can't read "argv": no such variable
    while executing
"lindex $argv 0"
    (in namespace eval "::request" script line 440784)
    invoked from within
"namespace eval ::request $script"
    ("::try" body line 12)
OUTPUT BUFFER:
package provide app-ordalie 1.0

proc 2GO {args} {

    #Load
    #LesTypesDeRequetes
    #LesRequetes
    #LesGO
    #$Requete WhatIsIt
    #$Requete LesLiens -> LesGO
    #$GO      LesLiens -> LesRequetes

    global TableauInterrogation2GO

    if {[string equal -nocase $args "Load"] && ![info exists TableauInterrogation2GO(EstCharge)]} {
	if {[info exists TableauInterrogation2GO]} {unset TableauInterrogation2GO}
	set TableauInterrogation2GO(EstCharge) 1
	Load2GO TableauInterrogation2GO
	return
    }

    if {[string equal -nocase $args "unset"]} {
	if {[info exists TableauInterrogation2GO]} {unset TableauInterrogation2GO}
	return
    }
    set Quoi [join $args ","]
    if {[info exists TableauInterrogation2GO($Quoi)]} {
	return [lsort -unique [set TableauInterrogation2GO($Quoi)]] 
    }
    ###################CHARGE Fichier2GO###################
    if {![info exists TableauInterrogation2GO(EstCharge)]} {
	set TableauInterrogation2GO(EstCharge) 1
	Load2GO TableauInterrogation2GO
    }
    if {![info exists TableauInterrogation2GO($Quoi)]} {return}
    return [lsort -unique [set TableauInterrogation2GO($Quoi)]] 

}

proc 2Pi {} {

    return [expr {2.*acos(-1.)}]

}

proc AADansPil {file} {


    global Sequences
    global LNOrdali
    global ListeDesPiliersDuGroupe


    DecortiqueUnMSF
    CreeLesPiliers

    set Nt [llength $LNOrdali]
    foreach seuil {60 65 70 75 80 85 90 95 100} {
	set NIndi($seuil) 0
    }

    foreach p [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)] {
	foreach seuil {60 65 70 75 80 85 90 95 100} {
	    set Nb [regsub -all {\.} $p "" tmp]
	    if {[expr ($Nt.-$Nb.)/$Nt*100] > $seuil} {incr NIndi($seuil)}
	}
    }



    return

}

proc AADuNomDuFichier {NomDuFichier {AvecAlias AvecAlias}} {

    global AAAlias

    if { ! [info exists AAAlias] } {
	set AAAlias(ly1) lys
	set AAAlias(ly2) lys
	set AAAlias(pha) phe
	set AAAlias(phb) phe
	set AAAlias(gla) gly
	set AAAlias(glb) gly
    }
    set AA3 [string range $NomDuFichier 0 2]
    if { $AvecAlias != "AvecAlias" && [info exists AAAlias($AA3)]} {
	return [set AAAlias($AA3)]
    } else {
	return $AA3
    }

}

proc AAFrequents2 {FichierCod} {

    if {![file exist $FichierCod]} {return}
    set Nom [file tail $FichierCod]
    append First "$Nom\t"
    set LesFreq [CreeListeCodonFrequency $FichierCod]
    set LesFreqTrie [lsort -index 2 -decreasing $LesFreq]
    set LesFirst [lrange $LesFreqTrie 0 2]
    foreach AA $LesFirst {
	set aa [lindex $AA 0]
	set Codon [lindex $AA 1]
	append First "$aa\($Codon\)\t"
    }
    return $First

}

proc AAFrequents2PourTous {} {

    foreach Nom [ListeDesPABs] {
	set FichierCod "[RepertoireDuGenome]/codonfrequency/tables_codonfrequency/$Nom.cod"
	set AA [AAFrequents2 $FichierCod]
	append Tous "$AA\n"
    }
    return $Tous

}

proc AALePlusDifferent {FichierCodMusRef FichierCodSeq} {

    set LesDifferences [CompareDeuxTablesCodonFrequency $FichierCodMusRef $FichierCodSeq]
    set LePlus [lrange $LesDifferences 0 0]
    return $LePlus

}

proc AALePlusFrequent {FichierCod} {

    set LesFreq [CreeListeCodonFrequency $FichierCod]
    set LesFreqTrie [lsort -index 2 -decreasing $LesFreq]
    set LesFirst [lrange $LesFreqTrie 0 0]
    foreach AA $LesFirst {
	set f [lindex $AA 2]
	set fa [format "%.2f" $f]
	set AA [lreplace $AA 2 2 $fa]
	lappend LesFirstArr $AA
    }
    return $LesFirstArr

}

proc AALesPlusDifferents2 {FichierCodMusRef FichierCodSeq} {

    set Nom [file tail $FichierCodSeq]
    set LesDifferences [CompareDeuxTablesCodonFrequency $FichierCodMusRef $FichierCodSeq]
    set LesPlus [lrange $LesDifferences 0 2]
    append Plus "$Nom\t"
    foreach PlusDifferent $LesPlus {
	set aa [lindex $PlusDifferent 1]
	set codon [lindex $PlusDifferent 2]
	append Plus "$aa\($codon\)\t"
    }
    return $Plus

}

proc AALesPlusDifferents2PourTous {} {

    set FichierCodMusRef "[RepertoireDuGenome]/codonfrequency/mus.cod"
    foreach Nom [ListeDesPABs] {
	set FichierCodSeq "[RepertoireDuGenome]/codonfrequency/tables_codonfrequency/$Nom.cod"
	set Plus [AALesPlusDifferents2 $FichierCodMusRef $FichierCodSeq]
	append Tous "$Plus\n"
    }
    return $Tous

}

proc AALesPlusDifferentsPourTous {} {

    set FichierCodMusRef "[RepertoireDuGenome]/codonfrequency/mus.cod"
    foreach Nom [ListeDesPABs] {
	set FichierCodSeq "[RepertoireDuGenome]/codonfrequency/tables_codonfrequency/$Nom.cod"
	set LePlus [AALePlusDifferent $FichierCodMusRef $FichierCodSeq]
	append Tous "$LePlus\n"
    }
    return $Tous

}

proc AARares {FichierCod} {

    if {![file exist $FichierCod]} {return}
    set Nom [file tail $FichierCod]
    append First "$Nom\t"
    set LesFreq [CreeListeCodonFrequency $FichierCod]
    set LesFreqTrie [lsort -index 2 -increasing $LesFreq]
    set LesFreqTrieSansEnd {}
    foreach Ligne $LesFreqTrie {
	set Type [lindex $Ligne 0]
	if {$Type=="End"} {
	    continue
	} else {
	    lappend LesFreqTrieSansEnd $Ligne
	}
    }
    set LesFirst [lrange $LesFreqTrieSansEnd 0 2]
    foreach AA $LesFirst {
	set aa [lindex $AA 0]
	set Codon [lindex $AA 1]
	append First "$aa\($Codon\)\t"
    }
    return $First

}

proc AARaresPourTous {} {

    foreach Nom [ListeDesPABs] {
	set FichierCod "[RepertoireDuGenome]/codonfrequency/tables_codonfrequency/$Nom.cod"
	set AA [AARares $FichierCod]
	append Tous "$AA\n"
    }
    return $Tous

}

proc AAStart {Nom} {

    global LesAAsStart
    if {[info exists LesAAsStart($Nom)]} { return LesAAsStart($Nom) }
    if {[info exists LesAAsStart("EstCharge")]} { return "" }
    set LesAAsStart("EstCharge") 1
    ChargeLesCodonsStart
    return [AAsStart $Nom]

}

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 AAduCodon {Codon {AA ""}} {

    global CodonToAminoAcid
    global FichierTranslate

    if {$Codon=="Reset" && [info exists CodonToAminoAcid]} {unset CodonToAminoAcid ; return ""}

    if {[string length $Codon] != 3 } { return "-" }

    if {[regexp -nocase {[^ATGC]} $Codon]} { return "X" }

    if { ! [info exists CodonToAminoAcid("EstCharge")]} {
	set CodonToAminoAcid("EstCharge") 1
	set ListeDesLignes [split [ContenuDuFichier $FichierTranslate] "\n"]
	set IndexPointPoint [lsearch -regexp $ListeDesLignes {\.\.}]
	if { $IndexPointPoint == -1 } { Warne "$FichierTranslate merde."; exit}
	set PartieCodage [lrange $ListeDesLignes [incr IndexPointPoint 2] end]
	foreach Ligne $PartieCodage {
	    set fin [expr [string first "\!" $Ligne]-1]
	    set Interet [string range $Ligne 0 $fin]
	    if {[info exists a]} { unset a }
	    if {[info exists b]} { unset b }
	    if {[info exists c]} { unset c }
	    if {[info exists d]} { unset d }
	    if {[info exists e]} { unset e }
	    if {[info exists f]} { unset f }
	    if {[info exists g]} { unset g }
	    if {[info exists h]} { unset h }
	    scan $Interet "%s %s %s %s %s %s %s %s %s %s" A AAA a b c d e f g h
	    if {[info exists a]} { set CodonToAminoAcid([string toupper $a]) $A}
	    if {[info exists b]} { set CodonToAminoAcid([string toupper $b]) $A}
	    if {[info exists c]} { set CodonToAminoAcid([string toupper $c]) $A}
	    if {[info exists d]} { set CodonToAminoAcid([string toupper $d]) $A}
	    if {[info exists e]} { set CodonToAminoAcid([string toupper $e]) $A}
	    if {[info exists f]} { set CodonToAminoAcid([string toupper $f]) $A}
	    if {[info exists g]} { set CodonToAminoAcid([string toupper $g]) $A}
	    if {[info exists h]} { set CodonToAminoAcid([string toupper $h]) $A}
	}
	
	if { ![CodonStopPossible "TGA"] } { set CodonToAminoAcid(TGA) "W" }
    }
    set CODON [string toupper $Codon]
    if {$AA!=""} { set CodonToAminoAcid($CODON) $AA }
    if { ! [info exists CodonToAminoAcid($CODON)]} { return "X" }
    return [set CodonToAminoAcid($CODON)]

}

proc ACTAYRfinder {} {


# Recherche un motif en générant un mismatch (adapté récepteurs nucléaires)

set FichierEntree [open "/genomics/link/STAF/fiches/Bidir/SequencesTotales.bidir" "r"] 
set FichierSortie [open "/genomics/link/STAF/fiches/Bidir/ACTAYRdansLesPromoteurs.bidir" "w"] 
Espionne "ACTAYR : Start"	
	set J 0
	set I 0
	while { [gets $FichierEntree Ligne]  >=0 } {
	incr J
	set Entete $Ligne
	gets $FichierEntree Ligne
	set Acc [lindex $SeqTFA(index) 0]
	set RegExp {ACTA[CT][AG]|[AG][GA]TAGT}
	set ListeDesPositions [regexp -indices -all -inline "$RegExp" $Ligne]
	
	foreach PaireDeBornes $ListeDesPositions {
		set NewStart [expr [lindex $PaireDeBornes 0] + 1]
		set NewEnd [expr [lindex $PaireDeBornes 1] + 1]
		puts $FichierSortie "$Entete $NewStart $NewEnd"
		incr I
	}
}
	Espionne "ACTAYR : End ($I ACTAYR trouves dans $J promoteurs)"
	close $FichierEntree
	close $FichierSortie

}

proc ACetDRdansTREMBL {} {

    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/narcisse"] {
	scan $Ligne "%s %s %s" Nom BanqueId Access
	set Narcisse([string toupper $Access]) $Nom
	set Narcisse($Nom) $Access
    }

    set F [open "/prot/trembl/sp_tr_nrdb/trembl.dat" "r"]

    while {[gets $F Ligne]>=0} {
	if {[regexp "^AC" $Ligne]} { set AC $Ligne }
	if {[regexp "^OS" $Ligne]} { set OS $Ligne }
	if {[regexp "^DR   EMBL" $Ligne]} {
	    set DR $Ligne
	    if { ! [regexp "Pyrococcus abyssi" $OS]} { continue }
	    scan $DR "%s %s %s %s" a b c Access
	    if { ! [regexp -nocase {Cab[0-9][0-9][0-9][0-9][0-9]} $Ligne Access]} { continue }
	    scan $AC "%s %s" Bidon AC
	    regsub {;} $AC "" AC
	    set Nom "???????????????"
	    set ACCESS [string toupper $Access]
	    if {[info exists Narcisse($ACCESS)]} { set Nom [set Narcisse($ACCESS)] }
	    lappend Sortie "$Nom $Access $AC"
	    Espionne "$Nom $Access $AC"
	}
    }
    SauveLesLignes $Sortie dans "$RepertoireDuGenome/fiches/narcisse-a-trois"


}

proc ALaMain {Quoi} {

    global ALaMain

    if {[info exists ALaMain($Quoi)]} { return $ALaMain($Quoi) }
    if {[info exists ALaMain("EstCharge")]} { return "" }
    set ALaMain("EstCharge") 1

    set ALaMain(gi_bsdc1_sp_q9nw68.1_) "Unknown unknown SP:q9nw68"
    set ALaMain(gi_26332042_dbj_bac29751.1_) "Unknown unknown dbj:bac29751"
    set ALaMain(gi_160703882_gb_eat79375.2_) "Unknown unknown gb:eat79375"
    set ALaMain(gi_157336387_emb_cao71072.1_) "Unknown unknown emb:cao71072"
    set ALaMain(gi_predict_edq55772.1_) "Unknown unknown edq55772"
    set ALaMain(gi_125525362_gb_eay73476.1_) "Unknown unknown gb_eay73476"
    set ALaMain(gi_116000504_emb_cal50184.1_) "Unknown unknown emb_cal50184"
    set ALaMain(gi_sap_dm_emb_caa56416.1_b) "Unknown unknown emb_caa56416"
    set ALaMain(gi_74191837_dbj_bae32869.1_) "Unknown unknown dbj_bae32869"
    set ALaMain(gi_30580527_sp_q9d5v6.1_syap1_) "Unknown unknown sp_q9d5v6.1_syap1"
    set ALaMain(gi_149035828_gb_edl90495.1_) "Unknown unknown gb_edl90495"
    set ALaMain(gi_14042052_dbj_bab55087.1_) "Unknown unknown dbj_bab55087"
    set ALaMain(gi_15779193_gb_aah14657.1_) "Unknown unknown gb_aah14657"
    set ALaMain(gi_62897271_dbj_bad96576.1_) "Unknown unknown dbj_bad96576"
    set ALaMain(gi_14189980_gb_aak55531.1_af30) "Unknown unknown gb_aak55531"
    set ALaMain(gi_47215840_emb_cag00695.1_) "Unknown unknown emb_cag00695"
    set ALaMain(gi_sap_danio_p_957236.1_) "Brachidanio rerio  p_957236"
    set ALaMain(gi_edp29796.1_bsd-bruggia) "Brugia  malayi edp29796"
    set ALaMain(gi_schistosoma_gb_aaw25233.1_) "schistosoma_ gb:aaw25233"
    set ALaMain(gi_bsd_oris_aba94285.2_) "oris_ aba94285"
    set ALaMain(gi_147818233_emb_can73547.1_) "Unknown unknown emb_can73547"
    set ALaMain(gi_162674980_gb_edq61481.1_) "Unknown unknown gb_edq61481"
    set ALaMain(gi_162683699_gb_edq70107.1_) "Unknown unknown gb_edq70107"
    set ALaMain(gi_29841361_gb_aap06393.1_) "Unknown unknown gb_aap06393"
    set ALaMain(gi_56753973_gb_aaw25179.1_) "Unknown unknown gb_aaw25179"
    set ALaMain(gi_114636465_ref_xp_001173050.) "Unknown unknown YYY:xp_001173050"
    set ALaMain(gi_predictprot_macala_xp_001085333.) "Unknown unknown YYY:xp_001085333"
    set ALaMain(gi_114052006_ref_np_001039615.) "Unknown unknown YYY:np_001039615"
    set ALaMain(gi_114636455_ref_xp_001173101.) "Unknown unknown YYY:xp_001173101"
    set ALaMain(gi_149719503_ref_xp_001505012.) "Unknown unknown YYY:xp_001505012"
    set ALaMain(gi_p62_hom_s_ref_np_005307.1) "Unknown unknown YYY:np_005307"
    set ALaMain(gi_126332087_ref_xp_001366557.) "Unknown unknown YYY:xp_001366557"
    set ALaMain(gi_57102734_ref_xp_534083.1) "Unknown unknown YYY:xp_534083"
    set ALaMain(gi_p62_mousemgb_aah52837.1) "Unknown unknown GB:aah52837"
    set ALaMain(gi_157816977_ref_np_001101955.) "Unknown unknown YYY:np_001101955"
    set ALaMain(gi_31982313_ref_np_032212.2) "Unknown unknown YYY:np_032212"
    set ALaMain(gi_p62_xenopustrop_np_001006921.1) "Unknown unknown YYY:np_001006921"
    set ALaMain(gi_118091234_ref_xp_421013.2) "Unknown unknown YYY:xp_421013"
    set ALaMain(gi_52219046_ref_np_001004596.1) "Unknown unknown YYY:np_001004596"
    set ALaMain(gi_125880724_ref_xp_001342123.) "Unknown unknown YYY:xp_001342123"
    set ALaMain(gi_p62putative_ref_xp_798784.1) "Unknown unknown YYY:xp_798784"
    set ALaMain(gi_p62_sc__010597.1) "Saccharomyces cerevisiae YYY:010597"
    set ALaMain(gi_45184782_ref_np_982500.1) "Unknown unknown YYY:np_982500"
    set ALaMain(gi_156837512_ref_xp_001642780.) "Unknown unknown YYY:xp_001642780"
    set ALaMain(gi_bsd_gallusgallusp_001012860) "Gallus gallus YYY:NP_001012860"
    set ALaMain(gi_pdb_syap1_humana_structure) "Unknown unknown PDB:1X3A_a"
    set ALaMain(gi_pdb_syap1_humanb_structure) "Unknown unknown PDB:1X3A_b"
    set ALaMain(gi_cryptosporidium_ref_xp_6660) "Unknown unknown YYY:xp_6660"
    set ALaMain(gi_cryptosporidium_xp_625548.1) "Unknown unknown YYY:xp_625548"
    set ALaMain(gi_58261118_ref_xp_567969.1) "Unknown unknown YYY:xp_567969"
    set ALaMain(gi_115692152_ref_xp_780429.2) "Unknown unknown YYY:xp_780429"
    set ALaMain(gi_158287538_ref_xp_309535.4) "Unknown unknown YYY:xp_309535"
    set ALaMain(gi_15233107_ref_np_191701.1) "Unknown unknown YYY:np_191701"
    set ALaMain(gi_149237456_ref_xp_001524605.) "Unknown unknown YYY:xp_001524605"
    set ALaMain(gi_159474828_ref_xp_001695527.) "Unknown unknown YYY:xp_001695527"

    set ALaMain(gi_predict_EDQ55772.1) "Unknown unknown YYY:EDQ55772"
    set ALaMain(gi_BSD_gallusgallusP_001012860.1) "Gallus gallus YYY:NP_001012860"
    set ALaMain(gi_PDB_syap1_HUMANa_structure_1X3A_A_1) "Homo sapiens PDB:1X3A"
    set ALaMain(gi_PDB_syap1_HUMANb_structure_1X3A_A_2) "Homo sapiens PDB:1X3A"
    set ALaMain(gi_SAP_danio_P_957236.1) "Brachydanio rerio YYY:NP_957236"
    set ALaMain(gi_EDP29796.1_bsd-bruggia) "Brugia malayi YYY:EDP29796"
    set ALaMain(gi_BSD_ORIS_ABA94285.2) "Oryza sativa SPT:ABA94285"
    set ALaMain(gi_bsdputat_Orizaesativ_BAD53348.1) "Oryza sativa SPT:BAD53348"
    return [ALaMain $Quoi]

}

proc ANGLES {aB aANGLE aU} {


    upvar $aB B
    upvar $aANGLE ANGLE
    upvar $aU U

    # A partir de la matrice de rotation, calcule les angles d'Euler,
    # l'angle de rotation et coord. spheriques de l'axe, et les cos.
    # directeurs de l'axe
    #
    set PI [Pi]
    #    set PI 3.1415926
    set PIS2 [expr {0.5 * $PI}]
    set DEGRAD [expr {$PI/180.}]
    set DETERM 0.

    set DETERM [S_deterM [M_T B]]

    if {$DETERM <= 0.99 || $DETERM > 1.01} {
	puts " =======> Determinant = $DETERM "
	return -1
    }

    # Angles d'Euler
    set TH2 [ARCTG [expr {sqrt(pow($B(1,3),2)+pow($B(2,3),2))}] $B(3,3)]
    set ZETA [expr {1.-cos($TH2)}]

    if {$ZETA > 0.001 && $ZETA < 1.9999} {
	set TH1 [ARCTG $B(3,1) [expr {-$B(3,2)}]]
	set TH3 [ARCTG $B(1,3) $B(2,3)]
    } else {
	# Valeur arbitraire de TH3
	set TH3 0.
	if {$ZETA <= 0.001} {
	    set TH1 [ARCTG [expr {$B(1,2)-$B(2,1)}] [expr {$B(1,1)+$B(2,2)}]]
	} else {
	    set TH1 [ARCTG [expr {$B(1,2)+$B(2,1)}] [expr {$B(1,1)-$B(2,2)}]]
	}
    }

    set ALPHA    [expr {fmod(($TH1-$PIS2)/$DEGRAD+360.,360.)}]
    set BETA     [expr {$TH2/$DEGRAD}]
    set GAMMA    [expr {fmod(($TH3+$PIS2)/$DEGRAD,360.)}]
    set ANGLE(1) $ALPHA
    set ANGLE(2) $BETA
    set ANGLE(3) $GAMMA

    # ANGLE DE ROTATION ET COS. DIRECTEURS DE L'AXE
    set CKAPPA [expr {0.5*($B(1,1)+$B(2,2)+$B(3,3)-1.)}]
    set AKAPPA [ARCOS $CKAPPA]

    if {$CKAPPA > 0.9999} {
	# ROTATION NULLE. DIRECTION ARBITRAIRE
	set U(1) 0.
	set U(2) 0.
	set U(3) 1.
    } elseif {$CKAPPA < -0.999} {
	# ROTATION PROCHE DE 180
	foreach I {1 2 3} {
	    set ARG [expr {[set B($I,$I)]-$CKAPPA}]
	    if {$ARG < 0.} {
		if {$ARG < -0.01} {
		    puts "sqrt of zero "
		    return -1
		    #		    exit
		}
		set ARG 0.
	    }
	    set U($I) [expr {sqrt($ARG/(1.-$CKAPPA))}]
	}
	# DETERMINER LE SIGNE DU PLUS GRAND COS.DIR.

	set I 1
	foreach K {2 3} {
	    if {[set U($K)] > [set U($I)]} {set I $K}
	}
	set K [expr {($I%3)+1}]
	set L [expr {($K%3)+1}]

	set U($I) [SIGN [set U($I)] [expr {([set B($K,$L)]-[set B($L,$K)])}]]
	set U($K) [SIGN [set U($K)] [expr {[set U($I)]*([set B($K,$I)]+[set B($I,$K)])}]]
	set U($L) [SIGN [set U($L)] [expr {[set U($I)]*([set B($L,$I)]+[set B($I,$L)])}]]
    } else {
	# ROTATION GENERALE

	set DSK [expr {2.*sin($AKAPPA)}]
	foreach I {1 2 3} {
	    set K [expr {($I%3)+1}]
	    set L [expr {($K%3)+1}]
	    set U($I) [expr {([set B($K,$L)]-[set B($L,$K)])/$DSK}]
	}
    }

    set PSIZ [ARCOS $U(3)]
    set PHIZ [ARCTG $U(2) $U(1)]

    set ANGLE(4) [expr {$AKAPPA/$DEGRAD}]
    set ANGLE(5) [expr {$PSIZ/$DEGRAD}]
    set ANGLE(6) [expr {$PHIZ/$DEGRAD}]

    # Ramener a l'hemisphere nord
    if {$ANGLE(5) > 90.} {
	foreach i {1 2 3} {
	    set U($i) [expr {-[set U($i)]}]
	}
	set ANGLE(4) [expr {-$ANGLE(4)}]
	set ANGLE(5) [expr {180.-$ANGLE(5)}]
	set ANGLE(6) [expr {$ANGLE(6)+180.}]
    }

    set ANGLE(6) [expr {fmod(($ANGLE(6)+360.),360.)}]

    return

}

proc ARCOS {A} {


    set absa [expr {abs($A)}]
    if {$absa > 1.} {
	if {$absa > 1.00001} {
	    # pourrait mettre un puts pour dire ....
	}
	if {$absa > 1.01} {
	    puts " =====> ARCOS"
	    return
	    #	    exit
	}
	set A [SIGN 1. $A]
    }

    set LARCOS [expr {acos($A)}]

    return $LARCOS

}

proc ARCTG {B A} {


    set ARCTG 0.

    if {abs($A) >= 0.00001 || abs($B) >= 0.00001} {
	set ARCTG [expr {atan2($B,$A)}]
    }

    return $ARCTG

}

proc ARPAnno {{LesFichiersTFA ""} {LesFamilles ""} {Verbose 0}} {


    Wup "Programme de d annotation des sous Familles D ARPs"
    Wup "ARPAnno: ARP Annotation Server"
    Wup "v 1.0"
    Wup "      Based on BLAST,"
    Wup "      clustalw,"
    Wup "      aln_pos aln_res aln_insert,"
    Wup "      Domaines.txt Residus.txt"
    Wup "Jean Muller IGBMC/LBMAGM"

    #Repertoire contenant les banques Blast, Macs et Domaines et Residus de reference
    set RepARP          "[RepARPAnno]"
    set RepTFA          "$RepARP/ARP_TFA"
    set RepBanque       "$RepARP/ARP_BLAST"
    set RepMACS         "$RepARP/ARP_MACS"
    set RepSignature    "$RepARP/ARP_Signature"

    #Repertoire contenant les resultats
    set RepARP_Results  "[RepARPAnnoWeb]"
    set RepTFAResults   "$RepARP_Results"
    set RepBlastResults "$RepARP_Results"
    set RepMACSResults  "$RepARP_Results"
 
    #Passage au mode Verbose
    if {   $Verbose != "0"} {
	set Verbose 1
    }
    Verbose_Mode $Verbose
    
    if {$LesFichiersTFA==""} {
	set LesFichiersTFA [glob -nocomplain -directory "${RepTFA}_lesarps"    "*.tfa"]
	set LesFichiersTFA [glob -nocomplain -directory "${RepTFA}_validation" "*.tfa"]
    }
    set LesFichiersASupprimer ""
    set LesFichiersBLASTs     ""
    set NewMACS               ""

    #Les Familles de proteines (Actin Orphan ARP1-11)
    #################################################
    set LesVraisFamilles ""
    set LesVraisFamilles [LesFamillesDARPs]
    LesResultatsARPAnalyses "LesFamilles" $LesVraisFamilles "Positionne"

    foreach TFA $LesFichiersTFA {
	set AccessQuery "query_protein"
	set AccessDeRef "P02568"
	
	#1 Traitement du fichier d entree au format TFA
	###############################################
	#On recupere l access (premier mot apres le chevron ">")
	#On ajoute query_protein a la place qui sera utilise par clustalw
	#On reecrit le fichier TFA dans RepTFAResults
	set FileName   [file tail $TFA]
	set FichierTFA "$RepTFAResults/${FileName}"

	if {[regexp -nocase {^ARPAnno_[0-9]{4}_[0-9]{2}[0-9]{2}_} $FileName]} {
	    #On vient du web on garde pour VraiAccess le nom du fichier (utilise apres pour nom.msf)
	    set  VraiAccess [string tolower [FormateLeFichierTFA $TFA $FichierTFA 1]]
	    set  VraiAccess $FileName
	} else {
	    #set  VraiAccess [string tolower [FormateLeFichierTFA $TFA $FichierTFA 0]]
	    set  VraiAccess [string tolower [FormateLeFichierTFA $TFA $FichierTFA 1]]
	    if {$VraiAccess=="-1"} {Espionne "Pb FormateLeFichierTFA: $FichierTFA does not exists or is empty";return ""}
	    set  VraiAccess $FileName
	}
	set FichierLog "${FichierTFA}.log"
	AjouteAuARPLog "" $FichierLog
	LesResultatsARPAnalyses "VraiAccess" $VraiAccess "Positionne"

	set     Categorie [InterrogeLesInfosDesARPs [string toupper $VraiAccess] Categorie]
	if {   $Categorie == ""} {
	    set Categorie "Unknown"
	} else {
	    regsub -all {\-\-\-\-} $Categorie "" Categorie
	    regsub           "Les" $Categorie "" Categorie
	}
	if {[Verbose_Mode]} {
	    set    TextLog "><"
	    AjouteAuARPLog "$TextLog"
	    set    TextLog ">Access $VraiAccess -- $Categorie"
	    AjouteAuARPLog "$TextLog"
	}

	#2 Identificaction des meilleures familles d ARPs pour la query
	###############################################################
	if {$LesFamilles != ""} {
	    set MaxIDCutOffBlast "0.1"
	} else {		
	    set MaxIDCutOffBlast "0.25"
	}
	#2 On fait les Blasts contre toutes les banques blast des ARPs
	set LesFichiersBLASTs   [BlastQueryVsARPs $FichierTFA $LesFamilles]
	#2 1er Filtrage des sorties BLAST dont ne retient que les meilleurs P Identity
	set LesFamillesIdentity [IdentifieLeMeilleurBLAST $LesFichiersBLASTs $VraiAccess $FichierLog]
	#2 2eme Filtrage pour se separer des identite limites
	set LesFamillesRetenues ""
	set FPIdC               ""
	foreach FPIdC $LesFamillesIdentity {
	    set Famille ""
	    set PId     ""
	    set Cover   ""
	    foreach {Famille PId Cover} $FPIdC {
		if {$PId >= $MaxIDCutOffBlast} { 
		    LesResultatsARPAnalyses "$Famille,PId,$VraiAccess"   $PId   "Positionne"
		    LesResultatsARPAnalyses "$Famille,Cover,$VraiAccess" $Cover "Positionne"
		    lappend LesFamillesRetenues $Famille
		    if {$PId>="0.8" && $Cover>="0.8"} {
			if {[regexp -nocase "actin" $Famille]} {
			    set Texte "Your query protein is a conventional actin with [expr {$PId*100.0}]% identity shared among [expr ${Cover}*100.0]% of the sequence."
			    LesResultatsARPAnalyses "Result" $Texte "Positionne"
			    LesResultatsARPAnalyses "BestFamily" $Famille "Positionne"
			} elseif {[regexp -nocase "orphan" $Famille]} {
			    set Texte "Your query protein is a orphan with [expr {$PId*100.0}]% identity shared among [expr ${Cover}*100.0]% of the sequence."
			    LesResultatsARPAnalyses "Result" $Texte "Positionne"
			    LesResultatsARPAnalyses "BestFamily" $Famille "Positionne"
			}
		    }
		}
	    }     
	}
	if {[Verbose_Mode]} {
	    set    TextLog ">>>For $VraiAccess ($Categorie) selected family:$LesFamillesRetenues"
	    AjouteAuARPLog "$TextLog"
	}
	#On supprime les fichiers BLASTs de toutes les familles non retenues
	foreach FBlast $LesFichiersBLASTs {
	    #Q78DQ1.tfa_ARP6.blastp"
	    set Famille     ""
	    set Famille_tmp ""
	    set tmp         ""

	    set Famille     [file tail $FBlast]
	    regsub -nocase  {.blastp$} $Famille "" Famille
	    regexp -nocase  {_([a-z]{2,4}[0-9]{1,2}|actin|orphans)$} $Famille tmp Famille_tmp
	    if {$Famille_tmp != ""} {set Famille $Famille_tmp}
	    if {$Famille     != "" && [regexp -nocase $Famille $LesFamillesRetenues]} {continue}
	    lappend LesFichiersASupprimer $FBlast
	}
	
	if {$LesFamillesRetenues == ""} {
	    #Aucune famille n a ete retenue pour chercher si elle fait partie des ARPs
	    set Texte "No family could be selected. Your query may not be part of Actin superfamily."
	    LesResultatsARPAnalyses "Result" $Texte "Positionne"
	    continue
	} else {
	    #On a des resultats et on check si on a deja une famille (actin ou orphan)
	    if {[LesResultatsARPAnalyses "Result" "LaValeurMerci"] != ""} {
		continue
	    }
	}
	
	#3 Test de la sequence contre les alignements de references
	###########################################################
	set AccessDeRef_OLD ""
	foreach Famille $LesFamillesRetenues {
	    if {$AccessDeRef_OLD != "" && $AccessDeRef_OLD != $AccessDeRef } {
		set AccessDeRef $AccessDeRef_OLD
		set AccessDeRef_OLD ""
	    }
	    #On ne teste pas la famille des Actin
	    if {[regexp -nocase "actin" $Famille]} {continue}
	    
	    set MACSDeRef   "$RepMACS/${Famille}.rsf"
	    set NewMACS     "$RepMACSResults/${VraiAccess}_${Famille}.msf"
	    set Res         ""
	    set Dom         ""
	    set AligneOuPas "-1"
	    
	    if {[Verbose_Mode]} {
		set    TextLog ">< 2- Check $Famille family in progress (multiple alignment)><"
		AjouteAuARPLog "$TextLog"
	    }

	    #3-1 Alignement de la sequence contre les alignements de references
	    ###################################################################
	    set  AligneOuPas [AlignQueryVsMACS $FichierTFA $MACSDeRef $NewMACS]
	    if {$AligneOuPas=="-1"} {
		Espionne "Pb AlignQueryVsMACS"
		continue
	    } 
	    if {    [file exists $NewMACS]} {
		if {[file size   $NewMACS]=="0"} {
		    #Le fichier MACS est vide
		    Espionne "Pb AlignQueryVsMACS $NewMACS, empty file."
		    continue
		}
	    } else {
		#Le fichier MACS n existe pas
		Espionne "Pb AlignQueryVsMACS $NewMACS, no file exists."
		Espionne "$FichierTFA $MACSDeRef $NewMACS"
		continue
	    }
	    #lappend LesFichiersASupprimer $NewMACS

	    #3-2 Verification des Residus
	    #############################
	    #Choix des access de ref de familles differentes
	    if {$Famille == "ARP2"} {
		#PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
		#ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
		set AccessDeRef_OLD $AccessDeRef
		set AccessDeRef     "ARP05"
	    }
	    if {[Verbose_Mode]} {
		set    TextLog ">< 2-1 Specific Residues Filter ><"
		AjouteAuARPLog "$TextLog"
	    }
	    set Res [CheckARPSpecificResiduesForQuery query_protein $VraiAccess $AccessDeRef $NewMACS $Famille]
	    switch -exact -- $Res {
		"-2" {
		    #No residues yet determined
		    if {[Verbose_Mode]} {
			set    TextLog "No residues yet determined for $Famille"
			AjouteAuARPLog "$TextLog"
		    }
		}
		"-1" {
		    #Probleme d alignement
		    Espionne "Pb avec $NewMACS"
		}
		"1" {
		    #La sequence possede tous les groupes de residus de cette famille testee
		    #Espionne "$VraiAccess is an $Famille"
		}
		"2" {
		    #La sequence possede les groupes de residus de cette famille testee mais egalement des Gaps
		    #Espionne "$VraiAccess could have be an $Famille but there is too much GAP or missing sequences"
		}
		"0" {
		    #La sequence ne possede pas les groupes de residus de cette famille testee
		    #Espionne "$VraiAccess is not an $Famille"
		}
	    }

	    #3-3 Verification des Domaines
	    ##############################
	    if {$Famille == "ARP2"} {
		#ATTENTION ON REVIENT A LA NORMALE CAR C PAS BON POUR LES DOMAINES
		set AccessDeRef "$AccessDeRef_OLD"
	    }
	    if {[Verbose_Mode]} {
		set    TextLog ">< 2-1 Specific Insertions Filter ><"
		AjouteAuARPLog "$TextLog"
	    }
	    set Dom [CheckARPSpecificDomainsForQuery query_protein $VraiAccess $AccessDeRef $NewMACS $Famille]
	    switch -exact -- $Dom {
		"-2" {
		    #No insertions yet determined
		    if {[Verbose_Mode]} {
			set    TextLog "No specific insertions yet determined for $Famille"
			AjouteAuARPLog "$TextLog"
		    }
		}
		"-1" {
		    #Probleme d alignement
		    Espionne "Pb avec $NewMACS"
		}
		"1" {
		    #La sequence possede tous les groupes de domaines de cette famille testee
		    #Espionne "$VraiAccess is an $Famille"
		}
		"2" {
		    #La sequence possede les groupes de domaines de cette famille testee mais egalement des Gaps
		    #Espionne "$VraiAccess could have be an $Famille but there is too much GAP or missing sequences"
		}
		"0" {
		    #La sequence ne possede pas les groupes de domaines de cette famille testee
		    #Espionne "$VraiAccess is not an $Famille"
		}
	    }
	}

	#4 Choix de l ARP
	#################
	set Score_PId     ""
	set Score_Cover   ""
	set Score_Residue ""
	set Score_Domain  ""
	set NbGroupOk     ""
	set NbGroupTotal  ""
	set NbGroupGap    ""
	set NbDomainOk    ""
	set NbDomainTotal ""
	set NbDomainGap   ""

	if {[Verbose_Mode]} {
	    set    TextLog ">< 3- Final score calculation ><"
	    AjouteAuARPLog "$TextLog"
	}

	set Best_Score    "0.0"
	set Best_Family   ""
	foreach Famille $LesFamillesRetenues {
	    #On sort de toutes les familles il faut decider a quelle on appartient
	    #Score          est le score final d un parametre
	    #Impact_Score   est le poids d un parametre dans la decision finale
	    #Le score final est la somme des score individuels ponderes par leur impact score
	    #Si un score n est pas disponible sa part de score est redistribuee

	    set Score                "0.0"
	    set Score_PId            "" 
	    set Score_Cover          ""
	    set Score_Residue        ""
	    set Score_Domain         ""
	    set Impact_Score_PId     "0.2"
	    set Impact_Score_Cover   "0.1"
	    set Impact_Score_Residue "0.4"
	    set Impact_Score_Domain  "0.3"
	    set Impact_Score_Redis   "0.0"
	    set Nb_Redis             "0"
	    set ListeImpactScores    [list Impact_Score_PId Impact_Score_Cover Impact_Score_Residue Impact_Score_Domain]
	    set Nb_Score             [llength $ListeImpactScores]

	    set Score_PId     [LesResultatsARPAnalyses "$Famille,PId,$VraiAccess"   PId   "LaValeurMerci"]
	    set Score_Cover   [LesResultatsARPAnalyses "$Famille,Cover,$VraiAccess" Cover "LaValeurMerci"]
	    set NbGroupOk     [LesResultatsARPAnalyses "$Famille,NbGroupOk"               "LaValeurMerci"]
	    set NbGroupTotal  [LesResultatsARPAnalyses "$Famille,NbGroupTotal"            "LaValeurMerci"]
	    set NbGroupGap    [LesResultatsARPAnalyses "$Famille,NbGroupGap"              "LaValeurMerci"]
	    set NbDomainOk    [LesResultatsARPAnalyses "$Famille,NbDomainOk"              "LaValeurMerci"]
	    set NbDomainTotal [LesResultatsARPAnalyses "$Famille,NbDomainTotal"           "LaValeurMerci"]
	    set NbDomainGap   [LesResultatsARPAnalyses "$Famille,NbDomainGap"             "LaValeurMerci"]
	
	    #Dans le cas ou un des scores n est pas calcule.
	    #On ne retient pas son score et on redistribue son Impact_score
	    if {$NbGroupTotal  == "" || $NbGroupTotal  == "0"} {
		set Score_Residue        0
		set Impact_Score_Redis   [expr {$Impact_Score_Redis + 0.4}]
		set Impact_Score_Residue "0.0"
		incr Nb_Redis
	    } else {
		#Espionne "Res  $NbGroupOk -- $NbGroupTotal"
		#Espionne "[expr (($NbGroupOk*1.0) / $NbGroupTotal)]"
		set Score_Residue "[expr {($NbGroupOk*1.0)  / $NbGroupTotal}]"
	    }
	    if {$NbDomainTotal == "" || $NbDomainTotal == "0"} {
		set Score_Domain         0
		set Impact_Score_Redis   [expr {$Impact_Score_Redis + 0.3}] 
		set Impact_Score_Domain  "0.0"
		incr Nb_Redis
	    } else {
		#Espionne "Domain  $NbDomainOk -- $NbDomainTotal"
		#Espionne "[expr (($NbDomainOk*1.0) / $NbDomainTotal)]"
		#ATTENTION ON CONSIDERE QUE UNE SEULE SEQUENCE SUFFIE POUR DIRE SI UN GROUPE EST OK
		##if {$NbDomainOk != "0" && [expr $NbDomainOk + $NbDomainGap]>=[expr $NbDomainTotal]} {}
		if {[expr {$NbDomainOk + $NbDomainGap}]>=[expr $NbDomainTotal]} {
		    set NbDomainOk [expr {$NbDomainOk + $NbDomainGap}]
		}
		set Score_Domain  "[expr {($NbDomainOk*1.0) / $NbDomainTotal}]"
	    }
	    	    
	    #Si on doit redistribuer l impact score sur les autres
	    if {$Nb_Redis!="0"} {
		set Impact_Score_Redis [expr {($Impact_Score_Redis * 1.0) / ($Nb_Score - $Nb_Redis)}]
		foreach Score $ListeImpactScores {
		    if {[set $Score]=="0.0"} {
			continue
		    } else {
			set $Score [expr [set $Score] + $Impact_Score_Redis]
		    }
		}
	    }
	    #Espionne "[format "Impact Score: %5.1f %5.1f %5.1f %5.1f | %5.1f %2d" $Impact_Score_PId $Impact_Score_Cover $Impact_Score_Residue $Impact_Score_Domain $Impact_Score_Redis $Nb_Redis]"

	    #Calcul du score final
	    set Score_PId     [expr  {$Score_PId     * 100.0}]
	    set Score_Cover   [expr  {$Score_Cover   * 100.0}]
	    set Score_Residue [expr  {$Score_Residue * 100.0}]
	    set Score_Domain  [expr  {$Score_Domain  * 100.0}]

	    LesResultatsARPAnalyses "$Famille,Score_PId_ini"     $Score_PId     "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Cover_ini"   $Score_Cover   "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Residue_ini" $Score_Residue "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Domain_ini"  $Score_Domain  "Positionne"
	    #LesResultatsARPAnalyses "$Famille,Score_ini"         $Score         "Positionne"

	    set Score_PId     [expr {$Score_PId     * $Impact_Score_PId}]
	    set Score_Cover   [expr {$Score_Cover   * $Impact_Score_Cover}]
	    set Score_Residue [expr {$Score_Residue * $Impact_Score_Residue}]
	    set Score_Domain  [expr {$Score_Domain  * $Impact_Score_Domain}]
	    set Score         [expr {($Score_PId + $Score_Cover + $Score_Residue + $Score_Domain) * 1.0}]
	    set Score         [format "%5.1f" $Score]

	    if {[Verbose_Mode]} {
		set    TextLog "[format "%7s score: %5.1f %1s | %5.1f %5.1f %5.1f %5.1f" $Famille $Score % $Score_PId $Score_Cover $Score_Residue $Score_Domain]"
		AjouteAuARPLog "$TextLog"
	    }

	    set TabResultat($Famille,Score_PId)     $Score_PId
	    set TabResultat($Famille,Score_Cover)   $Score_Cover
	    set TabResultat($Famille,Score_Residue) $Score_Residue
	    set TabResultat($Famille,Score_Domain)  $Score_Domain
	    set TabResultat($Famille,Score)         $Score
	    
	    LesResultatsARPAnalyses "$Famille,Score_PId"     $Score_PId     "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Cover"   $Score_Cover   "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Residue" $Score_Residue "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score_Domain"  $Score_Domain  "Positionne"
	    LesResultatsARPAnalyses "$Famille,Score"         $Score         "Positionne"
	    
	    if {[expr $Best_Score < $Score]} {
		set Best_Score  $Score
		set Best_Family $Famille
	    } 
	}
	set Texte "The best family chosen for your query is $Best_Family with score = $Best_Score."
	LesResultatsARPAnalyses "Result"     $Texte       "Positionne"
	LesResultatsARPAnalyses "BestScore"  $Best_Score  "Positionne"
	LesResultatsARPAnalyses "BestFamily" $Best_Family "Positionne"

	foreach F $LesVraisFamilles {
	    if {! [info exists TabResultat($F,Score)]} {
		LesResultatsARPAnalyses "$F,Score_PId"     "No" "Positionne"
		LesResultatsARPAnalyses "$F,Score_Cover"   "No" "Positionne"
		LesResultatsARPAnalyses "$F,Score_Residue" "No" "Positionne"
		LesResultatsARPAnalyses "$F,Score_Domain"  "No" "Positionne"
		LesResultatsARPAnalyses "$F,Score"         "No" "Positionne"
	    }
	}
	if {[info exists TabResultat]} {array unset TabResultat "*"}
    }

    #5 Fin du programme on vide la memoire (fait dans ARPAnno.tcl) et on supprime les fichiers
    ##########################################################################################
    set        LesFichiersASupprimer ""
    foreach F $LesFichiersASupprimer {
	if {[file exists $F]} {file delete -force $F}
    }
    #LesResultatsARPAnalyses UnsetAll
    #DechargeLesResidusDesARPs
    #DechargeLesDomainesDesARPs

    return ""    

}

proc ARPAnno_Result_HTML {} {


    Wup "Permet de presenter les resultats sous une forme plus jolie"
    Wup "Affichage sous la forme d un tableau au format HTML"

    #On recupere le resultat final
    #si c une actin on le dit et c tout
    #si c une orphan on ajoute le lien vers le blastp contre les banques dediees
    set BestFam  [LesResultatsARPAnalyses "BestFamily" "LaValeurMerci"]
    set Resultat [LesResultatsARPAnalyses "Result" "LaValeurMerci"]
    if {[regexp -nocase "actin" $BestFam]} {
	return "[join $Resultat "\n"]"
    } elseif {[regexp  -nocase "orphan" $BestFam]} {
	set VraiAccess   "[LesResultatsARPAnalyses "VraiAccess" "LaValeurMerci"]"
	set T            "Orphans"
	set FichierBlast "${VraiAccess}_${T}.blastp"
	if {[file exists "[RepARPAnnoWeb]/$FichierBlast"]} {
	    set Texte "The blast result is available here"
	}
	lappend Resultat $Texte
	return "[join $Resultat "\n"]"
    }

    set     TexteResultat ""
    lappend TexteResultat "
"
    lappend TexteResultat ""
    lappend TexteResultat ""
    foreach F [list Family Score GID pCover pDR pDI] {
	lappend TexteResultat ""
    }
    lappend     TexteResultat ""

    set VraiAccess "[LesResultatsARPAnalyses "VraiAccess" "LaValeurMerci"]"

    set LesVraisFamilles  [LesResultatsARPAnalyses "LesFamilles" "LaValeurMerci"]
    foreach Famille $LesVraisFamilles {
	lappend TexteResultat ""

	set Score_PId     [LesResultatsARPAnalyses "$Famille,Score_PId"         "LaValeurMerci"]
	set Score_Cover   [LesResultatsARPAnalyses "$Famille,Score_Cover"       "LaValeurMerci"]
	set Score_Residue [LesResultatsARPAnalyses "$Famille,Score_Residue"     "LaValeurMerci"]
	set Score_Domain  [LesResultatsARPAnalyses "$Famille,Score_Domain"      "LaValeurMerci"]
	set Score         [LesResultatsARPAnalyses "$Famille,Score"             "LaValeurMerci"]
	set Score_PId     [LesResultatsARPAnalyses "$Famille,Score_PId_ini"     "LaValeurMerci"]
	set Score_Cover   [LesResultatsARPAnalyses "$Famille,Score_Cover_ini"   "LaValeurMerci"]
	set Score_Residue [LesResultatsARPAnalyses "$Famille,Score_Residue_ini" "LaValeurMerci"]
	set Score_Domain  [LesResultatsARPAnalyses "$Famille,Score_Domain_ini"  "LaValeurMerci"]


	foreach V [list Score_PId Score_Cover Score_Residue Score_Domain Score] {
	    if {      [set $V] == "No"} {
		continue
	    } elseif {[set $V] == ""} {
		set   [set  V]    "No"
	    } else {
		set   [set  V]    [format "%5.1f" [set $V]]
	    }
	}

	if {$Famille==[LesResultatsARPAnalyses "BestFamily" "LaValeurMerci"]} {
	    set GoodColor "orange"
	} else {
	    set GoodColor "gainsboro"
	}
	set i 0
	foreach R [list $Famille $Score $Score_PId $Score_Cover $Score_Residue $Score_Domain] {
	    incr i
	    set Color $GoodColor
	    if {$i=="1"} {
		#set FichierMSF   "${VraiAccess}_${R}.xml"
		set FichierMSF   "${VraiAccess}_${R}.msf"
		set FichierMSF   "${VraiAccess}_${R}.html"
		set FichierBlast "${VraiAccess}_${R}.blastp"
		if {[file exists "[RepARPAnnoWeb]/$FichierMSF"]} {
		    set R "$R"
		} elseif {[file exists "[RepARPAnnoWeb]/$FichierBlast"]} {
		    set R "$R"
		}
	    }
	    if {$i=="2"} {
		if {   $Color != "orange"} {
		    set Color    "skyblue"
		}
		set R "$R"
	    }
	    lappend TexteResultat ""
	}
	lappend TexteResultat ""
    }
    lappend TexteResultat "
$F
$R
"

    if {$Resultat != ""} {
	lappend TexteResultat "
"
	lappend TexteResultat "$Resultat"
    }

    return "[join $TexteResultat "\n"]"

}

proc ARPAnno_Result_Text {} {


    Wup "Permet de presenter les resultats sous une forme plus jolie"
    Wup "Affichage sous la forme d un tableau separe par des tabulations"

    #On recupere le resultat final
    #si c est une actin ou une orphan on le dit et c est tout
    set          Resultat [LesResultatsARPAnalyses "Result" "LaValeurMerci"]
    if {[regexp "actin|orphan" $Resultat]} {
	return "$Resultat"
    }
    
    set     TexteResultat ""
    set LesNoms [list Family Score GID pCover pDR pDI]
    set LesNoms [join $LesNoms "\t"]
    lappend TexteResultat "$LesNoms"

    set LesVraisFamilles  [LesResultatsARPAnalyses "LesFamilles"            "LaValeurMerci"]
    foreach Famille $LesVraisFamilles {
	set Score_PId     [LesResultatsARPAnalyses "$Famille,Score_PId"     "LaValeurMerci"]
	set Score_Cover   [LesResultatsARPAnalyses "$Famille,Score_Cover"   "LaValeurMerci"]
	set Score_Residue [LesResultatsARPAnalyses "$Famille,Score_Residue" "LaValeurMerci"]
	set Score_Domain  [LesResultatsARPAnalyses "$Famille,Score_Domain"  "LaValeurMerci"]
	set Score         [LesResultatsARPAnalyses "$Famille,Score"         "LaValeurMerci"]

	foreach V [list Score_PId Score_Cover Score_Residue Score_Domain Score] {
	    if {      [set $V] == "No"} {
		continue
	    } elseif {[set $V] == ""} {
		set   [set  V]    "No"
	    } else {
		set   [set  V]    [format "%5.1f" [set $V]]
	    }
	}

	set Resultat [list $Famille $Score $Score_PId $Score_Cover $Score_Residue $Score_Domain]
	lappend TexteResultat "[join $Resultat "\t"]"
    }

    set     Liste ""
    lappend Liste "Access"
    foreach F $LesVraisFamilles {
	lappend Liste $F
    }
    lappend TexteResultat "[join $Liste "\t"]"

    set VraiAccess       [LesResultatsARPAnalyses "VraiAccess" "LaValeurMerci"]
    set     Liste ""
    lappend Liste $VraiAccess
    foreach F $LesVraisFamilles {
	set        Score [LesResultatsARPAnalyses "$F,Score"   "LaValeurMerci"]
	if {      $Score == ""} {
	    set    Score    "No"
	} elseif {$Score != "No"} {
	    set    Score [format "%5.1f" $Score]
	}
	lappend Liste $Score
    }
    lappend TexteResultat "[join $Liste "\t"]"

    return "[join $TexteResultat "\n"]"
    
    
    #Obsolete au cas ou on veuille afficher les nombre de residus sur Max residus et pareil pour insertions
    #3-2 Affiche les resultats
    ##########################
    #protein|q9gzn1|arp6_human is an ARP6
    #         PId    NbGroupOk  NbGroupTotal   
    #       : 1.00   2          2              
    #Group  : 1    2    
    #Result : 1/1  3/3  
    set PId          ""
    set Cover        ""
    set NbGroupOk    ""
    set NbGroupTotal ""
    if {0 && $Res != "-1"} {
	#On recupere les donnees stockees en memoire
	set PId          [LesResultatsARPAnalyses "$Famille,PId,$VraiAccess"   PId   "LaValeurMerci"]
	set Cover        [LesResultatsARPAnalyses "$Famille,Cover,$VraiAccess" Cover "LaValeurMerci"]
	set NbGroupOk    [LesResultatsARPAnalyses "$Famille,NbGroupOk"               "LaValeurMerci"]
	set NbGroupTotal [LesResultatsARPAnalyses "$Famille,NbGroupTotal"            "LaValeurMerci"]
	
	set Ligne   [format "%-7s  %-6s %-10s %-15s" ""  PId  NbGroupOk  NbGroupTotal]
	Espionne    "$Ligne"
	set Ligne   [format "%-7s: %-6s %-10s %-15s" "" $PId $NbGroupOk $NbGroupTotal]
	Espionne    "$Ligne"
	set Ligne1  [format "%-7s: " Group]
	set Ligne2  [format "%-7s: " Result]
	
	set NbGroup [LesResultatsARPAnalyses $Famille,NbGroupTotal "LaValeurMerci"]
	for {set Gr 1} {$Gr<=$NbGroup} {incr Gr} {
	    append Ligne1 [format "%-5s" $Gr]
	    set NbResiduOk    [LesResultatsARPAnalyses $Famille,$Gr,NbResiduOk    "LaValeurMerci"]
	    set NbResiduTotal [LesResultatsARPAnalyses $Famille,$Gr,NbResiduTotal "LaValeurMerci"]
	    append Ligne2 [format "%-5s" "$NbResiduOk/$NbResiduTotal"]
	}
	Espionne "$Ligne1"
	Espionne "$Ligne2"
	Espionne ""
    }
    
    #3-3 Affiche les resultats
    ##########################
    #protein|q9gzn1|arp6_human is an ARP6
    #         PId    NbGroupOk  NbGroupTotal   
    #       : 1.00   2          2              
    #Group  : 1    2    
    #Result : 1/1  3/3  
    #On recupere les donnees stockees en memoire
    set NbDomainOk    ""
    set NbDomainTotal ""
    if {0 && $Dom != "-1"} {
	set NbDomainOk    [LesResultatsARPAnalyses "$Famille,NbDomainOk"    "LaValeurMerci"]
	set NbDomainTotal [LesResultatsARPAnalyses "$Famille,NbDomainTotal" "LaValeurMerci"]
	
	set Ligne  [format "%-7s  %-11s %-15s" ""  NbDomainOk  NbDomainTotal]
	Espionne   "$Ligne"
	set Ligne  [format "%-7s  %-10s %-15s" "" $NbDomainOk $NbDomainTotal]
	Espionne   "$Ligne"
	
	set Ligne1 [format "%-7s: " Domain]
	set Ligne2 [format "%-7s: " Result]
	
	#set NbDomainTotal  [LesResultatsARPAnalyses $Famille,NbDomainTotal  "LaValeurMerci"]
	for {set Do 1} {$Do<=$NbDomainTotal} {incr Do} {
	    append Ligne1  [format "%-5s" $Do]
	    set NbAccOk    [LesResultatsARPAnalyses "$Famille,$Do,NbAccOk"    "LaValeurMerci"]
	    set NbAccTeste [LesResultatsARPAnalyses "$Famille,$Do,NbAccTeste" "LaValeurMerci"]
	    append Ligne2  [format "%-5s" "$NbAccOk/$NbAccTeste"]
	}
	Espionne "$Ligne1"
	Espionne "$Ligne2"
	Espionne ""
    }

}

proc ARPAnno_Stat {} {

    
    Wup "Permet de recuperer un certain nombre de stat sur le fontionnement de ARPAnno"

    #24.7.237.137	ARPAnno_0624_2338_0486
    #24.7.237.137	ARPAnno_0624_2340_0723
    
    #set LogFile "/srs6/WebTempFiles/ARPAnno/ARPAnno.log"
    set LogFile "[RepARPAnnoWeb]/ARPAnno.log"

    set Tab(Date)     ""
    set Tab(LesDates) ""

    set F [open "$LogFile"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	
	set LigneSplitee [split $Ligne "\t"]
	
	set ID        [lindex $LigneSplitee 0]
	set ARPAnnoID [lindex $LigneSplitee 1]
    
	#Date 
	set Date ""
	regexp {^ARPAnno_([0-9][0-9])} $ARPAnnoID tmp Date

	if {[info exists Tab(Date,$Date)]} {
	    #Cas ou a deja vu cette date
	    if {[set Tab(Date)]==$Date || [set Tab(Date)]==""} {
		#ok pas de probleme on continue une serie de date en cours
	    } else {
		set i 0
		while {1} {
		    incr i
		    set Datetmp "${Date}_${i}"
		    if {[info exists Tab(Date,$Datetmp)]} {
			continue
		    } else {
			set Tab(Date) $Date
			
			set Date $Datetmp
			set     Tab(Date,$Date) 1
			lappend Tab(LesDates)   $Date
			break
		    }
		}
	    }
	} else {
	    set Tab(Date,$Date) 1
	    lappend Tab(LesDates) $Date
	    Espionne ">>>>>>>>>>$Date"
	    set Tab(Date) $Date
	}

	#Nombre de requete par date
	if {! [info exists TabDate($Date,request)]} {
	    set TabDate($Date,request) "0"
	}
	incr TabDate($Date,request)

	#Liste des utilisateurs par date
	if {! [info exists TabDate($Date,user)]} {
	    set TabDate($Date,user) ""
	}
	lappend TabDate($Date,user) $ID
    }
    close $F
    
    set ToSave ""
    foreach Date [set Tab(LesDates)] {
	set NbUser    [llength [lsort -unique [set TabDate($Date,user)]]]
	set NbRequest [set TabDate($Date,request)]

	Espionne "$Date $NbRequest $NbUser"

	lappend ToSave [join [list $Date $NbRequest $NbUser] "\t"]
    }

    AppendAuFichier "/home/jmuller/ARPAnno.stat" [join $ToSave "\n"]

    return 

}

proc ATGAenOverlap {} {


    set OneFour [Entre 4]

    set n 0
    set nATGA 0
    set nGTGA 0
    set nTTGA 0
    set nOver4A 0
    set nOver4G 0
    set nOver4T 0
    foreach Nom [ListeDesPABs] {
	incr n
	set FN "[RepertoireDuGenome]/nuctfa/$Nom"
	if { ! [file exists $FN]} { continue }
	set SeqNuc [QueLaSequenceDuFichierTFA $FN]
	set Quatre [string range $SeqNuc 0 5]
	if { ! [info exists Cumul($Quatre)]} { set Cumul($Quatre) 0 }
	incr Cumul($Quatre)
	if {[regexp -nocase "^ATGA" $SeqNuc] } {
	    incr nATGA
	    set Ov [Overlap $Nom]
	    if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
	    incr nOver4A
	}
	if {[regexp -nocase "^GTGA" $SeqNuc] } {
	    incr nGTGA
	    set Ov [Overlap $Nom]
	    if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
	    incr nOver4G
	}
	if {[regexp -nocase "^TTGA" $SeqNuc] } {
	    incr nTTGA
	    set Ov [Overlap $Nom]
	    if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
	    incr nOver4T
	}
    }
    foreach {Q C} [array get Cumul] {
	set U [string range $Q 0 2]
	set D [string range $Q 3 5]
	lappend LL [list $Q $C [AAduCodon $U][AAduCodon $D]]
    }
    EspionneL [lsort -index 1 -integer $LL]
    return "$n $nATGA $nOver4A $nGTGA $nOver4G $nTTGA $nOver4T [file tail [RepertoireDuGenome]]"

}

proc ATV {NomFichierOuUrlPhylo {EnExec ""}} {


    if {$EnExec==""} { set EnExec "EnHtml" }
    if {$EnExec=="EnExec"} { set EnExec 1 } else { set EnExec 0 }

    set Nom          $NomFichierOuUrlPhylo
    set FichierPhylo $NomFichierOuUrlPhylo
    if {[regexp "/" $FichierPhylo]} {
	set RepPhylo [file dirname $FichierPhylo]
    } else {
	if {[EstUnPAB $Nom]} {
	    while 1 {
		set RepPhylo "phylosOrg"
		set FichierPhylo "[RepertoireDuGenome]/$RepPhylo/$Nom"
		if {[file exists $FichierPhylo]} { break }
		set RepPhylo "phylos"
		set FichierPhylo "[RepertoireDuGenome]/$RepPhylo/$Nom"
		if {[file exists $FichierPhylo]} { break }
		return ""
	    }
	}
    }
    if {$EnExec} {
	if {$FichierPhylo!="" && ! [file exists $FichierPhylo]} { return "" }
	if {[catch {exec atv $FichierPhylo &} Message]} {
	    return 0
	}
	return 1
    }

    if {[EstUnPAB $Nom]} {
	set UrlPhylo "[WscopeScience]&FileMoi&$RepPhylo&$Nom"
    } else {
	set UrlPhylo $NomFichierOuUrlPhylo
    }


    Html_ZeroToBody
    Html_Append ""
    Html_Append " "
    Html_Append ""
    Html_BodyToEnd
    return [Html_Get]

}

proc A_Voir_LesBanquesDesEntetesDeFrag {FichierFrag {Rep ""}} {


    if {$Rep==""} { set Rep "SameDir" }
    if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" }

    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $FichierFrag] {
	regsub {\:} $Ligne " " Ligne
	scan $Ligne "%s" Banque
	lappend LesBanques $Banque
    }
    set LesBonnesBanques {}
    foreach Banque $LesBanques {
	set Banque [file tail $Banque]
	set BonneBanque "$Rep/$Banque"
	set Nhr "$BonneBanque.nhr"
	if { ! [file exists $Nhr]} { FaireLire "$Nhr n'existe pas" }
	if {[catch {set Name [exec name $Banque]} Message]} {
	    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
	    continue
	}
	if {[regexp "^@GenDBConfigFiles" $Name]} {
	    regsub "^@" $Name "" Name
	    set NameDir [lindex [split $Name ":"] 0]
	    set Ferme   [lindex [split $Name ":"] 1]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    set Farm "$Dir/$Ferme"
	    if { ! [file exists $Farm]} { FaireLire "$Farm doesn't exists" ; continue }
	    foreach B [LesBanquesDeLaFerme $Farm] {
		Espionne "B $B"
		if {[catch {set NameDeB [exec name $B]} Message]} {
		    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
		    continue
		}
		set NameDirDeB [lindex [split $NameDeB ":"] 0]
		if {[catch {set DirDeB [exec name $NameDirDeB]} Message]} {
		    FaireLire "Problem with 'exec name $NameDirDeB'\ I got message \n$Message"
		    continue
		}
		lappend LesBonnesBanques "$BonneBanque $DirDeB $NameDeB"
	    }
	} else {
	    set NameDir [lindex [split $Name ":"] 0]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    lappend LesBonnesBanques "$BonneBanque $Dir $Name"
	}
    }
    return $LesBonnesBanques

}

proc AberrationParPatient {LimInf LimSup {LesPos ""} {LesNoms ""}} {

    # -> Compter le nb d'aberrations par patient

    # liste des cas 
    #set LesCas {Oligo806 Oligo807 Oligo809 Oligo810 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo817 Oligo818 Oligo819 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825 Oligo826 Oligo827}
    #set LesCas {BAC806 BAC807 BAC809 BAC810 BAC811 BAC812 BAC814 BAC815 BAC816 BAC817 BAC818 BAC819 BAC820 BAC821 BAC822 BAC823 BAC825 BAC826 BAC827}
    set LesCas {BAC806 BAC807 BAC809 BAC810 BAC811 BAC812 BAC814 BAC815 BAC816 BAC817 BAC818 BAC819 BAC820 BAC821 BAC822 BAC823 BAC825 BAC826 BAC827 Oligo806 Oligo807 Oligo809 Oligo810 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo817 Oligo818 Oligo819 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825 Oligo826 Oligo827}
    
    Espionne [llength $LesCas]
    
    set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY}
    # pour comparaison BAC vs oligo: pas possible sur chro X et Y a cause du mismatch fait pour BAC mais pas pour Oligo...
    #set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22}


    ### pour chaque fichier CGH Segmente ###
    foreach NomFichier $LesCas {

	set NomFichierSeg "$NomFichier\.seg"
	set FichierSeg "[RepertoireDuGenome]/PRIMA_CGH_SEG/$NomFichierSeg"
	#Espionne $FichierSeg
	
	set LesAberrations ""
	#### Pour chaque chromosome ###
	foreach Chromosome $ListeChro {

	    #Espionne $Chromosome
	    set x [InterrogeFichierSEG $FichierSeg "unset"]
	    ChargeFichierSEG TabS $FichierSeg $Chromosome $LesPos
	    if {[info exists TabS($FichierSeg,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabS($FichierSeg,Chromosome,$Chromosome,LesPos)] {
		    foreach LInfo [set TabS($FichierSeg,Chromosome,$Chromosome,$Pos)] {
			set PosInf [lindex $LInfo 3]
			set PosSup [lindex $LInfo 4]
			set Val [lindex $LInfo 6]
			set Val [format "%.2f" [expr $Val*1.0]]
			if {($Val>0 && $Val>=$LimSup) || ($Val<0 && $Val<=$LimInf)} {
			    lappend LesAberrations "$NomFichier\t$Chromosome\t$PosInf\t$PosSup\t$Val"
			}
		    }
		}
	    }
	}
	#Espionne [llength $LesAberrations]
	lappend ListeTotale "$NomFichier\t[llength $LesAberrations]"
	SauveLesLignes $LesAberrations dans "[RepertoireDuGenome]/aberrations/$NomFichier$LimSup"
    }
    SauveLesLignes [lsort -decreasing -index 1 -integer $ListeTotale] dans "[RepertoireDuGenome]/aberrations/total$LimSup"
    return 

}

proc AbsRef2Seq {n pos} {

    #set s [set ::Sequences($n)]
    set s [set ::Sref($n)]
    set s [string range $s 0 $pos]
    set s [string map {"." ""} $s]
    set pseq [expr {[string length $s] - 1}]
    #set pseq [string length $s]

    return $pseq

}

proc Ac1Ac2vide {} {

    set total 0; set D 0; set M 0; set N 0; set O 0; set P 0
    set cas1 0; set cas1a 0; set cas1b 0; 
    set cas2 0; set cas3 0; set cas4 0
    foreach I [RetChip5 ListOf Index] {
	incr total

	set LesAcProt {}
	set TousLesGenresProt {}
	array unset LesGenresProt
	set onasourisprot 0

	set ListAcsParGn {}; set BigList {}
	set LesAcsDna {}
	set genenamefait 0
	set LesAcsDeLaLigne "" 

	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]

	if { ($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && (($Ac3!="" && ![regexp {\?} $Ac3]) || $Ac4!="")} {
	    Espionne ""
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    Espionne "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    set Ac3 [string trim $Ac3]
	    regsub -all " " $Ac3 "" Ac3
	    set Ac4 [string trim $Ac4]
	    regsub -all " " $Ac4 "" Ac4
	    
	    if {$Ac3!="" && $Ac4!=""} {
		incr M
		set Ac3Ac4 "$Ac3,$Ac4"
		set LesAcProt [split $Ac3Ac4 ","]
	    } elseif {$Ac3!="" && ![regexp {\?} $Ac3]} {
		incr N
		set LesAcProt [split $Ac3 ","]
	    } elseif {$Ac4!=""} {
		incr O
		set LesAcProt [split $Ac4 ","]
	    } 
	    set LesAcProt [ListeSansDoublon $LesAcProt]
	    Espionne $LesAcProt
	    
	    foreach AcProt $LesAcProt {
		set GenreProt [OrgDuProt $AcProt]
		Espionne "AcProt $AcProt GenreProt $GenreProt"
		if {$GenreProt==""} {
		    #peut mettre toutes les variables a vide 
		    Espionne "attention pas fiche"
		    set pasfiche 1
		}
		LConcat TousLesGenresProt $GenreProt
		set LesGenresProt($AcProt) $GenreProt
	    }
	    set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
	    
	    foreach ChaqueGenreProt $TousLesGenresProt {
		if {[regexp {^Mus} $ChaqueGenreProt]} {
		    set onasourisprot 1
		}
	    }
	    if {$onasourisprot} {
		Espionne "cas1"; incr cas1
		foreach AcProt $LesAcProt {
		    set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
		    if {[regexp {^Mus} $LesGenresProt($AcProt)]} {
			set ResultParProt [AttriDesAcDnaParProt $AcProt]
			Espionne "ResultParProt $ResultParProt"
			set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			Espionne "ResultParGb $ResultParGb"
			if {$ResultParProt != ""} {
			   Espionne "cas1a"; incr cas1a
			    set ListeDesAcs1 [split $ResultParProt " "]
			}
			if {$ResultParGb != ""} {
			   Espionne "cas1b"; incr cas1b
			    set ListeDesAcs2 [split $ResultParGb " "]
			}
			set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			foreach elmt $LesAcsDnaProv {
			    LConcat LesAcsDna $elmt
			}
		    }
		}
		set LesAcsDna [ListeSansDoublon $LesAcsDna]
	    }
	    if {!$onasourisprot} {
		Espionne "cas2"; incr cas2
		set genenamefait 1
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    if {!$genenamefait} {
		Espionne "cas3"; incr cas3
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3])  && $Ac4==""} {
	   Espionne ""
	    incr P
	   Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	   Espionne "cas4"; incr cas4
	    set genenamefait 1
	   Espionne "$Des1 $Des2"
	    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    if {$ListAcsParGn == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set ListAcsParGn [ListeSansDoublon $ListAcsParGn]
		set ListAcsParGn [ListeSsElmtVide $ListAcsParGn]
		set LesAcsDeLaLigne [join $ListAcsParGn " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}
    }
   Espionne "nombre de lignes= $total"
   Espionne "D $D";Espionne "M $M";Espionne "N $N";Espionne "O $O";Espionne "P $P"
   Espionne "cas1 $cas1";Espionne "cas1a $cas1a";Espionne "cas1b $cas1b" 
   Espionne "cas2 $cas2";Espionne "cas3 $cas3";Espionne "cas4 $cas4"

}

proc Ac1Plein {} {

    set total 0; set C 0; set W 0; set X 0
    set cas1 0; set cas1a 0; set cas1b 0; set cas1c 0 
    set cas2 0; set cas2a 0; set cas2b 0; set cas2c 0; set cas2d 0
    set cas3 0; set cas4 0; set cas5 0; set cas6 0
    foreach I [RetChip5 ListOf Index] {  
	incr total

	set LesAc {}
	set Genre ""
	set TousLesGenres {}
	array unset LesGenres
	set onasouris 0
	set LesAcsDna {}

	set LesAcProt {}
	set TousLesGenresProt {}
	array unset LesGenreAcProt
	set onasourisprot 0

	set genenamefait 0
	set ListAcsParGn {}; set BigList {}
	set LesAcsDeLaLigne ""

	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]

	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	   Espionne ""
	    set Ac1 [string trim $Ac1]
	    regsub -all " " $Ac1 "" Ac1
	    incr C
	    Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"

	    if {$Ac2==""} {
		incr W
		set LesAc [split $Ac1 ","]
	    }
	    if {$Ac2!=""} {
		set Ac2 [string trim $Ac2]
		regsub -all " " $Ac2 "" Ac2
		incr X
		set Ac1Ac2 "$Ac1,$Ac2"
		set LesAc [split $Ac1Ac2 ","]
	    }
	    set LesAc [ListeSansDoublon $LesAc]
	    set LesAc [ListeSsElmtVide $LesAc]
	    Espionne $LesAc

	    foreach Ac $LesAc {
		set Genre [OrgDuNmOuGb $Ac]
		Espionne "Ac $Ac Genre $Genre"
		if {$Genre == ""} {Espionne "attention pas fiches"}
		LConcat TousLesGenres $Genre
		set LesGenres($Ac) $Genre
	    }
	    set TousLesGenres [ListeSansDoublon $TousLesGenres]
	    foreach ChaqueGenre $TousLesGenres {
		if {[regexp {^Mus} $ChaqueGenre]} {
		    set onasouris 1
		}
	    }
	    if {$onasouris} {
		Espionne "cas1"; incr cas1
		foreach Ac $LesAc {
		    set LesNmRefSeq {}; set LesNvxNm {}
		    if {[regexp {^Mus} $LesGenres($Ac)]} {
			Espionne "Ac $Ac"
			if { ![regexp {^NM_} $Ac] && ![regexp {^XM_} $Ac] && ![regexp {^NR_} $Ac]} {
			    set NM [MrnaRefseqUcscMouse $Ac "Nm"]
			    Espionne "NM $NM"
			    if { $NM != "" } {
				Espionne "cas1a"; incr cas1a
				set LesNmRefSeq [split $NM " "]
				foreach NmRefSeq $LesNmRefSeq {
				    set GenreNmRefSeq [OrgDuNmOuGb $NmRefSeq]
				    Espionne "$NmRefSeq $GenreNmRefSeq"
				    if {[regexp {^Mus} $GenreNmRefSeq]} {
					LConcat LesNvxNm $NmRefSeq
				    } 
				}
				set LesNvxNm [ListeSansDoublon $LesNvxNm]
				set NMjoint [join $LesNvxNm " "]
				Espionne "NMjoint $NMjoint"
				LConcat LesAcsDna "$Ac $NMjoint"
			    } else { 
				Espionne "cas1b"; incr cas1b
				LConcat LesAcsDna $Ac
			    }
			} else { 
			    Espionne "cas1c"; incr cas1c
			    LConcat LesAcsDna $Ac
			}
		    }
		}
	    }
	    Espionne "cas2"
	    incr cas2
	    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
	    if {$Ac3!="" || $Ac4!=""} {
		Espionne "cas2a"; incr cas2a
		if {$Ac3!="" && $Ac4!=""} {
		    Espionne "cas2b"; incr cas2b
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		    set Ac3Ac4 "$Ac3,$Ac4"
		    set LesAcProt [split $Ac3Ac4 ","]
		} elseif {$Ac3!=""} {
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		   Espionne "cas2c"; incr cas2c
		    set LesAcProt [split $Ac3 ","]
		} elseif {$Ac4!=""} {
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		    Espionne "cas2d"; incr cas2d 
		    set LesAcProt [split $Ac4 ","]
		}
		set LesAcProt [ListeSansDoublon $LesAcProt]
		set LesAcProt [ListeSsElmtVide $LesAcProt]
		EspionneL $LesAcProt
		foreach AcProt $LesAcProt {
		    set GenreAcProt [OrgDuProt $AcProt]
		    Espionne "$AcProt $GenreAcProt"
		    if {$GenreAcProt==""} {Espionne "attention pas fiches" }
		    LConcat TousLesGenresProt $GenreAcProt
		    set LesGenreAcProt($AcProt) $GenreAcProt
		}
		set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
		foreach ChaqueGenreProt $TousLesGenresProt {
		    if {[regexp {^Mus} $ChaqueGenreProt]} {
			set onasourisprot 1
		    }
		}
		if {$onasourisprot} {
		    Espionne "cas3"; incr cas3
		    foreach AcProt $LesAcProt {
			set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
			if {[regexp {^Mus} $LesGenreAcProt($AcProt)]} {
			    set ResultParProt [AttriDesAcDnaParProt $AcProt]
			    Espionne "ResultParProt $ResultParProt"
			    set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			    Espionne "ResultParGb $ResultParGb"
			    if {$ResultParProt != ""} {
				set ListeDesAcs1 [split $ResultParProt " "]
			    }
			    if {$ResultParGb != ""} {
				set ListeDesAcs2 [split $ResultParGb " "]
			    }
			    set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			    foreach elmt $LesAcsDnaProv {
				LConcat LesAcsDna $elmt
			    }
			}
		    }
		}
		set LesAcsDna [ListeSansDoublon $LesAcsDna]
		Espionne "cas4"; incr cas4
		set genenamefait 1
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	   
	    if {!$genenamefait && $Ac3=="" && $Ac4==""} {
		Espionne "cas5"; incr cas5
		set genenamefait 1
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    if {!$genenamefait} {
		Espionne "cas6"; incr cas6
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	    Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}
    }
    Espionne "nb de lignes= $total"
    Espionne "C $C";Espionne "W $W";Espionne "X $X"
    Espionne "cas1 $cas1";Espionne "cas1a $cas1a";Espionne "cas1b $cas1b";Espionne "cas1c $cas1c" 
    Espionne "cas2 $cas2";Espionne "cas2a $cas2a";Espionne "cas2b $cas2b";Espionne "cas2c $cas2c";Espionne "cas2d $cas2d"
    Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6"

}

proc Ac1videAc2plein {} {

    set total 0; set B 0
    foreach I [RetChip5 ListOf Index] { 
	incr total
	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]
	set LesNMs {}

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    Espionne "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set LesNMs [split $Ac2 ","]
	    foreach NM $LesNMs { 
		set GetzOut ""
		#set Commande "getz \"\(\\\[refseqrelease-acc:$NM\\\]\|\\\[refseqnew-acc:$NM\\\]\)\!\(\\\[refseqnew-acc:$NM\\\]>\\\[refseqrelease-acc:$NM\\\]\)\" \-view FastaSeqs"
		set Commande "getz \"\\\[refseq-acc:$NM\\\]\" \-view FastaSeqs" 
		set GetzOut [eval exec $Commande]
		if {$GetzOut == ""} {Espionne ">bidon ficherefseqpiqor n'existe plus\natgc" }
		if {$GetzOut != ""} { 
		    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
		    if { [regexp {^>ref.+>ref} $GetzOut] } {
			Espionne "ATTENTION AU - 2 SEQ FASTA"
		    }
		   Espionne $GetzOut
		}
	    }
	    continue
	}
    }
   Espionne "total= $total"
   Espionne "B=$B"

}

proc AcDuId {ID {Fichier ""}} {

    global AcDuId

    if {$Fichier==""} { set Fichier "[Fiches]/IDAC.txt" }

    if {[info exists AcDuId($ID)]} { return $AcDuId($ID) }
    if {[info exists AcDuId("EstCharge")]} { return "" }
    set AcDuId("EstCharge") 1
    foreach {N I A B} [LesLignesDuFichier $Fichier] {
	scan $N "%s %s" Bidon Nom
	if {[regexp "_" $Nom]} { continue }
	scan $I "%s %s" Bidon Id
	scan $A "%s %s" Bidon Ac
	regsub {\;} $Ac "" Ac
	set AcDuId($Id) $Ac
    }
    return [AcDuId $ID]

}

proc AcDuIdProt {ID} {

    set Commande "getz \"\\\[protein-id:$ID\\\]\" \-f acc"
    set GetzOut [eval exec $Commande]
    if { $GetzOut == "" } { 
	set AccLu ""	
	return $AccLu
    }
    set AccLu ""
    set AccLu [StringSuivant "AC" dans $GetzOut]
    regsub -all "\t" $AccLu"" AccLu
    regsub -all " " $AccLu "" AccLu
    return $AccLu

}

proc AcGnDeDesAccess {{FichierOuLesAccess ""} {FichierSortie ""}} {

    if {[llength $FichierOuLesAccess]==1 && [file exists $FichierOuLesAccess]} {
	set LesAccess {}
	foreach Access [LesLignesDuFichier $FichierOuLesAccess] {
	    regsub -nocase {[^A-Z0-9\-_].*} $Access "" Access
	    lappend LesAccess $Access
	}
    } else {
	set LesAccess $FichierOuLesAccess
    }
#   if {$LesAccess==""} { set LesAccess {C9K029 D3DX37 D3DX38 P0C7P4 P47985 Q13546 Q6ZNS2 Q8NBI3 Q8TCM3 Q96LT6 Q9NX33} }
    set I 0
    while { $I < [llength $LesAccess]} {
	set LesA [lrange $LesAccess $I [expr [incr I 100] - 1]]
	foreach A $LesA G [GenenameDesAccess $LesA] D [DescriptionDesAccess $LesA] {
	    lappend LeR "$A;$G;$D"
	}
	Espionne "$I $A;$G;$D"
    }
    if {$FichierSortie!=""} { return [SauveLesLignes $LeR dans $FichierSortie] }
    return $LeR

}

proc AccProtEtBanqueProt {} {

    set RepertoireProtEmbl "/genomics/link/EVImm/protembl"
    foreach F [lsort [glob -nocomplain "$RepertoireProtEmbl/EVI*"]] {
	if {![regexp {EVI0932} $F]} {continue}
	set Texte1 ""; set Texte2 ""; set Bq ""
	set Queue [file tail $F]
	Espionne "$Queue"
	foreach Ligne [LesLignesDuFichier $F] {
	   Espionne "$Ligne"
	    if {[regexp {^LOCUS} $Ligne]} {break}
	    if {[regexp {^AC} $Ligne]} {
		scan $Ligne "%s %s" bidon AccProt
		regsub ";" $AccProt "" AccProt
		Espionne "$Queue $AccProt"
		set Commande1 "getz \"\\\[swissprot-acc:$AccProt\\\]\" \-vf id"
		set Texte1 [eval exec $Commande1]
		if {$Texte1!=""} {
		    Espionne "1"
		    set LesMots1 [split $Texte1 ":"]
		    set Bq [lindex $LesMots1 0]
		    set Tab($Queue) $Bq
		    Espionne "$Bq"
		}
		if {$Texte1==""} {
		    Espionne "2"
		    set Commande2 "getz \"\\\[sptrembl-acc:$AccProt\\\]\" \-vf id"
		    set Texte2 [eval exec $Commande2]
		    set LesMots2 [split $Texte2 ":"]
		    set Bq [lindex $LesMots2 0]
		    set Tab($Queue) $Bq
		    Espionne "$Bq"
		}
		break
	    }
	}
    }
    #SauveLesLignes [array get Tab] dans TabCorres
    #array set Tab [LesLignesDuFichier toto]

}

proc AcceptInfoSeq {w} {

    global Defauts TEdit {*}[info globals "TD*"]

    InfosDeLaSeq toto ""

    set nseq [set TEdit(corr,$nseqIn)]
    if {$nseq in $LNOrdali} {
	FaireLire "Warning !\nSequence Name already exists ! Sequence Name should be unique !"
	return
    }

    foreach e [lsort [array names TEdit "*,*"]] {
	lassign [split $e ,] k nseqIn
	if {$k eq "corr" || $k eq "compaa" || $k eq "compGrp" || $k eq "compAll"} {continue}

	set r [set TEdit($e)]
	switch $k {
	    "seqname" {set TDesSeqnames($nseq) $r}
	    "access" {set TDesAccess($nseq) $r}
	    "bid"    {set TDesBId($nseq) $r}
	    "desc"   {set TDesDescriptifs($nseq) $r}
	    "ec"     {
		if {! [EstUnEC $r]} {
		    FaireLire "Warning !\nThe E.C. number of sequence $nseq is badly formatted !\n It should be made of 4 positives numbers,\nseparated by a point character (.)."
		    return
		}
		set TDesEC($nseq) $r
	    }
	    "taxid"  {set TDesTaxId($nseq) $r}
	    "groupe" {set TDuGroupeDesSeqs($nseq) $r}
	    "orga"   {set TDesOrganismes($nseq) $r}
	    "frag"   {set TDesFragment($nseq) $r}
	    "lifed"  {set TDesPhylum($nseq) $r}
	}
    }

    destroy $w
    
    EnregistreInfosSeqs
    ChangeNomsAff $Defauts(NomsAffiches)
    AfficheNomsEtSeqs
    RepeintNomsEtSeqs

    return

}

proc AcceptNewValues {w type what} {

    global EFeat LNOrdali TabSF ListeTypesDeFeatures NomTextSeq Sequences
    
    set EFeat(COk) 0
    if {$what eq "dismiss"} {
	destroy [winfo toplevel $w]
	
	#ChangeFeatureForEditing 
	
	return
    }

    set nc "" ; set nn "" ; set ns ""
    set nx1 "" ; set nx2 ""
    # residue ranges
    if {$type eq "newf"} {
	# residue range corresponds to selection
	set Lt [$NomTextSeq tag ranges slct]
	if {$Lt == {}} {
	    FaireLire "Please do a selection first !"
	    
	    return
	}
	set Lpos $Lt
    } else {
	set nx1 "" ; set nx2 ""
	if {$EFeat(ZoneX1) != ""} {
	    if {! [string is integer $EFeat(ZoneX1)] || ! [string is integer $EFeat(ZoneX2)]} {
		FaireLire "Beware !\nRange should contain integer values"
		return
	    }
	    set nx1 $EFeat(ZoneX1)
	    set nx2 $EFeat(ZoneX2)
	}
	set Lpos $EFeat(LRanges)
    }
    
    # check color
    if {$EFeat(Color) != ""} {
	if {[CouleurPlusProcheDeTkCol $EFeat(Color)] == -1} {
	    FaireLire "Beware !\nThe color specified does not exist !"
	    return
	}
	set nc $EFeat(Color)
    }
    
    # check score
    if {$EFeat(Score) != ""} {
	if {! [string is double $EFeat(Score)] || ! [string is integer $EFeat(Score)]} {
	    FaireLire "Beware !\n Score should be a real number"
	    return
	}
	set ns $EFeat(Score)
    }
    
    # Note
    if {$EFeat(Note) != ""} {
	set nn [string trim $EFeat(Note)]
    }
    
    # current feature
    if {$type eq "newf"} {
	set ft $EFeat(Name)
	if {$ft eq ""} {
	    FaireLire "Beware !\nA feature should have a name !"
	    return
	}
	set ft [string map [list " " "_"] $ft]
	
	# update combo if necessary
	if {$ft ni $ListeTypesDeFeatures} {
	    lappend ListeTypesDeFeatures $ft
	    set ListeTypesDeFeatures [lsort -unique $ListeTypesDeFeatures]
	    set EFeat(FTypes) [linsert $ListeTypesDeFeatures 0 "None"]
	    $EFeat(FeatCombo) configure -values $EFeat(FTypes)
	    set EFeat(Feat) $ft
	}
    } else {
	set ft $EFeat(Feat)
    }

    foreach {p1 p2} $Lpos {
	lassign [split $p1 .] y x1
	lassign [split $p2 .] y x2
	incr x2 -1
	set nom [lindex $LNOrdali $y-1]
	
	if {$type eq "newf"} {
	    # New Featue
	    set nx1 $x1 ; set nx2 $x2
	    if {[string index [set Sequences($nom)] $nx1] eq "." || [string index [set Sequences($nom)] $nx2] eq "."} {set cs "global"} {set cs "local"}
	    lappend TabSF(${nom},$ft) [list fstart $nx1 fstop $nx2 fcolor $nc fscore $ns fnote $nn fcsys $cs]
	} else {
	    # New Item
	    set Lf [set TabSF(${nom},$ft)]
	    set i 0
	    foreach e $Lf {
		DecortiqueUneFeature $e d f c s n cs
		if {$d == $x1 && $f == $x2} {
		    if {$nx1 eq ""} {set nx1 $x1}
		    if {$nx2 eq ""} {set nx2 $x2}
		    if {$nc eq ""} {set nc $c}
		    if {$ns eq ""} {set ns $s}
		    if {$nn eq ""} {set nn $n}
		    if {$cs eq "local"} {
			if {[string index [set Sequences($nom)] $nx1] eq "." || [string index [set Sequences($nom)] $nx2] eq "."} {set cs "global"} {set cs "local"}
		    }
		    set new [list fstart $nx1 fstop $nx2 fcolor $nc fscore $ns fnote $nn fcsys $cs]
		    break
		}
		incr i
	    }
	    set Lf [lreplace $Lf $i $i $new]
	    set TabSF($nom,$ft) $Lf
	}
    }
    if {$type eq "edit"} {
	set EFeat(LItemSel) [list]
    } else {
    }
    set Efeat(COk) 1
    
    destroy [winfo toplevel $w]

    $NomTextSeq configure -state normal
    $NomTextSeq tag remove slct 1.0 end
    $NomTextSeq configure -state disabled
	
    ChangeFeatureForEditing 
    VueEditee 1

    return

}

proc AccepteEtSauveDefauts {w} {

    global env OrdEtcDir Couleurs Defauts CoulTmp TmpDef TmpMap

    # Mapping
    if {[info exists TmpMap]} {
	set Lmap [list]
	set Le [list]
	foreach e [array names TmpMap "*,fg"] {
	    lappend Le [lindex [split $e ,] 0]
	}
	foreach e [lsort $Le] {
	    lappend Lmap [list $e [set TmpMap($e,fg)] [set TmpMap($e,bg)]]
	}
	set TmpDef(Mapping) $Lmap
    }

    array set Defauts  [array get TmpDef]
    array set Couleurs [array get CoulTmp]
    unset -nocomplain TmpDef CoulTmp

    set f [file join $env(HOME) ".ordalierc"]
    if {! [catch {file copy -force -- [file join $OrdEtcDir .ordalierc] $f}]} {
	SauveOrdalieDefauts $f
    }

    destroy [winfo toplevel $w]

    font configure SeqFont -size [set Defauts(SeqFontSize)] -family [set Defauts(SeqFontFaml)] -weight [set Defauts(SeqFontWght)]
    SeqlabFont

    set Threshold [set Defauts(Threshold)]
   
    update idletasks

    return

}

proc Access2GO {Access} {

    if {[EstUnAccessPDB $Access]} {return}
    set AccessCourt    $Access
    regsub {\-[0-9]+$} $Access "" AccessCourt
    set TousLesGO {}
    foreach Requete   [Access2Requetes $AccessCourt] {
	if {[regexp -nocase "^go:" $Requete]} {
	    lappend TousLesGO [string toupper $Requete]
	    continue
	}
	foreach GO [2GO $Requete LesLiens] {
	    set Type [GODB GO $GO LesTypes] 
	    set Def [GODB Type $Type GO $GO LesDefinitions]
	    lappend TousLesGO [string toupper $GO]
	}
    }
    #Espionne "LesGODeRefDesGO [LesGODeRefDesGO $TousLesGO]"
    #Espionne "EnterrerLesAn [EnterrerLesAncetresGO [LesGODeRefDesGO $TousLesGO]]"
    #Espionne "result"
    return [ElimineLesRedondancesDansUneListe [EnterrerLesAncetresGO [LesGODeRefDesGO $TousLesGO]]]

}

proc Access2Kegg {Access} {

    return [PageInfo2Kegg [PageInfo $Access protein "id acc des dr"]]

}

proc Access2Requetes {Access} {

    if {[EstUnAccessPDB $Access]} {return}
    set AccessCourt    $Access
    regsub {\-[0-9]+$} $Access "" AccessCourt

    #nG set Page [PageInfo $AccessCourt protein "DES DR Key"]
    set Page [PageInfo $AccessCourt uniprot "DES DR Key"]
    #set Page [join [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNature"] "\n"]
    return [PageInfo2Requetes $Page]

}

proc AccessAlternatif {Access} {

    global AccessAlternatif
    global RepertoireDuGenome

    if {[info exists AccessAlternatif($Access)]} { return [set AccessAlternatif($Access)] }

    if {[info exists AccessAlternatif("EstCharge")]} {
	if {[regexp {[a-z]} $Access]} {
	    return [AccessAlternatif [string toupper $Access]]
	} else {
	    return ""
	}
    }

    set FichierAccessAlternatif "$RepertoireDuGenome/../accessalternatif"
    if { ! [file exists $FichierAccessAlternatif]} { return "" }

    foreach Ligne [LesLignesDuFichier $FichierAccessAlternatif] {
	scan $Ligne "%s %s" Ancien Nouveau
	set AccessAlternatif($Ancien) $Nouveau
	set AccessAlternatif([string toupper $Ancien]) $Nouveau
	set AccessAlternatif($Nouveau) $Ancien
	set AccessAlternatif([string toupper $Nouveau]) $Ancien
    }
    set AccessAlternatif("EstCharge") "EstCharge"
    return [AccessAlternatif $Access]

}

proc AccessCorrespondantAuxARPs {ARP} {


    Wup "Permet de recuperer les correspondances entre les sequences originelles et les boites gscope"

    global ARP2Acc

    if {[info exists ARP2Acc] && [info exists ARP2Acc($ARP)]} {
	return [set ARP2Acc($ARP)]
    } else {
	set ARP2Acc(ARP01) P42024
	set ARP2Acc(ARP02) P42025
	set ARP2Acc(ARP03) P38696
	set ARP2Acc(ARP04) P45889
	set ARP2Acc(ARP05) O15142
	set ARP2Acc(ARP06) P32381
	set ARP2Acc(ARP07) P45888
	set ARP2Acc(ARP08) P32391
	set ARP2Acc(ARP09) P47117
	set ARP2Acc(ARP10) P32392
	set ARP2Acc(ARP11) O96019
	set ARP2Acc(ARP12) O94805
	set ARP2Acc(ARP13) P80428
	set ARP2Acc(ARP14) Q9V814
	set ARP2Acc(ARP15) Q8N724
	set ARP2Acc(ARP16) P53946
	set ARP2Acc(ARP17) Q9VEC3
	set ARP2Acc(ARP18) Q9GZN1
	set ARP2Acc(ARP19) Q12509
	set ARP2Acc(ARP20) P45890
	set ARP2Acc(ARP21) Q12406
	set ARP2Acc(ARP22) Q9H981
	set ARP2Acc(ARP23) Q12386
	set ARP2Acc(ARP24) Q9VX09
	set ARP2Acc(ARP25) Q05123
	set ARP2Acc(ARP26) Q9UTQ7
	set ARP2Acc(ARP27) Q9NZ32
	set ARP2Acc(ARP28) Q04549
	set ARP2Acc(ARP29) Q9VWE8
	set ARP2Acc(ARP30) Q9BYD9
	set ARP2Acc(ARP31) Q9D9A6
	set ARP2Acc(ARP32) Q9D9J3
	set ARP2Acc(ARP33) Q9D9L5
	set ARP2Acc(ARP34) Q9H568
	set ARP2Acc(ARP35) Q9Y615
	set ARP2Acc(ARP36) Q9Y614
	set ARP2Acc(ARP37) Q9QY84
	set ARP2Acc(ARP38) Q9QY83
	set ARP2Acc(ARP39) Q20329
	set ARP2Acc(ARP40) Q9LZY1
	set ARP2Acc(ARP41) P02568
	set ARP2Acc(ARP42) Q8RYC2
	set ARP2Acc(ARP43) O96621
    }
    if {[info exists ARP2Acc] && [info exists ARP2Acc($ARP)]} {
	return  [set ARP2Acc($ARP)]
    }
    return ""

}

proc AccessDUneLigneBlast {Ligne {Nom ""}} {

    global RepertoireDuGenome

    Wup "Certains blast ont ! entre Access0 et Access1"
    regsub "!" $Ligne " " Ligne

    scan $Ligne "%s %s" Access0 Access1

    if {[regexp {^AFF[0-9]{5}$} $Access0]} {
	if {[file exists "$RepertoireDuGenome/../AffyHS/nucembl/$Access0"]} {
	    return "$RepertoireDuGenome/../AffyHS/nucembl/$Access0"
	}
    }
    if {[regexp "ClonV:" $Access0]} {
	set Vec [lindex [split $Access0 ":"] 1]
	if {[file exists "$RepertoireDuGenome/vecteurs/$Vec"]} {
	    return "$RepertoireDuGenome/vecteurs/$Vec"
	}
    }
    if {[regexp "PABY:" $Access0]} {
	set PAB [lindex [split $Access0 ":"] 1]
	if {[file exists "$RepertoireDuGenome/../casimir/protembl/$PAB"]} {
	    return "$RepertoireDuGenome/../casimir/protembl/$PAB"
	}
    }
    if {[regexp -nocase "PAE:" $Access0]} {
	set PAE [lindex [split $Access0 ":"] 1]
	if {[file exists "$RepertoireDuGenome/../Pyrobac/protembl/$PAE"]} {
	    return "$RepertoireDuGenome/../Pyrobac/protembl/$PAE"
	}
    }
    if {[regexp -nocase "PFUR:" $Access0]} {
	set PFUR [lindex [split $Access0 ":"] 1]
	if {[file exists "$RepertoireDuGenome/../Pfuriosus/protembl/$PFUR"]} {
	    return "$RepertoireDuGenome/../Pfuriok/protembl/$PFUR"
	}
    }
    if {[regexp "PFUR:" $Access0]} {
	set PFOK [lindex [split $Access0 ":"] 1]
	if {[file exists "$RepertoireDuGenome/../Pfuriok/protembl/$PFOK"]} {
	    return "$RepertoireDuGenome/../Pfuriok/protembl/$PFOK"
	}
    }

    if { ! [info exists Access1]} { return $Access0 }

    Wup "Les copains"
    if { $Nom != "" && $Access1 != "" && [file exists "$RepertoireDuGenome/copains/$Nom/$Access1"]} {
	return "$Access1"
    }
    if { $Access1 != "" && [FetchTest "protein:$Access1"]} {
	return "protein:$Access1"
    }
    if { $Access1 != "" && [FetchTest "$Access1"]} {
	return "$Access1"
    }
    return $Access0

}

proc AccessDeLaBoite {PAB {Quoi ""} {DefOuNon ""}} {


    Wup "Retourne l Access de la boite Prot mrna ou tfa originel ou boite"
    Wup "Attention que pour Homo sapiens"

    #Prot puis mrna puis nuctfa puis PAB
    set Access ""
    set OnATrouve 0
  
    if {$Quoi=="protein"} {set OnATrouve 1}

    if {! $OnATrouve || $Quoi=="protein" || [string equal -nocase $Access ""]} {
	set Access [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access]
    }
    if {! $OnATrouve || $Quoi=="mRNA" || [string equal -nocase $Access ""]} {
	set Access [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" mRNA Access]
	if {$Quoi=="mRNA"} {set OnATrouve 1}
    }
    if {! $OnATrouve && $Access == ""} {
	set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$PAB"
	if {[file exists $FichierNuctfa]} {
	    set Access [EnteteDuFichierTFA $FichierNuctfa "access"]
	}
    }
    if {$Access == "" } {set Access $PAB}
    if {$DefOuNon=="Definition"} {
	set Access [InterrogeBestProteinAndmRNAForeachOrga Access $Access Definition]
    }
    return "$Access" 

}

proc AccessDeMonOrganisme {Nom} {

    set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml"
    if {! [file exists $Fichier]} {return}
    ParseMACSIMS $Fichier macsims
    set Sequences $macsims(Noms)
    set MonOS [NotreOS]
    foreach Sequence $Sequences {
        set Organisme $macsims($Sequence,Organisme)
        if {[regexp "$MonOS" $Organisme]} {
            return $Sequence
        }
    }
    return ""

}

proc AccessDesPremieresProteines {} {


    set Access ""
    append Access "S55507\tPDIP protein disulfide-isomerase (EC 5.3.4.1) ER60 precursor - human\n"
    append Access "P06576\tATPB_HUMAN\n"
    append Access "XP_028869\tIDH1 isocitrate dehydrogenase 1 (NADP+), soluble\n"
    append Access "AAA52688\tHP haptoglobin precursor\n"
    append Access "NP_000282\tPGK1 phosphoglycerate kinase 1\n"
    append Access "NP_061819\tCMAS N-acetylneuraminic acid phosphate synthase; sialic acid synthase; sialic acid phosphate synthase\n"
    append Access "AAH03119\tATP5A1 Similar to ATP synthase, H+ transporting, mitochondrial F1 complex, alpha subunit, isoform1, cardiac muscle\n"
    append Access "NP_004030\tANXA2 annexin A2; annexin II; lipocortin II\n"
    append Access "NP_005909\tMDH2 malate dehydrogenase 2, NAD (mitochondrial)\n"
    append Access "NP_002809\tPSME2 proteasome (prosome, macropain) activator subunit 2 (PA28 beta); Proteasome activator subunit-2\n"
    append Access "1403294A\tMSMB gamma seminoprotein\n"
    append Access "1HTI_A \tTPI1 ChainA, Triosephosphate Isomerase (Tim) (E.C.5.3.1.1) complexed with 2-Phosphoglycolic Acid\n"
    append Access "NP_003177\tTAGLN transgelin; smooth muscle protein 22-alpha; 22kDA actin-binding protein; SM22-alpha\n"
    append Access "NP_006699\tGLO1 glyoxalase I; lactoyl glutathione lyase; lactoylglutathione lyase\n"
    append Access "NP_002558\tPBP prostatic binding protein; phosphatidylethanolamine binding protein\n"
    append Access "BAA21139\tKNP-I beta protein\n"
    append Access "NP_005070\tTPD52 tumor protein D52\n"
    append Access "NP_005498\tCFL1 cofilin 1 (non-muscle)\n"
    append Access "NP_003188\tTCEB1L transcription elongation factor B polypeptide 1-like; organ of Corti protein 2\n"
    append Access "NP_001961\tEIF5A eukaryotic translation initiation factor 5A; eIF5AI; eIF5A\n"
    append Access "1E3F_A\tTTR Chain A, Structure Of Human Transthyretin Complexed With BromoPhenols: A New Mode Of Binding\n"
    append Access "NP_001435\tFABP5 fatty acid binding protein 5 (psoriasis-associated); E-FABP\n"

    return $Access 

}

proc AccessDuBanqueId {BanqueId} {

    regsub {^[^:]+:} $BanqueId "" BanqueId

    set Fiche [PageInfo $BanqueId "" acc]
    scan $Fiche "%s %s" ACC Access
    if {![info exists Access]} {return}
    regsub "\;$" $Access "" Access
    return $Access

}

proc AccessDuContigDuFragment {AccessDuFragment} {

    regsub {_[0-9]+$} $AccessDuFragment "" AccessDuContig
    return $AccessDuContig

}

proc AccessDuGI {GI} {

    set GI [string trim $GI]
    regsub "GI:" $GI "" GI

    set Page  [PageInfo  $GI genbankfull acc]
    if {$Page == ""} {return}
    scan $Page "%s %s" ACCESSION Access
    return $Access

}

proc AccessDuMiRNA {Nom} {

    set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
    set LesLignes [LesLignesDuFichier $Fichier]
    set Entete [lindex $LesLignes 0]
    set LesMots [split $Entete " "] 
    set GN [lindex $LesMots 1]
    set DE [join [lrange $LesMots 2 end] " "]
    set Access [lindex $LesMots end]

    set BonDE [ExtractFromRefseq $Access AllMiRNA2907 [RepertoireDuGenome] GetDefinition]
    set GeneName $GN
    if { ! [regexp {\-V[0-9]+$} $GeneName] && [regexp {transcript variant ([0-9]+)} $BonDE Match V]} {
	append GeneName "-V$V"
    }
    append BonDE " from $Access"

    set BonneEntete ">$Nom $GeneName $BonDE"
    set LaSeq [lrange $LesLignes 1 end]
    SauveLesLignes [concat [list $BonneEntete] $LaSeq] dans "[RepertoireDuGenome]/nuctfaNew/$Nom"
    InformeSansDemander $Nom "ValiDE: $BonDE"
    InformeSansDemander $Nom "AccessRefseq: $Access"    
    return $BonneEntete

}

proc AccessDuMiRNAPourTous {} {

    foreach Nom [ListeDesPABs] {
	Espionne [AccessDuMiRNA $Nom] 
    }

}

proc AccessDuPlusProcheDansDisphy {Nom OrgaCherche} {

    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/disphy/$Nom"] {
	scan $Ligne "%s %d %s" Orga Distance Access
	if {$Orga == $OrgaCherche} { return $Access }
    }
    return ""

}

proc AccessDuTFADeLaProteine {PAB} {


    Wup "Rend le banque Id du TFA"

    if {! [file exists $PAB]} {return ""}

    set F [open "$PAB"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {  [string range $Ligne 0 0] != ">"}           {continue}
	regsub "^>" $Ligne "" Ligne
	set AccessLu ""
	set BanqueId ""
	set bidon    ""
	scan $Ligne "%s %s %s" bidon BanqueId AccessLu
    }
    if {  ($BanqueId==":" || $BanqueId=="Protein" || $BanqueId=="PROTEIN") && $AccessLu!=""} {set BanqueId $AccessLu} 
    return $BanqueId

}

proc AccessDuTFADumRNA {PAB} {


    Wup "Rend le banque Id du TFA"

    if {! [file exists $PAB]} {return ""}

    set F [open "$PAB"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {  [string range $Ligne 0 0] != ">"}           {continue}

	regsub "^>" $Ligne "" Ligne
	set AccessLu ""
	set BanqueId ""
	set bidon    ""
	scan $Ligne "%s %s %s" bidon BanqueId AccessLu
    }
    if {  ($BanqueId==":" || $BanqueId=="mRNA") && $AccessLu!=""} {set BanqueId $AccessLu} 
    return $BanqueId

}

proc AccessEvi {Nom} {

    set BAcc [ExtraitInfo $Nom "BAcc"]
    set Access ""
    ScanLaListe [split $BAcc ":"] Banque Access
    return $Access

}

proc AccessFromHeader {Nom} {

    set Fichier "[RepertoireDuGenome]/prottfa/$Nom"
    if {[FileAbsent $Fichier]} { return "" }
    set Header [EnteteDuFichierTFA $Fichier]
    set Access [StringApres " from " dans $Header]
    return $Access

}

proc AccessHNR {} {

    foreach Nom [ListeDesPABs] {
	set Entete [EnteteDuFichierTFA [GscopeFile $Nom nuctfa]]
	set Access [lindex [LesMotsDeLaLigne $Entete] 5]
	InformeSansDemander $Nom "AccessProt: $Access"
    }
    exit

}

proc AccessNuc2GO {AccessNuc} {

    set LesGO {}
    foreach AccessProt [LesIdDeLaBanqueRelieALAccess $AccessNuc de genbankfull dans protein] {
	foreach GO [Access2GO $AccessProt] {lappend LesGO $GO}
    }
    return [EnterrerLesAncetresGO [LesGODeRefDesGO $LesGO]]

}

proc AccessOlida {access} {

    array set LesSequences {index {}}

    if {0} {
    # Récup les variants protéiques
    set varsplic ""
    catch {set varsplic [exec getz -e "(\[libs={varsplic}-ID:${access}*\] | \[libs-AccNumber:${access}*\])"]}
    foreach entry [splitFastaOlida $varsplic] {
	puts $entry

	regexp -nocase {^>((\w+)-(\d+))\|(\w+)\s+(.*)} [lindex [split $entry "\n"] 0] regMatch index protAccess variant id de
#	puts $index
#	puts $protAccess
#	puts $variant
#	puts $id
#	puts $entry

	lappend LesSequences(index) $index
	set LesSequences($index,access) $index
	set LesSequences($index,banque) "varsplic"
	set LesSequences($index,definition) [string trim $de]
	set LesSequences($index,protein) ">$entry"
    }
    exit
    }
    
    # Récupère les protéines
    set protein ""
    catch {set protein [exec getz -e "(\[libs={refseqp protein}-ID:${access}*\] | \[libs-AccNumber:${access}*\])"]}
    foreach entry [splitEmblOlida $protein] {
	puts $entry

	if {[regexp -lineanchor {^ID} $entry]} {
	    # Entrée uniprot/embl
	    if {[regexp -line {^DR\s+EMBL;\s+(\w+).*;\s+(\w+)\.} $entry regMatch nucAccess nucType]} {
		puts $nucAccess
		puts $nucType
		set nucEntry [exec getz -e "(\[libs={genbank}-AccNumber:${nucAccess}*\])"]
		puts $nucEntry
	    }
	}
    }

    parray LesSequences



#    set getzOut [exec getz -e "(\[libs={genbankfull refseq refseqp protein varsplic pdb}-ID:${access}*\] | \[libs={genbankfull refseq refseqp protein varsplic}-AccNumber:${access}*\])"]

}

proc AccessRefseq {Nom} {

    return [ExtraitInfo $Nom "AccessRefseq"]

}

proc AccessToKeepOrNotToKeep {Access} {


    global MesAccessInterressants

    if {! [info exists MesAccessInterressants]} {MesAccessInterressants}
    
    if {[info exists MesAccessInterressants($Access)]} {return 0} else {return 1}

}

proc AceSubset {aAce contigIdx} {

  upvar $aAce ace

  set subset(contigIdx) $contigIdx
  set subset(alignmentName) $ace(alignmentName)
  set subset(name) $ace($contigIdx,name)
  set subset(length) $ace($contigIdx,length)
  set subset(reads) $ace($contigIdx,reads)
  set subset(segments) $ace($contigIdx,segments)
  set subset(strand) $ace($contigIdx,strand)
  set subset(consensus) $ace($contigIdx,consensus)
  set subset(basesQuality) $ace($contigIdx,basesQuality)
  set subset(index) $ace($contigIdx,index)
  set subset(lowestRelativeConsensusPosition) $ace($contigIdx,lowestRelativeConsensusPosition)

  foreach readIdx $ace($contigIdx,index) {
    set subset($readIdx,name) $ace($contigIdx,$readIdx,name)
    set subset($readIdx,strand) $ace($contigIdx,$readIdx,strand)
    set subset($readIdx,consensusPosition) $ace($contigIdx,$readIdx,consensusPosition)
    set subset($readIdx,length) $ace($contigIdx,$readIdx,length)
    set subset($readIdx,numWholeReads) $ace($contigIdx,$readIdx,numWholeReads)
    set subset($readIdx,numTagReads) $ace($contigIdx,$readIdx,numTagReads)
    set subset($readIdx,sequence) $ace($contigIdx,$readIdx,sequence)
    set subset($readIdx,qualityStart) $ace($contigIdx,$readIdx,qualityStart)
    set subset($readIdx,qualityEnd) $ace($contigIdx,$readIdx,qualityEnd)
    set subset($readIdx,alignmentStart) $ace($contigIdx,$readIdx,alignmentStart)
    set subset($readIdx,alignmentEnd) $ace($contigIdx,$readIdx,alignmentEnd)
  }

  return [array get subset]

}

proc AceToMacSim {inputFile {outputDir XmlContigs}} {

  set prefix [PreFixe]
  set numerotation [FormatDesNumerosPourCollection]

  if { ! [file isdirectory [RepertoireDuGenome]/$outputDir] } {
    puts "Creating [RepertoireDuGenome]/$outputDir"
    file mkdir [RepertoireDuGenome]/$outputDir
  }

  # Read ACE file and store results in ace array
  array set ace [readACEfile $inputFile]

  set ORFnumber 1

  foreach contigIdx $ace(index) {
    puts $contigIdx
    array set contig [AceSubset ace $contigIdx]

    # Align sequences in the ace subset array
    puts "Aligning reads to consensus..."
    alignSequencesToConsensus contig

    # Generate XmlMacSim
    puts "Generating XmlMacSim..."
    set xml [generateXMLmacsim contig]

    # Writing...
    set fh [open [format "%s/%s/%s%${numerotation}" [RepertoireDuGenome] $outputDir $prefix $ORFnumber] w]
    puts $fh $xml
    close $fh
    
    incr ORFnumber
  }

  # Well done !
  puts "Finished."

#  quickConvert $outputDir

}

proc ActaClusFilter {Cluster} {


#Permet de retrouver dans un fichier de SBS quels sont ceux qui dans le fichier d'origine avaient un ACTACAN en 5'


set FichierClu [open "/genomics/link/UCSCAlignements/g11/STAF/fiches/Cluster4/Cluster$Cluster.tfa" "r"]

set I 0
if { [file exists $ActaCluster] } {
		file delete $ActaCluster
}
while { [gets $FichierDes25 Ligne25]  >=0 } {
			ScanLaListe $Ligne25 Sequence25
			lappend Liste25 $Sequence25
}
while { [gets $FichierClu LigneClu] >=0 } {
		incr I
		ScanLaListe $LigneClu SequenceClu
		foreach Seq $Liste25 {
			ScanLaListe $Seq Sequence 
			set SBS [string range $Sequence 7 24]
			if { $SequenceClu == $SBS } {
				AppendAuFichier $ActaCluster ">Act$I"
				AppendAuFichier $ActaCluster "$Sequence"
			}

		}
	}		

}

proc ActiChip1_0 {} {

   
    Wup "Permet de rendre la liste des PAB des oligos commandes pour ActiChip1_0"

    set Fichier "[RepertoireDuGenome]/fiches/ActiChip1_0.txt"

    global Oligo_ActiChip1_0

    if {[info exists Oligo_ActiChip1_0]} {
	return $Oligo_ActiChip1_0
    }

    if {! [file exists $Fichier]} {return ""}

    set Oligo_ActiChip1_0 ""

    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set  PAB ""
	scan $Ligne "%s" PAB
	lappend Oligo_ActiChip1_0 $PAB
    }
    close $F

    set     Oligo_ActiChip1_0 [lsort -unique $Oligo_ActiChip1_0]
    return $Oligo_ActiChip1_0

}

proc ActiChip2_0 {} {

   
    Wup "Permet de rendre la liste des PAB des oligos commandes pour ActiChip2_0"

    set Fichier "[RepertoireDuGenome]/fiches/ActiChip2_1.txt"

    global Oligo_ActiChip2_0

    if {[info exists Oligo_ActiChip2_0]} {
	return $Oligo_ActiChip2_0
    }

    if {! [file exists $Fichier]} {return ""}

    set Oligo_ActiChip2_0 ""

    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set  PAB ""
	scan $Ligne "%s" PAB
	lappend Oligo_ActiChip2_0 $PAB
    }
    close $F

    set     Oligo_ActiChip2_0 [lsort -unique $Oligo_ActiChip2_0]
    return $Oligo_ActiChip2_0

}

proc ActiChip2_0_Reference {File} {


    Wup "Cree un fichier avec la liste des PAB et des definitions"

    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"

    set LesLignes ""
    foreach PAB [ActiChip2_0] {
	
	#On annote en recherchant les definitions
	set ProteinAccess ""
	set DesignAccess  ""
	set Definition    ""
	#Access utilise lors du design
	#un mRNA ou sequence originale (nuctfa)
	#######################################
	set Query     "$RepmRNA/$PAB"
	if {[file exists $Query]} {
	    set         DesignAccess [AccessDeLaBoite $PAB mRNA]
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		set     DesignAccess [AccessDuTFADumRNA $Query]
	    } else {set DesignAccess "$PAB"}
	}
	#Access et definition de la proteine correspondante
	###################################################
	set ProteinAccess [AccessDeLaBoite $PAB protein]
	set Definition    [AccessDeLaBoite $PAB protein Definition]
	#Definition de secours (mRNA ou access)
	#######################################
	if {       $Definition == "" && $DesignAccess != ""} {
	    set     Definition [AccessDeLaBoite $PAB mRNA Definition]
	    if {   $Definition == ""} {
		set Definition [lrange [DefDeAcc $DesignAccess genbankfull Def] 1 end]
	    }
	} 
	lappend LesLignes "$PAB\t$Definition"
    }
    AppendAuFichier $File [join $LesLignes "\n"]

    return ""

}

proc ActiChip3_0 {} {

   
    Wup "Permet de rendre la liste des PAB des oligos commandes pour ActiChip3_0"

    set Fichier "[RepertoireDuGenome]/fiches/ActiChip3_0.txt"

    global Oligo_ActiChip3_0

    if {[info exists Oligo_ActiChip3_0]} {
	return $Oligo_ActiChip3_0
    }

    if {! [file exists $Fichier]} {return ""}

    set Oligo_ActiChip3_0 ""

    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set  PAB ""
	scan $Ligne "%s" PAB
	lappend Oligo_ActiChip3_0 $PAB
    }
    close $F

    set     Oligo_ActiChip3_0 [lsort -unique $Oligo_ActiChip3_0]
    return $Oligo_ActiChip3_0

}

proc ActiChipGenesOnWeb {{ListeDesNoms ""} {TitreSummary ""} args} {

    set LesHeadSup {}
    set I 0
    foreach {PH LesV} $args {
	regsub "_" $PH " " PH
	scan $PH "%s %s" Pos Head
	incr Pos $I
	lappend LesHeadSup $Head
	set PosSup($Head) $Pos
	set K 0
	foreach V $LesV {
	    set ValSup($Head,$K) $V
	    incr K
	}
	incr I
    }
    set FichierActinome "[RepertoireDuGenome]/TableauActiChip"
    set LesLignes  [LesLignesDuFichier $FichierActinome]
    set LigneDeTete [lindex $LesLignes 0]
    set LesHeaders [split $LigneDeTete ";"]

    foreach Head $LesHeadSup {
	set LesHeaders [linsert $LesHeaders $PosSup($Head) $Head]
    }
    set NbHeaders  [llength $LesHeaders]

    set Titre "Actinome Database $TitreSummary"
    set HeaderDuHtml ""
    #Html_ZeroToBody $Titre $HeaderDuHtml
    #Html_Append [H_Balise $Titre "h2"]

    Html_Append ""
    Html_BaliseOpen "html"
    Html_BaliseOpen "head"
    Html_Title  "$Titre"
    
    Html_Append ""

    Html_Append ""
    Html_Append "
"
    Html_Append "
"

    Html_Append "Get Help"
    Html_Append "
"
    Html_Append "
"

    Html_Append ""
    Html_Append ""
    Html_Append ""
  
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    
    Html_Append ""
    Html_Append ""
    Html_Append ""

    Html_Append ""
    Html_Append "
"

    set NbCol $NbHeaders
    CouleurDegradee $NbCol
    set Liste {}
    lappend Liste $NbCol
    lappend Liste "border='1' cellpadding='3' cellspacing='1'"
    lappend Liste ""
    foreach Header $LesHeaders {
	lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
    }
    foreach Header $LesHeaders {
	lappend Liste $Header
    }
    
    set K 0
    foreach Ligne $LesLignes {
	Espionne "Debut$Ligne FIN"
	set LesValeurs [split $Ligne ";"]
	foreach Head $LesHeadSup {
	    set P $PosSup($Head)
	    set V $ValSup($Head,$K)
	    set LesValeurs [linsert $LesValeurs $P $V]
	}
	incr I
	set Nom [lindex $LesValeurs 0]
	if { ! [EstUnPAB $Nom]} { continue }
	foreach H $LesHeaders V $LesValeurs {
	    if {$H=="ProbeSet" || $H=="Pathway"} {
		set LongV [string length $V]
		if {$LongV>=200} {
		    set Milieu [expr $LongV / 2]
		    set V "[string range $V 0 $Milieu]
[string range $V [expr $Milieu+1] end]"
		}
	    }
	    set Vue [BelleVueJean $H $V $Nom]
	    lappend Liste $Vue
	}
	incr K
    }
    Html_TableFromList $Liste

    Html_Append "
"
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append "
"
    Html_Append "
"
    Html_Append ""
    Html_Append "Muller et al (2007) BMC Genomics doi: 10.1186/1471-2164-8-294"
    Html_Append ""
    Html_Append "
"
    Html_Append "
"
    Html_Append "
"
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append ""
    Html_Append "
"
    Html_Append "
"
    Html_Append "
"
    Html_Append ""
    Html_Append "If you have any problems or questions, please, feel free to contact us at jean.muller@igbmc.u-strasbg.fr"
    Html_Append ""
    Html_Append "
"
    Html_Append "
"
    Html_Append "
"
    Html_Append "
"

    
    Html_BaliseClose "body"
    Html_BaliseClose "html"
    
    return [Html_Get "ZeroIt"]

}

proc AddACorrectedProteome {args} {


	#Telechargement des proteomes
	eval DownloadProteomes $args
	#Conversion pour Gscope 
	FastaProteomeConverter "completeProteome.fasta" "completeConvertedProteome"
	#Lancement de Gscope pour la creation du projet
	puts "##########################################################"
	puts "Gscope va se lancer, réalisez les opération suivantes :"
	puts "    - 'i need the file with all complete genomes' -->YES"
	puts "    - 2eme fentre --> Acknowlegde"
	puts "    - 'c'est pour un genome?' --> NO"
	puts "    - 'c'est pour une collection?' --> YES"
	puts "    - 'prefixe des ORFs' --> mettre un code 4 lettre (ex:AGAM pour anopheles gambiae)"
	puts "    - 'Does it concern only one organism?' --> YES"
	puts "    - Rentrez le nom de l'organisme"
	puts "    - Verifiez la taxinomie"
	puts "    - fenetre suivante --> Acknowlegde"
	puts "    - Choisissez 'Prot: protein for blastp tblastn etc.'"
	puts "    - Aux fenetre suivantes répondre oui pour celle demandant de charger un FASTA"
	puts "    - CHARGEZ completeConvertedProteome.fasta !!!!! Et pas autre chose !!!"
	puts "    - 'Do we handle DNA ?' --> NO"
	puts "    - 'Could you browse a TFA file with all sequences?' --> YES"
	puts "    - 'Do i keep information following each > ?' --> YES"
	puts "    - 'Do I use Access to create Narcisse ?' --> NO"
	puts "    - 'Do I force Access to be in position 1 ?' --> YES"
	puts "    - Ouvrir le fichier completeConvertedProteome.fasta créé."
	puts "    - Mettre 5 pour le nombre de Digits (ca devrait suffire, un proteome > 99999 proteine, c rare ^^)"
	puts "    - 'I will create sequences from a TFA file, are the header as follow ...' --> YES"
	puts "    - 'Do i use access as genename ?' --> YES"
	puts "    - 'Do all following definitions always start with the organism name ?' --> NO"
	puts "    - 'Can i use the Access as alias ?' --> YES"
	puts "    - Patience ... (~12 min pour 14000 proteines)"
	puts "    - répondre non jusqu'à la fin"
	puts "	  - quitter gscope, les instructions se relancent..."
	puts "##########################################################"
	exec gscope

}

proc AddACorrectedProteomeFromFile {fileName} {


	puts "##### ATTENTION !!!!! ###############################"
	puts "vos entetes doivent être sous la forme :"
	puts ">NUM_D_ACCESS genre espece Description_quelconque"
	puts "#####################################################"
	#recup du fichier fasta
	file rename $fileName "completeConvertedProteome.fasta"
	#Lancement de Gscope pour la creation du projet
	puts "##########################################################"
	puts "Gscope va se lancer, réalisez les opération suivantes :"
	puts "    - 'i need the file with all complete genomes' -->YES"
	puts "    - 2eme fentre --> Acknowlegde"
	puts "    - 'c'est pour un genome?' --> NO"
	puts "    - 'c'est pour une collection?' --> YES"
	puts "    - 'prefixe des ORFs' --> mettre un code 4 lettre (ex:AGAM pour anopheles gambiae)"
	puts "    - 'Does it concern only one organism?' --> YES"
	puts "    - Rentrez le nom de l'organisme"
	puts "    - Verifiez la taxinomie"
	puts "    - fenetre suivante --> Acknowlegde"
	puts "    - Choisissez 'Prot: protein for blastp tblastn etc.'"
	puts "    - Aux fenetre suivantes répondre oui pour celle demandant de charger un FASTA"
	puts "    - CHARGEZ completeConvertedProteome.fasta !!!!! Et pas autre chose !!!"
	puts "    - 'Do we handle DNA ?' --> NO"
	puts "    - 'Could you browse a TFA file with all sequences?' --> YES"
	puts "    - 'Do i keep information following each > ?' --> YES"
	puts "    - 'Do I use Access to create Narcisse ?' --> NO"
	puts "    - 'Do I force Access to be in position 1 ?' --> YES"
	puts "    - Ouvrir le fichier completeConvertedProteome.fasta créé."
	puts "    - Mettre 5 pour le nombre de Digits (ca devrait suffire, un proteome > 99999 proteine, c rare ^^)"
	puts "    - 'I will create sequences from a TFA file, are the header as follow ...' --> YES"
	puts "    - 'Do i use access as genename ?' --> YES"
	puts "    - 'Do all following definitions always start with the organism name ?' --> NO"
	puts "    - 'Can i use the Access as alias ?' --> YES"
	puts "    - Patience ... (~12 min pour 14000 proteines)"
	puts "    - répondre non jusqu'à la fin"
	puts "	  - quitter gscope, les instructions se relancent..."
	puts "##########################################################"
	exec gscope

}

proc AddARedundant {redundantSequencesL currentHit} {


	upvar $redundantSequencesL redundantSequences
	upvar $currentHit hit

	# on a une redondance entre A et B
	# on cree le couple  {A B} si il n'existe pas encore
	#set detected 0
	#set where 0
	set A [lindex $hit 0]
	set B [NomDuAlias [lindex $hit 2]]
	#set leCouple [list [lindex $hit 0] [NomDuAlias [lindex $hit 2]]]
	#puts "'$leCouple'"
	#si le couple existe , on le zappe
	#for {set x 0} {$x<[llength $redundantSequences]} {incr x} {
	#	if { [lindex $redundantSequences $x 0]==[lindex $leCouple 0]  #			&& [lindex $redundantSequences $x 1]==[lindex $leCouple 1] } {
	#		set detected 1
	#		continue
	#	}
	#}

	if {![info exists redundantSequences($A,$B)]} {
		set redundantSequences($A,$B) 1
	}
	#if {$detected==0} {
	#	lappend redundantSequences $leCouple
	#}
	

}

proc AddAliasPourMiRNA {} {
    
    foreach F [LesLignesDuFichier /genomics/link/MiRNA/ExtractFromRefseqAllMiRNA2907.fof] {
	set Access [file tail $F]
	regsub ".nuctfa" $Access "" Access
	
	scan [PremiereLigneDuFichier $F] "%s" Alias
	regsub ">" $Alias "" Alias
	set N "$Alias $F"
	Espionne $N
	lappend LesN $N
    }
    SauveLesLignes $LesN dans /genomics/link/MiRNA/ExtractFromRefseqAllMiRNA2907.fofnew
    exit

}

proc AddAnOrganismInCSV {fileName} {

	set output [open "paralogy" "w"]
	set input [open "$fileName" "r"]
	while {[gets $input line]!=-1} {
		if {$line=="" || $line=="\n" || ([string index $line 0]=="#")} {continue}
		set infos [split $line ";"]
		puts $output "[lindex $infos 0];[lindex $infos 1];[lindex $infos 2];[lindex $infos 3];[GetOrga [lindex $infos 2]];[lindex $infos 5];[lindex $infos 6]"
	}
	close $output
	close $input

}

proc AddBranch {B Tree {Index end}} {

    set NewBranches [linsert [Branches $Tree] $Index $B]
    return [NewTree [ValueOfTree $Tree] $NewBranches]

}

proc AddFObj {nom} {

    global pgl

    # proc is called to create the frame or 
    # to update the objects buttons
    set frObjc $pgl(frObjc)
    set c 0
    if {! [winfo exists $frObjc.f${nom}]} {
	set i [lindex [grid size $frObjc] 1]
	frame $frObjc.f${nom} -bg black -relief flat -bd 0 -highlightthickness 0
	
	button $frObjc.f${nom}.b$c  -text "- $nom" -font FontOgTitle  -bg black -fg white  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -pady 0 -padx 0  -highlightthickness 0  -anchor w -justify left  -command [list ToggleTabBouton $frObjc.f${nom}.b$c]
	button $frObjc.f${nom}.n$c  -text "New" -font FontOg  -bg DarkSlateGrey -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -pady 0 -padx 0  -highlightthickness 0  -anchor w -justify left  -command [list DefineNewObj $nom]

	grid $frObjc.f${nom}.b$c  -row $c -column 0 -sticky w  -ipady 0 -pady 0 -padx {0 5}
	grid $frObjc.f${nom}.n$c  -row $c -column 2 -sticky e  -ipady 0 -pady 0 -padx {5 0}

	grid columnconfig $frObjc.f${nom} all -weight 1
	# grid the whole frame
	grid $frObjc.f${nom}  -row $i -column 0 -sticky nwe  -pady 0 -ipady 0 -padx {20 1}
    } else {
	# if the frame exists , expand it if necassary
	if {[llength [grid slaves $frObjc.f${nom}]] == 2} {
	    $frObjc.f${nom}.b0 invoke
	}
    }

    # objects buttons
    set Lb [winfo children $frObjc.f${nom}]
    set Li [lsearch -all -regexp $Lb {\.b0|\.n0}]
    foreach i [lreverse $Li] {
	set Lb [lreplace $Lb $i $i]
    }
    destroy {*}$Lb
    foreach objI [$nom _ListeObjets] {
	if {$objI eq "Index"} {continue}
	incr c

	if {[$nom _EtatDeObjet $objI]} {
	    set col green1
	} else {
	    set col red
	}
	set obj [string range $objI 4 end]
	button $frObjc.f${nom}.bto$obj  -text "$obj" -font FontOg  -bg black -fg $col  -activeforeground $col  -activebackground black  -bd 0 -relief flat  -highlightthickness 0  -padx 0 -pady 0  -anchor w -justify left  -command [list AfficheObjet $frObjc.f${nom}.bto$obj $nom $obj]
	button $frObjc.f${nom}.bte$obj  -text "Edit" -font FontOg  -bg DarkSlateGrey -fg green1  -bd 0 -relief flat  -highlightthickness 0  -activeforeground green1  -activebackground black  -padx 0 -pady 0  -anchor e -justify left  -command [list DefineNewObj $nom $objI]
	button $frObjc.f${nom}.btd$obj  -text "Del" -font FontOg  -bg DarkSlateGrey -fg red  -bd 0 -relief flat  -highlightthickness 0  -activeforeground red  -activebackground black  -padx 0 -pady 0  -anchor e -justify left  -command [list DeleteObjet $nom $objI]
	grid $frObjc.f${nom}.bto$obj  -row $c -column 0 -sticky w  -pady 0 -ipady 0 -padx {5 0}
	grid $frObjc.f${nom}.bte$obj  -row $c -column 1 -sticky e  -pady 0 -ipady 0 -padx {5 5}
	grid $frObjc.f${nom}.btd$obj  -row $c -column 2 -sticky we  -pady 0 -ipady 0
    }

    return

}

proc AddGC {Path Organism Chrox bigZips} {

	set FichierIn [open "$Path.coord" "r"]
	set FichierOut [open "$Path.coo" "w"]
	while { [gets $FichierIn Ligne]  >=0 } {
		ScanLaListe $Ligne nbMatchs sequenceNumber start end matchType hs1Mistake hs2Mistake matchOut repeat
		if { $matchType == "F"} {
			set strand "+"
		} else {
			set strand "-"
		}
		set SequenceRallongee [BoutAdnDeUcscBoost [expr $start - 20] [expr $end + 20] $strand $Organism $Chrox $bigZips] 
		set Upstream [string range $SequenceRallongee 0 19]
		set Downstream [string range $SequenceRallongee [expr 19 + [string length $matchOut]] [expr 41 + [string length $matchOut]]]
		Espionne "$SequenceRallongee $Upstream $matchOut $Downstream"
	}
	close $FichierIn
	close $FichierOut

}

proc AddInFile {Text File} {

    set Channel [open $File "a"]
    puts $Channel $Text
    close $Channel
    return $File

}

proc AddInfo {GscopeCode} {

    #set Directory [RepertoireDuGenome]
    #si la sequence n'est pas une sequene protein entière mais un domain ou autre avec un code perso....? que se passe t-il?
    set LL [LaSequenceDesBanques $GscopeCode]
    DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX SequenceBrute LaDETotal
    InformeSansDemander $GscopeCode "ID: $ID"
    InformeSansDemander $GscopeCode "AC: $AC"
    InformeSansDemander $GscopeCode "DE: $DE"
    InformeSansDemander $GscopeCode "OS: $OS"
    InformeSansDemander $GscopeCode "OC: $OC"
    InformeSansDemander $GscopeCode "OX: $OX"

}

proc AddLabel {c elt index} {

    global Vrp

    set pos [$c coords $elt]
    set x1 [lindex $pos 2]
    set y1 [lindex $pos 3]
    # add if does not already exist
    if {[llength [$c find withtag t_$index]] == 0 } {
	$c create text $x1 $y1 -fill $Vrp(colLabel)  -font $Vrp(font)  -text "[lindex $Vrp(AA1) $index][lindex $Vrp(Nb) $index]"  -tags [list label t_$index]  -justify right -anchor sw
    }

    return

}

proc AddLeaf {Value Tree {Index end}} {

    return [AddBranch [NewLeaf $Value] $Tree $Index]

}

proc AddLinx {{Login ""} {LinkName ""} {Link ""} {Description ""} {Belongs ""}} {

    if {$LinkName==""} { set LinkName [Entre "FromGscope"] }
    if {$Login==""} { set Login [Login] }
    if {$Link==""}        { set Link64 "" } else { set Link64 [Base64Encode $Link] }
    if {$Description==""} { set Desc64 "" } else { set Desc64 [Base64Encode $Description] }
    if {$Belongs==""}     { set Belo64 "" } else { set Belo64 [Base64Encode $Belongs] }
    set Url "[LbgiUrl]/MyLinx.php?do=addlinx&lo=$Login&ln=$LinkName&li=$Link64&de=$Desc64&be=$Belo64"
    set Status [ContenuDuFichier $Url]
#rR faut il le faire ici   ????????????????????????
    MyLinx ResetMyLinx
    return $Status

}

proc AddLinxTest {} {

    return [AddLinx "poch" "" "http://raymondripp.fr" "Le site de RR" "public"]

}

proc AddModules {file} {

    global TabSF

    array unset TabSF "*,MODULE"
    update

    ReadRawFeatureFile $file

    set Old $::Defauts(FichierXML)
    set root [file rootname $Old]
    set New "${root}_new.xml"

    SauveLAlignement XML $New
    puts "on sauve $New"

    exit

}

proc AddNarcisse {inputFile} {

	#variables globales
    global RepertoireDuGenome
    set repInfos "$RepertoireDuGenome/infos"
	#puts "$repInfos"
	#open input file
	set fasta_file [open $inputFile "r"]
	#reads input line by line
	set compteur 0
	while {[gets $fasta_file line]!=-1} {
    	if {$line==""} { continue }
		#header, correct it
    	if {[string index $line 0]==">"} {
			#separation by |
			set infos1 [split $line "|"]
			lassign $infos1 origin accessNumber description
			regexp {>(.*)} $origin -> origin2
			#puts $origin2
			#pour le fasta de Alvinella pompejana
			if {[string length $origin2]>3} {
				set infos2 [split $origin2 " "]
				set accessNumber [lindex $infos2 0]
				set origin2 "file"
			}
			if {$origin2=="gi"} {
				set origin2 "ref"
			}
			#puts "'$origin2' '$accessNumber'"
			#recuperation de l'accession
			set numGScope [NomDuAlias $accessNumber]
			#puts "'$numGScope'  'Narcisse: $origin2:$accessNumber'"
			InformeSansDemander $numGScope "Narcisse: $origin2:$accessNumber "
			incr compteur
		}
	}
	puts "    -->$compteur infos modifie"

}

proc AddNewAARSPDB {id Lf} {

    global db Tpdb

    if {0} {
	# save file in structure directory
	set fout [file join [MiSynPatDir] data structures ${id}.pdb]
	set o [open $fout w]
	puts $o [join $Lf \n]
	close $o
    }

    # Organism :
    # look into SOURCE cards to find the scientific name and 
    # TaxId of the organism.
    set TaxId ""
    set Gene  ""
    set Li [lsearch -all -regexp $Lf {^SOURCE }]
    foreach i $Li {
	set l [lindex $Lf $i]
	if {[regexp {ORGANISM\_TAXID\:} $l]} {
	    set dTax [string first "TAXID:" $l]
	    set fTax [string first ";" $l]
	    set TaxId [string range $l $dTax+6 $fTax-1]
	}
	if {[regexp {GENE\:} $l]} {
	    set dGen [string first "GENE:" $l]
	    set fGen [string first ";" $l]
	    set Gene [string range $l $dGen+5 $fGen-1]
	}
    }
    set Tpdb($id,taxid) $TaxId
    set Tpdb($id,gene) $Gene
    puts "taxid $TaxId"
    puts "gene $Gene"

    # check if we have a mitochondrial human structure
    set tMit 0
    if {$TaxId == 9606} {
	# double check : in the title and the card
	set LiTitle [lsearch -all -regexp $Lf {^TITLE }]
	set titre ""
	foreach i $LiTitle {
	    append titre [string tolower [lindex $Lf $i]]
	}
	set tMit [regexp {mitochondr} $titre]
	if {$tMit} {
	    puts "==> HUMAN MITO !"
	}
    }
    set Tpdb($id,mito) $tMit
    
    return 1

}

proc AddNewFeatEntry {n db fb code name note score} {

    global CpB 

    lassign [set CpB(startstop,$n)] start stop

    if {$fb < $db} {return}
    if {$fb < $start || $db > $stop} {return}
    if {$db < $start} {set db $start}
    if {$fb > $stop} {set fb $stop}

    set dr [DonnePosGS $n $db]
    set fr [DonnePosGS $n $fb]
    
    switch $name {
	"BLOCK" {
	    if($fr - $dr<4) return;
	    if {$note eq "SBLOCK"} {
		set color $code
	    } elseif {note eq "LBLOCK"} {
		set color 12
	    }
	}
	"REGION" {
	    set color 10
	}
	"SEQERR" {
	    set color 3
	}
	"ANCHOR" {
	    set color $code
	}
	"REPEAT" {
	    set color $code
	}
	"STRUCT" {
	    switch $note {
		"PRED_HELIX" {set color VLRED}
		"PRED_STRAND" {set color VLGREEN}
		"PROP_HELIX" {set color LRED}
		"PROP_STRAND" {set color LGREEN}
		"HELIX" {set color RED}
		"STRAND" {set color GREEN}
	    }
	}
	"TRANSMEM" {
	    if {[regexp {^PRED\_} $note]} {
		set note "$note_$score"
		set color 10
	    } elseif {[regexp {^PROP\_} $note]} {
		,set color GRAY
	    } else {
		set color 1
	    }
	}
	"COIL" -
	"LOWCOMP" {
	    if {[regexp {^PRED\_} $note]} {
		set color LGRAY
	    } elseif {[regexp {^PROP\_} $note]} {
		set color GRAY
	    } else {
		set color 6
	    }
	}
	"DOMAIN" {
	    switch -regexp $note {
		{^PRED\_} {set color LGRAY}
		{^PROP\_} {set color GRAY}
		{^DNA\_BIND} {set color 2}
		{^ZN_FING} {set color 3}
		default {set color 1}
	    }
	}
	"PFAM-A" -
	"PFAM-B" -
	"PROSITE" -
	"ELM" -
	"DISORDER" {
	    if {[regexp {^PRED\_} $note]} {
		set color LGRAY
	    } elseif {[regexp {^PROP\_} $note]} {
		set color GRAY
	    } else {
		set color $code
	    }
	}
	"SIGNAL" {
	    switch -regexp {
		{^PRED\_} {
		    set note "$note_$score"
		    set color LGRAY
		}
		{PROP\_} {set color GRAY}
		"NUCLEAR" {set color 1}
		"CHLOROPLAST" {set color 2}
		"MITOCHONDRION" {set color 3}
		"MICROBODY" {set color 4}
		default {set color 5}
	    }
	}
	"VARSPLIC" {
	    if {[regexp {^PRED\_} $note]} {
		set color LGRAY
	    } elseif {[regexp {^PROP\_} $note]} {
		set color GRAY
	    } else {
		set color 5
	    }
	}
	"MOD_RES" {
	    set color 0
	    switch $note {
		"PRED_" {set color LGRAY}
		"PROP_" {set color GRAY}
		"ACETYLATION" {set color 1}
		"ALKYLATION" {set color 2}
		"HYDROXYLATION" {set color 3}
		"METHYLATION" {set color 4}
		"PHOSPHORYLATION" {set color 5}
		"SULFATION" {set color 6}
		"PYRROLIDONE" {set color 7}
		"MYRISTATE" {set color 8}
		"PALMITATE" {set color 9}
		"FARNESYL" {set color 10}
		"GERANYL" {set color 11}
		"GPI-ANCHOR" {set set color 12}
		"N-ACYL" {set color 13}
	    }
	}
	"SITE" {
	    set color 0
	    switch -regexp $note {
		{^PRED\_} {set color LGRAY}
		{^PROP\_} {set color GRAY}
		"SITE" {set color 0}
		"ACT_SITE" {set color 1}
		"CARBOHYD" {set color 2}
		"DISULFID" {set color 3}
		"BINDING" {set color 4}
		"NP_BIND" {set color 5}
		"CA_BIND" {set color 6}
		"TRANSIT" {set color 7}
		"LIPID" {set color 8}
		"METAL" {set color 9}
	    }
	}
    }
    
    
    lappend CpB(tb,$n) [list ftype $name fstart $start fstop $stop fcolor $color fscore $score fnote $note]
    
    return

}

proc AddObjToFObj {nom obj} {

    global pgl

    set frO "$pgl(frObjc).f${nom}"
    # open the "menu" corresponding to the pdb
    if {[llength [grid slaves $frO]] == 2} {
	$frO.b0 invoke
    }
    set c [lindex [grid size $frO] 1]
    button $frO.bto$obj  -text "$obj" -font FontOg  -bg black -fg green1  -activeforeground red  -activebackground black  -bd 0 -relief flat  -highlightthickness 0  -padx 0 -pady 0  -anchor w -justify left  -command [list AfficheObjet $frO.bto$obj $nom $obj]
    grid $frO.bto$obj  -row $c -column 0 -sticky ""  -columnspan 2  -pady 0 -ipady 0 -padx 0
    
    return

}

proc AddOrganismToOrgaCode {{NewOrga ""} {NewOrga2 ""}} {

JeMeSignale
    if {$NewOrga2!=""} { set NewOrga "$NewOrga $NewOrga2" }
    regsub "_" $NewOrga " " NewOrga

    
    set FichierOrganismes "[GscopeEtc]/gscope_listedesorganismes.txt"
    set FichierGlossaire  "[GscopeEtc]/gscope_glossaire"

    set Organismes [ContenuDuFichier $FichierOrganismes]
    if {$NewOrga!=""} {
	set Organismes "$NewOrga\n$Organismes"
    }
    if { ! [PourWscope]} {
	set Original $Organismes
	FaireLire "You can add other organisms 'Genus species' ... \n Doesn't matter for the alphabetical order or duplicates\n if it's a virus please enter 'Virus homo-sapiens-hiv'" 
	set  Organismes [EntreTexte $Organismes]
	if {$Organismes==""} { return "" }
    }
    set  Organismes [join [lsort -unique [split $Organismes "\n"]] "\n"]
    if {$Original!=$Organismes} {
	Garde $FichierOrganismes
	Sauve $Organismes dans $FichierOrganismes 
	file attribute $FichierGlossaire -permissions 0775
    }
    
    set LesOrganismes [split $Organismes "\n"]
    foreach Ligne $LesOrganismes {
	regsub -all { +} $Ligne " " Ligne
	set Ligne [string trim $Ligne]	
	if { ! [regexp -nocase {[a-z0-9\-]+ [a-z0-9\-]+\.?} $Ligne]} {
	    FaireLire "Invalid organism\n$Ligne\nOnly 2 words please : 'Homo sapiens'" 
	    continue
	}
	set Genre   [string tolower [lindex [split $Ligne " "] 0]]
	set espece  [string tolower [lindex [split $Ligne " "] 1]]
	set G	    [string toupper [string range $Genre 0 0]]
	set esp     [string range $espece 0 2]
	set gesp    [string tolower $G]$esp
	set Complet "$G[string range $Genre 1 end] $espece"
	set Pointe  "$G.$espece"
	set Demi    "$G[string range $Genre 1 3].[string range $espece 0 4]"
	lappend LeGlossaire "$gesp\t$Complet\t$Pointe\t$Demi"
    }
    
    Garde $FichierGlossaire
    SauveLesLignes $LeGlossaire dans $FichierGlossaire
    file attribute $FichierGlossaire -permissions 0775
    Glossaire "Reset"
    return [Glossaire]

}

proc AddPV {} {

    foreach Ligne [LesLignesDuFichier /planbis/commun/dbsql/backups/PRIVILEGES_201602071520.sql] {
	append Ligne ";"
	lappend LeNew $Ligne
    }
    SauveLesLignes $LeNew dans /planbis/commun/dbsql/backups/MYSQL_PRIVILEGES_201602071520.sql

}

proc AddRemoveLabel {c elt} {

    global Vrp

    set t $Vrp(WText)

    set index [lindex [split $elt "_"] 1]

    set item [$c find withtag t_$index]
    #check if label exists
    if {[llength $item] == 0} {
	# add text
	AddLabel $c $elt $index
    } else {
	$c delete $item
    }
    $t see [$t index 1.$index]
    HighlightChar $t $index

    return

}

proc AddSeq {ID {Sequence ""}} {

    #UneNouvelleSequencePourGscope P12346 Auto
    #Normalement la procedure UneNouvelleSequencePourGscope verifie si il y aou non une nouvelle sequence.
    #verification que cette sequence n'existe pas deja. Dans un premier temps
    #Si oui reprends les resultats précédement calcule
    Espionne "ID: $ID"
    Espionne "Sequence: $Sequence"
    
    if {$Sequence!=""} {
	set TFAQuery ">$ID\n$Sequence"
	set information [UneNouvelleSequencePourGscope $TFAQuery Auto]
	scan $information "%s" CodeGscope
	AddInfo $CodeGscope
    } else {
	#Espionne "Avant UneNouvelleSequencePourGscope"
	set information [UneNouvelleSequencePourGscope $ID Auto]
	#Espionne "apres UneNouvelleSequencePourGscope"
	scan $information "%s" CodeGscope
	AddInfo $CodeGscope
    }   
    return $CodeGscope

}

proc AddTaxToSelection {} {

    global LTaxSelected LShowId Tx
    
    puts "AddTo"
    set PAD $Tx(PAD)
    set n $Tx(ItemSel)
    puts "n= $n"
    if {$n eq ""} {return}

    set ix [lsearch $LShowId $n]
    puts "ix show $ix sel [lsearch $::LTaxSelected $n] user [lsearch $::LUserId $n]"
    puts ""
    if {$ix == -1} {return}

    set LShowId [lreplace $LShowId $ix $ix]
    lappend LTaxSelected $n
    
    # change outline of taxId
    $PAD itemconfig "R$n" -outline $Tx(fgCan)

    return

}

proc AddUser {{Login ""} {Uid ""} {Gid ""} {Prenom ""} {Nom ""} {HomeDir ""} {Shell ""} {Hash ""} {CreateDir ""}} {

    if {$Login==""}   { set Login   [Entre "Login="] }
    if {$Uid==""}     { set Uid     [Entre "Uid="] }
    if {$Gid==""}     { set Gid     [Entre "Gid=3000"] }
    if {$Prenom==""}  { set Prenom  [Entre "Prenom="] }
    if {$Nom==""}     { set Nom     [string toupper [Entre "NOM="]] }
    if {$HomeDir==""} { set HomeDir [Entre "Home=/maison"] }
    if {$Shell==""}   { set Shell   [Entre "Shell=/bin/bash"] }
    set Secret "[string tolower [string index $Prenom end][string index $Nom end]]2016"
    if {$Hash==""}    { set Hash    [Entre "Password=$Secret"] }
    if {$CreateDir==""} { set CreateDir "CreateDir" }
    
    if { ! [regexp {^\{} $Hash]} { set Hash [exec slappasswd -h "{SSHA}" -s $Hash] }

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

    foreach K {Login Uid Gid Prenom Nom HomeDir Shell} {
	regsub {[^=]*=} [set $K] "" $K
	set $K [string trim [set $K]]
	regsub { } [set $K] "-" $K
	if {$K=="Nom"} { set $K [string toupper [set $K]] }
	Espionne "$K [set $K]"
    }
    
    set LesNouveaux [list "$Login $Uid $Gid $Prenom $Nom $HomeDir $Shell"]
    
    set LesInfos {}
    set LeLdap {}
    foreach Ligne $LesNouveaux {
	lassign [split $Ligne " "] Login Uid Gid Prenom Nom HomeDir Shell
	Espionne $Ligne
	lappend LesInfos $Ligne
	if {$CreateDir || [OuiOuNonMemo "Je crée les répertoires ?" 0]} {
	    file mkdir "$HomeDir/$Login"
	    if { ! [file exists /home/$Login]} { exec ln -s $HomeDir/$Login /home/ }
	}
	lappend LeLdap "dn: uid=$Login,ou=users,dc=lbgi,dc=fr"
	lappend LeLdap "objectClass: inetOrgPerson"
	lappend LeLdap "objectClass: posixAccount"
	lappend LeLdap "cn: $Login"
	lappend LeLdap "sn: $Nom"
	lappend LeLdap "givenName: $Prenom"
	lappend LeLdap "homeDirectory: /home/$Login"
	lappend LeLdap "loginShell: $Shell"
	lappend LeLdap "uidNumber: $Uid"
	lappend LeLdap "gidNumber: $Gid"
	lappend LeLdap "userPassword: $Hash"
	lappend LeLdap ""
	incr UID
    }
    return [join $LeLdap "\n"]

}

proc AddUsers {} {

    set LesU {}
#   lappend LesU [AddUser collet       3356 3000 Pierre    Collet       /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser schreiner    3357 3000 Clément   Schreiner    /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser abotsi       3358 3000 Isaac     Abotsi       /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser julio        3359 3000 Julio     Navarra-Lara /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser cardosi      3360 3000 Paul      Cardosi      /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser raaj         3361 3000 Raaj      Seereekisson /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser michel       3362 3000 Christian Michel       /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser parrend      3363 3000 Pierre    Parrend      /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser karim        3364 3000 Karim     El-Soufi     /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser willaume     3365 3000 Pierre    Willaume     /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser colin        3366 3000 Florent   Colin        /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser deruyver     3367 3000 Aline     Deruyver     /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser guigou       3368 3000 Fabio     Guigou       /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser masai        3369 3000 Pierre    Masai        /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser mazzu        3370 3000 Timothée  Mazzucotelli /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser toussaint    3371 3000 Nicholas  Toussaint    /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser pasquier     3372 3000 Jean-Yves Pasquier     /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser chene        3373 3000 Jocelyn   Chene        /maison /bin/bash "" CreateDir]
#   lappend LesU [AddUser mesny        3374 3000 Fantin    Mesny	/maison /usr/bin/tcsh "" CreateDir]	
#   lappend LesU [AddUser joly         3375 3000 Mickael   Joly 	/maison /usr/bin/tcsh "" CreateDir]	
#   lappend LesU [AddUser leonteva     3376 3000 Anna      Leonteva 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser huber        3377 3000 Laurine   Huber 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser jeannin      3378 3000 Anne      Jeannin 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser pupka        3379 3000 Cedric    Pupka 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser lmary        3380 3000 Lora      Mary 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser guth         3381 3000 Catherine Guth 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser haegelin     3382 3000 Marc      Haegelin 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser bruyant      3383 3000 Alexandre Bruyant 	/maison /bin/bash "" CreateDir]	
#   lappend LesU [AddUser mayer        3386 3000 Claudine Mayer  	/maison /usr/bin/tcsh "" CreateDir]	
#   lappend LesU [AddUser durand       3387 3000 Dylan Durand   	/maison /usr/bin/tcsh "" CreateDir]	
    
    set FichierLdap [SauveLesLignes $LesU dans "[HomeRipp]/rh/Ldap_[Date Seconds].txt"]
    return $FichierLdap

}

proc AdieuOrdali {} {

    global StrucAVoir tmpdebut NomFenetreOrdali Defauts

    if {[set olog [set Defauts(SaveLog)]] != 0} {
	SauveLeLog $olog
    }
    
    FinDBProfile

    if {[VueEditee]} {
	if {[ModeI]} {
	    set chx [tk_dialog .chx "Warning" "Warning !\nThis alignment has not been saved !\nDo you want to save it before to quit Ordalie ?" "" 0 "Yes" "No" "Cancel"]
	} else {
	    set chx 0
	}
	switch $chx {
	    0 {
		SauveLAlignement
	    }
	    1 {
		if {[TypeAli] eq "ORD"} {
		    file rename -force $Defauts(FichierOBK) $Defauts(FichierORD)
		}
	    }
	    2 {return}
	}
    }
    
    catch {$::db close}
    NettoieLeTmp

    if {[ModeI]} {
	if {[winfo exists .lulu]} {
	    QuitteViandox
	}
	destroy $NomFenetreOrdali
    }

    if {! [ModeI]} {
	exit
    } else {
	if {$NomFenetreOrdali eq ".ordali"} {
	    exit
	} else {
	    return
	}
    }

}

proc AdjustFog {what} {

    puts "what $what"
    flush stdout
    update idletasks

    if {$what eq "up"} {
	set dadd  0.01
    } else {
	set dadd -0.01
    }
    if {$::fogsys ne "::GL_LINEAR"} {
	set den [tcl3dOglGetFloatState GL_FOG_DENSITY]
	set den [expr {$den + $dadd}]
	if {$den < 0.001} {set den 0.001}
	glFogf GL_FOG_DENSITY $den
	puts "   density $den"
    } else {
	set ::fact [expr {$::fact + $dadd}]
	if {$::fact < 0.005} {set ::fact 0.005}
	#if {$::fact > 2.} {set ::fact 2.}
	set end [expr {$::fact*2.*$::Rad}]
	glFogf GL_FOG_START 0.
	glFogf GL_FOG_END   $end
	puts "   end $end"
    }

    $::pgl(wogl) postredisplay

    return

}

proc AdnFictifPourCollection {{Liste ""} {Rep ""} {Zoom ""} {GetWhat ""} {Max ""}} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global DerniereBase LongueurADN

    Wup "Si Zoom est negatif c'est la valeur qu'on prend pour une sequence"
    Wup "Ca marche aussi si Rep est prottfa. Sauf pour ADN TDN et RAC (qui ne sert pas encore)"
    Wup "Attention ca marche aussi pour un autre projet Gscope ... mais sans creer de fichiers"

    if {$Liste==""} { set Liste [ListeDesPABs] }
    if {$GetWhat==""} { set GetWhat "SaveAndGetFilename" }

    if {$Rep==""} { set Rep nuctfa }
    if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }


    set LongSeqConstante 999
    if {$Zoom!="" && $Zoom<0} { set LongSeqConstante $Zoom; set Zoom 1 }
    if {$Zoom==""} { set Zoom 1 }
    set LongSeqConstante [expr -$LongSeqConstante]
    #si elle est negative on l'oublie

    set LongInconnu   300
    if {[OuiOuNon "Do I keep frame 1 for all ORFs ?" 0]} {
	set LongIntergene  99
    } else {
	set LongIntergene 100
    }
    set i [expr ($LongIntergene/3)*3]
    set ADN [string repeat "n" $i]
    set TDN [string repeat "n" $i]
    set RAC [string repeat "n" $i]
    set LesNouvellesBornesSansMutants {}
    foreach PAB $Liste {
	if {[EstUnPABMute $PAB]} {
#	    lappend LesNouvellesBornes "$PAB $Bornes"
	    continue
	}
	set FiNucTFA "$Rep/$PAB"
	if {[file exists $FiNucTFA]} {
	    set SeqNuc [QueLaSequenceDuFichierTFA $FiNucTFA]
	} else {
	    set SeqNuc [string repeat "n" $LongInconnu]
	}
	set Orient [Box $PAB orient]
	if {$Orient=="F"} {
	    set SeqF $SeqNuc
	} else {
	    set SeqF [NucToReverseAndComplementNuc $SeqNuc]
	}
	append ADN $SeqF

	if {$LongSeqConstante<0} {
	    set LongSeq [string length $SeqNuc]
	    set LongSeq [expr round($LongSeq * $Zoom)]
	} else {
	    set LongSeq $LongSeqConstante
	}
	if {[regexp "prottfa" $Rep]} { set LongSeq [expr $LongSeq*3] }
	if {$Max!=""} { set LongSeq [Maxi $Max $LongSeq] }

	set LongReste [expr (3-$LongSeq%3)%3]

	set Fin   [expr $i+$LongSeq]
	set Debut [incr i]

	Box $PAB debut $Debut
	Box $PAB fin   $Fin
	set Bornes "$Debut $Fin $Orient"
	lappend LesNouvellesBornesSansMutants "$PAB $Bornes"
	set i $Fin
	append ADN [string repeat "n" $LongReste]
	incr i $LongReste
	append ADN [string repeat "n" $LongIntergene]
	incr i $LongIntergene
    }
    set TDN "n[NucToReverseNuc $ADN]"
    set RAC "n[NucToReverseAndComplementNuc $ADN]"

    set LesNouvellesBornes {} 
    foreach Ligne $LesNouvellesBornesSansMutants {
	lappend LesNouvellesBornes $Ligne
	scan $Ligne "%s" Nom
	foreach Mutant [LesMutantsDe $Nom "Names"] {
	    regsub $Nom $Ligne $Mutant  LigneMutant
	    lappend LesNouvellesBornes $LigneMutant
	}
    }

    if {[string equal $GetWhat "GetBornesDesPABs"]} { return $LesNouvellesBornes }
    
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    if { ! [OuiOuNon "Do I modify $FichierBornes ?"]} { return "" }
    
    Garde $FichierBornes
    set FBPab [SauveLesLignes $LesNouvellesBornes dans $FichierBornes]
    return $FBPab

}

proc AffecteLesVariablesDeLaListe {Liste {Level 1}} {

#    JeMeSignale
    foreach Ligne $Liste {
	if { ! [regexp {^(Text|List|Array): } $Ligne]} { continue }
	set Type ""
	set NomDeVariable ""
	scan $Ligne "%s %s" Type NomDeVariable
	if { ! [regexp -nocase {^[a-z_]} $NomDeVariable] } { continue }
	lappend LesVariables $NomDeVariable
	regsub {\(} $NomDeVariable {\\(} NomDeVariable
	regsub {\)} $NomDeVariable {\\)} NomDeVariable
	regsub "^$Type $NomDeVariable " $Ligne "" Ligne
#	puts stderr [string range $Ligne 0 80]
	
	set Commande ""
	switch $Type {
	    "Text:"  {
		set Commande "set $NomDeVariable $Ligne"
	    }
	    "List:"  {
		set Commande "set $NomDeVariable [ListSeria $Ligne]"
	    }
	    "Array:" {
		regsub "^_x_" $NomDeVariable "" NomDeVariable
		set Commande "array set $NomDeVariable [ListSeria $Ligne]"
	    }
	}
	if {[regexp bonjour $Commande]} { Espionne $Commande }
	if {$Commande!=""} { uplevel $Level $Commande }
    }
    return $LesVariables

}

proc AffecteLesVariablesDeReponse {Reponse {Level ""}} {

    if {$Level==""} {
	set Level 2
    } else {
	if { ! [regexp {^\#} $Level]} {
	    incr Level
	}
    }
    return [AffecteLesVariablesDeLaListe [split $Reponse "\n"] $Level]

}

proc AffecteListeDesPABs {Liste} {

    global MemoAffecteListeDesPABs
    global ListeDesPABs

    if {$Liste=="Reset"} {
	if { ! [info exists MemoAffecteListeDesPABs]} {
	    return [ListeDesPABs]
	}
	set ListeDesPABs $MemoAffecteListeDesPABs
	unset MemoAffecteListeDesPABs
	return $ListeDesPABs
    }

    if { ! [info exists MemoAffecteListeDesPABs]} {
	set MemoAffecteListeDesPABs [ListeDesPABs]
    }
    set ListeDesPABs $Liste
    return $ListeDesPABs    

}

proc Affichage {LesNoms aProteines aTabSeq} {

    global GpeCases 2_cluster LesCases
    upvar $aProteines Proteines
    upvar $aTabSeq TabSeq
    set w .text
    frame $w
    pack $w -expand yes -fill both

    #boutons
    frame $w.buttons
    pack $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.sortie -text Exit -command "exit"
    pack $w.buttons.sortie -side left -expand 1

    #fenetre centrale
    frame $w.text -bd 2
    text $w.text.seq -relief sunken -bd 2 -xscrollcommand "$w.scrollx set" -yscrollcommand "$w.scrolly set"  -height 60 -wrap none
    text $w.text.noms -relief sunken -bd 2 -yscrollcommand "$w.scrolly set" -height 60 -width 20 -wrap none
    scrollbar $w.scrolly -command "CoupleYview $w.text.noms $w.text.seq"
    scrollbar $w.scrollx -orient horiz -command "$w.text.seq xview" 
    pack $w.scrolly -side right -fill y
    pack $w.scrollx -side bottom -expand yes -fill x
    pack $w.text -expand yes -fill both
    
    #ecriture des noms
    set chaine_noms ""
    foreach ns $LesNoms {
	append chaine_noms "$ns \n"
    }
    $w.text.noms insert end $chaine_noms

    #ecriture des sequences
    $w.text.seq tag configure c00 -background bisque1
    $w.text.seq tag configure c01 -background honeydew2
    $w.text.seq tag configure c02 -background LemonChiffon1
    $w.text.seq tag configure c03 -background MistyRose2
    $w.text.seq tag configure c04 -background azure2
    $w.text.seq tag configure c10 -background SlateGray1
    $w.text.seq tag configure c11 -background SteelBlue1
    $w.text.seq tag configure c12 -background PaleTurquoise2
    $w.text.seq tag configure c13 -background SkyBlue1
    $w.text.seq tag configure c14 -background aquamarine1
    $w.text.seq tag configure c20 -background gold1
    $w.text.seq tag configure c21 -background RosyBrown1
    $w.text.seq tag configure c22 -background Indianred1
    $w.text.seq tag configure c23 -background LightSalmon1
    $w.text.seq tag configure c24 -background LightPink1
    $w.text.seq tag configure c30 -background MediumPurple1
    $w.text.seq tag configure c31 -background orchid1
    $w.text.seq tag configure c32 -background VioletRed1
    $w.text.seq tag configure c33 -background HotPink2
    $w.text.seq tag configure c34 -background thistle3
    $w.text.seq tag configure c40 -background white
    $w.text.seq tag configure c41 -background yellow
    $w.text.seq tag configure c42 -background blue
    $w.text.seq tag configure c43 -background grey
    $w.text.seq tag configure c44 -background orange
    #test
    $w.text.seq tag configure c05 -background red
    $w.text.seq tag configure c15 -background red
    $w.text.seq tag configure c25 -background red
    $w.text.seq tag configure c35 -background red
    $w.text.seq tag configure c06 -background green
    $w.text.seq tag configure c16 -background green
    $w.text.seq tag configure c26 -background green
    $w.text.seq tag configure c36 -background green


    $w.text.seq delete 0.0 end 
    foreach ns $LesNoms {
	foreach Case $LesCases gpe_case $GpeCases {
	    set Deb [expr [lindex $Case 0]-1]
	    set Fin [expr [lindex $Case end]-1]
	    $w.text.seq insert end [join [lrange [set Proteines($ns)] $Deb $Fin] ""] "c[set TabSeq($ns)]$gpe_case"
	}
	$w.text.seq insert end \n
    }

    #coloration
    pack $w.text.seq -side right -expand yes -fill both
    pack $w.text.noms -side left -fill y

}

proc AffichageHDACroises {aLesPABs aBilan LesFamilles LesOrgCibles} {

    upvar $aLesPABs LesPABs
    upvar $aBilan Bilan
    global RepertoireDuGenome
    set lFam 0
    foreach Fam $LesFamilles {
	set lFam [Maxi [string length $Fam] $lFam]
    }
    incr lFam 1
    set lOrg 0
    foreach Org $LesOrgCibles {
	set lOrg [Maxi [string length $Org] $lOrg]
    }
    incr lOrg 1
    set BlancFam [string repeat " " $lFam]
    set BlancOrg [string repeat " " $lOrg]

    append Sortie $BlancOrg
    foreach Fam $LesFamilles {
	append Sortie [format "%${lFam}s" [llength [set LesPABs($Fam)]]]
    }
    append Sortie "\n" $BlancOrg
    foreach Fam $LesFamilles {
	append Sortie [format "%${lFam}s" $Fam]
    }
    append Sortie "\n"
    foreach Org $LesOrgCibles {
	append Sortie [format "%${lOrg}s" $Org]
	set NbHitsTblastn 0
	foreach Fam $LesFamilles {
	    set Tblastn [lindex [set Bilan($Fam,$Org)] 0]
	    puts "$Org $Fam Tblastn: $Tblastn"
	    set Couleur [CouleurHDACroises [set Bilan($Fam,$Org)]]
	    if {$Tblastn} {
		incr NbHitsTblastn 
	    }
	    if {$Couleur=="O"} {
		append Sortie [format "%${lFam}s" $Tblastn]
	    } else {
		append Sortie [format "%${lFam}s" $Couleur]
	    }
	}
	append Sortie  "      $NbHitsTblastn" "\n" $BlancOrg
	set NbHitsBlastp 0
	foreach Fam $LesFamilles {
	    set Blastp [lindex [set Bilan($Fam,$Org)] 1]
	    if {$Blastp} {
		incr NbHitsBlastp
	    }
	    if {$Couleur=="O"} {
		append Sortie [format "%${lFam}s" $Blastp] 
	    } else {
		append Sortie $BlancFam
	    }
	}
	append Sortie "      $NbHitsBlastp" "\n" $BlancOrg
	set NbJaunes 0
	foreach Fam $LesFamilles {
	    set Jaune [lindex [set Bilan($Fam,$Org)] 2]
	    if {$Jaune} {
		incr NbJaunes
	    }
	    if {$Couleur=="O"} {
		append Sortie [format "%${lFam}s" $Jaune] 
	    } else {
		append Sortie $BlancFam
	    } 
	}
	append Sortie "      $NbJaunes" "\n"
    }
    AfficheVariable $Sortie "GrandeLargeurSansRien" 
    EcritFichier [split $Sortie "\n"] "$RepertoireDuGenome/fiches/bilanHDAcroises_tableau"

}

proc Affiche {Page {Maniere ""} {NomDuFichierOrigine ""}} {

    return [AfficheVariable $Page $Maniere $NomDuFichierOrigine]

}

proc AfficheAliEnPage {Page LigneAccess Fichier} {


    return [AfficheVariable [PartieSegAli $Page $LigneAccess] " " $Fichier]

}

proc AfficheAliInOut {Nom} {

    global RepertoireDuGenome

    set Fichier "$RepertoireDuGenome/aliinout/$Nom"
    if { ! [file exists $Fichier]} { return "" } 
    set Fen [AfficheFichier $Fichier]
    return [Illumine "accepted" $Fen]

}

proc AfficheArbre {Arbre} {

    global AfficheArbreIndent
    if {[EstUneFeuille $Arbre]} {
	Espionne "[string repeat " " $AfficheArbreIndent]+ $Arbre"
	return
    }
    set A1 [lindex $Arbre 0] 
    set D1 [lindex $Arbre 1] 
    set A2 [lindex $Arbre 2] 
    set D2 [lindex $Arbre 3] 
    Espionne "[string repeat " " $AfficheArbreIndent]+ $D1"
    incr AfficheArbreIndent
    AfficheArbre $A1
    incr AfficheArbreIndent -1
    Espionne "[string repeat " " $AfficheArbreIndent]+ $D2"
    incr AfficheArbreIndent
    AfficheArbre $A2
    incr AfficheArbreIndent -1

}

proc AfficheAskAddSeq {aTAddS} {

    global TAddS LNDG

    array set TAddS $aTAddS

    if {[winfo exists .affas]} {
	raise .affas

	return
    }

    set w .affas
    toplevel $w
    wm title $w "Add Sequences"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix
    grid columnconfig $w 0 -weight 1
    grid rowconfig    $w 0 -weight 1

    frame $w.f
    grid $w.f -row 0 -column 0 -sticky news
    grid columnconfig $w.f 0 -weight 1

    # row index iR
    set iR 0
    set wf "$w.f"
    label $wf.title  -text "Add sequences to the alignment"  -font "Helvetica 16 bold"  -relief groove
    grid $wf.title -row $iR -column 0 -sticky w -padx 5 -pady {5 15}
    
    label $wf.lbfile  -text "Sequences File name : "  -relief flat
    grid $wf.lbfile -row [incr iR] -column 0 -sticky w -padx 5 -pady {15 5}
    frame $wf.ffile
    grid $wf.ffile -row [incr iR] -column 0 -sticky ew -padx 5
    grid columnconfig $wf.ffile 0 -weight 1
    entry $wf.ffile.enfile  -background white  -font [$wf.lbfile cget -font]  -textvariable TAddS(File)
    button $wf.ffile.bufile  -text "Browse"  -background cyan  -command "set TAddS(File) \[DemandeEtOuvreFichier *\]"
    grid $wf.ffile.enfile -row 0 -column 0 -sticky ew
    grid $wf.ffile.bufile -row 0 -column 1 -sticky e -padx {20 0}

    # align Sequences
    label $wf.lbali  -relief flat  -text "The imported sequences should be "
    grid $wf.lbali -row [incr iR] -column 0 -sticky w -padx 5 -pady {15 5}
    frame $wf.fali
    grid $wf.fali -row [incr iR] -column 0 -sticky ew -padx 5
    grid columnconfig $wf.fali {0 1} -weight 1
    radiobutton $wf.fali.align  -text "aligned against the alignment (using MAFFT)"  -relief flat  -value 1  -variable TAddS(Align)
    radiobutton $wf.fali.alone  -text "kept unchanged"  -relief flat  -value 0  -variable TAddS(Align)
    grid $wf.fali.align -row 0 -column 0 -sticky w -padx {30 5}
    grid $wf.fali.alone -row 0 -column 1 -sticky w
    if {[llength $LNDG] > 1} {
	checkbutton $wf.chkc  -text "keep existing clusters"  -relief flat  -onvalue 1  -offvalue 0  -variable TAddS(KeepClus)
	grid $wf.chkc -row [incr iR] -column 0 -sticky w -padx {30 5}
    }

    # what to do with seqs already here ?
    label $wf.lbdup  -text "If a sequence name already exists in the alignment,"
    grid $wf.lbdup -row [incr iR] -column 0 -sticky w -pady {15 5} -padx 5
    frame $wf.fck
    grid $wf.fck -row [incr iR] -column 0 -sticky ew -padx 5
    grid columnconfig $wf.fck {0 1} -weight 1
    radiobutton $wf.fck.copy  -text "create a copy"  -relief flat  -value 0  -variable TAddS(CopySkip)
    radiobutton $wf.fck.skip  -text "skip the imported sequence"  -relief flat  -value 1  -variable TAddS(CopySkip)
    grid $wf.fck.copy -row 0 -column 0 -sticky w -padx {30 5}
    grid $wf.fck.skip -row 0 -column 1 -sticky w

    # assign cluster
    label $wf.lbclu  -text "The imported sequences should be :"  -relief flat
    grid $wf.lbclu -row  [incr iR] -column 0 -sticky w -pady {15 5} -padx 5
    radiobutton $wf.bott  -relief flat  -text "inserted at the bottom of the alignment"  -value "end"  -variable TAddS(Position)
    grid $wf.bott  -row [incr iR] -column 0 -sticky w -padx {30 5}
    frame $wf.faf
    grid $wf.faf -row [incr iR] -column 0 -sticky ew -padx {30 5} 
    #grid columnconfig $wf.faf 0 -weight 1
    radiobutton $wf.faf.afse  -relief flat  -text "inserted after this sequence :"  -value "afterseq"  -variable TAddS(Position)
    set Lseqnames [list]
    foreach n $::LNOrdali {
	if {$n ne ""} {lappend Lseqnames $n}
    }
    set width [PlusLongEltDe $Lseqnames]
    ttk::combobox $wf.faf.cbs  -state readonly  -background white  -width $width -values $Lseqnames
    bind $wf.faf.cbs <> {set TAddS(seqInsert) [%W get]}
    grid $wf.faf.afse -row 0 -column 0 -sticky w
    grid $wf.faf.cbs  -row 0 -column 1 -sticky w -padx {10 0}

    if {[llength $LNDG] > 1} {
	radiobutton $wf.clus  -relief flat  -text "inserted into their corresponding cluster \naccording to sequences identity"  -justify left  -value "cluster"  -variable TAddS(Position)
	grid $wf.clus  -row [incr iR] -column 0 -sticky w -padx {30 5}
    }
    
    frame $wf.but 
    grid $wf.but -row [incr iR] -column 0 -sticky ew -pady {40 10} -padx 5
    grid columnconfig $wf.but {0 1} -weigh 1

    button $wf.but.dis  -background red  -text "Dismiss"  -command [list FinAfficheAskAddSeq dismiss]
    button $wf.but.ok  -background green1  -text " OK "  -command [list FinAfficheAskAddSeq ok]
    grid $wf.but.dis -row 0 -column 0 -sticky w -padx 5
    grid $wf.but.ok  -row 0 -column 1 -sticky e -padx 5

    bind $wf.but.ok  "$wf.but.ok invoke"

    FenetreAuCentre $w

    $wf.but.ok configure -default active
    focus $wf.but.ok

    tkwait window $w


    if {$TAddS(ok)} {
	return [array get TAddS]
    } else {
	return ""
    }

}

proc AfficheAssocie {Source CoRepertoire {Maniere ""}} {

    global RepertoireDuGenome

    regsub -nocase {\.[a-z_]*$} $Source "" Source

    set Nom [file tail $Source]
    set CheminSource [file dirname $Source]
    set CheminCheminSource [file dirname $CheminSource]
    set RepSource [file tail $CheminCheminSource]
    regsub "$RepSource" $Source "$CoRepertoire" Nouveau

    Wup "If Nouveau not found we try CoRepertoire/Nom"
    foreach Nouveau [list $Nouveau "$RepertoireDuGenome/$CoRepertoire/$Nom"] {
	if { ! [file exists $Nouveau]} { continue }
	if {$Maniere=="" && [regexp "bla" $CoRepertoire]} {
	    set Maniere "AvecAligneursAvecSegAlignement"
	}
	return [AfficheFichier $Nouveau $Maniere]
    }
    FaireLire "Sorry, no file associated to\n$Source $CoRepertoire"
    return ""

}

proc AfficheBallastDuBlastP {FichierBlastP Nom} {

    set TexteBallast [Ballast $FichierBlastP [RepertoireDeTravail] "" "TexteSansFichier"]
    return [AfficheVariable $TexteBallast  "AvecGrapheAvecSegAlignementAvecAligneurs" $Nom]

}

proc AfficheBarreBoutons {} {

    global OrdEtcDir OrdMeth ListeOrdMeth FrmToolBar NomFenetreOrdali

    set FrmToolBar $NomFenetreOrdali.tbb
    frame $FrmToolBar
    grid $FrmToolBar -row 1 -column 0 -sticky ew -padx 5

    set frm $FrmToolBar

    set fbopen [file join $OrdEtcDir open.gif]
    image create photo bopen -file $fbopen
    button $frm.btopen -image bopen -command OuvrirFichierAlignementDansOrdali

    set fbclose [file join $OrdEtcDir file_close.gif]
    image create photo bclose -file $fbclose
    button $frm.btclose -image bclose -command FermeFichier

    set freload [file join $OrdEtcDir file_reload.gif]
    image create photo breload -file $freload
    button $frm.btreload -image breload -command ReLoadFichier

    set fsave [file join $OrdEtcDir "save.gif"]
    image create photo bsave -file $fsave
    button $frm.btsave -image bsave -command SauveLAlignement

    set fbcut [file join $OrdEtcDir "cut.gif"]
    image create photo bcut -file $fbcut
    button $frm.btcut -image bcut -command CutLesNoms

    set fbcopy [file join $OrdEtcDir "copy.gif"]
    image create photo bcopy -file $fbcopy
    button $frm.btcopy -image bcopy -command CopyLesNoms

    set fbpaste [file join $OrdEtcDir "paste.gif"]
    image create photo bpaste -file $fbpaste
    button $frm.btpaste -image bpaste -command PasteLesNoms

    set fbinsp [file join $OrdEtcDir "inssep.gif"]
    image create photo binsp -file $fbinsp
    button $frm.btinsp -image binsp -command "AjouteSpaceSeq"

    set fbrems [file join $OrdEtcDir "remsep.gif"]
    image create photo brems -file $fbrems
    button $frm.btrems -image brems -command "EnleveSpaceSeq"

    set fboverview [file join $OrdEtcDir overview.gif]
    image create photo boverview -file $fboverview
    button $frm.btoverview -image boverview -command AfficheOverview

    set fbannote [file join $OrdEtcDir "notepad.gif"]
    image create photo bannote -file $fbannote
    #button $frm.btannote -image bannote -command [list ChangeMode annotation]

    set fbfind [file join $OrdEtcDir "find.gif"]
    image create photo bfind -file $fbfind
    button $frm.btfind -image bfind -command [list ChangeMode search]

    set fbprint [file join $OrdEtcDir "print.gif"]
    image create photo bprint -file $fbprint
    button $frm.btprint -image bprint -command PrintSetup

    set fbtree [file join $OrdEtcDir "buildtree.gif"]
    image create photo btree -file $fbtree
set ::WOrdali(BtnArbres) $frm.bttree
    button $frm.bttree -image btree -command [list ChangeMode arbres]

    set fbclus [file join $OrdEtcDir "cluster.png"]
    image create photo bclus -file $fbclus
    button $frm.btclus -image bclus -command [list ChangeMode arbres]

    set fbeditor [file join $OrdEtcDir "editor.gif"]
    image create photo beditor -file $fbeditor
    button $frm.bteditor -image beditor -command [list ChangeMode seqlab]

    set fbo3d [file join $OrdEtcDir "ord3d.gif"]
    image create photo bo3d -file $fbo3d
    button $frm.bto3d -image bo3d -command [list ChangeMode superpose]

    grid $frm.btopen     -row 0 -column  0 -sticky w
    grid $frm.btclose    -row 0 -column  1 -sticky w
    grid $frm.btreload   -row 0 -column  2 -sticky w
    grid $frm.btsave     -row 0 -column  3 -sticky w 
    grid $frm.btprint    -row 0 -column  4 -sticky w -padx {1 5}

    grid $frm.btcut      -row 0 -column  5 -sticky w -padx {5 1}
    grid $frm.btcopy     -row 0 -column  6 -sticky w
    grid $frm.btpaste    -row 0 -column  7 -sticky w -padx {1 5}

    grid $frm.btclus     -row 0 -column  8 -sticky w -padx {5 1}
    grid $frm.btinsp     -row 0 -column  9 -sticky w
    grid $frm.btrems     -row 0 -column 10 -sticky w
    grid $frm.bttree     -row 0 -column 11 -sticky w
    grid $frm.bteditor   -row 0 -column 12 -sticky w
    grid $frm.bto3d      -row 0 -column 13 -sticky w -padx {1 5}

    grid $frm.btfind     -row 0 -column 14 -sticky w -padx {5 1}
    grid $frm.btoverview -row 0 -column 15 -sticky w
    #grid $frm.btannote   -row 0 -column 16 -sticky w

#    grid rowconfig    $frm 0   -weight 0
#    grid columnconfig $frm all -weight 1
#    grid columnconfig $frm {16 17} -weight 1
#    grid columnconfig $frm 16 -minsize $wdt

    setTooltip $frm.btopen     "Open"
    setTooltip $frm.btclose    "Close"
    setTooltip $frm.btreload   "Reload"
    setTooltip $frm.btsave     "Save"
    setTooltip $frm.btcut      "Cut"
    setTooltip $frm.btcopy     "Copy"
    setTooltip $frm.btpaste    "Paste"
    #setTooltip $frm.btundo     "Edit backward"
    #setTooltip $frm.btredo     "Edit forward"
    setTooltip $frm.btinsp     "Add separator"
    setTooltip $frm.btrems     "Remove separator"
    setTooltip $frm.btoverview "Alignment overview"
    #setTooltip $frm.btannote   "Annotate alignment"
    setTooltip $frm.btfind     "Search"
    setTooltip $frm.btprint    "Print"
    setTooltip $frm.btclus     "Cluster mode"
    setTooltip $frm.bttree     "Tree building"
    setTooltip $frm.bteditor   "Alignment editor"
    setTooltip $frm.bto3d      "3D display"

    #update idletasks

    #MesCouleurs $frm

    return

}

proc AfficheBarreMac {} {

    global NomFenetreOrdali FrmVues WOrdali NomTextSeq ListeDesMacs

    set wv $NomFenetreOrdali.fmac
    set FrmVues $wv
    frame $FrmVues
    grid $FrmVues -row 2 -column 0 -sticky ew -padx 5 -pady {1 3}
    
    frame $wv.fcx
    grid $wv.fcx -row 0 -column 0 -sticky w
    label $wv.fcx.lmac  -text "Alignment "  -justify left  -anchor w
    set WOrdali(combomac) $wv.fcx.cmac
    ttk::combobox $wv.fcx.cmac  -background white  -state readonly  -width 40  -textvariable ::Defauts(NmMacCourant)
    bind $WOrdali(combomac) <> [list MiseAJourMac]

    grid $wv.fcx.lmac -row 0 -column 0 -sticky w -padx {1 2}
    grid $wv.fcx.cmac -row 0 -column 1 -sticky w -padx {2 5}
    
    frame $wv.fbt
    grid $wv.fbt -row 0 -column 1 -sticky e
    set WOrdali(BoutZones) $wv.fbt.bzon
    button $wv.fbt.bzon  -text "View Zone"  -bg cyan  -command [list AfficheZonesClustering]
    button $wv.fbt.binf  -text "Info"  -bg white  -command [list InfosDuMac]
    button $wv.fbt.bsav  -text "Overwrite"  -bg green1  -command [list SauveLeMac 0]
    button $wv.fbt.bres  -text "Reset"  -bg cyan  -command [list MiseAJourMac reset]
    button $wv.fbt.bkip  -text "New !"  -bg green1  -command [list SauveLeMac 1]
    
    grid $wv.fbt.bzon -row 0 -column 0 -sticky e -padx {5 1}
    grid $wv.fbt.binf -row 0 -column 1 -sticky e -padx {1 5}
    grid $wv.fbt.bres -row 0 -column 2 -sticky e -padx {5 1}
    grid $wv.fbt.bsav -row 0 -column 3 -sticky e
    grid $wv.fbt.bkip -row 0 -column 4 -sticky e

    grid rowconfigure $wv 0   -weight 0
    grid columnconfig $wv all -weight 1

    return

}

proc AfficheBarreMenus {} {

    global Defauts NomFenetreOrdali Toggle FrmMenu
    global MenuFile MenuEdit MenuView MenuGroups MenuDisplay MenuStructure Toggle
    
    set bgm [set Defauts(BackAppli)]
    
    set w $NomFenetreOrdali
    set mb $w.menuBar
    menu $mb -tearoff 0
    
    set mfi $w.menuBar.file
    set med $w.menuBar.edit
    set mvw $w.menuBar.view
    set mse $w.menuBar.sequence
    set mal $w.menuBar.alignement
    set mst $w.menuBar.structure
    set mto $w.menuBar.tools
    set min $w.menuBar.info
    set mhe $w.menuBar.help
    
    set MenuFile       $mfi
    set MenuEdit       $med
    set MenuView       $mvw
    set MenuSequence   $mse
    set MenuAlignement $mal
    set MenuStructure  $mst
    set MenuTools      $mst
    
    # create sub-menus
    menu $mfi -activebackground "#0083ffff0000" -foreground black
    menu $med -activebackground "#0083ffff0000" -foreground black
    menu $mvw -activebackground "#0083ffff0000" -foreground black
    menu $mse -activebackground "#0083ffff0000" -foreground black
    menu $mal -activebackground "#0083ffff0000" -foreground black
    menu $mst -activebackground "#0083ffff0000" -foreground black
    menu $mto -activebackground "#0083ffff0000" -foreground black
    menu $min -activebackground "#0083ffff0000" -foreground black
    menu $mhe -activebackground "#0083ffff0000" -foreground black

    # Create the munu bar itself
    $mb add cascade -label File -menu $mfi -underline 0
    $mb add cascade -label Edit -menu $med -underline 0
    $mb add cascade -label View -menu $mvw -underline 0
    $mb add cascade -label Sequences -menu $mse -underline 0
    $mb add cascade -label Alignment -menu $mal -underline 0
    $mb add cascade -label Structures -menu $mst -underline 0
    $mb add cascade -label Tools -menu $mto -underline 0
    $mb add cascade -label " ? " -menu $min -underline 1
    $mb add cascade -label Help -menu $mhe -underline 0

    # 
    # Menu file
    set mfiti "$mfi.typefilein"
    menu $mfiti -tearoff 0 -background $bgm
    $mfiti add command -label "a MSF file" -command "OuvrirFichierAlignementDansOrdali MSF"
    $mfiti add command -label "a Macsim/XML file" -command "OuvrirFichierAlignementDansOrdali XML"
    $mfiti add command -label "a TFA file" -command "OuvrirFichierAlignementDansOrdali TFA"
    $mfiti add command -label "a Clustal ALN file" -command "OuvrirFichierAlignementDansOrdali ALN"
    $mfiti add command -label "a RSF file" -command "OuvrirFichierAlignementDansOrdali RSF"
    $mfi add cascade -label "Open ..." -menu $mfiti -underline 0 -background $bgm
    $mfi add command -label "Save" -command "SauveLAlignement"
    # cascade "save as ..."
    set mfito "$mfi.typefileout"
    menu $mfito -tearoff 0
    $mfito add command -label "MSF file" -command "SauveLAlignement MSF JLeSauveAs"
    $mfito add command -label "Macsim/XML file" -command "SauveLAlignement XML JLeSauveAs"
    $mfito add command -label "TFA file" -command "SauveLAlignement TFA JLeSauveAs"
    $mfito add command -label "ALN (ClustalW) file" -command "SauveLAlignement ALN JLeSauveAs"
    $mfito add command -label "ORD file" -command "SauveLAlignement ORD JLeSauveAs"
    $mfi add cascade -label "Save as ..." -menu $mfito -underline 0
    # save window as ..
    set mfitw "$mfi.windowfileout"
    menu $mfitw -tearoff 0 -background $bgm
    $mfitw add command -label "a MSF file" -command "CreeLAlignementDeLaFenetre MSF"
    $mfitw add command -label "a TFA file" -command "CreeLAlignementDeLaFenetre TFA"
    $mfi add cascade -label "Save window as" -menu $mfitw -underline 0
    $mfi add command -label "Close" -command "FermeFichier"
    $mfi add separator
    $mfi add command -label "Add sequences ..." -command "AjouteSeqs"
    $mfi add command -label "Add PDB ..." -command "FenetreAjoutePDB"
    $mfi add separator
    $mfi add command -label "Print" -command "PrintSetup"
    $mfi add separator
    $mfi add command -label "Quit Ordalie" -command "AdieuOrdali"

    # Menu edition
    $med add command -label "Cut"   -accelerator "Ctrl-x" -command "CutLesNoms"
    $med add command -label "Copy"  -accelerator "Ctrl-c" -command "CopyLesNoms"
    $med add command -label "Paste" -accelerator "Ctrl-v" -command "PasteLesNoms"
    $med add separator
    $med add command -label "Preferences" -command "AffichePreferences2"

    # Menu View
    $mvw add command -label "Bigger font" -accelerator "Ctrl-plus" -command "TailleFonte +2"
    $mvw add command -label "Smaller font" -accelerator "Ctrl-minus" -command "TailleFonte -2"
    $mvw add separator
    $mvw add command -label "Open Log Console" -command "ToggleAuLog"
    # output log cascade
    set mvwol $mvw.outlog
    menu $mvwol -tearoff 0 -background $bgm
    $mvwol add command -label "HTML" -command {AuLog LOutput HTML}
    $mvwol add command -label "Text" -command {AuLog LOutput Text}
    $mvw add cascade -label "Output Log as ..." -menu $mvwol
    $mvw add separator
    $mvw add command -label "Toggle Full-screen mode" -command "ToggleFullScreen"
    $mvw add separator

    set Toggle(AllSeqs) [set Defauts(ToggleAllSeqs)]
    set Toggle(ToolBar) [set Defauts(ToggleToolBar)]
    set Toggle(Feature) [set Defauts(ToggleFeature)]
    set Toggle(Scores)  [set Defauts(ToggleScores)]
    set Toggle(AuLog)   [set Defauts(ToggleAuLog)]
    set Toggle(ColRes)  [set Defauts(ToggleColRes)]

    $mvw add checkbutton -label "Show/Hide ToolBar" -variable Toggle(ToolBar) -command ToggleToolbar
    $mvw add checkbutton -label "Show/Hide Scores" -variable Toggle(Scores) -command ToggleScores
    $mvw add checkbutton -label "Show/Hide Features" -variable Toggle(Feature) -command ToggleFeature

    # Menu sequence
    set msena "$mvw.nomsaff"
    $mse add cascade -label "Names as " -menu $msena -underline 0 -background $bgm
    menu $msena -tearoff 0 -background [set Defauts(BackAppli)]
    $msena add command -label "Seq. Name" -command "AutresNomsAff seqname"
    $msena add command -label "Accession Number" -command "AutresNomsAff access"
    $msena add command -label "Bank Id" -command "AutresNomsAff bid"
    $msena add command -label "Gen.Sp" -command "AutresNomsAff gen.sp"
    $mse add separator
    $mse add command -label "Identity Mode" -command "ChangeMode donnepci" -accelerator "Shift I"
    $mse add command -label "Search Mode"  -command "ChangeMode search"
    $mse add separator
    $mse add command -label "retrieve Seq. info" -command "FetchInfosSeqs"
    $mse add command -label "Browse Seq. info" -command "MontreInfoSeq"
    $mse add command -label "Edit Seq. info" -command "EditInfoSeq"
    $mse add command -label "Sequence Vrp" -command "Ordali_Vrp"
    $mse add separator
    $mse add checkbutton -label "Show/Hide Phylum" -variable Defauts(AffPhy) -command "ColorieNomsSelonPhylum"
    $mse add checkbutton -label "Show/Hide group colors" -variable Defauts(AffGrp) -command "ColorieNomsSelonGroupes"
    $mse add checkbutton -label "Show/Hide Sec. Str." -variable Defauts(AffSS) -command ToggleSecStr

    #
    # Menu alignement
    $mal add command -label "Create Macsims ..." -command CreateAndDisplayMacsims
    $mal add separator
    $mal add command -label "Clusters Mode" -command "ChangeMode cluster" -accelerator "Shift G"
    $mal add command -label "Add separator" -command "AjouteSpaceSeq"
    $mal add command -label "Remove separator" -command "EnleveSpaceSeq"
    $mal add command -label "Remove All separators" -command "NettoieAffichage"
    $mal add command -label "Names Of Clusters" -command "NamesOfClusters"
    $mal add separator
    $mal add command -label "Alignment Overview" -command "AfficheOverview"
    $mal add command -label "Alignment Barcode" -command BarcodeAlignment
    $mal add command -label "Features Summary" -command "FeatureSummary"
    #$mal add command -label "Annotate Alignment" -command "ChangeMode annotation"
    $mal add separator
    $mal add command -label "Feature Mode" -command "ChangeMode feature"
    $mal add command -label "Alignment Editor" -command "ChangeMode seqlab" -accelerator "Shift E"
    
    $mal add command -label "Conservation Mode" -command "ChangeMode conservation" -accelerator "Shift C"
    $mal add command -label "Tree Mode" -command "ChangeMode arbres" -accelerator "Shift T"
    $mal add command -label "Features Editor" -command "ChangeMode feateditor"
    $mal add separator
    $mal add command -label "Toggle physicochem. col." -command "ToggleCouleursResidues"

    #
    # Menu structure
    $mst add command -label "Superpose Structures" -command [list ChangeMode superpose]
    $mst add separator
    $mst add command -label "Display Structures" -command "VisualiseStructure"
    $mst add separator
    $mst add command -label "Color Sec. Str by conservation" -command "ColorieSSSelonConservation"
    $mst add separator
    $mst add command -label "Save PDB" -command "SauveLesPDB"
    
    # menu tools
    $mto add command -label "Profile identity" -command IdentityProfileGUI

    # Menu info
    $min add command -label "About Ordali" -command "InfosSurOrdali"

    # Menu help
    $mhe add command -label "Help on Ordali" -command "LanceDoc"

    [winfo toplevel $NomFenetreOrdali] configure -menu $mb

    return

}

proc AfficheBilanXHda {{Selection ""}} {


    global RepertoireDuGenome
 
    Wup "Affiche parmi la liste des bilans, ceux voulus"
   
    set RepBilan "$RepertoireDuGenome/bilan_xhda"
    
    if {$Selection==""} {
	foreach FichierBilan [glob -nocomplain "$RepBilan/*"] {
	    set LeBilan [File tail $FichierBilan]
	    lappend LesBilans $LeBilan
	}
	set Selection [ChoixDesPresents [lsort $LesBilans]]
    }
    set Selection [join $Selection "\n"]

    return [CreeEtAfficheUnBilanHDACroises $Selection]

}

proc AfficheBootstrap {AId n} {


    set t   [set ::Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return}

    foreach e [$t children $n] {
	AfficheBootstrap $AId $e
    }
    if {$n eq "root"} {return}

    set PAD  [set ::Abr($AId,PAD)]
    set ir   [$t get $n IdRot]
    set Lbox [$PAD bbox $ir]

    MarqueBootstrap $AId $n $Lbox $ir

    return

}

proc AfficheBoutonsAnnotation {} {

    global FrmBouton Anno

    if {[TypeAli] eq "pasdali"} {return}

    set wp "${FrmBouton}.fanno"
    frame $wp -relief sunken  -bd 2
    grid $wp -row 0 -column 1 -sticky ew

    grid rowconfig    $wp all       -weight 0
    grid columnconfig $wp {0 1 3 4} -weight 0
    grid columnconfig $wp 2         -weight 1

    set Lcol [set ::Couleurs(Stock)]
    set Anno(fgcol) [lindex $Lcol 0]
    set Anno(NtagCou) ""
    set wcol [PlusLongEltDe $Lcol]
    ttk::combobox $wp.ccol  -state readonly  -width $wcol  -values $Lcol  -textvariable Anno(fgcol)
    bind $wp.ccol <> [list ChangeCouleurAnnotation]
    button $wp.bnew  -text " New "  -bg cyan  -command [list NouvelleAnnotation]
    button $wp.bedt  -text "Edit"  -bg cyan  -command [list EditeAnnotation]
    set Anno(WText) $wp.txt
    text $wp.txt  -width 10 -height 3  -font "Helvetica 10"  -bg white  -yscrollcommand "$wp.scr set"  -state normal
    scrollbar $wp.scr  -width 8  -command "$wp.txt yview "
    button $wp.badd  -bg yellow  -text " Add "  -command [list AjouteAnnotation %W]
    button $wp.bdel  -bg red  -text "Delete"  -command [list DetruitAnnotation]
    button $wp.bret  -bg green1  -text "Done !"  -command [list QuitteAnnotation]
    
    grid $wp.ccol -row 0 -column 0 -columnspan 2 -sticky w
    grid $wp.bnew -row 1 -column 0 -sticky w -ipadx 2
    grid $wp.bedt -row 1 -column 1 -sticky w -ipadx 2
    grid $wp.txt  -row 0 -column 2 -rowspan 3 -sticky news 
    grid $wp.scr  -row 0 -column 3 -rowspan 3 -sticky ns 
    grid $wp.badd -row 0 -column 4 -sticky e
    grid $wp.bdel -row 1 -column 4 -sticky e
    grid $wp.bret -row 2 -column 4 -sticky e

    $::NomTextSeq tag configure selZone -background lightblue

    tkwait window $wp
    
    return

}

proc AfficheBoutonsArbres {} {

    global Defauts FrmBouton NomTextSeq ZoneTree ZoneSelect ListeTypesDeFeatures WOrdali

    # pre-definit variables
    set lg [LongueurAlignement]
    set lgd [expr {double($lg)}]
    set Defauts(TreeNBoot) [expr {int($lgd*1.15)}]
    while {$Defauts(TreeNBoot) % 10} {
	incr Defauts(TreeNBoot)
    }

    # mise en place boutons
    set w $FrmBouton
    set ws $w.treesel
    frame $ws -relief sunken -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5

    frame $ws.falcl
    grid $ws.falcl -row 0 -column 0 -sticky nw -padx 5 -pady 5

    label $ws.falcl.lbf  -anchor w  -justify left  -text "Feature :"
    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }
    set wdt [PlusLongEltDe $ListeTypesDeFeatures]
    set LesTypes [linsert $ListeTypesDeFeatures 0 "None"]
    set Tree(Combo) $ws.falcl.cft
    ttk::combobox $ws.falcl.cft  -state readonly  -width $wdt  -background white  -values $LesTypes  -textvariable TreeFeat
    set WOrdali(Tree,SelectAll) $ws.falcl.sal 
    $ws.falcl.cft current 0
    bind $ws.falcl.cft <> [list ChangeFeature %W]
    button $ws.falcl.cle  -text "Clear"  -background white  -command "DeselectToutesLesColonnes "
    button $ws.falcl.sal  -text "Select All"  -background cyan  -command "SelectionneToutesColonnes"

    grid $ws.falcl.lbf -row 0 -column 0 -sticky ew
    grid $ws.falcl.cft -row 0 -column 1 -sticky ew
    grid $ws.falcl.cle -row 1 -column 0 -sticky ew
    grid $ws.falcl.sal -row 1 -column 1 -sticky ew
    grid columnconfig $ws.falcl 1 -weight 1

    frame $ws.frmsst
    grid $ws.frmsst -row 0 -column 1 -sticky nw -padx 5 -pady 5
    checkbutton $ws.frmsst.pdb  -text "with PDB seq"  -anchor w -justify left  -variable Defauts(PDBTree)  -onvalue 1  -offvalue 0
    checkbutton $ws.frmsst.gap  -text "pairwise/global"  -anchor w -justify left  -variable Defauts(TypeGapTree)  -onvalue "pairwise"  -offvalue "global"
    button $ws.frmsst.loe  -text "Load Tree"  -background white  -command LoadUnArbre
    grid $ws.frmsst.pdb -row 0 -column 0 -sticky ew
    grid $ws.frmsst.gap -row 1 -column 0 -sticky ew
    grid $ws.frmsst.loe -row 0 -column 1 -sticky ew
    grid columnconfig $ws.frmsst 0 -weight 1

    frame $ws.fbtp
    grid $ws.fbtp -row 0 -column 2 -sticky nw -padx 5 -pady 5
    set WOrdali(Tree,Bootstrap) $ws.fbtp.ynbtp 
    checkbutton $ws.fbtp.ynbtp  -text "Bootstrap"  -anchor w -justify left  -variable Defauts(TreeBoot)  -onvalue 1  -offvalue 0
    entry $ws.fbtp.nbbtp  -justify right  -width 5 -bg white  -textvariable Defauts(TreeNBoot)
    grid $ws.fbtp.ynbtp -row 0 -column 0 -sticky ew
    grid $ws.fbtp.nbbtp -row 1 -column 0 -sticky ew
    grid columnconfig $ws.fbtp 0 -weight 1

    set wc "$ws.control"
    frame $wc
    grid $wc -row 0 -column 3 -sticky ne -padx 5 -pady 5
    set WOrdali(Tree,Draw) $wc.fin
    button $wc.fin  -text "Draw"  -background green1  -command "CalculeUnArbre"
    button $wc.dis  -text "Return"  -background orange  -command "destroy $ws"
    grid $wc.fin -row 0 -column 0 -sticky ew
    grid $wc.dis -row 1 -column 0 -sticky ew
    grid columnconfig $wc 0 -weight 1

    grid columnconfig $ws all -weight 1

    # bindings
    BindModeSelection
    if {! [info exists ZoneTree]} {
	set ZoneTree {}
    } else {
	set ZoneSelect $ZoneTree
    }
    AfficheZonesSelectionnees $ZoneTree
    StockPosition

    MesCouleurs $FrmBouton

    tkwait window $ws

    $NomTextSeq tag remove slct 1.0 end

    return

}

proc AfficheBoutonsCherche {{prevMode ""}} {

    global FrmBouton Chrc

    # setup window pour AfficheModeCherche
    set Chrc(NbrOccus)  "0 found"
    set Chrc(Motif)    ""
    set Chrc(LOccus)   {}
    set Chrc(IdxMotif) {}
    set Chrc(prevMode) $prevMode

    set ws "$FrmBouton.fsearch"
    frame $ws -relief sunken -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5

    frame $ws.fse
    label $ws.fse.lbl1  -text "Search a sequence motif"  -justify left -anchor w
    label $ws.fse.lbl2  -text "Motif :"  -anchor w -justify left
    entry $ws.fse.ent  -background white  -width 20  -textvariable Chrc(Motif)
    button $ws.fse.sea  -text "Search"  -background yellow  -command "ChercheMotif"
    label $ws.fse.lbnb  -anchor w -justify right  -textvariable Chrc(NbrOccus)
    grid $ws.fse.lbl1 -row 0 -column 0 -columnspan 2 -sticky nw
    grid $ws.fse.lbl2 -row 1 -column 0 -sticky nw
    grid $ws.fse.ent  -row 1 -column 1 -sticky nw 
    grid $ws.fse.sea  -row 0 -rowspan 2 -column 2 -sticky nsw
    grid $ws.fse.lbnb -row 0 -rowspan 2 -column 3 -sticky nsw -ipadx 5
    grid $ws.fse -row 0 -column 0 -sticky nw -pady 2 -padx 2 -ipadx 5
    grid columnconfig $ws.fse 1 -weight 1

    frame $ws.frbt
    button $ws.frbt.next  -text "Find Next"  -background cyan  -command ChercheMotifSuivant
    button $ws.frbt.dismiss  -text "Return"  -background orange  -command "FinCherche"
    grid $ws.frbt.next    -row 0 -column 0 -sticky nsw
    grid $ws.frbt.dismiss -row 0 -column 1 -sticky nse
    grid $ws.frbt -row 0 -column 1 -sticky news -padx {20 2}
    grid columnconfig $ws.frbt 1   -weight 1
    grid rowconfig    $ws.frbt all -weight 1
    grid columnconfig $ws 1 -weight 1 

    bind $ws.fse.ent  {$FrmBouton.fsearch.fse.sea invoke}

    MesCouleurs $FrmBouton
    focus $ws.fse.ent

    tkwait window $ws

    return

}

proc AfficheBoutonsClusters {} {

    global FrmBouton NomTextSeq ZoneClusterisation ListeTypesDeFeatures Clus

    set ws $FrmBouton.clusel
    frame $ws  -relief sunken  -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5
    grid columnconfig $FrmBouton 1 -weight 1

    set Clus(Title) "Give a Title to your clustering"
    set Clus(ShowSeqOut) 1
    set Clus(NewEntry) 1

    # Features/Clear/Select All
    frame $ws.fs
    grid $ws.fs -row 0 -column 0 -sticky w -padx 5 -pady 5
    label $ws.fs.lbf  -anchor w -justify left  -text "Feature :"
    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }
    set LesTypes [linsert $ListeTypesDeFeatures 0 "None"]
    set wdt [PlusLongEltDe $LesTypes]
    set Clus(Combo) $ws.fs.cft
    ttk::combobox $ws.fs.cft  -state readonly  -width $wdt  -background white  -values $LesTypes  -textvariable ClusFeat
    button $ws.fs.sal  -text "Select All"  -background cyan  -command [list SelectionneToutesColonnes]
    button $ws.fs.cle  -text "Clear"  -background white  -command [list DeselectToutesLesColonnes]
    grid $ws.fs.lbf -row 0 -column 0 -sticky we
    grid $ws.fs.cft -row 0 -column 1 -sticky we
    grid $ws.fs.cle -row 1 -column 0 -sticky we
    grid $ws.fs.sal -row 1 -column 1 -sticky we
    grid columnconfig $ws.fs 0 -weight 1
    
    # Criterion
    frame $ws.fv
    grid $ws.fv -row 0 -column 1 -sticky e -padx 5 -pady 5
    label $ws.fv.lctr  -text "Criterions : "  -relief flat  -anchor w -justify right
    menubutton $ws.fv.mctr  -relief raised  -text "Choose ..."  -direction above  -menu $ws.fv.mctr.criteres
    menu $ws.fv.mctr.criteres -tearoff 0
    foreach f {"% identity" "length" "hydrophobicity" "pI" "aa composition"} {
	$ws.fv.mctr.criteres add checkbutton -label "$f" -variable Clus(LCrit,$f) -onvalue 1 -offvalue 0 
    }
    set lfdm "Life Domain"
    set Clus(LCrit,$lfdm) 0
    $ws.fv.mctr.criteres add separator
    $ws.fv.mctr.criteres add command -label "Life Domain" -command {set lfdm "Life Domain" ; set ::Clus(LCrit,$lfdm) [expr {! [set ::Clus(LCrit,$lfdm)]}] ; update}
    # clustering methods
    label $ws.fv.lmet  -text "Method : "  -relief flat  -anchor w -justify right
    set Lmeth [list "kmeans / DPC" "hierarchic / secator" "mixture model / AIC" "mixture model / BIC"]
    ttk::combobox $ws.fv.cmet  -state readonly  -values $Lmeth  -textvariable Clus(Method)
    #bind $ws.fv.cmet <> NouveauClustering

    grid $ws.fv.lctr -row 0 -column 0 -sticky e
    grid $ws.fv.mctr -row 0 -column 1 -sticky ew
    grid $ws.fv.lmet -row 1 -column 0 -sticky e
    grid $ws.fv.cmet -row 1 -column 1 -sticky ew
    
    # Run
    button $ws.run  -text "Compute"  -background yellow  -command NouveauClustering
    grid $ws.run -row 0 -column 2 -rowspan 2 -sticky ns -padx 5 -pady 5

    # controls
    frame $ws.fc 
    grid $ws.fc -row 0 -column 3 -sticky e -padx 5 -pady 5
    grid columnconfig $ws.fc 0 -weight 1
    button $ws.fc.ori  -text "Reset"  -background green1  -command [list DefinitionGroupes integral]
    button $ws.fc.noc  -text "No Clusters"  -background yellow  -command [list NouveauClustering nogroups]

    grid $ws.fc.ori -row 0 -column 0 -sticky we -padx 5
    grid $ws.fc.noc -row 1 -column 0 -sticky ns -padx 5

    # Dismiss/New/Overwrite
    frame $ws.fb    
    grid $ws.fb -row 0 -column 4 -sticky e -padx 5 -pady 5
    grid columnconfig $ws.fb 0 -weight 1
    button $ws.fb.cnm  -text "Clusters\nNames"  -bg cyan  -command {NamesOfClusters}
    button $ws.fb.fin  -text " Save "  -background green1  -command GardeClustering
    button $ws.fb.dis  -text "Return"  -background green1  -command [list QuitteModeClusters $ws]
    grid $ws.fb.cnm -row 0 -column 0 -rowspan 2 -sticky ns -padx 5
    grid $ws.fb.fin -row 0 -column 1 -sticky ew -padx 5
    grid $ws.fb.dis -row 1 -column 1 -sticky ew -padx 5

    grid columnconfig $ws all -weight 1
    grid rowconfig    $ws all -weight 0

    $ws.fs.cft current 0
    bind $ws.fs.cft <> [list ChangeFeature %W]

    #update idletasks

    # bindings
    if {! [info exists ZoneClusterisation]} {set ZoneClusterisation ""}
    AfficheZonesSelectionneesCluster
    StockPosition
    BindModeSelection

    # Tags Specifiques
    $::NomNomSeq tag configure SLock -foreground black -background grey

    MesCouleurs $FrmBouton
    
    tkwait window $ws

    BindModeNormal
    
    return

}

proc AfficheBoutonsConservation {} {

    global FrmBouton Cons Defauts

    set ws $FrmBouton.cons
    frame $ws -relief sunken -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5
    grid columnconfig $ws 1 -weight 1

    set wx "$ws.chx"
    frame $wx
    grid $wx -row 0 -column 0 -sticky nw -padx 2 -pady {2 5}
    grid columnconfig $wx 1 -weight 1
    
    label $wx.lmth  -text "Method : "  -anchor w -justify left
    set ListeOrdMeth [list "Threshold" "Liu" "Mean Distances" "Vector Norm" "Multi" "BILD"]
    set wdt [PlusLongEltDe $ListeOrdMeth]
    ttk::combobox $wx.smth  -width $wdt  -background white  -state readonly  -textvariable Cons(Method)  -values $ListeOrdMeth
    $wx.smth current 0
    bind $wx.smth <> [list set ::Cons(Title) ""]
    label $wx.ltt  -text "Title : "  -anchor w -justify left 
    set Cons(Entry) $wx.tit
    entry $wx.tit  -bg white  -textvariable Cons(Title)  -width 20
    
    set Cons(OnlyGlobal) 0
    checkbutton $wx.glo  -text "only global"  -anchor w -justify left  -relief flat  -onvalue 1  -offvalue 0  -variable Cons(OnlyGlobal)
    
    set Cons(PDB) 0
    checkbutton $wx.pdb  -text "include PDB"  -anchor w -justify left  -relief flat  -variable Cons(PDB)  -onvalue 1  -offvalue 0
    
    grid $wx.lmth -row 0 -column 0 -sticky new
    grid $wx.smth -row 0 -column 1 -sticky new
    grid $wx.ltt  -row 1 -column 0 -sticky new
    grid $wx.tit  -row 1 -column 1 -sticky new
    grid $wx.pdb  -row 0 -column 2 -sticky new
    grid $wx.glo  -row 1 -column 2 -sticky new
    
    set wc "$ws.control"
    frame $wc
    grid $wc -row 0 -column 1 -sticky nsw -padx 2 -pady 2
    grid columnconfig $wc 2   -weight 1
    button $wc.run  -text "Compute"  -bg yellow  -command [list LanceCalculConservation]
    set Cons(Show) [set ::Toggle(Scores)]
    update
    checkbutton $wc.shh  -text "Show scores "  -anchor w -justify left  -relief flat  -onvalue 1  -offvalue 0  -variable Cons(Show)
    label $wc.lal  -text "Show : "  -anchor w -justify left
    set Cons(ConsCou) "None"
    set Cons(ListeCons) [list "None"]
    set wdt [PlusLongEltDe $Cons(ListeCons)]
    set Cons(ComboSel) $wc.call
    ttk::combobox $wc.call  -width $wdt  -background white  -state readonly  -textvariable Cons(ConsCou)  -values $Cons(ListeCons)
    $wc.call current 0
    bind $wc.call <> [list ChangeConservation]
    
    grid $wc.run  -row 0 -rowspan 2 -column 0 -sticky nsw -ipadx 5
    grid $wc.lal  -row 0 -column 1 -sticky nw 
    grid $wc.call -row 0 -column 2 -sticky new 
    grid $wc.shh  -row 1 -column 1 -columnspan 2 -sticky new -ipadx 5
    grid rowconfig    $wc all -weight 1

    # frame save/return
    set wb "$ws.sds"
    frame $wb
    grid $wb -row 0 -column 2 -sticky nse -padx 2 -pady 2
    button $wb.save  -text " Save "  -bg green1  -command [list SauveConservation]
    button $wb.dis  -text "Return"  -background green1  -command [list QuitteModeConservation $ws]
    grid $wb.save -row 0 -column 0 -sticky new
    grid $wb.dis  -row 1 -column 0 -sticky new

    update idletasks
    trace add variable Cons(PDB) write PrendPDBDansPilier
    trace add variable Cons(Show) write ToggleScores
    trace add variable Cons(ConsCou) write ToggleScores

    tkwait window $ws

    return

}

proc AfficheBoutonsFeateditor {} {

    global FrmBouton ListeTypesDeFeatures EFeat TabSF TSFori LTFori NomTextSeq

    if {! [ModeI]} {return}

    if {[info exists TabSF]} {
	# TSFori est une sauvegarde !!
	array set TSFori [array get TabSF]
	set LTFori $ListeTypesDeFeatures
    } else {
	array set TSFori {}
	set LTFori [list]
    }

    set wb $FrmBouton
    set ws "$wb.select"
    frame $ws -relief sunken -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5 -padx 5

    # Utilise features presentes
    label $ws.lbf  -anchor w  -justify left  -text "Feature :"
    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }
    set EFeat(FTypes) [linsert $ListeTypesDeFeatures 0 "None"]
    set wdt [PlusLongEltDe $ListeTypesDeFeatures]
    set EFeat(FeatCombo) $ws.cft
    ttk::combobox $ws.cft  -state readonly  -width $wdt  -background white  -values $EFeat(FTypes)  -textvariable EFeat(Feat)
    $ws.cft current 0
    bind $ws.cft <> [list ChangeFeatureForEditing %W]
    button $ws.bnw  -text "Clear selection"  -bg cyan -anchor w  -command [list CmdsMenuFeatures "clearsel"]
    button $ws.bdf  -text "Delete Feature"  -bg yellow  -command {DeleteFeature all ""}

    grid $ws.lbf -row 0 -column 0 -sticky ew
    grid $ws.cft -row 0 -column 1 -sticky ew
    grid $ws.bnw -row 1 -column 0 -sticky ew -columnspan 2
    grid $ws.bdf -row 0 -column 2 -sticky ew -padx 3

    # frame boutons fichier feat/fet summary
    frame $wb.fffs
    set wff $wb.fffs
    grid $wff -row 0 -column 2 -rowspan 2 -sticky nws -padx 10 -pady 5
    button $wff.ff  -text "Load feat. file"  -background white  -command [list ReadRawFeatureFile]
    button $wff.sm  -text "Feature summary"  -background cyan  -command [list FeatureSummary]

    grid $wff.ff -row 0 -column 0 -sticky nsw -padx 5
    grid $wff.sm -row 0 -column 1 -sticky nse -padx 5

    # frame boutons OK / dismiss
    frame $wb.fokdm
    set wok $wb.fokdm
    grid $wok -row 0 -column 3 -sticky ne -padx 5 -pady 5
    button $wok.ok  -text " Save "  -background green1  -command [list RetourEditFeatures save]
    button $wok.dismiss  -text "Cancel"  -background red  -command [list RetourEditFeatures dismiss]

    grid $wok.ok      -row 0 -column 0 -sticky ew
    grid $wok.dismiss -row 1 -column 0 -sticky ew
    grid columnconfig $wok all -weight 0
    grid rowconfig    $wok all -weight 1

    # bindings pour edit features
    # menu contextuel
    BindingsFeatEditor
    set EFeat(LItemSel) [list]
    set EFeat(ContextMenu) $NomTextSeq.ctxm
    CreateContextMenuFeature 
    bind $NomTextSeq  [list ShowContextMenuFeat]

    # Selection de zones 
    $NomTextSeq configure -state normal
    $NomTextSeq tag configure slct -background LightGrey -foreground black
    $NomTextSeq configure -state disabled

    # some inits
    set EFeat(BindInit) [bindtags $NomTextSeq]
    set EFeat(Score) ""
    set EFeat(Note) ""
    set EFeat(Color) ""
    set EFeat(Name) ""
    set EFeat(Lx1x2) ""
    set EFeat(ZoneX1) ""
    set EFeat(ZoneX2) ""
    set EFeat(LItemSel) ""

    tkwait window $ws

    return

}

proc AfficheBoutonsFeatures {} {

    global FrmBouton FrmBtnFea ListeTypesDeFeatures Defauts OrdEtcDir NomNomSeq NomTextSeq EtatBtnFeat

    if {! [ModeI]} {return}

    set law $FrmBouton
    set wb "$FrmBouton.lesbt"
    set FrmBtnFea $wb
    frame $wb -relief sunken -bd 2
    grid $wb -row 0 -column 1 -sticky news -pady 5

    set LFeature [lsort -unique $ListeTypesDeFeatures]
    if {"Clear" ni $LFeature} {
	lappend LFeature "Clear"
    }

    set NFeat [llength $LFeature]
    set wdt [winfo reqwidth $NomTextSeq]
    set lg 0
    foreach f $LFeature {
	incr lg [expr {[string length $f] + 2}]
    }

    set Fs [font measure BtnFeatFont "Z"]
    set Npl [expr {floor($wdt/(($lg/$NFeat)*$Fs))}]

    set i 0 ; set j 0
    foreach f $LFeature {
	set flo [string tolower $f]
	regsub -all " " $flo "" fnsp
	if {[regexp {^Score\-} $f]} {
	    set bg yellow
	} else {
	    set bg green1
	}

	button ${wb}.$fnsp  -background $bg  -foreground black  -font BtnFeatFont  -text "$f"  -command [list ColorieSelonFeature $f $wb.$fnsp]
	grid $wb.$fnsp  -padx 2 -pady 1  -row $i -column $j  -sticky ew
	update

	incr j
	if {$j >= $Npl} {
	    set j 0
	    incr i
	}
	if {! [info exists EtatBtnFeat($wb.$fnsp)]} {
	    set EtatBtnFeat($wb.$fnsp) 0
	} elseif {[EtatDuBouton "$wb.$fnsp"]} {
	    EnfonceBtnFeature $wb.$fnsp
	}
    }
    grid rowconfig    $wb all -weight 0 -minsize 0
    grid columnconfig $wb all -weight 1 -minsize 0
    update

    lassign [grid bbox $wb] t a x y 
    lassign [grid size $wb] c r 
    if {$c == 1} {set c 2}
    set wdt [winfo width $FrmBtnFea]
    set px [expr {floor(($wdt-$x)/($c-1)/2)}]
    foreach e [grid slaves $wb] {
	#grid configure $e -ipadx $px
	if {[$e cget -text] eq "Clear"} {$e configure -background white}
    }

    MesCouleurs $FrmBouton

    return

}

proc AfficheBoutonsOrdali {} {

    global boutordali boutreport FrmBouton menustatus

    if {! [ModeI]} {return}

    set wb "$FrmBouton.flab"
    frame $wb -relief sunken -bd 2
    grid $wb -row 0 -column 1 -sticky news -pady 5

    set boutordali $wb.label

    label $wb.label  -textvariable menustatus  -relief sunken  -bd 2  -anchor w  -bg white  -justify left  -font "Helvetica 12"
    grid $wb.label -row 0 -column 0 -sticky ew -padx 2 -pady 1
    grid columnconfig $wb all -weight 1 -minsize 0

    set menustatus "Hummm ..... \nEverything seems OK ....\nLet's go !"

    MesCouleurs $FrmBouton

    return

}

proc AfficheBoutonsPCI {} {

    global LNOrdali FrmBouton OrdEtcDir nsq1 nsq2 pciLbl pl1Lbl pl2Lbl LesPCI ListeTypesDeFeatures ZoneSelect ZonePCI

    if {[TypeAli] eq "pasdali"} {return}

    set LNoms "Select"
    foreach n $LNOrdali {
	if {$n ne ""} {lappend LNoms $n}
    }
    set LMx [PlusLongEltDe $LNoms]

    set wp "$FrmBouton.fpci"
    frame $wp -relief sunken  -bd 2
    grid $wp -row 0 -column 1 -sticky ew -pady 5
    grid columnconfig $wp {1 2 3} -weight 1

    frame $wp.falcl
    label $wp.falcl.lbf  -anchor w  -justify left  -text "Feature :"
    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }
    set EPCI(FTypes) [linsert $ListeTypesDeFeatures 0 "None"]
    set wdt [PlusLongEltDe $EPCI(FTypes)]
    set EPCI(FeatCombo) $wp.falcl.cft
    ttk::combobox $wp.falcl.cft  -state readonly  -width $wdt  -background white  -values $EPCI(FTypes)  -textvariable EPCI(Feat)
    $wp.falcl.cft current 0
    bind $wp.falcl.cft <> [list ChangeFeatureForEditing %W]
    button $wp.falcl.cle  -text "Clear"  -background white  -command "DeselectToutesLesColonnes "
    button $wp.falcl.sal  -text "Select All"  -background cyan  -command "SelectionneToutesColonnes"
    grid $wp.falcl.lbf -row 0 -column 0 -sticky ew
    grid $wp.falcl.cft -row 0 -column 1 -sticky ew
    grid $wp.falcl.cle -row 1 -column 0 -sticky ew
    grid $wp.falcl.sal -row 1 -column 1 -sticky ew
    grid $wp.falcl -row 0 -column 0 -sticky nw -padx 2
    grid columnconfig $wp.falcl 1 -weight 1

    button $wp.bdo  -background yellow  -text "Compute"  -command [list ComputeIdentity]
    grid $wp.bdo -row 0 -column 1 -sticky nsw -padx 5 -pady 5

    set nsq1 [lindex $LNoms 0]
    set nsq2 [lindex $LNoms 0]
    set pciLbl "Identity :"
    set pl1Lbl "length 1 :"
    set pl2Lbl "length 2 :"

    frame $wp.fse
    ttk::combobox $wp.fse.sq1  -background white  -width $LMx -height 10  -state readonly  -values $LNoms  -textvariable nsq1
    $wp.fse.sq1 current 0
    bind $wp.fse.sq1 <> {CherchePCI %W}
    ttk::combobox $wp.fse.sq2  -background white  -width $LMx -height 10  -state readonly  -values $LNoms  -textvariable nsq2
    $wp.fse.sq2 current 0
    bind $wp.fse.sq2 <> {CherchePCI %W}
    label $wp.fse.lpci  -textvariable pciLbl  -justify left  -anchor w
    label $wp.fse.lpl1  -textvariable pl1Lbl  -justify left  -anchor w
    label $wp.fse.lpl2  -textvariable pl2Lbl  -justify left  -anchor w
    grid $wp.fse.sq1  -row 0 -column 0 -sticky ew
    grid $wp.fse.sq2  -row 1 -column 0 -sticky ew
    grid $wp.fse.lpci -row 0 -column 1 -padx 5 -sticky ew
    grid $wp.fse.lpl1 -row 1 -column 1 -padx 5 -sticky ew
    grid $wp.fse.lpl2 -row 2 -column 1 -padx 5 -sticky ew

    grid $wp.fse -row 0 -column 2 -sticky nw -padx 5 -pady 5

    frame $wp.frbt
    grid rowconfig $wp.frbt 0 -weight 1
    button $wp.frbt.sum  -text "Summary"  -bg cyan  -command [list SummaryPCI]
    button $wp.frbt.dis  -text "Return"  -background orange  -command "DetruitBoutonsOrdali"
    grid $wp.frbt.sum -row 0 -column 0 -sticky nsew
    grid $wp.frbt.dis -row 0 -column 1 -sticky nsew
    grid $wp.frbt -row 0 -column 3 -sticky nse -padx 5 -pady 5

    BindModeSelection
    if {! [info exists ZonePCI]} {
	set ZonePCI {}
    } else {
	set ZoneSelect $ZonePCI
    }
    AfficheZonesSelectionnees $ZonePCI
    StockPosition

    tkwait window $FrmBouton.fpci

    return

}

proc AfficheBoutonsSeqLab {} {

    global FrmBouton

    if {! [ModeI]} {return}

    set wb $FrmBouton.sl
    frame $wb  -relief sunken  -bd 2
    grid $wb -row 0 -column 1 -sticky news -pady 5

    frame $wb.frmgp
    grid $wb.frmgp -row 0 -column 0 -sticky w -padx 2

    button $wb.frmgp.clear  -text "Clear"  -background white  -width 10  -command "ClearSelections"
    button $wb.frmgp.ungroup  -text "Ungroup"  -background cyan  -width 10  -command "DegroupeLesSequences"
    button $wb.frmgp.group  -text "Group"  -background cyan  -width 10  -command "GroupeLesSequences"
    grid $wb.frmgp.clear   -row 0 -column 0 -rowspan 2 -sticky news -padx {2 5} 
    grid $wb.frmgp.group   -row 0 -column 1 -sticky ew
    grid $wb.frmgp.ungroup -row 1 -column 1 -sticky ew
    grid columnconfig $wb.frmgp 0   -weight 1
    grid rowconfig    $wb.frmgp all -weight 0

    frame $wb.frmnet
    grid $wb.frmnet -row 0 -column 1 -sticky w -padx 2
    button $wb.frmnet.col  -text "Rem col gap"  -background pink  -width 10  -command RemColGap
    checkbutton $wb.frmnet.ulock  -text "Lock/Unlock Seq"  -anchor w -justify left  -variable ::LockSeqs -onvalue 1  -offvalue 0  -command "EtatLockSeqs"
    grid $wb.frmnet.ulock  -row 0 -column 0 -sticky ew
    grid $wb.frmnet.col    -row 1 -column 0 -sticky ew
    grid columnconfig $wb.frmnet 0 -weight 1

    frame $wb.frmsv
    grid $wb.frmsv -row 0 -column 2 -sticky e -padx 2
    button $wb.frmsv.search  -text "Search Motif"  -background yellow  -command [list ChangeMode "search"]
    button $wb.frmsv.save  -text "temp. save"  -background cyan  -command SauveTempSeqlab
    set bdismiss $wb.frmsv.dismiss
    set breturn  $wb.frmsv.return
    button $wb.frmsv.return  -text "Save & Return"  -background orange  -command [list RetourFenetreOrdali $wb save $breturn]
    button $wb.frmsv.dismiss  -text "Cancel"  -background red  -command "RetourFenetreOrdali $wb dismiss $bdismiss"
    grid $wb.frmsv.save    -row 0 -column 0 -sticky ew -padx {2 20}
    grid $wb.frmsv.search  -row 1 -column 0 -sticky ew -padx {2 20}
    grid $wb.frmsv.return  -row 0 -column 1 -sticky ew
    grid $wb.frmsv.dismiss -row 1 -column 1 -sticky ew
    grid columnconfig $wb.frmsv all -weight 1
    grid rowconfig    $wb.frmsv all -weight 0
    
    grid columnconfig $wb all -weight 1
    grid rowconfig    $wb all -weight 1 
    
    MesCouleurs $FrmBouton

    update idletasks
    
    tkwait window $wb

    return

}

proc AfficheBoutonsSuperposition {} {

    global FrmBouton NomTextSeq ListeTypesDeFeatures

    if {! [ModeI]} {return}

    set w $FrmBouton
    set ws "$w.select"
    frame $ws -relief sunken -bd 2
    grid $ws -row 0 -column 1 -sticky news -pady 5

    frame $ws.falcl
    grid $ws.falcl -row 0 -column 0 -sticky w -padx 2

    label $ws.falcl.lbf  -anchor w  -justify left  -text "Feature :"
    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }
    set wdt [PlusLongEltDe $ListeTypesDeFeatures]
    set LesTypes [linsert $ListeTypesDeFeatures 0 "None"]
    ttk::combobox $ws.falcl.cft  -state readonly  -width $wdt  -background white  -values $LesTypes  -textvariable SupFeat
    $ws.falcl.cft current 0
    bind $ws.falcl.cft <> [list ChangeFeature %W]
    button $ws.falcl.cle  -text "Clear"  -background white  -command "DeselectToutesLesColonnes "

    button $ws.falcl.sal  -text "Select All"  -background cyan  -command "SelectionneToutesColonnes"
    grid $ws.falcl.lbf -row 0 -column 0 -sticky ew
    grid $ws.falcl.cft -row 0 -column 1 -sticky ew
    grid $ws.falcl.cle -row 1 -column 0 -sticky ew
    grid $ws.falcl.sal -row 1 -column 1 -sticky ew
    grid columnconfig $ws.falcl 1 -weight 1

    frame $ws.frmsst
    grid $ws.frmsst -row 0 -column 1 -sticky nw -padx 2 -pady 2
    # buttons for helix and sheet
    button $ws.frmsst.hel  -text "All Helices"  -background red  -width 10  -command [list SelectSSDeType helix]
    button $ws.frmsst.she  -text "All Strands"  -background green1  -width 10  -command [list SelectSSDeType sheet]
    button $ws.frmsst.fin  -text "Superpose"  -background yellow  -width 9 -height 2  -command "FaitSuperposition 1"
    button $ws.frmsst.dpl  -text "Display"  -background green1  -width 7 -height 2  -command "VisualiseStructure"
    grid $ws.frmsst.hel -row 0 -column 0 -sticky new
    grid $ws.frmsst.she -row 1 -column 0 -sticky new -ipadx 5
    grid $ws.frmsst.fin -row 0 -rowspan 2 -column 1 -sticky news -ipady 5
    grid $ws.frmsst.dpl -row 0 -rowspan 2 -column 2 -sticky news -ipady 5
    grid $ws.frmsst -row 0 -column 1 -sticky news -padx 2 -pady 2 

    button $ws.dis  -text "Return"  -background orange  -command "DismissSuper"
    grid $ws.dis -row 0 -column 2 -rowspan 2 -sticky news -padx 2 -pady 2 

    grid rowconfig $ws 0 -weight 0
    grid columnconfig $ws all -weight 1

    # bindings
    BindModeSelection

    $NomTextSeq tag bind Hel  [list SelectLaFeature @%x,%y]
    $NomTextSeq tag bind H31  [list SelectLaFeature @%x,%y]
    $NomTextSeq tag bind She  [list SelectLaFeature @%x,%y]
    $NomTextSeq tag bind Tur  [list SelectLaFeature @%x,%y]

    AfficheZonesSelectionneesSuper
    StockPosition

    tkwait window $ws

    $NomTextSeq tag remove slct 1.0 end
    $NomTextSeq tag remove Marque 1.0 end

    return

}

proc AfficheChaqueSegmentDuBlastN {Nom {FichierBlast ""} {Selection ""}} {

    global RepertoireDuGenome

    Wup "Shows only these from Selection, all if empty"

    if {$FichierBlast==""} { set FichierBlast "$RepertoireDuGenome/blastn/$Nom" }
    if { ! [file exists $FichierBlast]} { return "" }

    set SeuilDuBlastN 0.001
    set LesVoulus {}
    if {$Selection!=""} {
	foreach Ligne [split $Selection "\n"] {
	    scan $Ligne "%s" Voulu
	    lappend LesVoulus $Voulu
	}
	if {$LesVoulus=={}} { return "" }
	set SeuilDuBlastN 9999.9
    }

    set LesSegments [ChaqueSegmentDuBlastN $FichierBlast $SeuilDuBlastN $LesVoulus]
    set Fen [AfficheVariable [join $LesSegments "\n"] "GrandeLargeur" "ChaqueSegmentDuBlast_$Nom"]
    if { ! [regexp "blastn" $FichierBlast]} { return "" }
    set B [BoutonneLaFenetre $Fen "Locs on Chromos\nGenScan output" ""]
    bind $B <1> "VoirLesLocalisationsDuCDNA $Nom \[selection get\]"
    bind $B     "AfficheGenscanDuContig \[selection get\]"
    return 

}

proc AfficheCompare {{FichierCompare ""} {FichierTFA1 Absent} {FichierTFA2 Absent} {NbPointsMinDansDiag 10}} {

    global RepertoireDuGenome
    if {$FichierCompare == ""} {
	set FichierCompare [ButineArborescence All [pwd]]
    } elseif {![file exists $FichierCompare]} {
	return ""
    }
    if {![file exists $FichierTFA2]} {set FichierTFA2 "Absent"}
    if {![file exists $FichierTFA1]} {set FichierTFA1 "Absent"}

    if {$FichierTFA1 != "Absent" && $FichierTFA2 != "Absent"} {
	set Seq1    [QueLaSequenceDuTFA     $FichierTFA1]
	set Seq2    [QueLaSequenceDuTFA     $FichierTFA2]
    }
    
    set BordX 100
    set BordY 100
    set ResVerti [winfo screenwidth .]
    set HauteurFenetre   [expr ($ResVerti*1.0)*2/3]
    set LargeurFenetre   $HauteurFenetre
    set HauteurAffichage [expr ($HauteurFenetre - 2*$BordY ) * 1.0]
    set LargeurAffichage $HauteurAffichage
    
    set TailleMaxNomQuery 100
    
    LitFichierCompare TabCompare $FichierCompare
    set DQ1          [set TabCompare(DebutQuery1) ]
    set FQ1          [set TabCompare(FinQuery1)   ]
    set DQ2          [set TabCompare(DebutQuery2) ]
    set FQ2          [set TabCompare(FinQuery2)   ]
    set Points       [set TabCompare(Points)      ]
    set Input1       [set TabCompare(Input1)      ]
    set Input2       [set TabCompare(Input2)      ]
    if {[info exists TabCompare(Description1)]} {
	set NameQuery1 [set TabCompare(Description1)]
    } else {
	set NameQuery1 $Input1
    }
    if {[info exists TabCompare(Description2)]} {
	set NameQuery2 [set TabCompare(Description2)]
    } else {
	set NameQuery2 $Input2
    }
    if {[info exists TabCompare(Window)    ]} {set Window     [set TabCompare(Window)    ]}
    if {[info exists TabCompare(Stringency)]} {set Stringency [set TabCompare(Stringency)]}
    if {[info exists TabCompare(WordSize)  ]} {set WordSize   [set TabCompare(WordSize)  ]}
    if {[info exists TabCompare(Alphabet)  ]} {set Alphabet   [set TabCompare(Alphabet)  ]} 
    set LesPoints [set TabCompare(LesPoints)]

    set LargeurNuage   [expr (abs($FQ1 - $DQ1)+1)*1.0]
    set HauteurNuage   [expr (abs($FQ2 - $DQ2)+1)*1.0]

    if {$LargeurNuage <= $HauteurNuage} {
	set Rapport [expr $LargeurAffichage/$LargeurNuage]
	set LargeurMax $LargeurFenetre
	set HauteurMax [expr $HauteurNuage*$Rapport + 2*$BordY]
    } else {
	set Rapport [expr $HauteurAffichage/$HauteurNuage]
	set HauteurMax $HauteurFenetre
	set LargeurMax [expr $LargeurNuage*$Rapport + 2*$BordY]
    }
    set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY]
    $K configure -background white

    $K create rectangle $BordX $BordY [expr $LargeurNuage*$Rapport + $BordX] [expr $HauteurNuage*$Rapport + $BordY] -outline red

    if {$TailleMaxNomQuery < [string length $NameQuery1]} { 
	set NameQ1 [string range $NameQuery1 0 $TailleMaxNomQuery]
	append NameQ1 "..."
    } else {
	set NameQ1 $NameQuery1
    }
    $K create text [expr $LargeurFenetre/2] [expr $BordY*2/3              ] -text "$NameQ1"
    $K create text [expr $LargeurFenetre/2] [expr $HauteurMax - $BordY*2/3] -text "$NameQ1"
    $K create text $BordX [expr $BordY/2              ] -text "$DQ1"
    $K create text $BordX [expr $HauteurMax - $BordY/2] -text "$DQ1"
    $K create text [expr $LargeurMax - $BordX] [expr $BordY/2              ] -text "$FQ1"
    $K create text [expr $LargeurMax - $BordX] [expr $HauteurMax - $BordY/2] -text "$FQ1"
    
    if {$TailleMaxNomQuery < [string length $NameQuery2]} { 
	set NameQ2 [string range $NameQuery2 0 $TailleMaxNomQuery]
	append NameQ2 "..."
    } else {
	set NameQ2 $NameQuery2
    }
    regsub -all "" $NameQ2 "\n" NameQ2
    regsub "^\n" $NameQ2 "" NameQ2
    regsub "\n$" $NameQ2 "" NameQ2
    $K create text [expr $BordX*2/3              ] [expr $HauteurFenetre/2] -text "$NameQ2"
    $K create text [expr $LargeurMax - $BordX*2/3] [expr $HauteurFenetre/2] -text "$NameQ2"
    $K create text [expr $BordX/2              ] $BordY -text "$DQ2"
    $K create text [expr $LargeurMax - $BordX/2] $BordY -text "$DQ2"
    $K create text [expr $BordX/2              ] [expr $HauteurMax - $BordY] -text "$FQ2"
    $K create text [expr $LargeurMax - $BordX/2] [expr $HauteurMax - $BordY] -text "$FQ2"

    foreach LePoint $LesPoints {
	set PosQ1 [lindex $LePoint 0]
	set PosQ2 [lindex $LePoint 1]
	set NbVoisins 0
	set PosQ1p [expr $PosQ1 + 1 ]
	set PosQ1m [expr $PosQ1 - 1 ]
	set PosQ2p [expr $PosQ2 + 1 ]
	set PosQ2m [expr $PosQ2 - 1 ]
	if {[info exists TabCompare($PosQ1,$PosQ2p) ]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1p,$PosQ2p)]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1p,$PosQ2) ]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1p,$PosQ2m)]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1,$PosQ2m) ]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1m,$PosQ2m)]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1m,$PosQ2) ]} {incr NbVoisins}
	if {[info exists TabCompare($PosQ1m,$PosQ2p)]} {incr NbVoisins}
	if {$NbVoisins == 0 && $NbPointsMinDansDiag !=0} {
	    continue
	} elseif {$NbVoisins == 0 && $NbPointsMinDansDiag ==0} {
	    set XMin [expr ($PosQ1 - $DQ1 + 1) * $Rapport + $BordX]
	    set YMin [expr ($PosQ2 - $DQ2 + 1) * $Rapport + $BordY]
	    set XMax [expr ($PosQ1 - $DQ1 + 1) * $Rapport + $BordX]
	    set YMax [expr ($PosQ2 - $DQ2 + 1) * $Rapport + $BordY]
	    $K create rectangle $XMin $YMin $XMax $YMax -fill $Couleur -width 2 -tags [list "$NameQuery1" "$PosXMinDiag1" "$PosXMaxDiag1" "$NameQuery2" "$PosYMinDiag1" "$PosYMaxDiag1" "AvecPosition"]
	} else {
	    if {![info exists DejaVuSurUneDiag1($PosQ1,$PosQ2)]} {
		set NbPointsAvantSurDiag1 0
		while {[info exists TabCompare($PosQ1m,$PosQ2m)]} {
		    incr NbPointsAvantSurDiag1
		    set PosQ2m [expr $PosQ2m - 1]
		    set PosQ1m [expr $PosQ1m - 1]
		    set DejaVuSurUneDiag1($PosQ1m,$PosQ2m) 1
		}
		set PosXMinDiag1 [expr $PosQ1 - $NbPointsAvantSurDiag1]
		set PosYMinDiag1 [expr $PosQ2 - $NbPointsAvantSurDiag1]
		set NbPointsApresSurDiag1 0
		while {[info exists TabCompare($PosQ1p,$PosQ2p)]} {
		    incr NbPointsApresSurDiag1
		    set PosQ2p [expr $PosQ2p + 1]
		    set PosQ1p [expr $PosQ1p + 1]
		    set DejaVuSurUneDiag1($PosQ1p,$PosQ2p) 1
		}
		set PosXMaxDiag1 [expr $PosQ1 + $NbPointsApresSurDiag1]
		set PosYMaxDiag1 [expr $PosQ2 + $NbPointsApresSurDiag1]
		
		if {[info exists LaDiagExiste($PosXMinDiag1,$PosYMinDiag1,$PosXMaxDiag1,$PosYMaxDiag1)]} {continue}
		set LaDiagExiste($PosXMinDiag1,$PosYMinDiag1,$PosXMaxDiag1,$PosYMaxDiag1) 1
		
		set NbPointsSurDiag1 [expr 1 + $NbPointsApresSurDiag1 + $NbPointsAvantSurDiag1]
		if {$NbPointsSurDiag1 < $NbPointsMinDansDiag} {continue}
		set Couleur "blue"
		set XMin [expr ($PosXMinDiag1 - $DQ1 + 1) * $Rapport + $BordX]
		set YMin [expr ($PosYMinDiag1 - $DQ2 + 1) * $Rapport + $BordY]
		set XMax [expr ($PosXMaxDiag1 - $DQ1 + 1) * $Rapport + $BordX]
		set YMax [expr ($PosYMaxDiag1 - $DQ2 + 1) * $Rapport + $BordY]
		$K create line $XMin $YMin $XMax $YMax -fill $Couleur -width 2 -tags [list "$NameQuery1" "$PosXMinDiag1"  "$PosXMaxDiag1" "$NameQuery2" "$PosYMinDiag1" "$PosYMaxDiag1" "AvecPosition"]
	    }
	    if {![info exists DejaVuSurUneDiag2($PosQ1,$PosQ2)]} {
		set NbPointsAvantSurDiag2 0 
		while {[info exists TabCompare($PosQ1m,$PosQ2p)]} {
		    incr NbPointsAvantSurDiag2
		    set PosQ2p [expr $PosQ2p + 1]
		    set PosQ1m [expr $PosQ1m - 1]
		    set DejaVuSurUneDiag1($PosQ1m,$PosQ2p) 1
		}
		set PosXMinDiag2 [expr $PosQ1 - $NbPointsAvantSurDiag2]
		set PosYMinDiag2 [expr $PosQ2 + $NbPointsAvantSurDiag2]
		set NbPointsApresSurDiag2 0
		while {[info exists TabCompare($PosQ1p,$PosQ2m)]} {
		    incr NbPointsApresSurDiag2
		    set PosQ2m [expr $PosQ2m - 1]
		    set PosQ1p [expr $PosQ1p + 1]
		    set DejaVuSurUneDiag1($PosQ1p,$PosQ2m) 1
		}
		set PosXMaxDiag2 [expr $PosQ1 + $NbPointsApresSurDiag2]
		set PosYMaxDiag2 [expr $PosQ2 - $NbPointsApresSurDiag2]
		
		if {[info exists LaDiagExiste($PosXMinDiag2,$PosYMinDiag2,$PosXMaxDiag2,$PosYMaxDiag2)]} {continue}
		set LaDiagExiste($PosXMinDiag2,$PosYMinDiag2,$PosXMaxDiag2,$PosYMaxDiag2) 1
		
		set NbPointsSurDiag2 [expr 1 + $NbPointsApresSurDiag2 + $NbPointsAvantSurDiag2]
		if {$NbPointsSurDiag2 < $NbPointsMinDansDiag} {continue}
		set Couleur "green"
		set XMin [expr ($PosXMinDiag2 - $DQ1 + 1) * $Rapport + $BordX]
		set YMin [expr ($PosYMinDiag2 - $DQ2 + 1) * $Rapport + $BordY]
		set XMax [expr ($PosXMaxDiag2 - $DQ1 + 1) * $Rapport + $BordX]
		set YMax [expr ($PosYMaxDiag2 - $DQ2 + 1) * $Rapport + $BordY]
		$K create line $XMin $YMin $XMax $YMax -fill $Couleur -width 2 -tags [list "$NameQuery1" "$PosXMinDiag1" "$PosXMaxDiag1" "$NameQuery2" "$PosYMinDiag1" "$PosYMaxDiag1" "AvecPosition"]
	    }
	}
    }
    regsub {\.canvas} $K "" w
    set B [BoutonneLaFenetre $w "TailleMinDesDiags Default / NoLimit / X"]
    bind $B <1> "AfficheCompare $FichierCompare $FichierTFA1 $FichierTFA2 10"
    bind $B <2> "AfficheCompare $FichierCompare $FichierTFA1 $FichierTFA2 0"
    bind $B <3> "AfficheCompare $FichierCompare $FichierTFA1 $FichierTFA2 \[Entre\]"

    if {$FichierTFA1 != "Absent" && $FichierTFA2 != "Absent"} {
	if {$Seq1 != "" && $Seq2 != ""} {
	    $K bind "AvecPosition"     <1> "AfficheDiagonaleCorrespondante $K $Seq1 $Seq2"
	}
    }
    return $K

}

proc AfficheContigComplet {Selection} {

    foreach Ligne [split $Selection "\n"] {
	set Ligne [OteSuperfluPourFetch $Ligne]
	scan $Ligne "%s" AccessDuFragment
	set F [AfficheVariable [ContigComplet $AccessDuFragment] "AvecBlaste" $AccessDuFragment]
    }
    return $F

}

proc AfficheCorrelationClustersOperons {} {

    global TableauOrf2Cluster2Operon

    set CO [CorrelationClustersOperons TCCO]
    set LesXs [lindex $CO 0]
    set LesYs [lindex $CO 1]

    DessineBilanHDACroises $LesXs $LesYs TCCO "CorrelationClustersOperons"

}

proc AfficheDansOmac {} {


global COmac
global Defauts
global EquivalenceZone
global OrdEtcDir
global StrucAVoir
global NomEtSeqAssPDB

DefinitStructuresAVoir
if {$StrucAVoir == "return"} {return}

OuvreFichierSortieO
if {$COmac == ""} {return}

FaireAttendre "Please wait ...\nSuperposing structures ..."
IlFautVoir "! "
IlFautVoir "! To execute the Ordali macro, type :"
IlFautVoir "! "
IlFautVoir "! @ord"
IlFautVoir "! "
IlFautVoir "! [DonneDateEtHeure] "
IlFautVoir "! "
IlFautVoir "DebutMc ord"
IlFautVoir "read [file join $OrdEtcDir color_rgb.dat]"
IlFautVoir "read [file join $OrdEtcDir color_names.dat]"
IlFautVoir "sketch_setup sphere solid 1"

set CmdSup {}
if {[info exists EquivalenceZone]} {
if {[set Defauts(MethodeSuper)]=="lsq"} {
set CmdSup [SuperAvecO]
} else {
SuperAvecOrdali
AppliqueSuperposition
}
}

foreach elt $StrucAVoir {
set idx [lsearch -regexp $NomEtSeqAssPDB $elt]
set cible [lindex $NomEtSeqAssPDB $idx]
scan $cible "%s %s %s" pdb NSAss MolId
set chn [string index $MolId 5]
set MolId [string range $MolId 0 3]
set RepS [CalculeSpheres $chn $MolId]
}

foreach elt $StrucAVoir {
set idx [lsearch -regexp $NomEtSeqAssPDB $elt]
set cible [lindex $NomEtSeqAssPDB $idx]
scan $cible "%s %s %s" pdb NomSeqAss MolId
set chn [string index $MolId 5]
set MolId [string range $MolId 0 3]
set fpdb [file tail [SigneFichier $pdb]]
file copy -force $pdb $fpdb

IlFautVoir "s_a_i"
IlFautVoir "[pwd]/$fpdb"
IlFautVoir "$MolId"
IlFautVoir "PDB"
if {$RepS} {IlFautVoir "draw ${elt}sf"}
}

foreach c $CmdSup {
foreach sousc [split $c \n] {
IlFautVoir $sousc
}
}

TraceObjetDansO $StrucAVoir

set mref [lindex $StrucAVoir 0]
if {[set Defauts(MethodeSuper)] == "lsq"} {
foreach elt $StrucAVoir {
if {$elt != $mref} {
IlFautVoir "rot_tran_obj .lsq_rt_${elt}2$mref ${elt}sf"
}
}
}

if {$RepS} {
foreach elt $StrucAVoir {
set idx [lsearch -regexp $NomEtSeqAssPDB $elt]
set cible [lindex $NomEtSeqAssPDB $idx]
scan $cible "%s %s %s" pdb NSAss MolId
set chn [string index $MolId 5]
set MolId [string range $MolId 0 3]
CalculeSpheres $chn $MolId
EcritSpheres $MolId
}
}

if {[set Defauts(Balibase)]} {PeintCAEnCouleur}

IlFautVoir "FinDbMc"
IlFautVoir "FinOMac"
FaireLaSuite .superpopo

return

}

proc AfficheDansPyMOL {} {


    DefinitStructuresAVoir
    if {$StrucAVoir == "return"} {return}
    update

    foreach elt $StrucAVoir {
	set idx [lsearch -regexp $NomEtSeqAssPDB $elt]
	set cible [lindex $NomEtSeqAssPDB $idx]
	scan $cible "%s %s %s" pdb NomSeqAss MolId
	set chn [string index $MolId 5]
	set MolId [string range $MolId 0 3]
	set deja -1
	if {[info exists DisplayMolecule]} {
	    set deja [lsearch $DisplayMolecule $MolId]
	}
	if {$deja == -1} {
	    set fpdb [file tail [SigneFichier $pdb]]
	    puts "on regarde $fpdb"
	    file copy -force $pdb $fpdb
	    IlFautVoir "load $fpdb"
	    lappend DisplayMolecule $MolId
	}
    }

    #    load $pdb , object-name
    #    show cartoon , object-name
    #    hide lines , object-name
    #    set smooth_loops=0 , object-name # de-smooth le cartoon --> Ca trave
    #    color cyan , object-name # tout en cyan
    #    color cyan , object-name//res1:res2/
    #    color cyan , (resi  and chain )
    return

}

proc AfficheDansRasMol {} {

    global ListePDB
    global StrucAVoir
    global InitRasMol
    global Defauts
    global ReponseRasmol
    global RasM

    set InitRasMol 1

    FenetreControlesRasMol

    IlFautVoir "zap"
    IlFautVoir "rotate all"
    IlFautVoir "background [set Defauts(Background)]"
    IlFautVoir "set cartoons 6"
    IlFautVoir "set menus off"

    set i 1
    set r 0
    foreach mold $StrucAVoir {
	set idx [lsearch [ExtraitListeDeListe $ListePDB 0] $mold]
	lassign [lindex $ListePDB $idx] mol fpdb

	IlFautVoir "load pdb $fpdb"
	if {[info exists ReponseRasmol]} {
	    set nfois 0
	    while {[lsearch -regexp $ReponseRasmol "Experiment"] == -1} {
		update
		incr nfois
		if {$nfois >= 10} {break}
	    }
	    set inmr [string first " NMR" $ReponseRasmol]
	    if {$inmr != -1} {
		set RasM(mol$r,Exp) "NMR"
		set RasM(mol$r,Sel) "restrict */1"
	    } else {
		set RasM(mol$r,Exp) "X-RAY"
		set RasM(mol$r,Sel) "select all"
	    }
	}
	IlFautVoir "molecule $i"
	IlFautVoir [set RasM(mol$r,Sel)]
	IlFautVoir "colour grey"
	TraceObjetDansRasMol $mol

	incr i
	incr r
    }

    return

}

proc AfficheDansVMD {} {

    global StrucAVoir
    global ListePDB

    if {$StrucAVoir eq "return"} {return}
    if {$StrucAVoir eq {}} {return}

    foreach mold $StrucAVoir {
	set idx [lsearch [ExtraitListeDeListe $ListePDB 0] $mold]
	lassign [lindex $ListePDB $idx] mol fpdb

	set chn   [DonneChainDeAccessPDB $mol]
	set MolId [DonneIdDeAccessPDB $mol]

	IlFautVoir "NouvelleMolecule $fpdb $MolId $chn"
    }

    return

}

proc AfficheDansViandox {} {

    global pgl Rad OrdaliDir StrucAVoir Liste3dMol

    # Deja passe par la
    if {[info exists pgl(wogl)]} {
	raise [winfo toplevel $pgl(wogl)]
	update idletasks
	return
    }

    # On y va !
    Initialisation

    set ObjDone [expr {[LoadObjFromDB] > 0}]
    
    # Liste des structures pour la combobox
    set Liste3dMol [list]
    foreach e $StrucAVoir {
	lappend Liste3dMol [DonneIdDeAccessPDB $e]
    }

    set cx 0. ; set cy 0. ; set cz 0.
    set zmin 999999. ; set zmax -999999.
    set ymin 999999. ; set ymax -999999.
    set xmin 999999. ; set xmax -999999.
    set cmp 0 ; set ZeRad 1.

    foreach mold $StrucAVoir {
	set nom [DonneIdDeAccessPDB $mold]
	set chn [DonneChainDeAccessPDB $mold]
	lappend ListeObjPDB $nom

	lassign [$nom bbox] xm ym zm xx yx zx 
	if {$zm < $zmin} {set zmin $zm}
	if {$zx > $zmax} {set zmax $zx}
	if {$ym < $ymin} {set ymin $ym}
	if {$yx > $ymax} {set ymax $yx}
	if {$xm < $xmin} {set xmin $xm}
	if {$xx > $xmax} {set xmax $xx}
	#if {$zeRad < [$nom radius]} {set ZeRad [$nom radius]}

	if {! $ObjDone} {
	    if {$::Defauts(PrecomputeSrf)} {
		$nom newObj "SF${nom}$chn"
		$nom select chain $chn
		$nom ribbons "SF${nom}$chn"
		$nom surface "SF${nom}$chn"
		$nom render "SF${nom}$chn"
	    }

	    #$nom newObj "CP${nom}$chn"
	    #$nom select chain $chn
	    #$nom CPK "CP${nom}$chn"
	    #$nom render "CP${nom}$chn"
	}

	if {1} {
	    $nom newObj "CT${nom}$chn"
	    $nom select chain $chn
	    $nom catrace "CT${nom}$chn"
	    $nom render "CT${nom}$chn"
	}

	if {1} {
	    if {! $ObjDone} {
		$nom newObj "AL${nom}$chn"
		$nom select chain $chn
		$nom atomes "AL${nom}$chn"
		$nom render "AL${nom}$chn"
		update

		$nom newObj "CA${nom}$chn"
		$nom select chain $chn
		$nom ribbons "CA${nom}$chn"
		#$nom setboite "CA${nom}$chn" $chn
		$nom render "CA${nom}$chn"
	    }
	}

	if {0} {
	    $nom newObj "CP${nom}$chn"
	    $nom select chain $chn
	    $nom CPK "CP${nom}$chn"
	    $nom render "CP${nom}$chn"
	}
    }

    set pgl(xCen) [expr {($xx+$xm)/2.}]
    set pgl(yCen) [expr {($yx+$ym)/2.}]
    set pgl(zCen) [expr {($zx+$zm)/2.}]

    set Rad [expr {sqrt(  ($xmax-$xmin)**2 +  ($ymax-$ymin)**2 +  ($zmax-$zmin)**2)  / 2.}]


    set pgl(Rad)       $Rad

    # backclip = z near (z neg)
    set pgl(backclip)  [expr {-0.1 * $Rad}]
    # frontclip = z far 
    set pgl(frontclip) [expr { 2.1 * $Rad}]

    set pgl(eyeX)      0.0
    set pgl(eyeY)      0.0
    set pgl(eyeZ)      $pgl(frontclip)

    set pgl(fogStart)  [expr {0.3*$Rad}]
    set pgl(fogEnd)    [expr {0.6*$Rad}]
    
    AfficheFenetreOpengl

    set LFPDB {}
    foreach mold $StrucAVoir {
	set nom [DonneIdDeAccessPDB $mold]
	set chn [DonneChainDeAccessPDB $mold]

	if {$nom ni $LFPDB} {
	    AddFObj $nom
	    lappend LFPDB $nom
	}

	lassign [$nom center] x y z
	set cx  [expr {$cx + $x}]
	set cy  [expr {$cy + $y}]
	set cz  [expr {$cz + $z}]

	incr cmp
    }
    if {$cmp != 0} {
	set cx [expr {$cx/$cmp}]
	set cy [expr {$cy/$cmp}]
	set cz [expr {$cz/$cmp}]
    }

    TousObjetsOff
    #ToggleAllOff
    update

    set pgl(xCen) $cx
    set pgl(yCen) $cy
    set pgl(zCen) $cz

    set pgl(fogStart) [expr {abs($cz)}]
    set pgl(fogEnd)   [expr {0.9*($Rad-abs($cz))}]
    
    Update3DMatrices
    $pgl(wogl) postredisplay

    return

}

proc AfficheDiagonaleCorrespondante {K Seq1 Seq2} {

    set Liste [$K find withtag current]
    set Blanc ""
    set NbBaseParLigne 50

    foreach Diag $Liste {
	set NameQuery1 [lindex [$K gettags $Diag] 0]
	set PosMin1    [lindex [$K gettags $Diag] 1]
	set PosMax1    [lindex [$K gettags $Diag] 2]
	set NameQuery2 [lindex [$K gettags $Diag] 3]
	set PosMin2    [lindex [$K gettags $Diag] 4]
	set PosMax2    [lindex [$K gettags $Diag] 5]

	set FragSeq1   [string range [string trim $Seq1] [expr $PosMin1-11] [expr $PosMax1+9] ]
	set LeFragSeq1 [split $FragSeq1 ""]
	
	set FragSeq2 [string range [string trim $Seq2] [expr $PosMin2-11] [expr $PosMax2+9] ]
	set LeFragSeq2 [split $FragSeq2 ""]

	set NBaseTotale [string length $FragSeq1]
	set InterSeq ""
	for {set i 0} {$i < $NBaseTotale} {incr i} {
	    set Base1 [lindex $LeFragSeq1 $i]
	    set Base2 [lindex $LeFragSeq2 $i]
	    if {$Base1 == $Base2} {
		if {$Base1 != "N"} {
		    append InterSeq "\|"
		} else {
		    append InterSeq " "
		}
	    } else {
		append InterSeq " "
	    }
	}
	
	set ResteDeSeq1     $FragSeq1
	set ResteDeSeq2     $FragSeq2
	set ResteDeInterSeq $InterSeq
	set Debut1 [expr $PosMin1-10]
	set Debut2 [expr $PosMin2-10]
	set PosMin1 "$PosMin1-10"
	set PosMax1 "$PosMax1+10"
	set PosMin2 "$PosMin2-10"
	set PosMax2 "$PosMax2+10"
	set Alignement ""
	if {1<[expr ($NBaseTotale*1.0)/($NbBaseParLigne*1.0)]} { 
	    if {[expr $NBaseTotale/$NbBaseParLigne]== [expr ($NBaseTotale*1.0)/($NbBaseParLigne*1.0)] } {
		set NbLignes [expr $NBaseTotale/$NbBaseParLigne]
	    } else {
		set NbLignes [expr $NBaseTotale/$NbBaseParLigne + 1]
	    }
	   
	    for {set Ligne 1} {$Ligne <= $NbLignes} {incr Ligne} {
		set LigneSeq1     [string range $ResteDeSeq1     0 [expr $NbBaseParLigne-1]]
		set LigneSeq2     [string range $ResteDeSeq2     0 [expr $NbBaseParLigne-1]]
		set LigneInterSeq [string range $ResteDeInterSeq 0 [expr $NbBaseParLigne-1]]
		if {$Ligne == 1} {
		    set LigneSeq1 [format "%11s %s %-11s\n" $PosMin1 $LigneSeq1 $NbBaseParLigne]
		    set LigneSeq2 [format "%11s %s %-11s\n" $PosMin2 $LigneSeq2 $NbBaseParLigne]
		    set LigneInterSeq [format "%11s %s\n" $Blanc $LigneInterSeq]
		    append Alignement "$NameQuery1\n"
		    append Alignement $LigneSeq1
		    append Alignement $LigneInterSeq
		    append Alignement $LigneSeq2
		    append Alignement "$NameQuery2\n\n\n"
		    
		    set ResteDeSeq1     [string range $ResteDeSeq1 $NbBaseParLigne end]
		    set ResteDeSeq2     [string range $ResteDeSeq2 $NbBaseParLigne end]
		    set ResteDeInterSeq [string range $ResteDeInterSeq $NbBaseParLigne end]
		} elseif {$Ligne == $NbLignes} {
		    set Min1 [expr $Debut1  + ($Ligne-1)*$NbBaseParLigne]
		    set Min2 [expr $Debut2  + ($Ligne-1)*$NbBaseParLigne]
		    set LigneSeq1 [format "%11s %s %-11s\n" $Min1 $LigneSeq1 $PosMax1]
		    set LigneSeq2 [format "%11s %s %-11s\n" $Min2 $LigneSeq2 $PosMax2]
		    set LigneInterSeq [format "%11s %s\n" $Blanc $LigneInterSeq]
		    append Alignement $LigneSeq1
		    append Alignement $LigneInterSeq
		    append Alignement $LigneSeq2
		    break
		} else {
		    set Min1 [expr $Debut1  + ($Ligne-1)*$NbBaseParLigne]
		    set Min2 [expr $Debut2  + ($Ligne-1)*$NbBaseParLigne]
		    set Max1 [expr $Min1 + $NbBaseParLigne]
		    set Max2 [expr $Min2 + $NbBaseParLigne]
		    
		    set LigneSeq1 [format "%11s %s %-11s\n" $Min1 $LigneSeq1 $Max1]
		    set LigneSeq2 [format "%11s %s %-11s\n" $Min2 $LigneSeq2 $Max2]
		    set LigneInterSeq [format "%11s %s\n" $Blanc $LigneInterSeq]
		    append Alignement $LigneSeq1
		    append Alignement $LigneInterSeq
		    append Alignement "$LigneSeq2\n\n\n"
		    		    
		    set ResteDeSeq1     [string range $ResteDeSeq1 $NbBaseParLigne end]
		    set ResteDeSeq2     [string range $ResteDeSeq2 $NbBaseParLigne end]
		    set ResteDeInterSeq [string range $ResteDeInterSeq $NbBaseParLigne end]
		}
	    }
	} else {
	    set LigneFrag1 [format "%11s %s %-11s\n" $PosMin1 $FragSeq1 $PosMax1]
	    set LigneFrag2 [format "%11s %s %-11s\n" $PosMin2 $FragSeq2 $PosMax2]
	    set Ali [format "%11s %s\n" $Blanc $InterSeq]
	    append Alignement "$NameQuery1\n"
	    append Alignement $LigneFrag1
	    append Alignement $Ali
	    append Alignement $LigneFrag2
	    append Alignement "$NameQuery2\n"
	}
	AfficheVariable "$Alignement" "AvecRien" "Input1 - Input2"
    }

}

proc AfficheDistances {} {

    global pgl

    set $pgl(TextDeDist) [list]
    if {$pgl(Dist2Show) == {} } {return}

    glColor3fv $pgl(DistColor)
    glLineStipple 3 0xAAAA
    glEnable GL_LINE_STIPPLE
    foreach e $pgl(Dist2Show) {
	lassign $e v1 v2 dst
	glBegin GL_LINES
	glVertex3fv $v1
	glVertex3fv $v2
	glEnd
	
	lappend pgl(TextDeDist) {*}[V_VV $v1 + [V_SV 0.5 * [V_VV $v2 - $v1]]] [format " %4.1f A" $dst]
    }
    glDisable GL_LINE_STIPPLE
    
    return

    # recup de la matrice de modelisation
    set mvmatrix [tcl3dVector GLdouble 16]
    glGetDoublev GL_MODELVIEW_MATRIX $mvmatrix
    set modmat [tcl3dVectorToList $mvmatrix 16]

    # recup de la matrice de projection
    set pjmatrix [tcl3dVector GLdouble 16]
    glGetDoublev GL_PROJECTION_MATRIX $pjmatrix
    set projmat [tcl3dVectorToList $pjmatrix 16]

    # Recup du viewport
    set viewmat [tcl3dVector GLint 4]
    glGetIntegerv GL_VIEWPORT $viewmat
    set viewport [tcl3dVectorToList $viewmat 4]

    # print the string
    glMatrixMode GL_MODELVIEW
    glPushMatrix
    glLoadIdentity

    foreach v $Lx text $Lt {
	lassign $v x y z

	set xa [expr {[lindex $modmat 0]*$x + [lindex $modmat 4]*$y + [lindex $modmat 8]*$z + [lindex $modmat 12]}]
	set ya [expr {[lindex $modmat 1]*$x + [lindex $modmat 5]*$y + [lindex $modmat 9]*$z + [lindex $modmat 13]}]
	set za [expr {[lindex $modmat 2]*$x + [lindex $modmat 6]*$y + [lindex $modmat 10]*$z + [lindex $modmat 14]}]

	glRasterPos3f $xa $ya $za

	printString $text
    }

    glPopMatrix
    glFlush

    return

}

proc AfficheDownloadPDB {} {

    global StrucAVoir DwnPDB

    set w ".dwnpdb"
    toplevel $w
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix

    grid rowconfig    $w 0 -weight 1 -minsize 0
    grid columnconfig $w 0 -weight 0 -minsize 0
    grid columnconfig $w 1 -weight 1 -minsize 0
    grid columnconfig $w 2 -weight 0 -minsize 0

    label $w.l -text "Please specify PDB files to be used" -anchor w
    set i 1
    foreach s $StrucAVoir {
	label $w.l$i -text "$s"
	entry $w.e$i -bg white -width 25 -textvariable DwnPDB($i)
	button $w.b$i -text "browse ..."  -bg cyan -width 10  -command [list eval set DwnPDB($i) \[DemandeEtOuvreFichier pdb 1\]]
	grid $w.l$i -padx 10 -pady 1  -row $i -column 0 -rowspan 1 -columnspan 1 -sticky news
	grid $w.e$i -padx 1 -pady 1  -row $i -column 1 -rowspan 1 -columnspan 1 -sticky news
	grid $w.b$i -padx 10 -pady 1  -row $i -column 2 -rowspan 1 -columnspan 1 -sticky news
	incr i
    }
    frame $w.f
    button $w.f.ok  -background green1  -text " OK "  -command [list FinAfficheDownloadPDB "" $w]
    button $w.f.dis -bg red  -text "Cancel"  -command [list FinAfficheDownloadPDB dismiss $w]
    pack $w.f.dis $w.f.ok -side left -expand 1

    grid $w.l -padx 10 -pady 10  -row 0 -column 0 -rowspan 1 -columnspan 3 -sticky news
    grid $w.f -padx 10 -pady 10  -row $i -column 0 -rowspan 1 -columnspan 3 -sticky news

    FenetreAuCentre $w
    MesCouleurs $w

    tkwait window $w

    return

}

proc AfficheExtraitOligoDuTFA {K PAB} {


    Wup "Affiche la sequence tfa de l oligo du PAB voulu"
        
    set Id         [$K find withtag current]
    set MesTags    [$K gettags $Id]
    set NomOligo   [lindex $MesTags 4]
    set Dir        [lindex $MesTags 5]
    set TFADeOligo [ExtraitOligoDuTFA $PAB $NomOligo $Dir]

    return [AfficheVariable [join $TFADeOligo "\n"] "AvecFormateAvecBlaste" "$Dir/$PAB"]

}

proc AfficheFenetreOpengl {} {

    global OrdEtcDir pgl

    # define fonts
    if {"FontOg" ni [font names]} {
	font create FontOg -family Helvetica -size 10 -weight normal
    }
    if {"FontOgTitle" ni [font names]} {
	font create FontOgTitle -family Helvetica -size 10 -weight bold
    }

    rename EnvoieLesObjets EnvoieLesObjets_wait
    rename EnvoieLesObjetsTmp EnvoieLesObjets

    # define window
    set wgl .ordogl
    toplevel $wgl
    wm title $wgl $pgl(appName)
    wm protocol $wgl WM_DELETE_WINDOW KillParLaCroix
    wm withdraw $wgl
    $wgl configure -background black

    # put FaireAttendre window on top
    if {[winfo exists .fattendre]} {
	focus -force .fattendre
	raise .fattendre
	wm attributes .fattendre -topmost 1
	update idletasks
    }

    set frInfo [frame $wgl.f1 -bg black -bd 0 -relief flat -highlightthickness 0]
    set frCtrl [frame $wgl.f2 -bg black -bd 0 -relief flat -highlightthickness 0]
    set frObjc [frame $wgl.f3 -bg black -bd 0 -relief flat -highlightthickness 0]
    set frTogl [frame $wgl.f4 -bg black -bd 0 -relief flat -highlightthickness 0]
    set frFonc [frame $wgl.f5 -bg black -bd 0 -relief flat -highlightthickness 0]
    
    set pgl(frInfo) $frInfo
    set pgl(frCtrl) $frCtrl
    set pgl(frTogl) $frTogl
    set pgl(frObjc) $frObjc
    set pgl(frFonc) $frFonc

    # frame Banniere
    set fmacsim [file join $OrdEtcDir "MACSIM_30px_cut_transparent.gif"]
    image create photo macsim
    #    macsim read $fmacsim -shrink
    macsim read $fmacsim
    set pgl(TextInfo) "Ordalie Structure Viewer"
    label $frInfo.imgm  -image macsim -anchor w  -bd 0 -bg black -padx 30 -pady 10
    label $frInfo.linf  -bg black -fg magenta  -anchor w -justify left  -bd 0  -textvariable pgl(TextInfo)
    grid $frInfo.imgm -row 0 -column 0 -padx {20 10}
    grid $frInfo.linf -row 0 -column 1 -padx {1 20} -sticky ew
    grid columnconfig $frInfo 1 -weight 1

    # frame Control
    global Mol3dCou Obj3dCou Feat3dCou
    global ListeTypesDeFeatures ListeFeat43d
    global Liste3dMol
    if {! [info exists Liste3dMol]} {
	set Liste3dMol {}
    }
    set Mol3dCou ""
    set Obj3dCou ""
    set Feat3dCou "None"
    set ListeFeat43d [MetAJourFeaturesViandox]

    trace add variable ListeTypesDeFeatures write MetAJourFeaturesViandox

    frame $frCtrl.f1 -bd 0 -highlightthickness 0 -relief flat -bg black
    label $frCtrl.f1.txt1  -relief flat -bd 0  -bg black -fg white  -text "Molecule :"  -anchor w -justify left  -highlightthickness 0

    combobox::combobox $frCtrl.f1.co1  -background black  -foreground white  -width 6  -editable false  -textvariable Mol3dCou  -listvar Liste3dMol
    grid $frCtrl.f1.txt1 -row 0 -column 0 -sticky ""
    grid $frCtrl.f1.co1  -row 0 -column 1 -sticky ew
    trace add variable Mol3dCou write UpdateMol3dObjets
    
    frame $frCtrl.f2 -bd 0 -highlightthickness 0 -relief flat -bg black
    label $frCtrl.f2.txt2  -anchor e -bg black -fg white  -text "Object :"  -relief flat -bd 0  -anchor w -justify left  -highlightthickness 0
    global ListeMol3dObjets
    combobox::combobox $frCtrl.f2.co2  -background black -foreground white  -width 6  -editable false  -textvariable Obj3dCou  -listvar ListeMol3dObjets
    grid $frCtrl.f2.txt2 -row 0 -column 0 -sticky ""
    grid $frCtrl.f2.co2  -row 0 -column 1 -sticky ew

    frame $frCtrl.f3 -bd 0 -highlightthickness 0 -relief flat -bg black
    label $frCtrl.f3.txt3  -bg black -fg white  -text "Feature 1 :"  -anchor w -justify left  -highlightthickness 0
    combobox::combobox $frCtrl.f3.co3  -background black -foreground white  -width 10  -editable false  -textvariable Feat3dCou  -command [list UpdateMolObjFeat]  -listvar ListeFeat43d
    grid $frCtrl.f3.txt3 -row 0 -column 0 -sticky ""
    grid $frCtrl.f3.co3  -row 0 -column 1 -sticky ew
    bind $frCtrl.f3.co3 <> [list UpdateMolObjFeat]

    frame $frCtrl.f4 -bd 0 -highlightthickness 0 -relief flat -bg black
    label $frCtrl.f4.txt4  -bg black -fg white  -anchor w -justify left  -highlightthickness 0  -text "Feature 2 :"
    combobox::combobox $frCtrl.f4.co4  -background black -foreground white  -width 10  -editable false  -textvariable Feat3dCou2  -command [list UpdateMolObjFeat]  -listvar ListeFeat43d
    grid $frCtrl.f4.txt4 -row 0 -column 0 -sticky ""
    grid $frCtrl.f4.co4  -row 0 -column 1 -sticky ew
    bind $frCtrl.f4.co4 <> [list UpdateMolObjFeat]

    grid $frCtrl.f1 -row 0 -column 0  -sticky w -padx 20
    grid $frCtrl.f2 -row 0 -column 1  -sticky "" -padx 20
    grid $frCtrl.f3 -row 0 -column 2  -sticky "" -padx 20
    grid $frCtrl.f4 -row 0 -column 3  -sticky e -padx 20
    grid columnconfig $frCtrl all -weight 1

    # frame OpenGL
    # Fenetre Togl
    set pgl(wogl) $frTogl.c 
    togl $frTogl.c  -width $pgl(width)  -height $pgl(height)  -double true  -depth true  -reshapeproc Togl_ReshapeFonct  -createproc  Togl_CreateFonct  -displayproc Togl_DisplayFonct
    grid $frTogl.c -row 0 -column 0 -sticky news
    grid columnconfig $frTogl 0 -weight 1
    grid rowconfig    $frTogl 0 -weight 1
    
    # Frame Fonctions
    button $frFonc.ca -text "\u2022Reset"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command {ResetFonctions}
    button $frFonc.ci -text "\u2022Clear Ids"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command [list ClearIDs]
    button $frFonc.cd -text "\u2022Clear Distances"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command [list ClearDistances]
    set pgl(BoutonDistance) "$frFonc.ds"
    button $frFonc.ds -text "\u2022Distance"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command [list MeasureDistance]


    set pgl(BoutonCenter) "$frFonc.ct"
    button $frFonc.ct -text "\u2022Centre On Atom"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command [list CentreOnAtome $frFonc.ct]
    button $frFonc.pr -text "\u2022Print"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command {PrintOgl}
    button $frFonc.fs -text "\u2022Full Screen"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command {ToggleWindowMode}
    button $frFonc.st -text "\u2022Stereo"  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -bd 0 -relief flat  -highlightthickness 0 -anchor w  -command [list NYI]

    button $frFonc.cl -text "Close"  -bg forestgreen -fg white  -activeforeground red  -activebackground forestgreen  -highlightthickness 0 -anchor w  -command [list QuitteViandox]

    grid $frFonc.ca -row 0 -column 0 -pady 0 -sticky nwe
    grid $frFonc.ci -row 1 -column 0 -pady 0 -sticky nwe
    grid $frFonc.cd -row 2 -column 0 -pady 0 -sticky nwe
    grid $frFonc.ds -row 3 -column 0 -pady 0 -sticky nwe
    grid $frFonc.ct -row 4 -column 0 -pady 0 -sticky nwe
    grid $frFonc.pr -row 5 -column 0 -pady 0 -sticky nwe
    grid $frFonc.fs -row 6 -column 0 -pady 0 -sticky nwe
    grid $frFonc.st -row 7 -column 0 -pady 0 -sticky nwe
    grid $frFonc.cl -row 8 -column 0 -pady 20 -sticky swe
    grid rowconfig $frFonc 8 -weight 1

    # Frame Objects
    frame $frObjc.onoff -bg black -relief flat -bd 0 -highlightthickness 0

    button $frObjc.onoff.allon  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -text "All On"  -font FontOg  -bd 0 -highlightthickness 0  -anchor w -justify left  -padx 0 -relief flat  -command [list TousObjetsOn]

    button $frObjc.onoff.alloff  -bg black -fg cyan  -activeforeground yellow  -activebackground black  -font FontOg  -text "All Off"  -anchor e -justify right  -padx 0 -relief flat  -bd 0 -highlightthickness 0  -command [list TousObjetsOff]

    grid $frObjc.onoff.allon  -row 0 -column 0 -sticky w -ipadx 10
    grid $frObjc.onoff.alloff -row 0 -column 1 -sticky e -ipadx 10
    grid columnconfig $frObjc.onoff all -weight 1
    grid $frObjc.onoff -row 0 -column 0 -sticky we -pady 0 -ipady 0 -padx {20 1}

    grid columnconfig $frObjc all -weight 1

    # Grille Generale
    grid $frInfo -row 0 -column 0 -columnspan 3 -sticky ew
    grid $frCtrl -row 1 -column 0 -columnspan 3 -sticky ew
    grid $frObjc -row 2 -column 0 -sticky news -pady 15
    grid $frTogl -row 2 -column 1 -sticky news -pady 15
    grid $frFonc -row 2 -column 2 -sticky news -pady 15

    grid rowconfigure $wgl 2 -weight 1
    grid columnconfig $wgl 1 -weight 1

    # Bindings 
    bind $frTogl.c  {PickAtom %x %y %W}
    #    bind $frFonc.c.c    {CenterAtom %x %y %W}

    set ::BQx [expr {$pgl(width)/2}]
    set ::BQy [expr {$pgl(height)/2}]
    bind $frTogl.c  {set ::BQx %x ; set ::BQy %y}
    #bind $frTogl.c <1>         "LClick %x %y"
    #bind $frTogl.c  "LDrag %x %y %W"
    bind $frTogl.c  {QDrag %x %y}

    bind $frTogl.c <2> {set cx %x; set cy %y}
    bind $frTogl.c <3> {set cx %x; set cy %y}

    bind $frTogl.c  {Mouse TraXY %x %y %W}

    bind $frTogl.c <4> {HandleZoom  0.03 %W}
    bind $frTogl.c <5> {HandleZoom -0.03 %W}

    #bind $wgl  {AdieuOrdali}
    bind $wgl  [list ToggleWindowMode]
    bind $wgl  [list ToggleShowFrame]
    bind $wgl  {PrintOgl}
    bind $wgl  {ToggleWindowMode escape}

    set ::fact 0.1
    bind $wgl  {AdjustFog up}
    bind $wgl  {AdjustFog down}
    set ::fogon 1
    bind $wgl  {FogOnOff}
    set ::fogsys "::GL_EXP2"
    bind $wgl  {ChangeFogSys}
    set ::fogcoords "fog"
    bind $wgl  {FogCoords}
    set ::eyepos "zero"
    #bind $wgl  {EyePos}
    
    wm deiconify $wgl
    FenetreAuCentre $wgl

    # put FaireAttendre window on top
    if {[winfo exists .fattendre]} {
	focus -force .fattendre
	raise .fattendre
	wm attributes .fattendre -topmost 1
	update idletasks
    }

    update idletasks

    rename EnvoieLesObjets EnvoieLesObjetsTmp
    rename EnvoieLesObjets_wait EnvoieLesObjets

    Update3DMatrices
    EnvoieLesObjets

    #glFlush
    #$pgl(Wogl) postredisplay

    return

}

proc AfficheFenetreOrdali {} {

    global Defauts NomFenetreOrdali

    set menustatus    "    "
    set w $NomFenetreOrdali

    grid rowconfig    $w {0 1 2 4 5 6} -weight 0
    grid rowconfig    $w 3             -weight 1
    grid columnconfig $w 0             -weight 1

    AfficheBarreMenus
    AfficheBarreBoutons
    AfficheBarreMac
    AfficheFrameSequences
    AfficheFrameScores
    AfficheFrameFeatures
    AfficheFrameDebug

    AfficheBoutonsOrdali

    LesDefauts BackAppliOri [$w cget -background]

    return

}

proc AfficheFenetreSeqlab {} {

    global TScrollX TScrollY FrmSequence LNOrdali
    global NomNomSeq NomTextSeq wtx wxx LongueurTotale

    set width  [$NomTextSeq cget -width]
    set height [$NomTextSeq cget -height]
    $FrmSequence.biotextsequence configure  -width $width  -height $height

    grid forget $FrmSequence.textsequence
    grid $FrmSequence.biotextsequence  -row 0 -column 1  -rowspan 1 -columnspan 2  -sticky news

    set NomTextSeq $FrmSequence.biotextsequence

    $TScrollX configure -command {CoupleX}
    $TScrollY configure -command {CoupleY}

    update idletasks
    FenetreAuCentre [winfo toplevel $NomTextSeq]

    return

}

proc AfficheFetch {Selection {NomDuFichierOrigine ""}} {

    global RepertoireDuGenome
    global AccessDejaVus

    LogWscope "AfficheFetch $Selection"
    Wup "On cherche la sequence et on l'affiche"
    
    Gs "Frame"

    if {[regexp " " $NomDuFichierOrigine]} {
	foreach Mot [split $NomDuFichierOrigine " "] {
	    if {[regexp "/" $Mot]} { set NomDuFichierOrigine $Mot ; break }
	}
    }
    if {[regexp " " $NomDuFichierOrigine]} { scan $NomDuFichierOrigine "%s" NomDuFichierOrigine }
	
    
    set FormatVoulu ""
    if {$NomDuFichierOrigine=="OnVeutNature"} {
	set FormatVoulu "OnVeutNature"
	set NomDuFichierOrigine ""
    }
    if {[regexp "^OnVeut" $NomDuFichierOrigine]} {
	set FormatVoulu $NomDuFichierOrigine
	set NomDuFichierOrigine ""
    }


    set Nom ""
    if {$NomDuFichierOrigine != "" } {
	set Nom [file tail $NomDuFichierOrigine]
	Wup "NomDuFichierOrigine peut finir par Nom (de PAB)"
	if { ! [YaPABdans $Nom]} {
	    Wup "Recherche du pab si c'est un copain"
	    set Nom [file tail [file dirname $NomDuFichierOrigine]]
	}
	if { ! [YaPABdans $Nom]} { set Nom "" }
    }
    Wup "Si Nom n'est pas vide c'est qu'on a affaire a un PAB"
    
    set LesFramesFetchees {}
    
    set Liste [split $Selection "\n"]
    foreach Ligne $Liste {
	if { ! [regexp -nocase {[a-z0-9_]} $Ligne]} { continue }
	set Ligne [OteSuperfluPourFetch $Ligne]
	scan $Ligne "%s" aPDB
Espionne $aPDB
	if {[EstUnAccessPDB $aPDB]} {
	    if {[info exists DejaVu($aPDB)]} { continue }
	    set  DejaVu($aPDB) 1
	    if {[set LaFramePDB [AffichePDB $aPDB]]!=""} { 
		lappend LesFramesFetchees $LaFramePDB
		continue
	    } 
	}

	set BanqueId ""
	set Access ""
	Wup "On cherche d'abord Access dans la ligne"
	if { [regexp "^Query=" $Ligne] } {
	    Wup "C'est une ligne Query"
	    set Access [QueryDeLaLigne $Ligne]
	} elseif  { [regexp "^Name:" $Ligne] } {
	    Wup "C'est une ligne d'un MSF"
	    set Access [lindex [split $Ligne " "] 1]
	} elseif  { [regexp {^(AC|ID) } $Ligne] } {
	    Wup "C'est une ligne d'un EMBL"
	    scan $Ligne "%s %s" AC Access
	} elseif {[regexp -nocase {^[a-z0-9_]+=[a-z0-9_]+ } $Ligne]} {
	    Wup "Ligne descriptif"
	    regsub "=" $Ligne " " Access_BanqueId
	    scan $Access_BanqueId "%s %s" Access BanqueId
	} elseif {[regexp {^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+[ !]* [a-zA-Z0-9_]+} $Ligne]} {
	    Wup "Ligne blast"
	    regsub "!" $Ligne " " BanqueId_Access
	    scan $BanqueId_Access "%s %s" BanqueId Access
	} elseif { [regexp {^[a-zA-Z0-9_]+: +[a-zA-Z0-9_]+} $Ligne]} {
	    Wup "Ligne du type 'Clef: access'"
	    scan $Ligne "%s %s" Bidon Access
	} else {
	    scan $Ligne "%s" Access
	}
	if {$BanqueId==""} { set BanqueId $Access }

	if {$Nom!="" && [OnTraiteUneCollection]} {
	    set FichierCopain "$RepertoireDuGenome/coembl/$Nom/$Access"
	    if {[file exists $FichierCopain]} {
		if {[info exists DejaVu($FichierCopain)]} { continue }
		set  DejaVu($FichierCopain) 1
		lappend LesFramesFetchees [AfficheVariable [ContenuDuFichier $FichierCopain] "AvecBlasteAvecFormate" "$FichierCopain"]
		continue
	    }
	}
	if {[info exists DejaVu($BanqueId,$Access)]} { continue }
	set AccessOk ""
	set LaSeqDesBan [LaSequenceDesBanques $BanqueId $Access AccessOk $FormatVoulu]
	set Sequence [join $LaSeqDesBan "\n"]
	if {$Sequence!=""} {
	    set  DejaVu($BanqueId,$Access) 1
	    lappend LesFramesFetchees [AfficheVariable $Sequence "AvecBlasteAvecFormate" $AccessOk]
	    continue
	}
	Wup "Ici on n'a toujours rien trouve ... "
	set FichierMSF "$RepertoireDuGenome/msf/$Nom"
	if {[info exists DejaVu($FichierMSF)]} { continue }
	if {[YaPABdans $Nom] && [file exists $FichierMSF]} {
	    set Sequence [UneSequenceDuMSF $FichierMSF $Access]
	    set TFA [SequenceFormatTFA $Sequence $Access "protbrut"]
	    if {$TFA!=""} { 
		set  DejaVu($FichierMSF) 1
		lappend LesFramesFetchees [AfficheVariable $TFA "AvecBlasteAvecFormate"]
		continue
	    }
	}
    }
    
    if {[llength $LesFramesFetchees]>0} {
	return [lindex $LesFramesFetchees 0]
    }

}

proc AfficheFetchFromTaxoLine {Ligne {Titre ""}} {

    if {[regexp "\n" $Ligne]} {
	set LesFen {}
	foreach Li [split $Ligne "\n"] {
	    lappend LesFen [AfficheFetchFromTaxoLine $Li $Titre] 
	}
	return $LesFen
    }
    set iDernierDoubleBlanc [string last "  " $Ligne]
    set Access ""
    scan [string range $Ligne $iDernierDoubleBlanc end] "%s" Access
    return [AfficheFetch $Access $Titre]

}

proc AfficheFicheInfo {K} {

    global RepertoireDuGenome
    set Id      [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Nom     [lindex $MesTags 0]

    set Fichier "$RepertoireDuGenome/bilan/$Nom"
    if {![file exists $Fichier]} {
	set Fichier "$RepertoireDuGenome/ProtAndmRNA/$Nom"
    }
    if {[file exists $Fichier]} {
	set Texte [ContenuDuFichier $Fichier]
	AfficheVariable $Texte "" $Fichier
    } else {
	SeeAby Show $Nom
    }
    return

}

proc AfficheFichier {Fichier {Maniere ""}} {

    
    if { $Fichier == "" } return ""
    if { [FileAbsent $Fichier]} {
	if { ! [regexp {.gz$} $Fichier] && [FileExists "$Fichier.gz"]} {
	    return [AfficheFichier "$Fichier.gz" $Maniere]
	}
	FaireLire "I wanted to show the file \n$Fichier\n It doesn't exist. Sorry."
	return ""
    }
    if {[file isdirectory $Fichier]} {
	set Page "[file dirname $Fichier]\n"
	if { ! [regexp "/" $Page]} { set Page "./$Page" }
	append Page [join [lsort [glob -nocomplain "$Fichier/*"]] "\n"]
    } else {
	if {[EstUnFichierImage $Fichier]} { return [ShowImage $Fichier] }
	set Page [ContenuDuFichier $Fichier]
    }
    return [Affiche $Page $Maniere $Fichier]

}

proc AfficheFournisseur {Selection} {

    if {[regexp "\n" $Selection]} {
	foreach Ligne $Selection {
	    AfficheFournisseur $Ligne
	}
	return ""
    }
    if { ! [regexp {P[0-9]+} $Selection P]} { return "" }
    set Fournis [Fournisseur $P]
    if {$Fournis==""} {
	return [AfficheVariable "Sorry. No order file was found for $P" "" "OrderFileOf_$P"]
    }
    scan $Fournis "%s %s" Lieu Fichier
    set Page "$Fichier\n$Lieu"
    if {[file exists $Fichier]} { append Page "\n[ContenuDuFichier $Fichier]" }
    set Fen [AfficheVariable $Page "AvecOli" "OrderFileOf_$P"]
    Illumine $P $Fen
    return $Fen

}

proc AfficheFrameDebug {} {

    # Debuggage
    # Permet de resourcer un fichier (merci rR)
    # Permet d'executer une commande

    global FAS CAE NomFenetreOrdali FrmDebug

    set FrmDebug "$NomFenetreOrdali.fdev"
    frame $FrmDebug
    grid $FrmDebug -row 6 -column 0 -sticky ew -padx 10 -pady 1

    grid columnconfig $FrmDebug {0 2} -weight 0
    grid columnconfig $FrmDebug 1     -weight 1
    grid rowconfig    $FrmDebug 0     -weight 0

    if {! [Devlpt]} {return}

    label $FrmDebug.lblc -text "Command"
    entry $FrmDebug.entc -background white -textvariable CAE
    button $FrmDebug.okc -text " OK " -bg green1 -command "uplevel #0 \[$FrmDebug.entc get\]"

    grid $FrmDebug.lblc -column 0 -row 0 -sticky e
    grid $FrmDebug.entc -column 1 -row 0 -sticky ew
    grid $FrmDebug.okc  -column 2 -row 0 -sticky w

    update

    return

}

proc AfficheFrameFeatures {} {

    global FrmBouton FrmImgM NomNomSeq NomFenetreOrdali OrdEtcDir

    set FrmBouton $NomFenetreOrdali.fbout
    frame $FrmBouton
    grid $FrmBouton -row 5 -column 0 -padx 10 -pady 10 -sticky news

    frame $FrmBouton.fimg
    grid $FrmBouton.fimg -row 0 -column 0 -sticky ""
    
    grid columnconfig $FrmBouton 0 -weight 0
    grid columnconfig $FrmBouton 1 -weight 1
    grid rowconfig    $FrmBouton 0 -weight 1

    set wmac "$FrmBouton.fimg.limg"
    set Wdt [expr {[winfo reqwidth $NomNomSeq] - 10}]
    set fmacsim [file join $OrdEtcDir "MACSIM_50px_cut_transparent.gif"]
    image create photo macsim
    macsim read $fmacsim -shrink
    label $wmac  -image macsim  -anchor n  -width $Wdt
    grid $wmac -row 0 -column 0 -sticky news
    grid columnconfig $FrmBouton.fimg 0 -weight 0
    grid rowconfig    $FrmBouton.fimg 0 -weight 0
    
    return

}

proc AfficheFrameScores {} {

    global FrmScores NomFenetreOrdali

    set w $NomFenetreOrdali
    set FrmScores "$w.scores"
    frame $FrmScores
    grid $FrmScores -row 4 -column 0 -sticky ew

    return

}

proc AfficheFrameSequences {} {

    global LNOrdali Defauts TScrollX TScrollY NomFenetreOrdali
    global NomNomSeq NomTextSeq FrmSequence SearchNom
    global wtn wtx wxx wxn

    set w $NomFenetreOrdali
    set FrmSequence "$w.lessequences"
    frame $FrmSequence
    grid $FrmSequence -row 3 -column 0 -padx 5 -sticky news

    #
    # widgets to display names of sequences, and
    # sequences, with their scrollbars
    #
    set TScrollX   $w.lessequences.scrollxseq
    set TScrollY   $w.lessequences.scrolly
    set NomNomSeq  $w.lessequences.textnomseq
    set NomTextSeq $w.lessequences.textsequence
    set wxn $NomNomSeq
    set wxx $NomTextSeq
    set wtx "$FrmSequence.biotextsequence"

    # Names
    if {[info exists LNOrdali]} {
	set WdtNom [expr {[PlusLongEltDe $LNOrdali]+1}]
	puts "WdtNom $WdtNom in"
	puts [set Defauts(LongNom)]
	if {$WdtNom > [set Defauts(LongNom)]} {
	    set WdtNom [set Defauts(LongNom)]
	}
    } else {
	set WdtNom 10
    }
    puts "WdtNom $WdtNom"
    text $w.lessequences.textnomseq  -relief sunken  -bd 2  -font SeqFont  -cursor left_ptr  -yscrollcommand "$FrmSequence.scrolly set"  -setgrid 1  -width $WdtNom  -wrap none  -foreground black  -background white  -selectforeground black  -selectbackground white  -inactiveselectbackground white  -state disabled  -selectborderwidth 0  -autoseparators 0  -undo 1  -highlightthickness 0
    
    # Sequences : biotext widget for seqlab , 
    #             text    widget otherwise
    biotext $FrmSequence.biotextsequence  -yscrollcommand "FromScrollYBiotext2Names"  -xscrollcommand "$TScrollX set"  -height 20  -width 60  -relief flat  -class Biotext  -bd 0 
    
    text $w.lessequences.textsequence  -xscrollcommand "$FrmSequence.scrollxseq set"  -yscrollcommand "$FrmSequence.scrolly set"  -relief sunken  -height 20  -width 60  -bd 2  -cursor left_ptr  -font SeqFont  -wrap none  -state disabled  -foreground black  -background white  -insertwidth 6  -insertbackground yellow  -selectborderwidth 0  -autoseparators 0  -undo 1  -highlightthickness 0
    
    # position ruler
    text $w.lessequences.regle  -bd 0  -state disabled  -font SeqFont  -cursor left_ptr  -foreground black  -background white  -xscrollcommand "$w.lessequences.scrollxseq set"  -setgrid 1  -wrap none  -height 2
    
    scrollbar $w.lessequences.scrollxseq  -orient horiz  -command [list CoupleX]  -width 8  -bd 2
    scrollbar $w.lessequences.scrolly  -width 8  -command "CoupleY"  -bd 2
    
    # Frame to display cursor position in sequence 
    frame $w.lessequences.fpos  -width 17  -relief sunken  -bd 1
    grid $w.lessequences.fpos  -row 3 -column 1  -sticky w
    label $w.lessequences.fpos.tposg  -text "gen "  -relief flat  -width 4  -anchor w
    label $w.lessequences.fpos.vposg  -textvariable XGen  -relief flat  -width 4  -anchor w
    label $w.lessequences.fpos.tposs  -text " seq "  -relief flat  -width 5  -anchor w
    label $w.lessequences.fpos.vposs  -textvariable XSeq  -relief flat  -width 4  -anchor w
    grid $w.lessequences.fpos.tposg -row 0 -column 0 -sticky w
    grid $w.lessequences.fpos.vposg -row 0 -column 1 -sticky w
    grid $w.lessequences.fpos.tposs -row 0 -column 2 -sticky w
    grid $w.lessequences.fpos.vposs -row 0 -column 3 -sticky w
    
    grid columnconfig $w.lessequences.fpos all -weight 0
    grid rowconfig    $w.lessequences.fpos 0 -weight 0

    # entry to search for a sequence name
    entry $w.lessequences.srcnom  -width [expr {$WdtNom-2}]  -textvariable SearchNom  -relief groove -bd 2  -background white
    bind $w.lessequences.srcnom  [list ChercheNom]
    
    # then gridify all that !
    grid $w.lessequences.textnomseq  -row 0 -column 0  -sticky news
    grid $w.lessequences.scrolly  -row 0 -column 3  -sticky ns
    grid $w.lessequences.textsequence  -row 0 -column 1  -columnspan 2  -sticky news
    grid $w.lessequences.srcnom  -row 1 -column 0  -sticky w
    grid $w.lessequences.regle  -row 1 -column 1  -columnspan 2  -sticky ew
    # ATTENTION
    # on laisse la row 2 vide pour y mettre 
    # le profil de conservation si besoin !
    grid $w.lessequences.scrollxseq  -row 3 -column 2  -sticky ew

    grid rowconfig    $FrmSequence 0 -weight 1
    grid rowconfig    $FrmSequence {1 2 3} -weight 0
    grid columnconfig $FrmSequence {0 1 3} -weight 0
    grid columnconfig $FrmSequence 2 -weight 1

    $NomTextSeq tag configure TagZoneClus -background green1 -foreground red

    #update idletasks

    return

}

proc AfficheGenscanDuContig {Selection} {


    Wup "Shows Genscan output for all contig of selection"

    if {$Selection==""} { return "" }

    set F ""
    foreach Ligne [split $Selection "\n"] {
	scan $Ligne "%s" ChroContig
	set FichierGSC [GenScanEnStock $ChroContig "FileNamePlease"]
	if {$FichierGSC==""} { continue }
	set F [AfficheFichier $FichierGSC "AvecRien"]
	set B [BoutonneLaFenetre $F "See DNA of sel.\nBlastP sel. prot" ""]
	$B configure -background "green"
	bind $B <1> "VoirADNduContig $ChroContig \[selection get\]"
	bind $B  "Blaste P \[selection get\]"
    }
    return $F

}

proc AfficheGroupesDansSeqlab {} {


    global LNSeqlab
    global LSSeqlab
    global NomTextSeq
    global NomNomSeq
    global LNDG
    global SDG

    $NomNomSeq configure -state normal

    set Q 1
    set P 0
    set LStmp {}
    set LNtmp {}
    foreach g $LNDG {
	if {$g == "GroupeToutLeMonde"} {continue}
	$NomTextSeq insert $Q.0 " \n"
	$NomNomSeq  insert $Q.0 " \n"
	set LNSeqlab [linsert $LNSeqlab $P " "]
	lappend LStmp " "
	lappend LNtmp " "
	incr Q
	incr P

	foreach s [set SDG($g)] {
	    set i [lsearch $LNSeqlab $s]
	    set y [expr {$i+1}]
	    set dmpT  [$NomTextSeq dump -tag $y.0 $y.0 lineend]
	    set LtagT [TagsDuDump $dmpT]
	    set Seq   [$NomTextSeq get $y.0 "$y.0 lineend"]

	    lappend LNtmp $s
	    lappend LStmp $Seq

	    set LNSeqlab [lreplace $LNSeqlab $i $i]
	    set LNSeqlab [linsert $LNSeqlab $P $s]
	    $NomTextSeq delete $y.0 [expr {$y+1}].0
	    $NomTextSeq insert $Q.0 "${Seq}\n"
	    $NomNomSeq  delete $y.0 [expr {$y+1}].0
	    if {[regexp {^PDB_[0-9]} $s]} {
		set t PDB
	    } else {
		set t ""
	    }
	    $NomNomSeq  insert $Q.0 "$s\n" $t
	    foreach {t x1 x2} $LtagT {
		$NomTextSeq tag add $t $Q.$x1 $Q.$x2
	    }
	    incr Q
	    incr P
	}
    }

    set LNSeqlab $LNtmp
    set LSSeqlab $LStmp

    $NomNomSeq configure -state disabled

    return

}

proc AfficheHelp {{Quoi ""}} {


    Wup "Permet de donner une petite aide pour les commandes disponibles"

    set    Texte ""
    append Texte "Graph Panel:\n"
    append Texte "------------\n"
    append Texte "   Panel that allows you display or hide,\n"
    append Texte "   \tGraph itself\n"
    append Texte "   \tAverage\n"
    append Texte "   \tAll or none\n\n"
    append Texte "GC Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: 100% GC bases\n"
    append Texte "   Middle Value: Average composition in GC bases\n"
    append Texte "   Lower  Value: 100% AT bases\n"
    append Texte "   Enter  Display the %GC of the current Position\n\n"
    append Texte "Tm Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: maximum Tm value\n"
    append Texte "   Middle Value: Average Tm value\n"
    append Texte "   Lower  Value: minimum Tm value\n"
    append Texte "   Enter  Display the Tm of the current Position\n\n"
    append Texte "Identity Percent (Blastn):\n"
    append Texte "--------------------------\n"
    append Texte "   Upper  Value: 100% Id\n"
    append Texte "   Middle Value: Average Id percent\n"
    append Texte "   Lower  Value: 0%   Id\n"
    append Texte "   Enter  Display the %Id of the current Position\n\n"
    append Texte "Sequence Content (Blastn):\n"
    append Texte "--------------------------\n"
    append Texte "   Upper  Value: maximum number of sequence\n"
    append Texte "   Middle Value: Average number of sequence\n"
    append Texte "   Lower  Value: minimum number of sequence\n"
    append Texte "   Enter  Display the number of sequence under the current Position\n\n"
    append Texte "Query:\n"
    append Texte "------\n"
    append Texte "   Mouse 1 Basic nucleic informations (GC, length, Tm ...)\n"
    append Texte "   Mouse 2 Fetch Sequence (informations from the bank)\n"
    append Texte "   Mouse 3 Display Query s Sequence in fasta format\n\n"
    append Texte "Oligonucleotide (Probe):\n"
    append Texte "------------------------\n"
    append Texte "   Enter   Display Information about the current Oligo\n"
    append Texte "   Mouse 1 Display the Position regarding the Query\n"
    append Texte "   Mouse 2 Display Oligo s specificity\n"
    append Texte "   Mouse 3 Display Oligo s Sequence (fasta format)\n"
    append Texte "   Shift  -2 Display Oligo s specificity in detail\n"
    append Texte "   Control-1 Select the oligonucleotide for that database\n"
    append Texte "   Control-2 Select the oligonucleotide as X-Selection"

    if {$Quoi=="DuBouton"} {
	after idle {   .fairelire.msg configure -wraplength 10i -background red -font "Courier 12"}
	tk_dialog      .fairelire "Please press OK" "$Texte" {} 0 Acknowledge
	catch {destroy .fairelire}
	return ""
    } else {return $Texte}

}

proc AfficheHelpDuPrimer {{Quoi ""}} {


    Wup "Permet de donner une petite aide pour les commandes disponibles"

    set    Texte ""
    append Texte "Graph Panel:\n"
    append Texte "------------\n"
    append Texte "   Panel that allows you display or hide,\n"
    append Texte "   \tGraph itself\n"
    append Texte "   \tAverage\n"
    append Texte "   \tAll or none\n\n"
    append Texte "GC Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: 100% GC bases\n"
    append Texte "   Middle Value: Average composition in GC bases\n"
    append Texte "   Lower  Value: 100% AT bases\n"
    append Texte "   Enter  Display the %GC of the current Position\n\n"
    append Texte "Tm Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: maximum Tm value\n"
    append Texte "   Middle Value: Average Tm value\n"
    append Texte "   Lower  Value: minimum Tm value\n"
    append Texte "   Enter  Display the Tm of the current Position\n\n"
    append Texte "Query:\n"
    append Texte "------\n"
    append Texte "   Mouse 1 Basic nucleic informations (GC, length, Tm ...)\n"
    append Texte "   Mouse 2 Fetch Sequence (informations from the bank)\n"
    append Texte "   Mouse 3 Display Query s Sequence in fasta format\n\n"
    append Texte "Primer:\n"
    append Texte "-------\n"
    append Texte "   Enter   Display Information about the current Primer\n"
    append Texte "   Mouse 1 Display the Position regarding the Query\n"
    append Texte "   Mouse 2 Display Primer s informations\n\n"
    append Texte "Amplified Region:\n"
    append Texte "-----------------\n"
    append Texte "   Enter   Display Information about the current Region\n"
    append Texte "   Mouse 1 Display the Position regarding the Query\n"
    append Texte "   Mouse 2 Display Region s sequence"

    if {$Quoi=="DuBouton"} {
	after idle {.fairelire.msg configure -wraplength 10i -background red -font "Courier 12"}
	tk_dialog      .fairelire "Please press OK" "$Texte" {} 0 Acknowledge
	catch {destroy .fairelire}
	return ""
    } else {return $Texte}

}

proc AfficheHelpInfoDeMaSequence {{Quoi ""}} {


    Wup "Permet de donner une petite aide pour les commandes disponibles"

    set Texte ""
    append Texte "Designing Help:\n"
    append Texte "---------------\n"
    append Texte "You are able to display, select and save designing area(s).\n"
    append Texte "   Shift  -1             Show position on the query\n"
    append Texte "   Control-1             Put one Flag for area selection\n\n"
    append Texte "   Mouse 1(Green button) Show previously areas (in the Panel)\n"
    append Texte "   Mouse 2(Green button) Save areas (!!It overwrite previous!!)\n"
    append Texte "   Mouse 3(Green button) Clear areas\n"

    append Texte "Graph Panel:\n"
    append Texte "------------\n"
    append Texte "   Panel that allows you display or hide,\n"
    append Texte "   \tGraph itself\n"
    append Texte "   \tAverage\n"
    append Texte "   \tAll or none\n\n"

    append Texte "GC Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: 100% GC bases\n"
    append Texte "   Middle Value: Average composition in GC bases\n"
    append Texte "   Lower  Value: 100% AT bases\n"
    append Texte "   Enter  Display the %GC of the current Position\n\n"

    append Texte "Tm Content:\n"
    append Texte "-----------\n"
    append Texte "   Upper  Value: maximum Tm value\n"
    append Texte "   Middle Value: Average Tm value\n"
    append Texte "   Lower  Value: minimum Tm value\n"
    append Texte "   Enter  Display the Tm of the current Position\n\n"
		  
    append Texte "Query:\n"
    append Texte "------\n"
    append Texte "   Mouse 2 Fetch Sequence (informations from the bank)\n"
    append Texte "   Mouse 3 Display Query s Sequence in fasta format"
		  
    if {$Quoi=="DuBouton"} {
	after idle {.fairelire.msg configure -wraplength 10i -background red -font "Courier 12"}
	tk_dialog .fairelire "Please press OK" "$Texte" {} 0 Acknowledge
	catch {destroy .fairelire}
	return ""
    } else {return $Texte}

}

proc AfficheHelpOligoArray {{Quoi ""}} {


    Wup "Permet de donner une petite aide pour les commandes disponibles"

    set Texte ""
    append Texte "GC Content:\n"
    append Texte "   Upper  Value: 100% GC bases\n"
    append Texte "   Middle Value: Average composition in GC bases\n"
    append Texte "   Lower  Value: 100% AT bases\n"
    append Texte "   Enter  Display the %GC of the current Position\n"
		  
    append Texte "Query:\n"
    append Texte "   Mouse 2 Fetch Sequence (informations from the bank)\n"
    append Texte "   Mouse 3 Display Query's Sequence in fasta format\n"
		  
    append Texte "Oligonucleotide (Probe):\n"
    append Texte "   Mouse 1 Display the Position regarding the Query\n"
    append Texte "   Mouse 2 Display Oligo's specificity\n"
    append Texte "   Mouse 3 Display Oligo's Sequence (fasta format)\n"
    append Texte "   Enter   Display Information about the current Oligo"

    if {$Quoi=="DuBouton"} {
	return "[AfficheVariable $Texte "SansRien" "Help"]"
    } else {return $Texte}

}

proc AfficheInfoBulle {K X Y Action} {


    Wup "Permet d avoir des InfoBulles pour des Id dans un canvas"    
    Wup "Ces InfosBulles sont independantes du canvas"
    
    catch {destroy .infobulle}

    if {$Action=="Leave"} {return ""}
    
    set Id      [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Texte   [lindex $MesTags 1]

    #Les coordonnees de l Id a InfoBuller
    set MesCoords [$K coords $Id]
    set Xmin      [lindex $MesCoords 0]
    set Xmax      [lindex $MesCoords 2]
    set Ymin      [lindex $MesCoords 1]
    set Ymax      [lindex $MesCoords 3]

    #Cas particulier des lignes verticales on prend comme repere la position de la souris
    if {$Ymin==$Ymax} {set Xmin $X;set Xmax $X}
    #Correction pour ceux avec seulement 2 coordonnees
    if {$Xmax==""} {set Xmax $Xmin}
    if {$Ymax==""} {set Ymax $Ymin}

    #Il nous faut les mensurations de l objet a InfoBuller
    if {$Xmax>$Xmin} {
	set TagLargeur [expr $Xmax-$Xmin]
    } else {
	set TagLargeur [expr $Xmin-$Xmax]
	set Xtmp $Xmin
	set Xmin $Xmax
	set Xmax $Xtmp
    }
    if {$Ymax>$Ymin} {
	set TagHauteur [expr $Ymax-$Ymin]
    } else {
	set TagHauteur [expr $Ymin-$Ymax]
	set Ytmp $Ymin
	set Ymin $Ymax
	set Ymax $Ytmp
    }

    #Les positions initiales du canvas contenant Id
    set PosX [winfo rootx $K]
    set PosY [winfo rooty $K]

    #Correction pour le facteur de Zoom
    set Facteurx [ZoomFacteur $K X]
    #set Facteury [ZoomFacteur $K Y]
    set Xmin     [expr $Xmin/$Facteurx]
    set Xmax     [expr $Xmax/$Facteurx]

    #Creation du InfoBulle independant du canvas
    toplevel .infobulle -background "black"
    wm overrideredirect .infobulle 1
    label .infobulle.label  -text       "$Texte"  -relief     "flat"  -font       {Courier 8}  -background "lightyellow"  -foreground "black"  -padx       "2"  -pady       "0"  -anchor     "w"  -justify    "left"

    #1 Creation
    pack .infobulle.label -side "left" -padx "1" -pady "1"
    #2 On Oublie
    wm withdraw .infobulle
    update
    if {! [winfo exists .infobulle]} {return ""} 
    #3 Recuperation des mensurations
    set MessageLargeur [winfo width  .infobulle]
    set MessageHauteur [winfo height .infobulle]
    if {$MessageLargeur=="1" && $MessageHauteur=="1"} {
	set MessageLargeur [winfo reqwidth  .infobulle]
	set MessageHauteur [winfo reqheight .infobulle] 
    }
    
    #4 Ajustement des positions de l InfoBulle
    #4 Par rapport a l objet a infobuller
    #4 Par rapport a sa position sur l ecran
    #Sur Beaufort le withdraw empeche d avoir la taille de la fenetre voir mise a jour
    #Mais le reqwidth et le reqheight contourne le pb
    set OnForceADroite 1
    set OnForceEnBas   0
    if {$MessageHauteur==1} {set OnForceADroite 0}
    if {$MessageLargeur==1} {set OnForceEnBas   1}

    set EcranHauteur [winfo screenheight .]
    set EcranLargeur [winfo screenwidth  .]
    if {$OnForceADroite && $X > [expr $EcranLargeur/2]} {
	#On affiche a gauche
	incr X -15
	while {$X>$Xmin} {incr X -15}
	set PosX [expr $PosX - $MessageLargeur +$X]
    } else {
	#On affiche a droite
	incr X 15
	while {$X<$Xmax} {incr X 15}
	set PosX [expr $PosX + $X]
    }
    if {$OnForceEnBas || $Y< 50} {
	#On affiche en bas
	incr Y 10 
	set PosY [expr $PosY + $Y]
    } else {
	#On affiche en haut
	incr Y -10 
	set PosY [expr $PosY - $MessageHauteur +$Y]
    }

    set PosX [format "%.0f" $PosX]
    set PosY [format "%.0f" $PosY]

    #Ajustement final des positions de l InfoBulle et positionnement
    if {$PosX<0} {
	#On sort de l ecran par la gauche
	set PosX 0
    } elseif {[expr $PosX + $MessageLargeur]> $EcranLargeur} {
	#On sort de l ecran par le droite
	set PosX [expr $EcranLargeur - $MessageLargeur]
    }
    if {$PosY<0} {
	#On sort de l ecran par le dessus
	set PosY 0
    } elseif {[expr $PosY + $MessageHauteur]> $EcranHauteur} {
	#On sort de l ecran par le dessous
	set PosY [expr $EcranHauteur - $MessageHauteur]
    }

    wm geometry .infobulle +${PosX}+${PosY}
           bind .infobulle    "destroy .infobulle"
           bind .infobulle <1>       "destroy .infobulle"
           bind $K          "destroy .infobulle"
    #5 Apres avoir oublie la fenetre on se souvient
    wm deiconify .infobulle
    return ""

}

proc AfficheLEnvironnementDeGscope {{Comment ""} {Quoi ""}} {

    global env
    global InfoScript
    global FichierGscopeSource
    global WithPackage

    if {$Comment==""} { set Comment "Show" }

    set LaPage {}
    catch {lappend LaPage [format "%-30s %s" RunningSince "[CaVa RunningSinceDate] as [CaVa Science]"] } 
    catch {lappend LaPage [format "%-30s %s" HostName [Hostname]]}
    catch {lappend LaPage [format "%-30s %s" Dialog [DialogPort "GetAll"]]}
    catch {lappend LaPage [format "%-30s %s" GscopeDir [GscopeDir]]} 
    catch {lappend LaPage [format "%-30s %s" GscopeContrib [GscopeContrib]] }
    catch {lappend LaPage [format "%-30s %s" GscopeSource $FichierGscopeSource]} 
    catch {lappend LaPage [format "%-30s %s" RepertoireDuGenome [RepertoireDuGenome]]} 
    catch {lappend LaPage [format "%-30s %s" RepertoireDeTravail [RepertoireDeTravail]]}
    catch {lappend LaPage [format "%-30s %s" HumanGenomeDir [HumanGenomeDir]]}
    catch {lappend LaPage [format "%-30s %s" OntologyDir [OntologyDir]]}
    catch {lappend LaPage ""}
    catch {lappend LaPage [format "%-30s %s" script [InfoScript]] }
    catch {lappend LaPage ""}
    catch {lappend LaPage [format "%-30s %s" OutsideCSTB [OutsideCSTB]] }
    lappend LaPage ""
    foreach P [array names WithPackage] {
	if {[regexp "Default" $P]} { continue }
	lappend LaPage [format "%-30s %s" "Pack $P" [WithPackage $P]] 
    }
    if {$Quoi!="WithoutEnv"} {
	lappend LaPage ""
	foreach V [array names env] {
	    lappend LaPage [format "%-30s %s" $V [set env($V)]] 
	}
    }
    set Display "not set"
    if {[info exists env(DISPLAY)]} { set Display $env(DISPLAY) }
    lappend LaPage [format "%-30s %s" DISPLAY $Display]

    set Page [join $LaPage "\n"]
    if {$Comment=="GetItAsText"} { return $Page }
    if {[PourWscope]} { return [Html_DuTexteTelQuel $Page] }
    if {$Comment=="GetIt"} { return $Page }
    return [AfficheVariable $Page "" "Gscope's environment"]

}

proc AfficheLaProc {Procedure} {


    Wup "Shows the proc Procedure or lappend to the called procs"

    scan [string trim $Procedure] "%s" Procedure

    if {[info procs $Procedure]=={}} { return "" }
 
    set Args [info args $Procedure]
    set Body [info body $Procedure]
    set TexteProc "$Procedure {$Args} {\n$Body\n}"

    if {[PourWscope]} { return [Html_DuTexteTelQuel $TexteProc] }

    return [ShowText $TexteProc "SansFetchAvecRienAvecCallProcGrandeLargeur" $Procedure]

}

proc AfficheLaQuery {K FichierQuery} {


    Wup "Permet d afficher la sequence tfa de la query"
    
    if {!  [file exists $FichierQuery]} {
	if {[regexp {/} $FichierQuery]} {
	    set PAB [file tail $FichierQuery]
	} else {
	    set PAB $FichierQuery
	}
	set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
	set Repnuctfa "[RepertoireDuGenome]/nuctfa"
	if {      [file exists "$RepmRNA/$PAB"]} {
	    set FichierQuery   "$RepmRNA/$PAB"
	} elseif {[file exists "$Repnuctfa/$PAB"]} {
	    set FichierQuery   "$Repnuctfa/$PAB"
	} else {set FichierQuery ""}
    }
    if {$FichierQuery == ""} {return [AfficheVariable "No sequence file for $FichierQuery"]}
    set LeTFADeLaQuery [join [LesLignesDuFichier $FichierQuery] "\n"]

    return "[AfficheVariable $LeTFADeLaQuery "" "$FichierQuery"]"

}

proc AfficheLaRechercheDansLesBody {{Texte ""}} {

    set LesTrouvees [RechercheDansLesBody $Texte]
    if {$LesTrouvees=={}} { return "" }
    return [ShowText [join $LesTrouvees "\n"]  "SansFetchAvecRienAvecAffiProc" "Procs containing your text."]

}

proc AfficheLaSeqTFA {K Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set DQ     [lindex $MesTags 0]
    set FQ     [lindex $MesTags 1]
    set DS     [lindex $MesTags 2]
    set FS     [lindex $MesTags 3]
    set Strand [lindex $MesTags 4]
    set Type   [lindex $MesTags 5]
    set nType  [lindex $MesTags 6]
    set SeqTFA [lindex $MesTags 7]
 
    AfficheVariable $SeqTFA "AvecFormateAvecBlaste"
    return ""

}

proc AfficheLaSequenceDeLOligo {K PAB} {


    Wup "Affiche la sequence tfa de l oligo du PAB voulu"
    Wup "Mise a jour pour InterrogeInfoDeOligo"
        
    set Id       [$K find withtag current]
    set MesTags  [$K gettags $Id]
    set NomOligo [lindex $MesTags 4]
    set Dir      [lindex $MesTags 5]

    set Fichier "$Dir/${PAB}.oligo"
    if {! [file exists $Fichier]} {
	set Fichier "$Dir/$PAB"
	if {! [file exists $Fichier]} {return ""}
    }
    set Entete     ">$PAB $NomOligo"
    set Sequence   [InterrogeInfoDeLOligo $Fichier $NomOligo Sequence]
    set TFADeOligo [join [list $Entete $Sequence] "\n"]
    
    return [AfficheVariable $TFADeOligo "AvecFormateAvecBlaste" "$Dir/$PAB"]

}

proc AfficheLabels {} {

    if {$::pgl(Text2Show) == {} } {
	return
    } else {
	set Lxt $::pgl(Text2Show)
	if {$::pgl(TextDeDist) != {}} {
	    lappend Lxt {*}$::pgl(TextDeDist)
	}
    }

    # recup de la matrice de modelisation
    set mvmatrix [tcl3dVector GLdouble 16]
    glGetDoublev GL_MODELVIEW_MATRIX $mvmatrix
    set modmat [tcl3dVectorToList $mvmatrix 16]

    # recup de la matrice de projection
    set pjmatrix [tcl3dVector GLdouble 16]
    glGetDoublev GL_PROJECTION_MATRIX $pjmatrix
    set pgl(projmat) [tcl3dVectorToList $pjmatrix 16]
    set projmat $pgl(projmat)

    # Recup du viewport
    set viewmat [tcl3dVector GLint 4]
    glGetIntegerv GL_VIEWPORT $viewmat
    set pgl(viewport) [tcl3dVectorToList $viewmat 4]
    set viewport $pgl(viewport)

    # print the string
    glMatrixMode GL_MODELVIEW
    glPushMatrix
    glLoadIdentity

    foreach {x y z text} $Lxt {
	set xa [expr {[lindex $modmat 0]*$x + [lindex $modmat 4]*$y + [lindex $modmat 8]*$z + [lindex $modmat 12]}]
	set ya [expr {[lindex $modmat 1]*$x + [lindex $modmat 5]*$y + [lindex $modmat 9]*$z + [lindex $modmat 13]}]
	set za [expr {[lindex $modmat 2]*$x + [lindex $modmat 6]*$y + [lindex $modmat 10]*$z + [lindex $modmat 14]}]

	glRasterPos3f $xa $ya $za

	printString $text
    }

    glPopMatrix

    return

}

proc AfficheLeBlastNDuContig {K x y} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set QueryFraction   [lindex [$K gettags $Id] 0]
    scan $QueryFraction "%s %s" Contig Fraction

    set w [AfficheFichier "$RepertoireDuGenome/blastn/TTH-$Contig" "AvecRien"]
    Illumine $Fraction $w

}

proc AfficheLeClusterXHda {Nom} {


    set LeClusterXHda [LeClusterXHda $Nom]
  
    if {$LeClusterXHda=={}} {
	FaireLire "No cluster available"
	return ""
    }
    foreach PAB $LeClusterXHda {
	set DE [DefinitionApproximative $PAB]
	lappend LeTexte "$PAB $DE"
    }

    #Jean a rajoute Tri et bind3
    set Texte [join $LeTexte "\n"]
    set Fen [AfficheVariable $Texte "AvecRien" "${Nom}_X-HDA_cluster"]
    set   B [BoutonneLaFenetre $Fen "X-HDA Sel/Sort\nAll/Sort\nInfoClust/OntoClust/Dpc"]
    bind $B <1>       "CreeEtAfficheUnBilanHDACroises \[selection get\]"
    bind $B <2>       "CreeEtAfficheUnBilanHDACroises \[selection get\] AvecTri"
    bind $B  "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\]"
    bind $B  "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\] AvecTri"
    bind $B  "AfficheLesInfosDuCluster"
    bind $B  "OntologyDesClusters \[set PagePropre($Fen)\]"
    bind $B  "DpcShow"
         $B configure -background "green"

    return $Fen

}

proc AfficheLeNombreDeResidusDansLesDomaines {FichierMSF FichierBornes} {

    foreach Ligne [LesLignesDuFichier $FichierBornes] {
	scan $Ligne "%s %s" D F 
	set LesComptes [LeNombreDeResidusDansLeDomaine $FichierMSF $D $F]
	EspionneL $LesComptes
	foreach Compte $LesComptes {
	    scan $Compte "%s %d" Access nRes
	    if { ! [info exists DejaVu($Access)]} { lappend LesAccess $Access }
	    set DejaVu($Access) 1
	    lappend LesResultats($Access) $D $F $nRes 
	}
    }
    foreach Access $LesAccess {
	set Ligne [format "%-10s" $Access]
	foreach {D F nRes} [set LesResultats($Access)] {
	    append Ligne [format "%5s-%4s=%4s  " $D $F $nRes]
	}
	lappend LesLignes $Ligne
    }
    return [AfficheVariable [join $LesLignes "\n"] "" "ResidueCountOf_$FichierMSF"]
    

}

proc AfficheLePlot {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set TypeCGH [lindex $MesTags 4]
    ### transformation de la val en log base 10 (oligo CGH) en log base 2
    if {$TypeCGH!="CGH"} {
	set Val [format "%.2f" [expr [lindex $MesTags 3] *1.0]]
	set Val [format "%.2f" [expr $Val*log(10)/log(2)] *1.0]
	set Posinf [lindex $MesTags 1]
	set Possup [lindex $MesTags 2]
	regsub -all {^0*} $Posinf "" Posinf
	regsub -all {^0*} $Possup "" Possup
	set PosMid [expr $Posinf + (($Possup*1.0 - $Posinf*1.0)/2)]
    } else {
	set Val [format "%.2f" [expr [lindex $MesTags 2] *1.0]]
	set PosMid [lindex $MesTags 1]
    }
    set Texte "$Chro\nPosMid: $PosMid\nLog2ratio: $Val"

    ac_AfficheVariable "$Texte" "" "Summary"

    return "$Texte"

}

proc AfficheLePlotAffy {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set ProbeSet [lindex $MesTags 0]
    set PosMid [lindex $MesTags 1]
    set Val [format "%.2f" [expr [lindex $MesTags 2] *1.0]]
    if {[lindex $MesTags 3]!="Affy"} {
	set C [lindex $MesTags 3]
	regsub -all "chr" $C " chr" C
	set Texte "$ProbeSet\nPosMid: $PosMid\nVal: $Val\n!!! This probeset is multi-located ($C)!!!"
	ac_AfficheVariable "$Texte" "" "Warning"
    } else {
	set Texte "$ProbeSet\nPosMid: $PosMid\nVal: $Val"
	ac_AfficheVariable "$Texte" "" "Summary"
    }
    return "$Texte"

}

proc AfficheLeSpectreGC {K MinSpectreY MaxSpectreY} {

    global RepertoireDuGenome

    set FichierSpectre "$RepertoireDuGenome/fiches/spectregcxy"

    if { ! [file exists $FichierSpectre]} { return }

    set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]
    
    set LesCoordonnees ""
    set n 0
    set PremiereLigne 1
    foreach Ligne [LesLignesDuFichier $FichierSpectre] {
	if {$PremiereLigne} {
	    scan $Ligne "%d %d" xMin yMin
	    set PremiereLigne 0
	    set DeuxiemeLigne 1
	    continue
	}
	if {$DeuxiemeLigne} {
	    scan $Ligne "%d %d" xMax yMax
	    set DeuxiemeLigne 0
	    set TroisiemeLigne 1
	    continue
	}
	if {$TroisiemeLigne} {
	    scan $Ligne "%d %d" x yMoyen
	    set TroisiemeLigne 0
	    $K create line  $xMin [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $xMax [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
	    $K create line  $xMin [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $xMax [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
	    $K create line  $xMin [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $xMax [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
	    continue
	}

	scan $Ligne "%d %d" x y
	set XY " $x [expr $MaxSpectreY-($y-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)] "
	append LesCoordonnees $XY
	if {[incr n] > 100} {
	    eval $K create line $LesCoordonnees
	    set LesCoordonnees $XY
	    set n 1
	}
    }
    if { $n > 1 } { 
	    eval $K create line $LesCoordonnees
    }

}

proc AfficheLeSpectreGCDUneListe {K UneListe XDebutQuery XFinQuery MinSpectreY MaxSpectreY {OneNtPixel ""} {ColorLine black} {TagDuGraph GC}} {

    global RepertoireDuGenome

    Wup "Affiche le spectre GC pour IllustreOligo"

    if {$OneNtPixel==""} {set OneNtPixel 1}

    set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]
     
    set n 0
    set PremiereLigne 1
    foreach Ligne $UneListe {
	if {$PremiereLigne} {
	    scan $Ligne "%d %d" xMin yMin
	    #Mise a l echelle plus debut de la query
	    #set xMin [expr $XDebutQuery + [expr $xMin * $OneNtPixel]]
	    set VraiyMin [expr $yMin*1.0]
	    set yMin 0

	    set PremiereLigne 0
	    set DeuxiemeLigne 1
	    continue
	}
	if {$DeuxiemeLigne} {
	    scan $Ligne "%d %d" xMax yMax
	    #set xMax [expr $XFinQuery   + [expr $xMax * $OneNtPixel]]
	    #set xMax [expr $XDebutQuery + [expr $xMax * $OneNtPixel]]
	    set VraiyMax [expr $yMax*1.0]
	    set yMax 100	    
	    
	    set DeuxiemeLigne 0
	    set TroisiemeLigne 1
	    continue
	}
	if {$TroisiemeLigne} {
	    scan $Ligne "%f %f" x yMoyen
	    #set xMin   [expr $x * $OneNtPixel]
	    
	    set TroisiemeLigne 0
	    $K create text [expr $XDebutQuery-5] [expr $MaxSpectreY-($HauteurDuSpectreY/4)+(($HauteurDuSpectreY/4)/2)]  -text "% GC"  -tags [list "" "Echelle $yMin a $yMax\nMin $VraiyMin Max $VraiyMax" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine -anchor e
	    
	    #Ligne 0% de GC
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine
	    
	    #Ligne Moyenne
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "Moy GC [format "%4.1f" $yMoyen]%" "Affichable" "OligoGraph" "$TagDuGraph" "AverageGC"]  -fill $ColorLine  -dash {6 4}
	    
	    #Ligne 100% de GC
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine
	    continue
	}
	scan $Ligne "%f %f" x y
	
	set X [expr $XDebutQuery + [expr $x * $OneNtPixel]]
	set Y [expr $MaxSpectreY-((($y-$yMin)*($HauteurDuSpectreY))/($yMax-$yMin))]
	
	incr n
	if { $n > 1 } { 
	    $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y  -tags [list "" "[format "%.1f" [expr ([set Coordonnees(VraiY)]+$y)/2]] % GC" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine
	    set n 1
	}
	set Coordonnees(VraiY) $y
	set Coordonnees(LastX) $X
	set Coordonnees(LastY) $Y
	lappend LesPoints "$X $Y $y"
    }
 
    foreach Coord $LesPoints {
	set X  [lindex $Coord 0]
	set Y  [lindex $Coord 1]
	set GC [lindex $Coord 2]
	$K create line $X $Y $X $Y  -fill "$ColorLine"  -tags [list "" "[format "%.1f" $GC] % GC" "Affichable" "OligoGraph" "$TagDuGraph"] 
    }

    if {[info exists Coordonnees]} {array unset Coordonnees}
    return ""

}

proc AfficheLeSpectreGCenCouleur {K PosLineY} {

    global RepertoireDuGenome
    
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/spectregc"] {
	scan $Ligne "%d %d %s" d f Couleur
	if {[regexp "green" $Couleur]} { continue }
	$K create line $d $PosLineY $f $PosLineY -fill $Couleur -width 5
    }

}

proc AfficheLeSpectreIdDUneListe {K UneListe XDebutQuery XFinQuery MinSpectreY MaxSpectreY {OneNtPixel ""} {ColorLine black} {TagDuGraph ""}} {

    global RepertoireDuGenome

    Wup "Affiche le spectre du Nb de sequence pour IllustreOligo"

    if {$OneNtPixel==""} {set OneNtPixel 1}

    set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]

    set n 0
    set PremiereLigne 1
    foreach Ligne $UneListe {
	if {$PremiereLigne} {
	    scan $Ligne "%d %f" yMin VraiyMin
	    set PremiereLigne 0
	    set DeuxiemeLigne 1
	    continue
	}
	if {$DeuxiemeLigne} {
	    scan $Ligne "%d %f" yMax VraiyMax
	    set DeuxiemeLigne 0
	    set TroisiemeLigne 1
	    continue
	}
	if {$TroisiemeLigne} {
	    scan $Ligne "%d %f" yMoyen VraiyMoyen
	    	    	    
	    set TroisiemeLigne 0

	    $K create text [expr $XDebutQuery-5] [expr $MaxSpectreY-(2*$HauteurDuSpectreY/4)+(($HauteurDuSpectreY/4)/2)]  -text "% Id"  -tags [list "" "$TagDuGraph\nEchelle $yMin a $yMax\nMin $VraiyMin Max $VraiyMax" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine -anchor e
        
	    #Ligne min de nb seq 0
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    
	    #Ligne Moyenne
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "Moy Id [format "%4.1f" $yMoyen]%" "Affichable" "OligoGraph" "$TagDuGraph" "Average$TagDuGraph"]  -fill "$ColorLine"  -dash {6 4}

	    #Ligne de max nbseq
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    continue
	}
	scan $Ligne "%f %f" x y
	
	set X [expr $XDebutQuery + [expr $x * $OneNtPixel]]
	set Y [expr $MaxSpectreY-((($y-$yMin)*($HauteurDuSpectreY))/($yMax-$yMin))]
	
	incr n
	if {$n > 1} { 
	    $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y  -tags [list "" "[format "%.1f" [expr ([set Coordonnees(VraiY)]+$y)/2]] % Id" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill "$ColorLine"
	    set n 1
	}
	set Coordonnees(VraiY) $y
	set Coordonnees(LastX) $X
	set Coordonnees(LastY) $Y
	lappend LesPoints "$X $Y $y"
    }
 
    foreach Coord $LesPoints {
	set X  [lindex $Coord 0]
	set Y  [lindex $Coord 1]
	set Id [lindex $Coord 2]
	$K create line $X $Y $X $Y  -fill "$ColorLine"  -tags [list "" "[format "%.1f" $Id] % Id" "Affichable" "OligoGraph" "$TagDuGraph"] 
    }
    if {[info exists Coordonnees]} {array unset Coordonnees}
    return ""

}

proc AfficheLeSpectreNbSequenceDUneListe {K UneListe XDebutQuery XFinQuery MinSpectreY MaxSpectreY {OneNtPixel ""} {ColorLine black} {TagDuGraph ""}} {

    global RepertoireDuGenome

    Wup "Affiche le spectre du Nb de sequence pour IllustreOligo"

    if {$OneNtPixel==""} {set OneNtPixel 1}

    set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]

    set n 0
    set PremiereLigne 1
    foreach Ligne $UneListe {
	if {$PremiereLigne} {
	    scan $Ligne "%d %f" yMin VraiyMin
	    set PremiereLigne 0
	    set DeuxiemeLigne 1
	    continue
	}
	if {$DeuxiemeLigne} {
	    scan $Ligne "%d %f" yMax VraiyMax
	    set DeuxiemeLigne 0
	    set TroisiemeLigne 1
	    continue
	}
	if {$TroisiemeLigne} {
	    scan $Ligne "%d %f" yMoyen VraiyMoyen
	    	    	    
	    set TroisiemeLigne 0
	    $K create text [expr $XDebutQuery-5] [expr $MaxSpectreY-(4*$HauteurDuSpectreY/4)+(($HauteurDuSpectreY/4)/2)]  -text "nSeq"  -tags [list "" "$TagDuGraph\nEchelle $yMin a $yMax\nMin $VraiyMin Max $VraiyMax" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine -anchor e

	    #Ligne min de nb seq 0
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    
	    #Ligne Moyenne
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "Moy NbSeq [format "%3.1f" $yMoyen]" "Affichable" "OligoGraph" "$TagDuGraph" "Average$TagDuGraph"]  -fill "$ColorLine"  -dash {6 4}
	    
	    #Ligne de max nbseq
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    continue
	}
	scan $Ligne "%d %d" x y
	
	set X [expr $XDebutQuery + [expr $x * $OneNtPixel]]
	set Y [expr $MaxSpectreY-((($y-$yMin)*($HauteurDuSpectreY))/($yMax-$yMin))]
	
	incr n
	if {$n > 1} { 
	    $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y  -tags [list "" "[expr ([set Coordonnees(VraiY)]+$y)/2] seq(s)" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill "$ColorLine"
	    set n 1
	}
	set Coordonnees(VraiY) $y
	set Coordonnees(LastX) $X
	set Coordonnees(LastY) $Y
	lappend LesPoints "$X $Y $y"
    }
 
    foreach Coord $LesPoints {
	set X    [lindex $Coord 0]
	set Y    [lindex $Coord 1]
	set NbSq [lindex $Coord 2]
	$K create line $X $Y $X $Y  -fill "$ColorLine"  -tags [list "" "$NbSq seq(s)" "Affichable" "OligoGraph" "$TagDuGraph"] 
    }
    if {[info exists Coordonnees]} {array unset Coordonnees}
    return ""

}

proc AfficheLeSpectreTmDUneListe {K UneListe XDebutQuery XFinQuery MinSpectreY MaxSpectreY {OneNtPixel ""} {ColorLine black} {TagDuGraph ""}} {

    global RepertoireDuGenome

    Wup "Affiche le spectre du Tm pour IllustreOligo"

    if {$OneNtPixel==""} {set OneNtPixel 1}

    set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]

    set n 0
    set PremiereLigne 1
    foreach Ligne $UneListe {
	if {$PremiereLigne} {
	    scan $Ligne "%f %f" yMin VraiyMin
	    set PremiereLigne 0
	    set DeuxiemeLigne 1
	    continue
	}
	if {$DeuxiemeLigne} {
	    scan $Ligne "%f %f" yMax VraiyMax
	    set DeuxiemeLigne 0
	    set TroisiemeLigne 1
	    continue
	}
	if {$TroisiemeLigne} {
	    scan $Ligne "%f %f" yMoyen VraiyMoyen
	    	    	    
	    set TroisiemeLigne 0
	    $K create text [expr $XDebutQuery-5] [expr $MaxSpectreY-(3*$HauteurDuSpectreY/4)+(($HauteurDuSpectreY/4)/2)]  -text "Tm"  -tags [list "" "$TagDuGraph\nMin $VraiyMin Max $VraiyMax " "Affichable" "OligoGraph" "$TagDuGraph"]  -fill $ColorLine -anchor e
	    
	    #Ligne min de nb seq 0
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    
	    #Ligne Moyenne
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "Moy Tm [format "%4.1f" $yMoyen]°C" "Affichable" "OligoGraph" "$TagDuGraph" "Average$TagDuGraph"]  -fill "$ColorLine"  -dash {6 4}

	    #Ligne de max nbseq
	    $K create line  $XDebutQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  $XFinQuery  [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]  -tags [list "" "OligoGraph" "$TagDuGraph"]
	    continue
	}
	scan $Ligne "%f %f" x y
	
	set X [expr $XDebutQuery + [expr $x * $OneNtPixel]]
	set Y [expr $MaxSpectreY-($y-$yMin)*($HauteurDuSpectreY*1.0)/($yMax-$yMin)]
	
	incr n
	if {$n > 1} { 
	    $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y  -tags [list "" "[format "%.1f" [expr ([set Coordonnees(VraiY)]+$y)/2]] °C" "Affichable" "OligoGraph" "$TagDuGraph"]  -fill "$ColorLine"
	    set n 1
	}
	set Coordonnees(VraiY) $y
	set Coordonnees(LastX) $X
	set Coordonnees(LastY) $Y
	lappend LesPoints "$X $Y $y"
    }
 
    foreach Coord $LesPoints {
	set X  [lindex $Coord 0]
	set Y  [lindex $Coord 1]
	set Tm [lindex $Coord 2]
	$K create line $X $Y $X $Y  -fill "$ColorLine"  -tags [list "" "[format "%.1f" $Tm] °C" "Affichable" "OligoGraph" "$TagDuGraph"] 
    }
    if {[info exists Coordonnees]} {array unset Coordonnees}
    return ""

}

proc AfficheLesAliEnPage {Page Selection Fichier} {

    set LesSel [split $Selection "\n"]
    if {[PourWscope]} {
	set s [lindex $LesSel 0]
	return [AfficheAliEnPage $Page $s $Fichier]
    }
    foreach s $LesSel {
	AfficheAliEnPage $Page $s $Fichier
    }

}

proc AfficheLesAutresCandidats {K PAB} {


    Wup "Permet d afficher les candidats de l oligo"
    Wup "On ajoute les boutons pour les liens vers les banques"

    set Id           [$K find withtag current]
    set MesTags      [$K gettags $Id]
    set NomOligo     [lindex $MesTags 4]
    set Dir          [lindex $MesTags 5]

    set  LesAccessDef [LesAccessDefDeLOligo $PAB $NomOligo $Dir]
    if {$LesAccessDef==""} {return ""}

    set Fen  [AfficheVariable [join $LesAccessDef "\n"] "" "$NomOligo de $PAB dans [file tail $Dir]"]
    set FenB "$Fen.buttons"

    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur "white"
    set D [TouchePour $FenB "FastaCmd" ""]
    TouchePour $FenB NouvelleCouleur "green"
    TouchePour $FenB     "Sel" "catch {SauveLesInfosDe $K Win \[FastaCmd \[selection get\]\]}"
    TouchePour <2>      "/All" "catch {SauveLesInfosDe $K Win \[FastaCmd \[set PagePropre($Fen)\]\]}"
    TouchePour <3> "/Complete" "catch {SauveLesInfosDe $K Win \[FastaCmd \[selection get\] Complet\]}"
    set    Texte [format   "%-10s" "Buttons below:"]
    append Texte [format "\n%-10s" "To retrieve sequence in fasta format from blast database"]
    append Texte [format "\n%-10s" "To retrieve sequence header (access and definition)"]
    set_balloon $D "$Texte"
    $D configure -state disabled -disabledforeground "black"

    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur  "white"
    set B [TouchePour $FenB "Link Uniseq To" ""]
    TouchePour $FenB NouvelleCouleur  "green"
    TouchePour $FenB "Unigene ID Sel" "catch {SauveLesInfosDe $K Win \[LeUnigeneDeUniseq_GUI \[selection get\]\]}" 
    TouchePour <2>             "/All" "catch {SauveLesInfosDe $K Win \[LeUnigeneDeUniseq_GUI \[set PagePropre($Fen)\]\]}"
    
    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur "green"
    TouchePour $FenB "Genbank Sel" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq genbank All\]}"
    TouchePour <2>           "/Id" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]\]}"
    TouchePour <3>          "/All" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[set PagePropre($Fen)\]\]}"
    
    TouchePour $FenB "Protein Sel" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq protein All\]}"
    TouchePour <2>           "/Id" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq protein\]}"
    TouchePour <3>          "/All" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[set PagePropre($Fen)\] uniseq protein\]}"

    set    Texte [format   "%-10s" "Buttons below:"]
    append Texte [format "\n%-10s" "To Link Unigene to Genbank or to Protein database"]
    append Texte [format "\n%-10s" "Allows to retrieve access only (Id and all) or complete entry (Sel.)"]
    append Texte [format "\n%-10s" "Allows to retrieve also Unigene (Ug.xxx) id from Uniseq (HS#xxx)"]
    set_balloon $B "$Texte"
    $B configure -state disabled -disabledforeground "black"

    return $Fen

}

proc AfficheLesAutresCandidatsComplet {K PAB} {


    Wup "Permet d afficher les candidats de l oligo avec leur pourcentages d identite et leur nb bases contigues"
    Wup "On ajoute les boutons pour les liens vers les banques"

    set Id       [$K find withtag current]
    set MesTags  [$K gettags $Id]
    set NomOligo [lindex $MesTags 4]
    set Dir      [lindex $MesTags 5]
    set Debut    [lindex $MesTags 2]
    set Fin      [lindex $MesTags 3]

    set  LesAccessDef [LesAccessStatCompletes "$Dir/${PAB}.log" $Debut $Fin]
    if {$LesAccessDef==""} {return ""}
    
    set Fen  [AfficheVariable [join $LesAccessDef "\n"] "" "$NomOligo de $PAB dans [file tail $Dir]"]
    set FenB "$Fen.buttons"

    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur "white"
    set D [TouchePour $FenB "FastaCmd" ""]
    TouchePour $FenB NouvelleCouleur "green"
    TouchePour $FenB     "Sel" "catch {SauveLesInfosDe $K Win \[FastaCmd \[selection get\]\]}"
    TouchePour <2>      "/All" "catch {SauveLesInfosDe $K Win \[FastaCmd \[set PagePropre($Fen)\]\]}"
    TouchePour <3> "/Complete" "catch {SauveLesInfosDe $K Win \[FastaCmd \[selection get\] Complet\]}"
    set    Texte [format   "%-10s" "Buttons below:"]
    append Texte [format "\n%-10s" "To retrieve sequence in fasta format from blast database"]
    append Texte [format "\n%-10s" "To retrieve sequence header (access and definition)"]
    set_balloon $D "$Texte"
    $D configure -state disabled -disabledforeground "black"

    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur  "white"
    set B [TouchePour $FenB "Link Uniseq To" ""]
    TouchePour $FenB NouvelleCouleur  "green"
    TouchePour $FenB "Unigene ID Sel" "catch {SauveLesInfosDe $K Win \[LeUnigeneDeUniseq_GUI \[selection get\]\]}" 
    TouchePour <2>             "/All" "catch {SauveLesInfosDe $K Win \[LeUnigeneDeUniseq_GUI \[set PagePropre($Fen)\]\]}"
    
    TouchePour $FenB NouvelleGamme
    TouchePour $FenB NouvelleCouleur "green"
    TouchePour $FenB "Genbank Sel" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq genbank All\]}"
    TouchePour <2>           "/Id" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]\]}"
    TouchePour <3>          "/All" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[set PagePropre($Fen)\]\]}"
    
    TouchePour $FenB "Protein Sel" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq protein All\]}"
    TouchePour <2>           "/Id" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\]        uniseq protein\]}"
    TouchePour <3>          "/All" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[set PagePropre($Fen)\] uniseq protein\]}"

    set    Texte [format   "%-10s" "Buttons below:"]
    append Texte [format "\n%-10s" "To Link Unigene to Genbank or to Protein database"]
    append Texte [format "\n%-10s" "Allows to retrieve access only (Id and all) or complete entry (Sel.)"]
    append Texte [format "\n%-10s" "Allows to retrieve also Unigene (Ug.xxx) id from Uniseq (HS#xxx)"]
    set_balloon $B "$Texte"
    $B configure -state disabled -disabledforeground "black"
    
    return $Fen

}

proc AfficheLesAutresCandidatsOligoArray {K PAB} {


    Wup "Permet d'afficher les candidats de l'oligo"

    set Id           [$K find withtag current]
    set MesTags      [$K gettags $Id]
    set NomOligo     [lindex $MesTags 4]
    set Dir          [lindex $MesTags 5]

    set LesAccessDef [LesAccessDefDeLOligoArray $PAB $NomOligo $Dir]
    set Fen          [AfficheVariable [join $LesAccessDef "\n"] "" "$NomOligo de $PAB dans $Dir"]

    #set texte ["$Fen.frame.list" get 0 end]
    set B [BoutonneLaFenetre $Fen "Getz\nuniseq > genbank Sel/Id/All Id\nuniseq > protein   Sel/Id/All Id\ngenbank > protein Sel/Id/All Id"]
 
       bind $B <1>         "GetzUniseq_GUI $K \[selection get\]        uniseq  genbank EntreeComplete"
       bind $B <2>         "GetzUniseq_GUI $K \[selection get\]        uniseq  genbank AccessDef"
       bind $B <3>         "GetzUniseq_GUI $K \[set PagePropre($Fen)\] uniseq  genbank AccessDef"
    					  
       bind $B    "GetzUniseq_GUI $K \[selection get\]        uniseq  protein EntreeComplete"
       bind $B    "GetzUniseq_GUI $K \[selection get\]        uniseq  protein AccessDef"
       bind $B    "GetzUniseq_GUI $K \[set PagePropre($Fen)\] uniseq  protein AccessDef"
					  
       bind $B  "GetzUniseq_GUI $K \[selection get\]        genbank protein EntreeComplete"
       bind $B  "GetzUniseq_GUI $K \[selection get\]        genbank protein AccessDef"
       bind $B  "GetzUniseq_GUI $K \[set PagePropre($Fen)\] genbank protein AccessDef"
  
    $B configure -background "green"
    return $Fen
    #return "[AfficheVariable [join $LesAccessDef "\n"] "" "$NomOligo de $PAB dans $Dir"]"

}

proc AfficheLesBAC {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Id [lindex $MesTags 4]
    set IntId [lindex $MesTags 5]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin\nName: $Nom\nID: $Id\nInternationalID: $IntId"

    ac_AfficheVariable "$Texte" "" "Summary"

    return "$Texte"

}

proc AfficheLesBlastXDesHitsMultiples {Nom} {

    foreach Fichier [LesBlastXDesHitsMultiples $Nom] {
	AfficheFichier $Fichier "AvecSegAlignement"
    }
    return

}

proc AfficheLesBoutonsNonOpen {{V ""}} {

    global LesBoutonsNonOpen

#    if {$V==""} { set V [Vitrine "GetVitrine"] }
    foreach b $LesBoutonsNonOpen {
	pack $b -fill both
    }

}

proc AfficheLesConcernesDeCeRang {K X Y Fichier} {

    global RepertoireDuGenome
    global NotreOS
    global PABRetenus

    Wup "if K is an Organism then return LesAtteints (for PourGif)"
    if {[regexp {^\.} $K]} {
	set PourGif 0
    } else {
	set PourGif 1
    }

    regsub "orgaetsesplaces" $Fichier "distancesphylo.[Glossaire $NotreOS Court]" FichierDPh
    regsub "orgaetsesplaces" $Fichier "pabretenus"     FichierDesRetenus

    set TailFDR [file tail $FichierDesRetenus]

    if { ! [info exists PABRetenus($TailFDR)] && [file exists $FichierDesRetenus]} {
	set  PABRetenus($TailFDR) 1
	foreach Ligne [LesLignesDuFichier $FichierDesRetenus] {
	    scan $Ligne "%s" Nom
	    set PABRetenus($TailFDR,$Nom) 1
	}
    }

    if { ! [file exists $FichierDPh]} {
	FaireLire "I can't find $FichierDPh"
	return ""
    }
    if {$PourGif} {
	set Orga  [Glossaire $K Court]
	set Score $X
	set Rang  $Y
	set Rep ""
    } else {
	set Id [$K find withtag current]
	set Orga [Glossaire [lindex [$K gettags $Id] 0] Court]
	set Score [lindex [$K gettags $Id] 1]
	set Rang  [lindex [$K gettags $Id] 2]
	set Rep "$RepertoireDuGenome/"
    }

    set LesAtteints {}
    foreach Ligne [LesLignesDuFichier $FichierDPh] {
	set LesMots [split $Ligne " "]
	set Nom [lindex $LesMots 0]
	set Ieme [lsearch -exact $LesMots $Orga]
	if { [expr ($Ieme-1)/3] == [expr $Rang-1] } {
	    if { ! [info exists PABRetenus($TailFDR)] ||  [info exists PABRetenus($TailFDR)] && [info exists PABRetenus($TailFDR,$Nom)]} {
		lappend LesAtteints "${Rep}msf/$Nom $Ligne"
	    }
	}
    }

    if {$PourGif} { return $LesAtteints }

    if {[llength $LesAtteints]>0} {
	AfficheVariable [join $LesAtteints "\n"] "AvecShowSansFetch"
    } else {
	FaireLire "Sorry I can't find the associated alignments ... I'm so messy ..."
    }

}

proc AfficheLesConditionsDeTmEtDeTaille {{PAB ""} {Taille ""} {Tm ""} {AvecAffiche 0}} {


    Wup "Affiche les resultats du Test pour tous les PABs et dans plusieurs conditions de Tm et de taille" 
    
    #ChargeLeTableauDesTestsSurLeTmEtLaTaille   TabRes "StatOligoPossible" $PAB $Taille $Tm
    ChargeLeTableauDesTestsSurLeTmEtLaTaille   TabRes "StatOligoPossible_60.new" $PAB $Taille $Tm
    CalculLesMeilleursConditionsDeTmEtDeTaille TabRes
    
    if {$PAB==""} {set LesPABs [set TabRes(LesPABs)]} else {set LesPABs $PAB}
    
    Espionne "Test pour les PABs des meilleures conditions de Tm ([set TabRes(LesTms)]) et de Taille ([set TabRes(LesLongueurs)]) qui genere le plus grand nombre de sondes." 

    foreach PAB $LesPABs {
	if {$PAB=="ACT1165"} {continue}
	if {$AvecAffiche} {Espionne "\nMeilleur Tm pour toutes les conditions de Taille"}
	foreach Length [set TabRes(LesLongueurs)] {
	    set LeMeilleurTm [set TabRes($PAB,$Length,LeMeilleurTm)]

	    #Incremente le nb des meilleurs pour chaque Tm de toutes les conditions
	    incr    TabRes(nbMeilleurTm,$LeMeilleurTm) 
	    incr    TabRes($Length,$LeMeilleurTm,nbMeilleurTm) 
	    lappend TabRes($Length,$LeMeilleurTm,nbMeilleurTm,LesPABs) $PAB

	    if {$AvecAffiche} {
		set PerAccept  [set TabRes($PAB,$Length,$LeMeilleurTm,PercentAccepted)]
		set PerRej     [set TabRes($PAB,$Length,$LeMeilleurTm,PercentRejected)]
		set Accepted   [set TabRes($PAB,$Length,$LeMeilleurTm,NbAccepted)]
		set Rejected   [set TabRes($PAB,$Length,$LeMeilleurTm,NbRejected)]  
		set GCAccepted [set TabRes($PAB,$Length,$LeMeilleurTm,GCAccept)]
		set GCRejected [set TabRes($PAB,$Length,$LeMeilleurTm,GCReject)]
		Espionne "$PAB $Length $LeMeilleurTm $Accepted $PerAccept $Rejected $PerRej $GCAccepted $GCRejected"
	    }
	}
	
	if {$AvecAffiche} {Espionne "\nMeilleur Taille pour toutes les conditions de Tm"}
	foreach Tm [set TabRes(LesTms)] {
	    set LaMeilleureTaille [set TabRes($PAB,$Tm,LaMeilleureTaille)]
	    
	    #Incremente le nb des meilleurs pour chaque Taille de toutes les conditions
	    incr TabRes(nbMeilleureTaille,$LaMeilleureTaille) 
	    #incr    TabRes($LaMeilleureTaille,$Tm,nbMeilleureTaille) 
	    #lappend TabRes($LaMeilleureTaille,$Tm,nbMeilleureTaille,LesPABs) $PAB
	    
	    if {$AvecAffiche} {
		set PerAccept  [set TabRes($PAB,$LaMeilleureTaille,$Tm,PercentAccepted)]
		set PerRej     [set TabRes($PAB,$LaMeilleureTaille,$Tm,PercentRejected)]
		set Accepted   [set TabRes($PAB,$LaMeilleureTaille,$Tm,NbAccepted)]
		set Rejected   [set TabRes($PAB,$LaMeilleureTaille,$Tm,NbRejected)]  
		set GCAccepted [set TabRes($PAB,$LaMeilleureTaille,$Tm,GCAccept)]
		set GCRejected [set TabRes($PAB,$LaMeilleureTaille,$Tm,GCReject)]
		Espionne "$PAB $LaMeilleureTaille $Tm $Accepted $PerAccept $Rejected $PerRej $GCAccepted $GCRejected"
	    }
	}
	
	#Calcul des meilleures conditions pour chaque PAB
	#Taille vs Tm     actif
	#Tm     vs Taille inactif
	set LeMeilleurTmDuPAB      [set TabRes($PAB,LeMeilleurTm)]
	set LaTailleDeLeMeilleurTm [set TabRes($PAB,LaTailleDeLeMeilleurTm)]
	#Espionne "$PAB $LaTailleDeLeMeilleurTm $LeMeilleurTmDuPAB"

	if {![info exists TabRes($LaTailleDeLeMeilleurTm,$LeMeilleurTmDuPAB,nbMeilleurTmDeTous)]} {
	    set  TabRes($LaTailleDeLeMeilleurTm,$LeMeilleurTmDuPAB,nbMeilleurTmDeTous) 1
	} else {			       
	    incr TabRes($LaTailleDeLeMeilleurTm,$LeMeilleurTmDuPAB,nbMeilleurTmDeTous) 1
	}
	lappend TabRes($LaTailleDeLeMeilleurTm,$LeMeilleurTmDuPAB,nbMeilleurTmDeTous,LesPABs) $PAB

#	set LaMeilleureTailleDuPAB       [set TabRes($PAB,LaMeilleureTaille)]
#	set LeTmDeLaMeilleureTailleDuPAB [set TabRes($PAB,LeTmDeLaMeilleureTaille)]
#	if {![info exists TabRes($LaMeilleureTailleDuPAB,$LeTmDeLaMeilleureTailleDuPAB,nbMeilleurTailleDeTous)]} {
#	    set  TabRes($LaMeilleureTailleDuPAB,$LeTmDeLaMeilleureTailleDuPAB,nbMeilleurTailleDeTous) 1
#	} else {			       				     
#	    incr TabRes($LaMeilleureTailleDuPAB,$LeTmDeLaMeilleureTailleDuPAB,nbMeilleurTailleDeTous) 1
#	}
    }
    
    set NbTotalPAB    [set TabRes(nbPAB)]
    set NbTotalTaille [set TabRes(nbTaille)]
    set NbTotalTm     [set TabRes(nbTm)]

    Espionne "Nombre de fois que le Tm est le meilleur:"
    #Rq:On divise par le nombre de Taille
    foreach Tm [set TabRes(LesTms)] {
	set Valeur  [set TabRes(nbMeilleurTm,$Tm)]
	set Percent [expr 100.0*$Valeur/$NbTotalTaille]
	Espionne "$Tm\t[format "%6d\t%2.1f" $Valeur $Percent] %"
    }
    Espionne "Total: $NbTotalTaille = PAB ($NbTotalPAB) * NbTaille ([llength [set TabRes(LesLongueurs)]])\n"
   
    Espionne "Nombre de fois que la Taille est la meilleure:"
    #Rq:On divise par le nombre de Tm
    foreach Taille [set TabRes(LesLongueurs)] {
	set Valeur  [set TabRes(nbMeilleureTaille,$Taille)]
	set Percent [expr (100.0*$Valeur)/$NbTotalTm]
	Espionne "$Taille\t[format "%6d\t%2.1f" $Valeur $Percent] %"
    }
    Espionne "Total: $NbTotalTm = PAB ($NbTotalPAB) * NbTm ([llength [set TabRes(LesTms)]])\n"
 
    Espionne "Meilleures conditions (Tm pour chaque Taille) en considerant a chaque fois tous les PABs:"
    foreach Taille [set TabRes(LesLongueurs)] {
	set Valeur  "Nombre" 
	set Percent "Pourcent"
	
	Espionne "$Taille\t--\t$Valeur\t$Percent\txGC Total\txGC Accepted"
	set Total 0
	foreach Tm [set TabRes(LesTms)] {
	    if {! [info exists TabRes($Taille,$Tm,nbMeilleurTm)]} {
		set Nb 0
	    } else {
		set Nb [set TabRes($Taille,$Tm,nbMeilleurTm)]
	    }
	    
	    set Total [expr $Total+$Nb]

	    if {! [info exists TabRes($Taille,$Tm,nbMeilleurTm,LesPABs)]} {
		set MoyenneDuGCDesPAB      0.0
		set MoyenneDuGCDesAccepted 0.0
	    } else {
		set ListePABs       [set TabRes($Taille,$Tm,nbMeilleurTm,LesPABs)]
		set NbPAB           [llength $ListePABs]
		set ATGCDesPABTotal 0
		set GCAcceptedTotal 0
	
		foreach PAB $ListePABs {
		    set ATGC            [CompositionATGCDuPAB $PAB GC]
		    set ATGCDesPABTotal [expr $ATGCDesPABTotal+$ATGC]
		    
		    set GCAccepted      [set TabRes($PAB,$Taille,$Tm,GCAccept)]
		    #set GCRejected [set TabRes($PAB,$Taille,$Tm,GCReject)]
		    set GCAcceptedTotal [expr $GCAcceptedTotal+$GCAccepted]
		}
		if {$NbPAB=="0"} {
		    set MoyenneDuGCDesPAB      0.0
		    set MoyenneDuGCDesAccepted 0.0
		} else {
		    set MoyenneDuGCDesPAB      [format " %.1f" [expr (1.0*$ATGCDesPABTotal)/$NbPAB]]
		    set MoyenneDuGCDesAccepted [format " %.1f" [expr (1.0*$GCAcceptedTotal)/$NbPAB]] 
		}
		
	    }
	    Espionne "--\t$Tm\t$Nb\t--\t$MoyenneDuGCDesPAB\t$MoyenneDuGCDesAccepted"
	}
	Espionne "--\t--\t$Total\t[format "%.1f" [expr 100.0*($Total*1.0)/($NbTotalPAB)]]"
    }
    Espionne "PAB au total: $NbTotalPAB PAB(s)"

    Espionne "\n"
    Espionne "Meilleures conditions (Tm pour chaque Taille) ultimes:"
    set CompteurDePAB 0
    foreach Taille [set TabRes(LesLongueurs)] {
	set Valeur  "Nombre" 
	set Percent "Pourcent"
	
	Espionne "$Taille\t--\t$Valeur\t$Percent\txGC Total\txGC Accepted"
	set Total 0
	foreach Tm [set TabRes(LesTms)] {
	    if {! [info exists TabRes($Taille,$Tm,nbMeilleurTmDeTous)]} {
		set Nb 0
	    } else {
		set Nb [set TabRes($Taille,$Tm,nbMeilleurTmDeTous)]
	    }
	    
	    set Total [expr $Total+$Nb]
	    if {! [info exists TabRes($Taille,$Tm,nbMeilleurTmDeTous,LesPABs)]} {
		set MoyenneDuGCDesPAB      0.0
		set MoyenneDuGCDesAccepted 0.0
	    } else {
		set ListePABs       [set TabRes($Taille,$Tm,nbMeilleurTmDeTous,LesPABs)]
		set NbPAB           [llength $ListePABs]
		set ATGCDesPABTotal 0
		set GCAcceptedTotal 0
	
		foreach PAB $ListePABs {
		    incr CompteurDePAB 1
		    set ATGC            [CompositionATGCDuPAB $PAB GC]
		    set ATGCDesPABTotal [expr $ATGCDesPABTotal+$ATGC]
		    
		    set GCAccepted      [set TabRes($PAB,$Taille,$Tm,GCAccept)]
		    #set GCRejected [set TabRes($PAB,$Taille,$Tm,GCReject)]
		    set GCAcceptedTotal [expr $GCAcceptedTotal+$GCAccepted]
		}
		if {$NbPAB=="0"} {
		    set MoyenneDuGCDesPAB      0.0
		    set MoyenneDuGCDesAccepted 0.0
		} else {
		    set MoyenneDuGCDesPAB      [format " %.1f" [expr (1.0*$ATGCDesPABTotal)/$NbPAB]]
		    set MoyenneDuGCDesAccepted [format " %.1f" [expr (1.0*$GCAcceptedTotal)/$NbPAB]] 
		}
	    }
	    Espionne "--\t$Tm\t$Nb\t--\t$MoyenneDuGCDesPAB\t$MoyenneDuGCDesAccepted"
	}
	Espionne "--\t--\t$Total\t[format "%.1f" [expr 100.0*($Total*1.0)/($NbTotalPAB)]]"
    }
    Espionne "PAB au total: $CompteurDePAB PAB(s)"

    return ""

}

proc AfficheLesConditionsDeTmEtDeTailleDePAB {PAB} {


    Wup "Affiche les resultats du Test pour un PAB en particulier et dans plusieurs conditions de Tm et de taille" 
    
    ChargeLeTableauDesTestsSurLeTmEtLaTaille  TabRes "StatOligoPossible" $PAB

    if {$PAB==""} {set LesPABs [set TabRes(LesPABs)]} else {set LesPABs $PAB}
    
    set ListeSortie {}
    foreach PAB $LesPABs {
	foreach Length [set TabRes(LesLongueurs)] {
	    foreach Tm [set TabRes(LesTms)] {
		set PerAccept       [set TabRes($PAB,$Length,$Tm,PercentAccepted)]
		set PerRej          [set TabRes($PAB,$Length,$Tm,PercentRejected)]
		set Accepted        [set TabRes($PAB,$Length,$Tm,NbAccepted)]
		set Rejected        [set TabRes($PAB,$Length,$Tm,NbRejected)]  
		lappend ListeSortie [list $PAB $Length $Tm $Accepted $PerAccept $Rejected $PerRej]
	    }
	}
    }
    return $ListeSortie

}

proc AfficheLesCouleursEtSignifications {K} {

    global TypeCouleur

    set LesNomSignif [LesSignificationsAssocieesAuxORFs $K]

    set OldSignif "trululuyoupiii"
    set LaSortie {}
    foreach Ligne $LesNomSignif {
	scan $Ligne "%s" Nom
	set Signif [StringSuivant " " dans $Ligne]
	if {$Signif!=$OldSignif} { set N 0 }
	lappend LaSortie "$Nom [incr N] $Signif"
	set OldSignif $Signif
    }
    return [AfficheVariable [join $LaSortie "\n"] "AvecShow"] 

}

proc AfficheLesDescriptifs {Source {Ordre MemeOrdre} {QuoiRetourner ""} {LesAccessOrdonnes ""} {LesClefs ""} {NomOrigine ""}} {

    #rR Source can be Texte, a file or descriptif/Nom msf/Nom rsf/Nom blast/Nom etc.
    #rR il y a une petite confusion a regler pour LesAccessOrdonnees

    #rR attention je croyais que ca marcherait si on donne une source qui n'est pas du même projet !!!
    #rR ca ne marche pas si on prend MemeOrdre qu'un fichier Macsim par exemple car LeDescriptif est trop spécfique au projet Gscope :'( A VOIR  

    Wup "Attention: blast doesn't rearrange the order of the file"

    if {[regexp "\n" $Source]} {
	set TmpMSF "[TmpFile].msf"
	Sauve $Source dans $TmpMSF
	set NomOuFichier $TmpMSF
    } else {
	set NomOuFichier $Source
	while {[FileAbsent $NomOuFichier]} {
	    set Possible "[RepertoireDuGenome]/$NomOuFichier"
	    if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    if {[EstUnPAB $NomOuFichier]} {
		#rR on priviligie le MSF
		set Possible "[RepertoireDuGenome]/msf/$NomOuFichier"
		if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    }
	    if {[regexp "rsf" $NomOuFichier]} {
		set Queue [file tail $NomOuFichier]
		set Possible "[RepertoireDuGenome]/macsimRsf/$Queue"
		if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    }
	    FaireLire "I can not find $NomOuFichier"
	    return ""
	}
    }

    if {$NomOrigine==""} { set NomOrigine $NomOuFichier }
    set Nom [file tail $NomOrigine]

    set RepDesc "[RepertoireDuGenome]/descriptifs"
    set PossibleRepDesc "[file dirname [file dirname $Source]]/descriptifs"
    if {[file exists $PossibleRepDesc/$Nom]} { set RepDesc $PossibleRepDesc }

    if { 0 && [regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
	#rR a mis 0 ... 20150521 ..................................................... ca merde ... si le projet n'est pas le RepertoireDuGenome
	set FichierDescriptif $NomOuFichier
    } else {
	set FichierDescriptif "$RepDesc/$Nom"
    }
    set FichierModele "NeDoitPasExister"

    if {[FileAbsent $FichierDescriptif]} { return "" }

    if {$Ordre=="Natif"} { set LesDes [LesLignesDuFichier $FichierDescriptif] ; set NomOuFichier $FichierDescriptif }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "msf|clustal" $NomOuFichier]} {
	DecortiqueUnMSF $NomOuFichier LesAccessOrdonnes
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "rsf" $NomOuFichier]} {
	DecortiqueUnRSF $NomOuFichier LesAccessOrdonnes
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "blast" $NomOuFichier]} {
	DecortiqueBlast $NomOuFichier 0.001 "SansLimiteDeNombre" Query lBA LesAccessOrdonnes lDE lProfil lPN
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "aliinout" $NomOuFichier]} {
	set LesAccessOrdonnes [LesAccessDuAliInOut $NomOuFichier]
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "disphy" $NomOuFichier]} {
	set LesAccessOrdonnes [FromDisphy $NomOuFichier]
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "apns" $NomOuFichier]} {
	set LesAccessOrdonnes [LesAccessDuAPN $NomOuFichier]
    }
    if {[info exists LesAccessOrdonnes] && $LesAccessOrdonnes!=""} {
	if { ! [info exists lBA]} { set lBA $LesAccessOrdonnes }
	foreach Access $LesAccessOrdonnes BA $lBA {
	    set Des [LeDescriptif $Access $Nom]
	    if {[regexp "no description" $Des]} {
		regsub {^[^\:]+:} $BA "" BA
		set Des [LeDescriptif $BA $Nom]
	    }
	    lappend LesDes $Des 
	}
    } else {
	set LesDes [LesLignesDuFichier $FichierDescriptif]
    }
    foreach Descriptif $LesDes {
	set BeauDes [MiseEnPageDuDescriptif $Descriptif $LesClefs]
	lappend LesBeauxDes $BeauDes
    }

    if {[info exists TmpMSF] && [file exists $TmpMSF]} { file delete -force $TmpMSF }

    if { $QuoiRetourner == "PourGif" } {
	return [join $LesBeauxDes "\n"]
    } elseif { $QuoiRetourner == "LaListe" } {
	return $LesBeauxDes
    } else {
	return [AfficheVariable [join $LesBeauxDes "\n"] "GrandeLargeurAvecAligneurs" $NomOrigine] 
    }

}

proc AfficheLesDescriptifsDuMSF {NomOuFichier} {

    global LesDescriptifs

    set Nom [file tail $NomOuFichier]
    if {[regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
	set Fichier $NomOuFichier
    } else {
	set Fichier "[RepertoireDuGenome]/msf/$Nom"
    }
    if { ! [file exists $Fichier]} { return "" }

    set MSFdesCopains [expr [OnTraiteUneCollection] && [YaPABdans $Nom]]

    set LesAccess {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp "//" $Ligne]} { break }
	if { ! [regexp "Name\:" $Ligne]} { continue }
	scan $Ligne "%s %s" Name Access
	if {[info exists LesDescriptifs($Access)]} { continue }
	lappend LesAccess $Access
    }
    if {$LesAccess!={} && ! $MSFdesCopains} {
	PrepareLesSequencesDesBanques $LesAccess $LesAccess
    }
    set AuMoinsUneDescription 0
    foreach Access $LesAccess {
	if {[info exists LesDescriptifs($Access)]} {
	    set Descriptif [set LesDescriptifs($Access)]
	} else {
	    if {0 && $MSFdesCopains} {
		set LesLignesEMBL [split [CoCherche "embl" $Nom $Access] "\n"]
	    } else {
		set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
	    }
	    if {$LesLignesEMBL=={} } {
		lappend Liste "$Access (no description)"
		continue
	    }
	    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	    set Descriptif "$Access OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX"
	    set LesDescriptifs($Access) $Descriptif
	}
	lappend Liste [MiseEnPageDuDescriptif $Descriptif]
	set AuMoinsUneDescription 1
    }

    if { ! $AuMoinsUneDescription || ! [info exists Liste]} { return "" }

    return [AfficheVariable [join $Liste "\n"] "AvecAligneurs" $Fichier]

}

proc AfficheLesFichiers {Selection {Maniere ""}} {

    set Dernier ""
    foreach Ligne [split $Selection "\n"] {
	foreach Fichier [split $Ligne " "] {
	    if {[FileAbsent $Fichier]} {continue}
	    set Dernier [AfficheFichier $Fichier $Maniere]
	}
    }
    return $Dernier

}

proc AfficheLesFichiersApresSplit {Selection {Maniere ""}} {

    FaireLire "AfficheLesFichiersApresSplit obsolete, use AfficheLesFichiers"
    return [AfficheLesFichiers $Selection $Maniere]

}

proc AfficheLesFragmentsDeMutation {Nom} {

    set LesFragments [CombineLesFragments $Nom "MutationFragments"]
    Espionne $LesFragments
    while {[OuiOuNon "Do we continue to combine these fragments ?"]} {
	set LesFragments [CombineLesFragments $Nom $LesFragments]
    }
    return $LesFragments

}

proc AfficheLesGenes {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Brin [lindex $MesTags 4]
    set Debcds [lindex $MesTags 5]
    set Fincds [lindex $MesTags 6]
    set NbExons [lindex $MesTags 7]
    set ExonStarts [lindex $MesTags 8]
    set ExonEnds [lindex $MesTags 9]
    set ProtID [lindex $MesTags 10]
    set DefProt [lindex $MesTags [expr [llength $MesTags] -3]]

    set Texte "$Nom\n$Chro\nFrom: $Deb\nTo: $Fin\nStrand: $Brin\nStart_cds: $Debcds\nEnd_cds: $Fincds\nNbExons: $NbExons\nProtein_ID: $ProtID\nDef: $DefProt"

    ac_AfficheVariable "$Texte" "" "Summary"
    return "$Texte"

}

proc AfficheLesInfosDeMaSequence {PAB} {

    
    Wup "Montre les regions interessantes"

    set Indice [file tail $PAB]
    regsub -all  {\.} $Indice "" Indice
    
    set w ".lesinfosdemaseq$Indice"
    if {[winfo exists $w]} {wm deiconify $w;raise $w;return ""} else {toplevel $w}
    
    wm geometry  $w +300+100
    wm title     $w "Information for $PAB"
    wm resizable $w false false

    set    FInfo "$w.frameinfo"
    frame $FInfo -borderwidth "3" -relief "groove"
    pack  $FInfo -fill both       -expand true
    
    #Attention il faut une query, sinon pas de taille ....
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set Repnuctfa "[RepertoireDuGenome]/nuctfa"
        
    set FichierQuery $PAB
    if {[regexp {/} $PAB]} {set PAB [file tail $PAB]}

    if {    [file exists $FichierQuery]} {
	set FichierQuery $FichierQuery
    } elseif {[file exists "$RepmRNA/$PAB"]} {
	set FichierQuery   "$RepmRNA/$PAB"
    } elseif {[file exists "$Repnuctfa/$PAB"]} {
	set FichierQuery   "$Repnuctfa/$PAB"
    } else {Espionne "No Input File for the Query ($PAB)";destroy $w;return ""}

    set Police         {-family "arial" -size 12 -weight bold}
    set CouleurOutline "black"
    set LargeurMax     [expr [winfo screenwidth  .] * 2/3]
    set HauteurMax     [expr [winfo screenheight .] * 1/2]
    set LargeurFenetre [expr [winfo screenwidth  .] * 2/3]
    set HauteurFenetre [expr [winfo screenheight .] * 1/2]
    set XMilieu        [expr $LargeurMax/2]
    
    set BordureX       50.0
    set BordureY       50.0
    set Intervalle     10.0
    set EpaisseurBoite 15.0

    #Position du Graph content
    set YDebutGraph    [expr 0 + $BordureY]
    set YFinGraph      [expr $YDebutGraph + 100]

    #Position de la query
    set XDebutQuery    [expr 0            + $BordureX]
    set YDebutQuery    [expr $YFinGraph   + 10]
    set XFinQuery      [expr $LargeurMax  - $BordureX] 
    set YFinQuery      [expr $YDebutQuery + $EpaisseurBoite]
    
    #Besoin de la taille de la query pour conversion et affichage
    set AccessQuery    [AccessDuTFADumRNA         $FichierQuery]
    set  SeqQuery      [QueLaSequenceDuFichierTFA $FichierQuery]
    if {$SeqQuery==""} {Espionne "$FichierQuery no sequence available";return ""}
    set TailleQueryNt  [string length $SeqQuery]
    #Rapport du nombre de pixel pour un nt
    set OneNtPixel     [expr ($XFinQuery-$XDebutQuery)/($TailleQueryNt - 1)] 

    #Debut des Oligos
    set YDebutDeOligo  [expr $YFinQuery + $Intervalle]
        
    set     K "$FInfo.canvas"
    canvas $K    -width      $LargeurFenetre -height $HauteurFenetre 
    $K configure -height     $YDebutDeOligo
    $K configure -background "grey" 

    SauveLesInfosDe $K MonPAB $PAB
    #On modifie le comportement lors de la destruction de la fenetre principale
    #Ceci pour vider les infos stockees
    wm protocol $w WM_DELETE_WINDOW "DetruitLesInfosDe $K;after 10 destroy $w"

    #Le Masque pour les graphes
    $K create rectangle [expr $XDebutQuery-40] [expr $YDebutGraph-4] [expr $XFinQuery+40] [expr $YFinGraph+4]  -fill    "gray97"  -outline "gray97"  -tags    [list "" "Masque"]

    #Affiche la petite aide
    $K create oval [expr $XDebutQuery-30] [expr $YDebutGraph-30] [expr $XDebutQuery-10] [expr $YDebutGraph-10]  -fill    "green"  -outline "white"
    $K create text [expr $XDebutQuery-20] [expr $YDebutGraph-20]  -text    "?"  -tags    [list "" "[AfficheHelpInfoDeMaSequence]" "Affichable"]  -anchor  "center" 

    #Affichage du Tm content
    #On recupere la methode de Tm par defaut choisie et on la remet apres
    set TmDefault [LesParametresDuDesign TmMethod "LaValeurMerci"]
    LesParametresDuDesign TmMethod "NearestNeighbor" "Positionne"

    set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
    if {$TmResults !=""} {
	AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange" "TmNN"
    }
    LesParametresDuDesign TmMethod $TmDefault "Positionne"

    #Affichage du GC content
    set  GCResults [PosEtGCDeLaRegion $SeqQuery $TailleQueryNt]
    if {$GCResults !=""} {
	AfficheLeSpectreGCDUneListe $K $GCResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel
    }

    #Affiche la query
    $K create rectangle $XDebutQuery $YDebutQuery $XFinQuery $YFinQuery  -outline "$CouleurOutline"  -fill    "red"  -tags    "Query"
    $K create text [expr $XDebutQuery-5.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)]  -text    "1"  -font    "$Police"  -anchor  "e"
    $K create text [expr $XFinQuery  +5.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)]  -text    "$TailleQueryNt"  -font    "$Police"  -anchor  "w"
    $K create text $XMilieu [expr 1*$BordureY/3]  -text    "Sequence Informations from $PAB"  -font    "$Police"  -anchor  "center"  -justify "center"

    #La fiche contenant les infos
    set  FicheInfo  ""
    set  Text       "$FInfo.text"
    set  ListBoxSBH "$FInfo.xscroll"
    set  ListBoxSBV "$FInfo.yscroll"

    scrollbar $ListBoxSBH -orient "horizontal" -command "$Text xview"
    scrollbar $ListBoxSBV -orient   "vertical" -command "$Text yview"
    text $Text  -state          "disabled"  -wrap           "word"  -font           "courier 10"  -xscrollcommand "$ListBoxSBH set"  -yscrollcommand "$ListBoxSBV set"
    
    set FicheInfo [LesInfosDeBaseDeMaSequence $SeqQuery]
    foreach element [split $FicheInfo "\n"] {
	$Text configure -state normal
	$Text insert    "end"  "$element\n"
	$Text configure -state disabled
    }

    #Les boutons
    set ButtonFrame    "$FInfo.buttonframe"
    set  ActionButton  "$ButtonFrame.button1"
    set  DestroyButton "$ButtonFrame.button2"
    set  LCharpente1   "$ButtonFrame.lcharpente1" 
    set  LCharpente2   "$ButtonFrame.lcharpente2" 
    set  ZoneButton1   "$ButtonFrame.zbutton1"
    set  ZoneButton2   "$ButtonFrame.zbutton2"
    #set  ZoneButton3   "$ButtonFrame.zbutton3"

    frame  $ButtonFrame  -borderwidth "3"      -relief "groove"
    button $ActionButton -background  "yellow" -text "Graph Panel / Add / Delete" 
      bind $ActionButton  <1> "Graph_Panel     $K"
      bind $ActionButton  <2> "AjouteUnGraph   $K $FichierQuery $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel"
      bind $ActionButton  <3> "SupprimeUnGraph $K"
    set    Texte [format     "%-10s" "Panel to change graph display (order,color)"]
    append Texte [format   "\n%-10s" "Allow to add or delete graph"]
    append Texte [format   "\n%-10s" "Allow to search items in oligo display text"]
    set_balloon $ActionButton "$Texte"

    button $DestroyButton -background "red"    -text "Close / Help"  -command "eval \[wm protocol $w WM_DELETE_WINDOW\]"
      bind $DestroyButton <2> "AfficheHelpInfoDeMaSequence DuBouton"

    button $ZoneButton1  -background "green"   -text "Area(s) Draw / Clear / Save" 
      bind $ZoneButton1   <1> "MontreLesZones $K $XDebutQuery $XFinQuery $YDebutGraph $OneNtPixel"
      bind $ZoneButton1   <2> "ClearLesZones  $K"
      bind $ZoneButton1   <3> "SauveLesZones  $K"
    set Texte   [format      "%-10s" "Allow to show (defined), clear or save designing area(s)"]
    set_balloon $ZoneButton1 "$Texte"

    button $ZoneButton2  -background "green"   -text "Reset for $PAB / all" 
      bind $ZoneButton2   <1> "ResetLesZones    $K"
      bind $ZoneButton2   <2> "ResetAllLesZones $K"
    set Texte   [format      "%-10s" "Allow to clear saved design areas"]
    set_balloon $ZoneButton2 "$Texte"

    #button $ZoneButton3  -background "yellow"  -text "Zoom In / Out / Reset"
    #  bind $ZoneButton3  <1> "zoom $K 1.25 1.25"
    #  bind $ZoneButton3  <2> "zoom $K 0.8 0.8"
    #  bind $ZoneButton3  <3> "ResetZoom $K"

    label  $LCharpente1 -background "#808FFF" -relief "groove" 
    label  $LCharpente2 -background "#808FFF" -relief "groove" 

    pack $K             -fill both -side top
    pack $ButtonFrame   -fill both -side top    -expand true
    pack $LCharpente1   -fill both -side left   -expand true
    pack $DestroyButton -fill y    -side left
    #pack $ZoneButton3   -fill y    -side left
    pack $ActionButton  -fill y    -side left
    pack $ZoneButton1   -fill y    -side left
    pack $ZoneButton2   -fill y    -side left
    pack $LCharpente2   -fill both -side left   -expand true

    pack $ListBoxSBV    -fill y    -side right 
    pack $Text          -fill both              -expand true
    pack $ListBoxSBH    -fill x    -side bottom 

    $K bind "Affichable"  "AfficheInfoBulle $K %x %y Enter"
    $K bind "Affichable"  "AfficheInfoBulle $K %x %y Leave"
			
    $K bind "Query"      <2>     "AfficheFetch   $AccessQuery OnVeutNature"
    $K bind "Query"      <3>     "AfficheLaQuery $K $FichierQuery"

    bind $K        "PositionneLesZones $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $OneNtPixel"
    bind $K  "ViseurDeSeq        $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YFinQuery $OneNtPixel"
    bind $K          "ViseurDeSeq        $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YFinQuery $OneNtPixel"
    return ""

}

proc AfficheLesInfosDuCluster {} {

    
    set ClusterOuNom [Entre "ClusterOuNom: "] 

    if {[regexp "^ClusterOuNom:" $ClusterOuNom]} {
	regsub "^ClusterOuNom: " $ClusterOuNom "" ClusterOuNom  
    }
    scan $ClusterOuNom "%s" ClusterOuNom 
    
    Espionne "Question $ClusterOuNom"
    
    set Fen [AfficheVariable [LesInfosDuCluster $ClusterOuNom] "" "Les Info de $ClusterOuNom"] 

    return $Fen

}

proc AfficheLesMembresDeLaFamille {Nom} {

    
    set MembresDeLaFamille [LesMembresDeLaFamille $Nom]

    set Texte [join $MembresDeLaFamille "\n"]
    
    set Fen [AfficheVariable $Texte "AvecRien" "${Nom}Les Membres de sa Famille"]
    
    #Jean a rajoute 
    set   B [BoutonneLaFenetre $Fen "X-HDA Sel/Sort\nAll/Sort\nInfo Cluster//DpcShow"]
    #set   B [BoutonneLaFenetre $Fen "Show X-HDA sel/all"]
    bind $B <1>       "CreeEtAfficheUnBilanHDACroises \[selection get\]"
    bind $B <2>       "CreeEtAfficheUnBilanHDACroises \[selection get\] AvecTri"
    bind $B  "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\]"
    bind $B  "CreeEtAfficheUnBilanHDACroises \[set PagePropre($Fen)\] AvecTri"
    bind $B  "AfficheLesInfosDuCluster"
    bind $B  "DpcShow"
    
         $B configure -background "green"

    return $Fen

}

proc AfficheLesOligo {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Id [lindex $MesTags 4]
    set Access [lindex $MesTags 5]
    set GN [lindex $MesTags 6]
    set Des [lindex $MesTags 7]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin\nName: $Nom\nID: $Id\nAccessions: $Access\nGeneName: $GN\nDescription: $Des"

    ac_AfficheVariable "$Texte" "" "Summary"
    return "$Texte"

}

proc AfficheLesOrthologuesFamiliersDuBlastP {Nom} {

    set LesOF [LesOrthologuesFamiliersDuBlastP $Nom]
    return [AfficheVariable [join $LesOF "\n"] "AvecRien" $Nom]

}

proc AfficheLesPartsDeCamembert {K X Y Action} {

    set H [winfo screenheight .]
    set L [winfo screenwidth  .]

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set PetiteLegende             [lindex $MesTags 1]
    set GrandeLegende             [lindex $MesTags 2]

    if {$GrandeLegende != ""} {set Texte $GrandeLegende} else {set Texte $PetiteLegende}

    return [AfficheVariable $Texte]

}

proc AfficheLesPoints {} {

    global LongueurTotale LNDG SDG NomTextSeq LesPointsDuGroupe Couleurs

    set NbrGrp [expr {[llength $LNDG] - 2}]

    if {$NbrGrp <= 1} {return}

    $NomTextSeq configure -state normal
    $NomTextSeq tag configure PtBack -background LightGray

    set Idx 1
    set ng 1
    set NbrSeq 0
    set IdxGrp 1
    foreach NmGrp $LNDG {
	if {$NmGrp eq "GroupeToutLeMonde"} {continue}
	if {$NmGrp eq "bidon"} {continue}
	if {$NmGrp eq "grise"} {continue}

	set col [RGBDeLaCouleur [CouleurDuGroupe $IdxGrp]]
	$NomTextSeq tag configure Pt$NmGrp -foreground $col -background LightGray
	set y [expr {$Idx+$NbrSeq+($ng-1)*2}]

	#	$NomTextSeq delete $y.0 "$y.0 lineend - 1c"
	$NomTextSeq delete $y.0 "$y.0 lineend"
	$NomTextSeq insert $y.0 [set LesPointsDuGroupe($NmGrp)]
	$NomTextSeq tag add PtBack $y.0 "$y.0 lineend"
	set Li [regexp -all -indices -inline {\*} [set LesPointsDuGroupe($NmGrp)]]
	foreach c $Li {
	    lassign $c d f 
	    $NomTextSeq tag add Pt$NmGrp $y.$d
	}

	set NbrSeq [expr {$NbrSeq + [llength [set SDG($NmGrp)]]}]
	incr ng
	incr IdxGrp
    }

    $NomTextSeq configure -state disabled

    return

}

proc AfficheLesProcs {{LesQuelles ""} {Liste ""}} {

    Wup "Shows the names and args of all Procs"
    
    Gs "Frame"
    
    if { ! [PourWscope] && ! [AutorisationPourPsy] } { return "" }

    set WithRef [PourWscope]

    set LesBonnes {}
    foreach Procedure [LesProceduresExistantes] {
	set Args [info args $Procedure]
#AAAAAAAAAAAAAAAAAAAAAAAAAAFFFFFFFFFFFFFFFFFIIIIIIIIIIIIIIIIIINNNNNNNNNNNNNNNNNNNIIIIIIIIIIIIIRRR	set MotProc $Procedure
#	if {$WithRef} { set MotProc "      "/Ppcr"     "AfficheRec1 \[selection get\] Ppcr"
    TouchePour <3>      "/Vect"     "AfficheRec1 \[selection get\] Vecteur"
    return $Fen

}

proc AfficheLesRec2 {{UnRec ""}} {


    if {$UnRec==""} { set Liste [Rec2 LaListeDes Rec2] } else { set Liste [list $UnRec] }

    set LaPage {}
    foreach R $Liste {
	lappend LaPage "[format %-27s $R] Rec2 in [Rec2 $R Vecteur] of [Rec2 $R R1] Rec1 [Rec2 $R Rec1Description]"
    }
    set Page [join $LaPage "\n"]
    set Fen [AfficheVariable $Page "AvecRec2" ListOfRec2]
    if {$Fen==""} { return "" }
    set Clavier "$Fen.buttons"
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "magenta"
    TouchePour $Clavier "It's File" "AfficheRec2 \[selection get\] Fichier"
    TouchePour <2>      "/Rec1"     "AfficheRec2 \[selection get\] Rec1"
    TouchePour <3>      "/Vector"   "AfficheRec2 \[selection get\] Vecteur"
    return $Fen

}

proc AfficheLesSortiesBlast {Selection} {

    foreach NomDuFichierBlast [split $Selection "\n"] {
	AfficheUneSortieBlast $NomDuFichierBlast
    }

}

proc AfficheLesSortiesDuBallast {FichierBlastP {Quoi rsf}} {

    regsub {/co[a-z]+/} $FichierBlastP "/coballast/" FichiersBallast
    regsub -nocase {\.[a-z_]*$} $FichiersBallast "" FichiersBallast
    set Fichier "$FichiersBallast.$Quoi"
    Espionne $Fichier
    if { ! [file exists $Fichier]} { return "" }
    return [AfficheFichier $Fichier "Avec$Quoi"]

}

proc AfficheLesSourcesDeGscope {{PathType ""} {AvecMain ""} {WithoutOrdali ""}} {

    set LesSourcesDeGscope [LesSourcesDeGscope $PathType $AvecMain]
    set Page [join $LesSourcesDeGscope "\n"]
    set Fen [AfficheVariable $Page "AvecShowFile" "LesSourcesDeGscope_$PathType"]
    set B [BoutonneLaFenetre $Fen "Path exact/abs/rel" ""]
    bind $B <1> "AfficheLesSourcesDeGscope Exact    $AvecMain"
    bind $B <2> "AfficheLesSourcesDeGscope Absolute $AvecMain"
    bind $B <3> "AfficheLesSourcesDeGscope Relativ  $AvecMain"
    $B configure -background "green"

}

proc AfficheLesSpines {Page {KO ""}} {

    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk 
	if {$SpOk} {
	    lappend LesBons $Ligne
	} else {
	    lappend LesMauvais $Ligne
	}	
    }
    if {$KO=="KO"} {
	set NewPage [join $LesMauvais "\n"]
    } else {
	set NewPage [join $LesBons "\n"]
    }
    return [AfficheVariable $NewPage]

}

proc AfficheLesStructuresSecondairesDeLActin {} {


    Wup "Article ARP permet d afficher la numerotation des elements de structures secondaires et leur positions"

    set NbHelix [LePCIDuResidu Helix Number]
    for {set i 1} {$i<=$NbHelix} {incr i} {
	set D [LePCIDuResidu Helix $i Reference Debut]
	set F [LePCIDuResidu Helix $i Reference Fin]

	Espionne "H${i} ${D}-${F}" 
    }
    set NbSheet [LePCIDuResidu Sheet Number]
    for {set i 1} {$i<=$NbSheet} {incr i} {
	set D [LePCIDuResidu Sheet $i Reference Debut]
	set F [LePCIDuResidu Sheet $i Reference Fin]

	Espionne "S${i} ${D}-${F}" 
    }
    return ""

}

proc AfficheLesmiRNAs {K} {

    global RepertoireDuGenome

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin"
    ac_AfficheVariable "$Texte" "" "Summary"
    return "$Texte"

}

proc AfficheListe {Liste {Maniere ""} {NomDuFichierOrigine ""}} {

    return [Affiche [join $Liste "\n"] $Maniere $NomDuFichierOrigine]

}

proc AfficheLogDesMSF {Selection} {

    foreach MSF [split $Selection "\n"] {
	AfficheLogDuMSF $MSF
    }

}

proc AfficheLogDuMSF {MSF} {

    global LogDuMSF
    if {[info exists LogDuMSF($MSF)]} {
	set Log [set LogDuMSF($MSF)]
    } else {
	regsub {.out} $MSF {.log} logmsf
	regsub {.msf$} $logmsf {} Log
    }
    if {[info exists Log]} {
	AfficheFichier $Log "AvecRien"
    }

}

proc AfficheMapping {FichierBlast {BanquesId ""} {SensGeneralDeS ""} {ExpectDeRef ""} {TailleMaxDesRAS NoCompress}} {

    global RepertoireDuGenome
    set Repertoire [RepertoireDeTravail]

    if {$ExpectDeRef == "" } {set ExpectDeRef "100"}

    if {![file exists $FichierBlast]} {return "toto"}
    
    set FichierTFA ""
    if {[EstUnPAB [file tail $FichierBlast]]} {
	set Nom [file tail    $FichierBlast]
	set Dir [file dirname $FichierBlast]
	if {$Dir == "."} {set Dir [pwd]}
	set DirDuRepertoireDuGenome [lindex [split $Dir "/"] end]
	if {[regexp "^blastn|^blastx" $DirDuRepertoireDuGenome]} {
	    set FichierTFA "$RepertoireDuGenome/nucmask/$Nom"
	    if {![file exists $FichierTFA]} {
		set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom"
	    } 
	} elseif {[regexp "^blastp|^tblastn" $DirDuRepertoireDuGenome]} {
	    if {[file exists "$RepertoireDuGenome/genscanpredictions/$Nom"]} {
		set FichierTFA "$RepertoireDuGenome/genscanpredictions/$Nom"
	    } else {
		set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
	    }
	} elseif {[regexp "^mrnablast" $DirDuRepertoireDuGenome]} {
	    set FichierTFA "$RepertoireDuGenome/mrnahuman/$Nom"
	}
    }
    if {![file exists $FichierTFA]} {set FichierTFA ""}

    set LargeurMax      [expr [winfo screenwidth .] - 200]
    set HauteurMax      [expr [winfo screenheight .]*3/4]
    set LargeurFenetre  [expr [winfo screenwidth .] - 200]
    set HauteurFenetre  [expr [winfo screenheight .]*3/4]
    
    set HBox            25.0
    set HSmallBox       10.0
    set BordY           50.0
    set BordX           125.0
    set EcartY          1.0
    set CentreX [expr $LargeurMax/2]
    set PosYEnteteDeQ 8
    set PosYEnteteDeS [expr $HauteurMax - $PosYEnteteDeQ]
    set Police "Courier 10"
    set YNomQuery       [expr $BordY*2/3]
    set YTypeDeBlast    [expr $BordY/4]
    set TailleMaxNomQuery 100
    set XTexteGauche [expr $BordX/2]
    set XTexteDroite [expr $LargeurMax - $BordX/2]
    set YTailleQ [expr $BordY + $HBox/2]
    set YTailleS [expr $HauteurMax - $BordY - $HBox/2]

    set LesBanquesId [split $BanquesId "\n"]
    if {$BanquesId==""} {set BId [set tab(1)];set LesBanquesId [list "$BId"]}

    DepouilleLeBlast tab $FichierBlast "" "" $LesBanquesId
    set Database    [set tab(Database)   ]
    set TypeDeBlast [set tab(TypeDeBlast)]
    set TypeDeBlast "$TypeDeBlast: $Database"
    set NomQuery    [set tab(Query)]
    if {$TailleMaxNomQuery < [string length $NomQuery]} { 
	set PetitNomQuery [string range $NomQuery 0 $TailleMaxNomQuery]
	append PetitNomQuery "..."
    } else {
	set PetitNomQuery $NomQuery
    }

    if {$TailleMaxDesRAS == ""} {
	set TailleMaxDesRAS 500
    } elseif {$TailleMaxDesRAS == "NoCompress"} {
	set TailleMaxDesRAS "1e200"
    } else {
	if {![EstCeUnNombre $TailleMaxDesRAS]} {
	    set TailleMaxDesRAS "500"
	}
    }
    foreach BanqueId $LesBanquesId {
	scan $BanqueId "%s" BanqueId
	set ToutesLesRegions [ToutesLesRegionsDeLaQuery tab $FichierBlast $BanqueId $FichierTFA]
	set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre]
	$K configure -background white   
	
	if {[lindex [lindex $ToutesLesRegions 0] 5] != ""} {
	    set PresenceDUnSubject 1
	} else {
	    set PresenceDUnSubject 0
	}
	
	set TailleQ [lindex [lindex $ToutesLesRegions 0] 2]
	set TailleS [lindex [lindex $ToutesLesRegions 0] 5]
	
	set TailleReduiteS $TailleS
	set TailleReduiteQ $TailleQ
	set LesRegionsDeLaQuery {}
	set LesRegionsDuSubject {}
	set LesRegionsAvecLesDeux {}
	set CalculSensS 0
	foreach UneRegion $ToutesLesRegions {
	    set DebutQ [lindex $UneRegion 0] 
	    set FinQ [lindex $UneRegion 1]
	    set DebutS [lindex $UneRegion 3]
	    set FinS [lindex $UneRegion 4] 
	    set TypeRegion [lindex $UneRegion 6]
	    set Sens [SensDeLaRegion $TypeRegion]
	    
	    if {  $DebutS != "" && $FinS != ""} {
		set Diffs [expr $FinS - $DebutS + 1]
		if {$Sens == "+"} {
		    set CalculSensS [expr $CalculSensS + $Diffs]
		} elseif {$Sens == "-"} {
		    set CalculSensS [expr $CalculSensS + $Diffs]
		}
	    }
	    if {$DebutQ != "" && $FinQ != ""} {
		lappend LesRegionsDeLaQuery $UneRegion
	    }
	    if {$DebutS != "" && $FinS != ""} {
		lappend LesRegionsDuSubject $UneRegion
	    }
	    if {$DebutS != "" && $FinS != "" && $DebutQ != "" && $FinQ != ""} {
		lappend LesRegionsAvecLesDeux $UneRegion
	    }
	    
	    if {      $DebutS != "" && $FinS != "" && $TypeRegion == "RAS"} {
		set DiffS [expr $FinS - $DebutS + 1]
		if {$TailleMaxDesRAS<$DiffS} {
		    set TailleReduiteS [expr $TailleReduiteS - $DiffS + $TailleMaxDesRAS]
		}
		
	    } elseif {$DebutQ != "" && $FinQ != "" && $TypeRegion == "RAS"} {
		set DiffQ [expr $FinQ - $DebutQ + 1]
		if {$TailleMaxDesRAS<$DiffQ} {
		    set TailleReduiteQ [expr $TailleReduiteQ - $DiffQ + $TailleMaxDesRAS]
		}
	    } 
	}

	if {$SensGeneralDeS == ""} {
	    if {$CalculSensS < 0} {
		set SensGeneralDeS "-"
	    } else {
		set SensGeneralDeS "+"
	    }
	}
	#########QUERY##############################
	#########QUERY##############################
	set OldXDebutQ ""
	set OldXFinQ ""
	set OldYDebutQ ""
	set OldYFinQ ""
	
	set RapportQ [expr ($LargeurMax - 2 * $BordX) / $TailleReduiteQ]
	set ModifTailleQ 0
	set LesRegionsOccupees {}
	foreach Region $LesRegionsDeLaQuery {
	    ######### COLORING########################
	    set ColorOutLine "white"
	    set TypeRegion [lindex $Region 6]
	    if {$TypeRegion == "" && [regexp "BLASTP" $TypeDeBlast]} {
		set TypeRegion "Prot / Prot"
	    }
	    set Sens [SensDeLaRegion $TypeRegion]	    
	    set ColorFill [ColoriageDuMapping $TypeRegion]
	    #########QUERY##############################
	    if {[lindex $Region 0] == "" || [lindex $Region 1] == ""} {continue}
	    
	    set DebutQ [lindex $Region 0]
	    set FinQ [lindex $Region 1]
	    
	    if {$DebutQ == $FinQ} {
		set XDebutQ [expr $BordX + ($DebutQ - 0.5  - $ModifTailleQ) * $RapportQ ]
		set XFinQ [expr $BordX + ($FinQ + 0.5 - $ModifTailleQ) * $RapportQ ]
	    } else {
		set XDebutQ [expr $BordX + ($DebutQ - $ModifTailleQ) * $RapportQ ]
		set XFinQ [expr $BordX + ($FinQ - $ModifTailleQ) * $RapportQ ]
	    }
	    
	    if {$TypeRegion == "RAS"} {
		set DiffQ [expr $FinQ - $DebutQ + 1]
		if {$DiffQ > $TailleMaxDesRAS} {
		    set ColorFill "darkgrey"
		    set XFinQ [expr $BordX + ([lindex $Region 0] - $ModifTailleQ + $TailleMaxDesRAS) * $RapportQ ]
		    set ModifTailleQ [expr $ModifTailleQ + $DiffQ - $TailleMaxDesRAS]
		}
	    }
	    
	    set NbRecouvrement [RecouvrementDeLaRegion $DebutQ $FinQ $LesRegionsOccupees "Etendre"]
	    if {$NbRecouvrement >= 40} {set NbRecouvrement 40}
	    if {$NbRecouvrement == 0} {
		set YDebutQ $BordY
		set YFinQ   [expr $YDebutQ + $HBox]
	    } else {
		set YDebutQ [expr $BordY + $HBox + ($NbRecouvrement * $EcartY) + ($NbRecouvrement-1) * $HSmallBox]
		set YFinQ   [expr $YDebutQ + $HSmallBox]
	    }
	    
	    set LesCoordonnees [list "$XDebutQ" "$XFinQ" "$YDebutQ" "$YFinQ" "$ColorFill"]
	    set TabQ($DebutQ,$FinQ) $LesCoordonnees
	    
	    set LeDebutEtLaFin [list "$DebutQ" "$FinQ"]
	    lappend LesRegionsOccupees $LeDebutEtLaFin
	}
	
	set LesRegionsDuSubject [lsort -increasing -integer -index 3 [lsort -decreasing -integer -index 4 $LesRegionsDuSubject]]
	#######SUBJECT###############################	
	#######SUBJECT###############################
	if {[lindex [lindex $ToutesLesRegions 0] 5]!= ""} { 
	    set RapportS [expr ($LargeurMax - 2 * $BordX) / $TailleReduiteS]
	    set YFinS [expr $HauteurMax - $BordY]
	    set YDebutS [expr $YFinS - $HBox]	
	}
	set ModifTailleS 0
	set ModifTailleQ 0
	foreach Region $LesRegionsDuSubject {
	    ######### COLORING########################
	    set ColorOutLine "white"
	    set TypeRegion [lindex $Region 6]
	    if {$TypeRegion == "" && [regexp "BLASTP" $TypeDeBlast]} {
		set TypeRegion "Prot / Prot"
	    }
	    set ColorFill [ColoriageDuMapping $TypeRegion]
	    
	    #######SUBJECT###############################
	    if {[lindex $Region 3] == "" || [lindex $Region 4] == ""} {continue}
	    set DebutS [lindex $Region 3]
	    set FinS [lindex $Region 4]
	    
	    set XDebutS [expr $BordX + ($DebutS - $ModifTailleS) * $RapportS ]
	    set XFinS [expr $BordX + ($FinS - $ModifTailleS) * $RapportS ]
	    if {$TypeRegion == "RAS"} {
		set DiffS [expr $FinS - $DebutS + 1]
		if {$DiffS > $TailleMaxDesRAS} {
		    set ColorFill "darkgrey"
		    set XFinS [expr $BordX + ($DebutS - $ModifTailleS + $TailleMaxDesRAS) * $RapportS ]
		    set ModifTailleS [expr $ModifTailleS + $DiffS - $TailleMaxDesRAS]
		}
	    }		
	    set LesCoordonnees [list "$XDebutS" "$XFinS" "$YDebutS" "$YFinS" "$ColorFill"]
	    set TabS($DebutS,$FinS) $LesCoordonnees
	}

	$K create text $CentreX $YTypeDeBlast -text "$TypeDeBlast" -font "$Police"
	$K create text $CentreX $YNomQuery -text "$PetitNomQuery" -font "$Police"
	
	$K create text $XTexteGauche $YTailleQ -text "1" -font "$Police"
	$K create text $XTexteDroite $YTailleQ -text "$TailleQ" -font "$Police"
	
	if {$PresenceDUnSubject} {
	    $K create text $CentreX [expr $HauteurMax - $YNomQuery] -text "$BanqueId" -font "$Police"
	    if {$SensGeneralDeS == "+"} {
		$K create text $XTexteGauche $YTailleS -text "1" -font "$Police" -anchor w
		$K create text $XTexteDroite $YTailleS -text "$TailleS" -font "$Police" -anchor e
	    } else {
		$K create text $XTexteDroite $YTailleS -text "1" -font "$Police" -anchor e
		$K create text $XTexteGauche $YTailleS -text "$TailleS" -font "$Police" -anchor w
	    }
	}
	
	foreach UneRegion $ToutesLesRegions {
	    set XDebutQ ""
	    set XFinQ ""
	    set XDebutS ""
	    set XFinS ""
	    set DebutQ      [lindex $UneRegion 0] 
	    set FinQ      [lindex $UneRegion 1]
	    set DebutS      [lindex $UneRegion 3]
	    set FinS      [lindex $UneRegion 4] 
	    set TypeRegion [lindex $UneRegion 5]
	    set Sens [SensDeLaRegion $TypeRegion]
	    
	    if {    $DebutQ != "" && $FinQ != "" &&  $DebutS == "" && $FinS == "" } {
		set LesCoordonnees [set TabQ($DebutQ,$FinQ)]
		set XDebutQ [lindex $LesCoordonnees 0]
		set XFinQ [lindex $LesCoordonnees 1]
		set YDebutQ [lindex $LesCoordonnees 2]
		set YFinQ [lindex $LesCoordonnees 3]
		set ColorFill [lindex $LesCoordonnees 4]
		
		$K create rectangle $XDebutQ $YDebutQ $XFinQ $YFinQ -outline $ColorOutLine -fill $ColorFill
	    }  elseif {$DebutS != "" && $FinS != "" &&  $DebutQ == "" && $FinQ == "" } {
		set LesCoordonnees [set TabS($DebutS,$FinS)]
		
		if {$SensGeneralDeS == "+"} {
		    set XDebutS [lindex $LesCoordonnees 0]
		    set XFinS [lindex $LesCoordonnees 1]
		} else {
		    set XDebutS [expr $LargeurMax - [lindex $LesCoordonnees 0]]
		    set XFinS   [expr $LargeurMax - [lindex $LesCoordonnees 1]]
		}
		
		set YDebutS [lindex $LesCoordonnees 2]
		set YFinS [lindex $LesCoordonnees 3]
		
		set ColorFill [lindex $LesCoordonnees 4]
		
		$K create rectangle $XDebutS $YDebutS $XFinS $YFinS -outline $ColorOutLine -fill $ColorFill
	    } elseif {$DebutS != "" && $FinS != "" &&  $DebutQ != "" && $FinQ != "" } {
		
		set LesCoordonnees [set TabQ($DebutQ,$FinQ)]
		set XDebutQ [lindex $LesCoordonnees 0]
		set XFinQ [lindex $LesCoordonnees 1]
		set YDebutQ [lindex $LesCoordonnees 2]
		set YFinQ [lindex $LesCoordonnees 3]
		set ColorFill [lindex $LesCoordonnees 4]
		
		set LesCoordonnees [set TabS($DebutS,$FinS)]
		set YDebutS [lindex $LesCoordonnees 2]
		set YFinS [lindex $LesCoordonnees 3]
		if {$SensGeneralDeS == "+"} {
		    set XDebutS [lindex $LesCoordonnees 0]
		    set XFinS [lindex $LesCoordonnees 1]
		} else {
		    set XDebutS [expr $LargeurMax - [lindex $LesCoordonnees 0]]
		    set XFinS   [expr $LargeurMax - [lindex $LesCoordonnees 1]]
		}
		
		set ColorFill [lindex $LesCoordonnees 4]
		
		$K create rectangle $XDebutQ $YDebutQ $XFinQ $YFinQ -outline $ColorOutLine -fill $ColorFill
		$K create rectangle $XDebutS $YDebutS $XFinS $YFinS -outline $ColorOutLine -fill $ColorFill
		$K create line $XDebutQ $YFinQ $XDebutS $YDebutS -fill $ColorFill
		$K create line $XFinQ $YFinQ $XFinS $YDebutS -fill $ColorFill
	    }
	}
	regsub {\.canvas} $K "" w
	set B [BoutonneLaFenetre $w "Show Blast/Subject/Fetch\nMosaic"]
	bind $B <1> "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs"
	bind $B <2> "AfficheLesAliEnPage \[ContenuDuFichier $FichierBlast\] $BanqueId $FichierBlast"
	bind $B <3> "AfficheFetch  $BanqueId OnVeutNature"
	bind $B  "IllustreLeBlast $FichierBlast"

	set C [BoutonneLaFenetre $w "Color" "CouleursDesBoites"]
	set S [BoutonneLaFenetre $w "Direction      +    / - / Default\n Compression Default / x /  None"]
	bind $S <1>       "AfficheMapping $FichierBlast $BanqueId + $ExpectDeRef $TailleMaxDesRAS"
	bind $S <2>       "AfficheMapping $FichierBlast $BanqueId - $ExpectDeRef $TailleMaxDesRAS"
	bind $S <3>       "AfficheMapping $FichierBlast $BanqueId \"\" $ExpectDeRef $TailleMaxDesRAS"
	bind $S  "AfficheMapping $FichierBlast $BanqueId $SensGeneralDeS $ExpectDeRef \"\""
	bind $S  "AfficheMapping $FichierBlast $BanqueId $SensGeneralDeS $ExpectDeRef \[Entre\]"
	bind $S  "AfficheMapping $FichierBlast $BanqueId $SensGeneralDeS $ExpectDeRef NoCompress"
    }
    return $K

}

proc AfficheMedline {Selection} {

    Wup "Calls Jean-Marie Wurtz's program to fetch medline's http file."
    foreach Ligne [split $Selection "\n"] {
	catch {unset Uid}
	if {[regexp "^RX" $Ligne]} {
	    catch {set Uid [IntegerApres "MEDLINE;" dans $Ligne]}
	} elseif {[regexp "PMID:" $Ligne]} {
	    catch {set Uid [IntegerApres "PMID:" dans $Ligne]}
	} else {
	    continue
	}
	if { ! [info exists Uid] || ! [regexp {^[0-9]+$} $Uid] } { continue }
	AfficheVariable [exec medhttp $Uid] "AvecRien"
    }

}

proc AfficheMesPABs {} {


    foreach PAB [ListeDesPABs] {
	Espionne "$PAB [Alias $PAB]"
    }

}

proc AfficheModeAnnotation {} {


    AfficheBoutonsAnnotation

    return

}

proc AfficheModeArbres {} {


    AfficheBoutonsArbres
    BindModeNormal

    return

}

proc AfficheModeCherche {{prevMode ""}} {


    AfficheBoutonsCherche $prevMode

    return

}

proc AfficheModeClusters {} {


    InitSeqsOut 0
    AfficheBoutonsClusters
    
    return

}

proc AfficheModeConservation {} {


    AfficheBoutonsConservation

    return

}

proc AfficheModeFeateditor {} {

    array set ::Tori [array get ::TabSF]
    AfficheBoutonsFeateditor
    unset -nocomplain ::Tori

    return

}

proc AfficheModeFeatures {} {

    global LFeatCourantes

    if {! [info exists LFeatCourantes]} {
	set LFeatCourantes [list]
    }
    AfficheBoutonsFeatures

    return

}

proc AfficheModeOrdali {} {

    AfficheBoutonsOrdali
    BindModeNormal

    return

}

proc AfficheModePCI {} {


    AfficheBoutonsPCI
    BindModeNormal

    return

}

proc AfficheModeSeqlab {} {

    global NomTextSeq Toggle NomNOmSeq

    LesDefauts AffSS 1
    CacheStrSecDansAlignement
    if {[set Toggle(Scores)]} {
	set Toggle(Scores) 0
	ToggleScores
    }

    EmulationSeqLab
    BindModeSeqlab
    AfficheBoutonsSeqLab

    return

}

proc AfficheModeSuperposition {} {

    global ListePDB

    if {[TypeAli] eq "pasdali"} {return}

    # pas , ou 1 seul , pdb
    if {! [info exists ListePDB] || $ListePDB == {}} {
	FaireLire "No 3D structures in this alignment !"
	return
    }

    if {[llength $ListePDB] == 1} {
	set ::StrucAVoir $ListePDB
	VisualiseStructure
    } else {
	AfficheBoutonsSuperposition
    }

    BindModeNormal

    return

}

proc AfficheMoi {args} {

    set Pro [lindex $args 0]
    if { ! [HtmlAuthorize $Pro]} { Expe "Error from Gscope : $Pro isn't authorized" ; return "" }
    set Retour [eval $args]
    return [Html_DuTexteTelQuel $Retour] 

}

proc AfficheMsfFamily {Nom} {

    global RepertoireDuGenome
    set Famille [NomDeFamille $Nom]
    if {$Famille=="UnknownFamily"} { return "" }
    set Fichier "$RepertoireDuGenome/msffamily/$Famille.msf"

    if { ! [file exists $Fichier]} { return "" }

    return [AfficheFichier $Fichier "GrandeLargeurAvecEtudeMSF"]

}

proc AfficheMsfOfFamiliarOrganisms {NomOrigine} {

    
    set Nom [file tail $NomOrigine]
    set FamMsf [MsfOfFamiliarOrganisms $Nom]
    if {$FamMsf==""} { return "" }
    return [AfficheVariable $FamMsf "AvecEtudeMSFGrandeLargeur" $NomOrigine]

}

proc AfficheNomsEtSeqs {} {

    global Defauts NomsAffiches LSOrdali NomNomSeq NomTextSeq TScrollY

    if {! [ModeI]} {return}

    set YPos [$TScrollY get]
    EffaceWNomsWSeqs

    $NomNomSeq configure -state normal
    $NomNomSeq tag configure PDB -foreground black -background red -underline 1
    $NomNomSeq insert end [join $NomsAffiches "\n"]
    $NomNomSeq configure -state disabled

    if {[QuelMode] ne "seqlab"} {
	$NomTextSeq configure -state normal
	$NomTextSeq insert end [join $LSOrdali "\n"]
	$NomTextSeq configure -state disabled
    }

    $TScrollY set {*}$YPos

    return

}

proc AfficheNuc {Boite} {

    set Nom [Box $Boite nom]
    if { $Nom=="" } { return "" }
    set Debut  [Box $Boite debut]
    set Fin    [Box $Boite fin]
    set Orient [Box $Boite orient]
    set SeqNuc [BoutADN $Debut $Fin $Orient]
    set NucTFA [SequenceFormatTFA $SeqNuc "$Nom $Debut $Fin $Orient" "nucbrut"]
    return [AfficheVariable $NucTFA "AvecBlasteAvecFormateAvecVoisinsSansFetch" $Nom]

}

proc AfficheORGAorgaDesMSFs {{Etat ""}} {

    foreach Nom [ListeDesPABs] {
	lappend LesORGAorga "$Nom [ORGAorgaDesMSFs $Nom $Etat]"
    }
    AfficheVariable [join $LesORGAorga "\n"] "AvecRien" "OrthologuesInCompleteGenomes"

}

proc AfficheObjet {w nom obj} {

    global pgl

    if {[$w cget -foreground] eq "green1"} {
	$nom ObjetOff $obj
	$w configure -foreground red
    } else {
	$nom ObjetOn $obj
	$w configure -foreground green1
    }

    DefineLabels2Show
    set pgl(SelectionList) ""

    $pgl(wogl) postredisplay

    return

}

proc AfficheOperonsCommunsAuxClusters {} {

    set Fichier "[RepertoireDuGenome]/fiches/operons_communs"
    set Texte [ContenuDuFichier $Fichier]
    regsub -all "\t" $Texte " " Texte
    while {[regexp "  " $Texte]} { regsub -all "  " $Texte " " Texte }
    return [AfficheVariable $Texte "AvecOpCom" $Fichier]

}

proc AfficheOverview {} {

    global Ovw FrmBtnFea LNDG ListeTypesDeFeatures NomTextSeq

    # alignement vide
    if {[TypeAli] eq "pasdali"} {return}
    if {[QuelMode] eq "seqlab"} {
	FaireLire "Not available in Editor mode !"
	return
    }
    
    # configure features
    FaireAttendre "Please wait ...\nDrawing alignment overview ..."

    if {! [info exists Ovw]} {
	set Ovw(Groupes) $LNDG
	set Ovw(Liste) [list 1]
	set Id 1
    } else {
	set Id [expr {[lindex [set Ovw(Liste)] end] + 1}]
    }
    MetAJourFeaturesOverview

    # define new overview
    set Ovw(O$Id,Feat) "automatic"
    set Ovw(O$Id,Mac) [MacCourant]

    set w ".overview$Id"
    toplevel $w
    wm title $w "Overview No $Id"
    wm iconname $w "Overview $Id"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix
    wm resizable $w 0 0

    set Ovw(O$Id,w) "$w.c"
    canvas $w.c  -height 300  -width 500  -background white
    pack $w.c -side top -expand 1
    set wc "$w.c"
    
    frame $w.btn
    pack $w.btn -expand 1 -fill x -side bottom -padx 5 -pady 10
    ttk::combobox $w.btn.combo  -background white  -state readonly  -height 0  -textvariable Ovw(O$Id,Feat)  -values $Ovw(LFeat)  -width $Ovw(FeatWidth)
    $w.btn.combo index 0
    bind $w.btn.combo <> "MetAJourDessinOverview $Id %W"
    pack $w.btn.combo -side left -expand 1
    frame $w.btn.fpm
    button $w.btn.fpm.btm  -text "-"  -background cyan  -command [list ChangeEchelleOverview $Id "moins"]
    button $w.btn.fpm.btp  -text "+"  -background cyan  -command [list ChangeEchelleOverview $Id "plus"]
    pack $w.btn.fpm.btm $w.btn.fpm.btp -side left
    pack $w.btn.fpm -side left
    button $w.btn.btprt  -text "Print"  -background yellow  -command [list PrintCanvas $wc png]
    pack $w.btn.btprt -side left -expand 1
    button $w.btn.btclose  -text "Close"  -background green1  -command [list DetruitOverview $Id]
    pack $w.btn.btclose -side left -expand 1

    #    MesCouleurs $w

    CalculeOverview $Id

    if {[info exists FrmBtnFea] && [QuelMode] eq "feature"} {
	foreach c [winfo children $FrmBtnFea] {
	    if {[EtatDuBouton $c]} {
		set f [lindex [$c cget -command] 1]
		DessineFeatureSurOverview $Id "" $f 1
	    }
	}
    }

    FaireLaSuite .wover

    trace add execution RepeintNomsEtSeqs leave MetAJourOverview
    trace add variable ListeTypesDeFeatures write MetAJourFeaturesOverview

    # position new window
    set h 0
    foreach top [winfo children .] {
	if {[string first ".overview" $top] != 0} {
	    continue
	}
	if {$top eq $w} {
	    continue
	}
	incr h [winfo height $top]
    }
    wm geometry $w +0+$h

    update idletasks

    return $Id

}

proc AffichePDB {aPDB} {

JeMeSignale
    set TextePDB [TextePDB $aPDB "Ref"]

    if {$TextePDB==""} { return "" }

    return [AfficheVariable $TextePDB "AvecPDB"]


}

proc AffichePeptideSort {Nom {Page ""} {ShowEnzymes ""}} {

    if {[EstUnPAB $Nom]} {
	set Texte [PeptideSort $Nom $ShowEnzymes]
    } elseif {$Page!=""} {
	set Texte [PeptideSort $Page $ShowEnzymes]
    } elseif {$Nom!=""} {
	set Texte [PeptideSort $Nom $ShowEnzymes]
    } else { 
	return ""
    }
    if {$Texte==""} { return "" }
    scan $Nom "%s" Titre
    return [AfficheVariable $Texte "AvecRien" $Titre] 

}

proc AffichePeptideSortPourLesFusions {{LesFiFu ""} {ChoixPourCoupure ""} {AvecAffichage ""}} {


    if {$AvecAffichage=="SansAffichage"} { set AvecAffichage 0 } else { set AvecAffichage 1 }

    if {$LesFiFu==""} {
	set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
	set LesFiFu [ChoixDesPresents $LesFiFu]
    }
    if {$LesFiFu=="AllFusion"} {
	set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
    }
    if {$LesFiFu==""} { return "" }

    if {[llength [split $ChoixPourCoupure " "]]==5} {
	set ChoixCoupure $ChoixPourCoupure
    } else {
	set ChoixCoupure [ChoixDUnSiteDeCoupure $ChoixPourCoupure]
    }
    set LongCoupP ""
    scan $ChoixCoupure "%s %s %d %s %d" Coupure CoupN LongCoupN CoupP LongCoupP
#    if {$LongCoupP==""} { return {} }
    foreach FiFu $LesFiFu {
	set Nom [file tail $FiFu]
	regsub ".nuctfa" $Nom "" Nom
	regsub ".prottfa" $FiFu ".nuctfa" FiFuN

	lappend LesNoms $Nom

	set SeqN [QueLaSequenceDuTFA $FiFuN]
	set SeqP [SeqNucToSeqPro $SeqN]
	set Zone(Seq) "Full"
	set LesVariablesSeq [list "Seq"]
	if {$Coupure!="SansCoupure"} {
	    set iDebutCoupure [string first $CoupN [string toupper $SeqN]]
	    set lastDebutCoupure [string last $CoupN [string toupper $SeqN]]
	    if {$iDebutCoupure!=$lastDebutCoupure} {
		FaireLire "At least two sites for $Coupure are possible. \nI'll take the first one : $iDebutCoupure"
	    }
	    if {$iDebutCoupure>=0} {
		set GaucheSeqN [string range $SeqN 0 [expr $iDebutCoupure+$LongCoupN-1]]
		set DroiteSeqN [string range $SeqN [expr $iDebutCoupure+$LongCoupN] end]
	    }
	    set GaucheSeqP [SeqNucToSeqPro $GaucheSeqN]
	    set DroiteSeqP [SeqNucToSeqPro $DroiteSeqN]
	    lappend LesVariablesSeq "GaucheSeq" "DroiteSeq"
	    set Zone(GaucheSeq) "Left"
	    set Zone(DroiteSeq) "Righ"
	}
	foreach VariableSeq $LesVariablesSeq {
	    set CR      [CodonsRares [set [set VariableSeq]N] "AvecBlanc"]
	    set PepSort [PeptideSort [set [set VariableSeq]P]]
	    if {[info exists TPep]} { unset TPep }
	    DecortiquePeptideSort $PepSort "" TPep
	    set Residues         [set TPep(Residues)]
	    set Molecularweight  [set TPep(Molecularweight)]
	    set Charged          [set TPep(Charged)]
	    set Isoelectricpoint [set TPep(Isoelectricpoint)]
	    
	    set SeqCompressee ""
	    append SeqCompressee [string range [set [set VariableSeq]P] 0 5]
	    append SeqCompressee "..."
	    append SeqCompressee [string range [set [set VariableSeq]P] end-5 end]
	    set ZoNom [string range "[set Zone($VariableSeq)]_$Nom" 0 36]
	    lappend LesFragments [format "%-40.40s %4d %3d %10.2f %5.2f %s %s"  $ZoNom  $Residues $Charged  $Molecularweight $Isoelectricpoint  $SeqCompressee  $CR ]
	}
    }
    set LesFragments [LesLignesTrieesSurUneClefEntete $LesFragments [list 0 3 1]]
    if {$AvecAffichage} {
	FaireLire "I'll show you the report. Please don't forget to save it."
	AfficheVariable [join $LesFragments "\n"] "AvecTriFragments" PeptideSortSurFusion
    } else {
	set LesNR1 {}
	foreach Nom $LesNoms {
	    regsub {_[^_]+$} $Nom "" NR1
	    lappend LesNR1 $NR1
	}
	set NomFusRep [join [lsort -unique $LesNR1] "-"]
	set FichierReport "[RepertoireDuGenome]/fusionreport/${NomFusRep}_[Date].txt"
	return [SauveLesLignes $LesFragments dans $FichierReport]
    }
    return $LesFragments

}

proc AffichePof {{Quoi ""}} {

    if {$Quoi==""} { set Quoi "PofOl_PofPPCR_PofMut_PofSeq" }
    set Retour {}
    if {[regexp "AllPs" $Quoi]} {
	set LesPofOl  [PofOl  "LesPofOl"]
	set LesPofMut [PofMut "LesPofMut"]
	set LesPofSeq [PofSeq "LesPofSeq"]
	set LesPs [lsort [concat $LesPofOl $LesPofMut $LesPofSeq]]
	foreach TextP $LesPs {
	    scan $TextP "%s" P
	    set DejaVu($P) 1
	}
	foreach P [Oli "LaListeMerci"] {
	    if {[info exists DejaVu($P)]} { continue }
	    lappend LesPs [Oli $P "AllOnOneLine"]
	}

	set FO [AfficheListe $LesPs "AvecOliAvecFiOl" "PofOl_PofMut_PofSeq"]
	lappend Retour $FO
    }
    if {[regexp "PofOl" $Quoi]} {
	set FO [AfficheListe [PofOl  "LesPofOl"] "AvecOliAvecFiOl" "PofOligos"]
	lappend Retour $FO
    }
    if {[regexp "PofMut" $Quoi]} {
	set FO [AfficheListe [PofMut "LesPofMut"] "AvecOliAvecFiOl" "PofMutation"]
	lappend Retour $FO
    }
    if {[regexp "PofSeq" $Quoi]} {
	set FO [AfficheListe [PofSeq "LesPofSeq"] "AvecOliAvecFiOl" "PofSequencing"]
	lappend Retour $FO
    }
    if {[regexp "PofPPCR" $Quoi]} {
	set FP [AfficheListe [PofPPCR "5_3"]      "AvecOliAvecFiPPCR" "PofPPCR"]
	lappend Retour $FP
    }
    return $Retour

}

proc AffichePosGenSeq {w {pos ""}} {

    # return conditions
    if {[TypeAli] eq "pasdali" || [QuelMode] eq "seqlab" || $pos eq ""} {return}

    lassign [split [$w index $pos] .] y x 
    if {! [string is integer -strict $y]} {return}

    if {[set nom [lindex $::LNOrdali $y-1]] eq ""} {return}

    set ::XGen [expr {$x+1}]
    set ::XSeq [DonnePosGS $nom $x]

    return

}

proc AffichePosGenSeqSL {w {pos ""}} {

    # ==> Pour le Mode SeqLab !!
    #
    # return conditions
    if {[TypeAli] eq "pasdali"} {return}
    update idletasks
    
    lassign [split [$w index $pos] .] y x 
    if {! [string is integer -strict $y]} {return}

    if {[set nom [lindex $::LNSeqlab $y-1]] eq ""} {return}

    set ::XGen [expr {$x+1}]
    set ::XSeq [DonnePosGS_SL $nom $w $y $x]

    return

}

proc AffichePositionOligo {K X Y Action {Id ""}} {

    
    Wup "Affiche a droite et a gauche la position de l oligo sur la query"

    global PositionExisteDeja 

    if {$Id == ""} {set Id [$K find withtag current]}
    
    set MesTags   [$K gettags $Id]
    set MesCoords [$K coords  $Id]
    set Nom       [lindex $MesTags 4]
    set Banque    [lindex $MesTags 5]

    if {! [info exists PositionExisteDeja($K,$Id)]} {set PositionExisteDeja($K,$Id) 0}  
    if {$Action=="Hide" || [set PositionExisteDeja($K,$Id)]=="1"} { 
	set PositionExisteDeja($K,$Id) 0
	set Texte " "
	set Id    ""
	foreach Id [$K find withtag "Position"] {
	    if {[lindex [$K gettags $Id] 0] != $Nom || [lindex [$K gettags $Id] 1] !=$Banque} {continue}
	    $K itemconfigure $Id -text $Texte
	}
	return ""
    }
    set PositionExisteDeja($K,$Id) 1

    set Xmin [lindex $MesCoords 0]
    set Xmax [lindex $MesCoords 2]
    set Ymin [lindex $MesCoords 1]
    set Ymax [lindex $MesCoords 3]
    $K create text [expr $Xmin-3] [expr (($Ymax-$Ymin)/2)+$Ymin]  -text [lindex $MesTags 2]  -tags [list $Nom $Banque "Position"]  -anchor "e"

    $K create text [expr $Xmax+3] [expr (($Ymax-$Ymin)/2)+$Ymin]  -text [lindex $MesTags 3]  -tags [list $Nom $Banque "Position"]  -anchor "w"
    return ""

}

proc AffichePositionOligoPourTous {K X Y Action} {

    
    Wup "Affiche a droite et a gauche la position de tous les oligos par rapport a la query"

    EffacePositionOligoPourTous $K $X $Y
    
    set         LesId [$K find withtag "Positionner"]
    foreach Id $LesId {
	AffichePositionOligo $K $X $Y $Action $Id
    }
    return ""

}

proc AffichePourLaFamilleHDACroises {K Quoi} {

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Famille [lindex $MesTags 1]

    if {$Quoi==1} {
	if {[EstUnPAB $Famille]} {return [SearchOnBoard $Famille]}
	set LesMembres [LesMembresDeLaFamilleHDACroises $Famille]
	return [AfficheVariable [join $LesMembres "\n"] "" "HDA_family_members_$Famille"]
    }

    if {$Quoi==2} {
	if {[EstUnPAB $Famille]} {return [AfficheLesMembresDeLaFamille $Famille]}
    }

    if {$Quoi==3} {
	if {[EstUnPAB $Famille]} {return [AfficheLeClusterXHda $Famille]}
    }
    return ""

}

proc AffichePreferences {} {

    global Defauts
    global TmpDef
    global TypeCons
    global Couleurs
    global TypeText

    if {[winfo exists .prf]} {return}

    set oldGrab [grab current]
    if {$oldGrab ne ""} {set oldStatus [grab status $oldGrab]}
    set oldFocus [focus]

    array set TmpDef [array get Defauts]

    toplevel .prf
    wm title .prf "Preferences"
    wm protocol .prf WM_DELETE_WINDOW KillParLaCroix

    frame .prf.fnb
    pack .prf.fnb -side top -expand 1 -fill both

    set w ".prf.fnb.nb"
    NoteBook $w -side top  -activebackground green  -bd 2 -arcradius 4  -bg [set Defauts(BackAppli)]


    $w insert 0 gen -text "General"
    $w insert 1 col -text "Colors"
    $w insert 2 cns -text "Conservation"
    $w insert 3 dbs -text "Databases"
    $w insert 4 str -text "Structure"

    # Frame General

    set pgen [$w getframe gen]

    label $pgen.lbl -text "Ordalie appearance parameters" -font "Helvetica 14 bold" -anchor w -justify left

    label $pgen.lac -text "Application background color : " -anchor w -justify left
    button $pgen.bac -bg [set TmpDef(BackAppli)] -command "ChangeCouleurAppli $pgen.bac" -height 1
    button $pgen.bca -text "Apply" -bg green1 -command "AppliqueBackColor" -height 1

    label $pgen.whl -text "Mouse Wheel controls :" -anchor w -justify left
    label $pgen.lwy -text "Vertical scrolling " -anchor w -justify left
    entry $pgen.ewy -width 3 -bg white -textvariable TmpDef(DeltaYScroll) -justify right
    label $pgen.wuy -text " line(s)" -anchor w -justify left

    label $pgen.lwx -text "Horizontal scrolling " -anchor w -justify left
    entry $pgen.ewx -width 3 -bg white -textvariable TmpDef(DeltaXScroll) -justify right
    label $pgen.wux -text " character(s)" -anchor w -justify left


    grid $pgen.lbl  -row 0 -column 0 -columnspan 4 -pady {10 20} -sticky ew
    grid $pgen.fntl -row 1 -column 0 -sticky news
    grid $pgen.ffml -row 1 -column 1 -sticky news
    grid $pgen.fsiz -row 1 -column 2 -sticky news
    grid $pgen.fwgh -row 1 -column 3 -sticky news
    grid $pgen.lac  -row 2 -column 0 -columnspan 2 -ipady 30 -sticky ew
    grid $pgen.bac  -row 2 -column 2 -sticky ew
    grid $pgen.bca  -row 2 -column 3 -sticky ew
    grid $pgen.whl  -row 3 -column 0 -columnspan 4 -pady {30 5} -sticky news
    grid $pgen.lwy  -row 4 -column 1 -sticky news
    grid $pgen.ewy  -row 4 -column 2 -sticky news
    grid $pgen.wuy  -row 4 -column 3 -sticky news
    grid $pgen.lwx  -row 5 -column 1 -sticky news
    grid $pgen.ewx  -row 5 -column 2 -sticky news
    grid $pgen.wux  -row 5 -column 3 -sticky news

    # Frame couleurs d'ordalie

    set pcol [$w getframe col]

    # Frame Conservation

    set pcns [$w getframe cns]
    grid columnconfig $pcns {1 2} -weight 1

    label $pcns.lbl -text "Click on the buttons to change the colors assigned\nto the different conservation types" -anchor w -justify left
    set i 0
    foreach Type [lrange $TypeCons 0 2] {
	incr i
	scan [set Couleurs($Type)] "%s %s" fg bg
	label  $pcns.l$Type -text [set TypeText($Type)] -anchor w
	button $pcns.f$Type -bg $fg -activebackground $fg -width 4 -command "ChangeCouleur $Type $fg $pcns.f$Type"
	button $pcns.b$Type -bg $bg -activebackground $bg -width 4 -command "ChangeCouleur $Type $bg $pcns.b$Type"

	grid $pcns.l$Type -row $i -column 0 -sticky w
	grid $pcns.f$Type -row $i -column 1 -sticky w
	grid $pcns.b$Type -row $i -column 2 -sticky w
    }
    grid $pcns.lbl -row 0 -column 0 -columnspan 3 -sticky we -pady {10 0}

    label $pcns.lblm -text "For the Threshold Method :\nDefine the threshold above which a column is said\nto be conserved" -justify left
    label $pcns.sclb -text "Threshold " -anchor w -justify left
    scale $pcns.scal -from 0 -to 100  -orient horiz -showvalue true  -variable TmpDef(Threshold)  -width 8 -length 75
    grid $pcns.lblm -row 4 -column 0 -columnspan 3 -sticky ew -pady {20 5}

    grid $pcns.sclb -row 5 -column 0 -columnspan 1 -sticky w
    grid $pcns.scal -row 5 -column 1 -columnspan 2 -sticky news

    label $pcns.sim -text "Use similarity" -anchor w -justify left
    radiobutton $pcns.simy -text "Yes" -variable Defauts(SimiGris) -relief flat -value "1"
    radiobutton $pcns.simn -text "No" -variable Defauts(SimiGris) -relief flat -value "0"

    grid $pcns.sim  -row 6 -column 0 -sticky w
    grid $pcns.simy -row 6 -column 1
    grid $pcns.simn -row 6 -column 2

    # Frame Databases

    set pdbs [$w getframe dbs]
    label $pdbs.ldbs -justify left -anchor w -text "Ordalie retrieves some information using distant\n databases. You may change the defaults ones to\n yours. IMPORTANT ! The XXXX stands for the Id\n to be retrieved, and it must be specified in your url !" -font "Helvetica 14 bold"

    label $pdbs.lpdb -text "Protein Data Bank (PDB) location :" -justify left -anchor w
    entry $pdbs.epd1 -bg white -textvariable TmpDef(UrlPdbWorld)
    entry $pdbs.epd2 -bg white -textvariable TmpDef(UrlPdbHome)

    label $pdbs.lsrs -text "Sequence Retrieval System (SRS) location :" -justify left -anchor w
    entry $pdbs.esr1 -bg white -textvariable TmpDef(UrlSRSWorld)
    entry $pdbs.esr2 -bg white -textvariable TmpDef(UrlSRSHome)

    label $pdbs.lbrd -text "Biological Information Retrieval Database (BIRD) location :" -justify left -anchor w
    entry $pdbs.ebr1 -bg white -textvariable TmpDef(UrlPdbHoan)

    grid $pdbs.ldbs -row 0 -column 0 -sticky news -pady {10 5}
    grid $pdbs.lpdb -row 1 -column 0 -sticky news -pady {20 1}
    grid $pdbs.epd1 -row 2 -column 0 -sticky news
    grid $pdbs.epd2 -row 3 -column 0 -sticky news
    grid $pdbs.lsrs -row 4 -column 0 -sticky news -pady {20 1}
    grid $pdbs.esr1 -row 5 -column 0 -sticky news
    grid $pdbs.esr2 -row 6 -column 0 -sticky news
    grid $pdbs.lbrd -row 7 -column 0 -sticky news -pady {20 1}
    grid $pdbs.ebr1 -row 8 -column 0 -sticky news -pady {0 10}

    # Frame Structure

    set pstr [$w getframe str]

    # Fin notebook

    pack $w -fill both -expand yes
    $w compute_size
    $w raise gen

    # Frame boutons OK, Dismiss, etc ...

    frame .prf.fbt -relief flat
    pack .prf.fbt -side bottom -fill x -expand 1
    set w ".prf.fbt"
    button $w.dis -text "Dismiss" -bg red -command [list DismissDefauts .prf]
    button $w.sav -text "Save" -bg yellow -command [list SauveLesDefauts]
    button $w.ok  -text " OK " -bg green1 -command [list AccepteDefauts .prf]
    pack $w.dis $w.sav $w.ok -side left -expand 1 -padx 10 -pady 10

    #    MesCouleurs .prf
    FenetreAuCentre .prf

    grab -global .prf
    focus .prf

    tkwait window .prf

    focus $oldFocus
    if {$oldGrab ne ""} {
	if {$oldStatus eq "global"} {
	    grab -global $oldGrab
	} else {
	    grab $Grab
	}
    }

    return

}

proc AffichePreferences2 {} {

    global PrfListe LesItems OldPrf FrmPref TmpDef CoulTmp Couleurs Defauts

    if {[winfo exists .prf]} {
	raise .prf
	return
    }

    set oldGrab [grab current]
    if {$oldGrab ne ""} {set oldStatus [grab status $oldGrab]}
    set oldFocus [focus]

    array set TmpDef  [array get Defauts]
    array set CoulTmp [array get Couleurs]

    toplevel .prf
    wm title .prf "Preferences"
    wm protocol .prf WM_DELETE_WINDOW KillParLaCroix
    raise .prf

    set LesItems {General Sequences Databases Conservation Editor "3D Display" Trees}
    set Larg [PlusLongEltDe $LesItems]

    frame .prf.fnb
    pack .prf.fnb -side top -expand 0 -fill both -pady 5 -padx 5

    set w ".prf.fnb"
    set PrfListe ".prf.fnb.lst"
    listbox $w.lst  -width $Larg -height 20  -selectmode single  -borderwidth 3  -highlightthickness 0  -disabledforeground black  -bg white -fg black

    # Frame pref
    labelframe $w.frm  -relief groove  -font "Helvetica 14 bold"
    
    set FrmPref "$w.frm"
    
    # Frame Boutons OK dismiss default
    frame $w.btn
    button $w.btn.cancel  -text "Cancel"  -background red  -command [list DismissDefauts $w]
    button $w.btn.defaut  -text "Default"  -background yellow  -command [list RemetDefauts $PrfListe]
    button $w.btn.cebon  -text " OK "  -background green1  -command [list AccepteEtSauveDefauts $w]
    
    grid $w.btn.cancel -row 0 -column 0
    grid $w.btn.defaut -row 0 -column 1
    grid $w.btn.cebon  -row 0 -column 2
    grid columnconfig $w.btn {0 1 2} -weight 1
    grid rowconfig    $w.btn 0       -weight 0

    grid $w.lst -row 0 -column 0 -rowspan 2 -sticky ns -padx 5 -pady 5
    grid $w.frm -row 0 -column 1 -sticky news -pady {5 1} -padx 5 -ipady 5
    grid $w.btn -row 1 -column 1 -sticky wes -padx 10 -pady 10
    grid columnconfig $w 0 -weight 0
    grid columnconfig $w 1 -weight 0
    grid rowconfig    $w 0 -weight 0
    grid rowconfig    $w 1 -weight 0

    $w.lst insert 0 {*}$LesItems
    $w.lst selection set 0

    update
    set h1 [winfo height $w.lst]
    set h2 [winfo height $w.btn]
    $w.frm configure -height [expr {$h1-$h2}]

    set OldPrf "General"
    EnvoiePrfGeneral

    wm protocol .prf WM_DELETE_WINDOW AdieuOrdali
    MesCouleurs .prf
    FenetreAuCentre .prf

    bind $w.lst <1> {}
    #bind $w.lst  "DefinitPrfItem %W \[selection get\]"
    bind $w.lst <> "DefinitPrfItem %W \[selection get\]"

    return

}

proc AfficheProfileResults {} {

    global WProfile

    package require Tk
    
    set w .prfrst
    catch {destroy $w}
    toplevel $w

    set WProfile "$w.f.text"
    set wp "$w.f"
    frame $wp
    scrollbar $wp.scroll  -width 8  -command "$wp.text yview "
    text $wp.text -height 25 -width 80 -yscrollcommand "$wp.scroll set" -font "courier 14 bold" -bg black -fg white
    pack $wp.text   -fill both -side left -expand 1
    pack $wp.scroll -side left -fill y
    pack $wp -side top
    set wb "$w.b"
    frame $wb -bg black
    button $wb.calls -text "Nb Calls" -bg cyan -command {SortBy calls}
    button $wb.avgrn -text "avgRunTime" -bg cyan -command {SortBy avgRn}
    button $wb.total -text "totalTime" -bg cyan -command {SortBy total}
    button $wb.exclu -text "exclusiveTime" -bg cyan -command {SortBy exclu}
    button $wb.avgex -text "avgExcTime" -bg cyan -command {SortBy avgEx}
    button $wb.print -text "Save" -bg yellow -command {SauveProfile}
    button $wb.close -text " Close " -bg green1 -command {CloseProfileResults}
    pack $wb.calls $wb.avgrn $wb.total $wb.exclu $wb.avgex $wb.print $wb.close -side left -expand 1
    pack $wb -side bottom -expand 1 -fill x -pady 20

    InitDataProfile
    $wb.calls invoke

    bind $wp.text  [list DumpFunction %W @%x,%y]

    tkwait window $w

    return

}

proc AfficheProfileSegment {Selection Maniere Fichier} {

    scan $Selection "%s" Access
    set Page [ProfileSegment "$Access,$Fichier"]
    return [AfficheVariable $Page "" "${Access}_of_$Fichier"]

}

proc AfficheRec1 {Selection {Quoi ""}} {

    JeMeSignale
    if {$Quoi==""} { set Quoi "Description" }
    if {[regexp "\n" $Selection]} {
	foreach Ligne [split $Selection "\n"] {
	    AfficheRec1 $Ligne $Quoi
	}
	return
    }
    scan $Selection "%s" R
    if {$Quoi=="Description"} { return [AfficheLesRec1 $R] }
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec1 $R $Quoi] "AvecFormate"] }
    if {$Quoi=="Ppcr"}    {
	set N [Rec1 $R "N"]
	return [ShowVirtualPPCR $N]
    }
    if {$Quoi=="Vecteur"}    {
	set V [Rec1 $R "Vecteur"]
	set Fichier "[RepertoireDuGenome]/vecteurs/pDONR/$V"
	Espionne $Fichier
	return [AfficheFichier $Fichier "AvecFormate"]
    }
    return [AfficheVariable [Rec2 $R $Quoi]]

}

proc AfficheRec2 {Selection {Quoi ""}} {

    if {$Quoi==""} { set Quoi "Description" }
    if {[regexp "\n" $Selection]} {
	foreach Ligne [split $Selection "\n"] {
	    AfficheRec2 $Ligne $Quoi
	}
	return
    }
    scan $Selection "%s" R
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec2 $R $Quoi]] }
    scan $Selection "%s" R
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec2 $R $Quoi] "AvecFormate"] }
    if {$Quoi=="Rec1"}    {
	set R1 [Rec2 $R "R1"]
	return [AfficheLesRec1 $R1]
    }
    if {$Quoi=="Vecteur"}    {
	set V [Rec2 $R "Vecteur"]
	set Fichier "[RepertoireDuGenome]/vecteurs/pDEST/$V.tfa"
	Espionne $Fichier
	return [AfficheFichier $Fichier "AvecFormate"]
    }
    return [AfficheVariable [Rec2 $R $Quoi]]

}

proc AfficheReduceMsf {NomOuFichier {MinAB ""}} {

    set MSF [ReduceMsf $NomOuFichier "GetText" $MinAB]
    return [AfficheVariable $MSF "AvecEtudeMSFGrandeLargeur" $NomOuFichier]

}

proc AfficheRegle {{w .ordali.lessequences}} {

    global WTexteRegle TexteWRegle Defauts

    if {! [ModeI]} {return}

    set WTexteRegle "$w.regle"

    $WTexteRegle configure -state normal
    $WTexteRegle configure -font SeqFont
    $WTexteRegle delete 1.0 end

    $WTexteRegle insert end [set TexteWRegle(Tirets)]
    $WTexteRegle insert end "\n"
    $WTexteRegle insert end [set TexteWRegle(Comptr)]
    $WTexteRegle tag remove sel 1.0 end

    $WTexteRegle configure -state disabled

    return

}

proc AfficheReordonneMSF {MSF {LesAccess ""} {FichierOrigine ""}} {


    if {$LesAccess=="" || $LesAccess=="Ask"} { 
	set LesAccess [ChoixParmi {"Disphy" "Secator" "Dpc" "Oumy" "ShowSecator"}]
	if {$LesAccess==""} { return "" }
    }

    if {$LesAccess=="ShowSecator"} {
	MontreSecator $MSF
    }

    set Nom [file tail $FichierOrigine]

    set Fenetre [AfficheVariable [ReordonneMSF $MSF $LesAccess $Nom] "AvecEtudeMSFGrandeLargeur" "$FichierOrigine"]
    if {$LesAccess=="Disphy"} { return $Fenetre }
    set LesAGs [MontreSecator $MSF]
    IllumineSuivantLesGroupes $LesAGs $Fenetre
    MemoSelection $Fenetre Memorize
    return $Fenetre

}

proc AfficheRequeteSurLaMeilleureLocalisation {K Fichier {Qui OnlyTheBest} {LesNoms ""}} {

    global RepertoireDuGenome

    set Id      [$K find withtag current]
    set MesTags [$K gettags $Id         ]
    set Requete [lindex $MesTags 0      ]

    set LesResultats [RequeteSurLaMeilleureLocalisation $Requete $Fichier $Qui $LesNoms]
    if {$LesResultats != {}} {
	set Texte [join $LesResultats "\n"]
    } else {
	set Texte "Nothing"
    }

    AfficheVariable "$Texte" "" "Results"

    return "$Texte"

}

proc AfficheRognure {Page Selection Maniere NomDuFichierOrigine {InOut In}} {


    if {$InOut=="Alone"} {
	if {$Maniere=="Retour"} { return $Selection }
	return [AfficheVariable $Selection $Maniere $NomDuFichierOrigine]
    }

    set LesAccess {}
    foreach Ligne [split $Selection "\n"] {
	regsub "Name:" $Ligne "" Ligne
	set Access ""
	scan $Ligne "%s" Access
	if {$Access==""} { continue }
	lappend LesAccess $Access
    }
    set NouvellePage [MSFSelection $Page $LesAccess $InOut]

    if {$Maniere=="Retour"} { return $NouvellePage }
    return [AfficheVariable $NouvellePage $Maniere "$NomDuFichierOrigine"]

}

proc AfficheSequencesCorrelees {Fichier {Groupe ""}} {

    global RepertoireDuGenome
    
    JeMeSignale

    set Nom [file tail $Fichier]
    set Fichier "$RepertoireDuGenome/correlator/$Nom"
    if { ! [file exists $Fichier]} { return "" }
    set VasY 0
    set DejaVu 0
    set LesBons {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {$Groupe!=""} {
	    if {[regexp "groupe :" $Ligne]} {
		scan $Ligne "%s %s %d" Bidon DP GroupeLu
		if {$GroupeLu == $Groupe} {
		    set VasY 1
		    set DejaVu 1
		    continue
		} else {
		    if {$DejaVu} { break }
		}
	    }
	    if { ! $VasY } { continue }
	}
	regsub "^>" $Ligne "" Ligne
	lappend LesBons $Ligne
    }
    return [AfficheVariable [join $LesBons "\n"] ""]

}

proc AfficheSlidingCodonRare {Page {WindowSize ""}} {

    set SCR [SlidingCodonRare $Page]
    return [AfficheVariable [join $SCR "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"] 

}

proc AfficheSlidingCodonRarePour {{Liste ""}} {

    if {$Liste==""} {
	set Liste [MorceauxChoisis [PresentationDesPABs]]
    }
    if {$Liste=={}} { return "" }

    set WindowSize [ChoisisWindowSizePourSlidingCodonRare]

    foreach Ligne $Liste {
	scan $Ligne "%s" Nom
	set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"
	if { ! [file exists $FichierTFA]} { continue }
	set SCR [SlidingCodonRare $FichierTFA $WindowSize]
	lappend LesSCRs $Ligne
	lappend LesSCRs [join $SCR "\n"]
	lappend LesSCRs ""
    }
    
    return [AfficheVariable [join $LesSCRs "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"] 

}

proc AfficheSortedDistances {NomOuFichier} {

    set LesDistances [PairwizeDistancesInMsf "SortedDistances" $NomOuFichier]
    return [Graphe $LesDistances]

}

proc AfficheSpineDefinitions {} {

    set Page [SpineSummary "RetourneTexte"]
    foreach Ligne [split $Page "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or
	set DE [SpineDefinition $X]
	set BelleDE [format "%-50s" $DE]
#	regsub "$Or" $Ligne "$BelleDE $Or" Texte
	set Texte "$Ligne $BelleDE"
	lappend LeTout $Texte
    }
    return [AfficheVariable [join $LeTout "\n"] "" coucou]

}

proc AfficheTaxoFromTaxoLine {Ligne {Titre ""}} {

    set LeMessage {}
    foreach Li [split $Ligne "\n"] {
	set TaxId [lindex [LesMotsDeLaLigne $Li] 2]
	set Message "[format %-7s $TaxId] [TaxClass $TaxId Name]"
	lappend LeMessage $Message
    }
    return [AfficheListe $LeMessage "" $Titre]

}

proc AfficheTexte {Texte {Titre ""} {X ""} {Y ""}} {

    
    set w [NomDe fenetre]
    toplevel $w
    if {$Titre==""} { set Titre [string range $Texte 0 19] }
    wm title $w $Titre
    wm iconname $w $Titre

    set LesLignesDuTexte [split $Texte "\n"]
    set PremiereLigne [lindex $LesLignesDuTexte 0]

    set Hauteur [Mini 12 [Maxi 30 [llength $LesLignesDuTexte]]]
    set Largeur 80
    foreach Ligne $LesLignesDuTexte {
	set Largeur [Maxi $Largeur [string length $Ligne]]
    }
    set Largeur [Mini $Largeur 180]

    text  $w.text -wrap none -relief sunken -bd 2  -xscrollcommand "$w.scrollx set" -setgrid 1  -yscrollcommand "$w.scrolly set" -setgrid 1  -width $Largeur -height $Hauteur
          $w.text insert 0.0 $Texte
    $w.text configure -state "disable"
    focus $w.text
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m

    button $w.buttons.dismiss -background red -text "Dismiss" -command "destroy $w"
      pack $w.buttons.dismiss -side left -expand 1
    button $w.buttons.saveas -text "Save All/Sel."
      bind $w.buttons.saveas <1> "SaveAs \[$w.text get 1.0 end\]"
      bind $w.buttons.saveas <2> "SaveAs \[$w.text get sel.first sel.last\]"
      pack $w.buttons.saveas -side left -expand 1
    button $w.buttons.medline -text "Medline"
      bind $w.buttons.medline <1> "AfficheMedline \[$w.text get 1.0 end\]"
      pack $w.buttons.medline -side left -expand 1
    
    scrollbar $w.scrollx -command "$w.text xview" -orient "horizontal"
         pack $w.scrollx -side bottom -fill x
    scrollbar $w.scrolly -command "$w.text yview"
         pack $w.scrolly -side right -fill y

    pack $w.text -expand yes -fill both
    if {$X!=""} {
	$w.text xview scroll $X units
    }
    if {$Y!=""} {
	$w.text yview scroll $Y units
    }
    return $w

}

proc AfficheTousLesMedlinesDeLaSequence {Sequence} {

    Wup "Calls Jean-Marie Wurtz's program to fetch medline's http file."
    
    Gs "Frame"
    
    set LesLignes [split $Sequence "\n"]
    if {[llength $LesLignes] < 1} {
        FaireLire "$Sequence\nis n't a sequence."
        return ""
    }
    set iAccess [lsearch -regexp $LesLignes {^AC}]
    if {$iAccess<0} {
        FaireLire "Sorry I can't find the Access of the sequence"
        return ""
    }
    scan [lindex $LesLignes $iAccess] "%s %s" AC Access
    regsub ";" $Access "" Access
    return [AfficheVariable [exec meddata $Access] "AvecRien"]

}

proc AfficheToutesLesDefinitions {} {

#rR je sais pas si ca marche ....???????????????
    set Sortie {} 
    foreach Operon [lrange [LesOperons] 0 10] {
	set Premier [lindex $Operon 0]
	set LesDefs [Operon $Premier "Definitions"]
	lappend Sortie ""
	lappend Sortie  $Operon
	foreach Def $LesDefs {
	    lappend Sortie "    $Def"
	}
    }
    return [AfficheVariable [join $Sortie "\n"] "" ""]

}

proc AfficheUnArbre {AId} {

    global Abr Defauts WOrdali

    set w ".arbre$AId"
    toplevel $w
    wm title $w "Tree No $AId"
    wm iconname $w "Tree $AId"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix
    if {[winfo exists .fattendre]} {lower $w .fattendre}

    frame $w.fc
    frame $w.fb
    # packing des deux frames principales
    grid $w.fc -row 0 -column 0 -sticky news
    grid $w.fb -row 1 -column 0 -sticky news
    grid rowconfig    $w 0 -weight 1
    grid columnconfig $w 0 -weight 1

    # Frame canvas + ascenceurs
    set wc "$w.fc.c"
    set Abr($AId,PAD) $wc
    set Abr($AId,ContextMenu) $w.fc.c.menu
    canvas $w.fc.c  -height [set Abr($AId,FHeight)]  -width  [set Abr($AId,FWidth)]  -scrollregion [list 0 0 [set Abr($AId,PADWdt)] [set Abr($AId,PADHgt)]]  -cursor hand2  -background white  -relief groove  -xscrollcommand "$w.fc.hs set"  -yscrollcommand "$w.fc.vs set"

    scrollbar $w.fc.vs -command "$wc yview" -width 8
    scrollbar $w.fc.hs -orient horiz -command "$wc xview" -width 8

    grid $w.fc.c  -row 0 -column 0 -sticky news
    grid $w.fc.vs -row 0 -column 1 -sticky ns
    grid $w.fc.hs -row 1 -column 0 -sticky ew
    grid rowconfig    $w.fc 0 -weight 1
    grid columnconfig $w.fc 0 -weight 1
    grid columnconfig $w.fc 1 -weight 0

    # Frame des fonctions 
    frame $w.fb.fsrp -relief groove -borderwidth 2
    set WOrdali(Tree,DenRad) $w.fb.fsrp.esra
    checkbutton $w.fb.fsrp.esra  -text "Dendro/Radial"  -anchor w -justify left  -onvalue dendrogram  -offvalue radial  -variable Abr($AId,TypeTree)  -command [list OnReDessineArbre $AId]
    checkbutton $w.fb.fsrp.swap  -text "swap nodes"  -anchor w -justify left  -variable Abr($AId,Swap)  -relief flat  -onvalue 1  -offvalue 0  -command [list ModeSwap $AId]
    set Abr($AId,BReroot) "$w.fb.fsrp.reroot"
    checkbutton $w.fb.fsrp.reroot  -text "re-root tree"  -anchor w -justify left  -disabledforeground dimgrey  -variable Abr($AId,Reroot)  -relief flat  -onvalue 1  -offvalue 0  -command [list ModeReroot $AId]
    set Abr($AId,BCollapse) $w.fb.fsrp.col
    checkbutton $w.fb.fsrp.col  -text "collapse tree"  -anchor w -justify left  -variable Abr($AId,CollapseTree)  -onvalue 1  -offvalue 0  -command [list CollapseTree $AId]


    grid $w.fb.fsrp.esra   -row 0 -column 0 -sticky we
    grid $w.fb.fsrp.swap   -row 1 -column 0 -sticky we
    grid $w.fb.fsrp.reroot -row 2 -column 0 -sticky we
    grid rowconfig    $w.fb.fsrp all -weight 0
    grid columnconfig $w.fb.fsrp all -weight 1

    # Frame de display infos
    frame $w.fb.fa -relief groove -borderwidth 2
    checkbutton $w.fb.fa.phylum  -text "show phylum"  -anchor w -justify left  -variable Abr($AId,Phylum)  -onvalue 1  -offvalue 0  -command [list PeintParPhylum $AId]
    # show bootstrap :
    # different cases if dendro or radial
    set Abr($AId,ShowBootDen) $w.fb.fa.boots
    checkbutton $w.fb.fa.boots  -text "show bootstrap"  -anchor w -justify left  -variable Abr($AId,BootShow)  -onvalue 1  -offvalue 0  -command [list MontreBootstrap $AId]
    set Abr($AId,ShowBootRad) $w.fb.fa.fboo
    frame $w.fb.fa.fboo
    set Abr($AId,ThresBootPC) [set Defauts(ThresBootPC)]
    set Abr($AId,ThresBoot) [expr {1.0*$Abr($AId,ThresBootPC)*[set Defauts(TreeNBoot)]/100.}]
    checkbutton $w.fb.fa.fboo.b1  -text "show boot"  -anchor w -justify left  -variable Abr($AId,BootShow)  -onvalue 1  -offvalue 0  -command [list MontreBootstrap $AId]
    set Abr($AId,ThrBootEnt) $w.fb.fa.fboo.e1 
    entry $w.fb.fa.fboo.e1  -background white  -textvariable Abr($AId,ThresBootPC)  -justify right  -width 3  -validate none
    grid $w.fb.fa.fboo.b1 -row 0 -column 0
    grid $w.fb.fa.fboo.e1 -row 0 -column 1
    grid rowconfig    $w.fb.fa.fboo 0   -weight 0
    grid columnconfig $w.fb.fa.fboo all -weight 0

    checkbutton $w.fb.fa.shclus  -text "show clusters"  -anchor w -justify left  -variable Abr($AId,ShClusters)  -onvalue 1  -offvalue 0  -command [list PeintParClusters $AId]

    grid $w.fb.fa.phylum -row 0 -column 0 -sticky we
    grid $w.fb.fa.fboo   -row 1 -column 0 -sticky we
    #grid $w.fb.fa.boots  -row 1 -column 0 -sticky we
    grid $w.fb.fa.shclus -row 2 -column 0 -sticky we
    grid rowconfig    $w.fb.fa all -weight 0
    grid columnconfig $w.fb.fa 0 -weight 1 -minsize 0
    if {[TypeAli] ne "XML" && [TypeAli] ne "ORD"} {
	$w.fb.fa.phylum configure -state disabled
    }
    bind [set Abr($AId,ThrBootEnt)]  [list ChangeThresholdBoot $AId]
    if {! [set Abr($AId,BootDone)]} {
	#$w.fb.fa.boots configure -state disabled
	$w.fb.fa.fboo.b1 configure -state disabled
	bind [set Abr($AId,ThrBootEnt)]  ""
    }

    # Frame de redimentionnement de l'arbre
    # Deux frames :
    #    - cartesienne pour dendrgramme (width/height)
    #    - rotation    pour radial (rot/zoom)
    #
    # Pour dendogramme
    set Abr($AId,FDimXY) "$w.fb.fd"
    frame $w.fb.ft -relief groove -borderwidth 2

    set Abr($AId,FDimRZ) "$w.fb.fr"
    frame $w.fb.ft.f1
    checkbutton $w.fb.ft.f1.tnode  -text "Tag node"  -variable Abr($AId,DoTagNode)  -onvalue 1  -offvalue 0  -command [list ModeTagNode $AId]
    
    frame $w.fb.ft.f2
    set Wdt [PlusLongEltDe [set Abr($AId,LSeq)]]
    set Abr($AId,DoTagleaf) 0
    set Abr($AId,LeafSelOld) [lindex $Abr($AId,LSeq) 0]
    checkbutton $w.fb.ft.f2.ctag  -text "Tag"  -variable Abr($AId,DoTagLeaf)  -onvalue 1  -offvalue 0
    set Abr($AId,CbLTag) $w.fb.ft.f2.stag
    ttk::combobox $w.fb.ft.f2.stag  -background white  -width $Wdt  -height 15  -textvariable Abr($AId,LeafSel)  -state readonly  -values $Abr($AId,LSeq)
    $w.fb.ft.f2.stag index 0
    bind $w.fb.ft.f2.stag <> [list ModeTagLeaf $AId]
    frame $w.fb.ft.f3
    set Abr($AId,AddLeg)   0
    set Abr($AId,LegText)   ""
    set Abr($AId,LegBoot)  1
    set Abr($AId,LegCoul)  0
    set Abr($AId,LegGap)   1
    set Abr($AId,LegSites) 1
    set Abr($AId,Legend)   ""
    set Abr($AId,LegWText)  ""
    checkbutton $w.fb.ft.f3.ckleg  -text "Caption"  -anchor w -justify left  -onvalue 1 -offvalue 0  -variable Abr($AId,AddLeg)  -command [list DefineLegend $AId define]
    button $w.fb.ft.f3.clr  -text "Clear"  -bg white  -command [list DefineLegend $AId clear]

    grid columnconfig $w.fb.ft.f1 all -weight 1
    grid rowconfig    $w.fb.ft.f1 all -weight 1
    grid $w.fb.ft.f1.tnode -row 0 -column 0 -sticky ew

    grid $w.fb.ft.f2.ctag -row 0 -column 0 -sticky ew
    grid $w.fb.ft.f2.stag -row 0 -column 1 -sticky ew
    grid columnconfig $w.fb.ft.f2 all -weight 1
    grid rowconfig    $w.fb.ft.f2 all -weight 1

    grid $w.fb.ft.f3.ckleg -row 0 -column 0 -sticky ew
    grid $w.fb.ft.f3.clr   -row 0 -column 1 -sticky ew
    grid columnconfig $w.fb.ft.f3 all -weight 1
    grid rowconfig    $w.fb.ft.f3 all -weight 1

    #grid $w.fb.ft.f1 -row 0 -column 0 -sticky ew
    grid $w.fb.ft.f2 -row 1 -column 0 -sticky ew
    grid $w.fb.ft.f3 -row 2 -column 0 -sticky ew
    grid rowconfig    $w.fb.ft all -weight 0
    grid columnconfig $w.fb.ft all -weight 0

    #
    # gestion labels : on ecrit quoi
    frame $w.fb.ff -relief groove -borderwidth 2
    label $w.fb.ff.name  -text "Label"  -anchor w -justify left
    set cbw [PlusLongEltDe [set Abr(TypeAff)]]
    ttk::combobox $w.fb.ff.chnm  -background white  -height 0 -width $cbw  -textvariable Abr($AId,TAff)  -state readonly  -values $Abr(TypeAff)
    bind $w.fb.ff.chnm <> [list ChangeLabelTree $AId]

    # gestion fonte
    label $w.fb.ff.ftsize  -text "font size"  -anchor w -justify left
    spinbox $w.fb.ff.fsz  -readonlybackground white  -width 6  -state readonly  -values {6 8 10 12 14 16 18 20 22 24}  -command [list FonteMode $AId size %s]
    label $w.fb.ff.ftwght  -text "font weight"  -anchor w -justify left
    spinbox $w.fb.ff.fwh  -readonlybackground white  -width 6  -state readonly  -values [list normal bold]  -command [list FonteMode $AId weight %s]
    grid $w.fb.ff.ftsize -row 0 -column 0 -sticky w
    grid $w.fb.ff.fsz    -row 0 -column 1 -sticky ew
    grid $w.fb.ff.ftwght -row 1 -column 0 -sticky w
    grid $w.fb.ff.fwh    -row 1 -column 1 -sticky ew
    if {[TypeAli] eq "XML" || [TypeAli] eq "ORD"} {
	grid $w.fb.ff.name -row 2 -column 0 -sticky w
	grid $w.fb.ff.chnm -row 2 -column 1
    }
    grid rowconfig    $w.fb.ff all -weight 0
    grid columnconfig $w.fb.ff all -weight 0


    # Print, save, close, reset
    frame $w.fb.fprc
    button $w.fb.fprc.print  -text "Print"  -background yellow  -command [list PrintCanvas $wc png]
    button $w.fb.fprc.save  -text "Save"  -background cyan  -command [list SaveTree $AId]
    button $w.fb.fprc.reset  -text "Reset"  -background white  -command [list ResetArbre $AId $wc]
    button $w.fb.fprc.close  -text "Close"  -background red  -command "DetruitArbre $AId"

    grid $w.fb.fprc.print -row 0 -column 0
    grid $w.fb.fprc.save  -row 1 -column 0
    grid $w.fb.fprc.reset -row 0 -column 1 -pady {1 5}
    grid $w.fb.fprc.close -row 1 -column 1 -pady {1 5}
    grid rowconfig    $w.fb.fprc all -weight 0
    grid columnconfig $w.fb.fprc all -weight 0

    #
    # Packing
    #
    grid $w.fb.fsrp -row 0 -column 0 -padx 5 -sticky news
    grid $w.fb.fa   -row 0 -column 1 -padx 5 -sticky news
    grid $w.fb.ft   -row 0 -column 2 -padx 5 -sticky news
    grid $w.fb.ff   -row 0 -column 3 -padx 5 -sticky news
    grid $w.fb.fprc -row 0 -column 4 -padx 5 -sticky ne -pady {1 5}
    grid columnconfig $w.fb 4   -weight 1
    grid rowconfig    $w.fb all -weight 1


    $w.fb.ff.fsz set [set Abr($AId,FontSize)]
    $w.fb.ff.fwh set [set Abr($AId,FontWght)]

    # bindings, trace , etc ...
    InitContextMenu
    CreateContextMenu $AId [set Abr($AId,ContextMenu)]
    bind $wc  [list ShowContextMenu $AId [set Abr($AId,ContextMenu)]]

    bind $wc  {%W scan mark %x %y}
    bind $wc  {%W scan dragto %x %y 1}

    bind $wc <4> {eval %W yview scroll -1 units}
    bind $wc <5> {eval %W yview scroll  1 units}
    bind $wc  {eval %W xview scroll -1 units}
    bind $wc  {eval %W xview scroll  1 units}

    trace add variable Abr($AId,TypeTree) write ChangeConfigFenetre
    trace add variable Abr($AId,DoTagNode) write ModeTagNode
    trace add variable Abr($AId,DoTagLeaf) write ModeTagLeaf

    DefineLegend $AId clear
    ChangeCurseur $AId normal
    MesCouleurs $w
    FenetreAuCentre $w

    OnReDessineArbre $AId

    return

}

proc AfficheUneSequence {{NomDuFichier ""} {AvecManiere ""}} {

    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == ""} {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }
    return [AfficheFichier $NomDuFichier "AvecFormate$AvecManiere"]

}

proc AfficheUneSortieBlast {{NomDuFichier ""} {AvecManiere ""}} {

    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == ""} {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }

    if { ! [regexp "/" $NomDuFichier] && [EstUnPAB $NomDuFichier]} {
	set Nom $NomDuFichier
	set NomDuFichier "[RepertoireDuGenome]/blastp/$Nom"
    }

    return [AfficheFichier $NomDuFichier "AvecGrapheAvecSegAlignementAvecAligneurs$AvecManiere"]

}

proc AfficheUsageDesCodons {{Nom ""}} {

    if {$Nom==""} { set Nom [Entre [PreFixe]] }

    set UC [UsageDesCodons $Nom]
    set YaEuEntete 0
    set YaEuPourCent 0
    set LesA {}
    set LesCodons {}
    foreach Ligne [split $UC "\n"] {
	regsub -all {[ \t]+} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	set LesMots [LesMotsDuTexte $Ligne]
	if {[regexp -nocase {[A-Z]} $Ligne]} {
	    set LesADeLaLigne {}
	    set LesCodonsDeLaLigne {}
	    foreach {A Codon} $LesMots {
		lappend LesA $A
		lappend LesCodons $Codon
		lappend LesADeLaLigne $A
		lappend LesCodonsDeLaLigne $Codon
	    }
	    set YaEuEntete 1
	    continue
	}
	if {$YaEuEntete} {
	    set YaEuEntete 0
	    foreach A $LesADeLaLigne Codon $LesCodonsDeLaLigne P $LesMots {
		set Gde($A)     $P
		set Gde($Codon) $P
		lappend LesG  $P
		lappend LesADeG($P) $A
		lappend LesCodonDdeG($P) $Codon
	    }
	    set YaEuPourCent 1
	    continue
	}
	if {$YaEuPourCent} {
	    set YaEuPourCent 0
	    foreach A $LesADeLaLigne Codon $LesCodonsDeLaLigne P $LesMots {
		set Lde($A)     $P
		set Lde($Codon) $P
		lappend LesL  $P
		lappend LesADeL($P) $A
		lappend LesCodonDdeL($P) $Codon
	    }
	    continue
	}
    }
    set LesG [lsort -integer -unique -decreasing $LesG]
    set LesL [lsort -integer -unique -decreasing $LesL]

    foreach Codon [list AAC AAT ACC ATC ATT CAG CTC CTG GAA GAC GAG GAT GCC GGC GGT GTA GTC GTT TAC TTC] {
	set X($Codon) 1
    }

    set CodonsG ""
    set PourCentG ""
    foreach G $LesG {
	foreach Codon $LesCodonDdeG($G) {
	    if {[info exists X($Codon)]} {
		append CircuG   [format " %s %s" [AAduCodon $Codon] $Codon]
	    } else {
		append CircuG   [format " %s %s" " " "   "]
	    }
	    set PourCent $G
	    append CodonsG   [format " %s %s" [AAduCodon $Codon] $Codon]
	    append PourCentG [format " %5d" $PourCent]
	}
    }

    set Codons ""
    set PourCent ""
    foreach L $LesL {
	foreach Codon $LesCodonDdeL($L) {
	    if {[info exists X($Codon)]} {
		append CircuL   [format " %s %s" [AAduCodon $Codon] $Codon]
	    } else {
		append CircuL   [format " %s %s" " " "   "]
	    }
	    set PourCent $L
	    append CodonsL   [format " %s %s" [AAduCodon $Codon] $Codon]
	    append PourCentL [format " %5d" $PourCent]
	}
    }

    
    set Message $UC
    append Message "\n"
    append Message "\n"
    append Message $CircuG
    append Message "\n"
    append Message $CodonsG
    append Message "\n"
    append Message $PourCentG
    append Message "\n"
    append Message "\n"
    append Message $CircuL
    append Message "\n"
    append Message $CodonsL
    append Message "\n"
    append Message $PourCentL

    set Circu ""
    append Message "\n"
    append Message $Circu

    return [Affiche $Message "" "CodonUsageOf_$Nom"]

}

proc AfficheVariable {Page {Maniere ""} {NomDuFichierOrigine ""}} {

    Wup "Cette proc est le coeur de Gscope"
    Wup "Most used procedure ... : "
    Wup "Shows the text Page in a listbox, with a lot of buttons."
    Wup "Copyright 1999 Raymond Ripp"
    
    Gs "Frame"
    
    if {$Page==""} { return "" }
    
    global VariableDeRetour
    global LesFenetresDePAB
    global PagePropre
    global CurrentGenome
    
    
    regsub -all {[;\[\]]} $NomDuFichierOrigine " " NomDuFichierOrigine ; #rR pour éviter les mauvaises surprises car il rique d'être interprété
	
	
    set Nom ""
    set Queue [file tail $NomDuFichierOrigine]
    
    set w [NomDe fenetre]
    
    set PagePropre($w) $Page
    regsub -all {\t} $PagePropre($w) "       " PagePropre($w)
    if {[info procs EstPABouTROUouTRNAouARN]!=""} {
	set NomPossible [file tail $NomDuFichierOrigine]
	if {$Nom==""} {
	    set NomPossible [file tail $NomDuFichierOrigine]
	    if { [EstPABouTROUouTRNAouARN $NomPossible] } { set Nom $NomPossible }
	}
	if {$Nom==""} {
	    set NomPossible [lindex [split $NomDuFichierOrigine "_"] 0]
	    if { [EstPABouTROUouTRNAouARN $NomPossible] } { set Nom $NomPossible }
	}
	if {$Nom==""} {
	    set NomPossible [lindex [split $NomDuFichierOrigine "_"] end]
	    if { [EstPABouTROUouTRNAouARN $NomPossible] } { set Nom $NomPossible }
	}
    }
    
    #    if {[PourWscope]} { return [Html_DuTexteTelQuel [set PagePropre($w)]] } 
    
    lappend LesFenetresDePAB($Queue) $w
    
    regsub -all " " $NomDuFichierOrigine "_" NomDuFichierOrigine
    
    if { $NomDuFichierOrigine == "" } {
	set NomDuFichierOrigine "Tsointsoin"
    }
    if {$Maniere=="AutoManiere" || $Maniere==""} {
	set Maniere [LaManierePourAffiche $NomDuFichierOrigine]
    }
    if {$Nom!="" && [info procs NomDeScene]!="" && [NomDeScene $Nom]!=""} {
	set Titre "[NomDeScene $Nom]   $NomDuFichierOrigine"
    } else {
	set Titre "$NomDuFichierOrigine"
    }
    set Header ""
    #    if { ! [OnTraite "RetGene"]&& [PourWscope]} { return [Html_TextToListbox  [set PagePropre($w)] $Titre $Header "" "ResetAndWaqqqitForButtons"] } 
    
    set Clavier $w.buttons
    if { ! [PourWscope]} {
	toplevel $w
	wm title $w "$Titre"
	wm iconname $w "$Titre"
	
	label $w.msg -wraplength 4i -justify left -text "$Titre"
	pack  $w.msg -side top
	
	frame  $Clavier
	pack   $Clavier -side bottom -fill x -padx 3m -pady 1m
    }
    
    set ForValidateOnly 0
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "red"
    if { [regexp "AvecRetour" $Maniere] } {
	if {[regexp "AvecRetourPourInforme" $Maniere]} {
	    TouchePour $Clavier "Validate" "InformeSansDemanderParWscope $Nom \[selection get\]" "" "green"
	} else {
	    TouchePour $Clavier "Validate sel." "set VariableDeRetour($w) \[selection get\]"      "" "green"
	    TouchePour <2>      " /All"         "set VariableDeRetour($w) \[set PagePropre($w)\]" ""
	    TouchePour <3>      " / No!"        "set VariableDeRetour($w) {}"
	}
	if {[PourWscope]} { set ForValidateOnly 1 }
	TouchePour $Clavier NouvelleCouleur "pink"
    }
    TouchePour $Clavier "Dismiss"     "Dismiss $w" 
    TouchePour $Clavier "Dismiss_all" "DismissToutCePAB $Queue" "NoWeb"
    
    TouchePour $Clavier NouvelleCouleur "grey"
    TouchePour $Clavier "Display sel." "SendToWeb \[selection get\]"      "WebOnly"
    TouchePour <2>      "/Select all"   "onclick='return selectAll();'"   "WebOnly"
    TouchePour $Clavier "Save all"   "SaveAs      \[set PagePropre($w)\]" "NoWeb"
    TouchePour <2>      "/sel."      "SaveAs      \[selection get\]"      "NoWeb"
    TouchePour <3>      " /Edit"     "EditAndShow \[set PagePropre($w)\]" "NoWeb"
    TouchePour $Clavier "Memorize sel." "MemoSelection $w Memorize"       "NoWeb" "lightyellow"
    TouchePour <2>      "/Recall"       "MemoSelection $w Recall"         "NoWeb"
    TouchePour $Clavier NouvelleCouleur "grey"
    TouchePour $Clavier "Print"         "ImprimeLeTexte \[set PagePropre($w)\]"
    TouchePour <2>      "/Sort"         "TrieEtAffiche \[set PagePropre($w)\] Alpha $Maniere $NomDuFichierOrigine"
    TouchePour <3>      "/ask"          "TrieEtAffiche \[set PagePropre($w)\] Ask   $Maniere $NomDuFichierOrigine"
    TouchePour $Clavier "Copy"          "clipboard clear ; clipboard append \[selection get\]" "NoWeb"
    TouchePour <2>      "/Append"       "clipboard append \[selection get\]"                   "NoWeb"
    TouchePour <3>      " /Font"        "PolicePourListBox Ask $w"                             "NoWeb"
    TouchePour $Clavier "Exec"          "ExecuteUnBoutonDe $w"                                 "NoWeb"
    TouchePour <2>      "/Small"        "RapetisseLesBoutonsDe $w"                             "NoWeb"
    TouchePour <3>      "/Kill"         "DetruitUnBoutonDe $w"                                 "NoWeb"

    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "grey"
    
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "yellow"
    TouchePour $Clavier "Next"  "Focalise $w"     "NoWeb"
    TouchePour <2>      "/Top"  "Focalise $w top" "NoWeb" 
    TouchePour <3>      "/New"  "Focalise $w ask" "NoWeb"
    TouchePour $Clavier "Highlight [PreFixe]" "Illumine $Nom $w"                        "NoWeb"
    TouchePour <2>      "/Query"              "Illumine QUERY $w"                       "NoWeb"
    TouchePour $Clavier "High word"           "Illumine \[Entre\] $w"                   "NoWeb"
    TouchePour <2>      "/group"              "IllumineLeGroupeDe $Nom $w"              "NoWeb"
    TouchePour <3>      "/?"                  "IllumineLeGroupeDe $Nom $w Ask $Maniere" "NoWeb"
    TouchePour $Clavier "Sel. In"   "AfficheRognure \[set PagePropre($w)\] \[selection get\] $Maniere $NomDuFichierOrigine In"  
    TouchePour <2>      "/Out"      "AfficheRognure \[set PagePropre($w)\] \[selection get\] $Maniere $NomDuFichierOrigine Out"  
    TouchePour <3>      "/Alone"    "AfficheRognure \[set PagePropre($w)\] \[selection get\] $Maniere $NomDuFichierOrigine Alone"  
    
    if { $Nom!="" } {
	TouchePour $Clavier "Informe $Nom" "Informe $Nom"
	TouchePour $Clavier "Narcisse"   "FaireLire \[Narcisse $Nom\]"
	TouchePour <2>      "/fetch it"  "AfficheFetch \[Narcisse $Nom\]"
	TouchePour $Clavier "Ghost it "  "Fantomise $Nom ParDecret"
	TouchePour <2>      "/ask"       "Fantomise $Nom Ask"
	TouchePour $Clavier "Met it "    "MetIt $Nom ParDecret"
	TouchePour <2>      "/ask"       "MetIt $Nom Ask"
	TouchePour $Clavier "Reject it " "RejectIt $Nom ParDecret"
	TouchePour <2>      "/ask"       "RejectIt $Nom Ask"
	TouchePour <3>      "/NoRej"     "RejectIt $Nom {NoRejected ParDecret}"
    }
    TouchePour $Clavier "Search on board ..."   "SearchOnBoard \[selection get\]"
    if {$Nom==""} { set NomX x } else { set NomX $Nom } 
    TouchePour $Clavier "NewButton" "NouveauBouton $w New  $NomX $NomDuFichierOrigine" "NoWeb"
    TouchePour <2>      "/same"     "NouveauBouton $w Same $NomX $NomDuFichierOrigine" "NoWeb"
    TouchePour <3>      "/auto"     "NouveauBouton $w Auto $NomX $NomDuFichierOrigine" "NoWeb"
    
    if {$ForValidateOnly} { TouchePour $Clavier "RefuseAll" }
    
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "lightgrey"
    TouchePour $Clavier "Description"       "AfficheLesDescriptifs $NomDuFichierOrigine   MemeOrdre"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $NomDuFichierOrigine   Natif"
    TouchePour <3>      "/page"             "AfficheLesDescriptifs \[set PagePropre($w)\] MemeOrdre {} {} {} $Nom"
    TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy $NomDuFichierOrigine"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $NomDuFichierOrigine   Natif     {} {} {OX OC} $Nom"
    TouchePour <3>      "/page"             "AfficheLesDescriptifs \[set PagePropre($w)\] MemeOrdre {} {} {OX OC} $Nom"
    TouchePour $Clavier "FragFrom"          "FragFrom $Nom"	  
    TouchePour $Clavier "SeeDNA"            "SeeADN $NomDuFichierOrigine"
    TouchePour <2>      "/6PAB"             "VoisinADN $Nom"
    TouchePour <3>      "/6txt"             "VoisinADN \[set PagePropre($w)\]"
    TouchePour $Clavier "Compare to other"  "CompareADN \[set PagePropre($w)\]"
    TouchePour $Clavier "Frag"              "IsoleUnDomaine $Nom"	  
    TouchePour <2>      "/from page"        "IsoleUnDomaine \[set PagePropre($w)\]"	  
    TouchePour <3>      "/nuc"              "IsoleEtAfficheUnDomaineNucleique \[set PagePropre($w)\]"	  
    TouchePour $Clavier "PeptidSort"        "AffichePeptideSort $Nom \[set PagePropre($w)\]"	  
    TouchePour <2>      "/Enzym"            "AffichePeptideSort $Nom \[set PagePropre($w)\] ShowEnzymes"	  
    TouchePour $Clavier "Res Enzym"         "CheckRestrictionEnzymes for_$Nom All \[set PagePropre($w)\]"
    TouchePour <2>      "/Sign"             "CheckRestrictionEnzymes for_$Nom Signals \[set PagePropre($w)\]"
    TouchePour <3>      "/Ask"              "CheckRestrictionEnzymes for_$Nom \[Entre NdeI\] \[set PagePropre($w)\]"
    TouchePour $Clavier "Res Map $Nom"      "RestrictionMap $Nom"	  
    TouchePour <3>      "/Page"             "RestrictionMap \[set PagePropre($w)\]"	  
    TouchePour $Clavier "Codon usage"       "AfficheUsageDesCodons $Nom"
    TouchePour <2>      "/Rare"             "AfficheSlidingCodonRare \[set PagePropre($w)\]"
    TouchePour <3>      "/CPS"              "Cps \[selection get\] {} {} Show"
    TouchePour $Clavier "Hydrophobicities"  "AfficheVariable \[Hydrophobicities $NomDuFichierOrigine\] AutoManiere"
    TouchePour $Clavier "OrthoFamily"       "AfficheLesOrthologuesFamiliersDuBlastP $Nom"
    TouchePour $Clavier "Cluster X-HDA"     "AfficheLeClusterXHda $Nom"
    TouchePour <2>      "/MSF"              "AfficheMsfFamily $Nom"
    
    TouchePour $Clavier NouvelleGamme
    if { $Nom!="" && ! [regexp "SansSeeAby" $Maniere]} {
	TouchePour $Clavier NouvelleCouleur "lightgreen"
	set Nicolas "Nicolas"
	set Moumou  "Ordali"
	if {[OnTraiteUnGenome]}      { set SecondMSF "Para" }
	if {[OnTraiteUneCollection]} { set SecondMSF "MSF2" }
	if {[OnTraiteDesCDNAs]}      { set SecondMSF "Loc" ; set Moumou "allBN" ; set Nicolas "allBP"}
	if {[PreFixe]=="PEROX"}      { set SecondMSF "Loc" ; set Moumou "allBN" ; set Nicolas "allBP"}
	if {[OnTraiteBalibase]} {
	    TouchePour $Clavier "Macsim Rsf" "DessineMoiUnRSF     $Nom" "" "cyan"
	    TouchePour <2>      "/Xml"       "SeeAby MacsimXml $Nom"	    
	    TouchePour <3>      "/Html"      "HtmlFromXmlMacsim $Nom {} ShowHtml"	    
	}
	TouchePour $Clavier "Seq"          "SeeAby Seq         $NomDuFichierOrigine"
	TouchePour <2>      " /nuc"        "SeeAby Nuc         $NomDuFichierOrigine"
	TouchePour <3>      " /Show"       "SeeAby Show        $NomDuFichierOrigine"
	TouchePour $Clavier "Any"          "SeeAby MemoAny     $NomDuFichierOrigine"
	TouchePour <2>      "/choose"      "SeeAby ChooseAny   $NomDuFichierOrigine"
	TouchePour <3>      "/all"         "SeeAby AllAny      $NomDuFichierOrigine"
	TouchePour $Clavier "Blast"        "SeeAby MemoBlast   $NomDuFichierOrigine"
	TouchePour <2>      "/choose"      "SeeAby ChooseBlast $NomDuFichierOrigine"
	TouchePour <3>      "/all"         "SeeAby AllBlast    $NomDuFichierOrigine"
	TouchePour $Clavier "Msf"          "SeeAby MemoMsf     $NomDuFichierOrigine"
	TouchePour <2>      "/choose"      "SeeAby ChooseMsf   $NomDuFichierOrigine"
	TouchePour <3>      "/all"         "SeeAby AllMsf      $NomDuFichierOrigine"
	TouchePour $Clavier "ChangeDefaultDirs" "ReParDefaut"
	TouchePour $Clavier "Ordali"       "Ordali $Nom"
	if {[file exists "[RepertoireDuGenome]/taxobla"]} {
	    TouchePour <2>      " /Taxo"       "TaxonomyDuBlast $Nom"
	    TouchePour <3>      "/Outliers"    "OutlierOrganismInBlast $Nom"
	}	
	if {[PourWscope]} {
	    TouchePour $Clavier  "Jalview" "JalviewHtml $Nom"
	}
	if {[file exists "[RepertoireDuGenome]/blastxmultiples"]} {
	    TouchePour $Clavier "Frameshift BlastX" "AfficheLesBlastXDesHitsMultiples $Nom"
	    TouchePour <2>      "/Loc"              "FaireLire \[PossibleFrameshift $Nom\]"
	}
	if {[file exists "[RepertoireDuGenome]/fiches/Domaines"]} {
	    TouchePour $Clavier "Show Domains" "IllustreLesDomaines $Nom"
	}
	TouchePour $Clavier "Files"        "SeeAby Other       $NomDuFichierOrigine"
	TouchePour <2>      "/Other"       "SeeAby OnList      $NomDuFichierOrigine"
	TouchePour <3>      "/WithDir"     "ShowDirectories \[set PagePropre($w)\] $NomDuFichierOrigine"
	if {[OnTraiteSpine]} {
	    TouchePour $Clavier "Xml Spine"  "SeeAby SpineXml $NomDuFichierOrigine" "" "Purple"
	    TouchePour <2>      "/Macsim"    "SeeAby MacsimXml $NomDuFichierOrigine"	    
	    TouchePour <3>      "/Html"      "HtmlFromXmlMacsim $Nom {} ShowHtml"	    
	}
    }
    if { [regexp "AvecBlaste" $Maniere] || [regexp "AvecFormate" $Maniere] } {
	TouchePour $Clavier NouvelleCouleur "lightgreen"
	TouchePour $Clavier "Run BlastP"   "Blaste P  \[set PagePropre($w)\]"
	TouchePour <2>      "/tN"          "Blaste tN \[set PagePropre($w)\]"
	TouchePour <3>      "/Choose"      "Blaste Choix \[set PagePropre($w)\]"
	TouchePour $Clavier "GenScan"      "RunGenScanEtAffiche      \[set PagePropre($w)\]"
	TouchePour <2>      "/RepMasker"   "RunRepeatMaskerEtAffiche \[set PagePropre($w)\]"
	
	TouchePour $Clavier NouvelleCouleur "lightgreen"
	TouchePour $Clavier "Change format" "AfficheVariable \[FormateSequence \[set PagePropre($w)\]\] AvecFormateAvecBlasteSansFetch [file tail $NomDuFichierOrigine]"
	TouchePour <2> "/sel."              "AfficheVariable \[FormateSequence \[selection get\]\] AvecFormateAvecBlasteSansFetch part_of_[file tail $NomDuFichierOrigine]"
	TouchePour $Clavier "Medline all"   "AfficheTousLesMedlinesDeLaSequence \[set PagePropre($w)\]\]"
	TouchePour <2>      "/sel."  "AfficheMedline \[selection get\]"
    }
    if { [regexp "AvecAligneurs" $Maniere] } {
	TouchePour $Clavier "DbCl +Anchors"     "RunDbClustal \[selection get\] $NomDuFichierOrigine"
	TouchePour <2>      " / -"              "RunDbClustal \[selection get\]"
	TouchePour $Clavier "Tfas of selection" "CreeUnTFAs \[selection get\] ShowIt"
	TouchePour $Clavier "BlastBase sel"     "CreeUneBanqueBlast \[selection get\] [file tail $NomDuFichierOrigine]"
	TouchePour <2>      "/all"              "CreeUneBanqueBlastDuBlast $NomDuFichierOrigine"
	TouchePour <3>      "/+q"               "CreeUneBanqueBlastDuBlast $NomDuFichierOrigine AvecQuery"
    }
    if { [regexp "AvecShow" $Maniere] } {
	TouchePour $Clavier "Show"   "AfficheLesFichiers \[selection get\] AutoManiereAvecShow"
	TouchePour <2>      "/File"  "AfficheLesFichiers \[selection get\] AutoManiereAvecShow"
	TouchePour <3>      "/Split" "OffreLesMots       \[selection get\]"
    }
    
    if { [regexp "AvecEtudeMSF" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur  "lightblue"
	TouchePour $Clavier "Msfcolor"       "DessineMoiUnMSF \[set PagePropre($w)\] $NomDuFichierOrigine Ask" 
	TouchePour <2>      " /Xml"          "Ordali $Nom ForceXml"
	TouchePour <3>      " /RSF"          "DessineMoiUnRSF $NomDuFichierOrigine"
	TouchePour $Clavier "ClustalX"       "ClustalX \[set PagePropre($w)\] $NomDuFichierOrigine" 
	TouchePour <2>      " /NJPlot"       "NJPlotMSF \[set PagePropre($w)\] $NomDuFichierOrigine" 
	TouchePour <3>      " /ATV"          "ATV $NomDuFichierOrigine EnExec" 
	TouchePour $Clavier "NorMD"   "FaireLire \"memorized NorMD \[MDScore $NomDuFichierOrigine\]\"" 
	TouchePour <2>      "/Comput" "FaireLire \"just computed NorMD \[MDScore \[set PagePropre($w)\] IsText\]\"" 
	TouchePour <3>      "/2Word"  "MSF2WordML $NomDuFichierOrigine" 
	TouchePour $Clavier "StartStop" "TestCodonStartEtDeletionDuMSF $NomDuFichierOrigine"
	TouchePour <2>      " /Sort"         "AfficheReordonneMSF \[set PagePropre($w)\] Ask $NomDuFichierOrigine"
	TouchePour $Clavier "Ordali"       "Ordali $Nom [RepertoireDuGenome]/macsimXml/$Nom.xml {} {} ForceXml"
	TouchePour <2>      " /disp" "OrdaliDuTexteMSF \[set PagePropre($w)\] $NomDuFichierOrigine -viewer"
	TouchePour <3>      " /sel." "OrdaliDeLaSelection \[set PagePropre($w)\] \[selection get\] $NomDuFichierOrigine"
	TouchePour $Clavier "MSF familiar orgs" "AfficheMsfOfFamiliarOrganisms $NomDuFichierOrigine"	
	TouchePour $Clavier "MSF Reduce"        "AfficheReduceMsf              $NomDuFichierOrigine"	
	TouchePour <2>      "/Dist"             "AfficheSortedDistances        $NomDuFichierOrigine"	
	TouchePour <3>      "AliInOut"          "AfficheAliInOut $Nom"

	if {[PreFixe]=="TFIIH"} {
	    TouchePour $Clavier "Pid2a2" "Pid2a2 $Nom $NomDuFichierOrigine"
	}
    }
    if { [regexp "AvecGenoret" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "ForestGreen"
	TouchePour $Clavier "Show All Uploads" "ShowUploads"
	if {[regexp "AvecAllUploads" $Maniere]} { 
	    TouchePour $Clavier "Show sel. Upload" "ShowUpload \[selection get\]"
	}
	if {[regexp "AvecUpload" $Maniere]} { 
	    TouchePour $Clavier " SetGUs of sel."       "SetGUsWithUpload $NomDuFichierOrigine"
	}
	
	TouchePour $Clavier "ShowGUs" "ShowGUs"
	if {[regexp "AvecGUsList" $Maniere]} { 
	    TouchePour <2>      "/RemGUs"     "RemGUs \[selection get\]"
	}
    }
    if { [regexp "AvecXbgs" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "Magenta"
	TouchePour $Clavier "Spine"             "SpineSummary Show"
	TouchePour $Clavier "XML File"          "CreateSpineXML"
	TouchePour <2>      "/Show"             "CreateSpineXML Show"
	TouchePour <3>      "/sel"              "CreateSpineXML \[selection get\] Show"
	TouchePour $Clavier "Search Organisms"  "OrganismeDesXGSs"
	TouchePour $Clavier "Show SpineOnly"    "AfficheLesSpines \[set PagePropre($w)\]"
	TouchePour <2>      " /No"              "AfficheLesSpines \[set PagePropre($w)\] KO"
	TouchePour $Clavier "Change Owner"      "MemeOwner \[selection get\]"
	TouchePour <2>      "/XGS"              "XGSPourOwner \[selection get\]"
	TouchePour $Clavier "Def"               "AfficheSpineDefinitions"
	TouchePour <2>      " /Stat"            "HistoDesSpineTasks AllToGether Show"
	TouchePour <3>      " /SpOk"            "HistoDesSpineTasks SpineOnly Show"
    }
    
    if { [regexp "AvecLog" $Maniere] } {
	TouchePour $Clavier "Log" "AfficheLogDuMSF $NomDuFichierOrigine"
    }
    
    if { [regexp "AvecAide" $Maniere] } {
	TouchePourClavier $Clavier "?" "AideEnLigne \[selection get\]" "" "blue"
    }
    
    if { [regexp "AvecSmallMSF" $Maniere] } {
	TouchePour $Clavier "Small align" "ShowDifferentielBlastAlignement \[selection get\]" "" "green"
    }
    
    if { [regexp "AvecProfileSegments" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "green"
	TouchePour $Clavier "ProfilSeg align"  "AfficheProfileSegment \[selection get\] $Maniere $NomDuFichierOrigine"
    }
    if { [regexp "AvecSegAlignement" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightblue"
	TouchePour $Clavier "Blast segment align"  "AfficheLesAliEnPage \[set PagePropre($w)\] \[selection get\] $NomDuFichierOrigine"
	TouchePour $Clavier "Mosaic"         "IllustreLeBlast $NomDuFichierOrigine"
	TouchePour <2>      "/Map"           "AfficheMapping $NomDuFichierOrigine \[selection get\]"
	TouchePour <3>      "/DrawBlast"     "DrawBlast $NomDuFichierOrigine"
	TouchePour $Clavier "Localise 0.001" "AfficheChaqueSegmentDuBlastN $Nom $NomDuFichierOrigine"
	TouchePour <2>      "/sel."          "AfficheChaqueSegmentDuBlastN $Nom $NomDuFichierOrigine \[selection get\]" 
	TouchePour $Clavier "Chromos"        "IllustreLesChromosomes"
	TouchePour <2>      "/Histo"         "ChoixHistogramme"
	
	TouchePour $Clavier "HitsPN"    "LesBandelettesDuBlast $NomDuFichierOrigine {} {} OnGraphe"
	TouchePour <2>      "/SeqSizes" "TailleDesSequencesAAligner $Nom"
	TouchePour <3>      "/ All"     "LesEntetesChevronneesDuBlast \[set PagePropre($w)\] Show $NomDuFichierOrigine"
	TouchePour $Clavier "Bandes"     "LesElusDuBlastPParBandelettes $NomDuFichierOrigine {} Show"
	TouchePour <2>      "/Mounir"    "LesElusDuBlastPParMounir $NomDuFichierOrigine {} Show"
	TouchePour <3>      "/AuChoix"   "LesElusDuBlastPParAuChoix $NomDuFichierOrigine {} Show"
	
	TouchePour $Clavier "Ballast" "AfficheBallastDuBlastP $NomDuFichierOrigine $Nom"
	TouchePour $Clavier "Rsf"     "AfficheLesSortiesDuBallast $NomDuFichierOrigine rsf"
	TouchePour <2>      "/lmsp"   "AfficheLesSortiesDuBallast $NomDuFichierOrigine lmsp"
	TouchePour <3>      "/pssm"   "AfficheLesSortiesDuBallast $NomDuFichierOrigine pssm"
	TouchePour $Clavier "TopSeq"  "AfficheLesSortiesDuBallast $NomDuFichierOrigine topseq"
	TouchePour <2>      "/Tabl"   "AfficheLesSortiesDuBallast $NomDuFichierOrigine table"
	TouchePour <3>      "/Anch"   "AfficheLesSortiesDuBallast $NomDuFichierOrigine anchors"
	if {[regexp -nocase "psiblast" $NomDuFichierOrigine]} {
	    TouchePour $Clavier "SplitPsiBlast" "ShowLesBlastsDuPsiBlast $NomDuFichierOrigine" "lightgreen"
	    TouchePour <2>      "/first"        "ShowLesBlastsDuPsiBlast $NomDuFichierOrigine 1"
	    TouchePour <3>      "/last"         "ShowLesBlastsDuPsiBlast $NomDuFichierOrigine end"
	}
	regsub {\.blast[pn]?$} $NomDuFichierOrigine "" NomDuFasta
	append NomDuFasta ".fasta"
	if {[file exists $NomDuFasta]} {
	    TouchePour $Clavier "Show fasta"  "AfficheVariable \[ContenuDuFichier $NomDuFasta\]" "blue"
	}
    }
    
    if { [regexp "AvecOpCom" $Maniere] } {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur  "pink"
	TouchePour $Clavier "Operon ORFs" "ORFsDesOperonsCommuns \[selection get\] ORFsOfOperon"
    }
    
    if { ! [regexp "SansFetch" $Maniere]} {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "orange"
	set FichierAussi ""
	if {[OnTraiteUneCollection]} { set FichierAussi "$NomDuFichierOrigine" }
	if {[OnTraiteDesCDNAs]}      { set FichierAussi "OnVeutNucEMBL" } 
	
	TouchePour $Clavier "Fetch"          "AfficheFetch  \[selection get\] $FichierAussi"
	TouchePour <2>      " /nature"       "AfficheFetch  \[selection get\] OnVeutNature"
	TouchePour <3>      "/seq"           "AfficheFetch  \[selection get\] $NomDuFichierOrigine"
	TouchePour $Clavier "Split in words"     "OffreLesMots  \[selection get\]"
	TouchePour $Clavier "Contig"             "AfficheContigComplet \[selection get\]"
	TouchePour <2>      "/GenScan"           "AfficheGenscanDuContig \[selection get\]"
	TouchePour $Clavier "Kegg"               "IllustreLesPathwayDeLaBoite $Nom"
	TouchePour <2>      "/Dev"               "IllustreDevStage \[list $Nom\] 3 [Fiches]/SelectedEST" 
	TouchePour <3>      "/Tissue"            "IllustreTissueType \[list $Nom\] {} 3 \[Fiches\]/SelectedEST" 
	TouchePour $Clavier "Gene Identity Card" "GeneIdentityCard $Nom"
	TouchePour $Clavier "Show GOs"           "ShowGOs $Nom"
	TouchePour $Clavier NouvelleCouleur "cyan"
	if {[regexp "Tparva" [RepertoireDuGenome]]} {
	    TouchePour $Clavier "BlastP Sc" "ShowBlastFromSelection \[selection get\] blastpScReciproc"
	    TouchePour <2>        "/Yeast"  "YEAHshowYeast \[selection get\]"
	    TouchePour <3>        " /Info"  "Reciproc $Nom ShowInfo"
	    TouchePour $Clavier "BlastP Eh" "ShowBlastFromSelection \[selection get\] blastpEhistolica"
	    TouchePour <2>           "/ Pf" "ShowBlastFromSelection \[selection get\] blastpPfalciparumReciproc"
	    TouchePour <3>           "/ Tb" "ShowBlastFromSelection \[selection get\] blastpTbruceiReciproc"
	}
	
    }
    if { [regexp "AvecRecap" $Maniere]} {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "ForestGreen"
	TouchePour $Clavier "Blast"          "SeeAby MemoBlast   \[selection get\]"
	TouchePour <2>      "/choose"        "SeeAby ChooseBlast \[selection get\]"
	TouchePour <3>      "/all"           "SeeAby AllBlast    \[selection get\]"
	TouchePour $Clavier "BlastP"         "SeeAby blastp            \[selection get\]"
	TouchePour <2>      "/RefseqP"       "SeeAby blastprefseq-prot \[selection get\]"
	TouchePour $Clavier "Blastn wgs"     "SeeAby blastnwgs         \[selection get\]"
	TouchePour $Clavier "TBlastN wgs"    "SeeAby tblastnwgs        \[selection get\]"
	TouchePour <2>      "/Genomes"       "SeeAby tblastncompletegenomes \[selection get\]"
    }
    if {[OnTraiteDesClones]} {
	TouchePour $Clavier "My Oligos"  "IllustreLesPrimers $Nom" "" "Magenta"
	TouchePour <2>      "/vPPCR" "ShowLesVirtualPPCRsDuPGS $Nom"
	TouchePour <3>      "/VEs"   "ShowLesVEDidierDuPGS $Nom"
	if {1} {
	    TouchePour $Clavier "vPpcr "        "ShowVirtualPPCR \[selection get\]" "" "Magenta"
	    TouchePour <2>      "/choose"       "ShowVirtualPPCR \[selection get\] Choose"
	    TouchePour <3>      "/all"          "ShowVirtualPPCR \[selection get\] All"
	    TouchePour $Clavier "Rec1 of vPPCR" "ShowLesRec1DuVirtualPPCR \[selection get \]" "" "Magenta"
	    TouchePour $Clavier "Rec1 or 2 or fusion "  "ShowCorrespondingFile   \[selection get\]" "" "Magenta"
	    TouchePour $Clavier "ShowVEDidier"  "VEDidier \[selection get\] Show" "" "Magenta"	    
	}
    }
    if { ! [regexp "SansFetch" $Maniere] &&  [OnTraiteUneCollection] && ! [OnTraiteDesCDNAs] &&  [file tail $NomDuFichierOrigine]!=$Nom} {
	TouchePour $Clavier "Co-Fetch"    "AfficheAssocie $NomDuFichierOrigine copains"
	TouchePour <2>      "/BlastP"     "AfficheAssocie $NomDuFichierOrigine coblastp"
	TouchePour <3>      "/MSF"        "AfficheAssocie $NomDuFichierOrigine coclustalw"
	TouchePour $Clavier "Co-Info"     "AfficheAssocie $NomDuFichierOrigine coinfos"
	TouchePour <2>      "/tBlastN"    "AfficheAssocie $NomDuFichierOrigine cotblastn"
	TouchePour $Clavier "Co-modify"   "InformeLeCopain $NomDuFichierOrigine"
	TouchePour $Clavier "Co-rsf"      "AfficheLesSortiesDuBallast $NomDuFichierOrigine rsf"
	TouchePour <2>      "/lmsp"       "AfficheLesSortiesDuBallast $NomDuFichierOrigine lmsp"
	TouchePour <3>      "/pssm"       "AfficheLesSortiesDuBallast $NomDuFichierOrigine pssm"
    }
    
    if {[OnTraite "MSP"]} {
	TouchePour $Clavier NouvelleCouleur "magenta"
	TouchePour $Clavier "SeqCalage"  "SeqCalage $Nom"
    }
    if {[OnTraite "CilioCode"]} {
	TouchePour $Clavier NouvelleCouleur "magenta"
	TouchePour $Clavier "Cilio ForCilio"  "CilioBlastSummary     $Nom Show  blastpForCilio"
	TouchePour <2>      "/Expect"         "OrganismsInCilioBlast $Nom Graph blastpForCilio"
	TouchePour $Clavier "Cilio Protall"   "CilioBlastSummary     $Nom Show  blastpProtall"
	TouchePour <2>      "/Expect"         "OrganismsInCilioBlast $Nom Graph blastpProtall"
	TouchePour $Clavier "Cilio Ortholog"  "CilioBlastSummary     $Nom Show  blastpBanqueOrthologs"
	TouchePour <2>      "/Expect"         "OrganismsInCilioBlast $Nom Graph blastpBanqueOrthologs"
    }
    if {[OnTraiteDesClones]} {
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "magenta"
	if {[regexp "AvecOli" $Maniere]} {
	    TouchePour $Clavier "Oligo "  "ShowOli \[selection get\]"
	    TouchePour <2>      "/choose" "ShowOli \[selection get\] Choose"
	    TouchePour <3>      "/all"    "ShowOli \[selection get\] All"
	    TouchePour $Clavier "ShowBlastN"  "ShowBlastOfOligo \[selection get\]"
	    TouchePour <2>      "/Order"      "AfficheFournisseur \[selection get\]"
	}
	if {[regexp "AvecShowItsOligos" $Maniere]} {
	    set NA ""
	    if {[regexp "AvecShowItsOligos_NA" $Maniere]} { set NA "_NA" }
	    TouchePour $Clavier "Show its oligos" "ShowItsOligos \[selection get\] $NA"
	}
	if {[regexp "AvecFiOl" $Maniere]} {
	    TouchePour $Clavier "ShowOligosFiles" "ShowOligosFiles \[selection get\]"
	}
	if {[regexp "AvecVirtualPPCR" $Maniere]} {
	    TouchePour $Clavier "vPpcr "        "ShowVirtualPPCR \[selection get\]"
	    TouchePour <2>      "/choose"       "ShowVirtualPPCR \[selection get\] Choose"
	    TouchePour <3>      "/all"          "ShowVirtualPPCR \[selection get\] All"
	    TouchePour $Clavier "Rec1 of vPPCR" "ShowLesRec1DuVirtualPPCR \[selection get \]"
	}
	if {[regexp "AvecShowItsPPCR" $Maniere]} {
	    set NA ""
	    if {[regexp "AvecShowItsPPCR_NA" $Maniere]} { set NA "_NA" }
	    TouchePour $Clavier "Show its PPCR" "ShowItsPPCR \[selection get\] $NA"
	}
	if {[regexp "AvecTriFragments" $Maniere]} {
	    TouchePour $Clavier "SortFragments all" "TriFragments \[set PagePropre($w)\] Ask"
	    TouchePour <2>      "/sel."             "TriFragments \[selection get\] Ask"
	}
    }
    if {[regexp "AvecTaxNCBI" $Maniere]} { 
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightgreen"
	TouchePour $Clavier "BrowseTaxNCBI" "BrowseTaxNCBI"
	TouchePour $Clavier "Sel. Parent"   "BrowseTaxNCBI \[selection get\] Parent"
	TouchePour <2>      "/Children"     "BrowseTaxNCBI \[selection get\] Children"
	TouchePour <3>      "/?"            "BrowseTaxNCBI \[selection get\]"
	TouchePour $Clavier "All Parent"    "BrowseTaxNCBI \[set PagePropre($w)\] Parent"
	TouchePour <2>      "/Children"     "BrowseTaxNCBI \[set PagePropre($w)\] Children"
	TouchePour <3>      "/?"            "BrowseTaxNCBI \[set PagePropre($w)\]"
    }
    if {$ForValidateOnly} { TouchePour $Clavier "ReAcceptAll" }
    

    #rR 2016/02/02 On a peut-être Postponé des TouchePour ;)
    set LesPostpone [TouchePour "GetPostponeAndReset"]
    set Cla $w.buttons
    foreach Action $LesPostpone {
	regsub -all "@F@" $Action $w Action
	if {[regexp "<" [lindex $Action 0]]} {
	    TouchePour {*}$Action
	} else {
	    TouchePour $Cla {*}$Action
	}
    }
    
    set Largeur 80
    set Hauteur 35
    if { [regexp "GrandeLargeur" $Maniere] } { set Largeur 128 }
    if { [regexp {SetWidth([0-9]+)}  $Maniere Match Width] }  { set Largeur $Width }
    if { [regexp {SetHeight([0-9]+)} $Maniere Match Height] } { set Hauteur $Height }
    if { ! [PourWscope]} {
	frame $w.frame -borderwidth 10
	pack  $w.frame -side top -expand yes -fill both
	
	
	scrollbar $w.frame.yscroll -command "$w.frame.list yview"
	scrollbar $w.frame.xscroll -command "$w.frame.list xview"  -orient horizontal
	listbox $w.frame.list -width $Largeur -height $Hauteur -setgrid 1  -yscroll "$w.frame.yscroll set"  -xscroll "$w.frame.xscroll set"  -selectmode extended  -background "LightGrey"  -foreground "Black"  -selectbackground "LightYellow"  -selectforeground "Black"  -font [list Courier [PolicePourListBox]]

	bind $w.frame.list "<4>"         "%W yview scroll  1 units"
	bind $w.frame.list "<5>"         "%W yview scroll -1 units"
	bind $w.frame.list "" "%W xview scroll  1 units"
	bind $w.frame.list "" "%W xview scroll -1 units"
	
	grid $w.frame.list    -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid rowconfig    $w.frame 0 -weight 1 -minsize 0
	grid columnconfig $w.frame 0 -weight 1 -minsize 0
	
	set nLignes 0
	foreach Ligne [split [set PagePropre($w)] "\n"] {
	    incr nLignes
	    if { [regexp "AvecSegAlignement" $Maniere] && [regexp {^>[\./a-zA-Z]} $Ligne]  && ! [regexp "AvecTout" $Maniere]} { break }
	    $w.frame.list insert end $Ligne
	}
    }
    if {[PourWscope]} {
	set R [Html_TextToListbox [set PagePropre($w)] $w $Titre $Header "" $Maniere]
	if { [regexp "AvecRetour" $Maniere] } {
	    return $R

	    global VariableDeRetour
	    package require Tk
	    tkwait variable VariableDeRetour($w)
	    set v $VariableDeRetour($w)
	    LogWscope "apres tkwait de $Var valeur $v"
	    unset  VariableDeRetour($w)
#	    catch {destroy $w}
	    return $v
	}
	return $R
    }
    if {$nLignes<30} { $w.frame.list configure -height [expr $nLignes+3] }
    
    if {[regexp "AvecEtude" $Maniere] && $Nom!=""} {
	Illumine $Nom $w
    }
    
    bind $w.frame.list <3>               "DecrisLaLigne %W %x %y"
    bind $w.frame.list  "DecrisLaLigne %W %x %y Efface"
    
    if {[regexp "AvecRetour" $Maniere]} {
	$w.frame.list configure -background "lightgreen"
    }
    if { [regexp "AvecRetourMaisSansWait" $Maniere] } {
	return $w
    }

    if { [regexp "AvecRetour" $Maniere] } {
	tkwait variable VariableDeRetour($w)
	set v $VariableDeRetour($w)
	unset  VariableDeRetour($w)
	catch {destroy $w}
	return $v
    } else {
	return $w
    }

}

proc AfficheVirtualPPCR {} {

    set Page [join [VirtualPPCREnStock LesResumes] "\n"]
    set LesQuois [VirtualPPCREnStock LesQuois]
    return [AfficheVariable $Page "AvecVirtualPPCR" AllVirtualPPCRs]

}

proc AfficheZoneContigue {Fichier {Selection ""}} {

    if {$Selection==""} { set Selection "FirstOnly" }
    if {[regexp "\n" $Selection]} {
	set AliasALaFin ""
	foreach Access [split $Selection "\n"] {
	    if {[regexp {^ *Alias } $Access]} {
		set AliasALaFin $Access
		continue
	    }
	    AfficheZoneContigue $Fichier $Access 
	}
	if {$AliasALaFin!=""} { AfficheZoneContigue $Fichier $AliasALaFin }
	return
    }
    
    set Access ""
    scan $Selection "%s %s" Nature Access
    if {$Access==""} { set Access $Nature }
    
    set LesHomologues [LesHomologiesDuBlastN $Fichier "AvecLaSeq" "" "SansOrga" $Access]
    foreach Homo $LesHomologues {
	set lHomo [split $Homo "\t"]
	set i -1
	set Nom        [lindex $lHomo [incr i]]
	set nCops      [lindex $lHomo [incr i]]
	set nCopsSeq   [lindex $lHomo [incr i]]
	set BanqueId   [lindex $lHomo [incr i]]
	set OrgaHomo   [lindex $lHomo [incr i]]
	set Identities [lindex $lHomo [incr i]]
	set Expect     [lindex $lHomo [incr i]]
	set DebutQuery [lindex $lHomo [incr i]]
	set FinQuery   [lindex $lHomo [incr i]]
	set DebutSbjct [lindex $lHomo [incr i]]
	set FinSbjct   [lindex $lHomo [incr i]]
	set SeqQuery   [lindex $lHomo [incr i]]
	set SeqSbjct   [lindex $lHomo [incr i]]

	set SensSbjct 1
	if {$FinSbjct < $DebutSbjct} { set SensSbjct -1 }

	set iQ $DebutQuery
	set iQTexte ""
	set iQTexteEstVide 1
	set iS $DebutSbjct
	set iSTexte ""
	set iSTexteEstVide 1
	set ConMax -1
	set ConCourant 0
	set ConDebCourantQ -1
	set ConDebCourantS -1
	set Peigne  ""
	set PeigneN ""
	set ConDebQ -3
	set iP 1
	foreach Q [split $SeqQuery ""] S [split $SeqSbjct ""] {
	    if {[expr $iQ%10==0] && $Q!="-" } {
		set iQTexteEstVide 0
		append iQTexte [string range "$iQ          " 0 9]
	    } else {
		if {$iQTexteEstVide} { append iQTexte " " }
	    }
	    if {[expr $iS%10==0] && $S!="-" } {
		set iSTexteEstVide 0
		append iSTexte [string range "$iS          " 0 9]
	    } else {
		if {$iSTexteEstVide} { append iSTexte " " }
	    }
	    if {[string equal -nocase "N" $Q]} { append PeigneN "N" } else { append PeigneN " " }
	    if {[string equal -nocase $Q $S] || [string equal -nocase "N" $Q]} {
		append Peigne "|"
		incr ConCourant
		if {$ConDebCourantQ==-1} {
		    set ConDebCourantP $iP
		    set ConDebCourantQ $iQ
		    set ConDebCourantS $iS
		} 
		if { ! [info exists ConFinQ]} {
		    set ConFinP $iP
		    set ConFinQ $iQ
		    set ConFinS $iS
		}
		if {$ConCourant>$ConMax} {
		    set ConMax  $ConCourant
		    set ConFinP $iP
		    set ConFinQ $iQ
		    set ConFinS $iS
		    if {$ConDebQ!=$ConDebCourantQ} {
			set ConDebP $ConDebCourantP
			set ConDebQ $ConDebCourantQ
			set ConDebS $ConDebCourantS
		    }
		}
	    } else {
		set ConCourant 0
		append Peigne " "
		set ConDebCourantP -1
		set ConDebCourantQ -1
		set ConDebCourantS -1
	    }
	    incr iP
	    if {$Q!="-"} { incr iQ            } else { append iQTexte " " }
	    if {$S!="-"} { incr iS $SensSbjct } else { append iSTexte " " }
	}

	set iDebPeigne [expr $ConDebP - 1]
	set iFinPeigne [expr $ConFinP - 1]
	set lPeigne [expr $iFinPeigne - $iDebPeigne +1]
	set Peigne [string replace $Peigne $iDebPeigne $iFinPeigne [string repeat "+" $lPeigne]]

	if {$SensSbjct==1} {
	    set BonConDebS $ConDebS
	    set BonConFinS $ConFinS
	    set EtLeSens ""
	} else {
	    set BonConDebS $ConFinS
	    set BonConFinS $ConDebS
	    set EtLeSens "CAUTION: reverse"
	}
	lappend LaPage "$Access hit in $Fichier : $lPeigne contigous identical bases"
	lappend LaPage [format "%5d %5d %s"    $ConDebQ    $ConFinQ "from sequenced"]
	lappend LaPage [format "%5d %5d %s" $BonConDebS $BonConFinS "from $Access $EtLeSens"]
	global TextePourInformeVerificationSequencage
	set TextePourInformeVerificationSequencage "$BonConDebS-$BonConFinS"
	lappend LaPage $PeigneN
	lappend LaPage $iQTexte 
	lappend LaPage $SeqQuery
	lappend LaPage $Peigne
	lappend LaPage $SeqSbjct
	lappend LaPage $iSTexte
	set Page [join $LaPage "\n"]
	AfficheVariable $Page "" "${Fichier}_$Access"
    }

}

proc AfficheZonesClustering {} {

    global Defauts WOrdali NomTextSeq LNOrdali

    if {[TypeAli] eq "pasdali"} {return}

    $NomTextSeq configure -state normal
    $NomTextSeq tag configure TagZoneClus -background cyan

    set bt $WOrdali(BoutZones)
    if {! [EtatBouton $bt]} {
	set Lz [lindex [ZonesClustering] 0]
	if {$Lz eq "all"} {set Lz [list [list 0 end]]}
	foreach z $Lz {
	    lassign $z x1 x2
	    set i 1
	    foreach n $LNOrdali {
		if {$n ne ""} {
		    lappend ltag $i.$x1 $i.$x2
		}
		incr i
	    }
	}
	$NomTextSeq tag add TagZoneClus {*}$ltag

	$bt configure -relief sunken -background red -foreground white
    } else {
	$NomTextSeq tag remove TagZoneClus 1.0 end
	$bt configure -relief raised -background cyan -foreground black
    }

    update idletasks
    $NomTextSeq configure -state disabled

    return

}

proc AfficheZonesSelectionnees {zone} {

    global PositionInitiale

    if {$zone == {}} {return}
    foreach z $zone {
	lassign $z d f
	set PositionInitiale "1.$d"
	set fin "1.$f"
	SelectLesColonnes $fin
    }
    unset PositionInitiale

    return

}

proc AfficheZonesSelectionneesCluster {} {

    global ZoneClusterisation

    if {! [info exists ZoneClusterisation]} {return}

    AfficheZonesSelectionnees $ZoneClusterisation

    return

}

proc AfficheZonesSelectionneesSuper {} {

    global ZoneSuperposition

    if {! [info exists ZoneSuperposition]} {return}

    AfficheZonesSelectionnees $ZoneSuperposition

    return

}

proc AffyAnno {{Ligne ""} {Colonne ""}} {

    #attention un nouvelle version
    global AffyAnno

    if {$Ligne==""} { set Ligne "ListOf" }
    if {$Colonne==""} { set Colonne "Header" }

    if {[info exists AffyAnno($Ligne,$Colonne)]} { return $AffyAnno($Ligne,$Colonne) }
    if {[info exists AffyAnno("EstCharge")]} { return "" }
    set AffyAnno("EstCharge") 1

    set FichierAffyAnno "[RepertoireDuGenome]/fiches/AffyAnno"
    if {[file exists $FichierAffyAnno]} {
	array set AffyAnno [LesLignesDuFichier $FichierAffyAnno]
	return [AffyAnno $Ligne $Colonne]
    }

    set CreeFichierAffyAnno [OuiOuNon "Do I create $FichierAffyAnno ?"]

    set AffyAnno(ListOf,Header) {}
    set AffyAnno(ListOf,Index)  {}

    set LesFichiersAffyAnno [list  "/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Av2.na22.annot.csv"  "/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Bv2.na22.annot.csv"  "/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Cv2.na22.annot.csv"  "/genomics/link/affyArrayAnnot/AffyAnno20070309/MG430_2.0/Mouse430_2.na22.annot.csv"  "/genomics/link/affyArrayAnnot/AffyAnno20070309/MG430A_2.0/Mouse430A_2.na22.annot.csv" ]

    set LesTetes {}
    set LesIndex {}
    foreach CurrentFichierAffyAnno $LesFichiersAffyAnno {
	Espionne "$CurrentFichierAffyAnno"
	set Queue [file tail $CurrentFichierAffyAnno]
	Espionne "$Queue"
	regsub -nocase {\.[^\.]+$} $Queue "" Queue
	Espionne "$Queue"
	
	LoadTxlAffy $CurrentFichierAffyAnno AffyAnno 0 ","  
	set LesNouvellesTetes $AffyAnno(ListHeaderPlease,$Queue)
	Espionne "$LesTetes"
	Espionne "++"
	Espionne "$LesNouvellesTetes"
	if {$LesTetes=={}} { set LesTetes $LesNouvellesTetes }
	if {$LesTetes!=$LesNouvellesTetes} { FaireLire "The headers are different in [join $LesFichiersAffyAnno "\n"]" }
	LConcat LesIndex $AffyAnno(ListAllPlease,$Queue)
    }	
    set AffyAnno(ListOf,Header) $LesTetes
    set AffyAnno(ListOf,Index)  $LesIndex

    if {$CreeFichierAffyAnno} {
	SauveLesLignes [array get AffyAnno] dans $FichierAffyAnno
    }
	
    return [AffyAnno $Ligne $Colonne]

}

proc AffyAnnoAllFields {Probe} {

    foreach Tete [AffyAnno ListOf Header] {
	lappend LaSortie "[format %33s $Tete] [AffyAnno $Probe $Tete]"
    }
    return [join $LaSortie "\n"]

}

proc AffyAnnoChicken {{Ligne ""} {Colonne ""}} {

    global AffyAnnoChicken

    if {$Ligne==""} { set Ligne "ListOf" }
    if {$Colonne==""} { set Colonne "Header" }

    if {[info exists AffyAnnoChicken($Ligne,$Colonne)]} { return $AffyAnnoChicken($Ligne,$Colonne) }
    if {[info exists AffyAnnoChicken("EstCharge")]} { return "" }
    set AffyAnnoChicken("EstCharge") 1

    set version "na27"
    set FichierAffyAnnoChicken "[RepertoireAffyAnnot $version]/Chicken/AffyAnnoChicken"
    if {[file exists $FichierAffyAnnoChicken]} {
	array set AffyAnnoChicken [LesLignesDuFichier $FichierAffyAnnoChicken]
	return [AffyAnnoChicken $Ligne $Colonne]
    }

    set CreeFichierAffyAnnoChicken [OuiOuNon "Do I create $FichierAffyAnnoChicken ?"]

    set AffyAnnoChicken(ListOf,Header) {}
    set AffyAnnoChicken(ListOf,Index)  {}

    set LeFichierAffyAnnoChicken "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv"
	   
    set LesTetes {}
    set LesIndex {}
    
    set Queue [file tail $LeFichierAffyAnnoChicken]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    LoadTxlAffy $LeFichierAffyAnnoChicken AffyAnnoChicken 0 ","  
    set LesTetes $AffyAnnoChicken(ListHeaderPlease,$Queue)
    LConcat LesIndex $AffyAnnoChicken(ListAllPlease,$Queue)

    set AffyAnnoChicken(ListOf,Header) $LesTetes
    set AffyAnnoChicken(ListOf,Index)  $LesIndex

    if {$CreeFichierAffyAnnoChicken} {
	SauveLesLignes [array get AffyAnnoChicken] dans $FichierAffyAnnoChicken
    }
	
    return [AffyAnnoChicken $Ligne $Colonne]

}

proc AffyAnnoHGU133 {{Ligne ""} {Colonne ""}} {

    global AffyAnnoHGU133

    if {$Ligne==""} { set Ligne "ListOf" }
    if {$Colonne==""} { set Colonne "Header" }

    if {[info exists AffyAnnoHGU133($Ligne,$Colonne)]} { return $AffyAnnoHGU133($Ligne,$Colonne) }
    if {[info exists AffyAnnoHGU133("EstCharge")]} { return "" }
    set AffyAnnoHGU133("EstCharge") 1

    set version "na27"
    set FichierAffyAnnoHGU133 "[RepertoireAffyAnnot $version]/HG-U133+2/AffyAnnoHGU133"
    if {[file exists $FichierAffyAnnoHGU133]} {
	array set AffyAnnoHGU133 [LesLignesDuFichier $FichierAffyAnnoHGU133]
	return [AffyAnnoHGU133 $Ligne $Colonne]
    }

    set CreeFichierAffyAnnoHGU133 [OuiOuNon "Do I create $FichierAffyAnnoHGU133 ?"]

    set AffyAnnoHGU133(ListOf,Header) {}
    set AffyAnnoHGU133(ListOf,Index)  {}

    set LeFichierAffyAnnoHGU133 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv"
	  
    set LesTetes {}
    set LesIndex {}
    
    Espionne "LeFichierAffyAnnoHGU133 $LeFichierAffyAnnoHGU133"

    set Queue [file tail $LeFichierAffyAnnoHGU133]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    LoadTxlAffy $LeFichierAffyAnnoHGU133 AffyAnnoHGU133 0 ","  
    set LesTetes $AffyAnnoHGU133(ListHeaderPlease,$Queue)
    LConcat LesIndex $AffyAnnoHGU133(ListAllPlease,$Queue)

    set AffyAnnoHGU133(ListOf,Header) $LesTetes
    set AffyAnnoHGU133(ListOf,Index)  $LesIndex

    if {$CreeFichierAffyAnnoHGU133} {
	SauveLesLignes [array get AffyAnnoHGU133] dans $FichierAffyAnnoHGU133
    }
	
    return [AffyAnnoHGU133 $Ligne $Colonne]

}

proc AffyAnnoMG430 {{Ligne ""} {Colonne ""}} {

    global AffyAnnoMG430

    if {$Ligne==""} { set Ligne "ListOf" }
    if {$Colonne==""} { set Colonne "Header" }

    if {[info exists AffyAnnoMG430($Ligne,$Colonne)]} { return $AffyAnnoMG430($Ligne,$Colonne) }
    if {[info exists AffyAnnoMG430("EstCharge")]} { return "" }
    set AffyAnnoMG430("EstCharge") 1

    set version "na27"
    set FichierAffyAnnoMG430 "[RepertoireAffyAnnot $version]/MG430_2.0/AffyAnnoMG430"
    if {[file exists $FichierAffyAnnoMG430]} {
	array set AffyAnnoMG430 [LesLignesDuFichier $FichierAffyAnnoMG430]
	return [AffyAnnoMG430 $Ligne $Colonne]
    }

    set CreeFichierAffyAnnoMG430 [OuiOuNon "Do I create $FichierAffyAnnoMG430 ?"]

    set AffyAnnoMG430(ListOf,Header) {}
    set AffyAnnoMG430(ListOf,Index)  {}

    set LeFichierAffyAnnoMG430 "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv"
	  
    set LesTetes {}
    set LesIndex {}

    set Queue [file tail $LeFichierAffyAnnoMG430]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    LoadTxlAffy $LeFichierAffyAnnoMG430 AffyAnnoMG430 0 ","  
    set LesTetes $AffyAnnoMG430(ListHeaderPlease,$Queue)
    LConcat LesIndex $AffyAnnoMG430(ListAllPlease,$Queue)

    set AffyAnnoMG430(ListOf,Header) $LesTetes
    set AffyAnnoMG430(ListOf,Index)  $LesIndex

    if {$CreeFichierAffyAnnoMG430} {
	SauveLesLignes [array get AffyAnnoMG430] dans $FichierAffyAnnoMG430
    }
	
    return [AffyAnnoMG430 $Ligne $Colonne]

}

proc AffyAnnot {{Value ""}} {

    global AffyAnnot
    if {$Value!=""} { set AffyAnnot $Value }
    if { ! [info exists AffyAnnot]} { AffyAnnot  "[GxHome]/AffyAnnot" }
    return $AffyAnnot

}

proc AffyDsRefGene {FichierAffyAnnot} {

    #marche pas car affy ne donne pas les coordonnes de la target sequence mais de la consensus/exemplar sequence
    set Version [InterrogeFichierAffyAnnotRapide $FichierAffyAnnot "genome-version-ucsc" "version"]
    set FichierRefGene [CorresVersionGenomeEtFichierRefGene $Version]  
    Espionne "Version $Version"
    Espionne "FichierRefGene $FichierRefGene"

    foreach Ps [InterrogeFichierAffyAnnot $FichierAffyAnnot ListOf Id] {
	set ResultCur {}
	set Align [InterrogeFichierAffyAnnot $FichierAffyAnnot $Ps Alignments]
	Espionne ""
	Espionne "$Ps $Align"
	if {$Align=="---"} {lappend ResultCur "Pas Loc"; Espionne "ResultCur $ResultCur"; continue}
	regsub -all "///" $Align "#" Align
	regsub -all "//" $Align "@" Align
	set LesLocCompletes [split $Align "#"]
	foreach LocComplete $LesLocCompletes {
	    set ResultCur {}
	    set Loc [lindex [split [string trim $LocComplete] "@"] 0]
	    set Loc [string trim $Loc]
	    Espionne "$Loc"
	    set DetailLoc  [split $Loc ": -"]
	    set DetailLoc2 [split $Loc "\(\)"]
	    set ChromAffy [lindex $DetailLoc 0]
	    set StartAffy [lindex $DetailLoc 1]
	    set StopAffy  [lindex $DetailLoc 2]
	    set SensAffy  [lindex $DetailLoc2 1]
	    Espionne "LocInBetween $StartAffy $Version $ChromAffy Vide $StopAffy :"
	    set Result [LocInBetween $StartAffy $Version $ChromAffy "" $StopAffy]
	    Espionne "Result $Result"

	    if {[regexp "^Between" $Result]} {
		lappend ResultCur "Outside from Refseq"
	    } else  {
		foreach In $Result {
		    set SensIn [lindex [split $In " "] 3]
		    if {$SensIn==$SensAffy} {lappend ResultCur $In}
		}
	    }
	    Espionne "ResultCur $ResultCur"
	}
    }

}

proc AffyFileToMySql {AffyFile organism} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "AffyFileToMySql|$timestamp : Start"
	# Prepare un fichier CSV avec des ";" en remplacant les espaces par des "_" et les ";" par des tabulations
	set FichierIn [open "$Path.csv" "r"]
	set FichierOut [open "/tmp/Affy.txt" "w"]
	set Alire [read $FichierIn]
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "AffyFileToMySql|$timestamp : Replacements"
	set Alire [regsub -all -nocase -line "\",\"" $Alire ";"]
	set Alire [regsub -all -nocase -line "\"" $Alire ""]
	set Alire [regsub -all -nocase -line "Jun 30, 2009" $Alire "200907"]
	set Alire [regsub -all -nocase -line "///" $Alire ","]
	set Aecrire [regsub -all -nocase -line " // " $Alire ","]
	puts $FichierOut $Aecrire
	close $FichierIn
	close $FichierOut
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "AffyFileToMySql|$timestamp : Import into mySQL"
	exec "/usr/bin/mysqlimport --delete --user=anno --password=ceji387. --host=[LbgiHost] --fields-terminated-by=';' ucsc$organism /home/anno/Affy.txt"
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "AffyFileToMySql|$timestamp : End"

}

proc AffymetrixAccess {Nom} {

    return [ExtraitInfo $Nom "AffymetrixAccess"]

}

proc AffymetrixAssocie {} {

    global AffymetrixAssocie
    global RepertoireDuGenome

    if {[info exists AffymetrixAssocie]} {
	if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
	return $AffymetrixAssocie
    }
    set FichierAA "$RepertoireDuGenome/fiches/affymetrixassocie"
    if {[file exists $FichierAA]} {
	scan [ContenuDuFichier $FichierAA] "%s" AffymetrixAssocie
	if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
	return $AffymetrixAssocie
    }
    set D ""
    while {$D==""} {
	if { ! [OuiOuNon "Do You want to correlate with an associated Affymetrix Gscope ?" 0]} {
	    set D "NoAssociatedAffymetrix"
	    break
	}
	FaireLire "I need to know the associated Affymetrix directory.\nPlease browse for it."
	set D [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
	if {$D==""} {
	    set D [Entre "NoAssociatedAffymetrix"]
	}
    }
    set AffymetrixAssocie [file tail $D]
    Sauve $AffymetrixAssocie dans $FichierAA
    if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
    return $AffymetrixAssocie

}

proc Affymetrix_Chips {} {


    Wup "Permet de rendre le nom des repertoires des puces disponibles"

    global RepAffy

    set RepAffy [Affymetrix_Dir]
    
    if {! [file exists $RepAffy]} {
	set RepAffy "/genomics/g1/AffyProbes/Affymetrix/Full"
	if {! [file exists $RepAffy]} {
	    return ""
	}
    }

    set LesPuces [glob -nocomplain -directory "$RepAffy" -tails -types "d" "*"]
        
    return "$LesPuces"

}

proc Affymetrix_Dir {{Dir ""}} {


    #Localisation du repertoire contenant les projets ou donnees fournis par Affymetrix
    
    global Affymetrix_Dir

    if {$Dir == ""} {  
	if {[info exists Affymetrix_Dir] && [file exists $Affymetrix_Dir]} {return $Affymetrix_Dir}
	set     Affymetrix_Dir "/genomics/g1/AffyProbes/Affymetrix/Full"
    } else {
	if {[file exists $Dir]} {
	    set Affymetrix_Dir "$Dir"
	}
    }
    #if {[info exists Affymetrix_Dir] && [file exists $Affymetrix_Dir]} {return $Affymetrix_Dir}

    return $Affymetrix_Dir


}

proc AgentsDuBlock {d f {n ""}} {

    global TAg T LNOrdali MotifLen Sequences Sref
    
    if {$n eq ""} {
	set Lnoms $LNOrdali
    } else {
	set Lnoms $n
    }
      
    set LLag {}
    set nOk [expr {[llength $Lnoms] * 2}]
    for {set i $d} {$i <= ($f - $MotifLen + 1)} {incr i} {
	#lappend log "\n$i:"
	set Lag {}
	foreach n $Lnoms {
	    # check if gaps between d and f
	    set s [string range [set Sref($n)] $d $f]
	    if {[set ig [string first "." $s]] > -1} {
		puts "gap in $n pos $ig :\n$s"
		break
	    } else {
		set pos [AbsRef2Seq $n $i]
		foreach ag $TAg($n) {
		    if {$TAg($ag,$n,dep) == $pos} {
			lappend Lag $n $ag
			break
		    }
		}
	    }
	}
	if {[llength $Lag] == $nOk} {
	    lappend LLag $Lag
	} else {
	    puts "manque block !!"
	}
    }

    return $LLag

}

proc AgentsRemoveColsGaps {} {

    global Sequences LNOrdali LSOrdali
    
    #DonneMemeLongueur Sequences

    #puts "\nEntre :"
    #ShowAlignmentAgent

    set Lseq [list]
    foreach n $LNOrdali {
	lappend Lseq [set Sequences($n)]
    }
    set lmax [string length [lindex $Lseq 0]]
    unset Sequences LSOrdali

    for {set i 0} {$i < $lmax} {incr i} {
	set p$i 1
    }
    
    foreach s $Lseq {
	for {set i 0} {$i < $lmax} {incr i} {
	    if {[string index $s $i] ne "."} {
		set p$i 0
	    }
	}
    }

    set Li [list]
    for {set i 0} {$i < $lmax} {incr i} {
	if {[set p$i]} {lappend Li $i}
    }
    set Li [lsort -decreasing -integer $Li]

    set LSOrdali [list]
    foreach n $LNOrdali s $Lseq {
	foreach i $Li {
	    set s [string replace $s $i $i]
	}
	
	set Sequences($n) $s
	lappend LSOrdali $s
	incr lgout [string length $s]
    }
    update

    return

}

proc AideEnLigne {Selection} {

    global GscopeDir

    set LesMots [split [join [split $Selection "\n"] " "] " "]

    set Aucun 1
    foreach Mot $LesMots {
	set FichierHelp "$GscopeDir/help/gscope_[string tolower $Mot]_help.txt" 
	if {[file exists "$FichierHelp"]} {
	    AfficheFichier "$FichierHelp" "AvecAide"
	    set Aucun 0
	}
    }
    if { $Aucun } {
	FaireLire "Pas d'aide disponible.\nSelectionner une ligne avec des mots en MAJUSCULE"
    } 

}

proc Aiguille {Nom Couleur K Type {MilieuOuAngle milieu} {RapportAuRayonMin 0.1} {RapportAuRayonMax 0.7}} {

    global ParametresDuBoard
    global LesAutresTagsPourAiguilles

    set PI 3.14159

    set xFin           [set ParametresDuBoard($K,xFin)]
    set CentreX        [set ParametresDuBoard($K,CentreX)]
    set CentreY        [set ParametresDuBoard($K,CentreY)]
    set RayonMoyen     [set ParametresDuBoard($K,RayonMoyen)]
    set OffsetRayonMin [set ParametresDuBoard($K,OffsetRayonMin)]
    set OffsetRayonMax [set ParametresDuBoard($K,OffsetRayonMax)]

    set RayonMin [expr $RayonMoyen*$RapportAuRayonMin]
    set RayonMax [expr $RayonMoyen*$RapportAuRayonMax]


    if {$Type == "Zero" } {
	set Angle [expr $PI/2]
	set RayonMax $RayonMoyen
    } else {
	if { $MilieuOuAngle == "angle" } {
	    set Angle $Nom
	} elseif { $MilieuOuAngle == "milieu"} {
	    set Debut  [Box $Nom debut]
	    set Fin    [Box $Nom fin]
	    set Milieu [expr ($Debut+$Fin)/2]
	    if {$Type=="RepereBox"} {
		set Orient [Box $Nom orient]
		if {$Orient == "F"} { set Sens 1 } else { set Sens -1 }
		set RayonMax [expr $RayonMoyen+$Sens*($OffsetRayonMin+$OffsetRayonMax)/2]
	    }
	    set Angle [expr [DecalageAngulaireRosace] + 3.14159/2 - $Milieu*2*3.14159/$xFin]
	} else { 
	    FaireLire "Illegal\nJeMeSignale"
	    return 
	}
    }
    set PosMinX [PositionCanvaActuelleX $K [expr $CentreX+$RayonMin*cos($Angle)]]
    set PosMinY [PositionCanvaActuelleY $K [expr $CentreY-$RayonMin*sin($Angle)]]
    set PosMaxX [PositionCanvaActuelleX $K [expr $CentreX+$RayonMax*cos($Angle)]]
    set PosMaxY [PositionCanvaActuelleY $K [expr $CentreY-$RayonMax*sin($Angle)]]

    if {$Type == "RepereBox"} {
	set Couleur "black"
	$K create text $PosMinX $PosMinY -text $Nom -anchor c -tag "Txt $Type"
    }

    set BindBouton3 0
    set LesTags [list "Aiguille" "$Type"]
    if {[info exists LesAutresTagsPourAiguilles]} {
	set LesTags [concat $LesTags $LesAutresTagsPourAiguilles]
	if {[set i [lsearch $LesAutresTagsPourAiguilles "RosaceArcEnCiel"]] >= 0} {
	    set Tag [lindex $LesAutresTagsPourAiguilles 1]
	    set BindBouton3 1
	}
    }
    $K create line $PosMinX $PosMinY $PosMaxX $PosMaxY -fill $Couleur -tag $LesTags
    if {$BindBouton3} {
	$K bind "$Tag" <3>               "ManipuleLaRosace Point   $K $Tag %x %y"  
	$K bind "$Tag"  "ManipuleLaRosace Release $K $Tag %x %y"  
	$K bind "$Tag"        "ManipuleLaRosace Switch  $K $Tag %x %y"  
    }

}

proc AiguilleLaListe {ListeNomCouleur K Type {Po ""} {Min ""} {Max ""}} {

    if { ! [regexp "EnPlus$" $Type]} {
        foreach Id [$K find withtag $Type] {
            $K delete $Id
        }
    } else {
        regsub "EnPlus$" $Type "" Type
    }
    foreach {Nom Couleur} $ListeNomCouleur {
        Aiguille $Nom $Couleur $K $Type $Po $Min $Max
    }

}

proc AjoutConservationMacsims {ficXml meth} {

    
    global Defauts
    global LNOrdali
    global LSOrdali
    global TabSF
    global TPosSG
    global TPosGS
    
    if {! [info exists Defauts]} {LesDefauts}
    LesDefauts Mode Batch
    
    set lgMacsims [LesLignesDuFichier $ficXml]
    if {[lsearch -regexp $lgMacsims "CONS_RES"] != -1} {
	puts "Conservations are already listed in the xml file"
	return 0
    }

    DefinitionPreferences
  
    DecortiqueEtAfficheUnXML $ficXml
    catch {[RunMethode $meth]} Message
 
    switch $meth {
	"Cluster"      { set ft "Cons-Multi" }
	"VectorNorm"   { set ft "Cons-VectorN" }
	"MeanDistance" { set ft "Cons-MeanD" }
	"Ranganathan"  { set ft "Cons-Ranga" }
	default        { set ft "Cons-Multi" }
    }
    set LesCpl [array get TabSF "*,$ft"]
    # initialise la liste des couleurs utilisées...
    # je dois les fournir en tant que chiffre et non en tant que couleur!
    set lCol ""
    foreach {s e} $LesCpl {
	set seq [lindex [split $s ","] 0]
	set lgMacsD ""
	foreach el $e {
	    DecortiqueUneFeature $el dg fg col score note
	    if {[string index [lindex $LSOrdali [lsearch $LNOrdali $seq]] [expr $dg - 1]] != "."} {
		set pos [expr [set TPosGS($seq,[expr $dg - 1])] + 1]
		if {[lsearch $lCol $col] == -1} {
		    set color [llength $lCol]
		    lappend lCol $col
		} else {
		    set color [lsearch $lCol $col]
		}
		if {$note eq "IdenGlob"} {
		    set type "Global - rank 1"
		} elseif {$note eq "ConsGlob"} {
		    set type "Global - rank 2"
		} else {
		    set type "Intragroup - $note"
		}
		lappend lgMacsD "CONS_RES$pos$pos$color0.00$ft $type"
	    }
	}
	set lgMacsims [AjouteFeatAuMacsims $lgMacsims $seq $lgMacsD]
    }

    set fOut "$ficXml"
    set f [open $fOut w]

    foreach l $lgMacsims {
	puts $f $l
    }
    close $f

    return 1

}

proc AjouteAnnotation {w} {

    set txt [$::Anno(WText) get 1.0 end]
    set nom $::Anno(NtagCou)
    set zon [$w tag ranges $nom]

    DBAddAnnotation [VueCourante] $nom $txt $zon

    return

}

proc AjouteAuARPLog {{Texte ""} {Fichier ""}} {


    Wup "Permet de sauver dans un fichier Log les infos des resultats du process"

    global ARPLog

    if {  [info exists ARPLog] && $ARPLog  == ""} {return ""}
    if {! [info exists ARPLog] && $Fichier == ""} {return ""}
    if {$Fichier   != ""} {
	set ARPLog $Fichier
	if {$Texte == ""} {return ""}
    }

    AppendAuFichier $ARPLog "$Texte"

    return ""

}

proc AjouteAuDumpNoms {k v i} {


    global DumpNoms

    append DumpNoms $v
    return

}

proc AjouteAuDumpText {k v i} {


    global DumpText

    append DumpText $v
    return

}

proc AjouteAuLog {Log} {

  
    Wup "Permet d ecrire dans le log du panel general (GUI) ou par defaut d ecrire sur la sortie terminal"

    global LBLog

    if {! [info exists LBLog] || $Log==""} {Espionne "$Log";return ""}

    $LBLog configure -state normal
    $LBLog insert    "end"  "$Log\n"
    $LBLog configure -state disabled
    #Pour se positionner a la fin du texte
    $LBLog see end
    return ""

}

proc AjouteAuLogPipe {txt} {


    global DefautsPipe
    global TexteDuLog
    global Defauts 
        
    if {[set DefautsPipe(File,log)] == "verbose"} {
	if {! [info exists TexteDuLog]} {set TexteDuLog ""}
	append TexteDuLog "$txt\n"
    }
    return 1

}

proc AjouteBoutonFeature {bt cmd} {

    global FrmBouton FrmBtnFea

    # Attention ! Indices de grid commencent a 0 !

    set nc [expr {[lindex [grid size $FrmBtnFea] 0] - 1}]
    set nr [expr {[lindex [grid size $FrmBtnFea] 1] - 1}]

    regsub -all " " $bt "" btns
    set btns [string tolower $btns]
    button $FrmBtnFea.$btns   -text "$bt"  -command "$cmd"  -width [string length $bt]  -background green1

    grid $FrmBtnFea.$btns -in $FrmBtnFea  -pady 1 -padx 1  -row $nr -column $nc  -rowspan 1 -columnspan 1 -sticky news

    return

}

proc AjouteDefAListeDD {FichierListeDD} {

    #FichierListeDD: ANALYSE/ListeDDoverlapMABAffy (45+59) 104 redondance...5 DD
    
    #Les 45 prot DD en overlap avec MAB 
    set FichierLes45 "[RepertoireDuGenome]/ANALYSE/GO_45_MA/Les45DD"
    foreach Nom [CreeListePourFichierAUneColonne $FichierLes45] {
	set VuMAB($Nom) 1
    }
    #Les 59 prot DD en overlap avec Affy 
    set FichierLes59 "[RepertoireDuGenome]/ANALYSE/GO_59_Affy/Les59DD"
    foreach Nom [CreeListePourFichierAUneColonne $FichierLes59] {
	set VuAffy($Nom) 1
    }

    set FichierTot "[RepertoireDuGenome]/ANALYSE/Tous_6july05"
    set FichierUniq "[RepertoireDuGenome]/ANALYSE/JR_6july05"
    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set ListeDesUniques [lsort -unique [CreeListePourFichierAUneColonne $FichierListeDD]]
    foreach Nom $ListeDesUniques {
	set JR [JumeauRepresentatif $Nom]
	if {$JR!=$Nom} {Espionne "$Nom a pour JR $JR"}
	
	set OverlapMAB 0; set OverlapAffy 0
	#def 
	set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $JR N]
	set AccBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccProt]
	set DefBestProt [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefProt]
	#expr reg pour exclure ce qui suit les premieres ()

	set AccBestmRNA [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccRNA]
	set DefBestmRNA [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefRNA]
	#GO
	set LesGO [InterrogeGeneOntology $FichierGO $JR LesGO]
	if {$AccBestProtHuman!=""} {
	    if {$LesGO==""} {set Ontology ""} else {
		set Ontology ""
		foreach GO $LesGO {
		    set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition]
		    #append Ontology "$GO $LaDefinitionGO /"
		    set Ontology "$GO $LaDefinitionGO"
		    break
		}
	    } 
	} else {set Ontology ""}
	if {[info exists VuMAB($Nom)]} {set OverlapMAB 1}
	if {[info exists VuAffy($Nom)]} {set OverlapAffy 1}
	lappend L "$Nom\t$JR\t$DefBestProt\t$AccBestmRNA\t$DefBestmRNA\t$Ontology\t$OverlapMAB\t$OverlapAffy"
    }
    return $L

}

proc AjouteDesGaps {{idp ""} {nb 1}} {

    global NomTextSeq LNSeqlab LSSeqlab ListeSeqsGroupees

    if {$idp eq ""} {set idp [$NomTextSeq index active]}
    lassign [split $idp ,] il ic

    set seqass [lindex $LNSeqlab $il]
    if {$seqass eq ""} {return}

    set Lseq [SeqsGroupeSeqlabDe $seqass]
    foreach s $Lseq {
	lappend LIxSeq [lsearch $LNSeqlab $s]
    }

    AjouteDesGapsATous end $nb

    set Rs [lrepeat $nb "."]
    foreach i $LIxSeq {
	set s [lindex $LSSeqlab $i]
	set s [linsert $s $ic {*}$Rs]
	set s [lrange $s 0 end-$nb]
	lset LSSeqlab $i $s
    }

    EnleveColonnesGaps

    return

}

proc AjouteDesGapsATous {pos {nb 1}} {

    global LSSeqlab LNSeqlab NomTextSeq

    $NomTextSeq insert cols $pos $nb

    set Rs [lrepeat $nb "."]
    foreach s $LSSeqlab n $LNSeqlab {
	if {[string trim $n] ne ""} {
	    set s [linsert $s $pos {*}$Rs]
	}
	lappend new $s
    }

    set LSSeqlab $new

    return

}

proc AjouteEntreesBiblio {{db ""}} {

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

    set pmids [$db eval {select pmid from biblio where accepted=-1}]
    foreach pmid $pmids {
	set Linfo [eFetchREST pubmed $pmid]
	array set Tinfo $Linfo
	if { ! [info exists Tinfo($pmid,Title)] && ! [info exists Tinfo($pmid,Abstract)] && ! [info exists Tinfo($pmid,PubYear)]} {
	    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}
    }

    return $LesOk

}

proc AjouteExtension {Extension} {


    set Rep [pwd]
    Espionne $Rep
    if {[OuiOuNon "Do you want to rename all files from\n$Rep with $Extension"]} {
	
	foreach PAB [ListeDesPABs] {
	    set NewName "$Rep/${PAB}${Extension}"
	    set OldName "$Rep/${PAB}"
	    if {[file exists $OldName]} {
		file rename -force $OldName $NewName
	    }
	}
    }

}

proc AjouteFeatAuMacsims {lgMacsims seq features} {

    
    if {[regexp {^PDB_} $seq] == 1} {
	set sequ [string range $seq 4 end]
    } else {
	set sequ $seq
    }
    set idx [lsearch $lgMacsims "${sequ}"]
    set idxD [lsearch -start $idx $lgMacsims ""] 
    if {$idxD != -1} {
	set lgMacsD [lrange $lgMacsims 0 [expr $idxD - 1]]
	set lgMacsF [lrange $lgMacsims $idxD end]
	
	foreach feat $features {
	    lappend lgMacsD $feat
	}
	foreach l $lgMacsF {
	    lappend lgMacsD $l
	}
	return $lgMacsD
    } else {    
	return $lgMacsims
    }   

}

proc AjouteFils {pid par tid} {

    set Lp [set ::ATree($pid)]
    set Lt [set ::ATree($tid)]
    unset ::ATree($tid)

    set idx [lsearch -exact $Lp $par]
    set ls [llength [lrange $Lp $idx end]]
    lset Lt 1 $idx
    lappend Lp {*}[lrange $Lt 0 2]
    foreach {k i p} [lrange $Lt 3 end] {
	lappend Lp $k [incr i $ls] $p
    }
    set ::ATree($pid) $Lp

    return

}

proc AjouteGroupeToutLeMonde {} {

    global SDG LNDG

    # already here
    if {"GroupeToutLeMonde" in $LNDG} {
	return
    }

    set LNDG [linsert $LNDG 0 "GroupeToutLeMonde"]
    set Lt {}
    foreach e [array names SDG] {
	lappend Lt {*}[set SDG($e)]
    }
    set SDG(GroupeToutLeMonde) $Lt
    
    return

}

proc AjouteHS {Fichier FichierNew} {

    foreach Ligne [LesLignesDuFichier $Fichier] {
	#Espionne $Ligne
	if {$Ligne==""} {continue}
	if {[regexp -nocase "N/A" $Ligne]} {Espionne $Ligne;continue}
	set LesInfos [split $Ligne "\t"]
	set chro [lindex $LesInfos 0]
	if {$chro==0} {FaireLire $Ligne}
	if {$chro==""} {FaireLire $Ligne}
	if {$chro<10} {set NewChro "HS0$chro"} else {set NewChro "HS$chro"}
	set NewL [lreplace $LesInfos 0 0 $NewChro]
	#FaireLire $NewL
	set NewL [join $NewL "\t"]
	lappend L $NewL
    }
    SauveLesLignes $L dans $FichierNew

}

proc AjouteLesInfoDansLaListeBox {KListBox LesInfo} {

    foreach Elet $LesInfo {$KListBox insert end $Elet}
    return

}

proc AjouteLesTaxonsAuFichierDeClassificationTaxonomique {aTabTaxon LesTaxonsAncestraux {LeTexte ""}} {

    upvar $aTabTaxon TabTaxon

    set     Blanc                   " "
    set     DernierAncetre          [lindex  $LesTaxonsAncestraux end]
    set     NiveauDuDernierAncetre  [llength $LesTaxonsAncestraux]
    lappend LeTexte                 "[string repeat $Blanc [expr $NiveauDuDernierAncetre - 1]]$NiveauDuDernierAncetre\t$DernierAncetre"

    set     IndexAncetres            [join $LesTaxonsAncestraux ","]
    if {![info exists  TabTaxon($IndexAncetres,LesDescendants)]} {return $LeTexte}
    foreach Taxon [lsort [set TabTaxon($IndexAncetres,LesDescendants)]] {
	set LesTaxons [linsert $LesTaxonsAncestraux end $Taxon]
	set LeTexte [AjouteLesTaxonsAuFichierDeClassificationTaxonomique TabTaxon $LesTaxons $LeTexte]
    }
    return $LeTexte

}

proc AjouteNouveauPrefixe {we wl} {

    global TmpDef

    set e [string trim [$we get]]
    if {$e eq ""} {return}

    lappend TmpDef(PrefixesBank) $e
    $wl configure -state normal
    $wl delete 0 end
    $wl insert end {*}[set TmpDef(PrefixesBank)]
    $wl configure -state disabled
    $wl see end

    $we delete 0 end

    return

}

proc AjoutePDB {{what ok}} {

    global WAP LNOrdali ListePDB

    if {$what ne "ok"} {
	destroy $WAP(Win)
	unset WAP

	return
    }

    if {$WAP(File) eq ""} {
	FaireLire "Please supply a file name !"

	return
    }

    if {! [file exists $WAP(File)]} {
	FaireLire "The file\n$WAP(File)\ndoes not exists !"
	return
    }

    if {$WAP(Replace) eq ""} {
	FaireLire "Please select <> or give the new PDB Id"

	return
    }
    
    if {$WAP(Replace)} {
	if {$WAP(Id) eq "Choose"} {
	    FaireLire "Please choose a PDB Id"

	    return
	}

	DetruitUnPDB $WAP(Id)
	set pdbid $WAP(Id)
    } else {
	if {! [EstUnAccessPDB $WAP(NewId)]} {
	    FaireLire "Please give a valid PDB Id for this structure\nIt should be on the form : NXXX_Y where N is a number (0-9), X can be a number or a letter, and Y an alphanumaric character"

	    return
	}
	set pdbid $WAP(NewId)
    }
    LoadNouveauPDB $WAP(File) $pdbid

    foreach c [$pdbid _chains] {
	set nom [BonNomPDB ${pdbid}_$c]
	if {$nom in $LNOrdali && $nom ni $ListePDB} {
	    lappend ListePDB $nom
	}
    }

    destroy $WAP(Win)
    unset WAP

    return

}

proc AjoutePourcentageMRMDansInfos {Nom} {

    set PourcentMasque [QuelPourcentageApresMRM $Nom]
    if {$PourcentMasque!="" && $PourcentMasque!=0} {
	InformeSansDemander $Nom "MRMPourcent: $PourcentMasque"
    }

}

proc AjoutePourcentageMRMDansInfosPourTous {} {

    foreach Nom [ListeDesPABs] {
	AjoutePourcentageMRMDansInfos $Nom
    }

}

proc AjouteProfilMoyEtRN {FichierRegine FichierSortie} {

    set FichierTot "[RepertoireDuGenome]/OVERLAP931/TotalData"
    set FichierUniq "[RepertoireDuGenome]/OVERLAP931/DataUniques"
    #Profil DD
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] {
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 0]
	set Prof [lindex $LesChamps 1]
	if {$Prof=="+"} {set P($DD) "T"}
	if {$Prof=="-"} {set P($DD) "N"}
	if {$Prof=="0"} {set P($DD) "C"}
    }
    #Profil Virtual Northern et Northern
    set FichierProfilDDValidation "[RepertoireDuGenome]/totalite/ValidationProfil.txt"
    if {![file exists $FichierProfilDDValidation]} {return}
    foreach Ligne [LesLignesDuFichier $FichierProfilDDValidation] {
	if {$Ligne=="" || [regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set Owner [lindex $Ligne 0]
	set CC [lindex $Ligne 2]
	if {$Owner=="F"} {set CC [string toupper $CC]}
	if {$Owner=="I"} {regsub -all "\'" $CC "_" CC}
	set ProfVN [lindex $Ligne 3]
	set ProfNorthern [lindex $Ligne 5]
	
	set PVN($Owner,$CC) $ProfVN
	set PN($Owner,$CC) $ProfNorthern
    }
    #profil Macroarray
    set FichierMacroarray "[RepertoireDuGenome]/MembranesRegine/compar_profils_mb_gscope"
    foreach Ligne [LesLignesDuFichier $FichierMacroarray] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 1]
	set ProfMb [lindex $LesChamps 2]
	set PMb($DD) $ProfMb
    }
    #correspondance HNK DD
    set FichierCorres "[RepertoireDuGenome]/lacorrespondance"
    foreach Ligne [LesLignesDuFichier $FichierCorres] {
	if {$Ligne==""} {continue}
	set Ligne [split $Ligne "\t"]
	set New [lindex $Ligne 0]; set Old [lindex $Ligne 1]
	set N($Old) $New
    }
    foreach Ligne [LesLignesDuFichier $FichierRegine] {
	if {$Ligne==""} {continue}
	if {[regexp "GscopeCode" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	#HNK -> DD
	set HNK [string trim [lindex $Ligne 0]]
	if {$HNK!=""} {
	    if {[info exists N($HNK)]} {
		set DD $N($HNK)
		Espionne $DD
		#fiches/jumeaux est une copie de 931 (931 avec jum)
		set JR [JumeauRepresentatif $DD]
		#DD -> jumeaux
		set FichierJumeaux "[RepertoireDuGenome]/fiches/jumeaux"
		set LesJumeauxDuJR [LesJumeauxDuPAB $DD $FichierJumeaux]
		set LesJumeaux [TousLesJumeauxDuPAB $DD $FichierJumeaux]
		set LesJumeaux [split $LesJumeaux " "]
		#jumeaux -> VN Northern du cluster
		set ProfilVN ""; set ProfilNorthern ""; set ProfilMb ""
		foreach Jumeau $LesJumeaux {
		    set CodeClone [InterrogeFichierTotalDataDD $FichierTot $Jumeau Code]
		    set User [InterrogeFichierTotalDataDD $FichierTot $Jumeau User]
		    set Band [InterrogeFichierTotalDataDD $FichierTot $Jumeau Bande]
		    #virtual northern
		    if {[info exists PVN($User,$CodeClone)] && $ProfilVN==""} {set ProfilVN $PVN($User,$CodeClone)} 
		    set ProfilVN [string trim $ProfilVN]
		    if {[info exists PVN($User,$CodeClone)] && $ProfilVN!="" && [string trim $PVN($User,$CodeClone)]!="" && $ProfilVN!=$PVN($User,$CodeClone)} {
			#Espionne "VN: $ProfilVN dif de $PVN($User,$CodeClone) de $Jumeau"
			if {$ProfilVN==0 && $PVN($User,$CodeClone)!=0} {
			    set ProfilVN $PVN($User,$CodeClone)
			    #Espionne $Jumeau
			}
		    } 
		    #northern
		    if {[info exists PN($User,$CodeClone)] && $ProfilNorthern==""} {set ProfilNorthern $PN($User,$CodeClone)}
		    set ProfilNorthern [string trim $ProfilNorthern]
		    if {[info exists PN($User,$CodeClone)] && $ProfilNorthern!="" && [string trim $PN($User,$CodeClone)]!="" && $ProfilNorthern!=$PN($User,$CodeClone)} {
			#Espionne "Northern: $ProfilNorthern et $PN($User,$CodeClone) de $jumeau"
		    }
		    
		    #membrane nylon Regine
		    if {[info exists PMb($Jumeau)] && $ProfilMb==""} {set ProfilMb $PMb($Jumeau)} 
		    set ProfilMb [string trim $ProfilMb]
		    #if {$ProfilMb==" "} {set ProfilMb ""}
		    if {[info exists PMb($Jumeau)] && $ProfilMb!="" && [string trim $PMb($Jumeau)]!="" && $ProfilMb!=$PMb($Jumeau)} {
			#Espionne "Mb: $ProfilMb et $PMb($Jumeau)"
		    } 
		}
		if {$JR!=""} {
		    set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $DD N]
		    set ProfilCalc [InterrogeFichierTotalDataDD $FichierTot $DD Profil]
		    set ProfilConsensus [InterrogeFichierTotalDataDD $FichierTot $DD ProfCons]
		    
		    set DifE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifE]
		    set ProfE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfE]
		    set DifS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifS]
		    set ProfS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfS]
		    set DifU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifU]
		    set ProfU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfU]
		    set DifMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifMoy]
		    set ProfMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Pmoy]
		    
		    AppendAuFichier $FichierSortie "$CodeClone\t$Band\t$User\t$NumGeneDD\t$HNK\t$DD\t$JR\t$LesJumeauxDuJR\t$DifE\t$ProfE\t$DifS\t$ProfS\t$DifU\t$ProfU\t$DifMoy\t$ProfMoy\t$ProfilCalc\t$ProfilConsensus\t$ProfilVN\t$ProfilNorthern\t$ProfilMb"
		} else {
		    #si pas de JR, c'est un court ou conta ou nohomolog
		    #Espionne "$DD n'est pas dans les 931avecjum"
		    lappend Liste $DD
		    #VN
		    #if {[info exists PVN($User,$CodeClone)]} {set ProfilVN $PVN($User,$CodeClone)}
		    #Profil DD
		    #if {[info exists P($DD)]} {set ProfilCalc $P($DD)}
		    #Profil_consensus
		    #if {[info exists Pc($DD)]} {set ProfilConsensus $Pc($DD)}
		    #PMoy
		}
	    } else {Espionne "pb pour $HNK"}
	}
    }
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/Regine/pbs_out"

}

proc AjouteRepeatDansInfos {Nom} {

    set Repeat [QuelRepeat $Nom]
    if {$Repeat!=""} {
	InformeSansDemander $Nom "MRM: $Repeat"
    }

}

proc AjouteRepeatDansInfosPourTous {} {

    foreach Nom [ListeDesPABs] {
	AjouteRepeatDansInfos $Nom
    }

}

proc AjouteRepeatDansInfos_old {Nom} {

    set Repeat [QuelRepeatApresReMasking $Nom]
    if {$Repeat!=""} {
	InformeSansDemander $Nom "MRM: $Repeat"
    }

}

proc AjouteSeqs {} {

    global LNSeqlab LSSeqlab LNOrdali LSOrdali LongueurTotale ListePDB HashPDB Sequences NomSeqSel TAddS LNDG SDG
    
    if {[TypeAli] eq "pasdali"} {
	FaireLire "There are no sequences yet.\nPlease load an alignment first."
	
	return
    }
    
    # not in editor mode
    if {[QuelMode] eq "seqlab"} {
	FaireLire "You can't add sequences in Editor mode !\nLeave the Editor to add sequences."
	
	return
    }
    
    set res [AskAddSeqs]
    if {$res eq ""} {
	return
    }
    # repere position ascenceur
    lassign [$::TScrollY get] yscr tmp
    
    # ok let's go
    VueEditee 1
    
    FaireAttendre "Please wait ...\nLoading and parsing new sequences ..."
    
    # Load sequences et verif format
    set file $TAddS(File)
    if {[EstLeBonFormat $file TFA]} {
	DecortiqueUnTFA $file LNTank TTank
    } elseif {[EstLeBonFormat $file ALN]} {
	DecortiqueUnALN $file LNTank TTank
    } else {
	DecortiqueUnMSF $file LNTank TTank
    }
    
    # reference sequences
    if {[QuelMode] eq "seqlab"} {
	set LNomsAli $LNSeqlab
	set LSeqsAli [list]
	foreach s $LSSeqlab {
	    lappend LSeqsAli [join $s ""]
	}
    } else {
	set LNomsAli $LNOrdali
	set LSeqsAli $LSOrdali
    }
    set y [lsearch -exact $LNomsAli $TAddS(seqInsert)]
    
    # Nettoyages divers (ou d'ete)
    set lgsadd 0
    set LNAddSeq [list]
    set LSAddSeq [list]
    foreach n $LNTank {
	set s [set TTank($n)]
	set n [BonAccess $n]
	set s [BonneSequencePourAlignement $s]
	set nogap [string map {" " "" "~" "" "-" "" "." ""} $s]
	if {! [string length $nogap]} {
	    if {[ModeI]} {
		FaireLire "You have empty sequences !\n>$n< will be left out !"
	    }
	    continue
	}
	
	if {$n in $LNomsAli} {
	    # on ne duplique pas les pdb
	    if {$n in $ListePDB} {
		continue
	    }
	    
	    # sequence already exists
	    switch $TAddS(CopySkip) {
		1 {
		    continue
		}
		0 {
		    set pi 1
		    while {"${n}__$pi" in $LNomsAli} {
			incr pi
		    }
		    set n "${n}__$pi"
		}
	    }
	}
	set l [string length $s]
	set lgsadd [expr {$l>$lgsadd?$l:$lgsadd}]
	set n [string trim $n]
	set newS($n) $s
	lappend LNAddSeq $n
	lappend LSAddSeq $s
    }
    # no sequences to add
    if {$LNAddSeq == {} } {
	FaireLaSuite
	
	return
    }
    
    # should we align the new sequences ?
    set DoAlign $TAddS(Align)
    if {$DoAlign} {
	# create a TFA from alignment
	set aliTfa [list]
	foreach n $LNomsAli s $LSeqsAli {
	    if {$n ne ""} {
		set s [string map {. -} $s]
		lappend aliTfa ">$n" $s
	    }
	}
	set aliTfa [join $aliTfa "\n"]
	# create a TFA with seqs to be added
	set addTfa [list]
	foreach n $LNAddSeq s $LSAddSeq {
	    set s [string map {. -} $s]
	    lappend addTfa ">$n" $s
	}
	set addTfa [join $addTfa "\n"]
	
	# create MAFFT alignement
	if {[OutsideCSTB]} {
	    set LnewAli [Mafft_AddSequences $aliTfa $addTfa]
	} else {
	    set LnewAli [Mafft_AddSequences_local $aliTfa $addTfa]
	}
	
	if {$LnewAli eq ""} {
	    if {[ModeI]} {
		FaireLire "Something went wrong while computing alignment !\nSequences will be added unaligned"
	    }
	    set DoAlign 0
	}
    }
    
    if {! $DoAlign} {
	set lgsadd [DonneMemeLongueur newS]
	set LSAddSeq [list]
	foreach n $LNAddSeq {
	    lappend LSAddSeq $newS($n)
	}
	
	
	# Ajuste longueur alignement - seq add
	set lscou [LongueurAlignement [QuelMode]]
	set d [expr {$lgsadd - $lscou}]
	set add [string repeat "." [expr {abs($d)}]]
	if {$d < 0} {
	    # added sequences are shorter
	    set Ltmp [list]
	    foreach n $LNAddSeq s $LSAddSeq {
		append s $add
		set newS($n) $s
		lappend Ltmp $s
	    }
	    set LSAddSeq $Ltmp
	} elseif {$d > 0} {
	    # added sequences are longer
	    # -> adjust alignment sequences
	    set LongueurTotale $lgsadd
	    set Lnew [list]
	    foreach s $LSeqsAli {
		if {[string trim $s] ne ""} {
		    append s $add
		}
		lappend Lnew $s
	    }
	    set LSeqsAli $Lnew
	}
    } else {
	# sequences aligned by MAFFT
	DecortiqueUnTFA $LnewAli LNAligned SAligned
	# record aligned sequences
	set Lnew [list]
	set Ltmp [list]
	set Lall [concat $LNomsAli $LNAddSeq]
	foreach n $Lall {
	    if {$n eq ""} {
		set s ""
	    } else {
		set s $SAligned($n)
	    }

	    if {$n in $LNAddSeq} {
		lappend Ltmp $s
	    } else {
		lappend Lnew $s
	    }
	}
	set LSeqsAli $Lnew
	set LSAddSeq $Ltmp
    }
	
    # On traite les PDB ajoutes
    set ix -1
    set BadPDB [list]
    set Sprsde [list]
    foreach s $LNAddSeq {
	incr ix
	if {! [EstUnAccessPDB $s]} {
	    continue
	}
	
	set pdbid [DonneIdDeAccessPDB $s]
	set chn   [DonneChainDeAccessPDB $s]
	
	if {$pdbid ni [info commands]} {
	    set cok [LoadNouveauPDB $pdbid]
	    if {$cok == 0} {
		lappend BadPDB $ix
		continue
	    } elseif {$cok != 1} {
		# superseeded name ! 
		# Should change
		set nwnm $cok
		set cok 1
		lappend Sprsde [list $nwnm $ix]
	    }
	}
	lappend ListePDB $s
    }
    
    # Bad PDBs
    foreach i [lsort -integer -decreasing $BadPDB] {
	set e [lindex $LNAddSeq $i]
	set Molid [DonneIdDeAccessPDB $e]
	set Chn   [DonneChainDeAccessPDB $e]
	set newe "bsq${Molid}_$Chn"
	lset LNAddSeq $i $newe
    }

    # Superseeded names
    foreach e [lsort -integer -decreasing -index 1 $Sprsde] {
	lassign $e nwnm i
	set old [lindex $LNAddSeq $i]
	set Molid $nwnm
	set Chn   [DonneChainDeAccessPDB $old]
	set newe [BonNomPDB ${Molid}_$Chn]
	lset LNAddSeq $i $newe
    }

    # sequences have been checked
    # initialise new seqs, and insert them
    InitInfoSeqs $LNAddSeq
    
    # insertion of new sequences
    if {$TAddS(Position) eq "cluster"} {
	# choose closest cluster to insert 
	# each new sequence
	lassign [InsertionSequencesDansGroupes $LNomsAli $LSeqsAli $LNAddSeq $LSAddSeq] LNomsAli LSeqsAli
    } else {
	if {$TAddS(Position) eq "afterseq"} {
	    set i [lsearch -exact $LNomsAli $TAddS(seqInsert)]
	} else {
	    set i "end"
	}
	lassign [InsertionSequencesAPosition $LNomsAli $LSeqsAli $LNAddSeq $LSAddSeq $i] LNomsAli LSeqsAli
    }

    # recreate lists according to mode
    if {[QuelMode] ne "seqlab"} {
	set LNOrdali $LNomsAli
	set LSOrdali $LSeqsAli
	unset -nocomplain Sequences
	foreach n $LNOrdali s $LSOrdali {
	    if {$n ne ""} {
		set Sequences($n) $s
	    }
	}
    } else {
	set LNSeqlab $LNomsAli
	set LSSeqlab [list]
	foreach n $LNomsAli s $LSeqsAli {
	    lappend LSSeqlab [split $s ""]
	}
    }

    InitPosSeqGenGenSeq
    InfosDesPDB
    
    # Calculs divers
    AssigneLesPoids
    TraiteAABizarres
    CalculeComposition
    CalculePI
    CalculeMolecularWeight
    
    # Update Fenetre alignement
    MetAJourGroupes
    if {[QuelMode] ne "seqlab"} {
	set WdtNom [PlusLongEltDe $LNOrdali]
	InitWRegle
	AfficheRegle
    } else {
	set WdtNom [PlusLongEltDe $LNSeqlab]
	set y [expr {$y-1}]
	$::NomTextSeq addseqs $LIN $y
    }
    
    if {$WdtNom > $::Defauts(LongNom)} {
	LesDefauts LongNom $WdtNom
    }
    $::NomNomSeq configure -width $WdtNom
    
    ChangeNomsAff $::Defauts(NomsAffiches)
    AfficheNomsEtSeqs
    RepeintNomsEtSeqs
    update idletasks
    
    # remet ascenceur
    CoupleY moveto $yscr
    
    FaireLaSuite

    return

}

proc AjouteSpaceSeq {} {

    global LNSeqlab LSSeqlab LNOrdali LSOrdali NomTextSeq NomNomSeq NomSeqSel Defauts TScrollY

    if {[TypeAli] eq "pasdali"} {return}
    if {[llength $NomSeqSel] != 1} {
	FaireLire "Please select one sequence below\nwhich a separator should be inserted !"
	return
    }

    # strore Y-scroll position
    lassign [$TScrollY get] ysc tmp

    lassign [split $NomSeqSel .] y x 
    set i [expr {$y+1}]
    $NomNomSeq  configure -state normal
    $NomNomSeq  insert $i.0 "\n"
    $NomNomSeq  configure -state disabled

    if {[QuelMode] ne "seqlab"} {
	VueEditee 1
	$NomTextSeq configure -state normal
	$NomTextSeq insert $i.0 "\n"
	$NomTextSeq configure -state disabled

	set LNOrdali [linsert $LNOrdali $y {}]
	set LSOrdali [linsert $LSOrdali $y {}]
    } else {
	set LNSeqlab [linsert $LNSeqlab $y {}]
	set LSSeqlab [linsert $LSSeqlab $y {}]

	# Insert AFTER Index ...
	$NomTextSeq insert rows [expr {$y-1}] 1
    }

    MetAJourGroupes
    #ChangeNomsAff $Defauts(NomsAffiches)
    #AfficheNomsEtSeqs
    #RepeintNomsEtSeqs

    # re-position at original Y
    CoupleY moveto $ysc

    return

}

proc AjouteUnGraph {K FichierQuery XDebutQuery XFinQuery YDebutGraph YFinGraph OneNtPixel} {

    
    Wup "Ajoute un graph a un canvas"
    Wup "Ex Id et NbSeq lie au blastn et Tm et GC lie a une sequence donnee"
    
    set AvecTm        0
    set AvecGC        0
    set AvecId        0
    set AvecNbSeq     0
    set AvecTmNN      0
    set AvecTmWallace 0
    set AvecTmDNADNA  0
    set AvecTmDNARNA  0
    set AvecTmRNARNA  0
    set TmDefault    ""

    FaireLire "Choose between available graph to add."
    set  LesChoix [EntreDeux [list TmNN TmWallace TmDNADNA TmDNARNA TmRNARNA GC Id NbSeq]]
    if {$LesChoix == ""} {return ""}
    #On recupere la methode de Tm par defaut choisie et on la remet apres
    if {[regexp -nocase "tm" $LesChoix]} {set TmDefault [LesParametresDuDesign TmMethod "LaValeurMerci"]}

    foreach Choix $LesChoix {
	if {$Choix=="TmNN"}      {set AvecTm    1;set AvecTmNN      1}
	if {$Choix=="TmWallace"} {set AvecTm    1;set AvecTmWallace 1}
	if {$Choix=="TmDNADNA"}  {set AvecTm    1;set AvecTmDNADNA  1}
	if {$Choix=="TmDNARNA"}  {set AvecTm    1;set AvecTmDNARNA  1}
	if {$Choix=="TmRNARNA"}  {set AvecTm    1;set AvecTmRNARNA  1}
	if {$Choix=="GC"}        {set AvecGC    1}
	if {$Choix=="Id"}        {set AvecId    1}
	if {$Choix=="NbSeq"}     {set AvecNbSeq 1}
    }
    
    if {$AvecNbSeq || $AvecId} {
	set FichierBlastN ""
	set MesBlasts     "" 
	
	set PAB           "[file tail $FichierQuery]"
	regsub {.[a-zA-Z]+$} $PAB "" PAB

	set MesBlasts [LesInfosDe $K MesBlasts]
	while {1} {
	    if {[OuiOuNon "We need a related blastn file to build graph.\nCan I use one of these blasts ?\n$MesBlasts"]} {
		set FichierBlastN [ChoixParmi $MesBlasts]
		if {! [regexp -nocase $PAB $FichierBlastN]} {
		    FaireLire "Choose a correct blastn file according to your query sequence"
		} else {break}
		if {![OuiOuNon "Do you want to continue ?"]} {break}
	    } else {
		break
	    } 
	}
	if {$FichierBlastN=="" || ! [file exists $FichierBlastN]} {
	    FaireLire "Choose a blastn file to add two new graph to display."
	    while {1} {
		#Les types de fichier autorises
		set types {
		    {{Blastn Files} {.blastn}}
		    {{All Files}    *        }
		}
		set FichierBlastN [tk_getOpenFile -title "Choose a blastn file" -initialdir "[RepertoireDuGenome]" -filetypes $types]
		if {! [regexp -nocase $PAB $FichierBlastN]} {
		    FaireLire "Choose a correct blastn file according to your query sequence"
		} else {break}
		if {![OuiOuNon "Do you want to continue ?"]} {return ""}
	    }  
	}
	if {[file exists $FichierBlastN]} {
	    if {$AvecId} {
		#Affichage du Id content du blast
		set IdDuGraph ""
		while {1} {
		    if {[$K find withtag "Id$IdDuGraph"] != ""} {
			if {$IdDuGraph == ""} {set IdDuGraph 1} else {incr IdDuGraph}
		    } else {break}
		}
		set  IdResults [PosEtPIdAligneeDeLaRegion $FichierBlastN] 
		if {$IdResults !=""} {
		    AfficheLeSpectreIdDUneListe $K $IdResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "red" "Id$IdDuGraph"
		}
	    }
	    if {$AvecNbSeq} {
		#Affichage du nb de sequence du blast
		set IdDuGraph ""
		while {1} {
		    if {[$K find withtag "NbSeq$IdDuGraph"] != ""} {
			if {$IdDuGraph == ""} {set IdDuGraph 1} else {incr IdDuGraph}
		    } else {break}
		}
		set  NbSeqResults [PosEtNbSequenceAligneeDeLaRegion $FichierBlastN] 
		if {$NbSeqResults !=""} {
		    AfficheLeSpectreNbSequenceDUneListe $K $NbSeqResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "deepskyblue2" "NbSeq$IdDuGraph"
		}
	    }
	    UnsetLesTableauxDesGraphAvecBlast
	}
    }
    if {$AvecGC || $AvecTm} {
	set SeqQuery       [QueLaSequenceDuFichierTFA $FichierQuery]
	if {$SeqQuery==""} {Espionne "$FichierQuery no sequence available";return ""}
	set TailleQueryNt  [string length $SeqQuery]
    }
    if {$AvecTm && $AvecTmNN && [$K find withtag {"OligoGraph" && "TmNN"}] == ""} {
	LesParametresDuDesign TmMethod "NearestNeighbor" "Positionne"
	#Affichage du Tm content
	set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
	if {$TmResults !=""} {
	    AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange" "TmNN"
	}
    }
    if {$AvecTm && $AvecTmWallace && [$K find withtag {"OligoGraph" && "TmWallace"}] == ""} {
	LesParametresDuDesign TmMethod "Wallace" "Positionne"
	#Affichage du Tm content
	set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
	if {$TmResults !=""} {
	    AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange1" "TmWallace"
	}
    }
    if {$AvecTm && $AvecTmDNADNA && [$K find withtag {"OligoGraph" && "TmDNADNA"}] == ""} {
	LesParametresDuDesign TmMethod "DNADNA" "Positionne"
	#Affichage du Tm content
	set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
	if {$TmResults !=""} {
	    AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange2" "TmDNADNA"
	}
    }
    if {$AvecTm && $AvecTmDNARNA && [$K find withtag {"OligoGraph" && "TmDNARNA"}] == ""} {
	LesParametresDuDesign TmMethod "DNARNA" "Positionne"
	#Affichage du Tm content
	set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
	if {$TmResults !=""} {
	    AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange3" "TmDNARNA"
	}
    }
    if {$AvecTm && $AvecTmRNARNA && [$K find withtag {"OligoGraph" && "TmRNARNA"}] == ""} {
	LesParametresDuDesign TmMethod "RNARNA" "Positionne"
	#Affichage du Tm content
	set  TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] 
	if {$TmResults !=""} {
	    AfficheLeSpectreTmDUneListe $K $TmResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel "orange4" "TmRNARNA"
	}
    }
    if {$AvecGC && [$K find withtag {"OligoGraph" && "GC"}] == ""} {
	#Affichage du GC content
	set  GCResults [PosEtGCDeLaRegion $SeqQuery $TailleQueryNt]
	if {$GCResults !=""} {
	    AfficheLeSpectreGCDUneListe $K $GCResults  $XDebutQuery $XFinQuery  $YDebutGraph $YFinGraph $OneNtPixel
	}
    }
    
    #On recupere la methode de Tm par defaut choisie et on la remet apres
    LesParametresDuDesign TmMethod $TmDefault "Positionne"

    return ""

}

proc AjouteUnLien {Fichier_html {Texte ""} {URL ""}} {

    if {$Texte=="" || $URL==""}  {return}
    set Ref [Html_Href $URL $Texte]
    set Page [ContenuDuFichierAvecReferences $Fichier_html $Texte $Ref]
    return $Page

}

proc AjouteUnOligoPourCeuxDejaFait {PAB1 PAB2 Dir1 Dir2 Quoi} {

    
    Wup "Ajoute un oligo a la liste de ceux deja designe de dir1 a dir2"
    Wup "Cas particulier pour un redesign et completer la liste ou faire un update de l oligo"
    Wup "Quoi peut etre ref de oligo ou coordonnees debut fin"
    Wup "Rq: on teste si un oligo existe deja si oui on propose de changer de nom ou pas (update ou pas)"

    set FichierACharger1 "$Dir1/${PAB1}.oligo"
    set FichierACharger2 "$Dir2/${PAB2}.oligo"
    set NomAncienOligo   ""
    
    #Espionne ">>>>Try to complete $PAB1 with $Quoi<<<<"
    
    #Liste des oligos a partir de laquelle on va en rajouter un
    set  LesOligos1 [InterrogeInfoDeLOligo $FichierACharger1 LesNoms]
    if {$LesOligos1 == ""} {
	if {[InterrogeInfoDeLOligo $FichierACharger1 NotDone]=="1"} {
	    #Oligo non calcules
	    Espionne "Try to complete $PAB1 but no Oligo yet designed in $Dir1"
	    return ""
	} elseif {[InterrogeInfoDeLOligo $FichierACharger1 NoOligo]=="1"} {
	    #Oligo non trouves
	    Espionne "Try to complete $PAB1 but no Oligo found"
	    return ""
	} else {Espionne "Petit probleme";return ""}
    }

    #Liste des oligos auquel on veut en rajouter un
    set  LesOligos2 [InterrogeInfoDeLOligo $FichierACharger2 LesNoms]
    if {$LesOligos2 == ""} {
	if {[InterrogeInfoDeLOligo $FichierACharger2 NotDone]=="1"} {
	    #Oligo non calcules
	    Espionne "Try to complete $PAB2 but no Oligo yet designed in $Dir2"
	    return ""
	} elseif {[InterrogeInfoDeLOligo $FichierACharger2 NoOligo]=="1"} {
	    #Oligo non trouves
	    Espionne "Try to complete $PAB2 but no Oligo found"
	    return ""
	} else {Espionne "Petit probleme";return ""}
    }

    #Le nom de l oligo a ajouter
    set     LeNomOligo ""
    if {[llength $Quoi]>1} {
	set LeNomOligo [InterrogeInfoDeLOligo $FichierACharger1 [lindex $Quoi 0] [lindex $Quoi 1] NomOligo]
    } else {
	set LeNomOligo $Quoi
    }

    if {          $LeNomOligo  == ""}        {return ""}
    if {![regexp "$LeNomOligo" $LesOligos1]} {Espionne "No $LeNomOligo in $FichierACharger1";return ""}

    #On recupere les infos de l oligo a ajouter
    set Debut     [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Debut]
    set Fin       [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Fin]
    set Selection [join [ExtraitOligoDuTFA $PAB1 $LeNomOligo $Dir1] "\n"]

    #On teste dans la vieille liste si il existe deja
    if {[InterrogeInfoDeLOligo $FichierACharger2 $Debut $Fin NomOligo]!=""} {
	if {! [OuiOuNon "The Oligo for $Debut $Fin already exists\nDo I replace it ?"]} {return ""}
	set NomAncienOligo [InterrogeInfoDeLOligo $FichierACharger2 $Debut $Fin NomOligo]
	
	#On peut decider de faire un update simplement en gardant le nom de l oligo
	if {! [OuiOuNon "Should I keep the previous oligo reference (name) ?\n(Yes just for properties update)"]} {set NomAncienOligo ""}
	SupprimeUnOligoPourCeuxDejaFait $FichierACharger2 [InterrogeInfoDeLOligo $FichierACharger2 $Debut $Fin NomOligo]
	#SupprimeLeLogFileDeLOligo "$Debut $Fin" "$Dir2/${PAB2}.log"
    }

    #On change ou pas le nom de l oligo a ajouter (ou updater)
    set OldNom $LeNomOligo
    if {$NomAncienOligo!=""} {
	#On conserve le nom de l ancien oligo (juste un update)
	set LeNomOligo $NomAncienOligo
    } else {
	#On change le nom si il existe deja on incremente
	while {1} {
	    if {[regexp $LeNomOligo $LesOligos2]} {	
		regexp {Oligo([0-9]+)_} $LeNomOligo tmp Nb
		set OldNb $Nb
		incr Nb
		regsub "${OldNb}_" $LeNomOligo "${Nb}_" LeNomOligo
	    } else {break} 
	}
    }
    #Espionne "Ancien $OldNom -- Nouveau $LeNomOligo"
    regsub "$OldNom" $Selection "$LeNomOligo" Selection

    AppendAuFichier $FichierACharger2 $Selection
    #Espionne ">>>>Adding<<<<" 
    #Espionne "$Selection"
    #Espionne ">>>>>>To<<<<<<" 
    #Espionne "$FichierACharger2\n"
    return ""

}

proc AjouteUnOligoPourCeuxDejaFaitAuFichier {FichierACharger1 FichierACharger2 Quoi} {

    
    Wup "WARNING PROC NON TESTEES"

    Wup "Ajoute un oligo a la liste de ceux deja designe de dir1 a dir2"
    Wup "Cas particulier pour un redesign et completer la liste"
    Wup "Quoi peut etre ref de oligo ou coordonnees debut fin"

    #set FichierACharger1 "$Dir1/${PAB1}.oligo"
    #set FichierACharger2 "$Dir2/${PAB2}.oligo"

    set PAB1 [file tail $FichierACharger1]
    if {[regexp {\.[a-z]{3,}$} $PAB1]} {regsub {\.[a-z]{3,}$} $PAB1 "" PAB1}
    set Dir1 [file dirname $FichierACharger1]

    Espionne "$FichierACharger1 $PAB1 $Dir1"
    return ""
    Espionne ">>>>Try to complete $PAB1 with $Quoi<<<<"
    
    set  LesOligos1 [InterrogeInfoDeLOligo $FichierACharger1 LesNoms]
    if {$LesOligos1 == ""} {
	if {[InterrogeInfoDeLOligo $FichierACharger1 NotDone]=="1"} {
	    #Oligo non calcules
	    Espionne "Try to complete $PAB1 but no Oligo yet designed in $Dir1"
	    return ""
	} elseif {[InterrogeInfoDeLOligo $FichierACharger1 NoOligo]=="1"} {
	    #Oligo non trouves
	    Espionne "Try to complete $PAB1 but no Oligo found"
	    return ""
	} else {Espionne "Petit probleme";return ""}
    }

    set  LesOligos2 [InterrogeInfoDeLOligo $FichierACharger2 LesNoms]
    if {$LesOligos2 == ""} {
	if {[InterrogeInfoDeLOligo $FichierACharger2 NotDone]=="1"} {
	    #Oligo non calcules
	    Espionne "Try to complete $PAB2 but no Oligo yet designed in $Dir2"
	    return ""
	} elseif {[InterrogeInfoDeLOligo $FichierACharger2 NoOligo]=="1"} {
	    #Oligo non trouves
	    Espionne "Try to complete $PAB2 but no Oligo found"
	    return ""
	} else {Espionne "Petit probleme";return ""}
    }

    set     LeNomOligo ""
    if {[llength $Quoi]>1} {
	set LeNomOligo [InterrogeInfoDeLOligo $FichierACharger1 [lindex $Quoi 0] [lindex $Quoi 1] NomOligo]
    } else {
	set LeNomOligo $Quoi
    }

    #Espionne "Quoi $Quoi - NomOligo $LeNomOligo"

    if {          $LeNomOligo  == ""}        {return ""}
    if {![regexp "$LeNomOligo" $LesOligos1]} {Espionne "No $LeNomOligo in $FichierACharger1";return ""}

    set Debut     [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Debut]
    set Fin       [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Fin]
    #set Selection [join [ExtraitOligoDuTFA $PAB1 $LeNomOligo $Dir1] "\n"]
    set Selection [join [ExtraitOligoDuTFA2 $PAB $LeNomOligo $Dir1 [file tail $FichierACharger1]] "\n"]

    if {[InterrogeInfoDeLOligo $FichierACharger2 $Debut $Fin NomOligo]!=""} {
	if {! [OuiOuNon "Oligo for $Debut $Fin already exists\nDo I replace it ?"]} {return ""}
	set NomAncienOligo [InterrogeInfoDeLOligo $FichierACharger2 $Debut $Fin NomOligo]
	SupprimeUnOligoPourCeuxDejaFait $FichierACharger2 $NomAncienOligo
	#SupprimeLeLogFileDeLOligo "$Debut $Fin" "$Dir2/${PAB2}.log"
    }
    
    set OldNom $LeNomOligo
    #Espionne "NomOligo $LeNomOligo - OldNom $LeNomOligo"
    while {1} {
	if {[regexp $LeNomOligo $LesOligos2]} {	
	    #Espionne "NOmOligo $LeNomOligo - $LesOligos2"

	    regexp {Oligo([0-9]+)_} $LeNomOligo tmp Nb
	    #Espionne "NOmOligo $LeNomOligo - $tmp - $Nb"
	    set OldNb $Nb
	    incr Nb
	    regsub "${OldNb}_" $LeNomOligo "${Nb}_" LeNomOligo
	} else {break} 
    }
    regsub "$OldNom" $Selection "$LeNomOligo" Selection

    Espionne "Ajoute a $FichierACharger2 $Selection"
    #AppendAuFichier $FichierACharger2 $Selection
    
    #Espionne ">>>>Adding<<<<" 
    #Espionne "$Selection"
    #Espionne ">>>>>>To<<<<<<" 
    #Espionne "$FichierACharger2\n"

    Espionne "SupprimeUnOligoPourCeuxDejaFait $FichierACharger1 $OldNom"
    Espionne "Ajoute a $FichierACharger1 $Selection"

    #SupprimeUnOligoPourCeuxDejaFait $FichierACharger1 $OldNom 
    #AppendAuFichier $FichierACharger1 $Selection
    
    return ""

}

proc AjouteUnUnderscore {Mot Position} {

    set LesLettres [split $Mot ""]
    set LeMotAvecUnderscore [linsert $LesLettres $Position  "_"]
    set MotAvecUnderscore [join $LeMotAvecUnderscore ""]
    return $MotAvecUnderscore

}

proc AjusteAngles {AId n} {

    global Abr sum

    set t [set Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return $sum}
    if {$n eq "root"} {
	AjusteAnglesRoot $AId root
	return $sum
    }

    set RR [$t get $n RightR]
    set RR [expr {$RR>[Pi]?$RR-[2Pi]:$RR}]
    set RL [$t get $n RightL]
    set RL [expr {$RL>[Pi]?$RL-[2Pi]:$RL}]
    set LR [$t get $n LeftR]
    set LR [expr {$LR>[Pi]?$LR-[2Pi]:$LR}]
    set LL [$t get $n LeftL]
    set LL [expr {$LL>[Pi]?$LL-[2Pi]:$LL}]
    set AR [$t get $n AncesR]
    set AR [expr {$AR>[Pi]?$AR-[2Pi]:$AR}]
    set AL [$t get $n AncesL]
    set AL [expr {$AL>[Pi]?$AL-[2Pi]:$AL}]
    set NdRight [$t get $n NdRight]
    set NdLeft  [$t get $n NdLeft]
    set LRLL [$t get $n LRLL]
    set RRRL [$t get $n RRRL]

    if {abs($RL-$AL) < $RRRL} {
	set RRAL 0.
    } else {
	set RRAL [expr {abs($RR-$AL)}]
	set RRAL [expr {$RRAL>[Pi]?[2Pi]-$RRAL:$RRAL}]
    }
    if {abs($LL-$RL) < $LRLL} {
	set LRRL 0.
    } else {
	set LRRL [expr {abs($LR-$RL)}]
	set LRRL [expr {$LRRL>[Pi]?[2Pi]-$LRRL:$LRRL}]
    }
    if {$LRLL > abs($LR-$AR)} {
	set ARLL 0.
    } else {
	set ARLL [expr {abs($AR-$LL)}]
	set ARLL [expr {$ARLL>[Pi]?[2Pi]-$ARLL:$ARLL}]
    }

    set AngVide [expr {$LRRL + $ARLL + $RRAL}]
    set angeq [expr {$AngVide/3.}]
    set DecTot [expr {abs($angeq-$RRAL) + abs($angeq-$LRRL) + abs($angeq-$ARLL)}]
    set sum [expr {$sum + $DecTot}]

    set tilt1 [expr {$angeq-$RRAL}]
    TiltArbre $AId $n $NdRight $tilt1

    if {$tilt1 < 0.} {
	set LRRL [expr {$LRRL+abs($tilt1)}]
    } else {
	set LRRL [expr {$LRRL-abs($tilt1)}]
    }
    set tilt2 [expr {$angeq-$LRRL}]
    TiltArbre $AId $n $NdLeft $tilt2

    puts "----- Ajsutement --------"
    puts "$n | R $NdRight | L $NdLeft"
    puts [format "RRAL %5.2f RR %5.2f AL %5.2f" $RRAL $RR $AL]
    puts [format "LRRL %5.2f LR %5.2f RL %5.2f" $LRRL $LR $RL]
    puts [format "ARLL %5.2f AR %5.2f LL %5.2f" $ARLL $AR $LL]
    puts [format "Ang Egaux : %6.2f Decal %6.2f" $angeq $DecTot]
    puts [format "tilt RRAL : %6.2f | LRRL %6.2f" $tilt1 $tilt2]
    puts [format "nRRAL %6.2f nLRRL %6.2f" [expr {$RRAL+$tilt1}] [expr {$LRRL+$tilt2}]]
    puts ""

    return $sum

}

proc AjusteAngles2 {AId n} {

    global Abr sum PVmL PVmR

    set t [set Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return $sum}
    if {$n eq "root"} {
	AjusteAnglesRoot $AId root
	return $sum
    }

    set xn [$t get $n xcoord]
    set yn [$t get $n ycoord]

    set p [$t parent $n]
    set xp [$t get $p xcoord]
    set yp [$t get $p ycoord]
    if {$xn == $xp && $yn == $yp} {
	lassign [$t children $p] e1 e2
	if {$n eq $e1} {set p $e2} {set p $e1}
	set xp [$t get $p xcoord]
	set yp [$t get $p ycoord]
    }

    set NdMaxRight [$t get $n NdRight]
    set NdMaxLeft  [$t get $n NdLeft]
    set NdAncesL   [$t get $n NdAncesL]
    set NdAncesR   [$t get $n NdAncesR]

    lassign [$t children $n] e1 e2
    if {[lsearch [concat $e1 [$t descendants $e1]] $NdMaxRight] != -1} {
	set NdR $e1
	set NdL $e2
    } else {
	set NdR $e2
	set NdL $e1
    }
    puts "NdR $NdR"
    puts "NdL $NdL"
    set NRR [$t get $NdR NdRight]
    set NRL [$t get $NdR NdLeft]
    set NLR [$t get $NdL NdRight]
    set NLL [$t get $NdL NdLeft]
    puts "NRR $NRR NRL $NRL"
    puts "NLR $NLR NLL $NLL"

    if {0} {
	set Ln [concat $NdR [$t descendants $NdR]]
	if {[llength $Ln] == 1} {
	    set NRL $Ln
	    set NRR $Ln
	} else {
	    lassign [NoeudLRDe $AId $n $p $Ln] NRL NRR
	}
    }

    set x1 [$t get $NRL xcoord]
    set y1 [$t get $NRL ycoord]
    set RL [Coords2Angle [expr {$x1-$xn}] [expr {$y1-$yn}]]

    if {0} {
	set Ln [concat $NdL [$t descendants $NdL]]
	if {[llength $Ln] == 1} {
	    set NLL $Ln
	    set NLR $Ln
	} else {
	    lassign [NoeudLRDe $AId $n $p $Ln] NLL NLR
	}
    }
    set x2 [$t get $NLR xcoord]
    set y2 [$t get $NLR ycoord]
    set LR [Coords2Angle [expr {$x2-$xn}] [expr {$y2-$yn}]]

    set LL [$t get $n LeftA]
    while {$LL > [2Pi]} {set LL [expr {$LL - [2Pi]}]}
    set RR [$t get $n RightA]
    while {$RR > [2Pi]} {set RR [expr {$RR - [2Pi]}]}

    set AL [$t get $n AncesL]
    set AR [$t get $n AncesR]

    foreach v {RR RL LR LL AL AR} {
	set $v [expr {[set $v]>[Pi]?[set $v]-[2Pi]:[set $v]}]
    }

    set RRAL [expr {$RR-$AL}]
    if {$RRAL < 0.} {set RRAL [expr {[2Pi]+$RRAL}]}
    set RRAL [expr {$RRAL>[Pi]?[2Pi]-$RRAL:$RRAL}]

    set LRRL [expr {$LR-$RL}]
    if {$LRRL < 0.} {set LRRL [expr {[2Pi]+$LRRL}]}
    set LRRL [expr {$LRRL>[Pi]?[2Pi]-$LRRL:$LRRL}]

    set ARLL [expr {$AR-$LL}]
    if {$ARLL < 0.} {set ARLL [expr {[2Pi]+$ARLL}]}
    set ARLL [expr {$ARLL>[Pi]?[2Pi]-$ARLL:$ARLL}]

    set AngVide [expr {$LRRL + $ARLL + $RRAL}]
    set angeq [expr {$AngVide/3.}]
    set DecTot [expr {abs($angeq-$RRAL) + abs($angeq-$LRRL) + abs($angeq-$ARLL)}]
    set sum [expr {$sum + $DecTot}]

    set tilt1 [expr {$angeq-$RRAL}]
    TiltArbre $AId $n $NdR $tilt1

    if {$tilt1 < 0.} {
	set LRRL [expr {$LRRL+abs($tilt1)}]
    } else {
	set LRRL [expr {$LRRL-abs($tilt1)}]
    }
    set tilt2 [expr {$angeq-$LRRL}]
    TiltArbre $AId $n $NdL $tilt2

    puts "----- Ajsutement --------"
    puts "$n | R $NdR | L $NdL"
    puts [format "Nd RR %6.3f %s Nd RL %6.3f %s" $RR $NRR $RL $NRL]
    puts [format "Nd LR %6.3f %s Nd LL %6.3f %s" $LR $NLR $LL $NLL]
    puts [format "Nd AL %6.3f %s Nd AR %6.3f %s" $AL $NdAncesL $AR $NdAncesR]
    puts [format "RRAL %6.3f RR %6.3f AL %6.3f" $RRAL $RR $AL]
    puts [format "LRRL %6.3f LR %6.3f RL %6.3f" $LRRL $LR $RL]
    puts [format "ARLL %6.3f AR %6.3f LL %6.3f" $ARLL $AR $LL]
    puts [format "Ang Egaux : %6.3f Decal %6.3f" $angeq $DecTot]
    puts [format "tilt RRAL : %6.3f | LRRL %6.3f" $tilt1 $tilt2]
    puts [format "nRRAL %6.3f nLRRL %6.3f" [expr {$RRAL+$tilt1}] [expr {$LRRL+$tilt2}]]

    return $sum

}

proc AjusteAnglesRoot {AId n} {

    global Abr sum

    set t [set Abr(Arbre,$AId)]
    set xp [$t get $n xcoord]
    set yp [$t get $n ycoord]
    lassign [$t children $n] e1 e2

    set x [$t get $e1 xcoord]
    set y [$t get $e1 ycoord]
    if {$x == $xp && $y == $yp} {set p $e2} {set p $e1}

    if {! [$t isleaf $e1]} {
	set Ln [concat $e1 [$t descendants $e1]]
	lassign [NoeudLRDe $AId $e1 $p $Ln] NL1 NR1 
    } else {
	set NL1 $e1
	set NR1 $e1
    }

    if {! [$t isleaf $e2]} {
	set Ln [concat $e2 [$t descendants $e2]]
	lassign [NoeudLRDe $AId $e2 $p $Ln] NL2 NR2
    } else {
	set NR2 $e2
	set NL2 $e2
    }
    lassign [OverlapBranch $AId $NL1 $NR1 $NL2 $NR2] o1 o2 
    #    puts "OverlapBranch $o1 $o2"

    set R1 [$t get $e1 RightA]
    set L1 [$t get $e1 LeftA]
    set R2 [$t get $e2 RightA]
    set L2 [$t get $e2 LeftA]
    foreach v {R1 L1 R2 L2} {
	while {[set $v] > [2Pi]} {set $v [expr {[set $v]-[2Pi]}]}
	set $v [expr {[set $v]>[Pi]?[set $v]-[2Pi]:[set $v]}]
    }

    set L1R2 [expr {abs($L1-$R2)}]
    if {$L1R2 > [Pi]} {set L1R2 [expr {[2Pi]-$L1R2}]}

    set L2R1 [expr {abs($L2-$R1)}]
    if {$L2R1 > [Pi]} {set L2R1 [expr {[2Pi]-$L2R1}]}

    set AngVide [expr {$L1R2 + $L2R1}]
    set angeq [expr {$AngVide/2.}]
    set DecTot [expr {abs($angeq-$L1R2) + abs($angeq-$L2R1)}]
    set sum [expr {$sum + $DecTot}]

    if {[$t size $e1] < [$t size $e2]} {
	set AngT $L1R2
	set NdT $e1
    } else {
	set AngT $L2R1
	set NdT $e2
    }
    set tilt1 [expr {$angeq-$AngT}]
    TiltArbre $AId root $NdT $tilt1

    puts "----- ROOT Ajsutement --------"
    puts "$n | E1 $e1 | E2 $e2"
    puts [format "L1R2 %6.3f L1 %6.3f L2 %6.3f" $L1R2 $L1 $R2]
    puts [format "L2R1 %6.3f L2 %6.3f R1 %6.3f" $L2R1 $L2 $R1]
    puts [format "Ang Egaux : %6.3f Decal %6.3f" $angeq $DecTot]
    puts [format "tilt LRRL : %6.3f Nd tilt %s" $tilt1 $NdT]
    puts [format "nAngT %6.3f" [expr {$AngT+$tilt1}]]

    return $sum

}

proc AjusteCoordonneesInit {AId} {

    global Abr

    set t   [set Abr(Arbre,$AId)]
    set PWd [set Abr($AId,PADWdt)]
    set PHg [set Abr($AId,PADHgt)]
    set Wdt [set Abr($AId,FWidth)]
    set Hgt [set Abr($AId,FHeight)]
    set LongNom [PlusLongNomAff $AId]

    if {! [info exists Abr($AId,DMult)]} {
	#	set mult [expr {($Wdt-2*$LongNom)/[set Abr($AId,Dmax)]}]
	set mult [expr {($Wdt-2*$LongNom)/[set Abr($AId,rmax)]}]
	set Abr($AId,DMult) $mult
    }

    set Xmin  99999999.
    set Ymin  99999999.
    set Xmax -99999999.
    set Ymax -99999999.
    set m [set Abr($AId,DMult)]
    foreach d [$t nodes] {
	set x [expr {[$t get $d xcoord]*$m}]
	set y [expr {[$t get $d ycoord]*$m}]
	$t set $d xdes $x
	$t set $d ydes $y

	set Xmin [expr {$Xmin<$x?$Xmin:$x}]
	set Ymin [expr {$Ymin<$y?$Ymin:$y}]
	set Xmax [expr {$Xmax>$x?$Xmax:$x}]
	set Ymax [expr {$Ymax>$y?$Ymax:$y}]
    }

    set Abr($AId,XminR) $Xmin
    set Abr($AId,YminR) $Ymin
    set Abr($AId,XmaxR) $Xmax
    set Abr($AId,YmaxR) $Ymax

    return

}

proc AjusteCoordonneesInit2 {AId} {

    global Abr

    set t   [set Abr(Arbre,$AId)]
    set PWd [set Abr($AId,PADWdt)]
    set PHg [set Abr($AId,PADHgt)]
    set Wdt [set Abr($AId,FWidth)]
    set Hgt [set Abr($AId,FHeight)]
    set sca [set Abr($AId,ScaleR)]
    set LongNom [PlusLongNomAff $AId]

    #    set HgF   [font metrics "TreeFont$AId" -linespace]
    set HgF  [font configure "TreeFont$AId" -size]
    set rmin [set Abr($AId,rmin)]
    set rmax [set Abr($AId,rmax)]
    set sang [set Abr($AId,subangleMax)]
    set mult [expr {abs($HgF/($rmax*sin($sang)))}]

    if {0} {
	puts "PWd $PWd PHg $PHg Wdt $Wdt Hgt $Hgt"
	puts "HgF $HgF"
	puts "rmin $rmin"
	puts "rmax $rmax"
	puts "sang $sang"
	puts "mult $mult"
	puts "long Nom $LongNom"
	puts ""
    }

    # Taille de arbre sans les noms au bout
    # des feuilles
    set Xmin  99999999.
    set Ymin  99999999.
    set Xmax -99999999.
    set Ymax -99999999.
    foreach d [$t nodes] {
	set x [expr {$mult*[$t get $d xcoord]}]
	set y [expr {$mult*[$t get $d ycoord]}]
	#	set x [expr {$sca*$mult*[$t get $d xcoord]+$LongNom}]
	#	set y [expr {$sca*$mult*[$t get $d ycoord]+$LongNom}]
	$t set $d xcoord $x
	$t set $d ycoord $y

	set Xmin [expr {$Xmin<$x?$Xmin:$x}]
	set Ymin [expr {$Ymin<$y?$Ymin:$y}]
	set Xmax [expr {$Xmax>$x?$Xmax:$x}]
	set Ymax [expr {$Ymax>$y?$Ymax:$y}]
    }

    if {0} {
	puts "Min/Max SANS FEUILLES"
	puts "Xmin $Xmin"
	puts "Ymin $Ymin"
	puts "Xmax $Xmax"
	puts "Ymax $Ymax"
	puts ""
    }

    # Recentre Arbre sans feuille
    foreach d [$t nodes] {
	set x [expr {[$t get $d xcoord]-$Xmin}]
	set y [expr {[$t get $d ycoord]-$Ymin}]
	$t set $d xcoord $x
	$t set $d ycoord $y
    }

    set Xmin 0.
    set Ymin 0.
    set Xmax [expr {$Xmax-$Xmin}]
    set Ymax [expr {$Ymax-$Ymin}]

    set DX [expr {$Xmax-$Xmin}]
    set DY [expr {$Ymax-$Ymin}]
    set PlacePW [expr {$PWd - 2*$LongNom}]
    set PlacePH [expr {$PHg - 2*$LongNom}]
    if {$DX > $PlacePW || $DY > $PlacePH} {
	if {$DX - $PlacePW > $DY - $PlacePH} {
	    set mult [expr {$PlacePW/$DX}]
	} else {
	    set mult [expr {$PlacePH/$DY}]
	}
    }
    set PlaceSW [expr {$Wdt - 2*$LongNom}]
    set PlaceSH [expr {$Hgt - 2*$LongNom}]
    if {$DX < $PlaceSW && $DY < $PlaceSH} {
	if {$PlaceSW-$DX > $PlaceSH-$DY} {
	    set mult [expr {$PlaceSH/$DY}]
	} else {
	    set mult [expr {$PlaceSW/$DX}]
	}
    }
    #    puts "mult apres $mult"

    set NXmin  99999999999.
    set NYmin  99999999999.
    set NXmax -99999999999.
    set NYmax -99999999999.
    foreach d [$t nodes] {
	set OldX [$t get $d xcoord]
	set OldY [$t get $d ycoord]
	set x [expr {$mult*$OldX + $LongNom}]
	set y [expr {$mult*$OldY + $LongNom}]
	$t set $d xcoord $x
	$t set $d ycoord $y
	if {[$t isleaf $d]} {
	    lassign [CoordsNom $AId $d $x $y] x y
	}

	set NXmin [expr {$NXmin<$x?$NXmin:$x}]
	set NYmin [expr {$NYmin<$y?$NYmin:$y}]
	set NXmax [expr {$NXmax>$x?$NXmax:$x}]
	set NYmax [expr {$NYmax>$y?$NYmax:$y}]
    }

    set Abr($AId,XminR) $NXmin
    set Abr($AId,YminR) $NYmin
    set Abr($AId,XmaxR) $NXmax
    set Abr($AId,YmaxR) $NYmax

    if {0} {
	puts "Abr($AId,Xmin) $Xmin"
	puts "Abr($AId,Ymin) $Ymin"
	puts "Abr($AId,Xmax) $Xmax"
	puts "Abr($AId,Ymax) $Ymax"
	puts ""
    }

    return

}

proc AjusteScrollRegion {AId} {

    global Abr

    set PAD [set Abr($AId,PAD)]
    set Lal [$PAD bbox all]
    lassign $Lal x1 y1 x2 y2
    set Dx  [expr {$x2-$x1}]
    set Dy  [expr {$y2-$y1}]
    $PAD configure -scrollregion [list $x1 $y1 $Dx $Dy]

    update idletasks

    return

}

proc AjusteXY {AId n px py {mult 1.}} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    foreach xa {xO xE} ya {yO yE} {
	set x [$t get $n $xa]
	set y [$t get $n $ya]
	set nx [expr {($x+$px)*$mult}]
	set ny [expr {($y+$py)*$mult}]
	$t set $n $xa $nx
	$t set $n $ya $ny
    }

    foreach e [$t children $n] {
	AjusteXY $AId $e $px $py $mult
    }

    return

}

proc AjusteXYCart {AId n mx my {mult 1.}} {

    global Abr
    global Xmin Xmax Ymin Ymax

    set t  [set Abr(Arbre,$AId)]
    set x  [$t get $n xcoord]
    set y  [$t get $n ycoord]
    set nx [expr {(($x+abs($Xmin))*$mx)*$mult}]
    set ny [expr {(($y+abs($Ymin))*$my)*$mult}]
    $t set $n xcoord $nx
    $t set $n ycoord $ny

    set Xmin [expr {$Xmin<$nx?$Xmin:$nx}]
    set Ymin [expr {$Ymin<$ny?$Ymin:$ny}]
    set Xmax [expr {$Xmax>$nx?$Xmax:$nx}]
    set Ymax [expr {$Ymax>$ny?$Ymax:$ny}]

    foreach e [$t children $n] {
	AjusteXYCart $AId $e $mx $my $mult
    }

    return

}

proc AlA {{file ""} args} {

    global LNOrdali Sequences NbSeq Mbl LSOrdali WeightMotif Sref MotifLen Lscores WeightCols LgMax MblNeg Cbl NbSeq

    # positive si 1, matrix , scale 1.
    array set Cbl    [InitPAM35]
    array set Mbl    [InitClustalMatrix blosum62 1 1.]
    array set MblNeg [InitClustalMatrix blosum62 0 1.]

    LesDefsAlA
    
    # inits
    InitSeuils
        
    set RenameSeq   1

    # 1: poids gaussiens, 0 : 1.0 pour chqeue pos
    #InitWg 1
    InitWg 0

    AlACommandLineOptions $args
    puts "Inits done ..."
    
    set Lscores [list]
    
    set ok [SequencesPourAgent $file $RenameSeq]
    if {$ok == 0} {
	return 0
    }
    puts "Sequences :\n[join $LNOrdali \n]"

    puts "\n-------------------------"
    puts "| Score Ref : [ScoreAlignmentAgents Sref]"
    puts "-------------------------\n"
    puts "Nombre seqs   : $NbSeq"
    set LgMax 0
    foreach s $LSOrdali {
	incr LgMax [string length [string map {"." ""} $s]]
    }
    puts "Long. cumulee : $LgMax"

    #PrepareSequencesAgents
    AgentsRemoveColsGaps

    puts "Start init agents ...."
    InitAgents
    puts "done !"

    GUIAgents

    set ::iter 0

    #BruteForceAgents
    BruteForceAgents2
    #exit
    #RunAgents
    
    return 1

}

proc AlACommandLineOptions {args} {

    #puts "args $args"
    set args [lindex $args 0]
    #puts "[llength $args]"
    if {$args == "{}" } {
	return
    }

    if {[llength $args] % 2} {
	puts "Bad number of arguments ! Key-value "
	exit
    }

    foreach {key value} $args {
	switch $key {
	    "-wmotif" {
		set ::WeightMotif $value
	    }
	    "-initw" {
		InitWg $value
	    }
	    "-wcols" {
		set ::WeightCols $value
	    }
	    "-gui" {
		set ::WithGUI $value
		set ::StepMode 1
	    }
	    "-lenmotif" {
		set ::MotifLen $value
	    }
	}
    }

    return

}

proc Aleatoire {{Min 0} {Max 1}} {

    set Alea [expr round(rand() * ($Max - $Min)) + $Min]

}

proc AlgoGenet {NbIndiv NbMilliSecMax} {

    set LesPhrasesIni [LesPhrasesMemorisees]

    #genere une pop aleatoire de NbIndiv
    set LesIndividus  [InitPop $NbIndiv]

    #genere un maximum d'individu aleatoirement en NbMilliSecMax msec
    #lorsque l'un d'entre eux est meilleur que le moins bon de la pop
    #il le remplace alors
    Espionne "Old Best : [lindex [lindex $LesIndividus 0] 0]"

    set LesIndividus  [PopAleatoire  $LesIndividus $NbMilliSecMax]

    ##On ne garde que les meilleurs individus
    set LesPhrasesFinales {}
    set ScoreMax [lindex [lindex $LesIndividus 0] 0]
    foreach LIndiv $LesIndividus {
	set Score [lindex $LIndiv 0]
	if {$Score < $ScoreMax} {continue}
	lappend LesPhrasesFinales [join [lrange $LIndiv 1 end] " "]
    }

    ##On determine parmi les meilleurs celui qui est plus proche des phrases initiales
    return [MeilleurePhrase $LesPhrasesFinales $LesPhrasesIni]

}

proc AliCartoon {} {

    #rR c'est pour faire une petite animation d'un alignement (pour Renaud) 
    #rR  on part de l'alignemnet et on le des-aligne ... ;-)

    set K [UnCanva 200 1600 200 200]

    lappend Ali "..QLKIPV.YV.SLTNQTAKE"
    lappend Ali "TAQVKIQ........NQTAKE"
    lappend Ali "...VKIQVHYVDSLTNQ"

    set LargAli 0
    foreach Seq $Ali {
	set LargAli [expr max($LargAli,[string length $Seq])]
    }
    set I 0
    foreach Seq $Ali {
	set S($I) "$Seq[string repeat . [expr $LargAli-[string length $Seq]]]"
	incr I
    }

    set LesGaps {}
    foreach I [array names S] {
	set J 0
	foreach AA [split $S($I) ""] {
	    if { ! [regexp {[^\.]} [string range $S($I) $J end]]} { break }
	    if {$AA=="."} { lappend LesGaps "$I $J" }
	    incr J
	}
    }

    set N [llength $LesGaps]
    set CSGX 20
    set CSGY [expr 20 + $N*50]

    set DeplacementY 0
    set CSGY [expr 20]

    set Tic 0
    while {1} {
	Cartoon $K S $CSGX $CSGY ;  incr CSGY $DeplacementY
	FaireLire "Au suivant"
	if {$LesGaps=={}} { break }
	set L [llength $LesGaps]
	set Z [expr round(floor(rand()) * $L)]
	lassign [lindex $LesGaps $Z] I J
	set S($I) "[string replace $S($I) $J $J]."
	set LesGaps {}
	foreach I [array names S] {
	    set J 0
	    foreach AA [split $S($I) ""] {
		if { ! [regexp {[^\.]} [string range $S($I) $J end]]} { break }
		if {$AA=="."} { lappend LesGaps "$I $J" }
		incr J
	    }
	}
    }

}

proc AliFastaToAliBlast {AlignementFasta DQuery FQuery DSbjct FSbjct} {

    set NbCaractParLigne 60

    regsub -all ":" $AlignementFasta "\|" AlignementFasta

    set Blanc " "
    set LesLignes [split $AlignementFasta "\n"]
    set LaQuery   [split [string trim [lindex $LesLignes 0]] ""  ]
    set LesBarres [split [string trim [lindex $LesLignes 1]] ""  ]
    set LeSbjct   [split [string trim [lindex $LesLignes 2]] ""  ]

    set TailleDebut [string length [lindex [lsort -integer -decreasing [list $DQuery $DSbjct $FQuery $FSbjct]] 0]]
 
    set PremiereHomologie [lsearch $LesBarres "|"]

    set i 0
    set n $PremiereHomologie
    foreach Barre $LesBarres {
	if {$Barre  == "|"} {set n $i}   
	incr i
    }
    set DerniereHomologie $n

    set LaQuery   [lrange $LaQuery   $PremiereHomologie $DerniereHomologie]
    set LesBarres [lrange $LesBarres $PremiereHomologie $DerniereHomologie]
    set LeSbjct   [lrange $LeSbjct   $PremiereHomologie $DerniereHomologie]

    set i 0
    set AliBlast ""
    set LigneQuery   "" 
    set LigneBarres  ""
    set LigneSbjct   ""

    set DQ $DQuery
    set DS $DSbjct

    foreach ANQuery $LaQuery Barres $LesBarres ANSbjct $LeSbjct {
	incr i
	if {$i == $NbCaractParLigne} {
	    append LigneQuery  $ANQuery
	    append LigneBarres $Barres
	    append LigneSbjct  $ANSbjct

	    set n 0
	    foreach AN [split $LigneQuery ""] {
		if {![regexp -nocase {[ATGCNXMKRSYWVHDB]} $AN]} {continue}
		incr n
	    }
	    if {$DQuery < $FQuery} {set FQ [expr $DQ + $n - 1]} else {set FQ [expr $DQ - $n + 1]}

	    set n 0
	    foreach AN [split $LigneSbjct ""] {
		if {![regexp -nocase {[ATGCNXMKRSYWVHDB]} $AN]} {continue}
		incr n
	    }
	    if {$DSbjct < $FSbjct} {set FS [expr $DS + $n - 1]} else {set FS [expr $DS - $n + 1]}

	    set LigneQuery  [format "Query: %-${TailleDebut}d %s %d" $DQ    $LigneQuery $FQ]
	    set LigneBarres [format "%[expr $TailleDebut + 7]s %s"  $Blanc $LigneBarres   ]
	    set LigneSbjct  [format "Sbjct: %-${TailleDebut}d %s %d" $DS    $LigneSbjct $FS] 


	    if {$DQuery < $FQuery} {set DQ [expr $FQ+1]} else {set DQ [expr $FQ-1]}
	    if {$DSbjct < $FSbjct} {set DS [expr $FS+1]} else {set DS [expr $FS-1]}

	    append AliBlast "$LigneQuery\n$LigneBarres\n$LigneSbjct\n\n\n"

	    set LigneQuery  ""
	    set LigneBarres ""
	    set LigneSbjct  ""
	    set i 0
	    continue
	}
	append LigneQuery  $ANQuery
	append LigneBarres $Barres
	append LigneSbjct  $ANSbjct

    }
    if {$LigneQuery != ""} {
	set LigneQuery  [format "Query: %-${TailleDebut}d %s %d" $DQ    $LigneQuery $FQuery]
	set LigneBarres [format "%[expr $TailleDebut + 7]s %s"  $Blanc $LigneBarres   ]
	set LigneSbjct  [format "Sbjct: %-${TailleDebut}d %s %d" $DS    $LigneSbjct $FSbjct] 
	append AliBlast "$LigneQuery\n$LigneBarres\n$LigneSbjct\n\n"
    }
    return $AliBlast

}

proc AliTest {{Option genomes} {organism mouse} {BirdVersion bird}} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]	
	Espionne "$timestamp|AliTest : Start"
	set Path "/tmp/BirdCird"
#	set FichierDesCoord [open "$Path.txt" "r"]
	set FichierDesRequetes [open "$Path.sql" "w"]
	#ScanLaListe $Ligne Id Chromosome Start End
	#puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucschuman.alignements, ucschuman.alignements_sequences WHERE  ali_startq < $Start AND ali_endq > $End AND (ali_access = as_access) " 
	#puts $FichierDesRequetes "WH SQLNATIVE SELECT as_access FROM ucschuman.alignements_sequences where as_access NOT IN (select ali_access from ucschuman.alignements)" 
	#puts $FichierDesRequetes "WH SQLNATIVE SELECT count(*) FROM ucschuman.alignements where ali_access NOT IN (select as_access from ucschuman.alignements_sequences) " 
	#puts $FichierDesRequetes "WH SQLNATIVE SELECT ali_access, count(*) from ucschuman.alignements group by ali_access having count(*) > 1"
	if { $Option == "count" } {
		#puts $FichierDesRequetes ID * DB UCSC"
		#puts $FichierDesRequetes WH SQLNATIVE SELECT ali_genomet FROM ucsc$Organismet.alignements WHERE ali_access NOT in (select as_access from ucsc$Organismet.alignements_sequences)"
		#puts $FichierDesRequetes LM 30"
		
		puts $FichierDesRequetes "ID * DB UCSC"
		puts $FichierDesRequetes "WH SQLNATIVE SELECT count(*) FROM ucsc$organism.alignements"
		puts $FichierDesRequetes "LM 30"
		puts $FichierDesRequetes "//"

	} else { if { $Option == "genomes" } {
				puts $FichierDesRequetes "ID * DB UCSC"
				puts $FichierDesRequetes "WH SQLNATIVE SELECT ali_organismet FROM ucsc$organism.alignements group by ali_organismet" 
				puts $FichierDesRequetes "LM 30"
				puts $FichierDesRequetes "//"
			}
	}
	close $FichierDesRequetes
	exec /biolo/bird/bin/birdql_client.sh "$Path.sql" bird "$Path.res"
	set FichierDesRequetesExecutees [open "$Path.res" "r"]
	while { [gets $FichierDesRequetesExecutees Ligne]  >=0 } {
		Espionne $Ligne
	}
	close $FichierDesRequetesExecutees
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]	
	Espionne "$timestamp|AliTest : End"

}

proc Alias {Nom} {

    return [ExtraitInfo $Nom "Alias"]

}

proc AliasAlias {A {Lequel ""} {Append ""}} {

    global AliasAlias

    if {$Append==""} { set Append "NoAppend" }
    set Append [string equal -nocase $Append "Append"]

    if {$Lequel==""} { set Lequel "Gscope" }

    if {[info exists AliasAlias($A,$Lequel)]} { return $AliasAlias($A,$Lequel) }
    if {[info exists AliasAlias("EstCharge")]} { return "" }

    set LesAliasGscope [lsort -dictionary [LesAliasExistants]]
    set FichierAliasAlias "[RepertoireDuGenome]/fiches/AliasAlias"
    if {[FileExists $FichierAliasAlias]} {
	array set AliasAlias [LesLignesDuFichier $FichierAliasAlias]
    }
    set AliasAlias("EstCharge") 1
    if { ! $Append } { return [AliasAlias $A $Lequel] }

    foreach VE [VEDidier ListeDes VE] {
	Espionne $VE
	set ProtName [VEDidier $VE ProtName]
	set Organism [VEDidier $VE Organism]
	set Original $ProtName
	set ProtName [string trim $ProtName]
	regsub { [^ ]$} $ProtName "" ProtName
	set ProtOrga "${ProtName}_$Organism"
	regsub -all " " $ProtOrga "_" ProtOrga
	if {[info exists AliasAlias($ProtOrga,Gscope)]} { continue }
	Espionne "$ProtOrga"
	set LesAliasLesPlusProches [LesAliasLesPlusProches $ProtOrga]
	if {0 && [string equal $ProtName [lindex $LesAliasLesPlusProches 0]]} {
	    set AliasAlias($ProtOrga,Gscope) $AliasGscope
	    set AliasAlias($AliasGscope,Didier) $ProtOrga
	    continue
	}
	set Ligne [VEDidier $VE]
	while 1 {
	    set Meilleur [ChoixParmi [concat [list SaveAndQuit $ProtOrga $Ligne "****"]  $LesAliasLesPlusProches [list "******"] $LesAliasGscope]]
	    if {[regexp "SaveAndQuit" $Meilleur]} {
		if {[OuiOuNon "Do I save and quit ?"]} { break }
		continue
	    }
	    break
	}
	if {[regexp "SaveAndQuit" $Meilleur]} { break }
	set AliasAlias($ProtOrga,Gscope) $Meilleur
	set AliasAlias($Meilleur,Didier) $ProtOrga
    }
    foreach {C V} [array get AliasAlias] {
	ScanLaListe [split $C ","] POA Qui
	if {$Qui=="Gscope"} { lappend LesDidier $POA }
	if {$Qui=="Didier"} { lappend LesGscope $POA }
    }
    set AliasAlias(ListeDes,Gscope) [lsort $LesGscope]
    set AliasAlias(ListeDes,Didier) [lsort $LesDidier]

    SauveLesLignes [array get AliasAlias] dans $FichierAliasAlias
    return [AliasAlias $A $Lequel]

}

proc AliasDansTfaPourTous {} {

    if { ! [OuiOuNon "This proc read the 'alias' in the prottfa file.\n Please verify the source sode if it corresponds to what you need\n Do I continue ?"]} { return }

    foreach Nom [ListeDesPABs] {
	set FichierTfa "[RepertoireDuGenome]/prottfa/$Nom"
	if { ! [file exists $FichierTfa]} { continue }
	set Ent [EnteteDuFichierTFA $FichierTfa]
	if {[OuiOuNonMemo "Do I take the second word of the tfa file as the Alias?"]} {
	    set A ""
	    scan $Ent "%s %s" CN A
	    regsub ">" $CN "" NomLu
	    if {$NomLu!=$Nom} { FaireLire "$Nom has following line\n$Ent" }
	    InformeSansDemander $Nom "Alias: $A"
	    continue
	}
	continue
	set Seq [QueLaSequenceDuFichierTFA $FichierTfa]
	set BonTFA [SequenceFormatTFA [string toupper $Seq] "$Nom $A" "protbrut"]
	Espionne [Sauve $BonTFA dans $FichierTfa]
    }

}

proc AliasGeneNames {Nom} {

    set LesGn {}
    foreach PossibleAlias [list "AliasGnRna:" "AliasGnProt:" "AliasGnHuman:"] {
	LConcat LesGn [split [ExtraitInfo $Nom $PossibleAlias] " "]
    }
    set LesAliasGn {}
    set DejaVu([string toupper [ValiGN $Nom]]) 1
    foreach Gn $LesGn {
	set GN [string toupper $Gn]
	if {[info exists DejaVu($GN)]} { continue }
	set DejaVu($GN) $Gn
	lappend LesAliasGn $Gn
    }
    return $LesAliasGn

}

proc AliasManquants {} {

    foreach VE [VEDidier ListeDes VE] {
	set D [VEDidier $VE "ProtName"]
	set O [VEDidier $VE "Organism"]
	set DO "$D$O"
	regsub -all " " $DO "_" DO
	set VEDuAlias($DO) $VE
    }

    foreach D [AliasAlias ListeDes Didier] {
	set G [AliasAlias $D Gscope]
	if {[AliasAlias $D Gscope]!=""} { continue }
	set Scientist "Scientist unknown" 
	if {[info exists VEDuAlias($D)]} {
	    set VE $VEDuAlias($D)
	    set Scientist [VEDidier $VE Scientist]
	}
	Espionne "$D $Scientist"
    }
    exit

}

proc AliasParNomDuFichier {} {

    set FichierFOF [ButineArborescence All "[RepertoireDuGenome]"]
    foreach Ligne [LesLignesDuFichier $FichierFOF] Nom [ListeDesPABs] {
	scan $Ligne "%s %s" AliasLu FicLu
	set Nouveau [file tail $FicLu]
	if {0 && [Alias $Nom]!=$AliasLu} {
	    FaireLire "Attention pour $Nom $AliasLu != [Alias $Nom]"
	}
	Espionne "InformeSansDemander $Nom =Alias: $Nouveau"
	InformeSansDemander $Nom "=Alias: $Nouveau"
    }
    exit

}

proc AliasPourClonage {Nom} {

    global AliasPourClonage
    if {[info exists AliasPourClonage($Nom)]} { return [set AliasPourClonage($Nom)] }
    set Alias ""
    if {$Alias==""} { set Alias [Alias $Nom] }
    if {$Alias==""} { set Alias [Narcisse $Nom] }
    if {$Alias==""} { set Alias $Nom }
    set AliasPourClonage($Nom) $Alias
    return $Alias

}

proc AliasPourTous {} {

    global RepertoireDuGenome
    
    FaireLire "Please browse for the file .fof containing 'Alias ... ... ...'"
    set FOF [ButineArborescence "All" "$RepertoireDuGenome"]
    set Numero 0
    foreach Ligne [LesLignesDuFichier $FOF] {
	if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
	
	catch {unset Nom}
	catch {unset Ver}
	catch {unset OrigineBlastP}
	catch {unset OrigineBallast}
	catch {unset OrigineMSF}  
	set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
	if {$NbLus < 2} {
	    if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit } 
	    continue
	}
	
	set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] [incr Numero]]

	InformeSansDemander $Nom "=Alias: $Alias"
    }


}

proc AlignAgent {} {

    global iTag 

    set chx [chooseCouple]
    lassign $chx seq1 ag1 seq2
    puts "choose $chx"

    lassign [FindAgentFriend {*}$chx] ag2 score seuil

    if {$::debug} {
	DebugAgents $seq1 $ag1 $seq2 $ag2 $score $seuil
    }
    
    if {$ag2 eq "skip"} {
	#.l configure -background "#770000"
	append ::Lab " ==> SKIP $seq1 $::TAg($ag1,$seq1,seq)"
	return -1
    }

    #.l configure -background black
    append ::Lab " $seq1 $::TAg($ag1,$seq1,seq) $seq2 $::TAg($ag2,$seq2,seq) [format %6.3f $score]"

    if {$::StepMode} {
	puts "\nSHOW 1"
	set iTag 0
	ShowPairGUIAgent $seq1 $ag1 $seq2 $ag2
	MemorisePair $seq1 $ag1 $seq2 $ag2
    }
    
    set move [ShouldMoveAgents $seq1 $ag1 $seq2 $ag2]
    if {$move} {
	SlideAgent $seq1 $ag1 $seq2 $ag2
	if {$::StepMode} {
	    UpdateGUI
	    set iTag 0
	    ShowPairGUIAgent $seq1 $ag1 $seq2 $ag2 2
	}
	AgentsRemoveColsGaps
	UpdateGUI
    }
    
    return $move

}

proc AlignQueryVsMACS {{FichierTFA ""} {FichierMSF ""} {OutputMSF ""}} {


    Wup "Permet d aligner une sequence au format Fasta contre un MACS de reference"
    Wup "L alignement est realise par clustalw et le mode profile"
    
    if {$FichierMSF=="" || $FichierTFA=="" || $OutputMSF==""} {return "-1"}

    #Alignement de la sequence du fichier TFA contre le MACS
    set Output_Profile  ""
    set Clustal_Profile "clustalw"
    #set Clustal_Profile "/biolo/clustal/bin/clustalw"
    if {[catch {set Output_Profile  [exec  $Clustal_Profile  -profile1=$FichierMSF  -profile2=$FichierTFA  -sequences  -output=gcg  -outfile=$OutputMSF ]} Message]} {

	Espionne ">>>AlignQueryVsMACS $FichierMSF"
	Espionne "pb $Message"
	return "-1"
    } else {
	set FichierDND $FichierTFA
	regsub -nocase ".tfa$" $FichierDND ".dnd" FichierDND
	if {[file exists $FichierDND]} {
	    file delete -force $FichierDND
	}
	return "1"
    }

}

proc AlignRDNA2Prot {p r} {

    # first check length
    set pdg [string map [list "." ""] $p]
    # stop codon
    set Lstop [list tag taa tga TAG TAA TGA]
    if {[string range $r end-2 end] in $Lstop} {
	set r [string range $r 0 end-3]
    }

    # diff of 3 may be due to missing initiaor M
    if {abs( ([string length $pdg]*3) - [string length $r]) == 3} {
	# May be a missing leading M
	if {[string index $p 0] ne "M" && [string range $r 0 2] in [list atg ATG]} {
	    set r [string range $r 3 end]
	}
    }
    if {([string length $pdg]*3) != [string length $r]} {
	puts "PB ! RNA [string length $r] Prot [expr {[string length $pdg]*3}]"
	return ""
    }

    set i 0
    set Lc [split $p ""]
    set al ""
    foreach c $Lc {
	if {$c eq "."} {
	    append al "..."
	} else {
	    append al [string range $r [expr {$i*3}] [expr {$i*3+2}]]
	    incr i
	}
    }

    return $al

}

proc Aligne3PdeADN {Nom Devant DebutDevant FinDevant Derriere DebutDerriere FinDerriere Orient} {


    global RepertoireDuGenome
    global Commandes
    global ADN TDN RAC
    global NePlusFaireAligne3P

    if { ! [info exists NePlusFaireAligne3P]} { set NePlusFaireAligne3P 1 }

    if { $Orient == "F" } {
	set ListeDes3Frames {a b c}
    } else {
	set ListeDes3Frames {f e d}
    }

    if { $NePlusFaireAligne3P || ! [OuiOuNon "Je lance 3 alignements ?"]} {
	return "a faire."
    }

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set NomDesSequences ""

    if {[YaPABdans $Nom]} {
	set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
    }
    if {[regexp "TROU" $Nom]} {
	set FichierBlast "$RepertoireDuGenome/trousblastp/$Nom"
    }

    if { $Devant == "Laisser" } {
	set SequenceDevant [BoutADN $DebutDevant $FinDevant $Orient]
    }
    set LongueurPepDevant [expr ($FinDevant-$DebutDevant+1)/3]

    if { $Derriere == "Laisser" } {
	set SequenceDerriere [BoutADN $DebutDerriere $FinDerriere $Orient]
    }
    set LongueurPepDerriere [expr ($FinDerriere-$DebutDerriere+1)/3]

    set Sens [expr $Orient=="F" ? -1 : 1]
    foreach Frame $ListeDes3Frames {
	set CasseDevant "toupper"
	if { $Devant == "Changer" } {
	    incr DebutDevant $Sens 
	    incr FinDevant $Sens
	    set SequenceDevant [BoutADN $DebutDevant $FinDevant $Orient]
	    set SequenceDevant [string tolower $SequenceDevant]
	    set CasseDevant "tolower"
	    set NomDeLaSequence "${Nom}_${LongueurPepDevant}_${Frame}"
	}
	set CasseDerriere "toupper"
	if { $Derriere == "Changer" } {
	    incr DebutDerriere $Sens 
	    incr FinDerriere $Sens
	    set SequenceDerriere [BoutADN $DebutDerriere $FinDerriere $Orient]
	    set SequenceDerriere [string tolower $SequenceDerriere]
	    set CasseDerriere "tolower"
	    set NomDeLaSequence "${Nom}_${Frame}_${LongueurPepDerriere}"
	}
	append NomDesSequences "$NomDeLaSequence "
	set SequenceADN "$SequenceDevant$SequenceDerriere"

	set SeqGCG [NucToGCG $SequenceADN $NomDeLaSequence]

	set iPP [string first "\.\." $SeqGCG]
	set EncoreDevant $LongueurPepDevant 
	set EncoreDerriere $LongueurPepDerriere 
	catch {unset VraiDebutDevant VraiDebutDerriere}
	for {set i $iPP} {$i < [string length $SeqGCG]} {incr i} {
	    if {[regexp {[a-zA-Z\*]} [string range $SeqGCG $i $i]]} {
		if { $EncoreDevant } {
		    if { ! [info exists VraiDebutDevant]} {
			set VraiDebutDevant $i
		    }
		    set VraiFinDevant $i
		    incr EncoreDevant -1
		} else {
		    if { $EncoreDerriere } {
			if { ! [info exists VraiDebutDerriere]} {
			    set VraiDebutDerriere $i
			}
			set VraiFinDerriere $i
			incr EncoreDerriere -1
		    }
		}
	    }
	}
	set LowerSeqGCG " [string range $SeqGCG  0 [expr $VraiDebutDevant-1]] [string $CasseDevant   [string range $SeqGCG $VraiDebutDevant $VraiFinDevant]] [string $CasseDerriere [string range $SeqGCG $VraiDebutDerriere end]]"
	set iL [expr [string first "Length" $LowerSeqGCG]-1]
	set BonneSeqGCG "$NomDeLaSequence[string range $LowerSeqGCG $iL end]"
	set FichierPEP [Sauve $BonneSeqGCG dans $NomDeLaSequence]
	foreach Aligneur [Aligneurs] {
	    if { [Aligneurs $Aligneur] } {
		set MSF [AligneLesHomologuesDuBlastContreSeq  $Aligneur $FichierBlast $FichierPEP]
		lappend ListeDesMSF $MSF
	    }
	}
    }
    set Fenetre [AfficheVariable [join $ListeDesMSF "\n"]  "AvecShowAvecEtudeMSF" "Wait all be Highlighted ...\nThen reselect and press a function. "]
    BoutonneLaFenetre $Fenetre "Log" "AfficheLogDesMSF \[selection get\]"
    foreach Fichier $ListeDesMSF {
	set LaFenetreDesMSF($Fichier) $Fenetre
    }	    
    return "Aligne3P est lance sur $NomDesSequences"

}

proc AligneContrePDB {Lseqpdb aLbinhe aLbinsh aLbintu aLseqpdn aLseqadn} {

    upvar $aLbinhe Lbinhe $aLbinsh Lbinsh $aLbintu Lbintu $aLseqpdn Lseqpdn $aLseqadn Lseqadn
    
    set i 0
    set Lh [list] ; set Ls [list] ; set Lt [list]
    set Lp [list] ; set La [list]
    foreach a $Lseqpdb {
	if {$a eq "-"} {
	    lappend Lh X
	    lappend Ls X
	    lappend Lt X
	    lappend Lp X
	    lappend La XXX
	} else {
	    lappend Lh [lindex $Lbinhe $i]
	    lappend Ls [lindex $Lbinsh $i]
	    lappend Lt [lindex $Lbintu $i]
	    lappend Lp [lindex $Lseqpdn $i]
	    lappend La [lindex $Lseqadn $i]
	    incr i
	}
    }
    set Lbinhe $Lh
    set Lbinsh $Ls
    set Lbintu $Lt
    set Lseqpdn $Lp
    set Lseqadn $La
    
    return

}

proc AligneLesHomologuesDuBlast {Aligneur FichierBlast} {

    global RepertoireDuGenome

    set SeuilExpect 1e-3
    set MaxLongueurDuBlast 50

    DecortiqueBlast $FichierBlast $SeuilExpect $MaxLongueurDuBlast Query lBanqueId lAccess lDE lProfil lPN
    set Nom [file tail $Query]
    if {[YaPABdans $Nom]} {
	set lHomos "$RepertoireDuGenome/prottfa/$Nom"
    } elseif {[regexp "TROU" $Nom]} {
	set lHomos "$RepertoireDuGenome/trousprottfa/$Nom"
    } else {
	set lHomos $Query
    }
    if { [info exists lBanqueId] && [llength $lBanqueId] > 0 } {
	foreach BanqueId $lBanqueId Access $lAccess {
	    if {[FetchTest $BanqueId]} {
		lappend lHomos $BanqueId
		continue
	    }
	    if {[FetchTest "protein:$Access"]} {
		lappend lHomos "protein:$Access"
		continue
	    }
	    Warne "$BanqueId $Access introuvable"
	}
    }
    set Destination "$RepertoireDuGenome/${Aligneur}/$Nom"
    if { [llength $lHomos] < 2 } {
	Warne "$Aligneur inutile. Pas de sequences a aligner dans $FichierBlast"
	return ""
	return [Sauve "$Aligneur inutile. Pas de sequences a aligner dans $FichierBlast" dans $Destination]
    }
    set Selection [join $lHomos "\n"]
    set MSF [AlignePar $Aligneur $Selection "Interactif" $Nom]
    file rename $MSF $Destination 
    return $Destination

}

proc AligneLesHomologuesDuBlastContreSeq {Aligneur FichierBlast {Seq ""}} {

    global RepertoireDuGenome

    set SeuilExpect 1e-3
    set MaxLongueurDuBlast 50

    DecortiqueBlast $FichierBlast $SeuilExpect $MaxLongueurDuBlast Query lBanqueId lAccess lDE lProfil lPN
    set Nom [file tail $Query]
    if { $Seq == ""} { set Seq $Query }
    set lHomos [linsert $lAccess 0 $Seq]
    if { [llength $lHomos] < 2 } { return "" }
    set Selection [join $lHomos "\n"]
    set MSF [AlignePar $Aligneur $Selection "Batch" $Nom]

    return $MSF

}

proc AlignePar {Aligneur Selection Mode {NomOuNum ""}} {

    global Commandes

    if { $NomOuNum == ""} {
	set NomNum [pid].[NomDe ""]
    }
    if { [regexp {^[a-zA-Z]} $NomOuNum ] } {
	set NomNum ${NomOuNum}[NomDe ""]
    }
    if { [regexp {^[0-9]} $NomOuNum ] } {
	set NomNum $NomOuNum
    }
    if { [regexp {^\.[0-9]} $NomOuNum ] } {
	set NomNum $NomOuNum
    }
    set Tmp tmp.$NomNum
    
	
    if { $Mode == "Batch" } {
	set In  $Tmp.$Aligneur.inp
	set Out $Tmp.$Aligneur.out
	set Log $Tmp.$Aligneur.log
	set FOF [FichierFOF $Selection $Tmp]
	SauveLesLignes [FOFtoTFAs $FOF] dans $In
	catch {set Canal [open "| [set Commandes($Aligneur)] $In $Out $Log"]} Message
	fconfigure $Canal -blocking false -buffering line
	fileevent $Canal readable "ClosCanalEtMontreMSF $Aligneur $Canal $Out.msf $Log"
	Warne "$Aligneur est lance en batch"
	return "$Out.msf"
    }

    if { $Mode == "Interactif" } {
	set In  $Tmp.inp
	Sauve [ConcatLesTFAs $Selection] dans $In
	set LesFichiersCrees [list "$In"]
	foreach Ali [split $Aligneur "+"] {
	    set Out $Tmp.$Ali.out
	    set Log $Tmp.$Ali.log
	    Warne "$Ali lance en interactif ... un peu de patience. Merci."
	    eval exec "[set Commandes($Aligneur)] $In $Out $Log"
	    Warne "                                                            ... j'ai fini."
	    File delete -force $Out
	    File delete -force $Log
	    lappend LesFichiersCrees "$Out.msf"
	}
	if {[regexp "+" $Aligneur]} {
	    return $LesFichierCrees
	} else {
	    return "$Out.msf"
	}
    }

}

proc AlignementDeLaSelection {K} {

    set Liste [$K find withtag current]
    foreach Id $Liste {
	set BId        [lindex [$K gettags $Id] 0]
	set Alignement [lindex [$K gettags $Id] 2]
	AfficheVariable $Alignement "AvecRien" "$BId"
    }

}

proc AlignementDesSelections {{Zone ""} aSAli} {

    upvar $aSAli SAli
    global NomSeqSel Sequences LNOrdali

    set LesNoms {}
    set LesSequences {}
    set LesNomsDesSeqs $LNOrdali

    if {[info exists NomSeqSel] && [llength $NomSeqSel] > 3} {
	set Li {}
	foreach p $NomSeqSel {
	    lassign [split $p .] y x
	    incr y -1
	    lappend Li $y
	}
    } else {
	for {set i 0} {$i < [llength $LesNomsDesSeqs]} {incr i} {
	    lappend Li $i
	}
    }

    if {! [llength $Zone]} {
	set Zone [list [list 0 [expr {[LongueurDeLAlignement]-1}]]]
    }

    set LVide {}
    foreach i $Li {
	set Nm [lindex $LesNomsDesSeqs $i]
	if {$Nm eq ""} {continue}
	set sbrut [set Sequences($Nm)]

	set s ""
	foreach z $Zone {
	    lassign $z x1 x2
	    append s [string range $sbrut $x1 $x2]
	}
	set tmp [string map [list "." "" Z "" " " "" X ""] $s]
	if {[string trim $tmp] eq ""} {
	    lappend LVide $i
	    continue
	}
	lappend LesNoms $Nm
	lappend LesSequences $s
    }

    set SAli {}
    foreach n $LesNoms s $LesSequences {
	lappend SAli $n $s
    }

    return $LVide

}

proc AlignementDynamique {Liste} {

    if {0} {
	set LesPaires {}
	foreach Ligne [LesLignesDuFichier $Liste] {lappend LesPaires [split $Ligne "\t"]}
	set LesPaires [lsort -index 1 -integer -increasing $LesPaires]
    } else {
	set LesPaires [lsort -index 1 -integer -increasing $Liste]
    }

    set LesRangQ {}
    set LesRangS {}
    foreach LaPaire $LesPaires {
	set RangQ                   [lindex $LaPaire 0]
	set RangS                   [lindex $LaPaire 1]
	lappend LesRangQ $RangQ
	lappend LesRangS $RangS
	set TabScore($RangQ,$RangS) [lindex $LaPaire 2]
    }

    set ScoreMax 0
    set LesRangQ [lsort -unique -increasing -integer $LesRangQ]
    set LesRangS [lsort -unique -increasing -integer $LesRangS]
    set nRangQ   [llength $LesRangQ]
    set nRangS   [llength $LesRangS]

    set LaDernierePaireDuScoreOpt {}
    for {set i 0} {$i < $nRangQ} {incr i} {
	for {set j 0} {$j < $nRangS} {incr j} {
	    set RangQ [lindex $LesRangQ $i]
	    set RangS [lindex $LesRangQ $j]

	    if {![info exists TabScore($RangQ,$RangS)]} {continue}
	    set Score [set TabScore($RangQ,$RangS)]

	    set ScoreOptPrec 0
	    set LaMeilleurePairePrec {}
	    foreach     RangQPrec [lrange $LesRangQ 0 [expr $i - 1]] { 
		foreach RangSPrec [lrange $LesRangS 0 [expr $j - 1]] {
		    if {![info exists TabScore($RangQPrec,$RangSPrec)]} {continue}
		    set ScorePrec [set TabScore($RangQPrec,$RangSPrec)]

		    if {[info exists          TabScoreOpt($RangQPrec,$RangSPrec)]} {
			set ScoreOptDeLaPaire [set TabScoreOpt($RangQPrec,$RangSPrec)]
		    } else {
			set ScoreOptDeLaPaire [set TabScore($RangQPrec,$RangSPrec)]
		    }
		    if {$ScoreOptPrec < $ScoreOptDeLaPaire} {
			set ScoreOptPrec $ScoreOptDeLaPaire
			set LaMeilleurePairePrec [list $RangQPrec $RangSPrec $ScorePrec]
		    }
		}
	    }
	    set TabScoreOpt($RangQ,$RangS,LaMeilleurePairePrec) $LaMeilleurePairePrec
	    set ScoreOpt [expr $Score + $ScoreOptPrec]
	    set TabScoreOpt($RangQ,$RangS) $ScoreOpt

	    if {$ScoreMax < $ScoreOpt} {
		set ScoreMax $ScoreOpt
		set LaDernierePaireDuScoreOpt [list $RangQ $RangS $Score]
	    }
	}
    }
    set LesMeilleursRangs {}
    while {$LaDernierePaireDuScoreOpt != {}} {
	set RangQ [lindex $LaDernierePaireDuScoreOpt 0]
	set RangS [lindex $LaDernierePaireDuScoreOpt 1]
	lappend LesMeilleursRangs     $LaDernierePaireDuScoreOpt
	set LaDernierePaireDuScoreOpt [set TabScoreOpt($RangQ,$RangS,LaMeilleurePairePrec)]
    }
    return [lsort -index 0 -integer $LesMeilleursRangs]

}

proc AlignementEssai {Nom} {

    set Fichier       "[RepertoireDuGenome]/macsims/$Nom.xml"
    set FichierSortie "[RepertoireDuGenome]/annotation/$Nom.ali"
    ParseMACSIMS $Fichier macsims
    set LesNomsSequences $macsims(Noms)
    foreach NomSequence $LesNomsSequences { 
	set Ali $macsims($NomSequence,Sequence)
	Espionne $Ali
    }

}

proc AlignementEssai1 {} {

    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set FichierMacsims "[RepertoireDuGenome]/macsims2/$Nom.xml"
	if {[file exists $FichierMacsims]} {continue}
	FichierMsfPourGOAnno $Nom "Sans"
	set FichierAlignement "[RepertoireDuGenome]/annotation/$Nom.msf"
	
	if {! [file exists $FichierAlignement]} {continue}
	set RepertoireDuMsf "annotation"
	MacsimManu $Nom $RepertoireDuMsf
    }

}

proc Aligneurs {{LeQuel ""} {Defaut ""}} {

    Wup "Returns array Aligneurs, AligneursCoches or Aligneur($LeQuel)" 
    global Aligneurs AligneursCoches AligneursDefaut

    if { ! [info exists Aligneurs]} {
	set Aligneurs(clustalw) 1
	set Aligneurs(dialign)  0
	set Aligneurs(pileup)   0
	set Aligneurs(prrp)     0
	foreach {a ValAligneurs} [array get Aligneurs] {
	    set AligneursDefaut($a) $ValAligneurs
	    if {$ValAligneurs} {
		set AligneursCoches($a) $ValAligneurs
	    }
	}
    }

    if {$LeQuel==""} {
	return [array names Aligneurs]
    }
    if {$LeQuel=="Coches"} {
	return [array names AligneursCoches]
    }
    if { $Defaut == "" } {
	if {[info exists Aligneurs($LeQuel)]} {
	    return [set Aligneurs($LeQuel)]
	} else {
	    return 0
	}
    } else {
	if {[info exists AligneursDefaut($LeQuel)]} {
	    return [set AligneursDefaut($LeQuel)]
	} else {
	    return 0
	}
    }

}

proc Alignons {PourQui {NomATraiter ""}} {

    global RepertoireDuGenome
    global ListeDesPABs
    global NotreOS

    set OnEffaceBallast 0

    if {$NomATraiter == "" } { 	
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $NomATraiter]
    }

    if {$PourQui=="Paralogues"} {
	set RepertoireMSF "$RepertoireDuGenome/msfparalogues"
	File mkdir $RepertoireMSF
    }
    
    set Conserve 1
    if {[llength [glob -nocomplain "$RepertoireMSF/*"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
    }

    foreach Nom $Liste {

	Espionne "Je vais traiter $Nom"

	set FichierMSF     "$RepertoireMSF/$Nom"
	set FichierBlastP  "$RepertoireDuGenome/blastp/$Nom"

	if {$PourQui=="Paralogues" && [ParaloguesDe $Nom]=={}} { continue }
	if { ! [file exists $FichierBlastP]} { continue }
	if { $Conserve && [file exists $FichierMSF] } { continue }
	
	if {[file exists "$RepertoireDuGenome/ballast/$Nom"]} {
	    set FichierBallast "$RepertoireDuGenome/ballast/$Nom" 
	} else { 
	    set FichierBallast [Ballast $FichierBlastP]
	}
	if {$FichierBallast != "" &&  [regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
	    set FichierBallast ""
	}
	if {$PourQui=="Paralogues"} {
	    set LaSelectionUnique [ParaloguesDe $Nom "apn"]
	    EspionneL $LaSelectionUnique
	    Espionne [llength $LaSelectionUnique]
	    if {[llength $LaSelectionUnique] == 0} {
		continue
	    }
	} else {
	    set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
	    if {[llength $LaSelectionUnique] == 0} {
		Warne "$Nom pas de sequences a aligner"
		Sauve "NoSequencesToAlign" dans $FichierMSF
		continue
	    }
	}

	set Selection "$RepertoireDuGenome/protembl/$Nom $Nom 0.0 $NotreOS\n"
	append Selection [join $LaSelectionUnique "\n"]

	set StatusDbClustal [DbClustal $Nom $FichierMSF $Selection "AvecSelection"]
	if {$OnEffaceBallast && [file exists $FichierBallast]} {
	    File delete -force $FichierBallast
	    foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] { 
		File delete -force $FichierBallastExt
	    }
	}

	if {$StatusDbClustal=="OK"} { continue }
	if {$StatusDbClustal=="PasDeSequencesAAligner"} {
	    Warne "$Nom pas de sequences a aligner ou erreur dans l'alignement."
	    Sauve "NoSequencesToAlignOrError" dans $FichierMSF
	    continue
	}
	if {$StatusDbClustal=="YaLog"} {
	    continue
	}
    }    

}

proc AlignonsLesParalogues {} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp"
    if { ! [file exists $FichierParalogues]} { LesParaloguesDuBlastP }
    Alignons Paralogues

}

proc AligntSeulContreTous {nm seq} {

    global OrdTmpDir

    set In1  [file join ${OrdTmpDir} tmp1]
    set In2  [file join ${OrdTmpDir} tmp2]
    set Out  [file join ${OrdTmpDir} tmp2g]
    set Log  [file join ${OrdTmpDir} tmp3]

    CreeLeTfa $In1

    set f [open $In2 w]
    puts $f ">$nm"
    set D 0
    while {$D < [string length $seq]} {
	set F [expr {$D + 59}]
	set L [string range $seq $D $F]
	puts $f "$L"
	incr D 60
    }
    close $f

    BatchClustalwProfile $In1 $In2 $Out $Log -outorder=input

    set tmp [DecortiqueUnMSF $Out NomSeq LesSeqAli]
    set LNewSeqAli [array get LesSeqAli]
    catch {file delete -force $In1 $In2 $Log $Out}

    return $LNewSeqAli

}

proc AllAboutVE {} {

    FaireLire "Je ne sais pas ce que fait AllAboutVE ..."
    set LesLignes [list "VE\tProtein\tVector\tStart\tEnd\tPGS\tRec2\tDescription"]
    foreach VE [VE ListOf VE] {
	set Proteine [VE $VE "Protein"]
	set Vecteur [VE $VE "Vector"]
	set Bornes [VE $VE "Domain_Boundaries"]
	set Debut 1
	set Fin "98765"
	regsub "/" $Bornes " " Bornes
	scan $Bornes "%d %d" Debut Fin
	set Nom [NomDuAlias $Proteine]
	if {$Nom==""} { continue }
	Espionne "$Proteine $Nom"
	set Trouve 0
	foreach R2 [Rec2 $Nom LesRec2] {
	    set V2 [Rec2 $R2 Vecteur]
	    set Descr [Rec2 $R2 Description]
	    set PDF [StringApres " Ppcr for $Nom " dans $Descr]
	    set LesPDF [split $PDF "-"]
	    set D [lindex $LesPDF end-1]
	    set F [lindex $LesPDF end]
	    regsub -- "\\-$D\\-$F$" $PDF "" P
	    regsub ".$" $P "" P
	    if {[string equal -nocase $P $Proteine] && $D==$Debut && $F==$Fin} {
		set Trouve 1
		break
	    }
	}
	if { ! $Trouve} { continue }
	set Ligne "$VE\t$P\t$Vecteur\t$Debut\t$Fin\t$Nom\t$R2\t$Descr"
	lappend LesLignes $Ligne
    }
    return [SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/fiches/AllAboutVE.csv"]

}

proc AllCC {} {

    set Lsys [lsort [glob [MiSynPatDir]/data/alignments/*_WithModules.xml]]
    
    file delete -force logc
    foreach file $Lsys {
	exec ordali $file -exe CompteConsDiscri -downloadpdb 0 >> logc
    }

    set Ll [LesLignesDuFichier logc]
    set Ls [lsearch -all $Ll "System *"]
    set Lres [list]
    foreach {d f} $Ls {
	lappend Lres {*}[lrange $Ll $d $f-1]
	lappend Lres {}
    }

    file delete cd.txt
    set o [open cd.txt w]
    puts $o [join $Lres \n]
    close $o

    exit

}

proc AllClustering {} {

    set Lf [glob ./hubert/mmaic/sel*_50..acc]
    set Lacc [list]
    foreach f $Lf {
	set Lacc [concat $Lacc [LesLignesDuFichier $f]]
    }

    set o [open "All_clustering.acc" w]
    puts $o [join $Lacc \n]
    close $o

    exit

}

proc AllEleGen {{Qui ""} {Quoi ""} {Ou ""}} {

    global AllEleGen
    #rR EleGene permet d'interroger tous les chromosomes en même temps
    #rR Ce n'est qu'une mémorisation de EleGen Chromo par Chromo 
    #rR Attention ! Pour le charger plus vite il exists un fichier Memo
    #rR Si onchange quelque chose (programme ou données de départ il faut le recharger
    #rR   pour cela qds Zero AllEleGen Redo_
    #rR   (doit être fait en qds (donc au nom de ripp) pour avoir les droits !!!!!!)

    set FichierMemo "[AnnotRep]/AllEleGen.txt"

    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $FichierMemo]} { file delete $FichierMemo }
	if {[info exists AllEleGen]} { unset AllEleGen } 
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [AllEleGen $Qui $Quoi $Ou]
    }

    if {$Ou!=""} { set Ou [AnnotType $Ou "T"] }

    if {[info exists AllEleGen($Qui,$Quoi,$Ou)]} {
	if { 0 && [PourWscope]} { return "
[join $AllEleGen($Qui,$Quoi,$Ou) \n]\n
" }
	return $AllEleGen($Qui,$Quoi,$Ou)
    }
    if {[info exists AllEleGen("EstCharge")]}  {
	if { 0 && [info exists AllEleGen($Qui,$Quoi,)]} { Espionne coucou;  return $AllEleGen($Qui,$Quoi,) }
	return ""
    }
    set AllEleGen("EstCharge") 1

    if {[file exists $FichierMemo]} {
	array set AllEleGen [ContenuDuFichier $FichierMemo]
	return [AllEleGen $Qui $Quoi $Ou]
    }

    foreach Chr [lrange [ListOfChr] 0 end] {
	set LesGn [EleGen $Chr "F" ListOf Gn]
	set AllEleGen($Chr,ListOfGn,) $LesGn
	foreach Gn $LesGn {
	    lappend AllEleGen(ListOf,Gn,) $Gn
	    set AllEleGen($Gn,Chr,) $Chr
	    set AllEleGen($Gn,ListOfD,) [EleGen $Chr "F" $Gn ListOfD]
	    set AllEleGen($Gn,ListOfF,) [EleGen $Chr "F" $Gn ListOfF]
	    set Left  [lindex $AllEleGen($Gn,ListOfD,) 0]
	    set Right [lindex $AllEleGen($Gn,ListOfF,) end]
	    set AllEleGen($Gn,Cover,) "$Left $Right"
	    set AllEleGen($Gn,Size,) [expr $Right-$Left+1]
	}
	foreach T [AnnotType ListOf T] {
	    foreach Gn [EleGen $Chr $T ListOf Gn] {
		if {$Gn=="" || $Gn=="NA"} { continue }
		lappend AllEleGen(ListOf,Gn,$T) $Gn
		set AllEleGen($Gn,ListOfD,$T) [EleGen $Chr $T $Gn ListOfD]
		set AllEleGen($Gn,ListOfF,$T) [EleGen $Chr $T $Gn ListOfF]
		set Left  [lindex $AllEleGen($Gn,ListOfD,$T) 0]
		set Right [lindex $AllEleGen($Gn,ListOfF,$T) end]
		set AllEleGen($Gn,Cover,$T) "$Left $Right $Chr"
		set AllEleGen($Gn,Size,$T) [expr $Right-$Left+1]
		set AllEleGen($Gn,ListOf,Id) [EleGene $Chr $T $Gn ListOfId]
		foreach Id $AllEleGen($Gn,ListOf,Id) {
		    set AllEleGen($Id,Gn,)
		}
	    }
	    #rR on pourrait encore tout mémoriser pour les Id ...
	}
    }
    Sauve [array get AllEleGen] dans $FichierMemo
    return [AllEleGen $Qui $Quoi $Ou]

}

proc AllForGo {} {

    InformeFromOiPourTous
    InformeGoPourTous
    MyGenesFromGo
    MyGOsFromGene

}

proc AllGenesToTfa {Path} {


#Compteurs :
	set CompteurLus 0
	set CompteurEcrit 0


# Générer les requetes à partir des coordonnées
# =============================================
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|AllGenesToTfa : Building genes queries"

	set FichierDesAccess [open "$Path.acc" "r"]
	set FichierDesRequetes [open "/tmp/AllGenesToTfa.bql" "w"]

	set CompteurLus 0
	while { [gets $FichierDesAccess Ligne1] >=0 } {
		ScanLaListe $Ligne1 Distance NM

		incr CompteurLus
	 	set Moins "-"
		set Plus "+"
		puts $FichierDesRequetes "ID * DB UCSC"
		puts $FichierDesRequetes "WH SQLNATIVE SELECT name FROM ucsc$Organism.refgene"
		puts $FichierDesRequetes "#"
	}
	close $FichierDesRequetes
	close $FichierDesAccess

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|AllGenesToTfa : Executing NP queries"

	exec /biolo/bird/bin/birdql_client.sh /tmp/AllGenesToTfa.bql bird /tmp/AllGenesToTfa.res

	set FichierDesRequetesExecutees [open "/tmp/AllGenesToTfa.res" "r"]
	set FichierDesRequetes2 [open "/tmp/AllGenesToTfa2.bql" "w"]
	while { [gets $FichierDesRequetesExecutees Header]  >=0 } {
		gets $FichierDesRequetesExecutees NM
		puts $FichierDesRequetes2 "ID $NM DB REFSEQ"
		puts $FichierDesRequetes2 "FM FASTA"
		puts $FichierDesRequetes2 "LM 1"
		puts $FichierDesRequetes2 "#"
	}

	close $FichierDesRequetesExecutees
	close $FichierDesRequetes2

	exec /biolo/bird/bin/birdql_client.sh /tmp/AllGenesToTfa2.bql bird /tmp/AllGenesToTfa2.res

	set FichierDesRequetesExecutees2 [open "/tmp/AllGenesToTfa2.res" "r"]
	set FichierMiddle [open "$Path.mid" "w"]

	while { [gets $FichierDesRequetesExecutees2 Header]  >=0 } {
		puts $FichierMiddle $Header
		gets $FichierDesRequetesExecutees2 Sequence
		set Sequence [string trim $Sequence]
		puts $FichierMiddle $Sequence
	}

	close $FichierMiddle
	close $FichierDesRequetesExecutees2

	set FichierMiddle [open "$Path.mid" "r"]
	set FichierOut [open "$Path.tfa" "w"]

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|AllGenesToTfa : Purging bird file"

	while { [gets $FichierMiddle LigneMiddle] >= 0} {
		if { $LigneMiddle != "" } {
			puts $FichierOut $LigneMiddle
		}
	}
	close $FichierOut
	close $FichierMiddle
	
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "     - read : $CompteurLus"
	Espionne "     - found proteins : $CompteurProt"
	Espionne "     - blasted : $CompteurBlast"
	Espionne "     - written : $CompteurEcrits"
	Espionne "$timestamp|AllGenesToTfa : End"


}

proc AllGlobals {{Show ""}} {

    set Show [string equal -nocase $Show "Show"]
    set LeTexte {}
    foreach G [lsort [info globals]] {
	global $G
	if {[array exists $G]} {
	    lappend LeTexte "****************************** array $G"
	    foreach {C V} [lrange [array get $G] 0 19] {
		lappend LeTexte "   $C [string range $V 0 60]"
	    }
	    lappend LeTexte "************************************ $G"
	} else {
	    lappend LeTexte "$G [string range [set $G] 0 60]"
	}
    }
    set Texte [join $LeTexte "\n"]
    if {$Show} { return [AfficheVariable $Texte "" "AllGlobals"] }
    return $Texte

}

proc AllInteractions {FichierSortie Org Seuil} {

    CanalSqlString
    set TaxId [TaxIdOrg $Org]   
    regsub " " $Org "_" Org
    foreach {Pi1 Pi2 Cs} [SqlExec "select protein_id_a,
    protein_id_b,
    combined_score
    from 
    network.protein_protein_links
    where
    combined_score >= '$Seuil'
    and protein_id_a in (select protein_id from items.proteins_names where species_id = $TaxId) 
    order by combined_score DESC;" "GetList"] {
	set Pn1 [PreferredName $Pi1 $Org]
	set Pn2 [PreferredName $Pi2 $Org]
	set Ligne "$Pi1\t$Pn1\t$Pi2\t$Pn2\t$Cs"
	lappend LesLignes $Ligne
    }
    SauveLesLignes $LesLignes dans $FichierSortie
    CanalSqlDisconnect  

}

proc AllPromotorsATCGbackground {Path Organism Upstream Downstream {Database GeCo}} {

	
	Espionne "WhatIsMyATCGbackground: Start"
	set FichierDesRequetes [open "/tmp/WhatIsMyATCGbackground.bql" "w"]
	set RequetesExecutees "/tmp/WhatIsMyATCGbackground.res"
	Espionne "WhatIsMyATCGbackground: Building queries"
	puts $FichierDesRequetes "ID * DB UCSC"
	puts $FichierDesRequetes "WH SQLNATIVE SELECT chrom, txStart, txEnd, strand FROM ucsc$Organism.$Database where typegene ='Protein' order by chrom, txStart"
	puts $FichierDesRequetes "LM 35000"
	puts $FichierDesRequetes "//"
	close $FichierDesRequetes
	
	Espionne "WhatIsMyATCGbackground: Executing queries"
	#BirdFetch "/tmp/WhatIsMyATCGbackground.bql" "/tmp/WhatIsMyATCGbackground.res"
	
	set FichierDesRequetesExecutees [open "$RequetesExecutees" "r"]
	set FichierDesCoordonnees [open "$Path.coo" "w"]
	gets $FichierDesRequetesExecutees Ligne
	
	Espionne "WhatIsMyATCGbackground: Writing coordinates"
	set I 0
	while { [gets $FichierDesRequetesExecutees Ligne] > 0 } {
		incr I
		ScanLaPipe $Ligne chrom txStart txEnd strand
		if { $strand == "+"} {
			set TSS $txStart
			set promotorStart [expr $TSS - $Upstream]
			set promotorEnd [expr $TSS + $Downstream]
		} else {
			set TSS $txEnd
			set promotorEnd [expr $TSS + $Upstream]
			set promotorStart [expr $TSS - $Downstream]
		}
		puts $FichierDesCoordonnees "$I $chrom $promotorStart $promotorEnd $strand"
	}
	close $FichierDesCoordonnees
	#GetProm "$Path" 0 0
	set FichierDesSequences [open "$Path.pro" "r"]
	set A 0
	set T 0
	set C 0
	set G 0
	set Chars 0
	Espionne "WhatIsMyATCGbackground: Counting letters"
	while { [gets $FichierDesSequences Header] > 0 } {
			gets $FichierDesSequences Sequence
			set CharArray [split $Sequence ""]
			foreach Char $CharArray {
				
				if { $Char == "A" } {
					incr A
					incr Chars
				}
				if { $Char == "T" } {
					incr T
					incr Chars
				}
				if { $Char == "C" } {
					incr C
					incr Chars
				}
				if { $Char == "G" } {
					incr G
					incr Chars
				}
			}
	}
	set FA [expr (100*$A)/$Chars]
	set FT [expr (100*$T)/$Chars]
	set FC [expr (100*$C)/$Chars]
	set FG [expr (100*$G)/$Chars]
	Espionne "WhatIsMyATCGbackground: A=$FA"
	Espionne "WhatIsMyATCGbackground: T=$FT"
	Espionne "WhatIsMyATCGbackground: C=$FC"
	Espionne "WhatIsMyATCGbackground: G=$FG"
	Espionne "WhatIsMyATCGbackground: End"

}

proc AllToTitle {Texte} {

    set AlphAvant 0
    foreach C [split $Texte ""] {
	if {$AlphAvant} {
	    append Nouveau [string tolower $C]
	} else {
	    append Nouveau [string toupper $C]
	}	    
	set AlphAvant [regexp -nocase {[a-z]} $C]   
    }
    return $Nouveau

}

proc All_bz {PhyloTree All_bzLogFile} {

    ### all_bz program execution from the TBA suite ###
    # generates all blastz commands for pairs of specified sequences #
    Espionne "All_bz ..."
    #set Commande "exec [PATH all_bz] + \"$PhyloTree\" >& $All_bzLogFile" 
    set Commande "exec all_bz + \"$PhyloTree\" >& $All_bzLogFile" 
    puts $Commande
    if {[catch {eval $Commande} Message]} {Espionne $Message;return} 
    return 

}

proc AllerRetour {In {Out ""} {N ""}} {

    if {$Out==""} { set Out "${In}_new" }
    if {$N==""} { set N 1 }
    set Liste [LesLignesDuFichier $In]
    set ListeRetourne [RetourneLaListe $Liste]
    set LiiL [concat $Liste $ListeRetourne]
    set Finale {}
    foreach i [NombresEntre 1 $N] {
	set Finale [concat $Finale $LiiL]
    }
    return [SauveLesLignes $Finale dans $Out]

}

proc AllowIllegalCharactersInTFA {{Valeur ""}} {

    global AllowIllegalCharactersInTFA
    if { $Valeur=="ResetAllValues"} {
	if {[info exists AllowIllegalCharactersInTFA]} { unset AllowIllegalCharactersInTFA }
	set Valeur 0
    }
    if { ! [info exists AllowIllegalCharactersInTFA]} {
	set AllowIllegalCharactersInTFA(Level) 1
	set AllowIllegalCharactersInTFA(1) 0
    }
    if {[regexp "Previous" $Valeur]} {
	if {$AllowIllegalCharactersInTFA(Level)>1} { incr AllowIllegalCharactersInTFA(Level) -1 }
	return [AllowIllegalCharactersInTFA]
    }
    if {$Valeur!=""} {
	if {[regexp -nocase {[1YVA]} $Valeur]} { set Valeur 1 } else { set Valeur 0 }
	incr AllowIllegalCharactersInTFA(Level)
	set AllowIllegalCharactersInTFA($AllowIllegalCharactersInTFA(Level)) $Valeur 
    }
    return $AllowIllegalCharactersInTFA($AllowIllegalCharactersInTFA(Level))

}

proc AllumeLaSelection {K PAB LesDirs} {


    Wup "Highlight les oligos deja selectionnes (fichier .selection) en distinguant les differentes sources" 

    DeselectionneLesSelectionnes $K

    foreach Dir $LesDirs {
	set FichierSelection "$Dir/${PAB}.selection"
	if {![file exists $FichierSelection]} {continue}
	
	set F [open "$FichierSelection"]
	while {[gets $F Ligne]>=0} {
	    if {! [regexp -nocase {[a-z]+ || [0-9]+}  $Ligne]} {continue}
	    if {  [string range $Ligne 0 0] != ">"}            {continue}
	    if {  [regexp -nocase "NoOligo"           $Ligne]} {break}
	    set LigneSplitee [split  $Ligne "\t"]
	    set Entete       [lindex $LigneSplitee 0]
	    set NomOligo     [lindex $Entete 1]
	    
	    set         LesId [$K find withtag "$NomOligo && Boite && $Dir"]
	    foreach Id $LesId {
		set MesTags [$K gettags $Id]
		$K itemconfigure $Id -outline "black" 
		$K itemconfigure $Id -width   "2" 
		$K itemconfigure $Id -dash    {6 4 2 4}
		$K addtag "Selected" withtag $Id
	    }
	}
	close $F
    }
    return ""

}

proc AllumeLaXSelection {K PAB LesDirs} {


    Wup "Highlight les oligos croisee deja selectionnes (fichier .croisee) en distinguant les differentes sources" 

    DeselectionneLesXSelectionnes $K

    foreach Dir $LesDirs {
	set FichierSelection "$Dir/$PAB.croisee"
	if {![file exists $FichierSelection]} {continue}
	set F [open      "$FichierSelection"]
	while {[gets $F Ligne]>=0} {
	    if {! [regexp -nocase {[a-z]+ || [0-9]+}  $Ligne]} {continue}
	    if {  [string range $Ligne 0 0] != ">"}            {continue}
	    if {  [regexp -nocase "NoOligo"           $Ligne]} {break}
	    set LigneSplitee [split  $Ligne "\t"]
	    set Entete       [lindex $LigneSplitee 0]
	    set NomOligo     [lindex $Entete 1]
	    
	    set         LesId [$K find withtag "$NomOligo && Boite && $Dir"]
	    foreach Id $LesId {
		set MesTags   [$K gettags $Id]
		set MesCoords [$K coords $Id]
		set Xmin [lindex $MesCoords 0]
		set Xmax [lindex $MesCoords 2]
		set Ymin [expr [lindex $MesCoords 1]-([lindex $MesCoords 3]-[lindex $MesCoords 1])/4]
		set Ymax [expr [lindex $MesCoords 3]+([lindex $MesCoords 3]-[lindex $MesCoords 1])/4]
		$K create line $Xmin $Ymin $Xmax $Ymax  -tags [list "XSelect" "Trace" "$NomOligo"]  -fill "black" -width 4
		$K create line $Xmin $Ymax $Xmax $Ymin  -tags [list "XSelect" "Trace" "$NomOligo"]  -fill "black" -width 2
		$K addtag "XSelect" withtag $Id
	    }
	}
	close $F
    }
    return ""

}

proc AlphaNum {} {

    global TokCourant
    
    set Courant ""
    if {[regexp -nocase {[a-z_]} $TokCourant]} {
	set Courant $TokCourant
    }
    if {$Courant==""} {	return "AlphaNumNonValideCarNonAlphaEnDebut" }
    while {[regexp -nocase {[a-z_0-9]} [Tok]]} {
	append Courant $TokCourant
    }
    return $Courant

}

proc AlviCreePpcrProt {} {

    set RepPpcrProt "[RepertoireDuGenome]/ppcrprot"
    foreach Nom [ListeDesPABs] {
	set TfaPpcr [ContenuDuFichier [GscopeFile $Nom "ppcr"]]
	set Entete  [EnteteDuTexteTFA $TfaPpcr]
	set PcrNuc  [QueLaSequenceDuTexteTFA $TfaPpcr]
	set PosATG  [string first "ATG" $PcrNuc]
	set PosStop [StopProchain $PcrNuc $PosATG]
	incr PosStop -1
	if {$PosStop <0} { set PosStop "end" } 
	set PcrPro [SeqNucToSeqPro [string range $PcrNuc $PosATG $PosStop]]
	set TfaPpcrProt [SequenceFormatTFA $PcrPro $Entete "protbrut"]
	Espionne $TfaPpcrProt
	Sauve $TfaPpcrProt dans "$RepPpcrProt/$Nom"
    }

}

proc AlviVerif {} {

    foreach Ligne [LesLignesDuFichier "[Fiches]/OligosF.csv"] LigneR [LesLignesDuFichier "[Fiches]/OligosR.csv"] {
	ScanLaListe [split $Ligne ";"]  OligoNameF OligoF Bidon1 Bidon2 Bidon3 NotesF
	regexp {BOX[0-9]+} $NotesF Nom
	ScanLaListe [split $LigneR ";"] OligoNameR OligoR Bidon1 Bidon2 Bidon3 NotesR
	set OligoRSens [NucToReverseAndComplementNuc $OligoR]
	regexp {BOX[0-9]+} $NotesR NomR
	if {$Nom!=$NomR} { FaireLire COUCOU }

	set SeqOliNucF [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nucoligo"]]
	regsub {^ATG} $SeqOliNucF "" SeqF
	regsub {.+CATATG} $OligoF "" SeF

	set SeqOliNucR [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nucoligo"]]
	set SeR [string range $SeqOliNucR end-25 end]

	Espionne
	Espionne "$OligoNameF $OligoF [string range $NotesF 0 60]"
	Espionne "                                 $SeF"
	Espionne "                               [string range $SeqF 0 20]"
	Espionne "$OligoNameR $OligoRSens [string range $NotesR 0 60]"
	if {[regexp "RunOff" $NotesR]} { set SeR "RunOff" }
	Espionne "        $SeR"
    }

}

proc AlwaysTrue {Nom} {

    return 1

}

proc AmontAval {TypeDeSequence NomFichier} {


# Cree deux fichiers avec les SBS avant et apres les genes

# Déclaration des fichiers
set PathIn "/tmp/Conservation/Implications/"

set FichierDes230000enrichi [open "$PathIn$TypeDeSequence/$NomFichier" "r"]
set FichierDesSequencesUpstream "$PathIn$TypeDeSequence/Upstream$NomFichier"
set FichierDesSequencesDownstream "$PathIn$TypeDeSequence/Downstream$NomFichier"
set PathOut1 $FichierDesSequencesUpstream
set PathOut2 $FichierDesSequencesDownstream

# Suppressions des éventuelles versions précédentes des fichiers
if { [file exists $FichierDesSequencesUpstream] } {
	file delete $FichierDesSequencesUpstream
}
if { [file exists $FichierDesSequencesDownstream] } {
	file delete $FichierDesSequencesDownstream
}

while { [gets $FichierDes230000enrichi Ligne]  >=0 } {
	set DistanceAlaBorneDeExonOuIntron -999999999999999
	ScanLaListe $Ligne StafID ChromosomeH StartH EndH Acc Deb Fin Orientation Distance ExonOuIntron CdsOuPas UtrOuPas DebutExonOuIntron FinExonOuIntron DebutOuFinExonOuIntron DistanceAlaBorneDeExonOuIntron OccupationExonOuIntron
if { $DistanceAlaBorneDeExonOuIntron == -999999999999999 } {
		if { $Distance <= 0 } {
			AppendAuFichier $FichierDesSequencesUpstream $Ligne
		} else {
			AppendAuFichier $FichierDesSequencesDownstream $Ligne
		}
	}
}
Espionne ""
Espionne "Execution terminee ! Fichier écrit dans $PathOut1 et $PathOut2"

}

proc AnaBalAgent {} {

    package require sqlite3
    set db root
    sqlite3 $db res.sql

    set Lmat [ListeDesMatrices]
    set Lsco [ListeDesScores]
    set Lwgt [list 0 1]
    set Llen [ListeDesMotiflen]

    foreach mat $Lmat {
	foreach sco $Lsco {
	    foreach wgt $Lwgt {
		foreach len $Llen {
		    set Ns [$db eval {select count(s.pk_segment) from segment as s, ln_analyse_segment as las, analyse as a where  a.score = $sco and  a.matrix = $mat and  a.weight = $wgt and  a.motiflen = $len and  a.pk_analyse = las.pk_analyse and  las.pk_segment = s.pk_segment}]

		    set Nb [$db eval {select count(s.pk_segment) from segment as s, ln_analyse_segment as las, analyse as a where  a.score = $sco and  a.matrix = $mat and  a.weight = $wgt and  a.motiflen = $len and  a.pk_analyse = las.pk_analyse and  las.pk_segment = s.pk_segment}]

		    if {$Ns == 0} {
			continue
		    }
		    
		    set Ns0 [$d eval {select count(s.pk_segment) from segment as s, ln_analyse_segment as las, analyse as a where  a.score = $sco and  a.matrix = $mat and  a.weight = $wgt and  a.motiflen = $len and  a.pk_analyse = las.pk_analyse and  las.pk_segment = s.pk_segment and  s.rank = 0.0}]
		    
		    set Ns1 [$d eval {select count(s.pk_segment) from segment as s, ln_analyse_segment as las, analyse as a where  a.score = $sco and  a.matrix = $mat and  a.weight = $wgt and  a.motiflen = $len and  a.pk_analyse = las.pk_analyse and  las.pk_segment = s.pk_segment and  s.max = 1}]
		    
		    lappend Lres $sco $mat $wgt $len [expr {100*$Ns0/$Ns}] [expr {100*($Ns0 + $Ns1)/$Ns}] $Ns
		}
	    }
	}
    }

    $d close

    set Lres [lsort -stride 7 -index 5 -integer $Lres]
    foreach  {sc mat wgt len pc pc1 ns} $Lres {
	puts "$sc $mat $wgt $len | $pc $pc1 $ns"
    }

    exit

}

proc AnaMeth {} {

    DefinitionPreferences
    set Llim -99999999999.
    set v -2.0
    while {$v < 2.01} {
	lappend Llim $v $v
	set v [expr {$v + 0.1}]
    }
    lappend Llim 99999999999.

    set LMethods [list Norm Thompson Ranganatan VolPol Liu Liu2 RPCA Entrop1 Entrop2 EnpCube]
    foreach meth $LMethods {
	puts "\n$meth"
	set Ll [LesLignesDuFichier ${meth}.dat]
	set ListeV [list]
	foreach l $Ll {
	    lappend ListeV [split $l \t]]
	}
	puts "  ncol in [llength [lindex $ListeV 0]]"
	#set Lgr [Tclcluspack $ListeV -dt coordinates -cm mm -nbc aic -wc]
	exec /biolo/cluspack/binNew/cluspack $meth.dat -dt=coordinates -cm=mm -nbc=aic -wc
	set Ll [LesLignesDuFichier $meth.clu]
	set Lv [list]
	set Lgr [list]
	foreach l [lrange $Ll 2 end] {
	    set l [string trim $l]
	    if {$l eq ""} {continue}
	    if {[regexp {^Cluster} $l]} {
		if {$Lv != {}} {
		    lappend Lgr $Lv
		}
		set Lv [list]
		continue
	    }
	    lappend Lv [split $l \t]
	}
	lappend Lgr $Lv
	puts "  nbr clusters [llength $Lgr]"
	set Nj [llength [lindex [lindex $Lgr 0] 0]]
	puts "  ncol out $Nj"
	set Lx [list]
	for {set x 1} {$x < $Nj} {incr x} {
	    lappend Lx $x
	}
	set i 1
	set Ly [list]
	foreach g $Lgr {	    
	    set Nv [llength $g]
	    puts "  cluster $i : $Nv"
	    set ylab "cluster $i - $Nv"
 	    if {$Nv < 5} {
		continue
	    }
	    set Lyv [list]
	    for {set j 1} {$j < $Nj} {incr j} {
		set Lv [ExtraitListeDeListe $g $j]
		set mx [expr max([join $Lv ,])]
		set S [::tcl::mathop::+ {*}$Lv]
		lappend Lyv [expr {$S/$Nv*100.}]
	    }
	    set sum [expr [join $Lyv +]]
	    set titre "$meth - cluster $i"
	    if {$i == 1} {
		set col black
	    } else {
		set col [CouleurDuGroupe $i]
	    }
	    lappend Ly [list $Lyv $col $ylab]
	    incr i
	}
	DoRPlot $Lx $Ly $titre "${meth}.pdf"
    }
    
    exit

}

proc AnaPfam {} {

    global LNOrdali LSOrdali TDesPCI

    set fmt "%8s %6d %4d %6d %6d %6.2f %6.2f"
    set Ll [LesLignesDuFichier Summary_Pfam.txt]
    set o [open Summary_Pfam2.txt w]
    foreach l $Ll {
	regsub -all { +} [string trim $l] " " l
	lassign [split $l " "] pf nseq lgt maxg ming
	puts "Traite $pf :"
	puts "   nseq $nseq"
	puts "   lgt  $lgt"
	puts "   maxg $maxg"
	puts "   ming $ming"
	set f [file join /home moumou work moumou BenchPfam $pf]
	puts "   file $f"
	set LNOrdali [list]
	DecortiqueUnTFA $f LNOrdali Sequences
	set SAli [list]
	set LSOrdali [list]
	foreach n $LNOrdali {
	    lappend SAli $n [set Sequences($n)]
	    lappend LSOrdali [set Sequences($n)]
	}
	CalculeLesPCIGenerique $SAli TDesPCI
	#CalculeLesPCI "" "" "" "" 1

	# moyenne et ecart-type
	set i 1
	set m 0.
	set s2 0.
	foreach n1 [lrange $LNOrdali 0 end-1] {
	    foreach n2 [lrange $LNOrdali $i end] {
		set v [lindex [set TDesPCI($n1,$n2)] 0]
		set m  [expr {$m + $v}]
		set s2 [expr {$s2 + $v*$v}]
	    }
	    incr i
	}
	set Ni [expr {$nseq*($nseq-1)/2}]
	set m [expr {$m/$Ni}]
	set sd [expr {100.*sqrt($s2/$Ni - $m*$m)}]
	set m  [expr {100.*$m}]
	puts " --> m - sd : [format %6.2f $m] [format %6.2f $sd]"
	puts ""
	puts $o [format $fmt $pf $nseq $lgt $maxg $ming $m $sd]
	unset Sequences
	unset TDesPCI
	update
    }

    close $o
    
    exit

}

proc AnaProsite {} {


    package require sqlite3

    set db root
    sqlite3 $db /home/moumou/Prosite/Prosite.sql

    set Lp [$db eval {select accession, pattern, uniprot_id, uniprot_type from prosite where type = 'PATTERN'}]
    puts "[llength $Lp]"
    set pris 0
    foreach {ac pat lid ltype} $Lp {
	if {! [regexp {\[} $pat]} {continue}
	if {[regexp {\{} $pat]} {continue}
	if {$lid == "NULL"} {continue}
	set Lbid {}
	foreach id $lid ty $ltype {
	    if {$ty eq "N" || $ty eq "P" || $ty eq "T"} {
		lappend Lbid $id
	    }
	}
	if {[llength $Lbid] < 10} {continue}

	incr pris
	puts "$ac"
	puts "$pat"
	puts "lg $ac [llength $Lbid]"
	puts ""
    }

    puts "nb bons prosite : $pris"

    exit

}

proc AnaTaxId {} {

    source euka.taxid
    foreach a [array names TT] {
	lappend Lt [set TT($a)]
    }

    set Lt [lsort -unique -index 1 $Lt]
    puts "[llength $Lt]"
    puts "[join $Lt \n]"

    return

}

proc AnalyseBalibaseAgent {} {

    global TabSF LNOrdali
    
    CacheStrSecDansAlignement

    foreach b [array names TabSF "*,BLOCK"] {
	lassign [split $b ,] seq tmp
	
	foreach f $TabSF($b) {
	    DecortiqueUneFeature $f dg fg col sc nt
	    lappend Block($dg,$fg) $seq
	}
    }

    # cheche block communs
    set nSeq [llength $LNOrdali]
    set Lbck [list]
    foreach k [array names Block] {
	if {[llength $Block($k)] == $nSeq} {
	    lassign [split $k ,] dg fg
	    puts "=> $k"
	    lappend Lbck $dg $fg
	}
    }

    set lgt [LongueurDeLAlignement]
    for {set i 0} {$i < $lgt} {incr i} {
	set p$i 0
    }
    foreach {d f} $Lbck {
	#lassign [split $k ,] d f
	for {set j $d} {$j <= $f} {incr j} {
	    set p$j 1
	}
    }
    set dep -1 ; set fin -1
    for {set i 0} {$i < $lgt} {incr i} {
	if {[set p$i]} {
	    puts "p$j"
	    if {$dep == -1} {
		set dep $i
	    }
	} else {
	    if {$dep != -1} {
		set fin [expr {$i-1}]
		puts "$dep - $fin"
		set dep -1
	    }
	}
    }
	    


    
    #exit

}

proc AnalyseCoreBlocksAgent {Lblocks} {

    global TAg T LNOrdali MotifLen

    set Lres [list]
    foreach {d f} $Lblocks {
	if {($f - $d + 1) < $MotifLen} {
	    continue
	}
	puts "\nBlock : $d --- $f"
	set Lbck [list Block $d $f]
	set LLag [AgentsDuBlock $d $f]

	set log "Block $d $f"
	set Lseg [list]
	set iDep $d
	foreach Lag $LLag {
	    #puts "Lag: $Lag"
	    #set log [RankBlockChaines $Lag]
	    #set rep [RankBlockAllConnectes $Lag]
	    set rep [RankBlockAllConnectes2 $Lag]
	    if {$rep == -1} {
		lappend log "not all connected"
	    } else {
		lassign $rep srk min max nZero nSup
		lappend log "rank all $iDep [format %8.3f $srk] $min $max $nZero $nSup"
		lappend Lseg [list $MotifLen $srk $min $max $nZero $nSup]
	    }
	    puts [join $log \n]
	    set log {}

	    incr iDep
	}
	lappend Lbck $Lseg
	lappend Lres $Lbck
    }

    return $Lres

}

proc AnalyseFichierBalibase {{args ""}} {

    global Mbl Cbl MotifLen LNOrdali Sequences Lref Sref

    LesDefauts Mode batch
    LesDefauts TypeAli XML
    LesDefsAlA
    #LesDefauts FichierXML $f

    # override MotifLen
    if {$args ne ""} {
	lassign $args f len deb fin matrix typeScore Wgt
	set MotifLen $len

	set Lbornes [list $deb $fin]
    } else {
	# defauts
	set MotifLen 13
	set matrix blosum62
	set deb ""
	set typeScore sop
	set Wgt 0

	set Lbornes [CoreBlocksDuXML]
    }

    set ok [DecortiqueXmlAgent $f]
    if {$ok == 0} {
	puts "Problem loading alignment !"
	puts "file : $f\n"

	return [list]
    }
    
    puts "f= $f MotifLen $MotifLen"
    set lgt [LongueurDeLAlignement]
    set nbS 0
    foreach n $::LNOrdali {
	if {$n ne ""} {incr nbS}
    }

    set Lres [list $f $nbS $lgt $len $matrix $typeScore $Wgt]
    
    InitMatrix $matrix


    set RenameSeq   1

    if {0} {
	array set Sref [array get Sequences]
	set Ltmp {}
	foreach n $LNOrdali {
	    if {$n ne ""} {lappend Ltmp $n}
	}
	set LNOrdali $Ltmp
	foreach n $LNOrdali {
	    set s [string map {"." ""} $Sequences($n)]
	    set Sequences($n) $s
	}
	
	#set ok [SequencesPourAgent "" $RenameSeq]
    }
    
    SequencesPourAgent "" 1

    # 1: poids gaussiens, 0 : 1.0 pour chqeue pos
    #InitWg 1
    #InitWg 0
    InitWg $Wgt

    set nAgents [InitAgentsAnaBal]

    set nball [expr {$nAgents * $nAgents}]
    puts "all pairs          $nball"
    puts "n/2 pairs          [expr {$nAgents * $nAgents/2}]"
    set nab 0
    foreach {d f} $Lbornes {
	set LLag [AgentsDuBlock $d $f]
	foreach lag $LLag {
	    incr nab [llength $lag]
	}
    }
    puts "agents dans block  $nab"
    puts "nblock * agents    [expr {$nab * $nAgents}]"
    #exit
    InitTypeScore $typeScore
    
    #::profiler::reset
    if {$deb eq ""} {
	ComputeScoreAllPairsAgents $Lbornes
    } else {
	ComputeScorePairsDuBlockAgents $deb $fin
    }
    #AfficheProfileResults

    set ok [AnalyseCoreBlocksAgent $Lbornes]
    if {$ok == 0} {
	puts "Problem in dblock !"
	return 0
    } else {
	lappend Lres $ok
    }
    
    if {0} {
	set lor [lsort [lor [info globals] $::VariablesAuDepart]]
	#puts "\nlor\n[join $lor \n]"
	foreach v $lor {
	    if {$v eq "VariablesAuDepart"} {
		puts "FOUND !"
		continue
	    }
	    if {[array exists ::$v]} {
		#puts "delete $v"
		array unset ::$v
	    }
	    unset -nocomplain ::$v
	}
	
	#puts "verif [join [lsort [lor $::VariablesAuDepart [info globals]]] \n]"
	update
    }

    puts "FinalResult\n$Lres"

    #exit
    return $Lres

}

proc AnalyseGlobaleOverlap {FichierOverlap {TumorType 3T} {IntMin 0} {FCAffy 0.0} {FCDD 0.0}} {

    #FichierOverlap=/OVERLAP931NEW/Overlap.final (333 overlaps DD-Affy avec les profils etc...)
    #HOP: a ajouter aux genes correles car la RT-PCR a nie le profil du gel DD
    #aucune target Affy dont les 4 valeurs de detection egales A ou M n'est acceptee
    #TumorType: E, S, ou U, ou 3T (moy des 3 T)

    # ---
    #set Fichier "[RepertoireDuGenome]/OVERLAP931NEW/820DD.27may05"
    #set L [CreeListePourFichierAUneColonne $Fichier] 
    #foreach DD $L {set Vu($DD) 1}
    # ---
    set NbComparaisons 0
    set NbMemeProfil 0
    set NbN 0
    set NbT 0
    set TN 0
    set NT 0
    set LesFaibles ""
    set Liste ""
    set n 0
    set nbcomplexes 0
    foreach Ligne [LesLignesDuFichier $FichierOverlap] {
	set Ligne [string trim $Ligne]
	if {$Ligne ==""} {continue}
	set LesChamps [split $Ligne "\t"]
	incr n
	#1: Exclure les affy non detectes (que des A ou M)
	set dd [lindex $LesChamps 1]
	# Ajout ---
	#if {![info exists Vu($dd)]} {continue}
	# Fin ajout ---
	set TAR [lindex $LesChamps 2]
	set Detn [lindex $LesChamps 22]
	set Dete [lindex $LesChamps 23]
	set Dets [lindex $LesChamps 24]
	set Detu [lindex $LesChamps 25]
	if {($Detn=="A" || $Detn=="M") &&  ($Dete=="A" || $Dete=="M") &&  ($Dets=="A" || $Dets=="M") &&  ($Detu=="A" || $Detu=="M")} {
	    lappend LesAbsents $TAR
	    continue
	}

	#2: Exclure les overlaps avec FC inferieur au seuil fixe
	####a:recup data Fold DD et Affy
	if {$TumorType=="E"} {
	    set FoldAffy [lindex $LesChamps 30]
	    set FoldDD [lindex $LesChamps 10]
	    set ProfilAffy [lindex $LesChamps 31]
	    set ProfilDD [lindex $LesChamps 11]
	}
	if {$TumorType=="S"} {
	    set FoldAffy [lindex $LesChamps 32]
	    set FoldDD [lindex $LesChamps 12]
	    set ProfilAffy [lindex $LesChamps 33]
	    set ProfilDD [lindex $LesChamps 13]
	}
	if {$TumorType=="U"} {
	    set FoldAffy [lindex $LesChamps 34]
	    set FoldDD [lindex $LesChamps 14]
	    set ProfilAffy [lindex $LesChamps 35]
	    set ProfilDD [lindex $LesChamps 15]
	}
	if {$TumorType=="3T"} {
	    set FoldAffy [lindex $LesChamps 36]
	    set FoldDD [lindex $LesChamps 16]
	    set ProfilAffy [lindex $LesChamps 37]
	    set ProfilDD [lindex $LesChamps 17]
	}	
	####b: exclure les genes qui rentrent pas ds les criteres de stringence
	if {$FCAffy!=0 && $FCDD!=0} {
	    #si les cutoff sont differents de zero.
	    if {$FoldAffy>0 && $FoldAffy<=$FCAffy} {continue}
	    if {$FoldAffy<0 && $FoldAffy>=(-$FCAffy)} {continue}
	    if {$FoldDD!="" && $FoldDD!=0} {
		#
		if {$FoldDD>0 && $FoldDD<=$FCDD} {continue}
		if {$FoldDD<0 && $FoldDD>=(-$FCDD)} {continue}
	    }
	}

	#3:Exclure les affy avec les intensites par exemple inferieures a 650
	set Intn [lindex $LesChamps 26]
	set Inte [lindex $LesChamps 27]
	set Ints [lindex $LesChamps 28]
	set Intu [lindex $LesChamps 29]	
	if {$Intn<=$IntMin && $Inte<=$IntMin && $Ints<=$IntMin && $Intu<=$IntMin} {
	    lappend LesFaibles $TAR
	    continue
	}

	#3: Comparer profils du DD (profilgel ou profilcalc ou profilcons) avec profil affy
	set ProfilCalcDD [lindex $LesChamps 18]
	set ProfilConsDD [lindex $LesChamps 19]
	if {$ProfilDD==$ProfilAffy || $ProfilCalcDD==$ProfilAffy || $ProfilConsDD==$ProfilAffy} {
	    incr NbMemeProfil
	    lappend Liste $Ligne
	    if {$ProfilAffy=="N"} {incr NbN}
	    if {$ProfilAffy=="T"} {incr NbT}
	} else {
	    #ne pas compter les complexes
	    if {($ProfilDD=="" || $ProfilDD==0) &&  ($ProfilConsDD=="" || $ProfilConsDD=="?" || $ProfilConsDD=="0") &&  $ProfilCalcDD=="C" } {
		incr nbcomplexes
		continue
	    }
	    if {$ProfilAffy=="N"} {incr TN}
	    if {$ProfilAffy=="T"} {incr NT}
	    lappend ListeProfOpp $Ligne
	}
	incr NbComparaisons
	lappend ListeComplete $Ligne
	#3: compare fc
	#if {$FoldDD>0 && $FoldAffy<0} {incr TN}
	#if {$FoldDD<0 && $FoldAffy>0} {Espionne $dd;incr NT}
    }
    #Espionne $LesAbsents
    Espionne "absents: [llength $LesAbsents]"
    Espionne "lesfaibles: [llength $LesFaibles]"
    Espionne "nb complexes: $nbcomplexes"
    Espionne "$NbMemeProfil sur $NbComparaisons"
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/OVERLAP931NEW/ListeDesGenesAuxProfilsCorreles_1et3_pour820final"
    Espionne "$NbN N, $NbT T"
    Espionne "dd T et affy N: $TN - NT: $NT"
    Espionne "nb profils opposes : [llength $ListeProfOpp]"
    #Espionne $ListeProfOpp
    #SauveLesLignes $ListeProfOpp dans "[RepertoireDuGenome]/OVERLAP931NEW/esp_ListeDesGenesAuxProfilsOpposes_3T"
    #set PercentN [expr $NbN*1.0/($NbComparaisons-$NbT)]
    #set PercentT [expr $NbT*1.0/($NbComparaisons-$NbN)]
    #Espionne "percent N: $PercentN -- T: $PercentT"
    set Percent [expr $NbMemeProfil*1.0/$NbComparaisons]
    #Espionne [llength $ListeComplete]
    #SauveLesLignes $ListeComplete dans "[RepertoireDuGenome]/OVERLAP931NEW/PourGraphRatio"
    return $Percent

}

proc AnalyseGlobaleOverlap_pourCorrelFC {FichierOverlap {TumorType 3T} {IntMin 0} {FCAffy 0.0} {FCDD 0.0}} {

    #FichierOverlap ANALYSE/Overlap.final (333 overlaps DD-Affy avec les profils etc..)
    #aucune target Affy dont les 4 valeurs de detection sont egales A ou M n'est acceptee
    #TumorType: E, S, ou U, ou 3T (moy des 3 T)
    set NbComparaisons 0
    set NbMemeProfil 0
    set NbN 0
    set NbT 0
    set TN 0
    set NT 0
    set LesFaibles ""
    set Liste ""
    set n 0
    set nbcomplexes 0
    foreach Ligne [LesLignesDuFichier $FichierOverlap] {
	set Ligne [string trim $Ligne]
	if {$Ligne ==""} {continue}
	set LesChamps [split $Ligne "\t"]
	incr n
	#1: Exclure les affy non detectes (que des A ou M)
	set dd [lindex $LesChamps 1]
	set TAR [lindex $LesChamps 2]
	set Detn [lindex $LesChamps 22]
	set Dete [lindex $LesChamps 23]
	set Dets [lindex $LesChamps 24]
	set Detu [lindex $LesChamps 25]
	if {($Detn=="A" || $Detn=="M") &&  ($Dete=="A" || $Dete=="M") &&  ($Dets=="A" || $Dets=="M") &&  ($Detu=="A" || $Detu=="M")} {
	    lappend LesAbsents $TAR
	    continue
	}
	#correction
	#if {$Detn=="A" || $Detn=="M"} {continue}
	#if {($Dete=="A" || $Dete=="M") &&  #($Dets=="A" || $Dets=="M") &&  #($Detu=="A" || $Detu=="M")} {
	    #continue
	#}

	#2: Exclure les overlaps avec FC inferieur au seuil fixe
	####a:recup data Fold DD et Affy
	if {$TumorType=="E"} {
	    set FoldAffy [lindex $LesChamps 30]
	    set FoldDD [lindex $LesChamps 10]
	    set ProfilAffy [lindex $LesChamps 31]
	    set ProfilDD [lindex $LesChamps 11]
	}
	if {$TumorType=="S"} {
	    set FoldAffy [lindex $LesChamps 32]
	    set FoldDD [lindex $LesChamps 12]
	    set ProfilAffy [lindex $LesChamps 33]
	    set ProfilDD [lindex $LesChamps 13]
	}
	if {$TumorType=="U"} {
	    set FoldAffy [lindex $LesChamps 34]
	    set FoldDD [lindex $LesChamps 14]
	    set ProfilAffy [lindex $LesChamps 35]
	    set ProfilDD [lindex $LesChamps 15]
	}
	if {$TumorType=="3T"} {
	    set FoldAffy [lindex $LesChamps 36]
	    set FoldDD [lindex $LesChamps 16]
	    set ProfilAffy [lindex $LesChamps 37]
	    set ProfilDD [lindex $LesChamps 17]
	}	
	####b: exclure les genes qui rentrent pas ds les criteres de stringence
	#test sur minimum de stringence - arguments fournis: FCAffy et FCDD
	if {$FoldAffy>0 && $FoldAffy<=$FCAffy} {continue}
	if {$FoldAffy<0 && $FoldAffy>=(-$FCAffy)} {continue}
	if {$FoldDD!="" && $FoldDD!=0} {
	    if {$FoldDD>0 && $FoldDD<=$FCDD} {continue}
	    if {$FoldDD<0 && $FoldDD>=(-$FCDD)} {continue}
	}
	#if {[regexp "DD0037" $Ligne]} {FaireLire "$dd dd: $FoldDD affy: $FoldAffy"}
	#3:Exclure les affy avec les intensites inf a 650
	set Intn [lindex $LesChamps 26]
	set Inte [lindex $LesChamps 27]
	set Ints [lindex $LesChamps 28]
	set Intu [lindex $LesChamps 29]	
	if {$Intn<=$IntMin && $Inte<=$IntMin && $Ints<=$IntMin && $Intu<=$IntMin} {
	    lappend LesFaibles $TAR
	    continue
	}
	#voir quand T et N sont faibles alors T/N fort.
	set MoyenneDesT [format "%.3f" [expr ($Inte+ $Ints + $Intu)/3]]

	#if {$Intn<800 && $MoyenneDesT<800} {
	    #set FoldMoy -[expr $In($CodeAffy)*1.0/$MoyenneDesT]; set PMoy "N"
	    #Espionne "$TAR N:$Intn T:$MoyenneDesT -DetN :$Detn"
	    #continue
	#}
	
	#3: Comparer profils du DD (profilgel ou profilcalc ou profilcons) avec profil affy
	set ProfilCalcDD [lindex $LesChamps 18]
	set ProfilConsDD [lindex $LesChamps 19]
	if {$ProfilDD==$ProfilAffy || $ProfilCalcDD==$ProfilAffy || $ProfilConsDD==$ProfilAffy} {
	    #Exclure ceux ou le profildd s'oppose au profil calc ou cons qui est comme le profil affy ...cad s'oppose au profil affy
	    #if {$ProfilDD!=$ProfilCalcDD || $ProfilDD!=$ProfilConsDD} {continue}
	    #if {$ProfilDD!=$ProfilAffy} {continue}
	    #Comment: de toute facon la courbe reste la meme avec une diminution de la correlation qd FCAffy est entre 8 et 12 a peu pres
	    incr NbMemeProfil
	    lappend Liste $Ligne
	    if {$ProfilAffy=="N"} {incr NbN}
	    if {$ProfilAffy=="T"} {incr NbT}
	} else {
	    #ne pas compter les complexes
	    if {($ProfilDD=="" || $ProfilDD==0) &&  ($ProfilConsDD=="" || $ProfilConsDD=="?" || $ProfilConsDD=="0") &&  $ProfilCalcDD=="C" } {
		incr nbcomplexes
		continue
	    }
	    if {$ProfilAffy=="N"} {incr TN}
	    if {$ProfilAffy=="T"} {incr NT}
	    lappend ListeProfOpp $Ligne
	}
	incr NbComparaisons
	lappend ListeComplete $Ligne
	#T/N
	#Espionne "T: $MoyenneDesT"
	#Espionne "N: $Inte"
    }
    #Espionne [llength $ListeComplete]
    EspionneL $ListeComplete
    #Espionne "$NbMemeProfil meme profil - opp: [llength $ListeProfOpp] -nbcompar:$NbComparaisons"
    set Percent [expr $NbMemeProfil*1.0/$NbComparaisons]
    #Espionne $ListeProfOpp
    return "$Percent $NbMemeProfil $NbComparaisons exclus:$nbcomplexes"   

}

proc AnalyseLeBlastN {Fichier {BanqueBlast ""}} {

    global RepertoireDuGenome



    if { ! [file exists $Fichier]} {
	set FichierDeLOrga "$RepertoireDuGenome/blastn/[file tail $Fichier]"
	if { ! [file exists $FichierDeLOrga]} {
	    FaireLire "Sorry, I can't find  \n $Fichier \n nor \n $FichierDeLOrga"
	    return ""
	}
	set Fichier $FichierDeLOrga
    }

    CreeLesBornesDuBlastN     $Fichier $BanqueBlast
    LesZonesDuBlastNEnOverlap $Fichier
    exit

}

proc AnalyseLesDbClustal {} {

    if { [OuiOuNon "Do I run analysis on DBClustal outputs ? "]} {
	set DisPhy [OuiOuNon "CreeDistancesPhyloAvecLesMSFs ?"]
	set PIPS   [OuiOuNon "CreeLesFichiersPIClustalwEtPSClustalw ?"]
	set Oo     [OuiOuNon "ORGAorgaDesMSFs ?"]
	set PhylOr [OuiOuNon "PhylumsOrthologues ?"]
	set Para   [OuiOuNon "AlignonsLesParalogues ?"]
    	set TCSD   [OuiOuNon "TestCodonStartEtDeletionDuMSFPourTous ?"]
	set TCSC   [OuiOuNon "StartCodonClusterPourTous and CreeStartCodonReport ?"]
	set Diff   [OuiOuNon "DifferentielBlastAlignementPourTous ?"]
	if { $DisPhy } { CreeDistancesPhyloAvecLesMSFs }
	if { $PIPS   } { CreeLesFichiersPIClustalwEtPSClustalw}
	if { $Oo     } { ORGAorgaDesMSFs "CreateIt" }
	if { $PhylOr } { PhylumsOrthologues bidon }
	if { $Para   } { AlignonsLesParalogues }
    	if { $TCSD   } { TestCodonStartEtDeletionDuMSFPourTous }
    	if { $TCSC   } { StartCodonClusterPourTous ; CreeStartCodonReport }
	if { $Diff   } { DifferentielBlastAlignementPourTous }
    }

}

proc AnalyseLesTBlastN {{BanqueTBlastN ""}} {

    global RepertoireDuGenome

    set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]

    set LaTotale 0 
    if {[OuiOuNon "Do I run all analysis for tBlastN ?\n  ouatapetbn, orthotblastn, ootblastn, two genes cluster, ... ?"]} {
	set LaTotale 1
    }
    if {[file exists "$RepertoireDuGenome/tblastn$BanqueTBlastN"] &&  ! [file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"]} {
	if {$LaTotale || [OuiOuNon "Do I create fiches/ouatapetbn.$BanqueTBlastN ?"]} {
	    CreeOuATapeTBlastN $BanqueTBlastN
	}
    }
    if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] &&  ! [file exists "$RepertoireDuGenome/fiches/orthotblastn"]} {
	if {$LaTotale || [OuiOuNon "Do I create orthotblastn  ?"]} {
	    CreeOrthoTBlastN
	}
    }
    if {[file exists "$RepertoireDuGenome/fiches/orthotblastn"] &&  ! [file exists "$RepertoireDuGenome/fiches/ootblastn"]} {
	if {$LaTotale || [OuiOuNon "Do I create ootblastn ?"]} {
	    ORGAorgaDesTBlastNs "CreateIt"
	}
    }
    if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] &&  ! [file exists "$RepertoireDuGenome/fiches/organismesayantmemeoperon"]} {
	if {$LaTotale || [OuiOuNon "Do I run TwoGeneClusterAnalysis ?"]} {
	    CreeLeFichierOrganismesAyantMemeOperon genomes
	}
    }
    if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] &&  [info exists Org1] &&  ! [file exists "$RepertoireDuGenome/fiches/orthologuesdans$Org1"]} {
	if {$LaTotale || [OuiOuNon "Do I check for orthologs in $Org1 and $Org2 ? "]} {
	    foreach Orga [LesOrganismesTresProches] {
		CreeLeFichierOrthologueDans $Orga
	    }
	}
    }

}

proc AnalyseLongueurSequence {} {

    global RepertoireDuGenome
    set LaListeDesPetits {}
    foreach Nom [ListeDesPABs] {
	set longueur [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]]
	if {$longueur < 9} {lappend LaListeDesPetits $Nom}
    }
    Espionne $LaListeDesPetits

}

proc AnalyseMoi {args} {

    PourWscope 1
    return [Html_DuTexteTelQuel [join $args " "]] 

}

proc AnalyseNucMask {{Commentaire ""}} {

    global RepertoireDuGenome
    set Rep "$RepertoireDuGenome/nucmask"
    set LesMasked {}
    set LesPartiellementMasked {}
    set LesTotalementMasked {}
    set N 0
    set n1 0
    set n2 0
    foreach Fichier [ glob -nocomplain "$Rep/*.m" ] {
	set Contenu [ ContenuDuFichier $Fichier]
	scan $Contenu "%s %s %s %s"  CodeGscope TypeMask CodeClone User   
	regsub -all ">" $CodeGscope "" CodeGscope
	if {$TypeMask != "NoRepeatToMask" } {
	    incr N
	    lappend LesMasked $CodeGscope 
	} 
	if {$TypeMask == "PartiallyMasked"} {
	    incr n1
	    lappend LesPartiellementMasked $CodeGscope 
	    continue
	}
	if {$TypeMask == "TotallyMasked"} {
	    incr n2
	    lappend LesTotalementMasked $CodeGscope 
	    continue
	}
    }

    if {$Commentaire== "partiel" } {
	Espionne "Partially Masked cDNAs: $n1"
	Espionne "List of the partially Masked cDNAs: \n $LesPartiellementMasked"
	exit
    }
    if {$Commentaire== "total" } {
	Espionne "Totally Masked cDNAs: $n2"
	Espionne "List of the totally Masked cDNAs: \n $LesTotalementMasked"
	exit
    }
    Espionne "Masked cDNAs: $N"
    set Pourcent [expr round ($N/2899.0 *100)]
    Espionne "Percent/HeadNeck3: $Pourcent %" 
    Espionne "Partially Masked cDNAs: $n1"
    Espionne "Totally Masked cDNAs: $n2"
    Espionne "Total liste: \n $LesMasked "
    FaireLire ok
    return $LesMasked 

}

proc AnalyseNucMaskAndReMask {{Comment ""}} {

    global RepertoireDuGenome
    set Rep "$RepertoireDuGenome/nucMaskAndReMask"
    set LesMRM {}
    set LesPartiellementMRM {}
    set LesTotalementMRM {}
    set N 0
    set n1 0
    set n2 0
    foreach Fichier [ glob -nocomplain "$Rep/*.mrm" ] {
	set Contenu [ ContenuDuFichier $Fichier]
	scan $Contenu "%s %s %s %s %s %s"  CodeGscope CodeClone User TypeMask  Pourcent Fin 
	regsub -all ">" $CodeGscope "" CodeGscope
	regsub -all "%" $Pourcent "" Pourcent
	if {$TypeMask != "NoRepeatToMRM" } {
	    incr N
	    lappend LesMRM $CodeGscope 
	} 
	if {$TypeMask == "PartiallyMRM"} {
	    incr n1
	    lappend LesPartiellementMRM $CodeGscope 
	    continue
	}
	if {$TypeMask == "TotallyMRM"} {
	    incr n2
	    lappend LesTotalementMRM $CodeGscope 
	    continue
	}
    }

    if {$Comment== "partiel" } {
	Espionne "Partially MRM cDNAs: $n1"
	Espionne "List of the partially MRM cDNAs: \n $LesPartiellementMRM"
	exit
    }
    if {$Comment== "total" } {
	Espionne "Totally MRM cDNAs: $n2"
	Espionne "List of the totally MRM cDNAs: \n $LesTotalementMRM"
	exit
    }
    Espionne "MRM cDNAs: $N"
    set Pourcent [expr round ($N/2899.0 *100)]
    Espionne "Percent/HeadNeck3: $Pourcent %" 
    Espionne "Partially MRM cDNAs: $n1"
    Espionne "Totally MRM cDNAs: $n2"
    Espionne "Total liste: \n $LesMRM "
    #SauveLesLignes $LesMRM dans "$RepertoireDuGenome/listeDesPABsMRM" 

}

proc AnalyseNucReMask {{Comment ""}} {

    global RepertoireDuGenome
    set Rep "$RepertoireDuGenome/nucremask"
    set LesRemasques {}
    set LesPartiellementReMasques {}
    set LesTotalementReMasques {}
    set N 0
    set n1 0
    set n2 0
    foreach Fichier [ glob -nocomplain "$Rep/*.rm" ] {
	set Contenu [ ContenuDuFichier $Fichier]
	scan $Contenu "%s %s %s %s %s %s %s"  CodeGscope CodeClone User TypeMask Pourcent TypeRepeat Fin 
	regsub -all ">" $CodeGscope "" CodeGscope
	regsub -all "%" $Pourcent "" Pourcent
	if {$TypeMask != "NoSequenceToReMask" && $TypeMask != "NoRepeatToReMask"  } {
	    incr N
	    lappend LesRemasques $CodeGscope 
	} 
	if {$TypeMask == "PartiallyReMasked"} {
	    incr n1
	    lappend LesPartiellementRemasques $CodeGscope 
	    continue
	}
	if {$TypeMask == "TotallyReMasked"} {
	    incr n2
	    lappend LesTotalementReMasques $CodeGscope 
	    continue
	}
    }

    if {$Comment== "partiel" } {
	Espionne "Partially remasked cDNAs: $n1"
	Espionne "List of the partially remasked cDNAs: \n $LesPartiellementRemasques"
	exit
    }
    if {$Comment== "total" } {
	Espionne "Totally remasked cDNAs: $n2"
	Espionne "List of the totally remasked cDNAs: \n $LesTotalementReMasques"
	exit
    }
    Espionne "Remasked cDNAs: $N"
    set Pourcent [expr round ($N/2899.0 *100)]
    Espionne "Percent/HeadNeck3: $Pourcent %" 
    Espionne "Partially remasked cDNAs: $n1"
    Espionne "Totally remasked cDNAs: $n2"
    Espionne "Total liste: \n $LesRemasques "
    SauveLesLignes $LesRemasques dans "$Rep/lesremasques" 

}

proc AnalyseResAffymetrix_ProbeSet {FichierAffy} {


    Wup "Permet d obtenir des stats sur le resultat des recherche blat et des NM associes aux ProbeSet Affy"

    set nbProbeSet 0

    set F  [open "$FichierAffy"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	if {! [regexp {^>>>}              $Ligne]} {continue}
	
	#Espionne "$Ligne"

	set LigneSplitee [split $Ligne "\t"]

	set NbRefSeqTrouve   0
	set ProbeSetID       ""
	set LesRefSeqTrouves ""
	set RefSeqAffy       ""
	set DefAffy          ""

	set ProbeSetNoBlat   0
	set ProbeSetNoIds    0
	set RefSeqTrouve     0

	set NbRefSeqTrouve   0
	set ProbeSetID       [lindex $LigneSplitee 0]
	set LesRefSeqTrouves [split  [lindex $LigneSplitee 1] " "]
	set RefSeqAffy       [lindex $LigneSplitee 2]
	set DefAffy          [lindex $LigneSplitee 3]

	#Nombre de RefSeq trouve par ProbeSet
	if {      [regexp -nocase "no ids"  $LesRefSeqTrouves]} {
	    set ProbeSetNoIds    "1"

	    set NbRefSeqTrouve   "0"
	    set LesRefSeqTrouves ""
	    set RefSeqTrouve     "0"
	} elseif {[regexp -nocase "no blat hit" $Ligne]} {
	    set ProbeSetNoBlat   "1"
	    
	    set LesRefSeqTrouves ""
	    set RefSeqTrouve     "0"
	} else {
	    set NbRefSeqTrouve   [llength $LesRefSeqTrouves]
	    set RefSeqTrouve 1

	    set  NbRefSeqTrouve2 [regexp -all "NM_" $LesRefSeqTrouves]
	    if {$NbRefSeqTrouve != $NbRefSeqTrouve2} {
		Espionne "$ProbeSetID\t$NbRefSeqTrouve\t$NbRefSeqTrouve2"
	    }
	}
	
	#Nombre de ProbetSet ou on a pas trouve un RefSeq
	if {! [info exists TabResAffy(nbProbeSetNoIds)]} {
	    set  TabResAffy(nbProbeSetNoIds)  0
	}				       
	if {$ProbeSetNoIds} {
	    incr TabResAffy(nbProbeSetNoIds)
	}
	#Nombre de ProbetSet ou on a pas trouve de genome
	if {! [info exists TabResAffy(nbProbeSetNoBlat)]} {
	    set  TabResAffy(nbProbeSetNoBlat) 0
	}				       
	if {$ProbeSetNoBlat} {
	    incr TabResAffy(nbProbeSetNoBlat)
	}
	#Nombre de ProbetSet ou on a trouve un RefSeq
	if {! [info exists TabResAffy(nbProbeSetTrouve)]} {
	    set  TabResAffy(nbProbeSetTrouve) 0
	}				       
	if {$RefSeqTrouve} {
	    incr TabResAffy(nbProbeSetTrouve)
	}

	#Nombre de ProbeSet Affy a trouve
	if {! [info exists TabResAffy(nbProbeSetAvecNMAffy)]} {
	    set  TabResAffy(nbProbeSetAvecNMAffy) 0
	}				       
	if {[regexp -nocase "NM_" $RefSeqAffy] || [regexp -nocase "NM_" $DefAffy]} {
	    incr TabResAffy(nbProbeSetAvecNMAffy)
	    set NMPourProbeSet 1
	} else {
	    set NMPourProbeSet 0
	}

	#Nombre de ProbetSet ou on a trouve un RefSeq et valide
	set RefSeqValide 0
	if {$NMPourProbeSet} {
	    if {$RefSeqTrouve} {
		foreach Acc $LesRefSeqTrouves {
		    if {[regexp -nocase $Acc $RefSeqAffy] || [regexp -nocase $Acc $DefAffy]} {
			#Espionne "$Acc - $RefSeqAffy"
			set RefSeqValide 1
			break
		    }
		    #Espionne "$ProbeSetID -- $Acc - $RefSeqAffy"
		}
	    }
	} else {
	    if {! [info exists TabResAffy(nbRefSeqEnPlus)]} {
		set  TabResAffy(nbRefSeqEnPlus) 0
	    }
	    if {$RefSeqTrouve} {
		incr TabResAffy(nbRefSeqEnPlus)
	    }
	}
	incr nbProbeSet

	#Nombre de ProbeSet valide entre Affy et RefSeaq trouve
	if {! [info exists TabResAffy(nbValide)]} {
	    set  TabResAffy(nbValide) 0
	}
	if {$RefSeqValide} {
	    incr TabResAffy(nbValide)
	}

	if {! [info exists TabResAffy(nbTrouve,$NbRefSeqTrouve)]} {
	    set TabResAffy(nbTrouve,$NbRefSeqTrouve) 0
	}
	incr    TabResAffy(nbTrouve,$NbRefSeqTrouve)
	
	if {! [info exists TabResAffy(LesnbTrouve)]} {
	    set TabResAffy(LesnbTrouve) ""
	}
	lappend TabResAffy(LesnbTrouve) $NbRefSeqTrouve
    }
    close $F

    set TabResAffy(LesnbTrouve) [lsort -unique -integer -increasing [set TabResAffy(LesnbTrouve)]]

    Espionne "Affymetrix HG-U133 Plus ProbeSet Analysis"
    Espionne "Nb ProbeSet: $nbProbeSet"
    Espionne "Nb ProbeSet avec NM (Affy): [set TabResAffy(nbProbeSetAvecNMAffy)]"
    Espionne "Nb ProbeSet avec NM trouve: [set TabResAffy(nbProbeSetTrouve)]"
    Espionne "Nb ProbeSet sans NM: [set TabResAffy(nbProbeSetNoIds)]"
    Espionne "Nb ProbeSet sans Blat: [set TabResAffy(nbProbeSetNoBlat)]"
    Espionne "Nb ProbeSet Total: [expr [set TabResAffy(nbProbeSetTrouve)]+[set TabResAffy(nbProbeSetNoIds)]+[set TabResAffy(nbProbeSetNoBlat)]]"
    Espionne "Nb ProbeSet valide: [set TabResAffy(nbValide)]"
    #Espionne "Percent Valide: [expr ([set TabResAffy(nbValide)]*100.0)/[set TabResAffy(nbProbeSetTrouve)]]"
    Espionne "Percent Valide par rapport Affy: [expr ([set TabResAffy(nbValide)]*100.0)/[set TabResAffy(nbProbeSetAvecNMAffy)]]"
    Espionne "Nb ProbeSet en plus d Affy: [set TabResAffy(nbRefSeqEnPlus)]"

    foreach Nb [set TabResAffy(LesnbTrouve)] {
	Espionne "$Nb\t[set TabResAffy(nbTrouve,$Nb)]"
    }

    return ""

}

proc AnalyseSelections {outOf} {


    LesDefauts
    DefinitionPreferences
    InitComparaison
    global SDG
    global ListeDesAcidesAmines
    global TableauCouleurEtGroupe
    global Threshold
    global Defauts
    global TypeCons
    global ConsRef
    global ListeDesConsensusDuGroupe
    global Sequences
    global lesTypes

    if {$outOf == ""} {
	set lesTypes [list "_nature" "_mounir" "_bandelettes" "_luc"]
	set repIn "msf_nature/Rascal/Leon"
    } else {
	set lesTypes [list "_Selnature" "_Selmounir" "_Selbandelettes" "_Selluc"]
	set repIn "msf_Selnature"
    }

    set fileOut {}
    set file {}
    puts "Info\tNature\tSelMounir\tSelBandelettes\tSelLuc"
    set Lpab [ListeDesPABs]
    set Lpab [lrange $Lpab 269 end]
    #set Lpab "nPDB054"
    foreach f $Lpab {
	set lNbSeq {}
	set lNbSeqId {}
	set lNbClus {}
	set lNbIdGlob {}
	set lNbCGlob {}
	set lNbSGlob {}
	set lRandInd {}

	if {![file exists [file join [RepertoireDuGenome] ${repIn} $f]]} {continue}
	if {[lsearch [LesLignesDuFichier [file join [RepertoireDuGenome] ${repIn} $f]] "NoSequenceToAlign"] == 0} {continue}

	foreach type $lesTypes {

	    # mode Batch pour travailler sans interface graphique
	    LesDefauts Mode "Batch"
	    LesDefauts CheckSeq 0
	    set Threshold [set Defauts(Threshold)]

	    if {$outOf == ""} {
		set file  [file join [RepertoireDuGenome] "msf$type" "Rascal" "Leon" $f]
		set ficComp "/usr/tmp/${f}_nature.clu"
	    } else {
		set file  [file join [RepertoireDuGenome] "msf$type" $f]
		set ficComp "/usr/tmp/${f}_Selnature.clu"
	    }

	    DecortiqueEtAfficheUnMSF $file
	    DefinitionGroupes "dpc"
	    RunOrdali
	    RecupereReference
	    set grps($type) [array get SDG]
	    set data($type) [RecupereDonneesGlobales $type]

	    lappend lNbSeq [lindex [set data($type)] 0]
	    lappend lNbClus [lindex [set data($type)] 1]
	    lappend lNbIdGlob [lindex [set data($type)] 2]
	    lappend lNbCGlob [lindex [set data($type)] 3]
	    lappend lNbSGlob [lindex [set data($type)] 4]

	    #mise en evidence des residus Globaux (identite, conservation et similarite)
	    set lR$type [TabGlobaux $f [set data($type)] $outOf]

	    # traitement du fichier resu de la clusterisation
	    # comparaison des clusters obtenus pour chacune des selection par rapport a la ref
	    # calcul d un indice de conservation
	    set fileOut "/usr/tmp/${f}.dpc"
	    set fic "/usr/tmp/${f}${type}.clu"
	    file copy -force $fileOut $fic

	    if {![regexp "nature" $type]} {
		set lstat($type) [CompCluster $ficComp $fic]
		lappend lRandInd [string range [lindex [set lstat($type)] 0] 0 3]
		lappend lNbSeqId [lindex [set lstat($type)] 1]
	    } else {
		array set SeqN [array get Sequences]
	    }

	    FermeFichier
	}

	set lCommunsGlobaux [DetermineNbGlobauxCommuns [set lR[lindex $lesTypes 1]] [set lR[lindex $lesTypes 2]] [set lR[lindex $lesTypes 3]] [set lR[lindex $lesTypes 0]]]

	#determination des groupes communs
	set ListeCorrespondance [DetermineGroupesEquivalents [array get grps] [array get data] [array get SeqN]]
	puts "\n"
	puts "${f}_NbSeqTot\t[lindex $lNbSeq 0]\t[lindex $lNbSeq 1]\t[lindex $lNbSeq 2]\t[lindex $lNbSeq 3]"
	puts "${f}_NbSeqIden\t[lindex $lNbSeq 0]\t[lindex $lNbSeqId 0]\t[lindex $lNbSeqId 1]\t[lindex $lNbSeqId 2]"
	puts "${f}_NbIdGlob\t[lindex $lNbIdGlob 0]\t[lindex $lNbIdGlob 1]\t[lindex $lNbIdGlob 2]\t[lindex $lNbIdGlob 3]"
	puts "${f}_NbIdGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 3]"
	puts "${f}_NbConsGlob\t[lindex $lNbCGlob 0]\t[lindex $lNbCGlob 1]\t[lindex $lNbCGlob 2]\t[lindex $lNbCGlob 3]"
	puts "${f}_NbConsGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 3]"
	puts "${f}_NbSimiGlob\t[lindex $lNbSGlob 0]\t[lindex $lNbSGlob 1]\t[lindex $lNbSGlob 2]\t[lindex $lNbSGlob 3]"
	puts "${f}_NbSimiGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 3]"
	puts "${f}_NbClusTot\t[lindex $lNbClus 0]\t[lindex $lNbClus 1]\t[lindex $lNbClus 2]\t[lindex $lNbClus 3]"
	puts "${f}_aRandIndex\t1\t[lindex $lRandInd 0]\t[lindex $lRandInd 1]\t[lindex $lRandInd 2]"
	for {set i 1} {$i<=[lindex $lNbClus 0]} {incr i} {
	    puts "${f}_Cl${i}-SqId-IdGrCom\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 0]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 0]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 0]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 1]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 1]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 1]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 2]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 2]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 2]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 3]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 3]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 3]"
	}

	# efface fichiers crees pour la clusterisation dans /usr/tmp
	foreach fic [glob -nocomplain /usr/tmp/*${f}*] {
	    file delete -force $fic
	}
    }
    return 1

}

proc AnalyseSortieBlastADNc {{Liste ""}} {

    #Attention au gap=> ok
    #Attention aux n

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }

    set RepertoireSortieBlast "[RepertoireDuGenome]/blastnSuperSouris"
    set total 0; set statcas0 0; set statcas2a 0; set statcas2b 0; set statcas1 0; set lesout 0
    set statcas2c 0; set statcas2d 0; set statcas2cd 0
    foreach Nom $Liste {
	set File "$RepertoireSortieBlast/$Nom"
	set LesBons {}
	incr total
	set Queue [file tail $File]
	#Espionne "$Queue"
	set NbSujet [AskBlast $File NbSubject]
	#Espionne "NbSujet $NbSujet"
	if {$NbSujet==0} {
	    incr statcas0
	    continue
	}
	set cas1 0; set cas2 0; set cas2a 0; set cas2b 0; set cas2c 0; set cas2d 0

	for {set j 1} {$j<=$NbSujet} {incr j} {
	    set BId       [AskBlast $File Subject $j]
	    #Espionne "BId $BId"
	    set NbSegment [AskBlast $File BanqueId $BId NbSegment]
	    #Espionne "NbSegment $NbSegment"
	    for {set i 1} {$i<=$NbSegment} {incr i} {
		set LesLignesFinales {}
		set PId [AskBlast $File BanqueId $BId Segment $i Identities]
		set Gap [AskBlast $File BanqueId $BId Segment $i Gaps]
		regexp {([0-9]+)/([0-9]+) (\([0-9]+%\))} $PId Tmp nbId nbTot Pourcentage
		regsub -all {\(} $Pourcentage "" Pourcentage
		regsub -all {\)} $Pourcentage "" Pourcentage
		regsub % $Pourcentage "" Pourcentage
		#Espionne "PId $PId"
		#Espionne "++$nbId $nbTot $Pourcentage"
		#Espionne "Gap $Gap"
		#Espionne "$nbTot $Pourcentage $Gap"
		
		if {$nbTot<60} {set cas1 1}
		if {$nbTot>60} {
		    set cas2 1
		    if {$Pourcentage == "100"} {
			set cas2a 1
			lappend LesBons $BId
		    } 
		    if {$Pourcentage != "100"} {
			set cas2b 1
			set Align [AskBlast $File BanqueId $BId Segment $i Align]
			Espionne "$Align"
			set LesLignes [split $Align "\n"]
			set LesLignes [ListeSsElmtVide $LesLignes]
			foreach Ligne $LesLignes {
			    if {[regexp {^Query} $Ligne]} {
				set index [string first ":" $Ligne]
				set result [regexp -start $index -inline {[a-z]} $Ligne]
				set indexfinal [string first $result $Ligne $index]
				#Espionne "result $result"
				#Espionne "indexfinal $indexfinal"
				continue
			    }
			    if {[regexp {^Sbjct} $Ligne]} {continue}
			    if {![regexp {\|} $Ligne]} {continue}
			    #Espionne "1$Ligne"
			    set Ligne [string range $Ligne $indexfinal end]
			    #Espionne "2$Ligne"
			    lappend LesLignesFinales $Ligne
			}
			set LeResult [join $LesLignesFinales ""]
			#Espionne $LeResult
			set LesTraits [split $LeResult ""]
			set nombredetrait [llength $LesTraits]
			set Max 0; set nbtrait 0; set nbelmt 0
			foreach Trait $LesTraits {
			    incr nbelmt
			    #Espionne "++$Trait"
			    if {$Trait=="|"} {
				incr nbtrait
			    }
			    if {$Trait!="|"} {
				#Espionne "$nbtrait"
				if {$nbtrait>$Max} {set Max $nbtrait}
				set nbtrait 0
			    }
			    if {$nbelmt==$nombredetrait} {
				#Espionne "$nbtrait"
				if {$nbtrait>$Max} {set Max $nbtrait}
				set nbtrait 0
			    }
			}
			if {$Max>=60} {
			    lappend LesBons $BId
			    set cas2c 1
			} elseif {$Max<60} {
			    set cas2d 1
			}
		    }
		}
		#Espionne "$cas1 $cas2 $cas2a $cas2b $cas2c $cas2d"
	    }
	}
	if {$cas2a} {
	    incr statcas2a
	    #Espionne "$Queue oui"
	} elseif {$cas2b} {
	    incr statcas2b
	    #Espionne "$Queue test"
	    if {$cas2c && $cas2d} {
		incr statcas2cd
		#Espionne "$Queue ouietnonaptest"
	    } elseif {$cas2c && !$cas2d} {
		incr statcas2c
		#Espionne "$Queue ouiaptest"
	    } elseif {!$cas2c && $cas2d} {
		incr statcas2d
		#Espionne "$Queue nonaptest"
	    }
	} elseif {$cas1} {
	    incr statcas1
	    #Espionne "$Queue non"
	} else {
	    incr lesout
	    #Espionne "$Queue out"
	}
	set LesBons [ListeSansDoublon $LesBons]
	set LaChaineBonne [join $LesBons " "]
	if {$LesBons =={}} {
	    Espionne "BanqueADNc: No"
	    InformeSansDemander $Queue "BanqueADNc: No"
	}
	if {$LesBons!={}} {
	    Espionne "BanqueADNc: Yes $LaChaineBonne"
	    InformeSansDemander $Queue "BanqueADNc: Yes $LaChaineBonne"
	}
    }
    #Espionne "total $total"
    #Espionne "statcas0 $statcas0"
    #Espionne "statcas2a $statcas2a"
    #Espionne "statcas2b $statcas2b"
    #Espionne "statcas2cd $statcas2cd"
    #Espionne "statcas2c $statcas2c"
    #Espionne "statcas2d $statcas2d"
    #Espionne "statcas1 $statcas1"
    #Espionne "lesout $lesout"

}

proc AnalyseSortieBlastMagos {} {

    set LesLignesEcrites {}
    set File "/genomics/link/retinalFateForLaetitia/blastponms2phDB/recapResuBlastOnMs2phDB"
    set LesLignes [LesLignesDuFichier $File]
    set total 0; set bon 0; set mauvais 0; set intermediarymauvais 0; set intermediarybon 0; set saispas 0
    foreach Ligne $LesLignes {
	incr total
	set LigneEcrite ""
	if {[regexp {^pab} $Ligne]} {continue}
	set Elmts [split $Ligne "\t"]
	set IdBlast  [lindex $Elmts 0]
	set Query    [AskBlast $IdBlast Query]
	set LesElmtsQuery [split $Query " "]
	set Nom [lindex $LesElmtsQuery 1]
	set AccMouse [lindex $Elmts 1]
	set AccHuman [lindex $Elmts 2]
	set expect   [lindex $Elmts 3]
	set CommandeMouse "getz \"\\\[protein-acc:$AccMouse\\\]\" \-f gen"
	set GetzOutMouse [eval exec $CommandeMouse]
	set CommandeHuman "getz \"\\\[protein-acc:$AccHuman\\\]\" \-f gen"
	set GetzOutHuman [eval exec $CommandeHuman]
	if {$expect=="0.0"} {
	    Espionne "$Ligne => bon"
	    incr bon
	    if {$IdBlast=="evi022" || $IdBlast=="evi030" || $IdBlast=="evi036" || $IdBlast=="evi056"} {
		continue
	    }
	    if {$IdBlast=="evi014"} {
		set LigneEcrite "$IdBlast\t$Nom\tP04001"
		lappend LesLignesEcrites $LigneEcrite
		continue
	    }
	    set LigneEcrite "$IdBlast\t$Nom\t$AccHuman"
	    lappend LesLignesEcrites $LigneEcrite
	} elseif {$expect>"1"} { 
	    Espionne "$Ligne => mauvais"
	    incr mauvais
	} elseif {$expect>1.e-50} {
	    Espionne "$Ligne => intermediarymauvais"
	    incr mauvais
	} elseif {$expect<=1.e-118} {
	    Espionne "$Ligne => intermediarybon"
	    incr intermediarybon
	    if {$IdBlast=="evi005" || $IdBlast=="evi008"} {
		continue
	    }
	    set LigneEcrite "$IdBlast\t$Nom\t$AccHuman"
	    lappend LesLignesEcrites $LigneEcrite
	} else {
	    Espionne "$Ligne => saispas"
	    incr saispas
	    if {$IdBlast=="evi013" || $IdBlast=="evi037" || $IdBlast=="evi046"} {
		continue
	    }
	    set LigneEcrite "$IdBlast\t$Nom\t$AccHuman"
	    lappend LesLignesEcrites $LigneEcrite
	}
	Espionne "LigneEcrite $LigneEcrite"
    }
    Espionne "total $total"
    Espionne "bon $bon"
    Espionne "mauvais $mauvais" 
    Espionne "intermediarybon $intermediarybon"
    Espionne "saispas $saispas"
    SauveLesLignes $LesLignesEcrites dans "[RepertoireDuGenome]/MagosLesRetinalFateHuman"

}

proc AnalyseTabulatedFile {f} {

    set cont [ContenuDuFichier $f]
    set cont [string map {"\t\|\n" "LuCkYlUc67"} $cont]
    set cont [string map {"\n" " "} $cont]
    set cont [string map {"LuCkYlUc67" "\n"} $cont]
    set Ll [split $cont \n]

    foreach l $Ll {
	set Lix [regexp -all -inline -indices {\t\|\t} $l]
	set i 0
	set dp 0
	foreach li $Lix {
	    lassign $li dc fc
	    lappend C($i) [string range $l $dp $dc-1]
	    set dp [expr {$fc+1}]
	    incr i
	}
	lappend C($i) [string range $l $dp end]
    }
    foreach col [lsort -integer [array names C]] {
	#puts "[lrange $C($col) 0 4]"
	set lg [PlusLongEltDe $C($col)]
	set v  [PlusLongEltDe $C($col) val]
	puts "$col $lg $v"
    }
    unset -nocomplain C

    return
    exit

}

proc AnalyseTestClusterPos {f} {

    set Ll [LesLignesDuFichier $f]
    set res {}
    set vutype 0
    foreach l $Ll {
	if {[regexp {^type } $l]} {
	    if {$res != {} } {
		lappend LRes $res
	    }
	    set res [lindex [split $l " "] 1]
	    set vutype 1
	}
	if {[regexp {^\t} $l] && $vutype} {
	    lappend res [lindex [split $l " "] end]
	}
    }
    lappend LRes $res

    set fmt "%14s |[string repeat "%6.3f" 3] |[string repeat "%6.3f" 3]"

    # Trie sur Identite (1er cluster)
    puts "Tri sur Sum (sens+spec) : Identite"
    set LRes [lsort -real -decreasing -index 3 $LRes]
    foreach e $LRes {
	puts [format $fmt {*}$e]
    }

    # Trie sur global (1er et 2eme cluster)
    puts "\nTri sur Sum (sens+spec) : global"
    set LRes [lsort -real -decreasing -index 6 $LRes]
    foreach e $LRes {
	puts [format $fmt {*}$e]
    }

    exit

}

proc AnalyseValeursPropres {Le} {
    
    set s 0.
    foreach e $Le {
	set s [expr {$s+$e}]
    }
    foreach e $Le {
	lappend Ic [expr {$e/$s*100.}]
    }
    puts "\nEignevalues :"
    set fmt "%s |%7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f"
    puts [format $fmt "Abs" {*}[lrange $Le 0 9]]
    puts [format $fmt "Rel" {*}[lrange $Ic 0 9]]
    puts [format $fmt "Abs" {*}[lrange $Le 10 19]]
    puts [format $fmt "Rel" {*}[lrange $Ic 10 19]]
    puts ""

    return

}

proc AnalyseVecteursPropres {Ev {Cen 0}} {

    puts ""
    if {$Cen} {set Ev [CentreVecteur $Ev}

    set iPaaP [CorrelationAxe $Ev]

    set Av [VecteurDeAAIndex $iPaaP]
    set ccp [CoefficientCorrelation $Ev $Av]
    puts [format "%s %6.3f" "Coef.Corr = " $ccp]
    puts ""
	
    return [list $iPaaP $ccp]

}

proc AnalysissoftwareInput {} {

    if { ! [WithWebService "Gx" "TestIfExists"]} { WithWebService "Gx" 1 }
    InfoFromAnalysissoftwareInput
    set LesTetes "name,description,reference"
    foreach Name [InfoFromAnalysissoftwareInput ListOf Name] {
	set Existant [GxDbSqlExec "select pk_analysissoftware from analysissoftware where name='$Name';" "GetFirstValue"]
	if {$Existant!=""} { return "" }
	
	set name        [InfoFromAnalysissoftwareInput $Name "name" ]
	set description [InfoFromAnalysissoftwareInput $Name "description" ]
	set reference   [InfoFromAnalysissoftwareInput $Name "reference" ]

	set Ligne "'$name','$description','$reference'"
	Espionne "$Ligne"
	set Commande "insert into analysissoftware ($LesTetes) values ($Ligne);"
	Espionne "$Commande"
	set status [GxDbSqlExec $Commande]
    }
    return $status

}

proc AncetreCommun {A B {Quoi ""}} {


    Wup "On part des feuilles et on remonte une fois l'un une fois l'autre jusqu'a trouver un commun"

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

    if {[regexp {[^0-9]} $A]} { set A [Tax $A] }
    if {[regexp {[^0-9]} $B]} { set B [Tax $B] }
    if {$A=="" || $B==""} { return "" } 

    set ParentsDeA [list $A]
    set ParentsDeB [list $B]

    set AuTourDeA 1
    while 1 {
	set AncetreA [lindex $ParentsDeA end]
	set AncetreB [lindex $ParentsDeB end]
	#Espionne "A=$ParentsDeA/$AncetreA/[Tax $AncetreA]/ B=$ParentsDeB/$AncetreB/[Tax $AncetreB]/"
	if {[set iA [lsearch -exact $ParentsDeA $AncetreB]]>=0} {
	    if {[string equal -nocase $Quoi "IdCommun" ]} { return $AncetreB }
	    if {[string equal -nocase $Quoi "TwoLists" ]} {
		return [list [lrange $ParentsDeA 0 $iA] $ParentsDeB]
	    }
	    return [Tax $AncetreB $Quoi]
	}
	if {[set iB [lsearch -exact $ParentsDeB $AncetreA]]>=0} {
	    if {[string equal -nocase $Quoi "IdCommun" ]} { return $AncetreA }
	    if {[string equal -nocase $Quoi "TwoLists" ]} {
		return [list $ParentsDeA [lrange $ParentsDeB 0 $iB]]
	    }
	    return [Tax $AncetreA $Quoi]
	}
	if {   $AuTourDeA && $AncetreA<=1} { set AuTourDeA 0 }
	if { ! $AuTourDeA && $AncetreB<=1} { set AuTourDeA 1 }
	
	if {$AuTourDeA} {
	    set  AncetreA [Tax $AncetreA "RankedParent"]
	    if {$AncetreA==""} { return "" } 
	    lappend ParentsDeA $AncetreA
	    set AuTourDeA 0
	} else {
	    set  AncetreB [Tax $AncetreB "RankedParent"]
	    if {$AncetreB==""} { return "" } 
	    lappend ParentsDeB $AncetreB
	    set AuTourDeA 1
	}
    }

}

proc AncetreCommunDeLaListe {Liste {Quoi ""}} {

    if {$Quoi=="" || $Quoi=="IdCommun"} { set Quoi "TaxId" }
    set A [lindex $Liste 0]
    set A [Tax $A "TaxId"]
    set LesAutres [lrange $Liste 1 end]
    while {$LesAutres!={}} {
	set B [lindex $LesAutres 0]
	set LesAutres [lrange $LesAutres 1 end]
	set A [AncetreCommun $A $B]
    }
    set R [Tax $A $Quoi]
    return $R

}

proc AncetresDe {n} {

    global T

   set Lanc $n
    if {[info exists T($n,par)]} {
	set p $T($n,par)
    } else {
	return $n
    }
    while {$p >= -1} {
	lappend Lanc $p
	set f $p
	if {[info exists T($f,par)]} {
	    set p $T($f,par)
	} else {
	    break
	}
    }

    return $Lanc

}

proc AnchorsCoherents {FichierTFA FichierAnchors NomOuFichierBlast} {

    global RepertoireDuGenome

    JeMeSignale

    Wup "If the names in the TFA and Anchors don't correspond I change in the TFA"
    Wup " in Ballast I do otherwize and change in the Anchor file."

    if { ! [regexp -nocase {[0-9a-z_]} $FichierAnchors]} { return "" }

    foreach Ligne [LesLignesDuFichier $FichierTFA] {
	if { ! [regexp "^>" $Ligne]} { continue }
	regsub ">" $Ligne "" Ligne
	scan $Ligne "%s" AccessTFA
	set ACCESSTFA [string toupper $AccessTFA]
	set EstDansTFA($ACCESSTFA) 1
	set Beau($ACCESSTFA) $AccessTFA
    }

    set LesAnchorsAChanger {}
    foreach Ligne [LesLignesDuFichier $FichierAnchors] {
	if { ! [regexp "^seq\:" $Ligne]} { continue }
	set AccessAnchor ""
	scan $Ligne "%s %s %s" Seq Bidon AccessAnchor
	set ACCESSANCHOR [string toupper $AccessAnchor]
	if {[info exists EstDansTFA($ACCESSANCHOR)]} { continue }
	set MauvaisAnchors($ACCESSANCHOR) 1
	lappend LesAnchorsAChanger $AccessAnchor
    }

    if {$LesAnchorsAChanger=={}} { return $FichierAnchors }

    set FichierBlast $NomOuFichierBlast
    if { ! [regexp "/" $NomOuFichierBlast] || ! [file exists $FichierBlast]} {
	set Nom $NomOuFichierBlast
	set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
    }
    if { ! [file exists $FichierBlast]} { return $FichierAnchors }

    DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
    foreach BanqueId $lBanqueId Access $lAccess {
	regsub {\:} $BanqueId "|" BanqueId
	if {[regexp "mol\:protein" $Access]} { set Access $BanqueId }
	set BANQUEID [string toupper $BanqueId]
	set ACCESS   [string toupper $Access]
	if {[info exists DejaVu($BANQUEID)] || [info exists DejaVu($ACCESS)]} {
	    FaireLire "Deja vu $BanqueID $Access !! "
	}
	set Beau($BANQUEID)  $BanqueId
	set Beau($ACCESS)    $Access
	if {$BANQUEID!=$ACCESS} {
	    set Autre($BANQUEID) $ACCESS
	    set Autre($ACCESS)   $BANQUEID
	}
    }

    set NouveauxAnchors {}
    foreach Ligne [LesLignesDuFichier $FichierAnchors] {
	if { ! [regexp "^seq\:" $Ligne]} { lappend NouveauxAnchors $Ligne ; continue }
	set AccessAnchor ""
	scan $Ligne "%s %s %s" Seq Bidon AccessAnchor
	set ACCESSANCHOR [string toupper $AccessAnchor]
	if { ! [info exists MauvaisAnchors($ACCESSANCHOR)]} {
	    lappend NouveauxAnchors $Ligne
	    continue
	}
	if { ! [info exists Autre($ACCESSANCHOR)]} {
	    if { [EstUnAccessPDB $ACCESSANCHOR] && [regexp "_$" $ACCESSANCHOR]} {
		regsub "_$" $ACCESSANCHOR "" AUTREACC
	    } else {
		lappend NouveauxAnchors $Ligne
		continue
	    }
	} else {
	    set AUTREACC [set Autre($ACCESSANCHOR)]
	}
	if { ! [info exists EstDansTFA($AUTREACC)]} {
	    lappend NouveauxAnchors $Ligne
	    continue
	}
	set BeauNouveau [set Beau($AUTREACC)]
	set NouvelleLigne [SubstitueAvecBlancsDevant $Ligne $AccessAnchor $BeauNouveau]
	lappend NouveauxAnchors $NouvelleLigne
    }
    SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent2"
    return [SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent"]

}

proc AnchorsCount {Nom} {

    global AnchorsCount
    global RepertoireDuGenome

    if {[info exists AnchorsCount($Nom)]} { return [set AnchorsCount($Nom)] }
    if {[info exists AnchorsCount("EstCharge")]} { return [set AnchorsCount("EstCharge")] }

    set FichierAnchorsCount "$RepertoireDuGenome/fiches/anchors_count"
    while { ! [file exists $FichierAnchorsCount]} {
	if { ! [OuiOuNon "Do I count, NOW, the anchors in each alignment ?"]} {
	    set AnchorsCount("EstCharge") -2
	    return [AnchorsCount $Nom]
	} else {
	    set LesAnchors {}
	    foreach PAB [ListeDesPABs] {
		set FichierMSF "$RepertoireDuGenome/msf/$PAB"
		if { ! [file exists $FichierMSF]} { continue }
		set Entete [string toupper [LesPremieresLignesDuFichier $FichierMSF 5]]
		if { ! [regexp -nocase "ANCHORS" $Entete]} {
		    set N -3
		} else {
		    set N [IntegerApres "ANCHORS" dans $Entete]
		}
		lappend LesAnchors "$PAB $N"
	    }
	    SauveLesLignes $LesAnchors dans $FichierAnchorsCount
	}
    }

    set AnchorsCount("EstCharge") -1
    foreach Ligne [LesLignesDuFichier $FichierAnchorsCount] {
	scan $Ligne "%s %d" NomLu N
	lappend AnchorsCount(LaListeMerci) $N
	set AnchorsCount($NomLu) $N
    }
    return [AnchorsCount $Nom]

}

proc AncienChangePreferences {} {


    global Couleurs
    global TypeCons
    global TypeText
    global SphDef
    global Defauts

    set w .pref
    toplevel $w
    wm title $w "Preferences"
    wm iconname $w "Preferences"

    frame  $w.colors
    pack $w.colors -side top -fill x
    grid rowconfig    $w.colors 0 -weight 1 -minsize 0
    grid columnconfig $w.colors 0 -weight 0 -minsize 0

    label $w.colors.global -text "Global conservation" -relief sunken
    #    pack $w.colors.global -side top
    grid $w.colors.global -in $w.colors -padx 1 -pady 20  -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky w

    set EltCo 0
    set EltLi 0
    foreach Type $TypeCons {
	if {$EltCo == "9"} {
	    set EltCo 0
	    incr EltLi
	}

	if {[lsearch $TypeCons $Type] == "3"} {
	    incr EltLi
	    label  $w.colors.group -text "Group conservation"
	    grid $w.colors.group -in $w.colors -padx 1 -pady 10  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	    incr EltLi
	}

	if {[lsearch $TypeCons $Type] == "9"} {
	    incr EltLi
	    label  $w.colors.inter -text "Inter-Group conservation"
	    grid $w.colors.inter -in $w.colors -padx 1 -pady 10  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	    incr EltLi
	}

	if {[lsearch $TypeCons $Type] == "15"} {
	    incr EltLi
	    label  $w.colors.points -text "Points"
	    grid $w.colors.points -in $w.colors -padx 1 -pady 10  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	    incr EltLi
	}

	scan [set Couleurs($Type)] "%s %s" fg bg

	label  $w.colors.l$Type -text [set TypeText($Type)]
	grid $w.colors.l$Type -in $w.colors -padx 1 -pady 1  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	incr EltCo

	button $w.colors.f$Type -background $fg -activebackground $fg -command "ChangeCouleur $Type $fg $w.colors.f$Type"
	grid $w.colors.f$Type -in $w.colors -padx 1 -pady 1  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	incr EltCo

	button $w.colors.b$Type -background $bg -activebackground $bg -command "ChangeCouleur $Type $bg $w.colors.b$Type"
	grid $w.colors.b$Type -in $w.colors -padx 1 -pady 1  -row $EltLi -column $EltCo -rowspan 1 -columnspan 1 -sticky w
	incr EltCo
    }

    labelframe $w.control -relief groove -borderwidth 2 -text "Ordali Control Panel"
    grid rowconfig    $w.control 0 -weight 1 -minsize 0
    grid columnconfig $w.control 0 -weight 0 -minsize 0

    label $w.control.sph -text "Ordali Spheres"
    radiobutton $w.control.sphmean -text "Mean Volume" -variable SphDef -relief flat -value "Mean"
    radiobutton $w.control.sphhbnd -text "Mean Volume + HB" -variable SphDef -relief flat -value "HBond"

    label $w.control.sim -text "Use similarity"
    radiobutton $w.control.simy -text "Yes" -variable Defauts(SimiGris) -relief flat -value "1"
    radiobutton $w.control.simn -text "No" -variable Defauts(SimiGris) -relief flat -value "0"

    label $w.control.slg -text "Select length"
    radiobutton $w.control.slgy -text "Yes"  -variable Defauts(SelectionLong) -relief flat -value "1"
    radiobutton $w.control.slgn -text "No"  -variable Defauts(SelectionLong) -relief flat -value "0"

    label $w.control.sln -text "Select name"
    radiobutton $w.control.slny -text "Yes"  -variable Defauts(SelectionNom) -relief flat -value "1"
    radiobutton $w.control.slnn -text "No"  -variable Defauts(SelectionNom) -relief flat -value "0"

    label $w.control.chk -text "Check sequences"
    radiobutton $w.control.chky -text "Yes"  -variable Defauts(CheckSeq) -relief flat -value "1"
    radiobutton $w.control.chkn -text "No"  -variable Defauts(CheckSeq) -relief flat -value "0"

    label $w.control.grnc -text "Group Consensus 80%"
    radiobutton $w.control.grncy -text "Yes"  -variable Defauts(ConsNGrp) -relief flat -value "1"
    radiobutton $w.control.grncn -text "No"  -variable Defauts(ConsNGrp) -relief flat -value "0"

    set fontsize [lindex [split $fontext] 1]
    set fontsizeold $fontsize
    if {[lindex [split $fontext] 2] != ""} {
	set fontclas [lindex [split $fontext] 2]
	set fontclasold $fontclas
    } else {
	set fontclas "normal"
    }

    label $w.control.fntl -text "Alignment font : CourierNew "
    tk_optionMenu $w.control.fnts fontsize 6 8 10 12 14
    tk_optionMenu $w.control.fntc fontclas normal bold

    label $w.control.pds -text "Weighted sequences "
    radiobutton $w.control.pdsy -text "Yes"  -variable Defauts(Poids) -relief flat -value "1"
    radiobutton $w.control.pdsn -text "No"  -variable Defauts(Poids) -relief flat -value "0"

    grid $w.control.sph -in $w.control -padx 1 -pady 3  -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.sphmean -in $w.control -padx 1 -pady 3  -row 1 -column 1 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.sphhbnd -in $w.control -padx 10 -pady 3  -row 1 -column 2 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.sim -in $w.control -padx 1 -pady 3  -row 1 -column 3 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.simy -in $w.control -padx 1 -pady 3  -row 1 -column 4 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.simn -in $w.control -padx 10 -pady 3  -row 1 -column 5 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.slg -in $w.control -padx 1 -pady 3  -row 2 -column 0 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.slgy -in $w.control -padx 1 -pady 3  -row 2 -column 1 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.slgn -in $w.control -padx 10 -pady 3  -row 2 -column 2 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.sln -in $w.control -padx 1 -pady 3  -row 2 -column 3 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.slny -in $w.control -padx 1 -pady 3  -row 2 -column 4 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.slnn -in $w.control -padx 10 -pady 3  -row 2 -column 5 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.chk -in $w.control -padx 1 -pady 3  -row 3 -column 0 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.chky -in $w.control -padx 1 -pady 3  -row 3 -column 1 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.chkn -in $w.control -padx 10 -pady 3  -row 3 -column 2 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.grnc -in $w.control -padx 1 -pady 3  -row 3 -column 3 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.grncy -in $w.control -padx 1 -pady 3  -row 3 -column 4 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.fntl -in $w.control -padx 10 -pady 3  -row 4 -column 0 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.fnts -in $w.control -padx 10 -pady 3  -row 4 -column 1 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.fntc -in $w.control -padx 10 -pady 3  -row 4 -column 2 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.pds -in $w.control -padx 1 -pady 3  -row 5 -column 0 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.pdsy -in $w.control -padx 1 -pady 3  -row 5 -column 1 -rowspan 1 -columnspan 1 -sticky w
    grid $w.control.pdsn -in $w.control -padx 10 -pady 3  -row 5 -column 2 -rowspan 1 -columnspan 1 -sticky w

    pack  $w.control -side top -anchor w -padx 10 -pady 10

    frame $w.btnstrc
    pack $w.btnstrc -side bottom -pady 10
    button $w.btnstrc.cebon -text " OK " -background green1 -command "TermineChangePreferences $w"
    pack $w.btnstrc.cebon -side left

    MesCouleurs $w

    return

}

proc AncienNom {Nom} {

    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/lacorrespondance"] {
	scan $Ligne "%s %s" new old
	if {$new==$Nom} {
	    return $old
	}
    }

}

proc AncienNomsParmiLes555PCA {FichierCorrespondance} {
   
    foreach Ligne [LesLignesDuFichier $FichierCorrespondance] {
	set Old [lindex $Ligne 0]
	set PCA [lindex $Ligne 1]
	set Datas($PCA) $Old
    }
    set b 0
    foreach Nom [ListeDesPABs] {
	if {[info exists Datas($Nom)]} {
	    set OldNom $Datas($Nom)
	    if {[regexp "PROS" $OldNom]} {
		incr b 
	    }
	}
    }
    return $b

}

proc AngleDansRosace {R X {Y ""} {CentreX ""} {CentreY ""}} {

    global ParametresDuBoard

    set PI 3.14159

    if {[regexp -nocase {[a-z]} $X]} {
	set Nom $X
	set PosADN [Milieu $Nom]
	
	set Heure [expr $PosADN*2*$PI/[LongueurADN]]
	set Angle [expr  -$PI/2 - $Heure]]
	set Angle [expr $Angle + [DecalageAngulaireRosace]]
	set Angle [Entre0Et2PI [expr  -$PI/2 - $Heure]]
	return $Angle
    }

    if {$CentreX == ""} {
	set CentreX [set ParametresDuBoard($R,CentreX)]
	set CentreY [set ParametresDuBoard($R,CentreY)]
    }
    if {$R == "CoordonneesVraies"} {
	set xVrai $X
	set yVrai $Y
    } else {
	set xVrai [$R canvasx $X]
	set yVrai [$R canvasy $Y]
    }

    set x [expr $xVrai-$CentreX]
    set y [expr $yVrai-$CentreY]

    if {[expr abs($x) < 1] && [expr abs($y) < 1]} { return 0.0 }
    if {[expr abs($x) < 1] && [expr $y > 0]} {
	set Angle [expr $PI/2]
    } elseif {[expr abs($x) < 1] && [expr $y < 0]} {
	set Angle [expr 3*$PI/2]
    } else {
	set Angle [expr atan($y*1.0/$x)]
	if {$x<0} { set Angle [expr $Angle + $PI] }
	set Angle [expr $Angle + [DecalageAngulaireRosace]]
	set Angle [Entre0Et2PI $Angle]
    }
    return $Angle

}

proc AngleDeg {Angle {Unite r}} {

    #rR quand il n'y a pas de r on force le r
    if {[regexp -nocase "^r" $Unite]} { set Angle [expr ($Angle*180.)/[Pi]] }
    return $Angle

}

proc AngleEntre {V1 V2} {

    #lM 2014/05/21
    # angle qui ramene V1 sur V2
    set nV1 [V_nV $V1]
    set nV2 [V_nV $V2]

    if {[llength $nV2] == 2} {
	lassign $nV1 x1 y1
	lassign $nV2 x2 y2
	set sca [S_VV $nV1 * $nV2]
	set vct [expr {$x1*$y2-$x2*$y1}]
	set ang [expr {atan2($vct,$sca)}]
	if {$ang < 0.0} {
	    set ang [expr {$ang + [2Pi]}]
	}

	return $ang
    }

    set cos [S_VV $nV1 * $nV2]

    set vec [Vectoriel $nV1 $nV2]
    set sin [S_nV $vec]
    set vec [V_nV $vec]
    set verif [V_nV [Vectoriel $nV1 $vec]]
    set sver [S_VV $verif * $nV2]

    puts "   cos   $cos"
    puts "   sin   $sin"
    puts "   verif $verif"
    puts "   sver  $sver"

    set ang [expr {atan2($sin,$cos)}]
    puts "   ang [AngleDeg $ang]"
    if {$ang < 0.} {
	set ang [expr {$ang + [2Pi]}]
    }

    return $ang

}

proc AngleLRAncetres {AId n} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return}
    if {$n eq "root"} {return}

    set x [$t get $n xcoord]
    set y [$t get $n ycoord]
    set p [$t parent $n]
    lassign [$t children $p] e1 e2
    set xp [$t get $p xcoord]
    set yp [$t get $p ycoord]
    if {$x == $xp && $y == $yp} {
	if {$n eq $e1} {set p $e2} {set p $e1}
    }

    ::struct::tree tmpT
    tmpT deserialize [$t serialize]
    tmpT delete $n

    # ATTENTION ! Ordre inverse ! On regarde VERS la racine !!
    set Ln [tmpT nodes]
    if {[llength $Ln] > 2} {
	lassign [NoeudLRDe $AId $n $p $Ln 1] Nr Nl
    } else {
	lassign $Ln n1 n2
	if {$n1 eq "root"} {set Ln $n2} {set Ln $n1}
	set Nr $Ln
	set Nl $Ln
    }

    set xaR [$t get $Nr xcoord]
    set yaR [$t get $Nr ycoord]
    set Ang [Coords2Angle [expr {$xaR-$x}] [expr {$yaR-$y}]]
    set AR $Ang

    set xaL [$t get $Nl xcoord]
    set yaL [$t get $Nl ycoord]
    set Ang [Coords2Angle [expr {$xaL-$x}] [expr {$yaL-$y}]]
    set AL $Ang

    puts "----- Ancetre Gauche/Droite ----------------"
    puts [format "AL %6.3f AR %6.3f" $AL $AR]
    puts "NdL $Nl NdR $Nr"

    tmpT destroy

    $t set $n AncesR $AR
    $t set $n AncesL $AL
    $t set $n NdAncesL $Nl
    $t set $n NdAncesR $Nr

    return

}

proc AngleMaxGaucheDroite {AId n} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return}
    #    if {$n eq "root"} {exir}

    puts "--- Min Max Gauche/Droit ---------"
    puts [format "Nd n : %s | x=%7.2f y=%7.2f" $n [$t get $n xcoord] [$t get $n ycoord]]

    set NdL [$t get $n NdLeft]
    set NdR [$t get $n NdRight]
    set LNdL [concat $NdL [$t descendants $NdL]]
    set LNdR [concat $NdR [$t descendants $NdR]]

    set LMM [AnglesMinMaxDe $AId $n $LNdL]
    lassign $LMM Am Ax Sum
    set Am2  [expr {$Am>[Pi]?$Am-[2Pi]:$Am}]
    set Ax2  [expr {$Ax>[Pi]?$Ax-[2Pi]:$Ax}]
    set Sum2 [expr {$Sum>[Pi]?$Sum-[2Pi]:$Sum}]
    puts "Am2 $Am2 Ax2 $Ax2 Sum2 $Sum2"
    set LRLL [expr {abs($Sum2-$Am2)+abs($Ax2-$Sum2)}]
    if {$LRLL > [Pi]} {set obtu 1} {set obtu 0}

    if {abs($Ax-$Am) > [Pi] && ! $obtu} {
	if {$Am < $Ax} {
	    $t set $n LeftL $Am
	    $t set $n LeftR $Ax
	} else {
	    $t set $n LeftL $Ax
	    $t set $n LeftR $Am
	}
    } else {
	if {$Am > $Ax} {
	    $t set $n LeftL $Am
	    $t set $n LeftR $Ax
	} else {
	    $t set $n LeftL $Ax
	    $t set $n LeftR $Am
	}
    }

    set LMM [AnglesMinMaxDe $AId $n $LNdR]
    lassign $LMM Am Ax Sum
    set Am2  [expr {$Am>[Pi]?$Am-[2Pi]:$Am}]
    set Ax2  [expr {$Ax>[Pi]?$Ax-[2Pi]:$Ax}]
    set Sum2 [expr {$Sum>[Pi]?$Sum-[2Pi]:$Sum}]
    set RRRL [expr {abs($Sum2-$Am2)+abs($Ax2-$Sum2)}]
    if {$RRRL > [Pi]} {set obtu 1} {set obtu 0}

    if {abs($Ax-$Am) > [Pi] && ! $obtu} {
	if {$Am < $Ax} {
	    $t set $n RightL $Am
	    $t set $n RightR $Ax
	} else {
	    $t set $n RightL $Ax
	    $t set $n RightR $Am
	}
    } else {
	if {$Am > $Ax} {
	    $t set $n RightL $Am
	    $t set $n RightR $Ax
	} else {
	    $t set $n RightL $Ax
	    $t set $n RightR $Am
	}
    }

    $t set $n LRLL $LRLL
    $t set $n RRRL $RRRL

    puts [format "Nd L %s | LL %5.2f LR %5.2f LRLL %5.2f" [$t get $n NdLeft] [$t get $n LeftL] [$t get $n LeftR] [$t get $n LRLL]]
    puts [format "Nd R %s | RL %5.2f RR %5.2f RRRL %5.2f" [$t get $n NdRight] [$t get $n RightL] [$t get $n RightR] [$t get $n RRRL]]
    puts ""

    return

}

proc AngleRad {Angle {Unite d}} {

    #rR quand il n'y a pas de degres on force degre
    if {[regexp -nocase "^d" $Unite]} { set Angle [expr ($Angle*[Pi])/180.] }
    return $Angle

}

proc Angle_R {R} {

    return [lindex $R 0]

}

proc AnglesMinMaxDe {AId n Le} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    set Am  999.
    set Ax -999.
    set x [$t get $n xcoord]
    set y [$t get $n ycoord]
    set p [$t parent $n]
    set xp [$t get $p xcoord]
    set yp [$t get $p ycoord]
    set AnP [Coords2Angle [expr {$x-$xp}] [expr {$y-$yp}]]

    foreach d $Le {
	set xd [$t get $d xcoord]
	set yd [$t get $d ycoord]
	set Ang [Coords2Angle [expr {$xd-$x}] [expr {$yd-$y}]]

	if {$Ang < $Am} {set Am  $Ang}
	if {$Ang > $Ax} {set Ax  $Ang}
    }

    return [list $Am $Ax $AnP]

}

proc AnimateurSVP {IpCafe} {

    global CafeDesSciencesDir
    global Cafe

    DecortiqueIpCafe "$IpCafe" Ip Cafe
    PotinsDeQuestion "AnimateurSVP IpCafe $Ip $Cafe"

    set SocketteAnimateur ""
    while {[catch {set SocketteAnimateur [socket $Ip $Cafe]} Message]  && [regexp "address already in use" $Message]} {
	PotinsDeQuestion "attente Sockette $SocketteAnimateur du $Ip $Cafe already in use ..."
	set SocketteAnimateur ""
	after 1000
    }
    if {$SocketteAnimateur!=""} {
	PotinsDeQuestion "SocketteAnimateur $SocketteAnimateur";
	return $SocketteAnimateur
	#rR on avait un SocketteAnimateur en marche. **************************************
    }


    #rR pas d'animateur, on en cree un. ****************************************************
    set Hostname [info hostname]
    regsub {\..*} $Hostname "" HostnameCourt

    set RemoteShell "rsh $Ip -n"
    if {$Ip==$HostnameCourt || $Ip=="localhost" || [regexp {^127\.0} $Ip]} { set RemoteShell "" }

    set BiolOuQuoi "[string range $CafeDesSciencesDir 0 4]..."
    PotinsDeQuestion "exec $RemoteShell $BiolOuQuoi/cafe_des_sciences.tcl $Ip:$Cafe"

    eval exec $RemoteShell $CafeDesSciencesDir/cafe_des_sciences.tcl "$Ip:$Cafe" &

    after 1000
    set Encore 10
    while { [catch {set SocketteAnimateur [socket $Ip $Cafe]} MessageCafeFerme] } {
	if { ! [incr Encore -1] } {
	    PotinsDeQuestion "erreur: J'abandonne socket $Ip $Cafe"
	    return "erreur: Abandon animateur socket $Ip $Cafe  \nAfter execution of  \nexec $RemoteShell $CafeDesSciencesDir/cafe_des_sciences.tcl $Ip:$Cafe  \n I got the message : $MessageCafeFerme"
	}
	PotinsDeQuestion "$Encore attente socket $Ip $Cafe : $MessageCafeFerme"
	after 1000
    }
    PotinsDeQuestion "SocketteAnimateur $SocketteAnimateur"
    return $SocketteAnimateur

}

proc AnneGraph {args} {


    set file [lindex $args 0]

    set Ll [LesLignesDuFichier $file]
    set fx 1.
    set step 25
    set Diam 50
    set OffX 20
    set Lcol [list red brown orange green yellow dimgrey cyan pink magenta blue]

    toplevel .anne
    canvas .anne.c -width 1000 -height 1000 -background "#0000ff"
    pack .anne.c
    set w ".anne.c"

    set MaxX 0
    set MaxY 0
    set i 0
    foreach l [lrange $Ll 1 end] {
	set j 0
	foreach v [lrange [split $l "\t"] 1 end] {
	    set col [lindex $Lcol $j]
	    set r [expr $v * $Diam / 2]
	    set ym [expr (10-$j)*$step - $r]
	    set yx [expr (10-$j)*$step + $r]
	    set xm [expr $i*$step - $r + $OffX]
	    set xx [expr $i*$step + $r + $OffX]
	    $w create oval $xm $ym $xx $yx -fill $col -outline black
	    incr j
	    if {$yx > $MaxY} {set MaxY $yx}
	    if {$xx > $MaxX} {set MaxX $xx}
	}
	incr i
    }

    set MaxX [expr $MaxX + $OffX]
    $w configure -height $MaxY -width $MaxX

    return

}

proc Anne_CluspackGridChoixSecatorDPC {NomATraiter} {

    # cette proc de Anne utilise les procs de Luc (proc LanceurCluspack)
    # NB: LanceurCluspack peut passer a DPC si secator "plante" ou l'inverse. Ca arrive sur certains alignements.
    
    # !!! il est necessaire de lancer "setgscoperr NomDuProjet" puis "setordalilm" !!!
    
    # version cree mais momentanement non utilisee
    # en effet, problemes observes avec secator :
    # determine parfois des groupes contenant 1 seule sequence
    # a choisi en attendant de travailler avec DPC uniquement!!
    
    #global PipeCollection
    global PipeQuery

    set InInitLeon [file join [RepertoireDuGenome] leon $NomATraiter]
    set InLeon [file join [RepertoireDuGenome] cluspack ${NomATraiter}.msf]
    # placement du fichier d alignement dans le bon repertoire pour n avoir pas 
    # a deplacer les fichiers ensuite
    File copy -force $InInitLeon $InLeon
    
    # fichier ".clu" cree quel que soit la methode de clusterisation utilisee
    set OutClu [file join [RepertoireDuGenome] cluspack ${NomATraiter}.clu]
    # les autres fichiers sont crees uniquement par secator
    set OutNJ [file join [RepertoireDuGenome] cluspack ${NomATraiter}.nj]
    set OutDst [file join [RepertoireDuGenome] cluspack ${NomATraiter}.dst]

    if {! [file exists $InLeon]} {return 0}
    
    set NbAccess 0
    # determination du nombre de sequences dans l alignement
    set cmd "grep -c \"Name\" $InLeon" 
    set NbAccess [eval exec $cmd]
    
    # quel que soit le programme de clusterisation le debut de la commande est la meme
    set commande "LanceurCluspack $InLeon alignment"

    if {$NbAccess > 100} {
	set Moi    "dpc"
	puts $Moi
	set LAutre "secator"
	set arg "dpc kmeans 0.001"
	set FileClustering "${InLeon}.clu"
    } else {
	set Moi    "secator"
	puts $Moi
	set LAutre "dpc"
	set arg "secator bionj"
	set FileClustering "${InLeon}.clu"
	
    }

    if {[catch {eval $commande $arg} Message]} {
	Espionne $Message
	Espionne "Problem with $InLeon with $Moi je vais utiliser $LAutre"
	if {$LAutre == "secator"} {
	    catch {[$commande secator bionj]}
	} else {
	    catch {[$commande dpc kmeans 0.001]}
	}    
    }

    File delete -force $InLeon

    if {[file exists $OutNJ]} { File delete -force $OutNJ }
    if {[file exists $OutDst]} { File delete -force $OutDst }

    return 1

}

proc AnnotRep {} {

    return "/genomics/link/EleGen/code"

}

proc AnnotType {{Qui ""} {Quoi ""}} {

    global AnnotType
    if {[info exists AnnotType($Qui,$Quoi)]}  { return $AnnotType($Qui,$Quoi) }
    if {[info exists AnnotType("EstCharge")]}  {
	set QUI [string range [string toupper $Qui] 0 3]
	if {[info exists AnnotType($QUI,$Quoi)]} { return $AnnotType($QUI,$Quoi) }
	return ""
    }
    set AnnotType("EstCharge") 1

    set LesTypesCodes {}
    lappend LesTypesCodes           "genes_intergenic 1 Intergene"
    lappend LesTypesCodes           "enhancers_fantom 2 Enhancer"
    lappend LesTypesCodes               "genes_1to5kb 3 1to5kb"
    lappend LesTypesCodes              "genes_introns 4 Intron"
    lappend LesTypesCodes            "genes_promoters 5 Promoter"
    lappend LesTypesCodes "genes_intronexonboundaries 6 Boundary"
    lappend LesTypesCodes                "genes_3UTRs 7 3UTR"
    lappend LesTypesCodes                "genes_5UTRs 8 5UTR"
    lappend LesTypesCodes           "genes_firstexons 9 1stExon"
    lappend LesTypesCodes                "genes_exons X Exon"

    foreach TC $LesTypesCodes {
	scan $TC "%s %s %s" Type T Code
	lappend AnnotType(ListOf,Type) $Type
	lappend AnnotType(ListOf,T)    $T
	lappend AnnotType(ListOf,Code) $Code
	set AnnotType($Type,Type) $Type
	set AnnotType($Type,T)    $T
	set AnnotType($Type,Code) $Code
	set AnnotType($T,Type)    $Type
	set AnnotType($T,T)       $T
	set AnnotType($T,Code)    $Code
	set AnnotType($Code,Type) $Type
	set AnnotType($Code,T)    $T
	set AnnotType($Code,Code) $Code
	set AnnotType([string range [string toupper $Code] 0 3],Type) $Type
	set AnnotType([string range [string toupper $Code] 0 3],T)    $T
	set AnnotType([string range [string toupper $Code] 0 3],Code) $Code
    }

    set AnnotType(F,Type) Final
    set AnnotType(F,T)    F
    set AnnotType(F,Code) Final 

    return [AnnotType $Qui $Quoi]

}

proc AnnotVerif {Chr Q} {

    #set Final [ContenuDuFichier "[AnnotRep]/${Chr}_Final"] 
    set Xdn$Q [ContenuDuFichier "[AnnotRep]/${Chr}_Xdn$Q"] 
    set D 0
    set F $D
    set Previous "."
    set LesBornes {}
    foreach X [split [set Xdn$Q] ""] {
	if {$X eq "."} {
	    if {$Previous ne "."} { lappend LesBornes "$D $F" }
	    incr D
	    incr F
	} else {
	    incr F
	}
	set Previous $X
    }
    return $LesBornes

}

proc AnnotXdn {{Chr ""}} {

    set Rep [AnnotRep]
    set FichierAnnot  "$Rep/$Chr.annot"	
    set	FichierTypes  "$Rep/AnnotTypes.txt"
    # "chr19"	481674	481793	120	"*"	"enhancer:28085"	NA	NA	NA	"hg19_enhancers_fantom"
    # "chr19"	10654633	10655632	1000	"+"	"promoter:66212"	"uc010dxj.3"	"84971"	"ATG4D"	"hg19_genes_promoters"
    
    set LesXdn {}
    set Min 999999999999
    set Max -1
    foreach Ligne [LesLignesDuFichier $FichierAnnot] {
	regsub -all {\"} $Ligne "" Ligne		
	set LesMots [LesMotsDeLaLigne $Ligne]
	lassign $LesMots Ch Start Stop Length Brin Id Ucsc Gi Gn Type
	regsub {[a-z]+[0-9]+_} $Type "" Type 
	lappend LesBornes($Type) "$Start $Stop"
	set InfoDe($Type,$Stop) $Ligne
	lappend LesGn $Gn
	set Min [Mini $Start $Min]
	set Max [Maxi $Stop  $Max]
    }
    
    foreach Type [AnnotType ListOf Type] T [AnnotType ListOf T] {
	Espionne 
	Espionne $Type
	if { ! [info exists LesBornes($Type)]} { Espionne "Bornes pour $Type non trouve"; continue }
	set I 0
	set LesDF $LesBornes($Type)
	set LesDFTries [lsort -integer -index 0 $LesDF]

	Espionne "[llength $LesDFTries] element a traiter"

	set LesDFRetenus $LesDFTries
	set Superpose 1
	set I 0
	set J 1
	set DF1 [lindex $LesDFTries $I]
	set DF2 [lindex $LesDFTries $J]
	set LesBons {}
	set LesInfos {}
	Espionne "$J $DF1 $DF2 avant boucle pour $Type"
	while 1 {
	    if {$J%100==1} { Espionne "$J $DF1 $DF2" }
	    lassign $DF1 D1 F1
	    lassign $DF2 D2 F2
	    if {$D1==$D2} {
		set F2 [Maxi $F1 $F2]
		set DF1 "$D1 $F2"
		incr J
		set DF2 [lindex $LesDFTries $J]
		if {$DF2==""} {
#		    Espionne $DF1
		    lappend LesBons $DF1
		    lassign $DF1 D F
		    lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		    break
		}
#		Espionne "D1=D2"
		continue
	    }
	    if {$D2<=$F1} {
		set DF1 "$D1 [Maxi $F1 $F2]"
		incr J 
		set DF2 [lindex $LesDFTries $J]
		if {$DF2==""} {
#		    Espionne $DF1
		    lappend LesBons $DF1
		    lassign $DF1 D F
		    lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		    break
		}
#		Espionne "D2<=F1"
		continue
	    }
	    if {$F2<=$F1} {
		incr J
		set DF2 [lindex $LesDFTries $J]
		if {$DF2==""} {
#		    Espionne $DF1
		    lappend LesBons $DF1
		    lassign $DF1 D F
		    lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		    break
		}
#		Espionne "F2<=F1"
		continue
	    }
	    if {$F1==$D2} {
		set DF1 "$D1 $F2"
		incr J
		set DF2 [lindex $LesDFTries $J]
		if {$DF2==""} {
#		    Espionne $DF1
		    lappend LesBons $DF1
		    lassign $DF1 D F
		    lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		    break
		}
#		Espionne "F1=D2"
		continue
	    }
	    if {$F1<$D2} {
#		Espionne "$DF1"
		lappend LesBons "$DF1"
		lassign $DF1 D F
		lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		set DF1 $DF2
		incr J
		set DF2 [lindex $LesDFTries $J]
		if {$DF2==""} {
		    lappend LesBons "$DF1"
		    lassign $DF1 D F
		    lappend LesInfos "$DF1\t$InfoDe($Type,$F)"
		    break
		}
#		Espionne "F1="X"} { if {$XX ne "."} { append Final $XX ; continue } }
	if {$Ultime>="9"} { if {$X9 ne "."} { append Final $X9 ; continue } }
	if {$Ultime>="8"} { if {$X8 ne "."} { append Final $X8 ; continue } }
	if {$Ultime>="7"} { if {$X7 ne "."} { append Final $X7 ; continue } }
	if {$Ultime>="6"} { if {$X6 ne "."} { append Final $X6 ; continue } }
	if {$Ultime>="5"} { if {$X5 ne "."} { append Final $X5 ; continue } }
	if {$Ultime>="4"} { if {$X4 ne "."} { append Final $X4 ; continue } }
	if {$Ultime>="3"} { if {$X3 ne "."} { append Final $X3 ; continue } }
	if {$Ultime>="2"} { if {$X2 ne "."} { append Final $X2 ; continue } }
	                                      append Final $X1
    }
    set FicFinal "[AnnotRep]/${Chr}_Final.$Ultime"
    set o [open $FicFinal "w"]
    puts $o $Final
    flush $o
    close $o
    return $FicFinal
    

}

proc AnnotationEC {Nom SequencesDuGroupe} {

    set Fichier  "[RepertoireDuGenome]/macsims/$Nom.xml"

    if {! [file exists $Fichier]} {
	return "none"
    }
    set ListeDesECs {}
    ParseMACSIMS $Fichier macsims
    
    foreach Sequence $SequencesDuGroupe {
	set EC $macsims($Sequence,EC)
	if {$EC == "0.0.0.0"} {continue}
	regsub -all "EC " $EC "" EC
	regsub -all "EC_" $EC "" EC
	lappend ListeDesECs "$EC"
	lappend ListeDesECsAvecAccess [list $Sequence $EC]
    }
    
    set ECRetenu [ECDominant $ListeDesECs 0.7]
    if {$ECRetenu == ""} {set ECRetenu "none"}
    if {$ECRetenu != "none"} {
	set DefinitionEC [EnzymeCommission $ECRetenu]
	return [list $ECRetenu $DefinitionEC $ListeDesECsAvecAccess]
    } else {
	return "$ECRetenu"
    }

}

proc AnnotationGO {Nom AvecOuSansOrganismeEtudie} {

    FichierMsfPourGOAnno $Nom "$AvecOuSansOrganismeEtudie"
    RecreeLeFichierClust $Nom "$AvecOuSansOrganismeEtudie"
    LanceurGOAnno $Nom

}

proc AnnotationXml {FichierAnnotation {Quoi ""} args} {

    #FichierAnnotation "" "FichierMacsims.xml" ?"query"?
    #FichierAnnotation "GO" "FichierGeneOntology.xml"
    #FichierAnnotation "EC" "SortieDeProcedureEC"
    #FichierAnnotation "DE" "SortieDeProcedureMeilleureDef"
    #FichierAnnotation "PFAM" "SortieDeProcedurePFAM"

    # Lit xml existant ou crée document vide
    if {[file isfile $FichierAnnotation]} {
	set fh [open $FichierAnnotation "r"]
	dom parse -channel $fh doc
	close $fh
	$doc documentElement root
    } else {
	dom createDocument "annotation" doc
	$doc documentElement root
	
	#$root appendChild [$doc createElement "macsims"]
	#$root appendChild [$doc createElement "ec"]
	#$root appendChild [$doc createElement "gene_ontology"]
	#$root appendChild [$doc createElement "definition"]
	#$root appendChild [$doc createElement "pfam"]
    }

    # Création des noeuds principaux s'ils n'existent pas encore
    foreach n [list "macsims" "ec" "gene_ontology" "definition" "pfam"] {
	if {[llength [$root selectNodes "/annotation/$n"]] == 0} {
	    $root appendChild [$doc createElement $n]
	}
    }

    if {$Quoi eq ""} {
	set FichierMacsims [lindex $args 0]
	set Query [lindex $args 1]
	if {$Query eq ""} {set Query [regexp -inline {^[^.]+} [file tail $FichierMacsims]]}

	if {[file isfile $FichierMacsims]} {
	    # Tente de parser le fichier MACSIMS
	    set retryCount 5
	    while {$retryCount && [catch {
		ParseMACSIMS $FichierMacsims macsims
	    }]} {
		incr retryCount -1
	    }
	    if {!$retryCount} {error "Probleme avec $FichierMacsims"}
	    
	    # Récupère le groupe de la query
	    set groupeQuery $macsims(Groupe,$macsims($Query,Groupe))

	    # Récupère le noeud macsims
	    set macsimsNode [$root selectNodes "/annotation/macsims"]
	    # Supprime tous les noeud enfants
	    foreach node [$macsimsNode childNodes] {$node delete}
	    # ... et les attributs
	    foreach attrib [$macsimsNode attributes] {$macsimsNode removeAttribute $attrib}
	    
	    # Crée les commandes de creation de noeuds
	    dom createNodeCmd "elementNode" AnnotationXml::normd
	    dom createNodeCmd "elementNode" AnnotationXml::cluster
	    dom createNodeCmd "elementNode" AnnotationXml::query
	    dom createNodeCmd "elementNode" AnnotationXml::access
	    dom createNodeCmd "textNode" AnnotationXml::text

	    $macsimsNode appendFromScript {
		AnnotationXml::normd {AnnotationXml::text $macsims(Alignement,Score)}
		AnnotationXml::cluster "size" [llength $groupeQuery] {
		    AnnotationXml::query {AnnotationXml::text $Query}
		    foreach nom $groupeQuery {
			if {$nom ne $Query} {
			    AnnotationXml::access {AnnotationXml::text $nom}
			}
		    }
		}
	    }
	}
    } elseif {$Quoi eq "EC"} {
	set SortieDeProcedure [lindex $args 0]
	if {[llength $SortieDeProcedure] == 3} {
	    set commun [lindex $SortieDeProcedure 0]
	    set lClasses [lindex $SortieDeProcedure 1]
	    set lECs [lindex $SortieDeProcedure 2]
	} else {
	    set commun ""
	    set lClasses ""
	    set lECs ""
	}
	
	# Récupère le noeud ec
	set ecNode [$root selectNodes "/annotation/ec"]
	# Supprime tous les noeud enfants
	foreach node [$ecNode childNodes] {$node delete}
	# ... et les attributs
	foreach attrib [$ecNode attributes] {$ecNode removeAttribute $attrib}
	
	if {$commun ne "" && $lClasses ne "" && $lECs ne ""} {
	    # Crée les commandes de creation de noeuds
	    dom createNodeCmd "elementNode" AnnotationXml::common
	    dom createNodeCmd "elementNode" AnnotationXml::classes
	    dom createNodeCmd "elementNode" AnnotationXml::class
	    dom createNodeCmd "elementNode" AnnotationXml::sources
	    dom createNodeCmd "elementNode" AnnotationXml::source
	    dom createNodeCmd "textNode" AnnotationXml::text
	    
	    $ecNode appendFromScript {
		AnnotationXml::common {AnnotationXml::text $commun}
		AnnotationXml::classes {
		    foreach {classe def} $lClasses {
			AnnotationXml::class "number" $classe {AnnotationXml::text $def}
		    }
		}
		AnnotationXml::sources {
		    foreach liste $lECs {
			foreach {access ec} $liste {}
			AnnotationXml::source "ec" $ec {
			    AnnotationXml::text $access
			}
		    }
		}
	    }
	}
    } elseif {$Quoi eq "GO"} {
	set FichierGeneOntology [lindex $args 0]

	if {[file isfile $FichierGeneOntology]} {
	    # Parse le fichier GOAnno
	    ParseGOAnno $FichierGeneOntology goanno

	    # Récupère toute la hiérarchie go des parents
	    set ascendants {}
	    foreach go [concat $goanno(GPO,BiologicalProcess,GOs) $goanno(GPO,CellularComponent,GOs) $goanno(GPO,MolecularFunction,GOs)] {
		set ascendants [concat $ascendants [TousLesAscendantsGO $go]]
	    }
	    set ascendants [lsort -dictionary -index 2 [lsort -unique $ascendants]]
	    
	    # Récupère le noeud gene ontology
	    set goNode [$root selectNodes "/annotation/gene_ontology"]
	    # Supprime tous les noeud enfants
	    foreach node [$goNode childNodes] {$node delete}
	    # ... et les attributs
	    foreach attrib [$goNode attributes] {$goNode removeAttribute $attrib}

	    # Crée les commandes de creation de noeuds
	    dom createNodeCmd "elementNode" AnnotationXml::gpo
	    dom createNodeCmd "elementNode" AnnotationXml::hierarchy
	    dom createNodeCmd "elementNode" AnnotationXml::go
	    dom createNodeCmd "textNode" AnnotationXml::text
	    
	    $goNode appendFromScript {
		AnnotationXml::gpo {
		    foreach {type xmlType ontoType} [list "BiologicalProcess" "biological_process" "process" "CellularComponent" "cellular_component" "component" "MolecularFunction" "molecular_function" "function"] {
			foreach go $goanno(GPO,$type,GOs) {
			    set niv [lsort -unique [Onto $ontoType $go "LesNiveaux"]]
			    set parents [Onto $ontoType $go "LesParents"]

			    AnnotationXml::go "id" $go "type" $xmlType "levels" $niv "parents" $parents {
				AnnotationXml::text $goanno(GPO,$type,$go,Definition)
			    }
			}
		    }
		}
		AnnotationXml::hierarchy {
		    foreach goList $ascendants {
			foreach {go type niv def parents} $goList {}
			if {$type == "process"} {
			    set type "biological_process"
			} elseif {$type == "component"} {
			    set type "cellular_component"
			} elseif {$type == "function"} {
			    set type "molecular_function"
			}
			AnnotationXml::go "id" $go "type" $type "levels" $niv "parents" $parents {
			    AnnotationXml::text $def
			}
		    }
		}
	    }
	}
    } elseif {$Quoi eq "DE"} {
	set SortieDeProcedure [lindex $args 0]
	set score [lindex $SortieDeProcedure 0]
	set def [lindex $SortieDeProcedure 1]
	
	# Récupère le noeud gene ontology
	set deNode [$root selectNodes "/annotation/definition"]
	# Supprime tous les noeud enfants
	foreach node [$deNode childNodes] {$node delete}
	# ... et les attributs
	foreach attrib [$deNode attributes] {$deNode removeAttribute $attrib}
	
	if {$score ne "" && $def ne ""} {
	    # Crée les commandes de creation de noeuds
	    dom createNodeCmd "textNode" AnnotationXml::text
	    
	    $deNode setAttribute "score" $score
	    $deNode appendFromScript {
		AnnotationXml::text $def
	    }
	}
    } elseif {$Quoi eq "PFAM"} {
	set SortieDeProcedure [lindex $args 0]
	
	# Récupère le noeud pfam
	set pfNode [$root selectNodes "/annotation/pfam"]
	# Supprime tous les noeud enfants
	foreach node [$pfNode childNodes] {$node delete}
	# ... et les attributs
	foreach attrib [$pfNode attributes] {$pfNode removeAttribute $attrib}
	
	if {[llength $SortieDeProcedure] != 0} {
	    # Crée les commandes de creation de noeuds
	    dom createNodeCmd "elementNode" AnnotationXml::pfam_a
	    dom createNodeCmd "textNode" AnnotationXml::text
	    
	    $pfNode appendFromScript {
		foreach lPf $SortieDeProcedure {
		    foreach {access type accessPf dePf from longueurSeq} $lPf {}
		    AnnotationXml::pfam_a "access" $accessPf "from" $from "length" $longueurSeq {
			AnnotationXml::text $dePf
		    }
		}
	    }
	}
    }

    # Sauve le fichier
    set fh [open $FichierAnnotation "w"]
    puts $fh ""
    $doc asXML -channel $fh -doctypeDeclaration 0
    close $fh
    $doc delete

}

proc AnnotationXmlPourPAB {pab} {

    set RepertoireAnnotation "[RepertoireDuGenome]/annotation"
    if {![file isdirectory $RepertoireAnnotation]} {file mkdir $RepertoireAnnotation}
    set FichierAnnotation "$RepertoireAnnotation/$pab.xml"

    set FichierMacsims "[RepertoireDuGenome]/macsims/$pab.xml"
    if {[file isfile $FichierMacsims]} {
	# Extrait groupe macsims de la query
	ParseMACSIMS $FichierMacsims macsims
	set groupeQuery $macsims(Groupe,$macsims($pab,Groupe))
	set posQuery [lsearch -exact $groupeQuery $pab]
	set groupeQuery [lreplace $groupeQuery $posQuery $posQuery]

	# Annotation MACSIMS
	AnnotationXml $FichierAnnotation "" $FichierMacsims
	
	# Annotation EC
	AnnotationXml $FichierAnnotation "EC" [AnnotationEC $pab $groupeQuery]

	# Annotation GOAnno
	set FichierGOAnno "[RepertoireDuGenome]/GeneOntology/$pab.xml"
	AnnotationXml $FichierAnnotation "GO" $FichierGOAnno

	# Annotation meilleure definition Vero
	AnnotationXml $FichierAnnotation "DE" [MeilleuresDefinitions2_0 $groupeQuery]
    }

}

proc AnnotationcDNAParBlastX {{BlastX2Protein yes} {Overwrite yes} {ForbiddenWord ""} {Liste ""}} {

    # remplissage des fiches infos a partir du BlastX 
    # creation recapitulatif defdublastx.out dans fiches
    # en tenant compte de BlastX2Protein.out si arg1 yes 
    if {$Liste == ""} { set Liste [ListeDesPABs] }
    if {$BlastX2Protein=="yes"} {
    	foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/BlastX2Protein.out"] {
    		scan $Ligne "%s %s %s" ORF toto Homolog
    		if {$Homolog=="no"} {
    			set Homo($ORF) 0
    		} else {
    			set Homo($ORF) 1
    		}
    	}
    }
    foreach ORF $Liste {
	Espionne $ORF
	if {$Overwrite=="no" && [file exists "[RepertoireDuGenome]/infos/$ORF"]} {
	    continue
	} else {
	    set Sortie [BestDefinitionOfBlastX $ORF 0.001 $ForbiddenWord]
	    if {$Sortie=="" || ![set Homo($ORF)]} {
		InformeSansDemander $ORF "=DE_BlastX: unknown"
		InformeSansDemander $ORF "=OS_BlastX: unknown" 
		InformeSansDemander $ORF "=OC_BlastX: unknown"
		continue
	    }
	    if { ! [regexp {(.*)\(from} $Sortie Match Def]} { set Def "unknown" } 
	    set FinSortie [StringSuivant "(from " dans $Sortie]
	    regsub -all {\)[^\)]*$} $FinSortie "" FinSortie
	    scan $FinSortie "%s %s" Genre Espece
	    regsub {\.} $Espece "" Espece
	    set Espece [string tolower $Espece]
	    set Access [lindex [split $FinSortie " "] end-1]
	    InformeSansDemander $ORF "=DE_BlastX: $Def"
	    InformeSansDemander $ORF "=OS_BlastX: $Genre $Espece $Access"
	    if {$Espece=="sp"} {
		InformeSansDemander $ORF "=OC_BlastX: [OCduOS "$Genre"]"
	    } else {
		InformeSansDemander $ORF "=OC_BlastX: [OCduOS "$Genre $Espece"]"
	    }
	}
    }
    FicheDefDuBlastX

}

proc AnnoteBali {{fIn ""}} {

    global VariablesAuDepart

    LesDefauts
    LesDefauts TypeAli XML
    LesDefauts Mode "Batch"
    DefinitionPreferences
    InitialiseCouleurs
    set VariablesAuDepart [info globals]
	
    if {$fIn eq ""} {
	set BDir /home/moumou/Balibase3/bb3_release
	set Ldir [lsort [glob -types d [file join $BDir RV*]]]
    } else {
	set Ldir "."
    }

    foreach d $Ldir {
	puts "\n===================="
	puts "= [file tail $d]"
	puts "====================\n"
	
	if {$fIn eq ""} {
	    set Lf [glob [file join $d *.xml]]
	} else {
	    set Lf $fIn
	}
	foreach f $Lf {
	    if {[regexp {^BBS} [file tail $f]]} {
		continue
	    }

	    puts "\n => [file tail $f]"
	    set fout "[string range $f 0 end-4]_luc.xml"
	    set ford "[string range $f 0 end-4].ord"
	    if {[file exists $fout]} {
		if {[file exists $ford]} {
		    continue
		}
		file delete -force $fout
	    }

	    set FichierXML $f
	    LesDefauts FichierXML $FichierXML
	    puts "\n => [file tail $f]"
	    set fout "[string range $f 0 end-4]_luc.xml"
	    puts "outfile : $fout"
	    
	    LoadingAlignement
	    InitInfoSeqs
	    MetAJourGroupes
	    update

	    set YaSt 0 ; set YaBl 0
	    set ft ActiveSite
	    foreach p $::ListePDB {
		set nom [DonneIdDeAccessPDB $p]
		set chn [DonneChainDeAccessPDB $p]
		set Lsite [$nom GiveVar Site]
		if {$Lsite == {} } {
		    continue
		}

		unset -nocomplain St
		array set St $Lsite
		set Lft [list]
		set Lres [$nom _resnumber -chain $chn -polymer]
		foreach s [array names St] {
		    foreach {r c nm} [set St($s)] {
			if {$c ne $chn} {
			    continue
			}
			if {$r ni $Lres} {
			    continue
			}

			set x [DonnePosSG $p $r]
			if {$x == -1 || $x == ""} {
			    continue
			}
			lappend Lft [list "fstart" $x "fstop" $x "fcolor" magenta "fscore" 0.0 "fnote" $s "fcsys" local] 
		    }
		}

		if {$Lft != {} } {
		    set YaSt 1
		    set ::TabSF(${p},$ft) $Lft
		}
	    }
	    
	    # rajoute BLOCK comme feature
	    # Trash ...
	    set Ll [LesLignesDuFichier $f]
	    set i [lsearch -regexp $Ll {colsco-data}]
	    incr i
	    set l [lindex $Ll $i]
	    if {[set ib [string first "<" $l]] != -1} {
		set l [string range $l 0 $ib-1]
	    }
	    set l [string map [list "\n" ""] $l]
	    regsub -all { +} $l " " l
	    set Lv [split [string trim $l] " "]
	    set ft "BLOCK"
	    set i 0 ; set dg -1 ; set nbb 1
	    set Lft [list]
	    foreach v $Lv {
		if {$v} {
		    if {$dg == -1} {
			set dg $i
		    }
		    set fg $i
		} else {
		    if {$dg != -1} {
			lappend Lft [list "fstart" $dg "fstop" $fg "fcolor" orange "fscore" 0.0 "fnote" Block_$nbb "fcsys" local]
			incr nbb
			set dg -1
		    }
		}
		incr i
	    }
	    if {$dg != -1} {
		lappend Lft [list "fstart" $dg "fstop" [expr {$i-1}] "fcolor" orange "fscore" 0.0 "fnote" Block_$nbb "fcsys" local]
	    }

	    if {$Lft != {} } {
		set YaBl 1
		foreach n $::LNOrdali {
		    if {$n eq ""} {continue}
		    set ::TabSF(${n},$ft) $Lft
		}
	    }

	    if {$YaSt || $YaBl} {
		if {$YaSt} {
		    puts " --> Site"
		}
		if {$YaBl} {
		    puts " --> Blocks"
		}
		CreeLeMacsim $fout
	    }
	    
	    if {$::ListePDB != {} } {
		CreeObjBali $f
	    }
	    VueEditee 1

	    SauveLAlignement ORD JLeSauveAs

	    FermeFichier
	}
    }

    exit

}

proc AnnoteLeXMLDesARPs {{FichierXML ""} {FichierXMLOut ""}} {


    package require tdom

    Wup "Permet de modifier un fichier XML au format macsim pour y ajouter des informations"
    Wup "Ajout des positions des residus discriminants (1 couleur par groupe de residu)"
    Wup "Ajout des domaines (Family Insertion) avec 1 couleur par domaine."

    Wup "PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF POUR LA FAMILLE ARP2"
    Wup "ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES"

    if {$FichierXMLOut == ""} {return ""}

    set Famille ""
    set LesAccessAVirer ""

    #1 Recuperation de la famille d ARP (primordial)
    ################################################
    set Famille [file tail $FichierXML]
    set Famille_tmp ""
    regsub -nocase ".xml" $Famille "" Famille
    regexp -nocase  {_([a-z]{2,4}[0-9]{1,2}|actin|orphans)$} $Famille tmp Famille_tmp
    if {$Famille_tmp != ""} {set Famille $Famille_tmp}

    set AccessDeRef     "P02568"
    set AccessDeRef_OLD ""

    #2 Preparation Parsing XML avec TDOM
    #  Recuperation du noeud initial du XML
    set MacsimXml   [ContenuDuFichier $FichierXML]
    set IdXML       [dom parse $MacsimXml]
    set NoeudMacsim [$IdXML documentElement] 
    set  RId        [$NoeudMacsim selectNodes "alignment"]
    if {$RId == ""} {return ""}

    if {$Famille == "ARP2"} {
	#PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	#ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	set AccessDeRef_OLD $AccessDeRef
	set AccessDeRef     "ARP05"
    }
    
    #3   Traitement de la reference 
    #3-1 Recuperation du noeud initial de la Sequence de reference
    #P02568
    set qRef "//*\[string(seq-name)='$AccessDeRef'\]/*\[name(.)='seq-data'\]"
    set nRef [$RId  selectNodes "$qRef"]
    set sRef [$nRef selectNodes string(.)]

    #3-2 Calcul des positions absolue par rapport a l alignement
    ############################################################
    PositionAutreDe Absolue 1 $sRef
    #3-2-1 Pour les RESIDUS discriminants
    set  LesGroupesDeResidus   [InterrogeLesResidusDesARPs $Famille LesGroupes]
    foreach Groupe $LesGroupesDeResidus {
	set LesPositionsDesRes [InterrogeLesResidusDesARPs $Famille Groupe $Groupe Access $AccessDeRef LesPositions]
	#Espionne "Pos: $LesPositionsDesRes"
	foreach Pos $LesPositionsDesRes { 
	    #on veut la position absolue
	    set PosAbs [PositionAutreDe Relative $Pos $sRef]
	    set TabPosAbsDeRel(Absolue,$Groupe,$Pos) $PosAbs
	    #Espionne "$Pos -- $PosAbs"
	}
    }

    if {$AccessDeRef_OLD != ""} {
	#PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	#ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	set AccessDeRef $AccessDeRef_OLD

	#3   Traitement de la reference 
	#3-1 Recuperation du noeud initial de la Sequence de reference
	#P02568
 	set qRef ""
	set nRef ""
	set sRef ""

 	set qRef "//*\[string(seq-name)='$AccessDeRef'\]/*\[name(.)='seq-data'\]"
	set nRef [$RId  selectNodes "$qRef"]
	set sRef [$nRef selectNodes string(.)] 

	PositionAutreDe Absolue 1 $sRef
    }
    
    #3-2-2 Pour les DOMAINS discriminants
    set  LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef IN LesPositions]
    #1 On ne possede que la borne gauche de l insertion on ajoute donc + 1 pour avoir la fin
    #                 PosD        PosD+1
    #                  |           |
    # TMYPGIADRMQKEITALA...........PSTMKIKIIAPPERKYS
    # TMYPGLPSRLERELKQLYLERVLKGDVEKLSKFKIRIEDPPRRKHM
    #                  |           |
    #                 InD         InF
    set MaxLengthIN "8"
    set               LesDFPositionsDesDomaines ""
    foreach Position $LesPositionsDesDomaines {
	#On test si le domaine est specifique (conserve) pour toutes les proteines de la famille
	set  SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Remarque]
	if {$SpeOuPas == "" || [regexp -nocase "not specific" $SpeOuPas]} {continue}
	set  Taille   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Taille]
	if {$Taille   == "" || $Taille < $MaxLengthIN}                    {continue}
	
	lappend LesDFPositionsDesDomaines $Position
	lappend LesDFPositionsDesDomaines [expr {$Position + 1}]
    }
    foreach {PosD PosF} $LesDFPositionsDesDomaines { 
	#on veut la position absolue 
	#set AccessDeRef "P02568"
	#Attention probleme quand on a une insertion en N-terminal (on prend comme valeur absolue 1)
	#Attention on triche
	if {$PosD == "1" && $AccessDeRef == "P02568"} {
	    set PosDAbs "1"
	    set PosFAbs [PositionAutreDe Relative [expr {$PosF -1}] $sRef]
	} else {
	    set PosDAbs [PositionAutreDe Relative $PosD $sRef]
	    set PosFAbs [PositionAutreDe Relative $PosF $sRef]
	}
	set TabPosAbsDeRel(Absolue,Domain,$PosD) $PosDAbs
	set TabPosAbsDeRel(Absolue,Domain,$PosF) $PosFAbs
	#Espionne "$Pos -- $PosAbs"
    }

    #4 Recuperation de l ensemble des Noms de sequence et des sequences elle memes
    #  On va ensuite parcourir en parallel les 2 listes
    set qAcc "//seq-name"
    set nAcc [$RId  selectNodes "$qAcc"]
    foreach Node $nAcc {
	set Acc [$Node selectNodes string(.)]
	lappend LesAcc $Acc
    }
    set qAcc "//seq-data"
    set nAcc [$RId  selectNodes "$qAcc"]
    foreach Node $nAcc {
	set sAcc [$Node selectNodes string(.)]
	lappend LesSeqAcc $sAcc
    }

    #4 Boucle sur les 2 listes en parallele
    #######################################
    foreach Acc $LesAcc Seq $LesSeqAcc {
	#
	#R
	#11
	#5
	#0.00
	#R
	#
	set LesFItems ""
	#Le noeud de la sequence pour ajouter a l arbre
	set qRef "//*\[string(seq-name)='$Acc'\]/descendant::*\[name()='seq-info'\]"
	set nRef     [$RId  selectNodes "$qRef"]
	set VNodeRef [$nRef selectNodes "name(.)"]

	#Stockage des Access des ARPs a ne pas retenir (ex: ARP02)
	if {[regexp -nocase {^arp[0-9]{1,2}} $Acc]} {
	    lappend LesAccessAVirer $Acc
	}
	
	#5 Traitement des donnees sur les residus
	#########################################
	set LesFItems ""
	set i 0
	lappend LesFItems ""

	if {$Famille == "ARP2"} {
	    #PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	    #ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	    set AccessDeRef_OLD $AccessDeRef
	    set AccessDeRef     "ARP05"
	}
    
	foreach Groupe $LesGroupesDeResidus {
	    set LesPositionsDesRes [InterrogeLesResidusDesARPs $Famille Groupe $Groupe Access $AccessDeRef LesPositions]
	    #Espionne "Pos: $LesPositionsDesRes"
	    incr i
	    #On remet les couleurs a 0
	    if {$i>15} {set i 1}
	    set Color $i

	    foreach Pos $LesPositionsDesRes {
		if {$Pos     == ""} {Espionne "Pos vide"} 
		if {$Color   == ""} {Espionne "Color vide"} 
		if {$Famille == ""} {Espionne "Famille vide"} 
 
		#Recuperation de la valeur du Residu
		set Residu [InterrogeLesResidusDesARPs $Famille $AccessDeRef $Pos Res]

		#Recuperation des positions absolues
		set PosAbs [set TabPosAbsDeRel(Absolue,$Groupe,$Pos)]
		set PosRel [PositionAutreDe Absolue $PosAbs $Seq]
		set PosOk  "$PosAbs"
		#Espionne "$Acc -- $PosAbs - $PosRel -- $Residu"
		
		set    Item ""
		append Item ""
		append Item "Specific"
		append Item "$PosOk"
		append Item "$PosOk"
		append Item "$Color"
		append Item ""
		#append Item "\"Residue $Residu\""
		append Item "AbsolutePosition Residue $Residu in $PosRel"
		append Item ""
		
		lappend LesFItems "$Item"
	    }
	}

	#6 Traitement des donnees sur les domaines
	##########################################
	if {$AccessDeRef_OLD != ""} {
	    #PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	    #ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	    set AccessDeRef $AccessDeRef_OLD
	}
	set i 0
	foreach {PosD PosF} $LesDFPositionsDesDomaines {
	    incr i
	    #On remet les couleurs a 0
	    if {$i>15} {set i 1}
	    set Color $i

	    if {$PosD    == "" || $PosF == ""} {Espionne "Pos vide"} 
	    if {$Color   == ""}                {Espionne "Color vide"} 
	    if {$Famille == ""}                {Espionne "Famille vide"} 

	    #Recuperation des positions absolues pour les relatives
	    set PosAbsD [set TabPosAbsDeRel(Absolue,Domain,$PosD)]
	    set PosRelD [PositionAutreDe Absolue $PosAbsD $Seq]
	    #Pour les problemes de insertions en N-terminal
	    if {$PosRelD== "0"} {set PosRelD "1"} 
	    set PosDOk  "$PosAbsD"

	    set PosAbsF [set TabPosAbsDeRel(Absolue,Domain,$PosF)]
	    set PosRelF [PositionAutreDe Absolue $PosAbsF $Seq]
	    set PosFOk  "$PosAbsF"
	    #Espionne "$Acc -- $PosAbsD + $PosRelD | $PosAbsF + $PosRelF" 
	    
	    set    Item ""
	    append Item ""
	    append Item "Specific"
	    append Item "$PosDOk"
	    append Item "$PosFOk"
	    append Item "$Color"
	    append Item ""
	    append Item "AbsolutePosition Domain $PosRelD-$PosRelF"
	    append Item ""
	    
	    lappend LesFItems "$Item"
	}
	lappend LesFItems ""
	$nRef appendXML [join $LesFItems "\n"] 
    }

    #7   On se debarasse des sequences qui sont genantes
    #7-1 Les access P02568_*
    set AccessDeRef "P02568"
    set qRef "/macsim/alignment/sequence\[contains(.,'${AccessDeRef}_')\]"
    set nRef [$RId selectNodes "$qRef"]
    foreach Node $nRef {
	set sRef [$Node delete]
    }
    
    #7-2 Les access genants des ARP (ex: ARP02)
    foreach Acc $LesAccessAVirer {
	set qRef "/macsim/alignment/sequence\[contains(.,'${Acc}')\]"
	set nRef [$RId selectNodes "$qRef"]
	foreach Node $nRef {
	    set sRef [$Node delete]
	}
    }

    #8 Sauvegarde du fichier XML
    ############################
    if {[file exists $FichierXMLOut]} {
	file delete -force $FichierXMLOut
    }
    #Attention le fichier XML doit contenir pour etre utilise (clustalw) les 2 entetes suivants
    #
    #
    #Le dernier est obtenue par l option doctypeDeclaration de asXML
    set EnteteXML "" 
    set    f [open $FichierXMLOut w]
    puts  $f $EnteteXML
    puts  $f [$IdXML asXML -doctypeDeclaration 1 -indent 2]
    close $f

    return "$FichierXMLOut"

}

proc AnnoteLeXMLDesARPs_article {{FichierXML ""} {FichierXMLOut ""}} {


    package require tdom

    Wup "Pour faire le fichier html de l alignement pour l article"
    Wup "Permet de modifier un fichier XML au format macsim pour y ajouter des informations"
    Wup "Ajout des positions des residus discriminants (1 couleur par groupe de residu)"
    Wup "Ajout des domaines (Family Insertion) avec 1 couleur par domaine."

    Wup "PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF POUR LA FAMILLE ARP2"
    Wup "ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES"

    if {$FichierXMLOut == ""} {return ""}

    set Famille ""
    set LesAccessAVirer ""

    #1 Preparation Parsing XML avec TDOM
    #  Recuperation du noeud initial du XML
    set MacsimXml   [ContenuDuFichier $FichierXML]
    set IdXML       [dom parse $MacsimXml]
    set NoeudMacsim [$IdXML documentElement] 
    set  RId        [$NoeudMacsim selectNodes "alignment"]
    if {$RId == ""} {return ""}

    #2 Recuperation de l ensemble des Noms de sequence et des sequences elle memes
    #  On va ensuite parcourir en parallel les 2 listes
    set qAcc "//seq-name"
    set nAcc [$RId  selectNodes "$qAcc"]
    foreach Node $nAcc {
	set Acc [$Node selectNodes string(.)]
	lappend LesAcc $Acc
    }
    set qAcc "//seq-data"
    set nAcc [$RId  selectNodes "$qAcc"]
    foreach Node $nAcc {
	set sAcc [$Node selectNodes string(.)]
	lappend LesSeqAcc $sAcc
    }
    
    #3 Boucle sur les 2 listes en parallele
    #######################################
    foreach Acc $LesAcc Seq $LesSeqAcc {
	set LesDFPositionsDesDomaines ""

	#3-1 Recuperation de la famille d ARP (primordial)
	##################################################
	if {[regexp -nocase {separator}          $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}
	if {[regexp -nocase {reference\-\-\-\-_} $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}
	if {[regexp -nocase {1yag_a_2}           $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}
	if {[regexp -nocase {\-\-\-\-Nt_Kato2001\-\-\-\-}  $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}
	if {[regexp -nocase {\-\-\-\-Dimerization\-\-\-\-} $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}
	if {[regexp -nocase {\-\-\-\-NES\-\-\-\-}          $Acc]} {
	    #Espionne "$Acc"
	    lappend LesAccessAVirer $Acc
	}

	if {[regexp {\-\-\-\-} $Acc]} {continue}
	set     Categorie [InterrogeLesInfosDesARPs [string toupper $Acc] Categorie]
	if {   $Categorie == ""} {
	    set Categorie "Unknown"
	    continue
	} else {
	    regsub -all {\-\-\-\-} $Categorie "" Categorie
	    regsub           "Les" $Categorie "" Categorie
	}
	set Famille $Categorie
	
	#Espionne ">> $Acc -- $Famille"

	if {! [info exists TabPosAbsDeRel($Famille)]} {
	    #Espionne "On fait la famille $Famille"
	    #4 Recuperation des positions absolues des differents features (domaines et residus)
	    ####################################################################################
	    set AccessDeRef     "P02568"
	    set AccessDeRef_OLD ""
	    if {$Famille == "ARP2"} {
		#PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
		#ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
		set AccessDeRef_OLD $AccessDeRef
		set AccessDeRef     "ARP05"
	    }

	    #4   Traitement de la reference 
	    #4-1 Recuperation du noeud initial de la Sequence de reference
	    #P02568
	    set qRef "//*\[string(seq-name)='$AccessDeRef'\]/*\[name(.)='seq-data'\]"
	    set nRef [$RId  selectNodes "$qRef"]
	    set sRef [$nRef selectNodes string(.)]
	    
	    #4-2 Calcul des positions absolue par rapport a l alignement
	    ############################################################
	    PositionAutreDe Absolue 1 $sRef
	    #4-2-1 Pour les RESIDUS discriminants
	    set  LesGroupesDeResidus   [InterrogeLesResidusDesARPs $Famille LesGroupes]
	    foreach Groupe $LesGroupesDeResidus {
		set LesPositionsDesRes [InterrogeLesResidusDesARPs $Famille Groupe $Groupe Access $AccessDeRef LesPositions]
		#Espionne "Pos: $LesPositionsDesRes"
		foreach Pos $LesPositionsDesRes { 
		    #on veut la position absolue
		    set PosAbs [PositionAutreDe Relative $Pos $sRef]
		    set TabPosAbsDeRel($Famille,Absolue,$Groupe,$Pos) $PosAbs
		    #Espionne "$Pos -- $PosAbs"
		}
	    }
	    set TabPosAbsDeRel($Famille,LesGroupesDeResidus) $LesGroupesDeResidus

	    if {$AccessDeRef_OLD != ""} {
		#PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
		#ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
		set AccessDeRef $AccessDeRef_OLD
		
		#3   Traitement de la reference 
		#3-1 Recuperation du noeud initial de la Sequence de reference
		#P02568
		set qRef ""
		set nRef ""
		set sRef ""
		
		set qRef "//*\[string(seq-name)='$AccessDeRef'\]/*\[name(.)='seq-data'\]"
		set nRef [$RId  selectNodes "$qRef"]
		set sRef [$nRef selectNodes string(.)] 
		
		PositionAutreDe Absolue 1 $sRef
	    }
	    
	    #4-2-2 Pour les DOMAINS discriminants
	    set  LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef IN LesPositions]
	    #1 On ne possede que la borne gauche de l insertion on ajoute donc + 1 pour avoir la fin
	    #                 PosD        PosD+1
	    #                  |           |
	    # TMYPGIADRMQKEITALA...........PSTMKIKIIAPPERKYS
	    # TMYPGLPSRLERELKQLYLERVLKGDVEKLSKFKIRIEDPPRRKHM
	    #                  |           |
	    #                 InD         InF
	    set MaxLengthIN "8"
	    set               LesDFPositionsDesDomaines ""
	    foreach Position $LesPositionsDesDomaines {
		#On test si le domaine est specifique (conserve) pour toutes les proteines de la famille
		set  SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Remarque]
		if {$SpeOuPas == "" || [regexp -nocase "not specific" $SpeOuPas]} {continue}
		set  Taille   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Taille]
		if {$Taille   == "" || $Taille < $MaxLengthIN}                    {continue}
		
		lappend LesDFPositionsDesDomaines $Position
		lappend LesDFPositionsDesDomaines [expr {$Position + 1}]
	    }

	    set TabPosAbsDeRel($Famille,LesDFPositionsDesDomaines) $LesDFPositionsDesDomaines

	    foreach {PosD PosF} $LesDFPositionsDesDomaines { 
		#on veut la position absolue 
		#set AccessDeRef "P02568"
		#Attention probleme quand on a une insertion en N-terminal (on prend comme valeur absolue 1)
		#Attention on triche
		if {$PosD == "1" && $AccessDeRef == "P02568"} {
		    set PosDAbs "1"
		    set PosFAbs [PositionAutreDe Relative [expr {$PosF -1}] $sRef]
		} else {
		    set PosDAbs [PositionAutreDe Relative $PosD $sRef]
		    set PosFAbs [PositionAutreDe Relative $PosF $sRef]
		}
		set TabPosAbsDeRel($Famille,Absolue,Domain,$PosD) $PosDAbs
		set TabPosAbsDeRel($Famille,Absolue,Domain,$PosF) $PosFAbs
		#Espionne "$Pos -- $PosAbs"
	    }
	    
	    #Ok la famille est faite
	    set TabPosAbsDeRel($Famille) "1"
	} else {
	    #On recupere les groupes de residus et les Debut/Fin des domaines a checker
	    set LesGroupesDeResidus       [set TabPosAbsDeRel($Famille,LesGroupesDeResidus)] 
	    set LesDFPositionsDesDomaines [set TabPosAbsDeRel($Famille,LesDFPositionsDesDomaines)]
	}
	
	#
	#R
	#11
	#5
	#0.00
	#R
	#
	set LesFItems ""
	#Le noeud de la sequence pour ajouter a l arbre
	set qRef "//*\[string(seq-name)='$Acc'\]/descendant::*\[name()='seq-info'\]"
	set nRef     [$RId selectNodes "$qRef"]
	set VNodeRef [$nRef selectNodes "name(.)"]

	#Stockage des Access des ARPs a ne pas retenir (ex: ARP02)
	if {[regexp -nocase {^arp[0-9]{1,2}} $Acc]} {
	    lappend LesAccessAVirer $Acc
	}
	
	#5 Traitement des donnees sur les residus
	#########################################
	set LesFItems ""
	set i 0
	lappend LesFItems ""

	if {$Famille == "ARP2"} {
	    #PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	    #ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	    set AccessDeRef_OLD $AccessDeRef
	    set AccessDeRef     "ARP05"
	}
    
	foreach Groupe $LesGroupesDeResidus {
	    set LesPositionsDesRes [InterrogeLesResidusDesARPs $Famille Groupe $Groupe Access $AccessDeRef LesPositions]
	    #Espionne "Pos: $LesPositionsDesRes"
	    incr i
	    #On remet les couleurs a 0
	    if {$i>15} {set i 1}
	    set Color $i

	    foreach Pos $LesPositionsDesRes {
		if {$Pos     == ""} {Espionne "Pos vide"} 
		if {$Color   == ""} {Espionne "Color vide"} 
		if {$Famille == ""} {Espionne "Famille vide"} 
 
		#Recuperation de la valeur du Residu
		set Residu [InterrogeLesResidusDesARPs $Famille $AccessDeRef $Pos Res]

		#Recuperation des positions absolues
		set PosAbs [set TabPosAbsDeRel($Famille,Absolue,$Groupe,$Pos)]
		set PosRel [PositionAutreDe Absolue $PosAbs $Seq]
		set PosOk  "$PosAbs"
		#Espionne "$Acc -- $PosAbs - $PosRel -- $Residu"
		
		set    Item ""
		append Item ""
		append Item "Specific"
		append Item "$PosOk"
		append Item "$PosOk"
		append Item "$Color"
		append Item ""
		#append Item "\"Residue $Residu\""
		append Item "AbsolutePosition Residue $Residu in $PosRel"
		append Item ""
		
		lappend LesFItems "$Item"
	    }
	}

	#6 Traitement des donnees sur les domaines
	##########################################
	if {$AccessDeRef_OLD != ""} {
	    #PROBLEME DE POSITIONS PAR RAPPORT A L ACTINE DE REF
	    #ATTENTION ON REVIENT A LA NORMALE PAR APRES CAR C PAS BON POUR LES DOMAINES
	    set AccessDeRef $AccessDeRef_OLD
	}
	set i 0
	foreach {PosD PosF} $LesDFPositionsDesDomaines {
	    incr i
	    #On remet les couleurs a 0
	    if {$i>15} {set i 1}
	    set Color $i

	    if {$PosD    == "" || $PosF == ""} {Espionne "Pos vide"} 
	    if {$Color   == ""}                {Espionne "Color vide"} 
	    if {$Famille == ""}                {Espionne "Famille vide"} 

	    #Recuperation des positions absolues pour les relatives
	    set PosAbsD [set TabPosAbsDeRel($Famille,Absolue,Domain,$PosD)]
	    set PosRelD [PositionAutreDe Absolue $PosAbsD $Seq]
	    #Pour les problemes de insertions en N-terminal
	    if {$PosRelD== "0"} {set PosRelD "1"} 
	    set PosDOk  "$PosAbsD"

	    set PosAbsF [set TabPosAbsDeRel($Famille,Absolue,Domain,$PosF)]
	    set PosRelF [PositionAutreDe Absolue $PosAbsF $Seq]
	    set PosFOk  "$PosAbsF"
	    #Espionne "$Acc -- $PosAbsD + $PosRelD | $PosAbsF + $PosRelF" 
	    
	    set    Item ""
	    append Item ""
	    append Item "Specific"
	    append Item "$PosDOk"
	    append Item "$PosFOk"
	    append Item "$Color"
	    append Item ""
	    append Item "AbsolutePosition Domain $PosRelD-$PosRelF"
	    append Item ""
	    
	    lappend LesFItems "$Item"
	}
	lappend LesFItems ""
	$nRef appendXML [join $LesFItems "\n"] 
    }

    #7   On se debarasse des sequences qui sont genantes
    #7-1 Les access P02568_*
    set AccessDeRef "P02568"
    set qRef "/macsim/alignment/sequence\[contains(.,'${AccessDeRef}_')\]"
    set nRef [$RId selectNodes "$qRef"]
    foreach Node $nRef {
	set sRef [$Node delete]
    }
    
    #7-2 Les access genants des ARP (ex: ARP02)
    foreach Acc $LesAccessAVirer {
	set qRef "/macsim/alignment/sequence\[contains(.,'${Acc}')\]"
	set nRef [$RId selectNodes "$qRef"]
	foreach Node $nRef {
	    set sRef [$Node delete]
	}
    }

    #8 Sauvegarde du fichier XML
    ############################
    if {[file exists $FichierXMLOut]} {
	file delete -force $FichierXMLOut
    }
    #Attention le fichier XML doit contenir pour etre utilise (clustalw) les 2 entetes suivants
    #
    #
    #Le dernier est obtenue par l option doctypeDeclaration de asXML
    set EnteteXML "" 
    set    f [open $FichierXMLOut w]
    puts  $f $EnteteXML
    puts  $f [$IdXML asXML -doctypeDeclaration 1 -indent 2]
    close $f

    return "$FichierXMLOut"

}

proc AnnoteNonAnnotes {} {

    global LNOrdali TDesDescriptifs TDesOrganismes TDesTaxId TDuLineage TDesPhylum

    set L2gi [list]
    foreach n $LNOrdali {
	if {$n eq ""} {continue}

	if {[EstUnRefseq $n]} {
	    lappend L2gi $n
	}
	if {[set TDesOrganismes($n)] eq ""} {
	    lappend L2gi $n
	}
    }
    set L2gi [lsort -unique $L2gi]
    puts "\nL2gi $L2gi"
    set Lgi [Convert2GI protein $L2gi]
    puts "Lgi $Lgi"

    # retrieve basic information
    array set T [eSummaryREST protein $Lgi]
    set Ltn [list] ; set Lti [list]
    foreach gi $Lgi n $L2gi {
	# GI not found
	if {$gi eq $n} {continue}

	if {[info exists T($gi,Title)]} {
	    set TDesDescriptifs($n) [set T($gi,Title)]
	}
	if {[info exists T($gi,TaxId)]} {
	    set tid [set T($gi,TaxId)]
	    set TDesTaxId($n) $tid
	    lappend Ltn $n
	    lappend Lti $tid
	}
    }

    if {$Ltn != {} } {
	array set X [eFetchREST taxonomy $Lti]
	parray X
	foreach n $Ltn id $Lti {
	    if {[info exists X($id,Lineage)]} {
		set lin [split [set X($id,Lineage)] ;]
		set TDuLineage($n) $lin
		set TDesPhylum($n) [lindex $lin 1]
		set TDesOrganismes($n) [set X($id,ScientificName)]
	    }
	}
    }

    VueEditee 1
    SauveLAlignement XML JLeSauveAs

    puts ""
    foreach n $::LNOrdali {
	if {$n eq ""} {
	    puts ";;"
	    continue
	}
	
	set o [set TDesOrganismes($n)]
	set p [set TDuLineage($n)]
	puts "$n;$o;$p"
    }
    
    exit

}

proc AnnotePfam {} {

    global LNOrdali LSOrdali Rpfm
    
    foreach n $LNOrdali s $LSOrdali {
	if {$n eq ""} {
	    continue
	}
	
	set s [string map {"." ""} $s]
	trace add variable Rpfm($n) write TraitePfamScanResult
	set Rpfm($n,id) [after idle "LaunchPfamScan $n $s"]
    }

    puts "Rpfm"
    foreach k [array names ::Rpfm] {
	puts "$k $::Rpfm($k)"
    }

    return

}

proc AnnoteXml {Qui Quoi AccessDeRef FichierXml FichierResultat} {



    #Espionne "Dans le AnnoteXml: $AccessDeRef"	
    #Espionne "->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->->FichierXml: $FichierXml"
    
    package require tdom

    set EnteteXML "" 

    Wup "Permet de modifier un fichier XML au format macsim pour y ajouter des informations"


    #2 Preparation Parsing XML avec TDOM
    #  Recuperation du noeud initial du XML

    set MacsimXml   [ContenuDuFichier $FichierXml]
    set IdXML       [dom parse $MacsimXml]
    set NoeudMacsim [$IdXML documentElement] 
    set  RId        [$NoeudMacsim selectNodes "alignment"]
    if {$RId == ""} {
	    	$RId delete
		$NoeudMacsim delete
		$IdXML delete
		return ""
    }

    while 1 {
		set qRef "//*\[string(seq-name)='$AccessDeRef'\]/descendant::*\[name()='ftable'\]"
		set nRef     [$RId  selectNodes "$qRef"]
		if {$nRef!=""} { break }	
		set qRef "//*\[string(seq-name)='$AccessDeRef'\]/descendant::*\[name()='seq-info'\]"
		set nRef     [$RId  selectNodes "$qRef"]
		if {$nRef==""} {
	    		$RId delete
			$NoeudMacsim delete
			$IdXML delete		
			return ""
		}	
		$nRef appendXML ""
   }
    
    set LesIndicesDesSegments [Interroge$Qui $FichierResultat $Quoi]
    foreach I $LesIndicesDesSegments {
	
	set DebFin [Interroge$Qui $FichierResultat $Quoi $I]
	set Deb ""
	set Fin ""
	regsub {\-} $DebFin " " DebFin
	scan $DebFin "%d %d" Deb Fin
	
	if {$Deb==""} { 
		$RId delete
		$NoeudMacsim delete
		$IdXML delete
		return "" 
	}
	
	switch ${Qui}_$Quoi {
	    "GlobPlot_Disorder" { 
		set Color 4
		#Espionne "GlobPlot color 1"
	    }
	    "GlobPlot_GlobDoms" {
                set Color 5
                #Espionne "GlobPlot color 1"
            }
	    "DisEMBL_LOOPS" { 
		set Color 11 
		#Espionne "DisEMBL color 2"
	    }
            "DisEMBL_HOTLOOPS" {
                set Color 21
                #Espionne "DisEMBL color 2"
            }
            "DisEMBL_REM465" {
                set Color 19
                #Espionne "DisEMBL color 2"
            }
	    "FoldIndex_pds" { 
		set Color 6
		#Espionne "FoldIndex color 3"
	    }
	    "Ronn_DR" { 
		set Color 13 
		#Espionne "Ronn color 4"
	    }
	    default { set Color 1 }
	}
	
	#Espionne "Color: $Color"
	#set Color 25
	
	set FType "KOANNO"
	if {[regexp "${Qui}$Quoi$" $AccessDeRef]} {
	    set FType "AllPredictions"
	}
	
	set    Item ""
	append Item ""
	append Item "$FType"
	append Item "$Deb"
	append Item "$Fin"
	append Item "$Color"
	append Item "0"
	#$Qui $Quoi
	append Item "${Qui}_$Quoi"
	append Item ""
	
	$nRef appendXML $Item
    }
    
	set Status [SauveTDom $IdXML $EnteteXML $FichierXml]
	$RId delete
	$NoeudMacsim delete
	$IdXML delete
	
	return $Status

}

proc AnnoteXmlParTousPourUnAccess {Access FichierXml LesResultats} {

    foreach FichierResultat $LesResultats {
	if { [FileAbsent $FichierResultat]} { continue }
	set Queue [file tail $FichierResultat]
	regsub -nocase {Resultat\.html$} $Queue "" AP
	set P [StringApres "${Access}_" dans $AP]
	set P [BonneOrthographePour $P]
	set  BonAnnoteXml [QuelAnnoteXmlPour $P]
	if {$BonAnnoteXml==""} { continue }
	set Status [$BonAnnoteXml ${Access}_$P $FichierXml $FichierResultat]
    }
    return $FichierXml

}

proc AnnoteXmlPourDisEMBL {Access FichierXml FichierResultat} {

	set LesTypes [list "LOOPS" "HOTLOOPS" "REM465"]
	if {$Access=="LesTypes"} { return $LesTypes }
	set EtType ""
	foreach Type $LesTypes {
		if {[regexp "_DisEMBL$" $Access]} { set EtType "$Type" }
		AnnoteXml "DisEMBL" $Type ${Access}$EtType $FichierXml $FichierResultat
	}
	#global InfoDisEMBL; if {[info exists InfoDisEMBL]} { 
	#Espionne "Unset InfoDisEMBL"
	#array unset InfoDisEMBL 
	#}
	#ressayer cela mais avec une ,*
	DechargeDisEMBL $FichierResultat

}

proc AnnoteXmlPourDisEMBLX {Access FichierXml FichierResultat} {

    set LesTypes [list "LOOPS" "HOTLOOPS" "REM465"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_DisEMBL$" $Access]} { set EtType "$Type" }
	#AnnoteXml "DisEMBL" $Type ${Access}$EtType $FichierXml $FichierResultat
	InterrogeDisEMBL $FichierResultat $Type
    }

}

proc AnnoteXmlPourFoldIndex {Access FichierXml FichierResultat} {

    set LesTypes [list "pds"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_FoldIndex$" $Access]} { set EtType "$Type" }
	AnnoteXml "FoldIndex" $Type ${Access}$EtType $FichierXml $FichierResultat
    }
    #global InfoFoldIndex; if {[info exists InfoFoldIndex]} { 
    		#Espionne "Unset InfoFoldIndex"
    	#	array unset InfoFoldIndex 
	#}
	DechargeFoldIndex $FichierResultat

}

proc AnnoteXmlPourFoldIndexX {Access FichierXml FichierResultat} {

    set LesTypes [list "pds"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_FoldIndex$" $Access]} { set EtType "$Type" }
	InterrogeFoldIndex $FichierResultat $Type
    }
    #DechargeFoldIndex $FichierResultat

}

proc AnnoteXmlPourGlobPlot {Access FichierXml FichierResultat} {

	set LesTypes [list "Disorder" "GlobDoms"]
	if {$Access=="LesTypes"} { return $LesTypes }
	set EtType ""
	foreach Type $LesTypes {
		if {[regexp "_GlobPlot$" $Access]} { set EtType "$Type" }
		AnnoteXml "GlobPlot" $Type ${Access}$EtType $FichierXml $FichierResultat
	}
	#global InfoGlobPlot; if {[info exists InfoGlobPlot]} { 
		#Espionne "Unset InfoGlobPlot"
	#	array unset InfoGlobPlot 
	#}
	DechargeGlobPlot $FichierResultat


}

proc AnnoteXmlPourGlobPlotX {Access FichierXml FichierResultat} {

    set LesTypes [list "Disorder" "GlobDoms"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_GlobPlot$" $Access]} { set EtType "$Type" }
	InterrogeGlobPlot $FichierResultat $Type
    }
    #DechargeGlobPlot $FichierResultat

}

proc AnnoteXmlPourLesAccess {LesAccess RepParent FichierXml} {

	set varGlo [info globals]

	set Status ""
	foreach Access $LesAccess {
		set Rep "$RepParent/$Access"
		if { [FileAbsent $Rep]} { continue }
		set Status [AnnoteXmlPourUnAccess $Access $Rep $FichierXml]
	}

	Espionne "dans AnnoteXMLPourLesAccess"
	foreach v1 [info globals] {
	    if {$v1 in $varGlo} {continue}
	    puts $v1
	}

    return $Status
    #verifie les variable global

}

proc AnnoteXmlPourRonn {Access FichierXml FichierResultat} {

    set LesTypes [list "DR"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_Ronn$" $Access]} { set EtType "$Type" }	
	AnnoteXml "Ronn" $Type ${Access}$EtType $FichierXml $FichierResultat
    }
    #global InfoRonn; if {[info exists InfoRonn]} { 
		#Espionne "Unset InfoRonn"
    	#	array unset InfoRonn
    #}
	DechargeRonn $FichierResultat

}

proc AnnoteXmlPourRonnX {Access FichierXml FichierResultat} {

    set LesTypes [list "DR"]
    if {$Access=="LesTypes"} { return $LesTypes }
    set EtType ""
    foreach Type $LesTypes {
	if {[regexp "_Ronn$" $Access]} { set EtType "$Type" }	
	InterrogeRonn $FichierResultat $Type
    }
    #DechargeRonn $FichierResultat

}

proc AnnoteXmlPourUnAccess {Access Rep FichierXml} {

    #set LIGlobals [info globals]

	set Status ""
	foreach FichierResultat [glob -nocomplain "$Rep/{$Access}_*"] {
		regsub -nocase {Resultat\.html$} $FichierResultat "" AP
		set P [StringApres "${Access}_" dans $AP]
		set  BonAnnoteXml [QuelAnnoteXmlPour $P]
		if {$BonAnnoteXml==""} { continue }
		set Status [$BonAnnoteXml $Access $FichierXml $FichierResultat]
	}
	#Espionne "Avant la boucle de globals INfo"
	#foreach v [info globals] {
	 #   if {$v in $LIGlobals} {continue}
	  #  puts "variable tjours presente: $v"
	#}
	
	return $Status

}

proc AnyBal {f} {

    global ListePDB LConsSA
    global LNOrdali LSOrdali Sequences PABCourant OrdTmpDir FichierMSF Defauts SDG NomSeqSel
    global NId NCo NTt NConsDansId NConsDansCo NConsDansTt TableScore LNorMD
    global VariablesAuDepart TNResConsNSA TNResConsSA LongueurTotale LongTot NAli LongTot
    global NBench
    global TResSeeAsId TResSeeAsCo TResSeeAsTt TResId TResCo TResTt

    # Construction du set de residu conserves
    set Lcons [list]
    set Lden [list]
    unset -nocomplain Tden 
    foreach p $ListePDB {
	unset -nocomplain St
	set nom [DonneIdDeAccessPDB $p]
	set chn [DonneChainDeAccessPDB $p]
	set Lsite [$nom GiveVar Site]
	array set St $Lsite
	foreach s [array names St] {
	    foreach {r c nm} [set St($s)] {
		if {$c eq $chn} {
		    set x [DonnePosSG $p $r]
		    if {$x != -1 && $x != ""} {
			incr x
			if {$x ni $Lcons} {
			    lappend Lcons $x
			}
			lappend Tden($x) $p $r $nm
			lappend Lden $x
		    }
		}
	    }
	}
    }
    set l [DenombreLaListe $Lden]
    set LConsSA [list]
    foreach e $l {
	puts "e= $e"
	lassign $e k v
	if {$v != 1} {lappend LConsSA $k}
    }
    if {$LConsSA == {} } {return 0}
    if {$Lcons == {} } {return 0}
    #set LConsSA $Lcons
    puts "Liste cons :"
    puts "[join [DenombreLaListe $Lden] \n]"
    puts "Tableau :"
    parray Tden

    set Ntypes [list Norm Thompson Ranganatan VolPol Liu Liu2 RPCA Entrop1 Entrop2]
    set grp ""
    foreach tnom $Ntypes {
	unset -nocomplain TableScore
	foreach t $tnom {
	    ScoreDe$t $grp
	}
	
	set rep1 [VerificationAvantCalculs]
	if {! $rep1} {
	    puts "Une des methode foireuse !!"
	    puts "skip alignement\n"
	    set BontousTypes 0
	    
	    break
	}
	    
	set BonTousTypes 1
	set rep2 [LanceLesCalculs $tnom $grp 0 bali]
	if {$rep2} {
	    set tmp_TResSeeAsId($tnom) $NConsDansId
	    set tmp_TResSeeAsCo($tnom) $NConsDansCo
	    set tmp_TResSeeAsTt($tnom) $NConsDansTt
	    set tmp_TResId($tnom) $NId
	    set tmp_TResCo($tnom) $NCo
	    set tmp_TResTt($tnom) $NTt
	} else {
	    puts "fail for method $tnom"
	    set BonTousTypes 0
	    break
	}
    }

    if {$BonTousTypes} {
	incr LongTot $LongueurTotale
	incr NAli
	incr NBench [llength $LConsSA]

	foreach tnom $Ntypes {
	    incr TResSeeAsId($tnom) [set tmp_TResSeeAsId($tnom)]
	    incr TResSeeAsCo($tnom) [set tmp_TResSeeAsCo($tnom)]
	    incr TResSeeAsTt($tnom) [set tmp_TResSeeAsTt($tnom)]
	    incr TResId($tnom) [set tmp_TResId($tnom)]
	    incr TResCo($tnom) [set tmp_TResCo($tnom)]
	    incr TResTt($tnom) [set tmp_TResTt($tnom)]
	}
    }
    
    return

}

proc Appartient {LIndividu LesIndividus} {

    set AppartientIlALaPop 0
    foreach UnIndividu $LesIndividus {
	if {$LIndividu == $UnIndividu} {set AppartientIlALaPop 1;break}
    }
    return $AppartientIlALaPop

}

proc Appel {frm index} {


global OrdHlpDir

set tags [$frm tag names $index]
set i [lsearch -glob $tags help-*]

if {$i < 0} {
return
}

set cursor [$frm cget -cursor]
$frm configure -cursor watch
update
set helpfile [string range [lindex $tags $i] 5 end]
uplevel [list source [file join $OrdHlpDir $helpfile.tcl]]
update
$frm configure -cursor $cursor

$frm tag add visited "$index linestart +1 chars" "$index lineend -1 chars"

}

proc AppendAuFichier {Fichier Ligne} {

    set Canal [open $Fichier "a"]
    puts $Canal $Ligne
    close $Canal
    return $Fichier

}

proc AppendAuFichier_CACHEparRR {Fichier Ligne} {

    set Canal [open $Fichier "a"]
    puts $Canal $Ligne
    close $Canal
    return $Fichier

}

proc AppendEtRetourneDistance {Arbre Distance} {

    global ListeDistanceDeChaqueFeuille
    global MiniOuSomme

    JeMeSignale

    if { $Distance == "Inconnue" } {
	if {[EstUneFeuille $Arbre]} {
	    if {[CetteFeuilleEstLaCible $Arbre]} {
		if {$MiniOuSomme == "Mini"} {
		    set Distance 9999999.
		} else {
		    set Distance 0.0
		}
		return $Distance
	    } else {
		return "Inconnue"
	    }
	} else {
	    Dedouble $Arbre G x D y
	    set RetourG [AppendEtRetourneDistance $G "Inconnue"]
	    if { $RetourG != "Inconnue"} {
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourG [Mini $x $y]]
		} else {
		    set Dis [expr $RetourG+$x+$y]
		}
		AppendEtRetourneDistance $D $Dis
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourG $x]
		} else {
		    set Dis [expr $RetourG+$x]
		}
		return $Dis
	    }
	    set RetourD [AppendEtRetourneDistance $D "Inconnue"]
	    if { $RetourD != "Inconnue"} {
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourD [Mini $x $y]]
		} else {
		    set Dis [expr $RetourD+$y+$x]
		}
		AppendEtRetourneDistance $G $Dis
		if {$MiniOuSomme == "Mini"} {
		    set Dis [Mini $RetourD $y]
		} else {
		    set Dis [expr $RetourD+$y]
		}
		return $Dis
	    }
	    return "Inconnue"
	}  
    } else {
	if {[EstUneFeuille $Arbre]} {
	    lappend ListeDistanceDeChaqueFeuille "[NomDeLaFeuille $Arbre] $Distance"
	    return $Distance
	} else {
	    Dedouble $Arbre G x D y
	    if {$MiniOuSomme == "Mini"} {
		set Dis [Mini $Distance $x]
	    } else {
		set Dis [expr $Distance+$x]
	    }
	    AppendEtRetourneDistance $G $Dis
	    if {$MiniOuSomme == "Mini"} {
		set Dis [Mini $Distance $y]
	    } else {
		set Dis [expr $Distance+$y]
	    }
	    AppendEtRetourneDistance $D $Dis
	}
    }

}

proc AppendFOF {{Rep ""} {NewRep ""} {FichierFOF ""}} {


    Wup "Takes all TFA files from Rep and creates a normalised version with the PS as access"

    if {$FichierFOF==""} {
	set Projet [file tail [RepertoireDuGenome]]
	set FichierFOF "[RepertoireDuGenome]/$Projet.fof"
    }
    if {$Rep==""} { set Rep [ChoixDuRepertoire "[RepertoireDuGenome]/"] }
    if { ! [regexp "^/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    if {$NewRep==""} {
	set NewRep "[file dirname $Rep]/NewTFA"
    }
    if { ! [regexp "^/" $NewRep]} { set NewRep "[RepertoireDuGenome]/$NewRep" }
    if {[FileAbsent $NewRep]} { file mkdir $NewRep }
    Espionne $Rep
    foreach Fichier [lsort [glob -nocomplain "$Rep/*"]] {
	Espionne $Fichier
	set Queue [file tail $Fichier]
	regsub {^[A-Z]+_[^_]+_} $Queue "" PS
	set Entete [EnteteDuFichierTFA $Fichier]
	set Seq    [QueLaSequenceDuFichierTFA $Fichier]
	regsub {>[^ ]+ } $Entete "" DE
	set TFA [SequenceFormatTFA $Seq "$PS $DE" "nucbrut"]
	Espionne $TFA
	set FicTFA "$NewRep/$Queue"
	Sauve $TFA dans $FicTFA
	lappend LeNouveauFOF "$PS $FicTFA"
    }   
    if {[file exists $FichierFOF]} { Garde $FichierFOF }
    AppendAuFichier $FichierFOF [join $LeNouveauFOF "\n"]
    return $FichierFOF

}

proc AppendLaProc {SousProcedure Procedure} {

    global LesSousProcedures

    if {[info procs $SousProcedure]=={}} { return }

    lappend LesSousProcedures($Procedure) $SousProcedure

}

proc AppendPierre {} {

    global CanalPierre NomDuFichierPierre
    if { [info exists CanalPierre] } {
	ClosPierre
    }
    if { ! [info exists NomDuFichierPierre] } {
	set NomDuFichierPierre "pierre"
    }
    set CanalPierre [open $NomDuFichierPierre a]
    return $CanalPierre

}

proc AppendUneDemarcation {K {NomDuFichier ""}} {


    if {$NomDuFichier == ""} {
	set NomDuFichier [ButineArborescence]
    }
    if {$NomDuFichier == ""} { return "" }

    set Y 100
    set Etiquette "NoValue"
    foreach Ligne [LesLignesDuFichier $NomDuFichier] {
	if {[regexp {"#Don't remove this line it marks the end."} $Ligne]} { break }
	if {[regexp {^\#} $Ligne]} { continue }
	if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
	set n [scan $Ligne "%s %s %s" Nom Y Etiq]
	DemarcationEnPosition $K "v" $Nom $Y $Etiq
    }
    return $NomDuFichier

}

proc AppletCmd {w arglist} {

    # puts "AppletCmd: w=$w arglist=$arglist"
    label $w -text "The Applet $w" -bd 2 -relief raised

}

proc AppliqueBackColor {} {

    global TmpDef Defauts

    set Defauts(BackAppli) [set TmpDef(BackAppli)]
    ChangeTkOptions

    foreach e [wm stackorder .] {
	wm withdraw $e
	update idletasks
	wm deiconify $e
    }

    return

    LesDefauts BackAppliOri [set Defauts(BackAppli)]
    LesDefauts BackAppli    [set TmpDef(BackAppli)]
    update
    foreach e [winfo children .] {
	if {[regexp "BWIDGET" [string toupper $e]]} {continue}
	MesCouleurs $e
    }
    update idletasks

    return

}

proc AppliqueCouleurs {type w} {

    global NomNomSeq ListePDB

    if {[QuelMode] eq "seqlab"} {
	global LNSeqlab LSSeqlab

	set LesSeqs $LSSeqlab
	set LesNoms $LNSeqlab
    } else {
	global LNOrdali LSOrdali

	set LesSeqs $LSOrdali
	set LesNoms $LNOrdali
    }

    # configuration tags
    set Lgaa [list STAC DE ILMV FYW P RK Q G HN SPC]
    #    set Lfreg [list "S|T|A|C" "D|E" "I|L|M|V" "F|Y|W" "p" "R|K" "Q" "G" "H|N" "\\\."]
    set Lfreg [list "S|T|A|C" "D|E" "I|L|M|V" "F|Y|W" "P" "R|K" "Q" "G" "H|N"]

    set y 0
    foreach s $LesSeqs n $LesNoms {
	incr y
	if {$n eq ""} {continue}
	if {$n in $ListePDB} {continue}
	foreach a $Lgaa freg $Lfreg {
	    set lt {}
	    set lv [regexp -all -inline -indices -- $freg $s]
	    foreach e $lv {
		lassign $e d f 
		lappend lt $y.$d $y.[expr {$f+1}]
	    }
	    if {$lt != {}} {$w tag add Tag$a {*}$lt}
	}
    }

    update idletasks

    return

}

proc AppliqueFeature {ft} {

    global NomTextSeq NomNomSeq ListeTypesDeFeatures LNOrdali LesNomsDesSeqsOld TabSF ScoreMeth Defauts

    if {! [ModeI]} {return}

    $NomTextSeq configure -state normal

    if {$ft eq "Clear" || $ft eq "None"} {
	set Ltags [$NomTextSeq tag names]
	set ToDelete [lsearch -all -inline -regexp $Ltags "^(FX_|FDisp_)"]
	if {$ToDelete != {}} {
	    $NomTextSeq tag delete {*}$ToDelete
	}

	ResetDesBoutons
	$NomTextSeq configure -state disabled
	MetAJourDessinOverview -1 "" "None" 1
	if {[lsearch -regexp $ListeTypesDeFeatures "Cons-T"] != -1} {
	    EnleveLesPoints
	}

	return
    }
    
    set ftnsp [string map [list " " ""] $ft]

    set Lt [$NomTextSeq tag names]
    set LaFeat [lsearch -regexp -all -inline $Lt "_${ftnsp}_"]
    if {$LaFeat ne ""} {
	set isPresent 1
    } else {
	set isPresent 0
    }

    if {$isPresent} {
	$NomTextSeq tag delete {*}$LaFeat
	$NomTextSeq configure -state disabled
	MetAJourDessinOverview -1 "" $ft 0

	if {[QuelMode] eq "feature" && [regexp "Cons-" $ft]} {
	    setTooltip [BtnDeLaFeature $ft] ""
	}
	if {[regexp "Cons-T" $ft]} {
	    EnleveLesPoints
	}

	return
    }

    if {[regexp {^Cons\-|^Score\-} $ft]} {
	if {[set ScoreMeth($ft,Edit)]} {
	    $NomTextSeq tag configure "EdtFnd_${ftnsp}_1" -background "#ffdddd"
	    $NomTextSeq tag add "EdtFnd_${ftnsp}_1" 1.0 end
	    if {[QuelMode] eq "feature"} {
		setTooltip [BtnDeLaFeature $ft] "Beware ! Conservation is not valid anymore\nas the alignment has changed !"
	    }
	}
    
	if {[regexp "Cons-T" $ft]} {
	    #AfficheLesPoints
	}
	DessineLesScores $ft
    }

    set LFeatUse {}
    array set ToTag {}
    foreach key [array names TabSF "*,$ft"] {
	lassign [split $key ,] nom tmp
	set i [expr {[lsearch $LNOrdali $nom] + 1}]
	
	foreach f [set TabSF($nom,$ft)] {
	    set fcol "black"
	    DecortiqueUneFeature $f dg fg col sco note

	    if {$Defauts(RemovePropagated) && [string range $note 0 4] eq "PROP_"} {
		continue
	    }

	    incr fg
	    set LeTag "FX_${ftnsp}_$col"
	    lappend ToTag($LeTag) $i.$dg $i.$fg

	    if {$LeTag ni $LFeatUse} {
		if {$col eq "black" || $col eq "DimGray"} {
		    set fcol "white"
		}
		$NomTextSeq tag configure $LeTag -foreground $fcol -background $col
		lappend LFeatUse $LeTag
	    }

	    if {$note ne ""} {
		set lanote [string map [list " " "_"] $note]
		$NomTextSeq tag configure "FDisp_$lanote" -foreground black
		lappend ToTag(FDisp_${ftnsp}_$lanote) $i.$dg $i.$fg
	    }
	}
    }
    foreach e [array names ToTag] {
	set Lt [list]
	$NomTextSeq tag add $e {*}$ToTag($e)

	if {0} {
	    lassign [split [lindex $ToTag($e) 0] .] yc xd
	    lassign [split [lindex $ToTag($e) 1] .] yc xf
	    foreach {p1 p2} [lrange $ToTag($e) 2 end] {
		lassign [split $p1 .] y x1
		lassign [split $p2 .] y x2
		
		if {$xf != ($x1+1) || $yc != $y} {
		    lappend Lt $yc.$xd $yc.$xf
		    set xd $x1 
		    set yc $y
		}
		set xf $x2
	    }
	    lappend Lt $yc.$xd $yc.$xf
	    $NomTextSeq tag add $e {*}$Lt
	}
    }
    $NomTextSeq configure -state disabled
    
    MetAJourDessinOverview -1 "" $ft 1

    return

}

proc AppliqueRotation {V R T} {

    set Vt [V_MV $R * $V]
    set NewV [V_VV $Vt + $T]

    return $NewV

}

proc AppliqueSuperposition {} {

    global ListePDB StrucAVoir db

    foreach nmch [lrange $StrucAVoir 1 end] {
	set elt [DonneIdDeAccessPDB $nmch]
	set chn [DonneChainDeAccessPDB $nmch]

	array set TM [$elt GiveVar Rot]
	array set TT [$elt GiveVar Trans]
	set M [M_T TM]
	set T [V_T TT]
	lassign $M aM bM cM
	lassign $T t1 t2 t3

	set pdb $elt
	$db eval {begin transaction}
	set Lr [$db eval {select a.x,a.y,a.z,a.pk_atoms from atoms as a, chains as c, pdb as p where  p.name=$pdb and  c.pk_pdb=p.pk_pdb and  c.name=$chn and  a.pk_chains=c.pk_chains}]
	
	foreach {x y z ix} $Lr {
	    set nx [VMT $x $y $z $aM $t1]
	    set ny [VMT $x $y $z $bM $t2]
	    set nz [VMT $x $y $z $cM $t3]
	    $db eval {update atoms set x=$nx, y=$ny, z=$nz where pk_atoms=$ix}
	}

	$db eval {commit}

	$elt _Dimensions
	$elt ResetDrawing
    }

    return

}

proc AppliqueWidth {AId val} {


    set inc [expr {[set ::Abr($AId,Increment)] + $val}]
    if {$inc < 5} {return}
    set ::Abr($AId,Increment) $inc
    
    OnReDessineArbre $AId
    
    return

}

proc AppliqueZoom {AId val x y} {

    global Abr

    if {$val eq "zplus"} {set val 0.1} {set val -0.1}
    set Abr($AId,ScaleR) [expr {$val+[set Abr($AId,ScaleR)]}]
    if {[set Abr($AId,ScaleR)] < 0.1} {set Abr($AId,ScaleR) 0.1}

    OnReDessineArbre $AId

    return

}

proc ArClade {{Qui ""} {Quoi ""}} {

    global ArClade
    if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
    if {[info exists ArClade("EstCharge")]} {
	if {[info exists ArClade($Qui,OX)]} {
	    set OX $ArClade($Qui,OX)
	    if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
	}
	return ""
    }
    set ArClade("EstCharge") 1
    
    set LesClades [LesLignesDuFichier "/genomics/link/OI/fiches/PhylAr_ListOf_PhyOS.txt"]
    set LesClades [OrderedClades $LesClades]

    foreach Name $LesClades {
	set OX [Tax $Name TaxId]
	if {$OX==""} {
	    #FaireLire "$Name has no TaxId. I'll use Archaea instead"
	    set Name "Archaea"
	    set OX [Tax $Name TaxId]
	}
	set ArClade($Name,Name) $Name
	set ArClade($OX,OX)     $OX
	set ArClade($Name,OX)   $OX
	set ArClade($OX,Name)   $Name
	lappend ArClade(ListOf,OX)   $OX
	lappend ArClade(ListOf,Name) $Name
    }
    
    set ArClade(ListOf,AllOX)   $ArClade(ListOf,OX)
    set ArClade(ListOf,AllName) $ArClade(ListOf,Name)
    foreach Name [list Bacteria Eukaryota Viruses] {
	set OX   [Tax $Name TaxId]
	if {$Name=="root"} { set Name "Other" }
	lappend ArClade(ListOf,AllOX)   $OX
	lappend ArClade(ListOf,AllName) $Name
    }

    return [ArClade $Qui $Quoi] 

}

proc ArCladeOLD {{Qui ""} {Quoi ""}} {

    global ArClade
    if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
    if {[info exists ArClade("EstCharge")]} {
	if {[info exists ArClade($Qui,OX)]} {
	    set OX $ArClade($Qui,OX)
	    if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
	}
	return ""
    }
    set ArClade("EstCharge") 1
    
    set Fichier "/home/ripp/vrac/ArClade.txt"
    set ArClade(Filename,) $Fichier
    
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Name [string trim $Ligne " \t"]
	if {$Name==""} { continue }
	regsub -all " " $Name "_" Name
	set OX [Tax $Name TaxId]
	if {$OX==""} {
	    #FaireLire "$Name has no TaxId. I'll use Archaea instead"
	    set Name "Archaea"
	    set OX [Tax $Name TaxId]
	}
	set ArClade($Name,Name) $Name
	set ArClade($OX,OX)     $OX
	set ArClade($Name,OX)   $OX
	set ArClade($OX,Name)   $Name
	lappend ArClade(ListOf,OX)   $OX
	lappend ArClade(ListOf,Name) $Name
    }
    set ArClade(ListOf,OX)   [lsort -unique $ArClade(ListOf,OX)]
    set ArClade(ListOf,Name) [lsort -unique $ArClade(ListOf,Name)]
    foreach A $ArClade(ListOf,OX) {
	foreach B $ArClade(ListOf,OX) {
	    if {$A==$B} { continue }
	    if {[JeSuisTonAncetre $A $B]} { set ArClade($A,AncestorOf_$B) 1 }
	}
    }
    
    set ArClade(ListOf,OrderedOX) [lsort -command CompareArCladeAncestor $ArClade(ListOf,OX)]
    foreach OX $ArClade(ListOf,OrderedOX) {
	lappend ArClade(ListOf,OrderedName) $ArClade($OX,Name)
    }
    #parray ArClade 

    foreach D [list Bacteria Eukaryota Virus] {
	set N [Tax $D Name]
	if {$N=="root"} { set N "Other" }
	lappend ArClade(ListOf,OrderedOX)   $D
	lappend ArClade(ListOf,OrderedName) $N
    }

    return [ArClade $Qui $Quoi] 

}

proc ArCladeOf {{Qui ""} {Quoi ""}} {

    global ArCladeOf

    if {$Quoi=="Clade"} { set Quoi "Name" }

    if {[regexp -nocase "taxid" $Quoi]} { set Quoi "OX" }

    if {$Quoi=="" &&    [regexp {^[0-9]+$} $Qui]} { set Quoi "OX" }
    if {$Quoi=="" &&  ! [regexp {^[0-9]+$} $Qui]} { set Quoi "Name" }

    if {[info exists ArCladeOf($Qui,Quoi)]} { return $ArCladeOf($Qui,$Quoi) }
    set OX [Tax $Qui TaxId]
    set OS [Tax $Qui Name]
    
    foreach CX [ArClade ListOf OrderedOX] CS [ArClade ListOf OrderedName] {
	if {[JeSuisTonAncetre $CX $OX]} {
	    set ArCladeOf($OX,OX) $CX
	    set ArCladeOf($OS,OX) $CX
	    set ArCladeOf($OX,Name) $CS
	    set ArCladeOf($OS,Name) $CS
	    if {[info exists ArCladeOf($OX,$Quoi)]} { return $ArCladeOf($OX,$Quoi) }
	}
    }
    return ""

}

proc Arboot {} {

    global TokCourant
    if { ! [regexp {^\(} $TokCourant]} {
	set FeuilleDist [FeuilleDist]
	if {[regexp "NonValide" $FeuilleDist]} { return "ArbootNonValideCar$FeuilleDist" }
	return $FeuilleDist
    }
    Tok
    set Gauche [Arboot]
    if {[regexp "NonValide" $Gauche]} { return "ArbootNonValideCar$Gauche" }
    if { ! [regexp {\,} $TokCourant]} { return "ArbootNonValideCarSansVirgule" }
    Tok
    set Droite [Arboot]
    if {[regexp "NonValide" $Droite]} { return "ArbootNonValideCar$Droite" }
    if { ! [regexp {\)} $TokCourant]} { return "ArbootNonValideCarSansFermante" }
    Tok
    set ValeurDist [ValeurDist]
    if {[regexp "NonValide" $ValeurDist]} { return "ArbootNonValideCar$ValeurDist" }
    if {[regexp {^\[} $TokCourant]} {
	set ValeurBoot [ValeurBoot]
	if {[regexp "NonValide" $ValeurBoot]} { return "ArbootNonValideCar$ValeurBoot" }
    } else {
	set ValeurBoot 0
    }
    return [list $Gauche $Droite $ValeurDist $ValeurBoot]

}

proc ArbreAgent {iSeq} {

    global Larbres TAg T DoTour LNOrdali DoTour

    if {$DoTour} {
	return
    }

    set n [lindex $LNOrdali $iSeq]
    if {($iSeq + 1) == [llength $LNOrdali]} {
	set iSeq -1
	set DoTour 1
    }

    # cherche dans seq suivante
    incr iSeq
    set nf [lindex $LNOrdali $iSeq]

    if {$DoTour} {
	foreach agn $TAg($n) {
	    lappend Larbres [list $n $agn]
	}
	return $Larbres
    }

    foreach agn $TAg($n) {
	#set Lp [LiensAgent $n $agn $nf]
	set Lp [lsearch -all -exact -inline -index 0 $T($n,$agn) $nf]
	set Ltmp [list]
	foreach arbre [ArbreAgent $iSeq] {
	    foreach l $Lp {
		lassign $l n2 ag2 sc2
		lappend Ltmp [concat $arbre $n2 $ag2]
	    }
	}
	#lappend Larbres {*}$Ltmp
	set Larbres $Ltmp
    }

    #ArbreAgent $iSeq

    return $Larbres

}

proc ArbreBootstrapEnListe {TextePH} {

    regsub -all "\n" $TextePH "" t
    regsub -all {\:[0-9]\.[0-9]*} $t ":" t
    regsub -all {[\]\[]} $t "" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":,"  $t ":" t
    regsub -all {:\)}  $t ":" t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    exit
    eval set Arbre $t
    if {[llength $Arbre] == 4} {
	set Arbre [list  [list [lindex $Arbre 0] [lindex $Arbre 1] [lindex $Arbre 3]]  [lindex $Arbre 2]  [lindex $Arbre 3]]
    }
    return $Arbre 

}

proc ArbreBootstrapEnListeOld {TextePH} {

    regsub -all "\n" $TextePH "" t
    regsub -all {[0-9]\.[0-9]*} $t "" t
    regsub -all {[\]]} $t "" t
    regsub -all {[\[]} $t "" t
    regsub -all {\:\)} $t ":9999.\)" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    eval set Arbre $t
    if {[llength $Arbre] == 6} {
	set Arbre [list [lrange $Arbre 0 3] 0.0 [lindex $Arbre 4] [lindex $Arbre 5]]
    }
    return $Arbre 

}

proc ArbreDesClasses {} {

    Degrave T
    NicePrintOfTree $T
    exit
    if {[]} {}

}

proc ArbreEnListe {TextePH} {

    regsub -all "\n" $TextePH "" t
    regsub -all {\(} $t {[list } t
    regsub -all ","  $t " " t
    regsub -all ":"  $t " " t
    regsub -all {\)} $t {]} t
    regsub -all {;}  $t "" t
    eval set Arbre $t
    if {[llength $Arbre] == 6} {
	set Arbre [list [lrange $Arbre 0 3] 0.0 [lindex $Arbre 4] [lindex $Arbre 5]]
    }
    return $Arbre 

}

proc ArcInit {} {

    global StrucAVoir gDemo

    LoadTkAndPackages

    rename EnvoieLesObjets Envoie_wait
    rename Cubes EnvoieLesObjets

    set StrucAVoir [list]
    Initialisation

    # Font to be used in the Tk listbox.
    set gDemo(listFont) {-family {Courier} -size 18 -weight bold}
    
    # Display mode.
    set gDemo(fullScreen) false
    
    # Window size.
    set gDemo(winWidth)  640
    set gDemo(winHeight) 480

    set ::ArcBall   [tcl3dNewArcBall 640 480]
    set ::Transform [tcl3dVector GLfloat 16]
    set ::ThisRot   [tcl3dVector GLfloat 16]
    set ::LastRot   [tcl3dVector GLfloat 16]
    set ::ThisQuat  [tcl3dVector GLfloat  4]
    update

    ArcStart
    
    .top.fr.toglwin postredisplay

    return

}

proc ArcLaListe {ListeNomCouleur R Type {MilieuOuAngle milieu} {RayonMinimum ""} {RayonMaximum ""}} {

    Wup "Creates the arcs associated to each element of the list"
    global ParametresDuBoard

    Wup "Pour les fleches a l'envers c'est code 'Reverse\NomOuAngle' "

    set PI 3.14159

    set DeltaAnglePourFlecheDeg 1.5
    set DeltaAnglePourFlecheRad [expr $DeltaAnglePourFlecheDeg*$PI/180.]

    set CentreX [set ParametresDuBoard($R,CentreX)]
    set CentreY [set ParametresDuBoard($R,CentreY)]
    set RayonMoyen     [set ParametresDuBoard($R,RayonMoyen)]
    set OffsetRayonMin [set ParametresDuBoard($R,OffsetRayonMin)]
    set OffsetRayonMax [set ParametresDuBoard($R,OffsetRayonMax)]
    set IemeCouche     [set ParametresDuBoard($R,IemeCouche)]
    
    set Rayon  $RayonMinimum
    set Gauche [expr $CentreX-$Rayon]
    set Haut   [expr $CentreY-$Rayon]
    set Droite [expr $CentreX+$Rayon]
    set Bas    [expr $CentreY+$Rayon]

    set InRayon  [expr $Rayon*(1-0.9*$DeltaAnglePourFlecheRad)]
    set OutRayon [expr $Rayon*(1+0.9*$DeltaAnglePourFlecheRad)]

    set n [llength $ListeNomCouleur]

    set CumulF 0
    set CumulR 0
    set OldCouleur "CACADOIE"
    foreach {NomOuAngle Couleur} [concat $ListeNomCouleur [list "NomBidon" "CouleurPourFin"]] {
	if {[regexp {^Reverse_} $NomOuAngle]} {
	    set Orientation "R"
	    incr CumulR
	} else {
	    set Orientation "F"
	    incr CumulF
	}
	regsub {^Reverse_} $NomOuAngle "" NomOuAngle
	set Etiquette " "
	if {$Couleur != $OldCouleur && $OldCouleur != "CACADOIE"} {
	    if {$OldCouleur=="VIDE"} { set NonVide 0 } else { set NonVide 1 }
	    set i_ [string first "_" $OldCouleur]
	    if {$i_ < 0} {
		set VraieCouleur $OldCouleur
	    } else {
		set Etiquette [string range $OldCouleur [incr i_ 1] end] 
		set VraieCouleur [string range $OldCouleur 0 [incr i_ -2]]
	    } 
	    if {$CumulF>=$CumulR} {
		set Orientation "F"
		set NewStart [expr $Start+$DeltaAnglePourFlecheRad]
		set Queue    $NewStart
		set Pointe   $Start
	    } else {
		set Orientation "R"
		set NewStart $Start
		set Pointe [expr $Start+$Extent]
		set Queue  [expr $Pointe-$DeltaAnglePourFlecheRad] 
	    }
	    set NewExtent [expr $Extent-$DeltaAnglePourFlecheRad]

	    set Repeche 0
	    if {$Etiquette=="B" && [expr abs($Extent) < 2*$PI*5000./[LongueurADN]]} {
		set Repeche 1
	    }
	    set Noye 0
	    if {$Etiquette=="D5" && [expr abs($Extent) < 2*$PI*30000./[LongueurADN]]} {
		set Noye 1
	    }
	    Espionne "$Etiquette [expr $Extent*[LongueurADN]/(2*$PI)] $Repeche $Noye"
	    if {$Repeche || (! $Noye && $NonVide && [expr abs($Extent) > 2*$PI*19000./[LongueurADN]])} {
		set IdArc [$R create arc $Gauche $Haut $Droite $Bas -width 7  -start [expr $NewStart*180/$PI] -extent [expr $NewExtent*180/$PI]  -style "arc" -outline $VraieCouleur -tags "Zone"]
		set InQueueX  [expr ($Gauche+$Droite)/2  +  $InRayon*cos($Queue)]
		set InQueueY  [expr ($Haut+$Bas)/2       -  $InRayon*sin($Queue)]
		set OutQueueX [expr ($Gauche+$Droite)/2  + $OutRayon*cos($Queue)]
		set OutQueueY [expr ($Haut+$Bas)/2       - $OutRayon*sin($Queue)]
		set PointeX   [expr ($Gauche+$Droite)/2  +    $Rayon*cos($Pointe)]
		set PointeY   [expr ($Haut+$Bas)/2       -    $Rayon*sin($Pointe)]
		if { 0 } {
		    $R create polygon  $PointeX $PointeY  $InQueueX $InQueueY  $OutQueueX $OutQueueY  $PointeX $PointeY  -fill $VraieCouleur -outline $VraieCouleur -tags "Fleche"
		} else {
		    FlecheSurArc $R $IdArc $Orientation 
		}
		set EtiqX [expr ($Gauche+$Droite)/2  + 1.00*$OutRayon*cos($Start+$Extent/2)]
		set EtiqY [expr ($Haut+$Bas)/2       - 1.00*$OutRayon*sin($Start+$Extent/2)]
		$R create text $EtiqX $EtiqY -text $Etiquette  -anchor c  -font {Courier 10}  -tags "Etiquette"
	    }
	    unset Start
	    set CumulF 0
	    set CumulR 0
	}
	if {$Couleur == "CouleurPourFin"} { break }
	if {$MilieuOuAngle == "angle"} {
	    set Angle $NomOuAngle
	} elseif {$MilieuOuAngle == "milieu"} {
	    set Angle [AngleDansRosace $R $Nom]
	}
	if { ! [info exist Start]} { set Start $Angle }
	set Extent [EntreMinEtMax [expr $Angle-$Start] [expr -$PI] $PI]
	set OldCouleur $Couleur
    }

}

proc ArcStart {} {

    CreateWindow
    ResetRotations
    
    PrintInfo [format "Running on %s with a %s (OpenGL %s, Tcl %s)"  $::tcl_platform(os) [glGetString GL_RENDERER]  [glGetString GL_VERSION] [info patchlevel]]
    
    return

}

proc ArchaeaGenomesDeClaudine {{GetWhat ""}} {

    OiDomain A

    foreach OS [OiCode ListOf OS] {
	scan $OS "%s %s" Ge Es
	set GeEs "$Ge$Es"
	set OX [OiCode $OS OX]
#Espionne "$OX $GeEs \t\t$OS"
	lappend LesOXde($GeEs) $OX
    }

    set LesGS {}
    set Rates 0
    set LesMemes {}
    set LesCommeSoeur {}
    set LesRates {}
    set LesClaudine {}
    set NbAvecSoeur 0
    foreach G [ClaudineArchaea ListOf G] {
	set GX [ClaudineArchaea $G OX]
	set GS [ClaudineArchaea $G "Organism_Name"]
	set OS [OiCode $GX OS]
	set Clade [ArCladeOf $GX Name]
	lappend LesClaudine [format "%s %9d %-50s %s %s %s" $G $GX $GS Clade = $Clade]
	if {$OS!=""} {
	    set Meme($GX) 1
	    lappend LesMemes [format "%-9s %9d %-50s %-80s %s" $G $GX $GS $OS Clade = $Clade]
	    continue
	}
	set LesParents [list $GX]
	set PX $GX
	while {$OS==""} {
	    set PX [QuestionDeScience EVImm "ret Tax $PX Parent"]
	    if {$PX=="" || $PX==1} { break } 
	    lappend LesParents $PX
	    set OS [OiCode $PX OS]
	    if {$OS!=""} {  Espionne "$LesParents $OS" }
	}
	set LesSoeurs {}
	set PX [QuestionDeScience EVImm "ret Tax $GX Parent"]
	if {$PX!="" && $PX!=1} {
	    foreach OXSoeur [QuestionDeScience EVImm "ret Tax $PX Children"] {
		set OS [OiCode $OXSoeur OS]
		if {$OS!=""} {
		    lappend LesSoeurs "$OS OX = $OXSoeur"
		    set YaSoeur($OXSoeur) 1
		}
	    }
	    if {$LesSoeurs!={}} {
		incr NbAvecSoeur
		lappend LesCommeSoeur ""
		lappend LesCommeSoeur "$G $GX $Clade"
		lappend LesCommeSoeur $GS
		foreach Soeur $LesSoeurs {
		    lappend LesCommeSoeur $Soeur
		}
	    }
	    if {$LesSoeurs!={}} { continue }
	}
	lappend LesRates [format "%9s %9d %-40s %s %s %s" $G $GX $GS Clade = $Clade]
    }

    foreach OX [OiCode ListOf OX] {
	if {[info exists Meme($OX)]} {
	    lappend LesMemeQueYannis $OX
	    continue
	}
	lappend LesNouveauxDeYannis "$OX [OiCode $OX OS]"
    }

    set LesNouveauxDeYannis [lsort -index 1 $LesNouveauxDeYannis]

#    return [AfficheListe $LesClaudine   "" "Ceux de Claudine"]

    Espionne "[llength $LesClaudine] de Claudine"
    Espionne "[llength $LesMemes] Memes"
    Espionne "$NbAvecSoeur AvecSoeur"
    Espionne "[llength $LesRates] Rates"
    
    Espionne "[llength [OiCode ListOf OX]] de Yannis"
    Espionne "[llength $LesNouveauxDeYannis] Nouveaux chez Yannis"
    set LesFenetres {}
    lappend LesFenetres [AfficheListe $LesClaudine   "" "Ceux de Claudine"]
    lappend LesFenetres [AfficheListe $LesMemes      "" "LesMemes"]
#    lappend LesFenetres [AfficheListe $LesCommeSoeur "" "LesSoeurs"]
    lappend LesFenetres [AfficheListe $LesRates      "" "LesRates"] 
    lappend LesFenetres [AfficheListe $LesNouveauxDeYannis  "" "LesNouveauxDeYannis"] 
    lappend LesFenetres [AfficheListe [OiCode ListOf Info] "" "Ceux de Yannis"]

    return $LesFenetres

}

proc ArchiveBatch {{batchName ""} {batchDate ""}} {

    # Connect to database
    #canalSqlAssemblyDb
    NSAssemblyDb::getCanal

    # Retrieve pk and names of contigs in batch
    set sql "SELECT c.pk_contig, s.name FROM assembly AS a, contig AS c, sequence AS s WHERE a.pk_assembly = c.pk_assembly AND c.consensus_pk_sequence = s.pk_sequence AND a.name = '$batchName' AND a.date = '$batchDate'"
    set pkContigs [SqlExec $sql GetList]
    if {[llength $pkContigs] < 1} {
	puts "Batch $batchName ($batchDate) does not exists"
	exit 1
    }

    # BEGIN THE TRANSACTION
    SqlExec "BEGIN"

    foreach {pkC nameC} $pkContigs {
	puts "Archiving $nameC"

	# Retrieve read names in contig pkC
	set readNames [SqlExec "SELECT name FROM sequence WHERE pk_contig = $pkC" GetList]
	if {[llength $readNames] < 1} {
	    puts "ERROR: no reads in $nameC"
	    exit 1
	}

	# Insert read names into history table
	foreach rN $readNames {
	    SqlExecWithStatus "INSERT INTO history(pk_contig, read_name) VALUES($pkC, '$rN')"
	}

	# Remove reads of table sequence
	SqlExecWithStatus "DELETE FROM sequence WHERE pk_contig = $pkC"

    }
    
    # Mark the batch as archived
    SqlExecWithStatus "UPDATE assembly SET archived = true WHERE name = '$batchName' AND date = '$batchDate'"
    
    # FINISH THE TRANSACTION
    SqlExec "COMMIT"

    # Disconnect
    CanalSqlDisconnect

}

proc AretesDuCube {a1 b1 c1 d1 a2 b2 c2 d2} {


    # Face haut
    glBegin GL_LINES
    glVertex3fv $a1
    glVertex3fv $b1
    glEnd

    glBegin GL_LINES
    glVertex3fv $b1
    glVertex3fv $c1
    glEnd

    glBegin GL_LINES
    glVertex3fv $c1
    glVertex3fv $d1
    glEnd

    glBegin GL_LINES
    glVertex3fv $d1
    glVertex3fv $a1
    glEnd

    # face bas
    glBegin GL_LINES
    glVertex3fv $a2
    glVertex3fv $b2
    glEnd

    glBegin GL_LINES
    glVertex3fv $b2
    glVertex3fv $c2
    glEnd

    glBegin GL_LINES
    glVertex3fv $c2
    glVertex3fv $d2
    glEnd

    glBegin GL_LINES
    glVertex3fv $d2
    glVertex3fv $a2
    glEnd

    # Poteaux
    glBegin GL_LINES
    glVertex3fv $a1
    glVertex3fv $a2
    glEnd

    glBegin GL_LINES
    glVertex3fv $b1
    glVertex3fv $b2
    glEnd

    glBegin GL_LINES
    glVertex3fv $c1
    glVertex3fv $c2
    glEnd

    glBegin GL_LINES
    glVertex3fv $d1
    glVertex3fv $d2
    glEnd

    return

}

proc ArkaeaLike {Orga} {

    if {[PyroLike $Orga] ||  [regexp "mjan|aful|mthe|aper|ssol|saci|mvan|hsal|hvol|hcut|hhal|damb|dmob|dthe|dsp" $Orga]} {
	return 1
    }
    return 0

}

proc ArrayFromSerial {Texte aT} {

    upvar $aT T
    return [ArrayFromSeriallist [SeriallistFromSerial $Texte] T]

}

proc ArrayFromSeriallist {Liste aT} {

    upvar $aT T
    foreach {K V} [lindex $Liste 1] {
	set T([ValueFromSeriallist $K]) [ValueFromSeriallist $V]
    }
    return $aT

}

proc ArrayRecap {PourCas} {

    set LongPourCas [llength $PourCas]
   Espionne "LongPourCas= $LongPourCas"
    set somme 0
    foreach elmt $PourCas {
	set somme [expr $somme+$elmt] 
	if {[info exists DejaVu($elmt)]} {
	    incr DejaVu($elmt)
	    continue
	}
	set DejaVu($elmt) 1
    }
   Espionne "somme= $somme"
    set MoyPourCas [expr $somme/$LongPourCas]
   Espionne "MoyPourCas= $MoyPourCas"
    set grand 0; set petit 100
    set Resultat [array get DejaVu]
    foreach Cle [array names DejaVu] {
	if {$Cle>$grand} {set grand $Cle}
	if {$Cle<$petit} {set petit $Cle}
    }
    return "$grand $petit\n$Resultat"

}

proc ArraytypeEnAttente {} {

    set name "Ret13K"
    set type "spotted DNA/cDNA"
    set manufacturer "Cepko lab"
    set probesetcount "12243 mouse clones"
    set description "The Ret13K microarray includes 12,243 mouse clones including BMAP mouse retinal clones and 220 clones from the Incyte mouse unigene 1 collection. The cDNA inserts were amplified from replica plate cultures by PCR, purified and mechanically spotted onto polylysine-coated microscope slides using an OmniGrid robotic spotter (GeneMachines, San Carlo, CA)."
    set url "NA"
    set Ligne "$name;$type;$manufacturer;$probesetcount;$description;$url"
    lappend LesLignes $Ligne
    if {[ArraytypeWithPipeWork]} {
	CreateArray InitValues 1 "New" "0" $name $type $manufacturer $probesetcount $description $url
	set Serial [PhpSerialize InitValues "i"]
	Espionne $Serial
	lappend LesCreations [WebService "Gx" FromPipeWork "pipeworkname" "GXManageArraytype" "serialinitvalues" $Serial]
    }

}

proc ArraytypeInput {{LesFichiers ""}} {

    if { ! [WithWebService "Gx" "TestIfExists"]} { WithWebService "Gx" 1 }

    if {$LesFichiers==""              } { set LesFichiers [LesAffyAnnot] }
    if {$LesFichiers=="DansLeBonOrdre"} { set LesFichiers [LesAffyAnnotDansLeBonOrdre] }

    set LesCreations {}
    foreach File $LesFichiers {
	set Queue [file tail $File]
	set Chip [string range $Queue 0 [expr [string first "." $Queue] -1]]
	LConcat LesCreations [ChargeArraytype $Chip]
	foreach MultiChip [MesMultiChip $Chip] {
	    if {[info exists DejaVu($MultiChip)]} { continue }
	    set DejaVu($MultiChip) 1
	    LConcat LesCreations [ChargeArraytype $MultiChip]
	}
    }
    return $LesCreations

}

proc ArraytypeWithPipeWork {{Qui ""} {Valeur ""}} {

    global ArraytypeWithPipeWork

    if {$Qui==""} { set Qui "Gx" }

    if {$Valeur!=""} { set ArraytypeWithPipeWork($Qui) $Valeur}
    if {[info exists ArraytypeWithPipeWork($Qui)]} { return $ArraytypeWithPipeWork($Qui) }
    set ArraytypeWithPipeWork($Qui) 1
    return [ArraytypeWithPipeWork $Qui]

}

proc AsciiToInteger {A} {

    set I -1
    scan $A "%c" I
    return $I

}

proc AskAddSeqs {} {

    global TAddS LNDG

    set TAddS(File)      ""
    set TAddS(Align)     1
    set TAddS(CopySkip)  0
    set TAddS(Position)  "end"
    set TAddS(seqInsert) ""
    if {[llength $LNDG] > 1} {
	set TAddS(KeepClus) 1
    } else {
	set TAddS(KeepClus) 0
    }

    set TAddS(File) "add_jaris.tfa"
    set TAddS(Position) "end"
    set TAddS(seqInsert) "Q5ZAV6"
    set TAddS(Align) 1

    set res [array get TAddS]
    if {[ModeI]} {
	set res [AfficheAskAddSeq $res]
    }
    # if result is empty then leave AddSeq

    return $res

}

proc AskAnchors {args} {

    #unset
    #$FileAnchors IdDeRef
    #$FileAnchors LesId
    #$FileAnchors Id $Id NbLMS
    #$FileAnchors Id $Id LMS $n Pos
    #$FileAnchors Id $Id LMS $n Beg
    #$FileAnchors Id $Id LMS $n End
    #$FileAnchors Id $Id LMS $n Len

    global TabDesAnchorsDeBallast

    if {$args == ""} {return}
    set PremArg [lindex $args 0]
    if {[string equal -nocase $PremArg "unset"]} {
	if {[info exists TabDesAnchorsDeBallast ]} {unset TabDesAnchorsDeBallast}
	return
    }
    if {![file exists $PremArg]} {return}
    set Quoi [join $args ","]

    if {[info exists TabDesAnchorsDeBallast($Quoi)]} {return [set TabDesAnchorsDeBallast($Quoi)]}
    if {[info exists TabDesAnchorsDeBallast($PremArg,EstCharge)]} {return}
    
    set         TabDesAnchorsDeBallast($PremArg,EstCharge) 1
    LoadAnchors TabDesAnchorsDeBallast $PremArg

    if {[info exists TabDesAnchorsDeBallast($Quoi)]} {return [set TabDesAnchorsDeBallast($Quoi)]}
    return

}

proc AskBlast {args} {

    #$FileBlast Exists
    #unset 
    #unsetfile  $FileBlast
    #$FileBlast TypeDeBlast
    #$FileBlast Database
    #$FileBlast Query
    #$FileBlast Taille 

    #$FileBlast NbSubject

    #$FileBlast Subject $nSubject
    #$FileBlast BanqueId $BId Access
    #$FileBlast BanqueId $BId Definition
    #$FileBlast BanqueId $BId Taille
    #$FileBlast BanqueId $BId SubjectBrut

    #$FileBlast BanqueId $BId NbSegment
    #$FileBlast BanqueId $BId Segment $nSegment AlignBrut
    #$FileBlast BanqueId $BId Segment $nSegment Score
    #$FileBlast BanqueId $BId Segment $nSegment Expect
    #$FileBlast BanqueId $BId Segment $nSegment Identities
    #$FileBlast BanqueId $BId Segment $nSegment Positives
    #$FileBlast BanqueId $BId Segment $nSegment Gaps
    #$FileBlast BanqueId $BId Segment $nSegment Orientation
    #$FileBlast BanqueId $BId Segment $nSegment Align
    #$FileBlast BanqueId $BId Segment $nSegment AlignLineaire
    #$FileBlast BanqueId $BId Segment $nSegment AlignBrut
    #$FileBlast BanqueId $BId Segment $nSegment DQ
    #$FileBlast BanqueId $BId Segment $nSegment FQ
    #$FileBlast BanqueId $BId Segment $nSegment DS
    #$FileBlast BanqueId $BId Segment $nSegment FS

    global TableauContennantLesInformationsDuBlast

    if {$args == ""} {return}
    if {[string equal -nocase [lindex $args 0] "unset"]} {
	if {[info exists TableauContennantLesInformationsDuBlast]} {unset TableauContennantLesInformationsDuBlast}
	return
    }

    if {[string equal -nocase [lindex $args 0] "unsetfile"]} {
	set File [lindex $args 1]
	if {$File == "" || ![file exists $File] || ![info exists TableauContennantLesInformationsDuBlast]} {return}
	array unset TableauContennantLesInformationsDuBlast "$File*" 
	if {0} {
	    foreach Index [array name TableauContennantLesInformationsDuBlast] {
		if {![regexp "^$File" $Index]} {continue}
		unset TableauContennantLesInformationsDuBlast($Index)
	    }
	}
	return
    }

    set FileBlast [lindex $args 0]
    if {![file exists $FileBlast]} {return}

    set Quoi [join $args ","]

    if {[info exists TableauContennantLesInformationsDuBlast($Quoi)]} {return [set TableauContennantLesInformationsDuBlast($Quoi)]}
    if {[info exists TableauContennantLesInformationsDuBlast($FileBlast,Exists)]} {return}
    set              TableauContennantLesInformationsDuBlast($FileBlast,Exists) 1

    LoadBlast TableauContennantLesInformationsDuBlast $FileBlast
    if {[info exists TableauContennantLesInformationsDuBlast($Quoi)]} {return [set TableauContennantLesInformationsDuBlast($Quoi)]}
    return

}

proc AskBlastMoi {} {

    DecortiqueBlast $Fichier "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN

}

proc AskClust_Gretta {args} {

    global TabClust_Gretta
    ####PROCEDURE HYPER SPECIFIQUE DE GRETTA####

    set QUOI [join $args ","]

    if {[info exists TabClust_Gretta($QUOI) ]} {return [set TabClust_Gretta($QUOI)]}
    if {[info exists TabClust_Gretta(Loaded)]} {return}
    set TabClust_Gretta(Loaded) 1

    set NbCluster 6 

    set FichierOCADE  "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"
    set FichierSel    "[RepertoireDuGenome]/Data/20040910_SelectionDesBoites.txt"

    set TabClust_Gretta(LesClusters) {}
    set TabClust_Gretta(LesAffy)     {}
    set TabClust_Gretta(LesNoms)     {}

    set F [open $FichierSel]
    set i 0
    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == ""} {continue}
	set Ligne   [split $Ligne "\t"]

	set Affy    [lindex $Ligne 0]
	set Cluster [lindex $Ligne 1]

	if {![info exists TabClust_Gretta(Cluster,$Cluster,LesAffy)]} {
	    set TabClust_Gretta(Cluster,$Cluster,LesAffy) {}
	    set TabClust_Gretta(Cluster,$Cluster,LesNoms) {}
	    lappend TabClust_Gretta(LesClusters) $Cluster
	}

	if {![info exists TabClust_Gretta(Affy,$Affy,LesClusters)]} {
	    set TabClust_Gretta(Affy,$Affy,LesClusters) {}
	    lappend TabClust_Gretta(LesAffy) $Affy
	}
	lappend TabClust_Gretta(Affy,$Affy,LesClusters) $Cluster

	incr i
	set TabAffy($Cluster,$Affy) 1
    }
    close $F

    foreach Nom            [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	set Affy           [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access]
	set LesExpressions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions]

	for {set i 0} {$i < $NbCluster} {incr i} {
	    set Cluster [expr $i + 1]
	    set Expr [lindex $LesExpressions $i]
	    if {$Expr < 0} {continue}
	    if {![info exists TabAffy($Cluster,$Affy)]} {continue}

	    if {![info exists TabClust_Gretta(Nom,$Nom,LesClusters)]} {
		set     TabClust_Gretta(Nom,$Nom,LesClusters) {}
		lappend TabClust_Gretta(LesNoms)              $Nom
	    }

	    lappend TabClust_Gretta(Nom,$Nom,LesClusters)     $Cluster
	    lappend TabClust_Gretta(Cluster,$Cluster,LesNoms) $Nom
	}
    }

    if { [info exists TabClust_Gretta($QUOI) ]} {return [set TabClust_Gretta($QUOI)]}
    return

}

proc AskCorrespondances {args} {

    ### Interroge le fichier de correspondances ###
    global TableauCorrespondances

    #unset
    #FileCorrespondances NbGscopeBox 
    #FileCorrespondances LesClusters
    #FileCorrespondances GscopeBox $GscopeBox
    #...
    #a completer
    #

    set FirstArg [lindex $args 0]
    if {$FirstArg == "unset"} {
	if {[info exists TableauCorrespondances]} {unset TableauCorrespondances}
	return
    } 
    set Quoi [join $args ","]
    if {[info exists TableauCorrespondances($Quoi)]} { return [set TableauCorrespondances($Quoi)]}
    if {![file exists $FirstArg]} { return }
    if {[info exists TableauCorrespondances($FirstArg,EstCharge)]} { return }
    
    set TableauCorrespondences($FirstArg,EstCharge) 1
    LoadCorrespondances TableauCorrespondances $FirstArg

    if {[info exists TableauCorrespondances($Quoi)]} { return [set TableauCorrespondances($Quoi)]}
    return

}

proc AskDBTSS {args} {

    ### Interroge la banque DBTSS ###
    global TableauDBTSS
        
    #unset
    #LesId
    #$Id      Organism
    #$Id      SeqTFA
    #$IdCourt Organism
    #$IdCourt SeqTFA

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unset"} {
	if {[info exists TableauDBTSS]} {unset TableauDBTSS}
	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauDBTSS($Quoi)    ]} { return [set TableauDBTSS($Quoi)]}

    if {[info exists TableauDBTSS(EstCharge)]} { return }
    
    set TableauDBTSS(EstCharge) 1
    LoadDBTSS TableauDBTSS

    if {[info exists TableauDBTSS($Quoi)]} { return [set TableauDBTSS($Quoi)]}
    return

}

proc AskEPDIdOrga {args} {

    ### Interroge le fichier EPDIdOrga ###
    global TableauEPDIdOrga
        
    #unset
    #LesEPDIds
    #LesEPDOrgas
    #LesEPDOrganisms
    #LesEPDOrganismsLongs
    #EPDOrga      $EPDOrga      LesEPDIds
    #EPDId        $EPDId        EPDOrga
    #EPDId        $EPDId        EPDOrganism
    #EPDId        $EPDId        EPDOrganismLong

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unset"} {
	if {[info exists TableauEPDIdOrga]} {unset TableauEPDIdOrga}
	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauEPDIdOrga($Quoi)]}     { return [set TableauEPDIdOrga($Quoi)]}

    if {[info exists TableauEPDIdOrga(EstCharge)]} { return }
    
    set TableauEPDIdOrga(EstCharge) 1
    LoadEPDIdOrga TableauEPDIdOrga

    if {[info exists TableauEPDIdOrga($Quoi)]}     { return [set TableauEPDIdOrga($Quoi)]}
    return

}

proc AskEPDOrgas {args} {

    ### Interroge le fichier EPDOrgas ###
    global TableauEPDOrgas
        
    #unset
    #LesEPDOrgas
    #LesEPDOrganisms
    #LesEPDOrganismsLongs
    #EPDOrga      $EPDOrga      EPDOrganism
    #EPDOrga      $EPDOrga      EPDOrganismLong
    #EPDOrganism  $EPDOrganism  EPDOrganismLong

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unset"} {
	if {[info exists TableauEPDOrgas]} {unset TableauEPDOrgas}
	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauEPDOrgas($Quoi)]} { return [set TableauEPDOrgas($Quoi)]}

    if {[info exists TableauEPDOrgas(EstCharge)]} { return }
    
    set TableauEPDOrgas(EstCharge) 1
    LoadEPDOrgas TableauEPDOrgas

    if {[info exists TableauEPDOrgas($Quoi)]} { return [set TableauEPDOrgas($Quoi)]}
    return

}

proc AskEponine {args} {

    ### Interroge le fichier eponine ###
    global TableauEponine

    #unset
    #FileEponine NbEponines   --> nb eponinepredictions dans le FileEponine
    #FileEponine LesEponines  --> liste des indices des Eponines
    #FileEponine n $n D
    #FileEponine n $n F
    #FileEponine n $n Sens
    #FileEponine n $n Score

    set FirstArg [lindex $args 0]
    
    if {$FirstArg == "unset"} {
	if {[info exists TableauEponine]} {unset TableauEponine}
	return
    }
    set Quoi [join $args ","]
    if {[info exists TableauEponine($Quoi)]} { return [set TableauEponine($Quoi)]}
    if {![file exists $FirstArg]} { return }
    if {[info exists TableauEponine($FirstArg,EstCharge)]} { return }
    
    set TableauEponine($FirstArg,EstCharge) 1
    LoadEponine TableauEponine $FirstArg

    if {[info exists TableauEponine($Quoi)]} { return [set TableauEponine($Quoi)]}
    return

}

proc AskFileInfosDuFileTFAs {args} {

    ### Interroge le fichier FileInfosDuFileTFAs ###
    global TableauInfosDuFileTFAs
        
    #unsetall
    #unsetfile $FileInfosDuFileTFAs
    #$FileInfosDuFileTFAs LesSeqNames
    #$FileInfosDuFileTFAs SeqName $SeqName Id
    #$FileInfosDuFileTFAs SeqName $SeqName SeqLength
    #$FileInfosDuFileTFAs SeqName $SeqName Entete

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unsetall"} {
	if {[info exists TableauInfosDuFileTFAs]} {unset TableauInfosDuFileTFAs}
	return
    }
    
    if {[string equal -nocase $FirstArg "unsetfile"]} {
	set File [lindex $args 1]
	if {$File == "" || ![file exists $File] || ![info exists TableauInfosDuFileTFAs]} {return}
	foreach Index [array name TableauInfosDuFileTFAs] {
	    if {![regexp "^$File" $Index]} {continue}
	    unset TableauInfosDuFileTFAs($Index)
	}

	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauInfosDuFileTFAs($Quoi)]}               {return [set TableauInfosDuFileTFAs($Quoi)]}
    if {![file exists $FirstArg]}                                  {return}
    if {[info exists TableauInfosDuFileTFAs($FirstArg,EstCharge)]} {return}
    
    set TableauInfosDuFileTFAs(EstCharge) 1
    LoadFileInfosDuFileTFAs TableauInfosDuFileTFAs $FirstArg
    if {[info exists TableauInfosDuFileTFAs($Quoi)]}               {return [set TableauInfosDuFileTFAs($Quoi)]}
    return

}

proc AskFirstEF {args} {


    #unset
    #FileFirstEF LesSens
    #FileFirstEF Sens $Sens LesPredictions
    #FileFirstEF Sens $Sens Prediction $Prediction LesRangs
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang DPromoter
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang FPromoter
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang PPromoter
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang DExon
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang FExon
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang PExon
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang PDonor
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang InfoCpG
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang DCpG
    #FileFirstEF Sens $Sens Prediction $Prediction Rang $Rang FCpG

    global TableauFirstEF

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unset"} {
	if {[info exists TableauFirstEF]} {unset TableauFirstEF}
	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauFirstEF($Quoi)]} { return [set TableauFirstEF($Quoi)]}
    if {![file exists $FirstArg] || [info exists TableauFirstEF($FirstArg,EstCharge)]} { return }
    
    set TableauFirstEF($FirstArg,EstCharge) 1
    LoadFirstEF TableauFirstEF $FirstArg

    if {[info exists TableauFirstEF($Quoi)]} { return [set TableauFirstEF($Quoi)]}
    return

}

proc AskForNumberingGenbank {} {

    global AskForNumberingGenbank
    if {[info exists AskForNumberingGenbank]} { return $AskForNumberingGenbank }
    if {[OuiOuNon "Something is wrong with numbering genbank ORFs\n  Don't panic ... \n Do I stop to ask for your help ?"]} {
	set AskForNumberingGenbank 0
	return 0
    }
    if {[OuiOuNon "Do I always ask for your help ?"]} {
	set AskForNumberingGenbank 1
    }
    return 1

}

proc AskGOAnalyse {args} {

    global TabGOAnalyseXML 
 
    #unset
    #unsetfile $FichierXML
    #$FichierXML IdMin
    #$FichierXML NorMDMin
    #$FichierXML PMin
    #$FichierXML FMin
    #$FichierXML LesMethodes
    #$FichierXML LesAccess
    #$FichierXML Query Id
    #$FichierXML Query Name
    #$FichierXML Fichier MSF
    #$FichierXML Fichier CLUST
    #$FichierXML Methode $Methode LesTypes
    #$FichierXML Methode $Methode Type      $Type   LesGO
    #$FichierXML Methode $Methode Type      $Type   GO       $GO LesAccess
    #$FichierXML Methode $Methode Type      $Type   GO       $GO NbAccess
    #$FichierXML Methode $Methode LesAccess
    #$FichierXML Methode $Methode Access    $Access Types    $Type LesGO
    #$FichierXML Methode $Methode Access    $Access LesTypes
    #$FichierXML Type $Type GO $GO Definition

    set PremierArg [lindex $args 0] 
    if {[string equal -nocase $PremierArg  "unsetall"]} {
	unset TabGOAnalyseXML
	return
    }
    if {[string equal -nocase $PremierArg  "unsetfile"]} {
	set File [lindex $args 1]
	if {$File == "" || ![file exists $File] || ![info exists TabGOAnalyseXML]} {return}
	foreach Index [array name TabGOAnalyseXML] {
	    Espionne $Index
	    if {![regexp "^$File" $Index]} {continue}

	    unset TabGOAnalyseXML($Index)
	}
	return
    }

    set Quoi [join $args ","]

    #Espionne $args

    if {![file exists $PremierArg]} {return}
    if {[info exists TabGOAnalyseXML($Quoi)                ]} {return [set TabGOAnalyseXML($Quoi)]}

    if {[info exists TabGOAnalyseXML($PremierArg,EstCharge)]} {return}
    set TabGOAnalyseXML($PremierArg,EstCharge) 1
    LoadGOAnalyse TabGOAnalyseXML $PremierArg

    if {[info exists TabGOAnalyseXML($Quoi)                ]} {return [set TabGOAnalyseXML($Quoi)]}
    return

}

proc AskGOGraph {args} {

    #AskGOGraph search id $GO
    #AskGOGraph search name $name
    #AskGOGraph search synonym $synonym

    #AskGOGraph $GO get name
    #AskGOGraph $GO get namespace
    #AskGOGraph $GO get alternateIDs
    #AskGOGraph $GO get definition
    #AskGOGraph $GO get synonyms
    #AskGOGraph $GO get xrefs
    #AskGOGraph $GO get parents
    #AskGOGraph $GO get childs
    #AskGOGraph $GO get allParents
    #AskGOGraph $GO get allChilds

    LoadGOGraph

    switch -regexp [lindex $args 0] {
	"^search$" {
	    set search [lindex $args 2]

	    switch -exact [lindex $args 1] {
		"id" {
		    if {[GOGraph node exists $search]} {
			return $search
		    }
		    regsub -all {\"} $search {\\\0} search
		    return [GOGraph nodes -filter "lsearchNodeKeyGraphFilter -exact alternateIDs \"$search\""]
		}
		"name" {
		    return [GOGraph nodes -key name -value $search]
		}
		"synonym" {
		    regsub -all {\"} $search {\\\0} search
		    return [GOGraph nodes -filter "lsearchNodeKeyGraphFilter -exact synonyms \"$search\""]
		}
	    }
	}
	"^GO:\\d+" {
	    set GO [AskGOGraph search id [lindex $args 0]]
	    if {![GOGraph node exists $GO]} {return ""}

	    switch -exact [lindex $args 1] {
		"get" {
		    set key [lindex $args 2]

		    switch -exact $key {
			"name" -
			"namespace" -
			"alternateIDs" -
			"definition" -
			"synonyms" -
			"xrefs" {
			    if {[GOGraph node keyexists $GO $key]} {
				return [GOGraph node get $GO $key]
			    }
			    return ""
			}
			"parents" {
			    return [GOGraph nodes -out $GO]
			}
			"childs" {
			    return [GOGraph nodes -in $GO]
			}
			"allParents" {
			    set allParents {}

			    foreach parent [AskGOGraph $GO get parents] {
				lappend allParents $parent
				set parentParents [AskGOGraph $parent get allParents]
				if {[llength $parentParents] != 0} {
				    set allParents [concat $allParents $parentParents]
				}
			    }

			    return $allParents
			}
			"allChilds" {
			    set allChilds {}

			    foreach child [AskGOGraph $GO get childs] {
				lappend allChilds $child
				set childChilds [AskGOGraph $child get allChilds]
				if {[llength $childChilds] != 0} {
				    set allChilds [concat $allChilds $childChilds]
				}
			    }

			    return $allChilds
			}
		    }
		}
	    }
	}
    }

    error "[lindex [info level 0] 0]: could not parse arguments \"$args\""

}

proc AskLMS {args} {

    global TabDesLMSEtDesMotifsDuBallast

    if {$args == ""} {return}
    set PremArg [lindex $args 0]
    if {[string equal -nocase $PremArg "unset"]} {
	unset TabDesLMSEtDesMotifsDuBallast
	return
    }
    if {![file exists $PremArg]} {return}
    set Quoi [join $args ","]
    if {[info exists TabDesLMSEtDesMotifsDuBallast($Quoi)]} {return [set TabDesLMSEtDesMotifsDuBallast($Quoi)]}
    if {[info exists TabDesLMSEtDesMotifsDuBallast($PremArg,EstCharge)]} {return}
    
    set     TabDesLMSEtDesMotifsDuBallast($PremArg,EstCharge) 1
    LoadLMS TabDesLMSEtDesMotifsDuBallast $PremArg

    if {[info exists TabDesLMSEtDesMotifsDuBallast($Quoi)]} {return [set TabDesLMSEtDesMotifsDuBallast($Quoi)]}
    return

}

proc AskLesPagesInfos {args} {

    global TabDesPagesInfosEnMemoire

    set FirstArg [lindex $args 0]

    if {$FirstArg == "set"} {
	set Access   [lindex $args 1]
	set PageInfo [lindex $args 2]
	set TabDesPagesInfosEnMemoire($Access) $PageInfo
	return
    }
    if {$FirstArg == "unset"} {
	if {[info exists TabDesPagesInfosEnMemoire]} {unset TabDesPagesInfosEnMemoire}
	return
    }
    if {$FirstArg == "ask"} {
	set Id [lindex $args 1]
	if {![info exists TabDesPagesInfosEnMemoire($Id)]} {return}
	return [set TabDesPagesInfosEnMemoire($Id)]
    }
    if {$FirstArg == "load"} {
	set LesId  [lindex $args 1]
	set Banque [lindex $args 2]

	foreach ListeId [LaListeSplittee $LesId "100"] {
	    TabLesPageInfos TabDesPagesInfosEnMemoire $ListeId $Banque
	}
	return
    }
    return

}

proc AskMSF {args} {

    global TabSequencesDesProteinesDansMSF

    #unset 
    #$FileMSF LesAccess
    #$FileMSF $Access -> sequence

    set PremierArg [lindex $args 0]

    if {$PremierArg == "unset"} {
	if {[info exists TabSequencesDesProteinesDansMSF]} {unset TabSequencesDesProteinesDansMSF}
	return
    }

    if {![file exists $PremierArg]} {return}
    if {[info exists TabSequencesDesProteinesDansMSF] && ![info exists TabSequencesDesProteinesDansMSF($PremierArg,EstCharge)]} {
	unset TabSequencesDesProteinesDansMSF
    }

    set Quoi [lindex $args 1]
    if {[info exists TabSequencesDesProteinesDansMSF($Quoi)]} {
	return [set TabSequencesDesProteinesDansMSF($Quoi)]
    }
    if {[info exists TabSequencesDesProteinesDansMSF($PremierArg,EstCharge)]} {return}
    if {[info exists TabSequencesDesProteinesDansMSF]} {unset TabSequencesDesProteinesDansMSF}
    set   TabSequencesDesProteinesDansMSF($PremierArg,EstCharge) 1
    DecortiqueUnMSF $PremierArg TabSequencesDesProteinesDansMSF(LesAccess) TabSequencesDesProteinesDansMSF

    if {![info exists TabSequencesDesProteinesDansMSF($Quoi)]} {return}
    return [set TabSequencesDesProteinesDansMSF($Quoi)]

}

proc AskMatch {args} {

    ### Interroge la sortie du programme match ###
    
    #unset
    #FileMatch LesMotifs
    #FileMatch Motif $MotifId NbPresence
    #FileMatch Motif $MotifId n $i Debut
    #FileMatch Motif $MotifId n $i Fin
    #FileMatch Motif $MotifId n $i Sens
    #FileMatch Motif $MotifId n $i Sequence
    #FileMatch Motif $MotifId n $i ScoreCore
    #FileMatch Motif $MotifId n $i ScoreMotif
    
    global TableauMatchSearches

    set FirstArg [lindex $args 0]

    if {$FirstArg == "unset"} {
	if {[info exists TableauMatchSearches]} {unset TableauMatchSearches}
	return
    }
    
    set Quoi [join $args ","]
    if {[info exists TableauMatchSearches($Quoi)]} { return [set TableauMatchSearches($Quoi)]}
    if {![file exists $FirstArg] || [info exists TableauMatchSearches($FirstArg,EstCharge)]} { return }
    
    set TableauMatchSearches($FirstArg,EstCharge) 1
    LoadMatch TableauMatchSearches $FirstArg

    if {[info exists TableauMatchSearches($Quoi)]} { return [set TableauMatchSearches($Quoi)]}
    return

}

proc AskMatchMatrixAccess2Id2Name {args} {

    ### Interroge le fichier d'informations sur la librairie de matrices de Match ###
    global TableauMatchMatrixAccess2Id2Name

    #unset
    #Access $Access Id
    #Access $Access Name
    #Id     $Id     Access
    #Id     $Id     Name

    set FirstArg [lindex $args 0]
    if {$FirstArg == "unset"} {
	if {[info exists TableauMatchMatrixAccess2Id2Name]} {unset TableauMatchMatrixAccess2Id2Name}
	return
    }
    set File [MatchDir MatrixLibrary]

    set Quoi [join $args ","]  
    if {$FirstArg == "Id"} {regsub -all {\$} $Quoi "_" Quoi}

    if {[info exists TableauMatchMatrixAccess2Id2Name($File,$Quoi)]} { return [set TableauMatchMatrixAccess2Id2Name($File,$Quoi)]}
    if {![file exists $File]} { return }
    if {[info exists TableauMatchMatrixAccess2Id2Name($File,EstCharge)]} { return }
    
    set TableauMatchMatrixAccess2Id2Name($File,EstCharge) 1
    LoadMatchMatrixAccess2Id2Name TableauMatchMatrixAccess2Id2Name $File

    if {[info exists TableauMatchMatrixAccess2Id2Name($File,$Quoi)]} { return [set TableauMatchMatrixAccess2Id2Name($File,$Quoi)]}
    return

}

proc AskOptionsDeDrawBlast {args} {

    global TabOptionsDeDrawBlast

    set FirstArg [lindex $args 0]
    if {[string equal $FirstArg "unsetall"]} {
	if {[info exists TabOptionsDeDrawBlast]} {unset TabOptionsDeDrawBlast}
	return
    }

    if {[string equal $FirstArg "set"]} {
	set Qui [join [lrange $args 1 end-1] ","]
	set Quoi      [lindex $args   end  ]
	set TabOptionsDeDrawBlast($Qui) $Quoi
	return
    }
    if {[string equal $FirstArg "append"]} {
	set Qui [join [lrange $args 1 end-1] ","]
	set Quoi      [lindex $args   end  ]
	if {![info exists TabOptionsDeDrawBlast($Qui)]} {set TabOptionsDeDrawBlast($Qui) {}}
	lappend TabOptionsDeDrawBlast($Qui) $Quoi
	return
    }

    set Qui [join [lrange $args 1 end] ","]
    if {[string equal $FirstArg "unset"]} {
	if {![info exists TabOptionsDeDrawBlast($Qui)]} {return}
	unset TabOptionsDeDrawBlast($Qui)
	return
    }
    if {[string equal $FirstArg "exists"]} {
	if {![info exists TabOptionsDeDrawBlast($Qui)]} {return 0}
	return 1
    }
    if {[string equal $FirstArg "ask"]} {
	if {![info exists TabOptionsDeDrawBlast($Qui)]} {return}
	return [set TabOptionsDeDrawBlast($Qui)]
    }
    return

}

proc AskPrositeScan {Lseq} {

    set result [PrositeWebService -seq $Lseq]
    
    package require json
    set dres [::json::json2dict $result]
    set val [dict get $dres matchset]
    set i 1
    foreach e $val {
	foreach {k v} $e {
	    set Tres($i,$k) $v
	    #puts "\t$k $v"
	}
	incr i
    }

    return [array get Tres]

}

proc AskTOLDBUpdates {} {

    set db [InitTaxDB]
    unset -nocomplain ::db

    set res [list]
    $db eval {begin transaction}
    lappend res [$db eval {select value from admin where var = 'goldUpdate'}]
    lappend res [$db eval {select value from admin where var = 'taxoUpdate'}]
    $db eval {commit}
    $db close
    update

    return $res

}

proc AskUCSC {args} {

    ### Frederic Chalmel, Biozentrum Basel, 2005 ###
    ### ask du fichier refSeqAli.txt ###
    
    ### Liste des access de mRNA RefSeq de l'organisme considere:
    ### $File ListOfID                     --> liste des access de mRNA RefSeq
    ### Localisation des mRNA RefSeq sur le chromosome:
    ### $File ID       $ID ListOfPosition  --> liste          $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand
    ### Carte exonique:
    ### $File ID       $ID Chrom $Chr From $ChrFrom To $ChrTo Strand $Strand ListOfPosition
    ###                                    --> liste de [list $ID $Start1  $End1  $Chr $Start2  $End2  $Strand]
    
    global TabUCSCLocation
    
    # proc AskUCSC args -> %File ListOfID              -> return the list of the ID
    # proc AskUCSC args -> %File ID %ID ListOfPosition -> return the list of the position of the %ID ID on the genome
    
    set FirstArg [lindex $args 0]
    
    if {$FirstArg == "unset"} {
	if {[info exists TabUCSCLocation]} {unset TabUCSCLocation}
	return
    }
    if {$FirstArg == "unsetfile"} {
	set File [lindex $args 1]
	if {$File == "" || ![file exists $File] || ![info exists TabUCSCLocation]} {return}
	foreach Index [array name TabUCSCLocation] {
	    if {![regexp "^$File" $Index]} {continue}
	    unset TabUCSCLocation($Index)
	}
	return
    }
    
    set File $FirstArg
    
    set ARG [join $args ","]
    
    if {[info exists TabUCSCLocation($ARG)]        } {return [set TabUCSCLocation($ARG)]}
    if {[info exists TabUCSCLocation($File,Loaded)]} {return}
    LoadUCSC TabUCSCLocation $File
    if {[info exists TabUCSCLocation($ARG)]        } {return [set TabUCSCLocation($ARG)]}
    return

}

proc AssemblyDbTools {{dbName ""}} {


    while {$dbName==""} {
	if {[OnTraite Bathy2010]} { set dbName "Bathymodiolus"; break }
    }

    NSAssemblyDb::setCanal $dbName

    set win [toplevel [NomDe fenetre]]
    wm title $win "Assembly database tools"

    set libEditButton [button $win[NomDe button] -text "Library editor" -command "LibraryEditorGui"]
    pack $libEditButton -fill x
    set popDbButton [button $win[NomDe button] -text "Populate database" -command "PopulateAssemblyDbGui"]
    pack $popDbButton -fill x
    #rR Specific Bathyumodiolus !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    if {$dbName!="Bathymodiolus"} { return 0 }
    set popBathyButton [button $win[NomDe button] -text "Populate Bathymodiolus with Bathy2010" -command "PopulateBathy2010"]
    pack $popBathyButton -fill x
    return 0

}

proc AssignNbInternal {n} {

    global Tx

    set Lgen [DonneGenealogieMem $n]
    set cum 0
    foreach g $Lgen {
	set isI $Tx(isInt,$g)
	if {$isI} {
	    set Tx(NbInt,$g) 0
	    incr cum
	} else {
	    set Tx(NbInt,$g) $cum
	    if {$cum} {
		set cum 0
	    }
	}
    }

    return

}

proc AssignSeqToGroup {} {

    global LNDG SDG GroupeDeLaSequence TDuGroupeDesSeqs

    set Lg [lsearch -all -inline -regexp $LNDG {Group[0-9]+}]
    if {[llength $Lg] > 0} {
	set Lg [lrange $LNDG 1 end]
    } else {
	set Lg "GroupeToutLeMonde"
    }
    foreach g $Lg {
	if {$g eq "GroupeToutLeMonde"} {
	    set ng "Group0"
	} else {
	    set ng $g
	}
	foreach n [set SDG($g)] {
	    set GroupeDeLaSequence($n) $ng
	    set TDuGroupeDesSeqs($n) $ng
	}
    }

    if {! [info exists GroupeDeLaSequence]} {
	foreach n [set SDG(GroupeToutLeMonde)] {
	    set GroupeDeLaSequence($n) "Group0"
	}
    }

    return

}

proc AssigneBootstrap {AId} {

    global TSum Abr HashRef

    set t [set Abr(Arbre,$AId)]

    foreach n [$t nodes] {
	if {[$t isleaf $n]} {continue}
	if {$n eq "root"} {
	    set v 1000000
	} elseif {! [info exists TSum($n)]} {
	    puts "no TSum for $n"
	    set v 0
	} else {
	    set v [set TSum($n)]
	}
	$t set $n nboot $v
    }

    set Ser [$t serialize]
    set Abr(ArbreSer,$AId) $Ser

    return

}

proc AssigneGroupesDuRSF {} {


    global NomsGrpIntegral
    global LesNomsSeqGrpIntegral
    global LNOrdali
    global LeGroupeDesSeqs
    global TabRSF

    set NomsGrpIntegral {}
    foreach nom $LNOrdali {
	if {! [info exists TabRSF($nom,group)]} {continue}
	set grp [set TabRSF($nom,group)]
	if {[lsearch $NomsGrpIntegral "Group$grp"]==-1} {
	    lappend NomsGrpIntegral "Group$grp"
	}
	lappend LesNomsSeqGrpIntegral(Group$grp) $nom
    }

    return

}

proc AssigneGroupesIntegral {} {


    global LeGroupeDesSeqs
    global TDuGroupeDesSeqs
    global DocMacsim
    global NomsGrpIntegral
    global LesNomsSeqGrpIntegral
    global LNOrdali
    global TabRSF

    catch {unset NomsGrpIntegral}
    catch {unset LesNomsSeqGrpIntegral}

    if {[info exists TabRSF]} {
	AssigneGroupesDuRSF

	return
    }

    foreach nom $LNOrdali {
	if {[string trim $nom] eq ""} {continue}
	set grp [set TDuGroupeDesSeqs($nom)]
	lappend NomsGrpIntegral $grp
	lappend LesNomsSeqGrpIntegral($grp) $nom
    }
    set NomsGrpIntegral [lsort -unique $NomsGrpIntegral]

    return

}

proc AssigneLePoidsDesSeqs {} {


    global LePoidsDesSeqs
    global IdXml
    global LesPoidsDesSequences
    global LNOrdali
    global FichierMSF
    global FichierXML

    set LePoidsDesSeqs {}
    if {[info exists FichierMSF]} {
	LitLesPoidsDuMSF $FichierMSF
	foreach n $LNOrdali {
	    set p [set LesPoidsDesSequences($n)]
	    lappend LePoidsDesSeqs $p
	}
    }
    if {[info exists FichierXML]} {
	ExtraitLesPoids $IdXml LePoidsDesSeqs
    }

    return

}

proc AssigneLePoint {aa NmGrp pos} {

    global LNDG ListeDesPiliersDuGroupe

    set aa [string toupper $aa]
    set YaPoint 1

    foreach groupe [lrange $LNDG 1 end] {
	if {[string compare $groupe $NmGrp] && $YaPoint} {
	    set PilierCompare [lrange [set ListeDesPiliersDuGroupe($groupe)] $pos $pos]
	    set YaPoint [expr {![regexp $aa $PilierCompare]}]
	}
    }

    return $YaPoint

}

proc AssigneLesPoids {{nmgrp ""}} {

    global LesPoidsDesSequences Defauts Sequences LNOrdali OrdTmpDir

    if {! [set Defauts(Poids)] && ![set Defauts(Poids2)] && ![set Defauts(Poids3)]} {
	foreach s $LNOrdali {
	    set LesPoidsDesSequences($s) 1.
	}
	return
    }

    set in [file join $OrdTmpDir "in"]
    set out [file join $OrdTmpDir "out"]

    CreeLeTfa $in $nmgrp

    eval exec "calcule_weight $in $out"

    LitLesPoidsDuMSF $out $nmgrp

    file delete -force $in
    file delete -force $out

    return

}

proc AssigneTagsCouleursDesAA {} {

    global NomTextSeq TagCouleurAA

    foreach t {STAC DE HN G P Q ILMV RK FYW} {
	foreach a [split $t ""] {
	    set TagCouleurAA($a) $t
	    set TagCouleurAA([string tolower $a]) $t
	}
    }

    set conftag [ExtraitTable "[TypeSeq]"]
    foreach c $conftag {
	lassign $c n f b
	$NomTextSeq tag configure Tag$n -foreground $f -background $b
    }
    
    return

}

proc AssigneValParPos {} {

    global TableScore
    global ListeScore
    global LNOrdali
    global SDG
    global LNDG
    global ListeDesPiliersDuGroupe
    global TestCourant

    RecupereReference
    CreeFeaturesOrdali

    foreach g [lrange $LNDG 0 end-1] {
	if {[info exists TableScore]} {
	    array unset TableScore
	    catch {unset TableScore}
	}
	puts "Nom Grp   : $g"
	puts "NSeqs     : [llength $SDG($g)]"
	if {$g == "GroupeToutLeMonde"} {set g ""}

	ScoreDeRosace $g
	ScoreDeThompson   $g
	ScoreDeRanganatan $g

	CreeListeScore $g

	# fait les differentes combinaisons de parametres
	#
	#    norm dsp nVp mcos dist Ranganatan
	#     0    1   2   3    4     5
	#     n    p   v   m    d     g

	LanceLesCalculs 5 $g
	LanceLesCalculs 4 $g
	LanceLesCalculs 0 $g
	LanceLesCalculs 45 $g
	LanceLesCalculs 045 $g
    }

    return

}

proc AtomePicke {Lr} {


    global RasM

    foreach l $Lr {
	if {[string first "Atom: " $l] == 0} {
	    scan $l "Atom: %s %d Group: %s %d  Chain: %s" atName atNb resName resNb chain
	    set RasM(Picked) [list $atName $resName $resNb $chain]
	    set RasM(AtLabel) "$resName $resNb $atName , $chain"
	}
    }

    return

}

proc Atomes2Grille {bbox Lc Lx Lan} {

    set Step [set ::Defauts(Sampling)]
    set Offset [expr {$::SpS(Offset)+1}]

    set OffX $Offset
    set OffY $Offset
    set OffZ $Offset
    puts "Step $Step"
    puts "Offset $Offset"

    lassign $bbox xm xx ym yx zm zx
    set xmi [expr {int($xm*$Step)-1}]
    set ymi [expr {int($ym*$Step)-1}]
    set zmi [expr {int($zm*$Step)-1}]
    set xxi [expr {int($xx*$Step)+1}]
    set yxi [expr {int($yx*$Step)+1}]
    set zxi [expr {int($zx*$Step)+1}]
    
    lassign $Lc xc yc zc
    set xci [expr {round($xc*$Step)}]
    set yci [expr {round($yc*$Step)}]
    set zci [expr {round($zc*$Step)}]

    # faut Offset sur chaque bord
    set resX [expr {int($xx-$xm+0.5)*$Step+1+2*$Offset}]
    set resY [expr {int($yx-$ym+0.5)*$Step+1+2*$Offset}]
    set resZ [expr {int($zx-$zm+0.5)*$Step+1+2*$Offset}]

    # Faut que la resolution de la grille soit un 
    # multiple de 3
    set k 4
    set Extra 0
    while {$resX % (1*$Step) || $resX % ($k*$Step) } {
	incr Extra
	set resX [expr {int($xx-$xm+0.5)*$Step+1+2*$OffX+$Extra}]
    }
    set Extra 0
    while {$resY % (1*$Step) || $resY % ($k*$Step) } {
	incr Extra
	set resY [expr {int($yx-$ym+0.5)*$Step+1+2*$OffY+$Extra}]
    }
    set Extra 0
    while {$resZ % (1*$Step) || $resZ % ($k*$Step) } {
	incr Extra
	set resZ [expr {int($zx-$zm+0.5)*$Step+1+2*$OffZ+$Extra}]
    }
    puts "\nresX $resX resY $resY resZ $resZ"

    for {set k 0} {$k < $resZ } {incr k} {
	for {set j 0} {$j < $resY } {incr j} {
	    for {set i 0} {$i < $resX } {incr i} {
		set T($i,$j,$k) 0
	    }
	}
    }

    set g [open coord w]
    foreach rx $Lx lna $Lan {
	foreach v $rx an $lna {
	    lassign $v x y z
	    puts $g [format " %8.3f %8.3f %8.3f" $x $y $z]
	    set x [expr {round($x-$xm)*$Step+1+$OffX}]
	    set y [expr {round($y-$ym)*$Step+1+$OffY}]
	    set z [expr {round($z-$zm)*$Step+1+$OffZ}]

	    FillTheBox T $x $y $z $an
	    #set T($x,$y,$z) 1.
	}
    }
    close $g
    puts "fill table T [llength [array names T]]"

    foreach e [array names T] {
	lassign [split $e ,] i j k
	if {($i < 0 || $i >= $resX) || ($j < 0 || $j >= $resY) || ($k < 0 || $k >= $resZ)} {puts $e}
    }

    set Lv [list]
    lappend Lv [list $resX $resY $resZ]
    
    #ExpandMask T $resX $resY $resZ
    #ExpandMask T $resX $resY $resZ
    #ExpandMask T $resX $resY $resZ
    #ExpandMask T $resX $resY $resZ
    #ContractMask T $resX $resY $resZ
    #ContractMask T $resX $resY $resZ
    #ContractMask T $resX $resY $resZ
    #ContractMask T $resX $resY $resZ
    #ExpandMask T $resX $resY $resZ
    #ExpandMask T $resX $resY $resZ
    #ContractMask T $resX $resY $resZ

    set f [open test w]
    #lappend Lv [list 8 8 8]
    puts ""
    for {set k 0} {$k < $resZ } {incr k} {
	for {set j 0} {$j < $resY } {incr j} {
	    for {set i 0} {$i < $resX } {incr i} {
		lappend Lp [set T($i,$j,$k)]
		puts -nonewline $f [set T($i,$j,$k)]
		if {[set T($i,$j,$k)] == 0} {
		    puts -nonewline "."
		} else {
		    puts -nonewline "O"
		}
	    }
	    puts ""
	}
	puts "\n"
    }
    close $f
    puts "$resX $resY $resZ"
    exit
    lappend Lv $Lp
    
    set Ltrg [mctcl $Lv]

    return $Ltrg

}

proc AttendLeSavant {Animateur Ip Cafe Science Ident} {

    global SavantSpecialise
    
    if { [eof $Animateur] } {
	#PotinsDeQuestion "AttendLeSavant $Animateur $Ip $Cafe $Science recu 'eof'"
	close $Animateur
	return
    }
    if { [gets $Animateur Reponse] == -1 } {
	#PotinsDeQuestion "$Animateur $Ip $Cafe $Science mauvaise reponse"
	return
    }
    if { 0 && ! [EstUnSavant $Reponse]} {
	#PotinsDeQuestion "$Animateur $Ip $Cafe $Science a retourne $Reponse qui n'est pas un savant."
	return
    }

    set SavantSpecialise($Science,$Cafe,$Ident) $Reponse


}

proc AttendreLeFichier {Fichier {TimeOut ""}} {


    set Attente 1000
    while { 1 } {
	if {[file exists $Fichier]} { return $Fichier }
	if {$TimeOut != "" } {
	    set TimeOut [expr $TimeOut-$Attente]
	    if {$TimeOut<0} { return "" }
	}
	after $Attente
    }

}

proc AttendreLeFichierDuServeurWscope {Fichier {TimeOut ""}} {


    set Attente 1000
    while { 1 } {
	if {[file exists $Fichier]} { return $Fichier }
	if {$TimeOut != "" } {
	    set TimeOut [expr $TimeOut-$Attente]
	    if {$TimeOut<0} { return "" }
	}
	after $Attente
    }

}

proc AttendreTantQueExiste {Fichier {TimeOut 60000}} {

    while {[file exists $Fichier]} { after $TimeOut }
    return $Fichier

}

proc AttriCoord {} {

    set Fichier "/genomics/link/EVI0/parser/f2attritoutaccess"
    set LesLignes [LesLignesDuFichier $Fichier]
    set A 0; set B 0
    set AccessSansCoord {}
    set JaiTrouveLigne 0

    foreach Ligne $LesLignes {
	
	if {[regexp {^ligne} $Ligne]} {
	    set JaiTrouveLigne 1
	    set NumLigne [StringApres "ligne" dans $Ligne]
	    puts $NumLigne
	    continue
	} 
	if {$JaiTrouveLigne} {
	    #pr RA
	    if {![regexp {^Les} $Ligne]} {
		incr A
		continue
	    }

	    set LesAccess [string range $Ligne [expr [string first " " $Ligne]+1] end]
	    puts "$LesAccess"

	    #pr SsAccess
	    if {[regexp "vide" $LesAccess]} {
		incr B
		continue
	    }

	    set ListeDesAccess [split $LesAccess " ,"]
	    foreach Access $ListeDesAccess {
		set chr      [LocUcsc $Access chrom]
		set txstart  [LocUcsc $Access txStart]
		set txend    [LocUcsc $Access txEnd]
		set cdsstart [LocUcsc $Access cdsStart]
		set cdsend   [LocUcsc $Access cdsEnd]
		puts "$Access=$chr $txstart - $txend"
		#puts "$Access=$cdsstart - $cdsend"
		if {$txstart==""} {
		    lappend AccessSansCoord "$NumLigne=>$Access"
		}
	    }
	}
	set JaiTrouveLigne 0
    }
    set nb [llength $AccessSansCoord]
    puts "nb d'access sans coord= $nb"
    puts "nb de ra= $A"
    puts "nb ss access= $B"
    SauveLesLignes $AccessSansCoord dans /genomics/link/EVI0/parser/LesLignesSansCoord.txt 

}

proc AttriDesAcDna {} {

    set A 0; set B 0; set C 0; set Pr 0
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	set jaitrouve 0 
	set genenamefait 0
	set AccDna ""
	set LAccDna {}
	set LesAccDna {}

	if { [regexp {^RA[0-9]+} $Des1] } { continue }
	if { [regexp {\?} $Ac1] } { continue }
	

	if { $Ac1!="" } {
	    incr A
	    Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 =>$A"

	    if {$Ac2==""} {
		incr B
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    puts "pour $I, prend Ac1=$Ac1 et NM=$NM (A)"
			} else { puts "pour $I, prend Ac1=$Ac1 (Abis)" }
		    } else { puts "pour $I, prend Ac1=$Ac1 (B)" }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    incr Pr
		    puts "pour ligne $I, travail sur prot Ac3=$Ac3 Ac4=$Ac4=>$Pr (C)"
		    
		    if { [regexp "," $Ac3] } {puts "attention le prog ne prend pas en compte ce cas"}

		    set GenreP3 [OrgDuProt [string trim $Ac3]]
		    
		    if { $GenreP3 == "" } { 
			#jamais ce cas
			puts "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} { puts "dois prendre la def" }
			if {$Ac4 != ""} { puts "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    #cherche nm de prot_acc_piqor
			    if { [regexp "," $Ac4] } {puts "attention2 le prog ne prend pas en compte ce cas"}
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} { 
				    puts "pour $I, prend accdna=$AccDna (D)"
				    set LAccDna [split $AccDna " "]
				    foreach Q $LAccDna {LConcat LesAccDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4] 
				    if {$AccDna!=""} { 
					puts "pour $I, prend accdna=$AccDna (E)"
					set LAccDna [split $AccDna " "]
					foreach S $LAccDna {LConcat LesAccDna $S} 
				    }
				}
			    }
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Ebis)"
			} else {
			    set genenamefait 1
			    #voir avec la def
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (F)" }
			}
			if {$genenamefait == 0 && $AccDna == ""} {
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (G)" }
			}
			if {$AccDna == ""} {
			    puts "pas d'acccess"
			    lappend LesLignesPauvres $I
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    #jamais ce cas
			    set AccsProt "$Ac3,$Ac4"
			    puts "acess prot=$AccsProt"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				#recupere nm
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    puts "chaqueaccprot=$ChaqueAccProt a acc dna $AccDna (H)"
				    set LAccDna [split $AccDna " "]
				    foreach Q $LAccDna {LConcat LesAccDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					puts "pour $I, prend accdna=$AccDna (I)" 
					set LAccDna [split $AccDna " "]
					foreach S $LAccDna {LConcat LesAccDna $S} 
				    }
				}
			    } 
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Ibis)"
			} else {
			    #recupere que prot_acc 
			    set AccDna [AttriDesAcDnaParProt $Ac3]
			    if {$AccDna!=""} { 
				puts "pour $I, prend accdna=$AccDna (J)" 
				set LAccDna [split $AccDna " "]
				foreach Q $LAccDna {LConcat LesAccDna $Q} 
			    }
			    if {$AccDna==""} {  
				set AccDna [AttriDesAcDnaParGb $Ac3] 
				if {$AccDna!=""} { 
				    puts "pour $I, prend accdna=$AccDna (K)" 
				    set LAccDna [split $AccDna " "]
				    foreach S $LAccDna {LConcat LesAccDna $S}  
				}
			    }
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Kbis)"
			}
			if {$AccDna == ""} {
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (L)" }
			}
			if {$AccDna == ""} {
			    puts "pas d'access"
			    lappend LesLignesPauvres $I
			}
		    }
		}
	    }

	    if {$Ac2!=""} {
		incr C

		if { $Ac1==$Ac2 } {
		    puts "pour $I, prend refseq=$Ac2 (meme numero dans DNA_acc et refseq)(1)"
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    puts "pour $I, prend refseq=$Ac2 (meme numero dans DNA_acc et refseq)(2)"
			    set jaitrouve 1
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 et NM=$NM (3)"
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc2 $ListeNM]
				set Tout [lsort -unique $Tout]
				puts "pour $I, prend Ac1=$Ac1 et Ac2+NM=$Tout (3bis)"
			    } else { puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 (4)" }
			} else { puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 (5)" }
		    }

		    if {[regexp {^Homo$} $Genre]} {
			puts "pour $I, prend que refseq=$Ac2 (6)"
		    }
		}
	    }
	}
    }
    foreach LignePauvre $LesLignesPauvres { puts "lignepauvre=$LignePauvre" }
    set nbdepauvre [llength $LesLignesPauvres]
    Espionne "nbdepauvre=$nbdepauvre"
    Espionne "$Pr=nb de ligne ou on se sert de la prot"
    Espionne "$A=nb de ligne ac dna_acc"
    Espionne "$B=nb de ligne ac dna_acc et ss refseq_piqor"
    Espionne "$C=nb de ligne ac dna_acc et ac refseq_piqor"

}

proc AttriDesAcDnaClient {} {

    set total 0; set D 0; set E 0; set F 0; set G 0
    foreach I [RetChip5 ListOf Index] {
	set AC [RetChip5 $I "DNA_acc"]
	if {[regexp {\?} $AC]} {set AC ""}

	if { $AC!="" } {
	    set LesAc [split $AC ","]
	    foreach Ac $LesAc {
		incr total
		if { [regexp "^NM_" $Ac] || [regexp "^XM_" $Ac] || [regexp "^NR_" $Ac] } { 
		    incr D
		    puts "la ligne $I a deja un no NM=$Ac" 
		} else {
		    incr E
		    set NM [MrnaRefseqUcscMouse $Ac "Nm"]
		    if { $NM != "" } {
			incr F
			puts "pour $I, Ac=$Ac correspond a $NM ($F)"
		    } else {
			incr G
			puts "pour $I, Ac=$Ac correspond a rien"
		    }
		}
	    } 
	}
    }
    Espionne "il y a $total access DNA_acc"
    Espionne "il y a $D access qui ont deja un NM dans DNA_acc"
    Espionne "il y a $E access qui ont un access transforme"
    Espionne "il y a $F access qui ont 1 corresp"
    Espionne "il y a $G access qui ont pas corresp"

}

proc AttriDesAcDnaClient_AEffacer {} {

    set D 0
    set E 0
    set F 0
    foreach I [RetChip2 ListOf Index] {
	set Ac [RetChip2 $I "DNA_acc"]
	if { $Ac!="" } {
	    if { [regexp "," $Ac] } { puts "attention il y a pls access sur une ligne" } 
	    if { [regexp "^NM_" $Ac] } { 
		incr D
		#puts "la ligne $I a deja un no NM=$Ac" 
	    } else {
		incr E
		set NM [MrnaRefseqUcscMouse $Ac "Nm"]
		if { $NM != "" } {
		    puts "pour $I, Ac=$Ac correspond a $NM ($F)"
		    incr F
		} else {
		    lappend LesPauvres $Ac
		}
	    }
	} else { continue }
    }
    SauveLesLignes $LesPauvres dans [Fiches]/lesPauvres.txt
    set nb [llength $LesPauvres]
    Espionne "il y a $D lignes qui ont deja un NM dans DNA_acc"
    Espionne "il y a $E lignes qui ont un access transforme"
    Espionne "il y a $nb lignes qui ont pas corresp"
    Espionne "il y a $F lignes qui ont 1 corresp"

}

proc AttriDesAcDnaParGb {AC} {

    set LesAcsGbDeLaLigne {}
    set GetzOut ""; set GetzOutRs ""
    set CommandeRs "getz \"\\\[protein-acc:$AC\\\] > \(\\\[refseq-mol:mRNA\\\] & \\\[refseq-org:Mus musculus\\\]\)\" \-vf acc"
    set GetzOutRs [eval exec $CommandeRs]

    if { $GetzOutRs != "" } {
	#Espionne "Acc=$AC getzoutRs=$GetzOutRs"
	set LesLignesDeGetzOutRs [split $GetzOutRs "\n"]
	foreach LigneDeGetzOutRs $LesLignesDeGetzOutRs {
	    set AcRs ""
	    scan $LigneDeGetzOutRs "%s %s" Ref AcRs
	    #Espionne "acrs=$AcRs"
	    LConcat LesAcsGbDeLaLigne $AcRs	
	}
    }
    if {$GetzOutRs == ""} {
	set Commande "getz \"\\\[protein-acc:$AC\\\] > \(\\\[genbankfull-mol:mRNA\\\] & \\\[genbankfull-org:Mus musculus\\\]\)\ \" \-vf acc"
	set GetzOut [eval exec $Commande]
	if {$GetzOut!=""} {
	    #Espionne "Acc=$AC getzoutGb=$GetzOut"
	    set LesLignesDeGetzOut [split $GetzOut "\n"]
	    foreach LigneDeGetzOut $LesLignesDeGetzOut {
		set Ref ""; set AcGb ""; set mRNAGb ""
		scan $LigneDeGetzOut "%s %s" Ref AcGb
		#Espionne "acgb=$AcGb"
		LConcat LesAcsGbDeLaLigne $AcGb	
		if {![regexp {^NM_} $AcGb]} {
		    set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
		    #Espionne "mRNAGb $mRNAGb"
		    if {$mRNAGb != ""} { 
			#Espionne "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
			set ListemRNAGb [split $mRNAGb " "]
			foreach ChaqmRNAGb $ListemRNAGb {
			    set GenreChaqmRNAGb [OrgDuNmOuGb $ChaqmRNAGb]
			    #Espionne "$ChaqmRNAGb $GenreChaqmRNAGb"
			    if {[regexp {^Mus} $GenreChaqmRNAGb]} { 
				LConcat LesAcsGbDeLaLigne $ChaqmRNAGb
			    }
			}
		    }
		} 
	    }
	}
	if {$GetzOut == ""} { 
	    set LesAcsGbDeLaLigne ""
	    #Espionne "Acc=$AC getzout=vide pas fiche ou pas mrna" 
	}
    }
    set LesAcsGbDeLaLigne [ListeSansDoublon $LesAcsGbDeLaLigne]
    set LesAcsGbDeLaLigne [join $LesAcsGbDeLaLigne " "]
    return $LesAcsGbDeLaLigne

}

proc AttriDesAcDnaParGb_AEffacer {AC} {

    set LesAcsGbDeLaLigne {}
    set GetzOut ""
    set Commande "getz \"\\\[protein-acc:$AC\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
    set GetzOut [eval exec $Commande]
    if {$GetzOut == ""} { 
	set LesAcsGbDeLaLigne ""
	#puts "Acc=$AC getzout=vide pas fiche ou pas mrna" 
    }
    if {$GetzOut != ""} {
	#puts "Acc=$AC getzout=$GetzOut"
	set LesLignesDeGetzOut [split $GetzOut "\n"]
	foreach LigneDeGetzOut $LesLignesDeGetzOut {
	    set Ref ""
	    set AcGb ""
	    set mRNAGb ""
	    scan $LigneDeGetzOut "%s %s" Ref AcGb
	    #puts "acgb=$AcGb"
	    LConcat LesAcsGbDeLaLigne $AcGb	
	    if {![regexp {^NM_} $AcGb]} {
		set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
		if {$mRNAGb != ""} { 
		    #puts "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
		    set ListemRNAGb [split $mRNAGb " "]
		    foreach ChaqmRNAGb $ListemRNAGb {
			LConcat LesAcsGbDeLaLigne $ChaqmRNAGb
		    }
		} 
	    }
	}
    }
    set LesAcsGbDeLaLigne [ListeSansDoublon $LesAcsGbDeLaLigne]
    set LesAcsGbDeLaLigne [join $LesAcsGbDeLaLigne " "]
    return $LesAcsGbDeLaLigne

}

proc AttriDesAcDnaParGeneName {DescriC DescriM} {
 
    set LesNMsDeLaLigne {}
    set LesGeneNames {}
    set DescriMOri $DescriM
    set ListeNm {}; set ListmRNA {}; set ListmRNA1 {}
    set LesLignes1 {}; set LesLignes2 {}
    set LesNMs2 ""; set ListeNm2 {}; set mRNA12 {}; set ListmRNA12 {}
    #Espionne "descrimori=$DescriMOri"

    set IPF [string first ")" $DescriM]
    if {$IPF>0} {
	set DescriM [string range $DescriM 0 [incr IPF -1]]
	regsub -all {[\(\:]} $DescriM " " DescriM
	regsub -all -nocase { OR } $DescriM " " DescriM
	set LesGeneNames [LesMotsDeLaLigne $DescriM]
	set DescriM [string trim $DescriM]
	#Espionne "descrim=$DescriM" 
    }
    scan $DescriC "%s" DescriC
    set DescriC [string trim $DescriC]
    regsub -all {\(} $DescriC "" DescriC
    regsub -all {\)} $DescriC "" DescriC
    #Espionne "DescriC= $DescriC"
    set LesDescriC [split $DescriC ","]
    foreach LeDescriC $LesDescriC {
	lappend LesGeneNames $LeDescriC
    }

    if {$LesGeneNames == {} } { return "" }

    set LesGeneNames [ListeSsElmtVide $LesGeneNames]
    set LesGeneNames [ListeSansDoublon $LesGeneNames NoCase]
    #Espionne "lesgenenames=$LesGeneNames"

    foreach GN $LesGeneNames {
	if {[regexp {^Neo} $GN]} {continue}
	#if {[regexp {^RA} $GN]} {continue}
	#Espionne "GN $GN"
	set LesNMs [RefLinkUcscMouse $GN NM]
	#Espionne "LesNMs $LesNMs"
	
	if {$LesNMs!=""} {
	    #Espionne "1"
	    set ListeNm [split $LesNMs " "]
	    foreach ChaqueNM $ListeNm {
		set GenreChaqueNM [OrgDuNmOuGb $ChaqueNM]
		#Espionne "$ChaqueNM $GenreChaqueNM"
		if {[regexp {^Mus} $GenreChaqueNM]} {
		    #Espionne "ChaqueNM $ChaqueNM"
		    LConcat LesNMsDeLaLigne $ChaqueNM
		    if { ![regexp {^NM_} $ChaqueNM] || ![regexp {^XM_} $ChaqueNM] || ![regexp {^NR_} $ChaqueNM] } {
			set mRNA1 [MrnaRefseqUcscMouse $ChaqueNM "Nm"]
			#Espionne "mRNA1 $mRNA1"
			if {$mRNA1 != ""} { 
			    #Espionne "un NM=$mRNA1 correspond a access $ChaqueNM"
			    set ListmRNA1 [split $mRNA1 " "]
			    foreach ChaqmRNA1 $ListmRNA1 {
				set GenreChaqmRNA1 [OrgDuNmOuGb $ChaqmRNA1]
				#Espionne "$ChaqmRNA1 $GenreChaqmRNA1"
				if {[regexp {^Mus} $GenreChaqmRNA1]} { 
				    #Espionne "ChaqmRNA1 $ChaqmRNA1"
				    LConcat LesNMsDeLaLigne $ChaqmRNA1
				}
			    }
			}
		    }
		}
	    }
	}
	set LesNMs2 [RefGeneUcscMouse $GN Name]
	#Espionne "LesNMs2 $LesNMs2"
	if {$LesNMs2!=""} {
	    #Espionne "2"
	    set ListeNm2 [split $LesNMs2 " "]
	    foreach ChaqueNM2 $ListeNm2 {
		set GenreChaqueNM2 [OrgDuNmOuGb $ChaqueNM2]
		#Espionne "$ChaqueNM2 $GenreChaqueNM2"
		if {[regexp {^Mus} $GenreChaqueNM2]} {
		    #Espionne "ChaqueNM2 $ChaqueNM2"
		    LConcat LesNMsDeLaLigne $ChaqueNM2
		    if { ![regexp {^NM_} $ChaqueNM2] || ![regexp {^XM_} $ChaqueNM2] || ![regexp {^NR_} $ChaqueNM2] } {
			set mRNA12 [MrnaRefseqUcscMouse $ChaqueNM2 "Nm"]
			#Espionne "mRNA12 $mRNA12"
			if {$mRNA12 != ""} { 
			    #Espionne "un NM=$mRNA12 correspond a access $ChaqueNM2"
			    set ListmRNA12 [split $mRNA12 " "]
			    foreach ChaqmRNA12 $ListmRNA12 {
				set GenreChaqmRNA12 [OrgDuNmOuGb $ChaqmRNA12]
				#Espionne "$ChaqmRNA12 $GenreChaqmRNA12"
				if {[regexp {^Mus} $GenreChaqmRNA12]} { 
				    #Espionne "ChaqmRNA12 $ChaqmRNA12"
				    LConcat LesNMsDeLaLigne $ChaqmRNA12
				}
			    }
			}
		    }
		}
	    }
	}
	#Espionne "GN2 $GN"
	set Commande1 "getz \"\(\(\\\[refseq-Gene:$GN\\\] > parent\) \& \\\[refseq-Organism:mus musculus\\\]\)\" \-f acc"
	set GetzOut1 [eval exec $Commande1]
	set LesLignes1 [split $GetzOut1 "\n"]
	foreach Ligne1 $LesLignes1 {
	    #Espionne "Ligne1 $Ligne1"
	    if {![regexp {^ACCESSION} $Ligne1]} {
		continue
	    } else {
		scan $Ligne1 "%s %s" bidon Acc1
		if {[regexp {^NW} $Acc1] || [regexp {^NT} $Acc1] || [regexp {^NC} $Acc1]} {
		    continue
		} else {
		    #Espionne "Acc1 $Acc1"
		    LConcat LesNMsDeLaLigne $Acc1
		}
	    }
	}
	#Espionne "GN3 $GN"
	set Commande2 "getz \"\(\(\\\[genbankfull-Gene:$GN\\\] > parent\) \& \\\[genbankfull-Organism:mus musculus\\\]\)\" \-f acc"
	set GetzOut2 [eval exec $Commande2]
	set LesLignes2 [split $GetzOut2 "\n"]
	foreach Ligne2 $LesLignes2 {
	    #Espionne "Ligne2 $Ligne2"
	    if {![regexp {^ACCESSION} $Ligne2]} {
		continue
	    } else {
		scan $Ligne2 "%s %s" bidon Acc2
		#Espionne "Acc2 $Acc2"
		LConcat LesNMsDeLaLigne $Acc2
		set mRNA [MrnaRefseqUcscMouse $Acc2 "Nm"]
		if {$mRNA != ""} { 
		    #Espionne "un NM=$mRNA correspond a access $Acc2"
		    set ListmRNA [split $mRNA " "]
		    foreach ChaqmRNA $ListmRNA {
			set GenreChaqmRNA [OrgDuNmOuGb $ChaqmRNA]
			#Espionne "$ChaqmRNA $GenreChaqmRNA"
			if {[regexp {^Mus} $GenreChaqmRNA]} { 
			    #Espionne "ChaqmRNA $ChaqmRNA"
			    LConcat LesNMsDeLaLigne $ChaqmRNA
			}
		    }
		} 
	    }
	}
    }
    set LesNMsDeLaLigne [ListeSansDoublon $LesNMsDeLaLigne]
    #Espionne $LesNMsDeLaLigne
    #set LesNMsDeLaLigne [join $LesNMsDeLaLigne " "]
    return $LesNMsDeLaLigne

}

proc AttriDesAcDnaParGeneName2 {} {

    set LesLignes [NomLigne ListeDes Lignes]
    foreach Ligne $LesLignes {
	set TousLesNoms  [NomLigne $Ligne Noms]
	set ListeDesNoms [split $TousLesNoms " "]
	foreach Nom $ListeDesNoms {
	    set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	    set LesLignes [LesLignesDuFichier $Fichier]
	    set premiereligne [lindex $LesLignes 0]
	    if {[regexp "bidon" $premiereligne]} {
		regsub "EVI" $Nom "" NomSsEvi
		set LesElmts [split $NomSsEvi ""]
		set NomSsEvi [string range $NomSsEvi 0 end-1]
		if {[lindex $LesElmts 0]=="0"} {
		    set NomSsEvi [string range $NomSsEvi 1 end]
		}
		lappend LesLignesBidons $NomSsEvi
	    }
	}
    }
    Espionne "$LesLignesBidons"

    foreach Ligne $LesLignesBidons {
	Espionne ""
	Espionne "$Ligne"
	set DescriC [RetChip5 $Ligne "description_customer"]
	set DescriM [RetChip5 $Ligne "description_memorec"]
	set LesNMsDeLaLigne {}
	set LesGeneNames {}
	set DescriMOri $DescriM
	set ListeNm {}; set ListmRNA {}; set ListmRNA1 {}
	set LesLignes1 {}; set LesLignes2 {}
	set LesNMs2 ""; set ListeNm2 {}; set mRNA12 {}; set ListmRNA12 {}
	Espionne "descrimori=$DescriMOri"
    
	set IPF [string first ")" $DescriM]
	if {$IPF>0} {
	    set DescriM [string range $DescriM 0 [incr IPF -1]]
	    regsub -all {[\(\:]} $DescriM " " DescriM
	    regsub -all -nocase { OR } $DescriM " " DescriM
	    set LesGeneNames [LesMotsDeLaLigne $DescriM]
	    set DescriM [string trim $DescriM]
	    Espionne "descrim=$DescriM" 
	}
	scan $DescriC "%s" DescriC
	set DescriC [string trim $DescriC]
	regsub -all {\(} $DescriC "" DescriC
	regsub -all {\)} $DescriC "" DescriC
	Espionne "DescriC= $DescriC"
	set LesDescriC [split $DescriC ","]
	foreach LeDescriC $LesDescriC {
	    lappend LesGeneNames $LeDescriC
	}
	
	if {$LesGeneNames == {} } { 
	    Espionne "pas de genename" 
	    continue
	}
	
	set LesGeneNames [ListeSsElmtVide $LesGeneNames]
	set LesGeneNames [ListeSansDoublon $LesGeneNames NoCase]
	Espionne "lesgenenames=$LesGeneNames"
	
	foreach GN $LesGeneNames {
	    if {[regexp {^Neo} $GN]} {continue}
	    Espionne "GN $GN"
	    set Commande1 "getz \"\(\\\[refseq-AllText:$GN\\\] \& \\\[refseq-Organism:mus musculus\\\]\)\" \-f acc"
	    set GetzOut1 [eval exec $Commande1]
	    Espionne "GetzOut1 $GetzOut1"
	    set LesLignes1 [split $GetzOut1 "\n"]
	    foreach Ligne1 $LesLignes1 {
		#Espionne "Ligne1 $Ligne1"
		if {![regexp {^ACCESSION} $Ligne1]} {
		    continue
		} else {
		    scan $Ligne1 "%s %s" bidon Acc1
		    if {[regexp {^NW} $Acc1] || [regexp {^NT} $Acc1] || [regexp {^NC} $Acc1]} {
			continue
		    } else {
			#Espionne "Acc1 $Acc1"
			LConcat LesNMsDeLaLigne $Acc1
		    }
		}
	    }
	    set Commande2 "getz \"\(\\\[genbankfull-AllText:$GN\\\] \& \\\[genbankfull-Organism:mus musculus\\\]\)\" \-f acc"
	    set GetzOut2 [eval exec $Commande2]
	     Espionne "GetzOut2 $GetzOut2"
	    set LesLignes2 [split $GetzOut2 "\n"]
	    foreach Ligne2 $LesLignes2 {
		#Espionne "Ligne2 $Ligne2"
		if {![regexp {^ACCESSION} $Ligne2]} {
		    continue
		} else {
		    scan $Ligne2 "%s %s" bidon Acc2
		    #Espionne "Acc2 $Acc2"
		    LConcat LesNMsDeLaLigne $Acc2
		    set mRNA [MrnaRefseqUcscMouse $Acc2 "Nm"]
		    if {$mRNA != ""} { 
			Espionne "un NM=$mRNA correspond a access $Acc2"
			set ListmRNA [split $mRNA " "]
			foreach ChaqmRNA $ListmRNA {
			    set GenreChaqmRNA [OrgDuNmOuGb $ChaqmRNA]
			  #  Espionne "$ChaqmRNA $GenreChaqmRNA"
			    if {[regexp {^Mus} $GenreChaqmRNA]} { 
				#Espionne "ChaqmRNA $ChaqmRNA"
				LConcat LesNMsDeLaLigne $ChaqmRNA
			    }
			}
		    } 
		}
	    }
	    Espionne "Chez Homme"
	    set Commande3 "getz \"\(\(\\\[refseq-Gene:$GN\\\] > parent\) \& \\\[refseq-Organism:mus musculus\\\]\)\" \-f acc"
	    set GetzOut3 [eval exec $Commande3]
	    Espionne "GetzOut3 $GetzOut3"
	    
	    set Commande4 "getz \"\(\(\\\[genbankfull-Gene:$GN\\\] > parent\) \& \\\[genbankfull-Organism:mus musculus\\\]\)\" \-f acc"
	    set GetzOut4 [eval exec $Commande4]
	    Espionne "GetzOut4 $GetzOut4"
	    
	    set Commande5 "getz \"\(\\\[refseq-AllText:$GN\\\] \& \\\[refseq-Organism:homo sapiens\\\]\)\" \-f acc"
	    set GetzOut5 [eval exec $Commande5]
	    Espionne "GetzOut5 $GetzOut5"
	    
	    set Commande6 "getz \"\(\\\[genbankfull-AllText:$GN\\\] \& \\\[genbankfull-Organism:homo sapiens\\\]\)\" \-f acc"
	    set GetzOut6 [eval exec $Commande6]
	    Espionne "GetzOut6 $GetzOut6"
	    
	}
	set LesNMsDeLaLigne [ListeSansDoublon $LesNMsDeLaLigne]
	set LesNMsDeLaLigne [join $LesNMsDeLaLigne " "]
	Espionne $LesNMsDeLaLigne
    }

}

proc AttriDesAcDnaParGeneName_AEffacer {DescriC DescriM} {
  
    set LesNMsDeLaLigne {}
    set LesGeneNameMemorec {}
    set DescriMOri $DescriM
   # Espionne "descrimori=$DescriMOri"

    set IPF [string first ")" $DescriM]
    if {$IPF>0} {
	set DescriM [string range $DescriM 0 [incr IPF -1]]
	regsub -all {[\(\:]} $DescriM " " DescriM
	regsub -all -nocase { OR } $DescriM " " DescriM
	set LesGeneNameMemorec [LesMotsDeLaLigne $DescriM]
	#Espionne "descrim=$DescriM" 
	#Espionne "lesgenenamememorec=$LesGeneNameMemorec"
    }
    if {$LesGeneNameMemorec != {}} {
	foreach GN $LesGeneNameMemorec {
	    set LesNMs [RefLinkUcscMouse $GN NM]
	    #puts "++$LesNMs"
	    LConcat LesNMsDeLaLigne $LesNMs
	}
    }
    scan $DescriC "%s" DescriC
    #Espionne "descriC=$DescriC"
    if {$DescriC != ""} {
	set LesNMs [RefLinkUcscMouse $DescriC NM] 
	#puts "--$LesNMs"
	LConcat LesNMsDeLaLigne $LesNMs
    }
    set LesNMsDeLaLigne [ListeSansDoublon $LesNMsDeLaLigne]
    set LesNMsDeLaLigne [join $LesNMsDeLaLigne " "]
    return $LesNMsDeLaLigne

}

proc AttriDesAcDnaParProt {AC} {

    set LesAccDeLaLigne ""
    set IdLu [IdDuProt $AC]
    set Nm [LocUcsc $IdLu]
    #Espionne "$AC $IdLu nm=$Nm"

    if { $Nm=="" } { 
	#Espionne "pas d'accessnm"
	set retour ""
    }

    if { $Nm!="" } {
	set ListNm [split $Nm " "]
	foreach ChaqNm $ListNm {
	    if { [regexp {^NM_} $ChaqNm] || [regexp {^XM_} $ChaqNm] || [regexp {^NR_} $ChaqNm] } {
		#Espionne "cet acc=$ChaqNm a deja un numero nm"
		set GenreChaqNm [OrgDuNmOuGb $ChaqNm]
		#Espionne "GenreChaqNm= $GenreChaqNm"
		if {[regexp {^Mus} $GenreChaqNm]} { 
		    #Espionne "ChaqNm $ChaqNm"
		    LConcat LesAccDeLaLigne $ChaqNm 
		}
	    } else {
		#Espionne "chaqnm=$ChaqNm"
		LConcat LesAccDeLaLigne $ChaqNm
		set mRNA [MrnaRefseqUcscMouse $ChaqNm "Nm"]
		if {$mRNA != ""} { 
		    #Espionne "un NM=$mRNA correspond a access $ChaqNm"
		    set ListmRNA [split $mRNA " "]
		    foreach ChaqmRNA $ListmRNA {
			set GenreChaqmRNA [OrgDuNmOuGb $ChaqmRNA]
			if {[regexp {^Mus} $GenreChaqmRNA]} { 
			    #Espionne "ChaqmRNA $ChaqmRNA"
			    LConcat LesAccDeLaLigne $ChaqmRNA 
			}
		    }
		}
	    }
	}
	set LesAccDeLaLigne [ListeSansDoublon $LesAccDeLaLigne]
	set LesAccDeLaLigne [join $LesAccDeLaLigne " "]
	set retour $LesAccDeLaLigne
    }
    return $retour

}

proc AttriDesAcDnaParProt_AEffacer {AC} {

    #puts "acess=$AC"
    set IdLu [IdDuProt $AC]
    #puts "idlu=$IdLu"
    set Nm [LocUcsc $IdLu]
    #puts "nm=$Nm"

    if { $Nm=="" } { 
	#puts "pas d'accessnm"
	set retour ""
    }

    if { $Nm!="" } {
	set ListNm [split $Nm " "]
	foreach ChaqNm $ListNm {
	    if { [regexp {^NM_} $ChaqNm] } {
		#puts "cet acc=$ChaqNm a deja un numero nm"
		LConcat LesAccDeLaLigne $ChaqNm
	    } else {
		#puts "chaqnm=$ChaqNm"
		LConcat LesAccDeLaLigne $ChaqNm
		set mRNA [MrnaRefseqUcscMouse $ChaqNm "Nm"]
		if {$mRNA != ""} { 
		    #puts "un NM=$mRNA correspond a access $ChaqNm"
		    set ListmRNA [split $mRNA " "]
		    foreach ChaqmRNA $ListmRNA {
			LConcat LesAccDeLaLigne $ChaqmRNA
		    }
		}
	    }
	}
	set LesAccDeLaLigne [ListeSansDoublon $LesAccDeLaLigne]
	set LesAccDeLaLigne [join $LesAccDeLaLigne " "]
	set retour $LesAccDeLaLigne
    }
    return $retour

}

proc AttriDesAcDna_AEffacer {} {

    set A 0
    set B 0
    set C 0
    set Pr 0
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	set jaitrouve 0 
	set genenamefait 0
	set AccDna ""
	set LAccDna {}
	set LesAccDna {}

	if { [regexp {^RA[0-9]+} $Des1] } { continue }
	if { [regexp {\?} $Ac1] } { continue }
	

	if { $Ac1!="" } {
	    incr A
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 =>$A"

	    if {$Ac2==""} {
		incr B
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    puts "pour $I, prend Ac1=$Ac1 et NM=$NM (A)"
			} else { puts "pour $I, prend Ac1=$Ac1 (Abis)" }
		    } else { puts "pour $I, prend Ac1=$Ac1 (B)" }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    incr Pr
		    puts "pour ligne $I, travail sur prot Ac3=$Ac3 Ac4=$Ac4=>$Pr (C)"
		    
		    if { [regexp "," $Ac3] } {puts "attention le prog ne prend pas en compte ce cas"}

		    set GenreP3 [OrgDuProt [string trim $Ac3]]
		    
		    if { $GenreP3 == "" } { 
			#jamais ce cas
			puts "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} { puts "dois prendre la def" }
			if {$Ac4 != ""} { puts "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    #cherche nm de prot_acc_piqor
			    if { [regexp "," $Ac4] } {puts "attention2 le prog ne prend pas en compte ce cas"}
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} { 
				    puts "pour $I, prend accdna=$AccDna (D)"
				    set LAccDna [split $AccDna " "]
				    foreach Q $LAccDna {LConcat LesAccDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4] 
				    if {$AccDna!=""} { 
					puts "pour $I, prend accdna=$AccDna (E)"
					set LAccDna [split $AccDna " "]
					foreach S $LAccDna {LConcat LesAccDna $S} 
				    }
				}
			    }
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Ebis)"
			} else {
			    set genenamefait 1
			    #voir avec la def
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (F)" }
			}
			if {$genenamefait == 0 && $AccDna == ""} {
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (G)" }
			}
			if {$AccDna == ""} {
			    puts "pas d'acccess"
			    lappend LesLignesPauvres $I
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    #jamais ce cas
			    set AccsProt "$Ac3,$Ac4"
			    puts "acess prot=$AccsProt"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				#recupere nm
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    puts "chaqueaccprot=$ChaqueAccProt a acc dna $AccDna (H)"
				    set LAccDna [split $AccDna " "]
				    foreach Q $LAccDna {LConcat LesAccDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					puts "pour $I, prend accdna=$AccDna (I)" 
					set LAccDna [split $AccDna " "]
					foreach S $LAccDna {LConcat LesAccDna $S} 
				    }
				}
			    } 
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Ibis)"
			} else {
			    #recupere que prot_acc 
			    set AccDna [AttriDesAcDnaParProt $Ac3]
			    if {$AccDna!=""} { 
				puts "pour $I, prend accdna=$AccDna (J)" 
				set LAccDna [split $AccDna " "]
				foreach Q $LAccDna {LConcat LesAccDna $Q} 
			    }
			    if {$AccDna==""} {  
				set AccDna [AttriDesAcDnaParGb $Ac3] 
				if {$AccDna!=""} { 
				    puts "pour $I, prend accdna=$AccDna (K)" 
				    set LAccDna [split $AccDna " "]
				    foreach S $LAccDna {LConcat LesAccDna $S}  
				}
			    }
			    set LesAccDna [lsort -unique $LesAccDna]
			    set LesAccDna [join $LesAccDna " "]
			    puts "pour $I, prend accdna=$LesAccDna (Kbis)"
			}
			if {$AccDna == ""} {
			    set AccDna [AttriDesAcDnaParGeneName $Des1 $Des2]
			    if {$AccDna!=""} { puts "pour $I, prend accdna=$AccDna (L)" }
			}
			if {$AccDna == ""} {
			    puts "pas d'access"
			    lappend LesLignesPauvres $I
			}
		    }
		}
	    }

	    if {$Ac2!=""} {
		incr C

		if { $Ac1==$Ac2 } {
		    puts "pour $I, prend refseq=$Ac2 (meme numero dans DNA_acc et refseq)(1)"
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    puts "pour $I, prend refseq=$Ac2 (meme numero dans DNA_acc et refseq)(2)"
			    set jaitrouve 1
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 et NM=$NM (3)"
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc2 $ListeNM]
				set Tout [lsort -unique $Tout]
				puts "pour $I, prend Ac1=$Ac1 et Ac2+NM=$Tout (3bis)"
			    } else { puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 (4)" }
			} else { puts "pour $I, prend Ac1=$Ac1 et Ac2=$Ac2 (5)" }
		    }

		    if {[regexp {^Homo$} $Genre]} {
			puts "pour $I, prend que refseq=$Ac2 (6)"
		    }
		}
	    }
	}
    }
    foreach LignePauvre $LesLignesPauvres { puts "lignepauvre=$LignePauvre" }
    set nbdepauvre [llength $LesLignesPauvres]
    Espionne "nbdepauvre=$nbdepauvre"
    Espionne "$Pr=nb de ligne ou on se sert de la prot"
    Espionne "$A=nb de ligne ac dna_acc"
    Espionne "$B=nb de ligne ac dna_acc et ss refseq_piqor"
    Espionne "$C=nb de ligne ac dna_acc et ac refseq_piqor"

}

proc AttriDesSsDnaAcProt {} {

#pour prot_acc_piqor tous sont souris
    set W 0; set K 0; set J 0
    set pauv 0
    set accpauv 0
    set mixte 0
    set refseq 0
    set genbank 0
    set vraimentpauv 0
    set F 0

    foreach I [RetChip5 ListOf Index] { 
	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "refseq_PIQOR"]
	set Ac2 [RetChip5 $I "DNA_acc"]
	set Ac3 [RetChip5 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip5 $I "prot_acc"]

	set jaitrouvemixte 0
	set ListProt {}
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set G 0
	set pastrouveprtsaccprot 0

	if {$Ac1=="" && $Ac2==""} {

	    if {$Ac3!="" && $Ac4!=""} { 
		set Ac "$Ac3,$Ac4"
		set ListProt [split $Ac ","]
		set ListProt [lsort -unique $ListProt]
		foreach Prot $ListProt {
		    set IdLu1 [IdDuProt $Prot]
		    set NM [LocUcsc $IdLu1]
		    LConcat LesIdsDeLaLigne $IdLu1
		    LConcat LesNmsDeLaLigne $NM  
		}
		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		puts "2col=>ligne=$I Accs=$Ac3 et $Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne"
		continue
	    }

	    if {$Ac3!=""} {		
		incr W
		Espionne "\n$Ac3 de la ligne $I (col prot_acc_piqor)=>$W"
		if {[regexp "," $Ac3]} {incr K} else {incr J}
		set SesAcs [split $Ac3 ","]
		foreach Ac $SesAcs {
		    set IdLu2 ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    set IdLu2 [IdDuProt $Ac]
		    LConcat LesIdsDeLaLigne $IdLu2
		    if {$IdLu2 == ""} { 
			puts "ligne=$I Acc=$Ac3 Id=PAS FICHES" 
			set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
			LConcat LesNmsDeLaLigne $NM 
			LConcat LesmRNADeLaLigne $mRNA
			LConcat LesAcsGbDeLaLigne $AcGb	
			LConcat LesmRNAGbDeLaLigne $mRNAGb
			continue
		    }
		    set NM [LocUcsc $IdLu2]
		    if {$NM!=""} {
			set ListNM [split $NM " "]
			foreach ChaqNM $ListNM {
			    LConcat LesNmsDeLaLigne $ChaqNM 
			    if { ![regexp {^NM_} $ChaqNM] } { 
				set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
				if {$mRNA != ""} { 
				    puts "un NM=$mRNA correspond a access chaqnm=$ChaqNM"
				    set ListemRNA [split $mRNA " "]
				    foreach ChaqmRNA $ListemRNA {
					LConcat LesmRNADeLaLigne $ChaqmRNA
				    }	
				}
			    }
			}
		    } 
		    if {$NM==""} {
			set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
			set GetzOut [eval exec $Commande]
			if {$GetzOut == ""} { 
			    puts "ligne=$I Acc=$Ac getzout=vide pas fiche ou pas mrna" 
			}
			if {$GetzOut != ""} {
			    incr G; incr F
			    puts "ligne=$I Acc=$Ac3 getzout=$GetzOut"
			    set LesLignesDeGetzOut [split $GetzOut "\n"]
	    		    foreach LigneDeGetzOut $LesLignesDeGetzOut {
				set Ref ""
				set AcGb ""
				scan $LigneDeGetzOut "%s %s" Ref AcGb
				puts "acgb=$AcGb"
				LConcat LesAcsGbDeLaLigne $AcGb	
				set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
				if {$mRNAGb != ""} { 
				    puts "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
				    set ListemRNAGb [split $mRNAGb " "]
				    foreach ChaqmRNAGb $ListemRNAGb {
					LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				    }
				} 
			    }
			}
		    }
		    if { $NM=="" && $AcGb=="" } {
			incr accpauv
			puts "cet access_prot n'a pas d'access_mrna" 
			lappend LesAccsPauvres $Ac
		    }
		}
		
		if { [llength $SesAcs] != [llength $LesIdsDeLaLigne] } { 
		    puts "tous les access n'ont pas d'ID"
		    #ok 
		}
		if { $LesNmsDeLaLigne != {} && [llength $LesIdsDeLaLigne] > [llength $LesNmsDeLaLigne] } {
		    puts "attention certn id correspondent pas a un nm"
		    #ok
		}
		if { $LesNmsDeLaLigne == {} && $LesAcsGbDeLaLigne != {} &&  [llength $SesAcs] > [llength $LesAcsGbDeLaLigne] } {
		    set pastrouveprtsaccprot 1
		    #ligne 507
		    puts "attention certn acc_prot correspondent pas a un gb"
		}
 
		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
		set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
		set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

		if { [llength $LesIdsDeLaLigne] > 1 } { puts "plus d'un id" }

		if { $LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {} } {
		    incr mixte
		    set jaitrouvemixte 1 
		    if { $LesmRNADeLaLigne != {} || $LesmRNAGbDeLaLigne !={} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne" 
			puts "acgb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne"
		    } else {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne AcGb=$LesAcsGbDeLaLigne"
		    } 
		}

		if { ! $jaitrouvemixte && $LesNmsDeLaLigne != {} } {
		    incr refseq
		    if { $LesmRNADeLaLigne != {} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne"
		    } else {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne"
		    }
		}

		if { ! $jaitrouvemixte && $LesAcsGbDeLaLigne != {} } {
		    incr genbank
		    if { $pastrouveprtsaccprot } {
			set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			if { $LesAcsParGNDeLaLigne=={} } {
			    if {$LesmRNAGbDeLaLigne !={}} {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (1)"
			    } else {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (2)"
			    }
			}
			if { $LesAcsParGNDeLaLigne!={} } {
			    if {$LesmRNAGbDeLaLigne !={}} {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (3)"
			    } else {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (4)"
			    }
			}
		    }
		    if { ! $pastrouveprtsaccprot } {
			if {$LesmRNAGbDeLaLigne !={}} {
			    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (5)"
			} else {
			    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (6)"
			}
		    }
		}

		if { $LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={} } {
		    incr pauv
		    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne pas d'access"
		    lappend LesLignesPauvres "ligne=$I access=$Ac3"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauv
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne vraiment pas d'access"
			lappend LesLignesVraimentPauvres "ligne=$I access=$Ac3"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne"
		    }
		}
	    }
	}
    }
    Espionne "\n$W=nombre de lignes avec access prot ds col prot_acc_piqor"
    Espionne "$K=nombre qui ont pls access ds col prot_acc_piqor"
    Espionne "$J=nombre qui ont un access ds col prot_acc_piqor\n"

    Espionne "$accpauv=nb d'acc_prot sans access_mrna"
    Espionne "$mixte=nb de lignes ac mrna_refseq et ac mrna_genbank"
    Espionne "$refseq=nb de lignes ac mrna_refseq"
    Espionne "$genbank=nb de lignes ac mrna_genbank"
    Espionne "$pauv=nb de lignes ou il y a aucun access_mrna qui correspond"
    Espionne "$vraimentpauv=nb de lignes ou il y a vraiment pas d'access_mrna\n"

    foreach x $LesLignesPauvres {puts "x=$x"}
    foreach y $LesLignesVraimentPauvres {puts "y=$y"}

}

proc AttriDesSsDnaAcProt2 {} {

#pour prot_acc dois prendre en compte que les souris
    set W 0
    set K 0
    set J 0
    set A 0
    set B 0
    set Z 0
    set accpauv 0
    set mixte 0
    set refseq 0
    set genbank 0
    set pauv 0
    set vraimentpauv 0
    set pauvSsSouris 0
    set vraimentpauvSsSouris 0

    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "refseq_PIQOR"]
	set Ac2 [RetChip2 $I "DNA_acc"]
	set Ac4 [RetChip2 $I "prot_acc"]

	if { [regexp {^RA[0-9]+} $Des1] } { continue }
	if { [regexp {\?} $Ac4] } { continue }

	set jaitrouvemixte 0
	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set cont 0
	set LigneQueSouris 0
	set PauvSsSouris 0
	set SsFicheProt 0
	set dejafait1 0
	set dejafait2 0
	set vide 0

	if {$Ac1=="" && $Ac2==""} {

	    if {$Ac4!=""} {		
		incr W
		Espionne "\n$Ac4 de la ligne $I (col prot_acc)=>$W"

		if { [regexp "," $Ac4] } {
		    set pls 1 
		    incr K
		} else { 
		    incr J 
		}
		
		set SesAcs [split $Ac4 ","]
		foreach Ac $SesAcs {
		    set GenreLu ""; set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    set GenreLu [OrgDuProt $Ac]
		    if { $GenreLu == "" } { 
			puts "ligne=$I Acc=$Ac Id=PAS FICHES PROT"
			set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
			LConcat LesIdsDeLaLigne $IdLu
			LConcat LesNmsDeLaLigne $NM 
			LConcat LesmRNADeLaLigne $mRNA
			LConcat LesAcsGbDeLaLigne $AcGb	
			LConcat LesmRNAGbDeLaLigne $mRNAGb
			continue
		    }
		    if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
			if {! $pls} { 
			    incr Z
			    incr PasSouris
			    puts "$Ac4=pas souris=>$Z"
			    set cont 1; break
			}
			if {$pls} { 
			    incr PasSouris
			    puts "$Ac=pas souris passe suivant=>PasSouris=$PasSouris"
			    continue 
			}
		    }
		    
		    set IdLu [IdDuProt $Ac]
		    LConcat LesIdsDeLaLigne $IdLu
		    set NM [LocUcsc $IdLu]

		    if {$NM!=""} {
			set ListNM [split $NM " "]
			foreach ChaqNM $ListNM {
			    LConcat LesNmsDeLaLigne $ChaqNM 
			    if { ![regexp {^NM_} $ChaqNM] } { 
				set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
				if {$mRNA != ""} { 
				    puts "un NM=$mRNA correspond a access chaqnm=$ChaqNM"
				    set ListemRNA [split $mRNA " "]
				    foreach ChaqmRNA $ListemRNA {
					LConcat LesmRNADeLaLigne $ChaqmRNA
				    }	
				}
			    }
			}
		    } 
		    if {$NM==""} {
			set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
			set GetzOut [eval exec $Commande]
			if {$GetzOut == ""} { 
			    puts "ligne=$I Acc=$Ac getzout=PAS FICHES GB ou pas mrna" 
			}
			if {$GetzOut != ""} {
			    puts "ligne=$I Acc=$Ac getzout=$GetzOut"
			    set LesLignesDeGetzOut [split $GetzOut "\n"]
	    		    foreach LigneDeGetzOut $LesLignesDeGetzOut {
				set Ref ""
				set AcGb ""
				scan $LigneDeGetzOut "%s %s" Ref AcGb
				puts "acgb=$AcGb"
				LConcat LesAcsGbDeLaLigne $AcGb	
				set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
				if {$mRNAGb != ""} { 
				    puts "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
				    set ListemRNAGb [split $mRNAGb " "]
				    foreach ChaqmRNAGb $ListemRNAGb {
					LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				    }
				} 
			    }
			}
		    } 
		    if { $NM=="" && $AcGb=="" } {
			incr accpauv
			puts "cet access_prot n'a pas d'access_mrna"
			lappend LesAccsPauvres $Ac
			if {$pls} {incr vide}
		    }
		}

		if { [llength $SesAcs] == $PasSouris } {
		    puts "la ligne $I a que des access non souris"
		    set LigneQueSouris 1
		}
		if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		    puts "tous les access n'ont pas d'ID"
		    set SsFicheProt 1
		}
		if { $LesNmsDeLaLigne != {} && [llength $LesIdsDeLaLigne] > [llength $LesNmsDeLaLigne] } {
		    puts "attention certn id ne correspondent pas a un nm"
		    incr A
		}
		if { $LesNmsDeLaLigne == {} && $LesAcsGbDeLaLigne != {} && [llength $SesAcs] > [llength $LesAcsGbDeLaLigne] } {
		    puts "attention certn acc_prot correspondent pas a un gb"
		    incr B
		}

		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
		set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
		set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]
 
		if { [llength $LesIdsDeLaLigne] > 1 } { puts "plus d'un id" }

		if { $LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {} } {
		    incr mixte
		    set jaitrouvemixte 1 
		    if { $LesmRNADeLaLigne != {} || $LesmRNAGbDeLaLigne !={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne" 
			puts "acgb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (1)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne AcGb=$LesAcsGbDeLaLigne (2)"
		    } 
		}

		if { ! $jaitrouvemixte && $LesNmsDeLaLigne != {} } {
		    incr refseq
		    if { $LesmRNADeLaLigne != {} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne (3)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne (4)"
		    }
		}

		if { ! $jaitrouvemixte && $LesAcsGbDeLaLigne != {} } {
		    incr genbank
		    if {$LesmRNAGbDeLaLigne !={}} {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (5)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (6)"
		    }
		}

		if { $cont || $LigneQueSouris } {
		    set dejafait1 1
		    incr pauvSsSouris
		    puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'access souris (8)"
		    lappend LesLignesSsSouris "ligne=$I access=$Ac4"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauvSsSouris
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne vraiment pas d'access souris (8b)"
			lappend LesLignesVraimentSsSouris "ligne=$I access=$Ac4"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (8t)"
		    }
		}

		if { $LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={} } {
		    set dejafait2 1
		    incr pauv
		    puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'access (7)"
		    lappend LesLignesPauvres "ligne=$I access=$Ac4"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauv
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne vraiment pas d'access (7b)"
			lappend LesLignesVraimentPauvres "ligne=$I access=$Ac4"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (7t)"
		    }
		}

		if { !$dejafait1 && !$dejafait2 && $SsFicheProt } {
		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'autres infos pr cette ligne (9)"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (9b)"
		    }
		}

		if { !$dejafait1 && !$dejafait2 && !$SsFicheProt && $vide>0 } {
		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'autres infos pr cette ligne (10)"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (10b)"
		    }
		}
	    }
	}
    }
    Espionne "\n$W=nombre de lignes avec access prot ds col prot_acc"
    Espionne "$K=nombre qui ont pls access ds col prot_acc"
    Espionne "$J=nombre qui ont un access ds col prot_acc\n"

    Espionne "$Z=nombre de lignes avec UN access prot non souris"
    Espionne "$A=nombre de lignes ou certn id ne correspondent pas a un nm"
    Espionne "$B=nombre de lignes ou certn acc_prot na correspondent pas a un gb\n"

    Espionne "$accpauv=nb d'acc_prot sans access_mrna"
    Espionne "$mixte=nb de lignes ac mrna_refseq et ac mrna_genbank"
    Espionne "$refseq=nb de lignes ac mrna_refseq"
    Espionne "$genbank=nb de lignes ac mrna_genbank"
    Espionne "$pauv=nb de lignes ou il y a aucun access_mrna qui correspond"
    Espionne "$vraimentpauv=nb de lignes ou il y a vraiment pas d'access_mrna\n"
    foreach x $LesLignesPauvres {puts "x=$x"}
    foreach y $LesLignesVraimentPauvres {puts "y=$y"}
    Espionne "$pauvSsSouris=nb de lignes sans access souris"
    Espionne "$vraimentpauvSsSouris=nb de lignes ou il y a vraiment pas d'access souris"
    foreach v $LesLignesSsSouris {puts "v=$v"}
    foreach w $LesLignesVraimentSsSouris {puts "w=$w"}

}

proc AttriDesSsDnaAcProt2_AEffacer {} {

#pour prot_acc dois prendre en compte que les souris
    set W 0
    set K 0
    set J 0
    set A 0
    set B 0
    set Z 0
    set accpauv 0
    set mixte 0
    set refseq 0
    set genbank 0
    set pauv 0
    set vraimentpauv 0
    set pauvSsSouris 0
    set vraimentpauvSsSouris 0

    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "refseq_PIQOR"]
	set Ac2 [RetChip2 $I "DNA_acc"]
	set Ac4 [RetChip2 $I "prot_acc"]

	if { [regexp {^RA[0-9]+} $Des1] } { continue }
	if { [regexp {\?} $Ac4] } { continue }

	set jaitrouvemixte 0
	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set cont 0
	set LigneQueSouris 0
	set PauvSsSouris 0
	set SsFicheProt 0
	set dejafait1 0
	set dejafait2 0
	set vide 0

	if {$Ac1=="" && $Ac2==""} {

	    if {$Ac4!=""} {		
		incr W
		Espionne "\n$Ac4 de la ligne $I (col prot_acc)=>$W"

		if { [regexp "," $Ac4] } {
		    set pls 1 
		    incr K
		} else { 
		    incr J 
		}
		
		set SesAcs [split $Ac4 ","]
		foreach Ac $SesAcs {
		    set GenreLu ""
		    set IdLu ""
		    set NM ""
		    set mRNA ""
		    set AcGb ""
		    set mRNAGb ""

		    set GenreLu [OrgDuProt $Ac]

		    if { $GenreLu == "" } { 
			puts "ligne=$I Acc=$Ac Id=PAS FICHES PROT"
			set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
			LConcat LesIdsDeLaLigne $IdLu
			LConcat LesNmsDeLaLigne $NM 
			LConcat LesmRNADeLaLigne $mRNA
			LConcat LesAcsGbDeLaLigne $AcGb	
			LConcat LesmRNAGbDeLaLigne $mRNAGb
			continue
		    }
		    if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
			if {! $pls} { 
			    incr Z
			    incr PasSouris
			    puts "$Ac4=pas souris=>$Z"
			    set cont 1; break
			}
			if {$pls} { 
			    incr PasSouris
			    puts "$Ac=pas souris passe suivant=>PasSouris=$PasSouris"
			    continue 
			}
		    }
		    
		    set IdLu [IdDuProt $Ac]
		    LConcat LesIdsDeLaLigne $IdLu
		    set NM [LocUcsc $IdLu]

		    if {$NM!=""} {
			set ListNM [split $NM " "]
			foreach ChaqNM $ListNM {
			    LConcat LesNmsDeLaLigne $ChaqNM 
			    if { ![regexp {^NM_} $ChaqNM] } { 
				set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
				if {$mRNA != ""} { 
				    puts "un NM=$mRNA correspond a access chaqnm=$ChaqNM"
				    set ListemRNA [split $mRNA " "]
				    foreach ChaqmRNA $ListemRNA {
					LConcat LesmRNADeLaLigne $ChaqmRNA
				    }	
				}
			    }
			}
		    } 
		    if {$NM==""} {
			set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
			set GetzOut [eval exec $Commande]
			if {$GetzOut == ""} { 
			    puts "ligne=$I Acc=$Ac getzout=PAS FICHES GB ou pas mrna" 
			}
			if {$GetzOut != ""} {
			    puts "ligne=$I Acc=$Ac getzout=$GetzOut"
			    set LesLignesDeGetzOut [split $GetzOut "\n"]
	    		    foreach LigneDeGetzOut $LesLignesDeGetzOut {
				set Ref ""
				set AcGb ""
				scan $LigneDeGetzOut "%s %s" Ref AcGb
				puts "acgb=$AcGb"
				LConcat LesAcsGbDeLaLigne $AcGb	
				set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
				if {$mRNAGb != ""} { 
				    puts "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
				    set ListemRNAGb [split $mRNAGb " "]
				    foreach ChaqmRNAGb $ListemRNAGb {
					LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				    }
				} 
			    }
			}
		    } 
		    if { $NM=="" && $AcGb=="" } {
			incr accpauv
			puts "cet access_prot n'a pas d'access_mrna"
			lappend LesAccsPauvres $Ac
			if {$pls} {incr vide}
		    }
		}

		if { [llength $SesAcs] == $PasSouris } {
		    puts "la ligne $I a que des access non souris"
		    set LigneQueSouris 1
		}
		if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		    puts "tous les access n'ont pas d'ID"
		    set SsFicheProt 1
		}
		if { $LesNmsDeLaLigne != {} && [llength $LesIdsDeLaLigne] > [llength $LesNmsDeLaLigne] } {
		    puts "attention certn id ne correspondent pas a un nm"
		    incr A
		}
		if { $LesNmsDeLaLigne == {} && $LesAcsGbDeLaLigne != {} && [llength $SesAcs] > [llength $LesAcsGbDeLaLigne] } {
		    puts "attention certn acc_prot correspondent pas a un gb"
		    incr B
		}

		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
		set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
		set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]
 
		if { [llength $LesIdsDeLaLigne] > 1 } { puts "plus d'un id" }

		if { $LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {} } {
		    incr mixte
		    set jaitrouvemixte 1 
		    if { $LesmRNADeLaLigne != {} || $LesmRNAGbDeLaLigne !={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne" 
			puts "acgb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (1)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne AcGb=$LesAcsGbDeLaLigne (2)"
		    } 
		}

		if { ! $jaitrouvemixte && $LesNmsDeLaLigne != {} } {
		    incr refseq
		    if { $LesmRNADeLaLigne != {} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne (3)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne (4)"
		    }
		}

		if { ! $jaitrouvemixte && $LesAcsGbDeLaLigne != {} } {
		    incr genbank
		    if {$LesmRNAGbDeLaLigne !={}} {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (5)"
		    } else {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (6)"
		    }
		}

		if { $cont || $LigneQueSouris } {
		    set dejafait1 1
		    incr pauvSsSouris
		    puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'access souris (8)"
		    lappend LesLignesSsSouris "ligne=$I access=$Ac4"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauvSsSouris
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne vraiment pas d'access souris (8b)"
			lappend LesLignesVraimentSsSouris "ligne=$I access=$Ac4"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (8t)"
		    }
		}

		if { $LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={} } {
		    set dejafait2 1
		    incr pauv
		    puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'access (7)"
		    lappend LesLignesPauvres "ligne=$I access=$Ac4"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauv
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne vraiment pas d'access (7b)"
			lappend LesLignesVraimentPauvres "ligne=$I access=$Ac4"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (7t)"
		    }
		}

		if { !$dejafait1 && !$dejafait2 && $SsFicheProt } {
		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'autres infos pr cette ligne (9)"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (9b)"
		    }
		}

		if { !$dejafait1 && !$dejafait2 && !$SsFicheProt && $vide>0 } {
		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne pas d'autres infos pr cette ligne (10)"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac4 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (10b)"
		    }
		}
	    }
	}
    }
    Espionne "\n$W=nombre de lignes avec access prot ds col prot_acc"
    Espionne "$K=nombre qui ont pls access ds col prot_acc"
    Espionne "$J=nombre qui ont un access ds col prot_acc\n"

    Espionne "$Z=nombre de lignes avec UN access prot non souris"
    Espionne "$A=nombre de lignes ou certn id ne correspondent pas a un nm"
    Espionne "$B=nombre de lignes ou certn acc_prot na correspondent pas a un gb\n"

    Espionne "$accpauv=nb d'acc_prot sans access_mrna"
    Espionne "$mixte=nb de lignes ac mrna_refseq et ac mrna_genbank"
    Espionne "$refseq=nb de lignes ac mrna_refseq"
    Espionne "$genbank=nb de lignes ac mrna_genbank"
    Espionne "$pauv=nb de lignes ou il y a aucun access_mrna qui correspond"
    Espionne "$vraimentpauv=nb de lignes ou il y a vraiment pas d'access_mrna\n"
    foreach x $LesLignesPauvres {puts "x=$x"}
    foreach y $LesLignesVraimentPauvres {puts "y=$y"}
    Espionne "$pauvSsSouris=nb de lignes sans access souris"
    Espionne "$vraimentpauvSsSouris=nb de lignes ou il y a vraiment pas d'access souris"
    foreach v $LesLignesSsSouris {puts "v=$v"}
    foreach w $LesLignesVraimentSsSouris {puts "w=$w"}

}

proc AttriDesSsDnaAcProt_AEffacer {} {

#pour prot_acc_piqor tous sont souris
    set W 0
    set K 0
    set J 0
    set pauv 0
    set accpauv 0
    set mixte 0
    set refseq 0
    set genbank 0
    set vraimentpauv 0

    set F 0
    foreach I [RetChip2 ListOf Index] { 
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "refseq_PIQOR"]
	set Ac2 [RetChip2 $I "DNA_acc"]
	set Ac3 [RetChip2 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip2 $I "prot_acc"]

	if { [regexp {^RA[0-9]+} $Des1] } { continue }

	set jaitrouvemixte 0
	set ListProt {}
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set G 0
	set pastrouveprtsaccprot 0

	if {$Ac1=="" && $Ac2==""} {

	    if {$Ac3!="" && $Ac4!=""} { 
		set Ac "$Ac3,$Ac4"
		set ListProt [split $Ac ","]
		set ListProt [lsort -unique $ListProt]
		foreach Prot $ListProt {
		    set IdLu1 [IdDuProt $Prot]
		    set NM [LocUcsc $IdLu1]
		    LConcat LesIdsDeLaLigne $IdLu1
		    LConcat LesNmsDeLaLigne $NM  
		}
		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		#puts "2col=>ligne=$I Accs=$Ac3 et $Ac4 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne"
		continue
	    }

	    if {$Ac3!=""} {		
		incr W
		Espionne "\n$Ac3 de la ligne $I (col prot_acc_piqor)=>$W"
		if {[regexp "," $Ac3]} {
		    incr K
		} else {
		    incr J
		}
		set SesAcs [split $Ac3 ","]
		foreach Ac $SesAcs {
		    set IdLu2 ""
		    set NM ""
		    set mRNA ""
		    set AcGb ""
		    set mRNAGb ""

		    set IdLu2 [IdDuProt $Ac]
		    LConcat LesIdsDeLaLigne $IdLu2
		    if { $IdLu2 == "" } { 
			puts "ligne=$I Acc=$Ac Id=PAS FICHES" 
			set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
			LConcat LesNmsDeLaLigne $NM 
			LConcat LesmRNADeLaLigne $mRNA
			LConcat LesAcsGbDeLaLigne $AcGb	
			LConcat LesmRNAGbDeLaLigne $mRNAGb
			continue
		    }
		    set NM [LocUcsc $IdLu2]
		    if {$NM!=""} {
			set ListNM [split $NM " "]
			foreach ChaqNM $ListNM {
			    LConcat LesNmsDeLaLigne $ChaqNM 
			    if { ![regexp {^NM_} $ChaqNM] } { 
				set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
				if {$mRNA != ""} { 
				    puts "un NM=$mRNA correspond a access chaqnm=$ChaqNM"
				    set ListemRNA [split $mRNA " "]
				    foreach ChaqmRNA $ListemRNA {
					LConcat LesmRNADeLaLigne $ChaqmRNA
				    }	
				}
			    }
			}
		    } 
		    if {$NM==""} {
			set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
			set GetzOut [eval exec $Commande]
			if {$GetzOut == ""} { 
			    puts "ligne=$I Acc=$Ac getzout=vide pas fiche ou pas mrna" 
			}
			if {$GetzOut != ""} {
			    incr G; incr F
			    puts "ligne=$I Acc=$Ac getzout=$GetzOut"
			    set LesLignesDeGetzOut [split $GetzOut "\n"]
	    		    foreach LigneDeGetzOut $LesLignesDeGetzOut {
				set Ref ""
				set AcGb ""
				scan $LigneDeGetzOut "%s %s" Ref AcGb
				puts "acgb=$AcGb"
				LConcat LesAcsGbDeLaLigne $AcGb	
				set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
				if {$mRNAGb != ""} { 
				    puts "un NM=$mRNAGb correspond a access AcGb=$AcGb" 
				    set ListemRNAGb [split $mRNAGb " "]
				    foreach ChaqmRNAGb $ListemRNAGb {
					LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				    }
				} 
			    }
			}
		    }
		    if { $NM=="" && $AcGb=="" } {
			incr accpauv
			puts "cet access_prot n'a pas d'access_mrna" 
			lappend LesAccsPauvres $Ac
		    }
		}
		
		if { [llength $SesAcs] != [llength $LesIdsDeLaLigne] } { 
		    puts "tous les access n'ont pas d'ID"
		    #ok 
		}
		if { $LesNmsDeLaLigne != {} && [llength $LesIdsDeLaLigne] > [llength $LesNmsDeLaLigne] } {
		    puts "attention certn id correspondent pas a un nm"
		    #ok
		}
		if { $LesNmsDeLaLigne == {} && $LesAcsGbDeLaLigne != {} &&  [llength $SesAcs] > [llength $LesAcsGbDeLaLigne] } {
		    set pastrouveprtsaccprot 1
		    #ligne 507
		    puts "attention certn acc_prot correspondent pas a un gb"
		}
 
		set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
		set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
		set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
		set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
		set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

		if { [llength $LesIdsDeLaLigne] > 1 } { puts "plus d'un id" }

		if { $LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {} } {
		    incr mixte
		    set jaitrouvemixte 1 
		    if { $LesmRNADeLaLigne != {} || $LesmRNAGbDeLaLigne !={} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne" 
			puts "acgb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne"
		    } else {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne AcGb=$LesAcsGbDeLaLigne"
		    } 
		}

		if { ! $jaitrouvemixte && $LesNmsDeLaLigne != {} } {
		    incr refseq
		    if { $LesmRNADeLaLigne != {} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne mRNA=$LesmRNADeLaLigne"
		    } else {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne NM=$LesNmsDeLaLigne"
		    }
		}

		if { ! $jaitrouvemixte && $LesAcsGbDeLaLigne != {} } {
		    incr genbank
		    if { $pastrouveprtsaccprot } {
			set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			if { $LesAcsParGNDeLaLigne=={} } {
			    if {$LesmRNAGbDeLaLigne !={}} {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (1)"
			    } else {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (2)"
			    }
			}
			if { $LesAcsParGNDeLaLigne!={} } {
			    if {$LesmRNAGbDeLaLigne !={}} {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (3)"
			    } else {
				puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne AcParGn=$LesAcsParGNDeLaLigne (4)"
			    }
			}
		    }
		    if { ! $pastrouveprtsaccprot } {
			if {$LesmRNAGbDeLaLigne !={}} {
			    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne mRNAGb=$LesmRNAGbDeLaLigne (5)"
			} else {
			    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcGb=$LesAcsGbDeLaLigne (6)"
			}
		    }
		}

		if { $LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={} } {
		    incr pauv
		    puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne pas d'access"
		    lappend LesLignesPauvres "ligne=$I access=$Ac3"

		    set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		    if { $LesAcsParGNDeLaLigne=={} } {
			incr vraimentpauv
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne vraiment pas d'access"
			lappend LesLignesVraimentPauvres "ligne=$I access=$Ac3"
		    }
		    if { $LesAcsParGNDeLaLigne!={} } {
			puts "ligne=$I Acc=$Ac3 Id=$LesIdsDeLaLigne AcParGn=$LesAcsParGNDeLaLigne"
		    }
		}
	    }
	}
    }
    Espionne "\n$W=nombre de lignes avec access prot ds col prot_acc_piqor"
    Espionne "$K=nombre qui ont pls access ds col prot_acc_piqor"
    Espionne "$J=nombre qui ont un access ds col prot_acc_piqor\n"

    Espionne "$accpauv=nb d'acc_prot sans access_mrna"
    Espionne "$mixte=nb de lignes ac mrna_refseq et ac mrna_genbank"
    Espionne "$refseq=nb de lignes ac mrna_refseq"
    Espionne "$genbank=nb de lignes ac mrna_genbank"
    Espionne "$pauv=nb de lignes ou il y a aucun access_mrna qui correspond"
    Espionne "$vraimentpauv=nb de lignes ou il y a vraiment pas d'access_mrna\n"

    foreach x $LesLignesPauvres {puts "x=$x"}
    foreach y $LesLignesVraimentPauvres {puts "y=$y"}

}

proc AttriDesSsDnaSsProt {} {

    set LaSortie {}
    set LesVides {}
    #set FichierLigne "[RepertoireDuGenome]/parser/ligssacc2" 
    #ac RA
    set FichierLigne "[RepertoireDuGenome]/parser/ligssacc2ssra"
    #ss RA 
    set LesLignes [LesLignesDuFichier $FichierLigne]
    foreach Ligne $LesLignes {
	Espionne "$Ligne"
#	if {$Ligne != 304 } {continue} 
	set LesNMsDeLaLigne {}
	set LesGeneNameMemorec {}
	set DescriM [RetChip2 $Ligne description_memorec]
	set DescriMOri $DescriM
	set IPF [string first ")" $DescriM]
	#Espionne $IPF
	if {$IPF>0} {
	    set DescriM [string range $DescriM 0 [incr IPF -1]]
	    regsub -all {[\(\:]} $DescriM " " DescriM
	    regsub -all -nocase { OR } $DescriM " " DescriM
	    set LesGeneNameMemorec [LesMotsDeLaLigne $DescriM]
	    #Espionne $DescriM 
	    #Espionne $LesGeneNameMemorec
	}
	if {$LesGeneNameMemorec != {}} {
	    foreach GN $LesGeneNameMemorec {
		set LesNMs [RefLinkUcscMouse $GN NM]
		puts "++$LesNMs"
		LConcat LesNMsDeLaLigne $LesNMs
	    }
	}
	set DescriC [RetChip2 $Ligne description_customer]
	scan $DescriC "%s" DescriC
	Espionne $DescriC
	if {$DescriC != ""} {
	    set LesNMs [RefLinkUcscMouse $DescriC NM] 
	    puts "--$LesNMs"
	    LConcat LesNMsDeLaLigne $LesNMs
	}
	set LesNMsDeLaLigne [ListeSansDoublon $LesNMsDeLaLigne]
	if {$LesNMsDeLaLigne=={}} { lappend LesVides "$Ligne $DescriMOri" ; continue }
	lappend LaSortie "$Ligne [join $LesNMsDeLaLigne " "] $DescriMOri "
    }
    set LongS [llength $LaSortie]
    set LongV [llength $LesVides]
    AfficheVariable [join $LesVides "\n"] "" "Vides"
    AfficheVariable [join $LaSortie "\n"]
    Espionne "longueur de LaSortie = $LongS"
    Espionne "longueur de LesVides = $LongV"
    #pas de puts dans commande dans ce cas

}

proc AttriDesSsDnaSsProt_AEffacer {} {

    set LaSortie {}
    set LesVides {}
    #set FichierLigne "[RepertoireDuGenome]/parser/ligssacc2" 
    #ac RA
    set FichierLigne "[RepertoireDuGenome]/parser/ligssacc2ssra"
    #ss RA 
    set LesLignes [LesLignesDuFichier $FichierLigne]
    foreach Ligne $LesLignes {
	Espionne "$Ligne"
#	if {$Ligne != 304 } {continue} 
	set LesNMsDeLaLigne {}
	set LesGeneNameMemorec {}
	set DescriM [RetChip2 $Ligne description_memorec]
	set DescriMOri $DescriM
	set IPF [string first ")" $DescriM]
	#Espionne $IPF
	if {$IPF>0} {
	    set DescriM [string range $DescriM 0 [incr IPF -1]]
	    regsub -all {[\(\:]} $DescriM " " DescriM
	    regsub -all -nocase { OR } $DescriM " " DescriM
	    set LesGeneNameMemorec [LesMotsDeLaLigne $DescriM]
	    #Espionne $DescriM 
	    #Espionne $LesGeneNameMemorec
	}
	if {$LesGeneNameMemorec != {}} {
	    foreach GN $LesGeneNameMemorec {
		set LesNMs [RefLinkUcscMouse $GN NM]
		puts "++$LesNMs"
		LConcat LesNMsDeLaLigne $LesNMs
	    }
	}
	set DescriC [RetChip2 $Ligne description_customer]
	scan $DescriC "%s" DescriC
	Espionne $DescriC
	if {$DescriC != ""} {
	    set LesNMs [RefLinkUcscMouse $DescriC NM] 
	    puts "--$LesNMs"
	    LConcat LesNMsDeLaLigne $LesNMs
	}
	set LesNMsDeLaLigne [ListeSansDoublon $LesNMsDeLaLigne]
	if {$LesNMsDeLaLigne=={}} { lappend LesVides "$Ligne $DescriMOri" ; continue }
	lappend LaSortie "$Ligne [join $LesNMsDeLaLigne " "] $DescriMOri "
    }
    set LongS [llength $LaSortie]
    set LongV [llength $LesVides]
    AfficheVariable [join $LesVides "\n"] "" "Vides"
    AfficheVariable [join $LaSortie "\n"]
    Espionne "longueur de LaSortie = $LongS"
    Espionne "longueur de LesVides = $LongV"
    #pas de puts dans commande dans ce cas

}

proc AttriTout {} {

    set total 0; set B 0; set C 0; set D 0; set E 0
    set LesLignesPauvres {}

    foreach I [RetChip5 ListOf Index] { 
	incr total
	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]
	set jaitrouvednaacc 0
	set jaitrouve 0
	set jaitrouveRA 0
	set jaitrouvegn 0
	set genenamefait 0
	set jaitrouveprot 0
	set LesGenresP3 {}
	set AccDna ""
	set ListeDesAcs {}
	set LesAcsDna {}

	set LesAcsDeLaLigne ""

	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set LesAcsParGNDeLaLigne ""
	set LesAcsDeLaLigneList {}
	set cont 0
	set LigneQueSouris 0
	set SsFicheProt 0
	set vide 0
	puts "Ac1 $Ac1 Ac2 $Ac2"
	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    puts "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set LesNMs [split $Ac2 ","]
	    foreach NM $LesNMs { 
		#set Commande "getz \"\(\\\[refseqrelease-acc:$NM\\\]\|\\\[refseqnew-acc:$NM\\\]\)\!\(\\\[refseqnew-acc:$NM\\\]>\\\[refseqrelease-acc:$NM\\\]\)\" \-view FastaSeqs"
		set Commande "getz \"\\\[refseq-acc:$NM\\\]\" \-view FastaSeqs" 
		set GetzOut [eval exec $Commande]
		if {$GetzOut == ""} { puts ">bidon ficherefseqpiqor n'existe plus\natgc" }
		if {$GetzOut != ""} { 
		    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
		    if { [regexp {^>ref.+>ref} $GetzOut] } {
			puts "ATTENTION AU - 2 SEQ FASTA"
		    }
		    puts $GetzOut
		}
	    }
	    continue
	}
	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set jaitrouvednaacc 1
	    incr C
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"

	    if {$Ac2==""} {
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    set LesAcsDeLaLigne "$Ac1 $NM"
			} else { 
			    set LesAcsDeLaLigne $Ac1
			}
		    } else { 
			set LesAcsDeLaLigne $Ac1
		    }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
		    
		    set LesAcs3 [split $Ac3 ","]
		    foreach ChaqAc3 $LesAcs3 {
			set GenreAc3 [OrgDuProt $ChaqAc3]
			LConcat LesGenresP3 $GenreAc3
		    }
		    set LesGenresP3 [lsort -unique $LesGenresP3]
		    if { [llength $LesGenresP3] > 1 } { puts "attention ilya pls genres pour cette ligne" }
		    set GenreP3 [join $LesGenresP3 " "]

		    if { $GenreP3 == "" } { 
			#jamais ce cas; je ne le traite pas
			#puts "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} { puts "dois prendre la def" }
			if {$Ac4 != ""} { puts "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} {  
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4]
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach T $ListeDesAcs {LConcat LesAcsDna $T} 
				    }
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set genenamefait 1
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
			if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    set AccsProt "$Ac3,$Ac4"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach S $ListeDesAcs {LConcat LesAcsDna $S} 
				    }
				}
			    } 
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set ListeAc3 [split $Ac3 ","]
			    foreach ChaqueAc3 $ListeAc3 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc3]
				if {$AccDna!=""} { 
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				} 
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc3] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "] 
					foreach S $ListeDesAcs {LConcat LesAcsDna $S}
				    }  
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]
			}
			if {$LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }
		}
	    }

	    if {$Ac2!=""} {

		if { $Ac1==$Ac2 } {
		    set LesAcsDeLaLigne $Ac2
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne $Ac2
			    set jaitrouve 1
			    break
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				set ListeAc1 [split $Ac1 ","]
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc1 $ListeAc2 $ListeNM]
				set Tout [ListeSansDoublon $Tout]
				set LesAcsDeLaLigne [join $Tout " "]
			    } else { 
				regsub -all "," $Ac2 " " Ac2
				set LesAcsDeLaLigne "$Ac1 $Ac2"
			    }
			} else { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne "$Ac1 $Ac2"
			}
		    }

		    if {[regexp {^Homo$} $Genre]} {
			regsub -all "," $Ac2 " " Ac2
			set LesAcsDeLaLigne $Ac2
		    }
		}
		#jaitrouve
	    }
	    #refseqpiqorpasvide
	}
	#dnaaccpas vide

	if { $Ac1=="" && $Ac2=="" && ($Ac3!="" || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    set jaitrouveprot 1
	    puts "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    
	    if { [regexp "," $Ac3] || [regexp "," $Ac4] } {
		set pls 1 
	    }
	    
	    set LesAcs3 [split $Ac3 ","]
	    set LesAcs4 [split $Ac4 ","]
	    set LesAcs3et4 [concat $LesAcs3 $LesAcs4]
	    set SesAcs [split $LesAcs3et4 " "]
	    foreach Ac $SesAcs {
		set GenreLu ""; set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""		
		set GenreLu [OrgDuProt $Ac]
		if { $GenreLu == "" } { 
		    set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    LConcat LesIdsDeLaLigne $IdLu
		    LConcat LesNmsDeLaLigne $NM 
		    LConcat LesmRNADeLaLigne $mRNA
		    LConcat LesAcsGbDeLaLigne $AcGb	
		    LConcat LesmRNAGbDeLaLigne $mRNAGb
		    continue
		}
		if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
		    if {! $pls} { 
			incr PasSouris
			set cont 1; break
		    }
		    if {$pls} { 
			incr PasSouris
			continue 
		    }
		}
		    
		set IdLu [IdDuProt $Ac]
		LConcat LesIdsDeLaLigne $IdLu
		set NM [LocUcsc $IdLu]

		if {$NM!=""} {
		    set ListNM [split $NM " "]
		    foreach ChaqNM $ListNM {
			LConcat LesNmsDeLaLigne $ChaqNM 
			if { ![regexp {^NM_} $ChaqNM] } { 
			    set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
			    if {$mRNA != ""} { 
				set ListemRNA [split $mRNA " "]
				foreach ChaqmRNA $ListemRNA {
				    LConcat LesmRNADeLaLigne $ChaqmRNA
				}	
			    }
			}
		    }
		} 
		if {$NM==""} {
		    set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut != ""} {
			set LesLignesDeGetzOut [split $GetzOut "\n"]
			foreach LigneDeGetzOut $LesLignesDeGetzOut {
			    set Ref ""
			    set AcGb ""
			    scan $LigneDeGetzOut "%s %s" Ref AcGb
			    LConcat LesAcsGbDeLaLigne $AcGb	
			    set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
			    if {$mRNAGb != ""} { 
				set ListemRNAGb [split $mRNAGb " "]
				foreach ChaqmRNAGb $ListemRNAGb {
				    LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				}
			    } 
			}
		    }
		} 
		if { $NM=="" && $AcGb=="" } {
		    if {$pls} {incr vide}
		}
	    }

	    if { [llength $SesAcs] == $PasSouris } {
		set LigneQueSouris 1
	    }
	    if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		set SsFicheProt 1
	    }

	    set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
	    set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
	    set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
	    set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
	    set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

	    if { ($cont || $LigneQueSouris) || ($LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={}) || ($SsFicheProt) || ($vide>0) } {
		set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne $LesAcsParGNDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    }

	    if { $LesNmsDeLaLigne != {} || $LesAcsGbDeLaLigne != {} || ($LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {}) } {
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    } 
		
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3]) && $Ac4==""} {
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    set jaitrouvegn 1
	    incr E
	    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
	}

	if {$jaitrouvednaacc || $jaitrouveprot || $jaitrouvegn} {
	    if {$LesAcsDeLaLigne != ""} {
		set ListeFinal [split $LesAcsDeLaLigne " "]
		foreach ChaqueFinal $ListeFinal {
		    set GetzOut ""
		    if { [regexp {^NM_} $ChaqueFinal] || [regexp {^NR_} $ChaqueFinal] } {
			set Commande "getz \"\(\\\[refseqrelease-acc:$ChaqueFinal\\\]\|\\\[refseqnew-acc:$ChaqueFinal\\\]\)\!\(\\\[refseqnew-acc:$ChaqueFinal\\\]>\\\[refseqrelease-acc:$ChaqueFinal\\\]\)\" \-view FastaSeqs"
			#set Commande "getz \"\\\[refseq-acc:$ChaqueFinal\\\]\" \-view FastaSeqs" 
			set GetzOut [eval exec $Commande]
			set GetzOut [string range $GetzOut [string last ">r" $GetzOut] end]
			if { [regexp {^>ref.+>ref} $GetzOut] } {
			    puts "ATTENTION AU - 2 SEQ FASTA"
			}
		    }  
		    if { ![regexp {^NM_} $ChaqueFinal] && ![regexp {^NR_} $ChaqueFinal] } {
			set Commande "getz \"\\\[genbankfull-acc:$ChaqueFinal\\\]\" \-view FastaSeqs" 
			set GetzOut [eval exec $Commande]
			if { [regexp {^>gen.+>gen} $GetzOut] } {
			    puts "ATTENTION AU - 2 SEQ FASTA"
			}
		    }
		    if {$GetzOut == ""} { puts ">bidon fichedna n'existe plus\natcg" }
		    if {$GetzOut != ""} { puts $GetzOut }
		}
	    }
	    if {$LesAcsDeLaLigne == ""} {
		puts ">bidon pas d'access\natcg"
		lappend LesLignesPauvres "$I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    }
	}
    }
    #foreach
    set NbPauvres [llength $LesLignesPauvres]
    lappend LesLignesPauvres "$NbPauvres = nb de ligne Pauvres"
    SauveLesLignes $LesLignesPauvres dans [RepertoireDuGenome]/fiches/LesLignesPauvres

    Espionne "$B =nb ac refseq_piqor ms pas dna_acc"
    Espionne "$C =nb ac dna_acc"
    Espionne "$D =nb ac prot"
    Espionne "$E =nb ac rien"

}

proc AttriToutAccess {} {
 
    set A 0; set B 0; set C 0; set D 0; set E 0
    set LesLignesPauvres {}
    foreach I [RetChip2 ListOf Index] {  
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1  [RetChip2 $I "DNA_acc"]
	set Ac2  [RetChip2 $I "refseq_PIQOR"]
	set Ac3  [RetChip2 $I "prot_acc"]
	set Ac4  [RetChip2 $I "prot_acc_PIQOR"]


	set jaitrouvednaacc 0
	set jaitrouve 0
	set jaitrouveRA 0
	set jaitrouvegn 0
	set genenamefait 0
	set jaitrouveprot 0
	set LesGenresP3 {}
	set AccDna ""
	set ListeDesAcs {}
	set LesAcsDna {}

	set LesAcsDeLaLigne ""

	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set LesAcsParGNDeLaLigne ""
	set LesAcsDeLaLigneList {}
	set cont 0
	set LigneQueSouris 0
	set SsFicheProt 0
	set vide 0

	if { [regexp {^RA[0-9]+} $Des1] } {
	   Espionne "ligne $I Des1=$Des1 Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    incr A
	    set RA1324 ""; set AccmRNA1 ""; set Genre1 ""; set AccmRNA2 ""; set Genre2 ""

	    set Fichier "/genomics/link/Ret1324/fiches/Orf2Cluster2Access2Def2Expression"
	    set LesLignes [LesLignesDuFichier $Fichier]

	    foreach Ligne $LesLignes {
		scan $Ligne "%s %s %s %s" RA1324 x y RA2717
		if {$Des1==$RA2717} {
		    set JaiTrouveCorresEntre1324Et2717 1
		   Espionne "RA1324=$RA1324"

		    if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]} {
			set LAcRa1 [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]
			scan $LAcRa1 "%s %s %s %s %s" x y AccmRNA1 z Genre1
		    }

		    set Fichier2 "/genomics/link/Ret1324/fiches/AccessDesProteinesEtDesmRNAsChoisis"
		    set LesLignes2 [LesLignesDuFichier $Fichier2]

		    foreach Ligne2 $LesLignes2 {
			scan $Ligne2 "%s %s %s %s" NumRA AccProt AccmRNA Genre
			if {$RA1324==$NumRA} {
			    set jaitrouvecorres 1
			    set AccmRNA2 $AccmRNA
			    set Genre2 $Genre
			    if {[string equal $AccmRNA2 "NomRNA"]} {
				set AccmRNA2 "" 
			    }
			    if {[string equal $Genre2 "NoOrganism"]} {
				set Genre2 "" 
			    }
			}
		    }
		    Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"
		}
	    }
	    if {!$JaiTrouveCorresEntre1324Et2717} { 
		Espionne "pas de corresp"
		Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"
	    }
	    continue
	}

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	   Espionne "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	   Espionne "LesAcsDeLaLigne= $Ac2"
	    continue
	}
	
	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set jaitrouvednaacc 1
	    incr C
	   Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2"

	    if {$Ac2==""} {
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    set LesAcsDeLaLigne "$Ac1 $NM"
			} else { 
			    set LesAcsDeLaLigne $Ac1
			}
		    } else { 
			set LesAcsDeLaLigne $Ac1
		    }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
		    
		    set LesAcs3 [split $Ac3 ","]
		    foreach ChaqAc3 $LesAcs3 {
			set GenreAc3 [OrgDuProt $ChaqAc3]
			lappend LesGenresP3 $GenreAc3
		    }
		    set LesGenresP3 [lsort -unique $LesGenresP3]
		    if { [llength $LesGenresP3] > 1 } {Espionne "attention ilya pls genres pour cette ligne" }
		    set GenreP3 [join $LesGenresP3 " "]

		    if { $GenreP3 == "" } { 
			#jamais ce cas; je ne le traite pas
			#Espionne "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} {Espionne "dois prendre la def" }
			if {$Ac4 != ""} {Espionne "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} {  
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4]
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach T $ListeDesAcs {LConcat LesAcsDna $T} 
				    }
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set genenamefait 1
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
			if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    set AccsProt "$Ac3,$Ac4"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach S $ListeDesAcs {LConcat LesAcsDna $S} 
				    }
				}
			    } 
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set ListeAc3 [split $Ac3 ","]
			    foreach ChaqueAc3 $ListeAc3 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc3]
				if {$AccDna!=""} { 
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				} 
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc3] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "] 
					foreach S $ListeDesAcs {LConcat LesAcsDna $S}
				    }  
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]
			}
			if {$LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }
		}
	    }

	    if {$Ac2!=""} {

		if { $Ac1==$Ac2 } {
		    set LesAcsDeLaLigne $Ac2
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne $Ac2
			    set jaitrouve 1
			    break
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				set ListeAc1 [split $Ac1 ","]
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc1 $ListeAc2 $ListeNM]
				set Tout [ListeSansDoublon $Tout]
				set LesAcsDeLaLigne [join $Tout " "]
			    } else { 
				regsub -all "," $Ac2 " " Ac2
				set LesAcsDeLaLigne "$Ac1 $Ac2"
			    }
			} else { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne "$Ac1 $Ac2"
			}
		    }

		    if {[regexp {^Homo$} $Genre]} {
			regsub -all "," $Ac2 " " Ac2
			set LesAcsDeLaLigne $Ac2
		    }
		}
		#jaitrouve
	    }
	    #refseqpiqorpasvide
	}
	#dnaaccpas vide

	if { $Ac1=="" && $Ac2=="" && ($Ac3!="" || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    set jaitrouveprot 1
	   Espionne "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    
	    if { [regexp "," $Ac3] || [regexp "," $Ac4] } {
		set pls 1 
	    }
	    
	    set LesAcs3 [split $Ac3 ","]
	    set LesAcs4 [split $Ac4 ","]
	    set LesAcs3et4 [concat $LesAcs3 $LesAcs4]
	    set SesAcs [split $LesAcs3et4 " "]
	    foreach Ac $SesAcs {
		set GenreLu ""
		set IdLu ""
		set NM ""
		set mRNA ""
		set AcGb ""
		set mRNAGb ""
		
		set GenreLu [OrgDuProt $Ac]
		
		if { $GenreLu == "" } { 
		    set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    LConcat LesIdsDeLaLigne $IdLu
		    LConcat LesNmsDeLaLigne $NM 
		    LConcat LesmRNADeLaLigne $mRNA
		    LConcat LesAcsGbDeLaLigne $AcGb	
		    LConcat LesmRNAGbDeLaLigne $mRNAGb
		    continue
		}
		if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
		    if {! $pls} { 
			incr PasSouris
			set cont 1; break
		    }
		    if {$pls} { 
			incr PasSouris
			continue 
		    }
		}
		    
		set IdLu [IdDuProt $Ac]
		LConcat LesIdsDeLaLigne $IdLu
		set NM [LocUcsc $IdLu]

		if {$NM!=""} {
		    set ListNM [split $NM " "]
		    foreach ChaqNM $ListNM {
			LConcat LesNmsDeLaLigne $ChaqNM 
			if { ![regexp {^NM_} $ChaqNM] } { 
			    set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
			    if {$mRNA != ""} { 
				set ListemRNA [split $mRNA " "]
				foreach ChaqmRNA $ListemRNA {
				    LConcat LesmRNADeLaLigne $ChaqmRNA
				}	
			    }
			}
		    }
		} 
		if {$NM==""} {
		    set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut != ""} {
			set LesLignesDeGetzOut [split $GetzOut "\n"]
			foreach LigneDeGetzOut $LesLignesDeGetzOut {
			    set Ref ""
			    set AcGb ""
			    scan $LigneDeGetzOut "%s %s" Ref AcGb
			    LConcat LesAcsGbDeLaLigne $AcGb	
			    set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
			    if {$mRNAGb != ""} { 
				set ListemRNAGb [split $mRNAGb " "]
				foreach ChaqmRNAGb $ListemRNAGb {
				    LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				}
			    } 
			}
		    }
		} 
		if { $NM=="" && $AcGb=="" } {
		    if {$pls} {incr vide}
		}
	    }

	    if { [llength $SesAcs] == $PasSouris } {
		set LigneQueSouris 1
	    }
	    if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		set SsFicheProt 1
	    }

	    set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
	    set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
	    set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
	    set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
	    set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

	    if { ($cont || $LigneQueSouris) || ($LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={}) || ($SsFicheProt) || ($vide>0) } {
		set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne $LesAcsParGNDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    }

	    if { $LesNmsDeLaLigne != {} || $LesAcsGbDeLaLigne != {} || ($LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {}) } {
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    } 
		
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3]) && $Ac4==""} {
	   Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    set jaitrouvegn 1
	    incr E
	    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
	}

	if {$jaitrouvednaacc || $jaitrouveprot || $jaitrouvegn} {
	    if {$LesAcsDeLaLigne != ""} {
		Espionne "LesAcsDeLaLigne= $LesAcsDeLaLigne"
	    }
	    if {$LesAcsDeLaLigne == ""} {Espionne "LesAcsDeLaLigne= vide"}
	}
    }
    #foreach
    Espionne "$A =nb de RA"
    Espionne "$B =nb ac refseq_piqor ms pas dna_acc"
    Espionne "$C =nb ac dna_acc"
    Espionne "$D =nb ac prot"
    Espionne "$E =nb ac rien"

}

proc AttriToutAccess_AEffacer {} {
 
    set A 0
    set B 0 
    set C 0
    set D 0
    set E 0
    set LesLignesPauvres {}

    foreach I [RetChip2 ListOf Index] {  
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]


	set jaitrouvednaacc 0
	set jaitrouve 0
	set jaitrouveRA 0
	set jaitrouvegn 0
	set genenamefait 0
	set jaitrouveprot 0
	set LesGenresP3 {}
	set AccDna ""
	set ListeDesAcs {}
	set LesAcsDna {}

	set LesAcsDeLaLigne ""

	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set LesAcsParGNDeLaLigne ""
	set LesAcsDeLaLigneList {}
	set cont 0
	set LigneQueSouris 0
	set SsFicheProt 0
	set vide 0

	if { [regexp {^RA[0-9]+} $Des1] } {
	    puts "ligne $I Des1=$Des1 Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    incr A
	    set RA1324 ""; set AccmRNA1 ""; set Genre1 ""; set AccmRNA2 ""; set Genre2 ""

	    set Fichier "/genomics/link/Ret1324/fiches/Orf2Cluster2Access2Def2Expression"
	    set LesLignes [LesLignesDuFichier $Fichier]

	    foreach Ligne $LesLignes {
		scan $Ligne "%s %s %s %s" RA1324 x y RA2717
		if {$Des1==$RA2717} {
		    set JaiTrouveCorresEntre1324Et2717 1
		    puts "RA1324=$RA1324"

		    if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]} {
			set LAcRa1 [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]
			scan $LAcRa1 "%s %s %s %s %s" x y AccmRNA1 z Genre1
		    }

		    set Fichier2 "/genomics/link/Ret1324/fiches/AccessDesProteinesEtDesmRNAsChoisis"
		    set LesLignes2 [LesLignesDuFichier $Fichier2]

		    foreach Ligne2 $LesLignes2 {
			scan $Ligne2 "%s %s %s %s" NumRA AccProt AccmRNA Genre
			if {$RA1324==$NumRA} {
			    set jaitrouvecorres 1
			    set AccmRNA2 $AccmRNA
			    set Genre2 $Genre
			    if {[string equal $AccmRNA2 "NomRNA"]} {
				set AccmRNA2 "" 
			    }
			    if {[string equal $Genre2 "NoOrganism"]} {
				set Genre2 "" 
			    }
			}
		    }
		    Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"
		}
	    }
	    if {!$JaiTrouveCorresEntre1324Et2717} { 
		puts "pas de corresp"
		Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"
	    }
	    continue
	}

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    puts "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    puts "LesAcsDeLaLigne= $Ac2"
	    continue
	}
	
	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set jaitrouvednaacc 1
	    incr C
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2"

	    if {$Ac2==""} {
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    set LesAcsDeLaLigne "$Ac1 $NM"
			} else { 
			    set LesAcsDeLaLigne $Ac1
			}
		    } else { 
			set LesAcsDeLaLigne $Ac1
		    }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
		    
		    set LesAcs3 [split $Ac3 ","]
		    foreach ChaqAc3 $LesAcs3 {
			set GenreAc3 [OrgDuProt $ChaqAc3]
			lappend LesGenresP3 $GenreAc3
		    }
		    set LesGenresP3 [lsort -unique $LesGenresP3]
		    if { [llength $LesGenresP3] > 1 } { puts "attention ilya pls genres pour cette ligne" }
		    set GenreP3 [join $LesGenresP3 " "]

		    if { $GenreP3 == "" } { 
			#jamais ce cas; je ne le traite pas
			#puts "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} { puts "dois prendre la def" }
			if {$Ac4 != ""} { puts "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} {  
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4]
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach T $ListeDesAcs {LConcat LesAcsDna $T} 
				    }
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set genenamefait 1
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
			if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    set AccsProt "$Ac3,$Ac4"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach S $ListeDesAcs {LConcat LesAcsDna $S} 
				    }
				}
			    } 
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set ListeAc3 [split $Ac3 ","]
			    foreach ChaqueAc3 $ListeAc3 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc3]
				if {$AccDna!=""} { 
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				} 
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc3] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "] 
					foreach S $ListeDesAcs {LConcat LesAcsDna $S}
				    }  
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]
			}
			if {$LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }
		}
	    }

	    if {$Ac2!=""} {

		if { $Ac1==$Ac2 } {
		    set LesAcsDeLaLigne $Ac2
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne $Ac2
			    set jaitrouve 1
			    break
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				set ListeAc1 [split $Ac1 ","]
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc1 $ListeAc2 $ListeNM]
				set Tout [ListeSansDoublon $Tout]
				set LesAcsDeLaLigne [join $Tout " "]
			    } else { 
				regsub -all "," $Ac2 " " Ac2
				set LesAcsDeLaLigne "$Ac1 $Ac2"
			    }
			} else { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne "$Ac1 $Ac2"
			}
		    }

		    if {[regexp {^Homo$} $Genre]} {
			regsub -all "," $Ac2 " " Ac2
			set LesAcsDeLaLigne $Ac2
		    }
		}
		#jaitrouve
	    }
	    #refseqpiqorpasvide
	}
	#dnaaccpas vide

	if { $Ac1=="" && $Ac2=="" && ($Ac3!="" || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    set jaitrouveprot 1
	    puts "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    
	    if { [regexp "," $Ac3] || [regexp "," $Ac4] } {
		set pls 1 
	    }
	    
	    set LesAcs3 [split $Ac3 ","]
	    set LesAcs4 [split $Ac4 ","]
	    set LesAcs3et4 [concat $LesAcs3 $LesAcs4]
	    set SesAcs [split $LesAcs3et4 " "]
	    foreach Ac $SesAcs {
		set GenreLu ""
		set IdLu ""
		set NM ""
		set mRNA ""
		set AcGb ""
		set mRNAGb ""
		
		set GenreLu [OrgDuProt $Ac]
		
		if { $GenreLu == "" } { 
		    set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    LConcat LesIdsDeLaLigne $IdLu
		    LConcat LesNmsDeLaLigne $NM 
		    LConcat LesmRNADeLaLigne $mRNA
		    LConcat LesAcsGbDeLaLigne $AcGb	
		    LConcat LesmRNAGbDeLaLigne $mRNAGb
		    continue
		}
		if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
		    if {! $pls} { 
			incr PasSouris
			set cont 1; break
		    }
		    if {$pls} { 
			incr PasSouris
			continue 
		    }
		}
		    
		set IdLu [IdDuProt $Ac]
		LConcat LesIdsDeLaLigne $IdLu
		set NM [LocUcsc $IdLu]

		if {$NM!=""} {
		    set ListNM [split $NM " "]
		    foreach ChaqNM $ListNM {
			LConcat LesNmsDeLaLigne $ChaqNM 
			if { ![regexp {^NM_} $ChaqNM] } { 
			    set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
			    if {$mRNA != ""} { 
				set ListemRNA [split $mRNA " "]
				foreach ChaqmRNA $ListemRNA {
				    LConcat LesmRNADeLaLigne $ChaqmRNA
				}	
			    }
			}
		    }
		} 
		if {$NM==""} {
		    set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut != ""} {
			set LesLignesDeGetzOut [split $GetzOut "\n"]
			foreach LigneDeGetzOut $LesLignesDeGetzOut {
			    set Ref ""
			    set AcGb ""
			    scan $LigneDeGetzOut "%s %s" Ref AcGb
			    LConcat LesAcsGbDeLaLigne $AcGb	
			    set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
			    if {$mRNAGb != ""} { 
				set ListemRNAGb [split $mRNAGb " "]
				foreach ChaqmRNAGb $ListemRNAGb {
				    LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				}
			    } 
			}
		    }
		} 
		if { $NM=="" && $AcGb=="" } {
		    if {$pls} {incr vide}
		}
	    }

	    if { [llength $SesAcs] == $PasSouris } {
		set LigneQueSouris 1
	    }
	    if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		set SsFicheProt 1
	    }

	    set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
	    set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
	    set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
	    set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
	    set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

	    if { ($cont || $LigneQueSouris) || ($LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={}) || ($SsFicheProt) || ($vide>0) } {
		set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne $LesAcsParGNDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    }

	    if { $LesNmsDeLaLigne != {} || $LesAcsGbDeLaLigne != {} || ($LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {}) } {
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    } 
		
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3]) && $Ac4==""} {
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    set jaitrouvegn 1
	    incr E
	    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
	}

	if {$jaitrouvednaacc || $jaitrouveprot || $jaitrouvegn} {
	    if {$LesAcsDeLaLigne != ""} {
		puts "LesAcsDeLaLigne= $LesAcsDeLaLigne"
	    }
	    if {$LesAcsDeLaLigne == ""} {puts "LesAcsDeLaLigne= vide"}
	}
    }
    #foreach
    Espionne "$A =nb de RA"
    Espionne "$B =nb ac refseq_piqor ms pas dna_acc"
    Espionne "$C =nb ac dna_acc"
    Espionne "$D =nb ac prot"
    Espionne "$E =nb ac rien"

}

proc AttriToutLesBidonAcAccNonExistant {} {

    set total 0; set B 0; set C 0; set W 0; set X 0; set D 0; set M 0; set N 0; set O 0; set P 0
    set cas1 0; set cas1a 0; set cas1b 0; set cas1c 0 
    set cas2 0; set cas2a 0; set cas2b 0; set cas2c 0; set cas2d 0
    set cas3 0; set cas4 0; set cas5 0; set cas6 0
    set cas7 0; set cas7a 0; set cas7b 0; 
    set cas8 0; set cas9 0; set cas10 0; set cas11 0
    set LesLignesPauvres {}
    set ListeI {87 178 200 220 1197 1289 1367 1431 1602 1702 1949}
    foreach I $ListeI {
	incr total
	Espionne $I
	set Des1 [RetChip5 $I "description_customer"]
	Espionne $Des1
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]
	set LesNMs {}

	set LesAc {}
	set Genre ""
	set TousLesGenres {}
	array unset LesGenres
	set onasouris 0
	set LesAcsDna {} 

	set LesAcProt {} 
	set TousLesGenresProt {} 
	array unset LesGenreAcProt 
	set onasourisprot 0 

	set genenamefait 0
	set ListAcsParGn {}; set BigList {}
	set LesAcsDeLaLigne ""

	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set Ac1 [string trim $Ac1]
	    regsub -all " " $Ac1 "" Ac1
	    incr C
	   Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"

	    incr W
	    set LesAc [split $Ac1 ","]

	    set LesAc [ListeSansDoublon $LesAc]
	    set LesAc [ListeSsElmtVide $LesAc]

	    foreach Ac $LesAc {
		set Genre [OrgDuNmOuGb $Ac]
		Espionne "Ac $Ac Genre $Genre"
		#if {$Genre == ""} {Espionne "attention pas fiches"}
		LConcat TousLesGenres $Genre
		set LesGenres($Ac) $Genre
	    }
	    set TousLesGenres [ListeSansDoublon $TousLesGenres]
	    foreach ChaqueGenre $TousLesGenres {
		if {[regexp {^Mus} $ChaqueGenre]} {
		    set onasouris 1
		}
	    }
	    if {$onasouris} {
		Espionne "cas1"
		incr cas1
		foreach Ac $LesAc {
		    set LesNmRefSeq {}; set LesNvxNm {}
		    if {[regexp {^Mus} $LesGenres($Ac)]} {
			#Espionne "Ac $Ac"
			if { ![regexp {^NM_} $Ac] && ![regexp {^XM_} $Ac] && ![regexp {^NR_} $Ac]} {
			    set NM [MrnaRefseqUcscMouse $Ac "Nm"]
			    #Espionne "NM $NM"
			    if { $NM != "" } {
				Espionne "cas1a"
				incr cas1a
				set LesNmRefSeq [split $NM " "]
				foreach NmRefSeq $LesNmRefSeq {
				    set GenreNmRefSeq [OrgDuNmOuGb $NmRefSeq]
				    #Espionne "$NmRefSeq $GenreNmRefSeq"
				    if {[regexp {^Mus} $GenreNmRefSeq]} {
					LConcat LesNvxNm $NmRefSeq
				    } 
				}
				set LesNvxNm [ListeSansDoublon $LesNvxNm]
				set NMjoint [join $LesNvxNm " "]
				Espionne "NMjoint $NMjoint"
				LConcat LesAcsDna "$Ac $NMjoint"
			    } else { 
				Espionne "cas1b"
				incr cas1b
				LConcat LesAcsDna $Ac
			    }
			} else { 
			   Espionne "cas1c"
		    incr cas1c
			    LConcat LesAcsDna $Ac
			}
		    }
		}
	    }
	    #Espionne "cas2"
	    incr cas2
	    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
	    if {$Ac3!="" || $Ac4!=""} {
		Espionne "cas2a"
		incr cas2a
		if {$Ac3!="" && $Ac4!=""} {
		   Espionne "cas2b"
		    incr cas2b
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		    set Ac3Ac4 "$Ac3,$Ac4"
		    set LesAcProt [split $Ac3Ac4 ","]
		} elseif {$Ac3!=""} {
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		   Espionne "cas2c"
		    incr cas2c
		    set LesAcProt [split $Ac3 ","]
		} elseif {$Ac4!=""} {
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		   Espionne "cas2d"
		    incr cas2d 
		    set LesAcProt [split $Ac4 ","]
		}
		set LesAcProt [ListeSansDoublon $LesAcProt]
		set LesAcProt [ListeSsElmtVide $LesAcProt]
		foreach AcProt $LesAcProt {
		    set GenreAcProt [OrgDuProt $AcProt]
		   Espionne "$AcProt $GenreAcProt"
		    #if {$GenreAcProt==""} {Espionne "attention pas fiches" }
		    LConcat TousLesGenresProt $GenreAcProt
		    set LesGenreAcProt($AcProt) $GenreAcProt
		}
		set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
		foreach ChaqueGenreProt $TousLesGenresProt {
		    if {[regexp {^Mus} $ChaqueGenreProt]} {
			set onasourisprot 1
		    }
		}
		if {$onasourisprot} {
		   Espionne "cas3"
		    incr cas3
		    foreach AcProt $LesAcProt {
			set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
			if {[regexp {^Mus} $LesGenreAcProt($AcProt)]} {
			    set ResultParProt [AttriDesAcDnaParProt $AcProt]
			   Espionne "ResultParProt $ResultParProt"
			    set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			   Espionne "ResultParGb $ResultParGb"
			    if {$ResultParProt != ""} {
				set ListeDesAcs1 [split $ResultParProt " "]
			    }
			    if {$ResultParGb != ""} {
				set ListeDesAcs2 [split $ResultParGb " "]
			    }
			    set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			    foreach elmt $LesAcsDnaProv {
				LConcat LesAcsDna $elmt
			    }
			}
		    }
		}
		if {!$onasourisprot} {
		    set LesAcsDna [ListeSansDoublon $LesAcsDna]
		   Espionne "cas4"
		    incr cas4
		    set genenamefait 1
		    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
		}
	    }
	
	    if {!$genenamefait && ($ListAcsParGn == {} && $LesAcsDna == {})} {
		Espionne "cas6"
		incr cas6
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if { ($Ac1=="" || [regexp {\?} $Ac1]) && (($Ac3!="" && ![regexp {\?} $Ac3]) || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	   Espionne "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    set Ac3 [string trim $Ac3]
	    regsub -all " " $Ac3 "" Ac3
	    set Ac4 [string trim $Ac4]
	    regsub -all " " $Ac4 "" Ac4
	    
	    if {$Ac3!="" && $Ac4!=""} {
		incr M
		set Ac3Ac4 "$Ac3,$Ac4"
		set LesAcProt [split $Ac3Ac4 ","]
	    } elseif {$Ac3!="" && ![regexp {\?} $Ac3]} {
		incr N
		set LesAcProt [split $Ac3 ","]
	    } elseif {$Ac4!=""} {
		incr O
		set LesAcProt [split $Ac4 ","]
	    } 
	    set LesAcProt [ListeSansDoublon $LesAcProt]
	    
	    foreach AcProt $LesAcProt {
		set GenreProt [OrgDuProt $AcProt]
		Espionne "AcProt $AcProt GenreProt $GenreProt"
		#if {$GenreProt==""} {Espionne "attention pas fiche"}
		LConcat TousLesGenresProt $GenreProt
		set LesGenresProt($AcProt) $GenreProt
	    }
	    set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
	    
	    foreach ChaqueGenreProt $TousLesGenresProt {
		if {[regexp {^Mus} $ChaqueGenreProt]} {
		    set onasourisprot 1
		}
	    }
	    if {$onasourisprot} {
		Espionne "cas7"
		incr cas7
		foreach AcProt $LesAcProt {
		    set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
		    if {[regexp {^Mus} $LesGenresProt($AcProt)]} {
			set ResultParProt [AttriDesAcDnaParProt $AcProt]
			Espionne "ResultParProt $ResultParProt"
			set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			Espionne "ResultParGb $ResultParGb"
			if {$ResultParProt != ""} {
			   Espionne "cas7a"
			    incr cas7a
			    set ListeDesAcs1 [split $ResultParProt " "]
			}
			if {$ResultParGb != ""} {
			   Espionne "cas7b"
			    incr cas7b
			    set ListeDesAcs2 [split $ResultParGb " "]
			}
			set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			foreach elmt $LesAcsDnaProv {
			    LConcat LesAcsDna $elmt
			}
		    }
		}
		set LesAcsDna [ListeSansDoublon $LesAcsDna]
	    }
	    if {!$onasourisprot} {
		Espionne "cas8"
		incr cas8
		set genenamefait 1
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    if {!$genenamefait && ($ListAcsParGn=={} && $LesAcsDna=={})} {
		Espionne "cas9"
		incr cas9
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && ($Ac3=="" || [regexp {\?} $Ac3])  && $Ac4==""} {
	    incr P
	   Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	   Espionne "cas10"
	    incr cas10
	    set genenamefait 1
	   Espionne "$Des1 $Des2"
	    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    if {$ListAcsParGn == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set ListAcsParGn [ListeSansDoublon $ListAcsParGn]
		set ListAcsParGn [ListeSsElmtVide $ListAcsParGn]
		set LesAcsDeLaLigne [join $ListAcsParGn " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
	   Espionne "cas11"
	    incr cas11
	    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    if {$ListAcsParGn == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set ListAcsParGn [ListeSansDoublon $ListAcsParGn]
		set ListAcsParGn [ListeSsElmtVide $ListAcsParGn]
		set LesAcsDeLaLigne [join $ListAcsParGn " "]
	    }
	   Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}
        

	if {$LesAcsDeLaLigne == ""} {
	    set LignePauvre "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    lappend LesLignesPauvres $LignePauvre
	   Espionne ">bidon trouve pas \natgc"
	} else {
	    foreach Acs $LesAcsDeLaLigne {
		if { [regexp "^NM_" $Acs] || [regexp "^XM_" $Acs] || [regexp "^NR_" $Acs] } {
		    set GetzOut ""
		    set Commande "getz \"\\\[refseq-acc:$Acs\\\]\" \-view FastaSeqs" 
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut == ""} {Espionne ">bidon fiche n'existe plus\natgc" }
		    if {$GetzOut != ""} { 
			if { [regexp {^>ref.+>ref} $GetzOut] } {
			    if {$I==178 || $I==1197} {set GetzOut [string range $GetzOut [string first ">" $GetzOut] [expr [string last ">" $GetzOut] - 1]] }
			   Espionne "ATTENTION AU - 2 SEQ FASTA"
			} else {
			    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
			}
			Espionne $GetzOut
		    }
		} else {
		    set GetzOut ""
		    set Commande "getz \"\\\[genbankfull-acc:$Acs\\\]\" \-view FastaSeqs" 
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut == ""} {Espionne ">bidon fiche n'existe plus\natgc" }
		    if {$GetzOut != ""} { 
			set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
			if { [regexp {^>ref.+>ref} $GetzOut] } {
			   Espionne "ATTENTION AU - 2 SEQ FASTA"
			}
			Espionne $GetzOut
		    }
		}
	    }
	}
    }
    set longdespauvres [llength $LesLignesPauvres]
    SauveLesLignes $LesLignesPauvres dans [RepertoireDuGenome]/fiches/LesLignesPauvres.txt
    Espionne "nombre de lignes= $total"
    Espionne "B=$B";Espionne "C $C";Espionne "W $W";Espionne "X $X"
    Espionne "D $D";Espionne "M $M";Espionne "N $N";Espionne "O $O";Espionne "P $P"
    Espionne "cas1 $cas1";Espionne "cas1a $cas1a";Espionne "cas1b $cas1b";Espionne "cas1c $cas1c" 
    Espionne "cas2 $cas2";Espionne "cas2a $cas2a";Espionne "cas2b $cas2b";Espionne "cas2c $cas2c";Espionne "cas2d $cas2d"
    Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6"
    Espionne "cas7 $cas7";Espionne "cas7a $cas7a";Espionne "cas7b $cas7b" 
    Espionne "cas8 $cas8";Espionne "cas9 $cas9";Espionne "cas10 $cas10";Espionne "cas11 $cas11"
    Espionne "nombre de lignes pauvres = $longdespauvres"

}

proc AttriToutRA {} {
 
    set A 0
    set Z 0
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set jaitrouveRA 0

	if { [regexp {^RA[0-9]+} $Des1] } {
	    incr A
	    puts "ligne $I Des1=$Des1"

	    set Fichier "/genomics/link/Ret1324/fiches/Orf2Cluster2Access2Def2Expression"
	    set LesLignes [LesLignesDuFichier $Fichier]

	    set Fichier2 "/genomics/link/Ret1324/fiches/AccessDesProteinesEtDesmRNAsChoisis"
	    set LesLignes2 [LesLignesDuFichier $Fichier2]
	    
	    
	    foreach Ligne $LesLignes {
		scan $Ligne "%s %s %s %s" RA1324 x y RA2717
		if {$Des1==$RA2717} {
		    set jaitrouveRA 1
		    puts  "=>Des1=$Des1 == Ret1324=$RA1324" 
		    if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]} { 
			set LeTfaDeRa [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]
			scan $LeTfaDeRa "%s %s %s" x y AccmRNA 
			if {$LeTfaDeRa==""} { puts "UN FICHIER MS PAS DE SEQ" }
			if {$LeTfaDeRa!=""} { 
			    puts "OK1=>$AccmRNA"			
			    #puts $LeTfaDeRa
			}
		    } else { 
			incr Z			
			puts "PAS DE FICHIER"
			lappend LesSsFiches "ligne $I Des1=$Des1 Ret1324=$RA1324"
		    }
		    foreach Ligne2 $LesLignes {
			scan $Ligne2 "%s %s %s" RA1324b AccmRNA2 
			if {$RA1324b == $RA1324} {
			    puts "OK2=>$AccmRNA2"
			} else { puts "pas d'access trouve ac blastx" }
		    }
		} 
	    } 
	    if {!$jaitrouveRA} { puts "PAS DE CORRES" }
	}
    }
    
    Espionne "$A =nb de ligne RA"
    Espionne "$Z =nb de lignes sans fichier"
    foreach X $LesSsFiches { puts $X } 

}

proc AttriToutRA_AEffacer {} {
 
    set A 0
    set Z 0
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set jaitrouveRA 0

	if { [regexp {^RA[0-9]+} $Des1] } {
	    incr A
	    puts "ligne $I Des1=$Des1"

	    set Fichier "/genomics/link/Ret1324/fiches/Orf2Cluster2Access2Def2Expression"
	    set LesLignes [LesLignesDuFichier $Fichier]

	    set Fichier2 "/genomics/link/Ret1324/fiches/AccessDesProteinesEtDesmRNAsChoisis"
	    set LesLignes2 [LesLignesDuFichier $Fichier2]

	    foreach Ligne $LesLignes {
		scan $Ligne "%s %s %s %s" RA1324 x y RA2717
		if {$Des1==$RA2717} {
		    set jaitrouveRA 1
		    puts  "=>Des1=$Des1 == Ret1324=$RA1324" 
		    if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]} { 
			set LeTfaDeRa [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]
			scan $LeTfaDeRa "%s %s %s" x y AccmRNA 
			if {$LeTfaDeRa==""} { puts "UN FICHIER MS PAS DE SEQ" }
			if {$LeTfaDeRa!=""} { 
			    puts "OK1=>$AccmRNA"			
			    #puts $LeTfaDeRa
			}
		    } else { 
			incr Z
			puts "PAS DE FICHIER"
			lappend LesSsFiches "ligne $I Des1=$Des1 Ret1324=$RA1324"
		    }
		    foreach Ligne2 $LesLignes {
			scan $Ligne2 "%s %s %s" RA1324b AccmRNA2 
			if {$RA1324b == $RA1324} {
			    puts "OK2=>$AccmRNA2"
			} else { puts "pas d'access trouve ac blastx" }
		    }
		} 
	    } 
	    if {!$jaitrouveRA} { puts "PAS DE CORRES" }
	}
    }
    Espionne "$A =nb de ligne RA"
    Espionne "$Z =nb de lignes sans fichier"
    foreach X $LesSsFiches { puts $X } 

}

proc AttriToutRefseqPiqor {} {
 
    set B 0 
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } {continue}
	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    puts "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set LesNMs [split $Ac2 ","]
	    foreach NM $LesNMs { 
		set Commande "getz \"\(\\\[refseqrelease-acc:$NM\\\]\|\\\[refseqnew-acc:$NM\\\]\)\!\(\\\[refseqnew-acc:$NM\\\]>\\\[refseqrelease-acc:$NM\\\]\)\" \-view FastaSeqs"
		#set Commande "getz \"\\\[refseq-acc:$NM\\\]\" \-view FastaSeqs" 
		set GetzOut [eval exec $Commande]	
		if {$GetzOut == ""} { puts "attention fiche n'existe plus" }
		if {$GetzOut != ""} { 
		    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
		    if { [regexp {^>ref.+>ref} $GetzOut] } {
			puts "ATTENTION AU - 2 SEQ FASTA"
		    }
		    puts $GetzOut
		}
	    }
	}
    }
    Espionne "$B = nb de ligne ac refseqpiqor et ss dnaacc"

}

proc AttriToutRefseqPiqor_AEffacer {} {
 
    set B 0 
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } {continue}

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    puts "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set LesNMs [split $Ac2 ","]
	    foreach NM $LesNMs { 
		set Commande "getz \"\(\\\[refseqrelease-acc:$NM\\\]\|\\\[refseqnew-acc:$NM\\\]\)\!\(\\\[refseqnew-acc:$NM\\\]>\\\[refseqrelease-acc:$NM\\\]\)\" \-view FastaSeqs"
		#set Commande "getz \"\\\[refseq-acc:$NM\\\]\" \-view FastaSeqs" 
		set GetzOut [eval exec $Commande]
		if {$GetzOut == ""} { puts "attention fiche n'existe plus" }
		if {$GetzOut != ""} { 
		    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
		    if { [regexp {^>ref.+>ref} $GetzOut] } {
			puts "ATTENTION AU - 2 SEQ FASTA"
		    }
		    puts $GetzOut
		}
	    }
	}
    }
    Espionne "$B = nb de ligne ac refseqpiqor et ss dnaacc"

}

proc AttriToutStat {} {

    set total 0; set A 0; set B 0; set C 0; set D 0; set E 0; set F 0; set G 0; set H 0
    set J 0; set K 0; set L 0; set M 0
    foreach I [RetChip5 ListOf Index] { 
	incr total
	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1 [RetChip5 $I "DNA_acc"]
	set Ac2 [RetChip5 $I "refseq_PIQOR"]
	set Ac3 [RetChip5 $I "prot_acc"]
	set Ac4 [RetChip5 $I "prot_acc_PIQOR"]
	if { $Ac1=="" && $Ac2!="" } { incr A } 
	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    incr B
	    if {$Ac2==""} {
		incr C
		if {$Ac3 == "" && $Ac4 == ""} {incr D}
		if {$Ac3 == "" && $Ac4 != ""} {incr E}
		if {$Ac3 != "" && $Ac4 == ""} {incr F}
		if {$Ac3 != "" && $Ac4 != ""} {incr G}
	    }
	    if {$Ac2!=""} {incr H}
	} 
	if { ($Ac1 == "" || [regexp {\?} $Ac1]) && $Ac2 == "" } {
	    incr J
	    if { ($Ac3!="" && ![regexp {\?} $Ac3]) || $Ac4!="" } {
		incr K
	    }
	    if { ($Ac3=="" || [regexp {\?} $Ac3]) && $Ac4=="" } {
		incr L
	    }
	}
    }
    Espionne "total $total"
    Espionne "A $A";Espionne "B $B";Espionne "C $C";Espionne "D $D";Espionne "E $E";Espionne "F $F"
    Espionne "G $G";Espionne "H $H";Espionne "J $J";Espionne "K $K";Espionne "L $L";Espionne "M $M"

}

proc AttriToutVf {} {

    set total 0; set B 0; set C 0; set W 0; set X 0; set D 0; set M 0; set N 0; set O 0; set P 0
    set cas1 0; set cas1a 0; set cas1b 0; set cas1c 0 
    set cas2 0; set cas2a 0; set cas2b 0; set cas2c 0; set cas2d 0
    set cas3 0; set cas4 0; set cas5 0; set cas6 0
    set cas7 0; set cas7a 0; set cas7b 0; 
    set cas8 0; set cas9 0; set cas10 0; set cas11 0
    set LesLignesPauvres {}
    foreach I [RetChip5 ListOf Index] {
	#if {$I>=11} {continue}
	if {$I!=87} {continue}
	incr total
	set Des1 [RetChip5 $I "description_customer"]
	set Des2 [RetChip5 $I "description_memorec"]
	set Ac1  [RetChip5 $I "DNA_acc"]
	set Ac2  [RetChip5 $I "refseq_PIQOR"]
	set Ac3  [RetChip5 $I "prot_acc"]
	set Ac4  [RetChip5 $I "prot_acc_PIQOR"]

	set LesNMs {}

	set LesAc {}
	set Genre ""
	set TousLesGenres {}
	array unset LesGenres
	set onasouris 0
	set LesAcsDna {} 

	set LesAcProt {} 
	set TousLesGenresProt {} 
	array unset LesGenreAcProt 
	set onasourisprot 0 

	set genenamefait 0
	set ListAcsParGn {}; set BigList {}
	set LesAcsDeLaLigne ""

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    Espionne "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set Ac2 [string trim $Ac2]
	    regsub -all " " $Ac2 "" Ac2
	    set LesNMs [split $Ac2 ","]
	    set LesNMs [ListeSansDoublon $LesNMs]
	    set LesNMs [ListeSsElmtVide $LesNMs]
	    set LesAcsDeLaLigne [join $LesNMs " "]
	}

	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set Ac1 [string trim $Ac1]
	    regsub -all " " $Ac1 "" Ac1
	    incr C
	    Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"

	    if {$Ac2==""} {
		incr W
		set LesAc [split $Ac1 ","]
	    }
	    if {$Ac2!=""} {
		set Ac2 [string trim $Ac2]
		regsub -all " " $Ac2 "" Ac2
		incr X
		set Ac1Ac2 "$Ac1,$Ac2"
		set LesAc [split $Ac1Ac2 ","]
	    }
	    set LesAc [ListeSansDoublon $LesAc]
	    set LesAc [ListeSsElmtVide $LesAc]

	    foreach Ac $LesAc {
		set Genre [OrgDuNmOuGb $Ac]
		#Espionne "Ac $Ac Genre $Genre"
		#if {$Genre == ""} {Espionne "attention pas fiches"}
		LConcat TousLesGenres $Genre
		set LesGenres($Ac) $Genre
	    }
	    set TousLesGenres [ListeSansDoublon $TousLesGenres]
	    foreach ChaqueGenre $TousLesGenres {
		if {[regexp {^Mus} $ChaqueGenre]} {
		    set onasouris 1
		}
	    }
	    if {$onasouris} {
		#Espionne "cas1"
		incr cas1
		foreach Ac $LesAc {
		    set LesNmRefSeq {}; set LesNvxNm {}
		    if {[regexp {^Mus} $LesGenres($Ac)]} {
			#Espionne "Ac $Ac"
			if { ![regexp {^NM_} $Ac] && ![regexp {^XM_} $Ac] && ![regexp {^NR_} $Ac]} {
			    set NM [MrnaRefseqUcscMouse $Ac "Nm"]
			    #Espionne "NM $NM"
			    if { $NM != "" } {
				#Espionne "cas1a"
				incr cas1a
				set LesNmRefSeq [split $NM " "]
				foreach NmRefSeq $LesNmRefSeq {
				    set GenreNmRefSeq [OrgDuNmOuGb $NmRefSeq]
				    #Espionne "$NmRefSeq $GenreNmRefSeq"
				    if {[regexp {^Mus} $GenreNmRefSeq]} {
					LConcat LesNvxNm $NmRefSeq
				    } 
				}
				set LesNvxNm [ListeSansDoublon $LesNvxNm]
				set NMjoint [join $LesNvxNm " "]
				#Espionne "NMjoint $NMjoint"
				LConcat LesAcsDna "$Ac $NMjoint"
			    } else { 
				#Espionne "cas1b"
				incr cas1b
				LConcat LesAcsDna $Ac
			    }
			} else { 
			    #Espionne "cas1c"
			    incr cas1c
			    LConcat LesAcsDna $Ac
			}
		    }
		}
	    }
	    #Espionne "cas2"
	    incr cas2
	    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
	    if {$Ac3!="" || $Ac4!=""} {
		#Espionne "cas2a"
		incr cas2a
		if {$Ac3!="" && $Ac4!=""} {
		    #Espionne "cas2b"
		    incr cas2b
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		    set Ac3Ac4 "$Ac3,$Ac4"
		    set LesAcProt [split $Ac3Ac4 ","]
		} elseif {$Ac3!=""} {
		    set Ac3 [string trim $Ac3]
		    regsub -all " " $Ac3 "" Ac3
		    #Espionne "cas2c"
		    incr cas2c
		    set LesAcProt [split $Ac3 ","]
		} elseif {$Ac4!=""} {
		    set Ac4 [string trim $Ac4]
		    regsub -all " " $Ac4 "" Ac4
		    #Espionne "cas2d"
		    incr cas2d 
		    set LesAcProt [split $Ac4 ","]
		}
		set LesAcProt [ListeSansDoublon $LesAcProt]
		set LesAcProt [ListeSsElmtVide $LesAcProt]
		foreach AcProt $LesAcProt {
		    set GenreAcProt [OrgDuProt $AcProt]
		    #Espionne "$AcProt $GenreAcProt"
		    #if {$GenreAcProt==""} {Espionne "attention pas fiches" }
		    LConcat TousLesGenresProt $GenreAcProt
		    set LesGenreAcProt($AcProt) $GenreAcProt
		}
		set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
		foreach ChaqueGenreProt $TousLesGenresProt {
		    if {[regexp {^Mus} $ChaqueGenreProt]} {
			set onasourisprot 1
		    }
		}
		if {$onasourisprot} {
		    #Espionne "cas3"
		    incr cas3
		    foreach AcProt $LesAcProt {
			set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
			if {[regexp {^Mus} $LesGenreAcProt($AcProt)]} {
			    set ResultParProt [AttriDesAcDnaParProt $AcProt]
			    #Espionne "ResultParProt $ResultParProt"
			    set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			    #Espionne "ResultParGb $ResultParGb"
			    if {$ResultParProt != ""} {
				set ListeDesAcs1 [split $ResultParProt " "]
			    }
			    if {$ResultParGb != ""} {
				set ListeDesAcs2 [split $ResultParGb " "]
			    }
			    set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			    foreach elmt $LesAcsDnaProv {
				LConcat LesAcsDna $elmt
			    }
			}
		    }
		}
		if {!$onasourisprot} {
		    set LesAcsDna [ListeSansDoublon $LesAcsDna]
		    #Espionne "cas4"
		    incr cas4
		    set genenamefait 1
		    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
		}
	    }
	
	    if {!$genenamefait && ($ListAcsParGn == {} && $LesAcsDna == {})} {
		#Espionne "cas6"
		incr cas6
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	    #Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if { ($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && (($Ac3!="" && ![regexp {\?} $Ac3]) || $Ac4!="")} {
	    #Espionne Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    Espionne "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    set Ac3 [string trim $Ac3]
	    regsub -all " " $Ac3 "" Ac3
	    set Ac4 [string trim $Ac4]
	    regsub -all " " $Ac4 "" Ac4
	    
	    if {$Ac3!="" && $Ac4!=""} {
		incr M
		set Ac3Ac4 "$Ac3,$Ac4"
		set LesAcProt [split $Ac3Ac4 ","]
	    } elseif {$Ac3!="" && ![regexp {\?} $Ac3]} {
		incr N
		set LesAcProt [split $Ac3 ","]
	    } elseif {$Ac4!=""} {
		incr O
		set LesAcProt [split $Ac4 ","]
	    } 
	    set LesAcProt [ListeSansDoublon $LesAcProt]
	    
	    foreach AcProt $LesAcProt {
		set GenreProt [OrgDuProt $AcProt]
		#Espionne "AcProt $AcProt GenreProt $GenreProt"
		#if {$GenreProt==""} {Espionne "attention pas fiche"}
		LConcat TousLesGenresProt $GenreProt
		set LesGenresProt($AcProt) $GenreProt
	    }
	    set TousLesGenresProt [ListeSansDoublon $TousLesGenresProt]
	    
	    foreach ChaqueGenreProt $TousLesGenresProt {
		if {[regexp {^Mus} $ChaqueGenreProt]} {
		    set onasourisprot 1
		}
	    }
	    if {$onasourisprot} {
		#Espionne "cas7"
		incr cas7
		foreach AcProt $LesAcProt {
		    set ListeDesAcs1 {}; set ListeDesAcs2 {}; set LesAcsDnaProv {}
		    if {[regexp {^Mus} $LesGenresProt($AcProt)]} {
			set ResultParProt [AttriDesAcDnaParProt $AcProt]
			#Espionne "ResultParProt $ResultParProt"
			set ResultParGb   [AttriDesAcDnaParGb $AcProt]
			#Espionne "ResultParGb $ResultParGb"
			if {$ResultParProt != ""} {
			    #Espionne "cas7a"
			    incr cas7a
			    set ListeDesAcs1 [split $ResultParProt " "]
			}
			if {$ResultParGb != ""} {
			    #Espionne "cas7b"
			    incr cas7b
			    set ListeDesAcs2 [split $ResultParGb " "]
			}
			set LesAcsDnaProv [concat $ListeDesAcs1 $ListeDesAcs2]
			foreach elmt $LesAcsDnaProv {
			    LConcat LesAcsDna $elmt
			}
		    }
		}
		set LesAcsDna [ListeSansDoublon $LesAcsDna]
	    }
	    if {!$onasourisprot} {
		#Espionne "cas8"
		incr cas8
		set genenamefait 1
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    }
	    if {!$genenamefait && ($ListAcsParGn=={} && $LesAcsDna=={})} {
		#Espionne "cas9"
		incr cas9
		set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
		set genenamefait 1
	    }
	    set BigList [concat $LesAcsDna $ListAcsParGn]
	    set BigList [ListeSansDoublon $BigList]
	    if {$BigList == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set BigList [ListeSsElmtVide $BigList]
		set LesAcsDeLaLigne [join $BigList " "]
	    }
	    #Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3])  && $Ac4==""} {
	    incr P
	    Espionne "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    #Espionne "cas10"
	    incr cas10
	    set genenamefait 1
	    #Espionne "$Des1 $Des2"
	    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    if {$ListAcsParGn == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set ListAcsParGn [ListeSansDoublon $ListAcsParGn]
		set ListAcsParGn [ListeSsElmtVide $ListAcsParGn]
		set LesAcsDeLaLigne [join $ListAcsParGn " "]
	    }
	    #Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}

	if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
	    #Espionne "cas11"
	    incr cas11
	    set ListAcsParGn [AttriDesAcDnaParGeneName $Des1 $Des2]
	    if {$ListAcsParGn == {}} {
		set LesAcsDeLaLigne ""
	    } else {
		set ListAcsParGn [ListeSansDoublon $ListAcsParGn]
		set ListAcsParGn [ListeSsElmtVide $ListAcsParGn]
		set LesAcsDeLaLigne [join $ListAcsParGn " "]
	    }
	    #Espionne "LesAcsDeLaLigne $LesAcsDeLaLigne"
	}
	#temporaire 
	if {$LesAcsDeLaLigne == ""} {
	    set LignePauvre "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    lappend LesLignesPauvres $LignePauvre
	    Espionne "bidon trouve pas"
	} else {
	    Espionne "$LesAcsDeLaLigne"
	    foreach Acs $LesAcsDeLaLigne {
		if { [regexp "^NM_" $Acs] || [regexp "^XM_" $Acs] || [regexp "^NR_" $Acs] } {
		    set GetzOut ""
		    set Commande "getz \"\\\[refseq-acc:$Acs\\\]\" \-view FastaSeqs" 
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut == ""} {Espionne "$Acs bidon fiche n'existe plus" }
		    if {$GetzOut != ""} {Espionne "$Acs ok"} 
		} else {
		    set GetzOut ""
		    set Commande "getz \"\\\[genbankfull-acc:$Acs\\\]\" \-view FastaSeqs" 
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut == ""} {Espionne "$Acs bidon fiche n'existe plus" }
		    if {$GetzOut != ""} {Espionne "$Acs ok"} 
		}
	    }
	}
	#temporaire        
    } 
    set longdespauvres [llength $LesLignesPauvres]
    SauveLesLignes $LesLignesPauvres dans [RepertoireDuGenome]/fiches/NewLesLignesPauvres.txt
    Espionne "nombre de lignes= $total"
    Espionne "B=$B";Espionne "C $C";Espionne "W $W";Espionne "X $X"
    Espionne "D $D";Espionne "M $M";Espionne "N $N";Espionne "O $O";Espionne "P $P"
    Espionne "cas1 $cas1";Espionne "cas1a $cas1a";Espionne "cas1b $cas1b";Espionne "cas1c $cas1c" 
    Espionne "cas2 $cas2";Espionne "cas2a $cas2a";Espionne "cas2b $cas2b";Espionne "cas2c $cas2c";Espionne "cas2d $cas2d"
    Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6"
    Espionne "cas7 $cas7";Espionne "cas7a $cas7a";Espionne "cas7b $cas7b" 
    Espionne "cas8 $cas8";Espionne "cas9 $cas9";Espionne "cas10 $cas10";Espionne "cas11 $cas11"
    Espionne "nombre de lignes pauvres = $longdespauvres"

}

proc AttriTout_AEffacer {} {
 
    set A 0
    set B 0 
    set C 0
    set D 0
    set E 0
    set LesLignesPauvres {}

    foreach I [RetChip2 ListOf Index] {  
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]


	set jaitrouvednaacc 0
	set jaitrouve 0
	set jaitrouveRA 0
	set jaitrouvegn 0
	set genenamefait 0
	set jaitrouveprot 0
	set LesGenresP3 {}
	set AccDna ""
	set ListeDesAcs {}
	set LesAcsDna {}

	set LesAcsDeLaLigne ""

	set pls 0
	set PasSouris 0
	set LesIdsDeLaLigne {}
	set LesNmsDeLaLigne {}
	set LesmRNADeLaLigne {}
	set LesAcsGbDeLaLigne {}
	set LesmRNAGbDeLaLigne {}
	set LesAcsParGNDeLaLigne ""
	set LesAcsDeLaLigneList {}
	set cont 0
	set LigneQueSouris 0
	set SsFicheProt 0
	set vide 0


	if { [regexp {^RA[0-9]+} $Des1] } {
	    incr A
	    puts ">bidon raligne $I Des1=$Des1\natcg"
	    # if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$Des1"]} {set LeTfaDeRa [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$Des1"]; puts $LeTfaDeRa} else {puts "attention fichera n'existe plus" }
	    continue 
	}

	if {$Ac1=="" && $Ac2!=""} {
	    incr B
	    puts "ligne $I Ac1=$Ac1 et Ac2=$Ac2"
	    set LesNMs [split $Ac2 ","]
	    foreach NM $LesNMs { 
		set Commande "getz \"\(\\\[refseqrelease-acc:$NM\\\]\|\\\[refseqnew-acc:$NM\\\]\)\!\(\\\[refseqnew-acc:$NM\\\]>\\\[refseqrelease-acc:$NM\\\]\)\" \-view FastaSeqs"
		#set Commande "getz \"\\\[refseq-acc:$NM\\\]\" \-view FastaSeqs" 
		set GetzOut [eval exec $Commande]
		if {$GetzOut == ""} { puts ">bidon ficherefseqpiqor n'existe plus\natgc" }
		if {$GetzOut != ""} { 
		    set GetzOut [string range $GetzOut [string last ">" $GetzOut] end]
		    if { [regexp {^>ref.+>ref} $GetzOut] } {
			puts "ATTENTION AU - 2 SEQ FASTA"
		    }
		    puts $GetzOut
		}
	    }
	    continue
	}
	
	if { $Ac1!="" && ![regexp {\?} $Ac1] } {
	    set jaitrouvednaacc 1
	    incr C
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"

	    if {$Ac2==""} {
		
		set Genre [OrgDuNmOuGb $Ac1]
		
		if {[regexp {^Mus$} $Genre]} {
		    if { ![regexp {^NM_} $Ac1] } {
			set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			if { $NM != "" } {
			    set LesAcsDeLaLigne "$Ac1 $NM"
			} else { 
			    set LesAcsDeLaLigne $Ac1
			}
		    } else { 
			set LesAcsDeLaLigne $Ac1
		    }
		}
		
		if {[regexp {^Homo$} $Genre]} {
		    #travail sur prot Ac3=$Ac3 Ac4=$Ac4
		    
		    set LesAcs3 [split $Ac3 ","]
		    foreach ChaqAc3 $LesAcs3 {
			set GenreAc3 [OrgDuProt $ChaqAc3]
			lappend LesGenresP3 $GenreAc3
		    }
		    set LesGenresP3 [lsort -unique $LesGenresP3]
		    if { [llength $LesGenresP3] > 1 } { puts "attention ilya pls genres pour cette ligne" }
		    set GenreP3 [join $LesGenresP3 " "]

		    if { $GenreP3 == "" } { 
			#jamais ce cas; je ne le traite pas
			#puts "pls=>ligne=$I Acc=$Ac3 Id=attention PAS FICHESpls\n"
			if {$Ac4 == ""} { puts "dois prendre la def" }
			if {$Ac4 != ""} { puts "dois prendre prot_acc_piqor"} 
			continue 
		    }
		    
		    if {[regexp {^Homo} $GenreP3]} {
			if {$Ac4!=""} {
			    set ListeAc4 [split $Ac4 ","]
			    foreach ChaqueAc4 $ListeAc4 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc4]
				if {$AccDna!=""} {  
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc4]
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach T $ListeDesAcs {LConcat LesAcsDna $T} 
				    }
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set genenamefait 1
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
			if {$genenamefait == 0 && $LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }

		    if {[regexp {^Mus} $GenreP3]} {
			if {$Ac4!=""} {
			    set AccsProt "$Ac3,$Ac4"
			    set ListeAccsProt [split $AccsProt ","]
			    foreach ChaqueAccProt $ListeAccsProt {
				set AccDna [AttriDesAcDnaParProt $ChaqueAccProt]
				if {$AccDna!=""} {
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q} 
				}
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAccProt] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "]
					foreach S $ListeDesAcs {LConcat LesAcsDna $S} 
				    }
				}
			    } 
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]

			} else {
			    set ListeAc3 [split $Ac3 ","]
			    foreach ChaqueAc3 $ListeAc3 {
				set AccDna [AttriDesAcDnaParProt $ChaqueAc3]
				if {$AccDna!=""} { 
				    set ListeDesAcs [split $AccDna " "]
				    foreach Q $ListeDesAcs {LConcat LesAcsDna $Q}
				} 
				if {$AccDna==""} {  
				    set AccDna [AttriDesAcDnaParGb $ChaqueAc3] 
				    if {$AccDna!=""} { 
					set ListeDesAcs [split $AccDna " "] 
					foreach S $ListeDesAcs {LConcat LesAcsDna $S}
				    }  
				}
			    }
			    set LesAcsDna [ListeSansDoublon $LesAcsDna]
			    set LesAcsDeLaLigne [join $LesAcsDna " "]
			}
			if {$LesAcsDeLaLigne == ""} {
			    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
			}
		    }
		}
	    }

	    if {$Ac2!=""} {

		if { $Ac1==$Ac2 } {
		    set LesAcsDeLaLigne $Ac2
		    set jaitrouve 1
		}
		if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } {
		    set LesNMs [split $Ac2 ","]
		    foreach LeNM $LesNMs { 
			if { $LeNM==$Ac1 } { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne $Ac2
			    set jaitrouve 1
			    break
			}
		    }
		}

		if { $jaitrouve==0 } {

		    set Genre [OrgDuNmOuGb $Ac1]

		    if {[regexp {^Mus$} $Genre]} {
			if { ![regexp {^NM_} $Ac1] } {
			    set NM [MrnaRefseqUcscMouse $Ac1 "Nm"]
			    if { $NM != "" } {
				set ListeAc1 [split $Ac1 ","]
				set ListeAc2 [split $Ac2 ","]
				set ListeNM [split $NM " "]
				set Tout [concat $ListeAc1 $ListeAc2 $ListeNM]
				set Tout [ListeSansDoublon $Tout]
				set LesAcsDeLaLigne [join $Tout " "]
			    } else { 
				regsub -all "," $Ac2 " " Ac2
				set LesAcsDeLaLigne "$Ac1 $Ac2"
			    }
			} else { 
			    regsub -all "," $Ac2 " " Ac2
			    set LesAcsDeLaLigne "$Ac1 $Ac2"
			}
		    }

		    if {[regexp {^Homo$} $Genre]} {
			regsub -all "," $Ac2 " " Ac2
			set LesAcsDeLaLigne $Ac2
		    }
		}
		#jaitrouve
	    }
	    #refseqpiqorpasvide
	}
	#dnaaccpas vide

	if { $Ac1=="" && $Ac2=="" && ($Ac3!="" || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    set jaitrouveprot 1
	    puts "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    
	    if { [regexp "," $Ac3] || [regexp "," $Ac4] } {
		set pls 1 
	    }
	    
	    set LesAcs3 [split $Ac3 ","]
	    set LesAcs4 [split $Ac4 ","]
	    set LesAcs3et4 [concat $LesAcs3 $LesAcs4]
	    set SesAcs [split $LesAcs3et4 " "]
	    foreach Ac $SesAcs {
		set GenreLu ""
		set IdLu ""
		set NM ""
		set mRNA ""
		set AcGb ""
		set mRNAGb ""
		
		set GenreLu [OrgDuProt $Ac]
		
		if { $GenreLu == "" } { 
		    set IdLu ""; set NM ""; set mRNA ""; set AcGb ""; set mRNAGb ""
		    LConcat LesIdsDeLaLigne $IdLu
		    LConcat LesNmsDeLaLigne $NM 
		    LConcat LesmRNADeLaLigne $mRNA
		    LConcat LesAcsGbDeLaLigne $AcGb	
		    LConcat LesmRNAGbDeLaLigne $mRNAGb
		    continue
		}
		if { $GenreLu != "" && ![regexp -nocase {^Mus} $GenreLu]} {
		    if {! $pls} { 
			incr PasSouris
			set cont 1; break
		    }
		    if {$pls} { 
			incr PasSouris
			continue 
		    }
		}
		    
		set IdLu [IdDuProt $Ac]
		LConcat LesIdsDeLaLigne $IdLu
		set NM [LocUcsc $IdLu]

		if {$NM!=""} {
		    set ListNM [split $NM " "]
		    foreach ChaqNM $ListNM {
			LConcat LesNmsDeLaLigne $ChaqNM 
			if { ![regexp {^NM_} $ChaqNM] } { 
			    set mRNA [MrnaRefseqUcscMouse $ChaqNM "Nm"]
			    if {$mRNA != ""} { 
				set ListemRNA [split $mRNA " "]
				foreach ChaqmRNA $ListemRNA {
				    LConcat LesmRNADeLaLigne $ChaqmRNA
				}	
			    }
			}
		    }
		} 
		if {$NM==""} {
		    set Commande "getz \"\\\[protein-acc:$Ac\\\] > \\\[genbankfull-mol:mRNA\\\]\" \-vf acc"
		    set GetzOut [eval exec $Commande]
		    if {$GetzOut != ""} {
			set LesLignesDeGetzOut [split $GetzOut "\n"]
			foreach LigneDeGetzOut $LesLignesDeGetzOut {
			    set Ref ""
			    set AcGb ""
			    scan $LigneDeGetzOut "%s %s" Ref AcGb
			    LConcat LesAcsGbDeLaLigne $AcGb	
			    set mRNAGb [MrnaRefseqUcscMouse $AcGb "Nm"]
			    if {$mRNAGb != ""} { 
				set ListemRNAGb [split $mRNAGb " "]
				foreach ChaqmRNAGb $ListemRNAGb {
				    LConcat LesmRNAGbDeLaLigne $ChaqmRNAGb
				}
			    } 
			}
		    }
		} 
		if { $NM=="" && $AcGb=="" } {
		    if {$pls} {incr vide}
		}
	    }

	    if { [llength $SesAcs] == $PasSouris } {
		set LigneQueSouris 1
	    }
	    if { [expr [llength $SesAcs] - $PasSouris] != [llength $LesIdsDeLaLigne] } { 
		set SsFicheProt 1
	    }

	    set LesIdsDeLaLigne [lsort -unique $LesIdsDeLaLigne]
	    set LesNmsDeLaLigne [lsort -unique $LesNmsDeLaLigne]
	    set LesmRNADeLaLigne [lsort -unique $LesmRNADeLaLigne]
	    set LesAcsGbDeLaLigne [lsort -unique $LesAcsGbDeLaLigne]
	    set LesmRNAGbDeLaLigne [lsort -unique $LesmRNAGbDeLaLigne]

	    if { ($cont || $LigneQueSouris) || ($LesNmsDeLaLigne=={} && $LesAcsGbDeLaLigne=={}) || ($SsFicheProt) || ($vide>0) } {
		set LesAcsParGNDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne $LesAcsParGNDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    }

	    if { $LesNmsDeLaLigne != {} || $LesAcsGbDeLaLigne != {} || ($LesNmsDeLaLigne != {} && $LesAcsGbDeLaLigne != {}) } {
		set LesAcsDeLaLigneList [concat $LesNmsDeLaLigne $LesmRNADeLaLigne $LesAcsGbDeLaLigne $LesmRNAGbDeLaLigne]
		set LesAcsDeLaLigneList [ListeSansDoublon $LesAcsDeLaLigneList]
		set LesAcsDeLaLigne [join $LesAcsDeLaLigneList " "]
	    } 
		
	}

	if {($Ac1=="" || [regexp {\?} $Ac1]) && $Ac2=="" && ($Ac3=="" || [regexp {\?} $Ac3]) && $Ac4==""} {
	    puts "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    set jaitrouvegn 1
	    incr E
	    set LesAcsDeLaLigne [AttriDesAcDnaParGeneName $Des1 $Des2]
	}

	if {$jaitrouvednaacc || $jaitrouveprot || $jaitrouvegn} {
	    if {$LesAcsDeLaLigne != ""} {
		set ListeFinal [split $LesAcsDeLaLigne " "]
		foreach ChaqueFinal $ListeFinal {
		    set GetzOut ""
		    if { [regexp {^NM_} $ChaqueFinal] || [regexp {^NR_} $ChaqueFinal] } {
			set Commande "getz \"\(\\\[refseqrelease-acc:$ChaqueFinal\\\]\|\\\[refseqnew-acc:$ChaqueFinal\\\]\)\!\(\\\[refseqnew-acc:$ChaqueFinal\\\]>\\\[refseqrelease-acc:$ChaqueFinal\\\]\)\" \-view FastaSeqs"
			#set Commande "getz \"\\\[refseq-acc:$ChaqueFinal\\\]\" \-view FastaSeqs" 
			set GetzOut [eval exec $Commande]
			set GetzOut [string range $GetzOut [string last ">r" $GetzOut] end]
			if { [regexp {^>ref.+>ref} $GetzOut] } {
			    puts "ATTENTION AU - 2 SEQ FASTA"
			}
		    }  
		    if { ![regexp {^NM_} $ChaqueFinal] && ![regexp {^NR_} $ChaqueFinal] } {
			set Commande "getz \"\\\[genbankfull-acc:$ChaqueFinal\\\]\" \-view FastaSeqs" 
			set GetzOut [eval exec $Commande]
			if { [regexp {^>gen.+>gen} $GetzOut] } {
			    puts "ATTENTION AU - 2 SEQ FASTA"
			}
		    }
		    if {$GetzOut == ""} { puts ">bidon fichedna n'existe plus\natcg" }
		    if {$GetzOut != ""} { puts $GetzOut }
		}
	    }
	    if {$LesAcsDeLaLigne == ""} {
		puts ">bidon pas d'access\natcg"
		lappend LesLignesPauvres "$I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4"
	    }
	}
    }
    #foreach
    set NbPauvres [llength $LesLignesPauvres]
    set f [open LesLignesPauvres.txt w]
    puts $f "$NbPauvres = nb de ligne Pauvres"
    foreach Ligne $LesLignesPauvres {
	puts $f $Ligne
    }
    close $f

    Espionne "$A =nb de RA"
    Espionne "$B =nb ac refseq_piqor ms pas dna_acc"
    Espionne "$C =nb ac dna_acc"
    Espionne "$D =nb ac prot"
    Espionne "$E =nb ac rien"

}

proc AttributeNodeFromKEGG {} {

    #Les pathways doivent provenir du meme orga
    
    set ListPathway [list "hsa04210" "hsa04610" "hsa04660" "hsa04662" "hsa04062"]
    lappend LesLignes "Pn\tQueryColor"
    lappend LesLignesTest "Pn\tQueryColor"
    foreach Path $ListPathway {
	set LesGns {}
	regexp {([a-z]+)([0-9]+)} $Path tmp Org Id
	set File "/home/poidevin/ordi/bilbault/FromKegg/${Path}.gene"
	Espionne "$File"
	foreach Ligne [LesLignesDuFichier $File] {
	    LConcat LesGns [split [lindex [split $Ligne "\t\["] 1] " ,"]
	}
	set LesGns [ListeSansDoublon $LesGns]
	foreach Gn $LesGns {
	    set Gn [string trim $Gn]
	    if {$Gn==""} {continue}
	    lappend LesLignesTest "$Gn\t$Path"
	    lappend DejaVu($Gn) $Path
	}
    }
    foreach Clef [array names DejaVu] {
	if {[llength $DejaVu($Clef)]>1} {
	    set Id [join $DejaVu($Clef) "_"]
	    lappend LesLignes "$Clef\t$Id"
	    lappend LesCombi $DejaVu($Clef)
	} else {
	    lappend LesLignes "$Clef\t$DejaVu($Clef)"
	}
    }
    set LesCombi [ListeSansDoublon $LesCombi]
    EspionneL $LesCombi
    SauveLesLignes $LesLignesTest dans "/home/poidevin/ordi/bilbault/AttributeNodeFromKEGGTest2"
    SauveLesLignes $LesLignes dans "/home/poidevin/ordi/bilbault/AttributeNodeFromKEGG"

}

proc AttributsDeLaBalise {Item aTexte {Rogner NePasRogner}} {

    upvar $aTexte Texte
    ValeurDeLaBalise $Item $aTexte $Rogner A
    return $A

}

proc AuChoixDuBlast {NomDuFichier {FichierSortie ""}} {


    if {$FichierSortie==""} { set FichierSortie "GetText" }
    set f $NomDuFichier
    set nomori [file join [RepertoireDuGenome] "tfasdescopains_nature" $NomDuFichier]
    set Nom [file tail $NomDuFichier]
    if {[EstUnPAB $NomDuFichier]} {
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
    } else {
	set Fichier $NomDuFichier
    }
    if {! [file exists $Fichier]} {return ""}
    set LBlast [LesLignesDuFichier $Fichier]

    set lsm {}
    set lPN {}
    set LDPN {}
    set LDDPN {}

    set MaxListe 5000
    set SeuilExpect 0.001
    DecortiqueBlast $LBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN

    if {[llength $lPN] < 5} {
	set LesElus $lBanqueId
	if {$FichierSortie=="GetList"} { return $LesElus }
	if {$FichierSortie=="GetText"} {
	    set LeBlast [join $LBlast "\n"]
	    return $LeBlast
	}
	if {$FichierSortie=="Show"} {
	    return [AfficheVariable $LeBlast "AvecSegAlignement" "MounirReducedOf_/$Nom"]
	}
	return [Sauve $LeBlast dans $FichierSortie]
    }

    # Transformation E-values

    #    set lPN [LisseCourbe $lPN]
    foreach e $lPN {
	if {$e == 0.0} {set e "1.0e-300"}
	set e [expr log($e)]
	lappend llogPN $e
    }
    set Eder [lindex $lPN end]

    # Calcul des derivee premiere, seconde et tierce

    set LDPN  [Derivee $llogPN]
    #    set LDPN [LisseCourbe $LDPN]
    set LDPN  [linsert $LDPN  0 -300.]
    set LD2PN [Derivee $LDPN]
    set LD2PN [linsert $LD2PN 0 300.]
    #    set LD2PN [linsert $LD2PN end 300.]
    set LD3PN [Derivee $LD2PN]
    set LD3PN [linsert $LD3PN 0 300.]
    #    set LD3PN [linsert $LD3PN end 300. 300.]

    # fait tri
    # Met toujours le Premier

    lappend LesElus [lindex $lBanqueId 0]
    set nelus 0
    set i 0
    set LDt [lrange $LD3PN     0 end]
    set LBt [lrange $lBanqueId 0 end]
    foreach e $LDt {
	if {$i == 0 || $i == 1} {
	    incr i
	    continue
	}
	set icou [expr $i-1]
	set Flag 0
	if {$e < 0.0} {
	    set prev [lindex $LDt ${icou}]
	    if {$prev > 0.0} {
		lappend LesElus [lindex $LBt $icou]
		lappend Lid $icou
		set Flag 1
		incr nelus
	    }
	}
	if {$nelus >= 500} {break}
	incr i
    }
    foreach i $LesElus {
	if {$i == ""} {continue}
	lappend res $i
    }
    set LesElus $res

    if {$FichierSortie=="GetList"} { return $LesElus }
    if {$FichierSortie=="GetText"} {
	set LeReduit [BlastReduit $Fichier $LesElus]
	set Reduit [join $LeReduit "\n"]
	return $Reduit
    }
    if {$FichierSortie=="Show"} {
	return [AfficheVariable $Reduit "AvecSegAlignement" "MounirReducedOf_/$Nom"]
    }
    return [Sauve $Reduit dans $FichierSortie]

}

proc AuCongelo {{Action ""}} {

    set LesAvaries {}
    set LesAvariesAFaire {}
    set LesAFaire {}
    foreach Nom [ListeDesPABs] {
	set P [DernierePoele $Nom]
	set C [DernierCongelo $Nom]
	if {$P==""} { continue }
	Espionne "$Nom = $P = $C ="
	if {$C==""} {
	    Espionne "$P"
	    lappend LesAFaire $P
	}
	if {$C!="" && ([set TC [file mtime $C]] < [set TP [file mtime $P]])} {
	    lappend LesAFaire $P
	    lappend LesAvaries "$Nom [Date Nice $TC] [Date Nice $TP]"
	    lappend LesAvariesAFaire $C
	}
    }
    Espionne ".............................. LesAvaries"
    EspionneL $LesAvaries
    Espionne ".............................. LesAFaire"
    EspionneL $LesAFaire
    if { ! [OuiOuNon "Je congele effectivement ?"]} { return "" }
    set LesFaits {}
    foreach A $LesAvariesAFaire {
	exec mv $A /tempor/grid/poubelle/
    }
    foreach P $LesAFaire {
	exec mv $P /tempor/grid/congelo/
	lappend LesFaits "/tempor/grid/congelo/[file tail $P]"
    }
    return $LesFaits

}

proc AuLog {{args ""}} {

    global TexteDuLog Toggle NomFenetreOrdali wtlog Defauts

    switch [lindex $args 0] {
	"-nonewline" {
	    set bn ""
	    set txt [lindex $args 1]
	}
	"LClean" {
	    set TexteDuLog ""
	    return
	}
	"LOutput" {
	    set what [lindex $args 1]
	    if {$what eq ""} {set what HTML}
	    set fout [lindex $args 2]
	    set add  [lindex $args 3]
	    OutputTLog $what "$TexteDuLog" $fout $add
	    return
	}
	default {
	    set bn "\n"
	    set txt "$args"
	}
    }
    
    # voir ordali_tlog ....
    if {$::Defauts(OnlyTLog) && ! [regexp {^@} $txt]} {
	set txt "@text $txt"
    }
    if {[regexp {^\@text} $txt]} {
	regsub -all "\n" $txt "AlALiGNe" txt
    } 
    append TexteDuLog "${txt}$bn"

    return

}

proc AuLogOld {args} {

    global TexteDuLog Toggle NomFenetreOrdali wtlog Defauts

    if {![info exists TexteDuLog]} {set TexteDuLog ""}

    if {[lindex $args 0] eq "-nonewline"} {
	set bn ""
	set txt [lindex $args 1]
    } else {
	set bn "\n"
	set txt [join $args " "]
    }

    if {! [ModeI] || ! [info exists Toggle]} {
	# Dans tous les cas on ajoute au texte
	append TexteDuLog "$txt${bn}"
	return
    }

    if {$Toggle(AuLog)} {
	if {! [info exists wtlog]} {
	    set wlog ".wlog"
	    toplevel $wlog
	    wm title $wlog "Ordali Log Console"
	    wm iconname $wlog "ordali log"
	    wm protocol $wlog WM_DELETE_WINDOW KillParLaCroix
	    lower $wlog $NomFenetreOrdali

	    set wtlog "$wlog.frmt.text"
	    frame $wlog.frmt
	    scrollbar $wlog.frmt.scroll  -width 8  -command "$wlog.frmt.text yview "
	    text $wlog.frmt.text  -height 25 -width 80  -yscrollcommand "$wlog.frmt.scroll set"  -font "Courier 10"  -bg white
	    pack $wlog.frmt.text -fill both -side left -expand 1
	    pack $wlog.frmt.scroll -side left -fill y
	    pack $wlog.frmt -side top

	    frame $wlog.frmb
	    pack $wlog.frmb -side bottom -fill x -padx 5 -pady 10

	    button $wlog.frmb.save -text " Save " -background green1 -command "SauveLeLog"
	    button $wlog.frmb.clear -text " Close " -background red -command "DetruitLogConsole"
	    pack $wlog.frmb.clear $wlog.frmb.save -side left -expand 1

	    set y [expr {[winfo screenheight $wlog] - 2*[winfo reqheight $wlog]}]

	    wm geom $wlog +0+$y

	    $wtlog insert end "$TexteDuLog${bn}"
	    $wtlog see end
	}

	$wtlog insert end "$txt${bn}"
	$wtlog see end
    }

    # Dans tous les cas on ajoute au texte
    append TexteDuLog "$txt${bn}"

    return

}

proc AuLogWindow {{args JSuisBidon}} {

    global TexteDuLog Toggle NomFenetreOrdali wtlog Defauts LogTampon inBeginLog

    switch [lindex $args 0] {
	"-nonewline" {
	    set bn ""
	    set txt [lindex $args 1]
	}
	"LOutput" {
	    set what [lindex $args 1]
	    OutputTLog $what "$TexteDuLog"
	    return
	}
	default {
	    set bn "\n"
	    set txt [join $args " "]
	}
    }
    
    # voir ordali_tlog ....
    if {[regexp {^\@text} $txt]} {
	regsub -all "\n" $txt "AlALiGNe" txt
    }

    if {! [info exists wtlog]} {
	set inBeginLog 0
	set wlog ".wlog"
	toplevel $wlog
	wm title $wlog "Ordali Log Console"
	wm iconname $wlog "ordali log"
	wm protocol $wlog WM_DELETE_WINDOW KillParLaCroix
	lower $wlog $NomFenetreOrdali
	
	set wtlog "$wlog.frmt.text"
	frame $wlog.frmt
	scrollbar $wlog.frmt.scroll  -width 8  -command "$wlog.frmt.text yview "
	text $wlog.frmt.text  -height 25 -width 80  -yscrollcommand "$wlog.frmt.scroll set"  -font "Courier 10"  -bg white
	pack $wlog.frmt.text -fill both -side left -expand 1
	pack $wlog.frmt.scroll -side left -fill y
	pack $wlog.frmt -side top
	if {$::tcl_platform(platform) ne "unix"} {
	    bind $wlog.frmt.text  {%W yview scroll [expr {-%D/120}] units ; break}
	} else {
	    bind $wlog.frmt.text <4> {%W yview scroll -[set Defauts(DeltaYScroll)] units ; break}
	    bind $wlog.frmt.text <5> {%W yview scroll  [set Defauts(DeltaYScroll)] units ; break}
	}
	
	frame $wlog.frmb
	pack $wlog.frmb -side bottom -fill x -padx 5 -pady 10
	
	button $wlog.frmb.save  -text " Save "  -background green1  -command "SauveLeLog"
	button $wlog.frmb.clear  -text " Clear "  -background white  -command {DetruitLogConsole clear}
	button $wlog.frmb.destroy  -text " Close "  -background red  -command [list ToggleAuLog]
	pack $wlog.frmb.destroy $wlog.frmb.clear $wlog.frmb.save -side left -expand 1
	
	set y [expr {[winfo screenheight $wlog] - 2*[winfo reqheight $wlog]}]
	
	wm geom $wlog +0+$y
	
	
	if {[set toPrint [OutputTLog Text $TexteDuLog]] ne ""} {
	    $wtlog insert end $toPrint
	    $wtlog see end
	}
    }
    
    if {$txt ne "JSuisBidon"} {
	append TexteDuLog "${txt}$bn"
	if {[set toPrint [TraiteLogTampon "${txt}$bn"]] ne ""} {
	    $wtlog insert end $toPrint
	    $wtlog see end
	}
    }

    return

}

proc AuPif {{Min 0} {Max 1} {Type Int}} {


    if {![EstCeUnNombre $Min] || ![EstCeUnNombre $Max]} {return ""}
    if {$Max <= $Min} {return ""}
    
    set Diff [expr $Max - $Min]
    set Nombre [expr rand() * $Diff + $Min]
    
    if {$Type == "Int"} {
	set Nombre [expr round($Nombre)]
    }
    return $Nombre

}

proc AuSecours {{quoi ""}} {


if {$quoi != ""} {
demo help-$quoi
return
}

set w .help
toplevel $w
wm title $w "Help on Ordali"
set widgetDemo 1

set font {Helvetica 14}

frame  $w.buttons
pack   $w.buttons -side bottom -fill x -pady 2m
button $w.buttons.ok -background green1 -text "OK" -command "destroy $w"
pack   $w.buttons.ok -anchor s -expand 1

frame $w.statusBar
label $w.statusBar.lab -text "   "  -relief sunken -bd 1  -font $font -anchor w
label $w.statusBar.foo -width 8  -relief sunken -bd 1  -font $font -anchor w
pack $w.statusBar.lab -side left -padx 2 -expand yes -fill both
pack $w.statusBar.foo -side left -padx 2
pack $w.statusBar -side bottom -fill x -pady 2

frame     $w.textFrame
pack      $w.textFrame   -expand 1 -fill both
text      $w.textFrame.t  -yscroll "$w.textFrame.s set"  -wrap word  -width 60 -height 30  -font $font -setgrid 1  -highlightthickness 0  -padx 4 -pady 2  -takefocus 0
scrollbar $w.textFrame.s  -orient vertical  -command "$w.textFrame.t yview"  -highlightthickness 0 -takefocus 0
pack      $w.textFrame.s -side right -fill y
pack      $w.textFrame.t -expand 1 -fill both -padx 1


# Create a bunch of tags to use in the text widget, such as those for
# section titles and demo descriptions.  Also define the bindings for
# tags.

$w.textFrame.t tag configure title -font {Helvetica 24 bold}

# We put some "space" characters to the left and right of each demo description
# so that the descriptions are highlighted only when the mouse cursor
# is right over them (but not when the cursor is to their left or right)
#
$w.textFrame.t tag configure demospace  -lmargin1 1c -lmargin2 1c
$w.textFrame.t tag configure center -justify center


if {[winfo depth $w] == 1} {
$w.textFrame.t tag configure demo  -lmargin1 1c -lmargin2 1c  -underline 1
$w.textFrame.t tag configure visited -lmargin1 1c -lmargin2 1c  -underline 1
$w.textFrame.t tag configure hot  -background black -foreground white
} else {
$w.textFrame.t tag configure demo  -lmargin1 1c -lmargin2 1c  -foreground blue -underline 1
$w.textFrame.t tag configure visited -lmargin1 1c -lmargin2 1c  -foreground "#303080" -underline 1
$w.textFrame.t tag configure hot  -foreground red -underline 1
}

$w.textFrame.t tag bind demo  {Appel .help.textFrame.t [.help.textFrame.t index {@%x,%y}]}

set lastLine ""

$w.textFrame.t tag bind demo  {
set lastLine [.help.textFrame.t index {@%x,%y linestart}]
.help.textFrame.t tag add hot "$lastLine +1 chars" "$lastLine lineend -1 chars"
.help.textFrame.t config -cursor hand2
showStatus .help.textFrame.t [.help.textFrame.t index {@%x,%y}]
}

$w.textFrame.t tag bind demo  {
.help.textFrame.t tag remove hot 1.0 end
.help.textFrame.t config -cursor xterm
.help.statusBar.lab config -text ""
}

$w.textFrame.t tag bind demo  {
set newLine [.help.textFrame.t index {@%x,%y linestart}]
if {[string compare $newLine $lastLine] != 0} {
.help.textFrame.t tag remove hot 1.0 end
set lastLine $newLine

set tags [.help.textFrame.t tag names {@%x,%y}]
set i [lsearch -glob $tags help-*]
if {$i >= 0} {
.help.textFrame.t tag add hot "$lastLine +1 chars" "$lastLine lineend -1 chars"
}
}
}

# Create the text for the text widget.

$w.textFrame.t insert end "Ordali help" {title center}

$w.textFrame.t insert end {

This is the Ordali help. It is organize in a hierarchical manner. You can at any time remove the help pages open in clicking the Dismiss All button.

}

$w.textFrame.t insert end "General" title
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "1. What is Ordali ?" {demo help-general}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "2. Main principles" {demo help-principes}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "3. Further Developments" {demo help-whatnext}
$w.textFrame.t insert end " \n " {demospace}

$w.textFrame.t insert end \n {} "File Menu" title
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "1. Open ..." {demo help-open}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "2. Close ..." {demo help-close}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "3. Change Preferences" {demo help-preferences}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "3. Save Database" {demo help-savedb}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "3. Load Database" {demo help-loaddb}
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end \n {} "Groups" title
$w.textFrame.t insert end " \n " {demospace}
$w.textFrame.t insert end "1. Without scrollbars." {demo help-entry1}
$w.textFrame.t insert end " \n " {demospace}

$w.textFrame.t configure -state disabled
focus $w.textFrame.s

$w.textFrame.t configure -state disabled



}

proc Aujourdhui {} {

    scan [Today] "%s %s %s %s" S J M A
    set Aujourdhui "[Traduction $S francais] $J [Traduction $M francais] $A"
    return $Aujourdhui

}

proc AutoPathes {} {

    set RivetBob [list /usr/lib/tcltk/rivet2.1 /usr/lib/tcltk/rivet2.1/rivet-tcl /usr/lib/tcltk/rivet2.1/packages /usr/lib/tcltk/rivet2.1/packages-local /usr/lib/tcltk/rivet2.1 /usr/share/tcltk/tcl8.5 /usr/share/tcltk /usr/lib /usr/local/lib/tcltk /usr/local/share/tcltk /usr/lib/tcltk/x86_64-linux-gnu /usr/lib/tcltk /usr/share/tcltk/tcllib1.15 . /usr
/local/ActiveTcl/lib /usr/local/ActiveTcl/lib/tcllib1.14 /usr/local/ActiveTcl/lib/tcl3d0.4.1 /usr/local/ActiveTcl/lib/tklib0.4 /usr/local/ActiveTcl/lib/tclx8.4]
    set RivetEna [list /usr/lib/tcltk/rivet2.1 /usr/lib/tcltk/rivet2.1/rivet-tcl /usr/lib/tcltk/rivet2.1/packages /usr/lib/tcltk/rivet2.1/packages-local /usr/lib/tcltk/rivet2.1 /usr/share/tcltk/tcl8.5 /usr/share/tcltk /usr/lib /usr/local/lib/tcltk /usr/local/share/tcltk /usr/lib/tcltk/x86_64-linux-gnu /usr/lib/tcltk /usr/share/tcltk/tcllib1.15 . /usr/local/ActiveTcl/lib /usr/lib/tclx8.4 /usr/local/ActiveTcl/lib/tcl3d0.4.1 /usr/local/ActiveTcl/lib/tcllib1.14 /usr/local/ActiveTcl/lib/tklib0.4]

    EspionneL [ListsComplement $RivetEna $RivetBob]
    exit

}

proc AutorisationPourPsy {} {


    global AutorisationPourPsy
    if { ! [info exists AutorisationPourPsy]} {
	set AutorisationPourPsy -3
    }

    if { $AutorisationPourPsy==1 } { return 1 }
    if { $AutorisationPourPsy==0 } { return 0 }
    set Cou [Entre "Donnez la plus belle couleur pour une 2cv : "]   
    incr AutorisationPourPsy
    if { ! [regexp -nocase "rouge" $Cou] } { return 0 }
    set AutorisationPourPsy 1
    return 1

}

proc AutreAccessDansGM {X} {

    global LesAccessBanqueDeDecrypthon LesAccessDecrypthonDeBanque

    if {[info exists LesAccessBanqueDeDecrypthon($X)]} { return [set LesAccessBanqueDeDecrypthon($X)] }
    if {[info exists LesAccessDecrypthonDeBanque($X)]} { return [set LesAccessDecrypthonDeBanque($X)] }
    if {[info exists LesAccessDecrypthonDeBanque("EstCharge")]} { return "" }
    set LesAccessDecrypthonDeBanque("EstCharge") 1

    set file2 "/decrypthon/XRefs/GM_REFS";

    foreach Ligne [LesLignesDuFichier $file2] {
	scan $Ligne "%s %s" AD AB
	lappend LesAccessBanqueDeDecrypthon($AD) $AB
	lappend LesAccessDecrypthonDeBanque($AB) $AD
    }
    return [AutreAccessDansGM $X]

}

proc AutreAccessDansXref {X} {

    global LesAccessProtDeDecrypthon LesAccessDecrypthonDeProt

    if {[info exists LesAccessProtDeDecrypthon($X)]} { return [set LesAccessProtDeDecrypthon($X)] }
    if {[info exists LesAccessDecrypthonDeProt($X)]} { return [set LesAccessDecrypthonDeProt($X)] }
    if {[info exists LesAccessDecrypthonDeProt("EstCharge")]} { return "" }
    set LesAccessDecrypthonDeProt("EstCharge") 1

    set file1 "/decrypthon/XRefs/xrefs_red.dump";	  

    foreach Ligne [LesLignesDuFichier $file1] {
	scan $Ligne "%s %s" AD AP
	lappend LesAccessProtDeDecrypthon($AD) $AP
	lappend LesAccessDecrypthonDeProt($AP) $AD
    }
    return [AutreAccessDansXref $X]

}

proc AutreCode {X} {

    global RepertoireDuGenome
    global AutreCode

    if { ! [info exists AutreCode]} {
	foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/lookup"] {
	    scan $Ligne "%s %s" Nom AA
	    set AutreCode($Nom) $AA
	    set AutreCode($AA)  $Nom
	}
    }
    return [set AutreCode($X)]

}

proc AutreCodeLuc {X} {

    if {! [info exists ::AutreCodeLuc]} {
	InitCode3l1l
    }

    if {[info exists ::AutreCodeLuc($X)]} {
	return [set ::AutreCodeLuc($X)]
    } else {
	set n [string length $X]
	switch $n {
	    1 {return "XXX"}
	    3 {return "X"}
	}
    }

}

proc AutreTest {CodeGscope} {

    
    set RepertoireDeDomaines "[RepertoireDuGenome]/PDBParDomaine/$CodeGscope"
    #faut que je test Si y a un fichier MSF pour ne pas avoir de message d'erreur!!
    set r [glob -directory $RepertoireDeDomaines *.msf]
    foreach fichier $r {
	Espionne "R: $r"
    }

}

proc AutreTest2 {CodeGscope} {

    Espionne $CodeGscope

}

proc AutresNomsAff {quoi} {

    ChangeNomsAff $quoi
    AfficheNomsEtSeqs
    RepeintNoms

    return

}

proc AvecKegg {Nom} {

    global AvecKegg
    if {[info exists AvecKegg($Nom)]} { return $AvecKegg($Nom) }
    if {[info exists AvecKegg("EstCharge")]} { return "NotAvailable" }
    set AvecKegg("EstCharge") 1
    set FK [Fiches "Kegg"]
    if {[FileAbsent $FK]} { return 0 }
    foreach Ligne [LesLignesDuFichier $FK] {
	set NomLu ""
	scan $Ligne "%s" NomLu
	if {[regexp "Nothing" $Ligne]} {
	    set AvecKegg($NomLu) "Nothing"
	} else {
	    set AvecKegg($NomLu) "Yes"
	}
    }
    return [AvecKegg $Nom]

}

proc AvecPkTable {Table} {

    if {[regexp -nocase "RetinoBase" $Table]} { return 1 }
    if {[WithinGenoret] || [WithinFed]} { return 0 }
    if {[regexp -nocase "^LN_" $Table]} { return 0 }
    return 0
    return 1

}

proc AverageEntropy {LesNbDesClustersDesBranches {NbTotDesBranches ""}} {

    if {$NbTotDesBranches == ""} {
	foreach LesNbDesClustersDeLaBranche $LesNbDesClustersDesBranches {
	    foreach Nb $LesNbDesClustersDeLaBranche {
		set NbTotDesBranches [expr $NbTotDesBranches + $Nb]
	    }
	}
    }
    set AverageEntropy 0
    foreach LesNbDesClustersDeLaBranche $LesNbDesClustersDesBranches {
	set NbDeLaBranche 0
	foreach Nb $LesNbDesClustersDeLaBranche {set NbDeLaBranche [expr $NbDeLaBranche + $Nb]}
	set Entropy        [Entropy $LesNbDesClustersDeLaBranche]
	set PBranche       [expr $NbDeLaBranche * 1.0 / $NbTotDesBranches]

	set AverageEntropy [expr $AverageEntropy + $PBranche * $Entropy]
    }
    return $AverageEntropy

}

proc Axe_R {R} {

    return [lrange $R 1 end]

}

proc BAIOX {Ligne {AcceptIdOnly ""}} {

    set AcceptIdOnly [string equal -nocase "AcceptIdOnly" $AcceptIdOnly]
    scan $Ligne "%s" BAI
    set B ""; set Ac "" ; set Id ""; set OX "" 
    lassign [split $BAI "|"] B Ac Id
    set OX [IntegerApres "OX=" dans $Ligne]

    
    if {$B eq "" || $Ac eq "" || $Id eq "" || $OX eq ""} {
	if {$AcceptIdOnly} {
	    set Ac "Access$BAI"
	    set Id $BAI
	} else {
	    FaireLire "$Ligne\nsomething is wrong"
	}
    }
    return [list $B $Ac $Id $OX]

}

proc BBox3D {L} {

    set xm  9999. ; set ym  9999. ; set zm  9999.
    set xx -9999. ; set yx -9999. ; set zx -9999.
    foreach v $L {
	lassign $v x y z
	if {$x < $xm} {set xm $x}
	if {$y < $ym} {set ym $y}
	if {$z < $zm} {set zm $z}

	if {$x > $xx} {set xx $x}
	if {$y > $yx} {set yx $y}
	if {$z > $zx} {set zx $z}
    }

    return [list $xm $xx $ym $yx $zm $zx]

}

proc BCMT {} {

    global PfamDir

    BCM_setup

    #cd $PfamDir
    LitLeTFA PF01405.12 LNOrdali Sequences
    #DecortiqueUnTFA PF00001.16 LNOrdali Sequences
    puts "len ori [string length [set Sequences([lindex $LNOrdali 0])]]"
    BCM_SamplePfam PF01405.12 LNOrdali Sequences
    foreach n $LNOrdali {
	lappend Ls [set Sequences($n)]
    }
    puts "len avant [string length [lindex $Ls 0]]"
    #set Ls [lrange $Ls 0 15]
    #set LNOrdali [lrange $LNOrdali 0 15]
    set Lso [EnleveColonnesGaps $LNOrdali $Ls]
    puts "len apres [set ap [string length [lindex $Lso 0]]]"
    if {$ap == 0} {
	foreach n $LNOrdali s $Ls {
	    puts "$n $s"
	}
    }
    exit

}

proc BCM_AnalyseRes {} {

    global db GR Lrm
    
    set db root
    sqlite3 $db bench.sql
    $db eval {begin transaction}
    
    set GR(vis) [list]
    set Lgap [lsort -real [$db eval {select distinct gapthr from results}]]
    puts "Number of gap thresholds [llength $Lgap]"
    set GR(Lgap) $Lgap
    set Lmeth [list]
    set Largs [$db eval "select args from results where gapthr=[lindex $Lgap 0]"]
    foreach a $Largs {
	lassign [lindex $a 0] id file meth cm
	lappend Lmeth $meth
    }
    set Lmeth [lsort -unique $Lmeth]
    set GR(Lmeth) $Lmeth
    puts "Number of scoring methods [llength $Lmeth]"
    set Lcm [$db eval {select distinct cm from results}]
    set GR(Lcm) $Lcm
    puts "Number of clustering methods [llength $Lcm]"
    puts "List of parameters done ..."
    
    # Decoupage d'analyse
    set Llim [list 0. 100. 0. 30. 30. 50. 50. 100.]
    foreach {a b} $Llim {
	lappend GR(Llim) "$a $b"
    }
    # pfam stats
    set Lplni [$db eval {select pfamid,lgt,nseqs,idm from pfam}]
    foreach {pfid lgt nseqs idm} $Lplni {
	lappend Lpfamid $pfid
	lappend Llgt $lgt
	lappend Lnseqs $nseqs
	lappend Lidm $idm
    }

    puts ""
    puts "---------------------------------------"
    puts "# Brut Pfam stats "
    puts "---------------------------------------"
    puts ""
    foreach {deb fin} $Llim {
	set midm 0.0 ; set mseqs 0.0 ; set mlgt 0.0
	set midm2 0.0 ; set mseqs2 0.0 ; set mlgt2 0.0
	set count 0
	foreach idm $Lidm nseqs $Lnseqs lgt $Llgt {
	    if {! ($idm >= $deb && $idm < $fin)} {
		continue
	    }
	    
	    set midm [expr {$midm + $idm}]
	    set mlgt [expr {$mlgt + $lgt}]
	    set mseqs [expr {$mseqs + $nseqs}]
	    
	    set midm2  [expr {$midm2 + $idm*$idm}]
	    set mlgt2  [expr {$mlgt2 + $lgt*$lgt}]
	    set mseqs2 [expr {$mseqs2 +$nseqs*$nseqs}]

	    incr count
	}
	puts "# $deb - $fin "
	puts "Number of elements ..  $count"
	set midm [expr {$midm / $count}]
	set sdidm [expr {sqrt($midm2/double($count) - $midm*$midm)}]
	puts [format "mean/sd identity ....  %6.2f/%6.2f" $midm $sdidm]
	set mlgt [expr {double($mlgt) / $count}]
	set sdlgt [expr {sqrt(double($mlgt2)/$count - $mlgt*$mlgt)}]
	puts [format "mean/sd length ......  %6.2f/%6.2f" $mlgt $sdlgt]
	set mseqs [expr {double($mseqs) / $count}]
	set sdseqs [expr {sqrt(double($mseqs2)/$count - $mseqs*$mseqs)}]
	puts [format "mean/sd nbr seqs ....  %6.2f/%6.2f" $mseqs $sdseqs]
    }

    # global stats
    foreach pfid $Lpfamid {
	set LSA [$db eval {select r.posAl from residues as r, pfam as p where  r.pk_pfam=p.pk_pfam and  p.pfamid=$pfid and  (r.type='CSA' or r.type='Prosite')  }]
	
	set tmp [list]
	foreach e $LSA {
	    if {[string is list -strict $e]} {
		lappend tmp {*}$e
	    } elseif {$e eq "" || $e == {} || $e eq "{}"} {
		continue
	    } else {
		lappend tmp $e
	    }
	}
	set LSA [lsort -unique -integer $tmp]
	set TLSA($pfid) $LSA
    }
    puts "List of Pfam done ..."
    puts ""

    if {0} {
	GAR
	$db eval {commit}
	$db close
	return
    }

    array set Lrm [list]
    foreach {pcmin pcmax} $Llim {
	# take pfam under consideration
	set Lpfamid [lsort -unique -dictionary [$db eval {select pfamid from pfam where idm > $pcmin and idm <= $pcmax}]]
	set LSpfamid [list]
	set nLSA 0
	foreach z $Lpfamid {
	    lappend LSpfamid "'$z'"
	    incr nLSA [llength [set TLSA($z)]]
	}
	
	# gap threshold
	foreach gt $Lgap {
	    # methodes clustering
	    foreach cm $Lcm {
		unset -nocomplain T
		set Lpkresag [$db eval "select pk_results,job,args from results where job in ([join $LSpfamid ,]) and cm=''$cm'' and gapthr=$gt"]
		set Lpkres [list]
		foreach {pk job ar} $Lpkresag {
		    lassign [lindex $ar 0] tmp tmp mth tmp
		    lappend T($mth,pkr) $pk
		    set T($pk) $job
		}
		
		# par methode de scoring 
		set nTot 0
		foreach meth $Lmeth {
		    set Lpkres [set T($meth,pkr)]
		    if {$Lpkres == {}} {
			puts "Aucune valeur !\n"
			continue
		    }
		    
		    set npkr [llength $Lpkres]
		    set nTP 0 ; set nFP 0
		    set nTN 0 ; set nFN 0
		    set nFind 0
		    foreach pkr $Lpkres {
			set Lfl [$db eval {select pos,lgt from results where pk_results=$pkr}]
			lassign $Lfl Lfind lgt
			set Lfind [lsort -unique -integer $Lfind]
			incr nFind [llength $Lfind]
			set pfid [set T($pkr)]
			set LSA  [set TLSA($pfid)]
			incr nTot $lgt

			set TP [ListsIntersection $Lfind $LSA]
			set nbTP [llength $TP]
			set FN [lor $LSA $Lfind from1]
			set nbFN [llength $FN]
			set FP [lor $LSA $Lfind from2]
			set nbFP [llength $FP]
			set nbTN [expr {$lgt - [llength $LSA] - $nbFN}]
			
			foreach v {TP FP TN FN} {
			    incr n$v [set nb$v]
			}
		    }
		    # Sens= VraiPos / (VraiPos + FauxNeg)
		    set sens [expr {1.0*$nTP/($nTP+$nFN)}]
		    # Spec= VraiNeg / (VraiNeg +FauxPos)
		    set spec [expr {1.0*$nTN/($nTN+$nFP)}]
		    # Power
		    set power [expr {$sens+$spec-1.}]
		    lappend Lrm($pcmin,$pcmax,$gt,$cm) [list $meth $sens $spec $power $nTot $nLSA $nFind $npkr]
		}
	    }
	}
    }

    GAR
    $db eval {commit}
    $db close
    return

    #
    # Create output
    foreach {pcmin pcmax} $Llim {
	set Ltot [list]
	puts "\n=================="
	puts "# $pcmin - $pcmax"
	puts "------------------\n"
	foreach gt $Lgap {
	    set tmp [lindex [array names Lrm "$pcmin,$pcmax,$gt,*"] 0]
	    lassign [lindex $Lrm($tmp) 0] x y z k nTot nLSA nFind nres
	    puts ""
	    puts "Gap Threshold ..........: $gt"
	    puts "Nbr total colonnes .....: $nTot"
	    puts "Nbr sites vrais ........: $nLSA"
	    foreach cm $Lcm {
		puts "Clustering method ......: $cm\n"
		
		set Lval [list]
		foreach v [lsort [set Lrm($pcmin,$pcmax,$gt,$cm)]] {
		    lassign $v meth sens spec power nTot nLSA nFind npkr
		    lappend Lval $v
		    lappend Ltot [list {*}$v $gt $cm]
		    puts [format "%6.4f %6.4f %6.4f | %4d | %s" $sens $spec $power $npkr $meth]
		}

		# 10 meilleurs sens
		foreach {titre idx} [list Sensibility 1 Specificity 2 Power 3] {
		    puts "\n$titre"
		    set Lval [lsort -decreasing -real -index $idx $Lval]
		    set i 1
		    puts "   | sensib specif power  | sco. meth."
		    foreach v [lrange $Lval 0 9] {
			lassign $v me ss sp pw nf
			puts [format "%2d | %6.4f %6.4f %6.4f | %5d | %s" $i $ss $sp $pw $nf $me]
			incr i
		    }
		}
		puts ""
	    }
	}
	# stats globales
	puts "\n======================"
	puts "| Best of "
	puts "======================\n"
	foreach {titre idx} [list Sensibility 1 Specificity 2 Power 3] {
	    puts "\n$titre"
	    set Ltot [lsort -decreasing -real -index $idx $Ltot]
	    set i 1
	    puts "   | sensib specif power  | gapT ClusM "
	    foreach v [lrange $Ltot 0 9] {
		lassign $v me ss sp pw tmp tmp tmp gt cm
		puts [format "%2d | %6.4f %6.4f %6.4f | %4.2f %s %s" $i $ss $sp $pw $gt $cm $me]
		incr i
	    }
	}
    }
    
    $db eval {commit}
    $db close
    
    exit

}

proc BCM_CheckIDs {Lpdb2id pfamid} {

    global LNOrdali Sequences LSOrdali

    # cree id "propres"
    set tmp [list]
    foreach n $LNOrdali {
	lappend tmp [lindex [split $n "/"] 0]
    }

    set Ldel [list]
    foreach {pk id} $Lpdb2id {
	if {$id ni $tmp} {
	    lappend Ldel $pk
	    puts "  !! $id not present !!"
	}
    }

    # enleve de Lpdbid
    if {$Ldel != {}} {
	set nl [list]
	foreach {pk id} $Lpdb2id {
	    if {$pk in $Ldel} {continue}
	    lappend nl $pk $id
	}
	set Lpdb2id $nl
    }

    return $Lpdb2id

}

proc BCM_CreateJobs2Do {} {

    global Dbcm dres

    # - liste pfam2do
    set Lpkpfam [lsort -integer [$::db eval {select pk_pfam from pfam}]]
    #set Lpkpfam [lrange $Lpkpfam 0 50]
    puts "nbr pfam a faire : [llength $Lpkpfam]"
    
    $dres eval {begin transaction}
    foreach pk $Lpkpfam {
	$dres eval {insert into tests values (NULL,$pk,NULL,'-1',0)}
	lappend Lj2d [list $pk ""]
    }
    $dres eval {commit}
    puts "Nbr jobs a faire [llength $Lpkpfam]"

    return $Lj2d

}

proc BCM_CreateJobs2Do_Tests {{PTest ""}} {

    global Dbcm db

    if {$PTest eq ""} {
	# - liste pfam2do
	set Lpkpfam [BCM_TriePfam2Do]
    } else {
	set Lpkpfam [$db eval {select pk_pfam from pfam where pfamid=$PTest}]
    }
    puts "nbr pfam a faire : [llength $Lpkpfam]"

    # liste des fonction scoring
    #   -> 5 paquets (cf Valdar) :
    #       - symbol frequency
    #       - symbol entropy
    #       - stereochemical
    #       - stereochemically sensitive entropy SSE
    #       - substitution matrix
    #
    
    #set Lmeth [list Liu Dist Liu2 VolPol RPCA Williamson Kabat Entrop1]
    #set Lmeth [list Thompson Liu2 RPCA Williamson Kabat Entrop1]
    set Lmeth [list BILD Thompson Entrop1 Liu2 Williamson Kabat RPCA Norm SanderSP Peivar Karlin Valdar Capra Wang Caffrey]

    set LGrMeth [list  [list Kabat]  [list Norm RPCA]  [list Wang Capra]  [list Entrop1 Williamson Caffrey]  [list Karlin BILD Thompson SanderSP Valdar Peivar Liu2]]
    
    #  -> faire les paires entre categories
    set Lmdbl [list]
    if {1} {
	set i 1 ; set tmp [list]
	foreach g1 [lrange $LGrMeth 0 end-1] {
	    foreach g2 [lrange $LGrMeth $i end] {
		foreach m1 $g1 {
		    foreach m2 $g2 {
			lappend tmp [list $m1 $m2]
		    }
		}
	    }
	    incr i
	}
	set Lmdbl $tmp
    }

    # -> faire les triplets
    set Lmtpl [list]
    if {0 && [llength $Lmeth] > 2} {
	set i 1; set j 2; set tmp [list]
	foreach m1 [lrange $Lmeth 0 end-2] {
	    foreach m2 [lrange $Lmeth $i end-1] {
		foreach m3 [lrange $Lmeth $j end] {
		    lappend tmp [list $m1 $m2 $m3]
		}
		incr j
	    }
	    incr i
	}
	set Lmtpl $tmp
    }

    if {$Lmdbl != {} } {
	lappend Lmeth {*}$Lmdbl
    }
    if {$Lmtpl != {} } {
	lappend Lmeth {*}$Lmtpl
    }

    # clustering methods
    set Lmclus [list mixturemodel secator dpc]

    set Lj2d [list]
    foreach pk $Lpkpfam {
	set pfamid [$db eval {select pfamid from pfam where pk_pfam=$pk}]
	set fpfam [lindex [lsort [glob -nocomplain [file join /genomics/link/Pfam "${pfamid}*"]]] end]

	foreach m $Lmeth {
	    foreach cm $Lmclus {
		lappend Lj2d [list $pfamid [list $pk $fpfam $m $cm]]
	    }
	}
    }
    puts "Nbr jobs [llength $Lj2d]"

    return $Lj2d

}

proc BCM_CreeBenchmarkPfam {} {

    global db dps ConsRef PfamDir ListePDB LNOrdali Sequences T

    BCM_setup

    set dps rpros
    sqlite3 $dps Prosite.sql
    set db root
    sqlite3 $db bench.sql

    # Inits
    set ListePDB [list]

    # CSA
    BCM_LoadCSADB

    # - pdbmap : lien pfam <-> pdb
    # -> prend id pdb et id pfam
    
    $db eval {begin transaction}

    set Lpf [lsort -unique -dictionary [$db eval {select pfamid from pdbmap}]]
    puts "nbr of pfam .... : [llength $Lpf]"

    #set fin 10
    set fin end
    foreach pfamid [lrange $Lpf 0 $fin] {
	puts "\n$pfamid"
	puts "----------"
	set pfile [lindex [lsort [glob -nocomplain [file join $PfamDir "${pfamid}*_smp"]]] end]
	
	set pk [lindex [$db eval {select pk_pfam from pfam where pfamid=$pfamid}] 0]

	# Read alignment
	puts "reading [file join $PfamDir $pfile]"
	DecortiqueUnTFA [file join $PfamDir $pfile] LNOrdali Sequences
	foreach n $LNOrdali {
	    set nid [lindex [split $n "/"] 0]
	    set T($nid) $n
	}

	# -> cherche pdb du pfam
	set Lpdbv [$db eval {select pdbid,chn,acc,id,pdeb,pfin,sdeb,sfin from pdbmap where pfamid=$pfamid}]
	puts "Nbr potentials PDB .....: [expr {[llength $Lpdbv]/8}]"

	# -> dans CSA	
# -> corespondance res CSA -> ali pfam
	BCM_MapCSA2Pfam $Lpdbv $pfile

	# -> residues interface
	# -> correspondance res interface -> ali pfam
	BCM_MapInterface2Pfam $Lpdbv $pfile

	# -> residues PROSITE
	BCM_MapProsite2Pfam $Lpdbv $pfile

	unset -nocomplain LNOrdali Sequences T LSOrdali
	update
    }

    $db eval {commit}
    $db close
    $dps close

    exit

}

proc BCM_CreeThread {} {

    global TDT 

    thread::errorproc BCM_ThreadError
    set Id [thread::create]
    set TDT($Id) $Id
    thread::configure $Id -unwindonerror 1
    thread::send $Id {
	set GscopeDir $env(GSCOPEDIR)
	set OrdaliDejaSource 1
	source [file join $GscopeDir gscope_source.tcl]    
	
	set OrdaliDir $env(ORDALIDIR)
	set OrdaliDejaSource 0
	source [file join $OrdaliDir src ordali_source.tcl]
	
	InitLesDefauts
	LesDefauts Mode batch
	
	package require Thread
	#LoadTclPackages
	#package require tclcluspack
	package require tclordalie
	#package require sqlite3
	set VariablesAuDepart [info globals]
	
	source /home/moumou/gscopublic/bcm.tcl
	source /home/moumou/gscopublic/bcm_setup.tcl
	source /home/moumou/gscopublic/bcm_run.tcl

	BCM_setup
    }
    puts "thread $Id created ([llength [thread::names]]) ...\n"
    flush stdout

    trace add variable TDT($Id) write BCM_RecupResults
    update

    return $Id

}

proc BCM_DoTests {} {

    global db dres CestFini TDT nThreads TMaster nDone Dbcm

    package require Thread

    puts "[DonneDateEtHeure]"
    set TMaster [thread::id]
    puts "\nThread Master : $TMaster\n"

    BCM_setup

    set nDone 0
    # old table 
    set db root
    sqlite3 $db bench.sql
    file delete -force dres.sql
    set dres [FabriqueDeTables $Dbcm(TableRes) dres dres.sql]

    # creation des jobs
    #set dres dres
    #sqlite3 $dres dres2.sql
    BCM_CreateJobs2Do

    set CestFini 0
    # Creation des threads et preserved
    set nThreads 20
    #set nThreads 135

    set listeID [list]
    thread::errorproc BCM_ThreadError
    for {set i 1} {$i < $nThreads} {incr i} {
	set Id [BCM_CreeThread]
	lappend ListeID $Id
    }
    foreach Id $ListeID {
	BCM_DonneUnJob $Id
    }

    # lance l'event loop du master
    vwait CestFini

    foreach a [array names TDT "tid*"] {
	if {[regexp {,} $a]} {continue}
	
	puts "trace $a [join [trace info variable $a] \n]"
    }
	
    $db close

    # Creation des Index
    $dres eval {begin transaction}
    $dres eval {create index idx_results on results (pk_tests,cm, gapthr, TP, FP, TN, FN)}
    $dres eval {commit}
    $dres close

    puts "[DonneDateEtHeure]"

    exit

}

proc BCM_DonneUnJob {lId} {

    global CestFini nDone TDT dres db
    
    set pkmin [$dres eval {select min(pk_tests) from tests where thread='-1'}]
    if {! [string is integer -strict $pkmin]} {
	puts "\nAll done !\nReleasing threads $lId ...\nNbr threads [llength [thread::names]]\n"
	set CestFini 1
	update

	return
    }
    
    set pkpfmeth [$dres eval {select pk_tests,pk_pfam,smeth from tests where pk_tests=$pkmin}]
    lassign $pkpfmeth pktest pkpfam Lmeth
    $dres eval {update tests set thread=$lId where pk_tests=$pkmin}
    set pfamid [$db eval {select pfamid from pfam where pk_pfam=$pkpfam}]

    set fpfam [glob [file join /home/moumou/work/moumou/BenchPfam "${pfamid}*"]]

    # cherche Vrai Positifs
    #set LVP [lsort -unique [$db eval {select posAl from residues where pk_pfam=$pkpfam}]]

    #pdbid 
    set Lpdb2id [$db eval {select pk_pdbmap,id from pdbmap where pfamid=$pfamid}]
    
    #set TDT($lId,Data) [list $pkpfam $pfam $Lmeth]
    set TDT($lId,Data) [list $pkpfam $fpfam]
    #thread::send -async $lId [list ::BCM_ThreadExe $pkpfam $pfam $Lmeth $LVP] TDT($lId)
    thread::send -async $lId [list ::BCM_ThreadExe $pkpfam $fpfam $Lpdb2id] TDT($lId)

    #puts "pkpfmeth $pkmin $pkpfmeth pour $lId"
    incr nDone
    if {! ($nDone % 1000)} {
	puts "... $nDone done ([llength [thread::names]]) [DonneDateEtHeure]"
	flush stdout
	update idletasks
    }
    update

    return

}

proc BCM_Init {} {

    global db PfamDir Dbcm Tsite

    # Init variables
    BCM_setup

    # cree db pour :
    # -> CSA
    #file delete -force bench.sql
    set db [FabriqueDeTables $Dbcm(tables) "" bench2.sql]
    puts "tables crees ..."

    # traite pdb mapped to pfam
    set Ll [LesLignesDuFichier [file join $PfamDir pdbmap]]
    puts "Nbr pdb mappes..... : [llength $Ll]"

    set badnum 0
    foreach l $Ll {
	set l [string map [list ";" ""] $l]
	set Lv [split $l "\t"]
	lassign $Lv idpdb chn pdf nmpfam idpfam acc adf
	lassign [split $pdf -] pd pf

	if {! [string is integer -strict $pd] || ! [string is integer -strict $pf]} {
	    incr badnum

	    continue
	}

	lassign [split $adf -] ad af

	if {! [info exists Psite($idpdb,$chn)]} {
	    set Psite($idpdb,$chn) [list]
	}
	lappend Psite($idpdb,$chn) [list $pd $pf $idpfam $acc $ad $af]
    }
    puts "bad numbering ..... : $badnum" 
    puts ""
    puts "Cross-check with CSA"

    set Lcsa [lsort -unique [BCM_LoadCSADB]]
    set nsite 0
    set Lpdb [list] ; set Lacc [list]
    $db eval {begin transaction}
    foreach k [array names Psite] {
	lassign [split $k ,] pdbid chn
	lappend Lpdb $pdbid
	set Ls [list]

	foreach kt [array names Tsite "$k,*"] {
	    lappend Ls {*}[set Tsite($kt)]
	}
	foreach Ldf [set Psite($k)] {
	    lassign $Ldf deb fin pfamid acc ad af
	    lappend Lacc $acc
	    foreach v $Ls {
		lassign $v nm nb
		if {$nb >= $deb && $nb <= $fin} {
		    $db eval {insert into pdbmap values (NULL,$pfamid,$pdbid,$chn,$deb,$fin,$acc,NULL,$ad,$af)}
		    incr nsite
		}
	    }
	}
    }
    $db eval {commit}
    puts "bad numbering ..... : $badnum" 
    puts "Nbr sites ......... : $nsite"
    puts "Nbr pdbs .......... : [llength [lsort -unique $Lpdb]]"

    set Lacin [lsort -unique $Lacc]
    set Lid [IDMapping "ACC+ID" ID $Lacin]
    puts ""
    puts "doublons access :"
    puts " in     [llength $Lacc]"
    puts " unique [llength $Lacin]"

    $db eval {begin transaction}
    set i 0
    foreach acc $Lacin id $Lid {
	if {$id eq ""} {
	    lappend Ldel $acc
	} else {
	    $db eval {update pdbmap set id=$id where acc=$acc}
	    incr i
	}
    }
    puts "Nbr UNmapped Access : [llength $Ldel]"
    puts "Nbr mappend........ : $i"
    foreach acc $Ldel {
	$db eval {delete from pdbmap where acc=$acc}
    }
    puts "-> reste en db..... : [$db eval {select count(pk_pdbmap) from pdbmap}]"
    $db eval {commit}

    if {0} {
	# doublons PFAM/ID pdb
	$db eval {begin transaction}
	set Lv [$db eval {select pfamid,id from pdbmap}]
	set Lpi [list]
	foreach {p i} $Lv {
	    lappend Lpi [list $p $i]
	}
	set Lpi [lsort -unique $Lpi]
	set Ldel [list]
	foreach e $Lpi {
	    lassign $e p i
	    set Lv [$db eval {select pk_pdbmap,sdeb,sfin from pdbmap where pfamid=$p and id=$i}]
	    set Ltpl [list]
	    foreach {a b c} $Lv {
		lappend Ltpl [list $a $b $c]
	    }
	    set Ltpl [lsort -unique -index 1 -integer  $Ltpl]
	    # is here only once
	    if {[llength $Ltpl] == 1} {
		continue
	    }
	    
	    set Lv [list]
	    foreach e $Ltpl {
		lappend Lv {*}$e
	    }
	    set Lv [lassign $Lv pkm sd0 sf0]
	    set lmax [expr {$sf0-$sd0+1}]
	    foreach {pk sd sf} $Lv {
		if {$sd >= $sf0} {
		    # new range
		    set sd0 $sd
		    set sf0 $sf
		    set pkm $pk
		    set lmax [expr {$sf0-$sd0+1}]
		    continue
		}
		
		if {($sf - $sd + 1) > $lmax} {
		    # don't keep old max
		    lappend Ldel $pkm
		    # define new max
		    set pkm $pk
		    set sd0 $sd
		    set sf0 $sf
		    set lmax [expr {$sf0-$sd0+1}]
		} else {
		    # not a max, delete
		    lappend Ldel $pk
		}
	    }
	}
	puts "doublon ID deb/fin par Pfam : [llength $Ldel]"
	if {[llength $Ldel] > 0} {
	    $db eval "delete from pdbmap where pk_pdbmap in ([join $Ldel ,])"
	}
	$db eval {commit}
	$db eval {vacuum}
	
	puts ""
	puts "TOTAL ENTRIES...... : [$db eval {select count(pk_pdbmap) from pdbmap}]" 
    }	

    # udate pfam table
    set Lv [lsort -unique [$db eval {select pfamid from pdbmap}]]
    $db eval {begin transaction}
    foreach pfamid $Lv {
	$db eval {insert into pfam values(NULL,$pfamid,NULL,NULL,NULL,NULL,NULL)}
    }
    $db eval {commit}
    $db eval {vacuum}

    # indexes
    $db eval {create index idx_pdbmap on pdbmap (pfamid, pdbid, chn, pdeb, pfin, acc, id, sdeb, sfin)}
    $db eval {create index idx_pfam on pfam (pfamid, nseqs, lgt)}
    $db close

    exit
    return

}

proc BCM_LoadCSA {} {

    global Tsite
    
    set Ll [LesLignesDuFichier [file join /home moumou ordali typify csa CSA_2_2_12.dat]]
    set nris 0
    foreach e [lrange $Ll 1 end] {
	# PDB ID,SITE NUMBER,RESIDUE TYPE,CHAIN ID,RESIDUE NUMBER,CHEMICAL FUNCTION,EVIDENCE TYPE,LITERATURE ENTRY
	lassign [split $e ,] pdbid snb rtype chn rnmr tmp tmp tmp

	set pdbid [string toupper $pdbid]
	if {[set res [AutreCodeLuc $rtype]] eq "XXX"} {
	    continue
	}

	if {! [info exists Tsite($pdbid,$chn,$snb)]} {
	    set Tsite($pdbid,$chn,$snb) [list]
	}
	lappend Tsite($pdbid,$chn,$snb) [list $res $rnmr]
	lappend Lpdb $pdbid
	incr nris
    }
    set Lpdb [lsort -unique $Lpdb]
    puts "CSA :"
    puts "-----"
    puts "Nombre pdbId .......... :[llength $Lpdb]"
    puts "Nombre res in sites ... : $nris"
    puts ""

    return $Lpdb

}

proc BCM_LoadCSADB {} {

    global Tsite

    if {[file exists sites_csa_data.tcl]} {
	source [file join /home moumou ordali typify sites_csa_data.tcl]
	foreach k [array names Tsite] {
	    incr nris [llength $Tsite($k)]
	}
	puts "CSA :"
	puts "-----"
	puts " ==> from file >sites_csa_data.tcl<"
	puts "Nombre pdbId .......... : [llength $Lpdb]"
	puts "Nombre res in sites ... : $nris"
	puts ""

	return $Lpdb
    }

    sqlite3 d [file join /home moumou ordali typify CSA_TABLES.db]
    d eval {begin transaction}
    
    # recupere sites annotes
    set La [d eval {select pdbId,type,number,chain,siteNumber from CSA_catalyticResidues}]
    # prend les homologues
    set Lh [d eval {select pdbId,residue,number,chain,siteNumber from CSA_homologueResidues}]
    set Lsites [concat $La $Lh]
    d eval {commit}
    d close
 
    # traitement
    set Lpdb [list]
    foreach {pdbid type nbr chn snb} $Lsites {
	set pdbid [string toupper $pdbid]
	set type [string toupper $type]
	if {[AutreCodeLuc $type] eq "X"} {
	    continue
	}

	if {$pdbid ni $Lpdb} {
	    lappend Lpdb $pdbid
	}

	if {! [info exists Tsite($pdbid,$chn,$snb)]} {
	    set Tsite($pdbid,$chn,$snb) [list]
	}
	set add [list $type $nbr]
	if {$add ni [set Tsite($pdbid,$chn,$snb)]} {
	    lappend Tsite($pdbid,$chn,$snb) $add
	    incr nris
	}
    }

    puts "CSA :"
    puts "-----"
    puts "Nombre pdbId .......... : [llength $Lpdb]"
    puts "Nombre res in sites ... : $nris"
    puts ""

    return $Lpdb

}

proc BCM_MapCSA2Pfam {Lpdbv pfam} {

    global db PfamDir Tsite ConsRef LNOrdali Sequences T

    set pfamid [lindex [split [file tail $pfam] .] 0]
    set pk [lindex [$db eval {select pk_pfam from pfam where pfamid=$pfamid}] 0]

    set nsf 0
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	if {! [info exists T($id)]} {
	    puts "error !"
	    puts "no T for $id (pdb $pdb acc $acc"
	    #exit
	    continue
	}
	set idn [set T($id)]

	# are there some CSA sites ?
	set La [array names Tsite "$pdb,$chn,*"]
	if {$La == {}} {
	    puts "No CSA sites found in $pdb $chn !"
	    continue
	}

	# take correspondance
	set nsf 0
	foreach a $La {
	    set Lres [set Tsite($a)] 
	    foreach rtn $Lres {
		lassign $rtn res rnb
		set rnm [AutreCodeLuc $res]
		# out from alignment
		if {$rnb < $pd || $rnb > $pf} {
		    continue
		}
		
		# Correspondance
		# 
		# PDB : 11  14        18
		# Seq : 15  18        22
		#     : A.DEF...GF...IL
		# Ali : 1   4         8
		# Mem : 0   3         7
		# 
		set x [expr {$rnb+($sd-$pd)-$sd}]
		set c [DonnePosSG $idn $x]
		lappend ConsRef($pf,CSA) $c
		$db eval {insert into residues values(NULL,$pk,$x,$c,'CSA')}
		incr nsf
	    }
	}
    }
    puts "Nombre site CSA ...... : $nsf"

    return

}

proc BCM_MapInterface2Pfam {Lpdbv pfam} {

    global PfamDir ConsRef db LNOrdali Sequences T

    # pdb list to retreive
    set Lpdb [list]
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	lappend Lpdb $pdb
    }
    set nri 0
    set pk [lindex [$db eval {select pk_pfam from pfam where pfamid=$pfamid}] 0]
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	if {! [info exists T($id)]} {
	    puts "$id not present !"
	    continue
	}
	set n [set T($id)]

	# -> search PDBe interface ID pdb
	set xml [PDBeInterface $pdb]
	if {[string range $xml 0 5] ne " retrieve interface residues for chain
	set Lres [ResiduesInterface $xml $pdb $chn]
	if {$Lres == {}} {
	    puts "Pas de residue interface in $pdb $chn !"

	    continue
	}
	
	# take correspondance
	set nri 0
	foreach r $Lres {
	    lassign $r rnb res
	    set rnm [AutreCodeLuc $res]
	    # out from alignment
	    if {$rnb < $pd || $rnb > $pf} {
		continue
	    }
	    # Correspondance
	    # 
	    # 15  18        22
	    # A.DEF...GF...IL
	    # 1   4         8
	    # 0   3         7
	    # 
	    set x [expr {$rnb+($sd-$pd)-$sd}]
	    set c [DonnePosSG $n $x]
	    lappend ConsRef($pf,Int) $c
	    $db eval {insert into residues values(NULL,$pk,$x,$c,'Interface')}

	    incr nri
	}
    }
    puts "Nombre residue Interface .. : $nri"

    return

}

proc BCM_Pdb2Pfam {pfamid Lpdb2id} {

    # checking if PDB IDs are present
    set Lpdb2id [BCM_CheckIDs $Lpdb2id $pfamid]

    # -> stats de pfam ID :
    # nseq, lg, min-max gaps, pci m - sd
    set Lout [BCM_PfamStats $pfamid $Lpdb2id]

    return $Lout

}

proc BCM_PfamStats {pfamid Lpdb2id} {

    global PfamDir LPCI LNOrdali Sequences LSOrdali

    set Nseq [llength $LNOrdali]
    puts "    Nombre sequences ..... : $Nseq"
    set Lgt  [string length [set Sequences([lindex $LNOrdali 0])]]
    puts "    Longueur initiale .... : $Lgt"

    # Nbr pdb dans le pfam
    puts "    IDs mapped to pdb .... : [expr {[llength $Lpdb2id]/2}]"

    # 1st sampling if more than 5000 seqs
    if {$Nseq > 5000} {
	puts "==> too many seqs -> samplling 3000"
	BCM_SamplePfam $Lpdb2id $pfamid LNOrdali Sequences 5000
	set Nseq [llength $LNOrdali]
	set LSOrdali [list]
	foreach n $LNOrdali {
	    lappend LSOrdali [set Sequences($n)]
	}
    }
    
    # remove seqs with 100% identity
    BCM_RemoveIdentities $Lpdb2id $pfamid LNOrdali Sequences 
    set LSOrdali [list]
    foreach n $LNOrdali {
	lappend LSOrdali [set Sequences($n)]
    }
    
    # PROSITE filter
    set fname "[TmpFile toto /tmp].[thread::id]"
    EcritLeTfa $fname $LNOrdali $LSOrdali
    set Lps [LesPrositesDuTFA $fname]
    file delete -force $fname
    file delete -force "${fname}.out"
    set Lnp [list]
    if {$Lps != {} } {
	foreach {acc Lv} $Lps {
	    foreach {p Lp} $Lv {
		lappend TP($p) $acc
	    }
	}
	set Lpat [array names TP]
	puts "    Patterns PROSITES ..... : $Lpat"
	set Lnp [list] ; set Lpf [list]
	# align final  < 500 seqs, so
	set ThrProsite 500 
	foreach p $Lpat {
	    set nocc [llength [set TP($p)]]
	    puts "    $p $nocc"
	    if {$nocc > $ThrProsite} {
		lappend Lnp $p
	    }
	}

	# prosite patterns have been choosen
	if {[llength $Lnp] > 1} {
	    set Lpf [set TP([lindex $Lnp 0])]
	    foreach p [lrange $Lnp 1 end] {
		set Lpf [land $Lpf [set TP($p)]]
	    }
	} elseif {[llength $Lnp] == 1} {
	    set Lpf [set TP($Lnp)]
	}

	if {[llength $Lpf] > 0} {
	    puts "    Nbr seq prosite ... : [llength $Lpf]"
	    set LNOrdali $Lpf
	    # 
	    # ATTENTION !
	    # ici on ENLEVE les pdb qui n'ont pas le
	    # motif prosite !!
	    set Lidn [list]
	    foreach n $LNOrdali {
		lappend Lidn [lindex [split $n /] 0]
	    }
	    set Ldel [list]
	    foreach {pk id} $Lpdb2id {
		if {$id ni $Lidn} {
		    lappend Ldel $pk
		}
	    }
	    if {$Ldel != {} } {
		set nl [list]
		foreach {pk id} $Lpdb2id {
		    if {$pk in $Ldel} {continue}
		    lappend nl $pk $id
		}
		set Lpdb2id $nl
	    }
	}
	set LSOrdali [list]
	foreach n $LNOrdali {
	    lappend LSOrdali [set Sequences($n)]
	}
    }
    puts ""

    # final sampling
    set Nseq [llength $LNOrdali]
    if {$Nseq > 500} {
	puts "==> too many seqs -> 1000"
	BCM_SamplePfam $Lpdb2id $pfamid LNOrdali Sequences
	set Nseq [llength $LNOrdali]
	set LSOrdali [list]
	foreach n $LNOrdali {
	    lappend LSOrdali [set Sequences($n)]
	}
    }
    
    # final round of gap removal
    set LSOrdali [EnleveColonnesGaps]
    unset -nocomplain Sequences
    foreach n $LNOrdali s $LSOrdali {
	set Sequences($n) $s
    }
    set Lgt [string length [set Sequences([lindex $LNOrdali 0])]]
    puts "    Longueur actuelle .... : $Lgt"

    # compute identities
    set SAli [list]
    foreach n $LNOrdali {
	lappend SAli $n [set Sequences($n)]
    }
    set LPCI [CalculeLesPCIGenerique $SAli]
    array set TPCI $LPCI
    
    # write stats ...
    set pf $pfamid
    set Nseq [llength $LNOrdali]
    set Lgt  [string length [set Sequences([lindex $LNOrdali 0])]]
    puts "    Nbr sequences ........ : $Nseq"
    puts "    Longueur ............. : $Lgt"

    # moyenne et ecart-type
    set Lv [list]
    foreach a $LNOrdali {
	foreach b $LNOrdali {
	    lappend Lv "$a,$b" [set TPCI($a,$b)]
	}
    }
    lassign [SM_StatPCI $Lv] m sd tmp tmp
    set PCIm $m
    set PCIsd $sd

    puts "    Identite moyenne ..... : [format %6.2f $m]"
    puts "    Identite ecart-type .. : [format %6.2f $sd]"
    set Lout [list $Nseq $Lgt $m $sd $Lnp]

    return $Lout

}

proc BCM_Puts {txt} {

    global PTxt

    if {! [info exists PTxt]} {set PTxt ""}
    if {$txt eq "decharge"} {return $PTxt}
    append PTxt "$txt\n"

    return

}

proc BCM_RecupResults {a b op} {

    global TDT db dres
    
    set Lres [set TDT($b)]
    if {[string range $Lres 0 4] ne "tid0x" || ! [string is list -strict $Lres]} {
	# on est en train de traiter une erreur !!
	puts "==> $b : $Lres\n$::errorInfo"

	after 1000
	set tid $b
	trace remove variable TDT($tid) write BCM_RecupResults
	
	set Larg [set TDT(${tid},Data)]
	if {[thread::exists $tid]} {
	    catch {thread::release $tid}
	}
	array unset TDT "${tid}*"
	update
	
	set pkt [$dres eval {select pk_tests from tests where thread=$tid}]

	# met le job du thread à -1
	$dres eval {update tests set res=-1,thread=0 where pk_tests=$pkt}
	
	puts "sort error\n$pkt $Larg [llength [thread::names]]"
	set b [BCM_CreeThread]
	after 1000
	BCM_DonneUnJob $b
	update

	return
    }

    lassign $Lres Id pkpfam smeth Lval
    if {$b ne $Id} {
	puts "\nProblem\n$b ne $Id !"
	flush stdout
	set b $Id
    }
    update idletasks
    
    set pkt [$dres eval {select pk_tests from tests where thread=$tid}]
    $dres eval {update tests set res=$ires,thread='0' where pk_tests=$pkt}
    set pfamid [$db eval {select pfamid from pfam where pk_pfam=$pkpfam}]

    lassign $Lval Nseq Lgt m sd Lpro

    $db eval {insert into pfam values(NULL,'$pfamid',NULL,$Nseq,$Lgt,$m,$sd)}
    foreach p $Lpro {
	$db eval {insert into propfam values(NULL,'$p','$pfamid')}
    }
    
    update

    BCM_DonneUnJob $b

    return

    if {0} {
	set YaErr 0
	set LErr [list]
	if {[llength $Lval] == 0} {
	    set YaErr 1
	    lappend LErr "Aucune valeurs !"
	}
	set Lcm [list "'dpc'" "'mm'" "'secator'"]
	foreach res $Lval {
	    lassign $res cm gap Lpos
	    if {$cm ni $Lcm} {set YaErr 1}
	    if {! [string is double $gap]} {set YaErr 1}
	    if {! [string is list -strict $Lpos]} {set YaErr 1}
	    
	    if {$YaErr} {
		lappend LErr $res
	    } else {
		if {[catch {$dres eval "insert into results values(NULL,$pkt,[join $res ,])"} Msg]} {
		    set YaErr 1
		    lappend LErr $res
		    lappend LErr $Msg
		}
	    }
	}
	
	set ires 1
	if {$YaErr} {
	    puts "\nProblem $b!\npkt $pkt smeth $smeth pfam $pkpfam\n[join $LErr \n]\n"
	    flush stdout
	    set ires -1
	}
	
	$dres eval {update tests set res=$ires,thread='0' where pk_tests=$pkt}
	
	update
	
	BCM_DonneUnJob $b
    }

    return

}

proc BCM_RemoveIdentities {Lpdb2id pfamid aL aS} {

    upvar $aL L $aS S

    foreach n $L {
	set sq [set S($n)]
	if {[info exists TDes3000($sq)]} {continue}
	set TDes3000($sq) 1
	set pn [lindex [split $n / ] 0]
	set NDes3000($pn) 1
	lappend Lsd $n
    }

    #
    # ACHTUNG !
    # a same pdbid can be present several times !
    # as several zones can match the current pfam !
    set Lpdbid [list]
    foreach {pk id} $Lpdb2id {
	lappend Lpdbid $id
    }
    set add 0 ; set prs 0
    foreach n $L {
	set idn [lindex [split $n "/"] 0]
	if {$idn in $Lpdbid} {
	    if {$n ni $Lsd} {
		lappend Lsd $n
		incr add
	    } else {
		incr prs
	    }
	    update
	}
    }
    puts "    PDB in db ....... : [llength $Lpdbid]"
    puts "    PDB presents .... : $prs"
    puts "    PDB rajoutes .... : $add"

    update
    
    return

}

proc BCM_SamplePfam {Lpdb2id pfamid aL aS {Nsmp 500}} {

    upvar $aL L $aS S

    set Lpris [list] ; set Lres [list]
    set lg [llength $L]
    set n 0
    while {$n < $Nsmp} {
	set i [expr {int(rand()*$lg)}]
	if {$i in $Lpris} {continue}

	lappend Lres [lindex $L $i]
	lappend Lpris $i
	incr n
    }

    # check if we have corresponding pdbs in sample
    #
    # ACHTUNG !
    # a same pdbid can be present several times !
    # as several zones can match the current pfam !
    set Lpdbid [list]
    foreach {pk id} $Lpdb2id {
	lappend Lpdbid $id
    }
    set add 0 ; set prs 0
    foreach n $L {
	set idn [lindex [split $n "/"] 0]
	if {$idn in $Lpdbid} {
	    if {$n ni $Lres} {
		lappend Lres $n
		incr add
	    } else {
		incr prs
	    }
	    update
	}
    }
    puts "    PDB in db ....... : [llength $Lpdbid]"
    puts "    PDB presents .... : $prs"
    puts "    PDB rajoutes .... : $add"

    # cree le nouveau pfam
    set Lseq [list]
    foreach n $Lres {
	lappend Lseq [set S($n)]
	set A($n) [set S($n)]
    }

    unset S
    set L $Lres
    array set S [array get A]
    update

    return

}

proc BCM_SplitPfamBrut {} {

    # take the fasta pfam file from ftp
    # split it into PFxxxxx files
    cd /genomics/link/Pfam
    set f [open Pfam-A.fasta r]
    set open 0 ; set pf "" ; set Lpf [list]
    while {[gets $f l] >= 0} {
	if {[string index $l 0] eq ">"} {
	    # nouvelle seq
	    set lori $l
	    regsub -all { +} [string trim $l] " " l
	    set l [string map [list " " ";"] $l]
	    set pf [lindex [split $l ";"] 2]
	    lappend Tpf($pf) $lori
	} else {
	    lappend Tpf($pf) $l
	}
    }
    foreach pf [array names Tpf] {
	set o [open $pf w]
	puts $o [join [set Tpf($pf)] \n]
	close $o
    }

    exit

}

proc BCM_StatDB {} {

    global db

    BCM_setup

    set db root
    sqlite3 $db bench.sql
    $db eval {begin transaction}

    set nZero 0
    set nColCSA 0 ; set nColInt 0 ; set nCol 0
    set lgtCSA 0  ; set lgtInt 0  ; set lgtT 0
    set npCSA 0   ; set npInt 0   ; set npT 0

    set Lpkpfam [$db eval {select pk_pfam,pfamid from pfam}]
    foreach {pkpfam pfam} $Lpkpfam {
	set nInt [$db eval {select count(pk_residues) from residues where pk_pfam=$pkpfam and type='Interface'}]
	set nCSA [$db eval {select count(pk_residues) from residues where pk_pfam=$pkpfam and type='CSA'}]
	set nPro [$db eval {select count(pk_residues) from residues where pk_pfam=$pkpfam and type='Prosite'}]
	if {$nInt == 0 && $nCSA == 0 && $nPro == 0} {
	    incr nZero
	    continue
	}
	
	set lgt [$db eval {select lgt from pfam where pk_pfam=$pkpfam}]

	if {$nInt != 0 && $nCSA != 0 && $nPro != 0} {
	    incr npT
	    incr nCol $nInt
	    incr nCol $nCSA
	    incr nCol $nPro
	    incr lgtT $lgt
	} elseif {$nCSA == 0} {
	    incr npInt
	    incr nColInt $nInt
	    incr lgtInt $lgt
	} else {
	    incr npCSA
	    incr nColCSA $nCSA
	    incr lgtCSA $lgt
	}
    }
    $db eval {commit}
    $db close

    set fmt "%3d %5d %6d %5.2f"
    puts "Zero $nZero"
    puts "CSA+Int : [format $fmt $npT $nCol $lgtT [expr {100.*$nCol/$lgtT}]]"
    puts "que Int : [format $fmt $npInt $nColInt $lgtInt [expr {100.*$nColInt/$lgtInt}]]"
    puts "que CSA : [format $fmt $npCSA $nColCSA $lgtCSA [expr {100.*$nColCSA/$lgtCSA}]]"
    
    exit

}

proc BCM_ThreadError {tid stack} {

    global TDT nThreads dres TMaster

    if {$tid eq $TMaster} {
	puts "\nMASTER Error\n$stack\n"
	flush stdout
	
	return
    }

    puts stdout "\nError dans le thread $tid\n$stack"
    flush stdout

    trace remove variable TDT($tid) write BCM_RecupResults

    set Larg [set TDT($tid,Data)]
    after 100
    if {[thread::exists $tid]} {
	puts "... deleting thread $tid"
	flush stdout
	thread::release $tid
    }
    array unset TDT "${tid}*"
    update

    set pkt [$dres eval {select pk_tests from tests where thread=$tid}]
    # met le job du thread à -1
    $dres eval {update tests set res=-1,thread=0 where pk_tests=$pkt}

    if {[llength [thread::names]] < $nThreads} {
	set Id [BCM_CreeThread]
	after 1000
	BCM_DonneUnJob $Id
    }
    update
    
    return

}

proc BCM_ThreadExe {pkpfam fpfam Lpdb2id} {

    global Sequences LNOrdali LSOrdali 

    set tid [thread::id]
    set t1 [clock milliseconds]

    unset -nocomplain Sequences LNOrdali LSOrdali

    set pfamid [lindex [split [file tail $fpfam] .] 0]

    # lit le fichier
    DecortiqueUnTFA $fpfam LNOrdali Sequences
    
    set Lout [BCM_Pdb2Pfam $pfamid $Lpdb2id]

    # finish
    EcritLeTfa "${fpfam}_smp" $::LNOrdali $::LSOrdali

    #FermeFichier

    set LRT [list $tid $pkpfam "" $Lout]

    return $LRT

}

proc BCM_ThreadExe_Tests {pkpfam pfam Lmscore LVP} {

    global Sequences LNOrdali LSOrdali ListeDesPiliersDuGroupe LNDG SDG TbScores ListeScore LongueurTotale ConsMeth
    
    # use executable -> exe or library -> lib
    set how "exe"
    #set how "lib"

    #puts "[thread::id] start job ..."
    #flush stdout

    set tid [thread::id]
    set t1 [clock milliseconds]

    unset -nocomplain Sequences LNOrdali LSOrdali
    unset -nocomplain SDG LNDG TbScores ListeDesPiliersDuGroupe

    set pfamid [lindex [split [file tail $pfam] .] 0]

    # lit le fichier
    DecortiqueUnTFA $pfam LNOrdali Sequences
    set LongueurTotale [string length [set Sequences([lindex [array names Sequences] 0])]]
    
    # calcule score
    set LNDG GroupeToutLeMonde
    set SDG(GroupeToutLeMonde) $LNOrdali    

    CreeLesPiliers

    # prepare pour scores
    set TbScores(Lcols) $Lmscore
    if {[llength $Lmscore] > 1} {
	set Scale 1
    } else {
	set Scale 0
    }
    set LRT [list $tid $pkpfam $Lmscore]
    set Lrcm [list]
    set Lthrgap [list 0.005 0.1 0.25 0.5 0.7]
    #set Lthrgap [list 0.01]
    foreach pcgap $Lthrgap {
	LesDefauts PCThrGap $pcgap

	unset -nocomplain ListeScore
	array unset TbScores "Score,*"
	update

	foreach mscore $Lmscore {
	    set sco [ScoreDe$mscore [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] 
	    if {$Scale} {
		set sco [CentreData $sco -999.0]
	    }
	    set TbScores(Score,$mscore) $sco
	}

	CreeListeScore

	set Lori $ListeScore
	set LgS [llength $ListeScore]
	if {$LgS < 2} {
	    # Probleme : nb cols < 2
	    puts "\nListeScore=0\n$Lmscore $pcgap $pfamid"
	    flush stdout

	    continue
	}

	if {$how eq "exe"} {
	    set o [file tempfile fdat]
	    foreach l $Lori {
		puts $o [join $l \t]
	    }
	    close $o
	    update idletasks
	    catch {file copy $fdat [file tail $fdat]}
	}

	# pour chaque meth clustering
	set Lres [list]
	foreach cm [list dpc mixturemodel secator] {
	    set Lval $Lori

	    # Fait clusters
	    switch $cm {
		"dpc" {
		    if {$how eq "lib"} {
			set Lgr [Tclcluspack $Lval -dt coordinates -cm kmeans -nbc dpc -wc]
		    } else {
			set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=kmeans -nbc=dpc -wc]
		    }
		    set lab dpc
		}
		"secator" {
		    if {$how eq "lib"} {
			set Lgr [Tclcluspack $Lval -dt coordinates -cm hierar -nbc secator -wc]
		    } else {
			set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=hierar -nbc=secator -wc]
		    }
		    set lab secator
		}
		"mixturemodel" {
		    if {$how eq "lib"} {
			set Lgr [Tclcluspack $Lval -dt coordinates -cm mm -nbc aic -wc]
		    } else {
			set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=mm -nbc=aic -wc]
		    }
		    set lab mm
		}
	    }
	    if {$how eq "exe"} {
		if {[catch {exec {*}$cmd >& ${tid}.log} Msg]} {
		    puts stderr "Pb Cluspack\n$Msg"
		    puts stderr "[ContenuDuFichier ${tid}.log]"
		    flush stderr
		}
		
		# lit clusters
		if {[file exists "${fdat}.clu"]} {
		    set Lres [TraiteResultatClustering "${fdat}.clu" ""]
		} else {
		    puts "log cluspack :\n[ContenuDuFichier ${tid}.log]"
		    flush stdout
		
		    continue
		}
		file delete -force ${tid}.log ${fdat}.clu
	    } else {
		set fdeb [open deb.txt w]
		puts $fdeb [join $Lval \n]
		puts $fdeb "------------"
		puts $fdeb [join $Lgr \n]
		close $fdeb
		set Lres [TraiteResultatClusteringTcl $Lgr ""]
	    }
	    
	    set Ltrouve [lindex $Lres 1]
	    set res [list "'$lab'" $pcgap $Ltrouve $LgS]
	    lappend Lrcm $res
	}
	if {$how eq "exe"} {
	    file delete -force [file tail $fdat] $fdat
	}
    }
    
    FermeFichier
    lappend LRT $Lrcm

    return $LRT

}

proc BCM_TriePfam2Do {} {

    global db

    BCM_setup

    set Lbonpk [list]
    set Lpk [$db eval {select pk_pfam from pfam where nseqs > 5}]
    puts "Lpk [llength $Lpk]"
    foreach pk $Lpk {
	set nres [$db eval {select count(pk_residues) from residues where pk_pfam=$pk}]
	if {$nres > 0} {
	    lappend Lbonpk $pk
	}
    }

    return [lsort -integer -unique $Lbonpk]

}

proc BCM_UploadPfam {} {

    global TPfam

    # take the fasta pfam file from ftp
    # split it into PFxxxxx files
    cd /genomics/link/Pfam
    set f [open Pfam-A.fasta r]
    set open 0 ; set pf "" ; set Lpf [list]
    while {[gets $f l] >= 0} {
	if {[string index $l 0] eq ">"} {
	    # nouvelle seq
	    set lori $l
	    regsub -all { +} [string trim $l] " " l
	    set l [string map [list " " ";"] $l]
	    set pf [lindex [split $l ";"] 2]
	    lappend TPfam($pf) $lori
	} else {
	    lappend TPfam($pf) $l
	}
    }

    return

}

proc BCM_corrDB {} {

    BCM_setup

    set db root
    sqlite3 $db bench.sql
    
    $db eval {begin transaction}
    set Lpkpfs [$db eval {select pk_pfam,pfamid from pfam}]
    set chm [file join /home moumou work moumou BenchPfam]
    foreach {pk pf} $Lpkpfs {
	set f [glob [file join $chm "${pf}*_smp"]]
	LitLeTFA $f Ln Sq
	set lg [string length [set Sq([lindex $Ln 0])]]
	$db eval {update pfam set lgt=$lg where pk_pfam=$pk}
	unset -nocomplain Sq
	set Ln {}
    }
    $db eval {commit}
    $db close
	    
    exit

}

proc BCM_setup {} {

    global Dbcm PfamDir
    
    set PfamDir "/genomics/link/Pfam/"
    set Dbcm(tables) "
    - pdbmap : mapping pdb pfam {
	. pk_pdbmap P
	. pfamid V7
	. pdbid V4
	. chn V1
	. pdeb I
	. pfin I
	. acc V20
	. id V20
	. sdeb I
	. sfin I
    }
    - propfam : lien prosite - pfam {
	. pk_propfam P
	. prosite V7 nom du prosite (PS00118)
	. pfamid V7 nom pfam (PF00068)
    }
    - pfam : info sur le pfam {
	. pk_pfam P
	. pfamid V7
	. name V128
	. nseqs I
	. lgt I
	. idm R identite moyenne
	. idsd R sd de identite
    }
    - residues : residues conserves dans les pfam {
	. pk_residues P
	. pk_pfam I
	. posSq I
	. posAl I
	. type V3
    }
    - results : resultat de test {
	. pk_results P
	. pk_tests I
	. job V128
	. args T
	. cm V12 clustering method
	. gapthr R threshold pour gap
	. pos T positions list
	. lgt I length of alignment with gapthr
    }
    "
    
    set Dbcm(TableRes) "
    - tests : tests a faire {
	. pk_tests P 
	. job T
	. args T methodes scoring
	. thread V32
	. res I -1 error, 0 pas fait, 1 ok
    }
    "

    return

}

proc BLASTDatabase_ICDS {{FichierIn ""} {FichierOut ""}} {


    Wup "Permet de creer une banque blast a partir du fichier TFA"
   
    if {$FichierIn == ""} {
	set RepBanque "[RepertoireDuGenome]"
	set FichierIn    [glob -nocomplain -directory "$RepBanque" "*.fasta"]
    }
    if {! [file exists $FichierIn]} {return ""}

    if {$FichierOut == ""} {
	regsub {\.[a-z]+$} $FichierIn "" FichierOut
    }
    
    set Title "ICDS_[file tail $FichierIn]"

    set Cmdformadb "formatdb  -i $FichierIn  -o T  -t $Title  -p F  -n $FichierOut"

    if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"}
    return ""

}

proc BLAT {{query ""} {output ""} {Databases ""} {Outstyle BLAST}} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "It is optimised to align mRNA or DNA fragment onto genomes"
    Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
    Wup "gfServer permits to load and start a server."
    Wup "gfClient permits to submit sequences to the server."
    Wup "Output can be set to looks like blast output"

    if {$Databases=="" || $query=="" || $output==""} {
	Espionne "BLAT use is database (or file containing list of database) query and output."
	Espionne "BLAT database can be fasta or pultiple fasta files or .nib (BLAT own Format)"
	return ""
    }

    if {! [file exists $query] || ! [file exists $Databases]} {
	Espionne "Problem with own of query and Databases files do not exists."
	return ""
    }

    if {[regexp -nocase "blast" $Outstyle]} {
	set Outstyle [string tolower $Outstyle]
    }

    #/biolo/blatSrc/bin/blat mouse.tfa human.tfa /genomics/g1/Actin/nuctfa/ACT0001 -q=rna -out=blast ACT0001.blat

    set BLAT "[BLATDIR]/blat"

    set Option "-out=$Outstyle"

    set CommandeBlat "eval exec $BLAT $Databases $query $Option $output"

    if {[catch {eval $CommandeBlat} Message]} {
	Espionne "Problem with $output"
	Espionne $Message
    }
    return $output

}

proc BLATDIR {} {
 

    Wup "BLAT bin or source directory"

    global BLATSourceDir
    if {[info exists BLATSourceDir] && [file exists $BLATSourceDir]} {return $BLATSourceDir}
    set BLATSourceDir "/biolo/blatSrc/bin/x86_64"

    return $BLATSourceDir

}

proc BLATGenomeDir {Genome} {
 

    Wup "Genome directory"
    
    return "[UCSCGenomeDir $Genome]"

}

proc BLATGenomePort {Genome} {
 

    Wup "Genome associated Port for BLAT"

    global BLATGenomePort
    if {[info exists BLATGenomePort($Genome)]} {return [set BLATGenomePort($Genome)]}

    switch -exact -- $Genome {
	"human"   {set BLATGenomePort($Genome) 50000}
	"mouse"   {set BLATGenomePort($Genome) 51000}
	"mstigr"  {set BLATGenomePort($Genome) 52000}
	"default" {return ""}
    }
 
    if {[info exists BLATGenomePort($Genome)]} {return [set BLATGenomePort($Genome)]}

    return ""

}

proc BLATPourTous {DirIn DirOut Databases {Outstyle BLAST}} {



    if {! [file exists "[RepertoireDuGenome]/${DirIn}"]} {
	Espionne "Problem input directory do not exists."
	return ""
    }

    if {![file exists "[RepertoireDuGenome]/${DirOut}"]} {
	file mkdir "[RepertoireDuGenome]/${DirOut}"
    }

    if {! [file exists $Databases]} {
	Espionne "Problem with Databases files do not exists."
	return ""
    }


    if {[regexp -nocase "blast" $Outstyle]} {
	set Outstyle [string tolower $Outstyle]
    }

    set LesPABs [ListeDesPABs]

    foreach PAB $LesPABs {
	set input  "[RepertoireDuGenome]/$DirIn/${PAB}"
	set output "[RepertoireDuGenome]/$DirOut/${PAB}"

	#Espionne "BLAT $PAB $output $Databases $Outstyle"
	BLAT $input $output $Databases $Outstyle
    }
    return ""

}

proc BLATServerName {} {
 

    Wup "Server Name associated for BLAT"

    global BLATServerName
    if {[info exists BLATServerName(Server)]} {return [set BLATServerName(Server)]}

    set BLATServerName(Server) "star6"

    if {[info exists BLATServerName(Server)]} {return [set BLATServerName(Server)]}

    return ""

}

proc BLAT_client {{Input ""} {Output ""} {DirOuGenome ""} {Outstyle ""} {Host ""} {Port ""} {OptionSup ""}} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "It is optimised to align mRNA or DNA fragment onto genomes"
    Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
    Wup "gfServer permits to load and start a server."
    Wup "gfClient permits to submit sequences to the server."
    Wup "Output can be set to looks like blast output"

    if {$Input  == ""} {
	Espionne "BLAT_client Usage is: Input \[complete file path\] Output \[same\] Organism \[human mouse\] (optional Outstyle \[blast\] Host \[star6\] Port \[linked to Organism\])"
	return ""
    }
    if {$Output == ""} {
	set  FileExt [file extension $Input]
	if {$FileExt != ""} {
	    regsub "$FileExt" $Input ".blat" Output
	} else {
	    set Output "${Input}.blat"
	}
    }

    if {$Port     == ""} {set Port     [BLATGenomePort $DirOuGenome]}
    if {$Host     == ""} {set Host     [BLATServerName]}
    if {$Outstyle == ""} {set Outstyle "blast"}

    if {[regexp -nocase "blast" $Outstyle]} {
	set Outstyle [string tolower $Outstyle]
    }
    set OptionsClient "-out=$Outstyle"
    if {$OptionSup!=""} { append OptionsClient " $OptionSup" }

    #/biolo/blatSrc/bin/gfClient [BLATServerName] 50000 ACT0015 ACT0015.blat -out=blast

    set BLAT "[BLATDIR]/gfClient"

    #Le "" dans la commande correspond a l option nibDir qui est le chemin relatif ou sont situe les fichier .nib"
    set CommandeBlat "$BLAT $Host $Port \"\" $Input $Output $OptionsClient"
    Espionne "$CommandeBlat"

    if {[catch {eval exec $CommandeBlat} Message]} {
	Espionne "Problem with $Output"
	Espionne $Message
    }
    return ""

}

proc BLAT_clientPourTous {{DirIn ""} {DirOut ""} {DirOuGenome ""} {Outstyle ""} {Host ""} {Port ""} {OptionSup ""}} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "It is optimised to align mRNA or DNA fragment onto genomes"
    Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
    Wup "gfServer permits to load and start a server."
    Wup "gfClient permits to submit sequences to the server."
    Wup "Output can be set to looks like blast output"

    #DirIn  directory where to find queries tfa files 
    #DirOut directory where to store results

    if {$DirIn=="" && $DirOut==""} {
	#Espionne "BLAT_clientPourTous Usage is: DirIn \[Input complete dir path\] DirOut \[same for output\] Organism \[human mouse\] (optional Outstyle \[blast\] Host \[star6\] Port \[linked to Organism\])"
	return ""
    }

    if {! [file exists "[RepertoireDuGenome]/${DirIn}"]} {
	Espionne "Problem input directory do not exists."
	return ""
    }

    if {![file exists "[RepertoireDuGenome]/${DirOut}"]} {
	file mkdir    "[RepertoireDuGenome]/${DirOut}"
    }
    
    if {$Port    ==""} {set Port     [BLATGenomePort $DirOuGenome]}
    if {$Host    ==""} {set Host     [BLATServerName]}
    if {$Outstyle==""} {set Outstyle "blast"}

    if {[regexp -nocase "blast" $Outstyle]} {
	set Outstyle [string tolower $Outstyle]
    }

    set  LesPABs ""
    #set  LesPABs [ListeDesPABs]
    if {$LesPABs == ""} {
	set LesPABs [glob -nocomplain -directory "$DirIn" -tails "*"]
    }
    
    if {! [BLAT_server_Running $DirOuGenome]} {
	Espionne "BLAT Server for $DirOuGenome is not running."
	#Espionne "Trying to launch it."
	#BLAT_server Start $DirOuGenome $Host $Port
	return ""
    } 

    foreach PAB $LesPABs {
	set Input  "[RepertoireDuGenome]/$DirIn/${PAB}"
	set Output "[RepertoireDuGenome]/$DirOut/${PAB}"
	if {[file exists $Output]} {continue}

	#Espionne "BLAT $PAB $Output $DirOuGenome $Outstyle"
	BLAT_client $Input $Output $DirOuGenome $Outstyle $Host $Port $OptionSup
    }
    return ""

}

proc BLAT_clientPourTousBoost {{DirIn ""} {DirOut ""} {DirOuGenome ""} {Outstyle ""} {Host ""} {Port ""} {OptionSup ""} {ListeATraiter ""}} {



    if {$DirIn=="" && $DirOut==""} {
       Espionne "BLAT_clientPourTous Usage is: DirIn \[Input complete dir path\] DirOut \[same for output\] Organism \[human mouse\] (optional Outstyle \[blast\] Host \[star6\] Port \[linked to Organism\])"
        return ""
    }

    if { ! [regexp "/" $DirIn]} { set DirIn "[RepertoireDuGenome]/$DirIn" }
    if {! [file exists $DirIn]} {
        Espionne "Problem input directory doesn't not exists."
        return ""
    }

    if { ! [regexp "/" $DirOut]} { set DirOut "[RepertoireDuGenome]/$DirOut" }
    if {![file exists $DirOut]} { file mkdir $DirOut }
    
    if {$Port    ==""} {set Port     [BLATGenomePort $DirOuGenome]}
    if {$Host    ==""} {set Host     [BLATServerName]}
    if {$Outstyle==""} {set Outstyle "blast"}

    if {[regexp -nocase "blast" $Outstyle]} {
        set Outstyle [string tolower $Outstyle]
    }

    if {$ListeATraiter=="ListeDesPABs"} { set ListeATraiter [ListeDesPABs] }
    if {$ListeATraiter == ""} {
        set ListeATraiter [glob -nocomplain -directory $DirIn -tails "*"]
    }
    
    if {! [BLAT_server_Running $DirOuGenome]} {
        Espionne "BLAT Server for $DirOuGenome is not running."
        #Espionne "Trying to launch it."
        #BLAT_server Start $DirOuGenome $Host $Port
        return ""
    } 

    set I 9999
    foreach PAB $ListeATraiter {
        set Input  "$DirIn/$PAB"
        set Output "$DirOut/$PAB"

        if {[file exists $Output]} {continue}

        if {[incr I]>100} {
        #    Espionne "I'll run  BLAT $Input $Output $DirOuGenome $Outstyle"
            set I 0
        }
        BLAT_client $Input $Output $DirOuGenome $Outstyle $Host $Port $OptionSup
    }
    return ""

}

proc BLAT_clientPourTousRR {{DirIn ""} {DirOut ""} {DirOuGenome ""} {Outstyle ""} {Host ""} {Port ""} {OptionSup ""} {ListeATraiter ""}} {


    Wup "If DirIn  has no / we use RepretoireDuGenome/DirIn" 
    Wup "If DirOut has no / we use RepretoireDuGenome/DirOut" 

    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "It is optimised to align mRNA or DNA fragment onto genomes"
    Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
    Wup "gfServer permits to load and start a server."
    Wup "gfClient permits to submit sequences to the server."
    Wup "Output '''[[Known Bugs]]''' can be set to looks like blast output"

    #DirIn  directory where to find queries tfa files 
    #DirOut directory where to store results

    if {$DirIn=="" && $DirOut==""} {
	Espionne "BLAT_clientPourTous Usage is: DirIn \[Input complete dir path\] DirOut \[same for output\] Organism \[human mouse\] (optional Outstyle \[blast\] Host \[star6\] Port \[linked to Organism\])"
	return ""
    }

    if { ! [regexp "/" $DirIn]} { set DirIn "[RepertoireDuGenome]/$DirIn" }
    if {! [file exists $DirIn]} {
	Espionne "Problem input directory doesn't not exists."
	return ""
    }

    if { ! [regexp "/" $DirOut]} { set DirOut "[RepertoireDuGenome]/$DirOut" }
    if {![file exists $DirOut]} { file mkdir $DirOut }
    
    if {$Port    ==""} {set Port     [BLATGenomePort $DirOuGenome]}
    if {$Host    ==""} {set Host     [BLATServerName]}
    if {$Outstyle==""} {set Outstyle "blast"}

    if {[regexp -nocase "blast" $Outstyle]} {
	set Outstyle [string tolower $Outstyle]
    }

    if {$ListeATraiter=="ListeDesPABs"} { set ListeATraiter [ListeDesPABs] }
    if {$ListeATraiter == ""} {
	set ListeATraiter [glob -nocomplain -directory $DirIn -tails "*"]
    }
    
    if {! [BLAT_server_Running $DirOuGenome]} {
	Espionne "BLAT Server for $DirOuGenome is not running."
	#Espionne "Trying to launch it."
	#BLAT_server Start $DirOuGenome $Host $Port
	return ""
    } 

    set I 9999
    foreach PAB $ListeATraiter {
	set Input  "$DirIn/$PAB"
	set Output "$DirOut/$PAB"

	if {[file exists $Output]} {continue}

	if {[incr I]>100} {
	    Espionne "I'll run  BLAT $Input $Output $DirOuGenome $Outstyle"
	    set I 0
	}
	BLAT_client $Input $Output $DirOuGenome $Outstyle $Host $Port $OptionSup
    }
    return ""

}

proc BLAT_server {{Quoi ""} {DirOuGenome ""} {Host ""} {Port ""} {OptionSup ""}} {

    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "It is optimised to align mRNA or DNA fragment onto genomes"
    Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
    Wup "gfServer permits to load and start a server."
    Wup "gfClient permits to submit sequences to the server."
    Wup "Output can be set to looks like blast output"

    set OptionsServer "-log=[TmpFile blatServer].log"
    if {$OptionSup!=""} { append OptionsServer " $OptionSup" }

    #Quoi start  - Start the server by calculating indexes and stores them into memory
    #     stop   - Stop  the server
    #     status - To get status and usage level of the server
    #     files  - To get input files list
    #/biolo/blatSrc/bin/gfServer start star6 50000 *.nib

    if {$Quoi == "" || $DirOuGenome == ""} {
	Espionne "BLAT_server usage is: BLAT_server Quoi DirOuGenome Host (option) Port (option)"
	Espionne "Quoi can be: start, stop, status or files."
	Espionne "DirOuGenome can be: mouse, human."
	return ""
    }

    set Out ""

    #1 On recupere les valeurs de chacun des parametres
    if {$Host == ""} {set Host [BLATServerName]}
    if {$Port == ""} {set Port [BLATGenomePort $DirOuGenome]}
    if {$Port == ""} {
	Espionne "Problem with $DirOuGenome, Port can not be set."
	return ""
    }
    set  DirNib [BLATGenomeDir $DirOuGenome]
    if {$DirNib == ""} {
	Espionne   "Problem with $DirOuGenome, no directory can be defined."
	return ""
    } else {
	set DirNib "$DirNib/blat/*.nib"
    }

    #2 On definit la commande BLAT a executer
    set BLAT "[BLATDIR]/gfServer"
    switch -exact -- $Quoi {
	"start"   {
	    #Test si le serveur tourne deja
	    if {[BLAT_server_Running $DirOuGenome $Host $Port]} {
		Espionne "BLAT server already running for $DirOuGenome."
		Espionne "You can not run it twice."
		return ""
	    } else {
		Espionne "BLAT server will be launched for $DirOuGenome."
		global env
		set HOST $env(HOST)
		if {[regexp -nocase "[BLATServerName]" $HOST]} {
		    #Espionne "On est sur $HOST - [BLATServerName] normalement."
		    set CommandeBlat "$BLAT $OptionsServer $Quoi $Host $Port [glob $DirNib]"
		} else {
		    #Espionne "On est sur $HOST - autre normalement."
		    set CommandeBlat "rsh [BLATServerName] $BLAT $OptionsServer $Quoi $Host $Port [glob $DirNib] "
		    #set CommandeBlat "rsh [BLATServerName] $BLAT $Quoi $Host $Port [glob $DirNib] > /home/jmuller/blat.tmp"
		}
		Espionne $CommandeBlat
		if {[catch {set Out [eval exec $CommandeBlat &]} Message]} {
		    return $Message
		} else {
		    return 1
		}
	    }
	}
	"stop"    {set CommandeBlat "$BLAT $Quoi $Host $Port"}
	"status"  {set CommandeBlat "$BLAT $Quoi $Host $Port"}
	"files"   {set CommandeBlat "$BLAT $Quoi $Host $Port"}
	"default" {return ""}
    }

    if {[catch {set Out [eval exec $CommandeBlat]} Message]} {
	#Erreur normale pour status on n'affiche rien
	if {$Quoi=="status" && [regexp -nocase "Couldn't connect to" $Message]} { return 0 }

	Espionne "Problem with $CommandeBlat"
	Espionne $Message
	return ""
    }

    #Rq: Out contient pour
    #        start  le numero UID du process (ex: 2331894)
    #        stop   le numero UID du process (ex: 2331894)
    #        status la liste des arguments du server
    #        files  la liste des fichiers charges
    return $Out

}

proc BLAT_server_Running {{DirOuGenome ""} {Host ""} {Port ""}} {


    Wup "Permet de savoir si un serveur existe deja pour le genome"

    if {$DirOuGenome == ""} {
	Espionne "Problem no Genome set."
	Espionne "Usage is: BLAT_server_Running DirOuGenome Host (option) Port (option)"
	return ""
    }
    if {$Host == ""} {set Host [BLATServerName]}
    if {$Port == ""} {set Port [BLATGenomePort $DirOuGenome]}
    if {$Port == ""} {
	Espionne "Problem with $DirOuGenome, Port can not be set."
	return ""
    }
 
    set Quoi  "status"
    set State [BLAT_server $Quoi $DirOuGenome $Host $Port]
    Espionne "State: -- $State --"
    
    if {$State == 0} {
	#Espionne "BLAT server for $DirOuGenome is not running."
	set Reply 0
    } elseif {$State == ""} {
	Espionne "BLAT server satus request has a problem."
	set Reply 0
    } else {
	#Espionne "BLAT server for $DirOuGenome is running."
	set Reply 1
    }
    return "$Reply"

}

proc BaClon {args} {

    global BaClon

    if {$args=={}} {
	return [list  "BaClon LesSujets PGS"  "BaClon LesOligos PGS"  "BaClon LesOligosDuCouple PGS Sujet"  "BaClon Trio PGS Sujet P"]
    }


    if {$args=="Save"} { 
	set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
	SauveLesLignes [array get BaClon] dans $FichierBaClon
	return $FichierBaClon
    }
    set Quoi [join $args ","]

    if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
    if {[info exists BaClon(EstCharge)]} { return "" }

    set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
    if {[file exists $FichierBaClon]} {
	array set BaClon [LesLignesDuFichier $FichierBaClon]
    }
    set BaClon(EstCharge) 1
    if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
    return ""

}

proc BaClonAppend {args} {

    global BaClon
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    if {[info exists BaClon($Quoi)] && [lsearch -exact [set BaClon($Quoi)] $Valeur]>-1} {
	return [set BaClon($Quoi)]
    }

    return [lappend BaClon($Quoi) $Valeur]

}

proc BaClonExists {args} {

    global BaClon

    if {$args=={}} { return [info exists BaClon(EstCharge)]}

    set Quoi [join $args ","]
    return [info exists BaClon($Quoi)]

}

proc BaClonSet {args} {

    global BaClon
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    return [set BaClon($Quoi) $Valeur]

}

proc BaClonUnset {args} {

    global BaClon
    set Quoi [join $args ","]
    catch {unset BaClon($Quoi)}

}

proc BaList {{RV ""}} {

    if {$RV==""} { return [ListeDesPABs] }
    set BaList {}
    foreach Nom [ListeDesPABs] {
	if {[RVof $Nom]==$RV} { lappend BaList $Nom } 
    }
    return $BaList

}

proc BalibaseCorrectLink {} {

    if {1} {
	cd [RepertoireDuGenome]
	cd "tfas"
	foreach RV [glob "../RV*"] {
	    Espionne $RV
	    foreach P [glob -nocomplain "$RV/*.tfa"] {
		set F [file tail $P]
		regsub {\..*} $F "" Nom
		Espionne "ln -sf $P $Nom"
	        exec ln -sf $P $Nom
	    }
	}
    }

    if {1} {
	cd [RepertoireDuGenome]
	cd "msf"
	foreach RV [glob "../RV*"] {
	    Espionne $RV
	    foreach P [glob -nocomplain "$RV/*.msf"] {
		set F [file tail $P] 
		regsub {\..*} $F "" Nom
		Espionne "ln -sf $P $Nom"
	        exec ln -sf $P $Nom
	    }
	}
    }

}

proc BalibaseCreateBlastDatabase {} {

    foreach Nom [ListeDesPABs] {
	set FichierTFAs [GscopeFile $Nom "tfas"]
	foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
	    regsub ">$Access" $TFA ">${Nom}_$Access" New
	    lappend LesNew $New 
	}
    }
    return [SauveLesLignes $LesNew dans "[RepertoireDuGenome]/banques/BalibaseAllProt"]

}

proc BalibaseFile {Nom {Type ""}} {

    if {$Type==""} { set Type "xml" }

    set RepRV "[RepertoireBalibase]/RV[RVof $Nom]"
    if {$Type=="rsf"} { return "$RepRV/$Nom.rsf" } 
    if {$Type=="xml"} { return "$RepRV/$Nom.xml" } 
    if {$Type=="tfa"} { return "$RepRV/$Nom.tfa" } 

    return "[RepertoireBalibase]/$Type/$Nom"

}

proc Ballast {FichierBlastP {RepertoireDestination ""} {Query ""} {TexteSansFichier ""}} {

    global RepertoireDuGenome
    global OptionsBallastPourJulie

    Wup "ATTENTION : Ballast puts BanqueId instead of Access so we change back if necessary"
    set AvecAccessAuLieuDeBanqueId 1

    set Nom [file tail $FichierBlastP]

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

    Espionne "$Query $Nom $FichierBlastP"

    if { $FichierBlastP==$Nom || ! [file exists $FichierBlastP]} {
	set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
    }

    if {$RepertoireDestination == ""} {
	set RepertoireDestination "$RepertoireDuGenome/ballast"
    }

    if { ! [File isdirectory $RepertoireDestination]} {
	File mkdir $RepertoireDestination
    }

    set Destination "$RepertoireDestination/$Nom"

    set Message ""
    set CommandeBallast "ballast   -p $FichierBlastP  -o $Destination  -anchors  -noext  -queryname $Query"
    if {[info exists OptionsBallastPourJulie]} {
	append CommandeBallast " $OptionsBallastPourJulie"
    }
    Espionne $CommandeBallast
    if {[catch {eval exec $CommandeBallast} Message]} {
	if {[regexp -nocase "Segmentation fault" $Message]} {
	    Warne "Don't worry about this message ..."
	    Warne $Message
	    Warne "Don't worry about this message ... be happy."
	    return ""
	}
	if {[regexp -nocase "error" $Message]} {
	    Warne "Don't worry about this message ..."
	    Warne $Message
	    Warne "Don't worry about this message ... be happy."
	    return ""
	}
	Warne "Don't worry about this message ..."
	Warne " Ballast failed with message on next line :"
	Warne $Message
	Warne "Don't worry about this message ... be happy."
	return ""
    }
    if {[regexp -nocase " error" [join [LesPremieresLignesDuFichier $Destination 10]] "\n"]} {
	Warne "Don't worry about this message ..."
	Warne [join [LesPremieresLignesDuFichier $Destination 5] "\n"]
	Warne "FATAL Error in Ballast Output"
	Warne "Don't worry about this message ... be happy."
	return ""
    }

    if {$AvecAccessAuLieuDeBanqueId} {
	set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
	if {[file exists "$FichierAPNs"]} {
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		set Access ""
		scan $Ligne "%s %s" BanqueId Access
		if { ! [regexp -nocase {[a-z_0-9]} $Access]} { continue }
		set BanqueId [string toupper $BanqueId]
		set AccessDuBanqueId($BanqueId) $Access
	    }
	} else {
	    DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre"  Query lBanqueId lAccess lDE lProfil lPN
	    foreach BanqueId $lBanqueId Access $lAccess { 
		if {$Access=="mol:protein"} { set Access $BanqueId }
		if { ! [regexp -nocase {[a-z_0-9]} $Access]} { continue }
		set BanqueId [string toupper $BanqueId]
		set AccessDuBanqueId($BanqueId) $Access
	    }	    
	}
	set FichierAnchors "$Destination.anchors"
	foreach Ligne [LesLignesDuFichier $FichierAnchors] {
	    scan $Ligne "%s %s %s" seq nom BanqueIdOriginal
	    if {$seq == "seq:"} {
		regsub {\|} $Ligne "_" Ligne
		regsub {\|} $BanqueIdOriginal "_" BanqueIdOriginal
		set BanqueId [string toupper $BanqueIdOriginal]
		regsub "_" $BanqueId ":" BanqueId
		if {[info exists AccessDuBanqueId($BanqueId)]} {
		    set Access [set AccessDuBanqueId($BanqueId)]
		} else {
		    set Access $BanqueIdOriginal
		}
		set NouvelleLigne [SubstitueAvecBlancsDevant $Ligne $BanqueIdOriginal $Access]
		lappend NouveauAnchors $NouvelleLigne
	    } else {
		lappend NouveauAnchors $Ligne
	    }
	}
	Espionne $FichierAnchors
	Espionne [SauveLesLignes $NouveauAnchors dans $FichierAnchors]
    }

    if { $TexteSansFichier != "TexteSansFichier"} {
	return $Destination
    } else {
	set Texte [ContenuDuFichier $Destination]
	File delete -force $Destination
	foreach FichierBallastExt [glob -nocomplain "$Destination.*"] {
	    File delete -force $FichierBallastExt
	}
	return $Texte
    }

}

proc BallastExe {} {


    global tcl_platform
    global OrdBinDir
    global env

    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./ballast"
    }
    if {[set tcl_platform(platform)] != "windows"} {
	if {[info exists OrdBinDir]} {
	    return [file join $OrdBinDir "ballast"]
	} else {
	    return "/biolo/ballast/bin/ballast"
	}
    } else {
	set lexe [file join $OrdBinDir "ballast.exe"]
	regsub "Program Files" $lexe "PROGRA~1" lexe
	return $lexe
    }

}

proc BallastGrid {NomATraiter} {


    global PipeQuery
    global PipeCollection
    
    if {$PipeCollection} {
	set FichierBlastP [file join [RepertoireDuGenome] blastp $NomATraiter]
	set Destination [file join [RepertoireDuGenome] ballast $NomATraiter]
	set FichierAncres [file join [RepertoireDuGenome] ballast $NomATraiter.anchors]
	if {[file exists $Destination]} {return 1}
    } else {
	set Destination   "[file rootname $NomATraiter].ballast"
	set FichierBlastP "[file rootname ${NomATraiter}].blastp"
	set FichierAncres "[file rootname $NomATraiter].ballast.anchors"
    }

    set Ll [LesLignesDuFichier $FichierBlastP]
    if {[llength $Ll] < 10} {
	Espionne "Something wrong with BlastP file"
	return 0
    }

    set CommandeBallast "[BallastExe]   -p $FichierBlastP  -o $Destination  -anchors  -noext  -queryname $PipeQuery"
    catch {eval exec $CommandeBallast} Message
    
#AF
# historiquement, on ne retournait ok = 1 que si le fichier destination etait cree
# finalement, on retourne systematiquement ok = 1 car avoir les ancres n est pas une condition obligatoire mais un plus...
    set ok 1
##
    if {[file exists $FichierAncres]} {
	AjouteAuLogPipe "ballast = ok"
    } else {
	AjouteAuLogPipe "ballast failed"
    }
    return $ok

}

proc BallastPourLesAffyEN {} {

    BallastPourTous [ListeDesDifferentiellementExprimesSansJumeaux]

}

proc BallastPourTous {{LesNoms ""} {AvecLMS 1}} {

    #global OptionsBallastPourJulie
    #global OptionsBallastPourJulieDemande
    global RepertoireDuGenome

    #set OptionsBallastPourJulie [Entre "-dbclustal 0.000001"]
    #set OptionsBallastPourJulieDemande 1

    set RepBlast "$RepertoireDuGenome/blastp"
    set RepBallast "$RepertoireDuGenome/ballast"
    if {![file exists $RepBallast]} {File mkdir $RepBallast}

    set Keep 0
    if {[OuiOuNon "If some files already exist, would you want to conserv them?"]} {set Keep 1}

    if {$AvecLMS} {
	set RepLMS "$RepertoireDuGenome/lms"
	if {![file exists $RepLMS]} {File mkdir $RepLMS}
    }
    if {$LesNoms == {}} {set LesNoms [ListeDesPABs]}

    foreach Nom $LesNoms {
	set FichierBlastP "$RepBlast/$Nom"
	if {![file exists $FichierBlastP]} {continue}
	if {[file exists "$RepBallast/$Nom"] && $Keep} {continue}
	BallastUnBlastP $FichierBlastP $RepBallast
	if {$AvecLMS} {Sauve [FichierLMSDesAccessDuBallast "$RepBallast/$Nom"] dans "$RepLMS/$Nom"}
    }
    return ""

}

proc BallastUnBlastP {Fichier {RepertoireDestination ""}} {

    global RepertoireDeTravail

    if {$RepertoireDestination==""} { set RepertoireDestination $RepertoireDeTravail }

    set Query [QueryDuFichierBlast $Fichier]

    set Destination [Ballast $Fichier $RepertoireDestination $Query]

    return [ContenuDuFichier $Destination]

}

proc BallastUnPAB {Nom {RepertoireDestination ""}} {

    global RepertoireDuGenome
    global RepertoireDeTravail

    if {$RepertoireDestination==""} { set RepertoireDestination $RepertoireDeTravail }

    set Query $Nom
    set Fichier "$RepertoireDuGenome/blastp/$Nom"

    set Destination [Ballast $Fichier $RepertoireDestination $Query]

    return [ContenuDuFichier $Destination]

}

proc BandesCytoPourLesJRDunChromo {chromo} {

    set LesGenesDuChromo [LesJRTouchantUnChromo $chromo]
    set LesNoms [split $LesGenesDuChromo " "]
    set LesBandesDuChromo {}
    foreach Nom $LesNoms {
	set LesBandes [BandesCytologiques $Nom]
	if {$LesBandes==""} {continue}
	set LaPremiereBande [lindex $LesBandes 0]
	lappend LesBandesDuChromo "$Nom: $LaPremiereBande\n"
    }
    set LesBandesDuChromoTriees [lsort -index 1 $LesBandesDuChromo] 
    set BandesTriees [join $LesBandesDuChromoTriees ""]
    return $BandesTriees

}

proc BandesCytologiques {Nom} {

    set LesBandesAPartirDucontig [BandesCytologiquesAPartirDuContig $Nom]
    if {$LesBandesAPartirDucontig!="" && $LesBandesAPartirDucontig!=" "} {
	set Bandes [split $LesBandesAPartirDucontig " "]
	set Nb [llength $Bandes]
	if {$Nb==1} {
	    #Espionne "avec numero contig "
	    return  $LesBandesAPartirDucontig
	}
    }
    
    set AccessRNA [ExtraitAccessDuRNA $Nom]
    if {$AccessRNA!=""} {
	set LesBandes [LesBandesCytologiquesDeLorganisme $AccessRNA]
	if {$LesBandes!=""} {
	    set Band [split $LesBandes " "]
	    set N [llength $Band]
	    if {$N==1} {
		#Espionne "avec access du mRNA"
		return  $LesBandes
	    }
	}
    }
    
    set DefinitionRNA [EssaiExtraitDefinitionRNA $Nom]
    set LesBandesAPartirDeDef [LesBandesCytologiquesDeLorganisme $DefinitionRNA]
    if {$LesBandesAPartirDeDef!=""} {
	set bb [split $LesBandesAPartirDeDef " "]
	set Nbd [llength $bb]
	if {$Nbd==1} {
	    #Espionne "avec un nom, nom de gene?"
	    return $LesBandesAPartirDeDef
	}
    }

    if {$DefinitionRNA!=""} {
	set Contig [ContigDuPremierHitDuBlast $Nom]
	set LesBandesChromo [LesBandesCytologiquesDeLorganisme $Contig "$DefinitionRNA"]
	if {$LesBandesChromo!=""} {
	    #Espionne "avec contig et le nom extrait de def rna"
	    return $LesBandesChromo
	}
    }
    #si on ne remplit aucune condition ci-dessus:
    set AccessRNA [ExtraitAccessDuRNA $Nom]
    if {$AccessRNA!=""} {
	set LesBandes [LesBandesCytologiquesDeLorganisme $AccessRNA]
	if {$LesBandes!=""} {
	    #Espionne "avec access mRNA:"
	    return $LesBandes
	}
    }
    if {$LesBandesAPartirDucontig!="" && $LesBandesAPartirDucontig!=" "} {
	#Espionne "avec numero contig:"
	return $LesBandesAPartirDucontig
    }

}

proc BandesCytologiquesAPartirDuContig {Nom} {

    set LesBandes {}
    set Contig [ContigDuPremierHitDuBlast $Nom]
    if {$Contig!=""} {
	set LesBandesDuContig [LesBandesCytologiquesDeLorganisme $Contig]
	if {$LesBandesDuContig==""} {return ""}
	return $LesBandesDuContig
    } else {return ""}

}

proc BandesTrouveesEtMoyen {Nom} {

    set LesBandesAPartirDucontig [BandesCytologiquesAPartirDuContig $Nom]
    if {$LesBandesAPartirDucontig!=""} {
	set Bandes [split $LesBandesAPartirDucontig " "]
	set Nb [llength $Bandes]
	set Contig [ContigDuPremierHitDuBlast $Nom]
	if {$Nb==1} {
	    return  "$Nom\t$Contig\t$LesBandesAPartirDucontig"
	}
    }
    
    set AccessRNA [ExtraitAccessDuRNA $Nom]
    if {$AccessRNA!=""} {
	set LesBandesAPartirDeAccessRNA [LesBandesCytologiquesDeLorganisme $AccessRNA]
	set Band [split $LesBandesAPartirDeAccessRNA " "]
	set N [llength $Band]
	if {$N==1} {
	    return  "$Nom\t$AccessRNA\t$LesBandesAPartirDeAccessRNA"
	}
    }
    
    set DefinitionRNA [EssaiExtraitDefinitionRNA $Nom]
    set LesBandesAPartirDeDef [LesBandesCytologiquesDeLorganisme $DefinitionRNA]
    if {$LesBandesAPartirDeDef!=""} {
	set Positions [split $LesBandesAPartirDeDef " "]
	set Nbd [llength $Positions]
	if {$Nbd==1} {
	    return "$Nom\t$DefinitionRNA\t$LesBandesAPartirDeDef"
	}
    }

    if {$DefinitionRNA!=""} {
	set Contig [ContigDuPremierHitDuBlast $Nom]
	set LesBandesAPartirDuContigEtDefRNA [LesBandesCytologiquesDeLorganisme $Contig "$DefinitionRNA"]
	if {$LesBandesAPartirDuContigEtDefRNA!=""} {
	    set BandesCyto [split $LesBandesAPartirDuContigEtDefRNA " "]
	    set nn [llength $BandesCyto]
		return "$Nom\t$Contig\t$DefinitionRNA\t$LesBandesAPartirDuContigEtDefRNA"
	}
    }
    #si aucune de ces conditions remplies
    set AccessRNA [ExtraitAccessDuRNA $Nom]
    if {$AccessRNA!=""} {
	set LesBandes [LesBandesCytologiquesDeLorganisme $AccessRNA]
	if {$LesBandes!=""} {
	    return "$Nom\t$AccessRNA\t$LesBandes"
	}
    }
    set Contig [ContigDuPremierHitDuBlast $Nom]
    if {$LesBandesAPartirDucontig!="" && $LesBandesAPartirDucontig!=" "} {
	return "$Nom\t$Contig\t$LesBandesAPartirDucontig"
    }

}

proc BandesTrouveesEtMoyenAffymetrix {Nom} {

    set LesBandesAPartirDucontig [BandesCytologiquesAPartirDuContig $Nom]
    if {$LesBandesAPartirDucontig!=""} {
	set Bandes [split $LesBandesAPartirDucontig " "]
	set Nb [llength $Bandes]
	set Contig [ContigDuPremierHitDuBlast $Nom]
	if {$Nb==1} {
	    return  "$Nom\t$Contig\t$LesBandesAPartirDucontig"
	}
    }
    set DefinitionRNA [DefinitionDuGeneAffymetrix $Nom]
    set LesBandesAPartirDeDef [LesBandesCytologiquesDeLorganisme $DefinitionRNA]
    if {$LesBandesAPartirDeDef!=""} {
	set Positions [split $LesBandesAPartirDeDef " "]
	set Nbd [llength $Positions]
	if {$Nbd==1} {
	    return "$Nom\t$DefinitionRNA\t$LesBandesAPartirDeDef"
	}
    }

    if {$DefinitionRNA!=""} {
	set Contig [ContigDuPremierHitDuBlast $Nom]
	set LesBandesAPartirDuContigEtDefRNA [LesBandesCytologiquesDeLorganisme $Contig "$DefinitionRNA"]
	if {$LesBandesAPartirDuContigEtDefRNA!=""} {
	    set BandesCyto [split $LesBandesAPartirDuContigEtDefRNA " "]
	    set nn [llength $BandesCyto]
		return "$Nom\t$Contig\t$DefinitionRNA\t$LesBandesAPartirDuContigEtDefRNA"
	}
    }
    #si aucune de ces conditions remplie
    set Contig [ContigDuPremierHitDuBlast $Nom]
    if {$LesBandesAPartirDucontig!="" && $LesBandesAPartirDucontig!=" "} {
	return "$Nom\t$Contig\t$LesBandesAPartirDucontig"
    }

}

proc BannierePlateforme {} {

    lappend Banniere ""
    lappend Banniere ""
    lappend Banniere ""
    lappend Banniere ""
    lappend Banniere "
"
    lappend Banniere ""
    lappend Banniere ""
    lappend Banniere "
"
    lappend Banniere "
"
    set Banniere [join $Banniere "\n"]
    return $Banniere 

}

proc BannisLePAB {Nom {Garde ""}} {

    
    set LesExistants [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"]

    set LesDaEx {}
    foreach Existant $LesExistants { 
	set Date [file mtime $Existant]
	lappend LesDaEx [list $Date $Existant]
    }
    set LesDaEx [lsort -index 0 $LesDaEx] 
    set LesExistants {}
    foreach DaEx $LesDaEx {
	lappend LesExistants [lindex $DaEx 1]
    }
    set LesBannis [MorceauxChoisis $LesExistants "" "Select the files You want to delete"]

    foreach Banni $LesBannis {
	file delete -force $Banni
    }
    return $LesBannis

}

proc BanqueBlastString {TaxId} {

    set fichierFasta "/tmp/String$TaxId"
    if {![file isfile "$fichierFasta.phr"]} {
	CreeFichierFastaDesProteinesString $fichierFasta $TaxId
	exec formatdb -i $fichierFasta -p T
	file delete $fichierFasta
    }
    return $fichierFasta

}

proc BanqueEvi {Nom} {

    set BAcc [ExtraitInfo $Nom "BAcc"]
    set Banque ""
    ScanLaListe [split $BAcc ":"] Banque Access
    return $Banque

}

proc BanqueIdDeLAccess {Access} {

    set Fiche [PageInfo $Access genbank id]
    if {$Fiche != ""} {
	scan $Fiche "%s %s" ID BanqueId
	return $BanqueId
    }
    set Fiche [PageInfo $Access protein id]
    if {$Fiche != ""} {
	scan $Fiche "%s %s" LOCUS BanqueId
	return $BanqueId
    }
    return ""

}

proc BanqueIdDeLaPageInfo {PageInfo} {

    foreach Ligne [split $PageInfo "\n"] {
	if {[regexp -nocase {^ID   |^LOCUS  } $Ligne]} {
	    set Id ""
	    scan $Ligne "%s %s" EnteteID Id
	    return $Id
	} 
    }
    return

}

proc BanqueIdDeLaProt_PageInfo {PageInfo} {

    set BanqueId ""
    foreach Ligne [split $PageInfo "\n"] {
	if {![regexp "^ID  " $Ligne]} {continue}
	scan $Ligne "%s %s" ID BanqueId
	break
    }
    return $BanqueId

}

proc BarcodeAlignment {} {

    global DS

    set DS(AliLg) [LongueurDeLAlignement]
    set DS(Pfam) 0
    set DS(AddGrps) 0
    set DS(AddPDB) 0

    CreeLesPiliers

    BarcodeFrame
    BarcodeBackFigure
    BarcodeTraceAliFig

    return

}

proc BarcodeBackFigure {} {

    global DS SDG LNDG TDesSeqnames ListePDB

    set Can [set DS(Can)]
    $Can delete all

    # Trace one rectangle per group
    set YOffset 0
    set x1 $DS(StartX)
    set x2 [expr {$DS(StartX) + $DS(LaneW)}]
    set y1 $DS(StartY)
    set Lnames [lrange $LNDG 1 end]
    set xn [expr {$x1 - 10}]
    set hn [lindex [font metrics FigF] 5]
    set DS(IdBegin) [$Can create text $x1 $y1  -justify center -anchor s  -text "1"  -font FigF]
    set DS(IdEnd) [$Can create text $x2 $y1  -justify center -anchor s  -text "[set DS(AliLg)]"  -font FigF]

    set fonte FigF
    set YOffset 10
    for {set i 0} {$i < ([llength $LNDG]-1)} {incr i} {	
	set n [lindex $LNDG $i+1]
	set y2 [expr {$y1 + $DS(LaneH)}]
	$Can create rectangle $x1 $y1 $x2 $y2  -fill LightGrey  -tags [list "R$n"]
	set yn [expr {$y1 + ($y2-$y1)/2}]
	$Can create text $xn $yn  -justify right -anchor e  -font "$fonte"  -text $n  -tag T$n
	if {$DS(AddPDB) && [set DS($n,PDB)] != {}} {
	    set Ln [list]
	    foreach e [set DS($n,PDB)] {
		lappend Ln [string range $e 4 end]
	    }
	    set Spdb [join $Ln " "]
	    $Can create text $x2 $yn  -text "$Spdb"  -justify left -anchor w  -font FigPDB
	}

	set y1 [expr {$y2 + $YOffset}]
    }
    set DS(StopY) $y1

    FenetreAuCentre $DS(Toplevel)

    return

}

proc BarcodeClose {} {

    global DS

    destroy $DS(Toplevel)
    unset DS

    return

}

proc BarcodeDrawPfam {} {

    global TabSF DS LNDG

    if {"FPfam" ni [font names]} {
	font create FPfam -size 14
    }

    set Lr [BarcodeExtractPfam]

    # decale Id
    set Can $DS(Can)
    $Can itemconfigure $DS(IdBegin) -justify right -anchor e
    $Can itemconfigure $DS(IdEnd) -justify left -anchor w

    if {[llength $LNDG] == 1} {
	set LG $LNDG
    } else {
	set LG [lrange $LNDG 1 end]
    }
    set n [lindex $LG 0] 
    set bb [$Can bbox [$Can find withtag R$n]]
    set lgt $DS(AliLg)
    lassign $bb x1 y1 x2 y2
    set h $DS(LaneH)
    set x1 $DS(StartX)
    set YOffset 10
    foreach e $Lr {
	lassign $e Id d f c n
	set xd [expr {$x1+int(1.0*$DS(LaneW)/$lgt*$d)}]
	set xf [expr {$x1+int(1.0*$DS(LaneW)/$lgt*$f)}]
	BarcodeEntetePfam $n $xd $xf $c

	set i -1
	set y1 $DS(StartY)
	foreach g $LG {
	    incr i

	    set y2 [expr {$y1 + $h}]
	    if {[PfamDansGroupe $g $Id $d $f]} {
		set yd [expr {$y1-6}]
		set yf [expr {$y2+6}]
		$Can create rectangle $xd $yd $xf $yf  -fill $c -outline $c  -tags PFam
	    }
	    set y1 [expr {$y2 + $YOffset}]
	}
    }

    $Can lower PFam

    return

}

proc BarcodeEntetePfam {n d f c} {

    global DS

    set y1 $DS(StartY)
    regsub -all "_" [string trim $n] " " n
    set w [font measure FPfam $n]
    set lb [regexp -all -inline -indices { } $n]
    set lb [lsort -decreasing -index 0 -integer $lb]
    set note $n
    set i 0
    while {$w > ($f - $d + 1)} {
	set ib [lindex [lindex $lb $i] 0]
	set note "[string range $n 0 $ib-1]\n[string range $n $ib+1 end]"
	set w [font measure FPfam [string range $n 0 $ib-1]]
	incr i
    }
    set Can $DS(Can)
    set xn [expr {$d + ($f - $d + 1)/2}]
    set yn [expr {$DS(StartY) - 10}]
    # entete deja la
    set ie [$Can find closest $xn $yn]
    if {$ie ne ""} {
	lassign [$Can bbox $ie] tmp yn tmp tmp
    }

    set id [$Can create text $xn $yn  -text "$note" -font FPfam  -fill white  -anchor s -justify center]
    lassign [$Can bbox $id] tmp y1 tmp y2
    $Can create rectangle $d $y1 $f $y2  -fill $c -outline $c  -tags entete

    $Can raise $id

    return

}

proc BarcodeExtractPfam {} {

    global TabSF DS

    # 1 recupere les TYPES de pfam presents
    set Lp [array names TabSF "*,PFAM*"]
    set Ltp [list]
    foreach e $Lp {
	lassign [split $e ,] n p
	lappend Ltp $p
    }
    set Ltp [lsort -unique $Ltp]
    
    # 2 recupere les ID/noms pfam
    foreach p $Ltp {
	set Ln [array names TabSF "*,$p"]
	foreach n $Ln {
	    foreach e [set TabSF($n)] {
		DecortiqueUneFeature $e d f c tmp note
		lassign [BarcodeTraitePfam $note] Id txt
		lappend Trbrut($Id) [list $d $f $c $txt]
	    }
	}
    }
    set Lr [TrieZonesPfam Trbrut]

    return $Lr

}

proc BarcodeFrame {} {

    global DS ListeTypesDeFeatures

    set DS(StartX) 300
    set DS(StartY) 200
    set DS(LaneW) 800
    set DS(LaneH) 50

    if {"FigF" ni [font names]} {
	font create FigF -family Helvetica -size 28
	font create FigMito -family Helvetica -size 28 -underline 1
	font create FigCyto -family Helvetica -size 28 -slant italic
	font create FigCyMi -family Helvetica -size 28 -slant italic -underline 1
	font create FigPDB -family Helvetica -size 14 -slant italic -underline 1
    }

    set w .barcode
    set DS(Toplevel) $w
    toplevel $w
    frame $w.css
    grid $w.css -row 0 -column 0 -sticky news
    grid columnconfig $w 0 -weight 1
    grid rowconfig    $w 0 -weight 1

    set Can $w.css.can
    set DS(Can) $Can
    canvas $w.css.can  -scrollregion [list 0 0 2000 2000]  -width 750  -height 420  -yscrollcommand "$w.css.scy set"  -xscrollcommand "$w.css.scx set"  -background white
    scrollbar $w.css.scy  -orient vertical  -command "$w.css.can yview"
    scrollbar $w.css.scx  -orient horizontal  -command "$w.css.can xview"
    grid $w.css.can -row 0 -column 0 -sticky news
    grid $w.css.scy -row 0 -column 1 -sticky ns
    grid $w.css.scx -row 1 -column 0 -sticky ew
    grid rowconfig    $w.css 0 -weight 1
    grid columnconfig $w.css 0 -weight 1

    frame $w.cb
    grid $w.cb -row 1 -column 0 -sticky ew
    set Lfeat [linsert $ListeTypesDeFeatures 0 Select]
    set wdt [PlusLongEltDe $Lfeat]
    set DS(FeatSel) [lindex $Lfeat 0]
    ttk::combobox $w.cb.cbox  -values $Lfeat  -width $wdt  -background white  -foreground black  -state readonly  -textvariable DS(FeatSel)
    $w.cb.cbox index 0
    bind $w.cb.cbox <> ""
    checkbutton $w.cb.pfam  -text " PFAM "  -onvalue 1  -offvalue 0  -variable DS(Pfam)
    checkbutton $w.cb.pdb  -text " PDB "  -onvalue 1  -offvalue 0  -variable DS(AddPDB)
    checkbutton $w.cb.grp  -text " Groups "  -onvalue 1  -offvalue 0  -variable DS(AddGrps)
    button $w.cb.close  -text "Close"  -background red  -command BarcodeClose
    button $w.cb.print  -text "Print"  -background yellow  -command {PrintCanvas "$w.css.can" png}
    grid $w.cb.cbox  -row 0 -column 0 -padx 20
    grid $w.cb.pfam  -row 0 -column 1
    grid $w.cb.pdb   -row 0 -column 2
    grid $w.cb.grp   -row 0 -column 3
    grid $w.cb.print -row 0 -column 4
    grid $w.cb.close -row 0 -column 5 -padx 20
    grid columnconfig $w all -weight 1
    grid columnconfig $w.cb all -weight 1
    grid rowconfig    $w 0   -weight 1

    bind $Can  {%W scan mark %x %y}
    bind $Can  {%W scan dragto %x %y 1}

    trace add variable DS(Pfam)    write BarcodeView
    trace add variable DS(AddPDB)  write BarcodeView
    trace add variable DS(AddGrps) write BarcodeView

    FenetreAuCentre $w

    return

}

proc BarcodeTracageFeature {n Lf} {

    global DS

    set Can $DS(Can)
    set bb [$Can bbox [$Can find withtag R$n]]
    lassign $bb x1 y1 x2 y2
    incr y1 2
    incr y2 -2
    set Lg $DS(AliLg)
    set ctr 0
    foreach f $Lf {
	lassign $f d f c
	set xd [expr {$x1+int(1.0*$DS(LaneW)/$Lg*$d)}]
	set xf [expr {$x1+int(1.0*$DS(LaneW)/$Lg*$f)}]
	if {$ctr} {
	    # INDEL = contour de la zone
	    $Can create rectangle $xd $y1 $xf $y2  -width 6  -outline $c
	} else {
	    # residue = trace ligne
	    if {$d == $f} {
		$Can create line $xd $y1 $xd $y2  -fill $c  -width 3
	    } else {
		$Can create rectangle $xd $y1 $xf $y2  -fill $c  -outline $c
	    }
	}
    }

    return

}

proc BarcodeTraceAliFig {} {

    global DS db ListeDesPiliersDuGroupe LNDG
    
    if {[llength $LNDG] == 1} {
	set Lg $LNDG
    } else {
	set Lg [lrange $LNDG 1 end]
    }

    foreach n $Lg {
	set i 0
	set plg [string length [lindex $ListeDesPiliersDuGroupe($n) 0]]
	set DS(Dep) -1
	set DS(Contig) 0
	for {set i 0} {$i < $DS(AliLg)} {incr i} {
	    set p [string map [list "." ""] [lindex $ListeDesPiliersDuGroupe($n) $i]]]
	    set pl [string length $p]
	    if {100.*$pl/$plg >= 10 } {
		BarcodeTracePilierFig [expr {$i+1}] $n
	    }
	}
	BarcodeTracePilierFig $i $n 1
	$DS(Can) lower R$n
    }

    return

}

proc BarcodeTraceFeatureFig {} {

    global DS TabSF LNOrdali SDG LNDG

    if {[llength $LNDG] == 1} {
	set Lg $LNDG
    } else {
	set Lg [lrange $LNDG 1 end]
    }

    set ft $DS(FeatSel)
    foreach n $Lg {
	set Lfaf [list]
	set Ls [set SDG($n)]
	foreach nom $Ls {
	    if {! [info exists TabSF($nom,$ft)]} {
		continue
	    }
	    foreach e [set TabSF($nom,$ft)] {
		DecortiqueUneFeature $e d f c tmp note
		lappend Lfaf [list $d $f $c]
	    }
	}
	set Lfaf [lunique [lsort -integer -index 1 $Lfaf]]
	BarcodeTracageFeature $n $Lfaf
    }

    return

}

proc BarcodeTracePilierFig {i n {fin 0}} {

    global DS

    if {! $DS(Contig)} {
	set DS(Contig) 1
	set DS(Dep) $i
    } elseif {$DS(Dep)+$DS(Contig) == $i} {
	incr DS(Contig)
	if {$fin} {
	    set fin 0
	} else {
	    return
	}
    }

    set c $DS(Can)
    set bb [$c bbox [$c find withtag R$n]]
    lassign $bb x1 y1 x2 y2
    set ic1 [expr {int(double($DS(LaneW))/$DS(AliLg)*$DS(Dep))}]
    set xi1 [expr {$x1+$ic1}]
    set ic2 [expr {int(double($DS(LaneW))/$DS(AliLg)*($DS(Dep)+$DS(Contig)))}]
    set xi2 [expr {$x1+$ic2}]
    if {$xi1 == $xi2} {
	
	$c create line $xi1 $y1 $xi1 $y2  -fill DarkSlateGrey
    } else {
	$c create rectangle $xi1 $y1 $xi2 $y2  -fill DarkSlateGrey  -outline DarkSlateGrey
    }
    
    set DS(Contig) 1
    set DS(Dep) $i

    return

}

proc BarcodeTraitePfam {n} {

    if {[regexp {^PROP_} $n]} {
	set n [string range $n 5 end]
    }
    set Li [regexp -inline -indices {_from_} $n]
    if {$Li != ""} {
	set i [lindex [lindex $Li 0] 0]
	set n [string range $n 0 $i-1]
    }

    set Id [string range $n 0 6]
    set tx [string range $n 8 end]

    return [list $Id $tx]

}

proc BarcodeTriePfam {l} {


    set l [lsort -index 1 -integer $l]

    set Lr [list]
    lassign [lindex $l 0] id1 d1 f1 c1 t1
    set Done 0
    foreach e [lrange $l 1 end] {
	if {$Done} {
	    lappend Lr [list $id1 $d1 $f1 $c1 $t1 $s]
	} else {
	    set Done 1
	}

	lassign $e id2 d2 f2 c2 t2
	# inclusion
	if {$d2 <= $f1} {
	    set s 1
	} else {
	    set s 0
	}
	lassign $e id1 d1 f1 c1 t1
    }
    lappend Lr [list $id1 $d1 $f1 $c1 $t1 $s]

    return $Lr

}

proc BarcodeView {args} {

    global Defauts DS

    BarcodeBackFigure
    BarcodeTraceAliFig
    BarcodeTraceFeatureFig
    if {$DS(Pfam)} {
	BarcodeDrawPfam
    }

    return

}

proc Barycentre {LesXY} {

    set SX 0
    set SY 0
    set N [expr [llength $LesXY]/2]
    if {$N<1} { return {0. 0.} }
    foreach {X Y} $LesXY {
	set SX [expr $SX+$X]
	set SY [expr $SY+$Y]
    }
    return [list [expr 1.0*$SX/$N] [expr 1.0*$SY/$N]]

}

proc Barycentre3D {L} {

    set i 0
    set xc 0 ; set yc 0 ; set zc 0
    foreach t $L {
	lassign $t x y z
	set xc [expr {$xc + $x}]
	set yc [expr {$yc + $y}]
	set zc [expr {$zc + $z}]
	incr i
    }
    set xc [expr {$xc/$i}]
    set yc [expr {$yc/$i}]
    set zc [expr {$zc/$i}]

    return [list $xc $yc $zc]

}

proc BasculeLibs {from to} {

    # mise a jour librairies tcl
    #
    # Quand on installe nouvelle version de Tcl,
    # il faut ramener toutes les librairies qui 
    # existaient dans l'ancienne version vers la 
    # nouvelle, A L'EXCLUSION DES LIBS DE TCL LUI MEME
    #
    # from : top directory of OLD tcl install
    # to   : top directory of NEW Tcl install
    set home [pwd]

    cd /usr/local
    cd [file join $from lib]
    set Lfrom [glob -type d *]
    cd /usr/local
    cd [file join $to lib]
    set Lto   [glob -type d *]
    set Llib [lor $Lfrom $Lto "from1"]

    cd /usr/local
    foreach l $Llib {
	set in  [file join $from lib $l]
	set out [file join $to   lib $l]
	file copy -force $in $out
    }

    cd $home

    exit

}

proc Base10 {Texte} {

    regsub " " $Texte "" Texte
    if {[regexp "^\-" $Texte]} { set PlusOuMoins "-" } else { set PlusOuMoins "" }
    regsub {^[\-0]*} $Texte "" Texte
    if {$Texte==""} { set Texte 0 }
    return "$PlusOuMoins$Texte"

}

proc Base64Decode {Texte} {

    package require base64
    return [::base64::decode $Texte]

}

proc Base64Encode {Texte {KeepEqual ""}} {

    #rR depuis 20150310 le defaut est d'enlever les trailing =
    #rR les = sont rajoutes pour qu'il y ait un mltiple de 4 octets
    set KeepEqual [string equal -nocase "KeepEqual" $KeepEqual]
    package require base64    
    set B64 [::base64::encode -wrapchar "" $Texte]
    if { ! $KeepEqual } { set B64 [string trim $B64 "="] }
    return $B64

}

proc Base64Test {{Texte TRULULU}} {

    Espionne "Texte  >>>$Texte<<<"

    set B64 [Base64Encode $Texte]
    Espionne "B64    >>>$B64<<< [string length $B64]"
    set D64 [Base64Decode $B64]
    Espionne "DecB64 >>>$D64<<<"

    set B64 [Base64Encode $Texte KeepEqual]
    Espionne "B64    >>>$B64<<< KeepEqual  [string length $B64]"
    set D64 [Base64Decode $B64]
    Espionne "DecB64 >>>$D64<<< KeepEqual"

}

proc BaseCount {} {

    foreach T [concat [AnnotType ListOf T] [list F]] {
	set Total 0
	foreach Chr [ListOfChr] {
	    foreach D [EleGen $Chr $T ListOf D] F [EleGen $Chr $T ListOf F] {
		set Size [expr $F-$D+1]
		incr Total $Size
	    }
	}
	if {0} {
	    set FichierMotMap "[AnnotRep]/MotifsMapping.txt"
	    set Type [AnnotType $T Type]
	    if {$T==7 || $T==8 || $T==9} {
		set FichierMotMap "[AnnotRep]/MotifsMapping$T.txt"
	    }
	    if {$T=="F"} {
		set NbMotif [MotifMapping $T Nb Motif]
	    } else {
		set NbMotif [exec grep -c $Type $FichierMotMap]
	    }
	}
	set Ratio 0
	if {$NbMotif!=""} { set Ratio [expr (1000000000*$NbMotif)/$Total] }
	set Code [AnnotType $T Code]
	Espionne [format "%9s %7d %11d %7d pour 1Gb" $Code $NbMotif $Total $Ratio]
    }

}

proc BashFromTcsh {{FileT ""} {FileB ""}} {

    if {$FileB==""} { set FileB "$FileT.bash" } 
    if {[file exists $FileT]} {
	set T [ContenuDuFichier $FileT]
    } else {
	set T $FileT
    }

    set LeOld [split $T "\n"]
    set LeNew {}
    set PremiereLigne 1
    foreach Ligne [split $T "\n"] {
Espionne $Ligne
#	if {[regexp "set NoGcg=1" $Ligne]} { exit }
	set New $Ligne
	if {$PremiereLigne && [regexp {^#!.*/tcsh} $New]} {
	    set New "#!/bin/bash\n#rR converted from tcsh by BashFromTcsh"
	    set PremiereLigne 0
	    lappend LeNew $New
	    continue
	}
	if {[regexp {([ \t]*)(set)([ \t]+)([^=]+)(=)([ \t]*)(\$<)} $New Match B1 Set B2 Var B3 Egal B4 Chevron]} {
	    set New "${B1}read $Var"
	}
	set YaSet 0
	set YaSetenv 0
	if {[regexp {(^|[ \t]+)set([ \t]+)([^ \t=]+)} $New]} {
	    set YaSet 1
	    regsub  {(^|[ \t]+)set([ \t]+)([^ \t=]+)} $New "\\1\\3@=@" New
	}
	if {[regexp {(^|[ \t]+)setenv([ \t]+)([^ \t]+)} $New]} {
	    set YaSetenv 1
	    regsub  {(^|[ \t]+)setenv([ \t]+)([^ \t]+)} $New "\\1export \\3@=@" New
	}
	if {$YaSet || $YaSetenv} {
	    regsub {([ \t]*)@=@=?([ \t]*)} $New "\\1@=@" New
	    if {[regexp {@=@([^0-9\"\'].*)$} $New]} {
#		regsub  {@=@([^0-9].*)$} $New "@=@\"\\1\"" New
	    }
	    regsub {@=@} $New "=" New
	}
	if {[regexp {(^[ \t]*)(alias)([ \t]+)([^ \t]+)([ \t]+)(.*)} $New Match B1 Alias B2 Nom B3 Valeur]} {
	    if { ! [regexp {[\"\']} $Valeur]} {
		regsub -all "\"" $Valeur "\\\"" Valeur
		set Valeur "\"$Valeur\""
	    }
	    set New "$B1$Alias$B2$Nom=$Valeur"
	}
#                    B1       If  B2      Op  Exp     B3      Clo Suite
	if {[regexp {(^[ \t]*)(if)([ \t]+)(\()([^\)]+)([ \t]*)(\))(.*)} $New  Match B1 If B2 Open Exp B3 Close Suite]} {

	    set Exp [string trim $Exp]
#	    set OBash "\[\["
#	    set CBash "\]\]"
	    set OBash "test"
	    set CBash " "
	    set EBash $Exp
#	    set EBash [string map {"==" "-eq" "!=" "-ne" "<" "-lt" ">" "-gt" "<=" "-le" ">=" "-ge"} $Exp]
	    set EBash [string map {"<" "\\<" ">" "\\>-gt"} $Exp]

	    regsub -nocase -all {\$\?([a-z0-9_]+)} $EBash "$\{\\1\+x\}" EBash 

	    set Suite [string trim $Suite]
	    if {$Suite=="then"} {
		set Suite "; then"
	    } else {
		set Suite "; then $Suite ; fi"
	    }
	    set New "${B1}if $OBash $EBash $CBash $Suite"
	    Espionne 
	    Espionne $Ligne
	    Espionne $New
	    lappend LeNew $New
	    continue
	}
	if {[regexp {(^[ \t]*)(endif)(.*)} $New  Match B1 EndIf Suite]} {
	    set New "${B1}fi"
	    lappend LeNew $New
	    continue
	}
	Espionne $Ligne
	if {[regexp {(^[ \t]*)(unset(env)?)([ \t]+)(.*)} $New Match B1 Unset Env B2 Suite]} {
	    set New "${B1}unset$B2$Suite"
	    lappend LeNew $New
	    Espionne "B1   =$B1="
	    Espionne "unset=$Unset="
	    Espionne "B2   =$B2="
	    Espionne "Suite=$Suite="

	}
	
	lappend LeNew $New
    }
    SauveLesLignes $LeNew dans $FileB
    exec meld $FileT $FileB &
    exit

    AfficheListe $LeOld ""           "TCSH"
    AfficheListe $LeNew "AvecRetour" "BASH"
    return $LeNew

}

proc BatchClustalw {args} {


    global tcl_platform
    global OrdTmpDir
    global OrdaliDir

    if {[llength $args] != 0 } {
	set in1 [file tail [lindex $args 0]]
	set out [file tail [lindex $args 1]]
	set log [file tail [lindex $args 2]]

	set Argmt [join [lrange $args 3 end] " "]

	set tmpadel [file join $OrdTmpDir "tmp*"]
	file delete -force $tmpadel
	file delete -force $log
	file delete -force $out.msf

	set DndName [file join $OrdTmpDir "${in1}.dnd"]

	set Commande "[ClustalwExe] $in1 -output=gscope $Argmt >&  $log"
	if {[regexp -nocase "windows" $tcl_platform(platform)]} {
	    regsub -all " -" $Commande " /" Commande
	}

	cd $OrdTmpDir
	eval exec $Commande
	file delete -force $DndName
	file rename -force "${in1}.msf" [SigneFichier "$in1.msf"]
	cd $OrdaliDir
    }

    return

}

proc BatchClustalwProfile {args} {


    global tcl_platform
    global OrdTmpDir
    global OrdaliDir

    if {[llength $args] != 0 } {
	set In1 [file tail [lindex $args 0]]
	set In2 [file tail [lindex $args 1]]
	set Out [file tail [lindex $args 2]]
	set log [file tail [lindex $args 3]]

	set Argmt [join [lrange $args 4 end] " "]

	set tmpadel [file join $OrdTmpDir "tmp*"]
	file delete -force $tmpadel
	file delete -force $log
	file delete -force $Out.msf

	set DndName "${In2}.dnd"

	set Commande  "[ClustalwExe] -profile1=$In1 -profile2=$In2 -outfile=$Out -output=gscope $Argmt >& $log"
	if {[regexp -nocase "windows" $tcl_platform(platform)]} {
	    regsub -all " -" $Commande " /" Commande
	}

	cd $OrdTmpDir
	eval exec $Commande
	file delete -force $DndName
	cd $OrdaliDir
    }

    return

}

proc Bathy2010 {{Action ""}} {


    if {$Action==""} { set Action "ShowGetSave" }

    set FicTfaOri "[BathyCompositionContig NameOf Directory]/DeIsa/touteslesbathy.tfa"
    set FicTfaNew "[BathyCompositionContig NameOf Directory]/DeIsa/Bathy2010.tfa"
    set i 0
    foreach Access [LaSequenceDuTFAs $FicTfaOri "LaListeDesAccess"] {
	incr i
	set TFA    [LaSequenceDuTFAs $FicTfaOri $Access]
	set Entete [string trim [EnteteDuTexteTFA $TFA]]
	set Seq    [QueLaSequenceDuTexteTFA $TFA]
	set A ""
	if {[regexp {>(CL([0-9]+)Contig([0-9]+))} $Entete Match CLContig]} {
	    set A $CLContig
	    set Reads     [BathyCompositionContig $CLContig "Reads"]
	    set Libraries [BathyCompositionContig $CLContig "Libraries"]
	    set R [llength $Reads]
	    set L [llength $Libraries]
	    set E ">$A $R reads from $L libraries"
	    set New [SequenceFormatTFA $Seq $E "nucbrut"]
	}
	if {[regexp {>(IN0[A-Z]+([0-9]+)([^\.]+)).SCF} $Entete Match Nom I Y]} {
	    set A $Nom
	    set E ">$A SSH$I library $Y"
	    set New [SequenceFormatTFA $Seq $E "nucbrut"]
	}
	if {[regexp {>(SSH([0-9]+)\.([0-9]+)([^\.]+)\.ab1)} $Entete Match Nom I Y D]} {
	    set A "SSH$I.$Y"
	    set Lib "SSH$I"
	    if { ! [regexp {_\-_([^_]+)_([0-9\-]+)_(.+)} $D Match Z Date Id]} { FaireLire "couaccouac" }
	    set E ">$A $Lib library $Z $Date $Id"
	    set New [SequenceFormatTFA $Seq $E "nucbrut"]
	}
	if {[set X [regexp {>BA[0-9]+[ \t](IN0[A-Z]+([0-9]+)([^ \t]+))} $Entete Match Nom I Y]]} {
	    set A $Nom
	    set E ">$A Stress library $Y"
	    set New [SequenceFormatTFA $Seq $E "nucbrut"]
	}
	if {$A==""} {FaireLire "$Entete was not recognized";  continue }
	if {[info exists DejaVu($A)]} {
	    Espionne "$A"
#	    set AutreTFA [StringSuivant " " dans $DejaVu($A)]
	    set AutreTFA $DejaVu($A)
	    if {$TFA!=$AutreTFA} { FaireLire "duplication access" }
	    continue
	}
	lappend LeNew $New
	set DejaVu($A) "$TFA"
    }
    if {[regexp -nocase "Show" $Action]} {set Fen [AfficheListe $LeNew] }
    if {[regexp -nocase "Save" $Action]} {set Fic [SauveLesLignes $LeNew dans $FicTfaNew] }
    if {[regexp -nocase "GetShow" $Action]} {return $Fen }
    if {[regexp -nocase "GetSave" $Action]} {return $Fic }
    return ""

}

proc BathyCompositionContig {{Qui ""} {Quoi ""}} {

    global BCC
    if {$Qui ==""} { set Qui  "Show" }
    if {$Quoi==""} { set Quoi "Resume" }
    if {[info exists BCC($Qui,$Quoi)]} { return $BCC($Qui,$Quoi) }
    if {[info exists BCC("EstCharge")]} {
	if {$Qui=="Show"} { return [AfficheListe $BCC(ListOf,$Quoi)] }
	if {[info exists BCC("EstCharge")]} { return "" }
    }
    set BCC("EstCharge") 1
    set Bathy2010Dir "/genomics/link/Bathy2010"
    set BCC(NameOf,Directory) $Bathy2010Dir
    set LesPerdus {}
    foreach Ligne [LesLignesDuFichier "$Bathy2010Dir/DeIsa/composition_contigs.txt"] {
	if { ! [regexp {CL([0-9]+)Contig([0-9]+)} $Ligne CLContig CL C] } { continue }
	if {[info exists BCC($CLContig,Reads)]} { FaireLire "$CLContig deja vu !"; }
	set Libraries {}
	set Reads {}
	foreach Mot [split $Ligne " "] {
	    if { ! [regexp {(IN0ACC([0-9]+)([^\.]+)).SCF} $Mot Match Read I Y]} { lappend LesPerdus $Mot; continue }
	    set BCC($CLContig,CL) $CL
	    set BCC($CLContig,C)  $C
	    lappend Reads $Read
	    lappend Libraries "SSH$I"
	}
	set Reads     [lsort -dictionary -unique $Reads]
	set Libraries [lsort -dictionary -unique $Libraries]
	set BCC($CLContig,Reads)     $Reads
	set BCC($CLContig,Libraries) $Libraries
	lappend LesCLContig $CLContig
    }
    set BCC(ListOf,CLContig) [lsort -dictionary -unique $LesCLContig]
    foreach CLContig $LesCLContig {
	if { ! [regexp {CL([0-9]+)Contig([0-9]+)} $CLContig Bidon CL C] } { FaireLire "couac" }
	set Resume "$CLContig $CL $C : [join $Reads " "]"
	set BCC($CLContig,Resume)      $Resume
	lappend LeResume $Resume
    }
    set BCC(ListOf,Resume) $LeResume
    return [BathyCompositionContig $Qui $Quoi]

}

proc BeauDessin {} {

    set K [UnCanva]
    $K create rectangle 100 100 200 300 -fill "red"
    pack $K

}

proc BeauGN {GN} {

    return $GN

}

proc BeauScore {} {

    foreach Ligne [LesLignesDuFichier outlierscore] {
	scan $Ligne "%s %s" Nom S
	if {$S==""} { set S -2}
	set B [format "%8.1e" $S]
	Espionne $B
	lappend LesBeaux "$Nom $B"
    }
    SauveLesLignes $LesBeaux dans "[RepertoireDuGenome]/fiches/outlierscorebeaux" 
    exit

}

proc BeginWarning2HTML {aT} {

    upvar $aT tbl

    set style "font-style:bold;color:red;"
    if {$tbl(Id) ne ""} {
	Html_Append "
"
    } else {
	Html_Append "
"
    }
    Html_Append "
"

    return

}

proc BelleBanque {} {

    set FichierTFA "[RepertoireDuGenome]/banques/protenplus"
    set S 0
    set C 0
    set B 0
    foreach Access [LaSequenceDuTFAs $FichierTFA "LaListeDesAccess"] {
	set TFA [LaSequenceDuTFAs $FichierTFA $Access]
	set Entete [EnteteDuTexteTFA $TFA]
	Espionne "$Access"
	if {[regexp "^s" $Access]} { set A "SCB:Spur[format %3.3d [incr S]] $Entete" }
	if {[regexp "^c" $Access]} { set A "SCB:Cint[format %3.3d [incr C]] $Entete" }
	if {[regexp "^A" $Access]} { set A "SCB:$Access $Entete" }
	set Seq [QueLaSequenceDuTexteTFA $TFA]
	set New [SequenceFormatTFA $Seq $A "protbrut"]
	lappend LaNouvelle $New
    }
    set Nouvelle [join $LaNouvelle "\n"]
    return [Sauve $Nouvelle dans "$FichierTFA.bellebanque"]

}

proc BelleGauche {Texte} {

    set BeauTexte [format "%-12s  " $Texte]
    if {[regexp -nocase {[a-z]} $BeauTexte]} {
	set TexteHTML "$BeauTexte" 
    } else {
	set TexteHTML $BeauTexte
    }
    return $TexteHTML

}

proc BelleLigne {Ligne} {

    set LesMots [LesMotsDeLaLigne $Ligne]
    ScanLaListe $LesMots P G E A
    set O [lindex $LesMots end]
    set Reste [join [lrange $LesMots 4 end] " "]
    set Belle [format "%-30s %-10s %s %-10s %10s %-20s" $P $O $Reste $G $E $A]
    return $Belle

}

proc BelleVue {H V Nom} {

    if {$H=="ProbeSetId" || $H=="ProbeSet"} {return [H_Href $V "http://genoret.igbmc.fr/genoret/Project/igbmc/evimm/testGscopeLaetitia.php?GscopeID=$Nom" "target='_blank'"]}
    #if {$H=="ProbeSetId"} {return [H_Href $V "[LbgiUrl]/SignalIntensityImage/$Nom*" "target='_blank'"]}

    if {$H=="GscopeId"} {return [H_Href $V "[WscopeScience]&FileMoi&$Nom" "target='_blank'"]}

    if {$H=="Description"} {return [H_Href $V "[WscopeScience]&FileMoi¬es&$Nom" "target='_blank'"]}

    if {$H=="TissueTypes" || $H=="TissueType"} {
	return [H_Href $V "[LbgiUrl]/jpg_of_TissType/${Nom}_TissType.jpg" "target='_blank'"]
    }
    if {$H=="DevStages"} {
	return [H_Href $V "[LbgiUrl]/jpg_of_DevStage/${Nom}_DevStage.jpg" "target='_blank'"]
    }
    if {$H=="AccessmRNA"} {
	return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
    }
    if {$H=="AccessProt"} {
	return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
    }
    if {$H=="CopainsDesCompulsory"} {
	return [H_Href $V "[WscopeScience]&InterrogeCopainsDesCompulsory&$Nom" "target='_blank'"]
    }
    if {$H=="cDNA"} {
	return [H_Href $V "[WscopeScience]&FileMoi&ResultcDNA/RecapInfoADNc&$Nom" "target='_blank'"]
    }
    return $V

}

proc BelleVueJean {H V Nom} {

    if {$H=="RetscopeId"} {
	return [H_Href $V "[WscopeScience]&FileMoi&FastaFiles&$Nom" "target='_blank'"]
    }
    if {$H=="NucAccessionNumber"} {
	return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
    }
    if {$H=="ProtAccessionNumber"} {
	return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
    }
    return $V

}

proc BelleVueMutation {H V Nom} {

    if {$H=="MS2PH"} {
	return [H_Href $V "http://pig-pbil.ibcp.fr/cgi-bin/magos/home"]
    }
    if {$H=="Mutation"} { 
	set P ""
	scan $V "%s %s" B P
	if {$B==""} { return $V }
	set Access "${Nom}_${B}_${P}"
	set Queue $Access
	regsub -all {[>\?]} $Queue "-" Queue
	set Clics ""
	if { ! [regexp {[^p\.]} $P]} {
	    append Clics [H_Href $V "[WscopeScience]&FileMoi&nuctfaMut&$Queue" "target='_blank'"]
	} else {
	    regsub "$B $P" $V "" Commentaire
	    append Clics [H_Href $B "[WscopeScience]&FileMoi&nuctfaMut&$Queue" "target='_blank'"]
	    append Clics " "
	    append Clics [H_Href $P "[WscopeScience]&FileMoi&prottfaMut&$Queue" "target='_blank'"]
	    append Clics " "
	    append Clics $Commentaire
	}
	append Clics "  "
	append Clics [H_Href "(See diff)" "[WscopeScience]&ShowMutationOnWeb&$Nom&$Queue" "target='_blank'"]
	return $Clics
    }
    return [BelleVue $H $V $Nom]

}

proc BellesCouleurs {} {

    set Max 0
    foreach Ligne [LesLignesDuFichier "$GscopeEtc/gscope_couleurs.txt"] {
	scan $Ligne "%s %s" C H
	set Hexa($C) $H
	set Color($H) $C
	set Max [Maxi [string length $C] $Max]
	lappend LesCs $C
    }
    
    foreach C $LesCs {
	set H [set Hexa($C)]
	set c [string tolower $C]
	set Ligne [format "   %-${Max}s => \"%s\"," "\"$c\"" $H]
	Espionne $Ligne
    }
    exit

}

proc BenEnteteTFA {filename} {


		set found 0
		if {[FileAbsent "[RepertoireDuGenome]/prottfa/$filename"]} {return "file absent"}
		set FIC [open "[RepertoireDuGenome]/prottfa/$filename" "r"]
		while {[gets $FIC line]!=-1} {
			if {[string index $line 0]==">"} {
				set found 1
				close $FIC
				if {[string index $line end]=="\n"} {
					return [string range $line 0 end-1]
				} else {
					return $line
				}
			}
		}
		if {$found==0} {
			puts "Aucune entete fasta pour $filename"
		}
		close $FIC
		return ""
		


}

proc BenSeqLength {filename} {

	global RepertoireDuGenome
	set length 0
	set FIC [open "$RepertoireDuGenome/prottfa/$filename" "r"]
	#puts "'$RepertoireDuGenome/prottfa/$filename'"
	while {[gets $FIC line]!=-1} {
		if {[string index $line 0]==">"} { continue }
		if {[string index $line end]=="\n"} {
			set length [expr $length+[string length $line]-1]
		} else {
			set length [expr $length+[string length $line]]
		}
	}
	close $FIC
	#puts "'$length'"
	return $length

}

proc BenjiLaMalice {mode} {


    if { $mode == $::GL_SELECT } {
	global TLabList

	if {! [info exists TLabList]} {
	    global Cor

	    set TLabList [glGenLists 1]
	    glNewList $TLabList GL_COMPILE_AND_EXECUTE

	    set Cor(0) [list "Text P0" {0.0 0.0 0.0}]
	    glInitNames
	    glPushName 0

	    glLoadName 0
	    glBegin GL_POINTS
	    glVertex3f 0.0 0.0 0.0
	    glEnd

	    set Cor(2) [list "Text P2" {1.0 0.0 0.0}]
	    glLoadName 2
	    glBegin GL_POINTS
	    glVertex3f 1.0 0.0 0.0
	    glEnd

	    set Cor(4) [list "Text P4" {0.0 1.0 0.0}]
	    glLoadName 4
	    glBegin GL_POINTS
	    glVertex3f 0.0 1.0 0.0
	    glEnd

	    set Cor(6) [list "Text P6" {0.0 0.0 -1.0}]
	    glLoadName 6
	    glBegin GL_POINTS
	    glVertex3f 0.0 0.0 -1.0
	    glEnd

	    glEndList
	} else {
	    #	    puts "===> Call List !"
	    #	    glCallList $PickList
	}
    } else {
	glBegin GL_TRIANGLES

	glColor3f  1.0  0.0  0.0
	#	light_color3f  1.0  0.0  0.0
	glNormal3f 1.0  0.0  0.0
	glVertex3f 0.0  0.0  0.0

	#	light_color3f  0.0  1.0  0.0
	glColor3f  0.0  1.0  0.0
	glNormal3f 1.0  0.0  0.0
	glVertex3f 0.0  0.0  1.0

	#	light_color3f  0.0  0.0  1.0
	glColor3f  0.0  0.0  1.0
	glNormal3f 1.0  0.0  0.0
	glVertex3f 0.0  1.0  0.0

	if {0} {
	    glColor3f  1.0  1.0  1.0
	    glNormal3f 0.0  1.0  0.0
	    glVertex3f 0.0  0.0  0.0
	    glColor3f  0.0  0.0  1.0
	    glNormal3f 0.0  1.0  0.0
	    glVertex3f 1.0  0.0  0.0
	    glColor3f  1.0  0.0  0.0
	    glNormal3f 0.0  1.0  0.0
	    glVertex3f 0.0  0.0 -1.0

	    glColor3f  0.0  1.0  0.0
	    glVertex3f 0.0  1.0  0.0
	    glColor3f  0.0  0.0  1.0
	    glVertex3f 1.0  0.0  0.0
	    glColor3f  1.0  0.0  0.0
	    glVertex3f 0.0  0.0 -1.0

	    glColor3f  1.0  1.0  1.0
	    glVertex3f 0.0  0.0  0.0
	    glColor3f  0.0  0.0  1.0
	    glVertex3f 1.0  0.0  0.0
	    glColor3f  0.0  1.0  0.0
	    glVertex3f 0.0  1.0  0.0
	}
	glEnd
    }

    return

}

proc BestDE {Nom} {

    if {[set ValiDE  [ExtraitInfo $Nom "ValiDE:"]] !=""} { return $ValiDE } 
    if {[set DE      [ExtraitInfo $Nom "DE:"]]     !=""} { return $DE } 
    if {[set DraftDE [ExtraitInfo $Nom "DraftDE:"]]!=""} { return $DraftDE }
    return ""

}

proc BestDefinitionOfBlastP {Nom {SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""}} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    Wup "Attention ca marche AUSSI pour BlastX  avec RepDuBlast"

    if {$RepDuBlast==""} { set RepDuBlast "blastp" }
    if {$ForbidenWordInDE==""} { set ForbidenWordInDE "hypotheticalxxxxxxxxxxxxxxxxxxxx" }
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }

    set FichierBlastP "$RepertoireDuGenome/$RepDuBlast/$Nom"
    if { ! [file exists $FichierBlastP]} { return "No blastp" }
    DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
    foreach BanqueId $lBanqueId Access $lAccess DE $lDE PN $lPN {
	if {$PN>$SeuilExpect} { continue }
	if {[regexp -nocase {^UniRef[0-9]+_(.+)} $BanqueId Match A]} {
	    set Access $A
	}
	if {[regexp {\:} $BanqueId]} {
	    set N [StringApres ":" dans $BanqueId]
	    if {[EstUnPAB $N]} {continue}
	}
	if {$DE=="" || [regexp -nocase $ForbidenWordInDE $DE]} { continue }
	if {[EstUnAccessPDB $BanqueId]} {
	    set aPDB $BanqueId
	    set OS [OrganismeDuPDB $aPDB]
	    set DE [TextePDB $aPDB "KEYWDS"]
	} else {
	    if {[regexp -nocase {^UniRef[0-9]+_(.+)*} $Access Match Acc]} {
		set Access $Acc
	    } 
#	    set OS [QuestionDeScience QuidSeq "QuidOSOfAC $Access"]
	    set OS ""
	    set DE ""
#rR j'ai interverti les  DecortiqueLesLignesEMBL avec LesChampsInteressantsDuAccess
	    if {1 || $OS==""} {
		set LEmbl [LaSequenceDesBanques $BanqueId $Access AOk "OnVeutEmbl"]
		if {$LEmbl=={}} { continue }
		DecortiqueLesLignesEMBL $LEmbl IDlu AClu DElu GNlu OSlu OClu OXlu
		set OS $OSlu
		set DE $DElu
		regsub -all {[ \n\t]+} $DE " " DE
		set DE [string trim $DE]
	    }
	    if {$DE==""} {
		ScanLaListe [LesChampsInteressantsDuAccess $Access $Access "OS" "DE" ] OS DE
	    }
	    regsub -all {[ \n\t]+} $DE " " DE
	    set DE [string trim $DE]
	    set OS [string trim $OS]
	}
	if {$DE=="" || $OS==""} { continue }
	if {$OS==$NotreOS} { continue }
	return "$DE (from $OS $Access expect=$PN)" 
	return $DE
    }
    return ""

}

proc BestDefinitionOfBlastPPourTous {} {

    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfBlastP $Nom]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_BlastP: $DE"
    }

}

proc BestDefinitionOfBlastX {Nom {SeuilExpect ""} {ForbidenWordInDE ""} {RepDuBlast ""}} {

    if {$RepDuBlast==""} { set RepDuBlast "blastx" }
    return [BestDefinitionOfBlastP $Nom $SeuilExpect $ForbidenWordInDE $RepDuBlast]

}

proc BestDefinitionOfBlastXPourTous {} {

    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfBlastX $Nom]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_BlastX: $DE"
    }

}

proc BestDefinitionOfDbClustal {Nom} {

    global NotreOS
    global NotreOrga
    foreach {Orga Dist Access} [LesOrgaDistAccessDesOrthologues $Nom] {
	if {$Orga==$NotreOrga} { continue }
	if {[EstUnAccessPDB $Access]} {
	    set OS [OrganismeDuPDB $Access]
	    set DE [TextePDB $Access "KEYWDS"]
	} else {
	    set OS [OrgaDuAccess $Access]
	    set DE [DefinitionDuAccess $Access]
	}
	if {$DE=="" || [regexp -nocase "hypothetical" $DE]} { continue }
	return "$DE (from $OS $Access dist=$Dist)" 
    }
    return ""

}

proc BestDefinitionOfDbClustalPourTous {} {

    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfDbClustal $Nom]
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_DbClustal: $DE"
    }

}

proc BestDefinitionOfLeon {Nom} {

    set NotreOS    [NotreOS]
    set NotreOrga  [NotreOrga]
    set NotreTaxId [NotreTaxId]

    set FichierLeon "[RepertoireDuGenome]/leonLeo/$Nom"
    if { ! [file exists $FichierLeon]} {
	set FichierLeon "[RepertoireDuGenome]/leonLeo/$Nom.msf"
    }
    if { ! [file exists $FichierLeon]} { return "" }
    set n [DecortiqueUnMSF $FichierLeon LesNomsDeSequences]
    foreach NomSeq $LesNomsDeSequences] {
	set Dae [DaedalusHit $NomSeq $Nom]
	if {$Dae!=""} {
	    set TaxId [ChampDaedalus TaxId $NomSeq $Nom] 
	    if {$TaxId==$NotreTaxId} { continue }
	}
	set Orga
	if {$Orga==$NotreOrga} { continue }
	if {[EstUnAccessPDB $Access]} {
	    set OS [OrganismeDuPDB $Access]
	    set DE [TextePDB $Access "KEYWDS"]
	} else {
	    set OS [OrgaDuAccess $Access]
	    set DE [DefinitionDuAccess $Access]
	}
	if {$DE=="" || [regexp -nocase "hypothetical" $DE]} { continue }
	return "$DE (from $OS $Access dist=$Dist)" 
    }
    return ""

}

proc BestDefinitionOfLeonPourTous {} {

    foreach Nom [ListeDesPABs] {
	set DE [BestDefinitionOfLeon $Nom]
	if {$DE==""} { continue }
	Espionne "$Nom $DE"
	InformeSansDemander $Nom "DE_Leon: $DE"
    }

}

proc BestGCAnalysis {{Sequence ""}} {

    
    Wup "Permet de lancer les analyses pour determiner le meilleur GC pour un groupe de sequence"

    if {$Sequence==""} {
	set LesQuerys [LesParametresDuDesign Query "LaValeurMerci"]
    } else {
	set LesQuerys $Sequence
    }
    if {$LesQuerys==""} {return ""}

    foreach Q $LesQuerys {
	ChargeGCCount $Q
    }

    CalculLaMoyenneGCCount
    IllustreGCCount 
    DechargeGCCount
    return ""

}

proc BestGN {Nom} {

    if {[set ValiGN  [ExtraitInfo $Nom "ValiGN:"]] !=""} { return $ValiGN } 
    if {[set GN      [ExtraitInfo $Nom "GN:"]]     !=""} { return $GN } 
    if {[set DraftGN [ExtraitInfo $Nom "DraftGN:"]]!=""} { return $DraftGN }
    return ""

}

proc BestGeneId {Nom} {

    set G [NIAG $Nom G]
    if {$G!=""} { return $G }

}

proc BestHitReciproc {Nom {BlastDir ""} {CutPN ""} {HitOnly ""}} {

    if { ! [regexp "/" $BlastDir]} { set BlastDir [RepertoireDuGenome]/$BlastDir }
    if {$CutPN==""} { set CutPN 1.0e-3 }
    set FiBlast "$BlastDir/$Nom"
    if {[FileAbsent $FiBlast]} { return "NoBlastFile" }
    set N [DecortiqueBlast $FiBlast $CutPN 1 aQuery lBanqueId lAccess lDE]
    if {$N==0} { return "NoHitFound" }
    set BanqueId [lindex $lBanqueId 0]
    if {$HitOnly=="HitOnly"} { return $BanqueId }
    set Access   [lindex $lAccess   0]
    set AccessOk ""
    set LeHit [LaSequenceDesBanques $BanqueId $Access AccessOk]
    if {$LeHit=={}} { return "NoSequenceFor$AccessOk" }
    set Hit [join $LeHit "\n"]
    set Hit [SequenceFormatTFA $Hit]
    set Racine [file tail [RepertoireDuGenome]]
    set SortieBlast [Blast "blastp" $Hit "retourne" "[RepertoireDuGenome]/banques/$Racine"]
    if {$SortieBlast==""} { return "NoBlastResultFor$AccessOk" }
    Sauve $SortieBlast dans "${BlastDir}Reciproc/$AccessOk"
    set MaxValable 1
    set N [DecortiqueBlast $SortieBlast $CutPN $MaxValable aQuery lBanqueId lAccess lDE]
    foreach BanqueId $lBanqueId {
	if {$BanqueId==$Nom} {
	    return $AccessOk
	}
    }
    return "NoReciprocalHitFor$AccessOk"

}

proc BestHitReciprocPourTous {{BlastDir ""} {CutPN ""} {HitOnly ""}} {

    set Bla [file tail $BlastDir]
    foreach Nom [ListeDesPABs] {
	set Reciproc [BestHitReciproc $Nom $BlastDir $CutPN $HitOnly]
	Espionne "$Nom Reciproc1_$Bla: $Reciproc"
	InformeSansDemander $Nom "Reciproc1_$Bla: $Reciproc"
    }

}

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 BestInformePourBathy {} {

    foreach Nom [ListeDesPABs] {
	set Info [ExtraitInfo $Nom]
	set OSBlastX [ExtraitInfo $Nom "OS_BlastX:"]
	if {[regexp -nocase {([A-Z]+) ([a-z]+) ([a-z0-9]+)} $OSBlastX Match Genre Espece Access]} {
	    set LEmbl [LaSequenceDesBanques $Access]
	    DecortiqueLesLignesEMBL $LEmbl ID AC DE GN OS OC OX SequenceBrute LaDETotal
	    InformeSansDemander $Nom "BestAccess: $Access"
	    InformeSansDemander $Nom "BestID: $ID"
	    InformeSansDemander $Nom "BestAC: $AC"
	    InformeSansDemander $Nom "BestDE: $DE"
	    InformeSansDemander $Nom "BestGN: $GN"
	    InformeSansDemander $Nom "BestOS: $OS"
	    InformeSansDemander $Nom "BestOC: $OC"
	    InformeSansDemander $Nom "BestOX: $OX"
	}
    }

}

proc BestLocalisation {Nom {IdMin 0.8}} {

    set TailleFragment 100000 

    set FLocmRNAHsap "[RepertoireDuGenome]/Localisation/mRNAHsapLocalisation_Human"
    if {[file exists $FLocmRNAHsap]} {set LocmRNAHsapExiste 1} else {set LocmRNAHsapExiste 0}
    set FLocProttfa  "[RepertoireDuGenome]/Localisation/ProttfaLocalisation_Human"
    if {[file exists $FLocProttfa ]} {set LocProttfaExiste  1} else {set LocProttfaExiste  0}
    set FLocBox      "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human"
    if {[file exists $FLocBox     ]} {set LocBoxExiste      1} else {set LocBoxExiste      0}

    set LeTexte {}
    set EstCeQueLaProteineEstOK  1
    set EstCeQueLemRNAHumanEstOK 1
	
    if {    [file exists "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis"] ||  [file exists "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis"]} { 
	#Validite de la proteine de ref (sequence presente et bon %Id avec seq initiale) 
	if {    ([InterrogeProtAndmRNAChoisis $Nom SeqChoisie  ] != "SeqOK" || [InterrogeProtAndmRNAChoisis   $Nom InfoSeqChoisie] != "") &&  ([InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK" || [InterrogeProtAndContigChoisis $Nom InfoSeqChoisie] != "") } {
	    set EstCeQueLaProteineEstOK 0
	}
    }
    if {    [file exists "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga"] } {
	#Validite du mrna humain (sequence presente et bon %Id avec proteine de ref)
	set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access]
	if {$AccessmRNA == "" || [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] < $IdMin} {
	    set EstCeQueLemRNAHumanEstOK 0
	}
    }

    set LesLoc     [InterrogeLocalisation $FLocBox      Nom $Nom]
    set LesLocProt [InterrogeLocalisation $FLocProttfa  Nom $Nom]
    set LesLocmRNA [InterrogeLocalisation $FLocmRNAHsap Nom $Nom]

    #si la proteine est bonne et le mrna humain est bon on utilise la localisation du mrna humain
    #si seulement la proteine est bonne on utilise la localisation de  la proteine de ref
    #si ni la proteine de ref ni le mrna humain ne sont valides, on utilise la localisation de la sequence par defaut
    if {$EstCeQueLemRNAHumanEstOK && $LocmRNAHsapExiste && $LesLocmRNA != {}} {
	set LesLoc $LesLocmRNA
    } elseif {$EstCeQueLaProteineEstOK && $LocProttfaExiste && $LesLocProt != {}} {
	set LesLoc $LesLocProt
    }
    foreach LaLoc  $LesLoc {
	if {0} {
	    set Chrom  [NumeroDuChromosome [lindex $LaLoc 9]]
	    set DChrom [lindex $LaLoc 10]
	    set FChrom [lindex $LaLoc 11]
	    
	    set BC     [join [LesBandesCytologiquesDeLaRegion $Chrom $DChrom $FChrom] " "]
	    set LaLoc  [lreplace $LaLoc 19 19 $BC]
	}
	set Ligne [join $LaLoc "\t"]
	lappend LeTexte $Ligne
    }
    return $LeTexte

}

proc BestTmAnalysis {{Sequence ""}} {

    
    Wup "Permet de lancer les analyses pour determiner le meilleur Tm pour un groupe de sequence"

    if {$Sequence==""} {
	set LesQuerys [LesParametresDuDesign Query "LaValeurMerci"]
    } else {
	set LesQuerys $Sequence
    }
    if {$LesQuerys==""} {return ""}

    foreach Q $LesQuerys {
	ChargeTmCount $Q
    }

    CalculLaMoyenneTmCount

    IllustreTmCount
    DechargeTmCount
    return ""

}

proc BetterStartCodon {} {

    foreach Nom [ListeDesPABs] {
	set Rapport [StartCodonReport $Nom "Rapport"]
	if { ! [regexp "Wrong_Start_Codon" $Rapport]} { continue }
	scan $Rapport "%s %s" W AsPos
	regsub -all {[^0-9]} $AsPos "" Pos
	if {$Pos<2} { continue }

	set PosN [expr ($Pos-1)*3]

	set OldDebut [Box $Nom debut]
	set OldFin   [Box $Nom fin]
	set Orient   [Box $Nom orient]
	if {$Orient=="F"} {
	    Box $Nom debut [expr $OldDebut + $PosN]
	} else {
	    Box $Nom fin   [expr $OldFin   - $PosN]
	}
	set OldSD [ShineDalgarno $Nom]
	set SD [CreeLesFichiersDesShineDalgarnoDesPABs "" $Nom "RendreEtat"]
	set nBases 0
	set OldnBases 0
	set Over [Overlap $Nom]
	foreach Over [split $Over "/"] {
	    if { ! [regexp "I begin in" $Over]} { continue }
	    scan $Over "%s %d" Bidon OldnBases
	    set nBases [expr $OldnBases - $PosN]
	    break
	}
	Espionne [format "%s %4s Overlap de %3d a %3d   SD: %7s %s" $Nom $AsPos $OldnBases $nBases $SD $OldSD]
    }
    exit

}

proc BetterTaxId {TaxId} {

    global BetterTaxId
    if {[info exists BetterTaxId($TaxId)]} { return [set BetterTaxId($TaxId)] }
    if {[info exists BetterTaxId("EstCharge")]} { return $TaxId }

    foreach Ligne [LesLignesDuFichier "/genomics/link/Common/fiches/TaxNCBI/merged.dmp"] {
	scan $Ligne "%s %s %s" Old Bidon New
	set BetterTaxId($Old) $New
    }
    foreach Ligne [LesLignesDuFichier "/genomics/link/Common/fiches/TaxNCBI/better_de_rr.dmp"] {
	scan $Ligne "%s %s" Old New
	set BetterTaxId($Old) $New
    }
    set BetterTaxId("EstCharge") 1
    return [BetterTaxId $TaxId]

}

proc Between0And2Pi {Angle} {

    set Pi [Pi]
    while {$Angle < 0} { set Angle [expr $Angle + 2*$Pi] }
    while {$Angle >= 2*$Pi} { set Angle [expr $Angle - 2*$Pi] }
    return $Angle

}

proc BiCoordOnly {} {


	# Sert à virer la fin des lignes pour ne garder que les coordonnées
	set FichierDesBiDir [open "[Fiches]/Bidir/1000/SBSDansLes847promoteurs.txt" "r"]
	set FichierDesCoord [open "[Fiches]/Bidir/1000/SBSDansLes847promoteurs.coord" "w"]
	while { [gets $FichierDesBiDir Ligne]  >=0 } {
		ScanLaListe $Ligne Intergene Chromosome Start End Reste
		puts $FichierDesCoord "$Intergene $Chromosome $Start $End +"
	}

}

proc BiDansBi {Path} {

	
	# Verifie si, dans la liste des Bidi, il n'y a pas un gene qui s'est intercalé

	Espionne "BiDansBi : Debut"
	Espionne "BiDansBi : Constitution des requetes"
	set FichierDesBidir [open "$Path.coord" "r"]
	set FichierDesRequetes [open "/tmp/BiDansBi.bql" "w"]
	while { [gets $FichierDesBidir Ligne]  >=0 } {
	ScanLaListe $Ligne Chromosome StartIntergene EndIntergene
	puts $FichierDesRequetes "ID * DB UCSC"
	puts $FichierDesRequetes "WH SQLNATIVE SELECT access, name, typegene, chrom, txStart, txEnd, strand FROM ucschuman.GeCo WHERE txStart>$StartIntergene AND txEnd<$EndIntergene AND chrom='$Chromosome' AND pseudogene='no' "
	puts $FichierDesRequetes "LM 1"
	puts $FichierDesRequetes "#"	
	}
	close $FichierDesBidir
	close $FichierDesRequetes
	Espionne "BiDansBi : Execution des requetes"
	exec /biolo/bird/bin/birdql_client.sh /tmp/BiDansBi.bql bird /tmp/BiDansBi.res
	set FichierDesRequetesExecutees [open "/tmp/BiDansBi.res" "r"]
	set FichierDesErreurs [open "$Path.err" "w"]
	set NumeroIntergene 0
	Espionne "BiDansBi : Ecriture"
	while { [gets $FichierDesRequetesExecutees LigneExecutee]  >=0 } {
		incr NumeroIntergene
		gets $FichierDesRequetesExecutees LigneExecutee
		if { $LigneExecutee == "EMPTY" } {
			continue
		} else {
			puts $FichierDesErreurs "$NumeroIntergene $LigneExecutee"
		}
	}
	Espionne "BiDansBi : Fin"
	close $FichierDesRequetesExecutees

}

proc BidAccessDeLOrganisme {Orga Nom} {

    global RepertoireDuGenome

    regsub "_" $Orga " " Orga

    set APNsOnly 1

    set SeuilExpect 0.001
    set MaxListe     250

    if {[info exists BidAccessDeLOrganisme(Courant)] && [set BidAccessDeLOrganisme(Courant)]!=$Nom} {
	unset BidAccessDeLOrganisme
	set BidAccessDeLOrganisme(Courant) $Nom
    }
    if {[info exists BidAccessDeLOrganisme($Nom,$Orga)]} { return [set BidAccessDeLOrganisme($Nom,$Orga)] }
    if {[info exists BidAccessDeLOrganisme($Nom,"EstCharge")]} { return "" }

    set FichierAPNs "[RepertoireDuGenome]/apns/$Nom"
    if {[file exists $FichierAPNs]} {
	set nLu 0
	foreach Ligne [LesLignesDuFichier $FichierAPNs] {
	    incr nLu
	    scan $Ligne "%s %s %s" BanqueId Access Expect
	    if {[EstUnAccessPDB $BanqueId]} { continue }
	    if {$Expect > $SeuilExpect} { break }
	    if {$nLu    > $MaxListe   } { break }
	    set GEs ""
	    regsub " *$BanqueId +$Access +$Expect *" $Ligne "" GEs
	    if { ! [regexp -nocase {[a-z]} $GEs]} { continue }
	    set LesGEs [split $GEs ":"]
	    foreach GE $LesGEs {
		if {[info exists DejaVu($GE)]} { continue }
		set DejaVu($GE) 1
		set BidAccessDeLOrganisme($Nom,$GE) "$BanqueId $Access $Expect"
	    }
	}
    }

    if {[info exists BidAccessDeLOrganisme($Nom,$Orga)]} { return [set BidAccessDeLOrganisme($Nom,$Orga)] }

    if {$APNsOnly} { return "" }

    set OBP [OrthoBlastP $Nom $Orga]
    if {$OBP != "OrthoBlastPNonValide"} {
	if { ! $OBP } { return "" }
	set LesOs [OrthoBlastP $Nom]
	regsub " " $Orga "_" GenreEspece
	set i [lsearch $LesOs $GenreEspece]
	
	set Fichier "$RepertoireDuGenome/blastp/$Nom"
	if { ! [file exists $Fichier]} { return "" }
	DecortiqueBlast $Fichier 0.001 "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
	Espionne "Recherche de $Orga en $i ratee"
	set LesBids [Zippe [lrange $lBanqueId $i end] [RetourneLaListe [lrange $lBanqueId 0 [expr $i-1]]]]
	set LesAccs [Zippe [lrange $lAccess   $i end] [RetourneLaListe [lrange $lAccess   0 [expr $i-1]]]]
	foreach Bid $LesBids Access $LesAccs {
	    foreach Organisme [split [OrgaDuAccess $Access Complet $Bid] ":"] {
		if {[Glossaire $Organisme Complet]==$Orga} { return "$Bid $Access" }
	    }
	}
	return ""
    }
    return ""

}

proc Bidon {} {


    global Sequences
    global LNOrdali

    foreach mol {"11as" "12as"} {
	ExtraitSeqEtStrDuPdb "$mol.pdb" "" "${mol}_A"
	global PDB_[set mol]_Sequence
	puts "$mol A : [set PDB_[set mol]_Sequence(A)]"
	set Sequences(${mol}_A) [set PDB_[set mol]_Sequence(A)]
	lappend LNOrdali "${mol}_A"
	ExtraitSeqEtStrDuPdb "$mol.pdb" "" "${mol}_B"
	puts "$mol B : [set PDB_[set mol]_Sequence(B)]"
	set Sequences(${mol}_B) [set PDB_[set mol]_Sequence(B)]
	lappend LNOrdali "${mol}_B"
    }

    CreeLeTfa "toto.tfa"

    exit

}

proc Bidon_LoadImage {imgName} {

    set retVal [catch {set phImg [image create photo -file $imgName]} err1]
    if { $retVal != 0 } {
        error "Error reading image $texName ($err1)"
    } else {
        set w [image width  $phImg]
        set h [image height $phImg]
	set z [tcl3dPhotoChans $phImg]
        set texImg [tcl3dVectorFromPhoto $phImg]
        image delete $phImg
    }
    if {$z == 3} {
	set type $::GL_RGB
    } else {
	set type $::GL_RGBA
    }

    return [list $texImg $w $h $type]

}

proc BigBlast {expectLimit} {

	puts ">>>> creation de la banque pour le blast"
	CreeUneBanqueBlast "./proteomeToBlast.fasta" "BIGBANK"
	puts ">>>> lancement du BIGBLAST"
	exec gscope "yes" "BlastPPourTousOptionFiltre2" "" "BIGBANK" "" "$expectLimit" "F"

}

proc BiggestHeader {Fichier} {

    set Max 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase "^>" $Ligne]} { continue }
	set L [string length $Ligne]
	if {$L>$Max} {
	    set Max $L
	    set Biggest $Ligne
	}
    }
    return "$Max $Biggest"

}

proc BiggestHeaderPourTous {{Rep ""}} {

    if {$Rep==""} { set Rep "." }

    foreach Fasta [lsort [glob -nocomplain "$Rep/*"]] {
	set R [BiggestHeader $Fasta]
	scan $R "%d" M
	if {$M>600} { Espionne "$Fasta\n$R" }
    }

}

proc BilanATTGGSurLesClustersSansLesProteinesJumelles_PO {RepPromAn} {

    set FichierBilanATTGGSurLesClusters "$RepPromAn/BilanATTGG"
    set FichierProtJum                  "[RepertoireDuGenome]/fiches/ProteinesJumelles_old" 
    set FichierOCADE                    "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"
    set LesInfos                        {}
    
    InterrogeDefinitionsConsensus              unset
    InterrogeProteinesJumelles                 unset    
    InterrogeOrf2Cluster2Access2Def2Expression unset

    foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] {
	Espionne "Cluster -> $Cluster"
	# Traitement des proteines jumelles, ne garde que les proteines uniques pour chaque cluster
	set LesNoms {}
	foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] {
	    if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue}
	    set     TabDeJaVu($Cluster,$Nom) 1
	    foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {
		set TabDeJaVu($Cluster,$Jum) 1
	    }
	    lappend LesNoms $Nom
	}
	set LesNoms [lsort -unique $LesNoms]
	# Bilan ATTGG a partir du fichier PromAn
	foreach Nom $LesNoms {
	    set FilePromAn "$RepPromAn/$Nom.PromAn"
	    if {![file exists $FilePromAn]} {Espionne "$FilePromAn does not exists" ; continue }
	    set n          [PromAnPanel ask $FilePromAn ResultType PatternResearch Method ATTGG n]
	    if {$n == ""} { continue }
	    set MeanDef    [InterrogeDefinitionsConsensus $Nom Definition]
	    set LesTSSDist {}
	    for {set nATTGG 1} {$nATTGG <= $n} {incr nATTGG} {
		set     TSSDist    [PromAnPanel ask $FilePromAn ResultType "PatternResearch" Method "ATTGG" n $nATTGG TSSDist]
		lappend LesTSSDist $TSSDist
	    }
	    lappend LesInfos   "$Cluster\t$Nom\t$n\t$LesTSSDist\t$MeanDef"
	    PromAnPanel unset
	}
    }
    
    Sauve [join $LesInfos "\n"] dans $FichierBilanATTGGSurLesClusters
    
    PromAnPanel                                unset
    InterrogeDefinitionsConsensus              unset
    InterrogeProteinesJumelles                 unset    
    InterrogeOrf2Cluster2Access2Def2Expression unset
    return

}

proc BilanAnnotationAffymetrix_Morphine {Fichier} {


    Wup "Morphine Bilan pour creer le fichier des annotations"
    Wup "Fait avec Aurelie pour Katia et Jerome"

    set LesLignes ""
    lappend LesLignes "Gscope\tProbeset\tNone-None\tProttfa\tContig"
    foreach PAB [ListeDesPABs] {
	set Texte ""
	lappend Texte "$PAB"

	set Affy [AffymetrixAccess $PAB]
	lappend Texte $Affy

	set UnigeneAcc [InterrogeLesAccRSEtUG_Affymetrix $PAB AccUnigene]
	set RefSeqAcc  [InterrogeLesAccRSEtUG_Affymetrix $PAB AccRefSeq]
	if {$UnigeneAcc=="None" && $RefSeqAcc=="None"} {
	    lappend Texte "1"
	} else {
	    lappend Texte "0"
	}  

	if {! [file exists "[RepertoireDuGenome]/prottfa/$PAB"]} {
	    lappend Texte "0"
	} else {
	    lappend Texte "1"
	} 
	if {! [file exists "[RepertoireDuGenome]/contig/$PAB"]} {
	    lappend Texte "0"
	} else {
	    lappend Texte "1"
	} 
	
	set Texte [join $Texte "\t"]
	lappend LesLignes $Texte
    }
    AppendAuFichier $Fichier [join $LesLignes "\n"]

    return ""

}

proc BilanCilio {{Qui ""} {Quoi ""}} {

    global BilanCilio

    if {[OnTraite CilioCarta2014]} { return [BilanCilio2014 $Qui $Quoi] }

    #rR on lit le fichier Excel de Odile
    #rR gscope puts BilanCilio ListOf Usage

    if {[info exists BilanCilio($Qui,$Quoi)]} { return $BilanCilio($Qui,$Quoi) }
    if {[info exists BilanCilio("EstCharge")]} {
	regsub -all "_" $Qui   " " Qi
	regsub -all "_" $Quoi  " " Qo
	if {[info exists BilanCilio($Qui,$Qo)] } { return $BilanCilio($Qui,$Qo) }
	if {[info exists BilanCilio($Qi,$Quoi)]} { return $BilanCilio($Qi,$Quoi) }
	if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Quoi)]} { return $BilanCilio($BilanCilio($Qui,Column),$Quoi) }
	if {[info exists BilanCilio($Qi,Column)]  && [info exists BilanCilio($BilanCilio($Qi,Column),$Quoi)]}  { return $BilanCilio($BilanCilio($Qi,Column),$Quoi) }
	if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Qo)]}   { return $BilanCilio($BilanCilio($Qui,Column),$Qo) }
	if {[info exists BilanCilio($Qi,Column)]  && [info exists BilanCilio($BilanCilio($Qi,Column),$Qo)]}    { return $BilanCilio($BilanCilio($Qi,Column),$Qo) }
	if {$Qui=="Example"} {
	    set LesExemples {}
	    foreach Us $BilanCilio(ListOf,Usage) {
		if { ! [regexp "^Bilan" $Us]} { continue }
		lappend LesExemples "\n$Us"
		set Res [eval $Us]
		if {[string length $Res]>100} { set Res "[string range $Res 0 132] ..." }
		lappend LesExemples $Res
	    }
	    lappend LesExemples "\nYou can run all these commands with :"
	    lappend LesExemples "gscope puts BilanCilio N_Fungi TaxId"
	    return [join $LesExemples "\n"]
	}		
	return ""
    }
    set BilanCilio("EstCharge") 1

    #rR ************************************************** attention il faut le fichier sinon return 0 si on demande exists vide autrement
#    set Fichier "[RepertoireDuGenome]/bilan/bilanOK.csv"
    set Fichier "/genomics/link/CilioCarta/bilan/bilanOK.csv"
    if {[FileAbsent $Fichier]} {
	unset BilanCilio
	if {$Qui=="exists"} { return 0 }
	return ""
    }
    set BilanCilio(exists,) 1

    set ListOfUsage [list  "gscope puts BilanCilio Usage"  "gscope puts BilanCilio Example"  "BilanCilio ListOf GscopeId"  "BilanCilio ListOf UniprotId"  "BilanCilio ListOf TaxId"  "BilanCilio ListOf Class"  "BilanCilio ListOf Clade"  ""  "BilanCilio 10090  Species"  "BilanCilio 10090  Class"    "BilanCilio 10090  Clade"    "BilanCilio 10090  State"    "BilanCilio 10090  TaxId"    ""  "BilanCilio (556484_12968) Column"  "BilanCilio (556484_12968) Clade"   ""  "BilanCilio Y_Fungi  TaxId"  "BilanCilio Y_Fungi  CladeContentTaxIds"  "BilanCilio Y_Fungi  CladeContentSpecies"  "BilanCilio Y_Fungi  CladeContentColumns"  "BilanCilio N_Fungi  Permil"  "BilanCilio PR_Fungi Count"  ""  ]

    set BilanCilio(ListOf,Usage) $ListOfUsage
    set BilanCilio(Usage,) [join $ListOfUsage "\n"] 

    set BilanCilio(Filename,) $Fichier 

    set Texte [ContenuDuFichier $Fichier]
    regsub -all "\n\"" $Texte "\"" Texte
    
    set CladeContentTaxIds  {}
    set CladeContentSpecies {}
    set CladeContentColumns {}

    set Prems 1
    set Deuss 0
    set Trois 0
    set Quats 0
    set N 0
    foreach Ligne [split $Texte "\n"] {
	if {0 && [incr N]==1000} { break }
	if {$Prems} {
	    set Prems 0
	    set Deuss 1
	    set LesTaxIdLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set CladeContentTaxIds {}
	    set LesTaxId {}
	    foreach TaxId $LesTaxIdLus {
		if {$TaxId==""} {
		    if {$CladeContentTaxIds=={}} { break }
		    set TaxId "([join $CladeContentTaxIds { }])"
		    lappend BilanCilio(ListOf,CladeTaxIds) $TaxId
		    set BilanCilio($Column,CladeContentTaxIds)   $CladeContentTaxIds
		    set BilanCilio($Column,CladeContentColumns)  $CladeContentColumns
		    set CladeContentColumns {}
		    set CladeContentTaxIds {}
		} else {
		    lappend CladeContentColumns $Column
		    lappend CladeContentTaxIds  $TaxId
		    lappend BilanCilio(ListOf,TaxId) $TaxId
		}
		set BilanCilio($TaxId,Column) $Column
		set BilanCilio($Column,TaxId) $TaxId
		incr Column
	    }
	    continue
	}
	if {$Deuss} {
	    set Trois 1
	    set Deuss 0
	    set LesEspecesLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set LesEspeces {}
	    foreach Espece $LesEspecesLus {
		regsub { \(.+\) *$} $Espece "" Espece
		if {$Espece==""} { break }
		set TaxId $BilanCilio($Column,TaxId)
		if {[regexp {^[0-9]+$} $Espece]} {
		    set TailleClade $Espece
		    set BilanCilio($Column,CladeContentSize)    $TailleClade
		    set BilanCilio($Column,IsClade)             1
		    set BilanCilio($Column,CladeContentSpecies) $CladeContentSpecies
		    lappend BilanCilio(ListOf,CladeColumn)      $Column
		    set CladeContentSpecies {}
		} else {
		    lappend CladeContentSpecies              $Espece
		    lappend BilanCilio(ListOf,Species)       $Espece
		    lappend BilanCilio(ListOf,SpeciesColumn) $Column
		    set BilanCilio($Column,TaxId)            $TaxId
		    set BilanCilio($Column,Species)          $Espece
		    set BilanCilio($Espece,TaxId)            $TaxId
		    set BilanCilio($TaxId,OS)                $Espece
		    regsub -all " " $BilanCilio($TaxId,OS) "_" BilanCilio($TaxId,OS_) 
		}
		incr Column
	    }
	    continue
	}
	if {$Trois} {
	    set Trois 0
	    set Quats 1
	    #rR attention il y a des ; protégés par de "" on les remplace par 1 2 3 etc.
	    set iC 0
	    while {[regexp {;\"([^\"]+)\";} $Ligne Match Class]} {
		set ClassMemo($iC) $Class 
		regsub  {;\"([^\"])+\";} $Ligne ";$iC;" Ligne
		incr iC
	    }
	    set LesClassLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set LesEspeces {}
	    foreach Class $LesClassLus {
		if {[info exists ClassMemo($Class)]} { set Class $ClassMemo($Class) }
		if {$Class==""} { break }
		set TaxId $BilanCilio($Column,TaxId)
		if {[info exists BilanCilio($Column,IsClade)]} {
		    #rR ici on a le clade seul et non pas la classe de l'espèce.
		    set CladeSeul $Class
		    set BilanCilio($Column,CladeSeul) $CladeSeul
		    #rR il faut attendre la ligne 4 pour avoir les Y PR N
		} else {
		    set BilanCilio($Column,DoCount) 1
		    set BilanCilio($Column,TaxId) $TaxId
		    set BilanCilio($Column,Class) $Class
		}
		lappend BilanCilio(ListOf,Class) $Class  ; #rR attention les clades font partie de la liste des classes
		incr Column
	    }
	    continue
	}
	if {$Quats} {
	    set Quats 0
	    set LesHeadersLus [split $Ligne ";"]
	    set Column 0
	    set LesHeaders {}
	    foreach Header $LesHeadersLus {
		if {$Column==0} { set Header "Comment" }
		regsub {\([^\(]+\)} $Header "" Header
		if {$Header==""} { break }
		set Header [string trim $Header]
		set Header [BonneEntetePourBilanCilio $Header]
		if {[regexp {^(Y|PR|N)$} $Header]} {
		    set Etat $Header
		    set TaxId $BilanCilio($Column,TaxId)
		    if {[info exists BilanCilio($Column,CladeSeul)]} {
			set CladeSeul $BilanCilio($Column,CladeSeul)
			set EtatClade      "${Etat}_$CladeSeul"
			set BilanCilio($Column,Clade)     $EtatClade
			set BilanCilio($EtatClade,Column) $Column
			set BilanCilio($TaxId,Clade)      $EtatClade
			lappend BilanCilio(ListOf,Clade)  $EtatClade
			set Header $EtatClade
		    } else {
			set Species $BilanCilio($Column,Species)
			set SpeciesEtat "${Species} $Etat"
			set BilanCilio($SpeciesEtat,Column) $Column
			set BilanCilio($SpeciesEtat,TaxId)  $TaxId
			set BilanCilio($SpeciesEtat,Class)  $BilanCilio($Column,Class)
			#set Header $SpeciesEtat
			set Header $Species
		    }
		    set BilanCilio($Column,State) $Etat
		}
		set HeaderUnderscore $Header
		regsub -all " "      $HeaderUnderscore "_" HeaderUnderscore
		regsub -all {[\(\)]} $HeaderUnderscore ""  HeaderUnderscore
		set BilanCilio($Column,Header) $HeaderUnderscore
		set BilanCilio($Header,Column) $Column
		set BilanCilio($HeaderUnderscore,Column) $Column
		lappend BilanCilio(ListOf,Header) $HeaderUnderscore
		incr Column
	    }
	    continue
	}
	#rR maintenant il faut lire les données et les affecter en fonction de la column
	set LesMots [split $Ligne ";"]
	lassign $LesMots Comment InGoldStandard GscopeId UniprotId InOrthoinspector 
	set G $GscopeId
	lappend BilanCilio(ListOf,GscopeId) $GscopeId
	foreach K {Comment InGoldStandard GscopeId UniprotId InOrthoinspector} { 
	    set BilanCilio($G,$K) [set $K] 
	}
	set L [llength $BilanCilio(ListOf,Header)]; incr L -1
	foreach H $BilanCilio(ListOf,Header) Value [lrange $LesMots 0 $L] {
	    set BilanCilio($G,$H) $Value
	}
    }
    set BilanCilio(ListOf,JoinedClade) {}
    foreach Clade $BilanCilio(ListOf,Clade) {
	regsub {^[YNPR]+_} $Clade "" JoinedClade
	lappend BilanCilio(ListOf,JoinedClade) $JoinedClade
	if { ! [info exists BilanCilio($JoinedClade,CladeContentTaxIds)]} {
	    set BilanCilio($JoinedClade,CladeContentTaxIds) {}
	    set BilanCilio($JoinedClade,CladeContentSpecies) {}
	} 
#	LConcat BilanCilio($JoinedClade,CladeContentTaxIds)  $BilanCilio($Clade,CladeContentTaxIds)
#	LConcat BilanCilio($JoinedClade,CladeContentSpecies) $BilanCilio($Clade,CladeContentSpecies)
    }
    set BilanCilio(ListOf,JoinedClade) [lsort -unique $BilanCilio(ListOf,JoinedClade)]

    foreach CladeColumn $BilanCilio(ListOf,CladeColumn) {
	foreach Column $BilanCilio($CladeColumn,CladeContentColumns) {
	    set BilanCilio($Column,CladeColumn) $CladeColumn
	    set BilanCilio($Column,Clade) $BilanCilio($CladeColumn,Clade)
	}
    }

    set NG 0
    foreach G $BilanCilio(ListOf,GscopeId) {
	incr NG
	set U $BilanCilio($G,UniprotId)
	lappend BilanCilio(ListOf,UniprotId) $U
	set Column 0
	foreach H $BilanCilio(ListOf,Header) {
	    set BilanCilio($U,$H) $BilanCilio($G,$H)
	    if {[info exists BilanCilio($Column,DoCount)] && $BilanCilio($G,$H)==1 } { incr BilanCilio($H,Count) $BilanCilio($G,$H)}
	    incr Column
	}
    }
    foreach H $BilanCilio(ListOf,Header) {
	if { ! [info exists BilanCilio($H,Count)]} { set BilanCilio($H,Count) 0 }
	set BilanCilio($H,Permil) [expr round($BilanCilio($H,Count)*1000./$NG)]
	regsub -all " " $H "_" H
	lappend BilanCilio(ListOf,Usage) "BilanCilio HSAP00001 $H"  
    }
    set BilanCilio(ListOf,UniprotId) [lsort $BilanCilio(ListOf,UniprotId)]

    if {0} {
	foreach S [array names BilanCilio "10090,*"] {
	    regsub 10090 $S 9606 H
	    Espionne "$S $H"
	    set BilanCilio($H) $BilanCilio($S)
	}
	regsub -all 0 $BilanCilio(10090,State) 1 BilanCilio(9606,State)
	set BilanCilio(9606,Species) "Homo sapiens"
	set BilanCilio(9606,TaxId)   9606
    }
    set BilanCilio(9606,Clade) $BilanCilio($BilanCilio(10090,Column),Clade)
    set BilanCilio(9606,State) "Y"
    return [BilanCilio $Qui $Quoi]

}

proc BilanCilio2014 {{Qui ""} {Quoi ""}} {

    global BilanCilio2014

    #rR on lit le fichier Excel de Odile
    #rR gscope puts BilanCilio2014 ListOf Usage

    if {[info exists BilanCilio2014($Qui,$Quoi)]} { return $BilanCilio2014($Qui,$Quoi) }
    if {[info exists BilanCilio2014("EstCharge")]} {
	if {$Qui=="ListOf" && $Quoi=="Example"} {
	    set LesExemples {}
	    foreach Us $BilanCilio2014(ListOf,Usage) {
		if { ! [regexp "^Bilan" $Us]} { continue }
		lappend LesExemples "\n$Us"
		lappend LesExemples [eval $Us]
	    }
	    lappend LesExemples "\nYou can run all these commands with :"
	    lappend LesExemples "gscope puts BilanCilio2014 Y_Mammalia TaxId"
	    return [join $LesExemples "\n"]
	}		
	return ""
    }
    set BilanCilio2014("EstCharge") 1


    set Fichier "[RepertoireDuGenome]/fiches/bilan_presence_absence_avecgroupes_tentativescriteres.csv"
    if {[FileAbsent $Fichier]} { unset BilanCilio2014; return "" }
    set BilanCilio2014(exists,) 1

    set Usage [list  "gscope puts BilanCilio2014 ListOf Usage"  "BilanCilio2014 ListOf Box"  "BilanCilio2014 ListOf Access"  "BilanCilio2014 ListOf Categories"  "BilanCilio2014 ListOf TaxId"  "BilanCilio2014 ListOf Class"  "BilanCilio2014 ListOf Clade"  ""  "BilanCilio2014 10090  Class"  "BilanCilio2014 10090  Clade"  "BilanCilio2014 10090  State"  "BilanCilio2014 10090  PA"  ""  "BilanCilio2014 Y_Mammalia TaxId"  "BilanCilio2014 Y_Mammalia State"  "BilanCilio2014 Y_Mammalia States"  "BilanCilio2014 Y_Mammalia Count"  "BilanCilio2014 Y_Mammalia PA"  ""  ]
    set BilanCilio2014(ListOf,Usage) $Usage

    set BilanCilio2014(Filename,) $Fichier 

    set Texte [ContenuDuFichier $Fichier]
    regsub -all "\n\"" $Texte "\"" Texte

    
    set Prems 1
    set Deuss 0
    set Trois 0
    set LesTaxId {}
    set LesTaxIdsDuG {}
    set LesEtatsDuG {}
    set LesEspecesDuG {}
    set LesClades {}
    foreach Ligne [split $Texte "\n"] {
	if {$Prems} {
	    set Prems 0
	    set Deuss 1
	    set LesBox [lrange [split $Ligne ";"] 4 end]
	    set BilanCilio2014(ListOf,Box) $LesBox
	    continue
	}
	if {$Deuss} { set Trois 1; set Deuss 0 ; continue }
	if {$Trois} { set Trois 0; set BilanCilio2014(ListOf,Categories) [lrange [split $Ligne ";"] 4 end]; continue }
	set Classe ""
	if {[regexp {;\"([^\"]+)\";} $Ligne Match Classe]} {
	    regsub  {;\"([^\"])+\";} $Ligne ";Classe;" Ligne
	}
	set LesMots [split $Ligne ";"]
	
	set TaxId  [string trim [lindex $LesMots 0] " -"]
	set Espece [string trim [lindex $LesMots 1] " -"]
	set Clade  [string trim [lindex $LesMots 2] " -"]
	set Etat   [string trim [lindex $LesMots 3] " -"]

	if {$TaxId=="" && $Espece=="" && $Clade=="" && $Etat==""} {
	    set LesAccess [lrange $LesMots 4 end]
	    set BilanCilio2014(ListOf,Access) $LesAccess
	    break
	}

	set Clade "${Etat}_$Clade"
	regsub -all " +" $Clade "_" Clade 

	if {[regexp {^[0-9]+$} $TaxId]} {
	    lappend LesTaxIdsDuG  $TaxId
	    lappend LesEspecesDuG $Espece
	    lappend LesEtatsDuG   $Etat
	    lappend LesClassesDuG $Classe
	    lappend BilanCilio2014(ListOf,TaxId) $TaxId
	    lappend BilanCilio2014(ListOf,Class) $Classe
	    set BilanCilio2014($TaxId,PA) [lrange $LesMots 4 end]
	    set BilanCilio2014($TaxId,State) $Etat
	    set BilanCilio2014($TaxId,Class) $Classe
	    set BilanCilio2014($Classe,TaxId) $TaxId
	} else {
	    set Compte $Espece
	    lappend BilanCilio2014(ListOf,Clade) $Clade 
	    set BilanCilio2014($Clade,Count)   $Compte
	    set BilanCilio2014($Clade,State)   $Etat
	    set BilanCilio2014($Clade,TaxId)   $LesTaxIdsDuG
	    set BilanCilio2014($Clade,Species) $LesEspecesDuG
	    set BilanCilio2014($Clade,States)  $LesEtatsDuG
	    set BilanCilio2014($Clade,Class)   $LesClassesDuG
	    set BilanCilio2014($Clade,TaxId)   $LesTaxIdsDuG
	    set BilanCilio2014($Clade,PA) [lrange $LesMots 4 end]
	    foreach TaxId $LesTaxIdsDuG {
		set BilanCilio2014($TaxId,Clade) $Clade
		set BilanCilio2014($TaxId,Clade) $Clade
	    }
	    set LesTaxIdsDuG {}
	    set LesEtatsDuG {}
	    set LesEspecesDuG {}
	}
    }
    foreach S [array names BilanCilio2014 "10090,*"] {
	regsub 10090 $S 9606 H
	Espionne "$S $H"
	set BilanCilio2014($H) $BilanCilio2014($S)
    }
    regsub -all 0 $BilanCilio2014(10090,PA) 1 BilanCilio2014(9606,PA)
    return [BilanCilio2014 $Qui $Quoi]

}

proc BilanCilioQds {{Qui ""} {Quoi ""}} {

    return [QuestionDeScience CilioCarta "ret BilanCilio $Qui $Quoi"]

}

proc BilanDesClusters_Gretta {FichierBoitesSelectionnees FichierOUT} {

    set Fichier            "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"
    set FichierGO          "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set FichierGOProteo    "[GODBDir]/GeneOntology_HUMAN"
    set FichierProtJum     "[RepertoireDuGenome]/fiches/ProteinesJumelles" 
    set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST"

    set NbCluster 6

    set F [open $FichierBoitesSelectionnees]
    set i 0
    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == ""} {continue}
	set Ligne   [split $Ligne "\t"]
	set Affy    [lindex $Ligne 0]
	set Cluster [lindex $Ligne 1]
	incr i
	set TabAffy($Cluster,$Affy) 1
    }
    close $F

    set Tab(LesClusters) {}
    set Tab(LesNoms)     {}
    Espionne "Lecture du Fichier Orf2Cluster2Access2Def2Expression"
    foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesNoms] {
	set Affy [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Access]

	set LesExpressions [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom LesExpressions]
	for {set i 0} {$i < $NbCluster} {incr i} {
	    set Cluster [expr $i + 1]
	    if {![info exists Tab(Cluster,$Cluster,LesNoms)]} {
		set Tab(Cluster,$Cluster,LesNoms)      {}
		set Tab(Cluster,$Cluster,LesIndividusGO) {}
		set Tab(Cluster,$Cluster,LesIndividusTT) {}
		set Tab(Cluster,$Cluster,LesIndividusDS) {}
		set Tab(Cluster,$Cluster,LesIndividusDO) {}
		lappend Tab(LesClusters)               $Cluster
	    }
	    set Expr [lindex $LesExpressions $i]
	    if {$Expr < 0} {continue}
	    if {![info exists TabAffy($Cluster,$Affy)]} {continue}

	    lappend Tab(LesNoms)                  $Nom
	    lappend Tab(Cluster,$Cluster,LesNoms) $Nom
	}
    }
    if {[set Tab(LesNoms)] != {}} {set Tab(LesNoms) [lsort -unique [set Tab(LesNoms)]]}

    set LesIndividusGODeLaPop1    {}
    set LesIndividusGODeLaPopUp   {}
    set LesIndividusGODeLaPopDown {}
    set LesIndividusTTDeLaPop1    {}
    set LesIndividusTTDeLaPopUp   {}
    set LesIndividusTTDeLaPopDown {}
    set LesIndividusDSDeLaPop1    {}
    set LesIndividusDSDeLaPopUp   {}
    set LesIndividusDSDeLaPopDown {}
    set LesIndividusDODeLaPop1    {}
    set LesIndividusDODeLaPopUp   {}
    set LesIndividusDODeLaPopDown {}

    Espionne "Populations des clusters"
    foreach Cluster [set Tab(LesClusters)] {
	foreach Nom [set Tab(Cluster,$Cluster,LesNoms)] {
	    if {1} {
		####Tissue Type####################################
		set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]]
		if {$LIndividu != {}} {
		    if {$Cluster == 1 || $Cluster == 3 || $Cluster == 5} {
			lappend LesIndividusTTDeLaPopDown $LIndividu
		    } else {
			lappend LesIndividusTTDeLaPopUp   $LIndividu
		    }
		    lappend Tab(Cluster,$Cluster,LesIndividusTT) $LIndividu
		}
		####Dev Stage####################################
		set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]]
		if {$LIndividu != {}} {
		    if {$Cluster == 1 || $Cluster == 3 || $Cluster == 5} {
			lappend LesIndividusDSDeLaPopDown $LIndividu
		    } else {
			lappend LesIndividusDSDeLaPopUp   $LIndividu
		    }
		    lappend Tab(Cluster,$Cluster,LesIndividusDS) $LIndividu
		}
	    }

	    if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue}

	    if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue}
	    set     TabDeJaVu($Cluster,$Nom) 1
	    foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1}
	    if {1} {
		#####GO GO GO GO########################################
		set LIndividu {}
		foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
		    lappend LIndividu $GO
		    foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
			lappend LIndividu $GOAncetre
		    }
		}
		set LIndividu [lsort -unique $LIndividu]
		if {$LIndividu != {}} {
		    if {$Cluster == 1 || $Cluster == 3 || $Cluster == 5} {
			lappend LesIndividusGODeLaPopDown $LIndividu
		    } else {
			lappend LesIndividusGODeLaPopUp   $LIndividu
		    }
		    lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu
		}
	    }
	    if {1} {
		###Domaines#######################################
		
		set LIndividu {}
		foreach LeDom [InterrogeDomaines $Nom LesDomaines] {
		    set Type [lindex $LeDom 0]
		    set Dom  [lindex $LeDom 1]
		    set Def  [lindex $LeDom 2]
		    if {$Def == ""} {continue}
		    lappend LIndividu $Dom
		    set Tab(Dom,$Dom,Def) $Def
		    set Tab(Dom,$Dom,Type) $Type
		}
		
		set LIndividu [lsort -unique $LIndividu]
		if {$LIndividu != {}} {
		    if {$Cluster == 1 || $Cluster == 3 || $Cluster == 5} {
			lappend LesIndividusDODeLaPopDown $LIndividu
		    } else {
			lappend LesIndividusDODeLaPopUp   $LIndividu
		    }
		    lappend Tab(Cluster,$Cluster,LesIndividusDO) $LIndividu
		}
	    }
	}
    }
    Espionne "OK"

    if {[info exists TabDeJaVu]} {unset TabDeJaVu}

    Espionne "Populations totales selectionnees"
    foreach Nom [set Tab(LesNoms)] {
	if {1} {
	    ####Tissue Type####################################
	    set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]]
	    if {$LIndividu != {}} {
		lappend LesIndividusTTDeLaPop1               $LIndividu
	    }
	    ####Dev Stage####################################
	    set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]]
	    if {$LIndividu != {}} {
		lappend LesIndividusDSDeLaPop1               $LIndividu
	    }
	}
	
	if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue}
	
	set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster]

	if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue}
	set     TabDeJaVu($Cluster,$Nom) 1
	foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1}
	if {1} {
	    #####GO GO GO GO########################################
	    set LIndividu {}
	    foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
		lappend LIndividu $GO
		foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
		    lappend LIndividu $GOAncetre
		}
	    }
	    if {$LIndividu != {}} {
		set LIndividu [lsort -unique $LIndividu]
		lappend LesIndividusGODeLaPop1               $LIndividu
	    }
	}
	if {1} {
	    ###Domaines#######################################
	    
	    set LIndividu {}
	    foreach LeDom [InterrogeDomaines $Nom LesDomaines] {
		set Type [lindex $LeDom 0]
		set Dom  [lindex $LeDom 1]
		set Def  [lindex $LeDom 2]
		if {$Def == ""} {continue}
		lappend LIndividu $Dom
		set Tab(Dom,$Dom,Def) $Def
		set Tab(Dom,$Dom,Type) $Type
	    }
	    
	    set LIndividu [lsort -unique $LIndividu]
	    if {$LIndividu != {}} {
		lappend LesIndividusDODeLaPop1               $LIndividu
	    }
	}
    }
    Espionne OK

    Espionne "Lecture Du FichierGO du Proteome"
    #Gene Ontology du proteome humain#####
    set LesIndividusGODeLaPop2 {}
    if {1} {
	foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] {
	    set LIndividu {}
	    foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] {
		lappend LIndividu $GO
		foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] {
		    lappend LIndividu $GOAncetre
		}
	    }
	    if {$LIndividu == {}} {continue}
	    lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu]
	}
    }
    Espionne "OK"

    Espionne "Calcul"
    set LeTexte {}
    foreach Cluster [set Tab(LesClusters)] {
	set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)]
	set LesIndividusTT [set Tab(Cluster,$Cluster,LesIndividusTT)]
	set LesIndividusDS [set Tab(Cluster,$Cluster,LesIndividusDS)]
	set LesIndividusDO [set Tab(Cluster,$Cluster,LesIndividusDO)]

	###GO GO GO GO################
	foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop1] {
	    set GO [lindex $LeGO 0]
	    set r  [lindex $LeGO 2]
	    if {$r <= 0} {continue}

	    set Type [lindex [GODB GO $GO LesTypes                 ] 0]
	    set Def  [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
	    set Niv  [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]

	    set Stat [join [lrange $LeGO 1 end] "\t"]

	    Espionne        "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat"
	}
	foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPopDown] {
	    set GO [lindex $LeGO 0]
	    set r  [lindex $LeGO 2]
	    if {$r <= 0} {continue}

	    set Type [lindex [GODB GO $GO LesTypes                 ] 0]
	    set Def  [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
	    set Niv  [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]

	    set Stat [join [lrange $LeGO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tDown\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tDown\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat"
	}
	foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPopUp] {
	    set GO [lindex $LeGO 0]
	    set r  [lindex $LeGO 2]
	    if {$r <= 0} {continue}
	    
	    set Type [lindex [GODB GO $GO LesTypes                 ] 0]
	    set Def  [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
	    set Niv  [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]

	    set Stat [join [lrange $LeGO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tUp\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tUp\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat"
	}
	foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] {
	    set GO [lindex $LeGO 0]
	    set r  [lindex $LeGO 2]
	    if {$r <= 0} {continue}
	     
	    set Type [lindex [GODB GO $GO LesTypes                 ] 0]
	    set Def  [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
	    set Niv  [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]

	    set Stat [join [lrange $LeGO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat"
	}

	####Tissue Type#####################
	foreach LeTT [LesZscoreDesRequetesDuGroupe $LesIndividusTT $LesIndividusTTDeLaPop1] {
	    set TT [lindex $LeTT 0]
	    set r  [lindex $LeTT 2]
	    if {$r <= 0} {continue}
	     
	    set Stat [join [lrange $LeTT 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat"
	}
	foreach LeTT [LesZscoreDesRequetesDuGroupe $LesIndividusTT $LesIndividusTTDeLaPopDown] {
	    set TT [lindex $LeTT 0]
	    set r  [lindex $LeTT 2]
	    if {$r <= 0} {continue}

	    set Stat [join [lrange $LeTT 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tDown\tTissue Type\t\t\t\t$TT\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tDown\tTissue Type\t\t\t\t$TT\t\t$Stat"
	}
	foreach LeTT [LesZscoreDesRequetesDuGroupe $LesIndividusTT $LesIndividusTTDeLaPopUp] {
	    set TT [lindex $LeTT 0]
	    set r  [lindex $LeTT 2]
	    if {$r <= 0} {continue}

	    set Stat [join [lrange $LeTT 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tUp\tTissue Type\t\t\t\t$TT\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tUp\tTissue Type\t\t\t\t$TT\t\t$Stat"
	}
	###Dev Stage#####################
	foreach LeDS [LesZscoreDesRequetesDuGroupe $LesIndividusDS $LesIndividusDSDeLaPop1] {
	    set DS [lindex $LeDS 0]
	    set r  [lindex $LeDS 2]
	    if {$r <= 0} {continue}
	     
	    set Stat [join [lrange $LeDS 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat"
	}
	foreach LeDS [LesZscoreDesRequetesDuGroupe $LesIndividusDS $LesIndividusDSDeLaPopDown] {
	    set DS [lindex $LeDS 0]
	    set r  [lindex $LeDS 2]
	    if {$r <= 0} {continue}

	    set Stat [join [lrange $LeDS 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tDown\tDev Stage\t\t\t\t$DS\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tDown\tDev Stage\t\t\t\t$DS\t\t$Stat"
	}
	foreach LeDS [LesZscoreDesRequetesDuGroupe $LesIndividusDS $LesIndividusDSDeLaPopUp] {
	    set DS [lindex $LeDS 0]
	    set r  [lindex $LeDS 2]
	    if {$r <= 0} {continue}

	    set Stat [join [lrange $LeDS 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tUp\tDev Stage\t\t\t\t$DS\t\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tUp\tDev Stage\t\t\t\t$DS\t\t$Stat"
	}
	###Domaines#####################
	foreach LeDO [LesZscoreDesRequetesDuGroupe $LesIndividusDO $LesIndividusDODeLaPop1] {
	    set DO [lindex $LeDO 0]
	    set r  [lindex $LeDO 2]
	    if {$r <= 0} {continue}

	    set Def  [set Tab(Dom,$DO,Def)]
	    set Type [set Tab(Dom,$DO,Type)]
	    set Stat [join [lrange $LeDO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat"
	}
	foreach LeDO [LesZscoreDesRequetesDuGroupe $LesIndividusDO $LesIndividusDODeLaPopDown] {
	    set DO [lindex $LeDO 0]
	    set r  [lindex $LeDO 2]
	    if {$r <= 0} {continue}

	    set Def  [set Tab(Dom,$DO,Def)]
	    set Type [set Tab(Dom,$DO,Type)]
	    set Stat [join [lrange $LeDO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tDown\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tDown\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat"
	}
	foreach LeDO [LesZscoreDesRequetesDuGroupe $LesIndividusDO $LesIndividusDODeLaPopUp] {
	    set DO [lindex $LeDO 0]
	    set r  [lindex $LeDO 2]
	    if {$r <= 0} {continue}

	    set Def  [set Tab(Dom,$DO,Def)]
	    set Type [set Tab(Dom,$DO,Type)]
	    set Stat [join [lrange $LeDO 1 end] "\t"]
	    
	    Espionne        "Cluster $Cluster\tUp\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" 
	    lappend LeTexte "Cluster $Cluster\tUp\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat"
	}

    }
    Espionne "OK"

    Sauve [join $LeTexte "\n"] dans $FichierOUT

    return

}

proc BilanDesordre {alignementTFA {RepRes ""}} {


    Wup "Permet de comptabiliser le nombre de sequences desordonnees dans l alignement hnraccess"

    set Sequence ""
    set Access   ""
    
    set DebutAln 1
    set FinAln   0

    if {$RepRes==""} {
	set RepRes "/genomics/link/KoAnno/OnGoing/hnrAccess" 
    }

    #Tab(LesAccess)       - Liste des Access
    #Tab($PosAln,$Access) - Retourne a partir de la position dans l alignement (pos absolue) la pos dans Access

    #1 Position dans l alignement et dans la sequence
    set F [open "$alignementTFA"]
    while {[gets $F Ligne]>=0} {
	#>P43354 PileUp
	#------MPCVQAQYGSSPQGASPASQSYSY

	if {! [regexp -nocase {[a-z]+ || [0-9]+}  $Ligne]} {continue}
	if {  [string range $Ligne 0 0] == ">"} {
	    if {$Sequence != ""} {
		#Espionne "$Sequence"
		set PosAln 0
		set PosSeq 0
		foreach L [split $Sequence ""] {
		    incr PosAln
		    if {$L == "-"} {continue}
		    
		    incr PosSeq
		    
		    set Tab($PosAln,$Access) $PosSeq
		    #Espionne "$PosAln -- $PosSeq"

		    if {! [info exists Tab($PosAln,NbSeq)]} {
			set  Tab($PosAln,NbSeq) 1
		    } else {
			incr Tab($PosAln,NbSeq)
		    }
		}
		#Espionne "Alignement Min 1 -- Max $PosAln -- $Access $PosSeq"
		set FinAln $PosAln

		set Tab($Access,Taille) $PosSeq

		set Sequence ""
		set Access   ""
	    }
	    regsub -all {\>} $Ligne "" Ligne
	    scan $Ligne "%s %s" Access Prog

	    set Access [string toupper $Access]

	    if {! [info exists Tab(LesAccess)]} {
		set     Tab(LesAccess) $Access
	    } else {
		lappend Tab(LesAccess) $Access
	    }

	    continue
	}

	if {      $Sequence == ""} {
	    set    Sequence [string trim $Ligne]
	} else {
	    append Sequence [string trim $Ligne] 
	}
    }
    close $F
    
    if {$Sequence != ""} {
	set PosAln 0
	set PosSeq 0
	foreach L [split $Sequence ""] {
	    incr PosAln
	    if {$L == "-"} {continue}
	    
	    incr PosSeq
	    
	    set Tab($PosAln,$Access) $PosSeq
	    if {! [info exists Tab($PosAln,NbSeq)]} {
		set  Tab($PosAln,NbSeq) 1
	    } else {
		incr Tab($PosAln,NbSeq)
	    }
	}
	
	set Sequence ""
	set Access   ""
    }

    set NbAccessTotal [llength [set Tab(LesAccess)]]
    
    #1 Information par position
    #GlobPlot  - Disorder
    #FoldIndex - pds
    #Ronn      - DR
    #DisEMBL   - LOOPS HOTLOOPS REM465
    set LesMethodes [list GlobPlot FoldIndex Ronn DisEMBL]
    set Tab(GlobPlot,Quoi)  "Disorder"
    set Tab(FoldIndex,Quoi) "pds"
    set Tab(Ronn,Quoi)      "DR"
    set Tab(DisEMBL,Quoi)   [list LOOPS HOTLOOPS REM465]

    #set Tab(LesAccess) "P16058"

    foreach Acc [set Tab(LesAccess)] {
	
	set RepAcc "$RepRes/${Acc}"
	#P51843_DisEmblResultat.html   
	#P51843_FoldindexResultat.html  
	#P51843_GlobPlotResultat.html   
	#P51843_RonnResultat.html
	
	#Espionne "Access: $Access"
	foreach Method $LesMethodes {

	    set MethodOk [BonneOrthographePour2 $Method]

	    set Fichier "$RepAcc/${Acc}_${MethodOk}Resultat.html"
	    
	    #Espionne "Method: $Method"
	    foreach Quoi [set Tab($Method,Quoi)] {
		#Espionne "$Quoi"

		set LesIs [Interroge${Method} $Fichier $Quoi]
		#Espionne "Interroge${Method} $Fichier $Quoi"

		foreach I $LesIs {
		    set  LesPosDF [Interroge${Method} $Fichier $Quoi $I]
		    if {$LesPosDF==""} {continue}

		    #Espionne "I: $I -- $LesPosDF"
		    set Deb ""
		    set Fin ""
		    regsub {\-} $LesPosDF " " LesPosDF
		    scan $LesPosDF "%d %d" Deb Fin

		    if {$Deb==""|| $Fin=="" || ! [regexp {[0-9]} $Deb] || ! [regexp {[0-9]} $Fin]} {continue}
		    

		    for {set i $Deb} {$i<=$Fin} {incr i} {
			set Tab($Acc,$i,$Method,$Quoi) 1
			#Espionne "$Acc $i $Method $Quoi"
		    }
		}
	    }
	}
    }

    set Resultat ""
    set Resultat "Pos"
    
    foreach Method $LesMethodes {
	foreach Quoi [set Tab($Method,Quoi)] {
	    set METHOD "${Method}_${Quoi}"
	    lappend Resultat $METHOD
	}
    }
    lappend Resultat "NbSeq"
    lappend Resultat "NbSeqTotal"
    Espionne "[join $Resultat "\t"]"

    set Method   ""
    set Quoi     ""
    set METHOD   ""
    set Resultat ""

    for {set j $DebutAln} {$j<=$FinAln} {incr j} {
	lappend Resultat "$j"
	
	foreach Method $LesMethodes {
	    
	    foreach Quoi [set Tab($Method,Quoi)] {
		set METHOD "${Method}_${Quoi}"
		set TabRes($j,$METHOD) 0

		foreach Acc [set Tab(LesAccess)] {

		    if {! [info exists Tab($j,$Acc)]} {continue}
		    
		    set PosSeq [set Tab($j,$Acc)]
		    #Espionne "1 - ${Method}_${Quoi} On passe et posequi de $j est $PosSeq pour $Acc"
		    
		    if {! [info exists Tab($Acc,$PosSeq,$Method,$Quoi)]} {continue}
		    
		    #Espionne "2 - On arrive "

		    if {! [info exists TabRes($j,$METHOD)]} {
			set  TabRes($j,$METHOD) 1
		    } else {
			incr TabRes($j,$METHOD)
		    }
		}
		lappend Resultat [set TabRes($j,$METHOD)]
	    }
	}
	lappend Resultat [set Tab($j,NbSeq)]
	lappend Resultat $NbAccessTotal
	Espionne "[join $Resultat "\t"]"
	set Resultat ""
    }
    
    return ""

}

proc BilanFinalPresenceAbsenceDansCategorie {Fichier FichierFinal} {

    #Fichier: /fiches/GeneOntology_GPO
    
    foreach Nom [ListeDesPABs] {
	set Vu($Nom) 1
    }
    set ListeGO [list "GO:0006412" "GO:0006950" "GO:0008151" "GO:0016265" "GO:0007010" "GO:0007165" "GO:0008152"]
    foreach GO $ListeGO {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {$Ligne==""} {continue}
	    set DD [lindex [split $Ligne "\t"] 0 ]
	    if {[regexp -nocase $GO $Ligne] && [info exists Vu($DD)]} {
		#set Tab($DD,$GO) 1
		if {![info exists Tab($DD,$GO)]} {set Tab($DD,$GO) 1}
	    }
	}
    }
    #return [array get Tab]
    foreach Nom [ListeDesPABs] {
	set Ligne $Nom
	foreach GO $ListeGO {
	    if {[info exists Tab($Nom,$GO)]} {set Ligne [concat $Ligne $Tab($Nom,$GO)]} else {
		set Ligne [concat $Ligne 0]
	    }
	}
	set Ligne [join $Ligne "\t"]
	#lappend LeFinal $Ligne
	set InfosDD [InterrogeFichierFinal $Nom All]
	set InfosDD [join $InfosDD "\t"]
	lappend LeFinal "$Ligne\t$InfosDD"
    }
    SauveLesLignes $LeFinal dans $FichierFinal

}

proc BilanFullyMaskedDDSequences_PO {} {

    #################### Bilan les sequences du projet Gscope ICBP_TOPO qui ont ete entierement masquees #########
    #################### cad non localisees sur le genome humain ou des séquences de vecteur pur##################

    #Selection des repertoires dans lesquelles sont presentes les fichiers d'information sur le masking
    set RepDDMaskedSeq "/home/lardenoi/These_Projets/ICBP_TOPO"
    set LesRep [list $RepDDMaskedSeq/20040324 $RepDDMaskedSeq/20040427_ICBP_D $RepDDMaskedSeq/20040429_ICBP_D $RepDDMaskedSeq/20040428_ICBP_U $RepDDMaskedSeq/20040512_TOPO $RepDDMaskedSeq/20040730_ICBP_D $RepDDMaskedSeq/20040730_ICBP_U $RepDDMaskedSeq/20040730_TOPO_D $RepDDMaskedSeq/20040730_TOPO_U $RepDDMaskedSeq/20040817_ICBP_D $RepDDMaskedSeq/20040817_ICBP_U $RepDDMaskedSeq/20040817_TOPO_D $RepDDMaskedSeq/20040817_TOPO_U $RepDDMaskedSeq/20040916_ICBP_D $RepDDMaskedSeq/20040916_ICBP_U $RepDDMaskedSeq/20040916_TOPO_D $RepDDMaskedSeq/20040916_TOPO_U]
    #set LesRep    [list $RepDDMaskedSeq/MaskedDDSeq]
        #set FileInfos "$RepDDMaskedSeq/MaskedDDSeq/FullyMaskedSeq"
    #set LeTexte   {}

    foreach Rep $LesRep {
	set Tab(Rep,$Rep,FullyMaskedSeq)  0
	set Tab(FullyMaskedSeq)           0
    }

    foreach Rep $LesRep {
	Espionne $Rep
	foreach File [glob -nocomplain "$Rep/*.tfa.masking.infos"] {
	    #regsub -nocase {\.tfa.masking.infos} [file tail $File] "" SeqName 
	    #Espionne "SeqName: $SeqName"
	    set F [open $File]
	    while {[gets $F Ligne]>=0} {
		set Ligne [string trim $Ligne]
		if {$Ligne == ""} {continue}
		set LaLigne [split $Ligne "\t"]
		
		### Determination du nombre de DD sequences totalement masquees
		set TailleSeqInformative [lindex $LaLigne 2]
		if {$TailleSeqInformative == 0} {
		    #Espionne "Fully masked, $File"
		    incr Tab(Rep,$Rep,FullyMaskedSeq)
		    incr Tab(FullyMaskedSeq)
		    #lappend LeTexte $SeqName
		    break
		}
	    }
	    close $F
	}
    }
    
    foreach Rep $LesRep {
	Espionne "Rep: $Rep"
	Espionne "FullyMaskedSeq: [set Tab(Rep,$Rep,FullyMaskedSeq)]"
	Espionne "TotalFullyMaskedSeq: [set Tab(FullyMaskedSeq)]"
    }
    
    #Espionne $LeTexte
    #Sauve [join $LeTexte "\n"] dans $FileInfos

    return 

}

proc BilanGODeLaPop_Annaick {FichierPop FichierOUT} {

    ### Attention "FichierPop" a preciser selon etude
    
    #set FichierGO          "[RepertoireDuGenome]/fiches/GeneOntology"
    set FichierGO          "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set FichierGOProteo    "[GODBDir]/GeneOntology_HUMAN"

    set LesIndividusGODeLaPop {}

    Espionne "Populations des clusters"
    # ListeDesPABs ou CreeListePourFichierAUneColonne FichierPop
    #set FichierPop "[RepertoireDuGenome]/ANALYSE/GO_45_MA/Les45DD"
    #set FichierPop "[RepertoireDuGenome]/ANALYSE/GO_59_Affy/Les59DD"
    #set FichierPop "[RepertoireDuGenome]/ANALYSE/GO_820/Les820"
    #set FichierPop "[RepertoireDuGenome]/ListeDesTargetsDifferentiellementExprimeesSansJumeaux"

    ### Procure
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopExonhit.txt"
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopIGBMC.txt"
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopProteosys.txt"
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopSSH.txt"
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopTotale.txt"
    #set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopExonhitTN"
    # set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopExonhitHRHS"
    # set FichierPop "[RepertoireDuGenome]/ARTICLE/pop/PopExonhitBPHnonBPH"

    foreach Nom [CreeListePourFichierAUneColonne $FichierPop] {
	if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue}
	##### GO GO GO GO ########################################
	set LIndividu {}
	foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
	    lappend LIndividu $GO
	    foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
		lappend LIndividu $GOAncetre
	    }
	}
	set LIndividu [lsort -unique $LIndividu]
	if {$LIndividu != {}} {lappend LesIndividusGODeLaPop $LIndividu}
    }
    Espionne "OK"

    if {[info exists TabDeJaVu]} {unset TabDeJaVu}

    Espionne "Lecture Du FichierGO du Proteome"
    #Gene Ontology du proteome humain#####
    set LesIndividusGODeLaPopTot {}
    foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] {
	set LIndividu {}
	foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] {
	    lappend LIndividu $GO
	    foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] {
		lappend LIndividu $GOAncetre
	    }
	}
	if {$LIndividu == {}} {continue}
	lappend LesIndividusGODeLaPopTot [lsort -unique $LIndividu]
    }
    Espionne "OK"

    Espionne "Calcul"
    set LeTexte {}

    ###GO GO GO GO################
    foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGODeLaPop $LesIndividusGODeLaPopTot] {
	set GO [lindex $LeGO 0]
	set r  [lindex $LeGO 2]
	if {$r <= 0} {continue}
	
	set Type [lindex [GODB GO $GO LesTypes                 ] 0]
	set Def  [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
	set Niv  [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]
	
	set Stat [join [lrange $LeGO 1 end] "\t"]
	    
	Espionne        "$Type\t$Niv\t$GO\t$Def\t$Stat" 
	lappend LeTexte "$Type\t$Niv\t$GO\t$Def\t$Stat"
    }
    Espionne "OK"

    Sauve [join $LeTexte "\n"] dans $FichierOUT

    return

}

proc BilanHDAParFamille {LesOrgCibles Famille LesGenORFs aBilan} {

    upvar $aBilan Bilan
    set Seuil 50
    foreach {Gen ORF} $LesGenORFs {
	foreach Org $LesOrgCibles {
	    set  Blastp($ORF,$Org) 0
	    set Tblastn($ORF,$Org) 0
	}
	set LesBlastp [QuestionDeScience $Gen "ret LesOrganismesOrthologues $ORF BlastP Presents Court"]
	foreach Org $LesBlastp {
	    set Blastp($ORF,$Org) 1
	}
	set LesTblastn [QuestionDeScience $Gen "ret LesOrganismesOrthologues $ORF TBlastN Presents Court"]
	foreach Org $LesTblastn {
	    set Tblastn($ORF,$Org) 1
	}
	foreach Org $LesOrgCibles {
	    set Jaune($ORF,$Org) [expr [set Tblastn($ORF,$Org)] && ![set Blastp($ORF,$Org)]]  
	}
    }
    set NbMembres [expr [llength $LesGenORFs]/2]
    foreach Org $LesOrgCibles {
	set TotP 0
	set TotN 0
	set TotJ 0
	foreach {Gen ORF} $LesGenORFs {
	    incr TotP [set Blastp($ORF,$Org)]
	    incr TotN [set Tblastn($ORF,$Org)]
	    incr TotJ [set Jaune($ORF,$Org)]
	}
	set TotP [expr round($TotP*100.0/$NbMembres)]
	set TotN [expr round($TotN*100.0/$NbMembres)]
	set TotJ [expr round($TotJ*100.0/$NbMembres)]
	set LeBilan [list $TotN $TotP $TotJ]
	set Bilan($Famille,$Org) $LeBilan

    }
#	set [QuestionDeScience $Gen "ret LesOrganismesOrthologues DbClustal Presents Court"]

}

proc BilanMasking {Nom} {

    set LeTexte {}

    set Fnuctfa  "[RepertoireDuGenome]/nuctfa/$Nom"
    if {![file exists $Fnuctfa]} {
	return [list "$Nom\tNoSequence"]
    }
    set Taille                [TailleDeLaSequenceDuFichierTFA $Fnuctfa]
    set nNIni                 [NombreDeBasesMasquees          $Fnuctfa]
    
    set LesRepeats {}

    set Fnucm    "[RepertoireDuGenome]/nucmask/$Nom.m"
    if {[file exists $Fnucm]} {
	set nNAvecMasking         [NombreDeBasesMasquees             $Fnucm ]	

	set LesRepeatsDuMasking [LesRepeatsDeLEnteteDuTFA $Fnucm]
	set LesRepeats [concat $LesRepeats $LesRepeatsDuMasking]
	
	if {0 < [expr $nNAvecMasking - $nNIni]} {
	    set PDuMasking          "[format "%.1f" [expr (($nNAvecMasking - $nNIni) * 1.0 / $Taille) * 100]]"
	} else {
	    set PDuMasking "0"
	}
	
	#Espionne            "$Nom\tMasking\t$PDuMasking\t[join $LesRepeatsDuMasking "\t"]"
	lappend     LeTexte "$Nom\tMasking\t$PDuMasking\t[join $LesRepeatsDuMasking "\t"]"
    }
    
    set Fnucrm   "[RepertoireDuGenome]/nucmask/$Nom.rm"
    if {[file exists $Fnucrm]} {
	set nNAvecReMasking       [NombreDeBasesMasquees             $Fnucrm ]

	set LesRepeatsDuReMasking [LesRepeatsDeLEnteteDuTFA $Fnucrm]

	set LesRepeats [concat $LesRepeats $LesRepeatsDuReMasking]
	if {0 < [expr $nNAvecReMasking - $nNIni]} {
	    set PDuReMasking          "[format "%.1f" [expr (($nNAvecReMasking - $nNIni) * 1.0 / $Taille) * 100]]"
	} else {
	    set PDuReMasking "0"
	}
	#Espionne            "$Nom\tReMasking\t$PDuReMasking\t[join $LesRepeatsDuReMasking "\t"]"
	lappend     LeTexte "$Nom\tReMasking\t$PDuReMasking\t[join $LesRepeatsDuReMasking "\t"]"
    }
    
    set Fnucmrm   "[RepertoireDuGenome]/nucmask/$Nom.mrm"
    if {[file exists $Fnucmrm]} {
	if {0 < [expr $nNAvecReMasking + $nNAvecMasking - 2 * $nNIni]} {
	    set PDuMRM                "[format "%.1f" [expr (($nNAvecReMasking + $nNAvecMasking - 2 * $nNIni) * 1.0 / $Taille) * 100]]"
	} else {
	    set PDuMRM "0"
	}
    
	#Espionne            "$Nom\tMRM\t$PDuMRM\t[join $LesRepeats "\t"]"
	lappend     LeTexte "$Nom\tMRM\t$PDuMRM\t[join $LesRepeats "\t"]"
    }

    if {$LeTexte != {}} {return $LeTexte}
    set Fnucmask   "[RepertoireDuGenome]/nucmask/$Nom"

    if {[file exists $Fnucmask]} {
	set nNAvecMasking         [NombreDeBasesMasquees             $Fnucmask ]

	set LesRepeatsDuMasking [LesRepeatsDeLEnteteDuTFA $Fnucmask]
	set LesRepeats [concat $LesRepeats $LesRepeatsDuMasking]
	
	if {0 < [expr $nNAvecMasking - $nNIni]} {
	    set PDuMasking          "[format "%.1f" [expr (($nNAvecMasking - $nNIni) * 1.0 / $Taille) * 100]]"
	} else {
	    set PDuMasking "0"
	}
	
	#Espionne            "$Nom\tMasking\t$PDuMasking\t[join $LesRepeatsDuMasking "\t"]"
	lappend     LeTexte "$Nom\tMasking\t$PDuMasking\t[join $LesRepeatsDuMasking "\t"]"
    }

    return $LeTexte

}

proc BilanOrthologie {ListeSeq} {

    
    #creation du repertoire Bilan
    if { ! [file exists "Bilan"]} {
	File mkdir Bilan
    }
    if { ! [file exists "[RepertoireDuGenome]/Bilan/Summary"]} {
	File mkdir [RepertoireDuGenome]/Bilan/Summary
    }

    #creation d'un tableau associatif avec le nom des especes accepter dans notre recherche d'ortholgues
    set Lspecies [LesLignesDuFichier [RepertoireDuGenome]/Especes.txt]

    #tableau associatif, code gsscope (PUZ..) associe au nom de la prot exemple TAF01 (GN dans le fichier prottembl)
    #parcours les sequences de la liste a traiter!!!
    foreach fichier $ListeSeq {
	set n [split $fichier "/"]
	set CodeProt [lindex $n [llength $n]-1]
	set LL [LaSequenceDesBanques "[RepertoireDuGenome]/protembl/$CodeProt"]
	DecortiqueLesLignesEMBL $LL ID AC DE GN
	#Espionne "File: $CodeProt & GN= $GN"
	set CodeProtAssT($CodeProt) $GN
    }

    #rangement de la liste dans l'ordre alphapbetique
    set key [array names CodeProtAssT]
    set key [lsort -dictionary $key]

    #PAS OUBLIER DE REMPLIR LA PREMIERE LIGNE AVEC LES SUs taf taf etc...
    set cmpt 1
    set Torthologues(0,0) "species-SUs"
    foreach k $key {
	set Torthologues(0,$cmpt) $CodeProtAssT($k)
	incr cmpt
    }
    #remplir la premiere colonne
    set cmpt 1
    foreach c $Lspecies {
	set Torthologues($cmpt,0) $c
	incr cmpt
    }

    foreach fichier $ListeSeq {
	set n [split $fichier "/"]
	set CodeProt [lindex $n [llength $n]-1]
	set Leslignes [LesLignesDuFichier $fichier]
	foreach Ligne $Leslignes {
	    if {![regexp {^>PUZ.*} $Ligne] && [regexp {^>} $Ligne]} {
		regsub ">" $Ligne "" Ligne2 
		set ligneSpliter [split $Ligne2 " "]
		set specie [lindex $ligneSpliter 2]
		append specie " [lindex $ligneSpliter 3]"
		set ID [lindex $ligneSpliter 0]
		#Espionne "ID: $ID; specie: $specie"
		#si il y a deja un orthologue trouver pour cette espece
		if {[string trim  $specie]==""} { continue }
		if {[info exists Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1])]} {		    
		    set listete $Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1])
		    set tutu [lsearch -all -exact $listete $ID]
		    #Espionne "tutu: $tutu et $Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1]) et ID:$ID"
		    if {$tutu=="" || $tutu=="-1"} {
			set orthoMulti "$Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1]) - $ID"			
			set Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1]) $orthoMulti
		    }		    
		} else {	      
		    #if {$ID=="Q8SQS4"} {Espionne "ID normal: $ID"}
		    set Torthologues([expr [lsearch -all -exact $Lspecies $specie]+1],[expr [lsearch -all -exact $key $CodeProt]+1]) $ID
		}
	    }
	}
    }

    for {set i 0} {$i<=[llength $Lspecies]} {incr i} {
	for {set y 0} {$y<=[llength $key]} {incr y} {
	    if {[info exists Torthologues($i,$y)]} {
		append line "$Torthologues($i,$y)"
		if {$y<[llength $key]} {append line ";"}
	    } else {
		if {$y<[llength $key]} {
		    append line ";"
		}
	    }
	}
	lappend fileOrtho $line
	set line ""
    }

    set fileResult "[RepertoireDuGenome]/Bilan/Summary/OrthologieBilan.csv"
    SauveLesLignes $fileOrtho dans $fileResult

}

proc BilanOrthologiePourTous {{directory ""}} {


    if {$directory == ""} {
	set directory [RepertoireDuGenome]/NewTfasDesCopains
    }
    
    set r [glob -directory $directory *]
    #recupere le fichier ¨¤ traiter dans tfadescopains.... et faire le traitement pour le fichier
    foreach fichier $r {
	set n [split $fichier "/"]
	set f [lindex $n [llength $n]-1]
	if {[PasTouche $f]} { continue }
	lappend listSeq $fichier
	FinPasTouche $f
    }
    BilanOrthologie $listSeq

}

proc BilanPerteGainForOneFile {Quoi FileMacsims Ref} {

    #a readapter en regardant BilanPerteGainPfam {WithWhat}
    #Quoi: Pfam Block
    
    set LesLignesFic {}
    if {[info exists InfoQuoiRef]} { unset InfoQuoiRef }
    set LesQuoiRef {}

    set LesNamesMacsims [FromMacsims $FileMacsims ListOf Names]

    if {$Quoi=="Pfam"}  {set LesQuoiInfoRef [FromMacsims $FileMacsims $Ref "ConcatPfam"]}
    if {$Quoi=="Block"} {set LesQuoiInfoRef [FromMacsims $FileMacsims $Ref "ConcatBlock"]}
    #Espionne "$LesQuoiInfoRef"
    set SeqDataRef [FromMacsims $FileMacsims $Ref "SeqData"]
    PositionAbsolueDansAlignement 1 $SeqDataRef
    
    foreach InfoRef $LesQuoiInfoRef {
	if {$Quoi=="Pfam"} {
	    scan $InfoRef "%s" QuoiRef
	    set QuoiRef [string toupper $QuoiRef]
	    regsub -nocase {^PROP_} $QuoiRef "" QuoiRef 
	}
	if {$Quoi=="Block"} {
	    set QuoiRef [lindex [split $InfoRef "/"] 0]
	    set QuoiRef [string toupper $QuoiRef]
	}
	lappend LesQuoiRef $QuoiRef
	lappend InfoQuoiRef($QuoiRef) $InfoRef
	FstartFstop $InfoRef RFstart RFstop
	set AbsRef($RFstart) [PositionAbsolueDansAlignement $RFstart]
	set AbsRef($RFstop)  [PositionAbsolueDansAlignement $RFstop]
    }
    set LesQuoiRef [lsort -unique $LesQuoiRef]
    foreach Name $LesNamesMacsims {
	set differe 0
	if {[info exists InfoQuoiName]} { unset InfoQuoiName }
	if {[info exists DejaVu]} { unset DejaVu }
	
	if {$Quoi=="Pfam"}  {set LesQuoiInfoName [FromMacsims $FileMacsims $Name "ConcatPfam"]}
	if {$Quoi=="Block"} {set LesQuoiInfoName [FromMacsims $FileMacsims $Name "ConcatBlock"]}
	set SeqDataName [FromMacsims $FileMacsims $Name "SeqData"]
	PositionAbsolueDansAlignement 1 $SeqDataName
	
	#Espionne
	#Espionne "$Name" 
	set LigneFic "$Name:"
	lappend LesLignesFic $LigneFic
	set LesQuoiInfoName [ListeSsElmtVide $LesQuoiInfoName]
	#EspionneL "$LesQuoiInfoName"
	#Espionne "LesGainsPertes:"
	
	if {$LesQuoiInfoName=={}} {
	    set differe 1
	    foreach QuoiRef $LesQuoiRef {
		foreach InfoRef $InfoQuoiRef($QuoiRef) {
		    FstartFstop $InfoRef RFstart RFstop
		    set ResultPerdu [SitePerdu $Quoi $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)]  [PositionRelativeDansAlignement $AbsRef($RFstop)]]
		    set LigneFic "$ResultPerdu"
		    lappend LesLignesFic $LigneFic
		}
	    }
	    continue
	}
	foreach InfoName $LesQuoiInfoName {
	    if {$Quoi=="Pfam"} {
		scan $InfoName "%s" QuoiName
		set QuoiName [string toupper $QuoiName]
		regsub -nocase {^PROP_} $QuoiName "" QuoiName 
	    }
	    if {$Quoi=="Block"} {
		set QuoiName [lindex [split $InfoName "/"] 0]
		set QuoiName [string toupper $QuoiName]
	    }
	    lappend InfoQuoiName($QuoiName) $InfoName
	    
	    FstartFstop $InfoName Fstart Fstop
	    set AbsFstart [PositionAbsolueDansAlignement $Fstart]
	    set AbsFstop  [PositionAbsolueDansAlignement $Fstop]
	    
	    if { ! [info exists InfoQuoiRef($QuoiName)]} {
		set differe 1
		set ResultGagne [SiteGagne $Quoi $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] 
		#Espionne "$ResultGagne"
		set LigneFic "$ResultGagne"
		lappend LesLignesFic $LigneFic
	    }
	}
	foreach QuoiRef $LesQuoiRef {
	    foreach InfoRef $InfoQuoiRef($QuoiRef) {
		FstartFstop $InfoRef RFstart RFstop
		if { ! [info exists InfoQuoiName($QuoiRef)]} {
		    #if {[info exists DejaVu($QuoiRef)]} { continue }
		    set differe 1
		    set ResultPerdu [SitePerdu $Quoi $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)]  [PositionRelativeDansAlignement $AbsRef($RFstop)]]
		    #Espionne "$ResultPerdu"
		    set LigneFic "$ResultPerdu"
		    lappend LesLignesFic $LigneFic
		    lappend DejaVu($QuoiRef) "$AbsRef($RFstart) $AbsRef($RFstop)"
		} else {
		    set TousAbsents 1
		    foreach InfoName $InfoQuoiName($QuoiRef) {
			FstartFstop $InfoName Fstart Fstop
			set AbsFstart [PositionAbsolueDansAlignement $Fstart]
			set AbsFstop  [PositionAbsolueDansAlignement $Fstop]
			#Espionne "$AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop"
			if {[Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop]} {
			    set TousAbsents 0
			    break
			}
		    }
		    if { $TousAbsents } { 
			set differe 1
			set ResultPerdu [SitePerdu $Quoi $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)]  [PositionRelativeDansAlignement $AbsRef($RFstop)]]
			#Espionne "$ResultPerdu"
			set LigneFic "$ResultPerdu"
			lappend LesLignesFic $LigneFic
		    } 
		}
	    }
	}
	if {!$differe} {
	    #Espionne "   $Name rien gagne rien pris"
	    set LigneFic "   $Name rien gagne rien perdu"
	    lappend LesLignesFic $LigneFic
	}
    }
    Espionne ""
    Espionne "Ref $Ref"
    EspionneL "$LesLignesFic"
    #SauveLesLignes $LesLignesFic dans "$RepertoireOut/$Box"

}

proc BilanPerteGainFromCible {} {

    #surement a readapter car fait apres BilanPerteGainPfam 
    set File "/genomics/link/SpliRetMouse/CibleNaomi17092010/CibleFromNaomi_17092010.csv"
    foreach Ligne [LesLignesDuFichier $File] {
	foreach {IdOrg ClusterId} [split $Ligne ";"] {
	    set FileMacsims ""
	    if {$IdOrg == "SPR"} { 
		set Org "Rat"
		set Science "SpliRetRat" 
		set Repertoire "/genomics/link/SpliRetRat/comparepfam"
	    }
	    if {$IdOrg == "SPM"} {
		set Org "Mouse"
		set Science "SpliRetMouse"
		set Repertoire "/genomics/link/SpliRetMouse/comparepfam"
	    }
	    set ClusterId "cluster_$ClusterId"
	    set Box     [QuestionDeScience $Science "ret InterrogeBox $ClusterId Box"]
	    if {$Box==""} {continue}
	    set Ref     [QuestionDeScience $Science "ret ExtraitInfo $Box Ref"]
	    set RefPfam [QuestionDeScience $Science "ret ExtraitInfo $Box RefPfam"]
	    set FileMacsims "/genomics/link/$Science/macsimXml/$Box.orgord.aj"
	    if {![file exists $FileMacsims]} {set FileMacsims "/genomics/link/$Science/macsimXml/$Box.orgord"}
	    set LesPfamDeRefPfam [QuestionDeScience $Science "ret FromMacsims $FileMacsims $RefPfam ConcatPfam"]
	    set LesId {}
	    foreach PfamRef  $LesPfamDeRefPfam {
		set MotsPfamRef [split $PfamRef "/"]
		set Pfam     [lindex $MotsPfamRef 0]
		set MotsPfam [split $Pfam " "]
		set Id       [lindex $MotsPfam 0]
		set PfamName [lindex $MotsPfam 1]
		regsub "PROP_" $Id "" Id
		lappend LesId "$Id"
	    }
	    if {$RefPfam == $Box} {set RefPfam $Ref}
	    lappend LesLignesResult "$ClusterId $Box"
	    lappend LesLignesResult "Ref= $RefPfam: $LesId"
	    foreach LigneBilan [LesLignesDuFichier "$Repertoire/$Box"] {
		regsub $Box $LigneBilan $Ref LigneBilan
		lappend LesLignesResult $LigneBilan
		
		if {![regexp {^ } $LigneBilan]} {continue}
		set LigneBilan [string trim $LigneBilan]
		set MotsLigneBilan [split $LigneBilan " "]
		set Acc [lindex $MotsLigneBilan 0]
		if {[regexp "rien gagne rien perdu" $LigneBilan]} {
		    set Evmnt "aucun"
		    set Pfam ""
		    set AbsStart "" 
		    set AbsStop ""   
		    set RelStart "" 
		    set RelStop ""  
		    set LigneTab "$Box;$ClusterId;$Acc;$RefPfam;$Evmnt;;;"
		} else {
		    set Evmnt [lindex $MotsLigneBilan 2]
		    if {$Evmnt=="perdu"} {set Evmnt "perte"}
		    if {$Evmnt=="gagne"} {set Evmnt "gain"}
		    set Pfam  [lindex $MotsLigneBilan 3]
		    set Pfam  [string trim $Pfam "\""]
		    set index [expr [string last "\)" $LigneBilan] + 2]
		    set SousLigneBilan [string range $LigneBilan $index end]
		    set MotsSousLigneBilan [split $SousLigneBilan " "]
		    set AbsStart  [lindex $MotsSousLigneBilan 2]
		    set AbsStop   [lindex $MotsSousLigneBilan 3]
		    set RelStart  [lindex $MotsSousLigneBilan 6]
		    set RelStop   [lindex $MotsSousLigneBilan 7]
		    set LigneTab "$Box;$ClusterId;$Acc;$RefPfam;$Evmnt;$Pfam;$AbsStart-$AbsStop;$RelStart-$RelStop"
		}
		lappend LesLignesTab $LigneTab
	    }
	    lappend LesLignesResult ""
	}
    }
    #SauveLesLignes $LesLignesResult dans "/genomics/link/SpliRetMouse/CibleNaomi17092010/BilanPerteGainOfCibleNaomi"
    #SauveLesLignes $LesLignesTab dans "/genomics/link/SpliRetMouse/CibleNaomi17092010/BilanPerteGainOfCibleNaomiInCsv.csv"

}

proc BilanPerteGainPfam {WithWhat} {

    #WithWhat est Block or Prosite
    #ne prends que les prosites pattern
    #fait bilan perte-gain en pfam et quand on conserve le pfam regarde si on a conserve tous les blocks/prosite du pfam
    #NB: lance une 1ere fois avec block puis avec Prosite => ecrit resultats dans le meme fichier sous repertoire BilanPerteGain
    #                                                     => ecrit dans BilanPerteGainFile les resultats sous forme de liste
    #NB: peut relancer en utilisant seulement une categorie de PFAM avec InterrogeBindingPfamDesFromGo (ou on decide quel categorie de pfam). Mais attention doit changer nom des fichiers sorties sinon ecrase. 
    #detail proc:
#pas de pfam dans la ref et le name
#Name gagne pfam
   #Name gagne un nouveau pfam (ce pfam n existe pas dans la ref)
   #Name gagne un pfam existant (ce pfam existe dans la ref mais a une position differente)
#ce pfam de la ref est absent dans le Name => perdu
   #sauf si ce Pfam de la ref est avant le debut ou apres la fin du name => tiens pas compte car peut rien dire
#ce pfam de la ref est present dans le Name
   #sauf si ce pfam de la ref est au tout debut ou a la fin du name => tiens pas compte car peut rien dire
   #ce pfam de la ref est present dans le Name mais position differente => perdu
      #sauf si ce pfam de la ref est avant le debut ou apres la fin du name => tiens pas compte car peut rien dire
   #ce pfam de la ref est present dans le Name a la meme position => garde
      #sauf si ce Feature du pfam de la ref est elimine car le pfam du name est plus petit que le pfam de la ref et donc les Fe de la ref non contenus dans le pfam du name ne sont pas perdu => tiens pas compte	    
      #ce Feature du Pfam de la ref est absent dans le Name => perdu
         #sauf si ce Feature du Pfam de la ref est elimine car le debut ou la fin de la sequence se trouve dans ce Fe => tiens pas compte
      #ce Feature du Pfam de la ref est present dans le Name 
         #ce Feature du Pfam de la ref est present dans le Name mais position differente => perdu
            #sauf si ce Feature du Pfam de la ref est elimine car le debut ou la fin de la sequence se trouve dans ce Fe => tiens pas compte
         #ce Feature du Pfam de la ref est present dans le Name a la meme position => garde
            #sauf si ce Feature du Pfam de la ref est elimine car ce Name (sa sequence) commence ou se finit dans le feature et ce feature commence plus tôt ou se finit plus tard dans la ref, donc il manquera un fragment (avant le debut ou apres la fin de la sequence du Name) => sait pas si vraiment manquant ou pb sequencage; peut rien conclure tiens pas compte (ex: SPR0429 en Cter et SPM1041 en Nter)   
            #on perd un fragment dans ce Feature => perdu
               #sauf si ce Feature du Pfam de la ref est elimine car ce Name (sa sequence) commence ou se finit dans le feature et ce feature commence plus tôt ou se finit plus tard dans la ref, donc il manquera un fragment (avant le debut ou apres la fin de la sequence du Name) => sait pas si vraiment manquant ou pb sequencage; peut rien conclure tiens pas compte (ex: SPR0429 en Cter et SPM1041 en Nter)
	    #on perd un fragment entre ce Feature garde et le suivant => perdu
          
    set RepertoireOut     "[RepertoireDuGenome]/BilanPerteGain"
    set RepertoireOutFile "[RepertoireDuGenome]/BilanPerteGainFile"
    if {! [file exists $RepertoireOut]}     {file mkdir $RepertoireOut}
    if {! [file exists $RepertoireOutFile]} {file mkdir $RepertoireOutFile}
    foreach Box [ListeDesPABs] {	
	#if {[file exists "$RepertoireOut/$Box"]} {continue}
	#if {$Box != "SPR1881"} { continue }
	set Tag [ExtraitInfo $Box "Tag"]
	if {$Tag=="noalt"} {continue}
	set LesPfamInfoRef {}; set LesBlockInfoRef {}; set LesPrositeInfoRef {}
	set LesLignesFic {}; set LesPfamRef {}
	lappend LesLignesFic "With $WithWhat"
	if {[info exists InfoPfamRef]} { unset InfoPfamRef }
	if {[info exists AbsRef]} { unset AbsRef }
	
	if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} {
	    set Org Mouse
	} elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set Org Rat
	} else {
	    set Org SpliRet
	}

	if {$Org=="SpliRet"} {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new"}
	} else {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	}
	if {![file exists $FileMacsims]} {continue}

	set Cluster   [ExtraitInfo $Box "Cluster"]
	set Ref       [ExtraitInfo $Box "Ref"]
	set LesNames  [InterrogeNames $Cluster Name $Org]
	set RefPfam   [ExtraitInfo $Box "RefPfam"]
	set LesPfamInfoRefBrut  [FromMacsims $FileMacsims $RefPfam "ConcatPfam"]
	foreach PfamInfoRefBrut $LesPfamInfoRefBrut {
	    if {[regexp "^ERROR" $PfamInfoRefBrut] || [regexp "^WARN" $PfamInfoRefBrut]} {continue}
	    lappend LesPfamInfoRef $PfamInfoRefBrut
	}
	set SeqDataRef      [FromMacsims $FileMacsims $RefPfam "SeqData"]
	set SeqDataRefSsGap [FromMacsims $FileMacsims $RefPfam "SeqDataSansGap"]
	set LongSeqRef [string length $SeqDataRefSsGap]
	set quisuis RefPf
	PositionAbsolueDansAlignement 1 $SeqDataRef
	
	if {$WithWhat=="Block"} {
	    set LesBlockInfoRefBrut  [FromMacsims $FileMacsims $RefPfam "ConcatBlock"]
	    foreach BlockInfoRefBrut $LesBlockInfoRefBrut {
		if {[regexp "^ERROR" $BlockInfoRefBrut] || [regexp "^WARN" $BlockInfoRefBrut]} {continue}
		lappend LesBlockInfoRef $BlockInfoRefBrut
	    }
	    if {[info exists FeaturesDesPfamInfoRef]} { unset FeaturesDesPfamInfoRef }
	    FeaturesDesPfam FeaturesDesPfamInfoRef $LesPfamInfoRef $LesBlockInfoRef
	}
	if {$WithWhat=="Prosite"} {
	    set LesPrositeInfoRefBrut [FromMacsims $FileMacsims $RefPfam "ConcatProsite"]
	    foreach PrositeInfoRefBrut $LesPrositeInfoRefBrut {
		if {[regexp "^ERROR" $PrositeInfoRefBrut] || [regexp "^WARN" $PrositeInfoRefBrut]} {continue}
		lassign [split $PrositeInfoRefBrut "/-"] PsId PsDeb PsFin
		scan $PsId "%s" PsId
		regsub -nocase {^PROP_} $PsId "" PsId
		set TypeProsite [TypeProsite $PsId]
		if {$TypeProsite == "MATRIX"} {continue}
		lappend LesPrositeInfoRef $PrositeInfoRefBrut
	    }
	    if {[info exists FeaturesDesPfamInfoRef]} { unset FeaturesDesPfamInfoRef }
	    FeaturesDesPfam FeaturesDesPfamInfoRef $LesPfamInfoRef $LesPrositeInfoRef
	}

#	Espionne ""
	Espionne "$FileMacsims"
#	Espionne "$Box $Cluster"
#	Espionne "$LesNames"
#	Espionne "$RefPfam"
#	EspionneL "$LesPfamInfoRef"
#	Espionne "quisuis $quisuis"
#	Espionne ""

	foreach PfamInfoRef $LesPfamInfoRef {
	    scan $PfamInfoRef "%s" PfamRef
	    set PfamRef [string toupper $PfamRef]
	    regsub -nocase {^PROP_} $PfamRef "" PfamRef 

	    lappend LesPfamRef $PfamRef
	    lappend InfoPfamRef($PfamRef) $PfamInfoRef
	    FstartFstop $PfamInfoRef RFstart RFstop
	    set AbsRef($RFstart) [PositionAbsolueDansAlignement $RFstart]
	    set AbsRef($RFstop)  [PositionAbsolueDansAlignement $RFstop]
	}
	set LesPfamRef [ListeSansDoublon $LesPfamRef]


	foreach Name $LesNames {
	    set differe 0; set differeFe 0
	    #if {$Name != "LA0ACA19YO10CM1"} { continue }
	    if {![regexp "^LA" $Name] && ![regexp "^n3" $Name]} {continue}
	    set LesPfamInfoName {}; set LesBlockInfoName {}; set LesPrositeInfoName {}
	    if {[info exists InfoPfamName]} { unset InfoPfamName }

	    if {$Name==$Ref} {set Name $Box}
	    set LesPfamInfoNameBrut [FromMacsims $FileMacsims $Name "ConcatPfam"]
	    foreach PfamInfoNameBrut $LesPfamInfoNameBrut {
		if {[regexp "^ERROR" $PfamInfoNameBrut] || [regexp "^WARN" $PfamInfoNameBrut]} {continue}
		lappend LesPfamInfoName $PfamInfoNameBrut
	    }
	    set SeqDataName        [FromMacsims $FileMacsims $Name "SeqData"]
	    set SeqDataNameSsGap   [FromMacsims $FileMacsims $Name "SeqDataSansGap"]
	    set LongSeqName      [string length $SeqDataNameSsGap]
	    set quisuis NamePf
	    PositionAbsolueDansAlignement 1 $SeqDataName

	    set AbsNameFin [PositionAbsolueDansAlignement $LongSeqName]
	    set AbsNameDeb [PositionAbsolueDansAlignement 1]

	    lappend LesLignesFic "-$Name:"
	    set LesPfamInfoName [ListeSsElmtVide $LesPfamInfoName]

	    if {$WithWhat=="Block"} {
		set LesBlockInfoNameBrut [FromMacsims $FileMacsims $Name "ConcatBlock"]
		foreach BlockInfoNameBrut $LesBlockInfoNameBrut {
		    if {[regexp "^ERROR" $BlockInfoNameBrut] || [regexp "^WARN" $BlockInfoNameBrut]} {continue}
		    lappend LesBlockInfoName $BlockInfoNameBrut
		}
		if {[info exists FeaturesDesPfamInfoName]} { unset FeaturesDesPfamInfoName }
		FeaturesDesPfam FeaturesDesPfamInfoName $LesPfamInfoName $LesBlockInfoName
	    }
	    if {$WithWhat=="Prosite"} {
		set LesPrositeInfoNameBrut [FromMacsims $FileMacsims $Name "ConcatProsite"]
		foreach PrositeInfoNameBrut $LesPrositeInfoNameBrut {
		    if {[regexp "^ERROR" $PrositeInfoNameBrut] || [regexp "^WARN" $PrositeInfoNameBrut]} {continue}
		    lassign [split $PrositeInfoNameBrut "/-"] PsId PsDeb PsFin
		    scan $PsId "%s" PsId
		    regsub -nocase {^PROP_} $PsId "" PsId
		    set TypeProsite [TypeProsite $PsId]
		    if {$TypeProsite == "MATRIX"} {continue}
		    lappend LesPrositeInfoName $PrositeInfoNameBrut
		}
		if {[info exists FeaturesDesPfamInfoName]} { unset FeaturesDesPfamInfoName }
		FeaturesDesPfam FeaturesDesPfamInfoName $LesPfamInfoName $LesPrositeInfoName
	    }
#	    Espionne ""
#	    Espionne "$Name ($Box)"
#	    Espionne "$LesPfamInfoName"
#	    Espionne "$LesBlockInfoName"
#	    Espionne "quisuis $quisuis"
#	    Espionne "LesGainsPertes:"

	    if {$LesPfamInfoRef=={} && $LesPfamInfoName=={}} {
		#pas de Pfam dans la ref et le name
		if {$WithWhat=="Block"} {lappend LesLignesFic "$Name pas de pfam"}
		continue
	    }

	    foreach InfoName $LesPfamInfoName {
		#Name gagne Pfam
		scan $InfoName "%s" PfamName
		set PfamName [string toupper $PfamName]
		regsub -nocase {^PROP_} $PfamName "" PfamName 
		
		lappend InfoPfamName($PfamName) $InfoName
		FstartFstop $InfoName Fstart Fstop
		set AbsFstart [PositionAbsolueDansAlignement $Fstart]
		set AbsFstop  [PositionAbsolueDansAlignement $Fstop]

		#on ne prends en compte que les pfam binding
		set Des [InterrogeBindingPfamDesFromGo $PfamName Des]
		if {$Des==""} { continue }

		if { ! [info exists InfoPfamRef($PfamName)]} {
		    #Name gagne un nouveau Pfam (ce Pfam n existe pas dans la ref)
		    set differe 1
		    set ResultGagne [SiteGagne "Pfam" $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] 
#		    Espionne "ResultGagne1 $ResultGagne"	
		    lappend GagnePfam($Box) $ResultGagne
		    if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultGagne"}
		} else {
		    #Name gagne un Pfam existant (ce Pfam existe dans la ref mais a une position differente)
		    set JeSuisSeul 1
		    foreach PfamInfoRef $InfoPfamRef($PfamName) {
			FstartFstop $PfamInfoRef RFstart RFstop
			#ne prends pas en compte un pfam comme gagne dans les 2 cas suivants 
			    #En Nter: quand le PF01 est situe au debut de la ref et quand le PF01 du name est en amont de PF01 dans la ref(ex:SPM0005)
			    #En Cter: quand le PF01 est situe a la fin de la ref et quand le PF01 du name est en aval de PF01 dans la ref  
			if {$RFstart<=2            && $AbsFstop         < $AbsRef($RFstart)} {set JeSuisSeul 0; break}
			if {$RFstop == $LongSeqRef && $AbsRef($RFstart) < $AbsFstart       } {set JeSuisSeul 0; break}
			if {[Recouvrement $AbsFstart $AbsFstop $AbsRef($RFstart) $AbsRef($RFstop)]} {
			    set JeSuisSeul 0
			    break
			}
		    }
		    if {$JeSuisSeul} {
			set ResultGagne [SiteGagne "Pfam" $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] 
#			Espionne "ResultGagne2 $ResultGagne"
			lappend GagnePfam($Box) $ResultGagne
			if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultGagne"}
		    }
		}
	    }

	    foreach PfamRef $LesPfamRef {
		#on ne prends en compte que les pfam binding
		set Des [InterrogeBindingPfamDesFromGo $PfamRef Des]
		if {$Des==""} { continue }
		foreach PfamInfoRef $InfoPfamRef($PfamRef) {
#		    Espionne "PfamInfoRef $PfamInfoRef"
		    if {[info exists InfoFeatureRef ]} { unset InfoFeatureRef  }
		    if {[info exists InfoFeatureName]} { unset InfoFeatureName }
		    if {[info exists AbsFeRef]}      { unset AbsFeRef }
		    if {[info exists AbsFeName]}     { unset AbsFeName }
		    set PosRelNameRFstart ""; set PosRelNameRFstop ""
		    FstartFstop $PfamInfoRef RFstart RFstop
		    set PosRelNameRFstart [PositionRelativeDansAlignement $AbsRef($RFstart)]
		    set PosRelNameRFstop  [PositionRelativeDansAlignement $AbsRef($RFstop)]			    

		    if { ! [info exists InfoPfamName($PfamRef)]} {
#			Espionne "ce Pfam de la ref est absent dans le Name => perdu"
			if {($PosRelNameRFstart == 0 && $PosRelNameRFstop == 0) || ($PosRelNameRFstart == $LongSeqName && $PosRelNameRFstop == $LongSeqName)} {
#			    Espionne "ce Pfam de la ref est avant le debut ou apres la fin du name => tiens pas compte car peut rien dire"
			    set ResultElimine [SiteElimine "Pfam" $PfamInfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) $PosRelNameRFstart $PosRelNameRFstop]
#			    Espionne "ResultElimine $ResultElimine"
			    if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultElimine"}
			    continue 
			}
			set differe 1
			set ResultPerdu [SitePerdu "Pfam" $PfamInfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) $PosRelNameRFstart $PosRelNameRFstop]
#			Espionne "ResultPerdu2 $ResultPerdu"
			if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultPerdu"}
			lappend PerdPfam($Box) $ResultPerdu
		    } else {
#			Espionne "ce Pfam de la ref est present dans le Name"
			set TousAbsents 1 ; set DebOuFin 0
			foreach InfoName $InfoPfamName($PfamRef) {
			    FstartFstop $InfoName Fstart Fstop
			    set AbsFstart [PositionAbsolueDansAlignement $Fstart]
			    set AbsFstop  [PositionAbsolueDansAlignement $Fstop]
#			    Espionne "Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop"
			    if {[Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop]} {
				set PfamInfoGarde $InfoName
				set TousAbsents 0
				if {$Fstart==1 || $Fstop == $LongSeqName} { set DebOuFin 1; break }
				break
			    }
			}

			if { $DebOuFin } {
#			    Espionne "ce Pfam de la ref est au tout debut ou a la fin du name => tiens pas compte car peut rien dire" 
			    FstartFstop $PfamInfoGarde Fstart Fstop
			    set ResultElimine [SiteElimine "Pfam" $PfamInfoGarde $Name  [PositionAbsolueDansAlignement $Fstart] [PositionAbsolueDansAlignement $Fstop]  $Fstart $Fstop]
			    if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultElimine"}
#			    Espionne "ResultElimine $ResultElimine"
			    continue
			}

			if { $TousAbsents } { 
#			    Espionne "ce Pfam de la ref est absent dans le Name mais position differente => perdu"
			    if {($PosRelNameRFstart == 0 && $PosRelNameRFstop == 0) || ($PosRelNameRFstart == $LongSeqName && $PosRelNameRFstop == $LongSeqName)} {
				#ce Pfam de la ref est avant le debut ou apres la fin du name => tiens pas compte car peut rien dire 
				set ResultElimine [SiteElimine "Pfam" $PfamInfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) $PosRelNameRFstart $PosRelNameRFstop]
				if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultElimine"}
#				Espionne "$ResultElimine"
				continue
			    }
			    set differe 1
			    set ResultPerdu [SitePerdu "Pfam" $PfamInfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) $PosRelNameRFstart $PosRelNameRFstop]
#			    Espionne "ResultPerdu3 $ResultPerdu"
			    if {$WithWhat=="Block"} {lappend LesLignesFic "$ResultPerdu"}
			    lappend PerdPfam($Box) $ResultPerdu
			} 

			if { !$TousAbsents } {
			    set differeFeDsPf 0
#			    Espionne "ce Pfam de la ref est present dans le Name a la meme position => garde"
			    #le recupere dans $PfamInfoGarde
			    set LesLignesFicProv {}; set Precedent ""
			    if {[info exists FeSuivantDsRef]}  { unset FeSuivantDsRef }
			    if {[info exists CorresFeRefName]} { unset CorresFeRefName }
			    
			    
			    FstartFstop $PfamInfoGarde Fstart Fstop
			    set PosAbsFstart [PositionAbsolueDansAlignement $Fstart]
			    set PosAbsFstop [PositionAbsolueDansAlignement $Fstop]
			    set ResultGarde [SiteGarde "Pfam" $PfamInfoGarde $Name  $PosAbsFstart $PosAbsFstop $Fstart $Fstop]
			    
			    scan $PfamInfoGarde "%s" PfamNameGarde
			    set PfamNameGarde [string toupper $PfamNameGarde]
			    regsub -nocase {^PROP_} $PfamNameGarde "" PfamNameGarde
			    set PfamInfoGardeComp "$PfamNameGarde/$PosAbsFstart-$PosAbsFstop/$Fstart-$Fstop"

			    PositionAbsolueDansAlignement 1 $SeqDataRef
			    set quisuis RefFe
			    set LesFeDuPfRef $FeaturesDesPfamInfoRef($PfamInfoRef)
			    set LePremier 1
			    foreach FeDuPfRef $LesFeDuPfRef {
				lassign [split $FeDuPfRef " "] FeRef FeRefDeb FeRefFin
				lappend InfoFeatureRef($FeRef) $FeDuPfRef
				set AbsFeRef($FeRefDeb)  [PositionAbsolueDansAlignement $FeRefDeb]
				set AbsFeRef($FeRefFin)  [PositionAbsolueDansAlignement $FeRefFin]
				if {$WithWhat=="Block"} {
				    if {$LePremier} {set LePremier 0; set Precedent $FeDuPfRef; continue}
				    set FeSuivantDsRef($Precedent) $FeDuPfRef
				    set Precedent $FeDuPfRef
				}
			    }
			    if {$WithWhat=="Block" && $Precedent !=""} {
				set FeSuivantDsRef($Precedent) ""
			    }
			  
			    PositionAbsolueDansAlignement 1 $SeqDataName
			    set quisuis NameFe
			    set LesFeDuPfName $FeaturesDesPfamInfoName($PfamInfoGarde)
			    foreach FeDuPfName $LesFeDuPfName {
				lassign [split $FeDuPfName " "] FeName FeNameDeb FeNameFin
				lappend InfoFeatureName($FeName) $FeDuPfName
				set AbsFeName($FeNameDeb)  [PositionAbsolueDansAlignement $FeNameDeb]
				set AbsFeName($FeNameFin)  [PositionAbsolueDansAlignement $FeNameFin]
			    }
   
			    foreach FeDuPfRef $LesFeDuPfRef {
				lassign [split $FeDuPfRef " "] FeRef FeRefDeb FeRefFin
#				Espionne "FeDuPfRef $FeDuPfRef"
				#ce Feature du Pfam de la ref est elimine car le Pfam du name est plus petit que le Pfam de la ref et donc les Fe de la ref non contenus dans le Pfam du name ne sont pas perdu => tiens pas compte 
				if { ! [Recouvrement $AbsFeRef($FeRefDeb) $AbsFeRef($FeRefFin) $PosAbsFstart $PosAbsFstop]} {continue}
				if { ! [info exists InfoFeatureName($FeRef)]} {
				    #ce Feature du Pfam de la ref est elimine car le debut ou la fin de la sequence se trouve dans ce Fe => tiens pas compte
				    if { $AbsFeRef($FeRefDeb) <= $AbsNameFin && $AbsNameFin < $AbsFeRef($FeRefFin)} {continue}
				    if { $AbsFeRef($FeRefDeb) <= $AbsNameDeb && $AbsNameDeb < $AbsFeRef($FeRefFin)} {continue}
#				    Espionne "ce Feature du Pfam de la ref est absent dans le Name => perdu"
				    set differe 1; set differeFe 1; set differeFeDsPf 1
				    set ResultFeaturePerdu [SitePerdu $WithWhat $FeRef $Name $AbsFeRef($FeRefDeb) $AbsFeRef($FeRefFin) [PositionRelativeDansAlignement $AbsFeRef($FeRefDeb)]  [PositionRelativeDansAlignement $AbsFeRef($FeRefFin)] $PfamInfoGardeComp]
#				    Espionne "ResultFeaturePerdu $ResultFeaturePerdu"
				    lappend LesLignesFicProv $ResultFeaturePerdu
				    lappend PerdFeDsPfam($Box) $ResultFeaturePerdu
				} else {
#				    Espionne "ce Feature du Pfam de la ref est present dans le Name"
				    set TousAbsentsFe 1
				    foreach FeDuPfName $InfoFeatureName($FeRef) {
					lassign [split $FeDuPfName " "] FeName FeNameDeb FeNameFin
					if {[Recouvrement $AbsFeRef($FeRefDeb) $AbsFeRef($FeRefFin) $AbsFeName($FeNameDeb) $AbsFeName($FeNameFin)]} {
					    set FeDuPfNameGarde $FeDuPfName
					    set CorresFeRefName($FeDuPfRef) $FeDuPfName
					    set TousAbsentsFe 0
					    break
					}
				    }
				    if { $TousAbsentsFe } {
					#ce Feature du Pfam de la ref est elimine car le debut ou la fin de la sequence se trouve dans ce Fe => tiens pas compte
					if { $AbsFeRef($FeRefDeb) <= $AbsNameFin && $AbsNameFin < $AbsFeRef($FeRefFin)} {continue}
					if { $AbsFeRef($FeRefDeb) <= $AbsNameDeb && $AbsNameDeb < $AbsFeRef($FeRefFin)} {continue}
#					Espionne "ce Feature du Pfam de la ref est present dans le Name mais position differente => perdu" 
					set differe 1; set differeFe 1; set differeFeDsPf 1
					set ResultFeaturePerdu2 [SitePerdu $WithWhat $FeRef $Name $AbsFeRef($FeRefDeb) $AbsFeRef($FeRefFin)  [PositionRelativeDansAlignement $AbsFeRef($FeRefDeb)]  [PositionRelativeDansAlignement $AbsFeRef($FeRefFin)] $PfamInfoGardeComp]
#					Espionne "ResultFeaturePerdu2 $ResultFeaturePerdu2"
					lappend LesLignesFicProv $ResultFeaturePerdu2
					lappend PerdFeDsPfam($Box) $ResultFeaturePerdu2
				    } 
    
				    if { ! $TousAbsentsFe } {
#					Espionne "ce Feature du Pfam de la ref est present dans le Name a la meme position => garde"
					lassign [split $FeDuPfNameGarde " "] FeName FeNameDeb FeNameFin
					set LongFeDuPfRef [expr ($FeRefFin - $FeRefDeb) + 1]
					set LongFeDuPfName [expr ($FeNameFin - $FeNameDeb) + 1]
					set DiffLong [expr $LongFeDuPfRef-$LongFeDuPfName]
					#ce Feature du Pfam de la ref est elimine car ce Name (sa sequence) commence ou se finit dans le feature et ce feature commence plus tôt ou se finit plus tard dans la ref, donc il manquera un fragment (avant le debut ou apres la fin de la sequence du Name) => sait pas si vraiment manquant ou pb sequencage; peut rien conclure tiens pas compte (ex: SPR0429 en Cter et SPM1041 en Nter) 
					if {$FeNameDeb==1 && $AbsFeRef($FeRefDeb)<$AbsFeName($FeNameDeb)} {continue}
					if {$FeNameFin==$LongSeqName && $AbsFeRef($FeRefFin)>$AbsFeName($FeNameFin)} {continue}
					if {$LongFeDuPfRef > $LongFeDuPfName +3} { 
#					    Espionne "on perd un fragement dans ce Feature => perdu"
					    set differe 1; set differeFe 1; set differeFeDsPf 1
					    set ResultFragmentPerdu [SitePerdu "Fragment" "Fragment ($DiffLong) dans $FeName" $Name $AbsFeName($FeNameDeb) $AbsFeName($FeNameFin) $FeNameDeb $FeNameFin $PfamInfoGardeComp]
#					    Espionne "$ResultFragmentPerdu"
					    lappend LesLignesFicProv $ResultFragmentPerdu
					    lappend PerdFragmentDsFeDsPfam($Box) $ResultFragmentPerdu
					}
				    } 
				}
			    }
			    if {$differeFeDsPf} {
				#lappend LesLignesFic $ResultGarde
				LConcat LesLignesFic $LesLignesFicProv
			    }	
			    if {$WithWhat=="Block"} {
				#Espionne "regarde trous entre 2 blocks"
				foreach FeDuPfRef $LesFeDuPfRef {
#				    Espionne "FeDuPfRef $FeDuPfRef"
				    lassign [split $FeDuPfRef " "] Bidon FeDuPfRefDeb FeDuPfRefFin

				    if {![info exists CorresFeRefName($FeDuPfRef)]} {break}
				    set FeDuPfNameCorres $CorresFeRefName($FeDuPfRef)
				    lassign [split $FeDuPfNameCorres " "] FeDuPfNameCorresId FeDuPfNameCorresDeb FeDuPfNameCorresFin
				    
				    set FeSuivantDuPfRef $FeSuivantDsRef($FeDuPfRef)
				    if {$FeSuivantDuPfRef== ""} {break}
				    lassign [split $FeSuivantDuPfRef " "] Bidon FeSuivantDuPfRefDeb FeSuivantDuPfRefFin
				    
				    if {![info exists CorresFeRefName($FeSuivantDuPfRef)]} {break}
				    set FeSuivantDuPfNameCorres $CorresFeRefName($FeSuivantDuPfRef)
				    lassign [split $FeSuivantDuPfNameCorres " "] FeSuivantDuPfNameCorresId FeSuivantDuPfNameCorresDeb FeSuivantDuPfNameCorresFin
			
				    set DistanceEntreLesPfRef  [expr ($AbsFeRef($FeSuivantDuPfRefDeb)-$AbsFeRef($FeDuPfRefFin))-1]
				    set DistanceEntreLesPfName [expr ($AbsFeName($FeSuivantDuPfNameCorresDeb)-$AbsFeName($FeDuPfNameCorresFin))-1]
				    set DiffDistance [expr $DistanceEntreLesPfName - $DistanceEntreLesPfRef]
				    if {$DistanceEntreLesPfName > $DistanceEntreLesPfRef +3} { 
					set differe 1; set differeFe 1; set differeFeDsPf 1
					#on perd un fragment entre ce Feature garde et le suivant => perdu
					set ResultFragmentPerdu [SitePerdu "Fragment" "Fragment ($DiffDistance) entre $FeDuPfNameCorresId $FeSuivantDuPfNameCorresId" $Name $AbsFeName($FeDuPfNameCorresFin) $AbsFeName($FeSuivantDuPfNameCorresDeb) $FeDuPfNameCorresFin $FeSuivantDuPfNameCorresDeb $PfamInfoGardeComp]
					lappend LesLignesFic $ResultFragmentPerdu
					lappend PerdFragmentEntreFeDsPfam($Box) $ResultFragmentPerdu
				    }
				}
			    }
			}
		    }
		}
	    }
	    if {!$differe && $WithWhat=="Block"} {
		lappend LesLignesFic "$Name rien d'important"
	    }
	    if {!$differeFe && $WithWhat=="Prosite"} {
		lappend LesLignesFic "$Name rien d'important"
	    }
	}
	if {$WithWhat=="Block"} {
	    SauveLesLignes $LesLignesFic dans "$RepertoireOut/$Box"
	}
	if {$WithWhat=="Prosite"} {   
	    AppendAuFichier "$RepertoireOut/$Box" [join $LesLignesFic "\n"]
	}
    }

    foreach Clef [lsort [array names GagnePfam]] {
	lappend LesLignesGagnePfam "$Clef:"
	set LesValeurs [ListeSansDoublon $GagnePfam($Clef)]
	foreach Valeur $LesValeurs {
	    lappend LesLignesGagnePfam $Valeur
	}
    }
    lappend LesLignesGagnePfam  "nbtotal : [array size GagnePfam]"
    if {$WithWhat=="Block"} {
	SauveLesLignes $LesLignesGagnePfam dans "$RepertoireOutFile/${Org}GagnePfam"
	#NucAcBind
    }

    foreach Clef [lsort [array names PerdPfam]] {
	lappend LesLignesPerdPfam "$Clef:"
	set LesValeurs [ListeSansDoublon $PerdPfam($Clef)]
	foreach Valeur $LesValeurs {
	    lappend LesLignesPerdPfam $Valeur
	}
    }
    lappend LesLignesPerdPfam  "nbtotal : [array size PerdPfam]"
    if {$WithWhat=="Block"} {
	SauveLesLignes $LesLignesPerdPfam dans "$RepertoireOutFile/${Org}PerdPfam"
    }
    
    foreach Clef [lsort [array names PerdFeDsPfam]] {
	lappend LesLignesPerdFeDsPfam "$Clef:"
	set LesValeurs [ListeSansDoublon $PerdFeDsPfam($Clef)]
	foreach Valeur $LesValeurs {
	    lappend LesLignesPerdFeDsPfam $Valeur
	}
    }
    lappend LesLignesPerdFeDsPfam "nbtotal : [array size PerdFeDsPfam]"
    SauveLesLignes $LesLignesPerdFeDsPfam dans "$RepertoireOutFile/${Org}Perd${WithWhat}DsPfam"

    foreach Clef [lsort [array names PerdFragmentEntreFeDsPfam]] {
	lappend LesLignesPerdFragmentEntreFeDsPfam "$Clef:"
	set LesValeurs [ListeSansDoublon $PerdFragmentEntreFeDsPfam($Clef)]
	foreach Valeur $LesValeurs {
	    lappend LesLignesPerdFragmentEntreFeDsPfam $Valeur
	}
    }
    lappend LesLignesPerdFragmentEntreFeDsPfam "nbtotal : [array size PerdFragmentEntreFeDsPfam]"
    if {$WithWhat=="Block"} {
	SauveLesLignes $LesLignesPerdFragmentEntreFeDsPfam dans "$RepertoireOutFile/${Org}PerdFragmentEntre${WithWhat}DsPfam"
    }

    foreach Clef [lsort [array names PerdFragmentDsFeDsPfam]] {
	lappend LesLignesPerdFragmentDsFeDsPfam "$Clef:"
	set LesValeurs [ListeSansDoublon $PerdFragmentDsFeDsPfam($Clef)]
	foreach Valeur $LesValeurs {
	    lappend LesLignesPerdFragmentDsFeDsPfam $Valeur
	}
    }
    lappend LesLignesPerdFragmentDsFeDsPfam "nbtotal : [array size PerdFragmentDsFeDsPfam]"
    SauveLesLignes $LesLignesPerdFragmentDsFeDsPfam dans "$RepertoireOutFile/${Org}PerdFragmentDs${WithWhat}DsPfam"


}

proc BilanPerteGainPfamAideParentheses {} {

    foreach Box [ListeDesPABs] {	
	foreach Name $LesNames {
	    foreach PfamRef $LesPfamRef {
		foreach PfamInfoRef $InfoPfamRef($PfamRef) {
		    if { ! [info exists InfoPfamName($PfamRef)]} {
#			Espionne "ce Pfam de la ref est absent dans le Name => perdu"
		    } else {
#			Espionne "ce Pfam de la ref est present dans le Name"
			if { $DebOuFin } {
#			    Espionne "ce Pfam de la ref est au tout debut ou a la fin du name => tiens pas compte car peut rien dire" 
			}
			if { $TousAbsents } { 
#			    Espionne "ce Pfam de la ref est absent dans le Name mais position differente => perdu"
			} 
			if { !$TousAbsents } {	
#			    Espionne "ce Pfam de la ref est present dans le Name a la meme position => garde"
			    foreach FeDuPfRef $LesFeDuPfRef {
				if { ! [info exists InfoFeatureName($FeRef)]} {
#				    Espionne "ce Feature du Pfam de la ref est absent dans le Name => perdu"
				} else {
#				    Espionne "ce Feature du Pfam de la ref est present dans le Name"
				    if { $TousAbsentsFe } {
#					Espionne "ce Feature du Pfam de la ref est present dans le Name mais position differente => perdu" 
					set differe 1; set differeBlock 1
				    } 
    
				    if { ! $TousAbsentsFe } {
#					Espionne "ce Feature du Pfam de la ref est present dans le Name a la meme position => garde"
				    } 
				}
			    }
			    if {$differeBlock} {
				#lappend LesLignesFic $ResultGarde
				LConcat LesLignesFic $LesLignesFicProv
			    }	
			    if {$WithWhat=="Block"} {
				#Espionne "regarde trous entre 2 blocks"
			    }
			} 
			#Fin de if { !$TousAbsents } 
		    }
		    #Fin de else
		}
		#Fin de foreach PfamInfoRef $InfoPfamRef($PfamRef)
	    }
	    #Fin de foreach PfamRef $LesPfamRef
	    if {!$differe && $WithWhat=="Block"} {
		lappend LesLignesFic "$Name rien d'important"
	    }
	    if {!$differeBlock && $WithWhat=="Prosite"} {
		lappend LesLignesFic "$Name rien d'important"
	    }
	}
	#Fin de foreach Name $LesNames
	if {$WithWhat=="Block"} {
	    SauveLesLignes $LesLignesFic dans "$RepertoireOut/$Box"
	}
	if {$WithWhat=="Prosite"} {   
	    AppendAuFichier "$RepertoireOut/$Box" [join $LesLignesFic "\n"]
	}
    }
    #Fin de foreach Box [ListeDesPABs]

}

proc BilanPfamFrom1500 {} {

    set i 0
    set File "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromDes/PfamDesFrom1500.txt"
    foreach Ligne [LesLignesDuFichier $File] {
	set Des [lindex [split $Ligne "\t"] 2]
	if {[regexp "binding" $Des]} {
#&& [regexp "DNA" $Des]
	    Espionne "$Ligne"
	    incr i
	}
    }
    Espionne "$i"
    #71  BindingPfam sur 964 dans mes 1500 sequences  (g17/SpliRetMouse2008 + g17/SpliRetRat2008)
    #88  BindingPfam sur 1123 dans mes 1585 clusters  (g20/SpliRetMouse2009 + g20/SpliRetRat2009)
    #276 BindingPfam sur 3674 dans mes 15765 clusters (g23/SpliRetMouse + g23/SpliRetRat)

}

proc BilanPfamFrom1500InGo {} {

    set LesPfam [InterrogePfamDesFrom1500 ListOf Pfam]
    #964 PFAM
    set aGo 0
    foreach Pfam $LesPfam {
	#Espionne ""
	#Espionne "$Pfam"
	set Go [GoGetFromPfam $Pfam GOacc]
	#Espionne "LesGo: $Go"
	set LesResults {}
	if {$Go!=""} {
	    incr aGo
	    set LesGo [split $Go " "]
	    foreach GoSeule $LesGo {
		set MainGo [GoChildren GO:0003674 acc]
		set allParents [GoGetFromGo $GoSeule GOacc "" "" Up]
		set ListResult [ListsIntersection $MainGo $allParents]
		#Espionne "$GoSeule: $ListResult"
		LConcat LesResults $ListResult
	    }
	}
	set LesResults [ListeSansDoublon $LesResults]
	#Espionne "LesResults $LesResults" 
	foreach Result $LesResults {
	    if {[info exists DejaVu($Result)]} {
		incr DejaVu($Result)
	    } else {
		set DejaVu($Result) 1
	    }
	}
    }
    #489 PFAM ont un GO
    Espionne "nbPfamAcGo $aGo"
    foreach Clef [array names DejaVu] {
	Espionne "$Clef [GoGetFromGo $Clef GOname " " " " Here]\t$DejaVu($Clef)"
    }

}

proc BilanProt {pdbid {aTInf ""}} {

    global organism

    # compatibilite threading
    if {$aTInf ne ""} {
	array set TInf $aTInf
    } else {
	global TInf
    }
    
    if {! [info exists $organism]} {
	file mkdir $organism
    } else {
	file delete {*}[glob [file join $organism *]]
    }

    set fout [open [file join $organism $pdbid] w]
    puts $fout "
"
    
    set Lcanal [list "$fout" stdout]
    foreach cnl $Lcanal {
	puts $cnl "\n-----------------------"
	puts $cnl "| PDB : $pdbid"
	puts $cnl "-----------------------"
	foreach c $TInf($pdbid,LChains) {
	    if {! $TInf($pdbid,$c,ok)} {continue}
	    
	    puts $cnl "Chain : $c"
	    set spdn [set TInf($pdbid,$c,seqpdnal)]
	    set sunp [set TInf($pdbid,$c,sequnpal)]
	    set sres [set TInf($pdbid,$c,seqresal)]
	    set spdb [set TInf($pdbid,$c,seqpdbal)]
	    set ssec [set TInf($pdbid,$c,sSS)]
	    set srsa [set TInf($pdbid,$c,seqrsa)]
	    set snac [set TInf($pdbid,$c,seqnac)]
	    # plus long est seq traduite
	    set lgt [string length $spdn]
	    for {set i 0} {$i < $lgt} {incr i 50} {
		puts $cnl [format %4d [expr {$i+1}]]
		puts $cnl "strd [string range $spdn $i $i+49]"
		puts $cnl "sunp [string range $sunp $i $i+49]"
		puts $cnl "sres [string range $sres $i $i+49]"
		puts $cnl "spdb [string range $spdb $i $i+49]"
		puts $cnl "ssec [string range $ssec $i $i+49]"
		puts $cnl "srsa [string range $srsa $i $i+49]"
		puts $cnl "snac [string range $snac $i $i+49]"
		puts $cnl ""
	    }
	}
    }
    puts $fout "
"
    close $fout
    
    return

}

proc BindBulle {} {


    global Bulle

    bind Bulle  {
	set Bulle(set) 0
	set Bulle(first) 1
	set Bulle(id) [after 500 {balloon %W $Bulle(%W) %X %Y}]
    }
    
    bind Bulle  {
	set Bulle(first) 0
	kill_balloon
    }
    
    bind Bulle  {
	set Bulle(first) 0
	kill_balloon
    }
    
    bind Bulle  {
	if {$Bulle(set) == 0} {
	    after cancel $Bulle(id)
        set Bulle(id) [after 500 {balloon %W $Bulle(%W) %X %Y}]
	}
    }

}

proc BindDeplace {w x y} {


    if {[$w curvalue] eq ""} {return}
    set n [TamponNFois vide]
    lassign [split [$w index active] ,] r c

    set nx [expr {$n*$x}]
    set ny [expr {$n*$y}]
    set cell "[expr {$r+${ny}}],[expr {$c+${nx}}]"

    $w configure -state normal

    $w activate $cell
    $w selection clear all
    $w selection set active

    $w configure -state disabled

    $w xview scroll ${nx} units
    CoupleY scroll "${ny}" units

    return

}

proc BindLaRosace {R} {

	$R bind "Zone"      <1>               "GereLesZoneEtiquettee $R %x %y arc Point"
	$R bind "Zone"             "GereLesZoneEtiquettee $R %x %y arc Motion"
	$R bind "Zone"       "GereLesZoneEtiquettee $R %x %y arc Relache"
	$R bind "Zone"      <2>               "GereLesZoneEtiquettee $R %x %y arc Erase"
	$R bind "Zone"      <3>               "GereLesZoneEtiquettee $R %x %y arc ModifCouleur"
	$R bind "Zone"               "GereLesZoneEtiquettee $R %x %y arc ModifTaille"
	$R bind "Zone"             "GereLesZoneEtiquettee $R %x %y arc ModifSens"
								    
	$R bind "Fleche"    <1>               "GereLesZoneEtiquettee $R %x %y line Point"
	$R bind "Fleche"           "GereLesZoneEtiquettee $R %x %y line Motion"
	$R bind "Fleche"     "GereLesZoneEtiquettee $R %x %y line Relache"
	$R bind "Fleche"    <2>               "GereLesZoneEtiquettee $R %x %y line Erase"
	$R bind "Fleche"    <3>               "GereLesZoneEtiquettee $R %x %y line ModifCouleur"
	$R bind "Fleche"             "GereLesZoneEtiquettee $R %x %y line ModifTaille"
	$R bind "Fleche"           "GereLesZoneEtiquettee $R %x %y line ModifSens"
								    
	$R bind "Etiquette" <1>               "GereLesZoneEtiquettee $R %x %y text Point"
	$R bind "Etiquette"        "GereLesZoneEtiquettee $R %x %y text Motion"
	$R bind "Etiquette"  "GereLesZoneEtiquettee $R %x %y text Relache"
	$R bind "Etiquette" <2>               "GereLesZoneEtiquettee $R %x %y text Erase"
	$R bind "Etiquette" <3>               "GereLesZoneEtiquettee $R %x %y text ModifCouleur"
	$R bind "Etiquette"          "GereLesZoneEtiquettee $R %x %y text ModifTaille"
	$R bind "Etiquette"        "GereLesZoneEtiquettee $R %x %y text ModifTexte"

	$R bind "TexteRosace" <1>               "GereLesZoneEtiquettee $R %x %y text Point"
	$R bind "TexteRosace"        "GereLesZoneEtiquettee $R %x %y text Motion"
	$R bind "TexteRosace"  "GereLesZoneEtiquettee $R %x %y text Relache"
	$R bind "TexteRosace" <2>               "GereLesZoneEtiquettee $R %x %y text Erase"
	$R bind "TexteRosace" <3>               "GereLesZoneEtiquettee $R %x %y text ModifCouleur"
	$R bind "TexteRosace"          "GereLesZoneEtiquettee $R %x %y text ModifTaille"
	$R bind "TexteRosace"        "GereLesZoneEtiquettee $R %x %y text ModifTexte"

}

proc BindMenuItems {} {

    set tw [winfo toplevel $::NomFenetreOrdali]

    # Modes
    bind $tw  {FromMenu %W seqlab}
    bind $tw  {FromMenu %W superpose}
    bind $tw  {FromMenu %W arbres}
    bind $tw  {FromMenu %W cluster}
    bind $tw  {FromMenu %W conservation}
    bind $tw  {FromMenu %W feature}
    bind $tw  {FromMenu %W search}
    bind $tw  {FromMenu %W donnepci}

    return

}

proc BindModeColors {} {

    set Ls [bindtags $::TScrollX]
    set Ls [linsert $Ls 1 BScCols]
    bindtags $::TScrollX $Ls

    set Ls [bindtags $::TScrollY]
    set Ls [linsert $Ls 1 BScCols]
    bindtags $::TScrollY $Ls

    set Lt [bindtags $::NomTextSeq]
    set Lt [linsert $Lt 1 BColors BTxCols]
    bindtags $::NomTextSeq $Lt

    set Lt [bindtags $::NomNomSeq]
    set Lt [linsert $Lt 1 BColors]
    bindtags $::NomNomSeq $Lt

    return

}

proc BindModeNormal {} {

    set LNTags [list $::NomNomSeq BFocus BNSel BWhN BFont $::NomFenetreOrdali . all]
    set LSTags [list $::NomTextSeq BFocus BTStatus BNum BWhS BFont $::NomFenetreOrdali . all]
    if {[TypeAli] in {"XML" "ORD"}} {
	set LNTags [linsert $LNTags 1 BNLab]
	set LSTags [linsert $LSTags 1 BTLab]
    }
    bindtags $::NomNomSeq  $LNTags
    bindtags $::NomTextSeq $LSTags

    # Sauvegarde
    #bind .  [list SauveLAlignement]

    $::NomTextSeq tag delete Marque
    update idletasks

    return

}

proc BindModeSelection {} {

    $::NomTextSeq configure -state normal

    $::NomTextSeq tag configure Marque -background black -foreground black

    set lt [bindtags $::NomTextSeq]
    set lt [linsert $lt 1 BTSel]
    bindtags $::NomTextSeq $lt

    $::NomTextSeq configure -state disabled

    return

}

proc BindModeSeqlab {} {

    #set lt [bindtags $::NomTextSeq]
    set lt [list $::NomTextSeq Biotext BFocus BTStatusSL BNum BWhS BTSeqlab BFont $::NomFenetreOrdali . all]
    bindtags $::NomTextSeq $lt

    bindtags $::NomNomSeq [list $::NomNomSeq BFocus BNSel BWhN BFont . all]

    # Sauvegarde
    bind all  {SauveTempSeqlab}
    update idletasks

    return

}

proc BindRankToTaxaItem {} {

    set PAD $::Tx(PAD)
    set LId [$PAD find withtag LNode]
    foreach Id $LId {
	foreach t [$PAD gettags $Id] {
	    if {[regexp {(N|R)[0-9]+} $t]} {
		set n [string range $t 1 end]
		break
	    }
	}
	set Rank $::Tx(Rank,$n)
	InitBalloonOnItem $PAD $Id $Rank
    }
    
    return

}

proc BindSeqB1 {w x y} {


    SelectNomSeq "une" "@$x,$y"

    return

}

proc BindSvg {args} {

    return 

}

proc BindTextKey {w k} {

    set idx [$w cursor]
    lassign [split $idx .] y x
    set y [expr {$y-1}]
    if {[lindex $::LNSeqlab $y] eq ""} {return}

    $w chars $k $idx [tk::biotext::bufferNTimes empty]
    
    set Ns [list]
    foreach s [$w output all] {
	lappend Ns [split $s ""]
    }
    set ::LSSeqlab $Ns
    
    InitWRegle
    AfficheRegle

    update idletasks

    return

}

proc BindTextShiftLeft {w} {


    set n [TamponNFois vide]

    for {set i 0} {$i < $n} {incr i} {
	PousseAGauche
    }

    return

}

proc BindTextShiftRight {w} {


    set n [TamponNFois vide]
    for {set i 0} {$i < $n} {incr i} {
	PousseADroite
    }

    return

}

proc BindTextSpace {w {NoGroup ""}} {

    set idx [$w cursor]
    lassign [split $idx .] y x
    set y [expr {$y-1}]

    set seqass [lindex $::LNSeqlab $y]
    if {$seqass eq ""} {return}

    set nf [tk::biotext::bufferNTimes empty]
    if {$NoGroup eq ""} {
	$w chars "." $idx $nf
    } else {
	$w chars -nogroup "." $idx $nf
    }
    
    set Ns [list]
    foreach s [$w output all] {
	lappend Ns [split $s ""]
    }
    set ::LSSeqlab $Ns
    
    InitWRegle
    AfficheRegle

    update idletasks

    return

}

proc BindingPfamDesFromGo {} {

    #set LesBindingPfamFromGo [GoGetFromGo GO:0005488 PFAM "" "" "Down"]
    set LesBindingPfamFromGo [GoGetFromGo GO:0003676 PFAM "" "" "Down"]
    set longPfam [llength $LesBindingPfamFromGo]
    foreach Pfam $LesBindingPfamFromGo {
	#Espionne "$Pfam"
	set Commande "getz \"\\\[pfama-acc:$Pfam\\\]\" \-vf des"
	set Result [eval exec $Commande]
	set Ligne "$Pfam\t$Result"
	#Espionne "$Ligne"
	lappend LesLignes $Ligne
    }
    #SauveLesLignes $LesLignes dans "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/BindingPfamDesFromGo.txt"
    SauveLesLignes $LesLignes dans "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/NucleicAcidBindingPfamDesFromGo.txt"
    #1494 BindingPfamFromGo (Avril 2009)
    #1493 BindingPfamFromGo (Nov   2011)
       #533  NucleicAcidBindingPfamFromGo (Nov 2011) 

}

proc BindingsFeatEditor {} {

    global EFeat NomTextSeq

    set EFeat(PosInit) ""

    # Edit feature
    bind BEFEdit <1>         {EditFeatureItem seq @%x,%y ; break}
    bind BEFEdit  {EditFeatureItem group @%x,%y ; break}
    bind BEFEdit    {EditFeatureItem all @%x,%y ; break}

    # Delete ITEM
    #bind BEFDelete <1> {DeleteFeatItem seq @%x,%y ; break}
    #bind BEFDelete  {DeleteFeatItem group @%x,%y ; break}
    #bind BEFDelete  {DeleteFeatItem all @%x,%y ; break}

    # Delete FEATURE
    bind BEFDelfeat <1> {DeleteFeature seq @%x,%y ; break}
    bind BEFDelfeat  {DeleteFeature group @%x,%y ; break}
    bind BEFDelfeat  {DeleteFeature all @%x,%y ; break}

    # select item
    bind BEFSelitem <1>         {SelectItemFeatureForEditing seq @%x,%y ; break}
    bind BEFSelitem  {SelectItemFeatureForEditing group @%x,%y ; break}
    bind BEFSelitem    {SelectItemFeatureForEditing all @%x,%y ; break}

    # select ALL items
    bind BEFSelitall <1> {SelectAllItemFeatureForEditing seq @%x,%y ; break}
    bind BEFSelitall  {SelectAllItemFeatureForEditing group @%x,%y ; break}
    bind BEFSelitall  {SelectAllItemFeatureForEditing all @%x,%y ; break}

    # select region
    bind BEFSelreg  [list SelectSeqRegion @%x,%y stock]
    bind BEFSelreg  [list SelectSeqRegion @%x,%y motion seq]
    bind BEFSelreg  [list SelectSeqRegion @%x,%y seq]

    bind BEFSelreg  {SelectSeqRegion @%x,%y stock group ; break}
    bind BEFSelreg  {SelectSeqRegion @%x,%y motion group ; break}
    bind BEFSelreg  {SelectSeqRegion @%x,%y group ; break}

    bind BEFSelreg  {SelectSeqRegion @%x,%y stock all ; break}
    bind BEFSelreg  {SelectSeqRegion @%x,%y motion all ; break}
    bind BEFSelreg  {SelectSeqRegion @%x,%y all ; break}

    # Propagate
    # an item
    bind BEFPropi  {ExtendFeatTo item group @%x,%y ; break}
    bind BEFPropi  {ExtendFeatTo item all @%x,%y ; break}
    # a feature
    bind BEFPropf  {ExtendFeatTo all group @%x,%y ; break}
    bind BEFPropf <1> {ExtendFeatTo all all @%x,%y ; break}

    return

}

proc BindingsOrdali {} {

    global Defauts PosInitNom NomNomSeq NomTextSeq tcl_platform NomFenetreOrdali

    # Always active
    bind BFocus  {focus %W}
    bind all  {AdieuOrdali}

    # labels
    # names : description
    bind BNLab  {ShowDescription @%x,%y}
    bind BNLab   {ShowDescription -1.-1}
    bind BNLab  [list ShowLongInfoSeq "%x,%y"]
    bind BNLab  [list ShowLongInfoSeq -1,-1]

    # On text, show tags, pointer location
    bind BTLab  [list ShowFeature @%x,%y]
    bind BTLab   [list ShowFeature @%x,%y 0]
    bind BTLab  [list ChangeFeatAffOrder @%x,%y]

    $NomTextSeq mark set current  0.0

    # Couper/Copier/Coller
    bind BNSel  CutLesNoms
    bind BNSel  CopyLesNoms
    bind BNSel  PasteLesNoms

    # Selection Noms des Sequences
    bind BNSel <1> {SelectNomSeq "une" "@0,%y"}
    bind BNSel  {SelectNomSeq ctr "@0,%y"}
    bind BNSel     {SelectNomSeq shf "@0,%y"}
    bind BNSel  {SelectNomSeq all "@0,%y"}

    # selection Zone sur alignment
    bind BTSel <1> {StockPosition %W @%x,%y}
    bind BTSel  {DeselectLesColonnes %W @%x,%y}
    bind BTSel <3> {SelectLesColonnes @%x,%y}

    TagsGenerauxFenetre
    
    # Status pos seq - gen
    bind BTStatus  [list AffichePosGenSeq %W @%x,%y]

    # Status pos seq - gen SeqLab MODE !
    bind BTStatusSL  [list AffichePosGenSeqSL %W @%x,%y]

    # focus
    bind BFocus  {focus %W}

    # seqlab colors
    bind BColors <4> [list TagLaFenetre]
    bind BColors <5> [list TagLaFenetre]
    bind BTxCols   [list TagLaFenetre]
    bind BTxCols   [list TagLaFenetre]
    bind BScCols   [list TagLaFenetre]

    # MouseWheel
    # name frame
    if {$::tcl_platform(platform) ne "unix"} {
	bind BWhN  {CoupleY scroll [expr {-%D/120}] units ; break}
    } else {
	bind BWhN <4> {CoupleY scroll -[set Defauts(DeltaYScroll)] units ; break}
	bind BWhN <5> {CoupleY scroll  [set Defauts(DeltaYScroll)] units ; break}
    }
    # sequence frame
    if {$::tcl_platform(platform) ne "unix"} {
	bind BWhS  {CoupleX scroll [expr {-%D/120}] units ; break}
	bind BWhS  {CoupleY scroll [expr {-%D/120}] units ; break}
    } else {
	bind BWhS  {CoupleX scroll -[set Defauts(DeltaXScroll)] units ; break}
	bind BWhS  {CoupleX scroll  [set Defauts(DeltaXScroll)] units ; break}
	bind BWhS <4> {CoupleY scroll -[set Defauts(DeltaYScroll)] units ; break}
	bind BWhS <5> {CoupleY scroll  [set Defauts(DeltaYScroll)] units ; break}
    }
    
    # SEQLAB
    bind BSvSeqlab  SauveTempSeqlab
    # lettres .... Faudra faire diff entre prot et RNA
    bind BTSeqlab  {BindTextSpace %W nogroup}
    bind BTSeqlab  {BindTextSpace %W}
    set Lc [list a c d e f g h i k l m n p q r s t v w x y]
    foreach c $Lc {
	bind BTSeqlab "" {BindTextKey %W %A}
	bind BTSeqlab "" {BindTextKey %W %A}
    }
    
    # taille fontes et ecran
    bind BFont   [list TailleFonte +2]
    bind BFont     [list TailleFonte +2]
    bind BFont    [list TailleFonte +2]
    bind BFont    [list TailleFonte -2]
    bind BFont  [list TailleFonte -2]
    
    # Configure
    set ::AppChangeSize 0
    set ::OldAppW 0 ; set ::OldAppH 0
    #bind $NomFenetreOrdali  {ResizeApp2 %W %w %h}

    # fullscreen, frame seq
    bind $NomFenetreOrdali  ToggleFullScreen
    bind $NomFenetreOrdali  ToggleShowSeqFrame
    bind $NomFenetreOrdali  {puts "fno" ; AdieuOrdali}
    #bindtags $NomFenetreOrdali [list $NomFenetreOrdali . all]

    # Bindings digits - Left/Right/UP/Down arrows
    set ckp [list KP_Insert KP_End KP_Down KP_Next KP_Left KP_Begin KP_Right KP_Home KP_Up KP_Prior]
    set Lc [list 0 1 2 3 4 5 6 7 8 9]
    foreach c $Lc k $ckp {
	bind BNum ""    {bufferNTimes "add" %A}
	bind BNum "" {bufferNTimes "add" %A}
	if {$::tcl_platform(platform) ne "windows" && ! [regexp {^macos} [::platform::generic]] } {
	    bind BNum   {bufferNTimes "add" %A}
	}
    }
    bind BNum   {MoveToPos %W -1  0}
    bind BNum  {MoveToPos %W  1  0}
    bind BNum     {MoveToPos %W  0 -1}
    bind BNum   {MoveToPos %W  0  1}
        
    set ::ZoneSelect [list]
    set ::PosInitNom -1.-1

    return

}

proc BindingsVrp {c t} {


    bind $c    [list SetCenter $c %x %y]
    bind $c    [list SetCenterOfMass $c ]

    bind $c  {%W scan mark %x %y}
    bind $c      {%W scan dragto %x %y 1}
    bind $c <1>             [list HitPointXY $c %x %y]
    bind $c  [list itemStartScale $c %x %y]
    bind $c  [list itemScale $c %x %y]

    bind $c <4>             {%W yview scroll -1 units}
    bind $c <5>             {%W yview scroll  1 units}
    bind $c      {%W xview scroll -1 units}
    bind $c      {%W xview scroll  1 units}

    $t tag bind current <1> [list HighlightChar $t]
    bind $t <1> [list ShowCharOnVrp $t %x %y]
    $t configure -cursor left_ptr

    return

}

proc Bird {Query {Format ""} {Out ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    #nG if {$Out==""} { set Out "GetResult" }BirdSendQueryUrlAndGetFromUrl
    if {$Out==""} { set Out "GetResult" }
    if {[string equal -nocase $Out "GetResult"]} {
	set OutFile "/dev/null"
    } else {
	set OutFile $$Out
    }
    if {$Format==""} { set Format "xml" }
    set GetRootNode 0
    if {[string equal -nocase $Format "documentElement"]} {
	set Format "xml"
	set GetRootNode 1
    }
    set FichierQueryTmp "[TmpFile].sql"
    Sauve $Query dans $FichierQueryTmp
    set FichierQuery $FichierQueryTmp
#rR AFAIRE
#    set Q "http://star4:8080/mybiodb/bsearch?querytext=select%20NAME,%20TXSTART,%20TXEND,%20STRAND%20from%20ucscmouse.refgene%20where%20chrom='chr1'%20and%20txStart%3C=95452457&format=xml"
#rR
    set RetourBird [exec bird_explorer_ucsc $FichierQuery $OutFile format=$Format display=yes]
    if {[info exists FichierQueryTmp] && [file exists $FichierQueryTmp]} {file delete $FichierQueryTmp}

    if {$Format=="xml" && $GetRootNode} {
	package require tdom 
	set RootNode [[dom parse $RetourBird] "documentElement"]
	return $RootNode
    }
    if {$Out=="GetResult"} { return $RetourBird }
    return $OutFile

}

proc BirdEntry {ListeAcOuIds {ListeDBs UNIPROT}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
    package require http

    set url [BirdUrl]
    #rR set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
    #set url "http://d1.crihan.fr:8080/bird/bsearch"
    set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ","]"]
    
    set token [::http::geturl $url -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    set entries {}
    set entryStart 0
    foreach location [regexp -inline -all -indices -line {^//$} $body] {
	foreach {start stop} $location {}
	lappend entries "[string trim [string range $body $entryStart [expr $start - 1]]]\n//\n"
	set entryStart [expr $stop + 1]
    }

    return $entries

}

proc BirdEntryMoi {ListeAcOuIds {ListeDBs UNIPROT}} {

    if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
    package require http

    set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
    #set url "http://d1.crihan.fr:8080/bird/bsearch"
    set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ","]"]
    
    set token [::http::geturl $url -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    set entries {}
    set entryStart 0
    foreach location [regexp -inline -all -indices -line {^//$} $body] {
	foreach {start stop} $location {}
	lappend entries "[string range $body $entryStart [expr $start - 1]]//\n"
	set entryStart [expr $stop + 1]
    }

    return $entries

}

proc BirdEraser {Table {BirdVersion bird} {Database ucschuman}} {

	exec /biolo/bird/bin/bird_pub_empty.sh $BirdVersion "empty" $Database.$Table

}

proc BirdEstDisponible {{Value ""}} {

    global BirdEstDisponible
    if {$Value!=""} { set BirdEstDisponible $Value }
    if { ! [info exists BirdEstDisponible]} { set BirdEstDisponible 0 }
    return $BirdEstDisponible

}

proc BirdFasta {Access} {

    #Access est uniprot
    set Embl [BirdWeb UNIPROT $Access]
    if {$Embl==""} {return ""}
    return [SequenceFormatTFA $Embl "" "embl"]

}

proc BirdFastaOldDeRaymond {ListeAcOuIds {ListeDBs UNIPROT}} {

    if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
    package require http

    set url [BirdUrl]
    #set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
    #rR set url "http://d1.crihan.fr:8080/bird/bsearch"
    
    set query ""
    foreach acOuId $ListeAcOuIds {
	append query "ID $acOuId DB [join $ListeDBs ", "]\nFM FASTA\n//\n"
    }

    #set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ", "]\nFM FASTA"]
    set query [::http::formatQuery "service" "birdql" "query" $query]
    
    set token [::http::geturl $url -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    set entries {}
    set entryStart 0
    foreach location [regexp -inline -all -indices -line {^\s*$} $body] {
	foreach {start stop} $location {}
	set entry "[string trim [string range $body $entryStart [expr $start - 1]]]\n"
	if {[string trim $entry] ne ""} {
	    lappend entries $entry
	}
	set entryStart [expr $stop + 1]
    }

    return $entries

}

proc BirdFetch {FileIn FileOut} {

	exec /biolo/bird/bin/birdql_client.sh $FileIn "bird" $FileOut

}

proc BirdForceHoan {FileIn FileOut} {

	exec /biolo/bird/bin/birdql_client.sh $FileIn bird $FileOut

}

proc BirdFromQueryFile {Fichier {OutFile ""} {BirdUrl ""}} {


    return [BirdFromQueryText [ContenuDuFichier $Fichier] $OutFile $BirdUrl]
#rR reste est obsolete mais marche quand meme On utilise curl
    if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
    set Retour [eval exec curl -stderr /dev/null -F upload=@$Fichier "$BirdUrl/bsearch?service=birdql"]
    if {$OutFile==""} { return $Retour }
    return [Sauve $Retour dans $OutFile] 

}

proc BirdFromQueryText {Texte {OutFile ""} {BirdUrl ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    set Retour [BirdQL $Texte $BirdUrl]
    if {$OutFile==""} { return $Retour }
    return [Sauve $Retour dans $OutFile]

}

proc BirdFromTheBlast {Nom {DB ""} {Qui ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    global BirdFromTheBlast
    if {$Nom=="Reset"} { 
	if {[info exists BirdFromTheBlast]} { unset BirdFromTheBlast }
	return ""
    }
    if {[info exists BirdFromTheBlast($Nom)]} { return $BirdFromTheBlast($Nom) }
    if {$DB==""} { set DB "uniprot" }
    set FichierBlast [GscopeFile $Nom "blastp"]
    if { ! [file exists $FichierBlast]} { return "" }
    DecortiqueBlast $FichierBlast "" "" Query lBanqueId lAccess
    set Query {}
    foreach BanqueId $lBanqueId {
	set BanqueIdOrigine $BanqueId
	regsub -nocase {^Uniref[^\_]+_} $BanqueId "" BanqueId
	#rR a rajouté 2014/11/25
	if {[regexp "\|" $BanqueId]} {
	    set BanqueId [lindex [split $BanqueId "|"] 2]
	}
	set Origine($BanqueId) $BanqueIdOrigine
	lappend LesBanqueId $BanqueId
	lappend Query "ID $BanqueId DB $DB"
	lappend Query "FM FLAT"
    }
    set Query [join $Query "\n"]
    set R [BirdFromQueryText $Query]
    set Id ""
    set LesAc {}
    set LaSeq {}
    foreach Ligne [split $R "\n"] {
	if {[string trim $Ligne]==""} { continue }
	if {[regexp "^//" $Ligne]} {
	    lappend LaSeq $Ligne
	    set Seq [join $LaSeq "\n"]
	    lappend LesSeqDe($Id) $Seq
	    foreach Ac $LesAc {
		lappend LesSeqDe($Ac) $Seq
	    }
	    set Id ""
	    set LesAc {}
	    set LaSeq {}
	    continue
	}
	lappend LaSeq $Ligne
	set IdLu ""
	set LesAcLu ""
	if {[regexp {^ID   ([^ ]+)} $Ligne Match IdLu]} { set Id $IdLu }
	if {[regexp {^AC   (.*)}    $Ligne Match AcLu]} {
	    regsub -all {[ \;]+} $AcLu " " AcLu
	    set LesAc [split [string trim $AcLu " "] " "]
	}
    }
    foreach BanqueId $LesBanqueId {
	if { ! [info exists LesSeqDe($BanqueId)]} {
	    lappend LeResultat [list $BanqueId "NotFound"]
	    continue
	}
	if {[llength $LesSeqDe($BanqueId)]>1} { FaireLire "$BanqueId has more than 1 hits" }
	lappend LeResultat [list $BanqueId [lindex $LesSeqDe($BanqueId) 0]]
    }
    foreach R $LeResultat {
	lassign $R K V
	set BirdFromTheBlast($K) $V 
	set BirdFromTheBlast($Origine($K)) $V 
	
    }
    if {$Qui!=""} { return [BirdFromTheBlast $Qui] }
    return $LeResultat

}

proc BirdGet {NM {Field ""}} {

    if {$Field==""} { set Field "accession" }
    return [BirdGetFields $NM $Field "WithoutField"]

}

proc BirdGetFields {NM {Fields ""} {WithoutField ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    set WithoutField [string equal -nocase $WithoutField "WithoutField"]
    set LesFieldsAAfficher {}
    if {$Fields==""} {
	set Param ""
    } else {
	set FIELDS [string toupper $Fields]
	set LesFieldsDemandes {}
	foreach FieldDemande [split $FIELDS ","] {
	    if {$FieldDemande==""} { continue }
	    if { ! [regexp {^(DBXREF|GO_COMPONENT|GO_FUNCTION|GO_PROCESS)$} $FieldDemande]} {
		lappend LesFieldsDemandes $FieldDemande
	    }
	    set AAfficher($FieldDemande) 1
	    lappend LesFieldsAAfficher $FieldDemande
	}	    
	set Param "&field=[join $LesFieldsDemandes ","]"
    }
    set Tout [HttpGetTextFromUrl "[BirdUrl]/getprotein?db=REFSEQRNA&accession=$NM"]
    set Tout [string trim $Tout " \n\t"]
    set LesBons {}
    set LesClefs {}
    foreach Ligne [split $Tout "\n"] {
	if { ! [regexp {^[^=]+} $Ligne Clef]} {
	    lappend LesBons $Ligne
	    continue
	}
	set CLEF [string toupper $Clef]
	set Valeur [StringSuivant "=" dans $Ligne]
	if { ! [info exists DejaVu($CLEF)]} { lappend LesCLEFS $CLEF ; set DejaVu($CLEF) 1}
	lappend LesValeurs($CLEF) $Valeur
    }
    foreach CLEF $LesFieldsAAfficher {
	set TexteClef "$CLEF="
	if {$WithoutField} { set TexteClef "" }
	if { ! [info exists LesValeurs($CLEF)]} {
	    if {[info exists  AAfficher($CLEF)]} { lappend LesBons "$TexteClef" }
	    continue
	}
	if {[llength $LesValeurs($CLEF)]==1} {
	    if {[info exists  AAfficher($CLEF)]} { lappend LesBons "$TexteClef[string trim [lindex $LesValeurs($CLEF) 0] ";"]" }
	    continue
	}
	set LesBonnesValeurs {}
	foreach Valeur $LesValeurs($CLEF) {
	    regsub -all ";" $Valeur ",," Valeur
	    lappend LesBonnesValeurs $Valeur
	}
	if {[info exists AAfficher($CLEF)]} {
	    lappend LesBons "$TexteClef[join $LesBonnesValeurs ";"]"
	}
    }
    set Bon [join $LesBons "\n"]
    return $Bon

}

proc BirdGscopeKeywords {{BaseGscope ""} {Format ""}} {

    if {$BaseGscope==""} { set BaseGscope [file tail [RepertoireDuGenome]] }
    return [BirdKeywords $BaseGscope $Format]


}

proc BirdGscopeQueries {} {

    set FichierBirdGscopeQueries [Fiches "BirdGscopeQueries.ql"]
    if {[FileAbsent $FichierBirdGscopeQueries]} {
	set BaseGscope [file tail [RepertoireDuGenome]]
	set LaReq {}
	lappend LaReq "ID * DB $BaseGscope"
	lappend LaReq "LM 1"
	lappend LaReq "FM XML"
	set Req [join $LaReq "\n"]
	return $Req
    }
    return [ContenuDuFichier $FichierBirdGscopeQueries]

}

proc BirdGscopeSearch {} {

    set K [AfficheListe [BirdGscopeKeywords] "SetWidth9" "Possible_Keywords"]
    set Queries [BirdGscopeQueries]
    set Req [EntreTexte $Queries]
    if {$Req==""} { return "" }
    set Retour [BirdFromQueryText $Req]
    set Sep [string repeat "*" 80]
    set Texte "Result of following BirdQuery\n$Sep\n$Req\n$Sep\nIf you want to know more, select a Nom:... and press SearchOnBoard\n$Sep\n$Retour"
    set F [AfficheVariable $Texte "AvecBird" "Result_of_BirdGscopeSearch"]
    BoutonneLaFenetre $F "New Bird Search" "BirdGscopeSearch"
    return $F

}

proc BirdKeywords {{BaseBird ""} {Format ""}} {


    if {$Format==""} { set Format "FLAT" }

    set LaReq {}
    lappend LaReq "ID * DB $BaseBird"
    lappend LaReq "LM 1"
    lappend LaReq "FM $Format"
    set Req [join $LaReq "\n"]

    set Tout [BirdFromQueryText $Req]

    set LesClefs {}
    if {$Format == "XML"} {
	set Entry "[string tolower $BaseBird].entry"
	set Avant 1
	foreach Ligne [split $Tout "\n"] {
	    if {$Avant} {
		if { [regexp "<$Entry.*>" $Ligne]} { set Avant 0 }
		continue
	    }
	    if { [regexp {} $Ligne]} { continue }
	    if { [regexp "" $Ligne]} { continue }
	    regsub {>.*} $Ligne "" Clef
	    regsub {<} $Clef "" Clef
	    lappend LesClefs $Clef
	}
    } else {
	foreach Ligne [split $Tout "\n"] {
	    if { ! [regexp -nocase {^[a-z0-9_\-]+} $Ligne Clef]} { continue }
	    lappend LesClefs $Clef
	}
    }
    set LesClefs [lsort -unique $LesClefs]
    return $LesClefs

}

proc BirdLoader {Table DumpFile {BirdVersion bird} {Database ucschuman}} {

	Espionne "/biolo/bird/bin/bird_pub.sh $BirdVersion $Database.$Table $DumpFile '|'"
	exec /biolo/bird/bin/bird_pub.sh $BirdVersion $Database.$Table $DumpFile '|'
	#     /biolo/bird/bin/bird_pub.sh bird ucschuman.alignements

}

proc BirdMetadata {{Qui ""} {Quoi ""}} {

    global BirdMetadata

    if {$Qui==""} {
	set Qui "ListOf"
	set Quoi "BankType"
    }

    if {[info exists BirdMetadata($Qui,$Quoi)]} { return $BirdMetadata($Qui,$Quoi) }
    if {[info exists BirdMetadata("EstCharge")]} { return "" }
    set BirdMetadata("EstCharge") 1
#    set MetadataUrl "[BirdUrl]/bsearch?service=metadata&db=all"
#    set MetadataUrl "http://bird.u-strasbg.fr:8080/bird/temp/metadata.xml"
    set MetadataUrl "[BirdUrl]/temp/metadata.xml"
    set Metadata [HttpGetTextFromUrl $MetadataUrl]
    set XML $Metadata
    set Id  [dom parse $XML]
    set Root [$Id documentElement]


    set BirdMetadata(ListOf,BankType) {}
    set BirdMetadata(ListOf,BankName) {}
    set LesBankList [$Root selectNodes "bird-bank-meta"]
    foreach BankElement $LesBankList {
	set BankType     [$BankElement getAttribute "type"]
	set BankSchemas  [$BankElement getAttribute "schema"]
	set BankMetadata [$BankElement getAttribute "metadata"]
	set BankFormats  [$BankElement getAttribute "format_out"]
	regsub -all "," $BankFormats " " BankFormats
	set LesBankFormat [LesMotsDeLaLigne $BankFormats]	

	set BirdMetadata($BankType,BankMetadata) $BankMetadata
	set BirdMetadata($BankType,BankFormats)  $LesBankFormat

	regsub -all "," $BankSchemas " " BankSchemas
	set LesBankSchemas [LesMotsDeLaLigne $BankSchemas]
	lappend BirdMetadata(ListOf,BankType) $BankType
	set BirdMetadata($BankType,BankSchemas) {}
	foreach BankSchema $LesBankSchemas {
	    regsub {\(.*} $BankSchema "" BankSchema
	    if {[string trim $BankSchema]==""} { continue }
	    lappend BirdMetadata(ListOf,BankSchema) $BankSchema
	    lappend BirdMetadata($BankType,BankSchemas) $BankSchema
	    set BirdMetadata($BankSchema,BankType) $BankType
	}
	
	set LesKeys [$BankElement selectNodes "key"]
	set BirdMetadata($BankType,KeyDisplays)  {}
	set BirdMetadata($BankType,AliasBirdqls) {}
	set BirdMetadata($BankType,Comments)     {}
	foreach Key $LesKeys {
	    set KeyDisplay  [$Key getAttribute "keyDisplay"] 
	    set AliasBirdql [$Key getAttribute "alias_birdql"] 
	    set Comment     [$Key getAttribute "comment"]
	    lappend BirdMetadata(ListOf,KeyDisplay)  $KeyDisplay
	    lappend BirdMetadata(ListOf,AliasBirdql) $AliasBirdql
	    lappend BirdMetadata(ListOf,Comment)     $Comment
	    lappend BirdMetadata($BankType,KeyDisplays)  $KeyDisplay
	    lappend BirdMetadata($BankType,AliasBirdqls) $AliasBirdql
	    lappend BirdMetadata($BankType,Comments)     $Comment
	    set BirdMetadata($BankType:K:$KeyDisplay,KeyDisplay)   $KeyDisplay
	    set BirdMetadata($BankType:K:$KeyDisplay,AliasBirdql)  $AliasBirdql
	    set BirdMetadata($BankType:K:$KeyDisplay,Comment)      $Comment
	    set BirdMetadata($BankType:A:$AliasBirdql,KeyDisplay)  $KeyDisplay
	    set BirdMetadata($BankType:A:$AliasBirdql,AliasBirdql) $AliasBirdql
	    set BirdMetadata($BankType:A:$AliasBirdql,Comment)     $Comment
	}
    }
    set BirdMetadata(ListOf,KeyDisplay)  [lsort -unique $BirdMetadata(ListOf,KeyDisplay)]
    set BirdMetadata(ListOf,AliasBirdql) [lsort -unique $BirdMetadata(ListOf,AliasBirdql)]
    set BirdMetadata(ListOf,Comment)     [lsort -unique $BirdMetadata(ListOf,Comment)]
    foreach K [array names BirdMetadata] {
	regsub "," $K " " K
	scan $K "%s %s" I O
	lappend BirdMetadata(ListOf,Quoi) $O
	lappend BirdMetadata(ListOf,QuiQuoi) "$I $O"
	if {$I=="ListOf"} { lappend BirdMetadata(ListOf,ListOf) $O }
    }
    lappend lappend BirdMetadata(ListOf,Quoi) "ListOf"
    set BirdMetadata(ListOf,Quoi) [lsort -unique $BirdMetadata(ListOf,Quoi)]
    return [BirdMetadata $Qui $Quoi]

}

proc BirdPostFileAndGetFromUrl {Filename {Url ""} {Options ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set f [open $Filename r]
    set Query [read -nonewline $f]
    close $f

    set PostEncode [eval ::http::formatQuery querytext $Query]
    if {$Options!=""} { append PostEncode "&$Options" } 

    set Token [::http::geturl $Url -query $PostEncode]
    return [::http::data $Token]

}

proc BirdQL {query {BirdUrl ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    #rR ce BirdQL est de pris Nicolas Gagniere avec mes modifs
    #rR j'y ai rajoute BirdEntry et BirdFasta pris aussi dans gagniere/gscopublic au cas ou ...    package require http
    if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
    set BirdBsearchUrl $BirdUrl
    if { ! [regexp "bsearch" $BirdUrl]} { set BirdBsearchUrl "$BirdUrl/bsearch" }
    set query [::http::formatQuery "service" "birdql" "query" $query]
    set token [::http::geturl $BirdBsearchUrl -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    return $body

}

proc BirdSendQueryAndGetFromUrl {Query {Url ""} {Options ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set QueryEncode [::http::formatQuery querytext $Query]
#    Espionne $QueryEncode
    if {$Options!=""} { append QueryEncode "&$Options" } 
    set Token [eval ::http::geturl $Url -query $QueryEncode]
    return [::http::data $Token]

}

proc BirdSendQueryUrlAndGetFromUrl {QueryUrl {Url ""} {Options ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set QueryUrlEncode [eval ::http::formatQuery querytext "\"$QueryUrl\""]
#    regsub -all {\+} $QueryUrlEncode {%20} QueryUrlEncode
    if {$Options!=""} { append QueryUrlEncode "&$Options" } 
    set Token [::http::geturl $Url -query $QueryUrlEncode]
    return [::http::data $Token]

}

proc BirdShowTable {Schema Table} {

    set ShowTable [HttpGetTextFromUrl "[BirdUrl]/detail?metadata=$Schema.$Table"]
    return $ShowTable

}

proc BirdStar4FromQueryFile {Fichier {Options ""} {Racine ""} {KeepZip ""} {TarFile ""}} {


    set Options [string trim $Options " \t\n"]
    if {$Options!="" && ! [regexp {^\&} $Options]} { set Options "&$Options" }

    set KeepZip [string equal -nocase $KeepZip "KeepZip"]
    if {$Racine==""} { set Racine "BirdResult" }
    set Delete 0
    if {$TarFile==""} {
	set Delete 1
	set TarFile "[TmpFile].bird.tar.gz"
    }

    set CommandeBird "curl -s -F upload=@$Fichier  \"http://star4:8080/mybiodb/bsearch?service=bird_explorer&out_file=${Racine}${Options}\"  -o $TarFile"
    Espionne $CommandeBird
    if {[catch {eval exec $CommandeBird} Message]} {Espionne "Error from curl : START of message\n$Message\nEND of message"}	

    if {$KeepZip} { return $TarFile }
    set Retour [exec zcat $TarFile]
    if {$Delete} { file delete $TarFile }
    return $Retour

}

proc BirdTester {Requete {BirdVersion star4}} {

	set Path "/tmp/BirdTest"
	set FichierDesRequetes [open "$Path.sql" "w"]
	puts $FichierDesRequetes "ID * DB UCSC"
	puts $FichierDesRequetes "WH SQLNATIVE $Requete"
	puts $FichierDesRequetes "LM  1"
	puts $FichierDesRequetes "//"
	close $FichierDesRequetes
	BirdFetch "$Path.sql" $BirdVersion "$Path.res"
	set FichierDesRequetesExecutees [open "$Path.res" "r"]
	while { [gets $FichierDesRequetesExecutees Ligne] >=0 } {
		Espionne $Ligne
	}
	close $FichierDesRequetesExecutees

}

proc BirdUrl {} {

#   set Url "http://decrypthon.u-strasbg.fr:8080/bird"
#   set Url "http://star4:8080/bird"
#   set Url "http://bird.u-strasbg.fr:8080/bird"
#   set Url "http://bird.igbmc.fr:8080/bird"
   set Url "http://kbm.u-strasbg.fr:8080/birdsnp"
#   set Url "http://d1.crihan.fr:8080/bird"
#   set Url "http://195.221.22.98:8080/bird"
    return $Url

}

proc BirdWeb {Database Accession {Fields ""}} {


    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    if {$Fields==""} { set Fields "all" }

    #rR on peut deja avoir cherche et memorise tous les access d'un blast   (rajout du 2014/03/11)
    if {$Fields=="all" && [string equal -nocase "uniprot" $Database]} {
#	Espionne "I'll try BirdFromTheBlast $Accession"
	if {[set Info [BirdFromTheBlast $Accession]]!=""} {
	    if {$Info=="NotFound"} { return "" }
	    return $Info
	}
    }

    set FieldAuto(DBXREF) 1

    set LesFieldsDemandes {}
    foreach FieldDemande [split $Fields ","] {
	if {$FieldDemande=="all"} { continue }
	if {$FieldDemande==""} { continue }
	if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
	    lappend LesFieldsDemandes $FieldDemande
	}
	set AAfficher([string toupper $FieldDemande]) 1
	lappend LesFieldsAAfficher $FieldDemande
    }
    set Param ""
    if {$LesFieldsDemandes!={} || $Fields!="all"} {
	set LesKeysDemandes {}
	foreach F $LesFieldsDemandes {
	    set K $F
#	    if {[set K [BirdMetadata "$Database:K:$F AliasBirdql"]]==""} { set K $F } 
	    lappend LesKeysDemandes $K
	} 
	set Param "&field=[join $LesKeysDemandes ","]"
    }
    set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession$Param"
    if {[catch {set Tout [string trim [HttpGetTextFromUrl $Url]]} Message] } {
	Warne "Error from Bird with message : $Message"
	return ""
    }
    if {[string equal -nocase $Fields "all"]} { return $Tout }
    set LaSortie {}
    set YaEuSQ 0
    foreach Ligne [split $Tout "\n"] {
	if {[regexp "^SQ   " $Ligne]} {
	    set YaEuSQ 1
	    set Seq ""
	    continue
	}
	if {$YaEuSQ} {
	    if {[regexp "     " $Ligne]} { append Seq [string trim $Ligne] ; continue }
	    lappend LaSortie "$Seq"
	    set $YaEuSQ 0
	    continue 
	}
	if {[regexp "^//" $Ligne]} { continue }
	if {[regexp -nocase {[a-z_0-9]+([= ])} $Ligne Match PremierSeparateur]} {
	    set F [lindex [split $Ligne $PremierSeparateur] 0]
#	    set K [BirdMetadata $F "Key"]
	    set K $F
	    if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
	    set Valeur [string trim [StringSuivant $PremierSeparateur dans $Ligne]]
#	    set Valeur $Ligne
#	    regsub {[^=]*=} $Valeur "" Valeur
	    lappend LaSortie $Valeur
	} else {
	    set F [lindex [split $Ligne " "] 0]
#	    set K [BirdMetadata $F "Key"]
	    set K $F
	    if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
	    set Valeur $Ligne
	    regsub {[^ ]* +} $Valeur "" Valeur
	    lappend LaSortie $Valeur
	}
    }
    return [join $LaSortie "\n"]

}

proc BirdWebFromTFAs {Database Accession {Fields ""}} {

    if {$Fields==""} { set Fields "all" }

    set FieldAuto(DBXREF) 1

    set LesFieldsDemandes {}
    foreach FieldDemande [split $Fields ","] {
	if {$FieldDemande==""} { continue }
	if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
	    lappend LesFieldsDemandes $FieldDemande
	}
	set AAfficher([string toupper $FieldDemande]) 1
	lappend LesFieldsAAfficher $FieldDemande
    }
    set Param "&field=[join $LesFieldsDemandes ","]"
    set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession&format=flat$Param"
    set Tout [HttpGetTextFromUrl $Url]
    return $Tout

}

proc BirdqlExe {} {


    global tcl_platform
    global OrdBinDir
    global env

    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./birdql_http2.sh"
    }
    if {[set tcl_platform(platform)] != "windows"} {
	return "/home/friedric/bin/birdql_http2.sh"
    } else {
	set lexe [file join $OrdBinDir "birdql_http.exe"]
	regsub "Program Files" $lexe "PROGRA~1" lexe
	return $lexe
    }

}

proc Blast {{Programme ""} {Sequence ""} {NomOuNumOuSortie ""} {Banque ""} {WithGenericCommand ""}} {

    global RepertoireDuGenome
    global Commandes
    global BlastCommandeGenerique

    Wup "Il existe aussi Blaste plus oriente batch"


    if {$WithGenericCommand==""} { set WithGenericCommand "WithGenericCommand" }
    set WithGenericCommand [regexp -nocase "^With" $WithGenericCommand]

    while {$Sequence==""} { 
	set Fichier [ButineArborescence "All" "./"]
	if {[FileAbsent $Fichier]} {
	    if {[OuiOuNon "Do I cancel Blast ?"]} { return "" }
	    continue
	}
	set Sequence [ContenuDuFichier $Fichier]
	Espionne [FormatDeLaSequence $Sequence]
    }

    if {[regexp "/" $NomOuNumOuSortie]} {
	set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	set Sortie $NomOuNumOuSortie
    } else {
	set Sortie ""
	if { $NomOuNumOuSortie == "" } {
	    set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	} elseif { $NomOuNumOuSortie=="retourne" } {
	    set NomNum [TmpFile]
	    set Sortie "retourne"
	} elseif { [regexp {^[a-zA-Z]} $NomOuNumOuSortie ] } {
	    set NomNum ${NomOuNumOuSortie}[NomDe ""]
	} elseif { [regexp {^[0-9]} $NomOuNumOuSortie ] } {
	    set NomNum "[RepertoireDeTravail]/tmp.$NomOuNumOuSortie"
	} else {
	    set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	    set Sortie $NomOuNumOuSortie
	}
    }
    set Tmp $NomNum

    set In  "$Tmp"
    set Out "$In.blastp"
    set Log "$Out.log"

    Sauve [SequenceFormatTFA $Sequence] dans $In

    if {$Sortie==""} { set AskOrNot "" } else { set AskOrNot "DontAsk" }

    if { $Programme == "P"       || [string equal -nocase $Programme "blastp"]   } {
	if {$Banque==""} { set Banque "/catalog/blast/protall" }
	set Prog "blastp"
    } elseif { $Programme == "N" || [string equal -nocase $Programme "blastn"]   } {
	if {$Banque==""} { set Banque "/catalog/blast/genembl" }
	set Prog "blastn"
    } elseif { $Programme == "X" || [string equal -nocase $Programme "blastx"]   } {
	if {$Banque==""} { set Banque "/catalog/blast/protein" }
	set Prog "blastx"
    } elseif { $Programme == "tN" || [string equal -nocase $Programme "tblastn"] } {
	if {$Banque==""} { set Banque "/catalog/blast/genomes" }
	set Prog "tblastn"
    } elseif { $Programme == "tX" || [string equal -nocase $Programme "tblastx"] } {
	if {$Banque==""} { set Banque "/catalog/blast/genomes" }
	set Prog "tblastn"
    } elseif { $Programme == "Choix" } {
	set Prog ""
    } else {
	set Prog [ChoixParmi [list "blastp" "tblastn" "blastx" "blastn" "tblastx"]]
    }
    if {$WithGenericCommand} {
	if { ! [info exists BlastCommandeGenerique]} {
	    FaireLire "Please modify the parameters of the blast command.\n Don't touch the beginning of the command up to IIIIII OOOOOO\n I'll keep these parameters for all blast I'll run in this Gscope sessions"
	    set BlastCommandeGenerique [ChoisisTonBlast IIIIII OOOOOO $Prog $Banque "Ask"]
	} else {
	    set Commande $BlastCommandeGenerique
	}
	regsub "IIIIII" $Commande $In  Commande
	regsub "OOOOOO" $Commande $Out Commande
    } else {
	set Commande [ChoisisTonBlast $In $Out $Prog $Banque "DontAsk"]
    }

    if {$Commande==""} { return "" }
    if {$Sortie!=""} {
	regsub {^.*batchcom.tcl *} $Commande "" Commande
	set Etat [eval $Commande]
	if { ! [file exists $Out]} { return "" }
	if {$Sortie=="retourne"} { return [ContenuDuFichier $Out] }
	file copy -force $Out $Sortie
	return $Sortie
    }
    Espionne $Commande
    if {[catch {set Canal [open "| $Commande"]} Message]} {
	Warne $Message
    }
    fconfigure $Canal -blocking false -buffering line
    fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out"
    Warne "Blast $Prog lance en batch"

}

proc Blast18q21 {NomRepBlast RepTFA} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    foreach FichierTFA [glob -nocomplain $RepTFA/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}

	### select
	set EnteteTFA [EnteteDuFichierTFA $FichierTFA]
	if {[regexp "HS18 4" $EnteteTFA]} {
	###

	    Espionne "$Nom -> blastp  / banqueCGH"
	    set NbSubject      50
	    set ExpectDeRef    10.0
	    set FichierBlastTmp [TmpFile]
	    set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/ProtCGH06"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	    if {[file exists $FichierBlastTmp]} {
		File rename -force $FichierBlastTmp $FichierBlast
	    }
	    Espionne "$Nom -> blastp done"
	}
    }

}

proc BlastACorrectedProteome {{expectLimit ""} {fromFile ""}} {

	if {$expectLimit==""} {set expectLimit "1e-10"}
	#creation de la banque
	puts "#########################################"
	puts "--Creation de la banque pour les blasts--"
	puts "#########################################"
	puts "--> formatDB sur completeConvertedProteome.fasta"
	CreeUneBanqueBlast "./completeConvertedProteome.fasta" "[PreFixe]"
	puts "    --> OK"
	puts "#########################################"
	puts "--Ajout des infos Narcisse--"
	puts "#########################################"
	puts "--> ajout des infos pour la detection des origines des sequences (sp/tr/ref)"
	if {$fromFile==""} {
		AddNarcisse "completeProteome.fasta"
	} else {
		AddNarcisse $fromFile
	}
	puts "    --> OK"
	#Lancement des blast
	puts "#########################################"
	puts "--Lancement des blasts--"
	puts "#########################################"
	puts "remarque: si un des blast plante (très long, 3h pour Anopheles)"
	puts "          lancer la fonction 'RepriseDuProcessus \$expect'"
	exec gscope "yes" "BlastPPourTousOptionFiltre" "" "[PreFixe]" "" "$expectLimit" "F"

}

proc BlastAvecFastaDBTSS {FileTFA FileBlast FileFasta {Expect 10} {NbSubject 50}} {

    ###!!!Ne marche pas fasta!!!????????###
    ### Fasta non filtre d'une sequence d'un fichier TFA non masquee contre la DB DBTSS ###    
    if {![file exists $FileTFA]} {return}
    #BlastNAvecFastaN  $FileTFA [DBTSSDir "DBBlast"] $FileBlast $FileFasta $Expect $NbSubject
    BlastNAvecFastaN  $FileTFA human $FileBlast $FileFasta $Expect $NbSubject
    return

}

proc BlastCaSur {{Banque refseq-prot} FichierTfa {Format ""}} {

	

	#Petite routine inline pour blaster un fichier rapidement
	#ex de databank : protein
	set NomFic [file tail $FichierTfa]
	if {[catch {exec /bips/bin/blastall -p "blastp" -d "/blast/$Banque" -i $FichierTfa -o "$NomFic.blast" -F "m S" -s T -e 0.0001} Message] } {
		Espionne "Error for $Access:\n$Message"
   	}

}

proc BlastDBTSS {FileTFA FileBlast {Expect 0.001} {NbSubject 20} {Filter F}} {

    ### Blast non filtre d'une sequence d'un fichier TFA non masquee contre la DB DBTSS ###    
    if {![file exists $FileTFA]} {return}
    PipeBlast $FileTFA [DBTSSDir "DBBlast"] $FileBlast N $NbSubject $Expect F 4
    return

}

proc BlastDatabaseInventory {{Qui ""} {Quoi ""} {RepBan ""}} {

    global BDI

    if {$Qui=="ResetAll"} {
	if {[info exists BDI]} { unset BDI }
	return ""
    }

    if {$Qui==""} { set Qui "Usage" ; set Quoi "" }

    if {$Quoi=="Size"} { return [BlastDatabaseSizeNice $Qui] }

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

    if {$RepBan==""} { set RepBan "/blast" }

    set BDI(Dir,) $RepBan

    set LesNal {}

    set LesProBest [list  protall  uniprot  protein  swissprot  trembl  pdb  varsplic  refseq-prot  uniref90  ]
    set LesNucBest [list  genembl  genbank  refseq-nuc  est  HUMAN  MOUSE  ]
    
    set ToutesLesBanques [lsort [glob -nocomplain "$RepBan/*"]] 
    foreach Fichier $ToutesLesBanques {
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.pal|\.phr|\.nhr|\.nal)$} $Banque] } { continue }
	if {[regexp {\.pal$} $Banque]} {
	    regsub {\.pal$} $Banque "" B
	    set EstPal($B) $B
	}
	if {[regexp {\.nal$} $Banque]} {
	    regsub {\.nal$} $Banque "" B
	    set EstNal($B) $B
	}
    }
    foreach Fichier $ToutesLesBanques {
#	if {[file type $Fichier]=="link"} { continue }
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.pal|\.phr|\.nhr|\.nal)$} $Banque] } { continue }
	lappend BDI(ListOf,All) $Banque
	if {[regexp {\.pal$} $Banque]} {
	    regsub {\.pal$} $Banque "" B
	    set ContentOf($B) [ContenuDuFichier $Fichier]
	    foreach Ligne [LesLignesDuFichier $Fichier] {
		if {[regexp "^TITLE" $Ligne]} { set Title($B) [StringSuivant "TITLE " dans $Ligne] }
		if {[regexp "^DBLIST" $Ligne]} {
		    set Filles [StringSuivant "DBLIST " dans $Ligne]
		    regsub -all " +" $Filles " " Filles
		    set LesFilles [split [string trim $Filles] " "]
		    set LesFillesDe($B) {}
		    foreach Fille $LesFilles {
			if { ! [regexp "^/" $Fille] && [FileAbsent "$RepBan/$Fille.pal"] && [FileAbsent "$RepBan/$Fille.phr"]} {
			    continue 
			    FaireLire "$RepBan/$Fille.phr ou .pal introuvable"
			}
			lappend LesMeresDe($Fille) $B
			lappend LesFillesDe($B)    $Fille 
		    }
		}
	    }
	    if { ! [info exists Title($B)]} { set Title($B) "" }
	    if {$LesFillesDe($B)=={}} { continue }
	    lappend LesPal $B
	    set BDI($B,TITLE)  $Title($B)
	    set BDI($B,DBLIST) $LesFillesDe($B)
	    set BDI($B,CONTENT) $ContentOf($B)
	}
	if {[regexp {\.nal$} $Banque]} {
	    regsub {\.nal$} $Banque "" B
	    set ContentOf($B) [ContenuDuFichier $Fichier]
	    foreach Ligne [LesLignesDuFichier $Fichier] {
		if {[regexp "^TITLE" $Ligne]} { set Title($B) [StringSuivant "TITLE " dans $Ligne] }
		if {[regexp "^DBLIST" $Ligne]} {
		    set Filles [StringSuivant "DBLIST " dans $Ligne]
		    regsub -all " +" $Filles " " Filles
		    set LesFilles [split [string trim $Filles] " "]
		    set LesFillesDe($B) {}
		    foreach Fille $LesFilles {
			if {[FileAbsent "$RepBan/$Fille.nal"] && [FileAbsent "$RepBan/$Fille.nhr"]} {
			    continue
			    FaireLire "$RepBan/$Fille.nhr ou .nal introuvable"
			}
			lappend LesMeresDe($Fille) $B
			lappend LesFillesDe($B)    $Fille 
		    }
		}
	    }
	    if { ! [info exists Title($B)]} { set Title($B) "" }
	    if {$LesFillesDe($B)=={}} { continue }
	    lappend LesNal $B
	    set BDI($B,TITLE) $Title($B)
	    set BDI($B,DBLIST) $LesFillesDe($B)
	    set BDI($B,CONTENT) $ContentOf($B)
	}
	if {[info exists DejaVu($B)]} { FaireLire "$B\n$Fichier\n$DejaVu($B)" }
	set DejaVu($B) $Fichier	
    }
    set LesPhr {}
    set LesNhr {}
    foreach Fichier $ToutesLesBanques {
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.phr|\.nhr)$} $Banque] } { continue }
	if {[regexp {\.phr$} $Banque]} {
	    regsub {\.phr$} $Banque "" B
	    if {[regexp         {(unigene)[0-9]+$} $B] } { continue }
	    if {[regexp {(part|\.)[0-9]+$} $B] && [info exists LesMeresDe($B)]} { continue }
	    lappend LesPhr $B
	    lappend LesProWithTitle "[format %-33s $B] :"
	}
	if {[regexp {\.nhr$} $Banque]} {
	    regsub {\.nhr$} $Banque "" B
	    if {[regexp         {(unigene)[0-9]+$} $B] } { continue }
	    if {[regexp {(part|\.|unigene)[0-9]+$} $B] && [info exists LesMeresDe($B)]} { continue }
	    lappend LesNhr $B
	}
    }
    foreach {K V} [array get LesMeresDe] {
	set BDI($K,PartOf) $V
    }
    set LesPro [lsort [concat $LesPal $LesPhr]]
    set LesNuc [lsort [concat $LesNal $LesNhr]]
    set LesProBestExistant {}
    foreach B $LesProBest {
	if {[lsearch $LesPro $B]<0} { continue }
	lappend LesProBestExistant $B
    }
    set LesNucBestExistant {}
    foreach B $LesNucBest {
	if {[lsearch $LesNuc $B]<0} { continue }
	lappend LesNucBestExistant $B
    }
    set LesProBestFirst [ListeSansDoublon [concat $LesProBestExistant $LesPro]]
    set LesNucBestFirst [ListeSansDoublon [concat $LesNucBestExistant $LesNuc]]

    foreach X [list "Pro" "Nuc" "ProBestFirst" "NucBestFirst"] {
	set Les${X}WithTitle {}
	foreach B [set Les${X}] {
	    set T ""
	    if {[info exists Title($B)]} { set T $Title($B) }
	    lappend Les${X}WithTitle "[format %-33s $B] : $T"
	}
    }

    set BDI(ListOf,ProWithTitle) [join $LesProWithTitle "\n"]
    set BDI(ListOf,Pro)          [join $LesPro "\n"]
    set BDI(ListOf,Pal)          [join $LesPal "\n"]
    set BDI(ListOf,Phr)          [join $LesPhr "\n"]
    set BDI(ListOf,NucWithTitle) [join $LesNucWithTitle "\n"]
    set BDI(ListOf,Nuc)          [join $LesNuc "\n"]
    set BDI(ListOf,Nal)          [join $LesNal "\n"]
    set BDI(ListOf,Nhr)          [join $LesNhr "\n"]

    set BDI(ListOf,ProBestFirst)          [join $LesProBestFirst "\n"] 
    set BDI(ListOf,NucBestFirst)          [join $LesNucBestFirst "\n"] 
    set BDI(ListOf,ProBestFirstWithTitle) [join $LesProBestFirstWithTitle "\n"] 
    set BDI(ListOf,NucBestFirstWithTitle) [join $LesNucBestFirstWithTitle "\n"]

    set BDI(ListOf,ProNucBestFirstWithTitle) "$BDI(ListOf,ProBestFirstWithTitle)\n$BDI(ListOf,NucBestFirstWithTitle)"

    foreach B $LesPal {
	set BDI($B,Type) "Pal"
    }
    foreach B $LesPhr {
	set BDI($B,Type) "Phr"
    }
    foreach B $LesNal {
	set BDI($B,Type) "Nal"
    }
    foreach B $LesNhr {
	set BDI($B,Type) "Nhr"
    }
    set LesUs [array names BDI]
    set LesUsages {}
    foreach Us $LesUs {
	if {[regexp "EstCharge" $Us]} { continue }
	lassign [split $Us ","] A B
	if {[info exists BDI($A,PartOf)] || [info exists BDI($A,Type)]} { set A "BlastDatabank" }
	lappend LesUsages "BlastDatabaseInventory $A $B"
    }
    lappend LesUsages "BlastDatabaseInventory ResetAll"
    lappend LesUsages "BlastDatabaseInventory Usage"
    set LesUsages [lsort -unique $LesUsages] 
    set BDI(Usage,) [join $LesUsages "\n"]
    
    return [BlastDatabaseInventory $Qui $Quoi]

}

proc BlastDatabaseSize {B {DoBlastIfNecessary ""} {DefaultSize ""} {Nice ""}} {

    #rR Rend le nombre de séquences et le nombre de lettres si on le trouve N L sinon N
    #rR Initialement écrit par Mickael Joly
    #rR S'il existe un blast déjà fait sur cette base on va y chercher la taille
    #rR Sinon on va voir dans formatdb.log
    #rR Si c'est un .pal on cumule les tailles des sousbases

    set Info [exec /biolo/blast/bin/blastdbcmd -info -db $B]
    if { [regexp {([0-9\,]+) sequences; ([0-9\,]+) total residues} $Info Match NbSeq NbRes]} {
	regsub -all {\,} $NbSeq "" NbSeq
	regsub -all {\,} $NbRes "" NbRes
	return "$NbRes letters $NbSeq sequences"
    }

    set BlastTestDir "/blast/BlastTest"
    if {$DefaultSize==""} { set DefaultSize 3608421 }

    if { ! [regexp "^/" $B]} { set B "/blast/$B" }
    set queue [file tail $B]
    set FichierBlast "[BlastTestDir]/$queue.test.blast"
    if {[file exists $FichierBlast]}  {
	if {[regexp {([0-9\,]+) sequences} [ContenuDuFichier $FichierBlast] Match NAV]} {
	    regsub -all "\," $NAV "" N
	    if {[regexp {([0-9\,]+) total letters} [ContenuDuFichier $FichierBlast] Match LAV]} {
		regsub -all "\," $LAV "" L
		return "$L letters $N sequences"
	    }
	    return $N
	}
    } else {
	if {[string equal -nocase "DoBlastIfNecessary" $DoBlastIfNecessary] || [OuiOuNon "$FichierBlast does not exist ... Do I create it ... It will take some time" 0]} {
	    set FichierQuery "[BlastTestDir]/queryBidon.tfa"
	    set creationBlast [BlastForTest $FichierQuery $FichierBlast $B]
	    set Size [BlastDatabaseSize $B $DefaultSize]
	    return $Size
	}
    }
    set FicFormat "$B.formatdb.log"
    set total 0
    if {[file exists $FicFormat]} {
	foreach Ligne [LesLignesDuFichier $FicFormat] {
	    if {![regexp {Formatted ([0-9]+) sequences} $Ligne Match N]} {continue}
	    incr total $N
	}
	return $total
    }

    foreach Ext {pal nal} {
	set FicPal "$B.$Ext"
	Espionne $FicPal
	set total 0
	if {[FileAbsent $FicPal]} { continue }
	set Dir [file dirname $FicPal]
	foreach Ligne [LesLignesDuFichier $FicPal] {
	    if {![regexp {^DBLIST } $Ligne]} {continue}
	    regsub -all {[ \t]+} $Ligne " " Ligne
	    set LesMots [split $Ligne " "]
	    foreach SousBase [lrange $LesMots 1 end] {
		if {! [regexp "^/" $SousBase]} { set SousBase "$Dir/$SousBase" }
		Espionne $SousBase
		set N [BlastDatabaseSize $SousBase "No" 0]
		scan $N "%d" N
		incr total $N
		Espionne $N
	    }
	}
	return $total
    }
    return $DefaultSize

}

proc BlastDatabaseSizeNice {B {DoBlastIfNecessary ""} {DefaultSize ""}} {

    return [BlastDatabaseSize $B $DoBlastIfNecessary $DefaultSize "Nice"]

}

proc BlastDatabaseSizePourTous {} {

    set LesBanques [split [BlastDatabaseInventory ListOf ProBestFirst]]
    set LesNouveaux {}
    foreach Banque $LesBanques {
	set Queue [file tail $Banque]
	set FichierBlast "[BlastTestDir]/$Queue.test.blast"
	set FichierQuery "[BlastTestDir]/queryBidon.tfa"
	Espionne "$Queue $Banque $FichierBlast"
	if {[FileAbsent $FichierBlast]} {
	    BlastForTest $FichierQuery $FichierBlast $Banque "GetFilename" "Wait"
	}
	set Size [BlastDatabaseSize $Banque]
	Espionne $Size
	lappend LesSize "$Size $FichierBlast"
    }
    return $LesSize

}

proc BlastDesHitsHumainsDuProfil {} {

    set Rep "[RepertoireDuGenome]/blastpDesHitsHumainsDuProfil"
    if { ! [file exists $Rep]} { file mkdir $Rep }
    set Texte [ContenuDuFichier "/home/brelivet/multi_align/alignment/Profile/Homo_sapiens.DaedalusHits"]
    set BlastPDataBase "[RepertoireDuGenome]/banques/AllNR"
    while {[set BH [ValeurDeLaBalise "BlastHit" Texte]]!=""} {
	set AC [ValeurDeLaBalise AC BH NePasRogner]
	set ID [ValeurDeLaBalise ID BH NePasRogner]
	set DE [ValeurDeLaBalise DE BH NePasRogner]
	set EMBL [SequenceDesBanques $ID]
	if {$EMBL==""} { FaireLire "I can't find \n$BH" ; continue }
	set TFA [SequenceFormatTFA $EMBL "$ID $AC $DE" "embl"]
	set FichierBlast "$Rep/$ID.blastp"
	set FichierTFA [Sauve $TFA dans "[TmpFile].tfa"]
	set CommandeBlast "blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastPDataBase  -v 100  -K 0  -b 100  -e 10.0  -F T"
	Espionne "$ID $AC $DE"
	eval exec $CommandeBlast
	if {[file exists $FichierBlast.encours]} { file rename -force $FichierBlast.encours $FichierBlast }
    }
    exit

}

proc BlastDesMeilleursESTDuBlast {FichierBlastnEST FichierTFA Organism {ID 0.98} {TailleAliMin 50}} {

    Espionne "$FichierBlastnEST $FichierTFA $Organism"
    ##########################################################################
    ### Reduction du blast en blast reduit aux EST specifiques de la query ###
    ##########################################################################
    if {![file exists $FichierTFA]} {return}
    set FichierBlastnESTReduced "$FichierBlastnEST.reduced"
    #Les fichiers suivants sont effaces à la fin de la procedure
    set FichierSeqTFAsEST       "$FichierBlastnEST.esttfas"
    set FichierESTDB            "[RepertoireDeTravail]/[file tail $FichierBlastnEST].dbest"

    #########Selection des EST specifiques de la query sans regions repeat#########
    ###Reduction des subjects du blastnEST aux EST avec minimum d'identite et d'alignement###
    File copy -force   $FichierBlastnEST        $FichierBlastnESTReduced
    Espionne "IdentityWithoutFilter"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced IdentityWithoutFilter $ID
    Espionne "TailleAlignementMin"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced TailleAlignementMin   $TailleAliMin

    ###Extraction des id de mes EST dans le blast reduit###
    set LesBId [LesBanqueIdDuBlast $FichierBlastnESTReduced 1e200 1e200]
    ###Extraction des sequences de mes EST a partir des Id du blast et selection de l'organisme###
    Sauve [join [LesSeqTFAsDesBanqueId $LesBId est $Organism] "\n"] dans $FichierSeqTFAsEST
    ###Creation de la database de mes EST dans le repertoire junkdir###
    File copy -force $FichierSeqTFAsEST $FichierESTDB
    TFAs2DB $FichierESTDB
    #debutLP
    set FichierBlastnESTReducedPourVide [TmpFile]
    file copy -force $FichierBlastnESTReduced $FichierBlastnESTReducedPourVide
    #finLP

    #########Alignement des EST selectionnees avec toute la sequence query, dont les repeat########
    ###Blastn sans filtre du fichier tfa initial non masque contre la database d'EST creee###

    #BlastNDuFichier $FichierTFA $FichierESTDB $FichierBlastnESTReduced F 2000 0.1 0
    if {1} {
	set Commande "eval exec blastall -p blastn -i \$FichierTFA -o \$FichierBlastnESTReduced  -d \$FichierESTDB -v 2000 -K 0 -b 2000 -e 0.01 -F F"
	if {[catch {eval $Commande} Message]} {
	    Espionne "Problem with $FichierBlastnESTReduced"
	    Espionne $Message
	    #debutLP
	    if {[regexp "Database is empty" $Message]} {
		if {[file exists  $FichierSeqTFAsEST     ]} {File delete -force  $FichierSeqTFAsEST}
		if {[file exists  $FichierSeqTFAsEST     ]} {File delete -force  $FichierESTDB     }
		if {[file exists "$FichierSeqTFAsEST.nhr"]} {File delete -force "$FichierESTDB.nhr"}
		if {[file exists "$FichierSeqTFAsEST.nin"]} {File delete -force "$FichierESTDB.nin"}
		if {[file exists "$FichierSeqTFAsEST.nsq"]} {File delete -force "$FichierESTDB.nsq"}
		file copy -force $FichierBlastnESTReducedPourVide $FichierBlastnESTReduced
		file delete $FichierBlastnESTReducedPourVide
		return $FichierBlastnESTReduced
	    }
	    #finLP
	}
    }

    ###Selection des EST specifiques de la sequence query complete non masquee###
    Espionne "IdentityWithoutFilter"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced IdentityWithoutFilter $ID
    Espionne "TailleAlignementMin"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced TailleAlignementMin   $TailleAliMin
    Espionne "JusteLePremierAlignementDesSubjects"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced JusteLePremierAlignementDesSubjects
    Espionne "RegionsAligneesSurRegionsAlignables"
    FichierBlastReduit $FichierBlastnESTReduced $FichierBlastnESTReduced RegionsAligneesSurRegionsAlignables $ID

    if {[file exists  $FichierSeqTFAsEST     ]} {File delete -force  $FichierSeqTFAsEST}
    if {[file exists  $FichierSeqTFAsEST     ]} {File delete -force  $FichierESTDB     }
    if {[file exists "$FichierSeqTFAsEST.nhr"]} {File delete -force "$FichierESTDB.nhr"}
    if {[file exists "$FichierSeqTFAsEST.nin"]} {File delete -force "$FichierESTDB.nin"}
    if {[file exists "$FichierSeqTFAsEST.nsq"]} {File delete -force "$FichierESTDB.nsq"}

    return $FichierBlastnESTReduced

}

proc BlastDesMeilleursHTGDuBlast {FichierBlastnHTG FichierTFA Organism {ID 0.80} {TailleAliMin 50}} {

    #########################################################################
    ### Reduction du blast en blast reduit aux HTG specifiques de la query###  
    #########################################################################
    if {![file exists $FichierTFA]} {return}
    set FichierBlastnHTGReduced "$FichierBlastnHTG.reduced"
    set FichierSeqTFAsHTG       "$FichierBlastnHTG.htgtfas"
    set FichierHTGDB            "[RepertoireDeTravail]/$FichierBlastnHTG.dbhtg"
 
    #########Selection des HTG specifiques de la query sans regions repeat#########
    ###Reduction des subjects du blastnHTG aux HTG avec minimum d'alignement et d'identite###
    File copy -force   $FichierBlastnHTG        $FichierBlastnHTGReduced
    Espionne "TailleAlignementMin"
    FichierBlastReduit $FichierBlastnHTGReduced $FichierBlastnHTGReduced TailleAlignementMin   $TailleAliMin
    Espionne "IdentityWithoutFilter"
    FichierBlastReduit $FichierBlastnHTGReduced $FichierBlastnHTGReduced IdentityWithoutFilter $ID

    ###Extraction des id de mes HTG dans le blast reduit###
    set LesBId [LesBanqueIdDuBlast $FichierBlastnHTGReduced 1e200 1e200]
    ###Extraction des sequences de mes HTG a partir des Id du blast et selection de l'organisme###
    Sauve [join [LesSeqTFAsDesBanqueId $LesBId htg $Organism] "\n"] dans $FichierSeqTFAsHTG
    ###Creation de la database de mes HTG dans le repertoire junkdir###
    File copy -force $FichierSeqTFAsHTG $FichierHTGDB
    TFAs2DB $FichierHTGDB

    #########Alignement des HTG selectionnees avec toute la sequence query, dont les repeat########
    ###Blastn sans filtre du fichier tfa initial non masque contre la database d'HTG creee###
    #BlastNDuFichier $FichierTFA $FichierHTGDB $FichierBlastnHTGReduced F 2000 0.1 0
    if {1} {
	set Commande "eval exec blastall -p blastn -i \$FichierTFA -o \$FichierBlastnHTGReduced  -d \$FichierHTGDB -v 2000 -K 0 -b 2000 -e 0.01 -F F -a 4"
	if {[catch {eval $Commande} Message]} {
	    Espionne "Problem with $FichierBlastnHTGReduced\n$Message"
	}
    }

    ###Reduction des subjects du blastnHTG aux HTG avec minimum d'ID de aligne query sur taille query###
    ###La query doit etre totalement presente dans ces contigs###
    Espionne "RegionsAligneesSurTailleQueryDansLeMeilleurDesSens"
    FichierBlastReduit $FichierBlastnHTGReduced $FichierBlastnHTGReduced RegionsAligneesSurTailleQueryDansLeMeilleurDesSens $ID

    return $FichierBlastnHTGReduced

}

proc BlastEPD {FileTFA FileBlast {Expect 0.001} {NbSubject 20} {Filter F}} {

    ### Blast non filtre d'une sequence d'un fichier TFA non masquee contre la DB EPD ###    
    if {![file exists $FileTFA]} { return }
    #PipeBlast $FileTFA "/home/lardenoi/DB_Promoteurs/EPD/EPD_promoter.tfas" $FileBlast N $NbSubject $Expect F 4
    PipeBlast $FileTFA [EPDDir "DBBlast"] $FileBlast N $NbSubject $Expect F 4
    return $FileBlast

}

proc BlastForTest {FichierEntree {FichierSortie ""} {Banque ""} {GetWhat ""} {Wait ""}} {

    #rR on s'en sert surtout pour créer les blast qui permettent d'en extraire la taille par BlastDatabaseSize
    if {$GetWhat==""} { set GetWhat "GetFilename" }
    if {[string equal -nocase $GetWhat "GetPid"]} { set Wait "Wait" }
    set Wait [string equal -nocase $Wait "Wait"]

    if {[PourWscope]} {
	if {[regexp "\.\." $FichierSortie]} {
	    return "Sorry. You are not allowed to create $FichierSortie]"
	}
	if { ! [regexp [BlastTestDir] $FichierSortie] && ! [regexp "magasin" $FichierSortie]} { 
	    return "Sorry. You are not allowed to create $FichierSortie]"
	}
    }

    if { [file exists $FichierSortie] && [string equal -nocase $Action "Lire"]  } {return [ContenuDuFichier $FichierSortie]}
    set commande "tcsh -c \"/biolo/ncbi/bin/blastall -i $FichierEntree -a 8 -d $Banque -p blastp -F T -o $FichierSortie.tmp -K 0 -v 33 -b 33 -e 1.0e-33 ; mv $FichierSortie.tmp $FichierSortie;\""
    if {$Wait} {
	eval exec $commande
	if {[string equal -nocase $GetWhat "Lire"]  } { return [ContenuDuFichier $fichierSortie] }
	return $FichierSortie
    }
    set Pid [eval exec $commande &]
    return "blast was launched with command\n$commande\npid=$Pid Result will be available in $FichierSortie"

}

proc BlastFromOi {Nom} {

    #rR marche pas ........ je fais autrement voir TaxoblaDuCongelo
    #rR attention Nom represent ici un PAB du projet courant pour lequel on veut chercher le blast dans le congelo corespondant 
    set LesOP [LesBlastsDuCongelo]
    set LesGz [MissBlast $LesOP "GetAllGz"]
    foreach Gz $LesGz {
	
    }

}

proc BlastHitCount {Nom {Rep ""} {CutPN ""} {MaxListe ""}} {

    Wup "If Nom contains / then Rep is CutPN and CutPN is Maxlist"
    Wup "If Rep doesn't contain / I add RepertoireDuGenome"
    Wup "The default for Rep is blastp"
 
    if {[regexp "/" $Nom]} {
	set MaxListe $CutPN
	set CutPN $Rep
	set Rep [file dirname $Nom]
	set Nom [file tail $Nom]
    } else {
	if {[regexp -nocase {^[0-9\-\.e]+$} $Rep] || $Rep=="SansSeuilExpect" } {
	    set MaxLists $CutPN
	    set CutPN $Rep
	    set Rep ""
	}
	if {$Rep==""} { set Rep "blastp" }
	if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    }
    set Fichier "$Rep/$Nom"

    if { ! [file exists $Fichier]} { return -1 }
    return [DecortiqueBlast $Fichier $CutPN $MaxListe "BlastHitCount"]

}

proc BlastLocalInventaire {} {

    NousAllonsAuBoulot [RepertoireDuGenome]
    set TotN 0
    set TotF 0
    set TotB 0
    foreach Poeloc [lsort [glob -nocomplain -type d "oif/*"]] {
	set Nom [file tail $Poeloc]
	set LesF [glob -nocomplain "$Poeloc/fasta/*"]
	set LesB [glob -nocomplain "$Poeloc/blast/*"]
	set NbF [llength $LesF]
	set NbB [llength $LesB]
	incr TotN 1
	incr TotF $NbF
	incr TotB $NbB
	set Compte [format "%5s %-8s %5d fasta  %5d blast already done" " " $Nom $NbF $NbB] 
	lappend LeMessage $Compte
    }
    lappend LeMessage ""
    lappend LeMessage [format "%5d %-8s %5d fasta  %5d blast already done" $TotN "OIs" $TotF $TotB] 

    OnRevientDuBoulot
    set Message [join $LeMessage "\n"]
    return $Message

}

proc BlastLocalPourOi {{Nom ""}} {

    #rR On 
    set Oif         "[RepertoireDuGenome]/oif"                ; file mkdir $Oif
    set OifNom      "$Oif/$Nom"                               ; file mkdir $OifNom
    set OifNomFasta "$OifNom/fasta"                           ; file mkdir $OifNomFasta
    set OifNomBlast "$OifNom/blast"                           ; file mkdir $OifNomBlast

    set Fastas [GscopeFile $Nom "oip"]
    Espionne $Fastas
    if {[FileAbsent $Fastas]} { return "Error. No fasta file available for $Nom\n$Fastas" }
    foreach Access [LaSequenceDuTFAs $Fastas "LaListeDesAccess"] {
	set Id $Access
	if {[regexp "\|" $Access]} { lassign [split $Access "|"] B A Id }

	set FicFasta "$OifNomFasta/$Id"
	set FicBlast "$OifNomBlast/$Id"
	if {[file exists $FicBlast]} { continue }
	if {[PasTouche "Blastonl$Nom/$Id"]} { continue }
	set TFA [LaSequenceDuTFAs $Fastas $Access]
	Sauve $TFA dans $FicFasta
	exec /biolo/blast/bin/blastp -word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2 -query $FicFasta -out $FicBlast -db /blast/OrthoInspector/OiEukaryota -outfmt "7 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore" -num_threads 1
	FinPasTouche "Blastonl$Nom/$Id"
    }
    return $OifNomBlast

}

proc BlastLocalPourOiEnProcessSepare {Nom {Nb ""}} {

    #rR On exécute dans un process gscope séparé pour reprendre la main tout de suite
	if {$Nb==""} { set Nb 1 }
	set Host [Hostname]
	set LesCourants {}
	foreach i [NombresEntre 1 $Nb] {
		set Cle [pid][NomDe ""]
		set Courant ${Nom}_${Host}_${Cle}
		Espionne "tcsh -c \"setgscoperr OI -q ; gscope -notk puts BlastLocalPourOi $Nom >& [RepertoireDuGenome]/oif/log/$Courant.log\" &"
		exec tcsh -c "setgscoperr OI -q ; gscope -notk puts BlastLocalPourOi $Nom >& [RepertoireDuGenome]/oif/log/$Courant.log" &
		lappend LesCourants $Courant
	}
	return $LesCourants

}

proc BlastNAvecFastaN {FichierTFA {FichierTFAOuBanque human} {FichierBlast ""} {FichierFasta ""} {Expect 0.001} {N ""}} {

    if {![file exists $FichierFasta]} {
	FastaN $FichierTFA $FichierTFAOuBanque $FichierFasta $Expect 10 $N
    }
    if {$FichierBlast == ""} {set FichierBlast "$FichierTFA.blastn"}

    Espionne "$FichierTFA : Fasta -> BlastN"
    set FichierBlast [FastaNToBlastN $FichierFasta $FichierBlast]

    #File delete -force $FichierFasta
    return $FichierBlast

}

proc BlastNAvecFastaNAvecAffichage {FichierTFA {FichierTFAOuBanque human} {FichierBlast ""} {FichierFasta ""} {Expect 0.001} {N ""}} {

    set Fichier [BlastNAvecFastaN $FichierTFA $FichierTFAOuBanque $FichierBlast $FichierFasta $Expect $N]
    Espionne "$FichierTFA displaying ..."
    AfficheVariable [ContenuDuFichier $Fichier] AvecSegAlignement $Fichier
    return $Fichier

}

proc BlastNAvecFastaNPourTous {{Banque human} {LesNoms ""}} {

    global RepertoireDuGenome

    if {$LesNoms == {}} {set LesNoms [ListeDesPABs]}
    
    set Repertoire "$RepertoireDuGenome/blastn$Banque"
    if { ! [file exists "$Repertoire"]} {File mkdir $Repertoire}

    set Keep 1
    if {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	if {![OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
	    set Keep 0
	}
    }
    foreach Nom $LesNoms {
	foreach Rep {nucmask nuctfa} {
	    set FichierTFA "$RepertoireDuGenome/$Rep/$Nom"
	    if {[file exists $FichierTFA]} { break }	
	}
	if { $FichierTFA=="" || ! [file exists $FichierTFA]} {continue}
	set FichierBlast "$Repertoire/$Nom"
	if {[file exists $FichierBlast] && $Keep == 1} {continue}

	Espionne "$Nom -> en cours..."
	Sauve "$Nom en cours ..."  dans $FichierBlast

	set FichierFasta "[TmpFile $Nom].fasta"

	BlastNAvecFastaN $FichierTFA $Banque $FichierBlast $FichierFasta
    }
    Espionne "The End"
    return ""

}

proc BlastNContreChipPourTous_Ontario {} {


    set LesPABs [ListeOligos]
    
    BlastNContreChip_Ontario $LesPABs

}

proc BlastNContreChip_Affymetrix {{LesPABs ""}} {


    Wup "Permet de faire un blastn de nos sequences contre la banque blast affymetrix"
    
    set RepAffy   "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/"
    set RepBanque "$RepAffy/Banque_Blast"

    set Banque    "$RepBanque/HG-U133A_2"
    set RepDesign "[RepertoireDuGenome]/Probes/RefSeqBLAST3"
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"

    if {$LesPABs==""}            {set LesPABs [ActiChip2_0]}
    if {$LesPABs=="ActiChip1_0"} {set LesPABs [ActiChip1_0]}
    if {$LesPABs=="ActiChip2_0"} {set LesPABs [ActiChip2_0]}
    
    if {![file exists "$RepAffy/blastn"]} {
	file mkdir    "$RepAffy/blastn"
    }

    foreach PAB $LesPABs {
	set FichierBlast "$RepAffy/blastn/${PAB}"
	set Query        "$RepDesign/${PAB}.masked"
	if {[file exists $Query]} {
	    set FichierQuery $Query
	} else {
	    set Query     "$RepmRNA/$PAB"
	    if {[file exists $Query]} {
		set FichierQuery $Query
	    } else {
		set Query "$RepNuctfa/$PAB"
		if {[file exists $Query]} {
		    set FichierQuery $Query
		} else {Espionne "$PAB probleme de seq query";continue}
	    }
	}
	
	set CmdBlastN "blastall  -i $FichierQuery  -d $Banque  -p blastn  -o $FichierBlast  -F F  -a 4"
	if {[catch {eval exec $CmdBlastN} Message]} {Warne "Error in BlastN command:\n>>>>$Message";continue}
    }
    return ""

}

proc BlastNContreChip_Ontario {{LesPABs ""}} {


    Wup "Permet de faire un blastn de nos sequence contre la banque blast ontario"
    
    set Banque    "[RepertoireDuGenome]/Autres_Puces/Ontario/Banque_Blast/Chip_EST"
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"
    
    if {$LesPABs==""} {set LesPABs [ActiChip2_0]}
    
    foreach PAB $LesPABs {
	set FichierBlast "[RepertoireDuGenome]/Autres_Puces/Ontario/blastn/${PAB}"
	set Query        "$RepmRNA/$PAB"

	if {[file exists $Query]} {
	    set FichierQuery $Query
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		 set FichierQuery $Query
	    } else {Espionne "$PAB probleme de seq query";continue}
	}

	set CmdBlastN "blastall  -i $FichierQuery  -d $Banque  -p blastn  -o $FichierBlast  -F T  -a 4"
	if {[catch {eval exec $CmdBlastN} Message]} {Warne "Error in BlastN command:\n>>>>$Message";continue}
    }
    return ""

}

proc BlastNContreChip_UMCU {{LesPABs ""}} {


    Wup "Permet de faire un blastn de nos sequence contre la banque blast UMCU"
    
    set Banque    "[RepertoireDuGenome]/Autres_Puces/UMCU/Banque_Blast/UMCU_HUMANV2"
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"
    
    switch -regexp -- $LesPABs {
	"ActiChip1" {set LesPABs [ActiChip1_0]}
	"ActiChip2" {set LesPABs [ActiChip2_0]}
	"default"   {set LesPABs [ActiChip2_0]}
    }
    #Espionne "$LesPABs"
    
    foreach PAB $LesPABs {
	set FichierBlast "[RepertoireDuGenome]/Autres_Puces/UMCU/blastn/${PAB}"
	set Query        "$RepmRNA/$PAB"

	if {[file exists $Query]} {
	    set FichierQuery $Query
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		 set FichierQuery $Query
	    } else {Espionne "$PAB probleme de seq query";continue}
	}

	set CmdBlastN "blastall  -i $FichierQuery  -d $Banque  -p blastn  -o $FichierBlast  -F T  -a 4"
	if {[catch {eval exec $CmdBlastN} Message]} {Warne "Error in BlastN command:\n>>>>$Message";continue}
    }
    return ""

}

proc BlastNContreChip_UMCU_Main {} {


    BlastNContreChip_UMCU ActiChip2

    return ""

}

proc BlastNContreRefSeq {{LesPABs ""}} {


    Wup "Permet de faire un blastn de nos sequence contre la banque blast unigene"
    Wup "et ainsi de connaitre les equivalents dans la banque unigene"
    
    set Banque    "/blast/rshuman"
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"
    
    if {$LesPABs==""} {set LesPABs [ListeDesPABs]}
    
    foreach PAB $LesPABs {
	set FichierBlast "[RepertoireDuGenome]/blastn-refseq/${PAB}"
	set Query        "$RepmRNA/$PAB"

	if {[file exists $Query]} {
	    set FichierQuery $Query
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		 set FichierQuery $Query
	    } else {Espionne "$PAB probleme de seq query";continue}
	}

	set CmdBlastN "blastall  -i $FichierQuery  -d $Banque  -p blastn  -o $FichierBlast  -F T  -a 4"
	if {[catch {eval exec $CmdBlastN} Message]} {Warne "Error in BlastN command:\n>>>>$Message";continue}
    }
    return ""

}

proc BlastNContreUnigene {{LesPABs ""}} {


    Wup "Permet de faire un blastn de nos sequence contre la banque blast unigene"
    Wup "et ainsi de connaitre les equivalents dans la banque unigene"
    
    set Banque    "/blast/unigenehs"
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"
    
    if {$LesPABs==""} {set LesPABs [ListeDesPABs]}
    
    foreach PAB $LesPABs {
	set FichierBlast "[RepertoireDuGenome]/blastn-unigene/${PAB}"
	set Query        "$RepmRNA/$PAB"

	if {[file exists $Query]} {
	    set FichierQuery $Query
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		 set FichierQuery $Query
	    } else {Espionne "$PAB probleme de seq query";continue}
	}

	set CmdBlastN "blastall  -i $FichierQuery  -d $Banque  -p blastn  -o $FichierBlast  -F T  -a 4"
	if {[catch {eval exec $CmdBlastN} Message]} {Warne "Error in BlastN command:\n>>>>$Message";continue}
    }
    return ""

}

proc BlastNDUnOrgaComplet {{FichierTFA ""}} {

    global RepertoireDuGenome

    Wup "We make blastn agains a non overlapping database of the in 100000 bases cutted dna"

    if {$FichierTFA==""} {
	FaireLire "Please browse for a TFA file"
	set FichierTFA [ButineArborescence "All" "$RepertoireDuGenome/../"]
    }

    set AutreOrga [file tail $FichierTFA]
    regsub {\.tfa$} $AutreOrga "" AutreOrga
    set Orga [Glossaire $AutreOrga Court]
    while {$Orga==""} {
	FaireLire "I couldn't find the organism associated to $FichierTFA\n\Please help me."
	set Orga [Entre ""]
	set Orga [Glossaire $Orga Court]
	if {$Orga == "" && [OuiOuNon "Do I cancel ?"]} { return "" }
    }
    set BanqueBlastN "$RepertoireDuGenome/banques/[PreFixe]overlap"
    if { ! [file exists "$BanqueBlastN.nhr"]} {
	if {[OuiOuNon "Blastn database $BanqueBlastN doesn't exists.\n Do I create it ?"]} {
	    CreeLaBanqueBlastN $BanqueBlastN
	} else {
	    return ""
	}
    }

    set RepBlastN "$RepertoireDuGenome/blastn"
    if { ! [file exists $RepBlastN]} { File mkdir $RepBlastN }
    set FichierBlastN "$RepBlastN/$Orga"
    set FaireBlastN 1 
    if {[file exists $FichierBlastN]} {
	if {[OuiOuNon "$FichierBlastN already exists. Do I use it ?"]} {
	    set FaireBlastN 0
	} elseif { ! [OuiOuNon "$FichierBlastN already exists. Do I replace it ?"]} {
	    set FaireBlastN 1
	} else {
	    set FichierBlastN [FichierPourSaveAs "$FichierBlastN"]
	    if {$FichierBlastN==""} { return "" }
	    set FaireBlastN 1
	}
    }
    
    set AnalyseLeBlastN [OuiOuNon "Do I analyse the BlastN for overlaps ?"] 

    if {$FaireBlastN} {
	set CommandeBlast "blastall  -p blastn  -d $BanqueBlastN  -i $FichierTFA  -o $FichierBlastN  -q -1 -F F -G 6 -E 1"
	set CommandeBlast [Entre $CommandeBlast]
	if {$CommandeBlast==""} { return "" }
	eval exec $CommandeBlast
    }

    if {[file exists $FichierBlastN]} {
	AnalyseLeBlastN $FichierBlastN $BanqueBlastN
	return [AfficheFichier $FichierBlastN "AvecGrapheAvecSegAlignementAvecAligneurs"]
    } else {
	FaireLire "I have a problem ... $FichierBlastN doesn't exist."
	return ""
    }

}

proc BlastNDeLOligo {P {Banque ""}} {


    if {$Banque==""} {
	set NomBanque "All[file tail [RepertoireDuGenome]]"
	set Banque "[RepertoireDuGenome]/banques/$NomBanque"
    } else {
	set NomBanque [file tail $Banque]
    }
    set FicQuery [FiSeqOl $P]
    if { ! [file exists $FicQuery]} { return "" }

    set RepBlast "[RepertoireDuGenome]/blastn$NomBanque"
    if { ! [file exists $RepBlast]} { File mkdir $RepBlast }

    set Keep [OuiOuNonMemo "Do I keep existing files in $RepBlast"]
 
    set FichierBlast "$RepBlast/$P"

    if {$Keep && [file exists $FichierBlast]} { return $FichierBlast }
    
    if {[catch {exec blastall -p blastn -d $Banque -i $FicQuery -F F -o "$FichierBlast.encours"} Message] } {
	Warne "Error during blastall for $P . I got message :\n$Message"
    }
    if { ! [file exists "$FichierBlast.encours"]} { return "" }
    File rename -force "$FichierBlast.encours" "$FichierBlast"
    
    return $FichierBlast

}

proc BlastNDeLOligoPourTous {{Banque ""}} {

    set SaveOlIgbmc 0
    set LesPs [Oli "LaListeMerci"]
    foreach P $LesPs {
	set Seq [Oli $P "Seq"]
	set FB [BlastNDeLOligo $P $Banque]
	Espionne "$P $FB"
	set Fournis [Fournisseur $P]
	set MaxEssais 3
	foreach Ligne [LesLignesDuFichier $FB] {
	    if {[regexp "^>" $Ligne] || [regexp "no hits found" $Ligne]} { break }
	    if {[regexp {^OLIGO\:} $Ligne]} {
		if { ! [incr MaxEssais -1]} { break }
		scan $Ligne "%s" BanqueId
		set LEmbl [LaSequenceDesBanques $BanqueId $BanqueId AccessOK "OnVeutEMBL"]
		set NomDansOLIGO [StringApres ":" dans $BanqueId]
		set TFA [SequenceFormatTFA [join $LEmbl "\n"] $BanqueId "embl"]
		set SeqCible [QueLaSequenceDuTexteTFA $TFA]
		set NouvelleInfo "IGBMC detected_through_a_blastn_in_OLIGO $FB"
		if {[string equal -nocase $Seq $SeqCible]} {
		    if {$Fournis=="" || $Fournis=="IGBMC"} {
			set NouveauFournis $NouvelleInfo
		    } elseif { ! [regexp $NouvelleInfo $Fournis]} {
			set NouveauFournis "$Fournis $NouvelleInfo"
		    }
		    Fournisseur $P $NouveauFournis
		    set SaveOlIgbmc 1
		    OlIgbmc $P $BanqueId
		    break 
		}
		continue
	    }
	}
    }
    if {$SaveOlIgbmc} { OlIgbmc Save }
    return

}

proc BlastNDesContigsPures {} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global NotreOS
    
    set BanqueBlastN "$RepertoireDuGenome/banques/[PreFixe]"
    if { ! [file exists "$BanqueBlastN.nhr"]} {
	if {[OuiOuNon "Blastn database $BanqueBlastN doesn't exists.\n Do I create it ?"]} {
	    CreeLaBanqueBlastPureSansTroncon
	} else {
	    return ""
	}
    }
    set RepBlastN "$RepertoireDuGenome/blastn"
    if { ! [file exists $RepBlastN]} { File mkdir $RepBlastN }

    catch {unset ADN}
    catch {unset TDN}
    catch {unset RAC}

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC ".pure" }

    set OnAttendLeDernierContigDejaTraite 0
    set OnAttendLeDernierHomologueBon 0

    set FichierOuOntTapeLesContigs "$RepertoireDuGenome/fiches/ouonttapelescontigs"
    while {[file exists $FichierOuOntTapeLesContigs]} {
	if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I replace it ?"]} {
	    File delete $FichierOuOntTapeLesContigs
	    break
	}
	if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I append to it ?"]} {
	    set DernierHomologueBon [lindex [LesLignesDuFichier $FichierOuOntTapeLesContigs] end]
	    scan $DernierHomologueBon "%s" DernierContigDejaTraite
	    set OnAttendLeDernierContigDejaTraite 1
	    set OnAttendLeDernierHomologueBon 0
	    Espionne $DernierContigDejaTraite
	    Espionne $DernierHomologueBon

	    break
	}
	if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I cancel ?"]} {
	    return ""
	}
	if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I stop ?"]} {
	    exit
	}
    }

    NousAllonsAuBoulot
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdescontigs"] {
	scan $Ligne "%s %d %d" Contig Debut Fin
	set Orient "F"

	Espionne $Ligne

	if {$OnAttendLeDernierContigDejaTraite && ! [regexp $Contig $DernierContigDejaTraite]} { continue }
	set OnAttendLeDernierContigDejaTraite 0
 	set SeqNuc [BoutADN $Debut $Fin $Orient]
	set TFA [SequenceFormatTFA $SeqNuc "$Contig $Debut $Fin $Orient" "nucbrut"]
	set FichierTFA [Sauve $TFA dans $Contig]
	set FichierBlastN "$RepBlastN/[PreFixe]-$Contig"

	set CommandeBlast "blastall  -p blastn  -d $BanqueBlastN  -i $FichierTFA  -o $FichierBlastN  -q -1 -F T -G 6 -E 1"
	if { ! [file exists $FichierBlastN]} {
	    Espionne "BlastN de $FichierTFA sur $BanqueBlastN"
	    eval exec $CommandeBlast
	    Espionne " --------> resultat dans $FichierBlastN"
	}
	foreach Homo [LesHomologiesDuBlastN $FichierBlastN "" $BanqueBlastN] {
	    set lHomo [split $Homo "\t"]
	    set i -1
	    set Nom        [lindex $lHomo [incr i]]
	    set nCops      [lindex $lHomo [incr i]]
	    set nCopsSeq   [lindex $lHomo [incr i]]
	    set BanqueId   [lindex $lHomo [incr i]]
	    set OrgaHomo   [lindex $lHomo [incr i]]
	    set Identities [lindex $lHomo [incr i]]
	    set Expect     [lindex $lHomo [incr i]]
	    set DebutQuery [lindex $lHomo [incr i]]
	    set FinQuery   [lindex $lHomo [incr i]]
	    set DebutSbjct [lindex $lHomo [incr i]]
	    set FinSbjct   [lindex $lHomo [incr i]]
	    set SeqSbjct   [lindex $lHomo [incr i]]

	    set DebutQuery [expr $DebutQuery + $Debut -1]
	    set FinQuery   [expr $FinQuery   + $Debut -1]

	    set Homologue "$Nom\t$nCops\t$nCopsSeq\t$BanqueId\t$OrgaHomo\t$Identities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct"
	    Espionne "$Nom\t$nCops\t$nCopsSeq\t$Identities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct"
	    if {$OnAttendLeDernierHomologueBon && $Homologue != $DernierHomologueBon} { continue }
	    set OnAttendLeDernierHomologueBon 0
	    lappend LesHomologues $Homologue
	    AppendAuFichier $FichierOuOntTapeLesContigs $Homologue
	}
    }
    OnRevientDuBoulot
    catch {unset ADN}
    catch {unset TDN}
    catch {unset RAC}

}

proc BlastNDesFichiers {{Banque human} {EditCommand 0} {LesNomATraiter ""}} {

    global RepertoireDuGenome
    global GardeToutBlastNPourTous
    global TestExistenceBlastNPourTous

    JeMeSignale
    
    if {$LesNomATraiter == {}} {set LesNomATraiter [ListeDesPABs]}

    set NomDeLaBanque "/blast/$Banque"
    while { ! [file exists "$NomDeLaBanque.nhr"] && ! [file exists "$NomDeLaBanque.nal"]} {
	if {[OuiOuNon "The blastn database $NomDeLaBanque doesn't exist.\n  Do I cancel BlastNPourTous ?"]} {
	    return ""
	}
	FaireLire "Please complete the full name of the blastn database"
	set NomDeLaBanque [Entre "/genomics/link/"]
	set Banque [file tail $NomDeLaBanque]
    }

    set Repertoire "$RepertoireDuGenome/blastn${Banque}"
    if { ! [file exists "$Repertoire"]} {File mkdir $Repertoire}

    if {[info exists CommandeBlastNPourTous]} {
	set CommandeBlast $CommandeBlastNPourTous
	if {[info exists GardeToutBlastNPourTous]} {set GardeTout $GardeToutBlastNPourTous
	} else {setGardeTout 0}

	if {[info exists TestExistenceBlastNPourTous]} {
	    set TestExistence $TestExistenceBlastNPourTous
	} else {set TestExistence 1}

    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastNDataBase [LocaliseBlastNDataBase $NomDeLaBanque]
	if {$BlastNDataBase==""} { return "" }
	set CommandeBlast "eval exec blastall  -p blastn  -i \$FichierTFA  -o \${FichierBlast}.encours  -d $BlastNDataBase  -v 500  -K 0  -b 500  -e 10.0  -F T"

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	}
	if {![OuiOuNon "Would you want to save your BLAST files in this directory : $Repertoire"]} {
	    set Repertoire [Entre $Repertoire]
	    if {![file exists $Repertoire]} {File mkdir $Repertoire}
	}

	if {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {    
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I have to keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
	    } else {
		if {[OuiOuNon "Some files exist in $Repertoire\nDo I have to replace all of them ?"]} {
		    set TestExistence 0
		    set GardeTout 0
		    if {[OuiOuNon "Some files exist in $Repertoire\nDo I have to ask for each ?"]} {
			set TestExistence 1
			set GardeTout 0
		    }
		}
	    }
	} else {
	    set TestExistence 1
	    set GardeTout 1
	}
	set CommandeBlastNPourTous $CommandeBlast
	set GardeToutBlastNPourTous $GardeTout
	set TestExistenceBlastNPourTous $TestExistence
    }

    set TestLongueurMinimale [OnTraiteDesCDNAs]
    set SeuilLongueur 9

    ####################################################
    set LesRepTFA {}
    if {[file exists "$RepertoireDuGenome/nuctfa"]} {
	lappend LesRepTFA "$RepertoireDuGenome/nuctfa"
    }
    if {[file exists "$RepertoireDuGenome/nucmask"]} {
	lappend LesRepTFA "$RepertoireDuGenome/nucmask"
    }
    if {[file exists "$RepertoireDuGenome/mrnahuman"]} {
	lappend LesRepTFA "$RepertoireDuGenome/mrnahuman"
    }

    set RepTFA [ChoixParmi $LesRepTFA]
    if {$RepTFA == ""} {return ""}

    foreach Nom $LesNomATraiter {
	AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"

	set FichierTFA   "$RepTFA/$Nom"
	if { ! [file exists $FichierTFA]} {continue}	

	set FichierBlast "$Repertoire/$Nom"

	if {$TestLongueurMinimale} {
	    set LeTFA [LesLignesDuFichier $FichierTFA]
	    set Seq [join [lrange $LeTFA 1 end]]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    if {[string length $SeqSansN]<$SeuilLongueur} { continue }
	}
	
	if {$GardeTout && [file exists $FichierBlast] } {
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		continue
	    }
	}

	Espionne "Je vais lancer blastn sur $FichierBlast"
	Sauve "$Nom en cours..." dans $FichierBlast
	if {[catch {eval $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}   }   
}

proc BlastNDesTrousPourTous {{Banques ""}} {

    set ListeDesTrous [ListeDesTROUs]
    BlastNPourTous $Banques $ListeDesTrous "" F 1

}

proc BlastNDuFichier {FichierTFA {Banque human} {FichierBlast ""} {Filtre T} {NbSubject 500} {Expect 10.0} {EditCommand 0}} {

    global RepertoireDuGenome
 
    if {[NombreDeBasesContinuesMax $FichierTFA] == 15} {return ""}

    if {$Banque != "human"} {AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"}

    if {[regexp "/" $Banque]} {
	set NomDeLaBanque "$Banque"
    } else {
	set NomDeLaBanque "/blast/$Banque"
    }

    if {$Filtre != "T"} {set Filtre "F"}

    set Repertoire [RepertoireDeTravail]

    if {0 && [regexp -nocase "human" $NomDeLaBanque]} { append CommandeBlastN " -g F" }

    if {$EditCommand == 1 && [OuiOuNon "Do You want to edit the BlastN command ?" 0]} {
	set CommandeBlastX [Entre $CommandeBlastN]
    }
    if { ! [file exists "$Repertoire"] && [OuiOuNon "Do I create $Repertoire"]} {
	File mkdir $Repertoire
    }
    set FileName [file tail $FichierTFA]
    if {$FichierBlast == ""} {
	set FichierBlast "$Repertoire/$FileName.blastN"
    }     
    if { ! [file exists $FichierTFA]} { 
	Warne "$FichierTFA doesn't exist."
	exit
    }
    set CommandeBlastN "exec blastall  -p blastn  -i $FichierTFA  -o $FichierBlast  -d $NomDeLaBanque  -v $NbSubject  -F $Filtre  -b $NbSubject  -e $Expect"

    eval $CommandeBlastN

    return $FichierBlast

}

proc BlastNGenesPubliesContreBanqueAffy {} {

    global RepertoireDuGenome
    #choisir le fichier qui contient la liste des access
    set FichierTemp [ButineArborescence All]
    if { ! [file exists $FichierTemp]} {return "The file does not exist"}
    foreach Ligne [LesLignesDuFichier $FichierTemp] {
	scan $Ligne "%s" AC
	if {$AC==""} {continue}
	set FichierBlast "[GscopeDatabaseDir AffyHS]/blastnpapiers/$AC"
	if {[file exists $FichierBlast]} {
	    Espionne "Blast already done"
	    continue 
	}
	set Query [SequenceAcNuc $AC]
	if {$Query==""} {
	    Espionne "No sequence found"
	    continue
	}
	set FichierTmp "$RepertoireDuGenome/temp/TFAtemp/$AC"
	set FichierTFA [Sauve [SequenceFormatTFA $Query] dans "$FichierTmp"]
	Espionne "BlastN launched for : $AC"
	set NbSubject      10
	set ExpectDeRef    1e-3
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir AffyHS]/banques/AffyHS"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	File delete -force $FichierTFA
    }

}

proc BlastNGenesPubliesContreBanqueDD {} {

    global RepertoireDuGenome
    #choisir le fichier qui contient la liste des access
    set FichierTemp [ButineArborescence All]
    if { ! [file exists $FichierTemp]} {return "The file does not exist"}
    foreach Ligne [LesLignesDuFichier $FichierTemp] {
	scan $Ligne "%s" AC
	if {$AC==""} {continue}
	set Rep "$RepertoireDuGenome/blastnpapiers/"
	if {![file exists $Rep]} {File mkdir $Rep}
	set FichierBlast "$Rep/$AC"
	if {[file exists $FichierBlast]} {
	    Espionne "Blast already done"
	    continue 
	}
	set Query [SequenceAcNuc $AC]
	if {$Query==""} {continue}
	set RepTmp "$RepertoireDuGenome/temp/TFAtemp/"
	if {![file exists $RepTmp]} {File mkdir $RepTmp}
	set FichierTmp "$RepTmp/$AC"
	set FichierTFA [Sauve [SequenceFormatTFA $Query] dans "$FichierTmp"]
	Espionne "BlastN launched for : $AC"
	set NbSubject      10
	set ExpectDeRef    1e-3
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir HeadNeck3]/banques/bankDD"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	File delete -force $FichierTFA
    }

}

proc BlastNLesGenesCGHAmpli {NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    set RepTFAAmpli "[RepertoireDuGenome]/PRIMA_CGH_Fasta_Ampli/*"
    if {![file exists $RepTFAAmpli]} {return "$RepTFAAmpli does not exist"}
    foreach FichierTFA [glob -nocomplain $RepTFAAmpli/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}
	
	Espionne "$Nom -> blastn  / banqueCGH"
	set NbSubject      50
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/GenesCGH"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blast done"
    }

}

proc BlastNLesGenesCGHDelet {NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    foreach FichierTFA [glob -nocomplain "[RepertoireDuGenome]/PRIMA_CGH_Fasta_Del/*"] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}
	
	Espionne "$Nom -> blastn  / banqueCGH"
	set NbSubject      50
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/GenesCGH"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blast done"
    }

}

proc BlastNNuctfaContreBanqueAffy {Nom NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
    if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}
    set FichierTFA "[RepertoireDuGenome]/nucmask/$Nom"
    if {![file exists $FichierTFA]} {Espionne "$FichierTFA does not exist";return ""}
    Espionne "$Nom -> blastn nucmask / AffyTarget"
    set NbSubject      50
    set ExpectDeRef    10.0
    set FichierBlastTmp [TmpFile]
    set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
    if {[file exists $FichierBlastTmp]} {
	File rename -force $FichierBlastTmp $FichierBlast
    }
    Espionne "$Nom -> blast done"

}

proc BlastNPourTous {{Banque ""} {NomATraiter ""} {RepQuery ""} {Filtre ""} {NbProc ""}} {

    global RepertoireDuGenome
    global GardeToutBlastNPourTous
    global TestExistenceBlastNPourTous

    if {$Banque==""} { set Banque "human" }
    
    if {$Filtre==""} { set Filtre "T" }
    if {$NbProc==""} { set NbProc 1 }

    if {$NomATraiter==""} {
	set Liste [ListeDesPABs]
    } elseif {[string equal -nocase $NomATraiter "AskForSubList"]} {
	set Liste [SousListe [ListeDesPABs]]
    } elseif {[llength $NomATraiter]>1} {
	set Liste $NomATraiter
    } else {
	set Liste [list $NomATraiter]
    }

#    set NomDeLaBanque $Banque
    set NomDeLaBanque "/catalog/blast/$Banque"
    while { ! [file exists "$NomDeLaBanque.nhr"] && ! [file exists "$NomDeLaBanque.nal"]} {
	set Possible "[RepertoireDuGenome]/banques/$Banque"
	if {[file exists "$Possible.nhr"] || [file exists "$Possible.nal"]} {
	    if {[OuiOuNon "Do I use $Possible ?"]} {
		set NomDeLaBanque $Possible
		set Banque [file tail $NomDeLaBanque]
		break
	    }
	}
	if {[OuiOuNon "The blastn database $NomDeLaBanque doesn't exist.\n  Do I cancel BlastNPourTous ?"]} {
	    return ""
	}
	FaireLire "Please complete the full name of the blastn database"
	set NomDeLaBanque [Entre "[RepertoireDuGenome]/"]
	set Banque [file tail $NomDeLaBanque]
    }

    set Repertoire "$RepertoireDuGenome/blastn$Banque"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[OnTraiteDesCDNAs] && $Banque=="human" && ! [file exists "$RepertoireDuGenome/blastn"]} {
	set Link "$RepertoireDuGenome/blastn"
	if {[OuiOuNon "Do I create a link \n $Link -> \n $Repertoire\n ?"]} {
	    exec ln -s $Repertoire $Link
	}
    } 

    if { ! [file exists "$RepertoireDuGenome/nucmask"]} {
	if {[OuiOuNon "Do You want to run RepeatMasker for all ?" 0]} {
	    RepeatMaskerForAll
	}
    }

    if {[info exists CommandeBlastNPourTous]} {
	set CommandeBlast $CommandeBlastNPourTous
	if {[info exists GardeToutBlastNPourTous]} {
	    set GardeTout $GardeToutBlastNPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistenceBlastNPourTous]} {
	    set TestExistence $TestExistenceBlastNPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastNDataBase [LocaliseBlastNDataBase $NomDeLaBanque]
	if {$BlastNDataBase==""} { return "" }
	set CommandeBlast "blastall  -p blastn  -i \$FichierTFA  -o \${FichierBlast}.encours  -d $BlastNDataBase  -v 100  -K 0  -b 100  -e 10.0  -F $Filtre  -a $NbProc"

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastNPourTous $CommandeBlast
	set GardeToutBlastNPourTous $GardeTout
	set TestExistenceBlastNPourTous $TestExistence
    }

    set TestLongueurMinimale [OnTraiteDesCDNAs]
    set SeuilLongueur 9

    foreach Nom $Liste {
	if {[PasTouche $Nom]} { continue }

	set FichierTFA ""
	if {$RepQuery==""} {
	    set ListeDesReps [list  "[RepertoireDuGenome]/nucMaskAndReMask"  "[RepertoireDuGenome]/nucmask"  "[RepertoireDuGenome]/nuctfa"] 
	} else {
	    set ListeDesReps $RepQuery
	}
	foreach Rep $ListeDesReps {
	    set FichierTFA "$Rep/$Nom"
	    if {[file exists $FichierTFA]} { break }	
	}
	if { $FichierTFA=="" || ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA doesn't exist."
	    FinPasTouche $Nom
	    continue
	}
	set FichierBlast "$Repertoire/$Nom"

	if {$TestLongueurMinimale} {
	    set LeTFA [LesLignesDuFichier $FichierTFA]
	    set Seq [join [lrange $LeTFA 1 end]]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    if {[string length $SeqSansN]<$SeuilLongueur} {
		FinPasTouche $Nom
		continue
	    }
	}
	
	if {$GardeTout && [file exists $FichierBlast] } {
	    FinPasTouche $Nom
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		FinPasTouche $Nom
		continue
	    }
	}

	Espionne "Je vais lancer blastn sur $FichierBlast"
	if {[catch {eval exec $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    CorrectionPourVarsplicDuBlastP "${FichierBlast}.encours"
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
	}
	FinPasTouche $Nom
    }

}

proc BlastNPourTousEviVsADNc {{NomATraiter ""} {RepQuery ""} {Filtre ""} {NbProc ""}} {


    global RepertoireDuGenome
    global GardeToutBlastNPourTous
    global TestExistenceBlastNPourTous

    
    if {$Filtre==""} { set Filtre "T" }
    if {$NbProc==""} { set NbProc 1 }
    
    if {$NomATraiter==""} {
	set Liste [ListeDesPABs]
    } elseif {[llength $NomATraiter]>1} {
	set Liste $NomATraiter
    } else {
	set Liste [list $NomATraiter]
    }
    set Banque SuperSouris
    set Repertoire "$RepertoireDuGenome/blastn$Banque"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    set GardeTout 0
    set TestExistence 1
    set BlastNDataBase "/genomics/link/SuperSouris/banques/SuperSouris"
    if {$BlastNDataBase==""} { return "" }
    set CommandeBlast "blastall  -p blastn  -i \$FichierTFA  -o \${FichierBlast}.encours  -d $BlastNDataBase  -v 500  -K 0  -b 500  -e 10.0  -F $Filtre  -a $NbProc"
    set GardeToutBlastNPourTous $GardeTout
    set TestExistenceBlastNPourTous $TestExistence

    foreach Nom $Liste {
	if {[PasTouche $Nom]} { continue }

	set FichierTFA ""
	if {$RepQuery==""} {
	    set ListeDesReps [list  "[RepertoireDuGenome]/nucMaskAndReMask"  "[RepertoireDuGenome]/nucmask"  "[RepertoireDuGenome]/nuctfa"] 
	} else {
	    set ListeDesReps $RepQuery
	}
	foreach Rep $ListeDesReps {
	    set FichierTFA "$Rep/$Nom"
	    if {[file exists $FichierTFA]} { break }	
	}
	if { $FichierTFA=="" || ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA doesn't exist."
	    FinPasTouche $Nom
	    continue
	}
	set FichierBlast "$Repertoire/$Nom"
	
	if {$GardeTout && [file exists $FichierBlast] } {
	    FinPasTouche $Nom
	    continue 
	}

	Espionne "Je vais lancer blastn sur $FichierBlast"
	if {[catch {eval exec $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    CorrectionPourVarsplicDuBlastP "${FichierBlast}.encours"
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
	}
	FinPasTouche $Nom
    }

}

proc BlastNPourTousLesDDContreAffymetrix {FichierClusters {RepBlast blastntargetaffy} {Banque "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget"}} {


    set RepBlastAffy "[RepertoireDuGenome]/$RepBlast"
    if {![file exists $RepBlastAffy]} {File mkdir $RepBlastAffy}
    
    set RepTemp "[RepertoireDuGenome]/temp/pourblastnaffy"
    if {![file exists $RepTemp]} {File mkdir $RepTemp}
	    
    foreach JR [ListeMinimumDesJR $FichierClusters] {
	set Vu($JR) 1
    }

    set FichierDesAccess "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis"

    foreach Ligne [LesLignesDuFichier $FichierDesAccess] {
	scan $Ligne "%s %s %s %s" nom prot rna orga
	Espionne $nom
	if {! [info exists Vu($nom)]} {continue}
	
	set FichierBlast "$RepBlastAffy/$nom"
	if {[file exists $FichierBlast]} {continue}

	set SequenceProteique 0
	if {$prot=="NoProtein" && $rna=="NomRNA"} {
	    #on pourrait aller voir la proteine trouvee par contig...
	    set FichierMRM "[RepertoireDuGenome]/nucmask/$nom"
	    if {![file exists $FichierMRM]} {continue}
	    set FichierTFAPourLeBlast $FichierMRM	    
	}
	if {![regexp "Homo" $orga] && ![regexp "Mus" $orga]} {continue}
	
	if {$prot!="NoProtein" && $rna!="NomRNA"} {
	    #recherche de la sequence par la methode fred
	    set SequenceDeLaProteine [SequenceDeLAccess $prot]
	    if {$SequenceDeLaProteine==""} {
		#recherche de la seq par la methode rr
		set TexteEmbl [join [LaSequenceDesBanques $prot] "\n"]
		if {$TexteEmbl==""} {
		    #RNA
		    set SequenceDeLARNm [SequenceDeLAccess $rna]
		    if {$SequenceDeLARNm==""} {continue}
		    set SequenceFormatTFA [SequenceFormatTFA $SequenceDeLARNm "$nom mRNA $rna"] 
		} else {
		    set SequenceFormatTFA [SequenceFormatTFA $TexteEmbl "$nom Proteine $prot" "embl"]
		    set SequenceProteique 1		    
		}
	    } else {
		#proteine
		set SequenceFormatTFA [SequenceFormatTFA $SequenceDeLaProteine "$nom Proteine $prot" "brut"]		
		set SequenceProteique 1
	    }
	    set FichierTFAPourLeBlast "$RepTemp/$nom"
	    if {![file exists $FichierTFAPourLeBlast]} {
		set FichierTFAPourLeBlast [Sauve $SequenceFormatTFA dans "$RepTemp/$nom"]
	    }
	}
	
	if {$rna=="NomRNA" && $prot!="NoProtein"} {	    
	    set SequenceDeLaProteine [SequenceDeLAccess $prot]
	    if {$SequenceDeLaProteine==""} {
		set TexteEmbl [join [LaSequenceDesBanques $prot] "\n"]
		if {$TexteEmbl==""} { continue }
		set SequenceFormatTFA [SequenceFormatTFA $TexteEmbl "$nom Proteine $prot" "embl"]
		set SequenceProteique 1
	    } else {
		set SequenceFormatTFA [SequenceFormatTFA $SequenceDeLaProteine "$nom Proteine $prot" "brut"]		
		set SequenceProteique 1
	    }
	    set FichierTFAPourLeBlast "$RepTemp/$nom"
	    if {![file exists $FichierTFAPourLeBlast]} {
		set FichierTFAPourLeBlast [Sauve $SequenceFormatTFA dans "$RepTemp/$nom"]
	    }
	} 
	if {$rna!="NomRNA" && $prot=="NoProtein"} {
	    set SequenceDeLARNm [SequenceDeLAccess $rna]
	    if {$SequenceDeLARNm==""} {continue}
	    set SequenceFormatTFA [SequenceFormatTFA $SequenceDeLARNm "$nom mRNA $rna"]
	    set FichierTFAPourLeBlast "$RepTemp/$nom"
	    if {![file exists $FichierTFAPourLeBlast]} {
		set FichierTFAPourLeBlast [Sauve $SequenceFormatTFA dans "$RepTemp/$nom"]
	    }
	}
	set NbSubject      10
	set ExpectDeRef    1e-3
	set FichierBlastTmp [TmpFile]
	if {$SequenceProteique==1} {
	    Espionne "Je lance $FichierTFAPourLeBlast en TblastN contre $Banque"
	    set FichierBlastTmp [TBlastNDuFichier $FichierTFAPourLeBlast  $Banque  1 $FichierBlastTmp]
	} else {
	    Espionne "Je lance $FichierTFAPourLeBlast en BlastN contre $Banque"
	    set FichierBlastTmp [BlastNDuFichier $FichierTFAPourLeBlast  $Banque  $FichierBlastTmp  T $NbSubject $ExpectDeRef 10]
	}
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	File delete -force $FichierTFAPourLeBlast
	Espionne "$nom fini"
    }

}

proc BlastNmRNAHumanContreBanqueAffy {Nom NomRepBlast} {

    if {![file exists $NomRepBlast]} {file mkdir $NomRepBlast}
    set FichierBlast "$NomRepBlast/$Nom"
    if {[file exists $FichierBlast]} {
	Espionne "$Nom: Blast already done"; return ""
    }
    
    set RepmrnatfaHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    if {![file exists $RepmrnatfaHs]} {Espionne "no rep mrna" ; return ""}

    set FichierTFA "$RepmrnatfaHs/$Nom"
    if {![file exists $FichierTFA]} {Espionne "no mrna" ; return ""}

    Espionne "$Nom -> blastn mrnatfa / AffyTarget"
    set NbSubject      50
    set ExpectDeRef    10
    set FichierBlastTmp [TmpFile]
    set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
    if {[file exists $FichierBlastTmp]} {
	File rename -force $FichierBlastTmp $FichierBlast
    }
    Espionne "$Nom -> blast done"

}

proc BlastNmRNAPourTous {{LesNoms ""} {LesOrgasToKeep ""} {IdWithoutFilter ""} {Expect ""}} {

    global RepertoireDuGenome
    set RepBlastNGenembl "$RepertoireDuGenome/blastngenembl"
    set RepBlastNmRNA    "$RepertoireDuGenome/blastnmrna"

    if {$LesOrgasToKeep == ""} {
	if {[OuiOuNon "Would you want to select the mRNA complete CDS of Noe's selection (yes)? or the mRNA of any organism (no)?"]} {
	    set LesOrgasToKeep [LaSelectionDeNoe]
	}
    } else {
	if {$LesOrgasToKeep == "Noe"} {set LesOrgasToKeep [LaSelectionDeNoe]}
    }
    if {$IdWithoutFilter == ""} {
	if {[OuiOuNon "Would you want to select a threshold for the Identity?"]} {
	    set IdWithoutFilter [Entre 0.95]
	}
    }
    if {$Expect == ""} {
	if {[OuiOuNon "Would you want to select a threshold for the Expect value?"]} {
	    set Expect [Entre 0.001]
	}
    }
    if {![file exists $RepBlastNmRNA]} {File mkdir $RepBlastNmRNA}

    if {$LesNoms == {}} {set LesNoms [ListeDesPABs]}
    foreach Nom $LesNoms {
	if {![file exists "$RepBlastNGenembl/$Nom"]} {continue}
	
	set FileBlastNmRNA    "$RepBlastNmRNA/$Nom"
	if {[file exists $FileBlastNmRNA]} {
	    if {![info exists Keep]} {if {[OuiOuNon "Do I keep existing files?"]} {set Keep 1} else {set Keep 0}}

	    if {$Keep} {continue}
	}

	set FileTmp           "$RepBlastNmRNA/$Nom.tmp"
	if {[file exists $FileTmp]} {continue}

	Espionne "$Nom -> blastngenembl -> blastnmrna"
	set FileBlastNGenembl "$RepBlastNGenembl/$Nom"

	BlastmRNA $FileBlastNGenembl $FileBlastNmRNA $IdWithoutFilter $Expect $LesOrgasToKeep
    }
    return

}

proc BlastOutliers {{UseExpect ""} {Clade ""}} {

    return [HistoDelta $Clade "" Show "" $UseExpect]

}

proc BlastPDeLaPreditePourTous {{NomATraiter ""}} {

    global RepertoireDuGenome
    global CommandeBlastPPourTous
    global GardeToutBlastPPourTous
    global TestExistenceBlastPPourTous

    JeMeSignale
    
    if {$NomATraiter == ""} {
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $NomATraiter]
    }

    set Repertoire "$RepertoireDuGenome/blastp"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[info exists CommandeBlastPPourTous]} {
	set CommandeBlast $CommandeBlastPPourTous
	if {[info exists GardeToutBlastPPourTous]} {
	    set GardeTout $GardeToutBlastPPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistenceBlastPPourTous]} {
	    set TestExistence $TestExistenceBlastPPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastPDataBase [LocaliseBlastPDataBase]
	if {$BlastPDataBase==""} { return "" }
	set CommandeBlast "blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast  -d $BlastPDataBase  -v 500  -K 0  -b 300  -e 30.0  -F F"

	#attention sur les consignes d'olivier j'ai enleve le filtre !!

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastPPourTous $CommandeBlast
	set GardeToutBlastPPourTous $GardeTout
	set TestExistenceBlastPPourTous $TestExistence
    }

    foreach Boite $Liste {
	set Nom [Box $Boite nom]

	set FichierTFA   "$RepertoireDuGenome/genscanpredictions/$Nom"
	set FichierBlast "$Repertoire/$Nom"
	Espionne "Je m'occupe de $Nom"

	if { ! [file exists $FichierTFA]} {
	    Espionne "$FichierTFA does not exist"
	    InformeSansDemander $Nom "=BlastP: $FichierTFA does not exist."
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		continue
	    }
	}
	Espionne "Je vais lancer BlastP sur $Nom"
	InformeSansDemander $Nom "=BlastP: prediction genscan trouvee"
	eval exec $CommandeBlast

	
    }

}

proc BlastPDesFichiers {{Banque protall} {LesNomATraiter ""}} {

    global RepertoireDuGenome
    global GardeToutBlastXPourTous
    global TestExistenceBlastXPourTous

    JeMeSignale

    set BlastPDataBase "/blast/$Banque"

    if { ! [file exists "$BlastPDataBase.pal"] && ! [file exists "$BlastPDataBase.phr"]} {
	return ""
    }

    if {$LesNomATraiter == {}} {set LesNomATraiter [ListeDesPABs]}

    set Repertoire "$RepertoireDuGenome/blastp"
    if { ! [file exists "$Repertoire"]} {File mkdir $Repertoire}

    if {[info exists CommandeBlastPPourTous]} {
	set CommandeBlast $CommandeBlastPPourTous
	if {[info exists GardeToutBlastPPourTous]} {set GardeTout $GardeToutBlastPPourTous
	} else {setGardeTout 0}

	if {[info exists TestExistenceBlastPPourTous]} {
	    set TestExistence $TestExistenceBlastPPourTous
	} else {set TestExistence 1}

    } else {
	set GardeTout 0
	set TestExistence 1
	if {$BlastPDataBase==""} { return "" }
	set CommandeBlast "eval exec blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastPDataBase  -v 500  -b 500 "

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	}

	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastPPourTous $CommandeBlast
	set GardeToutBlastPPourTous $GardeTout
	set TestExistenceBlastPPourTous $TestExistence
    }

    set TestLongueurMinimale [OnTraiteDesCDNAs]
    set SeuilLongueur 0

    ####################################################
    set LesRepTFA {}
    if {[file exists "$RepertoireDuGenome/prottfa"]} {
	lappend LesRepTFA "$RepertoireDuGenome/prottfa"
    } elseif {[file exists "$RepertoireDuGenome/genscanpredictions"]} {
	lappend LesRepTFA "$RepertoireDuGenome/genscanpredictions"
    }

    set RepTFA [ChoixParmi $LesRepTFA]
    if {$RepTFA == ""} {return ""}

    foreach Nom $LesNomATraiter {
	Espionne $Nom
	AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"

	set FichierTFA   "$RepTFA/$Nom"
	if {![file exists $FichierTFA]} {continue}

	set FichierBlast "$Repertoire/$Nom"

	if {$TestLongueurMinimale} {
	    set LeTFA [LesLignesDuFichier $FichierTFA]
	    set Seq [join [lrange $LeTFA 1 end]]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    if {[string length $SeqSansN]<$SeuilLongueur} { continue }
	}
	
	if {$GardeTout && [file exists $FichierBlast] } {
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		continue
	    }
	}

	Espionne "Je vais lancer blastp sur $FichierBlast"
	Sauve "$Nom en cours..." dans $FichierBlast
	if {[catch {eval $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}   }   
}

proc BlastPDuFichier {FichierTFA {Banque protall} {FichierBlast ""} {Filtre T} {NbSubject 500} {Expect 10.0} {EditCommand 0}} {

    global RepertoireDuGenome
    
    if {[NombreDeBasesContinuesMax $FichierTFA] == 15} {return ""}
    
    if {$Banque != "protall"} {AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"}
    #Espionne "--- blastp en cours ---"
    if {[regexp "/" $Banque]} {
	set NomDeLaBanque "$Banque"
    } else {
	set NomDeLaBanque "/blast/$Banque"
    }
    if {$Filtre != "T"} {set Filtre "F"}
    #c est le junkdir
    set Repertoire [RepertoireDeTravail]
    #if {0 && [regexp -nocase "human" $NomDeLaBanque]} { append CommandeBlastN " -g F" }
    if {$EditCommand == 1 && [OuiOuNon "Do You want to edit the BlastN command ?" 0]} {
	set CommandeBlastX [Entre $CommandeBlastN]
    }
    if { ! [file exists "$Repertoire"] && [OuiOuNon "Do I create $Repertoire"]} {
	File mkdir $Repertoire
    }
    set FileName [file tail $FichierTFA]
    if {$FichierBlast == ""} {
	set FichierBlast "$Repertoire/$FileName.blastP"
    }     
    if { ! [file exists $FichierTFA]} { 
	Warne "$FichierTFA doesn't exist."
	exit
    }
    ##ac
    set CommandeBlast "eval exec blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast  -d $NomDeLaBanque  -F $Filtre  -e $Expect  -v $NbSubject  -b $NbSubject "
    eval $CommandeBlast
    return $FichierBlast

}

proc BlastPGrid {NomATraiter} {

    
    global DefautsPipe
    global PipeCollection

    if {$PipeCollection} {
	set Repertoire [file join [RepertoireDuGenome] "blastp"]
	set FichierTFA [file join [RepertoireDuGenome] "prottfa" "$NomATraiter"]
	set FichierBlast [file join $Repertoire $NomATraiter]
    } else {
	set FichierTFA   $NomATraiter
	set FichierBlast "[file rootname ${NomATraiter}].blastp"
    }

    if {! [file exists $FichierTFA]} { 
	Espionne "$FichierTFA does not exist."
	return 0
    }

    # pour Nicolas G
    if {[file exists $FichierBlast] && [llength [LesLignesDuFichier $FichierBlast]] > 10} {
	return 1
    }

    set DBlast ""
    foreach e [array names DefautsPipe "Blast,*"] {
	set option [lindex [split $e ","] 1]
	set val [set DefautsPipe($e)]
	append DBlast "-$option $val "
    }

    set CommandeBlast "[BlastallExe] -i $FichierTFA -o $FichierBlast $DBlast"
    if {[catch {eval exec $CommandeBlast} Message]} {puts "$Message"}
    
    if {[file exists $FichierBlast]} {
	AjouteAuLogPipe "blastp = ok"
    } else {
	AjouteAuLogPipe "blastp failed"
    }

    return 1

}

proc BlastPLesGenesCGHAmpli {NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    set RepTFAAmpli "[RepertoireDuGenome]/PRIMA_CGH_Fasta_prot_Ampli_BAC_meta_0.07"
    if {![file exists $RepTFAAmpli]} {return "$RepTFAAmpli does not exist"}
    foreach FichierTFA [glob -nocomplain $RepTFAAmpli/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}
	
	Espionne "$Nom -> blastp  / banqueCGH"
	set NbSubject      50
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/ProtCGHBACmeta007"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blastp done"
    }

}

proc BlastPLesGenesCGHDelet {NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    set RepTFADelet "[RepertoireDuGenome]/PRIMA_CGH_Fasta_prot_Del_BAC_meta_0.07"
    if {![file exists $RepTFADelet]} {return "$RepTFADelet does not exist"}
    foreach FichierTFA [glob -nocomplain $RepTFADelet/*] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done";return ""}
	
	Espionne "$Nom -> blastp  / banqueCGH"
	set NbSubject      50
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/ProtCGHBACmeta007"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blastp done"
    }

}

proc BlastPPourBallast {FichierTFA {FichierBlast ""} {EditCommand 0} {Banque protall} {Expect 10} {Filtre 1} {ShowSubject 250}} {

    global RepertoireDuGenome

    AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"

    if {$Filtre} {	set Filtre "T"
    } else {   	        set Filtre "F"}
    
    set BlastPDataBase "/blast/$Banque"
    if { ! [file exists "$BlastPDataBase.pal"] && ! [file exists "$BlastPDataBase.phr"]} {
	return ""
    }
    set CommandeBlastX "eval exec blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast  -d \$BlastPDataBase  -F \$Filtre  -e \$Expect  -v \$ShowSubject  -b \$ShowSubject"

    if {$EditCommand == 1 && [OuiOuNon "Do You want to edit the BlastP command ?" 0]} {
	set CommandeBlastX [Entre $CommandeBlastX]
    }
    if {$FichierBlast == ""} {
	set RepBlast [RepertoireDeTravail]
	set FichierBlast "$RepBlast/[file tail $FichierTFA]\.blastp"
    }
    if { ! [file exists $FichierTFA]} { Warne "$FichierTFA doesn't exist.";exit}

#rR a rajoute le catch
    catch {eval $CommandeBlastX} Message
    if {[file exists $FichierBlast]} { return $FichierBlast }
    return ""

}

proc BlastPPourCollection {Nom} {

    Wup "Attention we call the BlastPPourTous for only one !!"
    BlastPPourTous $Nom

}

proc BlastPPourStrStat {{CodeGscope ""} {Expect ""}} {


    #Prendre en compte la possibilite de choisir les bases de donnees souhaite (par defaut: Uniprot et PDB)
    #Applique sur l'interface WEB!!

    set nbPDB 0
    set LesTFAsDeCop {}
    if { ! [file exists "tfasdescopains"]} {
	File mkdir tfasdescopains
    }
    set FileTFAsDesCopains [RepertoireDuGenome]/tfasdescopains/$CodeGscope

    #Ici mets les information de prottfa dans LesTFAsDeCop
    lappend LesTFAsDeCop ">$CodeGscope"
    lappend LesTFAsDeCop [QueLaSequenceDesBanques $CodeGscope]

    BlastPPourTous $CodeGscope "" "" $Expect   
    set FileBlast [RepertoireDuGenome]/blastp/$CodeGscope
    LoinToujours "NotUse"
    set LesElus [LesElusDuBlastPParBandelettes $FileBlast] 
    LoinToujours "Reset"
    foreach UnElu $LesElus {
	scan $UnElu "%s %s" BId Access
	if {[EstUnAccessPDB $BId]} {
	    incr nbPDB
	    #Etape 4
	    set res [ResolutionUnPDB $BId]
	    #plus petit que 0 alors il n'y a pas de resolution -> donc RMN
	    #plus grand que 4 pas bon
	    if {$res<0 || $res<=4 } {
		set EMBL [SequenceDesBanques $BId $Access "AccessOK" "OnVeutEMBL"]
		lappend LesTFAsDeCop [SequenceFormatTFA $EMBL "" "protembl"]
	    } else {
		Espionne "$BId resolution: $res"
	    }
	} else {
	    set EMBL [SequenceDesBanques $BId $Access "AccessOK" "OnVeutEMBL"]
	    lappend LesTFAsDeCop [SequenceFormatTFA $EMBL "" "protembl"]
	}
    }
    SauveLesLignes $LesTFAsDeCop dans $FileTFAsDesCopains
    #Espionne "NombreDePDB: $nbPDB"
    return $nbPDB

}

proc BlastPPourTous {{NomATraiter ""} {Banque ""} {AvecPasTouche ""} {Expect ""} {Vparam ""} {Bparam ""}} {

    global RepertoireDuGenome
    global CommandeBlastPPourTous
    global GardeToutBlastPPourTous
    global TestExistenceBlastPPourTous

    JeMeSignale
    
    set Extension [file tail $Banque]


    if {$Expect==""} { set Expect 10 }

    if {$AvecPasTouche==""} { set AvecPasTouche "AvecPasTouche" }
    set AvecPasTouche [string equal -nocase $AvecPasTouche "AvecPasTouche"]

    if {$NomATraiter=="" || $NomATraiter=="All"} {
	set NomATraiter ""
	set Liste [ListeDesPABs]
    } elseif {[regexp "," $NomATraiter]} {
	set Liste [split $NomATraiter ","]
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } elseif {$NomATraiter=="ListeDesFusions"} {
	set Liste [ListeDesFusions]
    } else {
	if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
	set Liste [list $NomATraiter]
    }

    set Repertoire "$RepertoireDuGenome/blastp$Extension"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[info exists CommandeBlastPPourTous]} {
	set CommandeBlast $CommandeBlastPPourTous
	if {[info exists GardeToutBlastPPourTous]} {
	    set GardeTout $GardeToutBlastPPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistenceBlastPPourTous]} {
	    set TestExistence $TestExistenceBlastPPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastPDataBase [LocaliseBlastPDataBase $Banque]
	set V 250
	set B $V
	if {[regexp "protall" $BlastPDataBase]} { set V 500; set B 500 }   ;#rR attention BlastPDatabase peut erte remplacé par d si BlastParameters
	if {[OnTraite "CilioCarta"]} { set V 1000; set B $V }
	if {[OnTraite "CilioCode"]}  { set V 1000; set B $V }
	if {[OnTraite "TTLL"]}       { set V 2000; set B $V }
	if {$Vparam!=""} { set V $Vparam }
	if {$Bparam!=""} { set B $Bparam }
	set p "blastp"
	set v $V
	set K 0
	set b $B
	set e $Expect
	set F "T"
	set d $BlastPDataBase
	set LesObliges " p i o d v b K e F "
	set MoreOptions ""
	foreach {Key Value} [BlastParameters] {
	    regsub -- {^\-+} $Key "" Key
	    if {[regexp " $Key " $LesObliges]} {
		set $Key $Value
	    } else {
		append MoreOptions " -$Key $Value"
	    }
	}
	if {$d==""} { return "" }             ;#rR je l'ai déplacé de la haut pour qu'il soit pris en compte
	set CommandeBlast "blastall  -p $p  -i \$FichierTFA  -o \$FichierBlast.encours  -d $d  -v $v  -b $b  -K 0  -e $e  -F $F  $MoreOptions"

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastPPourTous $CommandeBlast
	set GardeToutBlastPPourTous $GardeTout
	set TestExistenceBlastPPourTous $TestExistence
    }

    set FichierBlast ""
    foreach Nom $Liste {
	set NomOrigine $Nom
	set Nom [file tail $Nom]
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }
	if {[EstUnPAB $Nom]} {
	    set FichierTFA   "$RepertoireDuGenome/prottfa/$Nom"
	    set FichierTFABest "$RepertoireDuGenome/prottfaBEST/$Nom"
	    if {[file exists $FichierTFABest]} {set FichierTFA $FichierTFABest}
	} else {
	    set FichierTFA $NomOrigine
	    if { ! [file exists $FichierTFA]} { set FichierTFA "$NomOrigine.tfa" }
	}
	set FichierBlast "$Repertoire/$Nom"

	if { ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA does'nt exist."
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    Espionne "$Nom already done"
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		if {$AvecPasTouche} { FinPasTouche $Nom }
		continue
	    }
	}

	if {[set Dedicated [DedicatedBlastDatabase]]!=""} {
	    set BanqueDedicated "[RepertoireDuGenome]/$Dedicated"
	    set MaBanque "$BanqueDedicated/$Nom-plus"
Espionne $BanqueDedicated
	    if {[FileAbsent $MaBanque]} {
		set General [file tail $BlastPDataBase]
		lappend LeTexte "TITLE $General and $BanqueDedicated for $Nom"
		lappend LeTexte "DBLIST $BlastPDataBase $BanqueDedicated/$Nom"
		SauveLesLignes $LeTexte dans $MaBanque.pal
	    }
Espionne $MaBanque
Espionne $CommandeBlast
Espionne "-d $BlastPDataBase" 
	    regsub -- "-d $BlastPDataBase " $CommandeBlast "-d $MaBanque " CommandeBlast 
Espionne $CommandeBlast
	}

	catch {eval exec $CommandeBlast}
	if {[file exists "$FichierBlast.encours"]} {
	     file rename -force "$FichierBlast.encours" $FichierBlast
	}

	if {$AvecPasTouche} { FinPasTouche $Nom }
	Espionne $FichierBlast
    }
    DedicatedBlastDatabase "Reset"
    return $FichierBlast

}

proc BlastPPourTousDuFichier {Fichier} {

    set LesNoms {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Nom ""
	scan $Ligne "%s" Nom
	if { ! [EstUnPAB $Nom]} { continue }
	lappend LesNoms $Nom
    }
    if {$LesNoms=={}} { return "" }
    BlastPPourTous $LesNoms

}

proc BlastPPourTousOptionFiltre {{NomATraiter ""} {Banque ""} {AvecPasTouche ""} {Expect ""} {Filter ""}} {

    global RepertoireDuGenome
    global CommandeBlastPPourTous
    global GardeToutBlastPPourTous
    global TestExistenceBlastPPourTous

    JeMeSignale
    
    set Extension [file tail $Banque]

	if {$Filter==""} { set Filter "T" }

    if {$Expect==""} { set Expect 10 }

    if {$AvecPasTouche==""} { set AvecPasTouche "AvecPasTouche" }
    set AvecPasTouche [string equal -nocase $AvecPasTouche "AvecPasTouche"]

    if {$NomATraiter == ""} {
	set Liste [ListeDesPABs]
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } elseif {$NomATraiter=="ListeDesFusions"} {
	set Liste [ListeDesFusions]
    } else {
	if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
	set Liste [list $NomATraiter]
    }

    set Repertoire "$RepertoireDuGenome/blastp$Extension"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[info exists CommandeBlastPPourTous]} {
	set CommandeBlast $CommandeBlastPPourTous
	if {[info exists GardeToutBlastPPourTous]} {
	    set GardeTout $GardeToutBlastPPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistenceBlastPPourTous]} {
	    set TestExistence $TestExistenceBlastPPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastPDataBase [LocaliseBlastPDataBase $Banque]
	if {$BlastPDataBase==""} { return "" }
	set CommandeBlast "blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastPDataBase  -v 1000  -K 0  -b 250  -e $Expect  -F $Filter "

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastPPourTous $CommandeBlast
	set GardeToutBlastPPourTous $GardeTout
	set TestExistenceBlastPPourTous $TestExistence
    }

    set FichierBlast ""
    foreach Nom $Liste {
	set NomOrigine $Nom
	set Nom [file tail $Nom]
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }
	if {[EstUnPAB $Nom]} {
	    set FichierTFA   "$RepertoireDuGenome/prottfa/$Nom"
	    set FichierTFABest "$RepertoireDuGenome/prottfaBEST/$Nom"
	    if {[file exists $FichierTFABest]} {set FichierTFA $FichierTFABest}
	} else {
	    set FichierTFA $NomOrigine
	    if { ! [file exists $FichierTFA]} { set FichierTFA "$NomOrigine.tfa" }
	}
	set FichierBlast "$Repertoire/$Nom"

	if { ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA does'nt exist."
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    Espionne "$Nom already done"
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		if {$AvecPasTouche} { FinPasTouche $Nom }
		continue
	    }
	}

	catch {eval exec $CommandeBlast}
	if {[file exists "$FichierBlast.encours"]} {
	     file rename -force "$FichierBlast.encours" $FichierBlast
	}

	if {$AvecPasTouche} { FinPasTouche $Nom }
	Espionne $FichierBlast
    }
    return $FichierBlast

}

proc BlastPPourTousOptionFiltre2 {{NomATraiter ""} {Banque ""} {AvecPasTouche ""} {Expect ""} {Filter ""}} {

    global RepertoireDuGenome
    global CommandeBlastPPourTous
    global GardeToutBlastPPourTous
    global TestExistenceBlastPPourTous

    JeMeSignale
    
    set Extension [file tail $Banque]

	if {$Filter==""} { set Filter "T" }

    if {$Expect==""} { set Expect 10 }

    if {$AvecPasTouche==""} { set AvecPasTouche "AvecPasTouche" }
    set AvecPasTouche [string equal -nocase $AvecPasTouche "AvecPasTouche"]

    if {$NomATraiter == ""} {
	set Liste [ListeDesPABs2]
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } elseif {$NomATraiter=="ListeDesFusions"} {
	set Liste [ListeDesFusions]
    } else {
	if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
	set Liste [list $NomATraiter]
    }

    set Repertoire "$RepertoireDuGenome/blastp$Extension"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[info exists CommandeBlastPPourTous]} {
	set CommandeBlast $CommandeBlastPPourTous
	if {[info exists GardeToutBlastPPourTous]} {
	    set GardeTout $GardeToutBlastPPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistenceBlastPPourTous]} {
	    set TestExistence $TestExistenceBlastPPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	set BlastPDataBase [LocaliseBlastPDataBase $Banque]
	if {$BlastPDataBase==""} { return "" }
	set CommandeBlast "blastall  -p blastp  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastPDataBase  -v 2000  -K 0  -b 250  -e $Expect  -F $Filter "

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastPPourTous $CommandeBlast
	set GardeToutBlastPPourTous $GardeTout
	set TestExistenceBlastPPourTous $TestExistence
    }

    set FichierBlast ""
    foreach Nom $Liste {
	set NomOrigine $Nom
	set Nom [file tail $Nom]
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }
	if {1 || [EstUnPAB $Nom]} {
	    set FichierTFA   "$RepertoireDuGenome/prottfa/$Nom"
	    set FichierTFABest "$RepertoireDuGenome/prottfaBEST/$Nom"
	    if {[file exists $FichierTFABest]} {set FichierTFA $FichierTFABest}
	} else {
	    set FichierTFA $NomOrigine
	    if { ! [file exists $FichierTFA]} { set FichierTFA "$NomOrigine.tfa" }
	}
	set FichierBlast "$Repertoire/$Nom"

	if { ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA does'nt exist."
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    Espionne "$Nom already done"
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		if {$AvecPasTouche} { FinPasTouche $Nom }
		continue
	    }
	}

	catch {eval exec $CommandeBlast}
	if {[file exists "$FichierBlast.encours"]} {
	     file rename -force "$FichierBlast.encours" $FichierBlast
	}

	if {$AvecPasTouche} { FinPasTouche $Nom }
	Espionne $FichierBlast
    }
    return $FichierBlast

}

proc BlastPProtDDContreHumanTF {NomRepBlast} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/Old2Jumeaux/TousLesJumeaux.final.SansDbAccess"] {
	set Nom [lindex $Ligne 0]
	#Espionne "$Nom en cours..."
	set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
	if {![file exists $FichierTFA]} {Espionne "$FichierTFA does not exist";continue}
	#->Blast de prot dd contre les humanTF
	Espionne "$Nom -> blast / HumanTF"
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {
	    Espionne "Blast already done"
	    continue 
	}
	set NbSubject      10
	set ExpectDeRef    1e-3
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir HumanTF]/banques/bank_HumanTF"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
    }

}

proc BlastPString {FichierQuery TaxId {pid 98} {pcover 98}} {

    set banqueBlast [BanqueBlastString $TaxId]
    set fichierOut "$FichierQuery.blastp"

    if {![file isfile $FichierQuery]} {return ""}

    while {[catch {
	file delete $fichierOut
	exec blastall -p blastp -d $banqueBlast -i $FichierQuery -o $fichierOut -F F
    }]} {Espionne "RETRY BLASTALL ON $FichierQuery"}

    while {[catch {
	array unset blast
	DepouilleLeBlast blast $fichierOut
    }]} {Espionne "RETRY PARSE $fichierOut"}

    while {[catch {
	file delete $fichierOut
    }]} {Espionne "RETRY FILE DELETE $fichierOut"}

    for {set i 1} {$i <= $blast(NbSubject)} {incr i} {
	set ID $blast($i)
	#Identities = 23/76 (30%)
	if {![regexp {(\d+)/(\d+) \((\d+)%\)} $blast($ID,1,Identities) regMatch matches length pident]} {
	    error "WTFException: cannot parse Identities '$blast($ID,1,Identities)'"
	}
	set cover [expr double($length) / $blast($ID,Taille) * 100.0]
	if {$pident >= $pid && $cover >= $pcover} {
	    Espionne "PID: $pident% Cover: $cover%"
	    return [list [lindex [split $ID ":"] 1] [lindex $blast($ID,SubjectBrut) 1]]
	}
    }

    return ""

}

proc BlastPStringAvecSeuilExpect {FichierQuery TaxId {seuilExpect 1e-5}} {

    set banqueBlast [BanqueBlastString $TaxId]
    set fichierOut "$FichierQuery.[lindex [info level 0] 0].blastp"

    if {![file isfile $FichierQuery]} {return ""}

    while {[catch {
	file delete $fichierOut
	exec blastall -p blastp -d $banqueBlast -i $FichierQuery -o $fichierOut -F F
    }]} {Espionne "RETRY BLASTALL ON $FichierQuery"}
    
    while {[catch {
	array unset blast
	DepouilleLeBlast blast $fichierOut
    }]} {Espionne "RETRY PARSE $fichierOut"}

    while {[catch {
	file delete $fichierOut
    }]} {Espionne "RETRY FILE DELETE $fichierOut"}

    for {set i 1} {$i <= $blast(NbSubject)} {incr i} {
	set ID $blast($i)
	if {$blast($ID,1,Expect) <= $seuilExpect} {
	    return [list [lindex [split $ID ":"] 1] [lindex $blast($ID,SubjectBrut) 1]]
	}
    }

    return ""

}

proc BlastPStringGeneral {FichierQuery FichierOut TaxId} {

    JeMeSignale
    if {![file exists $FichierOut]} {
	set banqueBlast [BanqueBlastString $TaxId]
	catch {eval exec blastall -p blastp -d $banqueBlast -i $FichierQuery -o $FichierOut -F F}
    }
    set NbSujet  [AskBlast $FichierOut NbSubject]
    if {$NbSujet==0} {
	Espionne "$FichierQuery pas de subject"
	return "vide"
    } 
    set BId      [AskBlast $FichierOut Subject 1]
    set PID  [lindex [split $BId ":"] 1]
    set Access   [AskBlast $FichierOut BanqueId $BId Access]
    set NbSegment [AskBlast $FichierOut BanqueId $BId NbSegment]
 #   if {$NbSegment>1} {Espionne "attention pls segments"}
    set Exp [AskBlast $FichierOut BanqueId $BId Segment 1 Expect]
#    Espionne "BId $BId \nPID $PID \nAccess $Access \nNbSegment $NbSegment \nExp $Exp"
    if {$Exp<1e-20} {
	return "$PID"
    } else {
	return "vide"
    }

}

proc BlastPStringMoi {FichierQuery TaxId} {

    set banqueBlast [BanqueBlastString $TaxId]
    set fichierOut "$FichierQuery.blastp"
    Espionne "fichierOut $fichierOut"
    if {![file exists $fichierOut]} {
	exec blastall -p blastp -d $banqueBlast -i $FichierQuery -o $fichierOut -F F
    }
    set NbSujet  [AskBlast $fichierOut NbSubject]
    if {$NbSujet==0} {return "pas de subject"} 
    set BId      [AskBlast $fichierOut Subject 1]
    set PID  [lindex [split $BId ":"] 1]
    set Access   [AskBlast $fichierOut BanqueId $BId Access]
    set NbSegment [AskBlast $fichierOut BanqueId $BId NbSegment]
    if {$NbSegment>1} {Espionne "attention pls segments"}
    set Exp [AskBlast $fichierOut BanqueId $BId Segment 1 Expect]
    Espionne "BId $BId \nPID $PID \nAccess $Access \nNbSegment $NbSegment \nExp $Exp"
    #$Exp<1e-20
    if {$Exp<1e-19} {
	return "$PID"
    } else {
	return "vide"
    }

}

proc BlastPSurLesInconnus {} {

    set BlastNDataBase "protein"
    set RepertoireBlastp "[RepertoireDuGenome]/Tau/blastp"
    foreach FichierTFA [glob -nocomplain "$RepertoireBlastp/fasta/*"] {
	set Access [file tail $FichierTFA]
	set FichierBlastp "$RepertoireBlastp/$Access"
	set CommandeBlast "blastall  -p blastp  -i $FichierTFA  -o $FichierBlastp  -d $BlastNDataBase  -v 100  -K 0  -b 100  -e 10.0  -F F  -a 1"
	if {[catch {eval exec $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlastpOri"
	    Espionne $Message
	}
    }

}

proc BlastParameters {{Rep ""}} {

    if {$Rep==""} { set Rep "blastp" }
    if {[regexp "/" $Rep]} {
	set ParametersFile "$Rep/BlastParameters.txt"
    } else {
	set ParametersFile "[RepertoireDuGenome]/$Rep/BlastParameters.txt"
    }
    if {[FileAbsent $ParametersFile]}  { return {} }
    set LesKV {}
    foreach Ligne [LesLignesDuFichier $ParametersFile] {
	if {[regexp {^\#} $Ligne]} { continue }
	regsub RepertoireDuGenome $Ligne [RepertoireDuGenome] Ligne
	scan $Ligne "%s %s" K V
	regsub -- {^\-+} $K "" K
	lappend LesKV "-$K" $V
    }
    return $LesKV

}

proc BlastQueryVsARPs {FichierQuery {Database ""}} {


    Wup "Permet de blaster la query contre toutes les banques BLAST d ARP"

    set RepARP          "[RepARPAnno]"
    set RepBanque       "$RepARP/ARP_BLAST"

    set RepARP_Results  "[RepARPAnnoWeb]"
    set RepBlastResults "$RepARP_Results"

    if {! [file exists $RepBlastResults]} {
	file mkdir $RepBlastResults
    }

    set Query [file tail $FichierQuery]
    
    #On recupere les differentes banques BLAST des ARPs
    set LesB ""
    set  LesBanques_tmp [glob -nocomplain -directory "$RepBanque/" "*.tfa"]
    foreach Banque $LesBanques_tmp {
	regsub -all {.[a-z]{2,3}$} $Banque "" Banque
	if {$Database != ""} {
	    if {[regexp -nocase [file tail $Banque] $Database]} {
		lappend LesB $Banque
	    } else {
		continue
	    }
	} else {
	    lappend LesB $Banque
	}
    }

    #On les ordonne correctement ARP1 a ARP10
    set Last       ""
    set LesBanques ""
    set OnActin    0
    foreach B $LesB {
	if {[regexp -nocase "ARP10" $B]} {
	    set Last $B
	    continue
	} elseif {[regexp -nocase "actin" $B]} {
	    set OnActin 1
	    set LesBanques [linsert $LesBanques 0 $B]
	} elseif {[regexp -nocase "orphans" $B]} {
	    if {$OnActin} {
		set LesBanques [linsert $LesBanques 1 $B]
	    } else {
		set LesBanques [linsert $LesBanques 0 $B]
	    }
	} else {
	    lappend LesBanques $B
	}
    }
    if {$Last != ""} {lappend LesBanques $Last}
    #Espionne "$LesBanques"

    foreach Banque $LesBanques {
	set NomBanque    [file tail $Banque]
	set TypeDeBlast  "blastp"

	set BlastPOutput "$RepBlastResults/${Query}_${NomBanque}.blastp"
	if {[file exists $BlastPOutput]} {
	    file delete -force $BlastPOutput
	}
	
	set CommandeBlast "eval exec blastall  -p $TypeDeBlast  -i \$FichierQuery  -o \$BlastPOutput  -d $Banque  -v 500  -K 0  -b 500  -F F  -e 0.001  -a 4"
	
	if {[catch {eval $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierQuery"
	    Espionne $Message
	} else {
	    lappend LesOutputs $BlastPOutput
	}
    }

    return "$LesOutputs"

}

proc BlastReduit {NomOuFichier ListeDesHits {AGarder ""}} {


    if {$AGarder=="AEnlever"} { set AGarder 0 } else { set AGarder 1 }
    set AEnlever [expr  ! $AGarder]

    foreach Hit $ListeDesHits {
	scan $Hit "%s" BId
	set BID [string toupper $BId]
	if {$AGarder}  { set Garder($BID) 1 }
	if {$AEnlever} { set Enlever($BID) 1 }
    }


    if {[regexp "/" $NomOuFichier]} {
	set Fichier $NomOuFichier
    } else {
	set Nom $NomOuFichier
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
    }

    if { ! [file exists $Fichier]} { return {} }

    set AvantListe 1
    set DansListe 0
    set DansFin 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { $DansFin } {
	    lappend LeNouveau $Ligne
	    continue
	}
	if {[regexp "  Database:" $Ligne]} {
	    lappend LeNouveau $Ligne
	    set DansFin 1
	    continue
	}
	if { $AvantListe } {
	    if { [regexp "Sequences producing" $Ligne] } { set AvantListe 0 }
	    lappend LeNouveau $Ligne
	    set DansListe 1
	    set PremierBlanc 1
	    continue
	} 
	if {[regexp "^>" $Ligne]} {
	    scan $Ligne "%s %s" BId Access
	    regsub ">" $BId "" BId
	    set BID [string toupper $BId]
	    set ACCESS [string toupper $Access]

	    if {[info exists Garder($BID)] || [info exists Garder($ACCESS)]} {
		set GarderAlignement 1
		lappend LeNouveau $Ligne
	    } else {
		set GarderAlignement 0
	    }
	    continue
	}   
	if {[info exists GarderAlignement]} {
	    if {$GarderAlignement} {
		lappend LeNouveau $Ligne
	    }
	    continue
	}
	if {$DansListe} {
	    if { $PremierBlanc } {
		lappend LeNouveau $Ligne
		set DansListe 1
		set PremierBlanc 0
		continue
	    }
	    if { ! [regexp -nocase {[A-Z]} $Ligne]} {
		set DansListe 0
		lappend LeNouveau $Ligne
		continue
	    }
	    scan $Ligne "%s %s" BId Access
	    set BID [string toupper $BId]
	    set ACCESS [string toupper $Access]

	    if {$AEnlever && ! [info exists Enlever($BID)]} { set Garder($BID) 1 }

	    if {[info exists Garder($BID)] || [info exists Garder($ACCESS)]} {
		lappend LeNouveau $Ligne
	    }
	    continue
	}
    }
    return $LeNouveau

}

proc BlastSamplingTaxo {blast ancestors {max 500}} {

	regsub -all aLaLiGnE $blast "\n" blast
	#set orgas [LesOrganismesDuBlast $blast KeepAll - GetText]
	set orgas [TaxonomyDuBlast $blast KeepAll - GetText]
	set orgas [string trim $orgas "\n"]

	set firstLines [ExtractFirstLinesFromBlast $blast]

	set elus {}
	foreach fline $firstLines line [split $orgas "\n"] {
		lassign [split $line "\t"] expect score taxid os header

		set taxid [string trim $taxid]
		if { [llength $elus] >= $max } {
			break
		}
		#puts -nonewline "$ancestor $taxid"
		# [JeSuisDescendantDe $ancestor $taxid] modif 20/03/2017
		if { $taxid != "" } {
			foreach anc [split $ancestors ","] {
				if {[JeSuisTonAncetre $anc $taxid]} {
					lappend elus $fline
					break
				}
			}
			#puts -nonewline " YES"
		}
		#puts ""
	}
	return [join $elus "\n"]

}

proc BlastSeqDDsansmRNAContreBanqueAffy {{NomRepBlast ""}} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    foreach Ligne [LesLignesDuFichier "/genomics/link/HeadNecknonrnr/Jumeaux/TousLesJumeaux.final.SansDbAccess"] {
	set Nom [lindex $Ligne 0]
	set AccRNACh [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access]
	if {[regexp -nocase "NomRNA" $AccRNACh] || $AccRNACh==""} {
	    Espionne $Nom
	    set FichierTFA "[RepertoireDuGenome]/nucmask/$Nom"
	    if {![file exists $FichierTFA]} {continue}
	    set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
	    set l [string length $Seq]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    set LsansN [string length $SeqSansN]
	    if {$LsansN<20} {continue}
	    set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	    if {[file exists $FichierBlast]} {
		Espionne "Blast already done"
		continue 
	    }
	    Espionne "$Nom -> blast / AffyTarget"
	    set NbSubject      10
	    set ExpectDeRef    1e-3
	    set FichierBlastTmp [TmpFile]
	    set FichierBlastTmp [BlastNDuFichier $FichierTFA  "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	    if {[file exists $FichierBlastTmp]} {
		File rename -force $FichierBlastTmp $FichierBlast
	    }
	}
    }

}

proc BlastService {args} {

    # keys === values
    #
    # https://ncbi.github.io/blast-cloud/dev/api.html
    #
    # QUERY gi|seq
    # DATABASE nr
    # HITLIST_SIZE 10
    # FILTER L
    # EXPECT 10
    # FORMAT_TYPE HTML
    # PROGRAM blastn|blastp
    # CLIENT web
    # SERVICE plain 
    # NCBI_GI on
    # PAGE Nucleotides
    # FORMAT_TYPE HTML|Text|XML
    # CMD Put|Get|Info
    set BaseUrl "https://www.ncbi.nlm.nih.gov/blast/Blast.cgi?"
    set Lopt [list CMD Put]
    foreach {k v} $args {
	switch $k {
	    "-d"      {lappend Lopt DATABASE $v}
	    "-query"  {lappend Lopt QUERY $v}
	    "-expect" {lappend Lopt EXPECT $v}
	    "-f"      {lappend Lopt FILTER L}
	    "-nlist"  {lappend Lopt HITLIST_SIZE $v}
	    "-p"      {lappend Lopt PROGRAM $v}
	    "-T"      {lappend Lopt FORMAT_TYPE $v}
	    "-orga"   {lappend Lopt ENTREZ_QUERY "txid$v\[orgn\]"}
	    "-qdef"   {lappend Lopt QUERY_BELIEVE_DEFLINE $v}
	}
    }

    set query [::http::formatQuery {*}$Lopt]
    #puts "query $query"
    set res [HttpCopy $BaseUrl "" $query]
    #puts "$res"
    set Lres [split $res "\n"]
    lassign [CheckBlastStatus $Lres] RID RTOE Status
    if {$Status ne ""} {
	puts "Problem with Blast service !"
	puts "Status= $Status"
	puts "Query $query"
	flush stdout
	return $Status
    }

    if {$RTOE eq "" || $RTOE <= 0} {
	puts "Problem with Blast !\nRTOE >$RTOE< RID >$RID<"
	flush stdout

	return ""
    }

    set url "${BaseUrl}&CMD=Get&RID=$RID&FORMAT_TYPE=Text"
    set nCmp 0 ; set maxCmp 100
    set twait [expr {$RTOE*500}]
    while {$Status ne "READY"} {
	after $twait
	set res [HttpCopy $url]
	set Lres [split $res "\n"]
	lassign [CheckBlastStatus $Lres] RID RTOE Status
	incr nCmp
    }

    if {0 && $nCmp == $maxCmp} {
	puts "Problem with Blast service !"
	puts "Status = $Status"
	return ""
    }

    return $Lres

}

proc BlastServiceEBI {args} {

    # see http://www.ebi.ac.uk/Tools/webservices/services/sss/ncbi_blast_rest
    #
    # the routine ListOfEBIDatabases lists all blast databases
    # available at EBI.
    # for facility, the arguments will be the same as for the
    # NCBI Blast service
    #
    
    set Lopt [list email $::Defauts(Email)]
    foreach {k v} $args {
	switch $k {
	    "-d"      {lappend Lopt database $v}
	    "-query"  {lappend Lopt sequence $v}
	    "-expect" {lappend Lopt exp $v}
	    "-f"      {
		if {[regexp -nocase {no|false|0} $v]} {
		    lappend Lopt filter F
		} else {
		    lappend Lopt filter T
		}
	    }
	    "-nlist"  {
		lappend Lopt scores $v
		lappend Lopt alignments $v
	    }
	    "-p"      {lappend Lopt program $v}
	    "-T"      {lappend Lopt FORMAT_TYPE $v}
	    "-stype"  {
		set Lval {protein rna dna}
		if {[string tolower $v] in $Lval} {
		    lappend Lopt stype $v
		}
	    }
	}
    }

    set query [::http::formatQuery {*}$Lopt]
    set BaseUrl "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/run/"
    set res [HttpCopy $BaseUrl "" $query]

    # do we got a good jobId ?
    set jobId [string trim $res]
    if {[string range $jobId 0 9] ne "ncbiblast-"} {
	return ""
    }

    set done 0
    set urlStatus "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/status/$jobId"
    set Lbad [list ERROR FAILED NOT_FOUND]
    while {! $done} {
	after 10000
	set res [HttpCopy $urlStatus]
	#puts ">$res<"
	if {$res in $Lbad} {
	    return ""
	}
	if {$res eq "FINISHED"} {
	    set done 1
	}
    }

    # get results
    set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/result/$jobId/out"
    set res [HttpCopy $url]

    return $res

}

proc BlastSplitteParOrganisme {FileBlast Banque {LesOrganismesOuTaxonsPrioritaires ""} {LesOrganismesOuTaxonsAExclure ""}} {

    foreach Organisme $LesOrganismesOuTaxonsAExclure     {set TabAExclure($Organisme)     1}
    foreach Organisme $LesOrganismesOuTaxonsPrioritaires {set TabPrioritaires($Organisme) 1}

    AskBlast unset

    Espionne "$FileBlast -> Loading ..."
    set LesBId {}
    set NbSubject [AskBlast $FileBlast NbSubject]
    if {$NbSubject == ""} {return}
    for {set i 1} {$i <= $NbSubject} {incr i} {lappend LesBId [AskBlast $FileBlast Subject $i]}
    Espionne "$FileBlast -> Loaded ..."

    Espionne "$FileBlast -> Loading database ..."
    AskLesPagesInfos load $LesBId $Banque
    
    set LesOrganismes {}
    foreach Id $LesBId {
	foreach Orga [LesOrgasDeLaPage_PageInfo [AskLesPagesInfos ask $Id]] {
	    if {$Orga == ""} {continue}
	    Espionne "$Id -> $Orga"
	    if {![info exists Tab($Orga,LesBId)]} {
		set     Tab($Orga,LesBId) {} 
		lappend LesOrganismes     $Orga
	    }
	    lappend Tab($Orga,LesBId) $Id
	}
    }
    Espionne "$FileBlast -> database loaded..."

    foreach Orga $LesOrganismes {
	set EstCeOK                   1
	set AiJeLesTaxonsPrioritaires 0
	foreach Tax [InterrogeClassificationTaxonomique $Orga LesPhylums] {
	    if {[info exists  TabAExclure($Tax)    ]} {set EstCeOK 0                  ;continue}
	    if {[info exists  TabPrioritaires($Tax)]} {set AiJeLesTaxonsPrioritaires 1;continue}
	}
	if {!$EstCeOK} {continue}
	if {$LesOrganismesOuTaxonsPrioritaires != "" && !$AiJeLesTaxonsPrioritaires} {continue}

	Espionne $Orga

	set Ext $Orga
	regsub -all " " $Orga "_" Ext

	set NewFileBlast "${FileBlast}_${Ext}"

	set LesId [set Tab($Orga,LesBId)]
	FichierBlastReduit $FileBlast $NewFileBlast LesBIdToKeep $LesId
    }

    AskLesPagesInfos unset
    AskBlast         unset
    return

}

proc BlastTestDir {} {

    set BlastTestDir "/blast/BlastTest"
    return $BlastTestDir

}

proc BlastTools {} {

    if {[winfo children .] != ""} {
	set       w [NomDe blasttools]
	toplevel $w
    } else {
	set w "."
	$w config -bd 3 -relief flat
    }
    wm title    $w "BlastTools"
    wm iconname $w "BlastTools"
    
    if {$w == "."} {set w ""}
    set    BoutonShowWithGscope            "${w}.boutonshowwithgscope"
    set    BoutonDrawBlast                 "${w}.boutondrawblast"
    set    BoutonClose                     "${w}.boutonclose"
    button $BoutonShowWithGscope           -borderwidth 1 -text "Show with Gscope"
    button $BoutonDrawBlast                -borderwidth 1 -text "Draw Blast"
    button $BoutonClose                    -borderwidth 1 -text "CLOSE"
    pack   $BoutonShowWithGscope           -side top -fill both -expand 1
    pack   $BoutonDrawBlast                -side top -fill both -expand 1
    pack   $BoutonClose                    -side top -fill both -expand 1
    if {$w == ""} {set w "."}

    $BoutonShowWithGscope configure -command "destroy $w ; AfficheUneSortieBlast"
    $BoutonDrawBlast      configure -command "DrawBlast"
    $BoutonClose          configure -command "destroy $w ; return"

}

proc BlastTrieDuPsiBlastPourTous {} {

    set Rep "[RepertoireDuGenome]/blastptrie"
    if { ! [file exists $Rep]} { file mkdir $Rep }
    foreach Nom [ListeDesPABs] {
	set FicPsiBlast "[RepertoireDuGenome]/psiblastp/$Nom"
	if { ! [file exists $FicPsiBlast]} { continue }
	set FicBlastTrie "$Rep/$Nom"
	set BlastTrie [DernierBlastDuPsiBlast $FicPsiBlast "Trie"]
	if {$BlastTrie==""} { continue }
	Sauve $BlastTrie dans $FicBlastTrie
    }

}

proc BlastWithAllExpectsToZero {Fichier {Nouveau ""}} {

    if {$Nouveau==""} { set Nouveau "GetText" }

    set OnAttendPartieScore 1
    set OnEstDansScore 0
    set OnFinit 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$OnAttendPartieScore} {
	    lappend LesBonnes $Ligne
	    if {[regexp "Sequences producing" $Ligne]} {
		set OnAttendPartieScore 0
		set OnEstDansScore 1
	    }
	    continue
	}
	if {$OnEstDansScore} {
	    if {[regexp ">" $Ligne]} {
		set OnEstDansScore 0
	    } else {
		if {[regexp { [\+\-\.0-9eE]+ *$} $Ligne]} {
		    regsub  { [\+\-\.0-9eE]+ *$} $Ligne " 0.0000" Ligne
		}
	    }
	    lappend LesBonnes $Ligne
	    continue
	}
	if {[regexp -nocase {Expect = .+} $Ligne]} {
	    regsub  -nocase {Expect = .+} $Ligne "Expect = 0.0000" Ligne
	}
	lappend LesBonnes $Ligne
    }
    if {$Nouveau=="GetLines"} { return $LesBonnes }
    if {$Nouveau=="GetText"}  { return [join $LesBonnes "\n"] }
    return [SauveLesLignes $LesBonnes dans $Nouveau]

}

proc BlastX2Protein {ORF} {

    set Mito 0
    set Sortie [PremiereProteineDuBlastX "[RepertoireDuGenome]/blastx/$ORF" AvecLaSequence]
    if {[llength $Sortie]==0} {return "$ORF : no homolog"}

    ###
    ### récupère tous les hsp du 1er hit et stocke orientations, traductions dans le bon sens,...
    ###
    set i 0
    foreach el $Sortie {
	incr i
	scan $el "%s %s %s %s %s %s %s %s %s " ORF BanqueId DebQuery($i) FinQuery($i)  DebSub FinSub Cadre SegQuery SegSub
	
	if {[regexp -indices {\*} $SegQuery Indices]} {
	    set Position [lindex $Indices 0]
	    if {[string index $SegSub $Position]=="W"} {
		set Mito 1
	    }
	}
	if {[set DebQuery($i)] < [set FinQuery($i)]} {
	    set OrientQuery($i) "F"
	} else {
	    set OrientQuery($i) "R" 
	}
	set Frame($i) [expr abs($Cadre)]
	if {$Mito} {
	    AAduCodon AGA "S" ; AAduCodon AGG "S"; AAduCodon ATA "M";AAduCodon TGA "W"
	} else {
	    AAduCodon Reset
	}
	set SeqContig [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/$ORF"] 
	if {[set OrientQuery($i)]=="R"} {
	    set SeqContig [NucToReverseAndComplementNuc $SeqContig]
	}
	switch [set Frame($i)] {
	    1 {set Traduction($i) [SeqNucToSeqPro $SeqContig]}
	    2 {set Traduction($i) [SeqNucToSeqPro [string range $SeqContig 1 end]]}
	    3 {set Traduction($i) [SeqNucToSeqPro [string range $SeqContig 2 end]]}
	}
    }

    ###
    ### garde hsps qui sont dans la même orientation F/R que le 1er
    ### elements = {$i DQ FQ orient frame}
    ### DQ et FQ corrigés pour fonctionner avec sequence en reverse
    ###
    set NbFrag $i
    set ListeNumDebFin [list]
    set OrientationBestHit [set OrientQuery(1)]
    for {set i 1} {$i<=$NbFrag} {incr i} {
	if {$OrientationBestHit!=[set OrientQuery($i)]} continue
	if {[set OrientQuery($i)]=="F"} {
	    lappend ListeNumDebFin [list $i [set DebQuery($i)] [set FinQuery($i)] [set OrientQuery($i)] [set Frame($i)]]
	} else {
	    set Longueur [string length $SeqContig]
	    lappend ListeNumDebFin [list $i [expr $Longueur-[set DebQuery($i)]+1] [expr $Longueur-[set FinQuery($i)]+1] [set OrientQuery($i)] [set Frame($i)]]
	}
    }

    ###
    ### trie les elements par DQ
    ### et supprime de la liste finale les elements suivants d'autres qui ont le même DQ, la même frame
    ### ou qui se terminent au même FQ ou encore avant
    ###
    set ListeNumDebFin [lsort -integer -increasing -index 1 $ListeNumDebFin]
    #Nettoyage de la liste
    for {set i 0} {[expr $i+1]<[expr [llength $ListeNumDebFin]]} {incr i} {
	set el [lindex $ListeNumDebFin $i] 
	scan $el "%s %s %s %s %s" Num1 Deb1 Fin1 Orient1 Frame1
	set elsuivant [lindex $ListeNumDebFin [expr $i+1]] 
	scan $elsuivant "%s %s %s %s %s" Num2 Deb2 Fin2 Orient2 Frame2 
	lappend ListeFinale $el
	puts "$Frame1 $Frame2"
	while {($Deb1==$Deb2)|| ($Deb2<$Fin1 && $Fin2<=$Fin1) || $Frame1==$Frame2} {
	    incr i
	    if {$i==[llength $ListeNumDebFin]} break
	    set el [lindex $ListeNumDebFin $i] 
	    scan $el "%s %s %s %s %s" Num1 Deb1 Fin1 Orient1 Frame1 
	    set elsuivant [lindex $ListeNumDebFin [expr $i+1]]
	    scan $elsuivant "%s %s %s %s %s" Num2 Deb2 Fin2 Orient2 Frame2
	}
	
    }
    if {$i<=[expr [llength $ListeNumDebFin]-1]} {lappend ListeFinale [lindex $ListeNumDebFin end]}

    #nG mes infos
    set DebutTrad ""
    set FinTrad ""
    array set corresp {}
    set zProt 1
    #/nG

    set SeqProteine ""
    set StopEnDebut 0
    #allongement du debut
    set FirstSeg [lindex $ListeFinale 0]
    scan $FirstSeg "%s %s %s" Num1 Deb1 Fin1 
    set DebAA [expr ($Deb1+2)/3]
    set Traduction1 [set Traduction($Num1)]
    for {set i [expr $DebAA-2]} {$i>=0} {incr i -1} {
	if {[string index $Traduction1 $i]=="*"||[string index $Traduction1 $i]=="X"} {
	    if {[string index $Traduction1 $i]=="*"} {
		set StopEnDebut 1
	    }
	    incr i
	    break
	}	
    }
    ## !!!nG $i peut être < 0 !!!!????
    if {$i < 0} {set i 0}
    append SeqProteine [string range $Traduction1 $i [expr $DebAA-2]]
    set DebutTrad [expr ($i * 3 + 1) + ($Frame($Num1) - 1)]
    for {set zNuc $DebutTrad} {$zProt <= [string length $SeqProteine]} {incr zProt ; incr zNuc 3} {
	set corresp($zProt) $zNuc
    }

    #traitement du corps
    for {set i 0} {[expr $i+1]<[expr [llength $ListeFinale]]} {incr i} {
	set el [lindex $ListeFinale $i]
	scan $el "%s %s %s" Num1 Deb1 Fin1 
	set Traduction1 [set Traduction($Num1)]
	set elsuivant [lindex $ListeFinale [expr $i+1]]
	scan $elsuivant "%s %s %s %s" Num2 Deb2 Fin2 Orient2
	if {$Fin1<$Deb2} {	   
	    append SeqProteine [string range $Traduction1 [expr (($Deb1+2)/3)-1] [expr ($Fin1/3)-1]]
	    for {set zNuc [expr (((($Deb1+2)/3)-1) * 3 + 1) + ($Frame($Num1) - 1)]} {$zProt <= [string length $SeqProteine]} {incr zProt ; incr zNuc 3} {
		set corresp($zProt) $zNuc
	    }
	    set LongX [expr ($Deb2-$Fin1)/3]
	    append SeqProteine [string repeat "X" $LongX]
	    incr zProt $LongX
	} else {
	    append SeqProteine [string range $Traduction1 [expr (($Deb1+2)/3)-1] [expr ($Deb2/3)-2]]
	    for {set zNuc [expr (((($Deb1+2)/3)-1) * 3 + 1) + ($Frame($Num1) - 1)]} {$zProt <= [string length $SeqProteine]} {incr zProt ; incr zNuc 3} {
		set corresp($zProt) $zNuc
	    }
	    set LongX [expr ($Fin1-$Deb2+2)/3]
	    append SeqProteine [string repeat "X" $LongX]
	    incr zProt $LongX
	    set ListeFinale [lreplace $ListeFinale [expr $i+1] [expr $i+1] "$Num2 [expr $Fin1+2] $Fin2 $Orient2"]
	}
    }

    #traitement de la fin
    set YaStopFinal "No"
    set LastSeg [lindex $ListeFinale end]
    scan $LastSeg "%s %s %s" Num1 Deb1 Fin1
    set FinAA [expr $Fin1/3] 
    set DebAA [expr ($Deb1+2)/3]
    set Traduction1 [set Traduction($Num1)]
    append SeqProteine [string range $Traduction1 [expr $DebAA-1] [expr $FinAA-1]]
    for {set zNuc [expr (($DebAA-1) * 3 + 1) + ($Frame($Num1) - 1)]} {$zProt <= [string length $SeqProteine]} {incr zProt ; incr zNuc 3} {
	set corresp($zProt) $zNuc
    }
    for {set i $FinAA} {$i<[string length $Traduction1]} {incr i} {
	if {[string index $Traduction1 $i]=="*" || [string index $Traduction1 $i]=="X" ||[string index $Traduction1 $i]=="-" } {
	    if {[string index $Traduction1 $i]=="*"} {set YaStopFinal "OK"}
	    set i [expr $i-1]
	    break
	}	
    }
    ## !!!nG $i peut être >= long Traduction1 !!!!????
    if {$i >= [string length $Traduction1]} {set i [expr [string length $Traduction1] - 1]}
    append SeqProteine [string range $Traduction1 [expr $FinAA] $i]
    for {set zNuc [expr (($FinAA) * 3 + 1) + ($Frame($Num1) - 1)]} {$zProt <= [string length $SeqProteine]} {incr zProt ; incr zNuc 3} {
	set corresp($zProt) $zNuc
    }
    set NbAA [string length $SeqProteine]
    set FinTrad [expr (($i + 1) * 3) + ($Frame($Num1) - 1)]

    #recherche du premier met si stop en Nter
    set YaMet "No"
    if {$StopEnDebut} {
	set i 0
	while {[string index $SeqProteine $i]!="M" && $i<$NbAA} {
	    incr i
	}
	#rajout condition de longueur 30 pour coupure au niveau de met
	if {$i!=[expr $NbAA-1]&& [expr $NbAA-$i]>30} {
	    set SeqProteine [string range $SeqProteine $i end]
	    set YaMet "OK"
	    set DebutTrad $corresp([expr $i+1])
	} else {
	    puts "********************** no Met"
	}
    }


    set NbAA [string length $SeqProteine]
    set StopInt "No"
    if {[regexp {\*} $SeqProteine]} {
	set StopInt "yes"
	regsub -all {\*} $SeqProteine "X" SeqProteine
    } 

    set repertoireOut "[RepertoireDuGenome]/prottfa"
    if {![file isdir $repertoireOut]} {file mkdir $repertoireOut}

    set OrientFinale [lindex [lindex $ListeFinale 0] end-1]
    if {$OrientFinale eq "R"} {
	set DebutTrad [expr $Longueur - $DebutTrad + 1]
	set FinTrad [expr $Longueur - $FinTrad + 1]
	set tmp $DebutTrad 
	set DebutTrad $FinTrad
	set FinTrad $tmp
    }

    SauveLesLignes [split [SeqFasta $SeqProteine ">$ORF $NbAA aa Met $YaMet Stop $YaStopFinal InternalStop $StopInt CDS\[$OrientFinale\]:$DebutTrad-$FinTrad"] "\n"] dans "$repertoireOut/$ORF"
    return "$ORF : $NbAA aa $Mito"

}

proc BlastX2ProteinOld {ORF} {

    set Mito 0
    set Sortie [PremiereProteineDuBlastX "[RepertoireDuGenome]/blastx/$ORF" AvecLaSequence]
    if {[llength $Sortie]==0} {return "$ORF : no homolog"}
    set i 0
    foreach el $Sortie {
	incr i
	scan $el "%s %s %s %s %s %s %s %s %s " ORF BanqueId DebQuery($i) FinQuery($i)  DebSub FinSub Cadre SegQuery SegSub
	
	if {[regexp -indices {\*} $SegQuery Indices]} {
	    set Position [lindex $Indices 0]
	    if {[string index $SegSub $Position]=="W"} {
		set Mito 1
	    }
	}
	if {[set DebQuery($i)] < [set FinQuery($i)]} {
	    set OrientQuery($i) "F"
	} else {
	    set OrientQuery($i) "R" 
	}
	set Frame($i) [expr abs($Cadre)]
	if {$Mito} {
	    AAduCodon AGA "S" ; AAduCodon AGG "S"; AAduCodon ATA "M";AAduCodon TGA "W"
	} else {
	    AAduCodon Reset
	}
	set SeqContig [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/$ORF"] 
	if {[set OrientQuery($i)]=="R"} {
	    set SeqContig [NucToReverseAndComplementNuc $SeqContig]
	}
	switch [set Frame($i)] {
	    1 {set Traduction($i) [SeqNucToSeqPro $SeqContig]}
	    2 {set Traduction($i) [SeqNucToSeqPro [string range $SeqContig 1 end]]}
	    3 {set Traduction($i) [SeqNucToSeqPro [string range $SeqContig 2 end]]}
	}
    }
    set NbFrag $i
    set ListeNumDebFin [list]
    set OrientationBestHit [set OrientQuery(1)]
    for {set i 1} {$i<=$NbFrag} {incr i} {
	if {$OrientationBestHit!=[set OrientQuery($i)]} continue
	if {[set OrientQuery($i)]=="F"} {
	    lappend ListeNumDebFin [list $i [set DebQuery($i)] [set FinQuery($i)] [set OrientQuery($i)] [set Frame($i)]]
	} else {
	    set Longueur [string length $SeqContig]
	    lappend ListeNumDebFin [list $i [expr $Longueur-[set DebQuery($i)]+1] [expr $Longueur-[set FinQuery($i)]+1] [set OrientQuery($i)] [set Frame($i)]]
	}
    }

    set ListeNumDebFin [lsort -integer -increasing -index 1 $ListeNumDebFin]
    #Nettoyage de la liste
    for {set i 0} {[expr $i+1]<[expr [llength $ListeNumDebFin]]} {incr i} {
	set el [lindex $ListeNumDebFin $i] 
	scan $el "%s %s %s %s %s" Num1 Deb1 Fin1 Orient1 Frame1
	set elsuivant [lindex $ListeNumDebFin [expr $i+1]] 
	scan $elsuivant "%s %s %s %s %s" Num2 Deb2 Fin2 Orient2 Frame2 
	lappend ListeFinale $el
	puts "$Frame1 $Frame2"
	while {($Deb1==$Deb2)|| ($Deb2<$Fin1 && $Fin2<=$Fin1) || $Frame1==$Frame2} {
	    incr i
	    if {$i==[llength $ListeNumDebFin]} break
	    set el [lindex $ListeNumDebFin $i] 
	    scan $el "%s %s %s %s %s" Num1 Deb1 Fin1 Orient1 Frame1 
	    set elsuivant [lindex $ListeNumDebFin [expr $i+1]]
	    scan $elsuivant "%s %s %s %s %s" Num2 Deb2 Fin2 Orient2 Frame2
	}
	
    }
    if {$i<=[expr [llength $ListeNumDebFin]-1]} {lappend ListeFinale [lindex $ListeNumDebFin end]}
    set SeqProteine ""
    set StopEnDebut 0
    #allongement du debut
    set FirstSeg [lindex $ListeFinale 0]
    scan $FirstSeg "%s %s %s" Num1 Deb1 Fin1 
    set DebAA [expr ($Deb1+2)/3]
    set Traduction1 [set Traduction($Num1)]
    for {set i [expr $DebAA-2]} {$i>=0} {set i [expr $i-1]} {
	if {[string index $Traduction1 $i]=="*"||[string index $Traduction1 $i]=="X"} {
	    if {[string index $Traduction1 $i]=="*"} {
		set StopEnDebut 1
	    }
	    incr i
	    break
	}	
    }
    append SeqProteine [string range $Traduction1 $i [expr $DebAA-2]]
    #traitement du corps
    for {set i 0} {[expr $i+1]<[expr [llength $ListeFinale]]} {incr i} {
	set el [lindex $ListeFinale $i]
	scan $el "%s %s %s" Num1 Deb1 Fin1 
	set Traduction1 [set Traduction($Num1)]
	set elsuivant [lindex $ListeFinale [expr $i+1]]
	scan $elsuivant "%s %s %s %s" Num2 Deb2 Fin2 Orient2
	if {$Fin1<$Deb2} {	   
	    append SeqProteine [string range $Traduction1 [expr (($Deb1+2)/3)-1] [expr ($Fin1/3)-1]]
	    set LongX [expr ($Deb2-$Fin1)/3]
	    for {set j 1} {$j<=$LongX} {incr j} {
		append SeqProteine "X"
	    }
	} else {
	    append SeqProteine [string range $Traduction1 [expr (($Deb1+2)/3)-1] [expr ($Deb2/3)-2]]
	    set LongX [expr ($Fin1-$Deb2+2)/3]
	    for {set j 1} {$j<=$LongX} {incr j} {
		append SeqProteine "X"
	    }
	    set ListeFinale [lreplace $ListeFinale [expr $i+1] [expr $i+1] "$Num2 [expr $Fin1+2] $Fin2 $Orient2"]
	}
    }
    #traitement de la fin
    set YaStopFinal "No"
    set LastSeg [lindex $ListeFinale end]
    scan $LastSeg "%s %s %s" Num1 Deb1 Fin1
    set FinAA [expr $Fin1/3] 
    set DebAA [expr ($Deb1+2)/3]
    set Traduction1 [set Traduction($Num1)]
    append SeqProteine [string range $Traduction1 [expr $DebAA-1] [expr $FinAA-1]]
    for {set i $FinAA} {$i<[string length $Traduction1]} {incr i} {
	if {[string index $Traduction1 $i]=="*" || [string index $Traduction1 $i]=="X" ||[string index $Traduction1 $i]=="-" } {
	    if {[string index $Traduction1 $i]=="*"} {set YaStopFinal "OK"}
	    set i [expr $i-1]
	    break
	}	
    }
    append SeqProteine [string range $Traduction1 [expr $FinAA] $i]
    set NbAA [string length $SeqProteine]
    #recherche du premier met si stop en Nter
    set YaMet "No"
    if {$StopEnDebut} {
	set i 0
	while {[string index $SeqProteine $i]!="M" && $i<$NbAA} {
	    incr i
	}
	#rajout condition de longueur 30 pour coupure au niveau de met
	if {$i!=[expr $NbAA-1]&& [expr $NbAA-$i]>30} {
	    set SeqProteine [string range $SeqProteine $i end]
	    set YaMet "OK"
	} else {
	    puts "********************** no Met"
	}
    }


    set NbAA [string length $SeqProteine]
    set StopInt "No"
    if {[regexp {\*} $SeqProteine]} {
	set StopInt "yes"
	regsub -all {\*} $SeqProteine "X" SeqProteine
    } 
    if {![file exists "[RepertoireDuGenome]/prottfa"]} {file mkdir "[RepertoireDuGenome]/prottfa"}
    SauveLesLignes [split [SeqFasta $SeqProteine ">$ORF $NbAA aa Met $YaMet Stop $YaStopFinal InternalStop $StopInt"] "\n"] dans [RepertoireDuGenome]/prottfa/$ORF
    return "$ORF : $NbAA aa $Mito"

}

proc BlastX2ProteinPourTous {} {

    #traite les ORF d un projet
    #les blastx doivent etre dans le repertoire blastx
    set Sortie [list]
    foreach ORF [LesPABsDansLOrdre] {
	Espionne $ORF
	lappend Sortie [BlastX2Protein $ORF]
	Espionne [lindex $Sortie end]
    }
    EcritFichier $Sortie "[RepertoireDuGenome]/fiches/BlastX2Protein.out"


}

proc BlastXDesFichiers {{Banque protall} {LesNomATraiter ""} {Repertoire ""}} {

    global RepertoireDuGenome
    global GardeToutBlastXPourTous
    global TestExistenceBlastXPourTous

    JeMeSignale

    set BlastXDataBase "/blast/$Banque"

    if { ! [file exists "$BlastXDataBase.pal"] && ! [file exists "$BlastXDataBase.phr"]} {
	return ""
    }

    if {$LesNomATraiter == {}} {set LesNomATraiter [ListeDesPABs]}

    if {$Repertoire == ""} {
	set Repertoire "$RepertoireDuGenome/blastx"
    } elseif {![file exists $Repertoire]} {
	return "$Repertoire does not exist"
    }

    if { ! [file exists "$Repertoire"]} {File mkdir $Repertoire}

    if {[info exists CommandeBlastXPourTous]} {
	set CommandeBlast $CommandeBlastXPourTous
	if {[info exists GardeToutBlastXPourTous]} {set GardeTout $GardeToutBlastXPourTous
	} else {setGardeTout 0}

	if {[info exists TestExistenceBlastXPourTous]} {
	    set TestExistence $TestExistenceBlastXPourTous
	} else {set TestExistence 1}

    } else {
	set GardeTout 0
	set TestExistence 1
	if {$BlastXDataBase==""} { return "" }
	set CommandeBlast "eval exec blastall  -p blastx  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastXDataBase  -v 500  -b 500 "

	if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	}
    
	while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	    if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
		set TestExistence 1
		set GardeTout 1
		break 
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
		set TestExistence 0
		set GardeTout 0
		break
	    } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
		set TestExistence 1
		set GardeTout 0
		break
	    }
	}
	set CommandeBlastXPourTous $CommandeBlast
	set GardeToutBlastXPourTous $GardeTout
	set TestExistenceBlastXPourTous $TestExistence
    }

    set TestLongueurMinimale [OnTraiteDesCDNAs]
    set SeuilLongueur 0

    ####################################################
    set LesRepTFA {}
    if {[file exists "$RepertoireDuGenome/nuctfa"]} {
	lappend LesRepTFA "$RepertoireDuGenome/nuctfa"
    }
    if {[file exists "$RepertoireDuGenome/nucmask"]} {
	lappend LesRepTFA "$RepertoireDuGenome/nucmask"
    }
    if {[file exists "$RepertoireDuGenome/mrnahuman"]} {
	lappend LesRepTFA "$RepertoireDuGenome/mrnahuman"
    }

    set RepTFA [ChoixParmi $LesRepTFA]
    if {$RepTFA == ""} {return ""}

    foreach Nom $LesNomATraiter {
	AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"

	set FichierTFA   "$RepTFA/$Nom"
	if {![file exists $FichierTFA]} {continue}

	set FichierBlast "$Repertoire/$Nom"

	if {$TestLongueurMinimale} {
	    set LeTFA [LesLignesDuFichier $FichierTFA]
	    set Seq [join [lrange $LeTFA 1 end]]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    if {[string length $SeqSansN]<$SeuilLongueur} { continue }
	}
	
	if {$GardeTout && [file exists $FichierBlast] } {
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
		continue
	    }
	}

	Espionne "Je vais lancer blastx sur $FichierBlast"
	Sauve "$Nom en cours..." dans $FichierBlast
	if {[catch {eval $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}   }   
}

proc BlastXDesHitsMultiples {Nom} {

    set MesHits [HitMultiple $Nom]
    if {$MesHits=={}} { return "" }
    set Moi $Nom
    set Eux {}
    if {[info exists DejaLui]} { unset DejaLui }
    foreach Hit $MesHits {
	scan $Hit "%s" Lui
	set Nous "$Moi$Lui"
	set FichierNous "[RepertoireDuGenome]/blastxmultiples/$Nous"
	if {[file exists $FichierNous]} { continue }
	if {[info exists DejaVu($Lui,$Moi)]} { continue }
	if {[info exists DejaLui($Lui)]} { continue }
	set DejaLui($Lui) 1
	set DejaVu($Moi,$Lui) 1
	set DMoi [Box $Moi debut]
	set FMoi [Box $Moi fin]
	set DLui [Box $Lui debut]
	set FLui [Box $Lui fin]
	set D [Mini $DMoi $DLui]
	set F [Maxi $FMoi $FLui]
	set ADN [BoutADN $D $F "F"]
	set TFA [SequenceFormatTFA $ADN "$Moi$Lui nucleic sequence from $Moi to $Lui"]
	set FichierTFA [Sauve $TFA dans "[TmpFile $Moi$Lui].tfa"]
	set LesCommuns {}
	foreach ReHit [HitMultiple $Nom] {
	    scan $ReHit "%s %s" LuiLu Access
	    if {$LuiLu!=$Lui} { continue }
	    lappend LesCommuns "$Access $Access"
	}
	if {$LesCommuns=={}} { continue }
	set FichierBlast "[TmpFile $Moi$Lui].blastx" 
	set Communs [join $LesCommuns "\n"]
	set BlastXDataBase "[RepertoireDeTravail]/$Moi$Lui"
	if {[file exists $BlastXDataBase]} { file delete $BlastXDataBase }
	set BlastXDataBase [CreeUneBanqueBlast $Communs $BlastXDataBase]
	set CommandeBlast "blastall  -p blastx  -i $FichierTFA  -o $FichierBlast.encours  -d $BlastXDataBase  -v 50  -b 50 "

	if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} {
	    set CommandeBlast [Entre $CommandeBlast]
	    if {$CommandeBlast==""} { return "" }
	}
	if {[catch {eval exec $CommandeBlast} Message]} { Espionne $Message }
	if { ! [file exists "$FichierBlast.encours"]} {
	    Espionne "No $FichierBlast"
	    continue
	}
	file copy -force $FichierBlast.encours $FichierNous
	lappend Eux $Lui 
    }
    return $Eux 

}

proc BlastXDesHitsMultiplesPourTous {} {

    foreach Nom [ListeDesPABs] {
	set LesBlastX [BlastXDesHitsMultiples $Nom]
	Espionne "$Nom $LesBlastX"
    }
    exit

}

proc BlastXDesTROUsPourTous {{NomATraiter ""}} {

    global RepertoireDuGenome

    set BlastXDataBase "/catalog/blast/protall"

    set RepTROUs "$RepertoireDuGenome/nuctfa"

    set Repertoire "$RepertoireDuGenome/trousblastx"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }    


    if {$NomATraiter == ""} {
	set Liste [ListeDesTROUs]
    } else {
	set Liste [list $NomATraiter]
    }

    set CommandeBlast "blastall  -p blastx  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastXDataBase  -v 100  -b 100 "


    
    if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
	set CommandeBlast [Entre $CommandeBlast]
	if {$CommandeBlast==""} { return "" }
    }
    
    foreach Nom $Liste {
	set FichierTFA "$RepTROUs/$Nom"
	if { ! [file exists "$FichierTFA"]} { continue }

	set FichierBlast "$Repertoire/$Nom"
	if {[file exists $FichierBlast] } { continue }

	if {[PasTouche $Nom]} { continue }

	Espionne "Je vais lancer BlastX  \n de $FichierTFA \nsur $BlastXDataBase \nresultat dans $FichierBlast"
	if {[catch {eval exec $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
	}
	FinPasTouche $Nom
    }

}

proc BlastXDuFichier {FichierTFA {Banque protall} {Filtre 1} {FichierBlast ""} {EditCommand 0}} {

    global RepertoireDuGenome

    AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"

    if {$Filtre} {	set Filtre "T"
    } else {   	        set Filtre "F"}
    
    set BlastXDataBase "/blast/$Banque"
    if { ! [file exists "$BlastXDataBase.pal"] && ! [file exists "$BlastXDataBase.phr"]} {
	return ""
    }
    set CommandeBlastX "eval exec blastall  -p blastx  -i \$FichierTFA  -o \$FichierBlast  -d \$BlastXDataBase -F \$Filtre -v 250  -b 250 "

    if {$EditCommand == 1 && [OuiOuNon "Do You want to edit the BlastX command ?" 0]} {
	set CommandeBlastX [Entre $CommandeBlastX]
    }
    if {$FichierBlast == ""} {
	set RepBlast [RepertoireDeTravail]
	set FichierBlast "$RepBlast/[file tail $FichierTFA]\.blastx"
    }
    if { ! [file exists $FichierTFA]} { Warne "$FichierTFA doesn't exist.";exit}

    eval $CommandeBlastX
    return $FichierBlast

}

proc BlastXPourTous {{NomATraiter ""} {Banque ""}} {

    global RepertoireDuGenome

    if {$Banque==""} {
	set BlastXDataBase "/catalog/blast/protall"
    } else {
	if {[regexp "/" $Banque]} {
	    set BlastXDataBase $Banque
	} else {
	    set BlastXDataBase "/catalog/blast/$Banque"
	}
    }	

    set RepFileMask "$RepertoireDuGenome/nucmask"

    set Repertoire "$RepertoireDuGenome/blastx"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }    


    if {$NomATraiter == ""} {
	set Liste [ListeDesPABs]
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } else {
	set Liste [list $NomATraiter]
    }

    set CommandeBlast "blastall  -p blastx  -i \$FichierTFA  -o \$FichierBlast.encours  -d $BlastXDataBase  -v 50  -b 50 "


    
    if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} {
	set CommandeBlast [Entre $CommandeBlast]
	if {$CommandeBlast==""} { return "" }
    }
    
    set CommandeBlastXPourTous $CommandeBlast
    
    set TestLongueurMinimale [OnTraiteDesCDNAs]
    set SeuilLongueur 9
    
    foreach Nom $Liste {
	set FichierTFA ""
	foreach Rep {nucMaskAndReMask nucmask nuctfa} {
	    set FichierTFA "$RepertoireDuGenome/$Rep/$Nom"
	    if {[file exists $FichierTFA]} { break }	
	}
	if { $FichierTFA=="" || ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA doesn't exist."
	    continue
	}

	set FichierBlast "$Repertoire/$Nom"

	if {$TestLongueurMinimale} {
	    set LeTFA [LesLignesDuFichier $FichierTFA]
	    set Seq [join [lrange $LeTFA 1 end]]
	    regsub -all -nocase "N" $Seq "" SeqSansN
	    if {[string length $SeqSansN]<$SeuilLongueur} { continue }
	}
	
	if {[file exists $FichierBlast] } { continue }
	if {[PasTouche $Nom]} { continue }
	Espionne "Je vais lancer BlastX de $FichierTFA"
	if {[catch {eval exec $CommandeBlast} Message]} {
	    Espionne "Problem with $FichierBlast"
	    Espionne $Message
	}
	if {[file exists "${FichierBlast}.encours"]} {
	    file rename -force "${FichierBlast}.encours" $FichierBlast
	} else {
	    Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
	}
	FinPasTouche $Nom
    }

}

proc BlastXSeqDDSansProtContreHumanTF {{NomRepBlast ""} {Fichier Jumeaux/les721supp}} {

    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}
    set C [ContenuDuFichier $Fichier]
    set L [split $C " "]
    foreach Nom $L {
	#Espionne "$Nom en cours..."
	set FichierTFA "[RepertoireDuGenome]/nucmask/$Nom"
	if {![file exists $FichierTFA]} {Espionne "$FichierTFA does not exist";continue}
	set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
	set l [string length $Seq]
	regsub -all -nocase "N" $Seq "" SeqSansN
	set LsansN [string length $SeqSansN]
	if {$LsansN<20} {continue}
	#->Blast de prot dd contre les humanTF
	Espionne "$Nom -> blast / HumanTF"
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {
	    Espionne "Blast already done"
	    continue 
	}
	set NbSubject      10
	set ExpectDeRef    1e-3
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastXDuFichier $FichierTFA  "[GscopeDatabaseDir HumanTF]/banques/bank_HumanTF"  $NbSubject $ExpectDeRef 1 $FichierBlastTmp  0]
	
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
    }

}

proc BlastXdeADN {Nom DebutBlastX FinBlastX} {

    global Commandes
    global ADN TDN RAC
    global NePlusFaireBlastX
    global RepertoireDuGenome

    if { ! [info exists NePlusFaireBlastX]} { set NePlusFaireBlastX 1 }

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    if { $NePlusFaireBlastX || ! [OuiOuNon "Je lance BlastX ?"]} {
	return "a faire."
    }

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    if { [regexp {^[XFR]$} $Nom] } {
	if { [regexp {^[XF]$} $Nom] } {
	    set Orient "F"
	} else {
	    set Orient "R"
	}
    } else {
	set Orient [Box $Nom orient]
	if { $Orient == "" } {
	    FaireLire "$Nom n'est pas vraiment autorise\nen tant que debut de nom de sequence"
	    set Orient "F"
	}
    }

    set NomDeLaSequence "${Nom}_${DebutBlastX}_${FinBlastX}"
    set Sequence ">$NomDeLaSequence\n[BoutADN $DebutBlastX $FinBlastX $Orient]"

    if { [regexp {^[XFR]$} $Nom] } {
	Sauve $Sequence dans "$RepertoireDuGenome/tmpdir/$NomDeLaSequence"
    }

    set Num [NomDe ""]
    set Tmp tmp.[pid]$Num
    set In  "$Tmp.BlastX.in"
    set Out "$Tmp.BlastX"
    set Log "$Out.log"

    Sauve [SequenceFormatTFA $Sequence] dans $In

    catch {set Canal [open "| $Commandes(blastx) $In $Out $Log"]} Message
    Warne $Message
    fconfigure $Canal -blocking false -buffering line
    fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out $Log"
    Warne "BlastX est lance en batch"
    return "est lance sur $NomDeLaSequence"

}

proc BlastXsurZone {K} {

    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique

    if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
	FaireLire "IL faut selectionner une zone par "
	return ""
    }

    set Debut [PositionCanvaOriginaleX $K [Mini  [set xDebutRectangleDeSelectionNucleique($K)]  [set   xFinRectangleDeSelectionNucleique($K)]  ]]

    set   Fin [PositionCanvaOriginaleX $K [Maxi  [set xDebutRectangleDeSelectionNucleique($K)]  [set   xFinRectangleDeSelectionNucleique($K)]  ]]

    BlastXdeADN "X" $Debut $Fin

}

proc BlastYEAH {{Start ""} {Stop ""}} {


    set SeuilExpect "1.0e-10"
    set MaxListe "SansLimiteDeNombre"

    set Banque "[RepertoireDuGenome]/banques/YEAH"
    foreach X [YEAHStore "ListOfAccess" $Start $Stop] {
	if {[YEAHpa $X]!=""} { continue }
	set FiTFA "[RepertoireDuGenome]/prottfa/$X"
	if {[FileAbsent $FiTFA]} {
	    set TFA [YEAHStore $X]
	    Sauve $TFA dans $FiTFA
	}
	continue
	set FichierBlast "[RepertoireDuGenome]/blastpYEAH/$X"
	if {[FileAbsent $FichierBlast]} {
	    if {[PasTouche $X]} { continue }
	    BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect
	    FinPasTouche $X
	}
    }

}

proc BlastallExe {} {


    global tcl_platform
    global OrdBinDir
    global env

    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./blastall"
    }
    if {[set tcl_platform(platform)] != "windows"} {
	if {[info exists OrdBinDir]} {
	    return [file join $OrdBinDir "blastall"]
	} else {
	    return "/bips/bin/blastall"
	}
    } else {
	set lexe [file join $OrdBinDir "blastall.exe"]
	regsub "Program Files" $lexe "PROGRA~1" lexe
	return $lexe
    }

}

proc Blaste {Programme Sequence {NomOuNumOuSortie ""} {Banque ""}} {

    global RepertoireDuGenome
    global Commandes

    Wup "Il existe aussi Blast plus interactif"

    if {[FormatDeLaSequence $Sequence] == "tfas"} {
	foreach Seq [split [string range $Sequence 1 end] ">"] {
	    Blaste $Programme ">$Seq"
	}
	return
    }

    if {[regexp "/" $NomOuNumOuSortie]} {
	set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	set Sortie $NomOuNumOuSortie
    } else {
	set Sortie ""
	if { $NomOuNumOuSortie == "" } {
	    set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	} elseif { [regexp {^[a-zA-Z]} $NomOuNumOuSortie ] } {
	    set NomNum ${NomOuNumOuSortie}[NomDe ""]
	} elseif { [regexp {^[0-9]} $NomOuNumOuSortie ] } {
	    set NomNum "[RepertoireDeTravail]/tmp.$NomOuNumOuSortie"
	} else {
	    set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
	    set Sortie $NomOuNumOuSortie
	}
    }
    set Tmp $NomNum

    set In  "$Tmp"
    set Out "$In.blastp"
    set Log "$Out.log"

    Sauve [SequenceFormatTFA $Sequence] dans $In

    if {$Sortie==""} { set AskOrNot "" } else { set AskOrNot "DontAsk" }

    if { $Programme == "P"     } {
	if {$Banque==""} { set Banque "/catalog/blast/protall" }
	set Prog "blastp"
    } elseif { $Programme == "N"    } {
	if {$Banque==""} { set Banque "/catalog/blast/genembl" }
	set Prog "blastn"
    } elseif { $Programme == "X"    } {
	if {$Banque==""} { set Banque "/catalog/blast/protein" }
	set Prog "blastx"
    } elseif { $Programme == "tN"    } {
	if {$Banque==""} { set Banque "/catalog/blast/genomes" }
	set Prog "tblastn"
    } elseif { $Programme == "Choix" } {
	set Prog ""
    } else {
	set Prog [ChoixParmi "blastp" "tblastn" "blastx" "blastn"] 
    }
    set Commande [ChoisisTonBlast $In $Out $Prog $Banque $AskOrNot]

    if {$Commande==""} { return "" }
    if {$Sortie!=""} {
	regsub {^.*batchcom.tcl *} $Commande "" Commande
	set Etat [eval $Commande]
	if { ! [file exists $Out]} { return "" }
	if {$Sortie=="retourne"} { return [ContenuDuFichier $Out] }
	File copy -force $Out $Sortie
	return $Sortie
    }
    Espionne $Commande
    if {[catch {set Canal [open "| $Commande"]} Message]} {
	Warne $Message
    }
    fconfigure $Canal -blocking false -buffering line
    fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out"
    Warne "Blast $Programme lance en batch"

}

proc BlasterLeRep {Repertoire} {


	foreach Fichier [glob -tails -directory $Repertoire "*.tfa"] {
		Espionne $Fichier
		exec blastall -p blastn -i $Fichier -o $Fichier.blast -d human
	}

}

proc BlastmRNA {FileBlastGenembl FileBlastmRNA {IdWithoutFilter ""} {Expect ""} {LesOrganismes ""}} {

    if {![file exists $FileBlastGenembl]} {return}
    AskBlast unset

    Espionne "$FileBlastGenembl blastngenembl -> $FileBlastmRNA blastnmrna"
    File copy -force $FileBlastGenembl $FileBlastmRNA
    
    if {$Expect != ""} {
	FichierBlastReduit $FileBlastmRNA $FileBlastmRNA Expect                $Expect
    }
    if {$IdWithoutFilter != ""} {
	FichierBlastReduit $FileBlastmRNA $FileBlastmRNA IdentityWithoutFilter $IdWithoutFilter
    }
    if {$LesOrganismes != ""} {
	FichierBlastReduit $FileBlastmRNA $FileBlastmRNA LesOrgaToKeep        $LesOrganismes
    }
    FichierBlastReduit     $FileBlastmRNA $FileBlastmRNA LesmRNAsToKeep
    AskBlast unset
    return $FileBlastmRNA

}

proc BlastnEnsemblMouseJunctionOnHumanJunctionBank {} {

#pax2
    set FileEnsemblMouse "/genomics/link/UCSCGenomes/Mus_musculus/database/mm9/last/ensGene.txt"
    set ListeVarMouse [InterrogeRefGeneOuEnsGeneUcsc ENSMUSG00000004231 Name $FileEnsemblMouse]
    set BankJuncHuman "/genomics/link/SpliRetMouse/201404/RepDeTravail/Pax2/JunctionsHumanPax2"
    foreach VarMouse $ListeVarMouse {
	foreach FileVarMouse [glob -nocomplain "/genomics/link/SpliRetMouse/201404/RepDeTravail/Pax2/${VarMouse}_*" ] {
	    set CommandeBlast "blastall  -p blastn  -i $FileVarMouse  -o $FileVarMouse.bl  -d $BankJuncHuman  -e 50.0  -F F  -W 8"
	    set CommandeBlastNew "/biolo/blast/bin/blastn  -task blastn  -query $FileVarMouse  -out $FileVarMouse.bl  -db $BankJuncHuman  -evalue 50  -dust yes  -word_size 8"
	    if {[catch {eval exec $CommandeBlast} Message]} {
		Espionne "Problem with $FileVarMouse"
		Espionne $Message
	    }
	}
    }

}

proc BlastnMouseRatJunctionIDVOnHumanJunctionBank {Org} {

    #Org "rat" or "mouse"
    set BankJuncHuman "/genomics/link/SpliRetMouse/201404/PubliFarkas/JunctionsHumanFromFarkas"
    set Rep "/genomics/link/SpliRetMouse/201404/RepDeTravail/All6$Org"
    foreach FileNuc [glob -nocomplain "$Rep/*.tfa"] {
#	Espionne "$FileNuc"
	regsub {\.tfa} $FileNuc "" FileNucOut
	#pastouche ne sert que quand on lance la proc avec SubmitGscope
#	set Current [file tail $FileNucOut]
#	if {[PasTouche $Current]} {continue}

	set CommandeBlastOldFF "blastall -p blastn -i $FileNuc -o ${FileNucOut}_FF.bl2.2.10 -d $BankJuncHuman -e 50.0 -F F -W 8"
#	Espionne "$CommandeBlastOldFF"
#	lappend LesCommandes $CommandeBlastOldFF
#	if {[catch {eval exec $CommandeBlastOldFF} Message]} {
#	    Espionne "Problem with $CommandeBlastOldFF"
#	    Espionne $Message
#	}

	set CommandeBlastNewDustNo "/biolo/blast/bin/blastn -task blastn -query $FileNuc -out ${FileNucOut}_dustno.bl2.2.29 -db $BankJuncHuman -evalue 50.0 -dust no -word_size 8"
	Espionne "$CommandeBlastNewDustNo"
	lappend LesCommandes $CommandeBlastNewDustNo
	if {[catch {eval exec $CommandeBlastNewDustNo} Message]} {
	    Espionne "Problem with $CommandeBlastNewDustNo"
	    Espionne $Message
	}
    }
    SauveLesLignes $LesCommandes dans "$Rep/Commandes" 

}

proc BlastomeProjects {{Qui ""} {Quoi ""}} {

    global BlastomeProjects

    if {$Qui=="Reload"} {
	if {[info exists BlastomeProjects]} { unset BlastomeProjects }
    }

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

    set FicMemo "/genomics/link/CilioCarta/fiches/BlastomesProjects.txt"
    if {$Qui!="Reload" && [file exists $FicMemo]} { array set BlastomeProjects [ContenuDuFichier $FicMemo] ; return [BlastomeProjects] }
    if {$Qui=="Reload"} { set Qui "" }

    set BlastomeProjects(ListOf,Science) {}
    set BlastomeProjects(ListOf,Go)      {}
    set BlastomeProjects(ListOf,Taxobla) {}
    
    set LesRepTaxobla    [lsort [glob -nocomplain "/genomics/link/*/taxobla"]]
    set LesMyGOsFromGene [lsort [glob -nocomplain "/genomics/link/*/fiches/MyGOsFromGene.txt"]]
    set LesMyGenesFromGo [lsort [glob -nocomplain "/genomics/link/*/fiches/MyGenesFromGo.txt"]]

    set LesSciences {}
    foreach RepTaxobla $LesRepTaxobla {
	set Science [file tail [file dirname $RepTaxobla]]
	lappend LesSciences $Science
    }
    foreach MyGOsFromGene $LesMyGOsFromGene {
	set Science [file tail [file dirname [file dirname $MyGOsFromGene]]]
	lappend LesSciences $Science
    }
    foreach MyGenesFromGo $LesMyGenesFromGo {
	set Science [file tail [file dirname [file dirname $MyGenesFromGo]]]
	lappend LesSciences $Science
    }
    set LesSciences [lsort -unique $LesSciences]
    set BlastomeProjects(ListOf,Science) $LesSciences 

    set BlastomeProjects(ListOf,Info) {}
    foreach Science $BlastomeProjects(ListOf,Science) {
	set RG "/genomics/link/$Science"
	set Miniconfig [ContenuDuFichier $RG/beton/miniconfig]
	set Prefixe [StringApres "PrefixeDesORFs " dans $Miniconfig]
	set NbProttfa 0
	set RepProttfa "$RG/prottfa"
	if {[file exists $RepProttfa]} { set NbProttfa [llength [glob -nocomplain "$RepProttfa/$Prefixe*"]] }
	set NbTaxobla 0
	set RepTaxobla "$RG/taxobla"
	if {[file exists $RepTaxobla]} { set NbTaxobla [llength [glob -nocomplain "$RepTaxobla/$Prefixe*"]] }
	set NbBlastp 0
	set RepBlastp "$RG/blastp"
	if {[file exists $RepBlastp]} { set NbBlastp [llength [glob -nocomplain "$RepBlastp/$Prefixe*"]] }
	set BlastomeProjects($Science,NbTaxobla) $NbTaxobla
	set BlastomeProjects($Science,NbBlastp)  $NbBlastp
	set Missing ""
	if {$NbTaxobla<$NbBlastp} { set Missing "[expr $NbBlastp-$NbTaxobla] are missing :'(" }
	set NbGo 0
	set FicMyGenesFromGo "$RG/fiches/MyGenesFromGo.txt"
	if {[file exists $FicMyGenesFromGo]} { set NbGo [regexp -all {\,Noms} [ContenuDuFichier $FicMyGenesFromGo]] }
	set NbGn 0
	set FicMyGOsFromGene "$RG/fiches/MyGOsFromGene.txt" 
	if {[file exists $FicMyGOsFromGene]} { set NbGn [regexp -all {\,GOs}  [ContenuDuFichier $FicMyGOsFromGene]] }
	set Status 0
	if {$NbProttfa < 1         } { incr Status 11100 } 
	if {$NbBlastp  < $NbProttfa} { incr Status  1100 } 
	if {$NbTaxobla < $NbBlastp } { incr Status   100 }
	if {$NbGo      < 1         } { incr Status    10 }
	if {$NbGn      < 1         } { incr Status     1 }
	set Status [format "%5.5d" $Status]
	regsub -all "0"     $Status "." Status
	regsub -all {[1-9]} $Status "X" Status
	lappend BlastomeProjects(ListOf,Info) [format "%-10s %-6s %s %6d %6d %6d %6d %6d (prottfa blastp taxobla GoWithGn GnWithGO) %s" $Science $Prefixe $Status $NbProttfa $NbTaxobla $NbBlastp $NbGo $NbGn $Missing]	
    }
    set BlastomeProjects(,) [join $BlastomeProjects(ListOf,Info) "\n"]

    Sauve [array get BlastomeProjects] dans $FicMemo
    file attribute $FicMemo -permissions 0777
    return [BlastomeProjects $Qui $Quoi] 

}

proc Blastong {{MaxBlastong ""} {TestOnly ""} {LesNoms ""}} {

    #rR Blast On Grid (for OrthoInspector)  ;)

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastong Match N]} {
	set MaxBlastong ""
	set DoMore $N  
    }
    if {$MaxBlastong==""} { set MaxBlastong 4 }
    
    
    
    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastong]} { return [Blastong "" "TestOnly"] }
    
    set MessageAlreadyRunning ""
    set LeMessageBlastong {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastong$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} {
	    set LesRetours [glob -nocomplain "[RepertoireDuGenome]/PassePlat_${Nom}_*/assiette/*"]
	    if { $LesRetours!={}} {
		set Status [DoneBlastong $Nom]
		lappend LeMessageBlastong $Status
	    }
	    continue
	}
	#rR Attention là on cherche le Done$Nom et on compte les Blastong
	set NbBlastong 0
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastong$Nom"} {
		set Done 1
		break
	    }
	    if {[regexp "^Blastong" $PasTouche]} {
		incr NbBlastong
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastong>=$MaxBlastong} { set MessageAlreadyRunning "$NbBlastong are already running" ; continue }
	incr DoMore -1

	if {$TestOnly} {
	    if {[PasTouche "Blastong$Nom" "test"]} { continue }
	} else {
	    if {[PasTouche "Blastong$Nom"]} { continue }
	}
	    
	#rR Arrivé ici on lance une grillade !!!!!!!!!!!!!!!!!!!!! (sauf test)

	if {$TestOnly} {
	    incr MaxBlastong -1
	    set Grillade "I did not lauch $Nom because it is only a test"
	} else {
	    set Grillade [GrilladinPourOi $Nom ]
	}
	lappend LeMessageBlastong $Grillade
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastong "It seems all is done or is running" }
    if {$LeMessageBlastong=={}} {
	set LeMessageBlastong [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastong [join $LeMessageBlastong "\n"]
    return $MessageBlastong

}

proc Blastonh {{MaxBlastonh ""} {TestOnly ""} {LesNoms ""}} {

    #rR Blast On HPC (for OrthoInspector)  ;)

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastonh Match N]} {
	set MaxBlastonh ""
	set DoMore $N  
    }
    if {$MaxBlastonh==""} { set MaxBlastonh 4 }

    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastonh]} { return [Blastonh "" "TestOnly" $LesNoms] }

    set MessageAlreadyRunning ""
    set LeMessageBlastonh {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastong$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} {
	    set LesRetours [glob -nocomplain "[RepertoireDuGenome]/PassePlat_${Nom}_*/assiette/*"]
	    if { $LesRetours!={}} {
		set Status [DoneBlastonh $Nom]
		lappend LeMessageBlastonh $Status
	    }
	    continue
	}

	#rR Attention là on cherche le Done$Nom et on compte les Blastonh
	set NbBlastonh 0
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastong$Nom" || $PasTouche=="DoneBlastonh$Nom" || $PasTouche=="DoneBlastonl$Nom"} {
		set Done 1
		break
	    }
	    if {[regexp "^Blastonh" $PasTouche]} {
		incr NbBlastonh
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastonh>=$MaxBlastonh} { set MessageAlreadyRunning "$NbBlastonh are already running" ; continue }
	incr DoMore -1

	if {$TestOnly} {
	    Espionne "Test $Nom"
	    if {[PasTouche "Blastonh$Nom" "test"]} { continue }
	} else {
	    Espionne "try $Nom"
	    if {[PasTouche "Blastonh$Nom"]} { continue }
	}
	    
	#rR Arrivé ici on lance un hotdog sur HPC  !!!!!!!!!!!!!!!!!!!!! (sauf test)

	if {$TestOnly} {
	    incr MaxBlastonh -1
	    set Hotdog "I did not lauch $Nom because it is only a test"
	} else {
	    set Hotdog [HotdogPourOi $Nom ]
	}
	lappend LeMessageBlastonh $Hotdog
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastonh "It seems all is done or is running" }
    if {$LeMessageBlastonh=={}} {
	set LeMessageBlastonh [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastonh [join $LeMessageBlastonh "\n"]
    return $MessageBlastonh

}

proc Blastonl {{MaxBlastonl ""} {TestOnly ""} {LesNoms ""}} {

    #rR Blast en Local (for OrthoInspector)  ;)
    #rR Si on en lance c'est en process séparé
    #rR Attention on lance sur la machine courante !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    NousAllonsAuBoulot "[RepertoireDuGenome]/oif"

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastonl Match N]} {
	set MaxBlastonl ""
	set DoMore $N  
    }
    if {$MaxBlastonl==""} { set MaxBlastonl 4 }
    if {[regexp {[0-9]+$} $TestOnly]} {
		set Nb $TestOnly
		set TestOnly ""
	}   
    
    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastonl]} { return [Blastonl "" "TestOnly"] }

    set NbBlastonl 0
    foreach PasTouche [PasTouche "ListAllFilesAndDirectories"] {
	if {[regexp {^Blastonl(OI[0-9]+)} $PasTouche Match Nom]} {
	    set YaPasTouche($Nom) 1
	    incr NbBlastonl
	}
    }
    Espionne $NbBlastonl
    set MessageAlreadyRunning ""
    set LeMessageBlastonl {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} { continue }

	if {[info exist YaPasTouche($Nom)]} {
	    set AtLeastOneAbsent 0
	    set NbBlast [llength [glob -nocomplain "$Nom/blast/*"]]
	    if {$NbBlast>=10000 && [glob -nocomplain "[RepertoireDuGenome]/pastouche/Blastonl$Nom/*"]=={}} {
		Espionne "Je vais faire DoneBlastonl $Nom"
		set Status [DoneBlastonl $Nom]
		lappend LeMessageBlastonl $Status
		incr NbBlastonl -1
	    }
	}
	#rR Attention là on cherche le Done$Nom et on compte les Blastonl
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastonl$Nom"} {
		set Done 1
		break
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastonl>=$MaxBlastonl} { set MessageAlreadyRunning "$NbBlastonl are already running" ; continue }
	incr DoMore -1

	#rR Arrivé ici on lance un local !!!!!!!!!!!!!!!!!!!!! (sauf test)
	if {$TestOnly} {
	    incr MaxBlastonl -1
	    set Lolo "I did not lauch $Nom because it is only a test"
	} else {
	    set Lolo [BlastLocalPourOiEnProcessSepare $Nom $Nb]
	    set Lolo "I launched $Nom log in  oif/log/$Lolo"
	    set MessageAlreadyRunning "Bidon" ;#rR ne sera pas affiché
	}
	lappend LeMessageBlastonl "For $Nom $Lolo"
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastonl "It seems all is done or is running" }
    if {$LeMessageBlastonl=={}} {
	set LeMessageBlastonl [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastonl [join $LeMessageBlastonl "\n"]

    OnRevientDuBoulot
    return $MessageBlastonl

}

proc BlastpCGHSEGamplif {Banque RepBlast RepTFA} {

    # se placer ds le rep banques/ pour lancer ces blasts sur star

    if {![file exists $RepBlast]} {file mkdir $RepBlast}

    foreach FichierTFA [glob -nocomplain $RepTFA/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "$RepBlast/$Nom"
	
	if {[file exists "/genomics/link/Procure/$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}
	if {[file exists "$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}

	### select
	set EnteteTFA [EnteteDuFichierTFA $FichierTFA]
	set LesInfos [split $EnteteTFA " "]
	set LLesInfos [llength $LesInfos]
	set Val [lindex [split $EnteteTFA " "] [expr $LLesInfos -1]]
	if {$Val>0} {

	    Espionne "$Nom -> blastp  / $Banque"
	    set NbSubject      200
	    set ExpectDeRef    10.0
	    set FichierBlastTmp [TmpFile]
	    set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/$Banque"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	    if {[file exists $FichierBlastTmp]} {
		File rename -force $FichierBlastTmp $FichierBlast
	    }
	    Espionne "$Nom -> blastp / $Banque done"
	}
    }

}

proc BlastpCGHSEGdel {Banque RepBlast RepTFA} {


    if {![file exists $RepBlast]} {file mkdir $RepBlast}

    foreach FichierTFA [glob -nocomplain $RepTFA/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "$RepBlast/$Nom"
	
	if {[file exists "/genomics/link/Procure/$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}
	if {[file exists "$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}

	### select
	set EnteteTFA [EnteteDuFichierTFA $FichierTFA]
	set LesInfos [split $EnteteTFA " "]
	set LLesInfos [llength $LesInfos]
	set Val [lindex [split $EnteteTFA " "] [expr $LLesInfos -1]]
	if {$Val<0} {

	    Espionne "$Nom -> blastp  / $Banque"
	    set NbSubject      200
	    set ExpectDeRef    10.0
	    set FichierBlastTmp [TmpFile]
	    set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/$Banque"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	    if {[file exists $FichierBlastTmp]} {
		File rename -force $FichierBlastTmp $FichierBlast
	    }
	    Espionne "$Nom -> blastp / $Banque done"
	}
    }

}

proc BlastpCGHindividuel {FichierTFA Banque} {

    set NbSubject      200
    set ExpectDeRef    10.0
    set FichierBlastTmp [TmpFile]
    set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/$Banque"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
    return $FichierBlastTmp

}

proc BlastpPRIMA {Banque RepBlast RepTFA} {


    if {![file exists $RepBlast]} {file mkdir $RepBlast}

    foreach FichierTFA [glob -nocomplain $RepTFA/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "$RepBlast/$Nom"
	
	if {[file exists "/genomics/link/Procure/$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}
	if {[file exists "$RepBlast/$Nom"]} {Espionne "Blast already done"; continue}

	Espionne "$Nom -> blastp  / $Banque"
	set NbSubject      200
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/$Banque"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blastp / $Banque done"
    }

}

proc BlastpPRIMA_CGHprot {NomRepBlast RepTFA} {


    if {![file exists "[RepertoireDuGenome]/$NomRepBlast"]} {file mkdir "[RepertoireDuGenome]/$NomRepBlast"}

    foreach FichierTFA [glob -nocomplain $RepTFA/* ] {
	set Nom [file tail $FichierTFA]
	set FichierBlast "[RepertoireDuGenome]/$NomRepBlast/$Nom"
	if {[file exists $FichierBlast]} {Espionne "Blast already done"; continue}

	### select
	set EnteteTFA [EnteteDuFichierTFA $FichierTFA]
	Espionne "$Nom -> blastp  / banqueCGH"
	set NbSubject      200
	set ExpectDeRef    10.0
	set FichierBlastTmp [TmpFile]
	set FichierBlastTmp [BlastPDuFichier $FichierTFA  "[GscopeDatabaseDir Procure]/banques/TousLesOligos"  $FichierBlastTmp  T $NbSubject $ExpectDeRef 0]
	if {[file exists $FichierBlastTmp]} {
	    File rename -force $FichierBlastTmp $FichierBlast
	}
	Espionne "$Nom -> blastp / banque CGH done"
    }

}

proc Blob2HTML {aT} {

    upvar $aT tbl

    if {$tbl(Id) ne ""} {
	Html_Append "
"
    } else {
	Html_Append "
"
    }
    foreach elt [set tbl(LElt)] {
	switch -regexp -- $elt {
	    {^title\_} {
		Html_Append "
$tbl($elt,Title)
"
	    }
	    {^Subtitle\_} {
		Html_Append "
$tbl($elt,Subtitle)
"
	    }
	    {^text} {
		Html_Teletype "[join $tbl($elt,Text) \n]"
	    }
	}
    }
    Html_Append "
"
    Html_BR
    
    return

}

proc Blob2Text {aT} {

    upvar $aT tbl
    global TextOut

    foreach elt [set tbl(LElt)] {
	switch -regexp -- $elt {
	    {^title\_} {
		lappend TextOut "$tbl($elt,Title)"
	    }
	    {^Subtitle\_} {
		lappend TextOut "$tbl($elt,Subtitle)"
	    }
	    {^text} {
		lappend TextOut "[join $tbl($elt,Text) \n]"
	    }
	}
    }
    lappend TextOut ""
    
    return

}

proc BlockOverlap {f1 l1 f2 l2} {

    set len [expr {min($l1,$l2)-max($f1,$f2)+1}]
    
    return $len

}

proc BlocksDesPfam {aBlocks LesPf LesBl} {

    #ne sert plus, se sert de FeaturesDesPfam maintenant 
    upvar $aBlocks Blocks
    foreach Bl $LesBl {
	lassign [split $Bl "/-"] BlName Deb Fin
	foreach x [NombresEntre $Deb $Fin] {
	    lappend YaBl($x) [list $BlName $Deb $Fin]
	}
    }
    foreach Pf $LesPf {
	set Blocks($Pf) {}
	if {![regexp {^[PRO]*_?PF[0-9]+ [^/]+/([0-9]+)\-([0-9]+)} $Pf Match Deb Fin]} {continue}
	foreach x [NombresEntre $Deb $Fin] {
	    if {![info exists YaBl($x)]} {continue}
	    LConcat Blocks($Pf) $YaBl($x)
	}
	set Blocks($Pf) [lsort -unique -command CompareIntegerInFeaturesDesPfam $Blocks($Pf)]
    }
    return

}

proc BlomeClades {{Quoi ""} {GetWhat ""}} {

    #rR Est appelé par le python Blame ... en question de science ...

    #rR Merci de me mettre à jour
    set Possibles [lsort [list Archaea CMC Cilio TTLL]]

    set Clades {}

    if {[regexp -nocase "Possible" $Quoi]} {
	set Clades $Possibles
    }

    if {$Quoi=="Archaea"} {
	set Clades [PhylAr ListOf PhyOS]
    }
    if {$Quoi=="CMC"} {
	set Clades [CMC ListOf JoinedClade]
    }
    if {$Quoi=="TTLL"} {
	set Clades [TTLL ListOf JoinedClade]
    }
    if {$Quoi=="Cilio" || [OnTraite "CilioCarta" "Like"]} {
	if {[OnTraite "CilioCarta"]} {
	    set Clades [BilanCilio ListOf JoinedClade]
	} else {
	    set Clades [QuestionDeScience "CilioCarta" "ret BilanCilio ListOf JoinedClade"]
	}
    }
    if {$GetWhat=="GetList"} { return [split $Clades " "] }
    return $Clades

}

proc BlomeCladesClaudineNeSertPlus {} {

    #rR attention il y a ausi des choses qui ressemblent dans gscope_oi ...
    set LesPhylum [SqlExecForDatabase "[BlomeDbDir]/AHalma_Archaea.db" "select nom from clade order by nom" "GetList"]
    set LesPhylum [OrderedClades $LesPhylum]
    foreach PhName  $LesPhylum {
	set PhTaxId [Tax $PhName TaxId]
	set PhClass [TaxClass $PhTaxId Name]
	Espionne [format "%10d %-30s %s" $PhTaxId $PhName $PhClass]
    }

    OiDomain Archaea
    foreach OX [OiCode ListOf OX] {
	set OS [OiCode $OX OS]
	Espionne "$OX $OS"
    }

}

proc BlomeCreateDb {{Project ""} {KindOfClades ""} {GetWhat ""}} {


    if {$Project==""} { set Project [file tail [RepertoireDuGenome]] }

    set Bdd "[BlomeDbDir]/${Project}_${KindOfClades}.db"
    
    if {[FileExists $Bdd]} {
        if {[OuiOuNon "$Bdd already exists. Do I overwrite ?"]} {
            Garde $Bdd
	    file delete $Bdd
	} else {
            return "Error: Already exists"
	}
    }
    Espionne [CanalSql [ConnInfoForDatabase $Bdd "CreateIfNotExists"]]

    SqlExec "BEGIN TRANSACTION"

    SqlExec "DROP TABLE IF EXISTS ln_clade_organism"
    SqlExec "DROP TABLE IF EXISTS ln_organism_taxobla"
    SqlExec "DROP TABLE IF EXISTS ln_branche_taxobla"
    SqlExec "DROP TABLE IF EXISTS branche"
    SqlExec "DROP TABLE IF EXISTS sapin"
    SqlExec "DROP TABLE IF EXISTS organism"
    SqlExec "DROP TABLE IF EXISTS taxobla"
    SqlExec "DROP TABLE IF EXISTS clade"

    SqlExec "CREATE TABLE clade   (pk_clade    INTEGER , nom           VARCHAR(15))"
    SqlExec "CREATE TABLE organism(pk_organism INTEGER , taxid         VARCHAR(10), 
                                                         specie        VARCHAR(25))"
    SqlExec "CREATE TABLE taxobla (pk_taxobla  INTEGER , gscopeid      VARCHAR(10), 
                                                         chemin        VARCHAR(20),
                                                         uniprotaccess VARCHAR(12),
                                                         uniprotid     VARCHAR(15), 
                                                         gene_name     VARCHAR(20), 
                                                         gene_id       VARCHAR(20))"
    SqlExec "CREATE TABLE branche (pk_branche  INTEGER , pk_sapin   INTEGER, 
                                                         id_branche INTEGER, 
                                                         largeur    INTEGER)"

    SqlExec "CREATE TABLE ln_clade_organism   (pk_clade     INTEGER,
                                               pk_organism  INTEGER)"

    SqlExec "CREATE TABLE ln_organism_taxobla (pk_taxobla   INTEGER, 
                                               pk_organism  INTEGER)"

    SqlExec "CREATE TABLE ln_branche_taxobla  (pk_branche   INTEGER, 
                                               pk_taxobla   INTEGER)"

    SqlExec "CREATE TABLE sapin               (pk_sapin     INTEGER, 
                                               pk_clade     INTEGER)"


    if {0} {
    SqlExec "CREATE TABLE clade   (pk_clade    INTEGER PRIMARY KEY AUTOINCREMENT, nom           VARCHAR(15))"
    SqlExec "CREATE TABLE organism(pk_organism INTEGER PRIMARY KEY AUTOINCREMENT, taxid         VARCHAR(10), 
                                                                                  specie        VARCHAR(25))"
    SqlExec "CREATE TABLE taxobla (pk_taxobla  INTEGER PRIMARY KEY AUTOINCREMENT, gscopeid      VARCHAR(10), 
                                                                                  chemin        VARCHAR(20),
                                                                                  uniprotaccess VARCHAR(12),
                                                                                  uniprotid     VARCHAR(15), 
                                                                                  gene_name     VARCHAR(20), 
                                                                                  gene_id       VARCHAR(20))"
    SqlExec "CREATE TABLE branche (pk_branche  INTEGER PRIMARY KEY AUTOINCREMENT, pk_sapin   INTEGER, 
                                                                                  id_branche INTEGER, 
                                                                                  largeur    INTEGER, 
                                   FOREIGN KEY(pk_sapin) REFERENCES sapin(pk_sapin))"

    SqlExec "CREATE TABLE ln_clade_organism   (pk_clade     INTEGER,
                                               pk_organism  INTEGER, 
                                   PRIMARY KEY(pk_clade, pk_organism), 
                                   FOREIGN KEY(pk_clade)    REFERENCES clade(pk_clade), 
                                   FOREIGN KEY(pk_organism) REFERENCES organism(pk_organism))"
    SqlExec "CREATE TABLE ln_organism_taxobla (pk_taxobla   INTEGER, 
                                               pk_organism  INTEGER, 
                                   PRIMARY KEY(pk_taxobla, pk_organism), 
                                   FOREIGN KEY(pk_organism) REFERENCES organism(pk_organism), 
                                   FOREIGN KEY(pk_taxobla)  REFERENCES taxobla(pk_taxobla))"
    SqlExec "CREATE TABLE ln_branche_taxobla  (pk_branche   INTEGER, 
                                               pk_taxobla   INTEGER, 
                                   PRIMARY KEY(pk_branche, pk_taxobla), 
                                   FOREIGN KEY(pk_branche)  REFERENCES branche(pk_branche),
                                   FOREIGN KEY(pk_taxobla)  REFERENCES taxobla(pk_taxobla))"
    SqlExec "CREATE TABLE sapin               (pk_sapin     INTEGER PRIMARY KEY AUTOINCREMENT, 
                                               pk_clade     INTEGER, 
                                   FOREIGN KEY(pk_clade)    REFERENCES clade(pk_clade)) "
    }
    SqlExec "COMMIT"

    if {$GetWhat=="GetHandleAndFilename"} { return [list [CanalSql] $Bdd] }
    if {$GetWhat=="GetHandle"           } { return [CanalSql] }
    CanalSqlDisconnect
    return $Bdd

}

proc BlomeCreateIndex {{Bdd ""}} {

    if {$Bdd!=""} { CanalSql [ConnInfoForDatabase $Bdd] }
    SqlExec "CREATE INDEX iclade    ON clade     (pk_clade, nom)"
    SqlExec "CREATE INDEX iorganism ON organism  (pk_organism, taxid, specie)"
    SqlExec "CREATE INDEX itaxobla  ON taxobla   (pk_taxobla, gscopeid)"
    SqlExec "CREATE INDEX ibranche  ON branche   (pk_branche)" 
    SqlExec "CREATE INDEX isapin    ON sapin     (pk_sapin, pk_clade)"
    SqlExec "CREATE INDEX ilnco     ON ln_clade_organism   (pk_clade, pk_organism)"
    SqlExec "CREATE INDEX ilnot     ON ln_organism_taxobla (pk_taxobla, pk_organism)"
    SqlExec "CREATE INDEX ilbt      ON ln_branche_taxobla  (pk_branche, pk_taxobla)"
    if {$Bdd!=""} { CanalSqlDisconnect ; return "" }
    return [CanalSql]

}

proc BlomeDbDir {} {

    return "[BlomeDir]/cgi-bin"

}

proc BlomeDir {} {

    return "/home/ripp/www/blome"

}

proc BlomeFilterTaxobla {{Bdd ""} {ListOfPkOrg ""} {ListOfNot ""} {ListOfCladeCounts ""}} {

    #rR Attention cette procédure se rammelle elle-même pour les Not
    CanalSqlTaxobla $Bdd

    set UseUnion [string equal -nocase $ListOfCladeCounts "UseUnion"]

    LogWscope $ListOfPkOrg
    LogWscope $ListOfNot

    if {$ListOfPkOrg=="-"} { set ListOfPkOrg "" }
    if {$ListOfNot  =="-"} { set ListOfNot   "" }

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

    if {$ListOfPkOrg==""} {
	set LesPkTot [SqlExec "select pk_taxobla from taxobla" "GetList"]
    } else {
	set PremiereFois 1
	foreach PkO $ListOfPkOrg {
	    set Sql "select pk_taxobla from ln_organism_taxobla where pk_organism==$PkO"
	    set LesPkT [SqlExec $Sql "GetList"]
	    if {$PremiereFois} {
		set LesPkTot $LesPkT
		set PremiereFois 0
	    } else {
		if {$UseUnion} {
		    set LesPkTot [ListsUnion $LesPkTot $LesPkT]
		} else {
		    set LesPkTot [ListsIntersection $LesPkTot $LesPkT]
		}
	    }
	}
    }

    if {$ListOfNot=="GetListOfPk"} { return $LesPkTot }

    if {$ListOfNot!=""} {
	set LesNot [BlomeFilterTaxobla $Bdd $ListOfNot "GetListOfPk" "UseUnion"]
	set LesPkTot [ListsComplement $LesPkTot $LesNot]
    }

    #####################if {$ListOfCladeCounts==""} { return $LesPkTot }

    #rR on suppose qu'il n 'y a pas de Absence checkée si un nombre de species est demandé.
    #rR donc on peut filter sur le nombre voulu.
    set LesNbHitsDesClades {}
    foreach CC [split $ListOfCladeCounts ","] {
	LogWscope $CC
	scan $CC "%d/%s" PkClade CountText
	set LesBornes [split $CountText "-"]
	set D [lindex $LesBornes 0]
	set F [lindex $LesBornes end]
	set LesBonsNb {}
	set LeSql {}
	lappend LeSql "select ln_branche_taxobla.pk_taxobla from ln_branche_taxobla, branche, sapin, clade "
	lappend LeSql " where "
	lappend LeSql "              $PkClade     =              sapin.pk_clade "
	lappend LeSql "   and   sapin.pk_sapin    =            branche.pk_sapin "
	lappend LeSql "   and branche.pk_branche  = ln_branche_taxobla.pk_branche "
	lappend LeSql "   and branche.id_branche >= $D and branche.id_branche <= $F"
	set Sql [join $LeSql " "]
	regsub -all { +} $Sql " " Sql
	Espionne $Sql
	set LesBonsNb [SqlExec $Sql "GetList"]
	set Nb [llength $LesBonsNb]
	lappend LesNbHitsDesClades "$PkClade=$D-$F"
	set LesPkTot [ListsIntersection $LesPkTot $LesBonsNb]
    }
    
    set LesPk {}
    set LesGscopeId {}
    set LesGeneId {}
    set Sql "select pk_taxobla, gscopeid, gene_id from taxobla where pk_taxobla in ([join $LesPkTot ,])"
    LogWscope $Sql
    foreach {Pk GscopeId GeneId} [SqlExec $Sql "GetList"] {
	lappend LesPk       $Pk
	lappend LesGscopeId $GscopeId
	if {$GeneId!=""} { lappend LesGeneId $GeneId }
    }

    set Pks             [join $LesPk " "]
    set Noms            [join $LesGscopeId " "]
    set GeneIds         [join $LesGeneId " "]
    set NbHitsDesClades [join $LesNbHitsDesClades " "]
    set Resultat "$Pks/$Noms/$GeneIds/$NbHitsDesClades"
    return $Resultat

}

proc BlomeNewQuery {{Project ""} {KindOfClades ""}} {

    
    set Overwrite 1

    set RepSql "[RepertoireDuGenome]/blomesql"
    file mkdir $RepSql

    lassign [BlomeCreateDb $Project $KindOfClades "GetHandleAndFilename"] SqlHandle Bdd
    if {[regexp "^Error" $SqlHandle]} { return $SqlHandle } 
    
    set LesFichiersACharger {}

    if {$Overwrite} {
	set TaxIdQuery [NotreOX]
	
	set ListOfClades [lsort -unique [BlomeClades $KindOfClades]] 
	
	foreach Clade $ListOfClades {
	    Espionne "Clade $Clade"
	    set OrgsFromClade($Clade) [CladeContentWithinOi2017 $Clade $KindOfClades]
	    set Cardinal($Clade) [llength $OrgsFromClade($Clade)]
	    foreach TaxId $OrgsFromClade($Clade) {
		lappend AllTaxId $TaxId
		set OsFrom($TaxId) [Tax $TaxId "Name"]
		lappend LesCladesDuTaxId($TaxId) $Clade
	    }
	}
	set AllTaxId [lsort -unique -integer $AllTaxId]
	
	set PkClade 0
	set SqlPourClade {}
	foreach Clade $ListOfClades {
	    incr PkClade
	    lappend SqlPourClade "$PkClade\t$Clade"
	    set PkDuClade($Clade) $PkClade
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourClade dans "$RepSql/10_SqlPour-clade.txt"]
	
	set PkOrganism 0
	set SqlPourOrganism {}
	foreach TaxId [lsort -integer [array names OsFrom]] {
	    set Species $OsFrom($TaxId)
	    incr PkOrganism
	    lappend SqlPourOrganism "$PkOrganism\t$TaxId\t$Species"
	    set PkDuOrganismTaxId($TaxId)     $PkOrganism
	    set PkDuOrganismSpecies($Species) $PkOrganism
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourOrganism dans "$RepSql/20_SqlPour-organism.txt"]
	
	set SqlPourLnCladeOrganism {}
	foreach Clade $ListOfClades {
	    foreach TaxId $OrgsFromClade($Clade) {
		set PkOrganism $PkDuOrganismTaxId($TaxId)
		lappend SqlPourLnCladeOrganism $PkDuClade($Clade)\t$PkOrganism
	    }
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourLnCladeOrganism dans "$RepSql/30_SqlPour-ln_clade_organism.txt"]
	
	set SqlPourSapin {}
	foreach Clade $ListOfClades {
	    set PkSapin $PkDuClade($Clade)                            ;#rR je ne sais pas si peut y en avoir d'autres ???
	    lappend SqlPourSapin "$PkSapin\t$PkDuClade($Clade)"
	    lappend LesPkSapin $PkSapin
	    lappend LesCladesDuSapin($PkSapin) $Clade
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourSapin dans "$RepSql/40_SqlPour-sapin.txt"]
	
	set PkBranche 0
	set SqlPourBranche {}
	foreach PkSapin $LesPkSapin {
	    foreach Clade $LesCladesDuSapin($PkSapin) {
		set Largeur [llength $OrgsFromClade($Clade)]
		foreach IdBranche [NombresEntre 0 $Largeur] {
		    incr PkBranche
		    lappend SqlPourBranche $PkBranche\t$PkSapin\t$IdBranche\t$Largeur
		    set PkBrancheDe($PkSapin,$IdBranche) $PkBranche
		}
	    }
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourBranche dans "$RepSql/50_SqlPour-branche.txt"]
	
	set PkTaxobla 0
	set SqlPourTaxobla {}
	foreach Nom [ListeDesPABs] {
	    incr PkTaxobla
	    set PkTaxoblaDe($Nom) $PkTaxobla
	    set Ac [ExtraitInfo $Nom "AC:"]
	    set Id [ExtraitInfo $Nom "ID:"]
	    set Gn [ExtraitInfo $Nom "ValiGN:"] ; if {$Gn==""} { set Gn [ExtraitInfo $Nom "GN:"] }
	    set Gi [ExtraitInfo $Nom "GI:"]     ; if {$Gi==""} { set Gi [NIAG $Nom "G"] }
	    lappend SqlPourTaxobla "$PkTaxobla\t$Nom\ttaxobla\t$Ac\t$Id\t$Gn\t$Gi"
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourTaxobla dans "$RepSql/60_SqlPour-taxobla.txt"]
	
	
	set SqlPourLnOrganismTaxobla {}
	foreach Nom [ListeDesPABs] {
	    set PkTaxobla $PkTaxoblaDe($Nom)
	    foreach Clade $ListOfClades {
		set PkClade $PkDuClade($Clade)
		set NbHitsDansClade($PkTaxobla,$PkClade) 0
	    }
	    foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "taxobla"]] {
		scan $Ligne "%f %f %d" Pn Score TaxId
		if {$Pn>0.001} { break }
		set Score [expr round($Score)]
		if { ! [info exists PkDuOrganismTaxId($TaxId)]} { continue }
		set PkOrganism $PkDuOrganismTaxId($TaxId)
		lappend SqlPourLnOrganismTaxobla "$PkTaxobla\t$PkOrganism"
		foreach Clade $LesCladesDuTaxId($TaxId) {
		    set PkClade $PkDuClade($Clade)
		    incr NbHitsDansClade($PkTaxobla,$PkClade)
		}
	    }
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourLnOrganismTaxobla dans "$RepSql/70_SqlPour-ln_organism_taxobla.txt"]
	
	set SqlPourLnBrancheTaxobla {}
	foreach {K NbHits} [array get NbHitsDansClade] {
	    lassign [split $K ","] PkTaxobla PkSapin
	    if { ! [info exists PkBrancheDe($PkSapin,$NbHits)]} {
		Espionne "not existing PkBrancheDe($PkSapin,$NbHits) PkTaxobla $PkTaxobla"
		continue
	    }
	    set PkBranche $PkBrancheDe($PkSapin,$NbHits)  ;#rR NbHits = IdBranche
	    lappend SqlPourLnBrancheTaxobla "$PkBranche\t$PkTaxobla"
	}
	lappend LesFichiersACharger [SauveLesLignes $SqlPourLnBrancheTaxobla dans "$RepSql/80_SqlPour-ln_branche_taxobla.txt"]
    } else {
	set LesFichiersACharger [lsort [glob "$RepSql/*SqlPour-*"]]
    }
    foreach Fichier $LesFichiersACharger {
	set Queue [file tail $Fichier]
	if { ! [regexp {\-([^\.]+)\.} $Queue Match Table]} { continue }
	$SqlHandle copy abort $Table $Fichier "\t"
	Espionne "$Table done"
    }

    BlomeCreateIndex

    CanalSqlDisconnect
    return $Bdd

}

proc BoiteDuCourant {K X Y} {

    global MemoBoiteDuCourantKXY MemoBoiteDuCourantRetour

    if {[info exists MemoBoiteDuCourantKXY] && $MemoBoiteDuCourantKXY=="$K$X$Y"} {
	return $MemoBoiteDuCourantRetour
    }
    
    set MemoBoiteDuCourantKXY "$K$X$Y"
    set MemoBoiteDuCourantRetour ""

    set x [$K canvasx $X]
    set y [$K canvasy $Y]
    set Courants [$K find withtag current]
    foreach Id $Courants {
	set SesTags [$K gettags $Id]
	if { [lindex $SesTags 0] == "Box" } {
	    set MemoBoiteDuCourantRetour [lindex $SesTags 1]
	    break
	}
	if { [lindex $SesTags 0] == "TEXTE" } {
	    set MemoBoiteDuCourantRetour [StringApres "Txt_" dans [lindex $SesTags 1]]
	    break
	}
    }
    return $MemoBoiteDuCourantRetour

}

proc Bold_WordML {} {

    return ""

}

proc BonAccess {s} {

    set s [lindex [split $s " "] 0]
    if {! [info exists ::Defauts] || ! [set ::Defauts(RemoveBankPrefix)]} {
	return [string trim $s]
    }

    set a [EnlevePrefixeBank $s]
    if {[EstUnAccessPDB $a]} {
	set a [BonNomPDB $a]
    } else {
	if {[regexp {\|} $a]} {
	    set a [string range $a 0 [string first "|" $a]-1]
	}
	if {[regexp {\.|\_|\,|\;|\:|\|} [string index $a end]]} {
	    set a [string range $a 0 end-1]
	}
	# voir InitPosSeqGenGenSeq
	# enleve character separateur : @
	set a [string map [list "@" "_"] $a]
    }
    set a [EnleveVersionDeAccess $a]

    return [string trim $a]

}

proc BonAngle {a} {

    while {$a > 180.} {
	set a [expr {$a - 360.}]
    }
    while {$a < -180.} {
	set a [expr {$a + 360.}]
    }

    return $a

}

proc BonChr {Chr} {

    #rR Nous nommerons toujours les chromosomes Chr01 à Chr25 (X=23, Y=24, M=25)
    regsub -nocase "Chr" $Chr "Chr" Chr
    if {[regexp -nocase {^Chr([1-9])$} $Chr Match N]} { set Chr "Chr0$N" }
    regsub -nocase "ChrX" $Chr "Chr23" Chr
    regsub -nocase "ChrY" $Chr "Chr24" Chr
    regsub -nocase "ChrM" $Chr "Chr25" Chr
    return $Chr

}

proc BonDNA {Fichier} {

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp ">" $Ligne]} { continue }
	if { ! [regexp -nocase {[^ATGC N]} $Ligne]} { continue }
	Espionne $Ligne
    }
    exit

}

proc BonNomPDB {acc} {

    set Aori $acc

    if {[string range $acc 0 1] eq "::"} {
	set acc [string range $acc 2 end]
    }
    if {[regexp -nocase {^PDB} $acc]} {
	set acc [string range $acc 3 end]
    }
    if {! [regexp {[0-9]} [string index $acc 0]]} {
	set acc [string range $acc 1 end]
    }
    if {[EstUnAccessPDB [string range $acc 0 3]]} {
	set Id [string range $acc 0 3]
    } else {
	return $Aori
    }

    if {[string length $acc] > 4} {
	if {! [regexp {[0-9a-zA-Z]} [string index $acc 4]]} {
	    set Ch [string range $acc 5 end]
	} else {
	    set Ch [string range $acc 4 end]
	}
    } else {
	set Ch ""
    }
    
    set nom "PDB_${Id}_$Ch"

    return $nom

}

proc BonNombreDeParametres {{Comment 1}} {


    Wup "Verifie le bon nombre de parametre pour le design"

    if {$Comment=="AvecVerif"} {set SansVerif "0"} else {set SansVerif "1"}
    if {$SansVerif && [LesParametresDuDesign BonNombreDeParametre "Existe"]} {return "[LesParametresDuDesign BonNombreDeParametre "LaValeurMerci"]"}
    if {    [LesParametresDuDesign LengthOligo    Existe] && [LesParametresDuDesign Query          Existe] && [LesParametresDuDesign TmLimit        Existe] && [LesParametresDuDesign Step           Existe] && [LesParametresDuDesign IdLimit        Existe] && [LesParametresDuDesign NbContiguous   Existe] && [LesParametresDuDesign WorkingDir     Existe] && [LesParametresDuDesign BlastExpect    Existe] && [LesParametresDuDesign BlastWord      Existe] && [LesParametresDuDesign BlastNbAligned Existe] && [LesParametresDuDesign DataBase       Existe]} {
	LesParametresDuDesign BonNombreDeParametre 1 "Positionne"
	return "1"
    } else {
	LesParametresDuDesign BonNombreDeParametre 0 "Positionne"
	return "0"
    } 

}

proc BonObjName {obj} {

    if {! [regexp {^obj_} $obj]} {
	set obj "obj_${obj}"
    }

    return $obj

}

proc BonParenthesage {Texte {What ""}} {


    if {$What==""} { set What "GetOk" }
    if {[regexp -nocase "GetAll|GetX" $What]} {
	set What "GetX_GetC_GetA_GetP"
    }
    set GetC [regexp -nocase "GetC" $What]
    set GetA [regexp -nocase "GetA" $What]
    set GetP [regexp -nocase "GetP" $What]
    set GetX [regexp -nocase "GetX" $What]

    set LesC {} 
    set LesA {} 
    set LesP {} 

    set iC 0
    set iA 0
    set iP 0
    set DejaLu ""
    set YaBackSlash 0
    set x -1
    foreach C [split $Texte ""] {
	incr x
	append DejaLu $C

	if {$YaBackSlash} { set YaBackSlash 0 ; continue }
	if {$C=="\\"} { set YaBackSlash 1 ; continue}

	if {$C=="\["} { incr iC ; PushOnStack $x C ; continue}
	if {$C=="\{"} { incr iA ; PushOnStack $x A ; continue}
	if {$C=="\("} { incr iP ; PushOnStack $x P ; continue }
	if {$C=="\]"} { incr iC -1 ; lappend LesC "[set pC [PullFromStack C]] $x" ; lappend All "C $pC $x" }
	if {$C=="\}"} { incr iA -1 ; lappend LesA "[set pA [PullFromStack A]] $x" ; lappend All "A $pA $x" }
	if {$C=="\)"} { incr iP -1 ; lappend LesP "[set pP [PullFromStack P]] $x" ; lappend All "P $pP $x" }
	if {$iC<0} { return "Unexpected '\]' at [string range $DejaLu end-40 end]" }
	if {$iA<0} { return "Unexpected '\}' at [string range $DejaLu end-40 end]" }
	if {$iP<0} { return "Unexpected '\)' at [string range $DejaLu end-40 end]" }
    }
    if {$iC>0} { return "Missing '\]' at [string range $DejaLu end-40 end]" }
    if {$iA>0} { return "Missing '\}' at [string range $DejaLu end-40 end]" }
    if {$iP>0} { return "Missing '\)' at [string range $DejaLu end-40 end]" }
    if {[regexp -nocase "GetX" $What]} { return $All }
    if {[regexp -nocase "GetC" $What]} { return $LesC }
    if {[regexp -nocase "GetA" $What]} { return $LesA }
    if {[regexp -nocase "GetP" $What]} { return $LesP }
    return ""

}

proc BonParenthesageDuFichier {Fichier} {

    return [BonParenthesage [ContenuDuFichier $Fichier]]

}

proc BonPrintOrdali {} {

    global Defauts PrmPrt DumpNoms DumpText NomNomSeq NomTextSeq Sequences LongueurTotale WTexteRegle

    if {[TypeAli] eq "pasdali"} {return}
    if {! [info exists PrmPrt]} {
	PrintSetup defauts
    }
    PrintSetup "destroy"

    #set PrmPrt(FontSize) 8
    if {"FntPrt" ni [font names]} {
	font create FntPrt -family Courier -size [set PrmPrt(FontSize)] -weight [set PrmPrt(FontWght)]
    }

    set format [set PrmPrt(Format)]
    set file "Fichier[TypeAli]"
    set ftype [TypeAli]
    set pfile [lindex [file split [file rootname [set Defauts($file)]]] end]

    set PrmPrt(ColRes) 0
    if {[QuelMode] eq "seqlab" || $::Toggle(ColRes)} {
	set PrmPrt(ColRes) 1
	LoadingFontImages
    }
    update idletasks

    set FonteMetrics [font metrics FntPrt]
    set HauteurLettre [lindex $FonteMetrics 5]
    set LargeurLettre [font measure FntPrt "Z"]
    set PrmPrt(HgLet) $HauteurLettre
    set PrmPrt(WdLet) $LargeurLettre
    lassign [DimensionsPapier] DimXPapier DimYPapier

    NamesSeqsToPrint
    set LNoms $PrmPrt(LNoms)
    set LSeqs $PrmPrt(LSeqs)

    # Decoupage en Y
    set DimY $DimYPapier
    if {[set PrmPrt(Ruler)]} {
	set DimY [expr {$DimY - 2*$HauteurLettre}]
    }
    lassign [DecoupeYEnPages $DimY] NPagesY NSeqsParPage DecalYNom

    # Decoupage en X
    # Calcule place pour mettre noms
    set DecalXNom [expr {($PrmPrt(LgNoms) + 3) * $LargeurLettre}]
    set DimX [expr {$DimXPapier - $DecalXNom}]
    if {[set PrmPrt(ResidueNbr)]} {
	set DimX [expr {$DimX - 7*$LargeurLettre}]
    }
    lassign [DecoupeXEnPages $DimX] NPagesX NColsParPage

    if {0} {
	puts "DimXPapier $DimXPapier DimYPapier $DimYPapier"
	puts "DimX $DimX DimY $DimY"
	puts "DecalXNom $DecalXNom"
	puts ""
	puts "NPagesY $NPagesY"
	puts "NSeqsParPage $NSeqsParPage"
	puts ""
	puts "NPagesX $NPagesX"
	puts "NColsParPage $NColsParPage"
	puts ""
	puts "HauteurLettre $HauteurLettre"
	puts "LargeaurLettre $LargeurLettre"
	flush stdout
	update idletasks
    }

    set law .prttmp
    toplevel $law
    set K "$law.c"
    pack [canvas $K]
    
    if {$DimXPapier < 0} {
	# on met dim papier fictive
	set DimXPapier [expr {$NColsParPage*$LargeurLettre + 1000}]
	set DimYPapier [expr {$NSeqsParPage*$HauteurLettre + 1000}]
    }

    for {set i 1} {$i <= $NPagesX} {incr i} {
	set DebutX [expr {($i-1) * $NColsParPage}]
	set FinX   [expr {$i * $NColsParPage - 1}]
	if {$FinX >= $PrmPrt(LgSeqs)} {
	    set FinX [expr {$PrmPrt(LgSeqs)-1}]
	}

	set DumpRegle ""
	foreach Y {1 2} {
	    set d [$WTexteRegle get $Y.$DebutX $Y.$FinX]
	    append DumpRegle "$d\n"
	}

	for {set j 1} {$j <= $NPagesY} {incr j} {
	    set file "$pfile.$i.$j.$format"
	    if {$format eq "ps"} {
		set Channel [open $file w]
	    }
	    $K delete all
	    $K configure -width $DimXPapier -height $DimYPapier
	    set DebutY [expr {($j-1)*$NSeqsParPage}]
	    set FinY   [expr {$j * $NSeqsParPage-1}]
	    set DumpNoms [join [lrange $LNoms $DebutY $FinY] \n]
	    set IdN [$K create text 0 0  -font FntPrt  -anchor nw  -text $DumpNoms]
	    set BBNom [$K bbox $IdN]
	    set DecalYNom [lindex $BBNom 3]

	    MetTagsSurCanvas $K $DecalXNom $DebutX $FinX $DebutY $FinY

	    if {[set PrmPrt(Ruler)]} {
		$K create text $DecalXNom $DecalYNom  -font FntPrt  -anchor nw  -text $DumpRegle
	    }
	    if {[set PrmPrt(ResidueNbr)]} {
		set DumpResidus [CalculeNoRes $DebutY $FinY $FinX]
		set DecalNomSeq [expr {$DecalXNom + $DimX + $LargeurLettre}]
		$K create text $DecalNomSeq 0  -font FntPrt  -anchor nw  -text $DumpResidus
	    }

	    update idletasks

	    if {$format eq "ps"} {
		$K postscript  -channel $Channel  -rotate [expr {[set PrmPrt(Orientation)] eq "landscape"}]
		close $Channel
	    } else {
		PrintCanvas $K $format $file
	    }
	}
	update
    }

    destroy [winfo toplevel $K]
    font delete FntPrt

    return

}

proc BonjourDeDao {} {

	return "Bonjour"

}

proc BonneEntetePourBilanCilio {Header} {

    global BonneEntetePourBilanCilio
    set HEADER [string toupper $Header]
    if {[info exists BonneEntetePourBilanCilio($HEADER)]} { return $BonneEntetePourBilanCilio($HEADER) }
    if {[info exists BonneEntetePourBilanCilio("EstCharge")]} { return $Header }
    set BonneEntetePourBilanCilio("EstCharge") 1

    set LookupList [list  "In_GoldStandard"         "InGoldStandard"        "GScope"                  "GscopeId"              "Uniprot ID"              "UniprotId"             "In orthoinspector"       "InOrthoinspector"      "Groupe de paralogue"     "GroupOfParalog"        "GO"                      -                       "Function"                -                       "Citation"                -                       "ProteinName"             -                       "Uniprot Total"           "UniprotTotal"          "Genomique comparative"   "ComparativeGenomics"   "Proteomique"             -                       "Transcriptomique"        "Trasncriptomics"       "Promoteur X-Box"         "PromoteurX-Box"        "Total"                   -                       "Prediction"              -                       "Phylum specific"         "PhylumSpecific"        "Ciliated-specific"       "CiliatedSpecific"      "Diff Stramenopile"       "DiffStramenopile"      "Diff Archaeplastidae"    "Diff Archaeplastidae"  "Diff Alveolata"          "DiffAlveolata"         "Diff Fungi"              "DiffFungi"             "Nb de clades ciliés"     "NbCladesCilies"        "Nb de clades non ciliés" "NbCladesNonCilies"     "Nb de PR"                "NbPR"                  "Universal"               "Universal"             "Nb Diff"                 "NbDiff"                ]
    foreach {K V} $LookupList {
	if {$V=="-"} { set V $K }
	set BonneEntetePourBilanCilio([string toupper $K]) $V
    }
    return [BonneEntetePourBilanCilio $Header]

}

proc BonneOrthographePour {P} {

    if {[string equal -nocase "DisEmbl" $P]} { set P "DisEMBL" }
    if {[string equal -nocase "GlobPlot" $P]} { set P "GlobPlot" }
    if {[string equal -nocase "Foldindex" $P]} { set P "FoldIndex" }
    if {[string equal -nocase "Ronn" $P]} { set P "Ronn" }
    return $P

}

proc BonneOrthographePour2 {P} {

    if {[string equal  "DisEmbl"   $P]} { set P "DisEMBL" }
    if {[string equal  "GlobPlot"  $P]} { set P "GlobPlot" }
    if {[string equal  "Foldindex" $P]} { set P "FoldIndex" }
    if {[string equal  "Ronn"      $P]} { set P "Ronn" }
    if {[string equal  "DisEMBL"   $P]} { set P "DisEmbl" }
    if {[string equal  "FoldIndex" $P]} { set P "Foldindex" }
    return $P

}

proc BonneOrthographePourScience {Science} {

    Wup "To eliminate troubles with UPPER lower case"
    if {[regexp -nocase "^(Animateur|Cafe)$"   $Science]} { return "Animateur" } 
    if {[regexp -nocase "^QuidSeq$"            $Science]} { return "QuidSeq" } 
    if {[regexp -nocase "^GeneQuid$"           $Science]} { return "GeneQuid" } 
    if {[regexp -nocase "^Genoret$"            $Science]} { return "Genoret" } 
    if {[regexp -nocase "^Gx$"                 $Science]} { return "Gx" } 
    if {[regexp -nocase "^Fasabi$"             $Science]} { return "Fasabi" } 
    if {[regexp -nocase "^Ontology$"           $Science]} { return "Ontology" } 
    if {[regexp -nocase "^Graphiste$"          $Science]} { return "Graphiste" } 
    return $Science

}

proc BonneSequencePourAlignement {s {outtype ""}} {

    if {$outtype eq ""} {set outtype "ordali"}
    if {$outtype eq "same"} {return $s}

    switch $outtype {
	"ordali" -
	"msf" {
	    set rs "."
	    set s [string toupper $s]
	}
	"tfa" {
	    set rs "-"
	    set s [string toupper $s]
	}
	"xml" -
	"macsim" {
	    set rs "-"
	    set s [string tolower $s]
	}
    }

    set s [string map [list "-" $rs "." $rs " " $rs "\n" "" "~" $rs] $s]

    return $s

}

proc BonneTete {Tete} {

    global BonneTete
    if {[info exists BonneTete($Tete)]} { return $BonneTete($Tete) }
    if {[info exists BonneTete("EstCharge")]} { return 0 }
    set BonneTete("EstCharge") 1
    set BonneTete(Probe_Set_ID) 1
    set BonneTete(GeneChip_Array) 1
    set BonneTete(Species_Scientific_Name) 1
    set BonneTete(Annotation_Date) 1
    set BonneTete(Sequence_Type) 1
    set BonneTete(Representative_Public_ID) 1
    set BonneTete(UniGene_ID) 1
    set BonneTete(Genome_Version_) 1
    set BonneTete(Alignments) 1
    set BonneTete(Gene_Title) 1
    set BonneTete(Gene_Symbol) 1
    set BonneTete(Ensembl) 1
    set BonneTete(Entrez_Gene) 1
    set BonneTete(SwissProt) 1
    set BonneTete(OMIM) 1
    set BonneTete(RefSeq_Protein_ID) 1
    set BonneTete(RefSeq_Transcript_ID) 1
    set BonneTete(Gene_Ontology_Biological_Process) 1
    set BonneTete(Gene_Ontology_Cellular_Component) 1
    set BonneTete(Gene_Ontology_Molecular_Function) 1
    set BonneTete(Pathway) 1
    set BonneTete(InterPro) 1
    set BonneTete(Trans_Membrane) 1
    set BonneTete(ListAll) [array names BonneTete]
    set BonneTete(GrandChef) "Probe_Set_ID"
    set BonneTete(ListChef) [list "RefSeq_Transcript_ID" "Alignments" "Representative_Public_ID" "SwissProt" "RefSeq_Protein_ID"]
    foreach Chef $BonneTete(ListChef) {
	set BonneTete($Chef-IsChef) 1
    }

    lappend BonneTete(ListOfReferents) "Alignments"
    set BonneTete(ListChefForAlignments) [list "RefSeq_Transcript_ID" "Representative_Public_ID"]
    return [BonneTete $Tete]

}

proc Boo {Fichier} {

    Espionne [ArbreBootstrapEnListe [ContenuDuFichier $Fichier]]
    exit

}

proc BootstrapArbre {AId Lns} {

    global Abr FAPG Defauts TPil NoDeLArbre

    foreach {n s} $Lns {
	lappend Ln $n
	lappend Ls [split $s ""]
    }
    set nbs [llength $Ln]
    set lgs [llength [lindex $Ls 0]]

    # cree piliers
    for {set i 0} {$i < $lgs} {incr i} {
	set ltmp [list]
	set stmp ""
	foreach s $Ls {
	    set c [lindex $s $i]
	    lappend ltmp $c
	    append  stmp $c
	}
	lappend LpilT $ltmp
	lappend LpilC $stmp
    }

    set ::TLeaves [[set Abr(Arbre,$AId)] leaves]
    InitBootstrap $AId

    if {[set Defauts(UseSpeedCode)] ne "tcl"} {
	Init_C_Boot
    }

    # Bootstrap 100 fois par defaut
    FaireAttendre "Please wait ...\nBootstrapping tree ..." 1

    # Bootstrap iterations
    set Nboot [set Defauts(TreeNBoot)]
    for {set bt 0} {$bt < $Nboot} {incr bt} {
	set FAPG [expr {100.*$bt/$Nboot}]
	update idletasks

	set NoDeLArbre 0

	if {[set Defauts(UseSpeedCode)] eq "tcl"} {
	    set Ldst [T_DoBootstrap $Ln $LpilT]
	} else {
	    set Ldst [C_DoBootstrap $Ln $LpilC]
	}

	set rep [fastme $Ln $Ldst]
	set ATb [DecortiqueUnArbre $rep]
	puts "ATb $ATb [set Abr(Arbre,$ATb)]"
	set Tb [set Abr(Arbre,$ATb)]
	CompteBootArbre $Tb root
	DetruitArbre $ATb
    }

    AssigneBootstrap $AId

    FaireLaSuite

    return

}

proc BootstrapPourTous {{NomATraiter ""} {nBootstraps 1000}} {


    if {$NomATraiter == "" } { 	
	set Liste [ListeDeBoites]
    } else {
	set Liste [list $NomATraiter]
    }

    set RepertoireMSF       "[RepertoireDuGenome]/msf"
    set RepertoireBootstrap "[RepertoireDuGenome]/bootstrap"
    set MatriceDeSimilarite "[RepertoireDuGenome]/fiches/bootstrapmatrix"

    File mkdir $RepertoireBootstrap
    
    set Conserve 1
    if {! $Conserve && [llength [glob -nocomplain "$RepertoireBootstrap/*"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireBootstrap"]
    }

    foreach Nom $Liste {
	set FichierMSF "$RepertoireMSF/$Nom"

	set FichierBootstrap   "$RepertoireBootstrap/$Nom"
	set Log "tmp.bootstrap.log"

	if { ! [file exists $FichierMSF]} { continue }
	if { $Conserve && [file exists $FichierBootstrap] } { continue }

	exec bootstrap $FichierMSF $FichierBootstrap $MatriceDeSimilarite $Log $nBootstraps
    }    

}

proc BornesBonSens {} {

    foreach NomDebutFinOrient [LesLignesDuFichier "[RepertoireDuGenome]/fiches/bornesdespabs"] {
	ExtraireDe $NomDebutFinOrient N D F O
	if {$D>$F} { set W $D ; set D $F ; set F $W }
	lappend Sortie "$N $D $F $O"
    }
    SauveLesLignes $Sortie dans "[RepertoireDuGenome]/fiches/bornesdespabsOK"
    exit

}

proc BornesDeSeraphinVersCasimir {} {

    global RepertoireDuGenome
    global ListeDesPABs
    global ListeDesTRNAs
    global ListeDesARNs

    if { ! [regexp "bys" $RepertoireDuGenome]} {
	FaireLire "Il fallait lancer setgscope bys"
	exit
    }

    ChargeLesPABs
    set NouvellesBornes {}
    foreach Boite $ListeDesPABs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdespabs.arenommer"]

    ChargeLesTRNAs
    set NouvellesBornes {}
    foreach Boite $ListeDesTRNAs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdestrnas.arenommer"]

    ChargeLesARNs
    set NouvellesBornes {}
    foreach Boite $ListeDesARNs {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	lappend NouvellesBornes "$Nom [CasimirDu $Debut] [CasimirDu $Fin] $Orient"
    }
    Espionne [SauveLesLignes $NouvellesBornes dans "$RepertoireDuGenome/../casimir/fiches/bornesdesarns.arenommer"]




}

proc BornesDuGeneEtendu {Nom} {

    set Debut  [Box $Nom debut]
    set Fin    [Box $Nom fin]
    set Orient [Box $Nom orient]

    if {$Orient=="F"} {
	set Gauche [expr $Debut - 300]
	set SeqAvant [BoutADN $Gauche [expr $Debut-1] $Orient]
    } else {
	set Droite [expr $Fin + 300]
	set SeqAvant [BoutADN [expr $Fin+1] $Droite $Orient]
    }
    set lSeqAvant [string length $SeqAvant]
    set i [expr $lSeqAvant - 3]
    set iDernierMet $lSeqAvant
    while {$i>=0} {
	set Codon [string range $SeqAvant $i [expr $i+2]]
	if {[CodonStartPossible $Codon]} { set iDernierMet $i }
	if {[CodonStopPossible  $Codon]} { break }
	incr i -3
    }
    set OldBornes "$Nom $Debut $Fin $Orient"
    if {$Orient=="F"} {
	set Bornes "$Nom [expr $Debut - ($lSeqAvant-$iDernierMet)] $Fin $Orient"
    } else {
	set Bornes "$Nom $Debut [expr $Fin + ($lSeqAvant-$iDernierMet)] $Orient"
    }
    return $Bornes

}

proc BornesDuPABDUnAutreGenome {Nom {Genome ""}} {

    global RepertoireDuGenome

    if {$Genome==""} { set Genome [lindex [GenomeDu $Nom] 0]}

    if { ! [file exists $Genome]} {
	set Genome "$RepertoireDuGenome/../$Genome"
    }

    set FichierBornes "$Genome/fiches/bornesdespabs"
    if { ! [file exists $Genome]} { return "" }

    foreach Ligne [LesLignesDuFichier $FichierBornes] {
	if {[regexp "$Nom" $Ligne]} { return $Ligne }
    }
    return ""

}

proc BornesExon {Path NumeroExon {ExonLast no} {IntronLast no} {Org ""} {Strand ""} {FromWhere refGene}} {

	CanalSqlUcsc $Org
	#Récupére les bornes de tous les exons pour les génes en possédant au moins $NumeroExon
	# Pour l'exon last, choisir NumeroExon2
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|MappingNormalizer|$Org : Getting all Exon$NumeroExon or previous intron with ExonLast=$ExonLast and IntronLast=$IntronLast (20sec max)"
	# Déclaration des fichiers
	set I 0
	if { $ExonLast == "no"} {
		set FichierDesExons [open "$Path/$Org-Exon$NumeroExon.coord" "w"]
	} else {
		set FichierDesExons [open "$Path/$Org-ExonLast.coord" "w"]
	}
	if { $NumeroExon > 1} {
		set NumeroIntron [expr $NumeroExon - 1]
		if { $IntronLast == "no" && $ExonLast == "no"} {
			set FichierDesIntrons [open "$Path/$Org-Intron$NumeroIntron.coord" "w"]
		} else {
			set FichierDesIntrons [open "$Path/$Org-IntronLast.coord" "w"]
		}
	}
	set FichierDesRequetes [open "/tmp/$Org-ExonsDesGenesAvecAuMoinsUnExon$NumeroExon.bql" "w"]

   if {$FromWhere==""} { set FromWhere "refGene" }
    set org $Org
    set Where "exonCount >= $NumeroExon"

    if {$Strand != ""} {
        if {$Strand=="F"} { set Strand "+" }
        if {$Strand=="R"} { set Strand "-" }
        append Where " and strand='$Strand'"
    }

	foreach {access chrom count starts ends strand} [SqlExec "SELECT name, chrom, exonCount, exonStarts, exonEnds, strand from ucsc$org.$FromWhere where $Where"] {
		set I 0
		set ExonNum 0
		set lstarts [split $starts ","]
		set lends [split $ends ","]
		set nbStarts [llength $lstarts]
		set nbEnds [llength $lends]
		#Espionne $lstarts
		if {$strand == "-"} {
			set lstarts [lreverse $lstarts]
			set lends [lreverse $lends]	
			#Espionne $lstarts
		}
		#Espionne "$nbStarts $nbEnds $count"
		if {$nbStarts == $nbEnds && $nbEnds == [expr $count + 1]} {
			foreach start $lstarts {
				if {$start != ""} {
					incr ExonNum
					set end [lindex $lends $I]
					set size [expr $end - $start]
					if {$NumeroExon == $ExonNum && $ExonLast == "no" && ( $ExonNum != $count || $count == 1) } {
						puts $FichierDesExons "$access $count $size $chrom $start $end $strand"
						if { $NumeroExon > 1} {
							if { $strand == "+"} {
								set intronStart [expr $oldEnd + 1]
								set intronEnd [expr $start - 1]
							} else {
								set intronStart [expr $end + 1]
								set intronEnd [expr $oldStart - 1]
							}
							set size [expr $intronEnd - $intronStart]
							puts $FichierDesIntrons "$access $count $size $chrom $intronStart $intronEnd $strand"
						}
						break
					}
					if {$ExonNum == $count && $ExonLast != "no" && $ExonNum >= 1} {
						puts $FichierDesExons "$access $count $size $chrom $start $end $strand"
					}
					if { $ExonNum == $count && $IntronLast != "no" && $NumeroExon > 2 } {
						if { $strand == "+"} {
							set intronStart [expr $oldEnd + 1]
							set intronEnd [expr $start - 1]
						} else {
							set intronStart [expr $end + 1]
							set intronEnd [expr $oldStart - 1]
						}
						set size [expr $intronEnd - $intronStart]
						puts $FichierDesIntrons "$access $count $size $chrom $intronStart $intronEnd $strand"
						break
					}
					set oldNum $ExonNum
					set oldStart $start
					set oldEnd $end
				}
				incr I
			}
		}
	}

}

proc BornesGenes {{Org human_hg18} {Strand ""} {FromWhere ""}} {


	#Récupére les bornes de tous les genes
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|MappingNormalizer|$Org : Getting all genes bounds"
	# Déclaration des fichiers
	set FichierDesBornesGenes [open "/tmp/$Org-ListeDesGenes.txt" "w"]

	# Suppressions des éventuelles versions précédentes des fichiers
	if { [file exists $FichierDesBornesGenes] } {
		file delete $FichierDesBornesGenes
	}

	if {$FromWhere==""} { set FromWhere "refGene" }
	set fromwhere [string tolower $FromWhere]	
	set Where "txStart>0"
	if {$Strand != ""} {
	if {$Strand=="F"} { set Strand "+" }
	if {$Strand=="R"} { set Strand "-" }
	append Where " and strand='$Strand'"
	}
	set Quoi "chrom, name, txStart, txEnd, strand"
	if { $FromWhere == "GeCo" } {
		set Quoi "$Quoi, typegene"
	}
	foreach { chrom name txStart txEnd strand } [SqlExec "SELECT $Quoi FROM ucsc$Org.$fromwhere where $Where order by chrom, TxStart"] {
		puts $FichierDesBornesGenes "$chrom $name $txStart $txEnd $strand"
	}
	close $FichierDesBornesGenes


}

proc BornesLocales {SequencePointee dG fG} {


    set iL 0
    set iG 0
    foreach C [split $SequencePointee ""] {
	incr iG
	if {[string equal $C "."]} { continue }
#        if {[regexp {[0-9]} $C]} { continue }

	incr iL
	if {$iG>$fG} { break }
	if {$iG>=$dG && ! [info exists dL]} { set dL $iL }
	if {[info exists dL]} { set fL $iL }
    }
    if {[info exists dL]} { return "$dL $fL" }
    return "-1 -1"

}

proc Botanique {{FichierPH ""}} {

    if {$FichierPH eq ""} { set FichierPH "Botanique.ph" }
    set LeTree [ContenuDuFichier $FichierPH]
    return [AfficheUnArbre $LeTree]

}

proc BougeFourmi {} {

    set ::go [expr {! $::go}]
    update
    
    return

}

proc BouleSurCorps {if {tid ""}} {

    if {$tid eq ""} {
	set tid [$::PAD find withtag "$if && ball"]
	if {$tid == {} } {
	    return
	}
    }
    set id [$::PAD find withtag "$if && tete"]
    set xc 0.0 ; set yc 0.0
    set n 0
    foreach {x y} [$::PAD coords $id] {
	set xc [expr {$xc + $x}]
	set yc [expr {$yc + $y}]
	incr n
    }
#    puts "boule $tid sur $if , corps $id"
    set xc [expr {round($xc/$n)}]
    set yc [expr {round($yc/$n)}]
#    puts "-> $xc $yc"

    lassign [$::PAD coords $tid] x1 y1 x2 y2
    set xb [expr {($x1 + $x2) / 2}]
    set yb [expr {($y1 + $y2) / 2}]
    set vx [expr {$xc - $xb}]
    set vy [expr {$yc - $yb}]
#    puts "-> $vx $vy"
    #$::PAD moveto $tid $xc $yc
    $::PAD move $tid $vx $vy
    $::PAD raise $tid
    
    return

}

proc Boum {} {

    global SortieAutorisee

    if { ! [OuiOuNon "Do You want to exit Gscope" 0]} { return "" }

    exit

}

proc BoundingBox {UneListeDeBoites} {

    set xMin  999999999
    set xMax -999999999
    foreach Boite $UneListeDeBoites {
	set xMin [Mini $xMin [Box $Boite debut]]
	set xMax [Maxi $xMax [Box $Boite fin]]
    }
    return "$xMin $xMax"

}

proc BoundingBoxDuGenome {} {

    global BoundingBoxDuGenome
    if { ! [info exists BoundingBoxDuGenome]} {
	set DF [BoundingBox [ListeDeBoites]]
	scan $DF "%d %d" xDebut xFin
	set xDebut [Maxi 0 [expr $xDebut-3000]]
	incr xFin  1000
	set BoundingBoxDuGenome "$xDebut $xFin"
    }
    return $BoundingBoxDuGenome

}

proc BoutADN {{Debut 1} {Fin -1} {Orient F} {Banque ""} {aProbleme ""}} {

    global ADN TDN RAC
    global DerniereBase LongueurADN

    if {$aProbleme!=""} { upvar $aProbleme Probleme }

    if {$Banque!=""} { return [BoutADNDeLaBanque $Debut $Fin $Orient $Banque $aProbleme] }

    Wup "Attention on a mis un 'x' en position 0 pour que la 1ere base soit en 1"

    set Status "ADNetTDNetRACAvailable"
    if { ! [info exists ADN]} {	set Status [ChargeADNetTDNetRAC] }
    if {$Debut=="Existe"} {
	if {$Status=="ADNetTDNetRACNotAvailable"} { return 0 } else { return 1 }
    }

    if {$Status=="ADNetTDNetRACNotAvailable"} { return "" }

    if { ! [info exists DerniereBase]} {
	set LongueurADN [string length $ADN]
	set DerniereBase [expr $LongueurADN-1]
    }
    if {$Fin==-1} { set Fin $DerniereBase }

    if { $Orient == "F" } {
	if { $Debut>=1 && $Fin <= $DerniereBase } {
	    set Probleme 0
	    return [string range $ADN $Debut $Fin]
	} else {
	    if {$Debut < 1} {
		set Probleme [expr $Debut-1]
		return "[BoutADN [expr $DerniereBase+$Debut] $DerniereBase $Orient][BoutADN 1 $Fin $Orient]"
	    }
	    if {$Fin > $DerniereBase} {
		set Probleme [expr $Fin-$DerniereBase]
		return "[BoutADN $Debut $DerniereBase $Orient][BoutADN 1 [expr $Fin-$DerniereBase] $Orient]"
	    }
	}
    } else {
	if {$Debut>=1 && $Fin <=$DerniereBase} {
	    set Probleme 0
	    return [string range $RAC [expr $LongueurADN-$Fin] [expr $LongueurADN-$Debut]]
	} else {
	    if {$Debut < 1} {
		set Probleme [expr $Debut-1]
		return "[BoutADN 1 $Fin $Orient][BoutADN [expr $DerniereBase+$Debut] $DerniereBase $Orient]"
	    }
	    if {$Fin > $DerniereBase} {
		set Probleme [expr $Fin-$DerniereBase]
		return "[BoutADN 1 [expr $Fin-$DerniereBase] $Orient][BoutADN $Debut $DerniereBase $Orient]"
	    }
	}
    }

}

proc BoutADNDeLaBanque {Deb Fin Orient Bank aProbleme} {

    upvar $aProbleme Probleme

    #Bank est le nom de la banque tblastn
    #on considere que le genome est circulaire
    set FichierGBK [UnixFileName $Bank]
    puts "Fichier Banque: $FichierGBK"
    if {![file exists $FichierGBK]} {
	puts "Fichier $FichierGBK non trouve"
	return ""
    }
    if {[regexp "^ID  " [PremiereLigneDuFichier $FichierGBK]]} {
	set SeqADN [LaSequenceDuFichierEMBL $FichierGBK]
    } else {
	DecortiqueGenBank OS OC SeqADN $FichierGBK
    }
    set LongueurTotale [string length $SeqADN]
    if {$Fin=="end"} {set Fin $LongueurTotale}
    incr Deb -1 ; incr Fin -1
    set LongueurDesiree [expr $Fin - $Deb + 1]
    if {$Deb>=0} {
	if {$Fin<$LongueurTotale} {
	    set Probleme 0
	    set Seq [string range $SeqADN $Deb $Fin]
	} else {
	    set Seq1  [string range $SeqADN $Deb end]
	    set LongueurRestante [expr $LongueurDesiree - [string length $Seq1]]
	    set Seq2  [string range $SeqADN 0 [expr $LongueurRestante-1]]
	    set Seq   "$Seq1$Seq2"
	    set Probleme $LongueurRestante
	}
    } else {
	if {$Fin<$LongueurTotale} {
	    set Seq2  [string range $SeqADN 0 $Fin]
	    set LongueurRestante [expr $LongueurDesiree - [string length $Seq2]]
	    set Seq1  [string range $SeqADN [expr $LongueurTotale - $LongueurRestante] end]
	    set Seq   "$Seq1$Seq2"
	    set Probleme [expr $LongueurRestante * -1]
	} else {
	    set Seq $SeqADN
	    Probleme -9876543210
	}
    }
    if {$Orient=="R"} {
	set Seq [NucToReverseAndComplementNuc $Seq] 
    }
    return $Seq

}

proc BoutADNDeUcsc {Deb Fin Orient {Orga ""} {Chro ""} {BigZips ""}} {

    Wup "Attention BoutADNdeUCSC compte a partir de 1"
    Wup "UCSC compte a partir de 0 pour les starts, et 1 pour les end"

    if {$BigZips==""} { set BigZips "bigZips" }
    set FichierTFA ""
    if {$Orga==""} { set Orga "Homo_sapiens" }
    set NomBigZip $Orga
    if {[regexp -nocase "Human"      $Orga]} { set NomBigZip "Homo_sapiens"}
    if {[regexp -nocase "Mouse"      $Orga]} { set NomBigZip "Mus_musculus"}
    if {[regexp -nocase "Rat"        $Orga]} { set NomBigZip "Rattus_norvegicus"}
    if {[regexp -nocase "Worm"       $Orga]} { set NomBigZip "Caenorhabditis_elegans"}
    if {[regexp -nocase "Danio|Fish" $Orga]} { set NomBigZip "Danio_rerio"}
    if {[regexp -nocase "Fly|Droso"  $Orga]} { set NomBigZip "Drosophilia_melanogaster"}
    set FichierTFA "/genomics/link/UCSCGenomes/$NomBigZip/$BigZips/$Chro.fa"
    if {[FileAbsent $FichierTFA]} {
	regsub "chr" $Chro "" Rep
	regsub "/$BigZips/" $FichierTFA "/$BigZips/$Rep/" FichierTFA
    }
    if {[FileAbsent $FichierTFA]} {
	FaireLire "I cannot find $FichierTFA for $Orga $Chro $BigZips"
	return ""
    }
    if {$Deb=="GetFile"} { return $FichierTFA }
    return [BoutADNDuTFA $Deb $Fin $Orient $FichierTFA]

}

proc BoutADNDuTFA {Deb Fin Orient {FichierTFA ""}} {

    global BoutADNDuTFA

    if {$FichierTFA==""} { set FichierTFA $BoutADNDuTFA("Current")} 

    set BoutADNDuTFA("Current") $FichierTFA

    if { ! [info exists BoutADNDuTFA($FichierTFA)]} {
	set BoutADNDuTFA($FichierTFA) [QueLaSequenceDuFichierTFA $FichierTFA]
    }

    set LongueurTotale [expr [string length $BoutADNDuTFA($FichierTFA)]]
    if {$Fin=="end"} {set Fin $LongueurTotale}
    incr Deb -1 ; incr Fin -1
    set Seq [string range $BoutADNDuTFA($FichierTFA) $Deb $Fin]
    if {$Orient=="R"} {	set Seq [NucToReverseAndComplementNuc $Seq] }
    return $Seq

}

proc BoutADNDuTFAOldVersionSansMemoParFichier {Deb Fin Orient {FichierTFA ""}} {

    global BoutADNDuTFA  BoutADNDuTFAFichier

    if {$FichierTFA==""} { set FichierTFA $BoutADNDuTFAFichier } 

    if { ! [info exists BoutADNDuTFAFichier] || $BoutADNDuTFAFichier!=$FichierTFA} {
	set BoutADNDuTFAFichier $FichierTFA
	set BoutADNDuTFA [QueLaSequenceDuFichierTFA $FichierTFA]
    }

    set LongueurTotale [expr [string length $BoutADNDuTFA]]
    if {$Fin=="end"} {set Fin $LongueurTotale}
    incr Deb -1 ; incr Fin -1
    set Seq [string range $BoutADNDuTFA $Deb $Fin]
    if {$Orient=="R"} {	set Seq [NucToReverseAndComplementNuc $Seq] }
    return $Seq

}

proc BoutAdnDeUcscBoost {Deb Fin Orient {Qui Homo_sapiens} {Chro ""} {BigZips bigZips}} {

    Wup "Attention BoutADNdeUCSC compte a partir de 0. (BoutADN de Gscope compte a partir de 1."
    		
	# Format du brin pour BoutADNDuTFA sous-traite par BoutADNUcscBoost
	if { $Orient == "+" || $Orient == "Plus" || $Orient == "Plus/Plus" || $Orient == "F" } { 
		set Orient "F"
	} else {
		set Orient "R"
	}
	if {$BigZips==""} { set BigZips "bigZips" }
    set FichierTFA ""
	if {$Qui!=""} {
        if {[regexp -nocase "Mus|Mouse" $Qui]} { set HumMou "Mus_musculus"} else { set HumMou $Qui }
		if {[regexp -nocase "Human|HOMO" $Qui]} { set HumMou "Homo_sapiens"} else { set HumMou $Qui }
			set FichierTFA "/genomics/link/UCSCGenomes/$HumMou/$BigZips/chr$Chro.fa"

        if {[FileAbsent $FichierTFA]} {

            regsub "chr" $Chro "" Rep
            regsub "/$BigZips/" $FichierTFA "/$BigZips/" FichierTFA
        }
    }
	#Espionne "$Deb $Fin $Orient $FichierTFA"
    return [BoutADNDuTFA $Deb $Fin $Orient $FichierTFA]

}

proc BoutonneLaFenetre {Fenetre Texte {Commande ""}} {

    set NdB [NomDe bouton]
    if {$Commande==""} {
	button $Fenetre.buttons$NdB -text $Texte
    } else {
	button $Fenetre.buttons$NdB -text $Texte -command $Commande
    }
    pack $Fenetre.buttons$NdB -side right -expand 1
    return "$Fenetre.buttons$NdB"

}

proc BoutonneLaFenetreSvg {args} {

    set args [string map [list "'" "prime"] $args]
    set NomDuBouton [lindex $args 1]
    regsub -all " " $NomDuBouton "_" NomDuBouton
    return "VirtualButton_$NomDuBouton"

}

proc Box {Boite Arg {Valeur ""}} {

    global ContenusDesBox
    global ListeDeBoites

    if { $Valeur != "" } {
	set ContenusDesBox($Boite,$Arg) $Valeur
	return $Valeur
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    if { ! [info exists ContenusDesBox($Boite,$Arg)] } { return "" }
    return [set ContenusDesBox($Boite,$Arg)]

}

proc BoxLocalisation {Nom FichierBlastGenome {ExpectMax 0.001} {NbSbjctMax 250}} {

    set RepLocHuman "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocHuman/seq_contig.md"
    if {![file exists $FichierContigs]} {return}
    set FichierBandesCytos "$RepLocHuman/CytologicMap"
    if {![file exists $FichierBandesCytos]} {return}
    
    set TailleContig 100000

    if {![file exists $FichierBlastGenome]} {return [list "$Nom\tNoBlastFile"]}
    
    set NbSubjectDansBlast [AskBlast $FichierBlastGenome NbSubject]
    if {$NbSubjectDansBlast == "" || $NbSubjectDansBlast == 0} {return [list "$Nom\tNoLoc"]}

    set LeTexte {}
    ### Definition des variables de references pour definir la monolocalisation#######
    set ContigDeRef   [AskBlast $FichierBlastGenome Subject 1]
    set LeContigDeRef [LeContig $ContigDeRef]
    set ChromDeRef    [lindex $LeContigDeRef 0]
    set AccessDeRef   [lindex $LeContigDeRef 1]
    set NbFragment    [lindex $LeContigDeRef 3]

    set BorneFragment [expr $NbFragment * $TailleContig]
    
    set ScoreDeRef  [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 Score ]
    regexp {^([e0-9\.\+]*) bits} $ScoreDeRef tmp ScoreDeRef
    set ExpectDeRef [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 Expect]
    set DQDeRef     [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 DQ    ]
    set FQDeRef     [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 FQ    ]
    set DSDeRef     [expr [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 DS] + $BorneFragment]
    set FSDeRef     [expr [AskBlast $FichierBlastGenome BanqueId $ContigDeRef Segment 1 FS] + $BorneFragment]
    if {$FSDeRef < $DSDeRef} {set tmp $FSDeRef;set FSDeRef $DSDeRef;set DSDeRef $tmp}
    
    ##########Determination de la monolocalisation#################################
    set LesSubjectsPoly {}
    set ListePoly  {}
    set ListeMayBe {}
    set NbSubjct 0
    set LesContigs {}
    set AiJeDejaVuLaRef 0
    for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {
	set Contig [AskBlast $FichierBlastGenome Subject $i]
	set Expect [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 Expect]
	if {$ExpectMax < $Expect} {continue}
	incr NbSubjct
	if {$NbSbjctMax <= $NbSubjct} {break}
	set Score [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 Score]
	
	lappend LesContigs $Contig
	set LeContig   [LeContig $Contig]
	set Access     [lindex $LeContig 1]
	set NbFragment [lindex $LeContig 3]
	
	if {![info exists TabBlast($Access,ExpectDeRef)]} {set TabBlast($Access,ExpectDeRef) $Expect}
	if {![info exists TabBlast($Access,ScoreDeRef) ]} {set TabBlast($Access,ScoreDeRef)  $Score }
	
	set BorneFragment [expr $NbFragment*$TailleContig]
	
	set Score  [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 Score]
	regexp {^([e0-9\.\+]*) bits} $Score tmp Score
	
	set DQ           [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 DQ]
	set FQ           [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 FQ]
	set DS     [expr [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 DS] + $BorneFragment]
	set FS     [expr [AskBlast $FichierBlastGenome BanqueId $Contig Segment 1 FS] + $BorneFragment]
	if {$FS < $DS} {set tmp $FS;set FS $DS;set DS $tmp}
	
	if {$Access == $AccessDeRef} {
	    if {    $ExpectDeRef <= $Expect && $ScoreDeRef <= $Score &&  $DQ == $DQDeRef && $FQ == $FQDeRef } {
		if {    $AiJeDejaVuLaRef && $DSDeRef != $DS && $FSDeRef != $FS} {
		    lappend ListePoly $Access
		    lappend LesSubjectsPoly $i
		}
		if {    !$AiJeDejaVuLaRef && $DSDeRef == $DS && $FSDeRef == $FS} {
		    lappend ListePoly $Access
		    lappend LesSubjectsPoly $i
		    set AiJeDejaVuLaRef 1
		}
	    }
	} else {
	    if {$ExpectDeRef <= $Expect && $ScoreDeRef <= $Score} {
		lappend ListePoly $Access
		lappend LesSubjectsPoly $i
	    } else {
		lappend ListeMayBe $Access
		}
	}
    }
    set nPoly  [llength $ListePoly]
    set nMayBe [llength $ListeMayBe]
    
    if {$nPoly == 1 && $nMayBe == 0} {
	set InfoLocalisation "MonoLoc"
    } elseif {$nPoly == 1 && $nMayBe != 0} {
	set InfoLocalisation "MayBePolyLoc"
    } elseif {1 < $nPoly} {
	set InfoLocalisation "PolyLoc"
    } elseif {$nPoly == 0  && $nMayBe == 0} {
	set InfoLocalisation "NoLoc"
    }
    
    if {$InfoLocalisation == "NoLoc"} {return [list "$Nom\tNoLoc"]}
    ##############################################################
    
    if {[info exists TabTmp]} {unset TabTmp}
    set LesLocalisations {}
    set i 0
    foreach Contig $LesContigs {
	incr i
	
	set LeContig   [LeContig $Contig]
	set Chromosome [lindex $LeContig 0]
	set Access     [lindex $LeContig 1]
	set Fragment   [lindex $LeContig 2]
	set NbFragment [lindex $LeContig 3]
	
	set BorneFragment [expr $NbFragment*$TailleContig]
	
	set ExpectDeRef [set TabBlast($Access,ExpectDeRef)]
	set ScoreDeRef  [set TabBlast($Access,ScoreDeRef)]
	regexp {^([e0-9\.\+]*) bits} $ScoreDeRef tmp ScoreDeRef
	
	set NbSegment [AskBlast $FichierBlastGenome BanqueId $Contig NbSegment]
	for {set j 1} {$j <= $NbSegment} {incr j} {
	    set PId [PourcentageDIdentiteDuSegmentDeLId $FichierBlastGenome $Contig $j]
	    
	    set Expect [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j Expect]
	    if {$ExpectMax < $Expect} {continue}
	    
	    set Info ""
	    if {($InfoLocalisation == "MonoLoc" || $InfoLocalisation == "MayBePolyLoc") &&  $i == 1 && $j == 1} {
		set Info "BestLoc"
	    } elseif {    $InfoLocalisation == "PolyLoc" &&  [regexp $i [join $LesSubjectsPoly " "]] && $j == 1} {
		set Info "BestPolyLoc"
	    }

	    set Score  [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j Score]
	    regexp {^([e0-9\.\+]*) bits} $Score tmp Score
	    
	    set Orientation [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j Orientation]
	    set Sens        [SensDeLaRegion $Orientation]
	    
	    set DQ     [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j DQ]
	    set FQ     [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j FQ]
	    if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp}
	    set DS     [expr [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j DS] + $BorneFragment]
	    set FS     [expr [AskBlast $FichierBlastGenome BanqueId $Contig Segment $j FS] + $BorneFragment]
	    if {$FS < $DS} {set tmp $FS;set FS $DS;set DS $tmp}
	    
	    if {[info exists TabTmp($DQ,$FQ,$DS,$FS)]} {continue}
	    set TabTmp($DQ,$FQ,$DS,$FS) 1
	    
	    set LesBandesCytologiques [LesBandesCytologiquesDeLaLocalisation $Access $DS $FS      ]
	    set LesCoordonnees        [CoordonneesSurChromosome              $Access $DS $FS $Sens]
	    set DSurChr               [lindex $LesCoordonnees 1]
	    set FSurChr               [lindex $LesCoordonnees 2]
	    set SensSurChr            [lindex $LesCoordonnees 3]
	    
	    set LesInfos [list $Nom $InfoLocalisation  $ExpectDeRef $Expect $ScoreDeRef $Score [format "%.2f" $PId]  $DQ $FQ  $Chromosome       $DSurChr $FSurChr $SensSurChr  $Access $Fragment $DS      $FS      $Orientation $Sens  [join $LesBandesCytologiques " "] $Info]

	    lappend LeTexte [join $LesInfos "\t"]
	}
    }
    AskBlast unset

    return $LeTexte

}

proc BoxWithBindingInDes {} {

    foreach Box [ListeDesPABs] {
	set LesPfam {}; set trouve 0
	set Cluster   [ExtraitInfo $Box "Cluster"]

	if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} {
	    set Org Mouse
	} elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set Org Rat
	} else {
	    set Org SpliRet
	}
	#set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit"
	#if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"}
	set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	if {![file exists $FileMacsims]} {continue}

	set LesNames [NamesFromMacsims $FileMacsims]
	foreach Name $LesNames {
	    set LesPfamJust [FromMacsims $FileMacsims $Name "JustPfam"]
	    foreach PfamJust $LesPfamJust {
		set Pfam [lindex [split $PfamJust " "] 0]
		if {[regexp "_" $Pfam]} {
		    set Pfam [lindex [split $Pfam "_"] 1]
		}
		lappend LesPfam $Pfam
	    }
	}
	set LesPfam [ListeSansDoublon $LesPfam]
	foreach Pfam $LesPfam {
	    set Des [InterrogePfamDesFrom1500 $Pfam Des]
	    if {[regexp "binding" $Des]} {
		#&& [regexp "DNA" $Des]
		set trouve 1
	    }
	}
	if {$trouve} {
	    lappend LesBoxRetenues $Box
	}
    }
    set LesBoxRetenues [ListeSansDoublon $LesBoxRetenues]
    Espionne "$LesBoxRetenues"
    Espionne "[llength $LesBoxRetenues]"

}

proc Branches {Tree} {

    return [DataSet links $Tree]

}

proc BrocOli {TFA} {

    global BrocOli
    JeMeSignale
    if { ! [info exists BrocOli("EstCharge")]} {
	set BrocOli("EstCharge") 1
	set BrocOli(FileName) "[RepertoireDuGenome]/fiches/BrocOli.txt"
	set BrocOli(ListOfNames) {}
	set BrocOli(AllText) [ContenuDuFichier $BrocOli(FileName)]
	set BrocOli(AllHtml) "
\n$BrocOli(AllText)\n
"
	set BrocOli(ListAll) [split $BrocOli(AllText) "\n"]
	foreach Ligne [LesLignesDuFichier $BrocOli(FileName)] {
	    if {[regexp { *\#} $Ligne]} { continue }
	    regsub {\#.*} $Ligne "" Ligne
	    if { ! [regexp -nocase {[ATGC]} $Ligne]} { continue }
	    scan $Ligne "%s %s" BrocName KeepName
	    regsub "$BrocName +$KeepName" $Ligne "" Ligne
	    regsub -all {[^ATGC ]} [string trim $Ligne] "" BrocAllSeq

	    set IsReverse [regexp "^reverse_" $BrocName]
	    if {$IsReverse} {
		regsub "reverse_" $BrocName "" BrocName
		set BrocAllSeq [NucToReverseAndComplementNuc $BrocAllSeq]
	    }

	    regsub { .+$}   $BrocAllSeq "" BrocLeftSeq
	    regsub {[^ ]+ } $BrocAllSeq "" BrocRightSeq
	    regsub " " $BrocAllSeq "" BrocAllSeq
	    if {[info exists BrocOli($BrocName,Seq)]} {
		FaireLire "I saw already BrocOli($BrocName,Seq) : $BrocOli($BrocName,Seq)"
	    }
	    set BrocOli($BrocName,IsReverse)   $IsReverse
	    set BrocOli($BrocName,KeepName)    $KeepName
	    set BrocOli($BrocName,KeepName)    $KeepName
	    set BrocOli($BrocName,AllSeq)      $BrocAllSeq
	    set BrocOli($BrocName,LeftSeq)     $BrocLeftSeq
	    set BrocOli($BrocName,RightSeq)    $BrocRightSeq
	    lappend BrocOli($BrocAllSeq,Names) $BrocName
	    lappend BrocOli(ListOfNames)       $BrocName
#	    Espionne "$BrocAllSeq"
	}
    }
    if {$TFA=="AllText"}     { return $BrocOli(AllText) }
    if {$TFA=="AllHtml"}     { return $BrocOli(AllHtml) }
    if {$TFA=="ListAll"}     { return $BrocOli(ListAll) }
    if {$TFA=="FileName"}    { return $BrocOli(FileName) }
    if {$TFA=="ListOfNames"} { return $BrocOli(ListOfNames) }

    set Seq [QueLaSequenceDuTexteTFA $TFA]
    set Access [EnteteDuTexteTFA $TFA "access"]

    set Trouve 0
    set LesTrouve {}
    foreach BrocName $BrocOli(ListOfNames) {
	Espionne "Pour $Access On essaye $BrocName"
	if { ! [regexp "^${BrocName}_" $Access] && ! [regexp "_${BrocName}$" $Access]} { continue }
	Espionne "Pour $Access On a trouve $BrocName"
	set IsReverse    $BrocOli($BrocName,IsReverse)
	set KeepName     $BrocOli($BrocName,KeepName)
	set BrocAllSeq   $BrocOli($BrocName,AllSeq)
	set BrocLeftSeq  $BrocOli($BrocName,LeftSeq)
	set BrocRightSeq $BrocOli($BrocName,RightSeq)
	if { ! [regexp -nocase "^$BrocAllSeq" $Seq]} {
	    FaireLire "$TFA\nindicates that it starts with BroOli $BrocName\n but its sequence doesn't correspond to $BrocAllSeq"
	    continue
	}
	lappend LesTrouve $BrocName
	set Trouve 1
    }
    if { ! $Trouve } { return "" }
    set BrocName [lindex $LesTrouve 0]
    if {[llength $LesTrouve]>1} {
	FaireLire "I found more then 1 BrocOli for \n$TFA\n\nPlease choose the right one ..." "Force"
	while {[set BrocName [ChoixParmi $LesTrouve]]==""} {
	    if {[OuiOuNon "Do we try again" 0 "Force"]} { return [BrocOli $TFA] }
	    if {[OuiOuNon "Do we do without BrocOli" 1 "Force"]} { return "" }   
	}
    }
    set IsReverse    $BrocOli($BrocName,IsReverse)
    set KeepName     $BrocOli($BrocName,KeepName)
    set BrocAllSeq   $BrocOli($BrocName,AllSeq)
    set BrocLeftSeq  $BrocOli($BrocName,LeftSeq)
    set BrocRightSeq $BrocOli($BrocName,RightSeq)
    
    Espionne "BrocName $BrocName"
    regsub -nocase $BrocLeftSeq $Seq "" RestSeq
    if { ! [regexp -nocase $BrocRightSeq $RestSeq]} {
	FaireLire "Something is wrong with BrocOli\n$TFA\n$BrocAllSeq" "Force"
    }
    if {$IsReverse} {
	regsub "_${BrocName}$" $Access "" RestAccess
	regsub -- {^[^_]+_} $Access "" Signaux
	set Entete "${RestAccess}_${KeepName} BrocOli with $BrocName replaces $Signaux"
    } else {
	regsub "${BrocName}_" $Access "" RestAccess
	regsub -- {_[^_]+$} $Access "" Signaux
	set Entete "${KeepName}_${RestAccess} BrocOli with $BrocName replaces $Signaux"
    }
    set NewTFA [SequenceFormatTFA $RestSeq $Entete "nucbrut"]
    Espionne $NewTFA
    return $NewTFA

}

proc BrowseShowTaxIdFile {} {

    set file [DemandeEtOuvreFichier *]
    if {$file eq "" || ! [file exists $file]} {
	return
    }
    set ::Tx(-ShowFile) $file

    return

}

proc BrowseTaxNCBI {{Texte ""} {Quoi ""}} {


    if {[regexp "\n" $Texte]} {
	foreach Ligne [split $Texte "\n"] {
	    if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
	    BrowseTaxNCBI $Ligne $Quoi
	}
	return
    }

    if {$Texte==""} { set Texte "AskForAction" }

    if {$Texte=="AskForAction"} {
	lappend LesActions "Ask for a node ..."
	lappend LesActions "BrowseTaxNCBI List Queries"
	lappend LesActions "BrowseTaxNCBI 1 TaxId"
	lappend LesActions "BrowseTaxNCBI 9606 Parent"
	lappend LesActions "CreateSqlTaxonomy ShowOnly"
	lappend LesActions "CreateSqlTaxonomy"
	set Action [ChoixParmi $LesActions]
	if {$Action==""} { return "" }
	if {[regexp "^Ask " $Action]} {
	    set Texte [Entre "9606"]
	    return [BrowseTaxNCBI $Texte $Quoi]
	}
	return [eval $Action]
    }

    if {$Quoi==""} {
	set Quoi [ChoixParmi [TaxNCBI List Queries]]
    }
    if {$Quoi==""} { return "" }

    scan $Texte "%s" Id
    if {[regexp {^[0-9]+$} $Id]} { set BonTexte $Id } else { set BonTexte $Texte }  
    set V [TaxNCBI $BonTexte $Quoi]
    if {[regexp "^Its" $Quoi]} {
	set LesVs $V
    } else {
	set LesVs [list $V]
    }
    set LeNouveauTexte {}
    foreach V $LesVs {
	if {[regexp {^[0-9]+$} $V]} {
	    set Noeud $V
	    set LesNoeuds [list [TaxNCBI $Noeud Name]]
	    if {[info exists DejaVu]} { unset DejaVu }
	    set DejaVu($Noeud) 1
	    while 1 {
		if {$Noeud==1} { break }
		set Parent [TaxNCBI $Noeud Parent]
		set NomDuNoeudParent [TaxNCBI $Parent Name]
		lappend LesNoeuds $NomDuNoeudParent
		set Noeud $Parent
		if {[info exists DejaVu($Noeud)]} { break }
		set DejaVu($Noeud) 1
	    }
	    set Classe [join $LesNoeuds ";"]
	    set BeauV "$V $Classe"
	} else {
	    set BeauV $V
	}
	lappend LeNouveauTexte $BeauV
    }
    if {$LeNouveauTexte=={}} { return "" }
    set NouveauTexte [join $LeNouveauTexte "\n"]
    set Fen [AfficheVariable $NouveauTexte "AvecTaxNCBI"]
    Illumine "" $Fen
    return $Fen

}

proc BrowseUserSelectedTaxIdFile {} {

    set file [DemandeEtOuvreFichier *]
    if {$file eq "" || ! [file exists $file]} {
	return
    }
    set ::Tx(-UserFile) $file

    return

}

proc BruteForceAgents {} {

    global LNOrdali Sequences TAg T Larbres

    unset -nocomplain T
    set Lnoms {}
    foreach n $LNOrdali {
	if {$n ne ""} {lappend Lnoms $n}
    }

    set Ltop  {}
    set Lnone {}
    foreach n1 $Lnoms {
	#puts "\n$n1"
	foreach ag1 $TAg($n1) {
	    #puts "\t$TAg($ag1,$n1,seq) $ag1 :"
	    set Ln {}
	    foreach n2 $Lnoms {
		if {$n1 eq $n2} {
		    continue
		}
		
		#puts "\t$n2"
		foreach ag2 $TAg($n2) {
		    lassign [ScoreAgentsPair $n1 $ag1 $n2 $ag2] score seuil
		    
		    if {$score ne "skip"} {
			#puts "\t\t=> $ag2 $TAg($ag2,$n2,mil)"
			#puts "\t\t$TAg($ag1,$n1,seq) $score"
			#puts "\t\t$TAg($ag2,$n2,seq) $seuil"
			lappend Ln [list $n2 $ag2 $score]
		    }
		}
	    }
	    set T($n1,$ag1) $Ln
	}
    }

    #NettoyageAgents
    #exit

    #Sauve [array get T] Dans filsde.dat
    #exit
    
    if {0} {
	# recap
	puts "\nRecap :"
	set nTop 0
	foreach n1 [lrange $LNOrdali 0 end-1] {	
	    puts "\n${n1}=="
	    foreach ag1 $TAg($n1) {
		if {[llength $T($n1,$ag1)] == 0} {
		    continue
		}
		
		#set sin [lindex [lindex $T($n1,$ag1) 0] 0]
		set sin ""
		set top 1
		foreach l [lsort -decreasing -real -index 2 $T($n1,$ag1)] {
		    lassign $l n2 ag2 score
		    if {$n2 ne $sin} {
			puts ""
			puts "\t>$TAg($ag1,$n1,seq) $ag1 $TAg($ag1,$n1,seq)"
			set sin $n2
		    }
		    set r [IsRealAgent $ag1 $n1 $ag2 $n2]
		    if {$top && $r eq "*"} {
			incr nTop
		    }
		    set top 0
		    puts "\t$r$TAg($ag2,$n2,seq) $n2 [format %-3d $ag2] [format %5.2f $score]"
		}
		puts ""
	    }
	}
	puts "nTop $nTop"
    }
    foreach n $LNOrdali {
	puts "$n [llength [array names T "$n1,*"]]"
    }

    #puts "\ntop  [llength $Ltop]"
    #puts "none [llength $Lnone]"
	
    set ::DoTour 0
    set Larbres {}
    #puts "chemins :"
    #set Lche [Che2]
    #puts "[join $Lche \n]"
    #exit

    if {0} {
	foreach f [array names T "s01,*"] {
	    lassign [split $f ,] n1 ag1
	    puts "\n$n1 $ag1"
	    puts [join [CheminsAgentAA $n1 $ag1 $n1 $ag1] \n]
	}
    }

    #exit

    return

}

proc BruteForceAgents2 {} {

    global LNOrdali Sequences TAg T Larbres

    unset -nocomplain T
    set Lnoms {}
    foreach n $LNOrdali {
	if {$n ne ""} {lappend Lnoms $n}
    }

    set Ltop  {}
    set Lnone {}
    set iNom 1
    foreach n1 [lrange $Lnoms 0 end-1] {
	#puts "\n$n1"
	foreach ag1 $TAg($n1) {
	    #puts "\t$TAg($ag1,$n1,seq) $ag1 :"
	    foreach n2 [lrange $Lnoms $iNom end] {
		#puts "\t$n2"
		set Ln {}
		foreach ag2 $TAg($n2) {
		    lassign [ScoreAgentsPair $n1 $ag1 $n2 $ag2] score seuil
		    
		    if {$score eq "skip"} {
			set score -999.0
		    }
		    lappend Ln [list $ag2 $score]
		    lappend T($n2,$ag2,$n1) [list $ag1 $score]
		}
		set T($n1,$ag1,$n2) $Ln
	    }
	}
	incr iNom
    }

    #NettoyageAgents
    #exit

    #Sauve [array get T] Dans filsde.dat
    #exit
    
    if {0} {
	# recap
	puts "\nRecap :"
	set nTop 0
	foreach n1 [lrange $LNOrdali 0 end-1] {	
	    puts "\n${n1}=="
	    foreach ag1 $TAg($n1) {
		if {[llength $T($n1,$ag1)] == 0} {
		    continue
		}
		
		#set sin [lindex [lindex $T($n1,$ag1) 0] 0]
		set sin ""
		set top 1
		foreach l [lsort -decreasing -real -index 2 $T($n1,$ag1)] {
		    lassign $l n2 ag2 score
		    if {$n2 ne $sin} {
			puts ""
			puts "\t>$TAg($ag1,$n1,seq) $ag1 $TAg($ag1,$n1,seq)"
			set sin $n2
		    }
		    set r [IsRealAgent $ag1 $n1 $ag2 $n2]
		    if {$top && $r eq "*"} {
			incr nTop
		    }
		    set top 0
		    puts "\t$r$TAg($ag2,$n2,seq) $n2 [format %-3d $ag2] [format %5.2f $score]"
		}
		puts ""
	    }
	}
	puts "nTop $nTop"
    }

    if {0} {
	foreach f [array names T "s01,*"] {
	    lassign [split $f ,] n1 ag1
	    puts "\n$n1 $ag1"
	    puts [join [CheminsAgentAA $n1 $ag1 $n1 $ag1] \n]
	}
    }

    #exit

    return

}

proc BtnDeLaFeature {f} {

    global FrmBtnFea

    foreach c [winfo children $FrmBtnFea] {
	if {[$c cget -text] eq $f} {return $c}
    }

    return ""

}

proc BuildDistrib {{plat ""}} {

    
    if {$plat ne ""} {
	if {$plat eq "all"} {
	    foreach plat {"Linux-x86" "Linux-x86_64" "Windows" "Mac"} {
		exec ordali BuildDisstrib $plat
	    }

	    exit
	}
    } else { 
	# Definit plateform, et repertoire associes
	package require platform
	set plat [::platform::generic]
    }
    
    set rep CreeExe
    
    # Tout se passe dans ordali/Build
    cd [file join $::OrdaliDir Build]
    
    # menage avant d'attaquer
    # - dans Build/
    catch {file delete -force ordalie.tcl}
    catch {file delete -force LesProcsDeGscope.tcl}
    # - dans Build/$rep
    catch {file delete -force {*}[glob [file join $rep ordalie*]]}
    # - dans ToPack
    catch {file delete -force [file join ToPack lib]}
    catch {file delete -force [file join ToPack etc]}
    catch {file delete -force {*}[glob [file join ToPack ordalie*]]}
    
    # Met a jour les libs en fonction de la platform
    puts ""
    puts "On met le bon environnement"
    PackLibrairies $plat
    
    # Recupere toutes les procedures ...
    puts "on cree le fichier global .tcl"
    set LesProcsDeGscope [ToutesLesProcsDeGscope]
    
    # Cree fichier tcl global
    # Ouvre fichier qui contient tout
    set f [open "ordalie.tcl" w]
    # procs de gscope , ordali ...
    puts $f [join $LesProcsDeGscope \n]
    # Ajoute ordali.tcl en fin
    set Lj [LesLignesDuFichier [file join $::OrdaliDir src ordali.tcl]]
    puts $f [join [lrange $Lj 3 end] "\n"]
    close $f

    # Prepare construction du starpack
    file copy -force ordalie.tcl [file join $rep ordalie.tcl]
    
    ##################
    # PLATFORM SPECIFIC
    #
    puts "on cree l executable"
    cd $rep
    CreeOrdalieStarpack $plat
    
    # Prepare creation de l'installeur
    file copy -force [glob ordalie*] [file join .. ToPack]
    
    cd [file join .. ToPack]
    puts "on est dans : [pwd]"
    puts "cree etc/"
    file copy -force [file join $::OrdaliDir etc] .
    
    # nettoyage des .svn ...
    set Lsvn [FindTcl .svn .]
    file delete -force {*}$Lsvn
    
    puts "\ndone !"
    
    exit

}

proc ButineArborescence {{Type ""} {RepertoireEtFichier ""}} {

    global RepertoireInitialDeButine
    global FichierInitialDeButine

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

    global OuiOuNonToujoursParDefaut
    if {[info exists OuiOuNonToujoursParDefaut] && $OuiOuNonToujoursParDefaut} {
	if {[file exists $RepertoireEtFichier]} { return $RepertoireEtFichier }
    } 

    if {[regexp {/$} $RepertoireEtFichier]} {
	regsub {/$} $RepertoireEtFichier "" Rep
	set Fic ""
    } else {
	set Rep [file dirname $RepertoireEtFichier]
	set Fic [file tail $RepertoireEtFichier]
    }
    if {$Rep!=""} {
	set RepertoireInitialDeButine $Rep
    }
    if {$Fic!=""} {
	set FichierInitialDeButine $Fic
    }

    if { ! [info exists RepertoireInitialDeButine]} { set RepertoireInitialDeButine [pwd] } 
    if { ! [info exists FichierInitialDeButine]}    { set FichierInitialDeButine "" } 


    set Types(All) {
	{{All files}            *  }
    }
    
    set Types(MSF) {
	{{Alignment output}  {.msf}}
	{{All files}            *  }
    }
    
    set Types(Blastp) {
	{{Blast output}   {.blastp}}
	{{All files}            *  }
    }
    
    set Types(FOF) {
	{{File Of Filenames} {.fof}}
	{{All files}            *  }
    }
    
    set Types(ps) {
	{{Postcript file} {.ps}}
	{{All files}            *  }
    }
    
    set Types(Sequence) {
	{{All files}            *  }
	{{Raw}               {.seq}}
	{{Fasta}             {.tfa}}
	{{GCG}               {.ged}}
    }

    set NomDeFichier [tk_getOpenFile -title "Fichier a ouvrir"  -initialdir $RepertoireInitialDeButine  -initialfile $FichierInitialDeButine  -defaultextension ""  -filetypes $Types($Type)]
    if { $NomDeFichier == "" } { return ""}
    set RepertoireInitialDeButine [file dirname $NomDeFichier]    
    return $NomDeFichier


}

proc ButineEtAjoute {Texte} {

    set NouveauTexte [ContenuDuFichier [ButineArborescence All]]
    if { $NouveauTexte != "" } {
	$Texte insert end $NouveauTexte
    }

}

proc ButineEtRemplace {Texte} {

    set NouveauTexte [ContenuDuFichier [ButineArborescence All]]
    if { $NouveauTexte != "" } {
	$Texte delete 0.0 end
	$Texte insert end $NouveauTexte
    }

}

proc CADO4MI {{args ""}} {


    Wup "Debut du design, mode ligne de commande ou interface graphique"
    Wup "Charger les variables et renseigne sur les "
    
    if {$args == ""} {
	CADO4MI_Panel
	return ""
    } elseif {$args == "-check" | $args == "-help"} {
	LogoCADO4MI
	AjouteAuLog "CADO4MI usage is query, database, length, range, nboligo and optional parameters"
	AjouteAuLog [format "%-20s  %-12s" " -q  (Query)" "Your query sequence in fasta format."] 
	AjouteAuLog [format "%-20s  %-12s" " -l  (Length)" "Length of oligonucleotide."]
	AjouteAuLog [format "%-20s  %-12s" " -ar (Area)" "List of begin-end points for restricted designing area(s)."]
	AjouteAuLog [format "%-20s  %-12s" "" "ex: 1 300 500 800 will design only between the two ranges."]
	AjouteAuLog [format "%-20s  %-12s" " -nb (nboligo)" "Number of oligonucleotide to keep at the end of process."]
	AjouteAuLog [format "%-20s  %-12s" " -t  (Tm)" "Tm threshold."]  
	AjouteAuLog [format "%-20s  %-12s" " -r  (TmRange)" "Tm range."]
	AjouteAuLog [format "%-20s  %-12s" " -b  (Database)" "Database in which specificity will be tested."]
	AjouteAuLog [format "%-20s  %-12s" " -st (Step)" "Step between each attempt to analyse an oligo."]
	AjouteAuLog [format "%-20s  %-12s" " -sp (Specificity)" "Specificity threshold to keep X-Hybridisation."]
	AjouteAuLog [format "%-20s  %-12s" "" "Please enter value as 70.0% (default value)"] 
	AjouteAuLog [format "%-20s  %-12s" " -nc (Contiguous)" "Specificity threshold for max contiguous bases allowed."]
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 15 contiguous bases rejected."] 
	AjouteAuLog [format "%-20s  %-12s" " -m  (TmMethod)" "Method for Tm calculation."]
	AjouteAuLog [format "%-20s  %-12s" " -gl (GCLower)" "The minimum %GC accepted."]
	AjouteAuLog [format "%-20s  %-12s" " -gu (GCUpper)" "The maximum %GC accepted."]
	AjouteAuLog [format "%-20s  %-12s" "" "Please enter values as 35.0%"] 
	AjouteAuLog [format "%-20s  %-12s" "" "Default is NearestNeighbor."] 
	AjouteAuLog [format "%-20s  %-12s" "" "Taille < 20 nt"]
	AjouteAuLog [format "%-20s  %-12s" "" "    Wallace Tm= 4*(G+C)+2*(A+T)]"]
	AjouteAuLog [format "%-20s  %-12s" "" "Taille >20 nt"]
	AjouteAuLog [format "%-20s  %-12s" "" "    NearestNeighbor Tm=1e3DH/DS+Rln(ADN/4)-273.15)"]
	AjouteAuLog [format "%-20s  %-12s" "" "    ADNADN Tm=81.5+16.6log M+0.410(%GC)-500/L-0.62F"]
	AjouteAuLog [format "%-20s  %-12s" "" "    ADNARN Tm=79.8+18.5log M+0.584(%GC)-820/L-0.35F+11.8(%GC)^2"]
	AjouteAuLog [format "%-20s  %-12s" "" "    ARNARN Tm=79.8+18.5log M+0.584(%GC)-820/L-0.50F+11.8(%GC)^2"]
	AjouteAuLog [format "%-20s  %-12s" " -p  (Prohib)" "Prohibited Sequence, must be a list of sequence"]
	AjouteAuLog [format "%-20s  %-12s" " -w  (WorkingDir)" "Choose the directory where to save your files"]
	AjouteAuLog [format "%-20s  %-12s" " -ev (BlastExpect)" "The Blast E-value limit."]
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 100."] 
	AjouteAuLog [format "%-20s  %-12s" " -bw (BlastWord)" "The word length for Blast searches."]
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 15 nt."] 
	AjouteAuLog [format "%-20s  %-12s" " -ba (BlastNbAligned)" "The Blast sequence limit to align."]
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 2000."] 
	AjouteAuLog [format "%-20s  %-12s" " -bs (BlastStrand)" "The Blast option to search on forward (1), reverse (2) or both (3) strands."]
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 1."] 
	AjouteAuLog [format "%-20s  %-12s" " -qc (QueryCheck)" "Your query is checked in database with % Id and %Cover."] 
	AjouteAuLog [format "%-20s  %-12s" "" "Default is 1 (for yes)."] 
	AjouteAuLog "\nYou need to define Length, Tm, Tm range, Database, number of oligo and your working directory."
	AjouteAuLog "The sequence are stored in many different files according to the name of your sequence:"
	AjouteAuLog "\tex:\tACT0001.masked    for the masked sequence (basically for poly A over 15 nts)"
	AjouteAuLog "\t\tACT0001.blastn    for the homology search result with BlastN program"
	AjouteAuLog "\t\tACT0001.log       for the log of all the steps during BlastN analysis"   
	AjouteAuLog "\t\tACT0001.oligo     for the results obtained in multiple fasta file format"
	AjouteAuLog "\t\t                  rejected sequence has <> label"
	AjouteAuLog "\t\tACT0001.selection for the best oligo available"
	AjouteAuLog "\t\tACT0001.croisee   for the best oligo available between two design."

	exit
	return ""
    } else {
	LogoCADO4MI
	foreach {Option Valeur} $args {
	    #AjouteAuLog "O $Option V $Valeur"
	    switch -regexp -- $Option {
		"-q$"  {LesParametresDuDesign Query          $Valeur "Positionne"}
		"-l$"  {LesParametresDuDesign LengthOligo    $Valeur "Positionne"}
		"-ar$" {
		    set NbZones  [llength $Valeur]
		    if {[expr $NbZones%2]} {
			AjouteAuLog "! Warning ! for option -ar you need pairs of begin-end points"
			return ""
		    } else {
			foreach {b e} $Valeur {
			    LesParametresDuDesign LesZones [list $b $e] "Ajoute"
			}
		    }
		}
		"-nb$" {LesParametresDuDesign NbOligo        $Valeur "Positionne"}
		"-t$"  {LesParametresDuDesign TmLimit        $Valeur "Positionne"}
		"-r$"  {LesParametresDuDesign TmRange        $Valeur "Positionne"}
		"-gl$" {LesParametresDuDesign GCContentMinus $Valeur "Positionne"}
		"-gu$" {LesParametresDuDesign GCContentPlus  $Valeur "Positionne"}
		"-b$"  {LesParametresDuDesign DataBase       $Valeur "Positionne"}
		"-st$" {LesParametresDuDesign Step           $Valeur "Positionne"}
		"-sp$" {LesParametresDuDesign IdLimit        $Valeur "Positionne"}
		"-nc$" {LesParametresDuDesign NbContiguous   $Valeur "Positionne"}
		"-m$"  {LesParametresDuDesign TmMethod       $Valeur "Positionne"}
		"-p$"  {LesParametresDuDesign LesProhibes    $Valeur "Positionne"}
		"-w$"  {LesParametresDuDesign WorkingDir     $Valeur "Positionne"}
		"-ev$" {LesParametresDuDesign BlastExpect    $Valeur "Positionne"}
		"-bw$" {LesParametresDuDesign BlastWord      $Valeur "Positionne"}
		"-ba$" {LesParametresDuDesign BlastNbAligned $Valeur "Positionne"}
		"-bs$" {LesParametresDuDesign BlastStrand    $Valeur "Positionne"}
		"-qc$" {LesParametresDuDesign QueryCheck     $Valeur "Positionne"}
	    }
	}
    }
    LesParametresParDefaut
    if {[BonNombreDeParametres "AvecVerif"]} {
	MontreLesParametresDuDesign

	OligoLauncher 
    } else {
	AjouteAuLog "Missing parameters."
	CADO4MI "-check"
	return ""
    }
    
    #On detruit toutes les infos
    #AskBLAST aussi ??
    #AskBlast unset
    LesParametresDuDesign UnsetAll

    return ""

}

proc CADO4MI_Panel {{w ""}} {

    
    Wup "Interface graphique de CADO4MI 1.0"
    Wup "Permet de lancer un design avec des criteres restrictifs"
    Wup "Permet de visualiser les resultats du design"
    Wup "Permet de visualiser certains des criteres de choix"

    Wup "Ajout de l interface vers IllustreOligo"
    Wup "Ajout des bulles infos, restriction pour les entrees"
    Wup "Ajout File management (delete files et save to excel file)"
    Wup "Ajout advanced parameters (step and blastn parameters, Batch mode)"
    Wup "Ajout Best GC et Tm calculation"

    #On gere la premiere fenetre en . si il y deja autre chose d utiliser dans .
    #ATTENTION on doit modifier . en "" pour pouvoir conserver la hierarchie des fenetres
    if {[winfo children .] != ""} {
	set       w ".startCADO4MI"
	if {[winfo exists $w]} {return ""}
	toplevel $w
    } else {
	set w "."
	#$w config -bd 3 -relief flat
    }
    wm geometry  $w +300+100
    wm title     $w "Microarray: Oligonucleotide Design"
    wm resizable $w false false
    #wm resizable $w true true
    wm protocol  $w WM_DELETE_WINDOW "exit"
    if {$w == "."} {set w ""}

    #0 Le titre
    set    FTitre "$w.ftitre"
    set    LTitre "$FTitre.ltitre"
    frame $FTitre -borderwidth "3" -relief "groove"
    set Titre "CADO4MI 1.0"
    label $LTitre -borderwidth "2" -relief "ridge"  -background "orange" -text "$Titre" -width "45" -pady "3"
    
    bind  $LTitre  "$LTitre configure -relief sunken -background red    -text \"----------- EXIT -----------\""
    bind  $LTitre  "$LTitre configure -relief ridge  -background orange -text \"CADO4MI 1.0\""
    if {$w == ""} {set w "."}
    bind  $LTitre <1>     "eval \[wm protocol $w WM_DELETE_WINDOW\]"

    if {$w == "."} {set w ""}
    #Les 2 frames majeures
    #1 Predesigned IllustreOligo Panel
    #2 Design      Tous les parametres du design
    set    FPreDesigned "$w.fpredesigned"
    set    FDesign      "$w.fdesign"
    frame $FPreDesigned -borderwidth "3" -relief "groove"
    frame $FDesign      -borderwidth "3" -relief "groove"

    #1.1 IllustreOligo panel
    global E1Illustre2
    global E2Illustre2
    set FIllustre1   "$FPreDesigned.fillustre1"
    set  LIllustre1  "$FIllustre1.lillustre1"
    set  BIllustre1  "$FIllustre1.billustre1"
    set FIllustre2   "$FPreDesigned.illustre2"
    set  L1Illustre2 "$FIllustre2.l1illustre2"
    set  E1Illustre2 "$FIllustre2.e1illustre2"
    set  B1Illustre2 "$FIllustre2.b1illustre2"
    set  B2Illustre2 "$FIllustre2.b2illustre2"
    set  L2Illustre2 "$FIllustre2.l2illustre2"
    set  E2Illustre2 "$FIllustre2.e2illustre2"
    set  B3Illustre2 "$FIllustre2.b3illustre2"
    set  B4Illustre2 "$FIllustre2.b4illustre2"

    frame  $FIllustre1  -borderwidth "2"          -relief "ridge" 
    label  $LIllustre1  -background  "#808FFF"    -relief "groove" -text "Show Designed Oligo Menu"
    button $BIllustre1  -background  "OliveDrab1" -relief "ridge"  -text "Show / Hide" -padx "2" -command "HideGridedFrame $FIllustre2"
    frame  $FIllustre2  -background "#808080"     -relief "groove" -borderwidth "0"
    label  $L1Illustre2 -background "#808FFF"     -relief "groove" -text "Acc:"   -width "10" -anchor "w"
    entry  $E1Illustre2 -textvariable PAB		      
    button $B2Illustre2 -background "yellow"      -padx "2"        -text "Browse" -command {
	set BrowsedPAB [tk_getOpenFile -multiple "y" -title "Choose 1 or more sequence(s)." -initialdir "[RepertoireDuGenome]"]
	$E1Illustre2 delete 0 end
	$E1Illustre2 insert   end $BrowsedPAB
    }
    button $B1Illustre2 -background "yellow"      -padx "2"        -text "OK"     -command {
	if {$PAB!=""} {
	    if {$ProbesDir==""} {
		if {[regexp {\\} $PAB] || [regexp {/} $PAB]} {
		    set LesDirs [file dirname $PAB]
		} else {
				    set RepOligo "[RepertoireDuGenome]/Probes"   
		    if {[file exists $RepOligo]} {
			set LesDirs ""
			set LaListe ""
			foreach File [glob -nocomplain -directory $RepOligo -types d "*"] {
			    lappend LaListe [file tail $File]
			}
			set  LaListe [EntreDeux [lsort $LaListe]]
			if {$LaListe==""} {AjouteAuLog "No Directories found";return ""}
			foreach Dir $LaListe {
			    lappend LesDirs "$RepOligo/$Dir"
			}
		    } else {AjouteAuLog "No Directories specified";return ""}
		}
	    } else {
		set LesDirs $ProbesDir
	    } 

	    foreach Seq $PAB {
		#IllustreOligo $Seq $ProbesDir
		IllustreOligo $Seq $LesDirs
	    }
	} else {
	    set Warning "Acc must be a regular GScope DataBase Name with previously designed oligo(s)."
	    AjouteAuLog $Warning
	}
    }
    label  $L2Illustre2 -background "#808FFF"     -relief "groove" -text "Directory:" -width "10" -anchor "w"
    entry  $E2Illustre2 -textvariable ProbesDir
    button $B4Illustre2 -background "yellow"      -padx   "2"      -text "Browse" -command {
	set BrowsedDir [tk_chooseDirectory -title "Choose one directory." -initialdir "[RepertoireDuGenome]"]
	$E2Illustre2 delete 0 end
	$E2Illustre2 insert   end $BrowsedDir
    }
    button $B3Illustre2 -background "yellow"      -padx   "2"      -text "OK"     -command {
	if {$ProbesDir!=""} {
	    set ExistingDir 1
	    foreach Dir $ProbesDir {
		if {![file exists $Dir]} {
		    set ExistingDir 0
		    set Warning "Directory must be a regular directory containing previously designed oligo(s)."
		    AjouteAuLog $Warning
		} 
	    }
	    if {$ExistingDir} {
		if {$PAB!=""} {
		    foreach Seq $PAB {
			IllustreOligo $Seq $ProbesDir
		    }
		} else {
		    set LesDirs ""
		    set LaListe ""
		    set RepOligo [lindex $ProbesDir 0]
		    foreach File [glob -nocomplain -directory $RepOligo "*.masked"] {
			regsub {.masked$} $File "" File
			lappend LaListe [file tail $File]
		    }
		    set  LaListe [EntreDeux [lsort $LaListe]]
		    if {$LaListe==""} {AjouteAuLog "No sequence selected.";return ""}
		    foreach Acc $LaListe {
			lappend PAB "$RepOligo/${Acc}.masked"
		    }
		    foreach Seq $PAB {
			IllustreOligo $Seq $ProbesDir
		    }
		    #set Warning "Acc must be choosen."
		    #AjouteAuLog $Warning
		}
	    }
	} else {
	    set Warning "Directory should contain oligo, it is an option."
	    AjouteAuLog $Warning
	}
    }
    set_balloon $LIllustre1  "Where you can display the design of Oligonucleotides"
    set_balloon $L1Illustre2 "Accession or file name for query with designed oligos"
    set_balloon $L2Illustre2 "Directory containing your design"

    #Les 2 frames des parametres
    #2.1 Menu du design
    #2.2 Frame de tous les parametres
    set     FParamMenu         "$FDesign.fparammenu"
    set     LParamMenu         "$FParamMenu.lparammenu"
    set     BParamMenu         "$FParamMenu.bparammenu"
    set     FTousLesParameters "$FDesign.fparameters"
    frame  $FParamMenu -borderwidth "2"          -relief "ridge"  
    label  $LParamMenu -background  "#808FFF"    -relief "groove" -text "Oligo Design Menu"
    button $BParamMenu -background  "OliveDrab1" -relief "ridge"  -text "Show / Hide" -padx "2" -command "HideGridedFrame $FTousLesParameters"
    frame  $FTousLesParameters -borderwidth "0"  -relief "groove" 
    set_balloon $LParamMenu "Where you can do the design of Oligonucleotides"

    #Les petites frames, parametres, Tm methode, menu, log
    #2.2.1 Frame des parametres query, edge, GC ...
    #2.2.2 Frame de la methode de Tm
    #2.2.3 Frame Advanced Parameters step, specificity et BLAST
    #2.2.4 Frame des boutons File, Reset, Run ...
    #2.2.5 Frame du Log
    set    FParameters1 "$FTousLesParameters.fparameters1"
    set    FParameters2 "$FTousLesParameters.fparameters2"
    set    FParameters3 "$FTousLesParameters.fparameters3"
    set    FMenuOut     "$FTousLesParameters.fmenuout"
    set    FVisible     "$FTousLesParameters.fvisible"
    frame $FParameters1 -borderwidth "0" -relief "groove"
    frame $FParameters2 -borderwidth "0" -relief "groove"
    frame $FParameters3 -borderwidth "0" -relief "groove"
    frame $FMenuOut     -borderwidth "3" -relief "ridge"
    frame $FVisible     -borderwidth "0" -relief "groove"

    #2.2.1.1 Query panel
    global EQuery
    set FQuery   "$FParameters1.fquery"
    set  LQuery  "$FQuery.lquery"
    set  EQuery  "$FQuery.equery"
    set  BQuery  "$FQuery.bquery"
    set  B2Query "$FQuery.b2query"
    set  B3Query "$FQuery.b3query"

    frame  $FQuery  -background "#808080" -relief "groove"
    label  $LQuery  -background "#808FFF" -relief "groove" -text "Query" -width "10" -anchor "w"
    entry  $EQuery  -textvariable QueryVar
    button $B3Query -background  "orange" -relief "groove" -text "Info"  -padx   "3" -borderwidth "2" -command {
	if {[LesParametresDuDesign Query "LaValeurMerci"]!=""} {
	    set LesQuerys [LesParametresDuDesign Query "LaValeurMerci"]
	    foreach Qy $LesQuerys {
		AfficheLesInfosDeMaSequence $Qy
	    }
	} else {
	    AjouteAuLog "Query must exist and also being validated"
	}
    }
    button $B2Query -background "yellow"  -padx "2"        -text "Browse" -command {
	set BrowsedQuery [tk_getOpenFile -multiple "y" -title "Choose one sequence file." -initialdir "[RepertoireDuGenome]"]
	$EQuery delete 0 end
	$EQuery insert   end $BrowsedQuery
    }
    button $BQuery  -background "yellow"  -padx "2"        -text "OK"     -command {
	if {$QueryVar!=""} {
	    if {$QueryVar=="LaTotale"}           {set QueryVar [ListeDesPABs]}
	    if {$QueryVar=="ListeTest"}          {set QueryVar [ListeTest]}
	    if {$QueryVar=="ListeControle"}      {set QueryVar [ListeControles]}
	    if {$QueryVar=="ListeDesNews"}       {set QueryVar [ListeDesNews]}
	    if {$QueryVar=="ListeDesRhos"}       {set QueryVar [ListeDesRhos]}
	    if {$QueryVar=="RepertoireDuGenome"} {set QueryVar [RepertoireDuGenome]}
	
	    if {[llength $QueryVar]=="1"} {
		#On a un seul fichier
		#Test si on un single ou multiple fasta file
		set  NbTFA  "0"
		set  NbTFA  [EstCeUnTFAOuUnTFAS $QueryVar]
		if {$NbTFA=="0"} {
		    AjouteAuLog "Query: $QueryVar is not a sequence in fasta format."
		} elseif {$NbTFA=="1"} {
		    LesParametresDuDesign Query $QueryVar "Positionne"
		} else {
		    set  Return [CheckTFAFile $QueryVar]
		    if {$Return != ""} {
			#On a un multi fasta
			LesParametresDuDesign Query           "Reset"
			LesParametresDuDesign Query "$Return" "Positionne"
			set QueryVar [LesParametresDuDesign Query "LaValeurMerci"]
		    }
		}
	    } else {
		#On a plusieurs fichiers
		set LesMauvais ""
		foreach Q $QueryVar {
		    set  NbTFA  "0"
		    set  NbTFA  [EstCeUnTFAOuUnTFAS $Q]
		    if {$NbTFA=="0"} {
			lappend LesMauvais $Q
		    }
		}
		if {$LesMauvais != ""} {
		    AjouteAuLog "Query: Be careful $LesMauvais seems not to be in single fasta format."
		}
		LesParametresDuDesign Query $QueryVar "Positionne"
	    }
	    AjouteAuLog "Query: $QueryVar"
	} else {
	    LesParametresDuDesign Query "Reset"
	    set Warning "Query must be a regular sequence file."
	    AjouteAuLog $Warning
	}
    }
    set_balloon $LQuery  "One or more single fasta sequence file"
    set_balloon $B3Query "Display sequence analysis (Tm and GC profile)\nand allows direct selection of designing areas"

    #2.2.1.2 Edge panel
    set FEdge   "$FParameters1.fedge"
    set  LEdge  "$FEdge.ledge"
    set  L2Edge "$FEdge.l2edge"
    set  L3Edge "$FEdge.l3edge"
    set  EEdge  "$FEdge.eedge"
    set  E2Edge "$FEdge.e2edge"
    set  BEdge  "$FEdge.bedge"
    set  B2Edge "$FEdge.b2edge"
    set  B3Edge "$FEdge.b3edge"

    frame  $FEdge  -background "#808080"             -relief "groove"
    label  $LEdge  -background "#808FFF" -width "10" -relief "groove" -text "Begin" -anchor "w"
    label  $L2Edge -background "#808FFF" -width  "5" -relief "groove" -text "End"   -anchor "center"
    label  $L3Edge -background "#808FFF"             -relief "groove" -text ""      -anchor "w"
    entry  $EEdge  -justify    "center"  -width  "5" -textvariable EdgeBegin
    entry  $E2Edge -justify    "center"  -width  "5" -textvariable EdgeEnd 
    button $B2Edge -background "yellow"  -padx   "2"                  -text "Add"   -command {
	if {$EdgeBegin!="" && $EdgeEnd!=""} {
	    if {$EdgeBegin=="" || $EdgeBegin<="0"} {set EdgeBegin 1}
	    if {$EdgeEnd  =="" || $EdgeEnd  <="0"} {set EdgeEnd 1000000}

	    set LesZonesExistantes [join [LesParametresDuDesign LesZones "LaValeurMerci"] " "]
	    LesParametresDuDesign LesZones [list $EdgeBegin $EdgeEnd] "Ajoute"
	    AjouteAuLog "New designing area $EdgeBegin $EdgeEnd added to previous: $LesZonesExistantes"
	} else {
	    set Warning "Begin and End of design are options."
	    AjouteAuLog $Warning
	}
    }
    button $B3Edge -background "yellow"  -padx "2"                    -text "Reset" -command {
	LesParametresDuDesign LesZones "Reset"
	set Warning "Own specific designing areas reset to null."
	AjouteAuLog $Warning
    }
    button $BEdge  -background "yellow"  -padx "2"                    -text "OK"    -command {
	if {$EdgeBegin!="" && $EdgeEnd!=""} {
	    if {$EdgeBegin=="" || $EdgeBegin<="0"} {set EdgeBegin 1}
	    if {$EdgeEnd  =="" || $EdgeEnd  <="0"} {set EdgeEnd 1000000}

	    if {$EdgeBegin>$EdgeEnd || $EdgeBegin==$EdgeEnd} { 
		set Warning "Please enter a regular value for Begin and End:\n\t0Begin"
		AjouteAuLog $Warning
		set EdgeEnd   ""
		set EdgeBegin ""
	    } else {
		LesParametresDuDesign LesZones                            "Reset"
		LesParametresDuDesign LesZones [list $EdgeBegin $EdgeEnd] "Ajoute"
		AjouteAuLog "Design from $EdgeBegin to $EdgeEnd"
	    }
	} else {
	    set Warning "Begin and End of design are options."
	    AjouteAuLog $Warning
	}
    } 
    set_balloon $LEdge  "Starting Point of a restricted design area\nWill be used if no specific area for query is set."
    set_balloon $L2Edge "Ending Point of a restricted the design area\nWill be used if no specific area for query is set."

    #2.2.1.3 Taille panel
    set FTaille   "$FParameters1.ftaille"
    set  LTaille  "$FTaille.ltaille"
    set  L2Taille "$FTaille.l2taille"
    set  ETaille  "$FTaille.etaille"
    set  BTaille  "$FTaille.btaille"

    frame  $FTaille  -background "#808080"  -relief "groove"
    label  $LTaille  -background "#808FFF"  -relief "groove" -text "Length" -width "10" -anchor "w"
    label  $L2Taille -background "#808FFF"  -relief "groove" -text "nucleotide(s)"      -anchor "w"
    entry  $ETaille  -justify    "center"   -width  "5"      -textvariable LengthVar
    button $BTaille  -background "yellow"   -padx "2"        -text   "OK"   -command {
	if {$LengthVar!=""} {
	    if {$LengthVar>100 | $LengthVar<=0} {
		set Warning "Please enter a regular value for Length\nLength: 01000000 | $NbOligoVar<=0} {
		set Warning "Please enter a regular value for the Number of Oligo to design \nNbOligo: 0120 | $TmVar<=0 | $TmRange>=$TmVar | $TmRange<0} {
		set Warning "Please enter a regular value for Tm and Range\nTm: 0.0100 | $GCContentMinusVar<0 | $GCContentPlusVar>100 | $GCContentPlusVar<0 | $GCContentMinusVar>$GCContentPlusVar} {
		set Warning "Please enter a regular value for the GC Content:\n0<\%GC<=100\nFirst "HideGridedFrame $FAdvanced2"
    frame $FAdvanced2 -background "#808080" -relief "groove" -borderwidth "0"
    set_balloon $LAdvanced1 "Parameters for advanced users (Blast,Specificity threshold ...)"

    #2.2.3.2 Query Validation
    set  FCheckQuery    "$FAdvanced2.fcheckquery"
    set   L1CheckQuery  "$FCheckQuery.lcquery1"
    set   L2CheckQuery  "$FCheckQuery.lcquery2"
    set   RB1CheckQuery "$FCheckQuery.rbcquery1"
    set   RB2CheckQuery "$FCheckQuery.rbcquery2"

    frame  $FCheckQuery  -background "#808080" -relief "groove"
    label  $L1CheckQuery -background "#808FFF" -relief "groove" -width "10" -text    "Query"               -anchor "w"
    label  $L2CheckQuery -background "#808FFF" -relief "groove" -width  "3" -text    "Database Validation" -anchor "center"
    radiobutton $RB1CheckQuery -relief "groove" -anchor "w" -variable CheckQueryVar -text "Yes" -value "1" -command {
	LesParametresDuDesign QueryCheck $CheckQueryVar "Positionne"	     
	AjouteAuLog "Query: database validation"				     
    }									     
    radiobutton $RB2CheckQuery -relief "groove" -anchor "w" -variable CheckQueryVar -text "No"  -value "0" -command {
	LesParametresDuDesign QueryCheck $CheckQueryVar "Positionne"		     
	AjouteAuLog "Query: no database validation"				     
    }									     
    set_balloon $L1CheckQuery  "Additional query parameters"
    set_balloon $L2CheckQuery  "Perform or not sequence validation with % ID and % cover of your query in database."
    set_balloon $RB1CheckQuery "Yes for query validation in database."
    set_balloon $RB2CheckQuery "No for no query validation in database."

    #2.2.3.2 Step panel
    set FStep   "$FAdvanced2.fstep"
    set  LStep  "$FStep.lstep"
    set  L2Step "$FStep.l2step"
    set  EStep  "$FStep.estep"
    set  BStep  "$FStep.bstep"

    frame  $FStep  -background "#808080" -relief "groove"
    label  $LStep  -background "#808FFF" -relief "groove" -text "Step"  -width "10" -anchor "w"
    label  $L2Step -background "#808FFF" -relief "groove" -text "nt(s)"             -anchor "w"
    entry  $EStep  -justify    "center"  -width  "5"      -textvariable StepVar
    button $BStep  -background "yellow"  -padx   "2"      -text "OK"    -command {
	if {$StepVar!=""} {
	    if {$StepVar<=0} {
		set Warning "Please enter a regular value for the Number of Oligo to design \nStep: 0100 | $SpecificityVar<=0 | $NbContiguous<0} {
		set Warning "Please enter a regular value for Specificity and MaxContiguous\nSpecificity: 0" $l]
	set i2 [string first "<" $l $i1+1]
	set v [string trim [string range $l $i1+1 $i2-1]]
	set v [string map [list "." ""] $v]
	switch -regexp $l {
	    {\"Genus\"} {
		set genus $v
	    }
	    {\"Species\"} {
		if {[regexp {^sp} $v]} {
		    set v [lindex [split $v " "] 0]
		}
		set species $v
	    }
	}
    }
	
    return [list $genus $species]

}

proc CF_GetInfo {l} {

    set Ll [split $l \n]
    set taxid ""
    set title ""
    foreach l $Ll {
	if {! [regexp {Item Name} $l]} {
	    continue
	}
	set i1 [string first ">" $l]
	set i2 [string first "<" $l $i1+1]
	set v [string range $l $i1+1 $i2-1]
	switch -regexp $l {
	    {\"Title\"} {
		set title $v
	    }
	    {\"TaxId\"} {
		set taxid $v
	    }
	}
    }

    return [list $taxid $title]

}

proc CF_GetLifeD {l} {

    set l [string map [list "<" " " ">" " "] $l]
    set Ll [split $l \n]
    set lifed undefined
    foreach l $Ll {
	set Lv [split [string trim $l] " "]
	if {[lindex $Lv 0] eq "Lineage"} {
	    set lifed [string totitle [lindex $Lv 3]]
	    break
	}
    }
	
    return [string map [list ";" ""] $lifed]

}

proc CG {X} {

    set X [string toupper $X]
    foreach A {A T G C} {
	foreach B {A T G C} {
	    foreach C {A T G C} {
		set Codon "$A$B$C"
		set AA [AAduCodon $Codon]
		lappend T($AA) $Codon
		lappend L "$Codon $AA" 
	    }
	}
    }
    if {[info exists T($X) ]} { return $T($X) }
    return $L

}

proc CMC {{Qui ""} {Quoi ""}} {

    #rR Les Clades Multi Ciliés de Audrey
    global CMC

    regsub -all "_" $Qui " " Qui

    if {[regexp -nocase "Help" $Qui]} {
	lappend LeHelp "CMC stands for Clade Multi Cilia (from Audrey)"
	lappend LeHelp "CMC ListOf Clade"
	lappend LeHelp "CMC ListOf OX"
	lappend LeHelp "CMC ListOf OS"
	lappend LeHelp "CMC 9606 Clade"
	lappend LeHelp "CMC Homo_sapiens Clade     -> Sarcopterygii     (eh oui !!! on est comme ça !!) "
	lappend LeHelp "CMC 9606 Clade             -> Sarcopterygii"
	lappend LeHelp "CMC Sarcopterygii OX       -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
	lappend LeHelp "CMC Sarcopterygii OS       -> lists the organism names" 
	lappend LeHelp "CMC 9606 OX                -> 9606"
	lappend LeHelp "CMC 9606 OS                -> Homo sapiens"
	lappend LeHelp "CMC Homo_sapiens OX        -> 9606              (nb : with underscore _ you don't need quotes) "
	lappend LeHelp "CMC Homo_sapiens OS        -> Homo sapiens"
	lappend LeHelp "Attention some Organims can belong to several Clades"
	lappend LeHelp "CMC 12345 Clade   may return several hits"
	lappend LeHelp ""
	lappend LeHelp "      Raymond"
	return [join $LeHelp "\n"]
    }

    set FichierCsv "/home/defosset/Groupes_blome_Audrey.csv"
    set Fichier    "/genomics/link/OI/fiches/CladesMultiCilia.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $Fichier]} { file delete $Fichier }
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [CMC $Qui $Quoi]
    }

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

    set OnMemorise 0                               ; #rR Attention si on mémorise il faut faire redo quand il faut
    if { $OnMemorise && [file exists $Fichier]} {
	array set CMC [ContenuDuFichier $Fichier]
	set CMC(csv,file) $FichierCsv
	return [CMC $Qui $Quoi]
    }
    set CMC(ListOf,Clade) {}
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	set A ""
	set B ""
	lassign [split $Ligne ";"] A B
	set A [string trim $A]
	set B [string trim $B]
	if {[regexp -nocase {[A-Z]} $A]} {
	    set Clade $A
	    set CMC($Clade,OX) {}
	    set CMC($Clade,OS) {}
	    lappend CMC(ListOf,Clade) $Clade
	    continue
	}
	if {[regexp {^[0-9]+$} $A]} {
	    lappend CMC($Clade,OX) $A
	    lappend CMC($Clade,OS) $B
	    lappend CMC($A,Clade) $Clade
	    lappend CMC($B,Clade) $Clade
	    lappend CMC(ListOf,OX) $A
	    lappend CMC(ListOf,OS) $B
	    set CMC($A,OX) $A
	    set CMC($A,OS) $B
	    set CMC($B,OX) $A
	    set CMC($B,OS) $B
	    continue
	}
    }
    set CMC(ListOf,Clade) [lsort -unique $CMC(ListOf,Clade)]
    set CMC(ListOf,JoinedClade) [join $CMC(ListOf,Clade) " "]
    set CMC(ListOf,OX)     [lsort -unique $CMC(ListOf,OX)]
    set CMC(ListOf,OS)     [lsort -unique $CMC(ListOf,OS)]
    if {$OnMemorise} { Sauve [array get CMC] dans $Fichier }
    return [CMC $Qui $Quoi]

}

proc COMPARORTHO {aXX aW aMDeRot aVDeTrans} {

    upvar $aXX XX
    upvar $aW W
    upvar $aMDeRot MDeRot
    upvar $aVDeTrans VDeTrans

    # BUT : 
    # LE PROGRAMME ESSAIE DE SUPERPOSER UNE MOL. B A UNE MOL
    # A EM MINIMISANT CHI**2 = SOMME (W*(X'(B)-X(A))**2), OU LA SOMM
    # EST FAITE SUR LES 3 COORDONNEES DE TOUS LES ATOMES COMMUNS.
    # X'(B) EST LA TRANSFORMEE DE X(B) PAR LE DEPLACEMENT
    # A DETERMINER, ET W = PONDERATION.
    #
    # LA METHODE PEUT SERVIR A COMPARER UNE MOLECULE A SA SYMETRIQU
    # (SI UNE MOLECULE SEMBLE ADMETTRE UN ELEMENT DE SYMETRIE NON
    # CRISTALLOGRAPHIQUE, PAR EXEMPLE), AUTREMENT DIT LA MOLECULE B
    # PEUT ETRE IDENTIQUE A A. MAIS DANS CE CAS, LES VALEURS DE CHI**2
    # ET DU NOMBRE DE DEGRES DE LIBERTE DOIVENT ETRE MODIFIEES.
    #
    # LA METHODE EST DECRITE DANS : B. REES, THESE 1969, PP. 90-94.
    #
    #    ROGRAMME REPRIS EN DECEMBRE 1974 (BR)
    #
    #...Mis sous forme de sous-programme ,pour VAX 750, en juin 84
    # Presentation modifiee en janvier 87
    #...Modif. fevrier 89: impression de la matrice en coord. absolues,
    #...et de la translation associee.
    #...Calcul de coordonnees d'un point de l'axe
    # (projection du milieu des barycentres) dans POINTFIXE
    #...Modif. avril 94 : NA transmis en argument.
    #...Ponderation fixee dans le progr. d'appel (sauf cas
    # =0). Attention : W est dimensionne a NAT alors
    # que SIG2 etait dimensionne a (NAT,2).
    #  Cas IOUT=0
    #   Nouvel argument : error
    #   Corrections dans POINTFIXE
    #...Modif. sept. 96 : COMMON/ecarts/
    #...Modif. mars  99 : les ecarts individuels pour les 10000 premiers
    #   atomes sont mis dans COMMON/ecarts/
    #...
    #   ARGUMENTS :
    #
    #	A l'entree :
    #
    # IIN  : Numero logique pour les lectures (non utilise dans cette
    #	version)
    # ====> pas utilise en tcl
    #
    # IOUT : Numero logique du fichier output (0 pour ne rien imprimer)
    # ====> pas utilise en tcl
    #
    # NATC : Nombre d'atomes pour la comparaison
    # ====> pas utilise en tcl
    #
    # NA : Nombre max. d'atomes (dimension de XX, W, NOM)
    # ====> pas utilise en tcl
    #
    # (XX(K,IAT,IMOL)K=1,3,IAT=1,NATC,IMOL=1,2) : coord.
    # pour les deux molecules, les atomes a superposer se corres-
    # pondant deux a deux. A la sortie, XX(K,IAT,2) contient les
    # coord. de la molecule B superposee a A
    #
    # W(IAT) : ponderation 	(par defaut : W=1)
    #
    # IPRINT : Si non nul, la distance apres superposition sera
    #	imprimee atome par atome
    # ====> pas utilise en tcl
    #
    # NOM(IAT) : Nom des atomes (15 caracteres). Pas utilise si
    #	IPRINT=0.
    # ====> pas utilise en tcl
    #
    #	A la sortie :
    #
    #	XBAR(K,IMOL) : coord. des barycentres des deux
    #	molecules
    #
    #	ROT : matrice de la rotation B->A
    #
    #	ANGLE : Valeurs de Alpha,Beta,Gamma et de Kappa,Psi,Phi
    #	pour cette rotation
    #	Kappa :angle de la rotation; Psi,Phi : coord. spheriques;
    #	Alpha,Beta,Gamma : angles d'Euler (convention Crowther)
    #
    #	ERROR : = .false. normalement, .true. si la superposition
    #		n'a pas pu se faire
    #		En outre les coord. d'un point de l'axe de rotation
    #		et le deplacement parallele a l'axe sont transmis
    #		dans le common /HELICON/
    #......
    #
    #
    # AUTRES OPTIONS :
    #	 	   DEFINITION D'UN SYSTEME D'AXES MOLECULAIRE, PAR LA
    #     MATRICE DE TRANSFORMATION ( COORD. MOLECULAIRES EN FONCTION
    #     DES COORDONNEES ABSOLUES (CRISTAL) + CONSTANTE). LES LIGNES DE
    #     LA MATRICE , CHACUNE AVEC LA CONSTANTE CORRESPONDANTE, SONT
    #     DONNEES EN 3 CARTES EN 4 F9.6  (ITRANS=1)
    #
    #                  DONNEE DES BARYCENTRES (CAS DES MOLECULES
    #         CENTROSYMETRIQUES)  (IBAR=1)
    #
    #                  COMPARAISON DE A A L'ENANTIOMORPHE DE B (ISYM=1).
    #
    #		   jPRINT=1 : Impressions detaillees
    #......
    #

    set NATC [llength [array names W]]

    set ITRANS 0
    set ISYM 0
    set ANOM(1) " A  "
    set ANOM(2) " B  "

    set error 0

    set jPRINT 0

    foreach IMOL {1 2} {
	foreach K {1 2 3} {
	    foreach L {1 2 3} {
		set ORTHO($K,$L,$IMOL) 0.
	    }
	    set ORTHO($K,$K,$IMOL) 1.
	}
    }

    set SW 0.
    for {set i 1} {$i <= $NATC} {incr i} {
	set SW [expr {$SW+[set W($i)]}]
    }

    # Si pas de ponderation, prendre 1 par defaut
    if {$SW < 0.0001} {
	for {set i 1} {$i <= $NATC} {incr i} {
	    set W($i) 1.
	}
    }

    foreach K {1 2 3} {
	foreach L {1 2 3} {
	    set TRANS($K,$L,1) [set ORTHO($K,$L,1)]
	    set TRANS($K,$L,2) [set ORTHO($K,$L,2)]
	}
    }

    foreach I {1 2} {
	foreach K {1 2 3} {
	    set SX($K,$I) 0.
	}
    }

    for {set J 1} {$J <= $NATC} {incr J} {
	foreach I {1 2} {
	    foreach K {1 2 3} {
		set SX($K,$I) [expr {[set SX($K,$I)]+[set W($J)]*[set XX($K,$J,$I)]}]
	    }
	}
    }

    foreach I {1 2} {
	foreach K {1 2 3} {
	    set XBAR($K,$I) [expr {[set SX($K,$I)]/$SW}]
	}
    }

    puts "\n================================="
    puts "Nbr of superposed atoms = $NATC"
    puts ""
    puts "BARYCENTRES :"

    foreach ii {1 2} {
	puts "$ii [set ANOM($ii)] [format "%6.2f %6.2f %6.2f" [set XBAR(1,$ii)] [set XBAR(2,$ii)] [set XBAR(3,$ii)]]"
    }

    foreach K {1 2 3} {
	set SX($K,1) [expr {[set XBAR($K,1)]-[set XBAR($K,2)]}]
	set SX($K,2) [expr {0.5*([set XBAR($K,1)]+[set XBAR($K,2)])}]
    }

    puts ""
    puts "BA vector     : [format "%6.2f %6.2f %6.2f" [set SX(1,1)] [set SX(2,1)] [set SX(3,1)]]"
    puts "Middle of  AB : [format "%6.2f %6.2f %6.2f" [set SX(1,2)] [set SX(2,2)] [set SX(3,2)]]"

    # soustrait le barycentre

    foreach I {1 2} {
	for {set J 1} {$J <= $NATC} {incr J} {
	    foreach K {1 2 3} {
		set XX($K,$J,$I) [expr {[set XX($K,$J,$I)]-[set XBAR($K,$I)]}]
	    }
	}
    }

    # EXPRESSION DANS LE SYST.D'AXES D''INERTIE'

    foreach IM {1 2} {
	foreach I {1 2 3} {
	    foreach J {1 2 3} {
		set AINER($I,$J,$IM) 0.
	    }
	}

	foreach I {1 2 3} {
	    foreach J {1 2 3} {
		for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
		    set AINER($I,$J,$IM) [expr {[set AINER($I,$J,$IM)]-[set W($JAT)]*[set XX($I,$JAT,$IM)]*[set XX($J,$JAT,$IM)]}]
		}
	    }
	}

	foreach I {1 2 3} {
	    set AINER($I,$I,$IM) 0.
	}

	foreach I {1 2 3} {
	    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
		set AINER($I,$I,$IM) [expr { [set AINER($I,$I,$IM)] +  [set W($JAT)]*( [set XX(1,$JAT,$IM)]**2 + [set XX(2,$JAT,$IM)]**2 + [set XX(3,$JAT,$IM)]**2 - [set XX($I,$JAT,$IM)]**2)}]
	    }
	}

	foreach I {1 2 3} {
	    foreach J {1 2 3} {
		set AI($I,$J) 0.
	    }
	}

	foreach I {1 2 3} {
	    foreach J {1 2 3} {
		set AI($I,$J) [set AINER($I,$J,$IM)]
	    }
	}

	# Jacobi travaille avec matrices index 0.
	unset -nocomplain AT

	set mAI [M_T AI]
	unset AI
	T_M AI $mAI

	set mV [concat 2 3 3 {*}$mAI]

	mevsvd_br mV evals
	#	jacobi AI AT VV 3

	set mAT {}
	set mV [lrange $mV 3 end]
	for {set i 0} {$i < 3} {incr i} {
	    lappend mAT [lrange $mV [expr {3*$i}] [expr {3*($i+1)-1}]]
	}
	T_M AT $mAT 1

	set mAI [M_T AI]
	unset AI
	T_M AI $mAI 1

	set D [S_deterM [M_T AT]]

	if {$D < 0.} {
	    foreach I {1 2 3} {
		foreach J {1 2 3} {
		    set AT($J,$I) [expr {-1.*[set AT($J,$I)]}]
		}
	    }
	}

	foreach K {1 2 3} {
	    foreach L {1 2 3} {
		set ROT($L,$K) [set AT($K,$L)]
	    }
	}

	set MROT [M_T ROT]

	MULTMAT $MROT TRANS $IM

	for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
	    foreach K {1 2 3} {
		set XI($K,$JAT,$IM) 0.
		foreach J {1 2 3} {
		    if {$IM == 1} {set BT($J,$K) [set AT($J,$K)]}

		    set XI($K,$JAT,$IM) [expr { [set XI($K,$JAT,$IM)]+ [set AT($J,$K)]*[set XX($J,$JAT,$IM)]}]
		}
	    }
	}
    }

    set CHI2(1) 0.

    foreach IM {1 2} {
	for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
	    foreach J {1 2 3} {
		set XX($J,$JAT,$IM) [set XI($J,$JAT,$IM)]
	    }
	}
    }

    # ROTATIONS ET TESTS EN CHI**2

    foreach K {1 2 3} {
	foreach L {1 2 3} {
	    set ROT($K,$L) 0.
	}
    }

    foreach I {2 3 4 5} {

	# ON FERME A 350
	# ON PERMUTE LES AXES A CHAQUE ITERATION

	# on ferme a 340

	# Initialise JP !! AU PIF !!

	set JP 0

	foreach IPERM {1 2 3} {
	    foreach IM {1 2} {
		for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
		    foreach J {1 2 3} {
			incr JP
			if {$JP-3 > 0} {
			    set JP [expr {$JP-3}]
			}
			set XI($JP,$JAT,$IM) [set XX($J,$JAT,$IM)]
			set ROT($JP,$J) 1.
		    }
		}
	    }

	    foreach J {1 2 3} {
		foreach K {1 2 3} {
		    set B($J,$K) 0.
		    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
			set B($J,$K) [expr {[set B($J,$K)]+[set W($JAT)]*[set XI($J,$JAT,1)]*[set XI($K,$JAT,2)]}]
		    }
		}
	    }

	    foreach L {2 3} {
		if {[set B($L,$L)] < 0} {
		    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
			set XI($L,$JAT,2) [expr {-1.*[set XI($L,$JAT,2)]}]
			set XI(1,$JAT,2) [expr {-1.*[set XI(1,$JAT,2)]}]
		    }

		    foreach J {1 2 3} {
			set ROT(1,$J) [expr {-1.*[set ROT(1,$J)]}]
			set ROT($L,$J) [expr {-1.*[set ROT($L,$J)]}]
			set B($J,1) [expr {-1.*[set B($J,1)]}]
			set B($J,$L) [expr {-1.*[set B($J,$L)]}]
		    }
		}
	    }

	    set CHI2($I) 0.
	    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
		foreach J {1 2 3} {
		    set  CHI2($I) [expr {[set CHI2($I)]+[set W($JAT)]*pow(([set XI($J,$JAT,2)]-[set XI($J,$JAT,1)]),2)}]
		}

	    }

	    set CU 1.
	    set CV 1.
	    set CW 1.
	    set SU 0.
	    set SV 0.
	    set SW 0.

	    set DEN [expr {$CW*$B(1,1)+$CV*$SW*$B(1,2)-$SW*$B(2,1)+$CV*$CW*$B(2,2)-$SV*$B(3,2)}]
	    if {$DEN != 0.} {
		set U [expr {atan((-$CV*$SW*$B(1,1)+$CW*$B(1,2)-$CV*$CW*$B(2,1)-$SW*$B(2,2)+$SV*$B(3,1))/$DEN)}]
		set SU [expr {sin($U)}]
		set CU [expr {cos($U)}]
	    }

	    set DEN [expr {-$SU*$SW*$B(1,1)+$CU*$SW*$B(1,2)-$SU*$CW*$B(2,1)+$CU*$CW*$B(2,2)+$B(3,3)}]
	    if {$DEN != 0.} {
		set V [expr {atan(($SW*$B(1,3)+$CW*$B(2,3)+$SU*$B(3,1)-$CU*$B(3,2))/$DEN)}]
		set SV [expr {sin($V)}]
		set CV [expr {cos($V)}]
	    }

	    set DEN [expr {$CU*$B(1,1)+$SU*$B(1,2)-$SU*$CV*$B(2,1)+$CU*$CV*$B(2,2)+$SV*$B(2,3)}]
	    if {$DEN != 0.} {
		set WW [expr {atan((-$SU*$CV*$B(1,1)+$CU*$CV*$B(1,2)+$SV*$B(1,3)-$CU*$B(2,1)-$SU*$B(2,2))/$DEN)}]
		set SW [expr {sin($WW)}]
		set CW [expr {cos($WW)}]
	    }

	    set R(1,1) [expr {$CU*$CW-$SU*$CV*$SW}]
	    set R(1,2) [expr {$SU*$CW+$CU*$CV*$SW}]
	    set R(1,3) [expr {$SV*$SW}]
	    set R(2,1) [expr {-$CU*$SW-$SU*$CV*$CW}]
	    set R(2,2) [expr {-$SU*$SW+$CU*$CV*$CW}]
	    set R(2,3) [expr {$SV*$CW}]
	    set R(3,1) [expr {$SU*$SV}]
	    set R(3,2) [expr {-$CU*$SV}]
	    set R(3,3) $CV

	    # rempli le tableau XX avec coord de mol 1 inchangees et coords
	    # de mol 2 tournees par R

	    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
		foreach J {1 2 3} {
		    set XX($J,$JAT,2) 0.
		    foreach K {1 2 3} {
			set XX($J,$JAT,2) [expr {[set XX($J,$JAT,2)]+[set R($J,$K)]*[set XI($K,$JAT,2)]}]
		    }
		}

		foreach J {1 2 3} {
		    set XX($J,$JAT,1) [set XI($J,$JAT,1)]
		}
	    }

	    set MROT [M_T ROT]
	    set MR [M_T R]

	    MULTMAT $MROT TRANS 2
	    MULTMAT $MR TRANS 2

	    T_M R $MR 1
	    T_M ROT $MROT 1
	}

	if {abs([set CHI2($I)]-[set CHI2([expr {$I-1}])])-0.01*[set CHI2($I)] <= 0.} {
	    set CHI02 [set CHI2($I)]
	    break
	}
    }

    if {$I == 5 && abs([set CHI2($I)]-[set CHI2([expr {$I-1}])])-0.01*[set CHI2($I)] > 0.} {
	puts "No convergence of CHI**2"
	set error 0
	return
    }

    set NU [expr {3*$NATC-6}]

    set SW 0.
    set SWD2 0.
    set DMIN 1000000.
    set DMAX 0.

    for {set JAT 1} {$JAT <= $NATC} {incr JAT} {
	set D2 0.
	foreach J {1 2 3} {
	    set D2 [expr {$D2+pow(([set XX($J,$JAT,2)]-[set XX($J,$JAT,1)]),2)}]
	}

	set D [expr {sqrt($D2)}]
	set SWD2 [expr {$SWD2+$D2*[set W($JAT)]}]
	set SW [expr {$SW + [set W($JAT)]}]
	if {$D < $DMIN} {set DMIN $D}
	if {$D > $DMAX} {set DMAX $D}
	if {$JAT <= 10000} {set distance($JAT) $D}
    }

    set DRMS [expr {sqrt($SWD2/$SW)}]

    puts [format "CHI**2 = %8.3f for %3d degrees of freedom" $CHI02 $NU]
    puts [format "RMS    = %8.3f , Max Dev = %8.3f" $DRMS $DMAX]

    # for [set NOM($jatmax,1)] --> [set NOM($jatmax,2)]

    foreach K {1 2 3} {
	foreach L {1 2 3} {
	    set ROT($K,$L) [set TRANS($K,$L,1)]
	}
    }

    set MROT [M_T ROT]

    set mrot2 $MROT
    set MROT [M_invM $MROT]

    MULTMAT $MROT TRANS 2

    T_M ROT $MROT 1

    puts ""
    puts "TRANSFORMATION B->A :"
    puts "( axes cristallins pour chaque molecule ) :"
    puts "                xA = MATRICE * xB  +  T"
    puts ""
    puts "                  MATRIX                   T"

    foreach i {1 2 3} {
	set v {}
	foreach j {1 2 3} {
	    lappend v [set TRANS($i,$j,2)]
	}
	lappend Mat $v
	lappend x1 [set XBAR($i,2)]
    }

    set vxtrans [V_MV $Mat * $x1]

    foreach K {1 2 3} {
	set xtrans($K) [lindex $vxtrans [expr {$K-1}]]
	foreach L {1 2 3} {
	    set ROT($K,$L) [set TRANS($K,$L,2)]
	}
	set xtrans($K) [expr {[set XBAR($K,1)]-[set xtrans($K)]}]
	puts "[format "        %7.3f %7.3f %7.3f       %8.3f" [set ROT($K,1)] [set ROT($K,2)] [set ROT($K,3)] [set xtrans($K)]]"
    }

    array set MDeRot [array get ROT]
    array set VDeTrans [array get xtrans]

    set MROT [M_T ROT]

    set res [ANGLES ROT ANGLE AXE]
    if {$res == -1} {return [list -1 -1]}

    set crow [list $ANGLE(1) $ANGLE(2) $ANGLE(3)]
    set pola [list $ANGLE(4) $ANGLE(5) $ANGLE(6)]

    puts ""
    puts "Eulerian angles  (Crowther convention) :"
    puts "alpha, beta, gamma       = [Nice_V $crow %7.2f]"
    puts "Sphe. ang. kappa,psi,phi = [Nice_V $pola %7.2f]"
    puts "cosinus directeurs       = [Nice_V [V_T AXE] %7.2f]"
    puts ""

    # Projection sur l'axe de la ligne des barycentres

    set PROJ 0.
    set DIST 0.
    foreach K {1 2 3} {
	set DELTA [expr {[set XBAR($K,1)]-[set XBAR($K,2)]}]
	set DIST [expr {$DIST+$DELTA*$DELTA}]
	set PROJ [expr {$PROJ+[set AXE($K)]*$DELTA}]
    }

    set DIST [expr {sqrt($DIST)}]
    if {$DIST != 0.} {
	puts "barycentres distance BA        = [format %7.2f $DIST]"
	puts "BA projection on the axis      = [format %7.2f $PROJ]"

	#... Projection sur l'axe du milieu des barycentres AB

	set MROT  [M_T ROT]
	set vAXE  [V_T AXE]
	set vXBA1 [list $XBAR(1,1) $XBAR(2,1) $XBAR(3,1)]
	set vXBA2 [list $XBAR(1,2) $XBAR(2,2) $XBAR(3,2)]

	if {0} {
	    POINTFIXE $MROT $vAXE $vXBA1 $vXBA2 XAXE
	    puts " Projection of the BA middle point on the rotation axis = [Nice_V [V_T XAXE] %7.2f]"
	}
    }

    return [list $DRMS $DMAX]

}

proc CP {} {

    foreach F [glob "*/WithAny.parser"] {
	Espionne [CorrigeParser $F]
    }

}

proc CSA_AnyBal {f} {

    global LConsSA ResCSA LongueurTotale
    global NId NConsDansId TableScore LMethods
    global VariablesAuDepart NAli LongTot
    global NBench TResSeeAsId TResId BS

    # Construction du set de residu conserves
    set pdbid [file rootname [file tail $f]]
    set LConsSA [list]
    foreach e [set BS($pdbid)] {
	lassign $e x r nm
	#incr x
	lappend LConsSA $x
    }
    if {$LConsSA == {} } {return 0}
    puts "Nbr sites [llength $LConsSA]"

    set grp ""
    foreach tnom $LMethods {
	unset -nocomplain TableScore
	ScoreDe$tnom $grp
	
	set rep1 [VerificationAvantCalculs]
	if {! $rep1} {
	    puts "Une des methode foireuse !!"
	    puts "skip alignement\n"
	    set BontousTypes 0
	    
	    break
	}
	    
	set BonTousTypes 1
	set rep2 [CSA_CalculeROC $tnom $pdbid]
	if {! $rep2} {
	    puts "fail for method $tnom"
	    set BonTousTypes 0
	    break
	}
    }

    if {$BonTousTypes} {
	incr LongTot $LongueurTotale
	incr NAli
	incr NBench [llength $LConsSA]
    }
    parray ResCSA
    return

}

proc CSA_CalculeAUC {Lv} {

    set n [llength $Lv]
    set srf 0.
    for {set i 0} {$i < ($n-1)} {incr i} {
	lassign [lindex $Lv $i] ss0 sp0
	set sp0 [expr {1.0-$sp0}]
	lassign [lindex $Lv $i+1] ss1 sp1
	set sp1 [expr {1.0-$sp1}]
	set srf [expr {$srf + (($ss0+$ss1)/2.)*($sp1-$sp0)}]
    }

    return $srf

}

proc CSA_CalculeROC {meth f} {

    global ListeScore LConsSA ResCSA LongueurTotale

    # Creation histogramme
    set Nslices 10
    CreeListeScore "" ""
    NormalisationColonnes 1
    set ListeScore [lsort -real -index 1 $ListeScore]
    set nbv [expr {[llength $ListeScore]/$Nslices}]
    #set NVal [llength $ListeScore]
    set NVal $LongueurTotale
    set NBench [llength $LConsSA]

    # calcule sens/spec par tranche
    for {set i 0} {$i < $Nslices-1} {incr i} {
	set NConsDansId 0 
	set NId 0
	set b2 [expr {($i+1)*$nbv}]
	set H($i) [lrange $ListeScore $b2 end]

	set Nel [llength [set H($i)]]
	set NId $Nel
	foreach e [set H($i)] {
	    lassign $e r v
	    if {$r in $LConsSA} {
		incr NConsDansId
	    }
	}

	set sensId [expr {1.*$NConsDansId/$NBench}]
	set specId [expr {1.*($NVal - $NId - ($NBench - $NConsDansId))/(($NVal - $NId - ($NBench - $NConsDansId))+($NId - $NConsDansId))}]
	set SumSensSpecId [expr {($sensId + $specId) - 1.0}]
	lappend ResCSA($f,${meth},SsSp) [list $sensId $specId]
    }
    set ResCSA($f,${meth},AUC) [CSA_CalculeAUC [set ResCSA($f,$meth,SsSp)]]
    
    return 1

}

proc CSA_SiteDeId {id {chn ""}} {

    global Tsite

    if {$chn eq ""} {
	set Le [array names Tsite "${id},*"]
	foreach e $Le {
	    lassign [split $e ,] tmp ch tmp
	    lappend Lch $ch
	}
	set Lch [lsort -unique $Lch]
	set chn [lindex $Lch 0]
    }
    set Lres [list]
    foreach e [array names Tsite "${id},${chn},*"] {
	set Lres [concat $Lres [set Tsite($e)]]
    }

    return $Lres

}

proc CSA_Test {} {

    global FichierTFA Defauts NomSeqSel LMethods
    global NId NConsDansId TableScore NAli LongTot
    global VariablesAuDepart LongueurTotale ResCSA
    global TResSeeAsId NBench TResId BS SDG

    # Lit sites
    array set BS [ContenuDuFichier Sites_OK.dat]
    array set ResCSA {}

    # Methodes scoring
    set LMethods [list Norm Thompson Ranganatan VolPol Liu Liu2 RPCA Entrop1 Entrop2 EnpCube]

    set FichierTFA ""
    LesDefauts
    set NomSeqSel {}
    set HDir /home/moumou/ordali/typify/hali

    # Init Variables sens/spec
    set LongTot 0
    set NAli 0
    set NBench 0
    foreach type $LMethods {
	set TResSeeAsId($type) 0
	set TResId($type) 0
    }
    
    LesDefauts TypeAli TFA
    LesDefauts Mode "Batch"
    
    set VariablesAuDepart [info globals]
    
    set Lf [glob [file join $HDir *.tfa]]
    foreach f $Lf {
	set FichierTFA $f
	LesDefauts FichierTFA $FichierTFA
	puts "\n=> [file tail $f]"
	
	LoadingAlignement
	InitInfoSeqs
	LongueurDeLAlignement
	
	set NSqs [llength $SDG(GroupeToutLeMonde)]
	puts "NSeqs : $NSqs Lgt $LongueurTotale"
	if {$NSqs < 10} {
	    puts "Less than 10 Sequences !!"
	    FermeFichier
	    continue
	}
	
	CSA_AnyBal $f
	FermeFichier
    }
    
    # Calcul Specificite et Sensibilite
    puts "\n\n========================="
    puts "=    R E S U L T A T S  ="
    puts "========================="
    puts ""
    puts "Nombre alignements ..............: $NAli"
    puts "Longueur totale .................: $LongTot"
    puts "Nombre residus du benchmark .....: $NBench"
    puts ""

    foreach meth $LMethods {
	set SsT 0.0 ; set SpT 0.0
	set Le [array names ResCSA "*,${meth},SsSp"]
	if {[set n [llength $Le]] == 0} {
	    puts "no values for $meth"
	    continue
	}
	foreach e $Le {
	    lassign [lindex [set ResCSA($e)] end] ss sp
	    
	    set SsT [expr {$SsT + $ss}]
	    set SpT [expr {$SpT + $sp}]
	}
	set aucT 0.0
	foreach e [array names ResCSA "*,${meth},AUC"] {
	    set aucT [expr {$aucT + [set ResCSA($e)]}]
	}
	set SsT  [expr {$SsT/$n}]
	set SpT  [expr {$SpT/$n}]
	set aucT [expr {$aucT/$n}]
	puts "\n$meth"
	puts "--------"
	puts "  sensibilite  $SsT"
	puts "  specificiite $SpT"
	puts "  AUC finale   $aucT"
    }
    
    return

}

proc CSA_TraiteId {id} {

    global Tsite BS

    set Ll [LesLignesDuFichier toto]

    # retrieve chain
    set iNchain [lsearch -regexp $Ll {^NCHAIN}]
    if {$iNchain == -1} {
	puts "NCHAIN not found !"
	return 0
    }
    regsub -all { +} [lindex $Ll $iNchain] " " l
    set nch [lindex [split $l " "] 1]
    set iKchain [lsearch -regexp $Ll {^KCHAIN}]
    if {$iKchain == -1} {
	set chn [lindex [$id _chains] 0]
    } else {
	set chn [lindex [split [lindex $Ll $iKchain] " "] end]
	# on a parfois A,B ... donc on splitte
	set chn [lindex [split $chn ,] 0]
    }
    lassign [$id dbref $chn] db1 db2
    puts "cross refs   : $db1 $db2"

    set iProt [lsearch -regexp $Ll {^## PROTE}]
    set iAlig [lsearch -regexp $Ll {^## ALIGN}]
    set iProf [lsearch -regexp $Ll {^## SEQUE}]
    if {$iAlig == -1 || $iProf == -1} {
	return 0
    }
    
    # Recupere noms proteines
    set ToDel [list]
    foreach l [lrange $Ll $iProt+2 $iAlig-1] {
	regsub -all { +} [string trim $l] " " l
	set reste [lassign [split $l " "] no tmp acc eqp pid]
	if {! [string is double $eqp]} {
	    puts "  $acc = $eqp"
	    set Lkp($acc) $eqp
	    set pci $pid
	} else {
	    set pci $eqp
	}
	if {$pci > 0.95 && $acc ne $db1 && $acc ne $db2} {
	    lappend ToDel $acc
	}
	lappend Lnom $acc
	lappend Lseq ""
    }
    puts "nb sequences : [llength $Lnom]"
    puts "nb seq to del: [llength $ToDel]"
    if {([llength $Lnom] - [llength $ToDel]) < 5} {
	puts "==> REJECTED ! Not enough sequences"
	return 0
    }

    # site de id
    set Lnos [CSA_SiteDeId $id $chn]
    set BS($id) [list]

    # recupere alignement
    set firstTime 1
    set DoQuery 1
    set Qseq ""
    set Qno [list]
    foreach l [lrange $Ll $iAlig $iProf-1] {
	if {[regexp {^## ALIG} $l]} {
	    if {! $firstTime} {
		set DoQuery 0
	    }
	    regsub -all { +} $l " " l
	    lassign [split $l " "] tmp tmp d tmp f
	    incr d -1 ; incr f -1
	    set pos -1
	    continue
	}
	if {[regexp {^ SeqNo} $l]} {
	    continue
	}

	# traite seq query
	if {$DoQuery} {
	    set no [string trim [string range $l 6 10]]
	    if {$no ne ""} {
		append Qseq [string index $l 14]
		set Qchn [string index $l 12]
		lappend Qno $no
	    }
	    set firstTime 0
	}
	# position gen de ali
	incr pos
	# traite seq
	set ali [string range $l 51 end]
	set ali [string toupper $ali]
	set ali [string map [list " " .] $ali]
	set Lali [split $ali ""]

	set i $d
	set tmp $Lseq
	foreach seq [lrange $Lseq $d $f] aa $Lali {
	    append seq $aa
	    lset tmp $i $seq
	    incr i
	}
	set Lseq $tmp
    }
    puts "longueur ali : [string length [lindex $Lseq 0]]"

    # check aa sequence
    set err [catch {set Qdb [exec fastacmd -d pdb -s "PDB:${id}_$chn"]} Msg]
    if {$err} {
	puts "  => can't retrieve pdb seq !"
	set Qdb ""
    }  else {
	set Qdb [join [lrange [split $Qdb \n] 1 end] ""]
    }
    if {$Qdb eq $Qseq} {
	puts "seq identiques"
    }

    # check aa active site
    foreach e $Lnos {
	lassign $e rnom rnmr
	set i [lsearch $Qno $rnmr]
	if {$i != -1} {
	    if {[string index $Qseq $i] eq $rnom} {
		# bon site
		lappend BS($id) [list $i $rnmr $rnom]
	    }
	}
    }

    # check seq same length
    # remove seq with lg < ou > 2 sd
    set m 0 ; set m2 0
    set Llg [list]
    foreach s $Lseq {
	set s [string map [list " " "" "-" "" "." ""] $s]
	set l [string length $s]
	lappend Llg $l
	incr m $l
	incr m2 [expr {$l*$l}]
    }
    set n [llength $Lseq]
    set moy [expr {int(double($m)/$n)}]
    set sd [expr {int(sqrt(double($m2)/$n - $moy*$moy))}]
    set lmin [expr {int($moy-2.*$sd)}]
    set lmax [expr {int($moy+2.*$sd)}]
    puts [format "lg mean - sd : %d %d" $moy $sd]
    
    set i 0
    set LgToDel [list]
    foreach l $Llg {
	if {$l < $lmin || $l > $lmax} {
	    lappend LgToDel $i
	}
	incr i
    }
    set LgToDel [lsort -integer -decreasing $LgToDel]
    if {[llength $LgToDel] > 0} {
	puts "Bad length   : [llength $LgToDel]"
    }

    set lg [string length [lindex $Lseq 0]]
    foreach s [lrange $Lseq 1 end] {
	if {[set nl [string length $s]] != $lg} {
	    puts "! -> [lindex $Lnom $i] $nl"
	}
    }

    # delete seqs with pci >= 0.95
    set Lix $LgToDel
    foreach acc $ToDel {
	lappend Lix [lsearch $Lnom $acc]
    }
    set Lix [lsort -unique -integer -decreasing $Lix]
    foreach i $Lix {
	set Lnom [lreplace $Lnom $i $i]
	set Lseq [lreplace $Lseq $i $i]
    }

    # sites bons
    if {[llength [set BS($id)]] > 0} {
	puts "nbr sites ok : [llength [set BS($id)]]"
    }

    set aLkp ""
    if {[info exists Lkp]} {
	set aLkp [array get Lkp]
    }

    set filout [file join hali ${id}.tfa]
    EcritLeTfa $filout $Lnom $Lseq

    return $aLkp

}

proc CSA_TrieSites {} {

    global Tsite BS
    
    set Ll [LesLignesDuFichier csa/lit_sa.dat]
    foreach e $Ll {
	# PDB ID,SITE NUMBER,RESIDUE TYPE,CHAIN ID,RESIDUE NUMBER,CHEMICAL FUNCTION,EVIDENCE TYPE,LITERATURE ENTRY
	lassign [split $e ,] pdbid snb rtype chn rnmr tmp tmp tmp

	if {[set res [AutreCodeLuc $rtype]] eq "XXX"} {
	    continue
	}

	if {! [info exists Tsite($pdbid,$chn,$snb)]} {
	    set Tsite($pdbid,$chn,$snb) [list]
	}
	lappend Tsite($pdbid,$chn,$snb) [list $res $rnmr]
	lappend Lpdb $pdbid
    }
    set Lpdb [lsort -unique $Lpdb]
    puts "Nombre pdbId [llength $Lpdb]"

    # Creation des alignements
    foreach id $Lpdb {
	set fin [file join /genomics link HSSP ${id}.hssp.bz2]
	puts "\n==> $id $fin"
	if {! [file exists $fin]} {
	    puts " ### FILE DOES NOT EXISTS IN HSSP "
	    continue
	}
	set cok [LoadNouveauPDB $id "" 0 0]
	if {! $cok} {
	    puts " ### PDB can not be LOADED !"
	    continue
	}

	exec cp /biolo/HSSP/${id}.hssp.bz2 toto.bz2
	exec bunzip2 toto.bz2
	
	set aLkp [CSA_TraiteId $id]
	if {[llength $aLkp] >= 2} {
	    array set Lkp $aLkp
	}

	file delete -force toto
	$id destroy
    }

    # sauve bons site
    set f [open Sites_OK.dat w]
    puts $f [array get BS]
    close $f
    
    exit

}

proc C_DoBootstrap {Ln Lpil} {

    
    return [Ccode_DoBootstrap $Lpil [expr {int(rand()*280167)}]]

}

proc C_DoBootstrap2 {Ln Lpil Lrd} {

    
    return [Ccode_DoBootstrap $Lpil $Lrd]

}

proc C_Random {alen} {

    return [Crand $alen [expr {int(rand()*280167)}]]

}

proc CaCommenceParAttB {Seq} {

    set Seq [string toupper $Seq]
    if {[string first [SEQAttB1Invitrogen]    $Seq]==0} { return 1 }
    if {[string first [SEQAttB2InvitrogenRaC] $Seq]==0} { return 2 }
    return 0

}

proc CaVa {{Comment ""}} {

    global CaVa
    set Comment [string toupper $Comment]
    if {$Comment==""} { set Comment "?" }
    if {[info exists CaVa($Comment)]} { return $CaVa($Comment) }

    set Science [Science]
    set Date [Date Nice]
    set CaVa(RUNNINGSINCEDATE) $Date
    set CaVa(SCIENCE)          $Science
    set CaVa(?)                "$Science running since $Date"
    return [CaVa $Comment]

}

proc CacheResNumber {w} {

    set i [$w find withtag LabelNbr]
    if {$i eq ""} {return}

    set t [lsearch -inline -regexp [$w gettags $i] {^A}]
    set Nbr [string range $t 1 end]
    $w delete LabelNbr

    set Li [$w find withtag "NBox && Nbr$Nbr"]
    foreach i $Li {
	if {[$w type $i] ne "line"} {
	    $w itemconfig $i -fill black
	    $w itemconfig $i -outline cyan
	} else {
	    $w itemconfig $i -fill cyan
	}
    }

    return

}

proc CacheStrSecDansAlignement {} {

    global Defauts NomTextSeq NomNomSeq WNomSequence WTextSequence

    if {! [set Defauts(AffSS)]} {return}
    if {[TypeAli] eq "pasdali"} {return}
    if {[QuelMode] eq "seqlab"} {return}

    $NomNomSeq  configure -state normal
    $NomTextSeq configure -state normal

    $NomTextSeq tag delete Hel 1.0 end
    $NomTextSeq tag delete H31 1.0 end
    $NomTextSeq tag delete She 1.0 end
    $NomTextSeq tag delete Tur 1.0 end

    $NomNomSeq  configure -state disabled
    $NomTextSeq configure -state disabled

    set Defauts(AffSS) 0

    return

}

proc CafeDeCafe {} {

    return [QuestionDeScience ouragan::GGWmm "ret ListeDesPABs"]

}

proc CalcMeanID_Pos {{FichierMSF ""} {FichierPosition ""} {FichierOut ""}} {


    Wup "Permet de calculer les Mean ID dans un MACS a partir d un fichier de positions"
    Wup "Moyenne des pourcentages d identite - eux meme -"
    
    #Format d entree du fichier
    #1ere ligne Seq de ref (P02568)
    #ligne suivante un couple de positions (Debut-Fin) par ligne
    #/home/julie/MACSIM_jean/calc_meanid1 Actin_Complet3_1_Propre.rsf ARP_ntbinding

    set Calc_MeanID1 "/home/julie/MACSIM_jean/calc_meanid1"

    if {![file exists $FichierMSF]      || $FichierMSF     ==""} {return "-1"}
    if {![file exists $FichierPosition] || $FichierPosition==""} {return "-1"}
    if {                                   $FichierOut     ==""} {return "-1"}
    
    #Lecture du fichier contenant les positions a recherchees
    set Reference ""
    set LesPos    ""
    set i 0
    set F [open "$FichierPosition"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	incr i
	if {$i=="1"} {
	    set Reference [lindex $Ligne 0]
	    continue
	}
	lappend LesPos [split [string trim $Ligne] " "]
    }
    close $F
    
    AppendAuFichier $FichierOut [join [join [list Positions $LesPos] " "] "\t"]

    #Calcul su MeanID aux positions demandees
    set LesResidus ""
    set Result     ""
    if {[catch {set LesMeanIDs [exec $Calc_MeanID1 $FichierMSF $FichierPosition]} Message]} {
	Espionne ">>>CalcMeanID_Pos $FichierMSF $FichierPosition"
	Espionne "pb $Message"
	return "-1"
    } else {
	foreach Result [split $LesMeanIDs "\n"] {
	    set Result [join [string trim $Result] "\t"]
	    AppendAuFichier $FichierOut $Result
	} 
	return "1"
    }

    return ""

}

proc CalcMeanID_PosPourTous {} {


    Wup "Permet de calculer les Mean ID dans un MACS a partir d un fichier de positions"
    Wup "Moyenne des pourcentages d identite - eux meme -"

    set Type "MeanId"

    set LesCategories [InterrogeLesInfosDesARPs LesCategories]
    Espionne "$LesCategories"
    regsub -all {\-\-\-\-} $LesCategories "" LesCategories
    regsub -all      "Les" $LesCategories "" LesCategories

    Espionne "$LesCategories"

    foreach Famille $LesCategories {
	set MSF           "/home/jmuller/gscoperso/ARPAnno/ARP_MACS/${Famille}.rsf"
	set MSF           "[RepertoireDuGenome]/Projet_ARP/Resultat/alignement/Actin_Complet5_0_Propre_${Famille}.rsf"
	set MSF           "[RepertoireDuGenome]/test_MeanId/Actin_Complet5_0_Propre_${Famille}.msf"
                                                            
	if {! [file exists $MSF]} {
	    Espionne "$MSF do not exists"
	    continue
	}
	Espionne "$MSF exists"

	set FichierPos    "[RepertoireDuGenome]/test_MeanId/ARP_IIStruct.pos"
	set FichierMeanId "[RepertoireDuGenome]/test_MeanId/${Famille}_MeanId"

	CalcMeanID_Pos $MSF $FichierPos $FichierMeanId

	set FichierOut "[RepertoireDuGenome]/test_MeanId/1yag_${Famille}_MeanId.pdb"

	ChangeLeFactorBParIDDansLaPDB "[RepertoireDuGenome]/test_MeanId/1yag.pdb" $FichierOut $FichierMeanId $Type
    }
    return ""

}

proc CalcMeanID_PosPourTousOLD {} {


    Wup "Permet de calculer les Mean ID dans un MACS a partir d un fichier de positions"
    Wup "Moyenne des pourcentages d identite - eux meme -"
 
    set LesCategories [InterrogeLesInfosDesARPs LesCategories]
    regsub -all {\-\-\-\-} $LesCategories "" LesCategories
    regsub -all      "Les" $LesCategories "" LesCategories

    foreach Famille $LesCategories {
	set MSF           "/home/jmuller/gscoperso/ARPAnno/ARP_MACS/${Famille}.rsf"
	set MSF           "[RepertoireDuGenome]/Projet_ARP/Resultat/alignement/Actin_Complet5_0_Propre_${Famille}.rsf"

	if {! [file exists $MSF]} {continue}

	set FichierPos    "[RepertoireDuGenome]/ARP_IIStruct.pos"
	set FichierMeanId "[RepertoireDuGenome]/${Famille}_MeanId"

	CalcMeanID_Pos $MSF $FichierPos $FichierMeanId

	set FichierOut "[RepertoireDuGenome]/1yag_${Famille}_MeanId.pdb"

	if {[catch {set LesResidus [ChangeLeFactorBParIDDansLaPDB "[RepertoireDuGenome]/1yag.pdb" $FichierOut $FichierMeanId]} Message]} {
	    foreach Global [info global] {
		if {[regexp {PDB\_} $Global]} {
		    global $Global

		    if {[info exists $Global]} {
			unset $Global
		    }
		}
	    }
	    continue
	}
    }

}

proc CalculDesBiaisEnCompositionDeLaSequence {Sequence} {

    Wup "N PN A PA T PT G PG C PC AT PAT AG PAG AC PAC TG PTG TC PTC GC PGC Taille"

    regsub -all -nocase {[^ATGCNXMKRSYWVHDB]| } $Sequence "" Sequence
    set T [string length $Sequence]
    if {$T == 0} {return ""}

    set nN  0;set nA  0;set nT  0;set nG  0;set nC  0
    foreach Base [split [string toupper $Sequence] ""] {
	if {$Base == "N"                } {incr nN;continue}
	if {$Base == "A"                } {incr nA;continue}
	if {$Base == "T"                } {incr nT;continue}
	if {$Base == "G"                } {incr nG;continue}
	if {$Base == "C"                } {incr nC;continue}
    }
    set PN  [format "%.1f" [expr $nN*100.0/$T]]
    set PA  [format "%.1f" [expr $nA*100.0/($T-$nN)]]
    set PT  [format "%.1f" [expr $nT*100.0/($T-$nN)]]
    set PG  [format "%.1f" [expr $nG*100.0/($T-$nN)]]
    set PC  [format "%.1f" [expr $nC*100.0/($T-$nN)]]

    set nAT [expr $nA + $nT]
    set nAG [expr $nA + $nG]
    set nAC [expr $nA + $nC]
    set nTG [expr $nT + $nG]
    set nTC [expr $nT + $nC]
    set nGC [expr $nG + $nC]
    set PAT [format "%.1f" [expr $nAT*100.0/($T-$nN)]]
    set PAG [format "%.1f" [expr $nAG*100.0/($T-$nN)]]
    set PAC [format "%.1f" [expr $nAC*100.0/($T-$nN)]]
    set PTG [format "%.1f" [expr $nTG*100.0/($T-$nN)]]
    set PTC [format "%.1f" [expr $nTC*100.0/($T-$nN)]]
    set PGC [format "%.1f" [expr $nGC*100.0/($T-$nN)]]

    return [list $nN $PN $nA $PA $nT $PT $nG $PG $nC $PC $nAT $PAT $nAG $PAG $nAC $PAC $nTG $PTG $nTC $PTC $nGC $PGC $T]

}

proc CalculDesBiaisEnCompositionDuFichierTFA {FichierTFA} {

    if {![file exists $FichierTFA]} {return}
    return [CalculDesBiaisEnCompositionDeLaSequence [QueLaSequenceDuTFA $FichierTFA]]

}

proc CalculLaMoyenneGCCount {} {


    Wup "Permet de calculer le moyenne des GCs"
    Wup "Somme de tous les GCs / Nombre de Valeurs mesurees"

    global TabDesGCs

    if {! [info exists TabDesGCs(GCTotal)]|| ! [info exists TabDesGCs(NbGC)]} {return ""}
    set TabDesGCs(GCMoyenne) [format "%.1f" [expr ([set TabDesGCs(GCTotal)]*1.0)/ [set TabDesGCs(NbGC)]]]
    return ""

}

proc CalculLaMoyenneTmCount {} {


    Wup "Permet de calculer le moyenne des Tms"
    Wup "Somme de tous les Tms / Nombre de Valeurs mesurees"

    global TabDesTms

    if {! [info exists TabDesTms(TmTotal)] || ! [info exists TabDesTms(NbTm)]} {return ""}
    set TabDesTms(TmMoyenne) [format "%.1f" [expr ([set TabDesTms(TmTotal)]*1.0)/ [set TabDesTms(NbTm)]]]
    return ""

}

proc CalculLeFichierOrdonneDesJumeaux {FichierEntree FichierSortie NOuP} {


    Wup "Permet d ordonner les jumeaux en fonction des banques ou de la taille" 
    
    if {![file exists $FichierEntree]} {return "No existing Input File"}
    if { [file exists $FichierSortie]} {
	if {! [OuiOuNonMemo "$FichierSortie already exists, would you like append to it ?"]} {
	    file delete -force $FichierSortie
	}
    }
    
    set TousLesJumeaux {}
    if {[file exists $FichierEntree]} {
	set F [open "$FichierEntree"]
	while {[gets $F Ligne]>=0} {
	    if {[regexp "no Fasta" $Ligne]} {continue}
	    lappend TousLesJumeaux [join $Ligne " "]
	}
	close $F
    }
    
    foreach Liste [lsort -unique $TousLesJumeaux] {
	if {[llength $Liste]!=1} {
	    if {$NOuP =="N"} {
		set Liste [OrdonneSelonLePlusLong $Liste]
	    } elseif {$NOuP =="P"} {
		set Liste [OrdonneSelonLesBanques $Liste]
	    }
	}
	AppendAuFichier $FichierSortie $Liste
    }
    return ""

}

proc CalculLesFichiersTestTm {} {


    set LesPABs [ListeDesPABs]

    foreach PAB $LesPABs {
	ChoixDesOligosParLeTm $PAB 60 92 5 1
    }

}

proc CalculLesMeilleursConditionsDeTmEtDeTaille {aTabRes} {


    Wup "Calcul les meilleurs conditions pour tous les Tests effectues"
    Wup "Pour chaque Taille quel est le meilleur Tm, pour chaque PAB quelle est la meilleure condition"
    
    upvar $aTabRes TabRes
    
    set TabRes(nbTaille) 0
    set TabRes(nbPAB)    0
    set TabRes(nbTm)     0
    set LesPABs          [set TabRes(LesPABs)]
    set OneBest          0.0
    set TheBest          0.0
    foreach PAB $LesPABs {
	set TheBest 0.0
	#On determine les meilleurs Tms pour chaque Taille par PAB
	##########################################################
	foreach Length [set TabRes(LesLongueurs)] {
	    if {! [info exists TabRes(nbMeilleureTaille,$Length)]} {set TabRes(nbMeilleureTaille,$Length) 0}
	    set OneBest 0.0
	    foreach Tm [set TabRes(LesTms)] {
		#if {! [info exists TabRes($Length,$Tm,nbMeilleurTaille)]} {set TabRes($Length,$Tm,nbMeilleurTaille) 0}
		set PercentAccepted [set TabRes($PAB,$Length,$Tm,PercentAccepted)]
		#On determine le meilleur Tm de chaque taille pour chaque PAB
		if {$PercentAccepted>=$OneBest} {
		    set OneBest $PercentAccepted
		    set TabRes($PAB,$Length,LeMeilleurTm) $Tm
		}
		#On determine le meilleur Tm pour chaque PAB avec sa Taille
		if {$PercentAccepted>=$TheBest} {
		    set TheBest $PercentAccepted
		    set TabRes($PAB,LeMeilleurTm)           $Tm
		    set TabRes($PAB,LaTailleDeLeMeilleurTm) $Length
		}
	    }
	    incr TabRes(nbTaille) 1
	}
	
	set TheBest 0.0
	#On determine les meilleures Tailles pour chaque Tm par PAB
	###########################################################
	foreach Tm [set TabRes(LesTms)] {
	    if {! [info exists TabRes(nbMeilleurTm,$Tm)]} {set TabRes(nbMeilleurTm,$Tm) 0}
	    set OneBest 0.0
	    foreach Length [set TabRes(LesLongueurs)] {
		if {! [info exists TabRes($Length,$Tm,nbMeilleurTm)]} {set TabRes($Length,$Tm,nbMeilleurTm) 0}
		set PercentAccepted [set TabRes($PAB,$Length,$Tm,PercentAccepted)]
		#On determine la meilleure Taille de chaque Tm pour chaque PAB
		if {$PercentAccepted>=$OneBest} {
		    set OneBest $PercentAccepted
		    set TabRes($PAB,$Tm,LaMeilleureTaille) $Length
		}
		#On determine la meilleure Taille pour chaque PAB avec son Tm
		if {$PercentAccepted>=$TheBest} {
		    set TheBest $PercentAccepted
		    set TabRes($PAB,LaMeilleureTaille)       $Length
		    set TabRes($PAB,LeTmDeLaMeilleureTaille) $Tm
		}
	    }
	    incr TabRes(nbTm) 1
	}
	incr TabRes(nbPAB) 1
    }
    #Espionne "nbPAB [set TabRes(nbPAB)] nbTaille [set TabRes(nbTaille)] nbTm [set TabRes(nbTm)]"
    return ""

}

proc CalculLesPIDParRapportALaStructure {MSF PDBref SeqRef} {


    Wup "Calcul les PID par structure IIaire de la PDB 1yag par rapport a l actin P02568"
    Wup "On donne un alignement multiple au format MSF (obligatoire) et le nom de la pdb (sana la chaine)"
    Wup "ex: gscope CalculLesPIDParRapportALaStructure essai.msf 1yag P02568"
   
    #MSF    fichier MSF
    #PDBref nom de la PDB
    #Seqref nom de la sequence de reference pour le calcul du pourcentage d identite

    LesDefauts
    LesDefauts CheckSeq 0
    LesDefauts Mode Batch

    DecortiqueEtAfficheUnNouveauFichier $MSF

    global NomEtSeqAssPDB
    global Sequences

    puts "MSF Loaded"

    set idx   [lsearch -regexp $NomEtSeqAssPDB $PDBref]
    set   n   [lindex $NomEtSeqAssPDB $idx]
    scan $n "%s %s %s" PDBin NmSeqAss MolId
    set chn   [string index $MolId 5]
    set MolId [string range $MolId 0 3]

    puts "$MolId $chn"

    global PDB_[set MolId]_SecStr
    global PDB_[set MolId]_Sequence

    set SeqAss [set Sequences($NmSeqAss)]
    set SeqAlignee [lindex [set PDB_[set MolId]_Sequence($chn)] 1]

    foreach ss [set PDB_[set MolId]_SecStr] {
	DecortiqueSS $ss Elt NomChnDep NomResDep NomResFin Rmk	
	if {$Elt == "Coil"} {continue}
	set LesBornes [CorrespondancePDBAli $MolId $NomChnDep $NomResDep $NomResFin $SeqAlignee]
	set DebAli [lindex $LesBornes 0]
	set FinAli [lindex $LesBornes 1]

	puts ">$Elt $DebAli $FinAli $NomResDep $NomResFin"

	CalculeLesPCIJean $DebAli $FinAli $SeqRef
    }

    return ""

}

proc CalculMeanPIDAndFMPID {FichierACharger {AccessDeRef ""}} {


    Wup "Permet pour le fichier calculer par IDAndMeanPIDInMACS de calculer les moyennes par famille et les ecarts types"

    if {$AccessDeRef == ""} {
	set AccessDeRef "P02568"
	#Pour faire le comparatif avec une autre reference
	#set AccessDeRef "1yag_A"
    }

    #1- Lecture du fichier et affichage des entetes
    ###############################################
    Espionne "Famille\tMeanPID\tEcartTypeMeanPID\tMean_ID\tMeanFPID\tEcartTypeMeanFPID"
    set OnaFini 1
    set F [open "$FichierACharger"]
    while {[gets $F Ligne]>=0} {
	#/genomics/ARP/alignement_ARP/Resultat/Actin_Complet5_0_Propre_ARP1.rsf
	#P02568  P02568  100.00
	#mean_id 0.55
	if {! [regexp -nocase {[a-z]+ || [0-9]+}  $Ligne]} {continue}

	set LigneSplitee [split $Ligne "\t"] 
	set Access [lindex $LigneSplitee 0]
	if {$OnaFini} {
	    set Famille [file tail $Access]
	    regsub -all {.[a-z]{2,3}$} $Famille "" Famille
	    regsub -all {Actin_Complet5_0_Propre_} $Famille "" Famille
	    set ToSkip            0
	    set OnaFini           0
	    set NbSeqPourMean     0
	    set NbSeqPourMeanF    0
	    set Mean_ID           ""
	    set MeanPID           ""
	    set MeanFPID          ""
	    set EcartFredMeanPID  0
	    set EcartFredMeanFPID 0
	    array unset Tab "*"
	    continue
	}

	#4- Calcul des RefID et FamID avec les valeurs d ecart types associees
	######################################################################
	if {[regexp "mean_id" $LigneSplitee]} {
	    set OnaFini 1
	    set Mean_ID [lindex $LigneSplitee 1]

	    #4-1 RefID
	    if {$MeanPID != ""} {
		set EcartFredMeanPID   [EcartTypeDeLaListe $MeanPID]
		#Espionne $MeanPID
		set MeanPID  [expr (1.0 * ([join $MeanPID  "+"])) / $NbSeqPourMean] 
	    
	    }
	    #4-2 FamID
	    if {$MeanFPID != ""} {
		set EcartFredMeanFPID  [EcartTypeDeLaListe $MeanFPID]
		#Espionne $MeanFPID
		set MeanFPID [expr (1.0 * ([join $MeanFPID "+"])) / $NbSeqPourMeanF] 
	    }

	    Espionne "$Famille\t$MeanPID\t$EcartFredMeanPID\t$Mean_ID\t$MeanFPID\t$EcartFredMeanFPID"

	    continue
	}

	#if {! [regexp -nocase $AccessDeRef $Ligne]} {continue}
	set Acc1 ""
	set Acc2 ""
	set PID  0
	set Acc1 [lindex $LigneSplitee 0]
	set Acc2 [lindex $LigneSplitee 1]
	set PID  [lindex $LigneSplitee 2]

	if {$Acc1==$Acc2} {continue}

	#2- Calcul du RefID (pourcentage d identite moyen par rapport a une reference)
	#   La reference est l actine humaine du muscle squelettique (ACTS_HUMAN ou P02568)
	###################################################################################
	if {$Acc1=="$AccessDeRef" && $Acc2!="$AccessDeRef"} {
	    #Attention seulement pour le cas particulier de AccessDeRef 1yag_A
	    if {0} {
		if {$Acc2=="P02568"} {
		    
		} else {
		    incr NbSeqPourMean 
		    lappend MeanPID $PID
		}
	    }
	    
	    set Orga "[InterrogeLesInfosDesARPs [string toupper $Acc2] Organisme]"
	    if {[regexp -nocase "plasmodium" $Orga]} {
		set Tab($Acc2,ToSkip) 1
		set ToSkip 1
		continue
	    }

	    #On ne garde pas si on a 2 x le meme orga
	    if {! [info exists Tab($Orga)]} {
		set  Tab($Orga) 1
	    } else {
		incr Tab($Orga)
		set  Tab($Acc2,ToSkip) 1
		set ToSkip 1
	    }
	    
	    if {$ToSkip} {
		#On fait rien on ne ne garde pas
	    } else {
		incr NbSeqPourMean 
		lappend MeanPID $PID
		Espionne "$Acc1 $Acc2 $Orga"
	    }
	    set ToSkip 0
	}
	
	#3- Calcul du FamID (pourcentage d identite moyen au sein d une famille d ARP)
	###################################################################################	
	if {! [info exists Tab($Acc1,$Acc2)] && (! [info exists Tab($Acc2,ToSkip)] && ! [info exists Tab($Acc2,ToSkip)])} {
	    set Tab($Acc1,$Acc2) 1
	    set Tab($Acc2,$Acc1) 1
	} else {
	    continue
	}
	if {$Acc1=="$AccessDeRef" || $Acc2=="$AccessDeRef"} {continue}

	incr NbSeqPourMeanF
	lappend MeanFPID $PID
    }
    close $F

    return ""

}

proc CalculMoyMA {Fichier} {

    # fichier est de la forme: numgene\tFoldChangeMA
    set NumGenePrec 0
    set FCprec 100000
    set n 1
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp "fc" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set NumGene [lindex $LesElts 0]
	set FC [lindex $LesElts 1]
	if {$NumGene==$NumGenePrec} {
	    incr n
	    set S [expr $S+$FC]
	} else {
	    if {$n==1} {
		if {$NumGenePrec!=0} {
		    lappend L "$NumGenePrec\t$FCprec"
		}
	    } else {
		set Moy [expr $S*1.0/$n]
		lappend L "$NumGenePrec\t$Moy"
		set n 1
	    }
	    set S $FC
	}
	set NumGenePrec $NumGene
	set FCprec $FC
    }
    #Espionne [llength $L]
    return $L

}

proc CalculNorMDMS2PH {type {pos ""}} {


    puts "pour $type"
    if { $pos == "" } {
	set outFile  [file join [RepertoireDuGenome] "msf_$type" "NorMD.out"]
    } elseif { $pos == "rascal" } {
	set outFile  [file join [RepertoireDuGenome] "msf_$type" "Rascal" "NorMD3.out"]
    } else {
	set outFile  [file join [RepertoireDuGenome] "msf_$type" "Rascal" "Leon" "NorMD3.out"]
    }

    set f [open $outFile w]


    set lpab [ListeDesPABs]
    set lpab [lrange $lpab 0 200]
    #foreach pab [ListeDesPABs] {}
    foreach pab $lpab {
	puts "pour $pab"
	if { $pos == "" } {
	    set FichierMSF [file join [RepertoireDuGenome] "msf_$type" "$pab"]
	} elseif { $pos == "rascal" } {
	    set FichierMSF [file join [RepertoireDuGenome] "msf_$type" "Rascal" "$pab"]
	} else {
	    set FichierMSF [file join [RepertoireDuGenome] "msf_$type" "Rascal" "Leon" "$pab"]
	}

	if {[file exists $FichierMSF]} {
	    set resu [MDScore $FichierMSF "CalculeMoi"]
	    puts "norMD : $resu"
	    puts $f "$pab\t$resu"
	}
    }

    close $f
    return 1

}

proc CalculTmDeLaSeq {{Seq ""} {Sel ""} {Formamide ""} {Methode ""}} {


    Wup "Calcul le Tm selon la formule voulue"
    Wup "avec M concentration en sel, F en Formamide"
    Wup "avec L la longueur de Seq, XG et XC la fraction molaire de GC dans la Seq"
    Wup "La concentration est exprimee en molaire. Pour le formamide certains considerent le %"
 
    #Formule selon Wallace et al. 1979
    ##################################
    #Taille < 20 nts
    #Tm= 4*(G+C)+2*(A+T)]
    #
    #Formule selon Meintoth and Wahl 1984
    #####################################
    #Taille > 20 nts
    #Tm ADN-ADN stability +
    #Tm= 81.5 + 16.6 log M + 0.41(%G+C) - 500/L - 0.62F
    #
    #Tm ADN-ARN stability ++
    #Tm= 79.8 + 18.5 log M + 0.584(%G+C) + 11.8(%G+C)^2 - 820/L - 0.35F
    #
    #Tm ARN-ARN stability +++
    #Tm= 79.8 + 18.5 log M + 0.584(%G+C) + 11.8(%G+C)^2 - 820/L - 0.50F
    #
    #Nearest Neighbor Method
    ########################
    #Taille < 70 nts
    #Tm= 1000(DH)/((A + DS)) + Rln([ADN]/4) -273.15 + 16.6log([Na+])
    #Correction pour le Na+
    #Tm= 1000(DH)/     (DS)  + Rln([ADN]/4) -273.15) 
    #Correction comprise dans les parametres DH et DS 
    #R gaz cst = 1.987 cal.deg-1.mol-1, A correction for initiation -10.8
    #DNA = concentration des brins non auto complementaires 
    #        DNA/4 si meme concentration
    #(DNA1-DNA2)/2 si pas la meme concentraion
    #Ici DNA = 10E-6 M a voir 
    
    if {$Seq       == ""} {Espionne "No sequence available";return ""}
    if {$Formamide == ""} {set Formamide 12.3}
    if {$Sel       == ""} {set Sel 1}
    if {$Methode   == ""} {set Methode "DNADNA"}
    if {$Methode   == "NearestNeighbor"} {
	set Tm [NearestNeighborTm $Seq]
    } else {
	#shortest length of the two partners in duplex
	set TailleSeq [string length  $Seq] 
	set xG        [NombreDeBaseDe $Seq "G"]
	set xC        [NombreDeBaseDe $Seq "C"]
	set xA        [NombreDeBaseDe $Seq "A"]
	set xT        [NombreDeBaseDe $Seq "T"]
	set GCP       [expr ($xG+$xC)/($TailleSeq*1.0)]    
	set GCPercent [expr $GCP*100.0]
	#set NewSel [expr $Sel/(1.0+(0.7*$Sel))]
	#autre formule pour le Sel
	#set Tm4 [expr 81.5 + 16.6*log($NewSel) + 0.41*($GCPercent) - 500/$TailleSeq - 0.62*$FormamidePercent]
	if {$Methode == "Wallace"} {
	    set Tm [expr 4*($xG+$xC)+2*($xA+$xT)]
	} elseif {$Methode == "DNADNA"} {
	    set Tm [expr 81.5 + 16.6*log($Sel) + 0.41 *($GCPercent)                    - 500/$TailleSeq - 0.62*$Formamide]
	} elseif {$Methode == "DNARNA"} {
	    set Tm [expr 79.8 + 18.5*log($Sel) + 0.584*($GCPercent) + 11.8*pow($GCP,2) - 820/$TailleSeq - 0.50*$Formamide]
	} elseif {$Methode == "RNARNA"} {
	    set Tm [expr 79.8 + 18.5*log($Sel) + 0.584*($GCPercent) + 11.8*pow($GCP,2) - 820/$TailleSeq - 0.35*$Formamide]
	} else {return ""}
    }
    return [format "%.2f" $Tm]

}

proc CalculeAccessibiliteDuPDB {pdbfile} {




    return

}

proc CalculeAlignt {seqatester seqref chn mol} {


    global Sequences
    global LNOrdali
    global OrdTmpDir

    if {![regexp -nocase {[A-Z]} $seqref]} {
	set nomseq [lindex $LNOrdali $seqref]
	set laseqrefgap  [set Sequences($nomseq)]
    } else {
	set laseqrefgap [set Sequences($seqref)]
    }

    regsub -all {\.} $laseqrefgap "" laseqref
    regsub -all " " $laseqref "" laseqref
    regsub -all {\-} $laseqref "" laseqref
    regsub -all " "  $seqatester "" laseqatester
    regsub -all {\.}  $laseqatester "" laseqatester

    set file [string trim "tmp${mol}$chn"]
    set In  [file join ${OrdTmpDir} $file]
    set file [string trim "tmp2${mol}$chn"]
    set Out [file join ${OrdTmpDir} $file]
    set file [string trim "tmp3${mol}$chn"]
    set Log [file join ${OrdTmpDir} $file]

    set f [open $In w]

    puts $f ">seqref"
    set D 0
    while {$D < [string length $laseqref]} {
	set F [expr {$D + 59}]
	set L [string range $laseqref $D $F]

	puts $f "$L"
	incr D 60
    }

    puts $f ">seqtest"
    set D 0
    while {$D < [string length $laseqatester]} {
	set F [expr {$D + 59}]
	set L [string range $laseqatester $D $F]

	puts $f "$L"
	incr D 60
    }
    close $f

    BatchClustalw $In $Out $Log -nopgap -nohgap -outorder=input

    set LesLignes [LesLignesDuFichier $Log]

    set score 0
    foreach ligne $LesLignes {
	if {[string first "Sequences (1:2)" $ligne] == "0"} {
	    scan [string range $ligne 31 end] "%d" score
	}
    }

    file delete -force $In $Log

    return $score

}

proc CalculeAligntContreGlobal {seqref seqatester mol} {


    global Sequences
    global LNOrdali
    global OrdTmpDir

    regsub -all {\.} $seqref "-" seqref

    set In1  [file join ${OrdTmpDir} tmp${mol}1]
    set In2  [file join ${OrdTmpDir} tmp${mol}2]
    set Out  [file join ${OrdTmpDir} tmp2${mol}g]
    set Log  [file join ${OrdTmpDir} tmp3]
    set f [open $In1 w]

    puts $f ">seqref"
    set D 0
    while {$D < [string length $seqref]} {
	set F [expr {$D + 59}]
	set L [string range $seqref $D $F]

	puts $f "$L"
	incr D 60
    }
    close $f

    set f [open $In2 w]

    puts $f ">seqtest"
    set D 0
    while {$D < [string length $seqatester]} {
	set F [expr {$D + 59}]
	set L [string range $seqatester $D $F]

	puts $f "$L"
	incr D 60
    }
    close $f

    BatchClustalwProfile $In1 $In2 $Out $Log -outorder=input
    set tmp [DecortiqueUnMSF $Out NomSeq LesSeqAli]
    catch {file delete -force $In1 $In2 $Out $Log}

    return [set LesSeqAli(seqtest)]

}

proc CalculeArbreMarie {rfile bons} {

    global OrdTmpDir

    set FichierTfa "$OrdTmpDir/tmp_[pid].tfa"
    set FichierDST "${rfile}.dst"
    set FichierPH  "${rfile}.ph"

    EcritLeTfa $FichierTfa [lindex $bons 0] [lindex $bons 1]
    set Commande "[ClustalwExe] -infile=$FichierTfa -tree -outputtree=dist -outtreefile=$FichierDST"
    eval exec $Commande
    if {! [file exists $FichierDST]} {
	FaireLire "Cannot compute distance matrix !"
	exit
    }
    catch {exec [FastMEExe] -i $FichierDST -o $FichierPH}
    if {! [file exists $FichierPH]} {
	FaireLire "Cannot compute tree !"
	exit
    }
    file delete -force $FichierTfa

    return 1

}

proc CalculeComposition {{force 0}} {

    global TDesCompos LNOrdali LSOrdali

    foreach n $LNOrdali {
	if {$n eq ""} {continue}

	if {! [info exists TDesCompos($n,aa)] || $force} {
	    set TDesCompos($n,aa) [DonneCompositionDe $n]
	    set TDesCompos($n,pc) [DonnePhysicoChimieDe $n]
	}
    }

    return

}

proc CalculeConservationParSS {LePDB} {

    global ListePCISS Sequences ZoneSelect

    set ZoneSelect [list]
    if {$LePDB eq ""} {
	set LePDB ""
	SelectSSDeType sheet
	SelectSSDeType helix
    } else {
	set chn   [DonneChainDeAccessPDB $LePDB]
	set MolId [DonneIdDeAccessPDB $LePDB]
	if {$chn eq ""} {set chn "a"}
	set Limites [$MolId SecStr -chain $chn]
	foreach Lelt $Limites {
	    # Elt Type No Chn dep res fin res lgt
	    set d [lindex $Lelt 4]
	    set f [lindex $Lelt 6]
	    lappend ZoneSelect [list $d $f]
	}
    }

    foreach e $ZoneSelect {
	lassign $e d f
	set ListePCISS($d,$f) [CalculeLesPCI $d $f "" "" 1]
    }

    return

}

proc CalculeDimensionsArbre {AId} {

    global Abr

    set Abr($AId,Xmax) -9999
    set Abr($AId,Ymax) -9999
    set Abr($AId,Xmin) 9999
    set Abr($AId,Ymin) 9999

    if {[set Abr($AId,TypeTree)] eq "dendrogram"} {
	DimensionsArbre $AId root 20 20
    } else {
	DessineArbreCirculaire $AId root 0 0 1
    }

    return

}

proc CalculeFilDeFer {list mol} {

    ReadDict
    dont_use_light
    FilDeFerDe2 $list $mol

    return

}

proc CalculeGroupes {Type {NbGr -1}} {

    global Defauts Sequences LNOrdali LNDG SDG
    global TabSF yaord LesPoidsDesSequences OrdrePrecedent

    if {[llength [array names Sequences]] < 3} {
	return "Not enough sequences to apply clustering !"
    }

    if {$Type eq "fixed"} {
	set NbGr [ChoixNbCluster]
	if {$NbGr < 2} {return "Not enough clusters"}
    }
    LesDefauts TypeDeGroupesACreer $Type

    catch {unset SDG}
    set LNDG {}

    switch $Type {
	"fichierclu" {
	    set FichierClu [set Defauts(FichierClu)]
	    LectureClusters $FichierClu SDG LNDG dpc
	}
	"integral" {
	    global NomsGrpIntegral
	    global LesNomsSeqGrpIntegral
	    AssigneGroupesIntegral
	    set LNDG $NomsGrpIntegral
	    array set SDG [array get LesNomsSeqGrpIntegral]
	}
	"ordsecator" {
	    GroupesSecator LNDG SDG ordali
	}
	"orddpc" {
	    GroupesDpc LNDG SDG ordali
	    set GrMeth "3 ordalie groups with dpc"
	}
	"secator" {
	    GroupesSecator LNDG SDG secator
	    set GrMeth "secator"
	}
	"dpc" {
	    GroupesDpc LNDG SDG dpc
	    set GrMeth "dpc"
	}
	"zonesecator" {
	    set LReste [GroupesZones LNDG SDG secator]
	}
	"zonedpc" {
	    set LReste [GroupesZones LNDG SDG dpc]
	    set GrMeth "zones with dpc"
	}
	"fixed" {
	    GroupesDpc LNDG SDG dpc $NbGr
	    set GrMeth "fixed number of groups (k-means)"
	}
	"phylum" {
	    GroupesPhylum LNDG SDG
	    set GrMeth "phylogenic grouping"
	}
	"nogroups" {
	    global TableauCouleurEtGroupe
	    unset -nocomplain TableauCouleurEtGroupe
	    set LNDG {}
	}
    }

    if {! [llength $LNDG]} {
	unset -nocomplain SDG
	set SDG(GroupeToutLeMonde) $LNOrdali
    } else {
	foreach g $LNDG {
	    lappend SDG(GroupeToutLeMonde) {*}[set SDG($g)]
	}
    }

    set LNDG [linsert $LNDG 0 "GroupeToutLeMonde"]
    if {! [info exists LReste]} {set LReste {}}
    GroupeRestant SDG LNDG $LReste

    AssignSeqToGroup

    return 1

}

proc CalculeLabFil {pdbid} {

    global PDB_[set pdbid]_Labels
    global PDB_[set pdbid]_NomAtm
    global PDB_[set pdbid]_AtmXYZ
    global PDB_[set pdbid]_NomRes
    global PDB_[set pdbid]_NmrRes
    global TLabList

    set TLabList [glGenLists 1]
    glNewList $TLabList GL_COMPILE_AND_EXECUTE

    set Lch [lrange [array names PDB_[set pdbid]_NomAtm] 1 end]

    glInitNames
    glPushName 0

    set i 0
    foreach c $Lch {
	set LNat [set PDB_[set pdbid]_NomAtm($c)]
	set Lxyz [set PDB_[set pdbid]_AtmXYZ($c)]
	set LNom [set PDB_[set pdbid]_NomRes($c)]
	set LNmr [set PDB_[set pdbid]_NmrRes($c)]

	foreach Lx $Lxyz La $LNat ro $LNom rn $LNmr {
	    set r [string totitle [AutreCodeLuc $ro]]
	    foreach a $La x $Lx {
		incr i
		set a [string trim $a]
		set PDB_[set pdbid]_Labels($i) [list "$a $r ${c}${rn}" $x]
		lassign $x x1 y1 z1
		glLoadName $i
		glBegin GL_POINTS
		glVertex3f $x1 $y1 $z1
		#		glVertex3f {*}$x
		glEnd
	    }
	}
    }

    glEndList

    return

}

proc CalculeLesORFsEnOverlap {{AvecGLIMMER ""}} {

    global ListeDeBoites
    global LesORFsEnOverlap

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    if {[info exists LesORFsEnOverlap]} {unset LesORFsEnOverlap}

    foreach Boite $ListeDeBoites {
	set Nom    [Box $Boite nom]
	if {$AvecGLIMMER=="" && [regexp "GLIMMER" $Nom]} { continue }
	if {[regexp "TROU" $Nom]} { continue }
	if {[Fantome $Nom]} { continue }
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]
	global OrfsAvecStop
	if {[info exists OrfsAvecStop]} {
	    if {$Orient=="F"} { incr Fin 3 }  
	    if {$Orient=="R"} { incr Debut -3 }
	}  
	lappend AQuiEstCeDebut($Debut) $Nom
	lappend AQuiEstCetteFin($Fin)  $Nom
	lappend LesDebuts $Debut 
	lappend LesFins   $Fin
    }

    set LesDebutsTries [ListeSansDoublon [lsort -integer $LesDebuts]]
    set LesFinsTries   [ListeSansDoublon [lsort -integer $LesFins]]

    for {set i 0} {$i<[llength $LesDebutsTries]} {incr i} {
	set D [lindex $LesDebutsTries $i]
	foreach Moi [set AQuiEstCeDebut($D)] {
	    foreach X [lrange $LesDebutsTries [expr $i-6] $i] {
		foreach Lui [set AQuiEstCeDebut($X)] {
		    if { $Moi == $Lui } { continue }
		    if {[Box $Moi debut]==[Box $Lui debut]  && [Box $Moi fin]==[Box $Lui fin] && [Box $Moi orient]==[Box $Lui orient]} { continue }
		    if { [Box $Lui fin] >= $D } {
			lappend LesORFsEnOverlap($Moi) $Lui
			lappend LesORFsEnOverlap($Lui) $Moi
		    }
		}
	    }
	}
    }
    foreach {Qui ValLesORFsEnOverlap} [array get LesORFsEnOverlap] {
	set LesORFsEnOverlap($Qui) [ListeSansDoublon $ValLesORFsEnOverlap]
    }
    EspionneL [array get LesORFsEnOverlap]
    Espionne fin
    FaireLire "fin calcul"
    return

}

proc CalculeLesOverlapsDe {Moi} {

    global LesORFsEnOverlap

    if { ! [info exists LesORFsEnOverlap] } { CalculeLesORFsEnOverlap } 
    if { ! [info exists LesORFsEnOverlap($Moi)] } { return "" } 

    set Message ""
    foreach Lui [set LesORFsEnOverlap($Moi)] {
	set Ov [CalculeOverlapEntre $Moi et $Lui]
	lappend ListeDesMessages $Ov
    }
    return [join $ListeDesMessages "\n"] 

}

proc CalculeLesPCI {{d ""} {f ""} {Lseq1 ""} {Lseq2 ""} {Reset 0}} {

    global PLesSeqs PLesLong PLesNoms TDesPCI LNOrdali LSOrdali

    if {$d eq ""} {set d 0}
    if {$f eq ""} {set f "end"}

    FaireAttendre "Please wait ...\nComputing pairwise identities ..."

    # Longueur doivent etre reel pour que
    # Identite (entier) / longueur (reel) soit reel

    if {$Reset || ! [info exists PLesNoms]} {
	unset -nocomplain PLesNoms PLesSeqs PLesLong PNomSeq
	foreach n $LNOrdali s $LSOrdali {
	    if {$n eq ""} {continue}

	    set s [string range $s $d $f]
	    set l [string length [string map {"." "" " " "" "Z" ""} $s]]
	    if {$l == 0} {continue}
	    set ls [split $s ""]
	    lappend PLesLong $l
	    lappend PLesSeqs ${ls}
	    lappend PLesNoms $n
	}
    }

    if {$Lseq1 eq ""} {
	set LNSqDep $PLesNoms
	set LLgsDep $PLesLong
	set LSeqDep $PLesSeqs
    } else {
	foreach s1 $Lseq1 {
	    lappend LNSqDep $s1
	    set iseq1 [lsearch $PLesNoms $s1]
	    lappend LLgsDep [lindex $PLesLong $iseq1]
	    lappend LSeqDep [lindex $PLesSeqs $iseq1]
	}
    }
    
    if {$Lseq2 ne ""} {
	foreach s2 $Lseq2 {
	    lappend LNSqArr $s2
	    set iseq2 [lsearch $PLesNoms $s2]
	    lappend LLgsArr [lindex $PLesLong $iseq2]
	    lappend LSeqArr [lindex $PLesSeqs $iseq2]
	}
    } else {
	set LNSqArr $PLesNoms
	set LLgsArr $PLesLong
	set LSeqArr $PLesSeqs
    }

    set LsurL 0.
    array set T [list]
    set ListePCI [list]
    foreach n1 $LNSqDep l1 $LLgsDep s1 $LSeqDep {
	foreach n2 $LNSqArr l2 $LLgsArr s2 $LSeqArr {
	    if {[info exists T($n1,$n2)] || [info exists T($n2,$n1)]} {
		continue
	    }
	    if {$n1 eq $n2} {
		lappend ListePCI [list $n1 $n2 1.0 $l1 $l2 1.]
		set TDesPCI($n1,$n2) [list "1.0" $l1 $l2 "1."]
		set T($n1,$n2) [list "1.0" $l1 $l2 "1."]
	    } elseif {! $l1 || ! $l2} {
		lappend ListePCI [list $n1 $n2 0.0 $l1 $l2 -1]
		set TDesPCI($n1,$n2) [list -1.0 $l1 $l2 -1]
		set TDesPCI($n2,$n1) [list -1.0 $l1 $l2 -1]
		set T($n1,$n2) [list -1.0 $l1 $l2 -1]
		set T($n2,$n1) [list -1.0 $l1 $l2 -1]
	    } else {
		set pcid [NRIdentite $s1 $l1 $s2 $l2]
		set LsurL [expr {$l1>$l2?1.0*$l1/$l2:1.0*$l2/$l1}]
		lappend ListePCI [list $n1 $n2 $pcid $l1 $l2 $LsurL]
		lappend ListePCI [list $n2 $n1 $pcid $l2 $l1 $LsurL]
		set TDesPCI($n1,$n2) [list $pcid $l1 $l2 $LsurL]
		set TDesPCI($n2,$n1) [list $pcid $l2 $l1 $LsurL]
		set T($n1,$n2) [list $pcid $l1 $l2 $LsurL]
		set T($n2,$n1) [list $pcid $l2 $l1 $LsurL]
	    }
	}
    }

    FaireLaSuite

    return $ListePCI

}

proc CalculeLesPCIDuMac {} {

    global TDesPCI LTPCI

    set SAli [list]
    foreach n $::LNOrdali s $::LSOrdali {
	if {$n ne ""} {
	    lappend SAli $n $s
	}
    }

    set LTPCI [CalculeLesPCIGenerique $SAli]

    array set TDesPCI $LTPCI

    return $LTPCI

}

proc CalculeLesPCIGenerique {Lnmsq {aTPCI ""}} {

    if {$aTPCI ne ""} {
	upvar $aTPCI TPCI
    }

    set LNom [list] ; set LSeq [list]
    foreach {n s} $Lnmsq {
	lappend LNom $n
	lappend LSeq $s
    }

    if {[set ::Defauts(UseSpeedCode)] eq "C"} {
	set Lpci [Ccode_Pairwise $LSeq]
	
	set i 0
	foreach n1 $LNom {
	    foreach n2 $LNom {
		set TPCI($n1,$n2) [lindex $Lpci $i]
		incr i
	    }
	}
    } else {
	set LLgr [list]
	foreach s $LSeq {
	    lappend LLgr [string length [string map {"." ""} $s]]
	}
	
	set i 1
	foreach n1 $LNom s1 $LSeq l1 $LLgr {
	    set TPCI($n1,$n1) [list 1.0 $l1 $l1 1.0]
	    foreach n2 [lrange $LNom $i end] s2 [lrange $LSeq $i end] l2 [lrange $LLgr $i end] {
		set pcid [NRIdentite $s1 $l1 $s2 $l2]
		set LsurL [expr {$l1<$l2?1.0*$l1/$l2:1.0*$l2/$l1}]
		set TPCI($n1,$n2) [list $pcid $l1 $l2 $LsurL]
		set TPCI($n2,$n1) [list $pcid $l2 $l1 $LsurL]
	    }
	    incr i
	}
    }

    set LTPCI [list]
    set LTPCI [array get TPCI]

    return $LTPCI

}

proc CalculeLesPCIJean {d f AccessDeRef} {


    Wup "Calcul les pourcentages d identite entre la sequence de ref (P02568 et les autres)"

    global Sequences
    global LesNomsDesSequencesDansLOrdre
    global LesPCI
    
    # Longueur doivent etre reel pour que 
    # Identite (entier) / longueur (reel) soit reel
    
    #set AccessDeRef "P02568"
    #set AccessDeRef "P60010"
    #set AccessDeRef "1yag_A"

    set NomSeq [array get Sequences]
    foreach {n s} $NomSeq {
	set s [string range $s $d $f]
	regsub -all {\.} $s "" tmp
	set l [string length $tmp]
	set ls [split $s ""]
	lappend LesLong $l
	lappend LesSeqs $ls
	lappend LesNoms $n
    }

    set idx [lsearch $LesNoms "$AccessDeRef"]
    set s1 [lindex $LesSeqs $idx]
    set n1 "$AccessDeRef"
    set l1 [lindex $LesLong $idx]

    foreach n2 $LesNoms l2 $LesLong s2 $LesSeqs {
	if {! $l2} {continue}
	
	set pcid [NRIdentite $s1 $l1 $s2 $l2]
	set pcid [expr $pcid * 100.]

	puts "$n1 $n2 $pcid $l1 $l2"
    }
    
    return ""

}

proc CalculeLesSeuils {pilier {nmgrp ""} {thr ""}} {

    global Threshold ListeDesPiliersDuGroupe SDG LNDG Sequences LNOrdali LesPoidsDesSequences

    set PoidsTotal 0.

    if {$thr eq ""} {
	set thr [expr {double($Threshold)/100.}]
    } else {
	set thr [expr {double($thr)/100.}]
    }
    if {$nmgrp eq ""} {set nmgrp "GroupeToutLeMonde"}

    set i 0
    set Lc [split $pilier ""]
    foreach s [set SDG($nmgrp)] c $Lc {
	if {$c eq "Z"} {continue}
	set PoidsTotal [expr {$PoidsTotal+[set LesPoidsDesSequences($s)]}]
	incr i
    }

    if {$i > 1} {
	set seuil [expr {floor($thr*$PoidsTotal)}]
    } else {
	set seuil -1.
    }

    return $seuil

}

proc CalculeLogProba1 {N n Fn} {

    set N "${N}."
    set n "${n}."
    set Nmn [expr {$N-$n}]

    set EN   [factorial1 $N]
    set En   [factorial1 $n]
    set ENmn [factorial1 $Nmn]

    set p1 [expr {log($EN/($En*$ENmn))}]
    set p2 [expr {$n*log($Fn)}]
    set p3 [expr {${Nmn}*log(1.-$Fn)}]

    return [expr {$p1+$p2+$p3}]

}

proc CalculeLogProba2 {N n Fn} {


    set Nmn [expr {$N-$n}]

    set p1 [expr {[LnFn $N]-([LnFn $n]+[LnFn ${Nmn}])}]
    set p2 [expr {$n*log($Fn)}]
    set p3 [expr {${Nmn}*log(1.-$Fn)}]

    return [expr {$p1+$p2+$p3}]

}

proc CalculeMolecularWeight {{force 0}} {

    global LNOrdali LSOrdali TMassesAA TDesMolW

    if {! [info exists TMassesAA]} {InitMasses}

    foreach n $LNOrdali s $LSOrdali {
	if {[string trim $n] eq ""} {continue}
	
	if {! [info exists TDesMolW($n)] || $force} {
	    if {! [ExisteAABizarres $n]} {
		set M [DonneMolWeightDe $s]
	    } else {
		set M 0.0
	    }
	    set TDesMolW($n) $M
	}
    }

    return

}

proc CalculeNoRes {yd yf xf} {

    global PrmPrt

    incr yd -1
    incr yf -1
    incr xf -1

    set dump ""
    set LNCou [lrange $PrmPrt(LNoms) $yd $yf]
    set fmt "% -5d"
    foreach e $LNCou {
	if {[string trim $e] eq ""} {
	    set txt "\n"
	} else {
	    set ie [lsearch $::NomsAffiches $e]
	    set ne [lindex $::LNOrdali $ie]
	    set x [DonnePosGS $ne $xf]
	    set txt "[format $fmt $x]\n"
	}
	append dump $txt
    }

    return $dump

}

proc CalculeOverlapEntre {Moi et Lui} {

    global ListeDeBoites

    set MonNom    [Box $Moi nom]
    set MonDebut  [Box $Moi debut]
    set MonFin    [Box $Moi fin]
    set MonOrient [Box $Moi orient]
    set SonNom    [Box $Lui nom]
    set SonDebut  [Box $Lui debut]
    set SonFin    [Box $Lui fin]
    set SonOrient [Box $Lui orient]
    global OrfsAvecStop
    if {[info exists OrfsAvecStop]} {
	if {$MonOrient=="F"} { incr MonFin 3 }  
	if {$MonOrient=="R"} { incr MonDebut -3 }
	if {$SonOrient=="F"} { incr SonFin 3 }  
	if {$SonOrient=="R"} { incr SonDebut -3 }
    }  

    if {  $MonDebut <= $SonDebut &&  $SonFin   <= $MonFin } {
	set Long [expr $SonFin - $SonDebut + 1 ]
	set BeauLong [format "%4d" $Long]
	set Message "Overlap: $BeauLong bases. I contain  $Lui from $SonDebut to $SonFin"
	return $Message
    }
    
    if {  $SonDebut <= $MonDebut &&  $MonFin   <= $SonFin } {
	set Long [expr $MonFin - $MonDebut + 1 ]
	set BeauLong [format "%4d" $Long]
	set Message "Overlap: $BeauLong bases. I am in    $Lui from $MonDebut to $MonFin"
	return $Message
    }
    
    if {  $SonDebut <= $MonDebut &&  $MonDebut <= $SonFin } {
	set Long [expr $SonFin - $MonDebut + 1 ]
	set BeauLong [format "%4d" $Long]
	if {$MonOrient == "R"} {
	    set BegEnd "end in  "
	} else {
	    set BegEnd "begin in"
	}
	set Message "Overlap: $BeauLong bases. I $BegEnd $Lui from $MonDebut to $SonFin"
	return $Message
    }
    
    if {  $SonDebut <= $MonFin &&  $MonFin   <= $SonFin } {
	set Long [expr $MonFin - $SonDebut + 1 ]
	set BeauLong [format "%4d" $Long]
	if {$MonOrient == "F"} {
	    set BegEnd "end in  "
	} else {
	    set BegEnd "begin in"
	}
	set Message "Overlap: $BeauLong bases. I $BegEnd $Lui from $SonDebut to $MonFin"
	return $Message
    }
    return "J'en ai rate un"

}

proc CalculeOverview {Id} {

    global NomTextSeq Ovw LongueurTotale

    
    set wc [set Ovw(O$Id,w)]
    set Twdt $LongueurTotale
    set Thgt [$NomTextSeq count -lines 0.0 end]
    set Ovw(O$Id,Width)  $Twdt
    set Ovw(O$Id,Height) $Thgt
 
    set fx [expr {$Twdt/600.}]
    set fy [expr {$Thgt/300.}]
    if {$fx <= 1.} {set fx 1.0}
    if {$fy <= 1.} {set fy 1.0}
    set Ovw(O$Id,ScaOriX) [expr {round(1./$fx*100)}]
    set Ovw(O$Id,ScaOriY) [expr {round(1./$fy*100)}]

    set Cwdt [expr {round($Twdt/$fx)}]
    set Chgt [expr {round($Thgt/$fy)}]
    $wc configure -height $Chgt -width $Cwdt
    set img [image create photo -height $Thgt -width $Twdt]

    set f " #888888"
    set b " #ffffff"
    # blank line
    set linew [string trim [string repeat $b $Twdt]]
    # get the whole alignment
    set s [$NomTextSeq get 1.0 end]
    set smap [string map [list . $b " " $b * $b A $f B $f C $f D $f E $f F $f G $f H $f I $f J $f K $f L $f M $f N $f P $f Q $f R $f S $f T $f U $f V $f W $f Y $f X $f Z $f] $s]
    set ls [split $smap "\n"]
    foreach l $ls {
	set l [string trim $l]
	if {$l eq ""} {
	    lappend Data $linew
	} else {
	    lappend Data $l
	}
    }
    $img put $Data

    LRI::imgtransform $img -scalex [set Ovw(O$Id,ScaOriX)] -scaley [set Ovw(O$Id,ScaOriY)]
    if {! [info exists Ovw(O$Id,ScaTot)]} {
	set Ovw(O$Id,ScaTot) {}
    } else {
	set St [expr int(100*[join [set Ovw(O$Id,ScaTot)] *])]
	LRI::imgtransform $img -scale $St
    }
    set TOri [$wc create image 0 0 -image $img -anchor nw -tags algt]
    set Ovw(O$Id,Images) $img
    set Ovw(O$Id,FOri) $TOri
    set Ovw(O$Id,FeatAff) {}

    InitCentreOverview $Id
    bind $wc  [list CentreOverview $Id %x %y]

    return

}

proc CalculePI {{force 0}} {

    global LNOrdali LSOrdali
    global TDespI

    foreach n $LNOrdali {
	if {[string trim $n] eq ""} {continue}
	if {! [info exists TDespI($n)] || $force} {
	    set TDespI($n) [DonnePIDe $n]
	}
    }

    return

}

proc CalculePoidsDuPilier {pilier nmgrp} {

    global LesPoidsDesSequences
    global Sequences
    global LNDG
    global SDG

    set poids 0.
    set i 0
    foreach s [set SDG($nmgrp)] {
	if {[regexp {[0-9]} [string index $pilier $i]]} {
	    set poids [expr {$poids + [set LesPoidsDesSequences($s)]}]
	}
	incr i
    }

    return $poids

}

proc CalculePoidsDuPilier2 {Pilier Laa NmGrp Seuil} {

    global SDG LNDG Sequences LesPoidsDesSequences

    set Lc [split $Pilier ""]
    set poids 0.
    foreach s [set SDG($NmGrp)] c $Lc {
	if {$c in $Laa} {
	    set poids [expr {$poids + [set LesPoidsDesSequences($s)]}]
	}
    }

    if {$poids >= $Seuil} {
	return 1
    } else {
	return 0
    }

}

proc CalculeRibbon {mol} {

    global RadMol
    global LesVecs

    DecortiqueUnPDB "${mol}.pdb"
    global PDB_[set mol]_AtmXYZ
    global PDB_[set mol]_NmrRes
    #    set ch [lindex [array names PDB_[set mol]_AtmXYZ] 0]
    set ch "A"

    set Lx [set PDB_[set mol]_AtmXYZ($ch)]
    foreach x $Lx {
	lassign $x n ca c o
	lappend Lca $ca
	lappend Lc $c
	lappend Lo $o
    }

    set LesVecs [CheminRibbon $Lca $Lc $Lo]

    return

}

proc CalculeScoresColonne {{file ""}} {

    global ListeScore TableScore LNOrdali FichierMSF Defauts

    set FichierMSF ""

    LesDefauts

    set fic $file

    LesDefauts CheckSeq 0
    LesDefauts Mode "Batch"

    if {! [file exists $fic]} {
	puts " >>$fic<< doesn t exists !"
	puts " -----------------------\n\n"
	exit
    }

    set FichierMSF $fic
    puts "==========="
    puts "| $FichierMSF |"
    puts "==========="

    LesDefauts FichierMSF $FichierMSF
    LesDefauts TypeAli MSF
    LoadingAlignement
    set NSqs [llength $LNOrdali]
    puts "NSeqs : $NSqs"
    if {$NSqs <= 3} {
	puts "TOO FEW SEQUENCES !"
	exit
    }

    unset -nocomplain TableScore
    set grp ""
    ScoreDeNorm    $grp ; # 0 1 2 3
    ScoreDeSurf    $grp ; # 0 1 2 3
    ScoreDeThompson    $grp   ; # 4
    ScoreDeRanganatan  $grp   ; # 5
    ScoreDeVolPol  $grp   ; # 6
    ScoreAl2Co     $grp   ; # 7	
    ScoreDeLiu     $grp   ; # 8
    ScoreDeLiu2    $grp   ; # 8
    ScoreDeRPCA    $grp   ; # 9
    ScoreDeEntrop1 $grp   ; # 9
    ScoreDeEntrop2 $grp   ; # 9
    ScoreDeEntrop3 $grp   ; # 9
    ScoreDeEntrop4 $grp   ; # 9

    CreeListeScore
    set f [open "brute.dat" w]
    set fmt "%7.3f"
    set fmt "%2d[string repeat $fmt 7]"
    foreach e $ListeScore {
	puts $f [format $fmt {*}$e]
    }
    close $f

    exit


}

proc CalculeSpheres {chn mol} {

    global ListeDesSpheres
    global ListeDesObjetsDansO
    global SphDef

    global PDB_[set mol]_NomAtm
    global PDB_[set mol]_NomRes
    global PDB_[set mol]_NmrRes
    global PDB_[set mol]_ChnIdn
    global PDB_[set mol]_AtmXYZ

    catch {unset ListeDesObjetsDansO}
    if {! [info exists ListeDesSpheres($mol)]} {return 0}

    set ListeAtm [set PDB_[set mol]_AtmXYZ($chn)]
    set ListeNom [set PDB_[set mol]_NmrRes($chn)]

    foreach sp [set ListeDesSpheres($mol)] {
	lassign $sp NoRes Coul
	set idn [lsearch $ListeNom $NoRes]
	set NAtm [llength [lindex $ListeAtm $idn]]

	set xm 0.
	set ym 0.
	set zm 0.

	foreach a [lindex $ListeAtm $idn] {
	    scan $a "%f %f %f" x y z

	    set xm [expr {$xm + $x}]
	    set ym [expr {$ym + $y}]
	    set zm [expr {$zm + $z}]
	}

	set xm [expr {$xm / $NAtm}]
	set ym [expr {$ym / $NAtm}]
	set zm [expr {$zm / $NAtm}]

	set dmax -9999
	foreach a [lindex $ListeAtm $idn] {
	    lassign $a x y z

	    set xd [expr {$x - $xm}]
	    set yd [expr {$y - $ym}]
	    set zd [expr {$z - $zm}]

	    set dist2 [expr {$xd * $xd + $yd * $yd + $zd * $zd}]
	    set dist [expr {sqrt($dist2)}]
	    if {$dist > $dmax} {set dmax $dist}
	}


	if {$SphDef == "Mean"} {
	    set Rayon $dmax
	} else {
	    set Hbond 3.4
	    set Rayon [expr {$dmax + $Hbond}]
	}

	set IdxPt [string last "PTS" $Coul]

	if {$IdxPt != -1} {
	    set CPts "PTS"
	    set Coul [string range $Coul 0 [expr {$IdxPt - 1}]]
	    lappend ListeDesObjetsDansO($CPts) "sphere_xyz [format "%6.2f %6.2f %6.2f %6.2f" $xm $ym $zm $Rayon]"
	}

	lappend ListeDesObjetsDansO($Coul) "sphere_xyz [format "%6.2f %6.2f %6.2f %6.2f" $xm $ym $zm $Rayon]"
    }

    #    EcritSpheres $mol
    #    puts " "
    return 1

}

proc CalculeStick {list mol} {


    ReadDict
    SticksDe $list $mol

    return

}

proc CalculeTetNmoyen {FichierSortie} {

    #la bande pour un couple (user, codeclone)
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] {
	## (rq: pas de user R dans ce fichier)
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set U [lindex $LesChamps 0]
	### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ######
	set CodeClone [string trim [lindex $LesChamps 1]]
	if {$U=="F"} {
	    set CodeClone [string toupper $CodeClone]
	}
	set B [lindex $LesChamps 2]
	set Band($U,$CodeClone) $B
    }
    #Espionne "[array names Band]"

    #Intensites
    #############################################
    #           Attention!                      #
    # les numeros de bandes ne sont pas uniques #
    # Exemple: J PM et CW ont fait une bande 48 #
    #############################################
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Bands_intensiteDD.txt"] {
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set User [lindex $LesChamps 0]
	set B [lindex $LesChamps 1]
	regsub -all "\'" $B "" B
	set I_TE($User,$B) [lindex $LesChamps 3]
	set I_NE($User,$B) [lindex $LesChamps 4]
	set I_TS($User,$B) [lindex $LesChamps 5]
	set I_NS($User,$B) [lindex $LesChamps 6]
	set I_TU($User,$B) [lindex $LesChamps 7]
	set I_NU($User,$B) [lindex $LesChamps 8]
    }

    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/jumeaux"] {
	Espionne $Ligne
	set LesJumeaux [split $Ligne " "]
	set NbJumeaux [llength $LesJumeaux]
	#Espionne "nb jum : $NbJumeaux"
	set Pena 0; set PenaE 0 ; set PenaS 0 ;set PenaU 0 
	incr n
	#Espionne "nb jum : $LesJumeaux"
	set SommeIte 0
	set SommeIne 0
	set SommeIts 0
	set SommeIns 0
	set SommeItu 0
	set SommeInu 0
	set W 0
	foreach DD $LesJumeaux {
	    Espionne $DD
	    #---
	    set JR [JumeauRepresentatif $DD]
	    #---
	    set CC [ExtraitInfo $DD "CodeClone"]
	    set Ow [ExtraitInfo $DD "OwnerOfCDNA"]
	    if {$Ow=="R"} {set Ow "I"}
	    if {$Ow=="F"} {set CC [string toupper $CC]}
	    if {[info exists Band($Ow,$CC)]} {
		set Bande $Band($Ow,$CC)
		#Bandes de Fred du type H16B sans profil alors que H16 avec profil et meme bande
		if {$Ow=="F" && [regexp -nocase {[A-Z]+[0-9]+[A-Z]} $Bande]} {
		    regexp -nocase -indices {[A-Z]+[0-9]+} $Bande tmp
		    set NewBande [string range $Bande 0 [lindex $tmp 1]]
		    set Bande $NewBande
		}
		# Donnees manquantes (pour la plupart, clones de Fred)
		if {(![info exists I_TE($Ow,$Bande)] || ([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)=="")) ||  (![info exists I_NE($Ow,$Bande)] ||  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)==""))} {
		    set Ite ""
		    set Ine ""
		    incr PenaE
		}
		if {(![info exists I_TS($Ow,$Bande)] ||  ([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)=="")) ||  (![info exists I_NS($Ow,$Bande)] ||  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)==""))} {
		    set Its ""
		    set Ins ""
		    incr PenaS
		}
		if {(![info exists I_TU($Ow,$Bande)] ||  ([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)==""))||  (![info exists I_NU($Ow,$Bande)] ||  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)==""))} {
		    set Itu ""
		    set Inu ""
		    incr PenaU
		}
		if {([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)!="") &&  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)!="")} {
		    set Ite $I_TE($Ow,$Bande)
		    set Ine $I_NE($Ow,$Bande)
		}
		if {([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)!="") &&  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)!="")} {
		    set Its $I_TS($Ow,$Bande)
		    set Ins $I_NS($Ow,$Bande)
		} 
		if {([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)!="") &&  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)!="")} {
		    set Itu $I_TU($Ow,$Bande)
		    set Inu $I_NU($Ow,$Bande)
		}
		if {$Ite=="" && $Ine=="" && $Its=="" && $Ins=="" && $Itu=="" && $Inu==""} {
		    Espionne "aucune valeur de gel DD pour cette bande: $Bande"
		    incr Pena
		}
		if {$Ite!="" && $Ine!=""} {
		    set SommeIte [expr $SommeIte + $Ite]
		    set SommeIne [expr $SommeIne + $Ine]
		}
		if {$Its!="" && $Ins!=""} {
		    set SommeIts [expr $SommeIts + $Its]
		    set SommeIns [expr $SommeIns + $Ins]
		}
		if {$Itu!="" && $Inu!=""} {
		    set SommeItu [expr $SommeItu + $Itu]
		    set SommeInu [expr $SommeInu + $Inu]
		}
	    } else {
		Espionne "$DD : no band"
		#AppendAuFichier $FichierPbsBand "$DD $CC $Ow"
		set Bande ""; set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu ""
		incr Pena
	    }
	}
	set Total [expr $NbJumeaux-$Pena]
	if {$Total==0} {
	    #Espionne "total nul pour $Ligne"
	    #AppendAuFichier $FichierSortie2 "$n\t$AccProt\t$DefProt\t$AccRNA\t$DefRNA"
	    if {[info exists Vu]} {unset Vu}
	    continue
	}
	####### E S U distincts ##############
	set TNE [expr $SommeIte-$SommeIne]
	set TNS [expr $SommeIts-$SommeIns]
	set TNU [expr $SommeItu-$SommeInu]
	if {$TNE>0} {set PE "T"} ; if {$TNE<0} {set PE "N"} ;if {$TNE==0} {set PE "0"} 
	if {$TNS>0} {set PS "T"} ; if {$TNS<0} {set PS "N"} ;if {$TNS==0} {set PS "0"} 
	if {$TNU>0} {set PU "T"} ; if {$TNU<0} {set PU "N"} ;if {$TNU==0} {set PU "0"} 
	######## MOYENNES ##################
	
	set TotalE [expr $NbJumeaux-$PenaE]
	set TotalS [expr $NbJumeaux-$PenaS]
	set TotalU [expr $NbJumeaux-$PenaU]
	if {$TotalE==0} {
	    set MoyIne 0
	    set MoyIte 0
	} else {
	    set MoyIne [expr ($SommeIne*1.0/$TotalE*1.0)]
	    set MoyIte [expr ($SommeIte*1.0/$TotalE*1.0)]
	}
	if {$TotalS==0} {
	    set MoyIns 0
	    set MoyIts 0
	} else {
	    set MoyIns [expr ($SommeIns*1.0/$TotalS*1.0)]
	    set MoyIts [expr ($SommeIts*1.0/$TotalS*1.0)]
	}
	if {$TotalU==0} {
	    set MoyInu 0
	    set MoyItu 0
	} else {
	    set MoyInu [expr ($SommeInu*1.0/$TotalU*1.0)]
	    set MoyItu [expr ($SommeItu*1.0/$TotalU*1.0)]
	}
	set SommeDesMoyennesN [format "%.3f" [expr $MoyIne + $MoyIns +$MoyInu]]
	set MoyenneDesMoyennesN [format "%.3f" [expr $SommeDesMoyennesN/3]]

	set SommeDesMoyennesT [format "%.3f" [expr $MoyIte + $MoyIts +$MoyItu]]
	set MoyenneDesMoyennesT [format "%.3f" [expr $SommeDesMoyennesT/3]]

	set DifTNmoy [expr ($MoyenneDesMoyennesT-$MoyenneDesMoyennesN)]
	#if {$n==159} {Espionne "159 a un tnmoyen de : $TNmoy"; exit}
	if {$DifTNmoy>0} {set Pmoy "T"}
	if {$DifTNmoy<0} {set Pmoy "N"}
	if {$DifTNmoy==0} {set Pmoy "0"}
	AppendAuFichier $FichierSortie "$n\t$MoyenneDesMoyennesT\t$MoyenneDesMoyennesN\t$DifTNmoy\t$Pmoy"
	if {[info exists Vu]} {unset Vu}
    }

}

proc CalculeUnArbre {} {

    global ZoneTree ZoneSelect ListePDB Defauts Abr TSum tcl_platform OrdTmpDir Rap

    if {[TypeAli] eq "pasdali"} {return}

    if {! [info exists ZoneSelect]} {
	set ZoneSelect [list]
    }
    set ZoneTree $ZoneSelect
    if {$ZoneTree == {}} {
	FaireLire "No zone selected ..."
	return
    }

    FaireAttendre "Please wait ...\nComputing distance matrix and phylogenetic tree ..."

    AlignementDesSelections $ZoneTree SAli

    set ZoneTree $ZoneSelect
    set NewAli {}
    foreach {n s} $SAli {
	if {$n in $ListePDB && ! [set Defauts(PDBTree)]} {
	    continue
	}
	lappend LNoms $n
	lappend LSeqs $s
	lappend NewAli $n $s
    }
    set SAli $NewAli

    if {[set Defauts(TypeGapTree)] eq "global"} {
	set Long [string length [lindex $LSeqs 0]]
	for {set i 0} {$i < $Long} {incr i} {
	    set p$i 1
	}
	
	foreach s $LSeqs {
	    for {set i 0} {$i < $Long} {incr i} {
		if {[set p$i] && [string index $s $i] eq "."} {
		    set p$i 0
		}
	    }
	}

	set lnew {}
	set ltmp $LSeqs
	for {set i [expr {$Long-1}]} {$i >= 0} {incr i -1} {
	    if {[set p$i]} {
		foreach s $ltmp {
		    set s [string replace $s $i $i]
		    lappend lnew $s
		}
	    }
	    set ltmp $lnew
	    set lnew {}
	    update
	}
	set LSeqs $ltmp
    }
    set NbrSites [string length [lindex $LSeqs 0]]

    if {$NbrSites < 10} {
	FaireLire "Error ! Less than 10 sites to compute tree !!"
	FaireLaSuite
	return
    }

    CalculeLesPCIGenerique $SAli TPCI
    
    set m 0. ; set m2 0.
    set min 9999999. ; set max -9999999.
    set Nseq [llength $LNoms]
    set Ldst [list]
    foreach n1 $LNoms {
	foreach n2 $LNoms {
	    lassign [set TPCI($n1,$n2)] pc l1 l2 lsl
	    lappend Ldst [expr {1.-$pc}]
	    if {$n1 ne $n2} {
		set m  [expr {$m + $pc}]
		set m2 [expr {$m2 + $pc*$pc}]
		if {$pc < $min} {set min $pc}
		if {$pc > $max} {set max $pc}
	    }
	}
    }
    set m  [expr {$m/($Nseq*($Nseq-1))}]
    set m2 [expr {$m2/($Nseq*($Nseq-1))}]
    set sd [expr {sqrt($m2-$m*$m)}]
    set Rap(nseq)   $Nseq
    set Rap(idmin)  $min
    set Rap(idmax)  $max
    set Rap(idmean) $m
    set Rap(idsd)   $sd

    set LeTree [fastme $LNoms $Ldst]

    FaireLaSuite

    set AId [InitialiseUnArbre $LeTree]
    
    # some spec
    set Abr($AId,Mode) normal
    set Abr($AId,TypeGapTree) $Defauts(TypeGapTree)
    set Abr($AId,NbrSites) $NbrSites
    set Abr($AId,TreeNBoot)   $Defauts(TreeNBoot)
    if {[set Defauts(TreeBoot)]} {
	set Abr($AId,BootDone) 1
	#::profiler::reset
	BootstrapArbre $AId $SAli
	#AffichePrTTTofileResults
    } else {
	set Abr($AId,BootDone) 0
    }

    #SequenceWeight $AId
    AfficheUnArbre $AId

    #parray Rap

    return $AId

}

proc CalculeValParColonne {} {

    global ListeScore LNOrdali

    puts "NSeqs     : [llength $LNOrdali]"

    ScoreDeRosace
    ScoreDeThompson
    ScoreDeRanganatan

    CreeListeScore
    set ListeScoreOri $ListeScore

    set ListeScore [ExtraitListeDeListe $ListeScore 0]
    NormalisationColonnes
    EcritPourDPC "g-tdpc.dat"

    CreeListeScore "0 4 5"
    NormalisationColonnes
    EcritPourDPC "ngd-tdpc.dat"

    set ListeScore $ListeScoreOri

    return

}

proc CamembertOntologieDesAffyDifExprimes {} {

    set MaListe [ListeDesDifferentiellementExprimesSansJumeaux]
    IllustreLeCamembertOntologiqueDesBoitesGscope $MaListe 

}

proc CanalSql {{ConnInfo ""}} {

    global CanalSql OldConnInfo

    if {[string equal -nocase $ConnInfo "GetDbname"]} {
	if { ! [info exists OldConnInfo]} { return "" }
	return [StringApres "dbname=" dans $OldConnInfo]
    }

    if {$ConnInfo==""} {
	if {[info exists OldConnInfo]} {
	    set ConnInfo $OldConnInfo
	} else {
	    # set ConnInfo "host=[LbgiHost] dbname=macsim user=ripp password=postgresRIPP"
	    # set ConnInfo "host=[LbgiHost] dbname=genoret user=ripp password=postgresRIPP"
	    set ConnInfo [ConnInfo]
	}
    }
    if {[info exists OldConnInfo] && $OldConnInfo==$ConnInfo && [info exists CanalSql]} {
	set Sgbd [StringApres "sgbd=" dans $ConnInfo]
	if { ! [string equal -nocase "mysql" $Sgbd]} { return $CanalSql }
	set  State [mysqlstate $CanalSql -numeric]
	if {$State==2 || $State==4} { return $CanalSql } 
	catch {mysqlclose $CanalSql} 
	unset CanalSql
	unset OldConnInfo
	return [CanalSql $ConnInfo]
    }
 
    if {[info exists CanalSql]} { unset CanalSql }

    set OldConnInfo $ConnInfo
    set Sgbd [StringApres "sgbd=" dans $ConnInfo]
    if {[string equal -nocase "mysql" $Sgbd]} {
	set Host     [StringApres "host="     dans $ConnInfo]
	set DbName   [StringApres "dbname="   dans $ConnInfo]
	set User     [StringApres "user="     dans $ConnInfo]
	set Password [StringApres "password=" dans $ConnInfo]
	set Sgbd     [StringApres "sgbd="     dans $ConnInfo]
	package require mysqltcl
	set Handle [mysqlconnect -host $Host -user $User -password $Password]

	mysqluse $Handle $DbName
	set CanalSql $Handle
	return $CanalSql
    }

    if {[string equal -nocase "sqlite" $Sgbd]} {
	global SqliteHandle
	set Host     [StringApres "host="     dans $ConnInfo]
	set DbName   [StringApres "dbname="   dans $ConnInfo]
	set User     [StringApres "user="     dans $ConnInfo]
	set Password [StringApres "password=" dans $ConnInfo]
	set Sgbd     [StringApres "sgbd="     dans $ConnInfo]

	if {[info exists SqliteHandle($Host)]} { return $SqliteHandle($Host) }

	package require sqlite3
	set Handle [NomDe "SqliteHandle"]
	sqlite3 $Handle $Host
	set SqliteHandle($Host) $Handle

	set CanalSql $Handle
	return $CanalSql
    }
    regsub { sgbd=[^ ]+} $ConnInfo "" ConnInfo
    set CanalSql [SqlConnect -conninfo $ConnInfo]
    return $CanalSql

}

proc CanalSqlCilioCarta {} {

    set CanalSql [CanalSql [ConnInfoCilioCarta]]
    return $CanalSql

}

proc CanalSqlCurrent {} {

    global CanalSql OldConnInfo
    if { ! [info exists CanalSql]} { return "" }
    return $OldConnInfo

}

proc CanalSqlDbgs {} {

    set CanalSql [CanalSql [ConnInfoDbgs]]
    return $CanalSql

}

proc CanalSqlDisconnect {} {

    global CanalSql
    if { ! [info exists CanalSql]} {return ""}
    set OldCanalSql $CanalSql
    unset CanalSql
    return [SqlDisconnect $OldCanalSql]

}

proc CanalSqlDomine {} {

    set CanalSql [CanalSql [ConnInfoDomine]]
    return $CanalSql

}

proc CanalSqlEncode {} {

    set CanalSql [CanalSql [ConnInfoEncode]]
    return $CanalSql

}

proc CanalSqlFedlord {} {

    set CanalSql [CanalSql [ConnInfoGenoret]]
    return $CanalSql

}

proc CanalSqlGecoDB {} {

    set CanalSql [CanalSql [ConnInfoGecoDB]]
    return $CanalSql

}

proc CanalSqlGeneOntology {} {

    set CanalSql [CanalSql [ConnInfoGeneOntology]]

}

proc CanalSqlGenoret {} {

    set CanalSql [CanalSql [ConnInfoGenoret]]
    return $CanalSql

}

proc CanalSqlGx {} {

    set CanalSql [CanalSql [ConnInfoGx]]
    return $CanalSql

}

proc CanalSqlGxDb {} {

    set CanalSql [CanalSql [ConnInfoGxDb]]
    return $CanalSql

}

proc CanalSqlInteraction {} {

    set CanalSql [CanalSql [ConnInfoInteraction]]
    return $CanalSql

}

proc CanalSqlMacsims {} {

    set CanalSql [CanalSql [ConnInfoMacsims]]
    return $CanalSql

}

proc CanalSqlMiSynPat {} {

    set CanalSql [CanalSql [ConnInfoMiSynPat]]
    return $CanalSql

}

proc CanalSqlOrthoInspector {} {

    set CanalSql [CanalSql [ConnInfoOrthoInspector]]
    return $CanalSql

}

proc CanalSqlPatternDB {} {

    set CanalSql [CanalSql [ConnInfoPatternDB]]
    return $CanalSql

}

proc CanalSqlPatternDB18 {} {

    set CanalSql [CanalSql [ConnInfoPatternDB18]]
    return $CanalSql

}

proc CanalSqlPatternDB19 {} {

    set CanalSql [CanalSql [ConnInfoPatternDB19]]
    return $CanalSql

}

proc CanalSqlPuzz {} {

    set CanalSql [CanalSql [ConnInfoPuzz]]
    return $CanalSql

}

proc CanalSqlRetinoBase {} {

    set CanalSql [CanalSql [ConnInfoRetinoBase]]
    return $CanalSql

}

proc CanalSqlSanger {} {

    set CanalSql [CanalSql [ConnInfoSanger]]
    return $CanalSql

}

proc CanalSqlSanger18 {} {

    set CanalSql [CanalSql [ConnInfoSanger18]]
    return $CanalSql

}

proc CanalSqlSanger19 {} {

    set CanalSql [CanalSql [ConnInfoSanger19]]
    return $CanalSql

}

proc CanalSqlString {} {

    set CanalSql [CanalSql [ConnInfoString]]
    return $CanalSql

}

proc CanalSqlTaxobla {{Bdd ""}} {


    if {$Bdd!="" && [FileAbsent $Bdd]} { set Bdd "[BlomeDbDir]/$Bdd" }

    Espionne $Bdd

    set Queue [file tail $Bdd]
    if { "[CanalSql "GetDbname"].db" != $Queue } {
	Espionne [CanalSql "GetDbname"]
	Espionne $Queue
	CanalSqlDisconnect
	CanalSql [ConnInfoForDatabase $Bdd]
    }
    return [CanalSql]

}

proc CanalSqlUcsc {{DbName ""}} {

    set CanalSql [CanalSql [ConnInfoUcsc $DbName]]

}

proc CanalSqlUcscDog {} {

    set CanalSql [CanalSql [ConnInfoUcscDog]]

}

proc CanalSqlUcscDroso {} {

    set CanalSql [CanalSql [ConnInfoUcscDroso]]

}

proc CanalSqlUcscHuman {} {

    set CanalSql [CanalSql [ConnInfoUcsc "Human"]]

}

proc CanalSqlUcscHuman18 {} {

    set CanalSql [CanalSql [ConnInfoUcsc "Human18"]]

}

proc CanalSqlUcscHuman19 {} {

    set CanalSql [CanalSql [ConnInfoUcsc "Human19"]]

}

proc CanalSqlUcscMouse {} {

    set CanalSql [CanalSql [ConnInfoUcscMouse]]

}

proc CanalSqlUcscRat {} {

    set CanalSql [CanalSql [ConnInfoUcscRat]]

}

proc CanalSqlUcscWorm {} {

    set CanalSql [CanalSql [ConnInfoUcscWorm]]

}

proc Canonise {Construction} {

    
    scan $Construction "%s" Construction

    set MemoCons $Construction

    regsub -all "hCOUP_TFII"    $Construction "hCOUP-TFII"   Construction
    regsub -all "SH1_ITK"       $Construction "SH1-ITK"      Construction
    regsub -all "TOPO_NcoI"     $Construction "TOPONcoI"     Construction
    regsub -all "AttB1_Adapter" $Construction "AttB1Adapter" Construction
    regsub -all "AttB2_Adapter" $Construction "AttB2Adapter" Construction
    if {[regexp -nocase {(EC|Y|H)(TAF|BDF|ASF|NFY[ABC])[0-9]*_[MNWDCHF0-9]+_[MNWDCHF0-9]+} $Construction Match]} {
	regsub -all "_" $Match "-" BonMatch
	regsub $Match $Construction $BonMatch Construction
    }
    if {[regexp -nocase {[a-z0-9]+_[0-9]+[_\-][0-9]+} $Construction Match]} {
	regsub -all "_" $Match "-" BonMatch
	regsub $Match $Construction $BonMatch Construction
    }
    regsub "^>" $Construction "" Construction
    return [list $Construction]

}

proc Canva {LargeurMaxi HauteurMaxi {LargeurVoulue 768} {HauteurVoulue 512} {GonfleAussiY NoY} {Titre ""} {AvecMainLevee ""} {w ""}} {

    ######################################################
    ###MODIFICATION DE LA PROCEDURE DE RAYMOND RIPP    ###
    ######################################################

    global ScrollRectangleOriginal IdScrollRectangle
    global CouleurDuFondDeUnCanva

    if { ! [info exists CouleurDuFondDeUnCanva]} {
	set CouleurDuFondDeUnCanva "white"
    }

    if {[regexp "MainLevee" $AvecMainLevee]} { set AvecMainLevee 1 } else { set AvecMainLevee 0 } 

    if {$GonfleAussiY=="NoY"} {
	set GonfleY 1.0
	set DegonfleY 1.0
    } else {
	set GonfleY "gonfle"
	set DegonfleY "degonfle"
    }
    set JAppartientAUneAutreFenetre 1
    if {$w == ""} {
	set JAppartientAUneAutreFenetre 0
	set w [NomDe canva]
	if {$Titre==""} { set Titre $w } 
	catch {destroy $w}
	toplevel $w
	wm title $w $Titre
	wm iconname $w $Titre
    } else {
	set w "$w.framecanva"
	if {![winfo exists $w]} {
	    frame $w
	    pack $w -fill both -expand 1
	} else {
	    $w.canvas delete all
	}
    }

    set CanvaScroMinX 0
    set CanvaScroMinY 0
    set CanvaScroMaxX $LargeurMaxi
    set CanvaScroMaxY $HauteurMaxi

    set K       $w.canvas
    set ScroHor $w.hscroll
    set ScroVer $w.vscroll
    set KShSv   $w.grid
    set Boutons $w.buttons

    if {![winfo exists $K]} {
	frame $KShSv
	scrollbar $ScroHor -orient horiz -command "$K xview"
	scrollbar $ScroVer               -command "$K yview"
    
	canvas $K

	grid rowconfig    $KShSv 0 -weight 1 -minsize 0
	grid columnconfig $KShSv 0 -weight 1 -minsize 0
	
	grid $K       -in $KShSv -padx 1 -pady 1  -row 0 -column 0  -rowspan 1 -columnspan 1  -sticky nsew
	grid $ScroVer -in $KShSv -padx 1 -pady 1  -row 0 -column 1  -rowspan 1 -columnspan 1  -sticky nsew
	grid $ScroHor -in $KShSv -padx 1 -pady 1  -row 1 -column 0  -rowspan 1 -columnspan 1  -sticky nsew
	pack $KShSv -expand 1 -fill both
    }

    set IdScrollRectangle($K) [$K create rect $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY -tags [list "Cadre"] -outline $CouleurDuFondDeUnCanva]
    set ScrollRectangleOriginal($K) "[$K coords [set IdScrollRectangle($K)]]"

    $K configure  -width $LargeurVoulue  -height $HauteurVoulue  -scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY]  -xscrollcommand "$ScroHor set"  -yscrollcommand "$ScroVer set"
    
    if {![winfo exists $Boutons]} {
	#########################
	frame $Boutons
	pack  $Boutons -side bottom -fill x
	if { ! [string equal -nocase "NoZoom" $GonfleAussiY]} {
	    button $Boutons.postscript -text "Zoom/UnZoom/Reset"
	    bind $Boutons.postscript <1>       "Gonfle $w all gonfle $GonfleY"
	    bind $Boutons.postscript <2>       "Gonfle $w all degonfle $DegonfleY"
	    bind $Boutons.postscript <3>       "Gonfle $w all reset reset"
	    pack $Boutons.postscript -fill x -side top -expand 1
	}
	if {!$JAppartientAUneAutreFenetre} {
	    button $Boutons.dismiss -text "CLOSE" -command "destroy $w"
	    pack   $Boutons.dismiss -fill x -side top -expand 1
	}
	##########################################################
    }
    if {$AvecMainLevee} { MainLeveeSurUnCanva $K }

    return $K

}

proc CanvaAsSvg {args} {

    global CAS

    set BlastFile ""

    lassign $args Qui Quoi W H File

    if {$Qui=="create" && $Quoi=="svg"} {
	set BlastFile $File
	set CAS(Current,BlastFile) $BlastFile
	if {[info exists CAS($BlastFile)]} { array unset CAS $BlastFile* }
	set CAS($BlastFile) 1
    }
    set BlastFile $CAS(Current,BlastFile)

    #rR Retour pour Qui Quoi
    if {[info exists CAS($BlastFile,$Qui,$Quoi)]} { return $CAS($BlastFile,$Qui,$Quoi) }
    if {$Quoi=="SequenceDesBanques"} {
	set SDB ""
	if {[info exists CAS($BlastFile,$Qui,BId)]} {
	    set BId $CAS($BlastFile,$Qui,BId)
	    set SDB [SequenceDesBanques $BId]
	    if {$SDB!=""} { return $SDB }
	}
	return "Sorry I didn't found any information about $Qui"
    }
    if {$Quoi=="WholeSubject"} {
	set WholeSubject ""
	if {[info exists CAS($BlastFile,$Qui,BId)]} {
	    set BId $CAS($BlastFile,$Qui,BId)
	    set Texte [ContenuDuFichier $BlastFile]
	    if {[regexp ">$BId \[^>\]+(>|$)" $Texte Match]} {
		set WholeSubject [string trimright $Match ">"]
		regsub "  Database:" $WholeSubject "" WholeSubject
		return $WholeSubject
	    }
	}
	return "Sorry I didn't found any information about $Qui"
    }
    #rR Retour pour Qui Quoi

    lassign $args Commande Forme
    if {$Commande=="close" && $Forme=="svg"} {
	lappend CAS($BlastFile,ContentOf,svg) ""
	set CAS($BlastFile,ContentOf,svg) [join $CAS($BlastFile,ContentOf,svg) "\n"]
	return $CAS($BlastFile,ContentOf,svg)
    }
    if {$Commande=="create"} {
	set iOptions 4
	if {$Forme=="rectangle"} { set iOptions 6 }
	set Coords  [lrange $args 2 $iOptions-1]
	set Options [lrange $args $iOptions end]
	if {$Forme=="svg"} {
	    lassign $Coords W H
	    lappend CAS($BlastFile,ContentOf,svg) "
Disordered regions:
" dans $Texte]
	if {$Bornes==""} { return "" }
	#modification 
 en 
	set iP [string first "
" $Bornes]
	if {$iP==-1} { return "" }
	#modification de 0 en 3
	set Bornes [string range $Bornes 0 [incr iP -1]]
	regsub -all {[^0-9\-\,]} $Bornes "" Bornes
	foreach DF [split $Bornes ","] {
	    set InfoRonn($Fichier,DR,$i) $DF
	    lappend InfoRonn($Fichier,DR) $i
	    incr i
	}
 	close $F
    }
    return ""

}

proc ChargeSeraphinEtCasimir {} {

    global RepertoireDuGenome
    global ListeSeraphin ListeCasimir

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/../bys/erreurssequence.liste"] {

	if {[regexp "ij" $Ligne]} { continue }

	scan $Ligne "%s %d %d" iOUj iSer jCas

	lappend ListeSeraphin $iSer
	lappend ListeCasimir  $jCas
    }

}

proc ChargeTFAsDeGretta {aTab FileTFAs} {

    upvar $aTab Tab

    set TFAs [ContenuDuFichier $FileTFAs]
    foreach TFA [split $TFAs ">"] {
	set TFA [string trim $TFA]
	if {$TFA == ""} {continue}
	set TFA ">$TFA"

	set Entete [string trim [EnteteDuTexteTFA $TFA]]
	set Id                  [lindex [split $Entete ";"] 0  ]
	set Id     [string trim [lindex [split $Id     ":"] end]]
	regsub ">" $Entete "" Entete
	set Entete "$Id $Entete"

	set Seq [QueLaSequenceDuTexteTFA $TFA]
	set TFA [SequenceFormatTFA $Seq $Entete]

	set Tab($Id) $TFA
    }
    return $aTab

}

proc ChargeTaxIJNC {} {

    global TaxI
    global TaxJ
    global TaxN
    global TaxC

    set TaxI("EstCharge") 1
    set TaxJ("EstCharge") 1
    set TaxN("EstCharge") 1
    set TaxC("EstCharge") 1


    set FichierSwiss "/prot/gcgswissprot/swissprot.ref"
#    set FichierSwiss "[HomeRipp]/sw.ref"

    set FichierTaxI "[GscopeDatabaseDir Common]/fiches/taxi"
    set FichierTaxJ "[GscopeDatabaseDir Common]/fiches/taxj"
    set FichierTaxN "[GscopeDatabaseDir Common]/fiches/taxn"
    set FichierTaxC "[GscopeDatabaseDir Common]/fiches/taxc"
    set ErrorLogI   "[GscopeDatabaseDir Common]/fiches/error_taxi.log"
    set ErrorLogN   "[GscopeDatabaseDir Common]/fiches/error_taxn.log"
    set ErrorLogC   "[GscopeDatabaseDir Common]/fiches/error_taxc.log"

    if {[file exists $FichierTaxI]} {
	if {[file exists $FichierTaxI]} { array set TaxI [LesLignesDuFichier $FichierTaxI] }
	if {[file exists $FichierTaxJ]} { array set TaxJ [LesLignesDuFichier $FichierTaxJ] }
	if {[file exists $FichierTaxN]} { array set TaxN [LesLignesDuFichier $FichierTaxN] }
	if {[file exists $FichierTaxC]} { array set TaxC [LesLignesDuFichier $FichierTaxC] }
	return
    }

    catch {unset OS}
    catch {unset OX}
    catch {unset OC}
    catch {unset LOS}
    catch {unset LOX}
    catch {unset LesOS}
    catch {unset LesOX}
    set OX ""
    set OldAccess ""
    set n 9999
    set FS [open $FichierSwiss "r"]
    while {[gets $FS Ligne]>=0} {
	if {[regexp "^>" $Ligne]} {
	    if { [expr $n%100==0] } { Espionne $n }
	    if { ! [incr n -1] } { break }
	    if {[info exists DejaVu($OX)] || ! [regexp -nocase "NCBI_TaxID=" $OX]} { continue }
	    set LesS [LesChampsIndividuels $OS]
	    regsub -nocase "NCBI_TaxID=" $OX "" OX
	    set LesX [LesChampsIndividuels $OX] 
	    if {[llength $LesS]!=[llength $LesX]} {
		FaireLire "Different list length\n $OS\n$OX"
		catch {unset OS}
		catch {unset OX}
		catch {unset OC}
		catch {unset LOS}
		catch {unset LOX}
		catch {unset LOC}
		catch {unset LesOS}
		catch {unset LesOX}
		regsub {>+} $Ligne "" OldAccess
		continue
	    }
	    if {[llength $LesS]==1} {
		foreach S $LesS X $LesX {
		    if { ! [info exists TaxN($X)]} { set TaxN($X) $S }
		    if { ! [info exists TaxI($S)]} { set TaxI($S) $X }
		    if {$S!=[set TaxN($X)]} {
			AppendAuFichier $ErrorLogI  "\nI saw already \n[set TaxN($X)]\n instead of\n$S\n$OldAccess for $X" 
			break 
		    }
		    if {$X!=[set TaxI($S)]} {
			AppendAuFichier $ErrorLogN  "\nI saw already \n[set TaxI($S)]\n instead of\n$X\n$OldAccess for $X" 
			break
		    }
		    set TN $S
		    while {[set TN [CondenseTaxName $TN]]!=""} {
			set TaxJ($TN) $X
		    }
		}
		if {[info exists OC]} {
		    set X [lindex $LesX 0]
		    set Class $OC
		    if {[info exists TaxC($X)] && [set TaxC($X)]!=$Class} {
			AppendAuFichier $ErrorLogC  "\nI saw already \n[set TaxC($X)]\n instead of\n[set TaxC($X)] \n$\n$OldAccess for $X"
			break
		    }
		    set TaxC($X) $Class
		    set S [lindex $LesS 0]
		    if {[info exists TaxC($S)] && [set TaxC($S)]!=$Class} {
			AppendAuFichier $ErrorLogClass  "\nI saw already \n[set TaxC($S)]\n instead of\n[set TaxC($S)] \n$\n$OldAccess for $S"
			break
		    }
		    set TaxC($S) $Class
		}
	    }
	    set DejaVu($OX) 1
	    catch {unset OS}
	    catch {unset OX}
	    catch {unset OC}
	    catch {unset LOS}
	    catch {unset LOX}
	    catch {unset LOC}
	    catch {unset LesOS}
	    catch {unset LesOX}
	    regsub {>+} $Ligne "" OldAccess
	    continue
	}
	if {[regexp "^OS " $Ligne]} {
	    if { ! [info exists LOS]} { set LOS {} }
	    regsub {^OS +} $Ligne "" O
	    lappend LOS $O
	    if {[regexp {\.$} $Ligne]} {
		set OS [join $LOS " "]
	    }
	}
	if {[regexp "^OC " $Ligne]} {
	    if { ! [info exists LOC]} { set LOC {} }
	    regsub {^OC +} $Ligne "" O
	    lappend LOC $O
	    if {[regexp {\.$} $Ligne]} {
		set OC [join $LOC " "]
	    }
	}
	if {[regexp "^OX " $Ligne]} {
	    if { ! [info exists LOX]} { set LOX {} }
	    regsub {^OX +} $Ligne "" O
	    lappend LOX $O
	    if {[regexp {\;$} $Ligne]} {
		set OX [join $LOX " "]
	    }
	}
    }
    close $FS
    SauveLesLignes [array get TaxI] dans $FichierTaxI
    SauveLesLignes [array get TaxJ] dans $FichierTaxJ
    SauveLesLignes [array get TaxN] dans $FichierTaxN
    SauveLesLignes [array get TaxC] dans $FichierTaxC
    return

}

proc ChargeTissueType {aTab FichierTissueType} {

    upvar $aTab Tab
    set Tab(LesTissues) {}

    if {![file exists $FichierTissueType]} {return}

    set Tab(LesNoms) {}
    set F [open $FichierTissueType]
    while {[gets $F Ligne]>=0} { 
	if {$Ligne == ""} {continue}
	set LaLigne [split $Ligne "\t"]
	set Nom     [lindex $LaLigne 0]
	set Acc     [lindex $LaLigne 1]
	if {$Acc == "NoESTFound"} {continue}

	set Tissue  [string tolower [lindex $LaLigne 3]]

	if {![info exists Tab($Nom,LesTissues)]} {
	    lappend Tab(LesNoms)                  $Nom
	    set Tab($Nom,LesTissues)              {}
	    set Tab($Nom,LesEST)                  {}
	}
	if {![info exists Tab(EST,$Acc,LesTissues)]} {
	    set Tab(EST,$Acc,LesTissues)          {}
	    set Tab(EST,$Acc,LesNoms)             {}
	}
	if {![info exists Tab(Tissue,$Tissue,LesNoms)]} {
	    set     Tab(Tissue,$Tissue,LesNoms)   {}
	    set     Tab(Tissue,$Tissue,LesEST)    {}
	    set     Tab(Tissue,$Tissue,n)         0
	    lappend Tab(LesTissues)               $Tissue
	}
	incr Tab(Tissue,$Tissue,n)

	if {![info exists Tab($Nom,Tissue,$Tissue,n)]} {
	    set Tab($Nom,Tissue,$Tissue,n)      0
	    set Tab($Nom,Tissue,$Tissue,LesEST) {}
	    lappend Tab($Nom,LesTissues)        $Tissue
	    lappend Tab(Tissue,$Tissue,LesNoms) $Nom
	}
	incr Tab($Nom,Tissue,$Tissue,n)

	if {![info exists Tab($Nom,Tissue,$Tissue,EST,$Acc,n)]} {
	    set     Tab($Nom,Tissue,$Tissue,EST,$Acc,n) 0
	    lappend Tab($Nom,Tissue,$Tissue,LesEST)     $Acc
	}
	incr Tab($Nom,Tissue,$Tissue,EST,$Acc,n)

	if {![info exists Tab(EST,$Acc,Tissue,$Tissue,n)]} {
	    set Tab(EST,$Acc,Tissue,$Tissue,n)  0
	    lappend Tab(EST,$Acc,LesTissues)    $Tissue
	    lappend Tab(Tissue,$Tissue,LesEST)  $Acc
	}
	incr Tab(EST,$Acc,Tissue,$Tissue,n)
    }
    close $F
    return $aTab

}

proc ChargeTmCount {{PAB ""}} {

    
    Wup "Calcul le Tm pour les regions de PAB et comptabilise le nombre de fois qu il est rencontre"
    Wup "Stock les resultats dans TabDesTms"
    Wup "Utilisable pour un PAB ou une sequence"

    global TabDesTms
    
    if {$PAB==""} {return ""}
      
    #Attention il faut une query, sinon pas de taille ....
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set Repnuctfa "[RepertoireDuGenome]/nuctfa"

    set FichierQuery $PAB
    if {[regexp {/} $PAB]} {set PAB [file tail $PAB]}
    if {[file exists $FichierQuery]} {
	set FichierQuery $FichierQuery
    } elseif { [file exists "$RepmRNA/$PAB"]} {
	set FichierQuery    "$RepmRNA/$PAB"
    } elseif  {[file exists "$Repnuctfa/$PAB"]} {
	set FichierQuery    "$Repnuctfa/$PAB"
    } else {
	set  LaSeq      $PAB
	if {         $LaSeq ==""}   {Espionne "$FichierQuery no sequence available";return ""}
	if {[IsItDNA $LaSeq]=="-1"} {Espionne "$LaSeq is not a valid DNA sequence";return ""}
	set TailleQuery [string length $LaSeq]
    }
    
    if {! [info exists LaSeq]} {
	set  LaSeq      [QueLaSequenceDuFichierTFA $FichierQuery]
	if {$LaSeq==""} {Espionne "$FichierQuery no sequence available";return ""}
	set TailleQuery [string length $LaSeq]
    }
    set  LaSeq [split $LaSeq ""]

    if {! [info exists TabDesTms(TmMin)]}     {set TabDesTms(TmMin)  99999.9}
    if {! [info exists TabDesTms(TmMax)]}     {set TabDesTms(TmMax)      0.0}
    if {! [info exists TabDesTms(TmMoyenne)]} {set TabDesTms(TmMoyenne)  0.0} 
    if {! [info exists TabDesTms(TmTotal)]}   {set TabDesTms(TmTotal)    0.0} 
    if {! [info exists TabDesTms(NbTm)]}      {set TabDesTms(NbTm)         0} 
    if {! [info exists TabDesTms(NbSeq)]}     {set TabDesTms(NbSeq)        0} 
    
    incr TabDesTms(NbSeq)

    set nbTm         0
    set TmTotal    0.0
    set DebutSeq     1

    set  LengthOligo [LesParametresDuDesign LengthOligo "LaValeurMerci"]
    if {$LengthOligo==""} {set LengthOligo 60}

    set  Methode     [LesParametresDuDesign TmMethod "LaValeurMerci"]
    if {$Methode    ==""} {set Methode "NearestNeighbor"}

    set  Pas         [LesParametresDuDesign Step "LaValeurMerci"]
    if {$Pas        ==""} {set Pas 10}
 
    set Fin         $LengthOligo

    #Calcul des Tms sur une sliding window de taille LengthOligo et de pas j
    for {set Debut $DebutSeq} {$Fin <= $TailleQuery} {incr Debut $Pas} {
	set Fin [expr $Debut + $LengthOligo - 1] 
	if {![expr $Fin <= $TailleQuery]}          {break}
		
	set Seq [join [lrange $LaSeq [expr $Debut - 1] [expr $Fin - 1]] ""]
	if {[string length $Seq]<$LengthOligo}     {continue}

	set Tm [format "%.1f" [CalculTmDeLaSeq $Seq "" "" "$Methode"]]
	if {$Tm=="-1"} {continue} elseif {$Tm==""} {return ""}	

	if {! [info exists TabDesTms($Tm)]} {
	    set  TabDesTms($Tm) 1
	} else {
	    incr TabDesTms($Tm)
	}
	incr nbTm
	set TmTotal [expr $TmTotal + $Tm]

	if {$Tm > [set TabDesTms(TmMax)]} {set TabDesTms(TmMax) $Tm}
	if {$Tm < [set TabDesTms(TmMin)]} {set TabDesTms(TmMin) $Tm}
    }
    
    #Pour la moyenne des Tms
    if {[set TabDesTms(TmTotal)]!="0.0"} {
	set  TabDesTms(TmTotal) [expr [set TabDesTms(TmTotal)] + $TmTotal]
    } else {
	set  TabDesTms(TmTotal) $TmTotal
    } 
    if {[set TabDesTms(NbTm)]!="0"} {
	set  TabDesTms(NbTm) [expr [set TabDesTms(NbTm)] + $nbTm]
    } else {
	set  TabDesTms(NbTm) $nbTm
    } 

    if {0} {
	#Moyenne des Tms
	Espionne "On est qd meme passe pas Tmmoyenne"
	set Moyennetmp [format "%.1f" [expr ($TmTotal*1.0)/$nbTm]]
	if {[set TabDesTms(TmMoyenne)]!="0.0"} {
	    set  TabDesTms(TmMoyenne) [format "%.1f" [expr (([set TabDesTms(TmMoyenne)] + $Moyennetmp)*1.0)/2.0] ]
	} else {
	    set  TabDesTms(TmMoyenne) $Moyennetmp
	}
	
	#Espionne "$PAB -- Moyen $Moyennetmp Nb $nbTm [set TabDesTms(NbTm)] Total $TmTotal [set TabDesTms(TmTotal)]"
    }
    return ""

}

proc ChargeX {{Repertoire ""}} {

    
    if {$Repertoire==""} { set Repertoire "/genomics/g18/PuzzleFit/msf" }
    puts "Repertoire: $Repertoire"
    
    set r [glob -directory $Repertoire *]
    
    foreach fichiermsf $r {
	puts "fichiermsf: $fichiermsf"
	CreeXmlAnnotePourUnMsfX2	$fichiermsf "" ""
    }    

}

proc ChatAlannot {args} {

    set R [eval $args]
    return $R

}

proc Che2 {} {

    global T LNOrdali

    set Lche [list]
    set n1 "s01"
    set done 0
    foreach k [lrange [array names T "$n1,*"] 0 1] {
	lassign [split $k ,] n1 ag1
	set Lcag [list $n1 $ag1]
	set done 0
	puts "$k"
	
	while {! $done} {
	    set i [lsearch $LNOrdali $n1]
	    puts "$i $n1"
	    incr i 
	    if {$i == [llength $LNOrdali]} {
		set i 0
		set done 1
	    }
	    set n2 [lindex $LNOrdali $i]
	    puts "$i $n2"
	    set Lf [lsearch -exact -all -inline -index 0 $T($n1,$ag1) $n2]
	    puts "Lf [llength $Lf] Lcag [llength $Lcag]\n"
	    set Ltmp [list]
	    foreach c $Lcag {
		foreach f $Lf {
		    lassign $f n2 ag2 sc2
		    lappend Ltmp [list {*}$c $n2 $ag2]
		}
	    }
	    set Lcag $Ltmp
	    set n1 $n2
	}
	lappend Lche {*}$Lcag
    }

    return $Lche

}

proc CheckARPClassificationAA {Fichier} {


    Wup "Classification des ARP par leur composition en acides amines --> Nicolas Wicker"

    #Number of clusters : 21
    # 
    #Cluster 0 ; size=14
    #AAH52039        0.067   0.018   0.044   0.099   0.032   0.062   0.018   0.032   0.037
    
    set Nb ""

    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {  [regexp -nocase "^Number of" $Ligne]} {continue}
	if {  [regexp -nocase "^Cluster"   $Ligne]} {
	    set Nb ""

	    regexp -nocase {^Cluster ([0-9]+)} $Ligne tmp Nb
	    if {! [info exists TabCluster(Cluster)]} {
		set TabCluster(Cluster) ""
	    }
	    lappend TabCluster(Cluster) $Nb

	    Espionne "Cluster $Nb"

	    continue
	}
	if {$Nb == ""} {continue}
	set Acc        [lindex $Ligne 0]
	set ARPFamille [InterrogeLesInfosDesARPs [string toupper $Acc] Categorie]
	regsub -all {\-\-\-\-} $ARPFamille "" ARPFamille
	regsub           "Les" $ARPFamille "" ARPFamille
	set Org [InterrogeLesInfosDesARPs [string toupper $Acc] Organisme]
	set Def [InterrogeLesInfosDesARPs [string toupper $Acc] Definition]

	Espionne "[format "%8s %6s %s" $Acc $ARPFamille $Org]"

	if {! [info exists TabCluster($Nb,$ARPFamille)]} {
	    set TabCluster($Nb,$ARPFamille) 0
	}
	incr TabCluster($Nb,$ARPFamille) 
    }
    close $F
    
    return ""

}

proc CheckARPSpecificDomainsForQuery {Query VraiAccess AccessDeRef {FichierMACS ""} {Famille ""}} {


    Wup "Permet de decider par rapport a un MACS pour les domaines si un access contient ou non les insertions voulues"
    
    if {! [file exists $FichierMACS] || $FichierMACS=="" || $Famille==""} {return "-1"}
    
    set RepARP         "[RepARPAnno]"
    set RepMACS        "$RepARP/ARP_MACS"

    set RepARP_Results "[RepARPAnnoWeb]"
    set RepMACSResults "$RepARP_Results"

    #ON CHERCHE LES DOMAINES AUX POSITIONS IMPORTANTES

    set LesFichiersASupprimer ""
    set LesTextLog            ""
    set MaxLengthIN          "8"
    set PAccDomCutoff     "50.0"
    set PDomCutoff        "90.0"
    set PIDCutoff         "10.0"
    set PLengthDomain      "0.5"

    #1 Les positions de reference des insertions de l access de reference
    #####################################################################
    #  On ne cherche que les insertions (IN)
    #set  LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef     LesPositions]
    #set  LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef DEL LesPositions]
    set  LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef IN  LesPositions]
    #No insertions yet determined
    if {$LesPositionsDesDomaines==""} {return "-2"}

    #1 On ne possede que la borne gauche de l insertion on ajoute donc + 1 pour avoir la fin
    #                 PosD        PosD+1
    #                  |           |
    # TMYPGIADRMQKEITALA...........PSTMKIKIIAPPERKYS
    # TMYPGLPSRLERELKQLYLERVLKGDVEKLSKFKIRIEDPPRRKHM
    #                  |           |
    #                 InD         InF
    set             LesDFPositionsDesDomaines ""
    foreach Position $LesPositionsDesDomaines {
	#On test si le domaine est specifique (conserve) pour toutes les proteines de la famille
	set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Remarque]
	if {$SpeOuPas == "" || [regexp -nocase "not specific" $SpeOuPas]} {continue}
	set  Taille  [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $Position Taille]
	if {$Taille   == "" || $Taille < $MaxLengthIN}                    {continue}

	lappend LesDFPositionsDesDomaines $Position
	lappend LesDFPositionsDesDomaines [expr {$Position + 1}]
    }    
    set  LesDFPositionsDesDomaines [join $LesDFPositionsDesDomaines " "]
    if {$LesDFPositionsDesDomaines == ""} {return "-2"}

    if {[Verbose_Mode]} {
	set    TextLog "Looking for positions : $LesDFPositionsDesDomaines"
	AjouteAuARPLog "$TextLog"
    }
    #2 Recherche des positions equivalentes pour ces insertions dans la query
    #########################################################################
    #  Creation du fichier pour aller questionner l alignement avec aln_pos
    set FichierPosDomTmpDeRef "$RepMACSResults/PosDomTmpDeRef_${VraiAccess}_${Famille}"
    if {[file exists $FichierPosDomTmpDeRef]} {file delete -force $FichierPosDomTmpDeRef}
    set LesLignes [list $AccessDeRef $LesDFPositionsDesDomaines $Query]
    AppendAuFichier  $FichierPosDomTmpDeRef [join $LesLignes "\n"]
    set LesLignes ""
    lappend LesFichiersASupprimer $FichierPosDomTmpDeRef
    
    #  On questionne l alignement avec aln_pos
    #  On recherche les positions des insertions de la ref dans notre query pour toutes les insertions
    #  Creation d un fichier contenant les positions equivalentes qui ont ete recherchees pour la query
    set               FichierResTmp "$RepMACSResults/PosDomEquiTmpDeRef_${VraiAccess}_${Famille}"
    if {[file exists $FichierResTmp]} {file delete -force $FichierResTmp}
    set  Result [RetrievePositionsInMACS "$FichierMACS" $FichierPosDomTmpDeRef "$FichierResTmp"]
    if {$Result=="-1"} {Espionne "Pb RetrieveResidueInMACS";return ""}
    lappend LesFichiersASupprimer $FichierResTmp

    #  Boucle sur les couples de positions (debut et fin) de la query pour tous les domaines
    set i             0
    set NbDomainOk    0
    set NbDomainTotal 0
    set NbGap         0
    #Ici se sont les positions demandees
    set LesPositions [InterrogeRetrievePositionsInMACS $FichierResTmp $Query LesPositions]

    #  Tableau contenant les equivalence entres les positions de la query et la reference
    #  Permet de regler les problemes lies au N-Ter et au C-Ter (a faire)
    foreach PosQ $LesPositions PosRef [split $LesDFPositionsDesDomaines " "] {
	set TabEquiQToRef($PosQ) $PosRef
    }

    #  La liste des access des tests contre lesquelles la query va etre testee
    set AccessToTest     ""
    set AccessToTest_Tmp ""
    #Access presents dans les definitions des domaines (attention on ne dispose pas de tous les access du MACS)
    #set AccessToTest_Tmp [split [string trim [join [InterrogeLesDomainesDesARPs $Famille LesAccess] " "]] " "]
    #Access presents dans les definitions des InfosDesARPs (attention pb Majuscules/minuscules)
    #set AccessToTest_Tmp [split [string trim [join [InterrogeLesInfosDesARPs $Famille LesAccess] " "]] " "]
    #Access presents dans le MACS
    set AccessToTest_Tmp [split [string trim [join [ListeDesAccessPresentsDansLeMACSDeLaFamille $Famille] " "]] " "]
    foreach A $AccessToTest_Tmp {
	if {[regexp -nocase $AccessDeRef $A]} {continue}
	lappend AccessToTest $A
    }
    set AccessToTest [join $AccessToTest "\n"]

    foreach {DomainD DomainF} $LesPositions {
	#Verification des positions initiales pour les extremites N-Ter et C-Ter
	#si N-Ter on remet la position de debut a 1
	#si C-Ter on ne touche pas car le prog de Julie va prendre la fin automatiquement (bug ??)
	set  PosEquiDansRef [set TabEquiQToRef($DomainD)]
	if {$PosEquiDansRef=="1"} {
	    #On a une extension en N-Terminal
	    set DomainD 1
	} 

	incr i
	incr NbDomainTotal

	#3 Calcul de la taille de l insertion pour la query
	###################################################
	set  TailleInsertQuery [expr {$DomainF - $DomainD}]
	if {$TailleInsertQuery < [expr {$MaxLengthIN - 2}] || $DomainD == $DomainF || $DomainD == "0" || $DomainF == "0"} {
	    #La query ne possede donc pas l insertion qui doit a la bases faire 8 de long et il n y a rien
	    #Le domaine est tout de meme comptabilise mais comme absent
	    #Espionne "Problem with positions (${DomainD}/${DomainF}) or domain length ($TailleInsertQuery)."
	    continue
	}

	#4 Calcul des caracteristiques des zones eventuelles d insertions
	#################################################################
	#  Recuperation du pourcentage d identite du domaine teste pour les access de test
	#  Creation d un fichier pour aller questionner l alignement avec aln_insert
	#  Creation d un fichier contenant les positions de la query pour rechercher les PID dans les insertions
	set               FichierPIDPosDomTmpDeRef "$RepMACSResults/PIDPosDomTmpDeRef${i}_${VraiAccess}_${Famille}"
	if {[file exists $FichierPIDPosDomTmpDeRef]} {file delete -force $FichierPIDPosDomTmpDeRef}
	set LesLignes [list $Query "$DomainD $DomainF" $AccessToTest]
	AppendAuFichier  $FichierPIDPosDomTmpDeRef [join $LesLignes "\n"]
	set LesLignes ""
	lappend LesFichiersASupprimer $FichierPIDPosDomTmpDeRef

	#  On questionne l alignement avec aln_insert
	#  On recherche les PID des zones etant des insertions dans les seq de references
	set               FichierPIDDomResTmp "$RepMACSResults/PIDDomTmpDeRef${i}_${VraiAccess}_${Famille}"
	if {[file exists $FichierPIDDomResTmp]} {file delete -force $FichierPIDDomResTmp}
	set  Result [RetrievePIDBetweenPosInMACS "$FichierMACS" $FichierPIDPosDomTmpDeRef "$FichierPIDDomResTmp"]
	if {$Result=="-1"} {Espionne "Pb RetrievePIDBetweenPosInMACS Taille Insertion";continue}
	lappend LesFichiersASupprimer $FichierPIDDomResTmp
	
	#5 Calcul de la taille de l insertion dans les access testes
	############################################################
	#  On questionne l alignement avec aln_pos
	#  On recherche les positions des zones de la query pour les seq de test
	set               FichierPosEquiPosDomResTmp "$RepMACSResults/PosEquiPosDomResTmp${i}_${VraiAccess}_${Famille}"
	if {[file exists $FichierPosEquiPosDomResTmp]} {file delete -force $FichierPosEquiPosDomResTmp}
	set  Result [RetrievePositionsInMACS "$FichierMACS" $FichierPIDPosDomTmpDeRef "$FichierPosEquiPosDomResTmp"]
	if {$Result=="-1"} {Espionne "Pb RetrievePositionsInMACS";continue}
	lappend LesFichiersASupprimer $FichierPosEquiPosDomResTmp

	#6 Verification pour les access de reference de la presence ou non d un domaine dans la query
	#############################################################################################
	set LesAccessTestes [split [string trim [join [InterrogeRetrievePIDBetweenPosInMACS $FichierPIDDomResTmp LesAccess] " "]] " "]
	set NbAccTeste 0
	set NbAccOk    0
	foreach Access $LesAccessTestes {
	    set Debut               ""
	    set Fin                 ""
	    set PID                 ""
	    set DebutAccessTeste    ""
	    set FinAccessTeste      ""
	    set TailleInAccessTeste ""
	    
	    set Debut  [InterrogeRetrievePIDBetweenPosInMACS $FichierPIDDomResTmp Debut]
	    set Fin    [InterrogeRetrievePIDBetweenPosInMACS $FichierPIDDomResTmp Fin]
	    set PID    [InterrogeRetrievePIDBetweenPosInMACS $FichierPIDDomResTmp $Access $Debut $Fin PID]
	    
	    #5 Taille reelle de linsertion dans les access testes 
	    set DebutAccessTeste    [InterrogeRetrievePositionsInMACS $FichierPosEquiPosDomResTmp $Access $Debut Position]
	    set FinAccessTeste      [InterrogeRetrievePositionsInMACS $FichierPosEquiPosDomResTmp $Access $Fin   Position]
	    set TailleInAccessTeste [expr {$FinAccessTeste - $DebutAccessTeste}]
	    if {$TailleInAccessTeste == "0"} {continue}
	    
	    incr NbAccTeste

	    # On conserve pour un access teste le domaine si
	    #  - le PID est superieur au cutoff
	    #  - la Taille de l IN dans la query > celle de l access teste 
	    #  - la Taille de l IN dans la query pas < plus 50 % celle de l access teste 
	    if {$PID >= $PIDCutoff && ( $TailleInsertQuery >= $TailleInAccessTeste || $TailleInsertQuery > [expr {$TailleInAccessTeste - ($TailleInAccessTeste * $PLengthDomain)}] )} {
		if {$TailleInsertQuery!="0"} {
		    set NbAccOk [expr {$NbAccOk + 1}]
		}
	    }

	    if {[Verbose_Mode]} {
		set    TextLog "[format "%9s%2d: %8s %4d %4d %5.1f %3d %3d" Insertion $i $Access $Debut $Fin $PID $TailleInAccessTeste $TailleInsertQuery]"
		lappend LesTextLog $TextLog
		#AjouteAuARPLog "$TextLog"
	    }
	}
	set  PercentAccOkForThisDomain "[expr {((1.0*$NbAccOk)/$NbAccTeste)*100.0}]"
	if {$PercentAccOkForThisDomain > $PAccDomCutoff} {
	    set NbDomainOk [expr {$NbDomainOk + 1}]
	} elseif {$NbAccOk > 0} {
	    #On regarde si au moins un access etait ok par rapport a la query
	    set NbGap      [expr {$NbGap + 1}]
	}
	
	LesResultatsARPAnalyses $Famille,$i,NbAccOk    $NbAccOk    "Positionne"
	LesResultatsARPAnalyses $Famille,$i,NbAccTeste $NbAccTeste "Positionne"
	
	DechargeRetrievePIDBetweenPosInMACS $FichierResTmp
	DechargeRetrievePositionsInMACS     $FichierPosEquiPosDomResTmp
    }

    if {[Verbose_Mode]} {
	#On stock le reste dans le souci d optimisation du temps de calcul (AppendAuFichier)
	AjouteAuARPLog "[join $LesTextLog "\n"]"
	set    TextLog "[format "All Domain: %2d / %2d and %2d" $NbDomainOk $NbDomainTotal $NbGap]"
	AjouteAuARPLog "$TextLog"
    }
    if {$NbDomainTotal == "0"} {
	set PercentDomainOk 0.0
    } else {
	set PercentDomainOk "[expr {((1.0*$NbDomainOk)/$NbDomainTotal)*100.0}]"
    }
    if {   $PercentDomainOk > $PDomCutoff} {
	#La query possede bien toutes les insertions et fait partie de cette famille d ARP
	set EstDeCetteFamille 1
    } else {
	#La query ne possede pas toutes les insertions
	#On estime les groupes avec Gap
	if {$NbDomainOk != "0" && [expr {$NbDomainOk + $NbGap}]>=[expr $NbDomainTotal]} {
	    #Elle peut faire partie de cette famille mais on es pas sur
	    set EstDeCetteFamille 2
	} else {
	    #Elle ne fait pas partie de cette famille d ARP
	    set EstDeCetteFamille 0
	}
    }
    LesResultatsARPAnalyses $Famille,NbDomainOk    $NbDomainOk    "Positionne"
    LesResultatsARPAnalyses $Famille,NbDomainTotal $NbDomainTotal "Positionne"
    LesResultatsARPAnalyses $Famille,NbDomainGap   $NbGap         "Positionne"

    DechargeRetrievePositionsInMACS $FichierResTmp
    foreach F $LesFichiersASupprimer {
	if {[file exists $F]} {file delete -force $F}
    }

    return "$EstDeCetteFamille"

}

proc CheckARPSpecificDomainsForQuery_All {{LesQuery ""} {Famille ""}} {


    set AccessDeRef "P02568"

    #set LesQuery [InterrogeLesInfosDesARPs LesAccess]

    #set LesQuery [InterrogeLesInfosDesARPs $Categorie LesAccess]
    #Espionne "$LesQuery"
    
    if {$LesQuery == ""} { 
	set LesQuery "ARP05"
	set LesQuery "Q870X5"
    }
    if {$Famille  == ""} {
	set Famille ARP2
    }

    #set MACS "[RepertoireDuGenome]/alignement_ARP/Actin_Complet3_9.rsf"
    set MACS "[RepertoireDuGenome]/alignement_ARP/ARPAnno/ARP_MACS/${Famille}.rsf"

    foreach Q $LesQuery {
	Espionne "$Q Vrai [InterrogeLesInfosDesARPs $Q Categorie]"
	#CheckARPSpecificResiduesForQuery $Q $AccessDeRef
	#set Res [CheckARPSpecificDomainsForQuery $Q $Q $AccessDeRef $MACS ARP2]
	set Res [CheckARPSpecificDomainsForQuery $Q $Q $AccessDeRef $MACS $Famille]
	#Espionne "$Res"
    }

}

proc CheckARPSpecificResiduesForQuery {Query VraiAccess AccessDeRef {FichierMACS ""} {Famille ""}} {


    Wup "Permet de decider par rapport a un MACS pour les residus si un access contient les residus voulus"
    
    if {! [file exists $FichierMACS] || $FichierMACS=="" || $Famille==""} {return "-1"}
    
    set RepARP          "[RepARPAnno]"
    set RepMACS         "$RepARP/ARP_MACS"

    set RepARP_Results  "[RepARPAnnoWeb]"
    set RepMACSResults  "$RepARP_Results"

    #ON CHERCHE LES RESIDUS AUX POSITIONS IMPORTANTES
    
    set LesFichiersASupprimer ""
    set LesTextLog            ""
    set PResCutoff        "90.0"
    set PGrpCutoff        "90.0"

    #1 Les positions de reference de l access de reference
    set  LesPositionsDesResidus [InterrogeLesResidusDesARPs $Famille $AccessDeRef LesPositions]
    if {$LesPositionsDesResidus==""} {return "-2"}
    
    if {[Verbose_Mode]} {
	set    TextLog "Looking for positions : $LesPositionsDesResidus"
	AjouteAuARPLog "$TextLog"
    }
    
    #2 On fait le fichier pour aller questionner l alignement avec aln_res
    #  Creation d un fichier contenant les positions a rechercher par rapport a la reference
    set FichierPosTmpDeRef "$RepMACSResults/Tmp_PosResDeRef_${VraiAccess}_${Famille}"
    if {[file exists $FichierPosTmpDeRef]} {file delete -force $FichierPosTmpDeRef}
    set LesLignes [list $AccessDeRef $LesPositionsDesResidus $Query]
    AppendAuFichier  $FichierPosTmpDeRef [join $LesLignes "\n"]
    set LesLignes ""
    lappend LesFichiersASupprimer $FichierPosTmpDeRef
    
    #2 On questionne l alignement avec aln_res
    #  Creation d un fichier contenant les positions qui ont ete recherchees pour la query
    set FichierResTmp "$RepMACSResults/Tmp_ResResDeRef_${VraiAccess}_${Famille}"
    if {[file exists $FichierResTmp]} {file delete -force $FichierResTmp}
    set  Result [RetrieveResidueInMACS "$FichierMACS" $FichierPosTmpDeRef "$FichierResTmp"]
    if {$Result=="-1"} {Espionne "Pb RetrieveResidueInMACS";return "-1"}
    lappend LesFichiersASupprimer $FichierResTmp
    
    #3 Analyse pour comparer les residus
    #3 On recupere les nombres de groupes de residus pour l analyse
    set LesGroupesDeResidus [InterrogeLesResidusDesARPs $Famille LesGroupes]
    #On va boucler sur les groupes de residus
    #########################################
    
    set NbGroupTotal 0
    set NbGroupOk    0
    set NbGroupGap   0
    foreach Groupe $LesGroupesDeResidus {
	incr NbGroupTotal
	
	if {[Verbose_Mode]} {
	    set    TextLog "Residue Group $Groupe :"
	    AjouteAuARPLog "$TextLog"
	}

	#On cherche les positions equivalentes pour chaque groupe de residus dans notre reference
	#  ex: Groupe 1 pour ARP2 = 27 et 28 
	set LesPositionsDesRes [InterrogeLesResidusDesARPs $Famille Groupe $Groupe Access $AccessDeRef LesPositions]
	
	set NbResiduTotal 0
	set NbResiduOk    0
	set NbGap         0
	foreach PosDeRes $LesPositionsDesRes {
	    #Le residu a la position pour la query
	    #  ex: Groupe 1 pour ARP2 = (pos 27) on a "N"
	    set Residu         [InterrogeLesResidusDesARPs     $Famille $AccessDeRef $PosDeRes Res]
	    #On cherche le residu a la position PosDeRes dans le subject (cf RetrieveResidueInMACS)
	    set Residu2Compare [InterrogeRetrieveResidueInMACS $FichierResTmp $Query $PosDeRes Residu]
	    
	    if {[Verbose_Mode]} {
		set    TextLog "[format "%6s %7s vs %7s %1s" $AccessDeRef $Residu $Query $Residu2Compare]"
		lappend LesTextLog $TextLog
		#AjouteAuARPLog "$TextLog"
	    }
	    incr NbResiduTotal
	    if {$Residu2Compare!="-" && ([regexp $Residu2Compare $Residu] || $Residu=="X")} {
		incr NbResiduOk 
	    } else {
		if {$Residu2Compare=="-"} {
		    #On estime les residus avec Gap
		    incr NbGap
		}
	    }
	}
	set PercentResiduesOk "[expr {((1.0*$NbResiduOk)/$NbResiduTotal)*100.0}]"

	LesResultatsARPAnalyses $Famille,$Groupe,NbResiduOk    $NbResiduOk    "Positionne"
	LesResultatsARPAnalyses $Famille,$Groupe,NbResiduTotal $NbResiduTotal "Positionne"
	LesResultatsARPAnalyses $Famille,$Groupe,NbGap         $NbGap         "Positionne"

	if {[Verbose_Mode]} {
	    #On stock le reste dans le souci d optimisation du temps de calcul (AppendAuFichier)
	    AjouteAuARPLog "[join $LesTextLog "\n"]"
	    set LesTextLog ""
	    set    TextLog "[format "%13s Gr %2d : %2d/%2d -- %2d Gap -- %5.1f %1s" $Query $Groupe $NbResiduOk $NbResiduTotal $NbGap $PercentResiduesOk %]"
	    AjouteAuARPLog "$TextLog"
	}
	if {$PercentResiduesOk > $PResCutoff} {
	    incr NbGroupOk
	} else {
	    #On decide si le groupe qui n est pas bon si c du au nb de Gap ou pas
	    if {[expr $NbResiduOk+$NbGap]==$NbResiduTotal} {
		incr NbGroupGap
	    }
	}
    }
    
    if {$NbGroupTotal=="0"} {
	set PercentGroupesOk "0.0"
    } else {
	set PercentGroupesOk [expr {((1.0*$NbGroupOk)/$NbGroupTotal)*100.0}]
    }
    if {   $PercentGroupesOk > $PGrpCutoff} {
	#La query possede tous les groupes de residus et fait partie de cette famille d ARP
	set EstDeCetteFamille 1
    } else {
	#La query ne possede pas tous les groupes de residus
	#On estime les groupes avec Gap
	if {$NbGroupOk!="0" && [expr {$NbGroupOk+$NbGroupGap}]>=[expr {$NbGroupTotal-1}]} {
	    #Elle peut faire partie de cette famille mais on es pas sur
	    set EstDeCetteFamille 2
	} else {
	    #Elle ne fait pas partie de cette famille d ARP
	    set EstDeCetteFamille 0
	}
    }

    LesResultatsARPAnalyses $Famille,NbGroupOk    $NbGroupOk    "Positionne"
    LesResultatsARPAnalyses $Famille,NbGroupTotal $NbGroupTotal "Positionne"
    LesResultatsARPAnalyses $Famille,NbGroupGap   $NbGroupGap   "Positionne"
    
    DechargeRetrieveResidueInMACS $FichierResTmp
    foreach F $LesFichiersASupprimer {
	if {[file exists $F]} {file delete -force $F}
    }

    return "$EstDeCetteFamille"

}

proc CheckARPSpecificResiduesForQuery_All {} {


    set AccessDeRef "P02568"

    set LesQuery [InterrogeLesInfosDesARPs LesAccess]

    set LesQuery [InterrogeLesInfosDesARPs $Categorie LesAccess]
    Espionne "$LesQuery"
    foreach Q $LesQuery {
	Espionne "$Q Vrai [InterrogeLesInfosDesARPs $Q Categorie]"
	#CheckARPSpecificResiduesForQuery $Q $AccessDeRef
	CheckARPSpecificResiduesForQuery $Q $AccessDeRef ARP9
    }

}

proc CheckBestProtmRNATFA {} {


    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    
    foreach PAB [ListeDesPABs] {
	set AccessBest [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" mRNA Access]
	set AccmRNATFA [AccessDuTFADumRNA "$RepmRNA/$PAB"]

	if {$AccessBest !="$AccmRNATFA"} {
	    Espionne "$PAB Best $AccessBest $AccmRNATFA"
	}
    }

}

proc CheckBlastStatus {Lignes} {

    set id [lsearch -regexp $Lignes "QBlastInfoBegin"]
    set if [lsearch -regexp $Lignes "QBlastInfoEnd"]
    if {$id == -1} {
	puts "Problem ! No Blast service information"
	if {[lsearch -regexp $Lignes "Server Error"] != -1} {
	    # Blast server Error
	    puts "Interrupted service !"
	    flush stdout
	    set Status "ServerError"
	} else {
	    puts "Blast Error :\n[join $Lignes \n]\n"
	    flush stdout
	    set Status "Error"
	}

	return [list 0 0 $Status]
    }

    set RID 0
    set RTOE 0
    set Status ""
    foreach l [lrange $Lignes $id+1 $if-1] {
	set l [string map {"\t" " " "=" " "} [string trim $l]]
	regsub -all { +} $l " " l
	lassign [split $l " "] what value
	switch $what {
	    "RID"    {set RID $value}
	    "RTOE"   {set RTOE $value}
	    "Status" {set Status $value}
	}
    }

    return [list $RID $RTOE $Status]

}

proc CheckChildsFull {Lin} {

    set Reste 0
    set Lout [list]
    foreach l $Lin {
	lassign $l f nb nc ng full
	
	# child is full, nothing to do
	if {$full} {
	    lappend Lout $l
	} else {
	    # plus d'echantillons que de Gold
	    if {$nb > $ng} {
		puts "  Warning  [format %7d $f] | $nb $ng samples > gold !"
		incr Reste [expr {$nb-$ng}]
		set nb $ng
		# Node is full !
		set full 1
	    }
	    # plus d'echantillons que d'enfants
	    if {$nb > $nc} {
		puts "  Warning  [format %7d $f] | $nb $nc samples > children !"
		incr Reste [expr {$nb-$nc}]
		set nb $nc
		# Node is full !
		set full 1
	    }
	    if {$nb == $ng || $nb == $nc} {
		set full 1
	    }
	    
	    lappend Lout [list $f $nb $nc $ng $full]
	}
    }
    
    return [list $Lout $Reste]

}

proc CheckCompletion {Qui {Quoi ""}} {

    global CheckCompletion

    if {$Quoi=="Signification"} { return $CheckCompletion($Qui) }
    if {$Quoi=="Color"} {
	set CC [CheckCompletion $Qui]
	set OK [CheckCompletion StatOk]
	if {$CC==$OK} {
	    set CheckCompletion(green) "CheckCompletion Ok"
	    return "green"
	} else {
	    set CheckCompletion(red) "CheckCompletion no copplete"
	    return "red"
	}   
    }

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

    set LesReps [list  prottfa  blastp  daedalushits  msf  msfLeon  macsimXml  ]
    foreach Nom [ListeDesPABs] {
	set N 1
	set Status 0
	set StatOk 0
	foreach Rep $LesReps {
	    set Fichier "[RepertoireDuGenome]/$Rep/$Nom"
	    if {[file exists $Fichier]} { incr Status $N }
	    incr StatOk $N
	    set CheckCompletion($StatOk) $Rep
	    set CheckCompletion($Rep) $StatOk
	    set N [expr $N*2]
	}
	set CheckCompletion(StatOk) $StatOk
	set CheckCompletion($Nom) $Status
    }
    set CheckCompletion("EstCharge") -1
    return [CheckCompletion $Qui]

}

proc CheckExpressionProfile {} {

    #fichier foldexpression dans /HeadNeckDD/fiches
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] {
	set DD [lindex $Ligne 0]
	set Prof [lindex $Ligne 1]
	set P($DD) $Prof
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/Jumeaux/TousLesJumeaux.final"] {
	set L [split $Ligne " "]
	if {[llength $L]==1} {continue}
	set i 0
	foreach Nom $L {
	    incr i
	    if {![info exists P($Nom)]} {return "pb profil $Nom"}
	    if {$i==1} {set Profil1 $P($Nom)}
	    if {$i>1} {
		set ProfilSuivant $P($Nom)
		if {$ProfilSuivant==$Profil1} {continue} else {lappend LesPbs $Ligne;break}
	    }
	}
    }
    Espionne [llength $LesPbs]
    SauveLesLignes $LesPbs dans "[RepertoireDuGenome]/fiches/LesPbsDeProfil"

}

proc CheckFiles {} {

    global OPjt PBV

    set Dir $OPjt(Dir)
    # Check for alignment files
    set Lf [lsort -unique [glob *]]
    set nfiles [llength $Lf]
    if {$nfiles == 0} {
	FaireLire "The project directory is empty !\nCan't do anything now ..."
	exit
    }

    # Cree arborescence ...
    file mkdir xml
    file mkdir ord
    file mkdir msf
    file mkdir tfa
    file mkdir Web
    file mkdir Logs
    # checks if a file exists several times in 
    # different formats
    set Lroot [list]
    set ic 0
    set PBV 0.
    foreach f $Lf {
	puts "Treating $f"
	set ext [string tolower [file extension $f]]
	if {$ext eq "." || $ext eq ""} {
	    set ext [string tolower [FormatDuFichierSequence $f]]
	    if {$ext eq "unknown"} {
		FaireLire "Can't find the alignment type contained in\n$f"
		continue
	    }
	} else {
	    set ext [string range $ext 1 end]
	}

	set cok [VerifieFormatAlignement $f $ext]
	if {! $cok} {
	    FaireLire "The file\n$f\nis not a [string toupper $ext] file !"
	    continue
	}
	set froot [file tail [file rootname $f]]
	lappend OPjt(FType,$ext) [list $f $froot]
	file rename $f [file join $ext $f]

	# convert into ORD file if necessary
	if {$ext ne "ord"} {
	    set olog ""
	    if {[catch {exec ordali [file join $ext $f] -convert ORD >& olog} Msg]} {
		puts "Msg : $Msg"
		puts "olog $olog"
		puts "doing ordali \[file join $ext $f\] -convert ORD >& olog"
		FaireLire "Problem converting file $f in Ordalie format !"
	    }
	    
	    file rename [file join $ext ${froot}.ord] [file join ord ${froot}.ord]
	}
	incr ic
	set PBV [expr {$PBV + 100./$nfiles}]
	update idletasks
    }

    CreateProjectDB
    LoadProject $OPjt(Dir)

    return

}

proc CheckForBestHitInDatabase {PAB Rep} {


    Wup "Permet de verifier si la query a un access dans le blast et de le rendre"
    Wup "Utilise InterrogeBestHitInDatabase qui va faire le calcul"
    Wup "Utiliser dans GUI ou voir aussi ReturnBestHitInDatabase"

    if {$PAB =="" || $Rep==""} {return ""}

    set FichierBlast "$Rep/${PAB}.blastn"
    
    if {![file exists $FichierBlast]} {Espionne "$FichierBlast do not exists";return ""}

    set Texte             ""
    set TailleQuery       [AskBlast                   $FichierBlast  Taille]
    set NbSubject         [AskBlast                   $FichierBlast  NbSubject]
    set AccessDeRef       [InterrogeBestHitInDatabase $FichierBlast  AccessDeRef]
    set BId               [InterrogeBestHitInDatabase $FichierBlast  BId]
    set LesBIdsBases      [InterrogeBestHitInDatabase $FichierBlast  LesBIdsBases]
    set InitialBId        [InterrogeBestHitInDatabase $FichierBlast  InitialBId]
    set InitialBIdAligned [InterrogeBestHitInDatabase $FichierBlast $InitialBId Aligned]

    #Test de la presence de la Query dans le blast
    ##############################################
    if {$NbSubject>0} {
	lappend Texte "Checking for $PAB with $TailleQuery nt(s)."
	if {$LesBIdsBases==""} {
	    lappend Texte "Seems not to have any equivalent in database."
	    lappend Texte "Be Careful with Design."
	} else {
 	    set BId           [InterrogeBestHitInDatabase $FichierBlast BId]
	    set PIdentity     0.95
	    set PRecouvrement 0.70
	    
	    lappend Texte "Best Id choosen : $InitialBId with $InitialBIdAligned nt(s) aligned."
	    
	    #Pourcentage d identite global: Aligne sur Total dans les alignements 
	    set IdGlobal      [InterrogeBestHitInDatabase $FichierBlast IdGlobal]
	    #Recouvrement de Q sur S ou inversement
	    #PCoverQuery   Query   par rapport au Subject
	    #PCoverSubject Subject par rapport au Query
	    set PCoverQuery   [InterrogeBestHitInDatabase $FichierBlast PCoverQuery]
	    set PCoverSubject [InterrogeBestHitInDatabase $FichierBlast PCoverSubject]
	    
	    if {$IdGlobal <= $PIdentity || $PCoverQuery<$PRecouvrement || $PCoverSubject<$PRecouvrement} {
		if {($PCoverQuery <= 0.2 || $PCoverSubject <= 0.2) || $IdGlobal <= 0.90} {
		    #On met tout de meme a zero car trop limite
		    lappend Texte "Is not equivalent to our query (\%Id [format "%.2f" $IdGlobal], Cover Q/S [format "%.2f" $PCoverQuery], Cover S/Q [format "%.2f" $PCoverSubject])."
		} else {
		    lappend Texte "Is weakly similar to our query (\%Id [format "%.2f" $IdGlobal], Cover Q/S [format "%.2f" $PCoverQuery], Cover S/Q [format "%.2f" $PCoverSubject])."
		}
		lappend Texte "Be Careful with this design."
	    } else {
		lappend Texte "Seems to be equivalent (\%Id [format "%.2f" $IdGlobal], Cover Q/S [format "%.2f" $PCoverQuery], Cover S/Q [format "%.2f" $PCoverSubject])."
		lappend Texte "Go on confident with this design."
	    }
	}
    } else {
	lappend Texte "Seems not to have any equivalent in database."
	lappend Texte "Be Careful with this design."
    }
    
    after idle {.fairelire.msg configure -wraplength 10i -background red -font "Courier 10 bold"}
    tk_dialog .fairelire "Please press OK" "[join $Texte "\n"]" {} 0 Acknowledge
    catch {destroy .fairelire}
    return ""

}

proc CheckForOligo {PAB FichierBlast {LogFile ""} {Output ""}} {

    
    Wup "Analyse la sequence pour le Tm, GC, Specificite ..."
    Wup "Ajout du classement de la sortie, des zones specifiques pour un design a facon."
    Wup "Ajout du choix de la query dans la banque (AccessDeRef) et design que pour cet access"
    Wup "Ajout de la gestion de AccessDeRef si vide"
    Wup "Ajout de la gestion des design ou il y trop de sequences par candidat au moment de la sauvegarde"
    Wup "22/10/2003"

    if {$PAB=="" || $FichierBlast==""} {return ""}
    if {    [file exists "$PAB"]} {
	set FichierQuery "$PAB"
    } else {AjouteAuLog "No File for the Query ($PAB)";return ""} 

    if {$LogFile == ""} {set LogFile "${PAB}.log"}
    if {$Output  == ""} {set Output  "${PAB}.oligo"}
    if {[file exists $Output] || [file exists $LogFile]} {AjouteAuLog "$PAB existe deja";return ""}
 
    #Les parametres du design
    #########################
    if {[BonNombreDeParametres]} {
	foreach  Parametre [list Step DataBase LengthOligo TmMethod TmLimit GCContentMinus GCContentPlus TmRange LesProhibes NbOligo NbContiguous IdLimit] {
	    set $Parametre [LesParametresDuDesign $Parametre "LaValeurMerci"]
	}
    } else {return ""}
    
    if {[regexp {\.masked$} $PAB]} {regsub -all {\.masked$} $PAB "" PAB}
    set PAB             [file tail $PAB]
    set AccessDeLaBoite [AccessDeLaBoite $PAB]
    #set AccessDeLaBoite [AccessDeLaBoite [file tail $PAB]]

    set TmLimitSup      [expr $TmLimit + $TmRange]
    set TmLimitInf      [expr $TmLimit - $TmRange]
    if {[expr $TmLimitInf<0]} {set TmLimitInf 0}
    set CaractereMasque "N"
    set LesProhibes     [linsert $LesProhibes 0 $CaractereMasque]
    set Pas             $Step
    set Tab(OnEnTient)  0
    #Qiagen parameters
    #set NbContiguous 20
 
    #Charge les resultats du Blast
    ##############################
    set SeuilId      "None"
    set TailleQuery  [AskBlast $FichierBlast Taille]
    set NbSubject    [AskBlast $FichierBlast NbSubject]

    set LaSeq [split [QueLaSequenceDuFichierTFA $FichierQuery] ""]
    set EnteteQuery  [   PremiereLigneDuFichier $FichierQuery]

    #Si on vient de nuctfa
    if {[regexp ":" $EnteteQuery]} {regsub -all -nocase " :" $EnteteQuery "" EnteteQuery}	
    AppendAuFichier $LogFile "Query Length : $TailleQuery"
    AppendAuFichier $LogFile "Oligo Requested: $LengthOligo nt between $TmLimitInf and $TmLimitSup with less than $NbContiguous contiguous and $IdLimit for X-hybridisation"

    #CHECK Query
    if {[LesParametresDuDesign QueryCheck "LaValeurMerci"]=="1"} {
	#Test de la presence de la Query dans le blast
	##############################################
	set AccessDeRef       ""
	if {$NbSubject>0} {
	    set PIdentity     0.95
	    set PRecouvrement 0.70
	    set LesBIdsBases  ""
	    set IdGlobal      0.0
	    set PCoverQuery   0.0
	    set PCoverSubject 0.0
	    
	    set     BId           [InterrogeBestHitInDatabase $FichierBlast InitialBId]
	    set  LesBIdsBases     [InterrogeBestHitInDatabase $FichierBlast LesBIdsBases]
	    if {$LesBIdsBases==""} {
		AppendAuFichier $LogFile "Query has no equivalent sequence in DataBase: No fitting sequence in Blast searches"
	    } else {
		#Pourcentage d identite global: Aligne sur Total dans les alignements 
		set  IdGlobal     [InterrogeBestHitInDatabase $FichierBlast IdGlobal]
		#Recouvrement de Q sur S ou inversement
		#PCoverQuery   Query   par rapport au Subject
		#PCoverSubject Subject par rapport au Query
		set PCoverQuery   [InterrogeBestHitInDatabase $FichierBlast PCoverQuery]
		set PCoverSubject [InterrogeBestHitInDatabase $FichierBlast PCoverSubject]
		set AccessDeRef   $BId
		
		if {$IdGlobal<$PIdentity || $PCoverQuery<$PRecouvrement || $PCoverSubject<$PRecouvrement} {
		    AppendAuFichier $LogFile "Query has no equivalent sequence in DataBase: $BId (\%Id [format "%.2f" $IdGlobal], Cover S/Q [format "%.2f" $PCoverQuery], Cover Q/S [format "%.2f" $PCoverSubject])."
		    #On ne met pas a zero pour preserver les cas limites de nos cutoffs
		    #set AccessDeRef ""
		    if {($PCoverQuery <= 0.2 || $PCoverSubject <= 0.2) || $IdGlobal <= 0.90} {
			#On met tout de meme a zero car trop limite
			set AccessDeRef ""
		    }
		} else {
		    AppendAuFichier $LogFile "Query has an equivalent sequence in DataBase: $BId (\%Id [format "%.2f" $IdGlobal], Cover S/Q [format "%.2f" $PCoverQuery], Cover Q/S [format "%.2f" $PCoverSubject])."
		}
	    }
	} else {
	    AppendAuFichier $LogFile "Query has no equivalent sequence in DataBase: No Hit found in Blast searches"
	    set AccessDeRef ""
	}
    } else {
	AppendAuFichier $LogFile "Query has maybe an equivalent sequence in DataBase but we did not check"
	set AccessDeRef ""
    }


    #Pour commencer a un autre endroit sur la Query
    ###############################################
    #Si il existe une zone particuliere pour la query on l utilise sinon on voit si il y en a une globale
    set     LesZones   [LesParametresDuDesign LesZones $PAB "LaValeurMerci"]
    if {   $LesZones==""} {
	set LesZones   [LesParametresDuDesign LesZones      "LaValeurMerci"]
    }
    if {   $LesZones == ""} {
	set LesZones   [list 1 $TailleQuery]
    } else {
	set LesTmps    [lsort -integer -increasing -index 0 $LesZones]
	set FinAvant   ""
	set DebutAvant ""
	set LesZones   ""
	set NbZones    [llength $LesTmps]
	set nb         0
	foreach Tmp $LesTmps {
	    set EdgeBegin [lindex $Tmp 0]
	    set EdgeEnd   [lindex $Tmp 1]
	    incr nb

	    if {$FinAvant=="" && $DebutAvant==""} {
		set DebutAvant $EdgeBegin
		set FinAvant   $EdgeEnd
		if {$nb==$NbZones} {lappend LesZones [list $DebutAvant $FinAvant]}
		continue
	    }
	    if {$EdgeBegin > $FinAvant} {
		lappend LesZones [list $DebutAvant $FinAvant]
		set DebutAvant $EdgeBegin
		set FinAvant   $EdgeEnd
	    } elseif {$EdgeEnd> $FinAvant} {
		set FinAvant   $EdgeEnd
	    }
	    if {$nb==$NbZones} {lappend LesZones [list $DebutAvant $FinAvant]}
	    continue
	}
    }

    foreach Zones $LesZones {
	set DebutDesign 1
	set Fin         $LengthOligo
	set FinDesign   $TailleQuery
	set EdgeBegin   [lindex $Zones 0]
	set EdgeEnd     [lindex $Zones 1]
	if {[info exists EdgeBegin] && $EdgeBegin!="" && $EdgeBegin>$DebutDesign} {set DebutDesign $EdgeBegin}
	if {[info exists EdgeEnd]   && $EdgeEnd  !="" && $EdgeEnd  <$TailleQuery} {set FinDesign   $EdgeEnd}
		
	#On teste la zone de design
	###########################
	for {set Debut $DebutDesign} {$Fin <= $FinDesign} {incr Debut $Pas} {
	    set nbGarde          0
	    set nbVire           0
	    set ProhibOnContinue 0

	    set Fin [expr $Debut  + $LengthOligo - 1] 
	    if {!   [expr $Fin   <= $FinDesign]} {break}
	    
	    set Seq [join [lrange $LaSeq [expr $Debut - 1] [expr $Fin - 1]] ""]
	    
	    AppendAuFichier $LogFile "\nMoving on: $Debut $Fin"
	    AppendAuFichier $LogFile "Sequence: $Seq"
	    
	    #Fin de la sequence ou non
	    ##########################
	    if {[string length $Seq]<$LengthOligo} {AppendAuFichier $LogFile "Length: TOOSHORT";continue} else {AppendAuFichier $LogFile "Length: OK"}
	    
	    #Module Determination de Sequences Prohibees
	    ############################################
	    if {$LesProhibes!=""} {
		foreach Prohib $LesProhibes {
		    if {[regexp $Prohib $Seq]} {set ProhibOnContinue 1;break}
		}
		if {$ProhibOnContinue==1} {
		    AppendAuFichier $LogFile "Prohibited: PROHIBES"
		    continue
		} else {
		    AppendAuFichier $LogFile "Prohibited: OK"}
	    } else {AppendAuFichier $LogFile "Prohibited: OK"}
	    
	    #Module Determination du GC Content
	    ###################################
	    if {[info exists GCContentMinus] && [info exists GCContentPlus] && $GCContentMinus!="" && $GCContentPlus!=""} {
		set xGC [NombreDeBaseDe $Seq "G|C"]
		set GC  [format "%.1f" [expr (($xGC)/($LengthOligo*1.0))*100.0]]
		if {$GC<$GCContentMinus || $GC>$GCContentPlus} {
		    AppendAuFichier $LogFile "GC: $GC Not OK"
		    continue
		} else {
		    AppendAuFichier $LogFile "GC: $GC OK"
		}
	    }
	    
	    #Module Calcul du Tm
	    ####################
	    set  Tm [format "%.1f" [CalculTmDeLaSeq $Seq "" "" $TmMethod]]
	    if {$Tm=="-1"} {
		AppendAuFichier $LogFile "Tm: Illegal caracter for Tm calculation"
		continue
	    } elseif {$Tm==""} {
		AppendAuFichier $LogFile "Tm: No Tm calculation"
		return ""
	    } elseif {$Tm>$TmLimitSup} {
		AppendAuFichier $LogFile "Tm: $Tm > $TmLimitSup"
		continue
	    } elseif {$Tm<$TmLimitInf} {
		AppendAuFichier $LogFile "Tm: $Tm < $TmLimitInf"
		continue
	    } else {
		AppendAuFichier $LogFile "Tm: $Tm OK"
	    }
	
	    #Traitements cas particuliers
	    #############################
	    #1-Pas de hit du tout dans le blast
	    #  On ne calcul donc pas de specificite mais au moins le reste
	    if {$NbSubject==0 && $nbGarde>=0} {
		if {$nbGarde==0} {set Tab($Debut,$Fin,candidat)   "No Hit found during DataBase searches"}
		if {   ! [info exists Tab($Debut,$Fin,contigue)]} {set Tab($Debut,$Fin,contigue) 0}
		set Tab($Debut,$Fin,oligo)    $Seq
		set Tab($Debut,$Fin,Tm)       $Tm
		#set Tab($Debut,$Fin,GC)       $GC
		set Tab(OnEnTient)            1
		set Tab($Debut,$Fin,nbGarde)  $nbGarde
		lappend Tab($nbGarde)         "$Debut $Fin"
		continue
	    }
	    
	    #Module Calcul de la Specificite
	    ################################
	    set  LesInfos          ""
	    set  LesPetitesRegions [list [list $Debut $Fin]]
	    set  LesInfos          [LesInfosDesRegionsDansLeBlast $FichierBlast $LesPetitesRegions All $SeuilId]
	    if {$LesInfos!=""} {
		#On a des hits dans cette zone
		#Cette zone est sans l AccessDeRef donc pas la peine de la traiter 
		#Si AccessDeRef est vide on passe quand meme 
		if {$AccessDeRef==""} {
		    #On calcul quand meme
		} elseif {! [regexp -nocase "$AccessDeRef" $LesInfos]} {
		    AppendAuFichier $LogFile "No query $AccessDeRef in this part $Debut $Fin"
		    continue
		}
		
		foreach Ligne $LesInfos {
		    #Description des informations rendues par LesInfosDesRegionsDansLeBlast
		    #1  60 3       1     NM001100 {Plus/Plus} +    67 126 60     60        60
		    #DQ FQ NAliTot NArea BId      Orient      Sens DS FS  NDsAli NDsAliTot NCont
		    #Pour Pallier au probleme de plusieurs Access pour un seul Id
		    #1 60 77 2 RSHUM:CD97 {Plus / Minus} - {147 147} {157 157} 14 22 3

		    set Facteur      [llength [lindex $Ligne 8]]
		    set NbBIdentique ""
		    set NbBAlignee   ""
		    set NbContigue   ""
		    set NbBIdentique [lindex $Ligne  9]
		    set NbBAlignee   [lindex $Ligne 10]
		    set NbContigue   [lindex $Ligne 11]
		    set IdGlobal     [format "%.2f" [expr ((1.0*$NbBIdentique)/($LengthOligo*$Facteur))*100.0]]

		    #Petit test de la query
		    #On teste si la query est suffisemment presente dans cette region
		    set LeCandidat   [lindex $Ligne 4]
		    if {$LeCandidat=="$AccessDeRef"} {
			if {$IdGlobal<70.0} {continue}
		    }
		    
		    #On est pas assez identique
		    if {$IdGlobal<=$IdLimit} {
			#Mais on a trop de bases identiques successives
			if {$NbContigue >= $NbContiguous} {
			    AppendAuFichier $LogFile "Spec: We keep TOOMUCHCONTIGUE    $Ligne"
			    AppendAuFichier $LogFile "\tID G $IdGlobal"
			    
			    incr nbGarde
			    #On compte le nombre de sequences de 15 nts contigues
			    if {![info exists Tab($Debut,$Fin,contigue)]} {
				set Tab($Debut,$Fin,contigue) 1
			    } else {incr Tab($Debut,$Fin,contigue)}
			    
			    lappend Tab($Debut,$Fin,candidat) [lindex $Ligne 4]
			    continue
			}
			AppendAuFichier $LogFile "Spec: We left NOTENOUGHIDENTICAL $Ligne"
			incr nbVire
			continue
		    }
		    #On compte le nombre de sequences de 15 nts contigues meme pour ceux gardes avec IdGlobal important
		    if {$NbContigue >= $NbContiguous} {
			if {![info exists Tab($Debut,$Fin,contigue)]} {
			    set Tab($Debut,$Fin,contigue) 1
			} else {incr Tab($Debut,$Fin,contigue)}
		    }
		    AppendAuFichier $LogFile "Spec: We keep TOOMUCHIDENTICAL   $Ligne"
		    AppendAuFichier $LogFile "\tID G $IdGlobal"	
		    incr nbGarde
		    
		    lappend Tab($Debut,$Fin,candidat) [lindex $Ligne 4]
		}
		AppendAuFichier $LogFile ">>>\tWe keep $nbGarde\tWe left $nbVire"
	    }

	    if {$nbGarde>=0} {
		if {$LesInfos==""} {
		    #1 - On n a pas de hits dans le blast dans cette zone
		    #    On le garde quand meme
		    AppendAuFichier $LogFile      "$Debut $Fin NoHitFound"
		    set Tab($Debut,$Fin,candidat) "No Hit found during DataBase searches"
		} else {
		    #2 - On a des hits dans le blast dans cette zone
		    if {$nbGarde==0} {
			#2 - 1 - On a des hits mais aucun suffisamment proche pour le retenir
			#        On le garde
			AppendAuFichier $LogFile      "$Debut $Fin NoHitWithEnoughIdentity"
			set Tab($Debut,$Fin,candidat) "No Hit found or retained during DataBase searches"
		    } else {
			#Equivalent a nbGarde > 0
			#2 - 2 - On a des hits et au moins un suffisamment proche pour le(s) retenir
			if {$AccessDeRef==""} {
			    #2 - 2 - 1 - On le garde quand meme car il n y a pas de query
			    AppendAuFichier $LogFile "$Debut $Fin NoHitWithEnoughIdentity"
			} elseif {! [regexp -nocase "$AccessDeRef" [set Tab($Debut,$Fin,candidat)]]} {
			    #2 - 2 - 2 - Cette zone ne contient pas (ou pas suffisamment) notre AccessDeRef
			    #On ne le garde pas
			    AppendAuFichier $LogFile "No query $AccessDeRef in this Candidat $Debut $Fin"
			    continue   
			}
		    }
		}
		if {! [info exists Tab($Debut,$Fin,contigue)]} {set Tab($Debut,$Fin,contigue) 0}
		set Tab($Debut,$Fin,oligo)   $Seq
		set Tab($Debut,$Fin,Tm)      $Tm
		#set Tab($Debut,$Fin,GC)      $GC
		set Tab(OnEnTient)           1
		set Tab($Debut,$Fin,nbGarde) $nbGarde
		lappend Tab($nbGarde)        "$Debut $Fin"
	    }
	}
    }
    
    set FirstTime 1
    #On va classer et sauvegarder les oligos si on en a trouve
    ##########################################################
    if {[set Tab(OnEnTient)] == 0} {
	#Pour les sequences sans oligos
	###############################
	scan $EnteteQuery "%s" PAB
	regsub {\>} $PAB "" PAB

	regsub ">$PAB" $EnteteQuery ">$PAB NoOligo Available" EnteteQuery
	AppendAuFichier "$Output" $EnteteQuery
	AppendAuFichier "$Output" [join $LaSeq ""]
    } else {
	#Pour les sequences avec oligos
	###############################
	while {1} {
	    if {$FirstTime} {
		set FirstTime 0
		#On enregistre dans le fichier de sortie les oligos avec moins de 30 candidats (MaxToStore) de specificite
		#On garde tout ceux qui ont 0, 1 ou 2 candidat(s) (MinimumAGarder), et pour ceux au dela jusqu a NbOligo
		set MinimumAGarder 2
		set CompteurDOligo 0
		set NumeroDeLOligo 1
		set OnAFini        0
		set OnEnASauverUn  0
		set MaxToStore     30
		#j nombre de candidats maximum a garder par oligo
		#CompteurDOligo et nbOligo nombre de d oligos a garder
	    } else {
		#On est au dessus de 30 candidats de specificite par oligo (MaxToStore)
		#Mais on a des candidats donc on recupere les categories de nb candidats (le j)
		set LesNbGarder       ""
		set LesEntetesNbGarde [array get Tab "*,*,nbGarde"]
		foreach {E NbGarder} $LesEntetesNbGarde {
		    lappend LesNbGarder $NbGarder
		}
		set LesNbGarder [lsort -unique -increasing -integer $LesNbGarder]

		#On va enregistrer dans le fichier de sortie les oligos en desespoir les 5 moins bon
		set NbOligo        5
		set MinimumAGarder 2
		set CompteurDOligo 0
		set NumeroDeLOligo 1
		set OnAFini        0
		set OnEnASauverUn  0
		set MaxToStore     [lindex $LesNbGarder end]
		#j nombre de candidats maximum a garder par oligo
		#CompteurDOligo et nbOligo nombre de d oligos a garder
	    }

	    for {set j 0} {$j <= $MaxToStore} {incr j} {
		#On recherche toutes les positions avec j candidats pour cet oligo
		if {$OnAFini=="1"}         {break}
		if {[info exists Tab($j)]} {
		    set LesPositions ""
		    set MesPositions ""
		    set MesPositions [set Tab($j)]
		    
		    foreach PosDeJ $MesPositions {
			set MonDebut   [lindex $PosDeJ 0]
			set MaFin      [lindex $PosDeJ 1]
			set NbContigue [set Tab($MonDebut,$MaFin,contigue)]
			lappend LesPositions "$PosDeJ $NbContigue"
		    }
		    #On trie selon le nombre de sequences contigues
		    set LesPositions [lsort -integer -increasing -index 2 $LesPositions]
		    
		    foreach UnePosition $LesPositions {
			if {$j>$MinimumAGarder} {
			    incr CompteurDOligo
			    if {$CompteurDOligo>$NbOligo} {
				set OnAFini 1
				break
			    }
			}
			set  EnteteDeLOligo ""
			set  NomDeLOligo    "${PAB}_Oligo${NumeroDeLOligo}_${AccessDeLaBoite}"
			#set  NomDeLOligo    "Oligo${NumeroDeLOligo}_${AccessDeLaBoite}"
			incr NumeroDeLOligo
			set  UnDebut        [lindex $UnePosition 0]
			set  UneFin         [lindex $UnePosition 1]
			set  Contigue       [lindex $UnePosition 2]
			
			#Format: EnteteQuery Taille Tm debut_fin candidats_nbcontigue candidats
			lappend EnteteDeLOligo [linsert $EnteteQuery 1 "$NomDeLOligo"]
			lappend EnteteDeLOligo $LengthOligo
			lappend EnteteDeLOligo "[set Tab($UnDebut,$UneFin,Tm)]"
			#lappend EnteteDeLOligo "[set Tab($UnDebut,$UneFin,GC)]"
			lappend EnteteDeLOligo "$UnDebut $UneFin"
			lappend EnteteDeLOligo "[set Tab($UnDebut,$UneFin,nbGarde)] $Contigue"
			lappend EnteteDeLOligo [join [set Tab($UnDebut,$UneFin,candidat)] " "]
			set     EnteteDeLOligo [join $EnteteDeLOligo "\t"]
			
			AppendAuFichier $Output $EnteteDeLOligo
			AppendAuFichier $Output "[set Tab($UnDebut,$UneFin,oligo)]"
			
			set OnEnASauverUn 1
			continue
		    }
		} else {continue}
	    }
	    if {$OnEnASauverUn} {break}
	}
	if {[info exists Tab]}  {unset Tab}
    }
    AskBlast         unsetfile $FichierBlast
    InterrogeBestHitInDatabase $FichierBlast Decharge 
    if {[info exists Tab]}      {unset Tab}
    if {[info exists LesInfos]} {unset LesInfos}
    
    AppendAuFichier $LogFile "FIN"
    return ""

}

proc CheckForProject {p} {

    global OPjt
    
    if {! [file exists $p]} {
	FaireLire "Directory $p does not exists !"
	exit
    }

    set OPjt(Dir) $p
    cd $OPjt(Dir)

    # common GUI declarations
    # toplevel est "."
    wm title . "Ordalie Project"
    wm iconname . "Project"
    set w ".opjt"
    set OPjt(Window) $w
    font create FntPrjt -size 12 -family Helvetica
    frame $w
    grid $w -row 0 -column 0 -sticky news
    grid columnconfig . all -weight 1
    grid rowconfig    . all -weight 1

    if {[file exists ${p}.opjt]} {
	LoadProject $p
    } else {
	DefineProject $p
    }

    return

}

proc CheckForRestrictedParameter {Value NomDuCutOff} {


    Wup "Permet de tester les parametres restreints selon la valeur donnee"
    Wup "3 classes de test Equal pour egal, Both pour 1 encadrement et Regexp pour une recherche de texte"

    if {$Value == ""} {return ""}
    if {[RestrictedParameter $NomDuCutOff "" Existe]=="0"} {return ""}

    set ValueDuCutOff [RestrictedParameter $NomDuCutOff "" LaValeurMerci]
    set Categorie     [LaCategorieDeCuttOffDe $NomDuCutOff]

    #Both   recherche les 2 criteres
    #Equal  recherche exactement ce critere
    #Regxep recherche la presence de tous en meme temps
    set Keep 1
    switch -exact -- $Categorie {
	"Equal"  {if {$Value !="" && $Value != $ValueDuCutOff} {set Keep 0}}
	"Both"   {
	    set  ValueDuCutOff2 [RestrictedParameter ${NomDuCutOff}_2 "" LaValeurMerci]
	    if {$ValueDuCutOff==""} {set ValueDuCutOff 0.0} elseif {$ValueDuCutOff2==""} {set ValueDuCutOff2 10000000}
	    if {$Value < $ValueDuCutOff || $Value > $ValueDuCutOff2} {set Keep 0} else {set Keep 1}   
	}
 	"Regexp" {
	    if {$Value !="" && ![regexp -nocase "$ValueDuCutOff" $Value]} {
		foreach V $ValueDuCutOff {
		    if {![regexp -nocase "$V" $Value]} {set Keep 0;break}
		    set Keep 1
		}
	    }
	}
    }
    if {$Keep} {return "1"} else {return "0"}

}

proc CheckForUserOrModelTaxId {Lid n} {

    global Tx LUserId LModelId

    # returns a list of added taxa and the number of added taxa
    # The list may be empty, and nadd != if the taxa were 
    # supplied by the user

    set Ladd [list]
    # Model 
    set iadd 0
    if {$Tx(-modelsin)} {
	foreach m $LModelId {
	    if {$m in $Lid && $iadd < $n} {
		lappend Ladd $m
		incr iadd
	    }
	}
    }
    if {$LUserId == {} } {
	return [list $Ladd [llength $Ladd]]
    }
    
    # check if there are already user taxa
    set nadd 0
    foreach t $Lid {
	if {$t in $LUserId} {
	    incr nadd
	}
    }

    return [list $Ladd $nadd]

}

proc CheckGoodDBType {l} {

    set Lgood [list I R T V P F U 0 1 2 3 4 5 6 7 8 9]
    # un seul caractere, ne peut etre que P I R T
    set Lun [list P I R T]
    # plus que un, prems est :
    set Lprems [list I R T V]
    # et deuxieme est 
    set Ldeux  [list F P U 0 1 2 3 4 5 6 7 8 9]
    
    set lg [llength $l]
    set ix 0
    foreach e $l {
	if {$lg == 1} {
	    if {$e ni $Lun} {
		#puts "bad column type >$e< !!"
	    }
	} else {
	    if {$ix > 0} {
		if {$e ni $Ldeux} {
		    #puts "bad column type >$e< in second place !!"
		}
	    }
	}
    }
    
    return 

}

proc CheckIdsAsList {LId} {

    if {[regexp {[ ,\n]} $LId]} {
	regsub -all {[ ,\n]+} $LId "," LId
	set LId [split [string trim $LId ","] ","]
    }

    return $LId

}

proc CheckInventaire {} {


    global RepertoireDuGenome 
    global CheckResultat ; set CheckResultat {}
    
    if {[TestRepOrga]==0} {
    } else { 
	TestFiches
	TestLiensGenomesOuCollection
	TestMsf
	TestNucProtTFAEMBL
	TestStatNuc
	TestBlastP
	TestTBlastN
	TestLesTrous
	TestLesNotes
    }
    set Fenetre [AfficheVariable [join $CheckResultat "\n"] "AvecShow" "Inventory Check at [Date Nice]"]
    set B [BoutonneLaFenetre $Fenetre "NewInventory\nNewCheck\nExecute"]
    $B configure -background "yellow"
	bind $B <1>          Inventaire
	bind $B     CheckInventaire   
        bind $B   "ExecuteLaSelectionDeCheck \[selection get\]"

    Illumine "run"     $Fenetre
    Illumine "copy it" $Fenetre

}

proc CheckLesResultatsDeLaGridManu {} {

    set FichierSortie "[RepertoireDuGenome]/fiches/checkgrid.log"
    AppendAuFichier $FichierSortie "Check Blast"
    set FichierSortieProt "[RepertoireDuGenome]/fiches/arefaire"

    foreach Nom [ListeDesPABs] {
	set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom"
	set LesLignes [LesLignesDuFichier $FichierNuctfa]
	set LaPremiereLigne [lindex $LesLignes 0]
	if {[regexp {bidon} $LaPremiereLigne]} {
	    lappend LesSsAcs $Nom
	}
    }
    
    foreach Nom [ListeDesPABs] {
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom"
	if {! [file exists $FichierProttfa]} {
	    lappend LesSsAcs $Nom
	}
    }
    set LesSsAcs [ListeSansDoublon $LesSsAcs]
    set longssacc [llength $LesSsAcs]

    set notacc 0
    foreach Nom [ListeDesPABs] {
	set onla 0
	foreach elmt $LesSsAcs {
	    if {$elmt==$Nom} {set onla 1}
	}
	if {$onla} {continue}
	set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
	if {! [file exists $FichierBlast]} {
	    AppendAuFichier $FichierSortie "$Nom"
	} else {continue}
    }
    AppendAuFichier $FichierSortie "\n"
    AppendAuFichier $FichierSortie "Check Msf"
    
    foreach Nom [ListeDesPABs] {
	set nb 0
	set FichierMsf "[RepertoireDuGenome]/cluspack/$Nom"
	if {! [file exists $FichierMsf]} {
	    #set FichierCopains "[RepertoireDuGenome]/fiches/nombredecopainsdansblast"
	    set FichierCopains "[RepertoireDuGenome]/tfasdescopains/$Nom"
	    if {! [file exists $FichierCopains]} {continue}
	    foreach Ligne [LesLignesDuFichier $FichierCopains] {
		if {[regexp {^>} $Ligne]} {incr nb}
		#scan $Ligne "%s %s" NomCopain NombreDeCopains
		#if {[regexp "$Nom" $NomCopain]} 
		#if {$NombreDeCopains != 0} 
	    }
	    if {$nb>1} {
		AppendAuFichier $FichierSortie "$Nom"
	    } 
	}
    }
    AppendAuFichier $FichierSortie "\n"
    AppendAuFichier $FichierSortie "Check Rascal"
    

    foreach Nom [ListeDesPABs] {
	foreach elmt $LesSsAcs {
	    if {$elmt==$Nom} {continue}
	}
	set FichierRascal "[RepertoireDuGenome]/msfrascal/$Nom"
	set FichierMsf    "[RepertoireDuGenome]/cluspack/$Nom"
	if {! [file exists $FichierRascal] && [file exists $FichierMsf]} {
	    AppendAuFichier $FichierSortie "$Nom"
	    set FichierProteine "[RepertoireDuGenome]/prottfa/$Nom"
	    foreach Ligne [LesLignesDuFichier $FichierProteine] {
		AppendAuFichier $FichierSortieProt "$Ligne"
	    }
	}
    }

    AppendAuFichier $FichierSortie "\n"
    AppendAuFichier $FichierSortie "Check Leon"
    

    foreach Nom [ListeDesPABs] {
	set FichierLeon       "[RepertoireDuGenome]/msfleon/$Nom"
	set FichierRascal     "[RepertoireDuGenome]/msfrascal/$Nom"
	if {! [file exists $FichierLeon] && [file exists $FichierRascal]} {
	    AppendAuFichier $FichierSortie "$Nom"
	    set FichierProteine "[RepertoireDuGenome]/prottfa/$Nom"
	    foreach Ligne [LesLignesDuFichier $FichierProteine] {
		AppendAuFichier $FichierSortieProt "$Ligne"
	    }
	}
    }
    AppendAuFichier $FichierSortie "\n"
    AppendAuFichier $FichierSortie "Check Normd"
    

    foreach Nom [ListeDesPABs] {
	set FichierNormd "[RepertoireDuGenome]/normd/$Nom"
	set FichierMsf   "[RepertoireDuGenome]/cluspack/$Nom" 
	if {! [file exists $FichierNormd] && [file exists $FichierMsf]} {
	    AppendAuFichier $FichierSortie "$Nom"
	}
    }

}

proc CheckLesZones {K} {


    Wup "Permet de mettre les numeros de zones dans un ordre convenable"
    
    set ListeIdLigne ""
    set         LesIds [$K find withtag {"Zonable" && "Flag"}]
    foreach Id $LesIds {
	lappend ListeIdLigne [list $Id [lindex [$K coords $Id] 0]]
    }
    set nbLigne      [llength $ListeIdLigne]
    set ListeIdLigne [lsort -increasing -real -index 1 $ListeIdLigne]

    set i 0
    foreach Ligne $ListeIdLigne {
	incr i
	if {$i >$nbLigne} {break}
	$K itemconfigure [lindex $Ligne 0] -text "$i"
    }
    return ""

}

proc CheckRestrictionEnzymes {NomOuAlias {ListOfEnzymes ""} {Texte ""} {Quoi ""}} {


    if {[regexp "^Get" $Texte]} { set Quoi $Texte ; set Texte "" } 

    regsub "^for_" $NomOuAlias "" NomOuAlias

    if {$ListOfEnzymes=="" || $ListOfEnzymes=="All"} { set ListOfEnzymes [RestrictionEnzyme ListOf Enzymes] }
    if {$ListOfEnzymes=="Signals"} {
	set ListOfEnzymes {}
	foreach Signal [Signal ListOf Signals] {
	    set EstUnSignal($Signal) 1 
	}
	foreach E [RestrictionEnzyme ListOf Enzymes] {
	    if {[info exists EstUnSignal($E)]} { lappend ListOfEnzymes $E }
	}
    }

    set Nom ""
    set Alias ""
    set DE ""
    while {$Nom==""} {
	if {$NomOuAlias=="FromFile"}      { set Nom "FromFile"  ; set NomOuAlias $Texte }
	if {[regexp "/" $NomOuAlias]}     { set Nom "FromFile"  ; break }
	if {$NomOuAlias=="FromSequence"}  { set Nom $NomOuAlias ; break }
	if {[EstUnPAB $NomOuAlias]}       { set Nom $NomOuAlias ; break }
	if {[NomDuAlias $NomOuAlias]!=""} { set Nom $NomOuAlias ; break }
	if {$Texte==""} { set Texte $NomOuAlias }
	set NomOuAlias "FromSequence"
    }
    if {[EstUnPAB $Nom]} {
	set Alias [Alias $Nom]
	set DE [DefinitionRapide $Nom]
	set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
    }
    if {$Nom=="FromSequence"} {
	if {[regexp ">" $Texte]} {
	    set Seq [QueLaSequenceDuTexteTFA $Texte]
	} else {
	    set Seq $Texte
	}
    }
    if {$Nom=="FromFile"} {
	set Seq [QueLaSequenceDuFichierTFA $NomOuAlias]
	set Nom $NomOuAlias
    }

    set Seq [string toupper $Seq]
    set LesHits [list "CheckRestrictionEnzymes for $Nom $Alias $DE"]
    foreach E $ListOfEnzymes {
	set SE [string toupper [RestrictionEnzyme $E "Sequence"]]
	set SEX [IUPAC $SE]

	set LesDFs [regexp -all -indices -inline $SEX $Seq]
	if {$LesDFs=={}} {
	    lappend LesHits "[format %-8s $E] [format %-20s $SE]         NotFound"
	} else {
	    set LesIs {}
	    foreach DF $LesDFs {
		scan $DF "%d" I
		lappend LesIs "[expr $I+1] [expr ($I+3)/3]"
	    }
	    lappend LesHits "[format %-8s $E] [format %-20s $SE] [join $LesIs " / "]"
	}
    }
    set Hits [join $LesHits "\n"]
    if {$Quoi=="GetHtml"} { return [Html_DuTexteTelQuel $Hits] }
    if {$Quoi=="GetHits"} { return $Hits } 
    return [AfficheVariable $Hits "" "Restriction Enzymes Hits for $Nom"]

}

proc CheckSampleTOLParameters {args} {

    global Tx db LUserId LShowId LShowIdOri TaxRoot LwarningHTML

    # inits
    # do we come from tk intergace or are we called ?
    set gui [expr {$args eq "gui"}]
    # params
    set Tx(-output) tk
    set Tx(-toshow) "def"

    if {! $gui} {
	# Default parameters
	#
	# output : tk ou html or terminal
	set Tx(-output) tk

	# complete genomes database :
	# uniprot gold ncbi
	set Tx(-cgdb) "uniprot"

	# taxonomy database
	# uniprot or ncbi
	set Tx(-txdb) "uniprot"

	# Nbr of taxa to take
	set Tx(-ntaxa) 200
	# root node from which the sampling starts
	set Tx(-root) "TOL"
	# Cares about branches weight (nb of children inside)
	set Tx(-weighted) 1
	# use 'all' or 'representative' organisms
	set Tx(-useorgs) representative
	# model organisms added as extra-taxa
	set Tx(-addmodel) 1
	# model organisms will be included in the ntaxa selected
	set Tx(-modelsin) 1
	set Tx(-addmodel) 0
	# User defined List
	set Tx(-UserFile) ""
	# tax id to show
	set Tx(-ShowFile) ""
	# show which taxa : all / def
	set Tx(-toshow) "def"
	# user defined IDs
	set Tx(-userids) ""

	# now assign user-defined parameters
	array set Tx $args
	if {$Tx(-output) ne "html"} {
	    puts "\nFinal options :"
	    parray Tx
	    puts ""
	}
    } else {
	# Cares about branches weight (nb of children inside)
	set Tx(-weighted) 1
	# how do we handle model organisms ?
	switch $Tx(chxmodel) {
	    1 {
		set Tx(-addmodel) 1
		set Tx(-modelsin) 0
	    }
	    0 {
		set Tx(-addmodel) 0
		set Tx(-modelsin) 1
	    }
	    -1 {
		set Tx(-addmodel) 0
		set Tx(-modelsin) 0
	    }
	}
	# root
	if {$Tx(-root) eq ""} {
	    set Tx(-root) "TOL"
	}
	if {$Tx(-ntaxa) eq ""} {
	    # No sampling, just viewing
	    set Tx(-ntaxa) 0
	}
    }
    
    set LwarningHTML [list]
    if {$Tx(-output) eq "html"} {
	LesDefauts Mode batch
	TaisToi
    } elseif {$Tx(-output) eq "terminal"} {
	LesDefauts Mode batch
    }
    
    set ntaxa $Tx(-ntaxa)
    if {! [string is integer -strict $ntaxa]} {
	if {$gui} {
	    FaireLire "ERROR : Number of samples should be an integer !"
	} else {
	    puts "ERROR : Number of samples should be an integer ! ntaxa >>$ntaxa<<"
	}
	return 0
    }
    if {! $gui} {
	foreach n {-weighted -modelsin -addmodel} {
	    set v $Tx($n)
	    if {! [string is boolean $v]} {
		puts "ERROR ! Should be a boolean value for -weighted, -addmodel or -modelsin"
		return 0
	    }
	}
	if {$Tx(-addmodel) && $Tx(-modelsin)} {
	    puts "ERROR : -addmodel and -modelsin can't be set simultaneously !"
	    return 0
	}
    }
    
    # User defined organisms list
    # -userids : string of taxaid separated with commas
    set LUserId [list]
    if {$Tx(-userids) != ""} {
	set Lid [split $Tx(-userids) ,]
	set LUserId [ReadUserTaxId $Lid $gui]
    }	
    # -UserFile : taxa IDs comes as a file to be read
    if {$Tx(-UserFile) ne ""} {
	if {! [file exists $Tx(-UserFile)]} {
	    set Msg "ERROR ! File $Tx(-UserFile) does not exists !"
	    if {! $gui} {
		puts $Msg
	    } else {
		FaireLire $Msg
	    }
	    return 0
	}
	set LUserId [ReadUserTaxId $Tx(-UserFile) $gui]
    }

    # define root
    if {[set nroot [string trim $Tx(-root)]] eq ""} {
	set nroot "TOL"
    }

    if {$nroot ne "TOL"} {
	if {[string is integer -strict $nroot]} {
	    set TaxRoot 131567
	    #set TaxRoot [$db eval {select taxid from taxonomy where taxid = $nroot}]
	} else {
	    set TaxRoot [$db eval {select taxid from taxonomy where Name = $nroot}]
	}

	if {$TaxRoot eq "" || $TaxRoot == {}} {
	    if {$gui} {
		FaireLire "ERROR ! No taxa id/name corresponding to >$Tx(-root)<"
	    } else {
		puts "ERROR ! No taxa id/name corresponding to >$Tx(-root)<"
	    }

	    return 0
	}
    } else {
	set TaxRoot [$db eval {select taxid from taxonomy where Name = "cellular organisms"}]
    }
    set Tx(-root) $nroot

    # output options
    puts ""
    set Lk [lsort [array names Tx "-*"]]
    set w [PlusLongEltDe $Lk]
    foreach k $Lk {
	set sp [expr {$w - [string length $k]}]
	#puts "Tx($k)[string repeat " " $sp] = $Tx($k)"
    }

    return 1

}

proc CheckSelectedOligoForLogFile {{LesPABs ""} {Dir ""}} {


    Wup "Permet de verifier que les sequences choisies dans le design comportent bien le log associe"

    set Dir  "[RepertoireDuGenome]/Probes/UnigeneBLAST3"
    set Dir2 "[RepertoireDuGenome]/Probes/RefSeqBLAST3"

    if {$LesPABs==""} {set LesPABs [ListeTest]}
    foreach PAB $LesPABs {
	#lappend LesQuerys "[RepertoireDuGenome]/Probes/RefSeqBLAST3/${PAB}"
	lappend LesQuerys "[RepertoireDuGenome]/Probes/UnigeneBLAST3/${PAB}"
    }

    set  RepDeTravail  ""
    foreach Query $LesQuerys {
	set PAB               [file tail $Query]
	set LogFile1          "${Query}.log"
	set OligoFile1        "${Query}.oligo"
	set FichierSelection1 "${Query}.selection"
	set FichierCroisee1   "${Query}.croisee"
	set FichierCroisee2   "$Dir2/${PAB}.croisee"
	set LesFichiers       [list $FichierSelection1 $FichierCroisee1]
	set LesFichiers       [list $FichierSelection1 $FichierCroisee1 $FichierCroisee2]

	#file copy -force $LogFile1 "[RepertoireDuGenome]/Probes/testlogfile/unigene"
	
	Espionne ">>>>>>>>>>>>>>>>>>>>$PAB<<<<<<<<<<<<<<<<<<<<<<<<"

	#Pour chaque fichier on va chercher si le log contient les infos
	foreach File1 $LesFichiers {
	    #Charge les noms des oligos a verifier
	    set LesNoms    [InterrogeInfoDeLOligo $File1 LesNoms]
	    
	    foreach NomNew $LesNoms {
		set Debut  [InterrogeInfoDeLOligo $File1 $NomNew Debut]
		set Fin    [InterrogeInfoDeLOligo $File1 $NomNew Fin]
		
		if {1} {
		    #Test si oligo existe dans le fichier .oligo
		    InterrogeInfoDeLOligo $OligoFile1 Decharge
		    if {[InterrogeInfoDeLOligo $OligoFile1 $Debut $Fin NomOligo]!=""} {
			Espionne ">>New $NomNew $Debut $Fin finally existe dans le fichier oligo"

			set NomDansOligo [InterrogeInfoDeLOligo $OligoFile1 $Debut $Fin NomOligo]
			set AutreNom     [InterrogeInfoDeLOligo $File1 $Debut $Fin NomOligo]
			if {$NomDansOligo!=$AutreNom} {
			    #On ajoute pas mais il faut changer le nom
			    Espionne "On ajoute pas mais il faut changer le nom $NomDansOligo ! = $AutreNom"
			    #SupprimeUnOligoPourCeuxDejaFait $File1 "$Debut $Fin"
			    #AjouteUnOligoPourCeuxDejaFaitAuFichier $OligoFile1 $File1 $NomDansOligo
			}
		    } else {
			set NomOligoToAdd ""
			set OligoToAdd    ""
			Espionne "New $NomNew $Debut $Fin existe pas dans le fichier oligo"
			#on recupere le nom et 
			set NomOligoToAdd [InterrogeInfoDeLOligo $File1 $Debut $Fin NomOligo]
			set    OligoToAdd [join [ExtraitOligoDuTFA2 $PAB $NomOligoToAdd $Dir [file tail $File1]] "\n"]
			
			#on verifie que le nom n existe pas encore
			if {[InterrogeInfoDeLOligo $OligoFile1 $NomOligoToAdd Taille]!=""} {
			    #On ajoute mais il faut changer le nom
			    Espionne "On ajoute mais il faut changer le nom"
			    Espionne "Attention $NomOligoToAdd already exists in $OligoFile1"
			    #AjouteUnOligoPourCeuxDejaFaitAuFichier $File1 $OligoFile1 $NomOligoToAdd
			    #SupprimeUnOligoPourCeuxDejaFait $File1 "$Debut $Fin"

			} else {
			    #On ajoute sans restriction
			    Espionne "On ajoute sans restriction"
			    Espionne "On ajoute $NomOligoToAdd $OligoFile1 $OligoToAdd"
			    #AppendAuFichier $OligoFile1 $OligoToAdd
			}
		    }
		}

		#Espionne "New $NomNew $Debut $Fin"
		InterrogeInfoDuLogDeLOligo $LogFile1 Decharge
		if {[InterrogeInfoDuLogDeLOligo $LogFile1 $Debut $Fin LesCandidats]!=""} {
		    #Espionne ">>New $NomNew $Debut $Fin finally exists"
		    continue
		}

		if {[OuiOuNonMemo "Could you give me a name Dir to find other log file to complete ?"]} {
		    if {$RepDeTravail =="" || ! [file isdirectory $RepDeTravail]} {
			while {1} {
			    set  RepDeTravail [tk_chooseDirectory -title "Choose a directory" -initialdir "[RepertoireDuGenome]"]
			    if {$RepDeTravail==""} {continue}
			    break
			}
		    }
		    set LogFile2 "${RepDeTravail}/${PAB}.log"
		    if {! [file exists $LogFile2]} {
			Espionne ">>>No specified file exists to search in"
			continue
		    }
		    
		    #Espionne "On va pouvoir completer"
		    if {[InterrogeInfoDuLogDeLOligo $LogFile2 $Debut $Fin LesCandidats]!=""} {
			Espionne "Ok ca marche"
			Espionne "CompleteLeLogFileDeLOligo $Debut $Fin $LogFile2 $LogFile1"
			#CompleteLeLogFileDeLOligo "$Debut $Fin" $LogFile2 $LogFile1
		    } else {
			Espionne "!!!! Marche pas pour $Debut $Fin $LogFile2 $LogFile1"
		    }
		    
		} else {
		    Espionne ">>>No dir to search a log file"
		}
		Espionne "End for $NomNew $Debut $Fin"
	    }
	}
    }

}

proc CheckSeqAdv {c Ladv} {

    global TInf

    set k [array names TInf *,$c,ok]
    lassign [split $k ,] pdbid c tmp
    
    set seqpdbal [set TInf($pdbid,$c,seqpdbal)]
    set seqpdb   [set TInf($pdbid,$c,seqpdb)]
    set seqres   [set TInf($pdbid,$c,seqres)]
    set sequnp   [set TInf($pdbid,$c,sequnp)]

    # faut traiter cas insertion dans pdb et
    # vide dans uniprot : ex 1ho8
    # ideee : creer une seq pdb SANS ces reidus,
    # aligner contre seqres avec, et reinserer 
    # en '0' les res
    set hasChanged 0
    set LToRem [list]
    foreach adv $Ladv {
	#puts "$adv"
	lassign $adv nm1 chn rn1 db acc nm2 rn2 cft
	if {$cft in {microheterogeneity variant engineered conflict strain substitution mutation "modified residue"}} {
	    set hasChanged 1
	    puts "\t=> $adv"
	    # numbreing starts at 0 here
	    # check good residue
	    if {[AutreCodeLuc $nm2] eq [string index $sequnp $rn2-1]} {
		set sequnp [string replace $sequnp $rn2-1 $rn2-1 "X"]
	    } else {
		puts "\tBAD ! residue not matching $rn2 $nm2 [string index $sequnp $rn2-1]"
	    }
	    #puts "$sequnp\n"
	    
	    # rn1 is the position in the PDB seq
	    # should find corresponding in seqres
	    set no [$pdbid _lookup $c $rn1]
	    set g 0 ; set s 0
	    while {$s < $no} {
		if {[string index $seqpdbal $g] ne "-"} {
		    incr s
		}
		incr g
	    }
	    
	    #puts "s= $s g= $g $rn1 $no"
	    set no $g
	    set seqres [string replace $seqres $no-1 $no-1 "X"]
	    set seqpdbal [string replace $seqpdbal $no-1 $no-1 "X"]
	    set seqpdb   [string replace $seqpdb $s-1 $s-1 "X"]
	    #puts "$seqres\n"
	} else {
	    puts "cft $cft"
	}
	if {$db ne "" && $nm2 eq "" && $rn2 eq ""} {
	    # insertion in pdb / uniprot. 
	    # remove it also in seqpdbal seqpdb
	    lappend LToRem $rn1 $nm1
	}
    }
    set TInf($pdbid,$c,seqpdbal) $seqpdbal
    set TInf($pdbid,$c,seqpdb)   $seqpdb
    set TInf($pdbid,$c,sequnp)   $sequnp
    set TInf($pdbid,$c,seqres)   $seqres
    if {$LToRem == {}} {
	return $hasChanged
    }

    #puts "LToRem $LToRem"
    set Lnmr [$pdbid _resnumber -chain $c -polymer]
    #puts "Lnmr $Lnmr"
    set Lno2ix [list]
    foreach {no nm} $LToRem {
	# position in seq
	lappend Lno2ix $no [lsearch $Lnmr $no]
    }

    set seqmod $seqpdb
    set Lno2ix [lsort -integer -decreasing -stride 2 -index 1 $Lno2ix]
    foreach {no ix} $Lno2ix { 
	# if ix = -1, residue not seen, no mod
	#puts "no $no ix $ix"
	#set seqmod [string replace $seqmod $ix $ix "X"]
	set seqmod [string replace $seqmod $ix $ix]
    }

    # seqmod = seqpdb sans les insertions
    # re-align seqres against resmod
    lassign [NW $seqmod $seqpdb] seqmod seqpdb
    # les gaps entre seqpdb seqmod sont insertions
    set Lsmod [split $seqmod ""]
    set Lgap [lreverse [lsearch -all $Lsmod "-"]]
    set Lspdb [split $seqpdb ""]
    set Lspal [split $seqpdbal ""]
    set Lsres [split $seqres ""]
    foreach ig $Lgap {
	lset Lspdb $ig "0"
	# remplace dans seqres et seqpdbal
	set iseq 0 ; set igen 0
	while {$iseq < $ig} {
	    if {[lindex $Lspal $igen] ne "-"} {
		incr iseq
	    }
	    incr igen
	}
	lset Lspal $igen "0"
	lset Lsres $igen "0"
    }
    set seqpdb [join $Lspdb ""]
    set seqres [join $Lsres ""]
    set seqpdbal [join $Lspal ""]
    set TInf($pdbid,$c,seqpdb) $seqpdb
    set TInf($pdbid,$c,seqpdbal) $seqpdbal
    set TInf($pdbid,$c,seqres) $seqres

    return $hasChanged

}

proc CheckSeqs {} {

    global Sequences
    global TDesTaxId
    global Tfa
    global S2T

    foreach s [array names Sequences] {
	if {[EstUnAccessPDB $s]} {continue}
	if {[info exists TDesTaxId($s)]} {
	    set tx [set TDesTaxId($s)]
	} else {
	    set tx [lindex [set Tfa($s)] 0]
	}
	lappend BonN $tx
	lappend BonS [set Sequences($s)]
	set S2T($s) $tx
    }

    return [list $BonN $BonS]

}

proc CheckSiteFeat {n1 n2 ft} {

    lassign $ft tm type tm deb tm fin tm col tm score tm note
    set s1 $::Sequences($n1)
    set s2 $::Sequences($n2)
    set r1 [string index $s1 $deb]
    set r2 [string index $s2 $deb]
    
    set ret 0
    if {$type eq "MODRES"} {
	regsub -all -nocase {[^a-z]} $note "" note
	switch $type {
	    "ACETYLATION" {
		if {$r1 eq $r2} {set ret 1}
	    }
	    "AMIDATION" -
	    "ALKYLATION" {set ret 1}
	    "HYDROXYLATION" {if {$r1 in [list D N P K]} {set ret 1}}
	    "METHYLATION" {
		if {$r1 in [list K R]} {set ret 1}
	    }
	    "PHOSPHORYLATION" {
		if {$r1 in [list S T Y D H]} {set ret 1}
	    }
	    "SULFATION" {
		if {$r1 eq "Y"} {set ret 1}
	    }
	    "MYRISTATE" {
		if {$r1 eq "K"} {set ret 1}
	    }
	    "PALMITATE" {
		if {$r1 in [list C S T]} {set ret 1}
	    }
	    "FARNESYL" -
	    "GERANYL" -
	    "NACYL" {
		if {$r1 eq "C"} {set ret 1}
	    }
	}
    }
    
    if {$type eq "SITE"} {
	if {$note eq "DISULFID" && $r2 eq "C" && $r2f eq "C"} {
	    set ret 1
	}
    }
    
    # Check that the sequences are identical
    set ncom 0
    for {set i $dft} {$i <= $fft} {incr i} {
	if {[string index $s1 $i] eq [string index $s2 $i]} {incr ncom}
    }
    if {$ncom != 0} {
	set pc [expr {($fft - $dft + 1)/$ncom}]
	if {$pc > 50.} {set ret 1}
    }
    
    return $ret

}

proc CheckTFAFile {Fichier} {


    Wup "Permet de tester et de decider pour un fichier fasta multiple"
    Wup "Retourne vide si rien n est fait et le nom des fichiers si des fichiers sont crees"

    if {! [file exists $Fichier]} {return ""}

    set LesNewFiles ""
    if {[EstCeUnTFAOuUnTFAS $Fichier]>1} {
	if {[OuiOuNon "$Fichier seems to be a multiple fasta sequence file.\nI need one file per sequence.\nWould you like to split your sequences ?"]} {
	    set Dir         [tk_chooseDirectory -title "Choose a saving directory." -initialdir "[RepertoireDuGenome]"]
	    set LesNewFiles [SplitLeTFAS $Fichier $Dir]
	}
    }

    return "$LesNewFiles"

}

proc CheckTFAMarie {} {

    set RepertoireDuGenome [RepertoireDuGenome]

    set rtfa [file join $RepertoireDuGenome tfasdescopains]

    puts ""
    for {set i 1} {$i <= 29} {incr i} {
	set e [format "SM%02d" $i]
	set ftfa [file join $rtfa $e]

	# Verif des doublons
	puts "\n$e"
	puts "----"
	DecortiquePseudoTFA $ftfa Lnom Lseq Lcmt
	set j 0
	foreach l1 [lrange $Lnom $j end-1] s1 [lrange $Lseq $j end-1] c1 [lrange $Lcmt $j end-1] {
	    foreach l2 [lrange $Lnom [expr {$j+1}] end] s2 [lrange $Lseq [expr {$j+1}] end] c2 [lrange $Lcmt [expr {$j+1}] end] {
		if {$l1 eq $l2} {puts "TWO Sequences with same names : $l1"}
		if {$s1 eq $s2} {
		    set m1 "$l1 [string range $c1 0 5]"
		    set m2 "$l2 [string range $c2 0 5]"
		    puts "Seqs $l1 :: $l2 identhiques (>>$m1<< >>$m2<<)"
		}
	    }
	    incr j
	}

	# Verif Seq
	foreach s $Lseq l $Lnom {
	    regsub -all {[A-Z]} $s "" tmp
	    if {[string length $tmp]} {
		puts "Seq $l :: caracteres speciaux $tmp"
	    }
	}

	puts ""
	unset Lnom
	unset Lseq
	unset Lcmt
    }

    exit

}

proc CheckUserId {} {

    global db Tx LUserId LwarningHTML

    if {[llength $LUserId] == 0} {
	return
    }

    set LBadId [list] ; set LBadSp [list]
    $db eval {begin transaction}
    foreach id $LUserId {
	if {[$db eval {select Name from taxonomy where taxid=$id}] == {}} {
	    lappend LBadId $id
	    continue
	}
	set spok 0
	foreach g [DonneGenealogieMem $id] {
	    if {$Tx(Rank,$g) eq "Species"} {
		set spok 1
		break
	    }
	}
	if {! $spok} {
	    lappend LBadSp $id
	}
    }
    $db eval {commit}

    if {$LBadId == {} && $LBadSp == {} } {
	return
    }

    lappend LwarningHTML "
User defined IDs :

"
    lappend LwarningHTML "[llength $LUserId] input user IDs
"
    lappend LwarningHTML "[llength $LBadId] not present in taxonomy !
"
    # bad taxid, not in taxonomy
    # check if it has been replaced
    unset -nocomplain T
    array set T [eFetchREST taxonomy $LBadId]
    set Exc [list]
    foreach k [array names T "*,isReplaced"] {
	lassign [split $k ,] Tax tmp
	lappend LUserId $Tax
	set old $T($k)
	# remove old from badId ...
	set ix [lsearch $LBadId $old]
	set LBadId [lreplace $LBadId $ix $ix]
	
	# log the nex TaxId
	set Msg "Warning ! TaxId $old has been replaced by $Tax\n"
	if {0 && ! $gui} {
	    puts $Msg
	} else {
	    FaireLire $Msg
	}
	lappend Exc $old $Tax
    }
    
    if {[llength $Exc] > 0} {
	lappend LwarningHTML "
"
	foreach {in out} $Exc {
	    lappend LwarningHTML "
$in has been replaced by $out
"
	}
    }

    if {[llength $LBadId] > 0} {
	lappend LwarningHTML "
"
	foreach in $LBadId {
	    lappend LwarningHTML "
$in does not exists in taxonomy !
"
	}
    }
    lappend LwarningHTML "
"
    lappend LwarningHTML "
The following taxa don't have any parent with a 'Species' rank in their lineage
"
    lappend LwarningHTML "
"
    foreach id $LBadSp {
	lappend LwarningHTML "
$id $Tx(Name,$id)
"
	set Tx(Rank,$id) "Species"
    }
    lappend LwarningHTML "
"

    # remove Bad Id from LUserId
    set tmp $LUserId
    foreach id $LBadId {
	set ix [lsearch $tmp $id]
	set tmp [lreplace $tmp $ix $ix]
    }
    set LUserId $tmp

    return

}

proc ChefDOrchestreDuCalculDEnrichissement {args} {

    global TabDuChefDOrchestreDuCalculDEnrichissement
    global LePanelPrincipalDuGOEnrichment

    if {$args == ""} {return}
    set PremierArg [lindex $args 0]

    if {[string equal -nocase $PremierArg "LesTypesDEntry"]} {
	return [list "Access" "Access file" "Blast file" "MSF file" "Clustering file" "Gscope GO file"]
    }
    
    if {[string equal -nocase $PremierArg "unsetgroup"]} {
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesAccess)           {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesBoitesGscope)     {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesIndividus)        {}
	return
    }
    if {[string equal -nocase $PremierArg "unsetpopulation"]} {
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesAccess)       {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesBoitesGscope) {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,Lesindividus)    {}
	return
    }
    if {[string equal -nocase $PremierArg "unset"]} {
	if {[info exists TabDuChefDOrchestreDuCalculDEnrichissement]} {unset TabDuChefDOrchestreDuCalculDEnrichissement}
	ChefDOrchestreDuCalculDEnrichissement Ini
	return
    }
    if {[string equal -nocase $PremierArg "Ini"]} {
	if {[info exists TabDuChefDOrchestreDuCalculDEnrichissement]} {unset TabDuChefDOrchestreDuCalculDEnrichissement}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesAccess)           {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesBoitesGscope)     {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesIndividus)        {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesAccess)       {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesBoitesGscope) {}
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,Lesindividus)    {}

	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,rMin)      0
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,rMax)      1.e200   
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,RMin)      0
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,RMax)      1.e200
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,nMin)      0
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,nMax)      1.e200
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,NMin)      0
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,NMax)      1.e200
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,ZscoreMin) 0
	set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,ZscoreMax) 1.e200
	return
    }
    if {[string equal -nocase $PremierArg "AppendGroup"] || [string equal -nocase $PremierArg "AppendPopulation"]} {
	if {[string equal -nocase $PremierArg "AppendGroup"]} {set Qui "Groupe"} else {set Qui "Population"}

	set Type  [lindex $args 1]
	set Entry [lindex $args 2]
	if {$Type == "" || $Entry == ""} {return}
	if {[regexp -nocase " file" $Type] && ![file exists $Entry]} {return}

	if {[string equal -nocase $Type "Access"]} {lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesAccess) $Entry}
	if {[string equal -nocase $Type "Access file"]} {
	    foreach Access [LesLignesDuFichier $Entry] {
		set Access [string trim $Access]
		if {$Access == ""} {continue}
		scan $Access "%s" Access
		lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesAccess) $Access
	    }
	}
	if {[string equal -nocase $Type "Blast file"]} {
	    foreach Access [DrawChoixDesHitsDuBlast  $Entry] {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesAccess) $Access      
	    }
	}
	if {[string equal -nocase $Type "Clustering file"]} {
	    foreach Access [DrawChoixDesHitsDuClustering  $Entry] {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesAccess) $Access        
	    }
	}
	if {[string equal -nocase $Type "MSF file"       ]} {
	    foreach Access [DrawChoixDesHitsDuMSF   $Entry] {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesAccess) $Access        
	    }
	}
	if {[string equal -nocase $Type "Gscope GO file" ]} {
	    foreach LaBoiteGscope [DrawChoixDesBoitesDuProjetGscope  $Entry] {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement($Qui,LesBoitesGscope) $LaBoiteGscope
	    }
	}
	return
    }
    if {[string equal -nocase $PremierArg "set"]} {
	set Quoi [join [lrange $args 1 end] ","]
	if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement($Quoi)]} {return}
	return [set TabDuChefDOrchestreDuCalculDEnrichissement($Quoi)]
    }
    if {[string equal -nocase $PremierArg "append"]} {
	set Quoi [join [lrange $args 1 end-1] ","]
	if {$Quoi == ""} {return}
	set AAjouter [lindex $args end]
	set TabDuChefDOrchestreDuCalculDEnrichissement($Quoi) $AAjouter
	return [set TabDuChefDOrchestreDuCalculDEnrichissement($Quoi)]
    }
    if {[string equal -nocase $PremierArg "Affiche"]} {
	set LesZscore                    [lindex $args 1]

	set rMin      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,rMin)     ]
	set rMax      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,rMax)     ]
	set RMin      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,RMin)     ]
	set RMax      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,RMax)     ]
	set nMin      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,nMin)     ]
	set nMax      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,nMax)     ]
	set NMin      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,NMin)     ]
	set NMax      [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,NMax)     ]
	set ZscoreMin [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,ZscoreMin)]
	set ZscoreMax [set TabDuChefDOrchestreDuCalculDEnrichissement(Valeur,ZscoreMax)]	

	set ListePourLHisto [list "z score"]

	set NbZscore 0
	foreach LeZscore $LesZscore {
	    set GO     [lindex $LeZscore 0]

	    set r      [lindex $LeZscore 2]
	    if {[EstCeUnNombre $rMin     ] && $r      < $rMin     } {continue}
	    if {[EstCeUnNombre $rMax     ] && $r      > $rMax     } {continue}
	    set R      [lindex $LeZscore 3]
	    if {[EstCeUnNombre $RMin     ] && $R      < $RMin     } {continue}
	    if {[EstCeUnNombre $RMax     ] && $R      > $RMax     } {continue}
	    set n      [lindex $LeZscore 4]
	    if {[EstCeUnNombre $nMin     ] && $n      < $nMin     } {continue}
	    if {[EstCeUnNombre $nMax     ] && $n      > $nMax     } {continue}
	    set N      [lindex $LeZscore 5]
	    if {[EstCeUnNombre $NMin     ] && $N      < $NMin     } {continue}
	    if {[EstCeUnNombre $NMax     ] && $N      > $NMax     } {continue}
	    set Zscore [format "%.3f" [lindex $LeZscore 1]]
	    if {[EstCeUnNombre $ZscoreMin] && $Zscore < $ZscoreMin} {continue}
	    if {[EstCeUnNombre $ZscoreMax] && $Zscore > $ZscoreMax} {continue}
	    
	    incr NbZscore

	    set ET     ""
	    set Color "lightgrey"

	    set     LInfo {}
	    lappend LInfo "GO         : $GO"
	    lappend LInfo "Definition :" 

	    set LesDefinitions {}
	    foreach Type [GODB GO $GO LesTypes] {
		set GO [GODB Type $Type GOSynonyme $GO GODeRef]
		if {[string equal -nocase $Type "component"]} {set Color "green"}
		if {[string equal -nocase $Type "function" ]} {set Color "blue" }
		if {[string equal -nocase $Type "process"  ]} {set Color "red"  }

		foreach Definition [GODB Type $Type GO $GO LesDefinitions] {
		    if {$Definition == ""} {continue}
		    if {![info exists TabTmp($GO,$Definition)]} {
			set TabTmp($GO,$Definition) 1
			lappend LInfo " $Definition"
			lappend LesDefinitions $Definition
		    }
		}
	    }

	    set DefDeRef [lindex $LesDefinitions 0]

	    set LesAccessDuGroupe       [ChefDOrchestreDuCalculDEnrichissement "set" GO $GO LesAccessDuGroupe            ]
	    set LesAccessDeLaPop        [ChefDOrchestreDuCalculDEnrichissement "set" GO $GO LesAccessDeLaPopulation      ]
	    set LesBoitesGscopeDuGroupe [ChefDOrchestreDuCalculDEnrichissement "set" GO $GO LesBoitesGscopeDuGroupe      ]
	    set LesBoitesGscopeDeLaPop  [ChefDOrchestreDuCalculDEnrichissement "set" GO $GO LesBoitesGscopeDeLaPopulation]

	    lappend LInfo "z score    : $Zscore"
	    lappend LInfo "Group      : $r / $R with this GO"
	    lappend LInfo "Population : $n / $N with this GO"
	    lappend LInfo "Group      :"
	    foreach LaBoite $LesBoitesGscopeDuGroupe {
		set Nom       [lindex $LaBoite 0]
		set FichierGO [lindex $LaBoite 1]
		lappend LInfo " $Nom $FichierGO"
	    }
	    lappend LInfo " [join $LesAccessDuGroupe " "]"
	    
	    lappend LInfo "Population :"
	    foreach LaBoite $LesBoitesGscopeDeLaPop {
		set Nom       [lindex $LaBoite 0]
		set FichierGO [lindex $LaBoite 1]
		lappend LInfo " $Nom $FichierGO"
	    }
	    lappend LInfo " [join $LesAccessDeLaPop  " "]" 
	    
	    set LeTexteDefinitif {}
	    foreach Ligne $LInfo {
		while {100 < [string length $Ligne]} {
		    lappend LeTexteDefinitif [string range $Ligne 0  59 ]
		    set     Ligne            [string range $Ligne 60 end]
		}
		if {[string length $Ligne] != 0} {lappend LeTexteDefinitif $Ligne}
	    }
	    set Qui "$GO : $DefDeRef [format "%8s" $Zscore]"

	    set     LesTags         [list "GO" [join $LeTexteDefinitif "\n"]]
	    lappend ListePourLHisto [list $Qui $Color $Zscore $ET $LesTags]
	}
	if {$NbZscore <= 0} {return}
	if {[info exists TabTmp]} {unset TabTmp}

	set FrameDuCanva  ""
	set KCanva         [lindex $LePanelPrincipalDuGOEnrichment 0]
	regsub {\.[^\.]+$} $KCanva "" FrameDuCanva

	if {[winfo exists $FrameDuCanva]} {destroy $FrameDuCanva}
	set FrameCanva [lindex $LePanelPrincipalDuGOEnrichment 5]
	set LMax       [lindex $LePanelPrincipalDuGOEnrichment 1]
	set HMax       [lindex $LePanelPrincipalDuGOEnrichment 2]
	set LWin       [lindex $LePanelPrincipalDuGOEnrichment 3]
	set HWin       [lindex $LePanelPrincipalDuGOEnrichment 4]
	set HauteurMax     [expr $HWin * 1.0 / 15 + $NbZscore * 30]
	if {$HauteurMax < $HWin} {set HauteurMax $HWin}
	set KCanva         [Canva $LMax $HauteurMax $LWin $HWin NoY "" "" $FrameCanva]
	$KCanva configure -background white
	set LePanelPrincipalDuGOEnrichment [list $KCanva $LMax $HMax $LWin $HWin $FrameCanva]
	
	PlaceLHistogramme $ListePourLHisto $KCanva 0 $HauteurMax 0 $LWin "Vertical"
	return $KCanva
    }
    if {[string equal -nocase $PremierArg "Calcul"]} {
	set TousLesGODesIndividusDuGroupe {}
	set TousLesGODesIndividusDeLaPop  {}
	foreach LaBoite [set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesBoitesGscope)] {
	    set Nom       [lindex $LaBoite 0]
	    set FichierGO [lindex $LaBoite 1]

	    set FichierProtJum "[file dirname $FichierGO]/ProteinesJumelles"
	    Espionne "Group $Nom from $FichierGO"

	    if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO)]} {
		set LesGODeLaBoite {}
		foreach     GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
		    foreach Type [GODB GO $GO LesTypes                     ] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			if {$GO == ""} {continue}
			lappend LesGODeLaBoite $GO
			foreach GOParent [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
			    set GOParent [GODB Type $Type GOSynonyme $GOParent GODeRef]
			    if {$GOParent == ""} {continue}
			    lappend LesGODeLaBoite $GOParent
			}
		    }
		}
		set LesGODeLaBoite [lsort -unique $LesGODeLaBoite]
		set TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO) $LesGODeLaBoite
	    } else {
		set LesGODeLaBoite [set TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO)]
	    }
	    foreach GO $LesGODeLaBoite {
		if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDuGroupe)]} {
		    set TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDuGroupe) {}
		}
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDuGroupe) $LaBoite
	    }
	    if {[info exists TabTmp(Groupe,$FichierGO,$Nom)]} {continue}
	    foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] {set TabTmp(Groupe,$FichierGO,$Jum) 1}

	    lappend TousLesGODesIndividusDuGroupe                                                  $LesGODeLaBoite
	    set TabTmp(Groupe,$FichierGO,$Nom) 1
	}
	foreach LaBoite [set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesBoitesGscope)] {
	    set Nom       [lindex $LaBoite 0]
	    set FichierGO [lindex $LaBoite 1]
	    
	    set FichierProtJum "[file dirname $FichierGO]/ProteinesJumelles"
	    Espionne "Population $Nom from $FichierGO"

	    if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO)]} {
		set LesGODeLaBoite {}
		foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
		    foreach Type [GODB GO $GO LesTypes                                 ] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			if {$GO == ""} {continue}
			lappend LesGODeLaBoite $GO
			foreach GOParent [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
			    set GOParent [GODB Type $Type GOSynonyme $GOParent GODeRef]
			    if {$GOParent == ""} {continue}
			    lappend LesGODeLaBoite $GOParent
			}
		    }
		}
		set LesGODeLaBoite [lsort -unique $LesGODeLaBoite]
		set TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO) $LesGODeLaBoite
	    } else {
		set LesGODeLaBoite [set TabDuChefDOrchestreDuCalculDEnrichissement(Gscope,$FichierGO,Nom,$Nom,LesGO)]
	    }

	    foreach GO $LesGODeLaBoite {
		if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDeLaPopulation)]} {
		    set TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDeLaPopulation) {}
		}
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesBoitesGscopeDeLaPopulation) $LaBoite
	    }

	    if {[info exists TabTmp(Population,$FichierGO,$Nom)]} {continue}
	    foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] {set TabTmp(Population,$FichierGO,$Jum) 1}

	    lappend TousLesGODesIndividusDeLaPop                                                  $LesGODeLaBoite
	    set TabTmp(Population,$FichierGO,$Nom) 1
	}
	if {[info exists TabTmp]} {unset TabTmp}

	########ACCESS###########
	set LesAccessDuGroupe [lsort -unique [set TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesAccess)    ]]
	foreach Access $LesAccessDuGroupe {
	    Espionne "Group $Access"
	    if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO)]} {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(Groupe,LesAccess) $Access

		set LesGODeLAccess {}
		set LesGO          [lsort -unique [Access2GO $Access]]
		set LesGO          [lsort -unique [concat $LesGO [TousLesAncetresGODesGO $LesGO]]]	
		foreach GO $LesGO {
		    foreach Type [GODB GO $GO LesTypes] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			if {[info exists TabTmp(Groupe,$Access,$GO)]} {continue}
			set TabTmp(Groupe,$Access,$GO) 1
			
			lappend LesGODeLAccess                                                       $GO
		    }
		}
		set     LesGODeLAccess                                                   [lsort -unique $LesGODeLAccess]
		set     TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO) $LesGODeLAccess
	    } else {
		set LesGODeLAccess [set TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO)]
	    }
	    foreach GO $LesGODeLAccess {
		if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDuGroupe)]} {
		    set TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDuGroupe) {}
		}
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDuGroupe) $Access
	    }
	    lappend TousLesGODesIndividusDuGroupe                                    $LesGODeLAccess
	}
	set LesAccessDeLaPop  [lsort -unique [set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesAccess)]]
	set TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesAccess) $LesAccessDeLaPop
	foreach Access $LesAccessDeLaPop {
	    Espionne "Population $Access"
	    if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO)]} {
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(Population,LesAccess) $Access
		
		set LesGODeLAccess {}
		set LesGO          [lsort -unique [Access2GO $Access]]
		set LesGO          [lsort -unique [concat $LesGO [TousLesAncetresGODesGO $LesGO]]]	
		foreach GO $LesGO {
		    foreach Type [GODB GO $GO LesTypes] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			if {[info exists TabTmp(Population,$Access,$GO)]} {continue}
			set TabTmp(Population,$Access,$GO) 1
			
			lappend LesGODeLAccess                                                             $GO
		    }
		}
		set     LesGODeLAccess                                                   [lsort -unique $LesGODeLAccess]
		set     TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO) $LesGODeLAccess
	    } else {
		set LesGODeLAccess [set TabDuChefDOrchestreDuCalculDEnrichissement(Access,$Access,LesGO)]
	    }
	    foreach GO $LesGODeLAccess {
		if {![info exists TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDeLaPopulation)]} {
		    set TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDeLaPopulation) {}
		}
		lappend TabDuChefDOrchestreDuCalculDEnrichissement(GO,$GO,LesAccessDeLaPopulation) $Access
	    }

	    lappend TousLesGODesIndividusDeLaPop                                     $LesGODeLAccess
	}
	################################################
	if {[info exists TabTmp]} {unset TabTmp}

	return [LesZscoreDesRequetesDuGroupe $TousLesGODesIndividusDuGroupe $TousLesGODesIndividusDeLaPop]
    }
    return

}

proc ChefDOrchestreDuGOHisto {args} {

    global TabDuChefDOrchestreDuGOHisto
    global LePanelPrincipalDuGOHisto

    if {$args == ""} {return}
    set PremierArg [lindex $args 0]

    if {[string equal -nocase $PremierArg "LesTypesDEntry"]} {
	return [list "Access" "Access file" "Blast file" "MSF file" "Clustering file" "Gscope GO file"]
    }
    
    if {[string equal -nocase $PremierArg "unset"]} {
	if {[lindex $args 1] != ""} {
	    set Quoi [join [lrange $args 1 end] ","]
	    if {[info exists TabDuChefDOrchestreDuGOHisto($Quoi)]} {unset TabDuChefDOrchestreDuGOHisto($Quoi)}
	} else {
	    if {[info exists TabDuChefDOrchestreDuGOHisto]} {unset TabDuChefDOrchestreDuGOHisto}
	    ChefDOrchestreDuGOHisto Ini
	}
	return
    }
    if {[string equal -nocase $PremierArg "Ini"]} {
	if {[info exists TabDuChefDOrchestreDuGOHisto]} {unset TabDuChefDOrchestreDuGOHisto}
	set TabDuChefDOrchestreDuGOHisto(LesAccess)           {}
	set TabDuChefDOrchestreDuGOHisto(LesBoitesGscope)     {}
	set TabDuChefDOrchestreDuGOHisto(LesIndividus)        {}

	set TabDuChefDOrchestreDuGOHisto(Valeur,nMin)      0
	set TabDuChefDOrchestreDuGOHisto(Valeur,nMax)      1.e200
	set TabDuChefDOrchestreDuGOHisto(Valeur,NivMin)    0
	set TabDuChefDOrchestreDuGOHisto(Valeur,NivMax)    1.e200
	return
    }
    if {[string equal -nocase $PremierArg "AppendGroup"]} {
	set Type  [lindex $args 1]
	set Entry [lindex $args 2]
	if {$Type == "" || $Entry == ""} {return}
	if {[regexp -nocase " file" $Type] && ![file exists $Entry]} {return}

	if {[string equal -nocase $Type "Access"]} {lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Entry}
	if {[string equal -nocase $Type "Access file"]} {
	    foreach Access [LesLignesDuFichier $Entry] {
		set Access [string trim $Access]
		if {$Access == ""} {continue}
		scan $Access "%s" Access
		lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Access
	    }
	}
	if {[string equal -nocase $Type "Blast file"]} {
	    foreach Access [DrawChoixDesHitsDuBlast  $Entry] {
		lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Access      
	    }
	}
	if {[string equal -nocase $Type "Clustering file"]} {
	    foreach Access [DrawChoixDesHitsDuClustering  $Entry] {
		lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Access        
	    }
	}
	if {[string equal -nocase $Type "MSF file"       ]} {
	    foreach Access [DrawChoixDesHitsDuMSF   $Entry] {
		lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Access        
	    }
	}
	if {[string equal -nocase $Type "Gscope GO file" ]} {
	    foreach LaBoiteGscope [DrawChoixDesBoitesDuProjetGscope  $Entry] {
		lappend TabDuChefDOrchestreDuGOHisto(LesBoitesGscope) $LaBoiteGscope
	    }
	}
	return
    }
    if {[string equal -nocase $PremierArg "set"]} {
	set Quoi [join [lrange $args 1 end] ","]
	if {![info exists TabDuChefDOrchestreDuGOHisto($Quoi)]} {return}
	return [set TabDuChefDOrchestreDuGOHisto($Quoi)]
    }
    if {[string equal -nocase $PremierArg "append"]} {
	set Quoi [join [lrange $args 1 end-1] ","]
	if {$Quoi == ""} {return}
	set AAjouter [lindex $args end]
	set TabDuChefDOrchestreDuGOHisto($Quoi) $AAjouter
	return [set TabDuChefDOrchestreDuGOHisto($Quoi)]
    }
    if {[string equal -nocase $PremierArg "Save"]} {
	set TousLesGO  [lindex $args 1]

	set nMin      [set TabDuChefDOrchestreDuGOHisto(Valeur,nMin)     ]
	set nMax      [set TabDuChefDOrchestreDuGOHisto(Valeur,nMax)     ]
	set NivMin    [set TabDuChefDOrchestreDuGOHisto(Valeur,NivMin)   ]
	set NivMax    [set TabDuChefDOrchestreDuGOHisto(Valeur,NivMax)   ]

	if {[info exists TabTmp]} {unset TabTmp}

	set LeTexte {}
	foreach GO [lsort -unique $TousLesGO] {
	    foreach Type [GODB GO $GO LesTypes] {
		set Niv [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]
		set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0]

		set n 0
		set LesRefs {}
		foreach LaBoite [ChefDOrchestreDuGOHisto "set" GO $GO LesBoitesGscope ] {
		    set Nom       [lindex $LaBoite 0]
		    set FichierGO [lindex $LaBoite 1]

		    if {[info exists TabTmp($FichierGO,$Nom,$Type,$GO)]} {continue}
		    set TabTmp($FichierGO,$Nom,$Type,$GO) 1

		    lappend LesRefs $Nom
		    incr n
		}
		set LesRefs [join $LesRefs " "]

		set LesAccess {}
		foreach Access [ChefDOrchestreDuGOHisto "set" GO $GO LesAccess] {
		    if {[info exists TabTmp($Access,$Type,$GO)]} {continue}
		    set TabTmp($Access,$Type,$GO) 1
		    lappend LesRefs $Access
		    incr n
		}
		
		if {[EstCeUnNombre $nMin     ] && $n        < $nMin       } {continue}
		if {[EstCeUnNombre $nMax     ] && $n        > $nMax       } {continue}
		if {[EstCeUnNombre $NivMin   ] && $Niv      < $NivMin     } {continue}
		if {[EstCeUnNombre $NivMax   ] && $Niv      > $NivMax     } {continue}

		lappend LeTexte [list $GO $Type $Niv $Def $n $LesRefs] 
	    }
	    ChefDOrchestreDuGOHisto unset GO $GO LesAccess
	    ChefDOrchestreDuGOHisto unset GO $GO LesBoitesGscope
	}
	if {$LeTexte == {}} {return}
	set File [tk_getSaveFile -title "Choose a file name to save results"]
	if {[file exists $File]} {File delete -force $File}

	AppendAuFichier $File "GO\tType\tLevel\tDescription\tn\tLinks"
	foreach Ligne [lsort -index 4 -real -decreasing $LeTexte] {AppendAuFichier $File [join $Ligne "\t"]}
	return $File
    }

    if {[string equal -nocase $PremierArg "Affiche"]} {
	set TousLesGO  [lindex $args 1]

	set nMin      [set TabDuChefDOrchestreDuGOHisto(Valeur,nMin)     ]
	set nMax      [set TabDuChefDOrchestreDuGOHisto(Valeur,nMax)     ]
	set NivMin    [set TabDuChefDOrchestreDuGOHisto(Valeur,NivMin)   ]
	set NivMax    [set TabDuChefDOrchestreDuGOHisto(Valeur,NivMax)   ]

	set NbBarre 0

	if {[info exists TabTmp]} {unset TabTmp}

	set ListePourLHisto {}
	foreach GO [lsort -unique $TousLesGO] {
	    foreach Type [GODB GO $GO LesTypes] {
		set Niv [lindex [GODB Type $Type GO $GO LesNiveaux    ] 0]
		set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0]
		
		set     LInfo {}
		lappend LInfo "GO         : $GO"
		lappend LInfo "Type       : $Type"
		lappend LInfo "Definition : $Def" 

		set n 0

		foreach LaBoite [ChefDOrchestreDuGOHisto "set" GO $GO LesBoitesGscope ] {
		    set Nom       [lindex $LaBoite 0]
		    set FichierGO [lindex $LaBoite 1]

		    if {[info exists TabTmp($FichierGO,$Nom,$Type,$GO)]} {continue}
		    set TabTmp($FichierGO,$Nom,$Type,$GO) 1
		    lappend LInfo " $Nom $FichierGO"
		    incr n
		}
		set LesAccess {}
		foreach Access [ChefDOrchestreDuGOHisto "set" GO $GO LesAccess] {
		    if {[info exists TabTmp($Access,$Type,$GO)]} {continue}
		    set TabTmp($Access,$Type,$GO) 1
		    lappend LesAccess $Access
		    incr n
		}

		lappend LInfo [join $LesAccess " "]

		if {[EstCeUnNombre $nMin     ] && $n        < $nMin       } {continue}
		if {[EstCeUnNombre $nMax     ] && $n        > $nMax       } {continue}
		if {[EstCeUnNombre $NivMin   ] && $Niv      < $NivMin     } {continue}
		if {[EstCeUnNombre $NivMax   ] && $Niv      > $NivMax     } {continue}

		incr NbBarre
				
		set ET     ""
		set Color "lightgrey"
		if {[string equal -nocase $Type "component"]} {set Color "green";set T "C"}
		if {[string equal -nocase $Type "function" ]} {set Color "blue" ;set T "F"}
		if {[string equal -nocase $Type "process"  ]} {set Color "red"  ;set T "P"}
		
		set Qui "$T $GO : $Def [format "%8s" $n]"
	    
		set LeTexteDefinitif {}
		foreach Ligne $LInfo {
		    while {100 < [string length $Ligne]} {
			lappend LeTexteDefinitif [string range $Ligne 0  59 ]
			set     Ligne            [string range $Ligne 60 end]
		    }
		    if {[string length $Ligne] != 0} {lappend LeTexteDefinitif $Ligne}
		}
		set     LesTags         [list "GO" [join $LeTexteDefinitif "\n"]]
		lappend ListePourLHisto [list $Qui $Color $n $ET $LesTags]
	    }
	    ChefDOrchestreDuGOHisto unset GO $GO LesAccess
	    ChefDOrchestreDuGOHisto unset GO $GO LesBoitesGscope
	}

	if {$ListePourLHisto == {}} {return}

	set ListePourLHisto [lsort -index 2 -real  -decreasing $ListePourLHisto]

	set ListePourLHisto [linsert $ListePourLHisto 0 "n"]


	if {$NbBarre <= 0} {return}
	if {[info exists TabTmp]} {unset TabTmp}

	set FrameDuCanva  ""
	set KCanva         [lindex $LePanelPrincipalDuGOHisto 0]
	regsub {\.[^\.]+$} $KCanva "" FrameDuCanva

	if {[winfo exists $FrameDuCanva]} {destroy $FrameDuCanva}
	set FrameCanva [lindex $LePanelPrincipalDuGOHisto 5]
	set LMax       [lindex $LePanelPrincipalDuGOHisto 1]
	set HMax       [lindex $LePanelPrincipalDuGOHisto 2]
	set LWin       [lindex $LePanelPrincipalDuGOHisto 3]
	set HWin       [lindex $LePanelPrincipalDuGOHisto 4]
	set HauteurMax     [expr $HWin * 1.0 / 15 + $NbBarre * 30]
	if {$HauteurMax < $HWin} {set HauteurMax $HWin}
	set KCanva         [Canva $LMax $HauteurMax $LWin $HWin NoY "" "" $FrameCanva]
	$KCanva configure -background white
	set LePanelPrincipalDuGOHisto [list $KCanva $LMax $HMax $LWin $HWin $FrameCanva]
	
	PlaceLHistogramme $ListePourLHisto $KCanva 0 $HauteurMax 0 $LWin "Vertical"
	return $KCanva
    }
    if {[string equal -nocase $PremierArg "Calcul"]} {
	set TousLesGO {}
	set LesBoitesGscope  [set TabDuChefDOrchestreDuGOHisto(LesBoitesGscope)]
	set LesAccess        [lsort -unique [set TabDuChefDOrchestreDuGOHisto(LesAccess)    ]]
	foreach LaBoite $LesBoitesGscope {
	    Espionne $LaBoite
	    set Nom       [lindex $LaBoite 0]
	    set FichierGO [lindex $LaBoite 1]
	    set LesGODeLaBoite {}
	    if {![info exists TabDuChefDOrchestreDuGOHisto(Gscope,$FichierGO,Nom,$Nom,LesGO)]} {
		foreach     GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
		    foreach Type [GODB GO $GO LesTypes                     ] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			if {$GO == ""} {continue}
			lappend LesGODeLaBoite $GO
			foreach GOParent [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
			    set GOParent [GODB Type $Type GOSynonyme $GOParent GODeRef]
			    if {$GOParent == ""} {continue}
			    lappend LesGODeLaBoite $GOParent
			}
			
		    }
		}

		set LesGODeLaBoite                                [lsort -unique $LesGODeLaBoite]
		set TabDuChefDOrchestreDuGOHisto(Gscope,$FichierGO,Nom,$Nom,LesGO) $LesGODeLaBoite
	    } else {
		set LesGODeLaBoite [set TabDuChefDOrchestreDuGOHisto(Gscope,$FichierGO,Nom,$Nom,LesGO)]
	    }
	    foreach GO [lsort -unique $LesGODeLaBoite] {
		if {[info exists TabTmp($FichierGO,$Nom,$GO)]} {continue}
		set TabTmp($FichierGO,$Nom,$GO) 1

		if {![info exists TabDuChefDOrchestreDuGOHisto(GO,$GO,LesBoitesGscope)]} {
		    set TabDuChefDOrchestreDuGOHisto(GO,$GO,LesBoitesGscope) {}
		}
		lappend TabDuChefDOrchestreDuGOHisto(GO,$GO,LesBoitesGscope) $LaBoite
		lappend TousLesGO $GO
	    }
	}
	if {[info exists TabTmp]} {unset TabTmp}

	########ACCESS###########
	foreach Access $LesAccess {
	    Espionne "$Access"
	    if {![info exists TabDuChefDOrchestreDuGOHisto(Access,$Access,LesGO)]} {
		lappend TabDuChefDOrchestreDuGOHisto(LesAccess) $Access

		set LesGODeLAccess {}
		set LesGO          [lsort -unique [Access2GO $Access]]
		set LesGO          [lsort -unique [concat $LesGO [TousLesAncetresGODesGO $LesGO]]]	
		foreach GO $LesGO {
		    foreach Type [GODB GO $GO LesTypes] {
			set GO [GODB Type $Type GOSynonyme $GO GODeRef]
			lappend LesGODeLAccess                             $GO
		    }
		}
		set     LesGODeLAccess                                     [lsort -unique $LesGODeLAccess]
		set     TabDuChefDOrchestreDuGOHisto(Access,$Access,LesGO) $LesGODeLAccess
	    } else {
		set LesGODeLAccess [set TabDuChefDOrchestreDuGOHisto(Access,$Access,LesGO)]
	    }
	    foreach GO [lsort -unique $LesGODeLAccess] {
		if {[info exists TabTmp($Access,$GO)]} {continue}
		set TabTmp($Access,$GO) 1

		if {![info exists TabDuChefDOrchestreDuGOHisto(GO,$GO,LesAccess)]} {
		    set TabDuChefDOrchestreDuGOHisto(GO,$GO,LesAccess) {}
		}
		lappend TabDuChefDOrchestreDuGOHisto(GO,$GO,LesAccess) $Access
		lappend TousLesGO                          $GO
	    }
	}
	################################################
	if {[info exists TabTmp]} {unset TabTmp}

	return [lsort -unique $TousLesGO]
    }
    return

}

proc CheminRibbon {type Lca Lcol {Lc ""} {Lo ""}} {

    if {$type eq "Nucleic"} {
	set Lca [Lissage3D $Lca]
	set nLcol [lrange $Lcol 0 1]
	for {set i 1} {$i < [llength $Lcol]-1} {incr i} {
	    lappend nLcol {*}[lrepeat 4 [lindex $Lcol $i]]
	}
	lappend nLcol [lindex $Lcol end]

	return [list $type $Lca $nLcol]
    }

    # ribbon de protein
    set LU $Lca
    set LV {}
    foreach ca1 $Lc ca2 $Lo  {
	set V [V_VV $ca2 - $ca1]
	set n [expr {1.0/[NormVec $V]}]
	set V [V_VS $V * $n]
	lappend LV $V
    }

    #GetRad $LU

    set len [llength $LV]
    set u0 [lindex $LV 0]
    lappend newv $u0
    foreach v [lrange $LV 1 end] {
	set norm [S_VV $u0 * $v]
	if {$norm < 0.0} {set v [V_SV -1. * $v]}
	set u0 $v
	lappend newv $v
    }
    set LV $newv

    # Lissage 3D par polynome Lagrange ordre 5
    set LNewU [Lissage3D $LU]
    set LNewV [Lissage3D $LV]

    # calcul des normales
    set L1 [lrange $LNewU 2 [expr {4*($len-1)}]]
    set L2 [lrange $LNewU 0 [expr {4*($len-1)-2}]]
    set LV [lrange $LNewV 1 [expr {4*($len-1)-1}]]
    foreach x1 $L1 x2 $L2 v $LV {
	set u0 [V_VV $x1 - $x2]
	set w [Vectoriel $u0 $v]
	set norm [NormVec2 $w]
	if {$norm > 0.001} {set norm [expr {1.0/sqrt($norm)}]}
	lappend Lw [V_SV $norm * $w]
    }

    # les extremites
    set Lw [linsert $Lw end [lindex $Lw end]]
    set Lw [linsert $Lw 0   [lindex $Lw 1]]

    set d1 0.7
    set d2 0.7

    set col1 [list 1.0 0.3 0.3]
    set col2 [list 1.0 0.3 0.3]
    set kstep 1

    # compute coordinates of points and of the normals
    set f [open logpt w]
    set LesVecs {}
    for {set i 0} {$i < $len-1} {incr i} {
	set c1 [lindex $Lcol $i]
	set c2 [lindex $Lcol $i]
	for {set k [expr {4*$i}]} {$k < 4*($i+1)} {incr k} {
	    # couleurs
	    set mlt [expr {$k-4.*$i}]
	    # set c1 [V_VV $col1 + [V_VS [V_VS [V_VV $col2 - $col1] * 0.25] * $mlt]]
	    # set c2 [V_VV $col1 + [V_VS [V_VS [V_VV $col2 - $col1] * 0.25] * [expr {$mlt+1}]]]

	    # points
	    set d [expr {$d1 + ($d2-$d1)*0.25*$mlt}]
	    set uk [lindex $LNewU $k]
	    set up [lindex $LNewU $k+1]
	    set vk [lindex $LNewV $k]
	    set vp [lindex $LNewV $k+1]
	    set wk [lindex $Lw $k]
	    set wp [lindex $Lw $k+1]

	    set p1 [V_VV $uk - [V_SV $d * $vk]]
	    set p2 [V_VV $uk + [V_SV $d * $vk]]
	    set d [expr {$d1 + ($d2-$d1)*0.25*($k+1.-4.*$i)}]
	    set p3 [V_VV $up - [V_SV $d * $vp]]
	    set p4 [V_VV $up + [V_SV $d * $vp]]

	    set fmt "%d %s %6.2f %6.2f %6.2f"
	    if {$k % 2} {
		#lappend LesVecs $wk $c1 $p1 $wp $c2 $p3 $wk $c1 $p2
		#lappend LesVecs $wk $c1 $p2 $wp $c2 $p3 $wp $c2 $p4


		lappend LesVecs $wk $c1 $p1 $wp $c2 $p4 $wk $c1 $p2
		lappend LesVecs $wk $c1 $p1 $wp $c2 $p3 $wp $c2 $p4


		#puts $f [format $fmt $k A {*}$p1]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k B {*}$p4]
		#puts $f [format $fmt $k N {*}$wp]
		#puts $f [format $fmt $k C {*}$p2]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k D {*}$p1]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k E {*}$p3]
		#puts $f [format $fmt $k N {*}$wp]
		#puts $f [format $fmt $k F {*}$p4]
		#puts $f [format $fmt $k N {*}$wp]
		#puts ""
		#puts ""
	    } else {
		lappend LesVecs $wk $c1 $p1 $wp $c2 $p4 $wk $c1 $p2
		lappend LesVecs $wk $c1 $p1 $wp $c2 $p3 $wp $c2 $p4
		#puts $f [format $fmt $k A {*}$p1]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k B {*}$p4]
		#puts $f [format $fmt $k N {*}$wp]
		#puts $f [format $fmt $k C {*}$p2]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k D {*}$p1]
		#puts $f [format $fmt $k N {*}$wk]
		#puts $f [format $fmt $k E {*}$p3]
		#puts $f [format $fmt $k N {*}$wp]
		#puts $f [format $fmt $k F {*}$p4]
		#puts $f [format $fmt $k N {*}$wp]
		#puts ""
	    }
	}
	if {$i == 10000} {
	    set foo $f
	    set f stdout
	}
    }
    if {$i < 10000} {
	close $f
    } else {
	close $foo
    }
    return [list $type $LesVecs]

}

proc CheminsAgent {n1 ag1 n2 ag2} {

    JeMeSignale
    global LesBonsSousChemins NiveauAgent AreteDejaVu
    
    global limit niveau
    #if {[incr limit] > 800} {exit}

    set LesCheminsDesFils {}
    if {$n1 eq "s08"} {
	return "Arrive"
	set LesCheminsDesFils [list "Arrive"]
    }
    
    if { ! [info exists NiveauAgent]} {
	set NiveauAgent 0 
    }
    
    
    incr NiveauAgent
    Espionne $NiveauAgent
    set Decal [string repeat " " $NiveauAgent]
    
    foreach fils [FilsDe $n1 $ag1] {
	lassign $fils nf agf scf
	if {($nf eq $n1) && ($agf == $ag1)} {
	    continue 
	}
	if {[info exists AreteDejaVu($n1,$ag1,$nf,$agf)]} {
	    continue
	}
	set AreteDejaVu($n1,$ag1,$nf,$agf) 1
	#Espionne ""
	#Espionne "$Decal filsde $n1 $ag1 = $nf $agf" 

	set LesCheminsDuFils [CheminsAgent $nf $agf $n2 $ag2]
	#set LesBonsSousChemins($a-$fils) $LesCheminsDuFils
  
	foreach CheminTrouve $LesCheminsDuFils {
	    set CheminParcouru [list $n1 $ag1 $nf $agf {*}$CheminTrouve]
	    #Espionne "$Decal trouve $CheminParcouru"
	    lappend LesCheminsDesFils $CheminParcouru
	}
	unset AreteDejaVu($n1,$ag1,$nf,$agf)
	#Espionne "$Decal LesCheminsDuFils $LesCheminsDuFils"
    }
    #Espionne "LesCheminsDesFils $LesCheminsDesFils"
    incr NiveauAgent -1

    return $LesCheminsDesFils

}

proc CheminsAgentAA {n1 ag1 n2 ag2} {
 global LesBonsSousChemins T
    
    return [CheminsAgent $n1 $ag1 $n2 $ag2]

}

proc CheminsAgentAARR {a b} {

    global LesBonsSousChemins MaxNiveau
    set R [CheminsAgentRR $a $b]
    Espionne $MaxNiveau
    return $R

}

proc CheminsAgentRR {a b} {

#    JeMeSignale
    global LesBonsSousChemins NiveauAgent AreteDejaVu MaxNiveau

    set LesCheminsDesFils {}
    if {[regexp "s08" $a]} { return "Arrive"; set LesCheminsDesFils [list "Arrive"] }

    if { ! [info exists NiveauAgent]} { set NiveauAgent 0 ; set MaxNiveau 0 }

    incr NiveauAgent
    set MaxNiveau [Maxi $MaxNiveau $NiveauAgent]
    set Decal [string repeat "\t" $NiveauAgent]

    foreach fils [FilsDeRR $a] {
	if {$fils==$a} { continue }
	if {[info exists AreteDejaVu($a-$fils)]} { continue }
	set AreteDejaVu($a-$fils) 1
#	Espionne ""
#	Espionne "$Decal filsde $a = $fils" 

	set LesCheminsDuFils [CheminsAgentRR $fils $b]
	#set LesBonsSousChemins($a-$fils) $LesCheminsDuFils
  
	foreach CheminTrouve $LesCheminsDuFils {
	    
	    set CheminParcouru "$a-$fils $CheminTrouve"
#	    Espionne "$Decal trouve $CheminParcouru"
	    lappend LesCheminsDesFils $CheminParcouru
	}
	unset AreteDejaVu($a-$fils)
#	Espionne "$Decal LesCheminsDuFils $LesCheminsDuFils"
    }
#    Espionne "LesCheminsDesFils $LesCheminsDesFils"
    incr NiveauAgent -1
    return $LesCheminsDesFils

}

proc ChercheDansFichierXML {Balise FichierXML} {

    set RepHTML "/home/chalmel/ProjRetine/PagesHTML"
    set FichierXML "$RepHTML/$FichierXML"
    if {![file exists $FichierXML]} {return ""}
    set PageXML [ContenuDuFichier $FichierXML]
    set Query [ChercheDansPageXML $Balise $PageXML]
    return $Query

}

proc ChercheDansPageXML {Balise PageXML} {

    if {[regexp "<" $Balise]} {regsub "<" $Balise "" Balise}
    if {[regexp ">" $Balise]} {regsub ">" $Balise "" Balise}
    if {[regexp "/" $Balise]} {regsub "/" $Balise "" Balise}
    set BaliseOuvrante "<$Balise>"
    set BaliseFermante ""

    set LesLignesDeLaPage [split $PageXML "\n"]
    set SuisJeDansMaQuery 0
    set Query ""
    foreach Ligne $LesLignesDeLaPage {
	while {[regexp "^ " $Ligne] } {regsub "^ " $Ligne "" Ligne}
	if {    [regexp -nocase $BaliseOuvrante $Ligne] &&  [regexp -nocase $BaliseFermante $Ligne]} {
	    regsub "$BaliseOuvrante" $Ligne "" Ligne
	    regsub "$BaliseFermante" $Ligne "" Ligne
	    set Query "$Ligne"
	    return $Query
	} else {
	    if {[regexp "$BaliseOuvrante" $Ligne]} {
		set SuisJeDansMaQuery 1
		regsub "$BaliseOuvrante" $Ligne "" Ligne
		append Query $Ligne
	    }
	    if {[regexp "$BaliseFermante" $Ligne]} {
		set SuisJeDansMaQuery 0
		regsub "$BaliseFermante" $Ligne "" Ligne
		append Query $Ligne
	    }
	    if {$SuisJeDansMaQuery} {
		append Query "$Ligne\n" 
    }   }   }
    return "$Query"

}

proc ChercheFonction {orf} {

    set lesfonctions [LitFichier "/home/lecompte/genomes/casimir/fiches/fonctionsvalidees"]
    set numero [string range $orf 4 7]
    set indice [lsearch -regexp $lesfonctions PAB$numero]
    set toto [lindex $lesfonctions $indice]
    while {[regsub -all "  " $toto " " toto]} {}
    set fonction [join [lrange [split $toto " "] 4 end] " "]
    return $fonction

}

proc ChercheLesGapsInternes {} {

	
	set FichierEntree [open "/genomics/link/STAF/fiches/VDR/Conservation/FichiersDesRepechesMouse.txt" "r"]
	set FichierSortie  [open "/genomics/link/STAF/fiches/VDR/Conservation/FichiersDesRepechesMouse.best" "w"]
	
	while { [gets $FichierEntree Ligne]  >=0 } {
		ScanLaListe $Ligne ID DRmouse ChromosomeM StartM EndM StrandM SequenceM NbGaps SequenceH UcscH AccesH DescriptionH
		set ListeBasesSequenceM [split $SequenceM ""]
		if { [lindex $ListeBasesSequenceM 0] != "-" && [lindex $ListeBasesSequenceM 1] != "-" && [lindex $ListeBasesSequenceM 2] != "-" && [lindex $ListeBasesSequenceM 3] != "-" && [lindex $ListeBasesSequenceM 4] != "-" && [lindex $ListeBasesSequenceM 5] != "-" } {
			if { $DRmouse == "DR3"} {
				if {[lindex $ListeBasesSequenceM 10] != "-" && [lindex $ListeBasesSequenceM 11] != "-" && [lindex $ListeBasesSequenceM 12] != "-" && [lindex $ListeBasesSequenceM 13] != "-" && [lindex $ListeBasesSequenceM 14] != "-" && [lindex $ListeBasesSequenceM 15] != "-"} {
					regsub -all -nocase {\-} $SequenceM "" MouseReduced 
					set MouseVdrPattern ""
					set MouseVdrPattern [VdrInteractivePattern $MouseReduced $StrandM]
						if { [string range $MouseVdrPattern 0 1] == "+" } {
								puts $FichierSortie $Ligne
						}
				}
			}
			if { $DRmouse == "DR4"} {
				if {[lindex $ListeBasesSequenceM 16] != "-" && [lindex $ListeBasesSequenceM 11] != "-" && [lindex $ListeBasesSequenceM 12] != "-" && [lindex $ListeBasesSequenceM 13] != "-" && [lindex $ListeBasesSequenceM 14] != "-" && [lindex $ListeBasesSequenceM 15] != "-"} {
					regsub -all -nocase {\-} $SequenceM "" MouseReduced 
					set MouseVdrPattern ""
					set MouseVdrPattern [VdrInteractivePattern $MouseReduced "+"]
						if { [string range $MouseVdrPattern 0 1] == "DR" } {
								puts $FichierSortie $Ligne
						}
				}
			}
			if { $DRmouse == "DR6"} {
				if {[lindex $ListeBasesSequenceM 18] != "-" && [lindex $ListeBasesSequenceM 17] != "-" && [lindex $ListeBasesSequenceM 16] != "-" && [lindex $ListeBasesSequenceM 15] != "-" && [lindex $ListeBasesSequenceM 14] != "-" && [lindex $ListeBasesSequenceM 13] != "-"} {
					regsub -all -nocase {\-} $SequenceM "" MouseReduced 
					set MouseVdrPattern ""
					set MouseVdrPattern [VdrInteractivePattern $MouseReduced "+"]
					if { [string range $MouseVdrPattern 0 1] == "DR" } {
						puts $FichierSortie $Ligne
					}
				}
			}
		}
	}

}

proc ChercheLesOligosDoubles {} {

    foreach P [Oli "LaListeMerci"] {
	set Seq [string toupper [Oli $P Seq]]
	if {[info exists DejaVu($Seq)]} {
	    lappend DejaVu($Seq) "$P [Oli $P Description]"
	    Espionne "\n[join [set DejaVu($Seq)] "\n"]"
	} else {
	    lappend DejaVu($Seq) "$P [Oli $P Description]"
	}
    }
    exit

}

proc ChercheMeilleureChaine {} {

    
    if {$SeqAss == ""} {return}
    
    if {$cherchemaxcc} {
	set chn [ChercheMeilleureChaineDuPDB $SeqAss $MolId]
    } else {
	regsub -all {\.} $SeqPdb "" SeqDegape
	set PDB_[set MolId]_Sequence($chn) $SeqDegape
	lappend PDB_[set MolId]_Sequence($chn) $SeqPdb
	return $chn
    }
    set fic "[SigneFichier [string trim [file join $OrdTmpDir tmp${MolId}$chn]].msf]"
    
    # Seq PDB alignee sur la sequence ref degapee
    
    set NomDuFichierMSF $fic
    DecortiqueUnMSF $NomDuFichierMSF NomSwNomPDB SeqSwSeqPDB
    regsub -all {\-} $SeqSwSeqPDB(seqtest) "." laseq
    set PDB_[set MolId]_Sequence($chn) $laseq
    
    # Seq PDB alignee sur la sequence ref TELLE QU ELLE EST DANS ALIGNT
    
    set laseqref [set Sequences($SeqAss)]
    set laseq [join [set PDB_[set MolId]_NomRes($chn)] ""]
    set seqali [CalculeAligntContreGlobal $laseqref $laseq $MolId]
    lappend PDB_[set MolId]_Sequence($chn) $seqali
    
    return $chn

}

proc ChercheMeilleureChaineDuPDB {SeqAss MolId} {

    global PDB_[set MolId]_ChnIdn
    global PDB_[set MolId]_NomRes
    
    set NbrChn [llength PDB_[set MolId]_ChnIdn]
    set scoremax -999
    set maxcc -1
    
    set LesChaines [set PDB_[set MolId]_ChnIdn]
    foreach cc $LesChaines {
	set str [join [set PDB_[set MolId]_NomRes($cc)] ""]
	set score($cc) [CalculeAlignt $str $SeqAss $cc $MolId]
	if {[set score($cc)] > $scoremax} {
	    set scoremax [set score($cc)]
	    set maxcc $cc
	}
    }
    
    return $maxcc

}

proc ChercheMotif {} {

    global NomTextSeq LSOrdali Chrc LNOrdali LNSeqlab

    if {[set LeMotif [EstUnBonPattern $Chrc(Motif)]] == 0} {
	return
    }

    if {$Chrc(prevMode) eq "seqlab"} {
	set LNoms $LNSeqlab
	set LSeqs [$NomTextSeq output all]
    } else {
	set LNoms $LNOrdali
	set LSeqs $LSOrdali
    }

    set i 0
    set Loccu {}
    foreach seq $LSeqs nom $LNoms {
	incr i
	if {$nom eq ""} {continue}
	set sdg [string map {"." "" " " ""} $seq]

	if {[catch {set LIdx [regexp -indices -all -inline -- $LeMotif $sdg]}]} {
	    FaireLire "Problem when searching !\nPlease check your pattern !"
	    return
	}
	if {$LIdx == {} } {continue}

	foreach e $LIdx {
	    lassign $e d f
	    if {$Chrc(prevMode) eq "seqlab"} {
		set dg [lindex [lindex [regexp -all -inline -indices {[A-Z]} $seq] $d] 0]
		set fg [lindex [lindex [regexp -all -inline -indices {[A-Z]} $seq] $f] 0]
		lappend Loccu [list $i.$dg $i.$fg]
	    } else {
		set dg [DonnePosSG $nom $d]
		set fg [DonnePosSG $nom $f]
		lappend Loccu [list $i.$dg $i.[expr {$fg+1}]]
	    }
	}
    }

    set Chrc(NextOc) {}
    set Chrc(LOccus) [list]
    foreach o $Loccu {
	lassign $o d f
	lappend Chrc(NextOc) $d
	lappend Chrc(LOccus) $d $f
    }
    set Chrc(NbrOccus) "[llength $Chrc(NextOc)] found"
    set Chrc(IdxMotif) 0
    if {$Chrc(LOccus) != {}} {
	set idx [lindex $Chrc(NextOc) $Chrc(IdxMotif)]
	$NomTextSeq see $idx
	lassign [split $idx .] line col
	$::NomNomSeq  see $line.1
    }

    PeintHitsCherche

    return

}

proc ChercheMotifSuivant {{enplace 0}} {

    global NomTextSeq Chrc

    set lg [llength $Chrc(NextOc)]
    if {! $lg} {return}
    if {! $enplace} {
	if {$Chrc(IdxMotif) == $lg-1} {
	    set Chrc(IdxMotif) 0
	} else {
	    incr Chrc(IdxMotif)
	}
    }

    $NomTextSeq see [lindex $Chrc(NextOc) $Chrc(IdxMotif)]

    return

}

proc ChercheNom {} {

    global NomNomSeq NomTextSeq SearchNom SNOld IdPosSearch

    #puts "SearchNom $SearchNom"
    set SearchNom [string trim $SearchNom]
    if {$SearchNom eq ""} {return}

    set Ln [split [$NomNomSeq get 1.0 end] "\n"]
    set Li [lsearch -all -nocase -regexp $Ln $SearchNom]
    if {$Li eq ""} {return}

    if {! [info exists SNOld] || $SNOld ne $SearchNom} {
	set IdPosSearch 0
	set SNOld $SearchNom
    } else {
	incr IdPosSearch
	if {$IdPosSearch >= [llength $Li]} {
	    set IdPosSearch 0
	}	
    }

    set yc [expr {[lindex $Li $IdPosSearch]+1}]
    set pos [$NomNomSeq index @0,0]
    $NomNomSeq  see $pos
    $NomTextSeq see $pos
    lassign [split $pos .] yv xv 
    set D [expr {$yc-$yv}]

    $NomNomSeq  yview scroll $D units
    $NomTextSeq yview scroll $D units

    return

}

proc ChercheNomDansListe {} {

    global EFeat

    #puts "SearchNom $SearchNom"
    set SearchNom [string trim $EFeat(SearchNom)]
    if {$SearchNom eq ""} {return}
    set Ln $EFeat(ListboxListe)
    set Li [lsearch -all -nocase -regexp $Ln $SearchNom]
    if {$Li eq ""} {return}

    if {! [info exists EFeat(SNOld)] || $EFeat(SNOld) ne $SearchNom} {
	set EFeat(IdPosSearch) 0
	set EFeat(SNOld) $SearchNom
    } else {
	incr EFeat(IdPosSearch)
	if {$EFeat(IdPosSearch) >= [llength $Li]} {
	    set EFeat(IdPosSearch) 0
	}	
    }

    set yc [expr {[lindex $Li $IdPosSearch]+1}]
    set pos [$EFeat(Listbox) index @0,0]
    $EFeat(Listbox) see $pos
    lassign [split $pos .] yv xv 
    set D [expr {$yc-$yv}]

    $EFeat(Listbox) yview scroll $D units

    return

}

proc CherchePCI {w args} {

    global TPCI nsq1 nsq2 pciLbl pl1Lbl pl2Lbl

    if {$nsq1 eq "" || $nsq2 eq "" || $nsq1 eq "Select" || $nsq2 eq "Select"} {return}

    set pair1 "$nsq1,$nsq2"
    if {! [info exists TDesPCI($pair1)]} {
	CalculeLesPCI "" "" $nsq1 $nsq2
	update
    }
    set val [set TPCI($pair1)]
    set pci [lindex $val 0]
    set pl1 [lindex $val 1]
    set pl2 [lindex $val 2]
    set pci [format "%5.1f" [expr {$pci*100.}]]

    set pciLbl "Identity : $pci %"
    set pl1Lbl "length 1 : $pl1"
    set pl2Lbl "lenght 2 : $pl2"

    return

}

proc ChercheProfilParticulier {AnalysisSoftware} {

    #AnalysisSoftware= RMA or dChip
    set total 0; set nb 0; set signi 0; set nonsigni 0
    set RepertoireSi "[RepertoireDuGenome]/transcriptomique/ConeSpe/SignalIntensityExp2J15"
    set FichierRMA   "[RepertoireDuGenome]/transcriptomique/ConeSpe/ListeRMAExp2J15Cond"
    set FichierdChip "[RepertoireDuGenome]/transcriptomique/ConeSpe/ListedChipExp2J15Cond"
    set LaListe$AnalysisSoftware {}
    foreach File [glob -nocomplain "$RepertoireSi/*"] {
	incr total
	set BeauPs [file tail $File]
	set LesSiTrb {}; set LesSiRd7 {}; set LesSiWt {}
	foreach Ligne [LesLignesDuFichier $File] {
	    set elmts [split $Ligne "\t"]
	    if {[regexp "Trbeta" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} {
		lappend LesSiTrb [lindex $elmts 4]
	    }
	    if {[regexp "rd7" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} {
		lappend LesSiRd7 [lindex $elmts 4]
	    }
	    if {[regexp "wt" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} {
		lappend LesSiWt [lindex $elmts 4]
	    }
	}
	Espionne "$BeauPs"
	set MoyTrb [MoyenneDeLaListe $LesSiTrb]
	set MoyRd7 [MoyenneDeLaListe $LesSiRd7]
	set MoyWt  [MoyenneDeLaListe $LesSiWt]
	if {$MoyRd7>$MoyWt && $MoyWt>$MoyTrb} {
	    incr nb
	    Espionne "Rd7 $LesSiRd7 $MoyRd7"
	    Espionne "Wt  $LesSiWt  $MoyWt"
	    Espionne "Trb $LesSiTrb $MoyTrb"
	    lappend LaListe$AnalysisSoftware $BeauPs
	}
    }
    EspionneL [set LaListe$AnalysisSoftware]
    if {[regexp -nocase "RMA" $AnalysisSoftware]} {
	#SauveLesLignes [set LaListe$AnalysisSoftware] dans $FichierRMA
    }
    if {[regexp -nocase "dChip" $AnalysisSoftware]} {
	#SauveLesLignes [set LaListe$AnalysisSoftware] dans $FichierdChip
    }
    Espionne "total $total"
    Espionne "nb $nb"
    Espionne "signi $signi"
    Espionne "nonsigni $nonsigni"

}

proc ChercheQuelOrf {listeorfs SeqSws} {

    # transforme listeorfs en tableau
    foreach orf $listeorfs {
	set ib [string first " " $orf]
	set k [string range $orf 0 $ib-1]
	lappend Lk $k
	set v [string trim [string range $orf $ib+1 end]]
	set ie [string first "=" $v]
	set c [string range $v 0 $ie-1]
	if {[string index $c 0] eq "/"} {
	    set c [string range $c 1 end]
	}
	if {$c eq "DNA"} {set c "ADN"}
	set v [string range $v $ie+1 end]

	set Torf($k,$c) $v
    }
    set Lorfs [lsort -dictionary -unique $Lk]
    puts "\tNombre ORFs : [llength $Lorfs]"

    # maintenant on parcout le tableau
    set trouveorf 0
    set SeqAdn ""
    foreach orf $Lorfs {
	# debug ...
	foreach ko [array names Torf $orf,*] {
	    #puts "$ko $Torf($ko)"
	}

	if {[info exists Torf($orf,translation)] && ! $trouveorf} {
	    # On compare les sequences traduites avec la Sws
	    puts "\tPrend seq traduite de orf $orf"
	    set sequenceembl [set Torf($orf,translation)]
	    set seqD [set Torf($orf,ADN)]
	} else {
	    if {[info exists Torf($orf,ADN)]} {
		puts "\tPrend ADN de orf $orf"
		set seqD [string toupper $Torf($orf,ADN)]
		set sequenceembl [SeqNucToSeqPro $seqD]
	    } elseif {[info exists Torf($orf,DNA)]} {
		puts "\tPrend DNA de orf $orf"
		set seqD [string toupper $Torf($orf,DNA)]
		set sequenceembl [SeqNucToSeqPro $seqD]
	    } else {
		puts "PROBLEM !! ORF sans ADN"
		continue
	    }
	}

	# enleve codon stop
	if {[string index $sequenceembl end] eq "*"} {
	    set sequenceembl [string range $sequenceembl 0 end-1]
	}
	if {[SeqNucToSeqPro [string range $seqD end end-2]] eq "*"} {
	    set seqD [string range $seqD 0 end-3]
	}

	set offset [string first $SeqSws $sequenceembl]
	if {$offset > -1} {
	    set trouveorf 1
	    set SeqAdn $seqD
	    puts "\t -> BON ORF ! offset $offset"
	    break
	} else {
	    #ShowProtDiff sequenceembl SeqSws
	}
    }

    if {! $trouveorf} {
	puts "\tPROBLEM ! orf de la prot non trouve !"
    }

    return $SeqAdn

}

proc ChercheRedondance {} {

    set nbbonneligne 0
    set Fichier "[RepertoireDuGenome]/Arnaud/CreeNuctfaPourDesignOligo1500"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s" Boite Raison
	if {$Raison=="+7+8" || $Raison=="compulsory" || $Raison=="+7-8" || $Raison=="cxcr4"} {
	    incr nbbonneligne
	    if {[info exists DejaVu($Boite)]} {
		incr DejaVu($Boite)
		continue
	    }
	    set DejaVu($Boite) 1 
	}
    }
    foreach {C V} [array get DejaVu] {
	if {$V>1} {Espionne "$C pls fois"}
    }

}

proc CherhePDBParpsiblast {msfFile CodeGscope resolution} {

    clustalConvertForpsiblast $msfFile
    #premier spliblast pour calculer la matrice le pssm
    PsiBlastPXavierPourTous $CodeGscope
    #deuxieme contre pdb only #pour trouver des pdbs
    global GardeToutPsiBlastPPourTous; unset GardeToutPsiBlastPPourTous
    global CommandePsiBlastPPourTous; unset CommandePsiBlastPPourTous
    PsiBlastPXavierPourTous $CodeGscope
    set psiBlastFile [RepertoireDuGenome]/psiblastp/$CodeGscope
    parsePsiblast $psiBlastFile $resolution
    #l'ajout des PDB dans le fichier PDB se fait dans la procedure parsePsiblast, mais egalement dans les tfasdescopains

}

proc Chevauchements {Ligne} {

    set ListeDesNoms [split [NomLigne $Ligne Noms] " "]
    set Mini 999999999999
    set Maxi -1
    set OnARien 1
    foreach Nom $ListeDesNoms {
	set Loc [ExtraitInfo $Nom "LocUcscFrom200602"]
	set LesMotsLoc [split $Loc ":- "]
	set C [lindex $LesMotsLoc 0]
	set D [lindex $LesMotsLoc 1]
	set F [lindex $LesMotsLoc 2]
	if {$D=="" || $F==""} { continue }
	set Mini [Mini $Mini $D]
	set Maxi [Maxi $Maxi $F]
    }
    set Amplitude [expr $Maxi -$Mini]
    if {$Amplitude<1} { return "" }
    set Couverture 60
    foreach Nom $ListeDesNoms {
	set Loc [ExtraitInfo $Nom "LocUcscFrom200602"]
	set LesMotsLoc [split $Loc ":- "]
	set C [lindex $LesMotsLoc 0]
	set D [lindex $LesMotsLoc 1]
	set F [lindex $LesMotsLoc 2]
	if {$D=="" || $F==""} { continue }
	set LR [expr $F - $D + 1]
	set DR [expr $D - $Mini]
	set FR [expr $F - $Mini]
	set DA [expr ($DR*$Couverture)/$Amplitude]
	set FA [expr ($FR*$Couverture)/$Amplitude]
	set LA [expr $FA - $DA +1]
	set Regle "$Nom $Loc [format "%6d" $LR] [string repeat " " $DA][string repeat "*" $LA]"
	lappend LesRegles $Regle
	
    }
    return [join $LesRegles "\n"]

}

proc ChiffreSurLOntologie_PourRapport {} {


    set FichierGOProttfa    "[RepertoireDuGenome]/fiches/GeneOntology_prottfa"
    set FichierBestGO       "[RepertoireDuGenome]/fiches/GeneOntology"

    set     LesTypes [InterrogeGeneOntology $FichierGOProttfa LesTypes]
    lappend LesTypes All

    set Tab(Prottfa,NbProtAvecGO,Type,All) 0
    foreach Nom [InterrogeGeneOntology $FichierGOProttfa LesNoms] {
	set LesGO  [InterrogeGeneOntology $FichierGOProttfa $Nom LesGO]
	
	if {$LesGO == ""} {continue}
	incr Tab(Prottfa,NbProtAvecGO,Type,All)

	foreach GO $LesGO {
	    set Type [InterrogeGeneOntology $FichierGOProttfa GO $GO Type]

	    if {![info exists Tab(Prottfa,NbProtAvecGO,Type,$Type)]} {
		set Tab(Prottfa,NbProtAvecGO,Type,$Type) 0
	    }

	    if {[info exists TabTmp($Nom,$Type)]} {continue}
	    set TabTmp($Nom,$Type) 1
	    incr Tab(Prottfa,NbProtAvecGO,Type,$Type)
	}
    }
    if {[info exists TabTmp]} {unset TabTmp}

    
    set Tab(Best,NbProtAvecGO,Type,All) 0
    foreach Nom [InterrogeGeneOntology $FichierBestGO LesNoms] {
	set LesGO  [InterrogeGeneOntology $FichierBestGO $Nom LesGO]
	
	if {$LesGO == ""} {continue}
	incr Tab(Best,NbProtAvecGO,Type,All)

	foreach GO $LesGO {
	    set Type [InterrogeGeneOntology $FichierBestGO GO $GO Type]

	    if {![info exists Tab(Best,NbProtAvecGO,Type,$Type)]} {set Tab(Best,NbProtAvecGO,Type,$Type) 0}

	    if {[info exists TabTmp($Nom,$Type)]} {continue}
	    set TabTmp($Nom,$Type) 1
	    incr Tab(Best,NbProtAvecGO,Type,$Type)
	}
    }
    if {[info exists TabTmp]} {unset TabTmp}

    foreach Type $LesTypes {
	set nAvant [set Tab(Prottfa,NbProtAvecGO,Type,$Type)]
	set nApres [set Tab(Best,NbProtAvecGO,Type,$Type)]
	Espionne "$Type\t$nAvant\t$nApres"
    }
    return

}

proc ChiffresSurLeBilanProteines_ComparaisonDDExperiencesPourTous_PO {} {

    ###NbProt ne considere ici que les proteines uniques par cluster et par experience,
    ###mais si dans une meme experience, une prot est presente dans x clusters, elle est comptée autant
    ###de fois que le nombre de clusters dans laquelle elle est presente

    set FichierBilan "[RepertoireDuGenome]/fiches/BilanProteines_ComparaisonDDExperiences"
    ###Dans ce fichier bilan, les prot jumelles sont comptees une seule fois par clusters
    ###Mais si elles sont presentes dans x clusters differents, elles sont comptees x fois
    set F [open $FichierBilan]

    set TabChiffresBilanProt(LesDDExperiences)           {}
    set TabChiffresBilanProt(LesTypesDeLesDDExperiences) {}

    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == ""}          {continue}
	if {[regexp -nocase {^Name} $Ligne]} {continue}
	set LaLigne [split $Ligne "\t"]
	#Espionne "Ligne: $Ligne"
	set Name             [lindex $LaLigne 0]
	#Espionne "Name: $Name"
	set DDExperience     [lindex $LaLigne 2]
	#Espionne "DDExperience: $DDExperience"
	set Cluster          [lindex $LaLigne 3]
	#Espionne "Cluster: $Cluster"
	set LeTypeDeLesDDExperiences [lindex $LaLigne 4]
	#Espionne "LeTypeDeLesDDExperiences: $LeTypeDeLesDDExperiences"
	#LesTypesDeLesDDExperiences correspond a la combinaison de DDExperiences ayant des proteines communes
	#ex: DD1, DD2 ou DD1 DD2dans le cas de deux experiences de DD. 
	#ex: DD1 DD2, DD1 DD3, DD2 DD3 et DD1 DD2 DD3 dans le cas de trois experiences de DD. 
	
	#Calculs sur la DDExperience
	if {![info exists TabChiffresBilanProt($DDExperience)]} {
	    set     TabChiffresBilanProt($DDExperience)                            1
	    set     TabChiffresBilanProt($DDExperience,NbProt)                     0
	    set     TabChiffresBilanProt($DDExperience,LesClusters)                {}
	    lappend TabChiffresBilanProt(LesDDExperiences)                         $DDExperience
	}
	incr TabChiffresBilanProt($DDExperience,NbProt)
	
	#Calculs sur chaque cluster de chaque DDExperience
	if {![info exists TabChiffresBilanProt($DDExperience,$Cluster)]} {
	    set     TabChiffresBilanProt($DDExperience,$Cluster)        1
	    lappend TabChiffresBilanProt($DDExperience,LesClusters)     $Cluster
	    set     TabChiffresBilanProt($DDExperience,$Cluster,NbProt) 0
	}
	incr    TabChiffresBilanProt($DDExperience,$Cluster,NbProt)
	
	#Calcul de LesTypesDeLesDDExperiences
	if {![info exists TabChiffresBilanProt(LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences)]} {
	    set TabChiffresBilanProt(LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences)              1
	    lappend TabChiffresBilanProt(LesTypesDeLesDDExperiences) $LeTypeDeLesDDExperiences
	    #Espionne "LeTypeDeLesDDExperiences: '$LeTypeDeLesDDExperiences'"
	    #Espionne "LesTypesDeLesDDExperiences: '[set TabChiffresBilanProt(LesTypesDeLesDDExperiences)]'"
	}

	#Calcul des sequences uniques et des sequences communes par DDExperience
	if {![info exists TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]} {
	    set      TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt) 0
	}
	incr TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)
	#Espionne "$DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt: [set TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]"
	
	#Calcul des sequences uniques et des sequences communes par Cluster de chaque DDExperience
	if {![info exists TabChiffresBilanProt($DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]} {
	    set TabChiffresBilanProt($DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt) 0
	    
	}
	incr TabChiffresBilanProt($DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)
    }

    #Espionne "Fin des calculs"
    Espionne "LesDDExperiences: [set TabChiffresBilanProt(LesDDExperiences)]"
    foreach DDExperience [set TabChiffresBilanProt(LesDDExperiences)] {
	#Espionne $DDExperience
	Espionne "$DDExperience,NbProt: [set TabChiffresBilanProt($DDExperience,NbProt)]"
    }
    
    Espionne "LesTypesDeLesDDExperiences: [set TabChiffresBilanProt(LesTypesDeLesDDExperiences)]"
    foreach DDExperience [set TabChiffresBilanProt(LesDDExperiences)] {
	Espionne $DDExperience
	foreach LeTypeDeLesDDExperiences [set TabChiffresBilanProt(LesTypesDeLesDDExperiences)] {
	    if {![info exists TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]} {continue}
	    Espionne "$DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt: [set TabChiffresBilanProt($DDExperience,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]"
	}
    }

    foreach DDExperience [set TabChiffresBilanProt(LesDDExperiences)] {
	set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_$DDExperience"
	foreach Cluster [set TabChiffresBilanProt($DDExperience,LesClusters)] {
	    set Taille [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms]]
	    Espionne "DDExperience,$DDExperience,Cluster,$Cluster,Taille: $Taille"
	    Espionne "DDExperience,$DDExperience,LesClusters: [set TabChiffresBilanProt($DDExperience,LesClusters)]"
	    Espionne "DDExperience,$DDExperience,$Cluster,NbProt: [set TabChiffresBilanProt($DDExperience,$Cluster,NbProt)]"
	    foreach LeTypeDeLesDDExperiences [set TabChiffresBilanProt(LesTypesDeLesDDExperiences)] {
		if {![info exists TabChiffresBilanProt($DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]} {continue}
		Espionne "$DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt: [set TabChiffresBilanProt($DDExperience,$Cluster,LeTypeDeLesDDExperiences,$LeTypeDeLesDDExperiences,NbProt)]"
	    }
	}
    }
    
    InterrogeOrf2Cluster2Access2Def2Expression unset
    close $F
    return

}

proc ChiffresSurLeBilanProteines_RedondanceInterClusters_PO {} {

    ### DD1 et DD2 specifies dans le nom du cluster dans le fichier OCADE
    ###Now 8 clusters car DD1_ICBP_D ... et idem avec DD2

    set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles"
    set FichierOCADE   "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"  
    
    ###1- Calculs sur LesClustersDesJumelles ###
    Espionne "Calculs sur LesClustersDesJumelles ..."
    foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	#Espionne $Nom
	set TabJumInterCluster($Nom,LesClDesJum) {}
	set ClNom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster]
	#Espionne "ClNom: $ClNom"
	lappend TabJumInterCluster($Nom,LesClDesJum) $ClNom
	if {![info exists TabJumInterCluster($Nom,$ClNom)]} {
	    set TabJumInterCluster($Nom,$ClNom)      1
	}
	
	foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {
	    set ClJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster]
	    #Espionne "Jumelle: $Jum, $ClJum"
	    if {$ClJum == $ClNom} {set TabJumInterCluster($Jum,$ClJum) 1 ;continue}
	    if {![info exists TabJumInterCluster($Nom,$ClJum)]} {
		set     TabJumInterCluster($Nom,$ClJum)                     1
		lappend TabJumInterCluster($Nom,LesClDesJum)                $ClJum
	    }
	}
	#Espionne "$Nom,LesClDesJum: [set TabJumInterCluster($Nom,LesClDesJum)]"
    }
    Espionne "Fin des calculs sur LesClustersDesJumelles"
    
    ###2- Calculs sur LeTypeDeLesClustersDesJumelles ###
    Espionne "Calculs sur LeTypeDeLesClustersDesJumelles ..."
    set TabJumInterCluster(LesTypeDeLesClDesJum) {}
	    
    foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	#Espionne $Nom
	set LesClDesJum [set TabJumInterCluster($Nom,LesClDesJum)]
	#Espionne "LesClDesJum: $LesClDesJum"
	if {![info exists TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum)]} {
	    set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum)        1
	    set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt) 0
	    lappend TabJumInterCluster(LesTypeDeLesClDesJum) $LesClDesJum
	    #Espionne "LesTypeDeLesClDesJum: [set TabJumInterCluster(LesTypeDeLesClDesJum)]"
	}
	incr TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt)
	#Espionne "LesTypeDeLesClDesJum,$LesClDesJum,NbProt: [set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt)]" 
    }
    ###2bis- Suite des calculs sur LeTypeDeLesClustersDesJumelles ###
    ###On classe LeTypeDeLesClustersDesJumelles par ordre alphabetique pour ne pas tenir compte de l'ordre des clusters
    ### et on additionne le nombre de prot trouve pour les meme LeTypeDeLesClustersDesJumelles quand classe
    foreach LeTypeDeLesClDesJum [set TabJumInterCluster(LesTypeDeLesClDesJum)] {
	set LeTypeDeLesClDesJumClasse [lsort -dictionary $LeTypeDeLesClDesJum]
	#Espionne "LeTypeDeLesClDesJum: $LeTypeDeLesClDesJum"
	#Espionne "LeTypeDeLesClDesJumClasse: $LeTypeDeLesClDesJumClasse"
	if {![info exists TabJumInterCluster($LeTypeDeLesClDesJumClasse)]} {
	    set TabJumInterCluster($LeTypeDeLesClDesJumClasse) 1
	    lappend LesTypesDeLesClDesJumClasse $LeTypeDeLesClDesJumClasse
	    #Espionne $LesTypesDeLesClDesJumClasse
	    set TabJumInterCluster($LeTypeDeLesClDesJumClasse,NbProt) 0
	}
	set NbProtIni   [set TabJumInterCluster($LeTypeDeLesClDesJumClasse,NbProt)]
	set NbProtToAdd [set TabJumInterCluster(LesTypeDeLesClDesJum,$LeTypeDeLesClDesJum,NbProt)]
	set TabJumInterCluster($LeTypeDeLesClDesJumClasse,NbProt) [expr $NbProtIni + $NbProtToAdd]
	#Espionne "$LeTypeDeLesClDesJumClasse,NbProt: [set TabJumInterCluster($LeTypeDeLesClDesJumClasse,NbProt)]"
    }
    Espionne "Fin des calculs sur LeTypeDeLesClustersDesJumelles"
    if {0} {
	###3- Resultats des calculs sur LesClustersDesJumelles ###
	Espionne "Resultats des calculs sur LesClustersDesJumelles"
	###On espionne uniquement le resultat de jumelles appartenant a des clusters distincts
	foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	    set TailleLesClDesJum [llength [set TabJumInterCluster($Nom,LesClDesJum)]]
	    ###Dans TabJumInterCluster($Nom,LesClDesJum) sont presents les clusters des jumelles du Nom 
	    ### ainsi que celui du nom, donc de l'ensemble de ce groupe de proteines jumelles
	    if {$TailleLesClDesJum >= 2} {
		#Espionne "Nom,$Nom,LesClDesJum: [set TabJumInterCluster($Nom,LesClDesJum)]"
	    }
	}
    }
    ###4- Resultats des calculs sur LeTypeDeLesClDesJumelles ###
    ###Utilise LesClDesJumelles precedemment calcules
    Espionne "Calculs sur LeTypeDeLesClustersDesJumelles"
    #Espionne "$LesTypesDeLesClDesJumClasse [llength $LesTypesDeLesClDesJumClasse]"
    foreach LeTypeDeLesClDesJumClasse $LesTypesDeLesClDesJumClasse {
	Espionne "$LeTypeDeLesClDesJumClasse,NbProt: [set TabJumInterCluster($LeTypeDeLesClDesJumClasse,NbProt)]"
    }
    
    InterrogeOrf2Cluster2Access2Def2Expression unset
    InterrogeProteinesJumelles                 unset
    return

}

proc ChiffresSurLeBilanProteines_RedondanceInterClusters_PO_OLD {} {

    ###_OLD car reprise dans ChiffresSurLeBilanProteines_RedondanceInterClusters_PO_OLD 
    ### car DD1 et DD2 specifies dans le nom du cluster dans le fichier OCADE
    set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles"
    set FichierOCADE   "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"  
    
    ###1- Calculs sur LesClustersDesJumelles ###
    Espionne "Calculs sur LesClustersDesJumelles ..."
    foreach DDExp $LesDDExp {
	Espionne $DDExp
	set TabJumInterCluster($DDExp,NbProtAyantJumInterCluster) 0
    
	
	if {![file exists $FichierOCADE]} {Espionne "$FichierOCADE does not exists" ; return}
	
	#Espionne "$DDExp: [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms]]"
	foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	    #Espionne $Nom
	    set TabJumInterCluster($Nom,LesClDesJum) {}
	    set ClNom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster]
	    #Espionne "ClNom: $ClNom"
	    lappend TabJumInterCluster($Nom,LesClDesJum) $ClNom
	    if {![info exists TabJumInterCluster($Nom,$ClNom)]} {
		set TabJumInterCluster($Nom,$ClNom)      1
	    }
	   
	    foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {
		set ClJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster]
		#Espionne "Jumelle: $Jum, $ClJum"
		if {$ClJum == ""} {continue}
		if {$ClJum == $ClNom} {set TabJumInterCluster($Jum,$ClJum) 1 ;continue}
		if {![info exists TabJumInterCluster($Nom,$ClJum)]} {
		    incr    TabJumInterCluster($DDExp,NbProtAyantJumInterCluster) 
		    set     TabJumInterCluster($Nom,$ClJum)                     1
		    lappend TabJumInterCluster($Nom,LesClDesJum)                $ClJum
		}
	    }
	    #Espionne "$Nom,LesClDesJum: [set TabJumInterCluster($Nom,LesClDesJum)]"
	}
    }	
    Espionne "Fin des calculs sur LesClustersDesJumelles"
    
    ###2- Calculs sur LeTypeDeLesClustersDesJumelles ###
    Espionne "Calculs sur LeTypeDeLesClustersDesJumelles ..."
    foreach DDExp $LesDDExp {
	Espionne $DDExp
	set TabJumInterCluster(LesTypeDeLesClDesJum) {}
	    
	set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_$DDExp"  
	if {![file exists $FichierOCADE]} {Espionne "$FichierOCADE does not exists" ; return}
	
	foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
	    Espionne $Nom
	    set LesClDesJum [set TabJumInterCluster($Nom,LesClDesJum)]
	    #Espionne "LesClDesJum: $LesClDesJum"
	    if {![info exists TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum)]} {
		set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum)        1
		set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt) 0
		lappend TabJumInterCluster(LesTypeDeLesClDesJum) $LesClDesJum
		Espionne "LesTypeDeLesClDesJum: [set TabJumInterCluster(LesTypeDeLesClDesJum)]"
	    }
	    incr TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt)
	    #Espionne "LesTypeDeLesClDesJum,$LesClDesJum,NbProt: [set TabJumInterCluster(LesTypeDeLesClDesJum,$LesClDesJum,NbProt)]" 
	}
    }

    Espionne "Fin des calculs sur LeTypeDeLesClustersDesJumelles"
    
    if {0} {
	###3- Resultats des calculs sur LesClustersDesJumelles ###
	Espionne "Resultats des calculs sur LesClustersDesJumelles"
	foreach DDExp $LesDDExp {
	    Espionne $DDExp
	    set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_$DDExp"  
	    if {![file exists $FichierOCADE]} {Espionne "$FichierOCADE does not exists" ; return}
	    
	    Espionne "$DDExp,NbProtAyantJumInterCluster: [set TabJumInterCluster($DDExp,NbProtAyantJumInterCluster)]"
	    
	    foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] {
		set TailleLesClDesJum [llength [set TabJumInterCluster($Nom,LesClDesJum)]]
		
		###Dans TabJumInterCluster($Nom,LesClDesJum) sont presents les clusters des jumelles 
		### ainsi que celui du nom
		if {$TailleLesClDesJum >= 2} {
		    Espionne "DDExp,$DDExp,Nom,$Nom,LesClDesJum: [set TabJumInterCluster($Nom,LesClDesJum)]"
		}
	    }
	}
    }

    ###4- Resultats des calculs sur LeTypeDeLesClustersDesJumelles ###
    Espionne "Resultats des calculs sur LeTypeDeLesClustersDesJumelles"
    foreach TypeDeLesClDesJum [set TabJumInterCluster(LesTypeDeLesClDesJum)] {
	Espionne "TypeDeLesClDesJum: $TypeDeLesClDesJum"
	Espionne "[set TabJumInterCluster(LesTypeDeLesClDesJum,$TypeDeLesClDesJum,NbProt)]"
    }
    
    InterrogeOrf2Cluster2Access2Def2Expression unset
    InterrogeProteinesJumelles                 unset
    return

}

proc ChiffresSurLesClusters_AL {FichierOCADE FichierProtJum} {

    #FichierOCADE est le fichier dans fiches sous genomics Orf2Cluster2Access2Def2Expression
    
    Espionne "Cluster\tNTot\tNbProt\tNbProtFrommRNA\tNbProtFromContig\tNbProtU\tNbmRNAHuman\tNbmRNAHumanU\tNbEPDouDBTSS\tNbTATAAABox\tNbTATAAABoxTot\tNbATTGGBox\tNbATTGGBoxTot\tNbCCAATBox\tNbCCAATBoxTot\tNbATTGGouCCAAT"
    
    InterrogeProtAndmRNAChoisis   unset
    InterrogeProtAndContigChoisis unset
    InterrogeProteinesJumelles    unset

    foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] {
	set LesNoms [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms]
	set NTot [llength $LesNoms]

	set NbProt           0
	set NbProtFrommRNA   0
	set NbProtFromContig 0
	set NbmRNAHuman      0

	set NbEPDouDBTSS     0
	set NbCCAATBox       0
	set NbCCAATBoxTot    0

	set NbATTGGBox       0
	set NbATTGGBoxTot    0

	set NbTATAAABox      0
	set NbTATAAABoxTot   0

	set NbATTGGouCCAAT   0

	set NbProtU 0
	set NbmRNAHumanU     0

	foreach Nom $LesNoms {
	    if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue}

	    if {[file exists "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom"]} {incr NbmRNAHuman}

	    incr NbProt

	    if {[InterrogeProtAndmRNAChoisis   $Nom SeqChoisie] == "SeqOK"} {incr NbProtFrommRNA  }
	    if {[InterrogeProtAndContigChoisis $Nom SeqChoisie] == "SeqOK"} {incr NbProtFromContig}
	
	    if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue}
	    set     TabDeJaVu($Cluster,$Nom) 1
	    foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1}

	    incr NbProtU

	    if {[file exists "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom"]} {incr NbmRNAHumanU}


	    set FilePromAn "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_promoter/$Nom.PromAn"
	    if {![file exists $FilePromAn]} {continue}
	    
	    PromAnPanel unset
	    set nDBTSS  [PromAnPanel ask $FilePromAn ResultType "PromoterAndTSS"  Method "DBTSS"           n]
	    set nEPD    [PromAnPanel ask $FilePromAn ResultType "PromoterAndTSS"  Method "EPD"             n]
	    if {$nDBTSS != "" || $nEPD != ""}   {incr NbEPDouDBTSS}

	    set nTATAAA [PromAnPanel ask $FilePromAn ResultType "PatternResearch" Method "TATAAA"          n]
	    if {$nTATAAA != ""}                 {incr NbTATAAABox ; incr NbTATAAABoxTot $nTATAAA}

	    set nATTGG  [PromAnPanel ask $FilePromAn ResultType "PatternResearch" Method "ATTGG"           n]
	    if {$nATTGG != ""}                  {incr NbATTGGBox  ; incr NbATTGGBoxTot  $nATTGG }

	    set nCCAAT  [PromAnPanel ask $FilePromAn ResultType "PatternResearch" Method "ATTGG antisense" n]
	    if {$nCCAAT != ""}                  {incr NbCCAATBox  ; incr NbCCAATBoxTot  $nCCAAT}

	    if {$nATTGG != "" || $nCCAAT != ""} {incr NbATTGGouCCAAT}
	    PromAnPanel unset
  	}
	Espionne "$Cluster\t$NTot\t$NbProt\t$NbProtFrommRNA\t$NbProtFromContig\t$NbProtU\t$NbmRNAHuman\t$NbmRNAHumanU\t$NbEPDouDBTSS\t$NbTATAAABox\t$NbTATAAABoxTot\t$NbATTGGBox\t$NbATTGGBoxTot\t$NbCCAATBox\t$NbCCAATBoxTot\t$NbATTGGouCCAAT"
    }
    PromAnPanel                   unset
    InterrogeProtAndmRNAChoisis   unset
    InterrogeProtAndContigChoisis unset
    InterrogeProteinesJumelles    unset

    return 

}

proc Chmr12 {Ligne Colonne} {

    global Chmr12

    if {[info exists Chmr12($Ligne,$Colonne)]} { return $Chmr12($Ligne,$Colonne) }
    if {[info exists Chmr12("EstCharge")]} { return "" }
    set Chmr12("EstCharge") 1

    set FichierChmr12 "[RepertoireDuGenome]/parser2007/chmr12_famille_Guillaume.csv"
    set Queue [file tail $FichierChmr12]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue

    LoadTxl $FichierChmr12 Chmr12 -1 ";" "" "WholeLine"   
    set LesTetes $Chmr12(ListHeaderPlease,$Queue)
    set LesIndex $Chmr12(ListAllPlease,$Queue)

    set Chmr12(ListOf,Header) $LesTetes
    set Chmr12(ListOf,Index)  $LesIndex

    return [Chmr12 $Ligne $Colonne]

}

proc Chmr3 {Ligne Colonne} {

    global Chmr3

    if {[info exists Chmr3($Ligne,$Colonne)]} { return $Chmr3($Ligne,$Colonne) }
    if {[info exists Chmr3("EstCharge")]} { return "" }
    set Chmr3("EstCharge") 1

    set FichierChmr3 "[RepertoireDuGenome]/parser2007/chmr3_famille_V11.csv"
    set Queue [file tail $FichierChmr3]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue

    LoadTxl $FichierChmr3 Chmr3 -1 ";" "" "WholeLine"   
    set LesTetes $Chmr3(ListHeaderPlease,$Queue)
    set LesIndex $Chmr3(ListAllPlease,$Queue)

    set Chmr3(ListOf,Header) $LesTetes
    set Chmr3(ListOf,Index)  $LesIndex

    return [Chmr3 $Ligne $Colonne]

}

proc ChoisiEtAjouteChampsInfo {Texte} {

    global LesChampsInfo
    if { ! [info exists LesChampsInfo] } {
	lappend LesChampsInfo "Famille: "
	lappend LesChampsInfo "Famille: DOS"
	lappend LesChampsInfo "Famille: P62"
	lappend LesChampsInfo "Famille: SAP"
	lappend LesChampsInfo "Famille: Inconnue"
	lappend LesChampsInfo "Remarque: "
	lappend LesChampsInfo "Remarque: blastX"
	lappend LesChampsInfo "Remarque: TblastN"
	lappend LesChampsInfo "Remarque: profile"
	lappend LesChampsInfo "Remarque: analyse"
	lappend LesChampsInfo "CodonStart: "
	lappend LesChampsInfo "CodonStop: "
	lappend LesChampsInfo "Fantome: oui par condamnation rR"
	lappend LesChampsInfo "Enterre: oui force"
	lappend LesChampsInfo "Fonction: "
	lappend LesChampsInfo "Transmembrane: "
	lappend LesChampsInfo "Operon: "
	lappend LesChampsInfo "AutresHomologues: "
	lappend LesChampsInfo "CreePAB: "
    }
    set NouveauTexte [ChoixParmi $LesChampsInfo]
    if { $NouveauTexte != "" } {
	$Texte insert end "$NouveauTexte\n"
    }

}

proc ChoisirUnBlast {Nom} {

    global RepertoireDuGenome
    set LesRepertoiresDuBlast {}
    foreach Rep [glob -nocomplain "$RepertoireDuGenome/*"] {
	if {![regexp -nocase "blast" $Rep]} {continue}
	if {![file exists "$Rep/$Nom"]} {continue}
	regsub "$RepertoireDuGenome/" $Rep "" Rep
	lappend LesRepertoiresDuBlast $Rep
    }
    set RepSelect [ChoixParmi $LesRepertoiresDuBlast]
    set FichierBlast "$RepertoireDuGenome/$RepSelect/$Nom"
    return $FichierBlast

}

proc ChoisirUnRepertoire {Title} {

    set RepertoireInitial [pwd]  
    set Repertoire [tk_chooseDirectory  -mustexist 1  -initialdir $RepertoireInitial  -title "$Title"]
    return $Repertoire	

}

proc ChoisisBonneBoite {Ligne} {

    set ListeDesNoms [split [NomLigne $Ligne Noms] " "]
    set BonneBoite {}
    set LeChoix {}
    foreach Nom $ListeDesNoms {
	set Acc [AccessEvi $Nom]
	set Gn  [ExtraitInfo $Nom "ValiGN"]
	set Des [ExtraitInfo $Nom "ValiDE"]
	set AliasRma [ExtraitInfo $Nom "AliasGnRna"]
	set AliasProt [ExtraitInfo $Nom "AliasGnProt"]
	lappend LeChoix "$Nom $Acc $Gn $Des AliasRma $AliasRma AliasProt $AliasProt"  
    }
    set Chevauchement $ListeDesNoms
    set Texte [join $LeChoix "\n"]
    append Texte "\n\n[Chevauchements $Ligne]"
    append Texte "\n[RetChip5 $Ligne description_customer]"
    append Texte "\n[RetChip5 $Ligne description_memorec]"
    set Choix [AfficheVariable $Texte "AvecRetour" "ChooseSomeOfThemFor_$Ligne"]
    if {$Choix!=""} {
	foreach Choix [split $Choix "\n"] {
	    scan $Choix "%s" Boite
	    lappend BonneBoite $Boite
	}
    }
    return $BonneBoite

}

proc ChoisisFichierSignauxEtSignaux {{AvAp ""}} {


    if {$AvAp==""} { set AvAp "AvantApres" }
    set Avant [regexp -nocase "Avant" $AvAp]
    set Apres [regexp -nocase "Apres" $AvAp]

    set LesFichiers [LesFichiersDeType "Signaux" "" $AvAp]
    if {[llength $LesFichiers]==0} { return "" }
    if {[llength $LesFichiers]==1} {
	set FichierDesSignauxAvant [lindex $LesFichiers 0]
	set FichierDesSignauxApres [lindex $LesFichiers 0]
    }
    if {[llength $LesFichiers]==2} {
	set FichierDesSignauxAvant [lindex $LesFichiers 0]
	set FichierDesSignauxApres [lindex $LesFichiers 1]
    }
    if {[llength $LesFichiers]>2  || ( ! $Avant || ! $Apres ) && [llength $LesFichiers] > 1 } {
	if {[OuiOuNon "You choose to much signal files.\n You can MergeSignalFiles and begin again.\n Do You want to do it now ?"]} {
	    MergeSignalFiles
	}
	return ChoisisFichierSignauxEtSignaux $AvAp
    }
    if {$Avant} { set LesAvants [ChoisisLesSignauxDansLeFichier $FichierDesSignauxAvant "at 5' end"]  }
    if {$Apres} { set LesApres  [ChoisisLesSignauxDansLeFichier $FichierDesSignauxApres "at 3' end"] }
    set Texte ""
    append Texte "I took the signals\n\n"
    if {$Avant} {
	append Texte "at 5' end  from the file $FichierDesSignauxAvant\n"
	append Texte "[join $LesAvants " "]\n\n"
    }
    if {$Apres} {
	append Texte "at 3' end  from the file $FichierDesSignauxApres\n"
	append Texte "[join $LesApres " "]\n"
    }
    
    if { ! [OuiOuNon "$Texte\n OK ? "]} {
	if {[OuiOuNon "Do We try again ?"]} { return [ChoisisFichierSignauxEtSignaux $AvAp] }
	if {[OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
	if {[OuiOuNon "Do I stop ?"]} { Boum }
    }
    if {$Avant && $Apres} { return [list $LesAvants $LesApres $FichierDesSignauxAvant $FichierDesSignauxApres] }
    if {$Avant          } { return [list $LesAvants           $FichierDesSignauxAvant] }
    if {          $Apres} { return [list            $LesApres                         $FichierDesSignauxApres] }

}

proc ChoisisLeCritere {} {

    global CritereSelectionne

    Wup "Asks for a Criteria (the name of a Proc)"

    set Fenetre [AfficheLesProcs "ArgsContain:^Nom"]
    set   Bouton [BoutonneLaFenetre $Fenetre "Select\nCancel" "SelectionneCeCritere \[selection get\]"]
         $Bouton configure -background "orange"
    bind $Bouton   "SelectionneCeCritere CritereNonVoulu"

    tkwait variable CritereSelectionne
    set Critere $CritereSelectionne
    unset CritereSelectionne
    catch { destroy $Fenetre }
    return $Critere

}

proc ChoisisLeMeilleurMsf {FichierNormd} {

    set NormdRascal 0; set NormdDbclustal 0; set NormdLeon 0
    set ListeNormd {}
    foreach Ligne [LesLignesDuFichier $FichierNormd] {
	if {$Ligne == ""} {continue}
	set Ligne [regsub -all {NorMD de } $Ligne ""]
	set Ligne [regsub -all " :" $Ligne ""]
	set Normd 0
	scan $Ligne "%s %s" NomProcess Normd
	if {[regexp "dbclustal" $NomProcess]} {
	    set NormdDbclustal $Normd
	    set LeNormd($NormdDbclustal) Dbclustal
	}
	if {[regexp "rascal" $NomProcess]} {
	    set NormdRascal $Normd
	    set LeNormd($NormdRascal) Rascal
	}
	if {[regexp "leon" $NomProcess]} {
	    set NormdLeon $Normd
	    set LeNormd($NormdLeon) Leon
	}
    }
    #Espionne "NormdDbclustal $NormdDbclustal"
    #Espionne "NormdRascal $NormdRascal"
    #Espionne "NormdLeon $NormdLeon"
    if {$NormdLeon>0.5} {
	set bestmsf "Leon"
    } else {
	foreach {C V} [array get LeNormd] {
	    lappend ListeNormd $C 
	}
	set Max [DetermineLePlusGrand $ListeNormd]
	#Espionne "Max $Max"
	#Espionne "$LeNormd($Max)"
	set bestmsf $LeNormd($Max)
    }
    return $bestmsf

}

proc ChoisisLesSignauxDansLeFichier {Fichier {AvAp ""}} {

    set LesSignaux [LesSignauxDuFichier $Fichier]
    set LesBons [MorceauxChoisis $LesSignaux "" "Transfer the signals to put $AvAp. \n Then, PLEASE, reorder them (highligh one and press 'Up' or 'Down')\nThen press 'Accept'"]
    return $LesBons

}

proc ChoisisTonBlast {FichierTFA FichierBlast {Programme ""} {Banque ""} {Ask ""}} {

    global RepertoireDuGenome
    global GscopeDir

    if {$Ask=="DontAsk"} { set Ask 0 } else { set Ask 1 }

    if {$Programme==""} {
	set Programme [ChoixParmi {blastp blastx blastn tblastn tblastx Other}]
	if {$Programme == "Other"} { set Programme [Entre] }
	if {$Programme == ""} { return "" }
    }
    set AvecBanques "nucpro"
    if {[regexp {^blastp$|^blastx$} $Programme]} {
	regsub "nuc" $AvecBanques "" AvecBanques
    }
    if {[regexp {^tblastn$|^tblastx$|^blastn$} $Programme]} {
	regsub "pro" $AvecBanques "" AvecBanques
    }
    
    if {$Banque==""} {
	lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banques"
	lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banquesblast"
	lappend LesRepertoiresDesBanques "/catalog/blast"
	set LesBanques {}
	foreach RepBan $LesRepertoiresDesBanques {
	    if {[regexp "nuc" $AvecBanques]} {
		set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nsq"]]
		set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nal"]]
	    }
	    if {[regexp "pro" $AvecBanques]} {
		set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.psq"]]
		set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.pal"]]
	    }
	}

	set LesBonnesBanques {}
	foreach Banque [lsort $LesBanques] {
	    regsub {\.nsq$|\.psq$|\.nal$|\.pal$} $Banque "" Banque
	    if {[info exists DejaVu($Banque)]} { continue }
	    set DejaVu($Banque) 1
	    lappend LesBonnesBanques $Banque
	}
	lappend LesBonnesBanques "Other"
	set Banque [ChoixParmi $LesBonnesBanques]
	if {$Banque == "Other"} {
	    set Banque [ButineArborescence "All" [RepertoireDuGenome]]
	    regsub {\.[np]..$} $Banque "" Banque
	}
	if {$Banque == ""} { return "" }
    }


    set CommandeBlast "$GscopeDir/gscope_batchcom.tcl eval exec blastall  -p $Programme  -i $FichierTFA  -o $FichierBlast  -d $Banque  -v 500  -K 0  -b 500  -e 10.0  -F T "

    if {$Ask} {
	set CommandeBlast [Entre $CommandeBlast]
    }
    return $CommandeBlast

}

proc ChoisisUnTamis {{ChampChoisi ""} {AvecNewTamis ""}} {


    Wup "Displays the known Tamis and asks for a selection"

    set LesTamisExistants [LeTamis "LaListeMerci"]
    if { $LesTamisExistants=="TamisInconnu" } {
	LeTamis AllPABs  "ListeDesPABs"
	LeTamis AllTRNAs "ListeDesTRNAs"
	LeTamis AllARNs  "ListeDesARNs"
	set LesTamisExistants [LeTamis "LaListeMerci"]
    }
    set LesBeauxTamis {}
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisWhere X Where X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisAnd X And X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisOr X Or X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisButNot X ButNot X] }
    foreach Tam $LesTamisExistants {
	lappend LesBeauxTamis [format "%-20s %s" $Tam [LeTamis $Tam]]
    }
    set ChampsNomEtCommande [ChoixDansLaListe $LesBeauxTamis]
    if {$ChampsNomEtCommande==""} { return "" }
    scan $ChampsNomEtCommande "%s" Tam
    if {$ChampChoisi=="ChampNom"} { return $Tam } 
    if {$ChampChoisi=="ChampCommande"} { return [LeTamis $Tam] } 
    return "$Tam [LeTamis $Tam]"

}

proc ChoisisUneGrille {{ChampChoisi ""}} {


    Wup "Displays the known Criterias and asks for a selection"

    set LesGrillesExistantes [NoCo "LaListeMerci"]
    if { $LesGrillesExistantes=={} } { return "" }
    foreach Grille $LesGrillesExistantes {
	set COV [NoCo "Commande" $Grille]
	lappend LesBellesGrilles [format "%-20s %s" $Grille $COV]
    }
    if {$ChampChoisi=="SansRetour"} {
	set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles "SansRetour"]
	return
    } else {
	set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles]
    }
    if {$ChampsNomEtCommande==""} { return "" }
    scan $ChampsNomEtCommande "%s" Grille
    return $Grille

}

proc ChoisisWindowSizePourSlidingCodonRare {{WindowSize ""}} {

    while { ! [regexp {^\-?[0-9]+} $WindowSize]} {
	set WindowSize [ChoixParmi [list 1 10 20 30 40 50 "WholeSequence" "Other"]]
	if {$WindowSize=="Other"} { set WindowSize [Entre 12] }
	if {$WindowSize=="WholeSequence"} { set WindowSize -1 }
    }
    return $WindowSize

}

proc ChoixCarteExonique {} {

    global RepertoireDuGenome
    set RepEM "$RepertoireDuGenome/mrnaexonicmap/"
    set Nom [file tail [ButineArborescence All $RepEM]]

    IllustreLaCarteExonique $Nom $Nom

}

proc ChoixColoration {} {


    set LesColor [ColorationsPossibles]
    set LesTradu [LaTraduction [ColorationsPossibles]]
    set LesRangs [ColorationsPossibles "" "OnVeutLesRangs"]
    foreach Rang $LesRangs {
	set iCoul [expr 0.1*int($Rang)]
	set CouleurDuTexte [Nuance $iCoul 0. 0.6]
	lappend LesCouleursDuTexte $CouleurDuTexte
    }
    return [ChoixParmiJoli $LesColor $LesCouleursDuTexte $LesTradu]

}

proc ChoixDUnSiteDeCoupure {{ChoixPourCoupure ""}} {


    if {$ChoixPourCoupure==""} { set ChoixPourCoupure "Ask" }
    if {$ChoixPourCoupure=="SansCoupure"} { return "SansCoupure" }

    while {$ChoixPourCoupure=="Ask" || [regexp -nocase {^[a-z\-0-9]+ +[0-9]+$} $ChoixPourCoupure]} {
	if {$ChoixPourCoupure=="Ask"} {
	    set LesCoups [LesCoupuresPossibles]
	    lappend LesCoups "OtherSignal" "NucleicSequence" "NoCuttingSite" "StopAsking"
	    set Choix [ChoixParmi $LesCoups]
	} else {
	    set Choix $ChoixPourCoupure
	}
	if {$Choix=="NoCuttingSite"} { return "SansCoupure" }
	if {$Choix==""} {
	    if { ! [OuiOuNon "NoCuttingSite ?"]} { continue }
	    set ChoixPourCoupure "SetToSansCoupure"
	    return "SansCoupure"
	} elseif {$Choix=="StopAsking"} {
	    return "SansCoupure"
	} elseif {$Choix=="OtherSignal"} {
	    FaireLire "Please give SignalName and Position"
	    set Choix [Entre "Thrombin 12 P"]
	    set Sign ""
	    set Pos ""
	    scan $Choix "%s %d" Sign Pos
	    if { ! [EstUnSignal $Sign] || ! [regexp {^[0-9]+$} $Pos]} {
		FaireLire "$Sign is not a signal name or Position is bad."
		continue
	    }
	    set CoupN [Signal $Sign]
	    set LongCoupN $Pos
	    set Coupure $Sign
	    set ChoixPourCoupure "SetToSignalName"
	} elseif {$Choix=="NucleicSequence"} {
	    FaireLire "Please give a nucleic sequence and Position"
	    set Choix [Entre "CATATG 3 N"]
	    set NucSeq ""
	    set Pos ""
	    scan $Choix "%s %d" NucSeq Pos
	    if { ! [regexp -nocase {^[a-z]+$} $NucSeq] || ! [regexp {^[0-9]+$} $Pos ]} {
		FaireLire "Something is wrong ... we'll try again"
		continue
	    }
	    set CoupN $NucSeq
	    set LongCoupN $Pos
	    set Coupure $NucSeq
	    set ChoixPourCoupure "SetToNucleicSequence"
	} elseif {[regexp -nocase {^NucSeq_[ATGCN]+ [0-9]+$} $Choix]} {
	    regsub {^NucSeq_} $Choix "" SeqPos
	    scan $SeqPos "%s %d" NucSeq Pos
	    set CoupN $NucSeq
	    set LongCoupN $Pos
	    set Coupure $NucSeq
	    set ChoixPourCoupure "SetToNucleicSequence"
	} else {
	    scan $Choix "%s %d" Sign Pos
	    set CoupN [Signal $Sign]
	    set LongCoupN $Pos
	    set Coupure $Sign
	    set ChoixPourCoupure "SetToSignal"
	}
	set CoupP [SeqNucToSeqPro $CoupN]
	set LongCoupP [expr $LongCoupN/3]
	set CoupN [string toupper $CoupN]
	set CoupP [string toupper $CoupP]
    }
    return "$Coupure $CoupN $LongCoupN $CoupP $LongCoupP"

}

proc ChoixDUneListeDeSitesDeCoupure {} {


    FaireLire "Please select as much sites as you want.\nStop with 'StopAsking'"

    set LeChoix {}
    while 1 {
	set SC [ChoixDUnSiteDeCoupure]
	if {$SC=="SansCoupure"} {
	    if {[OuiOuNon "Do we stop now ?"]} { break }
	    continue
	}
	scan $SC "%s %s %d" Coupure CoupN LongCoupN
	set   SC "$CoupN $LongCoupN"
	if {[info exists DejaVu($SC)]} { continue }
	set DejaVu($SC) 1
	lappend LeChoix "$SC"
    }
    return $LeChoix

}

proc ChoixDansLaListe {Liste {SansRetour ""}} {

    global ChoixDansLaListe

    Wup "Displays a list and ask for a selection"

    if {$SansRetour=="SansRetour"} {
	set Titre "For display only ..."
    } else {
	set Titre "Select a line and Accept"
    }

    set Fenetre [ShowText [join $Liste "\n"] "SansFetchAvecRien" $Titre]
    if {$SansRetour=="SansRetour"} { return }
    set   Bouton [BoutonneLaFenetre $Fenetre "Accept/Cancel/New" ""]
         $Bouton configure -background "green"
    bind $Bouton  <1> "ChoixDansLaListeFait \[selection get\] "
    bind $Bouton  <2> "ChoixDansLaListeFait PasDeChoixDansLaListe"
    bind $Bouton  <3> "ChoixDansLaListeFait NouveauChoixDansLaListe"
    set   Bouton [BoutonneLaFenetre $Fenetre "Show Criteria" ""]
         $Bouton configure -background "yellow"
    bind $Bouton  <1> "ChoisisUneGrille SansRetour"

    tkwait variable ChoixDansLaListe
    set LigneChoisie $ChoixDansLaListe
    unset ChoixDansLaListe
    destroy $Fenetre
    return $LigneChoisie

}

proc ChoixDansLaListeFait {Texte} {

    global ChoixDansLaListe

    Wup "Tests the selection for NormalSelection, Cancel or NewCommand" 

    if {$Texte==""} { return }
    if {$Texte=="PasDeChoixDansLaListe"} { set ChoixDansLaListe "" ; return }
    if {$Texte=="NouveauChoixDansLaListe"} {
	set ChoixDansLaListe [Entre]
	return 
    }
    set ChoixDansLaListe $Texte
    return 

}

proc ChoixDeLAccessParmi {LesAccess} {


    Wup "Permet de classer les access en fonction de leur banque"

    set LesAccSW  ""
    set LesAccSPT ""
    set LesAccNew ""

    foreach Acc $LesAccess {
	if {[EstUnAccessDeQuelleBanque $Acc swissprot]} {
	    lappend LesAccSW $Acc
	    Espionne "SW $Acc"
	}
    }
    
    if {$LesAccSW!=""} {return $LesAccSW}

    foreach Acc $LesAccess {
	if {[EstUnAccessDeQuelleBanque $Acc sptrembl]} {
	    lappend LesAccSPT $Acc
	    Espionne "Sptembl $Acc"
	}
    }
    if {$LesAccSPT!=""} {return $LesAccSPT}

    foreach Acc $LesAccess {
	if {[EstUnAccessDeQuelleBanque $Acc sptnew]} {
	    lappend LesAccNew $Acc
	    Espionne "Sptnew $Acc"
	}
    }
    if {$LesAccNew!=""} {return $LesAccNew}

    return ""

}

proc ChoixDesGenomesCompletsPresentsAbsents {{Ask ""} {LesGenomesAChoisir ""}} {

    global ChoixDesGenomesCompletsPresentsAbsents
    global NotreOrga NotreOS
    
    if {$LesGenomesAChoisir=={}} { set LesGenomesAChoisir [LesOrganismesImportantsPourDBClustal] }

    if { ! [info exists ChoixDesGenomesCompletsPresentsAbsents] || $Ask!=""} {
	set ChoixDesGenomesCompletsPresentsAbsents {}
	foreach G $LesGenomesAChoisir {
	    set P [PhylumDuOrganisme $G]
	    lappend LesPGs "$P $G"
	}
	set LesPGs [lsort $LesPGs]
	foreach PG $LesPGs {
	    scan $PG "%s" P
	    regsub "$P " $PG "" G
	    lappend LesGs $G
	}
	set PAI [LesPresentsAbsentsIndifferents $LesGs  $LesPGs]
	set LesPresents [lindex $PAI 0]
	set LesAbsents  [lindex $PAI 1]
	foreach Organisme $LesPresents {
	    lappend ChoixDesGenomesCompletsPresentsAbsents [string toupper [Glossaire $Organisme Court]]
	}
	foreach Organisme $LesAbsents {
	    lappend ChoixDesGenomesCompletsPresentsAbsents [string tolower [Glossaire $Organisme Court]]
	}
    }
    return $ChoixDesGenomesCompletsPresentsAbsents

}

proc ChoixDesOligosParLeTm {Seq {TailleOligo ""} {TmLimite ""} {Ecart ""} {AvecSave 0}} {


    Wup "Permet de determiner tous les oligos potentiellement utilisables avec un Tm donne"
    Wup "Attention les sequences avec des caracteres autres que ATGC sont remplaces par des N"

    global TabSeqTm

    if {$TailleOligo==""} {set TailleOligo 60}
    if {$TmLimite==""}    {set    TmLimite 88}
    if {$Ecart==""}       {set       Ecart  5}

    set RepDeTm "[RepertoireDuGenome]/Probes/TestTM"
    set FichierSortie "$RepDeTm/${Seq}.tm"

    #Attention il faut une query, sinon pas de taille ....
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set mrnaQuery "$RepmRNA/$Seq"
    if {! [file exists $mrnaQuery]} {
	set mrnaQuery "[RepertoireDuGenome]/nuctfa/$Seq"
	if {! [file exists $mrnaQuery]} {
	    return "0 0 0"
	}
    } 
    set Seq [QueLaSequenceDuFichierTFA $mrnaQuery]

    if {[file exists $FichierSortie]} {
	if {! [info exists TabSeqTm($FichierSortie,EstCharge)]} {	
	    if {[OuiOuNonMemo "Tm stat already done ! Would you like to use them ?" ]} {
		ChargeLeFichierStatsTm $FichierSortie TabSeqTm
	    }   
	}
    }

    #Attention tous les caracteres autres que N sont devenus des N (tm modifie)
    regsub -all {[^ATGCN]} $Seq "N" Seq

    set Taille     [string length $Seq]
    set Seq        [split  $Seq ""] 
    set TmSup      [expr $TmLimite+$Ecart]
    set TmInf      [expr $TmLimite-$Ecart]
    set NbOligo    0
    set NbAccepted 0
    set NbRejected 0
    set GCAccepted 0
    set GCRejected 0

    for {set i 0} {$i < $Taille} {incr i} {
	set Debut $i
	set Fin   [expr $i+$TailleOligo]
	if {$Fin>$Taille} {break}

	if {[info exists TabSeqTm($Debut,$Fin,Tm)]} {
	    set NNTm [set TabSeqTm($Debut,$Fin,Tm)]
	    set GC   [set TabSeqTm($Debut,$Fin,GC)]
	} else {
	    set MaSeq [lrange $Seq $Debut $Fin]
	    set NNTm  [CalculTmDeLaSeq [join $MaSeq ""] "" 0.0 NearestNeighbor]
	    set TabSeqTm($Debut,$Fin,Tm) $NNTm
	    
	    set xGC [NombreDeBaseDe $MaSeq "G|C"]
	    set GC  [format "%.2f" [expr (($xGC)/($TailleOligo*1.0))*100.0]]
	    set TabSeqTm($Debut,$Fin,GC) $GC
	}
	
	if {$AvecSave} {
	    AppendAuFichier $FichierSortie [join [list $Debut $Fin $NNTm $GC] "\t"]
	}

	incr     NbOligo
	set Etat "Accepted"
	if {$NNTm>$TmSup || $NNTm<$TmInf} {
	    set Etat "Rejected" 
	    incr NbRejected
	    set GCRejected [expr $GCRejected + $GC]
	} else {
	    set GCAccepted [expr $GCAccepted + $GC]
	}
    }
    set NbAccepted [expr $NbOligo - $NbRejected]

    if {$NbAccepted!="0"} {set GCAccepted [format "%.1f" [expr ($GCAccepted/($NbAccepted*1.0))]]} else {set GCAccepted "0.0"}
    if {$NbRejected!="0"} {set GCRejected [format "%.1f" [expr ($GCRejected/($NbRejected*1.0))]]} else {set GCRejected "0.0"}

    return "$NbOligo $NbAccepted $NbRejected $GCAccepted $GCRejected"

}

proc ChoixDesPresents {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} {

    return [lindex [LesPresentsAbsentsIndifferents $Liste $ListeDeTextes $Invite] 0]

}

proc ChoixDesVariablesDeLHistogramme {aTableau {LesVariables ""}} {

    upvar $aTableau Tableau
    global RepertoireDuGenome

    set FichierFold "$RepertoireDuGenome/fiches/FoldExpression"
    if {![file exists $FichierFold]} {
	set Fold 0
    } else {
	set Fold 1
    }

    set LesVariablesProposees {}

    lappend LesVariablesProposees            "Nb Seq"           
    set Tableau(Nb_Seq)                      "NbSeq"
    set Tableau(NbSeq,Couleur)               "MidnightBlue"
    set Tableau(NbSeq,Unit)                  "sequences"

    if {$Fold} {
	lappend LesVariablesProposees            "Nb Seq Plus"           
	set Tableau(Nb_Seq_Plus)                 "NbSeqPlus"
	set Tableau(NbSeqPlus,Couleur)           "blue"
	set Tableau(NbSeqPlus,Unit)              "sequences"
	lappend LesVariablesProposees            "Nb Seq Minus"           
	set Tableau(Nb_Seq_Minus)                "NbSeqMinus"
	set Tableau(NbSeqMinus,Couleur)          "red"
	set Tableau(NbSeqMinus,Unit)             "sequences"
	lappend LesVariablesProposees            "Nb Seq NoInf"           
	set Tableau(Nb_Seq_NoInf)                "NbSeqNoInf"
	set Tableau(NbSeqNoInf,Couleur)          "green"
	set Tableau(NbSeqNoInf,Unit)             "sequences"
    }

    lappend LesVariablesProposees            "Nb Seq per BP"           
    set Tableau(Nb_Seq_per_BP)               "SeqPerBP"
    set Tableau(SeqPerBP,Couleur)            "lightslateblue"
    set Tableau(SeqPerBP,Unit)               "sequences\/pb"

    if {$Fold} {
	lappend LesVariablesProposees            "Nb Seq Plus per BP"           
	set Tableau(Nb_Seq_Plus_per_BP)           "SeqPlusPerBP"
	set Tableau(SeqPlusPerBP,Couleur)        "lightblue"
	set Tableau(SeqPlusPerBP,Unit)           "sequences\/pb"
	lappend LesVariablesProposees            "Nb Seq Minus per BP"           
	set Tableau(Nb_Seq_Minus_per_BP)          "SeqMinusPerBP"
	set Tableau(SeqMinusPerBP,Couleur)       "lightcoral"
	set Tableau(SeqMinusPerBP,Unit)          "sequences\/pb"
	lappend LesVariablesProposees            "Nb Seq NoInf per BP"           
	set Tableau(Nb_Seq_NoInf_per_BP)          "SeqNoInfPerBP"
	set Tableau(SeqNoInfPerBP,Couleur)       "lightgreen"
	set Tableau(SeqNoInfPerBP,Unit)          "sequences\/pb"
    }

    lappend LesVariablesProposees            "Sequence percentage" 
    set Tableau(Sequence_percentage)         "PourcentageSequence"
    set Tableau(PourcentageSequence,Couleur) "purple"
    set Tableau(PourcentageSequence,Unit)    "\%"

    if {$Fold} {
	lappend LesVariablesProposees            "Sequence Plus percentage" 
	set Tableau(Sequence_Plus_percentage)         "PourcentageSequencePlus"
	set Tableau(PourcentageSequencePlus,Couleur) "darkblue"
	set Tableau(PourcentageSequencePlus,Unit)    "\%"
	lappend LesVariablesProposees            "Sequence Minus percentage" 
	set Tableau(Sequence_Minus_percentage)         "PourcentageSequenceMinus"
	set Tableau(PourcentageSequenceMinus,Couleur) "darkred"
	set Tableau(PourcentageSequenceMinus,Unit)    "\%"
	lappend LesVariablesProposees            "Sequence NoInf percentage" 
	set Tableau(Sequence_NoInf_percentage)         "PourcentageSequenceNoInf"
	set Tableau(PourcentageSequenceNoInf,Couleur) "darkgreen"
	set Tableau(PourcentageSequenceNoInf,Unit)    "\%"
    }

    lappend LesVariablesProposees            "Nb Genes"         
    set Tableau(Nb_Genes)                    "NbGenes"
    set Tableau(NbGenes,Couleur)             "orange"
    set Tableau(NbGenes,Unit)                "genes"

    lappend LesVariablesProposees            "Nb Genes per BP"           
    set Tableau(Nb_Genes_per_BP)             "GenesPerBP"
    set Tableau(GenesPerBP,Couleur)          "lightcoral"
    set Tableau(GenesPerBP,Unit)             "genes\/pb"

    lappend LesVariablesProposees            "Genic percentage" 
    set Tableau(Genic_percentage)            "PourcentageGenique"
    set Tableau(PourcentageGenique,Couleur)  "darkorange"
    set Tableau(PourcentageGenique,Unit)     "\%"

    lappend LesVariablesProposees            "Space available"  
    set Tableau(Space_available)             "EspaceDisponible"
    set Tableau(EspaceDisponible,Couleur)    "pink"
    set Tableau(EspaceDisponible,Unit)       "pb"

    lappend LesVariablesProposees            "Skew in sequences"
    set Tableau(Skew_in_sequences)           "BiaisEnSequences"
    set Tableau(BiaisEnSequences,Couleur)    "MediumOrchid"
    set Tableau(BiaisEnSequences,Unit)       ""

    if {$Fold} {
	lappend LesVariablesProposees            "Skew in sequences Plus"
	set Tableau(Skew_in_sequences_Plus)           "BiaisEnSequencesPlus"
	set Tableau(BiaisEnSequencesPlus,Couleur)    "royalblue"
	set Tableau(BiaisEnSequencesPlus,Unit)       ""
	lappend LesVariablesProposees            "Skew in sequences Minus"
	set Tableau(Skew_in_sequences_Minus)           "BiaisEnSequencesMinus"
	set Tableau(BiaisEnSequencesMinus,Couleur)    "tomato2"
	set Tableau(BiaisEnSequencesMinus,Unit)       ""
	lappend LesVariablesProposees            "Skew in sequences NoInf"
	set Tableau(Skew_in_sequences_NoInf)           "BiaisEnSequencesNoInf"
	set Tableau(BiaisEnSequencesNoInf,Couleur)    "palegreen3"
	set Tableau(BiaisEnSequencesNoInf,Unit)       ""
    }

    lappend LesVariablesProposees            "Length"                     
    set Tableau(Length)                      "Taille"
    set Tableau(Taille,Couleur)              "chartreuse"
    set Tableau(Taille,Unit)                 "pb"

    lappend LesVariablesProposees            "Base percentage"                     
    set Tableau(Base_percentage)             "PourcentageBase"
    set Tableau(PourcentageBase,Couleur)     "yellow"
    set Tableau(PourcentageBase,Unit)        "\%"

    if {$LesVariables == {}} {set LesVariables [ChoixDesPresents $LesVariablesProposees]}

    set Tableau(LesVariables) $LesVariables

    return $aTableau

}

proc ChoixDuChromosome {} {

    set Chro [ChoixParmi {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY}] 
    return $Chro

}

proc ChoixDuFichierCourbeBAC {} {

    set Rep "[RepertoireDuGenome]/PRIMA_CGH"
    set Fichier ""
    set Fichier [ChoixParmi [glob -nocomplain "$Rep/BAC*"]] 
    return $Fichier

}

proc ChoixDuFichierCourbeOligo {} {

    set Rep "[RepertoireDuGenome]/PRIMA_CGH"
    set Fichier ""
    set Fichier [ChoixParmi [glob -nocomplain "$Rep/Oligo*"]] 
    return $Fichier

}

proc ChoixDuFichierLocalisationHuman {} {

    global RepertoireDuGenome
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier ""
    set Fichier [ChoixParmi [glob -nocomplain "$Rep/*Localisation_Human"]] 
    return $Fichier

}

proc ChoixDuFichierLocalisationMouse {} {

    global RepertoireDuGenome
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier ""
    set Fichier [ChoixParmi [glob -nocomplain "$Rep/*Localisation_Mouse"]] 
    return $Fichier

}

proc ChoixDuFichierRMA {} {

    set Rep "[RepertoireDuGenome]/PRIMA_Affy"
    set Fichier ""
    set Fichier [ChoixParmi [glob -nocomplain "$Rep/RMA*"]] 
    return $Fichier

}

proc ChoixDuRepertoire {{RepInitial ""}} {


    global OuiOuNonToujoursParDefaut
    if {[info exists OuiOuNonToujoursParDefaut] && $OuiOuNonToujoursParDefaut} {
	if {$RepInitial!="" && [file exists $RepInitial]} { return $RepInitial }
    } 

    if {$RepInitial==""} { set RepInitial "./" }
# BUG dans Tk ... initialdir n'est pas pris
    set Rep [tk_chooseDirectory -initialdir $RepInitial]
    if {$Rep==""} { return "" }
    if {[file exists $Rep]} { return $Rep }
    if { ! [OuiOuNon "Do I create the directory\n$Rep ?"]} { FaireLire "Tant pis" ; return $Rep }
    set RepCree [CreeLeRepertoire $Rep]
    if {$RepCree!=""} {
	FaireLire "I created $Rep"
	return $RepCree
    }
    FaireLire "I couldn't create $Rep\nWe'll try again"
    return [ChoixDuRepertoire $RepInitial]

}

proc ChoixGN {ListeDesGN} {

    global retourChoixGN
    catch {destroy .choixGN}
    catch {unset retourChoixGN}
    toplevel .choixGN

    tk_optionMenu .choixGN.o retourChoixGN "Choisis le bon ..."
    foreach GN $ListeDesGN {
	.choixGN.o.menu add radiobutton -label $GN -variable retourChoixGN
    }
    pack .choixGN.o -side left -padx 25 -pady 25
    tkwait variable retourChoixGN
    destroy .choixGN
    return $retourChoixGN

}

proc ChoixHistogramme {} {

    global RepertoireDuGenome

    set Rep "[HumanGenomeDir]/Localisation"
    set FichierBandesCytos   "$Rep/CytologicMap"
    if {![file exists $FichierBandesCytos]} {
	Espionne "$FichierBandesCytos does not exist"
	return ""
    }
    set RepLocalisation "$RepertoireDuGenome/Localisation"

    set cyto 1;set ctg 1;set chr 1;set area1e6 1;set area1e7 1

    set LesFichiers {}
    if {![file exists "$RepLocalisation/chr_Distribution"      ]} {
	set chr     0
    } else {
	lappend LesFichiers "$RepLocalisation/chr_Distribution"
    }
    if {![file exists "$RepLocalisation/ctg_Distribution" ]}      {
	set ctg     0
    } else {
	lappend LesFichiers "$RepLocalisation/ctg_Distribution" 
    }
    if {![file exists "$RepLocalisation/cyto_Distribution"]}      {
	set cyto    0
    } else {
	lappend LesFichiers "$RepLocalisation/cyto_Distribution"
    }
    if {![file exists "$RepLocalisation/area1e6bp_Distribution"]} {
	set area1e6 0
    } else {
	lappend LesFichiers "$RepLocalisation/area1e6bp_Distribution"
    }
    if {![file exists "$RepLocalisation/area1e7bp_Distribution"]} {
	set area1e7 0
    } else {
	lappend LesFichiers "$RepLocalisation/area1e7bp_Distribution"
    }

    if {!$cyto || !$ctg || !$chr || !$area1e7 || !$area1e6} {
	if {[OuiOuNon "Some files does not exist. Do you want I create it?"]} {
	    QuelquesChiffresSurLesSequences Save 0
	}
    } else {
	set LesFichiers [glob -nocomplain "$RepertoireDuGenome/Localisation/*_Distribution"]
    }
    set LesDistributions {}
    foreach Fichier $LesFichiers {
	set Fichier [file tail $Fichier]
	regsub "_Distribution$" $Fichier "" Distribution
	lappend LesDistributions $Distribution
    }
    set ChoixDistribution [ChoixParmi $LesDistributions]
  
    if {$ChoixDistribution == ""} {return ""}
    ChoixDesVariablesDeLHistogramme TabVar
    set LesVariables [set TabVar(LesVariables)]
    if {$LesVariables == {}} {return ""}

    if {$ChoixDistribution == "chr"} {
	HistogrammeDesChromosomes $LesVariables
    } else {
	ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos
	set LesChromoSelectionnes [ChoixDesPresents [set LesBandesCytos(LesChromosomes)]]
	HistogrammeDesRegions $LesChromoSelectionnes $ChoixDistribution $LesVariables
    }
    return ""

}

proc ChoixMultiple {Liste {ListeDeTextes ""} {Invite "Select ..."}} {

    global retourChoixMultiple
    global ChoixMultipleRadio
    

    if {[PourWscope]} { return $Liste }

    if {$ListeDeTextes=="" } {
	set ListeDeTextes $Liste
    }
    
    if {[llength $Liste] == 0 } { return "" }
    
    set w [NomDe fenetre]
    catch {destroy $w}
    catch {unset validOk}
    toplevel $w
    wm geometry $w +300+100
    
    #tk_optionMenu $w.o retourChoixParmi $Invite
    #$w.o configure -background "Seagreen" -foreground "black" -bd 20
    #frame .question -height [llength $Liste] -width 10c
    set MaxWidth 0
    foreach Texte $ListeDeTextes {
	if { [string length $Texte] > $MaxWidth } {
	    set MaxWidth [string length $Texte]
	}
    }
    
    foreach Element $Liste Texte $ListeDeTextes {
	frame $w.$Element
	radiobutton $w.radio${Element}p -relief flat -variable ChoixMultipleRadio($Element) -value p
	radiobutton $w.radio${Element}a -relief flat -variable ChoixMultipleRadio($Element) -value a
	radiobutton $w.radio${Element}i -relief flat -variable ChoixMultipleRadio($Element) -value i
	text $w.text${Element} -height 1 -width $MaxWidth
	$w.text${Element} insert end $Texte
	
	#$w.o.menu add radiobutton -background $Couleur -foreground "black"  #	-label $Element -variable retourChoixParmi
    }
    
    frame  $w.termine
    button $w.dismiss  -text "Dismiss" -background "red"   -command { set validOk 0 }
    button $w.toutpresent -text "Present" -command { 
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) p
	}
    }
    button $w.toutabsent -text "Absent" -command { 
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) a
	}
    }
    button $w.toutindif -text "Indifferent" -command {
	foreach Element [array names ChoixMultipleRadio] {
	    set ChoixMultipleRadio($Element) i
	}
    }
    button $w.validate -text "Validate"      -background "green" -command { set validOk 1 }
    
    # pack $w.o
    set First ""
    foreach Element $Liste {
	pack $w.$Element
	pack $w.radio${Element}p $w.radio${Element}a $w.radio${Element}i $w.text${Element} -in $w.$Element -side left -fill both -expand 1
    }
    
    pack $w.termine -side top
    pack $w.toutpresent $w.toutabsent $w.toutindif $w.validate $w.dismiss -in $w.termine -side left
    
    tkwait variable validOk
    destroy $w
    
    set retourChoixMultiple {}
    foreach Element $Liste {
	set Var ChoixMultipleRadio($Element)
	if { [set $Var] == "p" } {
	    lappend retourChoixMultiple [string toupper $Element] 
	} else {
	    if { [set $Var] == "a" } {
		lappend retourChoixMultiple [string tolower $Element]
	    } else { 
		# lappend retourChoixMultiple $Element
	    }
	}
    }
    return $retourChoixMultiple

}

proc ChoixNbCluster {} {

    global FrmBouton OrdEtcDir NbGr Defauts

    set mode [set Defauts(dispmode)]
    LesDefauts dispmode "autre"
    DetruitBoutonsOrdali
    set wb $FrmBouton
    set wp "$wb.fchx"
    frame $wp -relief sunken  -bd 2
    pack $wp -side left -expand 1 -fill x -padx 10 -pady 10

    frame $wp.le
    label $wp.le.label  -text " Number of Clusters :"
    entry $wp.le.ent  -background white  -width 5  -textvariable NbGr
    pack $wp.le.label $wp.le.ent -side left
    button $wp.bok  -text " OK "  -bg green1  -command "FinChoixNbCluster ok"
    button $wp.bds  -text "Dismiss"  -bg red  -command "FinChoixNbCluster dismiss"
    pack $wp.le $wp.bok $wp.bds -side left -expand 1 -pady 20

    MesCouleurs $FrmBouton

    bind $wp.le.ent  {$FrmBouton.fchx.bok invoke}
    tkwait window $wp.bok

    ChangeMode $mode

    return $NbGr

}

proc ChoixPDBReference {} {

    global chxmolref Retour StrucAVoir

    set chxmolref ""

    set w .ref
    toplevel $w
    wm title $w "Choose Reference Structure"
    wm iconname $w "PDB reference"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix

    frame $w.r -relief flat -borderwidth 2
    pack  $w.r -side top -pady 10
    label $w.r.t -text "Choose the reference structure \nfor superposition (the fixed structure)" -justify left -anchor w
    pack $w.r.t -pady 10 -side top

    set i 0
    set fdrt "$w.r.d"
    set fgch "$w.r.g"
    frame $fdrt
    frame $fgch
    set d 1

    foreach molc $StrucAVoir {
	set mol [DonneIdDeAccessPDB $molc]
	set chn [DonneChainDeAccessPDB $molc]
	set txt "${mol}, chain $chn"

	if {$d == 1} {
	    set fbtni "${fdrt}.n$i"
	    set d 2
	} else {
	    set fbtni "${fgch}.n$i"
	    set d 1
	}
	radiobutton $fbtni  -text $txt  -variable chxmolref  -relief flat  -highlightthickness 0  -value "$molc"
	pack $fbtni -side top -pady 5 -padx 5
	incr i
    }
    pack $fdrt $fgch -side left -anchor n

    frame $w.btn
    pack $w.btn -side bottom -pady 20 -padx 10 -fill x
    button $w.btn.cancel -text Cancel  -background red  -command [list FinChoixPDBReference dism]
    button $w.btn.cebon -text " OK "  -background green1  -command [list FinChoixPDBReference OK]
    pack $w.btn.cancel $w.btn.cebon -side left -expand 1
    set oldFocus [focus]
    set oldGrab [grab current $w]
    if {$oldGrab ne ""} {
	set grabStatus [grab status $oldGrab]
    }
    update idletasks
    raise $w
    focus [winfo toplevel $w]
    grab -global [winfo toplevel $w]

    MesCouleurs $w
    FenetreAuCentre $w

    tkwait variable Retour

    destroy $w
    focus $oldFocus
    if {$oldGrab ne ""} {
	if {$grabStatus ne "global"} {
	    catch {grab $oldGrab}
	} else {
	    catch {grab -global $oldGrab}
	}
    }

    unset chxmolref
    return $Retour

}

proc ChoixParmi {Liste {ListeDeCouleurs ""}} {

    global retourChoixParmi

    if {[llength $Liste] == 0 } { return "" }
    if {[llength $Liste] == 1  && [lindex $Liste 0]!="Other"} { return [lindex $Liste 0] }

    global ChoixParmiDansListBox
    if {[PourWscope]  || [info exists ChoixParmiDansListBox] && $ChoixParmiDansListBox  || [llength $Liste]>40} {
	return [ChoixParmiDansListBox $Liste]
    }

    set w [NomDe fenetre]
    catch {destroy $w}
    catch {unset retourChoixParmi}

    set GW 300
    set GH 100
    set SW [winfo screenwidth .]
    set SH [winfo screenheight .]
    set OffX [expr ($SW - $GW)/2]
    set OffY [expr ($SH - $GH)/4]

    toplevel $w -borderwidth 20
    wm geometry $w ${GW}x${GH}+${OffX}+${OffY}
    $w configure -background orange

    set Invite    "     Please select within the list ...     "
    set InListBox "Same display in a listbox"
    set Salut     "... DISMISS (select nothing)"

    tk_optionMenu $w.o retourChoixParmi $Invite
    $w.o.menu add radiobutton -label $InListBox -background "orange" -variable retourChoixParmi
    $w.o configure -background "Seagreen" -foreground "black" -bd 10 -width 30 -height 2
    foreach Element $Liste Couleur $ListeDeCouleurs {
	if { $Couleur=="" } {
	    set Couleur "Seagreen"
	}
	$w.o.menu add radiobutton -background $Couleur -foreground "black"  -label $Element -variable retourChoixParmi
    }
    $w.o.menu add radiobutton -label $Salut -background "red" -variable retourChoixParmi
    
    pack $w.o

    tkwait variable retourChoixParmi
    destroy $w
    if { $retourChoixParmi == $InListBox } { return [ChoixParmiDansListBox $Liste] }
    if { $retourChoixParmi == $Invite || $retourChoixParmi == $Salut } {
	set retourChoixParmi ""
    }
    return $retourChoixParmi

}

proc ChoixParmiDansListBox {Liste {ListeAAfficher ""}} {

    set Choose "Select ONE of the following lines and press ACCEPT. Press DISMISS to cancel."
    if {$ListeAAfficher=={}} {
	set ListeA $Liste
    } else {
	set ListeA $ListeAAfficher
    }
    set ListeE [concat [list ""] $Liste]
    set ListeA [concat [list $Choose] $ListeA]
    foreach E $ListeE A $ListeA {
	while {[info exist ARetourner($A)]} {
	    set A "$A (bis)"
	}
	set ARetourner($A) $E
	lappend BonneListeA $A
    }
    set Texte [join $BonneListeA "\n"]
    set Retour [Affiche $Texte "AvecRienSansFetchAvecRetour" "SelectAndAccept"]

    if {$Retour==$Choose || $Retour==""} { return "" }
    if { ! [info exists ARetourner($Retour)]} { error $Retour } ;#rR ... error le transmet directement a Wscope 
    return $ARetourner($Retour)

}

proc ChoixParmiJoli {Liste {ListeDeCouleurs ""} {ListeAAfficher ""}} {

    global retourChoixParmi

    if {[llength $Liste] == 0 } { return "" }
    if {[llength $Liste] == 1 && [lindex $Liste 0]!="Other"} { return [lindex $Liste 0] }

    global ChoixParmiDansListBox
    if {([info exists ChoixParmiDansListBox] && $ChoixParmiDansListBox) || [llength $Liste]>40} {
	return [ChoixParmiDansListBox $Liste $ListeAAfficher]
    }

    set w [NomDe fenetre]
    catch {destroy $w}
    catch {unset retourChoixParmi}
    toplevel $w
    wm geometry $w +300+100

    set Invite "Choose ..."
    set InListBox "Same display in a listbox"
    set Salut  "... DISMISS"

    if {$ListeAAfficher=={}} { set ListeAAfficher $Liste }

    tk_optionMenu $w.o retourChoixParmi $Invite
    $w.o.menu add radiobutton -label $InListBox -background "orange" -variable retourChoixParmi
    $w.o configure -background "Seagreen" -foreground "black" -bd 20
    foreach Element $Liste Couleur $ListeDeCouleurs Affiche $ListeAAfficher {
	while {[info exists MonRetour($Affiche)]} { append Affiche "_" } 
	set MonRetour($Affiche) $Element
	if { $Couleur == "" } {
	    set Couleur "Seagreen"
	}
	$w.o.menu add radiobutton -background $Couleur -foreground "black"  -label $Affiche -variable retourChoixParmi
    }
    $w.o.menu add radiobutton -label $Salut -background "red" -variable retourChoixParmi
    
    pack $w.o

    tkwait variable retourChoixParmi
    destroy $w
    if { $retourChoixParmi == $InListBox } {
	set retourChoixParmi [ChoixParmiDansListBox $ListeAAfficher]
    }
    if { $retourChoixParmi == $Invite || $retourChoixParmi == $Salut } {
	set retourChoixParmi ""
    }
    if {$retourChoixParmi==""} { return "" }
    set Retour [set MonRetour($retourChoixParmi)]
    return $Retour

}

proc ChoixParmiJoliDansListe {Liste} {

    set LesClefs {}
    set LesCouleurs {} 
    set LesTextes {}
    foreach {Clef Couleur Texte} $Liste {
	lappend LesClefs $Clef
	lappend LesCouleurs $Couleur
	if {$Texte==""} { set Texte $Clef } 
	lappend LesTextes $Texte
    }
    return [ChoixParmiJoli $LesClefs $LesCouleurs $LesTextes]

}

proc ChoixPlusieursPDB {} {

    global oldGrab grabStatus oldFocus Defauts lesbts Retour ListePDB LNOrdali

    set w .pdbras
    if {[winfo exists $w]} {
	raise $w
	return
    }

    set oldFocus [focus]
    set oldGrab  [grab current .]
    if {$oldGrab ne ""} {
	set grabStatus [grab status $oldGrab]
    }

    set ls [llength $ListePDB]
    set lep [lindex $ListePDB 0]
    lassign $lep mol pdb
    set chn [DonneChainDeAccessPDB $mol]
    set mol [DonneIdDeAccessPDB $mol]
    set lamolrefdefaut $mol
    set lesbts {}

    toplevel $w
    wm title $w "Choose Structures"
    wm iconname $w "PDB Chooser"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix

    label $w.t  -text "Choose molecules you want to display with\n 3D Viewer" -justify left -anchor nw

    set i 0
    set fdrt "$w.d"
    set fgch "$w.g"
    frame $fdrt
    frame $fgch
    set d 1
    foreach elt $ListePDB {
	if {$elt ni $LNOrdali} {continue}

	lassign $elt mol pdb
	set chn [DonneChainDeAccessPDB $mol]
	set mol [DonneIdDeAccessPDB $mol]
	set txt "$mol, chain $chn"

	if {$d == 1} {
	    set fbtni "${fdrt}.n$i"
	    set d 2
	} else {
	    set fbtni "${fgch}.n$i"
	    set d 1
	}
	checkbutton $fbtni -text $txt  -variable molref$i  -relief flat  -highlightthickness 0  -onvalue "${mol}_${chn}"  -offvalue ""
	lappend lesbts $fbtni
	pack $fbtni -side top -pady 2 -padx 2
	incr i
    }
    
    frame $w.sdl
    radiobutton $w.sdl.net  -text "Download PDB from the internet"  -value "internet"  -variable Defauts(DownloadPDB)  -anchor w -justify left  -relief flat
    radiobutton $w.sdl.loc  -text "Download local PDB files"  -value "local"  -variable Defauts(DownloadPDB)  -anchor w -justify left  -relief flat
    pack $w.sdl.loc $w.sdl.net -side bottom -fill x -expand 1 -pady 5
    
    frame $w.btn
    button $w.btn.cancel -text Cancel -background red -command [list FinChoixPlusieursPDB $w dismiss]
    button $w.btn.selall -text "Select All" -background yellow -command [list SelectionneTousLesPDB]
    button $w.btn.cebon -text " OK " -background green1 -command [list FinChoixPlusieursPDB $w]
    pack $w.btn.cancel $w.btn.selall $w.btn.cebon -side left -padx 10 -pady 10 -fill x
    
    grid rowconfig    $w 0 -weight 1 -minsize 0
    grid columnconfig $w 0 -weight 1 -minsize 0
    grid columnconfig $w 1 -weight 1 -minsize 0
    
    grid $w.t -padx 5 -pady 5  -row 0 -column 0 -rowspan 1 -columnspan 2 -sticky news
    grid $w.d -padx 5 -pady 5  -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky news
    grid $w.g -padx 5 -pady 5  -row 1 -column 1 -rowspan 1 -columnspan 1 -sticky news
    grid $w.sdl -padx 5 -pady 5  -row 2 -column 0 -rowspan 1 -columnspan 2 -sticky news
    grid $w.btn -padx 5 -pady 10  -row 3 -column 0 -rowspan 1 -columnspan 2 -sticky news
    
    $w.btn.selall configure -default active
    bind $w.btn.selall  {SelectionneTousLesPDB}
    
    MesCouleurs $w
    FenetreAuCentre $w
    
    focus $w
    grab $w
    
    vwait Retour
    
    if {$oldFocus ne ""} {focus $oldFocus}
    if {$oldGrab  ne ""} {grab  $oldGrab}
    
    destroy $w
    
    return

}

proc ChoixProtocoleAnnotation {Nom {AvecOuSansOrganismeEtudie ""} {AvecGarde 1}} {

    if {[PasTouche $Nom]} {
	return
    }

    ## Positionne les options
    OptionsProtocoleAnnotation
    OptionsProtocoleAnnotation "OptionsGlobales,AvecGarde" $AvecGarde
    OptionsProtocoleAnnotation "OptionsGlobales,AvecOuSansOrganismeEtudie" $AvecOuSansOrganismeEtudie
    
    ## "PipeAlign & MACSIMS"
    set Option "PipeAlign & MACSIMS"

    set FichierMacsims "[RepertoireDuGenome]/macsims/$Nom.xml"
    if {![file isdirectory [file dirname $FichierMacsims]]} {
	file mkdir [file dirname $FichierMacsims]
    }

    if {[OptionsProtocoleAnnotation $Option] && (!$AvecGarde || ![file isfile $FichierMacsims])} {
	Espionne "$Nom -> $Option"
	PipeAlignPourUneSequenceAvecParametres $Nom 200 "" "" "" "" $AvecOuSansOrganismeEtudie
    }
    if {![file isfile $FichierMacsims]} {
	Espionne "$Nom -> PAS DE MACSIMS PRESENT"
	FinPasTouche $Nom
	return
    }

    ## Récupère les séquences du groupe dans le macsims
    if {$AvecOuSansOrganismeEtudie == "Sans"} {
	set SequencesDuGroupe      [LesSequencesDuGroupeMacsims $Nom "Sans"]
    } else {
	set SequencesDuGroupe      [LesSequencesDuGroupeMacsims $Nom ""]
    }

    ## !! FAIRE LE GARDE POUR LES ANNOTATIONS DANS LE FICHIER XML !!
    set FichierAnnotation "[RepertoireDuGenome]/annotation/$Nom.xml"
    if {![file isdirectory [file dirname $FichierAnnotation]]} {
	file mkdir [file dirname $FichierAnnotation]
    }

    ## "Annotation MACSIMS"
    set Option "Annotation MACSIMS"
    if {[OptionsProtocoleAnnotation $Option]} {
	Espionne "$Nom -> $Option"
	AnnotationXml $FichierAnnotation "" $FichierMacsims
    }

    ## "Annotation EC commun"
    set Option "Annotation EC commun"
    if {[OptionsProtocoleAnnotation $Option]} {
	Espionne "$Nom -> $Option"
	AnnotationXml $FichierAnnotation "EC" [AnnotationEC $Nom $SequencesDuGroupe]
    }

    ## "Annotation Definition"
    set Option "Annotation Definition"
    if {[OptionsProtocoleAnnotation $Option]} {
	Espionne "$Nom -> $Option"
	AnnotationXml $FichierAnnotation "DE" [MeilleuresDefinitions2_0 $SequencesDuGroupe]
    }

    ## "Annotation GOAnno"
    set Option "Annotation GOAnno"
    if {[OptionsProtocoleAnnotation $Option]} {
	Espionne "$Nom -> $Option"
	set FichierGOAnno "[RepertoireDuGenome]/GeneOntology/$Nom.xml"
	if {![file isdirectory [file dirname $FichierGOAnno]]} {
	    file mkdir [file dirname $FichierGOAnno]
	}
	set RepertoireFichesAnnotation "[RepertoireDuGenome]/fichesannotation"
	if {![file isdirectory $RepertoireFichesAnnotation]} {
	    file mkdir $RepertoireFichesAnnotation
	}
	#if {!$AvecGarde || ![file isfile $FichierGOAnno]} {
	    AnnotationGO $Nom $AvecOuSansOrganismeEtudie
	#}
	AnnotationXml $FichierAnnotation "GO" $FichierGOAnno
    }

    ## "Annotation PFAM-A"
    set Option "Annotation PFAM-A"
    if {[OptionsProtocoleAnnotation $Option]} {
	Espionne "$Nom -> $Option"
	AnnotationXml $FichierAnnotation "PFAM" [ExtraitFeatures $Nom "Query" $AvecOuSansOrganismeEtudie "PFAM-A"]
    }

    FinPasTouche $Nom

}

proc ChoixProtocoleAnnotationPourTous {{AvecOuSansOrganismeEtudie ""} {AvecGarde 1}} {

    foreach pab [MorceauxChoisis [ListeDesPABs]] {
	ChoixProtocoleAnnotation $pab $AvecOuSansOrganismeEtudie $AvecGarde
    }

}

proc ChoixUnSeulPDB {} {

    global Retour ListePDB

    set ls [llength $ListePDB]

    set lep [lindex $ListePDB 0]
    lassign $lep mol fpdb
    set molref [DonneIdDeAccessPDB $mol]

    if {$ls == 1} {return $molref}

    set w .pdbras
    toplevel $w
    wm title $w "Choose a structure ..."
    wm iconname $w "Choose PDB"

    frame $w.r -relief flat -borderwidth 2
    pack  $w.r -side top -pady 10
    label $w.r.t -text "Choose a molecule :" -justify left
    pack $w.r.t -pady 10

    frame $w.btn
    pack $w.btn -side bottom -pady 5 -padx 10
    button $w.btn.cancel -text Cancel -background red -command "destroy $w"
    button $w.btn.cebon -text " OK " -background green1 -command "set Retour \[set molref\]"
    pack $w.btn.cancel $w.btn.cebon -side left -padx 10 -pady 10 -fill x

    set i 0
    set fdrt "$w.r.d"
    set fgch "$w.r.g"
    frame $fdrt
    frame $fgch
    set d 1
    foreach elt $ListePDB {
	lassign $elt molc pdb
	set chn [DonneChainDeAccessPDB $molc]
	set mol [DonneIdDeAccessPDB $molc]
	set txt "$mol, chain $chn"

	if {$d == 1} {
	    set fbtni "${fdrt}.n$i"
	    set d 2
	} else {
	    set fbtni "${fgch}.n$i"
	    set d 1
	}
	radiobutton $fbtni  -text $txt  -relief flat  -value "$molc"  -highlightthickness 0  -variable molref 
	pack $fbtni -side top -pady 5 -padx 5
	incr i
    }

    pack $fdrt $fgch -side left -anchor n

    FenetreAuCentre $w
    tkwait variable Retour
    destroy $w
    update idletasks

    return $Retour

}

proc ChooseBlastFileDrawBlast {w} {

    AskOptionsDeDrawBlast set $w FichierBlast [DrawChooseFile "Choose the Blast File"]
    return

}

proc ChroContigTronconOffsetOrganisme {Header} {


    global SansOffsetEtOrganisme
    if {[info exists SansOffsetEtOrganisme] && $SansOffsetEtOrganisme} {
	return "0 0 0 0 Inconnu inconnu"
    }

    Wup "Works well for Homo sapiens only"

    scan $Header "%s" BanqueId
    regsub ">" $BanqueId "" BanqueId
    set Chro ""
    set Contig ""
    ScanLaListe [split $BanqueId ":"] Chro Contig
    set Troncon "__"
    if {[regexp {_[0-9]+$} $Contig Troncon]} {
	regsub {_[0-9]+$} $Contig "" Contig
    }
    set Genre  "Genre"
    set Espece "Espece"
    set Offset -1
    if {[regexp -nocase {^hs[0-9xy(un)]} $Chro]} {
	set Genre "Homo"
	set Espece "sapiens"
    } else {
	Wup "We try in with completegenome.frag file"
	scan [OffsetEtOrganismeDuFragment $BanqueId] "%d %s %s" Offset Genre Espece
	if {$Genre!="" && $Genre!="Genre"} { set Offset -1 }
    }

    if {$Offset<0} {
	set Offset 0
	if {[regexp "from base" $Header]} {
	    set Offset [IntegerApres "from base" dans $Header]
	    incr Offset -1
	}
    }
    return "$Chro $Contig $Troncon $Offset $Genre $Espece"

}

proc ChromoSize {Organisme Version chrNumero} {


#Renvoie la taille d'un chromosome pour un organisme donné
	set Size 0
	
	if { $Organisme == "mouse" } {
		if { $Version == "mm8" } {
			if { $chrNumero == "chr1" } { set Size 197069962 }
			if { $chrNumero == "chr1_random" } { set Size 172274 }
			if { $chrNumero == "chr2" } { set Size 181976762 }
			if { $chrNumero == "chr3" } { set Size 159872112 }
			if { $chrNumero == "chr4" } { set Size 155029701 }
			if { $chrNumero == "chr5" } { set Size 152003063 }
			if { $chrNumero == "chr5_random" } { set Size 2921247 }
			if { $chrNumero == "chr6" } { set Size 149525685 }
			if { $chrNumero == "chr7" } { set Size 145134094 }
			if { $chrNumero == "chr7_random" } { set Size 243910 }
			if { $chrNumero == "chr8" } { set Size 132085098 }
			if { $chrNumero == "chr8_random" } { set Size 206961 }
			if { $chrNumero == "chr9" } { set Size 124000669 }
			if { $chrNumero == "chr9_random" } { set Size 17232 }
			if { $chrNumero == "chr10" } { set Size 129959148 }
			if { $chrNumero == "chr10_random" } { set Size 10781 }
			if { $chrNumero == "chr11" } { set Size 121798632 }
			if { $chrNumero == "chr12" } { set Size 120463159 }
			if { $chrNumero == "chr13" } { set Size 120614378 }
			if { $chrNumero == "chr13_random" } { set Size 436191 }
			if { $chrNumero == "chr14" } { set Size 123978870 }
			if { $chrNumero == "chr15" } { set Size 103492577 }
			if { $chrNumero == "chr15_random" } { set Size 105932 }
			if { $chrNumero == "chr16" } { set Size 98252459 }
			if { $chrNumero == "chr17" } { set Size 95177420 }
			if { $chrNumero == "chr17_random" } { set Size 89091 }
			if { $chrNumero == "chr18" } { set Size 90736837 }
			if { $chrNumero == "chr19" } { set Size 61321190 }
			if { $chrNumero == "chrX" } { set Size 165556469 }
			if { $chrNumero == "chrX_random" } { set Size 39696 }
			if { $chrNumero == "chrY" } { set Size 16029404 }
			if { $chrNumero == "chrY_random" } { set Size 14577732 }
			if { $chrNumero == "chrM" } { set Size 16299 }
			if { $chrNumero == "chrUn_random" } { set Size 1540053 }
		}
		if { $Version == "mm9" } {
			if { $chrNumero == "chr1" } { set Size 197195432 }
			if { $chrNumero == "chr1_random" } { set Size 1231697 }
			if { $chrNumero == "chr2" } { set Size 181748087 }
			if { $chrNumero == "chr3" } { set Size 159599783 }
			if { $chrNumero == "chr4" } { set Size 155630120 }
			if { $chrNumero == "chr5" } { set Size 152537259 }
			if { $chrNumero == "chr5_random" } { set Size 357350 }
			if { $chrNumero == "chr6" } { set Size 149517037 }
			if { $chrNumero == "chr7" } { set Size 152524553 }
			if { $chrNumero == "chr7_random" } { set Size 362490 }
			if { $chrNumero == "chr8" } { set Size 131738871 }
			if { $chrNumero == "chr8_random" } { set Size 849593 }
			if { $chrNumero == "chr9" } { set Size 124076172 }
			if { $chrNumero == "chr9_random" } { set Size 449403 }
			if { $chrNumero == "chr10" } { set Size 129993255 }
			if { $chrNumero == "chr10_random" } { set Size 57815592 }
			if { $chrNumero == "chr11" } { set Size 121843856 }
			if { $chrNumero == "chr12" } { set Size 121257530 }
			if { $chrNumero == "chr13" } { set Size 120284312 }
			if { $chrNumero == "chr13_random" } { set Size 400311 }
			if { $chrNumero == "chr14" } { set Size 125194864 }
			if { $chrNumero == "chr15" } { set Size 103494974 }
			if { $chrNumero == "chr16" } { set Size 98319150 }
			if { $chrNumero == "chr17" } { set Size 95272651 }
			if { $chrNumero == "chr17_random" } { set Size 628739 }
			if { $chrNumero == "chr18" } { set Size 90772031 }
			if { $chrNumero == "chr19" } { set Size 61342430 }
			if { $chrNumero == "chrX" } { set Size 166650296 }
			if { $chrNumero == "chrX_random" } { set Size 1785075 }
			if { $chrNumero == "chrY" } { set Size 15902555 }
			if { $chrNumero == "chrY_random" } { set Size 58682461 }
			if { $chrNumero == "chrM" } { set Size 16299 }
			if { $chrNumero == "chrUn_random" } { set Size 5900358 }
		}
	}
	if { $Organisme == "human" } {
		if { $Version == "hg18" } {
			if { $chrNumero == "chr1" } { set Size 247249719}
			if { $chrNumero == "chr1_random" } { set Size 1663265}
			if { $chrNumero == "chr10" } { set Size 135374737}
			if { $chrNumero == "chr10_random" } { set Size 	113275}
			if { $chrNumero == "chr11" } { set Size 134452384}
			if { $chrNumero == "chr11_random" } { set Size 215294}	
			if { $chrNumero == "chr12" } { set Size 132349534}
			if { $chrNumero == "chr13" } { set Size 114142980}	
			if { $chrNumero == "chr13_random" } { set Size 186858}	
			if { $chrNumero == "chr14" } { set Size 106368585}	
			if { $chrNumero == "chr15" } { set Size 100338915}	
			if { $chrNumero == "chr15_random" } { set Size 784346}	
			if { $chrNumero == "chr16" } { set Size 88827254}	
			if { $chrNumero == "chr16_random" } { set Size 105485}	
			if { $chrNumero == "chr17" } { set Size 78774742}	
			if { $chrNumero == "chr17_random" } { set Size 2617613}	
			if { $chrNumero == "chr18" } { set Size 76117153}	
			if { $chrNumero == "chr18_random" } { set Size 4262}	
			if { $chrNumero == "chr19" } { set Size 63811651}	
			if { $chrNumero == "chr19_random" } { set Size 301858}	
			if { $chrNumero == "chr2" } { set Size 242951149}
			if { $chrNumero == "chr2_random" } { set Size 185571}
			if { $chrNumero == "chr20" } { set Size 62435964}	
			if { $chrNumero == "chr21" } { set Size 46944323}
			if { $chrNumero == "chr21_random" } { set Size 1679693}
			if { $chrNumero == "chr22" } { set Size 49691432}
			if { $chrNumero == "chr22_random" } { set Size 257318}	
			if { $chrNumero == "chr22_h2_hap1" } { set Size 63661}	
			if { $chrNumero == "chr3" } { set Size 199501827}	
			if { $chrNumero == "chr3_random" } { set Size 749256}	
			if { $chrNumero == "chr4" } { set Size 191273063}	
			if { $chrNumero == "chr4_random" } { set Size 842648}	
			if { $chrNumero == "chr5" } { set Size 180857866}	
			if { $chrNumero == "chr5_random" } { set Size 143687}	
			if { $chrNumero == "chr5_h2_hap1" } { set Size 1794870}
			if { $chrNumero == "chr6" } { set Size 170899992}
			if { $chrNumero == "chr6_random" } { set Size 1875562}	
			if { $chrNumero == "chr7" } { set Size 158821424}
			if { $chrNumero == "chr7_random" } { set Size 549659}
			if { $chrNumero == "chr8" } { set Size 146274826}
			if { $chrNumero == "chr8_random" } { set Size 943810}
			if { $chrNumero == "chr9" } { set Size 140273252}
			if { $chrNumero == "chr9_random" } { set Size 1146434}
			if { $chrNumero == "chrM" } { set Size 16571}
			if { $chrNumero == "chrX" } { set Size 154913754 }
			if { $chrNumero == "chrX_random" } { set Size 1719168}
			if { $chrNumero == "chrY" } { set Size 57772954}	
		}
	}
	return $Size


}

proc ChromosomeCutter {Chromosome MegabasesParFichier} {


# Découpe un chromosome (fichier avec une séquence) en plusieurs fichiers selon la taille désirée

	set PathIn "/tmp/GenomeMasque"
	set PathOut "/tmp/GenomeMasqueDecoupe"
	
	set End "fa.masked"
	
	set FichierFa [open "$PathIn/chr$Chromosome.$End" "r"]
	set FichierDecoupe "$PathOut/chr$Chromosome.1.$End"
	
	set NumeroFichier 1
	set NbLigne 0
	while { [gets $FichierFa LigneFa] >=0 } {
		ScanLaListe $LigneFa SequenceFa
		incr NbLigne
		set FirstCarac [string index $SequenceFa 0 ]
		set Entete ""
		if { $FirstCarac == ">" } {
			set Entete $SequenceFa
		}
		
		set LongueurLigne [string length $LigneFa]
		set Taille [expr $LongueurLigne * $NbLigne]
		if { $Taille > [expr $MegabasesParFichier * 1000000 ] } {
			incr NumeroFichier
			set FichierDecoupe "$PathOut/chr$Chromosome.$NumeroFichier.$End"
			AppendAuFichier $FichierDecoupe $Entete
			set Taille 0
			set LongueurLigne 0
			set NbLigne 0
		}
		
		if { $FirstCarac != ">" } {
			AppendAuFichier $FichierDecoupe $SequenceFa			
		}
	}


}

proc ChromosomeSelectionne {K {LesNoms ""} Qui} {

    set Liste [$K find withtag current]
    foreach Id $Liste {
	set Chromosome          [lindex [$K gettags $Id] 0]
	set FichierLocalisation [lindex [$K gettags $Id] 1]
	IllustreUnChromosome $Chromosome $LesNoms $Qui
    }

}

proc ChronnometreOrdali {{quoi ""}} {

    global _TpsInitial
    set rep ""
    if {$quoi eq "init"} {
	set _TpsInitial [clock scan now]
    } else {
	set diff [expr {[clock scan now] - $_TpsInitial}]
	set rep [clock format $diff -gmt 1 -format "%H:%M:%S"]
    }
    
    return $rep

}

proc Chronometre {args} {

    global TempsDeDepartDuChronometre

    set Action [lindex $args 0]
    if {[string equal -nocase $Action "Depart"]} {
	if {[info exists TempsDeDepartDuChronometre]} {unset TempsDeDepartDuChronometre}
	set TempsDeDepartDuChronometre [clock clicks -milliseconds]
	Espionne "Depart   -> 0.0 millisec"
	return 0
    }
    if {![info exists TempsDeDepartDuChronometre]} {return}
    if {[string equal -nocase $Action "Consulte"]} {
	set T [expr [clock clicks -milliseconds] - $TempsDeDepartDuChronometre]
	Espionne "Consulte -> $T millisec"
	return $T
    }
    if {[string equal -nocase $Action "Arrivee"]} {
	set T [expr [clock clicks -milliseconds] - $TempsDeDepartDuChronometre]

	unset TempsDeDepartDuChronometre
	
	Espionne "Arrivee  -> $T millisec"
	return $T
    }
    return

}

proc CibleFromNaomi {} {

    set boxtotalRat 0; set boxtotalMouse 0; set boxpresentRat 0; set boxpresentMouse 0
    set File "/genomics/link/SpliRetMouse2009/CibleNaomi17092010/CibleFromNaomi_17092010.csv"
    foreach Ligne [LesLignesDuFichier $File] {
	foreach {IdOrg ClusterId} [split $Ligne ";"] {
	    if {$IdOrg == "SPR"} { 
		incr boxtotalRat
		set Science "SpliRetRat" 
		set Org "Rat"
	    }
	    if {$IdOrg == "SPM"} {
		incr boxtotalMouse
		set Science "SpliRetMouse"
		set Org "Mouse"
	    }
	    set ClusterId "cluster_$ClusterId"
	    set Box [QuestionDeScience $Science "ret InterrogeBox $ClusterId Box"]
	    if {$Box==""} {lappend LesLignes "$Org;$ClusterId;No"; continue}
	    if {$IdOrg == "SPR"} {incr boxpresentRat}
	    if {$IdOrg == "SPM"} {incr boxpresentMouse}
	    set Tag [QuestionDeScience $Science "ret ExtraitInfo $Box Tag"]    
	    set LesNames [QuestionDeScience $Science "ret InterrogeNames $ClusterId Name $Org"]
	    lappend LesLignes "$Org;$ClusterId;$Tag;$LesNames"	    
	}
    }
    lappend LesLignes "nombre de cluster Rat         : $boxtotalRat"
    lappend LesLignes "nombre de cluster Rat trouve  : $boxpresentRat"
    lappend LesLignes "nombre de cluster Mouse       : $boxtotalMouse"
    lappend LesLignes "nombre de cluster Mouse trouve: $boxpresentMouse"
    SauveLesLignes $LesLignes dans "/genomics/link/SpliRetMouse/CibleNaomi17092010/CorresNaomiMoi"

}

proc CiliaStatusOfOrga {Orga} {


    regsub "_" $Orga " " Orga

    global CiliaStatusOfOrga
    if {[info exists CiliaStatusOfOrga($Orga)]} { return $CiliaStatusOfOrga($Orga) }
    if {[info exists CiliaStatusOfOrga("EstCharge")]} { return "" }
    set CiliaStatusOfOrga("EstCharge") 1
    
    set CiliaStatusOfOrga(filename) "[RepertoireDuGenome]/DeAlicia/OrgaWithWithoutLoosedCilia.list" 

    set Status "Unknown"
    foreach Ligne [LesLignesDuFichier $CiliaStatusOfOrga(filename)] {
	if {[regexp -nocase "# *with cilia"    $Ligne]} { set Status "WithCilia" ; lappend LesStatus $Status; continue }
	if {[regexp -nocase "# *without cilia" $Ligne]} { set Status "No"        ; lappend LesStatus $Status; continue }
	if {[regexp -nocase "# *lost cilia"    $Ligne]} { set Status "Lost"      ; lappend LesStatus $Status; continue }
	scan $Ligne "%s %s" Genre Espece
	set O "$Genre $Espece"
#	set O [string trim $O "."]
	set CiliaStatusOfOrga($O) $Status
	lappend CiliaStatusOfOrga($Status) $O
    }
    set CiliaStatusOfOrga(ListOfStatus) [lsort $LesStatus]
    foreach Status $CiliaStatusOfOrga(ListOfStatus) {
	set CiliaStatusOfOrga($Status) [lsort -unique $CiliaStatusOfOrga($Status)]
    }
    return [CiliaStatusOfOrga $Orga]

}

proc CilioBlastSummary {Nom {GetWhat ""} {RepBlast ""}} {

    
    global ScoreDansProfil ; set ScoreDansProfil 1
    set Long [LongueurDeLaSequence $Nom prottfa]
    set NbrCopBlast [NombreDeCopainsDansBlast $Nom]
    DecortiqueBlast [GscopeFile $Nom blastp] "SansSeuilExpect" "SansLimiteDeNombreDuTout" Query LesBId LesAcc LesDe LesScore LesExpect
    set MaxScore  [lindex $LesScore 0]
    set MinScore  [lindex $LesScore end]
    set MinExpect [lindex $LesExpect 1]
    set MaxExpect [lindex $LesExpect end]
    set ValNormD  [NormdEnStock $Nom $RepBlast]
    
    set LaSortie {}
    set ResultatBlast [OrganismsInCilioBlast $Nom "" $RepBlast]
    
    lappend LaSortie "Nom                 : $Nom"
    lappend LaSortie "Longueur sequence   : $Long"
    lappend LaSortie "Banque blast        : $RepBlast"
    lappend LaSortie "Score Min           : $MinScore"
    lappend LaSortie "Score Max           : $MaxScore"
    lappend LaSortie "Expect Min          : $MinExpect"
    lappend LaSortie "Expect Max          : $MaxExpect"
    lappend LaSortie "Valeur NormD        : $ValNormD"
    LConcat LaSortie $ResultatBlast
    
    if {[regexp -nocase "Show" $GetWhat]} { return [AfficheListe $LaSortie "" "$Nom"] }
    
    return $LaSortie

}

proc CilioBlastSummaryRR {Nom {GetWhat ""}} {

    #rR attention ceci est pour CilioCode ou les enteteschevronnées sont des fois sans BId Acc (onsaute)

    set LaSortie {}
    set TousLesExpects {}
    foreach Ligne [LesEntetesChevronneesDuBlast [GscopeFile $Nom "blastp"] "GetHeaders"] {
	if { ! [regexp {>[^_]+_[^_]+ } $Ligne]} { continue } ; #rR on saute
	regsub "^>" $Ligne "" Ligne 
	scan $Ligne "%s %s %s %s" BId Acc Genre Espece
	set Orga "$Genre $Espece"
	set Expect [StringApres "Expect=" dans $Ligne]
	lappend TousLesExpects $Expect
	if { ! [info exists Compte($Orga,Hits)]} {
	    lappend LesOrgas $Orga
	    set Compte($Orga,Hits) 0
	    set Compte($Orga,Repeats) 0
	    set Compte($Orga,Fragments) 0
	    set Compte($Orga,Uncharacterized) 0
	    set LesExpects($Orga) {}
	}
	incr Compte($Orga,Hits)
	if {[regexp -nocase "repeat" $Ligne]}   { incr Compte($Orga,Repeats) }
	if {[regexp -nocase "fragment" $Ligne]} { incr Compte($Orga,Fragments) }
	if {[regexp -nocase "uncharac" $Ligne]} { incr Compte($Orga,Uncharacterized) }
	lappend LesExpects($Orga) $Expect
    }
    if {[regexp -nocase "Expect" $GetWhat]} { return $TousLesExpects }
    if {[regexp -nocase "Orga"   $GetWhat]} { return $LesOrgas }
    if {[regexp -nocase "Graph"  $GetWhat]} { return [Graphe $TousLesExpects "" "" "" "" "" "" "" "$Nom"] }
    foreach Orga $LesOrgas {
	set CiliaStatus [CiliaStatusOfOrga $Orga] 
	lappend LaSortie "[format %40s $Orga] [format %-12s $CiliaStatus] $Compte($Orga,Hits) $Compte($Orga,Repeats) $Compte($Orga,Fragments) $Compte($Orga,Uncharacterized) [join $LesExpects($Orga) { }]"
    }
    if {[regexp -nocase "Show"   $GetWhat]} { return [AfficheListe $LaSortie "" "$Nom"] }
    return $LaSortie

}

proc CilioCartaDb {{Qui ""} {Quoi ""} {Value ""} {GetWhat ""}} {


    CanalSqlCilioCarta
#    set R [SqlExec "select name from sqlite_master" $Quoi]
#    set R [SqlExec "select * from prot where genename is not null limit 3" $Quoi]

    if {[regexp -nocase "ListOf" $Qui] && [regexp -nocase "Table" $Quoi]} {
	return [SqlExec "SELECT name FROM sqlite_master" "GetList"]
    }
    if {[regexp -nocase "Sql" $Qui] } {
	return [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
    }
    if {[regexp "Columns" $Qui]} {
	set S [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
	set LesMots [split [string trim [join [lrange [split $S " "] 3 end] " "] "()"] ","]
	set LeR {}
	set LesC {}
	foreach Mot $LesMots {
	    set Mot [string trim $Mot]
	    regsub " " $Mot "\t" Mot
	    lassign [split $Mot "\t"] N T
	    regsub -all {\"} $N "" N
	    lappend LeR [format "%-25s\t%s" $N $T]
	    lappend LesC $N
	}
	if {[regexp "ColumnsWith" $Qui]} { return $LeR }
	return $LesC
    }
    return [SqlExec "select * from $Qui where $Quoi like '$Value'" $GetWhat]    

}

proc CilioCartaDir {} {

    return "/genomics/link/CilioCarta/DeKirsley/101"

}

proc CilioCartaProject {{Qui ""} {Quoi ""}} {

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

    set LesDeOi [glob -nocomplain "/gstock/*/DeOi"]
    set LesProj {}
    foreach DeOi $LesDeOi {
	set Proj [file tail [file dirname $DeOi]]
	lappend LesProj $Proj
    }
    
    set LesTypes [list prottfa blastp taxobla descritptifs msf]

    set LesProj [lsort $LesProj]
    set PCC(ListOf,Project) $LesProj
    foreach Pro $LesProj {
	set Message [format "%-15s" $Pro]
	foreach Type $LesTypes {
	    set Rep "/gstock/$Pro/$Type"
	    if {[FileAbsent $Rep]} {
		set PCC($Pro,$Type) 0
	    } else {
		cd "/gstock/$Pro/$Type"
		set PCC($Pro,$Type) [exec ls -f | wc -l]
	    }
	    append Message [format "%10d %s" $PCC($Pro,$Type) $Type]
	}
	Espionne $Message
    }
    return [CilioCartaProject $Qui $Quoi]

}

proc CilioCartaVersion {} {

    return 1.2

}

proc CilioDesc {{Qui ""} {Quoi ""}} {

    global CilioDesc

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }

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

    set FichierCsv "[CilioCartaDir]/101_ciliopathies_desc.csv"
    set CilioDesc(filename,) $FichierCsv

    LoadTxlWithRowsOfCells $FichierCsv CilioDesc 0 "\t"

    set CilioDesc(ListOf,Gene)   $CilioDesc(ListAllPlease,)
    set CilioDesc(ListOf,Header) $CilioDesc(ListHeaderPlease,)
    return [CilioDesc $Qui $Quoi]

}

proc CilioMapping {{Qui ""} {Quoi ""}} {

    global CilioMapping

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Keys" }

    if {[info exists CilioMapping($Qui,$Quoi)]} { return $CilioMapping($Qui,$Quoi) }
    if {[info exists CilioMapping("EstCharge")]} {
	if {[info exists CilioMapping($Qui,GI)]  && [info exists CilioMapping($CilioMapping($Qui,GI),$Quoi)]} {
	    return $CilioMapping($CilioMapping($Qui,GI),$Quoi)
	}
	return ""
    }
    set CilioMapping("EstCharge") 1

    set FichierCsv "[CilioCartaDir]/101_ciliopathies_mapping_ids.tsv"
    set CilioMapping(filename,) $FichierCsv

    LoadTxlWithRowsOfCells $FichierCsv CilioMapping 0 "\t"

    set CilioMapping(ListOf,GI) $CilioMapping(ListAllPlease,)
    set CilioMapping(ListOf,Header)  $CilioMapping(ListHeaderPlease,)

    set LesH [list gene_stable_id gene_display_label transcript_stable_id translation_stable_id UniProt_ID]
    set LesK [list GI             GN                 TI                   PI                    AC        ]
    set CilioMapping(ListOf,Keys) $LesK
    foreach GI $CilioMapping(ListOf,GI) {
	set CilioMapping($GI,All) "$GI"
	foreach H $LesH K $LesK {
	    set $K [string trim $CilioMapping($GI,$H)]
	    append CilioMapping($GI,All) "\t[set $K]"
	    lappend CilioMapping(ListOf,$K) [set $K]
	    set CilioMapping($GI,$K) [set $K]
	    set CilioMapping([set $K],GI) $GI
	}
    }

    return [CilioMapping $Qui $Quoi]

}

proc CilioPep {{Qui ""} {Quoi ""}} {

    global CilioPep

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }

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

    set Fichier "[CilioCartaDir]/101_ciliopathies_pep.fasta"

    set LesK [list AC ID GN     GI   TI   PI   DE     SO          PM     CS             LO       CN           SQ FA]
    set LesG [list AC ID ValiGN ENSG ENST ENSP ValiDE SourceOfDef PubMed CiliomeStudies Location CuratorsNote "" ""]
    set CilioPep(ListOf,Header)       $LesK
    set CilioPep(ListOf,GscopeHeader) $LesG

    set LesLignes [LesLignesDuFichier $Fichier]
    lappend LesLignes ">fin"
    set PremiereFois 1
    foreach Ligne $LesLignes {
	if { ! [regexp ">" $Ligne]} {
	    lappend LaSeq $Ligne
	    continue
	}
	if {$PremiereFois} {
	    set PremiereFois 0
	    set LaSeq {}
	} else {
	    set SQ [join $LaSeq "\n"]
	    set LaSeq {}
	    set FA [SequenceFormatTFA $SQ "$GN $DE ID=$ID AC=$AC PI=$PI"]
	    foreach K $LesK {
		set CilioPep($GI,$K) [set $K]
		lappend CilioPep(ListOf,$K) [set $K]
	    }
	}
	if {$Ligne==">fin"} { break }
        #   AC     ID         DE          OS              GN
	#sp|Q8N157|AHI1_HUMAN Jouberin OS=Homo sapiens GN=AHI1 PE=1 SV=1

	if { ! [regexp {([^ ]+) ([^=]+)} $Ligne Match Access DE]} { FaireLire "ca merde pour $Ligne" }
	set AC [lindex [split $Access "|"] 1]
	set ID [lindex [split $Access "|"] 2]
	
	set DE [string trim [string range $DE 0 end-2]]
	regsub { PE=.*} $Ligne "" Ligne
	set GN [string trim [StringApres "GN=" dans $Ligne]]
	regsub { GN=.*} $Ligne "" Ligne
	set OS [StringSuivant "OS=" dans $Ligne]
#	Espionne "$AC $ID $GN $OS / $DE"

	set GI [CilioMapping $AC GI]
	set TI [CilioMapping $AC TI]
	set PI [CilioMapping $AC PI]

	set gn [CilioMapping $AC GN]         ; if {$gn!=$GN} { FaireLire "dans mapping $AC/$gn/!=/$GN/$AC [CilioMapping $AC All]" }
	set gn [CilioDesc $GI Gene_Name]     ; if {0 && $gn!=$GN} { FaireLire "dans desc $GI/$gn/!=$GN/" }
	set ei [CilioDesc $GI "Ensembl_ID"]  ; if {0 && $ei!=$GI} { FaireLire "Ca merde pour Ensembl_Id=$ei= et GI=$GI=" }

	set de [CilioDesc $GI "Description"] 	
	set SO ""
	if {[regexp {([^\[]+) \[Source:(.*)\]} $de Match NewDE SO]} {
	    set de [string trim $NewDE]
	    set SO [string trim $SO]
	}
	if {0 && $de!=$DE} {
	    regsub "protein " $DE "" DEcoupe
	    if {[string trim $de]!=[string trim $DEcoupe]} { FaireLire "Ca merde pour \n$de\n$DEcoupe" }
	}

	set PM [CilioDesc $GI "PubMed_IDs"]
	set CS [CilioDesc $GI "Ciliome_studies"]
	set LO [CilioDesc $GI "Localisation"]
	set CN [CilioDesc $GI "Curators_Note"]
    }

    foreach K $LesK {
	set CilioPep(ListOf,$K) [lsort -unique $CilioPep(ListOf,$K)]
    }
    foreach GI $CilioPep(ListOf,GI) {
	set GN $CilioPep($GI,GN)
	set PI $CilioPep($GI,PI)
	foreach K $LesK {
	    set CilioPep($GN,$K) $CilioPep($GI,$K)
	    set CilioPep($PI,$K) $CilioPep($GI,$K)
	}
    }
    
    return [CilioPep $Qui $Quoi]

}

proc CineticCongRD1 {{Qui ""} {Quoi ""}} {

    global CineticCongRD1

    if {$Qui==""} { set Qui "ListOf" ; set Quoi "GoodHeader" }

    if {[info exists CineticCongRD1($Qui,$Quoi)]}  { return $CineticCongRD1($Qui,$Quoi) }
    if {[info exists CineticCongRD1("EstCharge")]} {
	if {$Qui=="SaveInFile"} {
	    set LesGoodHeader [CineticCongRD1 ListOf GoodHeader]
	    set Headers [join $LesGoodHeader "\t"]
	    set LaSortie {}
	    lappend LaSortie $Headers
	    foreach PS [CineticCongRD1 ListOf PS] {
		set LaLigne {}
		foreach H [CineticCongRD1 ListOf GoodHeader] {
 		    lappend LaLigne [CineticCongRD1 $PS $H]
		}
		set Ligne [join $LaLigne "\t"]
		lappend LaSortie $Ligne
	    }
	    set Fichier $Quoi
	    set Fichier [SauveLesLignes $LaSortie dans $Fichier]
	    return $Fichier
	}
	return ""
    }
    set CineticCongRD1("EstCharge") 1

#rR set FichierFred "[HomeRipp]/GenoretWww/Collaboration/CineticCongRD1/Additional_File_3-Table.csv"
    set FichierFred "[HomeRipp]/GenoretWww/Collaboration/CineticCongRD1/Additional_File_3-Tablev3.csv"
    set Q [file tail $FichierFred]
    regsub -nocase {\.[^\.]+$} $Q "" Q
    LoadTxlWithRowsOfCells $FichierFred Txl -1 ";"

    set CineticCongRD1(File,Name)  $FichierFred
    set CineticCongRD1(File,Queue) $Q

#    EspionneL $Txl(ListHeaderPlease,$Q)
    set CineticCongRD1(ListOf,Header) $Txl(ListHeaderPlease,$Q)
    set CineticCongRD1(ListOf,Index)  $Txl(ListAllPlease,$Q)
    set UnknownGN 0
    foreach I $CineticCongRD1(ListOf,Index) {
	set GN $Txl($I,GeneName)
	if {$GN=="-"} { set GN "Unknown_[incr UnknownGN]" }
	lappend CineticCongRD1(ListOf,GN) $GN
	set PS $Txl($I,ID)
	lappend CineticCongRD1(ListOf,PS) $PS
	lappend CineticCongRD1($GN,ListOfPS) $PS
	if {[info exists DejaVu($PS)]} { FaireLire "I found redondant probesets : $I $GN $PS" }
	set DejaVu($PS) $I
	set CineticCongRD1($PS,GN) $GN
	foreach T $CineticCongRD1(ListOf,Header) {
	    set CineticCongRD1($I,$T)  $Txl($I,$T)
	    set CineticCongRD1($PS,$T) $Txl($I,$T)
	    set CineticCongRD1($PS,Index) $I
	}
    }


    set CineticCongRD1(ListOf,GN) [lsort -unique $CineticCongRD1(ListOf,GN)]
    foreach GN $CineticCongRD1(ListOf,GN) {
	foreach Mot [split $GN ","] {
	    if {[OnTraiteEVImm]} {
		set GscopeIds [GscopeIdsOfGeneName $Mot "WithSynonymsRetChipOnly"]
		set GscopeIds [CineticCongRD1Filter $GscopeIds]
	    } else {
		set GscopeIds [QuestionDeScience "EVImm" "ret GscopeIdsOfGeneName $Mot WithSynonymsRetChipOnly"]
		set GscopeIds [QuestionDeScience "EVImm" "ret CineticCongRD1Filter $GscopeIds"]
	    }
	    set CineticCongRD1($GN,GscopeIds) $GscopeIds
	    foreach PS $CineticCongRD1($GN,ListOfPS) {
		set CineticCongRD1($PS,GscopeIds) $GscopeIds
		set CineticCongRD1($PS,PS) $PS
		set CineticCongRD1($PS,GN) $GN
	    }
	}
    }
    set CineticCongRD1(ListOf,GoodHeader) [concat [list "PS" "GN" "GscopeIds"] $CineticCongRD1(ListOf,Header)] 
    return [CineticCongRD1 $Qui $Quoi]

}

proc CineticCongRD1Filter {Liste} {

    set New {}
    foreach Nom $Liste {
	if {[info exists DejaVu($Nom)]} { continue }
	set DejaVu($Nom) 1
	if { ! [IsRetchip $Nom]} { continue }
	lappend New $Nom
    }
    return $New

}

proc CineticCongRD1Tissues {} {

    CanalSqlRetinoBase
    SqlExec "select set_curcfg('default');"
    set LesTissues [list  "retina = Ret"  "MGC"  "brain = BR"  "testis"  "cumulus_oocyte_complex"  "ovary"  "placenta"  "aorta"  "heart"  "lung"  "kidney"  "liver"  "spleen"  "submax_gland"  "thymus"  "stomach"  "lymph_node"  "skeletal_muscle"  "CD4+_naive"  "embryo_d7"]
    foreach Truc $LesTissues {
	set Better ""
	set Old ""
	scan $Truc "%s %s %s" Name Better Old
	if {$Old!=""} { continue }
	if {$Better!=""} { set BetterName($Name) $Better ; set Name $Better }
	set Pk [ProchainPk "retinobase3.tissue"]
	regsub -all "_" $Name " " Description 
	set Sql "insert into retinobase3.tissue (pk_tissue, name, description) values ($Pk, '$Name', '$Description') ;"
	Espionne $Sql
#	SqlExec $Sql
    }
    CanalSqlDisconnect


}

proc CioNarcisse {A} {

    global CioNarcisse

    if {[info exists CioNarcisse($A)]} { return [set CioNarcisse($A)] }
    if {[info exists CioNarcisse("EstCharge")]} { return $A }

    set CioNarcisse("EstCharge") 1

    foreach Ligne [LesLignesDuFichier "/genomics/link/Ciona/fiches/narcisse"] {
	set X ""
	set Y ""
	scan $Ligne "%s %s" X Y
	set CioNarcisse($X) $Y
	set CioNarcisse($Y) $X
    }
    return [CioNarcisse $A]

}

proc CladeChallenge {{Challenger ""} {Referencer ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {

    FaireLire "Pas encore fini ... on voudrait comparer deux clades .. le meilleur de l'un par rapport à l'autre ???"
    if {$Challenger==""} { set Challenger [SelectOneClade]  }
    if {$Referencer==""}  { set Referencer [SelectOneClade]  }
    
    set EnTest [regexp {^(ripp|scherb)$} [Login]] 
    #	set EnTest 0
    
    if {$UseExpect==""}    { set UseExpect "UseScore" }	
    if {$GetWhat==""} { set GetWhat "Show" }
    if {$Seuil==""} { set Seuil 99999 }
    
    regsub -all " " $Challenger "_" ChallengerUnderscore
    regsub -all " " $Referencer "_" ReferencerUnderscore
    set UseExpect [string equal -nocase "UseExpect" $UseExpect]
    
    set Echantillonage 20
    
    if {[OnTraite CilioCarta Like]} {
	set LesTaxIdsChallenger [QuestionDeScience CilioCarta "ret CladeContent $Challenger"]
	set LesTaxIdsReferencer [QuestionDeScience CilioCarta "ret CladeContent $Referencer"]
    } elseif {[OnTraite OI2017 Like]} {
	set LesTaxIdsChallenger [QuestionDeScience OI "ret CladeContentWithinOi2017 $Challenger"]
	set LesTaxIdsReferencer [QuestionDeScience OI "ret CladeContentWithinOI2017 $Referencer"]
    } else {
    }
    set NbTaxIdChallenger [llength $LesTaxIdsChallenger]
    set NbTaxIdReferencer [llength $LesTaxIdsReferencer]
    
    # on fait l'initialisation
    foreach TaxId $LesTaxIdsReferencer {
	set SommeDesDeltasReferencerPour($TaxId) 0.0
	set NbDeltasReferencerPour($TaxId) 0
    }
    
    set LesMeilleursChallenger {}
    set LesMeilleursReferencer {}
    set NbNomChallenger 0
    set NbNomReferencer 0
    foreach Nom [ListeDesPABs] {
	if {0 && $NbNom%100==0} { Espionne "$NbNom $Nom" }
    	if {$EnTest && $Nom>"HSAP20193"} { break }
	set LesHitsAvecDeltaChallenger [LesHitsAvecDelta $Nom $LesTaxIdsChallenger $Seuil "GetList" $SelectMethod $UseExpect]
	set LesHitsAvecDeltaReferencer [LesHitsAvecDelta $Nom $LesTaxIdsReferencer $Seuil "GetList" $SelectMethod $UseExpect]
	if {$LesHitsAvecDeltaChallenger!={}} {
	    incr NbNomChallenger
	    foreach HitAvecDelta $LesHitsAvecDeltaChallenger {
		lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
		regsub -all "\t" $OS " " OS
		set SommeDesDeltasChallengerPour($TaxId) [expr $SommeDesDeltasChallengerPour($TaxId)+$Delta]
		set InfoDu($TaxId) "$OS\t$Reste"
		incr NbDeltasChallengerPour($TaxId)
		lappend LesDeltasChallengerDe($TaxId) $Delta
		lappend LesNomsChallengerDe($TaxId,$Delta) $Nom
		MemoDelta $TaxId $Delta $Nom
	    }
	}
	if {$LesHitsAvecDeltaReferencer!={}} {
	    incr NbNomReferencer
	    foreach HitAvecDelta $LesHitsAvecDeltaReferencer {
		lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
		regsub -all "\t" $OS " " OS
		set SommeDesDeltasReferencerPour($TaxId) [expr $SommeDesDeltasReferencerPour($TaxId)+$Delta]
		set InfoDu($TaxId) "$OS\t$Reste"
		incr NbDeltasReferencerPour($TaxId)
		lappend LesDeltasReferencerDe($TaxId) $Delta
		lappend LesNomsReferencerDe($TaxId,$Delta) $Nom
		MemoDelta $TaxId $Delta $Nom
	    }
	}
    }
    foreach TaxId $LesTaxIdsChallenger {
	set Moyenne [expr $SommeDesDeltasChallengerPour($TaxId)/$NbDeltasChallengerPour($TaxId)]
	set MoyenneDesDeltasChallengerPour($TaxId) $Moyenne
	lappend LesMoyennesDesDeltasChallenger $Moyenne
	lappend LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) $TaxId
    }
    foreach TaxId $LesTaxIdsReferencer {
	set Moyenne [expr $SommeDesDeltasReferencerPour($TaxId)/$NbDeltasReferencerPour($TaxId)]
	set MoyenneDesDeltasReferencerPour($TaxId) $Moyenne
	lappend LesMoyennesDesDeltasReferencer $Moyenne
	lappend LesTaxIdsDeLaMoyenneDesDeltasReferencer($Moyenne) $TaxId
    }
    if {$UseExpect} {
	set LesMoyennesDesDeltasChallenger [lsort -unique -real $LesMoyennesDesDeltasChallenger]
	set LesMoyennesDesDeltasReferencer [lsort -unique -real $LesMoyennesDesDeltasChallenger]
    } else {
	set LesMoyennesDesDeltasChallenger [lsort -decreasing -unique -real $LesMoyennesDesDeltasChallenger]
	set LesMoyennesDesDeltasReferencer [lsort -decreasing -unique -real $LesMoyennesDesDeltasReferencer]
    }
    #####################################################################################################################
    set LaSortie [list "# TailleP  NombreDeDelta  Moyenne    TaxId      Nom_de_l'espece "]
    foreach Moyenne $LesMoyennesDesDeltasChallenger {
	foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) {
	    set BelleMoyenne [format "%6.0f" $Moyenne]
	    lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPourChallenger($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)"
	}
    }
    set AvecHisto 0
    if {$AvecHisto} {
	set LargeurMax 4000
	set HauteurMax 5000
	set Largeur    3000
	set Hauteur    2000
	set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur]
	global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400]
    }
    set IemeTaxId -1
    
    foreach TaxId $LesTaxIdsChalenger {
	set OS [Tax $TaxId Name]
	regsub -all " " $OS "_" OSUnderscore
	incr IemeTaxId
	if {[info exists Cumul]} { unset Cumul }
	
	set MinDelta  9999999
	set MaxDelta -9999999
	foreach Delta $LesDeltasDeChallenger($TaxId) {
	    set MinDelta [Mini $Delta $MinDelta]
	    set MaxDelta [Maxi $Delta $MaxDelta]
	}
	set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage]
	
	set MinDeltaDe($TaxId) $MinDelta
	set MaxDeltaDe($TaxId) $MaxDelta
	set IntervalDeltaDe($TaxId) $IntDelta
	
	set MinCase  9999
	set MaxCase -9999
	foreach Delta $LesDeltasDe($TaxId) {
	    if {$IntDelta<0.0000001} {
		set Case 0
	    } else {
		set Case [expr round(($Delta - $MinDelta)/$IntDelta)]
	    }
	    set MinCase [Mini $MinCase $Case]
	    set MaxCase [Maxi $MaxCase $Case]
	    if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
	    incr Cumul($Case)
	    set Tag($Case) $Delta
	    foreach Nom [MemoDelta $TaxId $Delta] {
		set BeauDelta    [format "%6.0f" $Delta]
		set BelleMoyenne [format "%6.0f" $Moyenne]
		MemoInfo $TaxId $Case "$Nom $BeauDelta $BelleMoyenne"
	    }
	}
	set LesX {}
	set LesY {}
	set LesTags {}
	set LaCase [list "#EcartM      NF       Case         TaxId           OS                                                                     Reference_Clade"]
	set LesBornesDeCases [NombresEntre $MinCase $MaxCase]
	if { ! $UseExpect} {
	    set LesBornesDeCases [lreverse $LesBornesDeCases]
	}
	foreach Case $LesBornesDeCases {
	    if { ! [info exists Cumul($Case)]}         { continue }
	    if { ! [info exists Tag($Case)]}           { set Tag($Case) "0.0" }
	    if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" }
	    set X  [expr $MinDelta + $Case*$IntDelta]
	    lappend LesX $X
	    lappend LesY $Cumul($Case)
	    lappend LesTags "[format %5.0f $X]:$Cumul($Case) $OS"
	    lappend LaCase  "[format %5.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore"  
	}
	MemoCase $TaxId LaCase $LaCase
	if {$AvecHisto} {
	    set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]]
	    Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax
	} else {
	    #	    set F [AfficheListe $LaCase "AvecCase" $OS]
	    #	    set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
	    #	    $B configure -background "Magenta"
	}
	
    }
    
    if {$GetWhat=="Show"} {
	set F [AfficheListe $LaSortie "" "Delta distribution for $Clade"]
	set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"]
	$B configure -background "Magenta"
    }
    
    return $LaSortie

}

proc CladeContent {Clade {UseQds ""} {WithoutTaxIds ""}} {

    #rR WithoutTaxIds est une liste de TaxIds qu'il faut ne pas considérer (typiquement 9606)
    #rR UseQds Pour aller plus vite ... mais attention à ne pas le faire en QDS
    if {$UseQds=="UseQds" && ( ! [OnTraite CilioCarta] || ! [PourWscope]) } {
	return [QuestionDeScience CilioCarta "ret CladeContent $Clade Direct $WithoutTaxIds"]
    }
    set WithoutTaxIds [split $WithoutTaxIds ","]
    set Content {}
    foreach S {Y PR N} {
	if {[regexp {([A-Z]+)_} $Clade Match X]} {
	    if {$S!=$X} { Espionne $Clade; continue } 
	    set C [BilanCilio $Clade "CladeContentTaxIds"]
	} else {
	    set C [BilanCilio "${S}_$Clade" "CladeContentTaxIds"]
	}
	foreach TaxId $C {
	    if {[lsearch $WithoutTaxIds $TaxId]>=0} { continue }
	    lappend Content $TaxId
	}
    }
    return $Content

}

proc CladeContentWithinOi2017 {Clade {KindOfClades ""}} {

    JeMeSignale
    #rR on ne garde que ceux qui existent aussi dans Oi2017 ATTENTION AU DOMAINE ... à faire

    if {$KindOfClades==""} {
	if {[OiDomain]=="Archaea"} { set KindOfClades "Archaea" }
	if {[OiDomain]=="Eukaryota"} { set KindOfClades "CMC" }         ; #rR a corriger pour la suite   !!!!!!!!!!!
    }
    Espionne "OiDomain =[OiDomain]= KindOfClades =$KindOfClades="
    if {$KindOfClades=="CMC"} {
	set Domaine "Eukaryota"
	set LesTaxId [CMC $Clade OX]
    } elseif  {$KindOfClades=="TTLL"} {
	set Domaine "Eukaryota"
	set LesTaxId [TTLL $Clade OX]
    } elseif  {$KindOfClades=="Archaea"} {
	set Domaine "Archaea"
	set LesTaxId [PhylAr $Clade ListOfOX]
    } else {
	set Domaine "Eukaryota"
	set LesTaxId [CladeContent $Clade]
    }
    set LesBons {}
    foreach TaxId $LesTaxId {
	#if {[OiCodeForDomain $Domaine $TaxId OI]==""} { continue }
	if {[OiCode $TaxId OI]==""} { continue }
	lappend LesBons $TaxId
    }
    return $LesBons

}

proc CladeCourant {{NewValue ""} {Format ""}} {

    JeMeSignale
    global CladeCourant

    if {$Format==""} { set Format "Name" }

    if {$NewValue=="IsSet"} {
	return [info exists CladeCourant]
    }
    if {$NewValue=="UnSet"} {
	if {[info exists CladeCourant]} { unset CladeCourant }
	return ""
    }
    if {$NewValue=="New"} {
	while {$NewValue=="New"} {
	    if {[OnTraite "CilioCarta" "Like"]} {
		set NewValue ""
		break
	    }
	    set NewValue [Entre "Mammalia"]
	    if {[Tax $NewValue]==""} {
		if {[OuiOuNon "Sorry $NewValue does not exist. Do I exit CladeCourant ?"]} { return "" }
		set NewValue "New"
		continue
	    }
	}
    }
    if {$NewValue=="See"} {
	set NewValue ""
	if {[info exists CladeCourant]} { return [FaireLire $CladeCourant] }
	return [FaireLire "Current Clade is not yet set"]
    }
    if {$NewValue!=""} {
	set Value [Tax $NewValue "Name"]
	set CladeCourant $Value
	return [Tax $CladeCourant $Format]
    }
    if {[info exists CladeCourant]} { return [Tax $CladeCourant $Format] }
    if {[OnTraite "CilioCarta" "Like"]} {
	set CladeCourant [SelectClade "One" "UseQds"]
	if {$CladeCourant==""} { set CladeCourant "Fungi" }
    }
    return [CladeCourant "New"]
    return [CladeCourant $CladeCourant $Format]

}

proc CladesDistribution {{Method ""} {Criteria ""}} {


    if {$Criteria==""} { set Criteria "Rank" }
    if {$Method==""}   { set Method "Average" }
    
    set NomDeClaDistri [NomDe "ClaDistri"]

    foreach Clade [SelectClade "Multiple" "UseQds"] {
	set Cadre $Clade
	set MethCrit [TaxoBla $Cadre $Method $Criteria]
	if {$MethCrit==""} { continue }
	lappend LesCladeDuMethCrit($MethCrit) $Clade
	lappend LesMethCrit $MethCrit
	Espionne "$Clade $MethCrit"
    }
    set Sens "increasing"
    if {[regexp -nocase "Score" $Criteria]} { set Sens "decreasing" }
    set LesMethCrit [lsort -integer -$Sens [set LesMethCrit]]
    set LesCladesTries {}
    foreach MCrit $LesMethCrit {
Espionne "MCrit $MCrit"
	foreach Clade [set LesCladeDuMethCrit($MCrit)] {
	    set Cadre $Clade
	    if { ! [info exists DejaVu($Clade)]} {set DejaVu($Clade) 1 ; lappend LesCladesTries $Clade }
	    set MethCrit [TaxoBla $Cadre $Method $Criteria]
	    Espionne [format "%-18s %6d" $Clade $MethCrit]
	    foreach Crits [RankSample "ListOfList" $Criteria] {
Espionne "$Crits"
		set CritZone "[lindex $Crits 0]-[lindex $Crits end]"
		if { ! [info exists DejaVu($CritZone)]} { set DejaVu($CritZone) 1; lappend LesCritZones $CritZone }
		set LesZonards {}
		foreach Crit $Crits {
		    set ZonardsDuCrit [TaxoBla $Cadre ${Method}$Criteria-$Crit ListOfNom]
		    if {$ZonardsDuCrit!=""} { LConcat LesZonards $ZonardsDuCrit }
		}
		set NbZonards [llength $LesZonards]
		MemoZonards $NomDeClaDistri $Clade-$CritZone $LesZonards set 
	    }
	}
    }
    MemoZonards $NomDeClaDistri "" "" unique
    set I 0
    foreach Clade $LesCladesTries {
	set J 0
	foreach CritZone $LesCritZones {
	    set N [llength [MemoZonards $NomDeClaDistri $Clade-$CritZone]]
	    set T($I,$J) $N
	    incr J
	}
	incr I
    }
    set LeT [array get T]
    set K [Medals $LesCladesTries $LeT $LesCritZones "" "zonard" $NomDeClaDistri]
    regsub ".canvas" $K "" w
    set Titre "CladesDistribution $Method $Criteria"
    wm title    $w $Titre
    wm iconname $w $Titre
    set B [BoutonneLaFenetre $w "Clades Rank Distribution Average/ First"]
    bind $B <1> "CladesDistribution Average"
    bind $B <2> "CladesDistribution First"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "Clades Score Distribution Average/ First"]
    bind <1> "CladesDistribution Average Score"
    bind $B <2> "CladesDistribution First Score"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "Clades Expect Distribution Average/ First"]
    bind $B <1> "CladesDistribution Average LogExp"
    bind $B <2> "CladesDistribution First LogExp"
    $B configure -background "Magenta"
    return $K

}

proc ClassFromIdSvg {{Source ""} {Destin ""} {LesIdAClasser ""} {LesIdAGarder ""}} {

    #rR Extrats all id='a b c d' and if one appears in more than 1 element it become class='b"
    #rR If more than 1 remains in id in an element, the first one becomes id and all other become class
    if {$Destin==""} { set Destin "GetText" }
    if {[regexp " " $Source]} {
	set Texte $Source
    } elseif {[file exists $Source]} { 
	set Texte [ContenuDuFichier $Source]
    } else {
	set Texte [ContenuDuFichier $Source] ; #rR a completer
    }
    foreach IdAClasser $LesIdAClasser {
	set AClasser($IdAClasser) 1
    }
    foreach IdAGarder $LesIdAGarder {
	set AGarder($IdAGarder) 1
    }
    set LesTagsVus {}
    set iReste 0
    while {[set iCourant [string first " id='" $Texte $iReste]]>0} {
	if { ! [regexp {^ id='([^']+)'} [string range $Texte $iCourant end] Match Tags]} { set iReste [expr $iCourant + 1] ; continue }
	regsub -all {[ \n\t]+} $Tags " " Tags
	set LesTags [split [string trim $Tags " "]]
	foreach Tag $LesTags {
	    incr NbUse($Tag)
	    lappend LesTagsVus $Tag
	}
	set iReste [expr $iCourant + 1]
    }

    set LesTagsVus [lsort -unique $LesTagsVus]
    foreach Tag $LesTagsVus {
	if {$NbUse($Tag)==1 || [info exists AGarder($Tag)]} { continue }
	lappend LesIdAClasser $Tag
	set AClasser($Tag) 1
    }

    set iReste 0
    while {[set iCourant [string first " id='" $Texte $iReste]]>0} {
	if { ! [regexp {^ id='([^']+)'} [string range $Texte $iCourant end] Match Tags]} { set iReste [expr $iCourant + 1] ; continue }
	regsub -all {[ \n\t]+} $Tags " " Tags
	set LesTags [split [string trim $Tags " "]]
	set LesId {}
	set LesCl {}
	set FousToutEnClasse 0
	foreach Tag $LesTags {
	    if {[info exists AClasser($Tag)]} {
		lappend LesCl $Tag
	    } else {
		lappend LesId $Tag
		set FousToutEnClasse 1
	    }
	}
	set Ids [join $LesId " "]
	set Cls [join $LesCl " "]
	set TextIdCl ""
	if {$Ids!=""} { append TextIdCl " id='$Ids'" }
	if {$Cls!=""} { append TextIdCl " class='$Cls'" }
	set D $iCourant
	set F [expr $iCourant + [string length $Match] - 1]
	set Texte [string replace $Texte $D $F $TextIdCl]
	set iReste $F 
    }
    if {$Destin=="GetText"} { return $Texte }
    return [Sauve $Texte dans $Destin]

}

proc ClasseAllAccess {} {

    set FichierSw "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Sw_Vertebrata"
    set FichierTr "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Tr_Vertebrata"
    set FichierVa "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Varsplic/varsplic_Vertebrata"
    set FichierRn "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata"
    set FichierRr "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata"
    set FichierEn "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/Ensembl_Vertebrata"
    set ListeFichier [list $FichierSw $FichierTr $FichierVa $FichierRn $FichierRr $FichierEn]
    foreach Fichier $ListeFichier {
	Espionne "$Fichier"
	foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" ForceAccessFirst] {
	    #ForceAccessFirst pour que 'Access' soit en fait l'ID place en 1ere position juste apres le chevron (ex SW:DCUP_DANRE)
	    set TFA [LaSequenceDuTFAs $Fichier $Access]
	    set Seq [string toupper [QueLaSequenceDuTexteTFA $TFA]]
	    set LesLignes [split $TFA "\n"]
	    set LigneTete [lindex $LesLignes 0]
	    if {[regexp "Sw_Vertebrata" $Fichier] || [regexp "Tr_Vertebrata" $Fichier] || [regexp "varsplic_Vertebrata" $Fichier] || [regexp "refseq" $Fichier]} {
		set Orga [string trim [StringSuivant "OS=" dans $LigneTete]]
		if {[regexp "GN=" $Orga]} {
		    set index [string first "GN=" $Orga]
		    set Orga [string range $Orga 0 [expr $index-1]]
		}
	    }
	    if {[regexp "Ensembl_Vertebrata" $Fichier]} {
		set index [string last "P" $Access]
		set Ens [string range $Access 0 [expr $index-1]]
		set Orga [InterrogeCorresEnsEtOS $Ens OS]
	    }
	    set Orga [string trim $Orga]

	    set LigneVoulu [lindex $LesLignes 1]
	    set LigneVoulu [string toupper [string range $LigneVoulu 0 49]]
	    
	    set LigneFinal "$Orga $LigneVoulu Access:$Access"
	    lappend LesLignesFinales $LigneFinal
	}
    }
    set LesLignesFinales [lsort $LesLignesFinales]
    SauveLesLignes $LesLignesFinales dans "/genomics/link/SpliRetMouse/database/TousLesAccess"

}

proc ClasseCanonique {OC} {

    set OrigOC $OC
    regsub -all "ARCHAEBACTERIA;" $OC "ARCHAEA;" OC
    regsub -all "BACILLACEAE;" $OC "BACILLUS/STAPHYLOCOCCUS GROUP;" OC
    regsub "; PTERYGOTA; LEPIDOPTERA;" $OC "; PTERYGOTA; NEOPTERA; ENDOPTERYGOTA; LEPIDOPTERA;" OC
    regsub "; PTERYGOTA; DIPTERA;" $OC "; PTERYGOTA; NEOPTERA; ENDOPTERYGOTA; DIPTERA;" OC
    regsub "; PTERYGOTA; COLEOPTERA;" $OC "; PTERYGOTA; NEOPTERA; ENDOPTERYGOTA; COLEOPTERA;" OC
    return "$OC"

}

proc ClasseFonctionnelle {Nom} {

    global SourceClasseFonctionnelle
    global RepertoireDuGenome

    if {[info exists SourceClasseFonctionnelle]} {
	return [ClasseFonctionnelleDans$SourceClasseFonctionnelle $Nom]
    }

    set FichierFonctionsValidees "$RepertoireDuGenome/fiches/fonctionsvalidees"
    if {[regexp "casimir" $RepertoireDuGenome] || ! [file exists $FichierFonctionsValidees]} {
	set SourceClasseFonctionnelle "Info"
    } else {
	set SourceClasseFonctionnelle [ChoixParmiJoli {"Info" "FonctionsValidees"} {}  {"Functional classes in Info files" "Functional classes in FonctionsValidees"}]
    }
    return [ClasseFonctionnelle $Nom]

}

proc ClasseFonctionnelleDansFonctionsValidees {Nom} {

    global ClasseFonctionnelle
    global RepertoireDuGenome

    if {[info exists ClasseFonctionnelle($Nom)]} { return [set ClasseFonctionnelle($Nom)] }
    if {[info exists ClasseFonctionnelle("EstCharge")]} {
	if {[regexp "TROU" $Nom]} { return 200 }
	return 153
    }

    set ClasseFonctionnelle("EstCharge") 1

    set FichierFonctionsValidees "$RepertoireDuGenome/fiches/fonctionsvalidees"
    if {[file exists $FichierFonctionsValidees]} {
	foreach Ligne [LesLignesDuFichier $FichierFonctionsValidees] {
	    if { ! [regexp {^[A-Z]} $Ligne]} { continue }
	    scan $Ligne "%s %s %s" PAB FF CF
	    set PABY $PAB
	    if {[regexp {PAB[0-9]+} $PAB]} { regsub PAB $PAB [PreFixe] PABY }
	    Espionne "set ClasseFonctionnelle($PABY) $CF"
	    set ClasseFonctionnelle($PABY) $CF
	}
    }
    return [ClasseFonctionnelleDansFonctionsValidees $Nom]

}

proc ClasseFonctionnelleDansInfo {Nom} {


    if {[regexp "TROU" $Nom]} { return 200 }

    set ValiCF [ExtraitInfo $Nom "ValiCF"]

    set CF 00
    if {[regexp "unknown" $ValiCF]} { set ValiCF 153 }
    scan $ValiCF "%d" CF

    return [format "%3.3d" $CF]

}

proc ClasseLesAccessAvecOntology {} {

    
    Wup "Permet de classer les Acc retenus par MesAccessInterressants en fonction de leur Ontology"
    Wup "4 classes - Actin Intermediaire Microtubule et Autre"

    global MesAccessInterressants
    
    MesAccessInterressants

    set FichierSave "[RepertoireDuGenome]/DeJean/LesAccess.log"
    
    set LesAccess [array names MesAccessInterressants]
  
    set GOCytoActin    "GO:0015629"
    set GOCytoInter    "GO:0045111"
    set GOCytoMicro    "GO:0015630"
    set GOActinBinding "GO:0003779"
    
    #set LesGOActin [join [LesRequetesDuGOEtDesDescendants $GOCytoActin] " "]
    #set LesGOInter [join [LesRequetesDuGOEtDesDescendants $GOCytoInter] " "]
    #set LesGOMicro [join [LesRequetesDuGOEtDesDescendants $GOCytoMicro] " "]

    set LesGOActin ""
    foreach Requete [LesRequetesDuGOEtDesDescendants $GOCytoActin] {
	set Requete [lindex $Requete 1]
	
	if {[regexp -nocase "^go:" $Requete]} {
	    lappend LesGOActin [string toupper $Requete]
	    continue
	}
	foreach GO [Interroge2GO $Requete] {
	    lappend LesGOActin [string toupper $GO]
	}
    }
    set LesGOActin [lsort -unique $LesGOActin]

    foreach Requete [LesRequetesDuGOEtDesDescendants $GOActinBinding] {
	set Requete [lindex $Requete 1]
	
	if {[regexp -nocase "^go:" $Requete]} {
	    lappend LesGOActin [string toupper $Requete]
	    continue
	}
	foreach GO [Interroge2GO $Requete] {
	    lappend LesGOActin [string toupper $GO]
	}
    }
    set LesGOActin [lsort -unique $LesGOActin]

    set LesGOInter ""
    foreach Requete [LesRequetesDuGOEtDesDescendants $GOCytoInter] {
	set Requete [lindex $Requete 1]
	
	if {[regexp -nocase "^go:" $Requete]} {
	    lappend LesGOInter [string toupper $Requete]
	    continue
	}
	foreach GO [Interroge2GO $Requete] {
	    lappend LesGOInter [string toupper $GO]
	}
    }
    set LesGOInter [lsort -unique $LesGOInter]

    set LesGOMicro ""
    foreach Requete [LesRequetesDuGOEtDesDescendants $GOCytoMicro] {
	set Requete [lindex $Requete 1]
	
	if {[regexp -nocase "^go:" $Requete]} {
	    lappend LesGOMicro [string toupper $Requete]
	    continue
	}
	foreach GO [Interroge2GO $Requete] {
	    lappend LesGOMicro [string toupper $GO]
	}
    }
    set LesGOMicro [lsort -unique $LesGOMicro]

    AppendAuFichier $FichierSave "GOACTIN $LesGOActin"
    AppendAuFichier $FichierSave "GOINTER $LesGOInter"
    AppendAuFichier $FichierSave "GOMICRO $LesGOMicro"

    set LesAccessActin ""
    set LesAccessInter ""
    set LesAccessMicro ""
    set Autre          ""
    
    #set i 0
    foreach Acc $LesAccess {
	#incr i
	#if {$i==5} {break}
	set LesGOsDeBId [Access2GO $Acc]
	#set LesGOsDeBId [Access2Requetes $Acc]
	set OnLaCatalogue 0
	
	#Espionne "$Acc"
	#Espionne "$LesGOsDeBId"
	foreach GO $LesGOsDeBId {
	    #GO:0005200 du cytosquelette en general
	    if {$GO=="GO:0005200"}          {continue}
	    #Espionne $GO
	    if {[regexp "$GO" $LesGOActin]} {lappend LesAccessActin $Acc;set OnLaCatalogue 1;break}
	    if {[regexp "$GO" $LesGOInter]} {lappend LesAccessInter $Acc;set OnLaCatalogue 1;break}
	    if {[regexp "$GO" $LesGOMicro]} {lappend LesAccessMicro $Acc;set OnLaCatalogue 1;break}
	}
	if {$OnLaCatalogue} {continue} else {lappend Autre $Acc}
	continue
    }
    AppendAuFichier $FichierSave "Actin [llength $LesAccessActin] >>>$LesAccessActin"
    AppendAuFichier $FichierSave "Inter [llength $LesAccessInter] >>>$LesAccessInter"
    AppendAuFichier $FichierSave "Micro [llength $LesAccessMicro] >>>$LesAccessMicro"
    AppendAuFichier $FichierSave "Autre [llength $Autre] >>>$Autre"
     
    set FichierSave "[RepertoireDuGenome]/DeJean/LesActin"
    AppendAuFichier $FichierSave "Actin:"
    foreach Acc $LesAccessActin {
	AppendAuFichier $FichierSave "$Acc\t[join [lrange [DefDeAcc $Acc protein Def] 1 end] " "]"
    }
    
    set FichierSave "[RepertoireDuGenome]/DeJean/LesInter"
    AppendAuFichier $FichierSave "Inter:"
    foreach Acc $LesAccessInter {
	AppendAuFichier $FichierSave "$Acc\t[join [lrange [DefDeAcc $Acc protein Def] 1 end] " "]"
	#AppendAuFichier $FichierSave "$Acc [DefDeAcc $Acc protein AccDef]"
    }

    set FichierSave "[RepertoireDuGenome]/DeJean/LesMicro"
    AppendAuFichier $FichierSave "Micro:"
    foreach Acc $LesAccessMicro {
	AppendAuFichier $FichierSave "$Acc\t[join [lrange [DefDeAcc $Acc protein Def] 1 end] " "]"
	#AppendAuFichier $FichierSave "$Acc [DefDeAcc $Acc protein AccDef]"
    }

    set FichierSave "[RepertoireDuGenome]/DeJean/LesAutre"
    AppendAuFichier $FichierSave "Autre:"
    foreach Acc $Autre {
	AppendAuFichier $FichierSave "$Acc\t[join [lrange [DefDeAcc $Acc protein Def] 1 end] " "]"
	#AppendAuFichier $FichierSave "$Acc [DefDeAcc $Acc protein AccDef]"
    }
        

}

proc ClasseNormalisee {Texte} {

    set ListeDesMots [split $Texte ";"]
    if { [llength $ListeDesMots] == 0 } { set Retour $Texte }
    if { [llength $ListeDesMots]  > 0 } { set Retour [lindex $ListeDesMots 0] }
    return [string trim $Retour "\."]

}

proc ClasseParOrdreAlphabLeFichier {Fichier} {

    if {![file exists $Fichier]} {return ""}

    set LesLignes [lsort -dictionary [LesLignesDuFichier $Fichier]]
    set NouveauContenu [join $LesLignes "\n"]
    Espionne $NouveauContenu
    if {[OuiOuNon "Voulez vous sauvez ces lignes\?"]} {
	set NewFile [SauveLeFichierSous $Fichier]
	Sauve $NouveauContenu dans $Fichier
    }
    return "$NouveauContenu"

}

proc ClasseSizeOfClusters {} {

    set File "[RepertoireDuGenome]/SizeOfClusters"
    set LesLignes [LesLignesDuFichier $File]
    set LesLignes [lsort -index 1 -decreasing $LesLignes]
    SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/SizeOfClustersClasse"

}

proc Classement {Fichier} {

    set GOTotalTheorique [GOTotalTheorique $Fichier 0]
    set GOtheoriqueDansBanque [GOTotalTheorique $Fichier 1]
    set LesResultats {}
    foreach GO [LesGOsDuFichierXML $Fichier] {
	set LaDefinition [lindex [Onto process $GO LesDefinitions] 0]
	if {$LaDefinition=={}} {set LaDefinition "NoProcess"}
	set GOTotalObserve [GOTotalObserve $Fichier $GO 0]
	set Rapport [format "%.3f" [expr ($GOTotalObserve./$GOTotalTheorique.)]]
	set GOobserveDansBanque [GOTotalObserve $Fichier $GO 1]
	#Espionne $GOobserveDansBanque
	if {$GOobserveDansBanque==0} {
	    #Espionne "calcul de biais pas possible"
	    lappend LesResultats "$GO 0 $LaDefinition"
	    continue
	}
	set RapportBanque [format "%.15f" [expr ($GOobserveDansBanque./$GOtheoriqueDansBanque.)]]
	#Espionne $RapportBanque
	set BiaisGO [format "%.5f" [expr $Rapport/$RapportBanque]]
	lappend LesResultats "$GO $BiaisGO $LaDefinition"
    }
    set LeClassement [lsort -real -decreasing -index 1 $LesResultats]
    return $LeClassement

}

proc ClassementGlobal {Fichier} {

    if {![file exists $Fichier]} {return ""}
    set LesMeilleurs {}
    set LesResultats {}
    #fichier liste
    set Contenu [ContenuDuFichier $Fichier]
    regsub -all "\}" $Contenu "\n" Contenu
    regsub -all "\{" $Contenu "" Contenu
    #Espionne $Contenu
    foreach Ligne [split $Contenu "\n"] {
	#Espionne $Ligne
	scan $Ligne "%s %f" go n
	lappend LesMeilleurs $go
	if {[info exists DejaVu($go)]} {set N($go) [expr $n + $N($go)]}
	set DejaVu($go) 1
	set N($go) $n
	regsub "$go" $Ligne "" Ligne
	regsub "$n" $Ligne "" Ligne
	set D($go) $Ligne
    }
    foreach GO $LesMeilleurs {
	#Espionne $GO
	#Espionne $N($GO)
	lappend LesResultats "$GO $N($GO) $D($GO)"
    }
    set LeClassementFinal [lsort -real -decreasing -index 1 $LesResultats]
    return $LeClassementFinal

}

proc ClassementParArea1e6DesBiais {{NSeqMin 6}} {

    # Genes/chromosome
    set FichierDistributionDesGenesParChro "[HumanGenomeDir]/Localisation/Gene_chr_Distribution"
    if {![file exists $FichierDistributionDesGenesParChro]} {
	FaireLire "[HumanGenomeDir]/Localisation/Gene_chr_Distribution does not exist"
	return ""
    }
    # Genes/area
    set FichierDistributionDesGenesParArea "[HumanGenomeDir]/Localisation/Gene_area1e6bp_Distribution"
    if {![file exists $FichierDistributionDesGenesParArea]} {
	FaireLire "[HumanGenomeDir]/Localisation/Gene_area1e6bp_Distribution does not exist"
	return ""
    }

    # Sequences/chromosome
    set FichierDistributionDesSequencesParChro "[RepertoireDuGenome]/Localisation/chr_Distribution"
    if {![file exists $FichierDistributionDesSequencesParChro]} {
	if {[OuiOuNon "[RepertoireDuGenome]/Localisation/chr_Distribution does not exist.\nDo you want I create it?"]} {DistributionDesSequencesSurLesChromosomes} else {return ""} 
    }

    # Sequences/area1e6
    set FichierDistributionDesSequencesParArea "[RepertoireDuGenome]/Localisation/area1e6bp_Distribution"
    if {![file exists $FichierDistributionDesSequencesParArea]} {
	if {[OuiOuNon "[RepertoireDuGenome]/Localisation/area1e6bp_Distribution doesn't exist.\ndo you want I create it?"]} {
	    DistributionDesSequencesSurLesRegions 1e6
	}
    }
    
    foreach Ligne [LesLignesDuFichier $FichierDistributionDesSequencesParChro] {
	set PremierElement [lindex $Ligne 0]
	if {$PremierElement=="Chromosome" ||  $PremierElement=="Remaining" ||  $PremierElement=="Total"} {continue}
	scan $Ligne "%s %d %d" chro long nbseq
	set NbSeq($chro) $nbseq
    }

    foreach Ligne [LesLignesDuFichier $FichierDistributionDesGenesParChro] {
	set PremierElement [lindex $Ligne 0]
	if {$PremierElement=="Chromosome" ||  $PremierElement=="Remaining" ||  $PremierElement=="Total"} {continue}
	scan $Ligne "%s %d %d" chro long nbgen
	set NbGenes($chro) $nbgen
    }

    set chro "1"
    Espionne $NbGenes($chro)
    FaireLire ok
    
    set LesArea {}
    set LesNbSeq {}
    set LesChro {}
    foreach Ligne [LesLignesDuFichier $FichierDistributionDesSequencesParArea] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="Var"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend LesAreas "$Elt"} 
		}
	    }
	}
	if {$var=="NbSeq"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {
			lappend LesNbSeq "$Elt"
			lappend LesChro "$chro"
		    } 
		}
	    }
	}
    }
    
    set LesNbGenes {}
    foreach Ligne [LesLignesDuFichier $FichierDistributionDesGenesParArea] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="NbGenes"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend LesNbGenes "$Elt"} 
		}
	    }
	}
    }

    set ListeTotale {}
    foreach Chro $LesChro Zone $LesAreas Nseq $LesNbSeq Ngene $LesNbGenes {
	if {$Ngene!=0 && $Nseq!=0} {
	    if {$Nseq!=""} {
	    set BiaisArea [expr round((100*$Nseq* ($NbGenes($Chro)))/(($NbSeq($Chro))*$Ngene))]
	    lappend ListeTotale "$Chro $Zone $Nseq $Ngene $BiaisArea" 
	    }
	} 
    }
    set ListeTrieeEnFonctionDuBiais [lsort -decreasing -integer -index 4 $ListeTotale]
    set Final [format "%7s %-10s %-5s %-5s %-5s\n" Chromo Area1e6 NSeq NGene Skew]
    foreach Elt $ListeTrieeEnFonctionDuBiais {
	scan $Elt "%s %s %s %s %s" chr area nseq ngene biais 
	if {$nseq>=$NSeqMin} {
	    append Final [format "%7s %-10s %-5s %-5s %-5s\n" $chr $area $nseq $ngene $biais]
	}
    }
    set RepClassements "[RepertoireDuGenome]/Classements/"
    if {![file exists $RepClassements]} {File mkdir $RepClassements}
    if {[OuiOuNon "Do you want to save in [RepertoireDuGenome]/Classements/Biais_Area1e6_nseqmin$NSeqMin?"]} {
	Sauve $Final dans "[RepertoireDuGenome]/Classements/Biais_Area1e6_nseqmin$NSeqMin"
    } else {return $Final}    

}

proc ClassementParAreaDesNseq {Area} {

    if {$Area=="1e7"} {
	set Fichier "[GscopeDatabaseDir DDetAffy]/Localisation/area1e7bp_Distribution"
    }
    if {$Area=="1e6"} {
	set Fichier "[GscopeDatabaseDir DDetAffy]/Localisation/area1e6bp_Distribution"
    }
    set ListeArea {}
    set ListeNbSeq {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="Var"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeArea "$Elt"} 
		}
	    }
	}
	if {$var=="NbSeq"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeNbSeq "$chro $Elt"} 
		}
	    }
	}
    }
    set ListeTotale {}
    foreach Zone $ListeArea ChroNseq $ListeNbSeq {
	lappend ListeTotale "$Zone $ChroNseq" 
    }
    set ListeTriee [lsort -decreasing -integer -index 2 $ListeTotale]
    if {$Area=="1e7"} {
	set Final [format "%-5s %-10s %-5s\n" Chro Area1e7bp NSeq]
    }
    if {$Area=="1e6"} {
	set Final [format "%-5s %-10s %-5s\n" Chro Area1e6bp NSeq]
    }
    foreach Elt $ListeTriee {
	scan $Elt "%s %s %s" area chro nseq
	if {$nseq!=0} {append Final [format "%-5s %-10s %-5s\n" $chro $area $nseq]}
    }
    #Espionne $Final
    if {$Area=="1e7"} {
	Sauve $Final dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqParArea1e7"
    }
    if {$Area=="1e6"} {
	Sauve $Final dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqParArea1e6"
    }

}

proc ClassementParAreaDesNseqPourTous {Area} {

    global RepertoireDuGenome
    if {$Area=="1e7"} {
	set Fichier "$RepertoireDuGenome/Localisation/area1e7bp_Distribution"
    } elseif {$Area=="1e6"} {
	set Fichier "$RepertoireDuGenome/Localisation/area1e6bp_Distribution"
    } else {return "argument forgotten"}
    set ListeArea {}
    set ListeNbSeq {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="Var"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeArea "$Elt"} 
		}
	    }
	}
	if {$var=="NbSeq"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeNbSeq "$chro $Elt"} 
		}
	    }
	}
    }
    set ListeTotale {}
    foreach Zone $ListeArea ChroNseq $ListeNbSeq {
	lappend ListeTotale "$Zone $ChroNseq" 
    }
    set ListeTriee [lsort -decreasing -integer -index 2 $ListeTotale]
    if {$Area=="1e7"} {
	set Final [format "%-5s %-10s %-5s\n" Chro Area1e7bp NSeq]
    }
    if {$Area=="1e6"} {
	set Final [format "%-5s %-10s %-5s\n" Chro Area1e6bp NSeq]
    }
    foreach Elt $ListeTriee {
	scan $Elt "%s %s %s" area chro nseq
	if {$nseq!=0} {append Final [format "%-5s %-10s %-5s\n" $chro $area $nseq]}
    }
    #Espionne $Final
    if {$Area=="1e7"} {
	Sauve $Final dans "$RepertoireDuGenome/Classements/NbSeqParArea1e7"
    }
    if {$Area=="1e6"} {
	Sauve $Final dans "$RepertoireDuGenome/Classements/NbSeqParArea1e6"
    }

}

proc ClassementParBandeDesNseq {} {

    set Fichier "[GscopeDatabaseDir DDetAffy]/Localisation/cyto_Distribution"
    set ListeBande {}
    set ListeNbSeq {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="Var"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeBande "$Elt"} 
		}
	    }
	}
	if {$var=="NbSeq"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeNbSeq "$Elt"} 
		}
	    }
	}
    }
    set ListeTotale {}
    foreach Band $ListeBande Nseq $ListeNbSeq {
	lappend ListeTotale "$Band $Nseq" 
    }
    set ListeTriee [lsort -decreasing -integer -index 1 $ListeTotale]
    set Final [format "%-12s %-5s\n" Band NbSeq]
    foreach Elt $ListeTriee {
	scan $Elt "%s %s" band n
	if {$n!=0} {append Final [format "%-12s %-5s\n" $band $n]}
    }
    Sauve $Final dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqParBand"

}

proc ClassementParBandeDesNseqPlusBiais {} {

    set Fichier "[GscopeDatabaseDir DDetAffy]/Localisation/cyto_Distribution"
    set NbGenesTotal 0
    set NbSeqTotal 0
    foreach Ligne [LesLignesDuFichier "[GscopeDatabaseDir DDetAffy]/Localisation/chr_Distribution"] {
	scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3
	if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue}
	set NbSeqTotal [expr [expr $seq1+$seq2+$seq3+$seq4]+$NbSeqTotal]
	set NbGenesTotal [expr [expr $gene1+$gene2+$gene3]+$NbGenesTotal]
    }
    #Espionne $NbSeqTotal
    #Espionne $NbGenesTotal
    set ListeBande {}
    set ListeNbSeq {}
    set ListeNbGenes {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s" chro long type var 
	set n 0
	if {$var=="Var"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeBande "$Elt"} 
		}
	    }
	}
	if {$var=="NbSeq"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeNbSeq "$Elt"} 
		}
	    }
	}
	if {$var=="NbGenes"} {
	    foreach Elt $Ligne {
		if {$Elt!=" "} {
		    incr n
		    if {$n>4} {lappend ListeNbGenes "$Elt"} 
		}
	    }
	}
    }
    set ListeTotale {}
    foreach Band $ListeBande Nseq $ListeNbSeq Ngene $ListeNbGenes {
	if {$Ngene!=0} {
	    set BiaisBande [expr round((100*$Nseq*$NbGenesTotal)/($NbSeqTotal*$Ngene))]
	}
	set Somme [expr $BiaisBande+$Nseq]
	lappend ListeTotale "$Band $Nseq $Ngene $BiaisBande $Somme" 
    }
    set ListeTriee [lsort -decreasing -integer -index 4 $ListeTotale]
    set Final [format "%-12s %-5s %-5s %-5s %-5s %-10s\n" Band NSeq NGene Biais Somme Expr]
    foreach Elt $ListeTriee {
	scan $Elt "%s %s %s %s %s" band nseq ngene biais somme 
	set Expr [ProfilDExpressionPourUneBande $band]
	append Final [format "%-12s %-5s %-5s %-5s %-5s %-10s\n" $band $nseq $ngene $biais $somme $Expr]
    }
    #Espionne $Final
    Sauve $Final dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqPlusBiaisParBande"

}

proc ClassementParChromoDesNseqPlusBiais {} {

    set Fichier "[GscopeDatabaseDir DDetAffy]/Localisation/chr_Distribution"
    set ListeClassee {}
    set NbSeqTotal 0
    set NbGenesTotal 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3
	if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue}
	set NbSeqTotal [expr [expr $seq1+$seq2+$seq3+$seq4]+$NbSeqTotal]
	set NbGenesTotal [expr [expr $gene1+$gene2+$gene3]+$NbGenesTotal]
    }
    #Espionne $NbSeqTotal
    #Espionne $NbGenesTotal
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3
	if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue}
	set NseqChro [expr $seq1+$seq2+$seq3+$seq4]
	set NgenesChro [expr $gene1+$gene2+$gene3]
	set BiaisChromo [expr round((100*$NseqChro*$NbGenesTotal)/($NbSeqTotal*$NgenesChro))]
	#Espionne "$chro:$BiaisChromo"
	set Somme [expr $NseqChro+$BiaisChromo]
	lappend ListeClassee "$chro\t$NseqChro\t$BiaisChromo\t$Somme"
    }
    set ListeClassee [lsort -decreasing -index 3 -integer $ListeClassee]
    #set ListeClassee [lrange $ListeClassee 0 2]
    set ListeClassee [join $ListeClassee "\n"]
    set Titres "Chromo  NSeq  Skew  Skew+Nseq\n"
    set Classement "$Titres$ListeClassee"
    Sauve $Classement dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqPlusBiaisParChromo"

}

proc ClassifyWithNbInteract {ParserFile WithAllOrMy {NbGroup ""}} {

    if {$NbGroup==""} {set NbGroup 5}
    set BornesDesGroupes(5)  {1 5 10 30 100}
    #set BornesDesGroupes(10) {1 5 10 25 50 100 200 300 400 500}
    set Bornes $BornesDesGroupes($NbGroup)
    set Reverse [lreverse $Bornes]
    
    set Directory [file dirname $ParserFile]
    set SummaryFile "${Directory}/Summary.txt"
    
    foreach IdString     [FromParser ListOf IdString $ParserFile] {
	set IdInitial    [FromSummary $IdString IdInitial $SummaryFile]
	set IdInitial    [join $IdInitial "_"]
	if {$WithAllOrMy =="All"} { set NbInteract [FromParser $IdString NbInteract $ParserFile] }	
	if {$WithAllOrMy =="My"}  { set NbInteract [FromParser $IdString MyNbInteract $ParserFile] }
	foreach Borne $Reverse {
	    if {$NbInteract >= $Borne} {
		set BonneBorne $Borne
		if {$BonneBorne == 100} { set Categorie 5}
		if {$BonneBorne == 30}  { set Categorie 4}
		if {$BonneBorne == 10}  { set Categorie 3}
		if {$BonneBorne == 5}   { set Categorie 2}
		if {$BonneBorne == 1}   { set Categorie 1}
		break
	    }
	}
	lappend LesLignes "$IdString $IdInitial $Categorie $NbInteract"
    }
    set LesLignes [lsort -index 2 -integer -decreasing $LesLignes]
    SauveLesLignes $LesLignes dans "${Directory}/ClassifyWith${WithAllOrMy}NbInteract"

}

proc Claudine {args} {


    set LBlast [LesLignesDuFichier [lindex $args 0]]
    set LPab87tfa [LesLignesDuFichier [lindex $args 1]]

    DecortiqueBlastGrid $LBlast 9999. 5000 Query lBanqueId lAccess lDE lProfil lPN "LongDescription"

    foreach s $lBanqueId p $lPN {
	if {$p > 5} {break}
	lappend LesElus $s
    }

    set o [open "pab87_pdb.lst" w]
    puts $o [join $LesElus "\n"]
    close $o

    set res {}
    catch {exec fastacmd -i pab87_pdb.lst -d pdb} Msg

    set ls [split $Msg "\n"]
    foreach l $ls {
	if {[string index $l 0] == ">"} {
	    set i [expr [string first "|" $l] + 1]
	    set l ">[string range $l $i end]"
	}
	lappend res $l
    }
    set letfa [join $res "\n"]
    set f [open "pab87_pdb.copains" w]
    foreach l $LPab87tfa {
	puts $f $l
    }
    puts $f $letfa
    close $f

    set NomATraiter "pab87_pdb"
    set In  "${NomATraiter}.copains"
    set Out "${NomATraiter}.out"
    set Log "${NomATraiter}.log"
    set Msf "${NomATraiter}.msf"

    set Commande "[ClustalwExe] "
    append Commande "-output=gscope"
    append Commande "-outfile=$Out -infile=$In"

    catch { eval exec $Commande} Message]

    exit


}

proc ClaudineArchaea {{Qui ""} {Quoi ""}} {

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

    set Fichier "/home/ripp/vrac/ClaudineArchaea.csv"
    LoadTxl $Fichier CA 0 ";" "" "WholeLine"

    set LesG {}
    set LesOX {}
    set LesOS {}
    foreach I $CA(ListOf,Index) {
	if { ! [regexp "^Go" $I]} { continue }
	lappend LesG $I
	set OX [GoldArchaea $I OX]
	set CA($I,OX) $OX
	if {$OX!=""} {
	    lappend LesOX $OX
	    lappend LesOS [Tax $OX Name]
	} 
    }
    set CA(ListOf,G) $LesG
    set CA(ListOf,OX) $LesOX
    set CA(ListOf,OS) $LesOS
    return [ClaudineArchaea $Qui $Quoi]

}

proc CleanDoc {} {


    set li [LesLignesDuFichier index.html]
    set deb 0
    foreach l $li {
	if {[regexp "" $l]} {break}
	if {! $deb && ! [regexp "" $l]}  {
	    continue
	} else {
	    set deb 1
	}
	if {[regexp "href=" $l]} {
	    set ib1 [string first ">" $l]
	    set ib2 [string first "<" [string range $l $ib1 end]]
	    set txt [string range $l [incr ib1] [expr $ib2 + $ib1 -2]]
	    lappend TText $txt

	    set ib1 [expr [string first "\"" $l] +1]
	    set ib2 [string first "\"" [string range $l $ib1 end]]
	    set file [string range $l $ib1 [expr $ib2+$ib1-1]]

	    lappend LFile $file
	}
    }

    foreach file $LFile {
	lappend TText [ExtraitDocDe $file]
    }

    set f [open "doc.txt" w]
    puts $f [join $TText "\n"]
    close $f

    exit

}

proc CleanFeaturesInMACS {{FichierIn ""} {FichierOut ""}} {

    
    Wup "Permet de virer les features d 1 alignement"
    Wup "Trop de features posent problemes a Clustalw pour les conversions"
    
    if {! [file exists $FichierIn]} {return ""}
    
    if {$FichierOut == ""} {
	set FichierOut "$FichierIn"
	set extension  ""
	if {[regexp -nocase {.[a-z]+$} $FichierOut extension]} {
	    regsub -nocase "$extension" $FichierOut "_propre${extension}" FichierOut
	} else {
	    set FichierOut "${FichierIn}_propre"
	}
    }
    if {[file exists $FichierOut]} {
	file delete -force $FichierOut
    }

    set F [open "$FichierIn"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {[regexp "^  FT   " $Ligne] || [regexp "^feature " $Ligne]} {continue}
	
	lappend LesLigne $Ligne
    }
    close $F

    AppendAuFichier $FichierOut [join $LesLigne "\n"]
    
    return "$FichierOut"

}

proc CleanFeaturesInMACS2 {{FichierIn ""} {FichierOut ""}} {

    
    Wup "Permet de virer les features d 1 alignement"
    Wup "Trop de features posent problemes a Clustalw pour les conversions"
    
    if {! [file exists $FichierIn]} {return ""}
    
    if {$FichierOut == ""} {
	set FichierOut "$FichierIn"
	set extension  ""
	if {[regexp -nocase {.[a-z]+$} $FichierOut extension]} {
	    regsub -nocase "$extension" $FichierOut "_propre${extension}" FichierOut
	} else {
	    set FichierOut "${FichierIn}_propre"
	}
    }
    if {[file exists $FichierOut]} {
	file delete -force $FichierOut
    }

    set F [open "$FichierIn"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {[regexp "^  FT   " $Ligne] || [regexp "^feature " $Ligne]} {continue}
	
	AppendAuFichier $FichierOut $Ligne
    }
    close $F

    
    return "$FichierOut"

}

proc CleanRosace {K Quoi} {

    global ParametresDuBoard

    if {$Quoi=="Textes"}    { set LesTags [list "Txt"] }
    if {$Quoi=="Aiguilles"} { set LesTags [list "Aiguille"] }
    if {$Quoi=="Zones"}     {
	set LesTags [list "Zone" "Etiquette"]
    }
    catch {unset ParametresDuBoard($K,IemeCouche)} 
    
    foreach Tag $LesTags {
	foreach Id [$K find withtag $Tag] {
	    $K delete $Id
	}
    }

}

proc CleanSpace {} {

    global RepertoireDuGenome
    foreach F [glob "$RepertoireDuGenome/cdna/*"] {
	regsub -all "'" $F "_" D
	regsub -all " " $D "" D
	regsub "/cdna/" $D "/newcdna/" D
	file copy $F $D
    }

}

proc CleanUpProteome {{minIdentity ""}} {

	if {$minIdentity==""} {set minIdentity 100}
	#Correction de la redondance
	puts "#########################################"
	puts "--Correction de la redondance--"
	puts "#########################################"
	puts "remarque: par defaut demande 100% d'identité"
	set prefixe [PreFixe]
	CorrectRedundancyOnGscope "blastp$prefixe" $minIdentity

}

proc Clean_ARPAnno {} {


    Wup "Permet de supprimer tous les fichiers resultats"

    set RepARP_Results  "[RepARPAnnoWeb]"
    set RepTFAResults   "$RepARP_Results"
    set RepBlastResults "$RepARP_Results"
    set RepMACSResults  "$RepARP_Results"

    foreach Dir [list $RepMACSResults $RepBlastResults $RepTFAResults] {
	set LesFichiers [glob -nocomplain -directory "$Dir" "*"]
	foreach F $LesFichiers {
	    if {[file exists $F]} {
		#Espionne "$F"
		file delete -force $F
	    }
	}
    }
    return ""

}

proc Cleanup {} {

    if { [info exists ::quadric] } {
        gluDeleteQuadric $::quadric
        unset ::quadric
    }
    if { [info exists ::ArcBall] } {
        tcl3dDeleteArcBall $::ArcBall
        unset ::ArcBall
    }

}

proc ClearDistances {} {

    set ::pgl(Dist2Show) [list]
    set ::pgl(TextDeDist) [list]
    $::pgl(wogl) postredisplay

    return

}

proc ClearIDs {} {

    foreach mold $::StrucAVoir {
	set nom [DonneIdDeAccessPDB $mold]

	$nom ClearPicked
    }
    DefineLabels2Show

    $::pgl(wogl) postredisplay

    return

}

proc ClearLesZones {K} {

    
    Wup "Efface les zones de design"

    global LigneZone

    set         LesIds ""
    set         LesIds [$K find withtag "Zonable"]
    foreach Id $LesIds {
	catch {$K delete $Id} 
    }
    if {[info exists LigneZone]} {unset LigneZone}
    return ""    

}

proc ClearPassePlat {} {

    NousAllonsAuBoulot [RepertoireDuGenome]
    set LesClear {}
    set Previous ""
    foreach PP [lsort -decreasing [glob -nocomplain PassePlat*]] {
	if { ! [regexp {^PassePlat_([^_]+)_([0-9]+)$} $PP Match Nom Date]} {
	    set Previous ""
	    continue
	}
	if {$Nom==$Previous} {
	    lappend LesClear $PP
	}
	set Previous $Nom
    }
    set LesClearAFaire [AfficheListe $LesClear "AvecRetour" "Do I clear these"]
    foreach PP $LesClearAFaire {
	file delete $PP
    }
    OnRevientDuBoulot
    return $LesClearAFaire

}

proc ClearPassePlatDansFiches {} {

    NousAllonsAuBoulot "[RepertoireDuGenome]/fiches"
    set LesClear {}
    set Previous ""
    foreach PP [lsort -decreasing [glob -nocomplain PassePlat*]] {
	if { ! [regexp {^PassePlat_([^_]+)_([0-9]+)$} $PP Match Nom Date]} {
	    set Previous ""
	    continue
	}
	if {$Nom==$Previous} {
	    lappend LesClear $PP
	}
	set Previous $Nom
    }
    set LesClearAFaire [AfficheListe $LesClear "AvecRetour" "Do I clear these"]
    foreach PP $LesClearAFaire {
	file delete $PP
    }
    OnRevientDuBoulot
    return $LesClearAFaire

}

proc ClearSelectionNoms {} {

    $::NomNomSeq tag remove InvNm 1.0 end
    set ::NomSeqSel {}
    update

    return

}

proc ClearSelectionNwOj {{Ls ""}} {

    set w $::NwOj(Can)
    if {$Ls == {}} { 
	$w itemconfig Selected -fill black
	$w dtag all Selected
	set ::NwOj(ListeIdSel) [list]
    } else {
	foreach e $Ls {
	    $w itemconfig $e -fill black
	    $w dtag $e Selected
	}
    }

    return

}

proc ClearSelectionSequences {} {

    #$::NomTextSeq tag delete InvS 1.0 end

    return

}

proc ClearSelections {} {

    ClearSelectionNoms
    # not needed with biotext
    #ClearSelectionSequences

    return

}

proc ClearSpy {} {

    global debug debsq debag

    set debug 0
    set debsq "s01"
    set debag ""
    
    .t tag remove Spy 1.0 end

    return

}

proc ClearVar {} {

    global VODep

    set Lv [info globals]
    foreach v $Lv {
	if {$v eq "VODep"} {continue}
	if {[lsearch $VODep $v] != -1} {continue}
	global $v
	if {[info exists $v]} {
	    unset $v
	}
	if {[eval array exists $v]} {
	    eval array unset $v
	    eval unset $v
	}	
    }

    foreach f [font names] {
	font delete $f
    }
    update

    return

}

proc ClickDansSeq {K X Y} {

    set Id [$K find withtag current]

    set LesTags [$K gettags $Id]
    if {[llength $LesTags]>2} { FaireLire [join $LesTags "\n"] ; return }

    set NomSeq [lindex $LesTags 1]
    AfficheFetch $NomSeq

}

proc ClientMailDef {} {

    global CMDef

    LesDefauts

    font create CMFont -family Helvetica -size 24
    font create CMFontBold -family Helvetica -size 24 -weight bold
    set CMDef(Background) "#993355"
    set CMDef(Tables) "
       - mail {
          . pk_mail P
          . pk_folder I
          . uid I mail id
          . sender V64
          . receipient T
          . subject V256
          . date I epoch date-time
          . attachment I
          . read I
          . answered I
      }
      - mailbox {
         . pk_mailbox P
         . name V64
         . address V64
         . username V64
         . password V64
         . usessl I
         . port I
      }
      - folder {
         . pk_folder P
         . pk_mailbox I
         . name V64
         . lastuid I
      }
      - clientvar {
         . var V32
         . key V32
         . val T
      }"

    return

}

proc ClonInventory {args} {

    global ClonCollection

    set Quoi [join $args ","]

    if {[info exists ClonCollection($Quoi)]} { return [set ClonCollection($Quoi)] }
    if {[info exists ClonCollection(EstCharge)]} { return "" }

#rR set ClonCollection(LesOligos) [InventaireDesFichiersClonage "PAY" "RetournerOligos"] 
#rR set ClonCollection(LesPPCR)   [InventaireDesFichiersClonage "PAY" "RetournerPPCR"] 
    set ClonCollection(LesOligos) [InventaireDesFichiersClonage "ProGS" "RetournerOligos"] 
    set ClonCollection(LesPPCR)   [InventaireDesFichiersClonage "ProGS" "RetournerPPCR"] 
    set ClonCollection(EstCharge) 1
    if {[info exists ClonCollection($Quoi)]} { return [set ClonCollection($Quoi)] }
    return ""

}

proc ClonInventoryAppend {args} {

    global ClonCollection
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    return [lappend ClonCollection($Quoi) $Valeur]

}

proc ClonInventoryExists {args} {

    global ClonCollection

    if {$args=={}} { return [info exists ClonCollection(EstCharge)]}

    set Quoi [join $args ","]
    return [info exists ClonCollection($Quoi)]

}

proc ClonInventorySet {args} {

    global ClonCollection
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    return [set ClonCollection($Quoi) $Valeur]

}

proc ClonInventoryUnset {args} {

    global ClonCollection
    set Quoi [join $args ","]
    catch {unset ClonCollection($Quoi)}

}

proc ClonePuzzleFit {{OrgaCible ""} {PrefixeCible ""} {Destin ""}} {

    #rR il faut etre dans l'ancien pour creer le nouveua
    #rR Cree un nouveau projet Gscope en copiant tous les fichiers en y changeant les noms
    if {$Destin==""} { set Destin "PFyeastTFIID" }
    set RepDestin $Destin
    if { ! [regexp "/" $RepDestin]} { set RepDestin "/genomics/link/$Destin" }

    if {$OrgaCible==""} { set OrgaCible "Saccharomyces cerevisiae" }
    if {$PrefixeCible==""} { set PrefixeCible "PUY" }

    if {[NotreOS]==$OrgaCible || [PreFixe]=="$PrefixeCible"} {
	FaireLire "Attention il ne faut pas etre dans le projet Cible !!!\n  [NotreOS] [PreFixe] ==> $OrgaCible $PrefixeCible"
	exit
    }

    set Prefixe [PreFixe]
    foreach Nom [ListeDesPABs] {
	set GN [ValiGN $Nom]
	set AC [ExtraitInfo $Nom "AC:"]
	set AcDuPuz($Nom) $AC 
	set FicTFAs [GscopeFile $Nom "tfasdescopains"]
	set LesHomo {}
	set Homo ""
	foreach Access [LaSequenceDuTFAs $FicTFAs "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FicTFAs $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    regsub "^>" $Entete "" Entete
	    set B "" ; set G "" ; set E ""
	    scan $Entete "%s %s %s %s" A B G E
	    if { ! [string equal -nocase $OrgaCible "$G $E"]} { continue }
	    lappend LesHomo $A
	}
	if {[llength $LesHomo]==0} { set Homo ""; FaireLire "No homologue for $Nom $GN $AC" }
	if {[llength $LesHomo]==1} { set Homo [lindex $LesHomo 0] }
	if {[llength $LesHomo]>=2} {
#	    FaireLire "More than 1 homologue for $Nom $GN $AC, please select the good one"
	    if {[OuiOuNonMemo "Do I always use the first access"]} {
		set Homo [lindex $LesHomo 0]
	    } else {
		set Homo [ChoixParmi $LesHomo]
	    }
	}
	if {$Homo==""} { continue }
	if {[info exists DejaVu($Homo)]} {
#	    FaireLire "Handling $Homo in $Nom $GN $AC \n I saw already $DejaVu($Homo)"
	    continue
	}
	regsub $Prefixe $Nom $PrefixeCible New
	set Message "$New $Homo $Nom $GN $AC"
	set EstBon($Nom) 1
	lappend LesBonsHomo $Message
	set DejaVu($Homo) $Message
	Espionne $Message
    }

    set LesNouvellesBornes {}
    foreach Ligne [LesLignesDuFichier "[Fiches]/bornesdespabs"] {
	scan $Ligne "%s" Nom
	if { ! [info exists EstBon($Nom)]} { continue }
	regsub $Prefixe $Ligne $PrefixeCible Borne
	lappend LesNouvellesBornes $Borne
    }
    file mkdir "$RepDestin/fiches"
    SauvePuzzleFit [join $LesNouvellesBornes "\n"] dans "$RepDestin/fiches/bornesdespabs"

    set Beton [ContenuDuFichier "[RepertoireDuGenome]/beton/miniconfig"]
    regsub "PrefixeDesORFs $Prefixe" $Beton "PrefixeDesORFs $PrefixeCible" Beton
    regsub {NotreOS [^\n]+} $Beton "NotreOS $OrgaCible" Beton
    set Classe [OCduOS $OrgaCible]
    regsub {NotreOC [^\n]+} $Beton "NotreOC $Classe" Beton
    file mkdir "$RepDestin/beton"
    SauvePuzzleFit $Beton dans "$RepDestin/beton/miniconfig"

    file mkdir "$RepDestin/prottfa"
    file mkdir "$RepDestin/protembl"
    file mkdir "$RepDestin/infos"
    file mkdir "$RepDestin/tfasdescopains"
    file mkdir "$RepDestin/msf"
    file mkdir "$RepDestin/msfleon"
    file mkdir "$RepDestin/macsimXml"
    file mkdir "$RepDestin/pdb"
    foreach Ligne $LesBonsHomo {
	Espionne $Ligne
	scan $Ligne "%s %s %s %s %s" New Homo Nom GNh ACh
	set FicProttfa  "$RepDestin/prottfa/$New"
	set FicProtEmbl "$RepDestin/protembl/$New"
	set FicInfo     "$RepDestin/infos/$New"
	set FicTFAs     "$RepDestin/tfasdescopains/$New"
	set FicMSF      "$RepDestin/msf/$New"
	set FicLEON     "$RepDestin/msfleon/$New"
	set FicMacsims  "$RepDestin/macsimXml/$New"
	set FicPDB      "$RepDestin/pdb/$New"
	set LeEmbl [LaSequenceDesBanques $Homo]
	set Embl [join $LeEmbl "\n"]
	SauvePuzzleFit $Embl dans $FicProtEmbl
	DecortiqueLesLignesEMBL $LeEmbl ID AC DE GN OS OC OX
	set DE [VraiDEDeLaLigneDE $DE]
	set Linfo {}
	lappend Linfo "Nom: $New"
	lappend Linfo "ID: $ID"
	lappend Linfo "AC: $AC"
	lappend Linfo "DE: $DE"
	lappend Linfo "OS: $OS"
	lappend Linfo "OC: $OC"
	lappend Linfo "OX: $OX"
	lappend Linfo "ValiGN: $GN"
	set Info [join $Linfo "\n"]
	SauvePuzzleFit $Info dans $FicInfo

	set Entete ">$New $OrgaCible $AC $DE"
	set TFA [SequenceFormatTFA [join $LeEmbl "\n"] $Entete "protembl"]
	SauvePuzzleFit $TFA dans $FicProttfa

	set TFAs [ContenuDuFichier [GscopeFile $Nom "tfasdescopains"]]
	regsub ">$Nom "  $TFAs ">$ACh " TFAs
	regsub ">$Homo " $TFAs ">$New " TFAs
	foreach Puz [ListeDesPABs] {
	    set A $AcDuPuz($Puz)
	    regsub -all "$Puz"  $TFAs "$A" TFAs
	}
	SauvePuzzleFit $TFAs dans $FicTFAs

                                          set FicMacSource [GscopeFile "$Nom.org.aj" "macsimXml"]
	if {[FileAbsent $FicMacSource]} { set FicMacSource [GscopeFile "$Nom.org"    "macsimXml"] }
	if {[FileAbsent $FicMacSource]} { set FicMacSource [GscopeFile "$Nom"        "macsimXml"] }
	set Mac [ContenuDuFichier $FicMacSource]
	regsub -all "$Nom"  $Mac "$ACh" Mac
	regsub -all "$Homo" $Mac "$New" Mac
	set RE "${New}_\[^<\]+"
	regsub -all $RE $Mac "$New" Mac
	foreach Puz [ListeDesPABs] {
	    set A $AcDuPuz($Puz)
	    regsub -all "$Puz"  $Mac "$A" Mac
	}
	SauvePuzzleFit $Mac dans $FicMacsims

	set SourcePDB [GscopeFile $Nom "pdb"]
	if {[file exists $SourcePDB]} { file copy $SourcePDB $FicPDB }
    }
    return $LesBonsHomo

}

proc Clos {Destination} {

    PosteEtClos $Destination "ClosCanal"

}

proc ClosCanalEtMontreBlaste {Canal Out} {

	close $Canal
	set Fenetre [AfficheFichier $Out "AvecGrapheAvecSegAlignementAvecAligneurs"]
    return
    if {[gets $Canal]} {
	return 1
    }
    gets $Canal Message
    set Texte "I got an error from batch blast with following message :\n$Message"
    set Fenetre [AfficheVariable $Texte "ErrorFromBlast"]
    return 0

}

proc ClosCanalEtMontreMSF {Aligneur Canal MSF Log} {

    global LaFenetreDesMSF

    close $Canal
    if { [info exists LaFenetreDesMSF($MSF)] } {
	Illumine $MSF [set LaFenetreDesMSF($MSF)]
    } else {
	set Fenetre [AfficheFichier $MSF "GrandeLargeurAvecEtudeMSF"]
	BoutonneLaFenetre $Fenetre "Log" "AfficheFichier $Log AvecRien"
    }

}

proc ClosExpoCourante {} {

    global ExpoCourante
    catch {unset ExpoCourante}

}

proc ClosGalerieCourante {} {

    global GalerieCourante
    global ExpoCourante
    global xPointDeRaccord yPointDeRaccord 

    catch {unset xPointDeRaccord}
    catch {unset yPointDeRaccord}
    catch {unset GalerieCourante}

}

proc ClosPierre {} {

    global CanalPierre NomDuFichierPierre
    if { [info exists CanalPierre] } {
	close $CanalPierre
	unset  CanalPierre
    }

}

proc ClosUniquement {Destination} {

    close $Destination

}

proc CloseFenetreDrawBlast {w} {

    if {$w == ""} {set w "."}
    AskBlast  unset
    destroy   $w
    AskOptionsDeDrawBlast unsetall
    if {[winfo children .] == ""} {exit}
    return

}

proc CloseProfileResults {} {

    global WProfile

    destroy [winfo toplevel $WProfile]

    return

}

proc CloseRasMol {} {


    global RasM
    global CanalR
    global RecuperationEffectuee
    global LiaisonCoupee

    IlFautVoir "quit"
    catch {close $CanalR}
    unset CanalR
    unset RasM
    catch {unset RecuperationEffectuee}
    catch {unset LiaisonCoupee}
    destroy .fcviewer

    trace remove variable ListeTypesDeFeatures write MetAJourFeaturesRasmol

    return

}

proc Cluspack {ListeOuTexteOuFichier {FichierSortie ""}} {

    #rR j'ail'impression que ce n'est pas pour un alignement ... mais pour un fichier de coordonnees.

    if {$FichierSortie==""} { set FichierSortie "GetGroupsAndMembers" }

    if {[regexp "\n" $ListeOuTexteOuFichier]} {
	set Liste [split $ListeOuTexteOuFichier "\n"]
    } elseif { ! [regexp " " $ListeOuTexteOuFichier]} {
	set Liste [LesLignesDuFichier $ListeOuTexteOuFichier]
    } else {
	set Liste $ListeOuTexteOuFichier
    }

    set nL 0
    set nCOld -1
    foreach Ligne $Liste {
	incr nL
	set nC [expr [llength $Ligne] - 1]
	if {$nCOld==-1} { set nCOld $nC }
	if {$nC!=$nCOld} { FaireLire "Missing values in line $Ligne for Cluspack" }
    }
    set LeTexte {}
    lappend LeTexte "$nL $nC"
    lappend LeTexte ""
    LConcat LeTexte $Liste
    NousAllonsAuBoulot
    set Racine "[TmpFile Cluspack]"
    regsub -all {\.} $Racine "_" Racine
    set FichierSecatorIn [SauveLesLignes $LeTexte dans "$Racine.in"]
#   set ExecutableCluspack "/biolo/secator/cluspack"
    set ExecutableCluspack "/biolo/cluspack/binNew/cluspack"
    if {[catch {exec $ExecutableCluspack $FichierSecatorIn  -data_type=coordinates -clustering_method=ward -nb_clusters=secator} Message]} {
	FaireLire "cluspack failed with message\n $Message"
	return ""
    }
    set FichierSecatorOut "$Racine.clu"
    if { ! [file exists $FichierSecatorOut]} { return "" }
    if {$FichierSortie=="GetAsIs"} {
	set Sortie [ContenuDuFichier $FichierSecatorOut]
    } elseif {$FichierSortie=="GetGroupsAndMembers"} {
	set Sortie [LesClustersDeCluspack $FichierSecatorOut "GetGroupsAndMembers"]
    } elseif {$FichierSortie=="GetAllWithGroup"} {
	set Sortie [LesClustersDeCluspack $FichierSecatorOut "GetAllWithGroup"]
    } else {
	file copy $FichierSecatorOut $FichierSortie
	set Sortie $FichierSortie
    }
    if {[file exists "$Racine.in"]}  { file delete "$Racine.in" }
    if {[file exists "$Racine.clu"]} { file delete "$Racine.clu" }
    OnRevientDuBoulot
    return $Sortie

}

proc CluspackDeLaGrid {} {

    set Fichier "[RepertoireDuGenome]/fiches/normdensortiedegrid.grid"
    set CheminRepertoireOut "[RepertoireDuGenome]/cluspackgrid"
    set RepertoireOut "cluspackgrid"
    if {! [file exists $RepertoireOut]} {file mkdir $CheminRepertoireOut}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s %s %s" Nom NormdClustal NormdRascal NormdLeon
	if {$NormdRascal > $NormdLeon} {
	    set RepertoireIn "rascalgrid"
	} else {
	    set RepertoireIn "leongrid"
	}
	set FichierMsf "[RepertoireDuGenome]/$RepertoireIn/$Nom"
	if {! [file exists $FichierMsf]} {continue}
	set FichierClustSortie "[RepertoireDuGenome]/$RepertoireOut/$Nom.clu"
	if {[file exists $FichierClustSortie]} {
	    Espionne "$Nom already exists"
	    continue
	}
	#perrodou/gscoperso/gscope_lancement
	DPCManu $Nom $RepertoireIn $RepertoireOut
    }

}

proc CluspackExe {} {

    global tcl_platform OrdBinDir env

    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./cluspack"
    }
    if {$tcl_platform(platform) ne "windows"} {
	if {[info exists OrdBinDir]} {
	    return [file join $OrdBinDir "cluspack"]
	} else {
	    return "/biolo/cluspack/bin/cluspack"
	}
    } else {
	set lexe [file join $OrdBinDir "cluspack.exe"]
	regsub "Program Files" $lexe "PROGRA~1" lexe
	return $lexe
    }

}

proc CluspackGrid {NomATraiter} {


# version utilisant systematiquerment DPC
    global PipeCollection
    global PipeQuery
    global DefautsPipe

    set bchx [set DefautsPipe(Cluspack,bestmsf)]

    if {$PipeCollection} {
	set FicNormd [file join [RepertoireDuGenome] "normd" $NomATraiter]
    } else {
	set FicNormd "[file rootname ${NomATraiter}].normd"
    }
    if {![file exists $FicNormd]} {return 0}
    set rbest [string tolower [DefineBestMsfPipe $FicNormd $bchx]]
    puts "rbest vaut $rbest"
    AjouteAuLogPipe "rbest vaut $rbest"
    if {$rbest eq "no file"} {return 0}
    if {$PipeCollection} {
	set FicMSF [file join [RepertoireDuGenome] $rbest $NomATraiter]
	set InCpk  [file join [RepertoireDuGenome] cluspack ${NomATraiter}.msf]
	if {! [file exists $FicMSF]} {return 0}
	file copy -force $FicMSF $InCpk	
	set OutClu [file join [RepertoireDuGenome] cluspack ${NomATraiter}.clu]
    } else {
	if {$rbest eq "msf"} {
	    set rbest ""
	} else {
	    set rbest ".$rbest"
	}
	set InCpk  "[file rootname ${NomATraiter}]${rbest}.msf"
	set OutClu "[file rootname ${NomATraiter}].clu"
    }
    if {[file exists  $OutClu]} {return 1}
    set commande "LanceurCluspack $InCpk alignment"
    set arg "dpc kmeans 0.001"
    if {[catch {eval $commande $arg} Message]} {
	Espionne $Message
	Espionne "Problem with $InCpk with DPC"
	return 0
    }

    if {$PipeCollection} { file delete -force $InCpk }
 
    if {[file exists $OutClu]} {
	AjouteAuLogPipe "cluspack = ok"
    } else {
	AjouteAuLogPipe "cluspack failed"
    }

    return 1

}

proc CluspackGridChoixSecatorDPC {NomATraiter} {

    
# version cree mais momentanement non utilisee
# en effet, problemes observes avec secator :
# determine parfois des groupes contenant 1 seule sequence
# a choisi en attendant de travailler avec DPC uniquement!!
    global PipeCollection
    global PipeQuery

    if {$PipeCollection} {
	set InInitLeon [file join [RepertoireDuGenome] leon $NomATraiter]
	set InLeon [file join [RepertoireDuGenome] cluspack ${NomATraiter}.msf]
	# placement du fichier d alignement dans le bon repertoire pour n avoir pas 
	# a deplacer les fichiers ensuite
	File copy -force $InInitLeon $InLeon

	# fichier ".clu" cree quel que soit la methode de clusterisation utilisee
	set OutClu [file join [RepertoireDuGenome] cluspack ${NomATraiter}.clu]
	# les autres fichiers sont crees uniquement par secator
	set OutNJ [file join [RepertoireDuGenome] cluspack ${NomATraiter}.nj]
	set OutDst [file join [RepertoireDuGenome] cluspack ${NomATraiter}.dst]
    } else {
	set InLeon "${NomATraiter}.leon.msf"
	set OutClu "${NomATraiter}.clu"
	set OutNJ "${NomATraiter}.nj"
	set OutDst "${NomATraiter}.dst"
    }
    if {! [file exists $InLeon]} {return 0}
    
    set NbAccess 0
    # determination du nombre de sequences dans l alignement
    set cmd "grep -c \"Name\" $InLeon" 
    set NbAccess [eval exec $cmd]
    
    # quel que soit le programme de clusterisation le debut de la commande est la meme
    set commande "LanceurCluspack $InLeon alignment"

    if {$NbAccess > 100} {
	set Moi    "dpc"
	puts $Moi
	set LAutre "secator"
	set arg "dpc kmeans 0.001"
	set FileClustering "${InLeon}.clu"
    } else {
	set Moi    "secator"
	puts $Moi
	set LAutre "dpc"
	set arg "secator bionj"
	set FileClustering "${InLeon}.clu"
	
    }

    if {[catch {eval $commande $arg} Message]} {
	Espionne $Message
	Espionne "Problem with $InLeon with $Moi je vais utiliser $LAutre"
	if {$LAutre == "secator"} {
	    catch {[$commande secator bionj]}
	} else {
	    catch {[$commande dpc kmeans 0.001]}
	}    
    }

    if {$PipeCollection} { File delete -force $InLeon }

    if {[file exists $OutNJ]} { File delete -force $OutNJ }
    if {[file exists $OutDst]} { File delete -force $OutDst }

    return 1

}

proc ClustName {Owner} {

    return $Owner

}

proc Clustal2MSF {FichierClustal FichierMSF} {

    ############################################################
    ### Conversion d'un fichier format clustal au format msf ###
    ############################################################
    if {![file exists $FichierClustal]} {Espionne "FichierClustal $FichierClustal does not exists";return}
    Espionne "FichierMSF: $FichierMSF"

    set FichierMSF $FichierClustal
    Espionne "FichierMSF: $FichierMSF"
    regsub {\.[^\.]+$} $FichierClustal "" FichierMSFTmp
    set FichierMSFTmp "$FichierMSFTmp.msf"
    set Commande "eval exec [PATH clustalw] $FichierClustal -convert -output=gcg"
    catch {eval $Commande} Message

    if {![file exists $FichierMSFTmp]} {return}
    Espionne "FichierMSFTmp: $FichierMSFTmp"
    Espionne "FichierMSF:    $FichierMSF"    
    File rename -force $FichierMSFTmp $FichierMSF
        
    Espionne "FichierMSFTmp: $FichierMSFTmp"
    Espionne "FichierMSF:     $FichierMSF"  
  

    return $FichierMSF

}

proc ClustalX {MSF {IsFile ""}} {


    if {$IsFile=="IsFile"} {
	set FichierMSF $MSF
    } else {
	set FichierMSF [TmpFile "msf"]
	Sauve $MSF dans $FichierMSF
    } 

    exec clustalx $FichierMSF &

}

proc ClustalwExe {} {

    global tcl_platform
    global OrdBinDir
    global env

    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./clustalw"
    }
    if {[set tcl_platform(platform)] != "windows"} {
	if {[info exists OrdBinDir]} {
	    return [file join $OrdBinDir "clustalw"]
	} else {
	    return "/biolo/clustal/bin/clustalw"
	}
    } else {
	set lexe [file join $OrdBinDir "clustalw.exe"]
	regsub "Program Files" $lexe "PROGRA~1" lexe
	return $lexe
    }

}

proc ClusterAvOuSsRef {{Qui ""} {Quoi ""} {Orga ""}} {

    #ne compte pas les clusters vides
    #par orga car des numero de cluster sont commun aux 2 orga
    global ClusterAvOuSsRef

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

    if {[regexp -nocase "Test" $Orga]} {
	set RepertoireSourisOthers  "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai"
	set RepertoireSourisTfactor "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai"
	set RepertoireSourisNoAlt   "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai"
	set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNoAlt]
    }
    if {[regexp -nocase "Mouse" $Orga]} {
	set LesRepertoires [LesRepertoires "Mouse" "Ini"]
    }
    if {[regexp -nocase "Rat" $Orga]} {
	set LesRepertoires [LesRepertoires "Rat" "Ini"]
    }

    foreach Repertoire $LesRepertoires {
	foreach FileST [glob -nocomplain "$Repertoire/*"] {
	    set trouve 0
	    set cluster [lindex [split [file tail $FileST] "."] 0]
	    set taille [file size $FileST]
	    if {$taille == 0} {continue}
	    foreach Ligne [LesLignesDuFichier $FileST] {
		if {[regexp "^>" $Ligne] } { 
		    set Des [lindex [split $Ligne " "] 0]
		    if {[regexp "^>ENS" $Des] || [regexp "^>NM" $Des] || [regexp "^>XM" $Des]} {
			set trouve 1
		    }
		}
	    }
	    if {$trouve} {
		set ClusterAvOuSsRef($cluster,ref,$Orga) 1
	    } else {
		set ClusterAvOuSsRef($cluster,ref,$Orga) 0
		lappend ClusterAvOuSsRef($Repertoire,ListOfSsRef,$Orga) $cluster
		lappend ClusterAvOuSsRef(ListOf,SsRef,$Orga) $cluster
	    }
	}
    }
    return [ClusterAvOuSsRef $Qui $Quoi $Orga]	

}

proc ClusterIsoform {} {

    global LNOrdali LSOrdali SDG LNDG

    set SAli [list]
    set Lnom [list]
    foreach n $LNOrdali s $LSOrdali {
	if {$n eq ""} {continue}
	lappend SAli $n $s
	lappend Lnom $n
    }
    
    CalculeLesPCIGenerique $SAli TPCI
    set Lv [list]
    foreach n1 $Lnom {
	set tmp [list $n1]
	foreach n2 $Lnom {
	    lassign [set TPCI($n1,$n2)] pc l1 l2 lsl
	    lappend tmp [expr {1.-$pc}]
	}
	lappend Lv $tmp
    }
    
    if {[catch {set Lgr [Tclcluspack $Lv -dt coordinates -cm kmeans -nbc dpc]} Msg]} {
	puts "error"
	exit
    }
    unset -nocomplain SDG LNDG
    #puts [llength $Lgr]
    ClusterSeqsDeCluspackTcl $Lgr SDG LNDG
    #puts [array names SDG]
    AssignSeqToGroup
    
    LesDefauts Mode Batch
    LesDefauts Exit 1
    LesDefauts DownloadPDB none

    set fout "[file rootname [set ::Defauts(FichierTFA)]].xml"
    #SauveLAlignement XML $fout

    SauveLAlignement XML JLeSauveAs

    exit

}

proc ClusterPositions {LesNoms aBin NbPos} {

    global ListeNoeuds Branches1 Branches2 ListeDist GpesColonnes
    upvar  $aBin Bin
    global PremiereColPleine 

    #dissimilarite entre chaque colonne
    DissimilaritesPositions $LesNoms Bin Dissim ColPleines ListeGpes $NbPos

    #le gpe col pleines est le premier dans branches,dist et noeuds
    #mais dernier dans gpes et effectifs 
    set NbColPleines [llength $ColPleines]
    set ListeEffectifs [list]
    set Branches1 [list {}]
    set Branches2 [list {}]
    set ListeDist [list 0]
    set ListeNoeuds [list $ColPleines]
    foreach gpe $ListeGpes {
	lappend ListeEffectifs 1
    }
    #dissimilarite entre le groupe des colonnes pleines et les autres
    if {$NbColPleines>0} {
	foreach gpe $ListeGpes {
	    set terme1 [expr ($NbColPleines+2)*[set Dissim($PremiereColPleine,$gpe)]]
	    set Dissim($ColPleines,$gpe) [expr $terme1/($NbColPleines+1)]
	    set Dissim($gpe,$ColPleines) [set Dissim($ColPleines,$gpe)]
	}
	lappend ListeGpes $ColPleines
	lappend ListeEffectifs $NbColPleines
	set NbGpes [expr $NbPos-$NbColPleines+1]
    } else {
	set NbGpes $NbPos
    }
    #clustering pour tout le monde
    while {$NbGpes>1} {
	set Nompp [LePlusPetit $ListeGpes Dissim Valpp]
	set e1 [lindex $Nompp 0]
	set e2 [lindex $Nompp 1]
	set e12 "$e1 $e2"
	lappend ListeNoeuds [list $e12]
	lappend Branches1 $e1;lappend Branches2 $e2
	lappend ListeDist $Valpp
	set index1 [lsearch $ListeGpes $e1]
	set index2 [lsearch $ListeGpes $e2]
	set Prem [Mini $index1 $index2]
	set Dern [Maxi $index1 $index2]
	set eff1 [lindex $ListeEffectifs $index1]
	set eff2 [lindex $ListeEffectifs $index2]
	set ListeGpes [lreplace $ListeGpes $Dern $Dern]
	set ListeGpes [lreplace $ListeGpes $Prem $Prem]
	set ListeEffectifs [lreplace $ListeEffectifs $Dern $Dern]
	set ListeEffectifs [lreplace $ListeEffectifs $Prem $Prem]
	foreach gpe $ListeGpes EffGpe $ListeEffectifs {
	    set terme1 [expr {($eff1+$EffGpe)*[set Dissim($e1,$gpe)]}]
	    set terme2 [expr {($eff2+$EffGpe)*[set Dissim($e2,$gpe)]}]
	    set terme3 [expr {$EffGpe*[set Dissim($e1,$e2)]}]
	    set Dissim($e12,$gpe) [expr {($terme1+$terme2-$terme3)/($eff1+$eff2+$EffGpe)}]
	    set Dissim($gpe,$e12) [expr {($terme1+$terme2-$terme3)/($eff1+$eff2+$EffGpe)}]
	}
	lappend ListeEffectifs [expr $eff1+$eff2]
	lappend ListeGpes $e12
	incr NbGpes -1
    }
    set Seuil [DeterminationSeuil $ListeDist 0]
    set GpesColonnes [list]	
    Coupure end $Seuil GpesColonnes

}

proc ClusterSeqsDeCluspackTcl {Lres aTDeGrp aLGrp} {

    upvar $aTDeGrp tab $aLGrp Lgrp

    unset -nocomplain tab
    set Lgrp [list]

    set i 1
    foreach c $Lres {
	set ngr "Group$i"
	lappend Lgrp $ngr
	set tab($ngr) $c
	incr i
    }

    return 1

}

proc ClusterSequences {aBin ListeLabels TailleSeq} {

    global ListeNoeuds ListeDist Branches1 Branches2 GpesSequences
    upvar  $aBin Bin

    DissimilaritesSequences $ListeLabels Bin Dissim $TailleSeq

    set NbGpes [llength $ListeLabels]
    set ListeGpes $ListeLabels
    set Branches1   [list]
    set Branches2   [list]
    set ListeNoeuds [list]
    set ListeDist   [list]
    
    foreach Label $ListeLabels {
	lappend ListeEffectifs 1
    }

    while {$NbGpes>1} {
	#Recheche des deux groupes les plus proches
	set Nompp [LePlusPetit $ListeGpes Dissim Valpp]
	set e1 [lindex $Nompp 0]
	set e2 [lindex $Nompp 1]
	set e12 "$e1 $e2"

	#Mise a jour des listes
	lappend ListeNoeuds [list $e12]
	lappend Branches1 $e1;lappend Branches2 $e2
	lappend ListeDist $Valpp
	set index1 [lsearch $ListeGpes $e1]
	set index2 [lsearch $ListeGpes $e2]
	set Prem [Mini $index1 $index2]
	set Dern [Maxi $index1 $index2]
	set eff1 [lindex $ListeEffectifs $index1]
	set eff2 [lindex $ListeEffectifs $index2]
	set ListeGpes [lreplace $ListeGpes $Dern $Dern]
	set ListeGpes [lreplace $ListeGpes $Prem $Prem]
	set ListeEffectifs [lreplace $ListeEffectifs $Dern $Dern]
	set ListeEffectifs [lreplace $ListeEffectifs $Prem $Prem]
	#calcul de la dissimilarite entre le nouveau groupe et tous les autres
	foreach gpe $ListeGpes EffGpe $ListeEffectifs {
	    set terme1 [expr ($eff1+$EffGpe)*[set Dissim($e1,$gpe)]]
	    set terme2 [expr ($eff2+$EffGpe)*[set Dissim($e2,$gpe)]]
	    set terme3 [expr $EffGpe*[set Dissim($e1,$e2)]]
	    set Dissim($e12,$gpe) [expr ($terme1+$terme2-$terme3)/($eff1+$eff2+$EffGpe)]
	    set Dissim($gpe,$e12) [expr ($terme1+$terme2-$terme3)/($eff1+$eff2+$EffGpe)]
	}
	lappend ListeEffectifs [expr $eff1+$eff2]
	lappend ListeGpes $e12
	incr NbGpes -1
    }
    set Seuil [DeterminationSeuil $ListeDist 0]
    set GpesSequences [list]	
    Coupure end $Seuil GpesSequences

}

proc Cluster_Gretta {AffyOuPABOuList} {
 
    



}

proc ClusteringCourant {{quoi name}} {

    if {$quoi eq "index"} {
	return [set ::Defauts(IxClustCourant)]
    } else {
	return [set ::Defauts(NmClustCourant)]
    }

}

proc ClusteringDesMSFPourTous {{LesNoms ""} {NameRepMSF msf}} {

    if {$LesNoms == ""} {set LesNoms [ListeDesPABs]}

    set Rep [RepertoireDuGenome]
    set Keep 0
    if {0 < [llength [glob -nocomplain "$Rep/$NameRepMSF/*.clust"]]} {
	if {[OuiOuNon "Some files exist in $Rep/$NameRepMSF.\nWould you want to conserv them?"]} {
	    set Keep 1
	}
    }
    foreach Nom $LesNoms {
	Espionne $Nom
	set FileProt  "$Rep/prottfa/$Nom"
	set FileMSF   "$Rep/$NameRepMSF/$Nom"
	set FileClust "$FileMSF.clust"
	if {![file exists $FileProt] || ![file exists $FileMSF]} {continue}
	if {$Keep && [file exists $FileClust]} {continue}
	ClusteringDuMSF $FileMSF $FileClust
    }
    return

}

proc ClusteringDuMSF {FichierMSF FichierClustering {DPCouSecator ""}} {

    if {![file exists $FichierMSF]} {return}

    set NameFile [file tail $FichierMSF]
    regexp {^[^\.]+} $NameFile NameFile
    set FichierMSFTmp "[RepertoireDeTravail]/$NameFile"
    File copy -force $FichierMSF $FichierMSFTmp 

    if {$DPCouSecator == ""} {
        set NbAccess 0
	set F [open $FichierMSF]
	while {[gets $F Ligne]>=0} {    
	    set Entete [lindex [split [string trim $Ligne] " "] 0]
	    if {[string equal -nocase $Entete "Name:"]} {incr NbAccess}
	    if {$Entete == "//"} {break}
	}
	close $F

	if {100 < $NbAccess} {
	    set Moi    "dpc"
	    set LAutre "secator"
	    set Commande "eval exec /biolo/secator/dpc     $FichierMSFTmp alignment"
	    set FileClustering "${FichierMSFTmp}.dpc"
	} else {
	    set Moi    "secator"
	    set LAutre "dpc"
	    set Commande "eval exec /biolo/secator/secator $FichierMSFTmp"
	    set FileClustering "${FichierMSFTmp}.sec"
	}
	if {[catch {eval $Commande} Message]} {
	    Espionne $Message
	    Espionne "Problem with $FichierMSFTmp with $Moi je vais utiliser $LAutre"
	    return [ClusteringDuMSF $FichierMSF $FichierClustering $LAutre]
	}
	if {![file exists $FileClustering ]} {return}
	File rename -force $FileClustering $FichierClustering
    } else {
	if {[string equal -nocase $DPCouSecator "dpc"]} {
	    set Commande "eval exec /biolo/secator/dpc     $FichierMSFTmp alignment"
	    set FileClustering "${FichierMSFTmp}.dpc"
	}
	if {[string equal -nocase $DPCouSecator "secator"]} {
	    set Commande "eval exec /biolo/secator/secator $FichierMSFTmp"
	    set FileClustering "${FichierMSFTmp}.sec"
	}
	if {[catch {eval $Commande} Message]} {
	    Espionne $Message
	    Espionne "Problem with $FichierMSFTmp with $DPCouSecator"
	}
	if {![file exists $FileClustering ]} {return}
	File rename -force $FileClustering $FichierClustering
    }
    return $FichierClustering

}

proc ClusteringDuMac {{quoi name}} {

    set p [MacCourant]
    switch $quoi {
	"index" {
	    set r [$::db eval {select pk_clustering from clustering where pk_mac=$p}]
	}
	"name" {
	    set r [$::db eval {select name from clustering where pk_mac=$p}]
	}
	"method" {
	    set r [$::db eval {select method from clustering where pk_mac=$p}]
	}
	"zone" {
	    set r [$::db eval {select zone from clustering where pk_mac=$p}]
	}
    }
    
    return $r

}

proc ClusteringPourTous {} {

    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/leon/*"] {
	set Nom [file tail $Fichier]
	Espionne $Nom
	Anne_CluspackGridChoixSecatorDPC $Nom
    }

}

proc ClusteringRRPS {meth nbc} {

    set dcdn "toto"
    sqlite3 $dcdn wobble.sql

    set Ltables [lsort [$dcdn eval {select tbl_name from sqlite_master}]]

    # cree Liste pour Cluspack
    set table [lindex $Ltables 0]
    set Lpk [$dcdn eval "select pk_items from $table"]
    puts "Nbr of pks in clustering [llength $Lpk]"

    set Ldata [list]
    foreach pk $Lpk {
	set Ltmp [list $pk]
	foreach table $Ltables {
	    set Lv [$dcdn eval "select * from $table where pk_items=$pk"]
	    
	    set ok 1
	    #puts "$pk"
	    foreach {a b} [lrange $Lv 1 end] {
		if {0 && ($a == 0.0 || $b == 0.0)} {
		    set ok 0
		    break
		}
		#set dif [expr {abs($a - $b)}]
		set dif [expr {$a - $b}]
		if {0 && $dif == 1.0} {
		    set ok 0
		    break
		}
		
		if {1 && abs($dif) == 1.0} {
		    set dif 0.0
		} elseif {$dif == 0.0 && $a != 0.0} {
		    #set dif 0.005
		    set dif 0.0
		}
		
		lappend Ltmp $dif
	    }
	}
	#puts ""
	if {$ok} {
	    lappend Ldata $Ltmp
	}
    }
    
    puts "Compute clustering ..."
    puts "Nb data : [llength $Ldata]"
    set Ldori $Ldata
    set nbCols [llength [lindex $Ldori 0]]
    #set Ldata [CentreDataPourClustering $Ldata]
    #puts "Data centered \[-1,1\]"
    
    SauveDataClustering $Ldata

    switch $meth {
	"km" {
	    set methode "kmeans"
	    set methCl "kmeans"
	    set nbcCl $nbc
	}
	"mm" {
	    set methode "mixture model"
	    set methCl $meth
	    set nbcCl $nbc
	}
	"hie" {
	    set methode "hierarchic"
	    set meth "hi"
	    set methCl "hierar"
	    set nbc "sec"
	    set nbcCl "secator"
	}
    }
    set dir "$meth$nbc"
    if {! $::DeleteDone} {
	file delete {*}[glob -nocomplain [file join hubert $dir sel*.acc]]
	set ::DeleteDone 1
    }

    set Lgr [Tclcluspack $Ldata -dt coordinates -cm "$methCl" -nbc "$nbcCl" -wc]
    puts "Method : $methode"
    puts "Groups : $nbc"

    puts "\nClustering :"
    puts "Nb seqs : [llength $Ldori]"
    puts "\nNb Clusters : [llength $Lgr]"
    
    # Pour chaque cluster,
    # calcule norme avec data originales
    set ig 0
    set Lfin [list]
    foreach gr $Lgr {
	set Lpk [ExtraitListeDeListe $gr 0]
	# init
	set nbe [llength $gr]
	for {set col 1}  {$col < $nbCols} {incr col} {
	    set col$col 0.0
	}

	foreach pk $Lpk {
	    set ix [lsearch -exact -index 0 $Ldori $pk]
	    for {set col 1}  {$col < $nbCols} {incr col} {
		set col$col [expr {[set col$col] + abs([lindex [lindex $Ldori $ix] $col])}]
	    }
	}

	# calcule moy par colonne et sum totale
	set sum 0.0
	for {set col 1}  {$col < $nbCols} {incr col} {
	    set col$col [expr {[set col$col]/$nbe}]

	    #set sum [expr {$sum + [set col$col]}]
	    # change car diff n'est plus en 
	    # valeur absolue, mais moy oui
	    set sum [expr {$sum + abs([set col$col])}]
	}
	set sum [expr {$sum/($nbCols-1)}]

	set Ltmp [list "gr$ig" $nbe $sum]
	puts "gr$ig $nbe [format %6.4f $sum]"
	for {set col 1}  {$col < $nbCols} {incr col} {
	    puts -nonewline [format "%5.3f " [set col$col]]
	    lappend Ltmp [set col$col]
	}
	puts ""

	lappend Lfin $Ltmp
	incr ig
    }
    puts ""
    
    # tri
    set Lfin [lsort -decreasing -real -index 2 $Lfin]
    EcritClustersRRPS $Lfin $Lgr

    puts "Clusters with highest biais"
    foreach g $Lfin {
	puts -nonewline [format %5s [lindex $g 0]]
	puts -nonewline [format %5d [lindex $g 1]]
	foreach v [lrange $g 2 end] {
	    puts -nonewline [format " %6.4f" $v]
	}
	puts ""
    }
    puts ""

    # sauve premier de deuxieme clusters
    set db root
    sqlite3 $db rrps.sql
    for {set idx 0} {$idx < [llength $Lgr]} {incr idx} {
	set gr [lindex $Lfin $idx]
	set ig [string range [lindex $gr 0] 2 end]
	set Lv [lindex $Lgr $ig]
	set Lpk [list]
	if {$::typeAnalyse eq "hubert"} {
	    set fileout "sel${idx}_$::ThresholdRSA.acc"
	} else {
	    set fileout "sel${idx}.acc"
	}
	set fileout [file join $::typeAnalyse $dir $fileout]
	set o [open $fileout w]
	foreach l $Lv {
	    lappend Lpk [lindex $l 0]
	}
	set Lacc [$db eval "select accession from items where pk_items in ([join $Lpk ,])"]
	puts $o [join $Lacc \n]
	close $o
    }
    $db close

	return

}

proc ClusteringmethodETClustercountmethodInput {} {

    WithWebService "Gx" 0
    set LesTetes "name,description"
    set LesFichiers [list "[GxData]/ToGx/ClusteringmethodInput.txt" "[GxData]/ToGx/ClustercountmethodInput.txt"]
    foreach Fichier $LesFichiers {
	Espionne "$Fichier"
	set Table [string range $Fichier [expr [string last "/" $Fichier] +1] end]
	regsub {Input.txt$} $Table "" Table
	set Table [string tolower $Table]
	Espionne "$Table"
	foreach Name [InfoFromClusteringInput ListOf Name $Fichier] {
	    set Existant [GxDbSqlExec "select pk_$Table from $Table where name='$Name';" "GetFirstValue"]
	    if {$Existant!=""} { return "" }
	    
	    set name        [InfoFromClusteringInput $Name "name" $Fichier]
	    set description [InfoFromClusteringInput $Name "description" $Fichier]
	    
	    set Ligne "'$name','$description'"
	    set Commande "insert into $Table ($LesTetes) values ($Ligne);"
	    set status [GxDbSqlExec $Commande]
	}
	#return $status
    }

}

proc ClustersDExpression {{NSeqMin 6} {SplitScreen1 0} {SplitScreen2 1} {OldW ""}} {

 
    if {$OldW!=""} {catch {after 10 Destroy $OldW}}
    
    set FichierLocalisation "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best_selection2"
    set FichierDistributionArea1e6 "[RepertoireDuGenome]/Localisation/area1e6bp_Distribution_selection2"
    #mais il faut que ce fichier area1e6bp_Distribution_selection existe aussi sous le nom 
    #area1e6bp_Distribution pour que les proc de fred que j'appelle marchent.

    if {![file exists $FichierLocalisation]} {
	if {[OuiOuNon "$FichierLocalisation doesn't exist.\nDo you want I create it?"]} { 
	    FichierBoxLocalisation
	} else {
	    return ""
	}
    }

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    #set FichierBandesCytos "$RepLocalisation/CytologicMap"
    set FichierBandesCytos "/genomics/link/HeadNecknonrnr/essaicytomap"

    if {![file exists $FichierBandesCytos]} {
	Espionne "$FichierBandesCytos does not exist"
	return ""
    }

    set FichierFold "[RepertoireDuGenome]/fiches/FoldExpression_selection"
    if {![file exists $FichierFold]} {set Fold 0} else {set Fold 1}

    set LesVariablesDemandees {}
    ChoixDesVariablesDeLHistogramme TabVar
    foreach VariableDemandee [set TabVar(LesVariables)] {
	regsub -all " " $VariableDemandee "_" VariableDemandee
	lappend LesVariablesDemandees $VariableDemandee
	set Variable [set TabVar($VariableDemandee)]
    }
    set nVariables [llength $LesVariablesDemandees]
    if {$nVariables == 0} {exit}
    set ListeDesChro [ListeDesChromosomesHS]
    regsub "HSUN" $ListeDesChro ""  ListeDesChro
    foreach Chro $ListeDesChro {
	set ChromDeRef [NumeroDuChromosome $Chro]

	###                  !!! Calcul du biais (NRD) !!!                 ###
	###   fais par proc ChargeDistributionsSurRegions (Fred Chalmel)   ###

	ChargeDistributionsSurRegions Tab $ChromDeRef "area1e6bp"
	set LesRegions [set Tab($ChromDeRef,LesRegions)]
	foreach VariableDemandee $LesVariablesDemandees {
	    set Variable [set TabVar($VariableDemandee)]
	    foreach Region $LesRegions {
		if {![info exists Tab($ChromDeRef,$Region,$Variable)]} {continue}
		set Valeur [set Tab($ChromDeRef,$Region,$Variable)]
		if {![info exists VMax]} {set VMax $Valeur;continue}
		if { $VMax < $Valeur} {set VMax $Valeur}
	    }
	}
    }
    set VMaxi $VMax
    ChargeFoldDesSequences Expression
    
    set PoliceChromo "Courier 7 bold"
    set LargeurMax      [expr [winfo screenwidth .] - 100]
    set HauteurMax      [expr [winfo screenheight .] - 200]
    set LargeurFenetre  [expr [winfo screenwidth .] - 100 ]
    set HauteurFenetre  [expr [winfo screenheight .] - 200]
    set BordX           50.0
    set BordYInf        50
    set BordYSup        50  
    set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0]
    set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0]

    ChargeBandesCytologiques Genome $FichierBandesCytos
    set TailleMaxBrasP [set Genome(TaillePMax)]
    set TailleMaxBrasQ [set Genome(TailleQMax)]
    set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ]
    set NbChromosomes  [set Genome(NbChromosomes)]
    set LargeurChromo  [expr $LargeurAffichage/($NbChromosomes*3.0)] 
    set EcartEntreChromo [expr $LargeurChromo*4]
    set LargeurBoite [expr $EcartEntreChromo/2]
    
    set Facteur [expr $HauteurAffichage / ($TailleMaxChromo*3)]
    set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup]

    set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY]
    $K configure -background white 
    #regsub "/home/carles/genomes/" $RepertoireDuGenome "" Titre
    #$K create text [expr $LargeurAffichage/2]  20  -text "$Titre" -font "courrier 12 bold"

    set LaSerie1 {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08}
    lappend Les3Series $LaSerie1
    set LaSerie2 {HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16}
    lappend Les3Series $LaSerie2
    set LaSerie3 {HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY}
    lappend Les3Series $LaSerie3
    set s 0
    set PosY $PosYDuCentromer
    foreach Serie $Les3Series {
	#Espionne $Serie
	incr s
	set PosX $BordX
	foreach Chromosome $Serie {
	    ##fonction de la serie 
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	    }
	    set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]]
	    set PosXMin [expr $PosX + $EcartEntreChromo]
	    set PosXMax [expr $PosXMin + $LargeurChromo]
	    set PosXBande $PosX
	    set PosX [expr $PosXMax + $EcartEntreChromo]
	    set TailleBrasP [set Genome($Chromosome,TailleP)]
	    set TailleBrasQ [set Genome($Chromosome,TailleQ)]
	    
	    set PosXNomChromo [expr ($PosXMax + $PosXMin)/2]
	    set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20]
	    set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20]
	    
	    set Position($Chromosome) [list "$PosXMin" "$PosXMax"]
	    
	    #$K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" -tags [list "$Chromosome" "$FichierLocalisation" "Chromosome"]
	    $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" -tags [list "$Chromosome" "$FichierLocalisation" "Chromosome"]
	    
	    foreach BandeP $LesBandesP {
		set LesInfos  [set Genome($Chromosome,$BandeP)]
		set Taille    [lindex $LesInfos 1]
		set Type      [lindex $LesInfos 2]
		set ColorFill [CouleurDeLaBandeCytologique $Type]
		
		set PosYMin [expr $PosY - $Taille*$Facteur]
		set PosYMax $PosY
		set PosYBande [expr ($PosYMin+$PosYMax)/2]
		set PosY $PosYMin
		
		$K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"]
	    }
	    
	    set ExtremiteDuChromosome $PosYMin 
	    ##fonction de la serie 
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	    }
	    set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]]
	    
	    foreach BandeQ $LesBandesQ {
		set LesInfos  [set Genome($Chromosome,$BandeQ)]
		set Taille    [lindex $LesInfos 1]
		set Type      [lindex $LesInfos 2]
		set ColorFill [CouleurDeLaBandeCytologique $Type]
		
		set PosYMin $PosY
		set PosYMax [expr $PosY + $Taille*$Facteur]
		set PosYBande [expr ($PosYMin+$PosYMax)/2]
		set PosY $PosYMax
		
		$K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"]
	    }
	    set ExtremiteBasseDuChromo $PosYMax
	    
	    ########## DISPLAY HISTO 1 ##################

	    set ChromDeRef [NumeroDuChromosome $Chromosome]
	    ChargeDistributionsSurRegions Tab $ChromDeRef area1e6bp
	    set LesRegions [set Tab($ChromDeRef,LesRegions)]
	    
	    set PosXMaxHisto [expr $PosXMax + 50]
	    
	    if {$SplitScreen2} {
		#set HauteurAffichageHisto 35
		set HauteurAffichageHisto [expr $EcartEntreChromo/2]
		set PosAxeHisto [expr $PosXMaxHisto - 25]
	    } else {
		set PosAxeHisto [expr $PosXMax+5]
		set HauteurAffichageHisto 40
	    }
	    
	    set TailleChromo [set Tab($ChromDeRef,Taille)]
	    set FacteurHisto [expr ($ExtremiteBasseDuChromo-$ExtremiteDuChromosome)/$TailleChromo]
	    
	    set Debut 1
	    foreach Region $LesRegions {
		set Taille [set Tab($ChromDeRef,$Region,Taille)]
		set Fin    [expr $Debut + $Taille - 1 ]    
		set PosYMin [expr $ExtremiteDuChromosome + ($Debut*$FacteurHisto)]
		set PosYMax [expr $ExtremiteDuChromosome + ($Fin*$FacteurHisto)]
		set LargeurDesBarres [expr $Taille*$FacteurHisto/$nVariables]
		set i 0
		foreach VariableDemandee $LesVariablesDemandees {
		    set Variable  [set  TabVar($VariableDemandee)]	
		    set Valeur    [set  Tab($ChromDeRef,$Region,$Variable)]		
		    
		    if {$VMaxi == 0 || $Valeur == 0} {
			incr i
			continue
		    }
		    set Unit      [set  TabVar($Variable,Unit)]
		    
		    set PosYm     [expr $PosYMin + $i*$LargeurDesBarres]
		    set PosYM     [expr $PosYm + $LargeurDesBarres]
		    incr i
		    set FacteurY  [expr $HauteurAffichageHisto/$VMax]
		    
		    if {$SplitScreen2 && [regexp -nocase {moins|minus} $Variable]} {
			set PosXMin [expr $PosAxeHisto - $FacteurY*$Valeur]
			set PosXMax  $PosAxeHisto
			set OutLine "green"
			set ColorFill "green"
		    } else {
			set PosXMin $PosAxeHisto  
			set PosXMax [expr $PosAxeHisto + $FacteurY*$Valeur]
			set OutLine "red"
			set ColorFill "red"
		    }
		    $K create rectangle $PosXMin $PosYm $PosXMax $PosYM -outline $OutLine -fill $ColorFill -tags [list "$VariableDemandee" "$Valeur" "$Unit" "$Region" "Variable"] 
		}
		set Debut [expr $Fin + 1]
	    }
	    $K create line $PosAxeHisto $ExtremiteDuChromosome $PosAxeHisto $ExtremiteBasseDuChromo -fill black -width 1
	}
	##PosYfonction de la serie
	if {$s==1} {
	    set PosY $PosYDuCentromer		
	}
	if {$s==2} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	}
	if {$s==3} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	}
	$K create line  $BordX  $PosY $LargeurMax $PosY -fill red
    }

    ################# HISTO 2 ####################################

    set LesVariablesDemandees {}
    ChoixDesVariablesDeLHistogramme TabVar
    
    foreach VariableDemandee [set TabVar(LesVariables)] {
	regsub -all " " $VariableDemandee "_" VariableDemandee
	#Espionne $VariableDemandee
	lappend LesVariablesDemandees $VariableDemandee
	set Variable [set TabVar($VariableDemandee)]
    }
    EspionneL $LesVariablesDemandees
    #FaireLire ok
    set nVariables [llength $LesVariablesDemandees]
    if {$nVariables == 0} {exit}
    lappend LesVariablesDemandees "Nb_Seq"
    set TousLesChromos {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY}
    
    set vd "Skew_in_sequences"
    set v [set TabVar($vd)]
    foreach Chro $TousLesChromos {
	set ChromDeRef [NumeroDuChromosome $Chro]
	ChargeDistributionsSurRegions Tab $ChromDeRef area1e6bp
	set LesRegions [set Tab($ChromDeRef,LesRegions)]
	foreach Region $LesRegions {
	    set ValSeq [set Tab($ChromDeRef,$Region,NbSeq)]
	    if {$ValSeq<$NSeqMin} {continue}
	    set Valeur [set  Tab($ChromDeRef,$Region,$v)]
	    if {![info exists VMaxBiais]} {set VMaxBiais $Valeur;continue}
	    if {$VMaxBiais < $Valeur} {
		set VMaxBiais $Valeur
		if {$Valeur==455} {Espionne "$Chro $Region"}
	    }
	}
    }
    
    
    set VMaxi $VMaxBiais
    #Espionne $VMaxi
    #FaireLire ok
    set s 0
    foreach Serie $Les3Series {
	#Espionne $Serie
	incr s
	set PosX $BordX
	foreach Chromosome $Serie {
	    ##fonction de la serie 
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	    }
	    set PosXMin [expr $PosX + $EcartEntreChromo]
	    set PosXMax [expr $PosXMin + $LargeurChromo]
	    set PosXBande $PosX
	    set PosX [expr $PosXMax + $EcartEntreChromo]
	    set TailleBrasP [set Genome($Chromosome,TailleP)]
	    set TailleBrasQ [set Genome($Chromosome,TailleQ)]
	    set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]]
	    foreach BandeP $LesBandesP {
		set LesInfos  [set Genome($Chromosome,$BandeP)]
		set Taille    [lindex $LesInfos 1]
		set Type      [lindex $LesInfos 2]
		set ColorFill [CouleurDeLaBandeCytologique $Type]
		set PosYMin [expr $PosY - ($Taille*$Facteur)]
		
		set PosYMax $PosY
		set PosYBande [expr ($PosYMin+$PosYMax)/2]
		set PosY $PosYMin
	    }
	    
	    set ExtremiteDuChromosome $PosYMin 
	    ##fonction de la serie 
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	    }
	    set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]]
	    
	    foreach BandeQ $LesBandesQ {
		set LesInfos  [set Genome($Chromosome,$BandeQ)]
		set Taille    [lindex $LesInfos 1]
		set Type      [lindex $LesInfos 2]
		set ColorFill [CouleurDeLaBandeCytologique $Type]
		
		set PosYMin $PosY
		set PosYMax [expr $PosY + $Taille*$Facteur]
		set PosYBande [expr ($PosYMin+$PosYMax)/2]
		set PosY $PosYMax
	    }
	    set ExtremiteBasseDuChromo $PosYMax
	    
	    #################### DISPLAY OF HISTO 2 ##################################
	    
	    set ChromDeRef [NumeroDuChromosome $Chromosome]
	    ChargeDistributionsSurRegions Tab $ChromDeRef area1e6bp
	    set LesRegions [set Tab($ChromDeRef,LesRegions)]

	    set PosXMaxHisto [expr $PosXMax + 2*$EcartEntreChromo]

	    if {$SplitScreen1} {
		set HauteurAffichageHisto [expr 2*$EcartEntreChromo]
		set PosAxeHisto [expr $PosXMaxHisto - 2*$EcartEntreChromo]
	    } else {
		set PosAxeHisto [expr $PosXMaxHisto - $EcartEntreChromo]
		set HauteurAffichageHisto [expr $EcartEntreChromo/4]
	    }
	    
	    set TailleChromo [set Tab($ChromDeRef,Taille)]
	    set FacteurHisto [expr ($ExtremiteBasseDuChromo-$ExtremiteDuChromosome)/$TailleChromo]

	    set Debut 1
	    
	    foreach Region $LesRegions {
		set ValSeq [set Tab($ChromDeRef,$Region,NbSeq)]
		set Taille [set Tab($ChromDeRef,$Region,Taille)]
		set Fin    [expr $Debut + $Taille - 1 ]    
		set PosYMin [expr $ExtremiteDuChromosome + ($Debut*$FacteurHisto)]
		set PosYMax [expr $ExtremiteDuChromosome + ($Fin*$FacteurHisto)]
		set LargeurDesBarres [expr $Taille*$FacteurHisto/$nVariables]
		set i 0
		if {$ValSeq<$NSeqMin} {
		    set Debut [expr $Fin + 1]
		    continue
		}
		foreach VariableDemandee $LesVariablesDemandees {
		    set Variable  [set  TabVar($VariableDemandee)]	
		    if {$Variable=="NbSeq"} {
			incr i
			continue
		    }
		    
		    set Valeur    [set  Tab($ChromDeRef,$Region,$Variable)]		
		    #Espionne $Valeur
		    if {$VMaxi == 0 || $Valeur == 0} {continue}
		    
		    #set ColorFill [set  TabVar($Variable,Couleur)]
		    set ColorFill "black"
		    set Unit      [set  TabVar($Variable,Unit)]
		    
		    set PosYm     [expr $PosYMin + $i*$LargeurDesBarres]
		    set PosYM     [expr $PosYm + $LargeurDesBarres]
		    
		    incr i
		    
		    set FacteurY  [expr $HauteurAffichageHisto/$VMaxi]
		    
		    if {$SplitScreen1 && [regexp -nocase {moins|minus} $Variable]} {
			set PosXMin [expr $PosXMax - $FacteurY*$Valeur]
			set PosXMax  $PosAxeHisto
		    } else {
			set PosXMin $PosAxeHisto  
			set PosXMax [expr $PosAxeHisto + $FacteurY*$Valeur]
		    }
		    #if {$ColorFill == "black"} {set OutLine "white"} else {set OutLine "black"}
		    set OutLine "black"
		    $K create rectangle $PosXMin $PosYm $PosXMax $PosYM -outline $OutLine -fill $ColorFill -tags [list "$VariableDemandee" "$Valeur" "$Unit" "$Region" "Variable"] 
		}
		set Debut [expr $Fin + 1]
	    }
	    $K create line $PosAxeHisto $ExtremiteDuChromosome $PosAxeHisto $ExtremiteBasseDuChromo -fill black -width 1
	}
	##PosY fonction de la serie
	if {$s==1} {
	    set PosY $PosYDuCentromer		
	}
	if {$s==2} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	}
	if {$s==3} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	}
    }

    ################################# HISTO 3 ###############################

    set s 0
    foreach Serie $Les3Series {
	#Espionne $Serie
	incr s
	set PosX $BordX
	foreach Chromosome $Serie {
	    set ChromDeRef [NumeroDuChromosome $Chromosome]
	    ChargeDistributionsSurRegions Tab $ChromDeRef area1e6bp
	    set LesRegions [set Tab($ChromDeRef,LesRegions)]
	    set TailleChromo [set Tab($ChromDeRef,Taille)]

	    set LesClusters [LesMillionsEtLesScoresPourTousLesClustersDunChromo $Chromosome]
	     
	    ##fonction de la serie 
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup+($PosYDuCentromer *2)+60+60]
	    }
	    ####
	    set PosXMin [expr $PosX + $EcartEntreChromo]
	    set PosXMax [expr $PosXMin + $LargeurChromo]
	    set PosXBande $PosX
	    set PosX [expr $PosXMax + $EcartEntreChromo]
	    set TailleBrasP [set Genome($Chromosome,TailleP)]
	    set TailleBrasQ [set Genome($Chromosome,TailleQ)]
	    set TailleChromosome [expr $TailleBrasP+$TailleBrasQ]
	    ##histo##
	    #set PosXMaxHisto [expr $PosXMax + 95]
	    set PosXMaxHisto [expr $PosXMax + 90]
	    #set PosAxeHisto [expr $PosXMax + 80]
	    set PosAxeHisto [expr $PosXMax + 70]
	    #set HauteurAffichageHisto 30
	    set HauteurAffichageHisto 20
	    set VMaxi 8
	    set FacteurY  [expr $HauteurAffichageHisto/$VMaxi]
	    #########
	    set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]]
	    foreach BandeP $LesBandesP {
		set LesInfos  [set Genome($Chromosome,$BandeP)]
		set Taille    [lindex $LesInfos 1]
		set PosYMin [expr $PosY - $Taille*$Facteur]
		set PosYMax $PosY
		set PosY $PosYMin
	    }
	    set ExtremiteDuChromosome $PosYMin 
	    ##fonction de la serie
	    if {$s==1} {
		set PosY $PosYDuCentromer		
	    }
	    if {$s==2} {
		set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	    }
	    if {$s==3} {
		set PosY [expr $TailleMaxBrasP * $Facteur +$BordYSup +($PosYDuCentromer *2)+60+60]
	    }
	    set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]]
	    foreach BandeQ $LesBandesQ {
		set LesInfos  [set Genome($Chromosome,$BandeQ)]
		set Taille    [lindex $LesInfos 1]
		set PosYMin $PosY
		set PosYMax [expr $PosY + $Taille*$Facteur]
		set PosYBande [expr ($PosYMin+$PosYMax)/2]
		set PosY $PosYMax
	    }
	    set ExtremiteBasseDuChromo $PosYMax
	    set FacteurHisto [expr ($ExtremiteBasseDuChromo-$ExtremiteDuChromosome)/$TailleChromo]
	    ########### DISPLAY HISTO 3 ######################
	    
	    set Debut 1
	    foreach Region $LesRegions {
		set Taille [set Tab($ChromDeRef,$Region,Taille)]
		set LargeurDesBarres [expr $Taille*$FacteurHisto]
		set Fin [expr $Debut + $Taille - 1 ]
		foreach Cluster $LesClusters {
		    #Espionne $Cluster
		    set Million [lindex $Cluster 1]
		    set NNScore [lindex $Cluster 2]
		    if {$Million!=$Region} {
			continue
		    } else {
			set Val $NNScore
			set PosXMax [expr $PosAxeHisto + $FacteurY*$Val]  
			set PosYMin [expr $ExtremiteDuChromosome + ($Debut*$FacteurHisto)]
			set PosYMax [expr $ExtremiteDuChromosome + ($Fin*$FacteurHisto)]
			set PosXMin $PosAxeHisto  
			set PosXMax [expr $PosAxeHisto + $FacteurY*$Val]
			$K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline blue -fill blue  
		    }
		}
		set Debut [expr $Fin + 1]
	    }
	    $K create line $PosAxeHisto $ExtremiteDuChromosome $PosAxeHisto $ExtremiteBasseDuChromo  -fill black -width 1 
	}
	##fonction de la serie 
	if {$s==1} {
	    set PosY $PosYDuCentromer		
	}
	if {$s==2} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60]
	}
	if {$s==3} {
	    set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60]
	}
    }

    regsub {\.canvas} $K "" w
    #ces 2 lignes sont necessaires pour affichage 
    #lors du passage de la souris sur chaque region de l histo
    $K bind "Variable"  "DevoileLesHistogrammes $K %x %y Enter"
    $K bind "Variable"  "DevoileLesHistogrammes $K %x %y Leave"
    
    $K bind "Chromosome"         <1>     "ChromosomeSelectionne $K"
    $K bind "Chromosome"         <2>     "AfficheRequeteSurLaMeilleureLocalisation $K"
    
    $K bind "BandesCytologiques"  "DevoileLesBandesCytologiques $K %x %y Enter"
    $K bind "BandesCytologiques"  "DevoileLesBandesCytologiques $K %x %y Leave"
    $K bind "BandesCytologiques" <1>     "AfficheRequeteSurLaMeilleureLocalisation $K"
    
    $K bind "Box"                 "DevoileLesBoites $K %x %y Enter"
    $K bind "Box"                 "DevoileLesBoites $K %x %y Leave"
    $K bind "Box"                <1>     "AfficheFicheInfo $K"
    
    set B [BoutonneLaFenetre $w "Histogramm"]
    bind $B <1> "ChoixHistogramme"
    set Boutons "$w.buttons"

}

proc ClustersDeClonesAuxLocsChevauchantes {} {

##basee sur fichier box_localisation_best

#Cree le fichier jumeaux_Overlap dans le dir fiches.
#Jumeaux = Clones localises sur le meme chromosome avec des locs chevauchantes.
#Attention : Considere la best localisation.
#premiere best si cas polyloc. 
#Trie les clones d'un meme cluster par ordre decroissant de leur longueur (nuctfa)

    if { ! [file exists "[RepertoireDuGenome]/fiches"]} { File mkdir "[RepertoireDuGenome]/fiches" }
    set FichierDesClonesEnOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap"

    set FichierBestLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_best"
    if {![file exists $FichierBestLoc]} {return "I need the file BoxLocalisation_Human_best in /Localisation directory"}
    set LesLocsNom {}
    foreach Nom [ListeDesPABs] {
	set Loc [InterrogeLocalisation $FichierBestLoc Nom $Nom]
	if {$Loc==""} {continue}
	#modif: 
	#avant: set Loc [split $Loc " "]
	#maintenant: 
	#remarque split
	#pour les polyloc:
	if {[llength $Loc]>=2} {
	    set Loc [lindex $Loc 0]
	} else {
	    set Loc [join $Loc ""]    
	}
	set Chro [lindex $Loc 9]
	set DSurChro [lindex $Loc 10]
	set FSurChro [lindex $Loc 11]
	if {$Chro==""} {Espionne $Nom}
	lappend LesLocsNom "$Chro $DSurChro $FSurChro $Nom"
    }
    #commande vue avec Raymond
    #permet de trier en fonction de la borne inferieure "a"
    set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom]
    set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees]
    lappend LesLocsNomTriees "bidon bidon bidon bidon bidon"
    set OldChromo "zzzz"
    set OldInf 1111111111111111
    set OldSup 0
    set LaSortie {}
    foreach Loc $LesLocsNomTriees {
	if {$Loc!="bidon bidon bidon bidon bidon"} {
	    scan $Loc "%s %d %d %s" chromo inf sup code
	    if {($chromo == $OldChromo) && ($inf <= $OldSup)} {
		if {![info exists LesMemes]} { set LesMemes $Oldcode }
		lappend LesMemes $code
	    } else {
		if {[info exists LesMemes]} {
		    lappend LaSortie [join $LesMemes " "]
		    unset LesMemes
		}
	    }
	    set OldChromo $chromo
	    set OldInf $inf
	    set OldSup $sup 
	    set Oldcode $code
	}
    }

    if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace the file jumeaux_Overlap"]} {
	if {$LaSortie=={}} {
	    Sauve "No overlaps were found" dans $FichierDesClonesEnOverlap
	} else {
	    set Sortie [TrieLaSortie $LaSortie]
	    Espionne "fin"
	    Sauve $Sortie dans $FichierDesClonesEnOverlap
	} 
    }
    return $FichierDesClonesEnOverlap

}

proc ClustersoftwareInput {} {

    WithWebService "Gx" 0
    set LesTetes "pk_clusteringmethod,pk_clustercountmethod,name,description"
    foreach Name [InfoFromClustersoftwareInput ListOf Name] {
	
	set Lesnameccm [InfoFromClustersoftwareInput $Name "nameccm"]
	
	set pkCm [GxDbSqlExec "select pk_clusteringmethod from clusteringmethod where name='$Name';" "GetFirstValue"]
	foreach nameccm $Lesnameccm {
	    set pkCcm [GxDbSqlExec "select pk_clustercountmethod from clustercountmethod where name='$nameccm';" "GetFirstValue"]
	    set Existant [GxDbSqlExec "select pk_clustersoftware from clustersoftware where pk_clusteringmethod = $pkCm and pk_clustercountmethod = $pkCcm;" "GetFirstValue"]
	    if {$Existant!=""} { return "" }

	    set Ligne "$pkCm,$pkCcm,'${Name}_$nameccm','from cluspack'"
	    Espionne "$Ligne"
	    set Commande "insert into clustersoftware ($LesTetes) values ($Ligne);"
	    Espionne "$Commande"
	    set status [GxDbSqlExec $Commande]
	}
    }

}

proc CmdsMenuFeatures {what} {

    global EFeat

    set EFeat(Bindings) [bindtags $::NomTextSeq]
    switch $what {
	"selitem" {
	    set EFeat(LItemSel) [list]
	    set EFeat(LZonesT)  [list]
	    bindtags $::NomTextSeq [list BWhS BEFSelitem $::NomTextSeq all]
	}
	"selitall" {
	    set EFeat(LItemSel) [list]
	    set EFeat(LZonesT)  [list]
	    bindtags $::NomTextSeq [list BEFSelitall BWhS $::NomTextSeq all]
	}
	"selreg" {
	    set EFeat(ZonesSel) [list]
	    bindtags $::NomTextSeq [list BEFSelreg BWhS $::NomTextSeq all]
	}
	"clearsel" {
	    $::NomTextSeq configure -state normal
	    $::NomTextSeq tag remove slct 1.0 end
	    $::NomTextSeq configure -state disabled

	    set EFeat(Bindings) [list]	    
	    set EFeat(ZonesSel) [list]
	    bindtags $::NomTextSeq $::EFeat(BindInit)
	}
	"edit" {
	    EditFeatureItem
	    if {$EFeat(COk)} {
		bindtags $::NomTextSeq $::EFeat(BindInit)
	    }
	}
	"define" {
	    DefineNewFeature
	    bindtags $::NomTextSeq $::EFeat(BindInit)
	    set EFeat(Bindings) [list]
	}
	"propagitem" {
	    bindtags $::NomTextSeq $::EFeat(BindInit)
	    ExtendFeatTo group
	}
	"propagall" {
	    bindtags $::NomTextSeq $::EFeat(BindInit)
	    ExtendFeatTo all
	}
	"delete" {
	    DeleteSelected
	    bindtags $::NomTextSeq $::EFeat(BindInit)
	}
	"delfeat" {
	    bindtags $::NomTextSeq [list BEFDelfeat BWhS $::NomTextSeq all]
	}
    }

    return

}

proc CoGeno {} {

    
    set G [RepertoireDuGenome]
    set R "/work/moumou/PGrid/"
    set Gbla [file join $G blastp]
    set Rbla [file join $R blastp]
    set Gbal [file join $G ballast]
    set Rbal [file join $R ballast]
    set Gfil [file join $G tfasdescopains]
    set Rfil [file join $R tfasdescopains]
    set Gclu [file join $G msf]
    set Rclu [file join $R msf]
    set Gras [file join $G rascal]
    set Rras [file join $R rascal]
    set Gleo [file join $G leon]
    set Rleo [file join $R leon]
    set Gnor [file join $G normd]
    set Rnor [file join $R normd]
    
    set res [open "resultats.log" w]
    foreach e [ListeDesPABs] {
	set Lres {}
	set Errs 0
	lappend Lres "$e :"
	foreach p {"fil" "clu" "ras" "leo"} {
	    set Manque 0
	    set c1 [file join [set G$p] $e]
	    set c2 [file join [set R$p] $e]
	    if {! [file exists $c1]} {
		lappend Lres "$p $e genome n'existe pas "
		set Manque 1
		set Errs 1
	    }
	    if {! [file exists $c2]} {
		lappend Lres "$p $e grid n'existe pas "
		set Manque 1
		set Errs 1
	    }
	    if {! $Manque} {
		catch {eval exec diff $c1 $c2} vd
		if {$vd != ""} {
		    lappend Lres "$p :"
		    set Errs 1
		}
	    }
	}
	if {$Errs} {puts $res [join $Lres "\n"]}
	flush $res
    }

    close $res
    
    exit

}

proc CoGlimmer {Nom} {

    global RepertoireDuGenome
    global CoGlimmer

    if {[info exists CoGlimmer($Nom)]} { return [set CoGlimmer($Nom)] }

    if {[info exists CoGlimmer("EstCharge")]} { return [set CoGlimmer("EstCharge")] }

    Wup "Si bornesdesglimmers est cache on ne fait pas CoGlimmer"
    if { ! [file exists "$RepertoireDuGenome/fiches/bornesdesglimmers"]} {
	    set  CoGlimmer("EstCharge") "IgnoreCoGlimmer"
	    return [set CoGlimmer("EstCharge")]
    }
    
    set FichierCoGlimmer "$RepertoireDuGenome/fiches/coglimmer"
    while { ! [file exists $FichierCoGlimmer]} {
	if {[OuiOuNon "Do I calculate overlaps with GLIMMER to create the file\n$FichierCoGlimmer\ ?"]} {
	    CreeCorrespondanceAvecGlimmer $FichierCoGlimmer
	    continue
	}
	if {[OuiOuNon "Do I ignore overlaps with GLIMMER ?"]} {
	    set  CoGlimmer("EstCharge") "IgnoreCoGlimmer"
	    return [set CoGlimmer("EstCharge")]
	}
	if {[OuiOuNon "Do I exit ?"]} { exit }
    }
    foreach Ligne [LesLignesDuFichier $FichierCoGlimmer] {
	scan $Ligne "%s %s %s" A Etat B
	set CoGlimmer($A) "$Etat $B"
    }
    set CoGlimmer("EstCharge") "EstCharge"
    return [CoGlimmer $Nom]

}

proc CoOlPourTous {{Action ""}} {

    if {$Action==""} {
	set Action [ChoixParmi [list "Show"   "RecalculateAndShow"  "RecalculateAndReturnPofOl"   "ReturnPofOl" "RecalculateAndReturnPofPPCR" "ReturnPofPPCR" "RecalculateAndReturnCoOl"    "ReturnCoOl"]]
    }

    if { [regexp "Recalculate" $Action] } {
	set FichierLesPsRejetes "[Fiches]/LesPsRejetes"
	if {[OuiOuNon "Do I run MiseAJourDesPDesExistings ?"]} {
	    MiseAJourDesPDesExist|ings
	}
	if {[OuiOuNon "Do I run PositionSurMatricePourTous ?"]} {
	    PositionSurMatricesPourTous
	}
	InventaireDesFichiersClonage
	set LesPs {}
	while {$LesPs=={}} {
	    if {[OuiOuNon "Do you want to enter a list of Oligos"]} {
		set LesPs [Entre "P2639 P2643"]
		continue
	    }
	    if {1 || [OuiOuNon "Do I use Oli to list existing oligos (instead of CloDo) ?"]} {
		set LesPs [Oli LaListeMerci]
	    } else {
		set LesPs [CloDo ListAllPlease oligos]
	    }
	}
	set CreePofPPCR [OuiOuNon "Do I recalculate all PofPPCR ?"]
	if {$CreePofPPCR} {
	    set CreeVirtualPPCR 0
	    FaireLire "Please notate that you have to rerun CoOlPourTous to create the VirtualPPCRs"
	} else {
	    set CreeVirtualPPCR [OuiOuNon "Do I create VirtualPPCRs ?"]
	}
	foreach P $LesPs {
Espionne $P
	    set TypeOli  [Oli $P Type]
	    if {$TypeOli!="SynOli"} { continue }
	    set PSujets  [Oli $P Subjects]
	    set PSignals [Oli $P Signals]
	    regsub -all "_" $PSignals " " PSigs
	    set PSens    [Oli $P Sens]
	    if {$PSens=="5'"} {
		set POliSignals " === $PSigs === "
	    } else {
		set POliSignals " ===  === $PSigs"
	    }
	    foreach Ma [MatOl $P Matrice]  AA [MatOl $P AA]  NA [MatOl $P NA]  Or [MatOl $P Orient]  Su [MatOl $P Subjects] {
Espionne "$P $AA $NA $Or $Su =$Ma="
		if {0 && [Oli $P "IsRebuildedBrockenOli"]} {
		    set Brocken [Oli $P "Brocken"] 
		    set Ma [MatOl $Brocken Subjects]
		}
		set PGS [file tail $Ma]
		set CoOl "[string repeat x 50]\n$P"
		if {$TypeOli=="MutOli"} {
		    set Code [Oli $P "CodeMutation"]
		    append CoOl "\n     $Or oligo to mutate $Code in $PGS [Alias $PGS] at $AA $NA and for $Su"   
		    lappend LeTexte "$CoOl"
		    continue
		}
		if {[Oli $P "IsBrocOli"]} {
		    set Full [Oli $P "Full"]
		    append CoOl "\n     $Or BrocOli for Full $Full for $PGS [Alias $PGS]"   
		    lappend LeTexte "$CoOl"
		    continue
		}
		if {$PGS==""} { continue }
		BaClonAppend LesOligos $PGS $P 
		set LesSujets [split $Su " "]
		append CoOl [format " %5d %5d %s %s %s %s" $AA $NA $Or $PGS [Alias $PGS] $Su]
		if {$Or=="F"} { set Sens "5'" } else { set Sens "3'" }
		set AliasDuPGS [Alias $PGS]
		foreach Sujet $LesSujets {
		    regsub {\-[0-9]+\-[0-9]+$} $Sujet "" AliasDuSujet
		    if {  ! [MemeAlias $AliasDuSujet $AliasDuPGS]} {
			AppendAuFichier $FichierLesPsRejetes "$P $PGS $AliasDuPGS $AliasDuSujet $Sujet"
			continue 
		    }
		    set LesSigPourPPCRPossibles {}
		    BaClonAppend LesSujets $PGS $Sujet
		    BaClonSet LesSujets $PGS [lsort -unique [BaClon LesSujets $PGS]]
		    BaClonAppend LesOligosDuCouple $PGS $Sujet $P
		    BaClonSet Trio $PGS $Sujet $P $AA 
		    append CoOl "\n\n        $Sujet"
		    set LesOlis [ItsOligos $Sujet]
		    if {$LesOlis==""} {
			Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
			append CoOl "\n      ooooo no oligo found"
		    } else {
			set OK 0
			foreach Oli $LesOlis {
			    Espionne "Oli $Oli"
			    if { ! [string equal "$Sujet$POliSignals" $Oli]} { continue }
			    append CoOl "\n        $Oli"
			    set OK 1
			    regsub "===  ===" $POliSignals "===" SigPourPPCR
			    if { ! [regexp {=== *$} $SigPourPPCR]} { append SigPourPPCR " ===" } 
			    lappend LesSigPourPPCRPossibles $SigPourPPCR
			    lappend PofOl($Oli) $P
			    append CoOl "\n        PofOl : [join [set PofOl($Oli)] " "]"
			}
			if { ! $OK } {
			    Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
			    append CoOl "\n        ooooo no corresponding signal found"
			}
		    }
		    set LesPPCR [ItsPPCR $Sujet]
		    if {$LesPPCR==""} {
			append CoOl "\n      ppppp no ppcr found"
		    } else {
			set OK 0
			foreach PPCR $LesPPCR {
			    regsub -all {\+} $PPCR "=" xPPCR
			    if { ! [regexp {=== *$} $xPPCR]} { append xPPCR " ===" } 
			    foreach SigPourPPCR $LesSigPourPPCRPossibles {
				if { ! [regexp $SigPourPPCR $xPPCR]} { continue }
				append CoOl "\n        $PPCR"
				set OK 1
				if {$CreePofPPCR} {
				    if {$Sens=="5'"} {
					P5ofPPCR $PPCR $P
				    } else {
					P3ofPPCR $PPCR $P
				    }
				}
			    }
			    if {[P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable"} {
				append CoOl "\n        P5ofPPCR : [join [P5ofPPCR $PPCR] " "]"
			    }
			    if {[P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
				append CoOl "\n        P3ofPPCR : [join [P3ofPPCR $PPCR] " "]"
			    }
			    if {    [P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable" &&  [P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
				if {$CreeVirtualPPCR} {
				    NewVirtualPPCR $PPCR $PGS $Sujet
				}
			    }
			}
			if { ! $OK } { append CoOl "\n     ppppp no corresponding oligo found" }
		    }
		}
		lappend LeTexte $CoOl
	    }
	}
	set LesPofOl {}
	foreach Oli [lsort [array names PofOl]] {
	    set LesPs [lsort -unique [set PofOl($Oli)]]
	    set PofOl($Oli) $LesPs
	    lappend LesPofOl "[join $LesPs " "]    $Oli"
	}
	set LesPofOl [lsort $LesPofOl]
	if {[OuiOuNon "Do I save PofOl ?"]} {
	    SauveLesLignes [array get PofOl] dans "[RepertoireDuGenome]/fiches/PofOl"
	}
	set LesPofPPCR {}
	foreach PPCR [lsort -unique [concat [P5ofPPCR LaListeDesPPCRs] [P3ofPPCR LaListeDesPPCRs]]] {
	    if {[P5ofPPCR $PPCR]!=""} {
		set LesP5s [lsort -unique [P5ofPPCR $PPCR]]
		P5ofPPCR $PPCR $LesP5s
		set P5 [join $LesP5s " "]
	    } else {
		set P5 "     "
	    } 
	    if {[P3ofPPCR $PPCR]!=""} {
		set LesP3s [lsort -unique [P3ofPPCR $PPCR]]
		P3ofPPCR $PPCR $LesP3s
		set P3 [join $LesP3s " "]
	    } else {
		set P3 "     "
	    } 
	    lappend LesPofPPCR "$P5    $PPCR" 
	    lappend LesPofPPCR "$P3    $PPCR"
	    lappend LesPofPPCR ""
	}
	if {$CreePofPPCR} {
	    P5ofPPCR Save
	    P3ofPPCR Save
	}
	if {[OuiOuNon "Do I save BaClon ?"]} { BaClon Save }    
	if { ! $CreeVirtualPPCR} {
	    FaireLire "Don't forget to rerun CoOlPourTous to create the VirtualPPCRs"
	}
    }
    if {[regexp "Show" $Action]} {

	if { ! [info exists LesPofOl]} {
	    set LesPofOl [PofOl "LesPofOl"]
	}
	set FO [AfficheVariable [join $LesPofOl "\n"]   "AvecOliAvecFiOl" "PofOligos"]

	if { ! [info exists LesPofPPCR]} {
	    set LesPofPPCR [PofPPCR]
	}
	set FP [AfficheVariable [join $LesPofPPCR "\n"] "AvecOliAvecFiPPCR" "PofPPCR"]
	if { ! [info exists LeTexte]} {
	    set LeTexte {}
	    foreach PGS [ListeDesPABs] {
		if {[BaClon LesSujets $PGS]==""} {
		    lappend LeTexte "$PGS no subjects nor oligos"
		    continue
		}
		set LesSujets [BaClon LesSujets $PGS]
		lappend LeTexte "$PGS [Alias $PGS] concerns [llength $LesSujets] subjects"
		foreach Sujet $LesSujets {
		    lappend LeTexte "       $Sujet"
		    foreach P [BaClon LesOligosDuCouple $PGS $Sujet] {
			set AA [BaClon Trio $PGS $Sujet $P]
			lappend LeTexte "          $P [format "%4d" $AA] [Oli $P Description]"
		    }
		}
		
	    }
	}
	set FC [AfficheVariable [join $LeTexte "\n"]  "AvecOliAvecShowItsOligosAvecFiOlAvecShowItsPPCRAvecFiPPCRAvecShowItsPPCR"  CoOlPourTous]
	return [list $FO $FP $FC]
    }
    return 

}

proc CoVarianceDesListes {Liste1 Liste2 {nOUnmoins1 nmoins1}} {

    set n [llength $Liste1]
    if {$n != [llength $Liste2]} {return}

    set Mean1 [MoyenneDeLaListe $Liste1]
    set Mean2 [MoyenneDeLaListe $Liste2]
    set Somme 0
    foreach v1 $Liste1 v2 $Liste2 {set Somme [expr $Somme + ($v1 - $Mean1) * ($v2 - $Mean2)]}
    if {[string equal -nocase $nOUnmoins1 "nmoins1"]} {return [expr $Somme * 1.0 / ($n - 1)]}
    return [expr $Somme * 1.0 / $n]

}

proc CocheAligneurs {} {

    global Aligneurs retourCoche AligneursCochons
    
    Gs "Rien"
    
    set w [NomDe coche]
    catch {destroy $w}
    toplevel $w
    wm title $w "Merci de cocher ..."
    wm iconname $w "Coche"
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.dismiss -text "Dismiss" -background red    -foreground white  -command "set retourCoche($w) Dismiss"
    pack   $w.buttons.dismiss -side left -expand 1
    button $w.buttons.defaut -text "Default"  -background yellow -foreground black  -command "set retourCoche($w) Defaut"
    pack   $w.buttons.defaut -side left -expand 1
    button $w.buttons.accept -text "Accept"   -background green  -foreground black  -command "set retourCoche($w) Accept"
    pack   $w.buttons.accept -side left -expand 1

    set i 0
    foreach a [Aligneurs] {
	set AligneursCochons($a) [Aligneurs $a]
	set b $w.b$a
	checkbutton $b -text "$a" -variable AligneursCochons($a) -relief flat
	pack $b -side top -pady 2 -anchor w
    }

    tkwait variable retourCoche($w)
    if { [set retourCoche($w)] == "Defaut" } {
	foreach a [Aligneurs] {
	    set AligneursCochons($a) [Aligneurs $a "Defaut"] 
	}
	while { [set retourCoche($w)] == "Defaut" } {
	    unset retourCoche($w)
	    tkwait variable retourCoche($w)
	}
    }
    if { [set retourCoche($w)] != "Dismiss" } {
	foreach a [Aligneurs] {
	    set Aligneurs($a) [set AligneursCochons($a)] 
	}
    }
    unset retourCoche($w)
    catch { unset $AligneursCoches }
    foreach a [Aligneurs] {
	if {[Aligneurs $a]} {
	    set AligneursCoches($a) 1
	}
    }
    destroy $w

}

proc CocheDansLaListe {Liste {CocheParDefaut ""}} {

    global retourCoche
    global VariableAssociee

    set w [NomDe coche]
    catch {destroy $w}
    toplevel $w
    wm title $w "Merci de cocher ..."
    wm iconname $w "Coche"
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.dismiss -text "Dismiss" -background red    -foreground white  -command "set retourCoche($w) Dismiss"
    pack   $w.buttons.dismiss -side left -expand 1
    button $w.buttons.defaut -text "Default"  -background yellow -foreground black  -command "set retourCoche($w) Defaut"
    pack   $w.buttons.defaut -side left -expand 1
    button $w.buttons.accept -text "Accept"   -background green  -foreground black  -command "set retourCoche($w) Accept"
    pack   $w.buttons.accept -side left -expand 1

    set d 0
    set i 0
    foreach a $Liste d $CocheParDefaut {
	if {$d==""} { set d 0 }
	set VariableAssociee($a) $d
	set b $w.b[incr i]
	checkbutton $b -text "$a" -variable VariableAssociee($a) -relief flat
	pack $b -side top -pady 2 -anchor w
    }

    tkwait variable retourCoche($w)

    if { [set retourCoche($w)] == "Defaut" } {
	foreach a $Liste d $CocheParDefaut {
	    if {$d==""} { set d 0 }
	    set VariableAssociee($a) $d 
	}
	while { [set retourCoche($w)] == "Defaut" } {
	    unset retourCoche($w)
	    tkwait variable retourCoche($w)
	}
    }
    if { [set retourCoche($w)] != "Dismiss" } {
	set LesChoisis {}
	foreach a $Liste {
	    if {[set VariableAssociee($a)]} {
		lappend LesChoisis $a
	    }
	}
    }
    unset retourCoche($w)
    destroy $w
    return $LesChoisis

}

proc CochonsLes {SesMachins SesMachinsDefaut} {

    upvar $SesMachins Machins
    upvar $SesMachinsDefaut MachinsDefaut
    global retourCoche
    global MachinsCochons 

    array set Machins [array get MachinsDefaut]

    set w [NomDe coche]
    catch {destroy $w}
    toplevel $w
    wm title $w "Merci de cocher ..."
    wm iconname $w "Coche"
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    button $w.buttons.dismiss -text "Dismiss" -background red    -foreground white  -command "set retourCoche($w) Dismiss"
    pack   $w.buttons.dismiss -side left -expand 1
    button $w.buttons.defaut -text "Default"  -background yellow -foreground black  -command "set retourCoche($w) Defaut"
    pack   $w.buttons.defaut -side left -expand 1
    button $w.buttons.accept -text "Accept"   -background green  -foreground black  -command "set retourCoche($w) Accept"
    pack   $w.buttons.accept -side left -expand 1

    set i 0
    foreach a [array names Machins] {
	set MachinsCochons($a) [set Machins($a)]
	set b $w.b$a
	checkbutton $b -text "$a" -variable MachinsCochons($a) -relief flat
	pack $b -side top -pady 2 -anchor w
    }

    tkwait variable retourCoche($w)
    if { [set retourCoche($w)] == "Defaut" } {
	array set MachinsCochons [array get MachinsDefaut]
	while { [set retourCoche($w)] == "Defaut" } {
	    unset retourCoche($w)
	    tkwait variable retourCoche($w)
	}
    }
    if { [set retourCoche($w)] != "Dismiss" } {
        array set Machins [array get MachinsCochons]
    }
    unset retourCoche($w)
    destroy $w
    return $SesMachins

}

proc CodageParCase {LesNoms aBin} {

    global GpesSequences LesCases Codage GpeCases
    upvar $aBin Bin
#    upvar $acodage_cases codage_cases
    
    #codage horizontal
    #chaque sequence est codee en fonction de la presence d'une majorite 
    #de 1 pour chacune des cases
    foreach Nom $LesNoms {
	set ListeIntermed [list]
	set NumeroCase 1
	foreach Case $LesCases {
	    set Somme 0
	    foreach Col $Case {
		incr Somme [set Bin($Nom,$Col)]
	    }
	    if {$Somme>=[expr [llength $Case]*0.8]} {
		lappend ListeIntermed 1
		set Codage($Nom,$NumeroCase) 1
	    } else {
		lappend ListeIntermed 0
		set Codage($Nom,$NumeroCase) 0
	    }
	    incr NumeroCase
	}
	set codage_cases($Nom) $ListeIntermed
#	puts [set codage_cases($Nom)]
    } 


    set type_cases [list]
    set diagnostic_case [list]
    for {set NumCase 1} {$NumCase<=[llength $LesCases]} {incr NumCase} {
	set ListeIntermed [list]
	foreach Gpe $GpesSequences {
	    set NumGpe 1
	    set Somme 0
	    foreach Nom $Gpe {
		incr Somme [set Codage($Nom,$NumCase)]
	    }	    
	    if {$Somme>=[expr 0.8*[llength $Gpe]]} {
		set CodageParGpe($NumGpe,$NumCase) 1
		lappend ListeIntermed 1
	    } elseif {$Somme==0} {
		set CodageParGpe($NumGpe,$NumCase) 0
		lappend ListeIntermed 0
	    } else {
		set CodageParGpe($NumGpe,$NumCase) 0.5
		lappend ListeIntermed 0.5
	    }
	}
	lappend type_cases $ListeIntermed
    }

}

proc CodageSeqParCase {LesNoms acodage_cases} {

    global LesCases Bin LesNoms
    upvar $acodage_cases codage_cases
    foreach Nom $LesNoms {
	set ListeIntermed [list]
	foreach Case $LesCases {
	    set Somme 0
	    set NumeroCase 1
	    foreach Col $Case {
		incr Somme [set Bin($Nom,$Col)]
	    }
	    if {$Somme>=[expr [llength $Case]*0.8]} {
		lappend ListeIntermed 1
		set Codage($Nom,$NumeroCase) 1
	    } else {
		lappend ListeIntermed 0
		set Codage($Nom,$NumeroCase) 0
	    }
	}
	set codage_cases($Nom) $ListeIntermed
    } 

}

proc CodeAffyHS {Nom} {

    set Rep "[GscopeDatabaseDir AffyHS]/nuctfa"
    foreach Fichier [glob -nocomplain "$Rep/*"] {
	set Contenu [ContenuDuFichier $Fichier]
	scan $Contenu "%s %s %s" codeGscope ac clone 
	regsub -all ">" $codeGscope "" codeGscope 
	if {$Nom==$codeGscope} {return $clone}
    }

}

proc CodeClone {Nom} {

    return [ExtraitInfo $Nom "CodeClone"]

}

proc CodeCloneDuAffymetrix {Affy} {

    
    set AssoAffy [AffymetrixAssocie]
    if {$AssoAffy=="NoAssociatedAffymetrix"} { return "NoAssociatedAffymetrix" }
    set CC [QuestionDeScience $AssoAffy "ret CodeClone $Affy"]
    return $CC

}

proc CodeClonePourTous {Liste {NomATraiter ""}} {

    if {$NomATraiter == "" && $Liste==""} {
	return "I need a gscopecode or a list of gscopecodes for argument"
    } 
    if {$NomATraiter!=""} {
	if {[regexp " " $NomATraiter]} {
	    regsub -all "  " $NomATraiter " " NomATraiter
	    set Liste [split $NomATraiter " "]
	} else {
	    set Liste [list $NomATraiter]
	}
    }
    foreach Nom $Liste {
	set Code [ExtraitInfo $Nom "CodeClone"]
	#Espionne $Code
	lappend LesCodes $Code
    }
    return $LesCodes

}

proc CodeCouleur_Human {} {

    set Fichier "/genomics/link/UCSCGenomes/Homo_sapiens/database/cytoBand.txt"
    set LesLignes [LesLignesDuFichier $Fichier]
    foreach Ligne $LesLignes {
	set LesMots [LesMotsDeLaLigne $Ligne]
	set Code [lindex $LesMots 4]
	lappend LesCodes $Code
    }
    set LesCodes [ListeSansDoublon $LesCodes]
    foreach elmt $LesCodes {puts $elmt}

}

proc CodeGenetique {{Qui ""} {Quoi ""}} {

    #rR CodeGenetique rend l'acide amine d'un codon, ou les codons d'un acide amine
    #rR               ou le code a 3 lettres d'un code a 1 lettre et inversement
    #rR               ou les listes de tout ca.
    #rR   A signifie acide amine a 1 lettre  (code par exemple M)
    #rR AAA signifie acide amine a 3 lettres (code par exemple Met)
    #rR Qui peut aussi etre ListOf
    #rR Quoi peut etre A AAA Codons
    global CodeGenetique

    #rR comportement par defaut 
    if {$Qui==""} { set Qui "ListOf"; set Quoi "Codons" }
    if {$Quoi=="" && [regexp -nocase {^[ATGC][ATGC][ATGC]$} $Qui]} { set Quoi "A" }
    if {[regexp -nocase "Codon" $Quoi]} { set Quoi "Codons" }
    if {$Quoi==""} { set Quoi "Codons" }

    #rR on regle le cas de majuscules minuscules pour un aa a 1 lettre un codon ou un aa a 3 lettres
    if {[regexp -nocase {^[A-Z][A-Z][A-Z]$}    $Qui]} { set Qui [string totitle $Qui] }
    if {[regexp -nocase {^[ATGC][ATGC][ATGC]$} $Qui]} { set Qui [string toupper $Qui] }
    if {[regexp -nocase {^[A-Z]$}              $Qui]} { set Qui [string toupper $Qui] }

    if {[info exists CodeGenetique($Qui,$Quoi)]}  { return $CodeGenetique($Qui,$Quoi) }
    if {[info exists CodeGenetique("EstCharge")]} {
	if {[regexp {^[ATGC][ATGC][ATGC]$} $Qui] && [info exists CodeGenetique($Qui,A)]} {
	    #rR pour un codon on rend les codons qui codent pour le meme A
	    set A $CodeGenetique($Qui,A)
	    if {[info exists CodeGenetique($A,$Quoi)]} { return $CodeGenetique($A,$Quoi) }
	}
	return ""
    }
    set CodeGenetique("EstCharge") 1

    #rR au premier appel on passe par ici pour charger le tout, puis plus jamais.
    set FichierCodeGenetique "[GscopeEtc]/gscope_codegenetique.txt"

    set AllCodons                 {}
    set CodeGenetique(ListOf,A)   {}
    set CodeGenetique(ListOf,AAA) {}
    foreach Ligne [LesLignesDuFichier $FichierCodeGenetique] {
	regsub -all { +} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }

	set LesMots [LesMotsDeLaLigne $Ligne]
	set A   [string toupper [lindex $LesMots 0]]
	set AAA [string totitle [lindex $LesMots 1]]
	if {$A=="*"} { set A "X" }

	set CodeGenetique($A,Codons)   {}
	set CodeGenetique($AAA,Codons) {}
	set LesCodons {}
	foreach Codon [lrange $LesMots 2 end] {
	    set Codon [string toupper $Codon]
	    if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue }
	    lappend AllCodons $Codon
	    lappend LesCodons $Codon
	    set CodeGenetique($Codon,A)   $A
	    set CodeGenetique($Codon,AAA) $AAA
	    lappend CodeGenetique($A,Codons)   $Codon
	    lappend CodeGenetique($AAA,Codons) $Codon
	}
	if {$LesCodons=={}} { continue }

	lappend CodeGenetique(ListOf,A)   $A
	lappend CodeGenetique(ListOf,AAA) $AAA
	set CodeGenetique($A,A)   $A
	set CodeGenetique($AAA,A) $A
	set CodeGenetique($A,AAA)   $AAA
	set CodeGenetique($AAA,AAA) $AAA
    }
    set CodeGenetique(ListOf,Codons) [lsort $AllCodons]

    #rR maintenant tout est charge. On rappelle recursivement la fonction
    return [CodeGenetique $Qui $Quoi]

}

proc CodeMutation {Nom {Quoi ""}} {

    if {$Quoi==""} { set Quoi "CodeOnly" }
    set Mut [ExtraitInfo $Nom "Muted:"]
    if {$Quoi=="All"} {return $Mut}
    if {$Mut==""} { return "" }
    regsub {mutation of PGS[0-9]+ [^ ]+ } $Mut "" CodeMutation
    return $CodeMutation

}

proc CodeSecret {Code {V ""}} {

    global CodeSecret
    if {$Code=="Enter"} { set CodeSecret "" ; return }
    if {$Code=="Leave"} { set CodeSecret "" ; return }
    append CodeSecret $Code
    switch $CodeSecret {
	"00" { Boum }
	"10" { Boum }
	"0100" { eval [Entre] }
	"0101" { AfficheLesProcs }
	"0110" { DemandeEtExecute }
	"111000000" { AfficheLesBoutonsNonOpen $V}
	"111000111" { AfficheLaProc CodeSecret }
	default {}
    }
    return $CodeSecret

}

proc Codon2AA {Codon} {

    global TabCodeGenetique
    set Codon [string toupper [join $Codon ""]]

    if {[string length $Codon] != 3} {return}
    
    if {[info exists TabCodeGenetique]} {
	if {![info exists TabCodeGenetique($Codon)]} {return "X"}
	return [set TabCodeGenetique($Codon)]
    }
    set ListeDesCodons {}
    set ListeDesAA     {}
    lappend ListeDesCodons UUU UUC UUA UUG UCU UCC UCA UCG UAU UAC UAA UAG UGU UGC UGA UGG
    lappend ListeDesAA     F   F   L   L   S   S   S   S   Y   Y   "*" "*" C   C   "*" W
    
    lappend ListeDesCodons CUU CUC CUA CUG CCU CCC CCA CCG CAU CAC CAA CAG CGU CGC CGA CGG 
    lappend ListeDesAA     L   L   L   L   P   P   P   P   H   H   Q   Q   R   R   R   R

    lappend ListeDesCodons AUU AUC AUA AUG ACU ACC ACA ACG AAU AAC AAA AAG AGU AGC AGA AGG
    lappend ListeDesAA     I   I   I   M   T   T   T   T   N   N   K   K   S   S   R   R
    
    lappend ListeDesCodons GUU GUC GUA GUG GCU GCC GCA GCG GAU GAC GAA GAG GGU GGC GGA GGG
    lappend ListeDesAA     V   V   V   V   A   A   A   A   D   D   E   E   G   G   G   G

    foreach Cod $ListeDesCodons AA $ListeDesAA {
	set TabCodeGenetique($Cod) $AA
	regsub -all "U" $Cod "T" Cod
	set TabCodeGenetique($Cod) $AA
    }
    return [Codon2AA $Codon]

}

proc CodonStart {Nom} {

    set Valeur [ExtraitInfo $Nom "CodonStart"]

    Wup "To remove old frameshifts"
    set LesCS {}
    foreach Champ [split $Valeur "/"] {
	if {[regexp "erreur de sequence" $Champ]} { continue }
	lappend LesCS $Champ
    }
    return [join $LesCS "/"]

    Wup "Je ne veux plus les vieux CodonStart1"
    set Valeur2 [ExtraitInfo $Nom "CodonStart1"]
    if { $Valeur1 == "" && $Valeur2 == ""} { return "" }
    return "$Valeur1 / $Valeur2"

}

proc CodonStartPossible {Codon} {

    global CodonStartPossible
    global RepertoireDuGenome

    Wup "Return 1 if Codon is a valid start codon"

    if { ! [info exists CodonStartPossible]} {
	set Fichier "$RepertoireDuGenome/fiches/codonstartpossible"
	while { ! [file exists $Fichier]} {
	    if {[OuiOuNon "For Possible Start Codon ... \nThe file $Fichier does'nt exists.\nDo you want to create it ?"]} {
		set Possibles [string trim [Entre "ATG TTG GTG"]]
		while {[regexp "  " $Possibles]} { regsub "  " $Possibles " " Possibles }
		if {$Possibles == ""} { continue }
		regsub -all " " $Possibles "\n" Possibles
		Sauve $Possibles dans $Fichier
	    } else {
		if {[OuiOuNon "Do I exit ? "]} { exit }
		if {[OuiOuNon "Do I continue without creating $Fichier ? "]} { return {} }
	    }
	}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    lappend CodonStartPossible $Ligne
	}
    }

    if {$Codon=="LaListeMerci"} { return $CodonStartPossible }

    foreach Possible $CodonStartPossible {
	if { ! [string compare -nocase $Possible $Codon]} { return 1 }
    }
    return 0

}

proc CodonStopPossible {Codon} {

    global CodonStopPossible
    global RepertoireDuGenome

    Wup "Return 1 if Codon is a valid stop codon"

    if { ! [info exists CodonStopPossible]} {
	set Fichier "$RepertoireDuGenome/fiches/codonstoppossible"
	while { ! [file exists $Fichier]} {
	    if {[OuiOuNon "For Possible Stop Codon ... \nThe file $Fichier doen't exists.\nDo you want to create it ?"]} {
		set Possibles [string trim [Entre "TAA TAG TGA"]]
		regsub -all { +} $Possibles " " Possibles
		if {$Possibles == ""} { continue }
		regsub -all " " $Possibles "\n" Possibles
		Sauve $Possibles dans $Fichier
	    } else {
		if {[OuiOuNon "Do I exit ? "]} { exit }
		if {[OuiOuNon "Do I continue without creating $Fichier ? "]} { 
		    #lm doit retourner un boolean
		    #return {} 
		    return 0
		}
	    }
	}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    lappend CodonStopPossible $Ligne
	}
    }
    
    if {$Codon=="LaListeMerci"} { return $CodonStopPossible }

    foreach Possible $CodonStopPossible {
	if { ! [string compare -nocase $Possible $Codon]} { return 1 }
    }
    return 0

}

proc CodonW {} {

    global RepertoireDuGenome


    set TFA [CreeTfaPourCodonw]

    set RepCodonw "$RepertoireDuGenome/codonw" 
    set  FichierCAI "$RepCodonw/cai.def"
    if { ! [file exists $FichierCAI]} {
	Sauve "$TFA\n$FichierCAI" dans "$RepCodonw/cai.input"
	catch {exec cai < "$RepCodonw/cai.input" >& "$RepCodonw/cai.log"}
	if { ! [file exists $FichierCAI]} {
	    FaireLire "Problem with cai. I could'nt create $FichierCAI\nDid You setcodonw ?"
	    return ""
	}
    }
    return $FichierCAI

}

proc CodonsDeProt {what {pk ""}} {

    if {$what eq "sauve"} {
	set ins "insert into codons values($pk"
	foreach a1 {A T G C} {
	    foreach a2 {A T G C} {
		foreach a3 {A T G C} {
		    set cdn "$a1$a2$a3"
		    global $cdn
		    append ins ",[set $cdn]"
		}
	    }
	}
	append ins ")"
	$::dcdn eval $ins
    } else {
	foreach a1 {A T G C} {
	    foreach a2 {A T G C} {
		foreach a3 {A T G C} {
		    set cdn "$a1$a2$a3"
		    global $cdn
		    set $cdn 0
		}
	    }
	}
    }

    return

}

proc CodonsDuAA {AA} {

    return [CodeGenetique $AA Codons]

}

proc CodonsRares {Seq {SansZero ""} {args ""}} {


    if {$args==""} {
#	set LesRares {AGG AGA CGA CTA ATA CCC TAA TAG TGA}
	set LesRares {AGG AGA CGA CTA ATA CCC}
    } else {
	set LesRares $args
    }

    if {$Seq=="LaListeMerci"} { return $LesRares }
    if {$SansZero=="AvecBlanc"} { set AvecBlanc 1 } else { set AvecBlanc 0 }
    if {$SansZero=="" || $SansZero=="SansZero"} {
	set SansZero 1
    } else {
	set SansZero 0
    }	

    set Seq [string toupper $Seq]
    set L [string length $Seq]
    set M [expr $L%3]
    set Seq [string range $Seq 0 end-$M]


    foreach Rare $LesRares {
	set Compte($Rare) 0
    }

    foreach {a b c} [split $Seq ""] {
	set Codon "$a$b$c"
	if {[info exists Compte($Codon)]} { incr Compte($Codon)}
    }
    set LaSortie {}
    foreach Rare $LesRares {
	set N [set Compte($Rare)]
	if {$SansZero && $N==0} { continue }
	if {$AvecBlanc && $N==0} { lappend LaSortie "     " ; continue }
	lappend LaSortie "${N}_$Rare"
    }
    return [join $LaSortie " "]

}

proc CoefficientCorrelation {lx ly} {

    # Ici lx et ly doivent etre de meme longueur
    if {[llength $lx] != [llength $ly]} {
	return ""
    }

    # Calcule moyenne de x et y, 
    # somme des x2 , y2
    # somme des xy
    #
    # coef.corr = cov(x,y)/(sigx*sigy)
    set sx 0.  ; set sy 0.
    set s2x 0. ; set s2y 0.
    set sxy 0.
    set N [llength $lx]
    foreach x $lx y $ly {
	set sx  [expr {$sx + $x}]
	set sy  [expr {$sy + $y}]
	set sxy [expr {$sxy + $x*$y}]
	set s2x [expr {$s2x + $x*$x}]
	set s2y [expr {$s2y + $y*$y}]
    }
    set mx [expr {$sx/$N}]
    set my [expr {$sy/$N}]
    set ex [expr {sqrt($s2x/$N-$mx*$mx)}]
    set ey [expr {sqrt($s2y/$N-$my*$my)}]
    set c  [expr {($sxy/$N-$mx*$my)/($ex*$ey)}]

    return $c

}

proc CoherenceDesFamilles {} {


    set FichierCoherenceDesFamilles "[RepertoireDuGenome]/xhda/coherence_des_familles"

    foreach Famille [ListeDesFamilles] {
	set LesChefsDeFamille $Famille
	set LesMembres [LesMembresDeLaFamille $Famille]
	Espionne "\n\nVcho $LesMembres"
	if {$LesMembres=={}} { continue }
	catch {unset MesPABs}
	catch {unset SesPABs}
	set LesPABs {}
	foreach {GDB Membre} $LesMembres {
	    lappend LesPABs $Membre
	    set EstMembre($Famille,$Membre) 1
	}
	foreach {GDB Membre} $LesMembres {
	    set SesMembres [QuestionDeScience $GDB "ret LesMembresDeLaFamille $Membre"]
	    if {$SesMembres=={}} { continue }
	    set Chef $Membre
	    lappend LesChefsDeFamille $Chef
	    foreach {GDBautre Autre} $SesMembres {
		lappend LesPABs $Autre
		set EstMembre($Chef,$Autre) 1
	    }
	}
	set LesChefsDeFamille [lsort -unique $LesChefsDeFamille]
	set LesPABs [lsort -unique $LesPABs]
	set LesLignes {}
	foreach Chef $LesChefsDeFamille {
	    set Ligne [format "%9s :" $Chef]
	    foreach PAB $LesPABs {
		regsub -all "." $PAB "." Vide
		if {[info exists EstMembre($Chef,$PAB)]} {
		    set Mot $PAB
		} else {
		    set Mot $Vide
		}
		append Ligne " $Mot"
	    }
	    lappend LesLignes "$Famille $Ligne"
	}
	Espionne ""
	EspionneL $LesLignes
	set Texte [join $LesLignes "\n"]
	AppendAuFichier $FichierCoherenceDesFamilles $Texte
    }

}

proc ColMore {Repertoire} {


#Rajoute une donnée (colonne) dans un fichier a partir d'une partie du nom du fichier

	foreach Fichier [glob -tails -directory $Repertoire "*.cons"] {
		
		set FichierOut [open "/genomics/link/STAF/fiches/VDR/Consensus/WC/$Fichier" "w"]
		regexp {Chr([0-9]{1,2}|X|Y)} $Fichier Toto Chromosome
		regexp {DR([0-9]{1})} $Fichier Tata DR
		set FichierIn [open "$Fichier" "r"]
		while { [gets $FichierIn Ligne]  >=0 } {
			puts $FichierOut "chr$Chromosome DR$DR $Ligne"
		}
		close $FichierOut
	}

}

proc CollapseAllTaxInternal {} {

    foreach k [array names ::Tx "ShowInt,*"] {
	set ::Tx($k) 0
    }
    DrawTaxo

    return

}

proc CollapseBranche {AId n} {

    set t [set ::Abr(Arbre,$AId)]
    if {[$t isleaf $n]} {return}
    
    foreach e [$t children $n] {
	CollapseBranche $AId $e
    }
    if {$n eq "root"} {return}
    if {[$t get $n nboot] < [set ::Abr($AId,ThresBoot)]} {
	$t cut $n
	#CollapseDescendants $AId $n
    }

    return

}

proc CollapseDescendants {AId n} {

    set t [set ::Abr(Arbre,$AId)]
    foreach c [$t descendants $n] {
	if {! [$t isleaf $c]} {
	    $t cut $c
	}
    }

    return

}

proc CollapseTree {AId} {

    global Abr

    if {! [set Abr($AId,BootDone)]} {return}
    if {[set Abr($AId,CollapseTree)]} {
	CollapseBranche $AId root
    } else {
	set t [set Abr(Arbre,$AId)]
	set Ser [set Abr(ArbreSer,$AId)]
	$t destroy
	struct::tree $t
	$t deserialize $Ser
	$t set root r 0.0
	$t set root theta 0.0
	$t set root oldtheta 0.0
	$t set root length 0.0
	$t set root width [llength [$t leaves]]
    }

    OnReDessineArbre $AId

    return

}

proc Colle {w} {

    global xPointDeRaccord yPointDeRaccord DejaEmpiles
    global GalerieCourante
    global ExpoCourante

    set LargeurDuMotif [LargeurDe $w]
    set HauteurDuMotif [HauteurDe $w]
    set OnEnEmpile 4
    set HauteurDuLe [expr $OnEnEmpile*$HauteurDuMotif]

    if { ! [info exists xPointDeRaccord] } {
	set DejaEmpiles 0
	set xPointDeRaccord 0
	set yPointDeRaccord 0
    } else {
	incr DejaEmpiles
	incr yPointDeRaccord $HauteurDuMotif
    }
    if { $DejaEmpiles >= $OnEnEmpile } {
	set DejaEmpiles 0
	set yPointDeRaccord 0
	incr xPointDeRaccord $LargeurDuMotif
	set ScrollRegion [$GalerieCourante.frame.mur cget -scrollregion]
	set SR0 [lindex $ScrollRegion 0]
	set SR1 [lindex $ScrollRegion 1]
	set SR2 [lindex $ScrollRegion 2]
	set SR3 [lindex $ScrollRegion 3]
	$GalerieCourante.frame.mur configure  -width "[expr $SR2 + $LargeurDuMotif]"  -height "$HauteurDuLe"
	$GalerieCourante.frame.mur configure  -scrollregion "$SR0 $SR1 [expr $SR2 + $LargeurDuMotif] $HauteurDuLe"
    }

    $GalerieCourante.frame.mur create window  $xPointDeRaccord $yPointDeRaccord  -window $w -anchor nw

}

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 CollectionDeNucAPartirDeProtTFA {Nom} {

    global RepertoireDuGenome

    set Var         0.05

    set Expect      10-3
    set EditCommand 0
    set NbSbjct     20
    set Filtre      1

    set FichierProtTFA "$RepertoireDuGenome/prottfa/$Nom"
    if {![file exists $FichierProtTFA]} {Espionne "$Nom -> no mrna selected";return}

    set RepBlastP     "$RepertoireDuGenome/blastpinitial"
    if {![file exists $RepBlastP]} {File mkdir $RepBlastP}
    set FichierBlastP "$RepBlastP/$Nom"

    set RepNucTFA     "$RepertoireDuGenome/nuctfa"
    if {![file exists $RepNucTFA]} {File mkdir $RepNucTFA}
    set FichierNucTFA "$RepNucTFA/$Nom"

    set RepNucEMBL     "$RepertoireDuGenome/nucembl"
    if {![file exists $RepNucEMBL]} {File mkdir $RepNucEMBL}
    set FichierNucEMBL "$RepNucEMBL/$Nom"

    if {![file exists $FichierBlastP]} {
	Espionne "$Nom -> BlastP"
	BlastPPourBallast $FichierProtTFA $FichierBlastP $EditCommand protein $Expect $Filtre $NbSbjct
    }
    DepouilleLeBlast TabBlast $FichierBlastP
    if {![info exists TabBlast(NbSubject)]} {Espionne "$Nom -> no mrna selected";return}

    set LesProteines {}
    set NMax         0
    set NbSubject [set TabBlast(NbSubject)  ]
    for {set i 1} {$i <= $NbSubject} {incr i} {
	set BIdProt    [set TabBlast($i) ]
	set N  [NombreDeBasesEnCommun_TabBlast      TabBlast $BIdProt]
	set Id [PourcentageDIdentiteGlobal_TabBlast TabBlast $BIdProt]
	lappend LesProteines [list $BIdProt $N $Id]

	if {$NMax < $N} {set NMax $N}
    }	
    set NMaxMin [expr $NMax * (1 - $Var)]

    if {$LesProteines == {}} {Espionne "$Nom -> no mrna selected";return}

    set AccessmRNA ""
    foreach LaProteine [lsort -integer -index 1 -decreasing [lsort -real -index 2 -decreasing $LesProteines]] {
	set N       [lindex $LaProteine 1]
	if {$N < $NMaxMin} {continue}
	set BIdProt [lindex $LaProteine 0]
	set Id      [lindex $LaProteine 2]
	Espionne "$Nom -> $BIdProt have [expr $Id*100] % of identity with $FichierProtTFA  and $N AA in common."	
	Espionne "$Nom -> searching the mRNA RefSeq in $BIdProt"
	set AccessmRNA [LemRNADeLAccessProt $BIdProt]
	if {$AccessmRNA != ""} {set BIdProtDeRef $BIdProt;break}
    }

    if {$AccessmRNA == ""} {Espionne "$Nom -> no mrna selected";return}
    set Seq [QueLaSequenceDuTexteTFA [PageInfo $AccessmRNA "genbank" "seq"]]
    if {$Seq == ""} {Espionne "$Nom -> no mrna selected";return}
    set LesOrgas [LesOrgasDeLAccess $AccessmRNA]
 
    if {[OrganismeDuPAB $Nom] == "NotYetAffected"} {
	AppendAuFichier "$RepertoireDuGenome/fiches/organismesdespabs" "$Nom [join $LesOrgas ":"]"
    }
    set Entete ">$Nom $AccessmRNA mRNA of $BIdProtDeRef"
 
    Sauve [SequenceFormatTFA  $Seq $Entete] dans $FichierNucTFA
    Sauve [SequenceFormatEMBL $Seq        ] dans $FichierNucEMBL
    return

}

proc CollectionDeNucAPartirDeProtTFAPourTous {{LesNoms ""}} {

    global RepertoireDuGenome

    set RepNucTFA     "$RepertoireDuGenome/nuctfa"
    if {![file exists $RepNucTFA]} {File mkdir $RepNucTFA}

    if {[llength [glob -nocomplain "$RepNucTFA/*"]] > 0 && ![OuiOuNon "Some files exist in $RepNucTFA, would you want to conserv them?"]} {
	set ReInitialise 1
    } else {
	set ReInitialise 0
    }
    if {$LesNoms == {}} {set LesNoms [ListeDesPABs]}
    foreach Nom $LesNoms {
	if {!$ReInitialise && [file exists "$RepNucTFA/$Nom"]} {continue}
	CollectionDeNucAPartirDeProtTFA $Nom
    }
    return ""

}

proc ColonneDuMet {LesNoms aBin} {

    global PremiereColPleine GpesColonnes LesCases GpeCases TabCol
    upvar $aBin Bin
    if {$PremiereColPleine==-1} {
	set Min -1
	foreach gpe $GpesColonnes {
	    set i [lindex $gpe 0]
	    set Somme 0
	    foreach nom $LesNoms {
		incr Somme [set Bin($nom,$i)]
	    }
	    if {$Somme>$Min} {
		set Min $Somme
		set ColMax $i
	    }
	}
	set PremiereColPleine $ColMax
    }  	
    set GpeColPleine [set TabCol($PremiereColPleine)]
    return [lindex [lindex $LesCases [lsearch $GpeCases $GpeColPleine]] 0] 

}

proc ColonneOverlap {v1 v2 ang1 ang2 ec1 ec2} {

    set v1 [V_nV $v1]
    lassign $v1 x1 y1
    set a1 [expr {atan2($y1,$x1)}]
    #puts "a1ori $a1"
    set a1p $a1
    if {$a1p < 0.0} {
	set a1p [expr {$a1p + [2Pi]}]
    }

    set v2 [V_nV $v2]
    lassign $v2 x2 y2
    set a2 [expr {atan2($y2,$x2)}]
    #puts "a2ori $a2"
    set a2p $a2
    if {$a2p < 0.0} {
	set a2p [expr {$a2p + [2Pi]}]
    }
    #puts "a1p $a1p"
    #puts "a2p $a2p"

    # renverse
    if {$a2p > $a1p} {
	#puts "inverse a1 <-> a2"
	set tmp $a1 ; set a1 $a2 ; set a2 $tmp
	set tmp $a1p ; set a1p $a2p ; set a2p $tmp
	set tmp $ang1 ; set ang1 $ang2 ; set ang2 $tmp
	set tmp $ec1 ; set ec1 $ec2 ; set ec2 $tmp
    }

    # Cas special de Pi
    if {$a1p eq [Pi] &&  $a2 < 0.} {
	#puts "-> a1p Pi"
	set a1 -$a1
    }
    if {$a2p eq [Pi] &&  $a1 < 0.} {
	#puts "-> a2p Pi"
	set a2 -$a2
    }

    set a1m [expr {$a1p - $ang1}]
    set a1x [expr {$a1p + $ang1}]
    set a2m [expr {$a2p - $ang2}]
    set a2x [expr {$a2p + $ang2}]
    foreach v {a1m a1x a2m a2x} {
	if {[set $v] < 0.0} {
	    set $v [expr {[2Pi] - [set $v]}]
	}
	if {[set $v] > [2Pi]} {
	    set $v [expr {[set $v] - [2Pi]}]
	}
	if {[set $v] > [Pi]} {
	    #set $v [expr {[2Pi] - [set $v]}]
	}
    }

    puts ""
    puts "a1 $a1 a1p $a1p ang1 $ang1"
    puts "a1m $a1m a1x $a1x"
    puts "a2 $a2 a2p $a2p ang2 $ang2"
    puts "a2m $a2m a2x $a2x"
    if {($a1m - $a2x) < 0.0} {
	# overlap
	return 1
    } else {
	return 0
    }

}

proc ColorChainNwOj {what} {

    global NwOj NwOjR TabSF

    set can $NwOj(Can)
    if {$NwOj(ColorSel) eq "None"} {
	set col couldefond
    } elseif {$NwOj(ColorSel) eq "More ..."} {
	set col [tk_chooseColor]
	if {$col eq ""} {return}
	set NwOj(ColorSel) $col
    } elseif {$NwOj(ColorSel) eq "Feature Color" && $what ne "feature"} {
	return
    } else {
	set col $NwOj(ColorSel)
	if {$col eq "green"} {set col green1}
    }

    set chn $NwOj(Chain)
    switch $what {
	"all" {
	    foreach e [array names NwOjR "${chn},*"] {
		lset NwOjR($e) 2 $col
	    }
	}
	"selected" {
	    set Li [$can find withtag Selected]
	    foreach i $Li {
		set Lt [$can gettags $i]
		set nb [lsearch -inline -regexp $Lt {^Nbr}]
		set n [string range $nb 3 end]
		lset NwOjR($chn,$n) 2 $col
	    }
	    ClearSelectionNwOj
	}
	"feature" {
	    if {$NwOj(FeatCol) eq "None"} {return}
	    set feat $NwOj(FeatCol)
	    set mol $NwOj(Mol)
	    set chn $NwOj(Chain)
	    set nom [BonNomPDB "${mol}_$chn"]
	    set ft [info exists TabSF($nom,$feat)]
	    if {! $ft} {return}
	    foreach e [set TabSF($nom,$feat)] {
		DecortiqueUneFeature $e d f fcol sc note
		if {$NwOj(ColorSel) eq "Feature Color"} {
		    set col $fcol
		}
		# Special case for Discri
		# don't take if indel present
		if {[regexp -nocase {^indel} $note]} {
		    continue
		}
		for {set i $d} {$i <= $f} {incr i} {
		    set n [DonnePosGS $nom $i]
		    lset NwOjR($chn,$n) 2 $col
		}
	    }
	}
    }

    CanvasDeChaine

    return

}

proc ColorFromHSB {H S B} {

    set rgb [hsbToRgb $H $S $B]
    lassign $rgb r g b
    set color [format "#%04x%04x%04x" $r $g $b]
    return $color

}

proc ColorHexa {name} {

    if {[string index $name 0] != "#"} {
	set list [winfo rgb . $name]
	set red   [lindex $list 0]
	set green [lindex $list 1]
	set blue  [lindex $list 2]
	set shift 8
    } else {
	case [string length $name] {
	     4 {set format "#%1x%1x%1x" ; set shift -4}
	     7 {set format "#%2x%2x%2x" ; set shift 0}
	    10 {set format "#%3x%3x%3x" ; set shift 4}
	    13 {set format "#%4x%4x%4x" ; set shift 8}
	    default {error "syntax error in color name \"$name\""}
	}
	if {[scan $name $format red green blue] != 3} {
	    error "syntax error in color name \"$name\""
	}
    }
    if {$shift>=0} {
	set red   [expr $red   >> $shift]
	set green [expr $green >> $shift]
	set blue  [expr $blue  >> $shift]
    } else {
	set red   [expr ($red   << -$shift) + $red]
	set green [expr ($green << -$shift) + $green]
	set blue  [expr ($blue  << -$shift) + $blue]
    }
    set color [format "#%02x%02x%02x" $red $green $blue]
    return $color

}

proc ColorOfPfam {FileMacsimsXml Pfam} {

    package require tdom

    set FileMacsimsXml [TheTrueMacsimsFile $FileMacsimsXml]
    set fh [open $FileMacsimsXml "r"]
    dom parse -channel $fh doc
    close $fh
    $doc documentElement root

    foreach seq [$root selectNodes "//sequence"] {
	foreach noeud_PFAM [$seq selectNodes ".//fitem\[ftype=\"PFAM-A\"\]"] {
	    set PFAM [$noeud_PFAM selectNodes "string(./fnote)"]
	    set Color [$noeud_PFAM selectNodes "string(./fcolor)"]
	    if {[regexp "$Pfam" $PFAM]} {
		$doc delete 
		return $Color
	    }
	}
    }   
    $doc delete

}

proc ColorationDesClustersXHdaDesNomsPiques {Nom {Quoi Couleur}} {

    global ColorationDesClustersXHda

    JeMeSignale

    if {$Nom=="Reset" && [info exists ColorationDesClustersXHda]} {
	unset ColorationDesClustersXHda
	return 
    }

    if {[info exists ColorationDesClustersXHda($Nom,$Quoi)]} {
	return  [set ColorationDesClustersXHda($Nom,$Quoi)]
    }

    if {[info exists ColorationDesClustersXHda]} {
	if {[info exists ColorationDesClustersXHda("EstCharge",$Quoi)]} {
	    return  [set ColorationDesClustersXHda("EstCharge",$Quoi)]
	} else {
	    return "lightgrey"
	}
    }

    set ColorationDesClustersXHda("EstCharge",Couleur) "grey"
    set ColorationDesClustersXHda("EstCharge",Signif)  "not_in_same_cluster"

    set LesPiques [LesNomsPiques]
    if {$LesPiques=={}} {
	set ColorationDesClustersXHda("EstCharge",Couleur) "white"
	set ColorationDesClustersXHda("EstCharge",Signif)  "no_reference_was_choosen"
	return [ColorationDesClustersXHdaDesNomsPiques $Nom $Quoi]
    }
    
    set n [llength $LesPiques]
    set LesCouleurs [CouleursDuBleuAuRouge $n]
    
    foreach Pique $LesPiques Couleur $LesCouleurs {
	set Signif "same cluster as $Pique"
	set LeClusterXHda [LeClusterXHda $Pique]
	if {$LeClusterXHda=={}} { continue }
	set Premier [lindex $LeClusterXHda 0]
	if {[info exists DejaVu($Premier)]} { continue }
	set DejaVu($Premier) $Pique
	foreach PAB $LeClusterXHda {
	    set ColorationDesClustersXHda($PAB,Couleur) $Couleur
	    set ColorationDesClustersXHda($PAB,Signif)  $Signif
	}
    }
    return [ColorationDesClustersXHdaDesNomsPiques $Nom $Quoi]

}

proc ColorationsPossibles {{SansTamis ""} {QueVeutOn ""}} {

    global LesColorationsPossibles LesColorationsPossiblesRangs

    set OnVeutLesRangs [string equal $QueVeutOn "OnVeutLesRangs"] 

    if { ! $OnVeutLesRangs && [info exists LesColorationsPossibles]} {
	return $LesColorationsPossibles
    }
    if { $OnVeutLesRangs && [info exists LesColorationsPossiblesRangs]} {
	return $LesColorationsPossiblesRangs
    }
    foreach Ligne [split [info body CouleurParTypeEtNom] "\n"] {
	if {[PourWscope] && [regexp "\#.* noWeb" $Ligne]} { continue }
	if { ! [regexp {\"Coloration_[^\$][^\"]+} $Ligne CoCo]} { continue }
	set Rang 9.9
	if {[regexp "\#" $Ligne]} { set Rang [FloatApres "\#" dans $Ligne] }
	if {$SansTamis!="" && [regexp "FromTamis" $Ligne]} { continue }
	regsub {\"Coloration_} $CoCo "" Coloration
	lappend LesRangCol "$Rang $Coloration"
    }
    set LesRangCol [lsort -command CompareLesFloatsEnDebut $LesRangCol]
    foreach RangCol $LesRangCol {
	scan $RangCol "%f %s" Rang Col
	lappend LesColorationsPossibles $Col
	lappend LesColorationsPossiblesRangs $Rang
    }
    if {$OnVeutLesRangs} {
	return $LesColorationsPossiblesRangs
    } else {
	return $LesColorationsPossibles
    }

}

proc ColoriageDeLIdDeDrawBlast {Id} {

    global LesCouleursDeLaGammeDeLId
    if {![info exists LesCouleursDeLaGammeDeLId]} {
	set LesCouleursDeLaGammeDeLId [GammeDeCouleurBlancVersRouVouB V 5]
    }
    if {0.90 < $Id} {return [lindex $LesCouleursDeLaGammeDeLId 4]}
    if {0.80 < $Id} {return [lindex $LesCouleursDeLaGammeDeLId 3]}
    if {0.60 < $Id} {return [lindex $LesCouleursDeLaGammeDeLId 2]}
    if {0.30 < $Id} {return [lindex $LesCouleursDeLaGammeDeLId 1]}
    return [lindex $LesCouleursDeLaGammeDeLId 0]

}

proc ColoriageDeLaFrequence {Frequence} {

    set NTot 7.0
    if {$Frequence == 0} {
	set ColorFill "lightgrey"
	return $ColorFill
    } elseif {$Frequence == "N"} {
	set ColorFill "black"
	return $ColorFill
    } elseif {$Frequence == 1} {
	set n 1.0
    } elseif  {2   <= $Frequence && $Frequence <= 3  } {
	set n 2.0
    }  elseif {4   <= $Frequence && $Frequence <= 10 } {
	set n 3.0
    }  elseif {11  <= $Frequence && $Frequence <= 50 } {
	set n 4.0
    }  elseif {51  <= $Frequence && $Frequence <= 100} {
	set n 5.0
    }  elseif {101 <= $Frequence && $Frequence <= 200} {
	set n 6.0
    }  elseif {200 <= $Frequence} {
	set n 7.0
    }
    set Valeur [expr $n/$NTot]
    set ColorFill [Nuance $Valeur 0.0 0.987]
    return $ColorFill

}

proc ColoriageDeLaFrequenceDeDrawBlast {Frequence} {

    global LesCouleursDeLaGammeDeLaFreq
    if {![info exists LesCouleursDeLaGammeDeLaFreq]} {
	set LesCouleursDeLaGammeDeLaFreq [GammeDeCouleurBlancVersRouVouB B 8]
    }
    if {200 <=  $Frequence                    } {return [lindex $LesCouleursDeLaGammeDeLaFreq 7]}
    if {100 <= $Frequence && $Frequence <  200} {return [lindex $LesCouleursDeLaGammeDeLaFreq 6]}
    if {50  <= $Frequence && $Frequence <  100} {return [lindex $LesCouleursDeLaGammeDeLaFreq 5]}
    if {10  <= $Frequence && $Frequence <  50 } {return [lindex $LesCouleursDeLaGammeDeLaFreq 4]}
    if {4   <= $Frequence && $Frequence <  10 } {return [lindex $LesCouleursDeLaGammeDeLaFreq 3]}
    if {2   <= $Frequence && $Frequence <  4  } {return [lindex $LesCouleursDeLaGammeDeLaFreq 2]}
    if {1   <= $Frequence && $Frequence <  2  } {return [lindex $LesCouleursDeLaGammeDeLaFreq 1]}
    return [lindex $LesCouleursDeLaGammeDeLaFreq 0]

}

proc ColoriageDesExons {Type Sens} {

    if {$Type == "EXON"} {
	if {$Sens == "+"} {
	    set ColorFill "blue"
	} else {
	    set ColorFill "red"
	}
    } elseif {$Type == "REPEAT"} {
	set ColorFill "green"
    } elseif {$Type == "ABSENT"} {
	set ColorFill "lightgrey"
    }
    return $ColorFill

}

proc ColoriageDuMapping {TypeRegion} {

    if {$TypeRegion == "Plus / Plus"} {
	set ColorFill "blue"
    } elseif {$TypeRegion == "Plus / Minus"} {
	set ColorFill "red"
    } elseif {$TypeRegion == "N"} {
	set ColorFill "black"
    } elseif {$TypeRegion == "RAS"} {
	set ColorFill "lightgrey"
    } elseif {$TypeRegion == "+1"} {
	set ColorFill "DodgerBlue1"
    } elseif {$TypeRegion == "+2"} {
	set ColorFill "blue1"
    } elseif {$TypeRegion == "+3"} {
	set ColorFill "blue4"
    } elseif {$TypeRegion == "-1"} {
	set ColorFill "red1"
    } elseif {$TypeRegion == "-2"} {
	set ColorFill "red3"
    } elseif {$TypeRegion == "-3"} {
	set ColorFill "red4"
    } elseif {$TypeRegion == "Prot / Prot"} {
	set ColorFill "orange"
    } elseif {[regexp "\[1-3\+]{2} / \[1-3\+]{2}" $TypeRegion]} {
	set ColorFill "DarkOrchid"
    } elseif {[regexp "\[1-3\+]{2} / \[1-3\-]{2}" $TypeRegion]} {
	set ColorFill "MediumOrchid"
    } elseif {[regexp "\[1-3\-]{2} / \[1-3\+]{2}" $TypeRegion]} {
	set ColorFill "SpringGreen3"
    } elseif {[regexp "\[1-3\-]{2} / \[1-3\-]{2}" $TypeRegion]} {
	set ColorFill "SpringGreen4"
    } else {
	set ColorFill "HotPink1"
    }
    return $ColorFill

}

proc ColoriageDuMappingDeDrawBlast {TypeRegion} {

    if {$TypeRegion == "Plus / Plus"} {
	set ColorFill "blue"
    } elseif {$TypeRegion == "Plus / Minus"} {
	set ColorFill "red"
    } elseif {$TypeRegion == "N"} {
	set ColorFill "black"
    } elseif {$TypeRegion == "RAS"} {
	set ColorFill "lightgrey"
    } elseif {$TypeRegion == "+1"} {
	set ColorFill "DodgerBlue1"
    } elseif {$TypeRegion == "+2"} {
	set ColorFill "blue1"
    } elseif {$TypeRegion == "+3"} {
	set ColorFill "blue4"
    } elseif {$TypeRegion == "-1"} {
	set ColorFill "red1"
    } elseif {$TypeRegion == "-2"} {
	set ColorFill "red3"
    } elseif {$TypeRegion == "-3"} {
	set ColorFill "red4"
    } elseif {$TypeRegion == "Prot / Prot"} {
	set ColorFill "orange"
    } elseif {[regexp "\[1-3\+]{2} / \[1-3\+]{2}" $TypeRegion]} {
	set ColorFill "DarkOrchid"
    } elseif {[regexp "\[1-3\+]{2} / \[1-3\-]{2}" $TypeRegion]} {
	set ColorFill "MediumOrchid"
    } elseif {[regexp "\[1-3\-]{2} / \[1-3\+]{2}" $TypeRegion]} {
	set ColorFill "SpringGreen3"
    } elseif {[regexp "\[1-3\-]{2} / \[1-3\-]{2}" $TypeRegion]} {
	set ColorFill "SpringGreen4"
    } else {
	set ColorFill "HotPink1"
    }
    return $ColorFill

}

proc ColorieAlignementSecator {} {

    global TableauCouleurEtGroupe Couleurs LongueurTotale Defauts LNDG ListeDesConsensusDuGroupe NombreDeGroupes NomTextSeq

    puts [join $LNDG \n]
    if {[lindex $LNDG end] ne "grise"} {
	return
    }
    set NombreDeGroupes [llength $LNDG]
    if {$NombreDeGroupes == 2} {
	set NbrGrp [expr {$NombreDeGroupes - 1}]
    } else {
	set NbrGrp [expr {$NombreDeGroupes - 1}]
    }

    if {[ModeI]} {
	foreach type [array names Couleurs] {
	    if {$type eq "Stock"} {continue}
	    lassign [set Couleurs($type)] f b 
	    set f [CouleurO2Ordali $f]
	    set b [CouleurO2Ordali $b]
	    if {[regexp "CoulG" $type]} {set f "black"}
	    $NomTextSeq tag configure $type -foreground $f -background $b
	}
    }

    set EntreAvecStrSec 0
    if {$Defauts(AffSS)} {
	CacheStrSecDansAlignement
	set EntreAvecStrSec 1
    }

    unset -nocomplain TableauCouleurEtGroupe
    set GrTM "GroupeToutLeMonde"
    set ConsensusGlobal [set ListeDesConsensusDuGroupe($GrTM)]

    if {[ModeI]} {
	AfficheLesPoints
    }

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CGlob [string index $ConsensusGlobal $i]
	if {"#" ne $CGlob} {
	    if {[regexp {[A-Y]} $CGlob]} {
		ColorieGroupe $i $GrTM "IdenGlob"
	    }
	    if {[regexp {[a-y]} $CGlob]} {
		ColorieGroupe $i $GrTM "ConsGlob"
	    }
	    if {[regexp {[1-5]} $CGlob]} {
		ColorieGroupe $i $GrTM "SimiGlob"
	    }
	} else {
	    set j 1
	    foreach g [lrange $LNDG 1 end-1] {
		if {$g eq "bidon"} {continue}
#		if {$g eq "grise"} {continue}
		set ConsensusGrp [set ListeDesConsensusDuGroupe($g)]
		set CGrp [string index $ConsensusGrp $i]

		if {[regexp {[A-Y]} $CGrp]} {
		    ColorieGroupe $i $g "CoulG$j"
		}
		incr j
	    }
	}
    }

    return

}

proc ColorieDescendants {AId Lf col} {

    global Abr

    set PAD [set Abr($AId,PAD)]
    set t   [set Abr(Arbre,$AId)]
    set Lid [list]
    foreach n [$t nodes] {
	if {[$t isleaf $n]} {continue}

	set Ld [concat $n {*}[$t descendants $n]]
	set Ln [list]
	foreach d $Ld {
	    if {[$t isleaf $d]} {
		lappend Ln $d
	    }
	}
	set lo [lor $Ln $Lf from1]
	if {$lo != {}} {
	    continue
	}
	foreach d $Ld {
	    if {[set Li [$PAD find withtag "line-$d"]] != ""} { 
		lappend Lid {*}$Li
	    }
	}
    }

    set Lid [lsort -integer -unique $Lid]
    foreach i $Lid {
	$PAD itemconfig $i -width 2 -fill $col
    }

    return

}

proc ColorieGroupe {x Grp LeTag} {

    global LNDG TableauCouleurEtGroupe

    set TableauCouleurEtGroupe($x,$Grp) $LeTag

    if {$Grp == "0"} {
	set DernierGrp [expr {[llength $LNDG]-2}]
	for {set g 1} {$g <= $DernierGrp} {incr g} {
	    set TableauCouleurEtGroupe($x,$g) $LeTag
	}
    }

    return

}

proc ColorieMol3dSelonFeatures {f} {

    global StrucAVoir TabSF ListePDB
    global pgl Mol3dCou Obj3dCou Feat3dCou Feat3dCou2

    AfficheDansViandox

    foreach mold $StrucAVoir {
	set nom [DonneIdDeAccessPDB $mold]
	set chn [DonneChainDeAccessPDB $mold]

	set Mol3dCou $nom
	set Obj3dCou "CA${nom}${chn}"	
	set Feat3dCou $f

	UpdateMolObjFeat
    }

    return

}

proc ColorieNomsSelonGroupes {{quoi show}} {

    global TDuGroupeDesSeqs SDG LNOrdali Defauts LNSeqlab NomNomSeq LNDG

    if {[set Defauts(AffPhy)]} {
	return
    }

    if {[TypeAli] eq "pasdali"} {
	return
    }

    # seqlab ou pas
    if {[QuelMode] eq "seqlab"} {
	set Lrefs $LNSeqlab
    } else {
	set Lrefs $LNOrdali
    }

    if {$Defauts(AffGrp)} {
	set quoi show
    } else {
	set quoi hide
    }

    set Lig [list]
    foreach g $LNDG {
	if {! [regexp {^Group[0-9]+} $g]} {
	    continue
	}
	lappend Lig [string range $g 5 end]
    }
    if {$Lig == {}} {return}

    $NomNomSeq configure -state normal

    if {$quoi eq "hide"} {
	foreach i $Lig {
	    $NomNomSeq tag delete TCG$i 1.0 end
	}
	$NomNomSeq configure -state disabled

	return
    }

    if {"0" in $Lig} {set m 1} {set m 0}
    foreach icol $Lig {
	set g "Group$icol"
	set col [CouleurO2Ordali [CouleurDuGroupe [expr {$icol + $m}]]]
	$NomNomSeq tag configure TCG$icol -background $col -foreground black
	set Lt [list]
	foreach n $SDG($g) {
	    set y [lsearch $Lrefs $n]
	    incr y
	    lappend Lt $y.0 "$y.0 lineend"
	}
	$NomNomSeq tag add TCG$icol {*}$Lt
    }
    $NomNomSeq tag raise PDB

    $NomNomSeq configure -state disabled

    return

}

proc ColorieNomsSelonPhylum {{quoi show}} {

    global NomNomSeq TDesPhylum LNOrdali Defauts LNSeqlab

    if {[set Defauts(AffGrp)]} {
	return
    }
    if {[set Defauts(AffPhy)]} {
	set quoi show
    } else {
	set quoi hide
    }
    if {[TypeAli] eq "pasdali"} {
	return
    }
    if {! [info exists TDesPhylum]} {
	if {$quoi eq "hide"} {
	    return
	}
	FaireLire "No Life Domain information available !"
	return
    }

    $NomNomSeq configure -state normal

    if {$quoi eq "hide"} {
	foreach t {NPEuk NPArk NPPro} {
	    $NomNomSeq tag delete $t 1.0 end
	}
	$NomNomSeq configure -state disabled

	return
    }

    # seqlab ou pas
    if {[QuelMode] eq "seqlab"} {
	set Lrefs $LNSeqlab
    } else {
	set Lrefs $LNOrdali
    }

    $NomNomSeq tag configure NPEuk  -background $Defauts(BgEukaryota)  -foreground $Defauts(FgEukaryota)
    $NomNomSeq tag configure NPArk  -background $Defauts(BgArchaea)  -foreground $Defauts(FgArchaea)
    $NomNomSeq tag configure NPPro  -background $Defauts(BgBacteria)  -foreground $Defauts(FgBacteria)
    $NomNomSeq tag configure NPVir  -background $Defauts(BgViruses)  -foreground $Defauts(FgViruses)

    # attention problemen avec Retournetableau
    RetourneTableau TDesPhylum New
    foreach e {Eukaryota Archaea Bacteria Viruses} t {NPEuk NPArk NPPro NPVir} {
	if {! [info exists New($e)]} {
	    continue
	} else {
	    set Lnoms [set New($e)]
	}

	set Ltag [list]
	foreach n $Lnoms {
	    if {$n eq ""} {continue}
	    set i [lsearch $Lrefs $n]
	    if {$i == -1} {
		puts "$n non trouve !"
		continue
	    }
	    incr i
	    lappend Ltag $i.0 "$i.0 lineend"
	}
	$NomNomSeq tag add $t {*}$Ltag
    }
    $NomNomSeq configure -state disabled

    return

}

proc ColorieSSParamsGUI {} {

    global PSS ListePDB

    toplevel .pss
    wm title .pss "Select parameters ..."
    wm protocol .pss WM_DELETE_WINDOW KillParLaCroix
    wm resizable .pss 0 0
    set PSS(Top) .pss
    
    set fp .pss.f
    set ListChx [ExtraitListeDeListe $ListePDB 0]

    frame $fp
    grid $fp -row 0 -column 0 -sticky news
    grid columnconfig $fp 0 -weight 1

    label $fp.lbl  -text "Select Parameters ..."  -font "Helvetica 14 bold"  -anchor w -justify left
    grid $fp.lbl -row 0 -column 0 -sticky w  -pady 5 -padx 5
    
    set PSS(MeanRef) "mean"
    frame $fp.fpdb
    grid $fp.fpdb  -row 1 -column 0 -sticky ew -pady 5 -padx 5
    label $fp.fpdb.lbl  -text "Compute similarities on mean sec. str., or use a reference :"  -wraplength 250  -fg blue  -anchor w -justify left
    radiobutton $fp.fpdb.rmean -text "Mean"  -relief flat -anchor w  -variable PSS(MeanRef)  -value "mean"
    radiobutton $fp.fpdb.rref  -text "Use reference"  -relief flat -anchor w -variable PSS(MeanRef)  -value "ref"
    tk_optionMenu $fp.fpdb.mpdb PSS(PDBRef) {*}$ListChx
    grid $fp.fpdb.lbl -row 0 -column 0 -columnspan 2 -sticky ew
    grid $fp.fpdb.rmean -row 1 -column 0 -columnspan 2 -sticky w -padx {30 1}
    grid $fp.fpdb.rref  -row 2 -column 0 -sticky w -padx {30 1}
    grid $fp.fpdb.mpdb  -row 2 -column 1 -sticky w
    
    set PSS(Ramp) "color"
    frame $fp.framp
    grid $fp.framp -row 2 -column 0 -sticky ew -pady 5 -padx 5
    label $fp.framp.lbl  -text "Select the type of color gradient :"  -fg blue  -anchor w -justify left
    radiobutton $fp.framp.col  -text "Color"  -relief flat  -variable PSS(Ramp)  -value "color"
    radiobutton $fp.framp.gre  -text "Grey"  -relief flat  -variable PSS(Ramp)  -value "grey"
    grid $fp.framp.lbl -row 0 -column 0 -sticky w
    grid $fp.framp.col -row 1 -column 0 -sticky w -padx {30 1}
    grid $fp.framp.gre -row 2 -column 0 -sticky w -padx {30 1}
    
    set PSS(RExtend) "minmax"
    frame $fp.fborn
    grid $fp.fborn -row 3 -column 0 -sticky ew -pady 5 -padx 5
    label $fp.fborn.lbl  -text "Select limits of gradient :"  -fg blue  -anchor w -justify left
    radiobutton $fp.fborn.rvmm  -text "min to max"  -relief flat  -variable PSS(RExtend)  -value "minmax"    
    radiobutton $fp.fborn.rvmx  -text "0 to 100"  -relief flat  -variable PSS(RExtend)  -value "zerocent"
    grid $fp.fborn.lbl -row 0 -column 0 -sticky w
    grid $fp.fborn.rvmm -row 1 -column 0 -sticky w -padx {30 1}
    grid $fp.fborn.rvmx -row 2 -column 0 -sticky w -padx {30 1}

    set PSS(BFactor) 0
    checkbutton $fp.chkb  -text "assign similarites to B factors"  -relief flat -anchor w -justify left  -variable PSS(BFactor)  -onvalue 1 -offvalue 0
    grid $fp.chkb  -row 4 -column 0 -sticky ew -pady 5 -padx 5
    
    frame $fp.fbut
    grid $fp.fbut  -row 5 -column 0 -sticky ew -pady {30 10} -padx 5
    button $fp.fbut.bok  -text " OK "  -bg green1  -command [list FinColorieSSParams ok]
    button $fp.fbut.bdis  -text "Dismiss"  -bg red  -command [list FinColorieSSParams dismiss]
    grid $fp.fbut.bdis -row 0 -column 0 -sticky w -padx {20 1}
    grid $fp.fbut.bok  -row 0 -column 1 -sticky e -padx {1 20}
    grid columnconfig $fp.fbut 0 -weight 1
    
    set oldGrab [grab current]
    grab .pss
    FenetreAuCentre .pss

    tkwait window .pss

    if {$oldGrab ne ""} {
	grab $oldGrab
    }

    return

}

proc ColorieSSSelonConservation {} {

    global Sequences ZoneSelect ListePCISS ListePDB LNOrdali TabSF ListeTypesDeFeatures StrucAVoir Defauts PSS

    if {[TypeAli] eq "pasdali"} {return}

    # pas de pdb
    if {! [info exists ListePDB] || $ListePDB == {}} {
	FaireLire "No structures in this alignment !"
	return
    }

    # interface graphique pour parametres
    set toto [ColorieSSParamsGUI]
    if {! [info exists PSS]} {return}

    FaireAttendre "Please wait ...\nComputing sequence similarities\naccording to secondary structures ...."

    # ATTENTION ! 
    # Tout est fait en position de l'alignement !
    # Calcule ListePCISS
    if {[set PSS(MeanRef)] eq "mean"} {
	CalculeConservationParSS ""
    } else {
	CalculeConservationParSS $PSS(PDBRef)
    }
    set Lfeat [list]
    set min  99999999.
    set max -99999999.
    foreach df $ZoneSelect {
	lassign $df deb fin
	puts "\nd= $deb f= $fin"
	if {abs($fin - $deb) < 2} {
	    continue
	}

	set lp [set ListePCISS($deb,$fin)]
	if {$lp == {} } {
	    continue
	}

	set m 0.0
	set i 0
	foreach elt $lp {
	    lassign $elt n1 n2 pci d e f
	    
	    if {$n1 eq $n2} {
		continue
	    }
	    if {[info exists Vu($n1,$n2)] || [info exists Vu($n2,$n1)]} {
		continue
	    }
	    set Vu($n1,$n2) 1
	    set Vu($n2,$n1) 1
	    
	    #puts "pci $pci"
	    set m [expr {$m + $pci}]
	    incr i
	}
	unset -nocomplain Vu

	#puts "i= $i"
	if {$i != 0} {
	    set m [expr {100.*$m/$i}]
	    set ListePCISS($deb,$fin,mean) $m
	    if {$m <= $min} {set min $m}
	    if {$m >= $max} {set max $m}
	} else {
	    array unset ListePCISS "$deb,$fin"
	    array unset ListePCISS "$deb,$fin,*"
	}
	update
    }

    if {! [info exists StrucAVoir]} {
	set StrucAVoir [ExtraitListeDeListe $ListePDB 0]
    }

    if {$PSS(RExtend) eq "minmax"} {
	set step [expr {($max-$min)/10.}]
	set floor $min
    } else {
	set step 10.
	set min 0.
	set max 100.
	set floor 0.
    }
    
    for {set i 1} {$i <= 10} {incr i} {
	set seuilB [expr {$floor+$step*($i-1)}]
	set seuilH [expr {$floor+$step*$i}]
	set ic [expr {$i-1}]
	foreach df $ZoneSelect {
	    lassign $df deb fin
	    if {abs($fin - $deb) < 2 || ! [info exists ListePCISS($deb,$fin,mean)]} {
		continue
	    }
	    
	    set m [set ListePCISS($deb,$fin,mean)]
	    if {$m >= $seuilB && $m <= $seuilH} {
		if {$PSS(Ramp) eq "color"} {
		    set c [set Defauts(GammeCoul$ic)]
		} else {
		    set c [set Defauts(GammeGris$ic)]
		}
		#puts [format "    %s %6.2f" $c $m]
		lappend Lfeat [list "fstart" $deb "fstop" $fin "fcolor" $i "fscore" $m "fnote" $c]
	    }
	}
    }

    set idn "SS-Cons"
    if {$idn ni $ListeTypesDeFeatures} {
	lappend ListeTypesDeFeatures $idn
    } else {
	array unset TabSF "*,SS-Cons"
    }
    foreach n $StrucAVoir {
	set TabSF([BonAccess $n],$idn) $Lfeat
    }

    if {$PSS(BFactor)} {
	foreach n $StrucAVoir {
	    set mol [DonneIdDeAccessPDB $n]
	    set chn [DonneChainDeAccessPDB $n]
	    $mol _SetB all all 0.0 $chn
	    
	    foreach ft $Lfeat {
		DecortiqueUneFeature $ft d f c s note
		set deb [DonnePosGS $n $d]
		set fin [DonnePosGS $n $f]

		$mol _SetB $deb $fin $s $chn
	    }
	}
    }

    # Log les resultats
    AuLog @separator

    AuLog @begin table
    AuLog @title Mean %Identity per secondary structure
    if {$PSS(MeanRef) ne "mean"} {
	set pdb $PSS(PDBRef)
	set nom [DonneIdDeAccessPDB $pdb]
	set meth "Method : using $PSS(PDBRef) as reference for sec. str."
	set head [list "Abs  Range" "Rel Range" "%Identity" "Color"]
	set type [list T T R T ]
    } else {
	set meth "Method : using mean sec. str.\n"
	set head [list "Ranges" "%Identity" "Color"]
	set type [list T R T]
    }
    AuLog @text "$meth"
    AuLog @begin tabular
    AuLog @titlecols {*}$head
    AuLog @typecols {*}$type
    foreach elt $Lfeat {
	DecortiqueUneFeature $elt d f c s n
	set col [CouleurPlusProcheDeTkCol $n]

	if {$PSS(MeanRef) eq "ref"} {
	    set dr [DonnePosGS $pdb $d]
	    set fr [DonnePosGS $pdb $f]
	}
	if {$PSS(MeanRef) ne "mean"} {
	    AuLog @row "$d $f" "$dr $fr" $s $col
	} else {
	    AuLog @row "$d $f" $s $col
	}
    }
    AuLog @end
    AuLog @end

    # Lance la visualisation
    ColorieMol3dSelonFeatures "SS-Cons"

    FaireLaSuite
    unset PSS
    unset ListePCISS

    return

}

proc ColorieScore {} {

    global ListeScore
    global NomTextSeq
    global LNOrdali

    ColorieSelonFeature "Clear"
    DefinitionGroupes nogroups
    update idletasks
    set N 10
    set Nseqs [llength $LNOrdali]
    if {$Nseqs < 10} {return}

    if {! [ModeI]} {return}

    $NomTextSeq configure -state normal

    set coul [list red magenta brown orange yellow dimgray green cyan forestgreen blue]
    foreach c $coul {
	$NomTextSeq tag configure SCORE$c -background $c -foreground black
    }

    set Ny 1
    if {$Nseqs > 20} {
	set Ny 2
    }

    #    norm dis nVp mcos dist Ranganatan

    set f [open "resul.dat" w]
    foreach l $ListeScore {
	puts $f $l
    }
    close $f

    foreach n {0 1 2 3 4 5} {
	set liste [ExtraitListeDeListe $ListeScore $n]

	set Lt [lsort -unique -increasing -real $liste]
	set i 0
	if {[lindex $Lt $i] == -999.} {
	    incr i
	}
	set min [lindex $Lt $i]
	set max [lindex $Lt end]
	set step [expr {($max - $min) / $N}]

	set j 0
	foreach e $liste {
	    if {$e == -999.0} {
		incr j
		continue
	    }
	    foreach i {0 1 2 3 4 5 6 7 8 9} c $coul {
		set d [expr {$min + $i * $step}]
		set f [expr {$d + $step}]
		if {$e >= $d && $e < $f} {
		    set p [expr {$n * $Ny + 1}]
		    $NomTextSeq tag add SCORE$c $p.$j
		    break
		}
	    }
	    incr j
	}
    }

    update idletasks

    #    $NomTextSeq configure -state disabled

    return

}

proc ColorieSelonFeature {ft {w ""}} {

    global FrmBtnFea

    if {$ft ne "Clear"} {
	if {$w eq ""} {set w [BtnDeLaFeature $ft]}

	set Etat [ChangeEtatBouton $w]
	LesFeaturesUtilisees $ft $Etat
    }

    AppliqueFeature $ft

    return

}

proc ColorieStructureSelonFeature {ft MolId} {

    global TabSF ListePDB Sequences

    set chnok [DonneChainDeAccessPDB $MolId]
    set mol   [DonneIdDeAccessPDB $MolId]
    global PDB_[set mol]_Sequence
    set MolId [BonAccess $MolId]

    set AColorier {}

    foreach f [set TabSF($MolId,$ft)] {
	DecortiqueUneFeature $f dg fg col score note
	set dg [expr {$dg-1}]
	if {$col eq "black"} {set col "white"}

	for {set i $dg} {$i < $fg} {incr i} {
	    set NroRes [CorrespondanceGenPDB $MolId $i]
	    lappend AColorier [list $col ${chnok}$NroRes]
	}
    }

    set AColorier [lunique [lsort -index 0 $AColorier]]

    return $AColorier

}

proc ColorieVrpSelon {w ft} {

    global TabSF Vrp

    ResetColoriage
    
    if {$ft eq "None"} {return}
    if {$ft eq "VientDuCombo"} {set ft $Vrp(UseFeat)}
    set n [set Vrp(seqSelName)]
    if {! [info exists TabSF($n,$ft)]} {return}

    set c $Vrp(WCanvas)
    set t $Vrp(WText)
    foreach f [set TabSF($n,$ft)] {
	DecortiqueUneFeature $f dg fg col score note
	set db [DonnePosGS $n $dg]
	set fn [DonnePosGS $n $fg]

	for {set i $db} {$i < $fn} {incr i} {
	    set line [$c find withtag "l${Vrp(VId)}_$i"]
	    $c itemconfigure $line -fill $col
	    set dot [$c find withtag "p${Vrp(VId)}_$i"]
	    $c itemconfigure $dot -fill $col
	}
    }

    return

}

proc CombienAUntel {Untel} {

    global RepertoireDuGenome
    set n 0
    set l 0
    foreach rapport [ glob -nocomplain "$RepertoireDuGenome/rapportsaccess/*"] {
	set user [UserDeRapport $rapport]
	set loc [LoctypeDansRapport $rapport]
	if {$user==$Untel} {incr n}
	if {$loc!="NoLocalization" && $user==$Untel} {incr l}
    }
    return "$Untel: $n, loc:$l"

}

proc CombienDeClustersVides {version} {

    #version: avr ou mai
    set RepertoireGeneral "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_$version"
    if {$version=="avr"} {set RepertoireGeneral "/genomics/link/SpliRetMouse/FichiersInitial/Avril2011/PROT_VARIANTES_61_$version"}
    set RepertoireSourisTfactor "$RepertoireGeneral/SOURIS_Tfactor_61_$version"
    set RepertoireSourisOthers  "$RepertoireGeneral/SOURIS_others_61_$version"
    set RepertoireSourisNOALT   "$RepertoireGeneral/SOURIS_NO_ALT_61_$version"
    set RepertoireRatTfactor    "$RepertoireGeneral/RAT_Tfactor_61_$version"
    set RepertoireRatOthers     "$RepertoireGeneral/RAT_others_61_$version"
    set RepertoireRatNOALT      "$RepertoireGeneral/RAT_NO_ALT_61_$version"
    set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNOALT $RepertoireRatTfactor $RepertoireRatOthers $RepertoireRatNOALT]
    foreach Repertoire $LesRepertoires {
	set i 0; set j 0
	foreach FileST [glob -nocomplain "$Repertoire/*"] {
	    incr j
	    set cluster [lindex [split [file tail $FileST] "."] 0]
	    set taille [file size $FileST]
	    if {$taille == 0} {incr i}
	}
	Espionne "$Repertoire $i vides sur $j clusters"
    }

}

proc CombienDeProches {} {

    set plusgrand 0; set pluspetit 200
    foreach FileProche [glob -nocomplain "[RepertoireDuGenome]/ProchesQuery85/*"] {
	set i 0
	foreach Ligne [LesLignesDuFichier $FileProche] {incr i}
	if {$i>$plusgrand} {set plusgrand $i; set Fileplusgrand $FileProche}
	if {$i<$pluspetit} {set pluspetit $i; set Filepluspetit $FileProche}
	Espionne "$FileProche $i"
    }
    Espionne "plusgrand $Fileplusgrand $plusgrand"
    Espionne "pluspetit $Filepluspetit $pluspetit"

}

proc CombienDeRaDsRet1324 {} {

    set A 0 
    set Fichier "/genomics/link/Ret1324/fiches/bornesdespabs"
    set LesLignes [LesLignesDuFichier $Fichier]
    foreach Ligne $LesLignes {
	incr A
    }
    Espionne "$A = nb de RA ds Ret1324"

}

proc CombienTouchentChroContig {Chro {Contig ""}} {

    set LesTouches [QuiToucheChroContig $Chro $Contig]
    return [llength $LesTouches]

}

proc CombineLesFragments {Nom {LesBornesDesFragments ""}} {

    JeMeSignale
    set FichierNucTFA "[RepertoireDuGenome]/nuctfa/$Nom"
    set ToutNuc [QueLaSequenceDuFichierTFA $FichierNucTFA]
    set LesFragments {}

    set FragmentsDeMutation 0
    if {$LesBornesDesFragments==""} {
	if { ! [OuiOuNon "Do You want to see the mutation fragments ?"]} { return "" }
    }
    if {$LesBornesDesFragments=="MutationFragments"} {
	set FragmentsDeMutation 1
	set Entete [EnteteDuFichierTFA $FichierNucTFA]
	if { ! [regexp { muted (.+) of } $Entete Match Codes]} {
	    FaireLire "Sorry I can't find 'muted code1 code2 code3 of' in $Entete"
	    return ""
	}
	set LesCoOrdonnes [list 1]
	foreach Code [split $Codes " "] {
	    if { ! [regexp -nocase {[a-z]} $Code]} { continue }
	    regsub {[0-9]+} [string toupper $Code] " & " Coco
	    scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	    set LongAncienP [string length $AncienP]
	    lappend LesCoOrdonnes $PosAncienP
	}
	lappend LesCoOrdonnes [expr [string length $ToutNuc]/3]
	set LesCoOrdonnes [lsort -increasing -integer $LesCoOrdonnes]
	set LesBornesDesFragments $LesCoOrdonnes
    }

    set Frag "A"
    set LesBornesDesFragmentsOK {}
    foreach X $LesBornesDesFragments {
	if {[regexp -nocase "end" $X]} { set X [expr ([string length $ToutNuc]+4)/3] }
	if { ! [regexp {[0-9]+} $X Bon]} { continue }
	lappend LesBornesDesFragmentsOK $Bon
    }
    set LesBornesDesFragments $LesBornesDesFragmentsOK
    foreach DP [lrange $LesBornesDesFragments 0 end-1] FP [lrange $LesBornesDesFragments 1 end] {
	incr FP -1
	set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
	ScanLaListe $LesSequencesNP SeqN SeqP
	set PepSort [PeptideSort $SeqP]
	if {[info exists TPep]} { unset TPep }
	DecortiquePeptideSort $PepSort "" TPep
	Espionne [array get TPep]
	set Residues         [set TPep(Residues)]
	set nBases           [expr $Residues*3]
	set Molecularweight  [set TPep(Molecularweight)]
	set Charged          [set TPep(Charged)]
	set Isoelectricpoint [set TPep(Isoelectricpoint)]

	set SeqCompressee ""
	append SeqCompressee [string range $SeqP 0 5]
	append SeqCompressee "..."
	append SeqCompressee [string range $SeqP end-5 end]
	lappend LesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s"  $Nom  $Frag  $DP $FP  $Residues $nBases $Charged  $Molecularweight $Isoelectricpoint  $SeqCompressee]
	set Frag [NextALPHA $Frag]
    }
    if {[llength $LesFragments]==1} {
	set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
	if {$Choix=="" && [OuiOuNon "Do I cancel CombineLesFragments ?"]} { return "" }
	return $LesFragments
    }
    set Choix ""
    FaireLire "You can now create several contigous fragments"
    set TousLesFragments {}
    if {$FragmentsDeMutation} {
	set LesFragmentsDeMutation [TousLesSegmentsConsecutifs $LesFragments]
    }
    set Ever 1
    while $Ever {
	if {$FragmentsDeMutation} {
	    if {$LesFragmentsDeMutation=={}} {
		set OK [AfficheVariable [join $TousLesFragments "\n"] "AvecRetour" PleaseValidate]
		break
	    } else {
		set Choix [lindex $LesFragmentsDeMutation 0]
		set LesFragmentsDeMutation [lrange $LesFragmentsDeMutation 1 end]
	    }
	} else {
	    set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
	    if {$Choix=="" &&  [OuiOuNon "Did You choose enough fragments\n or maybe You want to reset selection"]} {
		set Tout [join $TousLesFragments "\n"]
		set Selection [AfficheVariable $Tout "AvecRetour" PleaseValidate]
		if {$Selection==""} {
		    if {[OuiOuNon "Do You want to cancel CombineFragments ?"]} { return "" }
		    if {[OuiOuNon "Do You really want to empty all selection You did ?"]} {
			set TousLesFragments {}
		    }
		    continue
		}
		if {$Selection==$Tout} { break }
		if {[OuiOuNon "Do You really want to keep only following selection\n$Selection"]} {
		    set TousLesFragments [split $Selection "\n"]
		    break
		}
		continue
	    }
	}
	Espionne $Choix
	set LeChoix [split $Choix "\n"]
	set DP ""
	set NomDuFragment ""
	foreach Fragment $LeChoix {
	    scan $Fragment "%s %s %d %d" NomLu FragLu DPlu FPlu
	    if {$DP==""} { set DP $DPlu }
	    set FP $FPlu
	    append NomDuFragment $FragLu
	}
	set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
	ScanLaListe $LesSequencesNP SeqN SeqP
	set PepSort [PeptideSort $SeqP]
	if {[info exists TPep]} { unset TPep }
	DecortiquePeptideSort $PepSort "" TPep
	set Residues         [set TPep(Residues)]
	set nBases           [expr $Residues*3]
	set Molecularweight  [set TPep(Molecularweight)]
	set Charged          [set TPep(Charged)]
	set Isoelectricpoint [set TPep(Isoelectricpoint)]

	set SeqCompressee ""
	append SeqCompressee [string range $SeqP 0 5]
	append SeqCompressee "..."
	append SeqCompressee [string range $SeqP end-5 end]
	lappend TousLesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s"  $Nom  $NomDuFragment  $DP $FP  $Residues $nBases $Charged  $Molecularweight $Isoelectricpoint  $SeqCompressee]
#	AfficheVariable [join $TousLesFragments "\n"] "" TheFragmentsYouSelect]
	set Choix ""
    }
    return $TousLesFragments

}

proc CombleSSParCoil {{lss ""} molid chn} {


    set LesRes [$molid _resnumber -chain $chn -polymer]
    set 1ResPDB [lindex $LesRes 0]
    set i1ResPDB 0
    set DResPDB [lindex $LesRes end]
    set iDResPDB [expr {[llength $LesRes]-1}]
    set df {}

    foreach s $lss {
	lassign $s Elt a z e Nm1 r Nm2 t q 
	lappend df [list $Nm1 $Nm2]
    }

    if {$df == {}} {
	lappend df "Coil xxx xxx $chn $1ResPDB xxx $DResPDB xxx"
	return $df
    }

    set i1ResSS [lsearch $LesRes [lindex [lindex $df 0] 0]]
    if {$i1ResSS > 0} {
	lassign [PreviousResDuPdb [lindex [lindex $df 0] 0] $chn $molid] finc fini 
	lappend lss "Coil xxx xxx $chn $1ResPDB xxx $finc"
    }

    lassign [NextResDuPdb [lindex [lindex $df 0] 1] $chn $molid] debc debi 
    foreach cpl [lrange $df 1 end] {
	lassign [PreviousResDuPdb [lindex $cpl 0] $chn $molid] finc fini 
	if {$fini-$debi >= 0} {
	    lappend lss "Coil xxx xxx $chn $debc xxx $finc xxx"
	}
	lassign [NextResDuPdb [lindex $cpl 1] $chn $molid] debc debi 
    }

    if {$debc ne ""} {
	if {$iDResPDB - $debc >= 0} {
	    lappend lss "Coil xxx xxx $chn $debc xxx $DResPDB xxx"
	}
    }

    #    return [lsort -integer -index 4 $lss]
    return $lss

}

proc CommandeOligos {LesFichiersOligos {NomPresumeDuFichierCommande ""}} {


    Wup "LesFichiersOligos can be a list. "

    OligoEnStock "Reload"
    StockeCetOligo "Reset" ""
    if {$NomPresumeDuFichierCommande=="StockeOnly"} { set StockeOnly 1 } else { set StockeOnly 0 }


    if {$NomPresumeDuFichierCommande==""  || $NomPresumeDuFichierCommande=="StockeOnly"  || [regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande] } {
	if {[regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande]} {
	    regsub "^usethisname_" $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	    regsub {\.txt} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	} else {
	    set NomPresumeDuFichierCommande [lindex $LesFichiersOligos 0]
	}
	regsub {\.(nuc|prot|)tfa$} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	append NomPresumeDuFichierCommande "_commande[Date Nice_H].txt"
    }

    set LesTFAs {}
    set D4 "50N"
    set D7 "DSL"
    foreach FichierOligos $LesFichiersOligos {
	foreach Access [LaSequenceDuTFAs $FichierOligos "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FichierOligos $Access]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    if {[info exists SeqDuAccess($Access)]} {
		FaireLire "DejaVu $Access !"
		continue
	    }
	    #rR Attention BrocOli 
	    set TfaBrocOli [BrocOli $TFA]
	    if {[WithBrocOli] && $TfaBrocOli!=""} {
		set AccBroc [EnteteDuTexteTFA $TfaBrocOli "access"]
		Espionne "AccBroc $AccBroc"
		lappend TFADuAccessNonBrocOli($AccBroc) $TFA
		lappend SeqDuAccessNonBrocOli($AccBroc) $Seq
		set TFA $TfaBrocOli
		set Seq [QueLaSequenceDuTexteTFA $TFA]
	    }
	    #rR Attention BrocOli 

	    set TFADuAccess($Access) $TFA
	    set SeqDuAccess($Access) $Seq
	    lappend LesAccessDeSeq($Seq) $Access
	    lappend LesAccess $Access
	}
    }
    set LeTFADeLaCommande {}
    set LaCommande {}
    set EnteteDeLaCommande ""
    set Fournisseur "Inconnu"

    FaireLire "Please select the Scale in Micro Mol to order at Sigma (default is 0.05)"
    set  SigmaScaleMicroMol [ChoixParmi [list 0.05 0.025 0.05 0.2, 1. 10. 15. "OtherValue"]]
    if {$SigmaScaleMicroMol=="OtherValue"} { set SigmaScaleMicroMol [Enter 0.05] }
    FaireLire "Please select the Purification to order at Sigma (default is RP1)"
    set  SigmaPurification [ChoixParmi [list "RP1" "DST" "PAGE" "HPLC" "OtherValue"]]
    if {$SigmaPurification=="OtherValue"} { set SigmaPurification [Enter "RP1"] }
    set  SigmaComment ""

    set ListeSigma {}

    if { ! $StockeOnly} {
	
	set EnteteDeLaCommande {}
	lappend EnteteDeLaCommande "                    SYNTHESE D'OLIGONUCLEOTIDES - IGBMC"
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Date de commande : [Date Nice]"
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Equipe           :            "
	lappend EnteteDeLaCommande " Nom du demandeur :            "
	lappend EnteteDeLaCommande " Telephone        :            "
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Sequence 5' -> 3'"
	lappend EnteteDeLaCommande ""
	set EnteteDeLaCommande [join $EnteteDeLaCommande "\n"]

	set Fournisseur "IGBMC"
	
	set NumeroPrimer 1
#	if { 0 && ! [OuiOuNon "Do I start Primer numbering with 1 ?"]} {
#	    set NumeroPrimer [Entre 1]
#	}
    }
    set nPrimer 0
    set TotalBases 0
    set TotalBasesSansAttB 0
    set nAttB1 0
    set nAttB2 0
    set CompteAttB ""
    set LesFichiersOligosStockes {}
    set LesNonCreesCarEnStock {}
    foreach Access $LesAccess {
	set Seq [set SeqDuAccess($Access)]
	if {[info exists DejaVu($Seq)]} { continue }
	set DejaVu($Seq) 1
	if {[set OliEnSto [OligoEnStock $Seq]]!=""} {
	    set LesAutres [join [set LesAccessDeSeq($Seq)] "\n"]
	    if {[OuiOuNon "I found an existing oligo $OliEnSto\nfor $LesAutres\n\nDo You use it ?"]} {
		foreach A $LesAutres {
		    set WarningBrocOli ""
		    if {[Oli $OliEnSto "IsBrocOli"]} {
			set GenericOligo [Oli $OliEnSto "ItsGenericOligo"]
			set WarningBrocOli " BrocOli with $GenericOligo"
		    }
		    lappend LesNonCreesCarEnStock "$A please use $OliEnSto$WarningBrocOli"
		}
		continue
	    }
	}
	set LesEntetes {}
	set AppendTexteBrocOli {}
	set LesB {}
	set LesS {}
	foreach Autre [set LesAccessDeSeq($Seq)] {
	    set TFA [set TFADuAccess($Autre)]
	    set Entete [EnteteDuTexteTFA $TFA]
	    Espionne "$Autre pour seq =$Seq="
	    if {[regexp { BrocOli.+$} $Entete TexteBrocOli]} {
		if {$AppendTexteBrocOli!="" && $AppendTexteBrocOli!=$TexteBrocOli} {
		    FaireLire "Different BrocOli for the same sequence \n$Seq\n$AppendTexteBrocOli\n$TexteBrocOli"
		}
		scan $$TexteBrocOli "%s %s %s %s %s %s" A b w B r S
		lappend LesB $B ; set LesB [ListeSansDoublon $LesB]
		lappend LesS $S ; set LesS [ListeSansDoublon $LesS]
		regsub "$TexteBrocOli" $Entete "" Entete
		set AppendTexteBrocOli " BrocOli with [join $LesB "+"] replaces [join $LesS "+"]"
	    }
	    regsub -all ">" $Entete "" Entete
	    lappend LesEntetes $Entete
	}
	set LesEntetes [ListeSansDoublon $LesEntetes]
	set Entete [join $LesEntetes "+"]
	if {$AppendTexteBrocOli!=""} { append Entete $AppendTexteBrocOli }

    	incr nPrimer
	incr TotalBases [string length $Seq]
	incr TotalBasesSansAttB [string length $Seq]

	set PStocke ""
	set EntetePourFiStockOl [FormatageEntete $Entete PourOligo "Pxxxx"]

	set FichierOligoStocke  [StockeCetOligo $EntetePourFiStockOl $Seq "AutoNumbering"]
	lappend LesFichiersOligosStockes $FichierOligoStocke
	set PStocke [file tail $FichierOligoStocke]
	regsub ".tfa$" $PStocke "" PStocke
	if {[WithBrocOli]} {
	    set EnteteBroc [EnteteDuFichierTFA $FichierOligoStocke]
	    scan $EnteteBroc "%s %s %s %s %s %s %s %s" P X o w s S f A
	    if {$X=="5'"} { set AccBroc "${S}_$A" } else { set AccBroc "${A}_$S" }
	    if {[info exists TFADuAccessNonBrocOli($AccBroc)]} {
		foreach TFANB $TFADuAccessNonBrocOli($AccBroc) SeqNB $SeqDuAccessNonBrocOli($AccBroc) B $LesB S $LesS {
		    regsub "BrocOli with .*" $EnteteBroc "BrocOli with $B replaces $S" OneEnteteBroc
		    Espionne "TFANB de $AccBroc $TFANB"
		    set EntetePourFiStockOlNB [FormatageEntete $OneEnteteBroc "PourOligoNonBrocOli" "Pxxxx"]
		    append EntetePourFiStockOlNB " seeBrocken $PStocke"
		    set FichierOligoStockeNB  [StockeCetOligo $EntetePourFiStockOlNB $SeqNB "AutoNumbering"]
		    lappend LesFichiersOligosStockes $FichierOligoStockeNB
		    set PStockeNB [file tail $FichierOligoStockeNB]
		    regsub ".tfa$" $PStockeNB "" PStockeNB
		    set Monbroc [ContenuDuFichier $FichierOligoStocke]
		    if {[regexp "seeFull AfterMe" $Monbroc]} {
			regsub "seeFull AfterMe" $Monbroc "seeFull $PStockeNB" MonBonBroc
			Sauve $MonBonBroc dans $FichierOligoStocke
		    } else {
			if {[regexp {seeFull ([P0-9\+]+)} $Monbroc Match]} {
			    regsub -all {\+} $Match "\\+" MatchX
			    regsub $MatchX $Monbroc "$Match+$PStockeNB" MonBonBroc
			    Sauve $MonBonBroc dans $FichierOligoStocke
			}
		    }
		}
	    }
	}
	if {$StockeOnly} { continue }

	set TFA [SequenceFormatTFA $Seq ">$Entete" "brut"]
	lappend LeTFADeLaCommande $TFA
	set PduTFA($TFA) $PStocke
	
	set EnteteCourte [FormatageEntete $Entete PourCommande $PStocke]
	scan $EnteteCourte "%s %s" P SigSuj
	set LS [list $P:$SigSuj $Seq $SigmaScaleMicroMol $SigmaPurification $SigmaComment]
	lappend ListeSigma [join $LS ","]
	if {$Fournisseur=="Invitrogen" || $Fournisseur=="IGBMC"} {
	    if {$Fournisseur=="IGBMC"} {
		lappend LaCommande [string repeat "-" 66]
		lappend LaCommande "$NumeroPrimer  $EnteteCourte"
		lappend LaCommande ""
		set LesTriplets {}
		set nTriplets 0
		set LesBases [split $Seq ""]
		set LesSuivantes [lrange [concat $LesBases [list X X X X X]] 3 end]
		set FiveP " 5'"
		foreach {a b c} $LesBases {d e f} $LesSuivantes {
		    lappend LesTriplets "$a$b$c"
		    set ThatsAllFolks [string equal "$d$e$f" "XXX"]
		    if {[incr nTriplets]==15 || $ThatsAllFolks} {
			set nTriplets 0
			set LigneDeTriplets [string toupper [join $LesTriplets " "]]
			if {$ThatsAllFolks} {
			    lappend LaCommande " $FiveP $LigneDeTriplets  3'"
			    break
			} else {
			    lappend LaCommande " $FiveP $LigneDeTriplets"
			}			    
			set LesTriplets {}
			set FiveP "   "
		    }
		}
		lappend LaCommande ""
	    } else {
		lappend LaCommande "*"
		lappend LaCommande "D1: $EnteteCourte"
		lappend LaCommande "D2: $NumeroPrimer"
		set SeqACommander [string toupper $Seq]
		set LigneD5 ""
		if {[CaCommenceParAttB $SeqACommander] && [NePasMettreAttB]} {
		    set LongOriginale [string length $SeqACommander]
		    set SeqACommander [RetireAttB    $SeqACommander]
		    set LongCommandee [string length $SeqACommander]
		    set LongEconomie [expr $LongOriginale-$LongCommandee]
		    set TotalBasesSansAttB [expr $TotalBasesSansAttB-$LongEconomie]
		    if {$LongEconomie>0 && [regexp "AttB1" $Entete]} { set LigneD5 "D5: GWF" ; incr nAttB1 }
		    if {$LongEconomie>0 && [regexp "AttB2" $Entete]} { set LigneD5 "D5: GWR" ; incr nAttB2 }
		    set CompteAttB "= $TotalBasesSansAttB without AttB + $nAttB1 AttB1 + $nAttB2 AttB2" 
		}
		lappend LaCommande "D3: $SeqACommander"
		lappend LaCommande "D4: $D4"
		if {$LigneD5!=""} { lappend LaCommande $LigneD5 }
		lappend LaCommande "D7: $D7"
	    }
	} else {
	    lappend LaCommande "\n>$Entete"
	    lappend LaCommande $Seq
	}
	incr NumeroPrimer
	continue
    }
    if {$StockeOnly} { return $LesFichiersOligosStockes }
    if {$Fournisseur=="IGBMC"} {
	lappend LaCommande ""
	lappend LaCommande "------------------------ FIN DE COMMANDE -------------------------"
    } else {
	lappend LaCommande " + "
    }
    lappend LaCommande "Total bases $TotalBases $CompteAttB for $nPrimer primers"
    lappend LaCommande "End of text automatically created by Gscope (33)388653305"
    set LEnteteDeLaCommande [list $EnteteDeLaCommande "HZ: $nPrimer" ""]
    set LaCommande [concat $LEnteteDeLaCommande $LaCommande]
    set Commande ""
    while {$Commande==""} {
	set Commande [join $LaCommande "\n"]
	set Commande [EntreTexte $Commande]
	if {$Commande==""} {
	    if {[OuiOuNon "Do You want to cancel CommandeOligos ?"]} {
		if {[OuiOuNon "Sorry, but I already created the files\n [join $LesFichiersOligosStockes "\n"]\n\nCan I delete them ?"]} {
		    foreach FOS $LesFichiersOligosStockes {
			if {[file exists $FOS]} { file delete $FOS }
		    }
		}
		return ""
	    } else {
		continue
	    }
	}
    }

    set WebOrder [OuiOuNon "Do I order these oligos through the [UrlCommandeOligo] Webserver ?"]

    while {1} {
	FaireLire "Please, tell me name for the TEXT file for oligos_commande (and oligos_weborder)"
	set FichierTXTCommandeOligos $NomPresumeDuFichierCommande
	set FichierTXTCommandeOligos [FichierPourSaveAs $FichierTXTCommandeOligos]
	if {$FichierTXTCommandeOligos==""} {
	    if {[OuiOuNon "Ok to continue WITHOUT saving the text of the oligos_commande ?"]} { break } else { continue }
	}
	regsub "_commande" $FichierTXTCommandeOligos "_weborder" FichierTXTWebOrderOligos
	regsub "_commande" $FichierTXTCommandeOligos "_sigma"    FichierTXTSigmaOligos
	regsub ".txt"      $FichierTXTSigmaOligos    ""          FichierTXTSigmaOligos
	append FichierTXTSigmaOligos ".csv"
 
	append Commande "\n $FichierTXTCommandeOligos"
	append Commande "\n $FichierTXTWebOrderOligos"
	append Commande "\n $FichierTXTSigmaOligos"
	set TFADeLaCommande [join $LeTFADeLaCommande "\n"]
	set FichierTXTCommandeOligos [Sauve $Commande dans $FichierTXTCommandeOligos]
	set FichierTXTWebOrderOligos [Sauve $TFADeLaCommande dans $FichierTXTWebOrderOligos]
	set FichierTXTSigmaOligos    [SauveLesLignes $ListeSigma dans $FichierTXTSigmaOligos]
	break
    }
    if {$LesNonCreesCarEnStock!={}} {
	FaireLire "Some oligos where not created because they exist in oligobase\n Please browse for a file name to store the list"
	regsub "_commande" $FichierTXTCommandeOligos "_existing" FichierDesNonCreesCarEnStock
	regsub ".txt$" $FichierDesNonCreesCarEnStock "" FichierDesNonCreesCarEnStock
	append FichierDesNonCreesCarEnStock ".list"
	set FichierDesNonCreesCarEnStock [FichierPourSaveAs $FichierDesNonCreesCarEnStock]
	if {$FichierDesNonCreesCarEnStock!=""} {
	    SauveLesLignes $LesNonCreesCarEnStock dans $FichierDesNonCreesCarEnStock
	}
    }

    if {$FichierTXTCommandeOligos!=""} {
	while {$WebOrder} {
	    foreach Access [LaSequenceDuTFAs $FichierTXTWebOrderOligos "LaListeDesAccess"] {
		set TFA [LaSequenceDuTFAs $FichierTXTWebOrderOligos $Access]
		set Nom $Access
		set Not [EnteteDuTexteTFA $TFA]
		set Seq [QueLaSequenceDuTexteTFA $TFA]
		if {[info exists PduTFA($TFA)]} { set Nom $PduTFA($TFA) }
		lappend LesNom $Nom
		lappend LesNot $Not
		lappend LesSeq $Seq
	    }
	    set Retour [WebOrder $LesSeq $LesNom $LesNot]
	    if {$Retour!=""} { break }
	    if {[OuiOuNon "Do I really cancel WebOrder ?"]} { break } 
	}
	if {[OuiOuNon "Do I print the order ?" 0]} {
	    ImprimeLeFichier $FichierTXTCommandeOligos "renoir -l "
	}
	if {[OuiOuNon "Do I mail the order ?" 0]} {
	    MailAuxDestinataires $FichierTXTCommandeOligos "" "Commande oligos"
	}
    }
    return $FichierTXTCommandeOligos

}

proc CommandesExecPossibles {} {

    global Commandes CommandesDefaut

    set Commandes(integral)  "batch-integral.tclsh "
    set Commandes(dbclustal) "batch-dbclustal.tclsh "

    array set CommandesDefaut [array get Commandes]

}

proc CommandesVideoAxeX {Fin} {


    foreach I [NombresEntre 1 $Fin] {
	lappend LesLignes "turn x,1"
	lappend LesLignes ";png $I.png;"
    }
    SauveLesLignes $LesLignes dans "CommandesVideo.txt"
    exit

}

proc CommandesVideoAxeY {Fin} {


    foreach I [NombresEntre 1 $Fin] {
	lappend LesLignes "turn y,$I"
	lappend LesLignes "ray"
	lappend LesLignes "png $I"
    }
    SauveLesLignes $LesLignes dans "CommandesVideo.txt"
    exit

}

proc CommenceIci {CommenceIci} {


    if {$CommenceIci=="AskWhereToBegin"} {
	if {[OuiOuNon "Do you want to begin with a given [Prefixe] ?"]} {
	    set CommenceIci [Entre [PreFixe]]
	}
    }
    return $CommenceIci

}

proc CompCluster {ficRef ficSel} {


    set fRef [file tail $ficRef]
    set fSel [file tail $ficSel]
    set NewFicRef "/usr/tmp/New$fRef"
    set NewFicSel "/usr/tmp/New$fSel"

    OteSqDivergentes $ficRef $ficSel
    set nbSqId [OteSqDivergentes $ficSel $ficRef]
    set lstat {}
    set stat [eval exec "aRandIndex $NewFicRef $NewFicSel"]
    set stat [string range $stat 24 end]
    lappend lstat $stat
    lappend lstat $nbSqId

    return $lstat

}

proc CompTabGlob {pab liste} {


    foreach n {"IdenGlob" "ConsGlob" "SimiGlob"} {
	set l${n}R {}
	foreach e [set liste] {
	    set pos [CorrespondanceGenSeqOrd $pab $e]
	    lappend l${n}R $pos
	}
	lappend lTotal [set l${n}R]
    }

    return $lTotal

}

proc ComparaisonAvecToutesLesEtudes_Gretta {} {

    set Rep        "[RepertoireDuGenome]/Comparaisons/RetScopemRNAMm"
    set BDB        "$Rep/AutresEtudesAll.tfas"
    set FileEtudes "$Rep/AutresEtudesAll.txt"
    set FileOUT    "$Rep/CompAvecAutresEtudesAll.txt"

    set LesID {}
    set F [open $FileEtudes]
    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == "" || [regexp {^\#} $Ligne]} {continue}
	set LaLigne [split $Ligne "\t"]
	set ID [lindex $Ligne 0]	

	set TabID($ID,LesNoms) {}
	set TabID($ID,Ligne)   [join [lrange $LaLigne 0 6] "\t"]
	lappend LesID $ID
    }
    close $F


    set     LesNoms     [AskClust_Gretta LesNoms]
    set     LesNoms [list PG0499]

    foreach Nom $LesNoms {
	Espionne $Nom

	set FileTFA "$Rep/$Nom"
	set FileBlast "$FileTFA.blastetudes"
	if {![file exists $FileTFA]} {continue}
	AskBlast unset

	if {1} {
	    PipeBlast $FileTFA $BDB $FileBlast N 20 0.01 T 4
	    FichierBlastReduit $FileBlast $FileBlast IdentityWithoutFilter 0.90
	    FichierBlastReduit $FileBlast $FileBlast TailleAlignementMin   100
	}
	set NbSubjectDansBlast [AskBlast $FileBlast NbSubject  ]
	if {$NbSubjectDansBlast < 1} {
	    #Espionne "$Nom -> none"
	    continue
	}

	for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {
	    set ID           [AskBlast $FileBlast Subject $i]
	    regsub {\$[0-9]+$} $ID "" ID

	    if {![info exists TabID($ID,LesNoms)]} {
		Espionne "$ID unknown"
		continue
	    }
	    Espionne "$Nom -> $ID"
	    lappend TabID($ID,LesNoms) $Nom
	}
    }

    set LeTexte {}
    foreach ID $LesID {
	set Ligne [set TabID($ID,Ligne)]

	set LesNomsDeLID {}
	foreach Nom [lsort -unique [set TabID($ID,LesNoms)]] {
	    ###DefinitionMoyenne#####
	    set MeanDef [InterrogeDefinitionsConsensus $Nom Definition]
	    
	    set LesGN {}
	    foreach GeneName [InterrogeGeneName $Nom LesGeneNames] {
		if {$GeneName == ""} {continue}
		set n [InterrogeGeneName $Nom GeneName $GeneName n]
		lappend LesGN [list "$GeneName ($n)" $n]
	    }
	    #seulement les 3 premiers GN
	    set LesGeneName {}
	    set i 0
	    foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] {
		incr i
		#if {$i > 3} {break}
		lappend LesGeneName [lindex $LeGN 0]
	    }
	    set GN [join $LesGeneName ";"]

	    foreach Clust [AskClust_Gretta Nom $Nom LesClusters] {
		lappend LeTexte "$Ligne\t$Nom\t$Clust\t$MeanDef\t$GN"
	    }
	}
    }

    Sauve [join $LeTexte "\n"] dans $FileOUT

}

proc Comparaison_clusters {LesClusters} {
 
    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_ClustersXHda" 
    set LesInfos {} 
    set Cl1          [lindex $LesClusters 0] 
    set Cl2          [lindex $LesClusters 1] 
    set Dist         [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 Distance]] 
    set NbCommonOp   [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 NbOperonsCommuns] 
    lappend LesInfos "$Cl1\t$Cl2\t$Dist\t$NbCommonOp" 

    foreach Cl $LesClusters { 
	set TCl       [O2C2O Cluster $Cl TailleCluster] 
	set Orf       [lindex [O2C2O Cluster $Cl LesOrfs] 0] 
	set PAllOrga  [O2C2O Cluster $Cl Categorie AllOrganism          Presence] 
	set POrgasInt [O2C2O Cluster $Cl Categorie OrganismeInteressant Presence] 
	set PBact     [O2C2O Cluster $Cl Categorie Bacteria             Presence] 
	set PFirm     [O2C2O Cluster $Cl Categorie Firmicutes           Presence] 
	set PProteo   [O2C2O Cluster $Cl Categorie Proteobacteria       Presence] 
	set PArchaea  [O2C2O Cluster $Cl Categorie Archaea              Presence] 
	set PEu       [O2C2O Cluster $Cl Categorie Eukaryota            Presence] 
	
	set InfoCl "$Cl\t$TCl\t$Orf\t$PAllOrga\t$POrgasInt\t$PBact\t$PFirm\t$PProteo\t$PArchaea\t$PEu" 
	foreach Def [InterrogeGeneOntology $FichierGO Groupe $Cl Type "process" LesDefinitions] { 
	    append InfoCl "\t$Def"} 
	lappend LesInfos $InfoCl     
	} 
	EspionneL $LesInfos 
	return 
    
}

proc Compare2Listes {} {

    set RMAtrouveDsdChip 0; set dChiptrouveDsRMA 0
    set FichierRMA "[RepertoireDuGenome]/transcriptomique/ConeSpe/ListeRMAExp2J15Cond"
    set FichierdChip "[RepertoireDuGenome]/transcriptomique/ConeSpe/ListedChipExp2J15Cond"
    foreach ElmtRMA [LesLignesDuFichier $FichierRMA] {
	foreach ElmtdChip [LesLignesDuFichier $FichierdChip] {
	    if {$ElmtRMA==$ElmtdChip} { 
		incr RMAtrouveDsdChip
		break
	    }
	}
    }
    foreach ElmtdChip [LesLignesDuFichier $FichierdChip] {
	foreach ElmtRMA [LesLignesDuFichier $FichierRMA] {
	    if {$ElmtRMA==$ElmtdChip} {
		incr dChiptrouveDsRMA
		break
	    }
	}
    }
    Espionne "RMAtrouveDsdChip $RMAtrouveDsdChip"
    Espionne "dChiptrouveDsRMA $dChiptrouveDsRMA"

}

proc Compare2Puces {FichierDeLaPlusPetite FichierDeLaPlusGrande} {

    #exemple FichierDeLaPlusPetite: [RepertoireAffyAnnot na27]/MG430A_2.0/Mouse430A_2.na27.annot.csv
    #exemple FichierDeLaPlusGrande: [RepertoireAffyAnnot na27]/MG430_2.0/Mouse430_2.na27.annot.csv
    set totalpetite 0; set trouve 0
    set LesLignesDeLaPlusPetite [TabulonsSansQuote $FichierDeLaPlusPetite "," ";" " " "GetListOfValues"]
    set LesLignesDeLaPlusGrande [TabulonsSansQuote $FichierDeLaPlusGrande "," ";" " " "GetListOfValues"]
    foreach LigneDeLaPlusPetite $LesLignesDeLaPlusPetite {
	set oui 0
	set ElmtPetite [split $LigneDeLaPlusPetite ";"]
	set ProbesetidPetite [lindex $ElmtPetite 0]
	#set typePetite [lindex $ElmtPetite 4]
	#if {![regexp "Control" $typePetite]} {continue}
	incr totalpetite
	#Espionne "$totalpetite $ProbesetidPetite"
	foreach LigneDeLaPlusGrande $LesLignesDeLaPlusGrande {
	    set ElmtGrande [split $LigneDeLaPlusGrande ";"]
	    set ProbesetidGrande [lindex $ElmtGrande 0]
	    #set typeGrande [lindex $ElmtGrande 4]
	    #if {![regexp "Control" $typeGrande]} {continue}
	    #Espionne "ProbesetidGrande $ProbesetidGrande"
	    if {$ProbesetidPetite == $ProbesetidGrande} {
		#Espionne "$ProbesetidPetite trouve"
		set oui 1
		incr trouve
		break
	    }
	}
	if {!$oui} {Espionne "$ProbesetidPetite trouve pas"}
    }
    Espionne "totalpetite $totalpetite"
    Espionne "trouve $trouve"

}

proc CompareADN {Page {SansAffichage ""} {Titre ""}} {

    global CompareADN
    if {[info exists CompareADN]} {
	set DeuxPages $CompareADN
	append DeuxPages "\n$Page"
	unset CompareADN
	return [VoisinADN $DeuxPages $SansAffichage $Titre]
    }
    set CompareADN $Page
    set Message "Please click on the CompareADN button of an another window"
    FaireLire $Message
    return $Message

}

proc CompareADNDesFichiersTFA {F1 F2 {SansAffichage ""} {Titre ""}} {

    set T1 [ContenuDuFichier $F1]
    set T2 [ContenuDuFichier $F2]
    return [CompareADNDesTextesTFA $T1 $T2 $SansAffichage $Titre]

}

proc CompareADNDesTextesTFA {T1 T2 {SansAffichage ""} {Titre ""}} {

    set DeuxPages $T1
    append DeuxPages "\n"
    append DeuxPages $T2
    return [VoisinADN $DeuxPages $SansAffichage $Titre]

}

proc CompareAjOldNew {} {

    foreach Old [glob -nocomplain "[RepertoireDuGenome]/macsimXmlOld/*.aj"] {
	lappend LesOld [file tail $Old]
    }
    foreach New [glob -nocomplain "[RepertoireDuGenome]/macsimXml/*.aj"] {
	lappend LesNew [file tail $New]
    }
    #dans LesOld mais pas dans LesNew
    #set OldPasNew [ListsComplement $LesOld $LesNew]
    #EspionneL [lsort $OldPasNew]
    #Espionne [llength $OldPasNew]

    #dans LesNew mais pas dans LesOld
    set NewPasOld [ListsComplement $LesNew $LesOld]
    EspionneL [lsort $NewPasOld]
    Espionne [llength $NewPasOld]

    #dans LesOld et LesNew
    #set OldNew [ListsIntersection $LesOld $LesNew]
    #EspionneL $OldNew
    #Espionne [llength $OldNew]

}

proc CompareArCladeAncestor {A B} {

    #rR attention il y a aussi CompareCladeAncestor où on utilise directement JeSuisTonAncetre
    global ArClade
    ArClade
    if {$A==$B} { return 0 }
    if {[info exists ArClade($B,AncestorOf_$A)]} { return -1 }
    if {[info exists ArClade($A,AncestorOf_$B)]} { return  1 }
    return 0

}

proc CompareArbres {} {

    global TBoot TSum HashRef

    foreach e $TBoot {
	if {[info exists HashRef($e)]} {
	    incr TSum([set HashRef($e)])
	}
    }

    return

}

proc CompareCandidatsPaper1AvecAffymetrix {} {

    set Fichier "[GscopeDatabaseDir HeadNeck3]/FichierPaper1TousLesCodes"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s" codeclone codegscope
	foreach DD [RendsListeDesDDavec1Affy] {
	    if {$DD!=$codegscope} {continue}
	    lappend ListeDesCandidatsPourPaper1DansAffy $codegscope
	}
    }
    #Espionne [llength $ListeDesCandidatsPourPaper1DansAffy]
    #return $ListeDesCandidatsPourPaper1DansAffy
    foreach CandidatPaperOneAvecAffy $ListeDesCandidatsPourPaper1DansAffy {
	set MeilleurCop [lindex [LesMeilleursCopainsDuBlast $CandidatPaperOneAvecAffy blastnAffyHs] 0]
	if {$MeilleurCop=="no hits found" || $MeilleurCop=="No value"} {
	    set MeilleurCop [lindex [LesMeilleursCopainsDuBlast $CandidatPaperOneAvecAffy blastnAffymetrix]0]
	}
	#Espionne $MeilleurCop
	scan $MeilleurCop "%s %s" affy code
	lappend LesAffy $code
    }
    foreach Aff [ListeDesDifferentiellementExprimesSansJumeaux] {
	set Vu($Aff) 1
    }
    foreach Affy $LesAffy {
	if {! [info exists Vu($Affy)]} {continue}
	lappend LesAffyDiffExpr $Affy
    }
    Espionne [llength $LesAffyDiffExpr]
    return $LesAffyDiffExpr

}

proc CompareChroContLoc {LigneA LigneB} {

    scan $LigneA "%s %s %d" ChA CoA DebA
    scan $LigneB "%s %s %d" ChB CoB DebB

    if {$ChA<$ChB} { return -1 }
    if {$ChA>$ChB} { return  1 }

    if {$CoA<$CoB} { return -1 }
    if {$CoA>$CoB} { return  1 }

    if {[expr $DebA<$DebB]} { return -1 }
    if {[expr $DebA>$DebB]} { return  1 }
    return 0

}

proc CompareChroDebut {LigneA LigneB} {

    scan $LigneA "%s %d" ChA DebA
    scan $LigneB "%s %d" ChB DebB

    if {$ChA<$ChB} { return -1 }
    if {$ChA>$ChB} { return  1 }

    if {[expr $DebA<$DebB]} { return -1 }
    if {[expr $DebA>$DebB]} { return  1 }
    return 0

}

proc CompareChroDebutFin {A B} {

    scan $A "%s %s %d %d" NomA CA DA FA
    scan $B "%s %s %d %d" NomB CB DB FB

    if {[set C [string compare $CA $CB]]} { return $C }

    if { $DA < $DB } { return -1 } 
    if { $DA > $DB } { return  1 }

    if { $FA < $FB } { return -1 } 
    if { $FA > $BB } { return  1 }
    return 0

}

proc CompareChroFin {LigneA LigneB} {

    #compare les fins
    scan $LigneA "%s %d %d" ChA DebA FinA
    scan $LigneB "%s %d %d" ChB DebB FinB

    if {$ChA<$ChB} { return -1 }
    if {$ChA>$ChB} { return  1 }

    if {[expr $DebA<$DebB]} { return -1 }
    if {[expr $DebA>$DebB]} { return  1 }

    if {[expr $FinA<$FinB]} { return -1 }
    if {[expr $FinA>$FinB]} { return  1 }
    return 0

}

proc CompareCladeAncestor {A B} {

    #rR je crois que ça ne sert plus .. il suffit de trier les classes.
    #rR attention il y a aussi CompareArCladeAncestor où on a déjà mémorisé
    if {$A==$B} { return 0 }
    if {[JeSuisTonAncetre $B $A]} { return -1 }
    if {[JeSuisTonAncetre $A $B]} { return  1 }
    return 0

}

proc CompareClonesMembraneAuxOverlapsDDAffy {} {

    set FichierMb "[RepertoireDuGenome]/compar_profils_mb_gscope"
    foreach Ligne [LesLignesDuFichier $FichierMb] {
	set Ligne [string trim $Ligne]
	if {$Ligne=={}} {continue}
	#set CC [lindex $Ligne 0]
	set DD [lindex $Ligne 1]
	set Vu($DD) 1
	set ProfilMb [lindex $Ligne 2]
	set PMb($DD) $ProfilMb
    }
    set FichierOv "[RepertoireDuGenome]/OverlapEtProfils"
    ###profils DD puis Affy
    set LesMbsOverlap {}
    set NbDA 0; set NbMA 0
    foreach Ligne [LesLignesDuFichier $FichierOv] {
	set Ligne [string trim $Ligne]
	if {$Ligne=={}} {continue}
	set Nom [lindex $Ligne 0]
	if {[info exists Vu($Nom)]} {
	    set NomAffy [lindex $Ligne 1]
	    set CodeAffy [lindex $Ligne 2]
	    set ProfDD [lindex $Ligne 3]
	    set ProfAffy [lindex $Ligne 4]
	    if {[info exists PMb($Nom)]} {
		#set ProfMb $PMb($Nom)
		if {$ProfDD==$ProfAffy} {incr NbDA ; set ComparDA 1} else {set ComparDA 0}
		if {$PMb($Nom)==$ProfAffy} {incr NbMA ; set ComparMA 1} else {set ComparMA 0}
		lappend LesMbsOverlap "$Nom\t$NomAffy\t$CodeAffy\t$ProfDD\t$ProfAffy\t$ComparDA\t$PMb($Nom)\t$ComparMA"
	    }
	}
    }
    if {$LesMbsOverlap!={}} {
	SauveLesLignes $LesMbsOverlap dans "[RepertoireDuGenome]/Mbs_OverlapAffy"
    }
    Espionne "compar DD-Affy: $NbDA bons; compar Mb-Affy: $NbMA bons"
    return [llength $LesMbsOverlap]

}

proc CompareCluspackMsfclust {} {

    foreach D [glob -nocomplain "[RepertoireDuGenome]/cluspack/*.clust"] {
	set QueueC [file tail $D]
	regsub ".clust" $QueueC "" QueueC
	lappend LesQueueC $QueueC
    }
    #EspionneL $LesQueueC
    foreach F [glob -nocomplain "[RepertoireDuGenome]/msfclust/*"] {
	set jaitrouve 0
	set QueueM [file tail $F]
	foreach Q $LesQueueC {
	    if {$QueueM==$Q} {
		set jaitrouve 1
		#Espionne "ok"
		break
	    }
	}
	if {!$jaitrouve} {
	   Espionne "$F pas ds msfclust"
	}
    }

}

proc CompareDate {D1 D2} {

    regsub -all {[\-\.\:/]} $D1 " " D1
    regsub -all { +} [string trim $D1] " " D1
    regsub -all {[\-\.\:/]} $D2 " " D2
    regsub -all { +} [string trim $D2] " " D2
    set J1 0; set M1 0; set A1 0
    regexp {^([^ ]+)$}                 $D1 Match       A1
    regexp {^([^ ]+) ([^ ]+)$}         $D1 Match    M1 A1
    regexp {^([^ ]+) ([^ ]+) ([^ ]+)$} $D1 Match J1 M1 A1
    set J2 0; set M2 0; set A2 0
    regexp {^([^ ]+)$}                 $D2 Match       A2
    regexp {^([^ ]+) ([^ ]+)$}         $D2 Match    M2 A2
    regexp {^([^ ]+) ([^ ]+) ([^ ]+)$} $D2 Match J2 M2 A2

    set Mois1 $M1
    set Mois2 $M2

    if {$A1<$A2} { return -1 }
    if {$A1>$A2} { return  1 }
    if {[regexp {^[0-9]+$} $Mois1]} {set M1 $Mois1} else { set M1 [Month1to12 $Mois1] }
    if {[regexp {^[0-9]+$} $Mois2]} {set M2 $Mois2} else { set M2 [Month1to12 $Mois2] }
    set M1 [Base10 $M1]
    set M2 [Base10 $M2]
    if {$M1<$M2} { return -1 }
    if {$M1>$M2} { return  1 }
    set J1 [Base10 $J1]
    set J2 [Base10 $J2]
    if {$J1<$J2} { return -1 }
    if {$J1>$J2} { return  1 }
    return 0

}

proc CompareDeuxFichiersDeCodes {F1 {F2 ""}} {

    if {$F2==""} {set Liste2 [ListeDesPABs]} else {set Liste2 [LesLignesDuFichier $F2]}
    if {![file exists $F1]} {return}

    foreach Ligne [LesLignesDuFichier $F1] {
	set Ligne [string trim $Ligne]
	scan $Ligne "%s %s" g cl
	set Clone $cl
	set Vu($Clone) 1
    }
    foreach Ligne $Liste2 {
	set Ligne [string trim $Ligne]
	set Clone [ExtraitInfo $Ligne "CodeClone"]
	if {![info exists Vu($Clone)]} {continue}
	Espionne coucou
	lappend LesCommuns $Ligne
    }
    return $LesCommuns

}

proc CompareDeuxFichiersFold {F1 {F2 ""}} {

    if {$F2==""} {set Liste2 [ListeDesPABs]} else {set Liste2 [LesLignesDuFichier $F2]}
    if {![file exists $F1]} {return}

    foreach Ligne [LesLignesDuFichier $F1] {
	set Ligne [string trim $Ligne]
	scan $Ligne "%s %s" g e
	if {$e=="0"} {set Vu($g) 1}
    }
    foreach Ligne $Liste2 {
	#set Ligne [string trim $Ligne]
	scan $Ligne "%s" gs 
	if {![info exists Vu($gs)]} {continue}
	lappend LesZeros $Ligne
    }
    return $LesZeros

}

proc CompareDeuxSetsDeGenes {} {

    set LesHere [split [ContenuDuFichier mfHere.txt] " "]
    set iOk 0
    foreach H $LesHere {
	if {[regexp {Gm[0-9]+} $H]} { continue }
	if {[regexp {n\-} $H]} { continue }
	incr iOk
    }
    Espionne $iOk
    set LesDown [split [ContenuDuFichier mfDown.txt] " "]
    set LesDiff [ListsComplement $LesDown $LesHere]
    set LesInte [ListsIntersection $LesHere $LesDown]
    Espionne [llength $LesHere]
    Espionne [llength $LesDiff]
    Espionne [llength $LesDown]
#    Espionne [expr [llength $LesDown] - $iGm]
    Espionne [llength $LesInte]
    Affiche [lrange $LesHere 0 100] "" LesHere
    Affiche [lrange $LesDiff 0 100] "" LesDiff

}

proc CompareDeuxTablesCodonFrequency {FichierCodMusRef FichierCodSeq} {

    #test statistique au risque 5%
    if {![file exists $FichierCodSeq] || ![file exists $FichierCodMusRef]} {return}
    set Nom [file tail $FichierCodSeq]
    set ListeMusRef [CreeListeCodonFrequency $FichierCodMusRef]
    set ListeSeq [CreeListeCodonFrequency $FichierCodSeq]
    set LesDifferences {}
    foreach AaCodonFrequenceMusRef $ListeMusRef AaCodonFrequenceSeq $ListeSeq {
	if {[lindex $AaCodonFrequenceMusRef 1]==[lindex $AaCodonFrequenceSeq 1]} {
	    set FreqMusRef [lindex $AaCodonFrequenceMusRef 2]
	    set FreqSeq [lindex $AaCodonFrequenceSeq 2]
	    #Espionne "$FreqMusRef $FreqSeq"
	    if {$FreqMusRef==$FreqSeq} {continue}
	    set PourEcartType [expr ((($FreqMusRef*(1-$FreqMusRef))/1000)+(($FreqSeq*(1-$FreqSeq))/1000))] 
	    #Espionne $PourEcartType
	    set EcartType [expr sqrt($PourEcartType)]
	    set Difference [expr (abs($FreqMusRef-$FreqSeq))]
	    set Borne [expr $EcartType*1.96]
	    #Espionne "[lindex $AaCodonFrequenceSeq 1] $Difference $Borne"
	    if {$Difference>$Borne} {
		#alors l' hypothese nulle est rejettee au seuil 5%
		set Difference [format "%.4f" $Difference]
		set Borne [format "%.4f" $Borne]
		set Dif [expr (abs($Difference-$Borne))]
		lappend LesDifferences "$Nom\t[lindex $AaCodonFrequenceSeq 0]\t[lindex $AaCodonFrequenceSeq 1]\t$Difference\t$Borne\t$Dif"
	    }
	}
    }
    set LesDifferences [lsort -index 5 -decreasing $LesDifferences]
    return $LesDifferences

}

proc CompareEC {A B} {

    regsub -nocase "EC " $A "" A
    regsub -nocase "EC " $B "" B
    regsub -all -- {\-} $A "0" A
    regsub -all -- {\-} $B "0" B
    set LesA [split $A "\."]
    set LesB [split $B "\."]
    foreach C {0 1 2 3} {
	if {[lindex $LesA $C] < [lindex $LesB $C]} {
	    return -1
	}
	if {[lindex $LesA $C] > [lindex $LesB $C]} {
	    return 1
	}
    }
    return 0

}

proc CompareElm {} {

    set RepertoireOut "[RepertoireDuGenome]/compareElm"
    if {! [file exists $RepertoireOut]} {file mkdir $RepertoireOut}
    foreach Box [ListeDesPABs] {
	if {$Box!="SP0001"} {continue}
	set LesLignesFic {}
	if {[info exists InfoElmRef]} { unset InfoElmRef }
	set LesElmRef {}

	if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} {
	    set Org Mouse
	} elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set Org Rat
	} else {
	    set Org SpliRet
	}
	
	set Cluster   [ExtraitInfo $Box "Cluster"]
	set Ref       [ExtraitInfo $Box "Ref"]
	set LesNamesInitials  [InterrogeNames $Cluster Name $Org]
	foreach Name $LesNamesInitials {
	    if {$Name==$Ref} {set Name $Box}
	    lappend LesNames $Name
	} 

	if {$Org=="SpliRet"} {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit.elm"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit.elm"}
	} else {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	}
	
	#Espionne ""
	Espionne "$Box $Cluster"
	#Espionne "$FileMacsims"
	#Espionne "$LesNames"
	#Espionne "$Ref"
	#Ref et Box represente la meme seq
	set LesElmInfoRef [FromMacsims $FileMacsims $Box "ConcatElm"]
	
	InitPosRel2Abs $FileMacsims $LesNames
	
	foreach InfoRef $LesElmInfoRef {
	    #Espionne "InfoRef $InfoRef"
	    lassign $InfoRef ElmRef RFstart RFstop
	    set ElmRef [string toupper $ElmRef]
	    #Espionne "ElmRef $ElmRef"
	    lappend LesElmRef $ElmRef
	    lappend InfoElmRef($ElmRef) $InfoRef
	}
	set LesElmRef [lsort -unique $LesElmRef]
	foreach Name $LesNames {
	    set differe 0
	    if {[info exists InfoElmName]} { unset InfoElmName }
	    if {$Name==$Box} {continue}

	    set LesElmInfoName [FromMacsims $FileMacsims $Name "ConcatElm"]

	 #   Espionne
	  #  Espionne "Name $Name" 
	    set LigneFic "$Name:"
	    lappend LesLignesFic $LigneFic
	    set LesElmInfoName [ListeSsElmtVide $LesElmInfoName]
	    #EspionneL "$LesElmInfoName"
	   # Espionne "LesGainsPertes:"

	    if {$LesElmInfoName=={}} {
		set differe 1
		foreach ElmRef $LesElmRef {
		    foreach InfoRef $InfoElmRef($ElmRef) {
			lassign $InfoRef ElmRef RFstart RFstop
			set AbsRFstart [DonnePosRA $Box $RFstart Absolue] 
			set AbsRFstop  [DonnePosRA $Box $RFstop Absolue]
			set ResultPerdu [SiteElmPerdu $InfoRef $Name $AbsRFstart $AbsRFstop $RFstart $RFstop]
			#Espionne "$ResultPerdu"
			set LigneFic "$ResultPerdu"
			lappend LesLignesFic $LigneFic
		    }
		}
		continue
	    }
	    foreach InfoName $LesElmInfoName {
		lassign $InfoName ElmName Fstart Fstop
		set ElmName [string toupper $ElmName]
		lappend InfoElmName($ElmName) $InfoName
		if { ! [info exists InfoElmRef($ElmName)]} {
		    set differe 1
		    set ResultGagne [SiteElmGagne $InfoName $Name] 
		   # Espionne "$ResultGagne"
		    set LigneFic "$ResultGagne"
		    lappend LesLignesFic $LigneFic
		}
	    }
	    foreach ElmRef $LesElmRef {
		foreach InfoRef $InfoElmRef($ElmRef) {
		    lassign $InfoRef ElmRef RFstart RFstop
		    set AbsRFstart [DonnePosRA $Box $RFstart Absolue] 
		    set AbsRFstop  [DonnePosRA $Box $RFstop Absolue]
		    set RelFstart [DonnePosRA $Name $AbsRFstart Relative]
		    set RelFstop [DonnePosRA $Name $AbsRFstop Relative]
		    if { ! [info exists InfoElmName($ElmRef)]} {
			set differe 1
			set ResultPerdu [SiteElmPerdu $InfoRef $Name $AbsRFstart $AbsRFstop $RelFstart $RelFstop]
			#Espionne "3 $ResultPerdu"
			set LigneFic "$ResultPerdu"
			lappend LesLignesFic $LigneFic
		    } else {
			set TousAbsents 1
			foreach InfoName $InfoElmName($ElmRef) {
			    lassign $InfoName ElmName RelFstartPrTest RelFstopPrTest
			    set AbsFstart [DonnePosRA $Name $RelFstartPrTest Absolue] 
			    set AbsFstop [DonnePosRA $Name $RelFstopPrTest Absolue] 
			    if {[Recouvrement $AbsRFstart $AbsRFstop $AbsFstart $AbsFstop]} {
				set TousAbsents 0
				break
			    }
			}
			if { $TousAbsents } { 
			    set differe 1
			    set ResultPerdu [SiteElmPerdu $InfoRef $Name $AbsRFstart $AbsRFstop $RelFstart $RelFstop]
			 #   Espionne "4 $ResultPerdu"
			    set LigneFic "$ResultPerdu"
			    lappend LesLignesFic $LigneFic
			} 
		    }
		}
	    }
	    if {!$differe} {
		#Espionne "   $Name rien gagne rien pris"
		set LigneFic "   $Name rien gagne rien perdu"
		lappend LesLignesFic $LigneFic
	    }
	}
	#Espionne "resume"
	#EspionneL "$LesLignesFic"
	SauveLesLignes $LesLignesFic dans "$RepertoireOut/$Box"
    }	

}

proc CompareFlottant {LA LB {Ieme ""} {S ""}} {

    if {$Ieme==""} { set Ieme 9 }
    if {$S==""} { set S ";" }
    set EA [lindex [split $LA $S] $Ieme]
    set EB [lindex [split $LB $S] $Ieme]
    return [CompareLesFloats $EA $EB]

}

proc CompareFlottantEn5 {LA LB} {

    set Ieme 5
    set S ";" 
    set EA [lindex [split $LA $S] $Ieme]
    set EB [lindex [split $LB $S] $Ieme]
    return [CompareLesFloats $EA $EB]

}

proc CompareGO200904EtGO201009 {} {

    #liste Pfam obtenue avec requete [GoGetFromGo GO:0005488 PFAM "" "" "Down"] avec version 2009 et 2010
    set File2009 "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/BindingPfamDesFromGo.txt"
    set File2010 "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/BindingPfamDesFromGo2010.txt"
    set commun 0; set spe2009 0; set commun2 0 ; set spe2010 0
    foreach Ligne2009 [LesLignesDuFichier $File2009] {
	set Pfam2009  [lindex [split $Ligne2009 "\t"] 0]
	set trouve 0
	foreach Ligne2010 [LesLignesDuFichier $File2010] {
	    set Pfam2010  [lindex [split $Ligne2010 "\t"] 0]
	    if {$Pfam2009==$Pfam2010} {
		set trouve 1
		break
	    }
	}
	if {$trouve}  {incr commun}
	if {!$trouve} {
	    Espionne "$Pfam2009 spe2009"
	    incr spe2009
	}
    }
    foreach Ligne2010 [LesLignesDuFichier $File2010] {
	set Pfam2010  [lindex [split $Ligne2010 "\t"] 0]
	set trouve 0
	foreach Ligne2009 [LesLignesDuFichier $File2009] {
	    set Pfam2009  [lindex [split $Ligne2009 "\t"] 0]
	    if {$Pfam2010==$Pfam2009} {
		set trouve 1
		break
	    }
	}
	if {$trouve}  {incr commun2}
	if {!$trouve} {
	    Espionne "$Pfam2010 spe2010"
	    incr spe2010
	}
    }
    Espionne "commun  $commun"
    Espionne "commun2 $commun2"
    Espionne "spe2009 $spe2009"
    Espionne "spe2010 $spe2010"

}

proc CompareGoCounts {X Y} {

    regsub -all {[^ 0-9\.]} $X " " X 
    regsub -all {[^ 0-9\.]} $Y " " Y 
    scan $X "%f %d %d %d %d %d" ABx SAx SBx NAx NBx NABx
    scan $Y "%f %d %d %d %d %d" ABy SAy SBy NAy NBy NABy
    if {$ABx<$ABy} { return -1 }
    if {$ABx>$ABy} { return  1 }
    if {$SAx<$SAy} { return -1 }
    if {$SAx>$SAy} { return  1 }
    if {$SBx<$SBy} { return  1 }
    if {$SBx>$SBy} { return -1 }
    if {$NAx<$NAy} { return -1 }
    if {$NAx>$NAy} { return  1 }
    if {$NBx<$NBy} { return  1 }
    if {$NBx>$NBy} { return -1 }
    return 0

}

proc CompareHG_U95AEtHG_U95Av2 {} {

    WithWebService "Gx" 0
    set Sql "select pk_probeset, pk_arraytype from ln_arraytype_probeset where pk_arraytype = 11 or pk_arraytype = 13 order by pk_probeset;"
    set i 0; set j 0; set m 0; set n 0
    foreach {pk_probeset pk_arraytype} [GxDbSqlExec $Sql "GetList"] {
	#Espionne "$pk_probeset $pk_arraytype"
	if {![info exists DejaVu($pk_probeset)]} {set DejaVu($pk_probeset) 0}
	incr DejaVu($pk_probeset)
    }
    foreach Clef [array names DejaVu] {
	if {$DejaVu($Clef)==1} {
	    incr i
	    lappend LesProbesetUniques $Clef
	} else {
	    incr j
	}
    }
    foreach PsUnique $LesProbesetUniques {
	set Sql2 "select pk_probeset, pk_arraytype from ln_arraytype_probeset where (pk_arraytype = 11 or pk_arraytype = 13) and pk_probeset = $PsUnique order by pk_arraytype;"
	foreach {pk_probeset pk_arraytype} [GxDbSqlExec $Sql2 "GetList"] {
	    Espionne "$pk_arraytype $pk_probeset"
	    if {$pk_arraytype == 11} {incr m}
	    if {$pk_arraytype == 13} {incr n}
	}
    }
    Espionne "$i"
    Espionne "11 $m"
    Espionne "13 $n"
    Espionne "$j"

}

proc CompareIeme {LA LB {Ieme ""} {S ""}} {

    if {$Ieme==""} { set Ieme 0 }
    if {$S==""} { set S ";" }
    set A [lindex [split $LA $S] $Ieme]
    set B [lindex [split $LB $S] $Ieme]
    return [string compare $A $B]

}

proc CompareIntegerFromMacsims {LA LB} {

    set IndexLA1 [string last "/" $LA]
    set IndexLA2 [string last "-" $LA]
    set DA [string range $LA $IndexLA1+1 $IndexLA2-1]
    set FA [string range $LA $IndexLA2+1 end]
    set IndexLB1 [string last "/" $LB]
    set IndexLB2 [string last "-" $LB]
    set DB [string range $LB $IndexLB1+1 $IndexLB2-1]
    set FB [string range $LB $IndexLB2+1 end]
    set Result [CompareLesIntegers $DA $DB]
    if {$Result==0} {
	return [CompareLesIntegers $FA $FB]
    } else {
	return $Result
    }

}

proc CompareIntegerInFeaturesDesPfam {LA LB} {

    set EA [lindex [split $LA " "] 1]
    set EB [lindex [split $LB " "] 1]
    return [CompareLesIntegers $EA $EB]

}

proc CompareKgPg {} {

    set fichierKG "[Fiches]/parseKG"
    set fichierPG "[Fiches]/parsePG"
    set LesLignesDuFichierPG [LesLignesDuFichier $fichierPG]
    set LesLignesDuFichierKG [LesLignesDuFichier $fichierKG]
    set I 0
    
    foreach LignePG $LesLignesDuFichierPG {
	if {$LignePG==""} {continue}
	set Nom [lindex [split $LignePG " "] 0]
	set LocalisationFinalPG [string range $LignePG 5 end]
	set LocalisationFinalPG [string trim $LocalisationFinalPG]
	if {[regexp "nolocalisation" $LignePG]} {
	    set LigneKG [lindex $LesLignesDuFichierKG $I]
	    set LocalisationFinalKG [string range $LigneKG 5 end]
	    set LocalisationFinalKG [string trim $LocalisationFinalKG]
	    if {[regexp "nolocalisation" $LigneKG]} {
		InformeSansDemander $Nom "Localisation: $LocalisationFinalPG"
	    } else {
		InformeSansDemander $Nom "Localisation: $LocalisationFinalKG"
	    }
	} else {
	    InformeSansDemander $Nom "Localisation: $LocalisationFinalPG"
	}
	incr I
    }

}

proc CompareKnownGenesEtRefGenes {} {

    set NbNom 0; set Vides 0; set Pleins 0; set ssloc 0; set locds2 0; set locds2meme 0; set locds2diff 0; set locdsgbrs 0; set locdsrs 0
    foreach Nom [ListeDesPABs] { 
	Espionne ""
	incr NbNom
	set LocUcsc ""
	set dsles2 0

	set Access [AccessEvi $Nom]

	if {$Access==""} {
	    incr Vides
	    continue
	}

	if {$Access!=""} {
	    incr Pleins
	    puts "$Nom $Access"

	    set LocUcscGbRs [ExtraitInfo $Nom "LocUcscFrom200503"]
	    set LocUcscRs [ExtraitInfo $Nom "LocUcscRefSeqFrom200503"]
	    puts "LocUcscGbRs= $LocUcscGbRs"
	    puts "LocUcscRs= $LocUcscRs"
	    if {![regexp {[0-9]+} $LocUcscGbRs] && ![regexp {[0-9]+} $LocUcscRs]} {
		incr ssloc
		set LocUcsc ""
		puts "pas de loc"
	    }

	    if {[regexp {[0-9]+} $LocUcscGbRs] && [regexp {[0-9]+} $LocUcscRs]} {
		set dsles2 1
		incr locds2
		if {$LocUcscGbRs == $LocUcscRs} {
		    incr locds2meme
		    set LocUcsc $LocUcscGbRs
		    puts "info est meme"
		} else {
		    incr locds2diff
		    puts "info est pas meme"
		}
	    }

	    if {!$dsles2 && [regexp {[0-9]+} $LocUcscGbRs]} {
		incr locdsgbrs
		set LocUcsc $LocUcscGbRs
		puts "prends GbRs"
	    }
	    if {!$dsles2 && [regexp {[0-9]+} $LocUcscRs]} {
		incr locdsrs
		set LocUcsc $LocUcscRs
		puts "prends Rs"
	    } 
	    puts "LocUcsc= $LocUcsc"
	    puts ""
	}
    }
    puts "nb total= $NbNom"
    puts "nb vide= $Vides"
    puts "nb plein= $Pleins"
    puts ""
    puts "ssloc= $ssloc"
    puts "locds2 $locds2"
    puts "locds2meme= $locds2meme"
    puts "locds2diff= $locds2diff"
    puts "locdsgbrs= $locdsgbrs"
    puts "locdsrs $locdsrs"

}

proc CompareLaVADesNombres {a b} {

    set a [expr abs($a)]
    set b [expr abs($b)]
    if {$a < $b} {return -1}
    if {$a > $b} {return  1}
    return 0

}

proc CompareLeDeuxiemeChamp {LigneA LigneB} {


    scan $LigneA "%s %f" A a
    scan $LigneB "%s %f" B b

    if {[expr $a <  $b]} { return -1}
    if {[expr $a == $b]} { return  0}
    if {[expr $a  > $b]} { return  1}

}

proc CompareLeTroisiemeChamp {LigneA LigneB} {


    scan $LigneA "%s %s %f" A AA a
    scan $LigneB "%s %s %f" B BB b

    if {[expr $a <  $b]} { return -1}
    if {[expr $a == $b]} { return  0}
    if {[expr $a  > $b]} { return  1}

}

proc CompareLesAccessProt {} {

    set Total 0; set meme 0; set diff 0
    set FichierFred "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisisOld"
    foreach Ligne [LesLignesDuFichier $FichierFred] {
	scan $Ligne "%s %s" Nom Prot
	if {$Prot=="NoProtein"} {continue}
	incr Total
	set IdEtAccessProt [ExtraitInfo $Nom "Id et Access prot:"]
	set LesInfosProt [split $IdEtAccessProt " "]
	set AccessProt [lindex $LesInfosProt 1]
	if {$AccessProt==""} {continue}
	if {$Prot==$AccessProt} {
	    #Espionne "meme"
	    #Espionne "$Nom $Prot $AccessProt"
	    incr meme
	} else {
	    #Espionne "diff"
	   Espionne "$Nom"
	    #Espionne "$Nom $Prot $AccessProt"
	    incr diff
	}
    }
    #Espionne "total= $Total"
    #Espionne "meme = $meme"
    #Espionne "diff = $diff"

}

proc CompareLesAttributionsAvecLaVersionPrecedente {} {

    set NvFichier "[RepertoireDuGenome]/parser2007/NewAttriToutVf"
    set premieresousligne 0; set nblignes 0; set pareil 0; set different 0
    foreach Ligne [LesLignesDuFichier $NvFichier] {
	if {[regexp {^ligne} $Ligne]} {
	    incr nblignes
	    set premieresousligne 0 
	    set NumeroLigne [StringApres "ligne " dans $Ligne]
	    continue
	}
	if {!$premieresousligne} {
	    set LesNvxAccEvi {}; set LesAccEvi {}
	    set premieresousligne 1
	    if {[regexp "bidon" $Ligne]} {
		set NvxAccEvi $Ligne
	    } else {
		set LesNvxAccEvi [split $Ligne " "]
		set LesNvxAccEvi [lsort $LesNvxAccEvi]
		set NvxAccEvi [join $LesNvxAccEvi " "]
	    }

	    set TousLesNoms  [NomLigne $NumeroLigne Noms]
	    set ListeDesNoms [split $TousLesNoms " "]
	     set pasaccess 0
	    foreach Nom $ListeDesNoms {
		set Access [AccessEvi $Nom]
		if {$Access==""} {
		    set pasaccess 1
		    set Raison [StringSuivant " " dans [lindex [LesLignesDuFichier "[RepertoireDuGenome]/nuctfa/$Nom"] 0]]
		    set AccEvi $Raison
		} else {
		    lappend LesAccEvi $Access
		}
	    }
	    if {!$pasaccess} {
		set LesAccEvi [lsort $LesAccEvi]
		set AccEvi [join $LesAccEvi " "]
	    }
	    if {[string equal $NvxAccEvi $AccEvi]} {
		incr pareil
		#Espionne "pareil"
	    } else {
		incr different
		Espionne ""
		Espionne "$NumeroLigne"
		Espionne "Ancien $AccEvi"
		Espionne "Nouvea $NvxAccEvi"
		Espionne "different"
	    }
	}
    }
    Espionne "nbtotal = $nblignes"
    Espionne "nbdepareil = $pareil"
    Espionne "nbdediffer = $different"

}

proc CompareLesExpectsDesSegments {TexteA TexteB} {


    scan $TexteA "%s %s %s %s %s %s %s %f" Trou Sens Frame BanqueId Debut Fin Long a
    scan $TexteB "%s %s %s %s %s %s %s %f" Trou Sens Frame BanqueId Debut Fin Long b

    if {[expr double($a) <  double($b)]} { return -1}
    if {[expr double($a) == double($b)]} { return  0}
    if {[expr double($a)  > double($b)]} { return  1}

}

proc CompareLesFichiersMasques {Nom} {

    ####################################################
    global RepertoireDuGenome

    ####################################################
    ####################################################

    set FichierOriginal "$RepertoireDuGenome/nuctfa/$Nom"
    set RepNucOriginaux "$RepertoireDuGenome/nuctfa"

    ####################################################
    set FichierMasque "$RepertoireDuGenome/nucmask/$Nom.m"
    set RepNucMask "$RepertoireDuGenome/nucmask"

    ####################################################
    set FichierReMasque "$RepertoireDuGenome/nucmask/$Nom.rm"
    set RepNucReMask "$RepertoireDuGenome/nucmask"

    ####################################################
    set FichierMasqueEtReMasque "$RepertoireDuGenome/nucmask/$Nom.mrm"
    set RepNucMaskAndReMask "$RepertoireDuGenome/nucmask"

    ####################################################
    ####################################################

    if {       ! [file exists $FichierOriginal]  || ! [file exists $FichierMasque]    || ! [file exists $FichierReMasque] || ! [file exists $FichierMasqueEtReMasque]} {
	return "$Nom"
    }

    ####################################################
    ####################################################
    
    set SeqOriginale [string toupper [QueLaSequenceDuTFA $FichierOriginal]]
    set SeqMasquee   [string toupper [QueLaSequenceDuTFA $FichierMasque]]
    set SeqReMasquee [string toupper [QueLaSequenceDuTFA $FichierReMasque]]
    set SeqMasqueeEtReMasquee [string toupper [QueLaSequenceDuTFA $FichierMasqueEtReMasque]]
    #######Masquage###################################

    if {$SeqOriginale == $SeqMasquee} {
	set ValeurDuMasque ""
    } else {
	set ValeurDuMasque "Masked"
    }

    #######ReMasquage#################################

    if {$SeqOriginale == $SeqReMasquee} {
	set ValeurDuReMasque ""
    } else {
	set ValeurDuReMasque "ReMasked"
    }

    #######MasquageEtReMasquage#################################
    if {$SeqOriginale == $SeqMasqueeEtReMasquee} {
	set ValeurDuMasqueEtReMasque ""
    } else {
	if {    $ValeurDuMasque   == "Masked"     &&  $ValeurDuReMasque == "ReMasked"} {
	    set ValeurDuMasqueEtReMasque "Masked \& ReMasked"
	} elseif { $ValeurDuMasque   == ""     &&  $ValeurDuReMasque == "ReMasked"} {
	    set ValeurDuMasqueEtReMasque "Just ReMasked"
	} elseif  { $ValeurDuMasque   == "Masked"     &&  $ValeurDuReMasque == ""} {
	    set ValeurDuMasqueEtReMasque "Just Masked"
	} 
    } 
    ####################################################
    ####################################################

    set NomsDesRepeatsDuM   [join [LesRepeatsDeLEnteteDuTFA $FichierMasque          ] " "]
    set NomsDesRepeatsDuRM  [join [LesRepeatsDeLEnteteDuTFA $FichierReMasque        ] " "]
    set NomsDesRepeatsDuMRM [join [LesRepeatsDeLEnteteDuTFA $FichierMasqueEtReMasque] " "]

    ####################################################
    ####################################################

    set TailleDeLaSeqOriginale          [string length $SeqOriginale         ]
    set TailleDeLaSeqMasquee            [string length $SeqMasquee           ]
    set TailleDeLaSeqReMasquee          [string length $SeqReMasquee         ]
    set TailleDeLaSeqMasqueeEtReMasquee [string length $SeqMasqueeEtReMasquee]
    ####################################################
    ####################################################
    
    if     {$TailleDeLaSeqOriginale != $TailleDeLaSeqMasquee   ||  $TailleDeLaSeqOriginale != $TailleDeLaSeqReMasquee ||  $TailleDeLaSeqOriginale != $TailleDeLaSeqMasqueeEtReMasquee} {
	set TailleDesSequences -999
    } else { set TailleDesSequences $TailleDeLaSeqOriginale }
    
    ####################################################
    ####################################################
    if {$TailleDesSequences != "ERREUR"} {
	####################################################
	set NbDeDiffAvecMasque           [NombreDeBasesDansRepeat $SeqOriginale $SeqMasquee]
	set NbDeDiffAvecReMasque         [NombreDeBasesDansRepeat $SeqOriginale $SeqReMasquee]
	set NbDeDiffAvecMasqueEtReMasque [NombreDeBasesDansRepeat $SeqOriginale $SeqMasqueeEtReMasquee]
	####################################################
	set PourcentagedeReMasquage           [PourcentageArrondiSup $NbDeDiffAvecReMasque $TailleDesSequences]
	set PourcentagedeMasquage             [PourcentageArrondiSup $NbDeDiffAvecMasque $TailleDesSequences]
	set PourcentagedeMasquageEtReMasquage [PourcentageArrondiSup $NbDeDiffAvecMasqueEtReMasque $TailleDesSequences]

    } else {
	set PourcentagedeMasquage "Erreur"
	set PourcentagedeReMasquage "Erreur"
	set PourcentagedeMasquageEtReMasquage "Erreur"
    }
   
    ####################################################
    ####################################################
    
    if {    $PourcentagedeReMasquage == 0 && $PourcentagedeMasquage == 0 &&  $PourcentagedeMasquageEtReMasquage == 0 } {
	set PourcentagedeReMasquage ""
	set PourcentagedeMasquage ""
	set PourcentagedeMasquageEtReMasquage ""
    }

    set LigneDuTableau [format "%s %4d %4s %4s %4s %-8s %-10s %-19s M\=%-s \; RM\=%-s"  $Nom  $TailleDesSequences  $PourcentagedeMasquage  $PourcentagedeReMasquage  $PourcentagedeMasquageEtReMasquage $ValeurDuMasque  $ValeurDuReMasque $ValeurDuMasqueEtReMasque $NomsDesRepeatsDuM $NomsDesRepeatsDuRM
    ]
    return $LigneDuTableau

}

proc CompareLesFichiersMasquesPourTous {} {

    ####################################################
    global RepertoireDuGenome

    set nTot 0
    set nMTot 0
    set nM 0
    set nRM 0
    set nMRM 0

    foreach Nom [ListeDesPABs] {
	set Ligne [CompareLesFichiersMasques $Nom]
	if {[regexp " Masked " $Ligne]} { incr nM }
	if {[regexp " ReMasked " $Ligne]} { incr nRM }
	if {[regexp " Masked " $Ligne] &&  [regexp " ReMasked " $Ligne]} { incr nMRM }
	incr nTot
	if {    [regexp " Masked "   $Ligne] || [regexp " ReMasked " $Ligne] } {
	    incr nMTot
	    Espionne $Ligne
	    append Tableau "$Ligne\n"
	}
    }
    Espionne "NbFichier\:$nTot NbFichiersAvecRepeats\:$nMTot Masked\:$nM ReMasked\:$nRM MRM\:$nMRM"

    if {[OuiOuNon "Do I save these Results ?"]} {
	set Fichier [FichierPourSaveAs "CompareMaskReMask.txt"]
	if {$Fichier!=""} {
	    Sauve $Tableau dans $Fichier
	}
    }
    return ""

}

proc CompareLesFichiersTFAEtComplete {Fichier1 Fichier2} {

    set LesAccessFichier1 {}
    set i 0
    foreach Ligne [LesLignesDuFichier $Fichier1] {
	if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue}
	if {[string index $Ligne 0] != ">"} {append Tab1($Access) "\n$Ligne";continue}
	if {[info exists Access]} {unset Access}
	regexp {>([^ ]*)} $Ligne tmp Access
	regsub -nocase {_from_[to0-9_]*$} $Access "" Access
	incr i
	set  Tab1($Access) $Ligne
	lappend LesAccessFichier1 $Access
    }
    Espionne $i
    set LesAccessFichier2 {}
    set i 0
    foreach Ligne [LesLignesDuFichier $Fichier2] {
	if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue}
	if {[string index $Ligne 0] != ">"} {append Tab2($Access) "\n$Ligne";continue}
	if {[info exists Access]} {unset Access}
	regexp {>([^ ]*)} $Ligne tmp Access
	incr i
	regsub -nocase {_from_[to0-9_]*$} $Access "" Access
	set  Tab2($Access) $Ligne
	lappend LesAccessFichier2 $Access
    }
    Espionne $i
    set LeTexte {}
    set i 0;set j 0
    foreach Access $LesAccessFichier1 {
	if {[info exists Tab2($Access)]} {
	    incr i
	    lappend LeTexte [set Tab2($Access)]
	} else {
	    incr j
	    lappend LeTexte [set Tab1($Access)]
	} 
	set Tab($Access) 1
    }
    Espionne "$i $j"

    Sauve [join $LeTexte "\n"] dans "ToutesLesSequences.tfa" 
    return

}

proc CompareLesFloats {TexteA TexteB} {


    if { [llength [split [string trim $TexteA] " "]] > 1 } {
	scan $TexteA "%s %f" A a
    } else {
	scan $TexteA "%f" a
    }  
    if { [llength [split [string trim $TexteB] " "]] > 1 } {
	scan $TexteB "%s %f" B b
    } else {
	scan $TexteB "%f" b
    }  

    if {[expr double($a) <  double($b)]} { return -1}
    if {[expr double($a) == double($b)]} { return  0}
    if {[expr double($a)  > double($b)]} { return  1}

}

proc CompareLesFloatsEnDebut {TexteA TexteB} {


    scan $TexteA "%f" a
    scan $TexteB "%f" b

    if {[expr double($a) <  double($b)]} { return -1}
    if {[expr double($a) == double($b)]} { return  0}
    if {[expr double($a)  > double($b)]} { return  1}

}

proc CompareLesIntegers {TexteA TexteB} {


    if { [llength [split [string trim $TexteA] " "]] > 1 } {
	scan $TexteA "%s %f" A a
    } else {
	scan $TexteA "%f" a
    }  
    if { [llength [split [string trim $TexteB] " "]] > 1 } {
	scan $TexteB "%s %f" B b
    } else {
	scan $TexteB "%f" b
    }  

    if {[expr $a <  $b]} { return -1}
    if {[expr $a == $b]} { return  0}
    if {[expr $a  > $b]} { return  1}

}

proc CompareLesIntegersEnDebut {TexteA TexteB} {

    scan $TexteA "%d" a
    scan $TexteB "%d" b

    if {[expr $a <  $b]} { return -1}
    if {[expr $a == $b]} { return  0}
    if {[expr $a  > $b]} { return  1}

}

proc CompareLesMilieux {LigneA LigneB} {


    scan $LigneA "%s %d %d" A DA FA
    scan $LigneB "%s %d %d" B DB FB

    set a [expr ($DA+$FA)/2]
    set b [expr ($DB+$FB)/2]

    if {[expr $a <  $b]} { return -1}
    if {[expr $a == $b]} { return  0}
    if {[expr $a  > $b]} { return  1}

}

proc CompareLesProcs {Selection {Meld ""}} {

    regsub -all {[ \t\n]+} $Selection " " Selection
    regsub -all gscope_contrib $Selection [GscopeContrib]
    regsub -all " gscope/" $Selection " [HomeRipp]/gscope" Selection
    lassign [split [string trim $Selection " \n"] " "] P F1 F2
Espionne $P
Espionne $F1
Espionne $F2
    scan $P "%s" P
    set B1 [ProcDuFichier $P $F1]
    set B2 [ProcDuFichier $P $F2]

    if {$Meld!=""} {
	regsub -all "/" $F1 "_" NF1
	regsub -all "/" $F2 "_" NF2
	Sauve $B1 dans [set TB1 [TmpFile $NF1]]
	Sauve $B2 dans [set TB2 [TmpFile $NF2]]
	exec meld $TB1 $TB2 &
    } else {
	set A1 [Affiche $B1 "" "${P}_de_$F1"]
	set A2 [Affiche $B2 "" "${P}_de_$F2"]
	return [list $A1 $A2]
    }
    return ""

}

proc CompareLesProfilsPourOverlapDDAffy {} {

    set F "/genomics/link/HeadNecknonrnr/OverlapEtProfils"
    set n 0
    set b 0
    foreach Ligne [LesLignesDuFichier $F] {
	if {$Ligne=={}} {continue}
	set ProfilDD [lindex $Ligne 3]
	set ProfilAffy [lindex $Ligne 4]
	if {$ProfilDD==$ProfilAffy} {incr n} else {incr b}
    }
    return "ok: $n diff:$b"

}

proc CompareLesSequencesDesAccess {A B} {


    Wup "Return 1 if the sequences of Access A and B are the same"

    set SeqA [LaSequenceDesLignesEMBL [LaSequenceDesBanques $A $A a "OnVeutEMBL"]]
    set SeqB [LaSequenceDesLignesEMBL [LaSequenceDesBanques $B $B b "OnVeutEMBL"]]
    return [string equal -nocase $SeqA $SeqB]

}

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 CompareLigneTabulee3 {A B} {

    set x [lindex [split $A "\t"] 3]
    set y [lindex [split $B "\t"] 3]
    if {$x==$y} { return 0}
    if {$x<$y} { return -1} else { return 1 }

}

proc CompareLigneTabulee5 {A B} {

    set x [lindex [split $A "\t"] 5]
    set y [lindex [split $B "\t"] 5]
    if {$x==$y} { return 0}
    if {$x<$y} { return -1} else { return 1 }

}

proc CompareListesPABS {Fichier1 Fichier2} {

    set L1 [CreeListePourFichierAUneColonne $Fichier1]
    foreach Nom $L1 {
	set Vu($Nom) 1
    }
    set L2 [CreeListePourFichierAUneColonne $Fichier2]
    foreach Nom $L2 {
	if {[info exists Vu($Nom)]} {lappend L3 $Nom}
    }
    return $L3

}

proc CompareLocalisations {FichierLesDDLocsSansFct FichierDesmiRNAs} {

    # FichierLesDDLocsSansFct "ANALYSE/miRNAs/LesDDLocSansFct" (248)
    # FichierDesmiRNAs "ANALYSE/miRNAs/LesM" (188)
    foreach Nom [CreeListePourFichierAUneColonne $FichierLesDDLocsSansFct] {
	if {$Nom==""} {continue}
	set Vu($Nom) 1
    }
    set FichierFinal "[RepertoireDuGenome]/ANALYSE/finaaal_6jul05_avecMAetSel_mitoch"
    foreach Ligne [LesLignesDuFichier $FichierFinal] {
	if {$Ligne==""} {continue}
	set LesInfos [split $Ligne "\t"]
	set JR [lindex $LesInfos 1]
	if {![info exists Vu($JR)]} {continue}
	set Chro [lindex $LesInfos 29]
	set Deb [lindex $LesInfos 30]
	set Fin [lindex $LesInfos 31]
	#set Sens [lindex $LesInfos 32]
	lappend LesLocsNom "$Chro $Deb $Fin $JR"
    }
    Espionne "lesDD: [llength $LesLocsNom]"
    set L [CreeListePourFichierAUneColonne $FichierDesmiRNAs]
    set FichierLoc "[RepertoireDuGenome]/Localisation/miRNAtfaLocalisation_Human"
    foreach M $L {
	set Locs [InterrogeLocalisation $FichierLoc Nom $M]
	if {$Locs==""} {continue}

	#if {[llength $Loc]>=2} {continue}
	foreach Loc $Locs {
	    #set L [join $L ""]    
	    #EspionneL $Loc
	    set Chro [lindex $Loc 9]
	    set DSurChro [lindex $Loc 10]
	    set FSurChro [lindex $Loc 11]
	    lappend LesLocsNom "$Chro $DSurChro $FSurChro $M"
	}
    }
    Espionne "lesDD et les M: [llength $LesLocsNom]"
    set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom]
    set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees]
    lappend LesLocsNomTriees "bidon bidon bidon bidon bidon"
    #########
    #set FichierBob "[RepertoireDuGenome]/bob"
    #SauveLesLignes $LesLocsNomTriees dans $FichierBob
    #exit
    #########
    set OldChromo "zzzz"
    set OldInf 1111111111111111
    set OldSup 0
    set LaSortie {}
    foreach Loc $LesLocsNomTriees {
	if {$Loc!="bidon bidon bidon bidon bidon"} {
	    scan $Loc "%s %d %d %s" chromo inf sup code
	    if {($chromo == $OldChromo) && ([expr $inf-$OldSup]<1000)} {
		if {![info exists LesMemes]} { set LesMemes $Oldcode }
		lappend LesMemes $code
	    } else {
		if {[info exists LesMemes]} {
		    lappend LaSortie [join $LesMemes " "]
		    unset LesMemes
		}
	    }
	    set OldChromo $chromo
	    set OldInf $inf
	    set OldSup $sup 
	    set Oldcode $code
	}
    }
    set FichierDesClonesEnOverlap "[RepertoireDuGenome]/ANALYSE/miRNAs/LocOverlapDDmiRNAs"
    if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace $FichierDesClonesEnOverlap"]} {
	if {$LaSortie=={}} {
	    Sauve "No overlaps were found" dans $FichierDesClonesEnOverlap
	} else {
	    #set Sortie [TrieLaSortie $LaSortie]
	    Espionne "fin"
	    SauveLesLignes $LaSortie dans $FichierDesClonesEnOverlap
	} 
    }
    return $FichierDesClonesEnOverlap

}

proc CompareLocalisations2 {FichierLesDDLocsSansFct} {

    # FichierLesDDLocsSansFct "ANALYSE/miRNAs/LesDDLocSansFct" (248)
    # FichierDesmiRNAs "ANALYSE/miRNAs/LesM" (188)
    foreach Nom [CreeListePourFichierAUneColonne $FichierLesDDLocsSansFct] {
	if {$Nom==""} {continue}
	set Vu($Nom) 1
    }
    set FichierFinal "[RepertoireDuGenome]/ANALYSE/finaaal_6jul05_avecMAetSel_mitoch"
    foreach Ligne [LesLignesDuFichier $FichierFinal] {
	if {$Ligne==""} {continue}
	set LesInfos [split $Ligne "\t"]
	set JR [lindex $LesInfos 1]
	if {![info exists Vu($JR)]} {continue}
	set Chro [lindex $LesInfos 29]
	set Deb [lindex $LesInfos 30]
	set Fin [lindex $LesInfos 31]
	#set Sens [lindex $LesInfos 32]
	lappend LesLocsNom "$Chro $Deb $Fin $JR"
    }
    Espionne "lesDD: [llength $LesLocsNom]"

    ##
    set FichierLocsNomMIR "[RepertoireDuGenome]/ANALYSE/miRNAs/ftp_sanger_genome_modifie2"
    set C [ContenuDuFichier $FichierLocsNomMIR]
    set LesLocsNommirna [split $C "\n"]
    set LesLocsNom [concat $LesLocsNom $LesLocsNommirna]
    ## 
    Espionne "lesDD et les M: [llength $LesLocsNom]"
    set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom]
    set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees]
    lappend LesLocsNomTriees "bidon bidon bidon bidon bidon"
    #########
    #set FichierBob "[RepertoireDuGenome]/bob"
    #SauveLesLignes $LesLocsNomTriees dans $FichierBob
    #exit
    #########
    set OldChromo "zzzz"
    set OldInf 1111111111111111
    set OldSup 0
    set LaSortie {}
    foreach Loc $LesLocsNomTriees {
	if {$Loc!="bidon bidon bidon bidon bidon"} {
	    scan $Loc "%s %d %d %s" chromo inf sup code
	    if {($chromo == $OldChromo) && ([expr $inf-$OldSup]<4000)} {
		if {![info exists LesMemes]} { set LesMemes $Oldcode }
		lappend LesMemes $code
	    } else {
		if {[info exists LesMemes]} {
		    lappend LaSortie [join $LesMemes " "]
		    unset LesMemes
		}
	    }
	    set OldChromo $chromo
	    set OldInf $inf
	    set OldSup $sup 
	    set Oldcode $code
	}
    }
    set FichierDesClonesEnOverlap "[RepertoireDuGenome]/ANALYSE/miRNAs/LocOverlapDDmiRNAs2"
    if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace $FichierDesClonesEnOverlap"]} {
	if {$LaSortie=={}} {
	    Sauve "No overlaps were found" dans $FichierDesClonesEnOverlap
	} else {
	    #set Sortie [TrieLaSortie $LaSortie]
	    Espionne "fin"
	    SauveLesLignes $LaSortie dans $FichierDesClonesEnOverlap
	} 
    }
    return $FichierDesClonesEnOverlap

}

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 CompareMachin {} {

    set Fichier "/genomics/link/UCSCGenomes/Mus_musculus/database/kgXref.txt"
    set LesLignes [LesLignesDuFichier $Fichier]
    foreach Ligne $LesLignes {
	set LesMots [split $Ligne "\t"]
	set KgId  [lindex $LesMots 0]
	set mRNA  [lindex $LesMots 1]
	set SwAcc [lindex $LesMots 2]
	set Gn    [lindex $LesMots 4]
	set GnMaj [string toupper $Gn]
	set GnMin [string tolower $Gn]
	set RsAcc [lindex $LesMots 5]
	set Des   [lindex $LesMots 7]
	Espionne "Gn $Gn"
	Espionne "GnMaj $GnMaj"
	Espionne "GnMin $GnMin"
    }

}

proc CompareMaskingEtReMasking {} {

    global RepertoireDuGenome
    
    set FichierNouveau "$RepertoireDuGenome/fiches/polylocalise.merge"
    set ChangementsNoLoc ""
    set ChangementsMonoLoc ""
    set ChangementsPolyLoc ""
    set ChangementsMayBePolyLoc ""
    set Finale ""
    append Finale [format "GscopeCode %-25s %-25s %-20s %-5s RepeatType\n" "LocBeforeRM" "LocAfterRM" "ReMask" "Percent"]
    #Espionne $Finale
    foreach Ligne [LesLignesDuFichier $FichierNouveau] {
	scan $Ligne "%s %s" Nom TypeLocApres
	#Espionne $Nom
	set Avant [PolyLocalise $Nom]
	#Espionne $Avant
	set Mask [QuelMask2 $Nom]
	set Repeat [QuelTypeRepeat2 $Nom]
	set Percent [QuelPourcent2 $Nom]
	if {$Avant!=$TypeLocApres && $Avant=="NoLocalization"} {
	    append ChangementsNoLoc [format "$Nom    %-25s %-25s %-20s %-5s $Repeat\n" $Avant $TypeLocApres $Mask $Percent]
	    continue
	} elseif {$Avant!=$TypeLocApres && $Avant=="MonoLocalization"} {
	    append ChangementsMonoLoc [format "$Nom    %-25s %-25s %-20s %-5s $Repeat\n" $Avant $TypeLocApres $Mask $Percent]
	    continue
	} elseif {$Avant!=$TypeLocApres && $Avant=="PolyLocalization"} {
	    append ChangementsPolyLoc [format "$Nom    %-25s %-25s %-20s %-5s $Repeat\n" $Avant $TypeLocApres $Mask $Percent]
	    continue
	} elseif {$Avant!=$TypeLocApres && $Avant=="MayBePolyLocalization"} {
	    append ChangementsMayBePolyLoc [format "$Nom    %-25s %-25s %-20s %-5s $Repeat\n" $Avant $TypeLocApres $Mask $Percent]
	    continue
	}
    }
    append Finale $ChangementsPolyLoc "\n"
    append Finale $ChangementsMonoLoc "\n"
    append Finale $ChangementsMayBePolyLoc "\n"
    append Finale $ChangementsNoLoc "\n"

    return $Finale

}

proc CompareNoms {TxtA TxtB} {


    set t1 [string range $TxtA [expr {[string first " " $TxtA]+1}] end]
    set t2 [string range $TxtB [expr {[string first " " $TxtB]+1}] end]

    if {$t1 >  $t2} {return  1}
    if {$t1 == $t2} {return  0}
    if {$t1 <  $t2} {return -1}

}

proc CompareOrganismFromOrthoInspectorAndYannis {} {

    foreach TYA [OrganismFromYannis ListOf TaxId] {
	set OSYA [OrganismFromYannis $TYA OS]
	set FullOsYA [OrganismFromYannis $TYA FullOs]
	set TOI [OrganismFromOrthoInspector $TYA TaxId]
	if {$TOI==""} {
	    set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
	    if {$TOI==""} {
		set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
		if {$TOI==""} { FaireLire "Je ne trouve pas\n$TYA $FullOsYA\ndans OrthoInspector" ; continue }
	    }
	}
 	set FullOsOI [OrganismFromOrthoInspector $TYA FullOs]
	if {$FullOsYA==$FullOsOI} { continue }
	Espionne "$FullOsYA\n$FullOsOI"
	Espionne
    }
	    

}

proc CompareOrganismsOiYannis {} {

    foreach TOI [OiOrganism ListOf TaxId] {
	set TYA [YannisOrganism $TOI TaxId]
#	Espionne "$TOI $TYA"
    }
    Espionne ""
    foreach TYA [YannisOrganism ListOf TaxId] {
	set TOI [OrganismFromOrthoInspector $TYA TaxId]
	set FOS [YannisOrganism $TYA FullOs]
	set OS  [YannisOrganism $TYA OS]
	if {$TOI==""} {
	    set TOI [OrganismFromOrthoInspector $OS TaxId]
	    set FOSoi [OrganismFromOrthoInspector $TOI FullOs]
	    Espionne "$TYA $TOI $FOS $FOSoi"
	}
    }

}

proc ComparePfamDesEtPfamGo {} {

    #Est ce que les x Pfam (avec binding dans la des) sont present dans les BindingPfam provenant de GO -> NON (y Pfam n'ont pas de GO Binding correspondant)
    #x=71 (g17/SpliRetMouse2008 + g17/SpliRetRat2008) y=31
    #x=88 (g20/SpliRetMouse2009 + g20/SpliRetRat2009) y=43
    set i 0
    set LesBindingPfamFromGo [GoGetFromGo GO:0005488 PFAM "" "" "Down"]
    #set File "/genomics/link/SpliRetMouse2008/BindingPfam/BindingPfamFromDes/PfamDesFrom1500.txt"
    set File "/genomics/link/SpliRetMouse2009/BindingPfam/BindingPfamFromDes/PfamDesFrom1500.txt"
    foreach Ligne [LesLignesDuFichier $File] {
	set trouve 0
	set BindingPfamFromDes [lindex [split $Ligne "\t"] 0]
	set Des         [lindex [split $Ligne "\t"] 2]
	if {[regexp "binding" $Des]} {
	    foreach BindingPfamFromGo $LesBindingPfamFromGo {
		if {$BindingPfamFromDes == $BindingPfamFromGo} {
		    set trouve 1
		    break
		}
	    }
	    if {!$trouve} {
		incr i 
		Espionne "$BindingPfamFromDes pas trouve dans go ($Des)"
	    }
	}
    }
    Espionne "$i n'ont pas de GO binding correspondant"

}

proc CompareProbesetFromAffyetBioC {} {

    #nous avons, pour la puce HuGene-1_0-st-v1, 33 297 transcrit_id (probeset_id par abus de langage) dans le fichier affy et que 33321 dans BioConducteur.
    #nous essayons avec cette proc de comprendre pourquoi BioC en perd 976
    #trouve pas de reponse ici, suppose que ensembl (ce que prend Bioc) a fait son propre mapping et elimine celles qui ne passaient ses criteres de selection
    set FileBioC "/genomics/link/g20/R_GxDB/liverGIST/HuGene1.0_allPS"
    set LesLignesBioC [LesLignesDuFichier $FileBioC]
    foreach IdBioC $LesLignesBioC {
	if {$IdBioC=="x"} {continue}
	set IdBioC [string trim $IdBioC]
	lappend LesIdBioC $IdBioC
	set VuDansBioC($IdBioC) 1
    }
    set FileTr "/genomics/link/affyArrayAnnot/HuGene-1_0/AffyAnno20130326/HuGene-1_0-st-v1.na33.2.hg19.transcript.csv"
    set LesLignesTr  [TabulonsSansQuote $FileTr "," ";" " " "GetListOfValues"]
    set DansBioC 0; set PasBioC 0
    set nbmRNA 0; set nbmRNABioC 0; set nbmRNANotBioC 0
    foreach LigneTr $LesLignesTr {
	set LesxhybmRNA {}
	set LesElmtsTr [split $LigneTr ";"]
	set IdTr [lindex $LesElmtsTr 0]
	set IdTr [string trim $IdTr]
	lappend LesIdTr $IdTr
	set mrnaassign [lindex $LesElmtsTr 8]
	regsub -all "///" $mrnaassign  "^" mrnaassign
	regsub -all "//" $mrnaassign "°" mrnaassign
	foreach item [split $mrnaassign "^"] {
	    incr nbmRNA
	    #peut changer l index "8" ici pour voir une diff avec autre chose. par ex par l index "4" pour voir ac assignment score
	    set xhybmRNA [string trim [lindex [split $item "°"] 8]]
	    if {[info exists VuDansBioC($IdTr)]} {
		incr nbmRNABioC
		if {![info exists AlreadySeenBioC($xhybmRNA)]} {set AlreadySeenBioC($xhybmRNA) 0}
		incr AlreadySeenBioC($xhybmRNA)	
		lappend LesxhybmRNABioC $xhybmRNA
		
		
	    } else {
		incr nbmRNANotBioC
		if {![info exists AlreadySeenNotBioC($xhybmRNA)]} {set AlreadySeenNotBioC($xhybmRNA) 0}
		incr AlreadySeenNotBioC($xhybmRNA)
		lappend LesxhybmRNANotBioC $xhybmRNA
		
	    }
	}

	set Sw [lindex $LesElmtsTr 9]
	set Crosshyb [lindex $LesElmtsTr 16]
	set Category [lindex $LesElmtsTr 17]
	if {[info exists VuDansBioC($IdTr)]} {
	    incr DansBioC
	    if {![info exists DejaVuBioC($Crosshyb)]} {set DejaVuBioC($Crosshyb) 0}
	    incr DejaVuBioC($Crosshyb)
	    if {![info exists DejaVuBioC($Category)]} {set DejaVuBioC($Category) 0}
	    incr DejaVuBioC($Category)
	    lappend LesCrosshybBioC $Crosshyb
	    lappend LesCategoryBioC $Category
	} else {
	    incr PasBioC 
	    if {![info exists DejaVuNotBioC($Crosshyb)]} {set DejaVuNotBioC($Crosshyb) 0}
	    incr DejaVuNotBioC($Crosshyb)
	    if {![info exists DejaVuNotBioC($Category)]} {set DejaVuNotBioC($Category) 0}
	    incr DejaVuNotBioC($Category)
	    lappend LesCrosshybNotBioC $Crosshyb
	    lappend LesCategoryNotBioC $Category
	}
    }
    set LesxhybmRNABioC    [lsort -unique $LesxhybmRNABioC]
    set LesxhybmRNANotBioC [lsort -unique $LesxhybmRNANotBioC]

    Espionne "nbmRNA $nbmRNA"
    Espionne "nbmRNABioC $nbmRNABioC"
    Espionne "nbmRNANotBioC $nbmRNANotBioC"

    Espionne "LesxhybmRNABioC $LesxhybmRNABioC"
    foreach xhybmRNABioC $LesxhybmRNABioC {
	Espionne "$xhybmRNABioC $AlreadySeenBioC($xhybmRNABioC)"
    }

    Espionne "LesxhybmRNANotBioC $LesxhybmRNANotBioC"
    foreach xhybmRNANotBioC $LesxhybmRNANotBioC {
	Espionne "$xhybmRNANotBioC $AlreadySeenNotBioC($xhybmRNANotBioC)"
    }

    set LesCrosshybBioC [ListeSansDoublon $LesCrosshybBioC]
    set LesCategoryBioC [ListeSansDoublon $LesCategoryBioC]
    set LesCrosshybNotBioC [ListeSansDoublon $LesCrosshybNotBioC]
    set LesCategoryNotBioC [ListeSansDoublon $LesCategoryNotBioC]
    Espionne ""
    Espionne "DansBioC $DansBioC"
    Espionne "PasBioC $PasBioC"
    Espionne "CrosshybBioC $LesCrosshybBioC"
    foreach CrosshybBioC $LesCrosshybBioC {
	Espionne "$CrosshybBioC => $DejaVuBioC($CrosshybBioC)"
    }
    Espionne "CrosshybNotBioC $LesCrosshybNotBioC"
    foreach CrosshybNotBioC $LesCrosshybNotBioC {
	Espionne "$CrosshybNotBioC => $DejaVuNotBioC($CrosshybNotBioC)"
    }
    Espionne "CategoryBioC $LesCategoryBioC"
    foreach CategoryBioC $LesCategoryBioC {
	Espionne "$CategoryBioC => $DejaVuBioC($CategoryBioC)"
    }
    Espionne "CategoryNotBioC $LesCategoryNotBioC"
    foreach CategoryNotBioC $LesCategoryNotBioC {
	Espionne "$CategoryNotBioC => $DejaVuNotBioC($CategoryNotBioC)"
    }

    Espionne ""
    Espionne "LesIdBioC [llength $LesIdBioC]"
    Espionne "LesIdTr   [llength $LesIdTr]"
    Espionne "LesIdBioCUnique [llength [ListeSansDoublon $LesIdBioC]]"
    Espionne "LesIdTrUnique   [llength [ListeSansDoublon $LesIdTr]]"

    Espionne ""
    Espionne "DsBioCPasTrIdTr [ListsComplement $LesIdBioC $LesIdTr]"
    Espionne "DsBioCPasTrIdTr Nb [llength [ListsComplement $LesIdBioC $LesIdTr]]"
    Espionne "DsTrIdTrPasBioC [ListsComplement $LesIdTr $LesIdBioC]"
    Espionne "DsTrIdTrPasBioC Nb [llength [ListsComplement $LesIdTr $LesIdBioC]]"

}

proc CompareProfilsDDProfilsMb {} {

    set FichierG "[RepertoireDuGenome]/pourgscope_FromRegine_mbs_gscopecode"
    foreach Ligne [LesLignesDuFichier $FichierG] {
	set Ligne [string trim $Ligne]
	if {$Ligne=={}} {continue}
	set CC [lindex $Ligne 0]
	set DD [lindex $Ligne 1]
	set G($CC) $DD
    }
    #profil gscope
    set FichierHNK "/genomics/link/HeadNeckDD/fiches/FoldExpression"
    foreach Ligne [LesLignesDuFichier $FichierHNK] {
	set Ligne [string trim $Ligne]
	if {$Ligne=={}} {continue}
	set HNK [lindex $Ligne 0]
	set ProfilHNK [lindex $Ligne 1]
	set P($HNK) $ProfilHNK
    }
    #comparaison des deux profils
    set FichierNouveau "[RepertoireDuGenome]/compar_profils_mb_gscope"
    set n 0
    set b 0
    set Fichier "[RepertoireDuGenome]/pourgscope_FromRegine_mbs"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	#set Ligne [string trim $Ligne]
	#if {$Ligne=={}} {continue}
	set Code [lindex $Ligne 0]
	set ProfilMb [lindex $Ligne 1]
	if {[info exists G($Code)]} {
	    if {$G($Code)==""} {
		continue
	    } else {
		set DD $G($Code)
		set HNK [AncienNom $DD]
		if {[info exists P($HNK)]} {set ProfilGscope $P($HNK)}
		if {($ProfilMb=="N" && $ProfilGscope=="-")  || ($ProfilMb=="T" && $ProfilGscope=="+")} {
		    incr b 
		    set Compar 1
		} else {
		    incr n 
		    set Compar 0
		}
		AppendAuFichier $FichierNouveau "$Code\t$DD\t$ProfilMb\t$ProfilGscope\t$Compar"
	    }
	}
    }
    return "meme prof: $b -- prof dif: $n"

}

proc ComparePv1 {LA LB} {

    if {[regexp {^GscopeId} $LA]} {return -1}
    if {[regexp {^GscopeId} $LB]} {return 1}
    return [CompareIeme $LA $LB 1 ";"]

}

proc CompareReduction {A B} {

    set LesMots [split $A ";"]
    set NomA [lindex $LesMots 0]
    set GenA [lindex $LesMots 2]
    set CopA [lindex $LesMots 4]
    set LesMots [split $B ";"]
    set NomB [lindex $LesMots 0]
    set GenB [lindex $LesMots 2]
    set CopB [lindex $LesMots 4]
    
    regsub {\+7 et \+8} $CopA "100" CopA
    regsub {\+7 et \+8} $CopB "100" CopB
    regsub {\+7 et \-8} $CopA "200" CopA
    regsub {\+7 et \-8} $CopB "200" CopB
    regsub {\-}         $CopA "300" CopA
    regsub {\-}         $CopB "300" CopB

    if {[set Cop [string compare $CopA $CopB]]!=0} { return $Cop }
    if {[set Gen [string compare $GenA $GenB]]!=0} { return $Gen }
    return [string compare $NomA $NomB]

}

proc CompareSansPremierChamp {TexteA TexteB} {


    set iB [string first " " $TexteA]
    if {$iB < 0} {
	set a ""
    } else {
	set a [string trimleft [string range $TexteA $iB end]]
    }

    set iB [string first " " $TexteB]
    if {$iB < 0} {
	set b ""
    } else {
	set b [string trimleft [string range $TexteB $iB end]]
    }

    return [string compare $a $b]

}

proc CompareSeulementLesNombres {TexteA TexteB} {

    scan $TexteA "%s" a
    scan $TexteB "%s" b
    if {[regexp -nocase {[a-z]} $a] && [regexp -nocase {[a-z]} $b]} {return 0}
    if {[regexp -nocase {[a-z]} $a] && [regexp -nocase {^[0-9]+$} $b]} {return 1}
    if {[regexp -nocase {^[0-9]+$} $a] && [regexp -nocase {[a-z]} $b]} {return -1}
    if {[regexp -nocase {^[0-9]+$} $a] && [regexp -nocase {^[0-9]+$} $b]} {
	if {[expr double($a) <  double($b)]} { return -1}
	if {[expr double($a) == double($b)]} { return  0}
	if {[expr double($a)  > double($b)]} { return  1}
    }

}

proc CompareSources {DirA DirB {Action ""}} {

    set LesMissingA {}
    set LesMissingB {}
    set LesCommuns {}
    set LesDiff {}
    set LesMemes {}
    set LesA {}
    set LesB {}
    foreach A [lsort [glob -nocomplain "$DirA/*.tcl"]] {
	set QA [file tail $A]
	set ContenuA($QA) [ContenuDuFichier $A]
	lappend LesQA $QA
	lappend LesA  $A
	set FileA($QA) $A
    }
    foreach B [lsort [glob -nocomplain "$DirB/*.tcl"]] {
	set QB [file tail $B]
	set ContenuB($QB) [ContenuDuFichier $B]
	lappend LesQB $QB
	lappend LesB  $B
	set FileB($QB) $B
    }
    foreach QA $LesQA {
	if { ! [info exists ContenuB($QA)]} { lappend LesMissingB $FileA($QA) ; continue}
	lappend LesCommuns $QA
    }
    foreach QB $LesQB {
	if { ! [info exists ContenuA($QB)]} { lappend LesMissingA $FileB($QB) ; continue}
    }
    foreach Q $LesCommuns {
	if {$ContenuA($Q)==$ContenuB($Q)} { lappend LesMemes $Q ; continue }
	lappend LesDiff $Q
    }
    AfficheListe $LesA "" "LesA" 
    AfficheListe $LesB "" "LesB" 
    AfficheListe $LesMissingA "" "LesMissingA" 
    AfficheListe $LesMissingB "" "LesMissingB" 
    AfficheListe $LesCommuns "" "LesCommuns" 
    AfficheListe $LesMemes   "" "LesMemes" 
    while {1} {
	set Zoom [AfficheListe $LesDiff "AvecRetour" "LesDiff"]
	if {$Zoom==""} { break "" }
	set A $FileA($Zoom)
	set B $FileB($Zoom)
	exec meld $A $B &
    }
    return ""

}

proc ComparemRNADeRet1324 {} {

    set A 0; set B 0; set C 0; set D 0; set E 0; set F 0; set G 0; set Z 0; set Y 0; set Ybis 0; set X 0; set Xbis 0; set W 0
    set Les1373RA {}
    set LesRAdoubles {}
    set LesRAAVerif {} 
    set LesRASsFiches {}
    foreach I [RetChip2 ListOf Index] {
	set AccmRNA1 ""; set Genre1 ""; set AccmRNA2 ""; set Genre2 ""
	set JaiTrouveCorresEntre1324Et2717 0
	set jaitrouvecorres 0
	set toutestvide 0
	set Des1 [RetChip2 $I "description_customer"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } {
	    puts "ligne $I Des1=$Des1 Ac1=$Ac1"
	    incr A

	    set Fichier "/genomics/link/Ret1324/fiches/Orf2Cluster2Access2Def2Expression"
	    set LesLignes [LesLignesDuFichier $Fichier]

	    foreach Ligne $LesLignes {
		scan $Ligne "%s %s %s %s" RA1324 x y RA2717
		if {$Des1==$RA2717} {
		    set JaiTrouveorresEntre1324Et2717 1
		    incr B
		    puts "**$RA1324"
		    foreach LeRa $Les1373RA {
			set LaLigneLeRa [split $LeRa " "] 
			if { $RA1324==[lindex $LeRa 0]} {
			    lappend LesRAdoubles "$LeRa"
			    lappend LesRAdoubles "$RA1324 $I $Des1"
			}
		    }
		    lappend Les1373RA "$RA1324 $I $Des1"
		    if {[file exists "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]} {
			incr C
			set LAcRa1 [ContenuDuFichier "/genomics/link/Ret1324/mrnatfa_Mus_musculus/$RA1324"]
			scan $LAcRa1 "%s %s %s %s %s" x y AccmRNA1 z Genre1
			#puts "++$AccmRNA1++"
			#puts "++$Genre1++"
		    } else {
			incr D
			puts "PAS DE FICHIER"
			#lappend LesSsFiches "ligne $I Des1=$Des1 Ret1324=$RA1324"
		    }

		    set Fichier2 "/genomics/link/Ret1324/fiches/AccessDesProteinesEtDesmRNAsChoisis"
		    set LesLignes2 [LesLignesDuFichier $Fichier2]

		    foreach Ligne2 $LesLignes2 {
			scan $Ligne2 "%s %s %s %s" NumRA AccProt AccmRNA Genre
			if {$RA1324==$NumRA} {
			    incr E
			    set jaitrouvecorres 1
			    set AccmRNA2 $AccmRNA
			    set Genre2 $Genre
			    if {[string equal $AccmRNA2 "NomRNA"]} {
				set AccmRNA2 "" 
				incr F
			    }
			    if {[string equal $Genre2 "NoOrganism"]} {
				set Genre2 "" 
			    }
			    if {$Genre2!="" && ![string equal $Genre2 "Mus"]} { puts "attention pas souris 2" }
			    #puts "--$AccmRNA2--"
			    #puts "--$Genre2--"
			}
		    }
		    #puts "$Genre2"
		    Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"

		    if {$AccmRNA1!="" && $AccmRNA2!="" && $AccmRNA1==$AccmRNA2} {
			incr Z
			#puts "Z= $Z"
		    } 
		    if {$AccmRNA1!="" && $AccmRNA2!="" && $AccmRNA1!=$AccmRNA2} {
			incr Y
			#puts "Y= $Y"
			if {[string equal $Genre2 "Mus"]} {
			    incr Ybis
			    lappend LesRAAVerif "RA1324=$RA1324 ligne=$I Des1=$Des1"
			 #   puts "Ybis= $Ybis"
			}
		    }
		    if {$AccmRNA1=="" && $AccmRNA2==""} {			
			set toutestvide 1
			incr W
			lappend LesRASsFiches "RA1324=$RA1324 ligne=$I Des1=$Des1"
			#puts "W= $W"
		    }
		   
		    if {!$toutestvide && ($AccmRNA1=="" || $AccmRNA2=="")} {
			incr X
			#puts "X= $X"
			if {$AccmRNA2!="" && ![string equal $Genre2 "Mus"]} {
			    incr Xbis
			    lappend LesRASsFiches "RA1324=$RA1324 ligne=$I Des1=$Des1"
			 #   puts "Xbis= $Xbis"
			}
		    }
		}
	    }
	    
	    if {!$JaiTrouveCorresEntre1324Et2717} { 
		incr G
		#puts "G= $G"
		puts "pas de corresp"
		Espionne "AccmRNA1=$AccmRNA1 Genre1=$Genre1 AccmRNA2=$AccmRNA2 Genre2=$Genre2\n"
	    }
	}
    }
    
    Espionne "A= $A =nb de RA"
    Espionne "B= $B =nb ac une corres ds Ret1324"
    Espionne "G= $G =nb ss une corres ds Ret1324"
    Espionne "C= $C =nb ac un access mRNA 1"
    Espionne "D= $D =nb ss access mRNA1"
    Espionne "E-F= [expr $E-$F] =nb ac un access mRNA 2"
    Espionne "F= $F =nb ss access mRNA 2"
    Espionne "Z= $Z =nb ou les 2 mRNA st ="
    Espionne "Y= $Y =nb ou les 2 mRNA st diff"
    Espionne "Ybis $Ybis =nb ou les 2 mRNA souris st diff"
    Espionne "X= $X =nb ou l un des 2 mRNA est vide"
    Espionne "Xbis= $Xbis =nb (mRNA1 vide) de mRNA2 non vide et non souris"
    Espionne "W= $W =nb ou les 2mRNA st vides"
    set LesRAdoubles [lsort $LesRAdoubles]  
    EspionneL $LesRAdoubles 
    set NbDouble [llength $LesRAdoubles]
    set NbDouble [expr $NbDouble/2]
    Espionne "NbDouble= $NbDouble"
    EspionneL $LesRAAVerif
    set NbRAAVerif [llength $LesRAAVerif]
    Espionne "NbRAAVerif= $NbRAAVerif"
    EspionneL $LesRASsFiches
    set NbRASsFiches [llength $LesRASsFiches]
    Espionne "NbRASsFiches= $NbRASsFiches"

}

proc CompileBACCGH {Cas SeuilPlus SeuilMoins {LesPos ""} {LesNoms ""}} {

    # liste des cas
    if {$Cas!="meta" && $Cas!="nometa"} {return}
    if {$Cas=="meta"} {
	set LesCas {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827}
    } else {set LesCas {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}}
    Espionne $LesCas
    Espionne [llength $LesCas]
    
    set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY}

    # position des cytobandes 
    set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap"
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos
    foreach Chromosome $ListeChro {
	if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""}
	set LesBandesP   [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ   [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}
	set PosIni 0
	foreach Bande $LesBandesCytologiques {
	    set LesInfos  [set LesBandesCytos($Chromosome,$Bande)]
	    set PosFin [expr [lindex $LesInfos 0] * 1.e6]
	    set TailleBande [expr round(($PosFin-$PosIni)/1.e6)]
	    set Deb($Chromosome,$Bande) $PosIni
	    set Fin($Chromosome,$Bande) $PosFin
	    set PosIni $PosFin
	}
    }

    # pour chaque fichier BAC
    foreach BAC $LesCas {
	set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC"
	set NomFichierBAC [file tail $FichierCourbeBAC]

	set x [InterrogeFichierCourbeCGH $FichierCourbeBAC "unset"]
	set VMin [InterrogeFichierCourbeCGH $FichierCourbeBAC VMin]
	set VMax [InterrogeFichierCourbeCGH $FichierCourbeBAC VMax]
	set VMaxf [format "%.2f" [expr $VMax*1.0]]
	set VMinf [format "%.2f" [expr $VMin*1.0]]
	lappend LesBornes "$BAC\t$VMinf\t$VMaxf"

	foreach Chromosome $ListeChro {
	    set CytoBand ""
	    if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""}
	    set LesBandesP   [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	    set LesBandesQ   [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	    set LesBandesCytologiques $LesBandesP
	    foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	    if {[info exists TabC]} {unset TabC}
	    ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] {
		    foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] {
			set PosMid [lindex $LInfo 1]
			#cytobande
			#if {[info exists B($Chromosome,$PosMid)]} {set CytoBand $B($Chromosome,$PosMid)}
			foreach Bande $LesBandesCytologiques {
			    if {$PosMid>=$Deb($Chromosome,$Bande) && $PosMid<=$Fin($Chromosome,$Bande)} {
				set CytoBand $Bande
			    }
			}
			if {$CytoBand==""} {Espionne "coucou $Chromosome $PosMid"}
			set Val [lindex $LInfo 2]
			set Value [format "%.2f" [expr $Val*1.0]]
			if {$Value>0 && $Value>$SeuilPlus} {
			    lappend LesPlus "$Cas\t$BAC\t$Chromosome\t$CytoBand\t$PosMid\t$Val"
			}
			if {$Value<0 && $Value<$SeuilMoins} {
			    lappend LesMoins "$Cas\t$BAC\t$Chromosome\t$CytoBand\t$PosMid\t$Val"
			}
		    }
		}
	    }
	}
    }
    #### fin boucle ###
    #Espionne "min et max:"
    EspionneL "$LesBornes"
    Espionne "---- liste des + ----"
    EspionneL $LesPlus
    Espionne "---- FIN liste des + ----"
    #EspionneL $LesMoins
    foreach Elt $LesPlus {
	set LesInfos [split $Elt "\t"]
	set Band [lindex $LesInfos 3]
	set Sample [lindex $LesInfos 1]
	if {![info exists Vus($Band,$Sample)]} {
	    set Vus($Band,$Sample) 1
	    if {![info exists N($Band)]} {set N($Band) 1} else {set N($Band) [expr $N($Band)+1]}
	}
    }
    
    foreach {B C} [array get N] {
	lappend L "$B\t$C"
    }
    foreach Elt $LesMoins {
	set LesInfos [split $Elt "\t"]
	set Band [lindex $LesInfos 3]
	set Sample [lindex $LesInfos 1]
	if {![info exists Vues($Band,$Sample)]} {
	    set Vues($Band,$Sample) 1
	    if {![info exists Nb($Band)]} {set Nb($Band) 1} else {set Nb($Band) [expr $Nb($Band)+1]}
	}
    }
    foreach {B C} [array get Nb] {
	lappend Lmoins "$B\t$C"
    }
    EspionneL "plus: $L"
    EspionneL "moins: $Lmoins"
    return

}

proc CompilePourGeneDonne {{Cas ""} {Chromosome ""} {Debut ""} {Fin ""} {LesPos ""} {LesNoms ""}} {

    #!! renvoyer le resultat dans un fichier

    # Cas: voir ci-dessous
    # Chromosome: HS01 par ex

    if {$Debut=="" || $Fin==""} {return}
    # Les cas
    if {$Cas=="meta"} {
	set LesBAC {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827}
	set LesOligo {Oligo806 Oligo807 Oligo810 Oligo817 Oligo818 Oligo819 Oligo826 Oligo827}
	set LesAffy {RMA7 RMA711 RMA821 RMA855 RMA818 RMA918 RMA921}
    }
    if {$Cas=="nometa"} {
	set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {Oligo809 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825}
	set LesAffy {RMA845 RMA886 RMA819 RMA926 RMA923 RMA924 RMA925}
    }
    if {$Cas=="cl"} {
	#set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {CL_22rv1 CL_DU145 CL_LNCaP CL_PC3}
	set LesAffy {RMA22Rv1 RMADU145 RMALNCaP RMAPC3}
    }

    if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]}

    set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    if {![file exists $FichierLocCGHBAC] || $FichierLocCGHBAC == ""} {return ""}

    set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation"
    if {![file exists $FichierLocCGHOligo] || $FichierLocCGHOligo == ""} {return ""}

    ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms
    ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms

    set nChromosome [NumeroDuChromosome $Chromosome]
    
    set PosInfInteret $Debut
    set PosSupInteret $Fin

    ################## Les donnees BAC ################
    # pour chaque echantillon
    if {[info exists LesBAC]} {
	foreach BAC $LesBAC {
	    set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC"
	    ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] {
		    if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
			foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] {
			    set PosMid [lindex $LInfo 1]
			    set Val [lindex $LInfo 2]
			    if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} {
				foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] {
				    foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] {
					set DebutBAC [expr [lindex $LInfo 1]*1.0]
					set FinBAC [expr [lindex $LInfo 2]*1.0]
					set PosMilieu [expr ($FinBAC-$DebutBAC)/2 +$DebutBAC]
					if {$PosMilieu==$PosMid} {
					    set NomBAC [lindex $LInfo 3]
					    set IDBAC [lindex $LInfo 4]
					    set InterIDBAC [lindex $LInfo 5]
					    lappend LesDonneesBAC "$BAC\t$NomBAC\t$IDBAC\t$InterIDBAC\t$PosMid\t$Val"
					}
				    }
				}
			    } 
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Oligo ################

    foreach Oligo $LesOligo {
	set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$Oligo"
	ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chromosome $LesPos
	if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} {
	    foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] {
		if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
		    set PosMid $Pos
		    foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] {
			set Val [lindex $LInfo 3]
			### tranfo log base 10 -> log base 2
			set Val [expr $Val*log(10)/log(2)]
			if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} {
			    foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] {
				set NomProbeIni toto
				foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] {
				    set DebutOli [expr [lindex $LInfo 1]*1.0]
				    set FinOli [expr [lindex $LInfo 2] *1.0]
				    set PosMilieu [expr ($FinOli-$DebutOli)/2 +$DebutOli]
				    if {$PosMilieu==$PosMid} {
					set NomProbe [lindex $LInfo 3]
					set Access [lindex $LInfo 4]
					if {$NomProbe!=$NomProbeIni} {
					    lappend LesDonneesOligo "$Oligo\t$NomProbe\t$Access\t$PosMid\t$Val"
					    set NomProbeIni $NomProbe
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Affy ################

    regsub "HS" $Chromosome "" num
    if {[regexp "^0" $num]} {regsub "0" $num "" num}
    set Chrom "chr$num"
    set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets]
    foreach ProbeSet $LesProbeSets {
	set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome] 
	if {[llength $LesChros]>1} {continue}
	set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] 
	set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin]
	foreach Debut $LesDebuts Fin $LesFins {
	    set PosMid [expr ($Fin-$Debut)/2 + $Debut]
	    if {$PosMid>=$PosInfInteret && $PosMid<=$PosSupInteret} {
		lappend L "$ProbeSet\t$PosMid"
	    }
	}
	#set Deb [expr [lrange $LesDebuts 0 0] *1.0]
	#set Fin [expr [lrange $LesFins 0 0] *1.0]
	#set PosMid [expr ($Fin-$Deb)/2 + $Deb]
	
    }
    set Ltriee [lsort -real -increasing -index 1 $L]
    if {$Ltriee!=""} {
	foreach Elt $Ltriee {
	    set LesInfos [split $Elt "\t"]
	    set PosMid [lindex $LesInfos 1]
	    set ProbeSet [lindex $LesInfos 0]
	    foreach Affy $LesAffy {
		set FichierAffy "[RepertoireDuGenome]/PRIMA_Affy/$Affy"
		if {![file exists $FichierAffy]} {return "$FichierAffy does not exist"}
		set Val [InterrogeFichierAffyRMA $FichierAffy $ProbeSet Val]
		lappend LesDonneesAffy "$Affy\t$ProbeSet\t$PosMid\t$Val"
		set x [InterrogeFichierAffyRMA $FichierAffy "unset"]
	    }
	}
    }
    	
    ####################### fin ###############################
    if {[info exists LesBAC] && [info exists LesDonneesBAC]} {EspionneL $LesDonneesBAC}
    EspionneL $LesDonneesOligo
    EspionneL $LesDonneesAffy
    return ""

}

proc CompilePourGraphDunGeneDonne {{Cas ""} {Chromosome ""} {Debut ""} {Fin ""} {LesPos ""} {LesNoms ""}} {

    #!! renvoyer le resultat dans un fichier

    # Cas: voir ci-dessous
    # Chromosome: HS01 par ex

    if {$Debut=="" || $Fin==""} {return}
    # Les cas
    if {$Cas=="meta"} {
	set LesBAC {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827}
	set LesOligo {Oligo806 Oligo807 Oligo810 Oligo817 Oligo818 Oligo819 Oligo826 Oligo827}
	set LesAffy {RMA7 RMA711 RMA821 RMA855 RMA818 RMA918 RMA921}
    }
    if {$Cas=="nometa"} {
	set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {Oligo809 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825}
	set LesAffy {RMA845 RMA886 RMA819 RMA926 RMA923 RMA924 RMA925}
    }
    if {$Cas=="cl"} {
	#set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {CL_22rv1 CL_DU145 CL_LNCaP CL_PC3}
	set LesAffy {RMA22Rv1 RMADU145 RMALNCaP RMAPC3}
    }

    if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]}

    set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    if {![file exists $FichierLocCGHBAC] || $FichierLocCGHBAC == ""} {return ""}

    set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation"
    if {![file exists $FichierLocCGHOligo] || $FichierLocCGHOligo == ""} {return ""}

    ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms
    ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms

    set nChromosome [NumeroDuChromosome $Chromosome]
    
    set PosInfInteret $Debut
    set PosSupInteret $Fin

    ################## Les donnees BAC ################
    # pour chaque echantillon
    if {[info exists LesBAC]} {
	foreach BAC $LesBAC {
	    set i 0
	    set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC"
	    ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] {
		    if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
			foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] {
			    set PosMid [lindex $LInfo 1]
			    set Val [lindex $LInfo 2]
			    if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} {
				foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] {
				    foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] {
					set DebutBAC [expr [lindex $LInfo 1]*1.0]
					set FinBAC [expr [lindex $LInfo 2]*1.0]
					set PosMilieu [expr ($FinBAC-$DebutBAC)/2 +$DebutBAC]
					if {$PosMilieu==$PosMid} {
					    incr i
					    set NomBAC [lindex $LInfo 3]
					    set IDBAC [lindex $LInfo 4]
					    set InterIDBAC [lindex $LInfo 5]
					    lappend LesDonneesBAC "$BAC\t$NomBAC\t$IDBAC\t$InterIDBAC\t$PosMid\t$Val"
					    #set TabVal($i, $BAC, $NomBAC, $PosMid) $Val
					}
				    }
				}
			    } 
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Oligo ################

    foreach Oligo $LesOligo {
	set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$Oligo"
	ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chromosome $LesPos
	if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} {
	    foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] {
		if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
		    set PosMid $Pos
		    foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] {
			set Val [lindex $LInfo 3]
			### tranfo log base 10 -> log base 2
			set Val [expr $Val*log(10)/log(2)]
			if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} {
			    foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] {
				set NomProbeIni toto
				foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] {
				    set DebutOli [expr [lindex $LInfo 1]*1.0]
				    set FinOli [expr [lindex $LInfo 2] *1.0]
				    set PosMilieu [expr ($FinOli-$DebutOli)/2 +$DebutOli]
				    if {$PosMilieu==$PosMid} {
					set NomProbe [lindex $LInfo 3]
					set Access [lindex $LInfo 4]
					if {$NomProbe!=$NomProbeIni} {
					    lappend LesDonneesOligo "$Oligo\t$NomProbe\t$Access\t$PosMid\t$Val"
					    set NomProbeIni $NomProbe
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Affy ################

    regsub "HS" $Chromosome "" num
    if {[regexp "^0" $num]} {regsub "0" $num "" num}
    set Chrom "chr$num"
    set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets]
    foreach ProbeSet $LesProbeSets {
	set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome] 
	if {[llength $LesChros]>1} {continue}
	set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] 
	set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin]
	foreach Debut $LesDebuts Fin $LesFins {
	    set PosMid [expr ($Fin-$Debut)/2 + $Debut]
	    if {$PosMid>=$PosInfInteret && $PosMid<=$PosSupInteret} {
		lappend L "$ProbeSet\t$PosMid"
	    }
	}
	#set Deb [expr [lrange $LesDebuts 0 0] *1.0]
	#set Fin [expr [lrange $LesFins 0 0] *1.0]
	#set PosMid [expr ($Fin-$Deb)/2 + $Deb]
	
    }
    set Ltriee [lsort -real -increasing -index 1 $L]
    if {$Ltriee!=""} {
	foreach Elt $Ltriee {
	    set LesInfos [split $Elt "\t"]
	    set PosMid [lindex $LesInfos 1]
	    set ProbeSet [lindex $LesInfos 0]
	    foreach Affy $LesAffy {
		set FichierAffy "[RepertoireDuGenome]/PRIMA_Affy/$Affy"
		if {![file exists $FichierAffy]} {return "$FichierAffy does not exist"}
		set Val [InterrogeFichierAffyRMA $FichierAffy $ProbeSet Val]
		lappend LesDonneesAffy "$Affy\t$ProbeSet\t$PosMid\t$Val"
		set x [InterrogeFichierAffyRMA $FichierAffy "unset"]
	    }
	}
    }
    	
    ####################### fin ###############################
    if {[info exists LesBAC] && [info exists LesDonneesBAC]} {EspionneL $LesDonneesBAC}
    EspionneL $LesDonneesOligo
    EspionneL $LesDonneesAffy
    return ""

}

proc CompilePourPositionDonnee {{Cas ""} {Chromosome ""} {CytoBandInteret ""} {LesPos ""} {LesNoms ""}} {

    #!! renvoyer le resultat dans un fichier

    # Cas: voir ci-dessous
    # Chromosome: HS01 par ex
    # CytoBandInteret: 7q11.23 par ex

    # Les cas
    if {$Cas=="meta"} {
	set LesBAC {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827}
	set LesOligo {Oligo806 Oligo807 Oligo810 Oligo817 Oligo818 Oligo819 Oligo826 Oligo827}
	set LesAffy {RMA7 RMA711 RMA821 RMA855 RMA818 RMA918 RMA921}
    }
    if {$Cas=="nometa"} {
	set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {Oligo809 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825}
	set LesAffy {RMA845 RMA886 RMA819 RMA926 RMA923 RMA924 RMA925}
    }
    if {$Cas=="cl"} {
	#set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {CL_22rv1 CL_DU145 CL_LNCaP CL_PC3}
	set LesAffy {RMA22Rv1 RMADU145 RMALNCaP RMAPC3}
    }

    if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]}

    set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    if {![file exists $FichierLocCGHBAC] || $FichierLocCGHBAC == ""} {return ""}

    set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation"
    if {![file exists $FichierLocCGHOligo] || $FichierLocCGHOligo == ""} {return ""}

    ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms
    ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms

    set nChromosome [NumeroDuChromosome $Chromosome]
    
    set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap"
    
    if {![file exists $FichierBandesCytos]} {
	Espionne "$FichierBandesCytos does not exist"
	return ""
    }
    
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos
    if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""}
    
    set LesBandesP   [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
    set LesBandesQ   [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
    set LesBandesCytologiques $LesBandesP
    foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}
    
    set PosIni 0
    ### Trouver les bornes de la cytobande d'interet ###
    foreach Bande $LesBandesCytologiques {
	set LesInfos  [set LesBandesCytos($Chromosome,$Bande)]
	set Position [expr [lindex $LesInfos 0] * 1.e6]
	set TailleBande [expr round(($Position-$PosIni)/1.e6)]
	if {$Bande==$CytoBandInteret} {set PosInfInteret $PosIni; set PosSupInteret $Position}
	set PosIni $Position
    }
    #FaireLire "deb $PosInfInteret fin $PosSupInteret"
    ################## Les donnees BAC ################
    # pour chaque echantillon
    if {[info exists LesBAC]} {
	foreach BAC $LesBAC {
	    set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC"
	    ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] {
		    if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
			foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] {
			    set PosMid [lindex $LInfo 1]
			    set Val [lindex $LInfo 2]
			    if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} {
				foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] {
				    foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] {
					set DebutBAC [expr [lindex $LInfo 1]*1.0]
					set FinBAC [expr [lindex $LInfo 2]*1.0]
					set PosMilieu [expr ($FinBAC-$DebutBAC)/2 +$DebutBAC]
					if {$PosMilieu==$PosMid} {
					    set NomBAC [lindex $LInfo 3]
					    set IDBAC [lindex $LInfo 4]
					    set InterIDBAC [lindex $LInfo 5]
					    lappend LesDonneesBAC "$BAC\t$NomBAC\t$IDBAC\t$InterIDBAC\t$PosMid\t$Val"
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Oligo ################

    foreach Oligo $LesOligo {
	set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$Oligo"
	ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chromosome $LesPos
	if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} {
	    foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] {
		if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
		    set PosMid $Pos
		    foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] {
			set Val [lindex $LInfo 3]
			### tranfo log base 10 -> log base 2
			set Val [expr $Val*log(10)/log(2)]
			if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} {
			    foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] {
				foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] {
				    set DebutOli [expr [lindex $LInfo 1]*1.0]
				    set FinOli [expr [lindex $LInfo 2] *1.0]
				    set PosMilieu [expr ($FinOli-$DebutOli)/2 +$DebutOli]
				    if {$PosMilieu==$PosMid} {
					set NomProbe [lindex $LInfo 3]
					set Access [lindex $LInfo 4]
					lappend LesDonneesOligo "$Oligo\t$NomProbe\t$Access\t$PosMid\t$Val"
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Affy ################

    regsub "HS" $Chromosome "" num
    if {[regexp "^0" $num]} {regsub "0" $num "" num}
    set Chrom "chr$num"
    set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets]
    foreach ProbeSet $LesProbeSets {
	set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome] 
	if {[llength $LesChros]>1} {continue}
	set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] 
	set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin]
	foreach Debut $LesDebuts Fin $LesFins {
	    set PosMid [expr ($Fin-$Debut)/2 + $Debut]
	    if {$PosMid>=$PosInfInteret && $PosMid<=$PosSupInteret} {
		lappend L "$ProbeSet\t$PosMid"
	    }
	}
	#set Deb [expr [lrange $LesDebuts 0 0] *1.0]
	#set Fin [expr [lrange $LesFins 0 0] *1.0]
	#set PosMid [expr ($Fin-$Deb)/2 + $Deb]
	
    }
    set Ltriee [lsort -real -increasing -index 1 $L]
    if {$Ltriee!=""} {
	foreach Elt $Ltriee {
	    set LesInfos [split $Elt "\t"]
	    set PosMid [lindex $LesInfos 1]
	    set ProbeSet [lindex $LesInfos 0]
	    foreach Affy $LesAffy {
		set FichierAffy "[RepertoireDuGenome]/PRIMA_Affy/$Affy"
		if {![file exists $FichierAffy]} {return "$FichierAffy does not exist"}
		set Val [InterrogeFichierAffyRMA $FichierAffy $ProbeSet Val]
		lappend LesDonneesAffy "$Affy\t$ProbeSet\t$PosMid\t$Val"
		set x [InterrogeFichierAffyRMA $FichierAffy "unset"]
	    }
	}
    }
    	
    ####################### fin ###############################
    if {[info exists LesBAC]} {EspionneL $LesDonneesBAC}
    EspionneL $LesDonneesOligo
    EspionneL $LesDonneesAffy
    return ""

}

proc CompilePourUneListeDeGenesDonnee {{Cas ""} {LesChromosomes ""} {LesDebuts ""} {LesFins ""} {LesPos ""} {LesNoms ""}} {


    # Cas: voir ci-dessous
    # Chromosome: HS01 par ex

    if {$Debut=="" || $Fin==""} {return}
    # Les cas
    if {$Cas=="meta"} {
	set LesBAC {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827}
	set LesOligo {Oligo806 Oligo807 Oligo810 Oligo817 Oligo818 Oligo819 Oligo826 Oligo827}
	set LesAffy {RMA7 RMA711 RMA821 RMA855 RMA818 RMA918 RMA921}
    }
    if {$Cas=="nometa"} {
	set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {Oligo809 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825}
	set LesAffy {RMA845 RMA886 RMA819 RMA926 RMA923 RMA924 RMA925}
    }
    if {$Cas=="cl"} {
	#set LesBAC {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}
	set LesOligo {CL_22rv1 CL_DU145 CL_LNCaP CL_PC3}
	set LesAffy {RMA22Rv1 RMADU145 RMALNCaP RMAPC3}
    }

    if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]}

    set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    if {![file exists $FichierLocCGHBAC] || $FichierLocCGHBAC == ""} {return ""}

    set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation"
    if {![file exists $FichierLocCGHOligo] || $FichierLocCGHOligo == ""} {return ""}

    ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms
    ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms

    set nChromosome [NumeroDuChromosome $Chromosome]
    
    set PosInfInteret $Debut
    set PosSupInteret $Fin

    ################## Les donnees BAC ################
    # pour chaque echantillon
    if {[info exists LesBAC]} {
	foreach BAC $LesBAC {
	    set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC"
	    ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} {
		foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] {
		    if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
			foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] {
			    set PosMid [lindex $LInfo 1]
			    set Val [lindex $LInfo 2]
			    if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} {
				foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] {
				    foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] {
					set DebutBAC [expr [lindex $LInfo 1]*1.0]
					set FinBAC [expr [lindex $LInfo 2]*1.0]
					set PosMilieu [expr ($FinBAC-$DebutBAC)/2 +$DebutBAC]
					if {$PosMilieu==$PosMid} {
					    set NomBAC [lindex $LInfo 3]
					    set IDBAC [lindex $LInfo 4]
					    set InterIDBAC [lindex $LInfo 5]
					    lappend LesDonneesBAC "$BAC\t$NomBAC\t$IDBAC\t$InterIDBAC\t$PosMid\t$Val"
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Oligo ################

    foreach Oligo $LesOligo {
	set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$Oligo"
	ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chromosome $LesPos
	if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} {
	    foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] {
		if {$Pos>=$PosInfInteret && $Pos<=$PosSupInteret} {
		    set PosMid $Pos
		    foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] {
			set Val [lindex $LInfo 3]
			### tranfo log base 10 -> log base 2
			set Val [expr $Val*log(10)/log(2)]
			if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} {
			    foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] {
				set NomProbeIni toto
				foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] {
				    set DebutOli [expr [lindex $LInfo 1]*1.0]
				    set FinOli [expr [lindex $LInfo 2] *1.0]
				    set PosMilieu [expr ($FinOli-$DebutOli)/2 +$DebutOli]
				    if {$PosMilieu==$PosMid} {
					set NomProbe [lindex $LInfo 3]
					set Access [lindex $LInfo 4]
					if {$NomProbe!=$NomProbeIni} {
					    lappend LesDonneesOligo "$Oligo\t$NomProbe\t$Access\t$PosMid\t$Val"
					    set NomProbeIni $NomProbe
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    ################## Les donnees Affy ################

    regsub "HS" $Chromosome "" num
    if {[regexp "^0" $num]} {regsub "0" $num "" num}
    set Chrom "chr$num"
    set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets]
    foreach ProbeSet $LesProbeSets {
	set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome] 
	if {[llength $LesChros]>1} {continue}
	set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] 
	set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin]
	foreach Debut $LesDebuts Fin $LesFins {
	    set PosMid [expr ($Fin-$Debut)/2 + $Debut]
	    if {$PosMid>=$PosInfInteret && $PosMid<=$PosSupInteret} {
		lappend L "$ProbeSet\t$PosMid"
	    }
	}
	#set Deb [expr [lrange $LesDebuts 0 0] *1.0]
	#set Fin [expr [lrange $LesFins 0 0] *1.0]
	#set PosMid [expr ($Fin-$Deb)/2 + $Deb]
	
    }
    set Ltriee [lsort -real -increasing -index 1 $L]
    if {$Ltriee!=""} {
	foreach Elt $Ltriee {
	    set LesInfos [split $Elt "\t"]
	    set PosMid [lindex $LesInfos 1]
	    set ProbeSet [lindex $LesInfos 0]
	    foreach Affy $LesAffy {
		set FichierAffy "[RepertoireDuGenome]/PRIMA_Affy/$Affy"
		if {![file exists $FichierAffy]} {return "$FichierAffy does not exist"}
		set Val [InterrogeFichierAffyRMA $FichierAffy $ProbeSet Val]
		lappend LesDonneesAffy "$Affy\t$ProbeSet\t$PosMid\t$Val"
		set x [InterrogeFichierAffyRMA $FichierAffy "unset"]
	    }
	}
    }
    	
    ####################### fin ###############################
    if {[info exists LesBAC] && [info exists LesDonneesBAC]} {EspionneL $LesDonneesBAC}
    EspionneL $LesDonneesOligo
    EspionneL $LesDonneesAffy
    return ""

}

proc ComplementDNA {seq} {

    set lg [string length $seq]
    set cpt ""
    set seq [string toupper $seq]
    for {set i 0} {$i < $lg} {incr i} {
	switch [string index $seq $i] {
	    "A" {append cpt "T"}
	    "T" {append cpt "A"}
	    "G" {append cpt "C"}
	    "C" {append cpt "G"}
	    "N" {append cpt "N"}
	}
    }

    return $cpt

}

proc ComplementInfoPourTous {} {

    global RepertoireDuGenome
    
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/Fam.txt"] {
	scan $Ligne "%s %s" Alias Autre
	set Alias [string toupper $Alias]
	set MaLigne($Alias) $Ligne
	if { ! [regexp {\(} $Autre]} { set Autre "" }
	Espionne "$Alias $Autre."
	regsub -all {[\(\)]} $Autre "" MonAutre($Alias)
	set Reste [string range $Ligne 26 35]
	set BAE ""
	if {[regexp "P" $Reste]} { append BAE "B" } else { append BAE "b" } 
	if {[regexp "A" $Reste]} { append BAE "A" } else { append BAE "a" } 
	if {[regexp "E" $Reste]} { append BAE "E" } else { append BAE "e" }
	set MonBAE($Alias) $BAE
    }
    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	set Autre [set MonAutre($Alias)]
	if {$Autre!=""} { set Autre "/$Autre" }
	InformeSansDemander $Nom "ValiGN: $Alias$Autre\nFamily: [set MaLigne($Alias)]\nBAE: [set MonBAE($Alias)]"
    }
    

}

proc ComplementNuc {Nuc} {

    global ComplementNuc

    if {[info exists ComplementNuc($Nuc)]} { return [set ComplementNuc($Nuc)] }
    if {[info exists ComplementNuc]} { return $Nuc }

    set ComplementNuc(X) "X"
    set ComplementNuc(x) "x"
    set ComplementNuc(A) "T"
    set ComplementNuc(T) "A"
    set ComplementNuc(G) "C"
    set ComplementNuc(C) "G"
    set ComplementNuc(a) "t"
    set ComplementNuc(t) "a"
    set ComplementNuc(g) "c"
    set ComplementNuc(c) "g"
    set ComplementNuc(N) "N"
    set ComplementNuc(n) "n"

    set ComplementNuc(M) "K"
    set ComplementNuc(K) "M"
    set ComplementNuc(R) "Y"
    set ComplementNuc(Y) "R"
    set ComplementNuc(W) "W"
    set ComplementNuc(S) "S"
    
    set ComplementNuc(m) "k"
    set ComplementNuc(k) "m"
    set ComplementNuc(r) "y"
    set ComplementNuc(y) "r"
    set ComplementNuc(w) "w"
    set ComplementNuc(s) "s"
    
    set ComplementNuc(V) "B"
    set ComplementNuc(H) "D"
    set ComplementNuc(D) "H"
    set ComplementNuc(B) "V"
    set ComplementNuc(v) "b"
    set ComplementNuc(h) "d"
    set ComplementNuc(d) "h"
    set ComplementNuc(b) "v"

    set ComplementNuc(ListKey)      [array names ComplementNuc]
    set ComplementNuc(ListKeyValue) [array get ComplementNuc]

    return [ComplementNuc $Nuc]

}

proc ComplementString {S} {

    regsub -all -- "A" $S "Z" S 
    regsub -all -- "T" $S "A" S
    regsub -all -- "Z" $S "T" S 
    regsub -all -- "G" $S "Z" S 
    regsub -all -- "C" $S "G" S
    regsub -all -- "Z" $S "C" S

    regsub -all -- "a" $S "z" S 
    regsub -all -- "t" $S "a" S
    regsub -all -- "z" $S "t" S 
    regsub -all -- "g" $S "z" S 
    regsub -all -- "c" $S "g" S
    regsub -all -- "z" $S "c" S
    return $S

}

proc CompleteBlastGscopeProject {{ProjName ""} {BlastDatabase ""} {ProttfaCourant ""}} {

    #rR est lancé en QDS ?????????????,

    if {$ProttfaCourant==""} { set ProttfaCourant "prottfa" }

    if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] }

    if {$ProjName==""} { set ProjName [file tail [RepertoireDuGenome]] }

    if {[PasTouche "CompleteBlastGscopeProject"]} { return "Sorry. CompleteBlastGscopeProject is still running" } 
    set PassePlat ""
    if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	scan $DBSizeTxt "%d" DBSize 
	Espionne      "Grillade::creerPoeleBlast  ProjectName $ProjNameWithDate  Input [RepertoireDuGenome]/$ProttfaCourant  DB $BlastDatabase  DBsize $DBSize"
	set PassePlat [Grillade::creerPoeleBlast  ProjectName $ProjNameWithDate  Input [RepertoireDuGenome]/$ProttfaCourant  DB $BlastDatabase  DBsize $DBSize]
	if {[regexp -nocase "^Error" $PassePlat]} {
	    set Message "Error. Something is wrong with Grilladin. I got the error message $PassePlat"
	}
	#rR Tcl ne veut pas pointer si la cible n'existe pas :file link -symbolic "[RepertoireDuGenome]/passeplat" "$PassePlat/blastp"
	exec ln -sf "$PassePlat/blastp" "[RepertoireDuGenome]/passeplat"
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
	set Message "Warning. I launched Grilladin for $ProjName. Blast files will be available at $PassePlat" 
	return $Message
    } else {
	set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin"
    }
    LogWscope $Message
    FinPasTouche "CompleteBlastGscopeProject"
    return $Message

}

proc CompleteCreateBlastDatabaseWithFasta {{FastaFile ""} {BlastDatabaseName ""}} {


    if {$BlastDatabaseName==""} { set BlastDatabaseName [file tail $FastaFile] } ;#rR 2016/11/07

LogWscope "CompleteCreateBlastDatabaseWithFasta $FastaFile $BlastDatabaseName"

    set Logfile $BlastDatabaseName.formatdb.log
    exec formatdb -i $FastaFile -p T -n $BlastDatabaseName -l $Logfile -o T
    if {[FileAbsent $Logfile]} {
	set Message "Error. Something went wrong with CompleteCreateBlastDatabaseWithFasta. I didn't got the log file"
    } elseif {[FileAbsent $BlastDatabaseName.phr] && [FileAbsent $BlastDatabaseName.pal]} {
	set Message "Error. Something went wrong with CompleteCreateBlastDatabaseWithFasta. I didn't got the result. Log file contents [ContenuDuFichier $Logfile]"
    } else {
	set Message "OK. The BlastDatabase should be available at $BlastDatabaseName."
    }
    LogWscope $Message
    return $Message

}

proc CompleteEtExecute {Commande} {

    regsub { +\{ *$} $Commande "" Commande
    Espionne ">$Commande<"
    if {[regexp -nocase {[a-z0-9_]+ +\{\}} $Commande]} {
	scan $Commande "%s" Complete
    } else {
	set Complete [Entre $Commande]
    }
    if {$Complete==""} { return "" }
    return [Execute $Complete]    

}

proc CompleteFicheInfo {{directory ""}} {


    if {$directory==""} {set directory [RepertoireDuGenome]/protembl}
    foreach Nom [ListeDesPABs] {
	Espionne "$Nom"
	set LL [LaSequenceDesBanques "$directory/$Nom"]
	DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX SequenceBrute LaDETotal
	set lengthSeq [LongueurDeLaSequence $Nom prottfa]
	set nbOrtho [nombreCaracteristiqueAnalyse $Nom orthologie]
	set nbPfam  [nombreCaracteristiqueAnalyse $Nom pfam]
	set nbPDB   [nombreCaracteristiqueAnalyse $Nom pdb]
	set nbInt   [nombreCaracteristiqueAnalyse $Nom interaction]

	Espionne "$LL"
	Espionne "$nbPfam"
	
	InformeSansDemander $Nom "=LOPPI: $lengthSeq $nbOrtho $nbPDB $nbPfam $nbInt"

	Espionne "ID: $ID"

	InformeSansDemander $Nom "ID: $ID"
	InformeSansDemander $Nom "AC: $AC"
	InformeSansDemander $Nom "DE: $DE"
	InformeSansDemander $Nom "OS: $OS"
	InformeSansDemander $Nom "OC: $OC"
	InformeSansDemander $Nom "OX: $OX"
	#Espionne "$Nom BestID: $ID"
	#Espionne "$Nom BestAC: $AC"
	#Espionne "$Nom BestDE: $DE"
	#Espionne "$Nom BestGN: $GN"
	#Espionne "$Nom BestOS: $OS"
	#Espionne "$Nom BestOC: $OC"
	#Espionne "$Nom BestOX: $OX"
    }


}

proc CompleteFichierDesJumeauxProtNotHumanChoisie {FichierDesPABs FichierJumeaux FichierSortie} {

    #FichierDesPABs=fiches/LesDDSansJumSeqSansCourtsSansJumProtChoisie
    #FichierJumeaux=fiches/jumeaux_AccProtChoisie_NotHuman
    #FichierSortie=fiches/LesDDAvecProtChoisieNotHuman
    set j 0
    foreach Ligne [LesLignesDuFichier $FichierJumeaux] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Jum $LesJumeaux {if {![info exists Vu($Jum)]} {set Vu($Jum) 1; incr j} else {Espionne $Jum}}
    }
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set s 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]
	if {$AccessProt!="NOPROTEIN" && $AccessProt!="" && $Orga!="Homo sapiens"} {
	    if {![info exists Vu($Nom)]} {lappend LesSupp $Nom; incr s}
	}
    }
    set Jumeaux [ContenuDuFichier $FichierJumeaux]
    #FaireLire $Jumeaux
    set LesJum [split $Jumeaux "\n"]
    #FaireLire $LesJum
    #FaireLire $LesSupp
    set LTotale [concat $LesSupp $LesJum]
    #set LTotale [concat $LesSupp [ContenuDuFichier $FichierJumeaux]]
    set LTotaleTriee [lsort $LTotale]
    Espionne [llength $LTotaleTriee]
    Espionne "nb j: $j - nb supp: $s"
    SauveLesLignes $LTotaleTriee dans $FichierSortie

}

proc CompleteFichierFinalAvecMA {FichierFinal FichierMA} {

    # FichierMA= ANALYSE/Macroarrays/Moyennes_pourfinal
    foreach Ligne [LesLignesDuFichier $FichierMA] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set NumGene [lindex $LesElts 0]
	set FCMA [lindex $LesElts 1]
	set FoldMA($NumGene) $FCMA
    }
    foreach Ligne [LesLignesDuFichier $FichierFinal] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set n [lindex $LesElts 0]
	if {[info exists FoldMA($n)]} {lappend LesElts "$FoldMA($n)"} else {lappend LesElts " "}
	set L [join $LesElts "\t"]
	lappend LFinale $L
    }
    #Espionne [llength $LFinale]
    return $LFinale

}

proc CompleteFichierFinalAvecMAEtTests {FichierFinalAvecMA FichierTTest FichierTestW FichierTestSAM} {

    # FichierTTest= select_ttest_avec18_genesuniq
    # FichierTestW= select_testw_avec18_genesuniq
    # FichierTestSAM=select_SAM_avec18_genesuniq
    foreach Ligne [LesLignesDuFichier $FichierTTest] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set NumGene [lindex $LesElts 0]
	set SelT [lindex $LesElts 1]
	set RatioT [lindex $LesElts 2]
	set NbTotT [lindex $LesElts 3]
	set RaT($NumGene) $RatioT
	set SelTTest($NumGene) $SelT
	set NbT($NumGene) $NbTotT
    }
    foreach Ligne [LesLignesDuFichier $FichierTestW] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set NumGene [lindex $LesElts 0]
	set SelW [lindex $LesElts 1]
	set RatioW [lindex $LesElts 2]
	set NbTotW [lindex $LesElts 3]
	set RaW($NumGene) $RatioW
	set SelTestW($NumGene) $SelW
	set NbW($NumGene) $NbTotW
    }
    foreach Ligne [LesLignesDuFichier $FichierTestSAM] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set NumGene [lindex $LesElts 0]
	set SelS [lindex $LesElts 1]
	set RatioS [lindex $LesElts 2]
	set NbTotSAM [lindex $LesElts 3]
	set RaS($NumGene) $RatioS
	set SelTestS($NumGene) $SelS
	set NbSAM($NumGene) $NbTotSAM
    }
    foreach Ligne [LesLignesDuFichier $FichierFinalAvecMA] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set n [lindex $LesElts 0]
	if {[info exists SelTTest($n)]} {lappend LesElts "$SelTTest($n)"} else {lappend LesElts " "}
	if {[info exists RaT($n)]} {lappend LesElts "$RaT($n)"} else {lappend LesElts " "}
	if {[info exists NbT($n)]} {lappend LesElts "$NbT($n)"} else {lappend LesElts " "}

	if {[info exists SelTestW($n)]} {lappend LesElts "$SelTestW($n)"} else {lappend LesElts " "}
	if {[info exists RaW($n)]} {lappend LesElts "$RaW($n)"} else {lappend LesElts " "}
	if {[info exists NbW($n)]} {lappend LesElts "$NbW($n)"} else {lappend LesElts " "}

	if {[info exists SelTestS($n)]} {lappend LesElts "$SelTestS($n)"} else {lappend LesElts " "}
	if {[info exists RaS($n)]} {lappend LesElts "$RaS($n)"} else {lappend LesElts " "}
	if {[info exists NbSAM($n)]} {lappend LesElts "$NbSAM($n)"} else {lappend LesElts " "}
	set L [join $LesElts "\t"]
	lappend LFinale $L
    }
    #Espionne [llength $LFinale]
    return $LFinale

}

proc CompleteFichierFinalAvecMitochondrie {FichierFinal FichierMito} {

    # FichierFinal /ANALYSE/final
    # FichierMito /ANALYSE/MitochondrialProteins
    foreach Ligne [LesLignesDuFichier $FichierMito] {
	if {$Ligne==""} {continue}
	set DD $Ligne 
	set M($DD) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierFinal] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set DD [lindex $LesElts 1]
	if {[info exists M($DD)]} {lappend LesElts $M($DD)} else {lappend LesElts " "}
	set L [join $LesElts "\t"]
	lappend LFinale $L
    }
    #Espionne [llength $LFinale]
    return $LFinale

}

proc CompleteGenomeScan {} {


    Wup "Proc pour lancer tous les TBlastN sur les genomes"

    /g1/ARP/banques/completegenomes.nal
    /g1/ARP/banques/genome_all.nal
    /g1/ARP/banques/genome_anopheles.nal
    /g1/ARP/banques/genome_ciona.nal
    /g1/ARP/banques/genome_cryptoparvum.nal
    /g1/ARP/banques/genome_cyanidioschyzon.nal
    /g1/ARP/banques/genome_dictyostelium.nal
    /g1/ARP/banques/genome_plasmodium.nal
    /g1/ARP/banques/genome_tetraodon.nal
    /g1/ARP/banques/genomesforarp.nal
    /g1/ARP/banques/genomesforarp2.nal
    /g1/ARP/banques/wgs-vertebrate.nal
    

}

proc CompleteGenomesPerDB {{what all} {details 0}} {

    #lm 2015/09/20
    # Returns the number of complete genomes per DB.
    # By default, returns for all db's in the order :
    # uniprot - gold - ncbi

    if {$what ni {uniprot ncbi gold all}} {
	return
    }

#    set db [InitTaxDB]
    unset -nocomplain ::db

    set db "root"
    sqlite3 $db /home/moumou/SoTOL/sotol.sql
    $db eval {begin transaction}
    set Ldbs [$db eval {select value from sotol where var = 'Ldbs'}]

    if {$what eq "all"} {
	set Ldb [split [join $Ldbs] " "]
    } else {
	set Ldb $what
    }

    set Lres [list]
    foreach ndb $Ldb {
	set key "$ndb,NbComp"
	lappend Lres [$db eval {select value from sotol where var = 'VSotol' and key = $key}]
	if {$details} {
	    foreach k {NbEuk NbArk NbBac} {
		set key "$ndb,$k"
		lappend Lres [$db eval {select value from sotol where var = 'VSotol' and key = $key}]
	    }
	}

	if {0} {
	    switch $db {
		"uniprot" {
		    # UniProt
		    set Lg [UniProtGenomes]
		    set nbUniProt [llenght $Lg]
		    lappend Lres $nbUniProt
		}
		"gold" {
		    # gold
		    set nbGold [$db eval {select count(distinct(taxid)) from gold where isComp=1}]
		    lappend Lres $nbGold
		}
		"ncbi" {
		    # NCBI
		}
	    }
	}
    }
    $db eval {commit}
    $db close
    
    return $Lres

}

proc CompleteGscopeProjectWithFasta {{FastaFile ""} {ProjName ""} {Prefixe ""} {NbDigit ""} {OS ""} {OX ""} {OC ""} {BlastDatabase ""}} {

    #rR est lancé en QDS
    if {$NbDigit=="."} { set NbDigit "" }
    if {$OS=="."} { set OS "" }
    if {$OX=="."} { set OX "" }
    if {$OC=="."} { set OC "" }
    
    if {$OX!="" && $OS==""} { set OS [QuestionDeScience EVImm "ret Tax $OX Name"] }
    if {$OS!="" && $OX==""} { set OX [QuestionDeScience EVImm "ret Tax $OS TaxId"] }
    if {$OX!="" && $OC==""} { set OC [QuestionDeScience EVImm "ret TaxClass $OX Name"] }
    if {$OS!="" && $OC==""} { set OC [QuestionDeScience EVImm "ret TaxClass $OS Name"] }
    regsub "^root; cellular organisms; " $OC "" OC 
    
    if {[PasTouche "CompleteGscopeProjectWithFasta"]} { return "Sorry. CompleteGscopeProjectWithFasta is still running" } 
    if {$NbDigit==""} { set NbDigit 5 }
    CreeFichierMiniConfig $Prefixe $NbDigit Prot $OX
    CreeLaCollection TFA $FastaFile "" KeepEntete "No" "No"
#    AllForGo
    LogWscope "BlastDatabase=$BlastDatabase"
    set PassePlat ""
    if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	scan $DBSizeTxt "%d" DBSize
	set NSeqPerJob 200
	set PassePlat [Grillade::creerPoeleBlast ProjectName $ProjNameWithDate InputDir "[RepertoireDuGenome]/prottfa" DB $BlastDatabase DBsize $DBSize NSeqPerJob $NSeqPerJob]
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
    } else {
	LogWscope "$BlastDatabase invalid"
    }
    FinPasTouche "CompleteGscopeProjectWithFasta"
    set Message "OK. Most of the job is done for CompleteGscopeProjectWithFasta."
    if {$PassePlat!=""} { append $Message "Blast files will be available at $PassePlat" }
    return $Message

}

proc CompleteGscopeProjectWithOi {Source OiCode FichierFasta {NbDigit ""}} {

    #rR est lancé en QDS
    if {[PasTouche "CompleteGscopeProjectWithOi"]} { return "Sorry. CompleteGscopeProjectWithOi is still running" } 
    if {$NbDigit==""} { set NbDigit 5 }
    if {$Source=="OiOld"} {
	set OX [OiName $OiCode OX]
    } else {
	#rR Source est OiArchaea ou OiEukaryota
	set Domain [string range $Source 2 end]
	set OX [OiCodeForDomain $Domain $OiCode OX]
    }
    CreeFichierMiniConfig $OiCode $NbDigit Prot $OX
    CreeLaCollection TFA $FichierFasta "" KeepEntete "No" "No"
    AllForGo
    FinPasTouche "CompleteGscopeProjectWithOi"
    return "OK. All is done for CompleteGscopeProjectWithOi"

}

proc CompleteLaDataBase {{BanqueTBlastN ""}} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOC
    global Org1 Org2

    if { [file exists "$RepertoireDuGenome/blastp"] && [OuiOuNon "Can I count the blastp hits ? "]} {
	if {[OuiOuNon "Do I use Daedalus ?"]} {
	    DaedalusHitsDuBlastPPourTous
	    CreeLeFichierNombreDeCopainsDansBlast
	} else {
	    CreeLesFichiersApns
	    CreeLeFichierNombreDeCopainsDansBlast
	}
	WithPDB "CreateIt"
    }
    if { [file exists "$RepertoireDuGenome/blastn"] && [OuiOuNon "Can I count the blastn hits ? "]} {
	CreeLesFichiersApns blastn
	CreeLeFichierNombreDeCopainsDansBlast
    }
    if {[file exists "$RepertoireDuGenome/apns"] && [OuiOuNon "Do I create Narcisse (the database reference of each prot) ?" ]} {
	Narcisse CreateIt
	if {[OuiOuNon "Do I update /infos files with the fields ID AC DE GN found in the database ?"]} {
	    InformeParNarcissePourTous
	}
    }
    if {[file exists "$RepertoireDuGenome/apns"] && [OuiOuNon "Do I create OrthoBlastP ?" ]} {
	CreeOrthoBlastP
	ORGAorgaDesBlastPs "CreateIt"
    }

    AnalyseLesDbClustal 

    if { [OuiOuNon "Do I create the phylo ranks  ? "]} {
	PhyloRank
    }

    AnalyseLesTBlastN $BanqueTBlastN

    if {[OuiOuNon "Do I create the summary files in $RepertoireDuGenome/notes/ ?"]} {
	CreeToutesLesNotes
    }

}

proc CompleteLaListeDesOligos {{LesPABsDF ""} {Dest1 ""} {Dest2 ""}} {

    
    Wup "Complete les resultats d 1 designe a 1 autre"
    Wup "Met a jour le fichier .oligo et .log"
    Wup "Ajoute un oligo a la liste de ceux deja designe de dir1 a dir2"
    Wup "Cas particulier pour un redesign et completer la liste"
    Wup "Version avec liste de liste de NomPAB debutOligo finOligo"

    if {$LesPABsDF==""} {
	set LesPABsDF [list  [list ACT0016 1215 1274]  [list ACT0010 1665 1724]  [list ACT0017 1713 1772]  [list ACT0005 1265 1324]  [list ACT0059 506 565]  [list ACT0059 26 85]  [list ACT0204 1176 1235]  [list ACT1162 1416 1475]  [list ACT0053 462 521]  [list ACT0053 281 340]  [list ACT0053 111 170]]
    }
    ###if {$Dest1==""} {set Dest1 "[RepertoireDuGenome]/Probes/RefSeq"}
    ###if {$Dest2==""} {set Dest2 "[RepertoireDuGenome]/Probes/Unigene"}
    Espionne "$Dest1 $Dest2"
    FaireLire "on y va"
    foreach PABDF $LesPABsDF {
	set PAB   [lindex $PABDF 0]
	set Debut [lindex $PABDF 1]
	set Fin   [lindex $PABDF 2]

	set DirOligo1 "[RepertoireDuGenome]/Probes/Redesign/RefSeq"
	set DirOligo2 "[RepertoireDuGenome]/Probes/Redesign/Unigene"
	set LogFile1  "$DirOligo1/${PAB}.log"
	set LogFile2  "$Dest1/${PAB}.log"
	
	Espionne ">>> AjouteUnOligoPourCeuxDejaFait $PAB $PAB $DirOligo1 $Dest1 \"$Debut $Fin\""
	AjouteUnOligoPourCeuxDejaFait $PAB $PAB "$DirOligo1" $Dest1 "$Debut $Fin"
	InterrogeInfoDeLOligo unset
	CompleteLeLogFileDeLOligo "$Debut $Fin" $LogFile1 $LogFile2

	if {$Dest2==""} {
	    set LogFile1  "$DirOligo2/${PAB}.log"
	    set LogFile2  "$Dest2/${PAB}.log"
	    AjouteUnOligoPourCeuxDejaFait $PAB $PAB "$DirOligo2" $Dest2 "$Debut $Fin"
	    InterrogeInfoDeLOligo unset
	    CompleteLeLogFileDeLOligo "$Debut $Fin" $LogFile1 $LogFile2
	}
	#UnOligoPourExcel $PAB "$Debut $Fin" $Dest1 $Dest2 "[RepertoireDuGenome]/NewOligo"
    }
    return ""

}

proc CompleteLaListeDesOligos_GUI {K {PAB ""} {DirOligo1 ""}} {

    
    Wup "Ajoute un oligo a la liste de ceux deja designe de dir1 a dir2"
    Wup "Cas particulier pour un redesign et completer la liste"
    Wup "Version graphique avec selection visuelle des oligos"

    if {$PAB=="" || $DirOligo1==""} {return ""}

    set FichierACharger1 "$DirOligo1/${PAB}.oligo"

    while {1} {
	set Texte "Choose a directory to complete $PAB oligos"
	FaireLire "$Texte"
	set Dir [tk_chooseDirectory -title "Choose the directory to be completed" -initialdir "[RepertoireDuGenome]"]
	if {$Dir == ""} {
	    if {! [OuiOuNon "Would you like to continue ?"]} {return ""}
	} else {
	    set DirOligo2 $Dir
	    break
	}
    }
        
    set FichierACharger2 "$DirOligo2/${PAB}.oligo"
    set Answer           ""
    set LesNomsOligos    ""
    while {1} {
	set Texte  "Please choose with Control+1 the oligo(s) to add:\nfrom $DirOligo1\nin $DirOligo2\nThen click on Ok."
	set Answer [FaireSavoir $Texte "Adding Results - Waiting your selection."]

	set  LesNomsOligos [LesOligosSelectionnes $K]
	if {$LesNomsOligos==""} {
	    if {! [OuiOuNon "No Oligo selected !\nWould you like to retry ?"]} {break} else {continue}
	}
	break
    }
    
    set LogFile1 "$DirOligo1/${PAB}.log"
    set LogFile2 "$DirOligo2/${PAB}.log"

    #On test si les resultats etaient deja charges ou non
    set  EstCharge  ""
    set  EstCharge [InterrogeInfoDeLOligo $FichierACharger2 EstCharge]
    if {$EstCharge==""} {set EstCharge 0}

    if {! [OuiOuNon "Are you sure to add the selected Oligo(s) to another ?"]} {return ""}
    foreach LeNomOligo $LesNomsOligos {
	set Debut [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Debut]
	set Fin   [InterrogeInfoDeLOligo $FichierACharger1 $LeNomOligo Fin]
	
	AjouteUnOligoPourCeuxDejaFait $PAB $PAB $DirOligo1 $DirOligo2 "$Debut $Fin"
	#Les infos sont modifies dans le deuxieme lot
	#InterrogeInfoDeLOligo $FichierACharger1 Decharge
	if {$EstCharge=="0"} {
	    #On ne decharge que si il ne l etais pas avant
	    InterrogeInfoDeLOligo $FichierACharger2 Decharge
	}	
	CompleteLeLogFileDeLOligo "$Debut $Fin" $LogFile1 $LogFile2
    }
    return ""

}

proc CompleteLaTableBackUp {Fichier} {

    # Fichier = /HeadNecknonrnr/backup/TousComplete_3oct2005.txt

    # Reverse Northern
    set FichierAnne "[RepertoireDuGenome]/ReverseNorthern/Anne_perso.txt"
    set FichierChrist "[RepertoireDuGenome]/ReverseNorthern/Christine_perso.txt"
    set FichierChunhua "[RepertoireDuGenome]/ReverseNorthern/Chunhua_perso.txt"
    set FichierFred "[RepertoireDuGenome]/ReverseNorthern/Fred_perso.txt"
    set FichierInnes "[RepertoireDuGenome]/ReverseNorthern/Innes_perso.txt"
    set FichierJulia "[RepertoireDuGenome]/ReverseNorthern/Julia_perso.txt"
    set FichierPatricia "[RepertoireDuGenome]/ReverseNorthern/Patricia_perso.txt"

    foreach Ligne [LesLignesDuFichier $FichierAnne] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) ""
    }
    foreach Ligne [LesLignesDuFichier $FichierChrist] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) ""
    }
    foreach Ligne [LesLignesDuFichier $FichierChunhua] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) ""
    }
    foreach Ligne [LesLignesDuFichier $FichierFred] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [string toupper [lindex $LesElts 1]]
	set Rev [lindex $LesElts 2]
	set RevSpe [lindex $LesElts 3]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) $RevSpe
    }
    foreach Ligne [LesLignesDuFichier $FichierInnes] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) ""
    }
    foreach Ligne [LesLignesDuFichier $FichierJulia] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) ""
    }
    foreach Ligne [LesLignesDuFichier $FichierPatricia] {
	if {[regexp -nocase "user" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	set User [lindex $LesElts 0]
	set CC [lindex $LesElts 1]
	set Rev [lindex $LesElts 2]
	set RevSpe [lindex $LesElts 3]
	set RN($User,$CC) $Rev
	set Spe($User,$CC) $RevSpe
    }
    ### Fin RN 
    set FichierCorres "[RepertoireDuGenome]/lacorrespondance"
    # Paper1
    foreach Ligne [LesLignesDuFichier $FichierCorres] {
	if {$Ligne==""} {continue}
	set Ligne [split $Ligne "\t"]
	set New [lindex $Ligne 0]; set Old [lindex $Ligne 1]
	set O($Old) $New
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/paper1"] {
	if {[info exists O($Ligne)]} {set DD $O($Ligne); set Paper($DD) 1} else {Espionne "no correspondance pour $Ligne"}
    }
    
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp -nocase "missingsequence" $Ligne]} {continue}
	set LesElts [split $Ligne "\t"]
	#FaireLire $LesElts
	set DD [lindex $LesElts 0]
	set U [lindex $LesElts 5]
	set C [lindex $LesElts 4]

	# Reverse Northern
	if {![info exists RN($U,$C)]} {set RN($U,$C) ""}
	if {![info exists Spe($U,$C)]} {set Spe($U,$C) ""}
	# Paper1
	if {![info exists Paper($DD)]} {set Paper($DD) ""}

	lappend LesElts "$RN($U,$C)"
	lappend LesElts "$Spe($U,$C)"
	lappend LesElts "$Paper($DD)"
	#Espionne $Ligne
	set NewLine [join $LesElts "\t"]
	lappend Liste $NewLine
    }
    #set Liste [join $LesElts "\t"]
    #EspionneL $Liste
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/essaibackup"

}

proc CompleteLeFichierDesJumeaux {Fichier} {

#Complete le fichier jumeaux_Overlap (ou autre) avec les clones sans localisation
#les noloc ayant la meme sequence sont regroupes selon fichier jumeaux_SeqNuc
    global RepertoireDuGenome 
    foreach Nom [ListeDesPABs] {
	set Vu($Nom) 0
    }
    set TexteDuFichierDesJumeauxTrie ""

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne!=""} {
	    set LesJumeaux [split $Ligne " "]
	    foreach Jumeau $LesJumeaux {
		set Vu($Jumeau) 1
	    }
	    set Ligne [join $LesJumeaux " " ]
	    append TexteDuFichierDesJumeauxTrie "$Ligne\n"
	}
    }

    set LeTexteDuFichierTrie [split $TexteDuFichierDesJumeauxTrie "\n"]
    set LeTexteDuFichierTrie [lsort -dictionary $LeTexteDuFichierTrie]
    set TexteDuFichierDesJumeauxTrie [join $LeTexteDuFichierTrie "\n"]

    set NouveauContenu "$TexteDuFichierDesJumeauxTrie\n"
    foreach Nom [ListeDesPABs] {
	if {$Vu($Nom)==0} {
	    set LigneDesjumeauxSeqNuc [LigneDuFichierJumeauxSeqNuc $Nom]
	    if {$LigneDesjumeauxSeqNuc!=""} {
		append NouveauContenu "$LigneDesjumeauxSeqNuc\n"
		set LesJumeauxSeqNuc [split $LigneDesjumeauxSeqNuc " "]
		foreach JumeauSeqNuc $LesJumeauxSeqNuc {
		    set Vu($JumeauSeqNuc) 1
		}
	    } else {
		append NouveauContenu "$Nom\n"
		set Vu($Nom) 1
	    }
	} else {
	    continue
	} 
    }
    set LeNouveauContenu [split $NouveauContenu "\n"]
    set LeNouveauContenu [lsort -dictionary $LeNouveauContenu]
    set NouveauContenu [join $LeNouveauContenu "\n"]
    return $NouveauContenu

}

proc CompleteLeFichierErreurs {Fichier} {

    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Nom ""
	if {[YaPABenDebutDe $Ligne]} {
	    set Nom [string range $Ligne 0 6]
	}
	if {[regexp {^TROU[0-9][0-9]+[A-FN]} $Ligne]} {
	    set Nom [string range $Ligne 0 8]
	}
	if { $Nom != "" } { 
	    set Ligne [format "%8.8s %8.8s %s" [Box $Nom debut] [Box $Nom fin] $Ligne]
	}
	Espionne $Ligne
    }

}

proc CompleteLeLogFileDeLOligo {DF Log1 Log2} {


    Wup "proc AjouteUnOligoPourCeuxDejaFait --> Ajoute un oligo a la liste de ceux deja designe de Log1 a Log2"
    Wup "Ici on complete le log file associe si l oligo n existait pas"
    Wup "Cas particulier pour un redesign et completer la liste"

    set Fichier1    $Log1
    set Fichier2    $Log2
    set FichierNew "$Log2.tmp"
    if {![file exists $Fichier1] || ![file exists $Fichier2] || $DF == ""} {return ""}
    
    set Debut [lindex $DF 0]
    set Fin   [lindex $DF 1]

    #Parcours du premier log et extraction de la zone a inseree dans le deuxieme log
    set OnLeTient 0
    set NewLines ""
    set F [open "$Fichier1"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	#Moving on: 41 100
	if {$OnLeTient} {
	    if {[regexp -nocase {Moving on:} $Ligne]} {
		set OnLeTient 0
		break
	    }
	    lappend NewLines $Ligne
	}
	if {! [regexp -nocase "Moving on: $Debut $Fin" $Ligne]} {continue}
	set OnLeTient 1

	lappend NewLines $Ligne
    }
    close $F
    if {$NewLines == ""} {return ""}
    set  NewLines [join $NewLines "\n"]
    
    #Recopiage du deuxieme log et insertion au bon endroit de la zone extraite precedemment
    #On sauve les lignes toujours apres donc on peut inserer au bon endroit
    set OnAPasCommence 0
    set OkOnASauve     0
    set OnEfface       0
    set OnSkip         0
    set LesLignes      ""
    set Ligne          ""
    set F [open "$Fichier2"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {$OnSkip} {
	} elseif {$OkOnASauve} {
	    AppendAuFichier $FichierNew $Ligne
	    continue
	}
	if {$OnAPasCommence=="0" && ![regexp -nocase {Moving on:} $Ligne]} {
	    AppendAuFichier $FichierNew $Ligne
	    continue
	}
	if {[regexp -nocase {Moving on:} $Ligne]} {
	    set OnAPasCommence 1
	    set   MaLigne      ""
	    regsub "^Moving on: " $Ligne "" MaLigne
	    scan $MaLigne "%s %s" ND NF
	    
	    #On stocke les precedents
	    if {$LesLignes!=""} {
		set LesLignes [join $LesLignes "\n"]
		AppendAuFichier $FichierNew $LesLignes
		set LesLignes ""
	    }
	    #On voulait laisser tomber un resultat et maintenant on arrete
	    if {   $OnSkip == "1"} {
		set OnSkip 0
		AppendAuFichier $FichierNew $Ligne
		continue
	    }
	    if {$Debut==$ND} {
		if {! [OuiOuNon "The information in the Log File for $Debut $Fin already exists\nDo I also update them ?"]} {
		    close $F    
		    if {[file exists $FichierNew]} {file delete -force $FichierNew}
		    return ""
		}
		set OnSkip     1
		set OkOnASauve 1
		AppendAuFichier $FichierNew $NewLines
		continue
	    }
	    if {$Debut<$ND} { 
		set OkOnASauve 1
		AppendAuFichier $FichierNew $NewLines
		AppendAuFichier $FichierNew $Ligne
		continue
	    }
	    lappend LesLignes $Ligne
	    continue
	}
	if {$OnSkip==0} {lappend LesLignes $Ligne}
    }
    if {$OkOnASauve=="0"} {AppendAuFichier $FichierNew $NewLines}
    close $F

    if {$OnAPasCommence=="0"} {
	file delete -force $FichierNew
    } else {
	file delete -force $Fichier2
	file rename -force $FichierNew $Fichier2 
    }
    return ""

}

proc CompleteLeTableauAvecAccess {{Fichier ""} {FichierAvecAccess ""}} {

    if {$Fichier == ""} {
	set Fichier [ButineArborescence All [pwd]]
    } else {
	if {![file exists $Fichier]} {return ""}
    }

    if {    [regexp "Access" [PremiereLigneDuFichier $Fichier]] &&  [regexp "Banque" [PremiereLigneDuFichier $Fichier]] } {
	return ""
    }
    set NomFichier [file tail $Fichier]
    regsub ".txt" $NomFichier "_modif.txt" NewFileName
    set Rep [file dirname $Fichier]
    set NewFile "$Rep/$NewFileName"

    if {$FichierAvecAccess == ""} {
	if {[OuiOuNon "Do you have a file with Access for the unknown sequence"]} {
	    set FichierAvecAccess [ButineArborescence All [pwd]]
	}
    } else {
	set FichierAvecAccess "/home/chalmel/ProjRetine/Documents/$FichierAvecAccess"
    }

    if {![file exists $Fichier]} {return ""}

    set LEnteteDuTab [split [PremiereLigneDuFichier $Fichier] "\t"]
    set LEnteteDuTab [linsert $LEnteteDuTab 2 "Access"]
    set LEnteteDuTab [linsert $LEnteteDuTab 3 "Banque"]
    
    set NewTable [join $LEnteteDuTab "\t"]

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LaLigne [split $Ligne "\t"]
	if {    ![regexp {^[0-9]} [lindex $LaLigne 0]] } {
	    continue
	} else { 
	    set LesInfosDeLAccess [LAccessEtLaBanque [lindex $LaLigne 1] $FichierAvecAccess]
	    set Position 2
	    foreach Element $LesInfosDeLAccess {
		set LaLigne [linsert $LaLigne $Position $Element]
		incr Position
	    }
	    set NewLine [join $LaLigne "\t"]
	    append NewTable "\n$NewLine"
	}  
    }
    Espionne $NewTable
    if {[OuiOuNon "Voulez-vous enregistrer le tableau modifie dans $NewFileName?"]} {
	Sauve $NewTable dans $NewFile
    }
    return $NewTable

}

proc CompleteLesAccRSEtUG_Ontario {} {


    Wup "Ajoute une les coordonnees sur la puce Block Row Column"
    Wup "Permet de sauver les resultats des recherches dans RefSeq et Unigene des sequence de la puce EST"
    
    set Fichier     "[RepertoireDuGenome]/LesAccDefRefSeqUnigene"
    set FichierSave "[RepertoireDuGenome]/LesAccDefRefSeqUnigene_2"
    
    set Texte "Gscope Access\tCodeClone\tAccRefSeq\tIdGRefSeq\tCoverRefSeq\tDefRefSeq\tAccUnigene\tUGId\tIdGUnigene\tCoverUnigene\tDefUnigene\tBlock\tRow\tColumn"
    AppendAuFichier $FichierSave $Texte
    
    if {[file exists $Fichier]} {
	set F [open "$Fichier"]
	while {[gets $F Ligne]>=0} {
	    if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	    set ListeDesObjets [split $Ligne "\t"]
	    
	    set Access [split [lindex $ListeDesObjets 1] "_"]
	    
	    set OriginalId [lindex $Access 0]
	    set VerifiedId [lindex $Access 1]
	    set Block  [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Block]
	    set Column [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Col]
	    set Row    [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Row]
	    
	    lappend ListeDesObjets $Block
	    lappend ListeDesObjets $Row
	    lappend ListeDesObjets $Column
	    set Texte [join $ListeDesObjets "\t"]
	    AppendAuFichier $FichierSave $Texte
	}
    }
    close $F

    return ""

}

proc CompleteResultatsUSAGE {FichRes FichTG} {

    #FichRes est le fichier resultats de la requete menee dans Usage sur le web
    #entre library sage de foie de Hs et tag_to_gene_Hs
    ###################################
    #FichTG est le fichier tag to gene
    ###en effet dans les resultats on n a pas les noms des genes ni leur unigene
    #mais un lien hypertexte
    if {![file exists $FichRes] || ![file exists $FichTG]} {return}
    foreach Ligne [LesLignesDuFichier $FichRes] {
	set Ligne [string trim $Ligne]
	scan $Ligne "%s %s %s %s" no ab n tag 
	#Espionne "$no $ab $n $tag"
	set Vu($tag) 1
	set Abondance($tag) $ab
    }
    foreach Ligne [LesLignesDuFichier $FichTG] {
	set Ligne [string trim $Ligne]
	#Espionne $Ligne
	set Tag [lindex $Ligne 0]
	set Ug [lindex $Ligne 2]
	set IndexLast [expr [llength $Ligne]-1]
	set DefGene [lrange $Ligne 3 [expr $IndexLast-1]]
	#Espionne "$Tag $Ug $DefGene"
	if {[info exists Vu($Tag)]} {
	    #Espionne $Abondance($tag)
	    lappend LesNouveauxResultats "$Tag\t$Abondance($Tag)\t$Ug\t$DefGene"
	    #EspionneL $LesNouveauxResultats
	}
    }
    #Espionne [llength $LesNouveauxResultats]
    return $LesNouveauxResultats

}

proc CompleteRetourGrilladinGscopeProject {} {

    #rR est lancé en QDS
    RetourGrilladin
    return "OK, RetourGrilladin done"

}

proc CompleteTableauAvecInfosDePresence {{FichierTableauRecapitulatif ""} {RepSeq ""}} {

    if {$FichierTableauRecapitulatif == ""} {
	set FichierTableauRecapitulatif [ButineArborescence All [pwd]]
    } else {
	if {![file exists $FichierTableauRecapitulatif]} {return ""}
    }
    
    if {$RepSeq == ""} {
	set RepSeq [ChoisirUnRepertoire "Choose The Directory containing your sequence"]
    } else {
	if {![file exists $RepSeq]} {return ""}
    }
  
    set Fichier $FichierTableauRecapitulatif

    set RepDocs [file dirname $Fichier]
 
    if {    [regexp "Seq infos" [PremiereLigneDuFichier $Fichier]]} {
	return ""
    }

    set EnteteDuTab [PremiereLigneDuFichier $Fichier]
    set LesEntetesDuTab [split $EnteteDuTab "\t"]
    set NewEnteteDuTab [join [linsert $LesEntetesDuTab 4 "Seq infos"  ] "\t"]

    set NewTable ""
    append NewTable "$NewEnteteDuTab"

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LesInfos [split $Ligne "\t"]

	if {    ![regexp {^[0-9]} [lindex $LesInfos 0]] } {
	    continue
	} else {
	    set CompleteId [lindex $LesInfos 1]

	    if {[regexp "/" $CompleteId]} {regsub "/" $CompleteId "" CompleteId}
	    set Id [lindex $LesInfos 2]

	    set FichierTFA "$RepSeq/$CompleteId.tfa"
	    
	    if {![file exists $FichierTFA]} {
		set InfoSurPresence "No file"
	    } else {
		set InfoSurPresence "OK"
		set EnteteTFA [PremiereLigneDuFichier $FichierTFA]
		if {    [regexp -nocase "found" $EnteteTFA] || [regexp -nocase "withdrawn" $EnteteTFA] ||  [regexp -nocase "not exist" $EnteteTFA]} {
		    set InfoSurPresence "No Sequence found"
		}
		
		if { [regexp -nocase "split" $EnteteTFA]} {
		    set LesNewsId [LesSequencesIssuesDeLaSequenceSplitee $FichierTFA]	    
		    if {    [llength $LesNewsId] == 1 && [lindex  $LesNewsId 0] == $CompleteId} {
			set InfoSurPresence "Probleme"
			Espionne "Probleme avec $CompleteId"
		    } else {
			set InfoSurPresence "Split into [join $LesNewsId " "]"
			set InfoSurPresence [string trim $InfoSurPresence]
		    }
		}
	    }
	}
	set NewLigne [join [linsert $LesInfos 4 $InfoSurPresence] "\t"]
	
	append NewTable "\n$NewLigne"
    }
    Espionne $NewTable
    
    regsub ".txt"  $FichierTableauRecapitulatif "_bis.txt" NewFile 

    Espionne $NewFile
    if {[OuiOuNon "Voulez-vous enregistrer le tableau modifie dans $NewFile?"]} {
	Sauve $NewTable dans $NewFile
    }
    return "$NewTable"

}

proc CompleteTableauAvecNomBOXDansGscope {{NomBox ""} {FichierTableauRecapitulatif ""}} {

    global RepertoireDuGenome

    if {![file exists "$RepertoireDuGenome/beton/miniconfig"]} {
	return ""
    } else {
	set LaMiniconfig [LesLignesDuFichier "$RepertoireDuGenome/beton/miniconfig"]
	foreach Ligne $LaMiniconfig {
	    if {[regexp -nocase "^PrefixeDesORFs " $Ligne]} {
		regsub "^PrefixeDesORFs " $Ligne "" Ligne
		set NomBox [string trim $Ligne]
		break
	    } 
	}
    }
    if {$FichierTableauRecapitulatif == ""} {
	set FichierTableauRecapitulatif [ButineArborescence All [pwd]]
    } else {
	if {![file exists $FichierTableauRecapitulatif]} {return ""}
    }
    set Fichier $FichierTableauRecapitulatif

    set RepDocs [file dirname $FichierTableauRecapitulatif]
    
    set RepNucTFA "$RepertoireDuGenome/nuctfa"

    if {[regexp "Ref Gscope" [PremiereLigneDuFichier $Fichier]]} {return ""}

    set EnteteDuTab [PremiereLigneDuFichier $Fichier]
    set LesEntetesDuTab [split $EnteteDuTab "\t"]
    set NewEnteteDuTab [join [linsert $LesEntetesDuTab 5 "Ref Gscope"  ] "\t"]
    Espionne $NewEnteteDuTab

    set NewTable ""
    append NewTable "$NewEnteteDuTab"

    set n 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LesInfos [split $Ligne "\t"]
	if {    ![regexp {^[0-9]} [lindex $LesInfos 0]] } {
	    continue
	}

	incr n

	set CompleteId [lindex $LesInfos 1]
	set Id [lindex $LesInfos 2]
	set SeqInfos [lindex $LesInfos 4]
	
	set RefGscope [ReferenceDeSeqDansGscope $n $NomBox]
	set FichierTFA "$RepNucTFA/$RefGscope"
	if {![regexp -nocase "$CompleteId" [ContenuDuFichier $FichierTFA]]} {
	    Espionne "$CompleteId Pbl avec $RefGscope 0"
	    return ""
	}
	
	if {![file exists $FichierTFA]} {
	    Espionne "Pbl avec $RefGscope"
	} else {
	    set EnteteTFA [PremiereLigneDuFichier $FichierTFA]
	    set InfoSurRefGscope ""
	    if {[regexp -nocase "does not exist" $EnteteTFA]} {
		set InfoSurRefGscope "$RefGscope"
	    } elseif {![regexp -nocase "split into" $EnteteTFA]} {
		set InfoSurRefGscope "$RefGscope"
	    } else {
		if {[regexp -nocase "Split into" $SeqInfos]} {
		    set InfoSurRefGscope "$RefGscope"
		    
		    regsub "Split into " $SeqInfos "" SeqInfos
		    set LesNewsIds [split $SeqInfos " "]
		    append InfoSurRefGscope " split into"
		    foreach NewId $LesNewsIds {
			incr n
			set RefGscope [ReferenceDeSeqDansGscope $n $NomBox]
			set FichierTFA "$RepNucTFA/$RefGscope"
			if {![file exists $FichierTFA]} {
			    Espionne "$NewId Pbl avec $RefGscope 1"
			    return ""
			} elseif {![regexp -nocase "$NewId" [ContenuDuFichier $FichierTFA]]} {
			    Espionne "$NewId Pbl avec $RefGscope 2"
			    return ""
			}
			append InfoSurRefGscope " $RefGscope"
		    }
		} else {
		    Espionne "$CompleteId Pbl de splittage avec $RefGscope 3"
		}
	    }
	}
	set LesNewInfo [linsert $LesInfos 5 $InfoSurRefGscope]
	set NewInfo [join $LesNewInfo "\t"]
	append NewTable "\n$NewInfo"
    }

    set NameFile [file tail $FichierTableauRecapitulatif]
    regsub ".txt"  $NameFile "_ter.txt" NewFileName 
    set NewFile "$RepDocs/$NewFileName"
    
    if {[OuiOuNon "Voulez-vous enregistrer le tableau modifie dans $NewFile?"]} {
	Sauve $NewTable dans $NewFile
    }
    return $NewTable

}

proc CompleteTaxoblaGscopeProject {{FromOi ""}} {

    #rR est normalement lancé en QDS
    if {$FromOi=="FromOi"} {
	LogWscope "CompleteTaxoblaGscopeProject $FromOi"
	set LesFicTax [TaxoblaFromOi]
	return "[llength $LesFicTax] taxobla files were created"
    }
    TaxonomyDuBlastPourTous
    return "OK, TaxonomyDuBlastPourTous done"

}

proc CompositionAADuGroupe {{grp ""}} {

    global LNDG SDG Sequences ListeDesAcidesAmines 

    set res [list]
    foreach a $ListeDesAcidesAmines {
	set n$a 0
    }
    
    if {$grp eq ""} {
	set grp [lindex $LNDG 0]
    }
    set Ln [set SDG($grp)]

    set sall ""
    foreach s $Ln {
	append sall [set Sequences($s)]
    }

    set nTot 0
    foreach a $ListeDesAcidesAmines {
	set stmp [string map [list $a ""] $sall]
	set n$a [expr {[string length $sall] - [string length $stmp]}]
	set sall $stmp
	incr nTot [set n$a]
    }
    foreach a $ListeDesAcidesAmines {
	lappend res $a [expr {100.0*[set n$a]/$nTot}]
    }
    foreach m {"AILMV" "KRH" "DEQN" "FYW" "PGST"} {
	set La [split $m ""]
	set np 0
	foreach a $La {
	    incr np [set n$a]
	}
	lappend res $m [expr {100.0*$np/$nTot}]
    }

    return $res

}

proc CompositionATGCDuPAB {PAB {Quoi ""}} {


    global MemoGC MemoAT MemoA MemoT MemoG MemoC MemoPAB

    if {$Quoi=="GC" && [info exists MemoGC] && $MemoPAB==$PAB} {
	return $MemoGC
    }
    if {$Quoi=="AT" && [info exists MemoAT] && $MemoPAB==$PAB} {
	return $MemoAT
    }
    if {$Quoi=="A" && [info exists MemoA] && $MemoPAB==$PAB} {
	return $MemoA
    }
    if {$Quoi=="T" && [info exists MemoT] && $MemoPAB==$PAB} {
	return $MemoT
    }
    if {$Quoi=="G" && [info exists MemoG] && $MemoPAB==$PAB} {
	return $MemoG
    }
    if {$Quoi=="C" && [info exists MemoC] && $MemoPAB==$PAB} {
	return $MemoC
    }

    set FichierCompoATGC "[RepertoireDuGenome]/fiches/compositionenatgc"
    if {! [file exists $FichierCompoATGC]} {return "No file $FichierCompoATGC"}

    set F [open "$FichierCompoATGC"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	if {! [regexp -nocase "$PAB" $Ligne]} {continue}
	scan $Ligne "%s %s %s %s %s %s %s" PAB GC AT A T G C
	break
    }
    close $F

    set MemoPAB $PAB
    set MemoGC  $GC
    set MemoAT  $AT
    set MemoA   $A
    set MemoC   $C
    set MemoT   $T
    set MemoG   $G
    switch $Quoi {
	"GC"      {return $GC}
	"AT"      {return $AT}
	"A"       {return $A}
	"T"       {return $T}
	"G"       {return $G}
	"C"       {return $C}
	"default" {return $GC}
    }
    return ""

}

proc CompositionDesSequences {{Rep ""} {Action ""} {Ordre ""} {Sens ""}} {

    if {$Rep==""} { set Rep [ChoixDuRepertoire [RepertoireDuGenome]] }
    if {$Sens==""}  { set Sens "increasing" }
    if {$Ordre==""} { set Ordre 0 }
    if {$Action==""} { set Action "Show" }
    if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    foreach Fichier [lsort [glob -nocomplain $Rep/*]] {
	set Nom [file tail $Fichier]
	set Seq [QueLaSequenceDuFichierTFA $Fichier]
	set Seq [string toupper $Seq]
	set Entete [EnteteDuFichierTFA $Fichier]
	set L [regexp -all "." $Seq]
	set Ligne "$Nom length [format "%4d" $L] :" 
	foreach C [lsort -unique [split $Seq ""]] {
	    set N [regexp -all -nocase -- "$C" $Seq]
	    append Ligne " [format "%4d" $N] $C"
	}
	append Ligne " $Entete" 
	lappend LeTexte $Ligne
	set ListeDesMots [LesMotsDeLaLigne $Ligne]
	lappend LesListesDesMots $ListeDesMots
	set TexteDesMots([join $ListeDesMots "_"]) $Ligne
    }
    set LeBonTexte {}
    foreach LdM [lsort -$Sens -index $Ordre $LesListesDesMots] {
	lappend LeBonTexte $TexteDesMots([join $LdM "_"])
    }
    if {$Action=="GetList"} { return $LeBonTexte }
    if {$Action=="GetText"} { return [join $LeBonTexte "\n"]}
    set F [AfficheVariable [join $LeBonTexte "\n"] "" "CompositionDesSequences_$Rep"]
    set B [BoutonneLaFenetre $F "Composition" ""]
    $B configure -text "Composition ReOrder lines/ New" -background "cyan"
    bind $B <1> "CompositionDesSequences $Rep Show \[Entre $Ordre\] \[ChoixParmi {increasing decreasing}\]"
    bind $B <2> "CompositionDesSequences"
    return $F

}

proc CompositionEn {Type Nom} {

    global RepertoireDuGenome
    global CompositionEnATGC 

    if { ! [info exists CompositionEnATGC]} {
	set FichierCompositionEnATGC "$RepertoireDuGenome/fiches/compositionenatgc"
	if { [file exists $FichierCompositionEnATGC] } {
	    foreach Ligne [LesLignesDuFichier $FichierCompositionEnATGC] {
		scan $Ligne "%s %d %d %d %d %d %d" NomLu pGC pAT pA pT pG pC
		set CompositionEnATGC($NomLu) "$pGC $pAT $pA $pT $pG $pC"
		lappend CompositionEnATGC(GC,LaListe) $pGC
		lappend CompositionEnATGC(AT,LaListe) $pAT
		lappend CompositionEnATGC(A,LaListe)  $pA
		lappend CompositionEnATGC(T,LaListe)  $pT
		lappend CompositionEnATGC(G,LaListe)  $pG
		lappend CompositionEnATGC(C,LaListe)  $pC
	    }
	}
	set CompositionEnATGC(Bidon) "EstCharge"
    }
    if {$Nom=="LaListeMerci"} {
	if {[info exists CompositionEnATGC($Type,LaListe)]} {
	    return [set CompositionEnATGC($Type,LaListe)]
	} else {
	    return {}
	}
    }
    if { ! [info exists CompositionEnATGC($Nom)]} { return "" }
    scan [set CompositionEnATGC($Nom)] "%d %d %d %d %d %d" pGC pAT pA pT pG pC
    if {$Type=="ATGC"} { return [set CompositionEnATGC($Nom)] }
    return [set p$Type]

}

proc Compress {{LesReps ""}} {

    if {$LesReps==""} {
	set LesPossiblesReps {}
	foreach Rep [glob "[RepertoireDuGenome]/*/"] {
	    lappend LesPossiblesReps $Rep
	}
	set LesReps [MorceauxChoisis $LesPossiblesReps]
    }
    foreach Rep $LesReps {
	if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
	foreach Nom [ListeDesPABs] {
	    set Fichier "$Rep/$Nom"
	    if {[FileAbsent $Fichier]} { continue }
	    Espionne "I'll compress $Fichier" 
	    exec compress $Fichier
	}
    }

}

proc CompressMacsims {} {

    set SourceDir "[RepertoireDuGenome]/macsims"
    foreach File [glob -nocomplain "$SourceDir/*.xml"] {
	#if {[regexp "org" $File]} {continue}
	exec gzip -9 $File
    }
    return 

}

proc ComptabiliseFichiersEnFonctionDeLeurTaille {SizeMin SizeMax} {

    set Rep [ChoisirUnRepertoire "Choisir Le Repertoire de destination"]

    set n 0
    foreach Fichier [glob -nocomplain *] {
	set Size [file size "$Rep/$Fichier"]
	if {$Size < $SizeMax && $Size > $SizeMin } {
	    Espionne $Fichier
	    incr n
	}
    }
    return "$n"

}

proc ComptageMotifsExons {FichierACompter} {

    set Fichier $FichierACompter
    set NbGenes  [exec cut -d , -f  4 $FichierACompter | sort -u | wc -l]
    set NbExons  [exec cut -d , -f 13 $FichierACompter | sort -u | wc -l]
    set NbMotifs [exec cut -d , -f 16 $FichierACompter | sort -u | wc -l]
    return "$NbGenes $NbExons $NbMotifs $FichierACompter"

}

proc CompteAcA {} {

    set D 0; set E 0; set M 0; set H 0; set A 0
    foreach I [RetChip5 ListOf Index] {
	set AC [RetChip5 $I "DNA_acc"]
	if { $AC!="" } {
	    if { [regexp {\?} $AC] } { continue }
	    incr D
	    puts "1 $AC"
	    regsub " " $AC "" AC 
	    puts "2 $AC"
	    Espionne "la ligne $I a un numero access:$AC dans DNA_acc=>$D"
	    set ListAc [split $AC ","]
	    foreach Ac $ListAc {
		puts "3 $Ac"
		incr E
		if { [regexp {^NM_} $Ac] || [regexp {^XM_} $Ac] || [regexp {^NR_} $Ac]} {
		    set Commande1 "getz \"\\\[refseq-acc:$Ac\\\]\" \-vf org"
		    set GetzOut1 [eval exec $Commande1]
		    if {$GetzOut1 == ""} {puts "attention pas fichesNM"; continue}
		    set RefLu1 ""; set GenreLu1 ""; set EspeceLu1 ""
		    scan $GetzOut1 "%s %s %s" RefLu1 GenreLu1 EspeceLu1
		    puts "$Ac=>organisme=$GenreLu1 $EspeceLu1"
		    if {[regexp {^Mus$} $GenreLu1]} {incr M} 
		    if {[regexp {^Homo$} $GenreLu1]} {incr H}
		    if {![regexp {^Mus$} $GenreLu1] && ![regexp {^Homo$} $GenreLu1]} {incr A}
		} else {
		    set Commande2 "getz \"\\\[genbankfull-acc:$Ac\\\]\" \-vf org"
		    set GetzOut2 [eval exec $Commande2]
		    if {$GetzOut2 == ""} {puts "attention pas fichesGB"; continue}
		    set RefLu2 ""; set GenreLu2 ""; set EspeceLu2 ""
		    scan $GetzOut2 "%s %s %s" RefLu2 GenreLu2 EspeceLu2
		    puts "$Ac=>organisme=$GenreLu2 $EspeceLu2"
		    if {[regexp {^Mus$} $GenreLu2]} {incr M} 
		    if {[regexp {^Homo$} $GenreLu2]} {incr H} 
		    if {![regexp {^Mus$} $GenreLu2] && ![regexp {^Homo$} $GenreLu2]} {incr A}
		} 
	    }
	}
    }
    Espionne "il y a $D ligne qui ont un access dans DNA_acc"
    Espionne "il y a $E access dans DNA_acc"
    Espionne "il y a $M access ds DNA_acc de souris"
    Espionne "il y a $H access ds DNA_acc d'homme"
    Espionne "il y a $A access ds DNA_acc d'autre chose"

}

proc CompteAcA_AEffacer {} {

    set D 0
    set M 0
    set H 0
    foreach I [RetChip2 ListOf Index] {
	set Ac [RetChip2 $I "DNA_acc"]
	if { $Ac!="" } {
	    incr D
	    Espionne "la ligne $I a un numero access:$Ac dans DNA_acc=>$D"
	    if { [string equal "?" $Ac] } { continue }
	    if { [regexp {^NM_} $Ac] } {
		set Commande1 "getz \"\\\[refseq-acc:$Ac\\\]\" \-vf org"
		set GetzOut1 [eval exec $Commande1]
		if {$GetzOut1 == ""} {puts "attention pas fichesNM"; continue}
		set RefLu1 ""
		set GenreLu1 ""
		set EspeceLu1 ""
		scan $GetzOut1 "%s %s %s" RefLu1 GenreLu1 EspeceLu1
		puts "NM=>organisme=$GenreLu1 $EspeceLu1"
		if {[regexp {^Mus$} $GenreLu1]} {incr M} 
		if {[regexp {^Homo$} $GenreLu1]} {incr H}
		if {![regexp {^Mus$} $GenreLu1] || ![regexp {^Homo$} $GenreLu1]} {incr A}
	    } else {
		set Commande2 "getz \"\\\[genbankfull-acc:$Ac\\\]\" \-vf org"
		set GetzOut2 [eval exec $Commande2]
		if {$GetzOut2 == ""} {puts "attention pas fichesGB"; continue}
		set RefLu2 ""
		set GenreLu2 ""
		set EspeceLu2 ""
		scan $GetzOut2 "%s %s %s" RefLu2 GenreLu2 EspeceLu2
		puts "GB=>organisme=$GenreLu2 $EspeceLu2"
		if {[regexp {^Mus$} $GenreLu2]} {incr M} 
		if {[regexp {^Homo$} $GenreLu2]} {incr H} 
		if {![regexp {^Mus$} $GenreLu1] || ![regexp {^Homo$} $GenreLu1]} {incr A}
	    } 
	}
    }
    Espionne "il y a $D lignes qui ont un access dans DNA_acc"
    Espionne "il y a $M lignes de souris"
    Espionne "il y a $H lignes d'homme"

}

proc CompteAcAbis {} {

    set D 0; set M 0; set H 0
    foreach I [RetChip5 ListOf Index] {
	set Des [RetChip5 $I "description_customer"]
	set AC [RetChip5 $I "DNA_acc"]
	if { $AC!="" } {
	    if { [regexp {\?} $AC] } { continue }
	    incr D
	    Espionne "la ligne $I a un numero access:$AC dans DNA_acc=>$D"
	    set ListAc [split $AC ","]
	    foreach Ac $ListAc {
		if { [regexp {^NM_} $Ac] || [regexp {^XM_} $Ac] || [regexp {^NR_} $Ac]} {
		    set Commande1 "getz \"\\\[refseq-acc:$Ac\\\]\" \-vf mol"
		    set GetzOut1 [eval exec $Commande1]
		    if {$GetzOut1 == ""} {puts "attention pas fichesNM"; continue}
		    set RefLu1 ""
		    set MolLu1 ""
		    scan $GetzOut1 "%s %s" RefLu1 MolLu1
		    puts "$Ac=>molecule=$MolLu1"
		    if {[regexp {^mRNA$} $MolLu1]} {incr M} 
		    if {[regexp {^DNA$} $MolLu1]} {incr H} 
		} else {
		    set Commande2 "getz \"\\\[genbankfull-acc:$Ac\\\]\" \-vf mol"
		    set GetzOut2 [eval exec $Commande2]
		    if {$GetzOut2 == ""} {puts "attention pas fichesGB"; continue}
		    set RefLu2 ""
		    set MolLu2 ""
		    scan $GetzOut2 "%s %s" RefLu2 MolLu2
		    if {[regexp {^mRNA$} $MolLu2]} {incr M} 
		    if {[regexp {^DNA$} $MolLu2]} {incr H} 
		    puts "$Ac=>molecule=$MolLu2"
		} 
	    }
	}
    }
    Espionne "il y a $D lignes qui ont un access dans DNA_acc"
    Espionne "il y a $M lignes mRNA"
    Espionne "il y a $H lignes DNA"

}

proc CompteAcAbis_AEffacer {} {

    set D 0
    set M 0
    set H 0
    foreach I [RetChip2 ListOf Index] {
	set Des [RetChip2 $I "description_customer"]
	set Ac [RetChip2 $I "DNA_acc"]

	if { [regexp {^RA[0-9]+} $Des] } { continue }
	if { [regexp {\?} $Ac] } { continue }

	if { $Ac!="" } {
	    incr D
	    Espionne "la ligne $I a un numero access:$Ac dans DNA_acc=>$D"
	    if { [string equal "?" $Ac] } { continue }
	    if { [regexp {^NM_} $Ac] } {
		set Commande1 "getz \"\\\[refseq-acc:$Ac\\\]\" \-vf mol"
		set GetzOut1 [eval exec $Commande1]
		if {$GetzOut1 == ""} {puts "attention pas fichesNM"; continue}
		set RefLu1 ""
		set MolLu1 ""
		scan $GetzOut1 "%s %s" RefLu1 MolLu1
		puts "NM=>molecule=$MolLu1"
		if {[regexp {^mRNA$} $MolLu1]} {incr M} 
		if {[regexp {^DNA$} $MolLu1]} {incr H} 
	    } else {
		set Commande2 "getz \"\\\[genbankfull-acc:$Ac\\\]\" \-vf mol"
		set GetzOut2 [eval exec $Commande2]
		if {$GetzOut2 == ""} {puts "attention pas fichesGB"; continue}
		set RefLu2 ""
		set MolLu2 ""
		scan $GetzOut2 "%s %s" RefLu2 MolLu2
		if {[regexp {^mRNA$} $MolLu2]} {incr M} 
		if {[regexp {^DNA$} $MolLu2]} {incr H} 
		puts "GB=>molecule=$MolLu2"
	    } 
	}
    }
    Espionne "il y a $D lignes qui ont un access dans DNA_acc"
    Espionne "il y a $M lignes mRNA"
    Espionne "il y a $H lignes DNA"

}

proc CompteAcNm {} {

    set E 0; set F 0; set M 0; set D 0
    foreach I [RetChip5 ListOf Index] {
	set Des [RetChip5 $I "description_customer"]
	set NM [RetChip5 $I "refseq_PIQOR"]
	set AC [RetChip5 $I "DNA_acc"]
	if {[regexp {\?} $AC]} {continue}
	if {$AC!=""} { incr D }
	if {$NM!="" && $AC!=""} {
	    incr E
	    Espionne "la ligne $I a 2 numeros access dans DNA_acc:$AC et refseq:$NM=>$E"
	}
	if { $NM!="" && $AC!="" && [regexp {.\,.} $NM] } {
	    set LesNMs [split $NM ","]
	    foreach LeNM $LesNMs { 
		if { $LeNM==$AC } { 
		    incr F 
		    Espionne "pls1=la ligne $I a le meme numero dans DNA_acc et refseq=>$F"  
		}
	    }
	    continue
	}
	if { $NM!="" && $AC!="" && [regexp {.\,.} $AC] } {
	    set LesACs [split $AC ","]
	    foreach LeAC $LesACs { 
		if { $LeAC==$NM } { 
		    incr F 
		    Espionne "pls2=la ligne $I a le meme numero dans DNA_acc $AC et refseq $NM=>$F"  
		}
	    }
	    continue
	}
	if {$NM!="" && $AC!="" && $NM==$AC} {
	    incr F
	    Espionne "uni=la ligne $I a le meme numero dans DNA_acc et refseq=>$F"
	}
    }
    Espionne "il y a $D lignes ac un access ds DNA_acc"
    Espionne "il y a $E lignes qui ont 2 access dans DNA_acc et refseq"
    Espionne "il y a $F lignes qui ont 2 access identiques dans DNA_acc et refseq"

}

proc CompteAcNm_AEffacer {} {

#ss RA ss ?
    set E 0
    set F 0
    set M 0
    set D 0
    foreach I [RetChip2 ListOf Index] {
	set Des [RetChip2 $I "description_customer"]
	set NM [RetChip2 $I "refseq_PIQOR"]
	set AC [RetChip2 $I "DNA_acc"]
	if { [regexp {^RA[0-9]+} $Des] } { continue }
	if { [regexp {\?} $AC] } { continue }

	if {$AC!=""} { incr D }
	if {$NM!="" && $AC!=""} {
	    incr E
	    Espionne "la ligne $I a 2 numeros access dans DNA_acc:$AC et refseq:$NM=>$E"
	}
	if { $NM!="" && $AC!="" && [regexp {.\,.} $NM] } {
	    set LesNMs [split $NM ","]
	    foreach LeNM $LesNMs { 
		if { $LeNM==$AC } { 
		    incr F 
		    Espionne "pls=la ligne $I a le meme numero dans DNA_acc et refseq=>$F"  
		}
	    }
	    continue
	}
	if {$NM!="" && $AC!="" && $NM==$AC} {
	    incr F
	    Espionne "uni=la ligne $I a le meme numero dans DNA_acc et refseq=>$F"
	}
    }
    Espionne "il y a $D lignes ac un access ds DNA_acc"
    Espionne "il y a $E lignes qui ont 2 access dans DNA_acc et refseq"
    Espionne "il y a $F lignes qui ont 2 access identiques dans DNA_acc et refseq"

}

proc CompteBootArbre {t n} {

    set ::TBoot {}
    CreeBootstrapTable $t
    CompareArbres

    return

}

proc CompteBootArbre2 {t n} {

    global TBoot

    if {[$t isleaf $n]} {return}
    foreach fils [$t children $n] {
	CompteBootArbre $t $fils
    }

    set L1 {}
    foreach e [$t children $n] {
	if {[$t isleaf $e]} {
	    set Le $e
	} else {
	    set Le [$t descendants $e filter FilterLeaf]
	}
	set Le [lsort $Le]
	lappend L1 [join $Le ","]
    }
    set k1 [join $L1 "@"]
    set k2 [join [lreverse $L1] "@"]
    incr TBoot($k1)
    incr TBoot($k2)

    return

}

proc CompteCons {} {

    set mdb "rootmis"
    sqlite3 $mdb [file join [MiSynPatDir] misynpat.sql]
    set sys [string index [file tail [set ::Defauts(FichierXML)]] 0]
    puts "\nSystem $sys"

    set sname [string toupper "${sys}ars%"]
    set Lmut [$mdb eval {select m.variant1, m.variant2 from mutation as m, synthetase as s where s.sname like $sname and s.pk_synthetase=m.pk_synthetase}]
    puts "Lmut $Lmut"
    if {[llength $Lmut] == 0} {
	puts "\nSystem Done"
	$mdb close
	FermeFichier
	exit
    }
    
    if {$sys eq "F"} {set sys "Fb"}
    set humi "${sys}mito_Homo.sapi"
    set Lcons {}
    set ncon 0
    set feat "Discri"
    if {[info exists ::TabSF($humi,$feat)]} {
	set Lft $::TabSF($humi,$feat)
    } else {
	puts "\nNo $feat for $humi !\n"
	set Lft [list]
    }
    
    foreach ft $Lft {
	DecortiqueUneFeature $ft deb fin col ssc note sys
	for {set i $deb} {$i <= $fin} {incr i} {
	    set no [DonnePosGS $humi $i]
	    lappend Lcons $no $note
	}
    }

    foreach k {"IdenGlob" "ConsGlob" "SimiGlob" "nocons"} {
	set Tc($k) [list]
    }

    foreach mut $Lmut {
	if {[regexp {[A-Y]} [string index $mut 0]]} {
	    set no [string range $mut 1 end-1]
	    lappend Lrmut $no
	}
    }
    set Lrmut [lsort -unique -integer $Lrmut]
    puts "\nNumber of missense mutations : [llength $Lrmut]"

    foreach no $Lrmut {
	set ires [lsearch -exact $Lcons $no]
	if {$ires > -1} {
	    set type [lindex $Lcons $ires+1]
	    lappend Tc($type) $no
	    incr ncon
	} else {
	    lappend Tc(nocons) $no
	}
    }
    puts ""
    set nmc 0
    foreach k {"IdenGlob" "ConsGlob" "SimiGlob"} {
	incr nmc [llength $Tc($k)]
    }
    puts "Number of mutations conserved : $nmc"
    puts "Number of non-conserved mut   : [llength $Tc(nocons)]"
    foreach k {"IdenGlob" "ConsGlob" "SimiGlob" "nocons"} {
	puts "   $k : [llength [set Tc($k)]]"
	puts "[set Tc($k)]"
    }
    puts "\nSystem Done"

    $mdb close
    FermeFichier

    exit

}

proc CompteConsDiscri {} {

    set mdb "rootmis"
    sqlite3 $mdb [file join [MiSynPatDir] misynpat.sql]
    set sys [string index [file tail [set ::Defauts(FichierXML)]] 0]
    puts "\nSystem $sys"

    set sname [string toupper "${sys}ars%"]
    set Lmut [$mdb eval {select m.variant1, m.variant2 from mutation as m, synthetase as s where s.sname like $sname and s.pk_synthetase=m.pk_synthetase}]
    puts "Lmut $Lmut"
    if {[llength $Lmut] == 0} {
	puts "\nSystem Done"
	$mdb close
	FermeFichier
	exit
    }
    
    if {$sys eq "F"} {set sys "Fb"}
    set humi "${sys}mito_Homo.sapi"
    set Lcons {}
    set ncon 0

    set Lfeat [list "Cons-T80" "Discri"]
    set Lft [list]
    foreach feat $Lfeat {
	if {[info exists ::TabSF($humi,$feat)]} {
	    lappend Lft {*}$::TabSF($humi,$feat)
	} else {
	    puts "\nNo $feat for $humi !\n"
	}
    }
    
    foreach ft $Lft {
	DecortiqueUneFeature $ft deb fin col ssc note sys
	if {$note ni {"IdenGlob" "ConsGlob"}} {
	    set note "Discri"
	}
	for {set i $deb} {$i <= $fin} {incr i} {
	    set no [DonnePosGS $humi $i]
	    lappend Lcons $no $note
	}
    }
    
    set Lcat {"IdenGlob" "ConsGlob" "Discri"}
    foreach k $Lcat {
	set Tc($k) [list]
    }
    set Tc(nocons) [list]

    foreach mut $Lmut {
	if {[regexp {[A-Y]} [string index $mut 0]]} {
	    set no [string range $mut 1 end-1]
	    lappend Lrmut $no
	}
    }
    set Lrmut [lsort -unique -integer $Lrmut]
    puts "\nNumber of missense mutations : [llength $Lrmut]"
    
    foreach no $Lrmut {
	set ires [lsearch -exact $Lcons $no]
	if {$ires > -1} {
	    set type [lindex $Lcons $ires+1]
	    lappend Tc($type) $no
	    incr ncon
	} else {
	    lappend Tc(nocons) $no
	}
    }
    puts ""
    set nmc 0
    foreach k $Lcat {
	incr nmc [llength $Tc($k)]
    }
    puts "Number of mutations conserved : $nmc"
    puts "Number of non-conserved mut   : [llength $Tc(nocons)]"
    lappend Lcat "nocons"
    foreach k $Lcat {
	puts "   $k : [llength [set Tc($k)]]"
	puts "[set Tc($k)]"
    }
    puts "\nSystem Done"

    $mdb close
    FermeFichier

    exit

}

proc CompteCytoBand {{Liste ""}} {

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }

    set Total 0; set Ra 0; set pasaccess 0; set SsLoc 0; set AcLoc 0; set Cas2 0; set Cas3 0; set Cas4 0; set Cas5 0;set Cas6 0
    foreach Nom $Liste {
	incr Total
	set yena2 0
	set LocUcsc ""; set CytoBand1 ""; set CytoBand2 ""; set CytoBand "" 
	set LocUcsc  [ExtraitInfo $Nom "LocUcsc:"]
	set Attention [ExtraitInfo $Nom "SeqWarning:"]

	if {[regexp "raligne" $Attention]} {
	    incr Ra
	   Espionne "cas0 $Nom=> CytoBand: novalue"
	    continue
	}
	if {[regexp "pas d access" $Attention]} {
	    incr pasaccess
	   Espionne "cas0bis $Nom=> CytoBand: novalue"
	    continue
	}

	if {$LocUcsc=="" || $LocUcsc=="no value"} {
	    incr SsLoc
	   Espionne "cas1 $Nom=> CytoBand: no value"
	}
	
	if {$LocUcsc!="" && $LocUcsc!="no value"} {
	    incr AcLoc
	    set LesMotsLocUcsc [split $LocUcsc {:- }]
	    set chrLocUcsc [lindex $LesMotsLocUcsc 0]
	    set startLocUcsc [lindex $LesMotsLocUcsc 1]
	    set stopLocUcsc [lindex $LesMotsLocUcsc 2]
	
	    set CytoBand1 [CytoBandUcsc Mouse $chrLocUcsc $startLocUcsc]
	    set CytoBand2 [CytoBandUcsc Mouse $chrLocUcsc $stopLocUcsc]

	    if {$CytoBand1=="" && $CytoBand2==""} {
		incr Cas2
		Espionne "cas2 $Nom=> CytoBand: no value"
	    }
	    if {$CytoBand1!="" && $CytoBand2!="" && $CytoBand1 == $CytoBand2} {
		incr Cas3
		set yena2 1
		set CytoBand $CytoBand1
		Espionne "cas3 $Nom=> CytoBand: $CytoBand"
	    } 
	    if {$CytoBand1!="" && $CytoBand2!="" && $CytoBand1 != $CytoBand2} {
		incr Cas4
		set yena2 1
		set CytoBand "$CytoBand1 Et $CytoBand2"
		Espionne "cas4 $Nom=> CytoBand: $CytoBand"
	    } 
	    if {!$yena2 && $CytoBand1!=""} {
		incr Cas5
		set CytoBand $CytoBand1
		Espionne "cas5 $Nom=> CytoBand: $CytoBand"
	    }
	    if {!$yena2 && $CytoBand2!=""} {
		incr Cas6
		set CytoBand $CytoBand2
		Espionne "cas6 $Nom=> CytoBand: $CytoBand"
	    }
	}
    }
   Espionne "total= $Total"
   Espionne "cas0=  $Ra"
   Espionne "cas0bis= $pasaccess"
   Espionne "ssloc= $SsLoc"
   Espionne "acloc= $AcLoc"
   Espionne "cas2=  $Cas2"
   Espionne "cas3=  $Cas3"
   Espionne "cas4=  $Cas4"
   Espionne "cas5=  $Cas5"
   Espionne "cas6=  $Cas6"

}

proc CompteDans {ListeDesNoms args} {

    foreach A $args { set CompteDe($A) 0 }
    foreach Nom $ListeDesNoms {
	set Acc [AccessEvi $Nom]
	if {[info exist DejaVu($Acc)]} {continue}
	set DejaVu($Acc) 1
	foreach A $args {
	    if {[regexp "$A" $Acc]} {incr CompteDe($A)}
	}
    }
    set LesComptes {}
    foreach A $args {
	lappend LesComptes $CompteDe($A)
    }
    return $LesComptes 

}

proc CompteDesOrganismesAyantMemeOperon {Nom} {

    global LesOrganismesAyantMemeOperon

    if { ! [info exists LesOrganismesAyantMemeOperon] } {
	ChargeLesOrganismesAyantMemeOperon
    }
    if { ! [info exists LesOrganismesAyantMemeOperon(LaListeMerci,Compte)] } {
	foreach {Clef Valeur} [array get LesOrganismesAyantMemeOperon] {
	    if { ! [regexp ",Compte$" $Clef]} { continue }
	    lappend LesComptes $Valeur
	}
	set LesOrganismesAyantMemeOperon(LaListeMerci,Compte) $LesComptes
    }
    
    if { [info exists LesOrganismesAyantMemeOperon($Nom,Compte)] } {
	return [set LesOrganismesAyantMemeOperon($Nom,Compte)] 
    } else {
	return 0
    }

}

proc CompteEC {} {

    set FichierSortie "[RepertoireDuGenome]/fiches/statEC"
    foreach Nom [ListeDesPABs] {
	set FichierNb "[RepertoireDuGenome]/fichesannotation/$Nom.nb"
	
	foreach Ligne [LesLignesDuFichier $FichierEC] {
	    scan $Ligne "%s" A
	}
	foreach Ligne1 [LesLignesDuFichier $FichierNb] {
	    scan $Ligne1 "%s" C
	}
	AppendAuFichier $FichierSortie "$Nom $A $C"
    }

}

proc CompteEmblRecupere {} {

    set A 0
    set Repertoire "[RepertoireDuGenome]/protemblRecupere"
    foreach F [glob -nocomplain "$Repertoire/EVI*"] {
	incr A
    }
   Espionne "A $A"

}

proc CompteEtListeLesProtUniquesParOrganismeNotHuman {FichierDDnothuman FichierOrgaNotHuman} {

    #FichierDDnothuman=fiches/LesDDAvecProtChoisieNotHuman
    #FichierOrgaNotHuman=fiches/LesOrgasNotHumanDesProtChoisies
    foreach Lorga [LesLignesDuFichier $FichierOrgaNotHuman] {
	#Espionne $Lorga
	set n 0
	set LesNoms ""
	foreach Ligne [LesLignesDuFichier $FichierDDnothuman] {
	    if {$Ligne==""} {continue}
	    set LesDD [split $Ligne " "]
	    set DDprem [lindex $LesDD 0]
	    set Orga [InterrogeProtAndmRNAChoisis $DDprem OrganismeChoisi]
	    if {$Orga==$Lorga} {incr n; lappend LesNoms $DDprem}
	}
	lappend Liste "$Lorga\t$n\t$LesNoms"
    }
    set ListeTriee [lsort -index 2 -integer -decreasing $Liste]
    return $ListeTriee

}

proc CompteExonGb {} {

    set total 0; set Total2 0; set cool 0; set pascool 0
    set lesAccs [LocUcsc ListOfMouse Access] 
    set lesAccs [ListeSansDoublon $lesAccs]
    foreach Acc $lesAccs {
	set ListeNombreExon {}
	incr total
	set ListeNombreExon [LocUcsc $Acc exonCounts]
	set ListeNombreExon [ListeSansDoublon $ListeNombreExon]
	set longueur [llength $ListeNombreExon]
	if {$longueur==1} {
	    incr cool
	    set NbExon [lindex $ListeNombreExon 0]
	    if { $NbExon == 2 } {Espionne "$Acc $NbExon" }
	    if { ! [info exists Compte($NbExon)]} { set Compte($NbExon) 0 }
	    incr Compte($NbExon)
	}
	if {$longueur>1} {
	    incr pascool
	    foreach NombreExon $ListeNombreExon {
		if { ! [info exists Compte($NombreExon)]} { set Compte($NombreExon) 0 }
		incr Compte($NombreExon)
	    }
	}
    }
    foreach Nb [lsort -integer [array names Compte]] {
	Espionne "$Nb exons = $Compte($Nb)"
	set X $Compte($Nb)
	if { ! [info exists Total2]} {
	    set Total2 $X
	} else {
	    set Total2 [expr $Total2+$X]
	}	
    }
   Espionne "total= $total"
   Espionne "ok= $cool"
   Espionne "attention= $pascool"
   Espionne "Total2= $Total2"

}

proc CompteExonRs {} {

    set total 0; set Total2 0; set cool 0; set pascool 0
    set lesAccs [LocUcscRefSeq ListOf Access] 
    set lesAccs [ListeSansDoublon $lesAccs]
    foreach Acc $lesAccs {
	set ListeNombreExon {}
	incr total
	set ListeNombreExon [LocUcscRefSeq $Acc exonCounts]
	set ListeNombreExon [ListeSansDoublon $ListeNombreExon]
	set longueur [llength $ListeNombreExon]
	if {$longueur==1} {
	    incr cool
	    set NbExon [lindex $ListeNombreExon 0]
	    if { ! [info exists Compte($NbExon)]} { set Compte($NbExon) 0 }
	    incr Compte($NbExon)
	}
	if {$longueur>1} {
	    incr pascool
	    foreach NombreExon $ListeNombreExon {
		if { ! [info exists Compte($NombreExon)]} { set Compte($NombreExon) 0 }
		incr Compte($NombreExon)
	    }
	}
    }
    foreach Nb [lsort -integer [array names Compte]] {
	Espionne "$Nb exons = $Compte($Nb)"
	set X $Compte($Nb)
	if { ! [info exists Total2]} {
	    set Total2 $X
	} else {
	    set Total2 [expr $Total2+$X]
	}	
    }
   Espionne "total= $total"
   Espionne "ok= $cool"
   Espionne "attention= $pascool"
   Espionne "Total2= $Total2"

}

proc CompteFeuilles {{t ""} {n ""} {a ""}} {

    global CompteFeuilles
    if {$t eq ""} { set CompteFeuilles 0 ; return }
    if {$t eq "get"} {return $CompteFeuilles}

    incr CompteFeuilles [$t isleaf $n]
    return $CompteFeuilles

}

proc CompteGenoret {} {

    set Total 0
    foreach Fichier [GlobRecursif "*.php" /home/berthomg/wwwGB/genoret] {
	set N 0
	scan [exec wc -l $Fichier] "%d" N
	incr Total $N
    }
    Espionne $Total
    exit

}

proc CompteHomologeneId {} {

    set total 0; set vide 0; set novalue 0; set oui 0
    foreach Nom [ListeDesPABs] {
	incr total
	#Espionne $Nom
	set Info ""
	set Info [ExtraitInfo $Nom "HomologeneId"]
	if {$Info==""} {incr vide;Espionne "vide"}
	if {[regexp "no value" $Info]} {incr novalue;Espionne "pasvaleur"}
	if {[regexp {[0-9]+} $Info]} {incr oui;Espionne "avaleur"}
    }
   Espionne "total $total"
   Espionne "vide $vide"
   Espionne "novalue $novalue"
   Espionne "oui $oui"

}

proc CompteLeNbDeGenesDansLaBanqueCGH {FichierTfas} {

    #FichierTfas = genomics/g2/Procure/banques/ProtCGH06
    foreach Ligne [LesLignesDuFichier $FichierTfas] {
	if {[regexp -nocase "^>" $Ligne]} {
	    set LesElts [split $Ligne "\|"]
	    set AccessProt [lindex $LesElts 1]
	    Espionne $AccessProt
	    if {[regexp "NP" $AccessProt]} {
		if {![info exists Vu($AccessProt)]} {set Vu($AccessProt) 1; lappend LesGenes $AccessProt}
	    } else {
		set Commande "getz \"\\\[protein-acc:$AccessProt\\\]\\\>\\\[refseqprelease-org:Homo sapiens\\\]\" \-vf acc"
		set GetzOut [eval exec $Commande]
		set LesElts [split $GetzOut " "]
		foreach Elt $LesElts {
		    if {[regexp "\:" $Elt]} {continue}
		    if {![info exists Vu($AccessProt)]} {
			set Vu($AccessProt) 1
			lappend LesGenes $AccessProt
		    }
		}
	    }
	}
    }
    Espionne [llength $LesGenes]
    set L [lsort -unique $LesGenes]
    Espionne [llength $L]
    SauveLesLignes $L dans "[RepertoireDuGenome]/banques/LesGenesDeProtCGH06_28Nov06"

}

proc CompteLeNombreDeNomsDifferents {Fichier} {

    set Nom bob
    set n 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" nom
	if {$nom!=$Nom} {incr n}
	set Nom $nom
    }
    return $n

}

proc CompteLesElmtsDuRecapTfa {} {

    set MGU74 0; set MG430 0
    set FichierTfaPourClusteringMGU74 "[RepertoireDuGenome]/transcriptomique/RecapTfaPourClusteringMGU74.tfa"
    set FichierTfaPourClusteringMG430 "[RepertoireDuGenome]/transcriptomique/RecapTfaPourClusteringMG430.tfa"
    foreach LigneMGU74 [LesLignesDuFichier $FichierTfaPourClusteringMGU74] {
	if {[regexp {^>} $LigneMGU74]} {
	    incr MGU74
	}
    }
    foreach LigneMG430 [LesLignesDuFichier $FichierTfaPourClusteringMG430] {
	if {[regexp {^>} $LigneMG430]} {
	    incr MG430
	}
    }
    puts "MGU74 $MGU74"
    puts "MG430 $MG430"

}

proc CompteLesErreurs {{Liste ""}} {

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    set existepas 0; set bidon 0; set plusdun 0; set plusdix 0
    set LesNomsQuiExistePas {}; set LesBidons {}; set LesPls {}; set LesPlusDix {}

    #meme chose
    #set LesLignes [NomLigne ListeDes Lignes]
    #foreach Ligne $LesLignes 
	#set TousLesNoms  [NomLigne $Ligne Noms]
	#set ListeDesNoms [split $TousLesNoms " "]
	#foreach Nom $ListeDesNoms 


    foreach Nom $Liste {
	set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	if {![file exists $Fichier]} {
	    incr existepas
	    lappend LesNomsQuiExistePas $Nom
	    continue
	}
	set LesLignes [LesLignesDuFichier $Fichier]
	set premiereligne [lindex $LesLignes 0]
	if {[regexp "bidon" $premiereligne]} {
	    incr bidon
	    lappend LesBidons $Nom
	    continue
	}
	set elmts [split $Nom ""]
	set chiffre [lindex $elmts 7]
	set NomSansFin [string range $Nom 0 end-1]
	if {$chiffre!=0} {
	    lappend LesPls $NomSansFin
	}
	if {$chiffre==9} {
	    lappend LesPlusDix $NomSansFin
	}
    }
    set LesPls     [ListeSansDoublon $LesPls]
    set LesPlusDix [ListeSansDoublon $LesPlusDix]
    set longLesPls     [llength $LesPls]
    set longLesPlusDix [llength $LesPlusDix]
    Espionne "LesNomsQuiExistePas $existepas"
    Espionne "$LesNomsQuiExistePas"
    Espionne "LesBidons $bidon"
    Espionne "$LesBidons"
    Espionne "LesPls $longLesPls"
    Espionne "$LesPls"
    Sauve $LesPls dans "[RepertoireDuGenome]/LesPlsDeCompteLesErreurs"
    Espionne "LesPlusDix $longLesPlusDix"
    Espionne "$LesPlusDix"

}

proc CompteLesGaps {Sequence} {

    set N 0
    foreach Lettre [split $Sequence ""] {
	if {[string equal -nocase $Lettre "-"]} { incr N }
    }
    return $N

}

proc CompteLesJRAvecARNmValide {FichierClusters} {

    set RepARNmValide "[RepertoireDuGenome]/mrnahuman"
    set n 0
    foreach JR [ListeMinimumDesJR $FichierClusters] {
	if {[file exists "$RepARNmValide/$JR"]} {
	    incr n
	}
    }
    return $n

}

proc CompteLesJRnonLocalises {FichierClusters} {

    set n 0
    foreach JR [ListeMinimumDesJR $FichierClusters] {
	if {[PolyLocalise $JR]=="NoLocalization"} {
	    incr n
	}
    }
    return $n

}

proc CompteLesLettres {SeqOUFic Input} {

    if {$SeqOUFic=="Fic"} {
	#set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom"
	#set FichierNuctfa "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom"; 
	if {[FileAbsent $Input]} { return -1 }
	set Seq [QueLaSequenceDuFichierTFA $Input]
    }
    if {$SeqOUFic=="Seq"} { set Seq $Input }
    set N 0
    foreach C [split $Seq ""] {
	if {[string equal -nocase $C "A"]} { incr N }
	if {[string equal -nocase $C "T"]} { incr N }
	if {[string equal -nocase $C "G"]} { incr N }
	if {[string equal -nocase $C "C"]} { incr N }
    }
    return $N

}

proc CompteLesLettres_AEffacer {Nom} {

    #set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom"
    set FichierNuctfa "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom"; 
    if {[FileAbsent $FichierNuctfa]} { return -1 }
  
    set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa]

    set N 0
    foreach C [split $Seq ""] {
	if {[string equal -nocase $C "A"]} { incr N }
	if {[string equal -nocase $C "T"]} { incr N }
	if {[string equal -nocase $C "G"]} { incr N }
	if {[string equal -nocase $C "C"]} { incr N }
    }
    return $N

}

proc CompteLesLocalisations {} {

    set Tout 0; set NbRien 0; set ToutSsVide 0; set SsLocG03 0; set AcLocG03 0; set SsLocG08 0; set AcLocG08 0; set SsLocR03 0; set AcLocR03 0; set SsLocR08 0; set AcLocR08 0; set SsLoc03 0; set AcLoc03 0; set SsLoc08 0; set AcLoc08 0
    foreach Nom [ListeDesPABs] {
	incr Tout
	set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom"
	set LesLignes [LesLignesDuFichier $FichierNuctfa]
	set LaPremiereLigne [lindex $LesLignes 0]
	if {[regexp {bidon} $LaPremiereLigne]} {
	    incr NbRien
		continue
	}
	incr ToutSsVide
	set LocG03 [ExtraitInfo $Nom "LocUcscFrom200503"]
	set LocG08 [ExtraitInfo $Nom "LocUcscFrom200508"]
	set LocR03 [ExtraitInfo $Nom "LocUcscRefSeqFrom200503"]
	set LocR08 [ExtraitInfo $Nom "LocUcscRefSeqFrom200508"]

	puts "$LocG03\n$LocG08\n$LocR03\n$LocR08"

	if {![regexp {[0-9]+} $LocG03]} {incr SsLocG03; puts "$Nom =>pas de locG03"}
	if {[regexp {[0-9]+} $LocG03]} {incr AcLocG03; puts "$Nom =>a locG03"}
	if {![regexp {[0-9]+} $LocG08]} {incr SsLocG08; puts "$Nom =>pas de locG08"} 
	if {[regexp {[0-9]+} $LocG08]} {incr AcLocG08; puts "$Nom =>a locG08"}
	if {![regexp {[0-9]+} $LocR03]} {incr SsLocR03; puts "$Nom =>pas de locR03"}
	if {[regexp {[0-9]+} $LocR03]} {incr AcLocR03; puts "$Nom =>a locR03"}
	if {![regexp {[0-9]+} $LocR08]} {incr SsLocR08; puts "$Nom =>pas de locR08"} 
	if {[regexp {[0-9]+} $LocR08]} {incr AcLocR08; puts "$Nom =>a locR08"}

	if {![regexp {[0-9]+} $LocG03] && ![regexp {[0-9]+} $LocR03]} {
	    incr SsLoc03
	    puts "$Nom =>pas de loc03"
	} else {
	    incr AcLoc03
	    puts "$Nom =>a loc03"
	}
	if {![regexp {[0-9]+} $LocG08] && ![regexp {[0-9]+} $LocR08]} {
	    incr SsLoc08
	    puts "$Nom =>pas de loc08"
	} else {
	    incr AcLoc08
	    puts "$Nom =>a loc08"
	}
    }
    puts "nombre total= $Tout"
    puts "nombressrien= $NbRien"
    puts "toutssvide= $ToutSsVide"
    puts ""
    puts "sslocG03= $SsLocG03"
    puts "aclocG03= $AcLocG03"
    puts "sslocG08= $SsLocG08"
    puts "aclocG08= $AcLocG08"
    puts "sslocR03= $SsLocR03"
    puts "aclocR03= $AcLocR03"
    puts "sslocR08= $SsLocR08"
    puts "aclocR08= $AcLocR08"
    puts ""
    puts "ssloc03= $SsLoc03"
    puts "acloc03= $AcLoc03"
    puts "ssloc08= $SsLoc08"
    puts "acloc08= $AcLoc08"

}

proc CompteLesN {Sequence} {

    set N 0
    foreach Lettre [split $Sequence ""] {
	if {[string equal -nocase $Lettre "n"]} { incr N }
    }
    return $N

}

proc CompteLesPlusDixAccmRNA {} {

    set NumeroLigne ""
    set NbDeFois 0
    set Trop 0
    set OnALigne 0
    foreach Ligne [LesLignesDuFichier "/genomics/link/EVImm/parser/AttriToutVf2"] {
	if {[regexp "^ligne" $Ligne]} {
	    set OnALigne 1
	    if {$NbDeFois>10} {
		Espionne "$NumeroLigne $NbDeFois"
		incr Trop
	    }
	    set NbDeFois 0
	    scan $Ligne "%s %s" Bidon NumeroLigne
	}
	if {$OnALigne && [regexp "^>" $Ligne]} {
	    incr NbDeFois
	}
    }
    Espionne "trop $Trop"


}

proc CompteLesProt {FichierJumeauxFinal} {

    #attention: le test from homo sapiens ne va pas...(voir prottfa/DD0024)
    set h 0
    foreach Ligne [LesLignesDuFichier $FichierJumeauxFinal] {
	if {$Ligne==""} {continue}
	set LesDD [split $Ligne " "]
	set JR [lindex $LesDD 0]
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$JR"
	if {![file exists $FichierProttfa]} {Espionne "$FichierProttfa does not exist"}
	set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa]
	if {[regexp "from Homo sapiens" $EnteteProttfa]} {incr h}
    }
    return $h

}

proc CompteLesSansProtSansEST {FichierEST} {

    set n 0
    foreach Nom [ListeDesPABs] {
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom"
	if {![file exists $FichierProttfa]} {
	    set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess]
	    if {$EST==""} {incr n}
	}
    }
    return $n

}

proc CompteLesSequencesAvecBoutDePlasmide {} {

    set Rep "[RepertoireDuGenome]/nucmask"
    foreach Fichier [glob -nocomplain -directory $Rep "DD*.mrm"] {
	set Nom [NomDeFichierSansExtension [file tail $Fichier]]
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp "^>" $Ligne]} {continue}
	    set TexteLigne [join $Ligne ""]
	    append TexteTotal $TexteLigne
	}
	#FaireLire $TexteTotal
	if {[regexp -nocase "GAATTCGAT" $TexteTotal]} {lappend ListeSeqAvecBoutPlasmide $Nom}
	set TexteTotal ""
    }
    Espionne [llength $ListeSeqAvecBoutPlasmide]
    return [lsort -unique $ListeSeqAvecBoutPlasmide]
    #return [llength [lsort -unique $ListeSeqAvecBoutPlasmide]]

}

proc CompteLesSequencesAvecBoutDePlasmideEtPolyT {} {

    set Rep "[RepertoireDuGenome]/nuctfa"
    set RepPlasmide "[RepertoireDuGenome]/nucmask_SansBoutPlasmide"
    set NewRep "[RepertoireDuGenome]/nuctfa_SansBoutPlasmideEtBonSens"
    if {![file exists $NewRep]} {file mkdir $NewRep}
    foreach Fichier [glob -nocomplain -directory $Rep "DD*"] {
	set Nom [NomDeFichierSansExtension [file tail $Fichier]]
	set p 0
	if {[file exists "$RepPlasmide/$Nom"]} {set Fichier "$RepPlasmide/$Nom"; set p 1}
	set EnteteTFA [EnteteDuFichierTFA $Fichier]
	set TexteSeq [QueLaSequenceDuTFA $Fichier]
	set SeqLength [string length $TexteSeq]
	set IndiceMilieuSeq [expr ($SeqLength/2)-1]
	#set MilieuSeq [expr ($SeqLength*1.0/2)-1] -> attention! pas de decimal pour la pos d'un nucleotide
	#FaireLire "$SeqLength $IndiceMilieuSeq"
	if {[regexp -nocase "TTTTTT" $TexteSeq] && $p==1} {lappend LesSeqPlasmideCorrEtPolyT $Nom}
    }
    return [llength $LesSeqPlasmideCorrEtPolyT]

}

proc CompteLesSequencesAvecPolyA {} {

    set Rep "[RepertoireDuGenome]/nuctfa"
    set RepNew "[RepertoireDuGenome]/nuctfa_SansBoutPlasmideEtBonSens"
    foreach Fichier [glob -nocomplain -directory $Rep "DD*"] {
	set Nom [NomDeFichierSansExtension [file tail $Fichier]]
	set p 0
	if {[file exists "$RepNew/$Nom"]} {set Fichier "$RepNew/$Nom"; set p 1}
	set EnteteTFA [EnteteDuFichierTFA $Fichier]
	set TexteSeq [QueLaSequenceDuTFA $Fichier]
	set SeqLength [string length $TexteSeq]
	set IndiceMilieuSeq [expr ($SeqLength/2)-1]
	if {[regexp -nocase "AAAAAA" $TexteSeq]} {lappend LesSeqAvecPolyA $Nom}
    }
    return [llength $LesSeqAvecPolyA]

}

proc CompteLesSequencesDDBizarres {} {

    set Fichier "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best"
    foreach Nom [ListeDesPABs] {
	set Loc [InterrogeLocalisation $Fichier Nom $Nom]
	set AccRNACh [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access]
	set AccProtCh [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	set OrgaChoisi [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]
	if {![regexp -nocase "Homo sapiens" $OrgaChoisi]} {
	    set AccessmRNACh ""
	    set AccessProtch ""
	}
	if {[regexp -nocase "NOMRNA" $AccRNACh] || $AccRNACh==""} {set R 0} else {set R 1}
	if {[regexp -nocase "NoProtein" $AccProtCh] || $AccProtCh==""} {set P 0} else {set P 1}
	if {$P==0} {
	    set AccProtContig [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access]
	    if {$AccProtContig!=""} {set P 1}
	}
	if {$Loc==""} {set L 0} else {set L 1}
	if {($L==0 && $R==1) || ($L==0 && $P==1)} {
	    lappend ListeBiz $Nom    
	}
    }
    Espionne [llength $ListeBiz]
    return $ListeBiz

}

proc CompteLesSequencesNormalesEtPolyT {} {

    set Rep "[RepertoireDuGenome]/nuctfa"
    set RepPlasmide "[RepertoireDuGenome]/nucmask_SansBoutPlasmide"
    set NewRep "[RepertoireDuGenome]/nuctfa_SansBoutPlasmideEtBonSens"
    if {![file exists $NewRep]} {file mkdir $NewRep}
    foreach Fichier [glob -nocomplain -directory $Rep "DD*"] {
	set Nom [NomDeFichierSansExtension [file tail $Fichier]]
	set p 0
	if {[file exists "$RepPlasmide/$Nom"]} {set Fichier "$RepPlasmide/$Nom"; set p 1}
	set EnteteTFA [EnteteDuFichierTFA $Fichier]
	set TexteSeq [QueLaSequenceDuTFA $Fichier]
	set SeqLength [string length $TexteSeq]
	set IndiceMilieuSeq [expr ($SeqLength/2)-1]
	#set MilieuSeq [expr ($SeqLength*1.0/2)-1] -> attention! pas de decimal pour la pos d'un nucleotide
	#FaireLire "$SeqLength $IndiceMilieuSeq"
	if {[regexp -nocase "TTTTTT" $TexteSeq] && $p==1 && [regexp -nocase "TAAGCTTTTT" $TexteSeq]} {lappend LesSeqPlasmideCorrEtPolyTetNormales $Nom} elseif {[regexp -nocase "TTTTTT" $TexteSeq] && $p==0 && [regexp -nocase "TAAGCTTTTT" $TexteSeq]} {lappend LesSeqPolyTetNormales $Nom}
    }
    Espionne "seq avec bout plasmide et poly T et Normales:  [llength $LesSeqPlasmideCorrEtPolyTetNormales]"
    Espionne $LesSeqPlasmideCorrEtPolyTetNormales
    return "seq sans bout plasmide et poly T et Normales:  [llength $LesSeqPolyTetNormales]"

}

proc CompteLesStartCodonsOk {} {

    global RepertoireDuGenome
    set OldNom ""
    set nOK 0
    set DejaCompte 0
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_summary.rr"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	regsub "/" $Ligne "" Ligne
	set Poch ""
	scan $Ligne "%s %d %s %d %d %d %d %d %d %d %s" Nom iGGT MVL iMet oAv oAp F T a b Poch
	if {[regexp {\+[1-9]} $Ligne]} { set oAp "+$oAp" }
	if {[regexp {^ok[qsi]} $Poch]} {
	    set BonMet $iMet
	    InformeSansDemander $Nom "=MetRR: $MVL $BonMet"
	    Espionne $Ligne
	    Espionne "          =MetRR: $MVL $BonMet"
	}
	if { ! $DejaCompte && $Nom==$OldNom && [regexp "^ok" $Poch]} {
	    incr nOK
	    set DejaCompte 1
	}
	if {$Nom!=$OldNom} { set DejaCompte 0 }
	set OldNom $Nom
    }
    Espionne $nOK
    exit

}

proc CompteLesTar {} {

    set nb 0
    set Repertoire "/genomics/link/EVI3_msf/EVI3_MSF_JOB-223"
    foreach G [glob -nocomplain "$Repertoire/Job*"] {
	#puts "$G $nb"
	incr nb
    }
    puts "nb $nb" 

}

proc CompteLesVraisOverlapsDDAffyLoc {} {

    set nb 0; set n 0; set b 0
    #set F "[RepertoireDuGenome]/OverlapDDAffy_Loc"
    set F "[RepertoireDuGenome]/OverlapDDAffy_Loc_New"
    foreach Ligne [LesLignesDuFichier $F] {
	incr nb
	if {![regexp -nocase "TAR" $Ligne]} {incr n}
	if {![regexp -nocase "DD" $Ligne]} {incr b}
    }
    Espionne "$nb - $n jumeaux Affy et $b jumeaux DD"
    return [expr $nb-($n+$b)]

}

proc CompteLigneAcPlusDixAccmRNA {} {

    set numeroligne ""
    set nbdefois 0; set trop 0; set onaligne 0
    foreach Ligne [LesLignesDuFichier "/genomics/link/EVImm/parser/AttriToutVf2"] {
	if {[regexp "^ligne" $Ligne]} {
	    set onaligne 1
	    #Espionne "$numeroligne $nbdefois"
	    if {$nbdefois>10} {
		Espionne "$numeroligne $nbdefois"
		incr trop
	    }
	    set nbdefois 0
	    scan $Ligne "%s %s" bidon numeroligne
	}
	if {$onaligne && [regexp "^>" $Ligne]} {
	    incr nbdefois
	}
    }
    Espionne "trop $trop"

}

proc CompteLigneAcPlusDixBoite {{Liste ""}} {

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    set LesPlusDix {}

    foreach Nom $Liste {
	set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	set elmts [split $Nom ""]
	set chiffre [lindex $elmts 7]
	set NomSansFin [string range $Nom 0 end-1]
	if {$chiffre==9} {
	    lappend LesPlusDix $NomSansFin
	}
    }
    foreach PlusDix $LesPlusDix {
	foreach Nom $Liste {
	    if {[regexp $PlusDix $Nom]} {
		set Gn  [ExtraitInfo $Nom "ValiGN"]
		set Des [ExtraitInfo $Nom "ValiDE"]
		set Acc [AccessEvi $Nom]
		lappend Final "$Nom $Gn $Acc $Des"
		regsub -all "EVI" $PlusDix "" PlusDixSsEVI
		set LesChiffres [split $PlusDixSsEVI ""]
		set premierchiffre [lindex $LesChiffres 0]
		if {$premierchiffre=="0"} { 
		    regsub "0" $PlusDixSsEVI "" PlusDixSsEVI
		}
		set PlusDixSsEVISuivant [expr $PlusDixSsEVI +1]
		if {$premierchiffre=="0"} {
		    set PlusDixSsEVISuivant "0$PlusDixSsEVISuivant"
		}
		lappend LesSuivants $PlusDixSsEVISuivant
	    }
	}
    }
    set LesSuivants [ListeSansDoublon $LesSuivants]
    foreach Suivant $LesSuivants {
	set Suivant "EVI$Suivant"
	foreach Nom $Liste {
	    if {[regexp $Suivant $Nom]} {
		set GnSuiv [ExtraitInfo $Nom "ValiGN"]
		set DesSuiv [ExtraitInfo $Nom "ValiDE"]
		set AccSuiv [AccessEvi $Nom]
		lappend Final "$Nom $GnSuiv $AccSuiv $DesSuiv"
	    }
	}
    }
    set Final [ListeSansDoublon $Final]
    set Final [lsort -index 0 $Final]
    set LesPlusDix [ListeSansDoublon $LesPlusDix]
    set longLesPlusDix [llength $LesPlusDix]
    EspionneL $Final
    #Espionne "LesPlusDix $longLesPlusDix"
    #Espionne "$LesPlusDix"

}

proc CompteMasking {} {

    foreach F [glob -nocomplain "[RepertoireDuGenome]/nucmask/EVI*"] {
	set Queue [file tail $F]
	set LesMots [split $Queue "."]
	set Nom [lindex $LesMots 0]
	if {[info exists DejaVu($Nom)]} {
	    incr DejaVu($Nom)
	} else {
	    set DejaVu($Nom) 1
	}
    }
   Espionne [array size DejaVu]

}

proc CompteNbExon {} {

    set Fichier "[RepertoireDuGenome]/PourOlivier"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LesMots [split $Ligne " "]
	set Acc [lindex $LesMots 0]
	set Nb [lindex $LesMots 1]
	if { ! [info exists Compte($Nb)]} { set Compte($Nb) 0 }
	incr Compte($Nb)
    }
    foreach Nb [lsort -integer [array names Compte]] {
	Espionne "$Nb exons = $Compte($Nb)"
	set X $Compte($Nb)
	if { ! [info exists Total]} {
	    set Total $X
	} else {
	    set Total [expr $Total+$X]
	}	
    }
   Espionne "Total= $Total"

}

proc CompteNm {} {

    set total 0
    set A 0
    set B 0
    set C 0
    foreach I [RetChip5 ListOf Index] {
	incr total
	set Des1 [RetChip5 $I "description_customer"]
	set NM3 [RetChip5 $I "refseq_PIQOR"]
	if { $NM3 != "" } { 
	    incr A 
	    if {[regexp {.\,.} $NM3]} {
		incr B
		Espionne "la ligne $I a pls access ds refseq=>$B"
	    } else {
		incr C
		Espionne "la ligne $I a un access ds refseq=>$C"
	    }
	}
    }
    Espionne "il y a $total lignes"
    Espionne "il y a $A lignes qui ont un NM ou pls ds refseq"
    Espionne "il y a $B lignes qui ont au moins 2 numeros ds refseq"
    Espionne "il y a $C lignes qui ont un seul numero dans refseq"

}

proc CompteNmA {} {

    set A 0
    foreach I [RetChip5 ListOf Index] {
	set NM1 [RetChip5 $I "refseq_PIQOR"]
	set NM2 [RetChip5 $I "DNA_acc"]
	if {$NM1=="" && [regexp {\?} $NM2]} {
	    incr A
	    Espionne "la ligne $I n'a aucun access dans 2 colonnes=>$A"
	}
	if {$NM1=="" && $NM2==""} {
            incr A
	    Espionne "la ligne $I n'a aucun access dans 2 colonnes=>$A"
	}
    }
    Espionne "il y a $A lignes qui n'ont aucun access dna"

}

proc CompteNmA_AEffacer {} {

    set A 0
    foreach I [RetChip2 ListOf Index] {
	set NM1 [RetChip2 $I "refseq_PIQOR"]
	set NM2 [RetChip2 $I "DNA_acc"]
	if {$NM1=="" && $NM2==""} {
            incr A
	    Espionne "la ligne $I n'a aucun access dans 2 colonnes=>$A"
	}
    }
    Espionne "il y a $A lignes qui n'ont aucun access dna"

}

proc CompteNmB {} {

    set A 0
    set B 0
    set C 0
    foreach I [RetChip5 ListOf Index] {
	set Des1 [RetChip5 $I "description_customer"]
	set NM3 [RetChip5 $I "refseq_PIQOR"]

	puts "$I=>$NM3"

	if { $NM3 != "" } { 
	    incr A 
	    if  {![regexp {^NM_} $NM3]} {
		#Espionne "attention commence pas par NM_=> $I=$NM3"
	    }
	    if  {[regexp {^NM_[0-9]+$} $NM3] || [regexp {^NR_[0-9]+$} $NM3]} {
		incr B
		#Espionne "la ligne $I a un access NM:$NM3 dans refseq=>$B"
	    }
	    if { [regexp {.\,.} $NM3] } {
		incr C
		Espionne "la ligne $I a plusieurs NM:$NM3 dans colonne refseq=>$C"
		set LesNms [split $NM3 ","]
		foreach LeNm $LesNms {
		    set Commande "getz \"\\\[refseq-acc:$LeNm\\\]\" \-f des"
		    set GetzOut [eval exec $Commande]
		    set Def [StringSuivant "DEFINITION" dans $GetzOut]
		    puts "$LeNm=>$Def"
		}
	    }
	}
    }
    Espionne "il ya $A lignes qui ont un NM ou pls ds refseq"
    Espionne "il y a $B lignes qui ont un seul numero NM dans refseq"
    Espionne "il y a $C lignes qui ont au moins 2 numeros NM dans refseq"

}

proc CompteNmB_AEffacer {} {

    set A 0
    set B 0
    set C 0
    foreach I [RetChip2 ListOf Index] {
	set Des1 [RetChip2 $I "description_customer"]
	set NM3 [RetChip2 $I "refseq_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } { continue }

	#puts "$I=>$NM3"

	if { $NM3 != "" } { 
	    incr A 
	    if  {![regexp {^NM_} $NM3]} {
		#Espionne "attention commence pas par NM_=> $I=$NM3"
	    }
	    if  {[regexp {^NM_[0-9]+$} $NM3]} {
		incr B
		#Espionne "la ligne $I a un access NM:$NM3 dans refseq=>$B"
	    }
	    if { [regexp {.\,.} $NM3] } {
		incr C
		Espionne "la ligne $I a plusieurs NM:$NM3 dans colonne refseq=>$C"
		set LesNms [split $NM3 ","]
		foreach LeNm $LesNms {
		    set Commande "getz \"\\\[refseq-acc:$LeNm\\\]\" \-f des"
		    set GetzOut [eval exec $Commande]
		    set Def [StringSuivant "DEFINITION" dans $GetzOut]
		    puts "$LeNm=>$Def"
		}
	    }
	}
    }
    Espionne "il ya $A lignes qui ont un NM ou pls ds refseq"
    Espionne "il y a $B lignes qui ont un seul numero NM dans refseq"
    Espionne "il y a $C lignes qui ont au moins 2 numeros NM dans refseq"

}

proc CompteNmSsRA {} {

    set A 0
    set B 0
    set C 0
    foreach I [RetChip2 ListOf Index] {

	set Des1 [RetChip2 $I "description_customer"]
	set NM3 [RetChip2 $I "refseq_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } { continue }

	if { $NM3 != "" } { 
	    incr A 
	    if {[regexp {.\,.} $NM3]} {
		incr B
		Espionne "la ligne $I a pls access ds refseq=>$B"
	    } else {
		incr C
		Espionne "la ligne $I a un access ds refseq=>$C"
	    }
	}
    }
    Espionne "il y a $A lignes qui ont un NM ou pls ds refseq"
    Espionne "il y a $B lignes qui ont au moins 2 numeros ds refseq"
    Espionne "il y a $C lignes qui ont un seul numero dans refseq"

}

proc CompteNm_AEffacer {} {

    set N 0
    set M 0
    foreach I [RetChip ListOf Index] {
	set NM [RetChip $I "refseq_PIQOR" ]
	Espionne "$NM existe1"
	if {[regexp {NM_[0-9]+\,} $NM]} {
	    incr M
	    set doubl [split $NM ","]
	    #foreach d $doubl { puts $d }
	}
	continue
	if { ! [regexp {^NM_[0-9]+$} $NM]} { 
	    set NM [RetChip $I "DNA_acc"] 
	    Espionne "$NM existe2"
	}
	if { ! [regexp {^NM_[0-9]+$} $NM]} {
	    incr N
	    Espionne "la ligne $I n'a pas de NM => $N"
	    continue
	}
    }
    exit

}

proc CompteOrganism {} {

    set total 0; set vide 0; set souris 0; set hom 0; set autre 0
    foreach Nom [ListeDesPABs] {
	set fait 0; set Info ""
	incr total
	set Info [ExtraitInfo $Nom "Organism"]
	if {$Info==""} {
	    set fait 1; incr vide
	    Espionne "$Nom vide"
	}
	if {[regexp "Mus" $Info]} {
	    set fait 1; incr souris
	    Espionne "$Nom souris"
	}
	if {[regexp "Homo" $Info]} {
	    set fait 1; incr hom
	    Espionne "$Nom hom"
	}
	if {!$fait} {
	    incr autre
	    Espionne "$Nom autre"
	}
    }
    Espionne "total $total"
    Espionne "vide $vide"
    Espionne "souris $souris"
    Espionne "hom $hom"
    Espionne "autre $autre"

}

proc CompteSsDnaAcProt {} {

    set W 0; set V 0; set X 0; set Y 0
    foreach I [RetChip5 ListOf Index] {
	set Des [RetChip5 $I "description_customer"]
	set Ac1 [RetChip5 $I "refseq_PIQOR"]
	set Ac2 [RetChip5 $I "DNA_acc"]
	set Ac3 [RetChip5 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip5 $I "prot_acc"]
	if {[regexp {\?} $Ac2]} {set Ac2 ""}
	if {[regexp {\?} $Ac4]} {set Ac4 ""}
	if {$Ac1=="" && $Ac2==""} {
	    puts "Ac1 $Ac1 Ac2 $Ac2 Ac3 $Ac3 Ac4 $Ac4"
	    if {$Ac3!="" || $Ac4!=""} {
		incr Y
	    }
	    if {$Ac3!=""} {
		incr W
		Espionne "la ligne $I a un acc prot ds col prot_acc_piqor=>$W"
	    }
	    if {$Ac4!=""} {
		incr V
		Espionne "la ligne $I a un acc prot ds col prot acc=>$V"
	    }    
	    if {$Ac3!="" && $Ac4!=""} { 
		incr X
		Espionne "la ligne $I a un acc prot ds 2 col:$Ac3 et $Ac4=>$X"
	    }
	}
    }
    Espionne "il y a $Y lignes qui ont un access prot ds une des 2 col" 
    Espionne "il y a $W lignes qui ont un access prot ds col prot_acc_piqor"
    Espionne "il y a $V lignes qui ont un access prot ds col prot_acc"
    Espionne "il y a $X lignes qui ont un access prot ds 2 col"

}

proc CompteSsDnaAcProt_AEffacer {} {

    set W 0
    set V 0
    set X 0
    set Y 0
    foreach I [RetChip2 ListOf Index] {
	set Des [RetChip2 $I "description_customer"]
	set Ac1 [RetChip2 $I "refseq_PIQOR"]
	set Ac2 [RetChip2 $I "DNA_acc"]
	set Ac3 [RetChip2 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip2 $I "prot_acc"]
	#if { [regexp {^RA[0-9]+} $Des] } { continue }
	if {$Ac1=="" && $Ac2==""} {
	    if {$Ac3!="" || $Ac4!=""} {
		incr Y
	    }
	    if {$Ac3!=""} {
		incr W
		Espionne "la ligne $I a un acc prot ds col prot_acc_piqor=>$W"
	    }
	    if {$Ac4!=""} {
		incr V
		Espionne "la ligne $I a un acc prot ds col prot acc=>$V"
	    }    
	    if {$Ac3!="" && $Ac4!=""} { 
		incr X
		Espionne "la ligne $I a un acc prot ds 2 col:$Ac3 et $Ac4=>$X"
	    }
	}
    }
    Espionne "il y a $Y lignes qui ont un access prot ds une des 2 col" 
    Espionne "il y a $W lignes qui ont un access prot ds col prot_acc_piqor"
    Espionne "il y a $V lignes qui ont un access prot ds col prot_acc"
    Espionne "il y a $X lignes qui ont un access prot ds 2 col"

}

proc CompteSsDnaSsProt {} {

    set Z 0
    foreach I [RetChip5 ListOf Index] {
	set Des [RetChip5 $I "description_customer"]
	set Ac1 [RetChip5 $I "refseq_PIQOR"]
	set Ac2 [RetChip5 $I "DNA_acc"]
	set Ac3 [RetChip5 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip5 $I "prot_acc"]
	if {$Ac1=="" && ($Ac2==""|| [regexp {\?} $Ac2]) && $Ac3=="" && ($Ac4=="" || [regexp {\?} $Ac4])} {
	    incr Z
	    Espionne "la ligne $I=$Des n'a pas acc dna ni acc prot=>$Z"
	}
    }
    Espionne "il y a $Z lignes qui ont ni acc dna ni acc prot" 

}

proc CompteSsDnaSsProt_AEffacer {} {

    set Z 0
    foreach I [RetChip2 ListOf Index] {
	set Des [RetChip2 $I "description_customer"]
	set Ac1 [RetChip2 $I "refseq_PIQOR"]
	set Ac2 [RetChip2 $I "DNA_acc"]
	set Ac3 [RetChip2 $I "prot_acc_PIQOR"]
	set Ac4 [RetChip2 $I "prot_acc"]
	if { [regexp {^RA[0-9]+} $Des] } { continue }
	if {$Ac1=="" && $Ac2=="" && $Ac3=="" && $Ac4==""} {
	    incr Z
	    Espionne "$I"
	    #Espionne "la ligne $I=$Des n'a pas acc dna ni acc prot=>$Z"
	}
    }
    #Espionne "il y a $Z lignes qui ont ni acc dna ni acc prot" 

}

proc CompterLesMismatchs {DR} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|CompterLesMismatchs : Start"
	set FichierOut [open "ComptageDesErreursDR$DR.txt" "w"] 
	foreach I {1 2 3 4 5 6} {
		set Tableau1($I) 0
		set Tableau2($I) 0
	}
	foreach J {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y} {
		set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
		Espionne "$timestamp|CompterLesMismatchs : Chromosome $J"
		set FichierEntree [open "chr$J-$DR.coord" "r"] 
		while { [gets $FichierEntree Ligne]  >=0 } {
			ScanLaListe $Ligne nbMatchs sequenceNumber chr matchStart matchEnd matchType hs1Mistake hs2Mistake matchSequence
			set hs1MMlist [split [lindex [split $hs1Mistake "@"] 1] "/"]
			set nbMM1 [lindex [split $hs1Mistake "@"] 0] 
			foreach MM1 $hs1MMlist {
				foreach I {1 2 3 4 5 6} {
					if {$MM1 == $I} {
						incr Tableau1($I)
					}
				}
			}
			set hs2MMlist [split [lindex [split $hs2Mistake "@"] 1] "/"]
			set nbMM2 [lindex [split $hs2Mistake "@"] 0] 
			foreach MM2 $hs2MMlist {
				foreach I {1 2 3 4 5 6} {
					if {$MM2 == $I} {
						incr Tableau2($I)
					}
				}
			}
		}
		close $FichierEntree
	}
	foreach I {1 2 3 4 5 6} {
		puts $FichierOut "Chr$I $Tableau1($I)"
	}
	foreach I {1 2 3 4 5 6} {
		puts $FichierOut "Chr$I $Tableau2($I)"
	}
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|CompterLesMismatchs : End"

}

proc CompteurDeCompteurs {NombreDeCompteurs} {


	#Décortique un fichier de compteur nx1 lignes

	# Déclaration des fichiers
	set FichierDesCompteurs [open "/tmp/Conservation/FichierDesOccurencesDownstream.txt" "r"]
	set FichierLog "/tmp/Conservation/CompteurDesOccurencesDownstream.txt"
	set PathOut $FichierLog

	# Suppressions des éventuelles versions précédentes des fichiers
	if { [file exists $FichierLog] } {
		file delete $FichierLog
	}
	set Lus 0
	set Compteur 0
	for {set I 1} {$I<=$NombreDeCompteurs} {incr I} {
		set Compteur$I 0
	}

	while { [gets $FichierDesCompteurs Ligne]  >=0 } {
		incr Lus
		for {set I 1} {$I<=$NombreDeCompteurs} {incr I} {
			if { $Ligne == $I } {
				incr Compteur$I
			}
		}
	}
Espionne "================================================"
Espionne " Statistiques du traitement CompteurDeCompteurs "
Espionne "================================================"
Espionne " "

	for {set I 1} {$I<=$NombreDeCompteurs} {incr I} {
		set Compteur [set Compteur$I]
	Espionne "Nombre de génes avec $I SBS : $Compteur"
	}
	Espionne "Execution terminée. Les résultats des $Lus lectures ont été écrits dans $PathOut"

}

proc Comptons {} {

    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    set Compteur(Total) 0
    set Compteur(FF)  0
    set Compteur(FF0) 0
    set Compteur(FF1) 0
    set Compteur(FF3) 0
    set Compteur(FF5) 0
    set Compteur(FF7) 0
    set Compteur(FF9) 0
    set Compteur(Enterres) 0
    set Compteur(Decedes) 0

    set Compteur(hTotal) 0
    set Compteur(hFF)  0
    set Compteur(hFF0) 0
    set Compteur(hFF1) 0
    set Compteur(hFF3) 0
    set Compteur(hFF5) 0
    set Compteur(hFF7) 0
    set Compteur(hFF9) 0
    set Compteur(hEnterres) 0
    set Compteur(hDecedes) 0

    set Compteur(fTotal) 0
    set Compteur(fFF)  0
    set Compteur(fFF0) 0
    set Compteur(fFF1) 0
    set Compteur(fFF3) 0
    set Compteur(fFF5) 0
    set Compteur(fFF7) 0
    set Compteur(fFF9) 0
    set Compteur(fEnterres) 0
    set Compteur(fDecedes) 0

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { ! [YaPABdans $Nom]} { continue }
	set FFx "FF[FiabiliteFonction $Nom]"
	incr Compteur(Total)
	incr Compteur($FFx)
	if {[Enterre $Nom]} { incr Compteur(Enterres) }
	if {[Decede  $Nom]} { incr Compteur(Decedes) }
	if {[Enterre $Nom] && [ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hEnterres) }
	if {[Enterre $Nom] && [ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fEnterres) }
	if {[Decede  $Nom] && [ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hDecedes) }
	if {[Decede  $Nom] && [ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fDecedes) }
	if {[ExisteOrthologueDans "phor" $Nom]} { incr Compteur(hTotal); incr Compteur(h$FFx)}
	if {[ExisteOrthologueDans "pfur" $Nom]} { incr Compteur(fTotal); incr Compteur(f$FFx)}
    }

    foreach Valeur [lsort [array names Compteur]] {
	puts [format "%10s %d" $Valeur [set Compteur($Valeur)]]
    }

}

proc ComptonsLesATGC {} {

    global ADN TDN RAC
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set l [string length $ADN]

    set nA 0
    set nT 0
    set nG 0
    set nC 0

    for {set i 1} {$i < $l} {incr i} {
	set c [string index $ADN $i]
	if { $c == "A" } { incr nA }
	if { $c == "T" } { incr nT }
	if { $c == "G" } { incr nG }
	if { $c == "C" } { incr nC }
    }
    set l [expr $nA + $nT +$nG + $nC]
    puts " $l bases"
    puts " "
    puts " A $nA [format %5.2f [expr (100.*$nA)/$l]]%"
    puts " T $nT [format %5.2f [expr (100.*$nT)/$l]]%"
    puts " G $nG [format %5.2f [expr (100.*$nG)/$l]]%"
    puts " C $nC [format %5.2f [expr (100.*$nC)/$l]]%"
    puts " "
    puts "AT [expr $nA+$nT] [format %5.2f [expr (100.*($nA+$nT))/$l]]%"
    puts "GC [expr $nG+$nC] [format %5.2f [expr (100.*($nG+$nC))/$l]]%"

}

proc ComptonsLesSolitaires {} {

    foreach Nom [ListeDesPABs] {
	set nCops [NombreDeCopainsDansBlast $Nom]
	set Report [StartCodonReport $Nom "Couleur"]
    }

}

proc ComptonsLesStartCodon {} {

    set RW 0
    set RWseul 0
    set Rg 0
    set RR 0
    set RG 0
    set GW 0
    set GWseul 0
    set Gg 0
    set GR 0
    set GG 0
    set Rmodifs 0
    set Rpile   0
    set T 0
    set TB 0
    set TM 0

    set N 0
    foreach Nom [ListeDesPABs] {
	set NorMD [MDScore $Nom]
	set nCops [NombreDeCopainsDansBlast $Nom]
	set Etendu [GeneEtendu $Nom "Color"]
	set Report [StartCodonReport $Nom "Couleur"]
	if {$Report=="orange"} { set Report "red" }

	if { $Etendu=="red"   && $Report=="white" } { incr RW }
	if { $Etendu=="red"   && $Report=="white" && $nCops < 3} { incr RWseul }
	if { $Etendu=="red"   && $Report=="grey" } { incr Rg }

	if { $Etendu=="green" && $Report=="white"} { incr GW }
	if { $Etendu=="green" && $Report=="white" && $nCops < 3} { incr GWseul }
	if { $Etendu=="green" && $Report=="grey" } { incr Gg }

	if {$Report=="red" || $Report=="green"} {
	    incr T
	    if {$NorMD>0.4} {
		incr TB
	    } else {
		incr TM
	    }
	}

	if { $Etendu=="red"   && $Report=="red"  } {
	    incr RR
	    set OldBornes [GeneEtendu $Nom "Old"]
	    scan $OldBornes "%s %d %d %s" OldNom OldDebut OldFin OldOrient
	    set Debut  [Box $Nom debut]
	    set Fin    [Box $Nom fin]
	    set Orient [Box $Nom orient]
	    set Diff [expr ($Fin - $Debut) - ($OldFin -$OldDebut)]
	    set Rapport [StartCodonReport $Nom "Rapport"]
	    scan $Rapport "%s %s" Signif CodonsProposes
	    regexp {[MVL]([0-9]+)} $CodonsProposes Match Pos
	    set Ecart [expr abs($Pos - $Diff/3 - 1)] 
	    if { $Ecart == 0} {
		incr Rpile
	    } else {
		lappend LesEcarts [list $Ecart [MDScore $Nom]]
	    }
	}
	if { $Etendu=="red"   && $Report=="green"} { incr RG }

	if { $Etendu=="green" && $Report=="red"  } { incr GR }
	if { $Etendu=="green" && $Report=="green"} { incr GG }
	incr N
    }
    EspionneL [lsort -index 0 -integer $LesEcarts]
    Espionne "$N $RW $RWseul $Rg $RR $RG  $GW $GWseul $Gg $GR $GG $Rmodifs $Rpile $T $TB $TM"
    exit

}

proc CompulsoryGenesOnWeb {} {

    return [RetinalGenesSummaryOnWeb [ListOfCompulsoryGenes] "CompulsoryGenes"]

}

proc ComputeBlocks {} {

    global LNDG SDG CpB LNOrdali LSOrdali TDesSeqWeights CBPCI Sequences

    # start / stop of each sequence
    # 
    # CpB : table contains all for computation
    #
    set CpB(Ltot) [LongueurDeLAlignement]
    set Ltot $CpB(Ltot)

    array set CBPCI [PCIPourBlocks]

    # compute tree
    set Ln [list]
    set Ldst [list]
    set Ldtc [list]
    foreach n1 $LNOrdali {
	if {$n1 eq ""} {continue}

	lappend Ln $n1
	foreach n2 $LNOrdali {
	    if {$n2 eq ""} {continue}

	    set pc [set CBPCI($n1,$n2)]
	    lappend Ldst [expr {1.-$pc}]
	    lappend Ldtc [expr {1.-$pc}]	    
	}
	lappend Ldtc 1.0
    }
    lappend Ldtc {*}[lrepeat [llength $Ln] "1.0"] 0.0
    lappend Lntc {*}$Ln "fictive_sequence"
    set CpB(Lseqs) $Ln

    set rep [fastme $Ln $Ldst]
    set ATb [DecortiqueUnArbre $rep]

    # groups
    # compute secator groups
    set SAli [list]
    foreach n $LNOrdali s $LSOrdali {
	if {[string trim $n] ne ""} {
	    lappend SAli $n $s
	}
    }
    puts "llength SAli [llength $SAli]"

    ######
    # 
    # Pour tests, prend meme clusters que Julie !
    # 
    ######
    if {1} {
	set Lres [Tclcluspack $SAli -dt alignment -cm bionj -nbc secator]
	puts "Lres [llength $Lres]"
	#set Lres [Tclcluspack $Lval -dt coordinates -cm mm -nbc aic]
	#set rep [fastme $Lntc $Ldtc]
	#set Lres [Tclcluspack $rep -dt newick -cm mm -nbc secator]
	
	ClusterSeqsDeCluspackTcl $Lres SeqsDeGrps LesNomsGrps 
    } else {
	# prend meme cluster que rascal
	LectureClusters lucky.clu SeqsDeGrps LesNomsGrps
	# prend meem arbre que rascal
	set Ll [LesLignesDuFichier lucky.ph]
	set rep [join $Ll ""]
	set ATb [DecortiqueUnArbre $rep]
    }

    set ngroups [llength $LesNomsGrps]
    if {$ngroups < 2} {
	FaireLire "Not enough groups to compute blocks !"
	return
    }
    set CpB(LNDG) [linsert $LesNomsGrps 0 GroupeToutLeMonde]
    puts "LNDG $CpB(LNDG)"
    foreach g $LesNomsGrps {
	lappend CpB(GroupeToutLeMonde) {*}[set SeqsDeGrps($g)]
	set CpB($g) [set SeqsDeGrps($g)]
	set CpB(GOri,$g) [set SeqsDeGrps($g)]
    }
    set CpB(LNDGOri) $CpB(LNDG)
    foreach g [lrange $CpB(LNDG) 1 end] {
	puts "DEBITEM $g"
	foreach n [set CpB($g)] {
	    puts "ITEM $n"
	}
    }
    
    # compute sequence weights from tree
    array set TDesSeqWeights [SequenceWeight $ATb]
    
    # Check weights
    puts "DEBITEM SeqWgt"
    set i 0
    foreach n [set CpB(GroupeToutLeMonde)] {
	puts "ITEM $n [set TDesSeqWeights($n)]"
	incr i
    }
    
    # check orphans
    OrphanSeqs 
    
    # computes blocks in each groups
    set window 8
    foreach g $CpB(LNDG) {
	set CpB($g,Lpil) [CreeLesPiliersPourBlocks [set CpB($g)]]
	set CpB(Blocks,$g) [list]
	LesBlocks $g $window
    }
    update
    
    # output
    foreach g [lrange [set CpB(LNDG)] 1 end] {
	puts "PGroup[string range $g 5 end]" 
	puts "seqs [llength [set CpB($g)]]"
	puts "blck [llength [set CpB(Blocks,$g)]]"
	puts "prf1 [llength [set CpB($g,Lprf1)]]"
	puts "prf2 [llength [set CpB($g,Lprf2)]]"
	puts "code [llength [set CpB($g,Lcode)]]"
	
	puts "DEBITEM NwB[string range $g 5 end]"
	foreach b [set CpB(Blocks,$g)] {
	    lassign $b d f
	    puts "ITEM $d $f"
	}
    }
    
    set shared_cutoff 80000
    set ig1 0
    foreach g1 [lrange $CpB(LNDG) 1 end-1] {
	incr ig1
	if {[llength $CpB($g1)] < 2} {continue}
	
	set j [expr {$ig1 + 1}]
	set ig2 $ig1
	foreach g2 [lrange $CpB(LNDG) $j end] {
	    incr ig2
	    if {[llength $CpB($g2)] < 2} {continue}
	    
	    for {set ib1 0} {$ib1 < [llength [set CpB(Blocks,$g1)]]} {incr ib1} {
		set b1  [lindex [set CpB(Blocks,$g1)] $ib1]
		set cd1 [lindex [set CpB($g1,Lcode)] $ib1]
		lassign $b1 f1 l1
		for {set ib2 0} {$ib2 < [llength [set CpB(Blocks,$g2)]]} {incr ib2} {
		    set b2  [lindex [set CpB(Blocks,$g2)] $ib2]
		    set cd2 [lindex [set CpB($g2,Lcode)] $ib2]
		    lassign $b2 f2 l2

		    if {[BlockOverlap $f1 $l1 $f2 $l2] > 0} {
			set score [ScoreBlockVsBlock $f1 $f2 [lindex [set CpB($g1,Lprf1)] $ib1] [lindex [set CpB($g2,Lprf2)] $ib2]]
			if {$score > $shared_cutoff} {
			    if {$cd1 == 0 && $cd2 == 0} {
				lset CpB($g1,Lcode) $ib1 [expr {$ig1+1}]
				lset CpB($g2,Lcode) $ib2 [expr {$ig1+1}]
			    } elseif {$cd1 > 0} {
				lset CpB($g2,Lcode) $ib2 $cd1
			    } elseif {$cd2 > 0} {
				lset CpB($g1,Lcode) $ib1 $cd2
			    }
			    set ffirst [expr {max($f1,$f2)+1}]
			    set flast [expr {min($l1,$l2)+1}]
			    puts "SHAREDCOREBLOCK $ig1 $ig2 $ffirst $flast $score"
			    if {($flast-$ffirst) > 3 && ($flast-$ffirst)*$score > 1} {
				lappend CpB(ShBck) [list $g1 $g2 $ffirst $flast $score]
			    }
			}
		    }
		}
	    }
	}
    }
    
    # compare orphan to all subgroups
    set i 2
    set ig1 0
    foreach g1 [lrange $CpB(LNDG) 1 end] {
	incr ig1
	if {[llength $CpB($g1)] != 1} {continue}
	set seq [set Sequences([set CpB($g1)])]
	
	set CpB(Blocks,$g1) [list]
	set CpB(MxSc,$g1)   [list]
	set CpB($g1,Lcode)  [list]
	set ig2 0
	foreach g2 [lrange $CpB(LNDG) 1 end] {
	    incr ig2
	    if {[llength $CpB($g2)] < 2} {continue}
	    
	    for {set ib2 0} {$ib2 < [llength [set CpB(Blocks,$g2)]]} {incr ib2} {
		set b2  [lindex [set CpB(Blocks,$g2)] $ib2]
		set cd2 [lindex [set CpB($g2,Lcode)] $ib2]
		lassign $b2 f2 l2
		set prf1 [lindex [set CpB($g2,Lprf1)] $ib2]
		set score [ScoreSequence $seq $prf1 $f2 $l2]
		if {$score > $shared_cutoff} {
		    puts "seq_score $ig1 [set CpB($g1)]  $ig2 [lindex [set CpB($g2)] 0] $f2 $l2 $score"
		    set found 0
		    for {set ik 0} {$ik < [llength $CpB(Blocks,$g1)]} {incr ik} {
			set bk [lindex [set CpB(Blocks,$g1)] $ik]
			lassign $bk fk lk
			if {[BlockOverlap $fk $lk $f2 $l2] > 0} {
			    set mx [lindex [set CpB(MxSc,$g1)] $ik]
			    if {$score > $mx} {
				lset CpB(MxSc,$g1) $ik $score
				lset CpB(Blocks,$g1) $ik $b2
				lset CpB($g1,Lcode) $ik [expr {$ib2+1}]
			    }
			    set found 1
			}
		    }
		    if {! $found} {
			lappend CpB(MxSc,$g1) $score
			lappend CpB(Blocks,$g1) $b2
			lappend CpB($g1,Lcode) [expr {$ib2+1}]
		    }
		    update
		}
	    }
	}
	
	lassign [set CpB(startstop,[set CpB($g1)])] deb fin
	set if 0
	foreach b $CpB(Blocks,$g1) c $CpB($g1,Lcode) m $CpB(MxSc,$g1) {
	    lassign $b f l
	    if {$f < $deb} {set f $deb}
	    if {$l < $deb} {set l $deb}
	    if {$f > $fin} {set f $fin}
	    if {$l > $fin} {set l $fin}
	    
	    lset CpB(Blocks,$g1) $if [list $f $l]
	    puts "SHAREDCOREBLOCK $c [expr {$ig1+1}] [expr {$f+1}] [expr {$l+1}] $m"
	    incr if
	}
	update
    }
    
    # check for any local core blocks that are not shared
    foreach g [lrange $CpB(LNDG) 1 end] {
	if {[llength [set CpB($g)]] <= 2} {continue}
	set CpB(LcBck,$g) [list]
	foreach c [set CpB($g,Lcode)] b [set CpB(Blocks,$g)] {
	    if {$c == 0} {
		puts "$g LOCALCOREBLOCK $b"
		lappend CpB(LcBck,$g) [list {*}$b $c]
	    }
	}
    }
    
    return
    exit

}

proc ComputeConservation {} {

    global Cons ListeTypesDeFeatures

     set Cons(OnlyGlobal) 1
    set Cons(PDB) 0
    set Cons(Title) ""
    set Cons(Method) Threshold

    LesDefauts Mode batch
    LesDefauts MethodeConservation "Threshold"

    set ft [PrepareRunOrdali]

    set Cons(ConsCou) "tmpCons-T80"
    set ScoreMeth($ft,Title) ""
    set ScoreMeth($ft,Methode) "Threshold"
    set Cons(ListeCons) "None"

    SauveConservation

    puts "[join $ListeTypesDeFeatures \n]"

    return

}

proc ComputeIdentity {} {

    global NomSeqSel ZoneSelect TPCI

    set NSTmp $NomSeqSel
    set NomSeqSel {}
    AlignementDesSelections "" SAli
    set NomSeqSel $NSTmp

    CalculeLesPCIGenerique $SAli TPCI
    
    return

}

proc ComputeMiSynPatMutation {sys aafrom pos aatype {chain A}} {

    # modeller uses aa in 3-letters code
    if {[string length $aatype] == 1} {
	set aatype [AutreCodeLuc $aatype]
    }
    if {[string length $aafrom] == 1} {
	set aafrom [AutreCodeLuc $aafrom]
    }

    # sys est du type aars2, dars2 , ...
    set sysdir [string tolower $sys]
    set SYS    [string toupper $sys]

    # never touch the original file, copy it.
    set file [file join [MiSynPatDir] data structures $sysdir ${sysdir}_model.pdb]
    # base temporary files used for computation
    # => Rivet is in tcl 8.5.15
    set wbase [file join [MiSynPatDir] temp "[SESSION id]_[Date Seconds]_$SYS"]
    # when Rivet in tcl 8.6, then use :
    # file tempfile wbase "[SESSION id]..." !!!!!!!!! non  car ce n'est pas le même d'une machine à l'autre !!!
    # input pdb file

    set work "$wbase.pdb"
    file copy $file $work
    # modeller log file
    set wlog "$wbase.log"
    # Output file :
    # modeller appends aa+pos.pdb to the input file
    set aaf1 [AutreCodeLuc $aafrom]
    set aat2 [AutreCodeLuc $aatype]
    set fout "${wbase}_$aaf1$pos$aat2.pdb"
    
    # run modeller script 
LogWscope "python mutate.py $work $pos $aatype $chain"
    exec python mutate.py $work $pos $aatype $chain

    set fpyout "${work}$aatype$pos.pdb"
    if {[file exists $fpyout]} {
	file rename $fpyout $fout
	set ret [string range $fout [string first "temp/" $fout] end]
	set retour "/misynpat/$ret"
    } else {
	set retour "ERROR"
    }
    #file delete {*}[glob ${wbase}*]

    return $retour

}

proc ComputeScoreAllPairsAgents {Lblock} {

    global TAg T LNOrdali

    set Lnoms {}
    foreach n $LNOrdali {
	if {$n ne ""} {lappend Lnoms $n}
    }

    set Lnone {}
    set iNom 0
    set iter 0
    foreach n1 [lrange $Lnoms 0 end] {
	set Lag1 [list]
	foreach {d f} $Lblock {
	    set Lags [AgentsDuBlock $d $f $n1]
	    #puts ">$Lags<"
	    foreach nag $Lags {
		if {$nag eq ""} {continue}
		lappend Lag1 [lindex $nag 1]
	    }
	}
	foreach ag1 $Lag1 {
	    foreach n2 [lrange $Lnoms 0 end] {
		#puts "\t$n2"
		set Ln {}
		foreach ag2 $TAg($n2) {
		    lassign [ScoreMotifAgents $n1 $ag1 $n2 $ag2] score seuil
		    
		    if {$score eq "skip"} {
			set score -999.0
		    }
		    lappend Ln [list $ag2 $score]
		    #lappend T($n2,$ag2,$n1) [list $ag1 $score]
		    incr iter
		}
		set T($n1,$ag1,$n2) [lsort -real -index 1 -decreasing $Ln]
	    }
	}
	incr iNom
    }

    puts "nb iteration       $iter"

    return

}

proc ComputeScorePairsDuBlockAgents {d f} {

    global TAg T LNOrdali

    set Lnoms {}
    foreach n $LNOrdali {
	if {$n ne ""} {lappend Lnoms $n}
    }

    set iNom 0
    set iter 0
    foreach n1 $Lnoms {
	set Lnag [AgentsDuBlock $d $f $n1]
	set Lag1 {}
	foreach nag $Lnag {
	    if {$nag == {} } {continue}
	    lappend Lag1 [lindex $nag 1]
	}
	foreach ag1 $Lag1 {
	    foreach n2 $Lnoms {
		#puts "\t$n2"
		set Ln {}
		foreach ag2 $TAg($n2) {
		    lassign [ScoreMotifAgents $n1 $ag1 $n2 $ag2] score seuil
		    
		    if {$score eq "skip"} {
			set score -999.0
		    }
		    lappend Ln [list $ag2 $score]
		    #lappend T($n2,$ag2,$n1) [list $ag1 $score]
		    incr iter
		}
		set T($n1,$ag1,$n2) [lsort -real -index 1 -decreasing $Ln]
	    }
	}
	incr iNom
    }

    puts "nb iteration       $iter"

    return

}

proc ConcatAlignments {OutFile args} {

    set I 0
    set LeTotal {}
    foreach F $args {
	incr I
	foreach Ligne [LesLignesDuFichier $F] {
	    regsub "^>" $Ligne ">${I}_" Ligne 
	    lappend LeTotal $Ligne
	}
    }
    return [SauveLesLignes $LeTotal dans $OutFile]

}

proc ConcatLesTFAs {Selection {ButNo ButNo:}} {

    global RepertoireDuGenome

    set ListeDesAccessARetirer [lrange [split $ButNo ":"] 1 end]

    set Force 1
    set Cool  0

    set LesTFAsConcatenes {}

    set LesBanqueIdRestants {}
    set LesAccessRestants {}
    set LesPNs {}
    set LesOXs {}
    foreach Ligne [split $Selection "\n"] {
	Espionne "Concat de $Ligne"
	if { ! [regexp -nocase {[A-Z]} $Ligne]} { continue }
	set Access ""
	set PN 0.001
	set OX "Inconnu inconnu"
	scan $Ligne "%s %s %s %s" BanqueId Access PN OX
	if {[regexp {\|} $BanqueId]} {
	    lassign [split $BanqueId "|"] B A I 
	    set BanqueId $I
	    set Access $A
	}
	if {$Access==""} { set Access $BanqueId }

	if {[lsearch -exact $ListeDesAccessARetirer $Access] > -1} { continue }

	if {[EstUnAccessPDB $BanqueId]} {
	    set AccessOK $BanqueId
	    if {[info exists DejaVu($AccessOK)]} { continue }
	    set DejaVu($AccessOK) 1
	    Wup "First we search in /catalog/blast/pdb if not in pdb.fasta"
	    set FiPdb "/catalog/blast/pdb"
	    if {[FileAbsent $FiPdb] && [FileExists "$FiPdb.fasta"]} { set FiPdb "$FiPdb.fasta" }
	    if {[FileAbsent $FiPdb]} { continue }
	    set TFA [LaSequenceDuTFAs $FiPdb $BanqueId "" "" "ForceAccessFirst"]
	    if {$TFA!=""} {
		lappend LesTFAsConcatenes $TFA
		continue
	    }
	    Wup "Then we search in pdb itself"
	    set TFA [TFADuPDB $BanqueId]
	    if {$TFA!=""} {
		lappend LesTFAsConcatenes $TFA
		continue
	    }
	    Warne "$Ligne\n not found in pdb"
	    continue
	}
	lappend LesBanqueIdRestants $BanqueId
	lappend LesAccessRestants   $Access
	lappend LesPNs $PN
	lappend LesOXs $OX
    }

    if { ! [PrepareLesSequencesDesBanques "YaQuelqun"]} {
	PrepareLesSequencesDesBanques $LesBanqueIdRestants $LesAccessRestants
    }

    foreach BanqueId $LesBanqueIdRestants Access $LesAccessRestants PN $LesPNs OX $LesOXs {
	set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
	Espionne "$BanqueId $Access AccessOK=$AccessOK [llength $LesLignesEMBL] lignes dans l'EMBL"
	if {[llength $LesLignesEMBL] == 0} { Warne "$Ligne\n introuvable" ; continue }
	if {[info exists DejaVu($AccessOK)]} { continue }
	set DejaVu($AccessOK) 1
	set Descriptif [LeDescriptif $AccessOK]                              ;#rR fait dans LesDescriptifsDuBlast
	Espionne "Descriptif avec $AccessOK : $Descriptif"
	if {[regexp "no description" $Descriptif]} { set Descriptif "" }
#rR	set TFA [SequenceFormatTFA [join $LesLignesEMBL "\n"] $Descriptif "embl"]
	set Entete ""
	if {$AccessOK!=""} { set Entete "$AccessOK $Descriptif" } 
	if {[UseBanqueIdForDbClustal]} {
	    if {[regexp -nocase {^[a-z0-9]+_[a-z0-9]+$} $BanqueId]} {
		set Entete "$BanqueId $Descriptif $AccessOK"
	    }
	}
	set TFA [SequenceFormatTFA [join $LesLignesEMBL "\n"] $Entete "embl"]
	if {[OnVireLesMonstresLointains]} {
	    set ExpectMonstresLointains 0.001
	    set LongueurMonstresLointains 3000
	    set Long [string length [QueLaSequenceDuTexteTFA $TFA]]
	    if {$PN>$ExpectMonstresLointains && $Long>$LongueurMonstresLointains  || [expr $Long>($LongueurMonstresLointains*3)]} {
		Warne "Je vire le monstre lointain $BanqueId Access"
		continue
	    }
	}
	lappend LesTFAsConcatenes $TFA

    }
    return [join $LesTFAsConcatenes "\n"]

}

proc ConcateneLesContigs {{FichierACreer ""} {NomDeBapteme ""}} {

    global RepertoireDuGenome

    if {$FichierACreer==""} {
	FaireLire "Please give me the name of the DNA sequence file."  
	set FichierACreer [FichierPourSaveAs "$RepertoireDuGenome/beton/allcontigs.tfa"]
    }
    if {$FichierACreer==""} { return "" }

    if {$NomDeBapteme==""} { set NomDeBapteme "DNAsequence" }

    set Tout ""
    set ToutPure ""
    set NumeroContig 0
    set FinContig 0
    foreach FichierContig [glob "$RepertoireDuGenome/contigs/*"] {
	incr NumeroContig
	set LigneKO 0
	set Contig ""
	foreach Ligne [LesLignesDuFichier $FichierContig] {
	    regsub -all -nocase "X" $Ligne "N" Ligne
	    if {[regexp -nocase {[^ATGCNMKRSYWVHDB ]} $Ligne Match]} {
		if {[OuiOuNon "In file $FichierContig a line contiains\n $Match\nwhich is unusual.  Do I skipp this file"]} { set LigneKO 1 ; break }
		if {[OuiOuNon "Do I skipp this line ?"]} { continue }
		if {[OuiOuNon "Do I remove the wrong characters ?"]} {
		    regsub -nocase {[^ATGCNMKRSYWVHDB]} $Ligne] "" Ligne
		}
		if {[OuiOuNon "Do I replace the wrong characters with 'n' ?"]} {
		    regsub -nocase {[^ATGCNMKRSYWVHDB]} $Ligne] "n" Ligne
		}
	    }
	    if {$LigneKO } { continue }
	    regsub " " $Ligne "" Ligne
	    append Contig $Ligne
	}
	set PotStart "TTAnTTAnTTATGnATGnATG"
	set TratStop "CATnCATnCATAAnTAAnTAA"
	set GrosContig "$PotStart$Contig$TratStop"
	set Tout "$Tout$GrosContig"

	set PotStartPure "nnnnnnnnnnnnnnnnnnnnn"
	set TratStopPure "nnnnnnnnnnnnnnnnnnnnn"
	set GrosContigPure "$PotStartPure$Contig$TratStopPure"
	set ToutPure "$ToutPure$GrosContigPure"

	set DebutContig [expr $FinContig+1]
	set FinContig   [string length $Tout]
	lappend LesBornesDesContigs "CONTIG[format "%4.4d" $NumeroContig] $DebutContig $FinContig"
    }
    Espionne [SauveLesLignes $LesBornesDesContigs dans "$RepertoireDuGenome/fiches/bornesdescontigs"]
    set Sequence [SequenceFormatTFA $Tout $NomDeBapteme "nucbrut"]
    set SequencePure [SequenceFormatTFA $ToutPure $NomDeBapteme.pure "nucbrut"]
    set NomDuFichierCree [Sauve $Sequence dans $FichierACreer]
    set NomDuFichierCreePure [Sauve $SequencePure dans $FichierACreer.pure]
    return $NomDuFichierCree
    return $NomDuFichierCreePure

}

proc ConcateneLesFichiersTFA {Rep FichierFinal} {

    set LesSeq {}
    foreach Fichier [glob -nocomplain "$Rep/*"] {
	lappend LesSeq [ContenuDuFichier $Fichier]
    }
    set ToutesLesSeq [join $LesSeq "\n"]
    #Espionne $ToutesLesSeq
    Sauve $ToutesLesSeq dans $FichierFinal
    return "" 

}

proc ConcateneLesNouveauxFichiersTFA {} {

    set FichierFinal [Entre "Please, enter the output file name"]
    set RepOrigine [ ChoisirUnRepertoire "Repertoire avec toutes les Sequences Tfa"]
    set RepDestination [ ChoisirUnRepertoire "Repertoire pour recevoir les Tfa concatenes"]
    set LesSeq {}
    foreach Fichier [ glob -nocomplain "$RepOrigine/*.tfa"] {
	lappend LesSeq [ContenuDuFichier $Fichier]
    }
    set ToutesLesSeq [join $LesSeq "\n"]
    #Espionne $ToutesLesSeq
    Sauve $ToutesLesSeq dans "$RepDestination/$FichierFinal"
    return $ToutesLesSeq

}

proc ConcernedOrganisms {fileName} {

	set fileToScan [open $fileName "r"]
	set compteur 0
	array set orgas {}
	while {[gets $fileToScan line]!=-1} {
		if {[string index $line 0]==">"} {
			set mots [split $line " "]
			if {[info exists orga([lindex $mots 2],[lindex $mots 3])]} {continue}
			set orga([lindex $mots 2],[lindex $mots 3]) 1
		}
		incr compteur
	}
	set lesOrgas {}
	foreach {key val} [array get orga] {
		set m [split $key ","]
		lappend lesOrgas "[lindex $m 0] [lindex $m 1]"
	}
	close $fileToScan
	return $lesOrgas

}

proc ConcordanceNumerotationDesIntergenes {Ancien Nouveau} {

    global RepertoireDuGenome

    set LesModifies {}


    foreach Ligne [LesLignesDuFichier $Ancien] {
	scan $Ligne "%s %d %d %s %s" A D F O L
	set AncienNom($D,$F) $A
	set AncienNomDebut($D) $A
	set AncienNomFin($F) $A
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNom($D,$F)]} {
	    set Nom [set AncienNom($D,$F)]
	    Espionne "Reprise complete $Nom $N"
	    lappend LesMemes    "$Nom $D $F $O $L"
	    lappend LesNouveaux "$Nom $D $F $O $L"
	    set DejaVu($Ligne) 1
	    set DejaUtilise($Nom) 1
	} else {
	    lappend LesModifies $Ligne
	} 
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNomDebut($D)]} {
	    set Nom [set AncienNomDebut($D)]
	    if { ! [info exists DejaUtilise($Nom)]} {
		Espionne "Reprise debut $Nom $N"
		lappend LesNouveaux "$Nom $D $F $O $L"
		set DejaVu($Ligne) 1
		set DejaUtilise($Nom) 1
	    }
	}
    }

    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	if {[info exists AncienNomFin($F)]} {
	    set Nom [set AncienNomFin($F)]
	    if { ! [info exists DejaUtilise($Nom)]} {
		Espionne "Reprise fin $Nom $N"
		lappend LesNouveaux "$Nom $D $F $O $L"
		set DejaVu($Ligne) 1
		set DejaUtilise($Nom) 1
	    }
	}
    }

    set Numero 10000
    foreach Ligne [LesLignesDuFichier $Nouveau] {
	if {[info exists DejaVu($Ligne)]} { continue }
	scan $Ligne "%s %d %d %s %d" N D F O L
	set Nom [format "INTERGENE%4.4d" [incr Numero -1]]
	Espionne "En desespoir $Nom $N"
	lappend LesNouveaux "$Nom $D $F $O $L"
	set DejaVu($Ligne) 1
	set DejaUtilise($Nom) 1
    }

    set LesNouveaux [lsort -command CompareLesMilieux $LesNouveaux]
    set LesMemes    [lsort -command CompareLesMilieux $LesMemes]
    set LesModifies [lsort -command CompareLesMilieux $LesModifies]
    return $LesNouveaux

}

proc CondenseTaxName {TN} {

    if {[regexp {\(} $TN]} {
	set iO [string last "(" $TN]
	set Nouveau [string trim [string range $TN 0 [incr iO -1]]]
	return $Nouveau
    }
    set G ""
    set E ""
    set R ""
    scan $TN "%s %s %s" G E R
    if {$R==""} { return "" }
    return "$G $E"

}

proc ConfigureRoot {id name} {

    set TId [struct::tree $id]

    set L [list root {} [list name $name length 0. AngAbs 0. ordre 0 theta 0. oldtheta 0. r 0. width 0]]
    $TId deserialize $L

    return "$TId"

}

proc ConfigureVrp {c} {

    global Vrp

    set reg [$c bbox all]
    set border $Vrp(Border)
    set xmin [expr {[lindex $reg 0] - $border}]
    set ymin [expr {[lindex $reg 1] - $border}]
    set xmax [expr {[lindex $reg 2] + $border}]
    set ymax [expr {[lindex $reg 3] + $border}]

    $c configure -scrollregion [list $xmin $ymin $xmax $ymax]

    return

}

proc ConnInfo {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""} {Port ""}} {

    #rR a modifier !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! trop dangereux
 
    if {$Host==""}     { set Host     "ena" }
    if {$DbName==""}   { set DbName   "genoret" }
    if {$User==""}     { set User     "ripp" }
    if {$Password==""} { set Password "postgres" ; append Password [string toupper $User]}
    if {$Sgbd==""}     { set Sgbd     "postgresql" }
    set ConnInfo "host=$Host dbname=$DbName user=$User password=$Password sgbd=$Sgbd"
    
    if {$Port!=""} { append ConnInfo " port=$Port" }    ;#rR rajouté 2015/12/30 
    return $ConnInfo

}

proc ConnInfoBioArrayBase {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "BioArrayBase" }
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoCilioCarta {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "/home/nevers/StageJuin/Database/CilioCarta.db" }
    if {$DbName==""}   { set DbName   "CilioCarta" }
    if {$User==""}     { set User     "" }
    if {$Password==""} { set Password "" }
    if {$Sgbd==""}     { set Sgbd     "sqlite" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoDbgs {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "dbgs" }
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoDomine {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "domine" }
    if {$User==""}     { set User     "brochetx" }
    if {$Password==""} { set Password "dominex" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoEncode {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "Encode" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoFedlord {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "fedlord" }
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoForDatabase {{Database ""} {CreateIfNotExists ""}} {


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

    set database [string tolower $Database]
   
    #attention tout en minuscule
    switch $database {
	"puzz"           { return [ConnInfoPuzz] } 
	"interaction"    { return [ConnInfoInteraction] } 
	"ucschuman18"    { return [ConnInfoUcsc "human18"] } 
	"ucschuman19"    { return [ConnInfoUcsc "human19"] } 
	"ucschuman"      { return [ConnInfoUcsc "human"] } 
	"ucscmouse"      { return [ConnInfoUcsc "mouse"] } 
	"ucscdroso"      { return [ConnInfoUcsc "droso"] } 
	"ucscworm"       { return [ConnInfoUcsc "worm"] } 
	"ucscrat"        { return [ConnInfoUcsc "rat"] } 
	"ucscdog"        { return [ConnInfoUcsc "dog"] } 
	"geneontology"   { return [ConnInfoGeneOntology] } 
	"genoret"        { return [ConnInfoGenoret] } 
	"fedlord"        { return [ConnInfoFedlord] } 
	"dbgs"           { return [ConnInfoDbgs] } 
	"gx"             { return [ConnInfoGx] } 
	"gxdb"           { return [ConnInfoGxDb] } 
	"macsims"        { return [ConnInfoMacsims] } 
	"retinobase"     { return [ConnInfoRetinoBase] } 
	"bioarraybase"   { return [ConnInfoBioArrayBase] } 
	"orthoinspector" { return [ConnInfoOrthoInspector] }
	"gecodb"         { return [ConnInfoGecoDB] }
	"patterndb"      { return [ConnInfoPatternDB] }
	"patterndb18"    { return [ConnInfoPatternDB18] }
	"patterndb19"    { return [ConnInfoPatternDB19] }
	"sanger"         { return [ConnInfoSanger] }
	"sanger18"       { return [ConnInfoSanger18] }
	"sanger19"       { return [ConnInfoSanger19] }
	"encode"         { return [ConnInfoEncode] }
	"domine"         { return [ConnInfoDomine] }
	"syscilia"       { return [ConnInfoSysCilia] }
	"misynpat"       { return [ConnInfoMiSynPat] }
	"string"         { return [ConnInfoString] }
	"default"      {
	    if {[regexp {.(db|sql)$} $Database] && ($CreateIfNotExists || [file exists $Database])} {
		set Host     $Database
		set DbName   [file tail $Host] ; regsub ".(db|sql)$" $DbName "" DbName
		set User     "" 
		set Password "" 
		set Sgbd     "sqlite"
		return [ConnInfo $Host $DbName $User $Password $Sgbd]
	    }
	    return [ConnInfo]
	}
    }

}

proc ConnInfoGecoDB {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "gecoDB" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoGeneOntology {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {[Science]=="ProGS"} { return [ConnInfoGoMiner $Host $DbName $User $Password $Sgbd] }
    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "geneontology" }
    if {$User==""}     { set User     "public" }
    if {$Password==""} { set Password "public" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoGenoret {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "genoret" }
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoGoMiner {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "moby" }
    if {$DbName==""}   { set DbName   "GoMiner" }
    if {$User==""}     { set User     "anno" }
    if {$Password==""} { set Password "ceji387." }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoGx {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "gx" }
    if {$User==""}     { set User "ripp" }
    if {$Password==""} { set Password "postgres" ; append Password [string toupper $User]}
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoGxDb {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "gxdb" }
    if {$User==""}     { set User "ripp" }
    if {$Password==""} { set Password "postgres" ; append Password [string toupper $User]}
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoInteraction {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "interaction" }
    if {$User==""}     { set User     "ripp" }
    if {$Password==""} { set Password "postgres" ; append Password [string toupper $User]}
    if {$Sgbd==""}     { set Sgbd     "postgresql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoMacsims {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "macsims" }
    if {$User==""}     { set User "ripp" }
    if {$Password==""} { set Password "postgres" ; append Password [string toupper $User]}
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoMiSynPat {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "[MiSynPatDir]/misynpat.sql" }
    if {$DbName==""}   { set DbName   "MiSynPat" }
    if {$User==""}     { set User     "" }
    if {$Password==""} { set Password "" }
    if {$Sgbd==""}     { set Sgbd     "sqlite" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoOrthoInspector {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "moby" }
    if {$DbName==""}   { set DbName   "orthoinspector_eukaryota__2011_12" }
    if {$User==""}     { set User     "linard" }
    if {$Password==""} { set Password "mononokee2803" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoPatternDB {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    return [ConnInfoPatternDB18 $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoPatternDB18 {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "patternDB_hg18" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoPatternDB19 {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "patternDB_hg19" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoPuzz {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "puzz" }
    if {$User==""}     { set User     "ripp" }
    if {$Password==""} { set Password "alphaRR" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoRetinoBase {{Host ""} {DbName ""} {User ""} {Password ""}} {

    if {$Host==""}     { set Host "" }
    if {$DbName==""}   { set DbName "BioArrayBase" }
    return [ConnInfo $Host $DbName $User $Password]

}

proc ConnInfoSanger {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    return [ConnInfoSanger18 $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoSanger18 {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "sanger_hg18" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoSanger19 {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "sanger_hg19" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoString {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""} {Port ""}} {

    global ConnInfoStringDefaultDbName
    if {$Host=="DefaultDbName"} { set ConnInfoStringDefaultDbName $DbName }
    if { ! [info exists ConnInfoStringDefaultDbName]} { set ConnInfoStringDefaultDbName "string10" }
    #if {$Host==""}     { set Host     "furi" } ; #rR et port 5431 pour String 9.1 pour Postgresql 9.1
    if {$Host==""}     { set Host     "ena" }
    if {$DbName==""}   { set DbName   $ConnInfoStringDefaultDbName }
    if {$User==""}     { set User     "string" }
    if {$Password==""} { set Password "string" }
    if {$Sgbd==""}     { set Sgbd     "postgresql" }
    if {$Port==""}     { set Port     "5432" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd $Port] ;#rR a rajouté l'option port 2015/12/30

}

proc ConnInfoSysCilia {{Host ""} {DbName ""} {User ""} {Password ""} {Sgbd ""}} {

    if {$Host==""}     { set Host     "studio" }
    if {$DbName==""}   { set DbName   "syscilia" }
    if {$User==""}     { set User     "ripp" }
    if {$Password==""} { set Password "alphaRR" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoUcsc {{DbName ""} {User ""} {Password ""} {Sgbd ""}} {

#    set DbName [string tolower $DbName]
    if {[string tolower $DbName]=="human"      } { set DbName "ucschuman_hg18" }
    if {[string tolower $DbName]=="human18"    } { set DbName "ucschuman_hg18" }
    if {[string tolower $DbName]=="human19"    } { set DbName "ucschuman_hg19" }
    if {[string tolower $DbName]=="ucschuman"  } { set DbName "ucschuman_hg18" }
    if {[string tolower $DbName]=="ucschuman18"} { set DbName "ucschuman_hg18" }
    if {[string tolower $DbName]=="ucschuman19"} { set DbName "ucschuman_hg19" }
    if { ! [regexp "^ucsc" $DbName]} { set DbName "ucsc$DbName" }
    set Host ""
    if {$Host==""}     { set Host     "" }
    if {$DbName==""}   { set DbName   "ucscmouse" }
    if {$User==""}     { set User     "lbgi" }
    if {$Password==""} { set Password "jaimelesfrites" }
    if {$Sgbd==""}     { set Sgbd     "mysql" }
    return [ConnInfo $Host $DbName $User $Password $Sgbd]

}

proc ConnInfoUcscDog {} {

    return [ConnInfoUcsc "dog"]

}

proc ConnInfoUcscDroso {} {

    return [ConnInfoUcsc "dros"]

}

proc ConnInfoUcscHuman {} {

    return [ConnInfoUcsc "human"]

}

proc ConnInfoUcscMouse {} {

    return [ConnInfoUcsc "mouse"]

}

proc ConnInfoUcscRat {} {

    return [ConnInfoUcsc "rat"]

}

proc ConnInfoUcscWorm {} {

    return [ConnInfoUcsc "worm"]

}

proc ConnectMailbox {} {

    global CMDef

    set rep [ConnectServer $CMDef(ServerAddress) $CMDef(UseSSL) $CMDef(Port)]
    if {$rep == 0} {
	return
    } else {
	set CMDef(imapID) $rep
    }
    if {! [LoginServer $CMDef(imapID) $CMDef(Username) $CMDef(Password)]} {
	return
    }

    ::imap4::select $CMDef(imapID) $CMDef(currFolder)

    return

}

proc ConnectServer {address {use_ssl 0} {port ""}} {

    if {$use_ssl} {
	set ::imap4::use_ssl 1
    }

    if {[catch {set imapID [::imap4::open $address $port]}]} {
	puts "Beware !\nI can't connect to the server address :\n$address"
	FaireLire "Beware !\nI can't connect to the server address :\n$address"
	return 0
    } else {
	return $imapID
    }

}

proc ConnexionsAgents {aT} {

    global LNOrdali TAg
    upvar $aT T

    # cherche ensemble d'un agents de s1 vers s2,
    # s2 ver , s3, ... sn vers s01
    
    # T(n,ag) (n ag score) ...

    set done 0
    # iseq : index sequence
    set iseq 0
    set n [lindex $LNOrdali $iseq]
    set nl 0
    foreack k [array names T "$n,*"] {
	lassign [split $k ,] n ag
	lappend tlk($nl) $n $ag
	while {$i < [llength $LNOrdali]} {
	    set Lpair [LiensAgents $i $k]
	    foreach {n1 a1 n2 a2} $Lpair {
		
	    }
	}
	incr nl
    }
    
    return

}

proc ConsGrid {pab} {

    
    global DefautsPipe
    global PipeCollection
    
    set methCons [set DefautsPipe(Conservation,method)]
    if {[string equal -nocase $methCons "Cluster"]} {
	set methCons "Cluster"
    } elseif {[string equal -nocase $methCons "VectorNorm"]} {
	set methCons "VectorNorm"
    } elseif {[string equal -nocase $methCons "MeanDistance"]} {
	set methCons "MeanDistance"
    } elseif {[string equal -nocase $methCons "Ranganathan"]} {
	set methCons "Ranganathan"
    } else {
	puts "Unknown conservation method"
	return 0
    }

    if {$PipeCollection} {
	set fileMacsims [file join [RepertoireDuGenome] "macsims" $pab.xml]
    } else {
	set fileMacsims "[file rootname $pab].macsims.xml"
    }
    if {[file exists $fileMacsims]} {
	catch [AjoutConservationMacsims $fileMacsims $methCons] Mess
	if {$Mess eq ""} {
	    return 1
	} else {
	    return  0
	}
    } else {
	return 0
    }

}

proc ConsacreVersusPredite {Nom} {

    global RepertoireDuGenome
    global ConsacreVersusPredite

    if {[info exists ConsacreVersusPredite($Nom)]} { return [set ConsacreVersusPredite($Nom)] }
    if {[info exists ConsacreVersusPredite("EstCharge")]} { return [set ConsacreVersusPredite("EstCharge")] }

    set Fichier "$RepertoireDuGenome/fiches/consacre_versus_predite"
    if {[file exists $Fichier]} {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    scan $Ligne "%s" NomLu
	    regsub "$NomLu *" $Ligne "" Valeur
	    if {$Valeur==""} { set Valeur "OK" }
	    set ConsacreVersusPredite($NomLu) $Valeur
	}
	set ConsacreVersusPredite("EstCharge") "No value"
	return [ConsacreVersusPredite $Nom]
    }
    set ConsacreVersusPredite("EstCharge") "No values available"
    return [set ConsacreVersusPredite("EstCharge")]

}

proc ConsensusCheck {chr DR} {


# Exploite la procédure de proximité au consensus (RGKTSA)

	set FichierDesDR [open "/genomics/link/STAF/fiches/VDR/DR$DR-Chr$chr.txt" "r"]
	set FichierDesConsensus "/genomics/link/STAF/fiches/VDR/Consensus/DR$DR-Chr$chr.cons"
	if { [file exists $FichierDesConsensus] } {
		file delete $FichierDesConsensus
	}
	while { [gets $FichierDesDR Ligne]  >=0 } {
		ScanLaListe $Ligne ID Start End Brin
		set Sequence [BoutADNDeUcscBoost $Start $End $Brin "Human" $chr "bigZips200603" ]
		if {$Brin == "-"} {
			set Sequence [NucToReverseAndComplementNuc $Sequence]
		}
		set RGKTSA [RGKTSA $Sequence $DR]
		ScanLaListe $RGKTSA Score Mismatch QuelMismatch
		# Espionne $RGKTSA
		if { $Mismatch <= 2} {
			AppendAuFichier $FichierDesConsensus "$Ligne $Sequence $RGKTSA"
		}
}

}

proc ConservHM {Chromosome} {


# Input : localisations chez Human et alignement Human / Mouse
# Process : Recherche si elles existent les séquences mouse alignées et calcule le score
# Output : deux fichiers (conservé/non-conservé)

# Définition des fichiers
set FichierDesLocalisations [open "/tmp/Conservation/localisations3.txt" "r"]
set FichierDesConservesSansGaps "/tmp/Conservation/SbsConservesChezLaSourisSansGapsChr$Chromosome.txt"
set FichierDesConservesAvecGaps "/tmp/Conservation/SbsConservesChezLaSourisAvecGapsChr$Chromosome.txt"
set FichierDesNonConserves "/tmp/Conservation/SbsNonConservesChezLaSourisChr$Chromosome.txt"
set FichierLog "/tmp/Conservation/ConservHMChr$Chromosome.log"

#Effacer les fichier de sortie si ils existent

#if { [file exists $FichierDesConservesSansGaps] } {
#		file delete $FichierDesConservesSansGaps	
#}
#if { [file exists $FichierDesConservesAvecGaps] } {
#		file delete $FichierDesConservesAvecGaps	
#}
#if { [file exists $FichierDesNonConserves] } {
#		file delete $FichierDesNonConserves
#}

# Initialisation
set ListeLoc {}
set input 104330
set RandomOuPas "PasRandom"
set Conservation 0
set ConservesSansGap 0
set ConservesMaisGap 0
set NonConserves 0
Espionne " "
set Chrox $Chromosome
set ConservesTotaux 0
Espionne "Je charge l'alignement du chromosome $Chrox humain avec la souris..."

set AlignementChromosome$Chrox [open "/tmp/ConservationHM/chr$Chrox.hg1.mm8.net.axt" "r"]
set ListeAli$Chrox {}

#Stockage des alignements dans une liste
while { [gets [set AlignementChromosome$Chrox] LigneAli]  >=0 } {

	if {$LigneAli != "" } {
			
			ScanLaListe $LigneAli SeqNum ChromosomeH StartH EndH ChromosomeM StartM EndM Strand Longueur
			set LigneEntete [string range $ChromosomeH 0 2 ]
			
			if {  $LigneEntete == "chr" } {

			set FullLine "$ChromosomeH $StartH $EndH $ChromosomeM $StartM $EndM $Strand $Longueur"
			
			gets [set AlignementChromosome$Chrox] SeqH
			ScanLaListe $SeqH SequenceH
			gets [set AlignementChromosome$Chrox] SeqM
			ScanLaListe $SeqM SequenceM
			
			lappend ListeAli$Chrox "$FullLine $SequenceH $SequenceM"
			set $ChromosomeH ""
			}
	}
}
Espionne "Chargement terminé, balayage en cours..."
#Parcours le fichier des locs puis la liste des séquences alignées
while { [gets $FichierDesLocalisations LigneLoc]  >=0 } {
		incr input
		
		ScanLaListe $LigneLoc  LocChro LocStart LocEnd LocStrand LocHeart LocSeq
	
		if {$Chrox == $LocChro } {
		
			foreach Alignement [set ListeAli$LocChro] {
				set Conservation 0
				ScanLaListe $Alignement ChromosomeH StartH EndH ChromosomeM StartM EndM St ScoreAli SeH SeM
				set RandomOuPas "PasRandom"
				if { [regexp -- {random} $ChromosomeM] } {
					set RandomOuPas "Random"
				}
				if { $LocStart >= $StartH && $LocEnd <= $EndH} {
					#Le SBS se trouve au milieu d'une région conservée
						set StartH [expr $StartH - 1]
						set EndH [expr $EndH - 1]
						set StartM [expr $StartM - 1]
						set EndM [expr $EndM - 1]
						set Start [expr $LocStart - $StartH]
						set Gapped 0
						set Ungapped 0
						incr ConservesTotaux
						foreach Caractere [split $SeH ""] {
							incr Gapped
							if { $Caractere != "-" } {
								incr Ungapped
							}
							if { $Ungapped == $Start } {
								break
							}
						}
							
						if { $LocStrand == "-" } {
							#Petit décalage de 1 en cas de moins, probablement dé au comptage du sens comme un gap
							set SequenceSbsM [string range $SeM [expr $Gapped ] [expr $Gapped + 17 ] ]
							set SequenceSbsH  [string range $SeH [expr $Gapped ] [expr $Gapped + 17 ] ]
							set TrueGapped [expr $Gapped + 1 ]
							set LocSeq [NucToReverseAndComplementNuc $LocSeq]
						} else {
							set TrueGapped $Gapped
							set SequenceSbsM [string range $SeM [expr $Gapped - 1] [expr $Gapped + 16 ] ]
							set SequenceSbsH  [string range $SeH [expr $Gapped - 1] [expr $Gapped + 16 ] ]
							set TrueGapped [expr $Gapped + 1 ]
						}
						
						#Récupération de la séquence mouse de l'alignement précédant le SBS potentiel, avec ses gaps.
						set prelim [string range $SeM 0 $TrueGapped]
						set UngappedM 0
						foreach CaractereM [split $prelim ""] {
														
							# Comptage des gaps précédant le SBS murin
							if { $CaractereM != "-" } {
								incr UngappedM
							}

						}

							set AlignementSbsStartM [expr $Start - $UngappedM]
							set AlignementSbsEndM [expr $AlignementSbsStartM + 17]
					

						
						if { $StrandM == "-"} {
						
						
							set ChromosomeSize [ChromoSize "Mouse" $ChromosomeM ]
							set StartAlignementDansLeBonSensM [expr $ChromosomeSize - $EndM]
							set EndAlignementDansLeBonSensM [expr $ChromosomeSize - $StartM]
							
							set EndSbsDansLeBonSensM [expr $EndAlignementDansLeBonSensM - $UngappedM +1 ]
							set StartSbsDansLeBonSensM [expr $EndSbsDansLeBonSensM - 17]
							
							set SequenceSbsMReverse [NucToReverseAndComplementNuc $SbsM]
											
						} else {
						
							set StartSbsDansLeBonSensM [expr $StartM + $UngappedM - 2]
							set EndSbsDansLeBonSensM [expr $StartSbsDansLeBonSensM + 17]
							set SequenceSbsMReverse $SbsM
						}
						
						if { [ regexp -- {-} $SequenceSbsM ]  || [ regexp -- {-} $SequenceSbsH ] } {
							AppendAuFichier $FichierDesConservesAvecGaps "Staf$input $LocStart $LocEnd $LocStrand $ChromosomeH $StartH $EndH $ChromosomeM $StartM $EndM $StrandM $ScoreAli  $SequenceSbsH $SequenceSbsM 	$StartSbsDansLeBonSensM $EndSbsDansLeBonSensM $SbsMReverse $RandomOuPas"
							incr ConservesMaisGap 1
							set Conservation 1
							break
						} else {
						
						AppendAuFichier $FichierDesConservesSansGaps "Staf$input $LocStart $LocEnd $LocStrand $ChromosomeH $StartH $EndH $ChromosomeM $StartM $EndM $StrandM $ScoreAli  $SequenceSbsH $SequenceSbsM 	$StartSbsDansLeBonSensM $EndSbsDansLeBonSensM $SbsMReverse $RandomOuPas"
							incr ConservesSansGap 1
							set Conservation 1
							break
						}
						
				}
			}
			if {$Conservation != 1 } {
				AppendAuFichier $FichierDesNonConserves "Staf$input $LocStart $LocEnd $LocStrand"
				incr NonConserves
				set Conservation 0
			}
	
} 

}
AppendAuFichier $FichierLog "============================="
AppendAuFichier $FichierLog "= Statistiques de ConservHM ="
AppendAuFichier $FichierLog "============================="
AppendAuFichier $FichierLog " "
AppendAuFichier $FichierLog "SBS potentiels lus : $input"
AppendAuFichier $FichierLog "SBS situés dans une région non-conservée : $NonConserves"
AppendAuFichier $FichierLog "SBS situés dans une région conservée : $ConservesTotaux"
AppendAuFichier $FichierLog "-- SBS sans gaps : $ConservesSansGap"
AppendAuFichier $FichierLog "-- SBS avec gaps : $ConservesMaisGap"

}

proc ConservScore2 {SequenceSbsH SequenceSbsM LocStrand} {


#Attribue un score aux SBS murins par rapport aux SBS humains

#Initialisations
set CompteurScore 0
set Score 0.000
set PosiScore 0.000
set H 0
set M 0
for { set J 1 } { $J <= 18 } { incr J } {
	set CaractereM$J " "
	set CaractereH$J " "
}
#On met les séquences dans le sens xxCCC pour pouvoir éliminer celles sans C4 ou C5
	if { $LocStrand == "-" } {
		set SequenceSbsH  [NucToReverseAndComplementNuc $SequenceSbsH]
		set SequenceSbsM  [NucToReverseAndComplementNuc $SequenceSbsM]
	}
	foreach CaractereHuman [split $SequenceSbsH ""] {
		incr H
		set CaractereH$H $CaractereHuman
	}
	foreach CaractereMouse [split $SequenceSbsM ""] {
		incr M
		set CaractereM$M $CaractereMouse
	}
		
	for { set I 1 } { $I <= 18 } { incr I } {
		
		if { [set CaractereM$I] == [set CaractereH$I] } {
			set PosiScore 1.000
		} else {
			
			set PosiScore [StafPosiScore $I [set CaractereM$I]]
			
		}
		
		set Score [expr $Score + $PosiScore]
		
	}
	
	return $Score


}

proc ConservationDesMutations {system} {

    set mdb "rootmis"
    sqlite3 $mdb [file join [MiSynPatDir] misynpat.sql]

    set Lmut [$mdb eval {select m.variant1, m.variant2 from mutation as m, synthetase as s where s.sname = $system and s.pk_synthetase=m.pk_synthetase}]

    set Lhtml [list]
    lappend "
"
    lappend Lhtml "
Conservation of affected residues :
"
    lappend Lhtml "Total number of reported mutations : [llength [lsort -unique $Lmut]]
"
    if {[llength $Lmut] == 0} {
	$mdb close
	return "[join $Lhtml \n]"
    }
    
    set sali [string toupper [string index $system 0]]
    if {$sali eq "F"} {
	set sali "Fb"
    }
    set humi "${sali}mito_Homo.sapi"
    set Lcons {}
    set ncon 0
    set feat "Cons-T80"
    if {[info exists ::TabSF($humi,$feat)]} {
	set Lft $::TabSF($humi,$feat)
    } else {
	lappend Lhtml "No $feat for $humi !\n"
	set Lft [list]
    }
    
    set ::ListePDB [list]
    foreach ft $Lft {
	DecortiqueUneFeature $ft deb fin col ssc note sys
	for {set i $deb} {$i <= $fin} {incr i} {
	    set no [DonnePosGS $humi $i]
	    lappend Lcons $no $note
	}
    }

    foreach k {"IdenGlob" "ConsGlob" "SimiGlob" "nocons"} {
	set Tc($k) [list]
    }

    foreach mut $Lmut {
	if {[string index $mut 0] ne "X"} {
	    set no [string range $mut 1 end-1]
	    lappend Lrmut $no
	}
    }
    set Lrmut [lsort -unique -integer $Lrmut]
    set nMis [llength $Lrmut]
    lappend Lhtml "Total number of missense+nonsense mutations : $nMis
"

    foreach no $Lrmut {
	set ires [lsearch -exact $Lcons $no]
	if {$ires > -1} {
	    set type [lindex $Lcons $ires+1]
	    lappend Tc($type) $no
	} else {
	    lappend Tc(nocons) $no
	}
    }

    set nmc 0
    foreach k {"IdenGlob" "ConsGlob" "SimiGlob"} {
	incr nmc [llength $Tc($k)]
    }
    lappend Lhtml "Total number of mutation affecting conserved mutations : $nmc
"
    lappend Lhtml "
"
    foreach k {"IdenGlob" "ConsGlob" "SimiGlob" "nocons"} tit {"affected residues 100% conserved" "affected residues > 80% conserved" "affected residues physicochemically conserved" "affected residues not conserved"} {
	lappend Lhtml ""
    }
    lappend Lhtml "
$tit
:
[llength [set Tc($k)]]
(residues [set Tc($k)])

"

    $mdb close
    
    return "[join $Lhtml \n]"

}

proc ConserveLesDomaines {FichierMSF FichierBornes Ref NouveauFichierMSF} {

    global TmpTFAsDuMSFMemo NomDuFichierMSFMemo
    if {[info exists TFAsDuMSFMemo] && $NomDuFichierMSFMemo==$FichierMSF} {
	set TmpTFA $TmpTFAsDuMSFMemo
    } else { 
	set TFAs [CreeLeTFAsDuMSF $FichierMSF]
	set TmpTFAs [Sauve $TFAs dans [TmpFile]]
	set TmpTFAsDuMSFMemo $TmpTFAs
	set NomDuFichierMSFMemo $FichierMSF
    }
    set LesBornesGlobales {}
    set LesBornesDesManquants [list 1]
    foreach Ligne [LesLignesDuFichier $FichierBornes] {
	if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
	scan $Ligne "%d %d" D F
	set DG [PositionDansMSF Global $FichierMSF $D $Ref]
	set FG [PositionDansMSF Global $FichierMSF $F $Ref]
	Espionne "$DG $FG"
	lappend LesBornesDesManquants [expr $DG-1]
	lappend LesBornesDesManquants [expr $FG+1]
	lappend LesBornesGlobales $DG $FG
    }
    lappend LesBornesDesManquants "end"

    if {[file exists bornes_des_manquants]} { file delete bornes_des_manquants }
    foreach {A B} $LesBornesDesManquants {
	AppendAuFichier bornes_des_manquants "$A $B"
    }

    foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] {
	set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]]
#	regsub -all {\.} $Seq "-" Seq
	set LesZones {}
	foreach {D F} $LesBornesGlobales {
	    set Zone [string range "x$Seq" $D $F]
	    Espionne "$D $F $Zone"
	    lappend LesZones $Zone
	}
	set NouvSeq [join $LesZones "-"]
	set NouvTFA [SequenceFormatTFA $NouvSeq "$Access" "protbrut"]
	lappend LesTFAs $NouvTFA
    }
    regsub ".msf$" $NouveauFichierMSF "" NouveauFichierTFAs
    append NouveauFichierTFAs ".tfas"
    set NouveauFichierTFAs [SauveLesLignes $LesTFAs dans $NouveauFichierTFAs]
    return [ConvertToMsf $NouveauFichierTFAs $NouveauFichierMSF

}

proc ConstruitSequenceNucleic {nA nG nC nT} {


    Wup "Construit une sequence ADN ordonnee avec le nombre de ATGC voulus"
    Wup "Interessant pour tester le Tm avec un nombre de GC ou AT different" 

    for {set x 0} {$x<$nA} {incr x} {append Seq "A"}
    for {set x 0} {$x<$nT} {incr x} {append Seq "T"}
    for {set x 0} {$x<$nG} {incr x} {append Seq "G"}
    for {set x 0} {$x<$nC} {incr x} {append Seq "C"}
    return $Seq

}

proc ContenuDuFichier {{Fichier ""}} {

    if { $Fichier == "" } {return ""}
    if {[regexp -nocase {https?\://|ftp\://} $Fichier]} { return [HttpCopy $Fichier] }              ;#rR 2014/07/02
    if {[regexp         {\.gz$}              $Fichier]} { return [exec zcat $Fichier] }

    if {[regexp -nocase {(\.jpg|\.gif|\.png)$} $Fichier]} {
	set f [open $Fichier r]
	fconfigure $f -translation binary
	set Texte [read $f]
    } else {
	set f [open $Fichier r]
	set Texte [read -nonewline $f]
    }

    close $f
    return $Texte

}

proc ContenuDuFichierAvecReferences {Fichier {LesTextesRefs ""} {Ref NoRefAtAll}} {


    if {$Ref!="NoRefAtAll"} { set LesTextesRefs [list $LesTextesRefs $Ref] }
    if {$LesTextesRefs!={}} {
	set Page [ContenuDuFichier $Fichier]
	foreach {T R} $LesTextesRefs {
	    regsub -all $T $Page [H_Href $T $R] Page
	}
	return $Page
    }

    set Nom [file tail $Fichier]
    set Rep [file tail [file dirname $Fichier]]
    if {$Rep=="aliinout"} {
	set LeTexte {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    set Access ""
	    scan $Ligne "%s %s" BanqueId Access
	    set LigneAvecRef [InsereHrefAccessDans $Ligne $BanqueId $Access]
	    lappend LeTexte $LigneAvecRef
	}
	return [join $LeTexte "\n"]
    }
    if {$Rep=="infos"} {
	set LeTexte [list "<<>>"
	return [join $LeTexte "\n"]
    }
    return [ContenuDuFichier $Fichier]

}

proc ContenuDuFichierLUUUC {Fichier} {


    if { $Fichier == "" } {return ""}
    
#    if {[regexp -nocase {https?\://|ftp\://} $Fichier]} { return [HttpGetTextFromUrl $Fichier] }
    if {[regexp -nocase {https?\://|ftp\://} $Fichier]} { return "tot" }
#puts $Fichier
    set f [open $Fichier r]
    set Texte [read -nonewline $f]
    close $f
    return $Fichier
    #return "tata"

}

proc ContenuDuFichierSansAccent {Fichier} {

    set R [exec uni2ascii -q -B $Fichier]
    return $R

}

proc ContenuEnGC {s} {

    set l [string length [set s [string map [list "." ""] $s]]]
    if {$l == 0} {
	return [list 0.0 0.0 0.0 0.0]
    }
    set Lres [list]
    foreach n [list A C G T] {
	set n$n [expr {$l-[string length [string map [list $n ""] $s]]}]
	lappend Lres [expr {100.*[set n$n]/$l}]
    }

    return $Lres

}

proc ContenuMisAJourDuFichier {Fichier} {

    set Texte [ContenuDuFichier $Fichier]
    while {[regexp {_([A-Z][a-zA-Z0-9]+)_} $Texte Match Pro]} {
	if {[regexp "isn't a procedure" [info args $Pro]]} { continue }
	set Val [$Pro]
	regsub $Match $Texte $Val Texte 
    }
    return $Texte

}

proc ContenuSubstitueDuFichier {Fichier args} {

    if { $Fichier == "" } {return ""}
    set f [open $Fichier r]
    set Texte [read -nonewline $f]
    close $f
    set I 0
    foreach argument $args {
	set VariableN "(\[^\\\\])\\$${I}(\[^0-9\])" 
	regsub -all {&} $argument {\\&} argument
	regsub -all $VariableN $Texte "\\1$argument\\2" Texte
	incr I
    }
    regsub -all {\\(\$[0-9])} $Texte "\\1" Texte
    return $Texte

}

proc ContientOuPas {Expression1 Expression2} {

    foreach Nom [ListeDesPABs] {
	set GO [InterrogeFichierFinal $Nom GO]
	set Pathway [InterrogeFichierFinal $Nom Pathway]
	set PFAM [InterrogeFichierFinal $Nom PFAM]
	if {([regexp -nocase "$Expression1" $GO] || [regexp -nocase "$Expression1" $Pathway] || [regexp -nocase "$Expression1" $PFAM]) && ([regexp -nocase "$Expression2" $GO] || [regexp -nocase "$Expression2" $Pathway] || [regexp -nocase "$Expression2" $PFAM])} {lappend Liste $Nom}
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    Espionne [llength $Liste]
    return $Liste

}

proc ContigComplet {AccessDuFragment} {


    if {[regexp "^Chro0_" $AccessDuFragment]} { return "" }

    set AccessDuContig [AccessDuContigDuFragment $AccessDuFragment]

    set TFA [ContigEnStock $AccessDuContig]
    if {$TFA!=""} { return $TFA }

    if {[regexp -nocase {[a-z]+[0-9]*_[a-z]+} $AccessDuFragment]} {
	regsub "_" $AccessDuFragment ":"  AccessAChercher
    } else {
	set AccessAChercher $AccessDuFragment
    }

    set LeFragmentOrigine [LaSequenceDesBanques $AccessAChercher $AccessAChercher AccessOK "OnVeutNature"]
    if {$LeFragmentOrigine=={}} {
	if { ! [regexp {_[0-9]+} $AccessAChercher]} {
	    foreach Fra {"01" "1" "001" "0001"} {
		set FragmentAChercher "${AccessAChercher}_$Fra"
		set LeFragmentOrigine [LaSequenceDesBanques $FragmentAChercher $FragmentAChercher AccessOK "OnVeutNature"]
		if {$LeFragmentOrigine!={}} { break }
	    }
	}
	if {$LeFragmentOrigine=={}} { return "" }
    }

    regexp -nocase {^[a-z][a-z0-9]*(\:|_)} $AccessDuFragment Chro
    regsub "_" $Chro ":" Chro

    set OnAttendSplit 1
    set OnAttendFragment 0
    set nSeqLues 0
    set Tout ""
    foreach Ligne $LeFragmentOrigine {
	if {$OnAttendSplit} {
	    if { ! [regexp "Sequence split into" $Ligne]} { continue }
	    set nSeq [IntegerApres "Sequence split into" dans $Ligne]
	    set OnAttendSplit 0
	    set OnAttendFragment 1
	    continue
	}
	if {$OnAttendFragment} {
	    if { ! [regexp "Fragment Name" $Ligne]} { continue }
	    set OnAttendFragment 0
	    continue
	}
	scan $Ligne "%s %d %d" Access Debut Fin
	set Access "$Chro$Access"
	set LeFragment [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNature"]
	if {$LeFragment=={}} { return "" }
	lappend LesFragments $Access
	set TFA [SequenceFormatTFA_l $LeFragment $Access "gcg"]
	set Seq [QueLaSequenceDuTexteTFA $TFA]

	if {[incr nSeqLues]<$nSeq} {
	    set Seq [string range $Seq 0 end-10000]
	}
	append Tout $Seq
	if {$nSeqLues==$nSeq} { break }
    }
    if {$OnAttendSplit} {
	set TFA [SequenceFormatTFA_l $LeFragmentOrigine $AccessDuContig "gcg"]
    } else { 
	set Entete "$AccessDuContig complete contig made with fragments [lindex $LesFragments 0] to [lindex $LesFragments end]"
	set TFA [SequenceFormatTFA $Tout $Entete "nucbrut"]
    }
    ContigEnStock $AccessDuContig $TFA
    return $TFA

}

proc ContigDuPAB {Nom} {

    global RepertoireDuGenome
    global ContigDuPAB
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }


    if {[info exists ContigDuPAB($Nom)]} { return [set ContigDuPAB($Nom)] }
    if {[info exists ContigDuPAB("EstCharge")]} { return 0 }

    set FichierBornesDesContigs "$RepertoireDuGenome/fiches/bornesdescontigs"
    set ContigDuPAB("EstCharge") "EstCharge"
    if { ! [file exists $FichierBornesDesContigs]} {
	return 0
    } else {
	foreach Ligne [LesLignesDuFichier $FichierBornesDesContigs] {
	    scan $Ligne "%s %s %s" Contig Debut Fin
	    lappend LesDebuts $Debut
	    lappend LesFins   $Fin
	    set Contigs($Debut) $Contig
	    set Fins($Debut) $Fin
	}
	foreach Boite $ListeDeBoites {
	    set NomLu  [Box $Boite nom]
	    set Debut  [Box $Boite debut]
	    set Fin    [Box $Boite fin]
	    set Orient [Box $Boite orient]
	    foreach DC $LesDebuts {
		if { $Debut < $DC } { continue }
		set ContigDuPAB($NomLu) "[set Contigs($DC)] $DC [set Fins($DC)]"
	    }
	}
	return [ContigDuPAB $Nom]
    }

}

proc ContigDuPremierHitDuBlast {Nom} {

    set Loc [PolyLocalise $Nom ]
    #Espionne "loc apres MRM: $Loc"
    if { $Loc!="NoBlastFile" && $Loc!="NoLocalization"} {
	set LesLocs [LesLocalisationsSurChroContig $Nom]
	set PremiereLoc [lindex $LesLocs 0]
	scan $PremiereLoc "%s %s %d %d %s" Chro Cont Gauche Droite Orient
	set Contig [AjouteUnUnderscore $Cont 2]
	return $Contig
    } else {return ""}

}

proc ContigEnStock {Access {TFA ""}} {

    global RepertoireDuGenome

    global IgnoreStockcontigs
    if {[info exists IgnoreStockcontigs] && $IgnoreStockcontigs} { return "" }

    set SizePlease 0
    if {[regexp -nocase {^SizePlease$} $TFA]} {
	set TFA ""
	set SizePlease 1
    } 

    set FileNamePlease 0
    if {[regexp -nocase {^FileNamePlease$} $TFA]} {
	set TFA ""
	set FileNamePlease 1
    } 

    regsub {_[0-9]+$} $Access "" Access 
    regsub {\:} $Access "_" Access
    set Access [string toupper $Access]
    
    set Stock "$RepertoireDuGenome/stockcontigs"
    while { ! [file exists $Stock]} {
	if {[OuiOuNon "$Stock doesn't exist.\nDo I link to an existing directory ?"]} {
	    set Ancien [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
	    if {$Ancien==""} { continue }
	    exec ln -s $Ancien $Stock
	    continue 
	}
	if {[OuiOuNon "$Stock doesn't exist.\nDo I create directory ?"]} {
	    File mkdir $Stock
	    continue
	}
	if {[OuiOuNon "Do I ignore all about stockcontigs ?"]} { set IgnoreStockcontigs 1 ; return "" }
    }

    set Fichier "$Stock/$Access"

    if {$SizePlease} {
	if {[file exists $Fichier]} {
	    return [string length [QueLaSequenceDuTFA $Fichier]]
	} else {
	    return -1
	}
    }

    if {$FileNamePlease} {
	if {[file exists $Fichier]} {
	    return $Fichier
	} else {
	    return ""
	}
    }

    if {$TFA==""} {
	if {[file exists $Fichier]} { return [ContenuDuFichier $Fichier] }
	return ""
    }

    if {[string index $TFA 0]!=">"} {
	FaireLire "You want to store an illegal file format in $Fichier"
	return ""
    }
	
    return [Sauve $TFA dans $Fichier]

}

proc ContractMask {aT rx ry rz} {

    upvar $aT T

    array set Q [array get T]

    # rajoute 1 rangee en -1 et au bord sup
    # en Z
    for {set i 0} {$i < $rx} {incr i} {
	for {set j 0} {$j < $ry} {incr j} {
	    set T($i,$j,$rz) 0
	    set T($i,$j,-1) 0
	}
    }
    # en Y
    for {set i 0} {$i < $rx} {incr i} {
	for {set k 0} {$k < $rz} {incr k} {
	    set T($i,$ry,$k) 0
	    set T($i,-1,$k) 0
	}
    }
    # en X
    for {set j 0} {$j < $ry} {incr j} {
	for {set k 0} {$k < $rz} {incr k} {
	    set T($rx,$j,$k) 0
	    set T(-1,$j,$k) 0
	}
    }

    
    for {set i 0} {$i < $rx} {incr i} {
	for {set j 0} {$j < $ry} {incr j} {
	    for {set k 0} {$k < $rz} {incr k} {
		set Q($i,$j,$k) [expr {[set T([expr {$i-1}],$j,$k)] && [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T([expr {$i+1}],$j,$k)] && [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,[expr {$j-1}],$k)] && [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,[expr {$j+1}],$k)] && [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,$j,[expr {$k-1}])] && [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,$j,[expr {$k+1}])] && [set Q($i,$j,$k)]}]
	    }
	}
    }

    unset T
    array set T [array get Q]

    return

}

proc ContraintesCap3 {FichierSequence {DistanceMin 50} {DistanceMax 2000}} {

    set fichierOut "$FichierSequence.con"

    array set tfa [readFasta $FichierSequence]
    
    array set lesNoms {}
    foreach nom $tfa(index) {set lesNoms($nom) ""}

    foreach nom $tfa(index) {
	if {[regexp {^(.*)FM.\.SCF$} $nom regMatch cloneForward]} {
	    set cloneReverse [array names lesNoms -regexp "^${cloneForward}R"]
	    if {[llength $cloneReverse] > 1} {
		Espionne "Plus 1 clone reverse ??"
		Espionne $nom
		Espionne $cloneReverse
		exit 1
	    }
	    if {[llength $cloneReverse] == 1} {
		Espionne "$nom <-> $cloneReverse"
		unset lesNoms($cloneReverse)
		set lesNoms($nom) $cloneReverse
	    } else {
		unset lesNoms($nom)
	    }
	}
    }

    set out [open $fichierOut "w"]

    foreach nom [array names lesNoms] {
	if {$lesNoms($nom) != ""} {
	    puts $out [format "%s %s %9d %9d" $nom $lesNoms($nom) $DistanceMin $DistanceMax]
	}
    }

    close $out

}

proc Convert2GI {db Lid} {

    return [eSearchREST $db $Lid]

}

proc Convert2RefSeq {Lid} {

    set Lrep [ConvertGI2RefSeq $Lid]
    set Lrep [ConvertUniProt2RefSeq $Lrep]

    # try to match unknowns ... usually strange 
    # NCBI numbers from genomes
    set Lunk [list]
    foreach n $Lid r $Lrep {
	if {[EstUnRefseq $r] || [EstUnAccessPDB $r]} {
	    continue
	}
	lappend Lunk $n
    }
    # all found ! nice ...
    if {$Lunk == {} } {
	return $Lrep
    }

    # try to find an existing refseq access
    set Lgi [eSearchREST protein $Lunk]
    if {$Lgi == {} } {
	#  nothing found , return
	return $Lrep
    }
    array set T [eSummaryREST protein $Lgi]
    foreach n $Lunk gi $Lgi {
	if {[info exists T($gi,refseq)] && [set T($gi,refseq)] ne ""} {
	    set i [lsearch $Lid $n]
	    lset Lrep $i [set T($gi,refseq)]
	}
    }
    update

    return $Lrep

}

proc Convert2UniProtAcc {LId} {

    set LId [CheckIdsAsList $LId]
    # takes any ID list and tries to find their 
    # UniProt equivalents if any.
    # Output is in the same order as input.
    # For IDs with no UniProt matching, return ID
    set Lrep [ConvertRefSeq2UniProtAcc $LId]
    set Lrep [ConvertGenBankEMBL2UniProtAcc $Lrep]
    set Lrep [ConvertGI2UniProtAcc $Lrep]
    set Lrep [ConvertUniProt2UniProtAcc $Lrep]

    return $Lrep

}

proc ConvertAllGCG {{Rep ""} {Ext .seq}} {

    if {$Rep==""} { set Rep [ChoixDuRepertoire [RepertoireDuGenome]]}
    if {$Rep==""} { return "" }

    foreach Fichier [glob "$Rep/*$Ext"] {
	set Entete ""
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp {\.\. *$} $Ligne]} {break}
	    if {[regexp "!!NA_SEQUENCE" $Ligne]} { continue }
	    append Entete $Ligne
	}
	set Entete [string trim $Entete]
	scan $Entete "%s" Access
	set Access [lindex [split $Access "|"] 1]
	set DE [StringSuivant " " dans $Entete]
	set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] "$Access $DE" "gcg"]
	lappend LesTFAs $TFA
    }
    Espionne [SauveLesLignes $LesTFAs dans "$Rep/../all.tfas"]
    exit

}

proc ConvertFastaToNib {Input Output} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "faToNib is the BLAT utility to convert fasta files into .nib files (BLAT)"
    Wup "This step is necessary to be able to load the database in memory for gfServer"

    set faToNib "[BLATDIR]/faToNib"

    set CommandeBlat "$faToNib $Input $Output" 

    if {[catch {eval exec $CommandeBlat} Message]} {
	Espionne "Problem with $Output"
	Espionne $Message
    }
    return ""

}

proc ConvertFastaToNibPourTous {dir} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "faToNib is the BLAT utility to convert fasta files into .nib files (BLAT)"
    Wup "This step is necessary to be able to load the database in memory for gfServer"
    
    set Suffixes [list ".fa" ".fasta" ".tfa"]
    
    set LesFichiers ""

    foreach Suf $Suffixes {
	if {$LesFichiers != ""} {continue}
	set  LesFichiers [glob -nocomplain -directory "$dir" "*${Suf}"]
    }
    
    foreach File $LesFichiers {
	set OutFile ""
	regsub -nocase {.[a-z]+$} $File {.nib} OutFile

	ConvertFastaToNib $File $OutFile
	#Espionne "ConvertFastaToNib $File $OutFile"
    }
    return ""

}

proc ConvertFastaToUniprotStandard {Fichier NewFichier} {

    if { ! [regexp {^.+_([0-9]+).fasta$} $Fichier Match OX]} { return "" }
    set OS [Tax $OX Name]
    if {$OS==""} { return "" }

    if {[regexp "_new_$OX.fasta" $Fichier] && [regexp {OR=} [PremiereLigneDuFichier $Fichier]]} {
	Espionne "$Fichier is already converted"
	return "$OX is already converted"
    }

    set LeNew {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "^>" $Ligne]} { lappend LeNew $Ligne ; continue }
	scan $Ligne "%s" Access
	regsub -all ">" $Access "" Access
	set Gene "" ; regexp { gene=([^ ]+) }            $Ligne Match Gene
	set Tran "" ; regexp { transcript=([^ ]+) }      $Ligne Match Tran
	set Prod "" ; regexp { gene_product=([^\|]+) \|} $Ligne Match Prod
	#if {$Gene!=""} { set Access "$Gene" }
	if {$Tran!=""} { set Access "$Tran" }
	set Origine $Ligne
	regsub -all ">"  $Origine ""  Origine
	regsub -all "="  $Origine ":" Origine
	regsub -all {\|} $Origine ""  Origine
	regsub -all { +} $Origine " " Origine
	set Origine [string trim $Origine]

	set TexteProd ""
	if { 0 && $Prod!=""} { set TexteProd " $Prod" }         ; #rR attention on ne met plus Prod

	set TexteGN ""
	if {$Gene!=""} { set TexteGN " GN=$Gene" }
	set Entete ">${Access}_$OX OS=$OS$TexteGN OR=$Origine"
	lappend LeNew $Entete
    }
    SauveLesLignes $LeNew dans $NewFichier
    return $OX

}

proc ConvertGI2GenBank {LId} {

    # NCBI GI <-> NCBI Refseq
    # use eSummary and eLink when unsuccessfull
    # 
    # returns a list of the refseq equivalents.
    # if a GI has no refseq equivalent, a empty
    # string is then set
    
    set Lref [list]
    set aT [eSummaryREST protein $LId]
    array set T $aT
    foreach n $LId {
	if {! [info exists T($n,genbank)]} {
	    set acc ""
	} else {
	    set acc [set T($n,genbank)]
	}
	
	if {[info exists T($n,ReplacedBy)] && [set T($n,ReplacedBy)] ne ""} {
	    puts "  ==> $n -> [set T($n,ReplacedBy)]"
	}
	
	# if does not exists , try using eLink
	if {0 && $acc eq ""} {
	    set Lel [eLinkREST protein protein $n]
	    if {$Lel ne ""} {
		unset -nocomplain Ttmp
		set at [eSummaryREST protein $Lel]
		array set Ttmp $at
		foreach ne $Lel {
		    if {[info exists Ttmp($ne,refseq)]} {
			set acc [set Ttmp($ne,refseq)]
		    }
		    if {$acc ne ""} {
			set n $ne
			break
		    }
		}
	    }
	}
	
	if {$acc eq ""} {
	    lappend Lref $n
	} else {
	    lappend Lref $acc
	}
    }
    
    return $Lref

}

proc ConvertGI2RefSeq {LId} {

    # NCBI GI <-> NCBI Refseq
    # use eSummary and eLink when unsuccessfull
    # 
    # returns a list of the refseq equivalents.
    # if a GI has no refseq equivalent, a empty
    # string is then set
    
    set Lref [list]
    set aT [eSummaryREST protein $LId]
    array set T $aT

    foreach n $LId {
	if {! [info exists T($n,refseq)]} {
	    set acc ""
	} else {
	    set acc [EnleveVersionDeAccess [set T($n,refseq)]]
	}
	
	if {[info exists T($n,ReplacedBy)] && [set T($n,ReplacedBy)] ne ""} {
	    set acc [EnleveVersionDeAccess $T($n,ReplacedBy)]
	}
	
	if {$acc eq ""} {
	    lappend Lref $n
	} else {
	    lappend Lref $acc
	}
    }
    
    return $Lref

}

proc ConvertGI2UniProtAcc {LId} {

    set LId [CheckIdsAsList $LId]
    # returns the ID list in the same order
    # replacing all possible IDs by their 
    # UniProt Accession when possible.
    # Otherwise, keep the original ID

    set ToAcc [IDMapping P_GI ACC $LId]
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertGenBank2UniProtAcc {LId} {

    # returns the ID list in the same order
    # replacing all possible IDs by their 
    # UniProt Accession when possible.
    # Otherwise, keep the original ID

    set ToAcc [IDMapping EMBL_ID ACC $LId]
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertGenBankEMBL2UniProtAcc {LId} {

    set LId [CheckIdsAsList $LId]
    # returns the ID list in the same order
    # replacing all possible IDs by their 
    # UniProt Accession when possible.
    # Otherwise, keep the original ID

    set ToAcc [IDMapping EMBL_ID ACC $LId]
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertMSF2XML {{FichierMSF ""} {OutputXML ""}} {


    Wup "Permet de convertir un fichier .msf en fichier .xml"
    
    if {$FichierMSF==""} {return "-1"}

    #Conversion du fichier msf
    set Clustal "clustalw"
    #set Clustal "/biolo/clustal/bin/clustalw"

    set Commande "$Clustal $FichierMSF -convert -output=relacs"
    if {$OutputXML != ""} {
	append Commande " -outfile=${OutputXML}"
    }

    catch {   unset   ClustalOut}
    if {[catch {set   ClustalOut [eval exec $Commande]} Message]} {
	Espionne ">>>ConvertMSF2XML $FichierMSF"
	Espionne "pb $Message"
	return "-1"
    } else {
	return "1"
    }

}

proc ConvertRefSeq2UniProtAcc {LId} {

    set LId [CheckIdsAsList $LId]
    # returns the ID list in the same order
    # replacing all possible IDs by their 
    # UniProt Accession when possible.
    # Otherwise, keep the original ID

    set ToAcc [IDMapping P_REFSEQ_AC ACC $LId]
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertToMsf {{Source ""} {GetWhat ""}} {

    set CleanSource 0
    if {[regexp "\n" $Source]} {
	set FiSource "[TmpFile].xxx"
	Sauve $Source dans $FiSource
	set CleanSource 1
    } elseif { [llength $Source] > 1 } {
	set FiSource "[TmpFile].xxx"
	SauveLesLignes $Source dans $FiSource
	set CleanSource 1
    } else {
	set FiSource $Source
	if {[FileAbsent $FiSource]} { return "" }
    }
    set FiMsf $GetWhat
    set CleanDestin 0
    if {$GetWhat==""} { set GetWhat "GetText" }
    if {$GetWhat=="GetText" || $GetWhat=="GetLines"} {
	set FiMsf "[TmpFile].msf"
	set CleanDestin 1
    }
    if {$GetWhat=="GetFile"} {
	set FiMsf $FiSource
	regsub {\.(rsf|tfa|tfas|msf)$} $FiMsf "" FiMsf
	append FiMsf ".msf"
    }
    if {[catch {exec clustalw $FiSource -convert -outorder=input -output=gscope -outfile=$FiMsf} Message]} {
	Warne $Message
	set GetWhat "Error"
    }
    set Retour ""
    if {$GetWhat=="GetText"}  { set Retour [ContenuDuFichier $FiMsf] }
    if {$GetWhat=="GetLines"} { set Retour [LesLignesDuFichier $FiMsf] }
    if {$GetWhat=="GetFile"}  { set Retour $FiMsf }
    if {$CleanSource && [file exists $FiSource]} { file delete $FiSource }
    if {$CleanDestin && [file exists $FiMsf]}    { file delete $FiMsf }
    return $Retour

}

proc ConvertToOneHundred {In Out} {

    if {[regexp "NoSequencesToAlign" [PremiereLigneDuFichier $In]]} {
	File copy -force $In $Out
	return $Out
    }
    set Tmp [TmpFile]
    set LeDebut {}
    set YADebut 0
    foreach Ligne [LesPremieresLignesDuFichier $In 10] {
	if {[regexp -nocase {Name *\: } $Ligne]} { break }
	set YADebut 1
	lappend LeDebut $Ligne
    }
    if {[catch {exec clustalw $In -convert -output=gscope -outfile=$Tmp} Message]} {
	Warne "Clustalw couldn't convert the msf to 100 : \n$Message"
	File copy -force $In $Out
	return $Out
    }
    set LeNouveau $LeDebut
    set OnAttendName 1
    foreach Ligne [LesLignesDuFichier $Tmp] {
	if {$YADebut && $OnAttendName && ! [regexp -nocase {Name *\: } $Ligne]} { continue }
	set OnAttendName 0
	lappend LeNouveau $Ligne
    }
    file delete -force $Tmp
    return [SauveLesLignes $LeNouveau dans $Out]

}

proc ConvertToOneHundredPourTous {{RepIn ""} {RepOut ""}} {

    if {$RepIn==""} {
	set RepIn "[RepertoireDuGenome]/msf"
    }
    if {$RepOut==""} {
	set RepOut "$RepIn.100"
	if { ! [file exists $RepOut]} { file mkdir $RepOut }
    }
    foreach Nom [ListeDesPABs] {
	set In  "$RepIn/$Nom"
	set Out "$RepOut/$Nom"
	Espionne "ConvertToOneHundred $In $Out"
	if { ! [file exists $In]} { continue }
	ConvertToOneHundred $In $Out
    }

}

proc ConvertToPkMacsSeq {aMacs {aSeq ""}} {

    upvar $aMacs Macs
    if {$aSeq!=""} { upvar $aSeq  Seq } else { set Seq 1 }
    if { ! [IsPk $Macs]} { set Macs [SqlExec "select pk_macsims from macsims where name = '$Macs'"] }
    if { ! [IsPk $Macs]} { return 0 }
    if { ! [IsPk $Seq]} { set Seq [SqlExec "select pk_seq from seq where name='$Seq' and pk_macsims=$Macs"] }
    if { ! [IsPk $Seq]} { return 0 }
    return 1

}

proc ConvertUCSCFastaToNibPourTous {Genome} {


    Wup "BLAT program is BLAST Like Alignment Tool"
    Wup "faToNib is the BLAT utility to convert fasta files into .nib files (BLAT)"
    Wup "This step is necessary to be able to load the database in memory for gfServer"
    Wup "Special case for UCSC genomes"
    
    #set Suffixes [list ".fa" ".fasta" ".tfa"]
    set Suffixes [list ".fa"]
    
    set LesFichiers     ""
    set LesFichiers_Tmp ""    

    set  DirGenome "[BLATGenomeDir $Genome]"
    if {$DirGenome==""} {
	Espionne "Problem with $DirOuGenome, no directory can be defined."
	return ""
    } else {
	set DirGenomeBigZip "$DirGenome/bigZips"
    }

    Espionne "FastaToNib conversion starts for $Genome"

    set DirNib "$DirGenome/blat"
    if {! [file exists $DirNib]} {
	file mkdir $DirNib
    }
    
    #1 On recupere tous les fichiers fasta du genome UCSC
    #  ATTENTION il peut y avoir des genomes ou les fasta sont directement dans bigZips
    #1-1 On recupere tous les fichiers fasta du genome UCSC directement dans bigZips
    set  LesFichiers_Tmp [glob -nocomplain -directory "$DirGenomeBigZip" "*${Suffixes}"]
    if {$LesFichiers_Tmp != ""} {
	set LesFichiers $LesFichiers_Tmp
    } else {
	#1-2 On recherche la liste des repertoires contenant les fichiers fasta
	set  LesDirs [glob -nocomplain -directory "$DirGenomeBigZip" -type d "*"]
	#Espionne "$LesDirs"
	
	#1-3 On recupere tous les fichiers fasta du genome UCSC dans chacun des sous repertoires
	set  LesFichiers_Tmp ""
	foreach Dir $LesDirs {
	    set  LesFichiers_Tmp [glob -nocomplain -directory "$Dir" "*${Suffixes}"]
	    if {$LesFichiers_Tmp != ""} {
		if {$LesFichiers==""} {
		    set LesFichiers $LesFichiers_Tmp
		} else {
		    set LesFichiers [concat $LesFichiers $LesFichiers_Tmp]
		}
	    }
	}
    }
    #Espionne "FastaToNib conversion for these files: $LesFichiers"
    
    #3 Conversion au format .nib et stockage a la racine du genome
    foreach File $LesFichiers {
	set FileTail [file tail $File]
	set OutFile  "$DirNib/${FileTail}"

	regsub -nocase {.[a-z]+$} $OutFile {.nib} OutFile
	
	Espionne "... $OutFile ..."
	ConvertFastaToNib $File $OutFile
	#Espionne "ConvertFastaToNib $File $OutFile"
    }
    
    Espionne "FastaToNib conversion complete for $Genome"

    return ""

}

proc ConvertUniProt2RefSeq {LId} {

    # returns the ID list in the same order
    # replacing all possible IDs by their 
    # RefSeq Accession when possible.
    # Otherwise, keep the original ID

    set ToAcc [IDMapping "ACC+ID" P_REFSEQ_AC $LId]
    puts "ToAcc $ToAcc"
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertUniProt2UniProtAcc {LId} {

    set LId [CheckIdsAsList $LId]
    # returns the ID list in the same order
    # replacing all possible id by their 
    # UniProt Accession when possible.
    # Otherwise, keep id

    set ToAcc [IDMapping "ACC+ID" ACC $LId]
    if {$ToAcc eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId acc $ToAcc {
	if {$acc eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $acc
	}
    }

    return $Lrep

}

proc ConvertUniProt2UniProtID {LId} {

    set LId [CheckIdsAsList $LId]
    # returns the ID list in the same order
    # replacing all possible id by their 
    # UniProt ID when possible.
    # Otherwise, keep id

    set ToID [IDMapping "ACC+ID" ID $LId]
    if {$ToID eq ""} {
	return $LId
    }

    set Lrep [list]
    foreach id $LId new $ToID {
	if {$new eq ""} {
	    lappend Lrep $id
	} else {
	    lappend Lrep $new
	}
    }

    return $Lrep

}

proc ConvertXML2MSF {{FichierXML ""} {OutputMSF ""}} {


    Wup "Permet de convertir un fichier .msf en fichier .xml"
    
    if {$FichierXML==""} {return "-1"}

    #Conversion du fichier msf
    set Clustal "clustalw"
    #set Clustal "/biolo/clustal/bin/clustalw"

    set Commande "$Clustal $FichierXML -convert -output=gcg"
    if {$OutputMSF != ""} {
	append Commande " -outfile=${OutputMSF}"
    }

    catch {   unset   ClustalOut}
    if {[catch {set   ClustalOut [eval exec $Commande]} Message]} {
	Espionne ">>>ConvertXML2MSF $FichierXML"
	Espionne "pb $Message"
	return "-1"
    } else {
	return "1"
    }

}

proc Coord {v i} {

    return [lindex $v $i]

}

proc CoordConverter {Repertoire {LongueurExtensionDeChaqueCote 100} {Organisme mouse} {StartVersion 200602} {EndVersion 200707}} {


	# Convertiseur de coordonnees d'une version N-1 d'un génome vers la version N

	set FichierDesCoordonneesStartVersion [open "$Repertoire/FichierDeCoordonnees-$StartVersion.coord" "r"]
	set FichierDesCoordonneesEndVersion [open "$Repertoire/FichierDeCoordonnees-$EndVersion.coord" "w"]
	set I 0
	
	# Boucle de création des fichiers contenant une seule séquence rallongée pour BLAT
	Espionne "CoordConverter : Constitution des fichiers TFA Ancienne version"
	while { [gets $FichierDesCoordonneesStartVersion LigneCoordonnees]  >=0 } {
	if { [string range $LigneCoordonnees 0 0] == ">"} {
		gets $FichierDesCoordonneesStartVersion LigneCoordonnees
	}
	ScanLaListe $LigneCoordonnees IDq AccessQ Chromosome StartQ EndQ StrandQ
		set StartExtendQ [expr $StartQ - $LongueurExtensionDeChaqueCote]
		set EndExtendQ [expr $EndQ + $LongueurExtensionDeChaqueCote]
		regsub -all -nocase  {chr} $Chromosome "" ChromosomeQ
		set SequenceRallongeeQ [BoutAdnDeUcscBoost $StartExtendQ $EndExtendQ $StrandQ $Organisme $ChromosomeQ "bigZips$StartVersion"]
		
		#Moulinette pour rajouter des 0 et pouvoir trier par la suite
		incr I
		set Id $I
		if { $I < 1000 } { set Id "0$Id" }
		if { $I < 100 } { set Id "0$Id" }
		if { $I < 10 } { set Id "0$Id" }
		
		#Ecriture du fasta mono-sequence
#		set FichierMonoSequenceRallongee [open "/tmp/OldFasta/Sequence$Id.fasta" "w"]
#		puts $FichierMonoSequenceRallongee ">Sequence$Id"
#		puts $FichierMonoSequenceRallongee $SequenceRallongeeQ
#		close $FichierMonoSequenceRallongee
#	}
#	close $FichierDesCoordonneesStartVersion
	
	#BLAT de tous les fichiers du répertoire & parser en sortie
	Espionne "CoordConverter : BLAT des sequences sur la nouvelle version du genome" 
	#BLAT_clientPourTousBoost "/tmp/OldFasta" "/tmp/blat" "$Organisme"
	Espionne "CoordConverter : Decorticage"
	#DecorticBlatBoost "/tmp/blat"
	
	#Fusion des résultats en un seul fichier de sortie
	Espionne "CoordConverter : Post-traitement Nouvelle version"
	set FichierDesCoordonneesEndVersionBrutes [open "/tmp/blat/Decortic.best"  "r"]
	while { [gets $FichierDesCoordonneesEndVersionBrutes LigneCoordonneesBrutes]  >=0 } {
		ScanLaListe $LigneCoordonneesBrutes IdT ChromosomeT StartExtendT EndExtendT StrandT
		set StartT [expr $StartExtendT + $LongueurExtensionDeChaqueCote]
		set EndT [expr $EndExtendT - $LongueurExtensionDeChaqueCote]
		if {$StrandT == "Plus/Plus" || $StrandT == "Plus/Minus"} {
			set StrandT "+"
		} else {
			set StrandT "-"
		}
		
		set LigneOut "$IdT $ChromosomeT $StartT $EndT $StrandT"
		puts $FichierDesCoordonneesEndVersion $LigneOut
	}
	close $FichierDesCoordonneesEndVersion
	close $FichierDesCoordonneesEndVersionBrutes
	Espionne "CoordConverter : Fin"

}

proc CoordConverterWeb {FichierDeCoordonnees JobId {LongueurExtensionDeChaqueCote 50} {Organisme Homo_sapiens} {StartVersion 200405} {EndVersion 200603}} {


	# Convertiseur de coordonnees d'une version N-1 d'un génome vers la version N
	set Repertoire "[RepertoireDeTravail]"
	file mkdir "/tmp/OldFasta"
	file mkdir "/tmp/blat"
	file delete "/tmp/blat/Decortic.orphan"
	file delete "/tmp/blat/Decortic.coord"
	file delete "/tmp/blat/Decortic.best"
	set ListeOldFastaDelete [glob -nocomplain -directory "/tmp/OldFasta/" "*.fasta"]
	set ListeBlatDelete [glob -nocomplain -directory "/tmp/blat/" "*.fasta"]
	foreach FichierOld $ListeOldFastaDelete {
		file delete $FichierOld
	}
	foreach FichierBlat $ListeBlatDelete {
		file delete $FichierBlat
	}
	set NomFichierOut "/tmp/$JobId.out"
	set FichierDesCoordonneesStartVersion [open "/home/anno/www/Gcon/$FichierDeCoordonnees" "r"]
	set FichierDesCoordonneesEndVersion [open $NomFichierOut "w"]
	set I 0
	set LigneOut ""
	# Boucle de création des fichiers contenant une seule séquence rallongée pour BLAT
	Espionne "Constitution des fichiers TFA Ancienne version"
	while { [gets $FichierDesCoordonneesStartVersion LigneCoordonnees]  >=0 } {
		if { [string range $LigneCoordonnees 0 0] == ">"} {
			gets $FichierDesCoordonneesStartVersion LigneCoordonnees
		}
		
		Espionne "Toto $LigneCoordonnees"
		set LigneCoordonnees [ExploseUCSC $LigneCoordonnees]
		Espionne "Tata $LigneCoordonnees"
		ScanLaListe $LigneCoordonnees Chromosome StartQ EndQ StrandQ
		
		set StartExtendQ [expr $StartQ - $LongueurExtensionDeChaqueCote]
		set EndExtendQ [expr $EndQ + $LongueurExtensionDeChaqueCote]
		regsub -all -nocase  {chr} $Chromosome "" ChromosomeQ
		set SequenceRallongeeQ [BoutAdnDeUcscBoost $StartExtendQ $EndExtendQ $StrandQ $Organisme $ChromosomeQ "bigZips$StartVersion"]
		
		#Moulinette pour rajouter des 0 et pouvoir trier par la suite
		incr I
		set Id $I
		if { $I < 1000 } { set Id "0$Id" }
		if { $I < 100 } { set Id "0$Id" }
		if { $I < 10 } { set Id "0$Id" }
		
		#Ecriture du fasta mono-sequence
		set FichierMonoSequenceRallongee [open "/tmp/OldFasta/Sequence$Id.fasta" "w"]
		puts $FichierMonoSequenceRallongee ">Sequence$Id"
		puts $FichierMonoSequenceRallongee $SequenceRallongeeQ
		close $FichierMonoSequenceRallongee
	}
	close $FichierDesCoordonneesStartVersion
	
	#BLAT de tous les fichiers du répertoire & parser en sortie
	BLAT_clientPourTousBoost "/tmp/OldFasta" "/tmp/blat" "human"
	DecorticBlatBoost "/tmp/blat"
	
	#Fusion des résultats en un seul fichier de sortie
	set FichierDesCoordonneesEndVersionBrutes [open "/tmp/blat/Decortic.best"  "r"]
	while { [gets $FichierDesCoordonneesEndVersionBrutes LigneCoordonneesBrutes]  >=0 } {
		ScanLaListe $LigneCoordonneesBrutes IdT ChromosomeT StartExtendT EndExtendT StrandT
		set StartT [expr $StartExtendT + $LongueurExtensionDeChaqueCote]
		set EndT [expr $EndExtendT - $LongueurExtensionDeChaqueCote]
		if {$StrandT == "Plus/Plus"} {
			set StrandT "+"
		} else {
			set StrandT "-"
		}
		
		set LigneOut "$IdT $ChromosomeT $StartT $EndT $StrandT"
		puts $FichierDesCoordonneesEndVersion $LigneOut
	}
	close $FichierDesCoordonneesEndVersion
	close $FichierDesCoordonneesEndVersionBrutes
	file rename -force $NomFichierOut "$Repertoire/$JobId.out"

}

proc CoordDuCourant {w} {

    set id [$w find withtag current]
    set x [lindex [$w coords $id] 0]
    set y [lindex [$w coords $id] 2]
    return "$x $y"

}

proc CoordGenom {{Qui ""} {Quoi ""}} {

    global CoordGenom

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

    foreach Box [ListeDesPABs] {
	set Cluster [ExtraitInfo $Box "Cluster"]
	set FileTfa "[RepertoireDuGenome]/FichiersInitial/SOURIS_Tfactor/$Cluster.fa"
	if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/SOURIS_others/$Cluster.fa"}
	if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/RAT_Tfactor/$Cluster.fa"}
	if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/RAT_others/$Cluster.fa"}
	if {![file exists $FileTfa]} {Espionne "$Box warning"}
	foreach Ligne [LesLignesDuFichier $FileTfa] {
	    if {[regexp "^\>" $Ligne]} { 
		scan $Ligne "%s %s %s %s" name chr start stop
		regsub "\>" $name "" name
		set coord "$chr $start $stop"
		set CoordGenom($Box,$name,coord) $coord
	    }
	}
    }
    return [CoordGenom $Qui $Quoi]

}

proc CoordonneesDesPavesVerticaux {EffectifHoriz EffectifTotal Hauteur Largeur} {

    set L [expr $Largeur * 1.0 / [Maxi 1 $EffectifHoriz]]
    set H [expr $Hauteur * 1.0 / [Maxi 1 $EffectifHoriz]]

    set NbLigne [expr int($EffectifTotal/[Maxi 1 $EffectifHoriz] + 0.5)] 

    set nPaves         0
    set nPavesSurLigne 0
    set nLigne 1
    set LesCoordonnees {}
    for {set i 1} {$i <= $EffectifTotal} {incr i} {
	if {$nPavesSurLigne == $EffectifHoriz} {set nPavesSurLigne 0;incr nLigne}
	incr nPavesSurLigne 
	incr nPaves 

	set HMinPave [expr ($nLigne-1)          * $H]
	set LMinPave [expr ($nPavesSurLigne-1)  * $L]
	set HMaxPave [expr $HMinPave            + $H]
	set LMaxPave [expr $LMinPave            + $L]

	lappend LesCoordonnees [list $nPaves $LMinPave $HMinPave $LMaxPave $HMaxPave]
    }
    return $LesCoordonnees

}

proc CoordonneesSurChromosome {Contig Debut Fin Sens} {

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {
	Espionne "$FichierContigs does not exist"
	return ""
    }
    ChargeContigsDesChromosomes Contigs $FichierContigs
    if {![info exists Contigs($Contig)]} {
	Espionne "$Contig does not exist"
	return ""
    }
    set LesInfosDuContig [set Contigs($Contig)      ]

    set Chromosome        [lindex $LesInfosDuContig 0]
    set DebutContig       [lindex $LesInfosDuContig 1]
    set FinContig         [lindex $LesInfosDuContig 2]
    set SensContig        [lindex $LesInfosDuContig 3]

    if {$SensContig == "-"} {
	set DebutSurChrom [expr $FinContig - $Fin  ]
	set FinSurChrom   [expr $FinContig - $Debut]
	
	if {      $Sens == "-"} {set SensSurChrom "+"
	} elseif {$Sens == "+"} {set SensSurChrom "-"}

    } elseif {$SensContig == "+"} {
	set DebutSurChrom [expr $DebutContig + $Debut - 1]
	set FinSurChrom   [expr $DebutContig + $Fin   - 1]
	
	set SensSurChrom  $Sens
    } elseif {$SensContig == "?"} {
	set DebutSurChrom [expr $DebutContig + $Debut - 1]
	set FinSurChrom   [expr $DebutContig + $Fin   - 1]
	
	set SensSurChrom  $SensContig
    } else {
	set DebutSurChrom $Debut
	set FinSurChrom   $Fin
	set SensSurChrom  $SensContig
    }
    return [list "$Chromosome" "$DebutSurChrom" "$FinSurChrom" "$SensSurChrom"]

}

proc Coords2Angle {x y {epsilon 0.0001}} {

    
    if {abs($x) > $epsilon} {
	set theta [expr {atan($y / $x)}]
    } elseif {$y >= 0.0} {
	set theta [expr {[Pi] / 2.}]
    } else {
	set theta [expr {1.5 * [Pi]}]
    }
    
    if {$x < -$epsilon} {set theta [expr {[Pi] + $theta}]}
    while {$theta > [2Pi]} {set theta [expr {$theta-[2Pi]}]}
    while {$theta < 0.0} {set theta [expr {$theta+[2Pi]}]}
    
    return $theta

}

proc CoordsNom {AId n x y} {

    global Abr

    set t [set Abr(Arbre,$AId)]

    set Angle [$t get $n oldtheta]
    while {$Angle >=  [2Pi]} {set Angle [expr {$Angle-[2Pi]}]}
    while {$Angle <= -[2Pi]} {set Angle [expr {$Angle+[2Pi]}]}
    if {$Angle < 0.} {set Angle [expr {$Angle+[2Pi]}]}

    set NAff [NomAffiche $AId $n]
    set Lg [font measure "TreeFont$AId" $NAff]
    set x [expr {$x + $Lg*cos($Angle)}]
    set y [expr {$y + $Lg*sin($Angle)}]

    return [list $x $y]

}

proc CopDePipeVersGscope {RepertoireOut RepertoireIn} {

    set RepertoireDeSortie "[RepertoireDuGenome]/$RepertoireOut"
    if {! [file exists $RepertoireDeSortie]} {file mkdir $RepertoireDeSortie}
    foreach Nom [ListeDesPABs] { 
	puts $Nom
	set Fichier "/genomics/link/EVI3_msf/$RepertoireIn/$Nom"
	if {![file exists $Fichier]} {continue}
	set Queue [file tail $Fichier]
	#set Queue [regsub ".clust" $Queue ""]
	file copy -force $Fichier $RepertoireDeSortie/$Queue
    }

}

proc CopainsDuBlastpEVImmProt {} {

    foreach Nom [ListeDesPABs] {
	set Fichier [GscopeFile $Nom "blastpEVImmProt"]
	if {[FileAbsent $Fichier]} { continue }
	set lBanqueId {}
	set lPN {}
	DecortiqueBlast $Fichier 1.0e-80 20 Query lBanqueId lAccess lDE lProfil lPN
	set SeqRef [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]
	foreach BId $lBanqueId PN $lPN {
	    set Hit ""
	    regsub {^[^\:]+\:} $BId "" Hit
	    if {$Hit==$Nom || $Hit==""} { continue }
	    set SeqHit [QueLaSequenceDuFichierTFA [GscopeFile $Hit "prottfa"]]
	    if {[string equal -nocase $SeqHit $SeqRef]} {
		lappend LesEgaux "$Hit = $Nom"
		Espionne "$Hit = $Nom"
		continue
	    }
	    if {[regexp -nocase $SeqHit $SeqRef]} {
		lappend LesPetits "$Hit < $Nom"
		continue
	    }
	    if {[regexp -nocase $SeqRef $SeqHit]} {
		lappend LesPetits "$Nom < $Hit"
		continue
	    }
	}
    }
    set LesEgaux  [lsort -unique $LesEgaux]
    set LesPetits [lsort -unique $LesPetits]
    SauveLesLignes $LesEgaux dans "[Fiches]/LesEgaux"
    SauveLesLignes $LesPetits dans "[Fiches]/LesPetits"
    return [concat $LesEgaux $LesPetits]

}

proc CopieArbre {s g} {

    set ls [llength $s]
    lset g 1 0
    lappend s {*}[lrange $g 0 2]
    foreach {k i p} [lrange $g 3 end] {
	lappend s $k [incr i $ls] $p
    }

    return $s

}

proc CopieArbre2 {td nd ta na} {

    # copie le sous-arbre de td au noeud nd dans
    # l'arbre ta au noeud na

    set cible $na
    if {$na eq "root"} {set cible [$ta get $na name]}
    set Ld [$td serialize]
    set La [$ta serialize $na]
    set idx [lsearch $Ld $nd]
    set lgd [llength $Ld]
    lappend Ld $cible $idx [lindex $La 2]
    foreach {n i k} [lrange $La 3 end] {
	incr i $lgd
	lappend Ld $n $i $k
    }
    #	puts "Ld $Ld"
    $td deserialize $Ld

    return

}

proc CopieBiolo {} {

    cd /biolo
    foreach F [glob -nocomplain *] {
Espionne $F
	if {[file exists "/commun/linux/biolo/$F"]} { continue }
	if { ! [file isdirectory $F]} { continue }
	if { ! [file readable $F]} { continue }
Espionne $F
	if { ! [OuiOuNon "On traite $F "]} { continue }
	catch {exec montar /biolo $F /commun/linux/biolo}
    }

}

proc CopieEnteteDuNuctfaVersProttfa {Nom} {

    set BonneEntete [EnteteDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"]
    set Fichier "[RepertoireDuGenome]/prottfa/$Nom"
    set LesLignes [LesLignesDuFichier $Fichier]

    set LaSeq [lrange $LesLignes 1 end]
    SauveLesLignes [concat [list $BonneEntete] $LaSeq] dans "[RepertoireDuGenome]/prottfaNew/$Nom"
    return $BonneEntete

}

proc CopieEnteteDuNuctfaVersProttfaPourTous {} {

    foreach Nom [ListeDesPABs] {
	Espionne [CopieEnteteDuNuctfaVersProttfa $Nom] 
    }

}

proc CopieLeMeilleurCopainsInfo {Nom Selection} {

    if { $Selection == "" } {return ""}
    foreach Ligne [split $Selection "\n"] {
	set Sequence [Fetche [AccessDUneLigneBlast $Ligne]]
	if { $Sequence == "" } { continue }
	DecortiqueFetch $Sequence ChampsDuFetch
	set OS [Glossaire [EspeceNormalisee $ChampsDuFetch(espece)] Court]
	set OC [ClasseNormalisee $ChampsDuFetch(classe)]
	set GN $ChampsDuFetch(gn)
	set DE $ChampsDuFetch(definition)
	lappend lOS $OS
	lappend lOC $OC
	lappend lGN $GN
	lappend lDE $DE
	lappend ListeDeChoix "$OS / $OC / [BeauGN $GN] / $DE"
	lappend ListeDeCouleurs [CouleurDePeauOsOc "$OC"]
    }
    set Elu [ChoixParmi $ListeDeChoix $ListeDeCouleurs]

    if { $Elu == "" } { return "" }

    set i [lsearch -exact $ListeDeChoix $Elu]
    set OS [lindex $lOS $i]
    set OC [lindex $lOC $i]
    set GN [lindex $lGN $i]
    set DE [lindex $lDE $i]

    if {[regexp " OR " $GN]} {
	set BonGN [ChoixParmi [split $GN " "]]
	if { $BonGN == "OR" } {set BonGN $GN}
    } else {
	set BonGN $GN
    }
    
    set aDE "" 
    set aGN ""
    if { $DE != "" } { set aDE "DE: $DE\n" }
    if { $BonGN != "" } { set aGN "GN: $BonGN\n" }
    set Append [string trim "$aGN$aDE"]
    if { $Append != ""} {
	Informe $Nom $Append
    }
    return "$Append"

}

proc CopieLesBonsDisphy {} {

    global RepertoireDuGenome

    foreach Nom [ListeDesPABs] {
	set PhyFaux "$RepertoireDuGenome/phylos.faux/$Nom"
	set PhyBon  "$RepertoireDuGenome/phylos/$Nom"
	set DisFaux "$RepertoireDuGenome/disphy.faux/$Nom"
	set DisBon  "$RepertoireDuGenome/disphy/$Nom"

	if { ! [file exists $PhyFaux]} { continue }

	if {[ContenuDuFichier $PhyFaux]==[ContenuDuFichier $PhyBon]} {
	    if { ! [file exists $DisFaux]} { continue }
	    File copy $DisFaux $DisBon
	    continue
	}
    }

}

proc CopieLesFichiersPourGroupedpcEtRetscope {Nom Repertoire} {

    set Extension ".clust"
    set FichierClust       "[RepertoireDuGenome]/$Repertoire/$Nom.clu"
    set FichierMsf         "[RepertoireDuGenome]/$Repertoire/$Nom"
   
    set RepertoireDeSortie "[RepertoireDuGenome]/cluspackfinal"
    if {! [file exists $RepertoireDeSortie]} {file mkdir $RepertoireDeSortie}
    set LeFichierClust [file tail $FichierClust]
    set LeFichierClust [split $Nom "."]
    set LeFichierClust [regsub " clu" $Nom ""]
    set FichierSortieClust "$LeFichierClust$Extension"
    file copy -force $FichierClust "$RepertoireDeSortie/$FichierSortieClust"

    set LeFichierMSF [file tail $FichierMsf]
    set FichierSortieMsf $LeFichierMSF
    file copy -force $FichierMsf "$RepertoireDeSortie/$FichierSortieMsf"

}

proc CopieLesPH {} {

    global RepertoireDuGenome
    foreach Fichier [LesLignesDuFichier "$RepertoireDuGenome/listedesph.fof"] {
	if { ! [regexp -nocase {[a-z0-9]} $Fichier]} { continue }
	set AA [string range [file tail $Fichier] 0 2]
	set Destin "$RepertoireDuGenome/phylos/[AutreCode $AA]"
	if {[file exists $Destin]} { continue }
	Espionne " copy -force $Fichier $Destin"
	File copy -force $Fichier $Destin
    }

}

proc CopieLesmRNADesJumeauxRepresentatifs {} {


    set DirDesJumeaux "[RepertoireDuGenome]/Jumeaux"
    set DirDesmRNA    "[RepertoireDuGenome]/Jumeaux/mrnatfaJumeaux_ACT0001_ACT1164"
    set Repnuctfa     "[RepertoireDuGenome]/nuctfa"
    set RepmRNA       "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"

    set LesPABs [ListeDesPABs]
    set LesPABs [lrange $LesPABs 0 1163]

    set i 0
    foreach PAB $LesPABs {
	set  JumeauRepresentatif [JumeauRepresentatif $PAB]
	if {$JumeauRepresentatif!="" && $PAB!=$JumeauRepresentatif} {Espionne "$PAB pas jumeau best";continue}

	if {[file exists "$RepmRNA/$PAB"]} {
	    set FichierQuery   "$RepmRNA/$PAB"
	} elseif {[file exists "$Repnuctfa/$PAB"]} {
	    set FichierQuery   "$Repnuctfa/$PAB"
	} else {
	    #Espionne "No File for the Query ($PAB)"
	    continue
	}
	incr i
	
	file copy -force $FichierQuery "$DirDesmRNA/[file tail $FichierQuery]"
	#Espionne "$FichierQuery $DirDesmRNA/[file tail $FichierQuery]"
    }
    return ""

}

proc CopieVersFichierBienNomme {F} {

    if {[regexp {\#} $F]} {
	regsub -all {\#} $F "_" BonF
	if {[file exists $BonF] && [OuiOuNon "$F\nwill be copied to\n$BonF\n\nIt already exists. Do I skipp ?"]} {
	    return ""
	}
	if { ! [OuiOuNon "$F\nOk to copy it to\n$BonF"]} { return "" } 
	file copy -force $F $BonF
	return $BonF
    }
    return $F

}

proc CopieVersFichierBienNommePourLeRep {} {

    foreach F [glob -nocomplain "./*"] {
	Espionne [CopieVersFichierBienNomme $F]
    }

}

proc CopresenceClustersDansOperons {} {

    set ListeDesClustersDesOperons [LesClustersDesOperons]
    set LesClusters {}
    foreach LOperon $ListeDesClustersDesOperons {
	set LOperon [ElimineLesRedondancesDansUneListe $LOperon]
	foreach Clust1 $LOperon {
	    if {![info exists TabClust($Clust1)]} {
		lappend LesClusters $Clust1
		set TabClust($Clust1) {}
	    }
	    foreach Clust2 $LOperon {
		if {$Clust1 == $Clust2} {continue}
		if {![info exists TabClust($Clust1,$Clust2)]} {
		    lappend TabClust($Clust1) $Clust2
		    set TabClust($Clust1,$Clust2) 0
		}    
		incr TabClust($Clust1,$Clust2) 
	    }
	}
    }
    set LeTexte {}
    foreach Clust [lsort -integer $LesClusters] {
	foreach ClustAssocie [lsort -integer [set TabClust($Clust)]] {
	    set n [set TabClust($Clust,$ClustAssocie)]
	    if {$n <= 1} {continue}
	    set Distance [DistanceEntreClustersXHda $Clust $ClustAssocie]
	    lappend LeTexte "$Clust\t$ClustAssocie\t$Distance\t$n"
	}
    }
    set File "[RepertoireDuGenome]/fiches/copresence_des_clusters_dans_operons"
    Sauve [join $LeTexte "\n"] dans $File
    return $LeTexte

}

proc CopsDunName {FileMacsims NameVoulu} {

    #concatene GroupDunName et NamesDunGroup
    set FileMacsims [TheTrueMacsimsFile $FileMacsims]
    set fh [open $FileMacsims "r"]
    dom parse -channel $fh doc
    close $fh
    $doc documentElement root
    foreach seq [$root selectNodes "//sequence"] {
	set Name  [$seq selectNodes "string(./seq-name)"]
	set Group [$seq selectNodes "string(./seq-info/group)"]
	if {$Name == $NameVoulu} {
	    set GroupVoulu $Group
	    break
	}
    }
    foreach seq [$root selectNodes "//sequence"] {
	set Name  [$seq selectNodes "string(./seq-name)"]
	set Group [$seq selectNodes "string(./seq-info/group)"]
	if {$Group == $GroupVoulu} {lappend LesNames $Name}
    }
    $doc delete
    return $LesNames

}

proc CopyBilanHTMLDesNomsInteressants {} {

    set RepBilanHTML "[RepertoireDuGenome]/BilanHTML"
    set RepHTML      "[RepertoireDuGenome]/HTML_TL"
    foreach Nom [LesNoms "NomsInteressants"] {
	set F1 "$RepBilanHTML/$Nom.html"
	set F2 "$RepHTML/$Nom.html"
	File copy -force $F1 $F2
	Espionne "$F1 done !"
    }
    return

}

proc CopyDansGscopublic {} {

    global FichierGscopePerso

    set RepGscoperso [file dirname $FichierGscopePerso]
    if {![file exists $RepGscoperso]} {File mkdir $RepGscoperso}

    set RepHome [string range $RepGscoperso 0 [expr [string last "/" $RepGscoperso] - 1 ]]
    set RepGscopublic "$RepHome/gscopublic"

    foreach File [glob -nocomplain "$RepGscopublic/*.*"] {
	Espionne $File
	set NomFichier [file tail $File]
	set File2 "$RepGscoperso/$NomFichier"

	if {![file exists $File2]} {continue}

	File copy -force $File2 $RepGscopublic
	Espionne "$File2 save in : $RepGscopublic"
    }
    return ""

}

proc CopyDunRepertoireALAutre {RepertoireOut RepertoireIn} {

    set RepertoireDeSortie "[RepertoireDuGenome]/$RepertoireOut"
    if {! [file exists $RepertoireDeSortie]} {file mkdir $RepertoireDeSortie}
    foreach Nom [ListeDesPABs] { 
	Espionne $Nom
	set Fichier "[RepertoireDuGenome]/$RepertoireIn/$Nom"
	if {![file exists $Fichier]} {continue}
	if {[regexp "bidon" [lindex [LesLignesDuFichier $Fichier] 0]]} {
	    Espionne "$Nom LesBidons"
	}
	set Queue [file tail $Fichier]
	file copy -force $Fichier $RepertoireDeSortie/$Queue
    }

}

proc CopyDunRepertoireALAutreOligoFinal {} {

    set RepertoireDeSortie "/genomics/link/EVImm/Arnaud/nuctfa1500Final"
    if {! [file exists $RepertoireDeSortie]} {file mkdir $RepertoireDeSortie}

    foreach Nom [ListeDesPABs] { 
	Espionne $Nom
	set FichierInitial "/genomics/link/EVImm/Arnaud/nuctfa1500/$Nom"
	
	
	if {$Nom=="EVI25020" || $Nom=="EVI25030" || $Nom=="EVI25040" || $Nom=="EVI11160"} {
	    Espionne "cas1"
	    continue
	}
	if {$Nom=="EVI03410" || $Nom=="EVI11157" || $Nom=="EVI16990" || $Nom=="EVI19394" || $Nom=="EVI26070" || $Nom=="EVI26300" || $Nom=="EVI27381" || $Nom=="EVI33750"} {
	    Espionne "cas2"
	    set Fichier "/genomics/link/EVImm/Arnaud/nuctfaSup/$Nom"
	    file copy -force $Fichier $RepertoireDeSortie/$Nom
	    continue
	}
	if {$Nom=="EVI08520" || $Nom=="EVI08530" || $Nom=="EVI22270" || $Nom=="EVI24960"} {
	    Espionne "cas3"
	    set Fichier "/genomics/link/EVImm/Arnaud/nuctfaMod/$Nom"
	    file copy -force $Fichier $RepertoireDeSortie/$Nom
	    continue
	}
	if {$Nom=="EVI18700" || $Nom=="EVI24390"} {
	    Espionne "cas4"
	    set Fichier "/genomics/link/EVImm/Arnaud/nuctfaMod2/$Nom"
	    file copy -force $Fichier $RepertoireDeSortie/$Nom
	    continue
	}
	Espionne "cas5"
	if {![file exists $FichierInitial]} {continue}
	
	if {[regexp "bidon" [lindex [LesLignesDuFichier $FichierInitial] 0]]} {
	    Espionne "$Nom LesBidons"
	}
	file copy -force $FichierInitial $RepertoireDeSortie/$Nom
    }

}

proc CopyFeaturesToDB {} {

    global TabSF LNOrdali db

    $db eval {begin transaction}
    set Lfeatvues [list]
    foreach n $LNOrdali {
	if {$n eq ""} {continue}
	
	set inom [$db eval {select pk_seqinfo from seqinfo where seqname=$n}]
	
	foreach key [array names TabSF "${n},*"] {
	    lassign [split $key ,] tmp feat
	    foreach f [set TabSF($kay)] {
		set note ""
		DecortiqueUneFeature $f dg fg color score note csys
		if {$note eq ""} {set note "NULL"}

		set pk [$db eval {select pk_seqfeat from seqfeat where fstart=$dg and fstop=$fg and fcolor=$color and fscore=$score and fnote=$note and fcsys=$csys}]
		# already seen
		if {! [string is integer -strict $pk]} {
		    # dans seqfeat, met feature orig.
		    $db eval {insert into seqfeat values(NULL,$inom, $feat, $dg, $fg, $color, $score, $note, $csys)}
		    set pk [$db last_insert_rowid]
		}

		$db eval {insert into ln_seqinfo_seqfeat values($inom,$pk)}
				incr i
	    }
	}
    }
    $db eval {commit}
    
    return

}

proc CopyFullSequenceData {old new} {

    global {*}[info globals "TD*"] Sequences SDG TabSF
    
    # infos sequence
    foreach t [info globals "TD*"] {
	set ${t}($new) [set ${t}($old)]
    }

    # features
    foreach k [array names TabSF "$old,*"] {
	lassign [split $k ,] tmp key
	set TabSF($new,$key) [set TabSF($k)]
    }

    # groups
    foreach g [array names SDG] {
	if {$old in [set SDG($g)]} {
	    lappend SDG($g) $new
	}
    }

    # sequences
    set Sequences($new) [set Sequences($old)]

    return

}

proc CopyLesNoms {} {

    global LNOrdali LSOrdali BufferSeq NomSeqSel LNSeqlab LSSeqlab NomNomSeq NomTextSeq

    if {[TypeAli] eq "pasdali"} {return}
    if {$NomSeqSel == {}} {return}
    if {$BufferSeq != {}} {
	set chx [tk_dialog .chx "Warning !" "Warning ! You already have sequences in the clipboard ! Cutting the sequences will discard them !" "" 0 "Discard" "Cancel"]
	if {$chx == 1} {return 0}
    }

    set Lix [list]
    set BufferSeq {}
    set NomSeqSel [lsort -real $NomSeqSel]
    foreach e $NomSeqSel {
	lassign [split $e .] y x
	set i [expr {$y-1}]
	if {[QuelMode] eq "seqlab"} {
	    set Nom [lindex $LNSeqlab $i]
	    if {$Nom eq ""} {continue}
	    set Seq [lindex $LSSeqlab $i]
	    set lt [$NomNomSeq tag names $e]
	    set Tname [lsearch -inline -regexp $lt {^TCG}]
	} else {
	    set Nom [lindex $LNOrdali $i]
	    if {$Nom eq ""} {continue}
	    set Seq [lindex $LSOrdali $i]
	    set Tname ""
	}
	lappend Lix $i
	lappend BufferSeq [list $Nom $Seq $Tname]
    }

    if {[QuelMode] eq "seqlab"} {
	$NomTextSeq copy $Lix
    }

    return 1

}

proc CopyLesNomsSB {} {

    global LNSeqlab
    global LSSeqlab
    global NomSeqSel
    global BufferSeq

    if {$NomSeqSel == {}} {return}

    set BufferSeq {}
    foreach e $NomSeqSel {
	lassign [split $e ,] y x

	set Nom [string trim [lindex $LNSeqlab $y]]
	if {$Nom eq ""} {continue}
	set Seq [lindex $LSSeqlab $y]

	lappend BufferSeq [list $Nom $Seq]
    }

    return

}

proc CopySeqsSel {} {


    global RegionSeqSel
    global NomTextSeq
    global NomNomSeq
    global LSSeqlab
    global LNSeqlab
    global BufferRegion

    if {$RegionSeqSel == {}} {return}
    foreach {d f} $RegionSeqSel {
	lassign [split $d "."] y x 
	incr y -1
	set s [string trim [lindex $LNSeqlab $y]]
	if {[SequenceLockee $s]} {return}
    }

    foreach {d f} $RegionSeqSel {
	set dmpT  [$NomTextSeq dump -tag $d $f]
	set LtagT [TagsDuDump $dmpT]
	set Seq   [$NomTextSeq get $d $f]
	lappend BufferRegion [list $d $LtagT $Seq]
    }

    return

}

proc CopySequenceData {old new} {

    global {*}[info globals "TD*"] TabSF

    foreach t [info globals "TD*"] {
	if {$t eq "TDesPCI"} {continue}

	set ${t}($new) [set ${t}($old)]
    }
    set TDesCompos(${new},aa) [set TDesCompos(${old},aa)]
    set TDesCompos(${new},pc) [set TDesCompos(${old},pc)]

    # Features
    foreach k [array names TabSF "$old,*"] {
	lassign [split $k ,] tmp key
	set TabSF($new,$key) [set TabSF($k)]
    }

    return

}

proc CoreBlocksDuXML {} {

    global TColScore LNOrdali LSOrdali

    set Ld $TColScore(coreblock,Data)
    set Ld [split [string map {"\n" ""} $Ld] " "]
    set dep -1
    set Lbornes [list]
    set i 0
    foreach col $Ld {
	if {$col == 1} {
	    if {$dep == -1} {
		set dep $i
	    }
	} else {
	    if {$dep != -1} {
		set fin [expr {$i-1}]
		#puts "$dep $fin"
		lappend Lbornes $dep $fin
		set dep -1
	    }
	}
	incr i
    }
    if {$dep != -1} {
	set fin [expr {$i-1}]
	#puts "$dep $fin"
	lappend Lbornes $dep $fin
    }
    
    return $Lbornes

}

proc CorrGetItem {l} {

    set id [string first ">" $l]
    set if [string last "<" $l]
    return [string range $l $id+1 $if-1]

}

proc CorrSetItem {l v} {

    set id [string first ">" $l]
    set if [string last "<" $l]
    set new "[string range $l 0 $id]${v}[string range $l $if end]"
    return $new

}

proc CorrectEOE {} {

    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	set Texte [ContenuDuFichier $Fichier]
	regsub -all "X" $Texte "N" Texte
	Sauve $Texte dans $Fichier
	set Fichier "[RepertoireDuGenome]/nucembl/$Nom"
	set Texte [ContenuDuFichier $Fichier]
	regsub -all "X" $Texte "N" Texte
	Sauve $Texte dans $Fichier
    }

}

proc CorrectRedundancyOnGscope {nomRepertoireDesBlast {minIdentity ""}} {

	## Liste des sequences redondantes
	## niveau 0 : groupes de sequences redondantes
	## niveau 1 : sequences redondantes entre elles
	array set redundantSequencesL {}
	### initialisation des variables
	if {$minIdentity==""} { set minIdentity 100.0 }
	puts "        --> % identity used = $minIdentity"
    global RepertoireDuGenome
    set RepBlast "$RepertoireDuGenome/$nomRepertoireDesBlast"
	set compteur 1
	puts "    -->chargement des informations des blasts (opération longue,"
	puts "       lecture détaillée de tous les BLASTs...)"
	foreach PAB [ListeDesPABs] {
		#puts "### BLAST n° $compteur"
		FindRedundancy redundantSequencesL "$RepBlast/$PAB" $minIdentity
		incr compteur
	}
	#creation des cluster
	set newList [MakeRedundancyClusters redundantSequencesL]
	#suppression des redondants d'un cluster
	Keep1ByCluster $newList $minIdentity
	puts "#########################################################################################"
	puts "    --> Correction de la redondance achevée !!!!"
	puts "        (^^ génial, c'est pas trop tot ...)"
	puts "    --> fichier nettoyé : final_correctedProteome.fasta"
	puts "    --> bon courage pour la suite ..."
	puts "#########################################################################################"

}

proc CorrectifDres {} {

    global dres db
    set Lpk [$db eval {select distinct(pk_tests) from results}]
    $dres eval {begin transaction}
    set done "done"
    $dres eval "update tests set thread='$done' where pk_tests in ([join $Lpk ,])"
    $dres eval {commit}

    return

}

proc CorrectifDresAJETER {} {

    global db dres

    set Ldone [$db eval {select distinct(pk_tests) from results}]
    $dres eval "update tests set thread='0' where pk_tests in ([join $Ldone ,])"
    
    return

}

proc Correction {Fichier Erreur Correction {SaveTheOldFile yes}} {

    set NouveauContenu ""
    set AncienContenu ""
    foreach AncienneLigne [LesLignesDuFichier "$Fichier"] {
	append AncienContenu "$AncienneLigne\n"
	if {[regexp "$Erreur" $AncienneLigne]} {
	    regsub -all -nocase "$Erreur" $AncienneLigne "$Correction" NouvelleLigne
	    append NouveauContenu "$NouvelleLigne\n"
	} else {
	    append NouveauContenu "$AncienneLigne\n"
    }   }
    if {$NouveauContenu == $AncienContenu} {
	Espionne "$Fichier NO CORRECTION"
	return ""
    }
    Espionne "$Fichier MODIFIED"
    set NouveauFichier "$Fichier"
    if {$NouveauFichier!=""} {
	Sauve $NouveauContenu dans $NouveauFichier
    }

    if {$SaveTheOldFile == "yes"} {
	set AncienFichier "$Fichier.bak"
	if {$AncienFichier!=""} {Sauve $AncienContenu dans $AncienFichier}   
    }

}

proc CorrectionDesBilansMRM {Erreur Correction} {

    foreach Nom [ListeDesPABs] {
	if {![file exist "./$Nom"]} {continue} 
	Correction $Nom $Erreur $Correction

    }
    Espionne "End of Corrections"
    
    if {![OuiOuNon "Do I conserve the old Files with the extension \*.bak ?"]} {
	foreach Nom [ListeDesPABs] {
	    if {![file exist "./$Nom"]} {continue} 
	    file delete "$Nom.bak"
    }   }
    return ""

}

proc CorrectionPourThrombin {LesLignes Fichier aNouveauNom} {

    upvar $aNouveauNom NouveauNom

    set NouveauNom $Fichier

    if {[regexp "^/home/" $LesLignes]} {
	set LesLignes [LesLignesDuFichier $LesLignes]
    }

    if {[lsearch -regexp $LesLignes "Thrombin"   ]==-1} { return $LesLignes }
    if {[lsearch -regexp $LesLignes "ThrombinOld"] >-1} { return $LesLignes } 
    set Texte [join $LesLignes "\n"]
    regsub -all "\n" $Texte "" TexteSeq
    regsub -all " "  $TexteSeq "" TexteSeq
    if { ! [regexp -nocase "[ThrombinOld]" $TexteSeq]} { return $LesLignes }
    regsub -all "Thrombin" $Texte   "ThrombinOld" NouveauTexte
    regsub -all "thrombin" $Fichier "thrombinold" NouveauNom
    return [split $NouveauTexte "\n"]

}

proc CorrectionPourVarsplicDuBlastP {Fichier {Out ""}} {

    if {$Out==""} { set Out $Fichier }
    set nVus 0
    set LeNouveau {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp -nocase {^VARSPLIC\:} $Ligne]} {
	    incr nVus
	    scan $Ligne "%s %s" BId Access
	    set BonAccess [StringApres ":" dans $BId]
	    if { ! [string equal -nocase $Access $BonAccess]} {
		set d [expr [string length $BonAccess] - [string length $Access]]
		if {$d<0} {
		    regsub " $Access" $Ligne " $BonAccess[string repeat " " [expr -$d]]"
		}
		if {$d==0} {
		    regsub " $Access" $Ligne " $BonAccess"
		}
		if {$d>0} {
		    regsub " $Access" $Ligne " $BonAccess" Ligne
		    set Ligne [string replace $Ligne [expr 66-$d+1] 66]
		}
		lappend LeNouveau $Ligne
		continue
	    }
	}
	if {[regexp -nocase {>VARSPLIC\:} $Ligne]} {
	    if {$nVus==0} { break }
	    scan $Ligne "%s %s" BId Access
	    set BonAccess [StringApres ":" dans $BId]
	    regsub " $Access" $Ligne " $BonAccess" Ligne
	    lappend LeNouveau $Ligne
	    continue	
	}
	lappend LeNouveau $Ligne
	continue
    }
    if {$nVus==0 && $Fichier==$Out} { return $Out }
    if {$nVus==0 && $Fichier!=$Out} { file copy -force $Fichier $Out ; return $Out }
    return [SauveLesLignes $LeNouveau dans $Out]

}

proc CorrectionPourVarsplicDuBlastPPourTous {} {

    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
	if { ! [file exists $Fichier]} { continue }
	regsub "/blastp/" $Fichier "/blastpOK/" Out
	Espionne [CorrectionPourVarsplicDuBlastP $Fichier $Out]
    }
    exit

}

proc CorrelFC {FichierOverlap DeltaDD FichierSortie} {

    for {set fca 1} {$fca < 97} {incr fca} {
	#les delta dd de 1 sont pris
	set PetG [AnalyseGlobaleOverlap_pourCorrelFC $FichierOverlap 3T 0 $fca $DeltaDD]
	lappend L "$fca $PetG"
    }
    Espionne [llength $L]
    SauveLesLignes $L dans "[RepertoireDuGenome]/OVERLAP931NEW/$FichierSortie"

}

proc CorrelationAxe {Lref} {

    global db
    
    set db "root"
    sqlite3 $db /home/moumou/AAindex/AAindex.sql

    $db eval {begin transaction}
    set Li [$db eval {select pk_aaindex, description, vecteur from aaindex where type = 'V'}]
    $db eval {commit}

    set i 0
    set cmax -9999.
    foreach {k d v} $Li {
	if {"NA" in $v} {
	    # puts "===> $v"
	    continue
	}

	set cc [CoefficientCorrelation $v $Lref]
	lappend Lcor [list $k $d $v $cc]
	if {$cc > $cmax} {
	    set cmax $cc
	    set kmax $k
	    set dmax $d
	}
	incr i
    }

    set nl [lsort -real -index 3 $Lcor]
    set fmt "%6.3f | %3d"
    for {set i 0} {$i < 5} {incr i} {
	lassign [lindex $nl $i] k d v c
	puts [format $fmt $c $k]
	puts "$d"
    }
    puts ""
    for {set i 4} {$i >= 0} {incr i -1} {
	lassign [lindex $nl end-$i] k d v c
	puts [format $fmt $c $k]
	puts "$d"
    }

    return $kmax

}

proc CorrelationClustersOperons {aT} {

    upvar $aT T
    global TableauOrf2Cluster2Operon

    set LesClusters [lsort -integer [O2C2O LesClusters]]
    set LesOperons  [lsort -integer [O2C2O LesOperons]]
    foreach Cluster [lrange $LesClusters 0 10] {
	set LesOperonsDuCluster  [lsort -integer [O2C2O Cluster $Cluster LesOperons]]
	foreach Operon $LesOperonsDuCluster {
	    if {[info exists TableauOrf2Cluster2Operon(Cluster,$Cluster,Operon,$Operon,LesOrfsEnCommun)]} {
		set LesOrfs [O2C2O Cluster  $Cluster Operon $Operon LesOrfsEnCommun]     
		set nOrfs   [llength $LesOrfs]
	    } else {
		set nOrfs 0
	    }
	    set TailleOperon [O2C2O Operon $Operon TailleOperon]
	    if {$TailleOperon!=0} { 
		set P [expr ($nOrfs*100)/$TailleOperon]
	    } else {
		set P 0
	    }
	    set T($Cluster,$Operon) [list $P $nOrfs [expr $nOrfs!=0]]
	}
    }
    return [list $LesClusters $LesOperons]

}

proc CorresAffyEntrePouletEtHomme {} {

    #set Fichier "/genomics/link/Tau/GSTRdCVF/BlastpSurStringPoulet/PSPoulet"
    set Fichier "/genomics/link/Tau/GSTControl/BlastpSurStringPoulet/PSPouletControl"
    set pashumain 0; set ok 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LesPsHumanDunGene {}
	set LesMots [split $Ligne "\t"]
	set ChampPs [lindex $LesMots 2]
	if {$ChampPs=="vide"} { continue }
	Espionne "ChampPs $ChampPs"
	set LesPsPouletDunGene [split $ChampPs ","]
	foreach PsPoulet $LesPsPouletDunGene {
	    set PsHuman [InterrogeOrtholHGU133Plus2 $PsPoulet PsOrthol]
	    Espionne "\t$PsPoulet : $PsHuman"
	    LConcat LesPsHumanDunGene $PsHuman
	    LConcat ToutesLesPsHuman $PsHuman
	}
	if {$LesPsHumanDunGene=={}} {
	    incr pashumain
	    Espionne "\tattention"
	} else {
	    incr ok
	    set LesPsHumanDunGene [ListeSansDoublon $LesPsHumanDunGene]
	    Espionne "\t LesPsHumanDunGene $LesPsHumanDunGene"
	}
    }
    set ToutesLesPsHuman [ListeSansDoublon $ToutesLesPsHuman]
    set ToutesLesPsHumanFinal [join $ToutesLesPsHuman "\n"]
    Espionne "pashumain $pashumain ok $ok"
   # Sauve $ToutesLesPsHumanFinal dans "/genomics/link/Tau/enrichismt/LesPsHumaines"
    Sauve $ToutesLesPsHumanFinal dans "/genomics/link/Tau/enrichismt/ControlLesPsHumaines"

}

proc CorresEnsEtOS {} {

    foreach File [glob -nocomplain "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/*.pep.all.fa.gz"] {
	set LesIDS {}
	
	set Queue [file tail $File]
	set OS [lindex [split $Queue "."] 0]
	regsub "_" $OS " " OS
	
	set FEns "[TmpFile].ens"
	exec gunzip -c $File > $FEns
	foreach Ligne [LesLignesDuFichier $FEns] {
	    if {[regexp "\>" $Ligne]} {
		set ID [lindex [split $Ligne " "] 0]
		regsub "\>" $ID "" ID
		regexp {([A-Z]+)([0-9]+)} $ID Match Let Chi
		set Let [string range $Let 0 end-1]
		lappend LesIDS $Let
	    }
	}
	if {$FEns!="" && [file exists $FEns]} { file delete $FEns }    
	set LesIDS [ListeSansDoublon $LesIDS]
	if {[llength $LesIDS]>1} {FaireLire "attention pls ID ds $File"}
	set Ens [lindex $LesIDS 0]
	set LigneFinal "$Ens $OS"
	lappend LesLignesFinales $LigneFinal
    }
    SauveLesLignes $LesLignesFinales dans "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/CorresEnsEtOS"

}

proc CorresEntreTypeEtAffy {type} {

    set LesFiles {}
    set version "na27"
    if {$type=="MG_U74ABC_AV2 set"}      {lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"}
    if {$type=="MG_U74ABC_ABV2 set"}     {
	lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"
	lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv"
    }
    if {$type=="MG_U74ABC_ABCV2 set"}    {
	lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"
	lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv"
	lappend LesFiles "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.na26.annot.csv"
    }
    if {$type=="MG_430_2.0 Array"}       {lappend LesFiles "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv"}
    if {$type=="MG_430A_2.0 Array"}      {lappend LesFiles "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.na27.annot.csv"}
    if {$type=="cDNA"}                   {lappend LesFiles {}}
    if {$type=="HG_U133 Plus 2.0 Array"} {lappend LesFiles "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv"}
    if {$type=="HG-U133A set"}           {lappend LesFiles "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.na27.annot.csv"}
    if {$type=="RG_U34A set"}            {lappend LesFiles "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.na27.annot.csv"}
    if {$type=="Zebrafish Array"}        {lappend LesFiles "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.na27.annot.csv"}
    if {$type=="DrosGenome1"}            {lappend LesFiles "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.na27.annot.csv"}
    if {$type=="Chicken Genome Array"}   {lappend LesFiles "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv"}
    return $LesFiles

}

proc CorresNumberProbesetAgilent {Qui Quoi} {

    global CorresNumberProbesetAgilent

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

    set F  "[HomeRipp]/GxHome/AgilentAnnot/GPL13607_family.soft"
    
    set LetsGo 0
    set PremiereFois 1
    set f [open $F r]
    while {[gets $f Ligne] >= 0} {
	if {[regexp {^!platform_table_begin} $Ligne]} { set LetsGo 1; continue}
	if {[regexp {^!platform_table_end} $Ligne]} { break }
	if {! $LetsGo} {continue}
	if {$PremiereFois} {
	    set PremiereFois 0
	    continue
	}
	set LesMots  [split $Ligne "\t"]
	set Number   [lindex $LesMots 0]
	set Probeset [lindex $LesMots 1]
#	Espionne "$Number $Probeset"
	lappend CorresNumberProbesetAgilent($Number,Probeset) $Probeset
	lappend CorresNumberProbesetAgilent($Probeset,Number) $Number
    }
    close $f
    return [CorresNumberProbesetAgilent $Qui $Quoi]

}

proc CorresNumberProbesetAgilentLuc {Qui Quoi} {

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

    set F  "/home/ripp/GxHome/AgilentAnnot/GPL13607_family.soft"
    
    set LetsGo 0
    set PremiereFois 1
    set f [open $F r]
    set DoIt 1
    while {$DoIt} {
	gets $f Ligne
	puts "Ligne $Ligne"
	if {[regexp {^!platform_table_begin} $Ligne]} {
	    Espionne "entre1"
	    set LetsGo 1
	    continue
	}
	if {[regexp {^!platform_table_end} $Ligne]} {
	    Espionne "entre2"
	    set DoIt 0
	    update
	    break
	}
	if {! $LetsGo} {continue}
	if {$PremiereFois} {
	    set PremiereFois 0
	    continue
	}
	set LesMots  [split $Ligne "\t"]
	set Number   [lindex $LesMots 0]
	set Probeset [lindex $LesMots 1]
#	Espionne "$Number $Probeset"
	set CorresNumberProbesetAgilent($Number,Probeset) $Probeset
	set CorresNumberProbesetAgilent($Probeset,Number) $Number
    }
    close $f
    return [CorresNumberProbesetAgilent $Qui $Quoi]

}

proc CorresRA {} {

    set Fichier "[Fiches]/Orf2Cluster2Access2Def2Expression"
    set LesLignes [LesLignesDuFichier $Fichier]
    foreach Ligne $LesLignes {
	if { ! [regexp {^RA} $Ligne]} {continue}
	scan $Ligne "%s %s %s %s" RA1324 x y RA2717
	puts "$RA1324 => $RA2717"
    }

}

proc CorresVersionGenomeEtFichierRefGene {Version} {
    
    if {$Version == "mm9"}     {set Orga "Mus_musculus"}
    if {$Version == "mm10"}    {set Orga "Mus_musculus"}
    if {$Version == "hg18"}    {set Orga "Homo_sapiens"}
    if {$Version == "hg19"}    {set Orga "Homo_sapiens"}
    if {$Version == "rn4"}     {set Orga "Rattus_norvegicus"}
    if {$Version == "galGal3"} {set Orga "Gallus_gallus"}
    if {$Version == "dm3"}     {set Orga "Drosophilia_melanogaster"}
    if {$Version == "danRer6"} {set Orga "Danio_rerio"}
    set FichierRefGene "/genomics/link/UCSCGenomes/$Orga/database/$Version/last/refGene.txt"
    return $FichierRefGene

}

proc CorrespAliSeq {seq pos} {


# ATTENTION ! On considere ici numerotation commence a 1 !

    set seq [string range $seq 0 [expr $pos - 1]]
    regsub -all {\-} $seq "" seq

    return [string length $seq]

}

proc CorrespSeqAli {seq pos} {

    
# ATTENTION ! On considere ici numerotation commence a 1 !

    regsub -all -- {\-} $seq "" tmp
    set lsd [string length $tmp]
    if {$pos >= $lsd} {
	return [string length [string trimright $seq "-"]]
    }

    set c 0
    set i 0
    set lc [split $seq ""]
    foreach a $lc {
	incr i
	if {[string equal $a "-"]} {continue}
	incr c
	if {$c >= $pos} {return $i}
    }

    return $i

}

proc CorrespondanceAliPDB {molid x1 x2 seqass seqali} {


    set chn [DonneChainDeAccessPDB $molid]
    set mol [DonneIdDeAccessPDB $molid]

    global PDB_[set mol]_Sequence
    global PDB_[set mol]_NmrRes

    regsub -all {\.} [string range $seqali 0 $x1] "" str1
    set long1 [expr {[string length $str1] -1}]
    set b1 [lindex [set PDB_[set mol]_NmrRes($chn)] $long1]

    regsub -all {\.} [string range $seqali 0 $x2] "" str2
    set long2 [expr {[string length $str2] -1}]
    set b2 [lindex [set PDB_[set mol]_NmrRes($chn)] $long2]

    if {$b1 == ""} {set b1 -9999}
    if {$b2 == ""} {set b2 -9999}

    set lgth [expr {$b2 - $b1}]

    return [list $b1 $b2 $lgth]

}

proc CorrespondanceGenPDB {molid x} {

    # position generale commence a 0

    set molid [BonAccess $molid]
    set mol [DonneIdDeAccessPDB $molid]
    set chn [DonneChainDeAccessPDB $molid]
    if {$chn eq ""} {set chn "a"}

    set seq [set ::Sequences($molid)]
    set s1 [string map [list "Z" "" "." "" " " ""] [string range $seq 0 $x]]
    if {$s1 eq ""} {
	set b1 0
    } else {
	set long1 [expr {[string length $s1] -1}]
	set b1 [lindex [$mol _resnumber -chain $chn -polymer] $long1]
    }

    return $b1

}

proc CorrespondanceGenSeq {mol x} {

    # ATTENTION ! On considere ici numerotation 
    # commence a 0 !

    set seq [string map [list "." "" "Z" ""] [string range [set ::Sequences($mol)] 0 $x]]

    return [expr {[string length $seq] -1}]

}

proc CorrespondancePDBAli {MolId Chn Dep Fin SeqAlignee} {


    global PDB_[set MolId]_NmrRes

    set IdxPrem [lsearch [set PDB_[set MolId]_NmrRes($Chn)] $Dep]
    set IdxDern [lsearch [set PDB_[set MolId]_NmrRes($Chn)] $Fin]

    # Cherche correspondance entre no residus PDB et positions de
    # l'alignement global

    incr IdxPrem
    incr IdxDern

    set DebAli -9999
    set FinAli -9999
    set i -1
    set cpt 0
    regsub -all "Z" $SeqAlignee "." seq

    set Lc [split $seq ""]
    foreach a $Lc {
	incr i
	if {$a eq "."} {continue}
	incr cpt
	if {$cpt == $IdxPrem} {set DebAli $i}
	if {$cpt == $IdxDern} {
	    set FinAli $i
	    break
	}
    }

    return [list $DebAli $FinAli]

}

proc CorrespondancePDBGen {molid x} {

    # Renvoie position generale commencant a 0 !

    set molid [BonAccess $molid]
    set mol [DonneIdDeAccessPDB $molid]
    set chn [DonneChainDeAccessPDB $molid]
    if {$chn eq ""} {set chn "a"}

    set seq [set ::Sequences($molid)]
    set seq [string map [list Z .] $seq]
    set IdxPrem [lsearch [$mol _resnumber -chain $chn -polymer] $x]

    set i -1
    set cpt -1
    set Lc [split $seq ""]
    foreach a $Lc {
	incr i
	if {$a eq "."} {continue}
	incr cpt
	if {$cpt == $IdxPrem} {
	    break
	}
    }

    return $i

}

proc CorrespondanceSeqGen {mol x} {

    # ATTENTION ! On considere ici numerotation 
    # commence a 0 !

    set seq [set ::Sequences($mol)]
    set seq [string map [list "Z" "."] $seq]
    set tmp [string map [list "." ""]  $seq]
    set lsd [string length $tmp]
    if {$x >= $lsd} {
	return [expr {[string length [string trimright $seq "."]] - 1}]
    }

    set c -1
    set i -1
    foreach a [split $seq ""] {
	incr i
	if {$a eq "."} {continue}
	incr c
	if {$c >= $x} {return $i}
    }

    return $i

}

proc CorriGenes {Path} {


	# petit script de rattrappage :p

	set FichierDesAccess [open "$Path.txt" "r"]
	set FichierDesRequetes [open "/tmp/BirdCorrigene.bql" "w"]
	set FichierDesCoordonnees [open "$Path.coord" "w"]
	while { [gets $FichierDesAccess access]  >=0 } {
		puts $FichierDesRequetes "ID * DB UCSC"
		puts $FichierDesRequetes "WH SQLNATIVE SELECT access, chrom, txStart, txEnd, strand FROM ucschuman.GeCo WHERE access='$access' ORDER BY chrom, txStart"
		puts $FichierDesRequetes "LM 1"
		puts $FichierDesRequetes "#"
	}
	close $FichierDesRequetes
	close $FichierDesAccess
	BirdFetch "/tmp/BirdCorrigene.bql" "bird" "/tmp/BirdCorrigene.res"
	set FichierDesRequetesExecutees [open "/tmp/BirdCorrigene.res" "r"]
	set FichierDesRequetes [open "/tmp/BirdCorrigene.res" "r"]
	while { [gets $FichierDesRequetesExecutees Ligne]  >=0 } {
		gets $FichierDesRequetesExecutees Ligne
		set Liste [split $Ligne '|']
		ScanLaListe $Liste Access Start End Strand
		puts $FichierDesCoordonnees "$Start $End $Strand"
	}

	close $FichierDesCoordonnees

}

proc Corrige {} {

    set NouveauF "/genomics/link/HeadNecknonrnr/pourgscope_FromRegine_mbs_gscopecode"
    set NNF "/genomics/link/HeadNecknonrnr/pourgscope_FromRegine_mbs_gscopecode2"
    set n 0
    set b 0
    set F "/genomics/link/HeadNecknonrnr/mb_69_sansG"
    foreach Ligne [LesLignesDuFichier $NouveauF] {
	set Ligne [string trim $Ligne]
	if {$Ligne=={}} {continue}
	#AppendAuFichier $NNF $Ligne
	set CC [lindex $Ligne 0]
	set G [lindex $Ligne 1]
	if {$G==""} {incr n; AppendAuFichier $F $CC}
	if {$G!=""} {incr b}
    }
    return "ok: $b -- $n"

}

proc CorrigeAfterMe {} {

    FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait au temps ou il y avait AfterMe dans les BrocOli"
    foreach FO [lsort -decreasing [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $FO]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $FO]
	if { ! [regexp "AfterMe" $TFA]} { set PreviousTFA $TFA ; set PreviousP $P ; continue }
	if { ! [regexp $P $PreviousTFA]} { FaireLire $P }
	Espionne "$P $PreviousP"
	Espionne $TFA
	regsub "AfterMe" $TFA $PreviousP NewTFA
	Espionne $NewTFA
	Sauve $NewTFA dans $FO
    }

}

proc CorrigeAliasGnEVImm {} {

    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set F [GscopeFile $Nom "infos"]
	if {[FileExists $F]} {
	    set LesLignes {}
	    foreach Ligne [LesLignesDuFichier $F] {
		if {[regexp {^(AliasGnRna|AliasGnProt)} $Ligne]} {
		    regsub -all ", " $Ligne " " Ligne
		    regsub -all ","  $Ligne " " Ligne
		    while {[regexp "  " $Ligne]} { regsub -all "  " $Ligne " " Ligne }
		}
		lappend LesLignes $Ligne
	    }
	    SauveLesLignes $LesLignes dans $F
	}
	set F [GscopeFile $Nom "infosfiche"]
	if {[FileExists $F]} {
	    set LesLignes {}
	    foreach Ligne [LesLignesDuFichier $F] {
		if {[regexp {^(RnaAliasGn|ProtAliasGn)} $Ligne]} {
		    regsub -all ", " $Ligne " " Ligne
		    regsub -all ","  $Ligne " " Ligne
		    while {[regexp "  " $Ligne]} { regsub -all "  " $Ligne " " Ligne }
		}
		lappend LesLignes $Ligne
	    }
	    SauveLesLignes $LesLignes dans $F
	}
    }

}

proc CorrigeAnabaenaNostoc {} {

    global RepertoireDuGenome
    set LesBonnes {}
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/orthoblastp"] {
	regsub -all {Anabaena_sp\.} $Ligne "Anabaena_sp. Nostoc_sp." Bonne
	lappend LesBonnes $Bonne
    }
    Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/orthoblastp.mieux"]

    set LesBonnes {}
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ooblastp"] {
	regsub -all "ASP nsp " $Ligne "ASP NSP " Bonne
	lappend LesBonnes $Bonne
    }
    Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/ooblastp.mieux"]

    set LesBonnes {}
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ootblastn"] {
	regsub -all "asp NSP " $Ligne "ASP NSP " Bonne
	lappend LesBonnes $Bonne
    }
    Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/ootblastn.mieux"]
    exit

}

proc CorrigeBspBaph {} {

    exit
    file mkdir "[RepertoireDuGenome]/bilan_xhda_new"
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/bilan_xhda/$Nom"
	if { ! [file exists $Fichier]} { continue }
	set Nouveau {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp -nocase " BSP "  $Ligne]} { continue }
	    if {[regexp -nocase " BAPH " $Ligne]} {
		 regsub -nocase " BAPH " $Ligne " BSP " LigneBSP
		lappend Nouveau $LigneBSP
	    }
	    lappend Nouveau $Ligne	    
	}
	Espionne [SauveLesLignes $Nouveau dans "[RepertoireDuGenome]/bilan_xhda_new/$Nom"]
    }
    Espionne "Il faut encore renommer bilan_xhda_new"
    exit 

    foreach O [FamiliarOrganism "LaListeMerci"] {
	FaireLire "On y va pour $O" 
	set Court [string totitle [Glossaire $O Court]]
	if {$Court=="Saur"} { set Court "Saur2" }
	foreach Type [list blastp tblastn msf] {
	    set FichierOO "/genomics/$Court/fiches/oo$Type"
	    if { ! [file exists $FichierOO]} { continue }
	    set Vieux [Garde $FichierOO]
	    Espionne $Vieux
	    set Nouveau {}
	    foreach Ligne [LesLignesDuFichier $Vieux] {
		if {[regexp "BAPH BAPH " $Ligne]} {
		    regsub  "BAPH BAPH " $Ligne "BSP BAPH " Ligne
		}
		if {[regexp "Baph Baph " $Ligne]} {
		    regsub  "Baph Baph " $Ligne "Bsp Baph " Ligne
		}
		if {[regexp "baph baph " $Ligne]} {
		    regsub  "baph baph " $Ligne "bsp baph " Ligne
		}
		lappend Nouveau $Ligne
	    }
	    Espionne [SauveLesLignes $Nouveau dans $FichierOO]
	}
    }

}

proc CorrigeCAPweb {} {

    foreach F [LesLignesDuFichier "[HomeRipp]/CAPwebFichiersAModifier.txt"] {
	Espionne $F
	set V [lindex [glob -nocomplain "$F.2006*"] 0]
	set Texte [ContenuDuFichier $V]
	if { ! [regexp {^<\?} $Texte]} { continue }
#	Garde $F
	regsub {^<\?} $Texte "=0} {
	if {[regexp {^seq:} $Ligne]} {
	    regsub -all {[^ \|]+\|} $Ligne "" Ligne
	    set Ligne [string toupper $Ligne]
	    regsub -nocase "SEQ:"    $Ligne "seq:"     Ligne
	    regsub -nocase "POS:"    $Ligne "pos:"     Ligne
	    regsub -nocase "BEG:"    $Ligne "beg:"     Ligne
	    regsub -nocase "LEN:"    $Ligne "len:"     Ligne
	    regsub -nocase "WEIGHT:" $Ligne "weight:"  Ligne
	}
	lappend LesLignes $Ligne
    }
    close $F

    Sauve [join $LesLignes "\n"] dans $FichierAnchors
    return $FichierAnchors

}

proc CorrigeFichiersSequencage {} {

    set LesFiFas [lsort [glob -nocomplain *.fas]]
    foreach FiFas $LesFiFas {
	regsub {\.fas$} $FiFas "" Access
	regsub {\.fas$} $FiFas ".tfa" FiTfa
	if {[file exists $FiTfa]} { continue }
	set Fas [ContenuDuFichier $FiFas]
	regsub ">" $Fas ">$Access " Tfa
	Sauve $Tfa dans $FiTfa
	Espionne $FiTfa
    }

}

proc CorrigeGluOli {} {

    foreach Fichier [glob "[RepertoireDuGenome]/atelier/OligosKeeper/OligosKeeper2008071*.nots"] {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp "BrocOli" $Ligne]} { lappend New $Ligne ; continue }
	    regsub ">" $Ligne "" Ligne
	    scan $Ligne "%s %s %s %s %s %s" A BrocOli With B Replaces C
	    set LesA [split $A "+"]
	    Espionne $LesA
	    set LesA [ListeSansDoublon $LesA]
	    Espionne $LesA
	}
    }
    exit

}

proc CorrigeHistolica {} {

    foreach Nom [ListedesPABs] {
	Espionne $Nom
	set Info [ContenuDuFichier [GscopeFile $Nom "infos"]]
	regsub -all "histolica" $Info "histolytica" Info
	Sauve $Info dans [GscopeFile $Nom "infos"]
    }

}

proc CorrigeId {OldId} {

    if {![regexp "_" $OldId] } {return $OldId}
    return [string range $OldId 0 [expr [string first "_" $OldId] - 1]]

}

proc CorrigeInfosEVI {} {

    foreach Nom [ListeDesPABs] {
	set DE [ExtraitInfo $Nom "DE"]
	if {$DE!=""} {
	    InformeParSuppressionDuChamp $Nom "DE:"
	    InformeSansDemander $Nom "ValiDE: $DE"
	}#rR Debut de gscope_atelier.tcl

	set GN [ExtraitInfo $Nom "ValiGN"]
	if {[regexp -nocase (Fragment|Mouse) $GN]} {
	    InformeParSuppressionDuChamp $Nom "ValiGN:"
	    Espionne $GN
	}
    }

}

proc CorrigeInfosU33p2 {} {

    foreach Nom [ListeDesPABs] {
	set X [ExtraitInfo $Nom "OwnerOfCDNA"]
	if {[regexp {([0-9])_([0-9])} $X Match C1 C2]} {
	    regsub $Match $X "$C1 $C2" AcPs
	}
	scan $AcPs "%s %s" Ac Ps
	set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]
	set TFA [SequenceFormatTFA $Seq "$Nom Homo sapiens Chip U133p2 Probeset $Ps from $Ac"]
	Espionne "$Nom $X $Ac $Ps"
	Espionne $TFA
	InformeSansDemander $Nom "OriginalAc: $Ac"
	InformeSansDemander $Nom "OriginalPs: $Ps"
	InformeSansDemander $Nom "Alias: $Ps"
	Sauve $TFA dans [GscopeFile $Nom nuctfa]
    }

}

proc CorrigeLEC {EC} {

    set EC [string trim $EC]
    regsub -nocase {^ec[ \:]} $EC "" EC

    regsub -all {[\.\-]*$} $EC "" EC
    set LesNum [split $EC "."]
    set LEC {}
    if {[lindex $LesNum 0] != ""} {lappend LEC [lindex $LesNum 0]} else {lappend LEC "-"}
    if {[lindex $LesNum 1] != ""} {lappend LEC [lindex $LesNum 1]} else {lappend LEC "-"}
    if {[lindex $LesNum 2] != ""} {lappend LEC [lindex $LesNum 2]} else {lappend LEC "-"}
    if {[lindex $LesNum 3] != ""} {lappend LEC [lindex $LesNum 3]} else {lappend LEC "-"}
    return [join $LEC "."]

}

proc CorrigeLOrganisme {Organism} {

    if {[string equal -nocase "Rattus sp."  $Organism]} {return "Rattus norvegicus"}
    if {[string equal -nocase "Rattus sp"   $Organism]} {return "Rattus norvegicus"}
    if {[string equal -nocase "House mouse" $Organism]} {return "Mus musculus"     }
    set Organism [Glossaire $Organism Complet]
    if {$Organism != ""} {return $Organism}
    return "Unknown unknown"

}

proc CorrigeLaRequete {Requete} {

    set Requete [string trim $Requete]
    while {[regexp "  " $Requete]} {regsub -all "  " $Requete " " Requete}
    regsub -nocase "^ec " $Requete "" Requete
    return $Requete

}

proc CorrigeLesBestCops {} {

    set Compte 0
    set DeCompte 100
    foreach Fichier [lsort [glob "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterOld/*lesbestcops"]] {
	if { ! [incr DeCompte -1]} { Espionne "[incr Compte] $Fichier"; set DeCompte 100 }
	set Queue [file tail $Fichier]
	regsub {\-lesbestcops} $Queue "" Queue
	regsub {\-} $Queue {\\-} QX
	set LesAutres {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp "nbdecombinaison" $Ligne]} {set Nlu [IntegerApres "nbdecombinaison" dans $Ligne] ; continue}
	    regsub -all "/" $Ligne "-OU-" Ligne
	    if {[regexp "$QX " $Ligne]} {
		set MoiMeme $Ligne
		scan $MoiMeme "%d" N
		if {$Nlu!=$N} { FaireLire "$Queue $N $Nlu $Ligne" }
		continue
	    }
	    lappend LesAutres $Ligne
	}
	set LeNouveau [list $MoiMeme]
	LConcat LeNouveau $LesAutres
	SauveLesLignes $LeNouveau dans $Fichier
    } 

}

proc CorrigeLesBrocOlis {} {

#    if {[OuiOuNon "Attention il est dangereux de relancer CorrigeLesBrocOlis. STOP ?"]} { return "" }

    foreach N [VirtualPPCREnStock LaListeDesNs] {
	set P5 [VirtualPPCREnStock $N P5]
	if { ! [Oli $P5 "IsBrocOli"]} { continue }
	Espionne "[VirtualPPCREnStock $N]"
    } 

    foreach F [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $F]
	regsub ".tfa$" $P "" P
	set TFA [ContenuDuFichier $F]
	if {$TFA!=[Oli $P TFA]} { FaireLire "$TFA" }
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq [QueLaSequenceDuTexteTFA $TFA]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	set Full [StringApres "seeFull" dans $Entete]
	set EF [EnteteDuFichierTFA "[RepertoireDuGenome]/oligos/$Full.tfa"]
	set Broc [StringApres "seeBrocken" dans $EF]
	if {$Broc!=$P} { Espionne "$Entete\n$EF\n\n" }
	lappend LesB $P
    }
    AfficheListe $LesB "AvecOli" LesBrocOlis
    return 
    exit
    set DernierP 1120
    foreach F [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $F]
	regsub ".tfa$" $P "" P
	set TFA [ContenuDuFichier $F]
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq [QueLaSequenceDuTexteTFA $TFA]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	if {[regexp " replaces " $Entete]} { continue }
	if {[regexp " Rebuilded " $Entete]} { continue }
	regsub "/oligos/" $F "/oligos.20050930/" V
	if {[FileAbsent $V]} { FaireLire $V ; continue } 
	set VTFA [ContenuDuFichier $V]
	set VENT [EnteteDuTexteTFA $VTFA]
	set VSeq [QueLaSequenceDuTexteTFA $VTFA]
	set Coupe [StringApres "BrocOli with" dans $VENT]
	set Full [StringApres signal dans $Entete]
	regexp {_[^_]+$} $Coupe Ancre

	incr DernierP
	set NewP [format "P%4.4d" $DernierP]

	regsub "BrocOli with " $Entete "RebuildedBrockenOli of " NENT
	append NENT " seeBrocken $P"
	regsub {P[0-9]+ } $NENT "$NewP " NENT

	set BonVENT "$VENT replaces $Full seeFull $NewP"

	Espionne "\n\n$Entete\n$NENT\n$BonVENT"
	Espionne "$Seq\n$VSeq"
	Espionne "$Full $Coupe $Ancre"
	set Petit [SequenceFormatTFA $VSeq $BonVENT "nucbrut"]
	set Grand [SequenceFormatTFA $Seq  $NENT    "nucbrut"]
	
	Espionne "$Petit\n$Grand"
	Sauve $Petit dans "$F.new"
	Sauve $Grand dans "[RepertoireDuGenome]/oligos/$NewP.tfa.new"
	continue

	set Bon [string range $Entete 1 [incr I -1]]
	set New [SequenceFormatTFA $Seq $Bon "nucbrut"]
	Espionne "\n\n$TFA\n$New"
	Sauve $New dans $F
    }
    exit

    foreach P [Oli LaListeMerci] {
	set Entete [Oli $P Description]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	Espionne $Entete
	set Signaux [Oli $P Signals]
	set Subjects [Oli $P Subjects]
	set Broc [lindex $Subjects end]
	set SeqO [Oli $P Seq]

	set LesBroc [split $Broc "_"]
	set LesCoupes [lrange $LesBroc 0 end-1]
	set LesSeqB {}
	foreach B $LesCoupes {
	    lappend LesSeqB [Signal $B]
	}
	set SeqB [join $LesSeqB ""]
	set SignauxCoupes [join $LesCoupes "_"]
	set BonneSeq "$SeqB$SeqO"

	set LesOlis [split $Signaux "_"]
	set LesBonsSignaux [concat $LesCoupes $LesOlis]
	set BonsSignaux [join $LesBonsSignaux "_"]
	regsub "with signal " $Entete "with signal ${SignauxCoupes}_" BonneEntete

	Espionne "$P $Signaux $Broc $BonsSignaux"	
	set BonTFA [SequenceFormatTFA $BonneSeq $BonneEntete "nucbrut"]
	Espionne [Sauve $BonTFA dans [FiSeqOl $P]]
    }

}

proc CorrigeLesDescriptifs {} {

    set LesOS [QuestionDeScience "CilioCarta" "FromOrthoInspector ListOf OS"]
    set LesNouveaux {}
    foreach Nom [ListeDesPABs] {
	set  FichierDescriptif [GscopeFile $Nom descriptifs]
	if {[FileAbsent $FichierDescriptif]} { continue }
	set LeNew {}
	set YaDuNeuf 0
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    if { ! [regexp {OS\:  GN\:} $Ligne]} { lappend LeNew $Ligne; continue }
	    if { ! [regexp {DE\:([A-Z][a-z]+) ([a-z\.]+) } $Ligne Match G E]} { lappend LeNew $Ligne; continue }
	    set YaDuNeuf 1
	    set New $Ligne
	    regsub {OS\:  GN\:}                    $New "OS:$G $E GN:" New
	    regsub {DE\:([A-Z][a-z]+) ([a-z\.]+) } $New "DE:"           New
	}
	if {$YaDuNeuf} {
	    SauveLesLignes $LeNew dans $FichierDescriptif
	    lappend LesNouveaux $FichierDescriptif
	}
    }
    return $LesNouveaux

}

proc CorrigeLesDescriptifsEnSupprimantRootEtCellularOrganism {} {

    set LesNouveaux {}
    foreach Nom [ListeDesPABs] {
	set  FichierDescriptif [GscopeFile $Nom descriptifs]
	if {[FileAbsent $FichierDescriptif]} { continue }
	set LeNew {}
	set YaDuNeuf 0
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    set New $Ligne
	    if { [regexp {OC\:root; cellular organisms; } $New]} {
		incr YaDuNeuf 1
		regsub {OC\:root; cellular organisms; } $New "OC:" New
	    }
	    if { [regexp {Opisthokonta; } $New]} {
		incr YaDuNeuf 1
		regsub {Opisthokonta; } $New "" New
	    }
	    lappend LeNew $New
	}
	if {$YaDuNeuf} {
	    Espionne "$Nom $YaDuNeuf"
	    SauveLesLignes $LeNew dans $FichierDescriptif
	    lappend LesNouveaux $FichierDescriptif
	}
    }
    return $LesNouveaux

}

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 CorrigeLesOrganismesDansDisphy {} {

    global RepertoireDuGenome

    foreach Fichier [glob "$RepertoireDuGenome/disphy/[PreFixe]*"] {
	set Nom [file tail $Fichier]
	LeDescriptif PourQuIlSoitCharge $Nom
	set LesLignes [LesLignesDuFichier $Fichier]
	if { ! [regexp "ukno|uukn|xxxx|iinc" [join $LesLignes "\n"]]} { continue }
	set Nouveau {}
	foreach Ligne $LesLignes {
	    scan $Ligne "%s %d %s" Orga Dist Access
#	    set UnPrecis [regexp {^PAE[0-9]+} $Access] 
	    if {[regexp "ukno|uukn|xxxx|iinc" $Orga]} {
		set OldOrga $Orga
		set MeilleurOrga [OrgaDuAccess $Access Court]
		if {$MeilleurOrga!=""} { set Orga $MeilleurOrga }
		Espionne "$Nom $Access $OldOrga $Orga"
	    }
	    foreach O [SplitOrgas $Orga] {
		lappend Nouveau "$O $Dist $Access"
	    }
	}
	Espionne [SauveLesLignes $Nouveau dans $Fichier]
    }
    CreeDistancesPhyloAvecLesMSFs

}

proc CorrigeLesOutliers {} {

    FaireLire "Attention obsolete"
    exit
    foreach Fichier [glob "[RepertoireDuGenome]/outlier/*"] {
	set Texte [ContenuDuFichier $Fichier]
	if {[regexp "^I\ndid" $Texte]} {
	    Espionne $Fichier
	    Sauve "I didn't find any Batrachochytrium_dendrobatidis or Fungi" dans $Fichier
	}
    }
    exit

}

proc CorrigeLesRebuildedBrocOli {} {

    FaireLire "ne pas relancer."
    exit
    set LesFichiers [lsort [glob "[RepertoireDuGenome]/oligos/*.tfa"]]
    foreach Fichier $LesFichiers {
	set P [file tail $Fichier]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $Fichier]
	if { ! [regexp "Rebuilded" $TFA]} { continue }
	if { ! [regexp {\+} $TFA]} { continue }
	set Rac [QueLaSequenceDuTexteTFA $TFA]
	set Seq [NucToReverseAndComplementNuc $Rac]
	set Ensembles [StringApres "with signal" dans $TFA]
	set LesEnsembles [split $Ensembles "+"]
	foreach Signaux $LesEnsembles {
	    set LesSignal [split $Signaux "_"]
	    set LesSignalInverse [RetourneLaListe $LesSignal]
	    set Trouve ""
	    set Gagne 1
	    foreach NS $LesSignalInverse {
		set S [Signal $NS "SEQ"]
		if { ! [regexp -nocase $S $Seq]} {set Gagne 0 ;  break }
		append Trouve " $NS"
	    }
	    if {$Gagne} {
		Espionne "$P $Signaux $Trouve"
		set I [string first $Signaux $Ensembles]
		set Vide [string repeat " " $I]
		Espionne "il faudrait remplacer \n$Ensembles\n$Vide$Signaux"
	    }
	    regsub -all {\+} $Ensembles "\\+" E
	    regsub $E $TFA $Signaux NewTFA
	    Espionne $NewTFA
	    Sauve $NewTFA dans $Fichier
	}
    }
    exit

}

proc CorrigeLesSujetsDesBrocoli {} {

    foreach P [Oli "LaListeMerci"] {
	set LesSubjects [Oli $P "Subjects"]
	set Signals [Oli $P "Signals"]
	foreach Sujet $LesSubjects {
	    set SS "${Signals}_$Sujet"
	    regsub {\-[0-9]+$} $SS "" SSDebut
	    lappend LesPsDuSS($SS) $P
	    lappend LesPsDuSS($SSDebut) $P
	    lappend LesPsDuSS($SSDebut,Complet) $SS
	}
    }
  
    foreach FO [glob -nocomplain "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] {
	set Rep [file dirname $FO]
	set ShowFO 1
	foreach Access [LaSequenceDuTFAs $FO "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FO $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    if { ! [regexp "^>AttB1_" $Entete]} { continue }
	    scan $Entete "%s" SS
	    regsub ">" $SS "" SS
	    if {[info exists LesPsDuSS($SS)]} { continue }

	    set Sujet [lindex [split $SS "_"] end]
	    regsub {\-[0-9]+$} $SS "" SSDebut	    
	    if {[info exists LesPsDuSS($SSDebut)]} {
		if {$ShowFO} { Espionne "\n$FO" ; set ShowFO 0 }
		Espionne "pas de ref pout $SS"
		set P $LesPsDuSS($SSDebut)
		scan $P "%s" P
		if {[info exists MeilleurDP($P)]} {
		    set DP $MeilleurDP($P)
		} else {
		    set DP [Oli $P Description]
		}
		regsub " RebuildedBrockenOli" $DP " $Sujet RebuildedBrockenOli" DPOk
		set MeilleurDP($P) $DPOk
		set B [Oli $P "Brocken"]
		if {[info exists MeilleurDB($B)]} {
		    set DB $MeilleurDB($B)
		} else {
		    set DB [Oli $B Description]
		}
		regsub " BrocOli" $DB " $Sujet BrocOli" DBOk
		set MeilleurDB($B) $DBOk
		Espionne "$SS\n$SSDebut\n$LesPsDuSS($SSDebut,Complet)\n$DP\n$DPOk\n$DB\n$DBOk\n"
		set SeqP [Oli $P "Seq"]
		set BonP [SequenceFormatTFA $SeqP $DPOk]
		Espionne $BonP
		Sauve $BonP dans "[RepertoireDuGenome]/oligos/$P.tfa"
		set SeqB [Oli $B "Seq"]
		set BonB [SequenceFormatTFA $SeqB $DBOk]
		Espionne $BonB
		Sauve $BonB dans "[RepertoireDuGenome]/oligos/$B.tfa"
	    } else {
		if {$ShowFO} { Espionne $FO ; set ShowFO 0 }
		Espionne "$SS introuvable" 
	    }
	    set LesSignaux [lrange [split $SS "_"] 0 end-1]
	    set Sujet [lindex [split $SS "_"] end]
	}
    }
    exit

}

proc CorrigeLesSujetsDesMultiples {} {

    foreach P [Oli "LaListeMerci"] {
	set LesSubjects [Oli $P "Subjects"]
	set Signals [Oli $P "Signals"]
	foreach Sujet $LesSubjects {
	    if {[Oli $P "Sens"]=="5'"} {
		set SS "${Signals}_$Sujet"
		lappend LesPsDuSS($SS) $P
		regsub {\-[0-9]+$} $SS "" SSDebut
		lappend LesPsDuSS($SSDebut) $P
		lappend LesPsDuSS($SSDebut,Complet) $SS
	    } else {
		set SS "${Sujet}_$Signals"
		lappend LesPsDuSS($SS) $P
		if { ! [regexp {\-([0-9]+)\-([0-9]+)_} $SS Match Deb Fin]} { continue }
		regsub {\-([0-9]+)\-([0-9]+)$} $Sujet "" Gene
		lappend LesPsDuSS($Gene,$Fin) $P
		lappend LesPsDuSS($Gene,$Fin,Complet) $SS
	    }
	}
    }
    foreach FO [glob -nocomplain "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] {
	set Rep [file dirname $FO]
	set ShowFO 1
	foreach Access [LaSequenceDuTFAs $FO "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FO $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    scan $Entete "%s" SS
	    regsub ">" $SS "" SS
	    if {[regexp "SeqOli_" $SS]} { continue }
	    if {[info exists LesPsDuSS($SS)]} { continue }
	    Espionne $SS
	    if {[regexp "^AttB1" $SS]} { continue }
	    if { ! [regexp {\-([0-9]+)\-([0-9]+)_} $SS Match Deb Fin]} { continue }
	    regsub {\-([0-9]+)\-([0-9]+)_.+} $SS "" Gene
	    Espionne "$SS $Gene $Deb $Fin"
	    if {[info exists LesPsDuSS($Gene,$Fin)]} {
		if {$ShowFO} { Espionne "\n$FO" ; set ShowFO 0 }
		Espionne "pas de ref pout $SS"
		set P $LesPsDuSS($Gene,$Fin)
		scan $P "%s" P
		if {[info exists MeilleurDP($P)]} {
		    set DP $MeilleurDP($P)
		} else {
		    set DP [Oli $P Description]
		}
		set Sujet "$Gene-$Deb-$Fin"
		set DPOk "$DP $Sujet"
		set MeilleurDP($P) $DPOk
		Espionne "$SS\n$Deb $Fin\n$LesPsDuSS($Gene,$Fin,Complet)"
		Espionne "  $DP\n  $DPOk"
		set SeqP [Oli $P "Seq"]
		set BonP [SequenceFormatTFA $SeqP $DPOk]
		Espionne $BonP
		Sauve $BonP dans "[RepertoireDuGenome]/oligos/$P.tfa"
	    } else {
		if {$ShowFO} { Espionne $FO ; set ShowFO 0 }
		Espionne "$SS introuvable" 
	    }
	}
    }
    exit

}

proc CorrigeMGU {} {

    foreach Fichier [glob "/genomics/link/MGU4302/ngn3_644gbForAnnot/AllFasta/*"] {
	set Queue [file tail $Fichier]
	if {[regexp {[A-Z]+[0-9]+_} $Queue Match]} {
	    regsub $Match $Queue "" PS
	    lappend LeFOF "$PS $Fichier"
	    continue
	    set TFA [ContenuDuFichier $Fichier]
	    if {[regexp "ID   " $TFA]} {
		set TFA [SequenceFormatTFA $TFA "" "embl"]
		regsub ">" $TFA ">$PS " TFA
		Sauve $TFA dans $Fichier
	    } else {
		Espionne $TFA 
		scan $TFA "%s %s %s" A PSV merde
		regsub -all {\|} $merde {\\|} merde
		set PS [string trim $PSV ","]
		regsub ">" $A "" Acc
		regsub "$A $PSV $merde" $TFA ">$PS $Acc" TFA  
		Espionne $TFA
		Sauve $TFA dans $Fichier
	    }
	} else {
	    regexp {([A-Z]+_[0-9]+)_(.+)} $Queue Match Acc PS
	    lappend LeFOF "$PS $Fichier"
	    continue
	    Espionne "$Queue $Acc $PS"
	    set TFA [ContenuDuFichier $Fichier]
	    Espionne $TFA
	    regsub {>[^ ]+ } $TFA ">$PS $Acc " TFA
	    Espionne $TFA
	    Sauve $TFA dans $Fichier
	}
    }
    SauveLesLignes $LeFOF dans lefof.fof

}

proc CorrigeOo {{Oo ""}} {

    set LesOrgas {}
    foreach Complet [LesGenomesDansLeBonOrdre] {
	lappend LesOrganismes $Complet
	lappend LesOrgas [Glossaire $Complet Court]
    }
    set FichierOo "[RepertoireDuGenome]/fiches/$Oo"
    set Different 0
    set Hit(Bidon) "coucou"
    foreach Ligne [LesLignesDuFichier $FichierOo] {
	set LesMots [LesMotsDeLaLigne $Ligne]
	set Nom [lindex $LesMots 0]
	unset Hit
	foreach Mot [lrange $LesMots 1 end] {
	    set Orga [string tolower $Mot]
	    set Hit($Orga) $Mot
	}
	set LeNew [list $Nom]
	foreach Orga $LesOrgas {
	    set o [string tolower $Orga]
	    if {[info exists Hit($Orga)]} { Espionne "$o $Orga $Hit($Orga)" ; set o $Hit($Orga) }
	    lappend LeNew $o
	}
	set New [join $LeNew " "]
	if {$New!=$Ligne} { set Different 1 }
	lappend LeBonOo $New
    }
    if { ! $Different} { return "" }
    Garde $FichierOo
    return [SauveLesLignes $LeBonOo dans $FichierOo]

}

proc CorrigeOuATapeTBlastN {} {

    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ouatapetbn.myself"] {
	if { ! [regexp ">" $Ligne]} {continue}
	lappend LeNeuf $Ligne
    }
    SauveLesLignes $LeNeuf dans "[RepertoireDuGenome]/fiches/ouatapetbn.myself"
    exit

}

proc CorrigeParser {Fichier} {

    set LeNew {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	lassign [split $Ligne "\t"] I G T L C P
	regsub {\(\)}      $C "" C
	regsub {\([0-9]+ } $C "" C
	regsub {\)}        $C "" C
	regsub -all {\,[0-9]+}  $C "" C
	set New "$I\t$G\t$T\t$L\t$P\t$C"
	Espionne $Ligne
	Espionne $New
	lappend LeNew $New
    }
    SauveLesLignes $LeNew dans $Fichier
    return $Fichier.new
    

}

proc CorrigeProteinesJumelles_AL {FilePJ} {

    set i 0
    set F [open $FilePJ]
    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == ""} {continue}
	foreach Nom [split $Ligne "\t"] {
	    if {$Nom == ""} {continue}
	    set TabDejaVu($Nom) 1
	    incr i
	}
    }
    close $F


    set LesNomsSelected {}
    set i 0
    foreach Nom [ListeDesPABs] {
	if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue}
	if {[info exists TabDejaVu($Nom)]} {continue}
	Espionne "$Nom j'ai la proteine mais je ne suis pas dans le fichier"
	AppendAuFichier $FilePJ $Nom
    }

    return

}

proc CorrigeRebuilded {} {

    FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait pour corriger les without signal du STREP"
    foreach FO [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $FO]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $FO]
	if { ! [regexp "RebuildedBrockenOli" $TFA]} { continue }
	if { ! [regexp "without signal"      $TFA]} { continue }
	set Entete [EnteteDuTexteTFA $TFA]
	set B [StringApres "seeBrocken " dans $Entete]
	regsub $P $FO $B FB
	set EB [EnteteDuFichierTFA $FB]
	set NewEntete ">[FormatageEntete $EB "PourOligoNonBrocOli" $P] seeBrocken $B"
	Espionne 
	Espionne "$Entete"
	Espionne "$NewEntete"
	regsub $Entete $TFA $NewEntete NewTFA
	Espionne "$TFA\n$NewTFA"
#	Sauve $NewTFA dans $FO
    }

}

proc CorrigeRec2 {} {

    foreach Fichier [glob "[RepertoireDuGenome]/rec2/N*"] {
	set Queue [file tail $Fichier]
	set TFA [ContenuDuFichier $Fichier]
	set Entete [EnteteDuTexteTFA $TFA]
	scan $Entete "%s" Access
	regsub ">" $Access "" Access
	set pDEST [lindex [split $Access "_"] end]
	regsub "_$pDEST$" $Access "" Rec1
	regsub "Rec2 with " $Entete "Rec2 in $pDEST of $Rec1 Rec1 in " NouvelleEntete
	set LeTFA [split $TFA "\n"]
	set LeNouveauTFA [list $NouvelleEntete]
	LConcat LeNouveauTFA [lrange $LeTFA 1 end]
	Espionne [SauveLesLignes $LeNouveauTFA dans "[RepertoireDuGenome]/rec2nouveau/$Queue" ]
    }

}

proc CorrigeSummary {} {

    set Rep "[HomeRipp]/sear"
    cd $Rep 
    foreach Racine [glob -types d *] {
	set FichierSummary "$Racine/Summary.txt"
	if {[FileAbsent $FichierSummary]} { continue }
	Espionne "\n\n$Racine"
	set LeSummary [LesLignesDuFichier $FichierSummary]
	set LeNew {}
	set Precedent ""
	foreach Ligne $LeSummary {
	    if {[regexp "^Initial" $Ligne] && [regexp "^Initial" $Precedent]} { continue }
	    set Precedent $Ligne
	    set LesMots [split $Ligne ";"]
	    set PN   [lindex $LesMots 2]
	    set Name [lindex $LesMots 4]
	    if {$PN!=$Name} { Espionne "$Racine $Ligne" }
	    lappend LeNew $Ligne
	}
#	Garde $FichierSummary
#	SauveLesLignes $LeNew dans $FichierSummary 
    }


}

proc CorrigeSynMito {} {

    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	set FichierTFA [GscopeFile $Nom prottfa]
	set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
	set TFA [SequenceFormatTFA $Seq ">$Nom Homo sapiens mitochondrial aaRS $Alias" "protbrut"]
	InformeSansDemander $Nom "ValiDE: mitochondrial aaRS $Alias"
	InformeSansDemander $Nom "ValiGN: $Alias"
	Sauve $TFA dans $FichierTFA
    }

}

proc CorrigeTFA {} {

    global RepertoireDuGenome
    foreach Nom [ListeDesPABs] {
	set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
	if { ! [file exists $FichierTFA]} { FaireLire "$FichierTFA n'existe pas" }
	set TFA [ContenuDuFichier $FichierTFA]
	Espionne [string range $TFA 0 100]
	regsub -nocase {^>[a-z0-9]+ [0-9]+ [0-9]+ [FR]+} $TFA ">$Nom" TFA
	Espionne [string range $TFA 0 100]
    }

}

proc CorrigeU133 {{Rep ""}} {

    foreach Fichier [glob "[RepertoireDuGenome]/$Rep/FASTA_NM/*"] {
	set Queue [file tail $Fichier]
	Espionne $Queue
	if {[regexp {[A-Z]+[0-9]+_} $Queue Match]} {
	    regsub $Match $Queue "" PS
	    regsub "_$" $Match "" Access
	    Espionne $PS
	    lappend LeFOF "$PS $Fichier"
	    set TFA [ContenuDuFichier $Fichier]
	    if {[regexp "ID   " $TFA]} {
		set TFA [SequenceFormatTFA $TFA "" "embl"]
		regsub ">" $TFA ">$PS " TFA
		Espionne "coucou" 
		Espionne $TFA
		Sauve $TFA dans $Fichier
	    } else {
		set Entete [EnteteDuTexteTFA $TFA]
		set Seq [QueLaSequenceDuTexteTFA $TFA]
		set I -1
		set LesMots [LesMotsDeLaLigne $Entete]
		set LeChoix {}
		while {[incr I]<4} {
		    set Choix [join [lrange $LesMots $I end] " "]
		    lappend LeChoix $Choix
		}
		set BelleEntete "$PS [ChoixParmi $LeChoix] from $Access"
		set TFA [SequenceFormatTFA $Seq $BelleEntete "nucbrut"]
		Espionne $TFA
		Sauve $TFA dans $Fichier
	    }
	} else {
	    regexp {([A-Z]+_[0-9]+)_(.+)} $Queue Match Acc PS
	    lappend LeFOF "$PS $Fichier"
	    continue
	    Espionne "$Queue $Acc $PS"
	    set TFA [ContenuDuFichier $Fichier]
	    Espionne $TFA
	    regsub {>[^ ]+ } $TFA ">$PS $Acc " TFA
	    Espionne $TFA
	    Sauve $TFA dans $Fichier
	}
    }
    SauveLesLignes $LeFOF dans lefof.fof
    return $LeFOF

}

proc CorrigeUneExpressionDansLesInfos {Old New {Confirmation SansConfirmation}} {

    global RepertoireDuGenome

    set SansConfirmation [string compare $Confirmation "AvecConfirmation"]

    foreach Fichier [glob "$RepertoireDuGenome/infos/*"] {
	set Nom [file tail $Fichier]
	set LesNouvellesLignes {}
	set YaModif 0
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if {[regexp $Old $Ligne]} {
		if {$SansConfirmation || [OuiOuNon "Je corrige $Nom\n$Ligne\n  ?"]} {
		    set YaModif 1
		    regsub $Old $Ligne $New Ligne
		}
	    }
	    lappend LesNouvellesLignes $Ligne
	}
	if {$YaModif} {
	    Espionne [SauveLesLignes $LesNouvellesLignes dans $Fichier]
	}
    }

}

proc CorrigeValiGNSiPresenceName {} {

    set LesCorriges {}
    foreach Nom [ListeDesPABs] {
	set ValiGN [ValiGN $Nom]
	if { ! [regexp {^Name=([^;]+);} $ValiGN Match GN]} { continue }
	lappend LesCorriges "$Nom $GN $ValiGN" 
	InformeSansDemander $Nom "=ValiGN: $GN"
    }
    return $LesCorriges

}

proc CorrigerChromosome {Path} {

	Espionne $Path
	set FichierEntree [open "$Path.coord" "r"]
	set FichierSortie [open "$Path.coo" "w"]	
	set Chromosome [regexp -all -inline {^chr[0-9A-Z]{1,2}} $Path]
	while { [gets $FichierEntree Ligne]  >=0 } {
		ScanLaListe $Ligne nbMatchs sequenceNumber matchStart matchEnd matchType hs1Mistake hs2Mistake matchSequence
		puts $FichierSortie "$nbMatchs $Chromosome $matchStart $matchEnd $matchType $hs1Mistake $hs2Mistake $matchSequence"
	}
	close $FichierEntree
	close $FichierSortie

}

proc CorrigerLongueurMatInspector {Path} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "CorrigerLongueurMatInspector : Start"
	set FileIn [open "$Path.coord" "r"]
	set FileOut [open "$Path.coo" "w"]
	while { [gets $FileIn Ligne]  >=0 } {
		ScanLaListe $Ligne ID ChromosomeH StartH EndH OrientationH ActacaH SequenceH ScoreH UpstreamH DownStreamH
		if {$OrientationH == "-"} {
			set StartH [expr $StartH + 1]
		} else {
			set EndH [expr $EndH - 1]
		}
		puts $FileOut "$ID $ChromosomeH $StartH $EndH $OrientationH $ActacaH $SequenceH $ScoreH $UpstreamH $DownStreamH"
	}
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "CorrigerLongueurMatInspector : End"
	close $FileIn
	close $FileOut

}

proc CoucouDeMickael {} {

    return "Coucou de Mickael"

}

proc CoucouFromJulie {} {

    return "Hello from Julie"

}

proc CoucouHtml {} {

    return "
Coucou
"


}

proc CouleurAuNombreDeCopainsDansBlast {nCops {K ""}} {


    global SeuilsNbCops
    if { ! [info exists SeuilsNbCops]} {
	if {[OnTraiteMS2PH]} {
	    set SeuilsNbCops(30) 300
	    set SeuilsNbCops(10) 100
	    set SeuilsNbCops(5)   50
	    set SeuilsNbCops(2)    2
	    set SeuilsNbCops(1)    1
	    set SeuilsNbCops(0)    0
	    set SeuilsNbCops(-1)  -1
	} elseif {[OnTraite "BaDe"]} {
	    set SeuilsNbCops(30) 300
	    set SeuilsNbCops(10) 100
	    set SeuilsNbCops(5)   50
	    set SeuilsNbCops(2)   10
	    set SeuilsNbCops(1)    1
	    set SeuilsNbCops(0)    0
	    set SeuilsNbCops(-1)  -1
	} elseif {[OnTraite "CilioCarta" "Like"]} {
	    set SeuilsNbCops(30) 5000
	    set SeuilsNbCops(10) 2500
	    set SeuilsNbCops(5)   500
	    set SeuilsNbCops(2)   100
	    set SeuilsNbCops(1)    3
	    set SeuilsNbCops(0)    0
	    set SeuilsNbCops(-1)  -1
	} elseif {[regexp "MsFinal" [RepertoireDuGenome]]} {
	    set SeuilsNbCops(30) 300
	    set SeuilsNbCops(10) 100
	    set SeuilsNbCops(5)   50
	    set SeuilsNbCops(2)   10
	    set SeuilsNbCops(1)    1
	    set SeuilsNbCops(0)    0
	    set SeuilsNbCops(-1)  -1
	} else {
	    #rR modifie 2014/03/28 car on en a beaucoup de nos jours !!!
	    set SeuilsNbCops(30) 200
	    set SeuilsNbCops(10) 100
	    set SeuilsNbCops(5)   10
	    set SeuilsNbCops(2)    5
	    set SeuilsNbCops(1)    1
	    set SeuilsNbCops(0)    0
	    set SeuilsNbCops(-1)  -1
	}
    }

    if {$nCops=="SetAllSignification"} {
	SetSignification $K red     "Blast hits : $SeuilsNbCops(30) <= n"
	SetSignification $K orange  "Blast hits : $SeuilsNbCops(10) <= n <  $SeuilsNbCops(30)"
	SetSignification $K yellow  "Blast hits : $SeuilsNbCops(5) <= n <  $SeuilsNbCops(10)"
	SetSignification $K green   "Blast hits : $SeuilsNbCops(2) <= n <  $SeuilsNbCops(5)"
	SetSignification $K blue    "Blast hits : $SeuilsNbCops(1) <  n <  $SeuilsNbCops(2)"
	SetSignification $K cyan    "Blast hits : $SeuilsNbCops(1)  = n      "
	SetSignification $K white   "Blast hits : $SeuilsNbCops(0)  = n      "
	SetSignification $K grey    "Blast hits : no value available"
	return
    }
    if {[expr $SeuilsNbCops(30) <= $nCops]} { return "red"}
    if {[expr $SeuilsNbCops(10) <= $nCops]} { return "orange"}
    if {[expr  $SeuilsNbCops(5) <= $nCops]} { return "yellow"}
    if {[expr  $SeuilsNbCops(2) <= $nCops]} { return "green"}
    if {[expr  $SeuilsNbCops(1) <  $nCops]} { return "cyan"}
    if {[expr  $SeuilsNbCops(1) == $nCops]} { return "blue"}
    if {[expr  $SeuilsNbCops(0) == $nCops]} { return "white"}
    if {[expr $SeuilsNbCops(-1) == $nCops]} { return "grey"}
    return "black"

}

proc CouleurDeAtome {a} {

    switch [string index [string trim $a] 0] {
	"C"  {set col [list 1. 1. 0.]}
	"N"  {set col [list 0. 0. 1.]}
	"O"  {set col [list 1. 0. 0.]}
	"P"  {set col [list 1. 1. 0.]}
	"S"  {set col [list 0. 1. 0.]}
	"Se" {set col [list 0. 1. 0.]}
	"H"  {set col [list 1. 1. 1.]}
	"6"  {set col [list 1. 1. 0.]}
	"7"  {set col [list 0. 0. 1.]}
	"8"  {set col [list 1. 0. 0.]}
	"15"  {set col [list 1. 0. 0.]}
	"16"  {set col [list 0. 1. 0.]}
	"34"  {set col [list 0. 1. 0.]}
	"1" {set col [list 1. 1. 1.]}
	default {set col [list 1. 0. 0.]}
    }

    return $col

}

proc CouleurDeLOligo {NbCandidat} {

    
    Wup "Retourne une couleur de boite en fonction du nombre de candidats"

    if {$NbCandidat==""} {return "black"}

    set CouleurDeLOligo ""
    switch -exact -- $NbCandidat {
	"-1" {set CouleurDeLOligo "black"}
	"0"  {set CouleurDeLOligo "white"}
	"1"  {set CouleurDeLOligo "green3"}
	"2"  {set CouleurDeLOligo "skyblue"}
	"3"  {set CouleurDeLOligo "Yellow2"}
	"4"  {set CouleurDeLOligo "Yellow2"}
	"5"  {set CouleurDeLOligo "Yellow2"}
	"6"  {set CouleurDeLOligo "orange"}
	"7"  {set CouleurDeLOligo "orange"}
	"8"  {set CouleurDeLOligo "orange"}
    }
    if {   $CouleurDeLOligo==""} {set CouleurDeLOligo "red"}
    return $CouleurDeLOligo

}

proc CouleurDeLaBandeCytologique {Type} {

    if {$Type == "centromere"} {
	set ColorFill "yellow"
    } elseif {$Type == "other1"} {
	set ColorFill "green"
    } elseif {$Type == "other2"} {
	set ColorFill "orange"
    } elseif {$Type == "darkgrey"} {
	set ColorFill "grey25"
    } elseif {$Type == "grey"} {
	set ColorFill "grey50"
    } elseif {$Type == "lightgrey"} {
	set ColorFill "grey90"
    } elseif {$Type == "black"} {
	set ColorFill "black"
    } elseif {$Type == "white"} {
	set ColorFill "white"
    } else {
	set ColorFill "pink"
    }
    return $ColorFill

}

proc CouleurDeLaBandeCytologique_TL {Type} {

    if {$Type == "centromere"} {
	set ColorFill "#ffffffff5374"
    } elseif {$Type == "other1"} {
	set ColorFill "#a72affffa72a"
    } elseif {$Type == "other2"} {
	set ColorFill "#99dbc188ffff"
    } elseif {$Type == "darkgrey"} {
	set ColorFill "grey25"
    } elseif {$Type == "grey"} {
	set ColorFill "grey50"
    } elseif {$Type == "lightgrey"} {
	set ColorFill "grey90"
    } elseif {$Type == "black"} {
	set ColorFill "black"
    } elseif {$Type == "white"} {
	set ColorFill "white"
    } else {
	set ColorFill "pink"
    }
    return $ColorFill

}

proc CouleurDeLaBoite {Boite TypeDeCouleur} {

    global RepertoireDuGenome
    global CouleurDeFrame
    global CouleurDuFond

    set Nom [Box $Boite nom]

    return [CouleurParTypeEtNom $TypeDeCouleur $Nom]

}

proc CouleurDeLaLettre {Lettre {PourQui ""}} {

    global CouleurDuFond
    if {[regexp "HNR" [RepertoireDuGenome]]} {
	if { $Lettre == " " } { return "white" }
	if { $Lettre == "." } { return "white" }
	if { $PourQui == "PourExpo" } { return "grey" }
    } else {
	if { $Lettre == " " } { return $CouleurDuFond }
	if { $Lettre == "." } { return "grey" }
	if { $PourQui == "PourExpo" } { return "red" }
    }
    if {[regexp -nocase {[PAGST]} $Lettre]} { return "yellow"}
    if {[regexp -nocase {[DEQN]}  $Lettre]} { return "green"}
    if {[regexp -nocase {[KRH]}   $Lettre]} { return "blue"}
    if {[regexp -nocase {[ILMV]}  $Lettre]} { return "red"}
    if {[regexp -nocase {[FYW]}   $Lettre]} { return "pink"}
    if {[regexp -nocase {[CX]}    $Lettre]} { return "black"}
    Warne "$Lettre non colore"
    return "purple"

}

proc CouleurDeLaPopulation {n} {

    if {      $n == 1} {
	return "white"
    } elseif {2 <= $n   && $n <= 3   } {
	return "grey90"
    } elseif {4 <= $n   && $n <= 7   } {
	return "grey80"
    } elseif {8 <= $n   && $n <= 15  } {
	return "grey70"
    } elseif {16 <= $n  && $n <= 31  } {
	return "grey60"
    } elseif {32 <= $n  && $n <= 63  } {
	return "grey50"
    } elseif {64 <= $n  && $n <= 127 } {
	return "grey40"
    } elseif {128 <= $n && $n <= 255 } {
	return "grey30"
    } elseif {256 <= $n && $n <= 511 } {
	return "grey20"
    } elseif {512 <= $n && $n <= 1023} {
	return "grey10"
    } elseif {1024 <= $n            } {
	return "black"
    } else {
	return "red"
    }

}

proc CouleurDeLaZone {Nom} {

    Wup "Returns the color of Nom's zone in the dotplot"
    global LesCouleursDesZones

    set Milieu [expr ([Box $Nom debut]+[Box $Nom fin])/2]

    foreach DebutFinCouleur $LesCouleursDesZones {
	scan $DebutFinCouleur "%s %s %s" OldPosADN PosADN Couleur
	if {$OldPosADN <= $Milieu && $Milieu <= $PosADN} { return $Couleur }
    }
    return "white"    

}

proc CouleurDePeau {Access} {


    set Orga [OrgaDuFetcheAccess $Access]
    return [Glossaire $Orga Couleur]

}

proc CouleurDePeauOsOc {OsOc} {


    set CouleurDeClasse(PROKARYOTA)     "green"
    set CouleurDeClasse(EUKARYOTA)      "skyblue"
    set CouleurDeClasse(EUBACTERIA)     "yellow"
    set CouleurDeClasse(ARCHAEBACTERIA) "brown"

    Espionne $OsOc
    foreach {Phylum VaCouleurDeClasse} [array get CouleurDeClasse] {
	if {[regexp -nocase [string range $Phylum 0 3] $OsOc]} {
	    return $ValCouleurDeClasse
	}
    }

    return [Glossaire $OsOc Couleur]

}

proc CouleurDeci2Hexa {c} {

    set c [CouleurDeci2Int $c]
    return [CouleurInt2Hexa $c]

}

proc CouleurDeci2Int {c} {

    foreach e $c {
	lappend l [expr {int($e*255)}]
    }

    return $l

}

proc CouleurDegradee {{Quoi ""}} {

    global CouleurDegradee NombreDeCouleursDegradees IemeCouleurDegradee

    if {[regexp {^[0-9]+$} $Quoi]} {
	set NombreDeCouleurs $Quoi
	set NombreDeCouleursDegradees $NombreDeCouleurs
	set IemeCouleurDegradee $NombreDeCouleurs
	return
    }

    set BackGround [Nuance [expr [incr IemeCouleurDegradee -1]/(1.*$NombreDeCouleursDegradees)]]
    set ForeGround "black"

    if {$Quoi==""} { set Quoi "BackGround" }
    if {$Quoi=="BackGround"} { return "$BackGround" }
    if {$Quoi=="ForeGround"} { return "$ForeGround" }
    if {$Quoi=="BackFore"}   { return "$BackGround $ForeGround" }
    if {$Quoi=="ForeBack"}   { return "$Foreground $BackGround" }
    return "$BackGround $ForeGround"

}

proc CouleurDuFold {Fold} {

    if {$Fold == "-"} {
	set ColorFill "red"
    } elseif {$Fold == "+"} {
	set ColorFill "Mediumblue"
    } else {
	set ColorFill "springgreen4"
    } 
    return $ColorFill

}

proc CouleurDuGeneColorFill {Evidence} {

    if {$Evidence == "C"} {
	set ColorFill "blue"
    } elseif {$Evidence == "E"} {
	set ColorFill "lightgreen"
    } elseif {$Evidence == "PE"} {
	set ColorFill "khaki4"
    } elseif {$Evidence == "P"} {
	set ColorFill "khaki3"
    } elseif {$Evidence == "?"} {
	set ColorFill "orange"
    } elseif {$Evidence == "I"} {
	set ColorFill "yellow"
    } else {
	set ColorFill "pink"
    }
    return $ColorFill

}

proc CouleurDuGroupe {n} {

    global Lookup_Couleurs Couleurs

    set col "cyan"
    if {$n <= [llength [set Couleurs(Stock)]]} {
	set col [lindex [set Couleurs(Stock)] [expr {$n-1}]]
    } else {
	foreach c [array names Lookup_Couleurs] {
	    if {[lsearch [set Couleurs(Stock)] $c] == -1} {
		set col $c
		lappend Couleurs(Stock) $c
		break
	    }
	}
    }

    return $col

}

proc CouleurDuNuancier {Ieme NombreDeCouleurs {UnPeu ""} {Passion ""} {Format ""} {Saturation ""} {Brightness ""}} {


    if {$NombreDeCouleurs<1} { set NombreDeCouleurs 1 }
    incr Ieme -1

    if {$NombreDeCouleurs<2} {
	set Amour 0
    } else {
	set Amour [expr 1.0*$Ieme/($NombreDeCouleurs-1)]
    }

    set Couleur [Nuance $Amour $UnPeu $Passion $Format $Saturation $Brightness]
    return $Couleur

}

proc CouleurDuPrimer {NbCandidat} {

    
    Wup "Retourne une couleur de boite en fonction du nombre de candidats"

    if {$NbCandidat==""} {return "red"}

    set CouleurDuPrimer ""
    switch -exact -- $NbCandidat {
	"2"  {set CouleurDuPrimer "green3"}
	"1"  {set CouleurDuPrimer "skyblue"}
	"3"  {set CouleurDuPrimer "green3"}
    }
    if {   $CouleurDuPrimer==""} {set CouleurDuPrimer "red"}
    return $CouleurDuPrimer

}

proc CouleurDuSens {Sens} {

    if {$Sens == "-"} {
	set ColorFill "red"
    } elseif {$Sens == "+"} {
	set ColorFill "blue"
    } elseif {$Sens == "?"} {
	set ColorFill "green"
    } else {
	set ColorFill "pink"
    }
    return $ColorFill

}

proc CouleurDuStock {i} {


    set n [llength [set ::Couleurs(Stock)]]
    set c [lindex [set ::Couleurs(Stock)] [expr {$i%$n}]]

    return [LaTkColDe $c]

}

proc CouleurExquiseDeLaZone {Etiquette {VraieCouleur ""}} {

    Wup "Returns the color of the dotplot zone"
    Wup " appending the name of the label if not VraieCouleur"
    global RepertoireDuGenome
    global LaPaletteDesCouleursDeZoneEtiquettee

    if { ! [info exists LaPaletteDesCouleursDeZoneEtiquettee]} {
	foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/palettezoneetiquette"] {
	    scan $Ligne "%s %s" Couleur E
	    set LaCouleur($E) "$Couleur" 
	}
    }

    set PremiereLettre [string range $Etiquette 0 0] 
    if {$VraieCouleur==""} {
	return [set LaCouleur($PremiereLettre)]_$Etiquette
    } else {
	return [set LaCouleur($PremiereLettre)]
    }

}

proc CouleurFormat {rgb Format {InputFormat ""}} {

    #rR rajoute 2016/01/21 .. ça ne fait pas de mal ;) 
    if {[regexp -nocase {[a-z]} $rgb]} {
	lassign [FromTkCol $rgb rgb] r g b
	set r [expr $r*256]
	set g [expr $g*256]
	set b [expr $b*256]
	set rgb [list $r $g $b]
    }

    if {$InputFormat=="3x8"} {
	lassign $rgb r g b
	set r [expr $r*256]
	set g [expr $g*256]
	set b [expr $b*256]
	set rgb [list $r $g $b]
    }	
    if {[llength $rgb]==1 && [string length $rgb]>=12} {
	regsub "#" $rgb "" rgb
	scan $rgb "%04x%04x%04x" r g b
	set rgb [list $r $g $b]
    } elseif {[llength $rgb]==1 && [string length $rgb]>=6} {
	regsub "#" $rgb "" rgb
	scan $rgb "%02x%02x%02x" r g b
	set r [expr $r*256]
	set g [expr $g*256]
	set b [expr $b*256]
	set rgb [list $r $g $b]
    }
    lassign $rgb r g b
    if {$Format=="3x16"}  { return "$r $g $b" }
    if {$Format=="3x8" }  { return [format "%d %d %d" [expr $r/256] [expr $g/256] [expr $b/256]] }
    if {$Format=="hexa"}  { return [format "#%04x%04x%04x" $r $g $b] }
    if {$Format=="hexa2"} { return [format "#%02x%02x%02x" [expr $r/256] [expr $g/256] [expr $b/256]] }
    if {[regexp -nocase "n" $Format] } {
	set Proche [PlusProcheCouleur [list [expr $r/256] [expr $g/256] [expr $b/256]] "3x8"]
	if {[regexp -nocase "all" $Format]} { return [FromTkCol $Proche "Nom"] }
	set Nom [lindex [FromTkCol $Proche "Nom"] 0]
	return $Nom
    }
    return $rgb

}

proc CouleurHDACroises {Liste {Seuil 50}} {

    set PTblastN [lindex $Liste 0]
    set PBlastP  [lindex $Liste 1]
    set PJaune   [lindex $Liste 2]
    if {$PJaune==100.0 || ($PJaune>0 && $PBlastP<1)} {return "J"}
    if {$PJaune}                                     {return "LJ"}
    if {($PBlastP==100.0) && ($PTblastN==100.0)}     {return "V"}
    if {($PBlastP>$Seuil) && ($PTblastN>$Seuil)}     {return "B"}
    if {!$PBlastP && !$PTblastN}                     {return "R"}
    return "O" 

}

proc CouleurHexa2Deci {c} {

    if {[string length $c] == 7} {
	set base 32
	set r [string range $c 1 2]
	set g [string range $c 3 4]
	set b [string range $c 5 6]
    } elseif {[string length $c] == 13} {
	set base 64
	set r [string range $c 1 4]	
	set g [string range $c 5 8]
	set b [string range $c 9 12]
    }

    return [list [Hexa2Deci $r $base] [Hexa2Deci $g $base] [Hexa2Deci $b $base]]

}

proc CouleurHexa2Int {c} {

    set c [CouleurHexa2Deci $c]
    return [CouleurDeci2Int $c]

}

proc CouleurInt2Deci {c} {

    lassign $c r g b
    if {! [string is integer $r]} {return $c}

    set r [format "%4.2f" [expr {double($r)/255.}]]
    set g [format "%4.2f" [expr {double($g)/255.}]]
    set b [format "%4.2f" [expr {double($b)/255.}]]

    return [list $r $g $b]

}

proc CouleurInt2Hexa {c {base 32}} {

    lassign $c r g b
    if {$base == 64} {
	return [format "\#%04x%04x%04x" $r $g $b]
    } else {
	return [format "\#%02x%02x%02x" $r $g $b]
    }

}

proc CouleurO2Ordali {Co} {

    if {[regexp {[A-Z]} [string index $Co 0]]} {return $Co}
    if {[string index $Co 0] eq "#"} {return $Co}

    set Co [string tolower $Co]
    set li [regexp -all -indices -inline {\_} $Co]
    if {$li != ""} {
	set li [lsort -decreasing -integer -index 0 $li]
	foreach e $li {
	    set i [lindex $e 0]
	    set im [expr {$i - 1}]
	    set ip [expr {$i + 1}]

	    set Co "[string toupper $Co 0 0]"
	    set Co "[string toupper $Co ${ip} ${ip}]"
	    set Co "[string range $Co 0 ${im}][string range $Co $ip end]"
	}
    }

    return [string trim $Co]

}

proc CouleurOrdali {ActionOuFB {LesCouleurs ""} {aTexteHTML ""}} {

    global CouleurTag
    global CouleurOrdali
    global CodeSpanOrdali
    if {$aTexteHTML!=""} { upvar $aTexteHTML TexteHTML }

    Wup "Initializes Couleurs if LesCouleurs not empty" 
    Wup "Returns the fg or bg colocouleurordr associated to the current Tag CouleurTag"
    Wup "Ordali uses Couleurs, Gscope uses Couleurs to create CouleurOrdali"

    if {$LesCouleurs!=""} {
	set LesTags [list CouleurTagParDefaut]
	set CouleurOrdali(CouleurTagParDefaut,fg) "black"
	set CouleurOrdali(CouleurTagParDefaut,bg) "white"
	foreach TexteCouleur $LesCouleurs {
	    ScanLaListe [split $TexteCouleur " "] Tag Fore Back
	    lappend LesTags $Tag
	    if {$Fore==""} { set Fore [set CouleurOrdali(CouleurTagParDefaut,fg)] }
	    if {$Back==""} { set Back [set CouleurOrdali(CouleurTagParDefaut,bg)] }
	    set CouleurOrdali($Tag,fg) $Fore 
	    set CouleurOrdali($Tag,bg) $Back
	}
    }
    set CodeSpan ""
    if {$ActionOuFB=="CreateHTML"} {
	append TexteHTML "\n\n"
	return
    }


    set FB $ActionOuFB

    if {[info exists CouleurOrdali($CouleurTag,$FB)]} { return [set CouleurOrdali($CouleurTag,$FB)] }
    if {$FB=="fg"} { return "NoColor" }
    if {$FB=="bg"} { return "NoColor" }
    return "UnknownGround"

}

proc CouleurOrdali2O {Cord} {

    #    set Cord [string tolower $Cord]
    if {[regexp "_" $Cord]} {return $Cord}
    if {[regexp {^[A-Za-z0-9#]+$} $Cord]} {return $Cord}

    regsub -all {([A-Z])} $Cord {_\1} Ctemp
    set Ctmp [string trim $Ctemp "_"]

    return [string tolower $Ctmp]

}

proc CouleurOrdali2Rasmol {c} {


    global Lookup_Couleurs

    if {[string index $c 0] eq "#"} {
	scan [string range $c 1 2]  "%2x" r
	scan [string range $c 5 6]  "%2x" g
	scan [string range $c 9 10] "%2x" b
    } else {
	lassign [set Lookup_Couleurs($c)] r g b 
    }

    set col "\[$r,$g,$b\]"

    return $col

}

proc CouleurParTypeEtNom {TypeDeCouleur Nom K} {

    global RepertoireDuGenome
    global CouleurDuFond
    global LesORFsEnOverlap
    global CodonPreference CodonPreferenceMini CodonPreferenceMaxi
    global CouleurDeFrame           SignificationCouleurDeFrame
    global CouleurDuCodonStart      SignificationCouleurDuCodonStart
    global CouleurFiabiliteFonction SignificationCouleurFiabiliteFonction
    global CouleurDeLaSuperClasse   SignificationCouleurDeLaSuperClasse
    global TasTamis

    if {[regexp "GLIMMER" $Nom]} { return $CouleurDuFond }

    if { $TypeDeCouleur=="ClassesFonctionnelles" && ! [info exists CouleurDeLaSuperClasse]} {
	set CouleurDeLaSuperClasse(Hy) "yellow"
	set CouleurDeLaSuperClasse(NC) "green"
	set CouleurDeLaSuperClasse(CP) "blue"
	set CouleurDeLaSuperClasse(Tl) "orange"
	set CouleurDeLaSuperClasse(RT) "red"
	set CouleurDeLaSuperClasse(CE) "blue"
	set CouleurDeLaSuperClasse(Me) "green"
	set CouleurDeLaSuperClasse(tR) "black"
	set CouleurDeLaSuperClasse(RR) "black"
	set CouleurDeLaSuperClasse(IG) $CouleurDuFond
	foreach {SC ValCouleurDeLaSuperClasse} [array get CouleurDeLaSuperClasse] {
	    if {[info exists SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse)]} {
		append SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse) "or $SC"
	    } else {
		set SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse) "SuperClass $SC"
	    }
	}
    }
    
    if { $TypeDeCouleur=="FiabiliteFonction" && ! [info exists CouleurFiabiliteFonction]} {
	set CouleurFiabiliteFonction(0) "white"
	set CouleurFiabiliteFonction(1) "skyblue"
	set CouleurFiabiliteFonction(2) "skyblue"
	set CouleurFiabiliteFonction(3) "green"
	set CouleurFiabiliteFonction(4) "green"
	set CouleurFiabiliteFonction(5) "yellow"
	set CouleurFiabiliteFonction(6) "yellow"
	set CouleurFiabiliteFonction(7) "orange"
	set CouleurFiabiliteFonction(8) "orange"
	set CouleurFiabiliteFonction(9) "red"
	set CouleurFiabiliteFonction(-1) "white"
    }
    
    if { $TypeDeCouleur=="SuivantLaFrame" && ! [info exists CouleurDeFrame] } {
	set CouleurDeFrame(a) "blue"
	set CouleurDeFrame(b) "white"
	set CouleurDeFrame(c) "red"
	set CouleurDeFrame(d) "yellow"
	set CouleurDeFrame(e) "orange"
	set CouleurDeFrame(f) "green"
	set CouleurDeFrame(T) "brown"
	set CouleurDeFrame(t) "brown"
	set CouleurDeFrame(N) "purple"
	set CouleurDeFrame(n) "purple"
	set CouleurDeFrame(Z) "grey"
	set CouleurDeFrame(z) "grey"
	foreach {F ValCouleurDeFrame} [array get CouleurDeFrame] {
	    if {[info exists SignificationCouleurDeFrame($ValCouleurDeFrame)]} {
		append SignificationCouleurDeFrame($ValCouleurDeFrame) "or $F"
	    } else {
		set SignificationCouleurDeFrame($ValCouleurDeFrame) "Frame $F"
	    }
	}
    }
    
    if { ! [info exists CouleurDuCodonStart]} {
	set CouleurDuCodonStart(ATG)      "green"
	set CouleurDuCodonStart(GTG)      "yellow"
	set CouleurDuCodonStart(TTG)      "orange"
	set CouleurDuCodonStart(Anormal)  "red"
	set CouleurDuCodonStart(OK)       "lightgreen"
	set CouleurDuCodonStart(Probleme) "white"
	set CouleurDuCodonStart(Inconnu)  "grey"
	foreach {CS ValCouleurDuCodonStart} [array get CouleurDuCodonStart] {
	    set SignificationCouleurDuCodonStart($ValCouleurDuCodonStart) "StartCodon $CS"
	}
    }
    
    switch "Coloration_$TypeDeCouleur" {
	"Coloration_FromTamis" { # 9.99 noWeb
	    set Couleur "grey"
	    if {[info exists TasTamis($Nom)]} { set Couleur "green"  }
	    if {[info exists TasTamis(FromTamis)]} {	    
		SetSignification $K green "Ok in tamis [set TasTamis(FromTamis)]"
		SetSignification $K grey  "No in tamis [set TasTamis(FromTamis)]"
	    }
	}
	"Coloration_Taxonomy" { # 1.0 noWeb
	    set Couleur "white"
	    set Taxo [Taxonomy $Nom]
	    if {[regexp "Virus"      $Taxo]} { set Couleur "darkgrey" ; SetSignification $K darkgrey "Virus"}
	    if {[regexp "Bacteria"   $Taxo]} { set Couleur "yellow"   ; SetSignification $K yellow   "Bacteria"}
	    if {[regexp "Archae"     $Taxo]} { set Couleur "blue"     ; SetSignification $K blue     "Archae"}
	    if {[regexp "Eukaryota"  $Taxo]} { set Couleur "pink"     ; SetSignification $K pink     "Eukaryota"}
	    if {[regexp "Metazoa"    $Taxo]} { set Couleur "red"      ; SetSignification $K red      "Metazoa"}
	    if {[regexp "Nematoda"   $Taxo]} { set Couleur "orange"   ; SetSignification $K orange   "Nematoda"}
	    if {[regexp "Arthropoda" $Taxo]} { set Couleur "purple"   ; SetSignification $K purple   "Arthropoda"}
	    if {[regexp "sapiens"    $Taxo]} { set Couleur "green"    ; SetSignification $K green    "Human"}
	    if {[regexp "musculus"   $Taxo]} { set Couleur "cyan"     ; SetSignification $K cyan     "Mouse"}
	    if {[regexp "Xenopus"    $Taxo]} { set Couleur "brown"    ; SetSignification $K brown    "Xenopus"}
	    if {[regexp "elegans"    $Taxo]} { set Couleur "lightgreen" ; SetSignification $K lightgreen "C.elegans"}	    
	}
	"Coloration_Outlier" { # 1.1 Web
	    set Couleur "white"
	    set OutlierScore [OutlierScore $Nom]
	    scan $OutlierScore "%s" OutlierScore
	    if { $OutlierScore==""} { set OutlierScore -9 }
	    if {                                   [expr $OutlierScore <  -9 ]    } { set Couleur "green"  }
	    if { [expr -9     <= $OutlierScore] && [expr $OutlierScore <  -1 ]    } { set Couleur "yellow" }
	    if { [expr -1     <= $OutlierScore] && [expr $OutlierScore <   1 ]    } { set Couleur "orange" }
	    if { [expr  1     <= $OutlierScore] && [expr $OutlierScore <  99 ]    } { set Couleur "red"    }
	    if { [expr 99     <= $OutlierScore]                                   } { set Couleur "lightblue" }
	    SetSignification $K white   "Not yet available"
	    SetSignification $K green   "Outlier better at least e10"
	    SetSignification $K yellow  "Outlier with equal expect"
	    SetSignification $K red     "Reference better than Outlier"
	    SetSignification $K skyblue "No outlier or reference in the blast"
	}
	"Coloration_Balibase" { # 1.1 noWeb
	    set Couleur "white"
	    set Classe [ExtraitInfo $Nom "RV"]
	    if {[regexp "11" $Classe]} { set Couleur "red"  }
	    if {[regexp "12" $Classe]} { set Couleur "orange"  }
	    if {[regexp "20" $Classe]} { set Couleur "yellow"  }
	    if {[regexp "30" $Classe]} { set Couleur "skyblue" }
	    if {[regexp "40" $Classe]} { set Couleur "blue" }
	    if {[regexp "50" $Classe]} { set Couleur "purple" }
	    SetSignification $K red     "Class Ref1v1"
	    SetSignification $K orange  "Class Ref1v2"
	    SetSignification $K yellow  "Class Ref2"
	    SetSignification $K skyblue "Class Ref3"
	    SetSignification $K blue    "Class Ref4"
	    SetSignification $K purple  "Class Ref5"
	}
	"Coloration_CheckCompletion" { # 1.1 noWeb
	    set Couleur [CheckCompletion $Nom Color]
	    SetSignification $K $Couleur [GeneEtendu $Nom Signification]
	}
	"Coloration_Rejected" { # 1.1 noWeb
	    set Couleur "white"
	    set Reject [ExtraitInfo $Nom "Rejected:"]
	    if {$Reject!=""}                   { set Couleur "green"  }
	    if {[regexp "NoRejected" $Reject]} { set Couleur "red"  }
	    SetSignification $K red     "NoRejected"
	    SetSignification $K green   "Rejected"
	    SetSignification $K green   "Not yet annotated"
	}
	"Coloration_ScerevisiaeEhistolica" { # 1.1 noWeb
	    set Couleur "green"
	    set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
	    set Eh [ExtraitInfo $Nom "Reciproc1_blastpEhistolica:"]
	    if {   [regexp "^No" $Sc] &&   [regexp "^No" $Eh]} { set Couleur "yellow"  }
	    if {   [regexp "^No" $Sc] && ! [regexp "^No" $Eh]} { set Couleur "blue"  }
	    if { ! [regexp "^No" $Sc] &&   [regexp "^No" $Eh]} { set Couleur "red"  }
	    if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Eh]} { set Couleur "green"  }
	    SetSignification $K yellow     "-Sc -Eh"
	    SetSignification $K blue       "-Sc +Eh"
	    SetSignification $K red        "+Sc -Eh"
	    SetSignification $K green      "+Sc +Eh"
	}
	"Coloration_ScerevisiaeTbrucei" { # 1.1 noWeb
	    set Couleur "green"
	    set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
	    set Tb [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"]
	    if {   [regexp "^No" $Sc] &&   [regexp "^No" $Tb]} { set Couleur "yellow"  }
	    if {   [regexp "^No" $Sc] && ! [regexp "^No" $Tb]} { set Couleur "blue"  }
	    if { ! [regexp "^No" $Sc] &&   [regexp "^No" $Tb]} { set Couleur "red"  }
	    if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Tb]} { set Couleur "green"  }
	    SetSignification $K yellow     "-Sc -Tb"
	    SetSignification $K blue       "-Sc +Tb"
	    SetSignification $K red        "+Sc -Tb"
	    SetSignification $K green      "+Sc +Tb"
	}
	"Coloration_ScerevisiaePfalciparum" { # 1.1 noWeb
	    set Couleur "green"
	    set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
	    set Pf [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"]
	    if {   [regexp "^No" $Sc] &&   [regexp "^No" $Pf]} { set Couleur "yellow"  }
	    if {   [regexp "^No" $Sc] && ! [regexp "^No" $Pf]} { set Couleur "blue"  }
	    if { ! [regexp "^No" $Sc] &&   [regexp "^No" $Pf]} { set Couleur "red"  }
	    if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Pf]} { set Couleur "green"  }
	    SetSignification $K yellow     "-Sc -Pf"
	    SetSignification $K blue       "-Sc +Pf"
	    SetSignification $K red        "+Sc -Pf"
	    SetSignification $K green      "+Sc +Pf"
	}
	"Coloration_ReciprocTbrucei" { # 1.1 noWeb
	    set Couleur "green"
	    set Reciproc [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"]
	    if {[regexp "NoBlastFile"        $Reciproc]} { set Couleur "white"  }
	    if {[regexp "NoHitFound"         $Reciproc]} { set Couleur "grey"  }
	    if {[regexp "NoSequenceFor"      $Reciproc]} { set Couleur "lightgrey"  }
	    if {[regexp "NoBlastResultFor"   $Reciproc]} { set Couleur "orange"  }
	    if {[regexp "NoReciprocalHitFor" $Reciproc]} { set Couleur "red"  }
	    SetSignification $K green     "ReciprocExists"
	    SetSignification $K white     "NoBlastFile"
	    SetSignification $K grey      "NoHitFound"
	    SetSignification $K lightgrey "NoSequenceFor"
	    SetSignification $K orange    "NoBlastResultFor"
	    SetSignification $K red       "NoReciprocalHitFor"
	}
	"Coloration_ReciprocPfalciparum" { # 1.1 noWeb
	    set Couleur "green"
	    set Reciproc [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"]
	    if {[regexp "NoBlastFile"        $Reciproc]} { set Couleur "white"  }
	    if {[regexp "NoHitFound"         $Reciproc]} { set Couleur "grey"  }
	    if {[regexp "NoSequenceFor"      $Reciproc]} { set Couleur "lightgrey"  }
	    if {[regexp "NoBlastResultFor"   $Reciproc]} { set Couleur "orange"  }
	    if {[regexp "NoReciprocalHitFor" $Reciproc]} { set Couleur "red"  }
	    SetSignification $K green     "ReciprocExists"
	    SetSignification $K white     "NoBlastFile"
	    SetSignification $K grey      "NoHitFound"
	    SetSignification $K lightgrey "NoSequenceFor"
	    SetSignification $K orange    "NoBlastResultFor"
	    SetSignification $K red       "NoReciprocalHitFor"
	}
	"Coloration_Famille" { # 1.1 noWeb
	    set Couleur "white"
	    set Famille [ExtraitInfo $Nom "Famille:"]
	    if {[regexp "P62"   $Famille]} { set Couleur "green"  }
	    if {[regexp "DOS"   $Famille]} { set Couleur "yellow"  }
	    if {[regexp "SAP"   $Famille]} { set Couleur "red"  }
	    if {[regexp "Other" $Famille]} { set Couleur "grey"  }
	    SetSignification $K green     "Famille P62"
	    SetSignification $K yellow    "Famille DOS"
	    SetSignification $K red       "Famille SAP"
	    SetSignification $K grey      "Famille Other"
	}
	"Coloration_Classes" { # 1.1 noWeb
	    set Couleur "white"
	    set Classe [ExtraitInfo $Nom "Class"]
	    if {[regexp "1a" $Classe]} { set Couleur "red"  }
	    if {[regexp "1b" $Classe]} { set Couleur "orange"  }
	    if {[regexp "1c" $Classe]} { set Couleur "yellow"  }
	    if {[regexp "2a" $Classe]} { set Couleur "skyblue" }
	    if {[regexp "2b" $Classe]} { set Couleur "blue" }
	    if {[regexp "2c" $Classe]} { set Couleur "purple" }
	    SetSignification $K red     "Class 1a"
	    SetSignification $K orange  "Class 1b"
	    SetSignification $K yellow  "Class 1c"
	    SetSignification $K skyblue "Class 2a"
	    SetSignification $K blue    "Class 2b"
	    SetSignification $K purple  "Class 2c"
	}
	"NoColoration_ContigsAlternes" { # 1.2 noWeb
	    set Couleur "grey"
	    scan [ContigDuPAB $Nom] "%s" Contig
	    if {[regexp {[02468]$} $Contig]} { set Couleur "white" }
	    if {[regexp {[13579]$} $Contig]} { set Couleur "black" }
	    SetSignification $K white "Contig even"
	    SetSignification $K black "Contig odd"
	    SetSignification $K grey  "Contig unknown"
	}
	"Coloration_DifferentialDisplay" { # 1.8 noWeb
	    set Couleur [DifferentialDisplay $Nom Color]
	    SetSignification $K $Couleur [DifferentialDisplay $Nom Signification]
	}
	"Coloration_GeneEtendu" { # 2.1 noWeb
	    set Couleur [GeneEtendu $Nom Color]
	    SetSignification $K $Couleur [GeneEtendu $Nom Signification]
	}
	"Coloration_SuivantLaFrame" { # 2.2
	    set Couleur [set CouleurDeFrame([Box $Nom frame])]
	    SetSignification $K $Couleur [set SignificationCouleurDeFrame($Couleur)] 
	}
	"Coloration_CodonStartMVL" { # 2.3
	    if {[info exists CouleurDuCodonStart([NucDuCodonStart $Nom])]} {
		set Couleur $CouleurDuCodonStart([NucDuCodonStart $Nom])
	    } else {
		Warne "Codon anormal en $Nom"
		set Couleur $CouleurDuCodonStart(Anormal)
	    }
	    SetSignification $K $Couleur [set SignificationCouleurDuCodonStart($Couleur)] 
	}
	"Coloration_BiaisEnGC" { # 2.4
	    set GC [CompositionEn GC $Nom]
	    if { $GC == "" } {
		set Couleur "white"
		SetSignification $K $Couleur "GC skew no value"
	    } else {
		set Couleur [QuelInterval $GC [LesSeuilsGC] [CouleursDuRougeAuBleu 5]]
		set Signif  [QuelInterval $GC [LesSeuilsGC] [LesSeuilsGC "SignificationMerci"]]
		SetSignification $K $Couleur $Signif
	    }
	}
	"Coloration_Overlap" { # 2.5
	    if { [Fantome $Nom] } {
		set Couleur $CouleurDuFond
		SetSignification $K $Couleur "Overlap Fantome"
	    } else {
		set Couleur "green"
		SetSignification $K $Couleur "No overlap"

		set Olap [Overlap $Nom]
		regsub -all {Overlap\: *} $Olap "/" Olap
		if { $Olap != "" && $Olap != "/" } { 
		    if {[regexp "I begin" $Olap]} {
			set Couleur "red"
			SetSignification $K $Couleur "Overlap of more than 4 bases"
		    }
		    if {[regexp "/1 bases. I begin" $Olap]} {
			set Couleur "orange"
			SetSignification $K $Couleur "Overlap 1 base (as taAtg or tgAtg or taGtg)"
		    }
		    if {[regexp "/4 bases. I begin" $Olap]} {
			set Couleur "yellow"
			SetSignification $K $Couleur "Overlap 4 bases (as aTGa or gTGa or tTGa)"
		    }
		    if {[regexp "I am in" $Olap]} {
			set Couleur "blue"
			SetSignification $K $Couleur "Full overlaped"
		    }
		}	    
	    }
	}
	"Coloration_ShineDalgarno" { # 2.6
	    switch -regexp [ShineDalgarno $Nom] {
		"^bons" {
		    set Couleur "green"
		    SetSignification $K $Couleur "With ShineDalgarno"
		}
		"^mets" {
		    set Couleur "yellow"
		    SetSignification $K $Couleur "ShineDalgarno if you change StartCodon"
		}
		"^loin" {
		    set Couleur "orange"
		    SetSignification $K $Couleur "Far ShineDalgarno"
		}
		"^sans" {
		    set Couleur "red"
		    SetSignification $K $Couleur "NoShineDalgarno"
		}
		default { set Couleur $CouleurDuFond }
	    }
	}
	"NoColoration_CodonPreference" { 
	    if { ! [info exists CodonPreference] } { ChargeCodonPreference }
	    if { ! [info exists CodonPreference($Nom)] } { 
		set Couleur $CouleurDuFond
		SetSignification $K $Couleur "CodonPreference no value"
	    } else {
		set Preference [set CodonPreference($Nom)]
		set ValeurEntre0et1 [expr ($Preference-$CodonPreferenceMini) / ($CodonPreferenceMaxi-$CodonPreferenceMini)]
		set Couleur [Nuance $ValeurEntre0et1]
	    }
	    SetSignification $K $Couleur "CodonPreference [setCodonPreference($Nom)]"
	} 
	"NoColoration_TrogStatus" { 
	    set Couleur "grey"
	    set Status [TrogStatus $Nom]
	    if {[regexp -- "^0" $Status]} { set Couleur "red"  }
	    if {[regexp -- "^1" $Status]} { set Couleur "yellow"  }
	    if {[regexp -- "^2" $Status]} { set Couleur "green"  }
	    if {[regexp -- "-1" $Status]} { set Couleur "grey" }
	    SetSignification $K red     "TrogStatus Loss"
	    SetSignification $K yellow  "TrogStatus FalseOrthologue"
	    SetSignification $K green   "TrogStatus TrueOrthologue"
	    SetSignification $K grey    "TrogStatus NoOrthologue"
	}
	"Coloration_RepeatMasker" { # 3.2 noWeb
	    set Couleur [QuelMask $Nom "ColorPlease"]
	    SetSignification $K $Couleur [QuelMask $Nom]
	}
	"Coloration_RepeatMRM" { # 3.21 noWeb
	    set Couleur [QuelMaskMRM $Nom "ColorPlease"]
	    SetSignification $K $Couleur [QuelMaskMRM $Nom]
	}
	"Coloration_PolyLocalization" { # 3.5 noWeb
	    set Couleur [PolyLocalise $Nom "ColorPlease"]
	    SetSignification $K $Couleur [PolyLocalise $Nom]
	}
	"Coloration_OverlapAffymetrix" { # 3.6 noWeb
	    if {[WithOverlapAffymetrix $Nom]} {
		set Couleur "green"
		SetSignification $K $Couleur "Affymetrix overlap"
	    } else {
		set Couleur "grey"
		SetSignification $K $Couleur "No Affymetrix overlap"
	    }
	}
	"Coloration_CompareSeqWithQuery" { # 3.7
	    set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
	    set AutreRep "[RepertoireDuGenome]/prottfainitial"
	    set MS [MemesSequencesDansFichiersTFA $FichierTFA $AutreRep "Pourquoi"]
	    set Couleur "black"
	    regexp {\(([a-z]+)\)} $MS Match Couleur
	    SetSignification $K $Couleur "$MS"
	}
	"Coloration_NombreDeCopainsDansBlast" { # 4.1
	    CouleurAuNombreDeCopainsDansBlast SetAllSignification $K
	    set Couleur [CouleurAuNombreDeCopainsDansBlast [NombreDeCopainsDansBlast $Nom]]
	}
	"Coloration_HitMultiple" { # 4.2
	    set HitMultiple [HitMultiple $Nom]
	    if {$HitMultiple=={}} {
		set Couleur "green"
		SetSignification $K "green"  "No Multiple Hit"
	    } else {
		if {[regexp "FS no" [ExtraitInfo $Nom "EP"]]} {
		    set Couleur "yellow"
		    SetSignification $K "yellow" "With Multiple Hit without Frameshift"
		} else {
		    set Couleur "red"
		    SetSignification $K "red"    "With Multiple Hit and Frameshift"
		}
	    }
	}
	"Coloration_PDBstructures" { # 4.3
	    set Couleur "white"
	    set n [WithPDB $Nom]
	    if {29 < $n             } { set Couleur "red" }
	    if { 9 < $n && $n <= 29 } { set Couleur "orange" }
	    if { 5 < $n && $n <= 9  } { set Couleur "yellow" }
	    if { 1 < $n && $n <= 5  } { set Couleur "green" }
	    if { 0 < $n && $n <= 1  } { set Couleur "blue" }
	    if {           $n <= 0  } { set Couleur "grey" }
	    SetSignification $K red     "known PDB structures 29 < n"              
	    SetSignification $K orange  "known PDB structures  9 < n && n <= 29 " 
	    SetSignification $K yellow  "known PDB structures  5 < n && n <= 9 " 
	    SetSignification $K green   "known PDB structures  1 < n && n <= 5 " 
	    SetSignification $K blue    "known PDB structures  0 < n && n <= 1 " 
	    SetSignification $K grey    "known PDB structures           n == 0 " 
	    SetSignification $K white   "known PDB structures  no value" 
	}
	"Coloration_PDBDansGroupes" { # 4.3
	    set Couleur [NombreDePDBDansGroupes $Nom "couleur"]
	    SetSignification $K $Couleur [NombreDePDBDansGroupes $Nom "signification"]
	}
	"Coloration_NumberOfParalogues" { # 4.8
	    set nPara [llength [ParaloguesDe $Nom]]
	    if {$nPara<=0} {
		set Couleur "blue"
		SetSignification $K $Couleur "$nPara paralogues"
	    } elseif {$nPara==1} {
		set Couleur "yellow"
		SetSignification $K $Couleur "$nPara paralogues"
	    } elseif {$nPara<=3} {
		set Couleur "green"
		SetSignification $K $Couleur "2 <= nParalogues <= 3"
	    } elseif {$nPara<=8} {
		set Couleur "orange"
		SetSignification $K $Couleur "4 <= nParalogues <= 8"
	    } else {
		set Couleur "red"
		SetSignification $K $Couleur "9 <= nParalogues"
	    }
	}
	"Coloration_ProttfaFileExists" { # 4.9
	    set TheRep "prottfa"
	    if {[file exists "$RepertoireDuGenome/$TheRep/$Nom"]} {
		set Couleur "green"
		SetSignification $K $Couleur "file exists in $TheRep"
	    } else {
		set Couleur "red"
		SetSignification $K $Couleur "file does not exist in $TheRep"
	    }
	}
	"Coloration_MSFParaloguesExiste" { # 4.9
	    if {[file exists "$RepertoireDuGenome/msfparalogues/$Nom"]} {
		set Couleur "green"
		SetSignification $K $Couleur "Paralog exist"
	    } else {
		set Couleur "blue"
		SetSignification $K $Couleur "Paralog no"
	    }
	}
	"Coloration_AnchorsCount" { # 5.1 noWeb
	    set AC [AnchorsCount $Nom]
	    set AC "$AC.0"
	    set Couleur [QuelInterval $AC [LesSeuilsAC] [LesSeuilsAC "CouleurMerci"]]
	    set Signif  [QuelInterval $AC [LesSeuilsAC] [LesSeuilsAC "SignificationMerci"]]
	    SetSignification $K $Couleur $Signif
	}
	"Coloration_MDScore" { # 5.1
	    set MD [MDScore $Nom]
	    set Couleur [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "CouleurMerci"]]
	    set Signif  [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "SignificationMerci"]]
	    SetSignification $K $Couleur $Signif
	}
	"Coloration_WithKegg" { # 5.9
	    if {[AvecKegg $Nom]=="Yes"} {
		set Couleur "green"
		SetSignification $K $Couleur "Kegg information is available"
	    }
	    if {[AvecKegg $Nom]=="Nothing"} {
		set Couleur "red"
		SetSignification $K $Couleur "No Kegg was found"
	    }
	    if {[AvecKegg $Nom]=="NotAvailable"} {
		set Couleur "grey"
		SetSignification $K $Couleur "No Kegg not yet processed"
	    }
	}
	"Coloration_HomologDetectionAgreement" { # 6.1
	    set Couleur [HomologDetectionAgreement $Nom "Color"]
	    SetSignification $K $Couleur [HomologDetectionAgreement $Nom "Signif"]
	}
	"Coloration_PresenceAndAbsenceMSF" { # 6.2
	    if {[PresenceEtAbsenceDesGenomesComplets $Nom "MSF"]} {
		set Couleur "green"
		SetSignification $K $Couleur "Present"
	    } else {
		set Couleur "grey"
		SetSignification $K $Couleur "Absent"
	    }
	}
	"Coloration_PresenceAndAbsenceBlastP" { # 6.3
	    if {[PresenceEtAbsenceDesGenomesComplets $Nom "BlastP"]} {
		set Couleur "green"
		SetSignification $K $Couleur "Present"
	    } else {
		set Couleur "grey"
		SetSignification $K $Couleur "Absent"
	    }
	}
	"Coloration_PresenceAndAbsenceTBlastN" { # 6.4
	    if {[PresenceEtAbsenceDesGenomesComplets $Nom "TBlastN"]} {
		set Couleur "green"
		SetSignification $K $Couleur "Present"
	    } else {
		set Couleur "grey"
		SetSignification $K $Couleur "Absent"
	    }
	}
	"Coloration_TaxoSpecif" { # 6.45
	    set Couleur [TaxoSpecif $Nom "color"]
	    SetSignification $K $Couleur [TaxoSpecif $Nom "signification"]
	}
	"Coloration_SameClusterXHda" { # 6.5 noWeb
	    set Couleur [ColorationDesClustersXHdaDesNomsPiques $Nom "Couleur"]
	    SetSignification $K $Couleur [ColorationDesClustersXHdaDesNomsPiques $Nom "Signif"]
	}
	"Coloration_PhylumOrtho" { # 6.6
	    set Couleur "lightgrey"
	    set BAE [PhylumsOrthologues $Nom]
	    if {[regexp "BAE" $BAE]} { set Couleur "white"   }
	    if {[regexp "BAe" $BAE]} { set Couleur "green"  }
	    if {[regexp "BaE" $BAE]} { set Couleur "orange" }
	    if {[regexp "Bae" $BAE]} { set Couleur "yellow"   }
	    if {[regexp "bAE" $BAE]} { set Couleur "purple" }
	    if {[regexp "bAe" $BAE]} { set Couleur "blue" }
	    if {[regexp "baE" $BAE]} { set Couleur "red"    } 
	    if {[regexp "bae" $BAE]} { set Couleur "grey"   }
	    SetSignification $K white  "BAE high all phylums"
	    SetSignification $K green  "BAe low Eukaryota"
	    SetSignification $K orange "BaE low Archaea"
	    SetSignification $K yellow "Bae Bacteria"
	    SetSignification $K purple "bAE low Bacteria"
	    SetSignification $K blue   "bAe high Archaea"
	    SetSignification $K red    "baE high Eukariota"
	    SetSignification $K grey   "bae low all phylums"
	    SetSignification $K lightgrey   "bae no value"	    
	}
	"Coloration_NearestOrganismsHit" { # 6.5
	    set Couleur "lightgrey"
	    set NOH [NearestOrganismsHit $Nom]
	    if {$NOH==0} { set Couleur "red" }
	    if {$NOH==1} { set Couleur "green" }
	    if {$NOH==2} { set Couleur "blue" }
	    SetSignification $K green  "Hit in nearest organisms"
	    SetSignification $K red    "No hit found in nearest organisms"
	    SetSignification $K blue   "No hit at all"
	    SetSignification $K lightgrey "No value"	    
	}
	"Coloration_OperonsHomologues" { # 6.5
	    set N [CompteDesOrganismesAyantMemeOperon $Nom]
	    if { $N == 0 } {
		set Couleur "grey"
		SetSignification $K $Couleur "ClusterMaintenance Zero"
	    } else {
		set Couleur [QuelInterval $N [LesSeuilsOperonsHomologues] [CouleursDuBleuAuRouge 5]]
		set Signif  [QuelInterval $N [LesSeuilsOperonsHomologues] [LesSeuilsOperonsHomologues "SignificationMerci"]]
		SetSignification $K $Couleur $Signif
	    }
	}
	"Coloration_DeletedStart" { # 7.1 noWeb
	    if {[DeletedStart $Nom]} {
		set Couleur "red"
		SetSignification $K $Couleur "PossibleDeletedStart"
	    } else {
		set Couleur "green"
		SetSignification $K $Couleur "No information about start"
	    }
	}
	"Coloration_CodonStartOK" { # 7.1 noWeb
	    set Couleur $CouleurDuCodonStart(Inconnu)
	    if {[regexp -nocase "OK" [CodonStart $Nom]] } {
		set Couleur $CouleurDuCodonStart(OK)
	    }
	    if {[regexp -nocase "Problem" [CodonStart $Nom]] } {
		set Couleur $CouleurDuCodonStart(Probleme)
	    }
	    SetSignification $K $Couleur [set SignificationCouleurDuCodonStart($Couleur)] 
	}
	"Coloration_StartCodonColor" { # 7.1
	    set Couleur [StartCodonReport $Nom "Couleur"]
	    SetSignification $K $Couleur [StartCodonReport $Nom "Signification"]  
	}
	"Coloration_DiffBlaAli" { # 7.2 
	    set Couleur "white"
	    set DBA [DiffBlaAli $Nom]
	    if {[regexp "^No" $DBA]} { set Couleur "grey" }
	    if {[regexp "^Same" $DBA]} { set Couleur "green" }
	    if {[regexp "^Close" $DBA]} { set Couleur "orange" }
	    if {[regexp "^Different" $DBA]} { set Couleur "red" }
	    SetSignification $K red     "Blast vs DbClustal  Different" 
	    SetSignification $K orange  "Blast vs DbClustal  Close" 
	    SetSignification $K green   "Blast vs DbClustal  same" 
	    SetSignification $K grey    "Blast vs DbClustal  no alignment" 
	    SetSignification $K white   "Blast vs DbClustal  no value" 
	}
	"Coloration_Target" { # 7.3
	    set Target [ExtraitInfo $Nom "Target"]
	    if {$Target==""} {
		set Couleur "grey"
		SetSignification $K $Couleur "No Target information available"  
	    } else {
		if {[regexp -nocase "OK" $Target]} {
		    set Couleur "green"
		    SetSignification $K $Couleur "Target OK"  
		} else {
		    set Couleur "lightblue"
		    SetSignification $K $Couleur "not selected as target"  
		}
	    }
	}
	"Coloration_CAIecol" { # 7.3
	    set x [CAI $Nom]
	    if { $x == "" } {
		set Couleur "white"
		SetSignification $K $Couleur "CAI no value"
	    } else {
		set Couleur [QuelInterval $x [LesSeuilsCAI] [CouleursDuRougeAuBleu 5]]
		set Signif  [QuelInterval $x [LesSeuilsCAI] [LesSeuilsCAI "SignificationMerci"]]
		SetSignification $K $Couleur $Signif
	    }
	}
	"Coloration_HydrophobicIndex" { # 7.4
	    set Couleur "white"
	    set H [Hydrophobicity $Nom "Hydro"]
	    if { $H <= 0.85 } { set Couleur "yellow" }
	    if { 0.85 < $H  } { set Couleur "blue" }
	    SetSignification $K yellow  "HydrophobicIndex less than 0.85"
	    SetSignification $K blue    "HydrophobicIndex more than 0.85"
	    SetSignification $K white   "HydrophobicIndex no value"
	}
	"Coloration_HydrophobicHelices" { # 7.5
	    set Couleur "white"
	    set nH [Hydrophobicity $Nom "nHelices"]
	    if { $nH >  7 } { set Couleur "red" }
	    if { $nH == 7 } { set Couleur "orange" }
	    if { $nH == 6 } { set Couleur "yellow" }
	    if { $nH == 5 } { set Couleur "yellow" }
	    if { $nH == 4 } { set Couleur "green" }
	    if { $nH == 3 } { set Couleur "skyblue" }
	    if { $nH == 2 } { set Couleur "skyblue" }
	    if { $nH == 1 } { set Couleur "skyblue" }
	    if { $nH == 0 } { set Couleur "blue" }
	    SetSignification $K red     "HydrophobicHelices 8, and more"
	    SetSignification $K orange  "HydrophobicHelices 7"
	    SetSignification $K yellow  "HydrophobicHelices 5, 6"
	    SetSignification $K green   "HydrophobicHelices 4"
	    SetSignification $K skyblue "HydrophobicHelices 1, 2, 3"
	    SetSignification $K blue    "HydrophobicHelices 0"
	    SetSignification $K white   "HydrophobicHelices no value"
	}
	"Coloration_FiabiliteFonction" { # 9.7 noWeb
	    set FF [FiabiliteFonction $Nom]
	    if { ! [regexp {[0-9]} $FF] } {
		set Couleur [set CouleurFiabiliteFonction(-1)]
		SetSignification $K $Couleur "Function reliability bad value"
	    } else {
		scan $FF "%d" Valeur
		if { [info exists Valeur] &&  [info exists CouleurFiabiliteFonction($Valeur)] } {
		    set Couleur [set CouleurFiabiliteFonction($Valeur)]
		    SetSignification $K $Couleur "Function reliability $FF"
		} else {
		    Warne "Code FiabiliteFonction $FF pour $Nom incomprehensible"
		    set Couleur [set CouleurFiabiliteFonction(-1)]
		    SetSignification $K $Couleur "Function reliability bad value"
		}
	    }
	}
	"NoColoration_LesCas" {
	    if {[Fantome $Nom]} {
		set Couleur $CouleurDuFond
	    } elseif {[regexp "CasNonConnu" [Cas $Nom]]} {
		set Couleur "white"
	    } elseif {[regexp {^1} [Cas $Nom]]} {
		set Couleur "black"
	    } elseif {[regexp {1$} [Cas $Nom]]} {
		set Couleur "red"
	    } elseif {[regexp {1,0$} [Cas $Nom]]} {
		set Couleur "orange"
	    } elseif {[regexp {1,0,0$} [Cas $Nom]]} {
		set Couleur "yellow"
	    } else {
		set Couleur "green"
	    }
	}
	"Coloration_PhyloFolle" { # 6.8 noWeb
	    if {[Fantome $Nom]} {
		set Couleur $CouleurDuFond
		SetSignification $K $Couleur "no Phylo : Fantome"
	    } elseif {[PhyloFolle $Nom] == 1} {
		set Couleur "red"
		SetSignification $K $Couleur "Phylo crazy"
	    } elseif {[PhyloFolle $Nom] == -1} {
		set Couleur "white"
		SetSignification $K $Couleur "Phylo no value"
	    } else {
		set Couleur "green"
		SetSignification $K $Couleur "Phylo normal"
	    }
	}
	"Coloration_ClassesFonctionnelles" { # 9.9 noWeb
	    set SC [SuperClasse [ClasseFonctionnelle $Nom]]
	    if {[info exists CouleurDeLaSuperClasse($SC)]} {
		set Couleur [set CouleurDeLaSuperClasse($SC)]
		SetSignification $K $Couleur "Functional class $SC"
	    } else {
		set Couleur $CouleurDuFond
		SetSignification $K $Couleur "Functional class no value"
	    }
	}
	"NoColoration_InfoExiste" { # 9.3 noWeb
	    if { [file exists "$RepertoireDuGenome/infos/$Nom"] } {
		if {[regexp "[PreFixe]" $Nom]} {
		    set Couleur "skyblue"
		    SetSignification $K $Couleur "Info file exists for this [PreFixe]" 
		} else {
		    switch -regexp $Nom {
			"TROU" {
			    set Couleur "grey"
			    SetSignification $K $Couleur "Info file exists for this InterGenicRegion" 
			}
			"TRNA" {
			    set Couleur "purple"
			    SetSignification $K $Couleur "Info file exists for this TRNA" 
			}
			"ARN" {
			    set Couleur "brown"
			    SetSignification $K $Couleur "Info file exists for this ARN" 
			}
			default {
			    FaireLire "pas de couleur affectee a $Nom InfoExiste" 
			}
		    }
		}
	    } else {
		set Couleur "red"
		SetSignification $K $Couleur "Info file does'nt exists." 
	    }
	}
	default {
	    set Couleur "black"
	}
    }
    return $Couleur

}

proc CouleurPlusProcheDeTkCol {col} {

    global TkCol

    if {! [info exists TkCol]} {InitTkCol}

    if {[regexp -nocase {^#([0-9a-f]{6}|[0-9a-f]{12})$} $col]} {
	lassign [CouleurHexa2Deci $col] rc gc bc
    } elseif {[llength $col] == 3} {
	lassign $col rc gc bc
    } else {
	if {[set i [lsearch -nocase $::ListeTkCol $col]] == -1} {
	    return -1
	} else {
	    return [lindex $::ListeTkCol $i]
	}
    }

    set ncol ""
    set dr 9999. ; set dg 9999. ; set db 9999.
    foreach a [array names TkCol] {
	lassign [set TkCol($a)] r g b
	set rr [expr {abs($r-$rc)}]
	set gg [expr {abs($g-$gc)}]
	set bb [expr {abs($b-$bc)}]
	if {$rr <= $dr && $gg <= $dg && $bb <= $db} {
	    set dr $rr ; set dg $gg ; set db $bb
	    set ncol $a
	}
    }

    return $ncol

}

proc CouleurSeqlab {X} {

    global CouleurSeqlab
    global CouleurSeqlabLower
    if { ! [info exists CouleurSeqlab]} {
	set CouleurSeqlab [list ForestGreen Orange Magenta Red  SkyBlue LimeGreen Blue Purple Black  Grey30 Grey50 Grey65 Grey80 Grey90 Grey95 White Pink  orangeRed LightBlue yellow green tomato cyan brown lightGreen fireBrick darkOrange  goldenRod seagreen coral  violet khaki navyblue salmon sienna turquoise darkgreen maroon springgreen  mediumblue indianred dimgray light gray gray]
	foreach Couleur $CouleurSeqlab {
	    lappend CouleurSeqlabLower [string tolower $Couleur]
	}
    }

    if {$X=="LaListeMerci"} { return $CouleurSeqlab }
    if {[regexp -nocase {[A-Z]} $X]} {
	set X [string tolower $X]
	return [lsearch $CouleurSeqlabLower $X]
    } else {
	set Couleur [lindex $CouleurSeqlab $X] 
	if {$Couleur=="" } { set Couleur "Red" }
	return $Couleur
    }

}

proc CouleurSuivantOrganismesAyantMemeOperon {Nom} {

    global CouleurDuFond
    global Org1 Org2

    set ListeOMO [lrange [ListeDesOrganismesAyantMemeOperon $Nom] 1 end]

    set nOMO [llength $ListeOMO]

    if { $nOMO == 0 } {
	set Couleur "white"
    } elseif { $nOMO == 1 &&  [regexp $Org1 $ListeOMO]} {
	set Couleur "skyblue"
    } elseif { $nOMO == 1 &&  [regexp $Org2 $ListeOMO]} {
	set Couleur "blue"
    } elseif { $nOMO == 2 &&  [regexp $Org1 $ListeOMO] &&  [regexp $Org2 $ListeOMO]} {
	set Couleur "green"		   
    } elseif { $nOMO == 2 &&  [regexp $Org1 $ListeOMO] && ![regexp $Org2 $ListeOMO]} {
	set Couleur "yellow"		   
    } elseif { $nOMO == 2 && ![regexp $Org1 $ListeOMO] &&  [regexp $Org2 $ListeOMO]} {
	set Couleur "orange"		   
    } elseif { $nOMO  > 2 &&  [regexp $Org1 $ListeOMO] &&  [regexp $Org2 $ListeOMO]} {
	set Couleur "red"		   
    } elseif { $nOMO  > 2 && ![regexp $Org1 $ListeOMO] &&  [regexp $Org2 $ListeOMO]} {
	set Couleur "pink"		   
    } elseif { $nOMO  > 2 &&  [regexp $Org1 $ListeOMO] && ![regexp $Org2 $ListeOMO]} {
	set Couleur "purple"
    } else {
	set Couleur "black"
    }
    return $Couleur

}

proc Couleur_WordML {Couleur} {

    return ""

}

proc CouleursDesBoites {} {

    set ColorOutLine "white"
    set BackGround "white"
    set Police "couriel 10"
    set PoliceEntete "Couriel 12"
    
    set HBox "20"
    set LBox "200"
    set BordX "5"
    set BordY "5"
    set Ecart "2"
    
    set ListeDeTousLesTypesDeColoriage {}
    set BasicColor  [list "Basic Coloring" ""]         ; lappend ListeDeTousLesTypesDeColoriage $BasicColor
    set Masked [list "Masked AREA" "black"]            ; lappend ListeDeTousLesTypesDeColoriage $Masked
    set RAS    [list "Empty AREA" "lightgrey"]         ; lappend ListeDeTousLesTypesDeColoriage $RAS
    set RASRed [list "Compressed Empty AREA" "darkgrey"] ; lappend ListeDeTousLesTypesDeColoriage $RASRed
    set Strand   [list "STRAND" ""    ] ; lappend ListeDeTousLesTypesDeColoriage $Strand
    set StrandPP [list "+ / +"  "blue"] ; lappend ListeDeTousLesTypesDeColoriage $StrandPP
    set StrandMM [list "+ / -"  "red" ] ; lappend ListeDeTousLesTypesDeColoriage $StrandMM

    set Frame       [list "FRAME" ""]        ; lappend ListeDeTousLesTypesDeColoriage $Frame
    set FramePlus3  [list "+3" "blue4"]      ; lappend ListeDeTousLesTypesDeColoriage $FramePlus3
    set FramePlus2  [list "+2" "blue1"]      ; lappend ListeDeTousLesTypesDeColoriage $FramePlus2
    set FramePlus1  [list "+1" "DodgerBlue1"]; lappend ListeDeTousLesTypesDeColoriage $FramePlus1
    set FrameMoins1 [list "-1" "red1"]       ; lappend ListeDeTousLesTypesDeColoriage $FrameMoins1
    set FrameMoins2 [list "-2" "red3"]       ; lappend ListeDeTousLesTypesDeColoriage $FrameMoins2
    set FrameMoins3 [list "-3" "red4"]       ; lappend ListeDeTousLesTypesDeColoriage $FrameMoins3

    set Prot    [list "PROTEIN" ""]          ; lappend ListeDeTousLesTypesDeColoriage $Prot
    set Protein [list "Prot / Prot" "orange"]; lappend ListeDeTousLesTypesDeColoriage $Protein

    set TBlastX    [list "TBLASTX" ""]          ; lappend ListeDeTousLesTypesDeColoriage $TBlastX
    set TBlastX1   [list "+\(1-3\) / +\(1-3\)" "DarkOrchid"]; lappend ListeDeTousLesTypesDeColoriage $TBlastX1
    set TBlastX2   [list "+\(1-3\) / -\(1-3\)" "MediumOrchid"]; lappend ListeDeTousLesTypesDeColoriage $TBlastX2
    set TBlastX3   [list "-\(1-3\) / +\(1-3\)" "SpringGreen3"]; lappend ListeDeTousLesTypesDeColoriage $TBlastX3
    set TBlastX4   [list "-\(1-3\) / -\(1-3\)" "SpringGreen4"]; lappend ListeDeTousLesTypesDeColoriage $TBlastX4

    set ErrorT [list "ERROR" ""]      ; lappend ListeDeTousLesTypesDeColoriage $ErrorT
    set Error  [list "ERROR" "HotPink1"] ; lappend ListeDeTousLesTypesDeColoriage $Error

    set N [llength $ListeDeTousLesTypesDeColoriage]
    set HauteurMax [expr 2*$BordY + $N*($HBox + $Ecart)]
    set LargeurMax [expr $LBox + 2*$BordX]
    set K [UnCanva $LargeurMax $HauteurMax  $LargeurMax $HauteurMax]
    $K configure -background $BackGround

    set PosYMin $BordY
    set PosXMin $BordX
    set PosXCenter [expr $LargeurMax/2]
    set PosXMax [expr $PosXMin + $LBox]
    foreach UnElement $ListeDeTousLesTypesDeColoriage {
	set Texte [lindex $UnElement 0]
	set ColorFill [lindex $UnElement 1]
	
	if {[info exists PosYMax]} {set PosYMin [expr $PosYMax + $Ecart]}
	
	set PosYMax [expr $PosYMin + $HBox]
	set PosYCenter [expr ($PosYMax - $PosYMin)/2 + $PosYMin]
	
	if {$ColorFill == ""} {
	    set ColorFill "white"
	    $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax  -outline $ColorOutLine -fill $ColorFill
	    $K create text $PosXCenter $PosYCenter  -text "$Texte" -font "$PoliceEntete" -anchor c
	} else {
	    $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax  -outline $ColorOutLine -fill $ColorFill
	    $K create text $PosXCenter $PosYCenter  -text "$Texte" -font "$Police" -anchor c -fill white
	}
    }

    regsub {\.canvas} $K "" w
    destroy $w.buttons.postscript
    return ""

}

proc CouleursDesFrequences {} {

    set ColorOutLine "white"
    set BackGround "white"
    set Police "couriel 10"
    set PoliceEntete "Couriel 12"
    
    set HBox "20"
    set LBox "200"
    set BordX "5"
    set BordY "5"
    set Ecart "2"

    set ListeDeTousLesTypesDeColoriage {}

    set BasicColor  [list "Basic Coloring" ""]         ; lappend ListeDeTousLesTypesDeColoriage $BasicColor
    set Masked [list "Masked AREA" "black"]            ; lappend ListeDeTousLesTypesDeColoriage $Masked
    set RAS    [list "Empty AREA" "lightgrey"]         ; lappend ListeDeTousLesTypesDeColoriage $RAS
    set RASRed [list "Compressed Empty AREA" "darkgrey"] ; lappend ListeDeTousLesTypesDeColoriage $RASRed
    
    set Nuancier  [list "Distribution" ""]              ; lappend ListeDeTousLesTypesDeColoriage $Nuancier
    set ColorFill [ColoriageDeLaFrequence 1]
    set N1        [list "n \= 1" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N1
    set ColorFill [ColoriageDeLaFrequence 2]
    set N2_3      [list "2   < n < 3" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N2_3
    set ColorFill [ColoriageDeLaFrequence 4]
    set N4_10     [list "4   < n < 10" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N4_10
    set ColorFill [ColoriageDeLaFrequence 11]
    set N11_50    [list "11  < n < 50" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N11_50
    set ColorFill [ColoriageDeLaFrequence 51]
    set N51_100   [list "51  < n < 100" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N51_100
    set ColorFill [ColoriageDeLaFrequence 101]
    set N101_200  [list "101 < n < 200" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N101_200
    set ColorFill [ColoriageDeLaFrequence 201]
    set N201      [list "201 < n" "$ColorFill"] ; lappend ListeDeTousLesTypesDeColoriage $N201

        set N [llength $ListeDeTousLesTypesDeColoriage]
    set HauteurMax [expr 2*$BordY + $N*($HBox + $Ecart)]
    set LargeurMax [expr $LBox + 2*$BordX]
    set K [UnCanva $LargeurMax $HauteurMax  $LargeurMax $HauteurMax]
    $K configure -background $BackGround

    set PosYMin $BordY
    set PosXMin $BordX
    set PosXCenter [expr $LargeurMax/2]
    set PosXMax [expr $PosXMin + $LBox]
    foreach UnElement $ListeDeTousLesTypesDeColoriage {
	set Texte [lindex $UnElement 0]
	set ColorFill [lindex $UnElement 1]
	
	if {[info exists PosYMax]} {set PosYMin [expr $PosYMax + $Ecart]}
	
	set PosYMax [expr $PosYMin + $HBox]
	set PosYCenter [expr ($PosYMax - $PosYMin)/2 + $PosYMin]
	
	if {$ColorFill == ""} {
	    set ColorFill "white"
	    $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax  -outline $ColorOutLine -fill $ColorFill
	    $K create text $PosXCenter $PosYCenter  -text "$Texte" -font "$PoliceEntete" -anchor c
	} else {
	    $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax  -outline $ColorOutLine -fill $ColorFill
	    $K create text $PosXCenter $PosYCenter  -text "$Texte" -font "$Police" -anchor c -fill white
	}
    }

    regsub {\.canvas} $K "" w
    destroy $w.buttons.postscript
    return ""

}

proc CouleursDuBleuAuRouge {n} {

    return [RetourneLaListe [CouleursDuRougeAuBleu $n]]

}

proc CouleursDuRougeAuBleu {n} {

    if {$n==1} { return {red                                   } }
    if {$n==2} { return {red                               blue} }
    if {$n==3} { return {red               green           blue} }
    if {$n==4} { return {red orange        green           blue} }
    if {$n==5} { return {red orange        green lightblue blue} }
    if {$n==6} { return {red orange yellow green lightblue blue} }
    if {$n==7} { return {brown red orange yellow green lightblue blue} }
    if {$n==8} { return {brown red orange yellow green lightblue blue purple} }
    if {$n<=0} { return {} }
    return [concat [CouleursDuRougeAuBleu [incr n -1]] [list black]]

}

proc CouleursOrdali {MolId} {


    set chnok [string trim [string index $MolId 5]]
    if {$chnok == ""} {set chnok "a"}
    set mol [string range $MolId 0 3]

    global Defauts
    global LNOrdali
    global SDG
    global LNDG
    global Couleurs
    global Sequences
    global LongueurTotale
    global PDB_[set mol]_Sequence
    global TableauCouleurEtGroupe
    global ListeDesSpheres
    global LesPointsDuGroupe
    global NomEtSeqAssPDB

    set AColorier {}

    set NombreDeGroupes [llength $LNDG]
    set NbrGrp [expr {$NombreDeGroupes-2}]

    if {[lindex $LNDG end] != "grise"} {return}

    foreach elt $NomEtSeqAssPDB {
	scan $elt "%s %s %s" PDB NomSeqSel LaMolId
	if {$LaMolId == $MolId} {break}
    }
    set SeqSel $NomSeqSel
    set SeqAss [set Sequences($SeqSel)]
    set LongueurAli [string length $SeqAss]
    set SeqAlignee [lindex [set PDB_[set mol]_Sequence($chnok)] 1]
    set ListeDesSpheres($mol) {}

    set IdxDernierGroupe [expr {[llength $LNDG] - 2}]
    foreach groupe [lrange $LNDG 1 $IdxDernierGroupe] {
	set Ya [lsearch [set SDG($groupe)] $SeqSel]
	if {$Ya != -1} {
	    set NoGr [lsearch $LNDG $groupe]
	    set NmGr $groupe
	}
    }

    foreach e [array names TableauCouleurEtGroupe] {
	set Typecons [set TableauCouleurEtGroupe($e)]
	scan $e "%d,%d" ix iGr

	if {$NoGr != $iGr} {continue}
	if {[string index $SeqAss $ix] != "." && [string index $SeqAlignee $ix] !="."} {
	    set equiv [CorrespondanceAliPDB $MolId $ix $ix $SeqAss $SeqAlignee]
	    set NroRes [lindex $equiv 0]
	} else {
	    continue
	}

	if {[regexp "CoulG" $Typecons]} {
	    set CoulG [CouleurO2Ordali [CouleurDuGroupe $NoGr]]
	    set fgo $CoulG
	} else {
	    scan [set Couleurs($Typecons)] "%s %s" fg bg
	    set fgo $fg
	}

	if {$Typecons == "SimiGlob"} {
	    set fgo [set Defauts(CoulVariable)]
	}
	if {$Typecons == "IdenGlob"} {
	    set fgo $bg
	}
	if {$Typecons == "ConsGlob"} {
	    set fgo $bg
	}
	if {[regexp "InterG" $Typecons]} {
	    set fgo $bg
	}
	if {[regexp "IdenGr" $Typecons]} {
	    set fgo $bg
	}
	if {[regexp "Gris" $Typecons]} {
	    if {[set Defauts(SimiGris)]} {
		set fgo $fg
	    } else {
		set fgo [set Defauts(CoulVariable)]
	    }
	}
	set ResCou "$NroRes $fgo"

	if {[lindex [set LesPointsDuGroupe($NmGr)] $ix] == "*"} {
	    #		set ResCou "${chnok}$NroRes ${fgo}PTS"
	    set ResCou "$NroRes ${fgo}PTS"
	}
	lappend ListeDesSpheres($mol) $ResCou
	lappend AColorier [list $fgo ${chnok}$NroRes]
    }

    set AColorier [lsort -index 0 $AColorier]

    return $AColorier

}

proc CouleursPourO {ListeCouleurs} {


if {$ListeCouleurs == {}} {return ""}

set cpl0 [lindex $ListeCouleurs 0]
set c [lindex $cpl0 0]
set ccou [CouleurOrdali2O $c]
if {$ccou == "black"} {set ccou "white"}
set rdeb [lindex $cpl0 1]
if {[regexp {^a} $rdeb]} {set rdeb [string range $rdeb 1 end]}
set rfin $rdeb

foreach cpl [lrange $ListeCouleurs 1 end] {
set c [lindex $cpl 0]
set c [CouleurOrdali2O $c]
if {$c == "black"} {set c "white"}
set r [lindex $cpl 1]
if {[regexp {^a} $r]} {set r [string range $r 1 end]}
if {[LeNombreDuResidu $r] == [expr [LeNombreDuResidu $rfin]+1]} {
if {$c != $ccou} {
lappend LesCmds "pai_zone ; $rdeb $rfin $ccou"
set rdeb $r
set rfin $r
set ccou $c
}
set rfin $r
} else {
lappend LesCmds "pai_zone ; $rdeb $rfin $ccou"
set rdeb $r
set rfin $r
set ccou $c
}
}

return $LesCmds

}

proc CouleursPourPyMol {ListeCouleurs Chn} {


    set cavant ""
    set Cmd ""
    foreach cpl $AColorier {
	set c [lindex $cpl 0]
	set r [lindex $cpl 1]
	if {$c != $cavant} {
	    if {$Cmd != ""} {
		append Cmd ",$r)"
		lappend LesCmds "$Cmd"
		set Cmd ""
	    }
	    set Cmd "color $c, (chain $chn and resi $r"
	    set cavant $c
	} else {
	    append Cmd ",$r"
	    if {[string length $Cmd] > 60} {
		set cavant "toto"
	    }
	}
    }

    return $LesCmds

}

proc CouleursPourRasMol {ListeCouleurs} {


    global Lookup_Couleurs

    if {$ListeCouleurs == ""} {
	lappend LesCmds "select all"
	return $LesCmds
    }

    set cpl0 [lindex $ListeCouleurs 0]
    set c [lindex $cpl0 0]
    set c [string tolower [CouleurOrdali2O $c]]
    set rc [lindex [set Lookup_Couleurs($c)] 0]
    set gc [lindex [set Lookup_Couleurs($c)] 1]
    set bc [lindex [set Lookup_Couleurs($c)] 2]
    set ccou "\[$rc,$gc,$bc\]"

    set rdeb [LeNombreDuResidu [lindex $cpl0 1] ]
    set rfin $rdeb
    set cmd "select"
    set lav ""

    foreach cpl [lrange $ListeCouleurs 1 end] {
	set c [lindex $cpl 0]
	set toto $c
	set c [string tolower [CouleurOrdali2O $c]]
	set rc [lindex [set Lookup_Couleurs($c)] 0]
	set gc [lindex [set Lookup_Couleurs($c)] 1]
	set bc [lindex [set Lookup_Couleurs($c)] 2]
	set c "\[$rc,$gc,$bc\]"
	set r [LeNombreDuResidu [lindex $cpl 1] ]

	if { $c != $ccou } {
	    if {$rfin == $rdeb } {
		append cmd " ${lav}$rfin"
		lappend LesCmds $cmd
		lappend LesCmds "colour $ccou"
		set cmd "select"
	    } else {
		append cmd " ${lav}$rdeb-$rfin"
		lappend LesCmds $cmd
		lappend LesCmds "colour $ccou"
		set cmd "select"
	    }
	    set rdeb $r
	    set lav ""
	} else {
	    if {$r != ($rfin+1)} {
		if {[string length $cmd] > 100} {
		    lappend LesCmds $cmd
		    if {$rfin == $rdeb} {
			set cmd "select selected, $rdeb"
		    } else {
			set cmd "select selected, $rdeb-$rfin"
		    }
		} else {
		    if {$rfin == $rdeb} {
			append cmd " ${lav}$rdeb"
		    } else {
			append cmd " ${lav}$rdeb-$rfin"
		    }
		}
		set rdeb $r
		set lav ","
	    }
	}
	set rfin $r
	set ccou $c
    }

    lappend LesCmds "colour $ccou"
    lappend LesCmds "select all"

    return $LesCmds

}

proc CouleursPourVMD {ListeCouleurs Id} {

    global Lookup_ColVMD
    global Defauts

    set LesCmds {}
    set CVariable [CouleurOrdali2O [set Defauts(CoulVariable)]]
    lappend LesCmds "mol addrep $Id"
    lappend LesCmds "mol modselect 0 $Id all"
    lappend LesCmds "mol modcolor 0 $Id colorid [set Lookup_ColVMD($CVariable)]"

    if {$ListeCouleurs == {}} {return $LesCmds}

    set irep 1
    lappend LesCmds "mol addrep $Id"
    set cmd "mol modselect $irep $Id resid "

    set Ncol [llength [lsort -unique [ExtraitListeDeListe $ListeCouleurs 0]]]

    set cpl0 [lindex $ListeCouleurs 0]
    set ccou [CouleurOrdali2O [lindex $cpl0 0]]
    set cprev $ccou
    set iccou [set Lookup_ColVMD($ccou)]
    if {$iccou > 32} {set iccou [expr {$iccou - 32}]}
    set rdeb [LeNombreDuResidu [lindex $cpl0 1] ]
    set rfin $rdeb

    foreach cpl [lrange $ListeCouleurs 1 end] {
	set c [CouleurOrdali2O [lindex $cpl 0]]
	set ic [set Lookup_ColVMD($c)]
	if {$ic > 32} {set ic [expr {$ic - 32}]}
	set cprev ${ccou}
	set icprev $ic
	set r [LeNombreDuResidu [lindex $cpl 1] ]
	if { $c != $ccou } {
	    if {$rfin == $rdeb } {
		append cmd " $rfin"
	    } else {
		append cmd " $rdeb to $rfin"
	    }
	    lappend LesCmds $cmd
	    lappend LesCmds "mol modcolor $irep $Id colorid $iccou"
	    incr irep
	    lappend LesCmds "mol addrep $Id"
	    set cmd "mol modselect $irep $Id resid "
	    set rdeb $r
	} else {
	    if {$r != $rfin+1} {
		if {$rfin == $rdeb} {
		    append cmd " $rdeb"
		} else {
		    append cmd " $rdeb to $rfin"
		}
		set rdeb $r
	    }
	}
	set rfin $r
	set ccou $c
	set iccou $ic
    }

    if { $cprev != $ccou } {
	lappend LesCmds $cmd
	lappend LesCmds "mol modcolor $irep $Id colorid ${icprev}"
	incr irep
	lappend LesCmds "mol addrep $Id"
	set cmd "mol modselect $irep $Id resid "
	append cmd " $rfin"
    } else {
	if {$rfin == $rdeb} {
	    append cmd " $rdeb"
	} else {
	    append cmd " $rdeb to $rfin"
	}
    }
    lappend LesCmds $cmd
    lappend LesCmds "mol modcolor $irep $Id colorid ${iccou}"

    return $LesCmds

}

proc CountChildsWithGold {n} {


    set ::Tx(ChildD,$n) {}
    set nC 0
    foreach f $::Tx(Child,$n) {
	if {$::Tx(NbComp,$f)} {
	    incr nC
	    lappend Tx(ChildD,$n) $f
	}
    }
    set ::Tx(NbChildD,$n) $nC
    if {$nC == 0} {
	set ::Tx(hasSel,$n) 0
    } else {
	set ::Tx(hasSel,$n) 1
    }
    
    foreach f $::Tx(Child,$n) {
	CountChildsWithGold $f
    }

    return

}

proc CountCompleteGenomesPerNode {} {

    global LSelectableId Tx

    foreach g $LSelectableId {
	# g is in its own genealogy
	foreach anc [DonneGenealogieMem $g] {
	    incr Tx(NbComp,$anc)
	}
    }

    return

}

proc CountEnteteFASTA {fileName} {

	set fasta_file [open $fileName "r"]
	#reads input line by line
	set compteur 0
	while {[gets $fasta_file line]!=-1} {
    	if {$line==""} { continue }
    	if {[string index $line 0]==">"} {
			incr compteur
		}
	}
	return $compteur

}

proc CoupeAuBonMet {Nom PositionDuMet} {

    global RepertoireDuGenome

    set Debut  [Box $Nom debut]
    set Fin    [Box $Nom fin]
    set Orient [Box $Nom orient]

    if {$Orient == "F"} {
	set CoupeDebut   $Debut
	set CoupeFin     [expr $PositionDuMet-1]
	set NouveauDebut $PositionDuMet
	set NouvelleFin  $Fin
    } else {
	set CoupeDebut   [expr $PositionDuMet+1]
	set CoupeFin     $Fin
	set NouveauDebut $Debut
	set NouvelleFin  $PositionDuMet
    }

    set CoupeNuc [BoutADN $CoupeDebut $CoupeFin $Orient]
    set LongCoupeNuc [string length $CoupeNuc]
    set CoupePro [SeqNucToSeqPro $CoupeNuc]
    set LongCoupePro [string length $CoupePro]
    if { $LongCoupePro < 30 } {
	set CoupeTxt "Cut $LongCoupePro aas  $CoupePro"
    } else {
	set CoupeTxt "Cut $LongCoupePro aas  [string range $CoupePro 0 12] to [string range $CoupePro [expr $LongCoupePro-13] end]"
    }

    set SeqNuc [BoutADN $NouveauDebut $NouvelleFin $Orient]
    set SeqPro [SeqNucToSeqPro $SeqNuc]

    set NUC [SequenceFormatTFA $SeqNuc "$Nom $NouveauDebut $NouvelleFin $Orient Cut $LongCoupeNuc bases" "nucbrut"]
    if {[file exists "$RepertoireDuGenome/nuctfa/$Nom"]} {
	file copy -force "$RepertoireDuGenome/nuctfa/$Nom" "$RepertoireDuGenome/nuctfaorig/$Nom"
    }
    Espionne [Sauve $NUC dans "$RepertoireDuGenome/nuctfa/$Nom"]

    set TFA [SequenceFormatTFA $SeqPro "$Nom $NouveauDebut $NouvelleFin $Orient $CoupeTxt" "protbrut"]
    if {[file exists "$RepertoireDuGenome/prottfa/$Nom"]} {
	file copy -force "$RepertoireDuGenome/prottfa/$Nom" "$RepertoireDuGenome/prottfaorig/$Nom"
    }
    Espionne [Sauve $TFA dans "$RepertoireDuGenome/prottfa/$Nom"]

    return "$Nom $NouveauDebut $NouvelleFin $Orient"


}

proc CoupeAuBonMetPourTous {} {


    set NouvellesBornesDesPABs {} 
    set NouvellesBornesDesPABsSeules {} 
    foreach Nom [ListeDesPABs] {

	set Debut  [Box $Nom debut]
	set Fin    [Box $Nom fin]
	set Orient [Box $Nom orient]

	set NewCodonStart [ExtraitInfo $Nom "NewCodonStart"]
	if {[regexp {^ *[A-Z] [0-9]+} $NewCodonStart]} {
	    scan $NewCodonStart "%s %d" AA Position
	    if {$Position==1} { 
		lappend NouvellesBornesDesPABs "$Nom $Debut $Fin $Orient"
		continue
	    }
	    set SeqPro [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	    set AncienneEntamme [string range $SeqPro 0 8]
	    set AncienStart     [string index $SeqPro 0]
	    set AnciennePosition [expr -$Position + 1]
	    set Texte "=CuttedCodonStart: $AncienStart $AnciennePosition from $AncienneEntamme"
	    Espionne $Texte
	    InformeSansDemander $Nom $Texte
	    InformeParSuppressionDuChamp $Nom "CutCodonStart"
	} else {
	    lappend NouvellesBornesDesPABs "$Nom $Debut $Fin $Orient"
	    continue
	}

	if { $Orient == "F" } {
	    set PositionAbs [expr $Debut + ($Position-1)*3] 
	} else {
	    set PositionAbs [expr $Fin - ($Position-1)*3] 	    
	}
	
	set NomDebutFinOrient [CoupeAuBonMet $Nom $PositionAbs]
	ExtraireDe $NomDebutFinOrient N D F O
	Box $Nom debut  $D
	Box $Nom fin    $F
	Box $Nom orient $O
	lappend NouvellesBornesDesPABsSeules $NomDebutFinOrient
	lappend NouvellesBornesDesPABs       $NomDebutFinOrient
    }
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    Garde $FichierBornes
    SauveLesLignes $NouvellesBornesDesPABs dans $FichierBornes
    ChargeListeDeBoites
    return $NouvellesBornesDesPABsSeules

}

proc CoupleX {args} {

    global Toggle FrmSequence WTexteRegle NomTextSeq NomNomSeq

    $NomTextSeq  xview {*}$args
    $WTexteRegle xview {*}$args

    if {! [set Toggle(Scores)]} {
	return
    }
    set LgLtr [font measure SeqFont Z]
    lassign [split $args " "] t n p 
    set n [expr {$n*$LgLtr}]
    set args "$t $n $p"
    $FrmSequence.csc xview {*}$args

    return

}

proc CoupleY {args} {

    $::NomTextSeq yview {*}$args
    $::NomNomSeq  yview {*}$args

    return

}

proc CoupleYview {w1 w2 args} {

    eval $w1 yview $args
    eval $w2 yview $args

}

proc Coupure {Index Seuil aGpesDefinitifs} {

    global ListeNoeuds Branches1 Branches2 ListeDist GpesSequences
    upvar  $aGpesDefinitifs GpesDefinitifs
    
	set Index1 [lsearch $ListeNoeuds [list [lindex $Branches1 $Index]]]
	set Index2 [lsearch $ListeNoeuds [list [lindex $Branches2 $Index]]]
	if {[lindex $ListeDist $Index1]<$Seuil || $Index1==0} {
		lappend GpesDefinitifs [lindex $Branches1 $Index]
	} else {
	    Coupure $Index1 $Seuil GpesDefinitifs
	}
	if {[lindex $ListeDist $Index2]<$Seuil || $Index2==0} {
		lappend GpesDefinitifs [lindex $Branches2 $Index]
	} else {
	    Coupure $Index2 $Seuil GpesDefinitifs
	}	

}

proc CoupureDUnADNCirculaire {ADN LesSeqPos} {


    set LongADN [string length $ADN]
    Espionne $LongADN
    set Double [string toupper "$ADN$ADN$ADN"]

    foreach SeqPos $LesSeqPos {
	scan $SeqPos "%s %d" Seq Pos
	set Seq [string toupper $Seq]
	set iMin -1
	Espionne $Seq
	while 1 {
	    set i [string first $Seq $Double $iMin]
	    if {$i<0} { break }
	    set iMin [expr $i+1]
	    set Site [expr $i+$Pos]
	    lappend LesSites $Site
	    set SeqDuSite($Site) $Seq
	    incr Site $LongADN
	    lappend LesSites $Site
	    set SeqDuSite($Site) $Seq
	}
    }
    set LesSites [lsort -unique -integer $LesSites]
    set LesZones {}
    set LesSitesDeCoupure {}
    foreach SiteA [lrange $LesSites 0 end-1] SiteB [lrange $LesSites 1 end] {
	Espionne "$SiteA $SiteB"
	if {[info exists DejaVu($SiteA)]} { break }
	set DejaVu([expr $SiteA+$LongADN]) 1
	set FinSiteB [expr $SiteB-1]
	set Zone [string range $Double $SiteA $FinSiteB]
	lappend LesZones $Zone
	if {$FinSiteB>$LongADN} { set FinSiteB [expr $FinSiteB-$LongADN] } 
	lappend LesSitesDeCoupure "$SiteA $FinSiteB [set SeqDuSite($SiteA)] [set SeqDuSite($SiteB)]"
    }
    return [list $LesZones $LesSitesDeCoupure]

}

proc CoupureDesADNCirculaires {{LesFichiersTFA ""} {LesSeqPos ""} {RepDestin ""} {Enzyme ""}} {


    if {$LesSeqPos=={}} {
	set LesSeqPos [ChoixDUneListeDeSitesDeCoupure]
    }
    if {$LesFichiersTFA=={}} {
	set LesFichiersTFA [LesFichiersDeType "Rec2"]
    }

    if {$RepDestin==""} {
	FaireLire "Please browse for the directory where to store the files"
	set RepDestin [ChoixDuRepertoire [RepertoireDuGenome]]
    }
    set Rep $RepDestin
    set LesFichiersCrees {}
    foreach Fichier $LesFichiersTFA {
	set Queue [file tail $Fichier]
	regsub {.tfa$|.nucfa$} $Queue "" Queue
	set Access [EnteteDuFichierTFA $Fichier "access"]
	regsub -nocase {^(rec1_|rec2_|fusion_)} $Access "" Access
	set ADN [QueLaSequenceDuFichierTFA $Fichier]
	set ZonesEtSites [CoupureDUnADNCirculaire $ADN $LesSeqPos]
	set Zones [lindex $ZonesEtSites 0]
	set Sites [lindex $ZonesEtSites 1]
	foreach Zone $Zones Site $Sites {
	    set BeauSite [join $Site "-"]
	    if {$Enzyme!=""} { set BeauSite $Enzyme }
	    set BeauAccess "cut_${Access}_$BeauSite"
	    set FichierCree "$Rep/cut_${Queue}_$BeauSite.nuctfa"
	    set nBases [string length $Zone]
	    set TFA [SequenceFormatTFA $Zone "$BeauAccess $nBases bases" "nucbrut"]
	    Espionne [Sauve $TFA dans $FichierCree]
	    lappend LesFichiersCrees $FichierCree

	    set CDS ""
	    foreach {A B C} [split $Zone ""] {
		set Codon "$A$B$C"
		if {[CodonStopPossible $Codon]} { break }
		append CDS $Codon
	    }
	    set nAA [string length $CDS]
	    set SeqPro [SeqNucToSeqPro $CDS]
	    set ProtTFA [SequenceFormatTFA $SeqPro "$BeauAccess $nAA AA" "protbrut"]
	    set FichierCreeProt $FichierCree
	    regsub ".nuctfa$" $FichierCreeProt ".prottfa" FichierCreeProt
	    Espionne [Sauve $ProtTFA dans $FichierCreeProt]
	    lappend LesFichiersCrees $FichierCreeProt
	}
    }
    return $LesFichiersCrees

}

proc CoupureDesADNCirculairesPourTous {} {

    set RepDestin "[RepertoireDuGenome]/coupure"
    set LesFichiersCrees {}
    foreach R2 [Rec2 LaListeDes Rec2] {
	set FichierTFA [Rec2 $R2 Fichier]
	if {[FileAbsent $FichierTFA]} { continue }
	set Coupe [QuelleCoupure $R2]
	if {$Coupe==""} { continue }
	set Type "N"
	scan $Coupe "%s %s %s" Enzyme Pos Type
	if {$Type!="P"} { continue }
	set Seq [Signal $Enzyme SEQ]
	set LesFic [CoupureDesADNCirculaires [list $FichierTFA] [list "$Seq $Pos"] $RepDestin $Enzyme]
	LConcat LesFichiersCrees $LesFic
    }
    return $LesFichiersCrees

}

proc CoupureParEnzyme {{Qui ""} {Quoi ""}} {

    global CoupureParEnzyme
    if {[info exists CoupureParEnzyme($Qui,$Quoi)]} { return $CoupureParEnzyme($Qui,$Quoi) }
    if {[info exists CoupureParEnzyme("EstCharge")]} { return "" }

    foreach Coup [LesCoupuresPossibles] {
	set Type "N"
	scan $Coup "%s %s %s" Enzyme Pos Type
	set CoupureParEnzyme($Enzyme,position) $Pos
	set CoupureParEnzyme($Enzyme,type) $Type
	set Seq [Signal $Enzyme SEQ]
	set CoupureParEnzyme($Enzyme,sequence) $Seq
	lappend CoupureParEnzyme(ListeDes,Enzymes) $Enzyme
    }
    set CoupureParEnzyme("EstCharge") 1
    return [CoupureParEnzyme $Qui $Quoi]

}

proc CourtOS {OS} {

    return [Glossaire $OS Court]

}

proc Cousins {args} {

    global RepertoireDuGenome

    set FichierDesCousins "cousins"
    File delete -force $FichierDesCousins

    set RepertoireRacine [file dirname $RepertoireDuGenome]

    foreach Gdb $args {
	set Rep "$RepertoireRacine/$Gdb"
	foreach Fichier [glob -nocomplain "$Rep/nuctfa/*"] {
	    set Nom "$Gdb/nuctfa/[file tail $Fichier]"
	    if { ! [file exists $Fichier]} { continue }
	    set Seq [QueLaSequenceDuTFA $Fichier]
	    lappend LesSeqNom "$Seq $Nom"
	}
    }
    set LesSeqNom [lsort $LesSeqNom]
    lappend LesSeqNom "bidon bidon"
    set OldSeq "zzzzzz"
    set LaSortie {}
    foreach SeqNom $LesSeqNom {
	scan $SeqNom "%s %s" Seq Nom
	if {$OldSeq==$Seq} {
	    if { ! [info exists LesMemes]} { set LesMemes $OldNom }
	    lappend LesMemes $Nom
	} else {
	    if {[info exists LesMemes]} {
		Espionne [join $LesMemes " "]
		lappend LaSortie [join $LesMemes " "]
		unset LesMemes
	    }
	}
	Espionne "[string range $Seq 0 80] [string length $Seq]"
	set OldSeq $Seq
	set OldNom $Nom
    }
    if {$LaSortie=={}} {
	Sauve "No cusins were found" dans $FichierDesCousins
    } else {
	SauveLesLignes $LaSortie dans $FichierDesCousins
    } 
    return $FichierDesCousins

}

proc Cps {{Pattern ""} {Genome ""} {Mismatch ""} {GetWhat ""}} {


    regsub -all -nocase {[^A-Z]} $Pattern "" Pattern

    if {$Genome==""} { set Genome "human_2006_nomask" }
    if {$Mismatch==""} { set Mismatch 0 }
    set Pattern [string trim $Pattern]
    if {[string length $Pattern] < 5} { return "Error: Pattern contain at least $MinLength bases" } 
    set    UrlCps "http://kilida.u-strasbg.fr:8086/CST_Java_Servlet/InterfaceWebCST?action=search&access_program=1"
    append UrlCps "&genome=$Genome"
    append UrlCps "&pattern=$Pattern"

    Espionne $UrlCps
    set LesHits {}
    set LeNice {}
    foreach Ligne [LesLignesDuFichier $UrlCps] {
Espionne $Ligne
	set C ""; set S ""; set D ""; set F ""; set H ""
	if { ! [regexp -nocase {^chr[^1-9XY]*([0-9XY]+) +\(?([FBR\+\-])\)? +([0-9]+)[ \-]+ ([0-9]+) +[^A-Z]*([A-Z]+)} $Ligne Match C S D F H]} { continue }
	regsub -nocase {[F]}  $S "+" S
	regsub -nocase {[RB]} $S "-" S
	set C "chr$C"
	lappend LesHits "$C:$D-${F}($S) $H"
	lappend LeNice [format "%-5s %9d %9d (%s) %s" $C $D $F $S $H]
    }
    if {$GetWhat=="Show"}    { return [AfficheListe $LeNice "" "Hits on $Genome"] }
    if {$GetWhat=="GetNice"} { return [join $LeNice "\n"] }
    if {$GetWhat=="GetText"} { return [join $LesHits "\n"] }
    return $LesHits

}

proc CreatCSVFileSpeDom {TypeDeDomain} {


    switch $TypeDeDomain {
	"pfam"       { 
	    set Concat "ConcatPfam"
	    set Rep "[RepertoireDuGenome]/GPfam"
	}
	"domain"     { 
	    set Concat "ConcatDomain"
	    set Rep "[RepertoireDuGenome]/GDomain"
	}
	"region"     { 
	    set Concat "ConcatRegion"
	    set Rep "[RepertoireDuGenome]/GRegion"
	}
    }
    set Lspecies [LesLignesDuFichier [RepertoireDuGenome]/Especes.txt]
    set tab {}
    set ligne "Species/Prot"
    
    set ListeProt [ListeDesPABs]
    foreach fichier $ListeProt {
	#extrait info de IDExtraitInfo PUZ01 ID et recupere nombre de domain maximum trouver pour chaque PUZ
	set fileNBDom "$Rep/$fichier"
	append fileNBDom "DomMax"
	if { [file exists $fileNBDom]} {
	    foreach Ligne [LesLignesDuFichier $fileNBDom] {
		set NbDom $Ligne
		if {$NbDom==0} {set NbDom 1}
		#voir pour ici...
	    }
	    append ligne ";[ExtraitInfo $fichier "ID"]:$NbDom"
	} else {
	    #append ligne ";[ExtraitInfo $fichier "ID"]:0"
	    append ligne ";[ExtraitInfo $fichier "ID"]:1"
	}
    }
    lappend tab $ligne
    unset ligne
    
    #parcours les especes...
    foreach specie $Lspecies {
	#recupere le nombre maximum de paralogue trouve par espece
	set FileNbPara "[RepertoireDuGenome]/Bilan/NbMaxParaBilan"
	foreach Ligne [LesLignesDuFichier $FileNbPara] {
	    set valeur [split $Ligne ":"]
	    set esp [lindex $valeur 0]
	    if {$esp==$specie} {set nbLigneMax [lindex $valeur 1]}
	}
	set  tableau(0) "Esp:$specie;"
	for {set h 1} {$h<$nbLigneMax} {incr h} {
	    set tableau($h) ""
	}

	#parcours les PUZ
        foreach fichier $ListeProt {
	    #Espionne "fichier: $fichier"
	    if { [file exists "[RepertoireDuGenome]/macsimXml/$fichier.aj"]} {
		set fileMacsim "[RepertoireDuGenome]/macsimXml/$fichier.aj"
	    } else {
		set fileMacsim "[RepertoireDuGenome]/macsimXml/$fichier"
	    }
	    #retourne une liste d'ID correspodant à une espece et un PUZ definit
	    set listedesIDs [IDPourEspeceDanstfasdescopains $fichier "$specie"]
	    set ligne ""
	    set h 0
	    set fileNBDom "$Rep/$fichier"
	    append fileNBDom "DomMax"
	    foreach ID $listedesIDs {
		if {[regexp {^[1-9][A-Z0-9]{3}_[A-Z].*} $ID]} {
		    continue
		}
		append ligne $tableau($h)
		if { [file exists $fileNBDom]} {
		    foreach Ligne [LesLignesDuFichier $fileNBDom] {
			set NbDom $Ligne
			if {$NbDom==0} {set NbDom 1}
		    }
		    append ligne "$NbDom:"
		} else {
		    append ligne "1:"
		    #append ligne "0"
		}
		#recupere les annotion macsim pour le domain concerne
		set annotation [FromMacsims "$fileMacsim" "$ID" "$Concat"]
		foreach an $annotation {
		    #ancien... suivant
		    #set dom [lindex [split $an "/"] 0]
		    #nvx suivant
		    set dom [lindex [split $an " "] 0]
		    if {[regexp {(.*)from.*} $dom a p]} {
			set dom [string trim $p]
		    }
		    if {[regexp {^PROP_(.*)} $dom a d]} {
			set dom [string trim $d]
		    } else {
			set dom [string trim $dom]
		    }
		    append ligne "$dom|"
		}
		set tableau($h) $ligne
		incr h
		unset ligne
	    }
	    for {set s $h} {$s<$nbLigneMax} {incr s} {
		set Ligne1 $tableau($s)
		if { [file exists $fileNBDom]} {
		    foreach valeur [LesLignesDuFichier $fileNBDom] {
			set NbDom $valeur
			if {$NbDom==0} {set NbDom 1}
		    }
		    append Ligne1 "$NbDom:"
		} else {
		    append Ligne1 "1:"
		    #append Ligne1 "0"
		}
		set tableau($s) $Ligne1
		unset Ligne1
	    }
	    for {set h 0} {$h<$nbLigneMax} {incr h} {
		set Ligne1 $tableau($h)
		append Ligne1 ";"
		set tableau($h) $Ligne1
	    }
	}
	for {set h 0} {$h<$nbLigneMax} {incr h} {
	    lappend tab $tableau($h)
	}
    }
    set file "$Rep/Bilan.csv"
    SauveLesLignes $tab dans $file

}

proc CreateARPMACS_article {{FichierRSF ""}} {


    Wup "Creer les fichiers html des alignememts des familles obtenues"

    #1 Recuperation des familles D ARP et de l access
    if {$FichierRSF == ""} {
	set FichierRSF "[RepertoireDuGenome]/alignement_ARP/Actin_Complet6_7.rsf"
    }
    
    if {! [file exists "$FichierRSF"]} {continue}

    Espionne "1- Get and clean MACS"
    set FichierRSF [CleanFeaturesInMACS $FichierRSF ""]

    #2 Conversion du fichier rsf au format xml
    set FichierMSF  "$FichierRSF"
    set FichierXML  "$FichierRSF"
    set FichierHTML "$FichierRSF"
    regsub ".rsf$" $FichierMSF  ".msf"  FichierMSF
    regsub ".rsf$" $FichierXML  ".xml"  FichierXML
    regsub ".rsf$" $FichierHTML ".html" FichierHTML

    Espionne "2- Convert MACS in XML"
    set  ConversionOk [ConvertMSF2XML $FichierRSF $FichierXML]
    if {$ConversionOk == "-1"} {
	Espionne "Pb ConvertMSF2XML $FichierRSF $FichierXML"
	return ""
    }
    
    #3 Annotation du xml en fonction des elements specifiques aux familles d ARPs
    Espionne "3- Annotate MACS in XML"
    set NewXML [AnnoteLeXMLDesARPs_article $FichierXML $FichierXML]
    
    #4 Conversion et mise au format HTML pour ARPAnno
    Espionne "4- Convert MACS in HTML"
    HtmlFromXmlMACS $NewXML "Ftype_Specific" "$FichierHTML"
    
    #5 Conversion et mise au format MSF des nouveaux msf (sans les P02568_ et ARP01)
    Espionne "5- Convert back MACS in MSF"
    foreach F [list $FichierMSF] {
	#file delete -force $F
    }
    set  ConversionOk [ConvertXML2MSF $NewXML $FichierMSF]
    if {$ConversionOk == "-1"} {
	Espionne "Pb ConvertMSF2XML $FichierRSF $FichierXML"
	return ""
    }
    
    foreach F [list $FichierRSF $NewXML] {
	#file delete -force $F
    }

    return ""

}

proc CreateASM {} {

    set UID 3845
    set LesInfos {}
    set LeLdap {}
    foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/ASM2014/LoginASM2014.txt"] {
	regsub -all {[ \t]+} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	set L ""
	lassign [split $Ligne " "] N P L
	if {$L==""} { set L [string tolower $N] }
	set N [string toupper $N]
	set Info "$L $P $N $UID 3114 asm14 /home/$L asm2014"
	Espionne $Info
	lappend LesInfos $Info
	if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
	    file mkdir "/maison/asm2014/$L"
	}
	lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
	lappend LeLdap "objectClass: inetOrgPerson"
	lappend LeLdap "objectClass: posixAccount"
	lappend LeLdap "cn: $L"
	lappend LeLdap "sn: $N"
	lappend LeLdap "givenName: $P"
	lappend LeLdap "homeDirectory: /home/$L"
	lappend LeLdap "loginShell: /usr/bin/tcsh"
	lappend LeLdap "uidNumber: $UID"
	lappend LeLdap "gidNumber: 3114"
	lappend LeLdap "userPassword: {SSHA}1H8LEI+i4Pl7JuWJmoRW5VA0maeLU+UP"
	lappend LeLdap ""
	incr UID
    }
    SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/ASM2014/ToutPourASM2014.txt"
    set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/ASM2014/LdapPourASM2014.txt"]
    return $FichierLdap

}

proc CreateAgents {Lag} {

    global TAg Sequences
    #puts "[join $Lag \n]"
    foreach ag $Lag {
	lassign $ag n iAG active deb fin
	set s $Sequences($n)
	lappend TAg($n)         $iAG
	set TAg($iAG,$n,active) $active
	set TAg($iAG,$n,nseq)   $n
	set TAg($iAG,$n,seq)    [string range $s $deb $fin]
	set TAg($iAG,$n,dep)    $deb
	set TAg($iAG,$n,fin)    $fin
	set TAg($iAG,$n,mil)    [expr {int(1.*(($deb + $fin)/2))}]
    }
    
    return

}

proc CreateAliDump {OrganismeTarget VersionGenomeTarget {OrganismeQuery human} {VersionGenomeQuery hg18} {NbPairesDeChromosomes 23} {BirdVersion bird}} {

	Espionne " " 
	Espionne "CreateAliDump : Debut du chargement $OrganismeQuery VS $OrganismeTarget"
	set Path "/tmp"
	set PathOut "/tmp"
	set Extension "$VersionGenomeQuery.$VersionGenomeTarget.net.axt"
	set FichierDeDump [open "$PathOut/$VersionGenomeQuery.VS.$VersionGenomeTarget.dump" "w"]
	set genomeT $VersionGenomeTarget
	set genomeQ $VersionGenomeQuery
	set organismeT $OrganismeTarget
	set VraiNbChromosomes [expr $NbPairesDeChromosomes + 1]
	for {set I 1 } { $I <= $VraiNbChromosomes } {incr I} {
		if { $I < $NbPairesDeChromosomes } {		
			set Chrox $I
		} else {
			if { $I == $NbPairesDeChromosomes } {
				set Chrox "X"
			} else {
				set Chrox "Y"
			}
		}
		Espionne "Ajout du chromosome $Chrox au dump"
		set FichierAli [open "$Path/chr$Chrox.$Extension" "r"]
		set CompteurIdentifiantUnique 0
		while { [gets $FichierAli Ligne] >= 0 } {
			set FirstChar [string range $Ligne 0 0]
			while { $FirstChar == "#" } {
				gets $FichierAli Ligne	
				set FirstChar [string range $Ligne 0 0]
			}
			incr CompteurIdentifiantUnique
			ScanLaListe $Ligne aligID chromosomeQ startQ endQ chromosomeT startT endT strandT score
			gets $FichierAli sequenceQ
			gets $FichierAli sequenceT
			gets $FichierAli ligneVide
			set access "$VersionGenomeQuery.chr$I.seq$CompteurIdentifiantUnique.VS.$VersionGenomeTarget"
			puts $FichierDeDump "$access|$genomeQ|$genomeT|$CompteurIdentifiantUnique|$organismeT|$chromosomeQ|$startQ|$endQ|$chromosomeT|$startT|$endT|$strandT|$score|$sequenceQ|$sequenceT"
		
		}
		close $FichierAli
		unset FichierAli
	}
	#close $FichierDeClobDump
	close $FichierDeDump
	Espionne "CreateAliDump : Fin chargement $OrganismeQuery VS $OrganismeTarget" 	

}

proc CreateAllARPMACS_XML2HTML {{FichierTFA ""}} {


    Wup "Creer les fichiers html des alignememts des familles obtenues"
    Wup "Creer les fichiers html des alignememts des familles obtenues"

    #1 Recuperation des familles D ARP et de l access
    set VraiAccess       [LesResultatsARPAnalyses "VraiAccess"  "LaValeurMerci"]
    set LesVraisFamilles [LesResultatsARPAnalyses "LesFamilles" "LaValeurMerci"]
    foreach Famille $LesVraisFamilles {
	set FichierMSF "[RepARPAnnoWeb]/${VraiAccess}_${Famille}.msf"
	if {! [file exists "$FichierMSF"]} {continue}

	#2 Conversion du fichier msf au format xml
	set FichierXML  "$FichierMSF"
	set FichierHTML "$FichierMSF"
	regsub ".msf$" $FichierXML  ".xml"  FichierXML
	regsub ".msf$" $FichierHTML ".html" FichierHTML
	
	set  ConversionOk [ConvertMSF2XML $FichierMSF $FichierXML]
	if {$ConversionOk == "-1"} {continue}

	#3 Annotation du xml en fonction des elements specifiques aux familles d ARPs
	set NewXML [AnnoteLeXMLDesARPs $FichierXML $FichierXML]

	#4 Conversion et mise au format HTML pour ARPAnno
	HtmlFromXmlMACS $NewXML "Ftype_Specific" "$FichierHTML"

	#5 Conversion et mise au format MSF des nouveaux msf (sans les P02568_)
	foreach F [list $FichierMSF] {
	    file delete -force $F
	}
	
	set  ConversionOk [ConvertXML2MSF $NewXML $FichierMSF]
	if {$ConversionOk == "-1"} {continue}

	foreach F [list $FichierMSF $NewXML] {
	    #file delete -force $F
	}

    }
    return ""

}

proc CreateAllChrFinal {{Fichier ""}} {

    if {$Fichier==""} { set Fichier "[AnnotRep]/AllChrFinal.txt" }
    set LeTout {}
    foreach I [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] { 
	set L [EleGen Chr$I F ListOf All]
	LConcat LeTout $L
    }
    return [SauveLesLignes $LeTout dans $Fichier]

}

proc CreateAllHtmlFromXmlMacsim {NomOuFichier {Format ""} {RacineForAll ""} {TitreDeLaPage ""}} {

    #rR attention inversion des args
    return [HtmlFromXmlMacsim $NomOuFichier $Format "CreateAllHtml" $TitreDeLaPage $RacineForAll]

}

proc CreateAndDisplayMacsims {} {

    global ListeTypesDeFeatures TabSF LNOrdali LSOrdali Sequences

    if {[TypeAli] eq "XML" || [TypeAli] eq "ORD"} {
	return
    }
    
    if {$::Defauts(MacsimDone)} {
	FaireLire "Macsim already done !\nCan't do it twice for the moment !"

	return
    }

    FaireAttendre "Please wait ...\nCreating Macsims ..."
    
    ClearSelectionNoms
    set Lmsf [CreeLeMSF OnRetourne]

    set Txml [MacsimsOnWeb [join $Lmsf \n]]
    #Sauve $Txml Dans tmp.xml
    # Carefull !!
    # Txml is not a list but a text string !!
    if {! [regexp {^\<\?xml |^\ [AnnotRep]/$Nom"
	lappend LesCrees $Nom
    }
    return $LesCrees

}

proc CreateCommandeSigmaFromIgbmc {{LesFichiersCommande ""} {GetWhat ""}} {

    if {$GetWhat==""} { set GetWhat "GetList" }
    if {$LesFichiersCommande=={}} {
	set LesFichiersCommande [MorceauxChoisis [lsort [glob -nocomplain "*_commande*.txt"]]]
    }
    
    set SigmaScaleMicroMol [Entre "Scale in Micro Mol to order at Sigma: 0.05"]
    regsub -all {[^0-9\.]} $SigmaScaleMicroMol "" SigmaScaleMicroMol
    set SigmaPurification [Entre "Purification for Sigma: RPI"]
    regsub {[^\:]*\:} $SigmaPurification "" SigmaPurification
    set SigmaPurification [string trim $SigmaPurification]
    set SigmaComment ""

    set ListeSigma {}
    foreach FichierCommande $LesFichiersCommande {
	set OnAttend 1
	foreach Ligne [LesLignesDuFichier $FichierCommande] {
	    if {[regexp "FIN DE COMMANDE" $Ligne]} { break }
	    if {$OnAttend} {
		if { [regexp -- {\-\-\-\-\-} $Ligne]} { set OnAttend 0 }
		continue
	    }  
	    if { [regexp -- {\-\-\-\-\-} $Ligne]} { continue }
	    if { [string trim $Ligne]==""} { continue }
	    if {[regexp { *[0-9]+ +P[0-9]+ *} $Ligne]} {
		scan $Ligne "%d %s %s" n P SS
		set Seq($P) ""
		set SigSuj($P) $SS
		lappend LesP $P
		continue
	    }
	    regsub {[53]'} $Ligne "" S
	    regsub -all " " $S "" S
	    append Seq($P) $S
	}
    }
    foreach P $LesP {
	lappend ListeSigma "$P $SigSuj($P)\t$Seq($P)\t$SigmaScaleMicroMol\t$SigmaPurification\t$SigmaComment"
    }
    if {$GetWhat=="GetList"} { return $ListeSigma }
    if {$GetWhat=="GetText"} { return [join $ListeSigma "\n"] }
    return [SauveLesLignes $ListeSigma dans $GetWhat]  
	

}

proc CreateConglomerat {Fichier {FichierConglomerat ""}} {

    JeMeSignale
    set LesHeader [LitString ListOf Header $Fichier]
    set LesLignes {}
    lappend LesLignes [join $LesHeader "\t"]
    foreach I [LitString ListOf Index] {
	set PC [LitString $I PIDCop]
	if {[LitString $PC IsRef]} { continue }
	set LesPIDRefs [lsort -unique [LitString $PC "ListOfRef"]]
	set LesPNRefs {}
	foreach Ref $LesPIDRefs {
	    set PNRef [LitString $Ref PN]
	    lappend LesPNRefs $PNRef
	}
	set Hub [join $LesPNRefs "/"]
	lappend CopsDuHub($Hub) $PC
	lappend LesHubs $Hub
	set HubDuCop($PC) $Hub
    }
    foreach I [LitString ListOf Index] {
	set PC [LitString $I PIDCop]
	if {[LitString $PC IsRef]} {
	    set NewLabel ""
	} else {
	    set Hub $HubDuCop($PC)
	    if {[info exists DejaVu($Hub)] && ! [info exists DejaVuCop($PC)]} { continue }
	    set DejaVu($Hub) 1
	    set DejaVuCop($PC) 1
	    set CopsDuHub($Hub) [lsort -unique $CopsDuHub($Hub)]
	    set LesCops {}
	    foreach PIDCop $CopsDuHub($Hub) {
		set PNCop [LitString $PIDCop PN]
		lappend LesCops $PNCop
	    }
	    set Copains [join $LesCops ""]
	    set LabelCopains $Copains
	    if {[string length $Copains]>25} {
		set LabelCopains "[string range $Copains 0 20]...-[llength $CopsDuHub($Hub)]"
	    }
	    set HubName $LabelCopains
	    set NewLabel $HubName
	}
	set LaLigne {}
	foreach H $LesHeader {
	    set Value [LitString $I $H]
	    if {$H=="PNCop"} { set Value $HubName }
	    lappend LaLigne $Value
	}
	lappend LesLignes [join $LaLigne "\t"]
    }
    
    return [SauveLesLignes $LesLignes dans $FichierConglomerat]

}

proc CreateContextMenu {AId menu} {

    # destroy any pre-exising menu with the same name
    set mRad "${menu}Rad"
    set mDen "${menu}Den"
    destroy $mRad
    destroy $mDen
    
    # create new menus
    # for radial representation
    menu $mRad -tearoff 0
    $mRad add command -compound left -image PT -label "Pointer" -command [list PointerMode $AId]
    $mRad add command -compound left -image ZP -label "Zoom +" -command [list ZoomMode $AId zplus]
    $mRad add command -compound left -image ZM -label "Zoom -" -command [list ZoomMode $AId zmoins]
    $mRad add command -compound left -image RP -label "Rotate +" -command [list RotateMode $AId "-[PiS8]"]
    $mRad add command -compound left -image RM -label "Rotate -" -command [list RotateMode $AId [PiS8]]
#    $mRad add command -label "Zoom +" -command [list ZoomMode $AId zplus]
#    $mRad add command -label "Zoom -" -command [list ZoomMode $AId zmoins]
#    $mRad add command -label "Rotate +" -command [list RotateMode $AId "-[PiS16]"]
#    $mRad add command -label "Rotate -" -command [list RotateMode $AId [PiS16]]
#    $mRad add command -label "Tag ..." -command [list set Abr($AId,DoTagNode) 1]

    # for dendrogram representation
    menu $mDen -tearoff 0
    $mDen add command -label "Pointer" -compound left -image PT -command [list PointerMode $AId]
    $mDen add command -label "Width +" -compound left -image WE -command [list WidthMode $AId 20]
    $mDen add command -label "Width -" -compound left -image WS -command [list WidthMode $AId -20]
    $mDen add command -label "Height +" -compound left -image HE -command [list HeightMode $AId 5]
    $mDen add command -label "Height -" -compound left -image HS -command [list HeightMode $AId -5]

    return

}

proc CreateContextMenuFeature {} {

    global EFeat

    set m [set EFeat(ContextMenu)]
    # destroy any pre-exising menu with the same name
    destroy $m
    
    # create new menus
    menu $m -tearoff 0
    if {$EFeat(LItemSel) == {} } {
	$m add command -label "Select Item ..." -command {CmdsMenuFeatures "selitem"}
	$m add command -label "Select All Items ..." -command {CmdsMenuFeatures "selitall"}
	$m add command -label "Select region ..." -command {CmdsMenuFeatures "selreg"}
	$m add separator
	$m add command -label "Clear selection ..." -command {CmdsMenuFeatures "clearsel"}
    } else {
	$m add command -label "Edit Item ..." -command {CmdsMenuFeatures "edit"}
	$m add command -label "Define New ..." -command {CmdsMenuFeatures "define"}
	$m add command -label "Delete selected Items ..." -command {CmdsMenuFeatures "delete"}
	$m add command -label "Propagate Item to this group" -command {CmdsMenuFeatures "propagitem"}
	$m add command -label "Propagate Item to all" -command {CmdsMenuFeatures "propagall"}
	$m add separator
	$m add command -label "Clear selection ..." -command {CmdsMenuFeatures "clearsel"}
    }

    return

}

proc CreateContextMenuTax {} {

    global Tx

    set m [set Tx(ContextMenu)]
    # destroy any pre-exising menu with the same name
    destroy $m
    
    # create new menus
    menu $m -tearoff 0  -foreground white  -background black  -font TaxFont
    $m add command -label "Add to selection" -command {AddTaxToSelection}
    $m add command -label "Remove from selection" -command {RemoveTaxFromSelection}

    return

}

proc CreateDimer {system} {

    global LNOrdali LSOrdali TabSF Sequences ListePDB StrucAVoir PositionInitiale

    LesDefauts Mode batch

    set sysdir [string tolower $system]
    set aars [string toupper [string index $system 0]]
    set file [file join [MiSynPatDir] data alignments "${aars}_WithModules.xml"]
    DecortiqueUnXml2 $file
    InitSequences
    InitInfoSeqs
    AssignSeqToGroup
    DonneTabFeature TabSF
    global {*}[info globals "TD*"]
    update
    puts "alignment file loaded ..."
    
    # name of human mito sequence
    set nhm "[string toupper [string index $system 0]]mito_Homo.sapi"
    set shm [set Sequences($nhm)]

    # find closest PDB structure
    set Lns [list]
    foreach n $ListePDB {
	lappend Lns $n [set Sequences($n)]
    }
    lappend Lns $nhm $shm
    CalculeLesPCIGenerique $Lns TPCI
    set Lres [list]
    foreach k [array names TPCI "$nhm,*"] {
	lassign [split $k ,] tmp nm
	if {[string range $nm 0 3] ne "PDB_"} {
	    continue
	}
	set pc [lindex $TPCI($k) 0]
	lappend Lres [list $pc $nm]
    }
    set Lres [lsort -real -decreasing -index 0 $Lres]
    
    foreach k $Lres {
	lassign $k pc nm
	puts "$pc -- $nm"
	set nom [DonneIdDeAccessPDB $nm]
	foreach c [$nom _chains] {
	    puts "   $c : [$nom dbref $c]"
	}
	puts ""
    }

    return
    exit

}

proc CreateDirIfAbsent {Dir} {

    if {[DirExists $Dir]} { return "" }
    file mkdir $Dir
    return $Dir

}

proc CreateESBS2015 {} {

    set UID 4001
    set Hash [exec slappasswd -h "{SSHA}" -s esbs2015]
    set LesInfos {}
    set LeLdap {}
    foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/ESBS2015/ListeESBS2015.txt"] {
	regsub -all {[ \t]+} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	set L ""
	lassign [split $Ligne " "] N P M L
	if {$L==""} { set L [string tolower $N] }
	set N [string toupper $N]
	set Info "$L $P $N $UID 3115 esbs15 /home/$L esbs2015"
	Espionne $Info
	lappend LesInfos $Info
	if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
	    set HomeDir "/maison/esbs2015/$L"
	    if { ! [file exists $HomeDir]} { file mkdir "/maison/esbs2015/$L" }
	    if { ! [file exists /home/$L]} { exec ln -s $HomeDir /home/ }
	}
	lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
	lappend LeLdap "objectClass: inetOrgPerson"
	lappend LeLdap "objectClass: posixAccount"
	lappend LeLdap "cn: $L"
	lappend LeLdap "sn: $N"
	lappend LeLdap "givenName: $P"
	lappend LeLdap "homeDirectory: /home/$L"
	lappend LeLdap "loginShell: /usr/bin/tcsh"
	lappend LeLdap "uidNumber: $UID"
	lappend LeLdap "gidNumber: 3900"
	lappend LeLdap "userPassword: $Hash"
	lappend LeLdap ""
	incr UID
    }
    SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/ESBS2015/ToutPourESBS2015.txt"
    set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/ESBS2015/LdapPourESBS2015.txt"]
    return $FichierLdap

}

proc CreateFileResume {fichier} {

    
    set directory [RepertoireDuGenome]
    set repProtembl [RepertoireDuGenome]/protembl
    #Espionne "repProtembl $repProtembl"
    #liste des infos a recupere dans le fichier macsimXML
    set infoParse {"ConcatDomain" "ConcatPfam" "ConcatStruct" "ConcatKoanno"}
    #EspionneL "infoParse: $infoParse"
    
    #creation du repertoire Bilan
    if { ! [file exists "Bilan"]} {
	File mkdir Bilan
    }
    set newRep [RepertoireDuGenome]/Bilan
    
    #Espionne "Repertoire : $directory"
    set filetmp {}
    set pdbList {}
    #Espionne $fichier
    set n [split $fichier "/"]
    set filename [lindex $n [llength $n]-1]
    #Espionne $filename
    set newFile $newRep/$filename
    
    set LL [LaSequenceDesBanques $fichier]
    DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX CC SequenceBrute LaDETotal
    set Entete "$ID $AC $OS $DE"
    #set DR [EmblInfo $fichier DR]
    set SQ [EmblInfo $fichier SQ]
    set longueurSeq [lindex $SQ 0]
    set longueurSeq [lindex [split $longueurSeq ";"] 0]
    set taille [lindex [split $longueurSeq " "] 3]
    lappend filetmp "ID: $ID"
    lappend filetmp "AC: $AC"
    lappend filetmp "DE: $DE"
    foreach sq $SequenceBrute {
	lappend filetmp "DE: $sq"
    }
    lappend filetmp "OS: $OS"
    lappend filetmp "GN: $LaDETotal"
    lappend filetmp "$longueurSeq"
    
    
    lappend filetmp "\n"
    #set compt [comptNbOrtho "[RepertoireDuGenome]/OrthoResult/$filename.fasta"]
    set compt [comptNbOrtho "[RepertoireDuGenome]/NewTfasDesCopains/$filename"]
    lappend filetmp "*Orthologues:"
    #-1 pour la sequence d'interet qui est dans le fichier fasta de orthoinspector
    lappend filetmp "  Nombre d'orthologues trouv¨¦s: [expr $compt-1]"
    
    #recher des infos pdb, PFAM et KoAnno
    lappend filetmp "\n"
    lappend filetmp "*Annotation Macsim"
    
    
    if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} {
	set fileMacsim "[RepertoireDuGenome]/macsimXml/$filename.aj"
    } else {
	set fileMacsim "[RepertoireDuGenome]/macsimXml/$filename"
    }
    
    #Espionne "fileMacsim: $fileMacsim"
    foreach Iparse $infoParse {
	#Espionne "pour: $Iparse"
	if { [regexp {Concat(.*)} $Iparse p ip]} {
	    lappend filetmp "$ip:"
	    #Espionne "ip: $ip"
	}
	if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} {
	    set annotation [FromMacsims "$fileMacsim" "$filename" "$Iparse"]
	    foreach an $annotation {
		#Espionne "an: $an"
		set pos [split [lindex [split $an "/"] 1] "-"]
		set deb [lindex $pos 0]
		set end [lindex $pos 1]
		set long [expr $end-$deb+1]
		set recouvrement [expr ($long*100)/$taille]
		lappend filetmp "  $an  longueur: $long  recouvrement: $recouvrement%"
	    }
	} else {
	    set annotation [FromMacsims "$fileMacsim" "$filename" "$Iparse"]
	    foreach an $annotation {
		#Espionne "an2 $an"
		lappend filetmp "  $an"
	    }
	}
    }
    
    #recuperation de la sequence d'interet avec les gaps
    if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} {
	set annotation [FromMacsims "$fileMacsim" "$filename" "SeqData"]
	set SeqInt [split $annotation ""]
    } else {
	set annotation [FromMacsims "$fileMacsim" "$filename" "SeqData"] 
	set SeqInt [split $annotation ""]
    }

    #puis recuperation de la sequence de la ou des PDB!!!
    lappend filetmp "PDB:"
    #recuperation des pdb
    set ListProt [FromMacsims "$fileMacsim" "ListOf" "Names"]
    foreach l $ListProt {
	if {[regexp {[1-9][a-z0-9]{3}_.*|[1-9][A-Z0-9]{3}_.} $l]} {
	    #Espionne "PDB: $l"
	    lappend pdbList $l
	}
    }
    
    foreach lpdb $pdbList {

	if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} {
	    set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"]
	    set SeqPdb [split [string trim $annotation] ""]
	} else {
	    set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"]
	    set SeqPdb [split [string trim $annotation] ""]
	}
	
	#creation d'un pocedure pour calculer le recouvrement entre deux sequences.
	#recouvrement position de debut et de fin du pbd par rapport ¨¤ une sequene cible (dan l'alignement)
	set recouvrement [RecouvrementDesSequences $SeqInt $SeqPdb]
	set position [split $recouvrement "/"]
	set LengthPdb [expr [lindex $position 1] - [lindex $position 0] +1]
	lappend filetmp "  $lpdb: Length: $LengthPdb - recouvrement $recouvrement - [expr ($LengthPdb*100)/$taille]%"
    }
    
    #Recherche des info String
    set repString [glob -directory [RepertoireDuGenome]/StringRep *]
    #Espionne "repString $repString"
    if { [file exists $repString]} {
	if {[file exists $repString/$filename]} {
	    set Lignes [LesLignesDuFichier $repString/$filename]
	    lappend filetmp "\n"
	    lappend filetmp "Interactions:"
	    foreach l $Lignes {
		lappend filetmp $l
	    }
	}
    }
    SauveLesLignes $filetmp dans $newFile

}

proc CreateFileResumePourTous {{directory ""}} {

    
    if {$directory==""} {set directory [RepertoireDuGenome]/protembl}
    set r [glob -directory $directory *]
    
    foreach fichier $r {
	set n [split $fichier "/"]
	set f [lindex $n [llength $n]-1]
	if {[PasTouche $f]} { continue }
	#Espionne "Fichier en cours de traitement: $fichier"
	CreateFileResume $fichier
	FinPasTouche $f
    }

}

proc CreateGeneralDatas {} {

	set listeBlast [ListeDesPABs2]
	set FICOUT [open "all.csv" "w"] 
	set compteur 1
	foreach PAB $listeBlast {
		puts $FICOUT "$compteurGroupes;$PAB;[GetOrga $PAB]"
		incr compteur
		puts $compteur
	}
	close $FICOUT

}

proc CreateGscopeDatabaseForCDSProtFoF {} {


    while 1 {
	set FoF [ButineArborescence All "[RepertoireDuGenome]"]
	if {$FoF=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
	break
    }

    foreach Ligne [LesLignesDuFichier $FoF] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	scan $Ligne "%s" FN 
	if { ! [file exists $FN]} { continue }
	set Access [EnteteDuFichierTFA $FN "Access"]
	lappend LesFOFs "$Access $FN"
    }
    set StartFOF "[RepertoireDuGenome]/StartingWithNuc.fof"
    if {[FileAbsent $StartFOF]} { 
	set StartFOF [SauveLesLignes $LesFOFs dans $StartFOF]
    }
    CreeBornesDesPABsPourUneCollection $StartFOF

}

proc CreateGscopeProjectFromOiName {{Source ""} {OiName ""} {SpOnly ""}} {

JeMeSignale
    #rR Attention ici OiName peut aussi être OiCode ............ mais je laisse OiName en nom de variable
    if {$Source=="OiOld"} { set UseOiCode 0 } else { set UseOiCode 1 }
    if {$SpOnly==""} {
	set SpOnly [OuiOuNon "Do I use only Swissprot (I'll test BANK=sp in the protein headers)" 0]
    }
    while {$OiName==""} {
	if {$UseOiCode} {
	    set Info [ChoixParmi [OiCode ListOf Info]]
	} else {
	    set Info [ChoixParmi [OiName ListOf Info]]
	}
	if {$Info==""} {
	    if {[OuiOuNon "Do I skip CreateGscopeProjectFromOiName"]} { return "" }
	    continue
	}
	scan $Info "%s" OiName
    }
    set RepGen     "/gstock/$OiName"
    set RepGenLink "/genomics/link/$OiName"
    if {[file exists $RepGen] || [file exists $RepGenLink]} {
	if { ! [OuiOuNon "$RepGen or $RepGenLink already exists. Do I continue anyway ?" 1]} { return "" }
    }
    if {[FileAbsent $RepGen]}     { file mkdir $RepGen }
    if {[FileAbsent $RepGenLink]} { file link -symbolic $RepGenLink $RepGen}

    set DeOiDir $RepGenLink/DeOi
    file mkdir $DeOiDir
    if {$UseOiCode} {	
	set FastaFile [OiCode $OiName FullFilePath]
	set FastaName [OiCode $OiName OI]
	set OX        [OiCode $OiName OX]
    } else {
	set FastaFile [OiName $OiName Fasta]
	set FastaName [OiName $OiName Orga]
	set OX        [OiName $OiName OX]
    }
    set Destin $DeOiDir/$FastaName

Espionne "file copy $FastaFile $Destin"

    if {[FileAbsent $Destin]} { file copy $FastaFile $Destin }
    if {$SpOnly} {
	set AllBanks "${Destin}_AllBanks"
	file rename $Destin "$AllBanks"
	SpOnlyFromFasta $AllBanks $Destin
    }


    set OS [QuestionDeScience EVImm "ret Tax $OX Name"]
    set OC [QuestionDeScience EVImm "ret TaxClass $OX Name"]
    regsub "^root; cellular organisms; " $OC "" OC 

    return $Destin

}

proc CreateGscopeProjectWithFasta {{FastaFile ""} {ProjName ""}} {

    set RepGen     "/gstock/$ProjName"
    set RepGenLink "/genomics/link/$ProjName"
    if {[file exists $RepGen] || [file exists $RepGenLink]} {
	if { ! [OuiOuNon "$RepGen or $RepGenLink already exists. Do I continue anyway ?" 1]} { return "" }
    }
    if {[FileAbsent $RepGen]}     { file mkdir $RepGen }
    if {[FileAbsent $RepGenLink]} { file link -symbolic $RepGenLink $RepGen}
    
    set DeDir "$RepGenLink/DeWeb"
    file mkdir $DeDir
    set FastaName [file tail $FastaFile]
    set Destin $DeDir/$FastaName
    if {[FileAbsent $Destin]} { file copy $FastaFile $Destin }
    
    return $Destin

}

proc CreateGscopeProjectWithOi {Source OiName {SpOnly ""}} {

    if {$SpOnly ==""} { set SpOnly  0 }
    set FichierFasta [CreateGscopeProjectFromOiName $Source $OiName $SpOnly]
    return $FichierFasta

}

proc CreateIDMapping {} {

    set table "
       - idmapping : {
          . acc V16
          . db V24
          . target V64
       
}"
    set db "root"
    package require sqlite3
    set db [FabriqueDeTables $table $db idmapping.sql]
    $db copy ignore idmapping idmapping.dat "\t"
    $db close
    
    exit

}

proc CreateIcarusScripts {} {

	###script pour extraction de refseq
	if {[file exists "Extract_refseq_fasta_seq_full_desc.icarus"]} {
		file delete -force "Extract_refseq_fasta_seq_full_desc.icarus"
	}
	set script [open "Extract_refseq_fasta_seq_full_desc.icarus" "w"]
	puts $script "\$organism = \$Args:\[n:2\]"
	puts $script "\$queryStr = '\[refseqp-id:*\]'"
	puts $script "\$queryStr.app:\[s:'<\[refseqp-txi:'\]"
	puts $script "\$queryStr.app:\[s:\$organism\]"
	puts $script "\$queryStr.app:\[s:'\]'\]"
	puts $script "\$startEntry = 1"
	puts $script "\$blockSize = 100"
	puts $script "\$sess=\$Session:\[\]"
	puts $script "\$set = \$sess.query:\[\$queryStr\]"
	puts $script "\$setLen = \$set.size:\[\]"
	puts $script "for:{\$i=\$startEntry \$i<=\$setLen \$i+=\$blockSize} {"
	puts $script "  for:{\$j=0 \$j<\$blockSize \$j++} {"
	puts $script "    \$entryNum = \$i + \$j"
	puts $script "    if:(\$entryNum <= \$setLen) {"
	puts $script "      \$entry = \$set.getEntry:\[\$entryNum\]"
	puts $script "      \$des='>ref|'"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:id\]\]"
	puts $script "      \$des.app:\[s:'|'\]"
	puts $script "      \$des.app:\[s:'\['\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:org\]\]"
	puts $script "      \$des.app:\[s:'\]'\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:des\]\]"
	puts $script "      \$Print:|(\$des)"
	puts $script "      \$Print:|(\$entry.getSeq:\[format:plain inputFormat:genbank\])"
	puts $script "    }"
	puts $script "  }"
	puts $script "}"
	close $script
	puts "file created : Extract_refseq_fasta_seq_full_desc.icarus"
	### script pour extraction de uniprotKB/swissprot
	if {[file exists "Extract_uniprotKB-sp_fasta_seq_full_desc.icarus"]} {
		file delete -force "Extract_uniprotKB-sp_fasta_seq_full_desc.icarus"
	}
	set script [open "Extract_uniprotKB-sp_fasta_seq_full_desc.icarus" "w"]
	puts $script "\$organism = \$Args:\[n:2\]"
	puts $script "\$queryStrSP = '\[uniprot_swissprot-id:*\]'"
	puts $script "\$queryStrSP.app:\[s:'<\[uniprot_swissprot-txi:'\]"
	puts $script "\$queryStrSP.app:\[s:\$organism\]"
	puts $script "\$queryStrSP.app:\[s:'\]'\]"
	puts $script "\$queryStrTR = '\[uniprot_trembl-id:*\]'"
	puts $script "\$queryStrTR.app:\[s:'<\[uniprot_trembl-txi:'\]"
	puts $script "\$queryStrTR.app:\[s:\$organism\]"
	puts $script "\$queryStrTR.app:\[s:'\]'\]"
	puts $script "\$startEntry = 1"
	puts $script "\$blockSize = 100"
	puts $script "\$sess=\$Session:\[\]"
	puts $script "\$set = \$sess.query:\[\$queryStrSP\]"
	puts $script "\$setLen = \$set.size:\[\]"
	puts $script "for:{\$i=\$startEntry \$i<=\$setLen \$i+=\$blockSize} {"
	puts $script "  for:{\$j=0 \$j<\$blockSize \$j++} {"
	puts $script "    \$entryNum = \$i + \$j"
	puts $script "    if:(\$entryNum <= \$setLen) {"
	puts $script "      \$entry = \$set.getEntry:\[\$entryNum\]"
	puts $script "      \$des='>sp|'"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:pac\]\]"
	puts $script "      \$des.app:\[s:'|'\]"
	puts $script "      \$des.app:\[s:'\['\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:org\]\]"
	puts $script "      \$des.app:\[s:'\]'\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:id\]\]"
	puts $script "      \$des.app:\[s:' '\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:nam\]\]"
	puts $script "      \$des.app:\[s:' GN='\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:GE\]\]"
	puts $script "      \$Print:|(\$des)"
	puts $script "      \$Print:|(\$entry.getSeq:\[format:plain inputFormat:swiss\])"
	puts $script "    }"
	puts $script "  }"
	puts $script "}"
	close $script
	puts "file created : Extract_uniprotKB-sp_fasta_seq_full_desc.icarus"
	### script pour extraction de uniprotKB/swissprot
	if {[file exists "Extract_uniprotKB-tr_fasta_seq_full_desc.icarus"]} {
		file delete -force "Extract_uniprotKB-tr_fasta_seq_full_desc.icarus"
	}
	set script [open "Extract_uniprotKB-tr_fasta_seq_full_desc.icarus" "w"]
	puts $script "\$organism = \$Args:\[n:2\]"
	puts $script "\$queryStrTR = '\[uniprot_trembl-id:*\]'"
	puts $script "\$queryStrTR.app:\[s:'<\[uniprot_trembl-txi:'\]"
	puts $script "\$queryStrTR.app:\[s:\$organism\]"
	puts $script "\$queryStrTR.app:\[s:'\]'\]"
	puts $script "\$startEntry = 1"
	puts $script "\$blockSize = 100"
	puts $script "\$sess=\$Session:\[\]"
	puts $script "\$set = \$sess.query:\[\$queryStrTR\]"
	puts $script "\$setLen = \$set.size:\[\]"
	puts $script "for:{\$i=\$startEntry \$i<=\$setLen \$i+=\$blockSize} {"
	puts $script "  for:{\$j=0 \$j<\$blockSize \$j++} {"
	puts $script "    \$entryNum = \$i + \$j"
	puts $script "    if:(\$entryNum <= \$setLen) {"
	puts $script "      \$entry = \$set.getEntry:\[\$entryNum\]"
	puts $script "      \$des='>tr|'"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:pac\]\]"
	puts $script "      \$des.app:\[s:'|'\]"
	puts $script "      \$des.app:\[s:'\['\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:org\]\]"
	puts $script "      \$des.app:\[s:'\]'\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:id\]\]"
	puts $script "      \$des.app:\[s:' '\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:nam\]\]"
	puts $script "      \$des.app:\[s:' GN='\]"
	puts $script "      \$des.app:\[s:\$entry.str:\[field:GE\]\]"
	puts $script "      \$Print:|(\$des)"
	puts $script "      \$Print:|(\$entry.getSeq:\[format:plain inputFormat:swiss\])"
	puts $script "    }"
	puts $script "  }"
	puts $script "}"
	close $script
	puts "file created : Extract_uniprotKB-tr_fasta_seq_full_desc.icarus"

}

proc CreateImAnnoGenes {{WhatToDo ""}} {

    set Rep "/genomics/link/ImAnnoGenes"

    file mkdir "$Rep/nuctfa"
    file mkdir "$Rep/prottfa"

    if {$WhatToDo==""} { set WhatToDo [ChoixParmi [list "DoSeq" "DoBornesDoSeq" "InformeOnly"]] }

    set LongSeqDefaut 99 

    set Bornes {}
    set Deb 100
    foreach LesValeurs [lrange [GPG Get All] 0 end] {
	set Fin [expr $Deb + $LongSeqDefaut - 1]
	foreach K [GPG ListOf keys] V $LesValeurs {
	    set $K $V
	}
	set Nom $nom
	set Gn  $name
	if {[regexp "DoSeq" $WhatToDo]} {
	    set FicNuc "[NucProteomeDir]/$Gn.tfa"
	    if {[FileAbsent $FicNuc] || [file size $FicNuc]==0} {
		set TfaNuc ">$Nom $Gn not found yet\nATGTGA"
		set TfaPro ">$Nom $Gn not found yet\nATGTGA"
	    } else {
		set TfaNuc [ContenuDuFichier $FicNuc]
		regsub ">" $TfaNuc ">$Nom " TfaNuc
		set Entete [EnteteDuTexteTFA $TfaNuc]
		set SeqNuc [QueLaSequenceDuTexteTFA $TfaNuc]
		set SeqPro [SeqNucToSeqPro $SeqNuc]
		set TfaPro [SequenceFormatTFA $SeqPro $Entete "protbrut"]
	    }
	    Sauve $TfaNuc dans "$Rep/nuctfa/$Nom"
	    Sauve $TfaPro dans "$Rep/prottfa/$Nom"
	}
	lappend Bornes "$Nom $Deb $Fin"
	set Deb [expr $Deb + $LongSeqDefaut + 1]
	if {[regexp "Informe" $WhatToDo]} {
	    InformeSansDemander $Nom "=NM: $accessnum"
	    InformeSansDemander $Nom "=ValiGN: $Gn"
	    InformeSansDemander $Nom "=ValiDE: $description"
	    InformeSansDemander $Nom "=PkImAnno: $pk"
	    InformeSansDemander $Nom "=GenePaintId: $gpid"
	    InformeSansDemander $Nom "=EntrezId: $entrezid"
	}
    }
    if { ! [regexp "Borne" $WhatToDo]} { return "Je n'ai pas recréé bornesdespabs" }
    set FicBornes [SauveLesLignes $Bornes dans "$Rep/fiches/bornesdespabs"]
    return $FicBornes

}

proc CreateLinkInMacsimXmlOri {} {

    set XmlDir "[MiSynPatDir]/data/alignments"
    set RepMacimXml "[RepertoireDuGenome]/macsimXml_Ori"
    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 CreateMotifMappingLevure {FichierMotifAMapper} {

    set FichierMotif $FichierMotifAMapper
    regsub ".txt" $FichierMotif "_MappingLevure.txt" FichierMotif
    set FichierCodonStartExonMix "/home/nguefack/random/levure/levure_R64/S_cerevisiae_StartCodonMix_Position.txt"
    set LeNew {}
    set LeNew2 {}
    set I 0
    set DernierTrouve $I
    set LesExons [LesLignesDuFichier $FichierCodonStartExonMix]
    set N [llength $LesExons]
    foreach Ligne [LesLignesDuFichier $FichierMotifAMapper] {
	lassign [LesMotsDeLaLigne $Ligne] Chr D F L C U
	set I $Deniertrouve
	while 1 {
	    if {$I>=$N} { break }
	    set Ligne [lindex $LesExons $I]
	    incr I
	    set LesMots [LesMotsDeLaLigne $Ligne]
	    lassign $LesMots ChrA S E GnID GS GE TrID TS TE ExNb ES EE

	    if {$Chr==$ChrA && $ES <= $D && $D <= $EE} {
		set NewLigne "$Chr $S $E $GnID $GS $GE [expr $GE-$GS+1] $TrID $TS $TE [expr $TE-$TS+1] $ExNb $ES $EE [expr $EE-$ES+1] $D $F $L $C $U [expr $D-$E+1]"
		lappend LeNew $NewLigne
		set DernierTrouve [expr $I-1]
		break 
	    }
	}
    }
    SauveLesLignes $LeNew dans $FichierMotif
    return "ok"

}

proc CreateMotifsMapping {{TypeATester ""}} {

    #rR Ici on cree les fichier MotifsMapping.txt MotifsMappingX.txt MotifsMapping9.txt ... MotifsMapping1.txt
    #rR   chacun concernant un type d'élément donné.
    #rR Pour cela on combine le fichier motif_list.bed avec les appels à 'EleGen Chr T ListOf D' et 'EleGen Chr T ListOf F'
    #rR Mais attention il y a deux manières de parcourir les ListOf D et F
    #rR  - quand on traite le fichier final (MotifsMapping.txt) qui contient toutes les bornes contigues on peut avancer tranquille 
    #rR  - quand on traite les fichiers X 9 8 ... (MotifsMappingX.txt ... ) il faut recommencer à relire tous les ListOf D depuis le début. 

    if {$TypeATester=="DoAll"} {
	set LesCrees {}
	foreach T [AnnotType ListOf T] {
	    lappend LesCrees [CreateMotifsMapping $T]
	}
	lappend LesCrees [CreateMotifsMapping ""]
	return $LesCrees
    }

    set Contigu [string equal $TypeATester ""]

    if {$TypeATester==""} {
	set FichierMotifsMapping "[AnnotRep]/MotifsMapping.txt"
    } else {
	set FichierMotifsMapping "[AnnotRep]/MotifsMapping$TypeATester.txt"
    }
    if {$TypeATester==""} { set TypeATester "F" }


    set ChrPrec ""
    set LeResultat {}
    foreach Ligne [LesLignesDuFichier "[AnnotRep]/motif_list.bed"] {
    	lassign [LesMotsDeLaLigne $Ligne] Chr D F
	set Chr [BonChr $Chr]
	if { ! [regexp -nocase "Chr" $Chr]} { Espionne "Ligne incorrecte =$Ligne=" ; continue }
	if {$Chr!=$ChrPrec} {
	    set K 0
	    set LesD [EleGen $Chr $TypeATester ListOf D]
	    set LesF [EleGen $Chr $TypeATester ListOf F]
	    set I 0
	    set DC [lindex $LesD $I]
	    set FC [lindex $LesF $I]
	}
	set ChrPrec $Chr
	incr K
	if {$K%100==1} { Espionne "$Chr $ChrPrec $K $I $D $F //// [lrange $LesD $I-3 $I+3]" }
	# Espionne "$I motif $Ligne"
	set Trouve 0
	if { ! $Contigu } { set I 0 }        ; #rR Attention on recommence au debut pour checher le motif courant.
	while 1 {
	    if {$DC <= $D && $D <=$FC} { set Trouve 1 ;  break } 
	    incr I
	    set DC [lindex $LesD $I]
	    set FC [lindex $LesF $I]
	    #Espionne "$I $DC $FC $Ligne"
	    if {$DC==""} { break; FaireLire "Aie Aie Aie DC non trouve en $I $Chr $D $F" ; break }
	    if {$FC==""} { break; FaireLire "Aie Aie Aie FC non trouve en $I $Chr $D $F" ; break }
	}
	if { ! $Trouve } {
	    continue
	    Espionne "non trouve $DC $FC de =$Ligne="
	    #exit
	}
	set TduD [EleGen $Chr $TypeATester $DC E]
	set TduF [EleGen $Chr $TypeATester $FC E]
	set Info [EleGen $Chr $TypeATester $DC Info]

	set DebutMessage "$Chr $D $F [expr $F-$D+1]"
	set LaSuiteDuMessage [list "$TduD $Info"]

	
	if { ! $Contigu } { set I 0 }        ; #rR Attention on recommence au debut pour chercher le motif courant.
	set Trouve 0
	set PremiereFois 1
	while 1 {
	    if {$DC <= $F && $F <=$FC} {
		set Trouve 1
		if { ! $PremiereFois } { lappend LaSuiteDuMessage "$TduF $Info" } 
		break
	    }
	    set PremiereFois 0
	    #rR Ici on n'a pas trouve la fin dans le meme morceau ... 
	    incr I
	    set DC [lindex $LesD $I]
	    set FC [lindex $LesF $I]
	    set TduF [EleGen $Chr $TypeATester $FC E]
	    set Info [EleGen $Chr $TypeATester $DC Info]
	    if {$Contigu} { lappend LaSuiteDuMessage "$TduF $Info" } 
	    if {$DC==""} { break; FaireLire "Aie Aie Aie DC non trouve $Chr $D $F" ; break }
	    if {$FC==""} { break; FaireLire "Aie Aie Aie FC non trouve $Chr $D $F" ; break  }
	}
	if { ! $Trouve } {
	    continue
	    Espionne "non trouve $Ligne"
	    #exit
	}
	set LaSuiteDuMessage [lsort -decreasing $LaSuiteDuMessage]
	set Message "$DebutMessage [join $LaSuiteDuMessage { / }]" 
	#Espionne $Message
	lappend LeResultat $Message
    }
    set FicMotifsMapping [SauveLesLignes $LeResultat dans $FichierMotifsMapping]
    return $FicMotifsMapping

}

proc CreateMsfOfFamiliarOrganismsForAll {} {

    set CreateFiles {}
    set Rep "[RepertoireDuGenome]/msffam"
    if { ! [file exists $Rep]} { file mkdir $Rep }
    foreach Nom [ListeDesPABs] {
	set FamMsfFile "$Rep/$Nom"
	if {[file exists $FamMsfFile]} { continue }
	set FamMsf [MsfOfFamiliarOrganisms $Nom]
	if {$FamMsf==""} { continue }
	Espionne [Sauve $FamMsf dans $FamMsfFile]
	lappend CreateFiles $$FamMsfFile
    }
    return $CreateFiles

}

proc CreateNode {T {Where root} args} {

    if {$args=={}} {
	set Id [$T insert $Where]
    } else {
	set Id [$T insert $Where $args]
    }
    $T tag add "IAm$Id" $Id
    $T label $Id "memelabel"
    return $Id

}

proc CreateOligosAndPpcrForAlvi {} {


    set TMvoulu 60

    set RepPpcr "[RepertoireDuGenome]/ppcr"
    if {[FileAbsent $$RepPpcr]} { file mkdir $RepPpcr }

    set FichierOrdre "[Fiches]/pour_oligosAlvi.csv"
    set Queue [file tail $FichierOrdre]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    LoadTxl $FichierOrdre T -1 ","

    set LesHeaders $T(ListHeaderPlease,$Queue)
    Espionne $LesHeaders
    foreach I $T(ListAllPlease,$Queue) {
	Espionne $I
	foreach Header $LesHeaders {
	    set $Header $T($I,$Header)
	}
	if {$Nom_Demandeur==""} { set Nom_Demandeur $OldNom_Demandeur }
	set OldNom_Demandeur $Nom_Demandeur
	if {$Query==""} { set Query $OldQuery }
	set OldQuery $Query
	set LaLigne [list $Ordre_commande $GscopeId $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query]  
	set Infos($GscopeId) $LaLigne
	lappend LesLignes $LaLigne
	Espionne $LaLigne
    }
    set LesLignes [lsort -index 0 -integer $LesLignes]
    set NoSitePlease "NoSitePlease"
    set LesSites5ATester [list "NdeI" "force_NdeI"] 
    set LesSites3ATester [list "BamHI" "BglII" "force_$NoSitePlease"] 
    foreach Site [concat $LesSites5ATester $LesSites3ATester] {
	regsub "force_" $Site "" SiteVrai
	if {$SiteVrai==$NoSitePlease} {
	    set SeqSite($Site) "I'm not a -DNA- sequence"
	} else {
	    set SeqSite($Site) [QuestionDeScience ProGS "ret Signal $SiteVrai SEQ"]
	}
    }
    foreach LaLigne $LesLignes {
	ScanLaListe $LaLigne Ordre_commande GscopeId Plaque_Oligos Clone GscopeProjects Nom_Demandeur Query
	set Nom $GscopeId
	if {[ExtraitInfo $Nom "Junk:"]!=""} { continue }
	set Alias [Alias $Nom]
	set DE [ExtraitInfo $Nom "DE:"]
	set OliC [ExtraitInfo $Nom "OliC:"]
	set CterUnknown [regexp -nocase "^no" $OliC]
	set AccessStartEnd [EnteteDuFichierTFA [GscopeFile $Nom "nucoligo"] "access"]
	ScanLaListe [split $AccessStartEnd "-"] Bidon Start End
	set TFA [ContenuDuFichier [GscopeFile $Nom "nuctfa"]]
	set Seq "n[QueLaSequenceDuTexteTFA $TFA]"
	set Ent [EnteteDuTexteTFA $TFA]
	set CodonStart [string range $Seq $Start [expr $Start +2]]
	set CodonEnd   [string range $Seq [expr $End -2] $End]
	set Debut 1
	if {[string equal -nocase $CodonStart "ATG"]} { set Debut 2 } 
	set Fin [expr ($End - $Start +1)/3]
	if {[CodonStopPossible $CodonEnd]} { incr Fin -1 }
	set SeqPGS [string range $Seq $Start $End]
	set EntPGS "$Alias Alvinella pompejana"
	if {$DE!=""} { append EntPGS " $DE" }
	append EntPGS " from $Nom"
	set RunOff ""
	if {$CterUnknown} {
	    set RunOff "RunOffpME18S"
	    if {[regexp "^ALEN" [Alias $Nom]]} { set RunOff "RunOffpDONR222" }
	    append EntPGS " Cter sequence unknown, use RunOff oligo $RunOff"
	}
	set TFAPGS [SequenceFormatTFA $SeqPGS $EntPGS "nucbrut"]
	set SEQPGS [string toupper "$SeqPGS"]
	set BonSite5 ""
	foreach Site $LesSites5ATester {
	    if {[regexp "^force_" $Site]} {
		regsub "force_" $Site "" SiteVrai
		set BonSite5 $SiteVrai
		break
	    }
	    set SeqSi $SeqSite($Site)
	    set Indice [string first $SeqSi "n$SEQPGS"]
	    if {$Indice==-1} { set BonSite5 $Site ; break }
	}
	set BonSite3 ""
	foreach Site $LesSites3ATester {
	    if {[regexp "^force_" $Site]} {
		regsub "force_" $Site "" SiteVrai
		set BonSite3 $SiteVrai
		break
	    }
	    set SeqSi $SeqSite($Site)
	    set Indice [string first $SeqSi "n$SEQPGS"]
	    if {$Indice==-1} { set BonSite3 $Site ; break }
	}
	Espionne "$Nom $BonSite5 $BonSite3"
	if {$BonSite5==$NoSitePlease} { set Ajout5 "" } else { set Ajout5 "_$BonSite5" } 
	if {$BonSite3==$NoSitePlease} { set Ajout3 "" } else { set Ajout3 "_$BonSite3" } 
#rR     sans AttB1 car BrocOli
	set S5 "Thrombin${Ajout5}"
	set S3 "STOP${Ajout3}_AttB2"
	set Sujet "${Alias}-${Debut}-${Fin}"
	if {$RunOff!=""} { set S3 ${RunOff}_AttB2 }
	set Commande "${S5}_${Sujet}_$S3 $Clone"
	Espionne "$Nom $Commande\n$TFAPGS\n"
#rR Gros bug tous les oligos 5 sont faux detecte le 1/6/2007
#rR	set SeqSens [string range $SeqPGS [expr ($Debut-1)*3 + 2] [expr ($Fin-1)*3 + 2]]
	set SeqSens [string range $SeqPGS [expr ($Debut-1)*3] [expr ($Fin-1)*3 + 2]]
	
	set Entamme5 [EntammePourMeltingTemp $SeqSens $TMvoulu]
	set Oligo5 ""
	set SeqSignaux5 ""
	foreach Signal [split $S5 "_"] {
	    set SS [Signal $Signal "SEQ"]
	    append SeqSignaux5 $SS
	    append Oligo5 $SS
	}
	append Oligo5 $Entamme5
	set SeqRAC [NucToReverseAndComplementNuc $SeqSens]
	if {$RunOff!=""} {
	    set Entamme3 ""
	} else {
	    set Entamme3 [NucToReverseAndComplementNuc [EntammePourMeltingTemp $SeqRAC $TMvoulu]]
	}	
	set Oligo3 $Entamme3
	set SeqSignaux3 ""
	foreach Signal [split $S3 "_"] {
	    set SS [Signal $Signal "SEQ"]
	    append SeqSignaux3 $SS
	    append Oligo3 $SS
	}
	set Oligo3RAC [NucToReverseAndComplementNuc $Oligo3]
	Espionne $Oligo5
	Espionne $Oligo3
	regsub "[PreFixe]" $Nom "" Numero
	set Numero [Base10 $Numero]
	set OligoNameF [format "%s%5.5d%s" Ap $Numero F]
	set OligoNameR [format "%s%5.5d%s" Ap $Numero R]
	if {$RunOff!=""} { set OligoNameR $RunOff }
	set NotesF  "$OligoNameF ${S5}_${Sujet} for $GscopeId at $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query"
	set NotesR  "$OligoNameR ${Sujet}_${S3} for $GscopeId at $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query"
	Espionne $NotesF
	Espionne $NotesR
	regsub -all {\s} $Oligo5 "" OligoF
	regsub -all {\s} $Oligo3RAC "" OligoR
	lappend LaSortieF "$OligoNameF;$OligoF;3 OD;DST;;$NotesF"
	lappend LaSortieR "$OligoNameR;$OligoR;3 OD;DST;;$NotesR"
	
	set FichierPpcr "$RepPpcr/$Nom"
	if {$RunOff==""} {
	    set EntetePpcr "ProduitPCR_AttB1_${S5}_${Sujet}_$S3 for $Nom at $Plaque_Oligos"
	    set SeqPpcr "[Signal AttB1 SEQ]$SeqSignaux5$SeqSens$SeqSignaux3"
	    set TfaPpcr [SequenceFormatTFA $SeqPpcr $EntetePpcr "nucbrut"]
	    if {[FileAbsent $FichierPpcr] || [OuiOuNonMemo "Do I overwrite the NonRunOff Ppcr files?"]} {
		Sauve $TfaPpcr dans $FichierPpcr
	    }
	} else {
	    set N27 [string repeat "N" 27]
	    set EntetePpcr "ProduitPCR_AttB1_${S5}_${Sujet}_N27_$S3 for $Nom at $Plaque_Oligos !Caution! N27=3' missing sequence"
	    set SeqPpcr "[Signal AttB1 SEQ]$SeqSignaux5$SeqSens$N27$SeqSignaux3"
	    set TfaPpcr [SequenceFormatTFA $SeqPpcr $EntetePpcr "nucbrut"]
	    if {[FileAbsent $FichierPpcr] || [OuiOuNonMemo "Do I overwrite the RunOff Ppcr files?"]} {
		Sauve $TfaPpcr dans $FichierPpcr
	    }  
	}

    }
    set FichierOligosF "[Fiches]/OligosF.csv"
    set FichierOligosR "[Fiches]/OligosR.csv"
    if {[OuiOuNon "Do I save to \n$FichierOligosF\n and \n$FichierOligosR"]} {
	SauveLesLignes $LaSortieF dans $FichierOligosF
	SauveLesLignes $LaSortieR dans $FichierOligosR
    }
    exit

}

proc CreateOligosForMutation {FichierOuTexteOliMut {FicOli ""} {ReverseAussi ""}} {

    JeMeSignale
    if {$ReverseAussi==""} { set ReverseAussi "ReverseAussi" }
    if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
 
    global DefaultLengthes
    set SuperDefaultLengthes "5 5 15 15 (AA before, AA after, bases before, bases after)"

    if {[OuiOuNonMemo "Do you want to change the default length of 5' and 3' extensions of the mutation oligos ?" ]} {
	if { ! [info exists DefaultLengthes]} { set DefaultLengthes [Entre $SuperDefaultLengthes] }
    } else {
	set DefaultLengthes $SuperDefaultLengthes
    }

    ScanLaListe $DefaultLengthes NbAAsAvant NbAAsApres NbBasesAvant NbBasesApres

    if {$FichierOuTexteOliMut==""} { return "" }
    if {[regexp "\n" $FichierOuTexteOliMut]} {
	if {$FicOli==""} {
	    set FicOli [NomDuFichierDesOligosPourMutation "./mutationoligos.tfa"]
	    if {$FicOli==""} { return "" }
	}
	set Texte $FichierOuTexteOliMut
	set LesOligos {}
	foreach Ligne [split $Texte "\n"] {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    CreateOligosForMutation $Ligne $FicOli $ReverseAussi
	}
	return $FicOli
    }
    if { ! [regexp " " $FichierOuTexteOliMut]} {
	set Fichier $FichierOuTexteOliMut
	if {[file exists $Fichier]} {
	    set FicOli [NomDuFichierDesOligosPourMutation $Fichier]
	    if {$FicOli==""} { return "" }
	    return [CreateOligosForMutation [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
	}
	FaireLire "$FichierOuTexteOliMut\ndoesn't exist. I'll cancel CreateOligosForMutation"
	return [list "No mutation oligo for ($FichierOuTexteOliMut) which doesn't exist"]
    }

    if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourMutation ""] }
    if {$FicOli==""} { return "" }

    set Ligne $FichierOuTexteOliMut
    scan $Ligne "%s %s" PAB PABMute

    set FicNucTFA "[RepertoireDuGenome]/nuctfa/$PABMute"
    if { ! [file exists $FicNucTFA]} {
	FaireLire "$FicNucTFA\ndoesn't exists. I'll skip CreateOligosForMutation $Ligne"
	return [list "No mutation oligo for ($FichierOuTexteOliMut) $FicNucTFA doesn't exist"]
    }
    set ToutSeqNuc [QueLaSequenceDuFichierTFA $FicNucTFA]
    set MaxP [expr [string length $ToutSeqNuc]/3]

    set LesCodes [lrange [split [string trim $Ligne] " "] 2 end]
    set Extension [lindex $LesCodes end]
    if { ! [regexp -nocase  {^[a-z]} $Extension]} {
	set LesCodes [lrange $LesCodes 0 end-1]
    } else {
	set Extension ""
    }
    Espionne "\n\n$LesCodes  extension $Extension"
    set LesCoOrdonnes {}
    foreach Code $LesCodes {
	if { ! [regexp -nocase {[a-z]} $Code]} { continue }
#	regsub {[0-9]+} [string toupper $Code] " & " Coco
	regsub {[0-9]+} $Code " & " Coco
	scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	set LongAncienP [string length $AncienP]
	lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
    }
    set LesCoOrdonnes [lsort -increasing -integer -index 1 $LesCoOrdonnes]
    set Decalage 0
    set LesVraiesPositionsDebut {}
    set LesVraiesPositionsApres {}
    foreach Co $LesCoOrdonnes {
	scan $Co "%s %d %s" AncienP PosAncienP NouveauP
	set Code "$AncienP$PosAncienP$NouveauP"
	set MutationDeNucleotides [regexp {[a-z]} $Code]
	if {$MutationDeNucleotides} {
	    if { ! [OuiOuNon "I see lowercase letters in $Code!\nOk to mutate nucleotides ?"]} {
		FaireLire "I'll skip $Code"
		continue
	    }
	}
	set PosAncienP [expr $PosAncienP+$Decalage]
	regsub -all -nocase "X" $AncienP  "" VraiAncienP
	regsub -all -nocase "X" $NouveauP "" VraiNouveauP
	set Decalage [expr [string length $VraiNouveauP]-[string length $VraiAncienP]]
	set VraiePositionDebut       $PosAncienP
	set VraiePositionApres [expr $PosAncienP+[string length $VraiNouveauP]]
	lappend LesVraiesPositionsDebut $VraiePositionDebut
	lappend LesVraiesPositionsApres $VraiePositionApres
	if {$MutationDeNucleotides} {
	    set DebN [Maxi 1 [expr $VraiePositionDebut - $NbBasesAvant]]
	    set FinN [Mini   [expr $VraiePositionApres + $NbBasesApres] [expr $MaxP*3]]
	} else {
	    set DebP [Maxi 1 [expr $VraiePositionDebut    - $NbAAsAvant]]
	    set FinP [Mini   [expr $VraiePositionApres -1 + $NbAAsApres] $MaxP]
	    set DebN [expr ($DebP-1)*3     + 1]
	    set FinN [expr ($FinP-1)*3 + 2 + 1]
	}
	set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
	set AvecSubRegion [OuiOuNonMemo "Do you want to take a subregion of these mutation oligos ?" 0]
	if {$AvecSubRegion} {
	    set SeqNucOriginal $SeqNuc
	    set DebNOriginal $DebN
	    set FinNOriginal $FinN
	    while 1 {
		FaireLire "For $PABMute $Code\nPlease insert 2 spaces to indicate where to cut (0 to keep full seq)" 
		set SeqNucCutted [Entre $SeqNucOriginal]
		set i1 [string first " " $SeqNucCutted]
		set i2 [string last  " " $SeqNucCutted]
		if {$i1==-1 || $i2==-1} {
		    if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
		    FaireLire "Please insert 2 or 0 spaces"
		    continue
		}
		set NouveauDebutN [expr $DebN + $i1]
		set NouveauFinN   [expr $FinN - ([string length $SeqNucCutted]-$i2-1)]
		if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
		    FaireLire "You cut to much ... We redo cutting."
		    continue
		}
		set DebN $NouveauDebutN
		set FinN $NouveauFinN
		set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
		set AvecSubRegion 1
		break
	    }
	}
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	regsub -all "." $SeqPro "&  " SeqPro3
	Espionne "$SeqNuc\n$SeqPro3"
	set Entete ""
	set Alias [Alias $PABMute]
	if {$Alias==""} { set Alias $PABMute }
	set AliasCode "$Alias"
	if { ! [regexp "$Code$" $AliasCode]} { append AliasCode "-$Code" }
	if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
	set Entete "MutOli_$AliasCode mutation oligo for $PABMute $Alias $Code $DebN $FinN"
	set TFA [SequenceFormatTFA $SeqNuc $Entete "nucbrut"]
	AppendAuFichier $FicOli $TFA
	if {$ReverseAussi} {
	    if {$AvecSubRegion} {
		while 1 {
		    FaireLire "For the REVERSE sequence\n$PABMute $Code\n Please insert 2 spaces to indicate where to cut" 
		    set SeqNucCutted [Entre $SeqNucOriginal]
		    set i1 [string first " " $SeqNucCutted]
		    set i2 [string last  " " $SeqNucCutted]
		    if {$i1==-1 || $i2==-1} {
			if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
			FaireLire "Please insert 2 or 0 spaces"
			continue
		    }
		    set NouveauDebutN [expr $DebNOriginal + $i1]
		    set NouveauFinN   [expr $FinNOriginal - ([string length $SeqNucCutted]-$i2-1)]
		    if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
			FaireLire "You cut to much ... We redo cutting."
			continue
		    }
		    set DebN $NouveauDebutN
		    set FinN $NouveauFinN
		    set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
		    set SeqPro [SeqNucToSeqPro $SeqNuc]
		    regsub -all "." $SeqPro "&  " SeqPro3
		    Espionne "$SeqNuc\n$SeqPro3"
		    break
		}
	    }
	    if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
	    set SeqRaC [NucToReverseAndComplementNuc $SeqNuc]
	    set EnteteRaC "MutOliRac_$AliasCode mutation oligoRac for $PABMute $Alias $Code $DebN $FinN"
	    set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
	    AppendAuFichier $FicOli $TFARaC
	}
    }
    return $FicOli

}

proc CreateOligosForSequencing {FichierOuTexteOliSeq {FicOli ""} {ReverseAussi ""} {SansPremier ""}} {


    set LongueurOliSeq 21
    set LongOptimale  800
    set EcartAutorise  50

    while {! [OuiOuNon "Are following parameters ok ? \n OligoLength $LongueurOliSeq \n Offset between oligos $LongOptimale \n Tolerance $EcartAutorise"]} {
	set LongueurOliSeq [Entre 21]
	set LongOptimale   [Entre 800]
	set EcartAutorise  [Entre 50]
    }

    if {$ReverseAussi==""} {
	set ReverseAussi [Entre "SansReverse"]
    }
    if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
    if {$SansPremier==""} {
	if {[OuiOuNon "Do you want that I REMOVE the Nter and Cter oligos ?"]} {
	    set SansPremier "SansPremier"
	} else {
	    set SansPremier "AvecPremier"
	}
    }
    if {$SansPremier=="SansPremier" || $SansPremier==1 } { set SansPremier 1 } else { set SansPremier 0 }
 
    if {$FichierOuTexteOliSeq==""} { return "" }
    if {[regexp "\n" $FichierOuTexteOliSeq]} {
	if {$FicOli==""} {
	    set FicOli [NomDuFichierDesOligosPourSequencage "./sequencingoligos.tfa"]
	    if {$FicOli==""} { return "" }
	}
	set Texte $FichierOuTexteOliSeq
	set LesOligos {}
	foreach Ligne [split $Texte "\n"] {
	    CreateOligosForSequencing $Ligne $FicOli $ReverseAussi
	}
	return $FicOli
    }
    if { ! [EstUnPAB $FichierOuTexteOliSeq] && ! [regexp " " $FichierOuTexteOliSeq]} {
	set Fichier $FichierOuTexteOliSeq
	if {[file exists $Fichier]} {
	    set FicOli [NomDuFichierDesOligosPourSequencage $Fichier]
	    if {$FicOli==""} { return "" }
	    return [CreateOligosForSequencing [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
	}
	FaireLire "$FichierOuTexteOliSeq\ndoesn't exist. I'll cancel CreateOligosForSequencing"
	return [list "No sequencing oligo for ($FichierOuTexteOliSeq) which doesn't exist"]
    }

    if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourSequencage ""] }
    if {$FicOli==""} { return "" }

    set Ligne $FichierOuTexteOliSeq
    Espionne $Ligne

    if {[regexp "SeqOli" $Ligne]} {
	scan $Ligne "%s %s %s %s %s" Nom bidon Debut Fin Sens
	set TFAs [CreateSeqOli $Nom $Debut $Fin $Sens]
	AppendAuFichier $FicOli $TFAs
	return $FicOli
    }
    Espionne "perdu"
    set D ""
    set F ""
    scan $Ligne "%s %s %s" PAB D F
    set Alias [Alias $PAB]
    if {$Alias==""} { set Alias $PAB }

    set Marge 45
    if {$D=="SeqCheck"} {
	set BornesSeqCheck [LesBornesParSeqCheck $PAB]
	if {$BornesSeqCheck==""} { return "" }
	scan $BornesSeqCheck "%s %d %d" PAB DNuc FNuc
	set DNuc [expr $DNuc -$LongueurOliSeq -$Marge]
	set FNuc [expr $FNuc + $Marge]
	set D [expr ($DNuc-1)/3+1]
	set F [expr $FNuc/3]
	set SansPremier 0
    }
    set FichierNuc "[RepertoireDuGenome]/nuctfa/$PAB"
    if { ! [file exists $FichierNuc]} {
	FaireLire "$FichierNuc\ndoesn't exist. I'll cancel CreateOligosForSequencing for it."
	return [list "No sequencing oligo for ($FichierNuc) which doesn't exist"]
    }
    set LesSitesDeMutation [LesMutantsDe $PAB]
    set LesSitesDeMutationN {}
    foreach Site $LesSitesDeMutation {
	lappend LesSitesDeMutationN [expr ($Site-1)*3 + 1]
    }
    set  ToutSeq [QueLaSequenceDuFichierTFA $FichierNuc]
    set DToutSeqP 1
    set FToutSeqP [expr [string length $ToutSeq]/3]
    if {$D==""} { set D $DToutSeqP }
    if {$F==""} { set F $FToutSeqP }

    Wup "D et F indiquent les bornes en PROTEINE"

    set DN [expr ($D-1)*3 + 1]
    set FN [expr ($F-3)*3 + 1]
    set FinVoulue $FN
    set LongTotale [expr $FN-$DN+1]
    set LongVoulue ""
    while {$LongVoulue==""} {
	if {[expr $LongTotale<($LongOptimale+$EcartAutorise)]} { 
	    set LongVoulue $LongTotale
	    set NombrePossible 1
	    break
	} else {
	    set NombrePossible1 [expr $LongTotale/$LongOptimale]
	    set NombrePossible2 [expr $NombrePossible1+1]
	    set LongPossible1 [expr $LongTotale/$NombrePossible1 + 1]
	    set LongPossible2 [expr $LongTotale/$NombrePossible2 + 1]
	    if {[expr abs($LongOptimale-$LongPossible1)<$EcartAutorise]} {
		set NombrePossible $NombrePossible1
		set LongVoulue $LongPossible1
		break
	    }
	    if {[expr abs($LongOptimale-$LongPossible2)<$EcartAutorise]} {
		set NombrePossible $NombrePossible2
		set LongVoulue $LongPossible2
		break
	    }
	    set LongVoulue [ChoixParmi [list  "$LongPossible1 for $NombrePossible1 oligos"  "$LongPossible2 for $NombrePossible2 oligos"]]
	    if {$LongVoulue==""} { continue }
	    scan $LongVoulue "%d" LongVoulue
	    if {$LongVoulue==$LongPossible1} {
		set NombrePossible $NombrePossible1
	    } else {
		set NombrePossible $NombrePossible2
	    }
	}
    }
    set DOli $DN
    if {$SansPremier} { incr DOli $LongVoulue }
    while { $DOli < $FinVoulue} {
	set DOli3 [expr (($DOli-1)/3)*3 + 1]
	set FOli3 [expr $DOli3+$LongueurOliSeq-1]
	while 1 {
	    set ToucheUneMutation 0
	    foreach Site $LesSitesDeMutationN {
		if {$DOli3<=$Site && $Site<=$FOli3} {
		    set FOli3 [expr $Site-9]
		    set DOli3 [expr $FOli3-$LongueurOliSeq+1]
		    set ToucheUneMutation 1
		    break
		}
	    }
	    if { ! $ToucheUneMutation } { break }
	}
	set SeqOliN [string range "n$ToutSeq" $DOli3 $FOli3]
	set SeqOliP [SeqNucToSeqPro $SeqOliN]
	set DOliP [expr ($DOli3-1)/3 + 1]
	set NomDeLOligo "$Alias-${DOli3}to${FOli3}"
	set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $PAB $Alias $DOli3 to $FOli3"
	set TFA [SequenceFormatTFA $SeqOliN $EnteteOliSeq "brut"]
	Espionne $TFA
	AppendAuFichier $FicOli $TFA

	if {$ReverseAussi} {
	    set SeqRaC [NucToReverseAndComplementNuc $SeqOliN]
	    set EnteteRaC "SeqOliRaC_$NomDeLOligo sequencing oligoRaC for $PAB $Alias $DOli3 to $FOli3"
	    set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
	    AppendAuFichier $FicOli $TFARaC
	}

	incr DOli $LongVoulue
    }
    while {[OuiOuNon "Do you want to verify or remove some sequencing oligos"]} {
	set Nouveau [AfficheFichier $FicOli "AvecRetour"]
	set N [regexp -all {>} $Nouveau]
	if {[OuiOuNon "Do I save these $N oligos in $FicOli?"]} {
	    Sauve $Nouveau dans $FicOli
	    break
	}
    }
    return $FicOli

}

proc CreateOrthologyDatas {reciprocalHitOrthoT putOrthoAnalysedT {noHomologyT ""} {noHitsInT ""}} {

	upvar $reciprocalHitOrthoT reciprocalHitOrtho
	upvar $putOrthoAnalysedT putOrthoAnalysed

	if {$noHomologyT!=""} {upvar $noHomologyT noHomology}
	if {$noHitsInT!=""} {upvar $noHitsInT noHitsIn}
	array set hasOrthology {}

	#ouverture du fichier contenant toutes les proteines avec leur ID
	set FICIN [open "all.csv" "r"]
	while {[gets $FICIN line]!=-1} {
		set infoss [split $line ";"]
		set correspondance([lindex $infoss 1]) [lindex $infoss 0]
	}
	close $FICIN
	
	set FICOUT [open "orthology.csv" "w"] 
	set compteurGroupes 1
	#tab(A,B)= {orga1 orga2} la query A (orga1) a fait best hit reciproque sur le hit B (orga2)
	foreach {key val} [array get reciprocalHitOrtho] {
		set infos [split $key ","]
		puts $FICOUT "$compteurGroupes;[lindex $infos 0];[lindex $infos 1];[lindex $val 0];[lindex $val 1];$correspondance([lindex $infos 0]);$correspondance([lindex $infos 1])"
		set hasOrthology([lindex $infos 0]) 1
		set hasOrthology([lindex $infos 1]) 1
		incr compteurGroupes 
	}
	close $FICOUT
	
	#set FICOUT2 [open "homology.csv" "w"] 
	#set compteurGroupes 1
	#putOrthoAnalysed($queryPAB,$hitPAB) [list $hitNum $countOrga($hitOrga) $hitOrga]
	#foreach {key val} [array get putOrthoAnalysed] {
	#	puts compteurGroupes
	#	set infos [split $key ","]
	#	if {[lindex $putOrthoAnalysed($key) 1]==1} {
	#		puts $FICOUT2 "$compteurGroupes;[lindex $infos 0];[lindex $infos 1];[GetOrga [lindex $infos 0]];[lindex $val 2];$correspondance([lindex $infos 0]);$correspondance([lindex $infos 1])"
	#		incr compteurGroupes 
	#	}
	#}
	#close $FICOUT2

	if {$noHomologyT!=""} {
		set FICOUT3 [open "no_homology_from.csv" "w"] 
		set compteurGroupes 1
		foreach {key val} [array get noHomology] {
			puts $FICOUT3 "$compteurGroupes;$key;[GetOrga $key];$correspondance($key)"
		}
		close $FICOUT3
	}

	if {$noHitsInT!=""} {
		set FICOUT4 [open "no_hits_in_orga.csv" "w"] 
		set compteurGroupes 1
		foreach {key val} [array get noHitsIn] {
			foreach orga $val {
				puts $FICOUT4 "$compteurGroupes;$key;[GetOrga $key];$orga;$correspondance($key)"
				incr compteurGroupes 
			}
		}
		close $FICOUT4
	}

	set FICOUT5 [open "no_orthology.csv" "w"] 
	set compteurGroupes 1
	foreach PAB1 [ListeDesPABs2] {
		if {![info exists hasOrthology($PAB1)]} {
			puts $FICOUT5 "$compteurGroupes;$PAB1;[GetOrga $PAB1];$correspondance($PAB1)"
			incr compteurGroupes 
		}
	}
	close $FICOUT5

}

proc CreatePDBFromDB {} {

    global db HashPDB ListePDB BadPDB Warn

    $db eval {begin transaction}
    set LesPDBs [lsort -unique [$db eval {select name from pdb}]]
    set LNoms [$db eval {select access from seqinfo}]
    $db eval {commit}

    set HashPDB(iHmax) 0
    set BadPDB [list]
    set ListePDB [list]
    set ix -1
    foreach n $LNoms {
	incr ix
	if {! [EstUnAccessPDB $n]} {continue}

	set nom [DonneIdDeAccessPDB $n]
	set chn [DonneChainDeAccessPDB $n]

	if {$nom ni $LesPDBs} {
	    # Mauvais PDB
	    lappend Warn(BadPdb) $nom
	    set Warn($nom) 1
	    lappend BadPDB $ix
	    continue
	}

	set Warn($nom) 0
	if {$nom in [info commands]} {
	    # PDB deja vu, enregistre juste la chaine
	    lappend ListePDB [BonNomPDB ${nom}_$chn]
	    continue
	}

	Structure create $nom
	set cok [$nom new $nom "" 1]
	if {! $cok} {
	    lappend BadPDB $ix
	} else {
	    lappend ListePDB [BonNomPDB ${nom}_$chn]
	    set iH $HashPDB(iHmax)
	    set HashPDB($nom) $iH
	    set HashPDB($iH) $nom
	    incr iH
	    set HashPDB(iHmax) $iH
	}
    }

    return

}

proc CreateParalogyDatas {rapportsInParaT rapportsInParaRejetesT sansRapportsInParaT} {

	upvar $rapportsInParaT rapportsInPara
	upvar $rapportsInParaRejetesT rapportsInParaRejetes
	upvar $sansRapportsInParaT sansRapportsInPara

	#on ne veut pas de doublons dans notre CSV
	array set groupeExistant {}
	#ouverture du fichier contenant toutes les proteines avec leur ID
	set FICIN [open "[RepertoireDuGenome]/all.csv" "r"]
	while {[gets $FICIN line]!=-1} {
		set infoss [split $line ";"]
		set correspondance([lindex $infoss 1]) [lindex $infoss 0]
	}
	close $FICIN

	set FICOUT1 [open "paralogy.csv" "w"] 
	set compteurGroupes 1
	#rapportsInParaValides($celuiDeBase,$listeAAnalyser,$orga) "$countOK/$aTrouver" 
	foreach key [array names rapportsInPara] {
		set infos [split $key ","]
		set PABs [split [lindex $infos 0]]
		set lesIds ""
		foreach PAB $PABs {
			append lesIds "$correspondance($PAB) "
			set PABDansRelation($PAB) 1
		}
		if (![info exists groupeExistant($key)]) {
			puts $FICOUT1 "$compteurGroupes;[GetOrga [lindex $PABs 0]];[lindex $infos 1];$PABs;$lesIds"
			incr compteurGroupes
		}
		#on retient le groupe existant
		set groupeExistant($key) 1
	}
	close $FICOUT1

	set FICOUT2 [open "no_paralogy.csv" "w"] 
	set compteurGroupes 1
	foreach PAB [ListeDesPABs2] {
		if (![info exists PABDansRelation($PAB)]) {
			puts $FICOUT2 "$compteurGroupes;$PAB;[GetOrga $PAB];$correspondance($PAB)"
			incr compteurGroupes
		}
		#on retient le groupe existant
		set groupeExistant($PAB) 1
	}
	close $FICOUT2

	#set FICOUT3 [open "partial_paralogy.csv" "w"] 
	#set compteurGroupes 1

	#foreach {key val} [array get rapportsInParaRejetes] {
	#	set infos [split $key ","]
	#	set PABs [split [lindex $infos 1]]
	#	set proportion [split $val "/"]
	#	set lesIds ""
	#	foreach PAB $PABs {
	#		append lesIds "$correspondance($PAB) "
	#	}
	#	puts $FICOUT3 "$compteurGroupes;[GetOrga [lindex $infos 0]];[lindex $infos 1];[lindex $infos 2];$lesIds;[lindex $proportion 0];[lindex $proportion 1]"
	#	incr compteurGroupes
	#	#on retient le groupe existant
	#}
	#close $FICOUT3


}

proc CreatePdbFromSeqResAndProtName {{Sortie ""}} {

    foreach Acc [PdbSeqRes listof acc] {
	set Tfa [PdbSeqRes $Acc tfa]
	lappend LeTfa $Tfa
    }
    set GrosTfa [join $LeTfa "\n"]
    if {$Sortie==""} {return $GrosTfa }
    return [Sauve $GrosTfa dans $Sortie] 

}

proc CreatePfamFeature {} {

    set csys  "local"
    set score 0.0
    foreach k [array names ::Rpfm "*,feat"] {
	lassign [split $k ,] sqn tmp
	foreach feat $::Rpfm($k) {
	    lassign $feat from to color note
	    lappend TFtmp(${sqn},"PFAM-A") [list fstart $from fstop $to fcolor $color fscore $score fnote $note fcsys $csys]
	}
    }

}

proc CreateProjectDB {} {

    global OPjt db

    set Tbl "
    - files : recap des fichiers presents {
	. pk_files P
	. native_name T
	. nickname T
	. fileroot T
	. tfa I
	. msf I
	. aln I
	. rsf I
	. xml I
	. ord I
    }
    "

    set db [FabriqueDeTables $Tbl root "$OPjt(Dir).opjt"]

    $db eval {begin transaction}
    foreach k [array names OPjt "FType,*"] {
	foreach e {xml tfa msf rsf aln} {
	    set $e 0
	}
	lassign [split $k ,] tmp type
	set $type 1
	foreach fr [set OPjt($k)] {
	    lassign $fr file froot 
	    $db eval {insert into files values (NULL,$file,NULL,$froot,$tfa,$msf,$aln,$rsf,$xml,1)}
	}
    }
    $db eval {commit}
    $db close

    return

}

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 CreateQueryOnly {Fichier NewFichier IdentifiersFile} {

    JeMeSignale
    set LesHeader [LitString ListOf Header $Fichier]
    set LesLignes {}
    lappend LesLignes [join $LesHeader "\t"]
    foreach I [LitString ListOf Index] {
	set PC [LitString $I PIDCop]
	#if { ! [LitString $PC IsRef] } { continue }
	if {[FromStringList $PC $IdentifiersFile]} {
	    set LaLigne {}
	    foreach H $LesHeader {
		lappend LaLigne [LitString $I $H]
	    }
	    lappend LesLignes [join $LaLigne "\t"]
	}
    }
    return [SauveLesLignes $LesLignes dans $NewFichier]

}

proc CreateRandomTfa {{Fichier ""} {N ""}} {

    if {$Fichier==""} { set Fichier "/home/gioalt/arrayagilent_validation/SequenceList/014717_D_SequenceList_20080623.txt" }
    if {$N==""} { set N 5 }
    set LesTFAs {}
    foreach Ligne [ExtractRandomLinesFromFile $Fichier $N "" 3 "" "GetList"] {
	scan $Ligne "%s" Access
	set Seq [regsub "$Access " $Ligne ""]
	set Seq [regsub -all -nocase {[^ATGCN]} $Seq ""]
	set TFA [SequenceFormatTFA $Seq $Access "nucbrut"]
	lappend LesTFAs $TFA
    }
    return [join $LesTFAs "\n"]

}

proc CreateRetinalTargets {} {

    set D 1000
    set PremiereFois 1
    foreach Ligne [LesLignesDuFichier "/genomics/link/EVItest/parser/AttriToutVf"] {
	if {[regexp "^ligne" $Ligne]} {
	    set YaEuLigne 1
	    set NumLigne [IntegerApres "ligne" dans $Ligne]
	    set N [expr $NumLigne*10]
	    continue 
	}
	if { ! [regexp "^>" $Ligne]} {
	    lappend LeTFA $Ligne
	    continue
	}
	if { ! $PremiereFois} {
	    Espionne "Sauve dans $Nom"
	    SauveLesLignes $LeTFA dans "/genomics/link/EVItest/nuctfa/$Nom"
	}
	regsub ">" $Ligne "" Ligne
	if {[regexp "bidon" $Ligne] && ! $YaEuLigne} { FaireLire "Un bidon sans ligne !!!"}
	set YaEuLigne 0
	set I 0
	while 1 {
	    set Nom [format "EVI%5.5d" [expr $N+$I]]
	    if { ! [info exists DejaVu($Nom)]} { break }
	    incr I
	}
	set DejaVu($Nom) 1
	
	set F [expr $D + 3000] 
	set Bornes "$Nom $D $F F"
	incr D 3300
	lappend LesBornes $Bornes
	if {[regexp "^bidon" $Ligne]} {
	    regsub -all {\'} $Ligne " " Ligne
	    set L ">$Nom $Ligne"
	} else {
	    ScanLaListe [split $Ligne "|"] B A A2
	    set Entete [StringSuivant " " dans $Ligne]
	    regsub "genbankfull"   $B "gbf" B
	    regsub "refseqnew"     $B "rsn" B
	    regsub "refseqrelease" $B "rsr" B
	    regsub "refseq" $B "rs" B
	    set L ">$Nom $B:$A $Entete"
	}
	Espionne "\n$L"
	set LeTFA [list $L]
	set PremiereFois 0
	continue
    }
    SauveLesLignes $LeTFA dans "/genomics/link/EVItest/nuctfa/$Nom"
    SauveLesLignes $LesBornes dans "/genomics/link/EVItest/fiches/bornesdespabs"
    exit

}

proc CreateRetinalTargetsPourUnNuc {{Nom ""}} {

    #cree nuctfa et bornesdespabs
    set BlastNDataBase "refseq-rel-rna-mouse"
    set RepertoireBlastn "[RepertoireDuGenome]/blastn"
    if {! [file exists $RepertoireBlastn]} {file mkdir $RepertoireBlastn}
    set FichierBlast "$RepertoireBlastn/$Nom"
    set FichierTFA   "[RepertoireDuGenome]/depotweb/$Nom"

    set CommandeBlast "blastall  -p blastn  -i $FichierTFA  -o $FichierBlast  -d $BlastNDataBase  -v 500  -K 0  -b 500  -e 10.0  -F T  -a 1"
    if {[catch {eval exec $CommandeBlast} Message]} {
	Espionne "Problem with $FichierBlast"
	Espionne $Message
    }

    set NbSujet [AskBlast $FichierBlast NbSubject]
    #Espionne "NbSujet $NbSujet"
    if {$NbSujet==0} {
	Espionne "pas de subject"
    }    
    set BId       [AskBlast $FichierBlast Subject 1]
    #Espionne "BId $BId"
    set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment]
    #Espionne "NbSegment $NbSegment"
    set LesLignesFinales {}
    #set PId [AskBlast $FichierBlast BanqueId $BId Segment 1 Identities]
    #set Gap [AskBlast $FichierBlast BanqueId $BId Segment 1 Gaps]
    set Exp [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect]
    #regexp {([0-9]+)/([0-9]+) (\([0-9]+%\))} $PId Tmp nbId nbTot Pourcentage
    #regsub -all {\(} $Pourcentage "" Pourcentage
    #regsub -all {\)} $Pourcentage "" Pourcentage
    #regsub % $Pourcentage "" Pourcentage

    #Espionne "PId $PId"
    #Espionne "++$nbId $nbTot $Pourcentage"
    #Espionne "Gap $Gap"
    #Espionne "Expect $Exp"
    #Espionne "$nbTot $Pourcentage $Exp $Gap"
    set RepertoireNuctfa "[RepertoireDuGenome]/nuctfa"
    if {$Exp<=1.e-118} {
	set Access [lindex [split $BId ":"] 1]
	#Espionne "Access $Access"
	set Commande "getz \"\\\[refseq-acc:$Access\\\]\" \-view FastaSeqs" 
	set GetzOut [eval exec $Commande]
	#Espionne $GetzOut
	
	set LesLignesDeGetzOut [split $GetzOut "\n"]
	foreach Ligne $LesLignesDeGetzOut {
	    if {[regexp ">" $Ligne ]} {
		set Entete [StringSuivant " " dans $Ligne]
		ScanLaListe [split $Ligne "|"] B A A2
		regsub ">" $B "" B
		regsub "genbankfull"   $B "gbf" B
		regsub "refseqnew"     $B "rsn" B
		regsub "refseqrelease" $B "rsr" B
		regsub "refseq" $B "rs" B
		set L ">$Nom $B:$A $Entete"
		lappend LesL $L
	    } else {
		lappend LesL $Ligne
	    }
	}
	SauveLesLignes $LesL dans "$RepertoireNuctfa/$Nom"
    } else {
	set LesLignesDuTFA [LesLignesDuFichier $FichierTFA]
	set premiereligne [lindex $LesLignesDuTFA 0]
	if {[regexp ">" $premiereligne]} {
	    set Entete [StringSuivant " " dans $premiereligne]
	    ScanLaListe [split $premiereligne "|"] B A A2
	    regsub ">" $B "" B
	    regsub "genbankfull"   $B "gbf" B
	    regsub "refseqnew"     $B "rsn" B
	    regsub "refseqrelease" $B "rsr" B
	    regsub "refseq" $B "rs" B
	    set L ">$Nom Morceau $B:$A $Entete"
	    lappend LesL $L
	} else {
	    set L ">$Nom Morceau"
	    lappend LesL $L
	}
	foreach Ligne $LesLignesDuTFA {
	    if {[regexp ">" $Ligne ]} {continue} else {lappend LesL $Ligne}
	}
	SauveLesLignes $LesL dans "$RepertoireNuctfa/$Nom"
    }

}

proc CreateRetinalTargetsPourUnOld {{FichierTFA ""}} {

    #cree nuctfa et bornesdespabs
    set BlastNDataBase "refseq-rel-rna-mouse"
    set RepertoireBlastn "[RepertoireDuGenome]/blastn"
    if {! [file exists $RepertoireBlastn]} {file mkdir $RepertoireBlastn}

    set FichierBlast "$RepertoireBlastn/SequenceInconnue"
    set CommandeBlast "blastall  -p blastn  -i \$FichierTFA  -o \$FichierBlast  -d $BlastNDataBase  -v 500  -K 0  -b 500  -e 10.0  -F T  -a 1"
    if {[catch {eval exec $CommandeBlast} Message]} {
	Espionne "Problem with $FichierBlast"
	Espionne $Message
    }

    set NbSujet [AskBlast $FichierBlast NbSubject]
    #Espionne "NbSujet $NbSujet"
    if {$NbSujet==0} {
	Espionne "pas de subject"
    }    
    set BId       [AskBlast $FichierBlast Subject 1]
    #Espionne "BId $BId"
    set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment]
    #Espionne "NbSegment $NbSegment"
    set LesLignesFinales {}
    set PId [AskBlast $FichierBlast BanqueId $BId Segment 1 Identities]
    set Gap [AskBlast $FichierBlast BanqueId $BId Segment 1 Gaps]
    set Exp [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect]
    regexp {([0-9]+)/([0-9]+) (\([0-9]+%\))} $PId Tmp nbId nbTot Pourcentage
    regsub -all {\(} $Pourcentage "" Pourcentage
    regsub -all {\)} $Pourcentage "" Pourcentage
    regsub % $Pourcentage "" Pourcentage
    #Espionne "PId $PId"
    #Espionne "++$nbId $nbTot $Pourcentage"
    #Espionne "Gap $Gap"
    #Espionne "Expect $Exp"
    #Espionne "$nbTot $Pourcentage $Exp $Gap"

    if {$Exp<=1.e-118} {
	set Access [lindex [split $BId ":"] 1]
	Espionne "Access $Access"
	set Commande "getz \"\\\[refseq-acc:$Access\\\]\" \-view FastaSeqs" 
	set GetzOut [eval exec $Commande]
	#Espionne $GetzOut

	set RepertoireNuctfa "[RepertoireDuGenome]/nuctfa"
	set FichierPAB "[RepertoireDuGenome]/fiches/bornesdespabs"
	
	if { ! [file exists "$RepertoireNuctfa"]} {
	    File mkdir $RepertoireNuctfa
	    set Nom [format "GGW%5.5d" 1]
	    set D 1000
	    set F [expr $D + 3000] 
	    set Bornes "$Nom $D $F F"
	} else {
	    set LesLignesPabs [LesLignesDuFichier $FichierPAB]
	    set LongPab [llength $LesLignesPabs]
	    set DernierPAB [lindex $LesLignesPabs [expr $LongPab -1]]
	    ScanLaListe [split $DernierPAB " "] DernierNom DernierD DernierFin bidon
	    set D [incr DernierD 3300]
	    set F [expr $DernierD + 3000]
	    set Chiffre [string range $DernierNom 3 end]
	    if {[string index $Chiffre 0] == 0} {
		set Chiffre [string range $Chiffre 1 end]
		if {[string index $Chiffre 0] == 0} {
		    set Chiffre [string range $Chiffre 1 end]
		    if {[string index $Chiffre 0] == 0} {
			set Chiffre [string range $Chiffre 1 end]
			if {[string index $Chiffre 0] == 0} {
			    set Chiffre [string range $Chiffre  1 end]
			}
		    }
		}
	    }    
	    set Nom [format "GGW%5.5d" [expr $Chiffre + 1 ]]
	    set Bornes "$Nom $D $F F" 
	}
	set LesLignesDeGetzOut [split $GetzOut "\n"]
	foreach Ligne $LesLignesDeGetzOut {
	    if {[regexp ">" $Ligne ]} {
		set Entete [StringSuivant " " dans $Ligne]
		ScanLaListe [split $Ligne "|"] B A A2
		regsub ">" $B "" B
		regsub "genbankfull"   $B "gbf" B
		regsub "refseqnew"     $B "rsn" B
		regsub "refseqrelease" $B "rsr" B
		regsub "refseq" $B "rs" B
		set L ">$Nom $B:$A $Entete"
		lappend LesL $L
	    } else {
		lappend LesL $Ligne
	    }
	}
	file rename -force $RepertoireBlastn/SequenceInconnue $RepertoireBlastn/$Nom
	AppendAuFichier $FichierPAB $Bornes
	SauveLesLignes $LesL dans "$RepertoireNuctfa/$Nom"
	return $Nom
    }

}

proc CreateRetinalTargetsPourUneProt {{Nom ""}} {

    #cree nuctfa et bornesdespabs
    set BlastNDataBase "protein"
    set RepertoireBlastpOri "[RepertoireDuGenome]/blastpOri"
    if {! [file exists $RepertoireBlastpOri]} {file mkdir $RepertoireBlastpOri}
    set FichierBlastpOri "$RepertoireBlastpOri/$Nom"
    set FichierTFA   "[RepertoireDuGenome]/depotweb/$Nom"

    set CommandeBlast "blastall  -p blastp  -i $FichierTFA  -o $FichierBlastpOri  -d $BlastNDataBase  -v 500  -K 0  -b 500  -e 10.0  -F T  -a 1"
    if {[catch {eval exec $CommandeBlast} Message]} {
	Espionne "Problem with $FichierBlastpOri"
	Espionne $Message
    }

    set NbSujet [AskBlast $FichierBlastpOri NbSubject]
    #Espionne "NbSujet $NbSujet"
    if {$NbSujet==0} {
	Espionne "pas de subject"
    }    
    set BId       [AskBlast $FichierBlastpOri Subject 1]
    #Espionne "BId $BId"
    set NbSegment [AskBlast $FichierBlastpOri BanqueId $BId NbSegment]
    #Espionne "NbSegment $NbSegment"
    set LesLignesFinales {}
    set PId [AskBlast $FichierBlastpOri BanqueId $BId Segment 1 Identities]
    set Gap [AskBlast $FichierBlastpOri BanqueId $BId Segment 1 Gaps]
    set Exp [AskBlast $FichierBlastpOri BanqueId $BId Segment 1 Expect]
    regexp {([0-9]+)/([0-9]+) (\([0-9]+%\))} $PId Tmp nbId nbTot Pourcentage
    regsub -all {\(} $Pourcentage "" Pourcentage
    regsub -all {\)} $Pourcentage "" Pourcentage
    regsub % $Pourcentage "" Pourcentage

    #Espionne "PId $PId"
    #Espionne "++$nbId $nbTot $Pourcentage"
    #Espionne "Gap $Gap"
    #Espionne "Expect $Exp"
    #Espionne "$nbTot $Pourcentage $Exp $Gap"
    set RepertoireProttfa "[RepertoireDuGenome]/prottfa"
    if {$Exp<=1.e-118} {
	Espionne "entre 1"
	set Access [AskBlast $FichierBlastpOri BanqueId $BId Access]
	#Espionne "Access $Access"
	set Commande "getz \"\\\[protein-acc:$Access\\\]\" \-view FastaSeqs" 
	set GetzOut [eval exec $Commande]
	#Espionne "lasequence $GetzOut"
	
	set LesLignesDeGetzOut [split $GetzOut "\n"]
	foreach Ligne $LesLignesDeGetzOut {
	    if {[regexp ">" $Ligne ]} {
		set Entete [StringSuivant " " dans $Ligne]
		ScanLaListe [split $Ligne "|"] B A A2
		set L ">$Nom $A from $A2 $Entete"
		lappend LesL $L
	    } else {
		lappend LesL $Ligne
	    }
	}
	SauveLesLignes $LesL dans "$RepertoireProttfa/$Nom"
	set LesLignesEMBL [LaSequenceDesBanques protein $A "OnVeutEMBL"]
	if {$LesLignesEMBL == {}} { continue }
	set FichierEMBL "[GscopeFile $Nom protembl]"
	SauveLesLignes $LesLignesEMBL dans $FichierEMBL
    } else {
	set LesLignes [LesLignesDuFichier $FichierTFA]
	set premiereligne [lindex $LesLignes 0]
	if {[regexp ">" $premiereligne ]} {
	    set Entete [StringSuivant " " dans $premiereligne]
	    ScanLaListe [split $premiereligne "|"] B A A2
	    set L ">$Nom Morceau $A from $A2 $Entete"
	    lappend LesL $L

	    SauveLesLignes $LesL dans "$RepertoireProttfa/$Nom"
	    set LesLignesEMBL [LaSequenceDesBanques protein $A "OnVeutEMBL"]
	    if {$LesLignesEMBL == {}} { continue }
	    set FichierEMBL "[GscopeFile $Nom protembl]"
	    SauveLesLignes $LesLignesEMBL dans $FichierEMBL
	} else {
	    set L ">$Nom Morceau"
	    lappend LesL $L
	}
	foreach Ligne [LesLignesDuFichier $FichierTFA] {
	    if {[regexp ">" $Ligne ]} {continue} else {lappend LesL $Ligne}
	}
	SauveLesLignes $LesL dans "$RepertoireProttfa/$Nom"
    }

}

proc CreateRichAndPoor {FichierParser {FichierString ""} {FichierRich ""} {FichierPoor ""}} {


    set DirName [file dirname $FichierParser]
    set Titre [file tail $DirName]

    if {$FichierString==""} {
	set Fichierstring "$DirName/WithAny.string"
    }
    if {$FichierRich==""} {
	set FichierRich $FichierString
	regsub {\.[^\.]+} $FichierRich "" FichierRich
	append FichierRich ".string"
    }
    if {$FichierPoor==""} {
	set FichierPoor $FichierString
	regsub {\.[^\.]+} $FichierPoor "" FichierPoor
	append FichierPoor ".string"
    }

    foreach Ligne [LesLignesDuFichier $FichierParser] {
	set L [split $Ligne "\t"]
	lassign $L IdString GeneName A R P Copains
	lappend LL $L 
    }
    set LLT [lsort -index 2 -integer -decreasing $LL]
    set LesA {}
    set TotalA 0
    set nNonNuls 0
    foreach L $LLT {
	set A [lindex $L 2]
	lappend LesA $A
	if {1<$A} {
	    incr TotalA $A
	    incr nNonNuls
	}
    }

    set N [llength $LesA]
    set Moyenne       [expr ($TotalA)/$N]
    set MilieuNonNuls [expr ($TotalA)/$nNonNuls]
    Espionne $LesA
    set K [Graphe $LesA "" "" "" "" "" "" "" $Titre]
    Graphe [list 0 [expr $N-1]] [list $Moyenne $Moyenne] $K
    Graphe [list 0 [expr $N/2]] [list $MilieuNonNuls $MilieuNonNuls] $K
    if {$FichierString=="GetDistribution"} { return $K }
    exit

    set LesHeader [LitString ListOf Header $FichierString]
    set LesLignes {}
    lappend LesLignes [join $LesHeader "\t"]
    foreach I [LitString ListOf Index] {
	set PC [LitString $I PIDCop]
	if {[LitString $PC IsRef]} { 
	    set LaLigne {}
	    foreach H $LesHeader {
		lappend LaLigne [LitString $I $H]
	    }
	    lappend LesLignes [join $LaLigne "\t"]
	} else {
	    set LaLigne {}
	    set LesInitialsduPC [LitString $PC ListOfRef]
	    if {[llength $LesInitialsduPC]>1} {
		foreach H $LesHeader {
		    lappend LaLigne [LitString $I $H]
		}
		lappend LesLignes [join $LaLigne "\t"]
	    }
	}
    }
    return [SauveLesLignes $LesLignes dans $NewFichier]

}

proc CreateSAGE2016 {} {

    set UID 3875
    set GID 3016
    set Hash [exec slappasswd -h "{SSHA}" -s 16sages]
    set LesInfos {}
    set LeLdap {}
    set Rep "/maison/sage2016"
    foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/SAGE2016/SAGE2016.txt"] {
	regsub -all {[ \t]+} $Ligne " " Ligne
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	set L ""
	lassign [split $Ligne " "] N P Id M L
	if {$L==""} { set L [string tolower $N] }
	set N [string toupper $N]
	set Info "$L $P $N $UID $GID /home/$L"
	Espionne $Info
	if {[file exists "/home/$L"]} {
	    if {[OuiOuNon "On a déjà /home/$L\nJe garde l'ancien [file readlink /home/$L] ?"]} { incr UID ; continue }
	} 
	if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
	    set Maison "$Rep/$L"
	    file mkdir $Rep
	    file mkdir $Maison
	    exec chown $UID:$GID $Maison
	    NousAllonsAuBoulot /home
	    exec ln -s $Maison
	    Espionne [exec ls -l /home/$L]
	    OnRevientDuBoulot
	}
	lappend LesInfos $Info
	lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
	lappend LeLdap "objectClass: inetOrgPerson"
	lappend LeLdap "objectClass: posixAccount"
	lappend LeLdap "cn: $L"
	lappend LeLdap "sn: $N"
	lappend LeLdap "givenName: $P"
	lappend LeLdap "homeDirectory: /home/$L"
	lappend LeLdap "loginShell: /usr/bin/tcsh"
	lappend LeLdap "uidNumber: $UID"
	lappend LeLdap "gidNumber: $GID"
	lappend LeLdap "userPassword: $Hash"
	lappend LeLdap ""
	incr UID
    }
    SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/SAGE2016/ToutPourSAGE2016.txt"
    set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/SAGE2016/LdapPourSAGE2016.txt"]
    return $FichierLdap

}

proc CreateSandwich {Fichier NewFichier IdentifiersFile {NbInteractant ""}} {

    JeMeSignale
    if {$NbInteractant == ""} {set NbInteractant 1}
    set LesHeader [LitString ListOf Header $Fichier]
    set LesLignes {}
    lappend LesLignes [join $LesHeader "\t"]
    foreach I [LitString ListOf Index] {
	set PC [LitString $I PIDCop]
	set PI [LitString $I PIDInitial]
	#if {[LitString $PC IsRef]}
	if {[FromStringList $PC $IdentifiersFile]} {
	    set LaLigne {}
	    foreach H $LesHeader {
		lappend LaLigne [LitString $I $H]
	    }
	    lappend LesLignes [join $LaLigne "\t"]
	} else {
	    set LaLigne {}
	    set LesInitialsduPC [LitString $PC ListOfRef]
	    if {[llength $LesInitialsduPC]>$NbInteractant} {
		foreach H $LesHeader {
		    lappend LaLigne [LitString $I $H]
		}
		lappend LesLignes [join $LaLigne "\t"]
	    }
	}
    }
    return [SauveLesLignes $LesLignes dans $NewFichier]

}

proc CreateSeqOli {Nom Debut Fin {Sens ""} {FicOli ""}} {

    if {$Sens==""} { set Sens "FR" }

    set LesTFAs {}

    set Alias [Alias $Nom]
    set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
    set SeqOliF [string range "n$Seq" $Debut $Fin]
    set SeqOliR [NucToReverseAndComplementNuc $SeqOliF]
    set NomDeLOligo "$Alias-${Debut}to${Fin}"
    if {[regexp -nocase "F" $Sens]} {
	set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $Nom $Alias $Debut to $Fin"
	set TFA [SequenceFormatTFA $SeqOliF $EnteteOliSeq "brut"]
	lappend LesTFAs $TFA
    }
    if {[regexp -nocase "R" $Sens]} {
	set EnteteOliSeqRac "SeqOliRaC_$NomDeLOligo reverse sequencing oligo for $Nom $Alias $Debut to $Fin"
	set TFA [SequenceFormatTFA $SeqOliR $EnteteOliSeqRac "brut"]
	lappend LesTFAs $TFA
    }
    return [join $LesTFAs "\n"]

}

proc CreateSpineXML {{Selection ""} {FichierSpineXML ""}} {



    CreateTargetId "Reset"

    if {$FichierSpineXML==""} {
	set FichierSpineXML "[RepXbgs]/SpineTargetsP10.xml"
    }

    if {$Selection=="Show"} {
	return [AfficheFichier $FichierSpineXML]
    } 

    if {$Selection==""} {
	set Selection [SpineSummary "RetourneTexte"]
    }

    set LesLignes [split $Selection "\n"]

    lappend lXML ""
    lappend lXML ""

    lappend lXML ""
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	OneToSpine $Ligne lXML
    }
    lappend lXML ""
    if {$Selection=="Show"} {
	return [AfficheVariable [join $lXML "\n"] "" "XML_for_Spine"]
    } 

    if { ! [OuiOuNon "Ok to create a new $FichierSpineXML"]} { return "" } 

    regsub ".xml$" $FichierSpineXML "[Date].xml" FichierSpineXMLDate
            SauveLesLignes $lXML dans $FichierSpineXML
    return [SauveLesLignes $lXML dans $FichierSpineXMLDate]

}

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 CreateSqlFromChildOfAlignment {Noeud PkMacsims} {

    global PosInAln
    global CommandeAFaireApres

    if { ! [info exists PosInAln]} { set PosInAln 0 }
    incr PosInAln

    set NodeName [$Noeud nodeName]
    set NodeName [string tolower $NodeName]

    if {[IsColsConsFreeSurf $NodeName]} {
	return [CreateSqlFromNodeColsConsFreeSurf $Noeud $NodeName $PkMacsims $PosInAln]
    }

    if {[NodeSequence $NodeName]} {
	return [CreateSqlFromNodeSequence $Noeud $NodeName $PkMacsims $PosInAln]
    }

    FaireLire "Unknown nodename $NodeName"
    return ""

}

proc CreateSqlFromNodeColsConsFreeSurf {Noeud NodeName PkMacsims PosInAln} {

    global CommandeAFaireApres

    set NomSql [MacsimsCodification "Sql" $NodeName]
    set NomXml [MacsimsCodification "Xml" $NodeName]
    
    set Name  [$Noeud selectNodes "string($NomXml-name)"]
    set Owner [$Noeud selectNodes "string($NomXml-owner)"]
    set Type  [$Noeud selectNodes "string($NomXml-type)"]
    set Data  [$Noeud selectNodes "string($NomXml-data)"]
    
#   if {[OuiOuNonMemo "je stoppe encore ici"]} {}
    if {$Owner==""} { set Owner "all" }
    if {[regexp {^[0-9]+$} $Owner]} {
	set Owner "group_$Owner"
    }

    set PkTable [SqlInsertRecordIntoTable $NomSql  NAME  $Name  TYPE  $Type  DATA  $Data  POSINALN $PosInAln]
    
    if {$Owner==0 || [string equal -nocase "all" $Owner]} {
	set Status [SqlInsertOnceRecordIntoTable "LN_MACSIMS_$NomSql"  PK_MACSIMS  $PkMacsims  PK_$NomSql $PkTable]
	return $Status
    }
    if {[regexp {^group_[0-9]+$} $Owner]} {
	set ClustName [ClustName $Owner]
	set Query "select PK_CLUST from CLUST  where PK_MACSIMS=$PkMacsims and NAME='$ClustName'"
	set PkClust [SqlExec $Query "GetFirstValue"]
	if {$PkClust==""} {
	    set PkClust [SqlInsertRecordIntoTable CLUST  PK_MACSIMS $PkMacsims  NAME     $ClustName ]
	}
	set Status [SqlInsertOnceRecordIntoTable "LN_CLUST_$NomSql"  PK_CLUST   $PkClust  PK_$NomSql $PkTable]
	return $Status
    }
    #rR owner = seqname   
    set Query "select PK_SEQ from SEQ  where PK_MACSIMS=$PkMacsims and NAME='$Owner'"
    set PkSeq [SqlExec $Query "GetFirstValue"]
    set CommandeAFaire "SqlInsertOnceRecordIntoTable LN_SEQ_$NomSql  PK_SEQ      \[set PkSeq\]  PK_$NomSql  $PkTable"
    if {$PkSeq!=""} {
	set Status [eval $CommandeAFaire]
	return $Status
    } else {
	set Clef "SEQ,$PkMacsims,$Owner"
	lappend CommandeAFaireApres($Clef) $CommandeAFaire
#	Espionne "lappend CommandeAFaireApres($Clef) $CommandeAFaire"
	set Status "DefferedCommand $Clef"
	return $Status
    }	    

}

proc CreateSqlFromNodeSequence {Noeud NodeName PkMacsims PosInAln} {

    set NoeudSeqAli $Noeud
    set SeqName [$NoeudSeqAli selectNodes "string(seq-name)"]
    set SeqData [$NoeudSeqAli selectNodes "string(seq-data)"]
    regsub -all -nocase {[^\.\-A-Z]} $SeqData "" SeqData
    regsub -all -nocase {[^A-Z]} $SeqData "" SeqDataNoGap

    set Type "Protein"

    set PkSeq [SqlInsertRecordIntoTable "SEQ"  PK_MACSIMS $PkMacsims  NAME       $SeqName  TYPE       $Type  DATA       $SeqData  DATANOGAP  $SeqDataNoGap  POSINALN   $PosInAln]
    set Clef "SEQ,$PkMacsims,$SeqName"
    if {[info exists CommandeAFaireApres($Clef)]} {
	foreach CommandeAFaire $CommandeAFaireApres($Clef) {
	    eval $CommandeAFaire
	}
	unset CommandeAFaireApres($Clef)
    }

    set NoeudInfos  [$NoeudSeqAli selectNodes "seq-info"]

    foreach NoeudInfo [$NoeudInfos childNodes] {
	set NodeName [$NoeudInfo nodeName]

	if {$NodeName=="accession"} {
	    set DbName ""
	    set Accession [$NoeudInfo selectNodes "string()"]
	    set PkExtDbEntry [ValeurPk [SqlInsertOnceRecordIntoTable "EXTDBENTRY"  DBNAME $DbName  VALUE $Accession]]
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_EXTDBENTRY"  PK_SEQ $PkSeq  PK_EXTDBENTRY $PkExtDbEntry]
	    continue
	}
	if {$NodeName=="organism"} {
	    set GenreEspece [$NoeudInfo selectNodes "string()"]
	    regsub {\.} $GenreEspece " " GenreEspece
	    set Genre ""
	    set Espece ""
	    scan $GenreEspece "%s %s" Genre Espece
	    set PkTaxonomy [SqlExec "select PK_TAXONOMY from TAXONOMY  where name like '$Genre $Espece'" "GetFirstValue"]
	    if {$PkTaxonomy==""} { continue } 
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_TAXONOMY"  PK_SEQ $PkSeq  PK_TAXONOMY $PkTaxonomy]
	    continue
	}
	if {$NodeName=="taxid"} {
	    set TaxId [$NoeudInfo selectNodes "string()"]
	    set PkTaxonomy [SqlExec "select PK_TAXONOMY from TAXONOMY where PK_TAXONOMY=$TaxId" "GetFirstValue"]
	    if {$PkTaxonomy==""} { continue } 
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_TAXONOMY"  PK_SEQ $PkSeq  PK_TAXONOMY $PkTaxonomy]
	    continue
	}
	if {$NodeName=="keywordlist"} {
	    foreach NoeudKeywordList [$NoeudInfo selectNodes "string(keywordlist)"] {
		foreach NoeudKeyword [$NoeudKeywordList childNodes] {
		    set Keyword [$NoeudKeyword selectNodes "string()"]
		    set PkKeyword [ValeurPk [SqlInsertOnceRecordIntoTable "KEYWORD"  VALUE $Keyword]]
		    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_KEYWORD"  PK_SEQ $PkSeq  PK_KEYWORD $PkKeyword]
		    continue		    
		}
	    }
	    continue
	}
	if {$NodeName=="goxreflist"} {
	    foreach NoeudGoxrefList [$NoeudInfo selectNodes "string(goxreflist)"] {
		foreach NoeudGoxref [$NoeudGoxrefList childNodes] {
		    set GoId       [$NoeudGoxref selectNodes "string(goid)"]
		    set GoClass    [$NoeudGoxref selectNodes "string(goclass)"]
		    set GoDesc     [$NoeudGoxref selectNodes "string(godesc)"]
		    set GoEvidence [$NoeudGoxref selectNodes "string(goevidence)"]
		    set PkGoxref [ValeurPk [SqlInsertOnceRecordIntoTable "GOXREF"  GOID $GoId  GOCLASS $GoClass  GODESC $GoDesc  GOEVIDENCE $GoEvidence ]
		    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_GOXREF"  PK_SEQ $PkSeq  PK_GOXREF $PkGoxref]
		    continue
		}
	    }
	    continue
	}

	if {$NodeName=="ftable"} {
	    set NoeudFtable $NoeudInfo
	    foreach NoeudFitem [$NoeudFtable selectNodes "fitem"] {
		set Ftype  [$NoeudFitem selectNodes "string(ftype)"]
		set Fstart [$NoeudFitem selectNodes "string(fstart)"]
		set Fstop  [$NoeudFitem selectNodes "string(fstop)"]
		set Fcolor [$NoeudFitem selectNodes "string(fcolor)"]
		set Fscore [$NoeudFitem selectNodes "string(fscore)"]
		set Fnote  [$NoeudFitem selectNodes "string(fnote)"]
		set Status [SqlInsertRecordIntoTable SEQFEATURE  PK_SEQ      $PkSeq  FTYPE       $Ftype  FSTART      $Fstart  FSTOP       $Fstop  FCOLOR      $Fcolor  FSCORE      $Fscore  FNOTE       $Fnote  FSTATUS     $Status ]
	    }
	    continue
	}
	if {$NodeName=="lineage"} {
	    set LesTaxons {}
	    foreach NoeudTaxon [$NoeudInfo childNodes] {
		set Taxon [$NoeudTaxon selectNodes "string()"]
		lappend LesTaxons $Taxon
	    }
	    set Lineage [join $LesTaxons "; "]
	    set PkInfo [SqlInsertRecordIntoTable SEQINFO  PK_SEQ $PkSeq  TYPE   "lineage"  VALUE  $Lineage]
	    continue
	}
	

	set Info [$NoeudInfo selectNodes "string()"]
	set PkInfo [SqlInsertRecordIntoTable SEQINFO  PK_SEQ $PkSeq  TYPE   $NodeName  VALUE  $Info]

	if {$NodeName=="group"} {
	    set G $Info
	    set ClustName "group_$G"
	    set PkClust [ValeurPk [SqlInsertOnceRecordIntoTable "CLUST"  PK_MACSIMS $PkMacsims  NAME       $ClustName]]
	    SqlExec "update SEQ set PK_CLUST=$PkClust where PK_SEQ=$PkSeq" 
	}
	continue 
    }

}

proc CreateSqlFromXmlMacsims {NomOuFichier {FichierSql ""}} {


    package require tdom

    CanalSqlMacsims

    set Nom [file tail $NomOuFichier]
    while 1 {
	set FichierXml $NomOuFichier
	if {[regexp "/" $FichierXml]} { break }
	if { ! [EstUnPAB $Nom]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
	if {[file exists $FichierXml]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom.xml"
	if {[file exists $FichierXml]} { break }
	return ""
    }

    if {$FichierSql=="macsimSql"} {
	if {[regexp "/macsimXml/" $FichierXml]} {
	     regsub "/macsimXml/" $FichierXml "/macsimSql/" FichierSql
	} else {
	    set FichierSql $FichierXml
	}
	regsub ".xml$" $FichierSql "" FichierSql
	append FichierSql ".sql"
	set RepSql [file dirname $FichierSql]
	if {[DirAbsent $RepSql]} {file mkdir $RepSql}
    }
#    if {[FileExists $FichierSql]} { file delete $FichierSql }
    set FichierSql [LogInsUpDelPourExec "InFile" $FichierSql]

    set MacsimsXml [ContenuDuFichier $FichierXml]
    set NoeudMacsims [[dom parse $MacsimsXml] documentElement]


    set NoeudAli [$NoeudMacsims selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
    set AlnNote  [$NoeudAli selectNodes "string(aln-note)"]

    set LeFreetext [list "Macsims sql database created by Gscope [Date NiceSeconds]"]
    if {[OnTraiteSpine]} {
	set GscopeID  $Nom
	set SpineID   [ExtraitInfo $Nom "SpineID"]
	set SpineRef  [ExtraitInfo $Nom "SpineRef"]
	set SpineDef  [ExtraitInfo $Nom "SpineDef"]
	set SpineHRef [H_Href $SpineRef [WgetzSurWeb $SpineRef "" "GetUrl"]]

	lappend LeFreetext "GscopeID $GscopeID"
	lappend LeFreetext "Alias [Alias $Nom]"
	lappend LeFreetext "SpineID $SpineID"
	lappend LeFreetext "SpineRef $SpineRef"
	lappend LeFreetext "SpineDef $SpineDef"
	lappend LeFreetext "SpineHRef $SpineHRef"
    }
    set Freetext [join $LeFreetext "\n"]

    set TexteMsf    ""
    set TexteMacsims $FichierXml
    set PkMacsims [SqlInsertOnceRecordIntoTable "+MACSIMS"  NAME $AlnName  SCORE $AlnScore  NOTE $AlnNote  MSF $TexteMsf  MACSIMSXML $TexteMacsims]
    set AlreadyExists [regexp "already exists" $PkMacsims]

    scan $PkMacsims "%d" PkMacsims
    if {$AlreadyExists} {
	if {1 || [OuiOuNon "macsims $PkMacsims already exists. Do I skip it other information ?"]} {
	    LogInsUpDelPourExec "CloseFile"
	    return $FichierSql
	}
    } else {
	set GoodFreetext [QuoteEtBackslashPourSql $Freetext]
	SqlExec "update macsims set freetext='$GoodFreetext' where pk_macsims=$PkMacsims;"    
    }
    foreach NoeudLigne [$NoeudAli childNodes] {
	set NodeName [$NoeudLigne nodeName]
	if {[regexp {aln\-} $NodeName]} { continue }
	CreateSqlFromChildOfAlignment $NoeudLigne $PkMacsims
    }
    LogInsUpDelPourExec "CloseFile"
    return $FichierSql

}

proc CreateSqlFromXmlMacsimsFromDirectory {{Dir ""} {Ext ""}} {

    
    if {$Ext==""} { set Ext ".xml" }
    if {$Dir==""} { set Dir [ChoixDuRepertoire] }

    CanalSqlMacsims

#   CreateDirIfAbsent [GscopeSubDir "macsimSql"]
    foreach File [glob -nocomplain "$Dir/*$Ext"] {
	Espionne $File
	regsub "$Ext" $File "" FichierSql
	append FichierSql ".sql"
	set FichierSql "/dev/null"
#	if {[FileExists $FichierSql]} { Espionne "$FichierSql already exists" ; continue }
	set FichierXml $File
	if {[FileAbsent $FichierXml]} { Espionne "$FichierXml doesn't exist" ; continue }
	set Status [CreateSqlFromXmlMacsims $FichierXml $FichierSql]
    }

}

proc CreateSqlFromXmlMacsimsPourTous {} {

    
    CanalSqlMacsims

    CreateDirIfAbsent [GscopeSubDir "macsimSql"]
    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set FichierSql [GscopeFile $Nom "macsimSql"]
#	if {[FileExists $FichierSql]} { Espionne "$FichierSql already exists" ; continue }
	set FichierXml [GscopeFile $Nom "macsimXml"]
	if {[FileAbsent $FichierXml]} { Espionne "$FichierXml doesn't exist" ; continue }
	set Status [CreateSqlFromXmlMacsims $FichierXml $FichierSql]
    }

}

proc CreateSqlTaxonomy {} {

    
    set LesTaxId [lsort -integer [TaxNCBI List TaxId]]
    foreach TaxId $LesTaxId {
	set Name   [TaxNCBI $TaxId "Name"]
	set Parent [TaxNCBI $TaxId "Parent"]
	Espionne "$TaxId $Name"
	if {$Name==""} { continue }

	if {[info exists NameDejaVu($TaxId)]} {
	    FaireLire "DejaVu $TaxId $NameDejaVu($TaxId)"
	}
	if {0 && [info exists TaxIdDejaVu($Name)]} {
	    FaireLire "DejaVu $Name $TaxIdDejaVu($Name)"
	}
	set NameDejaVu($TaxId) $Name 
	set TaxIdDejaVu($Name)  $TaxId

	regsub -all {\'} $Name "\\'" BeauName
	set Csv "$TaxId|$Parent|$BeauName"
	lappend LesCreCsv $Csv
    }
    foreach TaxId $LesTaxId {
	set Parent [TaxNCBI $TaxId "Parent"]
	if { ! [info exists TaxIdDejaVu($Name)]} {
	    FaireLire "Parent $Parent of $TaxId $NameDejaVu($TaxId)\ndoesn't exist."
	    continue
	}
    }
    set FicCreCsv [SauveLesLignes $LesCreCsv dans "[RepertoireDuGenome]/createtaxoCre.csv"]
    return $FicCreCsv

}

proc CreateSqlTaxonomySynonym {} {

    
    set LesTaxId [lsort -integer [TaxNCBI List TaxId]]
    set Pk 0
    foreach TaxId $LesTaxId {
	set Name     [TaxNCBI $TaxId "Name"]
	set ItsNames [TaxNCBI $TaxId "ItsNames"]
	if {$Name==""} { continue }

	foreach Syno $ItsNames {
	    set BeauSyno $Syno
	    regsub -all {\\} $BeauSyno {\\\\} BeauSyno
	    regsub -all {\'} $BeauSyno "\\'"  BeauSyno
	    if { ! [string equal $Syno $BeauSyno]} { Espionne "$Syno\n$BeauSyno" }
	    if {[info exists SynoDejaVu($Syno)]} {
#		FaireLire "DejaVu $TaxId $Syno $SynoDejaVu($Syno)"
	    }
	    set SynoDejaVu($Syno) $TaxId

	    incr Pk
	    set Csv "$Pk|$TaxId|$BeauSyno"
	    lappend LesSynCsv $Csv
	}
    }
    set FicSynCsv [SauveLesLignes $LesSynCsv dans "[RepertoireDuGenome]/createtaxoSyn.csv"]
    return $FicSynCsv

}

proc CreateSqlonage {{Action ""}} {


    LoadSqlonage $Action

    Sqlonage eval "create table if not exists  oli(pk_oli INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, type TEXT, sens TEXT, seq TEXT, freetext TEXT)"

    Sqlonage eval "begin transaction"
    foreach P [Oli LaListeMerci] {
	set Name             $P
	set Type        [Oli $P "Type"]
	set Seq         [Oli $P "Seq"]
	set Sens        [Oli $P "Sens"]
	set Description [Oli $P "Description"]
	regsub -all "'" $Sens "''" Sens
	regsub -all "'" $Description "''" Description
	Sqlonage eval "insert into oli (name, type, sens, seq, freetext) values('$Name', '$Type', '$Sens', '$Seq', '$Description')"
    }
    Sqlonage eval "end transaction"

}

proc CreateStaf {} {

    FaireLire "Attention les STAF sont deja crees"
    set L 1
    foreach I [Staf ListOf Index] {
	set Nm     [string trim [Staf $I "h_Id_number"]]
	set Gene   [string trim [Staf $I "gene"]]
	if {$Gene==""} { set Gene "Unknown$I" }
	set Name   [string trim [Staf $I "name"]]
	set HPos   [string trim [Staf $I "h_pos."]]
	set Seq    [string trim [Staf $I "human_sequence"]]
	regsub -all -nocase {[^A-Z]} $Seq "" Seq
	set Nm2    [string trim [Staf $I "h_Id_number2"]]
	set Loc    [string trim [Staf $I "chromosome_and_localization"]]
	set Orient [string trim [Staf $I "ori."]]
	Espionne "$I $Nm $Gene $Name $Loc $HPos $Orient $Seq"
	if { ! [regexp "^N" $Nm]} { FaireLire $I }

	set Alias $Gene
	if {[info exists DejaVu($Alias)]} {
	    incr DejaVu($Alias)
	    set Alias "$Gene-$DejaVu($Alias)"
	} else {
	    set DejaVu($Alias) 1
	}

	

#	set Entete "$Alias Homo sapiens STAF binding site of $Name FROM $Nm"
#	set TFA [SequenceFormatTFA $Seq $Entete "nucbrut"]
#	set FichierTFA "/genomics/link/UCSCAlignements/STAF/proteome/$Alias"
#	Sauve $TFA dans $FichierTFA
#	lappend LeFof "$Alias $FichierTFA"
#	set LeGB [LaSequenceDesBanques $Nm "OnVeutGeneBank"]
#	if {$LeGB=={}} { FaireLire "Pas de GB" }
#	EspionneL $LeGB
    }
    SauveLesLignes $LeFof dans "/genomics/link/UCSCAlignements/STAF/STAF.fof"
    exit

}

proc CreateSummaryProject {} {

    global db FAPG

    set Lfroot [$db eval {select fileroot from files where ord=1}]

    FaireAttendre "Please wait ...\nProcessing files ..." 1
    set No 1
    foreach f $Lfroot {
	set FAPG [expr {100. * $No/[llength $Lfroot]}]
	update idletasks
	
	exec ordali [file join ord $f.ord] -batch -exe AuLog LOutput -exe exit
	if {[file exists [file join ord ${f}.html]]} {
	    file rename -force [file join ord ${f}.html] [file join Web $f.html]
	} else {
	    FaireLire "A problem occured when creating the output file for protein $f"
	}
	incr No
    }
    FaireLaSuite

    return

}

proc CreateTargetId {GS} {

    global DejaVuSpineNumber

    if {$GS=="Reset"} {
	if {[info exists DejaVuSpineNumber]} { unset  DejaVuSpineNumber }
	return ""
    }
    if {[EstUnPABMute $GS]} { return "Mutant" }

    if {[regexp "XGS" $GS]} { regsub "XGS" $GS ""  SpineNumber }
    if {[regexp "PGS" $GS]} {
	regsub "PGS" $GS "0" SpineNumber
	set SpineNumber [string range $SpineNumber end-3 end]
    }
    if {[info exists DejaVuSpineNumber($SpineNumber)]} {
	FaireLire "I had already the SpineNumber $SpineNumber for \n $DejaVuSpineNumber($SpineNumber)"
	return "Already seen"
    }
    set DejaVuSpineNumber($SpineNumber) $GS
    set TargetId "IGBMC-$SpineNumber-000"
    return $TargetId

}

proc CreateTfasForYEAH {Qui} {

    
    if {$Qui == "Sc"} {
	set FiS  "[RepertoireDuGenome]/DeJohan/Saccharomyces_cerevisiae.SGD1.48.pep.all.fa"
	set FiSc "[RepertoireDuGenome]/DeJohan/Sc.tfa"
	set i 100000
	foreach Access [LaSequenceDuTFAs $FiS "LaListeDesAccess"] {
	    incr i
	    set TFA [LaSequenceDuTFAs $FiS $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    set Def [StringSuivant " " dans $Entete]
	    set NewEntete "Sc$i Saccharomyces cerevisiae $Def"  
	    Espionne $NewEntete
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
	    lappend LeTFA $NewTFA
	}
	return [SauveLesLignes $LeTFA dans $FiSc]
    }
    if {$Qui == "Eh"} {
	set FiE  "[RepertoireDuGenome]/DeJohan/entamoeba_proteome.txt"
	set FiEh "[RepertoireDuGenome]/DeJohan/Eh.tfa"
	set i 200000
	foreach Access [LaSequenceDuTFAs $FiE "LaListeDesAccess"] {
	    incr i
	    set TFA [LaSequenceDuTFAs $FiE $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    set Def [StringSuivant " " dans $Entete]
	    set NewEntete "Eh$i Entamoeba histolytica $Def ($Access)"  
	    Espionne $NewEntete
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
	    lappend LeTFA $NewTFA
	}
	return [SauveLesLignes $LeTFA dans $FiEh]
    }
    if {$Qui == "At"} {
	set FiA  "[RepertoireDuGenome]/DeJohan/AGIrefseqAA"
	set FiAt "[RepertoireDuGenome]/DeJohan/At.tfa"
	set i 300000
	foreach Access [LaSequenceDuTFAs $FiA "LaListeDesAccess"] {
	    incr i
	    set TFA [LaSequenceDuTFAs $FiA $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    set Def [StringSuivant "| " dans $Entete]
	    regsub {\[Arabidopsis.*} $Def "" Def
	    set NewEntete "At$i Arabidopsis thaliana $Def ($Access)"  
	    Espionne $NewEntete
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
	    lappend LeTFA $NewTFA
	}
	return [SauveLesLignes $LeTFA dans $FiAt]
    }
    if {$Qui == "Hs"} {
	set FiH  "[RepertoireDuGenome]/DeJohan/Homo_sapiens.NCBI36.48.pep.all.fa"
	set FiHs "[RepertoireDuGenome]/DeJohan/Hs.tfa"
	set i 400000
	foreach Access [LaSequenceDuTFAs $FiH "LaListeDesAccess"] {
	    incr i
	    set TFA [LaSequenceDuTFAs $FiH $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    set Def [StringSuivant " " dans $Entete]
	    set NewEntete "Hs$i Homo sapiens $Def"  
	    Espionne $NewEntete
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
	    lappend LeTFA $NewTFA
	}
	return [SauveLesLignes $LeTFA dans $FiHs]
    }

}

proc CreateTreeFromDirectory {T parent dir} {

    set saved [pwd]

    cd $dir
    foreach f [glob -nocomplain *] {
	puts $f
	set name [file tail $f]
	if { [catch { file stat $f info }] != 0 } {
	    set node [$T insert $parent -label $name]
	} else {
	    if { $info(type) == "file" } {
		set info(type) [list @blt::tv::normalOpenFolder $name]
	    } else {
		set info(type) ""
	    }
	    set info(mtime) [clock format $info(mtime) -format "%b %d, %Y"]
	    set info(atime) [clock format $info(atime) -format "%b %d, %Y"]
	    set info(ctime) [clock format $info(ctime) -format "%b %d, %Y"]
            set info(size)  [FormatSize $info(size)]
	    set info(mode)  [FormatMode $info(mode)]
	    set node [$T insert $parent -label $name -data [array get info]]
	}
	if { [file type $f] == "directory" } {
	     CreateTreeFromDirectory $T $node $f
	}
    }
    cd $saved

}

proc CreateUserDir {{Rep ""}} {


    if {$Rep==""} { set Rep "." }

    foreach Ligne [split [exec ypcat passwd] "\n"] {
	Espionne $Ligne
	lassign [lrange [split $Ligne ":"] 0 2] Login bidon Uid
	set UidDe($Login) $Uid
	set LogDe($Uid) $Login
	lappend LesLoginUid "$Login $Uid"
	lappend LesUidLogin "$Uid $Login"
    }
    set LesUidLogin [lsort $LesUidLogin]
    set LesLoginUid [lsort $LesLoginUid]
    AfficheListe $LesUidLogin "" "LesUidLogin"
    AfficheListe $LesLoginUid "" "LesLoginUid"


    set Etudiants [NewUser "DontAsk" $Rep]
    foreach Ligne [split $Etudiants "\n"] {
	lassign [split $Ligne " "] L P N E M
	lappend LesLogins $L
#	set P [string range "$P[string toupper $N]" 3 10]
	set P "2014esbs"
Espionne "$P $L"
#	set S [string trim [exec htpasswd -nmb $L $P] " \n"]
	set S "$L:"
	append S {$6$8LDrNLVK$XkvEkFfmHYOnp82L0PfkE2lXZ88tuYaR23DeapNlt6O7Epp5VvNCU1aXErmtQqIsGunyfpq4ZJW/cO59bmxxK.}
	set Shad "$S:16107:0:99999:7:::"
	lappend LeShad $Shad
    }
    Sauve [join $LesLogins ","] dans "$Rep/loginsVirgule.txt"
    SauveLesLignes $LeShad dans "$Rep/shad.txt"

    if { ! [OuiOuNon "Je cree les repertoires"]} { exit }


    set NextUid [Entre 3850]
    foreach Ligne [split $Etudiants "\n"] {
	while {[info exists LoginDe($NextUid)]} { incr NextUid }
	lassign [split $Ligne " "] L P N E M
	if {[info exists UidDe($L)]} { FaireLire "$L existe deja avec Uid $UidDe($L)"; continue }
	set Home "/home/esbs2014/$L"
	if { ! [file exists $Home]} { file mkdir $Home }
	set N [string toupper $N]
	set Pass "$L:x:$NextUid:3014:$P $N,,:/home/$L:/usr/bin/tcsh"
	incr NextUid
	lappend LePass $Pass
    }
    return [SauveLesLignes $LePass dasn "$Rep/pass.txt"]

}

proc CreateWindow {} {

    set w .top
    toplevel $w 
    wm title $w "Tcl3D demo: NeHe & Terence J. Grant's ArcBall Rotation Tutorial (Lesson 48)"

    frame $w.fr
    grid $w.fr -row 0 -column 0 -sticky news
    grid rowconfigure    $w 0 -weight 1
    grid columnconfigure $w 0 -weight 1

    # Create Our OpenGL Window
    set wgl "$w.fr.toglwin"
    set ::pgl(wogl) $wgl
    togl $wgl  -width $::gDemo(winWidth)  -height $::gDemo(winHeight)  -double true  -depth true  -createproc CreateCallback  -reshapeproc Togl_ReshapeFonct  -displayproc DisplayCallback 
    listbox $w.fr.usage  -font $::gDemo(listFont)  -height 4
    label   $w.fr.info  -font $::gDemo(listFont)

    grid $w.fr.toglwin -row 0 -column 0 -sticky news
    grid $w.fr.usage   -row 1 -column 0 -sticky news
    grid $w.fr.info    -row 2 -column 0 -sticky news
    grid rowconfigure    $w.fr 0 -weight 1
    grid columnconfigure $w.fr 0 -weight 1

    # Watch For ESC Key And Quit Messages
    #wm protocol $w WM_DELETE_WINDOW "ExitProg"
    bind $w  "ExitProg"
    bind $w      "ToggleWindowMode"

    set ::BQx [expr {$::gDemo(winWidth)/2}]
    set ::BQy [expr {$::gDemo(winHeight)/2}]
    bind $wgl  {set ::BQx %x ; set ::BQy %y}
    bind $wgl  {QDrag %x %y}
    #bind $wgl <1>         "InitArcBall %x %y"
    #bind $wgl  "DragArcBall %x %y"
    bind $wgl <2>         "ResetRotations"
    bind $wgl <3>         "ResetRotations"
    bind $wgl  "ResetRotations"

    # FOG bindings
    set ::fact 0.1
    bind $w  {AdjustFog up}
    bind $w  {AdjustFog down}
    set ::fogon 1
    bind $w  {FogOnOff
	break}
    set ::fogsys "::GL_EXP2"
    bind $w  {ChangeFogSys}
    set ::fogcoords "frag"
    bind $w  {FogCoords}
    set ::eyepos "zero"
    #bind $wgl  {EyePos}

    $w.fr.usage insert end "Key-Escape Exit"
    $w.fr.usage insert end "Key-F1     Toggle window mode"
    $w.fr.usage insert end "Mouse-L    Drag objects with ArcBall"
    $w.fr.usage insert end "Mouse-MR   Reset rotations"
    $w.fr.usage configure -state disabled

    puts "window done ..."
    flush stdout

    return

}

proc CreateWithAny {fic ficout {seuil ""} {Org ""} {WithoutTextMiningOnly ""} {GetWhat ""}} {

    CanalSqlString

    if {$GetWhat==""} { set GetWhat "GetGn" }   ; #rR peut être GetGn GetSW ou GetGnGetSW

    set VersionString [StringApres "dbname=string" dans [CanalSqlCurrent]]
    set Commande LesInteractionsString9.0
    #if {$VersionString >= 9} {set Commande LesInteractionsString9.0}
    #if {$VersionString < 9}  {set Commande LesInteractionsString8.3}

    set listeId [LesLignesDuFichier $fic]
    if {[regexp -nocase  "Gn" $GetWhat]} {
	set Titre "PIDInitial\tPNInitial\tPIDCop\tPNCop\tcombinedScore\tevidenceScore"
    }
    if {                                  [regexp -nocase "Sw" $GetWhat]} {                     ;#rR a tester car certainement pas bon
	set Titre "PIDInitial\tPNInitial\tSwACInitial\tPNCop\tcombinedScore\tevidenceScore"
    }
    if {[regexp -nocase "Gn" $GetWhat] && [regexp -nocase "Sw" $GetWhat]} {
	set Titre "PIDInitial\tPNInitial\tSwACInitial\tPIDCop\tPNCop\tSwACCop\tcombinedScore\tevidenceScore"
    }

    set Tout [list $Titre]
    foreach e $listeId {
	LConcat Tout [$Commande $e $seuil $Org $WithoutTextMiningOnly $GetWhat]
    }
    CanalSqlDisconnect
    return [SauveLesLignes $Tout dans $ficout]

}

proc CreateurDesPABs {{Dieu ""}} {

    global RepertoireDuGenome
    global CreateurDesPABs

    set FichierCreateur "$RepertoireDuGenome/fiches/createurdespabs"

    if {$Dieu==""} {
	if {[info exists CreateurDesPABs]} { return $CreateurDesPABs }
	if {[file exists $FichierCreateur]} {
	    set CreateurDesPABs [ContenuDuFichier $FichierCreateur]
	} else {
	    set CreateurDesPABs "Inconnu"
	}
	return $CreateurDesPABs
    }
    set CreateurDesPABs $Dieu
    Sauve $CreateurDesPABs dans $FichierCreateur
    return $CreateurDesPABs

}

proc CreationDeLaListeDesDomaines {ListeDesBornes} {
    
    Espionne "CreationDeLaListeDesDomaines"
    set i 1
    set ListeDesDomaines {}
    #faut verifie cette liste des bornes.... #faut que cela soit une liste?? #fichier de liste de borne????
    foreach lesdomainesParborne $ListeDesBornes {
	#verifie cela doit être des chiffres
	scan $lesdomainesParborne "%s %s" debutDomaine finDomaine
	set start [DansAlignementPositionAbsolue $debutDomaine $CodeGscope $msfFile]
	set end   [DansAlignementPositionAbsolue $finDomaine   $CodeGscope $msfFile]
	set domaine "domaine$i"
	lappend ListeDesDomaines $domaine $start $end
	i incr
    }
    return $ListeDesDomaines

}

proc CreationDuFichierORF2CLUSTER_MORPHLH {} {


    #Nom       Cluster Access     Def        1 MORPH_D 1 MORPH_U
    #MORPH0001 MORPH_D 1416168_at 1416168_at      1       -1
    
    set Entete [list "#Nom" Cluster Access Def "1 MORPHLH_D" "1 MORPHLH_U"]
    lappend LesLignes [join $Entete "\t"]
    
    set File "[RepertoireDuGenome]/Affy3MorphineLH_WTDrugup.txt"
    set F  [open "$File"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set Affy ""
	scan $Ligne "%s" Affy
	set Tab($Affy,up) 1
    }
    close $F

    set File "[RepertoireDuGenome]/Affy3MorphineLH_WTDrugdown.txt"
    set F  [open "$File"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set Affy ""
	scan $Ligne "%s" Affy
	set Tab($Affy,down) 1
    }
    close $F
    
    foreach PAB [ListeDesPABs] {
	set Nom "$PAB"

	set Affy [AffymetrixAccess $PAB]
	if {[info exists Tab($Affy,up)]} {
	    set Cluster "MORPHLH_U"
	    set MORPHLH_D "-1"
	    set MORPHLH_U "1"
	} elseif {[info exists Tab($Affy,down)]} {
	    set Cluster "MORPHLH_D"
	    set MORPHLH_D "1"
	    set MORPHLH_U "-1"
	} else {
	    Espionne "Problem with $PAB"
	}
	set Ligne [list $PAB $Cluster $Affy $Affy $MORPHLH_D $MORPHLH_U]
	lappend LesLignes [join $Ligne "\t"]

    }
    set FileOut "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"
    AppendAuFichier $FileOut [join $LesLignes "\n"]
    
    return ""

}

proc CreationDuFichierORF2CLUSTER_MarkerLH {} {


    #Nom    Cluster Access  Def     1 Marker
    #MARK0001        Marker  1415975_at      1415975_at      1
    
    set Entete [list "#Nom" Cluster Access Def "1 MARKERLH"]
    lappend LesLignes [join $Entete "\t"]
    
    set File "[RepertoireDuGenome]/Affy3MarkerLHvsWBrain.txt"
    set F  [open "$File"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set Affy ""
	scan $Ligne "%s" Affy
	set Tab($Affy) 1
    }
    close $F
    
    foreach PAB [ListeDesPABs] {
	set Nom "$PAB"

	set Affy [AffymetrixAccess $PAB]
	if {[info exists Tab($Affy)]} {
	    set Cluster "MARKERLH"
	    set MARKERLH "1"
	} else {
	    Espionne "Problem with $PAB"
	}
	set Ligne [list $PAB $Cluster $Affy $Affy $MARKERLH]
	lappend LesLignes [join $Ligne "\t"]
    }
    set FileOut "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"
    AppendAuFichier $FileOut [join $LesLignes "\n"]
    
    return ""

}

proc CreationDuNalDesGenomesComplets {{Indesirables ""} {SuppOfficielles ""} {SuppGscope ""}} {

    global RepertoireDuGenome

    set RepertoireOfficiel "/catalog/blast"
    set LienLocal "blast"

    if { ! [file exists "$RepertoireDuGenome/banques"]} { File mkdir "$RepertoireDuGenome/banques" }

    while { ! [file exists "$RepertoireDuGenome/banques/blast"]} {
	if {[OuiOuNon "I need a link $RepertoireOfficiel -> $RepertoireDuGenome/banques/$LienLocal\n  Can I do it ? "]} {
	    eval exec "ln -s $RepertoireOfficiel $RepertoireDuGenome/banques/$LienLocal"
	} else {
	    if {[OuiOuNon "Do I skipp this now (You can fix it later) ?"]} { break }
	    if {[OuiOuNon "Do I cancel the Nal-blastn-database creation ?"]} { return }
	    if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
	}	    
    }
    set FichierNal "$RepertoireDuGenome/banques/completegenomes.nal"

    if {[OuiOuNon "Do you want to use the new version (2007/12/20) ?"]} {
	set LeNal {}
	foreach Genome [LesGenomesComplets] {
	    regsub " " $Genome "_" G
	    set RG "/catalog/blast/$G"
	    if {[file exists "$RG.nal"]} {
		lappend LeNal $RG
		continue
	    }
	    set RG [Entre $RG]
	    if {$RG ==""} { continue }
	    lappend LeNal $RG
	}
	set LeTexte {}
	lappend LeTexte "# Alias file created by Gscope"
	lappend LeTexte "#"
	lappend LeTexte "TITLE \"Complete Genomes created by Gscope [Date Nice]\""
	lappend LeTexte "#"
	lappend LeTexte "DBLIST [join $LeNal " "]"
	SauveLesLignes $LeTexte dans $FichierNal
	return $FichierNal    
    }

    set NalOfficiel "$RepertoireOfficiel/genomes.nal"
    
    foreach IS {"Indesirables" "SuppOfficielles" "SuppGscope"}  Action {"remove" "add" "add (from Gscope)"}  Defaut {"llact"  "/catalog/blast/dmel|/catalog/blast/worm|/catalog/blast/spombe|/catalog/blast/ecuniculi|/catalog/blast/yeast|/catalog/blast/athaliana"  "Mkan"} {
	if {[set $IS] != "PleaseAsk"} { continue }
	if {[OuiOuNon "Do You want to $Action some genomes in $NalOfficiel ? "]} {
	    FaireLire "Please give their names (BUT NOT human NOR mouse) (see in $NalOfficiel)"
	    set $IS [Entre $Defaut]
	    regsub -all {\|} [set $IS] " " $IS
	    while {[regexp "  " [set $IS]]} { regsub -all "  " [set $IS] " " $IS }
	    regsub -all " " [set $IS] "|" $IS
	} else {
	    set $IS ""
	} 
	Espionne "$IS [set $IS]"
    }

    set LesIndesirables    [split $Indesirables    "|"]
    set LesSuppOfficielles [split $SuppOfficielles "|"]
    set LesSuppGscope      [split $SuppGscope      "|"]

    Espionne $LesIndesirables
    Espionne $LesSuppOfficielles

    set LesBanquesOfficielles {}
    foreach Ligne [LesLignesDuFichier $NalOfficiel] {
	if { ! [regexp -nocase "^DBLIST" $Ligne]} { continue }
	
	set LesBanquesOfficielles [concat $LesBanquesOfficielles [lrange [split $Ligne " "] 1 end]]
    }

    foreach Banque $LesBanquesOfficielles {
	if { ! [regexp -nocase {[a-z]} $Banque]} { continue }
	if { [lsearch -exact $LesIndesirables $Banque] > -1 } { continue }
	lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
	lappend LesVraiesBanques $RepertoireOfficiel/$Banque
    }
    foreach BanqOff $LesSuppOfficielles {
	if { ! [file exists "$BanqOff.nhr"] && ! [file exists "/catalog/blast/$BanqOff.nhr"]} {
	    if {[OuiOuNon "$BanqOff.nhr doesn't exist ... Do I skip it ?"]} { continue }
	}
	set Banque [file tail $BanqOff]
	lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
	lappend LesVraiesBanques $BanqOff 
    }
    set LesBonnesBanquesANous {}
    foreach RepGenome $LesSuppGscope {
	if { ! [regexp "/" $RepGenome]} {
	    set Prefixe [PrefixeDuGenome $RepGenome]
	    set Banque "../../$RepGenome/banques/${Prefixe}overlap"
	}
	set BonneBanque 1
	set VraieBanque "$RepertoireDuGenome/banques/$Banque"
	while { ! [file exists "$VraieBanque.nhr"] } {
	    if {[OuiOuNon "$VraieBanque\n doesn't exist.\n  (Maybe you can create it later with\n    setgscope $RepGenome\n    gscope CreeLaBanqueBlastN\n  It's easy.)\n  Do I keep it now as it is ?"]} { break }
	    if {[OuiOuNon "the tfa file of $VraieBanque\n doesn't exist. Do I skipp it ?"]} {
		set BonneBanque 0
		break
	    }
	    if {[OuiOuNon "$VraieBanque\n doesn't exist. Do You know how to call it ?"]} {
		set Banque [Entre $Banque]
		set VraieBanque "$RepertoireDuGenome/banques/$Banque"
	    }
	}
	if {$BonneBanque} {
	    lappend LesBonnesBanquesANous $Banque
	    lappend LesVraiesBanques $VraieBanque
	}
    }
    set SuppHuman ""
    set LesHuman {}
    if {[OuiOuNon "Do You want to add the complete human genome ?"]} {
	set SuppHuman "human.nal"
	set LesHuman [LesBanquesDuNal "/catalog/blast/human.nal" "$LienLocal/"]
	foreach HB $LesHuman {
	    lappend LesVraiesBanques $HB
	}
    }
    set SuppMouse ""
    set LesMouse {}
    if {[OuiOuNon "Do You want to add the complete mouse genome ?"]} {
	set SuppMouse "mouse.nal"
	set LesMouse [LesBanquesDuNal "/catalog/blast/mouse.nal" "$LienLocal/"]
	foreach MB $LesMouse {
	    lappend LesVraiesBanques $MB
	}
    }
    set Liste [join [concat $LesBonnesBanquesANous $LesBonnesBanquesOfficielles $LesHuman $LesMouse] " "]
    set Sortie {}
    lappend Sortie "#"
    lappend Sortie "# Alias file for blast database created by Gscope [Date]"
    lappend Sortie "#"
    lappend Sortie "TITLE \"Complete Microbial Genomes without $Indesirables with $SuppOfficielles $SuppGscope $SuppHuman $SuppMouse\""
    lappend Sortie "#"
    lappend Sortie "DBLIST $Liste"
    lappend Sortie "#"
    set FichierNal [SauveLesLignes $Sortie dans "$RepertoireDuGenome/banques/completegenomes.nal"]

    set Hop 0
    set FichierHeaders    "$RepertoireDuGenome/banques/completegenomes.header"
    set FichierCorrection "$RepertoireDuGenome/banques/completegenomes.correction"
    if {[file exists $FichierHeaders] && [OuiOuNon "Do I replace $FichierHeaders ?"]} {
	File delete -force $FichierHeaders
    }
    set nORGinconnu 0
    foreach VraieBanque $LesVraiesBanques {
	Espionne "VraieBanque $VraieBanque"
	set Banque [file tail $VraieBanque]
	set SesHeaders [LesHeadersDeLaBanqueBlast $VraieBanque]
	set H [lindex $SesHeaders 0]
	Espionne "H     $H"
	set ORG [file tail $VraieBanque]
	if { ! [regexp -nocase {^[a-z0-9_]+\:[a-z0-9_]+} $H]} {
	    set ORG "$ORG:"
	    foreach H $SesHeaders {
		scan $H "%s" A
		AppendAuFichier $FichierCorrection "$A $ORG$A" 
		lappend SesNouveauxHeaders "$ORG$H"
		Espionne "I use ${ORG}$A instead of $A (see $FichierCorrection) "
	    }
	    set SesHeaders $SesNouveauxHeaders
	}
	AppendAuFichier $FichierHeaders [join $SesHeaders "\n"]
    }
    return $FichierNal

}

proc CreationDuProjetRet9033 {FileTable FileNewTable} {

    if {![file exists $FileTable]} {return}

    set TailleBoite      "999"
    set EcartEntreBoites "16"
    set FinDeRef         "101"

    set LeTexteDesPABs {}
    set LeTexte {}
    set F [open $FileTable]
    while {[gets $F Ligne]>=0} {
	set Ligne [string trim $Ligne]
	if {$Ligne == ""} {continue}
	set LaLigne    [split $Ligne "\t"]
	set Cluster    [lindex $LaLigne 0]
	if {$Cluster == "Cluster"} {continue}

	set Nom        [lindex $LaLigne 1]
	
	Espionne "$Nom"

	set DebutDeRef [expr $FinDeRef   + $EcartEntreBoites]
	set FinDeRef   [expr $DebutDeRef + $TailleBoite     ]

	lappend LeTexteDesPABs "$Nom $DebutDeRef $FinDeRef F"

	if {0} {
	    set Quoi       [lindex $LaLigne 2]
	    set Access     [lindex $LaLigne 3]
	    set Affy       [lindex $LaLigne 4]
	    set NomRet2717 [lindex $LaLigne 5]
	    set Def        [lindex $LaLigne 6]

	    Sauve "Nom: $Nom\nCodeClone: $Affy\nOwnerOfCDNA: ThierryLeveillard" dans "[RepertoireDuGenome]/infos/$Nom"
	    if {$NomRet2717 == ""} {set NomRet2717 "none"}
	    set Def "Affy:$Affy $Quoi:$Access Ret2717:$NomRet2717 $Def"
	    
	    if {$Quoi == "PROTEIN"} {
		set Banque "protein"
		set TFA [PageInfo $Access $Banque "seq"]
		set FileTFA "[RepertoireDuGenome]/prottfa/$Nom"
	    } else {
		set Banque "genbankfull"
		set TFA [PageInfo $Access $Banque "seq"]
		set FileTFA "[RepertoireDuGenome]/nuctfa/$Nom"
	    }
	    
	    set Entete ">$Nom $Quoi:$Access Affy:$Affy Ret2717:$NomRet2717"
	    if {$TFA == ""} {
		set InfoSeq "none"
		set TFA "$Entete NoSequenceFound"
	    } else {
	    set InfoSeq "OK"
		set TFA [SequenceFormatTFA [QueLaSequenceDuTexteTFA $TFA] $Entete]
	    }
	    
	    set Texte "$Cluster\t$Nom\t$Affy\t$Quoi\t$Access\t$InfoSeq\t$NomRet2717\t$Def"
	    
	    Espionne "$Nom -> $FileTFA"
	    Espionne $TFA
	    Espionne $Texte
	    
	    Sauve $TFA dans $FileTFA
	    lappend LeTexte $Texte

	    set FileNucTFA  "[RepertoireDuGenome]/nuctfa/$Nom"
	    set FileNucEMBL "[RepertoireDuGenome]/nucembl/$Nom"
	    if {[file exists $FileNucTFA]} {Sauve [SequenceFormatEMBLDuFichierTFA $FileNucTFA] dans $FileNucEMBL}
	}

    }
    close $F

    #Sauve [join $LeTexte "\n"] dans $FileNewTable

    Sauve [join $LeTexteDesPABs "\n"] dans "[RepertoireDuGenome]/fiches/bornesdespabs"

    return

}

proc CreationImagePourComparaisonDom {} {


    #Modification fusionne les PFAMs et les DOMAINS
    #Voir de ce que fait les differentes procedure et comment fusionne les deux PFAMS et DOMAINs
    
    #pour image protein par protein
    #nouveau 
    PFAMGroupePourTous         "" DomPfam
    ImageGroupeDom             "" DomPfam
    ImageGroupeDom             "" DomPfam position

    PFAMGroupePourTous         "" pfam
    ImageGroupeDom             "" pfam
    ImageGroupeDom             "" pfam position
    #pour le second tableau sans image!!!
    FichierTabDomainPourTous   "" pfam
    #############
    #pour image protein par protein
    PFAMGroupePourTous         "" domain
    ImageGroupeDom             "" domain
    ImageGroupeDom             "" domain position
    #pour le second tableau sans image!!!
    FichierTabDomainPourTous   "" domain
    #####################

    #Modification avant....
    PFAMGroupePourTous         "" region
    ImageGroupeDom             "" region
    ImageGroupeDom             "" region position
    FichierTabDomainPourTous   "" region


    #Ici il faut egalement modifie pour fusionner les PFAMs et les DOMAINS
    #Voir comment modifie cela!!!
    NbParalogueMax
    RelationDomainCouleurBilan "" pfam
    CreatCSVFileSpeDom pfam
    RelationDomainCouleurBilan "" domain
    CreatCSVFileSpeDom domain

}

proc CreeADNetTDNetRAC {SequenceBrute {Extension ""}} {

    global RepertoireDuGenome
    global ADN TDN RAC

    if {[file exists "$RepertoireDuGenome/beton/adn$Extension"]} {
	if {[OuiOuNon "Les Fichiers $RepertoireDuGenome/beton/adn$Extension ... existent deja.\nJe stoppe tout ?"]} { exit }
	if { [OuiOuNon "Je les garde ?"]} { return }
	if { ! [OuiOuNon "Je les recree ?"]} { return }
    }

    set Complement("X") "X"
    set Complement("x") "x"
    set Complement("A") "T" 
    set Complement("T") "A"
    set Complement("G") "C"
    set Complement("C") "G"
    set Complement("a") "t"
    set Complement("t") "a"
    set Complement("g") "c"
    set Complement("c") "g"
    set Complement("N") "N"
    set Complement("n") "n"

    set Complement("M") "K"
    set Complement("K") "M"
    set Complement("R") "Y"
    set Complement("Y") "R"
    set Complement("W") "W"
    set Complement("S") "S"

    set Complement("m") "k"
    set Complement("k") "m"
    set Complement("r") "y"
    set Complement("y") "r"
    set Complement("w") "w"
    set Complement("s") "s"

    set Complement("V") "B"
    set Complement("H") "D"
    set Complement("D") "H"
    set Complement("B") "V"
    set Complement("v") "b"
    set Complement("h") "d"
    set Complement("d") "h"
    set Complement("b") "v"

    set ADN "x"
    append ADN $SequenceBrute

    set L [string length $ADN]

    set TDN "x"
    set RAC "x"
    for {set i 1} {$i<$L} {incr i} {
	set D [string range $ADN $i $i]
	set F [string range $ADN [expr $L-$i] [expr $L-$i]]
	append TDN [set Complement("$D")]
	append RAC [set Complement("$F")]
    }

    set FichierADN [open "$RepertoireDuGenome/beton/adn$Extension" "w"]
    puts $FichierADN $ADN
    close $FichierADN

    set FichierTDN [open "$RepertoireDuGenome/beton/tdn$Extension" "w"]
    puts $FichierTDN $TDN
    close $FichierTDN

    set FichierRAC [open "$RepertoireDuGenome/beton/rac$Extension" "w"]
    puts $FichierRAC $RAC
    close $FichierRAC

}

proc CreeADNetTDNetRACaPartirDuFichierTFA {Fichier} {


    Wup "Create the flat files beton/adn beton/tdn beton/rac with the tfa file Fichier"
    Wup " if Fichier ends with .pure it creates adn.pure tdn.pure rac.pure"

    set DejaDemandeCodeDegenere 0
    set AccepteCodeDegenere 0

    set SequenceBrute ""
    foreach Ligne [LesLignesDuFichier $Fichier] {
	regsub " " $Ligne "" BelleLigne
	if {[regexp -nocase {[^ATGCNX]} $BelleLigne]} {
	    if {[regexp "^>" $BelleLigne]} { continue }
	    if {[regexp -nocase {[^ATGCNXMKRSYWVHDB]} $BelleLigne]} {
 		if {[OuiOuNon "$Ligne\n shows to be illegal, Do I stop ?"]} { exit }
		if {[OuiOuNon "Do I skipp ?"]} { continue }
	    } else {
		if { ! $DejaDemandeCodeDegenere} {
		    set DejaDemandeCodeDegenere 1
		    set AccepteCodeDegenere [OuiOuNon "Do You accept the degenerated code (ATGCNXMKRSYWVHDB) ?"]} {
		}
		if { ! $AccepteCodeDegenere } {
		    if {[OuiOuNon "$Ligne\n shows to be illegal, Do I stop ?"]} { exit }
		    if {[OuiOuNon "Do I skipp ?"]} { continue }
		}
	    }
	}
	append SequenceBrute [string toupper $BelleLigne]
    }
    if {[regexp "\.pure$" $Fichier]} {
	CreeADNetTDNetRAC $SequenceBrute ".pure"
    } else {
	CreeADNetTDNetRAC $SequenceBrute
    }

}

proc CreeAccessAliasDefinitionPourPeroxNew {} {

    global RepertoireDuGenome

    foreach {a b c} [LesLignesDuFichier "$RepertoireDuGenome/DeAurora/perox20010503ok.txt"] {
	set Alias ""
	set Access ""

	scan $a "%s" Alias
	set DE [string trim $b]
	scan $c "%s" Access

	if {$Alias=="" || $DE=="" || $Access==""} { break }

	lappend Sortie "$Access $Alias $DE"
	set LSDB [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"]
	if {$LSDB=={}} {
	    FaireLire "$a $b $c\nI couldn't get the sequence $Access"
	}
    }
    Espionne [SauveLesLignes $Sortie dans "$RepertoireDuGenome/PeroxAccesAliasDef.fof"]
    exit

}

proc CreeAdnDesProduitsPCR {Fichier} {

    set Adn [string repeat "n" 99]
    set Numero 0
    foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
	set TFA [LaSequenceDuTFAs $Fichier $Access]
	set Entete [lindex [split $TFA "\n"] 0]
	scan $Entete "%s %s %s %s" TexteNom TexteLong TexteDebut TexteFin
	set DebutProteine [StringApres "debut_" dans $TexteDebut]
	set FinProteine   [StringApres "fin_"   dans $TexteFin]

	incr Numero
	set D [FormatDesNumerosPourCollection]
	set BeauNumero [format "%$D" $Numero]
	set Debut [expr [string length $Adn] + $DebutProteine]
	set Fin   [expr [string length $Adn] + $FinProteine]
	set Orient "F"

	set Seq [QueLaSequenceDuTexteTFA $TFA]
	set lSeq [string length $Seq]
	set L [expr (($lSeq + 99)/3)*3 + 1]
	set NN [expr $L-$lSeq]
	append Adn $Seq
	append Adn [string repeat "n" $NN]
	set Nom "[PreFixe]$BeauNumero"
	lappend LesBornes "$Nom $Debut $Fin $Orient"
    }
    set AdnTFA [SequenceFormatTFA $Adn "adn create by Gscope" "nucbrut"]
    Sauve $AdnTFA dans "adn_des_produits_pcr.tfa"
    SauveLesLignes $LesBornes dans "bornes_des_produits_pcr.txt"
    return

}

proc CreeArbre {a b s c d args} {

    set Idg [CreeId $a $b]
    set Idd [CreeId $c $d]
    set Id  [ReunitBranches $Idg $Idd]

    if {[llength $args]} {
	#puts "args\n$args"
	set Ids [CreeId {*}[lrange $args 1 end]]
	set Id [ReunitBranches $Ids $Id]
    }

    return $Id

}

proc CreeArbre2 {args} {


    if {[llength $args] > 5} {
	set rest [lrange $args 5 end]
	set args [lrange $args 0 4]
	set Id [CreeArbre {*}$args]
	set args "$Id -1. [join $rest]"
	set Id [CreeArbre {*}$args]

	return $Id
    }

    lassign $args a b s c d

    set Idg [CreeId $a $b]
    set Idd [CreeId $c $d]
    set Id [ReunitBranches $Idg $Idd]

    return $Id

}

proc CreeBBC {{NomDeLaBanque ""} {Specif ""}} {

    return [CreeLaBanqueBlastClonage $NomDeLaBanque $Specif]

}

proc CreeBExe {Largs} {

    global PfamDir LNOrdali Sequences T LSOrdali ListePDB Tsite

    lassign $Largs pkpfam fpfam Lpdbv Lpat

    if {! [info exists Tsite]} {
	BCM_LoadCSADB
    }
    set ListePDB [list]
    
    set Lres [list]
    set pfamid [lindex [split [file tail $fpfam] .] 0]

    puts "\n$pfamid"
    puts "----------"
    puts "reading [file join $PfamDir $fpfam]"
    DecortiqueUnTFA [file join $PfamDir $fpfam] LNOrdali Sequences
    foreach n $LNOrdali {
	set nid [lindex [split $n "/"] 0]
	set T($nid) $n
    }
    
    set out [Cree_MapCSA2Pfam $pkpfam $Lpdbv $fpfam]
    if {$out != {} } {
	set Lres $out
    }
    
    if {0} {
	# -> residues interface
	# -> correspondance res interface -> ali pfam
	set out [Cree_MapInterface2Pfam $pkpfam $Lpdbv $fpfam]
	if {$out != {} } {
	    lappend Lres {*}$out
	}
    }

    # -> residues PROSITE
    set out [Cree_MapProsite2Pfam $pkpfam $Lpdbv $fpfam $Lpat]
    if {$out != {} } {
	lappend Lres {*}$out
    }

    unset -nocomplain LNOrdali Sequences T LSOrdali
    update

    return $Lres

}

proc CreeBJobs {} {

    global db dps ConsRef PfamDir ListePDB LNOrdali Sequences T

    BCM_setup

    set dps rpros
    sqlite3 $dps Prosite.sql

    # Inits
    set ListePDB [list]
    BCM_LoadCSADB

    $db eval {begin transaction}
    set Lpf [lsort -unique -dictionary [$db eval {select pfamid from pdbmap}]]
    puts "nbr of pfam .... : [llength $Lpf]"
    foreach pfamid $Lpf {
	set pfile [lindex [lsort [glob -nocomplain [file join $PfamDir "${pfamid}*"]]] end]
	
	set pkpfam [lindex [$db eval {select pk_pfam from pfam where pfamid=$pfamid}] 0]

	set Lpdbv [$db eval {select pdbid,chn,acc,id,pdeb,pfin,sdeb,sfin from pdbmap where pfamid=$pfamid}]

	set Lps [$db eval {select prosite from propfam where pfamid=$pfamid}]
	set Lpat [list]
	foreach ps $Lps {
	    lappend Lpat [$dps eval {select pattern from prosite where accession=$ps}]
	}

	lappend Ljob2do [list $pfamid [list $pkpfam $pfile $Lpdbv $Lpat]]
    }
    $db eval {commit}

    return $Ljob2do

}

proc CreeBResults {pktest pfamid Lval} {

    global db

    foreach r $Lval {
	lassign $r pk x c t
	$db eval {insert into residues values(NULL,$pk,$x,$c,$t)}
    }

    return [list]

}

proc CreeBThr {} {

    global db

    set db root
    # bench.sql est copie de bench_pfam.sql
    sqlite3 $db bench.sql
    file delete -force dres.sql

    set Ljobs [CreeBJobs]

    Thr_Submit -joblist $Ljobs -proccreate Tcree -procexe CreeBExe -procresults CreeBResults -nthreads 20
    
    $db close

    exit

}

proc CreeBalibaseBornesDesPABsAvecRV {} {

    set BBDir "/genomics/link/Balibase"
    foreach F [lsort [glob "$BBDir/RV*/*.tfa"]] {
	set Queue [file tail $F]
	regsub {\..+$} $Queue "" Nom
	Espionne $Nom
	lappend LesBB $Nom
    } 
    set Fin 299
    foreach Nom $LesBB {
	    set Debut [expr $Fin + 299]
	    set Fin   [expr $Debut + 1802]
	    set Orient "F"
	    lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
    }
    return [SauveLesLignes $LesBornesDesPABs dans "$BBDir/fiches/bornesdespabs"]

}

proc CreeBanqueBlastDuFichier {Fichier {NomDeLaBanque ""} {NomDeBapteme ""} {Format ""}} {


    Wup "if necessary, converts Fichier to a tfa file,"
    Wup " stores it in NomDeLaBanque,"
    Wup " creates the blast database NomDeLaBanque.nhr .nin .nsq"
    Wup " return the name of tfa file (=name of the blast database)"

    JeMeSignale
    
    if {$NomDeBapteme==""} { set NomDeBapteme [file tail $Fichier] }

    if {$NomDeLaBanque==""} {
	regsub {\.[^\.]*$} $Fichier "" NomDeLaBanque
    }

    set SeqDepart [ContenuDuFichier $Fichier]
    if {($Format!="tfa" && ! [regexp "tfa" [FormatDeLaSequence $SeqDepart]]) || $NomDeBapteme!=""} {
	set TFA [SequenceFormatTFA $SeqDepart $NomDeBapteme $Format]
    } else {
	set TFA $SeqDepart
    }

    set EcraseLeVieux 1
    while {[file exists $NomDeLaBanque]} {
	set Vieux [ContenuDuFichier $NomDeLaBanque]
	if {$TFA!=$Vieux} {
	    set EcraseLeVieux 0
	    break
	}
	if {[OuiOuNon "$NomDeLaBanque\n already exists. Can I overwrite ?"]} { break }
    }
    if {$EcraseLeVieux} { Sauve $TFA dans $NomDeLaBanque }
    
    exec formatdb -i $NomDeLaBanque -p F

    return $NomDeLaBanque

}

proc CreeBanqueBlastDuProjet {FichierTFA NomDeLaBanque NOuP} {

    
    if {![file exists $FichierTFA]} {return ""}
    
    if {$NOuP=="N"} {
	set NOuP F
    } elseif {$NOuP=="P"} {
	set NOuP T
    } else {Espionne "Petit probleme de NOuP";return ""} 
    
    set FormatdbCmd "/gcg/extensions/bin/formatdb  -i $FichierTFA  -t $NomDeLaBanque  -n $NomDeLaBanque  -p $NOuP  -o T"

    if {[catch {eval exec $FormatdbCmd} Message]} {Warne "Error in FormatDB command:\n>>>>$Message"}
    return ""

}

proc CreeBanqueBlast_Ontario {{Fichier ""} {FichierOut ""}} {


    Wup "Permet de creer une banque blast a partir du fichier TFA"
   
    #formatdb -i Chip_EST.tfa -o T -t EST_Chip -p F -n EST_Chip
    set FichierIn "[RepertoireDuGenome]/Autres_Puces/Ontario/Banque_Blast/Chip_EST.tfa"
    set Banque    "[RepertoireDuGenome]/Autres_Puces/Ontario/Banque_Blast/Chip_EST"
    
    if {! [file exists $FichierIn]} {return ""}
    
    set Cmdformadb "formatdb  -i $FichierIn  -o T  -t EST_Chip  -p F  -n $Banque"
    if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"}
    return ""

}

proc CreeBanqueBlast_UMCU {{Fichier ""} {FichierOut ""}} {


    Wup "Permet de creer une banque blast a partir du fichier TFA"
   
    set FichierIn "[RepertoireDuGenome]/Banque_Blast/UMCU.tfa"
    set Banque    "[RepertoireDuGenome]/Banque_Blast/UMCU_HUMANV2"
    
    if {! [file exists $FichierIn]} {return ""}
    
    set Cmdformadb "formatdb  -i $FichierIn  -o T  -t UMCU_HUMANV2  -p F  -n $Banque"
    if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"}
    return ""

}

proc CreeBanqueProtAbberrations {Nom} {

    NousAllonsAuBoulot "[GscopeDatabaseDir Procure]/banques/"
    eval exec "/gcg/extensions/bin/formatdb -i $Nom -p T"
    OnRevientDuBoulot
    return "[GscopeDatabaseDir Procure]/banques/$Nom"

}

proc CreeBanqueVertebrateRefSeq {} {

    #a faire un par un dans le repertoire concerne
    
    exec formatdb -i "Sw_Vertebrata" -p T -o T
    #exec formatdb -i "Tr_Vertebrata" -p T -o T

    #exec formatdb -i "varsplic_Vertebrata" -p T -o T

    #exec formatdb -i "refseq-new-proteic_Vertebrata" -p T -o T
    #exec formatdb -i "refseq-rel-proteic_Vertebrata" -p T -o T

    #exec formatdb -i "Ensembl_Vertebrata" -p T -o T

    #doit faire un "file delete" des fichiers tfa apres formation des banques 

}

proc CreeBanquesGenesAbberrationsChr {} {

    NousAllonsAuBoulot "[GscopeDatabaseDir Procure]/banques/"
    eval exec "/gcg/extensions/bin/formatdb -i GenesCGHBACmeta -p F"
    OnRevientDuBoulot
    return "[GscopeDatabaseDir Procure]/banques/GenesCGHBACmeta"

}

proc CreeBanquesProtAbberrationsChr {} {

    NousAllonsAuBoulot "[GscopeDatabaseDir Procure]/banques/"
    eval exec "/gcg/extensions/bin/formatdb -i ProtCGH06 -p T"
    OnRevientDuBoulot
    return "[GscopeDatabaseDir Procure]/banques/ProtCGH06"

}

proc CreeBilanGFF {Quoi} {

    #Pour Naomi
    #Quoi est PFAM ou BLOCK ou PROSITE
    set i 0
    foreach Box [ListeDesPABs] {
	if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} {
	    set Org Mouse
	} elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set Org Rat
	} else {
	    set Org SpliRet
	}
	
	set Cluster   [ExtraitInfo $Box "Cluster"]
	set Ref       [ExtraitInfo $Box "Ref"]
	set LesNames  [InterrogeNames $Cluster Name $Org]
	#set RefPfam   [InterrogeRefPfam $Box RefPfam]
	#set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims]
	set Gn  [ExtraitInfo $Box "ValiGN"]
	set Des [ExtraitInfo $Box "ValiDE"]

	if {$Org=="SpliRet"} {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne"}
	} else {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	}
	if {![file exists $FileMacsims]} {continue}
	foreach Name $LesNames {
	    incr i
	    if {$Quoi == "PFAM"}    {set QuoiFromMacsims "ConcatPfam"} 
	    if {$Quoi == "BLOCK"}   {set QuoiFromMacsims "ConcatBlock"}
	    if {$Quoi == "PROSITE"} {set QuoiFromMacsims "ConcatProsite"}

	    if {$Name==$Ref} {
		set NameAm $Box
		set LesFeaturesInfoName [FromMacsims $FileMacsims $NameAm $QuoiFromMacsims]
	    } else {
		set LesFeaturesInfoName [FromMacsims $FileMacsims $Name $QuoiFromMacsims]
	    }
	    foreach FeatureInfoName $LesFeaturesInfoName {
		set MotsFeatureInfoName [split $FeatureInfoName "/"]
		set Feature     [lindex $MotsFeatureInfoName 0]
		set MotsFeature [split $Feature " "]
		set Id          [lindex $MotsFeature 0]
		set FeatureName [lindex $MotsFeature 1]
		if {[regexp "^ERROR" $Id] || [regexp "^WARN" $Id]} {continue}
		regsub "PROP_" $Id "" Id
		FstartFstop $FeatureInfoName RFstart RFstop
		set LigneGFF "$Cluster;$Name;$Quoi;$Id;$RFstart;$RFstop"
		lappend LesLigneGFF $LigneGFF
	    }
	}
    }
    #SauveLesLignes $LesLigneGFF dans "[RepertoireDuGenome]/Bilan${Quoi}${Org}.gff"
    Espionne "$i"

}

proc CreeBilanGFFOld {} {

    #Pour Corinne
    set i 0
    foreach Box [ListeDesPABs] {
	Espionne "$Box"

	if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} {
	    set Org Mouse
	} elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set Org Rat
	} else {
	    set Org SpliRet
	}
	
	set Cluster   [ExtraitInfo $Box "Cluster"]
	set Ref       [ExtraitInfo $Box "Ref"]
	set LesNames  [InterrogeNames $Cluster Name $Org]
	#set RefPfam   [InterrogeRefPfam $Box RefPfam]
	#set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims]
	set Gn  [ExtraitInfo $Box "ValiGN"]
	set Des [ExtraitInfo $Box "ValiDE"]

	if {$Org=="SpliRet"} {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne"}
	} else {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	}

	foreach Name $LesNames {
	    incr i
	    Espionne "$i $Name"
	    if {$Name==$Ref} {
		set NameAm $Box
		set LesPfamInfoName [FromMacsims $FileMacsims $NameAm "ConcatPfam"]
	    } else {
		set LesPfamInfoName [FromMacsims $FileMacsims $Name "ConcatPfam"]
	    }
	    foreach PfamInfoName $LesPfamInfoName {
		set MotsPfamInfoName [split $PfamInfoName "/"]
		set Pfam     [lindex $MotsPfamInfoName 0]
		set MotsPfam [split $Pfam " "]
		set Id       [lindex $MotsPfam 0]
		set PfamName [lindex $MotsPfam 1]
		regsub "PROP_" $Id "" Id
		FstartFstop $PfamInfoName RFstart RFstop
		#Espionne "$Box $Name $PfamInfoName" 
		#Espionne "$Id $PfamName $RFstart $RFstop"
		set LigneGFF "$Name\tPFAM\t$Id\t$RFstart\t$RFstop\t.\t.\t."
		lappend LesLigneGFF $LigneGFF
	    }
	}
    }
    SauveLesLignes $LesLigneGFF dans "[RepertoireDuGenome]/Pfam${Org}.gff"
    Espionne "$i"

}

proc CreeBilanIndividuel {{Fichier ""}} {

    
    global RepertoireDuGenome
    
    set RepXHda "$RepertoireDuGenome/xhda"

    if {$Fichier==""} {
	set BilanTotal "$RepXHda/BilanXHdaTotal"
	if {! [File exists $BilanTotal]} {return "$BilanTotal does not exists"}
    }

    foreach ligne [LesLignesDuFichier $BilanTotal] {
	Espionne $ligne
	scan $ligne "%s" NomDeFamille
	AppendAuFichier "$RepertoireDuGenome/bilan_xhda/$NomDeFamille" $ligne
    }

}

proc CreeBlastDatabaseForUniprot {{Rep ""}} {

    #rR ceci sert surtout de pense-bête ...
    if {$Rep==""} { set Rep "./" }
    NousAllonsAuBoulot $Rep

    foreach B [list sprot trembl] {
	lappend LesCommandes "curl 'ftp://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/complete/uniprot_${B}.fasta.gz' -o uniprot_${B}.fasta.gz"
	lappend LesCommandes "gunzip uniprot_${B}.fasta.gz"
	lappend LesCommandes "mv uniprot_${B}.fasta ${B}SansOX"
	lappend LesCommandes "gscope yes FastaForBlast NewFastaFile - ${B}SansOX ${B}"
	lappend LesCommandes "ls "
	lappend LesCommandes "gscope yes CompleteCreateBlastDatabaseWithFasta $B $B"
    }
    set LesCommandesToDo [split [AfficheListe $LesCommandes "AvecRetour"] "\n"]
    EspionneL $LesCommandesToDo
    foreach Commande $LesCommandesToDo {
	Espionne $Commande
	if {[regexp "^gscope yes" $Commande]} {
	    regsub "gscope yes " $Commande "" Commande
	    eval $Commande
	} else {
	    eval exec $Commande
	}
	Espionne "$Commande done"
    }
    OnRevientDuBoulot
    return "coucou"

}

proc CreeBlastDatabaseWithOiCode {Domaine {NomBanque ""} {FormatdbOrMakeblastdb ""}} {


    if {$FormatdbOrMakeblastdb==""} { set FormatdbOrMakeblastdb "makeblastdb" }

    set LesFasta [OiCodeForDomain $Domaine ListOf FullFilePath]
    if {$NomBanque==""} { set NomBanque "Oi$Domaine" }

    set Rep "/blast/OrthoInspector"
    file mkdir $Rep
    NousAllonsAuBoulot $Rep

    if {[file exists $NomBanque] || [file exists $NomBanque.phr]} {
	if { ! [OuiOuNon "$NomBanque already exist. Do I overwrite"]} { OnRevientDuBoulot; return "" }
    }

    set F [open $NomBanque "w"]
    foreach Fasta $LesFasta {
	set TFA [ContenuDuFichier $Fasta]
	puts $F $TFA
    }
    close $F

    if {$FormatdbOrMakeblastdb=="formatdb"} {
	exec formatdb -i $NomBanque -p T -l $NomBanque.formatdb.log -o
    } else {
	exec /biolo/blast/bin/makeblastdb -dbtype prot -in $NomBanque -out $NomBanque -hash_index -parse_seqids
    }
    OnRevientDuBoulot
    return "$Rep/$NomBanque"

}

proc CreeBlastDatabasesWithOrthoinspectorProteomes {} {

    NousAllonsAuBoulot "[RepertoireDuGenome]/newbanques"
    set LesCrees {}
    foreach P [lsort [glob *]] {
	if {[regexp {\.p} $P]} { continue }
	Espionne $P
	exec formatdb -i $P -p T -o
	file rename formatdb.log $P.formatdb.log
	lappend LesCrees $P 
    }
    OnRevientDuBoulot
    return $LesCrees

}

proc CreeBootstrapRef {t n} {

    foreach n [$t nodes] {
	set Le [$t get $n Lleaves]
	set Lr [lor $::TLeaves $Le "from1"]
	set Se [join [lsort $Le] ,]
	set Sr [join [lsort $Lr] ,]
	set k1 "$Se@$Sr"
	set k2 "$Sr@$Se"
	
	set ::HashRef($n)  $k1
	set ::HashRef($k1) $n
	set ::HashRef($k2) $n
    }

    return

}

proc CreeBootstrapTable {t} {

    foreach n [$t nodes] {
	set Le [$t get $n Lleaves]
	set Lr [lor $::TLeaves $Le "from1"]
	set k1 "[join [lsort $Le] ,]@[join [lsort $Lr] ,]"
	lappend ::TBoot $k1	
    }
    
    return

}

proc CreeBornesDesCDNAs {{Qui ""} {Adjonction ""}} {

    global RepertoireDuGenome

    set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
    if {[file exists $FichierBornesDesPABs]} { Garde $FichierBornesDesPABs }

    set DebutBornes 101
    set FinBornes   $DebutBornes
    set NumDuDernier 0
    if {$Adjonction=="EnFin"} {
	set Adjonction 1
	set AdjonctionEnFin 1
	set LesBornesDesPABs [LesLignesDuFichier $FichierBornesDesPABs]
    } else {
	set Adjonction 0
	set AdjonctionEnFin 0
	set LesBornesDesPABs {}
    }
    if {$AdjonctionEnFin} {
	set DernierPos [DernierPAB "EnPosition"]
	set F [Box $DernierPos fin]
	set DebutBornes [expr $F + 1000]
	set FinBornes   $DebutBornes
	set DernierNum [DernierPAB "EnNumero"]
	regsub "^[PreFixe]" $DernierNum "" NumDuDernier
	set NumDuDernier [Base10 $NumDuDernier]
	set NouveauNum [expr $NumDuDernier + 1]
	set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $NouveauNum]
	if { ! [OuiOuNon "Ok to add the new elements \n at $DebutBornes after $DernierPos \n Numbering starts with $NouveauNom"]} { return "" }
	if { ! [OuiOuNon "I'll replace $FichierBornesDesPABs and exit.\nOK ?"]} { return "" }
    }

    set OS [Entre "Homo sapiens"]
    set OC [OCduOS $OS]

    if { ! [file exists "$RepertoireDuGenome/nuctfa"]}  { File mkdir "$RepertoireDuGenome/nuctfa" }
    if { ! [file exists "$RepertoireDuGenome/nucembl"]} { File mkdir "$RepertoireDuGenome/nucembl" }

    set PrenomNom(cDNA_with_owner_clone) "cDNAs with owner and clone"
    set PrenomNom(Affymetrix)            "Affymetrix"
    set PrenomNom(In_TFA)                "Nucleic sequences in one TFA file"
    set PrenomNom(In_TFA_WithCC)         "Nucleic sequences in one TFA file with CC and Owner"
    set PrenomNom(In_TFA_FromEstChip)    "Nucleic sequences in one TFA file with xxx_yyy and definition"
    set PrenomNom(DNA_with_Access_Alias) "file with a 'access (alias (def))' list"

    if {$Qui==""} {
	set LesQui [array names PrenomNom]
	foreach Q $LesQui {
	    lappend LesPNoms [set PrenomNom($Q)]
	}
	set Qui [ChoixParmiJoli $LesQui {} $LesPNoms]
	if {$Qui==""} { exit }
    }

    if {$Qui=="DNA_with_Access_Alias"} {
	if { ! [OuiOuNon "Could You browse for a file with 'access (alias (def))' ?"]} {
	    return [CreeBornesDesCDNAs]
	}
	set FichierAccessAlias [ButineArborescence "All" $RepertoireDuGenome]
	if {$FichierAccessAlias==""} { return [CreeBornesDesCDNAs] }

	set Debut $DebutBornes
	set Fin   $Debut
	set Long  1000
	set n $NumDuDernier
	foreach Ligne [LesLignesDuFichier $FichierAccessAlias] {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    set Alias [format "%s%[FormatDesNumerosPourCollection]" "ALIAS_" $n]
	    scan $Ligne "%s %s" Access Alias
	    regsub "$Alias +$Access +" $Ligne "" Descr

	    set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
	    set Debut [expr $Debut + $Offset]
	    set Fin   [expr $Debut + $Long -1]
	    set Orient "F"
	
	    incr n
	    set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
	    
	    set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
	    set FichierNucTFA  "$RepertoireDuGenome/nuctfa/$Nom"
	    if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
		set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
		if {$LesLignesEMBL==""} {
		    AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
		    continue
		}
		set DE ""
		set LesNouvellesLignes {}
		foreach Ligne $LesLignesEMBL {
		    if {[regexp "^ID " $Ligne]} {
			scan $Ligne "%s %s" Bidon ID
			set Ligne "ID $Nom  created by Gscope from ID $ID"
		    } 
		    if {[regexp "^AC " $Ligne]} {
			scan $Ligne "%s %s" Bidon AC
			set Ligne "AC $Nom;"
		    } 
		    if {[regexp "^DE " $Ligne]} {
			regsub {DE *} $Ligne "" DE
		    }
		    if {[regexp "^SQ " $Ligne]} {
			lappend LesNouvellesLignes "CC   Original description: $Descr"
		    }
		    lappend LesNouvellesLignes $Ligne
		}
		set Entete "$Nom $Access $Alias : $Descr"
		Espionne $Entete
		set NucEMBL [join $LesNouvellesLignes "\n"]
		set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
		Sauve $NucTFA  dans $FichierNucTFA
		Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
	    }
	    lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
	    SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
	    if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
	}
    }
    set FromEstChip 0
    set WithCC 0
    set IExpect "(I expect '>access definition ...')"
    if {$Qui=="In_TFA_WithCC"} {
	set WithCC 1
	set Qui "In_TFA"
	set IExpect "(I expect '>CodeClone Owner')"
    }
    if {$Qui=="In_TFA_FromEstChip"} {
	set FromEstChip 1
	set Qui "In_TFA"
	set IExpect "(I expect '>xxx_yyy definition')"
    }
    if {$Qui=="In_TFA"} {
	if { ! [OuiOuNon "Could You browse a TFA file with all sequences ? \n $IExpect"]} {
	    return [CreeBornesDesCDNAs]
	}
	set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
	if {$FichierTFAs==""} { return [CreeBornesDesCDNAs] }

	set Debut $DebutBornes
	set Fin   $Debut
	set Long  1000
	set n $NumDuDernier
	foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
	    set LesLignesEMBL {}
	    set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
	    set Descr [EnteteDuTexteTFA $TFA]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    regsub ">" $Descr "" Descr
	    if {$FromEstChip} { scan $Descr "%s" CC ; regsub "$CC " $Descr "" Descr }
	    if {$WithCC} { scan $Descr "%s %s" CC Owner }
	    regsub -all -nocase {[^a-z]} $Seq "" Seq
	    set LongSeq [string length $Seq]
	    
	    set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
	    set Debut [expr $Debut + $Offset]
	    set Fin   [expr $Debut + $Long -1]
	    set Orient "F"
	    
	    incr n
	    set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
	    
	    set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
	    set FichierNucTFA  "$RepertoireDuGenome/nuctfa/$Nom"
	    if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
		set LesLignesEMBL {}
		lappend LesLignesEMBL "ID   $Nom  created by Gscope from a tfas file "
		lappend LesLignesEMBL "AC   $Nom;"
		if {$WithCC} {
		    lappend LesLignesEMBL "CC   CodeClone $CC   Owner $Owner"
		    set Entete "$Nom $CC $Owner"
		} elseif {$FromEstChip} {
		    lappend LesLignesEMBL "CC   CodeClone $CC"
		    lappend LesLignesEMBL "CC   Description $Descr"
		    set Entete "$Nom $CC $Descr"
		} else {
		    set Sep ":"
		    foreach Wrap [WrapLeTexte $Descr 50] {
			lappend LesLignesEMBL "CC   Original description$Sep $Wrap"
			set Sep "+"
		    }
		    set Entete "$Nom : $Descr"
		}
		set SeqEMBL [QueSequenceFormatEMBL $Seq "AvecSQ"]
                lappend LesLignesEMBL $SeqEMBL
		
		set NucEMBL [join $LesLignesEMBL "\n"]
		set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
		Sauve $NucTFA  dans $FichierNucTFA
		Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
	    }
	    lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
	    SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
	    if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
	}
    }
	
    if {$Qui=="Affymetrix"} {
	if { ! [OuiOuNon "Could You browse a file with Affymetrix Clone Accession numbers ? \n (I expect 'Clone Access Definition ...')"]} {
	    return [CreeBornesDesCDNAs]
	}
	set FichierAffy [ButineArborescence "All" $RepertoireDuGenome]
	if {$FichierAffy==""} { return [CreeBornesDesCDNAs] } 

	set Debut $DebutBornes
	set Fin   $Debut
	set Long  500
	set n     $NumDuDernier
	foreach CcAcDescr [LesLignesDuFichier $FichierAffy] {
	    if { ! [regexp -nocase {[a-z]} $CcAcDescr]} { continue }
	    scan $CcAcDescr "%s %s" Alias Access
	    regsub "$Alias +$Access +" $CcAcDescr "" Descr

	    set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
	    set Debut [expr $Debut + $Offset]
	    set Fin   [expr $Debut + $Long -1]
	    set Orient "F"
	
	    incr n
	    set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
	    
	    set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
	    set FichierNucTFA  "$RepertoireDuGenome/nuctfa/$Nom"
	    if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
		set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
		if {$LesLignesEMBL==""} {
		    AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
		    continue
		}
		set DE ""
		set LesNouvellesLignes {}
		foreach Ligne $LesLignesEMBL {
		    if {[regexp "^ID " $Ligne]} {
			scan $Ligne "%s %s" Bidon ID
			set Ligne "ID $Nom  created by Gscope from ID $ID"
		    } 
		    if {[regexp "^AC " $Ligne]} {
			scan $Ligne "%s %s" Bidon AC
			set Ligne "AC $Nom;"
		    } 
		    if {[regexp "^DE " $Ligne]} {
			regsub {DE *} $Ligne "" DE
		    }
		    if {[regexp "^SQ " $Ligne]} {
			lappend LesNouvellesLignes "CC   Affy's description: $Descr"
		    }
		    lappend LesNouvellesLignes $Ligne
		}
		set Entete "$Nom $Access $Alias : $Descr"
		Espionne $Entete
		set NucEMBL [join $LesNouvellesLignes "\n"]
		set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
		Sauve $NucTFA  dans $FichierNucTFA
		Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
	    }
	    lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
	    SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
	    if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
	}
    }

    if {$Qui=="cDNA_with_owner_clone"} {
	foreach Fichier [glob "$RepertoireDuGenome/cdna/*"] {
	    set LeTFA [LesLignesDuFichier $Fichier]
	    set Entete [lindex $LeTFA 0]
	    set LaSeq  [lrange $LeTFA 1 end]
	    scan $Entete "%s %s" ChevronUser Clone 
	    regsub "$ChevronUser $Clone" $Entete "" Remarque
	    set Remarque [string trim $Remarque]
	    regsub ">" $ChevronUser "" User
	    set CDNAcode "$User$Clone"
	    set Seq [join $LaSeq ""]

	    set NomFiCDNA [file tail $Fichier]
	    set JR [JumeauRepresentatif $NomFiCDNA]
	    if {$JR!=$NomFiCDNA && $JR!=""} { append Remarque "SameSeqAs:$JR" }
	    set NomDuFichierCDNA($CDNAcode) $NomFiCDNA
	    set Clones($CDNAcode) $Clone
	    set Seqs($CDNAcode) $Seq
	    set Remarques($CDNAcode) $Remarque
	    set Users($CDNAcode) $User
	    lappend LesCDNAs $CDNAcode
	}
	set LesCDNAs [lsort $LesCDNAs]

	set Debut  $DebutBornes
	set Fin    $Debut
	set n $NumDuDernier
	foreach CDNA $LesCDNAs {
	    incr n
	    set Seq      [set Seqs($CDNA)]
	    set Clone  [set Clones($CDNA)]
	    set Rem [set Remarques($CDNA)]
	    set User    [set Users($CDNA)]
	    set NomFiCDNA [set NomDuFichierCDNA($CDNA)]
	    set Long [string length $Seq]
	    
	    set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
	    set Debut [expr $Debut + $Offset]
	    set Fin   [expr $Debut + $Long -1]
	    set Orient "F"
	    
	    set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
	    set PABduFiCDNA($NomFiCDNA) $Nom
	    lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"

	    if {[regexp "SameSeqAs:" $Rem]} {
		set JR [StringApres "SameSeqAs:" dans $Rem]
		append Rem " [set PABduFiCDNA($JR)]"
	    }

	    set NucTFA [SequenceFormatTFA $Seq "$Nom $Clone $User $Rem" "nucbrut"]
	    
	    set NucEMBL ""
	    append NucEMBL "ID   $Nom      PRELIMINARY;       DNA;   $Long bases."
	    append NucEMBL "\nAC   $Nom"
	    append NucEMBL "\nOS   $OS."
	    append NucEMBL "\nOC   $OC"
	    append NucEMBL "\nCC   -!- cDNA sequence by [set PrenomNom($Qui)]"
	    append NucEMBL "\nCC       User $User Clone $Clone"
	    if {$Rem!=""} { append NucEMBL "\nCC   $Rem" }
	    append NucEMBL "\n[QueSequenceFormatEMBL $Seq AvecSQ]"
	    
	    Sauve $NucTFA  dans "$RepertoireDuGenome/nuctfa/$Nom"
	    Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
	    if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
	    SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
	}
    }

    if {$Adjonction} { exit }
    InformeIdentitesDuCDNAPourTous
    return $LesBornesDesPABs

}

proc CreeBornesDesPABsAvecTFAs {{FichierTFAs ""} {KeepEntete ""} {CreateNarcisse ""} {ForceAccessFirst ""}} {

    global RepertoireDuGenome

    if {[OnTraiteDesNucleotides]} {
	if { ! [file exists "$RepertoireDuGenome/nuctfa"]}  { file mkdir "$RepertoireDuGenome/nuctfa" }
	if { ! [file exists "$RepertoireDuGenome/nucembl"]} { file mkdir "$RepertoireDuGenome/nucembl" }
    }
    if {[OnTraiteDesProteines]} {
	if { ! [file exists "$RepertoireDuGenome/prottfa"]}  { file mkdir "$RepertoireDuGenome/prottfa" }
	if { ! [file exists "$RepertoireDuGenome/protembl"]} { file mkdir "$RepertoireDuGenome/protembl" }
    }
    if {$FichierTFAs==""} {
	if { ! [OuiOuNon "Could You browse a TFAs file with all sequences ? \n (I expect \n '>Access ...'\n or \n '>sp|Access|something definition (GN) ...')"]} {
	    return {}
	}
	set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
	if {$FichierTFAs==""} { return {} }
    }

    if {$KeepEntete==""} {
	set KeepEntete [OuiOuNon "Do I keep the information following each '>'"]
    } else {
	set KeepEntete [string equal -nocase $KeepEntete "KeepEntete"]
    }

    if {$CreateNarcisse==""} {
	set CreateNarcisse [OuiOuNon "Can I use the Access from each sequence to create Narcisse ?"]
    } else {
	set CreateNarcisse [string equal -nocase $CreateNarcisse "CreateNarcisse"]
    }

    if {$ForceAccessFirst==""} {
	set ForceAccessFirst [OuiOuNon "Do I Force Access to be in position 1" 0]
    } else {
	set ForceAccessFirst [string equal -nocase $ForceAccessFirst "ForceAccessFirst"] 
    }
    if {$ForceAccessFirst} { set ForceAccessFirst "ForceAccessFirst" } else { set ForceAccessFirst "" }

    set AddNewSequences 0
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    if {[file exists $FichierBornes]} {
	if { ! [OuiOuNon "You want to add new sequences. Did You add them at the end of \n $FichierTFAs\n OK ?" 0]} {
	    return {}
	}
	set AddNewSequences 1
	set LesExistants [lsort [ListeDesPABs]]
    }

    set Debut 101
    set Fin   101
    set Long  1000
    set n 0
    set LeBonChamp -1
    foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "" $ForceAccessFirst] {
	incr n
	set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
	set Fin [expr $Debut+$Long]

	set Orient "F"
	lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
#	SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
	set Debut [expr $Fin + 33]

	set FichierNucEMBL  "$RepertoireDuGenome/nucembl/$Nom"
	set FichierNucTFA   "$RepertoireDuGenome/nuctfa/$Nom"
	set FichierProtEMBL "$RepertoireDuGenome/protembl/$Nom"
	set FichierProtTFA  "$RepertoireDuGenome/prottfa/$Nom"
	if {[OnTraiteDesProteines] && [file exists $FichierProtEMBL] && [file exists $FichierProtTFA] ||  [file exists $FichierNucEMBL] && [file exists $FichierNucTFA]} {
	    if {[OuiOuNonMemo "Do I keep the already existing sequences." 0]} {
		Espionne "I skip $Nom"
		continue
	    }
	}
	#Espionne "I'll create $Nom"

	if {$AddNewSequences && [lsearch -exact $LesExistants $Nom]>=0} {
	  #  set Debut [expr $Fin + 33]
	    continue
	}
	set BonAccess ""

	set TFA [LaSequenceDuTFAs $FichierTFAs $Access]

	set NewWay [OuiOuNonMemo "I'll create sequences from a TFA file \n Are the header lines as follow\n >Access Definition\n >Access Homo sapiens Definition\n >sp|Access|Id Definition\n >sp|Access|Id Homo sapiens Definition\n "]
	
	if {$NewWay} {
	    if {[OnTraiteDesProteines]} {
		set FormatVer "tfa"
		set SeqVer    $TFA
		set ProtEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
		if {$FormatVer=="tfa"} {
		    set ProtTFA  $SeqVer
		    regsub "^>" $ProtTFA ">$Nom " ProtTFA
		} else {
		    set ProtEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
		    set ProtTFA  [SequenceFormatTFA $ProtEMBL "" "embl"]
		}
		Sauve $ProtEMBL dans $FichierProtEMBL
		Sauve $ProtTFA  dans $FichierProtTFA
		if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
		    InformeSansDemander $Nom "Alias: $Access"
		}
	    } else {
		set FormatVer "tfa"
		set SeqVer    $TFA
		set NucEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
		if {$FormatVer=="tfa"} {
		    set NucTFA  $SeqVer
		    regsub "^>" $NucTFA ">$Nom " NucTFA
		} else {
		    set NucEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
		    set NucTFA  [SequenceFormatTFA $NucEMBL "" "embl"]
		}
		Sauve $NucEMBL dans $FichierNucEMBL
		Sauve $NucTFA  dans $FichierNucTFA
		if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
		    InformeSansDemander $Nom "Alias: $Access"
		}
	    }
	} 

	if { !  $NewWay} {
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set Ent [EnteteDuTexteTFA $TFA]
	    regsub {>+} $Ent "" Ent
	    scan $Ent "%s" Access
	    if {[regexp {\|} $Access]} {
		if {$LeBonChamp < 0} {
		    set LesChamps [split $Access "|"] 
		    FaireLire "Please help me to choose the correct access in $Access"
		    set LeBonChamp [ChoixParmiJoli [NombresEntre 0 [expr [llength $LesChamps]-1]] {} $LesChamps]
		    if {$LeBonChamp==""} { set LeBonChamp 999 }
		}
		set BonAccess [lindex $LesChamps $LeBonChamp]
	    } else {
		set BonAccess $Access
	    }
	    set Descr [string trim [StringSuivant " " dans $Ent]]
	    if {$Descr==""} { set Descr $Ent }
	    if {[regexp -nocase {\([a-z0-9_]+\)} $Ent GN]} {
		set GN [string range $GN 1 end-1]
	    } else {
		set GN ""
	    }
	    
	    set LongSeq [string length $Seq]
	    set Seq [SequenceFormatBrut $Seq]
	    
	    
	    if {$BonAccess!=""} {
		AppendAuFichier "$RepertoireDuGenome/fiches/narcisse" "$Nom $BonAccess"
	    }
	    if {([OnTraiteDesNucleotides] || [OnTraiteDesCDS]) &&  (! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA])} {
		set LesLignesEMBL {}
		lappend LesLignesEMBL "ID   $Nom  created by Gscope from a tfas file "
		lappend LesLignesEMBL "AC   $Nom;"
		if {$GN!=""} {
		    lappend LesLignesEMBL "GN   $GN"
		    InformeSansDemander $Nom "ValiGN: $GN"
		}
		set Sep ":"
		foreach Wrap [WrapLeTexte $Descr 50] {
		    lappend LesLignesEMBL "CC   Original description$Sep $Wrap"
		    set Sep "+"
		}
		lappend LesLignesEMBL "SQ   SEQUENCE $LongSeq bases;"
		lappend LesLignesEMBL $Seq
		if {$KeepEntete} { 
		    set Entete "$Nom $Ent"
		} else {
		    set Entete "$Nom $Descr"
		}
		scan $Entete "%s %s" A B
		if {$A==$B} { regsub "$A +" $Entete "" Entete }
		set NucEMBL [join $LesLignesEMBL "\n"]
		Sauve $NucEMBL dans $FichierNucEMBL
		set NucTFA [SequenceFormatTFA $NucEMBL $Entete "embl"]
		Sauve $NucTFA  dans $FichierNucTFA
	    }
	    
	    if {[OnTraiteDesProteines] &&  (! [file exists $FichierProtEMBL] || ! [file exists $FichierProtTFA])} {
		set LesLignesEMBL {}
		lappend LesLignesEMBL "ID   $Nom  created by Gscope from a tfas file "
		lappend LesLignesEMBL "AC   $Nom;"
		if {$GN!=""} {
		    lappend LesLignesEMBL "GN   $GN"
		    InformeSansDemander $Nom "ValiGN: $GN"
		}
		set Sep ":"
		foreach Wrap [WrapLeTexte $Descr 50] {
		    lappend LesLignesEMBL "CC   Original description$Sep $Wrap"
		    set Sep "+"
		}
		if {[OnTraiteDesCDS]} {
		    if { ! [file exists $FichierNucTFA]} { continue }
		    set Seq [SeqNucToSeqPro [QueLaSequenceDuFichierTFA $FichierNucTFA]]
		    set LongSeq [string length $Seq]
		}
		lappend LesLignesEMBL "SQ   SEQUENCE $LongSeq AA;"
		lappend LesLignesEMBL $Seq
		if {$KeepEntete} { 
		    set Entete "$Nom $Ent"
		} else {
		    set Entete "$Nom $Descr"
		}	    
		set ProtEMBL [join $LesLignesEMBL "\n"]
		set ProtTFA [SequenceFormatTFA $ProtEMBL "$Entete" "embl"]
		Sauve $ProtTFA  dans $FichierProtTFA
		Sauve $ProtEMBL dans "$RepertoireDuGenome/protembl/$Nom"
	    }
	}
    }
    SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"

}

proc CreeBornesDesPABsDuFichierSubset {FichierSubset} {

    set LesNoms {}
    foreach Ligne [LesLignesDuFichier $FichierSubset] {
	set Nom ""
	scan $Ligne "%s" Nom
	if { ! [EstUnPAB $Nom]} { continue }
	lappend LesNoms $Nom
    }
    if {$LesNoms=={}} { return "" }

    set OldFin 101
    foreach Nom $LesNoms {
	set FTFA "[RepertoireDuGenome]/prottfa/$Nom"
	set Long [expr [string length [QueLaSequenceDuFichierTFA $FTFA]] * 3]

	set Debut [expr $OldFin + 101]
	set Fin   [expr $Debut+$Long-1]
	lappend LesNouvellesBornes "$Nom $Debut $Fin F"

	set OldFin $Fin
    }

    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    Garde $FichierBornes
    SauveLesLignes $LesNouvellesBornes dans $FichierBornes
    exit

}

proc CreeBornesDesPABsLoc {} {

    global RepertoireDuGenome

    set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"

    set InterChros  1200
    set InterContigs 900
    set InterIlots   300

    set MaxiInterIlots 30

    foreach Loc [LesLignesDuFichier $FichTrD] {
	scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
	set ChroContig "$Chro$Contig"
	if { ! [info exists DejaVu($ChroContig)]} lappend LesChroContig $ChroContig
	lappend LesLocsDu($ChroContig) $Loc
	if { ! [info exists AlphaDu($ChroContig)]} {
	    set OmegaDu($ChroContig) $Fin
	} else {
	    set AlphaDu($ChroContig) [Mini $Debut [set AlphaDu($ChroContig)]]
	    set OmegaDu($ChroContig) [Maxi $Fin   [set OmegaDu($ChroContig)]]
	}
    }
    set Depart 0
    set OldOmega 0
    foreach ChroContig $LesChroContig {
	set LesLocs {}
	set LesDebuts {} 
	set LesFins {}
	foreach Loc [set LesLocsDu($ChroContig)]  {
	    scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
	    lappend LesDebuts $DebutCd
	    lappend LesFins   $FinCd
	    lappend LesLocs   $Loc
	}
	set Alpha [set AlphaDu($ChroContig)]
	set Omega [set OmegaDu($ChroContig)]
	Espionne [expr $Omega - $Alpha]
	foreach Loc $LesLocs {
	    scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
	    set D [expr $Depart+($Debut-$Alpha)]
	    set F [expr $D+$Fin-$Debut]
	    if {$Sens=="+"} { set O "F" } else { set O "R" }
	    Espionne "$Nom $D $F $O"
	    lappend LesBornes "$Nom $D $F $O"
	}

	set OldOmega $Omega
	set RajoutArrondi [expr (($Inter+$Omega-$Alpha+3)/3)*3]
	Espionne "$Depart $OldOmega $Alpha $Omega $RajoutArrondi"
	incr Depart $RajoutArrondi
	set LesLocs {}
	set LesDebuts {} 
	set LesFins {}
    }
    SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs_loc"

}

proc CreeBornesDesPABsPourUneCollection {FOF {RefaireCeNomUniquement ""}} {

    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesPABs
    global InformeSansDemander

    JeMeSignale

    Wup "On peut refaire un nom s'il existe deja. Supprimer les copains et autres."

    if { ! [info exists NarcisseDuAlias]} {
	if {[OuiOuNon "I need help to create Narcisse.\nOnce again, could You browse for a file with 'Access Alias' ?" 0]} {
	    ChargeNarcisseDuAlias
	}
    } 

    set OnEnRajoute 0
    set Conserve 0
    if { [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
	if {[OuiOuNon "$RepertoireDuGenome/fiches/bornesdespabs still exists.\n Do I stop ?"]} {
	    exit
	}
	if { ! [OuiOuNon "Do You want to keep the existing files ?"]} {
	    File rename -force "$RepertoireDuGenome/fiches/bornesdespabs" "$RepertoireDuGenome/fiches/bornesdespabs.old"
	} else {
	    if { ! [OuiOuNon "The new elements have to be at the end of the $FOF ...\nOK ?"]} {
		exit 
	    }
	    set OnEnRajoute 1
	    set Conserve 1
	    if { ! [info exists ListeDesPABs]} { ListeDesPABs }
	}
    }

    if { ! [file exists "$RepertoireDuGenome/msf"]} {
	File mkdir "$RepertoireDuGenome/msf"
    }
    if { ! [file exists "$RepertoireDuGenome/ballast"]} {
	File mkdir "$RepertoireDuGenome/ballast"
    }
    if { ! [file exists "$RepertoireDuGenome/blastp"]} {
	File mkdir "$RepertoireDuGenome/blastp"
    }
    if { ! [file exists "$RepertoireDuGenome/copains"]} {
	File mkdir "$RepertoireDuGenome/copains"
    }
    if { ! [file exists "$RepertoireDuGenome/ver"]} {
	File mkdir "$RepertoireDuGenome/ver"
    }

    set ORF [PreFixe]
    set Numero 0
    if { ! [OuiOuNon "Do I start $ORF numbering with [expr $Numero+1]"]} {
	set Numero [Entre 1]
	incr Numero -1
    }
    set Debut 0
    set Fin [expr $Debut + 900 - 1]
    set Saut 1000
    set Orient "F"
    set LesPABsExistants {}
    if {[info exists ListeDesPABs]} {
	foreach PAB $ListeDesPABs {
	    if {[EstUnPABMute $PAB]} {
		lappend LesMutants($Papa) $PAB 
		continue
	    }
	    lappend LesPABsExistants $PAB
	    set Papa $PAB
	}
    }
    Espionne $LesPABsExistants
    set LesBornes {}
    foreach Ligne [LesLignesDuFichier $FOF] {
	if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
	Espionne $Ligne
	
	set Alias ""
	catch {unset Nom}
	catch {unset Ver}
	catch {unset OrigineBlastP}
	catch {unset OrigineBallast}
	catch {unset OrigineMSF}  
	set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
	if {$NbLus < 2} {
	    set OrigineVer $Alias
	    set Alias ""
	    if {[OuiOuNonMemo "I got some lines with only one word. Do I use the access I'll find as alias. For all ??"]} {
		set TexteVer [ContenuDuFichier $OrigineVer]
		while 1 {
		    if { ! [regexp {^>([^ ]+)}      $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
		    if { ! [regexp {\nAC   ([^;]+)} $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
		}
	    }
	    if {$Alias==""} {
		if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit } 
		continue
	    }
	}
	set Nom [format "%s%[FormatDesNumerosPourCollection]" $ORF [incr Numero]]
#	if {[regexp "^bidonPour" $Alias]} { continue }
	if {[EstUnPAB $Alias] && $Alias==$Nom } { continue }
	if {[EstUnPAB $Alias] && $Alias!=$Nom } {
	    FaireLire "$Alias should be $Nom"
	    continue
	}

	if { [FileExists "[RepertoireDuGenome]/fiches/bornesdespabs"] && [Alias $Nom]!=$Alias} {
	    if {(! [info exists InformeSansDemander] || ! $InformeSansDemander)  && [OuiOuNon "Do I stop asking for Informe ? "]} {
		set InformeSansDemander 1
	    }
	    Informe $Nom "=Alias: $Alias"
	}

	if {$RefaireCeNomUniquement=="$Nom"} {
	    set Refaire 1
	} else {
	    set Refaire 0
	    if {$LesPABsExistants != {} } {
		set PAB [lindex $LesPABsExistants 0]
		set LesPABsExistants [lrange $LesPABsExistants 1 end]
		set GN [NomDeGene $Nom]
		while {$PAB!=$Nom || ($GN!=$PAB && $GN!=$Alias)} {
		    if {[OuiOuNon "$Ligne\n$PAB vs $Nom\n$GN vs $Alias\n don't correspond ... Do I stop ?"]} { exit }
		    if {[OuiOuNon "Do I ignore that Alias $Alias is not GeneName $GN"]} { break }
		    set MemoInformeSansDemander $InformeSansDemander
		    set InformeSansDemander 0
		    Informe $Nom
		    set InformeSansDemander $MemoInformeSansDemander		    
		}
		set Debut  [Box $Nom debut]
		set Fin    [Box $Nom fin]
		set Orient [Box $Nom orient]
		lappend LesBornes "$PAB $Debut $Fin $Orient"
		if {[info exists LesMutants($PAB)]} {
		    foreach PABMut [set LesMutants($PAB)] {
			set Debut  [Box $PABMut debut]
			set Fin    [Box $PABMut fin]
			set Orient [Box $PABMut orient]
			lappend LesBornes "$PABMut $Debut $Fin $Orient"
		    }
		}
		continue
	    }
	}

	if { [info exists SecondMSF] && [file exists $SecondMSF] } {
	    set MSF "$RepertoireDuGenome/msf2/$Nom"
	    if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
		File copy $SecondMSF $MSF
	    }
	}
	if { [info exists OrigineMSF] && [file exists $OrigineMSF] } {
	    set MSF "$RepertoireDuGenome/msf/$Nom"
	    if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
		set LeBeauMSF [StockeLesSequencesEtMaquilleLeMSF $OrigineMSF $Alias $Nom]
		SauveLesLignes $LeBeauMSF dans $MSF
	    }
	}
	if { [info exists OrigineBallast] && [file exists $OrigineBallast] } {
	    set Ballast "$RepertoireDuGenome/ballast/$Nom"
	    if { ! [file exists "$Ballast"] || ! $Conserve || $Refaire} {
		File copy $OrigineBallast $Ballast
	    }
	} 
	if { [info exists OrigineBlastP] && [file exists $OrigineBlastP] } {
	    set BlastP "$RepertoireDuGenome/blastp/$Nom"
	    if { ! [file exists "$BlastP"] || ! $Conserve || $Refaire} {
		File copy $OrigineBlastP $BlastP
	    }
	} 
	if { [info exists OrigineVer] && [file exists $OrigineVer] } {
	    set Ver "$RepertoireDuGenome/ver/$Nom"
	    if { ! [file exists "$Ver"] || ! $Conserve || $Refaire} {
		File copy -force $OrigineVer $Ver
	    }
	} 

	incr Debut $Saut
	incr Fin   $Saut

	Box $Nom nom $Nom
	Box $Nom debut $Debut
	Box $Nom fin $Fin
	Box $Nom orient $Orient
	Box $Nom frame [NomDeLaFrame [expr $Debut%3] $Orient]
	Box $Nom long [expr $Fin-$Debut+1]

	lappend ListeDesPABs  $Nom
	lappend ListeDeBoites $Nom
	lappend LesBornes "$Nom $Debut $Fin F"

	if {[regexp "thetase" "$RepertoireDuGenome"]} {
	    set AA3 [AADuNomDuFichier [file tail $OrigineMSF] "SansAlias"]
	    Informe $Nom "=ValiGN: ${AA3}rs"
	}
	if {[regexp "/NR$" "$RepertoireDuGenome"]} {
	    Informe $Nom "=ValiGN: $Alias"
	}
	if {[regexp "nag" "$RepertoireDuGenome"]} {
	    Informe $Nom "=ValiGN: $Alias"
	}
	if {[regexp "tfiih" "$RepertoireDuGenome"]} {
	    Informe $Nom "=ValiGN: $Alias"
	}
#	if {$RefaireCeNomUniquement==$Nom} { exit }
        Espionne fin
    }
    SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"

}

proc CreeBornesDesPABsTroisGradins {Premier Dernier {Prefixe ""} {Long ""} {Start ""} {FNum ""}} {


    if {$Prefixe==""} { set Prefixe [PreFixe] }
    if {$Long==""}    { set Long    601 }
    if {$Start==""}   { set Start   99 }

    set OldFin $Start

    if {$FNum==""} { set FNum [FormatDesNumerosPourCollectionDuProjet] }

    foreach N [NombresEntre $Premier $Dernier] {
	set Nom [format "%s$FNum" $Prefixe $N]
	set Debut [expr $OldFin + 10]
	set Fin   [expr $Debut+$Long-1]
	lappend LesNouvellesBornes "$Nom $Debut $Fin F"

	set OldFin $Fin
    }
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    Garde $FichierBornes
    return [SauveLesLignes $LesNouvellesBornes dans $FichierBornes]
 

}

proc CreeChangeCodonStart {Nom} {

    set CSP [ExtraitInfo $Nom "CSP"]
    if { ! [regexp {^[MVL]} $CSP AA]} { return "" }
    set PositionAA [IntegerApres $AA dans $CSP]
    if {$PositionAA==""} { return "" }
    if {$PositionAA==0} {
	set Message "$Nom 0 que faire pour $CSP"
	FaireLire $Message
	return ""
    }
    if {$PositionAA==1} {
	return ""
    }
    if {$PositionAA>0} {
	set SeqNuc [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"]
	set SeqProOfNuc [SeqNucToSeqPro $SeqNuc]
	set SeqPro [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	if { ! [string equal -nocase $SeqProOfNuc $SeqPro]} {
	    FaireLire "The translated sequence doen't correspond to prottfa/$Nom"
	}
	set SeqEnPos [string range $SeqPro [expr $PositionAA-1] [expr $PositionAA+8]]
	if {[string index $SeqEnPos 0]!=$AA} {
	    set Message "$AA doesn't begin $SeqEnPos please modify the info file for $Nom\n$CSP" 
	    FaireLire $Message
	    Informe $Nom
	    if {[OuiOuNon "Do I rerun the test ?"]} { return [CreeChangeCodonStart $Nom] }
	}
	set PositionD [expr ($PositionAA-1)*3]
	set PositionF [expr $PositionD+2]
	set Codon [string range $SeqNuc $PositionD $PositionF]
	if { ! [CodonStartPossible $Codon]} {
	    set Message "for $Nom I'm sorry; $Codon is not a possible start codon\n$CSP\n$SeqEnPos"
	    FaireLire $Message
	    Espionne $Message
	}
	set OldPosRel [expr -$PositionAA + 1]
	set OldAA [string index $SeqPro 0]
	set TexteInfo "=CutCodonStart: The cutted start was $OldAA $OldPosRel from [string range $SeqPro 0 9] "
	InformeSansDemander $Nom $TexteInfo
    } else {
	Espionne "Je rallonge  $Nom a $AA $PositionAA car $CSP" 
    }

}

proc CreeChangeCodonStartPourTous {} {

    foreach Nom [ListeDesPABs] {
	if {[Fantome $Nom]} {continue}
	CreeChangeCodonStart $Nom
    }

}

proc CreeClasseDesOrganismes {} {

    global RepertoireDuGenome

    foreach Organisme [Glossaire Bidon Index] {
	regsub "_" $Organisme " " Organisme
	set Classe [OCduOS $Organisme]
	if {$Classe=="ClassUnknown" && [regexp -nocase virus $Organisme]} { set Classe "Virus" }
	lappend Sortie "$Organisme $Classe"
    }
    Espionne [SauveLesLignes $Sortie dans glossaire.classes.arenommer]

}

proc CreeCompletTFAavecADN {{Extension ""}} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global FichierSequenceADN
    set NotreOS [NotreOS]

    if { $Extension!=""} { catch {unset ADN} ; catch {unset TDN} ; catch {unset RAC} }
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC $Extension}

    set NomDeLaBete "$NotreOS"
    regsub " "  $NomDeLaBete "_" NomDeLaBete 
    regsub {\.} $NomDeLaBete ""  NomDeLaBete 

    set Long [string length [string range $ADN 1 end]]

    set Entete ">$NomDeLaBete Genome complet.$Extension $Long BP"
    set Fichier [string tolower "$NomDeLaBete.tfa$Extension"]

    set TFA [SequenceFormatBrut [string range $ADN 1 end]]
    set NomDuFichierCompletTFA "$RepertoireDuGenome/beton/$Fichier"
    set NomDuFichierCompletTFA [Sauve "$Entete\n$TFA" dans "$RepertoireDuGenome/beton/$Fichier"]
    if {$Extension==""} {
	set FichierMiniConfig "$RepertoireDuGenome/beton/miniconfig"
	set LesNommes {}
	foreach Ligne [LesLignesDuFichier "$FichierMiniConfig"] {
	    if { ! [regexp "FichierSequenceADN" $Ligne]} {
		lappend LesNommes $Ligne
	    } else {
		lappend LesNommes "FichierSequenceADN $NomDuFichierCompletTFA"
	    }
	}
	SauveLesLignes $LesNommes dans $FichierMiniConfig
	set FichierSequenceADN $NomDuFichierCompletTFA
    }

    return $NomDuFichierCompletTFA

}

proc CreeCorrespondanceAvecGlimmer {{FichierCoGlimmer ""}} {

    global RepertoireDuGenome
    global LesORFsEnOverlap
    global ListeDeBoites

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    if {$FichierCoGlimmer==""} { set FichierCoGlimmer "$RepertoireDuGenome/fiches/coglimmer" }

    foreach Boite [concat [ListeDesGLIMMERs] [ListeDesPABs]] {
  	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]
	if {[regexp "GLIMMER" $Nom]} {
	    set GLI($Debut,$Fin,$Orient) $Nom
	}
	if {[YaPABenDebutDe $Nom]} {
	    set PAB($Debut,$Fin,$Orient) $Nom
	}
    }
    CalculeLesORFsEnOverlap "AvecGLIMMER"
    Espionne "debut array get LesORFsEnOverlap"
    EspionneL [array get LesORFsEnOverlap]
    Espionne "fin array get LesORFsEnOverlap"
    set Sortie {}
    FaireLire "coucou"
    foreach Boite [concat [ListeDesGLIMMERs] [ListeDesPABs]] {
  	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]
	Espionne $Nom
	if {[regexp "GLIMMER" $Nom]} {
	    if {[info exists PAB($Debut,$Fin,$Orient)]} {
		lappend Sortie "$Nom is [set PAB($Debut,$Fin,$Orient)]"
	    } else {
		Espionne "$Nom,$Debut,$Fin,$Orient"
		if {[info exists LesORFsEnOverlap($Nom)]} {
		    set Touches {}
		    foreach Over [set LesORFsEnOverlap($Nom)] {
			if { ! [YaPABenDebutDe $Over]} { continue }
			if {$Orient != [Box $Over orient]} { continue }
			if {[expr [Box $Over debut]%3] != [expr $Debut%3]} { continue }
			lappend Touches "$Over"
		    }
		    if {$Touches!={}} { lappend Sortie "$Nom touches [join $Touches " "]" }
		}
	    }
	}
	if {[YaPABenDebutDe $Nom]} {
	    if {[info exists GLI($Debut,$Fin,$Orient)]} {
		lappend Sortie "$Nom is [set GLI($Debut,$Fin,$Orient)]"
	    } else {
		Espionne "$Nom,$Debut,$Fin,$Orient"
		if {[info exists LesORFsEnOverlap($Nom)]} {
		    set Touches {}
		    foreach Over [set LesORFsEnOverlap($Nom)] {
			if { ! [regexp "GLIMMER" $Over]} { continue }
			if {$Orient != [Box $Over orient]} { continue }
			if {[expr [Box $Over debut]%3 != $Debut%3]} { continue }
			lappend Touches "$Over"
		    }
		    if {$Touches!={}} { lappend Sortie "$Nom overlaps [join $Touches " "]" }
		}
	    }
	}
    }
    catch {unset LesORFsEnOverlap}
    return [SauveLesLignes $Sortie dans $FichierCoGlimmer]

}

proc CreeDistancesPhyloAvecLesMSFs {{ReferenceVoulue ""} {Extension ""}} {

    global RepertoireDuGenome
    global ListeDesPABs
    global NotreOS

    if {$ReferenceVoulue == ""} { set ReferenceVoulue [Glossaire $NotreOS Court] } 
    if {$Extension == ""} { set Extension ".$ReferenceVoulue" } 

    set ReferenceVoulue [string toupper $ReferenceVoulue]

    if { ! [info exists ListeDesPABs]}  { ChargeLesPABs }

    set KeepDisphy 1
    set SauveDansDisphy 1
    set NotreOsEstLaReference 0
    if {[string toupper $ReferenceVoulue] == [string toupper [Glossaire $NotreOS Court]]} {
	set NotreOsEstLaReference 1
	set DisphyDir "$RepertoireDuGenome/disphy"
	if { ! [file exists $DisphyDir]} { File mkdir $DisphyDir }
	set SauveDansDisphy 1 
	if {[llength [glob -nocomplain "$DisphyDir/*"]] > 0} {
	    set KeepDisphy [OuiOuNon "Some files already exist in $DisphyDir\nDo I keep them ? "]
	}
    }

    set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo$Extension"
    while {[file exists $FichierDistancesPhylo]} {
	if {[OuiOuNon "$FichierDistancesPhylo\n  already exists. Do I replace it ? " 0]} {
	    File delete $FichierDistancesPhylo
	} else {
	    if {[OuiOuNon "Do I append to it ? "]} {
		foreach Ligne [LesLignesDuFichier $FichierDistancesPhylo] {
		    scan $Ligne "%s" Nom
		    set DejaVu($Nom) 1
		}
		break
	    } else {
		if {[OuiOuNon "Do I cancel ? "]} { return "" }
	    }
	}
    }
    
    foreach Nom $ListeDesPABs {
	Espionne $Nom
	if {[info exists DejaVu($Nom)]} { continue }
	set FichierPhylo  "$RepertoireDuGenome/phylos/$Nom"
	set FichierDisphy "$RepertoireDuGenome/disphy/$Nom"
	Wup "On peut ne pas avoir cree les fichiers phylos, alors on le fait ici."
	if { ! [file exists $FichierPhylo]} {
	    Espionne "Creation de phylo pour $Nom"
	    Wup "J'en cree qu'un, pas plusieurs ..."
	    CreeLesFichiersPhylos $Nom
	}
	if { ! [file exists $FichierPhylo]} {
	    Warne "$FichierPhylo couldn't be created"
	    continue
	}
	
	if {$NotreOsEstLaReference} {
	    set Reference $Nom
	} else {
	    set Reference [TrouveLaReferenceVoulue $ReferenceVoulue $FichierPhylo]
	}


	if {$KeepDisphy && $NotreOsEstLaReference && [file exists $FichierDisphy]} {
	    set ListeTriee [LesLignesDuFichier $FichierDisphy]
	} else {
	    set ListeTriee [ListeTrieeDesDistancesPhylos $Nom $Reference]
	    if {$SauveDansDisphy} {
		if { ! [file exists $FichierDisphy] || ! $KeepDisphy } {
		    Espionne "Creation de disphy pour $Nom"
		    SauveLesLignes $ListeTriee dans "$RepertoireDuGenome/disphy/$Nom"
		}
	    }
	}
#	lappend Sortie "$Nom [join $ListeTriee " "]"
	AppendAuFichier $FichierDistancesPhylo "$Nom [join $ListeTriee " "]"
    }
    return $FichierDistancesPhylo

}

proc CreeECcommun {} {

    #rR ne sert pas car on peut utiliser ParseAnnotationXml
    exit
    set Rep "[RepertoireDuGenome]/annotation"
    set LaSortie {}
    foreach Nom [ListeDesPABs] {
	set FichierXml "$Rep/$Nom.xml"
	if {[FileAbsent $FichierXml]} { continue }
	Espionne $FichierXml
	lappend LaSortie ">$Nom"
	set Commun "None"
	set LesClasses {}
	foreach Ligne [LesLignesDuFichier $FichierXml] {
	    if { [regexp {([^<]+)} $Ligne Match Cl]} { set Commun "EC $Cl"; continue }
	    if { [regexp "" $Ligne]} { break }
	    if { [regexp {]*>([^<]+)} $Ligne Match Number Name]} {
		lappend LaSortie "$Number $Name"
	    }
	}
	lappend LaSortie "commun: $Commun"
	lappend LaSortie ""

    }
    return [SauveLesLignes $LaSortie dans "[RepertoireDuGenome]/fiches/ECcommun.new"]

}

proc CreeEmpreinte {file query best} {

    
    set fileMSF  "$file.best.msf"
    set fileOut  "$file.empreinte"
    set msf2tfa  "/home/moumou/bin/msf2tfa"
    set tfa2msf  "/home/moumou/bin/tfa2msf"
    
    if {! [file exists $fileMSF]} {return 0}
        
    DecortiqueUnMSF $fileMSF LesNoms Sequences
    if { [string first ":" $query] != -1 } {
	regsub -all ":" $query "_" query
    }
    
    set best [EnlevePrefixeBank $best]
      
    set seqQuery [set Sequences($query)]
    set seqBest  [set Sequences($best)]

    regsub -all {\.} $seqQuery "-" seqQuery
    regsub -all {\.} $seqBest "-" seqBest
    
    set f [open $fileOut w]
    puts $f "pdb = $best"
    puts $f "query = $seqQuery"
    puts $f "template = $seqBest"
    close $f
    
    return 1

}

proc CreeEmpreintePipe {pab query} {

    
    global DefautsPipe
    global PipeCollection
    global lBestPdb
    
    if {$PipeCollection} {
	set fileMSF [file join [RepertoireDuGenome] "empreinte" $pab.msf]
    } else {
	set fileMSF "[file rootname $pab].best.msf"
    }
    
    if {! [file exists $fileMSF]} {return 0}
    
    DecortiqueUnMSF $fileMSF LesNoms Sequences
    if { [string first ":" $query] != -1 } {
	regsub -all ":" $query "_" query
    }
    
    set i 0
    foreach best $lBestPdb {
	incr i
	if {$PipeCollection} {
	    set fileOut [file join [RepertoireDuGenome] "empreinte" ${pab}_$i.empreinte]
	} else {
	    set fileOut "[file rootname $pab]_$i.empreinte"
	}

	set seqQuery [set Sequences($query)]
	set seqBest  [set Sequences($best)]
	
	regsub -all {\.} $seqQuery "-" seqQuery
	regsub -all {\.} $seqBest "-" seqBest
	
	set f [open $fileOut w]
	puts $f "pdb = $best"
	puts $f "query = $seqQuery"
	puts $f "template = $seqBest"
	close $f
    }
    
    return 1

}

proc CreeEnsemblMouseJunctionAndHumanJunctionBank {} {

    #apartir des fichiers ensGene, ex ac pax2
    #cree un fichier fasta pour chaque jonction souris et un seul fichier fasta pour toutes les jonctions humaines
    set FileEnsemblMouse "/genomics/link/UCSCGenomes/Mus_musculus/database/mm9/last/ensGene.txt"
    set FileEnsemblHuman "/genomics/link/UCSCGenomes/Homo_sapiens/database/hg19/last/ensGene.txt"
    set ListeVarMouse [InterrogeRefGeneOuEnsGeneUcsc ENSMUSG00000004231 Name $FileEnsemblMouse]
    set ListeVarHuman [InterrogeRefGeneOuEnsGeneUcsc ENSG00000075891 Name $FileEnsemblHuman]
   
    foreach VarMouse $ListeVarMouse {
	set Chr [InterrogeRefGeneOuEnsGeneUcsc $VarMouse chrom $FileEnsemblMouse]
	
	set Start [InterrogeRefGeneOuEnsGeneUcsc $VarMouse exonStarts $FileEnsemblMouse]
	set Start [string range $Start 0 end-1]
	set LesStart [split $Start ","]

	set Stop  [InterrogeRefGeneOuEnsGeneUcsc $VarMouse exonEnds $FileEnsemblMouse]
	set Stop  [string range $Stop 0 end-1]
	set LesStop  [split $Stop ","]

	for {set i 0} {$i<[expr [llength $LesStop]-1]} {incr i} {
	    #attention: numerote les junctions a partir de 0
	    set JunctionsIndMouse {}
	    set StopJunc [lindex $LesStop $i]
	    set j [expr $i+1];
	    set StartJunc [lindex $LesStart $j]
	    set StartJunc [expr $StartJunc + 1]
	    #prends toujours le sens +
	    set seq1 [BoutADNDeUcsc [expr $StopJunc - 49] $StopJunc F Mus_musculus $Chr bigZips200707]
	    set seq2 [BoutADNDeUcsc $StartJunc [expr $StartJunc + 49] F Mus_musculus $Chr bigZips200707]
	    set seq "${seq1}$seq2"
	    lappend JunctionsIndMouse ">${VarMouse}_$i"
	    lappend JunctionsIndMouse "$seq"
	    SauveLesLignes $JunctionsIndMouse dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/Pax2/${VarMouse}_$i"
	}
    }

    foreach VarHuman $ListeVarHuman {
	set Chr [InterrogeRefGeneOuEnsGeneUcsc $VarHuman chrom $FileEnsemblHuman]
	
	set Start [InterrogeRefGeneOuEnsGeneUcsc $VarHuman exonStarts $FileEnsemblHuman]
	set Start [string range $Start 0 end-1]
	set LesStart [split $Start ","]

	set Stop  [InterrogeRefGeneOuEnsGeneUcsc $VarHuman exonEnds $FileEnsemblHuman]
	set Stop  [string range $Stop 0 end-1]
	set LesStop  [split $Stop ","]

	for {set i 0} {$i<[expr [llength $LesStop]-1]} {incr i} {
	    #attention: numerote les junctions a partir de 0
	    set StopJunc [lindex $LesStop $i]
	    set j [expr $i+1];
	    set StartJunc [lindex $LesStart $j]
	    set StartJunc [expr $StartJunc + 1]
	    #prends toujours le sens +
	    set seq1 [BoutADNDeUcsc [expr $StopJunc - 49] $StopJunc F Homo_sapiens $Chr bigZips200903]
	    set seq2 [BoutADNDeUcsc $StartJunc [expr $StartJunc + 49] F Homo_sapiens $Chr bigZips200903]
	    set seq "${seq1}$seq2"
	    lappend JunctionsHuman ">${VarHuman}_$i"
	    lappend JunctionsHuman "$seq"
	}
    }
    SauveLesLignes $JunctionsHuman dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/Pax2/JunctionsHumanPax2"

}

proc CreeEtAfficheUnBilanHDACroises {Selection {Option ""}} {

    global RepertoireDuGenome
    set Liste {}
    foreach Ligne [split $Selection "\n"] {
	scan $Ligne "%s" Nom
	lappend Liste $Nom
    }
    if {$Liste=={}} { return "" }


    set FichierBilan "[TmpFile].bilan"
    set FichierBilan [CreeUnBilanHDACroises $Liste $FichierBilan]
    #Jean a rajouter Option et le if
    if {$Option=="AvecTri"} { return [ShowHDACroises $FichierBilan "Delete" "AvecTri"] }

    return [ShowHDACroises $FichierBilan "Delete"]  

}

proc CreeExpo {E} {

    global ExpoCourante

    Warne "Creation de l'expo $E"

    toplevel $E
    button $E.cloture  -text "Cloture" -background green -command "ClosExpoCourante" 
    button $E.dismiss  -text "Dismiss" -background red   -command "ClosExpoCourante; destroy $E"

    pack $E.cloture -side top -fill x
    pack $E.dismiss -side top -fill x

}

proc CreeExtendCodonStart {Nom} {

    
    Wup "Uses 'CSP: Met de MTVFS' from the info file"
    Wup " creates 'CSP: M -18 issu de Met de MTVFS"
    Wup " then "


    set CSP [ExtraitInfo $Nom "CSP"]
    if {[regexp -nocase "^(Ok )?(Met|Leu|Val) de " $CSP Match]} {
	regexp -nocase {(Met|Leu|Val)} $Match S3
	set S [UT $S3]
	set Seq [string toupper [StringApres $Match dans $CSP]]
	set D [Box $Nom debut]
	set F [Box $Nom fin]
	set O [Box $Nom orient]
	set ExtensionMaxAA 600
	if {$O=="F"} {
	    set DE [expr $D-$ExtensionMaxAA*3]
	    set FE $F
	} else {
	    set DE $D
	    set FE [expr $F+$ExtensionMaxAA*3]
	}
	set SeqNucEtendue [BoutADN $DE $FE $O]
	set SeqProEtendue [SeqNucToSeqPro $SeqNucEtendue]
	set  PosAAEtendue [string first $Seq $SeqProEtendue]
	if {$PosAAEtendue>0} {
	    set  PosAA [expr -($ExtensionMaxAA-$PosAAEtendue)]
	    if {$S!=[string index $Seq 0]} { FaireLire "$Nom $S $PosAA issu de $CSP" } 
	    TextePourInforme "=CSP: $S $PosAA issu de $CSP" 
	    Informe $Nom $TextePourInforme
	    Espionne $TextePourInforme
	    return $TextePourInforme
	} else {
	    set MessageErreur "I can't find the sequence $Seq upstream $Nom"
	    if {[OuiOuNon "$MessageErreur\nDo you want to see the info file ?"]} {
		set OldInfo [ExtraitInfo $Nom]
		Informe $Nom
		if {$OldInfo!=[ExtraitInfo $Nom]  && [OuiOuNon "Do I use this mofification ?"]} {
		    return [CreeExtendCodonStart $Nom]
		}
		return $MessageErreur
	    }
	}
    }

}

proc CreeExtendCodonStartPourTous {} {

    foreach Nom [ListeDesPABs] {
	if {[Fantome $Nom]} {continue}
	CreeExtendCodonStart $Nom
    }

}

proc CreeFOF {{Rep ""}} {

    set Projet [file tail [RepertoireDuGenome]]
    if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" }
    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	if {$Alias==""} { set Alias $Nom }
	set Source "$Rep/$Nom"
	lappend LeFOF "$Alias $Source"
    }
    return [SauveLesLignes $LeFOF dans "[RepertoireDuGenome]/$Projet.fof"]

}

proc CreeFastaDesSeqMacsims {} {

    set RepertoireSortie "[RepertoireDuGenome]/FastaMacsims"
    if {! [file exists $RepertoireSortie]} {file mkdir $RepertoireSortie}
    foreach Box [ListeDesPABs] {
	set LesNamesMacsims {}; set LesLignes {}
	if {[regexp -nocase "Mouse" [RepertoireDuGenome]] || [regexp -nocase "Rat" [RepertoireDuGenome]]} {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"}
	} else {
	    set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit"
	    if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit"}
	}
	
	set fh [open $FileMacsims "r"]
	dom parse -channel $fh doc
	close $fh
	$doc documentElement root	
	foreach seq [$root selectNodes "//sequence"] {
	    lappend LesNamesMacsims [$seq selectNodes "string(./seq-name)"]
	}
	$doc delete

	foreach NameMacsims $LesNamesMacsims {
	    set SeqSsGap [FromMacsims $FileMacsims $NameMacsims SeqDataSansGap]
	    set LigneTete ">$NameMacsims"
	    set LigneSeq "$SeqSsGap"
	    #quand la sequence ne commence pas par une Met, WolfPsort plante
	    if {![regexp -nocase "^m" $SeqSsGap]} {
		set SeqSsGap "m$SeqSsGap"
		set LigneSeq "$SeqSsGap"
	    }
	    lappend LesLignes $LigneTete
	    lappend LesLignes $LigneSeq
	}
	SauveLesLignes $LesLignes dans "$RepertoireSortie/$Box"
    }

}

proc CreeFeaturesMethod {ft} {

    global Couleurs ListeTypesDeFeatures SDG TabSF ConsMeth ScoreMeth Defauts ListePDB

    if {$ft ni $ListeTypesDeFeatures} {
	lappend ListeTypesDeFeatures $ft
    }

    set s 0.0
    set note ""
    foreach {t v} [array get ConsMeth] {
	if {$t eq "IdenGlob"} {
	    lassign [set Couleurs($t)] tmp c 
	    set g "GroupeToutLeMonde"
	} elseif {$t eq "ConsGlob"} {
	    lassign [set Couleurs($t)] tmp c 
	    set g "GroupeToutLeMonde"
	} else {
	    set i [string range $t 5 end]
	    set c [CouleurO2Ordali [CouleurDuGroupe $i]]
	    set g $t
	}

	set note $t
	foreach e $v {
	    set s [set ScoreMeth($ft,$g,$e)]
	    
	    # Up to here, all conservation is done 
	    # with columns starting at 1 (historical)
	    # Here we come back to numbering starting
	    # at 0
	    incr e -1

	    set nl [list "fstart" $e "fstop" $e "fcolor" $c "fscore" $s "fnote" $note "fcsys" "global"]
	    foreach n [set SDG($g)] {
		if {$n in $ListePDB && ! [set Defauts(PDBDansPilier)]} {continue}
		lappend TabSF($n,$ft) $nl
	    }
	}
    }

    set ScoreMeth($ft,Edit) 0

    return

}

proc CreeFeaturesOrdali {{OGlob 0}} {

    global ListeTypesDeFeatures NomTextSeq SDG TableauCouleurEtGroupe ScoreMeth Couleurs Threshold LNDG TabSF Defauts ListePDB

    if {! [info exists ListeTypesDeFeatures]} {
	set ListeTypesDeFeatures {}
    }

    set ft "tmpCons-T$Threshold"
    set ic [lsearch -all -regexp $ListeTypesDeFeatures "^$ft"]
    set nmax 1
    foreach i $ic {
	set f [lindex $ListeTypesDeFeatures $i]
	set n [string range $f [expr {[string last "_" $f]+1}] end]
	if {$n > $nmax} {set nmax $n}
    }
    if {$nmax > 1} {
	set ft "${ft}_$nmax"
    }
    lappend ListeTypesDeFeatures $ft

    set LesVals [array get TableauCouleurEtGroupe]

    foreach {v b} $LesVals {
	lassign [split $v ,] r Grp 
	
	# if only global conservation is required
	if {$OGlob && $Grp ne "GroupeToutLeMonde"} {
	    continue
	}

	if {$Grp eq "grise" || $Grp eq "bidon"} {
	    continue
	}

	set start $r
	set stop $r
	set score 0.0
	set note $b
	if {[regexp {^CoulG} $b]} {
	    set n [string range $b 5 end]
	    set col [CouleurO2Ordali [CouleurDuGroupe $n]]
	} else {
	    lassign [set Couleurs($b)] f col 
	}
	set csys "global"

	set nl [list "fstart" $start "fstop" $stop "fcolor" $col "fscore" $score "fnote" $note "fcsys" $csys]

	foreach n [set SDG($Grp)] {
	    if {$n in $ListePDB && ! [set Defauts(PDBDansPilier)]} {continue}
	    lappend TabSF($n,$ft) $nl
	}
    }

    set ScoreMeth($ft,Edit) 0
    set ScoreMeth($ft,ListeGrps) $::LNDG
puts "CreeFeatureOrdali $ft"
    return $ft

}

proc CreeFeaturesScore {idn g l1 l2} {

    global ListeTypesDeFeatures LNDG NomTextSeq SDG Couleurs TabSF

    if {! [ModeI]} {return}

    set idn [string toupper $idn]
    if {$idn ni $ListeTypesDeFeatures} {
	lappend ListeTypesDeFeatures $idn
    }

    set s 0.0
    set t ""
    set tag2 ""
    set c2 ""
    if {$g == ""} {
	set g "GroupeToutLeMonde"
	set tag  "IdenGlob"
	set tag2 "ConsGlob"
	set c2 [$NomTextSeq tag cget ${tag2} -background]
    } else {
	set i [lsearch $LNDG $g]
	set tag "CoulG$i"
    }
    set c [$NomTextSeq tag cget $tag -background]

    foreach n [set SDG($g)] {
	foreach e $l1 {
	    set d $e
	    set f $e
	    set nl [list $d $f $c $s $t]
	    lappend TabSF($n,$idn) $nl
	}
	if {$tag2 ne ""} {
	    foreach e $l2 {
		set d $e
		set f $e
		set nl [list $d $f ${c2} $s $t]
		lappend TabSF($n,$idn) $nl
	    }
	}
    }

    return

}

proc CreeFichierAvecFoldChangeAffyFromAnne {} {

    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/pourgscope_fromAnne"] {
	set fc [lindex $Ligne 5]
	set CodeAffy [lindex $Ligne 0]
	set Fold($CodeAffy) $fc
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapEtProfils"] {
	set DD [lindex $Ligne 0]
	set TAR [lindex $Ligne 1]
	set CAffy [lindex $Ligne 2]
	set PDD [lindex $Ligne 3]
	set PAffy [lindex $Ligne 4]
	if {[info exists Fold($CAffy)]} {
	    lappend L "$DD\t$TAR\t$CAffy\t$PDD\t$Fold($CAffy)\t$PAffy"
	} else {
	    lappend L "$DD\t$TAR\t$CAffy\t$PDD\t \t$PAffy"
	}
    }
    SauveLesLignes $L dans "[RepertoireDuGenome]/OverlapEtProfilsEtFold"

}

proc CreeFichierAvecJumeauxTemporaire {FichierEntree FichierJum FichierSortie} {

    foreach Ligne [LesLignesDuFichier $FichierEntree] {
	if {$Ligne==""} {continue}
	set AChercher [lindex [split $Ligne " "] [expr [llength [split $Ligne " "]] -1]]
	set Vu($AChercher) 1
	set LigneSansDernier [lreplace [split $Ligne " "] [expr [llength [split $Ligne " "]] -1] [expr [llength [split $Ligne " "]] -1]]
	set LL($AChercher) $LigneSansDernier
    }
    set L 0
    foreach Ligne [LesLignesDuFichier $FichierJum] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Jumeau $LesJumeaux {
	    if {[info exists Vu($Jumeau)] && [lindex $LesJumeaux 0]==$Jumeau} {
		set NewL [concat $LL($Jumeau) $Ligne]; lappend Liste $NewL; set VuJumeau($Jumeau) 1;break
	    }
	}
    }
    foreach Ligne [LesLignesDuFichier $FichierEntree] {
	if {$Ligne==""} {continue}
	set AChercher [lindex [split $Ligne " "] [expr [llength [split $Ligne " "]] -1]]
	if {![info exists VuJumeau($AChercher)]} {lappend Liste $Ligne}
    }
    SauveLesLignes $Liste dans $FichierSortie

}

proc CreeFichierAvecJumeauxTemporaire_quad {FichierEntree FichierJum FichierSortie} {

    foreach Ligne [LesLignesDuFichier $FichierJum] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	set JR [lindex $LesJumeaux 0]
	set Vu($JR) 1
	set LL($JR) $LesJumeaux
    }
    foreach Ligne [LesLignesDuFichier $FichierEntree] {
	#un seul elt de la ligne peut avoir des jumeaux...NON!plusieurs!
	if {$Ligne==""} {continue}
	Espionne "nouvelle ligne: $Ligne"
	set LesElts [split $Ligne " "]
	set NewLigne $LesElts
	set i 0; set New 0
	foreach Elt $LesElts {
	    if {$Elt=="DD0046"} {Espionne $Elt}
	    if {[info exists Vu($Elt)]} {
		Espionne "index de celui qui a des jumeaux: $i"
		set New 1
		#set Ljum [split $LL($Elt) " "]
		set Ljum $LL($Elt)
		set LongLjum [llength $Ljum]
		Espionne "longueur liste jr + jum:  $LongLjum"
		set NewLigne [lreplace $NewLigne $i $i $Ljum]
		#if {$i==0} {incr i}
		set i [expr $i + $LongLjum]
		Espionne "index suivant: $i"
		set NewLigne [join $NewLigne " "]
		set NewLigne [split $NewLigne " "]
	    } else {incr i}
	}
	if {$New==1} {
	    #set NewLigne [join $NewLigne " "]
	    #set NewLigne [split $NewLigne " "]

	    lappend Liste $NewLigne
	    Espionne "l nouvelle ligne: [llength $NewLigne]"
	    Espionne $NewLigne
	    #FaireLire "fin ligne"
	} else {lappend Liste $LesElts}
    }
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans $FichierSortie

}

proc CreeFichierAvecJumeauxTemporaire_ter {FichierEntree FichierJum FichierSortie} {

    foreach Ligne [LesLignesDuFichier $FichierJum] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	set JR [lindex $LesJumeaux 0]
	set Vu($JR) 1
	set LL($JR) $LesJumeaux
    }
    foreach Ligne [LesLignesDuFichier $FichierEntree] {
	#un seul elt de la ligne peut avoir des jumeaux...
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne " "]
	set NewLigne ""
	set i 0
	foreach Elt $LesElts {
	    #lreplace $NewLigne -remplace par- lreplace $LesElts
	    if {[info exists Vu($Elt)]} {set NewLigne [lreplace $LesElts $i $i $LL($Elt)]}
	    incr i
	}
	if {$NewLigne!=""} {lappend Liste $NewLigne} else {lappend Liste $LesElts}
    }
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans $FichierSortie

}

proc CreeFichierBestLocalisation_Human {} {

    foreach Nom [ListeDesPABs] {
	set pasdeloc 0
	set LocUcsc [ExtraitInfo $Nom "Localisation:"]
	set CytoBand [ExtraitInfo $Nom "Cytoband:"]
	if {$LocUcsc=="nolocalisation"} {
	    set pasdeloc 1
	    set Ligne "$Nom\tNoLoc\t\t\t\t\t\t\t\tno_value\tno_value\tno_value\tno_value\t\t\t\t\t\t\tno_value\tBestLoc\t"
	    lappend LesLignes $Ligne
	    continue
	}

	set LesMots [split $LocUcsc {:\(\) }]
	set chr    [lindex $LesMots 0]
	set start  [lindex $LesMots 1]
	set stop   [lindex $LesMots 2]
	set strand [lindex $LesMots 3]
	
	if {!$pasdeloc && $CytoBand=="nocytoband"} {
	    set Ligne "$Nom\tMonoLoc\t\t\t\t\t\t\t\t$chr\t$start\t$stop\t$strand\t\t\t\t\t\t\tno_value\tBestLoc\t"
	    lappend LesLignes $Ligne
	    continue
	}
	set Ligne "$Nom\tMonoLoc\t\t\t\t\t\t\t\t$chr\t$start\t$stop\t$strand\t\t\t\t\t\t\t$CytoBand\tBestLoc\t"
	lappend LesLignes $Ligne
    }
    SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" 

}

proc CreeFichierClustersNew {} {

    #en fait fichier clusters! selon jumeaux.
    #Les 987 sont places devant.
    #Attention: l'overlap va reveler de nouveaux jumeaux, clustersnew change donc.
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ListeDesPABsNew"] {
	set DD [lindex $Ligne 0]
	set Vu($DD) 1
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/Jumeaux/TousLesJumeaux.final"] {
	set L [split $Ligne " "]
	set i 0
	foreach Nom $L {
	    if {[info exists Vu($Nom)]} {
		set LSansNom [lreplace $L $i $i]
		set LAvecNomDevant [concat $Nom $LSansNom]
		lappend LesDDEtLeursJumeaux $LAvecNomDevant
		set ReVu($Nom) 1
		break
	    }
	    incr i
	}
    }
    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ListeDesPABsNew"] {
	set DD [lindex $Ligne 0]
	if {![info exists ReVu($DD)]} {
	    incr n
	    lappend LesDDEtLeursJumeaux $DD
	}
    }
    Espionne $n
    Espionne [llength $LesDDEtLeursJumeaux]
    set LesDDEtLeursJumeaux [lsort $LesDDEtLeursJumeaux]
    SauveLesLignes $LesDDEtLeursJumeaux dans "[RepertoireDuGenome]/fiches/ClustersNew"

}

proc CreeFichierCompletDesPFAMUniques {} {

    #more Domaines | gr PFAM | grep PF | gr -v PB | grep "1\.0" | wc
    foreach Nom [ListeDesPABs] {
	set Vu($Nom) 1
    }

    set Fichier "[RepertoireDuGenome]/fiches/Domaines"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	if {![regexp "PFAM" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set PAB [lindex $Ligne 0]
	if {![info exists Vu($PAB)]} {continue}
	set Acc [lindex $Ligne 2]
	set Def [lindex $Ligne 3]
	#FaireLire [lindex $Ligne 3]
	set Id [lindex $Ligne 6]
	if {[regexp "^PF" $Acc] && $Id>="0.8"} {
	    if {[info exists TabInfosPF($Acc,LesPabs)]} {
		lappend TabInfosPF($Acc,LesPabs) $PAB
	    } else {
		set TabInfosPF($Acc,LesPabs) $PAB
	    }
	    set TabInfosPF($Acc,Definition) $Def
	    lappend Liste $Acc
	} else {
	    #Espionne $Ligne
	}
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    foreach PFAM $Liste {
	set LesPABs [lsort -unique [set TabInfosPF($PFAM,LesPabs)]]
	set nbPAB   [llength $LesPABs]
	set Def     [set TabInfosPF($PFAM,Definition)]
	lappend ListeFinale "$PFAM\t$Def\t$nbPAB\t$LesPABs"
	#AppendAuFichier "[RepertoireDuGenome]/fiches/pfamA100Complet" "$PFAM\t$Def\t$nbPAB\t$LesPABs"
    }
    Espionne [llength $ListeFinale]
    set Lt [lsort -index 2 $ListeFinale]
    SauveLesLignes $Lt dans "[RepertoireDuGenome]/fiches/pfamA80Complet"

}

proc CreeFichierCompletDesPathwaysKegg {FichierPop FichierSortie} {

    set L [CreeListePourFichierAUneColonne $FichierPop]
    foreach Nom $L {
	set Vu($Nom) 1
    }

    set Fichier "[RepertoireDuGenome]/fiches/Kegg"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	set Ligne [split $Ligne "\t"]
	set Type [lindex $Ligne 1]
	if {$Type!="Pathway"} {continue}
	set PAB [lindex $Ligne 0]
	if {![info exists Vu($PAB)]} {continue}
	set Num [lindex $Ligne 2]
	set Def [lindex $Ligne 3]
	#FaireLire [lindex $Ligne 3]
	if {[info exists TabInfosKEGG($Num,LesPabs)]} {
	    lappend TabInfosKEGG($Num,LesPabs) $PAB
	} else {
	    set TabInfosKEGG($Num,LesPabs) $PAB
	}
	set TabInfosKEGG($Num,Definition) $Def
	lappend Liste $Num
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    foreach Pathway $Liste {
	set LesPABs [lsort -unique [set TabInfosKEGG($Pathway,LesPabs)]]
	lappend ListePABs $LesPABs
	set nbPAB   [llength $LesPABs]
	set Def     [set TabInfosKEGG($Pathway,Definition)]
	AppendAuFichier $FichierSortie "$Pathway\t$Def\t$nbPAB\t$LesPABs"
    }
    set PABs [join $ListePABs]
    set LesPABs [split $PABs " "]
    Espionne [llength $LesPABs]
    Espionne [lsort -unique $LesPABs]
    Espionne [llength [lsort -unique $LesPABs]]

}

proc CreeFichierCytologicMapUCSC {FCytoBandUCSC FichierNew} {

    # FCytoBandUCSC: /genomics/link/UCSCGenomes/Homo_sapiens/database/cytoBand.txt
    # Chr\tDeb\tFin\tBand\tCodeCouleur
    # NB: Band commence par p ou q et le Code commence par gneg ou gpos
    # A mettre sous la forme:
    # Chro\tBand\tFinBande\tCodeCouleur
    
    set TaillePre 0
    set ChroPre chr1
    foreach Ligne [LesLignesDuFichier $FCytoBandUCSC] {
	if {$Ligne==""} {continue}
	set LesInfos [split $Ligne "\t"]
	set Chro [lindex $LesInfos 0]
	set Deb [lindex $LesInfos 1]
	set Fin [lindex $LesInfos 2]
	set Band [lindex $LesInfos 3]
	set CodeCouleur [lindex $LesInfos 4]

	# chr -> HS
	regsub "chr" $Chro "" Chiffre
	if {$Chiffre<10} {
	    set NewChiffre "0$Chiffre"
	    set NewChro "HS$NewChiffre"
	} else {
	    set NewChro "HS$Chiffre"
	}

	# Deb Fin -> Taille
	if {$Chro!=$ChroPre} {set TaillePre 0}

	set Taille [expr $Fin-$Deb]
	set FinBand [expr $TaillePre+$Taille]

	# Band -> chroband
	set NewBand "$Chiffre$Band"

	# CodeCouleur -> newcodecouleur
	if {$CodeCouleur=="gneg"} {set NewCodeCouleur "white"}
	if {$CodeCouleur=="gpos25"} {set NewCodeCouleur "lightgrey"}
	if {$CodeCouleur=="gpos50"} {set NewCodeCouleur "grey"}
	if {$CodeCouleur=="gpos75"} {set NewCodeCouleur "black"}
	if {$CodeCouleur=="gpos100"} {set NewCodeCouleur "black"}
	if {$CodeCouleur=="acen"} {set NewCodeCouleur "centromere"}
	if {$CodeCouleur=="gvar"} {set NewCodeCouleur "other2"}
	if {$CodeCouleur=="stalk"} {set NewCodeCouleur "other1"}

	lappend ListeNew "$NewChro\t$NewBand\t$FinBand\t$NewCodeCouleur"

	set TaillePre $FinBand
	set ChroPre $Chro
    }
    SauveLesLignes $ListeNew dans $FichierNew

}

proc CreeFichierCytologicMapUCSC_Human {FCytoBandUCSC FichierNew} {

    #viens de chez annaick proc CreeFichierCytologicMapUCSC sous gpoch/carles/gscopublic/CGHviewer/Windows/CGHviewer.tcl

    # FCytoBandUCSC: /genomics/link/UCSCGenomes/Homo_sapiens/database/cytoBand.txt
    # FichierNew: /genomics/link/UCSCGenomes/Homo_sapiens/database/CytologicMap
    # Chr\tDeb\tFin\tBand\tCodeCouleur
    # NB: Band commence par p ou q et le Code commence par gneg ou gpos
    # A mettre sous la forme:
    # Chro\tBand\tFinBande\tCodeCouleur
    
    set TaillePre 0
    set ChroPre chr1
    foreach Ligne [LesLignesDuFichier $FCytoBandUCSC] {
	if {$Ligne==""} {continue}
	set LesInfos [split $Ligne "\t"]
	set Chro [lindex $LesInfos 0]
	set Deb [lindex $LesInfos 1]
	set Fin [lindex $LesInfos 2]
	set Band [lindex $LesInfos 3]
	set CodeCouleur [lindex $LesInfos 4]

	regsub "chr" $Chro "" Chiffre
	
	# Deb Fin -> Taille
	if {$Chro!=$ChroPre} {set TaillePre 0}

	set Taille [expr $Fin-$Deb]
	set FinBand [expr $TaillePre+$Taille]

	# Band -> chroband
	set NewBand "$Chiffre$Band"

	# CodeCouleur -> newcodecouleur
	if {$CodeCouleur=="gneg"} {set NewCodeCouleur "white"}
	if {$CodeCouleur=="gpos25"} {set NewCodeCouleur "lightgrey"}
	if {$CodeCouleur=="gpos50"} {set NewCodeCouleur "grey"}
	if {$CodeCouleur=="gpos75"} {set NewCodeCouleur "black"}
	if {$CodeCouleur=="gpos100"} {set NewCodeCouleur "black"}
	if {$CodeCouleur=="acen"} {set NewCodeCouleur "centromere"}
	if {$CodeCouleur=="gvar"} {set NewCodeCouleur "other2"}
	if {$CodeCouleur=="stalk"} {set NewCodeCouleur "other1"}

	lappend ListeNew "$Chro\t$NewBand\t$FinBand\t$NewCodeCouleur"

	set TaillePre $FinBand
	set ChroPre $Chro
    }
    SauveLesLignes $ListeNew dans $FichierNew


}

proc CreeFichierDDRefSeqDef {FichierBestOverlaps FichierSortie} {

    #FichierBestOverlaps=/HeadNecknonrnr/OverlapNuctfaRefSeq/bestoverlaps
    #FichierClusters=...fiches/ClustersNew
    #FichierSortie=/HeadNecknonrnr/OverlapNuctfaRefSeq/bestavecdefinition
    foreach Ligne [LesLignesDuFichier $FichierBestOverlaps] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $Ligne 0]
	set NM [lindex $Ligne 1]
	if {![info exists RF($DD)]} {set RF($DD) $NM}
    }
    foreach JR [ListeDesPABs] {
	if {![info exists RF($JR)]} {continue}
	Espionne $JR
	set RefSeq $RF($JR)
	set BId "RSHUM:$RefSeq"
	set Page [PageInfoLaTotale $BId]
	set LaDef [LaDefinition_PageInfo $Page]
	set Def [join $LaDef " "]
	Espionne "$JR\t$RefSeq\t$Def"
	AppendAuFichier $FichierSortie "$JR\t$RefSeq\t$Def"
    }

}

proc CreeFichierDDTARScores {FichierTousLesJumeauxlog FichierSortie} {

    #Cette procedure peut servir pour n'importe quel fichier touslesjumeaux...
    foreach Ligne [LesLignesDuFichier $FichierTousLesJumeauxlog] {
	if {$Ligne==""} {set LignePre "";continue}
	set LesChamps [split $Ligne " "]
	if {[regexp "^Query" $Ligne]} {set LignePre 1;set DD [lindex $Ligne 1]}
	if {[regexp "^>>" $Ligne] && $LignePre==1} {
	    set TAR [lindex [split [lindex $LesChamps 0] ":"] 1]
	    #FaireLire $TAR
	    set IdGlob [lindex $LesChamps 2]
	    set CoverS [lindex $LesChamps 5]
	    set CoverQ [lindex $LesChamps 8]
	    AppendAuFichier $FichierSortie "$DD\t$TAR\t$IdGlob\t$CoverS\t$CoverQ"
	}
    }

}

proc CreeFichierDaedalus {} {

    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	#set AccessProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access]
	set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
	if {![file exists $FichierTFA]} {continue}
	set ID [AccessDuTFADeLaProteine $FichierTFA]
	set Tab($ID) $Nom
	lappend LesID $ID
	#FaireLire "$Nom $AccessProtHuman $ID"
	#AppendAuFichier "[RepertoireDuGenome]/PremierFichierDaedalus" "ID   $ID\nDR   prot;$AccessProtHuman;prot.\n//"
    }
    Espionne "LesID: [llength $LesID]"
    Espionne "LesPABs: [llength [ListeDesPABs]]"
    AskLesPagesInfos load $LesID protein
    foreach ID $LesID {
	set Page [AskLesPagesInfos ask $ID]
	set LesAccess [LesAccessDeLaPageInfo $Page]
	set Acc [lindex $LesAccess 0]
	if {$Acc==""} {set Acc [InterrogeBestProteinAndmRNAForeachOrga $Tab($ID) Organisme "Homo sapiens" "Protein" Access]}
	if {$Acc==""} {Espionne "probleme: $ID $Tab($ID)"}
	AppendAuFichier "[RepertoireDuGenome]/PremierFichierDaedalus" "ID   $ID\nDR   prot;$Acc;prot.\n//"

	AppendAuFichier "[RepertoireDuGenome]/IdAccess" "$Tab($ID)\t$ID\t[join $LesAccess " "]"
    }
    AskLesPagesInfos unset

}

proc CreeFichierDataAffyPourTous3T {FichierSortie} {

    #FichierSortie= /OVERLAP/TotalDesData
    set FichierN "[RepertoireDuGenome]/ExpressionData/Normal/poolN_ap.TXT"
    set FichierTE "[RepertoireDuGenome]/ExpressionData/Early/poolTE_ap.TXT"
    set FichierTS "[RepertoireDuGenome]/ExpressionData/Stable/poolTS_ap.TXT"
    set FichierTU "[RepertoireDuGenome]/ExpressionData/Unstable/poolTU_ap.TXT"

    #Intensites & Detections
    foreach Ligne [LesLignesDuFichier $FichierN] {
	if {[regexp "VADS" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Target [lindex $Ligne 0]
	set Intensite [lindex $Ligne 1]
	if {$Intensite!=""} {
	    set In($Target) $Intensite
	}
	set Detection [lindex $Ligne 3]
	if {$Detection!=""} {
	    set Dn($Target) $Detection
	    #FaireLire $Detection
	}
    }
    foreach Ligne [LesLignesDuFichier $FichierTE] {
	if {[regexp "VADS" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Target [lindex $Ligne 0]
	set Intensite [lindex $Ligne 1]
	if {$Intensite!=""} {
	    set Ite($Target) $Intensite
	}
	set Detection [lindex $Ligne 3]
	if {$Detection!=""} {
	    set Dte($Target) $Detection
	}
    }
    foreach Ligne [LesLignesDuFichier $FichierTS] {
	if {[regexp "VADS" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Target [lindex $Ligne 0]
	set Intensite [lindex $Ligne 1]
	if {$Intensite!=""} {
	    set Its($Target) $Intensite
	}
	set Detection [lindex $Ligne 3]
	if {$Detection!=""} {
	    set Dts($Target) $Detection
	}
    }
    foreach Ligne [LesLignesDuFichier $FichierTU] {
	if {[regexp "VADS" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Target [lindex $Ligne 0]
	set Intensite [lindex $Ligne 1]
	if {$Intensite!=""} {
	    set Itu($Target) $Intensite
	}
	set Detection [lindex $Ligne 3]
	if {$Detection!=""} {
	    set Dtu($Target) $Detection
	}
    }
    #AppendAuFichier $FichierSortie "TAR\tCodeAffy\tDefinition\tDet_N\tDet_TE\tDet_TS\tDet_TU\tInt_N\tInt_TE\tInt_TS\tInt_TU\tFCE\tPE\tFCS\tPS\tFCU\tPU\tFoldMoy\tProfMoy"
    
    #remarque: la liste des PABs ne contient que la selection SAM (2360)
    #liste des 12453 Affy:
    set L [CreeListePourFichierAUneColonne "[RepertoireDuGenome]/fiches/listetotaledespabs"]
    foreach TAR $L {
	Espionne $TAR
	set DefAffy [ExtraitInfo $TAR "GBtagsDefinition"]
	#CodeAffyTarget
	set CodeAffy [ExtraitInfo $TAR "CodeClone"]
	if {[info exists Dn($CodeAffy)] &&  [info exists Dte($CodeAffy)] &&  [info exists Dts($CodeAffy)] &&  [info exists Dtu($CodeAffy)]} {
	    set LesDetections [list $Dn($CodeAffy) $Dte($CodeAffy) $Dts($CodeAffy) $Dtu($CodeAffy)]
	}
	if {[info exists In($CodeAffy)] &&  [info exists Ite($CodeAffy)] &&  [info exists Its($CodeAffy)] &&  [info exists Itu($CodeAffy)]} {
	    set LesIntensites [list $In($CodeAffy) $Ite($CodeAffy) $Its($CodeAffy) $Itu($CodeAffy)]
	    ## E
	    if {$In($CodeAffy)>$Ite($CodeAffy)} {
		set FCE -[expr $In($CodeAffy)*1.0/$Ite($CodeAffy)]; set PE "N"
	    }
	    if {$In($CodeAffy)<$Ite($CodeAffy)} {
		set FCE [expr $Ite($CodeAffy)*1.0/$In($CodeAffy)]; set PE "T"
	    }
	    if {$In($CodeAffy)==$Ite($CodeAffy)} {set FCE 1;set PE "0"}
	    ## S
	    if {$In($CodeAffy)>$Its($CodeAffy)} {
		set FCS -[expr $In($CodeAffy)*1.0/$Its($CodeAffy)]; set PS "N"
	    }
	    if {$In($CodeAffy)<$Its($CodeAffy)} {
		set FCS [expr $Its($CodeAffy)*1.0/$In($CodeAffy)]; set PS "T"
	    }
	    if {$In($CodeAffy)==$Its($CodeAffy)} {set FCS 1;set PS "0"}
	    ## U
	    if {$In($CodeAffy)>$Itu($CodeAffy)} {
		set FCU -[expr $In($CodeAffy)*1.0/$Itu($CodeAffy)]; set PU "N"
	    }
	    if {$In($CodeAffy)<$Itu($CodeAffy)} {
		set FCU [expr $Itu($CodeAffy)*1.0/$In($CodeAffy)]; set PU "T"
	    }
	    if {$In($CodeAffy)==$Itu($CodeAffy)} {set FCU 1;set PU "0"}

	    #### MOYENNE DES T #############
	    set MoyenneDesT [format "%.3f" [expr [expr $Ite($CodeAffy)+ $Its($CodeAffy) + $Itu($CodeAffy)]/3]]
	    if {$In($CodeAffy)>$MoyenneDesT} {
		set FoldMoy -[expr $In($CodeAffy)*1.0/$MoyenneDesT]; set PMoy "N"
	    }
	    if {$In($CodeAffy)<$MoyenneDesT} {
		set FoldMoy [expr $MoyenneDesT*1.0/$In($CodeAffy)]; set PMoy "T"
	    }
	    if {$In($CodeAffy)==$MoyenneDesT} {
		set FoldMoy 1 ; set PMoy "0"
	    }
	}
	set Detections [join $LesDetections "\t"]
	set Intensites [join $LesIntensites "\t"]
	AppendAuFichier $FichierSortie "$TAR\t$CodeAffy\t$DefAffy\t$Detections\t$Intensites\t$FCE\t$PE\t$FCS\t$PS\t$FCU\t$PU\t$FoldMoy\t$PMoy"
    }

}

proc CreeFichierDes929LocAvecOuSansFonction {FichierTot FichierUniq FichierOverlap FichierAffy FichierRefSeq FichierSortie} {

    #set FichierTot "[RepertoireDuGenome]/OVERLAP/TotalDesData"
    #set FichierUniq "[RepertoireDuGenome]/OVERLAP/DataUniques"
    #FichierOverlap "/OVERLAP948/best"
    #set FichierAffy "/genomics/link/AffyTarget/OVERLAP/TotalDesData"
    #FichierRefSeq "OverlapRefSeq/new/DDRefSeqDef"

    #Presence ou absence d'un affy en overlap.
    foreach Ligne [LesLignesDuFichier $FichierOverlap] {
	if {$Ligne==""} {continue}
	set LesCodes [split $Ligne "\t"]
	set DD [lindex $LesCodes 0]
	set CodeAffy [lindex $Ligne 1]
	set Affy($DD) $CodeAffy
    }
    #Profil Virtual Northern et Northern
    set FichierProfilDDValidation "[RepertoireDuGenome]/totalite/ValidationProfil.txt"
    if {![file exists $FichierProfilDDValidation]} {return}
    foreach Ligne [LesLignesDuFichier $FichierProfilDDValidation] {
	if {$Ligne=="" || [regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set Owner [lindex $Ligne 0]
	set CC [lindex $Ligne 2]
	if {$Owner=="F"} {set CC [string toupper $CC]}
	if {$Owner=="I"} {regsub -all "\'" $CC "_" CC}
	set ProfVN [lindex $Ligne 3]
	set ProfNorthern [lindex $Ligne 5]
	
	set PVN($Owner,$CC) $ProfVN
	set PN($Owner,$CC) $ProfNorthern
    }
    #profil Macroarray
    set FichierMacroarray "[RepertoireDuGenome]/MembranesRegine/compar_profils_mb_gscope"
    foreach Ligne [LesLignesDuFichier $FichierMacroarray] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 1]
	set ProfMb [lindex $LesChamps 2]
	set PMb($DD) $ProfMb
    }
    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/931"] {
	Espionne $Ligne
	set LesJumeaux [split $Ligne " "]
	set NbJumeaux [llength $LesJumeaux]
	#Espionne "nb jum : $NbJumeaux"
	set ProfilVN ""; set ProfilNorthern ""; set ProfilMb ""
	foreach Jumeau $LesJumeaux {
	    set CodeClone [InterrogeFichierTotalDataDD $FichierTot $Jumeau Code]
	    set User [InterrogeFichierTotalDataDD $FichierTot $Jumeau User]

	    #virtual northern
	    if {[info exists PVN($User,$CodeClone)] && $ProfilVN==""} {set ProfilVN $PVN($User,$CodeClone)} 
	    set ProfilVN [string trim $ProfilVN]
	    if {[info exists PVN($User,$CodeClone)] && $ProfilVN!="" && [string trim $PVN($User,$CodeClone)]!="" && $ProfilVN!=$PVN($User,$CodeClone)} {
		#Espionne "VN: $ProfilVN dif de $PVN($User,$CodeClone) de $Jumeau"
		if {$ProfilVN==0 && $PVN($User,$CodeClone)!=0} {
		    set ProfilVN $PVN($User,$CodeClone)
		    #Espionne $Jumeau
		}
	    } 

	    #northern
	    if {[info exists PN($User,$CodeClone)] && $ProfilNorthern==""} {set ProfilNorthern $PN($User,$CodeClone)}
	    set ProfilNorthern [string trim $ProfilNorthern]
	    if {[info exists PN($User,$CodeClone)] && $ProfilNorthern!="" && [string trim $PN($User,$CodeClone)]!="" && $ProfilNorthern!=$PN($User,$CodeClone)} {
		#Espionne "Northern: $ProfilNorthern et $PN($User,$CodeClone) de $jumeau"
	    }
 
	    #membrane nylon Regine
	    if {[info exists PMb($Jumeau)] && $ProfilMb==""} {set ProfilMb $PMb($Jumeau)} 
	    set ProfilMb [string trim $ProfilMb]
	    #if {$ProfilMb==" "} {set ProfilMb ""}
	    if {[info exists PMb($Jumeau)] && $ProfilMb!="" && [string trim $PMb($Jumeau)]!="" && $ProfilMb!=$PMb($Jumeau)} {
		#Espionne "Mb: $ProfilMb et $PMb($Jumeau)"
	    } 
	}

	set JR [lindex $LesJumeaux 0]
	#Espionne $JR
	set LesJumeauxDuJR [lreplace $LesJumeaux 0 0]
	### INFOS JR
	#############
	incr n
	set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $JR N]
	set CodeClone [InterrogeFichierTotalDataDD $FichierTot $JR Code]
	set User [InterrogeFichierTotalDataDD $FichierTot $JR User]
	set Band [InterrogeFichierTotalDataDD $FichierTot $JR Bande]

	#les profils
	set ProfilCalc [InterrogeFichierTotalDataDD $FichierTot $JR Profil]
	set ProfilConsensus [InterrogeFichierTotalDataDD $FichierTot $JR ProfCons]
	
	#Sequence
	set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$JR"
	if {![file exists $FichierNuctfa]} {Espionne "$FichierNuctfa doesn t exist";set Seq ""; set LSeq ""} else {set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa];set LSeq [string length $Seq]}
	#Masking
	if {[InterrogeBilanMasking $JR LesEtats] != ""} {
	    set PercentMask  [InterrogeBilanMasking $JR Etat MRM PMasked ]
	    set LesRepeatsMasques [InterrogeBilanMasking $JR Etat MRM LesRepeats]
	}

	#localisation bande cyto (from proc CreeListeTotaleDD)
	set BandeCyto ""
	set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
	if {![file exists $FichierLoc]} {Espionne "$FichierLoc doesn t exist"}
	set LesLocs [InterrogeLocalisation $FichierLoc Nom $JR]
	if {$LesLocs!=""} {
	    foreach Loc $LesLocs {
		if {[regexp "Best" [lindex $Loc 20]]} {
		    set BandeCyto [lindex $Loc 19]
		    break
		}
	    }
	} 
	#Espionne $BandeCyto
	#if {$JR=="DD0004"} {FaireLire "$FichierLoc - [llength $Loc] - $BandeCyto"}

	#RefSeq
	set AccessRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR NM]
	set DefRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR Def]
	if {$AccessRefSeq==""} {set AccessRefSeq "";set DefRefSeq ""}

	#Best Human Prot
	set AccBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccProt]
	set DefBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefProt]
	set AccBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccRNA]
	set DefBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefRNA]

	#Gel DD pour le JR
	set DifE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifE]
	set ProfE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfE]
	set DifS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifS]
	set ProfS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfS]
	set DifU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifU]
	set ProfU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfU]
	
	set DifMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifMoy]
	set ProfMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Pmoy]
	
	#INFOS AFFY ###
	if {[info exists Affy($JR)]} {
	    set MA 1
	    set CodeAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Code]
	    set Def [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Def]
	    set FoldMoy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) FoldMoy]
	    set ProfilMoyAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) ProfMoy]
	} else {set MA 0;set CodeAffy ""; set Def ""; set FoldMoy ""; set ProfilMoyAffy ""}
	
	AppendAuFichier $FichierSortie "$n\t$JR\t$CodeClone\t$Band\t$User\t$LesJumeauxDuJR\t$LSeq\t$Seq\t$PercentMask\t$LesRepeatsMasques\t$DifE\t$ProfE\t$DifS\t$ProfS\t$DifU\t$ProfU\t$DifMoy\t$ProfMoy\t$ProfilCalc\t$ProfilConsensus\t$ProfilVN\t$ProfilNorthern\t$ProfilMb\t$ProfilMoyAffy\t$BandeCyto\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestRNAHuman\t$DefBestRNAHuman\t$AccessRefSeq\t$DefRefSeq\t$MA\t$CodeAffy\t$Def\t$FoldMoy"
    }

}

proc CreeFichierDesBandesCytologiquesPourTous {} {

    global RepertoireDuGenome
    set TexteFichier ""
    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set Bandes [BandesTrouveesEtMoyen $Nom]
	if {$Bandes==""} {append TexteFichier "$Nom\n"}
	append TexteFichier "$Bandes\n"
    }
    Sauve $TexteFichier dans "$RepertoireDuGenome/bandescytologiques"

}

proc CreeFichierDesConflitsDeProfils {} {

    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapEtProfilsEtFold"] {
	set PAB [lindex $Ligne 0]
	set O($PAB) 1
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] {
	set DD [lindex $Ligne 0]
	set Prof [lindex $Ligne 1]
	set P($DD) $Prof
    }
    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPbsDeProfil"] {
	set L [split $Ligne " "]
	incr n
	foreach Nom $L {
	    set CC [ExtraitInfo $Nom "CodeClone"]
	    set User [ExtraitInfo $Nom "OwnerOfCDNA"]
	    if {$CC=="" || $User==""} {Espionne "$Nom nocc noU"}
	    set AccRNACh [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access]
	    if {[regexp -nocase "NOMRNA" $AccRNACh] || $AccRNACh==""} {
		Espionne "$Nom nomrna" 
		set AccRNACh ""
	    }
	    set AccProtCh [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	    if {[regexp "NOPROTEIN" $AccProtCh] || $AccProtCh==""} {
		Espionne "$Nom noprot"
		set AccProtCh ""
	    }
	    if {![info exists P($Nom)]} {Espionne "$Nom noprofil"}
	    if {![info exists O($Nom)]} {set O($Nom) 0}
	    if {$P($Nom)=="+"} {set P($Nom) "T"}
	    if {$P($Nom)=="-"} {set P($Nom) "N"}
	    if {$P($Nom)=="0"} {set P($Nom) "C"}
	    lappend LesConflitsDeProfil "$n\t$Nom\t$CC\t$User\t$AccProtCh\t$AccRNACh\t$P($Nom)\t$O($Nom)"
	}
    }
    Espionne [llength $LesConflitsDeProfil]
    SauveLesLignes $LesConflitsDeProfil dans "[RepertoireDuGenome]/fiches/lesconflitspourvoir"

}

proc CreeFichierDesJR {Fichier} {

    return [ListeDesJR $Fichier]

}

proc CreeFichierDesPFAMA {} {

    #more Domaines | gr PFAM | grep PF | gr -v PB | grep "1\.0" | wc
    set Fichier "[RepertoireDuGenome]/fiches/Domaines"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	if {![regexp "PFAM" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set PAB [lindex $Ligne 0]
	set Acc [lindex $Ligne 2]
	set Def [lindex $Ligne 3]
	#FaireLire [lindex $Ligne 3]
	set Id [lindex $Ligne 6]
	if {[regexp "^PF" $Acc] && $Id>="0.80"} {
	    set LigneAvecTab [join $Ligne "\t"]
	    lappend Liste $LigneAvecTab
	}
    }
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/DomainesPFAMA"

}

proc CreeFichierDesPremiersGOsPourTous {} {

    global RepertoireDuGenome
    set RepLMS "$RepertoireDuGenome/lms"
    if {![file exists $RepLMS]} {return ""}
    set LesPremiersGOs {}
    foreach Fichier [glob "$RepLMS/*.go"] {
	if {$Fichier=="$RepLMS/Distribution.go"} {continue}
	if {[ContenuDuFichier $Fichier]==""} {continue}
	Espionne $Fichier
	set Premier [lindex [Classement $Fichier] 0]
	Espionne $Premier
	lappend LesPremiersGOs $Premier
    } 
    SauveLesLignes $LesPremiersGOs dans "$RepertoireDuGenome/temp/GO_tous"

}

proc CreeFichierDesPremiersGOsPourUneSelection {FichierSelection} {

    global RepertoireDuGenome
    set RepLMS "$RepertoireDuGenome/lms"
    if {![file exists $RepLMS]} {return ""}
    set LesPremiersGOs {}
    set ListeDesSelectionnes [CreeListe $FichierSelection]
    foreach Nom $ListeDesSelectionnes {
	set FichierGO "$RepLMS/$Nom.go"
	if {![file exists $FichierGO]} {continue}
	if {$FichierGO=="$RepLMS/Distribution.go"} {continue}
	if {[ContenuDuFichier $FichierGO]==""} {continue}
	set Premier [lindex [Classement $FichierGO] 0]
	lappend LesPremiersGOs $Premier
    }
    return $LesPremiersGOs

}

proc CreeFichierDesTFA {FichierAccess FichierSortie} {

    foreach Ligne [LesLignesDuFichier $FichierAccess] {
	if {$Ligne==""} {continue}
	set Access $Ligne
	lappend LesAccess $Access
    }
    set LesAccess [split $LesAccess " "]
    set LesAccess [join $LesAccess "\|"]
    set Commande "getz \"\\\[protein-acc:$LesAccess\\\]\" \-view FastaSeqs"
    set GetzOut [eval exec $Commande]
    AppendAuFichier $FichierSortie $GetzOut

}

proc CreeFichierDomaines {FichierPABs PercentId FichierSortie} {

    set L [CreeListePourFichierAUneColonne $FichierPABs]
    foreach Nom $L {
	set Vu($Nom) 1
    }

    set Fichier "[RepertoireDuGenome]/fiches/Domaines"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	if {![regexp "PFAM" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set PAB [lindex $Ligne 0]
	if {![info exists Vu($PAB)]} {continue}
	set Acc [lindex $Ligne 2]
	set Def [lindex $Ligne 3]
	#FaireLire [lindex $Ligne 3]
	set Id [lindex $Ligne 6]
	if {[regexp "^PF" $Acc] && $Id>=$PercentId} {
	    if {[info exists TabInfosPF($Acc,LesPabs)]} {
		lappend TabInfosPF($Acc,LesPabs) $PAB
	    } else {
		set TabInfosPF($Acc,LesPabs) $PAB
	    }
	    set TabInfosPF($Acc,Definition) $Def
	    lappend Liste $Acc
	} else {
	    #Espionne $Ligne
	}
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    foreach PFAM $Liste {
	set LesPABs [lsort -unique [set TabInfosPF($PFAM,LesPabs)]]
	set nbPAB   [llength $LesPABs]
	set Def     [set TabInfosPF($PFAM,Definition)]
	lappend ListeFinale "$PFAM\t$Def\t$nbPAB\t$LesPABs"
	#AppendAuFichier "[RepertoireDuGenome]/fiches/pfamA100Complet" "$PFAM\t$Def\t$nbPAB\t$LesPABs"
    }
    Espionne [llength $ListeFinale]
    #set Lt [lsort -index 2 $ListeFinale], ne marche pas, car les elements sont indexes en fct de l'espace et pas tab.
    SauveLesLignes $ListeFinale dans $FichierSortie

}

proc CreeFichierFastaDesProteinesString {FichierOut TaxId} {

    CanalSqlString
    set sql "SELECT p.protein_id, p.preferred_name, s.sequence
             FROM items.proteins_sequences s, items.proteins p
             WHERE s.protein_id = p.protein_id
             AND p.species_id = $TaxId"

    set out [open $FichierOut "w"]

    Espionne "Creating $FichierOut blast database..."
    foreach {id name sequence} [SqlExec $sql "GetList"] {
	puts $out [formatFasta "PID:$id $name" $sequence]
    }

    close $out

}

proc CreeFichierFinal {FichierTot FichierUniq FichierOverlap FichierAffy FichierRefSeq FichierSortie} {

    #FichierTot "[RepertoireDuGenome]/ANALYSE/Tous"
    #FichierUniq "[RepertoireDuGenome]/ANALYSE/JR"
    #FichierOverlap "OVERLAP931NEW/bestoverlaps"
    #FichierAffy "/genomics/link/AffyTarget/OVERLAP/TotalDesData"
    #FichierRefSeq "overlapHumanmRNARefSeq/DDNMDef"
    #Sortie: ANALYSE/final

    #---Courts, conta et N
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsCourts"] {
	set Court($Ligne) 1
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsContamines.28"] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Nom $LesJumeaux {
	    set Conta($Nom) 1
	}
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsAvecN.6july05"] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Nom $LesJumeaux {
	    set N($Nom) 1
	}
    }
    #--- paper1
    set FichierCorres "[RepertoireDuGenome]/lacorrespondance"
    foreach Ligne [LesLignesDuFichier $FichierCorres] {
	if {$Ligne==""} {continue}
	set Ligne [split $Ligne "\t"]
	set New [lindex $Ligne 0]; set Old [lindex $Ligne 1]
	set O($Old) $New
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/paper1"] {
	if {[info exists O($Ligne)]} {set DD $O($Ligne); set Paper($DD) 1} else {Espionne "no correspondance pour $Ligne"}
    }
    #---
    #Presence ou absence d'un affy en overlap.
    foreach Ligne [LesLignesDuFichier $FichierOverlap] {
	if {$Ligne==""} {continue}
	set LesCodes [split $Ligne "\t"]
	set DD [lindex $LesCodes 0]
	set CodeAffy [lindex $Ligne 1]
	set Affy($DD) $CodeAffy
    }
    #Profil Virtual Northern et Northern
    set FichierProfilDDValidation "[RepertoireDuGenome]/totalite/ValidationProfil.txt"
    if {![file exists $FichierProfilDDValidation]} {return}
    foreach Ligne [LesLignesDuFichier $FichierProfilDDValidation] {
	if {$Ligne=="" || [regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set Owner [lindex $Ligne 0]
	set CC [lindex $Ligne 2]
	if {$Owner=="F"} {set CC [string toupper $CC]}
	if {$Owner=="I"} {regsub -all "\'" $CC "_" CC}
	set ProfVN [lindex $Ligne 3]
	set ProfNorthern [lindex $Ligne 5]
	
	set PVN($Owner,$CC) $ProfVN
	set PN($Owner,$CC) $ProfNorthern
    }
    #profil Macroarray
    set FichierMacroarray "[RepertoireDuGenome]/MembranesRegine/compar_profils_mb_gscope"
    foreach Ligne [LesLignesDuFichier $FichierMacroarray] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 1]
	set ProfMb [lindex $LesChamps 2]
	set PMb($DD) $ProfMb
    }
    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set FichierLocBox "[RepertoireDuGenome]/Localisation/oldBoxLocalisation_Human_Best"
    set FichierLocBox2 "[RepertoireDuGenome]/Localisation/BoxLoc"
    if {![file exists $FichierLocBox]} {Espionne "$FichierLocBox doesn t exist"}
    if {![file exists $FichierLocBox2]} {Espionne "$FichierLocBox2 doesn t exist"}
    set FichierLocBest "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
    if {![file exists $FichierLocBest]} {Espionne "$FichierLocBest doesn t exist"}
    set FichierSelectEST "[RepertoireDuGenome]/fiches/SelectedEST"
    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/jumeaux"] {
	Espionne $Ligne
	
	set LesJumeaux [split $Ligne " "]
	set NbJumeaux [llength $LesJumeaux]
	#Espionne "nb jum : $NbJumeaux"
	set ProfilVN ""; set ProfilNorthern ""; set ProfilMb ""; set LesGO ""; set LesPathwaysKegg ""; set LesDomainesPFAMA ""
	set Papier 0
	foreach Jumeau $LesJumeaux {
	    # Papier Lemaire #
	    if {[info exists Paper($Jumeau)]} {set Papier 1} 
	    #---
	    set CodeClone [InterrogeFichierTotalDataDD $FichierTot $Jumeau Code]
	    set User [InterrogeFichierTotalDataDD $FichierTot $Jumeau User]

	    #virtual northern
	    if {[info exists PVN($User,$CodeClone)] && $ProfilVN==""} {set ProfilVN $PVN($User,$CodeClone)} 
	    set ProfilVN [string trim $ProfilVN]
	    if {[info exists PVN($User,$CodeClone)] && $ProfilVN!="" && [string trim $PVN($User,$CodeClone)]!="" && $ProfilVN!=$PVN($User,$CodeClone)} {
		if {$ProfilVN==0 && $PVN($User,$CodeClone)!=0} {
		    set ProfilVN $PVN($User,$CodeClone)
		}
	    } 
	    #northern
	    if {[info exists PN($User,$CodeClone)] && $ProfilNorthern==""} {set ProfilNorthern $PN($User,$CodeClone)}
	    set ProfilNorthern [string trim $ProfilNorthern]
 	    #membrane nylon Regine
	    if {[info exists PMb($Jumeau)] && $ProfilMb==""} {set ProfilMb $PMb($Jumeau)} 
	    set ProfilMb [string trim $ProfilMb]
	    #Les GOs
	    if {$LesGO==""} {set LesGO [InterrogeGeneOntology $FichierGO $Jumeau LesGO]}
	    #Les Pathways KEGG
	    if {$LesPathwaysKegg==""} {set LesPathwaysKegg [InterrogeMesKEGG $Jumeau LesPathway]}
	    #Les Domaines PFAMA (Id>0.8) 
	    if {$LesDomainesPFAMA==""} {set LesDomainesPFAMA [InterrogeDomaines $Jumeau LesDomaines]}
	}
	#---
	set JR [JumeauRepresentatif $Jumeau]
	set NbBandesDiftes [llength [LesDiftesBandesParCluster $LesJumeaux]]
	if {[info exists Court($JR)]} {set InfoCourt 1} else {set InfoCourt 0}
	if {[info exists Conta($JR)]} {set InfoConta 1} else {set InfoConta 0}
	if {[info exists N($JR)]} {set InfoN 1} else {set InfoN 0}
	# Localisation #
	set LesLocBest [InterrogeLocalisation $FichierLocBest Nom $JR]
	if {$LesLocBest==""} {
	    set LesLocBox [InterrogeLocalisation $FichierLocBox Nom $JR]
	    if {$LesLocBox==""} {
		set LesLocBox2 [InterrogeLocalisation $FichierLocBox2 Nom $JR]
		if {$LesLocBox2==""} {
		    set Chro ""; set Deb ""; set Fin ""; set Sens ""; set BandeCyto ""
		    Espionne "$JR est sans loc!"
		} else {
		    foreach Loc $LesLocBox2 {
			if {[regexp "Best" [lindex $Loc 20]]} {
			    set BandeCyto [lindex $Loc 19]
			    set Chro [lindex $Loc 9]
			    set Deb [lindex $Loc 10]
			    set Fin [lindex $Loc 11]
			    set Sens [lindex $Loc 12]
			    break
			}
		    }
		}
	    } else {
		foreach Loc $LesLocBox {
		    if {[regexp "Best" [lindex $Loc 20]]} {
			set BandeCyto [lindex $Loc 19]
			set Chro [lindex $Loc 9]
			set Deb [lindex $Loc 10]
			set Fin [lindex $Loc 11]
			set Sens [lindex $Loc 12]
			break
		    }
		}
	    }
	} else {
	    foreach Loc $LesLocBest {
		if {[regexp "Best" [lindex $Loc 20]]} {
		    set BandeCyto [lindex $Loc 19]
		    set Chro [lindex $Loc 9]
		    set Deb [lindex $Loc 10]
		    set Fin [lindex $Loc 11]
		    set Sens [lindex $Loc 12]
		    break
		}
	    }
	}
	# EST #
	set EST [InterrogeSelectedEST $FichierSelectEST Nom $JR LesAccess]
	if {$EST==""} {set SiEST 0} else {set SiEST 1}
	#---
	#set JR [lindex $LesJumeaux 0]
	#Espionne $JR
	set LesJumeauxDuJR [lreplace $LesJumeaux 0 0]
	### INFOS JR
	#############
	incr n
	set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $JR N]
	set CodeClone [InterrogeFichierTotalDataDD $FichierTot $JR Code]
	set User [InterrogeFichierTotalDataDD $FichierTot $JR User]
	set Band [InterrogeFichierTotalDataDD $FichierTot $JR Bande]
	#les profils
	set ProfilCalc [InterrogeFichierTotalDataDD $FichierTot $JR Profil]
	set ProfilConsensus [InterrogeFichierTotalDataDD $FichierTot $JR ProfCons]
	#Sequence
	set FichierNuctfa "[RepertoireDuGenome]/nuctfaNEW/$JR"
	if {![file exists $FichierNuctfa]} {Espionne "$FichierNuctfa doesn t exist";set Seq ""; set LSeq ""} else {set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa];set LSeq [string length $Seq]}
	#Masking
	if {[InterrogeBilanMasking $JR LesEtats] != ""} {
	    set PercentMask  [InterrogeBilanMasking $JR Etat MRM PMasked ]
	    set LesRepeatsMasques [InterrogeBilanMasking $JR Etat MRM LesRepeats]
	}
	#RefSeq
	set AccessRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR NM]
	set DefRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR Def]
	if {$AccessRefSeq==""} {set AccessRefSeq "";set DefRefSeq ""}
	#Best Human Prot: (JR SANS PROT MAIS JUM AVEC. EX DD0130)
	set AccBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccProt]
	set DefBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefProt]
	#best human mRNA
	set AccBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccRNA]
	set DefBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefRNA]
	#Warning Best Human Prot
	set Warning [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Warning]
	#Gel DD pour le JR
	set DifE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifE]
	set ProfE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfE]
	set DifS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifS]
	set ProfS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfS]
	set DifU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifU]
	set ProfU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfU]
	
	set DifMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifMoy]
	set ProfMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Pmoy]
	#Les GO
	if {$AccBestProtHuman!=""} {

	    if {$LesGO==""} {set Ontology ""} else {
		set Ontology ""
		foreach GO $LesGO {
		    set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition]
		    append Ontology "$GO $LaDefinitionGO /"
		}
	    } 
	    #LesPathways Kegg
	    if {$LesPathwaysKegg==""} {set Pathways ""} else {
		foreach Pathway $LesPathwaysKegg {
		    set Pathways ""
		    set LaDefinitionKEGG [InterrogeMesKEGG Pathway $Pathway Definition]
		    append Pathways "$Pathway $LaDefinitionKEGG /"
		} 
	    }
	    #Les Domaines
	    if {$LesDomainesPFAMA==""} {set DomainesPFAMA ""} else {
		set DomainesPFAMA ""
		foreach LeDomaine $LesDomainesPFAMA {
		    set i 0; set Liste ""
		    foreach Do $LeDomaine {
			incr i
			if {$i<4} {lappend Liste $Do}
		    }
		    append DomainesPFAMA "$Liste /"
		}
		#set DomainesPFAMA [join $LesDomaines " /"]
	    }
	} else {set Ontology ""; set Pathways ""; set DomainesPFAMA ""}
	#INFOS AFFY ### ATTENTION A FAIRE POUR CHAQUE JUMEAU (21 cas ou JR sans overlap mais jum oui. ex DD0130)
	if {[info exists Affy($JR)]} {
	    set MA 1
	    set CodeAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Code]
	    set Def [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Def]
	    set FoldMoy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) FoldMoy]
	    set ProfilMoyAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) ProfMoy]
	} else {set MA 0;set CodeAffy ""; set Def ""; set FoldMoy ""; set ProfilMoyAffy ""}
	
	AppendAuFichier $FichierSortie "$n\t$JR\t$CodeClone\t$Band\t$User\t$LesJumeauxDuJR\t$NbBandesDiftes\t$LSeq\t$Seq\t$PercentMask\t$LesRepeatsMasques\t$InfoCourt\t$InfoConta\t$InfoN\t$DifE\t$ProfE\t$DifS\t$ProfS\t$DifU\t$ProfU\t$DifMoy\t$ProfMoy\t$ProfilCalc\t$ProfilConsensus\t$ProfilVN\t$ProfilNorthern\t$ProfilMb\t$ProfilMoyAffy\t$BandeCyto\t$Chro\t$Deb\t$Fin\t$Sens\t$SiEST\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestRNAHuman\t$DefBestRNAHuman\t$Warning\t$AccessRefSeq\t$DefRefSeq\t$Ontology\t$Pathways\t$DomainesPFAMA\t$MA\t$CodeAffy\t$Def\t$FoldMoy\t$Papier"
    }

}

proc CreeFichierFoldExpressionPourOverlap {} {

    #fichier foldexpression dans /HeadNeckDD/fiches
    foreach Ligne [LesLignesDuFichier "/genomics/link/HeadNeckDD/fiches/FoldExpression"] {
	set HNK [lindex $Ligne 0]
	set Prof [lindex $Ligne 1]
	set P($HNK) $Prof
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/Jumeaux/TousLesJumeaux.final"] {
	set L [split $Ligne " "]
	foreach Nom $L {
	    set Old [AncienNom $Nom]
	    if {[info exists P($Old)]} {
		lappend FE "$Nom\t$P($Old)" 
	    }
	}
    }
    Espionne [llength $FE]
    SauveLesLignes $FE dans "[RepertoireDuGenome]/fiches/FoldExpression_tous"

}

proc CreeFichierFoldExpressionPourOverlapDDAffy {} {

    set FichierFE "/genomics/link/H/HeadNeckDD/fiches/FoldExpression"
    foreach Ligne [LesLignesDuFichier $FichierFE] {
	set Nom [lindex $Ligne 0]
	set Profil [lindex $Ligne 1]
	if {$Profil=="+"} {set P($Nom) "T"}
	if {$Profil=="-"} {set P($Nom) "N"}
	if {$Profil=="0"} {set P($Nom) "0"}
    }
    set Fichier "/genomics/link/HeadNecknonrnr/Les199OverlapDDAffy"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set DD [lindex $Ligne 0]
	set HNK [AncienNom $DD]
	if {[info exists P($HNK)]} {append ProfilDD "$DD\t$P($HNK)\n"}
    }
    Sauve $ProfilDD dans "/genomics/link/HeadNecknonrnr/fiches/FoldExpressionOverlap"

}

proc CreeFichierFoldExpression_Human {} {

    set compul 0; set opt 0; set pas 0
    foreach Nom [ListeDesPABs] {
	set Ligne "$Nom -"
	lappend LesLignes $Ligne
    }
    SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/fiches/FoldExpression"

}

proc CreeFichierGscopeCodeClone {FichierGscopeCodes} {

    if {![file exists $FichierGscopeCodes]} {return}
    foreach Ligne [LesLignesDuFichier $FichierGscopeCodes] {
	set Ligne [string trim $Ligne]
	set Clone [ExtraitInfo $Ligne "CodeClone"]
	append CodesGscopeEtClone "$Ligne\t$Clone\n"
    }
    return $CodesGscopeEtClone

}

proc CreeFichierInputArrayType {} {

    #attention 
    foreach Ligne [RetinobaseArraytype] {
	set NbTotal 0
	set ElmtLigne [split $Ligne "\t"]
	set manufacturer [lindex $ElmtLigne 1]
	set type         [lindex $ElmtLigne 2]
	set batch        [lindex $ElmtLigne 3]
	set arrayname    [lindex $ElmtLigne 4]
	if {$type=="MG_U74ABC_BV2 set" || $type=="MG_U74ABC_CV2 set"} {continue}
	if {$type=="cDNA"} {continue}
	#cDNA provisoire
	Espionne "$type"
	set LesFiles [CorresEntreTypeEtAffy $type]
	foreach File $LesFiles {
	    set caracteristique [CaracteristiqueDuneAffy $File]
	    set elmtcarac [split $caracteristique " "]
	    set Nb [lindex $elmtcarac 0]
	    set NbTotal [expr $NbTotal + $Nb]
	    set NbControl [lindex $elmtcarac 1]
	}
	set arraydescription "$NbTotal probesets of which $NbControl control" 
	set Ligne "$manufacturer\t$type\t$batch\t$arrayname\t$arraydescription"
	lappend LesLignes $Ligne
    }
    set LesLignes [lsort -index 1 $LesLignes] 
    EspionneL $LesLignes
    SauveLesLignes $LesLignes dans "[GxData]/ToGx/Arraytype/InputArraytype"
    #Inseredata arraytype "[GxData]/FichierInputAt.txt" $TetesGxPourCopy

}

proc CreeFichierInputLnArraytypeProbeset {} {

    #fichier pour table ln_arraytype_probeset (1 par puce)
    #pour Ps et PsControl
    set I 0;
    set version "na27"
    set FichierMG430A  "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.na27.annot.csv"
    set FichierMG430   "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv" 
    set FichierMGU74A  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"
    set FichierMGU74B  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv"
    set FichierMGU74C  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.na26.annot.csv"
    set FichierRGU34A  "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.na27.annot.csv"
    set FichierHGU1332 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv"
    set FichierHGU133A "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.na27.annot.csv"
    set FichierZebra   "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.na27.annot.csv"
    set FichierDroso   "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.na27.annot.csv"
    set FichierChick   "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv"
    set LesFichiers [list $FichierMG430A $FichierMG430 $FichierMGU74A $FichierMGU74B $FichierMGU74C $FichierRGU34A $FichierHGU1332 $FichierHGU133A $FichierZebra $FichierDroso $FichierChick]
    foreach Fichier $LesFichiers {
	set LesLignesLn {}
	Espionne "$Fichier"
	set Queue [file tail $Fichier]
	set Chip [string range $Queue 0 [expr [string first "." $Queue]-1]]
	set LesLignes [TabulonsSansQuote $Fichier "," ";" " " "GetListOfValues"]
	foreach Ligne $LesLignes {
	    incr I
	    Espionne ""
	    set Elmt [split $Ligne ";"]
	    set Ps [lindex $Elmt 0]
	    set LigneLn "$Chip $Ps"
	    lappend LesLignesLn $LigneLn
	}
	SauveLesLignes $LesLignesLn dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/InputLnAtPs$Chip.txt"
    }   

}

proc CreeFichierInputProbeset {} {

    #fichier pour table probeset (1 par puce)
    set I 0; set LesLignesRedondantes {}
    set LesTetesGx [GxAffyHeaders ListOf Gx]
    LConcat LesTetesGx [list retinalspecificity linkeddiseases targetseq_details evi_id speciessymbol]
    set TetesGxPourCopy [join $LesTetesGx ","]
    EspionneL $LesTetesGx
    set version "na27"
#   set FichierMG430A  "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.na27.annot.csv"
    set FichierMG430   "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv" 
    set FichierMGU74A  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"
    set FichierMGU74B  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv"
    set FichierMGU74C  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.na26.annot.csv"
    set FichierRGU34A  "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.na27.annot.csv"
    set FichierHGU1332 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv"
#   set FichierHGU133A "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.na27.annot.csv"
    set FichierZebra   "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.na27.annot.csv"
    set FichierDroso   "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.na27.annot.csv"
    set FichierChick   "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv"
    set LesFichiers [list $FichierMG430 $FichierMGU74A $FichierMGU74B $FichierMGU74C $FichierRGU34A $FichierHGU1332 $FichierZebra $FichierDroso $FichierChick]
    foreach Fichier $LesFichiers {
	set LesLignesValues {}
	Espionne "$Fichier"
	set Queue [file tail $Fichier]
	set Chip [string range $Queue 0 [expr [string first "." $Queue]-1]]
	set LesLignes [TabulonsSansQuote $Fichier "," ";" " " "GetListOfValues"]
	foreach Ligne $LesLignes {
	    incr I
	    Espionne ""
	    set LesValues {}
	    set Elmt [split $Ligne ";"]
	    set Ps [lindex $Elmt 0]
	    if {[regexp "AFFX" $Ps]} {continue}
	    if {[info exists DejaVu($Ps)]} {
		lappend LesLignesRedondantes "$Chip $Ps"
	    }
	    set DejaVu($Ps) 1
	    foreach TeteGx $LesTetesGx {
		if {$TeteGx=="retinalspecificity" || $TeteGx=="targetseq_details"} {
		    lappend LesValues "NA"
		    Espionne "$TeteGx NA"
		    continue
		}
		if {$TeteGx=="speciessymbol"} {
		    set ValueofCol [UcscAssemblyNameOf $Espece]
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		if {$TeteGx=="linkeddiseases"} {
		    set Dis1 [FromRetnetForAffy $GnMaj Dis1]
		    set Dis2 [FromRetnetForAffy $GnMaj Dis2]
		    if {$Dis1 == "" && $Dis2 == ""} { set ValueofCol "NA" }
		    if {$Dis1 != "" && $Dis2 == ""} { set ValueofCol $Dis1 }
		    if {$Dis1 != "" && $Dis2 != ""} { set ValueofCol "$Dis1/ $Dis2" }
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		if {$TeteGx=="evi_id"} {
		    set ValueofCol "NA"
		    if {[regexp "^Mus" $Espece]} {
			set ListeEvi [GscopeIdsOfGeneName $GnMaj]
			if {$ListeEvi != {}} { set ValueofCol [join $ListeEvi "/"] }
		    }
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		set Colonne    [GxAffyHeaders $TeteGx Col]
		set ValueofCol [lindex $Elmt $Colonne]
		if {$TeteGx=="genesymbol"} { 
		    set Gn $ValueofCol
		    set GnMaj [string toupper $Gn]
		}
		if {$TeteGx=="species"} { 
		    set Espece $ValueofCol
		}
		if {$TeteGx=="chromo_loc" || $TeteGx=="cytoband"} {
		    set LesLoc {}; set LesCyt {}
		    regsub -all "///" $ValueofCol "#" ValueofCol
		    regsub -all "//" $ValueofCol "@" ValueofCol
		    set LesLocCompletes [split $ValueofCol "#"]
		    if {$TeteGx=="chromo_loc"} {
			foreach LocComplete $LesLocCompletes {
			    set LocComplete [string trim $LocComplete]
			    set ElmtDeLoc [split $LocComplete "@"]
			    set LaLoc [string trim [lindex $ElmtDeLoc 0]]
			    regsub -all " " $LaLoc "" LaLoc
			    lappend LesLoc $LaLoc
			}
			set LesLoc [ListeSansDoublon $LesLoc]
			set ValueofCol [join $LesLoc ","] 
		    }
		    if {$TeteGx=="cytoband"} {
			foreach LocComplete $LesLocCompletes {
			    set LocComplete [string trim $LocComplete]
			    set ElmtDeLoc [split $LocComplete "@"]
			    set LaCyto [string trim [lindex $ElmtDeLoc 2]]
			    regsub -all " " $LaCyto "" LaCyto
			    if {$LaCyto==""} {set LaCyto "NA"}
			    lappend LesCyt $LaCyto
			}
			set LesCyt [ListeSansDoublon $LesCyt]
			set ValueofCol [join $LesCyt ","]
		    }
		}
		if {$ValueofCol=="---"} {set ValueofCol "NA"}
		Espionne "$TeteGx $ValueofCol"
		lappend LesValues $ValueofCol
	    }
	    set LigneValue [join $LesValues "\t"]
	    Espionne "$LigneValue"
	    lappend LesLignesValues $LigneValue
	}
	SauveLesLignes $LesLignesValues dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/InputPs$Chip.txt"
    }   
    SauveLesLignes $LesLignesRedondantes dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/PsRedondantes.txt"
    #Inseredata probeset "[GxData]/ToGx/ProbesetEtLnAtPs/FichierInputPs.txt" $TetesGxPourCopy

}

proc CreeFichierInputProbesetControl {} {

    #fichier pour table probeset (1 seule pour toutes les puces)
    #les probesets control peuvent etre presentes sur plusieurs puces. Dans ce cas, les lignes sont presque identiques entre puces (sauf l'espece (species scientific name, species symbol) et l'accno). on prends alors la premiere ligne  
    set LesTetesGx [GxAffyHeaders ListOf Gx]
    LConcat LesTetesGx [list retinalspecificity linkeddiseases targetseq_details evi_id speciessymbol]
    set TetesGxPourCopy [join $LesTetesGx ","]
    EspionneL $LesTetesGx
    
    set version "na27"
    set FichierMG430A  "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.na27.annot.csv"
    set FichierMG430   "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv" 
    set FichierMGU74A  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv"
    set FichierMGU74B  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv"
    set FichierMGU74C  "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.na26.annot.csv"
    set FichierRGU34A  "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.na27.annot.csv"
    set FichierHGU1332 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv"
    set FichierHGU133A "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.na27.annot.csv"
    set FichierZebra   "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.na27.annot.csv"
    set FichierDroso   "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.na27.annot.csv"
    set FichierChick   "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv"
    set LesFichiers [list $FichierMG430A $FichierMG430 $FichierMGU74A $FichierMGU74B $FichierMGU74C $FichierRGU34A $FichierHGU1332 $FichierHGU133A $FichierZebra $FichierDroso $FichierChick]
    foreach Fichier $LesFichiers {
	Espionne "$Fichier"
	set Queue [file tail $Fichier]
	set Chip [string range $Queue 0 [expr [string first "." $Queue]-1]]
	set LesLignes [TabulonsSansQuote $Fichier "," ";" " " "GetListOfValues"]
	foreach Ligne $LesLignes {
	    set LesValues {}
	    set Elmt [split $Ligne ";"]
	    set Ps [lindex $Elmt 0]
	    if {![regexp "AFFX" $Ps]} {continue}
	    if {[info exists DejaVu($Ps)]} {
		continue
	    } else {
		set DejaVu($Ps) 1
	    }
	    Espionne ""
	    Espionne "$Ligne"
	    foreach TeteGx $LesTetesGx {
		if {$TeteGx=="retinalspecificity" || $TeteGx=="targetseq_details"} {
		    lappend LesValues "NA"
		    Espionne "$TeteGx NA"
		    continue
		}
		if {$TeteGx=="speciessymbol"} {
		    set ValueofCol [UcscAssemblyNameOf $Espece]
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		if {$TeteGx=="linkeddiseases"} {
		    set Dis1 [FromRetnetForAffy $GnMaj Dis1]
		    set Dis2 [FromRetnetForAffy $GnMaj Dis2]
		    if {$Dis1 == "" && $Dis2 == ""} { set ValueofCol "NA" }
		    if {$Dis1 != "" && $Dis2 == ""} { set ValueofCol $Dis1 }
		    if {$Dis1 != "" && $Dis2 != ""} { set ValueofCol "$Dis1/ $Dis2" }
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		if {$TeteGx=="evi_id"} {
		    set ValueofCol "NA"
		    if {[regexp "^Mus" $Espece]} {
			set ListeEvi [GscopeIdsOfGeneName $GnMaj]
			if {$ListeEvi != {}} { set ValueofCol [join $ListeEvi "/"] }
		    }
		    lappend LesValues $ValueofCol
		    Espionne "$TeteGx $ValueofCol"
		    continue
		}
		set Colonne    [GxAffyHeaders $TeteGx Col]
		set ValueofCol [lindex $Elmt $Colonne]
		if {$TeteGx=="genesymbol"} { 
		    set Gn $ValueofCol
		    set GnMaj [string toupper $Gn]
		}
		if {$TeteGx=="species"} { 
		    set Espece $ValueofCol
		}
		if {$TeteGx=="chromo_loc" || $TeteGx=="cytoband"} {
		    set LesLoc {}; set LesCyt {}
		    regsub -all "///" $ValueofCol "#" ValueofCol
		    regsub -all "//" $ValueofCol "@" ValueofCol
		    set LesLocCompletes [split $ValueofCol "#"]
		    if {$TeteGx=="chromo_loc"} {
			foreach LocComplete $LesLocCompletes {
			    set LocComplete [string trim $LocComplete]
			    set ElmtDeLoc [split $LocComplete "@"]
			    set LaLoc [string trim [lindex $ElmtDeLoc 0]]
			    regsub -all " " $LaLoc "" LaLoc
			    lappend LesLoc $LaLoc
			}
			set LesLoc [ListeSansDoublon $LesLoc]
			set ValueofCol [join $LesLoc ","] 
		    }
		    if {$TeteGx=="cytoband"} {
			foreach LocComplete $LesLocCompletes {
			    set LocComplete [string trim $LocComplete]
			    set ElmtDeLoc [split $LocComplete "@"]
			    set LaCyto [string trim [lindex $ElmtDeLoc 2]]
			    regsub -all " " $LaCyto "" LaCyto
			    if {$LaCyto==""} {set LaCyto "NA"}
			    lappend LesCyt $LaCyto
			}
			set LesCyt [ListeSansDoublon $LesCyt]
			set ValueofCol [join $LesCyt ","]
		    }
		}
		if {$ValueofCol=="---"} {set ValueofCol "NA"}
		Espionne "$TeteGx $ValueofCol"
		lappend LesValues $ValueofCol
	    }
	    set LigneValue [join $LesValues "\t"]
	    Espionne "$LigneValue"
	    lappend LesLignesValues $LigneValue
	}
    }
    SauveLesLignes $LesLignesValues dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/InputPsControl.txt"
    #sans le DejaVu au dessus
    #SauveLesLignes $LesLignesValues dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/InputPsControlAcRedond.txt"
    #set LesLignesValues [ListeSansDoublon $LesLignesValues]
    #SauveLesLignes $LesLignesValues dans "[GxData]/ToGxOld/ProbesetEtLnAtPs/InputPsControlSsRedond.txt"

}

proc CreeFichierJumeauxLoc {} {

    #set F "[RepertoireDuGenome]/OverlapDDAffy_Loc"
    set F "[RepertoireDuGenome]/OverlapDDAffy_Loc_New"
    foreach Ligne [LesLignesDuFichier $F] {
	if {![regexp -nocase "TAR" $Ligne]} {lappend LesJumeauxDD $Ligne}
	if {![regexp -nocase "DD" $Ligne]} {lappend LesJumeauxAffy $Ligne}
    }
    #SauveLesLignes $LesJumeauxDD dans "[RepertoireDuGenome]/LesJumeauxLocParmi1014"
    #SauveLesLignes $LesJumeauxAffy dans "/genomics/link/AffyTarget/LesJumeauxLoc"
    SauveLesLignes $LesJumeauxDD dans "[RepertoireDuGenome]/LesJumeauxLocParmi1014_New"
    SauveLesLignes $LesJumeauxAffy dans "/genomics/link/AffyTarget/LesJumeauxLoc_New"

}

proc CreeFichierJumeauxLocs {} {

# basee sur fichier BestLocalisation_Human et fichier oldBoxLocalisation_Human_Best 
# Cree le fichier jumeaux_Overlap dans le dir fiches.
# Jumeaux = Clones localises sur le meme chromosome avec des locs chevauchantes.
# Attention : Considere la best localisation.
# Premiere best si cas polyloc. 
# Trie les clones d'un meme cluster par ordre decroissant de leur longueur (nuctfa)
# part de 2066 PABs sans jumeaux SeqNuc
    set Fichier "[RepertoireDuGenome]/fiches/LesPABsApresJumSeqNuc"
 
    set FichierDesClonesEnOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap"
    
    set FichierLocBox "[RepertoireDuGenome]/Localisation/oldBoxLocalisation_Human_Best"
    if {![file exists $FichierLocBox]} {Espionne "$FichierLocBox doesn t exist"}
    set FichierLocBest "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
    if {![file exists $FichierLocBest]} {Espionne "$FichierLocBest doesn t exist"}

    set LesLocsNom {}
    foreach Nom [CreeListePourFichierAUneLigne $Fichier] {
	#FaireLire $Nom
	# ---Localisation #
	set LesLocBest [InterrogeLocalisation $FichierLocBest Nom $Nom]
	if {$LesLocBest==""} {
	    set LesLocBox [InterrogeLocalisation $FichierLocBox Nom $Nom]
	    if {$LesLocBox==""} {
		set Chro ""; set Deb ""; set Fin ""; set Sens ""; set BandeCyto ""
		Espionne "$Nom est sans loc!"
	    } else {
		foreach Loc $LesLocBox {
		    if {[regexp "Best" [lindex $Loc 20]]} {
			set BandeCyto [lindex $Loc 19]
			set Chro [lindex $Loc 9]
			set Deb [lindex $Loc 10]
			set Fin [lindex $Loc 11]
			lappend LesLocsNom "$Chro $Deb $Fin $Nom"
			break
		    }
		}
	    }
	} else {
	    foreach Loc $LesLocBest {
		if {[regexp "Best" [lindex $Loc 20]]} {
		    set BandeCyto [lindex $Loc 19]
		    set Chro [lindex $Loc 9]
		    set Deb [lindex $Loc 10]
		    set Fin [lindex $Loc 11]
		    lappend LesLocsNom "$Chro $Deb $Fin $Nom"
		    break
		}
	    }
	}
    }
    #commande vue avec Raymond
    #permet de trier en fonction de la borne inferieure "a"
    set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom]
    set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees]
    lappend LesLocsNomTriees "bidon bidon bidon bidon bidon"
    set OldChromo "zzzz"
    set OldInf 1111111111111111
    set OldSup 0
    set LaSortie {}
    foreach Loc $LesLocsNomTriees {
	if {$Loc!="bidon bidon bidon bidon bidon"} {
	    scan $Loc "%s %d %d %s" chromo inf sup code
	    if {($chromo == $OldChromo) && ($inf <= $OldSup)} {
		if {![info exists LesMemes]} { set LesMemes $Oldcode }
		lappend LesMemes $code
	    } else {
		if {[info exists LesMemes]} {
		    lappend LaSortie [join $LesMemes " "]
		    unset LesMemes
		}
	    }
	    set OldChromo $chromo
	    set OldInf $inf
	    set OldSup $sup 
	    set Oldcode $code
	}
    }

    if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace the file jumeaux_Overlap"]} {
	if {$LaSortie=={}} {
	    Sauve "No overlaps were found" dans $FichierDesClonesEnOverlap
	} else {
	    set Sortie [TrieLaSortie $LaSortie]
	    Espionne "fin"
	    Sauve $Sortie dans $FichierDesClonesEnOverlap
	} 
    }
    return $FichierDesClonesEnOverlap

}

proc CreeFichierJumeauxProtChoisie {FichierDesPABs FichierSortie} {

    #prot: human ou pas.
    #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts
    #FichierSortie= fiches/jumeaux_AccProtChoisie
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set Zero 0; set Un 0; set NoHuman 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	if {$AccessProt!="NOPROTEIN" && $AccessProt!=""} {
	    lappend Liste "$Nom\t$AccessProt"
	} 
    }
    #Espionne [llength $Liste]
    set ListeTriee [lsort -index 1 $Liste]
    #Espionne $ListeTriee
    Espionne [llength $ListeTriee]

    set PrevAccess "zzzzz"
    foreach Elt $ListeTriee {
	set LesData [split $Elt "\t"]
	set DD [lindex $LesData 0]
	set Access [lindex $LesData 1]
	if {$Access==$PrevAccess} {
	    if {![info exists LesMemes]} {lappend LesMemes $PrevDD}
	    lappend LesMemes $DD
	} else {
	    if {[info exists LesMemes]} {
		lappend LaSortie [join $LesMemes " "]
		unset LesMemes
	    }
	}
	set PrevAccess $Access
	set PrevDD $DD
    }
    SauveLesLignes $LaSortie dans $FichierSortie

}

proc CreeFichierJumeauxProtContig {FichierDesPABs FichierSortie} {

    #prot: human ou pas.
    #FichierDesPABs=fiches/LesDDSansJumSeqSansCourtsSansJumProtChoisie
    #FichierSortie= fiches/jumeaux_AccProtContig
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set Zero 0; set Un 0; set NoHuman 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access]
	if {$AccessProt!=""} {
	    lappend Liste "$Nom\t$AccessProt"
	} 
    }
    #Espionne [llength $Liste]
    set ListeTriee [lsort -index 1 $Liste]
    #Espionne $ListeTriee
    Espionne [llength $ListeTriee]

    set PrevAccess "zzzzz"
    foreach Elt $ListeTriee {
	set LesData [split $Elt "\t"]
	set DD [lindex $LesData 0]
	set Access [lindex $LesData 1]
	if {$Access==$PrevAccess} {
	    if {![info exists LesMemes]} {lappend LesMemes $PrevDD}
	    lappend LesMemes $DD
	} else {
	    if {[info exists LesMemes]} {
		lappend LaSortie [join $LesMemes " "]
		unset LesMemes
	    }
	}
	set PrevAccess $Access
	set PrevDD $DD
    }
    SauveLesLignes $LaSortie dans $FichierSortie

}

proc CreeFichierJumeauxProtNotHumanChoisie {FichierDesPABs FichierOrgaNotHuman FichierSortie} {

    #prot: not human
    #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts
    #FichierOrgaNotHuman=fiches/LesOrgasNotHumanDesProtChoisies
    #FichierSortie= fiches/jumeaux_AccProtChoisie_NotHuman
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set Zero 0; set Un 0; set NoHuman 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]
	if {$AccessProt!="NOPROTEIN" && $AccessProt!="" && $Orga!="Homo sapiens"} {
	    lappend Liste "$Nom\t$AccessProt"
	    if {![info exists Vu($Orga)]} {set Vu($Orga) 1; lappend LesOrgas $Orga}
	}
    }
    set LesOrgasTries [lsort $LesOrgas]
    SauveLesLignes $LesOrgasTries dans $FichierOrgaNotHuman
    #Espionne [llength $Liste]
    set ListeTriee [lsort -index 1 $Liste]
    #Espionne $ListeTriee
    Espionne [llength $ListeTriee]

    set PrevAccess "zzzzz"
    foreach Elt $ListeTriee {
	set LesData [split $Elt "\t"]
	set DD [lindex $LesData 0]
	set Access [lindex $LesData 1]
	if {$Access==$PrevAccess} {
	    if {![info exists LesMemes]} {lappend LesMemes $PrevDD}
	    lappend LesMemes $DD
	} else {
	    if {[info exists LesMemes]} {
		lappend LaSortie [join $LesMemes " "]
		unset LesMemes
	    }
	}
	set PrevAccess $Access
	set PrevDD $DD
    }
    SauveLesLignes $LaSortie dans $FichierSortie

}

proc CreeFichierJumeauxProtOverlap {FichierProtOverlap FichierSortie} {

    #/Jumeaux/TousLesJumeaux_0.95_0.95_0.95.final
    foreach Ligne [LesLignesDuFichier $FichierProtOverlap] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne " "]
	if {[llength $LesChamps]>1} {lappend Liste $Ligne}
    }
    SauveLesLignes $Liste dans $FichierSortie

}

proc CreeFichierMacsimJalview {RepMacsims RepMacsimJal} {

    foreach F [glob -nocomplain "$RepMacsims/PCA*.xml"] {
	set Nom [lindex [split [file tail $F] "."] 0]
	Espionne $Nom
	set Commande "eval exec /home/julie/macsim_linux/macsim2jal $F $RepMacsimJal/$Nom"
	catch {eval $Commande} Message
    }

}

proc CreeFichierMiniConfig {{MiniConfigOrPrefixe ""} {OrfNumbering ""} {CollectionType ""} {OS ""} {OC ""} {OX ""}} {

JeMeSignale
    global RepertoireDuGenome
    global CurrentGenome
    global FichierMiniConfig
    global VersionDeGscopeAuBigBang
    global FichierSequenceADN
    global PrefixeDesORFs
    global LongueurMiniDesORFs
    global GenomeOuCollection
    global NarcisseDuAlias

    file mkdir "[RepertoireDuGenome]/beton"

    set Prefixe $MiniConfigOrPrefixe
    if {[regexp "," $MiniConfigOrPrefixe]} {
	set OS ""
	set OC "" 
	set OX ""
	lassign [split $MiniConfigOrPrefixe ","] Prefixe OrfNumbering CollectionType OS OC OX
    }
    if {[regexp {^[0-9]+$} $OS]} { set OX $OS; set OS "" } 
                               set OS [QuestionDeScience EVImm "ret Tax $OS Name"]
    if {$OX!="" && $OS=="" } { set OS [QuestionDeScience EVImm "ret Tax $OX Name"] }
    if {$OX==""}             { set OX [QuestionDeScience EVImm "ret Tax $OS TaxId"] }
    if {$OC==""}             { set OC [QuestionDeScience EVImm "ret TaxClass $OX Name"] } 

    regsub -all "_" $OS " " OS
    regsub -all "_" $OC " " OC

    set YaDuNeuf [expr  ![string equal $Prefixe ""]]

    if {[info exists FichierMiniConfig] && [file exists $FichierMiniConfig]} {
	if { ! $YaDuNeuf} { return $FichierMiniConfig }
	if {1 || [OuiOuNon "Do we overwrite $FichierMiniConfig"]} {
	    Garde $FichierMiniConfig "AndDelete"
	}
    }

    set Interactif [expr !$YaDuNeuf]

    set VersionDeGscopeAuBigBang "VersionDeGscopeAuBigBang [VersionDeGscope]"	
    set TFA [lindex [glob -nocomplain "$RepertoireDuGenome/beton/*.tfa"] 0]
    set FichierSequenceADN       "FichierSequenceADN $TFA"
    
    if {$Prefixe!=""} {
	set PrefixeDesORFs $Prefixe
    } else {
	set Interactif 1
	set PrefixeDesORFs [Entre "PrefixeDesORFs BOX"]
    }
    regsub { *PrefixeDesORFs *} $PrefixeDesORFs "" P
    set PrefixeDesORFs "PrefixeDesORFs $P"
    
    set FormatOrfNumbering [FormatDesNumerosPourCollection $OrfNumbering]
    set TextFormatOrfNumbering "FormatOrfNumbering $FormatOrfNumbering"
    set LongueurMiniDesORFs    "LongueurMiniDesORFs 0"    
    set GenomeOuCollection     "GenomeOuCollection Collection"
    

    if {$OS!=""} {
	NotreOS $OS
	if {$OC!=""} {
	    NotreOC $OC
	} else {
	    set OC [NotreOC]
	}
	if {$OX!=""} {
	    NotreOX $OX
	} else {
	    set OX [NotreOX]
	}
	set TexteNotreOS "NotreOS $OS"
	set TexteNotreOC "NotreOC $OC"
	set TexteNotreOX "NotreOX $OX"
    } else {
	set Interactif 1
	if {[OuiOuNon "Do this collection concern only one organism ?"]} {
	    set OS [Entre "Homo sapiens"]
	    if {$OS==""} { set OS "Inconnu inconnu" }
	    while {$OS=="Inconnu inconnu" ||  [Glossaire $OS Complet]!=$OS} {
		FaireLire "Sorry I don't know the organism $OS"
		scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece
		set OS "$Genre $Espece"
		Espionne $OS
	    }
	    set OC [Entre [NotreOC $OS]]
	    set OX [NotreOX]
	    set TexteNotreOS "NotreOS $OS"
	    set TexteNotreOC "NotreOC $OC"
	    set TexteNotreOX "NotreOX $OX"
	} else {
	    set TexteNotreOS "NotreOS Inconnu inconnu"
	    set TexteNotreOC "NotreOC ClassUnknown"
	    set TexteNotreOX "NotreOX 0"
	}
    }
    if {$CollectionType==""} {
	set Interactif 1
	FaireLire "Please tell me what kind of collection you want to create.\n To each one corresponds a specific analysis."
	set LeChoix [list  "DNA"        "DNA simple analysis (blastn, blastx, etc.)"  "" ""  "Prot"       "Prot: Protein for blastp tblastn etc."  "CDS"        "CDS:  DNA coding for a protein ( with correct frame )"  "CDSProt"    "Both: DNA coding for a protein ( with correct frame ) AND protein sequence"  "CDSProtFoF" "Both: DNA coding for a protein ( with correct frame ) AND protein sequence in a FoF"  "" ""  "EukProt"    "Eukaryotic Prot full analysis (loc, prot search, ontology...) "  "EukDNA"     "Eukaryotic cDNA full analysis (loc, prot search, ontology...) "  "EukDNAAffy" "Eukaryotic cDNA full analysis (loc, prot search, ontology...) from Affymetrix"  ]
	foreach {Clef Texte} $LeChoix {
	    lappend LesClefs $Clef
	    lappend LesTextes $Texte
	}
	set Clef ""
	while {$Clef==""} {
	    set Clef [ChoixParmiJoli $LesClefs "" $LesTextes]
	    if {$Clef!=""} { break }
	    Boum
	}
    } else {
	set Clef $CollectionType
    }
    switch $Clef {
	"DNA"        { set GenomeOuCollection "GenomeOuCollection Collection of DNA" }
	"Prot"       { set GenomeOuCollection "GenomeOuCollection Collection of proteins" }
	"CDS"        { set GenomeOuCollection "GenomeOuCollection Collection of CDS" }
	"CDSProt"    { set GenomeOuCollection "GenomeOuCollection Collection of CDS with protein" }
	"CDSProtFoF" { set GenomeOuCollection "GenomeOuCollection Collection of CDS with protein in a FoF" }
	"EukDNA"     { set GenomeOuCollection "GenomeOuCollection Collection of cDNA" }
	"EukDNAAffy" { set GenomeOuCollection "GenomeOuCollection Collection of cDNA from Affymetrix" }
	default { FaireLire "I don't know what to do in CreeLaCollection" ; Boum }
    }
    
    set     LaConfig {}
    lappend LaConfig "#MiniConfig "
    lappend LaConfig "$FichierSequenceADN"
    lappend LaConfig "$VersionDeGscopeAuBigBang"
    lappend LaConfig "$PrefixeDesORFs"
    lappend LaConfig "$TextFormatOrfNumbering"
    lappend LaConfig "$LongueurMiniDesORFs"
    lappend LaConfig "$TexteNotreOS"
    lappend LaConfig "$TexteNotreOC"
    lappend LaConfig "$TexteNotreOX"
    lappend LaConfig "$GenomeOuCollection"
    set       Config [join $LaConfig "\n"]
    
    if {$Interactif && ! [OuiOuNon "OK to save following miniconfig ?\n\n$Config" ]} { Boum }

    Sauve $Config dans $FichierMiniConfig
    return $FichierMiniConfig

}

proc CreeFichierOverlapAvecCodeAffyEtProfilsDD {} {

    set FichierAffy "/genomics/link/HeadNecknonrnr/Les199AffyEnOverlap"
    foreach Ligne [LesLignesDuFichier $FichierAffy] {
	set Gscope [lindex $Ligne 0]
	set Code [lindex $Ligne 1]
	set C($Gscope) $Code
    }
    set FichierProfilDD "/genomics/link/HeadNecknonrnr/OverlapEtProfilDD"
    foreach Ligne [LesLignesDuFichier $FichierProfilDD] {
	set NomDD [lindex $Ligne 0]
	set NomAffy [lindex $Ligne 1]
	set ProfilDD [lindex $Ligne 2]
	if {![info exists C($NomAffy)]} {Espionne "$NomAffy pb code?"}
	append Overlap "$NomDD\t$NomAffy\t$C($NomAffy)\t$ProfilDD\n"
    }
    Sauve $Overlap dans "/genomics/link/HeadNecknonrnr/OverlapCompletEtProfilDD"

}

proc CreeFichierOverlapAvecProfilDD {} {

    set FichierProfilDD "/genomics/link/HeadNecknonrnr/fiches/FoldExpressionOverlap"
    foreach Ligne [LesLignesDuFichier $FichierProfilDD] {
	set DD [lindex $Ligne 0]
	set Profil [lindex $Ligne 1]
	set P($DD) $Profil
    }
    set FichierOverlap "/genomics/link/HeadNecknonrnr/Les199OverlapDDAffy"
    foreach Ligne [LesLignesDuFichier $FichierOverlap] {
	set NomDD [lindex $Ligne 0]
	set NomAffy [lindex $Ligne 1]
	if {![info exists P($NomDD)]} {Espionne "$NomDD pb profil?"}
	append OverlapEtProfil "$NomDD\t$NomAffy\t$P($NomDD)\n"
    }
    Sauve $OverlapEtProfil dans "/genomics/link/HeadNecknonrnr/OverlapEtProfilDD"

}

proc CreeFichierOverlapAvecProfilsDDetAffy {} {

    set FichierProfilDD "/genomics/link/HeadNecknonrnr/OverlapCompletEtProfilDD"
    set FichierProfilAffy "/genomics/link/HeadNecknonrnr/pourgscope_fromAnne"
    foreach Ligne [LesLignesDuFichier $FichierProfilAffy] {
	set Code [lindex $Ligne 0]
	set Profil [lindex $Ligne 6]
	set P($Code) $Profil
    }
    foreach Ligne [LesLignesDuFichier $FichierProfilDD] {
	set NomDD [lindex $Ligne 0]
	set NomAffy [lindex $Ligne 1]
	set CodeAffy [lindex $Ligne 2]
	set ProfilDD [lindex $Ligne 3]
	if {![info exists P($CodeAffy)]} {Espionne "$CodeAffy pb profil?";continue}
	append Overlap "$NomDD\t$NomAffy\t$CodeAffy\t$ProfilDD\t$P($CodeAffy)\n"
    }
    Sauve $Overlap dans "/genomics/link/HeadNecknonrnr/OverlapEtProfils"

}

proc CreeFichierOverlapDDAffyLoc {} {

    #But: Ne garder que les vrais overlaps DD/Affy
    #set F "[RepertoireDuGenome]/OverlapDDAffy_Loc"
    set F "[RepertoireDuGenome]/OverlapDDAffy_Loc_New"
    foreach Ligne [LesLignesDuFichier $F] {
	if {![regexp -nocase "TAR" $Ligne]} {continue}
	if {![regexp -nocase "DD" $Ligne]} {continue}
	set Ltriee [lsort -dictionary $Ligne]
	lappend LeNouveau $Ltriee
    }
    #SauveLesLignes $LeNouveau dans "[RepertoireDuGenome]/OverlapDDAffy_Loc_sansDDclusters"
    SauveLesLignes $LeNouveau dans "[RepertoireDuGenome]/OverlapDDAffy_Loc_sansDDclusters_New"

}

proc CreeFichierOverlapFinal {FichierTot FichierUniq FichierAffy FichierOverlaps FichierSortie} {

    #correction: jumeaux dd , voir fichier clustersnew dans fiches.
    #FichierOverlaps = OVERLAP931NEW/bestoverlaps (le fichier overlap est de la forme:$DD $TAR)
    #set FichierTot "[RepertoireDuGenome]/ANALYSE/Tous"
    #set FichierUniq "[RepertoireDuGenome]/ANALYSE/JR"
    #set FichierAffy "/genomics/link/AffyTarget/OVERLAP/TotalDesData"
    #################################################################
    foreach Ligne [LesLignesDuFichier $FichierOverlaps] {
	if {$Ligne==""} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 0]
	#set JR [ac_JumeauRepresentatif $DD]
	#if {[info exists Vu($JR)]} {continue} else {set Vu($JR) 1}
	### INFOS DD 
	#############
	set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $DD N]
	# Attention: ne pas oublier le cas ou le DD fait partie des exclus, alors il n'a pas de "n"
	if {$NumGeneDD==""} {continue}
	set CodeClone [InterrogeFichierTotalDataDD $FichierTot $DD Code]
	set User [InterrogeFichierTotalDataDD $FichierTot $DD User]
	set Band [InterrogeFichierTotalDataDD $FichierTot $DD Bande]
	set ProfilCalc [InterrogeFichierTotalDataDD $FichierTot $DD Profil]
	set ProfilConsensus [InterrogeFichierTotalDataDD $FichierTot $DD ProfCons]

	set AccBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccProt]
	set DefBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefProt]
	set AccBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccRNA]
	set DefBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefRNA]

	set DifE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifE]
	set ProfE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfE]
	set DifS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifS]
	set ProfS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfS]
	set DifU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifU]
	set ProfU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfU]
	
	set DifMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifMoy]
	set ProfMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Pmoy]
	
	############
	set TAR [lindex $LesChamps 1]
	### INFOS AFFY #InterrogeFichierDataAffyPourTous3T
	##############
	set CodeAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR Code]
	set Def [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR Def]
	set DetN [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR DetN]
	set DetE [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR DetE]
	set DetS [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR DetS]
	set DetU [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR DetU]
	set IntN [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR IntN]
	set IntE [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR IntE]
	set IntS [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR IntS]
	set IntU [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR IntU]
	
	set FE [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR FE]
	set PE [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR PE]
	set FS [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR FS]
	set PS [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR PS]
	set FU [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR FU]
	set PU [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR PU]
	set FoldMoy [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR FoldMoy]
	set ProfilMoy [InterrogeFichierDataAffyPourTous3T $FichierAffy $TAR ProfMoy]
	
	AppendAuFichier $FichierSortie "$NumGeneDD\t$DD\t$TAR\t$CodeClone\t$Band\t$User\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestRNAHuman\t$DefBestRNAHuman\t$DifE\t$ProfE\t$DifS\t$ProfS\t$DifU\t$ProfU\t$DifMoy\t$ProfMoy\t$ProfilCalc\t$ProfilConsensus\t$CodeAffy\t$Def\t$DetN\t$DetE\t$DetS\t$DetU\t$IntN\t$IntE\t$IntS\t$IntU\t$FE\t$PE\t$FS\t$PS\t$FU\t$PU\t$FoldMoy\t$ProfilMoy"
    }

}

proc CreeFichierPourMainJumeaux {FichierDesPABs FichierSortie} {

    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    foreach Nom $L {
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom"
	if {![file exists $FichierProttfa]} {continue}
	set Seq [ContenuDuFichier $FichierProttfa]
	AppendAuFichier $FichierSortie $Seq
    }

}

proc CreeFichierProteineChoisieOuPas {FichierDesPABs FichierSortie} {

    #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts
    #FichierSortie=fiches/ProteineChoisieOuPas
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set Zero 0; set Un 0; set NoHuman 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access]
	#(peut ne rien rendre: pour DD1222 par exemple qui n'existe pas...)
	set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]
	if {$AccessProt=="NOPROTEIN" || $AccessProt==""} {
	    set Prot 0
	    incr Zero
	} elseif {$Orga=="Homo sapiens"} {set Prot 1; incr Un; lappend LesAccessProtHuman $AccessProt}
	if {$AccessProt!="NOPROTEIN" && $AccessProt!="" && $Orga!="Homo sapiens"} {set Prot 1; incr NoHuman; lappend LesAccessProtNotHuman $AccessProt}
	lappend Liste "$Nom\t$Prot"
    }
    Espionne [llength $Liste]
    set ListeTriee [lsort -unique $Liste]
    Espionne [llength $ListeTriee]
    Espionne "Nb zero: $Zero - Nb un: $Un - Nb nothuman: $NoHuman"
    
    Espionne "nb prot human avt tri : [llength $LesAccessProtHuman]"
    set LesAccessProtHumanUnique [lsort -unique $LesAccessProtHuman]
    Espionne "nb prot human sans doublons : [llength $LesAccessProtHumanUnique]"
    
    Espionne "nb prot not human avt tri : [llength $LesAccessProtNotHuman]"
    set LesAccessProtNotHumanUnique [lsort -unique $LesAccessProtNotHuman]
    Espionne "nb prot not human sans doublons : [llength $LesAccessProtNotHumanUnique]"
    #set ListeTriee2 [lsort -index 1 $ListeTriee]
    SauveLesLignes $ListeTriee dans $FichierSortie

}

proc CreeFichierProteineContigOuPas {FichierDesPABs FichierSortie} {

    #FichierDesPABs=fiches/LesDDSansJumSeqSansCourtsSansJumProtChoisie
    #FichierSortie=fiches/ProteineContigOuPas
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    set Zero 0; set Un 0; set NoHuman 0
    foreach Nom $L {
	set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access]
	set Orga [InterrogeProtAndContigChoisis $Nom OrganismeChoisi]
	if {$AccessProt==""} {
	    set Prot 0
	    incr Zero
	} elseif {$Orga=="Homo sapiens"} {set Prot 1; incr Un; lappend LesAccessProtHuman $AccessProt}
	if {$AccessProt!="" && $Orga!="Homo sapiens"} {set Prot 1; incr NoHuman; lappend LesAccessProtNotHuman $AccessProt}
	lappend Liste "$Nom\t$Prot"
    }
    Espionne [llength $Liste]
    set ListeTriee [lsort -unique $Liste]
    Espionne [llength $ListeTriee]
    Espionne "Nb zero: $Zero - Nb un: $Un - Nb nothuman: $NoHuman"
    
    Espionne "nb prot human avt tri : [llength $LesAccessProtHuman]"
    set LesAccessProtHumanUnique [lsort -unique $LesAccessProtHuman]
    Espionne "nb prot human sans doublons : [llength $LesAccessProtHumanUnique]"
    
    Espionne "nb prot not human avt tri : [llength $LesAccessProtNotHuman]"
    set LesAccessProtNotHumanUnique [lsort -unique $LesAccessProtNotHuman]
    Espionne "nb prot not human sans doublons : [llength $LesAccessProtNotHumanUnique]"
    #set ListeTriee2 [lsort -index 1 $ListeTriee]
    #SauveLesLignes $ListeTriee dans $FichierSortie

}

proc CreeFichierRedondanceSansJumeauxAccessProt {FichierRedondance} {

    foreach Ligne [LesLignesDuFichier $FichierRedondance] {
	if {![info exists Vu($Ligne)]} {
	    set Vu($Ligne) 1
	    set LesLignesDeJumeaux [LesLignesDesJumeauxAccessProt $Ligne $FichierRedondance]
	    set NewLigne {}
	    if {$LesLignesDeJumeaux==""} {
		lappend L $Ligne
	    } else {
		foreach LigneJum $LesLignesDeJumeaux {
		    set Vu($LigneJum) 1
		    set NewLigne [concat $NewLigne $LigneJum]
		}
		set NouvelleLigne [concat $Ligne $NewLigne]
		#Espionne $NouvelleLigne
		lappend L $NouvelleLigne
	    }
	}
    }
    return $L

}

proc CreeFichierTFADuGenomePourBanqueBlast {{FichierACreer ""}} {

    global RepertoireDuGenome
    global ADN DNA RAC
    global NotreOS
    global NotreOrga

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC  }

    if {$FichierACreer==""} {
	set FichierACreer "$RepertoireDuGenome/tfasdugenome/${NotreOrga}"
    }

    set Repertoire [file dirname $FichierACreer]
    if { ! [file exists $Repertoire]} { File mkdir $Repertoire }

    while {[file exists $FichierACreer]} {
	if {[OuiOuNon "$FichierACreer already exists. Do I overwrite it ?"]} {
	    break
	} else {
	    if {[OuiOuNon "Do I cancel ?"]} { return "" }	    
	    if {[OuiOuNon "Do I exit ?"]} { exit }
	}
    }

    FaireLire "give the title of the blastdatabase"
    set Titre [Entre "$NotreOrga:complete_genome"]

    set TFA [SequenceFormatTFA [string range $ADN 1 end] $Titre]
    set FichierACreer [Sauve $TFA dans $FichierACreer]

    return $FichierACreer

}

proc CreeFichierTFA_Ontario {{Fichier ""} {FichierOut ""}} {


    Wup "Permet d extraire les sequences des Id pour en faire un fichier fasta en vu de creer une banque blast"
    
    if {$Fichier    == ""} {set Fichier    "[RepertoireDuGenome]/Autres_Puces/Ontario/H19k_seq_250702.txt"}
    if {$FichierOut == ""} {set FichierOut "[RepertoireDuGenome]/Autres_Puces/Ontario/Banque_Blast/Chip_EST.tfa"}

    set NbPb      0                        
    set NbEntries 0
    set NbLigne   0

    set F  [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	#Original_Image_ID Verified_Image_ID accessID clusterID expectValue matchLength percentId score statusFlag sequence
	if {! [regexp -nocase {[a-z0-9]+}         $Ligne]} {continue}
	if {  [regexp -nocase "Original_Image_ID" $Ligne]} {continue}
	incr NbLigne
	set LigneSplitee [split $Ligne "\t"]

	set Original_Image_ID [lindex $LigneSplitee 0]
	set Verified_Image_ID [lindex $LigneSplitee 1]
	
	if {[regexp {No_seq|Unresolved} $Verified_Image_ID]} {
	    incr NbPb
	    continue
	}
	if {[regexp {N/A} $Verified_Image_ID]} {
	    if {! [info exists DejaFait($Original_Image_ID)]} {
		set DejaFait($Original_Image_ID) 1
	    } else {Espionne "On a deja $Original_Image_ID";continue} 
	}

	set accessionID [lindex $LigneSplitee 2]
	set clusterID   [lindex $LigneSplitee 3]
	set expectValue [lindex $LigneSplitee 4]
	set matchLength [lindex $LigneSplitee 5]
	set percentId   [lindex $LigneSplitee 6]
	set score       [lindex $LigneSplitee 7]
	set statusFlag  [lindex $LigneSplitee 8]
	set sequence    [lindex $LigneSplitee 9]
	
	set SeqSplitee  [split  $sequence " "]
	set Entete      [lindex $SeqSplitee 0]
	if {! [info exists Tab($Entete)]} {set Tab($Entete) 1} else {Espionne "$Entete already exists"}
	
	if {$Original_Image_ID!=$Verified_Image_ID && $Verified_Image_ID!=""} {
	    set ID $Verified_Image_ID
	} else {
	    set ID $Original_Image_ID
	}
	set Definition [InterrogeLeIOBFile_Ontario $ID Definition]

	regsub "^>" $Entete ">${Original_Image_ID}_${Verified_Image_ID} $Definition" Entete
	set VraiSeq    [join [lrange $SeqSplitee 1 end] ""]

	if {0 && [regexp {N/A} $Verified_Image_ID]} {
	    AppendAuFichier $FichierOut "$Entete $clusterID"
	    AppendAuFichier $FichierOut $VraiSeq
	}
	AppendAuFichier $FichierOut "$Entete $clusterID"
	AppendAuFichier $FichierOut $VraiSeq

	incr NbEntries
    }
    close $F

    Espionne "No seq for $NbPb entries"
    Espionne "Seq for $NbEntries entries"
    Espionne "Total seq $NbLigne entries"
    return ""

}

proc CreeFichierTousComplete {FichierSortie1} {

    # Sortie: /ANALYSE/TousComplete
    # Ajouter pour Regine (11 mai 2005)
    # la seq DD et sa longueur...+ sequence apres masking, L sans N, repeat, percent, refseq, go, kegg, pfama
    # + corrections pour paper1
    # + warning id prot

    #---Courts, conta et N
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsCourts"] {
	set Court($Ligne) 1
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsContamines.28"] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Nom $LesJumeaux {
	    set Conta($Nom) 1
	}
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsAvecN.6july05"] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	foreach Nom $LesJumeaux {
	    set N($Nom) 1
	}
    }
    #--- paper1
    set FichierCorres "[RepertoireDuGenome]/lacorrespondance"
    foreach Ligne [LesLignesDuFichier $FichierCorres] {
	if {$Ligne==""} {continue}
	set Ligne [split $Ligne "\t"]
	set New [lindex $Ligne 0]; set Old [lindex $Ligne 1]
	set O($Old) $New
    }
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/paper1"] {
	if {[info exists O($Ligne)]} {set DD $O($Ligne); set Paper($DD) 1} else {Espionne "no correspondance pour $Ligne"}
    }
    #---
    #la bande pour un couple (user, codeclone)
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] {
	## (rq: pas de user R dans ce fichier)
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set U [lindex $LesChamps 0]
	### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ######
	set CodeClone [string trim [lindex $LesChamps 1]]
	if {$U=="F"} {
	    set CodeClone [string toupper $CodeClone]
	}
	set B [lindex $LesChamps 2]
	set Band($U,$CodeClone) $B
    }
    #Espionne "[array names Band]"
    #Profil
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] {
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 0]
	set Prof [lindex $LesChamps 1]
	if {$Prof=="+"} {set P($DD) "T"}
	if {$Prof=="-"} {set P($DD) "N"}
	if {$Prof=="0"} {set P($DD) "C"}
    }
    #Profil_consensus
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/ResolutionTotaleDesConflits_pourGscope.txt"] {
	if {[regexp "gscopecode" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 1]
	set ProfCons [lindex $LesChamps 5]
	set Pc($DD) $ProfCons
    }
    #Intensites
    #############################################
    #           Attention!                      #
    # les numeros de bandes ne sont pas uniques #
    # Exemple: J PM et CW ont fait une bande 48 #
    #############################################
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Bands_intensiteDD.txt"] {
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set User [lindex $LesChamps 0]
	set B [lindex $LesChamps 1]
	regsub -all "\'" $B "" B
	set I_TE($User,$B) [lindex $LesChamps 3]
	set I_NE($User,$B) [lindex $LesChamps 4]
	set I_TS($User,$B) [lindex $LesChamps 5]
	set I_NS($User,$B) [lindex $LesChamps 6]
	set I_TU($User,$B) [lindex $LesChamps 7]
	set I_NU($User,$B) [lindex $LesChamps 8]
    }
    set FichierRefSeq "[RepertoireDuGenome]/overlapHumanmRNARefSeq/DDNMDef"
    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set FichierLocBox "[RepertoireDuGenome]/Localisation/oldBoxLocalisation_Human_Best"
    set FichierLocBox2 "[RepertoireDuGenome]/Localisation/BoxLoc"
    if {![file exists $FichierLocBox]} {Espionne "$FichierLocBox does not exist"}
    if {![file exists $FichierLocBox2]} {Espionne "$FichierLocBox2 does not exist"}
    set FichierLocBest "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
    if {![file exists $FichierLocBest]} {Espionne "$FichierLocBest does not exist"}
    set FichierSelectEST "[RepertoireDuGenome]/fiches/SelectedEST"
    foreach DD [ListeDesPABs] {
	Espionne $DD
	#---
	set JR [JumeauRepresentatif $DD]
	# Listes speciales
	if {[info exists Court($DD)]} {set InfoCourt 1} else {set InfoCourt 0}
	if {[info exists Conta($DD)]} {set InfoConta 1} else {set InfoConta 0}
	if {[info exists N($DD)]} {set InfoN 1} else {set InfoN 0}
	# Localisation
	set LesLocBest [InterrogeLocalisation $FichierLocBest Nom $DD]
	if {$LesLocBest==""} {
	    set LesLocBox [InterrogeLocalisation $FichierLocBox Nom $DD]
	    if {$LesLocBox==""} {
		set LesLocBox2 [InterrogeLocalisation $FichierLocBox2 Nom $JR]
		if {$LesLocBox2==""} {
		    set Chro ""; set Deb ""; set Fin ""; set Sens ""; set BandeCyto ""
		    Espionne "$JR est sans loc!"
		} else {
		    foreach Loc $LesLocBox2 {
			if {[regexp "Best" [lindex $Loc 20]]} {
			    set BandeCyto [lindex $Loc 19]
			    set Chro [lindex $Loc 9]
			    set Deb [lindex $Loc 10]
			    set Fin [lindex $Loc 11]
			    set Sens [lindex $Loc 12]
			    break
			}
		    }
		}
	    } else {
		foreach Loc $LesLocBox {
		    if {[regexp "Best" [lindex $Loc 20]]} {
			set BandeCyto [lindex $Loc 19]
			set Chro [lindex $Loc 9]
			set Deb [lindex $Loc 10]
			set Fin [lindex $Loc 11]
			set Sens [lindex $Loc 12]
			break
		    }
		}
	    }
	} else {
	    foreach Loc $LesLocBest {
		if {[regexp "Best" [lindex $Loc 20]]} {
		    set BandeCyto [lindex $Loc 19]
		    set Chro [lindex $Loc 9]
		    set Deb [lindex $Loc 10]
		    set Fin [lindex $Loc 11]
		    set Sens [lindex $Loc 12]
		    break
		}
	    }
	}
	# EST
	set EST [InterrogeSelectedEST $FichierSelectEST Nom $DD LesAccess]
	if {$EST==""} {set SiEST 0} else {set SiEST 1}
	# Papier Lemaire et al.
	if {[info exists Paper($DD)]} {set Papier 1} else {set Papier 0}
	# profil moyen (Jumeaux)
	set FichierFinal "[RepertoireDuGenome]/ANALYSE/final"
	set PMoy [InterrogeFichierFinal $DD PMoy]
	set IMoy [InterrogeFichierFinal $DD IMoy]
	#
	set CC [ExtraitInfo $DD "CodeClone"]
	set Ow [ExtraitInfo $DD "OwnerOfCDNA"]
	if {$Ow=="R"} {set Ow "I"}
	if {$Ow=="F"} {set CC [string toupper $CC]}
	set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access]
	set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" mRNA Access]
	# JR prot
	if {$JR!=""} {
	    if {$AccBestProtHuman==""} {
		set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" Protein Access]
	    }
	}
	# --
	if {$AccBestProtHuman!=""} {
	    set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition]
	    # Warning Identity pour BestProt Human
	    set IdBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Access $AccBestProtHuman Identity]
	    #set Identite [expr $IdBestProtHuman * 1.0]
	    set Identite $IdBestProtHuman
	    if {$Identite<0.6} {set Warning 1} else {set Warning ""}
	} else {set DefBestProtHuman ""; set Warning ""}
	# JR mRNA
	if {$JR!=""} {
	    if {$AccBestmRNAHuman==""} {
		set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" mRNA Access]
	    }
	}
	# --
	# GO, KEGG, Domaines
	#Les GOs
	set LesGO [InterrogeGeneOntology $FichierGO $DD LesGO]
	#Les Pathways KEGG
	set LesPathwaysKegg [InterrogeMesKEGG $DD LesPathway]
	#Les Domaines PFAMA (Id>0.8) 
	set LesDomainesPFAMA [InterrogeDomaines $DD LesDomaines]
	if {$AccBestmRNAHuman!=""} {
	    set DefBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestmRNAHuman Definition]
	    # Ontology
	    if {$LesGO==""} {set Ontology ""} else {
		set Ontology ""
		foreach GO $LesGO {
		    set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition]
		    append Ontology "$GO $LaDefinitionGO /"
		}
	    } 
	    # Pathways
	    if {$LesPathwaysKegg==""} {set Pathways ""} else {
		foreach Pathway $LesPathwaysKegg {
		    set Pathways ""
		    set LaDefinitionKEGG [InterrogeMesKEGG Pathway $Pathway Definition]
		    append Pathways "$Pathway $LaDefinitionKEGG /"
		} 
	    }
	    # DomainesPFAMA
	    if {$LesDomainesPFAMA==""} {set DomainesPFAMA ""} else {
		set DomainesPFAMA ""
		foreach LeDomaine $LesDomainesPFAMA {
		    set i 0; set Liste ""
		    foreach Do $LeDomaine {
			incr i
			if {$i<4} {lappend Liste $Do}
		    }
		    append DomainesPFAMA "$Liste /"
		}
	    }
	} else {set DefBestmRNAHuman "";set Ontology ""; set Pathways ""; set DomainesPFAMA ""}
	if {[info exists Band($Ow,$CC)]} {
	    set Bande $Band($Ow,$CC)
	    #Bandes de Fred du type H16B sans profil alors que H16 avec profil et meme bande
	    if {$Ow=="F" && [regexp -nocase {[A-Z]+[0-9]+[A-Z]} $Bande]} {
		regexp -nocase -indices {[A-Z]+[0-9]+} $Bande tmp
		set NewBande [string range $Bande 0 [lindex $tmp 1]]
		set Bande $NewBande
	    }
	    # Donnees manquantes (pour la plupart, clones de Fred)
	    if {(![info exists I_TE($Ow,$Bande)] || ([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)=="")) ||  (![info exists I_NE($Ow,$Bande)] ||  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)==""))} {
		set Ite ""
		set Ine ""
	    }
	    if {(![info exists I_TS($Ow,$Bande)] ||  ([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)=="")) ||  (![info exists I_NS($Ow,$Bande)] ||  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)==""))} {
		set Its ""
		set Ins ""
	    }
	    if {(![info exists I_TU($Ow,$Bande)] ||  ([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)==""))||  (![info exists I_NU($Ow,$Bande)] ||  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)==""))} {
		set Itu ""
		set Inu ""
	    }
	    if {([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)!="") &&  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)!="")} {
		set Ite $I_TE($Ow,$Bande)
		set Ine $I_NE($Ow,$Bande)
	    }
	    if {([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)!="") &&  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)!="")} {
		set Its $I_TS($Ow,$Bande)
		set Ins $I_NS($Ow,$Bande)
	    } 
	    if {([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)!="") &&  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)!="")} {
		set Itu $I_TU($Ow,$Bande)
		set Inu $I_NU($Ow,$Bande)
	    }
	    if {$Ite=="" && $Ine=="" && $Its=="" && $Ins=="" && $Itu=="" && $Inu==""} {
		Espionne "aucune valeur de gel DD pour cette bande: $Bande"
	    }
	} else {
	    Espionne "$DD : no band"
	    #AppendAuFichier $FichierPbsBand "$DD $CC $Ow"
	    set Bande ""; set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu ""
	}
	if {[info exists P($DD)]} {set Profil $P($DD)} else {set Profil ""}
	if {[info exists Pc($DD)]} {set Pcons $Pc($DD)} else {set Pcons ""}
	# --- Ajout
	#RefSeq
	set AccessRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $DD NM]
	set DefRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $DD Def]
	if {$AccessRefSeq==""} {set AccessRefSeq "";set DefRefSeq ""}
	###
	set FichierNuctfa "[RepertoireDuGenome]/nuctfaNEW/$DD"
	if {![file exists $FichierNuctfa]} {
	    Espionne "$FichierNuctfa does not exist";set Seq ""; set LSeq ""
	} else {
	    set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa]
	    set LSeq [string length $Seq]
	}
	set FichierMRM "[RepertoireDuGenome]/nucmask/$DD"
	set FichierMRMCorrigePlasmide "[RepertoireDuGenome]/nucmask_SansBoutPlasmide/$DD"
	if {[file exists $FichierMRMCorrigePlasmide]} {set FichierMRM $FichierMRMCorrigePlasmide}
	set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM]
	regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN
	set LSansN [string length $SeqMRMSansN]
	if {[InterrogeBilanMasking $DD LesEtats] != ""} {
	    set PercentMask  [InterrogeBilanMasking $DD Etat MRM PMasked ]
	    set LesRepeatsMasques [InterrogeBilanMasking $DD Etat MRM LesRepeats]
	}
	# --- fin ajout
	AppendAuFichier $FichierSortie1 "$DD\t$JR\t$CC\t$Ow\t$Bande\t$Seq\t$LSeq\t$SeqMRM\t$LSansN\t$LesRepeatsMasques\t$PercentMask\t$InfoCourt\t$InfoConta\t$InfoN\t$Chro\t$Deb\t$Fin\t$Sens\t$BandeCyto\t$SiEST\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Warning\t$AccessRefSeq\t$DefRefSeq\t$Ontology\t$Pathways\t$DomainesPFAMA\t$Profil\t$Pcons\t$PMoy\t$IMoy\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu\t$Papier"
    }

}

proc CreeFichierTousLesPABs {Fichier2467 FichierSortie} {

    foreach Nom [ListeDesJR $Fichier2467] {
	set CC [ExtraitInfo $Nom CodeClone]
	set User [ExtraitInfo $Nom OwnerOfCDNA]
	set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom"
	if {![file exists $FichierNuctfa]} {Espionne "$FichierNuctfa doesn t exist";set Seq ""; set LSeq ""} else {set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa];set LSeq [string length $Seq]}
	lappend Liste "$Nom\t$CC\t$User\t$LSeq\t$Seq"
    }
    Espionne [llength $Liste]
    set Ltriee [lsort -unique $Liste]
    Espionne [llength $Ltriee]
    SauveLesLignes $Ltriee dans $FichierSortie

}

proc CreeFichiersListesPABsDesFamilles {} {

    global RepertoireDuGenome
    if {![file exists "$RepertoireDuGenome/Families/Listes"} {
	File mkdir "$RepertoireDuGenome/Families/Listes"
    }
    foreach Nom [ListeDesPABs] {
	set Fam [NomDeFamille $Nom]
	lappend LesPABsDeLaFamille($Fam) $Nom
    }
    

}

proc CreeFichiersProtTFAEtProtEMBL {{LesNoms ""}} {

    global RepertoireDuGenome

    set RepProtTFA    "$RepertoireDuGenome/prottfa"
    if {![file exists "$RepProtTFA" ]} {File mkdir $RepProtTFA }
    set RepProtEMBL   "$RepertoireDuGenome/protembl"
    if {![file exists "$RepProtEMBL"]} {File mkdir $RepProtEMBL}
    set RepFiches     "$RepertoireDuGenome/fiches"
    set FichierCV     "$RepFiches/CrossValidation"
    if {![file exists "$FichierCV"]} {
	FaireLire "$FichierCV does not exist\.\nI am going to create it\."
	CrossValidationPourTous "" Save
    }

    set SeuilIdMinMemeOrga        0.95
    set SeuilIdMinDiffOrga        0.85
    if {[OuiOuNon "The threshold of Identitie for the same organism is $SeuilIdMinMemeOrga.\nWould you want to change it?" 0]} {
	set SeuilIdMinMemeOrga [Entre $SeuilIdMinMemeOrga]
    } 
    if {[OuiOuNon "The threshold of Identitie for the other organism is $SeuilIdMinDiffOrga.\nWould you want to change it?" 0]} {
	set SeuilIdMinDiffOrga [Entre $SeuilIdMinDiffOrga]
    }

    set LesFichiersExistants [glob -nocomplain "$RepProtTFA/*"]
    set ConserveFichiers 0
    if {0 < [llength $LesFichiersExistants]} {
	if {[OuiOuNon "Some Files exist in the saving directory.\nWould you want to keep this files?"] } {
	    set ConserveFichiers 1
	}
    }
    
    ChargeFichierDeCrossValidation CrossValidation

    if {$LesNoms == {} } {set LesNoms [ListeDesPABs]}
    foreach Nom $LesNoms {
	set MonOrganisme [OrganismeDuPAB $Nom]
	if {$MonOrganisme=="" || $MonOrganisme=="Inconnu inconnu"} {
	    set MonOrganisme [NotreOS]
	    if {$MonOrganisme=="" || $MonOrganisme=="Inconnu inconnu"} {
		set MonOrganisme "Vraimentinconnu vraimentinconnu"
	    }
	}

	if {[info exists BId]   } {unset BId   }
	if {[info exists Access]} {unset Access}

	Espionne "\n$Nom"
	if {$ConserveFichiers == 1 && [file exists "$RepProtTFA/$Nom"]} {continue}

	if {![info exists CrossValidation($Nom,Info)]} {continue}
	set Info     [set CrossValidation($Nom,Info)     ]
	if {![info exists CrossValidation($Nom,Organisme)]} {continue}

	set Organisme [set CrossValidation($Nom,Organisme)]
	scan $Organisme "%s %s" Genre Espece 

	if {$Info == "JustmRNA"} {
	    set BIdmRNA    [set CrossValidation($Nom,mRNA,BanqueId)]
	    set AccessmRNA [set CrossValidation($Nom,mRNA,Access)  ]

	    set IdentitiesmRNA [set CrossValidation($Nom,mRNA,Identities)]
	    set FichierBlast "$RepertoireDuGenome/blastngenembl/$Nom"

	    Espionne "$FichierBlast $BIdmRNA"
	    set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BIdmRNA]
	    scan $IdentitiesmRNA "%f/%f " Nb NbTot
	    set  IdmRNA [expr $Nb/($NbTot-$NbBasesFiltrees)]

	    if {[regexp -nocase "$Espece" [OrganismeDuPAB $Nom]]} {
		if {$IdmRNA < $SeuilIdMinMemeOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdmRNA $AccessmRNA is not a good mRNA, [expr round(100*$IdmRNA)]% of Identitie."
		    continue
		} 
	    } else {
		if {$IdmRNA < $SeuilIdMinDiffOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdmRNA $AccessmRNA is not a good mRNA, [expr round(100*$IdmRNA)]% of Identitie."
		    continue
		} 
	    }
	    Espionne "$Nom $Organisme $Info -> I am going to launch blastx with the mRNA completeCDS $BIdmRNA $AccessmRNA"

	    set Seq    [SequenceDeLAccess $AccessmRNA]
	    set SeqTFA [SequenceFormatTFA $Seq "$Nom $BIdmRNA $AccessmRNA $Organisme"]
	    set FichierTFA   "[RepertoireDeTravail]/${AccessmRNA}\.tfa"
	    Sauve $SeqTFA dans $FichierTFA

	    set FichierBlast "[RepertoireDeTravail]/${AccessmRNA}\.blastx"

	    Espionne "$Nom $Organisme $Info -> BlastX with $AccessmRNA sequence"
	    BlastXDuFichier $FichierTFA protein 0 $FichierBlast 0

	    Espionne "$Nom $Organisme $Info -> Extracting the best protein in the BlastX file"
	    DepouilleLeBlast TabBlast $FichierBlast 1e-3 50
	    set NbSubjectDansBlast [set TabBlast(NbSubject)  ]
	    for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {
		set BIdProt    [set TabBlast($i)             ]
		set AccessProt [set TabBlast($BIdProt,Access)]
		
		set OS [join [LesOrgasDeLAccess $AccessProt] "\t"]
		#set OS [QuiEsTu $BIdProt $AccessProt]
		
		set Identities [set TabBlast($BIdProt,1,Identities)]
		if {[regexp -nocase "$Espece" $OS]} {
		    scan $Identities "%f/%f " Nb NbTot
		    set  Id [expr $Nb/$NbTot]
		    if {$Id < $SeuilIdMinMemeOrga} {continue} 
		    set BId    $BIdProt
		    set Access $AccessProt
		    break
		}
	    }
	    if {![info exists Access]} {
		Espionne "$Nom $Organisme $Info -> $BIdmRNA $AccessmRNA no protein found in bank."
		continue
	    }
	    unset TabBlast
	    unset Espece
	    if {[file exists $FichierBlast]} {File delete -force $FichierBlast}
	    if {[file exists $FichierTFA  ]} {File delete -force $FichierTFA}
	} elseif {$Info == "JustProt"} {
	    set BIdProt        [set CrossValidation($Nom,Proteine,BanqueId)  ]
	    set AccessProt     [set CrossValidation($Nom,Proteine,Access)    ]

	    set Identities [set CrossValidation($Nom,Proteine,Identities)]

	    set FichierBlast "$RepertoireDuGenome/blastx/$Nom"
	    if {![file exists $FichierBlast]} {continue}

	    Espionne "$FichierBlast >$BIdProt<"
	    set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BIdProt]
	    scan $Identities "%f/%f " Nb NbTot

	    set  Id [expr $Nb/($NbTot-$NbBasesFiltrees)]

	    set OS [join [LesOrgasDeLAccess $AccessProt] "\t"]
	    #set OS [QuiEsTu $BIdProt $AccessProt]
	    
	    if {[SameOrganism $MonOrganisme $Organisme]} {
		if {$Id < $SeuilIdMinMemeOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdProt $AccessProt is not a good protein, [expr round(100*$Id)]% of Identitie."
		    continue
		} 
	    } else {
		if {$Id < $SeuilIdMinDiffOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdProt $AccessProt is not a good protein, [expr round(100*$Id)]% of Identitie."
		    continue
		} 
	    }
	    set BId    $BIdProt
	    set Access $AccessProt
	} elseif {$Info == "CrossValidation"} {
	    set BIdmRNA       [set CrossValidation($Nom,mRNA,BanqueId)    ]
	    set AccessmRNA    [set CrossValidation($Nom,mRNA,Access)      ]
	    set BIdProt       [set CrossValidation($Nom,Proteine,BanqueId)]
	    set AccessProt    [set CrossValidation($Nom,Proteine,Access)  ]

	    set IdentitiesmRNA [set CrossValidation($Nom,mRNA,Identities)]
	    set FichierBlast "$RepertoireDuGenome/blastngenembl/$Nom"
	    set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BIdmRNA]
	    scan $IdentitiesmRNA "%f/%f " Nb NbTot 
	    set  IdmRNA [expr $Nb/($NbTot-$NbBasesFiltrees)]

	    set IdentitiesProt [set CrossValidation($Nom,Proteine,Identities)]
	    set FichierBlast "$RepertoireDuGenome/blastx/$Nom"
	    set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BIdProt]
	    scan $IdentitiesProt "%f/%f " Nb NbTot
	    set  IdProt [expr $Nb/($NbTot-$NbBasesFiltrees)]

	    if {[SameOrganism $MonOrganisme $Organisme]} {
		if {$IdmRNA < $SeuilIdMinMemeOrga && $IdProt < $SeuilIdMinMemeOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdmRNA $AccessmRNA is not a good mRNA, [expr round(100*$IdmRNA)]% of Identitie."
		    continue
		} 
	    } else {
		if {$IdmRNA < $SeuilIdMinDiffOrga && $IdProt < $SeuilIdMinDiffOrga} {
		    Espionne "$Nom $Organisme $Info -> $BIdmRNA $AccessmRNA is not a good mRNA, [expr round(100*$IdmRNA)]% of Identitie."
		    continue 
		} 
	    }
	    set BId    $BIdProt
	    set Access $AccessProt
	} else {
	    continue
	}

	set SeqEMBL [join [LaSequenceDesBanques $BId $Access AccessOK OnVeutEMBL] "\n"]
	Sauve $SeqEMBL dans "$RepProtEMBL/$Nom"

	set SeqTFA  [SequenceFormatTFA $SeqEMBL "$Nom $BId $Access $Organisme" "embl"]
	Sauve $SeqTFA dans "$RepProtTFA/$Nom"
	Espionne $SeqTFA
    }

}

proc CreeFichiersmRNAHuman {{LesNoms ""}} {

    global RepertoireDuGenome
    
    set Organisme "Homo sapiens"

    set NbSubject 5

    set RepmRNA "$RepertoireDuGenome/mrnahuman"
    if {![file exists $RepmRNA]} {File mkdir $RepmRNA}

    if {[llength [glob -nocomplain "$RepmRNA/*"]] > 0 && [OuiOuNon "Some files exist in $RepmRNA, would you want to conserv them?"]} {
	set ReInitialise 0
    } else {
	set ReInitialise 1
    }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/beton/miniconfig"] {
	if {![regexp "^NotreOS " $Ligne]} {continue}
	regsub "^NotreOS " $Ligne "" NotreOS
    }

    if {$NotreOS != $Organisme} {set SeuilIdMin 0.85} else {set SeuilIdMin 0.95}

    if {[OuiOuNon "The threshold of Identitie is $SeuilIdMin.\nWould you want to change it?"]} {
	set SeuilIdMin [Entre $SeuilIdMin]
    }
    if {$LesNoms == {}} {set LesNoms [ListeDesPABs]}
    
    foreach Nom $LesNoms {
	set FichierTFA   "$RepmRNA/$Nom"
	set FichierBlastmRNA "$RepertoireDuGenome/mrnablastnhuman"
	
	if {[file exists $FichierTFA] && [file exists $FichierBlastmRNA] && $ReInitialise == 0} {continue}

	Espionne "$Nom -> searching...."
	ChargeInfosDeLaRechercheDeProtEtDemRNAs LesHits $Nom
	if {![info exists LesHits($Organisme,mRNA,Access)]} {
	    Espionne "$Nom -> no mRNA Complete CDS for $Organisme" 
	    continue
	} 
	set AccessmRNA [set LesHits($Organisme,mRNA,Access)   ]
	set BIdmRNA    [set LesHits($Organisme,mRNA,BanqueId) ]

	set IdentitiesmRNA [set LesHits($Organisme,mRNA,Identities)]
	set FichierBlast "$RepertoireDuGenome/blastngenembl/$Nom"

	set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BIdmRNA]
	scan $IdentitiesmRNA "%f/%f " Nb NbTot

	set  IdmRNA [expr $Nb/($NbTot-$NbBasesFiltrees)]

	unset LesHits($Organisme,mRNA,Access)
	if {$IdmRNA < $SeuilIdMin} {
	    Espionne "$Nom -> $AccessmRNA is not a good mRNA, [expr round(100*$IdmRNA)]% of Identitie." 
	    continue
	}

	set Seq    [SequenceDeLAccess $AccessmRNA]
	set SeqTFA [SequenceFormatTFA $Seq "$Nom $BIdmRNA $AccessmRNA $Organisme"]
	Espionne $SeqTFA
	
	Espionne "$Nom -> $AccessmRNA seems to be a good mRNA, [expr round(100*$IdmRNA)]% of Identitie."
	Sauve $SeqTFA dans $FichierTFA
	Espionne $SeqTFA
    }
    Espionne "The End"
    return ""

}

proc CreeGIF {} {


    set K .toto
    canvas $K -width 100 -height 200 
    $K create rectangle 20 20 40 50 -fill "red"
    CanvaEnGIF $K "OnVeutTout" "[HomeRipp]/gigi.gif"
    destroy $K

}

proc CreeGalerie {G} {

    global ExpoCourante

    CreeExpo $ExpoCourante

    Warne "Creation de la galerie $G"

    frame $G 
    pack  $G -expand yes -fill both 

    label $G.msg -wraplength 4i -justify left -text "$G" -relief sunken -borderwidth 1
    pack  $G.msg
    frame $G.frame -borderwidth 10
    pack  $G.frame -expand yes -fill both

    set Largeur 400
    set Hauteur 600

    canvas $G.frame.mur  -width $Largeur -height $Hauteur  -scrollregion "0 0 0 0"  -confine true  -background grey  -xscrollcommand "$G.frame.xscroll set"  -yscrollcommand "$G.frame.yscroll set"

    scrollbar $G.frame.yscroll -command "$G.frame.mur yview"
    scrollbar $G.frame.xscroll -command "$G.frame.mur xview" -orient horizontal

    grid              $G.frame.mur     -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
    grid              $G.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
    grid              $G.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
    grid rowconfig    $G.frame 0 -weight 1 -minsize 0
    grid columnconfig $G.frame 0 -weight 1 -minsize 0


}

proc CreeGeneOntologyGPO {} {

    #rR ne sert pas car on peut utiliser ParseAnnotationXml
    exit
    set Rep "[RepertoireDuGenome]/annotation"
    set LaSortie {}
    foreach Nom [ListeDesPABs] {
	set FichierXml "$Rep/$Nom.xml"
	if {[FileAbsent $FichierXml]} { continue }
	Espionne $FichierXml
	foreach Ligne [LesLignesDuFichier $FichierXml] {
	    if {   [regexp "" $Ligne]} { break }
	    if { ! [regexp "]+>([^<]+)} $Ligne Match Go Type Name]} {
		FaireLire $Ligne
		continue
	    }
	    regsub "biological_|cellular_|molecular_" $Type "" Type
	    set Info "$Nom\t\t$Nom\t$Type\t$Go\t$Name"
Espionne $Info
	    lappend LaSortie $Info
	}
    }
    return [SauveLesLignes $LaSortie dans "[RepertoireDuGenome]/fiches/GeneOntology_GPO.new"]

}

proc CreeHistogramme {liste N {sortie ""} {K ""} {color white} {tag ""} {min ""} {max ""} {step ""}} {

    
    if {$liste == {} } {return}
    
    set Lt [lsort -increasing -real $liste]
    if {$min eq ""} {
	set min [lindex $Lt 0]
    }
    if {$max eq ""} {
	set max [lindex $Lt end]
    }
    if {$step eq ""} {
	set step [expr {double(($max - $min))/$N}]
    }
    set d $min
    for {set i 0} {$i < $N} {incr i} {
	set d [expr {$min + $i * $step}]
	set f [expr {$d + $step}]
	set T($d) 0
	lappend Bornes $d
	foreach e $liste {
	    if {$e >= $d && $e < $f} {
		incr T($d)
	    }
	}
	lappend LesY [set T($d)]
    }
    
    if {$sortie eq "graph"} {
	set wdt [$K cget -width]
	set hgt [$K cget -height]
	set Ltag [lrepeat [llength $Bornes] $tag]
	return [Graphe $Bornes $LesY $K $color $wdt $hgt "" "" "" $Ltag]
    } else {
	return [array get T]
    }

}

proc CreeHtmlAnnoteParTousPourUnAccess {Access {RepParent ""}} {

    set FichierXml [CreeXmlAnnoteParTousPourUnAccess $Access $RepParent]
    if {[FileAbsent $FichierXml]} {return ""}
    regsub {\.xml$} $FichierXml ".html" FichierHtml 
    set Html [HtmlFromXmlMacsim $FichierXml]
    return [Sauve $Html dans $FichierHtml]

}

proc CreeHtmlAnnotePourUnMsf {FichierMsf {RepParent ""}} {

    set FichierXml [CreeXmlAnnotePourUnMsf $FichierMsf $RepParent]
    regsub {\.xml$} $FichierXml ".html" FichierHtml 
    set Html [HtmlFromXmlMacsim $FichierXml]
    return [Sauve $Html dans $FichierHtml]

}

proc CreeHumanJunctionBankFromFarkas {} {

    set File "/genomics/link/SpliRetMouse/201404/PubliFarkas/GSE40524_junctions_high-quality.bed"
    set i 0
    foreach Ligne [LesLignesDuFichier $File] {
	if {[regexp "track" $Ligne]} {continue} 
	incr i
#	Espionne "$Ligne"
	set LesMots [split $Ligne "\t"]
	set Chr         [string trim [lindex $LesMots 0]]
	set CoordStart  [string trim [lindex $LesMots 1]]
	set CoordStop   [string trim [lindex $LesMots 2]]
	set Name        [string trim [lindex $LesMots 3]]
	set BlockSizes  [string trim [lindex $LesMots 10]]
	set BlockSize1  [lindex [split $BlockSizes ","] 0]
	set BlockStarts [string trim [lindex $LesMots 11]]
	set BlockStart2 [lindex [split $BlockStarts ","] 1]
	set CoordStart    [expr $CoordStart +1]
	set CoordStopInt  [expr $CoordStart + $BlockSize1 -1]
	set CoordStartInt [expr $CoordStart + $BlockStart2]
#	Espionne "$CoordStart $CoordStopInt $CoordStartInt $CoordStop"
	set seq1 [BoutADNDeUcsc $CoordStart $CoordStopInt F Homo_sapiens $Chr bigZips200903]
	set seq2 [BoutADNDeUcsc $CoordStartInt $CoordStop F Homo_sapiens $Chr bigZips200903]
	set seq "${seq1}$seq2"
#	Espionne "$seq1"
#	Espionne "$seq2"
	lappend JunctionsHumanFromFarkas ">${Chr}_${CoordStart}-${CoordStop}_${i}_${Name}"
	lappend JunctionsHumanFromFarkas "$seq"
    }
    SauveLesLignes $JunctionsHumanFromFarkas dans "/genomics/link/SpliRetMouse/201404/PubliFarkas/JunctionsHumanFromFarkas"

}

proc CreeId {n l} {

    if {[llength $n] > 1} {
	lset n 2 3 $l
    } else {
	set n [list $n {} [list name $n length $l AngAbs 0. ordre 0 theta 0. oldtheta 0. r 0. width 0]]
    }

    return $n

}

proc CreeImagesDeFonte {} {

    package require Tk
    #package require Img
    
    set Lignes "I white magenta
    J white magenta
    L white magenta
    M white magenta
    V white magenta
    R white blue
    K white blue
    F white red
    Y white red
    W white red
    D white forestgreen
    B white forestgreen
    E white forestgreen
    Z black green1
    Q black green1
    P white black
    G black orange
    H black cyan
    N black cyan
    S white darkviolet
    T white darkviolet
    A white darkviolet
    U white darkviolet
    C white darkviolet
    X black dimgrey
    . black dimgrey
    0 black white
    1 black white
    2 black white
    3 black white
    4 black white
    5 black white
    6 black white
    7 black white
    8 black white
    9 black white
    Space white white"

    set Lmap [list]
    foreach l [split $Lignes \n] {
	lassign [split [string trim $l] " "] n f b
	lappend Lmap [list $n $f $b]
    }

    font create FonteImg -family CourierNew -size 8 -weight normal

    set w ".b"
    label $w  -font FonteImg  -bd 0  -padx 0 -pady 0  -width 1 -height 1  -anchor = $OnEnEmpile } {
	    $ExpoCourante.cloture invoke
	    set DejaEmpiles 0
	}
    }
    frame $w -borderwidth 10
    Warne "Creation de $w"
    return $w

}

proc CreeIndexes {Couleur LesOrdres} {

    global LesOrdresTries
    global IndexesDesOrdres
    
    if {! [info exists LesOrdresTries] } {
	set LesOrdresTries($Couleur) $LesOrdres
    }
    
    scan [BoundingBox [ListeDeBoites]] "%d %d" xDebut xFin
    set xDebut [Maxi 0 [expr $xDebut-3000]]
    incr xFin 1000
    set ScalX [ expr 1024.0 / ( $xFin - $xDebut ) ]
    set Pas [expr round ( ( 10240.0 / round ( 1.0 / $ScalX ) ) * ( $xFin - $xDebut ) / 1024.0 ) ]
    set DebutCourant $xDebut
    set FinCourant [expr $xDebut + $Pas]

    set I 0
    set IndexesDesOrdres($xDebut) "0 0"
    set OnALimiteMin 0
    foreach Ligne $LesOrdresTries($Couleur) {
	if { [regexp {^create} $Ligne] } {
	    if {[info exists X1]} { unset X1 }
	    if {[info exists Y1]} { unset Y1 }
	    if {[info exists X2]} { unset X2 }
	    if {[info exists Y2]} { unset Y2 }
	    
	    scan $Ligne "%s %s %f %f %f %f" Create Object X1 Y1 X2 Y2
	    set OnContinue 0
	    if { ! [info exists X2] } { set X2 $X1 }
	    if { ($X1 <= $DebutCourant && $DebutCourant < $X2) ||  ($X1 <= $FinCourant   && $FinCourant   < $X2) ||  ($DebutCourant < $X1  && $X2 <= $FinCourant) } {
		set OnContinue 1
	    }
	    
	    if { ! $OnALimiteMin && $X2 >= $FinCourant } {
		set LimiteMin $I
		set OnALimiteMin 1
	    }
	    
	    if { ! $OnContinue } {
		if { ! $OnALimiteMin } { set LimiteMin $DebutCourant }
		set DebutCourant $FinCourant
		set IndexesDesOrdres($DebutCourant) "$I $LimiteMin"
		incr FinCourant $Pas
		set OnALimiteMin 0
	    }
	}
	incr I
    }
    
    set ASauver {}
    set LesIndexTries [lsort -integer [array names IndexesDesOrdres]]
    foreach IndexCourant $LesIndexTries {
	lappend ASauver "$IndexCourant [set IndexesDesOrdres($IndexCourant)]"
    }
    lappend ASauver "$FinCourant [llength [set LesOrdresTries($Couleur)]] [llength [set LesOrdresTries($Couleur)]]" 
    
    return $ASauver

}

proc CreeIndividu {} {

    set TousLesMots   [InterrogeLesEffectifsDesMots TousLesMots]
    set NbMots        [llength $TousLesMots]
    foreach Mot $TousLesMots {
	set Tab($Mot,n) 0
	foreach MotSuiv [InterrogeLesEffectifsDesMots Mot $Mot LesSuivants] {
	    set Tab($Mot,$MotSuiv,n) 0
	}
    }

    set nMot          [Aleatoire 0 [expr $NbMots-1]]
    set MotPrec       [lindex $TousLesMots $nMot]
    set LIndividu     [list ""]
    while {$MotPrec != ""} {
	lappend LIndividu $MotPrec
	incr    Tab($MotPrec,n)
	set LesSuivants {}
	foreach Mot [InterrogeLesEffectifsDesMots Mot $MotPrec LesSuivants] {
	    set NTot      [InterrogeLesEffectifsDesMots Mot $Mot n]
	    set n         [set Tab($Mot,n)]
	    set NTotPaire [InterrogeLesEffectifsDesMots Couple $MotPrec $Mot n]
	    set nPaire    [set Tab($MotPrec,$Mot,n)]
	    if {[expr $NTot - $n]           <= 0} {continue} 
	    if {[expr $NTotPaire - $nPaire] <= 0} {continue}
	    lappend LesSuivants $Mot
	}
	if {$LesSuivants == {}} {set MotPrec "";continue}
	set     NbSuivants  [llength $LesSuivants]
	set     nSuivant    [Aleatoire 0 [expr $NbSuivants-1]]
	set     Mot         [lindex $LesSuivants $nSuivant]
	incr    Tab($MotPrec,$Mot,n)
	set     MotPrec $Mot
    }
    return [Evaluation $LIndividu]

}

proc CreeLAlignementDeLaFenetre {format {outfile ""}} {

    global tcl_platform OrdTmpDir NomNomSeq NomTextSeq

    if {! [ModeI]} {return}
    if {[TypeAli] eq "pasdali"} {return}

    if {$outfile eq ""} {set outfile [DemandeEtSauveFichier $format 1]}
    if {$outfile eq ""} {return}

    set d [$NomTextSeq index @0,0]
    lassign [split $d "."] ym xm 
    set f [$NomTextSeq index @[winfo width $NomTextSeq],[winfo height $NomTextSeq]]
    lassign [split $f "."] yx xx 
    while {$xx == 0} {
	set f [$NomTextSeq index "$yx.$xx - 1c"]
	lassign [split $f "."] yx xx 
    }
    # lassign [VisiblePartOfAlignment] xm ym xx yx

    for {set j $ym} {$j <= $yx} {incr j} {
	set n [$NomNomSeq get $j.0 "$j.0 lineend"]
	if {[string trim $n] eq ""} {
	    lappend seqs ""
	    lappend noms ""
	    continue
	}
	set s [$NomTextSeq get $j.$xm $j.$xx]
	if {[string index $s end] == "\n"} {set s [string range $s 0 end-1]}
	lappend seqs $s
	lappend noms $n
    }

    set ftmp [file join $OrdTmpDir "[pid]_tfatmptfatmp.tfa"]
    set f [open $ftmp w]
    set LongueurTotale [expr {$xx-$xm}]
    foreach Nm $noms Sq $seqs {
	puts $f ">$Nm"
	set Sq [string map [list "Z" "-" "." "-" " " "-"] $Sq]
	set D 0
	while {$D < $LongueurTotale} {
	    set F [expr {$D + 59}]
	    set L [string range $Sq $D $F]
	    puts $f "$L"
	    incr D 60
	}
    }
    close $f

    if {$format == "TFA"} {
	file rename -force $ftmp $outfile
	return
    }

    set Commande "[ClustalwExe] -convert -output=gscope -outfile=$outfile -infile=$ftmp"
    if {$tcl_platform(platform) == "windows"} {
	regsub -all -- "-" $Commande "/" Commande
    }
    eval exec $Commande

    file delete -force $ftmp

    return

}

proc CreeLaBanqueBlastClonage {{NomDeLaBanque ""} {Specif ""}} {

    if {$NomDeLaBanque==""} { set NomDeLaBanque "All[file tail [RepertoireDuGenome]]" }

    set LesTermesSpecifs {}
    if {$Specif!=""} {
	set LesTermesSpecifs [LesVirtualPPCRsDuPGS $Specif]
	lappend LesTermesSpecifs $Specif
    }

    if {[regexp "/" $NomDeLaBanque]} {
	set RepDeLaBanque [file dirname $NomDeLaBanque]
	set NomDeLaBanque [file tail $NomDeLaBanque]
    } else {
	set RepDeLaBanque "[RepertoireDuGenome]/banques"
	set NomDeLaBanque [file tail $NomDeLaBanque]	
    }

    set Banque "$RepDeLaBanque/$NomDeLaBanque"
    while {[file exists $Banque]} {
	if {[OuiOuNon "$Banque already exists. Do I cancel CreeLaBanqueBlastClonage ?"]} { return $Banque }
	if {[OuiOuNon "$Banque already exists. Do I replace it ?"]} { break }
    }
	
#    set LesGlobs [list "nuctfa/*" "rec1/*" "rec2/*" "ppcr/*" "ppcr_virtuels/*" "oligos/*.tfa" "vecteurs/pDONR/*.tfa" "vecteurs/pDEST/*.tfa"]
    set LesGlobs [list "nuctfa/*" "ppcr_virtuels/*" "oligos/*.tfa"]
    foreach Glob $LesGlobs {
	if {[regexp "^/" $Glob]} {
	    set FiGlob $Glob
	} else {
	    set FiGlob "[RepertoireDuGenome]/$Glob"
	}
	foreach FiTFA [glob -nocomplain $FiGlob] {
	    set Queue [file tail $FiTFA]

	    if {$Specif!=""} {
		set Ok 0
		foreach Terme $LesTermesSpecifs {
		    if {[regexp {^P[0-9]+.tfa$} $Queue] || [regexp $Terme $Queue]} {set Ok 1 ; break}
		}
		if { ! $Ok } { continue }
	    }
	    Espionne "I keep $Queue"
	    if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
	    if { ! [regexp "^>" [PremiereLigneDuFichier $FiTFA]]} { continue }
	    Espionne $FiTFA
	    lappend LeTFA [ContenuDuFichier $FiTFA]
	}
    }
    SauveLesLignes $LeTFA dans $Banque
    exec formatdb -i $Banque -p F
    return $Banque

}

proc CreeLaBanqueBlastDesFungisComplets {{FichierIn ""} {Banque ""}} {


    Wup "Permet de creer une banque blast a partir du fichier TFA"
   
    set RepBanque "[RepertoireDuGenome]/banques"

    if {![file exists "$RepBanque"]} {
	file mkdir    "$RepBanque"
    }
    if {! [file exists $FichierIn]|| $Banque==""} {return ""}
    
    set Cmdformadb "formatdb  -i $FichierIn  -o T  -t $Banque  -p F  -n \"$RepBanque/$Banque\""
    if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"}

    return ""

}

proc CreeLaBanqueBlastDesVecteurs {{Banque ""} {RepDestination ""} {RepVecteurs ""}} {


    if {$Banque==""} { set Banque "AllVectors" }
    if {$RepVecteurs==""} { set  RepVecteurs "[RepertoireDuGenome]/vecteurs/p*" }
    if {$RepDestination==""} { set RepDestination "[RepertoireDuGenome]/banques" }

    set FicBanque "$RepDestination/$Banque"

    while {[file exists $FicBanque]} {
	if {[OuiOuNon "$FicBanque already exists. Do I replace it ?"]} { break }
	if {[OuiOuNon "$FicBanque already exists. Do I cancel CreeLaBanqueBlastDesVecteurs ?"]} { return "" }
    }

    foreach FicTFA [glob -nocomplain "$RepVecteurs/*.tfa"] {
	lappend LesTFAs [ContenuDuFichier $FicTFA]
    }
    SauveLesLignes $LesTFAs dans $FicBanque

    NousAllonsAuBoulot $RepDestination
    if {[catch {exec formatdb -i $Banque -p F} Message]} {
	FaireLire "Error from formatdb :\n$Message"
	OnRevientDuBoulot
	return ""
    }
    OnRevientDuBoulot
    return $FicBanque

}

proc CreeLaBanqueBlastN {{FichierTFAs ""}} {

    global RepertoireDuGenome
    global NotreOS

    set LongueurChevauchement 10000

    set RepertoireBanquesBlast "$RepertoireDuGenome/banques"
    if {$FichierTFAs==""} {
	set FichierTFAs "$RepertoireBanquesBlast/[PreFixe]"
	if {[OuiOuNon "Do we use (old manner) overlapping regions ?" 0]} {
	    append FichierTFAs "overlap"
	}
    } 
    set RepertoireTFAs [file dirname $FichierTFAs]
    if {$RepertoireTFAs!=$RepertoireBanquesBlast} {
	if {[OuiOuNon "$RepertoireTFAs\nis not the same as\n$RepertoireBanquesBlast\n Do I exit ?"]} { exit }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    if { ! [file exists $RepertoireBanquesBlast]} { File mkdir $RepertoireBanquesBlast }

    if { ! [file exists $FichierTFAs]} {
	if {[OuiOuNon "The TFAs file \n$FichierTFAs\ndoesn't exist. Do I create it ?"]} {
	    while 1 {
		if {[OuiOuNon "We do no more need to create overlapping regions.\n Ok to create a blastdatabase with the whole file ?"]} {
		    CreeFichierTFADuGenomePourBanqueBlast $FichierTFAs
		    break
		}
		if {[OuiOuNon "We do no more need to create overlapping regions.\n Ok to create a blastdatabase with overlapping regions ?" 0]} {
		    CreeTroncons "TFA" $FichierTFAs $LongueurChevauchement
		    break
		}
		if {[OuiOuNon "Do I cancel CreeLaBanqueBlastN ?" 0]} { return "" }
	    }
	} else {
	    if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
	    return ""
	}
    }

    set NomDeLaBanque [file tail $FichierTFAs]

    return [CreeUneBanqueBlast $FichierTFAs "$RepertoireBanquesBlast/$NomDeLaBanque"]

}

proc CreeLaBanqueBlastPureSansTroncon {} {

    global RepertoireDuGenome
    global FichierSequenceADN

    set TFA $FichierSequenceADN
    if {[file exists "$TFA.pure"]} { set TFA "$TFA.pure" }
    return [CreeUneBanqueBlast $TFA "$RepertoireDuGenome/banques/[PreFixe]"] 

}

proc CreeLaBanqueBlast_Affymetrix {{FichierIn ""} {Banque ""}} {


    Wup "Permet de creer une banque blast a partir du fichier TFA"
   
    set RepAffy   "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/"
    set RepBanque "$RepAffy/Banque_Blast"

    if {$FichierIn==""} {
	set FichierIn "$RepAffy/Full/HG-U133A_2/LibFiles/HG-U133A_2.tfa"
    }
    if {$Banque==""} {
	set Banque    "$RepBanque/HG-U133A_2"
    }
 
    if {![file exists "$RepBanque"]} {
	file mkdir    "$RepBanque"
    }

    if {! [file exists $FichierIn]} {return ""}
    
    set Cmdformadb "formatdb  -i $FichierIn  -o T  -t AffyU133_2_0  -p F  -n $Banque"
    if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"}
    return ""

}

proc CreeLaBase {} {

    global RepertoireDuGenome
    global CurrentGenome
    global FichierMiniConfig
    global VersionDeGscopeAuBigBang
    global FichierSequenceADN
    global PrefixeDesORFs
    global LongueurMiniDesORFs
    global GenomeOuCollection
    global Org1 Org2

    if { ! [OuiOuNon "We will build, together,  the database for $CurrentGenome. \n
	    \n ... this means   beton/MiniConfig  \n                  beton/adn tdn rac  \n                  fiches/bornesdespabs  \n                  nuctfa/*, prottfa/*, nucembl/*, protembl/*  \n                  fiches/compositionenatgc \n                  blastp/*, apn/* fiches/nombredecopainsdansblast  \n                  msf/*, phylo  \n                  tblastngenomes/* TwoGeneClusterAnalysis etc.  \n
	    \n     If some of these files exist You can delete them before answering. \n                   \n     Go ?"]} {
	if {[OuiOuNon "Do I exit ?"]} { exit } else { return } 
    }

    set GenomeOuCollection "Genome"

    set LesRepertoiresNecessaires {"beton" "fiches" "infos"}
    foreach Rep $LesRepertoiresNecessaires {
	if {[file exists "$RepertoireDuGenome/$Rep"]} { continue }
	File mkdir "$RepertoireDuGenome/$Rep"
    }
    
    
    while { ! [file exists $FichierMiniConfig]} {

	set VersionDeGscopeAuBigBang "VersionDeGscopeAuBigBang [VersionDeGscope]"	
	
	set FichierSequenceADN ""
	while {$FichierSequenceADN==""} {
	    set TFA [lindex [glob -nocomplain $RepertoireDuGenome/beton/*.tfa] 0]
	    if {$TFA == ""} { set TFA "$RepertoireDuGenome/" }
	    if {[OuiOuNon "Can You browse for DNA sequence file ?"]} {
		set TFA [ButineArborescence "All" $TFA]	
		if {$TFA==""} { continue }
		set FichierSequenceADN "FichierSequenceADN $TFA"
		break
	    }
	    if {[OuiOuNon "Do You want to concatenate contigs ?"]} {
		set RepertoireContigs "$RepertoireDuGenome/contigs"
		while { ! [file exists $RepertoireContigs]} {
		    if { ! [OuiOuNon "Before answering, could You create $RepertoireContigs\n containing all the contigs files ?"]} { break }
		}
		if {[file exists $RepertoireContigs]} {
		    set TFA [ConcateneLesContigs]
		    if {$TFA==""} { continue }
		    set FichierSequenceADN "FichierSequenceADN $TFA"
		    break
		}
	    }
	    if {[OuiOuNon "Do You want to read GenBank files ?"]} {
		set OffsetNumero 0
		while {[OuiOuNon "Do I use the ORF numbering in the GenBank files ?" 0]} {
		    if {[OuiOuNon "From the /locus-tag ?"]} {
			set OffsetNumero "NumeroDansLocusTag"
			break
		    }
		    if {[OuiOuNon "From the /gene and-or the /note field ?"]} {
			set OffsetNumero "NumeroDansGeNo"
			break
		    }
		    if {[OuiOuNon "Only from the /gene field ?"]} {
			set OffsetNumero "NumeroDansGene"
			break
		    }
		    if {[OuiOuNon "Only from the /note field ?"]} {
			set OffsetNumero "NumeroDansNote"
			break
		    }
		}
		if {$OffsetNumero!=0} {
		    global SupposePrefixe    
		    if { ! [info exists SupposePrefixe]} {
			set SupposePrefixe ""
			while {$SupposePrefixe==""} {
			    if {[OuiOuNon "Do You know which prefixe is used for ORF numbering ?" 0]} {
				set SupposePrefixe [Entre "ECU\[0-9\]+_"]
				if {$SupposePrefixe!=""} { break }
			    } else {
				break
			    }
			}
		    }
		}
		while {1} {
		    FaireLire "I accept 3 situations ;\n  One GenBank file \n  Several GenBank files are in one directory, without other files\n  or \n  The file are somewhere (with other files) but numbered in increasing order"
		    if {[OuiOuNon "Is there only ONE GenBank file to read ?"]} {
			set FichiersGB [ButineArborescence All $RepertoireDuGenome]
			break
		    } elseif {[OuiOuNon "Are all the GenBank files alone in one directory ?"]} {
			set Rep [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/"]
			if {$Rep==""} { continue }
			set FichiersGB "$Rep/*"
			break
		    } elseif {[OuiOuNon "OK for increasing numbering.\nPlease browse for one of these files"]} {
			set FichiersGB [ButineArborescence All $RepertoireDuGenome]
			if {$FichiersGB==""} { continue }
			if {[regexp {[0-9]+$} $FichiersGB]} {
			    regsub {[0-9]+$} $FichiersGB "" FichiersGB
			}
			break
		    } else {
			continue 
		    }
		}
		if {$FichiersGB!=""} {
		    set TFA [DecortiqueLesGenBank $FichiersGB $OffsetNumero]
		    if {$TFA==""} { continue }
		    set FichierSequenceADN "FichierSequenceADN $TFA"
		    break
		}
	    }
	    if {[OuiOuNon "Do You want to read a FASTA file with all your sequences ?"]} {
		CreeLesPABsAvecUnProteomeDansTFAs
		break
	    }
	    if {[OuiOuNon "Do You want to use an existing ORF list ?\n(typically from an other Gscope project)"]} {
		CreeLeFichierBornesDesPABs
		break
	    }
	    if {[OuiOuNon "Do I stop ?"]} { exit }
	}

	    
	set PrefixeDesORFs           [Entre "PrefixeDesORFs ORF"]
	regsub { *PrefixeDesORFs *} $PrefixeDesORFs "" P
	set PrefixeDesORFs "PrefixeDesORFs $P"

	set LongueurMiniDesORFs      [Entre "LongueurMiniDesORFs 300"]
	regsub { *LongueurMiniDesORFs *} $LongueurMiniDesORFs "" L
	set LongueurMiniDesORFs "LongueurMiniDesORFs $L"

	FaireLire "Please select the organism." 
	set Genre "Genius"
	set Espece "species"
	scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece
	set TexteNotreOS                  "NotreOS $Genre $Espece."
	set TexteNotreOC                  "NotreOC [OCduOS "$Genre $Espece"]"
	set TexteNotreOX                  "NotreOX [NotreOX]"
	set GenomeOuCollection       "GenomeOuCollection Genome"

	set LaConfig {}
	lappend LaConfig "#MiniConfig "
	lappend LaConfig "$FichierSequenceADN"
	lappend LaConfig "$VersionDeGscopeAuBigBang"
	lappend LaConfig "$PrefixeDesORFs"
	lappend LaConfig "$LongueurMiniDesORFs"
	lappend LaConfig "$TexteNotreOS"
	lappend LaConfig "$TexteNotreOC"
	lappend LaConfig "$TexteNotreOX"
	lappend LaConfig "$GenomeOuCollection"

	if {[OuiOuNon "[join $LaConfig "\n"]\n\n   OK ?" ]} {	    
	    SauveLesLignes $LaConfig dans $FichierMiniConfig
	} else {
	    if {[OuiOuNon "Stop ?"]} { exit }
	}
    }

    ChargeMiniConfig
    LesOrganismesTresProches

    if { ! [file exists "$RepertoireDuGenome/beton/adn"]} {
	set AncienNomDuFichierSequenceADN $FichierSequenceADN
	if {[OuiOuNon "Should I create $RepertoireDuGenome/beton/adn tdn rac ?"]} {
	    CreeADNetTDNetRACaPartirDuFichierTFA $FichierSequenceADN
	    CreeCompletTFAavecADN
	}
	if {[file exists "$AncienNomDuFichierSequenceADN.pure"] &&  [OuiOuNon "Should I create $RepertoireDuGenome/beton/adn.pure tdn.pure rac.pure ?"]} {
	    CreeADNetTDNetRACaPartirDuFichierTFA "$AncienNomDuFichierSequenceADN.pure"
	}
    }
 

    if { ! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
	CreeLeFichierBornesDesPABs
    }

    if { [OuiOuNon "Do I run some basic sequence analysis ?"]} {
	if { [OuiOuNon "Do I create the files Nuc and Prot ? "]} {
	    CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBLAvecBornesDesPABsEtADN
	}
	set SeqLaTotale [OuiOuNon " Do I run all standard analysis ?\n ATGC composition, GC drawing, ShineDalgarno\n CodonW, Glimmer, tRNAscan\n (I hope You didn't forget to setcodonW setglimmer settrnascan !)"]
	
	if { $SeqLaTotale || [OuiOuNon "Do I create the file compositionenatgc ? "]} {
	    CreeLeFichierCompositionEnATGC
	}
	
	if { $SeqLaTotale || [OuiOuNon "Do I create the file spectregc ? "]} {
	    CreeLesFichiersSpectreDesGC
	}
	
	if { $SeqLaTotale || [OuiOuNon "Do I see for ShineDalgarno ? "]} {
	    CreeLesFichiersDesShineDalgarnoDesPABs
	}
	
	if { $SeqLaTotale || [OuiOuNon "Do I run CodonW for Codon Adaptation Index ? \n(Answer No if you didn't 'setcodonw'.)"]} {
	    CodonW
	}
	
	if { $SeqLaTotale || [CreateurDesPABs] != "Glimmer"  && [OuiOuNon "Do I run Glimmer to compare with existing ORFs ?"]} {
	    Glimmer "GLIMMER0000"
	    CreeCorrespondanceAvecGlimmer
	}
	
	if { $SeqLaTotale || [OuiOuNon "Do I run tRNAscan-SE ? "]} {
	    TRNAscanSE
	    CreeLesFichiersNucTFAetNucEMBLAvecBornesDesTRNAsEtADN
	}
    }

    if { [OuiOuNon "Do I run all BlastP ? "]} {
	BlastPPourTous
    }
    if { [OuiOuNon "Do I run all BlastN against human ? "]} {
	BlastNPourTous
    }

    set BanqueTBlastN ""
    if {[OuiOuNon "Do I run a tblastn for all ? "]} {
	set BanqueTBlastN [ChoixParmi [list "human" "genomes" "myself"]]
	if {$BanqueTBlastN!=""} {
	    set RepTBlastN "$RepertoireDuGenome/tblastn$BanqueTBlastN"
	    if { ! [file exists $RepTBlastN]} { File mkdir $RepTBlastN }
	    TBlastNPourTous $BanqueTBlastN
	}
    }
    set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]

    if { ! [OuiOuNon "Do You want to complete the database ?"]} { return }

    CompleteLaDataBase $BanqueTBlastN

    if {[OuiOuNon "Do I exit Gscope ?"]} { exit }

}

proc CreeLaBaseOuLaCollection {} {

    global FichierMiniConfig
    global GenomeOuCollection

    if {[file exists "$FichierMiniConfig"]} { ChargeMiniConfig }

    if { [OnTraiteUnGenome] } {
	CreeLaBase
    } else {
	CreeLaCollection
    }

}

proc CreeLaBaseSqlonage {} {

    set Handle [mysqlconnect -host localhost -user root]
    mysqlexec $Handle {create database if not exists Sqlonage;}
    mysqluse  $Handle "Sqlonage"
    return $Handle

}

proc CreeLaCollection {{CollectionType ""} {SequenceSourceFile ""} {MiniConfig ""} {KeepEntete ""} {CreateNarcisse ""} {ForceAccessFirst ""}} {

JeMeSignale
    global RepertoireDuGenome
    global CurrentGenome
    global FichierMiniConfig
    global VersionDeGscopeAuBigBang
    global FichierSequenceADN
    global PrefixeDesORFs
    global LongueurMiniDesORFs
    global GenomeOuCollection
    global NarcisseDuAlias

    set LesRepertoiresNecessaires [list "beton" "fiches" "infos"]
    foreach Rep $LesRepertoiresNecessaires {
	file mkdir "$RepertoireDuGenome/$Rep"
    }

    set FichierMiniConfig [CreeFichierMiniConfig $MiniConfig]
    
    ChargeMiniConfig
    LesOrganismesTresProches
    PasTouche Check


    #rR Avec les quelques lignes qui suivent on peut creer bornesdespabs automatiquement
    if {$CollectionType=="AAD" || $CollectionType=="BAAD"} {
	set FileOfFilename [CreeProteomeAvecUneListeAccessAliasDefinition $SequenceSourceFile $CollectionType]
	set Coll [CreeLaCollection "FOF" $FileOfFilename]
	if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
    }
    if {$CollectionType=="FOF"} {
	CreeBornesDesPABsPourUneCollection $SequenceSourceFile
	set Coll [CreeLaCollection]
	if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
    }
    if {$CollectionType=="TFA"} {
	CreeBornesDesPABsAvecTFAs $SequenceSourceFile $KeepEntete $CreateNarcisse $ForceAccessFirst
	set Coll [CreeLaCollection]
	if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
    }
    #rR Voila, la creation automatique de bornesdespabs est faite


    if {0 && [FileAbsent "[RepertoireDuGenome]/fiches/bornesdespabs]"] && [OnTraiteDesCDSProtFoF]} {
	Espionne salut
	CreateGscopeDatabaseForCDSProtFoF
	exit	
    }

    if {[OnTraiteDesClones] &&  ! [OnTraiteDesCDS]} {
	GestionDesClones
	exit
    }
    if {[OnTraiteDesCDNAs] && [OuiOuNon "Do I run LaTotalePourLesCDNAs ?"]} { 
	LaTotalePourLesCDNAs
	exit
    }
    if {[file exists "$RepertoireDuGenome/fiches/bornesdespabs"] &&  ! [OnTraiteSM2PH] &&  [OuiOuNon "Do you want to add a new sequence using the SeqIn procedure ?" 0]} {
	return [UneNouvelleSequencePourGscope]
    }

    set QuestionDidYouAddNew "Did You add new elements to the collection ?"
    while { ! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]  || [OuiOuNon $QuestionDidYouAddNew 0]  || [OuiOuNon "Do You want that I process a file with Access or FOF ?" 0] } {
	set QuestionDidYouAddNew "Once again,\n Did You add new elements to the collection ? \n Normally you answer NO"
	set Queue [file tail [RepertoireDuGenome]]
	set Possible "[RepertoireDuGenome]/$Queue.fof"
	if {[file exists $Possible]} {
	    set FichierFOFDefaut $Possible
	} else {
	    set FichierFOFDefaut [RepertoireDuGenome]
	}
	set FichierFOF $FichierFOFDefaut
	set AskForFOF 1
	FaireLire "Please help me to find your sequences"
	if {[OuiOuNon "Do You have a file with lines like (it can be mixed) \nAccess  \nAccess Alias  \nAccess Alias Definition  \n or 
		\nBanqueId Access  \nBanqueId Access Alias  \nBanqueId Access Alias Definition  \n  \n for example  \nSW:ANDR_RAT P15207 AR Androgen receptor (Dihydrotestosterone receptor)
		\n to collect the ORFs?"]} {
	    set FichierAccessAlias [ButineArborescence "All" $RepertoireDuGenome]
	    set FichierFOF [CreeProteomeAvecUneListeAccessAliasDefinition $FichierAccessAlias]
	    if {$FichierFOF!=""} { set AskForFOF 0 }
	}
	
	if {$FichierFOF==""} { set FichierFOF $FichierFOFDefaut }
	
	if {[OuiOuNon "Do you want to create a proteome from OrthoInspector" 0]} {
	    while {[OiDomain "Ask"]=="" && [OuiOuNon "Do I exit ?"]} { exit }
	    file mkdir "[RepertoireDuGenome]/banques"
	    OiSplit
	    FaireLire "Please verify that banques/blastpdatabase links to \n/blast/OrthoInspector/Oi[OiDomain]\nand this database is online.\nThen run gscope Blastong ;)"
	    exit
	}

	if { ! $AskForFOF ||  [OuiOuNon "Do you have a file of filenames with Filename\nFileName\n or \nAlias  FileName\nAlias  FileName\n...\n ?"]} {
	    CreeBornesDesPABsPourUneCollection [ButineArborescence "FOF" $FichierFOF]
	} elseif {[OuiOuNon "Do you have a file with all sequences in FASTA format in one file ?"]} {
	    CreeBornesDesPABsAvecTFAs
	} elseif {[OuiOuNon "Do you want to use an existing ORF list ? \n  From an other Gscope project ... or \n  From Glimmer \n  From a GenBank File \n  etc."]} {
	    CreeLeFichierBornesDesPABs
	}
	set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
	if {[info exists NarcisseDuAlias] &&  ! [file exists $FichierNarcisse]} {
	    if {[OuiOuNon "Can I use NarcisseDuAlias to create Narcisse ?" 0]} {
		set LesNarcisses {}
		foreach Nom [ListeDesPABs] {
		    set Alias [Alias $Nom]
		    if {[info exists NarcisseDuAlias($Alias)]} {
			set NdA [set NarcisseDuAlias($Alias)]
			set Narcisse($Nom) $NdA
			lappend LesNarcisses "$Nom $NdA"			
		    }
		}
		if {$LesNarcisses!={}} {
		    SauveLesLignes $LesNarcisses dans $FichierNarcisse
		}
	    }
	}
    }

    if {[OnTraiteUneCollection]} {
	if {[OuiOuNon "Do I collect the mRNA sequences corresponding to proteins ?" 0]} {
	    CollectionDeNucAPartirDeProtTFAPourTous
	    exit
	}
    }

    if { ! [OnTraiteSM2PH] && [OuiOuNon "Do I complete the basic data for of each Gene \n (sequence, blastp, dbclustal)?" ]} {
	set RepMSF      "$RepertoireDuGenome/msf"
	set RepBlastP   "$RepertoireDuGenome/blastp"
	set RepTBlastN  "$RepertoireDuGenome/tblastngenomes"
	set RepVer      "$RepertoireDuGenome/ver"
	set RepProtTFA  "$RepertoireDuGenome/prottfa"
	set RepProtEMBL "$RepertoireDuGenome/protembl"
	set RepNucTFA   "$RepertoireDuGenome/nuctfa"
	set RepNucEMBL  "$RepertoireDuGenome/nucembl"
	
	foreach Rep [list $RepMSF $RepBlastP $RepVer $RepProtTFA $RepProtEMBL $RepNucTFA $RepNucEMBL] {
	    if {[file exists $Rep]} { continue }
	    File mkdir $Rep
	}

	set SeqOnly [OuiOuNon "Do I create ONLY sequences ?"]
	if {[OnTraiteDesProteines]} {
	    set NucOnly 0
	} else {
	    set NucOnly [OuiOuNonMemo "Do I create only NUCLEIC sequences (no translation to protein) ?"]
	}
	foreach Nom [ListeDesPABs] {
	    Espionne "Traitement $Nom"
	    if {[PasTouche $Nom]} { continue }
	    set FiMSF "$RepMSF/$Nom"
	    set FiBla "$RepBlastP/$Nom"
	    set FiTBN "$RepTBlastN/$Nom"
	    set FiVer "$RepVer/$Nom"
	    set FiProtEMBL "$RepProtEMBL/$Nom"
	    set FiProtTFA  "$RepProtTFA/$Nom"
	    set FiNucEMBL  "$RepNucEMBL/$Nom"
	    set FiNucTFA   "$RepNucTFA/$Nom"
	    set Encore 1
	    set GN ""
	    while {$Encore} {
		if { $SeqOnly } {
		    if {[file exists $FiProtTFA]} { break }
		    if {$NucOnly && [file exists $FiNucTFA]} { break }
		} else {
		    set Encore 0
		    if {[file exists $FiMSF]} { continue }
		    set Encore 1
		    if {[file exists $FiBla]}     { MSFPourCollection $Nom    ; continue }
		    if {[file exists $FiProtTFA]} { BlastPPourCollection $Nom ; continue }
		}
		if {[file exists $FiProtEMBL] && ! [file exists $FiProtTFA]} {
		    set ProtTFA [SequenceFormatTFA [ContenuDuFichier $FiProtEMBL] "" "embl"]
		    Sauve $ProtTFA dans $FiProtTFA
		    continue
		}
		if {[file exists $FiVer]} {
		    set SeqVer [ContenuDuFichier $FiVer]
		    Espionne "SeqVer\n$SeqVer"
		    if { [OnTraiteDesCDS] || $NucOnly} {

			set FormatVer [FormatDeLaSequence $SeqVer]

			set NucEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
			if {$FormatVer=="tfa"} {
			    set NucTFA  $SeqVer
			    regsub "^>" $NucTFA ">$Nom " NucTFA
			} else {
			    set NucEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
			    set NucTFA  [SequenceFormatTFA $NucEMBL "" "embl"]
			}
			Sauve $NucEMBL dans $FiNucEMBL
			Sauve $NucTFA  dans $FiNucTFA

			set QueSeqNuc [QueLaSequenceDuTexteTFA $NucTFA]
			set DernierCodon [string range $QueSeqNuc end-2 end]
			if {[CodonStopPossible $DernierCodon]} { set QueSeqNuc [string range $QueSeqNuc 0 end-3] }
			set SeqProt [SeqNucToSeqPro $QueSeqNuc]
			set LongSeq [string length $SeqProt]

			set LesLignesEMBL {}
			lappend LesLignesEMBL "ID   $Nom  created by Gscope from a CDS file "
			set LigneAC [lindex [split $NucEMBL "\n"] 1]
			if {[regexp "^AC   " $LigneAC]} {
			    lappend LesLignesEMBL $LigneAC
			} else {
			    lappend LesLignesEMBL "AC   $Nom;"
			}
			set  ChampsInteressants [ChampsInteressantsDansTexteEMBL $NucEMBL]
			if {$ChampsInteressants!=""} {
			    foreach Champ [split $ChampsInteressants "\n"] {
				lappend LesLignesEMBL $Champ
				if {$GN=="" && [regexp "^GN  " $Champ]} {
				    set GN [VraiGNDeLaLigneGN $Champ]
				    InformeSansDemander $Nom "ValiGN: $GN"
				}
				if {[regexp "^DE  " $Champ]} {
				    set DE [VraiDEDeLaLigneDE $Champ]
				    InformeSansDemander $Nom "ValiDE: $DE"
				}
			    }
			}
			if {$NucOnly} { continue }
			lappend LesLignesEMBL "SQ   SEQUENCE $LongSeq AA;"
			lappend LesLignesEMBL [SequenceFormatBrut $SeqProt]
			set ProtEMBL [join $LesLignesEMBL "\n"]
			set ProtTFA [SequenceFormatTFA $ProtEMBL "$Nom" "embl"]			
			Sauve $ProtEMBL dans $FiProtEMBL
			Sauve $ProtTFA  dans $FiProtTFA
		    } else {
			set SeqProt [SequenceFormatEMBL $SeqVer]
			Espionne "SeqProt\n$SeqProt"
			regsub {^ID   [^\n]+} $SeqProt "ID   $Nom  created by Gscope" SeqProt   
			Sauve $SeqProt dans $FiProtEMBL
			set Entete "$Nom"
			set  ChampsInteressants [ChampsInteressantsDansTexteEMBL $SeqProt]
			if {$ChampsInteressants!=""} {
			    lappend LesLignesEMBL $ChampsInteressants
			    foreach Champ [split $ChampsInteressants "\n"] {
				lappend LesLignesEMBL $Champ
				if {[regexp "^GN  " $Champ]} {
				    set GN [VraiGNDeLaLigneGN $Champ]
				    InformeSansDemander $Nom "ValiGN: $GN"
				    append Entete " $GN"
				}
				if {[regexp "^DE  " $Champ]} {
				    set DE [VraiDEDeLaLigneDE $Champ]
				    InformeSansDemander $Nom "ValiDE: $DE"
				    append Entete " $DE"
				}
			    }
			}
			set ProtTFA [SequenceFormatTFA $SeqProt "$Entete" "embl"]
			Sauve $ProtTFA dans $FiProtTFA
		    }
		    continue
		} 
		if {[OuiOuNon "The Query sequence for $Nom doesn't yet exists. \n Do I skipp $Nom [Alias $Nom] ?"]} {
		    break
		}
	    }
	    FinPasTouche $Nom
	}
    }
    set BanqueTBlastN ""
    if {[OuiOuNon "Do I run a tblastn for all ? " 0]} {
	set BanqueTBlastN [ChoixParmi [list "human" "genomes" "myself"]]
	if {$BanqueTBlastN!=""} {
	    set RepTBlastN "$RepertoireDuGenome/tblastn$BanqueTBlastN"
	    if { ! [file exists $RepTBlastN]} { File mkdir $RepTBlastN }
	    TBlastNPourTous $BanqueTBlastN
	}
    }

    if { ! [OuiOuNon "Do you want to complete the database ?" 0]} { return }

    set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]
    CompleteLaDataBase $BanqueTBlastN

}

proc CreeLaListeDesPABNuctfa {} {



    set FichierOut "[RepertoireDuGenome]/ListeACT_SeqOriginelle"

    foreach PAB [ListeDesPABs] {
	set SeqOri ""
	set SeqOri "[OwnerOfCDNA $PAB]"
	AppendAuFichier $FichierOut "$PAB\t$SeqOri"
    }

}

proc CreeLaListeDesPFAMUniques {} {

    # more Domaines | gr PFAM | grep PF | gr -v PB | grep "1\.0" | wc
    set Fichier "[RepertoireDuGenome]/fiches/Domaines"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	if {![regexp "PFAM" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Acc [lindex $Ligne 2]
	#FaireLire [lindex $Ligne 3]
	set Id [lindex $Ligne 6]
	if {[regexp "^PF" $Acc] && $Id>="0.8"} {
	    lappend Liste $Acc
	    #lappend Liste $Ligne
	} else {
	    #Espionne $Ligne
	}
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/pfamA80"

}

proc CreeLaListeDesPFAMUniques_procure {} {

    # more Domaines | gr PFAM | grep PF | gr -v PB | grep "1\.0" | wc
    set Fichier "[RepertoireDuGenome]/fiches/Domaines"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	if {![regexp "PFAM" $Ligne]} {continue}
	set Ligne [split $Ligne "\t"]
	set Acc [lindex $Ligne 2]
	if {[info exists Vu($Acc)]} {continue}
	#FaireLire [lindex $Ligne 3]
	set Id [lindex $Ligne 6]
	if {[regexp "^PF" $Acc] && $Id=="1.0"} {
	    set Vu($Acc) 1
	    #lappend Liste $Acc
	    set Ligne [join $Ligne "\t"]
	    lappend Liste $Ligne
	} else {
	    #Espionne $Ligne
	}
    }
    Espionne [llength $Liste]
    set Liste [lsort -unique $Liste]
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/pfamA100"

}

proc CreeLaListeLesCopains {FichierOuNom {Source ""} {EvalCommand ""}} {

    global RepertoireDuGenome
    global NotreOS
    global DejaVuCeComplet
    global SeuilExpectPourJulie
    global LesOrganismesModelesAAligner
    global WithoutVarsplic
    global WithoutFragment
    global FirstPDBOnly
    if { ! [info exists WithoutVarsplic]} { set WithoutVarsplic 0 }
    if { ! [info exists WithoutFragment]} { set WithoutFragment 1 }
    if { ! [info exists FirstPDBOnly]   } { set FirstPDBOnly    1 }

    if {[OnTraiteMS2PH]} {
	set  WithoutFragment 0
	global TryGCG ; set TryGCG 0
    }

    if {$Source==""} { set Source "blast" }

    Wup "Creates the list of best orthologs in blastp or ballast" 

    set Nom [file tail $FichierOuNom]

    set LesOrganismesFamiliers  [FamiliarOrganism "LaListeMerci"]
    set LesOrganismesImportants [LesOrganismesImportantsPourDBClustal]
    scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect 

    if { ! [info exists DejaVuCeComplet]} {
	foreach Ligne $LesOrganismesImportants {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    set Genre ""
	    set Espece ""
	    scan $Ligne "%s %s" Genre Espece
	    set Complet "$Genre $Espece"
	    set Orga [Glossaire $Complet Complet]
	    set DejaVuCeComplet([string toupper $Orga]) 0
	}
    }
    foreach Genome [array names DejaVuCeComplet] {
	set DejaVuCeComplet($Genome) 0
    }
    set nPDB 0
    set nCops 0
    set ncomplets 0
    set LesCopains {}
    set LesCandidatsPotentiels [LesDescriptifsDuBlast $FichierOuNom $Source]
    foreach Candidat $LesCandidatsPotentiels {
	if { $nCops >= $MaxVoulus} {
	    RapportAliInOut "$BanqueId $Access break : ncops $nCops >= $MaxVoulus" $Nom
	    break
	}
	set Genre "Unknown unknown"
	set Espece ""
	set DE ""
	scan $Candidat "%s %s %f %s %s %s" BanqueId Access PN Genre Espece DE
	regsub -all "_" $DE " " DE

	if {$EvalCommand!=""} {
	    set R [EvalCom $EvalCommand $Candidat]
	    if {[regexp -nocase "^Reject" $R]} {
		RapportAliInOut "$BanqueId $Access rejected by evalcom : $R" $Nom
		continue
	    }
	}

	if { $Source != "ballast" && $PN > $SeuilExpect } {
	    RapportAliInOut "$BanqueId $Access break : expect $PN > $SeuilExpect" $Nom
	    break
	}

	if {$WithoutVarsplic && [regexp -nocase "^VARSPLIC" $BanqueId]} {
	    RapportAliInOut "$BanqueId $Access rejected, VARSPLIC : $DE" $Nom
	    continue
	}

	if {$WithoutFragment && [EstUnFragment $BanqueId $Access $DE]} {
	    RapportAliInOut "$BanqueId $Access rejected, fragment : $DE" $Nom
	    continue
	}

	if {[EstUnAccessPDB $BanqueId]} {
	    set Racine [RacineDuPDB $BanqueId]
	    if {$FirstPDBOnly} {
		if {[info exists DejaVuCePDB($Racine)]} {
		    RapportAliInOut "$BanqueId $Access rejected, other PDB already taken [set DejaVuCePDB($Racine)]." $Nom
		    continue
		}
		set DejaVuCePDB($Racine) $BanqueId
	    }
	    if {[incr nPDB]>$MaxPDB} {
		RapportAliInOut "$BanqueId $Access rejected, more than $MaxPDB PDB." $Nom
		continue
	    }
	    set Orga [OrganismeDuPDB $BanqueId]
	    lappend LesCopains "$BanqueId $Access $PN $Orga"
	    RapportAliInOut "$BanqueId $Access $Orga accepted after $nCops th, PDB $nPDB" $Nom
	    continue
	}

	set OS "$Genre $Espece"
	set Orga [OrganismeCanonique $OS "NonStricte"]
	if {$Orga==""} {
	    if {[OuiOuNon "I skip $OS"]} {
		RapportAliInOut "$BanqueId $Access rejected : $Organisme unknown >$OS<" $Nom
		continue
	    }
	    set Orga $OS
	}
	Wup "Si on ne veut qu'une seule fois chaque complet mettre 1"
	set UneSeuleFoisLesComplets [OuiOuNonMemo "Do I use only one time each organism" 0]
	if {$UneSeuleFoisLesComplets && [info exists DejaVuCeComplet([string toupper $Orga])]} {
	    if { $nCops >= $MinObliges && [set DejaVuCeComplet([string toupper $Orga])]} {
		RapportAliInOut "$BanqueId $Access rejected : $Orga already seen." $Nom
		continue 
	    }
	} else {
	    if { $nCops >= $MinObliges &&  ! [info exists DejaVuCeComplet([string toupper $Orga])] } {
		RapportAliInOut "$BanqueId $Access rejected : $Orga $nCops >= $MinObliges" $Nom
		continue 
	    }
	}
	if {[info exists DejaVuCeComplet([string toupper $Orga])]} {
	    set DejaVuCeComplet([string toupper $Orga]) 1
	}
	incr nCops
	RapportAliInOut "$BanqueId $Access $Orga accepted as $nCops th." $Nom
	lappend LesCopains "$BanqueId $Access $PN $Orga"
    }
    return $LesCopains

}

proc CreeLaNoteAnnotation {Nom} {

    set RepNotes "[RepertoireDuGenome]/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }
    set Note     {}
    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO"

    lappend Note "GscopeId : $Nom"
    set Status [ExtraitInfo $Nom "Status"]
    lappend Note "Status : $Status"
    
    lappend Note ""
    set Gn [ExtraitInfo $Nom "ValiGN"]
    lappend Note "Gene name ARNm: $Gn"
    set GnProt [ExtraitInfo $Nom "ValiGNProt"]
    lappend Note "Gene name Prot: $GnProt"
    set Alias [RecupereSynonyms $Nom]
    lappend Note "Alias Gene name : $Alias"
    set Des [ExtraitInfo $Nom "ValiDE"]
    lappend Note "Description ARNm : $Des"
    set DesProt [ExtraitInfo $Nom "ValiDEProt"]
    lappend Note "Description Prot : $DesProt"
    set DesUcsc [ExtraitInfo $Nom "ValiDEUcsc"]
    lappend Note "Description Ucsc : $DesUcsc"
    
    lappend Note ""
    set AccARN [AccessEvi $Nom]
    lappend Note "Accession Number ARNm : $AccARN"
    set IdAccProt [ExtraitInfo $Nom "IdAccProt"]
    set LesProt [split $IdAccProt " "]
    set AccProt [lindex $LesProt 1]
    lappend Note "Accession Number Prot : $AccProt"
    
    lappend Note ""
    set Loc [ExtraitInfo $Nom "LocUcscFrom200602"]
    lappend Note "Localisation : $Loc"
    
    lappend Note ""
    set ProbeSetId [ExtraitInfo $Nom "ProbeSetId:"]
    lappend Note "ProbeSetId : $ProbeSetId"
   
    set LesComponent {}; set LesFunction {}; set LesProcess {}
    foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] {
	set Type [InterrogeGeneOntology $FichierGO GO $GO Type]
	set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]
	if {[regexp {component} $Type]} {lappend LesComponent $DefGO}
	if {[regexp {function} $Type]} {lappend LesFunction $DefGO}
	if {[regexp {process} $Type]} {lappend LesProcess $DefGO}
    }
    set LesComponent [ListeSansDoublon $LesComponent]
    set LesFunction  [ListeSansDoublon $LesFunction]
    set LesProcess   [ListeSansDoublon $LesProcess]
    set comp [join $LesComponent ","]
    set func [join $LesFunction ","]
    set proce [join $LesProcess ","]
    lappend Note "GoComponent : $comp"
    lappend Note "GoFunction : $func"
    lappend Note "GoProcess : $proce"

    set HomologeneId [ExtraitInfo $Nom "HomologeneId:"]
    lappend Note "HomologeneId : $HomologeneId"
 

    set MaxD 0
    foreach Ligne $Note {
	if {[regexp -indices { \: } $Ligne Indices]} {
	    scan $Indices "%d" D
	    set MaxD [Maxi $MaxD $D]
	}
    }
    incr MaxD 2
    set LaBelleNote {}
    foreach Ligne $Note {
	if {[regexp -indices { \: } $Ligne Indices]} {
	    scan $Indices "%d" D
	    set nPoints [string repeat "." [expr $MaxD - $D]]
	    regsub { \: } $Ligne " $nPoints : " Ligne
	}
	    lappend LaBelleNote $Ligne
    }
    SauveLesLignes $LaBelleNote dans "$RepNotes/$Nom"

}

proc CreeLaNouvelleListeDesPABsApresJumeauxSeq {} {

    # Les jumeaux seq ont tous la meme longueur donc pas besoin de chercher a mettre le + long devant maintenant
    foreach Nom [ListeDesPABs] {
	set JR [JumeauRepresentatif $Nom]
	if {$JR==""} {lappend ListeNew $Nom} else {lappend ListeNew $JR}
    }
    #Espionne [llength [lsort -unique $ListeNew]]
    return [lsort -unique $ListeNew]

}

proc CreeLaSequenceDeLaZone {K} {

    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique

    if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
	FaireLire "Il faut selectionner une zone par "
	return ""
    }

    if {[regexp "rond" $K]} {
	set D [set xDebutRectangleDeSelectionNucleique($K)]
	set F [set   xFinRectangleDeSelectionNucleique($K)]
	set Debut [Mini $D $F]
	set   Fin [Maxi $D $F]
    } else {
	set Debut [PositionCanvaOriginaleX $K [Mini  [set xDebutRectangleDeSelectionNucleique($K)]  [set   xFinRectangleDeSelectionNucleique($K)]  ]]
	set   Fin [PositionCanvaOriginaleX $K [Maxi  [set xDebutRectangleDeSelectionNucleique($K)]  [set   xFinRectangleDeSelectionNucleique($K)]  ]]
    }

    if {[OuiOuNon "I create the nucleic sequence ... Forward ?"]} {
	set Orient "F"
    } elseif {[OuiOuNon "I create the nucleic sequence ... Reverse ?"]} {
	set Orient "R"
    } else { FaireLire "I do nothing."; return "" }
    set Entete "${Orient}_${Debut}_${Fin}"
    set SequenceNuc ">$Entete\n[SequenceFormatBrut [BoutADN $Debut $Fin $Orient]]"
    return [AfficheVariable $SequenceNuc "AvecFormateAvecBlaste" $Entete]

}

proc CreeLaTable {CommeCa {Source ""} {Orga ""} {Extension ""}} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOrga
    global TasTamis
    
    Wup "On peut avoir comme source distancesphylo ou psclustalw"

    if {$Source==""} { set Source "distancesphylo" }
    if {$Orga==""} { set Orga $NotreOrga }
    if {$Extension==""} { set Extension ".$Orga" }

    Wup "Devrait etre le meme que dans LesSpecifiquesDansDistancePhylo"
    set SeuilDistance 82
    set SeuilPIC 20

    Wup "On en repeche car il existent dans TBlastN mais pas dans le proteome de phor"
    set ARepecher "ABY0341 ABY7428 ABY3419 ABY7435 ABY3433"

    regsub {\$}        $CommeCa "" Titre
    regsub {\^}        $Titre   "" Titre
    regsub " "         $Titre   "" Titre
    regsub "TasTamis_" $Titre   "" Titre

    foreach Ligne [LesOrganismesImportantsPourDBClustal] {
	scan $Ligne "%s %s" Genre Espece
	set Complet "$Genre $Espece"
	set Organisme [Glossaire $Complet Court]
	set OrgaInteressant($Organisme) 1
    }

    catch {unset OrgaInteressant([Glossaire $Orga Court])}
    catch {unset OrgaInteressant(nmen)}
    
    set FichierPIClustalw "$RepertoireDuGenome/fiches/piclustalw$Extension"
    while { ! [file exists $FichierPIClustalw]} {
	if {[OuiOuNon "$FichierPIClustalw doesn't exist\Do I create it now ? (it will take a while)."]} {
	    CreeLesFichiersPIClustalwEtPSClustalw $Orga $Extension
	}
    }
    foreach Ligne [LesLignesDuFichier $FichierPIClustalw] {
	set Liste [split $Ligne " "]
	set Nom [lindex $Liste 0]
	set ListeOrgaPIC [lrange $Liste 1 end]
	if {[regexp $Nom $ARepecher]} {
	    set ListeOrgaPIC [linsert $ListeOrgaPIC 0 100]
	    set ListeOrgaPIC [linsert $ListeOrgaPIC 0 phor]
	}
	foreach {Orga PI} $ListeOrgaPIC {
	    if {[info exists PIC($Nom,$Orga)]} { continue }
	    set PIC($Nom,$Orga) $PI
	}
    }

    if {$Source=="distancesphylo"} {
	set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo$Extension"
	if { ! [file exists $FichierDistancesPhylo]} {
	    FaireLire "$FichierDistancesPhylo\nNous y voila"
	    set FichierDistancesPhylo [CreeDistancesPhyloAvecLesMSFs [Glossaire $NotreOS Court] [PreFixe]]
	}
    }

    if {$Source=="psclustalw"} {
	set FichierDistancesPhylo "$RepertoireDuGenome/fiches/psclustalw$Extension"
	set MaxiPS -9999.
	foreach Ligne [LesLignesDuFichier $FichierDistancesPhylo] {
	    scan $Ligne "%s %s %f" Nom Orga PS
	    set MaxiPS [Maxi $PS $MaxiPS]
	}
	set CoeffPSversDistance  [expr 100./$MaxiPS]
	set OffsetPSversDistance 0
    }

    set NombreDeLignesRejetees 0
    foreach Ligne [LesLignesDuFichier $FichierDistancesPhylo] {
	set Liste [split $Ligne " "]
	set Nom [lindex $Liste 0]
	set ListeOrgaDistance [lrange $Liste 1 end]
#	if {[regexp $Nom $ARepecher]} {
#	    set ListeOrgaDistance [linsert $ListeOrgaDistance 0 $MaxiPS]
#	    set ListeOrgaDistance [linsert $ListeOrgaDistance 0 phor]
#	}
	set NouvelleListeOrgaDistance {}
	set LesHonnetes {}
	catch { unset DejaVuCetOrga }
	foreach {Orga Distance Access} $ListeOrgaDistance {
	    if {$Source=="psclustalw"} {
		set Distance [expr $CoeffPSversDistance*$Distance + $OffsetPSversDistance]
	    }
	    if {[info exists DejaVuCetOrga($Nom,$Orga)]} { continue }
	    if {[info exists PIC($Nom,$Orga)]} {
		if {[set PIC($Nom,$Orga)] < $SeuilPIC } { continue }
	    } else {
		if {$Distance > $SeuilDistance} { continue }
	    }
	    set DejaVuCetOrga($Nom,$Orga) 1
	    lappend LesHonnetes $Orga
	    lappend LesHonnetes $Distance
	    if { ! [info exists OrgaInteressant($Orga)] } { continue }
	    lappend NouvelleListeOrgaDistance $Orga
	    lappend NouvelleListeOrgaDistance $Distance
	    lappend NouvelleListeOrgaDistance $Access
	}
	set YaUneBactos 0
	foreach {Orga Distance Access} $NouvelleListeOrgaDistance {
	    if { ! [PyroLike $Orga]} {
		set YaUneBactos 1
		break
	    } 
	}
	
	if { $NouvelleListeOrgaDistance == {} || $CommeCa == "no_ark" && ! $YaUneBactos } {
	    lappend LesRejetes $Ligne
	    incr NombreDeLignesRejetees
	    continue
	}
	set AncienneLigne($Nom) "$Nom [join $LesHonnetes " "]"
	lappend NouvellesLignes "$Nom [join $NouvelleListeOrgaDistance " "]"
    }

    SauveLesLignes $NouvellesLignes dans "$FichierDistancesPhylo.$Titre"
    
    set NombreDePhylosRetenus 0
    set MaxPlace 0
    set ListeDesOrgas {}
    set LesRetenus {}
    foreach Ligne $NouvellesLignes {
	set Liste [split $Ligne " "]
	set Nom [lindex $Liste 0]
	set ToutesLesEuryArks  [expr  [regexp "phor" $Ligne]  && [regexp "pfur" $Ligne]  && ( ! [info exists AutreOrganismeDeReference] || [regexp "paby" $Ligne])  && [regexp "mjan" $Ligne]  && [regexp "mthe" $Ligne]  && [regexp "aful" $Ligne]  ]
	if { $CommeCa == "toutes_euryarks" && ! $ToutesLesEuryArks } { continue } 
	if { $CommeCa == "manque_euryarks" &&   $ToutesLesEuryArks } { continue } 
	set NoEuryArk  [expr  ! [regexp "mjan" $Ligne]  && ! [regexp "mthe" $Ligne]  && ! [regexp "aful" $Ligne]  ]
	if { $CommeCa == "no_euryark" && ! $NoEuryArk } { continue } 
	set NoArk  [expr  ! [regexp "mjan" $Ligne]  && ! [regexp "mthe" $Ligne]  && ! [regexp "aful" $Ligne]  && ! [regexp "aper" $Ligne]  && ! [regexp "ssol" [set AncienneLigne($Nom)]]  && ! [regexp "hsal" [set AncienneLigne($Nom)]]  ]
	if { $CommeCa == "no_ark" && ! $NoArk } { continue } 

	if { [regexp "TasTamis" $CommeCa] && ! [info exists TasTamis($Nom)] } { continue }

	incr NombreDePhylosRetenus
	lappend LesRetenus $Ligne
	set SC [SuperClasse [ClasseFonctionnelle $Nom]]
	if {[info exists Cumul($SC)]} {
	    incr Cumul($SC)
	} else {
	    set Cumul($SC) 1
	}

	set ListeOrgaDistance [lrange $Liste 1 end]

	set Place 0
	catch {unset DejaVuDansCetteListe}
	set NomOrgasDuPAB $Nom

	foreach {Orga Distance Access} $ListeOrgaDistance {
	    if { ! [info exists DejaVu($Orga)] } {
		set DejaVu($Orga) 1
		if {[info exists CumulDesDistances($Orga)]} {
		    incr CumulDesDistances($Orga) $Distance
		    incr NombreDeDistancesCumulees($Orga)
		} else {
		    set CumulDesDistances($Orga) $Distance
		    set NombreDeDistancesCumulees($Orga) 1
		}
		lappend ListeDesOrgas $Orga
	    }
	    if {[info exists DejaVuDansCetteListe($Orga)]} { continue }
	    lappend ListeNomOrgaDistanceDesPABs "$Nom $Orga $Distance"
	    append NomOrgasDuPAB " $Orga"
	    set DejaVuDansCetteListe($Orga) 1
	    incr Place
	    set MaxPlace [Maxi $MaxPlace $Place]
	    if {0 && $Place > 15} { continue } 
	    set Place [Mini $Place 15]
	    if { ! [info exists CumulOrgaPlace($Orga,$Place)]} {
		set CumulOrgaPlace($Orga,$Place) 0
	    }
	    incr CumulOrgaPlace($Orga,$Place)
	}
	set GrosseDefinition "[Definition $Nom]"
#	Espionne "[string range $GrosseDefinition 0 60] $NomOrgasDuPAB"
	lappend ListeNomOrgas $NomOrgasDuPAB
   }
   Espionne "$NombreDeLignesRejetees PAB rejetes"
   Espionne "$NombreDePhylosRetenus PAB retenus"

   Wup "Mettre 10 pour ne garder que les 10 premieres par ex."
   set nColonnes 12
   set MaxPlace [Mini $MaxPlace $nColonnes]

   set ListeOrgaEtSesPlaces {}
   foreach Orga $ListeDesOrgas {
       set LesPlaces {}
       set SesPlaces ""
       set CumulDM 0
       set CumulMM 0
       set CumulM 0
       for {set Place 1} {$Place<=$MaxPlace} {incr Place} {
	   if {[info exists CumulOrgaPlace($Orga,$Place)]} {
	       set COP [set CumulOrgaPlace($Orga,$Place)]
	       lappend LesPlaces $COP
	       incr CumulDM [expr $Place*$COP*$COP]
	       incr CumulMM [expr        $COP*$COP]
	       incr CumulM  $COP
	   } else {
	       lappend LesPlaces -1
	   }
       }
       Wup "On affiche le % si 1   ou le # de fois si 0 "
       set OnVeutPourcentage 0
       set Tab " "

       Wup "Nombre de fois mini ou orga doit apparaitre pour etre significatif"
       set MiniCumulM 1
       if { $CumulM < $MiniCumulM } { continue }

       foreach Place $LesPlaces {
	   set PP [Maxi [expr ($Place*100)/$CumulM] 0]
	   if { $Place > 0 } {
	       if {$OnVeutPourcentage} {
		   append SesPlaces [format "$Tab%4d" $PP]
	       } else {
		   append SesPlaces [format "$Tab%4d" $Place]
	       }
	   } else {
	       append SesPlaces "$Tab    "
	   }
       }
#      set SesPlaces [string trimright $SesPlaces]
       set MoyenneDesDistances [expr [set CumulDesDistances($Orga)]/[set NombreDeDistancesCumulees($Orga)]]
       set SesPlaces "$SesPlaces $MoyenneDesDistances" 
       set PlacePreferee [expr (1.0*$CumulDM)/$CumulMM]
       set BellePlacePreferee [format "%5.1f" $PlacePreferee]
       set BelOrga [format "%-16s" [string range [Glossaire $Orga Pointe] 0 15]]
       set OrgaCentreEtSesPlaces "$BellePlacePreferee $BelOrga $SesPlaces"  
       lappend ListeOrgaEtSesPlaces $OrgaCentreEtSesPlaces
   }
   set ListeTriee [lsort -command CompareLesFloatsEnDebut $ListeOrgaEtSesPlaces]
   set BonneListeTriee {}
   foreach Ligne $ListeTriee {
       lappend BonneListeTriee [string range $Ligne 6 end]
   }
   Espionne [join $BonneListeTriee "\n"]

   set Resume "Ordre  "
   foreach Ligne $BonneListeTriee {
       scan $Ligne "%s" OrgaPointe
       set Orga [Glossaire $OrgaPointe Court]
       if {[regexp "M.thermoauto" $OrgaPointe]} { set Orga "mthe" }
       if {[regexp "nmen" $Orga]} { continue }
       append Resume " $Orga"
   }
   Espionne [string range $Resume 0 100]
#   foreach SC [LesSuperClassesDansLOrdre] {
#       if { ! [info exists Cumul($SC)]} { continue }
#       if {[regexp "RR|tR" $SC]} { continue }
#       set HistoDuSC [format "%4d %4.1f%% %s" [set Cumul($SC)] [expr [set Cumul($SC)]*100./$NombreDePhylosRetenus] $SC]
#       Espionne $HistoDuSC
#       lappend HistoDesSC $HistoDuSC
#   }

    set FichierOrgaEtSesPlaces "$RepertoireDuGenome/fiches/orgaetsesplaces.$Titre"
    if {[file exists $FichierOrgaEtSesPlaces]} {
	if { ! [OuiOuNon "$FichierOrgaEtSesPlaces\nalready exists. Do I replace it ?"]} {
	    set FichierOrgaEtSesPlaces [FichierPourSaveAs "$FichierOrgaEtSesPlaces"]
	}
    }
    if {$FichierOrgaEtSesPlaces!=""} {
	Espionne [SauveLesLignes $BonneListeTriee dans $FichierOrgaEtSesPlaces]
    }

    set FichierPABRetenus "$RepertoireDuGenome/fiches/pabretenus.$Titre"
    if {[file exists $FichierPABRetenus]} {
	if { ! [OuiOuNon "$FichierPABRetenus\nalready exists. Do I replace it ?"]} {
	    set FichierPABRetenus [FichierPourSaveAs "$FichierPABRetenus"]
	}
    }
    if {$FichierPABRetenus!=""} {
	Espionne [SauveLesLignes $LesRetenus dans $FichierPABRetenus]
    }
#   Espionne [SauveLesLignes $HistoDesSC dans "$RepertoireDuGenome/fiches/superclasses.$Titre"]
#   Espionne [SauveLesLignes $LesRejetes dans "$RepertoireDuGenome/fiches/pabrejetes.$Titre"]

}

proc CreeLaTableDuTamis {{Tam ""} {Source ""} {Orga ""} {Extension ""}} {

    if {$Tam==""} { set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"] }
    set Tam [CreeLeTasTamis $Tam]
    if {$Tam==""} { return "" } 
    CreeLaTable "TasTamis_$Tam" $Source $Orga $Extension

}

proc CreeLaTableSignals {Handle} {


    set Status [mysqlexec $Handle {
	create table if not exists Signals (
	PK integer,
	Name varchar(64), 
	Seq  varchar(254), 
	Description varchar(254),
	primary key (id)
	); 
    }]
    return $Status

}

proc CreeLeAln {{FilOut ""}} {

    lassign [SequencesASauver] LNoms LSeqs
    if {$LNoms == {}} {return}

    if {$FilOut eq ""} {
	set FilOut [DemandeEtSauveFichier "tfa" 1]
    }
    if {$FilOut eq ""} {return}

    set f [open $FilOut w]
    puts $f "CLUSTAL W : Created by Ordalie [DonneDateEtHeure]"
    puts $f ""
    set maxn [PlusLongEltDe $LNoms]
    set maxs [PlusLongEltDe $LSeqs]
    set fmt "%${maxn}s %s"

    set D 0
    while {$D < $maxs} {
	set F [expr {$D + 59}]
	foreach Nm $LNoms s $LSeqs {
	    if {[string trim $Nm] eq ""} {continue}

	    set Linit [string range $s $D $F]
	    set Linit [string map [list Z - . -] $Linit]
	    puts $f [format $fmt $Nm $Linit]
	}
	puts $f ""
	puts $f ""
	incr D 60
    }

    close $f

    return

}

proc CreeLeFichierActiChip1_0 {Fichier Out} {


    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set  PAB ""
	scan $Ligne "%s" PAB
	lappend LesPABs $PAB
    }
    close $F
    
    set LesPABs [lsort -unique $LesPABs]
    
    AppendAuFichier $Out [join $LesPABs "\n"]

    return ""

}

proc CreeLeFichierActiChip2_0 {Fichier} {


    set LesIDs [InterrogeLeGalFile_ActiChip LesIDs]
    
    set LesPABs ""
    foreach ID $LesIDs {
	#Espionne "$ID"
	set PAB ""

	if {! [regexp {^ACT[0-9]+} $ID]} {
	    continue
	} else {
	    regexp {^ACT[0-9]+} $ID PAB
	    lappend LesPABs $PAB
	}
    }
    set LesPABs [lsort -unique $LesPABs]
    
    AppendAuFichier $Fichier [join $LesPABs "\n"]

    return ""

}

proc CreeLeFichierActiChip3_0 {Fichier} {


    set LesIDs [ActiChip2_0]
    
    set LesPABs ""
    foreach PAB [ListeDesPABs] {
	if {[regexp -nocase $PAB $LesIDs]} {
	    continue
	} else {
	    lappend LesPABs $PAB
	}
    }
    set LesPABs [lsort -unique $LesPABs]
    
    AppendAuFichier $Fichier [join $LesPABs "\n"]

    return ""

}

proc CreeLeFichierAssocieAuxCouleurs {K {Fichier ""}} {

    global TypeCouleur

    set LesNomSignif [LesSignificationsAssocieesAuxORFs $K]

    if {$Fichier==""} {
	set Fichier [FichierPourSaveAs "[RepertoireDeTravail]/[set TypeCouleur($K)].lst"]
	if {$Fichier==""} { return "" }
    }
    return [SauveLesLignes $LesNomSignif dans "$Fichier"]

}

proc CreeLeFichierBornesDesIntergenes {{AskToKeep Ask} {LongueurMinimaleDesIntergenes ""}} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global ListeDeBoites
    global ListeDesTROUs

    if {$LongueurMinimaleDesIntergenes==""} { set LongueurMinimaleDesIntergenes 90 }

    if {$AskToKeep=="Replace"} { set AskToKeep 0 } else { set AskToKeep 1 }

    set Fichier "$RepertoireDuGenome/fiches/bornesdesintergenes"
    if {$AskToKeep &&  [file exists $Fichier] &&  [OuiOuNon "$Fichier already exists.\nDo I keep it?" 0]} {
	return $Fichier
    }


    set ListeDesTROUs "BidonPourFaireCroireQuIlExisteDeja"
    set LesBornesDesInterGenes {}
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    foreach Boite [ListeDeBoites] {
	set Nom    [Box $Boite nom]
	if {[regexp "GLIMMER" $Nom]} { continue }
	if { [Fantome $Nom] } { continue }
#	if { [Decede $Nom] } { continue }
#	if { [FiabiliteFonction $Nom] == 0 } { continue }
#	if { [FiabiliteFonction $Nom] == 1 } { continue }
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]
	lappend LesDebuts [expr $Debut*2] 
	lappend LesFins   [expr $Fin*2+1]
    }

    set LeToutTrie [lsort -integer [concat $LesDebuts $LesFins]]

    set Niveau 0
    set i 0
    set FinCourante 1
    foreach X $LeToutTrie {
	if {[expr $X%2 == 0]} {
	    set DebutCourant [expr $X/2-1]
	    incr Niveau  1
	    if { $Niveau == 1 } {
#		set Debut [expr ($FinCourante/3)*3+3]
#		set Fin   [expr (($DebutCourant+1)/3)*3]
		set Debut [expr $FinCourante+1]
		set Fin   [expr $DebutCourant-1]
		set Long  [expr $Fin-$Debut+1]
		set Orient "F"
		set Frame [NomDeLaFrame TROU $Orient]
		if { $Long >= $LongueurMinimaleDesIntergenes } {
		    set Num [format "%4.4d" [incr i]]
		    set Nom "INTERGENE$Num"
		    set  Boite        $Nom
		    Box $Boite nom    $Nom
		    Box $Boite orient $Orient
		    Box $Boite frame  $Frame
		    Box $Boite debut  $Debut
		    Box $Boite fin    $Fin
		    Box $Boite $Long

		    Espionne "$Nom $Debut $Fin $Orient $Long"

		    lappend LesBornesDesInterGenes "$Nom $Debut $Fin $Orient $Long" 

		    if {[info exists CompteParLong($Long)]} {
			incr CompteParLong($Long)
		    } else {
			set CompteParLong($Long) 1
		    }

		}
	    }
	} else {
	    set FinCourante [expr $X/2+1]
	    incr Niveau -1
	}
    }
    foreach Long [lsort -decreasing -integer [array names CompteParLong]] {
	puts "$Long [set  CompteParLong($Long)]"
    }
    return [SauveLesLignes $LesBornesDesInterGenes dans $Fichier]

}

proc CreeLeFichierBornesDesPABs {} {

    global RepertoireDuGenome

    file mkdir "$RepertoireDuGenome/fiches"

    set FichierBornes "$RepertoireDuGenome/fiches/bornesdespabs"
    if {[file exists $FichierBornes]} { return 1 }

    FaireLire "I will ask You how to determine the ORFs.\n So You have to choose between : \n - Glimmer\n - Gscope own calculation (ab initio)\n - already existing ORFs list\n - already known proteome (with or without DNA file)\n - from a GenBank file (with prots and DNA)\n - sequences from a Blast or MSF output."

    if {[OuiOuNon "Should I use Glimmer to create the ORFs ?"]} {
	Glimmer
	SauveLesLignes [LesBornesDeGlimmer] dans $FichierBornes
	CreateurDesPABs "Glimmer"
	return 1
    }

    if {[OuiOuNon "Should I create the ORFs ab initio ?"]} {
	if { ! [CreeLesPABsAbInitio]} { return 0 } 
	CreateurDesPABs "GscopeAbInitio"	
	return 1
    }

    if {[OuiOuNon "Could I use an old version of ORFs ... ?"]} {
	if { ! [RepriseDeVieuxPABs]} { return 0 }
	CreateurDesPABs "RepriseDeVieuxPABs"
	return 1
    }

    if {[OuiOuNon "Could I use an existing proteome from a GenBank file (with Prot and DNA) ... ?"]} {
	return [CreeLesPABsAvecGenBank]	
    }
    if {[OuiOuNon "Could I use an existing proteome from a tfas file (with Prot with/without DNA) ... ?"]} {
	return [CreeLesPABsAvecUnProteomeDansTFAs]	
    }
    if {[OuiOuNon "Could I use an existing proteome ... ?"]} {
	set FichierBornesProteome "$RepertoireDuGenome/fiches/bornesdespabs.proteome"
	while { ! [file exists $FichierBornesProteome] } {
	    if {[OuiOuNon "Do I create $FichierBornesProteome"]} {
		CreeLesPABsAvecUnProteomeEtADN
	    } else {
		if {[OuiOuNon "Do I skip proteome scanning ?"]} { return 0 }
		if {[OuiOuNon "Do I stop ?"]} { exit }
	    }
	}
	if {[OuiOuNon "Can I use \n $FichierBornesProteome\nas ORFs limits ?"]} {
	    File copy $FichierBornesProteome "$RepertoireDuGenome/fiches/bornesdespabs"
	    CreateurDesPABs "Proteome"	
	    return 1
	}
	
    }
    if {[OuiOuNon "Could I create ORFs from a Collection ... ?"]} {
	if { ! [CreeBornesDesPABsPourUneCollection [ButineArborescence "FOF"]]} { return 0 }
	CreateurDesPABs "Collection"
	return 1
    }

    if {[OuiOuNon "Stop ?"]} { exit }
    return 0

}

proc CreeLeFichierCdstfaMusMusculus {PAB} {

    set RepCdsMouse "[RepertoireDuGenome]/mrnatfa_cds_Mus_musculus"
    if {![file exists $RepCdsMouse]} {file mkdir $RepCdsMouse}
    set AccessRNA [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Mus musculus" "mRNA" Access]
    if {$AccessRNA==""} {continue}
    set LesCoord [LesCoordonneesDuCDSDumRNA $AccessRNA]
    if {$LesCoord==""} {continue}
    set FichiermRNAtfa "[RepertoireDuGenome]/mrnatfa_Mus_musculus/$PAB"
    append NouveauTfa "[EnteteDuFichierTFA $FichiermRNAtfa]\n"
    set SequenceCDS [ExtraitPartieDuTfa $FichiermRNAtfa [lindex $LesCoord 0] [lindex $LesCoord 1]]
    append NouveauTfa $SequenceCDS
    Sauve $NouveauTfa dans "$RepCdsMouse/$PAB"

}

proc CreeLeFichierChip_Affy_Gene_Present {{LesPABs ""} {Fichier ""} {PuceAffy ""}} {


    Wup "Permet de rechercher les access equivalents de nos sequences dans la puce affymetrix"
    Wup "Recherche combinee au moyen des annotations (access RefSeq par ex) et de la sequence (blast)"

    set DirOligo "[RepertoireDuGenome]/Probes/RefSeqBLAST3"

    if {$Fichier==""} {
	set Fichier  "[RepertoireDuGenome]/Probes/Chip_Affymetrix_Gene_Present"
	set Fichier  "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/Chip_Affymetrix_Gene_Present_ActiChip2_0"
    }
    if {$PuceAffy == ""}            {set PuceAffy "HG-U133_Plus_2"}
    if {$LesPABs  == ""}            {set LesPABs  [ActiChip2_0]}
    if {$LesPABs  == "ActiChip1_0"} {set LesPABs  [ActiChip1_0]}
    if {$LesPABs  == "ActiChip2_0"} {set LesPABs  [ActiChip2_0]}

    #Entete du fichier
    ##################
    AppendAuFichier $Fichier "[join [list Access AccRefSeq "Probe Set" Probe_Set_Text NbProbe_Set_Text Probe_Set_Blast NbProbe_Set_Blast] "\t"]"

    foreach PAB $LesPABs {
	set Probe_Set_Text  ""
	set Probe_Set_Blast ""
	set Probe_Set_Name  ""

	set AccRefSeq [ReturnBestHitFromLogFile $PAB $DirOligo]
	if {[regexp "Warning" $AccRefSeq]} {set AccRefSeq [lindex $AccRefSeq 1]}
	regsub "RSHUM:NM" $AccRefSeq "NM_" AccRefSeq
	#set Des [InterrogeLesInfosAffymetrix $PuceAffy $AccRefSeq Description]

	set   Probe_Set_Text  [InterrogeLesInfosAffymetrix $PuceAffy $AccRefSeq Probe_Set_Name]
	set NbProbe_Set_Text  [llength $Probe_Set_Text]
	set   Probe_Set_Blast [LesProbesSetDeNosSequencesParBlast $PAB]
	set NbProbe_Set_Blast [llength $Probe_Set_Blast]

	set Probe_Set_Name  [lsort -unique [concat $Probe_Set_Text $Probe_Set_Blast]]
	AppendAuFichier $Fichier "[join [list $PAB $AccRefSeq [join $Probe_Set_Name " "] $Probe_Set_Text $NbProbe_Set_Text $Probe_Set_Blast $NbProbe_Set_Blast] "\t"]"
	#Espionne "$PAB\t$AccRefSeq\t[join $Probe_Set_Name " "]"
    }
    return ""

}

proc CreeLeFichierChip_EST_Gene_Present {{Fichier ""} {LesPABs ""}} {


    Wup "Permet de rechercher les access equivalents de nos sequences dans la puce ontario"
    Wup "Recherche combinee au moyen des annotations (access RefSeq par ex) et des sequences (par blast)"

    if {$Fichier==""} {set Fichier "[RepertoireDuGenome]/Autres_Puces/Ontario/Chip_EST_Gene_Present_3.txt"}
    if {$LesPABs==""} {set LesPABs [ListeOligos]}
    
    set RepmRNA   "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa "[RepertoireDuGenome]/nuctfa"
    
    set     LesLignes ""
    lappend LesLignes [join  [list  GScopeAccess  ProteinAccess  DesignAccess  Definition  Chip_EST  Original_Image_ID  Verified_Image_ID  clusterID] "\t"]

    foreach PAB $LesPABs {
	set LesAccessOntario_Blast ""
	set LesAccessOntario_Text  ""
	set LesAccessOntario       ""
	set LesOriginal_Image_ID   ""
	set LesVerified_Image_ID   ""

	set GScopeAccess $PAB
	#On cherche les access equivalents a la fois par la sequence et par le meilleur access
	set LesAccessOntario_Blast [LesMeilleursOntarioDeNosSequencesParBlast     $PAB]
	set LesAccessOntario_Text  [LesMeilleursOntarioDeNosSequencesParReference $PAB]
	set LesAccessOntario       [lsort -unique [concat $LesAccessOntario_Blast  $LesAccessOntario_Text]]
	
	foreach AO $LesAccessOntario {
	    set AOsplite [split $AO "_"]
	    lappend LesOriginal_Image_ID [lindex $AOsplite 0]
	    lappend LesVerified_Image_ID [lindex $AOsplite 1]
	}
	if {$LesOriginal_Image_ID == ""} {
	    set Chip_EST "0"
	} else {
	    set Chip_EST [llength $LesOriginal_Image_ID]
	}	
	set LesOriginal_Image_ID [join $LesOriginal_Image_ID ";"]
	set LesVerified_Image_ID [join $LesVerified_Image_ID ";"]
	
	#On annote en recherchant les definitions
	set ProteinAccess ""
	set DesignAccess  ""
	set Definition    ""
	set clusterID     ""
	#Access utilise lors du design
	#un mRNA ou sequence originale (nuctfa)
	#######################################
	set Query     "$RepmRNA/$PAB"
	if {[file exists $Query]} {
	    set         DesignAccess [AccessDeLaBoite $PAB mRNA]
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		set     DesignAccess [AccessDuTFADumRNA $Query]
	    } else {set DesignAccess "$PAB"}
	}
	#Access et definition de la proteine correspondante
	###################################################
	set ProteinAccess [AccessDeLaBoite $PAB protein]
	set Definition    [AccessDeLaBoite $PAB protein Definition]
	#Definition de secours (mRNA ou access)
	#######################################
	if {       $Definition == "" && $DesignAccess != ""} {
	    set     Definition [AccessDeLaBoite $PAB mRNA Definition]
	    if {   $Definition == ""} {
		set Definition [lrange [DefDeAcc $DesignAccess genbankfull Def] 1 end]
	    }
	} 
	set clusterID ""

	set Ligne [join [list $GScopeAccess $ProteinAccess $DesignAccess $Definition $Chip_EST $LesOriginal_Image_ID $LesVerified_Image_ID $clusterID] "\t"]
	lappend LesLignes $Ligne 
    }
    set LesLignes [join $LesLignes "\n"]
    AppendAuFichier $Fichier "$LesLignes"

    return ""

}

proc CreeLeFichierChip_UMCU_Gene_Present {{Fichier ""} {LesPABs ""}} {


    Wup "Permet de rechercher les access equivalents de nos sequences dans la puce UMCU"
    Wup "Recherche au moyen des sequences (par blast) et du texte (interroge)"

    if {$Fichier==""} {set Fichier "[RepertoireDuGenome]/Autres_Puces/UMCU/Chip_UMCU_Gene_Present.txt"}

    switch -regexp -- $LesPABs {
	"ActiChip1" {set LesPABs [ActiChip1_0]}
	"ActiChip2" {set LesPABs [ActiChip2_0]}
	"default"   {set LesPABs [ActiChip2_0]}
    }
    #Espionne "$LesPABs"
    
    set RepmRNA     "[RepertoireDuGenome]/mrnatfa_Homo_sapiens"
    set RepNuctfa   "[RepertoireDuGenome]/nuctfa"
    set FichierUMCU "/genomics/g2/PuceUMCU/UMCU-H25k11.txt"
    set FichierUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU/UMCU-H25k11.txt"

    if {! [file exists $FichierUMCU]} {
	Espionne "$FichierUMCU does not exists, InterrogeLesInfosUMCU needs another file."
	return ""
    }

    set     LesLignes ""
    lappend LesLignes [join  [list  GScopeAccess  ProteinAccess  DesignAccess  Definition  UMCU_ID  UMCU_AC] "\t"]

    foreach PAB $LesPABs {
	set LesAccessUMCU_Blast ""
	set LesAccessUMCU_Text  ""
	set LesAccessUMCU       ""
	set UMCU_ID ""
	set UMCU_AC ""

	set GScopeAccess $PAB

	#1 On cherche les access equivalents par la sequence et par le texte
	####################################################################
	set LesAccessUMCU_Blast [LesMeilleursUMCUDeNosSequencesParBlast     $PAB]
	set LesAccessUMCU_Text  [LesMeilleursUMCUDeNosSequencesParReference $PAB]
	set LesAccessUMCU       [lsort -unique [concat $LesAccessUMCU_Blast  $LesAccessUMCU_Text]]
	#set LesAccessUMCU       [lsort -unique $LesAccessUMCU_Blast]
	
	foreach Acc $LesAccessUMCU {
	    lappend UMCU_AC $Acc
	    lappend UMCU_ID [InterrogeLesInfosUMCU $FichierUMCU $UMCU_AC Oligo_ID]
	}
	set UMCU_AC [join $UMCU_AC ";"]
	set UMCU_ID [join $UMCU_ID ";"]
	
	#2 On annote en recherchant les definitions
	###########################################
	set ProteinAccess ""
	set DesignAccess  ""
	set Definition    ""
	#Access utilise lors du design
	#un mRNA ou sequence originale (nuctfa)
	#######################################
	set Query     "$RepmRNA/$PAB"
	if {[file exists $Query]} {
	    set         DesignAccess [AccessDeLaBoite $PAB mRNA]
	} else {
	    set Query "$RepNuctfa/$PAB"
	    if {[file exists $Query]} {
		set     DesignAccess [AccessDuTFADumRNA $Query]
	    } else {set DesignAccess "$PAB"}
	}
	#Access et definition de la proteine correspondante
	###################################################
	set ProteinAccess [AccessDeLaBoite $PAB protein]
	set Definition    [AccessDeLaBoite $PAB protein Definition]
	#Definition de secours (mRNA ou access)
	#######################################
	if {       $Definition == "" && $DesignAccess != ""} {
	    set     Definition [AccessDeLaBoite $PAB mRNA Definition]
	    if {   $Definition == ""} {
		set Definition [lrange [DefDeAcc $DesignAccess genbankfull Def] 1 end]
	    }
	} 

	#3 On sauve le tout
	###################
	set Ligne [join  [list  $GScopeAccess  $ProteinAccess  $DesignAccess  $Definition  $UMCU_ID  $UMCU_AC] "\t"]
	#set Ligne [join [list $GScopeAccess $ProteinAccess $DesignAccess $Definition $Chip_EST $LesOriginal_Image_ID $LesVerified_Image_ID $clusterID] "\t"]
	lappend LesLignes $Ligne 
    }
    set LesLignes [join $LesLignes "\n"]
    AppendAuFichier $Fichier "$LesLignes"

    return ""

}

proc CreeLeFichierCompletRedondance1 {} {

    # synthetise les fichiers jumeaux de seqnuc et de loc en un : redondance1
    # tout est dans /fiches
    set FichierJumOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap"
    foreach Ligne [LesLignesDuFichier $FichierJumOverlap] {
	if {$Ligne==""} {continue}
	set LesNoms [split $Ligne " "]
	foreach Nom $LesNoms {
	    set Vu($Nom) 1
	    set LesJumSeq [LesJumeauxDeSequencesDuPremier $Nom]
	    if {$LesJumSeq==""} {continue} else {
		foreach Jum $LesJumSeq {set Vu($Jum) 1}
		set Ligne [concat $Ligne $LesJumSeq]
	    }
	}
	lappend ListeNew $Ligne
    }
    Espionne [llength $ListeNew]
    #return $ListeNew
    set FichierJumSeq "[RepertoireDuGenome]/fiches/jumeaux_SeqNuc"
    foreach Ligne [LesLignesDuFichier $FichierJumSeq] {
	set LesJumSeq [split $Ligne " "]
	set PremierNom [lindex $LesJumSeq 0]
	if {[info exists Vu($PremierNom)]} {continue}
	lappend ListeNew $Ligne
	foreach Nom $LesJumSeq {set Vu($Nom) 1}
    }
    Espionne [llength $ListeNew]
    foreach PAB [ListeDesPABs] {
	if {[info exists Vu($PAB)]} {continue}
	lappend ListeNew $PAB
    }
    Espionne [llength $ListeNew]
    return $ListeNew

}

proc CreeLeFichierCompositionEnATGC {} {

    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    set Source "BoutADN"
    while { ! [BoutADN Existe]} {
	if {[OuiOuNonMemo "Do I use the [RepertoireDuGenome]/nuctfa files to calculate ATGC composition ?"]} {
	    set Source "[RepertoireDuGenome]/nuctfa"
	    break
	}
	if {[OuiOuNonMemo "Do You want to browse a directory containing the nuc files ?"]} {
	    set Source [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/"]
	    if {$Source==""} { continue }
	    break
	}
	if {[OuiOuNon "DO You want to calculate ATGC composition later ?"]} { return "" }
    }

    set ntA 0
    set ntT 0
    set ntG 0
    set ntC 0
    set lt  0
    foreach Boite $ListeDeBoites {
	set Nom    [Box $Boite nom]    
	if {$Source=="BoutADN"} {
	    set Debut  [Box $Boite debut]
	    set Fin    [Box $Boite fin]
	    set Orient [Box $Boite orient]
	    
	    set ATGC [BoutADN $Debut $Fin $Orient]
	} else {
	    set FichierNucTFA "$Source/$Nom"
	    if { ! [file exists $FichierNucTFA]} {
		set ATGC ""
	    } else {
		set ATGC [QueLaSequenceDuFichierTFA $FichierNucTFA]
	    }
	}
	set l [Maxi 1 [string length $ATGC]]
	set nA 0
	set nT 0
	set nG 0
	set nC 0
	for {set i 0} {$i<$l} {incr i} {
	    incr lt
	    set c [string index $ATGC $i]
	    if { $c == "A" } { incr nA ; incr ntA }
	    if { $c == "T" } { incr nT ; incr ntT }
	    if { $c == "G" } { incr nG ; incr ntG }
	    if { $c == "C" } { incr nC ; incr ntC }
	}
	lappend Liste "$Nom  [expr round(($nG+$nC)*100./$l)]  [expr round(($nA+$nT)*100./$l)]  [expr round(($nA)    *100./$l)]  [expr round(($nT)    *100./$l)]  [expr round(($nG)    *100./$l)]  [expr round(($nC)    *100./$l)]"
    }
    set lt [Maxi $lt 1]
    	set Liste [linsert $Liste 0 "AllORFs  [expr round(($ntG+$ntC)*100./$lt)]  [expr round(($ntA+$ntT)*100./$lt)]  [expr round(($ntA)     *100./$lt)]  [expr round(($ntT)     *100./$lt)]  [expr round(($ntG)     *100./$lt)]  [expr round(($ntC)     *100./$lt)]"]

    set FichierCompo "$RepertoireDuGenome/fiches/compositionenatgc"
    return [SauveLesLignes $Liste dans "$FichierCompo"]

}

proc CreeLeFichierDansNucTfa {Nom Debut Fin Orient} {

    global RepertoireDuGenome
    global ADN TDN RAC

    JeMeSignale

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    catch {unset Nuc}
    if { $Orient == "F" } {
	set Nuc [string range $ADN $Debut $Fin]
    } else {
	set Nuc ""
	for {set i $Fin} {[expr {$i>=$Debut}]} {incr i -1} {
	    append Nuc [string range $TDN $i $i]
	}
    }
    
    set TFA [SequenceFormatTFA $Nuc $Nom "nucbrut"]
    return [Sauve $TFA dans "$RepertoireDuGenome/nuctfa/$Nom"]
#    set MauvaisNom "tmpreformatout.tmp"
#    set VraiDebut [expr [string first $MauvaisNom $GCG]+[string length $MauvaisNom]]
#    return [Sauve "${Nom}[string range $GCG $VraiDebut end]" dans "$RepertoireDuGenome/nuctfa/$Nom"]

}

proc CreeLeFichierDesProbeSetsDeNosSequences {{LesPABs ""}} {


    Wup "Cree un fichier contenant les ProbeSet de nos sequences"

    set Fichier       "[RepertoireDuGenome]/Probes/Chip_Affymetrix_Gene_Present"
    set Fichier       "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/Chip_Affymetrix_Gene_Present_ActiChip2_0"
    set FichierSortie "[RepertoireDuGenome]/Probes/Liste_ProbeSet_DeTest"

    if {$LesPABs==""}            {set LesPABs [ActiChip2_0]}
    if {$LesPABs=="ActiChip1_0"} {set LesPABs [ActiChip1_0]}
    if {$LesPABs=="ActiChip2_0"} {set LesPABs [ActiChip2_0]}

    set ProbeSetName ""
    set LesProbesSet ""

    set F  [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set LigneSplitee [split $Ligne "\t"]
	
	set PAB          [lindex $LigneSplitee 0]
	set RefSeq       [lindex $LigneSplitee 1]
	set ProbeSetName [split [lindex $LigneSplitee 2] " "]
	set LesProbesSet [concat $LesProbesSet $ProbeSetName]
    }

    AppendAuFichier $FichierSortie "[join $LesProbesSet "\n"]"

    close $F

    return ""

}

proc CreeLeFichierDesProbeSetsDeNosSequences2 {{LesPABs ""}} {


    Wup "Cree un fichier contenant les PAB et leurs ProbeSets a partir du fichier de resultat affymetrix"

    set Fichier "[RepertoireDuGenome]/Probes/Chip_Affymetrix_Gene_Present"
    set Fichier "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/Chip_Affymetrix_Gene_Present_ActiChip2_0"

    if {$LesPABs==""}            {set LesPABs [ActiChip2_0]}  
    if {$LesPABs=="ActiChip1_0"} {set LesPABs [ActiChip1_0]}
    if {$LesPABs=="ActiChip2_0"} {set LesPABs [ActiChip2_0]}

    set ProbeSetName     ""
    set LesLignesASauver ""
    set LesProbesSet     ""

    #On lit et on charge les PAB associes aux ProbeSetName et inversement
    set F  [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	set ProbeSetName ""
	set PAB          ""

	set LigneSplitee [split $Ligne "\t"]
	set PAB          [lindex $LigneSplitee 0]
	set ProbeSetName [split [lindex $LigneSplitee 2] " "]
	foreach Set $ProbeSetName {
	    set PABDuProbeSet($Set) $PAB
	}
    }

    #On relit le fichier de tous les resultats et on ne garde que nos probeset
    set NbLigne 0
    #D:\Jean\les_doc\Projet_Actin\Puces\Affymetrix\Analyse_resultats
    #set FichierAffy "D:\\Jean\\les_doc\\Projet_Actin\\Puces\\Affymetrix\\jean\\ListTest_AllAffyData.TXT"
    set FichierAffy "D:\\Jean\\les_doc\\Projet_Actin\\Puces\\Affymetrix\\Analyse_resultats\\AllAffyData3.TXT"
    set F  [open "$FichierAffy"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}
	if {$NbLigne=="0"} {
	    set LigneSplitee         [split    $Ligne             "\t"]
	    set LigneSplitee         [lreplace $LigneSplitee 0 0 "Probe_Set_Name"]
	    set LigneSplitee         [linsert  $LigneSplitee 0   "PAB"]
	    lappend LesLignesASauver [join     $LigneSplitee      "\t"]
	    set NbLigne              1
	}

	set ProbeSetName ""
	set PAB          ""
	set LigneSplitee ""

	set LigneSplitee [split $Ligne "\t"]
	set ProbeSetAffy [lindex $LigneSplitee 0]

	if {! [info exists PABDuProbeSet($ProbeSetAffy)]} {continue}
	set NewLine [linsert $LigneSplitee 0 [set PABDuProbeSet($ProbeSetAffy)]]
	
	lappend LesLignesASauver [join $NewLine "\t"]
    }
    
    set FichierSortie "D:\\Jean\\les_doc\\Projet_Actin\\Puces\\Affymetrix\\Analyse_resultats\\ListTest_AllAffyData_3"
    AppendAuFichier $FichierSortie "[join $LesLignesASauver "\n"]"

    close $F

    return ""

}

proc CreeLeFichierDistancesPhylo {} {

    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesPABs

    set TenirCompteDeFiabiliteFonction 0

    set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo"

    if {[file exists $FichierDistancesPhylo]} {
	if { ! [OuiOuNon "$FichierDistancesPhylo\n already exists. Do I replace it ?"]} {
	    return ""
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    foreach Nom [ListeDesPABs] {
	if {$TenirCompteDeFiabiliteFonction && [FiabiliteFonction $Nom] < 3 } { continue }
	set Liste [ListeTrieeDesDistancesPhylos $Nom]
	if {[llength $Liste] > 0} {
	    set NomListe "$Nom [join  $Liste " "]"
	    lappend ListeDesNomListe $NomListe
	}
    }
    return [SauveLesLignes $ListeDesNomListe dans $FichierDistancesPhylo]

}

proc CreeLeFichierExpectDans {Banque} {

    global RepertoireDuGenome

    foreach Nom [ListeDesPABs] {

	set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"
	if {[Enterre $Nom]} { continue }
	if { ! [file exists $Fichier]} { continue }
	DecortiqueBlast $Fichier  "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
	if {[llength $lPN] == 0} {
	    lappend ListeNomPN "$Nom 9999.9"
	} else {
	    lappend ListeNomPN "$Nom [lindex $lPN 0]"
	}   
    }
    SauveLesLignes $ListeNomPN dans "$RepertoireDuGenome/fiches/expectdans$Banque"

}

proc CreeLeFichierFonctionsDecouvertes {} {

    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set AF [NomDuMeilleurAful $Nom]
	if {$AF == ""} { continue }
	scan [MeilleurAful $Nom] "%s %s %f %s" AF AFok PN Raison
	if { ! $AFok} { continue }
	set TexteAF [lindex [DonneesAful $AF] 0]
	if {$TexteAF == "" } {
	    set RoFa "  00"
	    set TexteAF "$AF $RoFa sans reference fonctionnelle"
	} else {
	    scan $TexteAF "%s %d" AF RoFa
	}
	set FF [FiabiliteFonction $Nom]
	if {$FF == ""} { set FF "0" }
	lappend Liste [format "%3.3d %s %s %7s %s" $RoFa $Nom $FF $PN $TexteAF]	
    }
    set Liste [concat $Liste  [LesLignesDuFichier "$RepertoireDuGenome/aful/rolefamille"]]
    set ListeTriee [lsort $Liste]
    set Liste {}
    foreach Ligne $ListeTriee {
	lappend Liste [string range $Ligne 4 end]
    }
    Espionne [SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/fonctionsdecouvertes"]

}

proc CreeLeFichierFonctionsValidees {} {

    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]

	if {[Enterre $Nom]} { continue }

	set ValiDE [ExtraitInfo $Nom "ValiDE"]
	set ValiGN [ExtraitInfo $Nom "ValiGN"]
	set ValiCF [ExtraitInfo $Nom "ValiCF"]

	if {$ValiDE == "" } { continue }

	set CF [ClasseFonctionnelle $Nom]

	set FF [FiabiliteFonction $Nom]
	if {$FF == ""} { set FF "0" }
	lappend Liste [format "%3.3d %s %s %3.3d %-15s %s" $CF $Nom $FF $CF $ValiGN $ValiDE]	
    }
    set Liste [concat $Liste  [LesLignesDuFichier "$RepertoireDuGenome/aful/rolefamille"]]
    set ListeTriee [lsort $Liste]
    set Liste {}
    foreach Ligne $ListeTriee {
	lappend Liste [string range $Ligne 4 end]
    }
    Espionne [SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/fonctionsvalidees"]

}

proc CreeLeFichierGIF {K LesOrdresPourGIF LaBoundingBox CheminGIF ListeDesDimensions} {

    global CommandeCanvart
    global GraphisteDir
    
    if {[info exists SavantGraphiste] && $SavantGraphiste} {
	SauveLesLignes $LesOrdresPourGIF dans "[RepertoireDeTravail]/lesordrespourgif"
	QuestionDeScience Graphiste "exe ..."
    } else {
	if { ! [info exists CommandeCanvart]} {
	    set CommandeCanvart "java ImageDecoder2"
	}
	
	set X1 [lindex $LaBoundingBox 0]
	set Y1 [lindex $LaBoundingBox 1]
	set X2 [lindex $LaBoundingBox 2]
	set Y2 [lindex $LaBoundingBox 3]
	
	set ValWidth [lindex $ListeDesDimensions 0]
	if { [llength $ListeDesDimensions]==1 } {
	    set ValHeight [expr round($ValWidth*($Y2-$Y1)/($X2-$X1))]
	} else {
	    set ValHeight [lindex $ListeDesDimensions 1]
	}
	
	return [Graphiste $LesOrdresPourGIF $ValWidth $ValHeight $X1 $Y1 $X2 $Y2 $CheminGIF]
    }

}

proc CreeLeFichierGroupeDPCManu {Nom Repertoire} {

    Espionne $Nom
    set Fichier "[RepertoireDuGenome]/$Repertoire/$Nom.clu"
    if {! [file exists $Fichier]} {
	set Fichier "[RepertoireDuGenome]/$Repertoire/$Nom.clust"
    }
    if {$Repertoire == "cluspackgrid"} {
	set FichierSortie "[RepertoireDuGenome]/fiches/groupedpc.grid"
    }
    if {$Repertoire == "cluspackmafft"} {
	set FichierSortie "[RepertoireDuGenome]/fiches/groupedpc.mafft"
    }
    if {$Repertoire == "cluspackfinal"} {
	set FichierSortie "[RepertoireDuGenome]/fiches/groupedpc"
    }
    if {$Repertoire == "cluspack"} {
	set FichierSortie "[RepertoireDuGenome]/fiches/groupedpc"
    }
    set JeSuisSurUnCluster 0
    set OnATrouve 0
    
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$OnATrouve} {continue} 
	if {[regexp "Number of clusters" $Ligne]} {
	    set NombreDeClusters [StringSuivant "Number of clusters : " dans $Ligne]
	    set JeCommence 1
	}
	if {[regexp "Cluster" $Ligne]} {
	    set JeSuisSurUnCluster 1
	    set JeCommence 0
	    set NumeroCluster [StringApres "Cluster " dans $Ligne]
	    set Size [StringSuivant "size=" dans $Ligne]
	}
	if {$JeCommence && ! $JeSuisSurUnCluster} {continue}

	if {$Ligne == ""} {set JeSuisSurUnCluster 0}
	if {$NombreDeClusters == "1"} {
	    if {[regexp "Cluster" $Ligne]} {continue}
	    lappend LaListe "$Ligne"
	    	    
	}
	if {$JeSuisSurUnCluster && $NombreDeClusters != 1} {
	    if {[regexp "Cluster" $Ligne]} {continue}
	    lappend LaListe "$Ligne"
	}
	
	if {! $JeSuisSurUnCluster} {
	    if {[regexp "$Nom" $LaListe]} {
		set OnATrouve 1
	    } else {
		set LaListe {}
	    }
	}
    }
    set Liste [join $LaListe " "]
    set LaListe [regsub "$Nom " $LaListe ""]

    Espionne "$Nom $LaListe"
    AppendAuFichier $FichierSortie "$Nom $LaListe"

}

proc CreeLeFichierGroupedpcDeLaGrid {} {

    set Repertoire "cluspackgrid"
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/cluspackgrid/$Nom.clu"
	if { ! [file exists $Fichier]} {continue}
	CreeLeFichierGroupeDPCManu $Nom $Repertoire
    }

}

proc CreeLeFichierGroupedpcDuPipeLocal {Nom} {

    set Repertoire "cluspack"
    set Fichier "[RepertoireDuGenome]/cluspack/$Nom.clust"
    if { ! [file exists $Fichier]} {continue}
    CreeLeFichierGroupeDPCManu $Nom $Repertoire

}

proc CreeLeFichierMsfDuCluspak {Nom RepertoireIn RepertoireOut} {

    set FichierMSFTotal "[RepertoireDuGenome]/$RepertoireIn/$Nom.msf"
    if {! [file exists $FichierMSFTotal]} {
	set FichierMSFTotal "[RepertoireDuGenome]/$RepertoireIn/$Nom"
    }
    set RepertoireMSFDuCluster "[RepertoireDuGenome]/$RepertoireOut"
    if {! [file exists $RepertoireMSFDuCluster]} {file mkdir $RepertoireMSFDuCluster}
    set FichierMSFDuCluster "$RepertoireMSFDuCluster/$Nom"
    set MSFTotal [ContenuDuFichier $FichierMSFTotal]
    set LeGroupe [GroupeDpc $Nom "SameAs" "In"]
    set NouveauMSF [MSFSelection $MSFTotal $LeGroupe]
    AppendAuFichier $FichierMSFDuCluster $NouveauMSF

}

proc CreeLeFichierNombreDeCopainsDansBlast {{Source ""} {SeuilExpect ""} {Extension ""}} {

    global RepertoireDuGenome

    while {$Source==""} {
	FaireLire "I'll create Blast Hit count, please choose the source information"
	set LesSources [list taxobla DifferentOX DaedalusHits apns blastx blastp tblastngenomes tblastnhuman "MyOwnBlastDirectory"]
	set LesTextes  [list  "Count different TaxId from Taxobla"  "Count different TaxId"  "Count all DaedalusHits"  "Use ./apns/* files (obsolete)"  "Count simply hits from BlastX"  "Count simply hits from BlastP"  "Count simply hits from TBlastN genomes"  "Count simply hits from TBlastN human"  "Count simply hits from MyOwnBlastDirectory" ]
	set Source [ChoixParmiJoli $LesSources {} $LesTextes]
	if {$Source=="MyOwnBlastDirectory"} {
	    FaireLire "Please give the name of Your own blast directory\nthe letters 'blast' must appear in your name"
	    set Source [Entre "blast"]
	}
	if {$Source=="" && [OuiOuNon "Do I cancel "]} { return "" }
    }
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }


    set FichierNombreDeCopainsDansBlast "$RepertoireDuGenome/fiches/nombredecopainsdansblast$Extension"

    if {$Extension=="" && [OuiOuNon "Do You want to add an extension to \n $FichierNombreDeCopainsDansBlast"]} {
	set Extension [Entre ".$Source"]
	append FichierNombreDeCopainsDansBlast $Extension
    }

    set ListeNomNCops {}
    if {$Source=="DaedalusHits" || $Source=="DifferentOX"} {
	foreach Nom [ListeDesPABs] {
	    set FicDaedalus "[RepertoireDuGenome]/daedalushits/$Nom"
	    if { ! [file exists $FicDaedalus]} { continue }
	    set nCops 0
	    if {[info exists DejaVu]} { unset DejaVu }
	    foreach Ligne [LesLignesDuFichier $FicDaedalus] {
		set AncienneLigne $Ligne
		set PN [ValeurDeLaBalise PN Ligne]
		if {$PN==""} { continue ; FaireLire $AncienneLigne } 
		if { [expr $PN > $SeuilExpect] } { break }
		set OX [ValeurDeLaBalise OX Ligne]
		if {[info exists DejaVu($OX)]} { continue }
		incr nCops
		if {$Source=="DifferentOX"} { set DejaVu($OX) 1 }
	    }
	    lappend ListeNomNCops "$Nom $nCops"	    
	}
    } elseif {$Source=="apns"} {
	set ListeDesAPNs [concat  [glob -nocomplain "$RepertoireDuGenome/apns/*"]  [glob -nocomplain "$RepertoireDuGenome/trousapns/*"]  [glob -nocomplain "$RepertoireDuGenome/trouxsapns/*"]  [glob -nocomplain "$RepertoireDuGenome/trounsapns/*"]  ]
	
	foreach FichierAPN [lsort $ListeDesAPNs] {
	    set Nom [file tail $FichierAPN]
	    set nCops 0
	    foreach Ligne [LesLignesDuFichier $FichierAPN] {
		scan $Ligne "%s %s %f" BanqueId Access PN
		if { [expr $PN > $SeuilExpect] } { break }
		incr nCops
	    }
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } elseif {[regexp "blast" $Source]} {
	foreach Nom [ListeDesPABs] {
	    set FichierBlast "[RepertoireDuGenome]/$Source/$Nom"
	    if { ! [file exists $FichierBlast]} { continue }
	    set nCops [DecortiqueBlast $FichierBlast $SeuilExpect "" "BlastHitCount"]
	    Espionne "$Nom $nCops"
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } elseif {[regexp "taxobla" $Source]} {
	foreach Nom [ListeDesPABs] {
	    set FichierTaxobla "[RepertoireDuGenome]/$Source/$Nom"
	    if { ! [file exists $FichierTaxobla]} { continue }
	    set nCops [llength [LesLignesDuFichier $FichierTaxobla]]
	    Espionne "$Nom $nCops"
	    lappend ListeNomNCops "$Nom $nCops"
	}
    } else {
	FaireLire "Please give the source for CreeLeFichierNombreDeCopainsDansBlast"
	return ""
    }
    set Fichier [SauveLesLignes $ListeNomNCops dans $FichierNombreDeCopainsDansBlast]
    return [NombreDeCopainsDansBlast "Reload_Filename"]

}

proc CreeLeFichierOrganismesAyantMemeOperon {{Banque genomes} {SensSepares 0}} {

    global ListeDeBoites
    global RepertoireDuGenome
    global MemoPositionsDesAmis
    global MemoOrganismesDesAmis

    set FichierOMO "$RepertoireDuGenome/fiches/organismesayantmemeoperon"

    while {[file exists $FichierOMO]} {
	if {[OuiOuNon "$FichierOMO already exists,\nDo I append to it ?"]} { break }
	if {[OuiOuNon "$FichierOMO already exists,\nDo I replace it ?"]} {
	    File delete $FichierOMO
	    break
	}
	if {[OuiOuNon "Do I cancel ?"]} { return "" } 
	if {[OuiOuNon "Do I stop ?"]} { exit } 
    }

    if { ! [info exists MemoPositionsDesAmis]  && [file exists "$RepertoireDuGenome/fiches/ouatapetbn.$Banque"]  && [OuiOuNon "Can I use $RepertoireDuGenome/fiches/ouatapetbn.$Banque"]} {
	foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ouatapetbn.$Banque"] {
	    set LesMots [split $Ligne " "]
	    set Nom [lindex $LesMots 0]
	    if {[regexp -nocase {[a-z]} [lindex $LesMots 1]]} {
		set MemoOrganismesDesAmis($Nom) [lrange $LesMots 1 end]
	    }
	    if {[regexp -nocase {[0-9]} [lindex $LesMots 1]]} {
		set MemoPositionsDesAmis($Nom) [lrange $LesMots 1 end]
	    }
	}
    }

    if { ! [info exists AQuiEstCeDebut]} {

	if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

	foreach Boite $ListeDeBoites {
	    set Nom    [Box $Boite nom]
	    if {[Enterre $Nom] || ! [YaPABdans $Nom]} { continue }
	    set Debut  [Box $Boite debut]
	    set Fin    [Box $Boite fin]
	    set Orient [Box $Boite orient]
	    lappend AQuiEstCeDebut($Debut) $Nom
	    lappend AQuiEstCetteFin($Fin)  $Nom
	    lappend LesDebuts $Debut 
	    lappend LesFins   $Fin
	}
	
	set LesDebutsTries [lsort -integer $LesDebuts]
	set LesFinsTries   [lsort -integer $LesFins]
    }
    
    foreach Sens [list "F"] {
	catch {unset PositionsDesAmisDuVoisin}
	foreach Debut $LesDebutsTries {
	    set Nom [lindex [set AQuiEstCeDebut($Debut)] 0]
	    set Orient [Box $Nom orient]
	    if { $SensSepares && ($Orient != $Sens) } { continue }
	    set Debut [Box $Nom debut]
	    set   Fin [Box $Nom fin]


	    set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"
	    if {[FileAbsent $Fichier]} { continue }
	    if {[info exists MemoPositionsDesAmis($Nom)]} {
		set OrganismesDesAmis [set MemoOrganismesDesAmis($Nom)]
		set PositionsDesAmis  [set MemoPositionsDesAmis($Nom)]
	    } else {
		set PositionsDesAmis {}
		set OrganismesDesAmis {}
		set LesHits [OuATapeTBlastN $Fichier $Banque "ListeDesPositions"]
		foreach Hit $LesHits {
		    Espionne "Hit $Hit"
		    regsub -all ">" $Hit " " Hit
		    set OX [StringApres ">>>$Message"
	return ""
    }
    #Espionne "$ExtractTFAs"
    AppendAuFichier $Fichier $ExtractTFAs 

    return ""

}

proc CreeLeFichierTFAsDesAccessDuBlastPPourTous {{RepTFAs ""} {SeuilExpect ""} {MaxListe ""}} {

    if {$SeuilExpect==""} { set SeuilExpect 0.001 }
    if {$MaxListe==""}    { set MaxListe "SansLimiteDeNombre" }
    if {$RepTFAs==""}     { set RepTFAs "[RepertoireDuGenome]/tfaspourmafft" }

    if { ! [file exists $RepTFAs]} {file mkdir $RepTFAs} 

    foreach Nom [ListeDesPABs] {
	set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
	set FichierTFAs  "$RepTFAs/$Nom"
	if { ! [file exists $FichierBlast]} { continue }
	if {[file exists $FichierTFAs]} { continue }
	DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
	Espionne [CreeUnTFAsDesListesBidAccess $lBanqueId $lAccess $FichierTFAs]
    }

}

proc CreeLeFichierTFAsDesRNsDeCbriggsae {} {

    set LesTFAs {}
    foreach Ligne [LesRecepteursNucleairesDe "briggsae"] {
	scan $Ligne "%s %s" Bidon Access
	if {[info exists DejaVu($Access)]} { continue }
	set DejaVu($Access) 1 
	set TFA [LaSequenceDuTFAs "/catalog/blast/Cbriggsae" $Access]
	lappend LesTFAs $TFA
    }
    Espionne [SauveLesLignes $LesTFAs dans "[RepertoireDuGenome]/Cbriggsae_nr.tfa"]

}

proc CreeLeFichierTfaPourClustering {} {

    global TabRecap
    if { ! [info exists TabRecap]} { CreeTableRecapDesClusters }
    set FichierTfaPourClusteringMGU74 "[RepertoireDuGenome]/transcriptomique/RecapTfaPourClusteringMGU74.tfa"
    set FichierTfaPourClusteringMG430 "[RepertoireDuGenome]/transcriptomique/RecapTfaPourClusteringMG430.tfa"

    set LesLignesDeValeursMGU74 {}; set LesLignesDeValeursMG430 {}

    foreach Queue $TabRecap(LesQueues) {
	set LigneMGU74 {}; set LigneMG430 {}; set LesElmtDeTabRecap {}; set CodeLettreMGU74 ""; set CodeLettreMG430 ""
	set LesMots [LesMotsDeLaLigne $TabRecap($Queue)]

	set LesElmtsQueue [split [lindex $LesMots 0] "-"]
	if {[regexp {^AFFX} [lindex $LesElmtsQueue 1]]} {continue}
	set cluster1 [lindex $LesMots 1]

	if {$cluster1=="-1"} {
	    set LesMots [lreplace $LesMots 1 1 ""] 
	    set LesMots [lreplace $LesMots 2 2 ""] 
	    set LesMots [lreplace $LesMots 3 3 ""] 
	    set LesMots [lreplace $LesMots 5 5 ""] 
	    set LesMots [lreplace $LesMots 6 6 ""] 
	    set LesMots [lreplace $LesMots 13 13 ""]
	    set LesMots [lreplace $LesMots 14 14 ""]
	    set LesMots [lreplace $LesMots 15 15 ""]
	    set LesMots [lreplace $LesMots 21 21 ""]
	    set LesMots [lreplace $LesMots 22 22 ""]
	    set LesMots [lreplace $LesMots 23 23 ""]
	    set LesMots [lreplace $LesMots 24 24 ""]
	    set TabRecap($Queue) [join $LesMots " "]
	    regsub -all " {2,10}" $TabRecap($Queue) " " TabRecap($Queue)
	    lappend LesLignesDeValeursMGU74 ">$Queue"
	    set LesElmtDeTabRecap [split $TabRecap($Queue) " "]
	    set LesElmtDeTabRecap [ListeSsElmtVide $LesElmtDeTabRecap]
	    foreach MotMGU74 $LesElmtDeTabRecap { 
		if {[regexp {^EVI} $MotMGU74]} {continue}
		set CodeLettreMGU74 [MatriceLettreChiffre $MotMGU74 Lettre]
		lappend LigneMGU74 $CodeLettreMGU74
	    }
	    regsub -all " " $LigneMGU74 "" LigneMGU74
	    lappend LesLignesDeValeursMGU74 $LigneMGU74
	} else {
	    set LesMots [lreplace $LesMots 4 4 ""] 
	    set LesMots [lreplace $LesMots 7 7 ""] 
	    set LesMots [lreplace $LesMots 8 8 ""] 
	    set LesMots [lreplace $LesMots 9 9 ""]
	    set LesMots [lreplace $LesMots 10 10 ""]
	    set LesMots [lreplace $LesMots 11 11 ""]
	    set LesMots [lreplace $LesMots 12 12 ""]
	    set LesMots [lreplace $LesMots 16 16 ""]
	    set LesMots [lreplace $LesMots 17 17 ""]
	    set LesMots [lreplace $LesMots 18 18 ""]
	    set LesMots [lreplace $LesMots 19 19 ""]
	    set LesMots [lreplace $LesMots 20 20 ""]
	    set TabRecap($Queue) [join $LesMots " "]
	    regsub -all " {2,10}" $TabRecap($Queue) " " TabRecap($Queue)
	    lappend LesLignesDeValeursMG430 ">$Queue"
	    set LesElmtDeTabRecap [split $TabRecap($Queue) " "]
	    set LesElmtDeTabRecap [ListeSsElmtVide $LesElmtDeTabRecap]
	    foreach MotMG430 $LesElmtDeTabRecap { 
		if {[regexp {^EVI} $MotMG430]} {continue}
		set CodeLettreMG430 [MatriceLettreChiffre $MotMG430 Lettre]
		lappend LigneMG430 $CodeLettreMG430
	    }
	    regsub -all " " $LigneMG430 "" LigneMG430
	    lappend LesLignesDeValeursMG430 $LigneMG430
	}
    } 
    SauveLesLignes $LesLignesDeValeursMGU74 dans $FichierTfaPourClusteringMGU74
    SauveLesLignes $LesLignesDeValeursMG430 dans $FichierTfaPourClusteringMG430

}

proc CreeLeFichierTfaPourClusteringRavi {{FichierIn ""} {FichierOut ""}} {

    if {$FichierIn==""} {
	set FichierIn "/genomics/link/ravi/public_retina_metacluster/allexp_cluster.txt"
    }
    set premiereligne 1
    set I 0
    foreach Ligne [LesLignesDuFichier $FichierIn] {
	set LesChiffClu {}; set LesLettrClu {}
	if {$premiereligne} {
	    set premiereligne 0
	    set LesTetes [split $Ligne "\t"]
	    foreach Tete $LesTetes {
		incr I
		set ArrayTete($I) $Tete
	    }
	    #Espionne "++$ArrayTete(2)"
	    continue
	}
	set LesElmts [split $Ligne "\t"]
	set ProbeSetId [lindex $LesElmts 0]
	for {set j 1} {$j<$I} {incr j} {
	    set Chiff [lindex $LesElmts $j]
	    lappend LesChiffClu $Chiff
	    set lettr [MatriceLettreChiffreSsMinus1 $Chiff Lettre]
	    lappend LesLettrClu $lettr
	}
	set ChiffClu [join $LesChiffClu " "]
	set LettrClu [join $LesLettrClu ""]
	set ArrayChiffClu($ProbeSetId) $ChiffClu
	set ArrayLettrClu($ProbeSetId) $LettrClu
	set Ligne ">$ProbeSetId"
	lappend LesLignes $Ligne
	#set Ligne "$ArrayChiffClu($ProbeSetId)"
	#lappend LesLignes $Ligne
	set Ligne "$ArrayLettrClu($ProbeSetId)"
	lappend LesLignes $Ligne
    }
    if {$FichierOut==""} {
	SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/transcriptomique/MetaCluster/Ravi/TfaAllexp_cluster.tfa"
    } else {
	SauveLesLignes $LesLignes dans $FichierOut
    }

}

proc CreeLeGrosTfaVertebrateEnsembl {} {

    foreach File [glob -nocomplain "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/*.pep.all.fa.gz"] {
	Espionne "$File"
	set FEns ""
	set FEns "[TmpFile].ens"
	exec gunzip -c $File > $FEns
	foreach Ligne [LesLignesDuFichier $FEns] {
	    lappend LesLignesFinales $Ligne
	}
	if {$FEns!="" && [file exists $FEns]} { file delete $FEns }    
    }
    SauveLesLignes $LesLignesFinales dans "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/Ensembl_Vertebrata"

}

proc CreeLeGrosTfaVertebrateRefSeq {FichiersTfa FichierOut} {

    #FichiersTfa "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/tfa/rsnc.*"
    #FichierOut "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata"
    #FichiersTfa "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/tfa/complete*"
    #FichierOut "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata"
    set nbfile 0
    foreach File [glob -nocomplain $FichiersTfa] {
	incr nbfile
	Espionne "++$File"
	foreach Ligne [LesLignesDuFichier $File] {
	    lappend LesLignesFinales $Ligne
	}
    }
    SauveLesLignes $LesLignesFinales dans $FichierOut
    Espionne "nbfile $nbfile"

}

proc CreeLeGrosTfaVertebrateVarsplic {} {

    set FichierDepart "/blast/varsplic"
    set FichierSortie "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Varsplic/varsplic_Vertebrata"
    set LesPbs {}
    foreach Ligne [LesLignesDuFichier $FichierDepart] {
	if {[regexp "\>" $Ligne]} {
	    set prends 0
	    set Genre "Unknown"; set Espece "unknown"
	    set OS [StringSuivant "OS=" dans $Ligne]
	    scan $OS "%s %s %s" Genre Espece Virus
	    if {[regexp -nocase "virus|phage" $OS]} {set Espece "${Genre}_$Espece" ; set Genre "Virus"; continue}
	    set OS "$Genre $Espece"
	    set OC [OCduOS $OS]
	    if {$OC=="" && ![info exists DejaVu($OS)]} {set DejaVu($OS) 1; lappend LesPbs "Pb1 $Ligne"}
	    if {$OC=="ClassUnknown" && ![info exists DejaVu($OS)]} {set DejaVu($OS) 1; lappend LesPbs "Pb2 $Ligne"}
	    if {[regexp -nocase "Vertebrata" $OC]} {set prends 1}
	}
	if {$prends} {lappend LesLignesFinales $Ligne}
    }
    SauveLesLignes $LesLignesFinales dans $FichierSortie
    Espionne [join $LesPbs "\n"]


}

proc CreeLeMSF {{outfile ""} {LNoms ""} {LSeqs ""}} {

    if {$outfile eq ""} {
	set outfile [DemandeEtSauveFichier "msf" 1]
    }
    if {$outfile eq ""} {return}

    if {$LNoms == {} } {
	lassign [SequencesASauver] LNoms LSeqs
    }
    if {$LNoms == {}} {return}

    foreach s $LSeqs {
	set w [SeqGCGCheckSum $s]
	incr SumCheck $w

	lappend Lw $w
	lappend Lt [DefinitTypeSeq $s]
    }
    set SumCheck [expr {$SumCheck % 10000}]
    set len [string length [lindex $LSeqs 0]]
    set Nmax [PlusLongEltDe $LNoms]
    if {$Nmax < 12} {set Nmax 11}
    set uLt [lunique $Lt]
    if {[llength $uLt] > 1} {
	set nmax -1 ; set tmax ""
	foreach e $uLt {
	    set n [llength [lsearch $Lt $e]]
	    if {$n > $nmax} {
		set nmax $n
		set tmax $e
	    }
	}
	set uLt $tmax
    }
    if {$uLt eq "Protein"} {set type "P"} {set type "N"}

    set Llg [list]
    lappend Llg "PileUp\n\n\n\n"
    set ligne ""
    append ligne [format "   MSF:%5d  Type: %1s" $len $type]
    append ligne [format "    Check:%6ld   .. \n\n" $SumCheck]
    lappend Llg "$ligne"
    foreach n $LNoms w $Lw {
	lappend Llg [format " Name: %s oo  Len:%5d  Check:%6ld  Weight:  %.1f" $n $len $w 10.0]
    }
    lappend Llg "\n//"

    set chunks [expr {$len/100}]
    if {$len % 100 != 0} {incr chunks}
    
    for {set block 0} {$block < $chunks} {incr block} {
	lappend Llg "\n\n"
	set pos1 [expr {$block * 100}]
	set pos2 [expr {$len<$pos1+99 ? $len : $pos1+99}]
	foreach nom $LNoms seq $LSeqs {
	    set ligne [format "%${Nmax}s" $nom]
	    set bout [string range $seq $pos1 $pos2]
	    set nbout [expr {($pos2-$pos1+1)/10}]
	    for {set i 0} {$i < $nbout} {incr i} {
		append ligne " [string range $bout [expr {$i*10}] [expr {($i+1)*10-1}]]"
	    }
	    lappend Llg "$ligne"
	}
    }
    lappend Llg "\n\n"

    if {$outfile ne "OnRetourne"} {
	set f [open $outfile w]        
	puts $f [join $Llg \n]
	close $f
    }

    return $Llg

}

proc CreeLeMSFduTFAs {FichierOuTexteTFAs FichierMSF} {

    return [ConvertToMsf $FichierOuTexteTFAs $FichierMSF]

}

proc CreeLeMacsim {{out dehors} {LNoms ""} {LSeqs ""}} {

    global LNOrdali LSOrdali TabSF TpI TMolW
    global GroupeDeLaSequence
    global NomAlignement
    global AlnName AlnScore AlnNote
    global TColScore
    global {*}[info globals "TD*"]

    dom createDocument "macsim" doc

    # Crée les commandes de creation de noeuds
    dom createNodeCmd "elementNode" MS::alignment
    dom createNodeCmd "elementNode" MS::aln-name
    dom createNodeCmd "elementNode" MS::aln-score
    dom createNodeCmd "elementNode" MS::aln-note
    dom createNodeCmd "elementNode" MS::sequence
    dom createNodeCmd "elementNode" MS::seq-name
    dom createNodeCmd "elementNode" MS::seq-info
    dom createNodeCmd "elementNode" MS::accession
    dom createNodeCmd "elementNode" MS::nid
    dom createNodeCmd "elementNode" MS::definition
    dom createNodeCmd "elementNode" MS::organism
    dom createNodeCmd "elementNode" MS::taxid
    dom createNodeCmd "elementNode" MS::group
    dom createNodeCmd "elementNode" MS::lifedomain
    dom createNodeCmd "elementNode" MS::hydrophobicity
    dom createNodeCmd "elementNode" MS::ec
    dom createNodeCmd "elementNode" MS::length
    dom createNodeCmd "elementNode" MS::lineage
    dom createNodeCmd "elementNode" MS::taxon
    dom createNodeCmd "elementNode" MS::molecularweight
    dom createNodeCmd "elementNode" MS::isoelectricpoint
    dom createNodeCmd "elementNode" MS::seq-data
    dom createNodeCmd "elementNode" MS::ftable
    dom createNodeCmd "elementNode" MS::fitem
    dom createNodeCmd "elementNode" MS::ftype
    dom createNodeCmd "elementNode" MS::fstart
    dom createNodeCmd "elementNode" MS::fstop
    dom createNodeCmd "elementNode" MS::fcolor
    dom createNodeCmd "elementNode" MS::fscore
    dom createNodeCmd "elementNode" MS::fnote

    dom createNodeCmd "elementNode" MS::goxreflist
    dom createNodeCmd "elementNode" MS::goxref
    dom createNodeCmd "elementNode" MS::goid
    dom createNodeCmd "elementNode" MS::goclass
    dom createNodeCmd "elementNode" MS::godesc
    dom createNodeCmd "elementNode" MS::goevidence

    dom createNodeCmd "elementNode" MS::column-score
    dom createNodeCmd "elementNode" MS::colsco-name
    dom createNodeCmd "elementNode" MS::colsco-owner
    dom createNodeCmd "elementNode" MS::colsco-type
    dom createNodeCmd "elementNode" MS::colsco-group
    dom createNodeCmd "elementNode" MS::colsco-data
    dom createNodeCmd "textNode"    MS::text

    $doc documentElement root
    $root appendFromScript {
	MS::alignment
    }
    set aln [$root lastChild]

    append AlnNote " Created by Ordali"
    foreach n [list "aln-name" "aln-score" "aln-note"] k [list "$AlnName" "AlnScore" "$AlnNote"] {
	$aln appendFromScript {
	    MS::$n {MS::text $k}
	}
    }
    
    # Boucle sur les noms, remplit champ 
    if {$LNoms eq ""} {
	set LNoms $LNOrdali
	set LSeqs $LSOrdali
    }

    foreach n $LNoms s $LSeqs {
	if {[string trim $n] eq ""} {continue}

	set IsPDB [EstUnAccessPDB $n]
	if {$IsPDB} {
	    set mol [DonneIdDeAccessPDB $n]
	    set chn [DonneChainDeAccessPDB $n]
	    if {$chn eq ""} {set chn "a"}
	}
	set s [string map [list "." - "Z" -] $s]
	set s [string tolower $s]
	set lgs [string length [string map {- ""} $s]]

	$aln appendFromScript {
	    MS::sequence -seq-type Protein
	}
	set ns [$aln lastChild]
	$ns appendFromScript {
	    MS::seq-name {MS::text [set TDesSeqnames($n)]}
	}
	$ns appendFromScript {
	    MS::seq-info
	}
	# sequence infos
	set si [$ns lastChild]
	$si appendFromScript {
	    set ac [set TDesAccess($n)]
	    MS::accession {MS::text $ac}
	}
	if {[info exists TDesBId($n)]} {
	    $si appendFromScript {
		set bid [set TDesBId($n)]
		MS::nid {MS::text $bid}
	    }
	}
	$si appendFromScript {
	    set g [set GroupeDeLaSequence($n)]
	    set g [string range $g 5 end]
	    MS::group {MS::text $g}
	}
	if {[info exists TDesDescriptifs($n)]} {
	    $si appendFromScript {
		set des [set TDesDescriptifs($n)]
		MS::definition {MS::text $des}
	    }
	}
	if {[info exists TDesOrganismes($n)]} {
	    $si appendFromScript {
		set orga [set TDesOrganismes($n)]
		MS::organism {MS::text $orga}
	    }
	}
	if {[info exists TDesTaxId($n)]} {
	    $si appendFromScript {
		set tax [set TDesTaxId($n)]
		MS::taxid {MS::text $tax}
	    }
	}
	$si appendFromScript {
	    MS::length {MS::text $lgs}
	}
	if {[info exists TDesPhylum($n)]} {
	    $si appendFromScript {
		MS::lifedomain {MS::text [set TDesPhylum($n)]}
	    }
	}
	if {[info exists TDuLineage($n)]} {
	    $si appendFromScript {
		MS::lineage
		set tx [$si lastChild]
		foreach t [set TDuLineage($n)] {
		    $tx appendFromScript {
			MS::taxon {MS::text $t}
		    }
		}
	    }
	}
	if {[info exists TDesGO($n)]} {
	    $si appendFromScript {
		MS::goxreflist
		set ng [$si lastChild]
		foreach e [set TDesGO($n)] {
		    $ng appendFromScript {
			MS::goxref
			set nv [$ng lastChild]
			$nv appendFromScript {
			    foreach {k v} $e {
				MS::$k {MS::text $v}
			    }
			}
		    }
		}
	    }
	}

	if {[info exists TDesHydro($n)]} {
	    $si appendFromScript {
		MS::hydrophobicity {MS::text [set TDesHydro($n)]}
	    }
	}
	if {[info exists TDesEC($n)]} {
	    $si appendFromScript {
		MS::ec {MS::text [set TDesEC($n)]}
	    }
	}

	# Features
	if {[array names TabSF "$n,*"] != {} } {
	    $si appendFromScript {
		MS::ftable
	    }
	    set ft [$si lastChild]
	    foreach nf [lsort [array names TabSF "$n,*"]] {
		lassign [split $nf ,] tmp type
		foreach f [set TabSF($nf)] {
		    DecortiqueUneFeature $f iStart iStop color score note csys

		    if {$csys eq "local" || $csys eq ""} {
			# DonnePosGS gives pos seq. 
			# starting at 1
			set start [DonnePosGS $n $iStart]
			set stop  [DonnePosGS $n $iStop]
			if {$IsPDB} {
			    # CoordsPDB2Seq gives 
			    # values starting at 0 !
			    set start [expr {[$mol CoordsPDB2Seq $chn $start] + 1}]
			    set stop  [expr {[$mol CoordsPDB2Seq $chn $stop] + 1}]
			}
		    } else {
			set start [expr {$iStart + 1}]
			set stop  [expr {$iStop  + 1}]
		    }
		    $ft appendFromScript {
			MS::fitem -coords $csys
		    }
		    set fi [$ft lastChild]
		    $fi appendFromScript {
			MS::ftype {MS::text $type}
		    }
		    $fi appendFromScript {
			MS::fstart {MS::text $start}
		    }
		    $fi appendFromScript {
			MS::fstop {MS::text $stop}
		    }
		    $fi appendFromScript {
			MS::fcolor {MS::text $color}
		    }
		    $fi appendFromScript {
			MS::fscore {MS::text $score}
		    }
		    $fi appendFromScript {
			MS::fnote {MS::text $note}
		    }
		}
	    }
	}
	# data section -> the aa sequence
	$ns appendFromScript {
	    MS::seq-data {MS::text $s}
	}
	$si appendFromScript {
	    MS::molecularweight {MS::text [set TDesMolW($n)]}
	}
	$si appendFromScript {
	    MS::isoelectricpoint {MS::text [set TDespI($n)]}
	}
    }

    # Column Score
    if {[info exists TColScore]} {
	$aln appendFromScript {
	    MS::column-score
	}
	set cs [$aln lastChild]

	# insert each colmeasurement
	foreach name $TColScore(Names) {
	    $cs appendFromScript {
		MS::colsco-name {MS::text $name}
	    }
	    set cn [$cs lastChild]
	    for {set i 0} {$i < [llength [set TColScore($name,Owner)]]} {incr i} {
		foreach cle {colsco-owner colsco-type colsco-data colsco-group} k {Owner Type Data Group} {
		    $cn appendFromScript {
			MS::$cle {MS::text [lindex [set TColScore($name,$k)] $i]}
		    }
		}
	    }
	}
    }
        
    set fout [open $out w]
    puts $fout ""
    puts $fout ""
    $doc asXML -channel $fout
    close $fout
    
    $doc delete

    return

}

proc CreeLeNEXUS {} {

    

}

proc CreeLeOrd {f} {

    $::db backup $f

    return

}

proc CreeLeRepertoire {Rep} {

    if {$Rep=="" || [file exists $Rep]} { return $Rep }
    set Parent [file dirname $Rep]
    if { ! [file exists $Parent]} { set Parent [CreeLeRepertoire $Parent] }
    if {$Parent=="" ||  ! [file exists $Parent]} { return "" }
    file mkdir $Rep
    if {[file exists $Rep]} { return $Rep }
    return ""

}

proc CreeLeTFADesEnzymesDeRestriction {Fichier} {

    regsub ".txt$" $Fichier ".tfa" FicEnz
    set FicEnz [FichierPourSaveAs $FicEnz]
    if {$FicEnz==""} { return "" }
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Enz ""
	set Seq ""
	scan $Ligne "%s %s" Enz Seq
	if {$Enz=="" || $Seq==""} { continue }
	lappend LesEnz ">$Enz .."
	lappend LesEnz "$Seq"
	lappend LesEnz ""
    }
    return [SauveLesLignes $LesEnz dans $FicEnz]

}

proc CreeLeTFAPourGrille {} {


    set sortie {}
    foreach e [ListeDesPABs] {
	Espionne "$e"
	set file [file join "[RepertoireDuGenome]" prottfa $e]
	set Ll [LesLignesDuFichier $file]
	set sortie [concat $sortie $Ll]
    }

    set foo [open "grille.tfa" w]
    puts $foo [join $sortie "\n"]
    close $foo

    exit

}

proc CreeLeTFAsDuMSF {FichierMSF {AvecGap ""} {SansVide ""}} {


    if {$AvecGap==""} { set AvecGap "AvecGap" }
    if {$SansVide==""} { set SansVide 0 } else { set SansVide 1 }

    set n [DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]

    if {$n<=0} { return {} }
    foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
Espionne $NomDeSequence
	set Seq [set Sequences($NomDeSequence)]
	if {$AvecGap=="AvecGap"} {
	    regsub -all {\.} $Seq "-" Seq
	} else {
	    regsub -all {[\.\-]} $Seq "" Seq
	}
	if {$SansVide && $Seq==""} { continue }
	lappend LesTFAs [SequenceFormatTFA $Seq "$NomDeSequence" "protbrut"]
    }
    return [join $LesTFAs "\n"]

}

proc CreeLeTasTamis {{Tam ""}} {

    global TasTamis

    Wup "Creates the array TasTamis(Nom) for a Tamis Tam which can be choosen"

    if {$Tam==""} {
	set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"]
    }
    if {[info exists TasTamis]} { unset TasTamis }
    foreach Nom [Tamis $Tam] {
	set TasTamis($Nom) 1
    }
    set TasTamis(FromTamis) $Tam
    return $Tam

}

proc CreeLeTfa {{FilOut ""} {nmgrp ""}} {

    lassign [SequencesASauver] LNoms LSeqs
    if {$LNoms == {}} {return}

    EcritLeTfa $FilOut $LNoms $LSeqs

    return

}

proc CreeLeTfaDesZones {{FilOut ""} {nmgrp ""}} {

    global ZoneClusterisation

    set LVide [AlignementDesSelections $ZoneClusterisation SAli]

    foreach {n s} $SAli {
	lappend LesNoms $n
	lappend LesSequences $s
    }

    if {! [llength $LesNoms]} {
	set ok 0
    } else {
	EcritLeTfa $FilOut $LesNoms $LesSequences
	set ok 1
    }

    return [list $ok $LVide]

}

proc CreeLeXml {{filout ""}} {

    global OrdEtcDir tcl_platform DocMacsim NoeudMacsim IdXml

    if {$filout eq ""} {set filout [DemandeEtSauveFichier xml 1]}
    if {$filout eq ""} {return}

    lassign [SequencesASauver] LNoms LSeqs
    if {$LNoms == {} || $LSeqs == {}} {return}

    CreeLeMacsim $filout $LNoms $LSeqs

    return

}

proc CreeLes2GrosTfaVertebrateUniprot {} {

    foreach File [glob -nocomplain "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/uniprot_sprot_*.tfa"] {
	Espionne "$File"
	foreach Ligne [LesLignesDuFichier $File] {
	    lappend LesLignesSprot $Ligne
	}
    }
    SauveLesLignes $LesLignesSprot dans "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Sw_Vertebrata"

    foreach File [glob -nocomplain "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/uniprot_trembl_*.tfa"] {
	Espionne "$File"
	foreach Ligne [LesLignesDuFichier $File] {
	    lappend LesLignesTrembl $Ligne
	}
    }
    SauveLesLignes $LesLignesTrembl dans "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Tr_Vertebrata"


}

proc CreeLesABC {} {

    global NombreDeGroupes LongueurTotale ListeDesConsensusDuGroupe LNDG

    set NombreDeGroupes [llength $LNDG]
    if {$NombreDeGroupes == 1} {return}

    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    set Consensus $ConsensusGlobalTous

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CG [string index $ConsensusGlobalTous $i]
	if {$CG eq "#"} {
	    foreach NomDeGroupe [lrange $LNDG 1 end] {
		set Consi [string toupper [string index [set ListeDesConsensusDuGroupe($NomDeGroupe)] $i]]
		if {[regexp {[A-Y]} $Consi]} {
		    set T($Consi) $Consi
		}
	    }

	    set CarEgaux [llength [array name T]]

	    if {$CarEgaux == [expr {$NombreDeGroupes - 1}]} {
		set CG 6
	    } else {
		set CG "#"
	    }

	    if {! [info exists T]} {set T(toto) A}
	    catch [unset T]
	}
	set Consensus [string range $Consensus 0 [expr {$i - 1}]]$CG[string range $Consensus [expr {$i + 1}] end]
    }

    set ListeDesConsensusDuGroupe($PremierGroupe) $Consensus

    return

}

proc CreeLesBanquesBlastDesTFAsPourTous {{RepTFAs ""} {RepBanques ""} {FormatProt ""}} {

    if {$RepBanques==""} { set RepBanques "banquesdescopains" }
    if {$RepTFAs==""} { set RepTFAs "tfasdescopains" }

    file mkdir $RepBanques

    set LesBanques {}
    foreach Nom [ListeDesPABs] {
	set FicTFAs [GscopeFile $Nom $RepTFAs]
	if {[FileAbsent $FicTFAs]} { continue }
	lappend LesBanques [CreeUneBanqueBlastDuTFAs $FicTFAs $RepBanques $FormatProt]
    }
    return $LesBanques

}

proc CreeLesBornesDuBlastN {Fichier {BanqueBlast ""}} {


    set NS 0
    set NQ 0
    foreach Homo [LesHomologiesDuBlastN $Fichier "" $BanqueBlast] {
	set lHomo [split $Homo "\t"]
	set i -1
	set Nom        [lindex $lHomo [incr i]]
	set nCops      [lindex $lHomo [incr i]]
	set nCopsSeq   [lindex $lHomo [incr i]]
	set BanqueId   [lindex $lHomo [incr i]]
	set OrgaHomo   [lindex $lHomo [incr i]]
	set Identities [lindex $lHomo [incr i]]
	set Expect     [lindex $lHomo [incr i]]
	set DebutQuery [lindex $lHomo [incr i]]
	set FinQuery   [lindex $lHomo [incr i]]
	set DebutSbjct [lindex $lHomo [incr i]]
	set FinSbjct   [lindex $lHomo [incr i]]
	set SeqSbjct   [lindex $lHomo [incr i]]
	
	set LongSbjct [expr abs($FinSbjct-$DebutSbjct)+1]

	if {$LongSbjct<1000} { continue }

	regsub "/" $Identities " " IsurT

	scan $IsurT "%d %d" I T

	set PI [expr round(100.*$I/$T)]
	if {$PI < 60.} { continue }
	

	if {$DebutSbjct<=$FinSbjct} {
	    set DS $DebutSbjct
	    set FS $FinSbjct
	    set OS "F"
	} else {
	    set DS $FinSbjct
	    set FS $DebutSbjct
	    set OS "R"
	}
	if {$DebutQuery<=$FinQuery} {
	    set DQ $DebutQuery
	    set FQ $FinQuery
	    set OQ "F"
	} else {
	    set DQ $FinQuery
	    set FQ $DebutQuery
	    set OQ "R"
	}

	incr NS
	set MaZone "MaZone[format "%4.4d" $NS]"
	incr NQ
	set TaZone "TaZone[format "%4.4d" $NQ]"

	lappend MesBornes "$MaZone $DS $FS $OS $PI $TaZone" 
	lappend TesBornes "$TaZone $DQ $FQ $OQ $PI $MaZone" 
    }
    Espionne [SauveLesLignes $MesBornes dans "$Fichier.mesbornes"]
    Espionne [SauveLesLignes $TesBornes dans "$Fichier.tesbornes"] 

}

proc CreeLesCDNAsDeRegine {{Fichier ""} {Repertoire ""}} {

    global RepertoireDuGenome

    if {$Fichier==""} {
	FaireLire "Please browse for a file with 'clone length seq'"
	set Fichier [ButineArborescence All "$RepertoireDuGenome"]
	if {$Fichier==""} { return "" }
    }
    return $Fichier
    if {$Repertoire==""} {
	set Repertoire "$RepertoireDuGenome/cdna"
    }

    if { ! [file exists $Repertoire]} { File mkdir $Repertoire }

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Clone ""
	set Long -1
	set Seq ""
	ScanLaListe [split $Ligne "\t"] Clone Long Seq
	regsub -all -nocase {[^a-z0-9_]} $Clone "" Clone
	if {$Seq=="NA" || [regexp "non ana" $Seq]} { set Seq "" }
	Espionne "$Clone [string range $Seq 0 20] $Long [string length $Seq]"
	if {[string length $Seq]==0} { continue }
	set NomFichier "R$Clone.tfa"
	set Entete "R $Clone"
	set TFA [SequenceFormatTFA $Seq $Entete "nucbrut"]
	Sauve $TFA dans "$Repertoire/$NomFichier"
    }
    exit

}

proc CreeLesCoBlastn {Nom} {

    global RepertoireDuGenome

    set FichierBlast "$RepertoireDuGenome/blastp/$Nom"

    if { ! [file exists $FichierBlast]} { return {} }

    if { ! [file exists "$RepertoireDuGenome/banques/$Nom"]} {
	set PartieNoms [CreeUneBanqueBlastDuPAB $Nom]
    } else {
	set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
    }
    set LesQuerys [split $PartieNoms "\n"]
    if {$LesQuerys == "" } { return {} }

    set CommandeBlast "eval exec blastall  -p blastn  -i \$FichierTFA  -o \$FichierBlast  -d \$RepertoireDuGenome/banques/$Nom  -v 500  -K 0  -b 500  -e 10.0  -F T "

    set CommandeBlast [Entre $CommandeBlast]
    if {$CommandeBlast==""} { return "" }

    set Repertoire "$RepertoireDuGenome/coblastn/$Nom"
    if { ! [file isdirectory "$Repertoire"]} {
	File mkdir $Repertoire
    }

    set TestExistence 1
    set GardeTout 0
    foreach Ligne $LesQuerys {
	set Query [AccessDUneLigneBlast $Ligne]

	set FichierTFA  [Sauve [SequenceFormatTFA [SequenceDesBanques $Query]] dans "tmp_coblastn.tfa"]
	set FichierBlast "$Repertoire/$Query"

	if { ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA n'existe pas."
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "Some blast files allready exists.\nDo I keep them ?"]} {
		set TestExistence 0
	    } else {
		if {[OuiOuNon "Do I keep all ?"]} { set GardeTout 1 }
		if {$GardeTout || [OuiOuNon "$FichierBlast still exists.\nDo I keep it ?"]} { continue }
	    }
	}

	eval $CommandeBlast

	Espionne $FichierBlast
	
    }    

}

proc CreeLesCoClustalw {Nom} {

    global RepertoireDuGenome
    global Commandes

    set Repertoire "$RepertoireDuGenome/coclustalw/$Nom"
    if { ! [file isdirectory "$Repertoire"]} {
	File mkdir $Repertoire
    }

    foreach FichierCoBlastn [glob "$RepertoireDuGenome/coblastn/$Nom/*"] {
	set Copain [file tail $FichierCoBlastn]
	set Destination "$Repertoire/$Copain"
	if {[file exists $Destination]} { continue }
	set LesCopains {}
	DecortiqueBlast $FichierCoBlastn 1.0e-80 25 Query lBanqueId lAccess lDE lProfil lPN
	Espionne [join $lAccess "\n"]
	if {[llength $lAccess] < 2} { continue }
	set LesTFAsConcatenes {}
	foreach Access $lAccess {
	    set FichierCopain "$RepertoireDuGenome/copains/$Nom/$Access"
	    if { ! [file exists $FichierCopain]} {
		Warne "$Access n'est pas copain de $Copain"
		continue
	    }
	    set TFA [SequenceFormatTFA [ContenuDuFichier $FichierCopain] $Access]
	    lappend LesTFAsConcatenes $TFA
	}
	if {[llength $LesTFAsConcatenes] < 2} { continue }

	set Tmp "tmp.[pid][NomDe ""]"

	set In "$Tmp.inp"
	Sauve [join $LesTFAsConcatenes "\n"] dans $In

 	set Out $Tmp.out
	set Log $Tmp.log

	Warne "Clustalw sur $Nom $Access lance en interactif ... un peu de patience. Merci."
	eval exec "[set Commandes(dbclustal)] $In $Out $Log"
	Warne "                                                              ... j'ai fini."

#	File delete -force $In
#	File delete -force $Out
#	File delete -force $Log

	set MSF "$Out.msf"

	Espionne "$MSF en $Destination"
	if { ! [file exists $MSF]} { Warne "ai perdu $MSF" ; continue }
	File copy $MSF $Destination
    }

}

proc CreeLesConservesDuGroupe {NomDeGroupe} {

    global ListeDesConsensusDuGroupe ListeDesPiliersDuGroupe ListeDesAcidesAmines SDG

    set ConsensusGlobalDuGroupe [set ListeDesConsensusDuGroupe($NomDeGroupe)]
    set NouveauConsensusDuGroupe ""
    set LesPiliers [set ListeDesPiliersDuGroupe($NomDeGroupe)]
    set i 0
    foreach Pilier $LesPiliers {
	set Seuil [CalculeLesSeuils $Pilier $NomDeGroupe]

	foreach aa $ListeDesAcidesAmines {
	    set YaConsSeuil [CalculePoidsDuPilier2 $Pilier $aa $NomDeGroupe $Seuil]

	    if { $YaConsSeuil} {break}
	}

	set ConsensusAvant [string index $ConsensusGlobalDuGroupe $i]
	if {$YaConsSeuil && $ConsensusAvant eq "#"} {
	    set Consensus $aa
	    append NouveauConsensusDuGroupe [string tolower $Consensus]
	} else {
	    set ConsensusAvant [string index $ConsensusGlobalDuGroupe $i]
	    append NouveauConsensusDuGroupe $ConsensusAvant
	}
	incr i
    }

    set ListeDesConsensusDuGroupe($NomDeGroupe) $NouveauConsensusDuGroupe

    return

}

proc CreeLesConservesGlobaux {} {

    global LongueurTotale LNDG ListeDesPiliersDuGroupe ListeDesConsensusDuGroupe

    if {[llength $LNDG] == 1} {
	return
	set PremierGroupe [lindex $LNDG 0]
	set ListeDesConsensusDuGroupe([lindex $LNDG 0]) [set ListeDesConsensusDuGroupe($PremierGroupe)]
	return
    }

    set NouveauConsensusDuGroupe ""
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe([lindex $LNDG 0])]
    set ConsensusGlobalPremierGroupe [set ListeDesConsensusDuGroupe([lindex $LNDG 1])]

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set ConsensusAvant [string tolower [string index $ConsensusGlobalPremierGroupe $i]]

	set ConsEgaux 0
	if {[string index $ConsensusGlobalTous $i] eq "#"} {
	    foreach NomDeGroupe [lrange $LNDG 2 end] {
		set ConsensusGlobalDuGroupe [set ListeDesConsensusDuGroupe($NomDeGroupe)]
		set Consensus [string tolower [string index $ConsensusGlobalDuGroupe $i]]
		set ConsEgaux [expr {![string compare $ConsensusAvant $Consensus]}]
		if {! $ConsEgaux} {break}
	    }
	}
	if {$ConsEgaux} {
	    append NouveauConsensusDuGroupe $Consensus
	} else {
	    append NouveauConsensusDuGroupe [string index $ConsensusGlobalTous $i]
	}
    }
    set ListeDesConsensusDuGroupe([lindex $LNDG 0]) $NouveauConsensusDuGroupe

    return

}

proc CreeLesCopains {Nom} {

    global RepertoireDuGenome

    set Destination "$RepertoireDuGenome/copains/$Nom"
    if { ! [file isdirectory $Destination]} { File mkdir $Destination }

    set LesCopains {}
    if {[file exists "$RepertoireDuGenome/apns/$Nom"]} {
	foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/apns/$Nom"] {
	    scan $Ligne "%s %s" BanqueId Access
	    lappend LesCopains $Access
	}
    } else {
	set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
	if { ! [file exists $FichierBlast]} { return {} }
	set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
	set LesHits [split $PartieNoms "\n"]
	if {$LesHits == "" } { return {} }

	foreach Ligne $LesHits {
	    set Access [AccessDUneLigneBlast $Ligne]
	    lappend LesCopains $Access
	}
    }
    if {$LesCopains == {} } { return {} }

    foreach Copain $LesCopains {
	if {[file exists "$Destination/$Copain"]} { continue }
	if {[file exists "$Destination/[string toupper $Copain]"]} { continue }
	if {[file exists "$Destination/[string tolower $Copain]"]} { continue }
	Espionne [Sauve [Fetche $Copain] dans "$Destination/$Copain"]
    }

}

proc CreeLesDescriptifsAvecLeBlast {FichierBlast {PourQui ""} {SeuilExpect ""} {MaxListe ""}} {

    if {$SeuilExpect==""} { set SeuilExpect "SansSeuilExpect" }
    DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
    return [CreeLesDescriptifsAvecLesAccess $lAccess $PourQui $lBanqueId]

}

proc CreeLesDescriptifsAvecLeBlastPourTous {{Rep ""} {Keep ""} {SeuilExpect ""} {MaxListe ""}} {


    TaxClass 9606 ;#rR pour le charger !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    if {$Keep==""} { set Keep "Keep" }
    if {$Keep=="Keep"} { set Keep 1 } else { set Keep 0 }

    if { $Rep=="" }            { set Rep "[RepertoireDuGenome]/blastp" }
    if { ! [file exists $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    if { ! [file exists $Rep]} {
	FaireLire "Sorry, directory $Rep not found"
	return ""
    }

    set Dest "[RepertoireDuGenome]/descriptifs"
    if { ! [file exists $Dest]} { file mkdir $Dest }

    foreach Nom [ListeDesPABs] {
	set FichierDescr "$Dest/$Nom"
	if { $Keep && [file exists $FichierDescr]} { continue }
	set FichierBlast "$Rep/$Nom"
	if { ! [file exists $FichierBlast]} { continue }
	if {[PasTouche $Nom]} {continue} 
	set LeDescr [CreeLesDescriptifsAvecLeBlast $FichierBlast $Nom]
	FinPasTouche $Nom
    }

}

proc CreeLesDescriptifsAvecLeMSF {FichierMSF {PourQui ""}} {

    DecortiqueUnMSF $FichierMSF LesAccess
    return [CreeLesDescriptifsAvecLesAccess $LesAccess $PourQui]

}

proc CreeLesDescriptifsAvecLeMSFPourTous {{Rep ""}} {

    global RepertoireDuGenome

    if { $Rep=="" }            { set Rep "$RepertoireDuGenome/msf" }
    if { ! [file exists $Rep]} { set Rep "$RepertoireDuGenome/$Rep" }
    if { ! [file exists $Rep]} {
	FaireLire "Sorry, directory $Rep not found"
	return ""
    }

    foreach Nom [ListeDesPABs] {
	set FichierMSF "$Rep/$Nom"
	if { ! [file exists $FichierMSF]} { continue }
	CreeLesDescriptifsAvecLeMSF $FichierMSF $Nom
    }

}

proc CreeLesDescriptifsAvecLeProfileSearch {FichierPFS {PourQui ""}} {


    if {$PourQui==""} { set PourQui "list" }

    set OnAttend 1
    set lBanqueId {}
    set lAccess {}
    foreach Ligne [LesLignesDuFichier $FichierPFS] {
	if {$OnAttend} {
	    if { ! [regexp {Sequence  +Strd +ZScore   +Orig +Length} $Ligne]} { continue }
	    set OnAttend 0
	    continue 
	}
	scan $Ligne "%s %s %s %s %s %s %s" BId Strand ZScore Orig Length PEx Access 
	Espionne "$BId $Access"
	lappend lBanqueId $BId
	lappend lAccess $Access
    }
    return [CreeLesDescriptifsAvecLesAccess $lAccess $PourQui $lBanqueId]

}

proc CreeLesDescriptifsAvecLesAccess {lAccess {PourQui ""} {lBanqueId ""}} {

    global PABCourant
    set PABCourant $PourQui

    Wup "Attention if lBanqueId exists it's better. But we use Access as reference" 

    if {$lBanqueId=={}} { 
	set lBanqueId $lAccess
    }
    

    Wup "PourQui can be PABxxx or window_ or itself"
    Wup "PourQui can also be file_NAMEOFTHEFILETOCREATE"

    if {[regexp "^window_?" $PourQui]} {
	set PourWindow 1
	set LaListe {}
	set PourQui "itself_"
    }
    if {[regexp "^list_?" $PourQui]} {
	set PourListe 1
	set LaListe {}
	set PourQui "itself_"
    }
    if {[regexp "^append_?" $PourQui]} {
	set PourAppend 1
	set FichDesc [StringApres "_" dans $PourQui]
    }

    PrepareLesSequencesDesBanques $lBanqueId $lAccess
    foreach BanqueId $lBanqueId Access $lAccess {
	Espionne "$BanqueId $Access"
	set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
	if {$LesLignesEMBL=={}} { continue }
	DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	regsub -all {\:} $DE "_" DE
	set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
	set Retour [StockeLeDescriptif $AccessOK $Descriptif $PourQui]
	if {[info exists PourAppend]} { AppendAuFichier $FichDesc $Descriptif }
	if {$PourQui=="itself_"} { lappend LaListe $Retour }
    }
    if {[info exists PourWindow]} {
	return [AfficheVariable [join $LaListe "\n"] "GrandeLargeur"]
    }
    if {[info exists PourListe]} {
	return $LaListe
    }
    unset PABCourant

}

proc CreeLesDescriptifsPourTous {{Liste ""}} {

    #rR 2015/11/08 c'est assez confus ... jusqu'à 2015/11/08 on faisait  AvecLesCandidatsPouClustalW ...
    #rR  je pense les avec les blast c'est mieux ... 
    return [CreeLesDescriptifsAvecLeBlastPourTous]
#    return [CreeLesDescriptifs_AvecLesCandidatsPouClustalW_PourTous $Liste]

}

proc CreeLesDescriptifs_AvecLesCandidatsPouClustalW_PourTous {{Liste ""}} {

    global LesLignesEMBLEnMemoire
    global AccessOKEnMemoire

    if {$Liste==""} { set Liste [ListeDesPABs] }

    foreach Nom $Liste {
	set FichierDescriptif [GscopeFile $Nom "descriptifs"]
	if {[file exists $FichierDescriptif} { continue }
	if {[PasTouche $Nom]} { continue }
	Espionne "Creation du descriptif AvecLesCandidatsPouClustalW pour $Nom"
	if {[info exists LesLignesEMBLEnMemoire]} { unset LesLignesEMBLEnMemoire }
	if {[info exists AccessOKEnMemoire]} { unset AccessOKEnMemoire }
	LesCandidatsPourClustalW $Nom 
	FinPasTouche $Nom
    }

}

proc CreeLesFamillesDesSelectionnes {{LaSelection ""} {Ask ""}} {


    Wup "A partir du Board on selectionne des PABs, ou si rien n'est choisi LaListeDesPABs"
    Wup "Avec CreeListeCandidatsPour on creer les premiers candidats"
    Wup "On garde dans stone_NomFam la liste des premiers candidats"
    Wup "A partir des premiers on fait LaFamilleElargie, sauve dans /famille/nom.fam"
    Wup "si Ask vide on repond sinon on ne repond pas, LaTotale pour la ListeDesPABs"
   
    global RepertoireDuGenome
    global NotreOS
    
    set RepXHDA    "$RepertoireDuGenome/xhda"
    set RepFamille "$RepertoireDuGenome/xhda/famille"
    set RepStone   "$RepFamille/stone"
    set OrgaChoisi [Glossaire $NotreOS Complet]
    set UseExisting 1

    if {! [File exists $RepXHDA]} { File mkdir $RepXHDA }

    if {$Ask==""} { set Ask 1 } else { set Ask 0 }

    if {$LaSelection==""} {
	set LaSelection [LesNomsPiques]
    }

    if {$LaSelection=={} || $LaSelection=="LaTotale"} {
	if { $Ask &&  ! [OuiOuNon "Do I use all PABs ? " 0]} { return "" }
	set LaSelection [ListeDesPABs]
    }
    
    foreach PAB $LaSelection {
	if {[OnTraiteUneCollection]} {
	    regsub -all "/" [NomDeScene $PAB] "_" Famille 
	} else {
	    set Famille $PAB
	}
	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	lappend LesPABsDeLaFamille($Famille) $PAB
    }

    set LesChoix {}
    foreach Famille $LesFamilles {
	foreach PAB [set LesPABsDeLaFamille($Famille)] {
	    lappend LesChoix "$PAB $Famille"
	}
    }

    set Choix [join $LesChoix "\n"]
    if { $Ask } { set Choix [EntreTexte $Choix] }
    set Choix [string trim $Choix]
    if {$Choix==""} { return "" }
   
    if {[info exists DejaVu]} {
	unset DejaVu
	unset LesFamilles
	unset LesPABsDeLaFamille
    }

    set LesFamilles {}
    foreach Ligne [split $Choix "\n"] {
	scan $Ligne "%s %s" PAB Famille
	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	lappend LesPABsDeLaFamille($Famille) $PAB
    }

    if {! [file exists "$RepFamille"]} { File mkdir $RepFamille }
    if {! [file exists "$RepStone"]}   { File mkdir $RepStone }

    foreach Famille $LesFamilles {
	global NomDuFichierPierre ; set NomDuFichierPierre "$RepStone/stone_$Famille"
	if {$UseExisting && [file exists $NomDuFichierPierre]} {
	    Espionne "stone_$Famille already exists, I use it."
	    Degrave LesCandidatsDeLaFamille
	} else {
	    set LesCandidatsDeLaFamille {}
	    foreach PAB [set LesPABsDeLaFamille($Famille)] {
		set ListePremiersCandidats [CreeListeCandidatsPour $PAB $OrgaChoisi $Famille]
		LConcat LesCandidatsDeLaFamille $ListePremiersCandidats
	    }
	    set LesCandidatsDeLaFamille [lsort -unique $LesCandidatsDeLaFamille]	    
	    Grave LesCandidatsDeLaFamille
	    ClosPierre
	}
	set CandidatsDUneFamille($Famille) $LesCandidatsDeLaFamille
    }
 
    foreach Famille $LesFamilles {
	set LesCandidatsDeLaFamille [set CandidatsDUneFamille($Famille)]
	if {! [file exists $RepFamille]} {File mkdir $RepFamille}
	set FichierFamille "$RepFamille/$Famille.fam"

	if {$UseExisting && [file exists $FichierFamille]} {
	    Espionne "$Famille.fam already exists I keep it."
	    continue
	}
	SauveLesLignes [LaFamilleElargie $LesCandidatsDeLaFamille $Famille] dans $FichierFamille
    }
    unset CandidatsDUneFamille
    Espionne "Fin"

}

proc CreeLesFamillesDesSelectionnesPourTous {} {

    
    return [CreeLesFamillesDesSelectionnes "LaTotale" "NoAsk"]

}

proc CreeLesFichiersApns {{RepertoireDesBlasts blastp} {RepertoireDesAPns ""}} {

    global RepertoireDuGenome

    if { ! [file exists "$RepertoireDuGenome/$RepertoireDesBlasts"] || $RepertoireDesAPns=="" } {
	switch -regexp $RepertoireDesBlasts {
	    "blastp" {
		set DirDesBlasts "$RepertoireDuGenome/blastp"
		set DirDesApns "$RepertoireDuGenome/apns"
	    }
	    "blastn" {
		set DirDesBlasts "$RepertoireDuGenome/blastn"
		set DirDesApns "$RepertoireDuGenome/apns"
	    }
	    "trouxs" {
		set DirDesBlasts "$RepertoireDuGenome/trousblastx"
		set DirDesApns "$RepertoireDuGenome/trouxsapns"
	    }
	    "trouns" {
		set DirDesBlasts "$RepertoireDuGenome/troustblastxgenembl"
		set DirDesApns "$RepertoireDuGenome/trounsapns"
	    }
	    "trous"  {
		set DirDesBlasts "$RepertoireDuGenome/trousblastp"
		set DirDesApns "$RepertoireDuGenome/trousapns"
	    }
	    default  {
		set DirDesBlasts "$RepertoireDesBlasts"
		if {[file isdirectory "$RepertoireDesAPns"]} {
		    set DirDesApns   "$RepertoireDesAPns"
		} elseif {[file isdirectory "$RepertoireDuGenome/$RepertoireDesAPns"]} {
		    set DirDesApns   "$RepertoireDuGenome/$RepertoireDesAPns"
		} elseif {[OuiOuNon "Should I create $RepertoireDuGenome/$RepertoireDesAPns"]} {
		    set DirDesApns   "$RepertoireDuGenome/$RepertoireDesAPns"
		} else {
		    FaireLire "Please create the correct directory $RepertoireDesAPns"
		    return "RepertoireDesAPns inexistant"
		}
	    }
	}
    } else {
	if {[file exists "$RepertoireDesBlasts"] && [file exists "$RepertoireDesAPns"]} {
	    set DirDesBlasts "$RepertoireDesBlasts"
	    set DirDesApns   "$RepertoireDesAPns"
	} else {
	    FaireLire "Please create the correct directory $RepertoireDesAPns"
	    return "RepertoireDesAPns inexistant"
	}
    }

    File mkdir "$DirDesApns"

    set Conserve 0
    if {[llength [glob -nocomplain "$DirDesApns/*"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $DirDesApns ?"]
    }

    foreach FichierBlast [lsort [glob -nocomplain "$DirDesBlasts/*"]] {

	set Nom [file tail $FichierBlast]

	if { ! [YaPABouTROUouTRNAouARNenDebutDe $Nom] || [regexp ".encours" $Nom]} { continue }

	set FichierACreer "$DirDesApns/$Nom"

	if {$Conserve && [file exists $FichierACreer]} { continue }

	set lBanqueId {}
	DecortiqueBlast $FichierBlast  "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
	set ListeAPN {}
	
	if {[file tail $RepertoireDesBlasts]=="blastp"} {
	    foreach AGEs [LesOrgasDesAccess $lAccess] {
		scan $AGEs "%s" A
		regsub "$A " $AGEs "" GEs
		regsub {(^|\:)Inconnu inconnu($|\:)} $GEs "" GEs
		if {$GEs==""} { continue }
		set OrgaTrouve([string toupper $A]) $GEs
	    }
	}
	foreach BanqueId $lBanqueId Access $lAccess PN $lPN {
	    if {[file tail $RepertoireDesBlasts]=="blastn"} {		
		set Ligne "$BanqueId $BanqueId $PN"
	    } else {
		set Ligne "$BanqueId $Access $PN"
		if {[info exists OrgaTrouve([string toupper $Access])]} {
		    append Ligne " [set OrgaTrouve([string toupper $Access])]"
		}
	    }
	    lappend ListeAPN $Ligne
	}
	Espionne [SauveLesLignes $ListeAPN dans $FichierACreer]
    }

}

proc CreeLesFichiersCdstfaMusMusculus {} {

    set RepCdsMouse "[RepertoireDuGenome]/mrnatfa_cds_Mus_musculus"
    if {![file exists $RepCdsMouse]} {file mkdir $RepCdsMouse}
    foreach PAB [ListeDesPABs] {
	set NouveauTfa ""
	set AccessRNA [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Mus musculus" "mRNA" Access]
	if {$AccessRNA==""} {continue}
	set LesCoord [LesCoordonneesDuCDSDumRNA $AccessRNA]
	if {$LesCoord==""} {continue}
	set FichiermRNAtfa "[RepertoireDuGenome]/mrnatfa_Mus_musculus/$PAB"
	append NouveauTfa "[EnteteDuFichierTFA $FichiermRNAtfa]\n"
	set SequenceCDS [ExtraitPartieDuTfa $FichiermRNAtfa [lindex $LesCoord 0] [lindex $LesCoord 1]]
	append NouveauTfa $SequenceCDS
	Sauve $NouveauTfa dans "$RepCdsMouse/$PAB"
    }

}

proc CreeLesFichiersDataDD {FichierSortie1 FichierSortie2} {

    ### CALCUL DU PROFIL MOYEN pour chaque cluster de jumeaux (fiches/jumeaux)###
    ##########################
    #FichierSortie1 (TotalData) Tous
    #FichierSortie2 (DataUniques) JR
    #FichierPbsBand Pbs_band
    #FichierPbsExpr Pbs_expr

    #Attention au fichier avec les jumeaux.

    #la bande pour un couple (user, codeclone)
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] {
	## (rq: pas de user R dans ce fichier)
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set U [lindex $LesChamps 0]
	### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ######
	set CodeClone [string trim [lindex $LesChamps 1]]
	if {$U=="F"} {
	    set CodeClone [string toupper $CodeClone]
	}
	set B [lindex $LesChamps 2]
	set Band($U,$CodeClone) $B
    }
    #Espionne "[array names Band]"
    #Profil
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] {
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 0]
	set Prof [lindex $LesChamps 1]
	if {$Prof=="+"} {set P($DD) "T"}
	if {$Prof=="-"} {set P($DD) "N"}
	if {$Prof=="0"} {set P($DD) "C"}
    }
    #Profil_consensus
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/ResolutionTotaleDesConflits_pourGscope.txt"] {
	if {[regexp "gscopecode" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set DD [lindex $LesChamps 1]
	set ProfCons [lindex $LesChamps 5]
	set Pc($DD) $ProfCons
    }
    #Intensites
    #############################################
    #           Attention!                      #
    # les numeros de bandes ne sont pas uniques #
    # Exemple: J PM et CW ont fait une bande 48 #
    #############################################
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Bands_intensiteDD.txt"] {
	if {[regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set User [lindex $LesChamps 0]
	set B [lindex $LesChamps 1]
	regsub -all "\'" $B "" B
	set I_TE($User,$B) [lindex $LesChamps 3]
	set I_NE($User,$B) [lindex $LesChamps 4]
	set I_TS($User,$B) [lindex $LesChamps 5]
	set I_NS($User,$B) [lindex $LesChamps 6]
	set I_TU($User,$B) [lindex $LesChamps 7]
	set I_NU($User,$B) [lindex $LesChamps 8]
    }

    set n 0
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/jumeaux"] {
	Espionne $Ligne
	set LesJumeaux [split $Ligne " "]
	set NbJumeaux [llength $LesJumeaux]
	#Espionne "nb jum : $NbJumeaux"
	set Pena 0; set PenaE 0 ; set PenaS 0 ;set PenaU 0 
	incr n
	#Espionne "nb jum : $LesJumeaux"
	set SommeIte 0
	set SommeIne 0
	set SommeIts 0
	set SommeIns 0
	set SommeItu 0
	set SommeInu 0
	set W 0
	foreach DD $LesJumeaux {
	    Espionne $DD
	    #---
	    set JR [JumeauRepresentatif $DD]
	    #---
	    set CC [ExtraitInfo $DD "CodeClone"]
	    set Ow [ExtraitInfo $DD "OwnerOfCDNA"]
	    if {$Ow=="R"} {set Ow "I"}
	    if {$Ow=="F"} {set CC [string toupper $CC]}
	    set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access]
	    set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" mRNA Access]
	    if {$AccBestProtHuman!=""} {
		set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition]
		# Warning Identity pour BestProt Human
		set IdBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Access $AccBestProtHuman Identity]
		#set Identite [expr $IdBestProtHuman * 1.0]
		set Identite $IdBestProtHuman
		if {$Identite<0.6} {set Warning 1} else {set Warning ""}
	    } else {set DefBestProtHuman ""; set Warning ""}
	    if {$AccBestmRNAHuman!=""} {
		set DefBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestmRNAHuman Definition]
	    } else {set DefBestmRNAHuman ""}
	    if {$DD==$JR} {
		set AccProtJR $AccBestProtHuman
		set DefProtJR $DefBestProtHuman
		set AccmRNAJR $AccBestmRNAHuman
		set DefmRNAJR $DefBestmRNAHuman
		set W $Warning
	    }
	    if {[info exists Band($Ow,$CC)]} {
		set Bande $Band($Ow,$CC)
		#Bandes de Fred du type H16B sans profil alors que H16 avec profil et meme bande
		if {$Ow=="F" && [regexp -nocase {[A-Z]+[0-9]+[A-Z]} $Bande]} {
		    regexp -nocase -indices {[A-Z]+[0-9]+} $Bande tmp
		    set NewBande [string range $Bande 0 [lindex $tmp 1]]
		    set Bande $NewBande
		}
		# Donnees manquantes (pour la plupart, clones de Fred)
		if {(![info exists I_TE($Ow,$Bande)] || ([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)=="")) ||  (![info exists I_NE($Ow,$Bande)] ||  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)==""))} {
		    set Ite ""
		    set Ine ""
		    incr PenaE
		}
		if {(![info exists I_TS($Ow,$Bande)] ||  ([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)=="")) ||  (![info exists I_NS($Ow,$Bande)] ||  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)==""))} {
		    set Its ""
		    set Ins ""
		    incr PenaS
		}
		if {(![info exists I_TU($Ow,$Bande)] ||  ([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)==""))||  (![info exists I_NU($Ow,$Bande)] ||  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)==""))} {
		    set Itu ""
		    set Inu ""
		    incr PenaU
		}
		if {([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)!="") &&  ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)!="")} {
		    set Ite $I_TE($Ow,$Bande)
		    set Ine $I_NE($Ow,$Bande)
		}
		if {([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)!="") &&  ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)!="")} {
		    set Its $I_TS($Ow,$Bande)
		    set Ins $I_NS($Ow,$Bande)
		} 
		if {([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)!="") &&  ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)!="")} {
		    set Itu $I_TU($Ow,$Bande)
		    set Inu $I_NU($Ow,$Bande)
		}
		if {$Ite=="" && $Ine=="" && $Its=="" && $Ins=="" && $Itu=="" && $Inu==""} {
		    Espionne "aucune valeur de gel DD pour cette bande: $Bande"
		    incr Pena
		}
		if {$Ite!="" && $Ine!=""} {
		    set SommeIte [expr $SommeIte + $Ite]
		    set SommeIne [expr $SommeIne + $Ine]
		}
		if {$Its!="" && $Ins!=""} {
		    set SommeIts [expr $SommeIts + $Its]
		    set SommeIns [expr $SommeIns + $Ins]
		}
		if {$Itu!="" && $Inu!=""} {
		    set SommeItu [expr $SommeItu + $Itu]
		    set SommeInu [expr $SommeInu + $Inu]
		}
	    } else {
		Espionne "$DD : no band"
		#AppendAuFichier $FichierPbsBand "$DD $CC $Ow"
		set Bande ""; set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu ""
		incr Pena
	    }
	    if {[info exists P($DD)]} {set Profil $P($DD)} else {set Profil ""}
	    if {[info exists Pc($DD)]} {set Pcons $Pc($DD)} else {set Pcons ""}
	    AppendAuFichier $FichierSortie1 "$n\t$DD\t$JR\t$CC\t$Ow\t$Bande\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Profil\t$Pcons\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu"
	    #set Vu($Bande,$Ow) 1
	}
	set Total [expr $NbJumeaux-$Pena]
	if {$Total==0} {
	    #Espionne "total nul pour $Ligne"
	    #AppendAuFichier $FichierSortie2 "$n\t$AccProt\t$DefProt\t$AccRNA\t$DefRNA"
	    if {[info exists Vu]} {unset Vu}
	    continue
	}
	####### E S U distincts ##############
	set TNE [expr $SommeIte-$SommeIne]
	set TNS [expr $SommeIts-$SommeIns]
	set TNU [expr $SommeItu-$SommeInu]
	if {$TNE>0} {set PE "T"} ; if {$TNE<0} {set PE "N"} ;if {$TNE==0} {set PE "0"} 
	if {$TNS>0} {set PS "T"} ; if {$TNS<0} {set PS "N"} ;if {$TNS==0} {set PS "0"} 
	if {$TNU>0} {set PU "T"} ; if {$TNU<0} {set PU "N"} ;if {$TNU==0} {set PU "0"} 
	######## MOYENNES ##################
	
	set TotalE [expr $NbJumeaux-$PenaE]
	set TotalS [expr $NbJumeaux-$PenaS]
	set TotalU [expr $NbJumeaux-$PenaU]
	if {$TotalE==0} {
	    set MoyIne 0
	    set MoyIte 0
	} else {
	    set MoyIne [expr ($SommeIne*1.0/$TotalE*1.0)]
	    set MoyIte [expr ($SommeIte*1.0/$TotalE*1.0)]
	}
	if {$TotalS==0} {
	    set MoyIns 0
	    set MoyIts 0
	} else {
	    set MoyIns [expr ($SommeIns*1.0/$TotalS*1.0)]
	    set MoyIts [expr ($SommeIts*1.0/$TotalS*1.0)]
	}
	if {$TotalU==0} {
	    set MoyInu 0
	    set MoyItu 0
	} else {
	    set MoyInu [expr ($SommeInu*1.0/$TotalU*1.0)]
	    set MoyItu [expr ($SommeItu*1.0/$TotalU*1.0)]
	}
	set SommeDesMoyennesN [format "%.3f" [expr $MoyIne + $MoyIns +$MoyInu]]
	set SommeDesMoyennesT [format "%.3f" [expr $MoyIte + $MoyIts +$MoyItu]]
	set TNmoy [expr ($SommeDesMoyennesT-$SommeDesMoyennesN)]
	#if {$n==159} {Espionne "159 a un tnmoyen de : $TNmoy"; exit}
	if {$TNmoy>0} {set Pmoy "T"}
	if {$TNmoy<0} {set Pmoy "N"}
	if {$TNmoy==0} {set Pmoy "0"}
	AppendAuFichier $FichierSortie2 "$n\t$AccProtJR\t$DefProtJR\t$AccmRNAJR\t$DefmRNAJR\t$W\t$TNE\t$PE\t$TNS\t$PS\t$TNU\t$PU\t$TNmoy\t$Pmoy"
	if {[info exists Vu]} {unset Vu}
    }

}

proc CreeLesFichiersDesShineDalgarnoDesPABs {{Motif ""} {Liste ""} {Rendre ""}} {

    global RepertoireDuGenome
    global ListeDesPABs
    global NotreOC
    global MotifShineDalgarno


    if {$Liste==""} { set Liste [ListeDesPABs] }

    set RendreLeMotif 0
    if {$Motif=="LeMotifMerci"} {
	set RendreLeMotif 1
	set Motif ""
    }

    if {$Motif=="" && [info exists MotifShineDalgarno]} {
	set Motif $MotifShineDalgarno
    }

    if {$Motif==""} {
	if {[regexp -nocase "Archaea" $NotreOC]} {
	    set Motif "GGT"
	}
	if {[regexp -nocase "Bacteria" $NotreOC]} {
	    set Motif "GGA"
	}
	while {$Motif==""} {
	    if {[OuiOuNon "Do you known the main motif (GGT or GGA or ??? ) for the ShineDalgarno sequence ?"]} {
		set Motif [string toupper [Entre]]
		if {[regexp -nocase {[^ATGC]} $Motif]} {
		    FaireLire "$Motif seems to be wrong (use A,T,G, and C)"
		    set Motif ""
		    continue 
		} 
	    } else {
		if {[OuiOuNon "I'll stop this procedure ?"]} { return "" }
	    }
	}
    }

    if { ! [info exists MotifShineDalgarno]} { set MotifShineDalgarno $Motif }

    if {$RendreLeMotif} { return $Motif }

    if { ! [info exists ListeDesPABs]} { ChargeLesPABs }

    set Avant 18
    set TropLoin $Avant
    set TropPres  6

    set LesSansSD {}
    set LesLoinSD {}
    set LesMetsSD {}
    set LesBonsSD {}
    foreach Boite $Liste {
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	if {$Orient == "F"} {
	    set Seq    [BoutADN [expr $Debut-$Avant] [expr $Debut+2]  $Orient]
	    set SeqMet [BoutADN [expr $Debut-$Avant] [expr $Debut+11] $Orient]
	    set iOldMet $Avant
	} else {
	    set Seq    [BoutADN [expr $Fin-2]  [expr $Fin+$Avant]   $Orient]
	    set SeqMet [BoutADN [expr $Fin-11] [expr $Fin+$Avant] $Orient]
	    set iOldMet $Avant
	}
	set lSeq [string length $Seq]
	set iGGT [string last $Motif $Seq]
	set PosGGT [expr $iGGT-$lSeq]
	if {$iGGT < 0} {
	    lappend LesSansSD "$Nom"
	    continue
	} 
	if {[expr $lSeq-$iGGT] > $TropLoin} {
	    lappend LesLoinSD "$Nom [string range $SeqMet $iGGT end]"
	    continue
	}
	while {$iGGT >= 0 && [expr $lSeq-$iGGT] < $TropPres} {
	    set iGGT [string last $Motif [incr iGGT -1]]
	}
	if {$iGGT>=0} {
	    lappend LesBonsSD "$Nom"
	    continue 
	}

	Wup "Beginning again at farest iGGT, we try to find a better start codon"
	set iGGT [string last $Motif $Seq]
	set iNewMet $iOldMet
	for {set i [expr $iOldMet+3]} {$i < [string length $SeqMet]} {incr i 3} {
	    if {[CodonStartPossible [string range $SeqMet $i [expr $i+2]]]} {
		set iNewMet $i
	    }
	}
	set iGGT [string first $Motif $Seq]
	set AfficheSeq [string range $SeqMet $iGGT end]
	if {$iNewMet != $iOldMet} {
	    set    AfficheSeq                 [string range $SeqMet $iGGT             [expr $iOldMet-1]]
	    append AfficheSeq [string tolower [string range $SeqMet $iOldMet          [expr $iOldMet+2]]]
	    append AfficheSeq                 [string range $SeqMet [expr $iOldMet+3] [expr $iNewMet-1]]
	    append AfficheSeq [string tolower [string range $SeqMet [expr $iNewMet]   [expr $iNewMet+2]]]
	    append AfficheSeq                 [string range $SeqMet [expr $iNewMet+3] end              ]
	    lappend LesMetsSD "$Nom $AfficheSeq"
	} else {
	    set    AfficheSeq                 [string range $SeqMet $iGGT             [expr $iOldMet-1]]
	    append AfficheSeq [string tolower [string range $SeqMet $iOldMet          [expr $iOldMet+2]]]
	    append AfficheSeq                 [string range $SeqMet [expr $iOldMet+3] end              ]
	    lappend LesBonsSD "$Nom $AfficheSeq"
	}
    }
    if {$Rendre=="RendreLesListes"} {
	return [list $LesBonsSD $LesSansSD $LesLoinSD $LesMetsSD]
    }
    if {$Rendre=="RendreEtat"} {
	set Pos [expr $]
	if {$LesBonsSD!={}} { return "ok $PosGGT" }
	if {$LesSansSD!={}} { return "no $PosGGT" }
	if {$LesLoinSD!={}} { return "far $PosGGT" }
	if {$LesMetsSD!={}} { return "met $PosGGT" }
	return ""
    }
    Espionne [SauveLesLignes $LesSansSD dans "$RepertoireDuGenome/fiches/sd_sans"]
    Espionne [SauveLesLignes $LesLoinSD dans "$RepertoireDuGenome/fiches/sd_loin"]
    Espionne [SauveLesLignes $LesMetsSD dans "$RepertoireDuGenome/fiches/sd_mets"]
    Espionne [SauveLesLignes $LesBonsSD dans "$RepertoireDuGenome/fiches/sd_bons"]

}

proc CreeLesFichiersExtension5PrimeDeRec2 {Rec2} {


    set Rec2 [file tail $Rec2]
    regsub ".tfa$" $Rec2 "" Rec2

    set Titre  "Fus_$Rec2"
    set Fusion "Fus_$Rec2"
    set FiFuN "[RepertoireDuGenome]/fusion/$Fusion.nuctfa"
    set FiFuP "[RepertoireDuGenome]/fusion/$Fusion.prottfa"

    set Keep 1
    if {$Keep && [FileExists $FiFuP]} { return "$FiFuN $FiFuP" }


    set NucFusion [NucExtension5PrimeDeRec2 $Rec2]
    if {$NucFusion==""} {
	FaireLire "NucExtension5PrimeDeRec2 $Rec2\nis empty."
	return ""
    }

    
    set NucTFA [SequenceFormatTFA $NucFusion "$Titre" "nucbrut"]
    Espionne [Sauve $NucTFA dans $FiFuN]
    set ProtFusion [SeqNucToSeqPro $NucFusion]
    set ProtTFA [SequenceFormatTFA $ProtFusion "$Titre" "protbrut"]
    Espionne [Sauve $ProtTFA dans $FiFuP]
    return "$FiFuN $FiFuP"

}

proc CreeLesFichiersExtension5PrimeDeRec2PourTous {} {

    foreach FichierRec2 [Rec2 LaListeDes Fichiers] {
	set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $FichierRec2]
	if {$FiFuNP!=""} {
	    scan $FiFuNP "%s" FiFuN
	    lappend LesFiFuN $FiFuN
	}
    }
    return $LesFiFuN

}

proc CreeLesFichiersNucTFAetNucEMBLAvecBornesDesTRNAsEtADN {} {

    global RepertoireDuGenome

    if { ! [file exists "$RepertoireDuGenome/nuctfa"]} {
	File mkdir $RepertoireDuGenome/nuctfa
    }
    if { ! [file exists "$RepertoireDuGenome/nucembl"]} {
	File mkdir $RepertoireDuGenome/nucembl
    }

    set GardeLesExistants [OuiOuNon "Do I keep existing files ?"]
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdestrnas"] {
	ExtraireDe $Ligne Nom Debut Fin Orient
	CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL $Nom $Debut $Fin $Orient $GardeLesExistants
    }

}

proc CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL {Nom Debut Fin Orient {GardeLesExistants 1}} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global LongueurADN DerniereBase
    global DuProteome NucOui

    set NotreOS [NotreOS]
    set NotreOC [NotreOC]
    set NotreOX [NotreOX]

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    if { ! [info exists DuProteome]} {
	while {[file exists "$RepertoireDuGenome/proteometfa"]} {
	    if {[OuiOuNon "Do I keep the protein sequences from the proteome ?"]} {
		set DuProteome 1
		break
	    } else {
		if {[OuiOuNon "Do You confirm that I forget the proteome ?"]} {
		    set DuProteome 0
		    break
		}
		if {[OuiOuNon "Do I skip sequence creation ?"]} { return 0 }
		if {[OuiOuNon "Do I exit ?"]} { exit }
	    }
	}
    }

    if { ! [info exists NucOui]} {
	set NucOui [OuiOuNon "Do I create the nuc files ?"]
    }

    set LongN [expr $Fin - $Debut +1]
    set LongP [expr $LongN/3]
    
    if {$NucOui} {
	set SeqNuc [BoutADN $Debut $Fin $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
    }
    set FichierNucTFA   "$RepertoireDuGenome/nuctfa/$Nom"
    set FichierProtTFA  "$RepertoireDuGenome/prottfa/$Nom"
    set FichierNucEMBL  "$RepertoireDuGenome/nucembl/$Nom"
    set FichierProtEMBL "$RepertoireDuGenome/protembl/$Nom"
    
    if { $NucOui && (! $GardeLesExistants || ! [file exists "$FichierNucTFA"])} {    
	set NucTFA ">$Nom"
	append NucTFA "\n[SequenceFormatBrut $SeqNuc]"
	Espionne [Sauve $NucTFA dans "$FichierNucTFA"]
    }

    if { ! [regexp "ARN|TRNA" $Nom] && (! $GardeLesExistants || ! [file exists "$FichierProtTFA"])} {
	if {[info exists DuProteome] && $DuProteome} {
	    regsub -nocase {[a-z_\.]*} $Nom "ORF" Orf
	    set FichierProteome "$RepertoireDuGenome/proteometfa/$Orf"
	    if {[file exists $FichierProteome]} {
		set TFA [ContenuDuFichier $FichierProteome]
		regsub -nocase {>[a-z0-9\._]+ } $TFA ">$Nom " TFA
		Sauve $TFA dans $FichierProtTFA
	    }
	} else {
	    set ProtTFA ">$Nom"
	    append ProtTFA "\n[SequenceFormatBrut $SeqPro]"
	    Espionne [Sauve $ProtTFA dans "$FichierProtTFA"]
	}
    }

    if { $NucOui && (! $GardeLesExistants || ! [file exists "$FichierNucEMBL"])} {    
	set NucEMBL ""
	append NucEMBL "ID   $Nom      PRELIMINARY;       DNA;   $LongN Bps."
	append NucEMBL "\nAC   $Nom"
	append NucEMBL "\nOS   $NotreOS."
	append NucEMBL "\nOC   $NotreOC"
	append NucEMBL "\nOX   $NotreOX"
	append NucEMBL "\nCC   -!- from $Debut to $Fin. Orientation $Orient"
	append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]"
	Espionne [Sauve $NucEMBL dans "$FichierNucEMBL"]
    }

    if { ! [regexp "ARN|TRNA" $Nom] && (! $GardeLesExistants || ! [file exists "$FichierProtEMBL"])} {    
	set ProtEMBL ""
	append ProtEMBL "ID   $Nom      PRELIMINARY;       PRT;   $LongP AA."
	append ProtEMBL "\nAC   $Nom"
	append ProtEMBL "\nOS   $NotreOS."
	append ProtEMBL "\nOC   $NotreOC"
	append ProtEMBL "\nOC   $NotreOX"
	if {[info exists DuProteome] && $DuProteome} {
	    set Head [PremiereLigneDuFichier $FichierProtTFA]
	    regsub -nocase {>[a-z0-9\._]+ } $TFA ">$Nom " DE
	    append ProtEMBl "\nDE   $DE"
	    set SeqBrute [QueLaSequence [ContenuDuFichier $FichierProtTFA]]
	    append ProtEMBl "\nCC   -!- taken frome known proteome"
	    append ProtEMBL "\n[QueSequenceFormatEMBL $SeqBrute AvecSQ]"
	} else {
	    append ProtEMBL "\nCC   -!- from $Debut to $Fin. Orientation $Orient"
	    append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]"
	}
	Espionne [Sauve $ProtEMBL dans "$FichierProtEMBL"]
    }

}

proc CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBLAvecBornesDesPABsEtADN {} {

    global RepertoireDuGenome

    if { ! [OuiOuNon "Do I create the sequences in \n $RepertoireDuGenome/..."]} { return }

    if { ! [file exists "$RepertoireDuGenome/nuctfa"]} {
	File mkdir $RepertoireDuGenome/nuctfa
    }
    if { ! [file exists "$RepertoireDuGenome/prottfa"]} {
	File mkdir $RepertoireDuGenome/prottfa
    }
    if { ! [file exists "$RepertoireDuGenome/nucembl"]} {
	File mkdir $RepertoireDuGenome/nucembl
    }
    if { ! [file exists "$RepertoireDuGenome/protembl"]} {
	File mkdir $RepertoireDuGenome/protembl
    }

    set GardeLesExistants [OuiOuNon "Do I keep existing files ?"]

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {
	ExtraireDe $Ligne Nom Debut Fin Orient
	CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL $Nom $Debut $Fin $Orient $GardeLesExistants
    }

}

proc CreeLesFichiersNucTfa {{Liste ""}} {

    global RepertoireDuGenome
    global ListeDeBoites

    Espionne $Liste

    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    Wup "On peut en faire un seul, a la demande"

    if { $Liste == {}} {
	set ListeATraiter $ListeDeBoites
    } else {
	set ListeATraiter $Liste
    }

    foreach Boite $ListeATraiter {

	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]

	Espionne "$Nom $Debut $Fin $Orient"
	Espionne "$RepertoireDuGenome/nuctfa/$Nom"
	if {[file exists "$RepertoireDuGenome/nuctfa/$Nom"]} { continue }

	CreeLeFichierDansNucTfa $Nom $Debut $Fin $Orient
    }

}

proc CreeLesFichiersPIClustalwEtPSClustalw {{OrgaDeReference ""} {Extension ""}} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOrga
    global PiPsWaitsForTheMSF

    if { ! [info exists PiPsWaitsForTheMSF]} { set PiPsWaitsForTheMSF 0 }

    set PourParalogues [string equal $Extension ".paralogues"] 

    if {$OrgaDeReference==""} {
	set OrgaDeReference $NotreOrga
    }
    if {$Extension==""} {
	set Extension ".$OrgaDeReference"
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    set Source   "$RepertoireDuGenome/msf"
    if {$Extension==".$NotreOrga"} {
	set Source   "$RepertoireDuGenome/msf"
    }
    if {$PourParalogues} {
	set Source   "$RepertoireDuGenome/msfparalogues"
    }
    set DestinPI "$RepertoireDuGenome/fiches/piclustalw$Extension"
    set DestinPS "$RepertoireDuGenome/fiches/psclustalw$Extension"

    if {[file exists $DestinPI]} {
	if {[OuiOuNon "Do I keep the existing file $DestinPI ?"]} {
	    foreach Ligne [LesLignesDuFichier $DestinPI] {
		scan $Ligne "%s" Nom
		set DejaVuPI($Nom) 1
	    }
	} else {
	    File delete $DestinPI
	}
    }
    if {[file exists $DestinPS]} {
	if {[OuiOuNon "Do I keep the existing file $DestinPS ?"]} {
	    foreach Ligne [LesLignesDuFichier $DestinPS] {
		scan $Ligne "%s" Nom
		set DejaVuPS($Nom) 1
	    }
	} else {
	    File delete $DestinPS
	}
    }

    foreach Nom [ListeDesPABs] {
	LeDescriptif PourQuIlSoitCharge $Nom
	set Fichier "$Source/$Nom"

	if { ! [file exists $Fichier] && $PiPsWaitsForTheMSF } { after 120000 }
        if { ! [file exists $Fichier]} { continue }

	if {[regexp "NoSequence" [PremiereLigneDuFichier $Fichier]]} { continue }

	if {[info exists DejaVuPI($Nom)] && [info exists DejaVuPS($Nom)]} { continue }

	set LesAPIPSs [IdentiteEtSimilariteDansMSF $Fichier $OrgaDeReference]
	set LesOPIs {}
	set LesOPSs {}
	set LesAccess {}
	foreach AccessPIPS $LesAPIPSs {
	    scan $AccessPIPS "%s %f %f" Access PI PS
	    if {[YaPABenDebutDe $Access]} {
		set OrgaDuAccess($Access) $NotreOrga
		continue
	    }
	    lappend LesAccess $Access
	}
	foreach AccessOrga [LesOrgasDesAccess $LesAccess Court $Nom] {
	    scan $AccessOrga "%s %s" Access Orga
	    set OrgaDuAccess($Access) $Orga
	}
	foreach AccessPIPS $LesAPIPSs {
	    scan $AccessPIPS "%s %f %f" Access PI PS
	    if {[info exists OrgaDuAccess($Access)]} {
		set Orga [set OrgaDuAccess($Access)]
	    } elseif {[regexp "^PAB|^ABY|^PYAB" $Access]} {
		set Orga "paby"
	    } elseif {[regexp "^PFOK|^PFUR" $Access]} {
		set Orga "pfur"
	    } elseif {[regexp "^PAE:" $Access]} {
		set Orga "pae"
	    } else {
		set Orga [OrgaDuAccess $Access Court]
	    }
	    if {$PourParalogues} {
		if {[YaPABenDebutDe $Access]} {
		    set PAB $Access
		} else {
		    set PAB [Narcisse $Access]
		}
		lappend LesOPIs "$PAB $PI"
		lappend LesOPSs "$PAB $PS"
	    } else {
		foreach O [SplitOrgas $Orga] {
		    lappend LesOPIs "$O $PI"
		    lappend LesOPSs "$O $PS"
		}
	    }
	}
	set LesOPIsTries [lsort -decreasing -command CompareLesFloats $LesOPIs]
	set LesOPSsTries [lsort -decreasing -command CompareLesFloats $LesOPSs]
	set TextePI "$Nom [join $LesOPIsTries " "]"
	set TextePS "$Nom [join $LesOPSsTries " "]"
	if { ! [info exists DejaVuPI($Nom)]} {
	    AppendAuFichier $DestinPI $TextePI
	}
	if { ! [info exists DejaVuPS($Nom)]} {
	    AppendAuFichier $DestinPS $TextePS
	}
    }

}

proc CreeLesFichiersPhylos {{Nom ""}} {


    set Repertoire "[RepertoireDuGenome]/phylos"
    if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
    
    if { $Nom != ""} {
	set ListeATester [list $Nom]
    } else {
	set ListeATester [ListeDesPABs]
    }

    foreach Nom $ListeATester {
	set FichierPhylo "[RepertoireDuGenome]/phylos/$Nom"
	if {[file exists $FichierPhylo]} { continue }
	set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
	if { ! [file exists $FichierMSF]} { continue }
	set Premiere [PremiereLigneDuFichier $FichierMSF]
	if {$Premiere==""} { continue }
	if {[regexp "Clustalw inutile" $Premiere]} { continue }
	if {[regexp "NoSequencesToAlign" $Premiere]} { continue }

	Espionne [CreeLeFichierPhylo $FichierMSF $FichierPhylo]
    }
    return

}

proc CreeLesFichiersPourPermettrePopulate {} {

    
    if { ! [OnTraite Bathy2010]} {
	FaireLire "Attention ceci est specifique Bathymodiolus avec Bathy2010 !!"
	exit
    }
    set EditDir "[RepertoireDuGenome]/edit_dir"
    file mkdir $EditDir
    foreach Lib [list AllTogether SSH1 SSH2 SSH3 SSH4 SSH5 SSH6 SSH7 SSH8 SSH9 SSH10 Stress ] {
	set SingletsFile "$EditDir/Bathymodiolus.clean.$Lib.cap.singlets"
	if {[FileAbsent $SingletsFile]} {
	    foreach Nom [ListeDesPABs] {
		if {$Lib!="AllTogether"} {
		    set Libraries [ExtraitInfo $Nom "Libraries:"]
		    if {[lsearch -exact [split $Libraries " "] $Lib]<0} { continue }
		}
		set FiNuc [GscopeFile $Nom "nuctfa"]
		if {[FileAbsent $FiNuc]} { FaireLire "$FiNuc doesn't exist. I'll stop" }
		set TFA [ContenuDuFichier $FiNuc]
		regsub "^>$Nom +" $TFA ">" New
		scan $New "%s" Access
		lappend LesTFAs $New
	    }
	    lappend LesCrees [SauveLesLignes $LesTFAs dans $SingletsFile]
	}
    }
    return $LesCrees

}

proc CreeLesFichiersSequencesDesTrous {{AskToKeep Ask}} {

    global ADN TDN RAC
    global ListeDeBoites
    global ListeDesTROUs
    global ListeDesInterGenes
    global RepertoireDuGenome
    global IlFautRecreerLesFichiersSequencesDesTrous

    if {$AskToKeep=="Replace"} { set AskToKeep 0 } else { set AskToKeep 1 }

    set OnlyNuc 1

    set FichierBornes "$RepertoireDuGenome/fiches/bornesdestrous"
    if {$AskToKeep &&  [file exists $FichierBornes] &&  [OuiOuNon "Do I keep existing $FichierBornes" 0]} {
	return $FichierBornes
    }

    if { ! [info exists ListeDesInterGenes]} { ChargeLesInterGenes }
    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set lADN [string length $ADN]

    set OD(A,1) 0 ; set OD(A,2) 1 ; set OD(A,0) 2 
    set OD(B,1) 2 ; set OD(B,2) 0 ; set OD(B,0) 1 
    set OD(C,1) 1 ; set OD(C,2) 2 ; set OD(C,0) 0 
    set OD(D,1) 0 ; set OD(D,2) 1 ; set OD(D,0) 2 
    set OD(E,1) 2 ; set OD(E,2) 0 ; set OD(E,0) 1 
    set OD(F,1) 1 ; set OD(F,2) 2 ; set OD(F,0) 0 
    
    set OF(A,1) 2 ; set OF(A,2) 1 ; set OF(A,0) 0 
    set OF(B,1) 0 ; set OF(B,2) 2 ; set OF(B,0) 1 
    set OF(C,1) 1 ; set OF(C,2) 0 ; set OF(C,0) 2 
    set OF(D,1) 2 ; set OF(D,2) 1 ; set OF(D,0) 0 
    set OF(E,1) 0 ; set OF(E,2) 2 ; set OF(E,0) 1 
    set OF(F,1) 1 ; set OF(F,2) 0 ; set OF(F,0) 2 


    foreach InterGene $ListeDesInterGenes {

	Espionne $InterGene
	set NomIG  [Box $InterGene nom]
	set Debut  [Box $InterGene debut]
	set Fin    [Box $InterGene fin]
	set Orient [Box $InterGene orient]

	regsub -nocase "INTERGENE" $NomIG "" Numero
	set Nom "TROU${Numero}N"

	set Entete "$Nom $Debut $Fin F"
	Espionne $Entete
	set Sequence [SequenceFormatTFA [BoutADN $Debut $Fin "F"] $Entete]
	Sauve $Sequence dans "$RepertoireDuGenome/nuctfa/$Nom"

	lappend BornesDesTrous "$Nom $Debut $Fin $Orient"

	if {$OnlyNuc} {	continue }

	Wup "Rest is obsolete ... it creates the 6 proteins (for each frame)"

	foreach Frame {A B C D E F} Orient {F F F R R R} {
	    set DebutFrame [expr $Debut - [set OD($Frame,[expr $Debut%3])] ]
	    set FinFrame   [expr $Fin   + [set OF($Frame,[expr $Fin%3])] ]

	    if { $DebutFrame < 1 } { incr DebutFrame 3}
	    if { $FinFrame   > [expr $lADN-1] } { incr FinFrame -3}

	    set Nom "TROU${Numero}$Frame"
	    if { $IlFautRecreerLesFichiersSequencesDesTrous } {
		set Entete "$Nom $DebutFrame $FinFrame $Orient"
		set SeqNuc [BoutADN $DebutFrame $FinFrame $Orient]
		set SeqPro [SeqNucToSeqPro $SeqNuc]
		if {0 && [regexp {\*} $SeqPro]} {
		    set LesBonsBouts [split $SeqPro "*"]
		    set Long 0
		    foreach BonBout $LesBonsBouts {
			set Long [string length $BonBout]
			if { $Long > 10 } { break }
		    }
		    if  { $Long <= 10 } {
			Warne "Je jette $SeqPro"
			continue
		    }
		}
		set TFA [SequenceFormatTFA $SeqNuc "$Entete" "nucbrut"]
		Sauve $TFA dans "$RepertoireDuGenome/nuctfa/$Nom"
	    }
	    lappend BornesDesTrous "$Nom $DebutFrame $FinFrame"
	}
    }    
    SauveLesLignes $BornesDesTrous dans $FichierBornes
    if {[info exists ListeDesTROUs]} { unset ListeDesTROUs }
    ChargeLesTROUs
    return $FichierBornes

}

proc CreeLesFichiersSpectreDesGC {{SequenceADN ""} {Retour ""} {lWin 400}} {

    global RepertoireDuGenome
    if {$SequenceADN==""} {
	global ADN TDN RAC
	if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
    } else {
	set ADN $SequenceADN
    }
    set l [string length $ADN]

    set nGC 0
    for {set i 0} {$i<$lWin} {incr i} {
	set Win($i) "A"
	set Win([incr i]) "C"
	incr nGC
    }
    set pWin 0
    set ntGC 0
    set Mi 99
    set Ma  0

    set OldLimite 0
    foreach Limite {25 35 50 100} Couleur {"red" "orange" "green" "blue"} {
	for {set i $OldLimite} {$i < $Limite} {incr i} {
	    set CouleurDeLaBande($i) $Couleur
	}
	set OldLimite $Limite
    }
    set CouleurDeLaBande($Limite) $Couleur

    set OldCouleur "cacadoie"
    set Oldi 0
    for {set i 1} {$i < $l} {incr i} {
	set c [string index $ADN $i]
	set w [set Win($pWin)]
	if { $c == "G" || $c == "C" } { incr nGC  1 ; incr ntGC}
	if { $w == "G" || $w == "C" } { incr nGC -1 }
	set Win($pWin) $c
	set pWin [expr ($pWin+1)%$lWin]
	set NewpGC [expr ($nGC*100)/$lWin]
	if {[expr $i>$lWin/2] && [expr $i%($lWin/4)] == 0} { lappend SpectreXY "[expr $i-$lWin/2] $NewpGC" }
	set pGC $NewpGC
	set Mi [Mini $Mi $NewpGC]
	set Ma [Maxi $Ma $NewpGC]
	set Couleur [set CouleurDeLaBande($pGC)]
	if { $Couleur != $OldCouleur } {
	    lappend Spectre "[incr Oldi] $i $Couleur"
	    set Oldi $i
	}
	set OldCouleur $Couleur
    }
    set Moyen [expr ($ntGC*100)/[string length $ADN]]
    set Entete [list "0 $Mi" "$Oldi $Ma" "0 $Moyen"]

    set SpectreGCXY [concat $Entete $SpectreXY] 

    if {$Retour=="SpectreGCXY"} { return $SpectreGCXY }

    set FichierSpectreXY "$RepertoireDuGenome/fiches/spectregcxy" 
    Espionne [SauveLesLignes $SpectreGCXY dans "$FichierSpectreXY"]

    set FichierSpectre "$RepertoireDuGenome/fiches/spectregc" 
    Espionne [SauveLesLignes $Spectre dans "$FichierSpectre"]

}

proc CreeLesFichiersTFAsDesMeilleursCopainsDuBlastPourTous {RepBlast GrosFichierTFAs {Expect 1e-25} {RepTFAs ""}} {

    global RepertoireDuGenome

    if { $RepTFAs=="" } { set RepTFAs "copains[file tail $RepBlast]" }
    if { ! [regexp "/" $RepTFAs]} { set RepTFAs "$RepertoireDuGenome/$RepTFAs" }
    if { ! [file exists $RepTFAs]} { File mkdir $RepTFAs }

    foreach Nom [ListeDesPABs] {
	Espionne "Je vais traiter $Nom"
	set FichierTFAsACreer "$RepTFAs/$Nom"
	if {[file exists $FichierTFAsACreer]} { continue }
	set Texte [TexteTFAsDesMeilleursCopainsDuBlast $Nom $RepBlast $GrosFichierTFAs $Expect]
	if {$Texte==""} { continue }
	Espionne [Sauve $Texte dans "$FichierTFAsACreer"]
    }

}

proc CreeLesFichiersTFAsNUCsAvecBornesDesPABsEtADN {} {

    global RepertoireDuGenome

    if { ! [OuiOuNon "Je recree les sequences dans $RepertoireDuGenome"]} { return }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {

	ExtraireDe $Ligne Nom Debut Fin Orient

	if {[file exists "$RepertoireDuGenome/prottfa/$Nom"]} { continue }

	set SeqNuc [BoutADN $Debut $Fin $Orient]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	
	set NUC [SequenceFormatTFA $SeqNuc "$Nom $Debut $Fin $Orient $Cut" "nucbrut"]
	Espionne [Sauve $NUC dans "$RepertoireDuGenome/nuctfa/$Nom"]
	
	set TFA [SequenceFormatTFA $SeqPro "$Nom $Debut $Fin $Orient $Cut" "protbrut"]
	Espionne [Sauve $TFA dans "$RepertoireDuGenome/prottfa/$Nom"]

    }

}

proc CreeLesFichiersTfas {} {

    global RepertoireDuGenome
    FaireLire "CreeLesFichiersTfas obsolete" 

    FaireLire "Attention, on ne tient pas compte des nouveaux [PreFixe]s"

    foreach TFA [split [ContenuDuFichier "$RepertoireDuGenome/DuGenoscope/pep"] ">"] {
	if { $TFA == "" } { continue }
	set Nom [string range $TFA 0 6]
	Sauve ">$TFA" dans "$RepertoireDuGenome/prottfa/$Nom"
    }

}

proc CreeLesIdentitesDuGroupe {NomDeGroupe} {

    global Threshold LongueurTotale LNDG SDG ListeDesConsensusDuGroupe ListeDesPiliersDuGroupe ListeDesAcidesAmines Defauts

    if {$NomDeGroupe eq "grise" || $NomDeGroupe eq "bidon"} {return}

    set ConsensusGlobalDuGroupe [set ListeDesConsensusDuGroupe($NomDeGroupe)]
    set NouveauConsensusDuGroupe ""
    set LesPiliers [set ListeDesPiliersDuGroupe($NomDeGroupe)]

    set i 0
    foreach Pilier $LesPiliers {
	set Seuil [CalculeLesSeuils $Pilier $NomDeGroupe $Defauts(ThresholdIden)]
	if {$Seuil != -1.} {
	    foreach aa $ListeDesAcidesAmines {
		set YaCons [CalculePoidsDuPilier2 $Pilier $aa $NomDeGroupe $Seuil]
		if {$YaCons} {break}
	    }
	} else {
	    set YaCons 0
	}
	
	if {$YaCons} {
	    set Consensus $aa
	} else {
	    set Consensus [string index $ConsensusGlobalDuGroupe $i]
	}
	append NouveauConsensusDuGroupe $Consensus
	incr i
    }

    set ListeDesConsensusDuGroupe($NomDeGroupe) $NouveauConsensusDuGroupe

    return

}

proc CreeLesInfosDesTRNAs {} {

    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesTRNAs

    ChargeLesTRNAs

    foreach TRNA $ListeDesTRNAs {
	set AA [string range $TRNA 4 6]
	set Codon [string range $TRNA 7 9]
	set Info {}
	lappend Info "Nom: $TRNA"
	lappend Info "ValiDE: tRNA $AA $Codon"
	lappend Info "ValiGN: tRNA-$AA-$Codon"
	lappend Info "ValiCF: 191"
	Espionne [SauveLesLignes $Info dans "$RepertoireDuGenome/infos/$TRNA"]
    }

}

proc CreeLesInfosDuGenescope {Fichier Repertoire} {

    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { $Ligne == "" } { continue }
	if {[regexp "^Nom: [ExpressionReguliereDesPABs]" $Ligne]} {
	    if {[info exists InfoCourante]} {
		Sauve [join $InfoCourante "\n"] dans "$Repertoire/$Nom"
	    }
	    scan $Ligne "%s %s" Bidon Nom
	    set InfoCourante {}
	}
	if {[InfoInteressante $Ligne]} {
	    lappend InfoCourante $Ligne
	}
    }

}

proc CreeLesLiensDansBalibase {} {

    set RepEx(msf) "msf"
    set RepEx(tfa) "tfas"
    set RepEx(rsf) "macsimRsf"
    set RepEx(xml) "macsimXml"
    foreach Nom [ListeDesPABs] {
	set RV "RV[RVof $Nom]"
	foreach Ext [array names RepEx] {
	    set Rep $RepEx($Ext)
	    set FicR "[RepertoireDuGenome]/$RV/$Nom.$Ext"
	    set FicB "[RepertoireDuGenome]/$Rep/$Nom"
	    if {[FileAbsent $FicR]} { continue }
	    Espionne "$FicR"
	    exec ln -sf $FicR $FicB
	}
    }

}

proc CreeLesMsfFamily {} {

    global RepertoireDuGenome
    
    if {![File exists "$RepertoireDuGenome/Families"]} {
	File mkdir "$RepertoireDuGenome/Families"
	File mkdir "$RepertoireDuGenome/Families/listes"
	File mkdir "$RepertoireDuGenome/Families/merge"
	File mkdir "$RepertoireDuGenome/Families/rsf"
	File mkdir "$RepertoireDuGenome/Families/msf"
    }

    foreach Nom [ListeDesPABs] {
	set Fam [NomDeFamille $Nom]
	if {[info exists DejaVu($Fam)]} {
	    
	    if {![file exists "$RepertoireDuGenome/Families/msf/$Fam"]} {
		CreeFichierListePABsDeLaFamille $Famille
	    }
	}
    }

}

proc CreeLesNouveauxTFAs {NouveauRep} {

    if {![file exists $NouveauRep]} {file mkdir $NouveauRep}

    # set EnteteTFA [EnteteDuFichierTFA $Fichier]
    # set TFA [SequenceFormatTFA $SeqBonSens ">$EnteteTFA" "brut"]
    # set TexteSeq [QueLaSequenceDuTFA $Fichier]

    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/prottfa/PCA*"] {
	set NomFichier [file tail $Fichier]
	Espionne $NomFichier
	set NouveauFichier "[RepertoireDuGenome]/$NouveauRep/$NomFichier"
	if {[file exists $NouveauFichier]} {continue}
	set EnteteTFA [EnteteDuFichierTFA $Fichier]
	set TexteSeq [QueLaSequenceDuTFA $Fichier]
	
	regsub "|" $EnteteTFA " " EnteteTFA
	set TexteSeq [string toupper $TexteSeq]
	
	if {![regexp ">$NomFichier" $EnteteTFA]} {
	    set EnteteTFA ">$NomFichier"
	    Espionne "nouv entete: $EnteteTFA"
	}
	
	set TFA [SequenceFormatTFA $TexteSeq $EnteteTFA "brut"]
	Sauve $TFA dans $NouveauFichier
    }

}

proc CreeLesNouvellesBornesDesPABs {Fichier} {

    Espionne "$Fichier"
    if {![file exists $Fichier]} {return ""}
 
    set TailleBoitePrincipale 1800
    set Position 1
    set NewTable ""
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} 
	set PremierElement [lindex $Ligne 0]
	set Position [expr $Position +99]
	set PositionSup [expr $Position + $TailleBoitePrincipale]
	append NewTable "$PremierElement $Position $PositionSup F\n"
	set LesElements [split $Ligne " "]
	set NbElements [llength $LesElements]
	if {$NbElements >  1} {
	    set n 0
	    set TaillePetiteBoite [expr ($TailleBoitePrincipale/($NbElements-1)) -20]
	    set PositionPetiteboite [expr $Position + 1]
	    foreach Element $LesElements {
		incr n
		if {$n == 1} {continue}
		set mod [expr $PositionPetiteboite % 3]
		if {$mod == 1} {
		    set PositionPetiteboite [expr $PositionPetiteboite +1]
		} elseif {$mod == 0} {
		    set PositionPetiteboite [expr $PositionPetiteboite -1]
		}
		set PositionSupPetiteBoite [expr $PositionPetiteboite+ $TaillePetiteBoite]
		append NewTable "$Element $PositionPetiteboite $PositionSupPetiteBoite F\n"
		set PositionPetiteboite [expr $PositionSupPetiteBoite + 20]
	    }
	}
	set Position $PositionSup
    }
    set NewNameFile "bornesdespabs"
    set NewFile "[RepertoireDuGenome]/fiches/$NewNameFile"
    if {[OuiOuNon "Do you want to save the new table in $NewFile?"]} {
	Sauve $NewTable dans $NewFile
    }
    return $NewTable

}

proc CreeLesOligosManquants {} {

    FaireLire "ne pas relancer"; exit
    cd "[RepertoireDuGenome]/oligos"
    set iP 2798
    foreach P [list P2644.tfa P2645.tfa P2652.tfa P2654.tfa P2655.tfa P2657.tfa P2658.tfa P2660.tfa] {
	regsub ".tfa" $P "" BP
	set TFA [ContenuDuFichier $P]
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq    [QueLaSequenceDuTexteTFA $TFA]
	set SB    [StringApres " signal "   dans $Entete]
	set ST    [StringApres " replaces " dans $Entete]
	set Sujet [StringApres " for "      dans $Entete]
	regsub "_$SB" $ST "" SA
Espionne "$ST $SA"
	set SSA [Signal $SA "SEQ"]
	set FullSeq "$SSA$Seq"

	set FullP "P$iP"
	incr iP

	regsub "AfterMeButItDoesNotExist" $Entete $FullP NewEntete
	set NewTFA [SequenceFormatTFA $Seq $NewEntete "nucbrut"]

	set FullE "$FullP 5' oligo with signal $ST for $Sujet RebuildedBrockenOli of $SA seeBrocken $BP"
	set FullTFA [SequenceFormatTFA $FullSeq $FullE "nucbrut"]
	Sauve $NewTFA dans $P
	Sauve $FullTFA dans "$FullP.tfa"
    }

}

proc CreeLesOranges {} {

    global LNOrdali
    global Sequences
    global LNDG
    global ListeDesConsensusDuGroupe
    global ListeDesPiliersDuGroupe
    global LongueurTotale
    global NombreDeGroupes

    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    set Consensus $ConsensusGlobalTous

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CG [string index $ConsensusGlobalTous $i]

	if {![string compare $CG "#"]} {

	    set GroupeA [lindex $LNDG 1]
	    set GroupeB [lindex $LNDG 2]
	    set GroupeC [lindex $LNDG 3]

	    set ConsA [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeA)] $i]]
	    set ConsB [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeB)] $i]]
	    set ConsC [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeC)] $i]]

	    set A1 [expr {![string compare $ConsA $ConsC]}]
	    set A2 [string compare $ConsA $ConsB]
	    set A3 [regexp {[A-Y]} $ConsA]

	    if {$A1 && $A2 && $A3} {

		set LePilierOppose [lrange [set ListeDesPiliersDuGroupe($GroupeB)] $i $i]

		set BonOrange [expr {![regexp $ConsA $LePilierOppose]}]

		if {$BonOrange} {
		    set CG 7
		} else {
		    set CG "#"
		}
	    }
	}
	set Consensus [string range $Consensus 0 [expr {$i - 1}]]$CG[string range $Consensus [expr {$i + 1}] end]
    }
    set ListeDesConsensusDuGroupe($PremierGroupe) $Consensus

    return

}

proc CreeLesOrdresPourGIF {K {CeQuOnVeut Visible} {NomDuFichierGIF ""}} {

    global LesOrdresPourGIF

    JeMeSignale
    SauveLesLignes [$K configure] dans creelesordres.log

    if {$NomDuFichierGIF == ""} {
	set NomDuFichierGIF [FichierPourSaveAs]
    }
    if {$NomDuFichierGIF==""} { return "" }

    set LesOrdresPourGIF {}

    set LesOptions {}
    foreach OptionValeurs [$K configure] {
	set Option [lindex $OptionValeurs 0]
	set Valeur [lindex $OptionValeurs 4]
	if {$Valeur == {}} { continue } 
	if {[regexp " " $Valeur]} { set Valeur "\{$Valeur\}" }
	lappend LesOptions "$Option $Valeur"
    }

    lappend LesOrdresPourGIF "create canvas"
    foreach Option $LesOptions {
	lappend LesOrdresPourGIF $Option
    }
    lappend LesOrdresPourGIF "fin create canvas"

    if {$CeQuOnVeut=="" || $CeQuOnVeut=="Visible"} {
	set ScrollRegion [lindex [$K configure -scrollregion] 4]
	if {$ScrollRegion!=""} {
	    scan [$K xview] "%f %f" xVd xVf
	    scan [$K yview] "%f %f" yVd yVf
	    scan $ScrollRegion "%f %f %f %f" xSRd ySRd xSRf ySRf
	    set xd [expr $xSRd+$xVd*($xSRf-$xSRd)]
	    set yd [expr $ySRd+$yVd*($ySRf-$ySRd)]
	    set xf [expr $xSRd+$xVf*($xSRf-$xSRd)]
	    set yf [expr $ySRd+$yVf*($ySRf-$ySRd)]
	} else {
	    set xd 0
	    set yd 0
	    set xf [lindex [$K configure -width] 4]
	    set yf [lindex [$K configure -height] 4]
	}
	Espionne "$xd $yd $xf $yf"
	set LesObjets [$K find enclosed $xd $yd $xf $yf]
    }
    if {$CeQuOnVeut=="OnVeutTout"} {
	set LesObjets [$K find withtag all]
	set xd 0
	set yd 0
	set xf [lindex [$K configure -width] 4]
	set yf [lindex [$K configure -height] 4]
    }
    foreach Id $LesObjets {
	set Type [$K type $Id]
	set LesOptions {}
	foreach OptionValeurs [$K itemconfigure $Id] {
	    set Option [lindex $OptionValeurs 0]
	    set Valeur [lindex $OptionValeurs 4]
	    if {$Valeur == {}} { continue } 
	    if {[regexp " " $Valeur]} { set Valeur "\{$Valeur\}" }
	    lappend LesOptions "$Option $Valeur"
	}
	lappend LesOrdresPourGIF "create $Type [$K coords $Id]"
	foreach Option $LesOptions {
	    lappend LesOrdresPourGIF $Option
	}
	lappend LesOrdresPourGIF "fin create $Type"
    }
    if {$LesOrdresPourGIF=={}} { return "" }

    set LargeurImage [expr ($xf-$xd)]
    return [CreeLeFichierGIF $K $LesOrdresPourGIF [list $xd $yd $xf $yf] $NomDuFichierGIF [list $LargeurImage]]

}

proc CreeLesPABsAbInitio {} {

    global RepertoireDuGenome
    global ADN TDN RAC
    global PrefixeDesORFs
    global LongueurMiniDesORFs

    if { ! [info exists ADN]} { ChargeADNetTDNetRAC }

    set LongADN [string length $ADN]

    foreach DebutFrame {1 2 3} {
	set Orient "F"
	set DebutPotentiel $DebutFrame
	while {$DebutPotentiel < $LongADN} {
	    set TrouveStart 0
	    for {set i $DebutPotentiel} {$i < [expr $LongADN-3]} {} {
		set Codon [string range $ADN $i [expr $i+2]]
		if {[CodonStartPossible $Codon]} {
		    set Debut $i
		    set TrouveStart 1
		    break
		}
		incr i 3
	    }
	    if { ! $TrouveStart} { break }
	    Wup "On a trouve un Met"
	    set TrouveStop 0
	    for {set i [expr $Debut+3]} {$i < [expr $LongADN-3]} {} {
		set Codon [string range $ADN $i [expr $i+2]] 
		if {[CodonStopPossible $Codon]} {
		    set Fin [expr $i-1]
		    set TrouveStop 1
		    break
		}
		incr i 3
	    }
	    if { ! $TrouveStop} { set Fin [expr $i-1] }
	    if { [expr $Fin - $Debut] >=  $LongueurMiniDesORFs } {
		lappend ListeDesBornes($Orient) "ORF $Debut $Fin $Orient"
	    }
	    set DebutPotentiel [expr $Fin+1]
	}
    }
    foreach DebutFrame {1 2 3} {
	set Orient "R"
	set DebutPotentiel $DebutFrame
	while {$DebutPotentiel < $LongADN} {
	    set TrouveStart 0
	    for {set i $DebutPotentiel} {$i < [expr $LongADN-3]} {} {
		set Codon [string range $RAC $i [expr $i+2]]
		if {[regexp "ATG|TTG|GTG" $Codon]} {
		    set Debut $i
		    set TrouveStart 1
		    break
		}
		incr i 3
	    }
	    if { ! $TrouveStart} { break }
	    Wup "On a trouve un Met"
	    set TrouveStop 0
	    for {set i [expr $Debut+3]} {$i < [expr $LongADN-3]} {} {
		set Codon [string range $RAC $i [expr $i+2]]
		if {[CodonStopPossible $Codon]} {
		    set Fin [expr $i-1]
		    set TrouveStop 1
		    break
		}
		incr i 3
	    }
	    if { ! $TrouveStop} { set Fin [expr $i-1] }
	    if { [expr $Fin - $Debut] >=  $LongueurMiniDesORFs } {
		lappend ListeDesBornes($Orient) "ORF [expr $LongADN-$Fin] [expr $LongADN-$Debut] $Orient"
	    }
	    set DebutPotentiel [expr $Fin+1]
	}
    }
    set ListeTriee(F) [lsort -increasing -command CompareLesMilieux $ListeDesBornes(F)]
    set ListeTriee(R) [lsort -decreasing -command CompareLesMilieux $ListeDesBornes(R)]
    set Numero 0
    foreach Ligne [concat $ListeTriee(F) $ListeTriee(R)] {
	scan $Ligne "%s %d %d %s" ORF Debut Fin Orient
	set Nom [format "%s%4.4d" $PrefixeDesORFs [incr Numero]] 
	lappend ListeBornesDesPABs "$Nom $Debut $Fin $Orient"
    }
    set FichierBornesDesPABs "$RepertoireDuGenome/fiches/bornesdespabs"
    if {[file exists $FichierBornesDesPABs]} {
	if {[OuiOuNon "$FichierBornesDesPABs existe deja. Je stoppe tout ?"]} { exit }
    }
    Espionne [SauveLesLignes $ListeBornesDesPABs dans $FichierBornesDesPABs]
    return 1

}

proc CreeLesPABsAvecGenBank {{Fichier ""}} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOC
    global NePasPrevenirPourGenBank

    set Previens 1
    if {[info exists NePasPrevenirPourGenBank] && $NePasPrevenirPourGenBank} {
	set Previens 0
    }

    set FichierAttention "$RepertoireDuGenome/fiches/attention_genbank"

    if { ! [info exists "$RepertoireDuGenome/infos"]} {
	File mkdir "$RepertoireDuGenome/infos"
    }
    if { ! [info exists "$RepertoireDuGenome/prottfa"]} {
	File mkdir "$RepertoireDuGenome/prottfa"
    }
    if { ! [info exists "$RepertoireDuGenome/protembl"]} {
	File mkdir "$RepertoireDuGenome/protembl"
    }
    if { ! [info exists "$RepertoireDuGenome/nuctfa"]} {
	File mkdir "$RepertoireDuGenome/nuctfa"
    }
    if { ! [info exists "$RepertoireDuGenome/nucembl"]} {
	File mkdir "$RepertoireDuGenome/nucembl"
    }

    if {$Fichier==""} {
	FaireLire "Please browse for the Protein file created by GenBank"
	set Fichier [ButineArborescence All $RepertoireDuGenome/]
	if {$Fichier==""} { return 0 }
    }
    set OldNom ""
    set Keep 0
    if {[llength [glob -nocomplain "$RepertoireDuGenome/protembl/*"]]} {
	set Keep [OuiOuNon "Do I keep existing files in nucembl and protembl ?"]
    }
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "/" $Ligne]} {
	    scan $Ligne "%s %d %d %s" NomLu Debut Fin Orient
	    regsub -nocase {^[A-Z_]+} $NomLu [PreFixe] Nom
	    lappend LesBornes "$Nom $Debut $Fin $Orient"
	    set Gene ""
	    set Product ""
	    set Note ""
	    set SeqPro ""
	    set SeqNuc ""
	}
	if {$Keep && [file exists "$RepertoireDuGenome/protembl/$Nom"]} { continue }
	if {$SeqNuc==""} {
	    set SeqNuc [BoutADN $Debut $Fin $Orient]
	    Espionne "$Nom $Debut $Fin $Orient"
	    set TraNuc [SeqNucToSeqPro $SeqNuc]
	    set SeqPro $TraNuc
	    set Attention ""
	}
	if {[regexp {[^ATGC]} $SeqNuc Autre]} {
	    append Attention "$Nom $Debut $Fin $Orient degenerated code (between ><): >$Autre<\n$SeqNuc\n"
	}
	if {[regexp "/translation=" $Ligne]} {
	    set SeqPro [StringSuivant "/translation=" dans $Ligne]
	    if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
		append Attention "$Nom $Debut $Fin $Orient\n"
		append Attention " Translated Nuc and Prot don't correspond\n"
		append Attention "SeqPro > $SeqPro\nSeqNuc > $TraNuc\n"
	    }
	    if {$Attention==""} {
		set SeqPro $TraNuc
	    } else {
		if {$Previens && [string range $SeqPro 1 end-1] != [string range $TraNuc 1 end]} {
		    if {[OuiOuNon "Something is wrong with TranslatedNuc and Prot\n Do You want to ignore all messages ?"]} {
			set NePasPrevenirPourGenBank 1
			set Previens 0
		    } else {
			AfficheVariable $Attention "SansRien"
		    }
		}
		AppendAuFichier $FichierAttention $Attention
	    }
	}
	if {[regexp "/gene=" $Ligne]} {
	    set Gene [StringSuivant "/gene=" dans $Ligne]
	    InformeSansDemander $Nom "=GN_GenBank: $Gene"
	}
	if {[regexp "/product=" $Ligne]} {
	    set Product [StringSuivant "/product=" dans $Ligne]
	    InformeSansDemander $Nom "=DE_GenBank: $Product"
	}
	if {[regexp "/note=" $Ligne]} {
	    set Note [StringSuivant "/note=" dans $Ligne]
	    InformeSansDemander $Nom "=NT_GenBank: $Note"
	}
	if {[info exists SeqPro]} {

	    set NucTFA [SequenceFormatTFA $SeqNuc "$Nom $Gene $Product" "nucbrut"]
	    Sauve $NucTFA dans "$RepertoireDuGenome/nuctfa/$Nom"

	    set LongN [expr $Fin-$Debut+1]
	    set NucEMBL ""
	    append NucEMBL "ID   $Nom      PRELIMINARY;       DNA;   $LongN Bps."
	    append NucEMBL "\nAC   $Nom"
	    append NucEMBL "\nOS   $NotreOS."
	    append NucEMBL "\nOC   $NotreOC"
	    if {$Product!=""} { append NucEMBL "\nDE   $Product" }
	    if {$Gene!=""}    { append NucEMBL "\nGN   $Gene" }
	    append NucEMBL "\nCC   -!- from $Debut to $Fin. Orientation $Orient"
	    append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]"
	    Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"

	    set ProtTFA [SequenceFormatTFA $SeqPro "$Nom $Gene $Product" "protbrut"]
	    Sauve $ProtTFA dans "$RepertoireDuGenome/prottfa/$Nom"

	    set ProtEMBL ""
	    set LongP [expr $LongN/3]
	    append ProtEMBL "ID   $Nom      PRELIMINARY;       PRT;   $LongP AA."
	    append ProtEMBL "\nAC   $Nom"
	    append ProtEMBL "\nOS   $NotreOS."
	    append ProtEMBL "\nOC   $NotreOC"
	    if {$Product!=""} { append ProtEMBL "\nDE   $Product" }
	    if {$Gene!=""}    { append ProtEMBL "\nGN   $Gene" }
	    append ProtEMBl "\nCC   -!- taken from a GenBank file"
	    append ProtEMBL "\nCC   -!- from $Debut to $Fin. Orientation $Orient"
	    append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]"
	    Sauve $ProtEMBL dans "$RepertoireDuGenome/protembl/$Nom"
	}
    }
    SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"
    return 1

}

proc CreeLesPABsAvecUnProteomeDansTFAs {{FichierTFAsDuProteome ""}} {

    global RepertoireDuGenome
    global FichierSequenceADN
    global LongueurMiniDesORFs

    if {[OuiOuNon "Do I use a DNA file ?"]} {
	FaireLire "Sorry the program has to be written ... "
	return ""
    } else {
	set AvecADN 0
	if { ! [info exists FichierSequenceADN] || ! [regexp -nocase {[a-z]} $FichierSequenceADN] } {
	    set FichierSequenceADN "$RepertoireDuGenome/beton/adn_fantome"
	}
	if {! [file exists $FichierSequenceADN]} {
	    Sauve "xATGC" dans $FichierSequenceADN
	}
    }

    if { ! [info exists LongueurMiniDesORFs]} { set LongueurMiniDesORFs 300 }

    if {$FichierTFAsDuProteome==""} {
	set RepertoireParDefaut [lindex [glob -nocomplain "$RepertoireDuGenome/De*"] 0]
	if { ! [file exists $RepertoireParDefaut]} {
	    set RepertoireParDefaut "$RepertoireDuGenome/"
	} 
	set FichierTFAsDuProteomeParDefaut [glob -nocomplain "${RepertoireParDefaut}/*.tfa"]
	if { ! [file exists $FichierTFAsDuProteomeParDefaut] } {
	    set FichierTFAsDuProteomeParDefaut $RepertoireParDefaut
	}
	set FichierTFAsDuProteome [ButineArborescence "All" $FichierTFAsDuProteomeParDefaut]
    }

    if {$FichierTFAsDuProteome==""} { return {} }

    if {$AvecADN} {
	set FichierBornesDuProteome [LocaliseLeProteome $FichierTFAsDuProteome]
	if {$FichierBornesDuProteome==""} { return {} }
    }

    set RepertoireProteomeTFA "$RepertoireDuGenome/proteometfa"
    if { ! [file exists $RepertoireProteomeTFA]} {
	File mkdir $RepertoireProteomeTFA
    }

    set Keep 0
    if {[llength [glob -nocomplain "$RepertoireProteomeTFA/*"]]} {
	set Keep [OuiOuNon "Do I keep existing files in \n$RepertoireProteomeTFA/\n ?"]
    }

    if {[OuiOuNon "Do I use numbering from tfa file ?"]} {
	set Auto 0
	set NumeroAuto 10000
    } else {
	set Auto 1
	set NumeroAuto 0
    }
    set Orient "F"
    set Debut 1
    foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"] {
	incr Debut [expr $LongueurMiniDesORFs + 100]
	set Fin [expr $Debut+$LongueurMiniDesORFs]
	incr NumeroAuto
	set Seq [LaSequenceDuTFAs $FichierTFAsDuProteome $Access]
	set Head [lindex [split $Seq "\n"] 0]
	regsub ">" $Head "" DE
	if { ! [regexp -nocase {\([a-z0-9_\-]+\)} $Seq GN]} { set GN "" }
	if { ! [regexp -nocase {[0-9]+} $Access Numero]} { set Numero $NumeroAuto }
	while {[regexp {^0[0-9]+} $Numero]} { regsub {^0} $Numero "" Numero }
	
	set Nom [format "%s%4.4d" ORF $Numero]
	lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
	if {$Keep && [file exists "$RepertoireProteomeTFA/$Nom"]} { continue }
	set SeqPro [QueLaSequence $Seq]
	if {$AvecADN} {
	    set SeqNuc [BoutADN $Debut $Fin $Orient]
	    set TraNuc [SeqNucToSeqPro $SeqNuc]
	    set Attention ""
	    if {[regexp {[^ATGC]} $SeqNuc Autre]} {
		Warne "$Nom $Bornes $Autre\n$SeqNuc"
		set Attention "Degenerated code $Autre "
	    }
	    if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
		append Attention " TranslNuc and Prot don't correspond \n"
	    }
	    regsub ">" $Seq ">$Nom $Debut $Fin $Orient $Attention" Seq
	} else {
	    set Seq [SequenceFormatTFA $SeqPro ">$Nom $DE" "protbrut"]
	}
	Espionne [Sauve $Seq dans "$RepertoireProteomeTFA/$Nom"]
    }
    Espionne [SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs.proteome"]
    return $LesBornesDesPABs

}

proc CreeLesPABsAvecUnProteomeEtADN {{FichierTFAsDuProteome ""}} {

    global RepertoireDuGenome
    global FichierSequenceADN

    if {$FichierTFAsDuProteome==""} {
	set RepertoireParDefaut "$RepertoireDuGenome/DeGold/"
	if { ! [file exists $RepertoireParDefaut]} {
	    set RepertoireParDefaut "$RepertoireDuGenome/"
	} 
	set FichierTFAsDuProteomeParDefaut [glob -nocomplain "${RepertoireParDefaut}/*.ffa"]
	if { ! [file exists $FichierTFAsDuProteomeParDefaut] } {
	    set FichierTFAsDuProteomeParDefaut $RepertoireParDefaut
	}
	set FichierTFAsDuProteome [ButineArborescence "All" $FichierTFAsDuProteomeParDefaut]
    }

    if {$FichierTFAsDuProteome==""} { return {} }

    set FichierBornesDuProteome [LocaliseLeProteome $FichierTFAsDuProteome]
    if {$FichierBornesDuProteome==""} { return {} }

    set RepertoireProteomeTFA "$RepertoireDuGenome/proteometfa"
    if { ! [file exists $RepertoireProteomeTFA]} {
	File mkdir $RepertoireProteomeTFA
    }

    set Keep 0
    if {[llength [glob -nocomplain "$RepertoireProteomeTFA/*"]]} {
	set Keep [OuiOuNon "Do I keep existing files in \n$RepertoireProteomeTFA/\n ?"]
    }

    set Numero 0
    foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"]  Bornes [LesLignesDuFichier $FichierBornesDuProteome] {
	scan $Bornes "%s %d %d %s" AccessLu Debut Fin Orient
	set Seq [LaSequenceDuTFAs $FichierTFAsDuProteome $Access]
	if { ! [regexp -nocase {\([a-z0-9_\-]+\)} $Seq GN]} { set GN "" }
	set Nom [format "%s%4.4d" [PreFixe] [incr Numero]]
	lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
	if {$Keep && [file exists "$RepertoireProteomeTFA/$Nom"]} { continue }
	set SeqPro [QueLaSequence $Seq]
	set SeqNuc [BoutADN $Debut $Fin $Orient]
	set TraNuc [SeqNucToSeqPro $SeqNuc]
	set Attention ""
	if {[regexp {[^ATGC]} $SeqNuc Autre]} {
	    Warne "$Nom $Bornes $Autre\n$SeqNuc"
	    set Attention "Degenerated code $Autre "
	}
	if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
	    append Attention " TranslNuc and Prot don't correspond \n"
	}
	regsub ">" $Seq ">$Nom $Debut $Fin $Orient $Attention" Seq
	Espionne [Sauve $Seq dans "$RepertoireProteomeTFA/$Nom"]
    }
    Espionne [SauveLesLignes $LesBornesDesPABs dans "[RepertoireDuGenome]/fiches/bornesdespabs.proteome"]
    return $LesBornesDesPABs

}

proc CreeLesPiliers {} {

    global ListeDesPiliersDuGroupe LNDG LongueurTotale SDG Sequences Defauts ListePDB

    unset -nocomplain ListeDesPiliersDuGroupe
    if {! [info exists ListePDB]} {
	set ListePDB {}
    }
    set NombreDeGroupes [llength $LNDG]
    if {[lindex $LNDG end] eq "grise"} {
	set DernierGroupe [expr {$NombreDeGroupes-2}]
    } else {
	set DernierGroupe [expr {$NombreDeGroupes-1}]
    }
    set LGrp [lrange $LNDG 0 $DernierGroupe]
    
    foreach NomDeGroupe $LGrp {
	set Ls [list]

	foreach NSeq [set SDG($NomDeGroupe)] {
	    if {$NSeq in $ListePDB && ! [set Defauts(PDBDansPilier)]} {
		continue
	    }
	    lappend Ls [split [set Sequences($NSeq)] ""]
	}

	for {set i 0} {$i< $LongueurTotale} {incr i} {
	    lappend ListeDesPiliersDuGroupe($NomDeGroupe) [list [join [ExtraitListeDeListe $Ls $i] ""]]
	}
    }
    unset Ls
    update

    return

}

proc CreeLesPiliersPourBlocks {Ln} {

    global Sequences LongueurTotale

    set Ls {}
    foreach NSeq $Ln {
	lappend Ls [split [set Sequences($NSeq)] ""]
    }
    set Lpil [list]
    for {set i 0} {$i < $LongueurTotale} {incr i} {
	lappend Lpil [list [join [ExtraitListeDeListe $Ls $i] ""]]
    }

    return $Lpil

}

proc CreeLesPoints {} {

    global ListeDesConsensusDuGroupe LNDG LesPointsDuGroupe LongueurTotale ListeDesPiliersDuGroupe

    if {[lindex $LNDG end] == "grise"} {
	set DernierGroupe [expr {[llength $LNDG] - 2}]
	set NbrGrp [expr {[llength $LNDG] - 2}]
	if {$NbrGrp <= 1} {return}
    } else {
	set DernierGroupe [expr {[llength $LNDG] - 1}]
	set NbrGrp [expr {[llength $LNDG] - 1}]
    }

    if {$NbrGrp == 3} {
	set NmGrp1 [lindex $LNDG 1]
	set NmGrp2 [lindex $LNDG 2]
	set NmGrp3 [lindex $LNDG 3]
    }

    set ConsensusGlobal [set ListeDesConsensusDuGroupe([lindex $LNDG 0])]

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set ConsGlob [string index $ConsensusGlobal $i]
	if {$NbrGrp == 3} {
	    if {$ConsGlob == "7"} {
		set LesPointsDuGroupe($NmGrp1) [string replace [set LesPointsDuGroupe($NmGrp1)] $i $i "*"]
		set LesPointsDuGroupe($NmGrp3) [string replace [set LesPointsDuGroupe($NmGrp3)] $i $i "*"]
		set grp [lindex $LNDG 2]
		set CG [string index [set ListeDesConsensusDuGroupe($grp)] $i]
		if {[regexp {[A-Ya-y]} $CG]} {
		    set GroupeOppose $NmGrp1
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint1 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    set GroupeOppose $NmGrp3
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint3 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    if {$BonPoint1 && $BonPoint3} {set LesPointsDuGroupe($NmGrp2) [string replace [set LesPointsDuGroupe($NmGrp2)] $i $i "*"]}
		}
	    }

	    if {$ConsGlob == "8"} {
		set LesPointsDuGroupe($NmGrp1) [string replace [set LesPointsDuGroupe($NmGrp1)] $i $i "*"]
		set LesPointsDuGroupe($NmGrp2) [string replace [set LesPointsDuGroupe($NmGrp2)] $i $i "*"]
		set grp [lindex $LNDG 3]
		set CG [string index [set ListeDesConsensusDuGroupe($grp)] $i]
		if {[regexp {[A-Ya-y]} $CG]} {
		    set GroupeOppose $NmGrp1
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint1 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    set GroupeOppose $NmGrp2
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint2 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    if {$BonPoint1 && $BonPoint2} {set LesPointsDuGroupe($NmGrp3) [string replace [set LesPointsDuGroupe($NmGrp3)] $i $i "*"]}
		}
	    }

	    if {$ConsGlob == "9"} {
		set LesPointsDuGroupe($NmGrp2) [string replace [set LesPointsDuGroupe($NmGrp2)] $i $i "*"]
		set LesPointsDuGroupe($NmGrp3) [string replace [set LesPointsDuGroupe($NmGrp3)] $i $i "*"]
		set grp [lindex $LNDG 1]
		set CG [string index [set ListeDesConsensusDuGroupe($grp)] $i]

		if {[regexp {[A-Ya-y]} $CG]} {
		    set GroupeOppose $NmGrp2
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint2 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    set GroupeOppose $NmGrp3
		    set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
		    set BonPoint3 [expr {![regexp [string toupper $CG] $LePilierOppose]}]
		    if {$BonPoint2 && $BonPoint3} {set LesPointsDuGroupe($NmGrp1) [string replace [set LesPointsDuGroupe($NmGrp1)] $i $i "*"]}
		}
	    }
	}

	if {$ConsGlob != "7" && $ConsGlob != "8" && $ConsGlob != "9"} {
	    foreach grp [lrange $LNDG 1 $DernierGroupe] {
		set BonPoint 1
		set CG [string index [set ListeDesConsensusDuGroupe($grp)] $i]
		if {[regexp {[A-Z]} $CG] && [string index [set LesPointsDuGroupe($grp)] $i] != "*"} {
		    for {set j 1} {$j <= $NbrGrp} {incr j} {
			set grpcou [lindex $LNDG $j]

			if { $grpcou != $grp} {
			    if {$BonPoint} {
				set GroupeOppose [lindex $LNDG $j]
				set LePilierOppose [lindex [set ListeDesPiliersDuGroupe($GroupeOppose)] $i]
				set BonPointTmp [expr {![regexp [string toupper $CG] $LePilierOppose]}]
				set BonPoint [expr {$BonPoint && $BonPointTmp}]
			    }
			}
		    }

		    if {$BonPoint} {
			set LesPointsDuGroupe($grp) [string replace [set LesPointsDuGroupe($grp)] $i $i "*"]
		    }
		}
	    }
	}
    }

    return

}

proc CreeLesRBJOVVSurFondGris {} {

    global SDG
    global LongueurTotale
    global ListeDesAcidesAmines
    global ListeDesPiliersDuGroupe
    global ListeDesConsensusDuGroupe
    global LNDG
    global Threshold

    set NbrGrp [expr {[llength $LNDG] - 1}]
    set ListeDesConsensusDuGroupe(grise) ""
    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    lappend LNDG "grise"
    set DernierGrp [expr {[llength $LNDG] - 2}]

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CGlob [string index [set ListeDesConsensusDuGroupe($PremierGroupe)] $i]

	set bon 0
	if { $CGlob eq "#" || ($CGlob > 5 && $CGlob < 10) } {
	    foreach NomDeGroupe [lrange $LNDG 1 $DernierGrp] {
		set CG [string index [set ListeDesConsensusDuGroupe($NomDeGroupe)] $i]
		set Pilier [lindex [set ListeDesPiliersDuGroupe($NomDeGroupe)] $i]
		set Seuil [CalculeLesSeuils $Pilier $NomDeGroupe]
		set ValEqui 1

		set CGTmp($NomDeGroupe) $CG
		foreach Equiv {[ILMV] [PAGST] [DEQN] [FYW] [KRH]} {
		    set YaCount [CalculePoidsDuPilier2 $Pilier $Equiv $NomDeGroupe $Seuil]
		    if {$YaCount} {
			set CGTmp($NomDeGroupe) $ValEqui
			break
		    } else {
			incr ValEqui
		    }
		}
	    }

	    if {$NbrGrp == 3} {
		set GroupeA [lindex $LNDG 1]
		set GroupeB [lindex $LNDG 2]
		set GroupeC [lindex $LNDG 3]

		set g1 [set CGTmp($GroupeA)]
		set g2 [set CGTmp($GroupeB)]
		set g3 [set CGTmp($GroupeC)]

		set bon [expr {$g1 == $g2} && {$g1 == $g3} && {$g1 > 0} && {$g1 < 6}]
	    }

	    if {$NbrGrp == "2"} {
		set GroupeA [lindex $LNDG 1]
		set GroupeB [lindex $LNDG 2]

		set g1 [set CGTmp($GroupeA)]
		set g2 [set CGTmp($GroupeB)]

		set bon [expr {$g1 == $g2} && {$g1 > 0} && {$g1 < 6}]
	    }

	    if {$NbrGrp == "1"} {
		set GroupeA [lindex $LNDG 1]
		set g1 [set CGTmp($GroupeA)]

		set bon [expr {$g1 > 0} && {$g1 < 6}]
	    }

	    if {$bon} {
		append ListeDesConsensusDuGroupe(grise) $g1
	    } else {
		append ListeDesConsensusDuGroupe(grise) "#"
	    }
	} else {
	    append ListeDesConsensusDuGroupe(grise) "#"
	}

    }

    return

}

proc CreeLesRec1DeDidier {} {

    foreach E [PEntr "ListeDesEs"] {
	set PE [PEntr $E "All"]
	ScanLaListe [split $PE ","] PGS Alias Fragment Vecteur Oli5P Oli3P PCR Utilisateur
	set LesBons {}
	set LesLocs {}
	foreach N [LesVirtualPPCRsDuPGS $PGS] {
	    set Loc [LocalisationDesVirtualPPCRs "GetLocOf" $N]
	    lappend LesLocs $Loc
	    set  SujetPPCR [StringApres "ppcr:" dans $Loc]
	    if {$SujetPPCR==""} { continue }
	    if {$SujetPPCR==$Fragment} {
		lappend LesBons $Loc
	    } else {
		while 1 {
		    if {[regexp {\-1\-} $Fragment] && [regexp {\-2\-} $SujetPPCR]} {
			regsub {\-1\-} $Fragment "-2-" VraiFragment
			if {$SujetPPCR==$VraiFragment} {
			    lappend LesBons $Loc
			}
			break
		    }
		    scan $Loc "%s %s %d %s %d %d %s %d %s"  NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo 
		    set VraiFragment "$Fragment-$DPLu-$FPLu"
		    if {$SujetPPCR==$VraiFragment} {
			lappend LesBons $Loc
			break
		    }
		    if {[regexp "XPDhs" $Fragment]} {
			regsub "XPDhs" $Fragment "p80hs" Fragment
			continue
		    }
		    break
		}
	    }
	}
	if {[llength $LesBons]!=1} {
	    Espionne "J'ai trouve [llength $LesBons] locs pour $E"
	    Espionne $PE
	    EspionneL $LesLocs
	    Espionne ""
	}
    }

}

proc CreeLesRec1PourTousLesVirtualPPCR {} {

    set Keep 1
    set LesFSL {}
    foreach N [VirtualPPCREnStock LaListeDesNs] {
	set FicPPCR [VirtualPPCREnStock $N File]
	if { ! [file exists $FicPPCR]} { continue }
	set FicVect "[RepertoireDuGenome]/vecteurs/pDONR/pDONR207"
	set QueueVect [file tail $FicVect]
	regsub ".tfa" $QueueVect "" QueueVect
	set FicRec1 "[RepertoireDuGenome]/rec1/${N}_$QueueVect"
	if {$Keep && [file exists $FicRec1]} { continue } 
	set Resume [VirtualPPCREnStock $N Resume]
	if { ! [regexp -nocase AttB1 $Resume] || ! [regexp -nocase AttB2 $Resume]} { continue }
	set FSL [Recombinaison $FicPPCR $FicVect $FicRec1 "" "Premiere"]
	lappend LesFSL $FSL
	Espionne "Rec1 $N dans $QueueVect --> $FSL"
    }
    return $LesFSL

}

proc CreeLesRec2PourTousLesVEDidierCompatiblesGscope {} {

    set Keep 1
    set LesFichiersCrees {}
    foreach Ligne [LesVEDidierCompatiblesGscope "GetList"] {
	scan $Ligne "%s %s %s" VE R1 Vecteur
	set FicRec1 [Rec1 $R1 "Fichier"]
	Espionne $FicRec1
	if {[FileAbsent $FicRec1]} { continue }
	set VecFile [FindVector $Vecteur]
	set VecName [FindVector NameOf_$Vecteur]
	set FicRec2 "[RepertoireDuGenome]/rec2/${R1}_$VecName"
	if {$Keep && [FileExists $FicRec2]} { continue } 
	set FichierCree [Recombinaison $FicRec1 $VecFile $FicRec2 "" "Seconde"]
	lappend LesFichiersCrees $FichierCree
	Espionne "Rec2 $R1 dans $VecName --> $FichierCree"
    }
    FaireLire "refaire Rec2 en effacant d'abord fiches/rec2"
    return $LesFichiersCrees

}

proc CreeLesSimilaires {{OGlob 0}} {

    global SDG LongueurTotale ListeDesAcidesAmines
    global ListeDesPiliersDuGroupe ListeDesConsensusDuGroupe
    global LNDG Threshold NombreDeGroupes

    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    if {! $OGlob && $NombreDeGroupes > 1} {
	set LesGrps [lrange $LNDG 1 end]
    } else {
	set LesGrps $PremierGroupe
    }

    foreach NomDeGroupe $LesGrps {
	set Consensus [set ListeDesConsensusDuGroupe($NomDeGroupe)]
	set LesPiliers [set ListeDesPiliersDuGroupe($NomDeGroupe)]
	set i -1
	foreach Pilier $LesPiliers {
	    incr i
	    set CG [string index $Consensus $i]
	    if {$CG ne "#"} {
		continue
	    }

	    set Seuil [CalculeLesSeuils $Pilier $NomDeGroupe]
	    set ValEqui 1
	    foreach Equiv {{I L M V} {P A G S T} {D E Q N} {F Y W} {K R H}} {
		set YaCount [CalculePoidsDuPilier2 $Pilier $Equiv $NomDeGroupe $Seuil]
		if {$YaCount} {
		    set CG $ValEqui
		    break
		}
		incr ValEqui
	    }
	    set Consensus [string replace $Consensus $i $i $CG]
	}
	puts "$Consensus"
	set ListeDesConsensusDuGroupe($NomDeGroupe) $Consensus
    }

    return

}

proc CreeLesSynthetases {Fichier Destination {AA ""} {AAOrig ""}} {

    if {$AA==""} {
	set AA3 [AADuNomDuFichier $Fichier "AvecAlias"]
	set AA3Orig [AADuNomDuFichier $Fichier "SansAlias"]
	set AA1 [UT $AA3Orig]
    } else {
	set AA3     $AA
	if {$AAOrig==""} {
	    set AA3Orig  $AA3
	} else {
	    set AA3Orig $AAOrig
	}
	set AA1 [UT $AA3Orig]
    }
    set Nom [file tail $Fichier]

    Glossaire Pour init

    set DejaVuUn 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "Name:" $Ligne]} {
	    if {$DejaVuUn} { break } else { continue }
	}
	set DejaVuUn 1

	scan $Ligne "%s %s" Name Access

	if { ! [regexp -nocase "^hmr_" $Access] && [file exists "$Destination/$Access"]} { continue }

	if {[regexp -nocase "^sy" $Access]} {
	    set LesLignesEMBL [LaSequenceDesBanques "sw:$Access" "$Access" AccessOK "OnVeutEMBL"]
	    if {[llength $LesLignesEMBL]>0} {
		Espionne [SauveLesLignes $LesLignesEMBL dans "$Destination/$Access"]		    
		continue
	    }
	}
	
	set Hmr ""
	set AccessDansMSF $Access
	if {[regexp -nocase "hmr_" $Access Hmr]} {
	    set Access [string range $AccessDansMSF 4 end]
	}
	if {[regexp {^[a-zA-Z]+_[a-zA-Z]+} $Access]} {
	    set LesMots [split $Access "_"]
	    set Gen [lindex $LesMots 0]
	    set Esp [lindex $LesMots 1]
	    regsub {[0-9]} $Esp "" Esp
	    if {[llength $LesMots] > 2} {
		set Extension "_[join [lrange $LesMots 2 end] "_"]"
	    } else {
		set Extension ""
	    }

	    set Organisme [OrgApprochant $Gen $Esp]

	    set Sequence [UneSequenceDuMSF $Fichier $AccessDansMSF]
	    set Sequence [Scrunch $Sequence]
	    Espionne [SauveLesLignes [CreeUnFichierEMBL $AA3 $Organisme "$Hmr$AA1" $Sequence $Extension] dans "$Destination/$Hmr$Access"]
	    continue
	}

	continue
	if {[regexp {^ai|^gi} $Access]} {
	    set Pep [glob -nocomplain /home/moumou/hmr/*/$Access.pep]
	    set LePep [LesLignesDuFichier $Pep]
	    set Entete ""
	    foreach Lig [lrange $LePep 1 end] {
		if { ! [regexp {[a-zA-Z]} $Lig]} { break }
		append Entete $Lig
	    }
	    set Entete [string trim $Entete]
	    set LesChamps [split $Entete "\["]
	    set OR ""
	    set PN ""
	    set DE ""
	    set pn ""
	    set gn ""
	    foreach Champ $LesChamps {
		regsub {\]} $Champ "" Champ
		if {[regexp "OR:" $Champ]} {
		    set OS [string trim [string range $Champ 3 end]]
		}
		if {[regexp "PN:" $Champ]} {
		    set PN [string trim [string range $Champ 3 end]]
		} 
		if {[regexp "DE:" $Champ]} {
		    set DE [string trim [string range $Champ 3 end]]
		    set LesSousChamps [split $Champ "\("]
		    foreach SousChamp $LesSousChamps {
			regsub {\)} $SousChamp "" SousChamp
			if {[regexp "^pn:" $SousChamp]} {
			    set pn [string trim [string range $SousChamp 3 end]]
			} 
			if {[regexp "^gn:" $SousChamp]} {
			    set gn [string trim [string range $SousChamp 3 end]]
			} 
		    }
		    if {$pn==""} {
			set ipn [string first "pn:" $DE]
			if {$ipn>=0} {
			    set iSuivant [string first ":" [string range $DE [incr ipn 3] end]]
			    if {$iSuivant<0} {
				set fpn "end"
			    } else {
				set fpn [expr $iSuivant -4 +$ipn]
			    }
			    set pn [string range $DE $ipn $fpn]
			}
		    }
		    if {$gn==""} {
			set ign [string first "gn:" $DE]
			if {$ign>=0} {
			    set iSuivant [string first ":" [string range $DE [incr ign 3] end]]
			    if {$iSuivant<0} {
				set fgn "end"
			    } else {
				set fgn [expr $iSuivant -4 +$ign]
			    }
			    set gn [string range $DE $ign $fgn]
			}
		    }
		} 
		
	    }
	    
	    set iPP [lsearch -regexp $LePep {\.\.}]
	    set Sequence [join [lrange $LePep [incr iPP] end] ""]
	    regsub -all {[0-9\t\n \*]} $Sequence "" Sequence
	    set Sortie {}
	    lappend Sortie "ID   $Access; cree par rR d'apres $Access de HMR."
	    lappend Sortie "AC   $Access"
	    if {$PN!=""} {
		lappend Sortie "PN   $PN"
	    }
	    if {$DE!=""} {
		lappend Sortie "DE   $DE"
		if {$pn!=""} {
		    lappend Sortie "pn   $pn"
		}
		if {$gn!=""} {
		    lappend Sortie "gn   $gn"
		}
	    }
	    lappend Sortie "OS   $OS"
	    lappend Sortie [QueSequenceFormatEMBL $Sequence "AvecSQ"] 
	    
	    if {$PN=="" && $pn==""} {
		Warne ".......Manque PN\n$Entete"
	    }
	    Espionne [SauveLesLignes $Sortie dans "$Destination/$Access"]
	    continue
	}
	Warne "Je n'ai rien pour $Ligne"
    }

}

proc CreeLesTables {Source Orga Extension} {

    set LesTables {"tout_le_monde" "toutes_euryarks" "manque_euryarks" "no_ark" "pyro_specif"}
    set LesTables {"tout_le_monde"}
    foreach Table $LesTables {
	CreeLaTable $Table $Source $Orga $Extension
    }

}

proc CreeLesTetes {} {

    CanalSqlBioArrayBase
    foreach {Ex As} [SqlExec "select distinct e.description, a.name
    from retinobase3.experiment e, retinobase3.realexp re, retinobase3.rawdata ra, retinobase3.analysissoftware a
    where e.pk_experiment = re.pk_experiment
    and re.pk_realexp = ra.pk_realexp
    and ra.pk_software = a.pk_software;" "GetList"] {
	lappend LesLignes1 "$Ex\t$As"
    }
    foreach {Ex Cs} [SqlExec "select distinct e.description, c.clu_description
    from retinobase3.experiment e, retinobase3.ln_clu_exp_pro ln, retinobase3.cluster c
    where e.pk_experiment = ln.pk_experiment
    and ln.pk_cluster = c.pk_cluster;" "GetList"] {
	lappend LesLignes2 "$Ex\t$Cs"
    }
    CanalSqlDisconnect
    EspionneL $LesLignes1
    EspionneL $LesLignes2
    #SauveLesLignes $LesLignes1 dans "[RepertoireDuGenome]/transcriptomique/MetaCluster/ExAs"
    #SauveLesLignes $LesLignes2 dans "[RepertoireDuGenome]/transcriptomique/MetaCluster/ExCs"
    #SauveLesLignes $LesLignes1 dans "[RepertoireDuGenome]/transcriptomique/ConeSpe/Hierarchisation/ExAs"
    #SauveLesLignes $LesLignes2 dans "[RepertoireDuGenome]/transcriptomique/ConeSpe/Hierarchisation/ExCs"

}

proc CreeLesTfaVertebrateRefSeq {RepertoireInitial RepertoireDestination} {

    #RepertoireInitial -> "/refseqnew_upd/Protein/rsnc.*.gpff"
    #                  -> "/update/RefSeq-Release/*.protein.gpff.gz"
    #RepertoireDestination -> "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/tfa"
    foreach File [glob -nocomplain $RepertoireInitial] {
	Espionne "$File"
	set Nom [file tail $File]
	regsub ".gpff.gz" $Nom ".tfa" Nom
	regsub ".gpff" $Nom ".tfa" Nom
	set FileDestination "${RepertoireDestination}/$Nom"
	Sauve [SequenceFormatTFADuGenBankMultiple $File fields_ID_AC_DE_OS_OCwithVertebrata] dans $FileDestination
    }    

}

proc CreeLesTfasEtBlast1 {FichierSequences} {

    # FichierSequences = ANALYSE/miRNAs/seq_probe
    foreach Ligne [LesLignesDuFichier $FichierSequences] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set Nom [lindex $LesElts 0]
	Espionne $Nom
	set miRNA [lindex $LesElts 1]
	set Seq [lindex $LesElts 2]
	set SeqTFA [SequenceFormatTFA $Seq $miRNA "brut"]
	#FaireLire $SeqTFA
	set FichierTFA "[RepertoireDuGenome]/mirnatfa/$Nom"
	if {![file exists $FichierTFA]} {Sauve $SeqTFA dans $FichierTFA}
	set FichierBlast "[RepertoireDuGenome]/mirnatfa_blastnhuman/$Nom"
	set FichierBlast [BlastNDuFichier $FichierTFA "human" $FichierBlast "T"]
	Espionne "$Nom blastnhuman done"
    }

}

proc CreeLesTfasEtBlast2 {FichierSequences} {

    # FichierSequences = ANALYSE/miRNAs/Mature_seq_sanger

    # Extrait que les human
    foreach Ligne [LesLignesDuFichier $FichierSequences] {
	if {$Ligne==""} {continue}
	if {[regexp  "^>" $Ligne]} {
	    if {[regexp "Homo sapiens" $Ligne]} {
		set Vu 1
		lappend L $Ligne
	    } else {set Vu 0}
	} else {
	    if {$Vu==1} {lappend L $Ligne}
	}
    }
    #EspionneL $L
    set FichierHumanmiRNA "[RepertoireDuGenome]/ANALYSE/miRNAs/Human_Mature_seq_sanger"
    SauveLesLignes $L dans $FichierHumanmiRNA
    # Extrait les fichiers TFA
    set Ls ""
    foreach Ligne [LesLignesDuFichier $FichierHumanmiRNA] {
	if {$Ligne==""} {continue}
	if {[regexp  "^>" $Ligne]} {
	    if {$Ls!=""} {
		#FaireLire $Nom
		set FichierTFA "[RepertoireDuGenome]/mirnatfa2/$Nom"
		SauveLesLignes $Ls dans $FichierTFA
		set FichierBlast "[RepertoireDuGenome]/mirnatfa2_blastnhuman/$Nom"
		set FichierBlast [BlastNDuFichier $FichierTFA "human" $FichierBlast "T"]
		Espionne "$Nom blastnhuman done"
	    }
	    set Ls ""
	    set LesElts [split $Ligne " "]
	    set Nom [lindex $LesElts 4]
	    lappend Ls $Ligne
	} else {
	    lappend Ls $Ligne
	}
    }

}

proc CreeLesToilesPourTous {{Liste ""}} {

    if {[PourWscope]} {
	AppendAuFichier "[Fiches]/ToilesAFaire.txt" [join $Liste "\n"]
	return ""
    }
    set NombreDejaFaits 0
    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    foreach Nom $Liste {
	Espionne "$Nom $NombreDejaFaits"
	set RepertoireJpgDev "[RepertoireDuGenome]/jpg_of_DevStage"
	set RepertoireJpgTis "[RepertoireDuGenome]/jpg_of_TissType"
	if {! [file exists $RepertoireJpgDev]} {file mkdir $RepertoireJpgDev}
	if {! [file exists $RepertoireJpgTis]} {file mkdir $RepertoireJpgTis}
	set FD "$RepertoireJpgDev/${Nom}_DevStage.jpg"
	set FT "$RepertoireJpgTis/${Nom}_TissType.jpg"

	if {[FileAbsent $FD]} {
	    IllustreToileDevStage $Nom CreateJpg
	    if {[FileAbsent $FD]} {
		file copy "[GscopeEtc]/ImageForNoValue.jpg" $FD
	    } else {
		incr NombreDejaFaits
	    }
	}
	if {[FileAbsent $FT]} {
	    IllustreToileTissType $Nom CreateJpg
	    if {[FileAbsent $FT]} {
		file copy "[GscopeEtc]/ImageForNoValue.jpg" $FT
	    } else {
		incr NombreDejaFaits
	    }
	}
	if {$NombreDejaFaits>20} {
	    exec gscope yes CreeLesToilesPourTous >> "[RepertoireDuGenome]/toiles.log" &
	    exit
	}
    }

}

proc CreeLesVerts {} {

    global LNOrdali
    global Sequences
    global LNDG
    global ListeDesConsensusDuGroupe
    global ListeDesPiliersDuGroupe
    global LongueurTotale
    global NombreDeGroupes

    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    set Consensus $ConsensusGlobalTous

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CG [string index $ConsensusGlobalTous $i]

	if {![string compare $CG "#"]} {

	    set GroupeA [lindex $LNDG 1]
	    set GroupeB [lindex $LNDG 2]
	    set GroupeC [lindex $LNDG 3]

	    set ConsA [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeA)] $i]]
	    set ConsB [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeB)] $i]]
	    set ConsC [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeC)] $i]]

	    set A1 [expr {![string compare $ConsB $ConsC]}]
	    set A2 [string compare $ConsA $ConsB]
	    set A3 [regexp {[A-Y]} $ConsB]

	    if {$A1 && $A2 && $A3} {

		set LePilierOppose [lrange [set ListeDesPiliersDuGroupe($GroupeA)] $i $i]

		set BonVert [expr {![regexp $ConsC $LePilierOppose]}]

		if {$BonVert} {
		    set CG 9
		} else {
		    set CG "#"
		}
	    }
	}
	set Consensus [string range $Consensus 0 [expr {$i - 1}]]$CG[string range $Consensus [expr {$i + 1}] end]
    }
    set ListeDesConsensusDuGroupe($PremierGroupe) $Consensus

    return

}

proc CreeLesViolets {} {

    global LNOrdali
    global Sequences
    global LNDG
    global ListeDesConsensusDuGroupe
    global ListeDesPiliersDuGroupe
    global LongueurTotale
    global NombreDeGroupes

    set PremierGroupe [lindex $LNDG 0]
    set ConsensusGlobalTous [set ListeDesConsensusDuGroupe($PremierGroupe)]
    set Consensus $ConsensusGlobalTous

    for {set i 0} {$i < $LongueurTotale} {incr i} {
	set CG [string index $ConsensusGlobalTous $i]

	if {![string compare $CG "#"]} {

	    set GroupeA [lindex $LNDG 1]
	    set GroupeB [lindex $LNDG 2]
	    set GroupeC [lindex $LNDG 3]

	    set ConsA [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeA)] $i]]
	    set ConsB [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeB)] $i]]
	    set ConsC [string toupper [string index [set ListeDesConsensusDuGroupe($GroupeC)] $i]]

	    set A1 [expr {![string compare $ConsA $ConsB]}]
	    set A2 [string compare $ConsA $ConsC]
	    set A3 [regexp {[A-Y]} $ConsA]

	    if {$A1 && $A2 && $A3} {

		set LePilierOppose [lrange [set ListeDesPiliersDuGroupe($GroupeC)] $i $i]

		set BonViolet [expr {![regexp $ConsA $LePilierOppose]}]

		if {$BonViolet} {
		    set CG 8
		} else {
		    set CG "#"
		}
	    }
	}
	set Consensus [string range $Consensus 0 [expr {$i - 1}]]$CG[string range $Consensus [expr {$i + 1}] end]
    }
    set ListeDesConsensusDuGroupe($PremierGroupe) $Consensus

    return

}

proc CreeListeCandidatsPour {{PABVoulu ""} {CandidatOrga ""} {Famille famille}} {


    Wup "Rend une liste Access Orga pour PABVoulu"
     
    set ListeAccessCandidat {}
    set   ListeOrgaCandidat {}
    set       ListeCandidat {}

    set CandidatAccess [Narcisse $PABVoulu]
   
    Espionne "Boite $PABVoulu"
    Espionne "Orga $CandidatOrga"
    Espionne "Access Candidat $CandidatAccess"

    set ListeAccessCandidat [LesAccessDesOrganismesSample $PABVoulu]
    set ListeOrgaCandidat   [LesAccessDesOrganismesSample $PABVoulu "LesOrganismesMerci"]

    EspionneL "ListeAccessCandidat1 $ListeAccessCandidat"
    EspionneL "ListeOrgaCandidat2 $ListeOrgaCandidat"
    
    foreach AC $ListeAccessCandidat OG $ListeOrgaCandidat {
	lappend ListeCandidat "$AC $OG"
    } 
    
    if { $CandidatAccess != ""} {
	lappend ListeCandidat "$CandidatAccess $CandidatOrga"
    }
    set ListeCandidat [lsort -unique $ListeCandidat]
 
    EspionneL "$ListeCandidat"
    return $ListeCandidat

}

proc CreeListeCodonFrequency {FichierCod} {

    #FichierCod=Table Codon Frequency
    set Nom [file tail $FichierCod]
    set TailleEchantillon [TailleEchantillon $FichierCod]
    foreach Ligne [LesLignesDuFichier $FichierCod] {
	#attention aux lignes pas vraiment vides!!!!!!!!!!!!
	set Ligne [string trim $Ligne]
	#if {$Ligne==" " || $Ligne==""} {continue}
	if {$Ligne==""} {continue}
	if {[regexp {^Gly} $Ligne]} {
	    set VuDebut 1
	    scan $Ligne "%s %s %s" aa cod n
	    set Freq [expr $n/$TailleEchantillon]
	    lappend LesFrequences [list $aa $cod $Freq]
	} else { 
	    if {![info exists VuDebut]} {continue}
	    if {[info exists VuDebut]} {
		scan $Ligne "%s %s %s" aa cod n 
		set Freq [expr $n/$TailleEchantillon]
		lappend LesFrequences [list $aa $cod $Freq]
	    }
	}	
    }
    return $LesFrequences

}

proc CreeListeDeListesDansTemp {} {

#chaque ligne devient une liste de un ou plusieurs elements
#le fichier devient une liste de listes
    set FichierTemp [ButineArborescence All]
    if { ! [file exists $FichierTemp]} {return "The file does not exist"}
    set GrandeListe {}
    set PetiteListe {}
    set Jumeaux 0
    set i 0
    foreach Ligne [LesLignesDuFichier $FichierTemp] {
	set i 0
	if {$Ligne==""} {continue}
	set PetiteListe [list $Ligne]
	foreach Element $PetiteListe {
	    if { ! [info exists Vu($Element)]} {
		set Vu($Element) 1
	    } else {
		incr Jumeaux
		set PetiteListe [lreplace $PetiteListe $i $i]
	    }
	    incr i
	}
	lappend GrandeListe $PetiteListe
	set PetiteListe {}
    }
    set l [llength $GrandeListe]
    Espionne $l
    Espionne $Jumeaux
    set Uniques [expr $l-$Jumeaux]
    Espionne $Uniques
    return $GrandeListe

}

proc CreeListeDes12000Affys {Dir} {

    foreach Fichier [glob -nocomplain -directory $Dir "TAR*"] {
	set Nom [File tail $Fichier]
	lappend ListeTotale $Nom
    }
    Espionne [llength $ListeTotale]
    SauveLesLignes $ListeTotale dans "[RepertoireDuGenome]/fiches/listetotaledespabs"

}

proc CreeListeDesGeneNames {FichierPop FichierSortie} {

    set TousLesGN ""
    set L [CreeListePourFichierAUneColonne $FichierPop]
    foreach Nom $L {
	set LesGN [InterrogeGeneName $Nom LesGeneNames]
	if {$LesGN != ""} {
	    lappend TousLesGN $LesGN
	}
    }
    SauveLesLignes $TousLesGN dans $FichierSortie

}

proc CreeListeDesJRTropCourts {FichierRedondance1} {

    foreach Ligne [LesLignesDuFichier $FichierRedondance1] {
	if {$Ligne==""} {continue}
	set LesJumeaux [split $Ligne " "]
	set JR [lindex $LesJumeaux 0]
	set FichierMRM "[RepertoireDuGenome]/nucmask/$JR"
	set FichierMRMCorrigePlasmide "[RepertoireDuGenome]/nucmask_SansBoutPlasmide/$JR"
	if {[file exists $FichierMRMCorrigePlasmide]} {set FichierMRM $FichierMRMCorrigePlasmide}
	set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM]
	regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN
	set LSansN [string length $SeqMRMSansN]
	if {$LSansN<25} {lappend LesTropCourts $Ligne}
    }
    return $LesTropCourts

}

proc CreeListeDesSeqContaminees {FichierRedondance1SansCourts FichierNoLoc} {

    # FichierRedondance1 : fiches/Redondance1SansCourts
    # FichierLoc: Localisation/LesNoLoc
    foreach Ligne [LesLignesDuFichier $FichierNoLoc] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set DD [lindex $LesElts 0]
	set Vu($DD) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierRedondance1SansCourts] {
	if {$Ligne==""} {continue}
	set JR [TrouveLeOldJR $Ligne]
	if {$JR==""} {
	    set LesJumeaux [split $Ligne " "]
	    set JR [lindex $LesJumeaux 0]
	}
	if {[info exists Vu($JR)]} {
	    set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" Protein Access]
	    if {$AccBestProtHuman==""} {
		set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$JR"
		if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue}
		set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0.5 0]
		if {$LesProchesGb!=0} {lappend ListeConta $Ligne}
	    }
	}
    }
    Espionne [llength $ListeConta]
    set ListeConta [lsort -unique $ListeConta]
    Espionne [llength $ListeConta]
    return $ListeConta

}

proc CreeListeDesSeqDeMauvaiseQualite {FichierRedondance1 FichierNoLoc FichierSelectEST} {

    # no loc, no human prot, no gb, no est
    # FichierRedondance1 : fiches/Redondance1SansCourtsSansConta
    # Localisation/LesNoLoc : 
    # FichierSelectEST: fiches/SelectedEST
    
    foreach Ligne [LesLignesDuFichier $FichierNoLoc] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set DD [lindex $LesElts 0]
	set Vu($DD) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierRedondance1] {
	if {$Ligne==""} {continue}
	set JR [TrouveLeOldJR $Ligne]
	if {$JR==""} {
	    set LesJumeaux [split $Ligne " "]
	    set JR [lindex $LesJumeaux 0]
	}
	if {[info exists Vu($JR)]} {
	    set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" Protein Access]
	    if {$AccBestProtHuman==""} {
		set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$JR"
		if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue}
		set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0.5 0]
		if {$LesProchesGb==0} {
		    set EST [InterrogeSelectedEST $FichierSelectEST Nom $JR LesAccess]
		    if {$EST==""} {lappend ListeAExclure $Ligne}
		    # autre methode
		    set FichierEST "[RepertoireDuGenome]/blastnest/$JR"
		    if {![file exists $FichierEST]} {Espionne "$FichierEST doesn't exist";continue}
		    set LesProchesESTs [ac_LesProchesDansLeBlastBis $FichierEST 0.95 0.5 0]
		    if {$LesProchesESTs==0} {lappend ListeAExclure2 $Ligne}
		}
	    }
	}
    }
    Espionne [llength $ListeAExclure]
    Espionne [llength $ListeAExclure2]
    EspionneL $ListeAExclure
    return $ListeAExclure2

}

proc CreeListeDesSequencesCourtes {} {

    foreach PAB [ListeDesPABs] {
	set FichierMRM "[RepertoireDuGenome]/nucmask/$PAB"
	set FichierMRMCorrigePlasmide "[RepertoireDuGenome]/nucmask_SansBoutPlasmide/$PAB"
	if {[file exists $FichierMRMCorrigePlasmide]} {set FichierMRM $FichierMRMCorrigePlasmide}
	set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM]
	regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN
	set LSansN [string length $SeqMRMSansN]
	if {$LSansN<25} {lappend LesPABsCourts $PAB}
    }
    return $LesPABsCourts

}

proc CreeListeDesVidesRetrouves {} {

    foreach F [glob -nocomplain "[RepertoireDuGenome]/protemblVide/*"] {
	set Queue [file tail $F]
	lappend LesEVI $Queue
    }
    SauveLesLignes $LesEVI dans [Fiches]/Les36VidesRetrouves

}

proc CreeListeGenes {FichierPop FichierSortie} {

    # nom Gscope
    # Procure member -> (voir procure_paper.readme)
    # jumeaux?
    # seq origine (Lseq)
    # profil?
    # screening (T/N, BPH/nonBPH, HR/HS) -> lie au procure member 
    # access prot / def prot -> fichier best
    # access mRNA / def mRNA 
    # warning
    # Refseq Def / Access
    # GO
    # pathways
    # PFAMA
    # Gene Name?

    # FichierPop=PopTotaleTN
    # Cette proc se base sur la proc CreeFichierFinal (gscope_AnalyseSequencesDuDD.tcl) et proc CreeLesFichiersDataDD (gscope_overlap.tcl)


    set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO"
    set FichierPathways "[RepertoireDuGenome]/ARTICLE/Pathways/Pathways_PopTotaleTN"
    set L [CreeListePourFichierAUneColonne $FichierPop]
    foreach Nom $L {
	set LesGN [InterrogeGeneName $Nom LesGeneNames]
	if {$LesGN != ""} {
	    set GN $LesGN
	} else {set GN ""}

	set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access]
	set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access]

	if {$AccBestProtHuman!=""} {
	    set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition]
	    # Warning Identity pour BestProt Human
	    set IdBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccBestProtHuman Identity]
	    #set Identite [expr $IdBestProtHuman * 1.0]
	    set Identite $IdBestProtHuman
	    if {$Identite<0.6} {set Warning 1} else {set Warning ""}
	} else {set DefBestProtHuman ""; set Warning ""}
	
	if {$AccBestmRNAHuman!=""} {
	    set DefBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestmRNAHuman Definition]
	} else {set DefBestmRNAHuman ""}
	
	#Les GOs
	set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO]
	#Les Pathways KEGG
	set LesPathwaysKEGG [InterrogePathways $FichierPathways $Nom LesPathways]
	#Les Domaines PFAMA (Id>0.8) 
	set LesDomainesPFAMA [InterrogeDomaines $Nom LesDomaines]
	
	if {$AccBestProtHuman!=""} {
	    if {$LesGO==""} {set Ontology " "} else {
		set Ontology ""
		foreach GO $LesGO {
		    set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition]
		    append Ontology "$GO $LaDefinitionGO /"
		}
	    }
	    #LesPathways Kegg
	    
	    #Les Domaines
	    if {$LesDomainesPFAMA==""} {set DomainesPFAMA " "} else {
		set DomainesPFAMA ""
		foreach LeDomaine $LesDomainesPFAMA {
		    if {![regexp -nocase "PFAM PF" $LeDomaine]} {continue}
		    set i 0; set Liste ""
		    foreach Do $LeDomaine {
			incr i
			if {$i<4} {lappend Liste $Do}
		    }
		    append DomainesPFAMA "$Liste /"
		}
		#set DomainesPFAMA [join $LesDomaines " /"]
	    }
	} else {set Ontology ""; set Pathways ""; set DomainesPFAMA ""}
	
	AppendAuFichier $FichierSortie "$Nom\t$GN\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Warning\t$Ontology\t$DomainesPFAMA\t$LesPathwaysKEGG"

    }
    

}

proc CreeListeInfosPourWeb {ListeNoms FichierOut} {

    set FichierLocBest "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
    foreach Nom $ListeNoms {
	set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access]
	set DefinitionProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition]
	set Commande "getz -e \"\\\[protein-acc:$AccBestProtHuman\\\]\" \-vf gen"
	set GetzOut [eval exec $Commande]
	if {$GetzOut==""} {
	    set Commande "getz -e \"\\\[protein-id:$AccBestProtHuman\\\]\" \-vf gen"
	    set GetzOut [eval exec $Commande]
	}
	#regsub "^PROTEIN:[a-z]" $AccBestProtHuman "" Access
	set GetzOut [lindex [split [lindex [split $GetzOut "\n"] 0] "\t"] 1]
	#set GetzOut [lindex $LesElts 1]
	set LesLocBest [InterrogeLocalisation $FichierLocBest Nom $Nom]
	if {$LesLocBest==""} {
	    set BandeCyto ""
	} else {
	    foreach Loc $LesLocBest {
		if {[regexp "Best" [lindex $Loc 20]]} {
		    set BandeCyto [lindex $Loc 19]
		    break
		}
	    }
	}
	lappend L "$GetzOut\t$DefinitionProtHuman\t$AccBestProtHuman\t$BandeCyto\t$Nom\tMacsim"
    }
    Espionne [llength $L]
    #set L [lsort $L]
    SauveLesLignes $L dans $FichierOut

}

proc CreeListePourFichierAUneColonne {Fichier} {

#fichier avec un nom par ligne
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" nom
	lappend Liste $nom 
    }
    #Espionne [llength $Liste]
    return $Liste

}

proc CreeListePourFichierAUneLigne {Fichier} {

    if {[llength [LesLignesDuFichier $Fichier]]==1} {
	set Texte [ContenuDuFichier $Fichier]
	set LesMots [split $Texte " "]
	set Liste [join $LesMots "\n"]
    } else {return ""}
    return $Liste

}

proc CreeListeScore {{g ""}} {

    global ListeScore TbScores
    
    if {$g ne ""} {
	EnleveConservationGlobale
    }

    set len [llength [set TbScores(Score,[lindex $TbScores(Lcols) 0 ])]]
    set Lidx [list]
    for {set i 0} {$i < $len} {incr i} {
	lappend Lidx $i
    }

    set ListeScore [list]
    foreach i $Lidx {
	set ligne [list $i]
	set cok 1
	foreach sco [set TbScores(Lcols)] {
	    
	    if {[set val [lindex [set TbScores(Score,$sco)] $i]] == -999.0} {
		set cok 0
		break
	    }
	    lappend ligne $val
	}
	if {$cok} {
	    lappend ListeScore $ligne
	}
    }

    return $ListeScore

}

proc CreeListeTotaleDD {FichierSortie} {

    set FichierProfilDDValidation "[RepertoireDuGenome]/totalite/ValidationProfil.txt"
    if {![file exists $FichierProfilDDValidation]} {return}
    foreach Ligne [LesLignesDuFichier $FichierProfilDDValidation] {
	if {$Ligne=="" || [regexp "user" $Ligne]} {continue}
	set LesChamps [split $Ligne "\t"]
	set Owner [lindex $Ligne 0]
	set CC [lindex $Ligne 2]
	if {$Owner=="F"} {set CC [string toupper $CC]}
	if {$Owner=="I"} {regsub -all "\'" $CC "_" CC}
	set ProfVN [lindex $Ligne 3]
	set ProfNorthern [lindex $Ligne 5]
	
	set PVN($Owner,$CC) $ProfVN
	set PN($Owner,$CC) $ProfNorthern
    }

    set FichierOverlapAvecAffy "[RepertoireDuGenome]/OVERLAP/pourgscope_bestoverlaps_final_profilscorr.txt"
    if {![file exists $FichierOverlapAvecAffy]} {return}
    foreach Ligne [LesLignesDuFichier $FichierOverlapAvecAffy] {
	if {$Ligne==""} {continue}
	set LesOverlaps [split $Ligne "\t"]
	set DD [lindex $Ligne 1]
	set TAR [lindex $Ligne 2]
	set Affy($DD) $TAR
    }

    set LesPbs ""
    set FichierClusters "[RepertoireDuGenome]/fiches/ClustersNew"
    foreach JR [ListeDesJR $FichierClusters] {
	set NbJumeaux ""; set NumGeneDD "";set CodeClone ""; set User ""; set ProfilCalc ""; set ProfilConsensus ""; set AccBestProtHuman "";set DefBestProtHuman ""; set AccBestRNAHuman ""; set DefBestRNAHuman ""; set AccessRefSeq "";set DefRefSeq ""

	set NbJumeaux [NombreDeJumeauxOuListeDesJumeaux $JR $FichierClusters]
	set NumGeneDD [InterrogeFichierTotalDataDD $JR N]
	set CodeClone [InterrogeFichierTotalDataDD $JR Code]
	set User [InterrogeFichierTotalDataDD $JR User]
	set Band [InterrogeFichierTotalDataDD $JR Bande]
	set ProfilCalc [InterrogeFichierTotalDataDD $JR Profil]
	set ProfilConsensus [InterrogeFichierTotalDataDD $JR ProfCons]
	if {$ProfilConsensus=="T" || $ProfilConsensus=="N" || $ProfilConsensus=="C" } {
	    set ProfilDD $ProfilConsensus
	} else {set ProfilDD $ProfilCalc}
	#validation du profil: Virtual northern et Northern
	if {[info exists PVN($User,$CodeClone)]} {set ProfilVN $PVN($User,$CodeClone)} else {lappend LesPbs "$User $CodeClone"; set ProfilVN ""}
	if {[info exists PN($User,$CodeClone)]} {set ProfilNorthern $PN($User,$CodeClone)} else {set ProfilNorthern ""}

	set AccBestProtHuman [InterrogeFichierDDUniques3T $NumGeneDD AccProt]
	set DefBestProtHuman [InterrogeFichierDDUniques3T $NumGeneDD DefProt]
	set AccBestRNAHuman [InterrogeFichierDDUniques3T $NumGeneDD AccRNA]
	set DefBestRNAHuman [InterrogeFichierDDUniques3T $NumGeneDD DefRNA]
	set AccessRefSeq [InterrogeFichierBestNMavecDef $JR NM]
	set DefRefSeq [InterrogeFichierBestNMavecDef $JR Def]

	# Affy
	if {[info exists Affy($JR)]} {
	    set PresentSurAffy 1
	    set Target $Affy($JR)
	    set ProfilMoy [InterrogeFichierDataAffyPourTous3T $Target ProfMoy]
	} else {set PresentSurAffy 0; set ProfilMoy ""}
	# Sequence DD
	set FichierNucTfa "[RepertoireDuGenome]/nuctfa/$JR"
	if {![file exists $FichierNucTfa]} {set Seq ""; set LSeq ""}
	set Seq [QueLaSequenceDuFichierTFA $FichierNucTfa]
	set LSeq [string length $Seq]

	# Localisation
	set SourceLoc ""
	set BandeCyto ""
	set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human"
	set LesLocs [InterrogeLocalisation $FichierLoc Nom $JR]
	if {$LesLocs!=""} {
	    foreach Loc $LesLocs {
		if {[regexp -nocase "best" [lindex $Loc 20]]} {
		    set SourceLoc [lindex $Loc 21]
		    set BandeCyto [lindex $Loc 19]
		    break
		}
	    }
	} else {
	    set FichierLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best"
	    set LesLocs [InterrogeLocalisation $FichierLoc Nom $JR]
	    if {$LesLocs!=0} {
		foreach Loc $LesLocs {
		    set BandeCyto [lindex $Loc 19]
		    break
		}
		set Source "DD sequence"
	    }
	}
	#if {$JR=="DD0004"} {FaireLire "$FichierLoc - [llength $Loc] - $BandeCyto"}

	AppendAuFichier $FichierSortie "$NumGeneDD\t$JR\t$CodeClone\t$NbJumeaux\t$LSeq\t$ProfilDD\t$ProfilVN\t$ProfilNorthern\t$PresentSurAffy\t$ProfilMoy\t$BandeCyto\t$SourceLoc\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestRNAHuman\t$DefBestRNAHuman\t$AccessRefSeq\t$DefRefSeq\t$Seq"
    }
    Espionne [llength $LesPbs]
    return $LesPbs

}

proc CreeListesPourRavi {{Liste ""}} {

    set 7tm 0; set rho 0; set LesLignesGen {}; set LesLignesRho {}; set LesLignes7tm {}
    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    foreach Nom $Liste {
	set access  [AccessEvi $Nom]
	set probeset [ExtraitInfo $Nom "ProbeSetId"]

	set status  [ExtraitInfo $Nom "Status"]
	set CompOpt [string range $status 0 [expr [string first "(" $status] - 1]]
	set pointe  [string range $status [string first "(" $status] [string first ")" $status]]
	set ListeDestinataire [split $pointe {(,)}]
	set ListeDestinataire [ListeSsElmtVide $ListeDestinataire]

	set LigneGen "$Nom;$access;$probeset"
	lappend LesLignesGen $LigneGen

	if {[regexp {^comp} $CompOpt]} {
	    incr rho
	    set LigneRho "$Nom;$access;$probeset"
	    lappend LesLignesRho $LigneRho
	}
 
	foreach elmt $ListeDestinataire {
	    if {[regexp {7TM} $elmt]} {
		incr 7tm
		set Ligne7tm "$Nom;$access;$probeset"
		lappend LesLignes7tm $Ligne7tm
	    }
	}
    }
    puts "rho $rho"
    puts "7tm $7tm"
    SauveLesLignes $LesLignesGen dans "[RepertoireDuGenome]/ListePourRavi/ListeTotal"
    SauveLesLignes $LesLignesRho dans "[RepertoireDuGenome]/ListePourRavi/ListeRho"
    SauveLesLignes $LesLignes7tm dans "[RepertoireDuGenome]/ListePourRavi/Liste7tm"

}

proc CreeLookupNoms {} {

    global LookupNoms
    global ListeNomAssocieALAccess

    foreach d $ListeNomAssocieALAccess {
	lassign $d n1 n2
	set LookupNoms($n1) $n2
	set LookupNoms($n2) $n1
    }

    return

}

proc CreeMouseRatJunctionIDV {} {

    set LongDemiJunction 50
    foreach Org [list mouse rat] {
	if {$Org=="mouse"} {
	    set OrgSeq "Mus_musculus"
	    set BigZips "bigZips200707"
	}
	if {$Org=="rat"} {
	    set OrgSeq "Rattus_norvegicus"
	    set BigZips "bigZips200603"
	}
	set OrgBED [string toupper $Org]
	if {$OrgBED=="MOUSE"} {set OrgBED "SOURIS"}
	set FileBED "/genomics/link/SpliRetMouse/201404/cds${OrgBED}-06092011.bed"
	
	foreach Var [InterrogeBED ListOf name $FileBED] {
	    Espionne "$Var"
	    set LesClu {}; set LesGn {}
	    set Clu ""; set Gn ""
	    set LesClu [InterrogeClusters $Var Clu $Org]
	    set Clu [join $LesClu "-"]
	    if {$LesClu!={}} {
		foreach LeClu $LesClu {
		    set Gn [InterrogeClusters $LeClu Gn $Org]
		    lappend LesGn $Gn
		}
		set LesGn [ListeSansDoublon $LesGn]
		set Gn [join $LesGn "-"]
	    } 

	 #   if {![regexp "Meis2" $Gn] && ![regexp "Otx2" $Gn] && ![regexp "Rax" $Gn] && ![regexp "Ring1" $Gn] && ![regexp "Rorb" $Gn] && ![regexp "Vax2" $Gn]} {continue}
	 #  if {![regexp "Otx2" $Gn]} {continue}
	  
	    set Chr           [InterrogeBED $Var "chrom" $FileBED]
	    set CoordStart    [InterrogeBED $Var "chromStart" $FileBED]
	    set CoordStop     [InterrogeBED $Var "chromEnd" $FileBED]
	    set CoordCodStart [InterrogeBED $Var "thickStart" $FileBED]
	    set CoordCodStop  [InterrogeBED $Var "thickEnd" $FileBED]
	    set BlockCount    [InterrogeBED $Var "blockCount" $FileBED]
	    set BlockSizes    [InterrogeBED $Var "blockSizes" $FileBED]
	    set LesBlockSizes  [split $BlockSizes ","]
	    set BlockStarts   [InterrogeBED $Var "blockStarts" $FileBED]
	    set LesBlockStarts [split $BlockStarts ","]
		
	    #pas de junction possible
	    if {$BlockCount==1} {continue}
	    
	    set LesBlockSizes  [lrange $LesBlockSizes 0 end-1]
	    set LesBlockStarts [lrange $LesBlockStarts 1 end]
	    
	    #le .bed est en 0-based start and 1-based end
	    #pour utiliser BoutADN il faut etre en 1-based start and 1-based end, pour cela on rajoute +1 au start
	    #pour calculer la nouvelle coord quand on rajoute ou soustrait une longueur a une coord, il faut -1 a la longueur 
	    set premierefois 1
	    set CoordStart [expr $CoordStart + 1]
	    set CoordStartGn $CoordStart
	    set numerojunction 0
	    foreach BlockSize $LesBlockSizes BlockStart $LesBlockStarts {
		set JunctionsFromIdv {}
		incr numerojunction
		#	    Espionne "$Var $numerojunction"
		if {$premierefois} {
		    set CoordStartEx $CoordStart
		    set premierefois 0
		} else {
		    set CoordStartEx $CoordStartExonD
		}
		set CoordStopExonG  [expr $CoordStartEx + $BlockSize - 1]
		set CoordStartExonD [expr $CoordStartGn + $BlockStart]
		set Deb1 [expr $CoordStopExonG - ($LongDemiJunction -1)]
		set Fin1 $CoordStopExonG
		set seq1 [BoutADNDeUcsc $Deb1 $Fin1 "F" $OrgSeq $Chr $BigZips]
		#	    Espionne "$Deb1 $Fin1"
		#	    Espionne "BoutADNDeUcsc $Deb1 $Fin1 F $OrgSeq $Chr $BigZips"
		#	    Espionne "$seq1"
		set Deb2 $CoordStartExonD
		set Fin2 [expr $CoordStartExonD + ($LongDemiJunction -1)]
		set seq2 [BoutADNDeUcsc $Deb2 $Fin2 "F" $OrgSeq $Chr $BigZips]
		#	    Espionne "$Deb2 $Fin2"
		#	    Espionne "BoutADNDeUcsc $Deb2 $Fin2 F $OrgSeq $Chr $BigZips"
		#	    Espionne "$seq2"
		set seq "${seq1}$seq2"
		#	    Espionne "$seq"

		#si la jonction se trouve dans de l'exon non codant, on l elimine
		if {$Deb1<$CoordCodStart || $Fin2<$CoordCodStart} {continue}
		if {$Deb1>$CoordCodStop || $Fin2>$CoordCodStop} {continue}

		set Junction "${Chr}_${Deb1}-${Fin2}_${Org}"
		set VarJunc  "${Var}_${numerojunction}_${Gn}_${Clu}_${Org}"

		lappend LesVarDeJunction($Junction,VarJunc,$Org) $VarJunc
		if {[info exists DejaVu($Junction)]} {continue}
		set DejaVu($Junction) 1
		lappend LesJunctions $Junction

		lappend JunctionsFromIdv ">${Chr}_${Deb1}-${Fin2}_${Org}"
		lappend JunctionsFromIdv "$seq"
		SauveLesLignes $JunctionsFromIdv dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/All${Org}/${Chr}_${Deb1}-${Fin2}_${Org}.tfa"		    
	    }
	}
	foreach Junction $LesJunctions {
	    set LesVarJunc [ListeSansDoublon $LesVarDeJunction($Junction,VarJunc,$Org)]
	    set VarJunc [join $LesVarJunc " "]
	    lappend JunctionVarJunc "$Junction\t$VarJunc"
	}
	SauveLesLignes $JunctionVarJunc dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/CorresJuncVar_$Org"
    }

}

proc CreeMsfSelonNature {methode} {


    #set Lpab [ListeDesPABs]
    #set Lpab [lrange $Lpab 804 804]

    foreach pab [ListeDesPABs] {
	puts "traite $pab"
	set fileMSF [file join [RepertoireDuGenome] "msf_nature" "Rascal" "Leon" $pab]
	set newFileMSF [file join [RepertoireDuGenome] "msf_Sel$methode" $pab]
	set fileSel [file join [RepertoireDuGenome] "msf_$methode" $pab]
	set tmpFile [file join [RepertoireDuGenome] "tmp" $pab]
	set tmpFile2 [file join [RepertoireDuGenome] "tmp" "tmp$pab"]
	set msf2tfa "/home/moumou/bin/msf2tfa"
	set tfa2msf "/home/moumou/bin/tfa2msf"

	if {![file exists $fileMSF] || ![file exists $fileSel]} {continue}

	if {![file exists $tmpFile]} {
	    exec $msf2tfa $fileMSF $tmpFile
	}

	if {[file exists $tmpFile]} {
	    DecortiqueMSF $fileSel LNOrdali Sequences
	    set f [open $tmpFile2 w]

	    foreach l [LesLignesDuFichier $tmpFile] {
		if { [regexp ">" $l] } {
		    set test 0
		    if {[regexp -nocase [string range $l 1 end] $LNOrdali] } {
			set test 1
		    } else {set test 0}
		}
		if {$test==1} {
		    puts $f $l

		}

	    }
	    close $f

	    exec $tfa2msf $tmpFile2 $newFileMSF
	    if {[file exists $tmpFile]} {
		exec rm $tmpFile
	    }
	    if {[file exists $tmpFile2]} {
		exec rm $tmpFile2
	    }
	}
    }

    return 1

}

proc CreeMultiTfaDeTousLesAdd {Org} {

    #multitfa necessaire pour creer banque blast
    if {$Org=="Test"} {
	set RepertoireSourisTfactor "[RepertoireDuGenome]/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai"
	set RepertoireSourisOthers  "[RepertoireDuGenome]/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai"
	set RepertoireSourisNoAlt   "[RepertoireDuGenome]/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai"
	set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNoAlt]
    }
    if {$Org=="Mouse"} {
	set LesRepertoires [LesRepertoires "Mouse" "Mod"]
    }
    if {$Org=="Rat"} {
	set LesRepertoires [LesRepertoires "Rat" "Mod"]
    }
    foreach Repertoire $LesRepertoires {
	foreach Fichier [glob -nocomplain "$Repertoire/*"] {
	    foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" "ForceAccessFirst"] {
		set TFA  [LaSequenceDuTFAs $Fichier $Access]
		if {![info exists DejaVu($Access)]} {
		    lappend LesLignesFinal $TFA
		    set DejaVu($Access) 1
		} 
	    }
	    #foreach Ligne [LesLignesDuFichier $Fichier] {lappend LesLignesFinal $Ligne}
	}
    }
    set LesLignesFinal [EnleveLignesVides $LesLignesFinal]
   # SauveLesLignes $LesLignesFinal dans "[RepertoireDuGenome]/FichiersModifUnique/TousLesAdd$Org"

}

proc CreeNouveauArbre {t n l} {

    return [list $t {} [list name $n length $l AngAbs 0. ordre 0 theta 0. oldtheta 0. r 0. width 0]]

}

proc CreeNouveauArbreTax {tx nm rk pa} {

    set ::Tn($tx,Parent) $pa
    set ::Tn($tx,TaxId) $tx
    set ::ATree($tx) [list $tx {} [list taxid $tx name $nm rank $rk parent $pa count 0 gold 0 model 0]]

    return

}

proc CreeNouveauRepNuctfa {NewRep} {

    if {![file exists $NewRep]} {file mkdir $NewRep}
    foreach Nom [ListeDesPABs] {
	set Fichier1 "[RepertoireDuGenome]/nuctfa_SansBoutPlasmideEtBonSens/$Nom"
	set Fichier2 "[RepertoireDuGenome]/nuctfa/$Nom"
	set Fichier3 "$NewRep/$Nom"
	if {[file exists $Fichier1]} {
	    file copy $Fichier1 $Fichier3
	} elseif {[file exists $Fichier2]} {
	    file copy $Fichier2 $Fichier3
	} else {Espionne "$Nom est sans nuctfa!!!"}
    }

}

proc CreeNouveauxFichiersTFA {} {

    set RepDestination [ ChoisirUnRepertoire "Repertoire De Destination Des SeqTfa"]
    set RepOrigine [ ChoisirUnRepertoire "Repertoire Contenant Toutes Les SeqTfa D Origine"]
    set Listepasbon {}
    set Listebon {}
    foreach Fichier [ glob -nocomplain "$RepOrigine/*" ] {
	if { ! [file exists $Fichier ] } {continue}
	set Sequence [ QueLaSequenceDuFichierTFA $Fichier ]
	set Contenu [ ContenuDuFichier $Fichier]
	regsub "^>" $Contenu "" NouveauContenu
	scan $NouveauContenu "%s %s %s" GscopeCode CodeClone User
	#probleme avec l'underscore dans certains codes clones:
	if {[regexp -nocase "M-^R" $CodeClone]} {
	    set OldCodeClone $CodeClone
	    regsub  -nocase "M-^R" $OldCodeClone "_" CodeClone 
	    Espionne "$CodeClone $OldCodeClone $User $Fichier"
	}

	#if {$CodeClone == "1-1"} { Espionne "$CodeClone $User trouve!"}
	set Entete ">$CodeClone $User"
	set TexteTFA [ SequenceFormatTFA $Sequence $Entete]
	if {[file exists "$RepDestination/${CodeClone}_$User.tfa"]} {
	    lappend Listepasbon "$CodeClone\t$User\t$Fichier"
	} else {
	    lappend Listebon "$CodeClone\t$User\t$Fichier"
	}

	#Espionne $TexteTFA
	Sauve $TexteTFA dans "$RepDestination/${CodeClone}_$User.tfa"
    }
    Sauve [join [lsort -dictionary $Listepasbon] "\n"] dans pasbon.coucou
    Sauve [join [lsort -dictionary $Listebon] "\n"] dans bon.coucou

}

proc CreeNuctfaPourDesignOligo1500 {} {

    set RepertoireDeSortie "[RepertoireDuGenome]/Arnaud/nuctfa1500"
    set RepertoireDeSortieCompul "[RepertoireDuGenome]/Arnaud/nuctfaComp"

    set FichierSup "[RepertoireDuGenome]/Reduction/LesSupplementaires"
    
    set FichierRedondantQue78 "[RepertoireDuGenome]/Reduction/ListeDesRedondantsQue78"
    set FichierParalogueQue78 "[RepertoireDuGenome]/Reduction/ListeDesParaloguesQue78"
    set FichierRedondantQue7  "[RepertoireDuGenome]/Reduction/ListeDesRedondantsQue7"

    set LesRedondantsQue78 [lindex [LesLignesDuFichier $FichierRedondantQue78] 0]
    set LesParaloguesQue78 [lindex [LesLignesDuFichier $FichierParalogueQue78] 0]
    set LesRedondantsQue7  [lindex [LesLignesDuFichier $FichierRedondantQue7] 0]
    set ListeRedondantsQue78 [split $LesRedondantsQue78 " "]
    set ListeParaloguesQue78 [split $LesParaloguesQue78 " "]
    set ListeRedondantsQue7  [split $LesRedondantsQue7 " "]

    set FichierCopsCompul7 "[RepertoireDuGenome]/transcriptomique/LesCopsCompul/copsfinal7"
    set LigneDesGenes7 [lindex [LesLignesDuFichier $FichierCopsCompul7] 0]
    set ListeGn7 [split $LigneDesGenes7 " "]

    set FichierCopsCompul8 "[RepertoireDuGenome]/transcriptomique/LesCopsCompul/copsfinal8"
    set LigneDesGenes8 [lindex [LesLignesDuFichier $FichierCopsCompul8] 0]
    set ListeGn8 [split $LigneDesGenes8 " "]

    set LesLignesExl [NomLigne ListeDes Lignes]
    set nblignesExl 0
    set bidon 0; set redon 0; set paral 0; set compulsory 0; set septhuit 0

    foreach LigneExl $LesLignesExl {

 	incr nblignesExl
	set ListeDesNoms {}; set BonneListeDesNoms {}
	
	set TousLesNoms  [NomLigne $LigneExl Noms]
	set ListeDesNoms [split $TousLesNoms " "]
	set NbDeNomPrUneLigne [llength $ListeDesNoms]
	
	if {[llength $ListeDesNoms]==1} {
	    set BonneListeDesNoms $ListeDesNoms
	}
	if {[llength $ListeDesNoms]>1} {
	    set BonneListeDesNoms [split [RangeMoi get EviOf $LigneExl] " "]
	}
	
	foreach Nom $BonneListeDesNoms {
	    set onaredon 0; set onaparal 0
	    #Espionne "$LigneExl $Nom"
	    foreach Redond $ListeRedondantsQue78 {
		if {$Redond==$Nom} {
		    set onaredon 1
		    Espionne "$Nom Redond"
		    break
		}
	    }
	    if {$onaredon} {
		incr redon
		continue
	    }

	    foreach Paral $ListeParaloguesQue78 {
		if {$Paral==$Nom} {
		    set onaparal 1
		    Espionne "$Nom Paralo"
		    break
		}
	    }
	    if {$onaparal} {
		incr paral
		continue
	    }

	    set ona7 0; set ona8 0
	    set Gn ""; set TissueType ""
	    set Gn [ExtraitInfo $Nom "ValiGN"]
	    set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	    if {![file exists $Fichier]} {continue}
	    set Queue [file tail $Fichier]
	    
	    set LesLignes [LesLignesDuFichier $Fichier]
	    set premiereligne [lindex $LesLignes 0]
	    if {[regexp "bidon" $premiereligne]} {
		Espionne "$Nom bidon"
		incr bidon
		continue
	    }

	    set ona7 0; set ona8 0
	    set Status [ExtraitInfo $Nom "Status"]
	    set Status [string range $Status 0 [expr [string first "\(" $Status] - 1]] 
	    if {$Status=="compulsory"} {
		if {$Nom=="EVI25020" || $Nom=="EVI25030" || $Nom=="EVI25040"} {continue}
		incr compulsory
		Espionne "$Nom compulsory $compulsory"
		#file copy -force $Fichier $RepertoireDeSortie/$Queue
		#file copy -force $Fichier $RepertoireDeSortieCompul/$Queue
		continue
	    }
	 
	    foreach Gn8 $ListeGn8 {if {$Gn == $Gn8} {set ona8 1}}
	    foreach Gn7 $ListeGn7 {if {$Gn == $Gn7} {set ona7 1}}
	    if {$ona7 && $ona8} {
		incr septhuit
		Espionne "$Nom +7+8"
		#file copy -force $Fichier $RepertoireDeSortie/$Queue
		continue
	    }

	    if {$Nom=="EVI03330"} {
		Espionne "$Nom cxcr4"
		#file copy -force $Fichier $RepertoireDeSortie/$Queue
		continue
	    }
	}
    }  
    set nblignes 0; set sept 0; set redonque7 0
    foreach Ligne [LesLignesDuFichier $FichierSup] {
	set onaredonque7 0
	scan $Ligne "%s" Nom
	set Status [ExtraitInfo $Nom "Status"]
	set Status [string range $Status 0 [expr [string first "\(" $Status] - 1]] 
	if {$Status=="compulsory"} {continue}
	set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	if {![file exists $Fichier]} {continue}
	set Queue [file tail $Fichier]

	foreach RedondQue7 $ListeRedondantsQue7 {
	    if {$RedondQue7==$Nom} {
		set onaredonque7 1
		Espionne "$Nom RedondQue7"
		break
	    }
	}
	if {$onaredonque7} {
	    incr redonque7
	    continue
	}
	incr nblignes	
	if {$nblignes>=113} {continue}
	incr sept
	Espionne "$Nom +7-8 $sept"
	#file copy -force $Fichier $RepertoireDeSortie/$Queue
    }
    
    Espionne "bidon $bidon"
    Espionne "redon $redon"
    Espionne "paral $paral"
    Espionne "redonque7 $redonque7"
    Espionne "compulsory $compulsory"
    Espionne "septhuit $septhuit"
    Espionne "sept $sept"
    Espionne "plus un: cxcr4" 

}

proc CreeNuctfaPourDesignOligo1500PourCompul {} {

    set RepertoireDeSortieCompul "[RepertoireDuGenome]/Arnaud/nuctfaComp3eme"
   
    set FichierRedondantQue78 "[RepertoireDuGenome]/Reduction/ListeDesRedondantsQue78"
    set FichierParalogueQue78 "[RepertoireDuGenome]/Reduction/ListeDesParaloguesQue78"
    set FichierRedondantQue7  "[RepertoireDuGenome]/Reduction/ListeDesRedondantsQue7"

    set LesRedondantsQue78 [lindex [LesLignesDuFichier $FichierRedondantQue78] 0]
    set LesParaloguesQue78 [lindex [LesLignesDuFichier $FichierParalogueQue78] 0]
    set LesRedondantsQue7  [lindex [LesLignesDuFichier $FichierRedondantQue7] 0]
    set ListeRedondantsQue78 [split $LesRedondantsQue78 " "]
    set ListeParaloguesQue78 [split $LesParaloguesQue78 " "]
    set ListeRedondantsQue7  [split $LesRedondantsQue7 " "]

    set LesLignesExl [NomLigne ListeDes Lignes]
    set nblignesExl 0
    set bidon 0; set redon 0; set paral 0; set compulsory 0; set septhuit 0

    foreach LigneExl $LesLignesExl {

 	incr nblignesExl
	set ListeDesNoms {}; set BonneListeDesNoms {}
	
	set TousLesNoms  [NomLigne $LigneExl Noms]
	set ListeDesNoms [split $TousLesNoms " "]
	set NbDeNomPrUneLigne [llength $ListeDesNoms]
	
	if {[llength $ListeDesNoms]==1} {
	    set BonneListeDesNoms $ListeDesNoms
	}
	if {[llength $ListeDesNoms]>1} {
	    set BonneListeDesNoms [split [RangeMoi get EviOf $LigneExl] " "]
	}
	
	foreach Nom $BonneListeDesNoms {
	    set onaredon 0; set onaparal 0
	    #Espionne "$LigneExl $Nom"
	    foreach Redond $ListeRedondantsQue78 {
		if {$Redond==$Nom} {
		    set onaredon 1
		    Espionne "$Nom Redond"
		    break
		}
	    }
	    if {$onaredon} {
		incr redon
		continue
	    }

	    foreach Paral $ListeParaloguesQue78 {
		if {$Paral==$Nom} {
		    set onaparal 1
		    Espionne "$Nom Paralo"
		    break
		}
	    }
	    if {$onaparal} {
		incr paral
		continue
	    }

	    set ona7 0; set ona8 0
	    set Gn ""; set TissueType ""
	    set Gn [ExtraitInfo $Nom "ValiGN"]
	    set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
	    if {![file exists $Fichier]} {continue}
	    set Queue [file tail $Fichier]
	    
	    set LesLignes [LesLignesDuFichier $Fichier]
	    set premiereligne [lindex $LesLignes 0]
	    if {[regexp "bidon" $premiereligne]} {
		Espionne "$Nom bidon"
		incr bidon
		continue
	    }

	    set ona7 0; set ona8 0
	    set Status [ExtraitInfo $Nom "Status"]
	    set Status [string range $Status 0 [expr [string first "\(" $Status] - 1]] 
	    if {$Status=="compulsory"} {
		if {$Nom=="EVI25020" || $Nom=="EVI25030" || $Nom=="EVI25040"} {continue}
		incr compulsory
		Espionne "$Nom compulsory $compulsory"
		file copy -force $Fichier $RepertoireDeSortieCompul/$Queue
		continue
	    }
	}
    }

}

proc CreeNuctfaSupp {} {

    set RepertoireDesAjouter  "[RepertoireDuGenome]/Arnaud/nuctfaSup"
    set RepertoireDesModifier "[RepertoireDuGenome]/Arnaud/nuctfaMod"
    set RepertoireDesModifier2 "[RepertoireDuGenome]/Arnaud/nuctfaMod2"

    set ListeDesAjouter [list "EVI26300" "EVI16990" "EVI33750" "EVI03410" "EVI27381" "EVI26070" "EVI11157" "EVI19394"]
    set ListeDesModifier [list "EVI08520" "EVI08530" "EVI22270" "EVI24960"]
    set ListeDesModifier2 [list "EVI18700" "EVI24390"]

    foreach NomAjouter $ListeDesAjouter {
	set Fichier "[RepertoireDuGenome]/nuctfa/$NomAjouter"
	if {![file exists $Fichier]} {continue}
	set Queue [file tail $Fichier]
	#file copy -force $Fichier $RepertoireDesAjouter/$Queue
    }
    foreach NomModifier $ListeDesModifier {
	set Fichier "[RepertoireDuGenome]/nuctfa/$NomModifier"
	if {![file exists $Fichier]} {continue}
	set Queue [file tail $Fichier]
	#file copy -force $Fichier $RepertoireDesModifier/$Queue
    }
     foreach NomModifier2 $ListeDesModifier2 {
	set Fichier "[RepertoireDuGenome]/nuctfa/$NomModifier2"
	if {![file exists $Fichier]} {continue}
	set Queue [file tail $Fichier]
	file copy -force $Fichier $RepertoireDesModifier2/$Queue
    }

}

proc CreeObjBali {f} {


    foreach p $::ListePDB {
	lappend ::StrucAVoir [string range $p 4 end]
    }

    foreach p $::ListePDB {
	if {[info exists ::TabSF(${p},BLOCK)]} {
	    break
	}
    }

    # superposition
    foreach f [set ::TabSF(${p},BLOCK)] {
	DecortiqueUneFeature $f dg fg col sc nt
	set ::PositionInitiale "1.$dg"
	SelectLesColonnes "1.$fg"
    }
    FaitSuperposition
    
    #object ActiveSite
    foreach p $::ListePDB {
	set nom [DonneIdDeAccessPDB $p]
	set chn [DonneChainDeAccessPDB $p]
	
	# create CA obj anyway
	$nom newObj "CT${nom}_$chn"
	$nom select chain $chn
	$nom catrace "CT${nom}_$chn"

	# create CA-Trace obj anyway
	$nom newObj "CT${nom}_$chn"
	$nom select chain $chn
	$nom catrace "CT${nom}_$chn"

	if {! [info exists ::TabSF(${p},ActiveSite)]} {
	    continue
	}

	set LSite [$nom GiveVar Site]
	unset -nocomplain St
	array set St $LSite
	$nom newObj "Site_${nom}_$chn"
	set Lsnm [list]
	set Lres [$nom _resnumber -chain $chn -polymer]
	
	foreach s [array names St] {
	    foreach {r c nm} [set St($s)] {
		if {$c ne $chn} {continue}
		if {$r ni $Lres} {continue}
		lappend Lsnm $r
	    }
	}
	set Lsnm [lsort -unique -integer $Lsnm]

	$nom select resid [join $Lsnm ,] and chain $chn
	$nom selcolor mageneta
	$nom atomes "Site_${nom}_$chn"
    }

    return

}

proc CreeOrdalieStarpack {plat} {


    # kbstcl a executer est dependant de la platform
    # sur laquelle on est
    #
    package require platform
    switch [::platform::generic] {
	"win32-ix86" {set ekit kbstcl.exe}
	"linux-ix86" {set ekit kbstcl-x86}
	"linux-x86_64" {
	    #set ekit kbstcl-x86_64
	    set ekit tclkit-x86_64
	}
	"macosx-ix86" {set ekit kbstcl-macosx}
    }
    
    # plat definit la cible, c'est a dire l executable 
    # donne a sdx.kit (-runtime argument)
    switch $plat {
	"Windows" -
	"win32-ix86" {
	    set rtime kbstclcopy.exe
	    set ordex ordalie.exe
	}
	"linux-ix86" -
	"Linux-x86" {
	    set rtime kbstclcopy-x86
	    set ordex ordalie
	}
	"linux-x86_64" -
	"Linux-x86_64" {
	    #set rtime kbstclcopy-x86_64
	    set rtime tclkitcopy-x86_64
	    set ordex ordalie
	}
	"macosx-ix86" -
	"Mac" {
	    set rtime kbstclcopy-macosx
	    set ordex ordalie
	}
    }
    puts "CreeOrdaliStarpack $plat"
    exec ./$ekit sdx.kit qwrap  ordalie.tcl
    exec ./$ekit sdx.kit unwrap ordalie.kit
    
    # Rajoute LRIPhoto
    file copy -force [file join [pwd] .. .. Extensions AllPlatform LRIPhoto] [file join ordalie.vfs lib]
    
    exec ./$ekit sdx.kit wrap $ordex -runtime $rtime
    
    file delete -force ordalie.vfs
    file delete -force ordalie.kit
    file delete -force ordalie.tcl
    
    return

}

proc CreeOrdresTries {Couleur} {

    global LesOrdresTries
    global LimiteGauche LimiteDroite

    scan [BoundingBox [ListeDeBoites]] "%d %d" xDebut xFin
    set xDebut [Maxi 1 [expr $xDebut-3000]]
    incr xFin 1000
    set LimiteGauche $xDebut
    set LimiteDroite $xFin
    set LO [GscopeBoard titi PourGif]	    
    RedefinirLaCouleur OrdrePourGif $Couleur
    set LesOrdresTries($Couleur) [LesOrdresPourGif $LO]
    return $LesOrdresTries($Couleur)

}

proc CreeOreilleGeneraliste {CanalClient IpLocal PortSavant} {

    fconfigure $CanalClient -blocking 0 -buffering line -eofchar \x04
    fileevent  $CanalClient readable [list Generaliste $CanalClient]
    return     $CanalClient

}

proc CreeOrthoBlastP {{NomVoulu ""}} {

    global RepertoireDuGenome
    set FichierOBP "$RepertoireDuGenome/fiches/orthoblastp"

    set ApnsOnly 0
    set DaedalusOnly [OuiOuNon "Do I use only the organisms I'll find in the DaedalusHit files ?"]
    if { ! $DaedalusOnly} {
	set ApnsOnly [OuiOuNon "Do I use only the organisms I'll find in the ./apns files ?"]
    }

    while {[file exists $FichierOBP]} {
	if {[OuiOuNon "$FichierOBP already exists\nDo I replace it ?"]} {
	    File delete -force $FichierOBP
	    continue
	}
	if {[OuiOuNon "$FichierOBP already exists\nDo I append to it (keeping existing lines) ?"]} {
	    foreach Ligne [LesLignesDuFichier $FichierOBP] {
		scan $Ligne "%s" Nom
		set DejaVu($Nom) 1
	    }
	    break
	}
    }

    set SeuilExpect 0.001
    scan [TailleSortiePourDBClustal] "%d %d" MinObliges MaxVoulus
    set MaxListe [Maxi 250 [expr 3*$MaxVoulus]]

    if {$NomVoulu==""} {
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $NomVoulu]
    }

    if {$DaedalusOnly} {
	foreach Nom $Liste {
	    Espionne "Je repertorie les cops de $Nom"
	    if {[info exists DejaVu($Nom)]} { continue }
	    set FichierDaedalus "$RepertoireDuGenome/daedalushits/$Nom"
	    if { ! [file exists $FichierDaedalus]} { continue }
	    set nLu 0
	    set MesOrgas {}
	    foreach Ligne [LesLignesDuFichier $FichierDaedalus] {
		set Valeurs [ValeurDeLaBalise BlastHit Ligne "" BH]
		ValeurDeLaBalise AC Valeurs "NePasRogner" AC
#		ValeurDeLaBalise ID Valeurs "NePasRogner" ID
		ValeurDeLaBalise PN Valeurs "NePasRogner" PN
#		ValeurDeLaBalise OX Valeurs "NePasRogner" OX
#		ValeurDeLaBalise GN Valeurs "NePasRogner" GN
#		ValeurDeLaBalise DE Valeurs "NePasRogner" DE
		ValeurDeLaBalise OS Valeurs "NePasRogner" OS

		if {[EstUnAccessPDB $AC]} { continue }
		if {$PN > $SeuilExpect} { break }
		if {[incr nLu] > $MaxListe} { break }
		scan $OS "%s %s" Genre Espece
		regsub -all {[\.\,\;]} $Espece "" Espece
		set Orga "${Genre}_$Espece"
		lappend MesOrgas $Orga
	    }
	    set MoiEtMesOrgas "$Nom [join $MesOrgas " "]"
	    Espionne $MoiEtMesOrgas
	    if {$MesOrgas!={}} { AppendAuFichier $FichierOBP $MoiEtMesOrgas }
	}
    } else {
	foreach Nom $Liste {
	    Espionne "Je repertorie les cops de $Nom"
	    if {[info exists DejaVu($Nom)]} { continue }
	    set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
	    if { ! [file exists $FichierAPNs]} { continue }
	    set nLu 0
	    set LesAccess {}
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		scan $Ligne "%s %s %s" BanqueId Access Expect
		if {[EstUnAccessPDB $BanqueId]} { continue }
		incr nLu
		if {$Expect > $SeuilExpect} { break }
		if {$nLu    > $MaxListe} { break }
		lappend LesAccess $Access
		set GEs ""
		regsub " *$BanqueId +$Access +$Expect *" $Ligne "" GEs
		if { ! [regexp -nocase {[a-z]} $GEs]} { continue }
		set OrgaTrouve([string toupper $Access]) $GEs
	    }
	    if { ! $ApnsOnly} {
		foreach AGEs [LesOrgasDesAccess $LesAccess] {
		    scan $AGEs "%s" A
		    regsub "$A " $AGEs "" GEs
		    regsub {(^|\:)Inconnu inconnu($|\:)} $GEs "" GEs
		    if {$GEs==""} { continue }
		    set OrgaTrouve([string toupper $A]) $GEs
		}
	    }
	    set MesOrgas {}
	    set nLu 0
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		scan $Ligne "%s %s %f" BanqueId Access Expect
		if {[EstUnAccessPDB $BanqueId]} { continue }
		incr nLu
		if {$Expect > $SeuilExpect} { break }
		if {$nLu    > $MaxListe} { break }
		set ACCESS [string toupper $Access]
		set Orgas ""
		if {[info exists OrgaTrouve($ACCESS)]} {
		    set Orgas [set OrgaTrouve($ACCESS)]
		} else {
		    if { ! $ApnsOnly } {
			set Orgas [OrgaDuAccess $Access Complet $BanqueId]
		    }
		}
		foreach Orga [split $Orgas ":"] {
		    if {$Orga=="" || $Orga=="Inconnu inconnu"} { continue }
		    regsub " " $Orga "_" Orga
		    lappend MesOrgas $Orga
		}
	    }
	    if {$MesOrgas!={}} { AppendAuFichier $FichierOBP "$Nom [join $MesOrgas " "]" }
	}
    }
    return $FichierOBP

}

proc CreeOrthoTBlastN {} {

    global RepertoireDuGenome

    set FichierOrthoTBlastN "$RepertoireDuGenome/fiches/orthotblastn"

    set FichierOuATapeTBN "$RepertoireDuGenome/fiches/ouatapetbn.genomes"
    while { ! [file exists $FichierOuATapeTBN]} {
	if { ! [OuiOuNon "$FichierOuATapeTBN\n doesn't exist \n Do You want to do it now ?" 0]} { return "" }
	AnalyseLesTBlastN
	return ""
    } 

    set ToggleOrgaPositions 1
    foreach Ligne [LesLignesDuFichier $FichierOuATapeTBN] {
	if {$ToggleOrgaPositions} {
	    scan $Ligne "%s" Nom
	    set LesOrgas [lrange [split $Ligne " "] 1 end]
	    set ToggleOrgaPositions [expr ! $ToggleOrgaPositions]
	    continue 
	} else {
	    scan $Ligne "%s" NomLu
	    if {$NomLu!=$Nom} { FaireLire "Ca merde dans  CreeOrthoTBlastN\n$Ligne" }
	    set LesPositions [lrange [split $Ligne " "] 1 end]
	    set ToggleOrgaPositions [expr ! $ToggleOrgaPositions]
	}
	catch {unset DejaVu}
	set LesOrgasMaPosTaPos {}
	foreach Orga $LesOrgas {MaPos TaPos} $LesPositions {
	    if {[info exists DejaVu($Orga)]} { continue }
	    lappend LesOrgasMaPosTaPos $Orga $MaPos $TaPos 
	}
	Espionne $Nom
	lappend Sortie "$Nom [join $LesOrgasMaPosTaPos " "]"
    }
    return [SauveLesLignes $Sortie dans $FichierOrthoTBlastN] 

}

proc CreeOuATapeBlastX {{Banque ""} {AvecOrganismes ""} {AvecPositions ""} {AvecDupliques ""}} {

    global RepertoireDuGenome
    global ListeDeBoites

    if {$Banque==""} { set Banque "protall" }
    if {$AvecOrganismes==""} { set AvecOrganismes 0 }
    if {$AvecPositions ==""} { set AvecPositions  1 }
    if {$AvecDupliques ==""} { set AvecDupliques  0 }

    Wup "AvecOrganismes+AvecPositions  or  AvecDupliques"

    set FichierOuATape "$RepertoireDuGenome/fiches/ouatapebx.$Banque"

    if {[file exists $FichierOuATape]} {
	if {[OuiOuNon "$FichierOuATape\nalready exists. Do I replace it ?"]} {
	    File delete $FichierOuATape
	} else {
	    if {[OuiOuNon "Do I keep the existing lines from \n $FichierOuATape \n ?"]} {
		foreach Ligne [LesLignesDuFichier $FichierOuATape] {
		    scan $Ligne "%s" Nom
		    if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 0 }
		    incr DejaVu($Nom)
		}
	    } 
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }


    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/blastx/$Nom"
	if { ! [file exists $Fichier]} { continue }
	Espionne $Fichier

	if {$AvecOrganismes && ! [info exists DejaVu($Nom)]} {
	    set Organismes [join [OuATapeBlastX $Fichier "ListeDesOrganismes"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Organismes"
	}
	if {$AvecPositions && (! [info exists DejaVu($Nom)] || [set DejaVu($Nom)]<2)} {
	    set Positions  [join [OuATapeBlastX $Fichier "ListeDesPositions"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Positions"
	}
	if {$AvecDupliques && ! [info exists DejaVu($Nom)]} {
	    set Dupliques [join [OuATapeBlastX $Fichier "ListeDesDupliques"] "\n"]
	    AppendAuFichier $FichierOuATape "$Nom $Dupliques"
	}
    }

}

proc CreeOuATapeTBlastN {{Banque ""} {AvecOrganismes ""} {AvecPositions ""} {AvecDupliques ""}} {

    global RepertoireDuGenome
    global ListeDeBoites

    if {$Banque==""} { set Banque "genomes" }
    if {$AvecOrganismes==""} { set AvecOrganismes 0 }
    if {$AvecPositions ==""} { set AvecPositions  1 }
    if {$AvecDupliques ==""} { set AvecDupliques  0 }

    Wup "AvecOrganismes+AvecPositions  or  AvecDupliques"

    set FichierOuATape "$RepertoireDuGenome/fiches/ouatapetbn.$Banque"

    if {[file exists $FichierOuATape]} {
	if {[OuiOuNon "$FichierOuATape\nalready exists. Do I replace it ?"]} {
	    File delete $FichierOuATape
	} else {
	    if {[OuiOuNon "Do I keep the existing lines from \n $FichierOuATape \n ?"]} {
		foreach Ligne [LesLignesDuFichier $FichierOuATape] {
		    scan $Ligne "%s" Nom
		    if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 0 }
		    incr DejaVu($Nom)
		}
	    } 
	}
    }

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }


    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"
	if { ! [file exists $Fichier]} { continue }

	if {$AvecOrganismes && ! [info exists DejaVu($Nom)]} {
	    set Organismes [join [OuATapeTBlastN $Fichier $Banque "ListeDesOrganismes"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Organismes"
	}
	if {$AvecPositions && (! [info exists DejaVu($Nom)] || [set DejaVu($Nom)]<2)} {
	    set Positions  [join [OuATapeTBlastN $Fichier $Banque "ListeDesPositions"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Positions"
	}
	if {$AvecDupliques && ! [info exists DejaVu($Nom)]} {
	    set Dupliques [join [OuATapeTBlastN $Fichier $Banque "ListeDesDupliques"] " "]
	    AppendAuFichier $FichierOuATape "$Nom $Dupliques"
	}
    }

}

proc CreeOuTapeTBlastX {Banque} {

    global RepertoireDuGenome
    set Liste {}
    foreach Fichier [lsort [glob "$RepertoireDuGenome/troustblastx$Banque/TROU3*"]] {
	set Nom [file tail $Fichier]
	if {[Decede $Nom]} { continue }


#	lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesDupliques] " "]"
	Wup "Commentariser ci-dessus (pour les paralogues par ex.) ou les 2 ci-dessous ou l'un"
#	lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesOrganismes] " "]"
#	lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesPositions] " "]"
	set Liste [concat $Liste $Nom [OuATapeTBlastX $Fichier $Banque LesSegments]] 
    }
    SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/ouatapetbx.$Banque.arenommer"

}

proc CreePAB {Trou} {


    Wup "uses something like 'CreePAB: de MTVRD a KRTFS' in the info file of TROU"
    Wup " it replaces 'CreePAB' with 'PABcree' to avoid to do it twice."

    if {[set TexteCreePAB [ExtraitInfo $Trou "CreePAB"]]==""} { return ""}

    set AAsDebut ""
    set AAsFin   ""
    if { ! [regexp {^ *de ([A-Z]+) a ([A-Z]+)} $TexteCreePAB Matche AAsDebut AAsFin]} { return "" }
    set AAsDebut [string toupper $AAsDebut]
    set AAsFin   [string toupper $AAsFin]

    set DTrou [Box $Trou debut]
    set FTrou [Box $Trou fin]

    if {$DTrou==""} { FaireLire "$Trou doesn't exist" ; return "" }

    set Extension 99
    set BonneOrient ""
    foreach Orient {"F" "R"} {
	set BonneFrame ""
	foreach Frame {0 1 2} {
	    set ADNCouvrant [BoutADN [expr $DTrou-$Extension+$Frame] [expr $FTrou+$Extension+$Frame] $Orient] 
	    set ADNCouvrant [string toupper $ADNCouvrant]
	    set SeqPro [SeqNucToSeqPro $ADNCouvrant]
	    if {[regexp -indices $AAsDebut $SeqPro IndicesDeb]} { set BonneFrame $Frame ; break }
	}
	if {$BonneFrame!=""} { set BonneOrient $Orient ; break }
    }
    if {$BonneFrame==""} {
	FaireLire "I cannot find $AAsDebut in $Trou" ; return ""
    }
    if { ! [regexp -indices $AAsFin $SeqPro IndicesFin]} {
	FaireLire "I cannot find $AAsFin in $Trou" ; return ""
    }
    Espionne "$SeqPro\n$AAsDebut $IndicesDeb $AAsFin $IndicesFin"
    scan $IndicesDeb "%d %d" DDeb FDeb
    scan $IndicesFin "%d %d" DFin FFin

    set DDebNuc [expr $DDeb*3]
    set FFinNuc [expr $FFin*3 + 2]

    if {$BonneOrient=="F"} {
	set VraiDeb [expr $DTrou - $Extension + $BonneFrame + $DDebNuc]
	set VraiFin [expr $DTrou - $Extension + $BonneFrame + $FFinNuc]
    } else {
	set VraiDeb [expr $FTrou + $Extension + $BonneFrame - $FFinNuc]
	set VraiFin [expr $FTrou + $Extension + $BonneFrame - $DDebNuc]
    }
    Espionne "$Trou $DTrou $FTrou $AAsDebut $AAsFin $VraiDeb $VraiFin $BonneOrient"
    set Bout [BoutADN [expr $VraiDeb-3] [expr $VraiFin+3] $BonneOrient]
    Espionne "$BonneOrient $BonneFrame [string range $Bout 0 9] ... [string range $Bout end-9 end]"
    Espionne "[SeqNucToSeqPro [string range $Bout 0 17]] ... [SeqNucToSeqPro [string range $Bout end-17 end]]" 
    Espionne "$AAsDebut ... $AAsFin"
    Espionne ""

    regsub -all {[^0-9]} $Trou "" NumeroDuTrou
    set N 3
    while 1 {
	set Numero "${N}$NumeroDuTrou"
	set PAB "[PreFixe]$Numero"
	if {[Box $PAB nom]==""} { break }
	if {[OuiOuNon "During CreePAB $Trou I wanted to create $PAB\n It already exists. Do I overwrite"]} { 
	    break
	}
    }
    set Nom    $PAB
    set Debut  $VraiDeb
    set Fin    $VraiFin
    set Orient $BonneOrient

    set SeqNuc [BoutADN $Debut $Fin $Orient]
    set NucTFA [SequenceFormatTFA $SeqNuc "$Nom $Debut $Fin $Orient created from $Trou $AAsDebut $AAsFin"]
    Sauve $NucTFA dans "[RepertoireDuGenome]/nuctfa/$Nom"
    set SeqPro [SeqNucToSeqPro $SeqNuc]
    set ProTFA [SequenceFormatTFA $SeqPro "$Nom $Debut $Fin $Orient created from $Trou $AAsDebut $AAsFin"]
    Sauve $ProTFA dans "[RepertoireDuGenome]/prottfa/$Nom"
    
    set NouvellesBornes "$Nom $Debut $Fin $Orient"
    MiseAJourBornesDesPABs $NouvellesBornes "SansReCharge"

    set ToutTexteCreePAB "CreePAB: $TexteCreePAB"
    InformeParSuppressionDuChamp $Trou $ToutTexteCreePAB
    regsub "CreePAB" $ToutTexteCreePAB "PABCree" TextePABCree
    InformeSansDemander $Trou $TextePABCree

    Box $Nom nom    $Nom
    Box $Nom debut  $Debut
    Box $Nom fin    $Fin
    Box $Nom orient $Orient
    InformeSansDemander $Nom "DuTrou: $Trou $AAsDebut $AAsFin $BonneOrient $BonneFrame"
    
    return $NouvellesBornes

}

proc CreePABPourTous {} {

    foreach Trou [ListeDesTROUs] {
	set PABCree [CreePAB $Trou]
	if {$PABCree!=""} {
	    Espionne $PABCree
	}
    }
    

}

proc CreePABPourWeb {} {

    if {![file exists "[RepertoireDuGenome]/fiches"]} {
	file mkdir "[RepertoireDuGenome]/fiches"
    }
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    if {![file exists $FichierBornes]} {
	Sauve "" dans $FichierBornes
    }
    set FichierFormat "[RepertoireDuGenome]/fiches/format_orf_numbering"
    if {![file exists $FichierFormat]} {
	Sauve "5.5d" dans $FichierFormat
    }

    set format [string trim [ContenuDuFichier $FichierFormat]]
    set dernier [lindex [LesLignesDuFichier $FichierBornes] end]
    if {[string length $dernier] != 0} {
	scan $dernier "%s %d %d %s" pab debut fin sens
	regexp {\d+$} $pab numero
	scan $numero "%d" numero
	incr numero

	set nouveauPab [format "%s%$format" [PreFixe] $numero]
	set nouveauDebut [expr $fin + 1]
	set nouvelleFin [expr $nouveauDebut + 1]
    } else {
	set nouveauPab [format "%s%$format" [PreFixe] 1]
	set nouveauDebut 1
	set nouvelleFin 2
    }

    set fh [open $FichierBornes "a"]
    puts $fh [format "%s %d %d %s" $nouveauPab $nouveauDebut $nouvelleFin "F"]
    close $fh

    return $nouveauPab

}

proc CreePABdesTrousCitesDans {FOF} {

    foreach Trou [LesLignesDuFichier $FOF] {
	CreePAB $Trou
    }

}

proc CreePDBPourSurface {pdbid} {

    global DCpt ListePDB

    # fait le menage
    foreach nom {outfile out.pdb AllAtoms.pdb Cmp.pdb} {
	if {[file exists $nom]} {
	    file delete -force $nom
	}
    }

    # Bilan des chaines
    set Lc [$pdbid _chains]
    set AOT [list]
    foreach c $Lc {
	if {[BonNomPDB ${pdbid}_$c] ni $ListePDB} {
	    continue
	}
	if {[$pdbid _chainIs $c] eq "Protein"} {
	    lappend AOT $c
	}
    }
    if {[llength $AOT] < 2} {
	puts "Une seule chaine ! Pas d'interface !"
	return
    }
    
    # fichier avec tout
    set f1 "AllAtoms.pdb"
    $pdbid save all all all 0 AllAtoms.pdb

    # enleve prot une par une
    set Head ""
    foreach c $Lc {
	set Lgc [$pdbid save $c all all 0 ListeEnRetour]
	set Cl($c) [EnleveHeader $Lgc]
	if {$Head eq ""} {
	    set Head [lor $Lgc [set Cl($c)]]
	}
	set Cl($c) [lrange [set Cl($c)] 0 end-1]
    }
    puts "Chains to be removed : $AOT"

    foreach caot $AOT {
	puts "\nExcluding chain : --> $caot <--"
	unset -nocomplain TB Srf
	set Ltot $Head
	foreach c $Lc {
	    if {$c eq $caot} {continue}
	    lappend Ltot {*}[set Cl($c)]
	    lappend Ltot "TER    "
	}
	lappend Ltot "END   "
	set f2 "Cmp.pdb"
	set o [open $f2 w]
	puts $o [join $Ltot \n]
	close $o

	set res [LanceAreaimol $f1 $f2]
	set Lres [ParseOutputAreaimol $res]
	unset -nocomplain Srf
	array set Srf $Lres

	# Nettoie output
	# Garde si bonne chaine, et si diff > 1 A2
	set NbS 0
	unset -nocomplain TB
	foreach e [lsort [array names Srf]] {
	    lassign [split $e ,] chn rnmr
	    if {$chn ni $AOT} {continue}
	    if {abs([set Srf($e)]) < 29.} {continue}
	    incr NbS
	    set nmr [DonnePosSG [BonNomPDB ${pdbid}_$chn] $rnmr]
	    foreach g [array names DCpt] {
		if {$nmr in [set DCpt($g)]} {
		    lappend TB($g) $nmr
		}
	    }
	}
	puts "Nbr res interface : $NbS"
	foreach g [array names TB] {
	    puts "$g [llength [set TB($g)]] [llength [set DCpt($g)]]"
	}
	puts ""
    }

    return

}

proc CreePourcentageIdentite {{Banque genomes}} {

    global RepertoireDuGenome
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	set Fichier "$RepertoireDuGenome/tblastn$Banque/$Nom"

	puts "$Nom $Fichier"
	if { ! [file exists $Fichier]} { continue }

	Wup "Commentariser ci-dessus (pour les paralogues par ex.) ou les 2 ci-dessous ou l'un"
	lappend Liste "$Nom [join [OuATapeTBlastN $Fichier $Banque ListeDesOrganismes] " "]"
	Wup "Je rappelle que je triche en cachant le pourcentage dans score"
	lappend Liste "$Nom [join [OuATapeTBlastN $Fichier $Banque ListeDesScores] " "]"
    }
    SauveLesLignes $Liste dans "$RepertoireDuGenome/fiches/pourcentageidentite.$Banque.arenommer"

}

proc CreePrimers {Fichier} {

    set LesGenes {}
    set LesPrimersN {}
    set LesPrimersC {}
    set DansGenes 0
    set DansPrimers 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {$Ligne=="Genes"}   { set DansPrimers 0 ; set DansGenes 1 ; continue }
	if {$Ligne=="Primers"} { set DansPrimers 1 ; continue }
	if {$DansPrimers} {
	    scan $Ligne "%s %s %s %s" FichPlasmide SeqPrimer NomDuPrimer NouCter
	    if {$NouCter=="N"} {
		lappend LesPrimersN $SeqPrimer
		lappend LesTitresPrimersN "$NomDuPrimer $NouCter from $FichPlasmide"
	    } else {
		lappend  LesPrimersC $SeqPrimer
		lappend LesTitresPrimersC "$NomDuPrimer $NouCter from $FichPlasmide"
	    }
	    continue
	}
	if {$DansGenes} {
	    scan $Ligne "%s" FichierSeq
	    lappend LesGenes [QueLaSequenceDuFichierTFA $FichierSeq]
	    regsub {\-.*$} $FichierSeq "" TitreSeq
	    lappend LesTitresGenes "$TitreSeq"
	}	
    }

    set LongHybridationP 15
    set LongHybridationN [expr $LongHybridationP*3]
    set LongPromoteurP 17
    set LongPromoteurN [expr $LongPromoteurP*3]

    foreach Gene $LesGenes Titre $LesTitresGenes {
	foreach Primer $LesPrimersN TitrePrimer $LesTitresPrimersN {
	    if {[regexp "UpstreamPrimerA" $TitrePrimer]} {
		set Seq [string range "n$Gene"  [expr $LongPromoteurN-$LongHybridationN]   [expr $LongPromoteurN] ]
		set Oligo "$Seq $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	    if {[regexp "UpstreamPrimerB" $TitrePrimer]} {
		set Seq [string range "$Gene"  [expr $LongPromoteurN]  [expr $LongPromoteurN+$LongHybridationN]]
		set Rac [NucToReverseAndComplementNuc $Seq]
		set Oligo "$Rac $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	}
	foreach Primer $LesPrimersC TitrePrimer $LesTitresPrimersC {
	    if {[regexp "UpstreamPrimerA" $TitrePrimer]} {
 		set Seq [string range "x$Gene"  "end-[expr $LongPromoteurN+$LongHybridationN]"  "end-[expr $LongPromoteurN]"]
		set Oligo "$Seq $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	    if {[regexp "UpstreamPrimerB" $TitrePrimer]} {
 		set Seq [string range "x$Gene"  "end-[expr $LongPromoteurN -1]"  "end-[expr $LongPromoteurN-$LongHybridationN -1]"]
		set Rac [NucToReverseAndComplementNuc $Seq]
		set Oligo "$Rac $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	}
    }

}

proc CreeProjetGscopeCilioCarta {} {

    set LeTFAs [CilioPep ListOf FA]
    set FichierFasta [SauveLesLignes $LeTFAs dans "[CilioCartaDir]/CilioCarta.fasta"]
    return [Espionne "$FichierFasta est créé.\nMaitenant il faut faire \nsetgscoperr CilioCarta\n et lancer \ngscope\n puis gscope InformeCilioCarta"]

}

proc CreeProtTfaPhorDeGenEmbl {} {


    Wup "Comme c'etait pas tres clair j'ai pris /genome/P.horikoshii/phori.ref "
    Wup "  et j'en ai extrait les lignes  'gene              debut. .fin'"
    Wup "                            et   'gene              complement(debut. .fin)"


    set nForwards 0
    set nReverses 0
    set YaCDS 0
    set LesForwards {}
    set LesNomsForwards {}
    set LesReverses {}
    set LesNomsReverses {}
    set AuBon ""
    foreach Ligne [LesLignesDuFichier "/genome/P.horikoshii/phori.ref"] {
	if { [regexp "CDS             " $Ligne]} { set YaCDS 1 ; continue }
	if {$YaCDS && [regexp "/gene" $Ligne]} { continue }
	set YaCDS 0
	if {[regexp "/gene" $Ligne]} {
	    if {$AuBon == ""} { continue }
	    lappend $AuBon [StringApres "/gene=" dans $Ligne]
	    if {$DeuxFois} { lappend $AuBon [StringApres "/gene=" dans $Ligne] }
	    set AuBon ""
	}
	if { ! [regexp "gene            " $Ligne]} { continue }
	regsub -all {[^0-9]} $Ligne " " Deux
	set DeuxFois 0
	if {[regexp "join" $Ligne]} {
	    set DeuxFois 1
	    regsub -all {[^0-9]} $Ligne " " Quatre
	    scan $Quatre "%d %d %d %d" a b c d
	    if {[regexp "complement" $Ligne]} {
		lappend LesReverses "[incr c 3] $d"
		incr nReverses
	    } else {
		lappend LesForwards "$c [incr d -3]"
		incr nForwards
	    }
	}
	scan $Deux "%d %d" a b
	if {[regexp "complement" $Ligne]} {
	    lappend LesReverses "[incr a 3] $b"
	    incr nReverses
	    set AuBon "LesNomsReverses"
	} else {
	    lappend LesForwards "$a [incr b -3]"
	    incr nForwards
	    set AuBon "LesNomsForwards"
	}
    }

    Espionne $LesNomsForwards
    Espionne "[llength $LesForwards] [llength $LesNomsForwards]"
    Espionne "[llength $LesReverses] [llength $LesNomsReverses]"

    set NumeroF 0
    foreach Forward $LesForwards LeurNom $LesNomsForwards {
	set Orient "F"
	scan $Forward "%d %d" Debut Fin
	set BeauNumero [format "%4.4d" [incr NumeroF]]
	set Nom "PHOK$BeauNumero"
	set EnteteSolo ">$Nom $Debut $Fin $Orient $LeurNom"
	set EnteteTous ">PHOR:$Nom $Nom $Debut $Fin $Orient $LeurNom"
	set Sequence [SequenceFormatBrut [SeqNucToSeqPro [BoutADN $Debut $Fin $Orient]]]
	set TFA "$EnteteSolo\n$Sequence"
	Espionne $TFA
	lappend BornesDesPABs "$Nom $Debut $Fin $Orient"
	lappend ToutTFA "$EnteteTous\n$Sequence"
#       Espionne [Sauve $TFA dans "./prottfa/$Nom"]
    }

    set NumeroR [expr $nForwards+$nReverses+1]
    foreach Reverse $LesReverses LeurNom $LesNomsReverses {
	set Orient "R"
	scan $Forward "%d %d" Debut Fin
	set BeauNumero [format "%4.4d" [incr NumeroR -1]]
	set Nom "PHOK$BeauNumero"
	set EnteteSolo ">$Nom $Debut $Fin $Orient $LeurNom"
	set EnteteTous ">PHOR:$Nom $Nom $Debut $Fin $Orient $LeurNom"
	set Sequence [SequenceFormatBrut [SeqNucToSeqPro [BoutADN $Debut $Fin $Orient]]]
	set TFA "$EnteteSolo\n$Sequence"
	Espionne $TFA
	lappend BornesDesPABs "$Nom $Debut $Fin $Orient"
	lappend ToutTFA "$EnteteTous\n$Sequence"
#       Espionne [Sauve $TFA dans "./prottfa/$Nom"]
    }
#   Espionne [SauveLesLignes $BornesDesPABs dans "./fiches/bornesdespabs"]
#   Espionne [SauveLesLignes $ToutTFA dans "./db/proteines.tfa"]

}

proc CreeProteomeAvecUneListeAccessAliasDefinition {Fichier {AADorBAAD ""}} {

    global RepertoireDuGenome
    global NarcisseDuAlias

    set Geno [file tail $RepertoireDuGenome]
    set FichierFOF "$RepertoireDuGenome/$Geno.fof"

    set RepProteome "$RepertoireDuGenome/proteome"
    if { ! [file exists $RepProteome]} {
	File mkdir $RepProteome
    }

    if {[glob -nocomplain "$RepProteome/*"]=={}} {
	set LaTotale 1
    } else {
	set LaTotale [OuiOuNon "Do I replace all known files ? "]
    }
    set TesteTout 0
    set AppendSeul 0
    while {[file exists $FichierFOF]} {
	
	set LaTotale 0
	if {[OuiOuNon "$FichierFOF already exists. \nDo I keep it, doing nothing ?" 0]} { return $FichierFOF }
	if {[OuiOuNon "$FichierFOF already exists. \nDo I replace all existing files ?" 0]} {
	    set LaTotale 1	    
	    break
	}
	if {[OuiOuNon "$FichierFOF already exists. \nDo I test for changes ?"]} {
	    set TesteTout 1
	    break
	}
    }
    if {$TesteTout} {
	foreach Ligne [LesLignesDuFichier $FichierFOF] {
	    scan $Ligne "%s %s" Alias Ver
	    set VerDuAlias($Alias) $Ver
	}
    }

    if {$AADorBAAD==""} {
	if { [OuiOuNonMemo "Does this file contain BanqueId AND Access (Alias (Definition)) ?" 0] } {
	   set AADorBAAD "BAAD"
	} else {
	   set AADorBAAD "AAD"
	}
    } 
    set BanqueIdAndAccess [string compare -nocase $AADorBAAD "BAAD"]
    
    set n 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	incr n
	if { ! [regexp -nocase {[a-z]+} $Ligne]} { continue }
	if {[regexp -nocase {^[ \t]*\#} $Ligne]} { continue }
	regsub -all "\t" $Ligne " " Ligne 
	set BanqueId ""
	set Access ""
	set Alias "ALIAS_$n"
	set DE ""
	if {$BanqueIdAndAccess} {
	    scan $Ligne "%s %s %s" BanqueId Access Alias
	    regsub "\:" $BanqueId "\\:" BanqueIdSansPP
	    regsub " *$BanqueIdSansPP +$Access +$Alias +" $Ligne "" DE
	} else {
	    scan $Ligne "%s %s" Access Alias
	    regsub " *$Access +$Alias +" $Ligne "" DE
	}
	if {$Access==""} { set Access $BanqueId }
	Espionne "$BanqueId $Access $Alias $DE"


	if {$TesteTout && [info exists VerDuAlias($Alias)]} {
	    set Ver [set VerDuAlias($Alias)]
	    if {[regexp "/" $Access]} {
		set RepAccess $Access
	    } else {
		set RepAccess "$RepProteome/$Access"
	    }
	    while {$RepAccess!=$Ver} {
		FaireLire " Reading the line \n  $Ligne \n  I see that \n $Alias $RepAccess \n  doesn't correspond to the old \n $Alias $Ver"
		if {[OuiOuNon "Do I ignore this, and use $Access ?"]} { break }
		if {[OuiOuNon "Do I use the old access $Ver ?"]} { set Access [file tail $Ver] }
		if {[OuiOuNon "Do I cancel creation of $FichierFOF ?"]} { return "" }
	    }
	}

	set FichierEMBL "$RepProteome/[file tail $Access]"
	regsub {\.tfa$} $FichierEMBL "" FichierEMBL
	set AccessOK $Access	    
	if { $LaTotale || ! [file exists $FichierEMBL]} {
	    set AccessOK "NotYetAvailable"
	    set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
	    while {$LesLignesEMBL=={}} {
		if {[file exists $FichierEMBL]} {
		    set LesLignesEMBL [LesLignesDuFichier $FichierEMBL]
		    break
		}
		if {[OuiOuNon "I didn't found the sequence $Access. Do I do it later ?"]} {
		    set DoItLater 1
		    break
		} 
		if {[OuiOuNon "I didn't found the sequence $Access. Do I skipp ?"]}  {
		    set DoItLater 0
		    break
		} 
		if {[OuiOuNon "I didn't found the sequence $Access. Do I cancel ?"]} { return "" } 
		if {[OuiOuNon "I didn't found the sequence $Access. Do I stop ?"]}   { exit } 
	    }
	    if {$LesLignesEMBL!={}} {
		SauveLesLignes $LesLignesEMBL dans $FichierEMBL
	    } else {
		if {$DoItLater} {
		    set $FichierEMBL "xx"
		} else {
		    continue
		}
	    }
	}
	lappend LesFOFs "$Alias $FichierEMBL"
	set NarcisseDuAlias($Alias) $AccessOK
    }
    return [SauveLesLignes $LesFOFs dans $FichierFOF]

}

proc CreeQueryFile {{Liste ""}} {

    set LesLignes {}
    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    foreach Nom $Liste {
	set Ligne ""
	set Access [AccessEvi $Nom]
	set Banque [BanqueEvi $Nom]
	if {$Banque=="rs"} {set Bank REFSEQRNA}
	if {$Banque=="gbf"} {set Bank GENBANK}
	if {$Access==""} {continue}
	set Ligne "ID $Access DB $Bank"
	lappend LesLignes $Ligne
	set Ligne "FD dbxref"
	lappend LesLignes $Ligne
	set Ligne "//"
	lappend LesLignes $Ligne
    }
    SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/BirdMgi"

}

proc CreeRepQueryPourMainJumeaux {FichierDesPABs} {

    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    foreach Nom $L {
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom"
	if {![file exists $FichierProttfa]} {continue}
	file copy $FichierProttfa "[RepertoireDuGenome]/LesProttfaPourMainJumeaux/$Nom"
    }

}

proc CreeSeqTFAPourBlastCGH {Cas SeuilPlus SeuilMoins {LesPos ""} {LesNoms ""}} {


    # liste des cas !!!A DETERMINER!!!

    if {$Cas=="meta"} {
	set LesCas {CL_PC3}
    } else {
	### All
	set LesCas {Oligo807}
    }

    Espionne [llength $LesCas]
    # pour comparaison BAC vs oligo: pas possible sur chro X et Y a cause du mismatch fait pour BAC mais pas pour Oligo...
    set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22}

    ### Position des genes ###
    set FichierLocGenes "[RepertoireDuGenome]/PRIMA_Affichage/HumanAllGenesUCSC"
    if {![file exists $FichierLocGenes] || $FichierLocGenes == ""} {return ""}

    foreach Chromosome $ListeChro {
	ChargeFichierLoc TabG $FichierLocGenes $Chromosome $LesNoms
	if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} {
	    foreach Nom [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] {
		foreach LInfo [set TabG($FichierLocGenes,Chromosome,$Chromosome,$Nom)] {
		    set DebutGene [lindex $LInfo 1]
		    set FinGene [lindex $LInfo 2]
		    set Deb($Chromosome,$Nom) $DebutGene
		    set Fin($Chromosome,$Nom) $FinGene
		}
	    }
	}
    }
    
    set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    if {![file exists $FichierLocCGHBAC] || $FichierLocCGHBAC == ""} {return ""}

    set RepSeq "[RepertoireDuGenome]/ESBS/Sequences_Fasta_prot\_$SeuilPlus"
    #set RepSeq "[RepertoireDuGenome]/PRIMA_CGH_Fasta_prot_$Cas\_$SeuilPlus"
    if {![file exists $RepSeq]} {file mkdir $RepSeq}
    
    ### pour chaque fichier CGH ###
    foreach NomFichier $LesCas {
	set FichierCourbeCGH "[RepertoireDuGenome]/PRIMA_CGH/$NomFichier"
	Espionne $NomFichier
	
	set x [InterrogeFichierCourbeCGH $FichierCourbeCGH "unset"]
	set VMin [InterrogeFichierCourbeCGH $FichierCourbeCGH VMin]
	set VMax [InterrogeFichierCourbeCGH $FichierCourbeCGH VMax]
	set VMaxf [format "%.2f" [expr $VMax*1.0]]
	set VMinf [format "%.2f" [expr $VMin*1.0]]
	lappend LesBornes "$NomFichier\t$VMinf\t$VMaxf"
	
	#### Pour chaque chromosome ###
	foreach Chromosome $ListeChro {
	    Espionne $Chromosome
	    set LesGenes {}
	    # Dommage d'avoir deux fichiers distincts relatifs aux bac: la pos inf et sup des bac d'un cote (fichier PRIMA_CGH/CGH_BAC_localisation voir proc ac_IllustreUnChromosome) et la val de chaque bac pour un echantillon donne (fichier courbe cgh ex: PRIMA_CGH/BAC820)
	    # j'ai posmid mais pas posinf et possup du bac dans le fichiercourbe....
	    
	    if {[info exists TabC]} {unset TabC}
	    ChargeFichierCourbeCGH TabC $FichierCourbeCGH $Chromosome $LesPos
	    if {[info exists TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)]} {
		### Pour chaque position de BAC ou Oligo ###
		foreach Pos [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)] {
		    set PosMid $Pos
		    foreach LInfo [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,$Pos)] {
			# problem: posmid et pas debut et fin du bac ou de l'oligo
			# oligo: 60 bp, donc posmid +/- 30 bp
			# bac : 150 000 bp on average, donc posmid +/-75 000 bp

			### Autour de la position ###
			### selon si BAC ou Oligo ###
			if {[regexp "Oligo" $NomFichier] || [regexp "CL" $NomFichier]} {
			    #set PosMidN [expr $PosMid -25000]
			    #set PosMidP [expr $PosMid +25000]
			    set PosMidN [expr $PosMid -30]
			    set PosMidP [expr $PosMid +30]
			} else {
			    #set PosMidN [expr $PosMid -100000]
			    #set PosMidP [expr $PosMid +100000]
			    set PosMidN [expr $PosMid -75000]
			    set PosMidP [expr $PosMid +75000]
			}
			
			#SauveLesLignes $LesGenes dans "[RepertoireDuGenome]/lesgenes_CGHprot06"			
		   
			if {[regexp "Oligo" $NomFichier] || [regexp "CL" $NomFichier]} {
			    set Val [lindex $LInfo 3]
			    set Val [expr $Val*log(10)/log(2)]
			} else {
			    set Val [lindex $LInfo 2]
			}

			set Value [format "%.2f" [expr $Val*1.0]]

			if {$Value>0 && $Value>$SeuilPlus} {
			    Espionne "$PosMid $Value"
			    #lappend LesAberr "$Cas\t$NomFichier\t$Chromosome\t$LesGenes\t$PosMid\t$Val"
			    #lappend LesGenesAmpli $LesGenes
			    
			    ### Quels genes? ###
			    set LesGenes ""
			    if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} {
				# Pour chaque Gene
				foreach Name [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] {
				    # Remplacer par si posmid du bac ou de l'oligo match le gene
				    # cad si posmid entre debut et fin du gene...
				    if {$PosMidN>=$Deb($Chromosome,$Name) && $PosMidN<=$Fin($Chromosome,$Name) ||  $PosMidP>=$Deb($Chromosome,$Name) && $PosMidP<=$Fin($Chromosome,$Name) ||  $PosMidN<=$Deb($Chromosome,$Name) && $PosMidP>=$Fin($Chromosome,$Name)} {
					lappend LesGenes $Name
				    }
				}
			    }
			    
			    
			    if {$LesGenes!=""} {
				foreach Gene $LesGenes {
				    #Espionne "Acc Gene: $Gene"
				    #lappend LesGenesAmpli $Gene
				    if {[regexp -nocase "NM" $Gene]} {
					#Espionne "Acc Gene NM: $Gene"
					set AccessProt [InterrogeFichierRefLink /genomics/link/UCSCGenomes/Homo_sapiens/database/refLink.txt $Gene NP]
					if {$AccessProt==""} {continue}
					set Commande "getz \"\\\[\\\{refseqprelease refseqpnew\\\}-acc:$AccessProt\\\]\" \-view FastaSeqs"
					set GetzOut [eval exec $Commande]
					if {$GetzOut==""} {
					    Espionne "no seq for $AccessProt"
					} else {
					    set FichierSeq "$RepSeq/$AccessProt\_$NomFichier\_$Chromosome\_$PosMid"
					    if {[file exists $FichierSeq]} {
						continue
					    } else {
						Espionne $FichierSeq
						set Entete [EnteteDuTexteTFA $GetzOut]
						set NouvelleEntete "$Entete $Cas $NomFichier $Chromosome $PosMid $Value"
						set Seq [QueLaSequenceDuTexteTFA $GetzOut]
						set SeqProtTFA [SequenceFormatTFA $Seq $NouvelleEntete "brut"]
						Sauve $SeqProtTFA dans $FichierSeq
					    }
					}
				    } else {
					set LesAccProt [LesProteinesDeLAcNuc $Gene]
					if {[llength $LesAccProt]>1} {Espionne "$Gene: $LesAccProt"}
					foreach AccProt $LesAccProt {
					    set Commande "getz \"\\\[protein-acc:$AccProt\\\]\" \-view FastaSeqs"
					    set GetzOut [eval exec $Commande]
					    if {$GetzOut==""} {
						Espionne "no seq for $AccProt"
					    } else {
						set FichierSeq "$RepSeq/$AccProt\_$NomFichier\_$Chromosome\_$PosMid"
						if {[file exists $FichierSeq]} {
						    continue
						} else {
						    Espionne $FichierSeq
						    set Entete [EnteteDuTexteTFA $GetzOut]
						    set NouvelleEntete "$Entete $Cas $NomFichier $Chromosome $PosMid $Value"
						    set Seq [QueLaSequenceDuTexteTFA $GetzOut]
						    set SeqProtTFA [SequenceFormatTFA $Seq $NouvelleEntete "brut"]
						    Sauve $SeqProtTFA dans $FichierSeq
						}
					    }
					}
				    }
				}
			    }
			}
			if {$Value<0 && $Value<$SeuilMoins} {
			    Espionne "$PosMid $Value"

			    #lappend LesAberr "$Cas\t$NomFichier\t$Chromosome\t$LesGenes\t$PosMid\t$Val"
			    #lappend LesGenesDelet $LesGenes

			    ### Quels genes? ###
			    set LesGenes ""
			    if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} {
				# Pour chaque Gene
				foreach Name [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] {
				    # Remplacer par si posmid du bac ou de l'oligo match le gene
				    # cad si posmid entre debut et fin du gene...
				    if {$PosMidN>=$Deb($Chromosome,$Name) && $PosMidN<=$Fin($Chromosome,$Name) ||  $PosMidP>=$Deb($Chromosome,$Name) && $PosMidP<=$Fin($Chromosome,$Name) ||  $PosMidN<=$Deb($Chromosome,$Name) && $PosMidP>=$Fin($Chromosome,$Name)} {
					lappend LesGenes $Name
				    }
				}
			    }
			    
			    if {$LesGenes!=""} {
				foreach Gene $LesGenes {
				    #Espionne "Acc Gene: $Gene"
				    #lappend LesGenesDelet $Gene
				    if {[regexp -nocase "NM" $Gene]} {
					#Espionne "Acc Gene NM: $Gene"
					set AccessProt [InterrogeFichierRefLink /genomics/link/UCSCGenomes/Homo_sapiens/database/refLink.txt $Gene NP]
					if {$AccessProt==""} {continue}
					set Commande "getz \"\\\[\\\{refseqprelease refseqpnew\\\}-acc:$AccessProt\\\]\" \-view FastaSeqs"
					set GetzOut [eval exec $Commande]
					if {$GetzOut==""} {
					    Espionne "no seq for $AccessProt"
					} else {
					    set FichierSeq "$RepSeq/$AccessProt\_$NomFichier\_$Chromosome\_$PosMid"
					    if {[file exists $FichierSeq]} {
						continue
					    } else {
						Espionne $FichierSeq
						set Entete [EnteteDuTexteTFA $GetzOut]
						set NouvelleEntete "$Entete $Cas $NomFichier $Chromosome $PosMid $Value"
						set Seq [QueLaSequenceDuTexteTFA $GetzOut]
						set SeqProtTFA [SequenceFormatTFA $Seq $NouvelleEntete "brut"]
						Sauve $SeqProtTFA dans $FichierSeq
					    }
					}
				    } else {
					set LesAccProt [LesProteinesDeLAcNuc $Gene]
					if {[llength $LesAccProt]>1} {Espionne "$Gene: $LesAccProt"}
					foreach AccProt $LesAccProt {
					    set Commande "getz \"\\\[protein-acc:$AccProt\\\]\" \-view FastaSeqs"
					    set GetzOut [eval exec $Commande]
					    if {$GetzOut==""} {
						Espionne "no seq for $AccProt"
					    } else {
						set FichierSeq "$RepSeq/$AccProt\_$NomFichier\_$Chromosome\_$PosMid"
						if {[file exists $FichierSeq]} {
						    continue
						} else {
						    Espionne $FichierSeq
						    set Entete [EnteteDuTexteTFA $GetzOut]
						    set NouvelleEntete "$Entete $Cas $NomFichier $Chromosome $PosMid $Value"
						    set Seq [QueLaSequenceDuTexteTFA $GetzOut]
						    set SeqProtTFA [SequenceFormatTFA $Seq $NouvelleEntete "brut"]
						    Sauve $SeqProtTFA dans $FichierSeq
						}
					    }
					}
				    }
				}
			    }
			}
			
		    }
		    Espionne "next elt"
		}
	    }
	}
    }
    return ""

}

proc CreeSeqlabGroup {gcou Lseqi} {

    global LNSeqlab ListeSeqsGroupees NomNomSeq NomTextSeq
    
    set iGrp [string range $gcou 1 end]
    # yw : y dans widget, yl y dans LNSeqlab
    set Liy [list]
    set Totag [list]
    foreach {s yw yl g} $Lseqi {
	lappend Liy $yl
	lappend ListeSeqsGroupees($gcou) $s
	lappend Totag $yw.0 "$yw.0 lineend"
    }
    $NomNomSeq tag add TC$gcou {*}$Totag
    $NomTextSeq group $iGrp $Liy

    return

}

proc CreeSignifications {{K OrdrePourGif}} {

    global SignificationEnStock
    
    set Significations [GetSignification "ToutesLesCouleursPossibles" $K]
    
    set listeAAfficher [list ""]
    foreach Signif $Significations {
    	set TexteSignif [GetSignification $Signif $K]
	lappend ListeAAfficher "$Signif   :   $TexteSignif"
    }
    
    return $ListeAAfficher
    #SauveLesLignes $ListeAAfficher dans $FichierSignif

}

proc CreeSmallTaxo {} {

    global db
    InitTaxDB

    # find parent at level 4
    set tx 9606
    for {set i 1} {$i <= 4} {incr i} {
	set tx [$db eval {select Parent from taxonomy where taxid=$tx}]
    }
    
    # grab all tree from parent to 9606
    set Lid [list]
    set Ldb $tx
    while {"9606" ni $Lid} {
	set Lout [list]
	foreach n $Ldb {
	    lappend Lout {*}[$db eval {select taxid from taxonomy where Parent=$n}]
	}
	set Ldb $Lout
	lappend Lid {*}$Lout
    }
    set Lid [lsort -unique -integer $Lid]

    # dump
    set o [open dump.dat w]
    foreach n $Lid {
	set Lv [$db eval {select * from taxonomy where taxid=$n}]
	puts $o "[join $Lv \t]"
    }
    close $o
    $db close

    exit

}

proc CreeSousListe {First Last} {

    foreach Nom [ListeDesPABs] {
	if {$Nom==$First} {set VuFirst 1; lappend L $Nom; continue}
	if {[info exists VuFirst] && $Nom!=$Last} {lappend L $Nom}
	if {$Nom==$Last} {lappend L $Nom; break}
    }
    Espionne [llength $L]
    return $L

}

proc CreeSousListesExonhit {{SuffixeFichier TN} {Selec "EXH-PPRB PP00"}} {


    # gscope Exonhit
    # permet de faire les 3 listes correspondant aux 3 types de donnees suivants:

    # PPRA or EXH-PPRA   Hormone Refractory / Hormone Sensitive
    # PP00 or EXH-PPRB   Tumor / adjacent benign
    # EXH-PPRC           BPH / non-BPH

    # CreeSousListesExonhit                      -> PopExonhitTN
    # CreeSousListesExonhit HRHS "EXH-PPRA PPRA" -> PopExonhitHRHS
    # CreeSousListesExonhit BPHnonBPH "EXH-PPRC" -> PopExonhitBPHnonBPH

    set LesSelec [split $Selec " "]
    foreach Nom [ListeDesPABs] {
	set CodeClone [ExtraitInfo $Nom OwnerOfCDNA]
	foreach Sel $LesSelec {
	    if {[regexp "^$Sel" $CodeClone]} {
		AppendAuFichier "[RepertoireDuGenome]/PopExonhit$SuffixeFichier" $Nom
	    }
	}
    }

}

proc CreeSousListesExonhitProcure {FichierPop FichierOut} {

    # gscope Procure

    set FichierCorrespondance "[RepertoireDuGenome]/lacorrespondance"
    foreach Ligne [LesLignesDuFichier $FichierCorrespondance] {
	set Old [lindex $Ligne 0]
	set PCA [lindex $Ligne 1]
	set Datas($Old) $PCA
    }

    set n 0; set b 0
    set L [CreeListePourFichierAUneColonne $FichierPop]
    foreach Nom $L {
	if {[info exists Datas($Nom)]} {
	    incr n
	    set NomProcure $Datas($Nom)
	    AppendAuFichier $FichierOut $NomProcure
	} else {incr b;Espionne "pb avec $Nom"}
    }
    #Espionne "n=$n b=$b"

}

proc CreeStartCodonReport {} {

    global RepertoireDuGenome

    set FichierReport "$RepertoireDuGenome/fiches/startcodon_report"
    if {[file exists $FichierReport]} { set Copie [Garde $FichierReport] }

    set AppendToIt 0
    while {[file exists $FichierReport]} {
	if {[OuiOuNon "$FichierReport already exists. \nDo I append to it ?"]} {
	    set AppendToIt 1
	    break
	}
	if {[OuiOuNon "$FichierReport already exists. \nDo I replace it ?"]} {
	    File delete -force $FichierReport
	    continue
	}
	if {[OuiOuNon "Do I cancel CreeStartCodonReport"]} { return "" }
    }

    set Cluster [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_cluster"]

    set LesNoms {}
    foreach Nom [ListeDesPABs] {
	set LesSummary [StartCodonSummary $Nom]
	if {[regexp "NoSummary" $LesSummary]} { continue }
	foreach Ligne $LesSummary {
	    scan $Ligne "%s %s %s %s" iGGT AA Pos NbAccord
	    lappend LesNoms $Nom
	    lappend Classement($Nom) [list $AA $Pos $NbAccord]
	    set Commentaire($Nom) [StringSuivant "=" dans $Ligne]
	}
    }
    
    set LesNoms [lsort -unique $LesNoms]
    #Categories Raymond
    # 0 Met initial conserve
    # 1 Met initial a egalite
    # 2 Autre met
    # 3 Autre met a egalite
    
    if {$AppendToIt} {
	foreach Ligne [LesLignesDuFichier $FichierReport] {
	    scan $Ligne "%s %s %s" Nom Pos PC
	    if {[regexp {^(Pas|Probleme)} $Pos]} { continue }
	    set DejaVu($Nom) 1
	}
    }

    foreach Nom $LesNoms {
	if {[info exists DejaVu($Nom)]} { continue }
	set MetIni($Nom) [join [lrange [lindex [set Classement($Nom)] 0] 0 1] ""]
	set Classement($Nom) [lsort -integer -decreasing -index 2 [set Classement($Nom)]]
	set liste [set Classement($Nom)]
	if {[llength $liste]<=1 && [lindex [lindex $liste 0] 1]==1} {
	    set CatRay($Nom) 0
	} else {
	    set Premier [lindex $liste 0] 
	    set Second  [lindex $liste 1]
	    if {[lindex $Premier 1]==1} {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 1
		} else {
		    set CatRay($Nom) 0
		}
	    } else {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 3
		} else {
		    set CatRay($Nom) 2
		}
	    }
	}
    }

    #TRAITEMENT DES RESULTATS CLUSTERING
    set lesNomsCl [list]
    foreach Ligne $Cluster {
	if { ! [regexp -nocase {[a-z]} $Ligne]} continue
	while {[regexp "  " $Ligne]} {
	    regsub -all "  " $Ligne " " Ligne
	}
	set liste [split $Ligne " "]
	set Nom [lindex $liste 0]
	set Decal [lindex $liste 1]
	set Percent [lindex $liste 2]
	lappend LesNomsCl $Nom 
	if {[info exists Classement($Nom)]} { 
	    set MetRaymond [join [lrange [lindex [set Classement($Nom)] 0] 0 1] ""]
	} else {
	    set MetRaymond "X1"
	}
	if {[regexp "Pas" $Ligne] || ! [info exists CatRay($Nom)]} { 
	    set Bilan($Nom) "white No_Value"
	    set StartCodonProposal($Nom) "None"
	} else {
	    if {[regexp "Probleme" $Ligne]} {
		set Bilan($Nom) "grey Problem"
		set StartCodonProposal($Nom) "None"
	    } else {   
		if {$Decal != 0  || $Percent>50} {
		    set Bilan($Nom) "green Validated_Start_Codon"
		    set StartCodonProposal($Nom) [set MetIni($Nom)]
		} else { 
		    if {$Decal < -3} {
			set Deb [Box $Nom debut]
			set Fin [Box $Nom fin]
			set Orient [Box $Nom orient]
			scan [BornesDuGeneEtendu $Nom] "%s %s %s %s" x DebEtend FinEtend OrientEtend
			if {$Deb==$DebEtend && $Fin==$FinEtend} {
			    set Bilan($Nom) "green Validated_Start_Codon" 
			    set StartCodonProposal($Nom) [set MetIni($Nom)]
			} else {
			    if {$Deb!=$DebEtend} {
				set Diff [expr $Deb-$DebEtend]
			    } else {
				set Diff [expr $FinEtend-$Fin]
			    }
			    set NucEtendu [BoutADN $DebEtend $FinEtend $OrientEtend]
			    set NewMet [AAduCodon [string range $NucEtendu 0 2]]
			    set NewPos [expr $Diff/3]
			    if {$NewPos>2} {
				set Bilan($Nom) "blue Truncated_Gene"
				set StartCodonProposal($Nom) "${NewMet}-$NewPos"
			    } else {
				set Bilan($Nom) "green Validated_Start_Codon" 
				set StartCodonProposal($Nom) [set MetIni($Nom)]
			    }
			}
		    } else {
			set Cat [set CatRay($Nom)]  
			if {!$Cat} {
			    set Bilan($Nom) "green Validated_Start_Codon" 
			    set StartCodonProposal($Nom) $MetRaymond
			} else {
			    set NewDecal [expr $Decal+1]
			    set Classe [set Classement($Nom)] 
			    set Diff 999
			    set MeilleurIndex -1
			    set Index 0
			    foreach el $Classe {
				set Pos [lindex $el 1]
				if {[expr abs($NewDecal-$Pos)]<$Diff} {
				    set Diff [expr abs($NewDecal-$Pos)]
				    set MeilleurIndex $Index
				    if {!$Diff} break
				}
				incr Index
			    }
			    set MeilleurOdile [lindex $Classe $MeilleurIndex]
			    set MetOdile [join [lrange $MeilleurOdile 0 1] ""]
			    if {$Cat==2} {
				if {$Decal<0} {
				    set Bilan($Nom) "orange Doubtful_Start_Codon"
				    if {$MetRaymond==$MetOdile} {
					set StartCodonProposal($Nom) $MetRaymond
				    } else {
					set StartCodonProposal($Nom) $MetRaymond$MetOdile
				    }
				} else {
				    if {!$MeilleurIndex} {
					set Bilan($Nom) "red Wrong_Start_Codon"
					set StartCodonProposal($Nom) $MetRaymond
				    } else {
					set Bilan($Nom) "orange Doubtful_Start_Codon"
					set StartCodonProposal($Nom) $MetRaymond$MetOdile
				    }
				}
			    } else {
				if {[lindex $MeilleurOdile 1]==1} {
				    set Bilan($Nom) "green Validated_Start_Codon"
				    set StartCodonProposal($Nom) $MetOdile
				} else {
				    set Bilan($Nom) "orange Doubtful_Start_Codon"
				    set StartCodonProposal($Nom) $MetOdile
				    set Effectif [lindex [lindex $Classe 0] 2]
				    foreach el $Classe {
					if {[lindex $el 2]!=$Effectif} break
					if {[lindex $MeilleurOdile 1]== [lindex $el 1]} continue
					set StartCodonProposal($Nom) "[set StartCodonProposal($Nom)][join [lrange $el 0 1] ""]"
				    } 
				}
			    }
			}
		    }
		}
	    }
	}
	if { ! [info exists Classement($Nom)]} { set Classement($Nom) " " }
	set Report "$Nom [set Bilan($Nom)] [set StartCodonProposal($Nom)] $Decal [set Classement($Nom)]"
	Espionne $Report
	AppendAuFichier $FichierReport $Report
    }
    
    return $FichierReport

}

proc CreeStartCodonReportOld {} {

    global RepertoireDuGenome

    set FichierReport "$RepertoireDuGenome/fiches/startcodon_report"

    set AppendToIt 0
    while {[file exists $FichierReport]} {
	if {[OuiOuNon "$FichierReport already exists. \nDo I append to it ?"]} {
	    set AppendToIt 1
	    break
	}
	if {[OuiOuNon "$FichierReport already exists. \nDo I replace it ?"]} {
	    File delete -force $FichierReport
	    continue
	}
    }

    set Summary [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_summary"]
    set Cluster [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_cluster"]

    set LesNoms {}
    foreach ligne $Summary {
	if {$ligne==""} continue
	while {[regexp "  " $ligne]} {
	    regsub -all "  " $ligne " " ligne
	} 
	regsub -all $ligne + ligne " "
	set Nom [lindex $ligne 0]
	set AA  [lindex $ligne 2]
	set Pos [lindex $ligne 3]
	set IndexNbAccord [lsearch -regexp $ligne "/"]
	set NbAccord [lindex [split [lindex $ligne $IndexNbAccord] "/"] 0]
	lappend LesNoms $Nom
	lappend Classement($Nom) [list $AA $Pos $NbAccord]
	set Indice 3
	set OK 0
	foreach el [lrange $ligne 3 end] {
	    if {[string match -nocase {[a-z]*} $el]} {
		set OK 1
		break
	    }
	    incr Indice
	}
	if {$OK} {
	    set Commentaire($Nom) [lrange $ligne $Indice end]
	} else {
	    set Commentaire($Nom) " "
	}
    }
    
    set LesNoms [lsort -unique $LesNoms]
    #Categories Raymond
    # 0 Met initial conserve
    # 1 Met initial a egalite
    # 2 Autre met
    # 3 Autre met a egalite
    
    if {$AppendToIt} {
	foreach Ligne [LesLignesDuFichier $FichierReport] {
	    scan $Ligne "%s" Nom
	    set DejaVu($Nom) 1
	}
    }

    foreach Nom $LesNoms {
	if {[info exists DejaVu($Nom)]} { continue }
	set Classement($Nom) [lsort -integer -decreasing -index 2 [set Classement($Nom)]]
	set liste [set Classement($Nom)]
	if {[llength $liste]<=1 && [lindex [lindex $liste 0] 1]==1} {
	    set CatRay($Nom) 0
	} else {
	    set Premier [lindex $liste 0] 
	    set Second  [lindex $liste 1]
	    if {[lindex $Premier 1]==1} {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 1
		} else {
		    set CatRay($Nom) 0
		}
	    } else {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 3
		} else {
		    set CatRay($Nom) 2
		}
	    }
	}
    }

    #TRAITEMENT DES RESULTATS CLUSTERING
    set lesNomsCl [list]
    foreach ligne $Cluster {
	if {$ligne==""} continue
	while {[regexp "  " $ligne]} {
	    regsub -all "  " $ligne " " ligne
	}
	set liste [split $ligne " "]
	set Nom [lindex $liste 0]
	set Decal [lindex $liste 1]
	set Percent [lindex $liste 2]
	lappend LesNomsCl $Nom 
	if {[info exists Classement($Nom)]} { 
	    set MetRaymond [join [lrange [lindex [set Classement($Nom)] 0] 0 1] ""]
	} else {
	    set MetRaymond "X1"
	}
	if {[regexp "Pas" $ligne] || ! [info exists CatRay($Nom)]} { 
	    set Bilan($Nom) "white No_Value"
	    set StartCodonProposal($Nom) "None"
	} else {
	    if {[regexp "Probleme" $ligne]} {
		set Bilan($Nom) "grey Problem"
		set StartCodonProposal($Nom) "None"
	    } else {   
		if {!$Decal || $Percent>50} {
		    set Bilan($Nom) "green Validated_Start_Codon"
		    set StartCodonProposal($Nom) $MetRaymond
		} else { 
		    set Cat [set CatRay($Nom)]  
		    if {!$Cat} {
			set Bilan($Nom) "green Validated_Start_Codon" 
			set StartCodonProposal($Nom) $MetRaymond
		    } else {
			set NewDecal [expr $Decal+1]
			set Classe [set Classement($Nom)] 
			set Diff 999
			set MeilleurIndex -1
			set Index 0
			foreach el $Classe {
			    set Pos [lindex $el 1]
			    if {[expr abs($NewDecal-$Pos)]<$Diff} {
				set Diff [expr abs($NewDecal-$Pos)]
				set MeilleurIndex $Index
				if {!$Diff} break
			    }
			    incr Index
			}
			set MeilleurOdile [lindex $Classe $MeilleurIndex]
			set MetOdile [join [lrange $MeilleurOdile 0 1] ""]
			if {$Cat==2} {
			    if {$Decal<0} {
				set Bilan($Nom) "orange Doubtful_Start_Codon"
				if {$MetRaymond==$MetOdile} {
				    set StartCodonProposal($Nom) $MetRaymond
				} else {
				    set StartCodonProposal($Nom) $MetRaymond$MetOdile
				}
			    } else {
				if {!$MeilleurIndex} {
				    set Bilan($Nom) "red Wrong_Start_Codon"
				    set StartCodonProposal($Nom) $MetRaymond
				} else {
				    set Bilan($Nom) "orange Doubtful_Start_Codon"
				    set StartCodonProposal($Nom) $MetRaymond$MetOdile
				}
			    }
			} else {
			    if {[lindex $MeilleurOdile 1]==1} {
				set Bilan($Nom) "green Validated_Start_Codon"
				set StartCodonProposal($Nom) $MetOdile
			    } else {
				set Bilan($Nom) "orange Doubtful_Start_Codon"
				set StartCodonProposal($Nom) $MetOdile
				set Effectif [lindex [lindex $Classe 0] 2]
				foreach el $Classe {
				    if {[lindex $el 2]!=$Effectif} break
				    if {[lindex $MeilleurOdile 1]== [lindex $el 1]} continue
				    set StartCodonProposal($Nom) "[set StartCodonProposal($Nom)][join [lrange $el 0 1] ""]"
				} 
			    }
			}
		    }
		}
	    }
	}
	if {![info exists Classement($Nom)]} { set Classement($Nom) " "	}
	set Report "$Nom [set Bilan($Nom)] [set StartCodonProposal($Nom)] $Decal [set Classement($Nom)]"
	Espionne $Report
	AppendAuFichier $FichierReport $Report
    }
    
    return $FichierReport

}

proc CreeStartCodonReport_VOIR_LE_NOUVEAU_DANS_gscope_orfs {} {

    global RepertoireDuGenome

    set FichierReport "$RepertoireDuGenome/fiches/startcodon_report_essai"
    
    set AppendToIt 0
    while {[file exists $FichierReport]} {
	if {[OuiOuNon "$FichierReport already exists. \nDo I append to it ?"]} {
	    set AppendToIt 1
	    break
	}
	if {[OuiOuNon "$FichierReport already exists. \nDo I replace it ?"]} {
	    File delete -force $FichierReport
	    continue
	}
    }

    set Summary [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_summary"]
    set Cluster [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_cluster"]

    set LesNoms {}
    foreach ligne $Summary {
	if {$ligne==""} continue
	while {[regexp "  " $ligne]} {
	    regsub -all "  " $ligne " " ligne
	} 
	regsub -all $ligne + ligne " "
	set Nom [lindex $ligne 0]
	set AA  [lindex $ligne 2]
	set Pos [lindex $ligne 3]
	set IndexNbAccord [lsearch -regexp $ligne "/"]
	set NbAccord [lindex [split [lindex $ligne $IndexNbAccord] "/"] 0]
	lappend LesNoms $Nom
	lappend Classement($Nom) [list $AA $Pos $NbAccord]
	set Indice 3
	set OK 0
	foreach el [lrange $ligne 3 end] {
	    if {[string match -nocase {[a-z]*} $el]} {
		set OK 1
		break
	    }
	    incr Indice
	}
	if {$OK} {
	    set Commentaire($Nom) [lrange $ligne $Indice end]
	} else {
	    set Commentaire($Nom) " "
	}
    }
    
    set LesNoms [lsort -unique $LesNoms]
    #Categories Raymond
    # 0 Met initial conserve
    # 1 Met initial a egalite
    # 2 Autre met
    # 3 Autre met a egalite
    
    if {$AppendToIt} {
	foreach Ligne [LesLignesDuFichier $FichierReport] {
	    scan $Ligne "%s" Nom
	    set DejaVu($Nom) 1
	}
    }

    foreach Nom $LesNoms {
	if {[info exists DejaVu($Nom)]} { continue }
	set MetIni($Nom) [join [lrange [lindex [set Classement($Nom)] 0] 0 1] ""]
	set Classement($Nom) [lsort -integer -decreasing -index 2 [set Classement($Nom)]]
	set liste [set Classement($Nom)]
	if {[llength $liste]<=1 && [lindex [lindex $liste 0] 1]==1} {
	    set CatRay($Nom) 0
	} else {
	    set Premier [lindex $liste 0] 
	    set Second  [lindex $liste 1]
	    if {[lindex $Premier 1]==1} {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 1
		} else {
		    set CatRay($Nom) 0
		}
	    } else {
		if {[lindex $Premier 2]==[lindex $Second 2]} {
		    set CatRay($Nom) 3
		} else {
		    set CatRay($Nom) 2
		}
	    }
	}
    }

    #TRAITEMENT DES RESULTATS CLUSTERING
    set lesNomsCl [list]
    foreach ligne $Cluster {
	if {$ligne==""} continue
	while {[regexp "  " $ligne]} {
	    regsub -all "  " $ligne " " ligne
	}
	set liste [split $ligne " "]
	set Nom [lindex $liste 0]
	set Decal [lindex $liste 1]
	set Percent [lindex $liste 2]
	lappend LesNomsCl $Nom 
	if {[info exists Classement($Nom)]} { 
	    set MetRaymond [join [lrange [lindex [set Classement($Nom)] 0] 0 1] ""]
	} else {
	    set MetRaymond "X1"
	}
	if {[regexp "Pas" $ligne] || ! [info exists CatRay($Nom)]} { 
	    set Bilan($Nom) "white No_Value"
	    set StartCodonProposal($Nom) "None"
	} else {
	    if {[regexp "Probleme" $ligne]} {
		set Bilan($Nom) "grey Problem"
		set StartCodonProposal($Nom) "None"
	    } else {   
		if {!$Decal || $Percent>50} {
		    set Bilan($Nom) "green Validated_Start_Codon"
		    set StartCodonProposal($Nom) [set MetIni($Nom)]
		} else { 
		    if {$Decal<-3} {
			set Deb [Box $Nom debut]
			set Fin [Box $Nom fin]
			set Orient [Box $Nom orient]
			scan [BornesDuGeneEtendu $Nom] "%s %s %s %s" x DebEtend FinEtend OrientEtend
			if {$Deb==$DebEtend && $Fin==$FinEtend} {
			    set Bilan($Nom) "green Validated_Start_Codon" 
			    set StartCodonProposal($Nom) [set MetIni($Nom)]
			} else {
			    if {$Deb!=$DebEtend} {
				set Diff [expr $Deb-$DebEtend]
			    } else {
				set Diff [expr $FinEtend-$Fin]
			    }
			    set NucEtendu [BoutADN $DebEtend $FinEtend $OrientEtend]
			    set NewMet [AAduCodon [string range $NucEtendu 0 2]]
			    set NewPos [expr $Diff/3]
			    if {$NewPos>2} {
				set Bilan($Nom) "blue Truncated_Gene"
				set StartCodonProposal($Nom) "${NewMet}-$NewPos"
			    } else {
				set Bilan($Nom) "green Validated_Start_Codon" 
				set StartCodonProposal($Nom) [set MetIni($Nom)]
			    }
			}
		    } else {
			set Cat [set CatRay($Nom)]  
			if {!$Cat} {
			    set Bilan($Nom) "green Validated_Start_Codon" 
			    set StartCodonProposal($Nom) $MetRaymond
			} else {
			    set NewDecal [expr $Decal+1]
			    set Classe [set Classement($Nom)] 
			    set Diff 999
			    set MeilleurIndex -1
			    set Index 0
			    foreach el $Classe {
				set Pos [lindex $el 1]
				if {[expr abs($NewDecal-$Pos)]<$Diff} {
				    set Diff [expr abs($NewDecal-$Pos)]
				    set MeilleurIndex $Index
				    if {!$Diff} break
				}
				incr Index
			    }
			    set MeilleurOdile [lindex $Classe $MeilleurIndex]
			    set MetOdile [join [lrange $MeilleurOdile 0 1] ""]
			    if {$Cat==2} {
				if {$Decal<0} {
				    set Bilan($Nom) "orange Doubtful_Start_Codon"
				    if {$MetRaymond==$MetOdile} {
					set StartCodonProposal($Nom) $MetRaymond
				    } else {
					set StartCodonProposal($Nom) $MetRaymond$MetOdile
				    }
				} else {
				    if {!$MeilleurIndex} {
					set Bilan($Nom) "red Wrong_Start_Codon"
					set StartCodonProposal($Nom) $MetRaymond
				    } else {
					set Bilan($Nom) "orange Doubtful_Start_Codon"
					set StartCodonProposal($Nom) $MetRaymond$MetOdile
				    }
				}
			    } else {
				if {[lindex $MeilleurOdile 1]==1} {
				    set Bilan($Nom) "green Validated_Start_Codon"
				    set StartCodonProposal($Nom) $MetOdile
				} else {
				    set Bilan($Nom) "orange Doubtful_Start_Codon"
				    set StartCodonProposal($Nom) $MetOdile
				    set Effectif [lindex [lindex $Classe 0] 2]
				    foreach el $Classe {
					if {[lindex $el 2]!=$Effectif} break
					if {[lindex $MeilleurOdile 1]== [lindex $el 1]} continue
					set StartCodonProposal($Nom) "[set StartCodonProposal($Nom)][join [lrange $el 0 1] ""]"
				    } 
				}
			    }
			}
		    }
		}
	    }
	}
	if {![info exists Classement($Nom)]} { set Classement($Nom) " "	}
	set Report "$Nom [set Bilan($Nom)] [set StartCodonProposal($Nom)] $Decal [set Classement($Nom)]"
	Espionne $Report
	AppendAuFichier $FichierReport $Report
    }
    
    return $FichierReport

}

proc CreeStartCodonSummary {{Ask ""}} {

    global RepertoireDuGenome

    set FichierSummary  "$RepertoireDuGenome/fiches/startcodon_summary"
    if {$Ask=="FileName" && [file exists $FichierSummary]} { return $FichierSummary }

    if {$Ask=="" || $Ask=="Replace"} { set Ask 0 } else { set Ask 1}

    if {[file exists $FichierSummary]} {
	if { ! $Ask || [OuiOuNon "$FichierSummary\n already exists. Do I keep it ?" 0]} {
	    File delete $FichierSummary
	} else {
	   return $FichierSummary
	} 
    }

    set Sortie {}
    foreach Nom [ListeDesPABs] {
	set Poch [ExtraitInfo $Nom "met"]
	set MetRR [ExtraitInfo $Nom "MetRR"]
	set CS [CodonStart $Nom]
	if {$CS==""} { continue }
	set TailleDuGroupe 999
	set NombreDeSequences 999	
	if {[regexp "GroupSize" $CS]} {
	    scan $CS "%s %d %d" Bidon TailleDuGroupe NombreDeSequences
	    regsub {GroupSize [0-9]+ [0-9]+ } $CS "" CS
	}
	set LesDejaVus {}
	set OldOv [OverlapAtStart $Nom]
	FromDisphy $Nom
	Espionne "$Nom $CS"
	if { ! [regexp -nocase {^[A-Z]+ [0-9]+ } $CS]} { continue }
	if {[regexp -nocase " / " $CS]} {
	    FaireLire "I found an error in CodonStart. Please correct it"
	    set CS [Entre $CS]
	}
	foreach {AA P Accesses} [split $CS " "] {
	    set NewOv [expr $OldOv - ($P-1)*3]
	    if {$NewOv<0} { set NewOv "+[expr -$NewOv]" }
	    set LesAccess [split $Accesses "/"]
	    set nAcc [llength $LesAccess]
	    set CumulDisAli 0
	    set nCumul 0
	    set Distances ""
	    foreach Access $LesAccess {
		set DisAli [FromDisphy $Access]
		append Distances "/$DisAli"
		if {$DisAli==""} { continue }
		incr nCumul
		incr CumulDisAli $DisAli
	    }
	    if {$nCumul==0} {
		set MoyDisAli 999
	    } else {
		set MoyDisAli [expr $CumulDisAli/$nCumul]
	    }
	    Espionne "$Accesses\n$Distances $MoyDisAli"
	    set GGTtoATG [ShineDalgarnoSiNouveauMet $Nom $P]
	    set iGGT [string length $GGTtoATG]
	    
	    if {$MetRR==""} {
		set RemarquePochOuMetRR $Poch
	    } else {
		scan $MetRR "%s %d" MVL BonMet
		if {$BonMet==$P} {
		    set RemarquePochOuMetRR "Better $MetRR"
		} else {
		    set RemarquePochOuMetRR ""
		}
	    } 
	    lappend LesDejaVus [format "$Nom %3d %s %4d  %3d %4s  %3d/%3d %3d %3d = %-20s %s"  $iGGT $AA $P $OldOv $NewOv  $nAcc $TailleDuGroupe $NombreDeSequences $MoyDisAli  $RemarquePochOuMetRR $GGTtoATG]
	}
	if {$LesDejaVus=={}} { continue }
	lappend Sortie "\n[join $LesDejaVus "\n"]"
    }
    return [SauveLesLignes $Sortie dans $FichierSummary]    

}

proc CreeSummary {} {

    # cree liste des alignements
    cd yeast

    set fo [open alignment_list.html w]
    puts $fo ""
    puts $fo ""
    puts $fo ""
    puts $fo ""
    puts $fo "
List of protein alignments :

"
    set Lf [lsort [glob *]]
    set i 0
    puts $fo "
"
    set ligne ""
    foreach f $Lf {
	if {$i >= 20} {
	    set i 0
	    puts $fo $ligne
	    set ligne ""
	}
	append ligne "   $f   "
	incr i
    }
    puts $fo $ligne
    puts $fo "
"
    puts $fo "
"
    
    cd ../
    # cree index.html
    set fo [open ./index.html w]
    
    puts $fo "
"
    puts $fo "[DonneDateEtHeure]
"
    puts $fo "
Summary of Codon biais results

"
    puts $fo "3003 PDB chains"
    set db "toto"
    sqlite3 $db rrps.sql
    set Npdbok [$db eval {select count(distinct(pdbid)) from items where taxid=4932}]
    set Nchnok [$db eval {select count(pdbid) from items where taxid=4932}]
    set Naccok [$db eval {select count(distinct(accession)) from items where taxid=4932}]
    puts $fo "$Npdbok PDB ok
"
    puts $fo "$Nchnok chains ok
"
    puts $fo "$Naccok unique UniProt ok

"

    # lignements
    puts $fo "Alignments 
"

    # wobble
    puts $fo "wobble table based on  this page
"
    puts $fo "Article : tRNA genes and retroelements in the yeast genome. J Hani and H Feldmann Nucleic Acids Res. 1998 Feb 1; 26(3): 689696. 
"


    # histogram length
    puts $fo "
Distribution of protein lengths
"
    puts $fo [ContenuDuFichier ./ToPrint/distri_lgt.html]


    # explication
    puts $fo "Explications basiques"

    puts $fo "
Pour les calculs, on prend les protéines de longueur > 200 aas, soit 493 protéines"
    # clustering
    puts $fo "
Clusterings on data
"
    puts $fo "Pour aller aux clusters triés (cd Petite Explication) chercher 'highest' dans la page. Attention ! il y a évidemment 1 'highest' par threshold !"
    puts $fo "
"
    puts $fo "
kmeans - dpc

"
    puts $fo "
mixture model - aic

"
    puts $fo "
mixture model - bic

"
    puts $fo "
hierarchic - secator

"
    puts $fo "
"

    # GO enrichment
    puts $fo "
Enrichment tests based on clustering mixture model - aic, threshold 60.
"
    puts $fo "Take first cluster, 255 proteins over 493
"
    puts $fo "See the web site  GO enrichment in Gene Ontology
"
    puts $fo "GO : biologicla process
"
    puts $fo "GO : molecular function
"
    puts $fo "GO : cellular component
"
    # all prots
    puts $fo "
Enrichment based on all proteins
"
    puts $fo "Biological Process
"
    puts $fo "Molecular Function
"
    puts $fo "Cellular Component
"

    # donnes brutes
    puts $fo "
Données brutes
"
    set Ld [lsort [glob ./ToPrint/data_*.html]]
    puts $fo "
"
    foreach f $Ld {
	set pc [string range $f 15 16]
	puts $fo "
threshold $pc % et le fichier CSV  est ici ! 

"
    }
    puts $fo "

"

    puts $fo ""
    close $fo

    exit

}

proc CreeTFADeTousLesPABs {} {

    global RepertoireDuGenome

    set FichierTFAs "$RepertoireDuGenome/db/proteines.tfa"

    if {[file exists $FichierTFAs]} {
	if {[OuiOuNon "$FichierTFAs\n already exists. Do I replace it ?"]} {
	    File delete $FichierTFAs
	} else {
	    return $FichierTFAs
	}
    }
    set Rep [file dirname $FichierTFAs]
    if { ! [file exists $Rep]} { File mkdir $Rep }
    
    foreach Nom [ListeDesPABs] {
	set SeqPro [ContenuDuFichier "$RepertoireDuGenome/prottfa/$Nom"]
	set BanqueId "[string toupper [PreFixe]]:$Nom"
	regsub {^>} $SeqPro ">$BanqueId " SeqPro
	AppendAuFichier $FichierTFAs $SeqPro
    }
    return $FichierTFAs

}

proc CreeTFASelonAccess {lAccess} {

   
    global RepAJour

    set ficOutTar "bird.tar.gz"
    set ficOut    "listeResu"
    # listeBid va contenir la liste des bId effectivement present dans le fichier tfa
    # les nouvelles sequences sont ajoutees en fin de fichier
    
    set listeBid ""
    set LesTFAs  ""
    set ficOutTfa   [file join $RepAJour "MS2PH.tfa"]

    # recuperation des sequences selon access en interrogeant BIRD
    set test [RecupAccSeqParBird $lAccess 1]
    # si la requete dans BIRD s est bien deroulee
    if {$test == 1} {
	if {[file exists $ficOutTar]} {
	    # le fichier de resultat est dezippe - detare
	    eval exec tar -xzf $ficOutTar
	    if {[file exists ${ficOut}.sw]} {
		# on recupere les lignes du fichier qui nous interesse
		set lignes [LesLignesDuFichier ${ficOut}.sw]
		foreach acc $lAccess {
		    # creation d une liste contenant les donnees relatives au TFA
		    set TFA ""
		    set idx [lsearch -regexp $lignes $acc]
		    if {$idx != -1} {
			# si on a bien des donnees relatives a l access courant
			lappend TFA ">$acc"
			# on saute les listes d Access (peuvent etre sur +sieurs lignes)
			while {[string first "AC" [lindex $lignes $idx]] == 0} {
			    incr idx
			}
			# on saute encore 1 ligne qui est celle qui contient la long de la sequence
			set i     [expr $idx + 1]
			set ligne [lindex $lignes $i]
			# recuperation de la sequence
			while {[string first "//" $ligne] == -1} {
			    lappend TFA [string trim $ligne]
			    incr i
			    set ligne [lindex $lignes $i]
			}
		    }
		    foreach e $TFA {
			lappend LesTFAs $e
		    }
		}
	    }
	}
	
    } else {
	puts "Probleme dans la recuperation des sequences!"
	
    }
    
    return $LesTFAs

}

proc CreeTableRecapDesClusters {{UseFile ""}} {

    global TabRecap

    if {$UseFile==""} { set UseFile "UseFile" }

    set FichierTabRecap "[RepertoireDuGenome]/transcriptomique/MetaCluster/RecapPourClusteringAll"

    if {[string equal -nocase $UseFile "UseFile"] && [FileExists $FichierTabRecap]} {
	array set TabRecap [LesLignesDuFichier $FichierTabRecap]
	return
    }

    set RepertoireTranscriptomique "[RepertoireDuGenome]/transcriptomique/cluster"
    set LesExp [InterrogeExAs ListOf Exp]
    set LesExp [ListeSansDoublon $LesExp]
    foreach Exp $LesExp {
	set LesAnalSoft {}; set LesClusSoft {}; set LesClusSoft2 {}
	set ExpRaccourci [string range $Exp 0 24]
	regsub -all " " $ExpRaccourci "_" ExpRaccourci
	set LesAnalSoft [InterrogeExAs $Exp AnalSoft]
	set LesClusSoft [InterrogeExCs $Exp ClusSoft]
	foreach clus $LesClusSoft {
	    set LesMots [LesMotsDeLaLigne $clus]
	    set un    [lindex $LesMots 0]
	    set deux  [lindex $LesMots 3]
	    set trois [lindex $LesMots 4]
	    set clus2 "$un$deux$trois"
	    lappend LesClusSoft2 $clus2
	}
	foreach anal $LesAnalSoft {
	    regsub -all " " $anal "" anal
	    set I 0
	    foreach clus $LesClusSoft clus2 $LesClusSoft2 {
		set Tete "$ExpRaccourci/$anal/$clus2"
		lappend LesTetes $Tete
		set TeteComp "$Exp/$anal/$clus"
		lappend LesTetesComp $TeteComp
		set CompletDeTete($Tete) $TeteComp
		set CourtDeTeteComp($TeteComp) $Tete
	    }
	}
    }
   
    foreach File [glob -nocomplain "$RepertoireTranscriptomique/*"] {
	set Queue [file tail $File]
	lappend LesQueues $Queue
	foreach Ligne [LesLignesDuFichier $File] {
	    set LesMots [split $Ligne "\t"]
	    ScanLaListe $LesMots Bidon ExpPs AnalPs ClusPs NumClus
	    regsub -all " " $AnalPs "" AnalPs
	    set TeteCompFile "$ExpPs/$AnalPs/$ClusPs"
	    if {[info exists CourtDeTeteComp($TeteCompFile)]} {
		set TeteCourt $CourtDeTeteComp($TeteCompFile)
	    } else {
		AppendAuFichier "[Fiches]/missingHeader.log" $TeteCompFile
		continue 
	    }
	    set T($Queue,$TeteCourt) $NumClus
	    if {$NumClus!=""} { set TeteValide($TeteCourt) 1 }
	}
    }

    set TabRecap(LesTetesValides) {}
    foreach Queue $LesQueues {
	#Espionne "Queue $Queue"
	lappend TabRecap(LesQueues) $Queue
	set LaLigne [list $Queue]
	foreach Tete $LesTetes {
	    if { ! [info exists TeteValide($Tete)]} { continue }
	    if { ! [info exists DejaVu($Tete)]} {
		lappend TabRecap(LesTetesValides) $Tete
		set DejaVu($Tete) 1
	    }
	    #Espionne "Tete $Tete"
	    if {[info exists T($Queue,$Tete)]} {
		set Case $T($Queue,$Tete)
		#Espionne "Case $Case"
	    } else {
		set Case "-1"
	    }
	    lappend LaLigne $Case
	}
	set TabRecap($Queue) [join $LaLigne " "]
    }
    #return [SauveLesLignes [array get TabRecap] dans $FichierTabRecap]

}

proc CreeTableauBlastCGH {FichierBlast FichierSortie} {

    # pb initial: on ne voit pas l'essentiel dans le display du blast, a savoir la fin de l'entete de la sequence subject (type de cas, valeur de l'amplification ou de la deletion)
    # cree un tableau : "Entete_subject(entiere)"\t"Score"\t"Expect"

    if {![file exists $FichierBlast]} {return ""}

    set SuisJeSurLesAlignements 0
    set SuisJeSurUnAlignement 0
    set ToutLeSubject ""
    set TousLesSubjects {}
    set j 0
    set Score "" ; set Expect ""; set Identities ""
    #set SuisJeSurLeNomDeLaQuery 0

    DepouilleLeBlast      TabBlast $FichierBlast "1e-3"
    
    set NbSbjct      [set TabBlast(NbSubject)]
    set TailleQuery  [set TabBlast(Taille)]
    set NomQuery     [set TabBlast(Query)]
    
    set F [open $FichierBlast]
    while {[gets $F Ligne]>=0} {
	if {[string range $Ligne 0 0] == ">"} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    if {$Score!="" && $Expect!=""} {
		lappend ToutesLesInfosSupp "$Score\t$Expect\t$Identities"
	    }
	    set ToutLeSubject ""
	    set SuisJeSurLesAlignements 1
	    set SuisJeSurUnAlignement 1
	    regsub "\n" $Ligne "" Ligne
	    append ToutLeSubject $Ligne
	} elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
	    regsub "\n" $Ligne "" Ligne
	    append ToutLeSubject "\n$Ligne"
	    if {[string range $Ligne 0 8] == " Score = "} {
		set Score "" ; set Expect ""
		regexp {Score = ([e0-9a-z\.\+\(\) ]+)} $Ligne tmp Score 
		regsub {Score = [e0-9a-z\.\+\(\) ]+}   $Ligne "" Ligne
		set Score [string trim $Score]
		regexp { Expect =([ e0-9\.\-]+)} $Ligne tmp Expect
		regsub { Expect =[ e0-9\.\-]+}   $Ligne ""  Ligne
		set Expect [string trim $Expect]
		if {[regexp "^e" $Expect]} { set Expect "1$Expect"}
		set SuisJeSurLesAlignements 0
		set SuisJeSurUnAlignement 0
	    }
	}	
    }
    close $F
    if {$TousLesSubjects=="" && $ToutLeSubject!=""} {
	lappend TousLesSubjects $ToutLeSubject
	if {$Score!="" && $Expect!=""} {
	    lappend ToutesLesInfosSupp "$Score\t$Expect\t$Identities"
	}
    }
    
    foreach Subject $TousLesSubjects {
	regexp -indices " Length = " $Subject DebFin
	set EnteteSubject [string trim [string range $Subject 1 [lindex $DebFin 0]]]
	regsub -all "\n" $EnteteSubject "" EnteteSubject
	while {[regexp "  " $EnteteSubject]} {regsub -all "  " $EnteteSubject " " EnteteSubject}
	lappend LesEntetesSubject $EnteteSubject
	set Subject [string range $Subject [lindex $DebFin 0] end]
    }
    foreach Entete $LesEntetesSubject Info $ToutesLesInfosSupp {
	lappend LaTotale "$Entete\t$Info"
    }
    SauveLesLignes $LaTotale dans $FichierSortie

}

proc CreeTableauBlastCGHPourTous {RepFichierBlast RepSortie} {

    # pb initial: on ne voit pas l'essentiel dans le display du blast, a savoir la fin de l'entete de la sequence subject (type de cas, valeur de l'amplification ou de la deletion)
    # cree un tableau : "Entete_subject(entiere)"\t"Score"\t"Expect"

    if {![file exists $RepFichierBlast]} {return ""}
    if {![file exists $RepSortie]} {file mkdir "[RepertoireDuGenome]/$RepSortie"}

    foreach FichierBlast [glob -nocomplain $RepFichierBlast/*] {
	set NomFichier [file tail $FichierBlast]
	if {[file exists "[RepertoireDuGenome]/$RepSortie/$NomFichier"]} {Espionne "$NomFichier already done";continue}
	Espionne "$NomFichier on going"
	DepouilleLeBlast      TabBlast $FichierBlast "1e-3"
	
	set NbSbjct      [set TabBlast(NbSubject)]
	set TailleQuery  [set TabBlast(Taille)]
	set NomQuery     [set TabBlast(Query)]
	#Espionne "nbsub=$NbSbjct -taillequery=$TailleQuery - NomQuery=$NomQuery"
	set SuisJeSurLesAlignements 0
	set SuisJeSurUnAlignement 0
	set TousLesSubjects ""
	set ToutLeSubject ""
	set ToutesLesInfosSupp ""
	set LesEntetesSubject ""
	set LaTotale ""
	set Score ""; set Expect ""; set Identities ""

	set F [open $FichierBlast]
	while {[gets $F Ligne]>=0} {
	    if {[string range $Ligne 0 0] == ">"} {
		if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
		if {$Score!="" && $Expect!=""} {
		    lappend ToutesLesInfosSupp "$Score\t$Expect\t$Identities"
		}
		set ToutLeSubject ""
		set SuisJeSurLesAlignements 1
		set SuisJeSurUnAlignement 1
		regsub "\n" $Ligne "" Ligne
		append ToutLeSubject "$Ligne"
	    } elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
		regsub "\n" $Ligne "" Ligne
		append ToutLeSubject "\n$Ligne"
		if {[string range $Ligne 0 8] == " Score = "} {
		    set Score "" ; set Expect ""
		    regexp {Score = ([e0-9a-z\.\+\(\) ]+)} $Ligne tmp Score 
		    regsub {Score = [e0-9a-z\.\+\(\) ]+}   $Ligne "" Ligne
		    set Score [string trim $Score]
		    
		    regexp { Expect =([ e0-9\.\-]+)} $Ligne tmp Expect
		    regsub { Expect =[ e0-9\.\-]+}   $Ligne ""  Ligne
		    set Expect [string trim $Expect]
		    if {[regexp "^e" $Expect]} { set Expect "1$Expect"}
		    set SuisJeSurLesAlignements 0
		    set SuisJeSurUnAlignement 0
		}
	    }	
	}
	close $F
	
	foreach Subject $TousLesSubjects {
	    regexp -indices " Length = " $Subject DebFin
	    set EnteteSubject [string trim [string range $Subject 1 [lindex $DebFin 0]]]
	    regsub -all "\n" $EnteteSubject "" EnteteSubject
	    while {[regexp "  " $EnteteSubject]} {regsub -all "  " $EnteteSubject " " EnteteSubject}
	    lappend LesEntetesSubject $EnteteSubject
	    set Subject [string range $Subject [lindex $DebFin 0] end]
	}
	foreach Entete $LesEntetesSubject Info $ToutesLesInfosSupp {
	    lappend LaTotale "$Entete\t$Info"
	}
	SauveLesLignes $LaTotale dans "[RepertoireDuGenome]/$RepSortie/$NomFichier"
	Espionne "$NomFichier done"
    }

}

proc CreeTableauDeValeursAffyPourGeneCible {Chro Start End {LesNoms ""} {LesPos ""}} {

    # A revoir: utiliser le fichier HG_U95Av2_annot.csv pour trouver les ps spe des genes (NM)
    set LesSamples {7 8 821 855 818 918 920 889 925 845 886 819 45 926 923 924 706 711 921}
    
    # 1- Search for the probesets located at the gene locus.
    # from proc ac_IllustreUnChromosome
    set LesPSDuGene {}

    regsub "HS" $Chro "" num
    if {[regexp "^0" $num]} {regsub "0" $num "" num}
    set Chrom "chr$num"
    set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets]
    foreach ProbeSet $LesProbeSets {
	set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome]
	## cas ou pls chros
	if {[llength $LesChros]>1} {
	    set Warning($ProbeSet) 1
	    regsub " " $LesChros "" LesChros
	    set C($ProbeSet) $LesChros
	}
	
	set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] 
	set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin]
	
	if {[llength $LesDebuts]!=[llength $LesFins]} {Espionne "pb loc de $ProbeSet"; continue}
	foreach Debut $LesDebuts Fin $LesFins {
	    set PosMid [expr ($Fin-$Debut)/2 + $Debut]
	    
	    if {($Debut<=$End && $Debut>=$Start) || ($Fin>=$Start && $Fin<=$End)} {
		lappend LesPSDuGene $ProbeSet
	    }
	}
    }
    EspionneL "probeset(s): $LesPSDuGene"

    # 2- Retrieve the values for probesets (if exists) for all patient samples

    if {$LesPSDuGene!={}} {
	foreach PS $LesPSDuGene {
	    set LesValeursDePS($PS) {}
	    foreach Sample $LesSamples {
		set Vu 0
		set NomFichier "RMA$Sample"
		#Espionne $NomFichier
		set FichierCourbeAffy "[RepertoireDuGenome]/PRIMA_Affy/$NomFichier"
		
		if {[file exists $FichierCourbeAffy]} {
		    ChargeFichierAffyRMA TabRMA $FichierCourbeAffy
		    
		    set Val [InterrogeFichierAffyRMA $FichierCourbeAffy $PS Val]
		    if {$Val==""} {Espionne "no val for $PS"}
		    set Vu 1
		    lappend LesValeursDePS($PS) $Val
		}
		if {$Vu==0} {lappend LesValeursDePS($PS) " "}
	    }
	    # end of the samples
	    Espionne "PS = $PS"
	    EspionneL $LesValeursDePS($PS)
	}
    }
    

}

proc CreeTableauDeValeursPourGeneCible {Chro Start End {LesNoms ""} {LesPos ""}} {

    set LesSamples {806 810 817 818 819 826 825 812 823 809 811 814 816 820 821 822 815 807 827}

    # 1- Search for the BAC and oligos located at the gene locus.
    set LesBACsDuGeneCible {}
    set LesOligosDuGeneCible {}

    set FichierBACLoc "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation"
    set FichierOligoLoc "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation"

    ChargeFichierLoc TabB $FichierBACLoc $Chro $LesNoms
    ChargeFichierLoc TabO $FichierOligoLoc $Chro $LesNoms
    
    if {[info exists TabB($FichierBACLoc,Chromosome,$Chro,LesNoms)]} {
	foreach Nom [set TabB($FichierBACLoc,Chromosome,$Chro,LesNoms)] {
	    foreach LInfo [set TabB($FichierBACLoc,Chromosome,$Chro,$Nom)] {
		set DebutBAC [expr [lindex $LInfo 1]*1.0]
		set FinBAC [expr [lindex $LInfo 2]*1.0]
		set PosMidBAC [expr ($FinBAC-$DebutBAC)/2 +$DebutBAC]
		# Comparison of gene position and BAC position
		if {$DebutBAC<$Start && $FinBAC>$End} {lappend LesBACsDuGeneCible $PosMidBAC}
	    }
	}
    }

    if {[info exists TabO($FichierOligoLoc,Chromosome,$Chro,LesNoms)]} {
	foreach Nom [set TabO($FichierOligoLoc,Chromosome,$Chro,LesNoms)] {
	    set NomOligo $Nom
	    #Espionne $NomOligo
	    foreach LInfo [set TabO($FichierOligoLoc,Chromosome,$Chro,$Nom)] {
		set DebutOli [expr [lindex $LInfo 1]*1.0]
		set FinOli [expr [lindex $LInfo 2] *1.0]
		set PosMidOligo [expr ($FinOli-$DebutOli)/2 +$DebutOli]
		set AccessGene [lindex $LInfo 5]
		set GN [lindex $LInfo 6]
		set Des [lindex $LInfo 7]
		# Comparison of the positions
		if {$DebutOli>=$Start && $FinOli<=$End} {lappend LesOligosDuGeneCible $PosMidOligo}
	    }
	}
    }
    EspionneL "BAC: $LesBACsDuGeneCible"
    EspionneL "Oligo: $LesOligosDuGeneCible"

    # 2- Retrieve the values for BAC and oligos (if exists) for all patient samples

    if {$LesBACsDuGeneCible!={}} {
	foreach BACpos $LesBACsDuGeneCible {
	    set LesValeursDuBAC($BACpos) {}
	    foreach Sample $LesSamples {
		set Vu 0
		set NomFichier "BAC$Sample"
		#Espionne $NomFichier
		set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$NomFichier"

		ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chro $LesPos
		if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chro,LesPos)]} {
		    foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chro,LesPos)] {
			foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chro,$Pos)] {
			    set PosMid [lindex $LInfo 1]
			    # Find the BAC associated to the target gene
			    if {$PosMid==$BACpos} {
				set Vu 1
				set Val [lindex $LInfo 2]
				lappend LesValeursDuBAC($BACpos) $Val
			    }
			}
		    }
		}
		if {$Vu==0} {lappend LesValeursDuBAC($BACpos) " "}
	    }
	    # end of the samples
	    Espionne "BAC posmid = $BACpos"
	    EspionneL $LesValeursDuBAC($BACpos)
	}
    }

    if {$LesOligosDuGeneCible!={}} {
	foreach OligoPos $LesOligosDuGeneCible {
	    set LesValeursDeOligo($OligoPos) {}
	    foreach Sample $LesSamples {
		set NomFichier "Oligo$Sample"
		#Espionne $NomFichier
		set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$NomFichier"
		
		ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chro $LesPos
		if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chro,LesPos)]} {
		    foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chro,LesPos)] {
			if {$Pos==$OligoPos} {
			    foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chro,$Pos)] {
				set Val [lindex $LInfo 3]
				# from log10 to log2
				set Val [expr $Val*log(10)/log(2)]
				lappend LesValeursDeOligo($OligoPos) $Val
				break
			    }
			}
		    }
		}
	    }
	    # end of all the samples 
	    Espionne "oligo posmid = $OligoPos"
	    EspionneL $LesValeursDeOligo($OligoPos)
	}
    }
    
    # 3- Search for the BAC segments containing the target gene and retrieve of the values
    
    set LesValeursDeSegBAC {}
    set LesValeursDeSegOligo {}

    foreach Sample $LesSamples {
	set Vu 0 

	set NomFichier "BAC$Sample\.seg"
	set FichierSegBAC "[RepertoireDuGenome]/PRIMA_CGH_SEG/$NomFichier"
	
	ChargeFichierSEG TabS $FichierSegBAC $Chro $LesPos
	if {[info exists TabS($FichierSegBAC,Chromosome,$Chro,LesPos)]} {
	    foreach Pos [set TabS($FichierSegBAC,Chromosome,$Chro,LesPos)] {
		foreach LInfo [set TabS($FichierSegBAC,Chromosome,$Chro,$Pos)] {
		    set PosInf [lindex $LInfo 3]
		    set PosSup [lindex $LInfo 4]
		    # Comparison of gene position and BAC segment position
		    if {$PosInf<=$Start && $PosSup>=$End} {
			set Vu 1
			# then one segment contains our target gene
			set Val [lindex $LInfo 6]
			lappend LesValeursDeSegBAC $Val
			# NB: if the gene is on two segments, then there will be 2 values for one sample
		    }
		}
	    }
	}
	if {$Vu==0} {lappend LesValeursDeSegBAC " "}
    }
    Espionne "BAC seg:"
    EspionneL $LesValeursDeSegBAC

    # 3- Search for the Oligo segments containing the target gene and retrieve of the values
    
    foreach Sample $LesSamples {
	set Vu 0 

	set NomFichier "Oligo$Sample\.seg"
	set FichierSegOligo "[RepertoireDuGenome]/PRIMA_CGH_SEG/$NomFichier"
	
	ChargeFichierSEG TabE $FichierSegOligo $Chro $LesPos
	if {[info exists TabE($FichierSegOligo,Chromosome,$Chro,LesPos)]} {
	    foreach Pos [set TabE($FichierSegOligo,Chromosome,$Chro,LesPos)] {
		foreach LInfo [set TabE($FichierSegOligo,Chromosome,$Chro,$Pos)] {
		    set PosInf [lindex $LInfo 3]
		    set PosSup [lindex $LInfo 4]
		    # Comparison of gene position and Oligo segment position
		    if {$PosInf<=$Start && $PosSup>=$End} {
			set Vu 1
			# then one segment contains our target gene
			set Val [lindex $LInfo 6]
			lappend LesValeursDeSegOligo $Val
		    }
		}
	    }
	}
	if {$Vu==0} {lappend LesValeursDeSegOligo " "}
    }
    Espionne "oligo seg:"
    EspionneL $LesValeursDeSegOligo
    

}

proc CreeTableauPRIMA {Rep FichierAccess FichierOut FichierOutVal} {

    set Liste1 {806 810 817 818 819 826 825 812 823 809 811 814 816 820 821 822 815 807 827}

    set Liste2 {}
    set Liste2Val {}
    set LesAccessRecherches {}
    
    foreach file [glob -nocomplain $Rep/*] { 
	Espionne $file

	# Recuperer l'access de la query et le numero du "patient sample" dans "Query=..." du blast:
	DepouilleLeBlast TabBlast $file "1e-3"
	set q [set TabBlast(Query)]
	set LesElts [split $q "\|"]
	set AccessQuery [lindex $LesElts 1]

	set LesEltsDeLaFin [split [lindex $LesElts 2] " "]
	set Sample [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-4]]
	if {[regexp -nocase "BAC" $Sample]} {regsub "BAC" $Sample "" Patient} else {regsub "Oligo" $Sample "" Patient}

	# Liste des numeros des "patient samples" ou la proteine est amplifiee ou deletee trouves dans le blast:
	set M2 {}
	if {$Patient!="" && [regexp {^8[0-9][0-9_]$} $Patient]} {lappend M2 $Patient}
	
	if {[info exists Val]} {unset Val}

	# Liste temoin des recherches effectuees:
	lappend LesAccessRecherches $file

	# Liste de tous les access possibles de la Query
	set LesAccessQuery2 {}

	####################################################################
	# Recherche par SRS (getz) des access equivalents a l'access Query: 
	# Creation d'une liste d'access contenant l'access de la Query

	if {[regexp -nocase "NP" $AccessQuery]} {
	    # L'access de la Query est Refseq

	    set Commande "getz \"\\\[\\\{refseqprelease refseqpnew\\\}-acc:$AccessQuery\\\]\\\>\\\[protein-org:Homo sapiens\\\]\" \-vf acc"
	    set GetzOut [eval exec $Commande]
	    
	    if {$GetzOut==""} {
		set LesAccessQuery2 {}
	    } else { 
		set GetzOut [join $GetzOut " "]
		set LesElts [split $GetzOut " "]
		foreach Elt $LesElts {
		    if {[regexp "\:" $Elt]} { continue }
		    lappend LesAccessQuery2 $Elt
		}
	    }
	    
	    lappend LesAccessQuery2 $AccessQuery

	} else {
	    # L'access de la query n'est pas Refseq

	    set Commande "getz \"\\\[protein-acc:$AccessQuery\\\]\\\>\\\[\\\{refseqprelease refseqpnew\\\}-org:Homo sapiens\\\]\" \-vf acc"
	    set GetzOut [eval exec $Commande]

	    if {$GetzOut==""} {
		set LesAccessQuery2 {}
		lappend LesAccessQuery2 $AccessQuery
	    } else { 
		set GetzOut [join $GetzOut " "]
		set LesElts [split $GetzOut " "]
		foreach Elt $LesElts {
		    if {[regexp "\:" $Elt]} { continue }
		    lappend LesAccessQuery2 $Elt
		}
	    }

	    # Recherche de TOUS les access "protein" a partir de l'access refseq recupere:
	    if {$LesAccessQuery2!=""} {
		set A1 [lindex $LesAccessQuery2 0]
		
		if {[regexp -nocase "NP" $A1]} {
		    set Commande2 "getz \"\\\[\\\{refseqprelease refseqpnew\\\}-acc:[lindex $LesAccessQuery2 0]\\\]\\\>\\\[protein-org:Homo sapiens\\\]\" \-vf acc"
		    set GetzOut2 [eval exec $Commande2]
		
		    if {$GetzOut==""} {
			set LesAccessQuery2 {}
		    } else { 
			set GetzOut [join $GetzOut " "]
			set LesElts [split $GetzOut " "]
			foreach Elt $LesElts {
			    if {[regexp "\:" $Elt]} { continue }
			    lappend LesAccessQuery2 $Elt
			}
		    }
		}
	    }
	}

	# Creation d'une liste d'access non redondante
	set LesAccessQuery2 [lsort -unique $LesAccessQuery2]

	# Ajout a la liste des access recherches (sauvee a la fin)
	lappend LesAccessRecherches $LesAccessQuery2

	####################################################################
	# Recuperer les descriptions de tous les hits (Subjects) du blast:
	set SuisJeSurLesAlignements 0
	set SuisJeSurUnAlignement 0
	set ToutLeSubject ""
	set TousLesSubjects ""

	foreach Ligne  [LesLignesDuFichier $file] {

	    # NB: Le mot "Length" marque la fin de la description du Subject
	    if {[regexp -nocase "Length" $Ligne] && [regexp -nocase "=" $Ligne]} { set Vu 1 }

	    if {[string range $Ligne 0 0] == ">"} {
		
		# C'est la premiere ligne du Subject 
		if { $ToutLeSubject!="" } {lappend TousLesSubjects $ToutLeSubject}

		set ToutLeSubject ""
		regsub "\n" $Ligne "" Ligne
		append ToutLeSubject $Ligne

		set SuisJeSurLesAlignements 1
		set SuisJeSurUnAlignement 1
		set Vu 0

	    } elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
		# C'est la ligne suivante du Subject
		if {$Vu==0} { 
		    # Tant que le mot "Length" n'a pas ete vu, on complete la description du Subject:
		    append ToutLeSubject $Ligne
		}
	    }
	}
	if { $ToutLeSubject!="" } {lappend TousLesSubjects $ToutLeSubject}
	set L [llength $TousLesSubjects]
	
	######################################################################################
	# Recuperer le numero du patient pour chaque Subject ayant le meme access que la query
	foreach Hit $TousLesSubjects  {
	    #set k 0
	    # Recuperer l'access du Subject
	    set LesElts [split $Hit "\|"]
	    set AccessHit [lindex $LesElts 1]
	    
	    # Comparaison de l'access du Subject avec tous les access possibles de la Query
	    foreach A $LesAccessQuery2 {
		if { $AccessHit== $A } {
		    # Recuperer le numero du "patient sample" dans le Subject
		    set E [join [lindex $LesElts 2] " "]
		    set LesEltsDeLaFin [split $E " "]
		    set SampleHit [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin] -4 ]]
		    if {[regexp -nocase "BAC" $SampleHit]} {regsub "BAC" $SampleHit "" PatientHit} else {regsub "Oligo" $SampleHit "" PatientHit}
		    
		    if {$PatientHit!="" && [regexp {^8[0-9][0-9_]$} $PatientHit]} {
			lappend M2 $PatientHit
			# Recuperer le logratio 
			if {![info exists Val($PatientHit)]} {
			    set Val($PatientHit) [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin] -1]]
			}
		    }
		}
	    }
	}
	# Creation de la liste M2 sans redondance:
	set M2 [lsort -unique $M2]

	######################################################################################
	# Creation de la liste de presence/absence (0/1) pour la proteine Query consieree
	set Texte ""
	set TexteVal ""
	
	# !!! FILTRE !!!  Si la proteine est vue chez plus de n patient(s):
	set n 1
	if {[info exists DejaVu]} {unset DejaVu}
	if { [llength $M2] > $n} {
	    foreach m $M2 {
		set DejaVu($m) 1
	    }
	    # Parcours de la liste des patients 
	    foreach E $Liste1 {
		if {[info exists DejaVu($E)]} {
		    append Texte "1\t"
		    append TexteVal "$Val($E)\t"

		} else {
		    append Texte "0\t"
		    append TexteVal "0\t"
		}
	    }
	    lappend Liste2 "$AccessQuery\t$Texte"
	    lappend Liste2Val "$AccessQuery\t$TexteVal"
	}
	# Next file blast
    }

    # Supprimer les access identiques
    set Liste3 {}
    foreach Res $Liste2 {
	set accq [lindex [split $Res "\t"] 0]
	if {![info exists AccqVu($accq)]} {set AccqVu($accq) 1; lappend Liste3 $Res}
    }
    set Liste3Val {}
    foreach Res $Liste2Val {
	set accq [lindex [split $Res "\t"] 0]
	if {![info exists AccqVuVal($accq)]} {set AccqVuVal($accq) 1; lappend Liste3Val $Res}
    }

    # Creer la premiere ligne du tableau final avec la liste des patients
    set TextePa " \t"
    foreach pa $Liste1 {
	append TextePa "$pa\t"
    }
    set Liste4 {}
    set Liste4Val {}
    lappend Liste4 $TextePa
    lappend Liste4Val $TextePa
    
    # Creer le tableau final:
    set Liste5 [concat $Liste4 $Liste3]
    set Liste5Val [concat $Liste4Val $Liste3Val]

    # Enregistrer
    SauveLesLignes $LesAccessRecherches dans $FichierAccess
    SauveLesLignes $Liste5 dans $FichierOut
    SauveLesLignes $Liste5Val dans $FichierOutVal

    return

}

proc CreeTableauPRIMAfasta {n FichierTFA Fichier01 FichierLog} {

    # donnees segmentees
    # FichierTFA est le fichier de la banque blast creee.

    set ListeLesAccess {}
    set Liste1 {806 810 817 818 819 826 825 812 823 809 811 814 816 820 821 822 815 807 827}
    set Liste01 {}
    set ListeLog {}

    foreach Ligne [LesLignesDuFichier $FichierTFA] { 
	if {[string range $Ligne 0 0] == ">"} {
	
	    # Recuperer Access, Patient et Logratio dans l'entete de la sequence FASTA
	    set LesElts [split $Ligne "\|"]
	    set Access [lindex $LesElts 1]
	    lappend LesAccess $Access
	    set Vu($Access) 1


	    set LesEltsDeLaFin [split [lindex $LesElts 2] " "]
	    set Sample [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-5]]
	    if {[regexp -nocase "BAC" $Sample]} {regsub "BAC" $Sample "" Patient} else {regsub "Oligo" $Sample "" Patient}
	    if {![regexp {^8[0-9][0-9_]$} $Patient]} {return "!! Pb Patient = $Patient !!"}
	    
	    set Logratio [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-1]]

	    # Resultats
	    if {![info exists Pa($Access)]} {set Pa($Access) $Patient} else {
		# !! parfois la proteine est localisee a cheval sur pls segments !!
		# alors seule la derniere val sera retenue (voir etape de creation du tableau)
		lappend Pa($Access) $Patient
	    }
	    if {![info exists Log($Access)]} {set Log($Access) $Logratio} else {lappend Log($Access) $Logratio}
	}
    }

    # Creation du tableau final
    foreach A $LesAccess {
	set Texte ""
	set TexteVal ""
	if {[info exists DejaVu]} {unset DejaVu}
	
	# !! FILTRE !!
	if {[llength $Pa($A)] > $n} {
	    foreach m $Pa($A) l $Log($A) {
		set DejaVu($m) 1
		set Val($m) $l
	    }
	    
	    # Parcours de la liste des patients 
	    foreach E $Liste1 {
		if {[info exists DejaVu($E)]} {
		    append Texte "1\t"
		    append TexteVal "$Val($E)\t"
		    
		} else {
		    append Texte "0\t"
		    append TexteVal "0\t"
		}
	    }
	    lappend Liste01 "$A\t$Texte"
	    lappend ListeLog "$A\t$TexteVal"
	}
    }

    # Supprimer les listes d'access identiques
    set Liste3 {}
    foreach Res $Liste01 {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVu($Lacc)]} {set LaccVu($Lacc) 1; lappend Liste3 $Res}
    }
    set Liste3Val {}
    foreach Res $ListeLog {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVuVal($Lacc)]} {set LaccVuVal($Lacc) 1; lappend Liste3Val $Res}
    }
    Espionne "l01 : [llength $Liste01] - lval : [llength $ListeLog]"
    Espionne "l3: [llength $Liste3] - l3val : [llength $Liste3Val]"

    # Creer la premiere ligne du tableau final avec la liste des patients
    set TextePa " \t"
    foreach pa $Liste1 {
	append TextePa "$pa\t"
    }
    set Liste4 {}
    set Liste4Val {}
    lappend Liste4 $TextePa
    lappend Liste4Val $TextePa
    
    # Creer le tableau final:
    set Liste5 [concat $Liste4 $Liste3]
    set Liste5Val [concat $Liste4Val $Liste3Val]

    # Enregistrer
    SauveLesLignes $Liste5 dans $Fichier01
    SauveLesLignes $Liste5Val dans $FichierLog

    return

}

proc CreeTableauPRIMAfastaSansGetz {n FichierTFA Fichier01 FichierLog} {

    # FichierTFA est le fichier de la banque blast creee.

    set LesAccess {}
    set Liste1 {806 810 817 818 819 826 825 812 823 809 811 814 816 820 821 822 815 807 827}
    set Liste01 {}
    set ListeLog {}

    foreach Ligne [LesLignesDuFichier $FichierTFA] { 
	if {[string range $Ligne 0 0] == ">"} {
	    #Espionne $Ligne
	
	    # Recuperer Access, Patient et Logratio dans l'entete de la sequence FASTA
	    set LesElts [split $Ligne "\|"]
	    set Access [lindex $LesElts 1]

	    set LesEltsDeLaFin [split [lindex $LesElts 2] " "]
	    set Sample [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-5]]
	    if {[regexp -nocase "BAC" $Sample]} {regsub "BAC" $Sample "" Patient} else {regsub "Oligo" $Sample "" Patient}
	    if {![regexp {^8[0-9][0-9_]$} $Patient]} {return "!! Pb Patient = $Patient !!"}
	    
	    set Logratio [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-1]]
	    if {$Logratio>0} {continue}

	    # Resultats
	    if {![info exists Pa($Access)]} {set Pa($Access) $Patient } else {lappend Pa($Access) $Patient}
	    if {![info exists Log($Access)]} {set Log($Access) $Logratio } else {lappend Log($Access) $Logratio}
	    
	    # Liste des listes d'access
	    lappend LesAccess $Access
	}
    }

    # Creation du tableau final
    #set n 6
    foreach A $LesAccess {
	set Texte ""
	set TexteVal ""
	if {[info exists DejaVu]} {unset DejaVu}
	
	# !! FILTRE !!
	if { [llength $Pa($A)] > $n} {
	    foreach m $Pa($A) l $Log($A) {
		set DejaVu($m) 1
		set Val($m) $l
	    }
	    
	    # Parcours de la liste des patients 
	    foreach E $Liste1 {
		if {[info exists DejaVu($E)]} {
		    append Texte "1\t"
		    append TexteVal "$Val($E)\t"
		    
		} else {
		    append Texte "0\t"
		    append TexteVal "0\t"
		}
	    }
	    lappend Liste01 "$A\t$Texte"
	    lappend ListeLog "$A\t$TexteVal"
	}
    }

    # Supprimer les access identiques ds les 2 listes creees
    set Liste3 {}
    foreach Res $Liste01 {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVu($Lacc)]} {set LaccVu($Lacc) 1; lappend Liste3 $Res}
    }
    set Liste3Val {}
    foreach Res $ListeLog {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVuVal($Lacc)]} {set LaccVuVal($Lacc) 1; lappend Liste3Val $Res}
    }
    
    # Creer la premiere ligne du tableau final avec la liste des patients
    set TextePa " \t"
    foreach pa $Liste1 {
	append TextePa "$pa\t"
    }
    set Liste4 {}
    set Liste4Val {}
    lappend Liste4 $TextePa
    lappend Liste4Val $TextePa
    
    # Creer le tableau final:
    set Liste5 [concat $Liste4 $Liste3]
    set Liste5Val [concat $Liste4Val $Liste3Val]

    # Enregistrer
    SauveLesLignes $Liste5 dans $Fichier01
    SauveLesLignes $Liste5Val dans $FichierLog

    return

}

proc CreeTableauPRIMAfastaSansGetzPourSamplesPeuRearranges {n FichierTFA Fichier01 FichierLog} {

    # FichierTFA est le fichier de la banque blast creee.

    set LesAccess {}
    set Liste1 {810 818 826 825 812 811 814 820 822 807}
    set Liste01 {}
    set ListeLog {}

    # Filtre sur les patients
    foreach Num $Liste1 {
	set NumVu($Num) 1
    }

    foreach Ligne [LesLignesDuFichier $FichierTFA] { 
	if {[string range $Ligne 0 0] == ">"} {
	    #Espionne $Ligne
	
	    # Recuperer Access, Patient et Logratio dans l'entete de la sequence FASTA
	    set LesElts [split $Ligne "\|"]
	    set Access [lindex $LesElts 1]

	    set LesEltsDeLaFin [split [lindex $LesElts 2] " "]
	    set Sample [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-5]]
	    if {[regexp -nocase "BAC" $Sample]} {regsub "BAC" $Sample "" Patient} else {regsub "Oligo" $Sample "" Patient}
	    if {![regexp {^8[0-9][0-9_]$} $Patient]} {return "!! Pb Patient = $Patient !!"}
	    
	    set Logratio [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-1]]

	    # Filtre sur les logratios
	    if {$Logratio>0} {continue}
	    # Filtre sur les patients
	    if {![info exists NumVu($Patient)]} {continue}

	    # Resultats
	    if {![info exists Pa($Access)]} {set Pa($Access) $Patient } else {lappend Pa($Access) $Patient}
	    if {![info exists Log($Access)]} {set Log($Access) $Logratio } else {lappend Log($Access) $Logratio}
	    
	    # Liste des listes d'access
	    lappend LesAccess $Access
	}
    }

    # Creation du tableau final
    foreach A $LesAccess {
	set Texte ""
	set TexteVal ""
	if {[info exists DejaVu]} {unset DejaVu}
	
	# !! FILTRE !!
	if { [llength $Pa($A)] > $n} {
	    foreach m $Pa($A) l $Log($A) {
		set DejaVu($m) 1
		set Val($m) $l
	    }
	    
	    # Parcours de la liste des patients 
	    foreach E $Liste1 {
		if {[info exists DejaVu($E)]} {
		    append Texte "1\t"
		    append TexteVal "$Val($E)\t"
		    
		} else {
		    append Texte "0\t"
		    append TexteVal "0\t"
		}
	    }
	    lappend Liste01 "$A\t$Texte"
	    lappend ListeLog "$A\t$TexteVal"
	}
    }

    # Supprimer les listes d'access identiques
    set Liste3 {}
    foreach Res $Liste01 {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVu($Lacc)]} {set LaccVu($Lacc) 1; lappend Liste3 $Res}
    }
    set Liste3Val {}
    foreach Res $ListeLog {
	set Lacc [lindex [split $Res "\t"] 0]
	if {![info exists LaccVuVal($Lacc)]} {set LaccVuVal($Lacc) 1; lappend Liste3Val $Res}
    }
    
    # Creer la premiere ligne du tableau final avec la liste des patients
    set TextePa " \t"
    foreach pa $Liste1 {
	append TextePa "$pa\t"
    }
    set Liste4 {}
    set Liste4Val {}
    lappend Liste4 $TextePa
    lappend Liste4Val $TextePa
    
    # Creer le tableau final:
    set Liste5 [concat $Liste4 $Liste3]
    set Liste5Val [concat $Liste4Val $Liste3Val]

    # Enregistrer
    SauveLesLignes $Liste5 dans $Fichier01
    SauveLesLignes $Liste5Val dans $FichierLog

    return

}

proc CreeTableauPRIMApourCompensation {RepBlast RepTableBlast RepTemp} {

    # Obtenir un tableau des hits du blast 
    # Hits avec access differents de la query, meme patient, sens oppose pour le logratio 
    # avec score et expect
    # avec l'entete de la query

    set Liste1 {806 810 817 818 819 826 825 812 823 809 811 814 816 820 821 822 815 807 827}

    set Liste2 {}
    set Liste2Val {}
    
    foreach file [glob -nocomplain $RepBlast/*] { 
	set NomFichier [file tail $file]
	if {[file exists "$RepTableBlast/$NomFichier"]} {continue}
	if {[file exists "$RepTemp/$NomFichier"]} {continue}
	
	Espionne $file


	set LaSortie ""
	# Recuperer l'access query et le numero du "patient sample" et le logratio dans "Query=..." du blast:
	DepouilleLeBlast TabBlast $file "1e-3"
	set NbSbjct [set TabBlast(NbSubject)]
	#Espionne "nb subject: $NbSbjct"

	set q [set TabBlast(Query)]
	set LesEltsq [split $q "\|"]
	
	set AccessQuery [lindex $LesEltsq 1]

	set LesEltsDeLaFin [split [lindex $LesEltsq 2] " "]
	set Sample [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-5]]
	if {[regexp -nocase "BAC" $Sample]} {regsub "BAC" $Sample "" Patient} else {regsub "Oligo" $Sample "" Patient}

	set Logratio [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin]-1]]

	# Liste de tous les access possibles de la Query
	set LesAccessQuery2 {}
	lappend LesAccessQuery2 $AccessQuery
	
	if {[info exists Val]} {unset Val}

	####################################################################
	# Recherche par SRS (getz) des access equivalents a l'access Query: 
	# Creation d'une liste d'access contenant l'access de la Query

	if {[regexp -nocase "NP" $AccessQuery]} {

	    # L'access de la Query est Refseq
	    set Commande "getz \"\\\[\\\{refseqp refseqprelease refseqpnew\\\}-acc:$AccessQuery\\\]\\\>\\\[protein-org:Homo sapiens\\\]\" \-vf acc"
	    set GetzOut [eval exec $Commande]
	    
	    if {$GetzOut==""} {continue}
	    if {[regexp "\n" $GetzOut]} {
		set LesElts [split $GetzOut "\n"]
		foreach Elt $LesElts {
		    set LesDeux [split $Elt "\t"]
		    foreach D $LesDeux {
			if {![regexp "\:" $D]} {
			    set LesEltsGetz [split $D " "]
			    foreach EltGetz $LesEltsGetz {
				lappend LesAccessQuery2 $EltGetz
			    }
			}
		    }
		}
	    } else {
		set LesData [split $GetzOut "\t"]
		foreach Elt $LesData {
		    if {![regexp "\:" $Elt]} {
			set LesEltsGetz [split $Elt " "]
			foreach EltGetz $LesEltsGetz {
			    lappend LesAccessQuery2 $EltGetz
			}
		    }
		} 
	    } 
	} else {
	    
	    # L'access de la query n'est pas Refseq
	    set Commande "getz \"\\\[protein-acc:$AccessQuery\\\]\\\>\\\[\\\{refseqp refseqprelease refseqpnew\\\}-org:Homo sapiens\\\]\" \-vf acc"
	    set GetzOut [eval exec $Commande]
	    if {$GetzOut==""} {continue}
	    if {[regexp "\n" $GetzOut]} {
		set LesElts [split $GetzOut "\n"]
		foreach Elt $LesElts {
		    set LesDeux [split $Elt "\t"]
		    foreach D $LesDeux {
			if {![regexp "\:" $D]} {
			    set LesEltsGetz [split $D " "]
			    foreach EltGetz $LesEltsGetz {
				lappend LesAccessQuery2 $EltGetz
			    }
			}
		    }
		}
	    } else {
		set LesData [split $GetzOut "\t"]
		foreach Elt $LesData {
		    if {![regexp "\:" $Elt]} {
			set LesEltsGetz [split $Elt " "]
			foreach EltGetz $LesEltsGetz {
			    lappend LesAccessQuery2 $EltGetz
			}
		    }
		} 
	    } 
	}

	# Creation d'une liste d'access non redondante
	set LesAccessQuery2 [lsort -unique $LesAccessQuery2]
	#Espionne $LesAccessQuery2
	if {[info exists VuAcc]} {unset VuAcc}
	foreach A $LesAccessQuery2 {
	    set VuAcc($A) 1
	}

	####################################################################
	# Recuperer les descriptions de tous les hits (Subjects) du blast:
	set SuisJeSurLesAlignements 0
	set SuisJeSurUnAlignement 0
	set ToutLeSubject ""
	set TousLesSubjects ""
	set ToutesLesInfosSupp ""
	set Score ""; set Expect ""

	foreach Ligne [LesLignesDuFichier $file] {
	    regsub -all "\n" $Ligne "" Ligne
	    regsub -all "\t" $Ligne "" Ligne
	    regsub -all "           " $Ligne " " Ligne


	    if {[string range $Ligne 0 0] == ">"} {
		
		# C'est la premiere ligne du Subject 
		if {$ToutLeSubject!=""} {lappend TousLesSubjects $ToutLeSubject}
		if {$Score!="" && $Expect!=""} {lappend ToutesLesInfosSupp "$Score\t$Expect"}

		set ToutLeSubject ""
		append ToutLeSubject $Ligne

		set SuisJeSurLesAlignements 1
		set SuisJeSurUnAlignement 1
	    } elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
		append ToutLeSubject "\n$Ligne"
		if {[string range $Ligne 0 8] == " Score = "} {
		    set Score "" ; set Expect ""
		    regexp {Score = ([e0-9a-z\.\+\(\) ]+)} $Ligne tmp Score 
		    regsub {Score = [e0-9a-z\.\+\(\) ]+}   $Ligne "" Ligne
		    set Score [string trim $Score]
		    
		    regexp { Expect =([ e0-9\.\-]+)} $Ligne tmp Expect
		    regsub { Expect =[ e0-9\.\-]+}   $Ligne ""  Ligne
		    set Expect [string trim $Expect]
		    if {[regexp "^e" $Expect]} { set Expect "1$Expect"}
		    set SuisJeSurLesAlignements 0
		    set SuisJeSurUnAlignement 0
		}

	    }
	}
	set L [llength $TousLesSubjects]
	
	######################################################################################
	# Recuperer les subjects avec un access different de celui de la query et le meme patient que la query
	
	set LesEntetesSubject {}
	
	foreach Subject $TousLesSubjects {
	    regexp -indices " Length = " $Subject DebFin
	    set EnteteSubject [string trim [string range $Subject 1 [lindex $DebFin 0]]]
	    regsub -all "\n" $EnteteSubject "" EnteteSubject
	    while {[regexp "  " $EnteteSubject]} {regsub -all "  " $EnteteSubject " " EnteteSubject}
	    lappend LesEntetesSubject $EnteteSubject
	    set Subject [string range $Subject [lindex $DebFin 0] end]
	}
	foreach Entete $LesEntetesSubject Info $ToutesLesInfosSupp {

	    # Recuperer l'access du Subject
	    set LesEltsHit [split $Entete "\|"]
	    set AccessHit [lindex $LesEltsHit 1]

	    # Comparaison de l'access du Subject avec tous les access possibles de la Query
	    if {![info exists VuAcc($AccessHit)]} {
		# Recuperer le numero du "patient sample" dans le Subject
		set E [join [lindex $LesEltsHit 2] " "]
		set LesEltsDeLaFin [split $E " "]
		set SampleHit [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin] -5]]
		if {[regexp -nocase "BAC" $SampleHit]} {regsub "BAC" $SampleHit "" PatientHit} else {regsub "Oligo" $SampleHit "" PatientHit}
		if {$PatientHit!="" && [regexp {^8[0-9][0-9_]$} $PatientHit] && $PatientHit==$Patient} {
		    # Recuperer le logratio 
		    set Val [lindex $LesEltsDeLaFin [expr [llength $LesEltsDeLaFin] -1]]
		    if {($Val<0 && $Logratio>0)||($Val>0 && $Logratio<0)} {
			lappend LaSortie "$Entete\t$Info"
		    }
		}
	    }
	}
	if {$LaSortie!=""} {
	    set Query  [join $q " "]
	    set LaQuery [split $Query "\n"]
	    lappend LaQuery "\n"
	    set LaSortie [concat $LaQuery $LaSortie]
	    SauveLesLignes $LaSortie dans "$RepTableBlast/$NomFichier"
	} else {
	    SauveLesLignes $LaSortie dans "$RepTemp/$NomFichier"
	}
    }
    return

}

proc CreeTaxoblaVide {} {

    if { ! [OuiOuNon "Attention on crée des fichiers vides ... Si les blasts sont faits plus tard il faut penser à les supprimer\nJe crée quand même les vides"]} { return "" }
    set LesCrees {}
    foreach Nom [ListeDesPABs] {
	set FiTaxo [GscopeFile $Nom "taxobla"]
	if {[FileAbsent $FiTaxo]} {
	    lappend LesCrees [Sauve "" dans $FiTaxo] } 
    }
    return $LesCrees

}

proc CreeTaxoblaWithMyMissBlast {} {

    set LesCrees {}
    foreach Ligne [MyMissBlast] {
	scan $Ligne "%s %s %s" Nom Id Seq
	set SL [string length $Seq]
	set Ac [NIAG $Nom "A"]
	set PN 0.00
	set Score 1
	set TaxId [NotreOX]
	set Orga [NotreOS]
	set Info [PremiereLigneDuFichier [GscopeFile $Nom prottfa]]
	set Info [join [lrange [split $Info " "] 2 end] " "]
	set Info "$Id $Ac $Info SL=$SL" 
	if {[string length $Orga]>36} { set Orga "[string range $Orga 0 36]..." }
	set LigneTaxobla [format "%7s\t%6s\t%8s\t%-40s\t%s" $PN $Score $TaxId $Orga $Info]
	Espionne $LigneTaxobla
	set FicTaxobla [GscopeFile $Nom taxobla]
	if {[FileExists $FicTaxobla] && [file size $FicTaxobla]>0} {
	    if { ! [OuiOuNon "$FicTaxobla already exists; Do I overwrite ?"]} { continue }
	} 
	lappend LesCrees [Sauve $LigneTaxobla dans $FicTaxobla]
    }
    return $LesCrees

}

proc CreeTfaApartirSortieBlast {FichierBlast} {

    set Fichier "/genomics/link/EVImm/prpf31/riken/FastaDuBlast"
    set Query [AskBlast $FichierBlast Query]
    set LesMots [split $Query "|"]
    set AccessQuery [lindex [split $Query "|"] 1]
    set CommandeQuery "getz \"\\\[refseq-acc:$AccessQuery\\\]\" \-view FastaSeqs" 
    set GetzOutQuery [eval exec $CommandeQuery]
    AppendAuFichier $Fichier $GetzOutQuery

    set NbSujet [AskBlast $FichierBlast NbSubject]
    for {set i 1} {$i <= $NbSujet} {incr i} {lappend LesBId [AskBlast $FichierBlast Subject $i]}
    foreach BId $LesBId {
	lappend LesAccess [AskBlast $FichierBlast BanqueId $BId Access]
    }
    foreach Acc $LesAccess {
	set Commande "getz \"\\\[est-acc:$Acc\\\]\" \-view FastaSeqs" 
	set GetzOut [eval exec $Commande]
	AppendAuFichier $Fichier "$GetzOut"
    }

}

proc CreeTfaDesCops {Org} {

    #Cree fichier tfa par boite dans tfasdescopainsAdd (sans la ref = query)
    if {[regexp -nocase "Test" $Org]} {
	set RepertoireSourisTfactor "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai"
	set RepertoireSourisOthers  "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai"
	set RepertoireSourisNoAlt   "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai"
	set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNoAlt]
	set RepertoireOut "[RepertoireDuGenome]/tfasdescopainsAdd"
    }
    if {[regexp -nocase "Mouse" $Org]} {
	set LesRepertoires [LesRepertoires "Mouse" "Mod"]
	set RepertoireOut "[RepertoireDuGenome]/tfasdescopainsAdd"
    }
    if {[regexp -nocase "Rat" $Org]} {
	set LesRepertoires [LesRepertoires "Rat" "Mod"]
	set RepertoireOut "[RepertoireDuGenome]/tfasdescopainsAdd"
    }
    if {! [file exists $RepertoireOut]} {file mkdir $RepertoireOut}

    set nbfic 0
    foreach Repertoire $LesRepertoires {
	foreach FileST [glob -nocomplain "$Repertoire/*"] {
	    set taille [file size $FileST]
	    if {$taille == 0} {continue}
	    incr nbfic; set LesLignesCops {}
	    set cluster [lindex [split [file tail $FileST] "."] 0]
	    set Box    [InterrogeBox $cluster Box]
	    set EnsRef [InterrogeBox $Box Ref]
	    set trouveref 0
	    foreach Access [LaSequenceDuTFAs $FileST "LaListeDesAccess"] {
		regsub "Nbr" $Access "" Access
		if {$Access==$EnsRef} { set trouveref 1; continue}
		if {$Access!=$EnsRef || ($Access==$EnsRef && $trouveref==1)} {
		    set TFA  [LaSequenceDuTFAs $FileST $Access]
		    lappend LesLignesCops $TFA
		}
	    }
	    set LesLignesCops [EnleveLignesVides $LesLignesCops]
	    SauveLesLignes $LesLignesCops dans "$RepertoireOut/$Box"
	}
    }

}

proc CreeTfaDesRefs {Org} {

    #sert a creer les boites dans le projet gscope
    if {[regexp -nocase "Test" $Org]} {
	set Orga "Mus musculus"
	set RepertoireSourisOthers  "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai"
	set RepertoireSourisTfactor "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai"
	set RepertoireSourisNoAlt   "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai"
	set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNoAlt]
	set FichierRef "/genomics/link/SpliRetTest/FichiersInitial/RefsDesClusters"
	set FichierOut "/genomics/link/SpliRetTest/FichiersInitial/FichierTfaDesQuery"
    }
    if {[regexp -nocase "Mouse" $Org]} {
	set Orga "Mus musculus"
	set LesRepertoires [LesRepertoires "Mouse" "Mod"]
	set FichierRef "/genomics/link/SpliRetMouse/FichiersModifUnique/RefsDesClusters"
	set FichierOut "/genomics/link/SpliRetMouse/FichiersModifUnique/FichierTfaDesQuery"
    }
    if {[regexp -nocase "Rat" $Org]} {
	set Orga "Rattus norvegicus"
	set LesRepertoires [LesRepertoires "Rat" "Mod"]
	set FichierRef "/genomics/link/SpliRetRat/FichiersModifUnique/RefsDesClusters"
	set FichierOut "/genomics/link/SpliRetRat/FichiersModifUnique/FichierTfaDesQuery"
    }
    
    set nbfic 0
    foreach Repertoire $LesRepertoires {
	foreach FileST [glob -nocomplain "$Repertoire/*"] {
	    set taille [file size $FileST]
	    if {$taille == 0} {continue}
	    incr nbfic
	    set cluster [lindex [split [file tail $FileST] "."] 0]
	    set EnsRef [InterrogeRefs $cluster Ref $FichierRef]
	    foreach Access [LaSequenceDuTFAs $FileST "LaListeDesAccess" "" "" "ForceAccessFirst" "AllowDigitOnly"] {
		if {$Access==$EnsRef} {
		    set TFA  [LaSequenceDuTFAs $FileST $Access]
		    set Tete [EnteteDuTexteTFA $TFA]
		    regsub ">" $Tete "" Tete
		    if {[regexp ":" $Tete]} {
			regsub -all ":" $Tete " " Tete
			set LesMots [split $Tete " "]
			set Acc  [lindex $LesMots 0]
			set Chr  [string range [lindex $LesMots 1] 0 2]
			set Chr  "$Chr[lindex $LesMots 3]"
			set Coord "[lindex $LesMots 4] [lindex $LesMots 5]"
			set Sens [lindex $LesMots 6]
			if {$Sens=="1"}  {set Sens "sens=f"}
			if {$Sens=="-1"} {set Sens "sens=r"}
			set NvTete ">$cluster $Orga $Acc $Chr $Coord $Sens [lindex $LesMots 2] [lindex $LesMots 7]"
		    } else {
			set NvTete ">$cluster $Orga $Tete"
		    }
		    set NvTFA [SequenceFormatTFA $TFA $NvTete "tfa"]
		    lappend LesLignesRef $NvTFA
		}
	    }
	}
    }
    Espionne "$nbfic"
    set LesLignesRef [EnleveLignesVides $LesLignesRef]
    return [SauveLesLignes $LesLignesRef dans $FichierOut]

}

proc CreeTfaPourCodonw {} {

    global RepertoireDuGenome

    set RepCodonw "$RepertoireDuGenome/codonw" 

    if { ! [file exists $RepCodonw]} { File mkdir $RepCodonw }

    set TFA "$RepCodonw/[string tolower [PreFixe]].tfa"
    if { ! [OuiOuNon "$TFA\nwill be the name of the tfa file with all nuc. sequences. OK ?" 1]} {
	set TFA [Entre $TFA]
	if {$TFA==""} { return "" }
    }
    
    if {[file exists $TFA]} {
	if { ! [OuiOuNon "$TFA already exists. Do I replace it ?" 0]} { return $TFA }
	File delete $TFA
    }
    foreach Nom [ListeDesPABs] {
	set Debut  [Box $Nom debut]
	set Fin    [Box $Nom fin]
	set Orient [Box $Nom orient]
	if {$Orient=="F"} {
	    incr Fin 3
	} else {
	    incr Debut -3
	}
	if {[OuiOuNonMemo "Do I use the genome DNA file for CodonW?"]} {
	    set TFAduPAB ">$Nom\n[SequenceFormatBrut [BoutADN $Debut $Fin $Orient]]"
	} else {
	    set Rep [RepDesNucPourCodonW]
	    set TFAduPAB [ContenuDuFichier [GscopeFile $Nom $Rep]]
	}
	AppendAuFichier $TFA $TFAduPAB
    }
    return $TFA

}

proc CreeTfaSansRedondants {Fichier} {

    #Fichier:
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Sw_Vertebrata"
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Tr_Vertebrata"
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Varsplic/varsplic_Vertebrata"
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata"
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata"
    #"/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/Ensembl_Vertebrata"
    set FichierRedond "/genomics/link/SpliRetMouse/database/LesAccessRedondants"
    set RepertoireDestination "/genomics/link/SpliRetMouse/database/TousLesTfasSsRedond"
    set LesTFAs {}; set i 0
    Espionne "$Fichier"
    set LesMots [split $Fichier "/"]
    set FinFichier "[lindex $LesMots end-1]/[lindex $LesMots end]"

    foreach AccessRedond [LesLignesDuFichier $FichierRedond] {
	set Redond($AccessRedond) 1
    }
    
    foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" ForceAccessFirst] {
	if {[info exists Redond($Access)]} { continue }
	set TFA [LaSequenceDuTFAs $Fichier $Access]
	lappend LesTFAs $TFA
    }
    SauveLesLignes $LesTFAs dans "$RepertoireDestination/$FinFichier"

}

proc CreeTmpDe {tmp} {

    switch $::tcl_platform(platform) {
	"windows" {set user $::env(USERNAME)}
	"unix"    {set user $::env(USER)}
    }
    return "[pid]_${user}_${tmp}"

}

proc CreeTousLesRapportsPourAccess {{Start ""} {Keep ""}} {

 global RepertoireDuGenome

    set RepRapports "$RepertoireDuGenome/rapportsaccess"
    if { ! [file exists $RepRapports]} { File mkdir $RepRapports }

    if {$Keep==""} { set Keep 0 } else { set Keep 1 } 

    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	if {$Start!="" && $Nom!=$Start} { continue }
	set Start ""

	if {$Keep && [file exists "$RepRapports/$Nom"]} { continue }

	set Rapport {}
	
	#Generalites
	lappend Rapport "GscopeCode: $Nom"
	set codeCl [CodeClone $Nom]
	set User [OwnerOfCDNA $Nom]
	lappend Rapport "CodeClone: $codeCl"
	lappend Rapport "User: $User"
	set JR [JumeauRepresentatif $Nom]
	if {$JR!=$Nom && $JR!=""} {
	    set CC [CodeClone $JR]
	    lappend Rapport "JR: $CC $JR"
	}

	#RepeatMasker
	set TypeMask [QuelMask $Nom]
	Espionne $TypeMask
	set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
	lappend Rapport "MaskType: $TypeMask"
	lappend Rapport "MaskedProportion: $PourcentMask"
	set TypeRepeat [ExtraitInfo $Nom "RM"]
	if  { $TypeRepeat!="" } { 
	    lappend Rapport "RepeatType: $TypeRepeat" 
	}

	#BlastN contre le genome humain
	set PolyLoc [PolyLocalise $Nom]
	Espionne $PolyLoc
	lappend Rapport "LocType: $PolyLoc"

	if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
	    set LesLocs [LesLocalisationsSurChroContig $Nom]
	    set MeilleureLoc [lindex $LesLocs 0]
	    scan $MeilleureLoc "%s %s %d %d %s" Chro Contig Debut Fin Orient
	    regsub "HS" $Chro "" Chro 
	    lappend Rapport "Chromosome: $Chro"
	    lappend Rapport "Contig: $Contig"
	    lappend Rapport "Begin: $Debut"
	    lappend Rapport "End: $Fin"
	    lappend Rapport "Orientation: $Orient"
	}

	#GenScan

	set  GS  [ExtraitInfo $Nom "GS"]
	if {$GS  ==    "overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 1" }
	if {$GS  == "no overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 0" }

	set  GS3 [ExtraitInfo $Nom "GS3"]
	if {$GS3 ==     "in 3' region"} { lappend Rapport "InPredicted3Region: 1" }
	if {$GS3 == "not in 3' region"} { lappend Rapport "InPredicted3Region: 0" }

	set  GSE [ExtraitInfo $Nom "GSE"] 
	if {$GSE ==     "in an exon"}   { lappend Rapport "InAPredictedExon: 1" }
	if {$GSE == "not in an exon"}   { lappend Rapport "InAPredictedExon: 0" }
	
	#BlastP
	set LesCopains [MeilleursCopains $Nom]
	if {$LesCopains != {} } {
	    set MeilleurCopain [lindex $LesCopains 0]
	    if {$MeilleurCopain=="No hits found" ||  $MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastP results" ||  $MeilleurCopain=="No blastp file available" } {
		lappend Rapport "BlastPDef: $MeilleurCopain"
	    } else {
		set Access ""
		set PlusieursFonctions 0
		scan $MeilleurCopain "%s %s" BID Access
		regsub "$BID $Access" $MeilleurCopain "" PremDef
		set PremDef [string trim $PremDef]
		lappend Rapport "BlastPAccess: $BID"
		lappend Rapport "BlastPDef: $PremDef"
		if {[expr [llength $LesCopains] > 1]} {
		    foreach Cop [lrange $LesCopains 1 end] {
			scan $Cop "%s %s" BID Access
			set Definition [join [lrange [split $Cop " "] 2 end] " "]
			if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
		    }
		}
		lappend Rapport "BlastPMore: $PlusieursFonctions"
	    }
	    set CvP [ConsacreVersusPredite $Nom]
	    if {$CvP!="No values"} {
		lappend Rapport "Prediction_vs_BlastPHit: $CvP"
	    }
	}

	#BlastX
	set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
	if {$LesCopains != {} } {
	    set MeilleurCopain [lindex $LesCopains 0]
	    if {[regexp -nocase "^no hit" $MeilleurCopain]} { set MeilleurCopain "No hits found" }
	    if {$MeilleurCopain=="No hits found" ||  $MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastX results" ||  $MeilleurCopain=="No blastx file available" } {
		lappend Rapport "BlastXDef: $MeilleurCopain"
	    } else {
		set Access ""
		set PlusieursFonctions 0
		scan $MeilleurCopain "%s %s" BID Access
		regsub "$BID $Access" $MeilleurCopain "" PremDef
		set PremDef [string trim $PremDef]
		lappend Rapport "BlastXAccess: $BID"
		lappend Rapport "BlastXDef: $PremDef"
		if {[expr [llength $LesCopains] > 1]} {
		    foreach Cop [lrange $LesCopains 1 end] {
			scan $Cop "%s %s" BID Access
			set Definition [join [lrange [split $Cop " "] 2 end] " "]
			if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
		    }
		}
		lappend Rapport "BlastXMore: $PlusieursFonctions"
	    }
	}

	#BlastN contre genembl et est, et TBlastN contre est 
	foreach {Banque Titre} {blastngenembl Genembl blastnest Est tblastnest TbnEst} {
	    set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
	    if {$LesCops=={}} {
		lappend Rapport "${Titre}Def: values not yet available"
	    } elseif {[lindex $LesCops 0]=="File not yet available"} {
		lappend Rapport "${Titre}Def: values not yet available"
	    } elseif {[lindex $LesCops 0]=="No value"} {
		lappend Rapport "${Titre}Def: no value available"
	    } elseif {[lindex $LesCops 0]=="No hit"} {
		lappend Rapport "${Titre}Def: no hit"
	    } else {
		set PremiereFois 1
		set Autre 0
		foreach Cop $LesCops {
		    set Genre "Inconnu"
		    set Espece "inconnu"
		    scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
		    set OS "$Genre $Espece"
		    set DE [join [lrange [split $Cop " "] 5 end] " "]
		    if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
		    if {$PremiereFois} {
			lappend Rapport "${Titre}Def: $DE" 
			lappend Rapport "${Titre}Access: $BID"
			set PremDE $DE
			set PremiereFois 0 
			continue
		    }
		    if {$DE!=$PremDE} { incr Autre }
		}
		lappend Rapport "${Titre}More: [expr $Autre > 0]"
	    }
	}

	#Affymetrix overlaps
	set LesCC [LesCodeCloneDesAffymetrixEnOverlap $Nom]
	if {$LesCC!={}} {
	    set TexteAffy "Affymetrix: [join $LesCC " "]"
	} else {
	    if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
		set TexteAffy "Affymetrix: not tested"
	    } else {
		set TexteAffy "Affymetrix: not detected"
	    }
	}
	lappend Rapport $TexteAffy 

	SauveLesLignes $Rapport dans "$RepRapports/$Nom"
    }
    return ""

}

proc CreeTousLesTFAsDesMSFs {{Liste ""} {AvecGap ""} {SousRep ""}} {

    global RepertoireDuGenome

    set RepTfas "[RepertoireDuGenome]/$SousRep"
    if {$SousRep==""} {
	set SousRep "tfas"
	set Ask 1
    } else {
	set Ask 0
    }
    while {$Ask} {
	set RepTfas "[RepertoireDuGenome]/$SousRep"
	if {[OuiOuNon "Do I store the tfas files in $RepTfas"]} { break }
	set RepTfas [Entre $RepTfas]
	if {$RepTfas=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
    }
    if { ! [file exists $RepTfas]} { file mkdir $RepTfas }

    if {$Liste==""} {
	set Liste [ListeDesPABs]
    }
	
    foreach Nom $Liste {
	Espionne $Nom
	set FichierMSF "$RepertoireDuGenome/msf/$Nom"
	if { ! [file exists $FichierMSF]} { continue }
	set FichierTFA "$RepTfas/$Nom"
	if {[file exists $FichierTFA]} { continue }
	Espionne [SauveLesLignes [CreeLeTFAsDuMSF $FichierMSF $AvecGap] dans $FichierTFA]
    }

}

proc CreeTousLesTFAsPoulet {} {

    set vide 0; set total 0
    #set RepertoireBlastp "/genomics/link/Tau/GSTRdCVF/BlastpSurStringPoulet/"
    set RepertoireBlastp "/genomics/link/Tau/Dec2008/GSTRdCVF/BlastpSurStringHomme"
    foreach GI [InterrogeListTau ListOf GI] {
	incr total
	set GetzOutpdb ""; set GetzOut ""; set SeqGbTfa ""; set TfaProt ""
	set Access [InterrogeSortieNcbi $GI Access]
	set DB     [InterrogeSortieNcbi $GI DB]
	Espionne ""
	Espionne "$total"
	Espionne "$GI $Access $DB"
	if {[regexp "pdb" $DB]} {
	    set FichierRequete "/genomics/link/Tau/Dec2008/GSTRdCVF/entreepdb.bql"
	    set FichierSortie "/genomics/link/Tau/Dec2008/GSTRdCVF/sortiepdb.txt"
	    set Elmt [split $Access "_"]
	    set accesspdb [lindex $Elmt 0]
	    set chain     [lindex $Elmt 1]
	    lappend LesLignesBird "ID * DB PDB"
	    lappend LesLignesBird "WH SQLNATIVE SELECT distinct dr.dbaccession from pdb.header as h , pdb.dbref as dr where h.idcode='$accesspdb' and dr.chainid='$chain' and h.oid=dr.key_fk"
	    lappend LesLignesBird "FM CSV"
	    SauveLesLignes $LesLignesBird dans $FichierRequete    
	    BirdForceHoan $FichierRequete $FichierSortie
	    foreach LigneFic [LesLignesDuFichier $FichierSortie] {
		if {[regexp "Query" $LigneFic]} {continue}
		set NvAcc $LigneFic
	    }
	    Espionne "\t NvAcc $NvAcc"
	    set Commandepdb "getz \"\\\[uniprot-acc:$NvAcc\\\]\" \-view FastaSeqs" 
	    set GetzOutpdb [eval exec $Commandepdb]
	    Espionne "GetzOutpdb \n $GetzOutpdb"
	    Sauve $GetzOutpdb dans "$RepertoireBlastp/fastaquery/$NvAcc"
	} elseif {[regexp "ref" $DB]} {
	    set Commande "getz \"\\\[refseqp-acc:$Access\\\]\" \-view FastaSeqs" 
	    set GetzOut [eval exec $Commande]
	    if {$GetzOut==""} {
		incr sstfa
		Espionne "sstfaref"
	    } else {
		Espionne "GetzOut \n $GetzOut"
		Sauve $GetzOut dans "$RepertoireBlastp/fastaquery/$Access"
	    }
	} elseif {[regexp "gb" $DB]} {
	    set Texte [GenPeptDuNcbi $Access]
	    set SeqGbTfa [SequenceFormatTFA $Texte "" gbprot]
	    Espionne "SeqGbTfa \n $SeqGbTfa"
	    if {$SeqGbTfa!=""} {
		Sauve $SeqGbTfa dans "$RepertoireBlastp/fastaquery/$Access"
	    }
	} else {
	    set TfaProt [BirdFasta $Access]
	    Espionne "TfaProt \n $TfaProt"
	    if {$TfaProt!=""} {
		Sauve $TfaProt dans "$RepertoireBlastp/fastaquery/$Access"
	    }
	}
	if {$GetzOutpdb=="" && $GetzOut=="" && $SeqGbTfa=="" && $TfaProt==""} {
	    #4 fait a la main CAA06233 emb, CAC38058 emb, BAA03260 dbj, CAG31352 emb  
	    Espionne "vide"
	    incr vide
	}
    }
    Espionne "vide $vide"

}

proc CreeTousLesTFAsPouletControl {} {

    set vide 0
    #set RepertoireBlastp "/genomics/link/Tau/GSTControl/BlastpSurStringPoulet/fastaquery"
    set RepertoireBlastp "/genomics/link/Tau/Dec2008/GSTControl/BlastpSurStringHomme/fastaquery"
    foreach GI [InterrogeListTauControl ListOf GI] {
	set GetzOutpdb ""; set GetzOut ""; set SeqGbTfa ""; set TfaProt ""
	set Access [InterrogeSortieNcbiControl $GI Access]
	set DB     [InterrogeSortieNcbiControl $GI DB]
	Espionne ""
	Espionne "$GI $Access $DB"
	if {[regexp "pdb" $DB]} {
	    set FichierRequete "/genomics/link/Tau/GSTControl/entreepdb.bql"
	    set FichierSortie "/genomics/link/Tau/GSTControl/sortiepdb.txt"
	    set Elmt [split $Access "_"]
	    set accesspdb [lindex $Elmt 0]
	    set chain     [lindex $Elmt 1]
	    lappend LesLignesBird "ID * DB PDB"
	    lappend LesLignesBird "WH SQLNATIVE SELECT distinct dr.dbaccession from pdb.header as h , pdb.dbref as dr where h.idcode='$accesspdb' and dr.chainid='$chain' and h.oid=dr.key_fk"
	    lappend LesLignesBird "FM CSV"
	    SauveLesLignes $LesLignesBird dans $FichierRequete    
	    BirdForceHoan $FichierRequete $FichierSortie
	    foreach LigneFic [LesLignesDuFichier $FichierSortie] {
		if {[regexp "Query" $LigneFic]} {continue}
		set NvAcc $LigneFic
	    }
	    Espionne "\t NvAcc $NvAcc"
	    set Commandepdb "getz \"\\\[uniprot-acc:$NvAcc\\\]\" \-view FastaSeqs" 
	    set GetzOutpdb [eval exec $Commandepdb]
	    Espionne "GetzOutpdb \n $GetzOutpdb"
	    Sauve $GetzOutpdb dans "$RepertoireBlastp/$NvAcc"
	} elseif {[regexp "ref" $DB]} {
	    set Commande "getz \"\\\[refseqp-acc:$Access\\\]\" \-view FastaSeqs" 
	    set GetzOut [eval exec $Commande]
	    if {$GetzOut==""} {
		incr sstfa
		Espionne "sstfaref"
	    } else {
		Espionne "GetzOut \n $GetzOut"
		Sauve $GetzOut dans "$RepertoireBlastp/$Access"
	    }
	} elseif {[regexp "gb" $DB]} {
	    set Texte [GenPeptDuNcbi $Access]
	    set SeqGbTfa [SequenceFormatTFA $Texte "" gbprot]
	    Espionne "SeqGbTfa \n $SeqGbTfa"
	    if {$SeqGbTfa!=""} {
		Sauve $SeqGbTfa dans "$RepertoireBlastp/$Access"
	    }
	} else {
	    set TfaProt [BirdFasta $Access]
	    Espionne "TfaProt \n $TfaProt"
	    if {$TfaProt!=""} {
		Sauve $TfaProt dans "$RepertoireBlastp/$Access"
	    }
	}
	if {$GetzOutpdb=="" && $GetzOut=="" && $SeqGbTfa=="" && $TfaProt==""} {
	    #5 fait a la main CAA74577 emb, CAA25004 emb, CAH65368 emb, CAA60502 emb, BAB21247 dbj  
	    Espionne "vide"
	    incr vide
	}
    }
    Espionne "vide $vide"

}

proc CreeToutesLesNotes {{Liste ""}} {

    global RepertoireDuGenome
    global Org1 Org2

    if {[OnTraiteDesCDNAs]}      { return [CreeToutesLesNotesPourCDNA] }
    if {[OnTraiteUneCollection]} { return [CreeToutesLesNotesPourCollection] }

    set RepNotes "$RepertoireDuGenome/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }

    if {$Liste==""} { set Liste [ListeDesPABs] }

    foreach Boite $Liste {
	set Note {}
	set Nom    [Box $Boite nom]
	set Debut  [Box $Boite debut]
	set Fin    [Box $Boite fin]
	set Orient [Box $Boite orient]	

	set Long [expr ($Fin - $Debut + 1)/3]
	set CF [ClasseFonctionnelle $Nom]
	if {$CF==000} { set $CF "" } 

	set Access [Narcisse $Nom]
	if {$Access==""} {
	    set TexteAccess "This ORF couldn't yet be found in database."
	} else {
	    set TexteAccess "$Access"
	}

	lappend Note "$Nom"
	lappend Note ""
	set GN [NomDeGene $Nom]
	if {$GN!="" && $GN!=$Nom} {
	    lappend Note "Gene Name : $GN"
	} 
	lappend Note "Accession number : $TexteAccess"
	lappend Note "Function : [DefinitionApproximative $Nom]"
	set FF [FiabiliteFonction $Nom]
	set FDR "Unknown"
	if { $FF == 9 } { set FDR "Function definition reliability: High" }
	if { $FF == 7 } { set FDR "Function definition reliability: Good" }
	if { $FF == 5 } { set FDR "Function definition reliability: Low" }
	if { $FF == 3 } { set FDR "Function definition reliability: motif on small region" }
	if { $FF == 1 } { set FDR "Function definition reliability: any function detected" }
	if { $FF == 0 } { set FDR "Function definition reliability: no homology found" }
#	lappend Note $FDR
	lappend Note ""
	if {$Orient=="F"} { set Sens "+" } else { set Sens "-" } 
	lappend Note "Genome localisation : $Debut $Fin $Sens  $Long AA"
	lappend Note ""
 	set Texte [ExtraitInfo $Nom "PMID"]
	if { $Texte != "" } { lappend Note "PMID : $Texte\n" }

	set CompoATGC [CompositionEn ATGC $Nom]
	if { $CompoATGC != "" } {
	    scan $CompoATGC "%d %d %d %d %d %d" GC AT A T G C
	    lappend Note "ATGC composition : GC=$GC %  AT=$AT %  A=$A %  T=$T %  G=$G %  C=$C %"
	}
	set Texte [Overlap $Nom]
	if { $Texte != "" } { lappend Note "Overlap : $Texte" }

	set Texte [ShineDalgarno $Nom "Nice"]
	if { $Texte != "" } { lappend Note $Texte }

	lappend Note ""

	set Avant [TexteOMO $Nom Avant]
	set Apres [TexteOMO $Nom Apres]
	if {$Avant!="" || $Apres!=""} {
	    lappend Note "Two genes cluster maintenance"
	}
	if {$Avant!=""} { lappend Note "  with previous : [TexteOMO $Nom Long]" }
	if {$Apres!=""} { lappend Note "  with next     : [TexteOMO $Apres Long]" }
	
	set Texte [SignalDAutresHomologues $Nom]
	if { $Texte != "" } { lappend Note "Other homologs : $Texte" }

	lappend Note ""

	set nCops [NombreDeCopainsDansBlast $Nom]
	lappend Note "BlastP hits count : $nCops"

	if {0 && [info exists Org1] && [YaPABdans $Nom] && ! [ExisteOrthologueDans $Org1 $Nom]} {
	    lappend Note "Ortholog not found in [Glossaire $Org1 Complet]"
	}
	if {0 && [info exists Org1] && [YaPABdans $Nom] && ! [ExisteOrthologueDans $Org2 $Nom]} {
	    lappend Note "Ortholog not found in [Glossaire $Org2 Complet]"
	}
	set nParalogues [NombreDeParaloguesDe $Nom]
	if {$nParalogues==-1} {
	    set Texte ""
	} elseif {$nParalogues==0} {
	    set Texte "Paralogs : not found"
	} else {
	    set Texte "Paralogs : $nParalogues were found"
	}
	if { $Texte != "" } { lappend Note $Texte }
	lappend Note ""

	set pTBN [PourcentageDeGenomesCompletsOrthologuesDansTBlastN $Nom]
	set pDBC [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
	set nGinTBN [PourcentageDeGenomesCompletsOrthologuesDansTBlastN   "Count"]
	set nGinDBC [PourcentageDeGenomesCompletsOrthologuesDansDbClustal "Count"]
	lappend Note "Orthologuous organisms (within the $nGinDBC studied complete genomes)"
	lappend Note "  percentage in TBlastN   : $pTBN %  of $nGinTBN"
	lappend Note "  percentage in DbClustal : $pDBC %  of $nGinDBC"
	lappend Note ""
	
	set Texte [RecapitulatifDesOrthologues $Nom "TPMA"]
	if { $Texte != "" } { lappend Note "$Texte" }
	
	lappend Note ""
	set MD [MDScore $Nom]
	if {$MD > -9999.0} { lappend Note "NormMD : score of multialignment $MD" }
	lappend Note ""
 	set Start [StartCodonReport $Nom "Start"]
	set Texte $Start
	if {[regexp {[0-9]+} $Start Pos]} {
	    set Summary [StartCodonSummary $Nom $Pos]
	    if { ! [regexp "NoSummary" $Summary] } {
		scan $Summary "%d" iGGT
		set GGT ""
		if {$iGGT>0} {
		    set GGT [string trim [string range $Summary 55 end]]
		    append Texte " with ShineDalgarno at $iGGT $GGT"
		}
	    }
	}
	Espionne "$Nom $Texte"
	lappend Note "Proposed start codon : $Texte"
	set Texte [CAI $Nom]
	if {$Texte!=""} { lappend Note "Codon Adaptation Index : $Texte" }
	set Hi [Hydrophobicity $Nom "Hydro"]
	set Hn [Hydrophobicity $Nom "nHelices"]
	if {$Hi!=-999} { lappend Note "Hydrophobicity : Index $Hi ,  $Hn predicted helices" }
	lappend Note ""

	lappend Note [ContenuDuFichier $RepertoireDuGenome/prottfa/$Nom]
	lappend Note ""
	lappend Note [ContenuDuFichier $RepertoireDuGenome/nuctfa/$Nom]
	set MaxD 0
	foreach Ligne $Note {
	    if {[regexp -indices { \: } $Ligne Indices]} {
		scan $Indices "%d" D
		set MaxD [Maxi $MaxD $D]
	    }
	}
	incr MaxD 2
	set LaBelleNote {}
	foreach Ligne $Note {
	    if {[regexp -indices { \: } $Ligne Indices]} {
		scan $Indices "%d" D
		set nPoints [string repeat "." [expr $MaxD - $D]]
		regsub { \: } $Ligne " $nPoints : " Ligne
	    }
	    lappend LaBelleNote $Ligne
	}
	SauveLesLignes $LaBelleNote dans "$RepNotes/$Nom"
    }
    return $LaBelleNote

}

proc CreeToutesLesNotesAnnotation {} {

    foreach Nom [ListeDesPABs] {
	Espionne "$Nom"
	set FichierNote "[RepertoireDuGenome]/notes/$Nom"
	if {[file exists $FichierNote]} {continue}
	CreeLaNoteAnnotation $Nom
    }

}

proc CreeToutesLesNotesPourCDNA {{Start ""} {Keep ""}} {

    global RepertoireDuGenome

    set RepNotes "$RepertoireDuGenome/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }

    if {$Keep==""} { set Keep 0 } else { set Keep 1 } 

    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	if {$Start!="" && $Nom!=$Start} { continue }
	set Start ""

	if {$Keep && [file exists "$RepNotes/$Nom"]} { continue }

	set Note {}
	
	#Identites
	lappend Note "Name" "$Nom"
	lappend Note "" ""
	lappend Note "cDNA length" [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]]
	lappend Note "" ""
	set Clone [CodeClone $Nom]
	set Owner [OwnerOfCDNA $Nom]
	lappend Note "Code  in the Access database" $Clone
	lappend Note "Owner in the Access database" $Owner
	if {[OnTraiteDesAffymetrix]} {
	    set Access [AffymetrixAccess $Nom]
	    set DE [ExtraitInfo $Nom "GBtagsDefinition"]
	    lappend Note "GBtags accession number" $Access
	    lappend Note "GBtags definition" $DE
	}	    
	set JR [JumeauRepresentatif $Nom]
	if {$JR!=$Nom && $JR!=""} {
	    set CC [CodeClone $JR]
	    lappend Note "Same sequence as" "$JR $CC"
	}

	#RepeatMasker
	set TypeMask [QuelMask $Nom]
	Espionne $TypeMask
	set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
	lappend Note "RepeatMasker results" "$TypeMask ( $PourcentMask % )"
	set TypeRepeat [ExtraitInfo $Nom "RM"]
	if  { $TypeRepeat!="" } { 
	    lappend Note "" "$Nom contains $TypeRepeat sequence(s)" 
	}
	
	#BlastN contre le genome humain
	set PolyLoc [PolyLocalise $Nom]
	Espionne $PolyLoc
	lappend Note "BlastN human results" $PolyLoc
	if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
	    set LesLocs [LesLocalisationsSurChroContig $Nom]
	    foreach Loc $LesLocs {
		scan $Loc "%s %s %d %d %s" Chr Cont Gauche Droite Orient
		lappend Note "" "chromosome $Chr contig $Cont from $Gauche to $Droite ( $Orient )"
	    }
	}
	

	#GenScan
	set  GS [ExtraitInfo $Nom "GS"]
	if {$GS != "" } {lappend Note "GenScan results" $GS}

	set  GS3 [ExtraitInfo $Nom "GS3"]
	if {$GS3 != "" } {lappend Note "" "$Nom is $GS3"} 

	set  GSE [ExtraitInfo $Nom "GSE"]
	if {$GSE != "" } {lappend Note "" "$Nom is $GSE"}
	
	#BlastP
	set LesCopains [MeilleursCopains $Nom]
	EspionneL $LesCopains
	lappend Note "BlastP results" [lindex $LesCopains 0]
	foreach Copain [lrange $LesCopains 1 end] {
	    lappend Note "" $Copain
	}
	set CvP [ConsacreVersusPredite $Nom]
	if {$CvP!="No values"} {
	    lappend Note "Prediction_vs_BlastPHit" $CvP
	}

	#BlastX
	set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
	EspionneL $LesCopains
	lappend Note "BlastX results" [lindex $LesCopains 0]
	foreach Copain [lrange $LesCopains 1 end] {
	    lappend Note "" $Copain
	}

	#BlastN contre genembl et est, et TBlastN contre est 
	foreach {Banque Titre} {tblastnest "TblastN Est" blastngenembl "BlastN Genembl" blastnest "BlastN Est"} {
	    set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
	    if {$LesCops=={}} {
		lappend Note "$Titre results" "values not yet available"
	    } elseif {[lindex $LesCops 0]=="File not yet available"} {
		lappend Note "$Titre results" "values not yet available"
	    } elseif {[lindex $LesCops 0]=="No value"} {
		lappend Note "$Titre results" "no value available"
	    } elseif {[lindex $LesCops 0]=="No hit"} {
		lappend Note "$Titre results" "no hit"
	    } else {
		set PremiereFois 1
		foreach Cop $LesCops {
		    set Genre "Inconnu"
		    set Espece "inconnu"
		    scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
		    set OS "$Genre $Espece"
		    set DE [join [lrange [split $Cop " "] 5 end] " "]
		    if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
		    if {$PremiereFois} {
			lappend Note "$Titre results" "$BID $Access $Expect $DE"
			set PremiereFois 0 
			continue
		    } else {
			lappend Note "" "$BID $Access $Expect $DE"
		    }
		}
	    }
	}
	#Affymetrix overlaps
	set LesAffys [LesAffymetrixEnOverlap $Nom]
	if {$LesAffys!={}} {
	    set TexteAffy "[join $LesAffys " "]"
	} else {
	    if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
		set TexteAffy "not tested"
	    } else {
		set TexteAffy "not detected"
	    }
	}
	lappend Note "Affymetrix" $TexteAffy 

	#Traitement pour tous
	set LesLignes {}
	foreach {T V} $Note {
	    if {$T=="Name"} {
		lappend LesLignes $Nom
		continue
	    }
	    if {$T!="" || $V!=""} {
		set L [expr 30 - [string length $T]]
		if {$T!=""} { set C "." ; set S ":" } else { set C " " ; set S " " }
		set P [string repeat $C $L]
		lappend LesLignes [format "%s %s %s %s" $T $P $S $V]
	    } else {
		lappend LesLignes ""
	    }
	}
	SauveLesLignes $LesLignes dans "$RepNotes/$Nom"
    }
    return ""

}

proc CreeToutesLesNotesPourClonage {{Liste ""}} {


    if {$Liste==""} { set Liste [ListeDesPABs] }

    set RepNotes "[RepertoireDuGenome]/notes"
    if { ! [file exists RepNotes]} { file mkdir $RepNotes }
    foreach Nom $Liste {
	set FichierNotes "$RepNotes/$Nom"
	set LesSujets [split [BaClon LesSujets $Nom] " "]
	set LesSujets [LesSujetsDansLeBonOrdre $LesSujets]
	set LesOligos [split [BaClon LesOligos $Nom] " "]

	Espionne $LesSujets

	set TexteTitre "Note for $Nom [Alias $Nom] [CodeMutation $Nom All] [DefinitionRapide $Nom]"
	
	set LesLignesSujets {}
	set OldLigne ""
	foreach Sujet $LesSujets {
	    set Ligne [format "%-15s" $Sujet]
	    set LesPDuTrio {}
	    foreach P $LesOligos {
		if {[BaClonExists Trio $Nom $Sujet $P]} { lappend LesPDuTrio $P }
	    }
	    set LesPDuTrio [ListeSansDoublon $LesPDuTrio]
	    if {[llength $LesPDuTrio]==0} {
		append Ligne " NoOligoFound"
	    } elseif {[llength $LesPDuTrio]!=2} {
		append Ligne " OligosFound [join $LesPDuTrio " "]"
	    } else {
		set A [lindex $LesPDuTrio 0]
		set B [lindex $LesPDuTrio 1]
		set pA [BaClon Trio $Nom $Sujet $A]
		set pB [BaClon Trio $Nom $Sujet $B]
		if {$pA>$pB} { set W $A ; set A $B ; set B $W ; set W $pA ; set pA $pB ; set pB $W }
		Espionne "$Nom $Sujet $A $pA $B $pB"
		set dA [expr $pA - [string length [Oli $A SeqSignals]]/3 -1]
		set fA [expr $pA + [string length [Oli $A SeqSubject]]/3 -1]
		set dB [expr $pB - [string length [Oli $B SeqSignals]]/3 -1]
		set fB [expr $pB + [string length [Oli $B SeqSubject]]/3 -1]
		lappend LesPPCRsADessiner($Nom) "$Sujet [expr ($pA-1)*3+1] [expr $pB*3]  $A [expr ($dA-1)*3+1] [expr $fA*3]  $B [expr ($dB-1)*3+1] [expr $fB*3]"  
		set BlancDevant [string repeat "." [Maxi [expr $pA/10] 2]]
		set BlancDedans [string repeat "-" [Maxi [expr ($pB-$pA)/10] 2]]
		set TxtP " $BlancDevant $A $BlancDedans $B"
		append Ligne $TxtP
	    }
	    if {$Ligne!=$OldLigne} {
		lappend LesLignesSujets $Ligne
	    }
	    set OldLigne $Ligne
	}
	if {$LesLignesSujets=={}} {
	    set TexteSujets "No subject found"
	} else {
	    set TexteSujets [join $LesLignesSujets "\n"]
	}
	if {$LesOligos=={}} {
	    set TexteOligos "No oligos found"
	} else {
	    set TexteOligos {}
	    foreach P $LesOligos {
		lappend TexteOligos [Oli $P "Description"]
	    }
	    set TexteOligos [join $TexteOligos "\n"]
	}

	catch {unset DejaVu}
	foreach P $LesOligos { set DejaVu($P) 1 }
	set OtherOligos {}
	foreach P [LesOligosDuPGS $Nom] {
	    if {[info exists DejaVu($P)]} { continue }
	    lappend OtherOligos [Oli $P "Description"]
	}
	if {$OtherOligos==""} {
	    set TexteOtherOligos ""
	} else {
	    set TexteOtherOligos "Additional Oligos :\n[join $OtherOligos "\n"]"
	}

	set LeTextePPCR {}
	foreach N [LesVirtualPPCRsDuPGS $Nom] {
	    lappend LeTextePPCR [VirtualPPCREnStock $N "Resume"]
	}
	if {$LeTextePPCR=={}} {
	    set TextePPCR "No PPCR found"
	} else {
	    set TextePPCR [join $LeTextePPCR "\n"]
	}

	set LeTexteRec1 {}
	foreach R1 [Rec1 $Nom LesRec1] {
	    lappend LeTexteRec1 [Rec1 $R1 "Description"]
	}
	if {$LeTexteRec1=={}} {
	    set TexteRec1 "No Rec1 found"
	} else {
	    set TexteRec1 [join $LeTexteRec1 "\n"]
	}

	set LeTexteRec2 {}
	foreach R2 [Rec2 $Nom LesRec2] {
	    lappend LeTexteRec2 [Rec2 $R2 "Description"]
	}
	if {$LeTexteRec2=={}} {
	    set TexteRec2 "No Rec2 found"
	} else {
	    set TexteRec2 [join $LeTexteRec2 "\n"]
	}

	set Texte "$TexteTitre\n\n$TexteSujets\n\n$TexteOligos\n$TexteOtherOligos \n\n$TextePPCR\n\n$TexteRec1\n\n$TexteRec2"
	Espionne [Sauve $Texte dans $FichierNotes ]
    }
    if {[info exists LesPPCRsADessiner]} {
	SauveLesLignes [array get LesPPCRsADessiner] dans "[RepertoireDuGenome]/fiches/lesppcrsadessiner"
    }

}

proc CreeToutesLesNotesPourCollection {} {

    global RepertoireDuGenome

    set RepNotes "$RepertoireDuGenome/notes"
    if { ! [file exists $RepNotes]} { File mkdir $RepNotes }

    foreach Boite [ListeDeBoites] {
	set Note {}
	set Nom    [Box $Boite nom]

	set Access [Narcisse $Nom]
	if {$Access==""} {
	    set TexteAccess "This ORF couldn't yet be found in database."
	} else {
	    set TexteAccess "$Access is its database accession number."
	}

	lappend Note "$Nom [NomDeGene $Nom]"
	lappend Note "[DefinitionApproximative $Nom]"

	set MD [MDScore $Nom]
	if {$MD > -9999.0} { lappend Note "MD score of multialignment $MD" }

	if {[set TexteNote [ExtraitInfo $Nom "Note"]]!=""} {
	    lappend Note $TexteNote
	}

	lappend Note ""

	set Texte [RecapitulatifDesOrthologues $Nom "TPMA"]
	if { $Texte != "" } { lappend Note "$Texte" }

	SauveLesLignes $Note dans "$RepNotes/$Nom"
    }
    return ""

}

proc CreeToutesLesSynthetases {{QueLaListe ""}} {

    global RepertoireDuGenome
    global ListeDesPABs

    if {$QueLaListe==""} { set QueLaListe 0 } else { set QueLaListe 1 }

    if { ! [info exists ListeDesPABs]}  { ChargeLesPABs }
    
    if { ! [file exists "$RepertoireDuGenome/coembl"]} { File mkdir "$RepertoireDuGenome/coembl" }
    foreach Nom $ListeDesPABs {
	set FichierMSF "$RepertoireDuGenome/clustalw/$Nom"
	set AA3 [string range [NomDeGene $Nom] 0 2]
	if {$QueLaListe} {
	    lappend LesNomsAAs "$Nom $AA3"
	    continue
	}
	set Destination "$RepertoireDuGenome/coembl/$Nom"
	if { ! [file exists $Destination]} { File mkdir $Destination }
	CreeLesSynthetases $FichierMSF $Destination $AA3
    }
    if {$QueLaListe} {
	Espionne [SauveLesLignes $LesNomsAAs dans "$RepertoireDuGenome/fiches/lookup"]
    }

}

proc CreeTroncons {TFAouGCG {FichierACreer ""} {LongueurChevauchement 10000}} {

    global RepertoireDuGenome
    global ADN DNA RAC
    global NotreOS
    global NotreOrga
    global LongueurTroncons

    Wup "LongueurTroncons must be 100000 because Fred's blast databases"
    set LongueurTroncons 100000

    if {$TFAouGCG=="GCG"} {
	set OnVeutGCG 1
	set OnVeutTFA 0
    }
    if {$TFAouGCG=="TFA"} {
	set OnVeutGCG 0
	set OnVeutTFA 1
    }

    if {[file exists "$RepertoireDuGenome/beton/adn.pure"]} {
	catch {unset ADN}
	catch {unset TDN}
	catch {unset RAC}
	if { ! [info exists ADN]} { ChargeADNetTDNetRAC ".pure" }
	set UnsetADN 1
    } else {
	if { ! [info exists ADN]} { ChargeADNetTDNetRAC  }
	set UnsetADN 0
    }

    if {$FichierACreer==""} {
	set FichierACreer "$RepertoireDuGenome/tfasdugenome/${NotreOrga}overlap$LongueurChevauchement"
    }

    set Repertoire [file dirname $FichierACreer]
    if { ! [file exists $Repertoire]} { File mkdir $Repertoire }

    while {[file exists $FichierACreer]} {
	if {[OuiOuNon "$FichierACreer already exists. Do I overwrite it ?"]} {
	} else {
	    if {[OuiOuNon "Do I exit ?"]} { exit }
	    if {[OuiOuNon "Do I cancel ?"]} { return "" }	    
	}
    }

    set LongueurADN [expr [string length $ADN]-1]

    set Titre [Entre ">$NotreOrga:Part_"]

    set Debut 1
    set Partie 0
    while {$Debut < $LongueurADN} {
	incr Partie
	set Fin [expr $Debut+$LongueurTroncons+$LongueurChevauchement-1]
	set BeauPartie [format "%2.2d" $Partie]
	set BeauDebut [format "%7.7d" $Debut]
	set BeauFin   [format "%7.7d" $Fin]
	set Entete "$Titre$BeauPartie from base $BeauDebut to $BeauFin"

	if {$Fin > $LongueurADN} { set Fin $LongueurADN }
	set Bout [BoutADN $Debut $Fin "F"]

	set DB 0 
	set LargeurLigne 50
	lappend TFA $Entete
	while {$DB < [string length $Bout]} {
	    lappend TFA [string range $Bout $DB [expr $DB+$LargeurLigne-1]]
	    incr DB $LargeurLigne
	}

	incr Debut $LongueurTroncons
    }

    SauveLesLignes $TFA dans $FichierACreer
    if {$OnVeutGCG} {
	Wup "I create FicheirACreer.gcg"
	File rename "$FichierACreer" "$FichierACreer.tfa"  
	eval exec fromfasta "$FichierACreer.tfa" -Nucleotide
	File delete -force $FichierACreer.tfa
    }
    if {$UnsetADN} {
	catch {unset ADN}
	catch {unset TDN}
	catch {unset RAC}
    }

}

proc CreeUnBilanHDACroises {Liste {FichierACreer ""}} {

    global RepertoireDuGenome

    if {$FichierACreer==""} {
	FaireLire "Please give the file name to create"
	set FichierACreer [Entre "$RepertoireDuGenome/Bilan/bilan_"]
    }
    if {$FichierACreer==""} { return "" }

    set LesBons {}
    foreach Nom $Liste {
	set FichierBilan "$RepertoireDuGenome/bilan_xhda/$Nom"
	if { ! [file exists $FichierBilan]} { continue }
	LConcat LesBons [LesLignesDuFichier $FichierBilan]
    }
    return [SauveLesLignes $LesBons dans $FichierACreer]

}

proc CreeUnFichierEMBL {AA3 Organisme AA1 Sequence {Extension ""}} {


    set Sortie {}
    scan $Organisme "%s %s" Genre Espece
    set Gen_esp ""
    append Gen_esp [string toupper [string range $Genre 0 0]]
    append Gen_esp [string tolower [string range $Genre 1 2]]
    append Gen_esp "_[string tolower [string range $Espece 0 2]]"
 
    set Access "${AA1}_${Gen_esp}$Extension"

    lappend Sortie "ID   $Access; cree par rR d'apres un MSF egare."
    lappend Sortie "AC   $Access"
    lappend Sortie "DE   ${AA3}rs"
    lappend Sortie "OS   $Organisme"
    lappend Sortie "OC   [OCduOS $Organisme]"
    lappend Sortie [QueSequenceFormatEMBL $Sequence "AvecSQ"] 
    return $Sortie

}

proc CreeUnTFAs {Selection {FichierACreer ""}} {

    global RepertoireDuGenome

    Wup "Creates the TFAs file containing the sequences of the selected accesses"

    if {$Selection == "" } { return }

    if {[regexp "\n" $Selection]} { 
	set LaSelection [split $Selection "\n"]
    } else {
	set LaSelection $Selection
    }
    set SauveTFAs 1
    set LesTFAS {}
    foreach Ligne $LaSelection {
	scan $Ligne "%s" Fichier
	if {[regexp "/" $Fichier] && [file exists $Fichier]} {
	    set TFAouTFAs [ContenuDuFichier $Fichier]
	    set Format [FormatDeLaSequence $TFAouTFAs] 
	    if {$Format=="tfa" || $Format=="tfas"} {
		lappend LesTFAs $TFAouTFAs
	    }
	    continue
	}
	set Access ""
	scan $Ligne "%s %s" BanqueId Access
	if {[EstUnPAB $BanqueId]} {
	    set Nom $BanqueId
	    set Rep $Access
	    if {$Rep==""} { set Rep "nuctfa" }
	    set FicTFA [GscopeFile $Nom $Rep]
	    if {[FileExists $FicTFA]} {
		set TFA [ContenuDuFichier $FicTFA]
		lappend LesTFAs $TFA
	    }
	    continue
	}
	set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"] 
	lappend LesTFAs $TFA
    }
    if {$LesTFAs == {} } { return "" }

    if {$FichierACreer=="GetText"} { return [join $LesTFAs "\n"] }
    if {$FichierACreer=="GetList"} { return $LesTFAs }

    set TFAs [join $LesTFAs "\n"]
    
    if {$FichierACreer=="ShowIt"} {
	return [AfficheVariable $TFAs "AvecFormate"]
    }
    if {$FichierACreer!=""} {
	return [Sauve $TFAs dans $FichierACreer]
    }
    return $TFAs

}

proc CreeUnTFAsDesListesBidAccess {lBanqueId lAccess {FichierACreer ""}} {

    global RepertoireDuGenome

    Wup "Creates the TFAs file containing the sequences listed in lBanqueId lAccess"

    set SauveTFAs 1
    set LesTFAs {}
    foreach BanqueId $lBanqueId Access $lAccess {
	Espionne "Je cherche $BanqueId $Access"
	set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"] 
	lappend LesTFAs $TFA
    }
    if {$LesTFAs == {} } { return "" }
    set TFAs [join $LesTFAs "\n"]
    
    if {$FichierACreer=="ShowIt"} {
	return [AfficheVariable $TFAs "AvecFormate"]
    }
    if {$FichierACreer!=""} {
	return [Sauve $TFAs dans $FichierACreer]
    }
    return $TFAs

}

proc CreeUneBanqueBlast {{Selection ""} {RepBanquesBanque ""}} {

    global RepertoireDuGenome

    Wup "Selection can be 'AllProttfa' or 'AllNuctfa"
    Wup "Creates a blast database with the sequences whose file names are in the text Selection"
    Wup "If Banque doesn't contain a '/' I take RepertoireDuGenome/banques"

    if {$Selection == "" } {
	set LesPossibles [list "AllProttfa" "AllNuctfa" "DNA"]
	global FichierSequenceADN
	if {[info exists FichierSequenceADN] && [FileExists $FichierSequenceADN]} { lappend LesPossibles $FichierSequenceADN }
	set Selection [ChoixParmi $LesPossibles]
	if {$RepBanquesBanque == ""} { set RepBanquesBanque $Selection }
    }
    if {$Selection == "" } { return "" }

    set SauveTFAs 1

    set RepBanques "$RepertoireDuGenome/banques"

    if {$RepBanquesBanque == "" } { 
	FaireLire "Please give me the name of the Blast Database."
	set RepBanquesBanque [Entre "$RepBanques/$Selection"]
	set Banque [file tail $RepBanquesBanque]
	if {$Banque == ""} { return "" }
    }
    if { ! [regexp "/" $RepBanquesBanque]} { set RepBanquesBanque "$RepBanques/$RepBanquesBanque" }
    set RepBanques [file dirname $RepBanquesBanque]
    file mkdir $RepBanques
    set Banque [file tail $RepBanquesBanque]

    if {$Selection=="AllProttfa"} {
	set RepTFA "prottfa"
    }
    if {$Selection=="AllNuctfa"} {
	set RepTFA "nuctfa"
    }
    if {$Selection=="AllProttfa" || $Selection=="AllNuctfa"} {
	set UseNomAliasDE [OuiOuNonMemo "Do I create new header with '>Nom Alias DE' ?\n if not I'll take the original fasta file"]
	foreach Nom [ListeDesPABs] {
	    if {[Fantome $Nom]} { continue }
	    set FichierTFA "$RepertoireDuGenome/$RepTFA/$Nom"
	    if { ! [file exists $FichierTFA]} { continue }
	    set TFA [ContenuDuFichier $FichierTFA]
	    if {$UseNomAliasDE} {
		set Seq [QueLaSequenceDuTexteTFA $TFA]
		if {[string length $Seq]<1} { continue }
		set Alias [Alias $Nom]
		set DE [DefinitionRapide $Nom]
		regsub "^>" $TFA ">$Nom $Alias $DE" TFA
	    }
	    lappend LesTFAs $TFA
	}
	set TFAs [join $LesTFAs "\n"]
    } else {
	set LaSelection [split $Selection "\n"]
	if {$Selection==$RepBanquesBanque} {
	    set TFAs [ContenuDuFichier $Selection]
	    set SauveTFAs 0
	} else {
	    set SauveTFAs 1
	    foreach Ligne $LaSelection {
		scan $Ligne "%s" Fichier
		if {[regexp "/" $Fichier] && [file exists $Fichier]} {
		    set TFAouTFAs [ContenuDuFichier $Fichier]
		    set Format [FormatDeLaSequence $TFAouTFAs] 
		    if {$Format=="tfa" || $Format=="tfas"} {
			lappend LesTFAs $TFAouTFAs
			continue
		    }
		}
		set Access ""
		scan $Ligne "%s %s" BanqueId Access
		set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK]] 
		lappend LesTFAs $TFA
	    }
	    if {$LesTFAs == {} } { return "" }
	    set TFAs [join $LesTFAs "\n"]
	}
    }

    set FormatProt "F"
    foreach Ligne [split [string range $TFAs 0 2000] "\n"] {
	if {[regexp "^>" $Ligne]} { continue }
	if {[regexp -nocase {[DEFHIKLMPQSVWY]} $Ligne]} {
#	    Espionne $Ligne
	    set FormatProt "T"
	    break
	}
    }

    if { ! [file exists $RepBanques]} { File mkdir $RepBanques }
    if {$SauveTFAs} {
	if {[file exists "$RepBanques/$Banque"]} {
	    if { ! [OuiOuNon "$RepBanques/$Banque\n exists. Overwrite ? "]} { return "" }
	}
    Sauve $TFAs dans "$RepBanques/$Banque"
    }

    NousAllonsAuBoulot $RepBanques
    exec formatdb -i $Banque -p $FormatProt
    OnRevientDuBoulot
    return "$RepBanques/$Banque"

}

proc CreeUneBanqueBlastAvecOrthoInspector {{LesOsChoisis ""} {Banque ""} {Separate ""}} {

    #rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà

    if {$Separate==""} { set Separate "Separate" }
    set Separate [regexp -nocase "Separ" $Separate]

    set Dir ""
    if {$Banque==""} { set Banque "FromOI" } 
    if {[regexp "/" $Banque]} {
	set Dir [file dirname $Banque]
	set Banque [file tail $Banque]
    }
    if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" } 
    file mkdir $Dir

    if {$LesOsChoisis==""} {
	set LesOS [FromOrthoInspector ListOf TaxIdOs]	
	set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
	set LesOsChoisis [split $Choisis "\n"]
    }
    if {[string equal -nocase "All" $LesOsChoisis]} {
	set LesOsChoisis [split [FromOrthoInspector ListOf TaxIdOs] "\n"]
    }


    NousAllonsAuBoulot $Dir

    set LePal {}

    if {$Separate} {
	lappend LeTextePal "#"
	lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecOrthoInspector"
	lappend LeTextePal "#"
	lappend LeTextePal "#"
	lappend LeTextePal "TITLE $Banque"
	lappend LeTextePal "#"
    }


    set LeGrosTfa {}
    foreach OS $LesOsChoisis {
	set TaxId ""; set G ""; set E ""
	lassign [split $OS "_"] TaxId G E
	if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
	set GET "${G}_${E}_${TaxId}"
	set i 0
	set LePetitTfa {}
	foreach ID [FromOrthoInspector $TaxId IDs] {
	    set ID [string toupper $ID]
	    if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
	    set TFA [FromOrthoInspector $ID TFA]
	    if {$TFA==""} { continue }
	    if {$Separate} {
		lappend LePetitTfa $TFA
		lappend LePal $GET
	    } else {
		lappend LeGrosTfa $TFA
	    }
	    incr i
	}
	AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
	if {$Separate && ! [file exists $GET.phr]} {
	    SauveLesLignes $LePetitTfa dans $GET
	    exec formatdb -i $GET -p T
	}
    }
    set LePal [lsort -unique $LePal]
    if {$Separate} {
	set Pal [join $LePal " "]
	lappend LeTextePal "DBLIST $Pal"
	lappend LeTextePal "#"
	SauveLesLignes $LeTextePal dans "$Banque.pal"
    } else {
	while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
	    if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
		break
	    }
	    if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
	}
	SauveLesLignes $LeGrosTfa dans $Banque
	exec formatdb -i $Banque -p T
    }
    OnRevientDuBoulot

    return "$Dir/$Banque"

}

proc CreeUneBanqueBlastAvecYannis {{LesOsChoisis ""} {Banque ""} {Separate ""}} {

    #rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà

    if {$Separate==""} { set Separate "Separate" }
    set Separate [regexp -nocase "Separ" $Separate]

    set Dir ""
    if {$Banque==""} { set Banque "Proteome" } 
    if {[regexp "/" $Banque]} {
	set Dir [file dirname $Banque]
	set Banque [file tail $Banque]
    }
    if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" } 
    file mkdir $Dir

    if {$LesOsChoisis==""} {
	set LesOS [FromYannis ListOf TaxIdOs]	
	set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
	set LesOsChoisis [split $Choisis "\n"]
    }
    if {[string equal -nocase "All" $LesOsChoisis]} {
	set LesOsChoisis [split [FromYannis ListOf TaxIdOs] "\n"]
    }


    NousAllonsAuBoulot $Dir

    set LePal {}

    if {$Separate} {
	lappend LeTextePal "#"
	lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecYannis"
	lappend LeTextePal "#"
	lappend LeTextePal "#"
	lappend LeTextePal "TITLE $Banque"
	lappend LeTextePal "#"
    }


    set LeGrosTfa {}
    foreach OS $LesOsChoisis {
	set TaxId ""; set G ""; set E ""
	lassign [split $OS "_"] TaxId G E
	if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
	set GET "${G}_${E}_${TaxId}"
	set i 0
	set LePetitTfa {}
	foreach ID [FromYannis $TaxId IDs] {
	    set ID [string toupper $ID]
	    if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
	    set TFA [FromYannis $ID TFA]
	    if {$TFA==""} { continue }
	    if {$Separate} {
		lappend LePetitTfa $TFA
		lappend LePal $GET
	    } else {
		lappend LeGrosTfa $TFA
	    }
	    incr i
	}
	AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
	if {$Separate && ! [file exists $GET.phr]} {
	    SauveLesLignes $LePetitTfa dans $GET
	    exec formatdb -i $GET -p T
	}
    }
    set LePal [lsort -unique $LePal]
    if {$Separate} {
	set Pal [join $LePal " "]
	lappend LeTextePal "DBLIST $Pal"
	lappend LeTextePal "#"
	SauveLesLignes $LeTextePal dans "$Banque.pal"
    } else {
	while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
	    if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
		break
	    }
	    if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
	}
	SauveLesLignes $LeGrosTfa dans $Banque
	exec formatdb -i $Banque -p T
    }
    OnRevientDuBoulot

    return "$Dir/$Banque"

}

proc CreeUneBanqueBlastDuBlast {Fichier {NomDeLaBanque ""} {AvecQuery ""}} {

    global RepertoireDuGenome
    if {$NomDeLaBanque==""} { set NomDeLaBanque [file tail $Fichier] }
    set PartieNom [PartieNomsDesSequencesDuBlast $Fichier $AvecQuery]
    CreeUneBanqueBlast $PartieNom $NomDeLaBanque
    return $PartieNom

}

proc CreeUneBanqueBlastDuPAB {Nom {AvecQuery ""} {Rep ""}} {

    if {$Rep==""} { set Rep "blastp" }
    global RepertoireDuGenome
    set PartieNom [PartieNomsDesSequencesDuBlast "$RepertoireDuGenome/$Rep/$Nom" $AvecQuery]
    CreeUneBanqueBlast $PartieNom $Nom
    return $PartieNom

}

proc CreeUneBanqueBlastDuTFAs {FicTFAs {RepBanques ""} {FormatProt ""}} {


    if {$FormatProt==""} { set FormatProt "T" }
    if {$RepBanques==""} { set RepBanques "[RepertoireDuGenome]/banques" }
    
    set Banque [file tail $FicTFAs] 
    regsub -nocase {\.tfa} $Banque "" Banque
    file copy -force $FicTFAs "$RepBanques/$Banque"

    NousAllonsAuBoulot $RepBanques
    exec formatdb -i $Banque -p $FormatProt
    OnRevientDuBoulot
    return "$RepBanques/$Banque"

}

proc CreeUneBanqueBlastPAL {{LesOsChoisis ""} {Banque ""} {Dir ""}} {

    #rR on suppose que les .phr existent déjà. 
    #rR LesOsChoisis sont une liste de TaxId qui figurent en fin du nom des fichiers .phr

    set LesOSTaxId {}
    set LesOS      {}
    set LesTaxId   {}

    if {$Banque==""} { set Banque "BlastDatabase_[Date]" } 


    if {$Dir!=""} { set Dir "[RepertoireDuGenome]/banques" }
    NousAllonsAuBoulot $Dir
    foreach Fichier [lsort [glob -nocomplain "*.phr"]] {
	regsub ".phr$" $Fichier "" OSTaxId
	if { ! [regexp {([A-Z][a-z]+_[a-z\.]+)_([0-9]+)$} $OSTaxId Match OS TaxId]} { continue }
	lappend LesOSTaxId $OSTaxId
	lappend LesOS      $OS
	lappend LesTaxId   $TaxId
	set OSTaxIdDu($TaxId)   $OSTaxId
	set OSTaxIdDu($OSTaxId) $OSTaxId
    }
    if {$LesOsChoisis==""} { set LesOsChoisis [OrganismListForCilioCode "TaxId"] }
    if {$LesOsChoisis==""} { set LesOsChoisis [split [Affiche $LesOSTaxId "AvecRetour" "Select_the_organisms_and_press_Validate"] "\n"] }
    
    if {$LesOsChoisis==""} { return "" }
    
    set LesFichiersChoisis {} 
    foreach Choix $LesOsChoisis {
	if { ! [info exists OSTaxIdDu($Choix)]} {
	    set  OsName [QuestionDeScience EVImm "ret Tax $Choix"]
	    if {$OsName!=""} {
		set iUnder [string first " " $OsName]
Espionne $iUnder
		set Debut [string range $OsName 0 [incr iUnder -1]]
		Espionne $Debut
		set PhrTrouves [glob -nocomplain "$Debut*.phr"]
		if {$PhrTrouves!=""} {
		    set PhrRemplace ""
		    if {[llength $PhrTrouves]==1} {
			if {[OuiOuNon "I couldn't find $Choix $OsName\n Can I use \n$PhrTrouves\n"]} {
			    set PhrRemplace $PhrTrouves
			}
		    } else {
			if {[OuiOuNon "I couldn't find $Choix $OsName\n Ok to coose within\n$PhrTrouves\n"]} {
			    set PhrRemplace [ChoixParmi $PhrTrouves]
			}
		    }
		    if {$PhrRemplace!=""} {
			regsub ".phr$" $PhrRemplace "" Secours
			lappend LesFichiersChoisis $Secours
			continue
		    }
		}
	    }
	    Espionne "I can not find $Choix   I'll skip it. Sorry"
	    continue
	}
	lappend LesFichiersChoisis $OSTaxIdDu($Choix)
    }
    if {$LesFichiersChoisis==""} { return "" }
    
    set LeTextePal {}
    lappend LeTextePal "#"
    lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastPAL"
    lappend LeTextePal "#"
    lappend LeTextePal "#"
    lappend LeTextePal "TITLE $Banque"
    lappend LeTextePal "#"
    
    
    set LePal $LesFichiersChoisis
    set LePal [lsort -unique $LePal]
    set Pal [join $LePal " "]
    lappend LeTextePal "DBLIST $Pal"
    lappend LeTextePal "#"
    set BanqueCreee [SauveLesLignes $LeTextePal dans "$Banque.pal"]
    
    OnRevientDuBoulot

    return "$Dir/$BanqueCreee"

}

proc CreeUneNouvelleProcedure {{Texte ""}} {

    global LesProceduresExistantes

    regsub {^[ \t]*} $Texte "" Texte 

    if {$Texte==""} {
	set Texte [SqueletteDeProc]
    } else {
	if { ! [regexp "^proc " $Texte]} { set Texte "proc $Texte" }
    }
    set Nouveau [EntreTexte $Texte]
    if {$Nouveau==""} { return "" }
    scan $Nouveau "%s %s" P N
    source [Sauve $Nouveau dans [TmpFile ".tcl"]]
    set LesProceduresExistantes [linsert $LesProceduresExistantes 0 $N]
    AfficheLaProc $N

}

proc CreeVue {} {

    global db LNDG SDG Sequences TabSF ListeDesMacs Score ConsMeth ScoreMeth ListeScore OrdTmpDir ListeTypesDeFeatures TableScore LFeatCourantes Defauts TDesSeqnames TDesAccess TDesPhylum LNOrdali LesSequencesAssocieesClassesCanon NombreDeSequences TbScores

    $db eval {begin transaction}

    set pkm [MacCourant]
    set LTot [list]

    # Mise a jour groupes
    set LNDG  [LesClustersDuMac name]
    # WARNING !
    # Groups serve to define LNOrdali variable
    unset -nocomplain SDG
    foreach ng $LNDG {
	set ix [IndexDuCluster $ng]
	#set Ls [LesAccessDuCluster $ix]
	set Ls [LesSeqnamesDuCluster $ix]

	if {$ng eq "all"} {set ng GroupeToutLeMonde}
	set SDG($ng) $Ls
    }
    set ig [lsearch -nocase $LNDG "all"]
    lset LNDG $ig "GroupeToutLeMonde"

    # Mise a jour tableau Sequences
    unset -nocomplain Sequences
    set Ls [LesSequencesDuMac]
    set Ln [LesSeqnamesDuMac]
    set NombreDeSequences [llength $Ln]
    foreach n $Ln s $Ls {
	set Sequences($n) $s
    }

    MetAJourNomsEtSeqs
    AssigneLesPoids
    foreach e [set Defauts(LifeDomains)] {
	set LesSequencesAssocieesClassesCanon($e) [list]
    }
    foreach {n v} [array get TDesPhylum] {
	if {$n in $LNOrdali} {
	    lappend LesSequencesAssocieesClassesCanon($v) $n
	}
    }

    # Met a jour features AFFICHEES !!
    if {[set nbf [$db eval {select count(lsf.pk_featali) from ln_seqali_featali as lsf, ln_mac_seqali as lms where lms.pk_mac=$pkm and lms.pk_seqali=lsf.pk_seqali}]]} {
	set LFeatCourantes [list]
	set ListeTypesDeFeatures [list]
	unset -nocomplain TabSF

	set Lv [$db eval {select si.seqname, fi.* from seqinfo as si, seqali as sa, featali as fi, ln_seqali_featali as lsf, ln_mac_seqali as lms 
	where fi.pk_featali = lsf.pk_featali 
	and   lsf.pk_seqali = lms.pk_seqali 
	and   lms.pk_mac = $pkm  
	and   lms.pk_seqali = sa.pk_seqali
        and   si.pk_seqinfo = sa.pk_seqinfo}]

	foreach {nom x ftype fstart fstop fcolor fscore fnote csys} $Lv {
	    lappend TabSF($nom,$ftype) [list "fstart" $fstart "fstop" $fstop "fcolor" $fcolor "fscore" $fscore "fnote" $fnote "fcsys" $csys]
	    lappend ListeTypesDeFeatures $ftype	    
	}
	set ListeTypesDeFeatures [lsort -unique $ListeTypesDeFeatures]
	if {[set Lft [lsearch -inline -regexp -all $ListeTypesDeFeatures {^Cons\-}]] != {}} {
	    foreach ft $Lft {
		set ScoreMeth($ft,Edit) 0
		if {[regexp {^Cons\-T[0-9]+} $ft]} {
		    set ScoreMeth($ft,ListeGrps) $LNDG
		    foreach g $LNDG {
			set LesPointsDuGroupe($g) ""
		    }
		}
	    }
	}
    }

    # Conservation
    # Pas calcule si precompute = 0
    set pk_Clg [$db eval {select max(pk_clustering) from clustering where pk_mac=$pkm}]
    if {[llength [set Lpkmeas [$db eval {select pk_colmeasure from ln_mac_colmeasure where pk_mac=$pkm}]]]} {
	set i 1
	foreach pk_meas $Lpkmeas {
	    set nom [$db eval {select name from colmeasure where pk_colmeasure=$pk_meas}]
	    set ft "Cons-${nom}_$i"
	    set ident "$nom"
	    set TbScores(Lcols) $nom
	    foreach ix [LesClustersDuMac] g $LNDG {
		array unset TbScores "Score,*"
		if {$g eq "GroupeToutLeMonde"} {
		    set g all
		}
		    
		set l [$db eval {select cm.data from colscore as cm, ln_cluster_colscore as lcc, cluster as c where  cm.pk_colscore=lcc.pk_colscore and  lcc.pk_cluster=c.pk_cluster and  c.pk_cluster=$ix}]
		set l [split $l ,]
		set ConsMeth(IdenGlob) {}
		set ConsMeth(ConsGlob) {}
		# Si groupe trop petit pas de cons
		if {! [llength $l]} {
		    #puts "CreeVue : VIRE g= $g trop petit"
		    continue
		}
		if {[llength [lsort -unique $l]] == 1} {
		    #puts "CreeVue : VIRE g= $g une seule et meme val"
		    continue
		}
		
		if {$g eq "all" || $g eq "All"} {
		    set g ""
		}
		# Met tout en flottant.
		# Enleve -999. pour calc min/max
		set Nl [list] ; set lmx [list]
		foreach e $l {
		    set e [expr {double($e)}]
		    lappend Nl $e
		    if {$e != -999.} {
			lappend lmx $e
		    }
		}
		set l $Nl
		set lmx [lsort -unique -real $lmx]
		set min [lindex $lmx 0]
		set max [lindex $lmx end]
		set Lres [list]
		# scale values between 0 and 100.
		foreach e $l {
		    if {$e != -999.} {
			set e [expr {100.*($e-$min)/($max-$min)}]
			lappend Lres [expr {log($e+1.)}]
		    } else {
			lappend Lres $e
		    }
		}
		set TbScores(Score,$nom) $Lres
		
		CreeListeScore $g
		StockScores $ft $g
		set Lgr [Tclcluspack $::ListeScore -dt coordinates -cm mm -nbc aic -wc]
		TraiteResultatClusteringTcl $Lgr $ident $g "mixturemodels"
	    }
	    
	    if {[info exists ::ScoreMeth($ft,ListeGrps)]} {
		CreeFeaturesMethod $ft
	    }
	    incr i
	}
    }

    # Termine !
    set ListeDesMacs [LesMacs]

    $db eval {commit}

    VueEditee 0

    return

}

proc CreeXmlAnnoteParTousPourUnAccess {Access {RepParent ""}} {

    if {$RepParent==""} { set RepParent "." }
    set Rep "$RepParent/$Access"
    set FichierTfa "$RepParent/$Access.tfa"
    if {[FileAbsent $FichierTfa]} {
	set Seq ""
	catch {set Seq [SequenceDesBanques $Access]}
	if {$Seq==""} { return "" }
	set TFA [SequenceFormatTFA $Seq $Access]
	Sauve $TFA dans $FichierTfa
    }
    set FichierTfas "$RepParent/$Access.tfas"
    regsub ".tfa$" $FichierTfa ".tfas" FichierTfas
    regsub ".tfa$" $FichierTfa ".xml" FichierXml
    set TFA [ContenuDuFichier $FichierTfa]
    set LesTFAs {}
    set LesResultats {}
    foreach FichierResultat [glob -nocomplain "$Rep/{$Access}_*"] {
	regsub -nocase {Resultat\.html$} $FichierResultat "" AP
	set P [StringApres "${Access}_" dans $AP]
	if {[QuelAnnoteXmlPour $P]==""} { continue }
	set P [BonneOrthographePour $P]
	foreach Type [AnnoteXmlPour$P "LesTypes" "" ""] {
	    regsub -nocase ">$Access" $TFA ">${Access}_${P}$Type" TFAp
	    lappend LesResultats $FichierResultat
	    lappend LesTFAs $TFAp
	}
    }
    set TFAs [join $LesTFAs "\n"]
    Sauve $TFAs dans $FichierTfas
    exec clustalw $FichierTfas -convert -output=macsim -outfile=$FichierXml
    return [AnnoteXmlParTousPourUnAccess $Access $FichierXml $LesResultats]

}

proc CreeXmlAnnotePourUnMsf {FichierMsf {RepParent ""}} {

    if {$RepParent==""} { set RepParent "." }
    set NombreDeSequences [DecortiqueUnMSF $FichierMsf LesAccessDansLOrdre]
    regsub ".msf$" $FichierMsf ".xml" FichierXml 
    if {[FileAbsent $FichierXml]} {
	exec clustalw $FichierMsf -convert -output=macsim -outfile=$FichierXml
    }
    set Status [AnnoteXmlPourLesAccess $LesAccessDansLOrdre $RepParent $FichierXml]
    return 

}

proc CreeXmlAnnotePourUnMsfX {FichierMsf {RepParent ""} {FichierXml ""}} {

    
    if {$RepParent==""} { 
	set list [split $fichierMsF "/"]
	set RepParent "[RepertoireDuGenome]/KoAnno/[lindex $list [llength $list]-1]" 
    }
    if {$FichierXml==""} { 
	set list [split $FichierMsf "/"]
	set FichierXml "[RepertoireDuGenome]/macsimXml/[lindex $list [llength $list]-1]"
    }
    set NombreDeSequences [DecortiqueUnMSF $FichierMsf LesAccessDansLOrdre]
    
    Espionne "FichierMsf: $FichierMsf"
    Espionne "RepParent: $RepParent"
    Espionne "FichierXml: $FichierXml"

    #set ::attente 0
    #after 30000 {set ::attente 1}
    #vwait ::attente

    set Status [AnnoteXmlPourLesAccess $LesAccessDansLOrdre $RepParent $FichierXml]
    Espionne Status
    return 
    #return sert à rien?

}

proc CreeXmlAnnotePourUnMsfX2 {FichierMsf {RepParent ""} {FichierXml ""}} {

    
    puts "FichierMsF: $FichierMsf"
    
    if {$RepParent==""} { 
	set RepParent "/genomics/link/PuzzleFit/KoAnno/PUZ05" 
    }
    if {$FichierXml==""} { 
	set FichierXml "/genomics/link/PuzzleFit/macsimXml/PUZ05"
    }
    set NombreDeSequences [DecortiqueUnMSF $FichierMsf LesAccessDansLOrdre]
    
    puts "FichierMsf: $FichierMsf"
    puts "RepParent: $RepParent"
    puts "FichierXml: $FichierXml" 
    
     foreach Access $LesAccessDansLOrdre {
	 set Rep "$RepParent/$Access"
	 #puts $Rep
	 if { [FileAbsent $Rep]} { continue }
	 foreach FichierResultat [glob -nocomplain "$Rep/{$Access}_*"] {
	     regsub -nocase {Resultat\.html$} $FichierResultat "" AP	
	     set P [StringApres "${Access}_" dans $AP]
	     set  BonAnnoteXml [QuelAnnoteXmlPourX $P]
	     if {$BonAnnoteXml==""} { continue }
	     set Status [$BonAnnoteXml $Access $FichierXml $FichierResultat]
	 }	
     }
    return 

}

proc Cree_MapCSA2Pfam {pkpfam Lpdbv fpfam} {

    global PfamDir Tsite ConsRef LNOrdali Sequences T

    set pfamid [lindex [split [file tail $fpfam] .] 0]

    set nsf 0
    set Lres [list]
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	if {! [info exists T($id)]} {
	    puts "error ! no T for $id (pdb $pdb acc $acc"
	    continue
	}
	set idn [set T($id)]

	# are there some CSA sites ?
	set La [array names Tsite "$pdb,$chn,*"]
	if {$La == {}} {
	    puts "No CSA sites found in $pdb $chn !"
	    continue
	}

	# take correspondance
	set nsf 0
	foreach a $La {
	    set Lres [set Tsite($a)] 
	    foreach rtn $Lres {
		lassign $rtn res rnb
		set rnm [AutreCodeLuc $res]
		# out from alignment
		if {$rnb < $pd || $rnb > $pf} {
		    continue
		}
		
		# Correspondance
		# 
		# PDB : 11  14        18
		# Seq : 15  18        22
		#     : A.DEF...GF...IL
		# Ali : 1   4         8
		# Mem : 0   3         7
		# 
		set x [expr {$rnb+($sd-$pd)-$sd}]
		set c [DonnePosSG $idn $x]
		lappend Lres [list $pkpfam $x $c CSA]
		incr nsf
	    }
	}
    }
    puts "Nombre site CSA ...... : $nsf"

    return $Lres

}

proc Cree_MapInterface2Pfam {pkpfam Lpdbv fpfam} {

    global PfamDir ConsRef db LNOrdali Sequences T

    set Lres [list]

    set nri 0
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	if {! [info exists T($id)]} {
	    puts "$id not present !"
	    continue
	}
	set n [set T($id)]

	# -> retrieve interface residues for chain
	set xml [PDBeInterface $pdb]
	if {[string range $xml 0 5] ne ">[string range $xml 0 40]<<"
	    continue
	}
	set Lrpdb [ResiduesInterface $xml $pdb $chn]
	if {$Lrpdb == {}} {
	    puts "Pas de residue interface in $pdb $chn !"

	    continue
	}
	
	# take correspondance
	set nri 0
	foreach r $Lrpdb {
	    lassign $r rnb res
	    set rnm [AutreCodeLuc $res]
	    # out from alignment
	    if {$rnb < $pd || $rnb > $pf} {
		continue
	    }
	    # Correspondance
	    # 
	    # 15  18        22
	    # A.DEF...GF...IL
	    # 1   4         8
	    # 0   3         7
	    # 
	    set x [expr {$rnb+($sd-$pd)-$sd}]
	    set c [DonnePosSG $n $x]
	    lappend ConsRef($pf,Int) $c
	    lappend Lres [list $pkpfam $x $c Interface]

	    incr nri
	}
    }
    puts "Nombre residue Interface .. : $nri"

    return $Lres

}

proc Cree_MapProsite2Pfam {pkpfam Lpdbv fpfam Lpat} {

    global db dps LNOrdali Sequences T

    set pfamid [lindex [split [file tail $fpfam] .] 0]
    set Lpdbid [list]
    foreach {pdb chn acc id pd pf sd sf} $Lpdbv {
	if {! [info exists T($id)]} {
	    puts " No $id in alignment !"
	    continue
	}
	lappend Lpdbid [set T($id)]
    }

    # apply patterns
    set Lres [list]
    set Lval [list]
    foreach pat $Lpat {
	puts "pat $pat"
	set reg [Pattern2Regexp $pat]
	puts "reg $reg"

	# take a sequence, but not pdb one
	foreach n $LNOrdali {
	    if {$n ni $Lpdbid} {
		set s [set Sequences($n)]
		set sdg [string map [list "." "" "-" ""] $s]
		set rep [regexp -inline -indices $reg $sdg]
		if {$rep ne ""} {
		    puts "FOUND : $n"
		    break
		} else {
		    puts " => not in $n"
		}
	    }
	}

	set Li [list]
	foreach c [lrange $rep 1 end] {
	    lassign $c d f
	    for {set i $d} {$i <= $f} {incr i} {
		lappend Li $i
	    }
	}
	foreach i [lsort -unique -integer $Li] {
	    lappend Lval $i [DonnePosSG $n $i]
	}
    }
    set nres 0
    foreach {sq al} $Lval {
	lappend Lres [list $pkpfam $sq $al Prosite]
	incr nres
    }

    puts "Nombre residue Prosite .... : $nres"

    return $Lres

}

proc CreerFichierInfoESTConstructionmRNAFullLength {args} {

    ########### Creation du fichier expliquant le sort de chaque EST du blastnEST ini #################
    ###########     quand on les selectionne pour construire le mRNA full-length      ################
    ### Mode d'emploi:
    ### 1-Initialiser le tableau des BId                                     : args=ini
    ### 2-Remplir le tableau                                                 : args=Id $Id $Info  
    ### 3-Creation du fichier avec les informations contenues dans le tableau: args=write $FichierOut

    global TabInfoESTConstructionmRNAFullLength

    set FirstArg [lindex $args 0]
    ### Initialisation du tableau
    if {[string equal -nocase $FirstArg "ini"] && [info exists TabInfoESTConstructionmRNAFullLength]} {
	unset TabInfoESTConstructionmRNAFullLength
	set   TabInfoESTConstructionmRNAFullLength(LesBId) {}
	return 	
    }
    ### Remplie le tableau avec $Info à l'indexation $BId
    if {[string equal -nocase $FirstArg "Id"]} {
	set BId        [lindex $args 1]
	set Info [join [lrange $args 2 end] " "]
	if {![info exists TabInfoESTConstructionmRNAFullLength($BId,Info)]} {
	    lappend TabInfoESTConstructionmRNAFullLength(LesBId) $BId
	}
	set TabInfoESTConstructionmRNAFullLength($BId,Info) $Info
    }
    ### Creation du fichier de sortie avec chaque BId suivi de l'info le concernant
    if {[string equal -nocase $FirstArg "Write"]} {
	set File    [lindex $args 1]
	set LeTexte {}
	if {[info exists TabInfoESTConstructionmRNAFullLength(LesBId)]} {
	    foreach BId  [set TabInfoESTConstructionmRNAFullLength(LesBId)] {
		set Info [set TabInfoESTConstructionmRNAFullLength($BId,Info)]
		lappend  LeTexte "$BId\t$Info"
	    }
	}
	Sauve [join $LeTexte "\n"] dans $File
	return
    }
 
    return

}

proc CreerLeFichierAccessDesProteinesEtDesmRNAsChoisis_JM {} {


    #set Liste [lrange [ListeDesPABs] 1164 end]
    set Liste [ListeDesPABs]
    set File "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis"
    foreach PAB $Liste {
	set Ligne ""
	set ProtFile "[RepertoireDuGenome]/prottfa/$PAB"
	lappend Ligne $PAB
	#ACT1164 P04264  NomRNA  Homo sapiens    SeqOK
	#set Entete [EnteteDuFichierTFA $ProtFile]
	#set Acc [lindex [split $Entete " "] 3]
	#Espionne "$Acc"
	set  Acc [AccessDuTFADeLaProteine $ProtFile]
	if {$Acc==""} {
	    set Acc NoProtein
	    lappend Ligne $Acc
	    lappend Ligne NomRNA
	    lappend Ligne NoOrganism
	    lappend Ligne NoSeq
	    lappend Ligne NoSeq
	} else {
	    #ACT0755 NoProtein       NomRNA  NoOrganism      NoSeq   NoSeq
	    lappend Ligne $Acc
	    lappend Ligne NomRNA
	    lappend Ligne "Homo sapiens"
	    lappend Ligne SeqOK
	}
	set Ligne [join $Ligne "\t"]
	#Espionne $Ligne
	AppendAuFichier $File $Ligne
    }

}

proc CreerLeFichierDesARPsCorrespondances {} {


    Wup "Permet de recuperer les sequences originelles des boites gscope"

    foreach PAB [ListeDesPABs] {

	set Acc [AccessDuTFADeLaProteine prottfa/$PAB]
	Espionne "$PAB $Acc"
    }
    return ""

}

proc CreerLeFichierNRJSantaLucia {FichierNew} {


    #Parametres d initialisation
    set Enthalpy(A)  2.3
    set Enthalpy(T)  2.3
    set Enthalpy(G)  0.1
    set Enthalpy(C)  0.1
    set Enthalpy(Y)  1.2
    set Enthalpy(R)  1.2
    
    set Entropy(A)   4.1
    set Entropy(T)   4.1
    set Entropy(G)  -2.8
    set Entropy(C)  -2.8
    set Entropy(Y)   0.6
    set Entropy(R)   0.6
    
    set FreeNRJ(A)   1.03
    set FreeNRJ(T)   1.03
    set FreeNRJ(G)   0.98
    set FreeNRJ(C)   0.98
    set FreeNRJ(Y)   1.00
    set FreeNRJ(R)   1.00
    
    #Parametres pour l entropie
    set Entropy(A,A)  -22.2
    set Entropy(A,T)  -20.4
    set Entropy(A,G)  -21.0
    set Entropy(A,C)  -22.4
    set Entropy(T,A)  -21.3
    set Entropy(T,T)  -22.2
    set Entropy(T,G)  -22.7
    set Entropy(T,C)  -22.2
    set Entropy(G,A)  -22.2
    set Entropy(G,T)  -22.4
    set Entropy(G,G)  -19.9
    set Entropy(G,C)  -24.4
    set Entropy(C,A)  -22.7
    set Entropy(C,T)  -21.0
    set Entropy(C,G)  -27.2
    set Entropy(C,C)  -19.9
    
    #R Purine on a pris la moyenne
    set Entropy(A,R)  -21.6
    set Entropy(T,R)  -22.0
    set Entropy(G,R)  -21.0
    set Entropy(C,R)  -24.9
    set Entropy(R,A)  -22.2
    set Entropy(R,T)  -21.4
    set Entropy(R,G)  -20.4
    set Entropy(R,C)  -23.4
    
    #Y Pyrimidine on a pris la moyenne
    set Entropy(A,Y)  -21.4
    set Entropy(T,Y)  -22.2
    set Entropy(G,Y)  -21.4
    set Entropy(C,Y)  -20.4
    set Entropy(Y,A)  -22.0
    set Entropy(Y,T)  -21.6
    set Entropy(Y,G)  -24.9
    set Entropy(Y,C)  -21.0
    
    #Parametres pour l enthalpie
    set Enthalpy(A,A)  -7.9
    set Enthalpy(A,T)  -7.2
    set Enthalpy(A,G)  -7.8
    set Enthalpy(A,C)  -8.4
    set Enthalpy(T,A)  -7.2
    set Enthalpy(T,T)  -7.9
    set Enthalpy(T,G)  -8.5
    set Enthalpy(T,C)  -8.2
    set Enthalpy(G,A)  -8.2
    set Enthalpy(G,T)  -8.4
    set Enthalpy(G,G)  -8.0
    set Enthalpy(G,C)  -9.8
    set Enthalpy(C,A)  -8.5
    set Enthalpy(C,T)  -7.8
    set Enthalpy(C,G) -10.6
    set Enthalpy(C,C)  -8.0
    
    #R Purine on a pris la moyenne
    set Enthalpy(A,R)  -7.8
    set Enthalpy(T,R)  -7.5
    set Enthalpy(G,R)  -8.1
    set Enthalpy(C,R)  -9.5
    set Enthalpy(R,A)  -8.0
    set Enthalpy(R,T)  -7.8
    set Enthalpy(R,G)  -7.9
    set Enthalpy(R,C)  -9.1
    
    #Y Pyrimidine on a pris la moyenne
    set Enthalpy(A,Y)  -7.8
    set Enthalpy(T,Y)  -8.0
    set Enthalpy(G,Y)  -9.1
    set Enthalpy(C,Y)  -7.9
    set Enthalpy(Y,A)  -7.8
    set Enthalpy(Y,T)  -8.0
    set Enthalpy(Y,G)  -9.5
    set Enthalpy(Y,C)  -8.1
    
    #Parametres pour l energie libre
    set FreeNRJ(A,A)  -1
    set FreeNRJ(A,T)  -0.88
    set FreeNRJ(A,G)  -1.28
    set FreeNRJ(A,C)  -1.44
    set FreeNRJ(T,A)  -0.58
    set FreeNRJ(T,T)  -1
    set FreeNRJ(T,G)  -1.45
    set FreeNRJ(T,C)  -1.3
    set FreeNRJ(C,A)  -1.45
    set FreeNRJ(C,T)  -1.28
    set FreeNRJ(C,G)  -2.17
    set FreeNRJ(C,C)  -1.84
    set FreeNRJ(G,A)  -1.3
    set FreeNRJ(G,T)  -1.44
    set FreeNRJ(G,G)  -1.84
    set FreeNRJ(G,C)  -2.24
    
    #R Purine on a pris la moyenne
    set FreeNRJ(A,R)  -1.14
    set FreeNRJ(T,R)  -1.01
    set FreeNRJ(G,R)  -1.57
    set FreeNRJ(C,R)  -1.81
    set FreeNRJ(R,A)  -1.15
    set FreeNRJ(R,T)  -1.16
    set FreeNRJ(R,G)  -1.56
    set FreeNRJ(R,C)  -1.84
    
    #Y Pyrimidine on a pris la moyenne
    set FreeNRJ(A,Y)  -1.16
    set FreeNRJ(T,Y)  -1.15
    set FreeNRJ(G,Y)  -1.84
    set FreeNRJ(C,Y)  -1.56
    set FreeNRJ(Y,A)  -1.01
    set FreeNRJ(Y,T)  -1.14
    set FreeNRJ(Y,G)  -1.81
    set FreeNRJ(Y,C)  -1.57

    set LesBases [lsort -dictionary [array names Enthalpy]]
    foreach Base $LesBases {
	#Espionne "$Base\t[set Enthalpy($Base)]\t[set Entropy($Base)]\t[set FreeNRJ($Base)]"
	set Ligne "$Base\t[set Enthalpy($Base)]\t[set Entropy($Base)]\t[set FreeNRJ($Base)]"
	AppendAuFichier $FichierNew $Ligne
    }
    return ""

}

proc CreerLesOligosDesSpike {} {

    
    Wup "Permet de relire les spikes et de creer les oligos originaux ainsi que ceux de Laurent"

    #RCP1 Root cap 1 protein AF168390 AACAGTATCTTGCCTGGGACAACTGCTTTTGGTATTGCTGTGGCAGCTATAATCATGGCTCGAACTGGGA
    set RepSpike "[RepertoireDuGenome]/Probes/Spike_Athaliana"
    set Fichier  "$RepSpike/Spike_RNA_Athaliana.txt"

    set LesSpikes ""
    if {[file exists $Fichier]} {
	set F [open "$Fichier"]
	while {[gets $F Ligne]>=0} {
	    if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	    #RCP1 Root cap 1 protein AF168390 AACAGTATCTTGCCTGGGACAACTGCTTTTGGTATTGCTGTGGCAGCTATAATCATGGCTCGAACTGGGA
	    set Ligne                [split $Ligne "\t"]
	    set Name                 [string trim [lindex $Ligne 0]]
	    set Tab($Name,Def)       [string trim [lindex $Ligne 1]]
	    set Tab($Name,Acc)       [string trim [lindex $Ligne 2]]
	    set Tab($Name,Oligo)     [string trim [lindex $Ligne 3]]
	    set Tab($Name,UsedOligo) [string trim [lindex $Ligne 4]]
	    lappend LesSpikes $Name
	}
	close $F
    }
    foreach Spike $LesSpikes {
	set FichierTFA "$RepSpike/$Spike"

	set i 0
	foreach Oligo [list [set Tab($Spike,Oligo)] [set Tab($Spike,UsedOligo)]] {
	    incr i
	    set Output     "$RepSpike/$Spike.oligo"    
	    set tmp        ""
	    set DF         "0 0"
	    set EnteteDeLOligo "" 
	    
	    set SequenceSpike [QueLaSequenceDuFichierTFA $FichierTFA]
	    regexp -indices   "$Oligo"  $SequenceSpike tmp
	    set DF $tmp
	    set EnteteQuery   [PremiereLigneDuFichier $FichierTFA]
	    set D [expr [lindex $DF 0] + 1]
	    set F [expr [lindex $DF 1] + 1]
	    
	    #Format: EnteteQuery Taille Tm debut_fin candidats_nbcontigue candidats
	    set EnteteQuery "[string range $EnteteQuery 0 0]$Spike [string range $EnteteQuery 1 end]"
	    set EnteteQuery [linsert $EnteteQuery 1 "Spike_${Spike}_${i}"]
	    
	    lappend EnteteDeLOligo $EnteteQuery
	    lappend EnteteDeLOligo [string length $Oligo]
	    lappend EnteteDeLOligo "[format "%.1f" [CalculTmDeLaSeq $Oligo "" "" NearestNeighbor]]"
	    lappend EnteteDeLOligo "$D $F"
	    lappend EnteteDeLOligo "0 0"
	    if {$i==1} {
		lappend EnteteDeLOligo "No hit found in human databases (Wang & al Genome biology 2003)"
	    } else {
		lappend EnteteDeLOligo "No hit found in human databases (Laurent Vallar blasted against NCBI human and mouse 2003)"
	    }
	    set     EnteteDeLOligo [join $EnteteDeLOligo "\t"]
	    
	    AppendAuFichier $Output $EnteteDeLOligo
	    AppendAuFichier $Output "$Oligo"
	}
    }
    return ""

}

proc CreerUnWidget {K} {


    set Type [ChoixParmi {"Arc" "Line" "Oval" "Polygon" "Rectangle" "Text" "Fleche"}]

    switch $Type {
	"Arc" {
	}
	"Line" {
	    return [$K create line 50 50 100 100 100 200]
	}
	"Oval" {
	}
	"Polygon" {
	    return [$K create polygon 50 50 100 100 100 200 50 50]	    
	}
	"Rectangle" {
	    return [$K create rectangle 50 50 100 100]
	}
	"Text" {
	    set Texte [Entre "Your text"]
	    return [$K create text 100 100 -text $Texte]
	}
    }

    return $Nouveau

}

proc CreonsLeJaune {Famille OrgCible LesGenORFs} {

    global RepertoireDuGenome 

    if {![file exists "$RepertoireDuGenome/addon"]} {
	file mkdir "$RepertoireDuGenome/addon"
	file mkdir "$RepertoireDuGenome/addon/nuctfa"
	file mkdir "$RepertoireDuGenome/addon/blastp" 
	file mkdir "$RepertoireDuGenome/addon/msf"
	file mkdir "$RepertoireDuGenome/addon/prottfa"
    }
    set ErrorLog "$RepertoireDuGenome/addon/error"

    scan [LeMeilleurTblastn $OrgCible $LesGenORFs] "%s %s %s %s %s %s" Gen ORF BankId Deb Fin Expect
    puts "$Gen $ORF $BankId $Deb $Fin $Expect"
    set Bank [lindex [split $BankId ":"] 0]

    #momentane
    if {[regexp AL450380 $Bank]} {set Bank "MLEP"}
    if {[string equal -nocase "pae" $Bank]} {set Bank "PAER0"}
    if {    [regexp -nocase "^WORM" $Bank] || [regexp -nocase "^SPO" $Bank] || [regexp -nocase "^DMEL" $Bank] || ([regexp -nocase "^ECU" $Bank] && 0) || [string equal -nocase "YE" $Bank] || [string equal -nocase "AT1" $Bank] || [string equal -nocase "AT2" $Bank] || [string equal -nocase "AT3" $Bank] || [string equal -nocase "AT4" $Bank] || [string equal -nocase "AT5" $Bank]} {
	AppendAuFichier $ErrorLog "$Famille $Gen $ORF $BankId $Deb $Fin $Expect EUK"
	return
    }	
    #fin du momentane

    if {$Deb<=$Fin} {
	set SeqADN [ORFDeHSPTblastN $Deb $Fin "F" $Bank Frameshift]
    } else {
	set SeqADN [ORFDeHSPTblastN $Fin $Deb "R" $Bank Frameshift]
    }
    if {$SeqADN==""} {
	AppendAuFichier $ErrorLog "$Famille $Gen $ORF $BankId $Deb $Fin $Expect"
	return
    }

    #creation des fichiers TFA
    set Nom "${Famille}_$OrgCible"
    set SeqADNTFA  [Vrac2TFA $Nom [split $SeqADN ""]] 
    set FichierTFA         "$RepertoireDuGenome/addon/prottfa/$Nom"
    set FichierBlastP      "$RepertoireDuGenome/addon/blastp/$Nom"
    set FichierMSF         "$RepertoireDuGenome/addon/msf/$Nom"
    set FichierADN         "$RepertoireDuGenome/addon/nuctfa/$Nom"
    set FichierMet         "$RepertoireDuGenome/addon/startcodon_report"
    set FichierADNCorrige "${FichierADN}_corrige"
    set FichierTFACorrige "${FichierTFA}_corrige"
    set SeqProtTFA [NucToProtTFA $SeqADNTFA]
    EcritFichier $SeqProtTFA $FichierTFA
    EcritFichier $SeqADNTFA  $FichierADN

    #blastp
    eval exec blastall  -p blastp  -i $FichierTFA  -o $FichierBlastP  -d protein  -v 500  -K 0  -b 500  -e 30.0  -F T  -a 4

    #dbclustal (sans ancre)
    set LesAccess [LesCandidatsPourClustalW $FichierBlastP blastp]
    set TexteAccess "$FichierTFA\n[join $LesAccess "\n"]"
    DbClustal "toto" $FichierMSF $TexteAccess "AvecSelection"

    #Test du Start codon
    set Ligne [TestCodonStartEtDeletionDuMSF $FichierMSF "RetourneRemarque" $Nom $SeqADN]
    if {[regexp "CodonStart:" $Ligne]} {
	set Liste [lrange [split $Ligne " "] 4 end]
	set ListeSummary [list]
	foreach {AA Pos Access} $Liste {
	    set LesAccess [split $Access "/"]
	    set Nb [llength $LesAccess]
	    lappend ListeSummary "$Nom X $AA $Pos X X $Nb/"
	}
	set GroupeSecator [GroupeSecator $FichierMSF $Nom "In" "ToCalculate"]
	set ListeCluster [list [StartCodonCluster $Nom $FichierMSF 250 $GroupeSecator]]
	set RapportMet [RapportStartCodonPourMSFIndependant $ListeSummary $ListeCluster]
	AppendAuFichier $FichierMet $RapportMet
	set RapportMet [split $RapportMet " "]
	set Couleur [lindex $RapportMet 1]
	set CodonsProposes [lindex $RapportMet 3] 
	if {$Couleur=="orange" || $Couleur=="red"} {
	    regexp {[MVL]([0-9]+)} $CodonsProposes Match Pos 
	    if {$Pos!=1} {
		set SeqADNCorrige [string range $SeqADN [expr ($Pos-1)*3] end]
		set SeqADNCorrigeTFA [Vrac2TFA $Nom [split $SeqADNCorrige ""]]
		EcritFichier $SeqADNCorrigeTFA $FichierADNCorrige
		EcritFichier [NucToProtTFA $SeqADNCorrigeTFA]  $FichierTFACorrige
	    }
	}
    }

}

proc CreonsLesLoupesRR {} {


    global RepertoireDuGenome 
    
    set RepXHDA "$RepertoireDuGenome/xhda"
    set FichierDesLoupes "$RepXHDA/Loupe.parpab"

    set LesFamilles {}

    if {![file exists $FichierDesLoupes]} { return "Loupe.parpab does not exists" }

    foreach ligne [LesLignesDuFichier $FichierDesLoupes] {
	set OrgaLoupes {}
	
	scan $ligne "%s" Famille
	regsub "$Famille " $ligne "" ligne 
	
	set n [llength $ligne]
	for {set i 0} {$i<$n} {incr i 2} {
	    set Genre  [lindex $ligne $i] 
	    set Espece [lindex $ligne [expr $i+1]] 
	    lappend OrgaLoupes "$Genre $Espece"
	}

	if { ! [info exists DejaVu($Famille)]} {
	    lappend LesFamilles $Famille
	    set DejaVu($Famille) 1
	}
	    
	set OrgaLoupeDeLaFamille($Famille) $OrgaLoupes
	#Espionne "OrgaLoupe $OrgaLoupes"
    }
    #Espionne "LesFamilles $LesFamilles"

    foreach Fam $LesFamilles {
	#Espionne "Fam $Fam"

	set LesGenOrfs [LesMembresDeLaFamille $Fam]
	#Espionne "LesGenOrfs $LesGenOrfs"
	#Espionne "Tab [set OrgaLoupeDeLaFamille($Fam)]"
	
	foreach OrgaJaune [set OrgaLoupeDeLaFamille($Fam)] { 
	    set OrgaJaune [string toupper [Glossaire $OrgaJaune Court]]
	    #Espionne "OrgaJaune $OrgaJaune"
	    #Espionne "Slut CreonsLeJaune $Fam $OrgaJaune $LesGenOrfs"
	    CreonsLeJaune $Fam $OrgaJaune $LesGenOrfs
	}
    }

}

proc CrmParGene {} {


# Recense pour chaque gène le nombre de CRM qu'il posséde (utiliser la proc CompteurDeCompteurs{NombredeCompteurs} pour décortiquer

# Déclaration des fichiers
set FichierDesGenesClasse [open "/tmp/Conservation/UpstreamNV2epure.txt" "r"]
set FichierLog "/tmp/Conservation/FichierDesOccurencesDownstream.txt"
set PathOut $FichierLog

# Suppressions des éventuelles versions précédentes des fichiers
if { [file exists $FichierLog] } {
	file delete $FichierLog
}
set Lus 0
set AccessEnMemoire ""
set Compteur 0
while { [gets $FichierDesGenesClasse Ligne]  >=0 } {
	ScanLaListe $Ligne ID Chro StartSBS EndSBS Access StartGene EndGene Orientation Distance
#	Espionne "$Access $AccessEnMemoire"
	incr Lus
	if {$Access == $AccessEnMemoire && $Distance>=-10000 && $Distance <= 10000} {
		incr Compteur
	} else {
		AppendAuFichier $FichierLog $Compteur
		set Compteur 0		
	}
	set AccessEnMemoire $Access
}
Espionne "Execution terminée. Les résultats des $Lus gènes ont été écrits dans $PathOut"

}

proc CrmReady {} {


	set FileIn [open "/tmp/Conservation/ZeroMismatchsChezHuman-DeuxMismatchChezMouse-2000-2000.txt" "r"]
	set FileOut [open "/tmp/Conservation/ZeroMismatchsChezHuman-DeuxMismatchChezMouse-2000-2000-PourRelocSouris.txt" "w"]
gets $FileIn Ligne
	while { [gets $FileIn Ligne]  >=0 } {
		ScanLaListe $Ligne UcscID  Start  End  Strand Distance X X X X X X crhoX Nx Drx StartX EndX StrX SeqW ScoreX ZeroX MMx Souris Reste 
		
		set SourisListe [split $Souris "/"]
		set LigneOut1 [lindex $SourisListe 0]
		set LigneOut2 [lindex $SourisListe 1]
		puts $FileOut "$LigneOut1 $LigneOut2"
	}

	close $FileIn
close $FileOut 


}

proc CrmTargetsBqlGeneratorKnowngene {Organisme FileIn FileOut Database} {


# Crée un fichier de requétes pour envoi unique de Bird

#Déclaration des fichiers

set FichierDesCoordonnees [open "$FileIn" "r"]
set FichierDesRequetes [open "$FileOut" "w"]
set Chromosome ""

# Suppressions des éventuelles versions précédentes des fichiers

if { [file exists $FichierDesRequetes] } {
	file delete $FichierDesRequetes
}


}

proc CrmTargetsBqlGeneratorRefgene {Organisme FileIn FileOut} {


# Crée un fichier de requétes pour envoi unique de Bird

#Déclaration des fichiers

set FichierDesCoordonnees [open "$FileIn" "r"]
set FichierDesRequetes [open "$FileOut" "w"]
set Chromosome ""

# Suppressions des éventuelles versions précédentes des fichiers

if { [file exists $FichierDesRequetes] } {
	file delete $FichierDesRequetes
}


while { [gets $FichierDesCoordonnees LigneCoordonnees]  >=0 } {

# Dino : ScanLaListe $LigneCoordonnees ChromosomeH DR ID StartH EndH OrientationH SequenceH Score NbMismatch Reste
# Marc : ScanLaListe $LigneCoordonnees ChromosomeH StartH EndH OrientationH SequenceH
	
	ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH SequenceH
	set Chromosome "$ChromosomeH"
 	set Moins "-"
	set Plus "+"
	#In
	puts $FichierDesRequetes "ID * DB UCSC"
	puts $FichierDesRequetes "WH SQLNATIVE select NAME, TXSTART, TXEND, STRAND, EXONSTARTS, EXONENDS, EXONCOUNT, CDSSTART, CDSEND FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and txStart<=$StartH and txEnd>=$EndH ORDER BY TXSTART DESC fetch first 1 rows only"
	puts $FichierDesRequetes "FM FLAT"
	puts $FichierDesRequetes "#"
	puts $FichierDesPostgres "select NAME, TXSTART, TXEND, STRAND, EXONSTARTS, EXONENDS, EXONCOUNT, CDSSTART, CDSEND FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and txStart<=$StartH and txEnd>=$EndH ORDER BY TXSTART DESC fetch first 1 rows only"
	
	#AP
	puts $FichierDesRequetes "ID * DB UCSC"
	puts $FichierDesRequetes "WH SQLNATIVE select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Plus' ORDER BY TXSTART ASC fetch first 1 rows only"
	puts $FichierDesRequetes "FM FLAT"
	puts $FichierDesRequetes "#"
	puts $FichierDesPostgres "select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Plus' ORDER BY TXSTART ASC fetch first 1 rows only"

	#AI
	puts $FichierDesRequetes "ID * DB UCSC"	
	puts $FichierDesRequetes "WH SQLNATIVE select NAME, TXSTART, TXEND, STRAND,NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Moins' ORDER BY TXSTART ASC fetch first 1 rows only"
	puts $FichierDesRequetes "FM FLAT"
	puts $FichierDesRequetes "#"
	puts $FichierDesPostgres "select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Plus' ORDER BY TXSTART ASC fetch first 1 rows only"
	
	#BI
	puts $FichierDesRequetes "ID * DB UCSC"	
	puts $FichierDesRequetes "WH SQLNATIVE select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $StartH>=txEnd and strand='$Plus' ORDER BY TXEND DESC fetch first 1 rows only"
	puts $FichierDesRequetes "FM FLAT"
	puts $FichierDesRequetes "#"
	puts $FichierDesPostgres "select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Plus' ORDER BY TXSTART ASC fetch first 1 rows only"
	
	#BP
	puts $FichierDesRequetes "ID * DB UCSC"	
	puts $FichierDesRequetes "WH SQLNATIVE select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $StartH>=txEnd and strand='$Moins' ORDER BY TXEND DESC fetch first 1 rows only" 	
	puts $FichierDesRequetes "FM FLAT"
	puts $FichierDesRequetes "#"
	puts $FichierDesPostgres "select NAME, TXSTART, TXEND, STRAND, NAME2 FROM ucsc$Organisme.refgene WHERE chrom='$Chromosome' and $StartH>=txEnd and strand='$Moins' ORDER BY TXEND DESC fetch first 1 rows only"
	

}
close $FichierDesRequetes

}

proc CropLesAlignements {{Racine ""} {Ext ""}} {

    if {$Ext==""} { set Ext "png" }
    foreach  Fichier [glob "$Racine.*.*.png"] {
	set RX "$Racine\.(\[0-9\]+)\.(\[0-9\]+)\.$Ext$"
	if { ! [regexp $RX $Fichier Match X Y]} { continue }
	set ImageDe($X,$Y) $Fichier
	lappend LesX $X
	lappend LesY $Y
    }
    set LesX [lsort -integer $LesX]
    set LesY [lsort -integer $LesY]
    set PremierX [lindex $LesX 0]
    set PremierY [lindex $LesY 0]
    set DernierX [lindex $LesX end]
    set DernierY [lindex $LesY end]
    foreach Y $LesY {
	set CropYHaut  10
	set CropYBas  710
	if {$Y==$PremierY} { set CropYHaut   0 }
	if {$Y==$DernierY} { set CropYBas  823 }
	foreach X $LesX {
	    set CropXGauche 113
	    set CropXDroit 1103
	    if {$X==$PremierX} { set CropXGauche    0 }
	    if {$X==$DernierX} { set CropXDroit  1306 }
	    set w [expr $CropXDroit - $CropXGauche]
	    set h [expr $CropYBas  -  $CropYHaut]
	    set Source $ImageDe($X,$Y)
	    regsub "\.$Ext" $Source "-Crop.$Ext" Destin
	    set Destin "./Crop/$Destin"
	    exec convert -crop ${w}x${h}+$CropXGauche+$CropYHaut $Source $Destin
	    lappend LesDestin $Destin
	}
    }
    return $LesDestin

}

proc CroqueMorts {} {

    global RepertoireDuGenome
    global ListeDeBoites
    global InformeSansDemander

    set InformeSansDemander 1
    
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]

	if { [ItsAGene $Nom] } { continue }
	if { ! [Decede $Nom]} { continue }

	set Rapport ""
	foreach OrgaProche [LesOrganismesTresProches] {
	    append Rapport "\t[OrthologueDansTBlastN $Nom $Banque]"
	}

	if { ! [regexp "Orthologue" $Rapport] } {
	    set Message "Enterre: oui $Rapport"
	    Informe $Nom $Message
	    puts "$Nom $Message"
	} else {
	    set Message "Vivant $Rapport"
	    puts "$Nom $Message"
	}
    }

}

proc CrossValidation {Nom {EspecesSelectionnees ""}} {

    global RepertoireDuGenome

    set RepInfos      "$RepertoireDuGenome/mRNAAndProt"
    set FichierInfos  "$RepInfos/$Nom"
    if {![file exists "$FichierInfos"]} {return ""}
    set FicheInfos    [ContenuDuFichier $FichierInfos]
 
   if {[regexp -nocase "split into" $FicheInfos]} {
	set LeMeilleurTirCroise [list "$Nom" "Split"]
	return $LeMeilleurTirCroise
    } elseif {![regexp -nocase "BEGINNING OF THE AUTOMATIC PROTOCOL" $FicheInfos] &&  ![regexp -nocase "split into" $FicheInfos]} {
	set LeMeilleurTirCroise [list "$Nom" "Nothing"]
	return $LeMeilleurTirCroise
    }
    ChargeInfosDeLaRechercheDeProtEtDemRNAs LesHits $Nom

    if {![info exists LesHits(LesOrganismes)]} {
	set LeMeilleurTirCroise [list "$Nom" "Nothing"]
	return $LeMeilleurTirCroise
    }

    set JAiVuUnTirCroise 0
    set JAiVuUnmRNA      0
    set JAiVuUneProteine 0
    foreach Organisme [set LesHits(LesOrganismes)] {
	if {![regexp "$EspecesSelectionnees" $Organisme]} {continue}

	if {    [info exists LesHits($Organisme,mRNA,Access)   ] &&  [info exists LesHits($Organisme,Protein,Access)]} {
	    if {[info exists LesHits($Organisme,Protein,IDENT,LesmRNAs)]} {
		set LesIDENT [set LesHits($Organisme,Protein,IDENT,LesmRNAs)]
	    } elseif {[info exists LesHits($Organisme,Protein,IDENT,LesNucAcs)]} {
		set LesIDENT [set LesHits($Organisme,Protein,IDENT,LesNucAcs)]
	    } elseif {$JAiVuUnTirCroise == 0} {
		if {    $JAiVuUnmRNA == 0 &&  ([info exists LesHits($Organisme,Protein,BEST,LesmRNAs)] ||  [info exists LesHits($Organisme,Protein,BEST,LesNucAcs)])} {
		    ####### PROTEINE est Meilleure que le mRNA############
		    if {$JAiVuUneProteine == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
		    set JAiVuUneProteine 1
		    set Score      [set LesHits($Organisme,Protein,Score) ]
		    set AccessProt [set LesHits($Organisme,Protein,Access)]
		    if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
		    if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
		    if {![info exists ProteineDeRef ]} {set ProteineDeRef  $AccessProt}
		    if {$Score < $ScoreDeRef} {continue}
		    
		    set ProteineDeRef  $AccessProt
		    set ScoreDeRef     $Score
		    set OrganismeDeRef $Organisme
		} elseif {[info exists LesHits($Organisme,Protein,ABSENT,LesmRNAs)  ] ||  [info   exists LesHits($Organisme,Protein,ABSENT,LesNucAcs) ] ||  [info   exists LesHits($Organisme,Protein,DISTANT,LesmRNAs) ] ||  [info   exists LesHits($Organisme,Protein,DISTANT,LesNucAcs)] } {
		    ####### mRNA est meilleure que la PROTEINE###########
		    if {$JAiVuUnmRNA == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
		    set JAiVuUnmRNA 1
		    set AccessmRNA [set LesHits($Organisme,mRNA,Access)   ]
		    set Score      [set LesHits($Organisme,mRNA,Score)    ]
		    if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
		    if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
		    if {![info exists mRNADeRef     ]} {set mRNADeRef      $AccessmRNA}
		    if {$Score < $ScoreDeRef} {continue}
		    set mRNADeRef      $AccessmRNA
		    set ScoreDeRef     $Score
		    set OrganismeDeRef $Organisme
		} else {
		    #######INDETERMINE => comparaison des IDENTITIES#############
		    set   IdProt [set LesHits($Organisme,Protein,Identities)]
		    scan $IdProt "%d/%d" nProt nProtTot
		    set   IdProt [expr $nProt*1.0/$nProtTot]

		    set   IdmRNA [set LesHits($Organisme,mRNA,Identities)   ]
		    scan $IdmRNA "%d/%d" nmRNA nmRNATot
		    set   IdmRNA [expr $nmRNA*1.0/$nmRNATot]

		    if {$IdmRNA < $IdProt && $JAiVuUnmRNA == 0} {
			if {$JAiVuUneProteine == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
			set JAiVuUneProteine 1
			set Score      [set LesHits($Organisme,Protein,Score)    ]
			set AccessProt [set LesHits($Organisme,Protein,Access)]
			if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
			if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
			if {![info exists ProteineDeRef ]} {set ProteineDeRef  $AccessProt}
			if {$Score < $ScoreDeRef} {continue}
			set ProteineDeRef      $AccessProt
			set ScoreDeRef     $Score
			set OrganismeDeRef $Organisme
		    } elseif {$IdProt < $IdmRNA} { 
			if {$JAiVuUnmRNA == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
			set JAiVuUnmRNA 1
			set AccessmRNA [set LesHits($Organisme,mRNA,Access)   ]
			set Score      [set LesHits($Organisme,mRNA,Score)    ]
			if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
			if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
			if {![info exists mRNADeRef     ]} {set mRNADeRef      $AccessmRNA}
			if {$Score < $ScoreDeRef} {continue}
			set mRNADeRef      $AccessmRNA
			set ScoreDeRef     $Score
			set OrganismeDeRef $Organisme
		    }
		} 
		continue
	    } else {
		continue
	    }
	    if {$LesIDENT == {}} {continue}
	    
	    if {$JAiVuUnTirCroise == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
	    set JAiVuUnTirCroise 1

	    set AccessmRNA [set LesHits($Organisme,mRNA,Access)   ]
	    set Score      [set LesHits($Organisme,mRNA,Score)    ]
	    set AccessProt [set LesHits($Organisme,Protein,Access)]
	   
	    if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
	    if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
	    if {![info exists mRNADeRef     ]} {set mRNADeRef      $AccessmRNA}
	    if {![info exists ProteineDeRef ]} {set ProteineDeRef  $AccessProt}

	    if {$Score < $ScoreDeRef} {continue}
	    
	    set mRNADeRef      $AccessmRNA
	    set ProteineDeRef  $AccessProt
	    set ScoreDeRef     $Score
	    set OrganismeDeRef $Organisme
	} elseif {$JAiVuUnTirCroise == 0 &&  [info  exists LesHits($Organisme,mRNA,Access)   ] &&  ![info exists LesHits($Organisme,Protein,Access)]} {

	    if {$JAiVuUnmRNA == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
	    set JAiVuUnmRNA 1

	    set AccessmRNA [set LesHits($Organisme,mRNA,Access)   ]
	    set Score      [set LesHits($Organisme,mRNA,Score)    ]
	    if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
	    if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
	    if {![info exists mRNADeRef     ]} {set mRNADeRef      $AccessmRNA}
	    if {$Score < $ScoreDeRef} {continue}
	    set mRNADeRef      $AccessmRNA
	    set ScoreDeRef     $Score
	    set OrganismeDeRef $Organisme
	} elseif {$JAiVuUnTirCroise == 0 && $JAiVuUnmRNA == 0 &&  [info exists LesHits($Organisme,Protein,Access)] &&  ![info exists LesHits($Organisme,mRNA,Access)]} {
		if {$JAiVuUneProteine == 0 && [info exists ScoreDeRef]} {unset ScoreDeRef}
		set JAiVuUneProteine 1
		set Score      [set LesHits($Organisme,Protein,Score)    ]
		set AccessProt [set LesHits($Organisme,Protein,Access)]
		if {![info exists OrganismeDeRef]} {set OrganismeDeRef $Organisme }
		if {![info exists ScoreDeRef    ]} {set ScoreDeRef     $Score     }
		if {![info exists ProteineDeRef ]} {set ProteineDeRef  $AccessProt}
		if {$Score < $ScoreDeRef} {continue}
		set ProteineDeRef      $AccessProt
		set ScoreDeRef     $Score
		set OrganismeDeRef $Organisme
	}
    }

    if {$JAiVuUnTirCroise} {
	set AccessmRNA $mRNADeRef
	set BIdmRNA    [set LesHits($OrganismeDeRef,mRNA,BanqueId)  ]
	set ExpectmRNA [set LesHits($OrganismeDeRef,mRNA,Expect)    ]
	set ScoremRNA  [set LesHits($OrganismeDeRef,mRNA,Score)     ]
	set IdmRNA     [set LesHits($OrganismeDeRef,mRNA,Identities)]

	set AccessProt $ProteineDeRef
	set BIdProt    [set LesHits($OrganismeDeRef,Protein,BanqueId)   ]
	set ExpectProt [set LesHits($OrganismeDeRef,Protein,Expect)     ]
	set ScoreProt  [set LesHits($OrganismeDeRef,Protein,Score)      ]
	set IdProt     [set LesHits($OrganismeDeRef,Protein,Identities) ]
	
	set Info       "CrossValidation"
	set LeMeilleurTirCroise [list "$Nom" "$Info" "$OrganismeDeRef"  "$BIdmRNA" "$AccessmRNA" "$ExpectmRNA" "$ScoremRNA" "$IdmRNA"  "$BIdProt" "$AccessProt" "$ExpectProt" "$ScoreProt" "$IdProt"]

    } elseif {$JAiVuUnmRNA} {
	set AccessmRNA $mRNADeRef
	set BIdmRNA    [set LesHits($OrganismeDeRef,mRNA,BanqueId)  ]
	set ExpectmRNA [set LesHits($OrganismeDeRef,mRNA,Expect)    ]
	set ScoremRNA  [set LesHits($OrganismeDeRef,mRNA,Score)     ]
	set IdmRNA     [set LesHits($OrganismeDeRef,mRNA,Identities)]
	set Info       "JustmRNA"
	set LeMeilleurTirCroise [list "$Nom" "$Info" "$OrganismeDeRef"  "$BIdmRNA" "$AccessmRNA" "$ExpectmRNA" "$ScoremRNA" "$IdmRNA"]
    } elseif {$JAiVuUneProteine} {
	set AccessProt $ProteineDeRef
	set BIdProt    [set LesHits($OrganismeDeRef,Protein,BanqueId)   ]
	set ExpectProt [set LesHits($OrganismeDeRef,Protein,Expect)     ]
	set ScoreProt  [set LesHits($OrganismeDeRef,Protein,Score)      ]
	set IdProt     [set LesHits($OrganismeDeRef,Protein,Identities) ]
	set Info       "JustProt"
	set LeMeilleurTirCroise [list "$Nom" "$Info" "$OrganismeDeRef"  "$BIdProt" "$AccessProt" "$ExpectProt" "$ScoreProt" "$IdProt"]
    } else {
	set LeMeilleurTirCroise [list "$Nom" "Nothing"]
	return $LeMeilleurTirCroise   
    }
    return $LeMeilleurTirCroise

}

proc CrossValidationPourTous {{LesNoms ""} {Save ""}} {

    global RepertoireDuGenome
    set EspecesSelectionnees ""

    set LesOrganismesAEtudier [LaSelectionDeNoe]

    foreach OrganismeAEtudier $LesOrganismesAEtudier {
	if {$EspecesSelectionnees != ""} {append EspecesSelectionnees "|"}
	scan $OrganismeAEtudier "%s %s" Genre Espece
	append EspecesSelectionnees "$Espece"
    }

    if {$LesNoms == ""} {set LesNoms [ListeDesPABs]}
    set Resultats ""
    foreach Nom $LesNoms {
	Espionne "$Nom"
	set MeilleurTirCroise [join [CrossValidation $Nom $EspecesSelectionnees] "\t"]
	
	append Resultats "$MeilleurTirCroise\n"
    }
    Espionne $Resultats

    set RepFiches "$RepertoireDuGenome/fiches"
    set File "$RepFiches/CrossValidation"
    if {$Save == ""} {
	if {[OuiOuNon "Would you want to save this results in $File?"]} {set Save "Save"}
    }
    if {$Save == "Save"} {Sauve $Resultats dans $File}
    return "$Resultats\n\nSave in $File"

}

proc CssBaseOrdalie {} {

    global CssBaseOrdalie

    set CssBaseOrdalie {} 
    lappend CssBaseOrdalie ""
    set CssBaseOrdalie [join $CssBaseOrdalie "\n"]

    return $CssBaseOrdalie

}

proc CssWscope {} {

    global CssWscope
    if {0 && [info exists CssWscope]} { return $CssWscope }
    set CssWscope {} 
    lappend CssWscope ""
    set CssWscope [join $CssWscope "\n"]
    return $CssWscope

}

proc Cubes {{type one}} {

    global TList Rad pgl

    # 
    # type = one : une boule a chaque
    # coin du cube
    # type = multi : un cube a chaque coin
    # du cube

    if {0 && [info exists TList]} {
	glCallList $TList

	return
    }

    set cube [list  0 0 1  1 0 1  0 1 1  1 1 1  0 0 0  1 0 0  0 1 0  1 1 0]
    if {$type eq "multi"} {
	set voff 15.
	set rad 2.
	set fct 5.
    } else {
	set voff 15.
	set rad 5.
    }

    set TList [glGenLists 1]
    glNewList $TList GL_COMPILE_AND_EXECUTE
    
    use_light
    set QObj [gluNewQuadric]
    gluQuadricDrawStyle $QObj GLU_FILL
    gluQuadricOrientation $QObj GLU_OUTSIDE
    gluQuadricNormals   $QObj GLU_SMOOTH

    foreach {xo yo zo} $cube {
	set xo [expr {$xo*$voff}]
	set yo [expr {$yo*$voff}]
	set zo [expr {$zo*$voff}]
	
	set r [expr {0.7*$xo}]
	set g [expr {0.7*$yo}]
	set b [expr {0.7*$zo}]
	if {$r == 0.0 && $g == 0.0 && $b == 0.0} {
	    set r 0.5 ; set g 0.5 ; set b 0.5
	}
	set col [list $r $g $b 1.0]

	# gris pour les Z = voff, bleu Z = 0.0
	set col [list 0.5 0.5 0.8 1.0] 
	if {$zo > 0} {
	    set col [list 0.5 0.5 0.5 1.0] 
	}

	if {$type eq "multi"} {
	    foreach {x y z} $cube {
		set x [expr {$fct*$x + $xo}]
		set y [expr {$fct*$y + $yo}]
		set z [expr {$fct*$z + $zo}]
		
		lappend Lx $x
		lappend Ly $y
		lappend Lz $z
		
		glPushMatrix
		glTranslatef $x $y $z
		glColor4fv $col
		gluSphere $QObj $rad 16 16
		glPopMatrix
	    }
	} else {
	    lappend Lx $xo
	    lappend Ly $yo
	    lappend Lz $zo
	    
	    glPushMatrix
	    glTranslatef $xo $yo $zo
	    glColor4fv $col
	    gluSphere $QObj $rad 16 16
	    glPopMatrix
	}
    }
    gluDeleteQuadric $QObj	
    glEndList
    
    set xm [lindex [lsort -real $Lx] 0]
    set xx [lindex [lsort -real $Lx] end]
    set ym [lindex [lsort -real $Ly] 0]
    set yx [lindex [lsort -real $Ly] end]
    set zm [lindex [lsort -real $Lz] 0]
    set zx [lindex [lsort -real $Lz] end]

    # Calcul exact de Rad
    # Rad = dist entre points extremes/2 + 
    # 2 * rayon boules
    set Rad [expr {sqrt(($xx-$xm)**2 + ($yx-$ym)**2 + ($zx-$zm)**2)/2. + 2.*$rad}]

    set pgl(xCen) [expr {($xx+$xm)/2.}]
    set pgl(yCen) [expr {($yx+$ym)/2.}]
    set pgl(zCen) [expr {($zx+$zm)/2.}]

    #set pgl(xCen) 0.0
    #set pgl(yCen) 0.0
    #set pgl(zCen) 0.0

    # backclip = z near (z neg)
    set pgl(backclip)  [expr {$pgl(zCen)-1.1*$Rad
}]
    # frontclip = z far
    set pgl(frontclip) [expr {$pgl(zCen)+1.1*$Rad}]

    # backclip = z near (z neg)
    #set pgl(backclip)  [expr { -1.1 * $Rad}]
    # frontclip = zfar 
    #set pgl(frontclip) [expr {  1.1 * $Rad}]

    # backclip = z near (z neg)
    set pgl(backclip)  [expr { -2.1 * $Rad}]
    # frontclip = zfar 
    set pgl(frontclip) 0.0

    # backclip = z near (z neg)
    set pgl(backclip)  [expr { -0.1 * $Rad}]
    # frontclip = zfar 
    set pgl(frontclip) [expr {  2.1 * $Rad}]

    set pgl(eyeX)      0.0
    set pgl(eyeY)      0.0
    set pgl(eyeZ)      [expr {$pgl(frontclip)-1.}]
    
    puts ""
    puts [format "max    %6.2f %6.2f %6.2f" $xx $yx $zx]
    puts [format "min    %6.2f %6.2f %6.2f" $xm $ym $zm]
    puts ""
    puts [format "centre %6.2f %6.2f %6.2f" $pgl(xCen) $pgl(yCen) $pgl(zCen)]
    puts [format "tranla %6.2f %6.2f %6.2f" $pgl(xTra) $pgl(yTra) $pgl(zTra)]
    puts [format "eye    %6.2f %6.2f %6.2f" $pgl(eyeX) $pgl(eyeY) $pgl(eyeZ)]
    puts ""
    puts "Rad       $Rad"
    puts "frontclip $pgl(frontclip)"
    puts "backclip  $pgl(backclip)"
    puts ""

    update
    
    return

}

proc CumulChild {{start ""} {stop ""}} {

    global TaxRoot Tx

    puts "create cumul children ..."
    if {$start eq ""} {
	set start $TaxRoot
    }
    puts "start : $start"

    if {$Tx(-useorgs) eq "all"} {
	set stop toto
    } else {
	set stop "Species"
    }

    SumSpecies $start $stop

    return

}

proc Curl {Url {Fichier ""} {FicOut ""}} {

#rR ne marche pas encore. Voir gscope_bird avec BirdFromQueryFile
    package require http
    set Queue [file tail $Fichier]

    set Query [::http::formatQuery "upload" [ContenuDuFichier $Fichier]]
    set Headers [list  Content-type application/octet-stream  Content-Disposition "inline; filename=\"$Queue\""  Content-Transfer-Encoding binary  ]
    Espionne $Query
    Espionne $Headers

    set GetText 0
    if {$FicOut==""} { set FicOut "GetText" }
    if {$FicOut=="GetText"} { set GetText 1 ; set FicOut [TmpFile] }
    
    #rR from Kroc http://wfr.tcl.tk/1409
    set fout [open $FicOut w]
    set tok [::http::geturl $Url -headers $Headers -query $Query -binary 1 -channel $fout]
    ::http::wait $tok
    close $fout
    
    if { ! $GetText} { return $FicOut }
    set Texte [ContenuDuFichier $FicOut]
    file delete $FicOut
    return $Texte

}

proc CurlExe {} {

    
    global tcl_platform
    global OrdBinDir
    global env
    
    if {[info exists env(GRILLE)] && $env(GRILLE)} {
	return "./curl"
    } else {
	return "curl"
    }
    ## attention, plateforme windows non geree... a revoir

}

proc CurrentGenome {{NewValue ""}} {

    #rR modifié 20150405 
    global RepertoireDuGenome
    global CurrentGenome
    Gs "Text"
    if {$NewValue!=""} { set CurrentGenome $NewValue }

    if { [info exists CurrentGenome]} {
	return $CurrentGenome
    } else {
	set CurrentGenome [file tail $RepertoireDuGenome]
    }
    return $CurrentGenome

    #rR la suite est largemet obsolete 
    if {[regexp {^aby$}    $RepertoireDuGenome]} { set CurrentGenome "Emilie" }
    if {[regexp {^bys$}    $RepertoireDuGenome]} { set CurrentGenome "Seraphin" }
    if {[regexp {casimir$} $RepertoireDuGenome]} { set CurrentGenome "Casimir" }
    if {[regexp {hor}      $RepertoireDuGenome]} { set CurrentGenome "Horikoshii" }
    if {[regexp {fur}      $RepertoireDuGenome]} { set CurrentGenome "Furiosus" }
    
    if { ! [info exists CurrentGenome]} { set CurrentGenome [file tail $RepertoireDuGenome] }
    return $CurrentGenome

}

proc CutBranch {Tree {IndexOrNode end}} {

    set Branches [Branches $Tree]
    if {[regexp {^[0-9]+$} $IndexOrNode] && [string length $IndexOrNode]>5 } {
	set Index [lsearch $Branches $IndexOrNode]
    } else {
	set Index $IndexOrNode
    }
    set NewBranches [lreplace $Branches $Index $Index]
    return [NewTree [ValueOfTree $Tree] $NewBranches]

}

proc CutLesNoms {} {

    global NomSeqSel LSOrdali LNOrdali LNSeqlab LSSeqlab NomsAffiches Defauts NomTextSeq TScrollY

    if {[TypeAli] eq "pasdali"} {
	return
    }
    if {$NomSeqSel == {}} {
	return
    }

    # strore Y-scroll position
    lassign [$TScrollY get] ysc tmp

    set Li [list]
    set NomSeqSel [lsort -real $NomSeqSel]
    foreach e $NomSeqSel {
	lassign [split $e .] y x
	set i [expr {$y-1}]
	if {[lindex $NomsAffiches $i] eq ""} {
	    continue
	} else {
	    lappend Li $i
	}
    }
    set Li [lsort -integer -decreasing $Li]

    if {! [CopyLesNoms]} {
	return
    }

    if {[QuelMode] eq "seqlab"} {
	foreach i $Li {
	    set LNSeqlab [lreplace $LNSeqlab $i $i]
	    set LSSeqlab [lreplace $LSSeqlab $i $i]
	}
	$NomTextSeq cut $Li
    } else {
	foreach i $Li {
	    set LNOrdali [lreplace $LNOrdali $i $i]
	    set LSOrdali [lreplace $LSOrdali $i $i]
	}
	VueEditee 1
	FlagFeatureScore 1
    }
    set NomSeqSel {}
    MetAJourGroupes
    ChangeNomsAff $Defauts(NomsAffiches)
    AfficheNomsEtSeqs
    RepeintNomsEtSeqs

    # re-position at original Y
    CoupleY moveto $ysc

    return

}

proc CutLesNomsSB {} {

    global LNSeqlab
    global LSSeqlab
    global NomNomSeq
    global NomTextSeq
    global BufferSeq
    global NomSeqSel

    if {$NomSeqSel == {}} {return}

    foreach e $NomSeqSel {
	lassign [split $e ,] y x
	lappend Lxy [list $x $y]
    }
    set Lxy [lsort -unique -integer -index 1 -decreasing $Lxy]

    CopyLesNomsSB

    $NomNomSeq  configure -state normal
    $NomTextSeq configure -state normal

    set Long [$NomTextSeq cget -rows]

    set if [lindex [lindex $Lxy 0] 1]
    set n 1
    set Ldel {}
    foreach e [lrange $Lxy 1 end] {
	lassign $e x i
	if {$i+1 == $if} {
	    incr n
	    set if $i
	} else {
	    lappend Ldel $if $n
	    set n 1
	    set if $i
	}
    }
    lappend Ldel $if $n

    foreach {i n} $Ldel {
	$NomTextSeq delete rows $i $n
	$NomNomSeq  delete rows $i $n
	set LSSeqlab [lreplace $LSSeqlab $i [expr {$i+$n-1}]]
	set LNSeqlab [lreplace $LNSeqlab $i [expr {$i+$n-1}]]
    }

    $NomNomSeq  configure -usecommand 1
    $NomTextSeq configure -usecommand 1
    $NomNomSeq  configure -state disabled
    $NomTextSeq configure -state disabled

    set NomSeqSel {}
    update idletasks

    return

}

proc CutSeqsSel {} {


    global RegionSeqSel
    global NomTextSeq
    global NomNomSeq
    global LSSeqlab
    global LNSeqlab
    global BufferRegion

    if {$RegionSeqSel == {}} {return}
    foreach {d f} $RegionSeqSel {
	lassign [split $d "."] y x 
	incr y -1
	set s [string trim [lindex $LNSeqlab $y]]
	if {[SequenceLockee $s]} {
	    FaireLire "Beware ! You must unlock the sequences\nin order to change their residue content"
	    return
	}
    }

    foreach {d f} $RegionSeqSel {
	set dmpT  [$NomTextSeq dump -tag $d $f]
	set LtagT [TagsDuDump $dmpT]
	set Seq   [$NomTextSeq get $d $f]
	lappend BufferRegion [list $d $LtagT $Seq]
	$NomTextSeq delete $d $f
	lassign [split $d "."] y x1 
	lassign [split $f "."] y x2 
	set nx [expr {$x2 - $x1}]
	set sx [string repeat "." $nx]
	$NomTextSeq insert "$y.0 lineend" $sx SPC
	incr y -1
	set s "[string replace [lindex $LSSeqlab $y] $x1 [expr {$x2-1}]]$sx"
	set LSSeqlab [lreplace $LSSeqlab $y $y $s]
    }

    update idletasks

    $NomTextSeq edit separator
    EventNullPourNoms

    return

}

proc CytoBandUcsc {{Qui ""} {Quoi ""} {Quoi2 ""} {Quoi3 ""}} {

    Wup "CytoBandUcsc Mouse 4qA3                   returns the start and stop 17555508 27993917"
    Wup "CytoBandUcsc Mouse chr4 17555585          returns the cytoband 4qA3"
    Wup "CytoBandUcsc Mouse chr4          27993918 returns the cytoband 4qA4"
    Wup "CytoBandUcsc Mouse Limits Of 4            return all limits "
    Wup "CytoBandUcsc ListOf Organisms             return available organisms"
    if {! [OnTraiteUCSCGenomes]} {
	return [QuestionDeScience "UCSCGenomes" "ret CytoBandUcsc $Qui $Quoi $Quoi2 $Quoi3"]
    }
    global CytoBandUcsc
    if {$Quoi3!=""} { set Quoi2 "$Quoi2-$Quoi3" ; set Quoi3 "" } 
    if {$Quoi2!=""} { set Quoi "$Quoi-$Quoi2" ; set Quoi2 "" } 

    if {$Qui==""} {
	set Qui "ListOf"
	set Quoi "Organisms"
    } else {
	if {[regexp -nocase {Homo sapiens|Human} $Qui]} { set Qui "Human" }
	if {[regexp -nocase {Mus musculus|Mouse} $Qui]} { set Qui "Mouse" }
	set O $Qui
    }
    regsub "chr" $Quoi "" Quoi

    if {[regexp -nocase {^[0-9A-Z]+\-[0-9]+$} $Quoi]} { set Quoi "Loc-$Quoi" }

    if {[info exists CytoBandUcsc($Qui,$Quoi)]} { return $CytoBandUcsc($Qui,$Quoi) }
    if {[regexp -nocase {^(Loc\-?[0-9A-Z]+)\-([0-9]+)$} $Quoi Match Chro Pos]} {
	regsub {Loc\-?} $Chro "" Chro
	if {[lsearch [CytoBandUcsc ListOf Organisms] $O]<0} { return "" }
	set Bande [LocaliseDansLaListe [CytoBandUcsc $Qui "Limits-Of-$Chro"] $Pos]
	regsub " " $Bande "-" Bande
	return [CytoBandUcsc $O $Chro $Bande]
    } else {
	if {[info exists CytoBandUcsc("EstCharge")]} { return "" }
    }
    set CytoBandUcsc("EstCharge") 1

    set FichierCytoBandHuman "/genomics/link/UCSCGenomes/Homo_sapiens/database/cytoBand.txt"
    set FichierCytoBandMouse "/genomics/link/UCSCGenomes/Mus_musculus/database/cytoBand.txt"

    set LesLignes {}
    lappend LesLignes "Homo sapiens"
    LConcat LesLignes [LesLignesDuFichier $FichierCytoBandHuman]
    lappend LesLignes "Mus musculus"
    LConcat LesLignes [LesLignesDuFichier $FichierCytoBandMouse]

    set OldChro ""
    foreach Ligne $LesLignes {
	if { [regexp "^chrom" $Ligne]} { continue }
	if { ! [regexp "^chr" $Ligne]} {
	    if {[info exists RajouterF]} {
		lappend CytoBandUcsc($O,Limits-Of-$NChro) $RajouterF
		set CytoBandUcsc($O,$NChroCyto) "$D $F"
	    }
	    if {$Ligne=="Homo sapiens"} {
		set O "Human"
		lappend CytoBandUcsc(ListOf,Organisms) $O
	    }
	    if {$Ligne=="Mus musculus"} {
		set O "Mouse"
		lappend CytoBandUcsc(ListOf,Organisms) $O
	    }
	    continue
	}
	scan $Ligne "%s %s %s %s %s" Chro D F Cyto G
	if {$OldChro!="" && $Chro!=$OldChro} {
	    if {[info exists RajouterF]} {
		lappend CytoBandUcsc($O,Limits-Of-$NChro) $RajouterF
		set CytoBandUcsc($O,$NChroCyto) "$D $F"
	    }
	}
	set OldChro $Chro
	regsub "chr" $Chro "" NChro
	set NChroCyto "$NChro$Cyto"
	set CytoBandUcsc($O,$NChroCyto) "$D [expr $F-1]"
	set CytoBandUcsc($O,$NChro-$D-$F) $NChroCyto
	lappend CytoBandUcsc($O,Limits-Of-$NChro) $D
	lappend CytoBandUcsc($O,List-Of-CytoBands) $NChroCyto
	set RajouterF $F
    }
    if {[info exists RajouterF]} {
	lappend CytoBandUcsc($O,Limits-Of-$NChro) $RajouterF
	set CytoBandUcsc($O,$NChroCyto) "$D $F"
    }
    return [CytoBandUcsc $Qui $Quoi]

}

proc DASServers {} {


    if {0} {
	http://www@~.ebi.ac.uk/das-srv/registry/das/sources (a mirror of http://www.dasregistry.org/das/sources)
	http://www.ebi.ac.uk/das-srv/registry/das/coordinatesystem (a mirror of http://www.dasregistry.org/das/coordinatesystem) 
    }

    return

}

proc DBProfile {s t} {

    global TPS
    
    regsub -all "," $s " " s
    regsub -all {\(|\)} $s " " s
    regsub -all { +} $s " " s
    set l [split $s " "]
    switch [lindex $l 0] {
	"begin" {
	    incr TPS($s,fois)
	    incr TPS($s,time) $t
	    lappend TPS($s,sql) $s
	}
	"select" {
	    set ifrom [lsearch $l "from"]
	    set iwhere [lsearch $l "where"]
	    set lt [lrange $l [expr {$ifrom+1}] [expr {$iwhere-1}]]
	    set ias [lsearch -all $lt "as"]
	    foreach i $ias {
		lappend tb [lindex $lt [expr {$i-1}]]
	    }
	    incr TPS(select,[join $tb "-"],fois)
	    incr TPS(select,[join $tb "-"],time) $t
	    lappend TPS(select,[join $tb "-"],sql) $s
	}
	"insert" {
	    set tb [lindex $l 2]
	    incr TPS(insert,$tb,fois)
	    incr TPS(insert,$tb,time) $t
	    lappend TPS(insert,$tb,sql) "$s"
	}
    }
    
    return

}

proc DBTSSDir {args} {

    ### Information de la localisation du directory contenant DBTSS ###
    set Rep "/home/lardenoi/DB_Promoteurs/DBTSS"
    set FirstArg [lindex $args 0]
    if {$FirstArg == ""       } {return $Rep                           }
    if {$FirstArg == "Seq"    } {return [glob -nocomplain "$Rep/*.seq"]}
    if {$FirstArg == "TFAs"   } {return "$Rep/promoter.tfas"           }
    if {$FirstArg == "DBBlast"} {return "$Rep/promoter.tfas"           }
    return $Rep

}

proc DDSequenceMaskingPourTousTFADuRep_PO {Rep FileVectorLib Organism {MaskOrgaRepeat 1} {MaskNonAlignedArea 1}} {

    ### Pour tous les fichiers .tfa d'un repertoire
    ### Tous les fichiers sont crees dans le rep d'ou est lancee la procedure
    if {![file exists $FileVectorLib]} {
	Espionne "The vector library file $FileVectorLib does not exists"
	return
    }

    foreach File [glob -nocomplain "$Rep/*"] {
	if {![EstUnFichierTFA $File] || ![EstCeDeLADN $File] || [regexp "\.masked$" $File]} {continue}
	Espionne "File $File running..."
	DDSequenceMasking_PO $File $FileVectorLib $Organism $MaskOrgaRepeat $MaskNonAlignedArea 
	Espionne "File $File done."
    }
    return

}

proc DDSequenceMasking_PO {FileTFA FileVectorLib Organism {MaskOrgaRepeat 1} {MaskNonAlignedArea 1}} {

    ######################################################################################
    ###Enleve les sequences de vecteurs de sequence issues de manip comme phage display###
    ######################################################################################
    if {![file exists $FileTFA]} {Espionne "Warning: FileTFA $FileTFA does not exists" ; return }
    set FileTFAVectorMasked      "$FileTFA.vector.masked"
    set FileTFARepeatMasked      "$FileTFA.vector.repeat.masked"
    set FileTFAGenomeMasked      "$FileTFA.vector.repeat.genome.masked"
    set FileTFAMasked            "$FileTFA.masked"
    set FileBlastnHTG            "$FileTFA.blastnHTG"
    set FileBlastnHTGRed         "$FileTFA.blastnHTGred"
    set FileInfos                "$FileTFA.masking.infos"
    set IdMinBlastnHTG           0.9
        
    ### 1- Elimination des repeats sur la sequence initiale ###
    #librairie de vecteurs et adaptateurs puis librairie de l'organisme
    #TailleSeqInfo pour taille de la sequence informative cad non masquee
    Espionne "Repeat masker against $FileVectorLib lib running..."
    set FileTFAVMasked [repeatmasker $FileTFA $FileVectorLib]
    Espionne "FileTFAVMasked $FileTFAVMasked"
    Espionne "FileTFAVectorMasked $FileTFAVectorMasked"
    file rename -force $FileTFAVMasked $FileTFAVectorMasked
    Espionne "Repeat masker against $FileVectorLib lib done."
    regsub -nocase {\.tfa} [file tail $FileTFA] "" Nom
    set Taille  [TailleDeLaSequenceDuFichierTFA $FileTFA]
    foreach LaRVectorM [LesRegionsNouvellementMasquees $FileTFAVectorMasked $FileTFA] {
	set     DRVectorM       [lindex $LaRVectorM  0                                          ]
	set     FRVectorM       [lindex $LaRVectorM  1                                          ]
	set     LaLigne   [join [list   $Nom $Taille $DRVectorM $FRVectorM "Vector masked"] "\t"]
	lappend LeTexte   $LaLigne
    }
  
  if {$MaskOrgaRepeat} {
	Espionne "Repeat masker against $Organism repeat lib running..."
	set   MaskedTFA   [MasqueLesRepeatsDuFichier $FileTFAVectorMasked $Organism]
	Sauve $MaskedTFA  dans $FileTFARepeatMasked
	Espionne "Repeat masker against $Organism repeat lib done."
	foreach LaRRepeatM [LesRegionsNouvellementMasquees $FileTFARepeatMasked $FileTFAVectorMasked] {
	    set     DRRepeatM       [lindex $LaRRepeatM  0                                          ]
	    set     FRRepeatM       [lindex $LaRRepeatM  1                                          ]
	    set     LaLigne   [join [list   $Nom $Taille $DRRepeatM $FRRepeatM "Repeat masked"] "\t"]
	    lappend LeTexte   $LaLigne
	}
    }
    if {!$MaskNonAlignedArea} {return $FileTFARepeatMasked}

    ### 2- Blastn filtre du tfa masque contre la banque genomic: human si Hs et HTG si autre###
    if {$Organism == "Homo sapiens"} {set Banque "human"} else {set Banque "htg"}
    Espionne "Blastn against $Banque database running ..."
    if {![file exists $FileBlastnHTG] || [AskBlast $FileBlastnHTG Taille] == ""} {
	PipeBlast $FileTFARepeatMasked $Banque $FileBlastnHTG N 50 0.1 T 4
    }        
    FichierBlastReduit     $FileBlastnHTG    $FileBlastnHTGRed IdentityWithoutFilter $IdMinBlastnHTG
    if {$Banque != "human"} {
	FichierBlastReduit $FileBlastnHTGRed $FileBlastnHTGRed LesOrgaToKeep         [list $Organism]
    }
    Espionne "Blastn against $Banque database done."

    Espionne "Genome masking running..." 
    ### 3- Detection des regions de la query non alignees dans le blastnHTG (=$LesRAPR)###
    # Si pas de RAPR ds blastnHTG car pas de hit ou hit avec Id inferieur seuil, masquer toute la sequence
    set TailleQuery        [AskBlast $FileBlastnHTGRed Taille]
    Espionne "TailleQuery $TailleQuery" 
    set NbSubjectDansBlast [AskBlast $FileBlastnHTGRed NbSubject]
    Espionne "NbSubjectDansBlast: $NbSubjectDansBlast"
    if {$NbSubjectDansBlast != "" && $NbSubjectDansBlast != 0} {
	set LesGRQB [LesGrandesRegionsDeLaQueryDuBlast   $FileBlastnHTGRed 1e200 1e200 $IdMinBlastnHTG No ""]
	Espionne "LesGRQB: $LesGRQB"
	set LesPRGR [LesPetitesRegionsDesGrandesRegions  $LesGRQB                                           ]
	Espionne "LesPRGR: $LesPRGR"
	set LesRAPR [LesRegionsAbsentesDesPetitesRegions $LesPRGR 1 $TailleQuery                            ]
	Espionne "LesRAPR:$LesRAPR"
    } else {
	#set LaRegionAMasquer [list [list 1 $TailleQuery]]
	#MasqueLesRegionsDuFichierTFA $FileTFARepeatMasked $FileTFAGenomeMasked $LaRegionAMasquer N
	#set LesRAPR          [LesRegionsNouvellementMasquees $FileTFAGenomeMasked $FileTFARepeatMasked]
	set LesRAPR [list [list 1 $TailleQuery]]
    }
	
	### 4- Masque avec "n"les sequences de vecteur dans la sequence query###
    MasqueLesRegionsDuFichierTFA $FileTFARepeatMasked $FileTFAGenomeMasked $LesRAPR n
    Espionne "Genome masking done."
    foreach LaRGenomeM [LesRegionsNouvellementMasquees $FileTFAGenomeMasked $FileTFARepeatMasked] {
	set     DRGenomeM       [lindex $LaRGenomeM  0                                          ]
	set     FRGenomeM       [lindex $LaRGenomeM  1                                          ]
	set     LaLigne   [join [list   $Nom $Taille $DRGenomeM $FRGenomeM "Genome masked"] "\t"]
	lappend LeTexte   $LaLigne
    }
    file copy -force $FileTFAGenomeMasked $FileTFAMasked
    
    #Recherche de la taille finale de sequence informative cad non masquee
    set SeqTFAFinale [QueLaSequenceDuFichierTFA $FileTFAMasked]
    set i            0
    foreach Base [split $SeqTFAFinale ""] {
	if {[string equal -nocase $Base "N"]} {incr i}
    }
    set TailleSeqInformative [expr $Taille -$i]

    #Insertion de cette information dans le fichier .masking.infos
    #Le texte final: NomTFA TailleIni TailleFinaleSeqInfo DRMasquee FRMasquee EtapeDeMasking
    set LeTexteFinal {}
    foreach Ligne $LeTexte {
	set     LesElements     [split   $Ligne           "\t"                   ]
	set     LaNouvelleLigne [linsert $LesElements 2   "$TailleSeqInformative"] 
	set     NouvelleLigne   [join    $LaNouvelleLigne "\t"                   ]
	lappend LeTexteFinal    $NouvelleLigne
    }
    #EspionneL $LeTexteFinal
    Sauve  [join $LeTexteFinal "\n"] dans $FileInfos
    AskBlast "unset"
    return $FileTFAMasked

}

proc DEBlastX2Db {pkAssembly {onlyNonArchived 1}} {

    # s'occupe aussi de l'annotation integrative
    #canalSqlAssemblyDb
    NSAssemblyDb::getCanal

    if {$onlyNonArchived} {
	set sql "SELECT pk_assembly, gscope_project_directory FROM assembly WHERE archived = false"
    } else {
	set sql "SELECT pk_assembly, gscope_project_directory FROM assembly"
    }
    set projects [SqlExec $sql GetList]


    foreach {pk dir} $projects {
	if {$pk != $pkAssembly} {continue}
	puts "$dir [file tail $dir] in [GenomicsSubDir $dir]"
	set dir [GenomicsSubDir $dir]/[file tail $dir]

	set sql "SELECT seq.pk_sequence, seq.gscope_access FROM contig AS c, sequence AS seq WHERE c.pk_assembly = $pk AND seq.pk_sequence = c.consensus_pk_sequence ORDER BY seq.gscope_access"
	set contigs [SqlExec $sql GetList]

	set sql "SELECT seq.pk_sequence, seq.gscope_access FROM singlet AS s, sequence AS seq WHERE s.pk_assembly = $pk AND seq.pk_sequence = s.pk_sequence ORDER BY seq.gscope_access"
	set singlets [SqlExec $sql GetList]

	set sequences $contigs
	set sequences [join [linsert $sequences end $singlets]]

	## lecture des def vero
	set FichierDefVero "$dir/fiches/lesdefinitions"
	array set defVero {}
	if {[file isfile $FichierDefVero]} {
	    Espionne "Reading $FichierDefVero"
	    foreach ligne [LesLignesDuFichier $FichierDefVero] {
		if {[regexp {(\S+) : (.*)} $ligne regMatch access lesdefs]} {
		    set ladef [string trim [lindex [split $lesdefs "\#"] 0]]
		    if {[string length $ladef] != 0} {
			set defVero($access) [regsub -all {'} $ladef "''"]
		    }
		}
	    }
	}

	## lecture EC commun
	set FichierECcommun "$dir/fiches/ECcommun"
	array set ECCommun {}
	if {[file isfile $FichierECcommun]} {
	    Espionne "Reading $FichierECcommun"
	    foreach ligne [LesLignesDuFichier $FichierECcommun] {
		if {[regexp {^>(\S+)} $ligne regMatch access]} {
		    continue
		} elseif {[regexp {^commun: EC (\S+)} $ligne regMatch ec]} {
		    
		} elseif {[info exists ec] && [regexp "$ec (.*)" $ligne regMatch defEC]} {
		    set defEC [string trim $defEC]
		} elseif {[regexp {} $ligne]} {
		    unset -nocomplain access ec defEC
		}
		
		if {[info exists access] && [info exists ec] && [info exists defEC]} {
		    set ECCommun($access) [list $ec [regsub -all {'} $defEC "''"]]
		}
	    }
	}

	## lecture Gene Ontology
	set FichierGO "$dir/fiches/GeneOntology_GPO"
	array set GO {}
	if {[file isfile $FichierGO]} {
	    Espionne "Reading $FichierGO"
	    foreach ligne [LesLignesDuFichier $FichierGO] {
		set leGO [split $ligne "\t"]
		lappend GO([lindex $leGO 0]) [list [lindex $leGO 3] [lindex $leGO 4] [regsub -all {'} [lindex $leGO 5] "''"]]
	    }
	}

	## lecture PFAM-A
	set FichierPfam "$dir/fiches/recouvrementPfams"
	array set PfamA {}
	array set defsAccess {}
	if {[file isfile $FichierPfam]} {
	    Espionne "Reading $FichierPfam"
	    foreach ligne [LesLignesDuFichier $FichierPfam] {
		if {[regexp {^(\S+)\s+(\d+)\s+(\d+)\s+([0-9\.]+)\s+MesPfams:\s+(.*)\s+LesPfams:\s+(.*)\s+Origines:\s+(.*)} $ligne regMatch access nbPfams nbTotal recouv pfams pfamsTotaux origines]} {
		    if {$nbPfams != 0} {
			foreach ori [split [string trim $origines] ";"] {
			    set pfam [regsub {^(PROP|PRED|ERROR)_} [lindex $ori 0] ""]
			    set def [lindex $ori 1]
			    set from [lindex $ori 3]
			    if {![info exists defsAccess($from)]} {
			    set defsAccess($from) [regsub -all {'} [LaDefMACSIMSDe "$dir/macsims/$access.xml" $from] "''"]
			    }
			    lappend PfamA($access) [list $pfam $def $from $defsAccess($from)]
			}
			set PfamA($access,recouv) $recouv
		    }
		}
	    }
	}

	# pour chaque contig et singulet
	foreach {pkSeq access} $sequences {
	    Espionne "$pkSeq $access:"

	    ## Lecture du fichier annotation xml s'il existe
	    set FichierAnnotationXml "$dir/annotation/$access.xml"
	    array unset annotXml
	    if {[file isfile $FichierAnnotationXml]} {
		ParseAnnotationXml $FichierAnnotationXml annotXml
	    }

	    ## sequence proteique
	    set FichierProttfa "$dir/prottfa/$access"
	    if {[file isfile $FichierProttfa]} {
		array unset prottfa
		array set prottfa [readFasta $FichierProttfa 0]
		SqlExec "UPDATE sequence SET protein_seq = '$prottfa($access,sequence)' WHERE pk_sequence = $pkSeq"
		Espionne "\tprotein : $prottfa($access,sequence)"
	    } else {
		SqlExec "UPDATE sequence SET protein_seq = null WHERE pk_sequence = $pkSeq"
		Espionne "\tprotein : unknown"
	    }

	    ## de_blastx
	    set fichierInfos $dir/infos/$access
	    set de ""
	    if {[file isfile $fichierInfos]} {
		set infos [LesLignesDuFichier $fichierInfos]
		foreach inf $infos {
		    if {[regexp -nocase {^DE_BlastX:(.*)$} $inf regMatch p1]} {
			set de [string trim $p1]
		    }
		}
	    }
	    if {$de eq ""} {set de "unknown"}

	    Espionne "\tde_blastx : $de"
	    set de [regsub -all {'} $de "''"]
	    set sql "UPDATE sequence SET de_blastx = '$de' WHERE pk_sequence = $pkSeq"
	    SqlExec $sql

	    ## de_vero
	    if {[info exists annotXml(Definition,Definition)]} {
		if {$annotXml(Definition,Definition) != ""} {
		    set sql "UPDATE sequence SET de_vero = '$annotXml(Definition,Definition)' WHERE pk_sequence = $pkSeq"
		    Espionne "\tde_veroXML: $annotXml(Definition,Definition)"
		} else {
		    set sql "UPDATE sequence SET de_vero = null WHERE pk_sequence = $pkSeq"
		    Espionne "\tde_veroXML: unknown"
		}
	    } elseif {[info exists defVero($access)]} {
		set sql "UPDATE sequence SET de_vero = '$defVero($access)' WHERE pk_sequence = $pkSeq"
		Espionne "\tde_vero: $defVero($access)"
	    } else {
		set sql "UPDATE sequence SET de_vero = null WHERE pk_sequence = $pkSeq"
		Espionne "\tde_vero: unknown"
	    }
	    SqlExec $sql

	    ## EC commun
	    if {[info exists annotXml(EC,Commun)]} {
		if {$annotXml(EC,Commun) != ""} {
		    SqlExec "UPDATE sequence SET ec_commun = '$annotXml(EC,Commun)' WHERE pk_sequence = $pkSeq"
		    SqlExec "UPDATE sequence SET ec_def = '$annotXml(EC,Classes,$annotXml(EC,Commun))' WHERE pk_sequence = $pkSeq"
		    Espionne "\tEC communXML: $annotXml(EC,Commun)"
		} else {
		    SqlExec "UPDATE sequence SET ec_commun = null WHERE pk_sequence = $pkSeq"
		    SqlExec "UPDATE sequence SET ec_def = null WHERE pk_sequence = $pkSeq"
		    Espionne "\tEC communXML: unknown"
		}
	    } elseif {[info exists ECCommun($access)]} {
		SqlExec "UPDATE sequence SET ec_commun = '[lindex $ECCommun($access) 0]' WHERE pk_sequence = $pkSeq"
		SqlExec "UPDATE sequence SET ec_def = '[lindex $ECCommun($access) 1]' WHERE pk_sequence = $pkSeq"
		Espionne "\tEC commun: $ECCommun($access)"
	    } else {
		SqlExec "UPDATE sequence SET ec_commun = null WHERE pk_sequence = $pkSeq"
		SqlExec "UPDATE sequence SET ec_def = null WHERE pk_sequence = $pkSeq"
		Espionne "\tEC commun: unknown"
	    }

	    ## Gene Ontology
	    SqlExec "DELETE FROM gene_ontology WHERE pk_sequence = $pkSeq"
	    if {[info exists annotXml(GO,GPO)]} {
		if {[llength $annotXml(GO,GPO)] != 0} {
		    foreach gpo $annotXml(GO,GPO) {
			foreach {go def type parents niv} $gpo {}
			set sql "INSERT INTO gene_ontology(pk_sequence, \"type\", go, definition) VALUES($pkSeq, '$type', '$go', '$def')"
			SqlExec $sql
			Espionne "\tGOXML: $go"
		    }
		} else {
		    Espionne "\tGOXML: unknown"
		}
	    } elseif {[info exists GO($access)]} {
		foreach leGO $GO($access) {
		    set sql "INSERT INTO gene_ontology(pk_sequence, \"type\", go, definition) VALUES($pkSeq, '[lindex $leGO 0]', '[lindex $leGO 1]', '[lindex $leGO 2]')"
		    SqlExec $sql
		    #puts [SqlExec $sql -error]
		    Espionne "\tGO: $leGO"
		}
	    } else {
		Espionne "\tGO: unknown"
	    }

	    ## PFAM-A
	    SqlExec "DELETE FROM pfam WHERE pk_sequence = $pkSeq"
	    if {[info exists annotXml(PFAM,Liste)]} {
		if {[llength $annotXml(PFAM,Liste)] != 0} {
		    foreach lPfam $annotXml(PFAM,Liste) {
			foreach {pfam def from long} $lPfam {}
			regsub {^PROP_} $pfam "" pfam
			regsub {_PARTIAL$} $pfam "" pfam
			set sql "INSERT INTO pfam(pk_sequence, pfam, definition, \"from\", from_def) VALUES($pkSeq, '$pfam', '$def', '$from', '')"
			SqlExec $sql
			Espionne "\tPFAMXML: $pfam"
		    }
		} else {
		    SqlExec "UPDATE sequence SET pfam_cover = null WHERE pk_sequence = $pkSeq"
		    Espionne "\tPFAMXML: unknown"
		}
	    } elseif {[info exists PfamA($access)]} {
		SqlExec "UPDATE sequence SET pfam_cover = '$PfamA($access,recouv)' WHERE pk_sequence = $pkSeq"
		Espionne "\tPFAM: $PfamA($access,recouv)% cover"
		foreach pfam $PfamA($access) {
		    set sql "INSERT INTO pfam(pk_sequence, pfam, definition, \"from\", from_def) VALUES($pkSeq, '[lindex $pfam 0]', '[lindex $pfam 1]', '[lindex $pfam 2]', '[lindex $pfam 3]')"
		    SqlExec $sql
		    Espionne "\tPFAM: $pfam"
		}
	    } else {
		SqlExec "UPDATE sequence SET pfam_cover = null WHERE pk_sequence = $pkSeq"
		Espionne "\tPFAM: unknown"
	    }
	}

	Espionne "FINISHED."
    }

    CanalSqlDisconnect

}

proc DNA2Prot {Seq {Frame1ou2ou3 Frame1}} {

    set Seq [string toupper $Seq]
    regsub -all {[^A-Z]} $Seq "" Seq
    set LaSeq  [split $Seq ""]

    set Taille [llength $LaSeq]

    set Start 0
    if {$Frame1ou2ou3 == "Frame2"} {set Start 1}
    if {$Frame1ou2ou3 == "Frame3"} {set Start 2}

    set LaProt {}
    for {set D $Start} {$D < $Taille} {incr D +3} {
	set F [expr $D + 2]
	set Codon [lrange $LaSeq $D $F]
	set AA [Codon2AA $Codon]
	if {$AA == "*"} {set AA "X"}
	if {$AA == ""} {continue}
	lappend LaProt $AA
    }
    return [join $LaProt ""]

}

proc DNAProtocol {Nom} {

    set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"
    if {![file exists $FichierTFA]} {return}

    set Organisme [OrganismeDuPAB $Nom]

    if {![file exists $FichierTFA] || ![EstUnFichierTFA $FichierTFA]} {return}

    LaSelectionDeNoe

    ###RepeatMasker#############
    set RepNucMask "[RepertoireDuGenome]/nucmask"
    set FileMasked "$RepNucMask/$Nom"
    if {![file exists $RepNucMask]} {file mkdir $RepNucMask}

    set SelonMasking   0
    set SelonReMasking 0

    set Option "Masking"
    if {[OptionsDesProtocoles $Option]} {
	set SelonMasking 1                     
	if {[file exists "$FileMasked.m"] && [file exists "$FileMasked"] && [OptionsDesProtocoles $Option Continue]} {set SelonMasking 0}    
    }
    set Option "Masking & ReMasking"
    if {[OptionsDesProtocoles $Option]} {
	set SelonMasking 1;set SelonReMasking 1
	if {[file exists "$FileMasked.mrm"] && [file exists "$FileMasked"] && [OptionsDesProtocoles $Option Continue]} {
	    set SelonMasking 0;set SelonReMasking 0
	}    
    }
    if {$SelonMasking || $SelonReMasking} {
	Espionne "$Nom -> repeatmasker"
	AppendAuFichier [Fiches]/qds.log "$Nom -> repeatmasker"
	File copy -force $FichierTFA $FileMasked
	File copy -force [ProtocoleRepeatMasker $FileMasked $Organisme $SelonMasking $SelonReMasking] $FileMasked
    }

    set Option "Masking CheckUp"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	AppendAuFichier [Fiches]/qds.log "$Nom -> $Option"
	set Fichier "[RepertoireDuGenome]/fiches/BilanMasking"

	set Continue [OptionsDesProtocoles $Option Continue]
	if {$Continue} {
	    set Presence [PrepareLeFichierPourLeProtocole $Fichier $Nom "OnContinuera"]
	} else {
	    set Presence [PrepareLeFichierPourLeProtocole $Fichier $Nom "OnRemplacera"]
	}
	
	if {!$Presence || !$Continue} {AppendAuFichier $Fichier [join [BilanMasking $Nom] "\n"]}
    }

    ###BlastN Human#####
    set Option "BlastN Human"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set RepBlastHuman "[RepertoireDuGenome]/blastnhuman"
	if {![file exists $RepBlastHuman]} {file mkdir $RepBlastHuman}
	set FileBlastHuman "$RepBlastHuman/$Nom"

	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Filter    [OptionsDesProtocoles $Option Filter      ]
	
	if {![file exists $FileBlastHuman] || ![OptionsDesProtocoles $Option Continue]} { 
	    PipeBlast $FileMasked human $FileBlastHuman N $NbSubject $Expect $Filter 4
	}
    }

    ###BlastN Mouse#####
    set Option "BlastN Mouse"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set RepBlastMouse "[RepertoireDuGenome]/blastnmouse"
	if {![file exists $RepBlastMouse]} {file mkdir $RepBlastMouse}
	set FileBlastMouse "$RepBlastMouse/$Nom"

	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Filter    [OptionsDesProtocoles $Option Filter      ]
	
	if {![file exists $FileBlastMouse] || ![OptionsDesProtocoles $Option Continue]} { 
	    PipeBlast $FileMasked mouse $FileBlastMouse N $NbSubject $Expect $Filter 4
	}
    }
    
    ###Human exonic map with the DNA clones#############
    set Option "Human exonic map with the DNA clones"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	set RepEM     "[RepertoireDuGenome]/nuctfa_exonicmap"
	if {![file exists $RepEM]} {file mkdir $RepEM}
	set FileEM "$RepEM/$Nom"

	set FileTFA   "[RepertoireDuGenome]/nuctfa/$Nom"
	set FileBlast "[RepertoireDuGenome]/blastnhuman/$Nom"
	
	set AvecBlastOuSansBlast [OptionsDesProtocoles $Option AvecBlastOuSansBlast]
	set Var                  [OptionsDesProtocoles $Option Var                 ]
	set IdMin                [OptionsDesProtocoles $Option IdentityMin         ]
	set SplitWithGap         [OptionsDesProtocoles $Option SplitWithGap        ]
	set IdAlert              [OptionsDesProtocoles $Option IdAlert             ]
	set TailleMin            [OptionsDesProtocoles $Option TailleMin           ]
	set NbSubject            [OptionsDesProtocoles $Option NbSubjectMax        ]
	set Expect               [OptionsDesProtocoles $Option ExpectMax           ]

	if {![file exists $FileEM] || ![OptionsDesProtocoles $Option Continue]} {
	    if {[file exists $FileTFA] && [file exists $FileBlast]} {
		ExonicMapHuman $FileTFA $FileBlast $FileEM $AvecBlastOuSansBlast $Var $IdMin $SplitWithGap $IdAlert $TailleMin $NbSubject $Expect
	    }
	}
    }
    ###Location of DNA clones on Human genome#####
    set Option "Location of DNA clones on Human genome"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	set RepLoc "[RepertoireDuGenome]/Localisation"
	if {![file exists $RepLoc]} {file mkdir $RepLoc}
	set FichierBoxLoc      "$RepLoc/BoxLocalisation_Human"
	set FichierExonicMap   "[RepertoireDuGenome]/nuctfa_exonicmap/$Nom"

	set Continue [OptionsDesProtocoles $Option Continue]
	if {$Continue} {
	    set Presence [PrepareLeFichierPourLeProtocole $FichierBoxLoc $Nom "OnContinuera"]
	} else {
	    set Presence [PrepareLeFichierPourLeProtocole $FichierBoxLoc $Nom "OnRemplacera"]
	}
	if {!$Presence || !$Continue} {
	    AppendAuFichier $FichierBoxLoc [join [mRNAHsapLocalisation $Nom $FichierExonicMap "Box"] "\n"]
	}
    }
    ###Loc on human genome#####
    set Option "Location of  DNA clones on Human genome using the first blast hit"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	set RepLoc "[RepertoireDuGenome]/Localisation"
	if {![file exists $RepLoc]} {file mkdir $RepLoc}
	set FichierBoxLoc      "$RepLoc/BoxLocalisation_Human_FirstBlastHit"
	set FichierBlastGenome "[RepertoireDuGenome]/blastnhuman/$Nom"
	
	set Continue [OptionsDesProtocoles $Option Continue]
	if {$Continue} {
	    set Presence [PrepareLeFichierPourLeProtocole $FichierBoxLoc $Nom "OnContinuera"]
	} else {
	    set Presence [PrepareLeFichierPourLeProtocole $FichierBoxLoc $Nom "OnRemplacera"]
	}
	
	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	
	    AskBlast unset
	
	if {!$Presence || !$Continue} {
	    AppendAuFichier $FichierBoxLoc [join [BoxLocalisation $Nom $FichierBlastGenome $Expect $NbSubject] "\n"]
	}
	AskBlast unset
    }

    ###BlastX Protein#####
    set Option "BlastX protein"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	
	set RepBlastX "[RepertoireDuGenome]/blastx"
	if {![file exists $RepBlastX]} {file mkdir $RepBlastX}
	set FileBlastX "$RepBlastX/$Nom"

	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Filter    [OptionsDesProtocoles $Option Filter      ]

	if {![file exists $FileBlastX] || ![OptionsDesProtocoles $Option Continue]} { 
	    PipeBlast $FileMasked protein $FileBlastX X $NbSubject $Expect $Filter 4
	}
    }
    ###BlastN Genembl#####
    set Option "BlastN genembl"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set RepBlastGenembl "[RepertoireDuGenome]/blastngenembl"
	if {![file exists $RepBlastGenembl]} {file mkdir $RepBlastGenembl}
	set FileBlastGenembl "$RepBlastGenembl/$Nom"

	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Filter    [OptionsDesProtocoles $Option Filter      ]

	if {![file exists $FileBlastGenembl] || ![OptionsDesProtocoles $Option Continue]} { 
	    PipeBlast $FileMasked genembl $FileBlastGenembl N $NbSubject $Expect $Filter 4
	}
    }
    ###BlastN mRNA#####
    set Option "BlastN mRNA"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set RepBlastmRNA "[RepertoireDuGenome]/blastnmrna"
	if {![file exists $RepBlastmRNA]} {file mkdir $RepBlastmRNA}
	set FileBlastmRNA "$RepBlastmRNA/$Nom"
	set FileBlastGenembl "[RepertoireDuGenome]/blastngenembl/$Nom"

	set Id            [OptionsDesProtocoles $Option IdentityMin  ]
	set Expect        [OptionsDesProtocoles $Option ExpectMax    ]
	set LesOrganismes [OptionsDesProtocoles $Option LesOrganismes]

	AskBlast unset
	if {(![file exists $FileBlastmRNA] || ![OptionsDesProtocoles $Option Continue]) && [file exists $FileBlastGenembl]} { 
	    BlastmRNA $FileBlastGenembl $FileBlastmRNA $Id $Expect $LesOrganismes
	}
	AskBlast unset
    }
    ###Protein searches according to mRNA and Protein####
    set Option "Protein searches according to mRNA and Protein searches"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set Rep "[RepertoireDuGenome]/ProtAndmRNA"
	if {![file exists $Rep]} {file mkdir $Rep}
	set FichierProtAndmRNA "$Rep/$Nom"
	set FichierAccessProt  "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis"

	set IdMin     [OptionsDesProtocoles $Option IdentityMin ]
	set IdMax     [OptionsDesProtocoles $Option IdentityMax ]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]

	AskBlast unset
	if {![file exists $FichierProtAndmRNA] || ![OptionsDesProtocoles $Option Continue]} {
	    ProtAndmRNA $Nom $IdMin $IdMax $Expect $NbSubject
	    PrepareLeFichierPourLeProtocole $FichierAccessProt $Nom "OnRemplacera"
	    TFADeLaProteineChoisie $Nom 1
	}
	AskBlast unset
    }
    ###Protein searches according to contig searches####
    set Option "Protein searches according to contig searches"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set Rep "[RepertoireDuGenome]/contig"
	if {![file exists $Rep]} {file mkdir $Rep}

	set Continue [OptionsDesProtocoles $Option Continue]

	set FProttfa "[RepertoireDuGenome]/prottfa/$Nom"
	set Presence 0
	if {[file exists $FProttfa]} {
	    if {![regexp -nocase "from contig" [EnteteDuFichierTFA $FProttfa]]} {set Continue 1}
	    set Presence 1
	}

	set IdMin     [OptionsDesProtocoles $Option IdentityMin ]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Var       [OptionsDesProtocoles $Option Var]

	AskBlast unset
	if {!$Presence || !$Continue} {
	    set FichierContigAndProt  "[RepertoireDuGenome]/fiches/ContigAndProt"
	    set FichierAccessProt     "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis"
	    
	    PrepareLeFichierPourLeProtocole $FichierAccessProt    $Nom "OnRemplacera"
	    PrepareLeFichierPourLeProtocole $FichierContigAndProt $Nom "OnRemplacera"
	    AppendAuFichier $FichierContigAndProt [join [LaMeilleureProteineDuMeilleurContig $Nom $Expect $Var 10000 $IdMin] "\t"]
	    TFADeLaProteineDuContig $Nom 0.8
	}
	AskBlast unset
    }
    ###BlastN EST#####
    set Option "BlastN EST"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"

	set Banque "est"
	if {$Organisme == "Homo sapiens"} {set Banque "est-human"}
	if {$Organisme == "Mus musculus"} {set Banque "est-mouse"}

	set RepBlastEST "[RepertoireDuGenome]/blastn$Banque"
	if {![file exists $RepBlastEST]} {file mkdir $RepBlastEST}
	set FileBlastEST "$RepBlastEST/$Nom"

	set NbSubject [OptionsDesProtocoles $Option NbSubjectMax]
	set Expect    [OptionsDesProtocoles $Option ExpectMax   ]
	set Filter    [OptionsDesProtocoles $Option Filter      ]

	if {![file exists $FileBlastEST] || ![OptionsDesProtocoles $Option Continue]} { 
	    #debutLP sur star le nb de processus ne peut etre egal qu'a 1 pour l'instant
	    #PipeBlast $FileMasked $Banque $FileBlastEST N $NbSubject $Expect $Filter 4
	    PipeBlast $FileMasked $Banque $FileBlastEST N $NbSubject $Expect $Filter 1
	    #finLP
	}
    }
    ###EST Selection#####
    set Option "EST Selection"
    if {[OptionsDesProtocoles $Option]} {
	Espionne "$Nom -> $Option"
	
	set Fichier         "[RepertoireDuGenome]/fiches/SelectedEST"
	#LP
	set LaSelection [lindex [LesLignesDuFichier "[RepertoireDuGenome]/fiches/SelectionDeNoe"] 0]
	if {$LaSelection=="Mus musculus"} {
	    set FichierBlastEST "[RepertoireDuGenome]/blastnest-mouse/$Nom"
	} elseif {$LaSelection=="Homo sapiens"} {
	    set FichierBlastEST "[RepertoireDuGenome]/blastnest-human/$Nom"
	} else {
	    set FichierBlastEST "[lindex [glob -nocomplain "[RepertoireDuGenome]/blastnest*"] 0]/$Nom"
	}
	#set FichierBlastEST "[lindex [glob -nocomplain "[RepertoireDuGenome]/blastnest*"] 0]/$Nom"
	#LP
	set FichierTFA      "[RepertoireDuGenome]/nuctfa/$Nom"

	set Continue [OptionsDesProtocoles $Option Continue]
	if {$Continue} {
	    set Presence [PrepareLeFichierPourLeProtocole $Fichier $Nom "OnContinuera"]
	} else {
	    set Presence [PrepareLeFichierPourLeProtocole $Fichier $Nom "OnRemplacera"]
	}
	set Id           [OptionsDesProtocoles $Option IdentityMin]
	set Quoi         [OptionsDesProtocoles $Option AllOrgaOuJustMyOrga]
	set TailleAliMin [OptionsDesProtocoles $Option TailleAliMin]

	if {(!$Presence || !$Continue) && $FichierBlastEST != ""} {
	    Espionne "$Nom $FichierBlastEST JustMyOrga 0.95"
	    Espionne "$Nom $FichierTFA $FichierBlastEST $Quoi $Id $TailleAliMin"

	    set LesEST [LaSelectionDesEST $Nom $FichierTFA $FichierBlastEST $Quoi $Id $TailleAliMin]
	    if {$LesEST != {}} {
		AppendAuFichier $Fichier [join $LesEST "\n"]
	    } else {
		AppendAuFichier $Fichier "$Nom\tNoESTFound"
	    }
	}
    }
    
    return

}

proc DPCManu {Nom RepertoireIn RepertoireOut} {

    if {$RepertoireIn == ""} {
	set RepertoireIn "msf"
    }
    if {$RepertoireOut == ""} {
	set RepertoireIn "cluspack"
    }
    set InInit [file join [RepertoireDuGenome] $RepertoireIn $Nom]
    set In [file join [RepertoireDuGenome] $RepertoireOut ${Nom}]
    # placement du fichier d alignement dans le bon repertoir pour n avoir pas
    # a deplacer les fichier ensuite
    Espionne $InInit
    File copy -force $InInit $In
    # fichier ".clu" cree quel que soit la methode de clusterisation utilisee
    set OutClu [file join [RepertoireDuGenome] $RepertoireOut ${Nom}.clu]
    
    if {![file exists $In]} {return}
    
    set commande "LanceurCluspack $In alignment"
    set arg "dpc kmeans 0.001"
    set FileClustering "${In}.clu"
    puts "DPC"
    if {[catch {eval $commande $arg} Message]} {
	Espionne $Message
	Espionne "Problem with $In with DPC"
	return 0
    }
    return 1

}

proc DST {{Texte ""} {Action ""} {Espion ""}} {


    regexp -all {\:} $Texte "\\:"

    if {$Action==""} { set Action "Count" }
    if {$Espion==""} { set Espion "Espion" }
    if {$Espion=="Espion"} { set Espion 1 } else { set Espion 0 }
    
    set Cumul 0
    set LesBons {}
    foreach Nom [ListeDesPABs] {
	set Info [ExtraitInfo $Nom]
	if { ! [regexp -nocase $Texte $Info]} { continue }
	incr Cumul
	if {$Action=="Count"} { if {$Espion} { Espionne $Cumul } ;  continue } 
	lappend LesBons $Nom
	if {$Action=="List" } { if {$Espion} { Espionne $Nom   };  continue }
	lappend LesTextes "\n$Nom\n$Info"
	if {$Action=="Text" } { if {$Espion} { Espionne "\n$Nom\n$Info" } ; continue }
    }
    if {$Action=="Count"} { return $Cumul }
    if {$Action=="List" } { return $LesBons }
    if {$Action=="Text" } { return [join $LesTextes "\n"] }
    return

}

proc DaedalusFlatFileDeLaListe {ListeOuFichier {Sortie ""} {NomPossible ""}} {


    Wup "Sortie can be GetText (to return the text) or the name of the file to create"
    Wup "if Sortie is empty see below"

    if {$NomPossible==""} { set NomPossible "FlatFile" }
    if {[llength $ListeOuFichier]==1} {
	set Liste [LesLignesDuFichier $ListeOuFichier]
	if {$NomPossible=="FlatFile"} { set NomPossible [file tail $ListeOuFichier] }
    } else {
	set Liste $ListeOuFichier
    }
    if {$Sortie==""} { set Sortie "[TmpFile $NomPossible .].daedalus" }

    set Daedale {}
    foreach Ligne $Liste {
	scan $Ligne "%s" Access
	lappend Daedale "ID   $Access"
	lappend Daedale "DR   prot;$Access;."
	lappend Daedale "//"
    }
    if {$Sortie=="GetText"} { return [join $Daedale "\n"] }
    return [SauveLesLignes $Daedale dans $Sortie]

}

proc DaedalusFlatFileDuBlastP {NomOuFichier {Sortie ""} {SeuilExpect ""} {MaxListe ""}} {


    Wup "Sortie can be GetText (to return the text) or the name of the file to create"
    Wup "if Sortie is empty see below"

    set NomPossible [file tail $NomOuFichier]
    if {$Sortie==""} { set Sortie "[TmpFile $NomPossible .].daedalus" }

    if {$SeuilExpect=="" || $MaxListe==""} {
	scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpectVoulu
    }
    if {$SeuilExpect==""} { set SeuilExpect $SeuilExpectVoulu}
    if {$MaxListe==""}    { set MaxListe $MaxVoulus }
    if { ! [regexp "/" $NomOuFichier] && [EstUnPAB $NomOuFichier]} {
	set Nom $NomOuFichier
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
    } else {
	set Nom [file tail $NomOuFichier]
	set Fichier $NomOuFichier
    }
    if { ! [file exists $Fichier]} { return "" }

    global ScoreDansProfil ; set ScoreDansProfil 1
    set n [DecortiqueBlast $Fichier $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lScore lPN]
    set Daedale {}
    set NomQuery [file tail $Query]
    foreach BanqueId $lBanqueId Access $lAccess DE $lDE Score $lScore PN $lPN {
	if {[EstUnAccessDUneBanqueBlastPDeGscope $BanqueId]} {
	    set Access $BanqueId
	}
	if {[regexp {^\(.+\)$} $Access]} { regsub -all {[\(\)]} $Access "" Access }
	if {[regexp -nocase {VARSPLIC\:} $BanqueId]} { set Access [StringApres ":" dans $BanqueId] }
	lappend Daedale "ID   $Access"
        lappend Daedale "BL   Probe=$NomQuery ;Score=$Score ;Expect=$PN ;"
	if {[EstUnAccessPDB $BanqueId]} {
	    regsub -nocase {_[A-Z]*$} $BanqueId "" BanqueIdSansChaine
	    lappend Daedale "DR   pdb;$BanqueIdSansChaine;."
	    lappend Daedale "S0   $BanqueId pdb"
	} elseif {[regexp -nocase {VARSPLIC\:} $BanqueId]} {
	    regsub "VARSPLIC" $BanqueId "PROT" ProtId
	    if {[regexp {_[0-9]+} $ProtId]} {
		 regsub {_[0-9]+} $ProtId "" ProtId
		 regsub {_[0-9]+} $Access "" ProtAccess
	    }
	    if {[regexp {\-[0-9]+} $ProtId]} {
		 regsub {\-[0-9]+} $ProtId "" ProtId
		 regsub {\-[0-9]+} $Access "" ProtAccess
	    }
	    lappend Daedale "DR   prot;$ProtAccess;."
	    lappend Daedale "S0   $ProtId $ProtAccess"
	} elseif {[regexp -nocase {SW\:|SPT\:|SPTNEW\:} $BanqueId]} {
	    lappend Daedale "DR   prot;$Access;."
	    lappend Daedale "S0   $BanqueId $Access"
	} else {
	    lappend Daedale "DR   xxx;$Access;."
	    lappend Daedale "S0   $BanqueId $Access"
	}
	lappend Daedale "//"
    }
    if {$Sortie=="GetText"} { return [join $Daedale "\n"] }
    return [SauveLesLignes $Daedale dans $Sortie]

}

proc DaedalusGetz {Repertoire {Commande ""}} {


    if {$Commande==""} { set Commande "GetInfos" }
    
    NousAllonsAuBoulot $Repertoire
    set Sortie ""
    if {$Commande=="GetInfos"} {
	if {[catch {set Sortie [exec getz -f "AccNumber ID NCBI_TaxId GeneName Organism Description" -cs "\\\|" \[daedalus-id:*\]>protein]} Message]} {
	    FaireLire "error from getz \n$Message"
	}
    }
    if {$Commande=="GetExpects"} {
	if {[catch {set Sortie [exec getz -vf "Expect"  \[daedalus:*\]]} Message]} {
	    FaireLire "error from getz \n$Message"
	}
    }
    if {$Commande=="DaedalusProtView"} {
	if {[catch {set Sortie [exec getz -view DaedalusProtView  \[daedalus:*\]]} Message]} {
	    FaireLire "error from getz \n$Message"
	}
    }
    OnRevientDuBoulot
    return $Sortie

}

proc DaedalusHit {Access {Nom ""}} {

    global DaedalusHit DaedalusNomCourant
    if {$Nom==""} { set Nom $DaedalusNomCourant } else { set DaedalusNomCourant $Nom }
    if {[info exists DaedalusHit($Nom,$Access)]} { return [set DaedalusHit($Nom,$Access)] }
    if {[info exists DaedalusHit($Nom,"EstCharge")]} { return "" }
    if {[info exists DaedalusHit]} { unset DaedalusHit }
    set FichierDaedalus "[RepertoireDuGenome]/daedalushits/$Nom"
    set DaedalusHit($Nom,"EstCharge") 1
    if { ! [file exists $FichierDaedalus]} { return "" } 
    foreach Ligne [LesLignesDuFichier $FichierDaedalus] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	scan $Ligne "%s %s" BH AccessLu
	regsub " *$BH +$AccessLu" $Ligne "" Hit
	regsub {>>$} $Hit ">" Hit
	set LesACs [ValeurDeLaBalise AC Hit "NePasRogner"]
	set DaedalusHit($Nom,$AccessLu) $Hit
	set Hit [string trim $Hit]
	set DaedalusHit($Nom,[string toupper $AccessLu]) $Hit
	foreach AC [split $LesACs " "] {
	    set DaedalusHit($Nom,$AC) $Hit
	    set DaedalusHit($Nom,[string toupper $AC]) $Hit
	}
    }
    return [DaedalusHit $Access $Nom]

}

proc DaedalusHits {Source NomOuListeOuTexte {FichierDaedalusHits ""} {KeepDaedalus ""}} {


    Wup "Source can be DuRepDaedalus DuBlastP DeLaListe DuFlatText"
    Wup "if KeepDadalus it returns the list FichierDaedalus RepDaedalus" 

    set KeepDaedalus [regexp -nocase "KeepDaedalus" $KeepDaedalus]
    set Nom "NoName"
    if {$Source=="DuRepDaedalus"} {
	set RepDaedalus $NomOuListeOuTexte
    } else {
	if {$Source=="DuFlatText"} {
	    set FlatTexte $NomOuListeOuTexte
	}
	if {$Source=="DuBlastP"}   {
	    set Nom $NomOuListeOuTexte
	    set FlatTexte [DaedalusFlatFileDuBlastP $Nom "GetText"]
	}
	if {$Source=="DeLaListe"}  {
	    set FichierOuListe $NomOuListeOuTexte
	    set FlatTexte [DaedalusFlatFileDeLaListe $FichierOuListe "GetText"]
	}
	if {$FlatTexte==""} { return {} }
	set RepDaedalus [DaedalusSrsbuild $FlatTexte]
    }
    if {$FichierDaedalusHits==""} {
	set RepDaedalusHits "[RepertoireDuGenome]/daedalushits"
	if { ! [file exists $RepDaedalusHits]} { file mkdir $RepDaedalusHits }
	set FichierDaedalusHits "$RepDaedalusHits/$Nom"
    }
    
    set LesBeauxHits {}


#   set Methode   "DaedalusProtView"
    set Methode   "ExtractionDeProtein"
    if {$Methode=="ExtractionDeProtein"} {
	set ExpDaedalus [DaedalusGetz $RepDaedalus "GetExpects"]
	if {[info exists ExpectDe]} { unset ExpectDe }
	set LesPBDs {}
	set LesACCESS {}
	set LesPDBs {}
	set LesGscopes {}
	foreach Ligne [split $ExpDaedalus "\n"] {
	    set Expect 0.00099999
	    scan $Ligne "%s %s" Access Expect
	    set Access [StringApres "DAEDALUS:Flat_" dans $Access]
	    set ACCESS [string toupper $Access]
	    if {[regexp {_[0-9]+$} $Access]} {
		regsub {_[0-9]+$} $Access "" ProtAccess
		set Varsplic($ACCESS) $ProtAccess
	    }
	    if {[regexp {\-[0-9]+$} $Access]} {
		regsub {\-[0-9]+$} $Access "" ProtAccess
		set Varsplic($ACCESS) $ProtAccess
	    }
	    if {[EstUnAccessPDB $ACCESS]} {
		set EMBL [EMBLduPDB $ACCESS "ACFirst"]
		if {$EMBL!=""} {
		    lappend LesPDBs $EMBL
		}
	    }
	    if {[EstUnAccessDUneBanqueBlastPDeGscope $ACCESS]} {
		set EMBL [EMBLdeGscope $ACCESS "ACFirst"]
		if {$EMBL!=""} {
		    lappend LesGscopes $EMBL
		}
		if {[regexp {[\:_]} $ACCESS Car]} { set ACCESS [StringApres $Car dans $ACCESS] }
	    }
	    lappend LesACCESS $ACCESS
	    set ExpectDe($ACCESS) $Expect
	}

	set OutDaedalus [DaedalusGetz $RepDaedalus "GetInfos"]
	set FichierOutDaedalus "[RepertoireDuGenome]/daedalushits/$Nom.daedalus_output"
	Sauve $OutDaedalus dans $FichierOutDaedalus
	if { ! $KeepDaedalus } { file delete -force $RepDaedalus}
		
	set SansV 1
	set LesLignes [split $OutDaedalus "\n"]
	LConcat LesLignes $LesPDBs
	LConcat LesLignes $LesGscopes
	lappend LesLignes "AC   Thats all folks"
	set LesLignes [split [join $LesLignes "\n"] "\n"]
	set ClefPrecedente ""
	foreach Ligne $LesLignes {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    if { [regexp {^ } $Ligne]} { continue }
	    if {$SansV} {
		scan $Ligne "%s" Clef
		regsub "$Clef   " $Ligne "" Ligne
		if {$Clef=="AC" && $ClefPrecedente=="AC"} {
		    set LesNouveauxACs [LesMotsDeLaLigne $Ligne]
		    set LesACs [concat $LesACs $LesNouveauxACs]
		    continue
		}
		set ClefPrecedente $Clef
		if {$Clef=="AC"} {
		    if {[info exists PremierAC]} {
			if {[info exists ExpectDe($PremierAC)]} {
			    set Expect [set ExpectDe($PremierAC)]
			} else {
			    set Expect 0.000999
			}
			set PREMIERAC [string toupper $PremierAC]
			if {$LesOXs=={} && $LesOSs!={}} {
			    set PremTax [Tax [lindex $LesOSs 0]]
			    if { ! [regexp {^[0-9]+$} $PremTax]} { set PremTax -1 }
			    set LesOXs [list $PremTax]
			}
			if {$LesOSs=={} && $LesOXs!={}} {
			    set PremTax [lindex $LesOXs 0]
			    if { ! [regexp {^[0-9]+$} $PremTax]} {
				set PremOS "Inconnu inconnu"
			    } else {
				set PremOS [Tax $PremTax]
			    }
			    set LesOSs [list $PremOS]
			}
			set SesBeauxHits($PREMIERAC) "        "
			unset PremierAC
		    }
		    if {[regexp "Thats all folks" $Ligne]} { break }
		    set ID "No_ID"
		    set DE "No_DE" ; set LesDEs {}
		    set OS "No_OS" ; set LesOSs {}
		    set OX "No_OX" ; set LesOXs {}
		    set GN "No_GN" ; set LesGNs {}
		    set LesACs [LesMotsDeLaLigne $Ligne]
		    set PremierAC [lindex $LesACs 0]
		    continue 
		}
		if {$Clef=="ID"} {
		    scan $Ligne "%s" ID
		    continue
		}
		if {$Clef=="OX"} {
		    regsub -nocase "NCBI_TaxID=" $Ligne "" Ligne
		    regsub -all {[^0-9 ]} $Ligne "" Ligne
		    set LesOXs [LesMotsDeLaLigne $Ligne]
		    set OX [lindex $LesOXs 0]
		    continue
		}
		if {$Clef=="GN"} {
		    regsub {\.$} $Ligne "" Ligne
		    lappend LesGNs $Ligne
		    set GN [lindex $LesGNs 0]
		    continue
		}
		if {$Clef=="OS"} {
		    regsub {\.$} $Ligne "" Ligne
		    lappend LesOSs $Ligne
		    continue
		}
		if {$Clef=="DE"} {
		    lappend LesDEs $Ligne
		    continue
		}
	    } else {
		set LesChamps [split $Ligne "|"]
		set Description ""
		ScanLaListe $LesChamps Hit ID Acc NCBI_TaxId Organism Description
		set BonneDescription [join [lrange $LesChamps 5 end] " "]
		if {$Description!=$BonneDescription} { FaireLire "CS character in following line\n$Ligne" }
		lappend LesBeauxHits "$Acc $NCBI_TaxId $Description $Organism"
	    }
	}
	foreach ACCESS $LesACCESS {
	    if { ! [info exists SesBeauxHits($ACCESS)]} {
		if { ! [info exists Varsplic($ACCESS)]} { continue }
		if { ! [info exists SesBeauxHits([set Varsplic($ACCESS)])]} { continue }
		set Hit [set SesBeauxHits([set Varsplic($ACCESS)])]
		regsub -nocase {]+>} $Hit ""    Hit
		regsub -nocase {]+>}       $Hit ""          Hit
		regsub -nocase {]+>}       $Hit "" Hit
		set SesBeauxHits($ACCESS) $Hit
	    }
	    lappend LesBeauxHits [set SesBeauxHits($ACCESS)]
	}
    }
    if {$Methode=="DaedalusProtView"} {
	Wup "Attention ne traite pas les PDB pour le moment"
	set ViewDaedalus [DaedalusGetz $RepDaedalus "DaedalusProtView"]
	foreach Ligne [split $ViewDaedalus "//"] {
	    set LesChamps [split $Ligne "|"]
	    ScanLaListe $LesChamps ID OC OS TaxId DE Expect
	    regsub -all {[^0-9]} $TaxId " " TaxId
	    set OX [join [LesMotsDeLaLigne $TaxId] " "]
	    regsub -all "\n" $DE " " DE
	    lappend LesBeauxHits "      "
	}
    }
    if {$FichierDaedalusHits=="RetourneLesHits"} { return $LesBeauxHits }
    set FDH [SauveLesLignes $LesBeauxHits dans $FichierDaedalusHits]
    if {[file exists $FichierOutDaedalus]} { file delete -force $FichierOutDaedalus }
    if {$KeepDaedalus} { return [list $FDH $RepDaedalus] }
    return $FDH

}

proc DaedalusHitsDuBlastPPourTous {{EnProcessExterne ""} {CommenceIci ""}} {



    set Liste [ListeDesPABs]
    if {$CommenceIci!=""} {
	if {[set Trouve [lsearch -exact $Liste $CommenceIci]]>=0} {
	    set Liste [lrange $Liste [incr Trouve] end]
	}
    }

    if { $EnProcessExterne == "EnProcessExterne" } {
	set MaxDansMemeProcess 10
    } else {
	set MaxDansMemeProcess 999999
    }

    set RepDaedalusHits "[RepertoireDuGenome]/daedalushits"
    if { ! [file exists $RepDaedalusHits]} { file mkdir $RepDaedalusHits }
    set Keep 1
    if {[glob -nocomplain "$RepDaedalusHits/*"]!={}} {
	set Keep [OuiOuNon "Some files exist in $RepDaedalusHits/\nDo I keep all of them ?"]} {
    }
    set LesNouveaux {}
    set DejaFaitsDansMemeProcess 0
    foreach Nom $Liste {
	if {[Fantome $Nom]} { continue }
	set FichierDaedalusHits "$RepDaedalusHits/$Nom"
	if {$Keep && [file exists $FichierDaedalusHits]} { continue }
	if {[PasTouche $Nom]} { continue }
	Espionne "DaedalusHitsDuBlastPPourTous $Nom"
	AppendAuFichier "[RepertoireDuGenome]/daedalushits.log" "[pid] $FichierDaedalusHits [Date Nice]"
	set Dae [DaedalusHits "DuBlastP" $Nom $FichierDaedalusHits]
	FinPasTouche $Nom
	if {$Dae==""} { continue }
	lappend LesNouveaux $Dae
	if {[incr DejaFaitsDansMemeProcess] > $MaxDansMemeProcess} {
	    exec gscope yes DaedalusHitsDuBlastPPourTous "EnProcessExterne" $Nom &
	    exit
	}
    }
    return $LesNouveaux

}

proc DaedalusSrsbuild {FlatFileOuTexte {Nom ""} {RepTmp ""}} {


    if {[regexp "\n" $FlatFileOuTexte]} {
	set FlatTexte $FlatFileOuTexte
	if {$Nom==""} { set Nom "Flat" }
    } else {
	set FlatTexte [ContenuDuFichier $FlatFileOuTexte]
	if {$Nom==""} { set Nom [file tail $FlatFileOuTexte] }
    }
    if { ! [regexp ".daedalus$" $Nom]} { append Nom ".daedalus" }

    if {$RepTmp==""} {
	set RepTmp [TmpFile Daedalus]
    }
    if { ! [file exists $RepTmp]} { file mkdir $RepTmp }

    NousAllonsAuBoulot $RepTmp
    while {[file exists $Nom] && [ContenuDuFichier $Nom]!=$FlatTexte} {
	if {[OuiOuNon "[pwd]/$Nom already exists\nCan I replace it with the new Daedalus flatfile ?"]} { 
	    break
	}
    }
    Sauve $FlatTexte dans $Nom

    if {[catch {exec srsbuild -w daedalus } Message] } {
	global DejaVuSrsError
	if { ! [info exists DejaVuSrsError]} { 
	    FaireLire "error from srsbuild BUT I'll continue ... may be it isn't important ...\n$Message"
	    set DejaVuSrsError 1
	}
    }
    if {[catch {exec srsbuild -l daedalus } Message] } {
	global DejaVuSrsError
	if { ! [info exists DejaVuSrsError]} { 
	    FaireLire "error from srsbuild BUT I'll continue ... may be it isn't important ...\n$Message"
	    set DejaVuSrsError 1
	}
    }

    OnRevientDuBoulot

    return $RepTmp

}

proc DansAlignementPositionAbsolue {Pos Access {FichierMsf ""}} {

    return [DansAlignementPositionAutreDe "Relative" $Pos $Access $FichierMsf]

}

proc DansAlignementPositionAutreDe {RouA Pos Access {FichierMsf ""}} {

    Wup "On a generalise ici le PositionAutreDe en memorisant pour tous les access du Msf"
    global DAPAD
    if {$FichierMsf=="" && [info exists DAPAD(FichierMsf)]} {
	FaireLire "DansAlignementPositionAutreDe needs 4 params for its first call"
	return -1
    }
    if {$FichierMsf!="" &&   [info exists DAPAD(FichierMsf)] && $FichierMsf!=$DAPAD(FichierMsf)} { unset DAPAD }
    if {$FichierMsf!="" && ! [info exists DAPAD(FichierMsf)]} {
	set DAPAD(FichierMsf) $FichierMsf
	set n [DecortiqueUnMSF $FichierMsf LesNomsDesSequencesDansLOrdre Sequences]
	if {$n<=0} { return -1 }
	foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
	    set SeqGap [set Sequences($NomDeSequence)]
	    foreach {K V} [PositionAutreDe "GetArray" 0 $SeqGap] {
		set DAPAD($K,$NomDeSequence) $V
	    }
	}
    }
    if {[info exists DAPAD($RouA,$Pos,$Access)]} { return $DAPAD($RouA,$Pos,$Access) }
    return -1

}

proc DansAlignementPositionRelative {Pos Access {FichierMsf ""}} {

    return [DansAlignementPositionAutreDe "Absolue" $Pos $Access $FichierMsf]

}

proc DataBankDes90 {} {

    set i 0
    set refseq 0; set np 0; set xp 0; set swiss 0; set pdb 0; set emb 0; set gb 0; set dbj 0
    foreach GI [InterrogeListTau ListOf GI] {
	incr i
	set Access [InterrogeSortieNcbi $GI Access]
	set DB     [InterrogeSortieNcbi $GI DB]
	if {[regexp "ref" $DB]} {
	    incr refseq
	    if {[regexp "^NP_" $Access]} {incr np}
	    if {[regexp "^XP_" $Access]} {incr xp}
	} 
	if {[regexp "sp" $DB]}  {incr swiss} 
	if {[regexp "pdb" $DB]} {incr pdb}
	if {[regexp "emb" $DB]} {incr emb}
	if {[regexp "gb" $DB]}  {incr gb} 
	if {[regexp "dbj" $DB]} {incr dbj}
    }   
    Espionne "refseq $refseq"
    Espionne "np $np"
    Espionne "xp $xp"
    Espionne "swiss $swiss"
    Espionne "pdb $pdb"
    Espionne "emb $emb"
    Espionne "gb $gb"
    Espionne "dbj $dbj"

}

proc DataBench {} {

    global ConsRef
    
    source ConsPfam.txt
    set Ll [LesLignesDuFichier Summary_Pfam2.txt]
    foreach l $Ll {
	regsub -all { +} [string trim $l] " " l
	lassign [split $l " "] nm ns lg mxg mng id sd
	if {$ns < 4} {continue}
	if {! [info exists ConsRef($nm,sa)]} {continue}
	
	incr Nali
	incr LgTot $lg
	set nbsa 0
	foreach {sa d f} [set ConsRef($nm,sa)] {
	    incr nbsa [expr {$f - $d + 1}]
	}
	incr Nbsa $nbsa
	
	set nbnsa 0
	foreach {nsa d f} [set ConsRef($nm,nsa)] {
	    incr nbnsa [expr {$f - $d + 1}]
	}
	incr Nbnsa $nbnsa
	
	if {$id < 30.} {
	    set e "0-30"
	} elseif {$id < 40.} {
	    set e "30-40"
	} elseif {$id < 50.} {
	    set e "40-50"
	} elseif {$id < 60.} {
	    set e "50-60"
	} else {
	    set e "60-100"
	}
	incr pci($e)
	incr pci($e,lg)  $lg
	incr pci($e,sa)  $nbsa
	incr pci($e,nsa) $nbnsa
    }
    
    puts "GLOBAL :"
    puts "--------"
    puts "Nb alignements      : $Nali"
    puts "Long. Totale        : $LgTot"
    puts "Nombre res Identite : $Nbsa"
    puts "Nombre res Conserve : $Nbnsa"
    puts ""
    foreach e {"0-30" "30-40" "40-50" "50-60" "60-100"} {
	puts "% identite : $e"
	puts "-------------------"
	puts "Nb alignements      : [set pci($e)]"
	puts "Long. Totale        : [set pci($e,lg)]"
	puts "Nombre res Identite : [set pci($e,sa)]"
	puts "Nombre res Conserve : [set pci($e,nsa)]"
	puts ""
    }
    
    exit

}

proc DataDeLArbre {AId} {

    global Abr Rap

    set A [set Abr(Arbre,$AId)]

    # Analyse distances
    set Lf [$A leaves]
    set NbrF [llength $Lf]
    set max -888.
    foreach l $Lf {
	set sum 0.
	set mdepth 0
	set f $l
	while {$f > 0} {
	    if {[$A keyexists $f length]} {
		set t [$A get $f length]
		if {$t > -1.} {set sum [expr {$sum + $t}]}
	    }
	    set f [$A parent $f]
	}
	if {$sum > $max} {set max $sum}
	if {[$A depth $l] > $mdepth} {set mdepth [$A depth $l]}
    }

    set rmin 999.
    set rmax -999.
    foreach d [$A nodes] {
	if {! [$A isleaf $d]} {continue}
	set r [$A get $d r]
	if {$r < $rmin && $r > 0.} {set rmin $r}
	if {$r > $rmax && $r > 0.} {set rmax $r}
    }

    # length
    set lmin 999. ; set lmax -999. ; set nneg 0
    foreach d [$A nodes] {
	set l [$A get $d length]
	if {$l < $lmin} {set lmin $l}
	if {$l > $lmax} {set lmax $l}
	if {$l < 0.} {incr nneg}
    }
    set Rap(lmin) $lmin
    set Rap(lmax) $lmax
    set Rap(nneg) $nneg

    set Abr($AId,Dmax)    $max
    set Abr($AId,Depth)   $mdepth
    set Abr($AId,NLeaves) $NbrF
    set Abr($AId,rmin)    $rmin
    set Abr($AId,rmax)    $rmax
    set Abr($AId,deltaA)  [expr {(360./([$A size]+1))*acos(-1.)/180.}]

    if {0} {
	puts "Abr($AId,Dmax)    $max"
	puts "Abr($AId,Depth)   $mdepth"
	puts "Abr($AId,NLeaves) $NbrF"
	puts "Abr($AId,rmin)    $rmin"
	puts "Abr($AId,deltaA)  [expr {(360./([$A size]+1))*acos(-1.)/180.}]"
    }

    return

}

proc DataPourItol {rfile} {


    LesDefauts
    DefinitionPreferences

    DecortiqueUnXml2 "[RepertoireDuGenome]/macsimsdesrascal/${rfile}.xml"
    LitTfa "[RepertoireDuGenome]/tfasdescopains/$rfile"
    set Bons [CheckSeqs]
    CalculeArbreMarie $rfile $Bons
    EcritData $rfile

    return

}

proc DataSet {Action {Elem ""} {Val GetStoredValue}} {

    global DataSet DataSetElemIncr

    if {[string equal $Action "create"]} {
	
	if { ! [info exists DataSetElemIncr]} { set DataSetElemIncr 100 }
	set DataSetElemIncr [expr [incr DataSetElemIncr]%1000]
	set NewElem "[clock clicks -milliseconds]$DataSetElemIncr"
	
	set DataSetElem $NewElem
	set DataSet($NewElem,value)  $Elem
	set DataSet($NewElem,father) ""
	if {[string equal $Val "GetStoredValue"]} {
	    set DataSet($NewElem,links) {}
	} else {
	    set DataSet($NewElem,links) $Val
	}
	return $NewElem
    }

    if {[string equal $Action "hasBranches"]} {
	return [llength [DataSet links $Elem]]
    }

    if {[string equal $Action "isLeaf"]} {
	return [expr ! [DataSet hasBranches $Elem]]
    }

    if {[string equal $Action "spy"]} {
	set Texte "$Elem Value<[DataSet value $Elem]> Father<[DataSet father $Elem]> Links<[DataSet links $Elem]>"	
	if { ! [string equal $Val "Get"]} { puts $Texte }
	return $Texte
    }

    if {[string equal $Action "spyAll"]} {
	if {[string equal $Val "GetStoredValue"]} { set Val 0 }
	set Indent $Val
	set Indentation [string repeat " " $Indent]
	puts "$Indentation[DataSet spy $Elem Get]"
	incr Indent
	foreach Son [DataSet links $Elem] {
	    DataSet spyAll $Son $Indent
	}
	return ""
    }

    if {[string equal $Action "findValue"]} {
	set TheElements {}
	foreach {C V} [array get DataSet] {
	    if { ! [regsub {,value$} $C "" E]} { continue }
	    if { [DataSet value $E]==$Elem } { lappend TheElements $E }
	}
	return $TheElements
    }

    if {[string equal $Action "updateFather"]} {
	foreach Son [DataSet links $Elem] {
	    DataSet father $Son $Elem
	    DataSet updateFather $Son
	}
	return $Elem
    }

    if {[string equal $Action "clonedSonsOf"]} {
	set TheClonedSons {}
	foreach Son [DataSet links $Elem] {
	    lappend TheClonedSons [DataSet clone $Son]
	}
	return $TheClonedSons
    }

    if {[string equal $Action "clone"]} {
	set Value  [DataSet value $Elem]
	set Links  [DataSet links $Elem]

	set Clone [DataSet create $Value]

	DataSet links $Clone [DataSet clonedSonsOf $Elem]
	return $Clone
    }

    if {[string equal $Val "GetStoredValue"]} {
	return [set DataSet($Elem,$Action)]
    }

    if {[string equal $Action "value" ]} {
	set DataSet($Elem,value) $Val
	return $Val
    }

    if {[string equal $Action "links"]} {
	set DataSet($Elem,links) $Val
	return $Val
    }
    
    if {[string equal $Action "father"]} {
	set DataSet($Elem,$Action) $Val
	set DoIt 1
	foreach Son [DataSet links $Val] {
	    if {$Son==$Elem} { set DoIt 0 ; break }
	}
	if {$DoIt} { DataSet linksappend $Val $Elem }
	return $Val
    }

    if {[string equal $Action "linksappend"]} {
	lappend DataSet($Elem,links) $Val
	return [set DataSet($Elem,links)]
    }

    if {[string equal $Action "linkremove"]} {
	set TheOthers {}
	foreach Son [DataSet links $Elem] {
	    if {$Son == $Val} { continue }
	    lappend TheOthers $Son
	}
	set DataSet($Elem,links) $TheOthers
	return $TheOthers
    }

}

proc DatasXParmiLes555PCA {FichierCorrespondance} {

    foreach DatasTN [CreeListePourFichierAUneColonne "/genomics/link/Exonhit/DatasBPH"] {
	set Vu($DatasTN) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierCorrespondance] {
	set Old [lindex $Ligne 0]
	set PCA [lindex $Ligne 1]
	set Datas($PCA) $Old
    }
    set n 0; set b 0
    foreach Nom [ListeDesPABs] {
	if {[info exists Datas($Nom)]} {
	    set OldNom $Datas($Nom)
	    if {[regexp "^EX" $OldNom]} {
		incr b 
		if {[info exists Vu($OldNom)]} {
		    incr n 
		}
	    }
	}
    }
    Espionne $b
    return $n

}

proc Date {{Format ""} {TopChrono ""}} {


    if {$Format==""}  { set Format "%Y%m%d%H%M" }
    if {$Format=="_"} { set Format "YMD_HMS" }

    if {[string equal -nocase "YMD"     $Format]} { set Format "%Y%m%d"   }
    if {[string equal -nocase "YMD_HM"  $Format]} { set Format "%Y%m%d_%H%M"   }
    if {[string equal -nocase "YMD_HMS" $Format]} { set Format "%Y%m%d_%H%M%S" }

    if {[string equal -nocase $Format "Nice_"]} {
	set Format "%Y_%m_%d_%H_%M"
    }
    if {[string equal -nocase $Format "Nice_H"]} {
	set Format "%Y_%m_%d_%Hh%M"
    }
    if {[string equal -nocase $Format "Nice"]} {
	set Format "%Y/%m/%d %H:%M"
    }
    if {[string equal -nocase $Format "NiceSeconds"]} {
	set Format "%Y/%m/%d %H:%M:%S"
    }
    if {[string equal -nocase $Format "NiceYMD"]} {
	set Format "%Y/%m/%d"
    }

    if {[string equal -nocase $Format "Seconds"]} { set Format "%Y%m%d%H%M%S" }

    if {$TopChrono==""} { set TopChrono [clock scan now] }
    if {$Format=="TimeStamp"} { return $TopChrono }
    return [clock format $TopChrono -format $Format]

}

proc DateOfFile {File {Format ""} {WhichTime ""}} {

    if {[FileAbsent $File]} { return -1 }
    if {$WhichTime==""} { set WhichTime "mtime" }
    set TopChrono [file $WhichTime $File]
    return [Date $Format $TopChrono]    

}

proc Daud {} {

    foreach n $::LNOrdali {
	if {$n ne ""} {lappend Ln $n}
    }
    puts "lst [llength $Ln] [llength $::SDG(GroupeToutLeMonde)]"
    set ns 0
    foreach g [array names ::SDG] {
	if {$g ne "GroupeToutLeMonde"} {
	    incr ns [llength $::SDG($g)]
	}
    }
    puts "sum $ns [llength $::SDG(GroupeToutLeMonde)]"
    #exit

    return

}

proc DavidPattern {Motif} {


# Recherche un motif en générant un mismatch (adapté récepteurs nucléaires)
	set Fichier [open "/tmp/Conservation/David.txt" "w"] 
	set MotifReverse [NucToReverseAndComplementNuc $Motif]
	foreach Chromosome {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y} {
	Espionne "Scan du chromosome $Chromosome a la recherche du motif $Motif et $MotifReverse"
		set FichierChro "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200603/chr$Chromosome.fa"
		array unset SeqTFA
		array set SeqTFA [readFasta $FichierChro 0]
		set Acc [lindex $SeqTFA(index) 0]
		
		set RegExp {$Motif|$MotifReverse}
	
		set ListeDesPositions [regexp -indices -all -inline "$RegExp" $SeqTFA($Acc,sequence)]
		
		foreach PaireDeBornes $ListeDesPositions {
			set NewStart [expr [lindex $PaireDeBornes 0] + 1]
			set NewEnd [expr [lindex $PaireDeBornes 1] + 1]
		#	set Sequence [BoutADNDeUcscBoost $NewStart $NewEnd "+" "Homo_Sapiens" $chr]
			puts $Fichier "chr$Chromosome $NewStart $NewEnd"
		
		
		}
	
	}
	close $Fichier

}

proc Daylight {AId {n root}} {

    global sum Abr

    #    OrdonneLesFils $AId root
    #    LikeDrawtree $AId root
    #    exit
    puts ""
    #    DumpTree $AId [list NdLeft NdRight]
    puts ""

    set PAD [set Abr($AId,PAD)]
    set i 0
    set maxchange 1.0
    while {$i < 100 && $maxchange > 0.1} {
	if {$i >= 120} {set Step 1} {set Step 0}
	set sum 0.0
	set maxchange [Improvement $AId root $Step]
	incr i
	puts "\tIter $i $maxchange\n\n"
	if {0} {
	    $PAD delete all
	    RetraceToutCart $AId root
	    #	set xR [$t get root xcoord]
	    #	set yR [$t get root ycoord]
	    #	$PAD create oval [expr {$xR-8}] [expr {$yR-8}] [expr {$xR+8}] [expr {$yR+8}] -fill magenta -outline black
	    #	JAttends
	}
    }

    return

}

proc DbClustal {Nom FichierMSF {Source ""} {AvecQuoi ""} {KeepInTFAs ""} {KeepAnchors ""} {KeepLog ""}} {

    global RepertoireDuGenome
    global Commandes
    global RepertoireDeTravail
    global MyDbClustal

    JeMeSignale

    Wup "AvecQuoi tells what is source. It can be AvecSelection AvecFichierTFAs AvecTexteTFAs"
    Wup "Each Keep... can be a file name or 'Keep' so it will not be deleted"

    if { ! [regexp "^/" $FichierMSF]} { set FichierMSF "[pwd]/$FichierMSF" }

    if {$AvecQuoi==""} { set AvecQuoi "AvecSelection" }

    if {$KeepInTFAs==""} {
	set KeepInTFAs 0
	set FichInTFAs ""
    } else {
	if {[regexp "^Keep" $KeepInTFAs]} {
	    set FichInTFAs ""
	} else {
	    set FichInTFAs $KeepInTFAs
	}	    
	set KeepInTFAs 1
    }

    if {$KeepAnchors==""} {
	set KeepAnchors 0
	set FichAnchors ""
    } else {
	if {[regexp "^Keep" $KeepAnchors]} {
	    set FichAnchors ""
	} else {
	    set FichAnchors $KeepAnchors
	}	    
	set KeepAnchors 1
    }

    if {$KeepLog==""} {
	set KeepLog 0
	set FichLog ""
    } else {
	if {[regexp "^Keep" $KeepLog]} {
	    set FichLog ""
	} else {
	    set FichLog $KeepLog
	}	    
	set KeepLog 1
    }

    set CommandeDbClustal [set Commandes(dbclustal)]
    if {[info exists MyDbClustal] && [info exists Commandes($MyDbClustal)]} {
	set CommandeDbClustal [set Commandes($MyDbClustal)]
    }

    set Nom [file tail $Nom]
    if {$Nom==""} { set Nom "dbctmp" }

    set Racine [TmpFile $Nom]

    if {$FichInTFAs==""} {
	if {[EstUnPAB $Nom]} {
	    set FichInTFAs "$RepertoireDuGenome/tfasdescopains/$Nom"
	} else {
	    set FichInTFAs "$Racine.inp"
	}
    }

    set ButNo ""
    if {[regexp "penelope" $RepertoireDuGenome]} {
	regsub "^ABY" $Nom "PAB" PAB
	if {[regexp "^PAB" $PAB]} { set ButNo $PAB }
    }

    if {[regexp "AvecSelection" $AvecQuoi]} {
	set TexteTFA [ConcatLesTFAs $Source "ButNo:$ButNo"]
	Sauve $TexteTFA dans $FichInTFAs
    }
    if {[regexp "AvecFichierTFA" $AvecQuoi]} {
	set TexteTFA [ContenuDuFichier $Source]
	if {$Source!=$FichInTFAs} { Sauve $TexteTFA dans $FichInTFAs }
    }
    if {[regexp "AvecTexteTFA" $AvecQuoi]} {
	set TexteTFA $Source
	Sauve $TexteTFA dans $FichInTFAs
    }

    if {[regexp -all ">" $TexteTFA] < 2} {
	Warne "      ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! NoSequencesToAlign"
	return "NoSequencesToAlign"
    }

    NousAllonsAuBoulot
    set Anchors [FichierAnchorsPour $Nom]
    if { ! [file exists $Anchors]} {
	Warne "$Anchors\nfile not found, I run dbclustal without anchors"
	set Anchors "" 
    }
    set Anchors [AnchorsCoherents $FichInTFAs $Anchors $Nom] 
    set In  "$Racine.inp"
    set Out "$Racine.out"
    set Log "$Racine.log"
    
    File copy -force $FichInTFAs $In

    Warne "$CommandeDbClustal\n $In\n $Out\n $Log\n $Anchors"
    Warne "                     pour $Nom lance en interactif ... un peu de patience. Merci."
    if {[catch { eval exec "$CommandeDbClustal $In $Out $Log $Anchors"} Message]} {
	set Lolo "I got an error during DbClustal $Nom with following message\n$Message"
	Warne $Lolo
	AppendAuFichier $Log $Lolo
	set Status "YaLog"
    }
    if { ! [file exists "$Out.msf"]} {
	Warne [ContenuDuFichier $Log]
	File copy -force $Log "$Out.log"
	set Status "YaLog"
    } else {
	File rename -force $Out.msf $FichierMSF

	if { ! $KeepInTFAs } { File delete -force $In }
	if { ! $KeepAnchors} { File delete -force $Anchors }
	if { ! $KeepLog    } { File delete -force $Log }
	set Status "OK"
    }
    if {$KeepInTFAs  && $FichInTFAs!=""  && [file exists $In]}      { File copy -force $In $FichInTFAs }
    if {$KeepAnchors && $FichAnchors!="" && [file exists $Anchors]} { File copy -force $Anchors $FichAnchors }
    if {$KeepLog     && $FichLog!=""     && [file exists $Log]}     { File copy -force $Log $FichLog }
    
    Warne "                                                            ... j'ai fini. $Status"
    OnRevientDuBoulot
    return $Status

}

proc DbClustalEtMacsims {FichierTfa {FichierMsf ""} {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} {

    if { ! [regexp "^/" $FichierTfa]} { set FichierTfa "[pwd]/$FichierTfa" }
    regsub ".tfa$" $FichierTfa "" Racine
    if {$FichierMsf==""} { set FichierMsf "$Racine.msf" }
    if {$FichierXml==""} { set FichierXml "$Racine.xml" }
    if {$FichierRsf==""} { set FichierRsf "$Racine.rsf" }
    if {$FichierLog==""} { set FichierLog "$Racine.log" }
    if {[catch {set Status [DbClustal $Racine $FichierMsf $FichierTfa AvecFichierTFAs KeepInTFAs "" $FichierLog]} Message]} {
	return "Error. Something went wrong during DbClustal. I got  the message :\n$Message"
    }
    set LogDbClustal [ContenuDuFichier $FichierLog]
    if {$Status!="OK"} { return "Error. I could'nt get the alignment" } 
    if {[catch {set Status [Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog]} Message]} {
	return "Error. Something went wrong during Macsims. I got  the message :\n$Message"
    }
    Sauve "$LogDbClustal\n[ContenuDuFichier $FichierLog]" dans $FichierLog
    foreach Mot [split $Delete "_"] {
	set F "Fichier$Mot"
	if {[regexp {\.$} $F]} {
	    set FSansPoint [string trimright $F "."]
	    if { ! [info exists $FSansPoint]} { continue }
	    foreach FF [glob -nocomplain "[set $FSansPoint].*"] {
		file delete $FF
	    }
	} else {
	    if { ! [info exists $F]} { continue }
	    foreach FF [glob -nocomplain "[set $F]*"] {
		file delete $FF
	    }
	}
    }
    return $Status

}

proc DbClustalGrid {NomATraiter} {


    global PipeQuery
    global PipeCollection
    global DefautsPipe
    
    if {$PipeCollection} {
	set FichierMSF [file join [RepertoireDuGenome] msf $NomATraiter]
	if {[file exists $FichierMSF]} {return 1}

	set FicInTFAs [file join [RepertoireDuGenome] tfasdescopains $NomATraiter]
	set Anchors [file join [RepertoireDuGenome] ballast "${NomATraiter}.anchors"]
    } else {
	set FichierMSF "[file rootname $NomATraiter].msf"
	set FicInTFAs  "[file rootname $NomATraiter].copains"
	set Anchors    "[file rootname $NomATraiter].ballast.anchors"
    }

    if {! [file exists $FicInTFAs]} {return 0}
    if {[llength [LesLignesDuFichier $FicInTFAs]] < 2} {return 0}
    
    if {$PipeCollection} {
	file copy -force $FicInTFAs [file join [RepertoireDuGenome] msf "${NomATraiter}.inp"]
	set In  [file join [RepertoireDuGenome] msf "${NomATraiter}.inp"]
	set Out [file join [RepertoireDuGenome] msf "${NomATraiter}.out"]

	set Log [file join [RepertoireDuGenome] msf "${NomATraiter}.log"]
    } else {
	set In  $FicInTFAs
	set Out $FichierMSF
	set Log "[file rootname ${NomATraiter}].log"
    }
    
    set Commande "[ClustalwExe] "
    if {[set DefautsPipe(DbClustal,propagate)]} {
	append Commande "-propagate "
    }
    if {[set DefautsPipe(DbClustal,motifs)] && [file exists $Anchors]} {
	append Commande "-motifs=$Anchors "
    }
    append Commande "-output=[set DefautsPipe(DbClustal,output)] "
    append Commande "-outfile=${Out} -infile=$In"
    catch { eval exec $Commande} Message

    if {$PipeCollection} {
	if {! [file exists $Out]} {return 0}
	file rename -force $Out [file join [RepertoireDuGenome] msf $NomATraiter]
	file delete -force $In
	file delete -force $Log
	file delete -force *.dnd
    }
    
    if {[file exists $FichierMSF]} {
	AjouteAuLogPipe "dbclustal = ok"
    } else {
	AjouteAuLogPipe "dbclustal failed"
    }

    return 1

}

proc DbClustalPourTous {{NomATraiter ""} {Source ""}} {

    global RepertoireDuGenome
    global LesOrganismesModelesAAligner
    global OptionsBallastPourJulie SeuilExpectPourJulie
    global OptionsBallastPourJulieDemande
    global SortieRapportAliInOut
    global NotreOS
    global OnEffaceBallast
    global OkPourTfaDesCopains ;#rR 2015/01/19  mis en debut et lu aussi dans source 

    if {[string equal -nocase "All" $NomATraiter]} { set NomATraiter "" } ;#rR pour eviter le "" en ligne de commande

    set SourceOrigine $Source

    set ForceTFAsDesCopains 0
    if {[regexp -nocase "TFAsDesCopains" $Source]} {
	set OkPourTfaDesCopains 1
	set ForceTFAsDesCopains 1
    }

    if {[string equal -nocase $NomATraiter "All"]} { set NomATraiter "" }

    if {[OnTraite "Ribosome"]} {
	UseBanqueIdForDbClustal 1
	set SeuilExpectPourJulie 10.	
    }

    if {[regexp -nocase "Bandelettes" $Source]} {
	OnAligneTousLesElusDuBlastPPar "Bandelettes" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 10.
	if {[OnTraiteMS2PH]} { set SeuilExpectPourJulie 0.001 }
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }

    if {[regexp -nocase "Mounir" $Source]} {
	OnAligneTousLesElusDuBlastPPar "Mounir" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 0.001
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }

    if {[regexp -nocase "AuChoix" $Source]} {
	OnAligneTousLesElusDuBlastPPar "AuChoix" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 0.001
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }
    #rR 2014/07/01  rajout de OrthologsFromOrthoInspector
    #rR             ne marche que pour CilioCarta pour le moment ... voir ci-dessous Source



    #rR Et EvalCommand ... ne marche pas encore .............. à développer :
    #rR    En fait j'imagine une commande qui rejette chaque access du blast
    #rR Le tout est de savoir où le placer ... avant, pendant ou après LaSelectionUnique
    set EvalCommand 0
    if {[regexp "^eval_" $Source]} {
	set EvalCommand 1
	regsub "^eval_" $Source "" Commande
	regsub -all "_" $Commande " "
    }

    set OnEffaceBallast 0

    set AvecPasTouche 1
    set Liste {}
    if {$NomATraiter == "" } { 	
	set Liste [ListeDesPABs]
    } elseif {$NomATraiter=="ListeDesFusions"} {
	set Liste [ListeDesFusions]
    } elseif {[EstUnPAB $NomATraiter]} {
	set Liste [list $NomATraiter]
	set AvecPasTouche 0
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } elseif {[file exists $NomATraiter]} {
	set Liste [LesLignesDuFichier $NomATraiter]
    } elseif {$NomATraiter=="PourJulie"} {
	set Liste [LesLignesDuFichier "[RepertoireDuGenome]/fiches/liste_pour_julie"]
    }

    if { ! [info exists SortieRapportAliInOut]} {
	set SortieRapportAliInOut "$RepertoireDuGenome/aliinout"
	if { ! [file exists $SortieRapportAliInOut]} {
	    File mkdir $SortieRapportAliInOut
	}
    }

    if {[OnTraite "PubSpine"]} {
	set OptionsBallastPourJulieDemande 1
	set OptionsBallastPourJulie "-dbclustal 0.00000"
	set SeuilExpectPourJulie 10
    }
    if { ! [info exists OptionsBallastPourJulieDemande]  && [OuiOuNon "Do You want to change ballast options and expect ?" 0]} {
#	set OptionsBallastPourJulie [Entre "-dbclustal 0.000001"]
	set OptionsBallastPourJulie [Entre "-dbclustal 0.000000"]
	set SeuilExpectPourJulie [Entre 10.]
    }
    set OptionsBallastPourJulieDemande 1

    set RepertoireMSF "$RepertoireDuGenome/msf"
    if { ! [file exists $RepertoireMSF]} { File mkdir $RepertoireMSF }

    set RepertoireTfasDesCopains "$RepertoireDuGenome/tfasdescopains"
    if { ! [file exists $RepertoireTfasDesCopains]} { File mkdir $RepertoireTfasDesCopains }

    if {$NomATraiter==""} {
	set LesQuels "*"
    } else {
	set LesQuels [file tail $NomATraiter]
    }
    set Conserve 0
    if {[llength [glob -nocomplain "$RepertoireMSF/$LesQuels"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
    }

    set UseBirdFromTheBlast 0
    set Status "NothingHappend"
    foreach Nom $Liste {
	if {[Fantome $Nom]} { continue } 

	set FichierMSF "$RepertoireMSF/$Nom"
	if {$Conserve && [file exists $FichierMSF] } { continue }
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }

	Espionne "Je vais preparer $Nom pour DbClustal"

	set FichInTFAs "$RepertoireTfasDesCopains/$Nom"
	if { ! [info exists OkPourTfaDesCopains]} {
	    set OkPourTfaDesCopains [OuiOuNon "Can I use the existing files $FichInTFAs" 0]
	}
	if {$ForceTFAsDesCopains && ! [file exists $FichInTFAs]} {
	    Sauve "NoSequencesToAlign" dans $FichierMSF
	    Warne "$Nom fichier tfasdescopains is empty !!!!"
	    FinPasTouche $Nom
	    continue
	} elseif {$OkPourTfaDesCopains && [file exists $FichInTFAs]} {
	    set Source $FichInTFAs
	    set AvecQuoi "AvecFichierTFAs"
	} else {
	    set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
	    Espionne $FichierBlastP
	    BirdFromTheBlast $FichierBlastP  
	    
	    if { ! [file exists $FichierBlastP]} {
		Warne "$Nom pas de fichier blastp"
		FinPasTouche $Nom
		continue		
	    }
	    if {[OnAligneTousLesElusDuBlastPPar "Tous"]} {
		#rR il me semble qu'on ne passe jamais par là !!!!!!!!!!!!!!!
		set lBanqueId {}
		set lAccess   {}
		set lPN       {}
		
		DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query  lBanqueId lAccess lDE lProfil lPN
		set O ""
		set LaSelectionUnique {}
		foreach B $lBanqueId A $lAccess E $lPN {
		    #rR rajouté 2014/11/25 ************************************************************
		    if {[regexp "\|" $B]} {
			set A [lindex [split $B "|"] 1]
			set B [lindex [split $B "|"] 2]
		    }
		    lappend LaSelectionUnique "$B $A $E $O" 
		}
	    } elseif { [OnAligneTousLesElusDuBlastPPar "Bandelettes"] } {
		set LaSelectionUnique [LesElusDuBlastPParBandelettes $Nom "blastp"]
	    } elseif { [OnAligneTousLesElusDuBlastPPar "Mounir"]} {
		set LaSelectionUnique [LesElusDuBlastPParMounir $Nom "blastp"]
	    } elseif { [OnAligneTousLesElusDuBlastPPar "AuChoix"] } {
		set LaSelectionUnique [LesElusDuBlastPParAuChoix $Nom "blastp"]
	    } elseif {[regexp -nocase "Ortholog" $SourceOrigine]} {
		set LaSelectionUnique [OiOrthologsFromCilioCarta $Nom "IDs"]
	    } else {
		set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
	    }
	    
#	    BirdFromTheBlast "Reset"  

	    if {[llength $LaSelectionUnique] == 0} {
		Warne "$Nom pas de sequences a aligner"
		Sauve "NoSequencesToAlign" dans $FichierMSF
		FinPasTouche $Nom
		continue
	    }

	    set FichierQuery "$RepertoireDuGenome/prottfa/$Nom"
	    if { ! [file exists $FichierQuery]} {
		set FichierQuery "$RepertoireDuGenome/protembl/$Nom"
	    }
	    if { ! [file exists $FichierQuery]} {
		Warne "$Nom pas de fichier prottfa ni protembl"
		FinPasTouche $Nom
		continue		
	    }		
	    set Selection "$FichierQuery $Nom 0.0 $NotreOS\n"
	    append Selection [join $LaSelectionUnique "\n"]
	    set Source $Selection
	    set AvecQuoi "AvecSelection"
	}
	Espionne $Source
	set Status [DbClustal $Nom $FichierMSF $Source $AvecQuoi]

	if {[regexp "^NoSeq" $Status] || [regexp "PasDeSeq" $Status]} {
	    Sauve "NoSequencesToAlign" dans $FichierMSF
	}
	
	if {$Status=="OK"} {
	    if {$OnEffaceBallast} {
		set FichierBallast "$RepertoireDuGenome/ballast/$Nom"
		if {[file exists $FichierBallast]} { File delete -force $FichierBallast }
		foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] { 
		    File delete -force $FichierBallastExt
		}
	    }
	}
	FinPasTouche $Nom
    }
    return $Status

}

proc DbFetchForMacsim {{Quoi ""}} {

    regsub -all "aLaLiGnE" $Quoi "\n" Quoi
    set LesId {}
    foreach Ligne [split $Quoi "\n"] {
	if { ! [regexp "ID   (.+)" $Ligne Match Id]} { continue }
	regsub "\;.*" $Id "" Id
	lappend LesId $Id
    }
    set Uniprot  [DbFetchGET uniprot $LesId]
#    return $Uniprot
    set Interpro [DbFetchGET interpro $LesId]
    return $Interpro

}

proc DbFetchGET {db Lid {format ""} {style ""}} {

    # Taken from EBI :
    # https://www.ebi.ac.uk/Tools/dbfetch/

    set Lres [list]
    set paquets 200
    set ni [expr {int([llength $Lid]/$paquets)+1}]
    set url "http://www.ebi.ac.uk/Tools/dbfetch/dbfetch?db=LADB&id=LESIDS&style=raw"
    for {set i 0} {$i < $ni} {incr i} {
	set d [expr {$i*$paquets}]
	set f [expr {($i+1)*$paquets-1}]
	set req [string map [list LADB $db LESIDS "[join [lrange $Lid $d $f] ,]"] $url]
	if {$format ne ""} {
	    append req "&format=$format"
	}
	lappend Lres [HttpCopy $req]
    }
    set Tres [join $Lres \n]

    return $Tres

}

proc DbFetchSOAP {db Lid} {

    package require WS::Client

    # service DbFetch EBI
    set url "http://www.ebi.ac.uk/ws/services/WSDbfetch?wsdl"
    set ret [::WS::Client::GetAndParseWsdl $url]

    set Lid [list Q55C99 xp_570076 SYDC_HUMAN P13368]
    # DBs
    set rep [::WS::Client::DoCall WSDBFetchServerService getSupportedDBs [list ]]

    pdict $rep
    exit
    # DBs
    set rep [::WS::Client::DoCall WSDBFetchServerService  fetchBatch [list db $db ids [join $Lid ,] style default format default]]

    pdict $rep
    puts ""
    # Output is the TEXT of the entries
    set Lrep [split $rep \n]
    set Lres [list]
    switch $db {
	"uniprotkb" -
	"refseqp" {
	    set Lsep [lsearch -regexp -all $Lrep "^//"]
	    set d 0
	    set Lres [list]
	    foreach f $Lsep {
		lappend Lres [lrange $rep $d $f]
		set d [expr {$f+1}]
	    }
	}
    }
    puts "llength [llength $Lres]"
    foreach r $Lres {
	puts [join $r \n]
	puts ""
    }
    
    exit
    return

}

proc DbProfile {sql time} {

    global TTimeSql TSqlTime
    set TTimeSql($time) $sql
    set TSqlTime($sql) $time

}

proc DeAffyAString {FichierDepart RepertoireSortie Org SeuilString} {

    return [StringInteractome $FichierDepart $RepertoireSortie $Org $SeuilString "FromAffy"] 

}

proc DeChargeLeGPRFile {Fichier} {


    Wup "Decharge les infos chargees avec ChargeLeGPRFile"

    global InfoLeGPRFile

    array unset InfoLeGPRFile "$Fichier*"

    return ""

}

proc DeCsvStaf {Ligne Colonne} {

    global Staf
    if {[info exists Staf($Ligne,$Colonne)]} { return $Staf($Ligne,$Colonne) }
    if {[info exists Staf("EstCharge")]} { return "" }
    set Staf("EstCharge") 1

    set FichierStaf "/genomics/link/UCSCAlignements/STAF/nuctfa/between/BestHitBlastnhuman.csv"
    
    set Queue [file tail $FichierStaf]
    regsub -nocase {\.[^\.]+$} $Queue "" Queue
    Espionne $Queue
    if {[FileAbsent $FichierStaf]} {
	regsub "OK.csv$" $FichierStaf ".csv" FichierStafOri
	set Texte [ContenuDuFichier $FichierStafOri]
	
set In 0
foreach C [split $Texte ""] {
	    if {$C=="\""} { set In [expr ! $In]  continue }
	    if {$In && $C=="\n"} { set C "#/" }
	    lappend LesC $C
	}
	set BonTexte [join $LesC ""]
	Sauve $BonTexte dans $FichierStaf

	Espionne $BonTexte
    }

#rR LoadTxl
    LoadTxl $FichierStaf Staf -1 ""    
    set LesTetes $Staf(ListHeaderPlease,$Queue)
    set LesIndex $Staf(ListAllPlease,$Queue)
#rR loadTxl

    set Staf(ListOf,Header) $LesTetes
    set Staf(ListOf,Index)  $LesIndex
    Espionne $LesIndex

    return [Staf $Ligne $Colonne]
    

}

proc DeDoubleLesSequencesDuTFAs {FichierTFAs {Sortie ""} {Nice ""}} {

    #rR Le NiceHomosapiens c'est pour avoir une jolie definition pour la banque pour SM2PH 
    foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "@@@"] {
	if {[regexp {@@@} $Access]} { continue }
	if {[info exists DejaVu($Access)]} { continue }
	set DejaVu($Access) $Access
	set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
	if {[regexp -nocase "Nice" $Nice]} {
	    regsub -all {[\| ]+} $TFA " " TFA 
	}
	if {[regexp -nocase "NiceHomosapiens" $Nice]} {
	    set LeNice {}
	    foreach Ligne [split $TFA "\n"] {
		regsub -all {(>[^ ]+ )[0-9]+ } $Ligne "\\1Homo sapiens "  Ligne
		regsub -all { \[Homo.*} $Ligne "" Ligne
		lappend LeNice $Ligne
	    }
	    set TFA [join $LeNice "\n"]
	}
	
	lappend LaSortie $TFA
    }
    if {$Sortie=="GetList"} { return $LaSortie }
    if {$Sortie=="GetText"} { return [join $LaSortie "\n"] }
    return [SauveLesLignes $LaSortie dans $Sortie]

}

proc DeDoubleYEAHpa {} {

    set FiYEAHpa "[Fiches]/YEAHpa.txt"
    set i -1
    set LesUniques {}
    foreach Ligne [LesLignesDuFichier $FiYEAHpa] {
	incr i
	if {[info exists DejaVu($Ligne)]} { Espionne "$i $DejaVu($Ligne) $Ligne"; continue }
	set DejaVu($Ligne) $i
	lappend LesUniques $Ligne
    }
    SauveLesLignes $LesUniques dans "[Fiches]/YEAHpaUnique.txt"

}

proc DeFaitText {} {

    global NomTextSeq NomNomSeq LNOrdali LSOrdali

    set pos [$NomTextSeq index insert]
    lassign [split $pos .] y x 

    $NomNomSeq  configure -state normal
    $NomTextSeq configure -state normal

    catch {$NomNomSeq  edit undo}
    catch {$NomTextSeq edit undo}

    $NomNomSeq   configure -state disabled
    $NomTextSeq  configure -state disabled

    $NomTextSeq mark set current $pos
    $NomTextSeq mark set insert  $pos
#    $NomTextSeq see insert
#    $NomNomSeq  see "$y.0"

    set LSOrdali [split [$NomTextSeq get 1.0 end] \n]
    set LNOrdali [split [$NomNomSeq  get 1.0 end] \n]

    RepeintNomsEtSeqs

    return

}

proc DeFromUniprotData {{FicAc ""} {FicDe ""}} {

    foreach Ac [LesLignesDuFichier $FicAc] {
	set DE [QuestionDeScience GeneQuid "ret UniprotData $Ac DE-"]
	lappend LesDe $DE
    }
    return [SauveLesLignes $LesDe dans $FicDe]

}

proc DeProtEmblGBVersProtTfaEvi {} {

    set Rep "[RepertoireDuGenome]/prottfaGB"
    foreach Nom [ListeDesPABs] {
	set FichierProtEmbl  "[GscopeFile $Nom protembl]"
	set FichierProtEmbl2 "[GscopeFile $Nom protemblGB]"
	set FichierProtTfa2  "[GscopeFile $Nom prottfaGB]"
	set FichierProtTfa   "[GscopeFile $Nom prottfa]"
	set FichierNucTfa    "[GscopeFile $Nom nuctfa]"
	if {[FileExists $FichierProtTfa2]} { continue } 
	if {[FileAbsent $FichierProtEmbl2]} { continue }
	set LesLignesEMBL2 [LesLignesDuFichier $FichierProtEmbl2]
	DecortiqueLesLignesEMBL $LesLignesEMBL2 ID AC DE GN OS OC OX SequenceBrute
	if {[FileAbsent $FichierNucTfa]} { continue }
	set EnteteNucTfa [EnteteDuFichierTFA $FichierNucTfa]
	set EnteteProtTfa "$EnteteNucTfa prot from $ID"
	Espionne $EnteteProtTfa
	Espionne "$ID $OX $GN $DE $AC"
	Espionne ""
	set ProtTfa2 [SequenceFormatTFA [ContenuDuFichier $FichierProtEmbl2] "ForceHeaderTo=$EnteteProtTfa" "embl"]
	Sauve $ProtTfa2 dans $FichierProtTfa2
    }    

}

proc DeProtEmblMultipleVersProtTfaEvi {Nom} {

    set FichierProtEmbl "[GscopeFile $Nom protembl]"
    set FichierProtTfa2  "[GscopeFile $Nom protintermediare/prottfaBEST2]"
    Espionne "couocu3"
    set Meilleur [MeilleurEMBL $Nom]
    Espionne "coucou4"
    if {$Meilleur==""} { continue }
    regsub $Nom $FichierProtEmbl $Meilleur FichierProtEmblMeilleur
    file copy $FichierProtEmblMeilleur $FichierProtEmbl
    set LesLignesEMBL [LesLignesDuFichier $FichierProtEmbl]
    #Espionne $LesLignesEMBL
    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
    set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
    set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmbl] "ForceHeaderTo=$EnteteProtTfa" "embl"]
    Sauve $ProtTfa dans $FichierProtTfa2

}

proc DeProtEmblRecupereVersProtTfaEvi {} {

    set RepEntree "[RepertoireDuGenome]/protemblRecupere"
    foreach FichierProtEmblRecupere [glob -nocomplain "$RepEntree/EVI*"] {
	set Nom [file tail $FichierProtEmblRecupere]
	#Espionne $Nom
	set FichierProtTfa  "[GscopeFile $Nom prottfaRecupere]"
	set FichierNucTfa   "[GscopeFile $Nom nuctfa]"
	if {[FileExists $FichierProtTfa]} { continue } 
	set LesLignesEMBL [LesLignesDuFichier $FichierProtEmblRecupere]
	#Espionne $LesLignesEMBL

	if {[regexp {^LOCUS} [lindex $LesLignesEMBL 0]]} {
	    set TexteGB [ContenuDuFichier $FichierProtEmblRecupere]
	    set ProtTfa [SequenceFormatTFA $TexteGB "$Nom" "gbprot"]
	    #Espionne "$ProtTfa"
	    Sauve $ProtTfa dans $FichierProtTfa
	    continue
	}
	DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
	set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
	set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmblRecupere] "ForceHeaderTo=$EnteteProtTfa" "embl"]
	puts "$ProtTfa"
	Sauve $ProtTfa dans $FichierProtTfa
    }

}

proc DeProtEmblSingleVersProtTfaEvi {Nom} {

    set FichierProtEmblun "[GscopeFile $Nom protembl]_1"
    set FichierProtEmbl "[GscopeFile $Nom protembl]"
    set FichierProtTfa  "[GscopeFile $Nom protintermediare/prottfaBEST]"
    file copy -force $FichierProtEmblun $FichierProtEmbl
    set LesLignesEMBL [LesLignesDuFichier $FichierProtEmbl]
    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
    set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
    set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmbl] "ForceHeaderTo=$EnteteProtTfa" "embl"]
    Sauve $ProtTfa dans $FichierProtTfa

}

proc DeProtEmblVersProtTfaEvi {{Liste ""}} {

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }
    set RepProtInter "[RepertoireDuGenome]/protintermediare"
    if { ! [file exists $RepProtInter]} { File mkdir $RepProtInter }
    foreach Nom $Liste {
	Espionne "coucouc"
	set FichierProtEmbl "[GscopeFile $Nom protembl]"
	if {[FileExists $FichierProtEmbl]} { continue }
	set FichierProtTfa  "[GscopeFile $Nom protintermediare/prottfaBEST]"
	set FichierProtTfa2  "[GscopeFile $Nom protintermediare/prottfaBEST2]"
	if {[FileExists $FichierProtTfa] || [FileExists $FichierProtTfa2]} { continue }
	set FichierProtEmbldeux ""; set FichierProtEmblun ""
	set FichierProtEmblun "[GscopeFile $Nom protembl]_1"
	set FichierProtEmbldeux "[GscopeFile $Nom protembl]_2"
	if {![file exists $FichierProtEmblun]} {continue}
	if {[file exists $FichierProtEmbldeux]} {
	    set Repprottfabest2 "$RepProtInter/prottfaBEST2"
	    Espionne "coucouc2"
	    if { ! [file exists $Repprottfabest2]} { File mkdir $Repprottfabest2 }
	    DeProtEmblMultipleVersProtTfaEvi $Nom
	} else {
	    set Repprottfabest "$RepProtInter/prottfaBEST"
	    if { ! [file exists $Repprottfabest]} { File mkdir $Repprottfabest }
	    DeProtEmblSingleVersProtTfaEvi $Nom
	}
    }

}

proc DeProtVersNuc {{Nom ""}} {

    #attention ne prends en compte QUE la premiere ligne du GetzOut
    set InfoProt [ExtraitInfo $Nom "IdAccprot"]
    set AccProt [lindex [split $InfoProt " "] 1]
    Espionne "AccProt $AccProt"
    
    if {[regexp {^NP_} $AccProt]} {
	set CommandeNp "getz \"\\\[refseqp-acc:$AccProt\\\] > \\\[refseq-org:Mus musculus\\\]\" \-f acc"
	if {[catch {set GetzOutNp [eval exec $CommandeNp]}]} { set GetzOutNp "" }
	Espionne "GetzOutNp $GetzOutNp"
	if {$GetzOutNp!=""} {
	    set LigneNp [lindex [split $GetzOutNp "\n"] 0]
	    Espionne "LigneNp $LigneNp"
	    set AccArn [StringApres "ACCESSION" dans $LigneNp]
	    Espionne "AccArn $AccArn"
	}
	continue
    }
    
    set CommandeRs "getz \"\\\[protein-acc:$AccProt\\\] > \\\[refseq-org:Mus musculus\\\]\" \-f acc"
    if {[catch {set GetzOutRs [eval exec $CommandeRs]}]} { set GetzOutRs "" }
    Espionne "GetzOutRs $GetzOutRs"
    if {$GetzOutRs!=""} {
	set LigneRs [lindex [split $GetzOutRs "\n"] 0]
	Espionne "LigneRs $LigneRs"
	set AccArn [StringApres "ACCESSION" dans $LigneRs]
	Espionne "AccArn $AccArn"
	if {[regexp {^NC_} $AccArn]} {set AccArn ""}
    }  
    
    set CommandeGb "getz \"\\\[protein-acc:$AccProt\\\] > \\\[genbankfull-org:Mus musculus\\\]\" \-f acc"
    if {[catch {set GetzOutGb [eval exec $CommandeGb]}]} { set GetzOutGb "" }
    Espionne "GetzOutGb $GetzOutGb"
    if {$GetzOutGb!=""} {
	set LigneGb [lindex [split $GetzOutGb "\n"] 0]
	Espionne "LigneGb $LigneGb"
	set AccArn [StringApres "ACCESSION" dans $LigneGb]
	Espionne "AccArn $AccArn"
    }
    
    set RepertoireNuctfa "[RepertoireDuGenome]/nuctfa"
    set Commande "getz \"\\\[refseq-acc:$AccArn\\\]\" \-view FastaSeqs" 
    set GetzOut [eval exec $Commande]
    set LesLignesDeGetzOut [split $GetzOut "\n"]
    foreach Ligne $LesLignesDeGetzOut {
	if {[regexp ">" $Ligne ]} {
	    set Entete [StringSuivant " " dans $Ligne]
	    ScanLaListe [split $Ligne "|"] B A A2
	    regsub ">" $B "" B
	    regsub "genbankfull"   $B "gbf" B
	    regsub "refseqnew"     $B "rsn" B
	    regsub "refseqrelease" $B "rsr" B
	    regsub "refseq" $B "rs" B
	    set L ">$Nom $B:$A $Entete"
	    lappend LesL $L
	} else {
	    lappend LesL $Ligne
	}
    }
    SauveLesLignes $LesL dans "$RepertoireNuctfa/$Nom"

}

proc DeSeqAString {{RepertoireGscope ""} {Org ""} {SeuilString ""} {WithoutTextMiningOnly ""}} {


    if {$RepertoireGscope==""} { set RepertoireGscope [RepertoireDuGenome] }
    if {$Org==""}              { set Org [NotreOS] }
    if {$SeuilString==""}      { set SeuilString 700 }

    set total 0; set vide 0; set bon 0
    set RepertoireTfa         "$RepertoireGscope/prottfa"
    set RepertoireSortie      "$RepertoireGscope/STRING"
    set RepertoireSortieBlast "$RepertoireGscope/STRING/blastp"

    if {! [file exists $RepertoireTfa]} {return "need prottfa"}
    file mkdir $RepertoireSortie
    file mkdir $RepertoireSortieBlast

    #set FileVersion "$RepertoireSortie/STRINGVersion"
    #set Ligne "STRING_Version: 8.2"
    #Sauve $Ligne dans $FileVersion

    lappend LesLignesRecap "Box;Acc;ProteinID;PreferredName"
    CanalSqlString
    regsub "_" $Org " " Org
    set TaxId [TaxIdOrg $Org]   
    regsub " " $Org "_" Org
    
    set RepertoireSortie "$RepertoireGscope/String_${TaxId}_[Date]"
    file mkdir $RepertoireSortie
    set FichierIdentifiants "$RepertoireSortie/Identifiers"
    set FicQueryOnly        "$RepertoireSortie/QueryOnly.string"
    set FicSandwich         "$RepertoireSortie/Sandwich.string"
    set FicWithAny          "$RepertoireSortie/WithAny.string"
    set FicWithAnyParser    "$RepertoireSortie/WithAny.parser"

    #prevoir quand le fichier blast est deja fait
    #marche qu'avec un projet gscope => foreach PAB [ListeDesPABs] 
    foreach File [glob -nocomplain "$RepertoireTfa/*"] {
	set PAB [file tail $File]
	#if {[PasTouche $PAB]} { continue }
	incr total
	set FileTfa "$RepertoireTfa/$PAB"
	if {![file exists $FileTfa]} {continue}
	set FileOut "$RepertoireSortie/blastp/$PAB"
	set TFA [ContenuDuFichier $FileTfa]
	scan $TFA "%s %s" Bidon Acc
	set IdString [BlastPStringGeneral $FileTfa $FileOut $TaxId]

	set PN ""
	if {$IdString=="vide"} {
	    incr vide
	    set LigneRecap "$PAB;$Acc;vide"
	} else {
	    incr bon
	    lappend LesIdentifiants $IdString

	    set PNAll [PreferredName $IdString $Org "All"]
	    set PN    [PreferredName $IdString $Org]

	    set LigneRecap "$PAB;$Acc;$Result;$PNAll"
	}
	Espionne $LigneRecap
	lappend LesLignesRecap $LigneRecap
	#FinPasTouche $PAB
    }
    SauveLesLignes $LesLignesRecap dans "$RepertoireSortie/Summary.txt"

    set LesIdentifiants [ListeSansDoublon $LesIdentifiants]
    SauveLesLignes $LesIdentifiants dans $FichierIdentifiants    

    CreateWithAny $FichierIdentifiants $FicWithAny $SeuilString $Org $WithoutTextMiningOnly    
    ParseString   $FichierIdentifiants $FicWithAny $FicWithAnyParser 
    EnleveDoublonOfString $FicWithAny

    CreateSandwich $FicWithAny $FicSandwich

    CreateQueryOnly $FicWithAny $FicQueryOnly
    
    CanalSqlDisconnect
    return "total $total WithStringID $bon WithoutStringID $vide"

}

proc DeSeqAStringRetchip {RepertoireGscope Org SeuilString {WithoutTextMiningOnly ""}} {

    #adapte a retchip
    set total 0; set vide 0; set bon 0
    set RepertoireTfa "$RepertoireGscope/prottfa"
    set RepertoireSortie "$RepertoireGscope/STRING"

    if {! [file exists $RepertoireTfa]} {return "need prottfa"}
    if {! [file exists $RepertoireSortie]} {file mkdir $RepertoireSortie}

    #set FileVersion "$RepertoireSortie/STRINGVersion"
    #set Ligne "STRING_Version: 8.2"
    #Sauve $Ligne dans $FileVersion

    lappend LesLignesRecap "Box;Acc;ProteinID;PreferredName"
    CanalSqlString
    regsub "_" $Org " " Org
    set TaxId [TaxIdOrg $Org]   
    regsub " " $Org "_" Org
    
    set RepertoireSortie "$RepertoireGscope/String_${TaxId}_[Date]"
    file mkdir $RepertoireSortie
    set FichierIdentifiants "$RepertoireSortie/Identifiers"
    if {}
    set FicQueryOnly        "$RepertoireSortie/QueryOnly.string"
    set FicSandwich         "$RepertoireSortie/Sandwich.string"
    set FicWithAny          "$RepertoireSortie/WithAny.string"
    set FicWithAnyParser    "$RepertoireSortie/WithAny.parser"

    foreach PAB [ListeDesPABs] {
	#debut code specifique Retchip
	set Etat [ExtraitInfo $PAB RetChip]
	if {[regexp "no" $Etat]} {continue}
	incr total
	set FileTfa "$RepertoireTfa/$PAB"
	if {! [file exists $FileTfa]} {continue}
	set FileOut "$RepertoireSortie/blastp/$PAB"
	#set Acc [lindex [split [lindex [LesLignesDuFichier $FileTfa] 0] " "] 2]
	set Acc [lindex [split [lindex [LesLignesDuFichier $FileTfa] 0] " "] 1]
	#fin code specifique Retchip
	set IdString [BlastPStringGeneral $FileTfa $FileOut $TaxId]

	set PN ""
	if {$IdString=="vide"} {
	    incr vide
	    set LigneRecap "$PAB;$Acc;vide"
	} else {
	    incr bon
	    lappend LesIdentifiants $IdString

	    set PNAll [PreferredName $IdString $Org "All"]
	    set PN    [PreferredName $IdString $Org]

	    set LigneRecap "$PAB;$Acc;$Result;$PNAll"
	}
	Espionne $LigneRecap
	lappend LesLignesRecap $LigneRecap
    }
    SauveLesLignes $LesLignesRecap dans "$RepertoireSortie/Summary.txt"

    set LesIdentifiants [ListeSansDoublon $LesIdentifiants]
    SauveLesLignes $LesIdentifiants dans $FichierIdentifiants    

    CreateWithAny $FichierIdentifiants $FicWithAny $SeuilString $Org $WithoutTextMiningOnly    
    ParseString   $FichierIdentifiants $FicWithAny $FicWithAnyParser
    EnleveDoublonOfString $FicWithAny

    CreateSandwich $FicWithAny $FicSandwich

    CreateQueryOnly $FicWithAny $FicQueryOnly
    
    CanalSqlDisconnect
    return "total $total WithStringID $bon WithoutStringID $vide"

}

proc DeSeqAStringWeb {{RepertoireGscope ""} {Org ""} {SeuilString ""} {WithoutTextMiningOnly ""}} {


    if {$RepertoireGscope==""} { set RepertoireGscope [RepertoireDuGenome] }
    if {$Org==""}              { set Org [NotreOS] }
    if {$SeuilString==""}      { set SeuilString 700 }

    set total 0; set vide 0
    set RepertoireTfa         "$RepertoireGscope/prottfa"
    set RepertoireSortie      "$RepertoireGscope/STRING"
    set RepertoireSortieBlast "$RepertoireGscope/STRING/blastp"

    if {! [file exists $RepertoireTfa]} {return "need prottfa"}
    file mkdir $RepertoireSortie
    file mkdir $RepertoireSortieBlast

    set FileVersion "$RepertoireSortie/STRINGVersion"
    set Ligne "STRING_Version: 8.2"
    Sauve $Ligne dans $FileVersion

    CanalSqlString
    regsub "_" $Org " " Org
    set TaxId [TaxIdOrg $Org]   
    regsub " " $Org "_" Org
    lappend LesLignesRecap "BoxAcc;ProteinID;PreferredName"

    #prevoir quand le fichier blast est deja fait
    #marche qu'avec un projet gscope => foreach PAB [ListeDesPABs] 
    foreach File [glob -nocomplain "$RepertoireTfa/*"] {
	set PAB [file tail $File]
	#if {[PasTouche $PAB]} { continue }
	incr total
	set FileTfa "$RepertoireTfa/$PAB"
	Espionne "FileTfa $FileTfa"
	if {![file exists $FileTfa]} {continue}
	set FileOut "$RepertoireSortie/blastp/$PAB"
	set TFA [ContenuDuFichier $FileTfa]
	scan $TFA "%s %s" Bidon Acc
	set Result [BlastPStringGeneral $FileTfa $FileOut $TaxId]
	if {$Result=="vide"} {
	    incr vide
	    lappend LesLignesRecap "$PAB;$Acc;vide"
	} else {
	    set Ligne "$Result"
	    lappend LesLignes $Ligne
	    set PN [PreferedNameStringFromProteins $Result]
	    if {[regexp "^ENS" $PN]} {
		set GnFromEnsembl [GnDesFromEnsembl $PN protein $Org Gn]
		if {$GnFromEnsembl!=""} {
		    set PN "$PN/$GnFromEnsembl"
		} else {
		    set DesFromEnsembl [GnDesFromEnsembl $PN protein $Org Des]
		    if {$DesFromEnsembl!=""} {set PN "$PN/$DesFromEnsembl"}
		}
	    }
	    Espionne "$PAB;$Acc;$Result;$PN"
	    lappend LesLignesRecap "$PAB;$Acc;$Result;$PN"
	}
	#FinPasTouche $PAB
    }

    set LesLignes [ListeSansDoublon $LesLignes]
    set FileOut "$RepertoireSortie/$TaxId"
    SauveLesLignes $LesLignes dans "$FileOut"
    SauveLesLignes $LesLignesRecap dans "$RepertoireSortie/FichierRecapitulatif.txt"

    CreeFichierString $FileOut $SeuilString $Org $WithoutTextMiningOnly
    
    ParseString $FileOut ${FileOut}.string ${FileOut}.parser 
    
    StringNew ${FileOut}.string
    LitString Reset
    
    EnleveDoublonOfString ${FileOut}.string
    EnleveDoublonOfString ${FileOut}-QueInitial.string
    
    StringSandwich ${FileOut}.curstring

    CanalSqlDisconnect
    #Espionne ""
    #Espionne "total $total"
    #Espionne "SsIdString $vide"
    return "it's finished"

}

proc DeSgdToUniprot {} {

    set File "/genomics/link/Tparva/Copie_de_sgdid-laetitia.csv"
    foreach Sgd [LesLignesDuFichier $File] {
	if {$Sgd==""} {continue}
	Espionne "$Sgd"
	set Commande "getz \"\\\[uniprot-all:$Sgd\\\]\" \-f acc"
	set GetzOut [eval exec $Commande]
	Espionne "$GetzOut"
    }

}

proc Debroussaille {{LesRepRestants ""}} {

    if {$LesRepRestants=="PAY"} {
	set LesRepRestants [list  "/genomics/link/ProGS/signaux"  "/genomics/link/ProGS/atelier"  "/home/halter/oligos"  "/home/arnaud/Seqdir"  "/home/renouf/Donnees"  ]
    }
    if {$LesRepRestants=="ProGS"} {
	set LesRepRestants [list  "/genomics/link/ProGS/signaux"  "/genomics/link/ProGS/atelier"  ]
    }
    set LesRapportsPPCR {} 
    set LesRapportsPPCR_NA {} 
    set LesRapportsOligos {} 
    set LesRapportsOligos_NA {} 
    set LesFichiersPPCR {} 
    set LesFichiersPPCR_NA {} 
    set LesFichiersOligos {} 
    set LesFichiersOligos_NA {} 
    set LesDecomposPPCR {} 
    set LesDecomposPPCR_NA {} 
    set LesDecomposOligos {} 
    set LesDecomposOligos_NA {} 
    set LesRapportsSequence {} 
    set LesFichiersSignaux {}
    set LesCommandesDOligos {}

    if {$LesRepRestants==""} { set LesRepRestants [list "."] }
    while {1} {
	if {[llength $LesRepRestants]==0} { break }
	set RepCourant [lindex $LesRepRestants 0]
	set LesRepRestants [lreplace $LesRepRestants 0 0]
	foreach D [glob -nocomplain -type d "$RepCourant/*"] {
	    if {[regexp -nocase "Poubelle" $D]} { continue }
	    lappend LesRepRestants $D
	}
	foreach F [glob -nocomplain -type f "$RepCourant/*"] {
	    set YaD1 0
	    set Queue [file tail $F]
	    if { ! [regexp -nocase {\.(seq|nuctfa|tfa|pep|na|txt|list)$} $Queue]} { continue }
	    if { ! ([regexp {^(olimut_|oliseq_|oligos_|ppcr_)} $Queue]  || [regexp "obsolete" $Queue]  || [regexp "commande" $Queue]  || [regexp "existing" $Queue]  || [regexp "^signaux" $Queue] )} { continue }
	    if {[regexp {commande.*\.txt$} $F]} {
		set Fournis "Invitrogen"
		lappend LesCommandesDOligos "\n$F"
		set FournisseurDejaCite 0
		foreach Ligne [LesLignesDuFichier $F] {
		    if {[regexp -nocase {SYNTHESE.+IGBMC} $Ligne]} { set Fournis "IGBMC"}
		    if {[regexp "^D1" $Ligne]} {
			set YaD1 1
			if { ! $FournisseurDejaCite} {
			    set FournisseurDejaCite 1
			    lappend LesCommandesDOligos "  $Fournis"
			}
			set Description [StringSuivant "D1: " dans $Ligne]
			if {[regexp {^P[0-9]+} $Description P]} {
			    set Fournisseur($P) "$Fournis $F"
			}
			lappend LesCommandesDOligos "$Description"
		    }
		    if {! $YaD1 && $Fournis=="IGBMC" &&  [regexp {^ *([0-9]+) +P[0-9]+ +} $Ligne Match Numero]} {
			if { ! $FournisseurDejaCite} {
			    set FournisseurDejaCite 1
			    lappend LesCommandesDOligos "  $Fournis"
			}
			set Description [StringSuivant "$Numero " dans $Ligne]
			set Description [string trim $Description]
			if {[regexp {^P[0-9]+} $Description P]} {
			    set Fournisseur($P) "$Fournis $F"
			}
			lappend LesCommandesDOligos "$Description"
		    }
		}
	    }
	    if {[regexp {existing.*\.list$} $F]} {
		lappend LesCommandesDOligos "\n$F"
		foreach Ligne [LesLignesDuFichier $F] {
		    if {  ! [regexp {^([^ ]+) please use (P[0-9]+)} $Ligne Match SS P]} { continue }
		    lappend LesCommandesDOligos "$P $SS"
		}
	    }
	    set NASeq 0
	    set NbLignes 0
	    if {[catch {set LesLignes [LesLignesDuFichier $F]} Message]} {
		WarneReading "Problem reading $F. I got following error message :\n$Message\nI skipp this file.\n"
		continue
	    }
	    set LesLignes [CorrectionPourThrombin $LesLignes $F NouveauNomPourF]
	    foreach Ligne $LesLignes {
		set Decompo ""
		if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
		incr NbLignes
		if {$NbLignes>2  || [regexp "!!AA_SEQUENCE" $Ligne]  || [regexp "ID   " $Ligne] | [regexp ">>" $Ligne]  || [regexp -nocase "Reformat of" $Ligne]  || [regexp {[\:\|]} $Ligne]} {
			lappend LesRapportsSequence $F
			break
		}
		if {$NASeq} {
		    if {[regexp "^ProduitPCR" $Ligne]} {
			scan $Ligne "%s" Titre
			set Decompo [DecomposeLaLigne $Titre "" $F]
			if {[lindex $Decompo 0]!={}} {
			    lappend LesRapportsPPCR_NA "$F $Decompo"
			    lappend LesFichiersPPCR_NA $F
			    lappend LesDecomposPPCR_NA $Decompo
			    break
			}
		    } elseif {[regexp -nocase {_[a-z]+} $Ligne]} {
			scan $Ligne "%s" Titre
			set Decompo [DecomposeLaLigne $Titre "" $F]
			if {[lindex $Decompo 0]!={}} {
			    lappend LesRapportsOligos_NA "$F $Decompo"
			    lappend LesFichiersOligos_NA $F
			    lappend LesDecomposOligos_NA $Decompo
			    break
			}
		    }
		    lappend LesRapportsSequence "$F $Decompo"
		    break
		}
		if {[regexp "!!NA_SEQUENCE" $Ligne]} {
		    set NASeq 1
		    continue
		}
		if {[regexp "^>ProduitPCR" $Ligne]} {
		    set Decompo [DecomposeLesLignesDuFichier $F]
		    if {[lindex $Decompo 0]!={}} {
			lappend LesRapportsPPCR "$F $Decompo"
			lappend LesFichiersPPCR $F
			lappend LesDecomposPPCR $Decompo
			break
		    }
		    lappend LesRapportsSequence "$F $Decompo"
		    break
		}
 		regsub -all {[0-9]+} $Ligne "" SansChiffre
		regsub -all -- "-" $SansChiffre "" SansChiffre
		while {[regexp "__" $SansChiffre] } {regsub -all "__" $SansChiffre "_" SansChiffre}
		if {[regexp -nocase {>[^_]+_[a-z]+} $SansChiffre]} {
		    set Decompo [DecomposeLesLignesDuFichierOligos $F]
Espionne $Decompo
		    if {[lindex $Decompo 0]!={}} {
			lappend LesRapportsOligos "$F $Decompo"
			lappend LesFichiersOligos $F
			lappend LesDecomposOligos $Decompo
			continue
		    }
		    lappend LesRapportsSequence $F
		    continue
		}
		if {[regexp -nocase {>([a-z0-9]+)} $Ligne Match Signal] && [EstUnSignal $Signal]} {
		    lappend LesFichiersSignaux $F 
		    break
		}
	    }
	}
    }
    if {0} {
	AfficheVariable [join $LesRapportsOligos    "\n"] "AvecFetch" Oligos
	AfficheVariable [join $LesRapportsOligos_NA "\n"] "AvecFetch" Oligos_NA
	AfficheVariable [join $LesRapportsPPCR      "\n"] "AvecFetch" ProduitPCR
	AfficheVariable [join $LesRapportsPPCR_NA   "\n"] "AvecFetch" ProduitPCR_NA
	AfficheVariable [join $LesRapportsSequence  "\n"] "AvecFetch" Sequences
	set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux]
	if {$LesFichiersSignaux!={}} {
	    BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]"
	}
    }
    if {[info exists Fournisseur] && [OuiOuNon "Do I save Fournisseur of Oligos"]} {
	SauveLesLignes [array get Fournisseur] dans "[RepertoireDuGenome]/fiches/fournisseur"
    }
    return [list  $LesFichiersOligos  $LesFichiersOligos_NA  $LesFichiersPPCR  $LesFichiersPPCR_NA  $LesDecomposOligos  $LesDecomposOligos_NA  $LesDecomposPPCR  $LesDecomposPPCR_NA  $LesFichiersSignaux  $LesCommandesDOligos  ]

}

proc Debug {} {

    return [set ::Defauts(Debug)]

}

proc DebugAgents {args} {

    global debag debsq TAg

    # args depends on calling proc
    set proc [lindex [info level -1] 0]
    switch $proc {
	"StopAgents" {
	    lassign $args mean sdev sdif
	    puts "\nTest stop :"
	    puts "mean : [format %7.3f $mean]"
	    puts "sdev : [format %7.3f $sdev]"
	    puts "diff : [format %7.3f $sdif]"
	    puts "test = [format %7.3f $sdif] < [format %7.3f [expr {0.1*$mean}]]"
	}
	"RunAgents" {
	    ShowAlignmentAgent $args
	}
	"AlignAgent" {
	    lassign $args n1 a1 n2 a2 score seuil
	    puts "seq1: [format %12s $n1] $::TAg($a1,$n1,seq)"
	    if {$a2 ne "skip"} {
		puts "seq2: [format %12s $n2] $::TAg($a2,$n2,seq) [format %5.2f $score] [format %5.2f $seuil]"
	    } else {
		puts "SKIP !"
	    }
	    puts ""
	}
	"ScoreAgentsPair" {
	    lassign $args n1 ag1 n2 ag2 score seuil
	    # is it the good sequence ?
	    if {$n1 eq $debsq} {
		set sq $n1
		set ag $ag1
		set st $n2
		set at $ag2
	    } elseif {$n2 eq $debsq} {
		set sq $n2
		set ag $ag2
		set st $n1
		set at $ag1
	    } else {
		update idletasks

		return
	    }
	    
	    # is ti the good agent ?
	    if {$debag ne ""} {
		if {$ag ne $debag && $at ne $debag} {
		    update idletasks
		    return
		}
	    }
	    puts "$TAg($ag,$sq,seq) [format %6.2f $score]"
	    puts "$TAg($at,$st,seq) [format %6.2f $seuil]"
	    puts ""
	}
	"ShouldMoveAgents" {
	    puts "cols scores"
	    lassign $args sc1 sc2 sco Lcol1 Lcol2 Lcolo
	    puts [format "%8.2f %8.2f %8.2f" $sc1 $sc2 $sco]
	    foreach s1 $Lcol1 s2 $Lcol2 so $Lcolo {
		puts [format "%8s %8s %8s" $s1 $s2 $so]
	    }
	}
    }
    update idletasks

    return

}

proc DebugEcritConsensus {} {

    global ListeDesConsensusDuGroupe
    global LNDG
    global LongueurTotale

    set D 0
    while {$D < $LongueurTotale} {
	set F [expr {$D + 59}]
	foreach NomDeGroupe $LNDG {
	    set L [string range [set ListeDesConsensusDuGroupe($NomDeGroupe)] $D $F]
	    AuLog "[join $L ""] $NomDeGroupe"
	}
	incr D 60

	AuLog " "
    }

    return

}

proc DebugEcritPoints {} {

    global LesPointsDuGroupe
    global LNDG
    global LongueurTotale

    if {[lrange $LNDG end end] == "grise"} {
	set Ng [expr {[llength $LNDG] - 2}]
    } else {
	set Ng [expr {[llength $LNDG] - 1}]
    }

    set D 0
    while {$D < $LongueurTotale} {
	set F [expr {$D + 59}]
	foreach NomDeGroupe [lrange $LNDG 1 $Ng] {
	    set L [string range [set LesPointsDuGroupe($NomDeGroupe)] $D $F]
	    AuLog "[join $L ""] $NomDeGroupe"
	}
	incr D 60

	AuLog " "
    }

    return

}

proc DebugRib {l} {

    #dont_use_light

    set l [lindex $l 1]
    set i 0
    set col magenta
    set coltmp cyan
    foreach {n1 c1 v1 n2 c2 v2 n3 c3 v3} $l {
	if {1} {
	    puts [format "Pts 1 %8.3f %8.3f %8.3f" {*}$a3]
	    puts [format "Pts 2 %8.3f %8.3f %8.3f" {*}$b3]
	    puts [format "Pts 3 %8.3f %8.3f %8.3f" {*}$c3]
	    puts [format "Nrm 1 %8.3f %8.3f %8.3f" {*}$a1]
	    puts [format "Nrm 2 %8.3f %8.3f %8.3f" {*}$b1]
	    puts [format "Nrm 3 %8.3f %8.3f %8.3f" {*}$c1]
	    puts ""
	}

	if {! ($i%4)} {
	    puts "$i col $col coltmp $coltmp"
	    set col2 $col
	    set col $coltmp
	    set coltmp ${col2}
	    set vcol [RGBDeLaTkCol $col]
	    puts " -> col $col coltmp $coltmp"
	}
	    
	# triangle
	glColor3fv $vcol
	glBegin GL_LINES
	glVertex3fv $v1
	glVertex3fv $v2
	glEnd
	
	glColor3fv $vcol
	glBegin GL_LINES
	glVertex3fv $v2
	glVertex3fv $v3
	glEnd
	
	glColor3fv $vcol
	glBegin GL_LINES
	glVertex3fv $v1
	glVertex3fv $v3
	glEnd	
	
	if {0} {
	    # Normals
	    set n1 [RescaleNormale $n1 $v1]
	    set n2 [RescaleNormale $n2 $v2]
	    set n3 [RescaleNormale $n3 $v3]
	    glBegin GL_LINES
	    glVertex3fv $v1
	    glVertex3fv $n1
	    glEnd
	    
	    glBegin GL_LINES
	    glVertex3fv $n2
	    glVertex3fv $v2
	    glEnd
	    
	    glBegin GL_LINES
	    glVertex3fv $n3
	    glVertex3fv $v3
	    glEnd
	}
	incr i
	if {$i > 40} {break}
    }
    
    glEnd
    return

}

proc DebugSeqs {seqpdb sequnp seqpdb} {
 
    puts "[string range $seqpdb 0 60]"
    puts "[string range $sequnp 0 60]"
    puts "[string range $seqpdn 0 60]"
    puts ""
    if {[string length $seqpdb] > 60} {
	puts "[string range $seqpdb 60 119]"
	puts "[string range $sequnp 60 119]"
	puts "[string range $seqpdn 60 119]"
	puts ""
    }
    
    return

}

proc DebutActaXie {} {


	# Fournit le reel start des ACTA Xie (decalage de 2 pour les RRACTACA) en vue du dedoublonnage
	# Contrairement a Xie qui fournit les coordonnes - sous forme de +, ce script determine le REEL start de l'Acta
	Espionne "DebutActaXie: Start"
	set FichierDesCoordonneesIn [open "[Fiches]/Bidir/FichierDeCoordonnees-200603-AvecSequences.txt" "r"]
	set FichierDesCoordonneesOut [open "[Fiches]/Bidir/FichierDeCoordonnees-200603-AvecSequences-Et-ActaStart.txt" "w"]
	set I 0
	set J 0
	while { [gets $FichierDesCoordonneesIn LigneCoordonnees]  >=0 } {
		ScanLaListe $LigneCoordonnees Id Chromosome Start End Strand Sequence SbsPotentiel
		set Length [expr $End - $Start]
		if {$Length < 0} { Espionne "Warniiiiing !"}
		if {$Length == 7 } {
			incr I
			if { $Strand == "+"} {
				set ActaRealStart [expr $Start + 2]
			} else {
				set ActaRealStart [expr $End - 2]
			}
		} else {
			incr J
			if { $Strand == "+"} {
				set ActaRealStart $Start
			} else {
				set ActaRealStart $End
			}
		}		
		set LigneOut "$LigneCoordonnees $ActaRealStart"
		puts $FichierDesCoordonneesOut $LigneOut
	}
	close $FichierDesCoordonneesIn
	close $FichierDesCoordonneesOut
	set Total [expr $I + $J]
	Espionne "DebutActaXie: Done ($I RRACTACA / $Total )"

}

proc DebutDoc_WordML {{PoliceParDefaut Courier}} {

    global PoliceParDefautPourWordML
    set PoliceParDefautPourWordML $PoliceParDefaut


    set LeTexte {}
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""

    return [join $LeTexte "\n"]

}

proc DecalageAngulaireRosace {} {

    global DecalageAngulaireRosace
    if {[info exists DecalageAngulaireRosace]} { return $DecalageAngulaireRosace }
    if {[regexp "MsFinal" [RepertoireDuGenome]]} {
	set StartGenome    5916072
	set LongueurGenome 6988205
	set DecalageAngulaireRosace [expr (1.*$StartGenome/$LongueurGenome)*2*3.14159]
    } else {
	set DecalageAngulaireRosace 0
    }
    return $DecalageAngulaireRosace

}

proc Decede {Nom} {


    Wup "Cette notion n'existe plus"
    return 0

    if {0 && [regexp "TROU" $Nom]  && [NombreDeCopainsDansBlast $Nom] < 1} {
	return 1
    }
    
    set Valeur [ExtraitInfo $Nom "Decede"]
    if { $Valeur == "" } { return 0 }
    if {[regexp -nocase -- "oui" $Valeur]} {
	return 1
    } else {
	return 0
    }   

}

proc DechargeActiChip2Affy {} {

    
    Wup "Permet de questionner les Probe_Set commun entre ActiChip et Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeLesInfosAffymetrix"

    global TabActiChip_Affy

    array unset TabActiChip_Affy "*"

    return ""

}

proc DechargeActiChip2Ontario {{FichierOntario ""}} {

    
    Wup "Permet de questionner les sondes communes aux puces ActiChip et Ontario "
    Wup "Decharge les infos chargees avec ChargeActiChip2Ontario"

    global TabOntario

    array unset TabOntario "$FichierOntario*"

    return ""

}

proc DechargeActiChip2UMCU {} {


    Wup "Decharge les infos chargees avec ChargeActiChip2UMCU"

    global TabActiChip_UMCU

    array unset TabActiChip_UMCU "*"

    return ""

}

proc DechargeAffy_UCSC {FichierACharger} {

    
    Wup "Permet de questionner les Probe_Set Affymetrix U133A 2.0 dans UCSC"
    Wup "Decharge les infos chargees avec ChargeLesInfosAffymetrix"

    global TabAffy_UCSC

    array unset TabAffy_UCSC "$FichierACharger,*"

    return ""

}

proc DechargeBestHitInDatabase {FichierBlast} {

    
    Wup "Decharge les infos chargees avec ChargeBestHitInDatabase"
    Wup "Decharge les infos du blast associees"

    global InfoDatabase

    array    unset InfoDatabase "$FichierBlast*"
    AskBlast unsetfile           $FichierBlast
    
    return ""

}

proc DechargeCalcMeanID_Pos {Fichier} {

    
    Wup "Decharge les infos chargees avec ChargeCalcMeanID_Pos"

    global TabMeanIDInAln

    #Espionne "Decharge $Fichier"

    array unset TabMeanIDInAln "$Fichier*"
    
    return ""

}

proc DechargeDisEMBL {Fichier} {


    #Decharge les infos chargees avec ChargeDisEMBL
#Espionne "Decharge DisEMBL"
    global InfoDisEMBL

    if {[info exists InfoDisEMBL]} {
	    array unset InfoDisEMBL "*"     
    }
#il se passe rien ici
#foreach i [array names InfoDisEMBL $Fichier,*] {
#	Espionne "DisEMBL -> $i"
#	unset InfoDisEMBL($i)
#}
#    array unset InfoDisEMBL $Fichier,* 

    return ""

}

proc DechargeFoldIndex {Fichier} {


    #Decharge les infos chargees avec ChargeFoldIndex
	#Espionne "Decharge Foldindex"
    global InfoFoldIndex
    #foreach i [array names InfoFoldIndex $Fichier,*] {unset InfoFoldIndex($i)}
    if {[info exists InfoFoldIndex]} { 
	    array unset InfoFoldIndex "*"
    }
    #array unset InfoFoldIndex $Fichier,*
    
    return ""

}

proc DechargeGCCount {} {


    Wup "Permet d effacer les resultats du best GC"

    global TabDesGCs

    if {[info exists TabDesGCs]} {array unset TabDesGCs}

    return ""

}

proc DechargeGlobPlot {Fichier} {


    #Decharge les infos chargees avec ChargeGlobPlot

#Espionne "DechargeGlobPlot"
    global InfoGlobPlot
    
    #foreach i [array names InfoGlobPlot $Fichier,*] {unset InfoGlobPlot($i)}
    if {[info exists InfoFoldGlobPlot]} {
	    array unset InfoGlobPlot "*"
    }
    
    return ""

}

proc DechargeInfoDeOligo {FichierOligo} {

    
    Wup "Decharge les infos chargees avec ChargeInfoDeOligo"

    global InfoOligo

    array unset InfoOligo "$FichierOligo*"
    if {[info exists InfoOligo($FichierOligo,NotDone)]}   {unset InfoOligo($FichierOligo,NotDone)}
    if {[info exists InfoOligo($FichierOligo,NoOligo)]}   {unset InfoOligo($FichierOligo,NoOligo)}
    if {[info exists InfoOligo($FichierOligo,EstVide)]}   {unset InfoOligo($FichierOligo,EstVide)}
    if {[info exists InfoOligo($FichierOligo,EstCharge)]} {unset InfoOligo($FichierOligo,EstCharge)}

    return ""

}

proc DechargeInfoDePSORTII {FichierPsort} {

    
    Wup "Decharge les infos chargees avec ChargeInfoDePSORTII"

    global PsortInfo

    array unset PsortInfo "$FichierPsort*"

    return ""

}

proc DechargeInfoMAIA {Fichier} {


    Wup "Decharge les infos chargees avec ChargeInfoMAIA"

    global InfoMAIA

    array unset InfoMAIA "$Fichier*"

    return ""

}

proc DechargeInfoUMCU {Fichier} {


    Wup "Decharge les infos chargees avec ChargeInfoUMCU"

    global InfoUMCU

    array unset InfoUMCU "$Fichier*"

    return ""

}

proc DechargeLeGalFile_ActiChip {Fichier} {


    Wup "Decharge les infos chargees avec ChargeLeGalFile_ActiChip"

    global InfoGalFileActiChip

    array unset InfoGalFileActiChip "$Fichier*"

    return ""

}

proc DechargeLeInfosDesARPs {} {


    Wup "Decharge les infos chargees avec InterrogeLesInfosDesARPs"

    global LesInfosDesARPs
   
    array unset LesInfosDesARPs "*"

    return ""

}

proc DechargeLesAnnotAffymetrix {{Fichier ""}} {

    
    Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeLesAnnotAffymetrix"

    global TabAnnotAffy

    array unset TabAnnotAffy "$Fichier*"

    return ""

}

proc DechargeLesBornesMsmegmatis {} {

    
    Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeLesBornesMsmegmatis"

    global TabBMsmegatis

    array unset TabBMsmegatis "*"

    return ""

}

proc DechargeLesDomainesDesARPs {} {


    Wup "Decharge les infos chargees avec InterrogeLesDomainesDesARPs"

    global LesDomainesDesARPs

    array unset LesDomainesDesARPs "*"

    return ""

}

proc DechargeLesInfosAffymetrix {{Fichier ""}} {

    
    Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeLesInfosAffymetrix"

    global TabAffy

    array unset TabAffy "$Fichier*"

    return ""

}

proc DechargeLesInfosDuFichierLog {FichierLog} {

    
    Wup "Decharge les infos chargees avec ChargeInfoDeOligo"

    global InfoDuLogDeLOligo

    array unset InfoDuLogDeLOligo "$FichierLog*"
    return ""

}

proc DechargeLesInfosICDS {} {

    
    Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeLesInfosMsmegmatis"

    global TabICDS

    array unset TabICDS "*"

    return ""

}

proc DechargeLesResidusDesARPs {} {


    Wup "Decharge les infos chargees avec InterrogeLesResidusDesARPs"

    global LesResidusDesARPs

    array unset LesResidusDesARPs "*"

    return ""

}

proc DechargeOriginalAnnotAffymetrix {{Fichier ""}} {

    
    Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0"
    Wup "Decharge les infos chargees avec ChargeOriginalAnnotAffymetrix"

    global OriAnnotAffy

    array unset OriAnnotAffy "$Fichier*"

    return ""

}

proc DechargeRetrievePIDBetweenPosInMACS {Fichier} {

    
    Wup "Decharge les infos chargees avec ChargeRetrievePIDBetweenPosInMACS"

    global TabPIDInAln

    #Espionne "Decharge $Fichier"

    array unset TabPIDInAln "$Fichier*"
    
    return ""

}

proc DechargeRetrievePositionsInMACS {Fichier} {

    
    Wup "Decharge les infos chargees avec ChargeRetrievePositionsInMACS"

    global TabPosInAln

    #Espionne "Decharge $Fichier"

    array unset TabPosInAln "$Fichier*"
    
    return ""

}

proc DechargeRetrieveResidueInMACS {Fichier} {

    
    Wup "Decharge les infos chargees avec ChargeRetrieveResidueInMACS"

    global TabResInAln

    #Espionne "Decharge $Fichier"

    array unset TabResInAln "$Fichier*"
    
    return ""

}

proc DechargeRonn {Fichier} {


    #Decharge les infos chargees avec ChargeRonn

    global InfoRonn
    #Espionne "Decharge Ronn"
    #foreach i [array names InfoRonn $Fichier,*] {unset InfoRonn($i)}
     if {[info exists InfoRonn]} { 
    		array unset InfoRonn "*"
     }
    #array unset InfoRonn $Fichier,*
    
    return ""

}

proc DechargeTmCount {} {


    Wup "Permet d effacer les resultats du best Tm"

    global TabDesTms

    if {[info exists TabDesTms]} {array unset TabDesTms}

    return ""

}

proc DechargeX {Fichier} {

    
    #Decharge les infos chargees avec ChargeRonn

    global InfoDisEMBL
    global InfoRonn
    global InfoGlobPlot
    global InfoFoldIndex
    
    if {[info exists InfoRonn]} { 
	array unset InfoRonn "*"
    }
    if {[info exists InfoDisEMBL]} {
	array unset InfoDisEMBL "*"     
    }
    if {[info exists InfoFoldGlobPlot]} {
	array unset InfoGlobPlot "*"
    }
    if {[info exists InfoFoldIndex]} { 
	array unset InfoFoldIndex "*"
    }   
    return ""

}

proc Deci2Hexa {Deci} {

    return [format "%02X" $Deci]

}

proc DecisionsTrees_ID3 {LesNbDesClusters LesNbDesClustersDesBranches {NbTotDesBranches ""}} {

    set Entropy        [Entropy        $LesNbDesClusters                             ]
    set AverageEntropy [AverageEntropy $LesNbDesClustersDesBranches $NbTotDesBranches]

    Espionne "$Entropy $AverageEntropy"

    if {$AverageEntropy < $Entropy} {
	return 1
    }
    return 0

}

proc DecodeWord {w} {

    # decode word of type :
    # =?iso-8859-1?Q?bla bla bal ?=
    if {[string range $w 0 1] ne "=?"} {return $w}

    lassign [::mime::word_decode $w] charset type decString
    return [encoding convertfrom $charset $decString]

}

proc DecomposeLaLigne {Ligne {AvecOuSansErreur ""} {Fichier ""}} {

    if {[regexp "SeqOli|MutOli" $Ligne]} { return [list {} {} {}] }

    while {[regexp -nocase "BrocOli" $Ligne]} {
	regsub -nocase { BrocOli.*} $Ligne "" Ligne
	set Sujets [StringSuivant " for " dans $Ligne]
	if {$Sujets==""} { break }
	set LesSujets [split $Sujets " "]
	if {[regexp "5' oligo" $Ligne]} {
	    set LesAvants [split [StringApres " with signal " dans $Ligne]] ; set LesApres {}
	} else {
	    set LesAvants {} ; set LesApres [split [StringApres " with signal " dans $Ligne]] 
	}
	return [list $LesSujets $LesAvants $LesApres]
    }
    if {[regexp -nocase "RebuildedBrockenOli " $Ligne]} { regsub -nocase {RebuildedBrockenOli .*} $Ligne "" Ligne }

    Wup "returns a list of 3 lists LesSujets LesAvants LesApres" 
    Wup "If Ligne is like  S1 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2"
    Wup "it returns (S1 S2 S3) (Av1 Av2 Av3) (Ap1 Ap2)"
    Wup "(Av1 Av2 Av3) and (Ap1 Ap2) are common to S1 S2 and S3"

    if {$AvecOuSansErreur=="AvecErreur"} {
	set AvecErreur 1
    } else {
	set AvecErreur 0
    }

    set Titre [string trim $Ligne]
    if {[regexp {\+} $Titre]} {
	set LesSujets {}
	set OldAvants "bidon" 
	set OldApres  "bidon" 
	foreach Ti [split $Titre "+"] {
	    scan $Ti "%s" Ti
	    set DecTi [DecomposeLaLigne $Ti $AvecOuSansErreur $Fichier]
	    lappend LesSujets [lindex $DecTi 0] 
	    set LesAvants [lindex $DecTi 1]
	    set LesApres  [lindex $DecTi 2]
	    set Avants [join $LesAvants "_"]
	    set Apres  [join $LesApres  "_"]
	    if {$OldAvants!="bidon" && $OldAvants!=$Avants} { FaireLire "Av signals incoherent in $Ligne" }
	    if {$OldApres !="bidon" && $OldApres !=$Apres } { FaireLire "Ap signals incoherent in $Ligne" }
	}
	Wup "Une liste de sujets et les listes LesAvants et LesApres qui doivent etre identiques pour chaque sujet"
	return [list $LesSujets $LesAvants $LesApres]
    }
    set Titre [lindex [Canonise $Titre] 0]
    set LesMots [split $Titre "_"]
    if {[regexp -nocase "Produit" [lindex $LesMots 0]]} {
	set LesMots [lrange $LesMots 1 end]
    }
    set LesAvants {}
    set LesApres  {}
    set Avant 1
    foreach Mot $LesMots {
	if {[EstUnSignal $Mot]} {
	    if {$Avant} {
		lappend LesAvants $Mot
	    } else {
		lappend LesApres $Mot
	    }
	} else {
	    if {$Avant} {
		set Avant 0
		set Sujet $Mot
	    } else {
		if {$AvecErreur || [OuiOuNonMemo "I found more than 2 subjects.\nDo I stop all verifications ?"]} {
		    return [list {} {} {}]
		}
		if { ! $AvecErreur } {
		    FaireLire "$Ligne\n $Sujet and $Mot are 2 detected subjects\n May be one of them should be declared as signal.\n In that case : Please exit, create the signal and restart the program."
		}
		if {$AvecErreur || [regexp -nocase { [a-z0-9]+ } $Ligne] ||  [regexp {^[0-9]+$} $Mot] ||  [OuiOuNon "$Ligne\n $Sujet and $Mot are 2 detected subjects\nDo I skip $Ligne ?"]} {
		    return [list {} {} {}]
		} else {
		    append Sujet "-$Mot"
		}
	    }
	}
    }
    if {$Avant} {
	if { ! $AvecErreur} {
	    FaireLire "$Ligne\nno subject detected ...\n in $Fichier"
	    Espionne  "$Ligne\nno subject detected ...\n in $Fichier"
	}
	return [list {} $LesAvants $LesApres]
    }
    return [list $Sujet $LesAvants $LesApres]

}

proc DecomposeLesLignesDuFichier {Fichier} {


    set LesSujets {}
    set LesAvants {}
    set LesApres  {}
    set EstNA 0
    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
	if {[regexp "!!NA_SEQUENCE" $Ligne]} { set EstNA 1 ; continue }
	if {$EstNA} { regsub "" $Ligne ">" Ligne }
	if { ! [regexp ">" $Ligne]} { if {$EstNA} { break } else {continue } }
	set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
	set LesAv [lindex $DecTi 1]
	set LesAp [lindex $DecTi 2]
	foreach Sujet [lindex $DecTi 0] {
	    lappend LesSujets $Sujet
	    lappend LesAvants $LesAv
	    lappend LesApres  $LesAp
	}
	if {$EstNA} { break }
    }
    return [list $LesSujets $LesAvants $LesApres]

}

proc DecomposeLesLignesDuFichierOligos {Fichier} {


    return [DecomposeLesLignesDuFichier $Fichier]
    set LesSujets {}
    set LesAvants {}
    set LesApres  {}
    set LaSortie  {}
    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
	if { ! [regexp ">" $Ligne]} { continue }
	set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
	if {[lindex $DecTi 0]=={}} { return [list {} {} {}] }
	set LesSuj [lindex $DecTi 0]
	set LesAva [lindex $DecTi 1]
	set LesApr [lindex $DecTi 2]
	if {$LesAva=={} && $LesApr=={}} {
	    FaireLire "Decomposition of oligos \n$Fichier\nsomething is wrong at line \n$Ligne"
	}
	foreach Suj $LesSuj {
	    lappend LesSujets $Suj
	    lappend LesAvants $LesAva
	    lappend LesApres  $LesApr
	}
    }
    return [list $LesSujets $LesAvants $LesApres]

}

proc Decompte {{GetWhat ""}} {

    foreach Ligne [LesLignesDuFichier "[AnnotRep]/AllChrFinal.txt"]  {
	set T [lindex [LesMotsDeLaLigne $Ligne] 4]
	incr Decompte($T)
#	Espionne "$T $Decompte($T)"
    }
    foreach T [AnnotType ListOf T] {
	set Code [AnnotType $T Code]
	if { ! [info exists Decompte($T)]} { set Decompte($T) 0 }
	lappend LeDecompte $Decompte($T)
	lappend LeBeauDecompte [format "%s %7d %s" $T $Decompte($T) $Code]
    }
    Espionne $LeDecompte
    if {$GetWhat=="Nice"} { return $LeBeauDecompte }
    return $LeDecompte

}

proc DecompteDesProceduresTCL {Rep} {

    set LesProcedures {}
    foreach File [glob -nocomplain "$Rep/*.tcl"] {
	set F [open $File]
	while {[gets $F Ligne]>=0} {
	    if {![regexp -nocase {^proc } $Ligne]} {continue}
	    scan $Ligne "%s %s" Proc Procedure

	    if {![info exists Tab($Procedure)]} {
		lappend LesProcedures $Procedure
		set Tab($Procedure) 0
		set Tab($Procedure,LesFichiers) {}
	    }
	    incr  Tab($Procedure)
	    lappend Tab($Procedure,LesFichiers) [File tail $File]
	}
	close $F
    }
    set LesInfos {}
    foreach Procedure [lsort $LesProcedures] {
	lappend LesInfos "[set Tab($Procedure)]\t$Procedure\t[join [set Tab($Procedure,LesFichiers)] " "]"
    }

    EspionneL [lsort -decreasing $LesInfos]
    return

}

proc DecompteGeneral {} {

    set LaSortie {}
    foreach T [AnnotType ListOf T] {
	set Code [AnnotType $T Code]
	lappend LesHeader [format "%8s %s" $Code $T]
    }
    lappend LaSortie "      [join $LesHeader { }]"
    foreach Chr [ListOfChr] {
	set LaLigne {}
	foreach T [AnnotType ListOf T] {
	    if { ! [info exists Compte(All,$T)]} { set Compte(All,$T) 0 }
	    set N [llength [EleGen $Chr $T ListOf D]]
	    incr Compte(All,$T) $N
	    lappend LaLigne [format "%10d" $N]
	}
	lappend LaSortie "$Chr [join $LaLigne { }]"
    }
    set LaLigne {}
    foreach  T [AnnotType ListOf T] {
	lappend LaLigne [format "%10d" $Compte(All,$T)]
    }
    lappend LaSortie "All   [join $LaLigne { }]"
    set LaLigne {}
    foreach N [Decompte] {
	lappend LaLigne [format "%10d" $N]
    }
    lappend LaSortie "Final [join $LaLigne { }]"
    set Sortie [join $LaSortie "\n"]
    return [Sauve $Sortie dans "[AnnotRep]/DecompteGeneral.txt"]

}

proc DecortiCohen {} {

    global RepertoireDuGenome

    set LesLignes [LesLignesDuFichier "[HomeRipp]/cohen.html"]
    foreach Ligne $LesLignes {
	if { ! [regexp "" $Ligne]} { continue }
	regsub -all "" $Ligne "" Ligne
	regsub -all "" $Ligne "@" Ligne
	ScanLaListe [split $Ligne "@"] X0 P D X1 X2 X3 C H A
	regsub -all {<[^>]+>} $P "" PAB
	if { ! [regexp "^PAB" $PAB]} { continue }
	regsub -all {<[^>]+>} $C "" Commentaire

	regsub "PAB" $PAB [PreFixe] Nom
	Espionne $Nom

	set LeTexte "Nom:$PAB"
	lappend LeTexte "AuteurDate: $A $H"
	lappend LeTexte "DeCo: $D"
	lappend LeTexte "DeOO: [ExtraitInfo $Nom DE_Narcisse]"
	set i 0
	while {$Commentaire!=""} {
	    set Bout [string range $Commentaire 0 80]
	    set iBlanc [string last " " $Bout]
	    Espionne "$iBlanc $Commentaire" 
	    if {$iBlanc==-1} { set iBlanc 80 }
	    set BonBout [string range $Commentaire 0 $iBlanc]
	    set Commentaire [string range $Commentaire [incr iBlanc] end]
	    lappend LeTexte "Comment_[incr i]: $BonBout"
	}
	SauveLesLignes $LeTexte dans "$RepertoireDuGenome/cohen/$Nom"
    }

}

proc DecorticBlatBoost {Repertoire} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|DecorticBlatBoost : Start"
	set FichierDesBons [open "$Repertoire/Decortic.best"  "w"]
	set FichierDesCoord [open "$Repertoire/Decortic.coord" "w"]
	set FichierDesOrphelins [open "$Repertoire/Decortic.orphan" "w"]

    if {[file exists $FichierDesBons]}  {
	file delete $FichierDesBons
    }
    if {[file exists $FichierDesOrphelins] } {
	file delete $FichierDesOrphelins
    }
    if {[file exists $FichierDesCoord] } {
	file delete $FichierDesCoord
    }
    foreach Fichier [glob -directory "$Repertoire/" "*.blast"] {
#	set Fichier [GscopeFile $Nom "blastnhuman"]
#	set Fichier "[RepertoireDuGenome]/$NomDuRepertoire"
	if {[FileAbsent $Fichier]} { FaireLire "$Fichier doesn't exist" ; continue }
	set LesHits [DecortiqueBlat $Fichier]
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|DecorticBlatBoost : file is $Fichier"
	set LesBons {}
	foreach LeHit $LesHits {

		
	    ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand  DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct

		set LongQueryMoinsUn [expr $LongQuery - 1]
		set LongQueryMoinsDeux [expr $LongQuery - 2]
		set LongQueryMoinsTrois [expr $LongQuery - 3]
		set LongQueryMoinsQuatre [expr $LongQuery - 4]
		set LongQueryMoinsCinq [expr $LongQuery - 5]

	    set Ligne "$Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand $DebQuery $FinQuery $DebSbjct $FinSbjct $SeqQuery $Barres $SeqSbjct"
		set LigneCoord "$Query $BId $DebSbjct $FinSbjct $Strand"
		puts $FichierDesCoord $LigneCoord
		if { ![ regexp -nocase {COX} $BId ] && ![ regexp -nocase {QBL}  $BId ] && ![ regexp -nocase {NT} $BId ] } {
		lappend LesBons $Ligne
		}
	}	
	if {$LesBons=={}} {
	    puts $FichierDesOrphelins $Fichier } else {
	    set Bon [lindex $LesBons 0]
	#	AppendAuFichier $FichierDesBons $Bon
	    ScanLaListe $Bon Query LongQuery BId Access Length Score Expect Identities Strand  DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct
		puts $FichierDesBons "$Query $BId $DebSbjct $FinSbjct $Strand"	
	    }
	}
   	close $FichierDesBons 
	close $FichierDesCoord
	close $FichierDesOrphelins
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|DecorticBlatBoost : End"

}

proc DecorticM9 {Rep} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|NmToBlastP : Start"
	set FichierIn [open "GenesBidirClassesParTaille.pres" "r"]
	set FichierOut [open "$Rep/Decortic.blast" "w"]
	set Liste [glob -nocomplain -directory "$Rep/" "*.blast"]
	lsort -unique $Liste
	set BlastNumber 0
	foreach Element $Liste {
		gets $FichierIn LigneIn
		set FichierBlast [open "$Element" "r"]
		incr BlastNumber
		set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
		Espionne "$timestamp|NmToBlastP : Parsing blast $BlastNumber "
		gets $FichierBlast LigneComm
		gets $FichierBlast LigneComm
		gets $FichierBlast LigneComm
		gets $FichierBlast LigneEntete

		set HumanLength 0

		set HumanFlag "off"
		set ChimpFlag "off"
		set MouseFlag "off"
		set ZebrafishFlag "off"
		set DrosoFlag "off"
		set WormFlag "off"

		while {[gets $FichierBlast Ligne] >= 0 } {
			ScanLaListe $Ligne QueryID SubjectID IdentityPercentage AlignmentLength Mismatches GapOpenings StartQ EndQ StartT EndT eValue Score
			set Access $SubjectID			
			set Subject [lindex [split $SubjectID "_"] 1]
			if {$Subject == "HUMAN" && $HumanFlag == "off"} {
				set HumanFlag "on"
				set HumanLength $AlignmentLength
			}
			if {$Subject == "PANTR" && $ChimpFlag == "off"} {
				set ChimpID $Access
				set ChimpFlag "on"
				set ChimpRatio "$AlignmentLength/$HumanLength"
				set ChimpExpect $eValue
			}	
			if {$Subject == "MOUSE" && $MouseFlag == "off"} {
				set MouseID $Access
				set MouseFlag "on"
				set MouseRatio "$AlignmentLength/$HumanLength"
				set MouseExpect $eValue
			}
			if {$Subject == "DANRE" && $ZebrafishFlag == "off"} {
				set ZebrafishID $Access
				set ZebrafishFlag "on"
				set ZebrafishRatio "$AlignmentLength/$HumanLength"
				set ZebrafishExpect $eValue
			}

			if {$Subject == "DROME" && $DrosoFlag == "off"} {
				set DrosoID $Access
				set DrosoFlag "on"
				set DrosoRatio "$AlignmentLength/$HumanLength"
				set DrosoExpect $eValue
			}
			if {$Subject == "CAEEL" && $WormFlag == "off"} {
				set WormID $Access
				set WormFlag "on"
				set WormRatio "$AlignmentLength/$HumanLength"
				set WormExpect $eValue
			}
			
		}
		close $FichierBlast
		if { $ChimpFlag == "off" } {
			set ChimpID "Unconserved"
			set ChimpExpect "Max"
			set ChimpRatio "0/0"
		}
		if { $MouseFlag == "off" } {
			set MouseID "Unconserved"
			set MouseExpect "Max"
			set MouseRatio "0/0"
		}
		if { $ZebrafishFlag == "off" } {
			set ZebrafishID "Unconserved"
			set ZebrafishExpect "Max"
			set ZebrafishRatio "0/0"
		}
		if { $DrosoFlag == "off" } {
			set DrosoID "Unconserved"
			set DrosoExpect "Max"
			set DrosoRatio "0/0"
		}
		if { $WormFlag == "off" } {
			set WormID "Unconserved"
			set WormExpect "Max"
			set WormRatio "0/0"
		}
		puts $FichierOut "$QueryID $LigneIn $ChimpID $ChimpExpect $ChimpRatio $MouseID $MouseExpect $MouseRatio $ZebrafishID $ZebrafishExpect $ZebrafishRatio $DrosoID $DrosoExpect $DrosoRatio $WormID $WormExpect $WormRatio" 
	}
	close $FichierIn
	close $FichierOut
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|NmToBlastP : End"

}

proc DecortiqueAncresBallast {file alQue alObj alPos alBg1 alBg2 alLen alWgt} {


    upvar $alQue lQue
    upvar $alObj lObj
    upvar $alPos lPos
    upvar $alBg1 lBg1
    upvar $alBg2 lBg2
    upvar $alLen lLen
    upvar $alWgt lWgt

    set Ll [lrange [LesLignesDuFichier $file] 1 end]
    foreach l $Ll {
	regsub -all "\t" $l " " l
	update idletasks
	regsub -all { +} $l " " l
	set Le [split [string trim $l] " "]
	foreach {a Que Obj b Pos c Bg1 Bg2 d Len e Wgt} $Le {}
	lappend lQue $Que
	lappend lObj $Obj
	lappend lPos $Pos
	lappend lBg1 $Bg1
	lappend lBg2 $Bg2
	lappend lLen $Len
	lappend lWgt $Wgt
    }

    return

}

proc DecortiqueBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""} {aQuery ""} {alBanqueId ""} {alAccess ""} {alDE ""} {alProfil ""} {alPN ""} {alPartieSegAli ""}} {


    if {$CutPN==""} { set CutPN 0.001 }
    if {$MaxListe==""} { set MaxListe 99999 }

    if {$aQuery!="BlastHitCount" || $aQuery!="RetourneBlastTrie"} {
	if {$aQuery         !=""} { upvar $aQuery         Query        }
	if {$alBanqueId     !=""} { upvar $alBanqueId     lBanqueId    }
	if {$alAccess       !=""} { upvar $alAccess       lAccess      }
	if {$alDE           !=""} { upvar $alDE           lDE          }
	if {$alProfil       !=""} { upvar $alProfil       lProfil      }
	if {$alPN           !=""} { upvar $alPN           lPN          }
    }
    if {$alPartieSegAli != ""} {
	if { ! [string equal $alPartieSegAli "LongDefinition"]} {
	    upvar $alPartieSegAli lPartieSegAli
	}
	set OnVeutPartieSegAli 1
	set lPartieSegAli {}
    } else {
	set lPartieSegAli {}
	set OnVeutPartieSegAli 0
    }


    if {$aQuery=="RetourneBlastTrie"} { set RetourneBlastTrie 1 } else { set RetourneBlastTrie 0 }

    set AvecMemo 0
    if {$AvecMemo} {
	global MemoDecortique
	set LesVarMemo {FichierMemo NombreDeBons Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli}
	set FichierMemo $TexteOuListeOuFichier
	if {[info exists MemoDecortique(FichierMemo)] &&  ! $RetourneBlastTrie &&  $MemoDecortique(FichierMemo)==$FichierMemo} {
	    foreach V $LesVarMemo {
		set $V [set MemoDecortique($V)]
	    }
	    return $NombreDeBons
	}
	if {[info exists MemoDecortique]} { unset MemoDecortique }
    }

    set Fichier ""
    if {[regexp "\n" $TexteOuListeOuFichier]} {
	set ListeDesLignes [split $TexteOuListeOuFichier "\n"]
    } elseif {[regexp " " $TexteOuListeOuFichier]} {
	set ListeDesLignes $TexteOuListeOuFichier
    } elseif {[file exists $TexteOuListeOuFichier]} {
	set Fichier $TexteOuListeOuFichier
	set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
    } else {
	FaireLire "I don't know how to analyse the blast\n$TexteOuListeOuFichier\n It's not a text, not a list, not a file"
	return ""
    }

    if {$CutPN    == "" } { set CutPN    0.001 }
    if {$MaxListe == "" } { set MaxListe "SansLimiteDeNombre" }

    if {$CutPN    == "SansSeuilExpect"}    { set CutPN    9999.9 }
    set RenvoieLesHitsAvecSegAliUniquement 1
    if {$MaxListe == "SansLimiteDeNombreDuTout"} {
	set MaxListe "SansLimiteDeNombre"
	set RenvoieLesHitsAvecSegAliUniquement 0
    }
    if {$MaxListe == "SansLimiteDeNombre"} { set MaxListe 99999 }

    set lBanqueId {}
    set lAccess   {}
    set lDE       {}
    set lProfil   {}
    set lPN       {}
    set NombreDeBons 0

    set PremierMot ""
    scan [join [lrange $ListeDesLignes 0 3] " "]  "%s" PremierMot
    set RechercheDansFichier 1
    while {1} {
#	set PourBlastP  [string equal -nocase $PremierMot "BLASTP"]
#	set PourBallast [string equal -nocase $PremierMot "Ballast"]
#	set PourTBlastX [string equal -nocase $PremierMot "TBLASTX"]
#	set PourBlastN  [string equal -nocase $PremierMot "BLASTN"]
#	set PourTBlastN [string equal -nocase $PremierMot "TBLASTN"]
	set PourBlastP  [expr  ! [string compare $PremierMot "BLASTP"]]
	set PourBlastX  [expr  ! [string compare $PremierMot "BLASTX"]]
	set PourBallast [expr  ! [string compare $PremierMot "BALLAST"]]
	set PourTBlastX [expr  ! [string compare $PremierMot "TBLASTX"]]
	set PourBlastN  [expr  ! [string compare $PremierMot "BLASTN"]]
	set PourTBlastN [expr  ! [string compare $PremierMot "TBLASTN"]]
	if {[expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
	    break
	}
	if {$RechercheDansFichier &&  [regexp "BLASTP|BLASTX|Ballast|TBLASTX|BLASTN|TBLASTN"  [join [lrange $ListeDesLignes 0 9] " "] PremierMot]} {
	    set RechercheDansFichier 0
	    continue
	}
	if {[OuiOuNon "I can't choose between BLASTP BLASTX Ballast TBLASTX BLASTN TBLASTN\n  Could you help me ?" 0]} {
	    set PremierMot [Entre "BLASTP"]
	} else {
	    if {[OuiOuNon "Do I use BLASTP ?" 0]} { set PremierMot "BLASTP" ; continue }
	    if {[OuiOuNon "Do I skipp ?"]} { return "" }
	    if {[OuiOuNon "Do I stop  ?"]} { exit }
	}
    }
    set PositionPN 0
    set PositionScore 1
    if {$PourBallast} {
	set TexteSPSA     "Sequences producing "
	set iProfil       62
	set FinDE         65
    } elseif {$PourTBlastX} { 
	set PositionPN    0
	set PositionScore 1
	set TexteSPSA     "Sequences producing "
	set FinDE         66
	set iProfil       67
    } else {
	set TexteSPSA     "Sequences producing "
	set FinDE         65
	set iProfil       66
    }

    set IndexQuery [lsearch -regexp $ListeDesLignes "Query="]
    if { $IndexQuery == -1 } {
	FaireLire "Please select also the \"Query=\" line."
	return -1
    }
    if {$aQuery=="BlastHitCount"} {
	set Query    "NotImportantForBlastHitCount"
	set Nomquery "NotImportantForBlastHitCount"
    } else {
	set PossiblePAB [file tail $Fichier]
	set Query    [QueryDeLaLigne [lindex $ListeDesLignes $IndexQuery] "DoNotCreateIt" $PossiblePAB]
	set NomQuery [file tail $Query]
    }

    if {[lsearch -regexp [lrange $ListeDesLignes 0 30] "No hits found"] != -1} {
	return 0
    }

    set IndexSPSA [lsearch -regexp $ListeDesLignes $TexteSPSA]
    if { $IndexSPSA == -1 } { return 0}
    set Saut 2
    if {[regexp -nocase {[a-z]} [lindex $ListeDesLignes [expr $IndexSPSA + 1]]]} { incr Saut }
    set PartieRestante [lrange $ListeDesLignes [incr IndexSPSA $Saut] end]

    set PartieEntete [lrange $ListeDesLignes 0 $IndexSPSA]

    set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
    if { $IndexPremierChevron == -1 } {
	set PartieScores [lrange $PartieRestante 0 end]
	set PartieSegAli {}
    } else {
	set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
	set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
    }

    set OldPN -99999
    set zPN 0
    set IlFautTrier 0
    set EstUnPsiBlast 0
    set Profil 0
    foreach Ligne $PartieScores {
	if { $Ligne == "" } { continue }
	if { [regexp "Sequences not found previously" $Ligne] } {
	    set EstUnPsiBlast 1
	    continue
	}
	
	regsub "!" $Ligne " " Ligne

	if { $PourBallast && [regexp {\-{50}} $Ligne]} { continue }
	if { ! [regexp {[a-zA-Z]} $Ligne]} {
	    if {[regexp "^  Database\:" $Ligne]} { break }
	    if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
	    if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	}
	if {[regexp {\\\\End} $Ligne]} { break }
	if { [regexp {^[0-9a-zA-Z]} $Ligne]} {
	    set FromNCBI 0
	    set Access ""
	    #rR le NCBI ne met plus d'access mais il y a deux blancs ;)
	    if {[regexp {^([^ ]+)  } $Ligne Match B]} {
		regsub "  " $Ligne " $B " Ligne
		set FromNCBI 1
	    }
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {break}
	    set OriginalBanqueId $BanqueId
	    set OriginalAccess   $Access
	    set AccessLu $Access
	    if {[regexp -nocase {^UniRef} $BanqueId]} {
		set Access $BanqueId
	    }
	    if {[regexp -nocase {[\(\)\{\}\[\]]} $Access]} {
		set Access $BanqueId
	    }
	    if { ! [EstUnAccessPDB $Access] &&  ([EstUnAccessPDB $BanqueId] || ! [regexp -nocase {[a-z_]} $Access])} {
		set Access $BanqueId
	    }
	    set Profil [expr ![string compare [string range $Ligne $iProfil $iProfil] "*"]]
	    set ScorePN [string trim $Ligne]
	    regsub -all { +} $ScorePN " " ScorePN
	    set LesMots [split $ScorePN " "]
	    set sScore [lindex $LesMots end-$PositionScore]
	    scan $sScore "%d" Score
	    set sPN    [lindex $LesMots end-$PositionPN]
	    if {$sScore=="" || $sPN==""} { break }
	    if {$FromNCBI} {
		set DE [StringSuivant "$OriginalBanqueId $OriginalBanqueId " dans $Ligne]
	    } else {
		set DE $Ligne
		set DE [StringSuivant "$OriginalBanqueId" dans $DE]
		if { ! [EstUnAccessPDB $OriginalBanqueId] &&  ! [regexp -nocase {[^a-z0-9_]} $AccessLu] && ! [regexp -nocase {^UniRef} $BanqueId]} {
		    set DE [StringSuivant "$OriginalAccess" dans $DE]
		}
	    }
	    regsub "$sPN *$"       $DE "" DE
	    regsub "$sScore *$"    $DE "" DE
	    set DE [string trim $DE]
	} else {
	    if { ! $PourBallast} { 
		if {[regexp "^  Database\:" $Ligne]} { break }
		if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
		if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	    }
	    set Ligne [string trim $Ligne]
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {
		if {[regexp "^  Database\:" $Ligne]} { break }
		if {[OuiOuNon "$Ligne\n do I skip this line ?"]} { continue }
		if {[OuiOuNon "$Ligne\n do I stop processing ?"]} { break }
	    }
	    set DE [string range $Ligne [string length "$BanqueId $Access "] end]
	    set Profil $OldProfil
	    set PN     $OldPN
	}
	
	regsub {^[eE]} $sPN "1e" sPN
#	scan $sPN "%f" PN
	set PN $sPN
	if {[catch { expr $PN > $CutPN } ]} {
	    Warne "Oh le vilain $PN"
	    set PN 1E-200
	}
	if { ! $PourBallast && [expr $PN > $CutPN] } {
	    break
	}
	#rR attention depuis 2013/10/16 on ameliore toujours DE ecrasant l'autre (avant il fallait OnVeutPartieSegAli) 
	if { $PartieSegAli!={} } {
	    set PartieSegAliRestante [lrange $PartieSegAli 0 end]                   ;#rR il y avait 1 ???? corrige 2013/10/16
	    set IndexProchainChevron [lsearch -start 1 -regexp $PartieSegAliRestante {^>}]
	    if { [expr $IndexProchainChevron == -1] } {
		set IndexProchainChevron [lsearch -start 1 -regexp $PartieSegAliRestante {^ *Database:}]
		if { [expr $IndexProchainChevron != -1] } {
		    set IndexFinSegAliCourante [expr $IndexProchainChevron-1]
		} else {
		    set IndexFinSegAliCourante end
		}
	    } else {
		set IndexFinSegAliCourante [expr $IndexProchainChevron-1]
	    }

	    set SegAliCourante [lrange $PartieSegAli 0 $IndexFinSegAliCourante]
	    if {$OnVeutPartieSegAli} { lappend lPartieSegAli $SegAliCourante }   ;#rR a mis le test ici pour toujours ameliorer la DE
	    set LeMeilleurDE {}
	    foreach LigneDuSegAli $SegAliCourante {
		if { ! [regexp -nocase {[0-9a-z]} $LigneDuSegAli]} { break } 
		set  MeilleurDE [string trim $LigneDuSegAli]
		regsub {^>[^ ]+ } $MeilleurDE "" MeilleurDE
		if { ! $FromNCBI } { regsub {^[^ ]+ } $MeilleurDE "" MeilleurDE }
		lappend LeMeilleurDE [string trim $MeilleurDE]
	    }
	    set MeilleurDE [join $LeMeilleurDE " "]
	    if {[string length $MeilleurDE] > [string length $DE]} {
		set DE $MeilleurDE
	    }
	    set PartieSegAli [lrange $PartieSegAliRestante $IndexProchainChevron end]
	}

	if {$OldPN>$PN} { set IlFautTrier 1 }
	set OldPN     $PN
	set OldProfil $Profil

	lappend lBanqueId $BanqueId
	lappend lAccess   $Access
	lappend lDE       $DE
	lappend lProfil   $Profil
	lappend lPN       $PN
	lappend lScore    $Score

	set PNUnique "$PN [incr zPN]"
	lappend lPNUnique $PNUnique
	set LIduPN($PNUnique) $Ligne  
	set BIduPN($PNUnique) $BanqueId  
	set ACduPN($PNUnique) $Access
	set DEduPN($PNUnique) $DE
	set PRduPN($PNUnique) $Profil
	set PNduPN($PNUnique) $PN
	set SCduPN($PNUnique) $Score
	set SAduPN($PNUnique) [join $SegAliCourante "\n"]

	incr NombreDeBons

	if {$NombreDeBons >= $MaxListe } { break }
	if {$RenvoieLesHitsAvecSegAliUniquement &&  $OnVeutPartieSegAli && $IndexFinSegAliCourante == "end" } { break }
    }

    if {$IlFautTrier} {
	set lPNUnique [lsort -real -index 0 $lPNUnique]
	set lLignes   {}
	set lBanqueId {}
	set lAccess   {}
	set lDE       {}
	set lProfil   {}
	set lPN       {}
	set lScore    {}
	foreach PNUnique $lPNUnique {
	    lappend lLignes   $LIduPN($PNUnique)
	    lappend lBanqueId $BIduPN($PNUnique)
	    lappend lAccess   $ACduPN($PNUnique)
	    lappend lDE       $DEduPN($PNUnique)
	    lappend lProfil   $PRduPN($PNUnique)
	    lappend lPN       $PNduPN($PNUnique)
	    lappend lScore    $SCduPN($PNUnique)
	    lappend lSegAli   $SAduPN($PNUnique)
	}
    }

    global ScoreDansProfil
    if {[info exists ScoreDansProfil] && $ScoreDansProfil && [info exists lScore]} { set lProfil $lScore }
    
    if {$RetourneBlastTrie} {
	if {$IlFautTrier} {
	    set BlastTrie    [join $PartieEntete "\n"]
	    append BlastTrie "\n"
	    append BlastTrie [join $lLignes      "\n"]
	    append BlastTrie "\n\n"
#rR	    append BlastTrie [join $PartieSegAli "\n"]
	    append BlastTrie [join $lSegAli      "\n"]
	    append BlastTrie "\n"
	    return $BlastTrie
	} else {
	    return [join $ListeDesLignes "\n"]
	}
    }
    if {$AvecMemo} {
	foreach V $LesVarMemo {
	    set MemoDecortique($V) [set $V]
	}

    }
    return $NombreDeBons

}

proc DecortiqueBlastCommeBlat {TexteListeOuFichier} {

    return [DecortiqueBlat $TexteListeOuFichier]

}

proc DecortiqueBlastCommeBlat_AEffacer {TexteListeOuFichier} {

    return [DecortiqueBlat $TexteListeOuFichier]

}

proc DecortiqueBlastGrid {TexteOuListeOuFichier CutPN MaxListe aQuery {alBanqueId ""} {alAccess ""} {alDE ""} {alProfil ""} {alPN ""} {alPartieSegAli ""}} {

    
    global PourBallast
    
    if {$aQuery       !=""} { upvar $aQuery         Query        }
    if {$alBanqueId   !=""} { upvar $alBanqueId     lBanqueId    }
    if {$alAccess     !=""} { upvar $alAccess       lAccess      }
    if {$alDE         !=""} { upvar $alDE           lDE          }
    if {$alProfil     !=""} { upvar $alProfil       lProfil      }
    if {$alPN         !=""} { upvar $alPN           lPN          }
    
    if {$alPartieSegAli != ""} {
	if { ! [string equal $alPartieSegAli "LongDefinition"]} {
	    upvar $alPartieSegAli lPartieSegAli
	}
	set OnVeutPartieSegAli 1
	set lPartieSegAli {}
    } else {
	set lPartieSegAli {}
	set OnVeutPartieSegAli 0
    }
    
    set RetourneBlastTrie 0
    
    set Fichier ""
    if {[regexp "\n" $TexteOuListeOuFichier]} {
	set ListeDesLignes [split $TexteOuListeOuFichier "\n"]
    } elseif {[regexp " " $TexteOuListeOuFichier]} {
	set ListeDesLignes $TexteOuListeOuFichier
    } elseif {[file exists $TexteOuListeOuFichier]} {
	set Fichier $TexteOuListeOuFichier
	set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
    } else {
	return 0
    }
    
    if {$CutPN    == "" } { set CutPN    0.001 }
    if {$MaxListe == "" } { set MaxListe "SansLimiteDeNombre" }
    
    if {$CutPN    == "SansSeuilExpect"}    { set CutPN 9999.9 }
    set RenvoieLesHitsAvecSegAliUniquement 1
    if {$MaxListe == "SansLimiteDeNombreDuTout"} {
	set MaxListe "SansLimiteDeNombre"
	set RenvoieLesHitsAvecSegAliUniquement 0
    }
    if {$MaxListe == "SansLimiteDeNombre"} { set MaxListe 9999 }

    set lBanqueId {}
    set lAccess   {}
    set lDE       {}
    set lProfil   {}
    set lPN       {}
    set NombreDeBons 0

    set PremierMot ""
    scan [join [lrange $ListeDesLignes 0 3] " "]  "%s" PremierMot
    set RechercheDansFichier 1
    while {1} {
	set PourBlastP  [expr ![string compare $PremierMot "BLASTP"]]
	set PourBlastX  [expr ![string compare $PremierMot "BLASTX"]]
	set PourBallast [expr ![string compare $PremierMot "BALLAST"]]
	set PourTBlastX [expr ![string compare $PremierMot "TBLASTX"]]
	set PourBlastN  [expr ![string compare $PremierMot "BLASTN"]]
	set PourTBlastN [expr ![string compare $PremierMot "TBLASTN"]]

	if {[expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
	    break
	}
	if {$RechercheDansFichier &&  [regexp "BLASTP|BLASTX|Ballast|TBLASTX|BLASTN|TBLASTN"  [join [lrange $ListeDesLignes 0 9] " "] PremierMot]} {
	    set RechercheDansFichier 0
	    continue
	}
	return ""
    }

    if {$PourBallast} {
	set TexteSPSA "Sequences producing High-scoring Segment Pairs"
	set iProfil   62
	set FinDE     65
    } elseif {$PourTBlastX} { 
	set TexteSPSA "Sequences producing High-scoring Segment Pairs"
	set FinDE     59
	set iProfil   61
    } else {
	set TexteSPSA "Sequences producing significant alignments"
	set FinDE     65
	set iProfil   66
    }

    set IndexQuery [lsearch -regexp $ListeDesLignes "Query="]
    if { $IndexQuery == -1 } {return ""}

    if {$aQuery=="BlastHitCount"} {
	set Query    "NotImportantForBlastHitCount"
	set Nomquery "NotImportantForBlastHitCount"
    } else {
	set PossiblePAB [file tail $Fichier]
    }

    if {[lsearch -regexp [lrange $ListeDesLignes 0 30] "No hits found"] != -1} {
	return 0
    }

    set IndexSPSA [lsearch -regexp $ListeDesLignes $TexteSPSA]
    if { $IndexSPSA == -1 } { return 0}
    set Gapped [string equal [string index [lindex $ListeDesLignes $IndexSPSA] end] "N"]
    set Saut 2
    if {[regexp -nocase {[a-z]} [lindex $ListeDesLignes [expr $IndexSPSA + 1]]]} { incr Saut }
    set PartieRestante [lrange $ListeDesLignes [incr IndexSPSA $Saut] end]

    set PartieEntete [lrange $ListeDesLignes 0 $IndexSPSA]

    set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
    if { $IndexPremierChevron == -1 } {
	set PartieScores [lrange $PartieRestante 0 end]
	set PartieSegAli {}
    } else {
	set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
	set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
    }

    if {$Gapped} {set ICol 1} else {set ICol 0}
    set OldPN -99999
    set zPN 0
    set IlFautTrier 0
    set EstUnPsiBlast 0
    set Profil 0

    set FautVider [expr ! $PourBallast]
    set LuPremier 0
    foreach Ligne $PartieScores {
	if { $Ligne == "" } { continue }
	if { [regexp "Sequences not found previously" $Ligne] } {
	    set EstUnPsiBlast 1
	    continue
	}
	
	regsub "!" $Ligne " " Ligne

	if { $PourBallast && [regexp {\-{50}} $Ligne]} { continue }
	if {! [regexp {[a-zA-Z]} $Ligne]} {continue}
	if {  [regexp {\\\\End} $Ligne]} { break }
	if {! $PourBallast} {set FautVider 1}
	if {  [regexp {^[0-9a-zA-Z]} $Ligne]} {
	    if {$LuPremier} {
		lappend lBanqueId $oldBanqueId
		lappend lAccess   $oldAccess
		lappend lProfil   $oldProfil
		lappend lPN       $oldPN
		lappend lScore    $oldScore
		regsub -all "\"" $oldDE " " oldDE
		regsub -all {\(} $oldDE " " oldDE
		regsub -all {\)} $oldDE " " oldDE
		regsub -all {\{} $oldDE " " oldDE
		regsub -all {\}} $oldDE " " oldDE
		regsub -all {\[} $oldDE " " oldDE
		regsub -all {\]} $oldDE " " oldDE

		set oldDE         [join $oldDE]
		lappend lDE       $oldDE

		incr NombreDeBons
	    }

	    set LuPremier 1
	    set Access ""
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {break}
	    set AccessLu $Access
	    if {[regexp -nocase {^UniRef} $BanqueId] || [regexp {^ENS} $BanqueId]} {
		set Access $BanqueId
	    }
	    if {[regexp -nocase {[\(\)\{\}\[\]\:]} $Access]} {
		set Access $BanqueId
	    }
	    if {! [EstUnAccessPDB $Access] &&  ([EstUnAccessPDB $BanqueId] || ! [regexp -nocase {[a-z_]} $Access])} {
		set Access $BanqueId
	    }
	    set Profil [string equal [string range $Ligne $iProfil $iProfil] "*"]
	    set ScorePN [string trim $Ligne]
	    regsub -all { +} $ScorePN " " ScorePN
	    set LesMots [split $ScorePN " "]
	    set LesMots [lrange $LesMots 0 end-$ICol]

	    set sScore [lindex $LesMots end-1]
	    scan $sScore "%d" Score

	    set sPN [lindex $LesMots end]
	    if {$sScore=="" || $sPN==""} { break }

	    set DE $Ligne
	    set DE [StringSuivant "$BanqueId" dans $DE]
	    if {! [EstUnAccessPDB $BanqueId] && ! [regexp -nocase {[^a-z0-9_]} $AccessLu] } {
		set DE [StringSuivant "$AccessLu" dans $DE]
	    }
	    regsub "$sPN *$"       $DE "" DE
	    regsub "$sScore *$"    $DE "" DE
	    regsub -all "\""  $DE " " DE
	    regsub -all {\)}  $DE " " DE
	    regsub -all {\(}  $DE " " DE
	    regsub -all {\{}  $DE " " DE
	    regsub -all {\}}  $DE " " DE
	    regsub -all {\[}  $DE " " DE
	    regsub -all {\]}  $DE " " DE
	    set DE [string trim $DE]

	    set oldDE       $DE
	    set oldAccess   $Access
	    set oldBanqueId $BanqueId
	    set oldProfil   $Profil
	    set oldScore    $Score
	    regsub {^[eE]} $sPN "1e" sPN
	    set PN $sPN
	    set oldPN       $PN

	} else {
	    if { ! $PourBallast} {continue}
	    set Ligne [string trim $Ligne]
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {continue}
	    set DEt [string range $Ligne [string length "$BanqueId $Access "] end]
	    regsub -all "\"" $DEt " " DEt
	    regsub -all {\(} $DEt " " DEt
	    regsub -all {\)} $DEt " " DEt
	    lappend oldDE DEt
	    continue
	}
	
	if {[catch { expr $PN > $CutPN } ]} {set PN 1E-200}
	if {! $PourBallast && [expr $PN > $CutPN] } {break}

	if {$NombreDeBons >= $MaxListe } { break }
    }

    lappend lBanqueId $oldBanqueId
    lappend lAccess   $oldAccess
    lappend lProfil   $oldProfil
    lappend lPN       $oldPN
    lappend lScore    $oldScore
    set oldDE [join $oldDE " "]
    lappend lDE       $oldDE
    
    incr NombreDeBons

    set LIndexChevron [lsearch -regexp -all $PartieSegAli {^>}]
    set toto [lsearch -regexp -all $PartieSegAli {^>}]

    set n 0
    set nDE {}
    set npris [llength $lDE]
    set iend [expr $npris - 1]
    set LIndexChevron [lrange $LIndexChevron 0 $iend]
    foreach i $LIndexChevron des $lDE {
	if {$n == [expr $npris - 1]} {
	    set j "end"
	} else {
	    set j [expr [lindex $LIndexChevron [expr $n + 1]] - 1]
	}

	set PartieSegAliRestante [lrange $PartieSegAli $i $j]

	set LeMeilleurDE {}
	foreach LigneDuSegAli $PartieSegAliRestante {
	    if {! [regexp -nocase {[0-9a-z]} $LigneDuSegAli]} {break} 
	    set MeilleurDE [string trim $LigneDuSegAli]
	    regsub {^>[^ ]+ } $MeilleurDE "" MeilleurDE
	    lappend LeMeilleurDE $MeilleurDE 
	}
	set newDE [join $LeMeilleurDE " "]	
	regsub -all { +} $newDE " " newDE
	lappend nDE $newDE
	incr n
    }
    set lDE $nDE

    return

}

proc DecortiqueBlastGrid2 {TexteOuListeOuFichier CutPN MaxListe aQuery {alBanqueId ""} {alAccess ""} {alDE ""} {alProfil ""} {alPN ""} {alPartieSegAli ""}} {


    global PourBallast

    if {$aQuery       !=""} { upvar $aQuery         Query        }
    if {$alBanqueId   !=""} { upvar $alBanqueId     lBanqueId    }
    if {$alAccess     !=""} { upvar $alAccess       lAccess      }
    if {$alDE         !=""} { upvar $alDE           lDE          }
    if {$alProfil     !=""} { upvar $alProfil       lProfil      }
    if {$alPN         !=""} { upvar $alPN           lPN          }

    if {$alPartieSegAli != ""} {
	if { ! [string equal $alPartieSegAli "LongDefinition"]} {
	    upvar $alPartieSegAli lPartieSegAli
	}
	set OnVeutPartieSegAli 1
	set lPartieSegAli {}
    } else {
	set lPartieSegAli {}
	set OnVeutPartieSegAli 0
    }
        
    set RetourneBlastTrie 0
    
    set Fichier ""
    if {[regexp "\n" $TexteOuListeOuFichier]} {
	set ListeDesLignes [split $TexteOuListeOuFichier "\n"]
    } elseif {[regexp " " $TexteOuListeOuFichier]} {
	set ListeDesLignes $TexteOuListeOuFichier
    } elseif {[file exists $TexteOuListeOuFichier]} {
	set Fichier $TexteOuListeOuFichier
	set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
    } else {
	return ""
    }

    if {$CutPN    == "" } { set CutPN    0.001 }
    if {$MaxListe == "" } { set MaxListe "SansLimiteDeNombre" }

    if {$CutPN    == "SansSeuilExpect"}    { set CutPN 9999.9 }
    set RenvoieLesHitsAvecSegAliUniquement 1
    if {$MaxListe == "SansLimiteDeNombreDuTout"} {
	set MaxListe "SansLimiteDeNombre"
	set RenvoieLesHitsAvecSegAliUniquement 0
    }
    if {$MaxListe == "SansLimiteDeNombre"} { set MaxListe 9999 }

    set lBanqueId {}
    set lAccess   {}
    set lDE       {}
    set lProfil   {}
    set lPN       {}
    set NombreDeBons 0

    set PremierMot ""
    scan [join [lrange $ListeDesLignes 0 3] " "]  "%s" PremierMot
    set RechercheDansFichier 1
    while {1} {
	set PourBlastP  [expr ![string compare $PremierMot "BLASTP"]]
	set PourBlastX  [expr ![string compare $PremierMot "BLASTX"]]
	set PourBallast [expr ![string compare $PremierMot "BALLAST"]]
	set PourTBlastX [expr ![string compare $PremierMot "TBLASTX"]]
	set PourBlastN  [expr ![string compare $PremierMot "BLASTN"]]
	set PourTBlastN [expr ![string compare $PremierMot "TBLASTN"]]

	if {[expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
	    break
	}
	if {$RechercheDansFichier &&  [regexp "BLASTP|BLASTX|Ballast|TBLASTX|BLASTN|TBLASTN"  [join [lrange $ListeDesLignes 0 9] " "] PremierMot]} {
	    set RechercheDansFichier 0
	    continue
	}
	return ""
    }

    if {$PourBallast} {
	set TexteSPSA     "Sequences producing High-scoring Segment Pairs"
	set iProfil       62
	set FinDE         65
    } elseif {$PourTBlastX} { 
	set TexteSPSA     "Sequences producing High-scoring Segment Pairs"
	set FinDE         59
	set iProfil       61
    } else {
	set TexteSPSA     "Sequences producing significant alignments"
	set FinDE         65
	set iProfil       66
    }

    set IndexQuery [lsearch -regexp $ListeDesLignes "Query="]
    if { $IndexQuery == -1 } {
	return ""
    }
    if {$aQuery=="BlastHitCount"} {
	set Query    "NotImportantForBlastHitCount"
	set Nomquery "NotImportantForBlastHitCount"
    } else {
	set PossiblePAB [file tail $Fichier]
    }

    if {[lsearch -regexp [lrange $ListeDesLignes 0 30] "No hits found"] != -1} {
	return 0
    }

    set IndexSPSA [lsearch -regexp $ListeDesLignes $TexteSPSA]
    if { $IndexSPSA == -1 } { return 0}
    set Gapped [string equal [string index [lindex $ListeDesLignes $IndexSPSA] end] "N"]
    set Saut 2
    if {[regexp -nocase {[a-z]} [lindex $ListeDesLignes [expr $IndexSPSA + 1]]]} { incr Saut }
    set PartieRestante [lrange $ListeDesLignes [incr IndexSPSA $Saut] end]

    set PartieEntete [lrange $ListeDesLignes 0 $IndexSPSA]

    set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
    if { $IndexPremierChevron == -1 } {
	set PartieScores [lrange $PartieRestante 0 end]
	set PartieSegAli {}
    } else {
	set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
	set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
    }

    if {$Gapped} {set ICol 1} else {set ICol 0}
    set OldPN -99999
    set zPN 0
    set IlFautTrier 0
    set EstUnPsiBlast 0
    set Profil 0

    set FautVider [expr ! $PourBallast]
    set LuPremier 0
    foreach Ligne $PartieScores {
	if { $Ligne == "" } { continue }
	if { [regexp "Sequences not found previously" $Ligne] } {
	    set EstUnPsiBlast 1
	    continue
	}
	
	regsub "!" $Ligne " " Ligne

	if { $PourBallast && [regexp {\-{50}} $Ligne]} { continue }
	if {! [regexp {[a-zA-Z]} $Ligne]} {continue}
	if {  [regexp {\\\\End} $Ligne]} { break }
	if {! $PourBallast} {set FautVider 1}
	if {  [regexp {^[0-9a-zA-Z]} $Ligne]} {
	    if {$LuPremier} {
		lappend lBanqueId $oldBanqueId
		lappend lAccess   $oldAccess
		lappend lProfil   $oldProfil
		lappend lPN       $oldPN
		lappend lScore    $oldScore
		set oldDE [join $oldDE " "]
		lappend lDE       $oldDE

		incr NombreDeBons
	    }

	    set LuPremier 1
	    set Access ""
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {break}
	    set AccessLu $Access
	    if {[regexp -nocase {^UniRef} $BanqueId] || [regexp {^ENS} $BanqueId]} {
		set Access $BanqueId
	    }
	    if {[regexp -nocase {[\(\)\{\}\[\]]} $Access]} {
		set Access $BanqueId
	    }
	    if {! [EstUnAccessPDB $Access] &&  ([EstUnAccessPDB $BanqueId] || ! [regexp -nocase {[a-z_]} $Access])} {
		set Access $BanqueId
	    }
	    set Profil [string equal [string range $Ligne $iProfil $iProfil] "*"]
	    set ScorePN [string trim $Ligne]
	    while {[regsub -all "  " $ScorePN " " tmp]} {set ScorePN $tmp}
	    set LesMots [split $ScorePN " "]
	    set LesMots [lrange $LesMots 0 end-$ICol]
	    set sScore [lindex $LesMots end-1]
	    scan $sScore "%d" Score
	    set sPN [lindex $LesMots end]
	    if {$sScore=="" || $sPN==""} { break }
	    set DE $Ligne
	    set DE [StringSuivant "$BanqueId" dans $DE]
	    if {! [EstUnAccessPDB $BanqueId] && ! [regexp -nocase {[^a-z0-9_]} $AccessLu] } {
		set DE [StringSuivant "$AccessLu" dans $DE]
	    }
	    regsub "$sPN *$"       $DE "" DE
	    regsub "$sScore *$"    $DE "" DE
	    regsub -all {"} $DE "" DE
	    set DE [string trim $DE]
#"
	    set oldDE       $DE
	    set oldAccess   $Access
	    set oldBanqueId $BanqueId
	    set oldProfil   $Profil
	    set oldScore    $Score
	    regsub {^[eE]} $sPN "1e" sPN
	    set PN $sPN
	    set oldPN       $PN

	} else {
	    if { ! $PourBallast} {continue}
	    set Ligne [string trim $Ligne]
	    if {! [scan $Ligne "%s %s" BanqueId Access]} {continue}
	    lappend oldDE [string range $Ligne [string length "$BanqueId $Access "] end]
	    continue
	}
	
	if {[catch { expr $PN > $CutPN } ]} {set PN 1E-200}
	if {! $PourBallast && [expr $PN > $CutPN] } {break}

	if {$NombreDeBons >= $MaxListe } { break }
    }
    lappend lBanqueId $oldBanqueId
    lappend lAccess   $oldAccess
    lappend lProfil   $oldProfil
    lappend lPN       $oldPN
    lappend lScore    $oldScore
    set oldDE [join $oldDE " "]
    lappend lDE       $oldDE
    
    incr NombreDeBons

    set LIndexChevron [lsearch -regexp -all $PartieSegAli {^>}]
    set toto [lsearch -regexp -all $PartieSegAli {^>}]

    set n 0
    set nDE {}
    set npris [llength $lDE]
    set iend [expr $npris - 1]
    set LIndexChevron [lrange $LIndexChevron 0 $iend]
    foreach i $LIndexChevron des $lDE {
	if {$n == [expr $npris - 1]} {
	    set j "end"
	} else {
	    set j [expr [lindex $LIndexChevron [expr $n + 1]] - 1]
	}

	set PartieSegAliRestante [lrange $PartieSegAli $i $j]

	set LeMeilleurDE {}
	foreach LigneDuSegAli $PartieSegAliRestante {
	    if {! [regexp -nocase {[0-9a-z]} $LigneDuSegAli]} {break} 
	    set MeilleurDE [string trim $LigneDuSegAli]
	    regsub {^>[^ ]+ } $MeilleurDE "" MeilleurDE
	    lappend LeMeilleurDE $MeilleurDE 
	}
	set newDE [join $LeMeilleurDE " "]	
	while {[regsub -all "  " $newDE " " tmp]} {set newDE $tmp}
	lappend nDE $newDE
	incr n
    }

    set lDE $nDE

    return

}

proc DecortiqueBlastPCDNA {BanqueID Hit Quoi {Fichier ""} {MaxAccess -1} {MaxHitsParAccess -1}} {

    global DecortiqueBlastPCDNA 
    
     if {$Fichier==""} {
	if {[info exists DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)]} { 
	    return [set DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)] 
	}
	return {}
    } else {
	if {[info exists DecortiqueBlastPCDNA]} { unset DecortiqueBlastPCDNA }
    }
    
    set LesLignes [LesLignesDuFichier $Fichier]
    if {[lsearch -regexp [lrange $LesLignes 0 30] "No hits found"] != -1} { return 0 }
    set IndexSPSA [lsearch -regexp $LesLignes  "Sequences producing significant alignments"]
    if { $IndexSPSA == -1 } { return 0 }
    set PartieRestante [lrange $LesLignes [incr IndexSPSA 2] end]
    set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
    if { $IndexPremierChevron == -1 } { return 0 }
    set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
    set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]

    set EncoreUnAccess $MaxAccess
    foreach Ligne $PartieSegAli {
	if { $Ligne == "" } { continue }
	if { [regexp "^>" $Ligne] } {
	    if { ! [incr EncoreUnAccess -1]} { break }
	    set EncoreUnHit $MaxHitsParAccess
	    set NumHit 0
	    set CurrentAccess ""
	    scan $Ligne "%s %s" CurrentBID CurrentAccess
	    regsub ">" $CurrentBID "" CurrentBID
	    regsub "^>$CurrentBID" $Ligne "" Ligne
	    set LesMots [split $Ligne " "]
	    if {[EstUnAccessPDB $CurrentBID]} {
		set DefProt [join [lrange $LesMots 1 end] " "]
	    } else {
		set DefProt [join [lrange $LesMots 2 end] " "]
	    }
#	    lappend LesBIDs $CurrentBID
	    set Def($CurrentBID) $DefProt
	    set Acc($CurrentBID) $CurrentAccess
	    continue
	}
	if { [regexp "Length" $Ligne] } {
	    regsub "^ *Length = " $Ligne "" Ligne 
	    scan $Ligne "%d" Long
	    set LongProt($CurrentBID) $Long
	    continue
	}
	if { [regexp "Expect" $Ligne] } {
	    incr NumHit
	    set E [PNApres "Expect =" dans $Ligne]
	    set Expect($CurrentBID,$NumHit) $E
	    continue   
	}
	if { [regexp "Identities" $Ligne] } {
	    regsub -all "," $Ligne "" Ligne 
	    regsub -all {\(*\)} $Ligne "" Ligne
	    set nId [IntegerApres "Identities =" dans $Ligne]
	    set nTot [IntegerApres "/" dans $Ligne]
	    set nGaps [IntegerApres "Gaps =" dans $Ligne]
	    if {$nGaps==""} { set nGaps 0 } 
	    set Identites($CurrentBID,$NumHit) $nId
	    set Gaps($CurrentBID,$NumHit)      $nGaps
	    set LongHit($CurrentBID,$NumHit)   $nTot

	    if { ! [info exists DejaVu($CurrentBID)]} {
		lappend LesBIDs $CurrentBID
		set DejaVu($CurrentBID) 1
	    }
	    if { ! [incr EncoreUnHit -1]} { break }
	    lappend LesHits($CurrentBID) $NumHit
	}
    }
    set DecortiqueBlastPCDNA(All,All,Numbers) $LesBIDs
    foreach B $LesBIDs {
	set DecortiqueBlastPCDNA($B,All,DefProt)  [set Def($B)]
	set DecortiqueBlastPCDNA($B,All,Access)   [set Acc($B)]
	set DecortiqueBlastPCDNA($B,All,LongProt) [set LongProt($B)]
	set DecortiqueBlastPCDNA($B,All,Numbers)  [set LesHits($B)]
	foreach H [set LesHits($B)] {
	    set DecortiqueBlastPCDNA($B,$H,Identites) [set Identites($B,$H)]
	    set DecortiqueBlastPCDNA($B,$H,Gaps)      [set Gaps($B,$H)]
	    set DecortiqueBlastPCDNA($B,$H,Expect)    [set Expect($B,$H)]
	    set DecortiqueBlastPCDNA($B,$H,LongHit)   [set LongHit($B,$H)]
	}
    }
    return [DecortiqueBlastPCDNA $BanqueID $Hit $Quoi]

}

proc DecortiqueBlastPourAccessQuery {Nom} {

    global RepertoireDuGenome
    set FichierBlast "$RepertoireDuGenome/tblastnhuman/$Nom"
    foreach Ligne [LesLignesDuFichier $FichierBlast] {
	if {[regexp -nocase "Query=" $Ligne]} {
	    Espionne $Ligne
	    scan $Ligne "%s %s" query access
	    return $access
	}
    }

}

proc DecortiqueBlastPourLongueurQuery {Nom} {

    global RepertoireDuGenome
    set FichierBlast "$RepertoireDuGenome/tblastnhuman/$Nom"
    foreach Ligne [LesLignesDuFichier $FichierBlast] {
	if {[regexp -nocase "letters\\)" $Ligne]} {
	    Espionne $Ligne
	    scan $Ligne "%s" parentheseNb
	    regsub "\\(" $parentheseNb "" Nb
	    return $Nb
	}
    }

}

proc DecortiqueBlastYEAH {{Start ""} {Stop ""} {Attendre ""}} {



    set SeuilExpect "1.0e-10"
    set MaxListe "SansLimiteDeNombre"

    set Banque "[RepertoireDuGenome]/banques/YEAH"
    set OnAttend 0
    if {$Attendre!=""} { set OnAttend 1 }
    set i 0
    foreach X [YEAHStore "ListOfAccess" $Start $Stop] {
	if {$Attendre==""} {
	    if {[YEAHpa $X]!=""} { continue }
	    if {[YEAHpa $X "Others"]!=""} { Espionne $X ; continue }
	} else {
	    if {$OnAttend && $X!=$Attendre} { continue }
	    set OnAttend 0
	}
	set FichierBlast "[RepertoireDuGenome]/blastpYEAH/$X"
	if {[FileAbsent $FichierBlast]} { continue }
	DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
	set Moi $X
	Espionne $Moi
	foreach  Toi $lBanqueId PN $lPN DE $lDE {
	    YEAHpa $Moi $Toi $PN
	}
	if {[expr [incr i] % 100]==0} { YEAHpa "Save" }
    }
    YEAHpa "Save"

}

proc DecortiqueBlat {TexteListeOuFichier} {

    if {[regexp "\n" $TexteListeOuFichier]} {
	set LesLignes [split $TexteListeOuFichier "\n"]
    } elseif {[llength $TexteListeOuFichier]==1} {
	    set LesLignes [LesLignesDuFichier $TexteListeOuFichier]
    } else {
	set LesLignes $TexteListeOuFichier
    }
    set LongQuery -1
    set Query "QueryNotFoundInBlat"
    set StartBarrette -1
    set LesHits {}
    set AHitNeedsToBeStored 0
    set SeqQuery ""
    set Barres   ""
    set SeqSbjct ""
    set DebQuery -1
    set DebSbjct -1
    set Strand "Plus/Plus"
    lappend LesLignes "EndOfFile"
    foreach Ligne $LesLignes {
	if {[regexp {^>} $Ligne] || [regexp { Score =} $Ligne] || [regexp "^EndOfFile$" $Ligne]} {
	    if {$AHitNeedsToBeStored} {
		lappend LesHits [list $Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand  $DebQuery $FinQuery $DebSbjct $FinSbjct $SeqQuery $Barres $SeqSbjct] 
		set SeqQuery ""
		set Barres   ""
		set SeqSbjct ""
		set DebQuery -1
		set DebSbjct -1
		set AHitNeedsToBeStored 0
	    }
	}
	if {$StartBarrette>=0} {
	    set Barrette [string range $Ligne $StartBarrette end]
	    append Barres $Barrette
	    set StartBarrette -1
	    continue
	}
	if {[regexp {^Query= } $Ligne]} {
	    set Query [StringApres "Query=" dans $Ligne]
	    continue
	}
	if {[regexp {\(([0-9]+) letters\)} $Ligne Match LongQuery]} {
	    continue
	}
	if {[regexp {^>} $Ligne]} {
	    set Access ""
	    scan $Ligne "%s %s" BId Access
	    regsub ">" $BId "" BId
	    if {$Access==""} { set Access $BId }
	    continue
	}
	if {[regexp { Score =} $Ligne]} {
	    set Score  [IntegerApres "Score =" dans $Ligne]
	    set Expect [StringApres "Expect =" dans $Ligne]
	    regsub {^[eE]} $Expect "1e" Expect
	    continue
	}
	if {[regexp { Length =} $Ligne]} {
	    set Length  [IntegerApres "Length =" dans $Ligne]
	    continue
	}
	if {[regexp { Identities =} $Ligne]} {
	    set Identities  [StringSuivant "Identities = " dans $Ligne]
	    regsub { *\(.*} $Identities "" Identities
	    continue
	}
	if {[regexp { Strand =} $Ligne]} {
	    set Strand  [StringSuivant "Strand =" dans $Ligne]
	    regsub -all " " $Strand "" Strand
	    continue
	}
	if {[regexp {^Query\: +([0-9]+) +} $Ligne Match DQ]} {
	    if {$DebQuery==-1} { set DebQuery $DQ }
	    set StartBarrette [string length $Match]
	    regsub {^Query\: +([0-9]+) +} $Ligne "" SeqQ
	    if {[regexp { +([0-9]+) *$} $SeqQ MQ FQ]} { 
		regsub { +[0-9]+ *$} $SeqQ "" SeqQ
		set FinQuery $FQ
	    }
	    append SeqQuery $SeqQ
	    continue
	}
	if {[regexp {^Sbjct\: +([0-9]+) +} $Ligne Match DS]} {
	    if {$DebSbjct==-1} { set DebSbjct $DS }
	    regsub {^Sbjct\: +([0-9]+) +} $Ligne "" SeqS
	    if {[regexp { +([0-9]+) *$} $SeqS MS FS]} { 
		regsub { +[0-9]+ *$} $SeqS "" SeqS
		set FinSbjct $FS
	    }
	    append SeqSbjct $SeqS
	    set AHitNeedsToBeStored 1
	    continue
	}
    }
    return $LesHits

}

proc DecortiqueColumnScore {NoeudCol} {

    global TColScore

    set name [$NoeudCol selectNodes "string(colsco-name)"]
    # special case :
    # macsim names should be trucated after '_'
    if {[string range $name 0 5] eq "normd_"} {
	set name "normd"
    }
    if {$name ni $TColScore(Names)} {
	lappend TColScore(Names) $name
    }
    lappend TColScore($name,Owner) [$NoeudCol selectNodes "string(colsco-owner)"]
    lappend TColScore($name,Type) [$NoeudCol selectNodes "string(colsco-type)"]
    set cgrp ""
    catch {set cgrp [$NoeudCol selectNodes "string(colsco-group)"]}
    lappend TColScore($name,Group) $cgrp
    lappend TColScore($name,Data)  [$NoeudCol selectNodes "string(colsco-data)"]

    return

}

proc DecortiqueDisEmbl {} {

    global ItemHTMLFermant ; set ItemHTMLFermant(param) ">"
    global ItemHTMLFermant ; set ItemHTMLFermant(br) ">"
    set Texte [ContenuDuFichier "[HomeRipp]/vrac/DisEmblResultat.html"]

    while 1 {
	set Att ""
	set Titre [ValeurDeLaBalise h3 Texte Rogner]
	set F [ValeurDeLaBalise tt Texte Rogner Att]
	if {$F==""} { break }
	set F [StringSuivant "
" dans $F]
	regsub -all {<[^>]+>} $F "" F
	regsub -all -nocase {[^A-Z]} $F "" F
	Espionne "$Titre"
	Espionne "$F"
    }
    exit
    set X [ValeurDeLaBalise form Texte]
    Espionne $X
    Espionne "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    set X [ValeurDeLaBalise form Texte]
    Espionne $X
    exit

}

proc DecortiqueEtAfficheUnMSF {{FichierMSF ""}} {

    global Defauts
    global menustatus
    global LeFichierMSFDeDepart
    global LNOrdali
    global Sequences

    set LeFichierMSFDeDepart $FichierMSF
    if {! [VerifieFormatAlignement $FichierMSF MSF]} {return}

    DecortiqueUnMSF $FichierMSF LNOrdali Sequences
    if {! [InitSequences]} {return}
    InitPremierGroupe
    InitAffichage
    BindingsOrdali
    BindModeNormal

    MontreStrSecDansAlignement

    return

}

proc DecortiqueFetch {TexteGCG ChampsDuFetch} {


    upvar $ChampsDuFetch CDF

    set CDF(espece)     ""
    set CDF(classe)     ""
    set CDF(gn)         ""
    set CDF(definition) ""

    foreach Ligne [split $TexteGCG "\n"] {
	switch -regexp $Ligne {
	    "^OS" {
		append CDF(espece)     "[string trim [string range $Ligne 2 end]] "
	    }
	    "^OC" {
		append CDF(classe)     "[string trim [string range $Ligne 2 end]] "
	    }
	    "^GN" {
		append CDF(gn)         "[string trim [string range $Ligne 2 end]] "
	    }
	    "^DE" {
		append CDF(definition) "[string trim [string range $Ligne 2 end]] "
	    }
	}
    }

}

proc DecortiqueGBTags {aOS aOC aSeqADN {Fichier ""}} {

    upvar $aOS OS
    upvar $aOC OC
    upvar $aSeqADN SeqADN

    global RepertoireDuGenome

    set Avertir 0

    set LesClefsInteressantes {gene note product translation protein_id dbx_ref function}

    if {$Fichier==""} {
	set Fichier [ButineArborescence All $RepertoireDuGenome]
	if {$Fichier==""} { return "" }
    }
    set OS ""
    set LaSuiteEstPourOC 0
    set OC ""
    set LaSuiteEstPourDE 0
    set DE ""
    set LaSuiteEstPourCDS 0
    set LaSuiteEstPourADN 0
    set LongueurLue -1
    set RogneEnDebutSIlFaut 1
    set LesBornes {}
    set LeADN {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$LaSuiteEstPourADN} {
	    if {[regexp "^ORIGIN" $Ligne]} { continue }
	    if {[regexp {\.\.} $Ligne]} { continue }
	    if {[regexp "//" $Ligne]} { break }
	    regsub -all {[ 0-9]} $Ligne "" LigneADN
	    lappend LeADN $LigneADN
	    continue
	}
	if {[regexp "^BASE COUNT " $Ligne] ||  [regexp "^SQ" $Ligne] ||  [regexp {^ORIGIN( |$)} $Ligne] ||  [regexp {[^0-9]\.\. *$} $Ligne]} {
	    set LaSuiteEstPourADN 1
	    continue
	}
	if { ! $LaSuiteEstPourADN} {
	    regsub {\. \.} $Ligne ".." Ligne
	}
	if {[regexp "^ACCESSION   " $Ligne]} {
	    regsub "^ACCESSION   " $Ligne "" Access
	    lappend LeRetour "/Access=$Access"
	}
	if {[regexp -nocase "^DEFINITION  " $Ligne]} {
	    regsub "^DEFINITION  " $Ligne "" DE
	    set DE [string trim $DE]
	    set LaSuiteEstPourDE 1
	    continue
	}
	if {$LaSuiteEstPourDE} {
	    if {[regexp "^       " $Ligne]} {
		append DE " [string trim $Ligne]"
	    } else {
		set DE [string trim $DE]
		lappend LeRetour "/product=$DE"
		set LaSuiteEstPourDE 0
	    }
	    continue
	} 
	if {[regexp -nocase "^  ORGANISM  " $Ligne]} {
	    set Genre "Inconnu"
	    set Espece "inconnu"
	    scan $Ligne "%s %s %s" Key Genre Espece
	    set OS "$Genre $Espece"
	    lappend LeRetour "/OS=$OS"
	    set LaSuiteEstPourOC 1
	    continue
	}
	if {$LaSuiteEstPourOC} {
	    if {[regexp "^       " $Ligne]} {
		append OC "[string trim $Ligne] "
	    } else {
		set OC [string trim $OC]
		lappend LeRetour "/OC=$OC"
		set LaSuiteEstPourOC 0
	    }
	    continue
	} 
    }
    set SeqADN [join $LeADN ""]
    lappend LeRetour "/DNA=$SeqADN"
    return $LeRetour

}

proc DecortiqueGenBank {aOS aOC aSeqADN {FichierOuListeOuTexte ""} {OffsetADN 0} {OffsetNumero 0} {FichierProt ""}} {

    upvar $aOS OS
    upvar $aOC OC
    upvar $aSeqADN SeqADN

    global RepertoireDuGenome
    global NumeroHautPourGenbank
    global SupposePrefixe

    if {[info exists SupposePrefixe]} { Espionne "SupposePrefixe $SupposePrefixe" }

    set Avertir 0

    set LesClefsInteressantes {locus_tag gene note product translation protein_id dbx_ref function}

    if {$FichierOuListeOuTexte==""} { return "" }

    if {[regexp "\n" $FichierOuListeOuTexte]} { set FichierOuListeOuTexte [split $FichierOuListeOuTexte "\n"] }

    if {[llength $FichierOuListeOuTexte] < 2 } {
	set Fichier $FichierOuListeOuTexte
	if {$Fichier=="" || ! [file exists $Fichier]} {
	    if {[PourWscope]} { return "" }
	    set Fichier [ButineArborescence "All" $RepertoireDuGenome]
	    if {$Fichier==""} { return "" }
	}
	set LesLignes [LesLignesDuFichier $Fichier] 
    } else {
	set LesLignes $FichierOuListeOuTexte
    }
    set OS ""
    set LaSuiteEstPourOC 0
    set OC ""
    set LaSuiteEstPourCDS 0
    set LaSuiteEstPourADN 0
    set LongueurLue -1
    set RogneEnDebutSIlFaut 1
    set LesBornes {}
    set LeADN {}
    set GeNo ""
    set ClefCourante "bidon"
    set JoinCar " "
    foreach Ligne $LesLignes {
	if {$LaSuiteEstPourADN} {
	    if {[regexp "^ORIGIN" $Ligne]} { continue }
	    if {[regexp {\.\.} $Ligne]} { continue }
	    if {[regexp "//" $Ligne]} { break }
	    regsub -all {[ 0-9]} $Ligne "" LigneADN
	    if {[regexp -nocase {[^a-z]} $LigneADN] &&  ! [OuiOuNon "$Ligne\n is this really a DNA sequence line ?"]} {
		if {[OuiOuNon "Do I continue to scan non DNA information ?"]} { set LaSuiteEstPourADN 0 ; continue }
	    }
	    lappend LeADN $LigneADN
	    continue
	}
	if {[regexp "^DEFINITION " $Ligne]} { set Definition [StringSuivant "DEFINITION" dans $Ligne] }
	if {[regexp "^BASE COUNT " $Ligne] ||  [regexp "^SQ" $Ligne] ||  [regexp {^ORIGIN( |$)} $Ligne] ||  ([regexp {[^0-9]\.\. *$} $Ligne] && ! [regexp {^ +/} $Ligne])} {
	    if { ! [regexp {[^0-9]\.\. *$} $Ligne] ||  [OuiOuNon "Please answer Yes if the line \n$Ligne\nis the last line of non DNA information ?"]}  {
		set LaSuiteEstPourADN 1
		continue
	    }
	}
	if { ! $LaSuiteEstPourADN} {
	    regsub {\. \.} $Ligne ".." Ligne
	}
	if {[regexp "^ACCESSION   " $Ligne]} {
	    regsub "^ACCESSION   " $Ligne "" Access
	}
	if {[regexp "^FT   " $Ligne]} {
	    regsub "^FT   " $Ligne "" Ligne
	} elseif { 0 && [regexp {^[A-Z][A-Z]} $Ligne]} { continue }

	if {[regexp -nocase "^REFERENCE" $Ligne]} {
	    set LongueurLue [IntegerApres "(bases 1 to " dans $Ligne]
	    continue
	}

	set OldGeNo $GeNo
	set GeNo ""
	if {[regexp {/note=\"locus_tag\: } $Ligne]} {
	    regsub  {/note=\"locus_tag\: } $Ligne "/note=\"" Ligne
	}
	if {[regexp {/gene=\"BB} $Ligne] && [file tail [RepertoireDuGenome]]=="Bbur"} {
	    if { [regexp {/gene=\"(BB[A-Z][0-9]+)} $Ligne Match BB] } {
		set Lettre [string index $BB 2]
		set I [string first $Lettre " ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
		regsub "BB$Lettre" $BB "" NN
		set GeNo [format "BB%4.4d" [expr [Base10 $NN] + $I*100 + 1000]]
	    } elseif { [regexp {/gene=\"(BB[0-9]+)} $Ligne Match BB] } {
		regsub "BB" $BB "" NN
		set GeNo [format "BB%4.4d" [expr [Base10 $NN]]]
	    }
	    Espionne "$GeNo $Ligne"
	} elseif {[info exists SupposePrefixe] && $SupposePrefixe!="" } {
	    set REx " /(gene|note)=\"(.+\; *|)$SupposePrefixe\[0-9\]{2,}(i|c|\,|\;|\")"
	    Espionne $Ligne
	    if {[regexp $REx $Ligne Match]} {
		regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
		Espionne " ... avec $GeNo"
		if {[regexp {\;|\,} $GeNo Separateur]} {
		    set REx "$SupposePrefixe\[0-9\]{2,}"
		    foreach Mot [split $GeNo $Separateur] {
			if {[regexp $REx $Mot GeNo]} { break }
		    }
		}
		regsub $SupposePrefixe $GeNo "" GeNo
		regsub {(i|c)$} $GeNo "" GeNo
		Espionne "Hourra $GeNo"
	    } else {
		set GeNo $OldGeNo
	    }		
	} elseif {[regexp -nocase { /(gene|note)=\"(.+\; *|)[A-Z]+[0-9]{2,}(i|c|\,|\;|\")} $Ligne Match]} {
	    regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
	    if {[regexp {\;|\,} $GeNo Separateur]} {
		foreach Mot [split $GeNo $Separateur] {
		    if {[regexp -nocase {[A-Z]+[0-9]{2,}} $Mot GeNo]} { break }
		}
	    }
	    regsub {(i|c)$} $GeNo "" GeNo
	} else {
	    set GeNo $OldGeNo
	}
	if {$LaSuiteEstPourCDS && [regexp {^ {20,}} $Ligne]} {
	    if { ! [regexp "^ +/" $Ligne]} {                
		regsub -all "\"" $Ligne "" Valeur
		lappend LesValeurs [string trim $Valeur]
		set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
	    }
	    foreach Clef $LesClefsInteressantes {
		if {[regexp "^ +/$Clef" $Ligne]} {
		    regsub -all " +/$Clef=|\"" $Ligne "" Valeur
		    set LesValeurs [list [string trim $Valeur]]
		    set ClefCourante $Clef
		    if {$ClefCourante=="translation"} {
			set JoinCar ""
		    } else {
			set JoinCar " "
		    }
		    set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
		    break
		}
	    }
	    set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
	    continue
	}
	set LaSuiteEstPourCDS 0
	if {[regexp -nocase "^  ORGANISM  " $Ligne]} {
	    regsub -all { \([^\)]+\)} $Ligne "" Ligne

	    set Genre "Inconnu"
	    set Espece "inconnu"
	    scan $Ligne "%s %s %s" Key Genre Espece
	    set OS "$Genre $Espece"
	    set LaSuiteEstPourOC 1
	    continue
	}
	if {$LaSuiteEstPourOC} {
	    if {[regexp "^       " $Ligne]} {
		append OC "[string trim $Ligne] "
	    } else {
		set OC [string trim $OC]
		set LaSuiteEstPourOC 0
	    }
	    continue
	} 
	if {[regexp {^(()|     )CDS} $Ligne]} {
	    scan $Ligne "%s %s" Key Bornes
	    set Reverse [regexp "complement" $Bornes]
	    set RognerEnDebut 0
	    set RognerEnFin 0
	    if {[regexp "<" $Bornes]} { set RognerEnDebut 1}
	    if {[regexp ">" $Bornes]} { set RognerEnFin 1}
	    regsub -all {[^0-9]} $Bornes " " Bornes
	    scan $Bornes "%d %d" Debut Fin
	    if {$Reverse} {
		set Orient "R" 
		incr Debut 3
	    } else {
		set Orient "F"
		incr Fin -3
	    }
	    if {[expr ($Fin-$Debut+1)%3]  && ($RognerEnDebut && $RognerEnFin ||  ! $RognerEnDebut && ! $RognerEnFin )} {
		if {$RogneEnDebutSIlFaut} {
		    set RognerEnDebut 1
		    set RognerEnFin   0
		} else {
		    set RognerEnDebut 0
		    set RognerEnFin   1
		}
	    }
	    while {[expr ($Fin-$Debut+1)%3]} {
		if {$RognerEnDebut} { incr Debut }
		if {$RognerEnFin}   { incr Fin -1 }
	    }
	    set RogneEnDebutSIlFaut 0

	    lappend LesBornes "$Debut $Fin $Orient"
	    set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
	    set LaSuiteEstPourCDS 1
	    continue
	}
    }
    set SeqADN [join $LeADN ""]
    if { ! [info exists NumeroHautPourGenbank]} { set NumeroHautPourGenbank 9999 }
    set Numero $OffsetNumero
    foreach Bornes $LesBornes {
	scan $Bornes "%d %d %s" Debut Fin Orient
	set VraiDebut [expr $Debut + $OffsetADN]
	set VraiFin   [expr $Fin   + $OffsetADN]
	if {[regexp "NumeroDansGene" $OffsetNumero]} {
	    set Gene [set ArrayCDS($Debut,$Fin,$Orient,gene)]
	    if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Gene]} {
		FaireLire "/gene=$Gene isn't a valid ORF name ..."
	    }
	    regsub -all {[^0-9]} $Gene "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansNote" $OffsetNumero]} {
	    set Note [set ArrayCDS($Debut,$Fin,$Orient,note)]
	    if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Note Match]} {
		FaireLire "/note=$Note isn't a valid ORF name ..."		
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansGeNo" $OffsetNumero]} {
	    set GeNo [set ArrayCDS($Debut,$Fin,$Orient,GeNo)]
	    if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
		if {[AskForNumberingGenbank]} {
		    FaireLire "/geneORnote=$GeNo isn't a valid ORF name ..."
		}
		set Match $NumeroHautPourGenbank
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansLocusTag" $OffsetNumero]} {
	    set GeNo [set ArrayCDS($Debut,$Fin,$Orient,locus_tag)]
	    if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
		if {[AskForNumberingGenbank]} {
		    FaireLire "/locus_tag=$GeNo isn't a valid ORF name ..."
		}
		set Match $NumeroHautPourGenbank
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} else {
	    incr Numero
	}
	while {[info exists DejaVu($Numero)]} {
	    set Ask [AskForNumberingGenbank]
	    if {$Ask && [OuiOuNon "I saw already the ORF number $Numero. Do I skipp ?" 0]} { break }
	    if { ! $Ask || [OuiOuNon "Can You give me an other one ?"]} { 
		if {$Ask} {
		    set Autre [Base10 [Entre $NumeroHautPourGenbank]]
		} else {
		    set Autre [Base10 $NumeroHautPourGenbank]
		}
		if {$Autre==$NumeroHautPourGenbank} { incr NumeroHautPourGenbank -1 }
		if {$Autre==""} { continue }
		set Numero $Autre
	    }
	}
	if {[info exists DejaVu($Numero)]} { continue }
	set BeauNumero [format "%4.4d" $Numero]
	set DejaVu($Numero) 1
	set Nom "ORF$BeauNumero"
	set Info "$Nom $VraiDebut $VraiFin $Orient"
	if {$FichierProt!=""} {
	    AppendAuFichier $FichierProt $Info
	} else {
	    lappend LeRetour $Info
	    if {[info exists Access]} { lappend LeRetour "$Nom /Access=$Access" }
	    if {[info exists OS    ]} { lappend LeRetour "$Nom /OS=$OS" }
	    if {[info exists OC    ]} { lappend LeRetour "$Nom /OC=$OC" }
	    if {[info exists LeADN ]} { lappend LeRetour "$Nom /ADN=[Transcript $Bornes SeqADN]"}
	}
	foreach Clef $LesClefsInteressantes {
	    if { ! [info exists ArrayCDS($Debut,$Fin,$Orient,$Clef)]} { continue }
	    set Info "$Nom /$Clef=[set ArrayCDS($Debut,$Fin,$Orient,$Clef)]"
	    if {$FichierProt!=""} {
		AppendAuFichier $FichierProt $Info
	    } else {
		lappend LeRetour $Info 
	    }
	}
    }
    set LongADN [string length $SeqADN]
    if {$Avertir && $LongueurLue>0 && $LongADN!=$LongueurLue} {
	FaireLire "During DecortiqueGenBank $Fichier\n Longueur lue $LongueurLue != Longueur reelle $LongADN"
    }
    if {$FichierProt==""} {
	if {[info exists Access]}     { lappend LeRetour "ORF_ALL /Access=$Access" }
	if {[info exists OS]}         { lappend LeRetour "ORF_ALL /OS=$OS" }
	if {[info exists OC]}         { lappend LeRetour "ORF_ALL /OC=$OC" }
	if {[info exists Definition]} { lappend LeRetour "ORF_ALL /DEFINITION=$Definition" }
	if {[info exists LeADN]}      { lappend LeRetour "ORF_ALL /DNA=$SeqADN" }
	return $LeRetour
    } else {
	return "[expr $OffsetADN+$LongADN] $Numero"
    }

}

proc DecortiqueGenBankLuc {aDE aOS aOC aSeqADN {FichierOuListe ""} {OffsetADN 0} {OffsetNumero 0} {FichierProt ""}} {

    upvar $aDE DE
    upvar $aOS OS
    upvar $aOC OC
    upvar $aSeqADN SeqADN

    global RepertoireDuGenome
    global NumeroHautPourGenbank
    global SupposePrefixe

    if {[info exists SupposePrefixe]} { Espionne "SupposePrefixe $SupposePrefixe" }

    set Avertir 0

    set LesClefsInteressantes {locus_tag gene note product translation protein_id dbx_ref function}

    if {[llength $FichierOuListe] < 2 } {
	set Fichier $FichierOuListe
	if {$Fichier=="" || ! [file exists $Fichier]} {
	    set Fichier [ButineArborescence "All" $RepertoireDuGenome]
	    if {$Fichier==""} { return "" }
	}
	set LesLignes [LesLignesDuFichier $Fichier]
    } else {
	set LesLignes $FichierOuListe
    }
    set DE ""
    set LaSuiteEstPourDE 0
    set OS ""
    set LaSuiteEstPourOC 0
    set OC ""
    set LaSuiteEstPourCDS 0
    set LaSuiteEstPourADN 0
    set LongueurLue -1
    set RogneEnDebutSIlFaut 1
    set LesBornes {}
    set LeADN {}
    set GeNo ""
    set ClefCourante "bidon"
    set JoinCar " "
    foreach Ligne $LesLignes {
	if {$LaSuiteEstPourADN} {
	    if {[regexp "^ORIGIN" $Ligne]} { continue }
	    if {[regexp {\.\.} $Ligne]} { continue }
	    if {[regexp "//" $Ligne]} { break }
	    regsub -all {[ 0-9]} $Ligne "" LigneADN
	    if {[regexp -nocase {[^a-z]} $LigneADN] &&  ! [OuiOuNon "$Ligne\n is this really a DNA sequence line ?"]} {
		if {[OuiOuNon "Do I continue to scan non DNA information ?"]} { set LaSuiteEstPourADN 0 ; continue }
	    }
	    lappend LeADN $LigneADN
	    continue
	}
	if {[regexp "^DEFINITION " $Ligne]} {
	    set DE [StringSuivant "DEFINITION" dans $Ligne]
	    set LaSuiteEstPourDE 1
	    continue
	}
	if {$LaSuiteEstPourDE} {
	    if {[regexp "^       " $Ligne]} {
		append DE "[string trim $Ligne] "
		continue
	    } else {
		set DE [string trim $DE]
		set LaSuiteEstPourDE 0
	    }
	}

	if {[regexp "^BASE COUNT " $Ligne] ||  [regexp "^SQ" $Ligne] ||  [regexp {^ORIGIN( |$)} $Ligne] ||  ([regexp {[^0-9]\.\. *$} $Ligne] && ! [regexp {^ +/} $Ligne])} {
	    if { ! [regexp {[^0-9]\.\. *$} $Ligne] ||  [OuiOuNon "Please answer Yes if the line \n$Ligne\nis the last line of non DNA information ?"]}  {
		set LaSuiteEstPourADN 1
		continue
	    }
	}
	if { ! $LaSuiteEstPourADN} {
	    regsub {\. \.} $Ligne ".." Ligne
	}
	if {[regexp "^ACCESSION   " $Ligne]} {
	    regsub "^ACCESSION   " $Ligne "" Access
	}
	if {[regexp "^FT   " $Ligne]} {
	    regsub "^FT   " $Ligne "" Ligne
	} elseif { 0 && [regexp {^[A-Z][A-Z]} $Ligne]} { continue }

	if {[regexp -nocase "^REFERENCE" $Ligne]} {
	    set LongueurLue [IntegerApres "(bases 1 to " dans $Ligne]
	    continue
	}

	set OldGeNo $GeNo
	set GeNo ""
	if {[regexp {/note=\"locus_tag\: } $Ligne]} {
	    regsub  {/note=\"locus_tag\: } $Ligne "/note=\"" Ligne
	}
	if {[regexp {/gene=\"BB} $Ligne] && [file tail [RepertoireDuGenome]]=="Bbur"} {
	    if { [regexp {/gene=\"(BB[A-Z][0-9]+)} $Ligne Match BB] } {
		set Lettre [string index $BB 2]
		set I [string first $Lettre " ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
		regsub "BB$Lettre" $BB "" NN
		set GeNo [format "BB%4.4d" [expr [Base10 $NN] + $I*100 + 1000]]
	    } elseif { [regexp {/gene=\"(BB[0-9]+)} $Ligne Match BB] } {
		regsub "BB" $BB "" NN
		set GeNo [format "BB%4.4d" [expr [Base10 $NN]]]
	    }
	    Espionne "$GeNo $Ligne"
	} elseif {[info exists SupposePrefixe] && $SupposePrefixe!="" } {
	    set REx " /(gene|note)=\"(.+\; *|)$SupposePrefixe\[0-9\]{2,}(i|c|\,|\;|\")"
	    Espionne $Ligne
	    if {[regexp $REx $Ligne Match]} {
		regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
		Espionne " ... avec $GeNo"
		if {[regexp {\;|\,} $GeNo Separateur]} {
		    set REx "$SupposePrefixe\[0-9\]{2,}"
		    foreach Mot [split $GeNo $Separateur] {
			if {[regexp $REx $Mot GeNo]} { break }
		    }
		}
		regsub $SupposePrefixe $GeNo "" GeNo
		regsub {(i|c)$} $GeNo "" GeNo
		Espionne "Hourra $GeNo"
	    } else {
		set GeNo $OldGeNo
	    }
	} elseif {[regexp -nocase { /(gene|note)=\"(.+\; *|)[A-Z]+[0-9]{2,}(i|c|\,|\;|\")} $Ligne Match]} {
	    regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
	    if {[regexp {\;|\,} $GeNo Separateur]} {
		foreach Mot [split $GeNo $Separateur] {
		    if {[regexp -nocase {[A-Z]+[0-9]{2,}} $Mot GeNo]} { break }
		}
	    }
	    regsub {(i|c)$} $GeNo "" GeNo
	} else {
	    set GeNo $OldGeNo
	}
	if {$LaSuiteEstPourCDS && [regexp {^ {20,}} $Ligne]} {
	    if { ! [regexp "^ +/" $Ligne]} {
		regsub -all "\"" $Ligne "" Valeur
		lappend LesValeurs [string trim $Valeur]
		set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
	    }
	    foreach Clef $LesClefsInteressantes {
		if {[regexp "^ +/$Clef" $Ligne]} {
		    regsub -all " +/$Clef=|\"" $Ligne "" Valeur
		    set LesValeurs [list [string trim $Valeur]]
		    set ClefCourante $Clef
		    if {$ClefCourante=="translation"} {
			set JoinCar ""
		    } else {
			set JoinCar " "
		    }
		    set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
		    break
		}
	    }
	    set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
	    continue
	}
	set LaSuiteEstPourCDS 0
	if {[regexp -nocase "^  ORGANISM  " $Ligne]} {
	    set Genre "Inconnu"
	    set Espece "inconnu"
	    scan $Ligne "%s %s %s" Key Genre Espece
	    set OS "$Genre $Espece"
	    set LaSuiteEstPourOC 1
	    continue
	}
	if {$LaSuiteEstPourOC} {
	    if {[regexp "^       " $Ligne]} {
		append OC "[string trim $Ligne] "
	    } else {
		set OC [string trim $OC]
		set LaSuiteEstPourOC 0
	    }
	    continue
	}
	if {[regexp {^(()|     )CDS} $Ligne]} {
	    scan $Ligne "%s %s" Key Bornes
	    set Reverse [regexp "complement" $Bornes]
	    set RognerEnDebut 0
	    set RognerEnFin 0
	    if {[regexp "<" $Bornes]} { set RognerEnDebut 1}
	    if {[regexp ">" $Bornes]} { set RognerEnFin 1}
	    regsub -all {[^0-9]} $Bornes " " Bornes
	    scan $Bornes "%d %d" Debut Fin
	    if {$Reverse} {
		set Orient "R"
		incr Debut 3
	    } else {
		set Orient "F"
		incr Fin -3
	    }
	    if {[expr ($Fin-$Debut+1)%3]  && ($RognerEnDebut && $RognerEnFin ||  ! $RognerEnDebut && ! $RognerEnFin )} {
		if {$RogneEnDebutSIlFaut} {
		    set RognerEnDebut 1
		    set RognerEnFin   0
		} else {
		    set RognerEnDebut 0
		    set RognerEnFin   1
		}
	    }
	    while {[expr ($Fin-$Debut+1)%3]} {
		if {$RognerEnDebut} { incr Debut }
		if {$RognerEnFin}   { incr Fin -1 }
	    }
	    set RogneEnDebutSIlFaut 0

	    lappend LesBornes "$Debut $Fin $Orient"
	    set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
	    set LaSuiteEstPourCDS 1
	    continue
	}
    }
    set SeqADN [join $LeADN ""]
    if { ! [info exists NumeroHautPourGenbank]} { set NumeroHautPourGenbank 9999 }
    set Numero $OffsetNumero
    foreach Bornes $LesBornes {
	scan $Bornes "%d %d %s" Debut Fin Orient
	set VraiDebut [expr $Debut + $OffsetADN]
	set VraiFin   [expr $Fin   + $OffsetADN]
	if {[regexp "NumeroDansGene" $OffsetNumero]} {
	    set Gene [set ArrayCDS($Debut,$Fin,$Orient,gene)]
	    if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Gene]} {
		FaireLire "/gene=$Gene isn't a valid ORF name ..."
	    }
	    regsub -all {[^0-9]} $Gene "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansNote" $OffsetNumero]} {
	    set Note [set ArrayCDS($Debut,$Fin,$Orient,note)]
	    if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Note Match]} {
		FaireLire "/note=$Note isn't a valid ORF name ..."
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansGeNo" $OffsetNumero]} {
	    set GeNo [set ArrayCDS($Debut,$Fin,$Orient,GeNo)]
	    if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
		if {[AskForNumberingGenbank]} {
		    FaireLire "/geneORnote=$GeNo isn't a valid ORF name ..."
		}
		set Match $NumeroHautPourGenbank
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} elseif {[regexp "NumeroDansLocusTag" $OffsetNumero]} {
	    set GeNo [set ArrayCDS($Debut,$Fin,$Orient,locus_tag)]
	    if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
		if {[AskForNumberingGenbank]} {
		    FaireLire "/locus_tag=$GeNo isn't a valid ORF name ..."
		}
		set Match $NumeroHautPourGenbank
	    }
	    regsub -all {[^0-9]} $Match "" Numero
	    set Numero [Base10 $Numero]
	    if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
		incr Numero $Off
	    }
	} else {
	    incr Numero
	}
	while {[info exists DejaVu($Numero)]} {
	    set Ask [AskForNumberingGenbank]
	    if {$Ask && [OuiOuNon "I saw already the ORF number $Numero. Do I skipp ?" 0]} { break }
	    if { ! $Ask || [OuiOuNon "Can You give me an other one ?"]} {
		if {$Ask} {
		    set Autre [Base10 [Entre $NumeroHautPourGenbank]]
		} else {
		    set Autre [Base10 $NumeroHautPourGenbank]
		}
		if {$Autre==$NumeroHautPourGenbank} { incr NumeroHautPourGenbank -1 }
		if {$Autre==""} { continue }
		set Numero $Autre
	    }
	}
	if {[info exists DejaVu($Numero)]} { continue }
	set BeauNumero [format "%4.4d" $Numero]
	set DejaVu($Numero) 1
	set Nom "ORF$BeauNumero"
	set Info "$Nom $VraiDebut $VraiFin $Orient"
	if {$FichierProt!=""} {
	    AppendAuFichier $FichierProt $Info
	} else {
	    lappend LeRetour $Info
	    if {[info exists Access]} { lappend LeRetour "$Nom /Access=$Access" }
	    if {[info exists OS    ]} { lappend LeRetour "$Nom /OS=$OS" }
	    if {[info exists OC    ]} { lappend LeRetour "$Nom /OC=$OC" }
	    if {[info exists LeADN ]} { lappend LeRetour "$Nom /ADN=[Transcript $Bornes SeqADN]"}
	}
	foreach Clef $LesClefsInteressantes {
	    if { ! [info exists ArrayCDS($Debut,$Fin,$Orient,$Clef)]} { continue }
	    set Info "$Nom /$Clef=[set ArrayCDS($Debut,$Fin,$Orient,$Clef)]"
	    if {$FichierProt!=""} {
		AppendAuFichier $FichierProt $Info
	    } else {
		lappend LeRetour $Info
	    }
	}
    }
    set LongADN [string length $SeqADN]
    if {$Avertir && $LongueurLue>0 && $LongADN!=$LongueurLue} {
	FaireLire "During DecortiqueGenBank $Fichier\n Longueur lue $LongueurLue != Longueur reelle $LongADN"
    }
    if {$FichierProt==""} {
	if {[info exists Access]} { lappend LeRetour "ORF_ALL /Access=$Access" }
	if {[info exists OS]} { lappend LeRetour "ORF_ALL /OS=$OS" }
	if {[info exists OC]} { lappend LeRetour "ORF_ALL /OC=$OC" }
	if {[info exists Definition]} { lappend LeRetour "ORF_ALL /DEFINITION=$Definition" }
	if {[info exists LeADN]} { lappend LeRetour "ORF_ALL /DNA=$SeqADN" }
	return $LeRetour
    } else {
	return "[expr $OffsetADN+$LongADN] $Numero"
    }

}

proc DecortiqueGenScan {Prot Exon Quoi {Texte ""}} {

    global DecortiqueGenScan

    Wup "Prot can be All or a number"
    Wup "Exon can be All or a number"
    Wup "Quoi can be list of Protein numbers, Gauche, Droite, TFA, TFAo, Nature, Sens, Begin, End or Proba"

    if {$Texte==""} {
	if {[info exists DecortiqueGenScan($Prot,$Exon,$Quoi)]} { return [set DecortiqueGenScan($Prot,$Exon,$Quoi)] }
	return {}
    } else {
	if {[info exists DecortiqueGenScan]} { unset DecortiqueGenScan }
    }

    set OnAttendBeginEnd 1
    foreach Ligne [split $Texte "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {$OnAttendBeginEnd} {
	    if { ! [regexp {Begin[ \.]*End} $Ligne]} { continue }
	    set OnAttendBeginEnd 0
	    continue
	}
	if {[regexp "Predicted peptide sequence" $Ligne]} { continue }
	if {[regexp {^ *[0-9]+} $Ligne]} {
	    if {[info exists Prob]} {unset Prob}
	    scan $Ligne "%s %s %s %d %d %d %d %d %d %d %d %f %f"  sPE N S D F Len Fr Ph I Do CodRg Prob T
	    regsub {\.} $sPE " " sPE
	    scan $sPE "%s %s" P E

	    set Nature($P,$E) $N
	    set Sens($P,$E)   $S
	    set Sens($P)      $S
	    if {[info exists Prob]} {set Proba($P,$E) $Prob}

	    if {$S=="+"} {
		set Begin($P,$E)  $D
		set End($P,$E)    $F
		if { ! [info exists Gauche($P)]} { set Gauche($P) $D }
		set Droite($P) $F
	    } else {
		set Begin($P,$E)  $F
		set End($P,$E)    $D
		if { ! [info exists Gauche($P)]} { set Gauche($P) $F }
		set Droite($P) $D
	    }
	    if { ! [info exists DejaVu($P)]} { lappend LesPs $P}
	    set DejaVu($P) 1
	    lappend LesEs($P) $E
	    continue 
	}
	if {[regexp "^>" $Ligne]} {
	    set LigneO $Ligne
	    regsub -all {[>\|]} $Ligne " " Ligne
	    scan $Ligne "%s %s %s" ChroContig sP sLong
	    regexp {_[0-9]+$} $sP P
	    regsub "_" $P "" P
	    regsub "_aa$" $sLong "" Long
	    regsub "\:" $ChroContig "_" Access
	    set Entete ">${Access}_GS_$P found by GenScan in $ChroContig $Long aa"
	    set CurrentP $P
	    set LeTFAo($CurrentP) [list $LigneO]
	    set LeTFA($CurrentP) [list $Entete]
	    continue
	}
	lappend LeTFAo($CurrentP) $Ligne
	lappend LeTFA($CurrentP) $Ligne
    }
    set DecortiqueGenScan(All,All,Numbers) $LesPs
    foreach P $LesPs {
	set DecortiqueGenScan($P,All,Gauche)       [set Gauche($P)]
	set DecortiqueGenScan($P,All,Droite)       [set Droite($P)]
	set DecortiqueGenScan($P,All,Numbers)      [set LesEs($P)]
	set DecortiqueGenScan($P,All,Sens)         [set Sens($P)]
	set DecortiqueGenScan($P,All,TFAo)         [join [set LeTFAo($P)] "\n"]
	set DecortiqueGenScan($P,All,TFA)          [join [set LeTFA($P)] "\n"]
	foreach E [set LesEs($P)] {
	    set DecortiqueGenScan($P,$E,Nature)    [set Nature($P,$E)]
	    set DecortiqueGenScan($P,$E,Sens)      [set Sens($P,$E)]
	    set DecortiqueGenScan($P,$E,Begin)     [set Begin($P,$E)]
	    set DecortiqueGenScan($P,$E,End)       [set End($P,$E)]
	    if {[info exists Proba($P,$E)]} { 
		set DecortiqueGenScan($P,$E,Proba) [set Proba($P,$E)]
	    }
	}
    }
    return [DecortiqueGenScan $Prot $Exon $Quoi]

}

proc DecortiqueGeneArrayFilePs {} {

    set FilePs "/genomics/link/affyArrayAnnot/HuGene-1_0/AffyAnno20130326/HuGene-1_0-st-v1.na33.2.hg19.probeset.csv"
    set LesLignesPs  [TabulonsSansQuote $FilePs "," ";" " " "GetListOfValues"]
    set total 0; set h 0; set i 0; set j 0; set a 0; set b 0; set c 0 
    foreach LignePs $LesLignesPs {
	incr total
	set LesElmtsPs [split $LignePs ";"]
	set PsIdPs [lindex $LesElmtsPs 0]
	lappend LesPsIdPs $PsIdPs
	set TrIdPs [lindex $LesElmtsPs 6]
	set VuDansPs($TrIdPs) 1
	lappend LesTrIdPs $TrIdPs
	set CategoryPs [lindex $LesElmtsPs 38]
	lappend CatPsId($CategoryPs,PsId) $PsIdPs
	lappend CatPsId($CategoryPs,TrId) $TrIdPs
	lappend LesCatPs $CategoryPs
	set gnassign   [lindex $LesElmtsPs 9]
	set mrnaassign [lindex $LesElmtsPs 10]
	regsub -all "///" $gnassign  "^" gnassign 
	regsub -all "//" $gnassign "°" gnassign
	regsub -all "///" $mrnaassign  "^" mrnaassign
	regsub -all "//" $mrnaassign "°" mrnaassign
	set LesGn {}; set LesmRNA {}; set LesmRNACurated {}
	foreach item [split $gnassign "^"] {
	    lappend LesGn [string trim [lindex [split $item "°"] 0]]
	}
	foreach item [split $mrnaassign "^"] {
	    lappend LesmRNA [string trim [lindex [split $item "°"] 0]]
	}
	set LesGn   [lsort -unique $LesGn]
	set LesmRNA [lsort -unique $LesmRNA]
	set Gn   [join $LesGn " "]
	set mRNA [join $LesmRNA " "]
	if {$Gn == "---" && $mRNA == "---"} { incr a }
	if {$Gn != $mRNA} {
	    incr h
	}

	foreach mRNA $LesmRNA {
	    if {[regexp "^GENSCAN" $mRNA]} {continue}
	    lappend LesmRNACurated $mRNA
	}    
	set LesmRNACurated [lsort -unique $LesmRNACurated]

	if {$LesmRNACurated=={}} {
	    lappend LesmRNACurated "---"
	    #NB dans ce cas gnassign est vide aussi
	    incr i
	}
	set mRNA [join $LesmRNACurated " "]
	if {$Gn == "---" && $mRNA == "---"} { incr b }
	

	if {$Gn != $mRNA} {
	    incr j
	    if {$Gn=="---"} {incr c; continue}
#	    Espionne "$LignePs"
#	    Espionne "Gn:$Gn mRNA:$mRNA paspareil"
	}
    }
    Espionne "parmi les total: $total probesets, on en a h:$h ou gnassign != mrnaassign et plus que j:$j quand elimine les GENSCAN"
    Espionne "parmi ces j:$j on en a c:$c ou gnassign est vide mais pas mrnaassign"
    Espionne "parmi les total: $total on a a:$a + i:$i (quand elimine les GENSCAN) = b:$b probesets sans gnassign ni mrnaassign"
    set LesPsIdPs [ListeSansDoublon $LesPsIdPs]
    set LesTrIdPs [ListeSansDoublon $LesTrIdPs]
    Espionne "[llength $LesPsIdPs] PsIdPs"
    Espionne "[llength $LesTrIdPs] TrIdPs"
    
    set LesCatPs [ListeSansDoublon $LesCatPs]
    Espionne "LesCatPs $LesCatPs"
    foreach CatPs $LesCatPs {
	Espionne "$CatPs [llength $CatPsId($CatPs,PsId)] Ps"
    }

}

proc DecortiqueGeneArrayFileTr {} {

    #set FileTr "/genomics/link/affyArrayAnnot/HuGene-1_0/AffyAnno20130327/HuGene-1_0-st-v1.na33.2.hg19.transcript.csv"
    #set FileTr "/genomics/link/affyArrayAnnot/HuGene-2_0/AffyAnno20130402/HuGene-2_0-st-v1.na33.2.hg19.transcript.csv"
    set FileTr "/genomics/link/affyArrayAnnot/MoGene-2_0/AffyAnno20130328/MoGene-2_0-st-v1.na33.2.mm10.transcript.csv"
    set total 0; set h 0; set i 0; set j 0; set a 0; set b 0; set c 0; set d 0; set e 0; set f 0; set g 0; set h 0; set i 0; 
    set z1 0; set z2 0; set z3 0; set y1 0; set y2 0; set y3 0; set x1 0; set x2 0; set x3 0; set w1 0; set w2 0; set w3 0; set v1 0; set v2 0; set v3 0; set u1 0; set u2 0; set u3 0
    set LesLignesTr  [TabulonsSansQuote $FileTr "," ";" " " "GetListOfValues"]
    foreach LigneTr $LesLignesTr {
	incr total
	set LesElmtsTr [split $LigneTr ";"]
	set TrIdTr [lindex $LesElmtsTr 0]
	lappend LesTrIdTr $TrIdTr
	set PsIdTr [lindex $LesElmtsTr 1]
	lappend LesPsIdTr $PsIdTr
	set Sw [lindex $LesElmtsTr 9]

	#unigene
	set LesUnigene {}; set LesAccess {}
	if {[info exists UnigeneDAccess]} {unset UnigeneDAccess}
	set Unigene [lindex $LesElmtsTr 10]
	if {$Unigene=="---"} {
	    incr z1
	} else {
	    incr z2
	    regsub -all "///" $Unigene "^" Unigene 
	    regsub -all "//"  $Unigene "°" Unigene
	    foreach item [split $Unigene "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess
		set Unigene [string trim [lindex [split $item "°"] 1]]
		lappend LesUnigene $Unigene
		lappend UnigeneDAccess($Access) $Unigene
	    }
	    set LesUnigene [ListeSansDoublon $LesUnigene]
	    if {[llength $LesUnigene] > 1} {
		incr z3
		#Espionne "$TrIdTr $LesUnigene"
	    }
	    foreach Access $LesAccess {
		if {[llength $UnigeneDAccess($Access)]>1} {
		    #Espionne "$TrIdTr $Access $UnigeneDAccess($Access)"
		}
	    }
	}

	#pathway
	set LesAccess {}
	if {[info exists PathwayDAccess]} {unset PathwayDAccess}
	set Pathway [lindex $LesElmtsTr 14]
	if {$Pathway=="---"} {
	    incr y1
	} else {
	    incr y2
	    regsub -all "///" $Pathway "^" Pathway 
	    regsub -all "//"  $Pathway "°" Pathway
	    foreach item [split $Pathway "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess $Access
		lappend LesPathwayType [string trim [lindex [split $item "°"] 1]]
		set Pathway [string trim [lindex [split $item "°"] 2]]
		lappend PathwayDAccess($Access) $Pathway
	    }
	    foreach Access $LesAccess {
		if {$Access==[lindex $LesAccess 0]} { 
		    set AccessPremier $Access
		    set PathwayPremier $PathwayDAccess($Access) 
		    continue
		}
		if {$PathwayDAccess($Access) != $PathwayPremier} {
		    incr y3
	#	    Espionne "$TrIdTr"
	#	    Espionne "$AccessPremier $PathwayPremier"
	#	    Espionne "$Access $PathwayDAccess($Access)"
		    break
		}
	    }
	}

	#protein_domains
	set LesAccess {}
	if {[info exists DomaineDAccess]} {unset DomaineDAccess}
	set Domaine [lindex $LesElmtsTr 15]
	if {$Domaine=="---"} {
	    incr x1
	} else {
	    incr x2
	    regsub -all "///" $Domaine "^" Domaine 
	    regsub -all "//"  $Domaine "°" Domaine
	    foreach item [split $Domaine "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess $Access
		lappend LesDomaineType [string trim [lindex [split $item "°"] 1]]
		set DomaineId [string trim [lindex [split $item "°"] 2]]
		set DomaineDes [string trim [lindex [split $item "°"] 3]]
		lappend DomaineDAccess($Access) $DomaineId
	    }
	    foreach Access $LesAccess {
		if {$Access==[lindex $LesAccess 0]} { 
		    set AccessPremier $Access
		    set DomainePremier $DomaineDAccess($Access) 
		    continue
		}
		if {$DomaineDAccess($Access) != $DomainePremier} {
		    incr x3
	#	    Espionne "$TrIdTr"
	#	    Espionne "$AccessPremier $DomainePremier"
	#	    Espionne "$Access $DomaineDAccess($Access)"
		    break
		}
	    }
	}

	#GO_BP
	set LesAccess {}
	if {[info exists GO_BPDAccess]} {unset GO_BPDAccess}
	set GO_BP [lindex $LesElmtsTr 11]
	if {$GO_BP=="---"} {
	    incr w1
	} else {
	    incr w2
	    regsub -all "///" $GO_BP "^" GO_BP 
	    regsub -all "//"  $GO_BP "°" GO_BP
	    foreach item [split $GO_BP "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess $Access
		set GO_BPId [string trim [lindex [split $item "°"] 2]]
		set GO_BPDes [string trim [lindex [split $item "°"] 3]]
		lappend GO_BPDAccess($Access) $GO_BPId
	    }
	    foreach Access $LesAccess {
		if {$Access==[lindex $LesAccess 0]} { 
		    set AccessPremier $Access
		    set GO_BPPremier $GO_BPDAccess($Access) 
		    continue
		}
		if {$GO_BPDAccess($Access) != $GO_BPPremier} {
		    incr w3
	#	    Espionne "$TrIdTr"
	#	    Espionne "$AccessPremier $GO_BPPremier"
	#	    Espionne "$Access $GO_BPDAccess($Access)"
		    break
		}
	    }
	}

	#GO_CC
	set LesAccess {}
	if {[info exists GO_CCDAccess]} {unset GO_CCDAccess}
	set GO_CC [lindex $LesElmtsTr 12]
	if {$GO_CC=="---"} {
	    incr v1
	} else {
	    incr v2
	    regsub -all "///" $GO_CC "^" GO_CC 
	    regsub -all "//"  $GO_CC "°" GO_CC
	    foreach item [split $GO_CC "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess $Access
		set GO_CCId [string trim [lindex [split $item "°"] 2]]
		set GO_CCDes [string trim [lindex [split $item "°"] 3]]
		lappend GO_CCDAccess($Access) $GO_CCId
	    }
	    foreach Access $LesAccess {
		if {$Access==[lindex $LesAccess 0]} { 
		    set AccessPremier $Access
		    set GO_CCPremier $GO_CCDAccess($Access) 
		    continue
		}
		if {$GO_CCDAccess($Access) != $GO_CCPremier} {
		    incr v3
	#	    Espionne "$TrIdTr"
	#	    Espionne "$AccessPremier $GO_CCPremier"
	#	    Espionne "$Access $GO_CCDAccess($Access)"
		    break
		}
	    }
	}

	#GO_MF
	set LesAccess {}
	if {[info exists GO_MFDAccess]} {unset GO_MFDAccess}
	set GO_MF [lindex $LesElmtsTr 13]
	if {$GO_MF=="---"} {
	    incr u1
	} else {
	    incr u2
	    regsub -all "///" $GO_MF "^" GO_MF 
	    regsub -all "//"  $GO_MF "°" GO_MF
	    foreach item [split $GO_MF "^"] {
		set Access [string trim [lindex [split $item "°"] 0]]
		lappend LesAccess $Access
		set GO_MFId [string trim [lindex [split $item "°"] 2]]
		set GO_MFDes [string trim [lindex [split $item "°"] 3]]
		lappend GO_MFDAccess($Access) $GO_MFId
	    }
	    foreach Access $LesAccess {
		set GO_MFDAccess($Access) [ListeSansDoublon $GO_MFDAccess($Access)]
		if {$Access==[lindex $LesAccess 0]} { 
		    set AccessPremier $Access
		    set GO_MFPremier $GO_MFDAccess($Access) 
		    continue
		}
		if {$GO_MFDAccess($Access) != $GO_MFPremier} {
		    incr u3
	#	    Espionne "$TrIdTr"
	#	    Espionne "$AccessPremier $GO_MFPremier"
	#	    Espionne "$Access $GO_MFDAccess($Access)"
		    break
		}
	    }
	}

	#category
	set CategoryTr [lindex $LesElmtsTr 17]
	set CatTrId($TrIdTr) $CategoryTr
	lappend CatTrId($CategoryTr) $TrIdTr
	lappend LesCatTr $CategoryTr


	#gnassign et mrnaassign
	set gnassign   [lindex $LesElmtsTr 7]
	set mrnaassign [lindex $LesElmtsTr 8]
	regsub -all "///" $gnassign "^" gnassign 
	regsub -all "//"  $gnassign "°" gnassign
	regsub -all "///" $mrnaassign "^" mrnaassign
	regsub -all "//"  $mrnaassign "°" mrnaassign
	set LesAccGn {}; set LesAccmRNA {}; set LesAccmRNACurated {}
	set LesGnGn {}; set LesCytoband {}; set LesGeneId {}
	foreach item [split $gnassign "^"] {
	    lappend LesAccGn    [string trim [lindex [split $item "°"] 0]]
	    lappend LesGnGn     [string trim [lindex [split $item "°"] 1]]
	    lappend LesCytoband [string trim [lindex [split $item "°"] 3]]
	    lappend LesGeneId   [string trim [lindex [split $item "°"] 4]]
	}
	foreach item [split $mrnaassign "^"] {
	    lappend LesAccmRNA [string trim [lindex [split $item "°"] 0]]
	}
	set LesAccGn   [lsort -unique $LesAccGn]
	set LesAccmRNA [lsort -unique $LesAccmRNA]
	set LesGnGn    [lsort -unique $LesGnGn]
	set GnGn     [join $LesGnGn " "]
	set LesCytoband [lsort -unique $LesCytoband]
	set Cytoband [join $LesCytoband " "]
	set LesGeneId   [lsort -unique $LesGeneId]
	set GeneId   [join $LesGeneId " "]

	if {$gnassign== "---"} { 
	    incr d 
	} elseif {$GnGn== "---"} { 
	    incr e 
	} else {
	    if {[llength $LesGnGn] > 1} { 
	#	Espionne "$TrIdTr $LesGnGn"
		incr f 
	    }
	}

	if {$gnassign== "---"} { 
	    incr g 
	} elseif {$GeneId== "---"} { 
	    incr h 
	} else {
	    if {[llength $LesGeneId] > 1} { 
		#Espionne "$TrIdTr $LesGeneId"
		incr i 
	    }
	}


	set Gn   [join $LesAccGn " "]
	set mRNA [join $LesAccmRNA " "]
	if {$Gn == "---" && $mRNA == "---"} {Espionne "$TrIdTr vide aux deux"; incr a }
	if {$Gn != $mRNA} {
	    incr h
	}

	foreach mRNA $LesAccmRNA {
	    if {[regexp "^GENSCAN" $mRNA]} {continue}
	    lappend LesAccmRNACurated $mRNA
	}    
	set LesAccmRNACurated [lsort -unique $LesAccmRNACurated]

	if {$LesAccmRNACurated=={}} {
	    lappend LesAccmRNACurated "---"
	    #NB dans ce cas gnassign est vide aussi
	    incr i
	}
	set mRNA [join $LesAccmRNACurated " "]
	if {$Gn == "---" && $mRNA == "---"} { incr b }
	

	if {$Gn != $mRNA} {
	    incr j
	    if {$Gn=="---"} {incr c}
	}
    }
    Espionne "$z1 sur $total TrId ont un unigene vide"
    Espionne "$z3 sur $z2 TrId avec plusieurs unigenes"

    Espionne ""
    Espionne "$y1 sur $total TrId ont un pathway vide"
    Espionne "$y3 sur $y2 TrId ou les access n'ont pas les meme pathway"    
    set LesPathwayType [ListeSansDoublon $LesPathwayType]
    Espionne "LesPathwayType $LesPathwayType"

    Espionne ""
    Espionne "$x1 sur $total TrId ont un domaine vide"
    Espionne "$x3 sur $x2 TrId ou les access n'ont pas les meme domaine"    
    set LesDomaineType [ListeSansDoublon $LesDomaineType]
    Espionne "LesDomaineType $LesDomaineType"

    Espionne ""
    Espionne "$w1 sur $total TrId ont un GO_BP vide"
    Espionne "$w3 sur $w2 TrId ou les access n'ont pas les meme GO_BP"    

    Espionne ""
    Espionne "$v1 sur $total TrId ont un GO_CC vide"
    Espionne "$v3 sur $v2 TrId ou les access n'ont pas les meme GO_CC"    

    Espionne ""
    Espionne "$u1 sur $total TrId ont un GO_MF vide"
    Espionne "$u3 sur $u2 TrId ou les access n'ont pas les meme GO_MF"    

    Espionne ""
    Espionne "d $d e $e f $f"
    Espionne "g $g h $h i $i"

    set LesPsIdTr [ListeSansDoublon $LesPsIdTr]
    set LesTrIdTr [ListeSansDoublon $LesTrIdTr]
    Espionne "[llength $LesPsIdTr] PsIdTr"
    Espionne "[llength $LesTrIdTr] TrIdTr"

    set LesCatPerdus {}; set LesCatGardes {}
    foreach TrIdTr $LesTrIdTr {
	if {![info exists VuDansPs($TrIdTr)]} {
	    lappend LesCatPerdus $CatTrId($TrIdTr)
	} else {
	    lappend LesCatGardes $CatTrId($TrIdTr)
	}
    }
    set LesCatPerdus [ListeSansDoublon $LesCatPerdus]
    set LesCatGardes [ListeSansDoublon $LesCatGardes]
    Espionne "lesPerdues $LesCatPerdus"
    Espionne "lesGardes  $LesCatGardes"
    set LesCatTr [ListeSansDoublon $LesCatTr]
    foreach CatTr $LesCatTr {
	Espionne "$CatTr [llength $CatTrId($CatTr)]"
    }

    Espionne "total $total"
    Espionne "parmi les total: $total probesets, on en a h:$h ou gnassign != mrnaassign et plus que j:$j quand elimine les GENSCAN"
    Espionne "parmi ces j:$j on en a c:$c ou gnassign est vide mais pas mrnaassign"
    Espionne "parmi les total: $total on a a:$a + i:$i (quand elimine les GENSCAN) = b:$b probesets sans gnassign ni mrnaassign"

}

proc DecortiqueIpCafe {IpCafe aIp aCafe} {

    upvar $aIp Ip
    upvar $aCafe Cafe

    DecortiqueIpCafeScience "$IpCafe:bidon" Ip Cafe Bidon
    return "$Ip:Cafe"

}

proc DecortiqueIpCafeScience {IpCafeScience aIp aCafe aScience} {

    upvar $aIp Ip
    upvar $aCafe Cafe
    upvar $aScience Science
    global CafeDesSciencesDir

    set DefautIp "cafetier"
    set DefautCafe "20000"
    set DefautScience "Zero"

    
    if {[regexp -nocase "^GeneQuid" $IpCafeScience]} {
	set DefautIp "milex"
	set DefautCafe "20000"
    }

    if {[regexp -nocase "^Quid" $IpCafeScience]} {
	set DefautIp "milex"
	set DefautCafe "20000"
    }

    if {[regexp -nocase "TFIID" $IpCafeScience]} {
	set DefautIp "cafetier"
	set DefautCafe "20000"
    }

    if {[regexp -nocase "Magos" $IpCafeScience]} {
	set DefautIp "cafetier"
	set DefautCafe "20000"
    }

    if {[regexp -nocase {^(genoret|gx)} $IpCafeScience]} {
	set DefautIp "cafetier"
	set DefautCafe "20000"
    }

    if {[regexp ":" $IpCafeScience]} {
	ScanLaListe [split $IpCafeScience ":"] Ip Cafe Science
	if {[regexp {^[0-9][0-9]+$} $Ip]} {
	    set Science $Cafe
	    set Cafe    $Ip
	    set Ip      $DefautIp
	}
	if {[regexp -nocase {[a-z]} $Cafe]} {
	    set Science $Cafe
	    set Cafe $DefautCafe
	}
    } else {
	set Ip      $DefautIp
	set Cafe    $DefautCafe
	set Science $IpCafeScience
    }
    if {$Ip==""}      { set Ip      $DefautIp }
    if {$Cafe==""}    { set Cafe    $DefautCafe }
    if {$Science==""} { set Science $DefautScience }
    set Ip [IpSiLocalhost $Ip]

    set Science [BonneOrthographePourScience $Science] 
    return "$Ip:$Cafe:$Science"

}

proc DecortiqueLesGenBank {Fichiers {OffsetNumero 0}} {

    global RepertoireDuGenome

    set LesFichiersPresumes [lsort [glob $Fichiers]]
    set LesFichiers {}
    foreach F $LesFichiersPresumes {
#	if { ! [regexp {[0-9]+$} $F]} { continue }
	lappend LesFichiers  $F
    }
    if {$LesFichiers=={} && [file exists $Fichiers]} {
	set LesFichiers [list $Fichiers]
    }
    set DebEtFin $LesFichiers
    if {[llength $DebEtFin]> 20} {
	set DebEtFin [concat [lrange $LesFichiers 0 10 ] [list "..." "..."] [lrange $LesFichiers end-9 end]]
    }
    if { ! [OuiOuNon "Do I use\n[join $DebEtFin "\n"]\n ?"]} { return "" }

    set TestOverlap [OuiOuNon "Do I test for overlap between successiv files ? "]

    set OrgaSuppose [file tail $Fichiers]
    if {$OrgaSuppose=="*"} {
	set OrgaSuppose [file tail $RepertoireDuGenome]
    }
    regsub "_$" $OrgaSuppose "" OrgaSuppose 
    set OrgaSuppose "[string toupper [string index $OrgaSuppose 0]][string range $OrgaSuppose 1 end]"
    set Repertoire [file dirname [file dirname $Fichiers]]
    set FichierProt "$Repertoire/ProteinesDe$OrgaSuppose"
    set FichierADN  "$Repertoire/SequenceADNDe$OrgaSuppose"
    while { ! [OuiOuNon "Do I use the protein file \n$FichierProt\n and the DNA file \n$FichierADN\n ?"]} {
	FaireLire "Please select for the files you want to create"
	set FichierProt [FichierPourSaveAs $FichierProt]
	set FichierADN  [FichierPourSaveAs $FichierADN]
	if {$FichierProt=="" || $FichierADN==""} {
	    if {[OuiOuNon "Do I cancel ?"]} { return "" }
	}
    }
    while {[file exists $FichierProt] || [file exists $FichierADN]} {
	if {[OuiOuNon "Do I replace \n$FichierProt\n and \n$FichierADN\n ?"]} {
	    File delete -force $FichierProt
	    File delete -force $FichierADN
	} else {
	    if {[OuiOuNon "Do I cancel ?"]} { return "" }
	}
	if {[OuiOuNon "Do I use them ?"]} { return $FichierADN }
    }

    if {[regexp "NumeroDans" $OffsetNumero] && [OuiOuNon "Are there more than 1 chromosomes ? "]} {
	if {[OuiOuNon "Do You want that I use 10000 offset numbering for each chromosome ?"]} {
	    set ChromoOffset 10000
	    while { ! [OuiOuNon "Starting with an offset of $ChromoOffset ?"]} {
		incr ChromoOffset 10000
		if {$ChromoOffset > 90000} { set ChromoOffset [Entre 00000] } 
	    }
	}
    }

    set OffsetADN 0
    set TotaleSequenceADN ""
    
    set OffsetNumeroOri $OffsetNumero 
    foreach Fichier $LesFichiers {
	if {[info exists ChromoOffset]} {
	    set OffsetNumero "$OffsetNumeroOri+$ChromoOffset"
	    incr ChromoOffset 10000
	}
	set Retour [DecortiqueGenBank OS OC SeqADN $Fichier $OffsetADN $OffsetNumero $FichierProt]
	if {[scan $Retour "%d %d" OffsetADN OffsetNumeroLu]!=2} {
	    FaireLire "I got '$Retour' from DecortiqueGenBank.\n Something is wrong.\n I'll cancel GenBank scanning."
	    return ""
	}
	if {       $OffsetNumero!="NumeroDansGene"  && $OffsetNumero!="NumeroDansNote"  && $OffsetNumero!="NumeroDansGeNo" } { set OffsetNumero $OffsetNumeroLu }
	if {$TestOverlap} { set SeqADN [NonOverlapingSeqADN $SeqADN] }
	append TotaleSequenceADN $SeqADN
    }
    set TFA [SequenceFormatTFA $TotaleSequenceADN "$Fichiers $OS complete genome" "nucbrut"]
    return [Sauve $TFA dans $FichierADN]

}

proc DecortiqueLesLignesEMBL {LesLignesEMBL {aID ""} {aAC ""} {aDE ""} {aGN ""} {aOS ""} {aOC ""} {aOX ""} {aSequenceBrute ""} {aLaDETotal ""} {aGNTotal ""}} {

    #rR pour avoir toutes les infos voir la procedure EmblInfo ou aussi InfoEmbl
    if {$aID!=""} { upvar $aID ID }
    if {$aAC!=""} { upvar $aAC AC } 
    if {$aDE!=""} { upvar $aDE DE } 
    if {$aGN!=""} { upvar $aGN GN } 
    if {$aOS!=""} { upvar $aOS OS } 
    if {$aOC!=""} { upvar $aOC OC } 
    if {$aOX!=""} { upvar $aOX OX } 
    if {$aSequenceBrute != ""} {
	upvar $aSequenceBrute SequenceBrute
	set AvecSequence 1
    } else {
	set AvecSequence 0
    }
    if {$aLaDETotal!=""} { upvar $aLaDETotal LaDETotal } 
    if {$aGNTotal  !=""} { upvar $aGNTotal   GNTotal } 

    set SansOs 1
    set StringOC ""
    set SansDE 1
    set ID ""
    set AC ""
    set OS "Genre espece"
    set OC ""
    set OX ""

    set LaDETotal {}
    set DE ""
    set RecNameDejaVu 0
    set RecNameEnCours 0
    set SubNameDejaVu 0
    set SubNameEnCours 0
    set DEFull ""
    set DEShort ""
    set DEEC ""

    set GN ""
    set GNTotal ""
    set LaSeq {}
    set YaSQ 0
    set CurRN 0                             ; #rR pour les numeros de review
    foreach Ligne $LesLignesEMBL {
	if {[regexp "^//" $Ligne]} { break }
	set CurK "SEQUENCE"
	set K ""
	if {[regexp {^([A-Z][A-Z]) } $Ligne Match K]} {set CurK $K}
	set Information [string range $Ligne 5 end]

	regexp {RN   \[([0-9]+)\]} $Ligne Match CurRN
	if {[regexp {^R} $K]} {
	    lappend AllInfo(R$CurRN) "$K $Information"
	} else {
	    lappend AllInfo($K) $Information
	}
	set Information [string trim $Information]
	if {[regexp "^SQ " $Ligne]} { set YaSQ 1 ; continue }
	if {$YaSQ} { lappend LaSeq $Ligne }
	if {$ID=="" && [regexp "^ID " $Ligne]} { scan $Information "%s" ID ; regsub {\;.*} $ID "" ID }
	if {$AC=="" && [regexp "^AC " $Ligne]} { scan $Information "%s" AC ; regsub {\;.*} $AC "" AC }
	if { $SansOs && [regexp "^OS" $Ligne] } {
	    set lili [split $Information " "]
	    set Genre  [lindex $lili 0] 
	    regsub {[^A-Za-z]} [lindex $lili 1] "" Espece
	    #rR A la demande de lM on ne passe plus par glossaire !!!!!!!!!!!!!!!!!!!!!!!!!!!!
	    set OS "$Genre $Espece"
	    #rR	    set OS [Glossaire "$Genre $Espece" Complet]
	    #rR	    if {$OS==""} { set OS "$Genre $Espece" } 
	    set SansOs 0
	}
	if [regexp "^OC " $Ligne] {
	    append OC "$Information "
	} 
	if [regexp "^OX " $Ligne] {
	    append OX "$Information "
	} 
	if [regexp "^DE " $Ligne] {
	    lappend LaDETotal $Information
	    if {$RecNameEnCours && [regexp {^Short=} $Information]} {
		set DEShort [StringApres "=" dans $Information]
		set DEShort "Short:$DEShort"
		set DEShort [string trim $DEShort " ;,"]
		continue
	    }
	    if {$RecNameEnCours && [regexp {^EC=} $Information]} {
		set DEEC [StringApres "=" dans $Information]
		set DEEC "EC:$DEEC"
		set DEEC [string trim $DEEC " ;,"]
		continue
	    }
	    if { ! $RecNameDejaVu} {
		if {[regexp {RecName: Full=} $Information]} {
		    set DEFull [string trim [StringSuivant "=" dans $Information] " ;,"]
		    set RecNameEnCours 1
		    set RecNameDejaVu 1
		    continue
		}
	    }
	    set RecNameEnCours 0
	    if { ! $RecNameDejaVu && $SubNameEnCours && [regexp {^Short=} $Information]} {
		set DEShort [StringApres "=" dans $Information]
		set DEShort "Short:$DEShort"
		set DEShort [string trim $DEShort " ;,"]
		continue
	    }
	    if { ! $RecNameDejaVu && $SubNameEnCours && [regexp {^EC=} $Information]} {
		set DEEC [StringApres "=" dans $Information]
		set DEEC "EC:$DEEC"
		set DEEC [string trim $DEEC " ;,"]
		continue
	    }
	    if { ! $RecNameDejaVu &&  ! $SubNameDejaVu} {
		if {[regexp {SubName: Full=} $Information]} {
		    set DEFull [string trim [StringSuivant "=" dans $Information] " ;,"]
		    set SubNameEnCours 1
		    set SubNameDejaVu 1
		    continue
		}
	    }
	    set SubNameEnCours 0
	}
	if {[regexp "^GN " $Ligne]} {
	    if {$GN==""} {
		set GN $Information
		set GNTotal $Information
		if {[regexp "Name=" $GN]} {
		    set GN [StringApres "=" dans $GN]
		    set GN [string trim $GN " ;,"]
		}
	    } else {
		append GNTotal " $Information"
	    }
	}
    }
    set DE [join $LaDETotal " / "]
    if {$DEFull!=""} { set DE "$DEFull $DEShort $DEEC" }

    #rR attention depuis 20150405 je ne prends que le premier nombre car il y a d'autres m....s derrière
    regsub -all {[^0-9]} $OX " " OX
    set OX [string trim $OX]
    regsub -all { .+$} $OX "" OX

    set SequenceBrute [join $LaSeq ""]
    regsub -all {[ 0-9\t\n\.\*/]} $SequenceBrute "" SequenceBrute
    set AllInfo(RN) $CurRN
    return [array get AllInfo]

}

proc DecortiqueNoeudXml {Noeud aTab} {

    upvar $aTab tb
    global {*}[info globals "TD*"] Defauts LesSeqsDuGroupe SDG ListeItemFeatures LesSequencesAssocieesClassesCanon Sequences LNOrdali 

    set ListLifeD $Defauts(LifeDomains)
    set LClass [list eukaryota archaea bacteria viruses]

    set NoeudSeqAli $Noeud

    set SeqName [BonAccess [$NoeudSeqAli selectNodes "string(seq-name)"]]
    set SeqData [$NoeudSeqAli selectNodes "string(seq-data)"]
    set SeqData [BonneSequencePourAlignement $SeqData]
    if {$SeqData eq ""} {
	puts "\n>$SeqName< is an empty sequence !"
	return
    }

    set TDesSeqnames($SeqName) $SeqName
    lappend LNOrdali $SeqName
    set Sequences($SeqName) $SeqData

    set NoeudInfos [$NoeudSeqAli selectNodes "seq-info"]
    set LifeD "undefined"
    set isACGI 0 ; set isBIdRefseq 0
    foreach NoeudInfo [$NoeudInfos childNodes] {
	set NodeName [$NoeudInfo nodeName]
	set v [$NoeudInfo selectNodes "string()"]
	switch $NodeName {
	    "accession" {
		# for compatibility;
		# NCBI GI numbers are IDs, not access
		set bonac [BonAccess $v]
		set isACGI [EstUnGI $bonac]
		set TDesAccess($SeqName) $bonac
	    }
	    "nid" {
		# for compatibility;
		# NCBI GI numbers are IDs, not access
		set bonid [BonAccess $v]
		set isBIdRefseq [EstUnRefseq $bonid]
		set TDesBId($SeqName) $bonid
	    }
	    "lifedomain" {
		set LifeD [string totitle $v]
		if {$LifeD ni $ListLifeD} {set LifeD "undefined"}
		set TDesPhylum($SeqName) $LifeD
	    }
	    "organism" {
		set GenreEspece [string map [list . " "] $v]
		set TDesOrganismes($SeqName) $GenreEspece
	    }
	    "taxid" {
		set TDesTaxId($SeqName) $v
	    }
	    "definition" {
		set TDesDescriptifs($SeqName) $v
	    }
	    "length" {
		set TDesLength($SeqName) $v
	    }
	    "group" {
		set g "Group$v"
		lappend LesSeqsDuGroupe($g) $SeqName
		set TDuGroupeDesSeqs($SeqName) $g
	    }
	    "keywordlist" {
		foreach NoeudKeywordList [$NoeudInfo selectNodes "string(keywordlist)"] {
		    foreach NoeudKeyword [$NoeudKeywordList childNodes] {
			set Keyword [$NoeudKeyword selectNodes "string()"]
		    }
		}
	    }
	    "lineage" {
		set NoeudLin $NoeudInfo
		set Lt {}
		foreach n [$NoeudLin selectNodes "taxon"] {
		    lappend Lt [$n selectNodes string()]
		}
		if {$Lt != {} } {set TDuLineage($SeqName) $Lt}
	    }
	    "goxreflist" {
		set NoeudGO $NoeudInfo
		set Lv {}
		foreach NG [$NoeudGO selectNodes "goxref"] {
		    set LNoeudG [$NG childNodes]
		    foreach n $LNoeudG {
			set f [$n selectNodes name(.)]
			set v [$n selectNodes string()]
			lappend Lv [list $f $v]
		    }
		}
		if {$Lv != {}} {set TDesGO($SeqName) $Lv}
	    }
	    "ftable" {
		set NoeudFtable $NoeudInfo
		set tb($SeqName) {}
		foreach NF [$NoeudFtable selectNodes "fitem"] {
		    set LNoeudFeatures [$NF childNodes]
		    set coords [$NF getAttribute coords local]
		    set Lv {}
		    lappend Lv "coords" $coords
		    foreach n $LNoeudFeatures {
			set f [$n selectNodes name(.)]
			set v [$n selectNodes "string()"]
			set v [string map [list " " "_"] $v]
			lappend Lv $f $v
		    }
		    lappend tb($SeqName) $Lv
		}
	    }
	    "ec" {
		set TDesEC($SeqName) $v
	    }
	    "status" {
		set TDesStatus($SeqName) $v
	    }
	    "complex" {
		set TDesComplex($SeqName) $v
	    }
	    "weight" {
		set TDesWeight($SeqName) $v
	    }
	    "sense" {
		set TDesSense($SeqName) $v
	    }
	    "fragment" {
		set TDesFragment($SeqName) $v
	    }
	    "score" {
		set TDesScore($SeqName) $v
	    }
	    "hydrophobicity" {
		set TDesHydro($SeqName) $v
	    }
	    default {
		set Info $v
	    }
	}
    }
    
    if {$isACGI && $isBIdRefseq} {
	# invert the two for compatibility with UniProt
	set tmp $TDesAccess($SeqName)
	set TDesAccess($SeqName) $TDesBId($SeqName)
	set TDesBId($SeqName) $tmp
    }
    
    if {! [info exists TDuGroupeDesSeqs($SeqName)]} {
	set g "Group0"
	lappend LesSeqsDuGroupe($g) $SeqName
	set TDuGroupeDesSeqs($SeqName) $g
    }

    lappend LesSequencesAssocieesClassesCanon($LifeD) $SeqName

    return

}

proc DecortiquePeptideSort {Texte {Element ""} {aT ""}} {

    if {$aT!=""} { upvar $aT T }

    set LesFloats { "Molecular weight"  "Average Residue Weight"  "Isoelectric point"}
    set LesIntegers { "Residues"  "Charged"  "Extinction coefficient"}

    foreach F $LesFloats {
	regsub -all " " $F "" VF
	set T($VF) 0.0 
    }
    foreach I $LesIntegers {
	regsub -all " " $I "" VI
	set T($VI) 0
    }
    foreach Ligne [split $Texte "\n"] {
	foreach F $LesFloats {
	    if {[regexp $F $Ligne]} {
		regsub -all " " $F "" VF
		set Valeur [FloatApres "$F =" dans $Ligne]
		set T($VF) $Valeur
	    }
	}
	foreach I $LesIntegers {
	    if {[regexp $I $Ligne]} {
		regsub -all " " $I "" VI
		set Valeur [IntegerApres "$I =" dans $Ligne]
		set T($VI) $Valeur
	    }
	}
    }
    if {$Element==""} { return [array get T] }
    if {[info exists T($Element)]} { return [set T($Element)] }
    return "-99999"

}

proc DecortiquePfSS {PfSS aPf aFstart aFstop} {

    upvar $aPf Pf
    upvar $aFstart Fstart
    upvar $aFstop Fstop

    scan $PfSS "%s %d %d" Pf Fstart Fstop
    return $PfSS

}

proc DecortiqueProfileSegments {Fichier} {


    set LesLignes [LesLignesDuFichier $Fichier]
    lappend LesLignes "(Local) PROFILESEGMENTS of: Thats_all_folks"
    
    set LesProfileSegments {}
    foreach Ligne $LesLignes {
	if {[regexp {\(Local\) PROFILESEGMENTS of} $Ligne]} {
	    if {[info exists AccessEnCours]} {
		lappend LesProfileSegments "$AccessEnCours $Quality $Length $Ratio $Gaps $From $To"
		ProfileSegment "$AccessEnCours,$Fichier" [join $LAlignement "\n"]
#		set [set PS]($AccessEnCours) [join $LAlignement "\n"]
	    }
	    set AccessEnCours [StringApres "PROFILESEGMENTS of:" dans $Ligne] 
	    if {[regexp "Thats_all_folks" $AccessEnCours]} { break }
	    set From [IntegerApres "from:" dans $Ligne]
	    set To   [IntegerApres "to:"   dans $Ligne]
	    set OnAttentPP 1
	    set YAS 0
	    set YAP 0
	    set LAlignement [list "$AccessEnCours"]
	    continue
	}
	if {[regexp {Quality\:} $Ligne]} {
	    set Quality  [FloatApres "Quality:" dans $Ligne]
	    set Length [IntegerApres "Length:"  dans $Ligne]
	    lappend LAlignement $Ligne
	    continue
	}
	if {[regexp {Ratio\:} $Ligne]} {
	    set Ratio  [FloatApres "Ratio:" dans $Ligne]
	    set Gaps [IntegerApres "Gaps:"  dans $Ligne]
	    lappend LAlignement $Ligne
	    lappend LAlignement ""
	    continue
	}
	if {$OnAttentPP && ! [regexp {\.\. *$} $Ligne]} { continue }
	set OnAttentPP 0
	if {[regexp "^P" $Ligne]} {
	    lappend LAlignement $Ligne
	    lappend LAlignement ""
	    set YAS 0
	    set YAP P
	    continue
	}
	if {[regexp "^S" $Ligne]} {
	    lappend LAlignement $Ligne
	    set YAS 1
	    set YAP 0
	    continue
	}
	if { $YAS && ! $YAP} {
	    lappend LAlignement $Ligne
	    continue
	}
    }
    return $LesProfileSegments

}

proc DecortiquePseudoTFA {file aNom aSeq aCmt} {

    upvar $aNom Nom
    upvar $aSeq Seq
    upvar $aCmt Cmt

    set Lignes [LesLignesDuFichier $file]
    lappend Lignes ">"
    set n 0
    set laseq ""
    set lecmt ""
    foreach l $Lignes {
	set l [string trim $l]
	if {$l eq ""} {continue}
	if {[string index $l 0] eq ">"} {
	    if {$laseq ne ""} {
		regsub -all " "  $laseq ""  laseq
		regsub -all {\-} $laseq "." laseq
		regsub -all {\n} $laseq ""  laseq
		lappend Nom $lenom
		lappend Seq $laseq
		lappend Cmt $lecmt
		set laseq ""
		set lecmt ""
		incr n
	    }

	    set l [string trim [string range $l 1 end]]
	    set ib [string first " " $l]
	    if {$ib == -1} {
		set ib end
	    } else {
		incr ib -1
	    }
	    set lenom [string range $l 0 $ib]
	    if {$ib ne "end"} {
		set lecmt [string trim [string range $l [expr {$ib+1}] end]]
	    }
	} else {
	    append laseq $l
	}
    }

    return $n

}

proc DecortiqueSS {ss aElt aNomChnDep aNomResDep aNomResFin aRmk} {

    
    upvar $aElt Elt $aNomChnDep NomChnDep $aNomResDep NomResDep $aNomResFin NomResFin $aRmk Rmk
   
    set sstype [string range $ss 0 3]
    switch $sstype {
	"Heli" {
	    lassign $ss Elt Type HelNm NomChnDep NomResDep TypResDep NomResFin TypResFin LongHel 
	    set Elt $Type
	    set Rmk "$HelNm"
	}
	"Shee" {
	    set SensStrd 0
	    lassign $ss Elt SheetID StrandID NomChnDep NomResDep TypResDep NomResFin TypResFin SensStrd 
	    if {$SensStrd < 0} {
		set Rmk "-$StrandID"
	    } else {
		set Rmk "$StrandID"
	    }
	}
	"Turn" {
	    lassign $ss Elt tmp TurnNm NomChnDep NomResDep TypResDep NomResFin TypResFin 
	    set Rmk " "
	}
	"Coil" {
	    lassign $ss Elt a d NomChnDep NomResDep d NomResFin 
	    set Rmk " "
	}
    }
    
    return

}

proc DecortiqueSortieRepeatMasker {RepeatVoulu Quoi {Texte ""}} {

    global DecortiqueSortieRepeatMasker

    Wup "RepeatVoulu can be All or a number"
    Wup "Quoi can be Numbers, nBases, Pourcent, Nature, Occurrences"
    

    set LesRepeats {}
    
    if { $Texte=="" } {
	if {[info exists DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)]} { return [set DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)] }
	return {}
    } else {
	if {[info exists DecortiqueSortieRepeatMasker]} { unset DecortiqueSortieRepeatMasker }
    }

    set OnAttendBasesMasked 1
    set Repeat 0
    foreach Ligne  [split $Texte "\n"] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {$OnAttendBasesMasked} {
	    if { ! [regexp "bases masked" $Ligne]} { continue }
	    set OnAttendBasesMasked 0
	    regsub "bases masked:" $Ligne "" Ligne
	    regsub "bp" $Ligne "" Ligne
	    regsub {\(} $Ligne "" Ligne
	    regsub {\)} $Ligne "" Ligne
	    scan $Ligne "%d %f" nBasesMasquees PourcentMasque
	    set DecortiqueSortieRepeatMasker(All,nBases) $nBasesMasquees
	    set DecortiqueSortieRepeatMasker(All,Pourcent) $PourcentMasque
	    continue
	}
	if {[regexp "SINEs|LINEs|LTR elements|DNA elements|Total interspersed repeats" $Ligne]} { continue }

	if {[regexp {\%} $Ligne]} {
	    if {[regexp "Small RNA" $Ligne] || [regexp "Simple repeats" $Ligne] || [regexp "Low complexity" $Ligne] } {
		scan $Ligne "%s %s %d" TypeRepeat1 TypeRepeat2 nOccurrences
		set TypeRepeat "$TypeRepeat1 $TypeRepeat2"
	    } else {
		scan $Ligne "%s %d" TypeRepeat nOccurrences
	    }
	    if { $nOccurrences != 0 } {
		regsub {\:} $TypeRepeat "" TypeRepeat
		incr Repeat
		set Nature($Repeat) $TypeRepeat
		set Occurrences($Repeat) $nOccurrences
		lappend LesRepeats "$Repeat"
	    }	   
	    continue 
	}
    }
    set DecortiqueSortieRepeatMasker(All,Numbers) $LesRepeats
    foreach R $LesRepeats {
	set DecortiqueSortieRepeatMasker($R,Nature) [set Nature($R)]
	set DecortiqueSortieRepeatMasker($R,Occurrences) [set Occurrences($R)]
    }

    return [DecortiqueSortieRepeatMasker $RepeatVoulu $Quoi]

}

proc DecortiqueStringAcSeparateurDonne {Texte} {

    set LesElmt {}
    set i 0
    set oldi 0
    if {[regexp "///" $Texte]} {
	while {[set i [string first "///" $Texte $i]]} { 
	    if {$i==-1} {
		lappend LesElmt [string trim [string range $Texte [expr [string last "///" $Texte]+3] end]] 
		break
	    }
	    lappend LesElmt [string trim [string range $Texte $oldi [expr $i-1]]]
	    incr i 3
	    set oldi $i
	}
    }
    if {![regexp "///" $Texte]} {
	lappend LesElmt [string trim $Texte]
    }
    return $LesElmt

}

proc DecortiqueUnALN {file aNom aSeq} {

    upvar $aNom LNom $aSeq TSeq

    if {[regexp {\n} $file]} {
	set Lignes $file
    } else {
	set Lignes [LesLignesDuFichier $file]
    }

    set LNom [list]
    foreach l [lrange $Lignes 1 end] {
	if {[regexp {^ } $l] || [string trim $l] eq ""} {
	    continue
	}

	regsub -all { +} [string trim $l] " " l
	lassign [split $l " "] nomori seq tmp
	set nom [BonAccess $nomori]
	if {$nom ni $LNom} {
	    lappend LNom $nom
	    set TSeq($nom) $seq
	} else {
	    append TSeq($nom) $seq
	}
    }

    foreach n [array names TSeq] {
	set TSeq($n) [BonneSequencePourAlignement [set TSeq($n)]]
    }

    return [llength $LNom]

}

proc DecortiqueUnArbre {TextePH} {

    global Abr

    if {! [info exists Abr(Liste)]} {
	set AId 1
    } else {
	set AId [expr {[lindex [set Abr(Liste)] end] + 1}]
    }
    lappend Abr(Liste) $AId

    set t [string map {"\n" ""} $TextePH]
    regsub -all {\)I?[0-9\.]+(:|;)} $t "):" t
    set t [string map {"\(" "\[CreeArbre " "," " , " ":" " " "\)" "\]"} $t]

    eval set ArbreOri [string trim $t]

    lset ArbreOri 0 root
    set TArbre "Tree-$AId"
    struct::tree $TArbre
    
    if {0} {
	puts "\n$ArbreOri\n"
	foreach {n i k} $ArbreOri {
	    puts "$i $n [lrange $k 0 1]"
	    lappend Ln $n
	    if {$i != {}} {lappend Li $i}
	}
	puts "Ln [llength $Ln] [llength [lsort -unique $Ln]]"
	puts "Li [llength $Li] [llength [lsort -unique -integer $Li]]"
	puts ""

	puts "OR Ln"
	set Lns [lsort $Ln]
	set db [list]
	set prev [lindex $Lns 0]
	foreach e [lrange $Lns 1 end] {
	    if {$e eq $prev} {lappend db $prev}
	    set prev $e
	}
	puts "[join [lsort -unique $db] \n]"
	flush stdout
    }

    $TArbre deserialize $ArbreOri

    set Arbre "ArbreNo$AId"

    set Abr($AId,TextePH) $TextePH
    set Abr(Arbre,$AId) $TArbre
    set Abr(ArbreSer,$AId) $ArbreOri
    lappend Abr(ListeArbres) $TArbre

    # Calcule largeur arbre a chaque noeud    
    foreach l [$TArbre leaves] {
	$TArbre set $l width 1
	$TArbre set $l Lleaves {}
	foreach a [$TArbre ancestors $l] {
	    $TArbre set $a width [expr {[$TArbre get $a width] + 1}]
	    $TArbre lappend $a Lleaves $l
	}
    }
    
    return $AId

}

proc DecortiqueUnMSF {TexteOuFichierMSF {aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} {OutType ""}} {

    #rR OutType peut etre ordali, msf, tfa, ou same. Dans ce cas on ne change pas la sequence 
    if {$aLesNomsDesSequencesDansLOrdre!="" } { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
    if {$aSequences!=""} { upvar $aSequences Sequences }
 
    set LesNomsDesSequencesDansLOrdre {}

    if {[regexp "\n" $TexteOuFichierMSF]} {
	set LesLignes [split $TexteOuFichierMSF "\n"]
	set FichierMSF "MSF"
    } else {
	set FichierMSF $TexteOuFichierMSF
	if {[EstUnPAB $TexteOuFichierMSF]} { set FichierMSF [GscopeFile $FichierMSF "msf"] } 
	set LesLignes [LesLignesDuFichier $FichierMSF]
    }

    if {[llength $LesLignes] < 2} { return 0 }

    set iSlashSlash [expr [lsearch -regexp $LesLignes "//"]+1]
    foreach Ligne [lrange $LesLignes $iSlashSlash end] {
	if { ! [regexp {[\.a-zA-Z]} $Ligne] } { continue }
	scan $Ligne "%s" NomSeqLu
	set iNomSeqLu [string first $NomSeqLu $Ligne]
	set NomSeqLu [string map [list | :] $NomSeqLu]
	set iBlanc [expr {$iNomSeqLu+[string length $NomSeqLu]}]
	regsub {/.*} $NomSeqLu "" NomSeqLu
	set NomSeq $NomSeqLu
	set NomSeq [BonAccess $NomSeq]
	set BoutSequence [string map [list " " ""] [string range $Ligne $iBlanc end]]
	set BoutSequence [BonneSequencePourAlignement $BoutSequence $OutType]
	if { ! [info exists DejaVu($NomSeq)]} {
	    lappend LesNomsDesSequencesDansLOrdre $NomSeq
	}
	if {$aSequences!=""} {
	    if { ! [info exists DejaVu($NomSeq)]} {
		set Sequences($NomSeq) $BoutSequence
 	    } else {
		append Sequences($NomSeq) $BoutSequence
	    }
	}
	set DejaVu($NomSeq) 1
    }
    return [llength $LesNomsDesSequencesDansLOrdre]
#rR le reste est obsolete
#    if {$aSequences!=""} {
#	set Lns [array get Sequences]
#	Log $Lns
#	unset LesNomsDesSequencesDansLOrdre
#	if {[info exists Sequences]} { unset Sequences }
#	foreach {n s} $Lns {
#	    set n [BonAccess $n]
#	    set s [BonneSequence $s]
#	    set Sequences($n) $s
#	}
#	set LesNomsDesSequencesDansLOrdre [array names Sequences]
#    }
#    return [llength $LesNomsDesSequencesDansLOrdre]

}

proc DecortiqueUnMacsimXml {FichierOuTexteXML} {

    # Repompe de DecortiqueUnMacsimXml2 qui est lui-même
    # Repompe de rR pour parsing de xml
    # fait tout d'un coup, plus de routines separées pour chaque chose
    
    # Initialisation des strings, listes et tableaux. Et mise en global 
    set MacsimsVariables [MacsimsVariables "Initialise"]
    lassign $MacsimsVariables LesL LesT
    foreach L $LesL { global $L }
    foreach T $LesT { global $T }

    
    if {[file exists $FichierOuTexteXML]} {
	set MacsimXml [ContenuDuFichier $FichierOuTexteXML]
	set FromOrdalie 1
    } else {
	set MacsimXml $FichierOuTexteXML
	set FromOrdalie 0
    }
    
    foreach e {eukaryota bacteria archaea viruses undefined} {
	set LesSequencesAssocieesClassesCanon($e) {}
    }
    
    # Caution !! MacsimXml is not a list, but a text string !!
    set DocMacsim   [dom parse $MacsimXml]
    set NoeudMacsim [$DocMacsim documentElement]
    

    unset -nocomplain LesSeqsDuGroupe
    
    # alignment header
    set NoeudAli [$NoeudMacsim selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
    set AlnNote  [$NoeudAli selectNodes "string(aln-note)"]
    set TColScore(Names) [list]
    
    foreach NoeudLigne [$NoeudAli childNodes] {
	set NodeName [$NoeudLigne nodeName]
	if {[regexp {aln\-} $NodeName]} {
	    continue
	}
	if {[regexp {column\-} $NodeName]} {
	    DecortiqueColumnScore $NoeudLigne
	} else {
	    DecortiqueNoeudXml $NoeudLigne TabSF
	}
    }

    # Verifie qu'on n'a pas sequences en double !
    set Ltmp $LNOrdali
    set LNOrdali [list]
    foreach n $Ltmp {
	if {[string trim $n] eq ""} {continue}
	lappend LNOrdali $n
    }
    if {[llength $LNOrdali] != [llength [lsort -unique $LNOrdali]]} {
	set ld [DonneDoublons $LNOrdali]
	FaireLire "Beware !\nSeveral sequences have the same name :[join $ld]"
    }
    
    # XML est indexe par le seq-name. 
    # Ramene tous les tableaux a une indexation par
    # accession.
    #IndexationParAccess
    
    # premier grp = GroupeToutLeMonde
    InitPremierGroupe
    
    # Ajoute groupes du xml
    set Lg [ReordonneGroupes [array names LesSeqsDuGroupe]]
    if {[llength $Lg] > 1} {
	set LNDG [concat $LNDG $Lg]
	foreach g $Lg {
	    set LesSeqsDuGroupe($g) [lunique [set LesSeqsDuGroupe($g)]]
	    set SDG($g) [set LesSeqsDuGroupe($g)]
	}
    }

    $DocMacsim delete

    return $MacsimsVariables

}

proc DecortiqueUnNEXUS {file aNom aSeq} {

    upvar $aNom LNom $aSeq TSeq

    if {[regexp {\n} $file]} {
	set Lignes $file
    } else {
	set Lignes [LesLignesDuFichier $file]
    }

    set LNom [list]
    # 1st line NEXUS
    foreach l [lrange $Lignes 1 end] {
	set l [string trim $l]
	if {[regexp -nocase {^begin} $l]} {
	    set what [lindex [split $l " "] 1]
	}
   }

    return

}

proc DecortiqueUnPDB {Fichier {LaMolId ""}} {

    global Defauts
    
    if {! [info exists Defauts]} {LesDefauts}
    if {[llength $Fichier] == 1} {
	if {! [regsub {\.} $Fichier "" tmp]} {
	    set lignes [RecupereUnFichierSurWeb $Fichier]
	} else {
	    set lignes [LesLignesDuFichier $Fichier]
	}
    } else {
	set lignes $Fichier
    }
    set MolId [DonneIdDeAccessPDB $LaMolId]
    
    set lignesPDB [ExtraitLignesAtomesDuPDB $lignes]
    if {$MolId eq ""} {set MolId [file rootname [file tail $Fichier]]}
    
    global PDB_[set MolId]_Header
    global PDB_[set MolId]_Site
    
    set Header [ExtraitHeadDuPDB $lignes]
    set PDB_[set MolId]_Header $Header
    
    if {[llength $lignesPDB] == 0} {return 0}
    
    # Traite chaines apres chaines
    set Vraia 0
    set Lter [lsearch -regexp -all $lignesPDB {^TER}]
    set Lter [linsert $Lter 0 "0"]
    set Lter [linsert $Lter end "end"]

    set LterAr [lrange $Lter 1 end]
    set d [lindex $Lter 0]
    foreach f $LterAr {
	set deb $d
	set fin $f
	if {$deb != 0} {incr deb}
	if {$fin ne "end"} {incr fin -1}
	set LLignesChn [lrange $lignesPDB $deb $fin]
	if {$LLignesChn == {}} {
	    set d $f
	    continue
	}
	if {[lsearch -regexp $LLignesChn {^ATOM  }] != -1} {set polymer 1} {set polymer 0}
	set Yaa [LectureDeChainePDB $LLignesChn $MolId]
	if {$Yaa} {set Vraia 1}
	set d $f
    }
    
    set lsite [ExtraitSiteActifDuPDB $Header]
    if {$lsite != {}} {array set PDB_[set MolId]_Site $lsite}
    
    # Remet chaine a si elle n'existe pas
    global PDB_[set MolId]_ChnIdn
    if {0 && ! $Vraia} {
	set c [lindex [set PDB_[set MolId]_ChnIdn] 0]
	foreach n {AtmXYZ AtmBQ NomAtm NomRes NmrRes} {
	    global PDB_[set MolId]_${n}
	    set PDB_[set MolId]_${n}(a) [set PDB_[set MolId]_${n}($c)]
	}
	lappend PDB_[set MolId]_ChnIdn "a"
    }
    
    return 1

}

proc DecortiqueUnRSF {TexteOuFichierRSF {aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} {aTabRSF ""} {LesClefs ""} {AvecBornesLocales ""}} {

    if {$aLesNomsDesSequencesDansLOrdre!=""} { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
    if {$aSequences                    !=""} { upvar $aSequences Sequences }
    if {$aTabRSF                       !=""} { upvar $aTabRSF TabRSF }

    #rR J'ai changé le défaut 2015/03/31
    if {$AvecBornesLocales!=0} { set AvecBornesLocales 1 } else { set AvecBornesLocales 0 } 
 
    set LesNomsDesSequencesDansLOrdre {}

    if {[regexp "\n" $TexteOuFichierRSF]} {
	set LesLignes [split $TexteOuFichierRSF "\n"]
	set FichierRSF "RSF"
    } else {
	set FichierRSF $TexteOuFichierRSF
	set LesLignes [LesLignesDuFichier $FichierRSF]
    }

    if {[llength $LesLignes] < 2} { return 0 }

    if {$LesClefs==""} { set LesClefs [list "name" "sequence" "type" "group" "feature" "descrip" "creator"] }
    set ClefAvecListe(feature) 1
    foreach Clef $LesClefs {
	set ClefVoulue($Clef) 1
    }

    foreach Ligne $LesLignes {
	if {[regexp {^!!RICH_SEQUENCE}      $Ligne]} { continue }
	if {[regexp {^(\{|\}|\.\.)}         $Ligne]} { continue }
	if { ! [regexp -nocase {[\.a-z0-9]} $Ligne]} { continue }
	if {[regexp  -nocase {^[a-z]} $Ligne]} {
	    scan $Ligne "%s" Clef
	    set Clef [string tolower $Clef]
	    set Valeur [StringSuivant "$Clef " dans $Ligne]
	    if {$Clef=="name"} {
		#lm ajoute BonAccess et le string trim
		set NameCourant [BonAccess [string trim $Valeur]]
		lappend LesName $NameCourant
		set NumeroDeClef 0
	    }
	    if { ! [info exists ClefVoulue($Clef)]} { continue }
	    if { ! [info exists ClefDejaVue($NameCourant,$Clef)]} {
		set TabRSF($NameCourant,ListeDes,$Clef) {}
	    }
	    if {[info exists ClefAvecListe($Clef)]} {
		incr NumeroDeClef
		set ClefCourante "${Clef}_$NumeroDeClef"
	    } else {
		set ClefCourante $Clef
	    }
	    lappend TabRSF($NameCourant,ListeDes,$Clef) $ClefCourante
	    set ClefDejaVue($NameCourant,$Clef) 1
	    set TabRSF($NameCourant,$ClefCourante) {}
	    regsub $Clef $Ligne "" Ligne
	}
	if { ! [info exists ClefVoulue($Clef)]} { continue }
	set Valeur [string trim $Ligne]
	if {$ClefCourante=="sequence"} {
	    set Valeur [string trim $Valeur]
	    if { ! [info exist TabRSF($NameCourant,$ClefCourante)]} { set TabRSF($NameCourant,$ClefCourante) "" } 
	    append TabRSF($NameCourant,$ClefCourante) $Valeur
	} else {
	    lappend TabRSF($NameCourant,$ClefCourante) $Valeur
	}
	continue
    }
    set TabRSF(LesTypesDeFeatures) {}
    foreach Name $LesName {
	set Seq [join $TabRSF($Name,sequence) ""]
	set Seq [BonneSequencePourAlignement $Seq] ;#rR sur demande de Luc 2012/12/18			
	set Sequences($Name) $Seq
	set TabRSF($Name,LesTypesDeFeatures) {}

	if { ! [info exists TabRSF($Name,ListeDes,feature)]} {
	    set TabRSF($Name,ListeDes,feature) {}
	}
	set FeatureSequence [FeatureSequence $Seq]
	foreach TDF $FeatureSequence {
	    scan $TDF "%s %d %d %d %d" T D F DL FL
	    if { ! [regexp "^Seq" $T]} { continue } ;#rR on n'affiche que la sequence et pas les gaps !!!!!!!
	    set LastFeature [lindex $TabRSF($Name,ListeDes,feature) end]
	    if {$LastFeature==""} {
		set Feature "feature_1"
	    } else {
		set NLast 0
		regexp {feature_([0-9]+)} $LastFeature Match NLast
		incr NLast
		set Feature "feature_$NLast"
	    }
	    lappend TabRSF($Name,ListeDes,feature) $Feature
	    if {[regexp "^Before" $T]} { set C [CouleurSeqlab White] }
	    if {[regexp "^After"  $T]} { set C [CouleurSeqlab White] }
	    if {[regexp "^Seq"    $T]} { set C [CouleurSeqlab Grey80] }   ;#rR il y avait 50
	    if {[regexp "^Gap"    $T]} { set C [CouleurSeqlab Grey90] }   ;#rR il y avait 80
	    set TabRSF($Name,$Feature) [list "$D $F $C square solid SEQUENCE" "FT SEQUENCE $DL $FL  $T"]
	}

	foreach Feature [set TabRSF($Name,ListeDes,feature)] {
	    set DonneesDuFeature [lindex [set TabRSF($Name,$Feature)] 0]
	    scan $DonneesDuFeature "%d %d %d %s %s %s" D F C Forme EmptyFull FeatureType
	    set Couleur [CouleurSeqlab $C]
	    if { ! [info exists DejaVuCeTypeDeFeature($FeatureType)]} {
		set DejaVuCeTypeDeFeature($FeatureType) 1
		lappend TabRSF(LesTypesDeFeatures) $FeatureType 
	    }
	    set SequencePointee [set Sequences($Name)]
	    if {$AvecBornesLocales} {
		set BornesLocales [BornesLocales $SequencePointee $D $F]
	    } else {
		set BornesLocales "$D $F"
	    }
	    scan $BornesLocales "%d %d" DL FL
	    if { ! [info exists TabRSF($Name,Type,$FeatureType)]} {
		            set TabRSF($Name,Type,$FeatureType) {}
		lappend TabRSF($Name,LesTypesDeFeatures) $FeatureType
	    }
	    lappend TabRSF($Name,Type,$FeatureType) "$D $F $DL $FL $Couleur $Forme $EmptyFull  [lrange [set TabRSF($Name,$Feature)] 1 end]"
	}
    }
    set LesNomsDesSequencesDansLOrdre $LesName
    set TabRSF(LesNomsDesSequences) $LesNomsDesSequencesDansLOrdre
    return [llength $LesName]

}

proc DecortiqueUnTFA {file aNom aSeq} {

    upvar $aNom Nom $aSeq Seq
    
    if {[file exists $file]} {
	set Lignes [LesLignesDuFichier $file]
    } elseif {[string first "\n" $file] != -1} {
	# texte brut
	set Lignes [split $file "\n"]
    } elseif {[llength $file] > 1} {
	set Lignes $file
    }

    lappend Lignes ">"
    set n 0
    set laseq ""
    foreach l $Lignes {
	set l [string trim $l]
	if {$l eq ""} {continue}
	if {[string index $l 0] eq ">"} {
	    if {$laseq ne ""} {
		set laseq [BonneSequencePourAlignement $laseq]
		set lenom [BonAccess $lenom]
		lappend Nom $lenom
		set Seq($lenom) $laseq
		set laseq ""
		incr n
	    }

	    set l [string trim [string range $l 1 end]]
	    set ib [string first " " $l]
	    if {$ib == -1} {
		set ib end
	    } else {
		incr ib -1
	    }
	    set lenom [string range $l 0 $ib]
	} else {
	    append laseq $l
	}
    }

    return $n

}

proc DecortiqueUnXml {f anom aSeq} {


    #package require tdom

    upvar $aSeq Sequences
    upvar $anom LNOrdali

    FaireAttendre .pxml "Please wait ...\nParsing macsim file ..."

    if {$f eq ""} {return 0}
    set LXml {}
    if {[regexp "\n" $f]} {
	set LXml [join $f "\n"]
    } else {
	if {[file exists $f]} {
	    set LXml [ContenuDuFichier $f]
	}
    }
    if {$LXml eq {} } {return 0}

    set Id  [dom parse $LXml]
    set RId [$Id documentElement]
    set LNoeudsNoms [$RId selectNodes //seq-name]
    set Lseq [$RId selectNodes //seq-data]

    set LNOrdali {}
    foreach tn $LNoeudsNoms ts $Lseq {
	set n [$tn selectNodes string(.)]
	set n [string trim $n]

	set s [$ts selectNodes string(.)]
	set s [string map [list "-" "." "~" "." "\n" "" " " ""] $s]
	set s [string toupper $s]

	set Sequences($n) $s
	lappend LNOrdali $n
    }

    FaireLaSuite .pxml

    return $Id

}

proc DecortiqueUnXml2 {FichierOuTexteXML} {

    # Repompe de rR pour parsing de xml
    # fait tout d'un coup, plus de routines separe pour chaque chose
    
    global LesSequencesAssocieesClassesCanon
    global LNDG SDG
    global LesSeqsDuGroupe
    global LNOrdali Sequences TDesSeqnames
    global TDuGroupeDesSeqs
    global TabSF
    global NoeudMacsim DocMacsim
    global AlnName AlnScore AlnNote TColScore

    if {[file exists $FichierOuTexteXML]} {
	set MacsimXml [ContenuDuFichier $FichierOuTexteXML]
	set FromOrdalie 1
    } else {
	set MacsimXml $FichierOuTexteXML
	set FromOrdalie 0
    }
    
    foreach e {eukaryota bacteria archaea viruses undefined} {
	set LesSequencesAssocieesClassesCanon($e) {}
    }
    
    # Caution !!
    # MacsimXml is not a list, but a text string !!
    set DocMacsim   [dom parse $MacsimXml]
    set NoeudMacsim [$DocMacsim documentElement]
    
    # Initialise arrays for features
    InitInfoArrays

    unset -nocomplain LesSeqsDuGroupe
    
    # alignment header
    set NoeudAli [$NoeudMacsim selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
    set AlnNote  [$NoeudAli selectNodes "string(aln-note)"]
    set TColScore(Names) [list]
    
    foreach NoeudLigne [$NoeudAli childNodes] {
	set NodeName [$NoeudLigne nodeName]
	if {[regexp {aln\-} $NodeName]} {
	    continue
	}
	if {[regexp {column\-} $NodeName]} {
	    DecortiqueColumnScore $NoeudLigne
	} else {
	    DecortiqueNoeudXml $NoeudLigne TabSF
	}
    }

    # Verifie qu'on a pas sequences en double !
    set Ltmp $LNOrdali
    set LNOrdali [list]
    foreach n $Ltmp {
	if {[string trim $n] eq ""} {continue}
	lappend LNOrdali $n
    }
    if {[llength $LNOrdali] != [llength [lsort -unique $LNOrdali]]} {
	set ld [DonneDoublons $LNOrdali]
	FaireLire "Beware !\nSeveral sequences have the same name :[join $ld]"
    }
    
    # premier grp = GroupeToutLeMonde
    InitPremierGroupe
    
    # Ajoute groupes du xml
    set Lg [ReordonneGroupes [array names LesSeqsDuGroupe]]
    if {[llength $Lg] > 1} {
	set LNDG [concat $LNDG $Lg]
	foreach g $Lg {
	    set LesSeqsDuGroupe($g) [lunique [set LesSeqsDuGroupe($g)]]
	    set SDG($g) [set LesSeqsDuGroupe($g)]
	}
    }

    $NoeudMacsim delete
    $DocMacsim delete
    unset -nocomplain DocMacsim NoeudMacsim

    return 1

}

proc DecortiqueUneFeature {f as ae ac ar an {acs ""}} {

    upvar $as s
    upvar $ae e
    upvar $ac c
    upvar $ar r
    upvar $an n
    upvar $acs cs

    lassign $f fs s fp e fc c fo r fn n fcs cs

    return

}

proc DecortiqueXmlAgent {f} {

    global LNOrdali LSOrdali Sequences TColScore

    set LNOrdali {} ; set LSOrdali {}
    unset -nocomplain Sequences
    set Ll [LesLignesDuFichier $f]

    # noms
    set Lnom [lsearch -all -inline -glob $Ll "\= 0} {
	set NColParPage [expr {int($dimx/$LargeurLettre) + 1}]
	set NPagesX     [expr {int($XLen/$NColParPage)+1}]
    } else {
	set NColParPage $XLen
	set NPagesX 1
    }

    return [list $NPagesX $NColParPage]

}

proc DecoupeYEnPages {dimy} {

    global NomNomSeq PrmPrt Sequences

    set FonteMetrics  [font metrics FntPrt]
    set HauteurLettre [lindex $FonteMetrics 5]
    set LargeurLettre [font measure FntPrt "Z"]

    set XLen $PrmPrt(LgNoms)
    set NSeqs $PrmPrt(NbSeqs)
    if {$dimy >= 0} {
	set NSeqParPage [expr {int($dimy/$HauteurLettre) + 1}]
	set NPagesY     [expr {int($NSeqs/$NSeqParPage+1)}]
    } else {
	set NPagesY 1
	set NSeqParPage $NSeqs
    }
    set DecalX      [expr {$XLen*$LargeurLettre}]

    return [list $NPagesY $NSeqParPage $DecalX]

}

proc DecrValFromStack {{OtherStack ""} {ValueForIncr ""}} {


    if {$ValueForIncr==""} { set ValueForIncr -1 }

    set V [ValFromStack $OtherStack]
    incr V $ValueForIncr
    PullFromStack $OtherStack
    PushOnStack $V $OtherStack 
    return $V

}

proc DecrisLaLigne {W x y {Efface ""}} {


    regsub ".list" $W ".message" M
    catch {destroy $M}

    if {$Efface!=""} {
	return ""
    }

    set Ligne [$W get @$x,$y]
    
    set Access ""
    set AccessBis ""
    scan $Ligne "%s %s" Access AccessBis

    set Descr [LeDescriptif $Access]
    if {$Descr=="" || [regexp "no description" $Descr]} {
	set Descr [LeDescriptif $AccessBis]
    }
    if {$Descr=="" || [regexp "no description" $Descr]} { return "" }

    set OX [ChampDuDescriptif $Descr OX]
    if {[regexp " " $OX]} {
	foreach TaxId [split $OX " "] {
	    set OS [Tax $TaxId]
	    append Descr "($TaxId=$OS )"
	}
    }

    regsub -all {[A-Z][A-Z]:} $Descr "\n& " Texte

    message $M -borderwidth 3 -font {Courier 10} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    place $M -x 10 -y $y -anchor w

}

proc DedicatedBlastDatabase {{Rep ""}} {

    global DedicatedBlastDatabase
    if {$Rep=="Reset"} { set DedicatedBlastDatabase "" ; return "" }
    if {$Rep==""} {
	if {[info exists DedicatedBlastDatabase]} { return $DedicatedBlastDatabase }
    }
    set DedicatedBlastDatabase $Rep
    return $DedicatedBlastDatabase

}

proc Dedouble {Arbre aG ax aD ay} {

    upvar $aG G
    upvar $ax x
    upvar $aD D
    upvar $ay y

    if {[llength $Arbre] == 3} {
	set Arbre [list  [lindex $Arbre 0]  [lindex $Arbre 2]  [lindex $Arbre 1]  [lindex $Arbre 2]  ]
    }

    set G [lindex $Arbre 0]
    set x [lindex $Arbre 1]
    set D [lindex $Arbre 2]
    set y [lindex $Arbre 3]

}

proc DefDeAcc {AccessOuId Banques {Option EntreeComplete} {Link NoLink}} {


    Wup "Pour pouvoir recuperer la definition la taille par getz ..."

    if {$Option == "EntreeComplete"} {
	set option "-e"
    } elseif {$Option == "IdDef"} {
	set option "-f \"id des\""
    } elseif {$Option == "AccDef"} {
	set option "-vf \"acc des\""
    } elseif {$Option == "Def"} {
	set option "-vf \"des\""
    } elseif {$Option == "Id"} {
	set option "-vf \"id\""
    } elseif {$Option == "Taille"} {
	set option "-vf \"sl\""
    } elseif {$Option == "Acc"} {
	set option "-f \"acc\""
    }
    
    set LeType [list "acc" "id" "prd" "gid"] 
    foreach Type $LeType {
	if {$Link   == "NoLink"} {
	    set Commande "getz $option \"\\\[$Banques-$Type: $AccessOuId\\\]\""
	} else {
	    set Commande "getz $option \"\\\[$Banques-$Type: $AccessOuId\\\] \\\> $Link \""
	}
	catch {set GetzOut [eval exec $Commande]} Message
	if {![info exists GetzOut] || $GetzOut == ""} {continue}
	return $GetzOut
    }
    return ""

}

proc DefDesNms {{access ""}} {


    set Fich "[RepertoireDuGenome]/fiches/NmEnStock"
    set Ligne [LesLignesDuFichier $Fich]
    set BonNM 0
    set comp 0
    set lesdefs ""
    foreach L $Ligne {
	if {[regexp {^LOCUS } $L]} {
	    set NM [StringApres "LOCUS" dans $L]
	   # puts $NM
	    if {$NM == $access} {
		set BonNM 1
		continue
                  #change de ligne
	    }
	}
	if {$BonNM} {
	    if {[regexp {^DEFINITION } $L]} {
		append lesdefs $L
		#puts "$lesdefs=>1 ligne"
		set comp 1
		continue
	    }
	    if {$comp == 1} {
		if {[string index $L end]=="."} {
		    regsub {[ ]+} $L " " L
		    append lesdefs $L
		 #   puts "$lesdefs=>1 et 2lignes"
		}
	    }
	    puts "$NM=$access => $lesdefs"
	    break
	}

    }
    return

}

proc DefProt {LesNoms} {

    set Liste [split $LesNoms " "]
    foreach Nom $Liste {
	set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access]
	set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition]
	Espionne "$Nom $DefBestProtHuman"
    }

}

proc DefautOptionsDrawBlast {w} {

    AskOptionsDeDrawBlast set $w NbSubjectMax                  1.e200
    AskOptionsDeDrawBlast set $w ExpectMax                     1.e200
    AskOptionsDeDrawBlast set $w IdMin                         0.0
    AskOptionsDeDrawBlast set $w TailleMaxDUneRegionNonAlignee 1.e200
    return

}

proc DefineBestMsfClRasPipe {file} {


    set Ll   [LesLignesDuFichier $file]
    
    set Vd ""
    set Vr ""
    
    foreach l $Ll {
	if {[regexp "clustal" $l]} {
	    set Vd [string range $l [expr [string first ":" $l] +2] end]
	}
	if {[regexp "rascal" $l]} {
	    set Vr [string range $l [expr [string first ":" $l] +2] end]
	}
    }
    
    if {$Vd == "undetermined"} {set Vd -999.}
    if {$Vr == "undetermined"} {set Vr -999.}
    
    set max [Maxi $Vd $Vr]
    if {$max == -999.} {return "no file"}
    if {$max == $Vd} {
	return "Msf"
    } else {
	return "Rascal"
    }    

}

proc DefineBestMsfPipe {file {chx auto}} {

    
    # choisi leon si normd > 0.5
    # sinon prend le meilleur NorMD
    
    if {$chx ne "auto"} {return $chx}

    set Ll [LesLignesDuFichier $file]
    
    set Vd ""
    set Vr ""
    set Vl ""
    
    foreach l $Ll {
	if {[regexp "clustal" $l]} {
	    set Vd [string range $l [expr [string first ":" $l] +2] end]
	}
	if {[regexp "rascal" $l]} {
	    set Vr [string range $l [expr [string first ":" $l] +2] end]
	}
	if {[regexp "leon" $l]} {
	    set Vl [string range $l [expr [string first ":" $l] +2] end]
	}
    }
    
    if {$Vd == "undetermined"} {set Vd -999.}
    if {$Vr == "undetermined"} {set Vr -999.}
    if {$Vl == "undetermined"} {set Vl -999.}
    
    if {$Vl <= 0.5} {
	set max [Maxi $Vl $Vr]
	set max [Maxi $Vd $max]
	if {$max == -999.} {return "no file"}
	if {$max == $Vl} {
	    return "Leon"
	} elseif {$max == $Vr} {
	    return "Rascal"
	} else {
	    return "Msf"
	}
    }
    
    return "Leon"

}

proc DefineChildsWithGold {} {

    global LAllIds Tx TaxRoot

    foreach n $LAllIds {
	set nC 0
	set toto [list]
	foreach c $Tx(Child,$n) {
	    if {$c == $n} {continue}

	    if {$Tx(NbComp,$c)} {
		incr nC
		lappend toto $c
	    }
	}
	set Tx(ChildD,$n) $toto
	set Tx(NbChildD,$n) $nC
    }
    
    return

}

proc DefineGapThreshold {nseq} {

    set thr [expr {int($nseq*$::Defauts(PCThrGap))}]
    if {$thr < $::Defauts(MinThrGap)} {
	set thr $::Defauts(MinThrGap)
    }

    return $thr

}

proc DefineGroupForNewSeq {Lseq aT} {

    upvar $aT T
    global GroupeDeLaSequence SDG

    foreach seq $Lseq {
	set Lk [list]
	lappend Lk {*}[array names T "$seq,*"]
	lappend Lk {*}[array names T "*,$seq"]
	set pmax -1. ; set kmax ""
	set ix [lsearch -exact $Lk "$seq,$seq"]
	set Lk [lreplace $Lk $ix $ix]
	foreach k $Lk {
	    lassign [split $k ,] n1 n2
	    if {$n1 in $Lseq && $n2 in $Lseq} {
		continue
	    }
	    set pci [lindex [set T($k)] 0]
	    if {$pci > $pmax} {
		set kmax $k
		set pmax $pci
	    }
	}
	# take the name of the closest sequence
	lassign [split $kmax ,] n1 n2
	if {$n1 eq $seq} {set close $n2} {set close $n1}
	set g [set GroupeDeLaSequence($close)]
	lappend SDG($g) $seq
	set GroupeDeLaSequence($seq) $g
	puts "Group for $seq : $g"
	puts "closest $close, % id. [format %5.1f [expr {100.*$pmax}]]\n"
    }

    return

}

proc DefineInternalNodes {n nBrothers} {

    global Tx TaxRoot

    set nChilds $Tx(NbChildD,$n)
    if {$nChilds == 0 || $n == $TaxRoot} {
	set Tx(isInt,$n) 0
	set Tx(ShowInt,$n) 1
    } elseif {$nBrothers == 1 && $nChilds == 1} {
	set Tx(isInt,$n) 1
	set Tx(ShowInt,$n) 0
    } else {
	set Tx(isInt,$n) 0
	set Tx(ShowInt,$n) 0
    }

    foreach c $Tx(ChildD,$n) {
	DefineInternalNodes $c $nChilds
    }

    return

}

proc DefineLabels2Show {{mol ""}} {

    
    if {$mol eq ""} {
	set Lmol $::StrucAVoir
    } else {
	set Lmol $mol
    }

    set txt [list]
    foreach n $Lmol {
	set pdb [DonneIdDeAccessPDB $n]
	set l [::$pdb AllLabels]
	if {$l != [list]} {
	    lappend txt {*}$l
	}
    }

    set ::pgl(Text2Show) $txt

    return

}

proc DefineLegend {AId {quoi define}} {

    global Abr
    
    if {$quoi eq "clear"} {
	set Abr($AId,LegBoot)  1
	set Abr($AId,LegCoul)  0
	set Abr($AId,LegGap)   1
	set Abr($AId,LegSites) 1
	set Abr($AId,LegText)  ""
	set Abr($AId,Legend) ""
    }
    
    if {! $Abr($AId,AddLeg)} {
	$Abr($AId,PAD) delete Legend
	return
    }

    if {$Abr($AId,Legend) ne ""} {
	ShowTreeLegend $AId
	return
    }

    set w .legend
    toplevel $w
    wm title $w "Tree Caption"
    wm iconname $w "Caption"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix

    set wft $w.ftitre
    frame $wft
    grid $wft -row 0 -column 0 -sticky ew -padx 10 -pady 10
    label $wft.titre  -text "Legend :"  -font "Helvetica 14 bold"  -anchor w -justify left
    label $wft.exp -text "Select the elements to be displayed as the tree caption"  -anchor w -justify left
    grid $wft.titre -row 0 -column 0 -sticky ew -pady {5 10}
    grid $wft.exp   -row 1 -column 0 -sticky ew

    set wfe $w.felt
    frame $wfe
    label $wfe.ltxt  -text "Caption :"  -anchor w -justify left
    set Abr($AId,LegWText) $wfe.text
    text $wfe.text  -relief flat  -bd 2 -relief sunken  -background white  -width 30 -height 3
    checkbutton $wfe.gap -relief flat  -anchor w -justify left  -text "gap handling"  -onvalue 1  -offvalue 0  -variable Abr($AId,LegGap)
    checkbutton $wfe.nst -relief flat  -anchor w -justify left  -text "number of sites"  -onvalue 1  -offvalue 0  -variable Abr($AId,LegSites)
    checkbutton $wfe.boot  -relief flat  -anchor w -justify left  -text "number of bootstrap and threshold"  -onvalue 1  -offvalue 0  -variable Abr($AId,LegBoot)
    checkbutton $wfe.coul  -relief flat  -anchor w -justify left  -text "groups colors"  -onvalue 1  -offvalue 0  -variable Abr($AId,LegCoul)
    grid $wfe.ltxt -row 0 -column 0 -sticky w
    grid $wfe.text -row 1 -column 0 -sticky ew
    grid $wfe.gap  -row 2 -column 0 -sticky ew
    grid $wfe.nst  -row 3 -column 0 -sticky ew
    grid $wfe.boot -row 4 -column 0 -sticky ew
    grid $wfe.coul -row 5 -column 0 -sticky ew

    grid $wfe -row 1 -column 0 -sticky ew -padx 10 -pady 5
    grid columnconfig $wft all -weight 1

    set wfb $w.fbout
    frame $wfb
    button $wfb.bok  -background green1  -text " OK "  -command [list ShowTreeLegend $AId draw]
   button $wfb.bdis  -background red  -text "Dismiss"  -command [list ShowTreeLegend $AId dismiss]
    grid $wfb.bdis -row 0 -column 0 -sticky w
    grid $wfb.bok  -row 0 -column 1 -sticky e
    grid $wfb -row 2 -column 0 -sticky ew -padx 10 -pady 10
    grid columnconfig $wfb all -weight 1

    update idletasks
    FenetreAuCentre $w
    set oldGrab [grab current .]
    grab $w

    tkwait window $w

    if {$oldGrab ne ""} {
	grab $oldGrab
    }

    return

}

proc DefineNewFeature {} {

    global EFeat

    set Lp [$::NomTextSeq tag ranges slct]
    if {$Lp == {} } {
	FaireLire "Beware !\nYou should first select a region !"
	return
    }
    
    set Lx1x2 "Select"
    foreach {p1 p2} $Lp {
	lassign [split $p1 .] y1 x1
	lassign [split $p2 .] y2 x2
	incr x2 -1
	
	lappend Lx1x2 [list $x1 $x2]
    }

    set EFeat(Lcolor) "Select"
    set EFeat(Lscore) "Select"
    set EFeat(Lnote)  "Select"
    set EFeat(Lx1x2)  $Lx1x2

    WindowEditItem newf

    return

}

proc DefineNewObj {lamol {obj ""}} {

    global NwOj NwOjR

    set NwOj(Mol) $lamol
    set mol "::$lamol"
    set NwOj(Toplevel) .nwoj
    if {[winfo exists $NwOj(Toplevel)]} {
	raise $NwOj(Toplevel)
	return
    }

    set OldGrab [grab current]
    set tpl $NwOj(Toplevel)
    toplevel $tpl -bg black
    wm title $tpl "New Object ..."
    wm iconname $tpl "New Obj"
    wm protocol $tpl WM_DELETE_WINDOW KillParLaCroix

    set top $tpl.f
    frame $top -bg black
    grid $top -row 0 -column 0 -sticky news -padx 10 -pady 10
    grid columnconfig $tpl 0 -weight 1
    grid rowconfig    $tpl 0 -weight 1

    # frame for obj name
    frame $top.fnames -bg black
    if {$obj ne ""} {
	set text1 "Object : "
    } else {
	set text1 "New Object : "
    }
    label $top.fnames.lobj  -text $text1  -anchor w -justify left  -relief flat -highlightthickness 0  -bg black -fg white
    set NwOj(Obj) "objname"
    set NwOj(ObjEntry) $top.fnames.eobj
    entry $top.fnames.eobj  -textvariable NwOj(Obj)  -bg black -fg white
    label $top.fnames.lmol  -text "in Molecule $mol"  -anchor w -justify left  -relief flat -highlightthickness 0  -bg black -fg white
    grid $top.fnames.lobj -row 0 -column 0 -sticky w -padx 2
    grid $top.fnames.eobj -row 0 -column 1 -sticky ew
    grid $top.fnames.lmol -row 0 -column 2 -sticky w
    
    # frame for chain selection
    frame $top.fchains -bg black -relief groove -bd 2
    label $top.fchains.lchn  -text "Chain :"  -anchor w -justify left  -relief flat -highlightthickness 0  -bg black -fg white
    grid $top.fchains.lchn -row 0 -column 0 -sticky w -padx 2
    set col 1
    set Lchn [lsort [$mol _chains]]
    foreach chn $Lchn {
	ttk::radiobutton $top.fchains.r$chn  -style vdx.TRadiobutton  -text "$chn"  -value "$chn"  -variable NwOj(Chain)  -command CanvasDeChaine
	grid $top.fchains.r$chn -row 0 -column $col -ipadx 2
	incr col
    }
    set NwOj(ChainCou) ""
    set NwOj(ChType) "polymer"
    label $top.fchains.ltyp  -text "of type "  -anchor w -justify left  -relief flat -highlightthickness 0  -bg black -fg white
    ttk::radiobutton $top.fchains.typo  -style vdx.TRadiobutton  -text "Polymer"  -value "polymer"  -variable NwOj(ChType)
    ttk::radiobutton $top.fchains.tyli  -style vdx.TRadiobutton  -text "ligand"  -value "ligand"  -variable NwOj(ChType)
    grid $top.fchains.ltyp -row 1 -column 1 -columnspan 2 
    grid $top.fchains.typo -row 1 -column 3 -columnspan 3 -padx {1 2}
    grid $top.fchains.tyli -row 1 -column 6 -columnspan 3 -padx {2 1}

    # Inits
    set NwOj(Colors) [list None "Feature Color" red blue green yellow magenta cyan orange pink brown "more ..."]
    set wdtC [PlusLongEltDe $NwOj(Colors)]
    set NwOj(Types) [list "None" "Atoms" "Ca/P Trace" "Ribbon" "Ribbon + Atoms" "Ribbon + CPK" "Pearls" "CPK"]
    set wdtT [PlusLongEltDe $NwOj(Types)]
    set wdt [expr {max($wdtT,$wdtC)+1}]

    # frame selection
    frame $top.fsel -bg black -relief groove -bd 2
    label $top.fsel.ltyp  -text "Draw as " -relief flat  -width 10  -anchor w -justify left  -bg black -fg white 
    set NwOj(TypeSel) [lindex $NwOj(Types) 0]
    set NwOj(CbType) $top.fsel.ctyp
    ttk::combobox $top.fsel.ctyp  -style vdx.TCombobox  -state readonly  -width $wdt  -values $NwOj(Types)  -textvariable NwOj(TypeSel)
    label $top.fsel.lsel  -text " residues "  -bg black -fg white  -anchor w -justify left  -relief flat
    button $top.fsel.ball  -text "All" -relief flat  -bd 0 -highlightthickness 0  -relief flat -pady 0  -bg cyan -fg black  -command [list SelectChainNwOj all]
    button $top.fsel.bslt  -text "Selected" -relief flat  -bg cyan -fg black  -bd 0 -highlightthickness 0  -relief flat -pady 0  -command [list SelectChainNwOj selected]
    label $top.fsel.lfea  -text " in feature "  -width 15  -bg black -fg white  -anchor w -justify left  -relief flat
    set wdtF [PlusLongEltDe $::ListeFeat43d]
    set NwOj(ListeFeat) "None"
    set NwOj(FeatSel) [lindex $NwOj(ListeFeat) 0]
    set NwOj(CbFeat) $top.fsel.cfea
    ttk::combobox $top.fsel.cfea  -style vdx.TCombobox  -state readonly  -width $wdtF  -values $NwOj(ListeFeat)  -textvariable NwOj(FeatSel)
    bind $top.fsel.cfea <> [list SelectChainNwOj feature]

    grid $top.fsel.ltyp -row 0 -column 0 -rowspan 2 -sticky nsw -padx 2
    grid $top.fsel.ctyp -row 0 -column 1 -rowspan 2 -sticky ew
    grid $top.fsel.lsel -row 0 -column 2 -rowspan 2 -sticky nsw
    grid $top.fsel.ball -row 0 -column 3 -sticky w -pady 1
    grid $top.fsel.bslt -row 0 -column 4 -sticky ew
    grid $top.fsel.lfea -row 1 -column 3 -pady 2
    grid $top.fsel.cfea -row 1 -column 4 -pady 2 -sticky ew

    # frame painting
    frame $top.fpai -bg black -relief groove -bd 2
    label $top.fpai.ltyp  -text "Paint in " -relief flat  -width 10  -anchor w -justify left  -bg black -fg white 
    set NwOj(ColorSel) [lindex $NwOj(Colors) 0]
    set NwOj(CbCol) $top.fpai.ctyp
    ttk::combobox $top.fpai.ctyp  -style vdx.TCombobox  -state readonly  -width $wdt  -values $NwOj(Colors)  -textvariable NwOj(ColorSel)
    label $top.fpai.lsel  -text " residues "  -bg black -fg white  -anchor w -justify left  -relief flat
    button $top.fpai.ball  -text "All" -relief flat  -bd 0 -highlightthickness 0  -relief flat -pady 0  -bg cyan -fg black  -command [list ColorChainNwOj all]
    button $top.fpai.bslt  -text "Selected" -relief flat  -bg cyan -fg black  -bd 0 -highlightthickness 0  -relief flat -pady 0  -command [list ColorChainNwOj selected]
    label $top.fpai.lfea  -text " using feature "  -width 15  -bg black -fg white  -anchor w -justify left  -relief flat
    set wdt [PlusLongEltDe $::ListeFeat43d]
    set NwOj(ListeFeat) "None"
    set NwOj(FeatCol) [lindex $NwOj(ListeFeat) 0]
    set NwOj(CbFeatCol) $top.fpai.cfea
    ttk::combobox $top.fpai.cfea  -style vdx.TCombobox  -state readonly  -width $wdtF  -values $NwOj(ListeFeat)  -textvariable NwOj(FeatCol)
    bind $top.fpai.cfea <> [list ColorChainNwOj feature]

    grid $top.fpai.ltyp -row 0 -column 0 -rowspan 2 -sticky nsw -padx 2
    grid $top.fpai.ctyp -row 0 -column 1 -rowspan 2 -sticky ew
    grid $top.fpai.lsel -row 0 -column 2 -rowspan 2 -sticky nsw
    grid $top.fpai.ball -row 0 -column 3 -sticky w -pady 1
    grid $top.fpai.bslt -row 0 -column 4 -sticky ew
    grid $top.fpai.lfea -row 1 -column 3 -pady 2
    grid $top.fpai.cfea -row 1 -column 4 -pady 2 -sticky ew

    # frame canvas
    set NwOj(Can) $top.fcan.can
    frame $top.fcan -bg black
    canvas $top.fcan.can  -width 300 -height 200  -highlightthickness 0  -scrollregion [list 0 0 300 200]  -bg black
    
    grid $top.fcan.can -row 0 -column 0 -sticky news
    grid columnconfig $top.fcan 0 -weight 1
    grid rowconfig $top.fcan 0 -weight 1

    # frame surface
    frame $top.fsrf -bg black -relief groove -bd 2
    set NwOj(Surface) 0
    label $top.fsrf.lsrf  -text "Add surface : "  -bg black -fg white  -anchor w -justify left
    ttk::radiobutton $top.fsrf.ryes  -style vdx.TRadiobutton  -text "Yes"  -value 1  -variable NwOj(Surface)
    ttk::radiobutton $top.fsrf.rno  -style vdx.TRadiobutton  -text "No"  -value 0  -variable NwOj(Surface)
    grid $top.fsrf.lsrf -row 0 -column 0 -sticky w -padx 2
    grid $top.fsrf.ryes -row 0 -column 1 -sticky w
    grid $top.fsrf.rno  -row 0 -column 2 -sticky w

    # frame controls 
    frame $top.fbutton -bg black
    button $top.fbutton.ok  -text " OK "  -bg green1  -highlightthickness 0  -command [list FinNewObj ok]
    button $top.fbutton.dis  -text "Dismiss"  -highlightthickness 0  -bg red  -command [list FinNewObj dismiss]
    grid $top.fbutton.dis -row 0 -column 0 -sticky w -padx 20
    grid $top.fbutton.ok -row 0 -column 1 -sticky e -padx 20
    grid columnconfig $top.fbutton all -weight 1

    # grid les frames
    grid $top.fnames  -row 0 -column 0 -sticky ew -pady 5 -padx 5
    grid $top.fchains -row 1 -column 0 -sticky ew -padx 5 -pady 3
    grid $top.fsel    -row 2 -column 0 -sticky ew -padx 5 -pady 3
    grid $top.fpai    -row 3 -column 0 -sticky ew -padx 5 -pady 3
    grid $top.fcan    -row 4 -column 0 -sticky news -pady 3
    grid $top.fsrf    -row 5 -column 0 -sticky ew -padx 5 -pady 3
    grid $top.fbutton -row 6 -column 0 -sticky ew -pady {15 10}

    grid rowconfig    $top 2 -weight 1
    grid columnconfig $top all -weight 1

    # initialise object
    # Carefull !! only for polymer at present
    foreach chn $Lchn {
	set Lr [$mol _resnumber -chain $chn -polymer]
	foreach n $Lr {
	    set NwOjR($chn,$n) [list $n 0 couldefond]
	}
    }
    set NwOj(Edit) 0

    # Now update if editing
    if {$obj ne ""} {
	set NwOj(Obj) [string range $obj 4 end]
	set NwOj(Edit) 1
	$NwOj(ObjEntry) configure -state disabled
	array set NwOjR [$mol editObject $obj]
	$mol _dellist $obj
    }

    if {"Fcan" ni [font names]} {
	font create Fcan -size 10 

    }
    $top.fchains.r[lindex $Lchn 0] invoke

    FenetreAuCentre $top

    tkwait window $NwOj(Toplevel)

    if {$OldGrab ne ""} {
	grab $OldGrab
    }

    return

}

proc DefineNodeState {} {

    global Tx LTaxSelected TaxRoot LSelectableId
    
    # the set of taxa to consider
    FilterTax2Draw

    set Tx(hasSel,0) 1
    set Tx(Etat,$TaxRoot) 1
    set Tx(hasSel,$TaxRoot) 1

    # if we ask for no selection, then show all nodes
    if {$Tx(-ntaxa) == 0} {
	set Lor [list]
	set Lshow $LSelectableId
    } else {
	set Lor [ListsComplement $LSelectableId $LTaxSelected]
	set Lshow $LTaxSelected
    }

    # dont show the not selected nodes
    foreach n $Lor {
	foreach a [DonneGenealogieMem $n] {
	    set Tx(Etat,$a) 0
	    set Tx(hasSel,$a) 1
	}
	set Tx(Etat,$n) -1
    }

    # show selected
    foreach n $Lshow {
	foreach a [DonneGenealogieMem $n] {
	    set Tx(Etat,$a) 1
	    set Tx(hasSel,$a) 1
	}
	set Tx(Etat,$n) -1
    }

    return

}

proc DefineProject {p} {

    global OPjt PBV

    set w $OPjt(Window)

    label $w.ldef  -text "Creating new Ordalie project : $p"  -font "Helvetica 14 bold"  -anchor w -justify left
    set OPjt(Label) $w.ltitre
    label $w.ltitre  -text "Processing alignment files ...."  -anchor w -justify left
    set OPjt(Progbar) $w.prg
    ttk::progressbar $w.prg  -variable PBV

    
    grid $w.ldef   -row 0 -column 0 -sticky w  -pady 10 -padx 5
    grid $w.ltitre -row 1 -column 0 -sticky w  -padx 5
    grid $w.prg    -row 2 -column 0 -sticky ew -padx 5 -pady {5 15}
    FenetreAuCentre $w
    update idletasks

    CheckFiles

    return

}

proc DefineSelectableGenomes {} {

    global Tx db LCompleteId LSelectableId LModelId LAllIds LUserId
    
    # take all genomes as possible candidates
    if {$Tx(-useorgs) eq "all"} {
	return $LCompleteId
    }

    # take only one representative per 'Species'.
    # First, Flag model organisms as being potential selectable
    # genomes.
    set Ltot [concat $LUserId $LModelId]
    set Ltot [concat $Ltot $LCompleteId]
    set Ltot [lunique $Ltot]

    # Now take one representative per 'Species'
    set Lpris [list]
    foreach id $Ltot {
	set rk [set Tx(Rank,$id)]

	# flag until we find a 'Species' parent
	set par $id
	set out 0
	while {$rk ne "Species" && $par != 0} {
	    if {[info exists Vu($par)]} {
		set out 1
		break
	    }
	    # an unseen ID , so now flag it
	    #set Vu($par) 1
	    set Tx(NbChildCum,$par) 1
	    set par [set Tx(Parent,$par)]
	    set rk  [set Tx(Rank,$par)]
	}
	if {! $out && ! [info exists Vu($par)] && $par != 0} {
	    set Vu($par) 1
	    set Tx(NbChildCum,$par) 1
	    lappend Lpris $id
	}
	# cas special LUserId doit etre present
	if {$id in $LUserId && $id ni $Lpris} {
	    incr Tx(NbChildCum,$par)
	    lappend Lpris $id
	}
    }
    set LSelectableId [lunique $Lpris]
    puts "\nThere are now [llength $LSelectableId] potential genomes"

    return $LSelectableId

}

proc DefinirLaCouleurAuLancement {K} {

    if {[OnTraiteUnGenome]} {
	RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
	RedefinirLaCouleurDuLinge $K "BiaisEnGC"
	RedefinirLeFard           $K "BiaisEnGC"  
    } elseif {[OnTraiteUneCollection]} {
	RedefinirLeFard           $K "NombreDeCopainsDansBlast"  
	RedefinirLaCouleurDuLinge $K "NombreDeCopainsDansBlast"
	if {[OnTraiteDesCDNAs]} {
	    if {[file exists "[RepertoireDuGenome]/polyJENESAISPLUSQUOIxxxxxxxxxxxxxxxxxxx"]} {
		RedefinirLaCouleur        $K "PolyLocalization"
		RedefinirLaCouleurDuLinge $K "RepeatMasker"  
		RedefinirLeFard           $K "NombreDeCopainsDansBlast"  
	    } else {
		RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
		RedefinirLaCouleurDuLinge $K "NombreDeCopainsDansBlast"
		RedefinirLeFard           $K "NombreDeCopainsDansBlast"
	    }
	} elseif {[OnTraiteDesCDS]} {
	    RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
	    RedefinirLaCouleurDuLinge $K "PolyLocalization"  
	    RedefinirLeFard           $K "MDScore"  
	} else {
	    if {[OnTraite ScerFlo]} {
		RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
		RedefinirLaCouleurDuLinge $K "Rejected"
	    }
	    if {[PreFixe]=="SY"} {
		RedefinirLaCouleur    $K "Classes"
	    }
	    if {[PreFixe]=="RIB"} {
		RedefinirLaCouleur    $K "PhylumOrtho"
	    }
	    if {[PreFixe]=="PEROX"} {
		RedefinirLaCouleur    $K "CompareSeqWithQuery"
	    }
	    if {[PreFixe]=="COR"} {
		RedefinirLaCouleur    $K "PhylumOrtho"
	    }
	    if {[regexp "Droso" [RepertoireDuGenome]]} {
		RedefinirLaCouleur    $K "NombreDeCopainsDansBlast"
	    }
	    if {[OnTraiteBalibase]} {
		RedefinirLaCouleur    $K "Balibase"
	    }
	    if {[PreFixe]=="BSD"} {
		RedefinirLaCouleur    $K "Famille"
	    }
 	    if {[regexp Tparva [RepertoireDuGenome]]} {
#		RedefinirLaCouleurDuLinge $K "ScerevisiaePfalciparum"  
#		RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
		RedefinirLaCouleurDuLinge $K "ScerevisiaeTbrucei"  
		RedefinirLaCouleur        $K "NombreDeCopainsDansBlast"
	    }
	} 
    }

}

proc DefinitListeParams {} {

    set Lp [list mP mPm mC mCm mAm-mDm mA-mD mF mFm]
    set Ll $Lp
    lappend Ll [LCnk $Lp 2]
    lappend Ll {*}[LCnk $Lp 3]
    lappend Ll {*}[LCnk $Lp 4]
    lappend Ll {*}[LCnk $Lp 5]
    lappend Ll {*}[LCnk $Lp 6]
    lappend Ll {*}[LCnk $Lp 7]

    puts [join $Ll \n]
    puts "\n[llength $Ll]"

    return $Ll

}

proc DefinitNomMolecule {nom} {


    set idxp [lindex [regexp -indices -inline {[0-9]} $nom] 0]
    set idxa [string first "." $nom]
    set molid [string range $nomtmp $idxp $idxa]

    return $molid

}

proc DefinitPrfItem {w Quoi} {

    global FrmPref OldPrf

    regsub -all " " $Quoi "" Quoi
    if {$OldPrf eq $Quoi} {return}

    foreach e [winfo children $FrmPref] {
	destroy $e
    }

    eval "EnvoiePrf${Quoi}"

    set OldPrf $Quoi

    return

}

proc DefinitStructuresAVoir {} {

    global ZoneSuperposition
    global StrucAVoir
    global ListePDB

    set StrucAVoir {}
    ChoixPlusieursPDB
    update

    # si pas de PDB selectionne, ou 1 seul pris,
    # pas de superposition a faire
    if {[llength $StrucAVoir] < 2} {return}

    set choix [tk_dialog .chx "Beware !" "Beware ! Structures may be not superposed !\nDo you want to superpose them ?" "" 0 " Yes " " No "]
    if {$choix == 0} {Superposition}

    return $StrucAVoir

}

proc DefinitTypeAlignement {} {

    global Sequences LNOrdali TypeSeq ListeDesSimilarites ListeDesAcidesAmines

    if {[info exists TypeSeq]} {return}

    set seq ""
    foreach s $LNOrdali {
	if {[string trim [set Sequences($s)]] ne ""} {
	    append seq [set Sequences($s)]
	}
    }

    set rep [DefinitTypeSeq $seq]

    if {$rep eq "DNA"} {
	set TypeSeq "DNA"
	set ListeDesAcidesAmines {A C G T Z}
	set ListeDesSimilarites {1 2 3 4 5 Z}
    } elseif {$rep eq "Protein"} {
	set TypeSeq "Protein"
	# liste acides amines de Clustal
	set ListeDesAcidesAmines {A B C D E F G H I K L M N P Q R S T V W X Y Z}
	#set ListeDesAcidesAmines {A C D E F G H I K L M N P Q R S T V W Y Z}
	set ListeDesSimilarites {1 2 3 4 5 6 Z}
    } else {set TypeSeq "Unknown"}

    # Protein
    # 1 =  A,I,L,M,V
    # 2 =  P,A,G,S,T
    # 3 =  D,E,Q,N
    # 4 =  F,Y,W
    # 5 =  K,R,H
    # 6 =  C
    #   Z si sequence manquante

    return

}

proc DefinitTypeSeq {seq} {

    set seq [string map [list "." "" "\n" "" "Z" "" " " "" "X" ""] $seq]
    set Ld [string length $seq]
    set No [regsub -all "O"  $seq "" seq]
    set Lo [string length $seq]

    if {$Ld == 0} {return "Water"}

    set seq [string map [list "A" "" "C" "" "G" "" "T" "" "U" "" "N" ""] $seq]
    set Ll [string length $seq]
    set water [expr {double($Lo)/$Ld}]
    set ratio [expr {double($Ll)/$Ld}]

    if {$water < 0.15} {return "ligand"}

    if {$ratio < 0.15} {
	return "DNA"
    } else {
	return "Protein"
    }

}

proc Definition {Nom {Approx ""}} {

    set ValiDE [ExtraitInfo $Nom "ValiDE"]

    if {$ValiDE != ""} { return $ValiDE }

    if {[OnTraiteDesCDNAs]} { return "" }

    if {$Approx!=""} {
	set DE [ExtraitInfo $Nom "DEJ"]
	if {$DE!=""} { return "$DE"}

	set DE [ExtraitInfo $Nom "SpineDef"]
	if {$DE!=""} { return "$DE"}

	set DE [ExtraitInfo $Nom "DE_GenBank"]
	if {$DE!=""} { return "$DE (taken from Genbank)"}

	set DE [ExtraitInfo $Nom "DE_Narcisse"]
	if {$DE!=""} { return "$DE (taken from database)"}

	set DE [ExtraitInfo $Nom "DE_DbClustal"]
	if {$DE!=""} { return "DE_BestDbClustal: $DE" }

	set DE [ExtraitInfo $Nom "DE_BlastP"]
	if {$DE!=""} { return "DE_BlastP: $DE" }
	set DE [ExtraitInfo $Nom "DE_BlastX"]
	if {$DE!=""} { return "DE_BlastX: $DE" }

	if {[regexp "ApproxDansInfo" $Approx]} { return "DE not yet established" }

	set DE [BestDefinitionOfDbClustal $Nom]
	if {$DE!=""} { return "DE_BestDbClustal: $DE" }

	set DE [BestDefinitionOfBlastP $Nom]
	if {$DE!=""} { return "DE_BestBlastP: $DE" }
	set DE [BestDefinitionOfBlastX $Nom]
	if {$DE!=""} { return "DE_BestBlastX: $DE" }
    }
    return "Hypothetical protein or DE not known"

}

proc DefinitionApproximative {Nom} {

    return [Definition $Nom "Approx"]

}

proc DefinitionConsensus {Nom FileMSF FileClust {IdDesProtId 0.98} {NorMDMin 0.5} {NbMilliSecMax 30000} {NbIndiv 20}} {

    if {![file exists $FileMSF]} {return}
    AskMSF unset

    if {[AskMSF $FileMSF $Nom] != ""} {
	set Query $Nom
    } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} {
	set Query "QUERY_PROTEIN"
    } else {
	return
    }
    set LesAccess [LesProteinesProchesDeLaProteineDeRef $Query $FileMSF $FileClust $IdDesProtId "AvecCluster" $NorMDMin]

    AskLesPagesInfos load $LesAccess protein

    set LesMotsDeRef {}
    set LesDefinitionsDeRef {}
    foreach Access $LesAccess {
	if {$Access == $Query        } {continue}
	if {[regexp {^[0-9]} $Access]} {continue}

	LesPhrasesMemorisees         UNSET
	InterrogeLesEffectifsDesMots UNSET

	set PageInfo [AskLesPagesInfos ask $Access]
	if {$PageInfo == ""} {continue}
	set Def      [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "]
	if {$Def      == ""} {continue}

	Espionne "$Access $Def"
	lappend LesDefinitionsDeRef $Def
    }
    AskLesPagesInfos unset

    if {$LesDefinitionsDeRef == {}} {return}
    LesPhrasesMemorisees $LesDefinitionsDeRef
    if {[LesPhrasesMemorisees] == {}} {return}
    return [AlgoGenet $NbIndiv $NbMilliSecMax]

}

proc DefinitionDuAccess {BanqueId {Access ""}} {

    if {$Access==""} { set Access $BanqueId }
    set LesValeurs [LesChampsInteressantsDuAccess $BanqueId $Access "DE"]
    set DE [lindex $LesValeurs 0]
    regsub -all {[ \n\t]+} $DE " " DE
    set DE [string trim $DE]
    return $DE  

}

proc DefinitionDuGeneAffymetrix {Nom} {

    set GBtagsDefinition [ExtraitInfo $Nom "GBtagsDefinition"]
    if { ! [regexp -nocase "DEFINITION=" $GBtagsDefinition]} { return "" }
    set Ligne $GBtagsDefinition
    #Espionne "\n$Ligne"
    regsub -all {\[.*\]} $Ligne " " Ligne
    regsub -all {\{.*\}} $Ligne " " Ligne

    set Def [StringSuivant "DEFINITION=" dans $Ligne]
    #Espionne $Def
    scan $Def "%s" PremierMot
    regsub "$PremierMot *" $Def "" Def
    if {[regexp -nocase {^([A-Z0-9\-]+)=} $Def Match BonMot]} { return $BonMot }

    regsub -nocase -all {Human |Homo |sapiens |H.sapiens |mRNA for |mRNA encoding |mRNA fragment encoding} $Def "" Def
    regsub -nocase {(gene|mRNA)\,.*$} $Def "" Def
    if {[regexp -nocase {\(([a-z0-9\-]+ [0-9]{1})\)} $Def Match BonMot] } { return $BonMot }
    if {[regexp -nocase {\(([a-z0-9\-]+ alpha)\)} $Def Match BonMot] } { return $BonMot }
    if {[regexp -nocase {\(([a-z0-9\-]+ beta)\)} $Def Match BonMot] } { return $BonMot }
    if {[regexp -nocase {\(([a-z0-9\-]+ gamma)\)} $Def Match BonMot] } { return $BonMot }
    if {[regexp -nocase {\(([a-z0-9\-]+ delta)\)} $Def Match BonMot] } { return $BonMot }
    regsub -all {\([^ ]* .*\)} $Def "" Def
    regsub -all {mRNA} $Def "" Def
    if {[regexp {\((.*)\)} $Def Match BonMot]} { return $BonMot }
    set Def [string trim $Def]
    if { ! [regexp -nocase " " $Def]} { return $Def }
    regsub {\,.*$} $Def "" Def
    return $Def

}

proc DefinitionGroupes {Type {NbGr -1}} {

    global Defauts Sequences LNOrdali LNDG SDG
    global TabSF TabSF yaord "" LesPoidsDesSequences OrdrePrecedent

    if {[QuelMode] eq "seqlab"} {
	FaireLire "Not available in Editor !"
	return
    }

    if {[set Defauts(AffSS)]} {LesDefauts AffSS 0}
    ColorieNomsSelonPhylum hide

    switch $Type {
	"fichierclu" {
	    set txt "Please wait ...\nComputing Cluspack groups from cluster file"
	    set GrMeth "cluster file"
	}
	"integral" {
	    if {[TypeAli] ne "XML"} {
		FaireLire "This is not a Macsims file !"
		return
	    }
	    set txt "Please wait ...\nRestoring Macsims groups"
	    set GrMeth "taken from Macsims file"
	}
	"ordsecator" {
	    set txt "Please wait ...\nComputing Ordalie groups from secator"
	    set GrMeth "3 ordalie groups with secator"
	}
	"orddpc" {
	    set txt "Please wait ...\nComputing Ordalie groups from DPC"
	    set GrMeth "3 ordalie groups with dpc"
	}
	"secator" {
	    set txt "Please wait ...\nComputing Secator groups"
	    set GrMeth "secator"
	}
	"dpc" {
	    set txt "Please wait ...\nComputing DPC groups"
	    set GrMeth "dpc"
	}
	"zonesecator" {
	    set txt "Please wait ...\nComputing Secator groups using defined zones"
	    set GrMeth "zones with secator"
	}
	"zonedpc" {
	    set txt "Please wait ...\nComputing DPC groups using defined zones"
	    set GrMeth "zones with dpc"
	}
	"fixed" {
	    set txt "Please wait ...\nComputing $NbGr groups using DPC"
	    set GrMeth "fixed number of groups (k-means)"
	}
	"phylum" {
	    set txt "Please wait ...\nDefining groups using Phyla property"
	    set GrMeth "phylogenic grouping"
	}
	"nogroups" {
	    set txt "Clearing clusters"
	}
    }

    FaireAttendre "$txt"

    set rep [CalculeGroupes $Type $NbGr]
    if {$rep ne "1"} {
	FaireLire "$rep"
	FaireLaSuite
	return
    }

    if {! [ModeI]} {return}

    ClearSelections
    InitConsensus
    InitPoints
    
    if {[QuelMode] eq "feature"} {
	ColorieSelonFeature "Clear"
    }
    EnleveConservation
    EffaceWNomsWSeqs
    RafraichitAffichage
    
    if {[QuelMode] eq "cluster"} {
	AfficheZonesSelectionneesCluster
    }

    FaireLaSuite

    return

}

proc DefinitionInterpro {Interpro} {

    set Page [PageInfo         $Interpro interpro]
    return   [ValeurDeLaBalise name      Page    ]

}

proc DefinitionLookups {ordre} {


    global TypeCons
    global lookupGrp
    global lookupCns
    global lookupInt
    global LNDG

    if {[info exist lookupGrp]} {
	unset lookupGrp
	unset lookupCns
	unset lookupInt
    }

    set Grp1 [lindex $LNDG [string index $ordre 0]]
    set Grp2 [lindex $LNDG [string index $ordre 1]]
    set Grp3 [lindex $LNDG [string index $ordre 2]]

    set lookupGrp(0) 0
    set lookupGrp(1) $Grp1
    set lookupGrp(2) $Grp2
    set lookupGrp(3) $Grp3

    set lookupOrd(1) [string index $ordre 0]
    set lookupOrd(2) [string index $ordre 1]
    set lookupOrd(3) [string index $ordre 2]

    set g1 [string index $ordre 0]
    set g2 [string index $ordre 1]
    set g3 [string index $ordre 2]

    if {$g1 > $g2} {
	set p1 "$g2$g1"
    } else {
	set p1 "$g1$g2"
    }
    if {$g2 > $g3} {
	set p2 "$g3$g2"
    } else {
	set p2 "$g2$g3"
    }
    if {$g1 > $g3} {
	set p3 "$g3$g1"
    } else {
	set p3 "$g1$g3"
    }

    if {[string index $p1 0] == 2} {
	set lookupInt(9) 8
    } else {
	if {[string index $p1 1] == 2} {
	    set lookupInt(8) 8
	} else {
	    set lookupInt(7) 8
	}
    }

    if {[string index $p2 0] == 2} {
	set lookupInt(9) 9
    } else {
	if {[string index $p2 1] == 2} {
	    set lookupInt(8) 9
	} else {
	    set lookupInt(7) 9
	}
    }

    if {[string index $p3 0] == 2} {
	set lookupInt(9) 7
    } else {
	if {[string index $p3 1] == 2} {
	    set lookupInt(8) 7
	} else {
	    set lookupInt(7) 7
	}
    }

    foreach tp $TypeCons {
	if {[string first "InterG" $tp] != 0} {
	    set lookupCns($tp) $tp
	} else {
	    set g1 [string index $tp 6]
	    set g2 [string index $tp 7]
	    set ng1 [set lookupOrd($g1)]
	    set ng2 [set lookupOrd($g2)]

	    if {$ng1 > $ng2} {
		set ngs "$ng2$ng1"
	    } else {
		set ngs "$ng1$ng2"
	    }

	    set newtp "InterG$ngs[string range $tp 8 end]"
	    set lookupCns($tp) $newtp
	}
    }

    return

}

proc DefinitionPartagee {LesDefs {Fichier ""}} {

    if {$LesDefs=={}} { return "" } 
    if {[llength $LesDefs]==1} { return [lindex $LesDefs 0] }
    set IDef -1
    foreach Def $LesDefs {
	set Def [string tolower $Def]
	incr IDef  
	set LesMotsImportants($IDef) [LesMotsImportants $Def]
	foreach Mot [set LesMotsImportants($IDef)] {
	    lappend LesMotsExistants $Mot
	    lappend LesDefsDuMot($Mot) $IDef
	    if { ! [info exists Histo($Mot,$IDef)]} { set Histo($Mot,$IDef) 0 }
	    incr Histo($Mot,$IDef)
	}
    }
    set IDefMax $IDef
    set LesMotsExistants [lsort -unique $LesMotsExistants]

    foreach Mot $LesMotsExistants {
	set Ligne ""
	set Rang 0
	set Occu 0
	set LesScores {}
	foreach IDef [NombresEntre 0 $IDefMax] {
	    if {[info exists Histo($Mot,$IDef)]} {
		set Score $Histo($Mot,$IDef)
		append Ligne [format "%1d" $Score]
		incr Rang $IDef
		incr Occu
	    } else {
		set Score 0
		append Ligne " "
	    }
	    lappend LesScores $Score
	}
	set LesScoresLisses {}
	set LesScoresEtPlus $LesScores
	lappend LesScoresEtPlus 0 0 0 0
	set LesScoresEtPlus [lrange $LesScoresEtPlus 0 [expr ([llength $LesScoresEtPlus]/5)*5-1]]
	foreach {S1 S2 S3 S4 S5} $LesScoresEtPlus {
	    lappend LesScoresLisses [expr $S1 + $S2 + $S3 + $S4 + $S5]
	}
	set Rang [expr (1.0*$Rang)/($IDefMax+1)]
	set Ligne "[format "%-30s %4.1f %2d" $Mot $Rang $Occu]  =  [join $LesScoresLisses " "]"
	lappend LesLignes $Ligne
	lappend ListePourCluspack "$Mot [join $LesScoresLisses " "]"
    }
    set AllWithGroup [Cluspack $ListePourCluspack "GetAllWithGroup"]
    EspionneL $AllWithGroup
    foreach MG $AllWithGroup {
	scan $MG "%s %s" Mot Groupe
	Espionne "GroupeDuMot($Mot) $Groupe"
	set GroupeDuMot($Mot) $Groupe
    }
    foreach Ligne $LesLignes {
	scan $Ligne "%s" Mot
	Espionne "set Groupe GroupeDuMot($Mot)"
	set Groupe [set GroupeDuMot($Mot)]
	set LigneAvecGroupe "$Groupe $Ligne"
	lappend LesLignesAvecGroupes $LigneAvecGroupe
    }

    set Page [join [lsort -decreasing -integer -index 0 $LesLignesAvecGroupes] "\n"]
    return [AfficheVariable $Page "AvecRetour" $Fichier]

}

proc DefinitionPreferences {} {

    global SeqChangeDansSeqlab Defauts SeqlabMode SphDef TypeCons TypeText Couleurs OrdEtcDir

    set SphDef "Mean"
    set SeqlabMode 0
    set SeqChangeDansSeqlab 0

    # define fonts if tk loaded
    if {[info exists ::tk_patchLevel]} {
	if {"SeqFont" ni [font names]} {
	    font create SeqFont -family [set Defauts(SeqFontFaml)] -size [set Defauts(SeqFontSize)] -weight [set Defauts(SeqFontWght)]
	}
	if {"EdtTitre" ni [font names]} {
	    font create EdtTitre {*}[font configure TkDefaultFont] -size 14 -weight bold
	}
	if {"EdtItem" ni [font names]} {
	    font create EdtItem {*}[font configure TkDefaultFont] -weight bold
	}
	if {"BtnFeatFont" ni [font names]} {
	    font create BtnFeatFont -family Helvetica -size 10 -weight normal
	}
    }

    if {! [info exists TypeCons]} {set TypeCons {} }

    set TypeText(IdenGlob)     "Global identity"
    set TypeText(ConsGlob)     "Global conservation"
    set TypeText(SimiGlob)     "Global similarity"
    set TypeText(IdenGrp1)     "Identity Group 1"
    set TypeText(IdenGrp2)     "Identity Group 2"
    set TypeText(IdenGrp3)     "Identity Group 3"
    set TypeText(IdenGrp1Gris) "Group 1 similarity"
    set TypeText(IdenGrp2Gris) "Group 2 similarity"
    set TypeText(IdenGrp3Gris) "Group 3 similarity"
    set TypeText(InterG12)     "Inter-group 1-2"
    set TypeText(InterG13)     "Inter-group 1-3"
    set TypeText(InterG23)     "Inter-group 2-3"
    set TypeText(InterG12Gris) "Inter-group 1-2 sim."
    set TypeText(InterG13Gris) "Inter-group 1-3 sim."
    set TypeText(InterG23Gris) "Inter-group 2-3 sim."
    set TypeText(PoinGrp1)     "Points group 1"
    set TypeText(PoinGrp2)     "Points group 2"
    set TypeText(PoinGrp3)     "Points group 3"

    lappend TypeCons IdenGlob
    lappend TypeCons ConsGlob
    lappend TypeCons SimiGlob
    lappend TypeCons IdenGrp1
    lappend TypeCons IdenGrp2
    lappend TypeCons IdenGrp3
    lappend TypeCons IdenGrp1Gris
    lappend TypeCons IdenGrp2Gris
    lappend TypeCons IdenGrp3Gris
    lappend TypeCons InterG12
    lappend TypeCons InterG13
    lappend TypeCons InterG23
    lappend TypeCons InterG12Gris
    lappend TypeCons InterG13Gris
    lappend TypeCons InterG23Gris
    lappend TypeCons PoinGrp1
    lappend TypeCons PoinGrp2
    lappend TypeCons PoinGrp3

    ValsDeCouleurs

    set Couleurs(Stock) {red blue yellow green1 magenta orange cyan brown forest_green pink goldenrod sea_green coral violet khaki navy_blue salmon sienna turquoise lime_green maroon spring_green medium_blue indian_red dim_gray light_gray gray}

    return

}

proc DefinitionRapide {Nom} {

    return [Definition $Nom "ApproxDansInfo"]

}

proc DefinitionsOfAliasGeneName {Gn} {

    set DefinitionsOfAliasGeneName {}
    foreach Nom [GscopeIdsOfGeneName $Gn] {
	lappend DefinitionsOfAliasGeneName "$Nom [ValiGN $Nom] [DefinitionRapide $Nom]"
    }
    return $DefinitionsOfAliasGeneName

}

proc Degrave {VariableDeGrave} {

    upvar $VariableDeGrave $VariableDeGrave
#    upvar $VariableDeGrave ContenuVariableDeGrave (pourquoi ai-je mis cette ligne ?)
    set lElements [uplevel "array names $VariableDeGrave"]
    if {[llength $lElements]==0} {
	set Pierre [ReOuvrePierre]
	if {$Pierre==""} { return "" }
	set OnYest 0
	while { [gets $Pierre entree]>=0 } {
	    if { [regexp "#Debut $VariableDeGrave" $entree] } { 
		set OnYest 1 
		gets $Pierre entree
	    }
	    if { [regexp "#Fin   $VariableDeGrave" $entree] } { break }
	    if { $OnYest } { eval $entree }
	}
    } else {
    }
    return $VariableDeGrave

}

proc DegroupeLesSequences {} {

    global NomSeqSel NomTextSeq NomNomSeq Couleurs ListeSeqsGroupees LNSeqlab

    if {[llength $NomSeqSel] == 0} {
	FaireLire "Beware ! Select sequences to ungroup first !"
	return
    }

    set Lyl [list]
    set c -1
    # yw : pos dans widget, yl pos dans LNSeqlab
    foreach i $NomSeqSel {
	lassign [split $i .] yw x 
	set yl [expr {$yw-1}]
	set seqass [lindex $LNSeqlab $yl]
	set c -1
	foreach g [array names ListeSeqsGroupees] {
	    if {$seqass in [set ListeSeqsGroupees($g)]} {
		set c [lsearch [set ListeSeqsGroupees($g)] $seqass]
		break
	    }
	}
	if {$c == -1} {continue}

	lappend Lyl $yl
	set LseqG [set ListeSeqsGroupees($g)]
	set LseqG [lreplace $LseqG $c $c]
	set ListeSeqsGroupees($g) $LseqG
	$NomNomSeq tag remove TC$g $yw.0 "$yw.0 lineend"
    }
    $NomTextSeq ungroup $Lyl
    update

    foreach g [array names ListeSeqsGroupees] {
	if {[llength [set ListeSeqsGroupees($g)]] <= 1} {
	    DetruitSeqlabGroup $g
	}
    }

    ClearSelectionNoms
    $NomNomSeq configure -state disabled

    return

}

proc DeleteBallast {} {

    global RepertoireDuGenome

    foreach Fichier [glob "$RepertoireDuGenome/ballast/*"] {
	File delete $Fichier
    }
    exit

}

proc DeleteDoublonFastaFile {File} {
    
    #pour le fichier tu remplie un tableau associatif (vire les doublons)
    #recupere les cle dans une liste
    #pacours cette liste et lappend dans un set la cle suivit de la valeur
    #enfin ecris tous dans un nouveau fichier
    set doublon {}
    Espionne "FICHIER: $File"
    set mes_lignes [LesLignesDuFichier $File]
    foreach ligne $mes_lignes {
	if {[regexp {^>} $ligne]} {
	    set key $ligne
	} else {
	    set FastaEntry($key) $ligne
	}
    }
    #Les doublons meme ID sont eliminer par l'utilisation du tableau associatif
    set key [array names FastaEntry]
    foreach k $key {
	set seq1 $FastaEntry($k)
	set lineSplit [split $k " "]
	set specie1 [lindex $lineSplit 2]
	set ID1 [lindex $lineSplit 0]
	foreach k1 $key {
	    set lineSplit [split $k1 " "]
	    set ID2 [lindex $lineSplit 0]
	    #pas meme ID 
	    if {![info exist TabDoublon($k)]} {
		if {$ID1!=$ID2} {
		    #meme espece 
		    set specie2 [lindex $lineSplit 2]
		    if {$specie1==$specie2} {
			set seq2 $FastaEntry($k1)
			#meme seq alors on vire car doublon
			if {$seq1==$seq2} {
			    #Espionne "k= $k -----------  k1= $k1 ||||||||||||| Delete $k1"
			    lappend doublon $k1
			    #tabDoublon
			    set TabDoublon($k1) 1
			}
		    }
		}
	    }
	}
    }
    
    set key [array names FastaEntry]
    foreach k $key {
	foreach id $doublon {
	    if {$id==$k} {
		unset FastaEntry($k)
	    }
	}
    }
    set key [array names FastaEntry]
    foreach k $key {
	lappend newFile $k
	lappend newFile $FastaEntry($k)	    
    }
    
    SauveLesLignes $newFile dans $File
    set newFile {}
    set doublon {}
    array unset TabDoublon
    array unset FastaEntry

}

proc DeleteDoublonFastaFilePourTous {{directory ""}} {

    
    if {$directory==""} {set directory [RepertoireDuGenome]/tfasdescopains}
    
    set r [glob -directory $directory *]
    foreach fichier $r {
	set n [split $fichier "/"]
	set f [lindex $n [llength $n]-1]
	if {[PasTouche $f]} { continue }
	DeleteDoublonFastaFile $fichier
	FinPasTouche $f
    }

}

proc DeleteFeatItem {what pos} {

    global EFeat TabSF NomTextSeq LNOrdali SDG GroupeDeLaSequence

    set pos [$NomTextSeq index $pos]
    lassign [split $pos .] y x
    set nom [lindex $LNOrdali $y-1]
    if {$nom eq ""} {return}

    set ft [set EFeat(Feat)]
    set Ltag [$NomTextSeq tag names $pos]
    if {$Ltag == {}} {return}

    # last tag has highest priority
    set tg [lindex $Ltag end]
    # define what to delete
    set Ly [list]
    switch $what {
	"seq" {
	    set Ly $y
	}
	"group" {
	    set g [set GroupeDeLaSequence($nom)]
	    foreach s [set SDG($g)] {
		lappend Ly [expr {[lsearch $LNOrdali $s]+1}]
	    }
	}
	"all" {
	    set i 0
	    foreach s $LNOrdali {
		incr i
		if {$s ne ""} {lappend Ly $i}
	    }
	}
    }

    set Dptrn "FDisp_${EFeat(Feat)}_"
    set Fptrn "FX_${EFeat(Feat)}_"
    array set ToDel {}
    set Lt [list]
    foreach y $Ly {
	set nom [lindex $LNOrdali $y-1]

	# do it once. Same tag to delete for all 
	# selected sequences
	if {$Lt == {} } {
	    # Take tage at x. 
	    # Tags are sorted from lowest
	    # to highest priority
	    set Lt [lreverse [$NomTextSeq tag names $y.$x]]
	    # take the first for "FDisp" and "FX"
	    if {[set tF [lsearch -inline -regexp $Lt $Fptrn]] ne ""} {
		set tagcol [string range $tF [string length "$Fptrn"] end]
	    }
	    if {[set tD [lsearch -inline -regexp $Lt $Dptrn]] ne ""} {
		set tagnot [string range $tD [string length "$Dptrn"] end]
	    }
	    
	    # nothing found, return
	    if {$tD eq "" || $tF eq ""} {return}
	}

	# Determine which item is concerned
	set LixFeat [list]
	set ix -1
	foreach e [set TabSF(${nom},$ft)] {
	    incr ix
	    DecortiqueUneFeature $e d f col sco not
	    set notsp [string map [list " " "_"] $not]
	    if {! ($x <= $f && $x >= $d && $col == $tagcol && $notsp == $tagnot)} {continue}
	    
	    # search for tD tag (display)
	    foreach {p1 p2} [$NomTextSeq tag ranges $tD] {
		lassign [split $p1 .] y1 x1
		lassign [split $p2 .] y2 x2
		incr x2 -1
		if {$y1 != $y2 || $x1 != $d || $x2 != $f} {continue}
		lappend LixFeat $ix
	    }
	    # search for tF tag (color)
	    foreach {p1 p2} [$NomTextSeq tag ranges $tD] {
		lassign [split $p1 .] y1 x1
		lassign [split $p2 .] y2 x2
		incr x2 -1
		if {$y1 != $y2 || $x1 != $d || $x2 != $f} {continue}
		lappend LixFeat $ix
	    }
	}
	
	if {[set LixFeat [lsort -unique -integer -decreasing $LixFeat]] == {} } {
	    FaireLire "Probleme ! je ne trouve pas l item !! bordel fait chier !"
	    return
	}
	set Lf [set TabSF(${nom},$ft)]
	foreach i $LixFeat {
	    set Lf [lreplace $Lf $i $i]
	}
	set TabSF(${nom},$ft) $Lf
    }

    ChangeFeatureForEditing

    return -code break

}

proc DeleteFeature {what pos} {

    global EFeat TabSF NomTextSeq LNOrdali SDG GroupeDeLaSequence ListeTypesDeFeatures

    if {$EFeat(Feat) eq "None"} {return}

    if {$what ne "all"} {
	set pos [$NomTextSeq index $pos]
	lassign [split $pos .] y x
	set nom [lindex $LNOrdali $y-1]
	if {$nom eq ""} {return}
    }

    set ft [set EFeat(Feat)]

    switch $what {
	"seq" {
	    array unset TabSF "${nom},$ft"
	}
	"group" {
	    set g [set GroupeDeLaSequence($nom)]
	    foreach n [set SDG($g)] {
		array unset TabSF "${n},$ft"
	    }
	}
	"all" {
	    # la feature disparait completement !!
	    array unset TabSF "*,$ft"
	    set i [lsearch $ListeTypesDeFeatures $ft]
	    set ListeTypesDeFeatures [lreplace $ListeTypesDeFeatures $i $i]
	    set EFeat(FTypes) [linsert [set EFeat(FTypes)] 0 "None"]
	    $EFeat(FeatCombo) configure -values $EFeat(FTypes)
	    $EFeat(FeatCombo) current 0
	    set ft ""
	}
    }
    update

    AppliqueFeature "Clear"
    if {$ft ne ""} {
	AppliqueFeature $ft
    }

    return

}

proc DeleteJunkdir {{Qui ""}} {


    NousAllonsAuBoulot
    if {[OuiOuNon "Do I delete all files '$Qui*' in [pwd] ?"]} {
	if {[OuiOuNon "Sure that I delete all files '$Qui*'in [pwd] ?"]} {
	    set Ask 1
	    foreach Fichier [glob "$Qui*"] {
		if {[file isdirectory $Fichier]} { continue }
		File delete $Fichier
	    }
	}
    }
    OnRevientDuBoulot
    return 

}

proc DeleteJunkdirAvantDate {Annee Mois Jour {Heure 00}} {

    if {$Annee == ""} {set Annee "0000"}
    if {$Mois == ""} {set Mois   "00"  }
    if {$Jour  == ""} {set Jour  "00"  }
    if {$Heure == ""} {set Heure "00"  }

    set Date "$Annee$Mois$Jour$Heure"

    set Rep [RepertoireDeTravail]
    foreach File [glob -nocomplain "$Rep/*"] {
	set Top [file mtime $File]
	set YearMonthDayHour [clock format $Top -format "%Y%m%d%H"]
	if {$Date <= $YearMonthDayHour} {Espionne "$File $YearMonthDayHour";continue}
	file delete -force $File
    }
    return

}

proc DeleteLesSeqRedondanteDansTfasDesCop {CodeGscope} {


    set FichierTfas [RepertoireDuGenome]/tfasdescopains/$CodeGscope
    set ListeTfasNew {}
    set IDNouveau {}
    set Lignes [LesLignesDuFichier $FichierTfas]
    set add "No"

    foreach l $Lignes {
	if {[regexp  "^>" $l ]} {
	    set add "Yes"
	    scan $l "%s" Id
	    #Si ya PDB:1QZE_A faut virer le PDB....
	    if {[regexp {^>PDB:(\w*)} $Id tmp access]} {
		set Id ">$access"
	    }
	    if {[llength $IDNouveau]>0} {
		foreach IDN $IDNouveau {
		    if {[string equal -nocase $IDN $Id]} {
			set add "No"
			break
		    }
		}
		if {$add eq "Yes"} {
		    lappend IDNouveau $Id
		    lappend ListeTfasNew $Id
		    #lappend ListeTfasNew $l
		}
	    } else {
		lappend IDNouveau $Id
		lappend ListeTfasNew $Id
		#lappend ListeTfasNew $l
	    }
	} else {
	    if {$add eq "Yes"} {
		lappend ListeTfasNew $l
	    } else {
		continue
	    }
	}
    }
    #set fileTest [RepertoireDuGenome]/tfasdescopains/FileTest
    #SauveLesLignes $ListeTfasNew dans $fileTest
    SauveLesLignes $ListeTfasNew dans $FichierTfas

}

proc DeleteLesTmp {Selection Fenetre} {

    if { $Selection == "" } {
	FaireLire "Please select some files"
	return
    }
    foreach Fichier [split $Selection "\n"] {
	if { $Fichier != "" } {
	    File delete -force $Fichier
	}
    }
    destroy $Fenetre
    MenageLesTmp "Exit"

}

proc DeleteObjet {nom obj} {

    # cas fichier ORD, 
    if {[TypeAli] eq "ORD"} {
	VueEditee 1
    }

    if {[$nom _EtatDeObjet $obj]} {
	$nom ObjetOff $obj
    }

    # delete in database
    $nom deleteObjects $obj

    # delete buttons
    set frObjc $::pgl(frObjc)
    set obj [string range $obj 4 end]
    grid forget $frObjc.f${nom}.bto$obj $frObjc.f${nom}.bte$obj $frObjc.f${nom}.btd$obj
    destroy $frObjc.f${nom}.bto$obj $frObjc.f${nom}.bte$obj $frObjc.f${nom}.btd$obj
    update idletasks

    $::pgl(wogl) postredisplay

    return

}

proc DeleteSelected {} {

    global EFeat TabSF NomTextSeq LNOrdali SDG GroupeDeLaSequence

    if {$EFeat(LItemSel) == {} } {
	FaireLire "Please select items before to delete them !"

	return
    }

    foreach e $EFeat(LItemSel) {
	lassign $e zones noteRef ft
	foreach {p1 p2} $zones {
	    lassign [split $p1 .] y x1
	    lassign [split $p2 .] y x2
	    incr x2 -1
	    
	    set nom [lindex $LNOrdali $y-1]
	    set i 0 ; set Li [list]
	    foreach e [set TabSF(${nom},$ft)] {
		DecortiqueUneFeature $e d f col score note csys
		set nsp "${ft}_[string map [list " " _] $note]"
		if {$x1 == $d && $x2 == $f && $nsp eq $noteRef} {
		    lappend Li $i
		}
		incr i
	    }
	    
	    if {[set Li [lsort -unique -integer -decreasing $Li]] == {} } {
		FaireLire "Probleme ! je ne trouve pas l item !! bordel fait chier !"
		return
	    }
	    set Lf [set TabSF(${nom},$ft)]
	    foreach i $Li {
		set Lf [lreplace $Lf $i $i]
	    }
	    set TabSF(${nom},$ft) $Lf
	}
    }

    $NomTextSeq configure -state normal
    $NomTextSeq tag remove slct 1.0 end
    $NomTextSeq configure -state disabled
	
    ChangeFeatureForEditing 

    set EFeat(LItemSel) [list]

    return

}

proc DeleteUnusedInfos {} {

    global RepertoireDuGenome
    set repInfos "$RepertoireDuGenome/infos"
	set lesPABs [ListeDesPABs2]
	foreach elt $lesPABs {
		set tab($RepertoireDuGenome/infos/$elt) 1
	}
	foreach fileName [glob -nocomplain -tails -directory $repInfos *] {
        if {[info exists tab($fileName)]} {
           puts "$fileName est supprimé $tab($fileName)"
		 #file delete $RepertoireDuGenome/infos/$fileName
        }
    }

}

proc DeletedStart {Nom} {

    set Valeur [ExtraitInfo $Nom "DeletedStart"]
    set N [IntegerApres "il manque au moins " dans $Valeur]
    if {$N!=""} { set Valeur $N } else { set Valeur 0 }

    if {$Valeur!=""} { return $Valeur }

    Wup "For compatibility with older version where framshift were in codonstart2"
    set Valeur [ExtraitInfo $Nom "CodonStart2"]
    set LesFS {}
    foreach Champ [split $Valeur "/"] {
	if { ! [regexp "erreur de sequence" $Champ]} { continue }
	lappend LesDS $Champ
    }
    return [join $LesDS "/"]

}

proc Delimite {} {

    Espionne [string repeat "\n[Date NiceSeconds]" 10]

}

proc DeltaDistributionForClade {{Clade ""} {Seuil ""} {GetWhat ""} {Method ""} {Criteria ""}} {

    if {$Clade==""} { set Clade [SelectClade] }
    if {$Method==""} { set Method "Average" }
    if {$Criteria==""} { set Criteria "Rank" }

    set NomDeDistri [NomDe "Distri"]

    set EnTest [regexp {^(ripp|scherb)$} [Login]] 
    set EnTest 0

    if {$GetWhat==""}    { set GetWhat "Show" }
    if {$Seuil==""}      { set Seuil 0.001 }

    regsub -all " " $Clade "_" CladeUnderscore
    
    set Echantillonage 100
    
    set LesTaxIdsDuClade [CladeContent $Clade "UseQds" "Without,9606"]
	
    set NbTaxId [llength $LesTaxIdsDuClade]
    
    set Sens "increasing"
    if {[regexp -nocase "Score|DeltaS" $Criteria]} { set Sens "decreasing" }

    set Cadre $Clade
    foreach TaxId $LesTaxIdsDuClade {
	set OS [BilanCilioQds $TaxId "OS_"]
	set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
	set MethScore  [TaxoBla $Cadre $TaxId-$Method Score]
	set MethRank   [TaxoBla $Cadre $TaxId-$Method Rank]
	set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
	set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
	set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
Espionne "$Cadre $TaxId $Method $MethLogExp/$MethScore/$MethRank/$MethDeltaE/$MethDeltaS/$MethDeltaR"
	if {$MethRank==""} { continue }
	Espionne "$MethRank $OS $TaxId"
	lappend LesTaxIdDuMeth(LogExp,$MethLogExp) $TaxId
	lappend LesTaxIdDuMeth(Score,$MethScore)   $TaxId
	lappend LesTaxIdDuMeth(Rank,$MethRank)     $TaxId
	lappend LesTaxIdDuMeth(DeltaE,$MethDeltaE) $TaxId
	lappend LesTaxIdDuMeth(DeltaS,$MethDeltaS) $TaxId
	lappend LesTaxIdDuMeth(DeltaR,$MethDeltaR) $TaxId
	lappend LesMeth(LogExp) $MethLogExp
	lappend LesMeth(Score)  $MethScore
	lappend LesMeth(Rank)   $MethRank
	lappend LesMeth(DeltaE) $MethDeltaE
	lappend LesMeth(DeltaS) $MethDeltaS
	lappend LesMeth(DeltaR) $MethDeltaR
    }
    set LesMethCriteria [lsort -integer -$Sens $LesMeth($Criteria)]
    set LesTaxIdTries {}
    foreach MRank $LesMethCriteria {
	foreach TaxId $LesTaxIdDuMeth($Criteria,$MRank) {
	    Espionne $TaxId
	    if { ! [info exists DejaVu($TaxId)]} {set DejaVu($TaxId) 1 ; lappend LesTaxIdTries $TaxId }
	    set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
	    set MethScore  [TaxoBla $Cadre $TaxId-$Method Score]
	    set MethRank   [TaxoBla $Cadre $TaxId-$Method Rank]
	    set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
	    set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
	    set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
	    if {$MethRank==""} { continue }
	    Espionne "[BilanCilioQds $TaxId OS_]=$TaxId=$MethLogExp=$MethScore=$MethRank=$MethDeltaE=$MethDeltaS=$MethDeltaR"
	    Espionne [format "%-45s %-8s %6d %6d %6d %6d %6d %6d" [BilanCilioQds $TaxId "OS_"] $TaxId $MethLogExp $MethScore $MethRank $MethDeltaE $MethDeltaS $MethDeltaR]
	    set LesZonards {}
	    #rR Il faudrait commencer par remplir avec tout ce qui est avant le premier rang pour ne pas en perdre
	    #rR ........... mais il vaut mieux aoir le plus petit et le plus grand ...
	    foreach Ranks [RankSample "ListOfList" $Criteria] {
		set RankZone "[lindex $Ranks 0]-[lindex $Ranks end]"
		if { ! [info exists DejaVu($RankZone)]} { set DejaVu($RankZone) 1; lappend LesRankZones $RankZone }
#		set LesZonards {}
		foreach Rank $Ranks {
		    set ZonardsDuRank [TaxoBla $Cadre $TaxId-$Criteria-$Rank ListOfNom]
		    if {$ZonardsDuRank!=""} { LConcat LesZonards $ZonardsDuRank }
		}
		set NbZonards [llength $LesZonards]
		MemoZonards $NomDeDistri $TaxId-$RankZone $LesZonards set 
	    }
	}
    }
    MemoZonards $NomDeDistri "" "" unique
    set LesBeauxTaxIdTries {}
    set I 0
    foreach TaxId $LesTaxIdTries {
	lappend LesBeauxTaxIdTries "$TaxId [BilanCilioQds $TaxId OS_]"
	set J 0
	foreach RankZone $LesRankZones {
	    set N [llength [MemoZonards $NomDeDistri $TaxId-$RankZone]]
	    set T($I,$J) $N
	    incr J
	}
	incr I
    }
    set LeT [array get T]
    set K [Medals $LesBeauxTaxIdTries $LeT $LesRankZones "" "zonard" $NomDeDistri]

    set Titre "$Clade $Criteria distribution using $Method" 
    regsub ".canvas$" $K "" w
    wm title    $w $Titre
    wm iconname $w $Titre
    set B [BoutonneLaFenetre $w "Average Rank/DeltaR/DeltaE"]
    bind $B <1> "DeltaDistributionForClade $Clade $Seuil Show Average Rank"
    bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaR"
    bind $B <3> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaE"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "First Rank/DeltaR"]
    bind $B "DeltaDistributionForClade $Clade $Seuil Show First Rank"
    bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show First DeltaR"
    $B configure -background "Magenta"
    return $K

}

proc DemandeAccessibilite {system {res ""}} {


    if {[info command sqlite3]==""} { package require sqlite3 }

    set db "rootAccess"
    sqlite3 $db [file join [MiSynPatDir] data structures rsa.sql]
    lassign [$db eval {select rsamon,rsadim from rsa where system=$system}] RSAmon RSAdim
    $db close

    if {$res==""} { return [list $RSAmon $RSAdim] }

    set mon [lindex $RSAmon $res]
    set dim [lindex $RSAdim $res]

    return [list $mon $dim]

}

proc DemandeEtDessineOrgaEtSesPlaces {} {

    global RepertoireDuGenome
    
    Gs "Canvas"
    
    set Generique "orgaetsesplaces."
    set iGenerique [string length $Generique]
    set LesOrgasPossibles {}
    foreach Fichier [glob -nocomplain "$RepertoireDuGenome/fiches/$Generique*"] {
	set Orga [string range [file tail $Fichier] $iGenerique end]
	lappend LesOrgasPossibles $Orga
    }
    set Orga [ChoixParmi $LesOrgasPossibles]
    set Fichier "$RepertoireDuGenome/fiches/$Generique$Orga"
    if { ! [file exists $Fichier]} { return }
    DessineOrgaEtSesPlaces $Fichier

}

proc DemandeEtExecute {{Commande ""}} {

    global RepertoireDuGenome
    global GscopeDir

    FaireLire "Please write your instructions on the interactiv terminal window. To finish type 'return'."

    set Commande ""
    while {1} {
	puts -nonewline stdout "Gscope_: "
	flush stdout
	set Ligne [gets stdin]
	if {$Commande==""} {
	    set Commande $Ligne
	} else {
	    append Commande "\n$Ligne"
	}
	if {[info complete $Commande]} {
	    if {[regexp {^ *(return|stop) *$} $Commande]} {
		puts "Thanks for discussion. I close interaction. Bye bye !"
		return
	    }
	    if {[catch {eval $Commande} Message]} {
		puts $Message
	    }
	    set Commande ""
	}
    }

}

proc DemandeEtOuvreFichier {Extion {exc 0}} {

    set Extion [string tolower $Extion]

    set types {
	{{MSF files}		{.msf}		}
	{{Macsim/XML files}     {.xml .macsims}	}
	{{ORD Ordalie files}    {.ord}		}
	{{RSF files}	        {.rsf}		}
	{{Fasta files}		{.tfa .tfasta .fasta .fa} }
	{{Clustal files}        {.aln .clustal}	        }
	{{PDB files}            {.pdb}          }
	{{GIF files}	        {.gif}	        }
	{{Jpeg files}	        {.jpg .jpeg}    }
	{{PNG files}	        {.png}	        }
	{{text files}	        {.txt}	        }
	{{CSV file}             {.csv}          }
	{{All files}		*}
    }

    ReordonneType types $Extion $exc

    if {$Extion == ".msf"} {set Extion ""}

    return [tk_getOpenFile -filetypes $types]

}

proc DemandeEtSauveFichier {Extion {exc 0} {FichierParDefaut Untitled}} {


    set Extion [string tolower $Extion]
    set types {
	{{MSF files}		{.msf}		}
	{{Macsim/XML files}     {.xml}		}
	{{ORD ordalie files}    {.ord}		}
	{{RSF files}	        {.rsf}		}
	{{Fasta files}		{.tfa .tfasta}	}
	{{Clustal files}        {.aln}	        }
	{{Tree file}            {.ph}           }
	{{CSV file}            {.csv}           }
	{{PDB files}            {.pdb}          }
	{{O macro files}        {.omac}	        }
	{{Postscript files}     {.ps}	        }
	{{GIF files}	        {.gif}	        }
	{{PNG files}	        {.png}	        }
	{{Jpeg files}	        {.jpg .jpeg}    }
	{{PPM files}	        {.ppm}	        }
	{{All files}		*}
    }

    ReordonneType types $Extion $exc

    set file [tk_getSaveFile -filetypes $types -initialfile $FichierParDefaut]
    update idletasks

    return $file

}

proc DemandeTitreEtDescDuMac {} {

    global TiDe

    set w .tide
    toplevel $w
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix
    wm resizable $w 0 0
    wm title $w "Alignment Title"
    wm attributes $w -topmost

    frame $w.f
    grid $w.f -row 0 -column 0 -sticky news -padx 5 -pady 5

    label $w.f.lb  -text "Alignment Information"  -font "Helvetica 14 bold"  -justify left -anchor w
    label $w.f.tl  -font "Helvetica 12"  -text "Please supply an alignment title (COMPULSORY)\nand an alignment description.\nYou can also describe the current clustering"  -justify left -anchor w

    frame $w.f.ftd
    set wt "$w.f.ftd"
    label $wt.lbt  -font "Helvetica 12 bold"  -text "Alignment Title :"  -fg blue  -justify left -anchor w
    set TiDe(Wtitre) $wt.titre
    text $wt.titre  -font "Helvetica 12"  -width 20 -height 1  -background white
    label $wt.desc  -font "Helvetica 12 bold"  -text "Alignment Description :"  -fg blue  -justify left -anchor w
    set TiDe(Wdesc) $wt.tdesc
    text $wt.tdesc  -font "Helvetica 12"  -background white  -width 20 -height 3  -yscrollcommand "$wt.scr set"  -wrap word
    scrollbar $wt.scr  -width 8  -command "$wt.tdesc yview "
    grid $wt.lbt    -row 0 -column 0 -columnspan 2 -sticky ew
    grid $wt.titre  -row 1 -column 0 -columnspan 2 -sticky ew -pady {1 3}
    grid $wt.desc   -row 2 -column 0 -columnspan 2 -sticky ew
    grid $wt.tdesc  -row 3 -column 0 -sticky ew
    grid $wt.scr    -row 3 -column 1 -sticky ns
    grid columnconfig $wt 0 -weight 1

    frame $w.f.fcc
    set wc "$w.f.fcc"
    label $wc.lbt  -font "Helvetica 12 bold"  -text "Clustering Title :"  -fg blue  -justify left -anchor w
    set TiDe(Wctitre) $wc.titre
    text $wc.titre  -width 20 -height 1  -background white
    label $wc.desc  -font "Helvetica 12 bold"  -text "Clustering Description :"  -fg blue  -justify left -anchor w
    set TiDe(Wcdesc) $wc.tdesc
    text $wc.tdesc  -width 20 -height 3  -font "Helvetica 12"  -bg white  -yscrollcommand "$wc.scr set"  -state normal
    scrollbar $wc.scr  -width 8  -command "$wc.tdesc yview "
    grid $wc.lbt    -row 0 -column 0 -columnspan 2 -sticky ew
    grid $wc.titre  -row 1 -column 0 -columnspan 2 -sticky ew -pady {1 3}
    grid $wc.desc   -row 2 -column 0 -columnspan 2 -sticky ew
    grid $wc.tdesc  -row 3 -column 0 -sticky ew
    grid $wc.scr    -row 3 -column 1 -sticky ns
    grid columnconfig $wt 0 -weight 1

    frame $w.f.fb
    set wb "$w.f.fb"
    button $wb.bsav  -text " OK "  -background green1  -command [list FinDemandeTitre save $w]
    button $wb.bdis  -text "Cancel"  -background red  -command [list FinDemandeTitre dis $w]
    grid $wb.bdis -row 0 -column 0 -sticky w -padx 20
    grid $wb.bsav -row 0 -column 1 -sticky e -padx 20
    grid columnconfig $wb all -weight 1

    grid $w.f.lb -row 0 -column 0 -columnspan 2 -sticky ew
    grid $w.f.tl -row 1 -column 0 -columnspan 2 -sticky ew -pady {1 12}
    grid $wt     -row 2 -column 0 -sticky ew -padx {1 10}
    grid $wc     -row 2 -column 1 -sticky ew -padx {10 1}
    grid $wb     -row 4 -column 0 -columnspan 2 -sticky ew -pady 10
    grid rowconfig $w.f all -weight 0
    grid columnconfig $w.f all -weight 1

    FenetreAuCentre $w
	    
    tkwait window $w

    set atitre [set TiDe(titre)]
    set adesc  [set TiDe(desc)]
    set ctitre [set TiDe(ctitre)]
    set cdesc  [set TiDe(cdesc)]
    unset TiDe

   return [list $atitre $adesc $ctitre $cdesc]

}

proc Demarcation {Action K {X ""} {Y ""} {E ""}} {

    Wup "X peut etre un x de clic, une position ADN ou un Nom"
    global LesDemarcationsVerticales
    global LesDemarcationsHorizontales
    global LesAbscissesVerticales
    global LesAbscissesHorizontales
    global LesEtiquettesVerticales
    global LesEtiquettesHorizontales
    global ScrollRectangleOriginal IdScrollRectangle
    global NePasDessinerLesZonesDansLaRosace
    JeMeSignale

    scan "[$K coords [set IdScrollRectangle($K)]]" "%f %f %f %f" Gauche Haut Droite Bas

    if {$X!=""} {
	if {[regexp "SurADN_" $X]} {
	    set Nom $X
	    regsub "SurADN_" $X ""  XPositionADN
	    set XActuel [PositionCanvaActuelleX $K $XPositionADN]	    
	} else {
	    scan [$K gettags [$K find withtag current]] "%s %s %s" Nom Toi Coeur 
	    set XPositionADN [Milieu $Nom]
	    set XActuel [$K canvasx $X]
	}
	set XduTexte $XActuel
    }


    if {$Y!=""} {
	if {[regexp "SurADN_" $Y] || [regexp "SurADN_" $X]} {
	    regsub "SurADN_" $Y ""  YPositionADN
	    set YActuel [PositionCanvaActuelleY $K $YPositionADN]
	} else {
	    scan [$K gettags [$K find withtag current]] "%s %s %s" Nom Toi Coeur 
	    set YPositionADN $Toi
	    set YActuel [$K canvasy $Y]
	}
	set YduTexte $YActuel
    }

    if {[regexp "_ifyes" $Action]} {
	if { ! [OuiOuNon "Do you really want to erase the lines ?"]} { return }
    }
    regsub  "_ifyes" $Action "" Action

    if {$Action == "dall"} {
	set LesIds [$K find withtag "Ligne"]
	foreach Id $LesIds {
	    $K delete $Id
	}
	set LesIds [$K find withtag "Etiquette"]
	foreach Id $LesIds {
	    $K delete $Id
	}
	set LesDemarcationsVerticales($K)   {}
	set LesAbscissesVerticales($K)      {}
	set LesEtiquettesVerticales($K)     {}
	set LesDemarcationsHorizontales($K) {}
	set LesAbscissesHorizontales($K)    {}
	set LesEtiquettesHorizontales($K)   {}
	return
    }
    if {$Action == "dallv"} {
	set LesIds [$K find withtag "verticale"]
	foreach Id $LesIds {
	    $K delete $Id
	}
	set LesDemarcationsVerticales($K) {}
	set LesAbscissesVerticales($K) {}
	set LesEtiquettesVerticales($K)     {}
	return
    }
    if {$Action == "dallh"} {
	set LesIds [$K find withtag "horizontale"]
	foreach Id $LesIds {
	    $K delete $Id
	}
	set LesDemarcationsHorizontales($K) {}
	set LesAbscissesHorizontales($K) {}
	set LesEtiquettesHorizontales($K)   {}
	return
    }

    if {$Action == "d"} {
	set LesIds [$K find withtag current]
	foreach Id $LesIds {
	    set VouH [lindex [$K gettags $Id] 3]
	    set NomOuNum [lindex [$K gettags $Id] 0]
	    if {$VouH == "verticale"} {
		set i [lsearch [set LesDemarcationsVerticales($K)] $NomOuNum]
		if { $i < 0 } { continue }
		set LesDemarcationsVerticales($K) [lreplace [set LesDemarcationsVerticales($K)] $i $i]
		set LesAbscissesVerticales($K)    [lreplace [set LesAbscissesVerticales($K)]    $i $i]
		set LesEtiquettesVerticales($K)   [lreplace [set LesEtiquettesVerticales($K)]   $i $i]
	    }
	    if {$VouH == "horizontale"} {
		set i [lsearch $LesDemarcationsHorizontales($K) $NomOuNum]
		if { $i < 0 } { continue }
		set LesDemarcationsHorizontales($K) [lreplace [set LesDemarcationsHorizontales($K)] $i $i]
		set LesAbscissesHorizontales($K)    [lreplace [set LesAbscissesHorizontales($K)]   $i $i]
		set LesEtiquettesHorizontales($K)   [lreplace [set LesEtiquettesHorizontales($K)]  $i $i]
	    }
	    $K delete $Id
	}
	return
    }
    if {$Action == "rev"} {
	set Texte [EntreTexte [join [set LesEtiquettesVerticales($K)] "\n"]]
	if {$Texte == ""} { return }
	regsub "\n$" $Texte "" Texte
	set LesNouvellesEtiquettes [split $Texte "\n"]
	if {[llength $LesNouvellesEtiquettes] != [llength [set LesEtiquettesVerticales($K)]]} {
	    FaireLire "Sorry, you lose or add a label. I can't accept your modification"
	}
	set LesEtiquettesVerticales($K) $LesNouvellesEtiquettes
	MiseAJourDesEtiquettes $K
	return $LesNouvellesEtiquettes
    }
    if {$Action == "e"} {
	set LesIds [$K find withtag current]
	foreach Id $LesIds {
	    set VouH [lindex [$K gettags $Id] 3]
	    set NomOuNum [lindex [$K gettags $Id] 0]
	    if {$VouH == "verticale"} {
		set i [lsearch [set LesDemarcationsVerticales($K)] $NomOuNum]
		if { $i < 0 } { continue }
		set EtiquetteVerticale [lindex LesEtiquettesVerticales($K) $i]
		set NouvelleEtiquette [Entre $EtiquetteVerticale]
		if {$NouvelleEtiquette==""} { return }
		set LesEtiquettesVerticales($K) [lreplace $LesEtiquettesVerticales($K) $i $i $NouvelleEtiquette]
	    }
	    if {$VouH == "horizontale"} {
		set i [lsearch $LesDemarcationsHorizontales($K) $NomOuNum]
		if { $i < 0 } { continue }
		set EtiquetteHorizontale [lindex LesEtiquettesHorizontales($K) $i]
		set NouvelleEtiquette [Entre $EtiquetteHorizontale]
		if {$NouvelleEtiquette==""} { return }
		set LesEtiquettesHorizontales($K) [lreplace $LesEtiquettesHorizontales($K) $i $i $NouvelleEtiquette]
	    }
	}
	return
    }
    
    if {$Action == "lv"} {
	if {[info exists LesDemarcationsVerticales($K)]} {
	    return [set LesDemarcationsVerticales($K)]
	} else {
	    return {} 
	}
    }
    if {$Action == "lh"} {
	if {[info exists LesDemarcationsHorizontales($K)]} {
	    return [set LesDemarcationsHorizontales($K)]
	} else {
	    return {} 
	}
    }
    if {$Action == "av"} {
	if {[info exists LesDemarcationsVerticales($K)]} {
	    return [set LesAbscissesVerticales($K)]
	} else {
	    return {} 
	}
    }
    if {$Action == "ah"} {
	if {[info exists LesDemarcationsHorizontales($K)]} {
	    return [set LesAbscissesHorizontales($K)]
	} else {
	    return {} 
	}
    }
    if {$Action == "ev"} {
	if {[info exists LesDemarcationsVerticales($K)]} {
	    return [set LesEtiquettesVerticales($K)]
	} else {
	    return {} 
	}
    }
    if {$Action == "eh"} {
	if {[info exists LesDemarcationsHorizontales($K)]} {
	    return [set LesEtiquettesHorizontales($K)]
	} else {
	    return {} 
	}
    }

    if {$Action == "v" || $Action == "vh"} {
	if {$Action=="vh"} {
	    set Haut [expr $YActuel-5]
	    set Bas  [expr $YActuel+5]
	}
	lappend LesDemarcationsVerticales($K) $Nom
	lappend LesAbscissesVerticales($K)    $XPositionADN
	if {$E == ""} {
	    set Etiquette [NouveauNomDeZoneDeDemarcation $K]
	} else {
	    set Etiquette $E
	}
	lappend LesEtiquettesVerticales($K) $Etiquette
	TrieLesListesDeDemarcation $K "v"
	$K create line $XActuel $Haut $XActuel $Bas -tags [list $Nom $X "Ligne" "verticale"]
	$K create text $XduTexte $YduTexte  -text "$Etiquette"  -anchor "e"  -tags [list $Nom $X "Etiquette" "verticale" $Y $Etiquette]
    }
    if {$Action == "h" || $Action == "vh"} {
	if {$Action=="vh"} {
	    set Gauche [expr $XActuel-5]
	    set Droite [expr $XActuel+5]
	}
	$K create line $Gauche $YActuel $Droite $YActuel -tags [list $Nom $YPositionADN "Ligne" "horizontale"]
	lappend LesDemarcationsHorizontales($K) $YPositionADN
	lappend LesAbscissesHorizontales($K)    $YPositionADN
	lappend LesEtiquettesHorizontales($K)   [NomDe Etiquette]
	TrieLesListesDeDemarcation $K "h"
    }
    return 

}

proc DemarcationDesTRNAs {K VouH} {

    global RepertoireDuGenome

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdestrnas"] {
	scan $Ligne "%s %d %d %s" TRNA Debut Fin Orient
	set Milieu [expr ($Debut+$Fin)/2]
	set Milieux($TRNA,Moi) $Milieu
    }
    FaireLire "Please browse for the file bornesdestrnas of the other organism"
    set FichierLui [ButineArborescence "All" "$RepertoireDuGenome/"]
    set SonFichierADN "[file dirname $FichierLui]/../beton/adn"
    set LongueurLui [expr [string length [ContenuDuFichier $SonFichierADN]]-1]
    foreach Ligne [LesLignesDuFichier $FichierLui] {
	scan $Ligne "%s %d %d %s" TRNA Debut Fin Orient
	set Milieu [expr $LongueurLui - ($Debut+$Fin)/2]
	set Milieux($TRNA,Lui) $Milieu
	if {[info exists Milieux($TRNA,Moi)]} {
	    set XY($TRNA) "[set Milieux($TRNA,Moi)] $Milieu" 
	}
    }
    foreach {TRNA ValXY} [array get XY] {
	scan $ValXY "%d %d" X Y
	DemarcationEnPosition $K "vh" "SurADN_$X" "SurADN_$Y" $TRNA
    }
    return

}

proc DemarcationEnPosition {K VouH {NomOuPosition ""} {Y ""} {Etiquette ""}} {

    global ParametresDuDotPlot
    global ListeDeBoites
    global xFinLocal

    if { ! [info exists ListeDeBoites]} { ChargeLesBoites }

    if { ! [info exists xFinLocal]} {
	scan [BoundingBox $ListeDeBoites] "%d %d" xDebut xFinLocal
    }
    set xFin $xFinLocal

    set MinX [set ParametresDuDotPlot($K,MinX)]
    set MaxX [set ParametresDuDotPlot($K,MaxX)]
    set MinY [set ParametresDuDotPlot($K,MinY)]
    set MaxY [set ParametresDuDotPlot($K,MaxY)]
    set LargeurMaxi [set ParametresDuDotPlot($K,LargeurMaxi)]
    set HauteurMaxi [set ParametresDuDotPlot($K,HauteurMaxi)]

    if {$NomOuPosition == ""} {
	set NomOuPosition [Entre ""]
    }
    if {$NomOuPosition == ""} { return "" }

    set Nom "Manual"
    if {[YaPABouTROUouTRNAouARNenDebutDe $NomOuPosition]} {
	regsub {\-\+} $NomOuPosition "" Nom
	if {[Box $Nom nom]!=$Nom} {
	    FaireLire "$NomOuPosition not known"
	    return
	}
	if {[regexp {\-} $NomOuPosition]} {
	    set Position [Box $Nom debut]
	} elseif {[regexp {\+} $NomOuPosition]} {
	    set Position [Box $Nom fin]
	} else {
	    set Position [expr ([Box $Nom debut]+[Box $Nom fin])/2]
	}
	if {$Etiquette == ""} {
	    set Etiquette $Nom
	}
	set X "SurADN_$Position"
    } else {
	set X $NomOuPosition
    }
    Demarcation $VouH $K $X $Y $Etiquette

}

proc DemarcationEnPositionDansFichier {K VouH {Fichier ""}} {

    if {$Fichier == ""} {
	set Fichier [ButineArborescence]
	if {$Fichier == ""} { return }
    }
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp {"#Don't remove this line it marks the end."} $Ligne]} { break }
	if {[regexp {^\#} $Ligne]} { continue }
	if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
	set Y 100
	set Etiq "NoValue"
	set n [scan $Ligne "%s %s %s" NomOuPosition Y Etiq]
	if {$n<1} {
	    FaireLire "$Ligne\nis not correct. I'll skip it."
	}
	DemarcationEnPosition $K $VouH $NomOuPosition $Y $Etiq 
    }

}

proc DemarqueLaRosace {K {R ""}} {

    global RosaceCourante
    global NePasEffacerLesRepereBox
    global CurrentGenome
    global ParametresDuBoard
    global ParametresDuDotPlot
    global CouleurArcDeZone
    global LesCouleursDesZones
    global NePasDessinerLesZonesDansLaRosace

    set MinX [set ParametresDuDotPlot($K,MinX)]
    set MaxX [set ParametresDuDotPlot($K,MaxX)]
    set MinY [set ParametresDuDotPlot($K,MinY)]
    set MaxY [set ParametresDuDotPlot($K,MaxY)]
    set LargeurMaxi [set ParametresDuDotPlot($K,LargeurMaxi)]
    set HauteurMaxi [set ParametresDuDotPlot($K,HauteurMaxi)]


    if {$R==""} {
	if { ! [info exists RosaceCourante]} {
	    RscopeBoard $CurrentGenome
	}
	set R $RosaceCourante
    }

    if { ! [info exists ParametresDuBoard($R,IemeCouche)]} {
	set ParametresDuBoard($R,IemeCouche) 0
    }
    incr ParametresDuBoard($R,IemeCouche)
    set PI 3.14159

    set xFin           [set ParametresDuBoard($R,xFin)]
    set CentreX        [set ParametresDuBoard($R,CentreX)]
    set CentreY        [set ParametresDuBoard($R,CentreY)]
    set RayonMoyen     [set ParametresDuBoard($R,RayonMoyen)]
    set OffsetRayonMin [set ParametresDuBoard($R,OffsetRayonMin)]
    set OffsetRayonMax [set ParametresDuBoard($R,OffsetRayonMax)]
    set IemeCouche     [set ParametresDuBoard($R,IemeCouche)]

    set RayonInt [expr $RayonMoyen + $OffsetRayonMax + $IemeCouche*$OffsetRayonMax*0.5]
    set RayonExt $RayonInt

    set LesNoms [Demarcation "lv" $K]
    set LesXs   [Demarcation "av" $K]
    set LesEtiq [Demarcation "ev" $K]

    set RayonCourant $RayonExt
    set NePasEffacerLesRepereBox 1
    set LesCouleursDesZones {}
    foreach Nom $LesNoms X $LesXs Etiq $LesEtiq {
	set MaPos $X
	set Angle [Entre0Et2PI [expr $PI/2-$MaPos*2*$PI/$xFin]]
	Espionne "$Nom $X $Etiq $MaPos $Angle"
	if {[regexp -nocase "vide" $Etiq]} { set NonVide 0 } else { set NonVide 1 }
	if { 0 && $RayonCourant == $RayonInt } {
	    set RayonCourant $RayonExt
	} else {
	    set RayonCourant $RayonInt
	}
	set PosX [PositionCanvaActuelleX $R [expr $CentreX+$RayonCourant*cos($Angle)]]
	set PosY [PositionCanvaActuelleY $R [expr $CentreY-$RayonCourant*sin($Angle)]]
	
#	RepereBox "Nom: $Nom" $R "SansInforme"
	if {[info exists OldPosX]} {
	    set OldHeure [Entre0Et2PI [expr $PI/2-$OldAngle]]
	    set    Heure [Entre0Et2PI [expr $PI/2-$Angle]]
	    set HeureTexte   [Entre0Et2PI [expr ($OldHeure+$Heure)/2]]
	    set AngleCouleur [Entre0Et2PI [expr $HeureTexte+2*$PI/12]]
	    set AngleTexte   [Entre0Et2PI [expr $PI/2-$HeureTexte]]
	    set TextePosX [expr $CentreX+$RayonCourant*0.97*cos($AngleTexte)]
	    set TextePosY [expr $CentreY-$RayonCourant*0.97*sin($AngleTexte)]
	    if {$NonVide} {
#		set CouleurArcDeZone [Nuance $AngleCouleur/(2*$PI) 0.0 0.987]
		set CouleurArcDeZone  [CouleurExquiseDeLaZone $Etiq "VraieCouleur"]
		set CouleurEtiquettee [CouleurExquiseDeLaZone $Etiq ""]
	    } else {
		set CouleurArcDeZone "VIDE"
		set CouleurEtiquettee "VIDE"
	    }
	    set OldPosADN [expr $OldHeure*$xFin/(2*$PI)]
	    set PosADN [expr $Heure*$xFin/(2*$PI)]
	    lappend LesCouleursDesZones "$OldPosADN $PosADN $CouleurEtiquettee"
	    if {$NonVide} {
		set MemoCouleurArcDeZone $CouleurArcDeZone
		set CouleurArcDeZone "black"
		set Delta [expr [LongueurADN]/977]
		if { ! [info exists NePasDessinerLesZonesDansLaRosace]} {
#		    set IdP [ShowNucRosace $R $OldPosX $OldPosY "Point"  $OldMaPos]
#		    set IdM [ShowNucRosace $R    $PosX    $PosY "Motion" [expr $MaPos]]
		    set CouleurArcDeZone $MemoCouleurArcDeZone
		    set IdP [ShowNucRosace $R $OldPosX $OldPosY "Point"  [expr $OldMaPos+$Delta]]
		    set IdM [ShowNucRosace $R    $PosX    $PosY "Motion" [expr $MaPos-$Delta]]
		    $R addtag "Zone" withtag $IdM
		    FlecheSurArc $R $IdM "F"
		    $R create text $TextePosX $TextePosY  -text "$Etiq"  -anchor "c"  -font {Courier 10}  -tags [list "$Etiq" "Etiquette"]
		}
	    }
	    unset CouleurArcDeZone
	}

	BindLaRosace $R

	set OldMaPos $MaPos
	set OldPosX $PosX
	set OldPosY $PosY
	set OldAngle $Angle
    }
    catch {unset NePasEffacerLesRepereBox}
    return $R

}

proc DemarqueLeDotPlot {K {D ""}} {

    global RosaceCourante
    global NePasEffacerLesRepereBox
    global CurrentGenome
    global LesDotPlotCourants 

    if {$D==""} {
	if {[llength $LesDotPlotCourants]==1} {
	    FaireLire "Please, open an other DotPlot."
	    return 
	}
	set i [lsearch $LesDotPlotCourants $K]
	set LesAutres [lreplace $LesDotPlotCourants $i $i]
	set D [ChoixParmi $LesAutres]
	if {$D==""} { return }
    }

    set LesNoms [Demarcation "lv" $K]
    set LesXs   [Demarcation "av" $K]
    set LesEtiq [Demarcation "ev" $K]

    foreach Nom $LesNoms X $LesXs Etiq $LesEtiq {
	Demarcation v $D $X $Nom $Etiq
    }

}

proc DemarrageOrdali {{w ""}} {

    global OrdEtcDir PBV PBW
    
    if {! [ModeI]} {
	return
    }

    set fimg [file join $OrdEtcDir macsim_init.gif]
    set ph [image create photo]
    $ph read $fimg -format gif
    
    if {$w ne ""} {
	set top $w
	toplevel $w
    } else {
	set top .
    }
    wm title $top "Loading Ordalie"
    wm withdraw $top

    set PBV 0.
    set PBW "loading ..."

    frame $w.dmg
    pack $w.dmg
    label $w.dmg.l -image $ph
    label $w.dmg.w -textvariable PBW -anchor w -bg white
    ttk::progressbar $w.dmg.p  -variable PBV

    pack $w.dmg.l $w.dmg.w $w.dmg.p -side top -fill x
    wm attributes $top -topmost
    wm deiconify $top

    FenetreAuCentre $w.dmg
    raise $top

    update idletasks

    return

}

proc DenicheEtCompareLesIntegersEnDebut {TexteA TexteB} {

    regsub -all {[^0-9]} $TexteA " " TexteA
    regsub -all {[^0-9]} $TexteB " " TexteB
    return [CompareLesIntegersEnDebut $TexteA $TexteB]

}

proc DenombreLaListe {l} {

    set res [list]
    foreach e [lsort -unique $l] {
        lappend res [list $e [llength [lsearch -all $l $e]]]
    }
    return [lsort -integer -decreasing -index 1 $res]

}

proc DenombreLeTableau {aT} {

    upvar $aT T

    set Lres [list]
    foreach a [array names T] {
	lappend Lres [list $a [llength [set T($a)]]]
    }
    set Lres [lsort -integer -index 1 -decreasing $Lres]

    return [ExtraitListeDeListe $Lres 0]

}

proc DenombreMotsDansFichier {Fichier Mots} {

    if {![file exist "./$Fichier"]} {return ""} 
    set n [regsub -all "$Mots" [ContenuDuFichier $Fichier] "$Mots" Texte]
    return "$n"

}

proc DepartSequencage {{LesFichiersRec1 ""} {Quoi ""}} {

    if {$LesFichiersRec1==""} {
	FaireLire "Please select the rec1 files You want to send to the Sequencing Service"
	set LesFichiersRec1 [LesFichiersDeType "Rec1"]
    }
    set RepDepartSequencage "[RepertoireDuGenome]/departsequencage" 
    if { ! [file exists $RepDepartSequencage]} { File mkdir $RepDepartSequencage }
    set FichierNDSFic "$RepDepartSequencage/nds_fichier"

    if {$LesFichiersRec1=="GetAll" && $Quoi=="Lines"} {
	if {[file exists $FichierNDSFic]} {
	    return [LesLignesDuFichier $FichierNDSFic]
	} else {
	    return {}
	}
    }
    set DernierNDS "NDS10000"
    if {[file exists $FichierNDSFic]} {
	foreach Ligne [LesLignesDuFichier $FichierNDSFic] {
	    scan $Ligne "%s %s" NDS Fichier
	    set FichierDepartSequencage($NDS) $Fichier
	    lappend NumeroDepartSequencage($Fichier) $NDS
	    set DernierNDS $NDS
	}
    }
    if {$LesFichiersRec1=="GetAll" && $Quoi=="Files"} {
	return [lsort [array names NumeroDepartSequencage]]
    }
    if {$LesFichiersRec1=="GetAll" && $Quoi=="NDS"} {
	return [lsort [array names FichierDepartSequencage]]
    }
    if {$LesFichiersRec1=="GetLast" && $Quoi=="NDS"} {
	return [lindex [lsort [array names FichierDepartSequencage]] end]
    }
    if {$LesFichiersRec1=="GetNdsOf"} {
	if {[info exists NumeroDepartSequencage($Quoi)]} {
	    return [set NumeroDepartSequencage($Quoi)]
	} else {
	    return ""
	}
    }
    if {$LesFichiersRec1=="GetFilesOf" || $LesFichiersRec1=="GetFileOf"} {
	if {[info exists FichierDepartSequencage($Quoi)]} {
	    return [set FichierDepartSequencage($Quoi)]
	} else {
	    return ""
	}
    }

    regsub "NDS" $DernierNDS "" NumDernier
    set LesNouveaux {}
    foreach Fichier $LesFichiersRec1 {
	set DernierNDS [format "NDS%5.5d" [incr NumDernier]]
	lappend LesNouveaux "$DernierNDS $Fichier"
    }
    while 1 { 
	set Texte "\n\n         Please Validate /All or //No \n\n"
	append Texte [join $LesNouveaux "\n"]
	append Texte "\n\n         Please Validate /All or //No"
	set OK [AfficheVariable $Texte "AvecRetour" "New_Departure_to_Sequencing_Service"]
	if {$OK!=""} { break }
	if {[OuiOuNon "Do I cancel Departure to Sequencing Service ?"]} { return {} }
    }
    foreach Ligne $LesNouveaux {
	scan $Ligne "%s %s" NDS Fichier
	set FichierDepartSequencage($NDS) $Fichier
	lappend NumeroDepartSequencage($Fichier) $NDS
    }
    set LesToutLeMonde {}
    foreach NDS [lsort [array names FichierDepartSequencage]] {
	lappend LesToutLeMonde "$NDS [set FichierDepartSequencage($NDS)]"
    }
    SauveLesLignes $LesToutLeMonde dans $FichierNDSFic
    return $LesNouveaux

}

proc DepouilleLeBlast {aTabBlast FichierBlast {ExpectDeRef ""} {NbSubjectTot ""} {LesBIdOuAccess ""}} {

    upvar $aTabBlast TabBlast

    set Compteur 0

    if {$ExpectDeRef  == ""} {set ExpectDeRef "1e200"}
    if {$NbSubjectTot == ""} {set NbSubjectTot "1e200"}
    
    if {![file exists $FichierBlast]} {return ""}

    set SuisJeSurLesAlignements 0
    set SuisJeSurUnAlignement 0
    set ToutLeSubject ""
    set TousLesSubjects {}
    set j 0

    set SuisJeSurLeNomDeLaQuery 0

    set TailleMaxDUnFichier [expr 25*1e6]
    if {$TailleMaxDUnFichier < [file size $FichierBlast]} {
	set NbHitsMax 10000
	Espionne "$FichierBlast is too long, we are going to study only the $NbHitsMax first hits"
    } else {
	set NbHitsMax "NoLimit"
    }

    foreach BIdOuAccess $LesBIdOuAccess {
	scan $BIdOuAccess "%s" BIdOuAccess
	set  TabAccessOK($BIdOuAccess) 1
	set  BIdOuAccess [string toupper $BIdOuAccess]
	set  TabAccessOK($BIdOuAccess) 1
    }

    set NomQuery {}
    set F [open $FichierBlast]
    set nHits 0
    while {[gets $F Ligne]>=0} {
	if {[string range $Ligne 0 6] == "Query= "} {
	    set SuisJeSurLeNomDeLaQuery 1
	    set Ligne [string range $Ligne 7 end]
	}
	if {!$SuisJeSurLesAlignements && [regexp "\[0-9\.]* letters" $Ligne]} {
	    set SuisJeSurLeNomDeLaQuery 0 
	}
	if {$SuisJeSurLeNomDeLaQuery} {
	    regsub "\n" $Ligne " " Ligne
	    lappend NomQuery [string trim $Ligne]
	}
	incr j
	if {$j == 1 || $j == 2} {
	    if {[string range $Ligne 0 4] == "BLAST" || [string range $Ligne 0 5] == "TBLAST"} {
		set LigneTrim   [string trim  $Ligne]
		set TypeDeBlast [string range $LigneTrim 0 [expr [string first " " $LigneTrim]-1]]
		set TabBlast(TypeDeBlast) $TypeDeBlast
	    }
	}
	if {[string range $Ligne 0 11] == "  Database: " || [string range $Ligne 0 7] == "Matrix: "} {
#	if {[regexp {(Database|Matrix): } $Ligne]} {}
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    regsub "\n" $Ligne "" Ligne
	    regsub {(Database|Matrix): } $Ligne "" Ligne
	    set TabBlast(Database) [string trim $Ligne]
	    set SuisJeSurLesAlignements 0
	    break
	}
	if {[string range $Ligne 0 0] != ">" && $SuisJeSurLesAlignements == 0} {continue}
	if {[string range $Ligne 0 8] == " Score = "} {incr nHits}
	if {$NbHitsMax != "NoLimit" && $NbHitsMax < $nHits} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    break
	}
	if {[string range $Ligne 0 0] == ">"} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    set ToutLeSubject ""

	    set SuisJeSurLesAlignements 1
	    set SuisJeSurUnAlignement 1
	    append ToutLeSubject "$Ligne"
	} elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
	    append ToutLeSubject "\n$Ligne"
	}	
    }
    close $F

    if {0} {
	set T1 [clock clicks -milliseconds]
	set T2 [clock clicks -milliseconds]
	set T3 [clock clicks -milliseconds]
	Espionne "[expr $T2-$T1] [expr $T3-$T2]"
    }

    set NbSubject 0
    foreach Subject  $TousLesSubjects {
	#if {![regexp -nocase "SW:SAMP_CAVPO" $Subject]} {continue}
	regsub -all {Expect[ 0-9\(\)]* =} $Subject "Expect =" Subject

	set AiJeAuMoinsUnExpectCorrect 0
	set Tmp $Subject
	while {[regexp { Expect =([ e0-9\.\-]*)} $Tmp ToutLExpect Expect]} {
	    set Expect  [string trim $Expect]
	    if {[string range $Expect 0 0] == "e"} {set Expect "1$Expect"}
	    if {$Expect <= $ExpectDeRef} {set AiJeAuMoinsUnExpectCorrect 1;break}
	    regsub { Expect =[ e0-9\.\-]*} $Tmp "" Tmp
	}
	unset Tmp

	if {!$AiJeAuMoinsUnExpectCorrect} {continue}
	set SubjectBrut $Subject
	####BanqueId et Access et definition et Taille######
	regexp -indices " Length = " $Subject DebFin
	set EnteteSubject [string trim [string range $Subject 1                  [lindex $DebFin 0]]]
	set Subject                    [string range $Subject [lindex $DebFin 0] end               ]

	regsub  -all "\n"    $EnteteSubject " " EnteteSubject
	regsub  -all {\(|\)} $EnteteSubject "_" EnteteSubject
	while {[regexp "  " $EnteteSubject]} {regsub -all "  " $EnteteSubject " " EnteteSubject}
	set LEnteteSubject [split $EnteteSubject " "]
	set BanqueId       [lindex $LEnteteSubject 0]
	set BANQUEID       [string toupper $BanqueId]
	set Access         [lindex $LEnteteSubject 1]
	regsub "^_" $Access "" Access
	regsub "_$" $Access "" Access

	set ACCESS         [string toupper $Access  ]
	set Definition     [join [lrange $LEnteteSubject 2 end] " "]
	if {$Access == ""} {
	    set Access     $BanqueId
	    set Definition ""
	} elseif {![regexp -nocase {^[a-z]} $Access] || [EstUnAccessPDB $BanqueId]} {
	    set Access $BanqueId
	    set Definition [join [lrange $LEnteteSubject 1 end] " "]
	}
	#########Elimination en fonction de l'access ou du banqueid##################
	if {$LesBIdOuAccess != ""} {
	    if {![info exists TabAccessOK($ACCESS)] && ![info exists TabAccessOK($BANQUEID)]} {continue}
	}
	incr NbSubject
	if {$NbSubjectTot < $NbSubject} {incr NbSubject -1;break} 
	#############################################################################
	regexp -nocase { Length = ([0-9]+)[ ]*\n} $Subject tmp Taille 
	regsub         { Length = [0-9]+[ ]*\n}   $Subject ""  Subject

	set TabBlast($NbSubject)            $BanqueId
	set TabBlast($BanqueId,Access)      $Access
	set TabBlast($BanqueId,Definition)  $Definition
	set TabBlast($BanqueId,Taille)      $Taille
	set TabBlast($BanqueId,SubjectBrut) $SubjectBrut

	##############Split les alignements du subject##############
	set SuisJeSurUnAlignement 0
	set LesAlignements {}
	set LAlignement    {}
	foreach Ligne [split $Subject "\n"] {
	    if {[regexp -nocase "Score = " $Ligne]} {
		if {$LAlignement != {}} {
		    lappend LesAlignements [join $LAlignement "\n"]
		    set LAlignement {}
		}
		lappend LAlignement $Ligne 
		set SuisJeSurUnAlignement 1
	    } elseif {$SuisJeSurUnAlignement} {
		lappend LAlignement $Ligne
	    }
	}
	lappend LesAlignements [join $LAlignement "\n"]

	##############Decomposition des alignements###########
	set NbSegment 0
	foreach Alignement $LesAlignements {
	    set AlignementBrut $Alignement
	    incr NbSegment
	    set TabBlast($BanqueId,$NbSegment,AlignBrut) $Alignement

	    set Score ""
	    set Expect ""
	    set Identities ""
	    set Gaps ""
	    set Orientation ""
	    set Positives ""
	    set Query ""
	    set Sbjct ""
	    set Inter ""
	    set AlignementLineaire "" 
	    set DebutQuery ""
	    set FinQuery ""
	    set DebutSbjct "" 
	    set FinSbjct ""
	    
	    regexp { Score = ([e0-9a-z\.\+\(\) ]+)} $Alignement tmp Score 
	    regsub { Score = [e0-9a-z\.\+\(\) ]+}   $Alignement "" Alignement
	    set Score [string trim $Score]

	    regexp { Expect =([ e0-9\.\-]+)} $Alignement tmp Expect
	    regsub { Expect =[ e0-9\.\-]+}   $Alignement ""  Alignement
	    set Expect [string trim $Expect]
	    if {[regexp "^e" $Expect]} { set Expect "1$Expect"}

	    regexp { Identities = ([0-9a-z\/\%\(\) ]+)} $Alignement tmp Identities 
	    regsub { Identities = [0-9a-z\/\%\(\) ]+}   $Alignement ""  Alignement
	    set Identities [string trim $Identities]

	    if {[regexp { Positives = ([0-9\/\%\(\) ]+)} $Alignement tmp Positives]} {
		regsub  { Positives = [0-9\/\%\(\) ]+}   $Alignement "" Alignement
	    }
	    set Positives [string trim $Positives]

	    if {[regexp { Gaps = ([0-9\/\%\(\) ]+)} $Alignement tmp Gaps]} {
		regsub  { Gaps = [0-9\/\%\(\) ]+}   $Alignement "" Alignement
	    }
	    set Gaps [string trim $Gaps]

	    regexp -nocase { [a-z]+ = ([0-9a-z\/\-\+ ]+)} $Alignement tmp Orientation 
	    regsub -nocase { [a-z]+ = [0-9a-z\/\-\+ ]+}   $Alignement ""  Alignement
	    set Orientation [string trim $Orientation]

	    regsub -all "," $Alignement "" Alignement
	    set Alignement [string trim $Alignement]
	    foreach Ligne  [split $Alignement "\n"] {
		if {$Query != "" && [regexp {^Query: [0-9 ]+} $Ligne]} {
		    regsub {[0-9 ]+$}   $Query ""  Query
		    append Query [string range $Ligne $n end]
		}
		if {$Sbjct != "" && [regexp {^Sbjct: [0-9 ]+} $Ligne]} {
		    regsub {[0-9 ]+$}   $Sbjct ""  Sbjct
		    append Sbjct [string range $Ligne $n end]
		}
		if {      $Inter != ""                          &&  [regexp -nocase {^  }         $Ligne] &&  [regexp -nocase {[a-z\|\-\+]} $Ligne]} {
		    append Inter [string range $Ligne $n end]
		}

		if {      $Query == "" &&  [regexp {^Query: ([0-9 ]+)} $Ligne tmp DebutQuery]} {
		    set n  [string length $tmp]
		    append Query $Ligne
		}
		if {      $Sbjct == "" &&  [regexp {^Sbjct: ([0-9 ]+)}  $Ligne tmp DebutSbjct]} {
		    append Sbjct $Ligne
		}
		if {      $Inter == ""                  &&  [regexp {^  }         $Ligne] &&  [regexp {[a-z\|\-\+]} $Ligne] } {
		    append Inter $Ligne
		}
	    }
	    regexp {([0-9]+)[ ]*$} $Query tmp FinQuery
	    regexp {([0-9]+)[ ]*$} $Sbjct tmp FinSbjct

	    if {$AlignementLineaire != ""} {set AlignementLineaire "\n"}
	    append AlignementLineaire      "$Query\n$Inter\n$Sbjct"

	    set TabBlast($BanqueId,$NbSegment,Score)         $Score
	    set TabBlast($BanqueId,$NbSegment,Expect)        $Expect
	    set TabBlast($BanqueId,$NbSegment,Identities)    $Identities
	    set TabBlast($BanqueId,$NbSegment,Positives)     $Positives
	    set TabBlast($BanqueId,$NbSegment,Gaps)          $Gaps
	    set TabBlast($BanqueId,$NbSegment,Orientation)   $Orientation
	    set TabBlast($BanqueId,$NbSegment,Align)         $Alignement
	    set TabBlast($BanqueId,$NbSegment,AlignLineaire) $AlignementLineaire
	    set TabBlast($BanqueId,$NbSegment,AlignBrut)     $AlignementBrut
	    set TabBlast($BanqueId,$NbSegment,DQ)            [string trim $DebutQuery]
	    set TabBlast($BanqueId,$NbSegment,FQ)            [string trim $FinQuery  ]
	    set TabBlast($BanqueId,$NbSegment,DS)            [string trim $DebutSbjct]
	    set TabBlast($BanqueId,$NbSegment,FS)            [string trim $FinSbjct  ]
	}
	set TabBlast($BanqueId,NbSegment) $NbSegment
    }
    set NomQuery [join $NomQuery " "]
    while {[regexp "  " $NomQuery]} {regsub -all "  " $NomQuery " " NomQuery}
    set TabBlast(Query) $NomQuery

    set TabBlast(Taille) [TailleDeLaQueryDuBlast $FichierBlast]

    set TabBlast(NbSubject) $NbSubject
    return $aTabBlast

}

proc DepouilleLeBlast2 {aTabBlast FichierBlast {ExpectDeRef ""} {NbSubjectTot ""} {LesBIdOuAccess ""}} {

    upvar $aTabBlast TabBlast

    set Compteur 0

    if {$ExpectDeRef  == ""} {set ExpectDeRef "1e200"}
    if {$NbSubjectTot == ""} {set NbSubjectTot "1e200"}
    
    if {![file exists $FichierBlast]} {return ""}

    set SuisJeSurLesAlignements 0
    set SuisJeSurUnAlignement 0
    set ToutLeSubject ""
    set TousLesSubjects {}
    set j 0

    set SuisJeSurLeNomDeLaQuery 0

    set TailleMaxDUnFichier [expr 25*1e6]
    if {$TailleMaxDUnFichier < [file size $FichierBlast]} {
	set NbHitsMax 10000
	Espionne "$FichierBlast is too long, we are going to study only the $NbHitsMax first hits"
    } else {
	set NbHitsMax "NoLimit"
    }

    foreach BIdOuAccess $LesBIdOuAccess {
	scan $BIdOuAccess "%s" BIdOuAccess
	set  TabAccessOK($BIdOuAccess) 1
	set  BIdOuAccess [string toupper $BIdOuAccess]
	set  TabAccessOK($BIdOuAccess) 1
    }

    set NomQuery {}
    set F [open $FichierBlast]
    set nHits 0
    while {[gets $F Ligne]>=0} {
	if {[string range $Ligne 0 6] == "Query= "} {
	    set SuisJeSurLeNomDeLaQuery 1
	    set Ligne [string range $Ligne 7 end]
	}
	if {!$SuisJeSurLesAlignements && [regexp "\[0-9\.]* letters" $Ligne]} {
	    set SuisJeSurLeNomDeLaQuery 0 
	}
	if {$SuisJeSurLeNomDeLaQuery} {
	    regsub "\n" $Ligne " " Ligne
	    lappend NomQuery [string trim $Ligne]
	}
	incr j
	if {$j == 1 || $j == 2} {
	    if {[string range $Ligne 0 4] == "BLAST" || [string range $Ligne 0 5] == "TBLAST"} {
		set LigneTrim   [string trim  $Ligne]
		set TypeDeBlast [string range $LigneTrim 0 [expr [string first " " $LigneTrim]-1]]
		set TabBlast(TypeDeBlast) $TypeDeBlast
	    }
	}
	if {[string range $Ligne 0 11] == "  Database: " || [string range $Ligne 0 7] == "Matrix: "} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    regsub "\n" $Ligne "" Ligne
	    regsub " Database: " $Ligne "" Ligne
	    set TabBlast(Database) [string trim $Ligne]
	    set SuisJeSurLesAlignements 0
	    break
	}
	if {[string range $Ligne 0 0] != ">" && $SuisJeSurLesAlignements == 0} {continue}
	if {[string range $Ligne 0 8] == " Score = "} {incr nHits}
	if {$NbHitsMax != "NoLimit" && $NbHitsMax < $nHits} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    break
	}
	if {[string range $Ligne 0 0] == ">"} {
	    if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject}
	    set ToutLeSubject ""

	    set SuisJeSurLesAlignements 1
	    set SuisJeSurUnAlignement 1
	    append ToutLeSubject "$Ligne"
	} elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} {
	    append ToutLeSubject "\n$Ligne"
	}	
    }
    close $F

    if {0} {
	set T1 [clock clicks -milliseconds]
	set T2 [clock clicks -milliseconds]
	set T3 [clock clicks -milliseconds]
	Espionne "[expr $T2-$T1] [expr $T3-$T2]"
    }

    set NbSubject 0
    foreach Subject  $TousLesSubjects {
	#if {![regexp -nocase "SW:SAMP_CAVPO" $Subject]} {continue}
	regsub -all {Expect[ 0-9\(\)]* =} $Subject "Expect =" Subject

	set AiJeAuMoinsUnExpectCorrect 0
	set Tmp $Subject
	while {[regexp { Expect =([ e0-9\.\-]*)} $Tmp ToutLExpect Expect]} {
	    set Expect  [string trim $Expect]
	    if {[string range $Expect 0 0] == "e"} {set Expect "1$Expect"}
	    if {$Expect <= $ExpectDeRef} {set AiJeAuMoinsUnExpectCorrect 1;break}
	    regsub { Expect =[ e0-9\.\-]*} $Tmp "" Tmp
	}
	unset Tmp

	if {!$AiJeAuMoinsUnExpectCorrect} {continue}
	set SubjectBrut $Subject
	####BanqueId et Access et definition et Taille######
	regexp -indices " Length = " $Subject DebFin
	set EnteteSubject [string trim [string range $Subject 1                  [lindex $DebFin 0]]]
	set Subject                    [string range $Subject [lindex $DebFin 0] end               ]

	regsub  -all "\n"    $EnteteSubject " " EnteteSubject
	regsub  -all {\(|\)} $EnteteSubject "_" EnteteSubject
	while {[regexp "  " $EnteteSubject]} {regsub -all "  " $EnteteSubject " " EnteteSubject}
	set LEnteteSubject [split $EnteteSubject " "]
	set BanqueId       [lindex $LEnteteSubject 0]
	set BANQUEID       [string toupper $BanqueId]
	set Access         [lindex $LEnteteSubject 1]
	regsub "^_" $Access "" Access
	regsub "_$" $Access "" Access

	set ACCESS         [string toupper $Access  ]
	set Definition     [join [lrange $LEnteteSubject 2 end] " "]
	if {$Access == ""} {
	    set Access     $BanqueId
	    set Definition ""
	} elseif {![regexp -nocase {^[a-z]} $Access] || [EstUnAccessPDB $BanqueId]} {
	    set Access $BanqueId
	    set Definition [join [lrange $LEnteteSubject 1 end] " "]
	}
	#########Elimination en fonction de l'access ou du banqueid##################
	if {$LesBIdOuAccess != ""} {
	    if {![info exists TabAccessOK($ACCESS)] && ![info exists TabAccessOK($BANQUEID)]} {continue}
	}
	incr NbSubject
	if {$NbSubjectTot < $NbSubject} {incr NbSubject -1;break} 
	#############################################################################
	regexp -nocase { Length = ([0-9]+)[ ]*\n} $Subject tmp Taille 
	regsub         { Length = [0-9]+[ ]*\n}   $Subject ""  Subject

	set TabBlast($NbSubject)            $BanqueId
	set TabBlast($BanqueId,Access)      $Access
	set TabBlast($BanqueId,Definition)  $Definition
	set TabBlast($BanqueId,Taille)      $Taille
	set TabBlast($BanqueId,SubjectBrut) $SubjectBrut

	##############Split les alignements du subject##############
	set SuisJeSurUnAlignement 0
	set LesAlignements {}
	set LAlignement    {}
	foreach Ligne [split $Subject "\n"] {
	    if {[regexp -nocase "Score = " $Ligne]} {
		if {$LAlignement != {}} {
		    lappend LesAlignements [join $LAlignement "\n"]
		    set LAlignement {}
		}
		lappend LAlignement $Ligne 
		set SuisJeSurUnAlignement 1
	    } elseif {$SuisJeSurUnAlignement} {
		lappend LAlignement $Ligne
	    }
	}
	lappend LesAlignements [join $LAlignement "\n"]

	##############Decomposition des alignements###########
	set NbSegment 0
	foreach Alignement $LesAlignements {
	    set AlignementBrut $Alignement
	    incr NbSegment
	    set TabBlast($BanqueId,$NbSegment,AlignBrut) $Alignement

	    set Score ""
	    set Expect ""
	    set Identities ""
	    set Gaps ""
	    set Orientation ""
	    set Positives ""
	    set Query ""
	    set Sbjct ""
	    set Inter ""
	    set AlignementLineaire "" 
	    set DebutQuery ""
	    set FinQuery ""
	    set DebutSbjct "" 
	    set FinSbjct ""
	    
	    regexp { Score = ([e0-9a-z\.\+\(\) ]+)} $Alignement tmp Score 
	    regsub { Score = [e0-9a-z\.\+\(\) ]+}   $Alignement "" Alignement
	    set Score [string trim $Score]

	    regexp { Expect =([ e0-9\.\-]+)} $Alignement tmp Expect
	    regsub { Expect =[ e0-9\.\-]+}   $Alignement ""  Alignement
	    set Expect [string trim $Expect]
	    if {[regexp "^e" $Expect]} { set Expect "1$Expect"}

	    regexp { Identities = ([0-9a-z\/\%\(\) ]+)} $Alignement tmp Identities 
	    regsub { Identities = [0-9a-z\/\%\(\) ]+}   $Alignement ""  Alignement
	    set Identities [string trim $Identities]

	    if {[regexp { Positives = ([0-9\/\%\(\) ]+)} $Alignement tmp Positives]} {
		regsub  { Positives = [0-9\/\%\(\) ]+}   $Alignement "" Alignement
	    }
	    set Positives [string trim $Positives]

	    if {[regexp { Gaps = ([0-9\/\%\(\) ]+)} $Alignement tmp Gaps]} {
		regsub  { Gaps = [0-9\/\%\(\) ]+}   $Alignement "" Alignement
	    }
	    set Gaps [string trim $Gaps]

	    regexp -nocase { [a-z]+ = ([0-9a-z\/\-\+ ]+)} $Alignement tmp Orientation 
	    regsub -nocase { [a-z]+ = [0-9a-z\/\-\+ ]+}   $Alignement ""  Alignement
	    set Orientation [string trim $Orientation]

	    regsub -all "," $Alignement "" Alignement
	    set Alignement [string trim $Alignement]
	    foreach Ligne  [split $Alignement "\n"] {
		if {$Query != "" && [regexp {^Query: [0-9 ]+} $Ligne]} {
		    regsub {[0-9 ]+$}   $Query ""  Query
		    append Query [string range $Ligne $n end]
		}
		if {$Sbjct != "" && [regexp {^Sbjct: [0-9 ]+} $Ligne]} {
		    regsub {[0-9 ]+$}   $Sbjct ""  Sbjct
		    append Sbjct [string range $Ligne $n end]
		}
		if {      $Inter != ""                          &&  [regexp -nocase {^  }         $Ligne] &&  [regexp -nocase {[a-z\|\-\+]} $Ligne]} {
		    append Inter [string range $Ligne $n end]
		}

		if {      $Query == "" &&  [regexp {^Query: ([0-9 ]+)} $Ligne tmp DebutQuery]} {
		    set n  [string length $tmp]
		    append Query $Ligne
		}
		if {      $Sbjct == "" &&  [regexp {^Sbjct: ([0-9 ]+)}  $Ligne tmp DebutSbjct]} {
		    append Sbjct $Ligne
		}
		if {      $Inter == ""                  &&  [regexp {^  }         $Ligne] &&  [regexp {[a-z\|\-\+]} $Ligne] } {
		    append Inter $Ligne
		}
	    }
	    regexp {([0-9]+)[ ]*$} $Query tmp FinQuery
	    regexp {([0-9]+)[ ]*$} $Sbjct tmp FinSbjct

	    if {$AlignementLineaire != ""} {set AlignementLineaire "\n"}
	    append AlignementLineaire      "$Query\n$Inter\n$Sbjct"

	    set TabBlast($BanqueId,$NbSegment,Score)         $Score
	    set TabBlast($BanqueId,$NbSegment,Expect)        $Expect
	    set TabBlast($BanqueId,$NbSegment,Identities)    $Identities
	    set TabBlast($BanqueId,$NbSegment,Positives)     $Positives
	    set TabBlast($BanqueId,$NbSegment,Gaps)          $Gaps
	    set TabBlast($BanqueId,$NbSegment,Orientation)   $Orientation
	    set TabBlast($BanqueId,$NbSegment,Align)         $Alignement
	    set TabBlast($BanqueId,$NbSegment,AlignLineaire) $AlignementLineaire
	    set TabBlast($BanqueId,$NbSegment,AlignBrut)     $AlignementBrut
	    set TabBlast($BanqueId,$NbSegment,DQ)            [string trim $DebutQuery]
	    set TabBlast($BanqueId,$NbSegment,FQ)            [string trim $FinQuery  ]
	    set TabBlast($BanqueId,$NbSegment,DS)            [string trim $DebutSbjct]
	    set TabBlast($BanqueId,$NbSegment,FS)            [string trim $FinSbjct  ]
	}
	set TabBlast($BanqueId,NbSegment) $NbSegment
    }
    set NomQuery [join $NomQuery " "]
    while {[regexp "  " $NomQuery]} {regsub -all "  " $NomQuery " " NomQuery}
    set TabBlast(Query) $NomQuery

    set TabBlast(Taille) [TailleDeLaQueryDuBlast $FichierBlast]

    set TabBlast(NbSubject) $NbSubject
    return $aTabBlast

}

proc Derivee {l {s 2}} {

    # Attention !! Fct renvoie n-1 valeurs !!

    if {$s != 2 && $s != 3} {set s 3}
    if {$s == 2} {
	foreach v [lrange $l 0 end-1] w [lrange $l 1 end] {
	    set e [expr {$w-$v}]
	    lappend d $e
	}
    } else {
	foreach v [lrange $l 0 end-2] w [lrange $l 2 end] {
	    set e [expr {$w-$v}]
	    lappend d $e
	}
    }

    return $d

}

proc DernierBlastDuPsiBlast {FicPsiBlast {Trie ""}} {

  
    set DernierBlast [LesBlastsDuPsiBlast $FicPsiBlast "end" $Trie]
    return $DernierBlast

}

proc DernierBlastDuPsiBlastPourTous {{Nom ""}} {

    if {$Nom==""} {
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $Nom]
    }
    set RepDernier "[RepertoireDuGenome]/blastpDernierDuPsi"
    file mkdir $RepDernier
    foreach Nom $Liste {
	set FichierDer "$RepDernier/$Nom"
	if {[file exists $FichierDer]} { continue } 

	set FichierPsi "[RepertoireDuGenome]/psiblastp/$Nom"
	if { ! [file exists $FichierPsi]} { continue } 

	set DernierBlast [LesBlastsDuPsiBlast $FichierPsi "end" "Trie"]
	if {$DernierBlast==""} { continue }
	Espionne [Sauve $DernierBlast dans $FichierDer]
    }

}

proc DernierCongelo {Nom {GetWhat ""}} {

    set LesCongelos [lsort [glob -nocomplain "/tempor/grid/congelo/$Nom*"]]
    if {$LesCongelos=={}} { return "" }
    if {[string equal -nocase "GetAll" $GetWhat]} { return $LesCongelos }
    return [lindex $LesCongelos end]

}

proc DernierGz {Nom} {

    set Congelo [DernierCongelo $Nom]
    set Assiette "$Congelo/assiette"
    if {[FileAbsent $Assiette]} {
	set Message "No assiette $Assiette"
	Espionne $Message
	return ""
    }
    set Gz "$Assiette/output_formated.gz"
    if {[FileAbsent $Gz]} {
	set Gz "$Assiette/output.gz"
    }
    if {[FileAbsent $Gz]} {
	Espionne "No $Gz"
	return ""
    }
    return $Gz

}

proc DernierPAB {{Comment ""} {Format ""}} {

    if {$Comment==""} { set Comment "DansLaListe"} 
    switch $Comment {
	"EnPosition"  { scan [lindex [LesPABsDansLOrdre] end] "%s" Dernier }
	"DansLaListe" { set Dernier [lindex [ListeDesPABs] end] }
	"EnNumero"    { set Dernier [lindex [lsort [ListeDesPABs]] end] }
	default { FaireLire "wrong argument in DernierPAB" ; return [DernierPAB] }
    }
    if {$Format=="AvecBornes"} {
	return "$Dernier [Box $Dernier debut] [Box $Dernier fin] [Box $Dernier orient]"
    } else {
	return $Dernier
    }

}

proc DernierPointDeCoupure {LeGscA LeGscB TailleTroncon} {

    set Marge ""
    set Offset 0
    foreach X {"LeGscA" "LeGscB"} {
	foreach Ligne [set $X] {
	    if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} { continue }
	    scan $Ligne "%s %s %s %d %d" PE Type Sens D F
	    incr D $Offset
	    incr F $Offset
	    lappend LesDebuts $D
	    lappend LesTouches($D) "$Marge $PE $Type $Sens $D $F"
	    set MargeBlanche($D) [string repeat " " [string length "$Marge $PE $Type $Sens $D $F"]]
	}
	set Marge " === "
	set Offset $TailleTroncon
    }
    set LesDebutsTries [lsort -unique -integer $LesDebuts]
    set GeneComplet 0
    set GeneDebute  0
    set OldGeneComplet 0
    set DernierPointDeCoupure -1
    set DernierPointEgalite   -1
    set DernierValide 0
    set ProchainValide 0
    set AvantDernierDebut -1
    set DernierDebut -1
    foreach D $LesDebutsTries {
	set L [join $LesTouches($D) ""]
	regsub "^ === " $L $MargeBlanche($D) L
	Espionne $L
	set GeneDebute 0
	if {[regexp "===" $L]} { set DernierPointEgalite $D }
	if {[regexp "===" $L] || [regexp {     [0-9]+} $L]} {
	    set GeneDebute  [expr [regexp {Prom \+} $L] || [regexp {PlyA \-} $L]]
	    set GeneComplet [expr [regexp "===" $L] && ([regexp {PlyA \+} $L] || [regexp {Prom \-} $L])]
	    if {$GeneComplet} { set ProchainValide 1 ; continue }
	}
	if {$GeneDebute} { set AvantDernierDebut $DernierDebut ; set DernierDebut $D }
	if {$ProchainValide && $GeneDebute} { return $D }
	if {$GeneComplet && $GeneDebute} {
	    set GeneComplet 0
	    set GeneDebute 0
	    set AvantDernierPointDeCoupure $DernierPointDeCoupure
	    set DernierPointDeCoupure $D
	    set DernierValide 0
	}
	if { ! [regexp {     [0-9]+} $L]} {
	    set DernierValide 1
	    set GeneComplet [expr [regexp {PlyA \+} $L] || [regexp {Prom \-} $L]]
	}
    }
    if { $DernierPointDeCoupure == -1} {
	if {$DernierPointEgalite!=-1} { return $DernierPointEgalite }
	if { $AvantDernierDebut !=-1} { return $AvantDernierDebut }
	if { $DernierDebut      !=-1} { return $DernierDebut }
    }
    if { $DernierValide } {
	return $DernierPointDeCoupure
    } else {
	return $AvantDernierPointDeCoupure
    }

}

proc DerniereLigneDuFichier {Fichier} {

    return [lindex [LesLignesDuFichier $Fichier] end]

}

proc DernierePoele {Nom {GetWhat ""}} {

    set LesPoeles [lsort [glob -nocomplain "/tempor/grid/poeles/$Nom*"]]
    if {$LesPoeles=={}} { return "" }
    if {[string equal -nocase "GetAll" $GetWhat]} { return $LesPoeles }
    return [lindex $LesPoeles end]

}

proc DerniereVisite {{Nom ""}} {

    global DerniereVisite
    if {$Nom=="Reset"} {
	if {[info exists DerniereVisite]} { unset DerniereVisite }
	return ""
    }
    if {$Nom!=""} { set DerniereVisite $Nom }
    if {[info exists DerniereVisite]} { return $DerniereVisite }
    return ""

}

proc DesNouvellesSequencesPourGscope {Fichier} {

    
    Wup "Fichier contains a list of access, file names or a all TFAs sequences"

    if {[regexp {^[\n ]*>} [ContenuDuFichier $Fichier]]} {
	foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $Fichier $Access]
	    UneNouvelleSequencePourGscope $TFA "Auto" 
	    lappend LesAccess $Access
	}
	return $LesAccess
    }

    set LesLignes [LesLignesDuFichier $Fichier]
    foreach Ligne $LesLignes {
	scan $Ligne "%s" Nouveau
	UneNouvelleSequencePourGscope $Nouveau "Auto" 
    }
    return $LesLignes

}

proc DescDuRepertoire {Rep {PleaseAlign ""}} {

    global DescDuRepertoire

    if {$PleaseAlign=="PleaseAlign"} { set PleaseAlign 1 } else { set PleaseAlign 0 }

    set Rep [file tail $Rep]

    if {[info exists DescDuRepertoire($Rep)]} {
	set Desc [set DescDuRepertoire($Rep)]
	if {$PleaseAlign} {
	    set Blanc "$Rep ..............................................."
	    regsub $Rep [string range $Blanc 0 30] "" Blanc
	    return "$Blanc $Desc"
	} else {
	    return $Desc
	}
    }
    if {[info exists DescDuRepertoire("EstCharge")]} {return ""}

    set DescDuRepertoire("EstCharge") 1

    set DescDuRepertoire(descriptifs) "brief description of each homolog sequence"
    set DescDuRepertoire(leonLog) "log file of Leon"
    set DescDuRepertoire(notes) "summary of most important information concerning each sequence"
    set DescDuRepertoire(infos) "working file used as manual annotation tools for each sequence"
    set DescDuRepertoire(nuctfa) "fasta format file of nucleic sequence"
    set DescDuRepertoire(nucembl) "swissprot format file of nucleic sequence"
    set DescDuRepertoire(prottfa) "fasta format file of protein sequence"
    set DescDuRepertoire(protembl) "swissprot format file of protein sequence"
    set DescDuRepertoire(psiblastp) "Psiblast against protall (swissprot; sptrembl, sptnew, pdb)"
    set DescDuRepertoire(blastp) "BlastP against protall (swissprot; sptrembl, sptnew, pdb)"
    set DescDuRepertoire(blastngenembl) "all BlastN againstgenembl"
    set DescDuRepertoire(tblastngenomes) "all TBlastN against complete microbial genomes"
    set DescDuRepertoire(apns) "it contains a summary of blast hits"
    set DescDuRepertoire(daedalushits) "better than apns. It contains also TaxId, Definition, Class, etc. "
    set DescDuRepertoire(tfasdescopains) "fasta file containing all sequences used in multiple alignment"
    set DescDuRepertoire(msf)  "multiple alignment of complete sequences with DbClustal"
    set DescDuRepertoire(msfToHtml)  "converts the msf file to a MacsimXml and displays it with macsimHtml"
    set DescDuRepertoire(msfLeon)  "multiple alignment file after Leon's currating process"
    set DescDuRepertoire(msffam)  "multiple alignment file restricted to familiar organisms only"
    set DescDuRepertoire(msf2) "second multiple alignment of complete sequences with DbClustal"
    set DescDuRepertoire(rascal) "multiple alignment of complete sequences with DbClustal and Rascal"
    set DescDuRepertoire(macsimXml) "Macsim's analysis of multiple alignment in Xml format" 
    set DescDuRepertoire(macsimRsf) "Macsim's analysis of multiple alignment in Rsf format" 
    set DescDuRepertoire(macsimHtml) "Macsim's analysis of multiple alignment in Html format" 
    set DescDuRepertoire(macsimJalview) "See the Macsim with the Jalview java applet (needs JRE1.5)" 
    set DescDuRepertoire(description) "give a summary of all orthologues (AC, GN, Definition, Organism, ..."
    set DescDuRepertoire(aliinout) "why we keep or reject a sequence in the multiple alignment"
    set DescDuRepertoire(phylos) "phylogenetic tree of the multiple alignment (text file)"
    set DescDuRepertoire(AtvOfphylos) "phylogenetic tree of the multiple alignment displayed by ATV"
    set DescDuRepertoire(phylosOrg) "phylogenetic tree of the multiple alignment with Organism names (text file)"
    set DescDuRepertoire(AtvOfphylosOrg) "phylogenetic tree of the multiple alignment with Organism names displayed by ATV"
    set DescDuRepertoire(disphy) "phylogenetic distance from the multiple alignment"
    set DescDuRepertoire(ver) "nuc or prot sequence used to start the analysis"

    return [DescDuRepertoire $Rep $PleaseAlign]


}

proc Descendant {A B {ForceAncestorFirst ""}} {

    set ForceAncestorFirst [regexp -nocase "first" $ForceAncestorFirst]
    set iA [Tax $A TaxId]
    set iB [Tax $B TaxId]
    set iC [AncetreCommun $iA $iB]
    if {$iC==$iA} { return 1 }
    if {$ForceAncestorFirst} { return 0 }
    if {$iC==$iB} { return 1 }
    return 0

}

proc DescribePrefix {args} {

	global RepertoireDuGenome
	#relation(MMUS,premier)=[index de listedespabs2]
	#relation(MMUS,dernier)=[index de listedespabs2]
	array set bornesDesOrgas {}
	array set equivalence {}
	foreach relation $args {
		regexp {(.*)=(.*)} $relation tout gauche droite
		puts "Vous avez demandé: $gauche='$droite'"
		set equivalence($gauche) $droite
		set bornesDesOrgas($gauche,premier) 0
		set bornesDesOrgas($gauche,dernier) 0
	}
	set repOut "$RepertoireDuGenome/fiches"
	set FICOUT [open "$repOut/lienspabparorga" "w"]
	
	set compteur 1
	foreach PAB [ListeDesPABs2] {
		regexp {[A-Za-z]*} $PAB tt
		if {![info exists equivalence($tt)]} {
			incr compteur
			continue
		}
		#premiere occurence
		if {$bornesDesOrgas($tt,premier)==0} {
			set bornesDesOrgas($tt,premier) $compteur
			set bornesDesOrgas($tt,dernier) $bornesDesOrgas($tt,premier)
		}
		#derniere occurence
		incr bornesDesOrgas($tt,dernier)
		incr compteur
	}
	puts $FICOUT "### orga;prefixe;premiere ligne des pabs;derniere ligne des pabs"
	puts $FICOUT "### lignes comptees de 1 a n"
	foreach {key val} [array get equivalence] {
		puts "$val ($key) : d=$bornesDesOrgas($key,premier) f=[expr $bornesDesOrgas($key,dernier)-1]"
		puts $FICOUT "$val;$key;$bornesDesOrgas($key,premier);[expr $bornesDesOrgas($key,dernier)-1]"
	}
	close $FICOUT

}

proc DescriptionDeAAIndex {pk} {

    return [$::db eval {select description from aaindex where pk_aaindex = $pk}]

}

proc DescriptionDesAccess {Liste {GetWhat ""} {Database ""}} {

    if {$Database==""} { set Database "uniprot" }
    if {$GetWhat==""} { set GetWhat "ListOfDE" }
    set LesAD {}
    set LesADfull {}
    set LesDE {}
    set LesDEfull {}
    foreach Ligne $Liste {
	if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
	scan $Ligne "%s" Access
	set DE [BirdWeb $Database $Access "DE"]
	lappend LesADfull $Access $DE
	lappend LesDfull $DE
	regsub {\;.*} $DE "" DE
	if {[regexp {=(.+)} $DE Match Def]} { set DE $Def }
	lappend LesAD $Access $DE
	if {$DE!=""} { lappend LesDE $DE }
    }
    if {[string equal -nocase "ListOfDE" $GetWhat]} { return $LesDE }
    if {[string equal -nocase "ListOfAD" $GetWhat]} { return $LesAD }
    if {[string equal -nocase "ListOfDful" $GetWhat]} { return $LesDfull }
    if {[string equal -nocase "ListOfADful" $GetWhat]} { return $LesADfull }
    if {[string equal -nocase "ListOfDful" $GetWhat]} { return $LesDfull }
    return $LesADfull

}

proc DescriptionDuMac {{mac ""}} {

    if {$mac eq ""} {set mac [MacCourant]}
    return [$::db eval {select description from mac where pk_mac=$mac}]

}

proc DeselectLesColonnes {w pos} {

    global ZoneSelect LNOrdali

    if {! [info exists ZoneSelect]} {return}

    lassign [split [$w index $pos] .] y x

    $w tag delete Marque

    set NouvelleZone {}
    set Nf [llength $LNOrdali]
    foreach posi $ZoneSelect {
	lassign $posi x1 x2 

	if {$x >= $x1 && $x <= $x2} {
	    for {set i 0} {$i < $Nf} {incr i} {
		if {[lindex $LNOrdali $i] ne ""} {
		    $w tag remove slct [expr {$i+1}].$x1 [expr {$i+1}].[expr {$x2+1}]
		}
	    }
	} else {
	    lappend NouvelleZone [list $x1 $x2]
	}
    }
    set ZoneSelect $NouvelleZone

    return

}

proc DeselectToutesLesColonnes {} {

    global ZoneSelect NomTextSeq

    catch {unset ZoneSelect}

    $NomTextSeq tag delete Marque
    $NomTextSeq tag remove slct 1.0 end

    return

}

proc Deselecte {K} {

    global       RectangleDeSelectionNucleique
    global xDebutRectangleDeSelectionNucleique
    global yDebutRectangleDeSelectionNucleique
    global   xFinRectangleDeSelectionNucleique
    global   yFinRectangleDeSelectionNucleique
    global Piques

    foreach Nom [split [LesNomsPiques] "\n"] {
	Detoure $Nom $K
	unset Piques($Nom)
    }
    if {[info exists RectangleDeSelectionNucleique($K)]} {
	$K delete [set RectangleDeSelectionNucleique($K)]
	catch {unset       RectangleDeSelectionNucleique($K)}
	catch {unset xDebutRectangleDeSelectionNucleique($K)}
    }

}

proc DeselectionneLesSelectionnes {K} {


    Wup "Deselectionne tous les oligo choisis"
    
    set         LesIds [$K find withtag "Selected"]
    foreach Id $LesIds {
	$K itemconfigure $Id -outline "white" 
	$K itemconfigure $Id -width   "1"
	$K itemconfigure $Id -dash {}
	$K dtag $Id "Selected"
    }
    return ""

}

proc DeselectionneLesTrouves {K} {


    Wup "Deselectionne tous les oligos trouve par TrouveDansLesInfos"
    
    set LesIds [$K find withtag "Finded"]

    foreach Id $LesIds {
	$K itemconfigure $Id -outline "white" 
	$K itemconfigure $Id -width   "1"
	$K itemconfigure $Id -dash {}
	$K dtag $Id "Finded"
    }
    return ""

}

proc DeselectionneLesXSelectionnes {K} {


    Wup "Deselectionne tous les oligo croises choisis"
    
    set         LesIds [$K find withtag "Trace"]
    foreach Id $LesIds {
	$K delete $Id
    }
    set         LesIds [$K find withtag "XSelect"]
    foreach Id $LesIds {
	$K dtag $Id "XSelect"
    }
    return ""

}

proc DesignControlesAccess {} {

    
    Wup "Permet le design des Controles utilise sur la puce a ADN"
    
    set ListeControles [ListeControlesActiChip]
    
    #set DataBase1 "/blast/rshuman.nsq"
    #set DataBase2 "/blast/unigenehs.nsq"
    set DataBase1 "none"
    set DataBase2 "none"
    set Wdir1     "[RepertoireDuGenome]/Probes/Controles_ActiChip/RefSeq_Controles"
    set Wdir2     "[RepertoireDuGenome]/Probes/Controles_ActiChip/Unigene_Controles"

    foreach PAB $ListeControles {
	if {[regexp "^NM" $PAB]} {
	    set step 10
	} else {
	    set step 1
	}
	set PAB   "[RepertoireDuGenome]/Probes/Controles_ActiChip/$PAB"
	
	CADO4MI -q $PAB -l 60 -nb 1000 -t 92 -r 5 -b $DataBase1 -st $step -sp 70.0 -nc 15 -m NearestNeighbor -gl 30.00 -gu 70.00 -p "AAAAAAA TTTTTTT CCCCCCC GGGGGGG" -w $Wdir1
									    
	CADO4MI -q $PAB -l 60 -nb 1000 -t 92 -r 5 -b $DataBase2 -st $step -sp 70.0 -nc 15 -m NearestNeighbor -gl 30.00 -gu 70.00 -p "AAAAAAA TTTTTTT CCCCCCC GGGGGGG" -w $Wdir2
    }

    return ""

}

proc DesignPrimerICDS {} {


    Wup "Permet de lancer le design sur les projet ICDS"

    set      DataBase [glob -nocomplain -directory "[RepertoireDuGenome]/" "*.nsq"]
    if {    $DataBase == "" || ! [file exists $DataBase]} {
	BLASTDatabase_ICDS
	
	set  DataBase [glob -nocomplain -directory "[RepertoireDuGenome]/" "*.nsq"]
	if {$DataBase == "" || ! [file exists $DataBase]} {
	    Espionne "Pb Database blast for [RepertoireDuGenome]"
	    return ""
	}
    }

    set WorkingDir "[RepertoireDuGenome]/oligos"
    if {! [file exists $WorkingDir]} {
	file mkdir   $WorkingDir
    }

    set GenomeName [file tail [RepertoireDuGenome]]
    set LesSeqs    [glob -nocomplain -directory "[RepertoireDuGenome]/regions" "[PrefixeDuGenome $GenomeName]*"]

    foreach Seq $LesSeqs {
	set SeqName "" 
	set D1      ""
	set F1      ""
	set D2      ""
	set F2      ""

	set SeqName [file tail $Seq]
	set D1 [InterrogeLesInfosICDS $SeqName D1]
	set F1 [InterrogeLesInfosICDS $SeqName F1]
	set D2 [InterrogeLesInfosICDS $SeqName D2]
	set F2 [InterrogeLesInfosICDS $SeqName F2]

	set LesBornes "$D1 $F1 $D2 $F2"
	if {[regexp "ND" $LesBornes]} {
	    Espionne "$GenomeName $SeqName NOOOOOOOOOOOOOO for in $DataBase"
	    continue
	}

	Espionne "$GenomeName $SeqName for $D1 $F1 $D2 $F2 in $DataBase"


	CADO4MI -q $Seq -l 21 -nb 1000 -ar "$LesBornes" -t 63 -r 5 -b $DataBase -bs 3 -qc 0 -st 1 -sp 70.0 -nc 15 -m Wallace -p "AAAAAAA TTTTTTT CCCCCCC GGGGGGG" -w "$WorkingDir"
    }
    return ""

}

proc DesignSpikeAccess {} {

    
    Wup "Permet le design des Spike Thaliana utilise sur la puce a ADN"
    Wup "Le design est oriente sur les zones ou se trouvent les oligos predesignes"
    
    set ListeSpike "CAB LTP4 LTP6 NAC1 PRKase RCP1 RCA TIM XCP2 rbcL"
    #set ListeSpike "LTP4 LTP6"
    
    set DataBase1 "/blast/rshuman.nsq"
    set DataBase2 "/blast/unigenehs.nsq"
    #set DataBase1 "none"
    #set DataBase2 "none"
    set Wdir1     "[RepertoireDuGenome]/Probes/Spike_Athaliana/Spike_RefSeq"
    set Wdir2     "[RepertoireDuGenome]/Probes/Spike_Athaliana/Spike_Unigene"
    
    foreach PAB $ListeSpike {
	set PAB      "[RepertoireDuGenome]/Probes/Spike_Athaliana/$PAB"
	set Taille   [string length [QueLaSequenceDuFichierTFA $PAB]]
	set LesDF    ""
	set LesAreas ""
	set ListeLength 0

	set LesDF [InterrogeInfoDeLOligo "${PAB}.oligo" LesDebutFin]
	set LesDF [lsort -real -increasing -index 0 $LesDF]
	set ListeLength [llength $LesDF]
	set i 0
	foreach DF $LesDF {
	    incr i
	    set D [lindex $DF 0]
	    set F [lindex $DF 1]
	    if {$i==1} {
		lappend LesAreas "1 [expr $D - 1]"
	    }
	    lappend LesAreas "$D $F"

	    if {$i==$ListeLength} {
		lappend LesAreas "[expr $F + 1] $Taille"
	    }
	}
	set LesAreas [join $LesAreas " "]
	#set LesAreas "1 10000"

	CADO4MI -q $PAB -l 60 -nb 1000 -t 92 -r 5 -b $DataBase1 -st 1 -ar "$LesAreas" -sp 70.0 -nc 15 -m NearestNeighbor -gl 30.00 -gu 70.00 -p "AAAAAAA TTTTTTT CCCCCCC GGGGGGG" -w $Wdir1

	CADO4MI -q $PAB -l 60 -nb 1000 -t 92 -r 5 -b $DataBase2 -st 1 -ar "$LesAreas" -sp 70.0 -nc 15 -m NearestNeighbor -gl 30.00 -gu 70.00 -p "AAAAAAA TTTTTTT CCCCCCC GGGGGGG" -w $Wdir2
    }
    
    return ""

}

proc DessineArbre {AId n xCsg yCsg} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    set OffsetX [set Abr($AId,OffsetX)]
    set OffsetY [expr {[set Abr($AId,OffsetY)]/2+1}]
    set Increment [set Abr($AId,Increment)]

    set l [$t get $n length]
    if {$l != -1} {
	set l [expr {int($l*$Increment+$OffsetX)}]
    }

    set xP $xCsg
    set yP [expr {$yCsg+$OffsetY}]

    set xE [expr {$xCsg+$OffsetX+$l}]
    set yE $yCsg

    set LesAmarres {}
    set Feuille 1
    if {[$t numchildren $n] > 1} {
	set Le [$t children $n]
	if {$n ne "root" && [$t get $n ordre]} {
	    set Le [lreverse $Le]
	}

	foreach f $Le {
	    set Feuille 0
	    set OldyE $yE
	    set yE [lindex [DessineArbre $AId $f $xE $yE] 1]

	    lappend LesAmarres [expr {int(($OldyE+$yE)/2)}]
	}
	set yP [expr {int(($yE+$yCsg)/2)}]
    }

    set Rotation 1
    foreach A $LesAmarres {
	if {$Rotation} {
	    MarquePourRotation $AId $n $xE $yP
	}
	set Rotation 0
	DessineLigne $AId $n $xP $yP $xE $A
    }

    if {$Feuille} {
	set name [$t get $n name]
	EcritNom $AId $name $xP $yP $xE $yCsg
	return [list $xE [expr {$yCsg+2*$OffsetY}]]
	#	return [list $xE $yCsg]
    } elseif {! $Feuille && $n ne "root"} {
	MarquePourReroot $AId $n $xP $yP $xE
	return [list $xE $yE]
    }

}

proc DessineArbreCirculaire {AId n xCsg yCsg {Dim 0}} {

    global Abr
    global CurrAng

    set t [set Abr(Arbre,$AId)]
    set Increment [set Abr($AId,Increment)]

    set l 0
    if {[$t keyexists $n length]} {
	set l [$t get $n length]
	if {$l != -1} {set l [expr {int(10*$l*$Increment)}]}
    }

    set xP $xCsg
    set yP $yCsg
    set xE [expr {$xCsg+$l}]
    set yE $yCsg

    set CurrAng [expr {$CurrAng+[set Abr($AId,deltaA)]}]

    set OlddeltaA $CurrAng

    set LesAmarres {}
    set Feuille [$t isleaf $n]
    if {! $Feuille} {
	set Le [$t children $n]
	if {$n ne "root" && [$t get $n ordre]} {set Le [lreverse $Le]}

	set LesF {}
	set LesN {}
	foreach f $Le {
	    if {[$t isleaf $f]} {lappend LesF $f} {lappend LesN $f}
	}

	set MondeltaA [expr {([$t size $n]+1)*[set Abr($AId,deltaA)]/2.+$OlddeltaA}]
	set Lcor [TourneBoite $xP $yP $xE $yE $MondeltaA]
	lassign $Lcor xE yE
	lassign $Lcor xF yF
	lappend LesAmarres $Lcor

	foreach f [concat $LesF $LesN] {
	    set Lcor [DessineArbreCirculaire $AId $f $xE $yE $Dim]
	    if {! [$t isleaf $f]} {lappend LesAmarres $Lcor}
	}

	lappend LesAmarres [list $xP $yP]
    } else {
	set Lcor [TourneBoite $xP $yP $xE $yE $CurrAng]
	lassign $Lcor xE yE
	lassign $Lcor xFyF
    }

    if {$Dim} {
	$t set $n xO $xP
	$t set $n yO $yP
	$t set $n xE $xF
	$t set $n yE $yF
	$t set $n theta $CurrAng

	lappend LesAmarres [list $xE $yE]
	foreach e $LesAmarres {
	    lassign $e x y
	    if {0 && $Feuille} {
		set wtxt [font measure TreeFont$AId [NomAffiche $AId $n]]
		set Lc [TourneBoite $x $y [expr {$x+$wtxt}] $y $CurrAng]
		lassign $Lc xtst ytst
		set xtst [expr {int($xtst)}]
		set ytst [expr {int($ytst)}]
	    } else {
		set ytst [expr {int($y)}]
		set xtst [expr {int($x)}]
	    }

	    set Abr($AId,Xmax) [Maxi [set Abr($AId,Xmax)] $xtst]
	    set Abr($AId,Ymax) [Maxi [set Abr($AId,Ymax)] $ytst]
	    set Abr($AId,Xmin) [Mini [set Abr($AId,Xmin)] $xtst]
	    set Abr($AId,Ymin) [Mini [set Abr($AId,Ymin)] $ytst]
	}

	#	set CurrAng [expr {$CurrAng+[set Abr($AId,deltaA)]}]

	return [list $xE $yE]
    }
    #    Entre

    set Rotation 1
    foreach A $LesAmarres {
	# if {$Rotation} {MarquePourRotation $AId $n $xE $yP}
	# set Rotation 0
	global colordunoeud xcol ycol TextNoeud

	if {! [info exists colordunoeud]} {
	    set TextNoeud -1
	    set colordunoeud "red"
	    set xcol $xE
	    set ycol $yE
	    $Abr($AId,PAD) create oval [expr {$xE-2}] [expr {$yE-2}] [expr {$xE+2}] [expr {$yE+2}] -fill $colordunoeud
	} elseif { $xE != $xcol || $yE != $ycol } {
	    set colordunoeud "green"
	}
	incr TextNoeud
	if {0} {
	    $Abr($AId,PAD) create text [expr {$xE-}] [expr {$yE+8}] -text $TextNoeud -font "helvitica 6"
	}
	lassign $A nxE nyE
	DessineLigneCirculaire $AId $n $xE $yE $nxE $nyE
    }

    if {$Feuille} {
	set name [$t get $n name]
	EcritNomCirculaire $AId $name $xP $yP $xE $yE $CurrAng
    } elseif {$n ne "root"} {
	MarquePourReroot $AId $n $xP $yP $xE
    }

    return [list $xE $yE]

}

proc DessineBilanHDACroises {LesXs LesYs aT {Titre ""} {PourGif ""}} {

    upvar $aT T
    global RepertoireDuGenome
    global MemoBilanHDACroises

    if {$Titre==""} { set Titre "Cross-linked Homolog Detection Agreement" }
    if {[regexp "/" $Titre]} { set Titre [file tail $Titre] }
    set LC 25
    set HL 20

    set nLignes   [llength $LesYs]
    set nColonnes [llength $LesXs]

    set CouleursHDA(O) "orange"
    set CouleursHDA(B) "blue"
    set CouleursHDA(V) "green"
    set CouleursHDA(R) "red"
    set CouleursHDA(J) "yellow"
    set CouleursHDA(LJ) "lightyellow"

    set Fonte {Courier 15}
    set TailleTexteOrga [font measure $Fonte [string repeat "M" 26]] 
    set EspacementHorizontal 15
    set EspaceVertical 40
    set PosYEntete [expr $EspaceVertical/4]

    set DecalageDesRectangles [expr $EspacementHorizontal + $TailleTexteOrga + $EspacementHorizontal] 
    set LargeurVoulue [expr $DecalageDesRectangles + $nColonnes*$LC + $EspacementHorizontal]
    set HauteurVoulue [expr $EspaceVertical + ($nLignes+3)*$HL]

    if {$PourGif != ""} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K [UnCanva $LargeurVoulue $HauteurVoulue $LargeurVoulue $HauteurVoulue "GonfleAussiY"]     
	regsub ".canvas" $K "" w
	wm title $w "$Titre"
	wm iconname $w "$Titre"
    }

    set MemoBilanHDACroises($K,LesXs) $LesXs
    set MemoBilanHDACroises($K,LesYs) $LesYs
    foreach {C V} [array get T] {
	if {$C=="LesXs" || $C=="LesYs"} { continue } 
	set MemoBilanHDACroises($K,$C) $V
    }
    $K configure -background "lightgrey"
    $K create rectangle 0 0 $LargeurVoulue $HauteurVoulue -fill grey -tags [list "Cadre"]

    $K create text  [expr $DecalageDesRectangles/2] [expr $EspaceVertical/2]  -width 300  -text $Titre  -font {Courier 12}  -anchor c

    set iEmeOrga 0
    set MettreEntete 1 
    set MettreEnpied 0
    foreach Orga [concat $LesYs [list "LigneSupplementaire"]] {
	    
	if {$Orga=="LigneSupplementaire"} {
	    set MettreEnpied 1
	    incr iEmeOrga
	} else {
	    set Couleur "black"
	    set Complet [Glossaire $Orga Complet]
	    
	    set Phylum [PhylumDuGenome $Complet]
	    if {$Phylum=="X"} { set Phylum [PhylumDuOrganisme $Complet] }
	    
	    set Couleur "black"
	    if {$Phylum=="B"} { set Couleur "darkgreen" }
	    if {$Phylum=="A"} { set Couleur "blue" }
	    if {$Phylum=="E"} { set Couleur "red" }
	    if {[SampledOrganism $Orga]} { set Couleur "darkorange" }
	    incr iEmeOrga
	    
	    set TexteOrga [string range $Complet 0 25]
	    $K create text  $EspacementHorizontal [expr $EspaceVertical + $iEmeOrga*$HL]  -text $TexteOrga  -anchor w  -font $Fonte  -tags [list "$Complet" "$Orga" "TexteOrga" "Ligne_$iEmeOrga"]  -fill $Couleur
	}

	set ValeurVide ""
	set Colonne 0
	set Rang 0
	foreach X $LesXs {

	    incr Colonne
	    incr Rang

	    if {$MettreEntete || $MettreEnpied} {
		if {$MettreEnpied} { 
		    set PosYEntete [expr $EspaceVertical + $iEmeOrga*$HL]
		}
		set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
		set Texte $X
		$K create text  $PosX $PosYEntete  -width 20  -text $Texte  -font {Courier 6}  -anchor n  -tags [list "Famille" $Texte "TexteOrga"]  -fill "black"
	    }
	    if {[info exists T($X,$Orga)]} {
		set V [set T($X,$Orga)]
	    } else {
		set V $ValeurVide
	    }		

	    if { $V == $ValeurVide} { continue }
	    set Couleur [set CouleursHDA([CouleurHDACroises $V])]
	    set Texte        [TexteHDACroises $V $X $Complet]
	    set TexteDevoile [TexteHDACroises $V $X $Complet Devoile]
	    if {$PourGif} {
		set LesTags [list "WebClic" "gscope:AfficheLesConcernesDeCeRang \{$Complet\} $V $Rang Coucou"]
	    } else {
		set LesTagsR [list $Complet $TexteDevoile $Rang             "Affichable" "Ligne_$iEmeOrga"]
		set LesTagsT [list $Complet $TexteDevoile $Rang "TexteRang" "Affichable" "Ligne_$iEmeOrga"]
	    }

	    set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
	    $K create rect  [expr $PosX-$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL-$HL/3]  [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL+$HL/3]  -tags $LesTagsR  -outline $Couleur  -fill $Couleur
	    $K create text  [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL]  -text $Texte  -font {Courier 6}  -anchor e  -tags $LesTagsT  -fill "black"
	}
	set MettreEntete 0
    }

    $K configure -height [expr $EspaceVertical + ($iEmeOrga+2)*$HL]

    set   B [BoutonneLaFenetre $w "Hide Both/Org/Val\n Sort BAE/SmplBAE/Alph\nAverage tN/P/abs"]
    bind $B <1>         "ToggleTextePhylo $K Both"
    bind $B <2>         "ToggleTextePhylo $K Orga"
    bind $B <3>         "ToggleTextePhylo $K Rank"
    bind $B    "TriBilanHDACroises $K 1 SurOrganisme" 
    bind $B    "TriBilanHDACroises $K 2 SurOrganisme" 
    bind $B    "TriBilanHDACroises $K 3 SurOrganisme" 
    bind $B  "TriBilanHDACroises $K 1 SurLaMoyenne" 
    bind $B  "TriBilanHDACroises $K 2 SurLaMoyenne" 
    bind $B  "TriBilanHDACroises $K 3 SurLaMoyenne" 
         $B configure -background "green"

    set   B [BoutonneLaFenetre $w "Save X-HDA\nOther Show/Ask/New\nDisplay tN/P/A"]
    bind $B <1>         "SauveBilanHDACroisesDuCanvas $K AskForFile"
    bind $B    "ShowHDACroises {}"
    bind $B    "ShowHDACroises AskForFile"
    bind $B    "NewHDACroises" 
    bind $B  "DisplayBilanHDACroises $K 1" 
    bind $B  "DisplayBilanHDACroises $K 2" 
    bind $B  "DisplayBilanHDACroises $K 3" 
         $B configure -background "green"

    $K bind "Famille"    <1>         "AffichePourLaFamilleHDACroises $K 1" 
    $K bind "Famille"    <2>         "AffichePourLaFamilleHDACroises $K 2" 
    $K bind "Famille"    <3>         "AffichePourLaFamilleHDACroises $K 3" 
    $K bind "Famille"       "TriBilanHDACroises $K 1 SurFamille" 
    $K bind "Famille"       "TriBilanHDACroises $K 2 SurFamille" 
    $K bind "Famille"       "TriBilanHDACroises $K 3 SurFamille"

    $K bind "TexteOrga"     "TriBilanHDACroises $K 1 SurLaMoyenne" 
    $K bind "TexteOrga"     "TriBilanHDACroises $K 2 SurLaMoyenne" 
    $K bind "TexteOrga"     "TriBilanHDACroises $K 3 SurLaMoyenne" 
    $K bind "Affichable"      "DevoileLesValeursHDACroises $K %x %y Enter"
    $K bind "Affichable"      "DevoileLesValeursHDACroises $K %x %y Leave"
    $K bind "Affichable" <1>         ""
    $K bind "Affichable"  "ChangeOrdrePhylo $K %x %y $HL -1 $iEmeOrga"
    $K bind "Affichable"  "ChangeOrdrePhylo $K %x %y $HL  1 $iEmeOrga"

    if {$PourGif } { return $LesOrdresPourGif }
    if { 0 && [PourWscope] } {
	return $w
    } else {
	return $K
    }

}

proc DessineClonage {} {

    array set LesPPCRsADessiner [LesLignesDuFichier "[RepertoireDuGenome]/fiches/lesppcrsadessiner"]
    foreach Trio [set LesPPCRsADessiner($Nom)] {
	scan $Trio "%s %d %d %s %d %d %s %d %d" Frag dF fF A dA fA B dB fB
	
    }

}

proc DessineDistribution {Liste {UneFoissurX 5} {YTousles 100}} {

    set LargFenetre 1100 ; set HautFenetre 800; set Bord 50
    foreach el $Liste {
        if {$el==""} continue
        scan $el "%s %s" Intervalle Effectif
        lappend LesX $Intervalle
        lappend LesY $Effectif
    }

    set MaxValeurX [lindex $LesX end]
    set NbValeurX [llength $LesX]
    set MaxValeurY [MaxiDeLaListe $LesY]
    set LargUnit 8
    set HautUnit 1.5
    set LargeurMax [expr ($LargUnit*$NbValeurX)]
    set HauteurMax [expr ($HautUnit*$MaxValeurY)]
    
    set K [UnCanva [expr $LargeurMax+2*$Bord] [expr $HauteurMax+2*$Bord] $LargFenetre $HautFenetre NoY]
    $K configure -bg white
    $K create line $Bord $Bord $Bord [expr $Bord+$HauteurMax] -arrow first
    $K create line $Bord [expr $Bord+$HauteurMax] [expr $LargeurMax+$Bord] [expr $Bord+$HauteurMax] -arrow last

    for {set i 0} {$i<=$MaxValeurY} {set i [expr $i+$YTousles]} {
        $K create text [expr $Bord-20] [expr $HauteurMax+$Bord-($i*$HautUnit)] -text $i
        $K create line [expr $Bord-5] [expr $HauteurMax+$Bord-($i*$HautUnit)] $Bord [expr $HauteurMax+$Bord-($i*$HautUnit)]
    }
    set i 0
    foreach x $LesX y $LesY {
        puts "$x $y"
        set R [$K create rectangle [expr $Bord+($i*$LargUnit)] [expr $HauteurMax+$Bord]  [expr $Bord+(($i+1)*$LargUnit)] [expr ($HauteurMax+$Bord)-($y*$HautUnit)]  -fill red]
        $K itemconfigure $R -tag [list rectangle $x $y] 
        $K create line [expr $Bord+($i*$LargUnit)] [expr $HauteurMax+$Bord+5] [expr $Bord+($i*$LargUnit)]  [expr $HauteurMax+$Bord]
        if {[expr $i%$UneFoissurX]==0} {
            $K create text [expr $Bord+(($i+1)*$LargUnit)] [expr $HauteurMax+$Bord+12] -text $x
        }
        incr i
    }
    $K yview moveto 1

}

proc DessineFeatureDansRasMol {m i w f} {

    global RasM
    global TabSF
    global Lookup_Couleurs

    if {! [set RasM(mol$m,See)]} {
	set RasM(mol$m,Feat) [set RasM(mol$m,PrevFeat)]
	return
    }

    if {$f == "None"} {
	IlFautVoir "molecule $i"
	IlFautVoir "colour grey"
	return
    }

    if {[set RasM(mol$m,Feat)] == "automatic"} {
	if {$f == "automatic"} {
	    set Lb [ListeDesFeaturesUtilisees]
	    foreach b $Lb {
		DessineFeatureDansRasmol $m $i $w $LaF
	    }
	}
    }

    set nom [BonAccess [set RasM(mol$m,Name)]]
    if {! [info exists TabSF($nom,$f)]} {return}

    IlFautVoir "molecule $i"
    foreach e [set TabSF($nom,$f)] {
	DecortiqueUneFeature $e dg fg col score note
	set dg [expr {$dg-1}]
	set fg [expr {$fg-1}]
	set deb [CorrespondanceGenPDB $nom $dg]
	set fin [CorrespondanceGenPDB $nom $fg]

	set c [CouleurO2Ordali $col]
	set ccou [CouleurOrdali2Rasmol $c]

	if {$deb == $fin} {
	    set range "$deb"
	} else {
	    set range "$deb-$fin"
	}
	IlFautVoir "select $range"
	IlFautVoir "colour $ccou"
    }

    IlFautVoir [set RasM(mol$m,Sel)]
    IlFautVoir "refresh"

    return

}

proc DessineFeatureSurOverview {Id w ft {Show 1} {DeBtn 0}} {

    global NomNomSeq TabSF Ovw LNOrdali

    if {$DeBtn && ( [set Ovw(O$Id,Feat)] ne "automatic" ) } {
	return
    }

    set wc [set Ovw(O$Id,w)]
    set Ovft [set Ovw(O$Id,Feat)]

    if {$Ovft ne "automatic" || ( $ft eq "None" && $Ovft eq "automatic") } {
	set FOri [set Ovw(O$Id,FOri)]
	$wc raise $FOri
	$wc raise [set Ovw(O$Id,TagCentre)]
	$wc raise [set Ovw(O$Id,TagRegion)]
	update
	if {$ft eq "None"} {
	    return
	}
    }

    # Feature deja calculee, monte ou descend
    if {[info exists Ovw(O$Id,$ft)]} {
	if {! $Show} {
	    $wc lower [set Ovw(O$Id,$ft)]
	    set lf [set Ovw(O$Id,FeatAff)]
	    set i [lsearch $lf $ft]
	    set lf [lreplace $lf $i $i]
	    set Ovw(O$Id,FeatAff) [linsert $lf 0 $ft]
	} else {
	    $wc raise [set Ovw(O$Id,$ft)]
	}
	$wc raise [set Ovw(O$Id,TagCentre)]
	$wc raise [set Ovw(O$Id,TagRegion)]
	update idletasks
	return
    }

    # Calcul image de la feature
    set Wdt [set Ovw(O$Id,Width)]
    set Hgt [set Ovw(O$Id,Height)]
    # puts "WdO $Wdt HgO $Hgt | W [$wc cget -width] H [$wc cget -height]"
    set img [image create photo]
    $img blank

    set LNoms $LNOrdali

    set y -1
    foreach n $LNoms {
	incr y
	if {[string trim $n] eq ""} {continue}
	if {! [info exists TabSF($n,$ft)]} {continue}
	set h $y
	set b [expr {$y+1}]
	foreach e [set TabSF($n,${ft})] {
	    DecortiqueUneFeature $e d f col score note
	    if {$d == $f} {incr f}
	    $img put $col -to $d $h $f $b
	}
    }
    LRI::imgtransform $img -scalex $Ovw(O$Id,ScaOriX) -scaley $Ovw(O$Id,ScaOriY)
    if {[set Ovw(O$Id,ScaTot)] != {}} {
	set St [expr int(100*[join [set Ovw(O$Id,ScaTot)] *])]
	LRI::imgtransform $img -scale $St
    }

    set tag [$wc create image 0 0  -image $img  -anchor nw  -tags [list FX_${ft} ImgFeature]]
    lappend Ovw(O$Id,Images) $img
    set Ovw(O$Id,$ft) $tag
    if {$ft ne "automatic"} {set Ovw(O$Id,FeatAff) {} }
    lappend Ovw(O$Id,FeatAff) $ft

    $wc raise [set Ovw(O$Id,TagCentre)]
    $wc raise [set Ovw(O$Id,TagRegion)]
    update idletasks

    return

}

proc DessineLesDomaines {{CheckSpecific 1}} {


    Wup "Permet de dessiner les domaines des ARPs"

    if {$CheckSpecific != "1"} {set CheckSpecific "0"}
    
    set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/"

    set Police         "Courier 12"
    set Police2         {-family "arial" -size 12 -weight bold}
    set CouleurOutline "black"
    set LargeurMax     [expr [winfo screenwidth  .] - 200]
    set HauteurMax     [expr [winfo screenheight .] * 1/2]
    set LargeurFenetre [expr [winfo screenwidth  .] - 200]
    set HauteurFenetre [expr [winfo screenheight .] * 1/2]

    set K [UnCanvaDe $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "ARP signature"]
    $K configure -background "grey" 

    #La sequence de Reference
    set AccessDeRef "P02568"
    set TailleQuery 377

    set BordureX       50
    set EpaisseurBoite 50
    #Position de la query
    set XDebutQuery    [expr 0            + $BordureX]
    set YDebutQuery    [expr 0            + 20]
    set XFinQuery      [expr $XDebutQuery + $TailleQuery] 
    set YFinQuery      [expr $YDebutQuery + $EpaisseurBoite]
    set YFinQuery      [expr $YFinQuery   + 10]

    #Chargement des informations concernant les domaines
    ####################################################
    set LesFamilles [linsert [InterrogeLesDomainesDesARPs LesFamilles] 0 ARP1]
    #set LesFamilles ARP4
    set PosYDessin      $YFinQuery
    foreach Famille $LesFamilles {
	set PosYDessin [expr $PosYDessin + 20]
	$K create text [expr $XDebutQuery-10.0] [expr $PosYDessin + 5.0]  -text    "$Famille"  -anchor  "e"
    }

    set XDebutDessin $XDebutQuery
    set LastXDrawn   $XDebutDessin
    set LastPosDrawn 1
    set PosAnnotation "1"

    for {set i 0} {$i<=$TailleQuery} {incr i} {
	set PosYDessin      $YFinQuery
	set OnAUneInsertion 0
	set TailleMax       0
	
	#set LesFamilles [InterrogeLesDomainesDesARPs LesFamilles]
	#Pour la derniere position
	if {$i=="377"} {
	    set ColorFill   "green"
	    $K create rectangle $LastXDrawn [expr $YFinQuery+10] $XDebutDessin $YFinQuery  -width  "1"  -fill   "$ColorFill"  -tags   [list "" "P02568 de $LastPosDrawn a $i" "Affichable"]
	}
	#set LesFamilles [InterrogeLesDomainesDesARPs LesFamilles]
	set  LesFamilles [linsert [InterrogeLesDomainesDesARPs LesFamilles] 0 ARP1]
	foreach Famille $LesFamilles {
	    set nbIns "0"
	    set nbDel "0"

	    set PosYDessin [expr $PosYDessin + 20]
	    if {[InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]!=""} {
		set ColorFill "red"
		set ColorLine "black"
		
		set Type   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]
		set Taille [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Taille]
		if {$Type=="DEL" || $Taille < 10} {continue}
		if {$Taille < 10} {continue}

		if {$Type=="DEL"} {set ColorFill "blue"}


		#On test si le domaine est specific a la famille totale ou pas
		set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Remarque]
		if {[regexp -nocase "not specific" $SpeOuPas]} {
		    set ColorLine "yellow"
		    if {$CheckSpecific} {
			continue
		    }
		    incr nbDel
		} else {
		    incr nbIns 
		}

		set OnAUneInsertion 1
		if {$TailleMax<$Taille} {set TailleMax $Taille}
		#Espionne "$i $Famille $TailleMax"
		
		#La boite de l insertion de la famille
		$K create rectangle $XDebutDessin [expr $PosYDessin+10] [expr $XDebutDessin + [expr $Taille-1]] $PosYDessin  -width   "2"  -fill    "$ColorFill"  -outline "$ColorLine"  -tags    [list "" "$Famille $Type $i de $Taille aa" "Affichable"]

	    }
	}
	
	if {$OnAUneInsertion} {
	    #On dessine la query avant de dessiner l insertion
	    set ColorFill    "green"
	    #Pour la premiiere position
	    if {$i=="1"} {
		set LastXDrawn $XDebutQuery
	    } else {
		set Police2 {-family "arial" -size 8 -weight bold}

		#On affiche une fois en haut une fois en bas
		if {$PosAnnotation} {
		    set PosAnnotationY [expr $YFinQuery      - 5]
		    set PosAnnotation 0
		} else {
		    set PosAnnotationY [expr $YFinQuery + 10 + 5]
		    set PosAnnotation 1
		}
		if {$LastPosDrawn=="1"} {set LastPosDrawn 0}

		set PosD [expr $LastPosDrawn + 1]
		set PosF $i                      
		#set PosD [join [split [expr $LastPosDrawn + 1] "" ] "\n"]
		#set PosF [join [split $i                       "" ] "\n"]

		#Les 2 bornes Debut et Fin
		$K create text $LastXDrawn   $PosAnnotationY  -text   "$PosD"  -font   $Police2 -anchor "e"
		$K create text $XDebutDessin $PosAnnotationY  -text   "$PosF"  -font   $Police2 -anchor "w"
		#La boite de la query
		$K create rectangle $LastXDrawn [expr $YFinQuery+10] $XDebutDessin $YFinQuery  -width  "1"  -fill   "$ColorFill"  -tags   [list "" "P02568 de [expr $LastPosDrawn + 1] a $i" "Affichable"]
	    }
	    Espionne "[expr $LastPosDrawn + 1] -- $i : $LastXDrawn $XDebutDessin"

	    set XDebutDessin [expr $XDebutDessin + $TailleMax]
	    set TailleMax    0
	    set LastXDrawn   $XDebutDessin
	    set LastPosDrawn $i
	} else {
	    set XDebutDessin [expr $XDebutDessin + 1]
	}
    }

    $K bind "Affichable"   "AfficheInfoBulle $K %x %y Enter"
    $K bind "Affichable"   "AfficheInfoBulle $K %x %y Leave"

    #Binding pour permettre de zoomer en utilisant le 3eme bouton
    bind $K <3>               "zoomMark   $K %x %y"
    bind $K        "zoomStroke $K %x %y"
    bind $K  "zoomArea   $K %x %y"

    return ""

}

proc DessineLesDomaines2 {{CheckSpecific 1} {CutoffTaille ""}} {


    Wup "Permet de dessiner les domaines des ARPs"
    Wup "Version finale utilisee pour l article"

    #CheckSpecific - permet de tenir compte des INDELs non specifiques (1 non 0 oui)
    #CutoffTaille  - limite pour garder un une INDEL

    if {$CheckSpecific != "1"}                                    {set CheckSpecific "0"}
    if {$CutoffTaille  == "" || ! [regexp {[0-9]} $CutoffTaille]} {set CutoffTaille 10}

    set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/"

    set Police         "Courier 12"
    set Police2         {-family "arial" -size 12 -weight bold}
    set CouleurOutline "black"
    set LargeurMax     [expr [winfo screenwidth  .] - 200]
    set HauteurMax     [expr [winfo screenheight .] * 1/2]
    set LargeurFenetre [expr [winfo screenwidth  .] - 200]
    set HauteurFenetre [expr [winfo screenheight .] * 1/2]

    set K [UnCanvaDe $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "ARP signature"]
    $K configure -background "grey" 

    #La sequence de Reference
    set AccessDeRef "P02568"
    set TailleQuery 377

    set BordureX       50
    set EpaisseurBoite 50
    #Position de la query
    set XDebutQuery    [expr 0            + $BordureX]
    set YDebutQuery    [expr 0            + 20]
    set XFinQuery      [expr $XDebutQuery + $TailleQuery] 
    set YFinQuery      [expr $YDebutQuery + $EpaisseurBoite]
    set YFinQuery      [expr $YFinQuery   + 10]

    #1 Chargement des informations concernant les domaines
    ####################################################
    #Attention nomralement 11 familles d ARPs
    set LesFamilles [linsert [InterrogeLesDomainesDesARPs LesFamilles] 0 ARP1]
    #set LesFamilles ARP4
    set PosYDessin      $YFinQuery
    foreach Famille $LesFamilles {
	set PosYDessin [expr $PosYDessin + 20]
	$K create text [expr $XDebutQuery-10.0] [expr $PosYDessin + 5.0]  -text    "$Famille"  -anchor  "e"
    }

    for {set i 0} {$i<=$TailleQuery} {incr i} {
	set TailleMax 0
	foreach Famille $LesFamilles {
	    #set PosYDessin [expr $PosYDessin + 20]
	    if {[InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]!=""} {
		set Type   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]
		set Taille [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Taille]
		if {$Type=="DEL" || $Taille < $CutoffTaille} {continue}

		#On test si le domaine est specific a la famille totale ou pas
		set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Remarque]
		if {[regexp -nocase "not specific" $SpeOuPas]} {
		    if {$CheckSpecific} {continue}
		}
		if {$TailleMax<$Taille} {set TailleMax $Taille}
	    }
	}

	#On stock les positions de la reference ou il y a une insertion
	if {$TailleMax!="0"} {
	    set Tab($i,TailleMax) $TailleMax
	    #Espionne "IN pos $i de $TailleMax"
	}
    }
    
    #2 Charge les infos des residus
    #############################
    set LesFamilles $LesFamilles
    foreach Famille $LesFamilles {
	#set PosYDessin [expr $PosYDessin + 20]
	set  LesPositions [InterrogeLesResidusDesARPs $Famille $AccessDeRef LesPositions]
	#On stock les positions de la reference ou il y a un residus
	if {$LesPositions != ""} {
	    foreach Pos $LesPositions {
		set Tab($Famille,$Pos,Residus) $Pos
	    }
	}
    }			

    #3 Dessine la sequence de reference (Actine)
    ############################################
    set XDebutDessin  $XDebutQuery
    set LastXDrawn    $XDebutDessin
    set LastPosDrawn  1
    set PosAnnotation "1"

    set ColorFillREF  "green"
    set ColorLineREF  "black"
    set ColorFillIN   "red"
    set ColorLineIN   "red"
    set ColorFillDEL  "blue"
    set ColorLineDEL  "blue"
    set ColorFillRES  "black"
    set ColorLineRES  "black"
    set ColorLineSpe  "yellow"     

    for {set i 0} {$i<=$TailleQuery} {incr i} {
	set PosYDessin       $YFinQuery
		
	if {! [info exists Tab($i,TailleMax)]} {continue} 
	if {$i==1} {
	    set LastPosDrawn $i
	    set LastXDrawn   [expr $LastXDrawn   + [set Tab($i,TailleMax)] - 1]
	    set XDebutDessin [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
	    continue
	}

	#set XDebutDessin [expr $XDebutDessin + $i - 1]
	set XDebutDessin [expr $XDebutDessin + [expr $i - $LastPosDrawn] - 1]
	
	#3-1 Les 2 bornes Debut et Fin
	##############################
	set Police2 {-family "arial" -size 8 -weight bold}
	
	if {$LastPosDrawn=="1"} {
	    set PosD $LastPosDrawn
	} else {
	    set PosD [expr $LastPosDrawn + 1]
	}
	set PosF $i                      
		
	set PosAnnotationY [expr $YFinQuery -  5]
	$K create text $LastXDrawn   $PosAnnotationY  -text   "$PosD"  -font   $Police2 -anchor "c"

	set PosAnnotationY [expr $YFinQuery - 10]
	$K create text $XDebutDessin $PosAnnotationY  -text   "$PosF"  -font   $Police2 -anchor "c"
	
	#3-2 On dessine le rectangle precedent
	######################################
	$K create rectangle $LastXDrawn [expr $YFinQuery+10] $XDebutDessin $YFinQuery  -width  "1"  -fill   "$ColorFillREF"  -tags   [list "" "P02568 de $PosD a $i" "Affichable"]
	
	set LastPosDrawn $i
	set LastXDrawn   [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
	set XDebutDessin [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
    }

    #4 Dessine les features (Insertions, deletions et les residus et les structures secondaires)
    ############################################################################################
    set PosYDessin   $YFinQuery
    set StructureSecondaire 0
    set  LesFamilles [linsert [InterrogeLesDomainesDesARPs LesFamilles] 0 ARP1]
    foreach Famille $LesFamilles {
	set PosYDessin    [expr $PosYDessin + 20]

	set XDebutDessin  $XDebutQuery
	set LastXDrawn    $XDebutDessin
	set LastPosDrawn  1
	set PosAnnotation "1"

	for {set i 0} {$i<=$TailleQuery} {incr i} {
	    set NoDrawings 0

	    #4-1 Cas particulier de l insertion en N-terminus de la proteine
	    ################################################################
	    if {$i==1} { 
		set NoDrawings 0

		#On check si on a une Insertion ou pas
		if {[InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]!=""} {
		    set Type   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]
		    set Taille [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Taille]
		    if {$Type=="DEL" || $Taille < $CutoffTaille} {set NoDrawings 1}
		    
		    #On test si le domaine est specific a la famille totale ou pas
		    set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Remarque]
		    if {[regexp -nocase "not specific" $SpeOuPas]} {
			set ColorLine $ColorLineIN
			if {$CheckSpecific} {set NoDrawings 1}
		    } else {
			set ColorLine $ColorLineSpe
		    }
		    
		    if {$NoDrawings != "1"} {
			#La boite de l insertion de la famille
			$K create rectangle $XDebutDessin [expr $PosYDessin+10]  [expr $XDebutDessin + [expr $Taille-1]] $PosYDessin  -width   "2"  -fill    "$ColorFillIN"  -outline "$ColorLine"  -tags    [list "" "$Famille $Type $i de $Taille aa" "Affichable"]
		    }
		}

		#On check si on a une structure secondaire
		if {$StructureSecondaire=="0"} {
		    set  StructII [LesStructuresDeActin $i]
		    if {$StructII != "" && $StructII != "-"} {
			if {$StructII !="H"} {
			    set ColorFill2 "red"
			} else {	   
			    set ColorFill2 "blue"
			}
			#La boite de la structure secondaire
			$K create rectangle $XDebutDessin [expr $PosYDessin - 50]  [expr $XDebutDessin + 1] [expr $PosYDessin - 70]  -width   "1"  -fill    "$ColorFill2"  -outline "$ColorFill2"  -tags    [list "" "Structure IIaire $StructII $i" "Affichable"]
		    }
		}
		set LastPosDrawn $i
		set LastXDrawn   [expr $LastXDrawn   + [set Tab($i,TailleMax)] - 1]
		set XDebutDessin [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
		continue
	    }

	    #4-1 On passe au reste de la proteine
	    #################################
	    if {[InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]!=""} {
		set NoDrawings 0
		set Type   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]
		set Taille [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Taille]
		if {$Type=="IN" || $Taille < $CutoffTaille} {set NoDrawings 1}

		#On test si le domaine est specific a la famille totale ou pas
		set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Remarque]
		if {[regexp -nocase "not specific" $SpeOuPas]} {
		    set ColorLine "$ColorLineDEL"
		    if {$CheckSpecific} {set NoDrawings 1}
		} else {
		    set ColorLine $ColorLineSpe
		}
		
		if {$NoDrawings != "1"} {
		    for {set j 0} {$j<=$Taille} {incr j} {
			set Pos [expr $i + $j]
			set Tab($Famille,$Pos,Del) 1
			set Tab($Famille,$Pos,Ref) $i
			#Espionne "$Famille $Pos -- $i"
		    }
		}
	    }

	    #On check si on a un residu
	    ###########################
	    if {[info exists Tab($Famille,$i,Residus)]} { 
		set Type      "Residu"

		set XDebutDessin2 [expr $XDebutDessin + [expr $i - $LastPosDrawn] - 1]
		#La boite de l insertion de la famille
		$K create rectangle $XDebutDessin2 [expr $PosYDessin+10]  [expr $XDebutDessin2 + 1] $PosYDessin  -width   "1"  -fill    "$ColorFillRES"  -outline "$ColorLineRES"  -tags    [list "" "$Famille $Type $i" "Affichable"]
	    }

	    #On check si on a une deletion
	    ##############################
	    if {[info exists Tab($Famille,$i,Del)]} { 
		set NoDrawings 0
		set Tab($Famille,$Pos,Del) 1
		set PosDeRef [set Tab($Famille,$Pos,Ref)]
		
		#On test si le domaine est specific a la famille totale ou pas
		set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $PosDeRef Remarque]
		if {[regexp -nocase "not specific" $SpeOuPas]} {
		    set ColorLine $ColorLineDEL
		    if {$CheckSpecific} {set NoDrawings 1}
		} else {
		    set ColorLine $ColorLineSpe
		}

		set XDebutDessin2 [expr $XDebutDessin + [expr $i - $LastPosDrawn] - 1]
		if {$NoDrawings != "1"} {
		    #La boite de l insertion de la famille
		    $K create rectangle $XDebutDessin2 [expr $PosYDessin+10]  [expr $XDebutDessin2 + 1] $PosYDessin  -width   "1"  -fill    "$ColorFillDEL"  -outline "$ColorLine"  -tags    [list "" "$Famille $Type $i de $Taille aa" "Affichable"]
		}
	    }
	    
	    #On check si on a une structure secondaire
	    ##########################################
	    if {$StructureSecondaire=="0"} {
		set StructII [LesStructuresDeActin $i]
		if {$StructII != "" && $StructII != "-"} {
		    if {$StructII !="H"} {
			set ColorFill2 "red"
		    } else {
			set ColorFill2 "blue"
		    }
		    
		    set XDebutDessin2 [expr $XDebutDessin + [expr $i - $LastPosDrawn] - 1]
		    #La boite de la structure secondaire
		    $K create rectangle $XDebutDessin2 [expr $PosYDessin - 50]  [expr $XDebutDessin2 + 1] [expr $PosYDessin - 70]  -width   "1"  -fill    "$ColorFill2"  -outline "$ColorFill2"  -tags    [list "" "Structure IIaire $StructII $i" "Affichable"]
		}
	    }
	    if {! [info exists Tab($i,TailleMax)]} {continue} 

	    #On dessine enfin les boites
	    ############################
	    #set XDebutDessin [expr $XDebutDessin + $i - 1]
	    set XDebutDessin [expr $XDebutDessin + [expr $i - $LastPosDrawn] - 1]
	    set NoDrawings 0
	    if {[InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]!=""} {
		set Type   [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Type]
		set Taille [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Taille]
		if {$Type=="DEL" || $Taille < $CutoffTaille} {set NoDrawings 1}
		
		#On test si le domaine est specific a la famille totale ou pas
		set SpeOuPas [InterrogeLesDomainesDesARPs $Famille $AccessDeRef $i Remarque]
		if {[regexp -nocase "not specific" $SpeOuPas]} {
		    set ColorLine $ColorLineIN
		    if {$CheckSpecific} {set NoDrawings 1}
		} else {
		    set ColorLine $ColorLineSpe
		}
		
		if {$NoDrawings != "1"} {
		    #La boite de l insertion de la famille
		    $K create rectangle $XDebutDessin [expr $PosYDessin+10]  [expr $XDebutDessin + [expr $Taille-1]] $PosYDessin  -width   "2"  -fill    "$ColorFillIN"  -outline "$ColorLine"  -tags    [list "" "$Famille $Type $i de $Taille aa" "Affichable"]
		}
	    }
	    
	    set LastPosDrawn $i
	    set LastXDrawn   [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
	    set XDebutDessin [expr $XDebutDessin + [set Tab($i,TailleMax)] - 1]
	}
	 set StructureSecondaire 1
    }

    #5 Affichage des bulles d aides et le zoom
    $K bind "Affichable"   "AfficheInfoBulle $K %x %y Enter"
    $K bind "Affichable"   "AfficheInfoBulle $K %x %y Leave"
    #Binding pour permettre de zoomer en utilisant le 3eme bouton
    bind $K <3>               "zoomMark   $K %x %y"
    bind $K        "zoomStroke $K %x %y"
    bind $K  "zoomArea   $K %x %y"

    return ""

}

proc DessineLesScores {{f ""}} {

    global NomFenetreOrdali Toggle LongueurTotale FrmSequence NomTextSeq ScoreMeth

    #puts "dessine [set Toggle(Scores)]"
    if {! [set Toggle(Scores)]} {
	return
    }
    
    set HgLtr [font metrics SeqFont -linespace]
    set LgLtr [font measure SeqFont Z]

    set LgPxl [expr {$LgLtr * $LongueurTotale}]
    set HgPxl 50
    set Width [$NomTextSeq cget -width]
    set WdtPxl [expr {$Width * $LgLtr}]

    set Ccs $FrmSequence.csc
    if {! [winfo exists $Ccs]} {
	canvas $FrmSequence.csc  -height $HgPxl  -width $WdtPxl  -scrollregion [list 0 0 $LgPxl $HgPxl]  -bg white  -bd 2  -xscrollincrement 1  -xscrollcommand "$FrmSequence.scrollxseq set"
	grid $FrmSequence.csc -in $FrmSequence -row 2 -column 1 -columnspan 2 -sticky ew
	#grid columnconfigure $FrmSequence 2 -weight 1 -minsize 0
    } else {
	set Lcou [lindex [$Ccs cget -scrollregion] 2]
	if {$Lcou != $LgPxl} {
	    $Ccs configure -scrollregion [list 0 0 $LgPxl $HgPxl]
	}
    }

    if {$f eq ""} {
	$Ccs delete all
	return
    }

    set Lg [set ScoreMeth($f,ListeGrps)]
    #puts "Lg $Lg"

    #
    # Min/Max global or not
    if {[info exists ScoreMeth($f,ScaleGlobal)] && $ScoreMeth($f,ScaleGlobal)} {
	set ScaGlob 1
	set min  9999999.
	set max -9999999.
	foreach g $Lg {
	    if {$ScoreMeth($f,${g}-min) < $min} {
		set min $ScoreMeth($f,${g}-min)
	    }
	    if {$ScoreMeth($f,${g}-max) > $max} {
		set max $ScoreMeth($f,${g}-max)
	    }
	}
    } else {
	set ScaGlob 0
    }

    foreach g $Lg {
	if {$g eq "grise" || $g eq "bidon"} {continue}
	#puts "  g= $g"
	if {$g eq "GroupeToutLeMonde"} {
	    set col black
	} else {
	    set No [string range $g 5 end]
	    set col [CouleurO2Ordali [CouleurDuGroupe $No]]
	}
	#puts "   col $col"

	set Lv {} ; set Lx {}
	set Li [array names ScoreMeth "$f,$g,*"]
	#puts "   Li [llength $Li]"
	foreach v $Li {
	    lassign [split $v ,] t m i 
	    lappend Lx $i
	}
	set c -1
	foreach i [lsort -integer $Lx] {
	    while {$c != ($i - 1)} {
		lappend Lv -999.0
		incr c
	    }
	    lappend Lv [set ScoreMeth($f,$g,$i)]
	    incr c
	}
	if {! [llength $Lv]} {continue}

	if {! $ScaGlob} {
	    set max [set ScoreMeth($f,${g}-max)]
	    set min [set ScoreMeth($f,${g}-min)]
	}
	    
	set i -1
	set Coord {}
	foreach v [lrange $Lv 1 end] {
	    incr i
	    if {$v == -999.} {
		if {$Coord == {}} {continue}
		set x [expr {$i*$LgLtr}]
		set y $HgPxl
		lappend Coord $x $y
		$Ccs create line $Coord  -fill $col  -width 1
		set Coord {}
	    } else {
		set v [expr {1.0*($v-$min)/($max-$min)}]
		if {$Coord == {}} {
		    set x [expr {$i*$LgLtr}]
		    set y $HgPxl
		    lappend Coord $x $y
		}
		set x [expr {$i*$LgLtr+$LgLtr/2}]
		set y [expr {round($HgPxl-$v*$HgPxl)}]
		lappend Coord $x $y
	    }
	}
	if {$Coord != {}} {
	    incr i
	    set x [expr {$i*$LgLtr-1}]
	    set y $HgPxl
	    lappend Coord $x $y
	    $Ccs create line $Coord  -fill $col  -width 3
	}
    }
    
    FenetreAuCentre $NomFenetreOrdali
    $Ccs xview moveto [lindex [$FrmSequence.scrollxseq get] 0]
    update idletasks

    return

}

proc DessineLigne {AId n xi yi xf yf} {

    global Abr

    set PAD [set Abr($AId,PAD)]
    set xi [SurGrille $xi]
    set yi [SurGrille $yi]
    set xf [SurGrille $xf]
    set yf [SurGrille $yf]

    if {$n ne "root"} {
	set id [$PAD create line $xi $yi $xf $yi  -fill black  -width 2  -tags [list DItem "line-$n"]]
    }
    set id [$PAD create line $xf $yi $xf $yf  -fill black  -width 2  -tags [list DItem "line-$n"]]

    return

}

proc DessineLigneCirculaire {AId n xi yi xf yf} {

    global Abr

    set PAD [set Abr($AId,PAD)]
    set xi [SurGrille $xi]
    set yi [SurGrille $yi]
    set xf [SurGrille $xf]
    set yf [SurGrille $yf]

    if {$n ne "root"} {
	set id [$PAD create line $xi $yi $xf $yf  -fill black  -width 2]
    }

    return

}

proc DessineMoiLaTaxonomy {Source {NomDuFichierOrigine ""} {FenetreParent ""} {LargeurDUneBoite ""} {HauteurDUneBoite ""} {OutLineColor ""}} {
 
    LogWscope "$Source $NomDuFichierOrigine"
    LogWscope [RepertoireDuGenome]

    if {[regexp "wali/store" $Source]} {
	set Queue [file tail $Source]
	if {[regexp {^(HSAP[0-9]+)([^0-9]|$)} $Queue Match Nom]} {
	    set Source /genomics/link/CilioCarta/descriptifs/$Nom
	}
    }

    if {[OnTraite "Zero"]} { return "" }

    #rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir

    set AvecTexte 0
    set PourGif 0
    set PourCanVir 0
    if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
    if {                $FenetreParent==""} { set FenetreParent "NormalWindow" }
    if {$FenetreParent=="PourGif"} {
	set PourGif 1
    } elseif {$FenetreParent=="PourCanVir"} {
	CanvaVirtuel "Reset"
	set PourCanVir 1
    } else {
	if {$FenetreParent=="NormalWindow"} {
	    set w [NomDe fenetre]
	} else {
	    set w $FenetreParent
	}
    }

#    regsub {/macsim[^/]+/} $Source "/descriptifs/" DescFile
    set LesIDOXOSOC [AfficheLesDescriptifs $Source MemeOrdre LaListe "" "ID AC OX OS OC"]
    set INode 0
    set Nom [file tail $NomDuFichierOrigine]
    set Titre $NomDuFichierOrigine

    if {$PourGif} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } elseif {$PourCanVir} {
	CanvaVirtuel CanVir $NomDuFichierOrigine 
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set w "PourCanVir"
	set K "CanvaVirtuel"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K "ToCreate"
    }

    set BilanCilioExists [BilanCilio exists]
    if {$BilanCilioExists} {
	DifferentColor Reset
	set ColorOf(Clade_) "white"
	foreach Clade [BilanCilio ListOf Clade] {
	    regsub {[A-Z]+\_} $Clade "" Clade
	    if {[info exists ColorOf(Clade_$Clade)]} { continue }
	    set Color [DifferentColor]
	    set ColorOf(Clade_$Clade) $Color
	}
    }

    set MaxLevel 0
    set i -1
    set AllNode {}
    foreach Ligne $LesIDOXOSOC {
	incr i
	scan $Ligne "%s" ID
	regsub "=.*" $ID "" ID
	set VraiID [StringApres "ID:" dans $Ligne]
	if {$VraiID!="" && ! [regexp "_" $ID]} { set ID $VraiID } 
	set OX [IntegerApres "OX:" dans $Ligne]
	if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] }
 
	set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
	if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }

	regsub "OC:.*" $Ligne "" Ligne
	set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
	if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }
	regsub -all {[\. ]} $OC "" OC
	set LesNode [split $OC ";"]
	lappend LesNode $OS
#	Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
	set Level -1
	set PrevNode ""
	foreach Node $LesNode {
	    if { ! [info exists PreviousNode($Node)]} { set PreviousNode($Node) $PrevNode }
	    set PrevNode $Node
	    if { ! [info exists INodeOf($Node)]} {
		set INodeOf($Node) [incr INode]
	    }
	    incr Level
	    lappend AllNode $Node
	    lappend IdsFromNode($Node) $ID
	    set     LevelOfNode($Node) $Level
	    
	    if {[info exists AreaOf($Node)]} { set AreaOf($Node) 0 }
	    incr AreaOf($Node) $Level
	    
	}
	set MaxLevel [Maxi $MaxLevel $Level]
    }
    set NbLignes [expr $i+1]
    set AllNode [lsort -unique $AllNode]
    foreach Node $AllNode {
#	Espionne "$Node [llength $PreviousNode($Node)] $LevelOfNode($Node)"
    }

    set PreferedOrganisms [list "Homo sapiens" "Mus musculus"]
    set HighArea 9999
    foreach O $PreferedOrganisms {
	set AreaOf($O) [incr HighArea -1]
    }
    foreach {N A} [array get AreaOf] {
	lappend ListOfArea $A
	lappend NodesOfArea($A) $N
    }
    set ListOfArea [lsort -unique -integer -decreasing $ListOfArea]
    DifferentColor Reset
    foreach A $ListOfArea {
	foreach Node $NodesOfArea($A) {
	    if {[info exists ColorOf($Node)]} { continue }
	    set Color [DifferentColor]
	    lappend ListOfColor $Color
	    set ColorOf($Node) $Color
	    set N $Node
	    while {[info exists PreviousNode($N)] && [set N $PreviousNode($N)]!=""} {
		if {[info exists ColorOf($N)]} { break }
		set ColorOf($N) $Color
	    }
	}
    }

    if {$LargeurDUneBoite==""} { set LargeurDUneBoite 70 }
    if {$HauteurDUneBoite==""} { set HauteurDUneBoite 15 }
    if {$OutLineColor==""} {
	if {$HauteurDUneBoite<5} {
	    set OutLineColor "same"
	} else {
	    set OutLineColor "white"
	}
    }

    set xDebut 0
    set xFin   [expr ($MaxLevel+2)*$LargeurDUneBoite]

    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    set CanvaScreenX  $CanvaSizeX

    set yDebut 0
    set yFin   [expr ($NbLignes+2)*$HauteurDUneBoite]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

    if { [regexp "expo" $w] } {
	set NormalCanvaScreenX $CanvaScreenX
	set CanvaScreenX 300
	set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
	set Papa $w
    }

    if { ! $PourGif && ! $PourCanVir} {
	set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
    }

    set IdCadre [$K find withtag "Cadre"]
    $K itemconfigure $IdCadre -fill "white"

    set SepTexteNode "\n"
    if {$PourCanVir} { set SepTexteNode " " }

    

    set i -1
    foreach Ligne $LesIDOXOSOC {
#	regsub -all {[ \t]+} $Ligne " " Ligne   ;#rR rajouté 2015/01/24
	incr i
	set PosMinY [expr $i*$HauteurDUneBoite] 
	set PosMaxY [expr $PosMinY+$HauteurDUneBoite]
	scan $Ligne "%s" ID
	regsub "=.*" $ID "" ID
	set VraiID [StringApres "ID:" dans $Ligne]
	if {$VraiID!="" && ! [regexp "_" $ID]} {
	    regsub "^$ID=" $Ligne $VraiID= Ligne            ; #rR 2015/05/21  pour avoir le ID et non pas l'access 
	}
	set OX [IntegerApres "OX:" dans $Ligne]
	if {$OX=="" && [EstUnPAB $ID]} { set OX [NotreOX] } 

	set PlaceBilan 0
	if {$BilanCilioExists} {
	    set Clade [BilanCilio $OX Clade]
	    regsub {^[A-Z]+_} $Clade "" Clade
	    if {$Clade=="" && $OX==9606} { set Clade "Mammalia" }
	    set Etat [BilanCilio $OX State]

	    set Couleur $ColorOf(Clade_$Clade)
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
	    set XduF [expr $XduD  + $LargeurDUneBoite/2 -1]
	    $K create rect $XduD $PosMinY $XduF $PosMaxY  -tags [list "Clade" "$Clade $Etat" "$Clade$SepTexteNode$Ligne"]  -outline $CouleurTrait  -fill $Couleur
	    
	    incr PlaceBilan
	    set Couleur "lightgrey"
	    if {$Etat==""}   { set Couleur "#ffffffffffff" }
	    if {$Etat=="Y"}  { set Couleur "#90b1eed89080" }
	    if {$Etat=="N"}  { set Couleur "#ffffc0c4cbc4" }
	    if {$Etat=="L"}  { set Couleur "#ffffcc500000" }
	    if {$Etat=="PR"} { set Couleur "#ffffcc500000" }
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    set XduD [expr ($PlaceBilan) * $LargeurDUneBoite/2]
	    set XduF [expr $XduD  + $LargeurDUneBoite/2 -1]
	    $K create rect $XduD $PosMinY $XduF $PosMaxY  -tags [list "State" "$Etat $Clade" "$Etat$SepTexteNode$Ligne"]  -outline $CouleurTrait  -fill $Couleur
	    incr PlaceBilan 1
	}
 
	set OC [string trim [StringSuivant "OC:" dans $Ligne] " \t"]
	if {$OC=="" && [EstUnPAB $ID]} { set OC [NotreOC] }
	regsub "OC:.*" $Ligne "" Ligne
	set OS [string trim [StringSuivant "OS:" dans $Ligne] " \t"]
	if {$OS=="" && [EstUnPAB $ID]} { set OS [NotreOS] }

	regsub -all {[\. ]} $OC "" OC

	set LesNode [split $OC ";"]
	lappend LesNode $OS
#	Espionne "[llength $LesNoeuds] $ID $OX $OS $OC"
	set Level -1
	set Ruban ""
	set TexteDuNode ""
	set Sep ""
	set OffsetX 0
	foreach Node $LesNode {
	    append TexteDuNode "$Sep$Node"
	    set Sep "; "
	    incr Level
	    if { ! [info exists INodeOf($Node)]} {
		set INodeOf($Node) [incr INode]
	    }
	    append Ruban " [format %3.3d $INodeOf($Node)]"
	    set Couleur $ColorOf($Node)
	    set XduD [expr ($PlaceBilan + $Level) * $LargeurDUneBoite]
	    set XduF [expr $XduD  + $LargeurDUneBoite -1]
	    if {$OutLineColor=="same"} {
		set CouleurTrait $Couleur
	    } else {
		set CouleurTrait $OutLineColor
	    }		
	    $K create rect $XduD $PosMinY $XduF $PosMaxY  -tags [list "Node" $TexteDuNode "$Node$SepTexteNode$Ligne"]  -outline $CouleurTrait  -fill $Couleur
#	     $K create text $XduD [expr $PosMinY+$HauteurDUneBoite/2] -text $Couleur -font {Courier 8} -anchor w
#	     $K create text 1200 [expr $PosMinY+$HauteurDUneBoite/2] -text "[format %-30s $OS] $OC $OS" -anchor w
	}
#	Espionne $Ruban
    }
    global PagePropre
    set PagePropre($w) [join $LesIDOXOSOC "\n"]

    #rR on pourrait peut-être mettre ça plus bas mais il faut d'abord redéfinir TouchePour
    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
    if {$PourGif} { return $LesOrdresPourGif }

    $K bind "Node" <1>       "ClickDansSeq $K %x %y"
    $K bind "Node"    "EntreDansSeq $K %x %y"
    $K bind "Node"    "SortDeSeq $K %x %y"

    $K bind "Clade"    "EntreDansSeq $K %x %y"
    $K bind "Clade"    "SortDeSeq $K %x %y"
    $K bind "State"    "EntreDansSeq $K %x %y"
    $K bind "State"    "SortDeSeq $K %x %y"

    if {$HauteurDUneBoite==2} { set HBoite 15 } else { set HBoite 2 }

    set Clavier "[$Winfo parent $K].buttons"
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "lightgrey"
    TouchePour $Clavier "Description"       "AfficheLesDescriptifs $Source   MemeOrdre"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom      Natif"
    TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $Source $Source {} {} $HBoite"
    TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom      Natif     {} {} {OX OC} $Nom"
    TouchePour <3>      "/page"             "AfficheLesDescriptifs \[set PagePropre($w)\] MemeOrdre {} {} {OX OC} $Nom"

    return $w

}

proc DessineMoiLesMSF {Selection} {

    global GalerieCourante
    global ExpoCourante
    global Memo

    set ExpoCourante [NomDe expo]
    set GalerieCourante $ExpoCourante[NomDe galerie]

    CreeGalerie $GalerieCourante

    foreach FichierMSF [split $Selection "\n"] {
	set w [CreeImagette]
	DessineMoiUnMSF $FichierMSF $FichierMSF "" $w

	Espionne "[LargeurDe $w] [HauteurDe $w]"

	Expose $w
    }

}

proc DessineMoiLesTTLs {Fichier} {

    # Fichier avec les positions du TTL domain
    # /groupes/poch/carles/TTLL12/HumanTTLs/InfosTTLs2
    # (accession numbers des TTL et TTLL : voir le Mat&Meth de l'article TTLL12)
    
    set Police             "Courier 8"
    set PoliceTitre        "Courier 12 bold"

    set BordY              30.0
    set BordX              75.0

    set HauteurFenetre     [expr [winfo screenwidth .] - 200]
    set LargeurFenetre     [expr [winfo screenwidth .] - 100]

    set LargeurMax         [expr [winfo screenwidth .] - 100]
    set LargeurAffichage   [expr ($LargeurMax - 2*$BordX)*1.0]

    set HauteurBoiteChromo 30

    set EcartEntreRepresentations 10
    
    # Combien de choses a representer
    set HauteurMax [expr $BordY + 14*$HauteurBoiteChromo + 13*$EcartEntreRepresentations]

    if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax}
    set HauteurAffichage   [expr ($HauteurMax - 2*$BordY)*1.0]
    
    # CANEVA
    set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre]

    # FACTEUR (fct de la longueur la plus grande, ici pour aligner les TTL domaines, 946 (Nter + TTL domain de TTLL4)+ 875 (Cter TTLL5)
    set Facteur [expr $LargeurAffichage / 1821]

    set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo]
    set PosYMax [expr $HauteurMax - $BordY]
    set PosXMin $BordX 

    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LesElts [split $Ligne "\t"]
	set Nom [lindex $LesElts 0]
	set Longueur [lindex $LesElts 1]
	set TTLinf [lindex $LesElts 2]
	set TTLsup [lindex $LesElts 3]

	#FaireLire "-$Nom -$Longueur -$TTLinf -$TTLsup"
	
	set PosXMax [expr $BordX + ($Longueur*$Facteur)]
	set PosXMinTTL [expr $BordX + ($TTLinf*$Facteur)]
	set PosXMaxTTL [expr $BordX + ($TTLsup*$Facteur)]

	# 651 = TTLinf de TTLL4 (domain TTL le plus en Cter)
	set PosXMaxTTLL4inf [expr $BordX + (651.0*$Facteur)]
	set CorrectionAlign [expr $PosXMaxTTLL4inf - $PosXMinTTL]
	#FaireLire $CorrectionAlign

	set PosXMin [expr $PosXMin + $CorrectionAlign]
	set PosXMax [expr $PosXMax + $CorrectionAlign]
	set PosXMinTTL [expr $BordX + ($TTLinf*$Facteur) + $CorrectionAlign]
	set PosXMaxTTL [expr $BordX + ($TTLsup*$Facteur)+ $CorrectionAlign ]

	$K create line $PosXMin [expr $PosYMax-($HauteurBoiteChromo/2)] $PosXMax [expr $PosYMax-($HauteurBoiteChromo/2)] -fill "black" -width 2 
	$K create rectangle $PosXMinTTL $PosYMin $PosXMaxTTL $PosYMax -outline "black" -fill "black"

	$K create text [expr $BordX/2] [expr ($PosYMax + $PosYMin)/2] -text "$Nom" -font "$Police" -fill "blue"
	$K create text [expr $LargeurMax - $BordX/2] [expr ($PosYMax + $PosYMin)/2] -text "$Longueur aa" -font "$Police" -fill "blue"

	set PosYMax [expr $PosYMin - $EcartEntreRepresentations]    
	set PosYMin [expr $PosYMin - $EcartEntreRepresentations - $HauteurBoiteChromo]

	set PosXMin $BordX 
    }

}

proc DessineMoiUnMSF {TexteOuFichierMSF {NomDuFichierOrigine ""} {OnlyPDB All} {FenetreParent NormalWindow}} {

    global CouleurDuFond
    global DessinCourant
    global ScrollRectangleOriginal IdScrollRectangle
    global Memo
    global LesOrdresPourGif


#    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" } 
    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "white" } 

    if {[regexp "\n" $TexteOuFichierMSF]} {
	set MSF $TexteOuFichierMSF
    } else {
	if { ! [file exists $TexteOuFichierMSF]} { return "" }
	set MSF [ContenuDuFichier $TexteOuFichierMSF]
	if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $TexteOuFichierMSF }
    }

    set AvecTexte 0

    if {$OnlyPDB=="Ask"} {
	set OnlyPDB [ChoixParmi {"OnlyPDB" "All"}]
    }

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

    set PourGif ""
    if {$FenetreParent=="PourGif"} {
	set PourGif "PourGif"
    } else {
	set w $FenetreParent
    }

    set Nom [file tail $NomDuFichierOrigine]

    DecortiqueUnMSF $MSF LesSequencesDansLOrdre Sequences
    
    set LesBonnesSequencesDansLOrdre {}
    foreach NomSeq $LesSequencesDansLOrdre {
	if { $OnlyPDB && ! [EstUnPAB $NomSeq] && ! [EstUnAccessPDB $NomSeq] } { continue }
	lappend LesBonnesSequencesDansLOrdre $NomSeq
    }
    if {[llength $LesBonnesSequencesDansLOrdre]<2} {
	FaireLire "Only one sequence, no alignment to display."
	return ""
    }
    set LesSequencesDansLOrdre $LesBonnesSequencesDansLOrdre

    set NombreDeSequences [llength $LesSequencesDansLOrdre]
    set MaxLongueurSequence 0
    foreach NomSeq $LesSequencesDansLOrdre {
	set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
    }

    set Titre $NomDuFichierOrigine

    if {$PourGif != ""} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
#	set w [NomDe board]
#	catch {destroy $w}
#	toplevel $w
#	wm title $w "$Titre"
#	wm iconname $w "$Titre"
	set K       $w.canvas
    }


    set LargeurDUneLettre 1
    set xDebut 0
    set xFin   [expr $MaxLongueurSequence*$LargeurDUneLettre]
#    incr xDebut -50
#    incr xFin    50
    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    set CanvaScreenX  $CanvaSizeX

    set HauteurDUneLettre [expr $LargeurDUneLettre*2]
    set yDebut 0
    set yFin   [expr $NombreDeSequences*$HauteurDUneLettre]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

#   if { [regexp "expo" $w] } {
#	set NormalCanvaScreenX $CanvaScreenX
#	set CanvaScreenX 300
#	set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
#	set Papa $w
#    } else {
#	set KShSv   $w.grid
# 	$Fram $KShSv
#	set Papa    $KShSv
#    }

    set K [UnCanva $CanvaScreenX $CanvaScreenY $CanvaScreenX $CanvaScreenY]

    set i -1
    foreach NomSeq $LesSequencesDansLOrdre {
	incr i
	set Seq [set Sequences($NomSeq)]
	set lSeq [expr [string length $Seq]-1]
	for {set j $lSeq} {$j>=0} {incr j -1} {
	    if {[string index $Seq $j] != "."} { set lSeq $j ; break }
	}
	incr lSeq
	set SeqBlanc [string range $Seq 0 $lSeq]
	for {set j $lSeq} {$j < $MaxLongueurSequence} {incr j} {
	    append SeqBlanc " "
	}
	set PosMinY [expr $i*$HauteurDUneLettre] 
	set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
	set PointEstBlanc 1
	if {[info exists OldCouleur]} { unset OldCouleur }
	set PosMinX 0
	set PosMaxX 0
	for {set j 0} {$j < $MaxLongueurSequence} {incr j} {
	    set Lettre [string index $SeqBlanc $j]
	    if { $Lettre != "." } { set PointEstBlanc 0 }
	    if { $PointEstBlanc && $Lettre == "." } { set Lettre " " }
	    if {1 || [regexp "expo" $w]} {
		set Couleur [CouleurDeLaLettre $Lettre PourExpo]
		if {($NomSeq=="QUERY_PROTEIN" || [EstUnPAB $NomSeq])  && $Lettre != "." && $Lettre != " " } {
		    set Couleur "black"
		}
		if {[info exists OldCouleur] && ($Couleur!=$OldCouleur || [expr $j==$MaxLongueurSequence-1])} {
		    $K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY  -tags [list "Lettre"]  -outline $OldCouleur  -fill $OldCouleur
		    set PosMinX $PosMaxX
		}
		set OldCouleur $Couleur
		incr PosMaxX $LargeurDUneLettre
		continue
	    } else {
		set PosMinX [expr $j*$LargeurDUneLettre] 
		set PosMaxX [expr $PosMinX+$LargeurDUneLettre]
		set Couleur [CouleurDeLaLettre $Lettre]
		$K create rect $PosMinX $PosMinY $PosMaxX $PosMaxY  -tags [list "Lettre"]  -outline $Couleur  -fill $Couleur
		
		if { $AvecTexte} { 
		    set TxtCenX 0
		    set TxtCenY 0
		    set PosTxtX [expr ($PosMinX+$PosMaxX)/2 + $TxtCenX]
		    set PosTxtY [expr ($PosMinY+$PosMaxY)/2 + $TxtCenY]
		    if {[YaPABdans $NomSeq]} {
			set CouleurTxt "black"
			set FonteTxt {Courier 11}
		    } else {
			set CouleurTxt "black"
			set FonteTxt {Courier 10}
		    }
		    $K create text $PosTxtX $PosTxtY -tags [list "Texte" "$NomSeq"]  -text $Lettre  -anchor c  -fill $CouleurTxt  -font $FonteTxt
		}
	    }
	}
	if {$PourGif} {
	    set LesTags [list "WebClic" "tembl:$NomSeq"]
	    set Couleur $CouleurDuFond
	} else {
	    set LesTags [list "Seq" "$NomSeq"]
	    set Couleur ""
	}
	$K create rect $CanvaScroMinX $PosMinY $CanvaScroMaxX $PosMaxY  -tags $LesTags  -outline $Couleur  -fill $Couleur
    }

    if {$PourGif} { return $LesOrdresPourGif }

    if {1} {
 	set Clavier "[$Winfo parent $K].buttons"
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightgrey"
	TouchePour $Clavier "Description"       "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif"
	TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif     {} {} {OX OC} $Nom"
	TouchePour <3>      "/page"             "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
    }

    if { [regexp "expo" $w]} { 
	$K bind all <1>   "DessineMoiUnMSF $MSF $NomDuFichierOrigine" $OnlyPDB "NormalWindow" 
	$K scale all 0 0  [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] 
	set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
	set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
    } else {
	$K bind "Seq" <1>       "ClickDansSeq $K %x %y"
	$K bind "Seq"    "EntreDansSeq $K %x %y"
	$K bind "Seq"    "SortDeSeq $K %x %y"
	set DessinCourant $K
    }

    if {$PourGif} { return $LesOrdresPourGif }
    return $w

}

proc DessineMoiUnRSF {TexteOuNomOuFichierRSF {NomDuFichierOrigine ""} {FenetreParent ""} {AboutOrder ""} {WithSeq ""}} {

    global CouleurDuFond
    global DessinCourant
    global ScrollRectangleOriginal IdScrollRectangle
    global Memo
    global LesOrdresPourGif
    #rR a rajouté WithSeq pour permettre de passer la séquence pour chaque feature (dans les Tags)
    set WithSeq [regexp -nocase "WithSeq" $WithSeq]

    #rR FenetreParent can be a window name, NormalWindow, PourGif or PourCanVir

    #rR AboutOrder permet de rendre l'ordre ou d'imposer un nouveau (les index séparés par un blanc)
    set NewOrder ""
    set GetOrder 0
    if {$AboutOrder!=""} {
	set GetOrder [string equal -nocase $AboutOrder "GetOrder"]
	if { ! $GetOrder } {
	    regsub -all {[ \t\n,;]+} $AboutOrder " " AboutOrder
	    set NewOrder [split [string trim $AboutOrder] " "]
	}
    }

    if {[PourWscope] && $FenetreParent==""} { set FenetreParent "PourCanVir" }
    if {                $FenetreParent==""} { set FenetreParent "NormalWindow" }
    set AvecTexte 0
    set PourGif 0
    set PourCanVir 0

    if {$FenetreParent=="PourGif"} {
	set PourGif 1
    } elseif {$FenetreParent=="PourCanVir"} {
	CanvaVirtuel "Reset"
	set PourCanVir 1
    } else {
	if {$FenetreParent=="NormalWindow"} {
	    set w [NomDe fenetre]
	} else {
	    set w $FenetreParent
	}
    }

    if { ! [info exists CouleurDuFond]} { set CouleurDuFond "cadetblue" } 

    set RSF ""
    if {[regexp "\n" $TexteOuNomOuFichierRSF]} {
	set FichierRSF "RSF"
	set RSF $TexteOuNomOuFichierRSF
    } else {
	if {[regexp {\.msf$} $TexteOuNomOuFichierRSF]} {
	     regsub {\.msf$} $TexteOuNomOuFichierRSF "" TexteOuNomOuFichierRSF
	}
	set FichierRSF $TexteOuNomOuFichierRSF
	set Queue [file tail $TexteOuNomOuFichierRSF]
	if {[EstUnPAB $Queue]} {
	    set FichierRSF "[RepertoireDuGenome]/rsf/$Queue.rsf"
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/rsf/$Queue"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue.rsf"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF "[RepertoireDuGenome]/macsimRsf/$Queue"
	    }
	    if { ! [file exists $FichierRSF]} {
		set FichierRSF $TexteOuNomOuFichierRSF
	    }
	}
	if {[file exists $FichierRSF]} {
	    set RSF [ContenuDuFichier $FichierRSF]
	}
    }
    if { ! [regexp {^!!RICH} $RSF]} { return "" }
    if {$NomDuFichierOrigine==""} { set NomDuFichierOrigine $FichierRSF }


    set Nom [file tail $NomDuFichierOrigine]

    set NombreDeSequences [DecortiqueUnRSF $RSF LesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]

    if {$GetOrder} { return $LesSequencesDansLOrdre }
    if {$NewOrder!=""} { set LesSequencesDansLOrdre $NewOrder }
    set MaxLongueurSequence 0
    foreach NomSeq $LesSequencesDansLOrdre {
	set MaxLongueurSequence [Maxi $MaxLongueurSequence [string length [set Sequences($NomSeq)]]]
    }
#parray Sequences

    set Titre $NomDuFichierOrigine

    if {$PourGif} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } elseif {$PourCanVir} {
	CanvaVirtuel CanVir $NomDuFichierOrigine 
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set Winfo     NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set w "PourCanVir"
	set K "CanvaVirtuel"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set Winfo     winfo
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K "ToCreate"
    }


    set LargeurDUneLettre 1
    set xDebut 0
    set xFin   [expr $MaxLongueurSequence*$LargeurDUneLettre]
#    incr xDebut -50
#    incr xFin    50
    set CanvaSizeX    [expr $xFin - $xDebut]
    set CanvaScroMinX [expr $xDebut]
    set CanvaScroMaxX [expr $xFin  ]
    #set CanvaScreenX  $CanvaSizeX
    set CanvaScreenX  1200

    set HauteurDUneLettre [expr $LargeurDUneLettre*2]
    set yDebut 0
    set yFin   [expr $NombreDeSequences*$HauteurDUneLettre]
    set CanvaSizeY    [expr $yFin - $yDebut]
    set CanvaScroMinY [expr $yDebut]
    set CanvaScroMaxY [expr $yFin  ]
    set CanvaScreenY  [expr $CanvaSizeY]

    if { [regexp "expo" $w] } {
	set NormalCanvaScreenX $CanvaScreenX
	set CanvaScreenX 300
	set CanvaScreenY [expr round($CanvaSizeY*(1.0*$CanvaScreenX)/$CanvaSizeX)]
	set Papa $w
    }

    if { ! $PourGif && ! $PourCanVir} {
	set K [UnCanva $CanvaScroMaxX $CanvaScroMaxY $CanvaScreenX $CanvaScreenY "GonfleY" $NomDuFichierOrigine]
    }

    set IdCadre [$K find withtag "Cadre"]
    $K itemconfigure $IdCadre -fill "white"

    if {0} {
	foreach K [array names TabRSF] {
	    if { ! [regexp KAD7_HUMAN $K]} { continue }
	    Espionne "$K $TabRSF($K)"
	}
	exit
    }


    set i -1
    foreach NomSeq $LesSequencesDansLOrdre {
	incr i
	set PosMinY [expr $i*$HauteurDUneLettre] 
	set PosMaxY [expr $PosMinY+$HauteurDUneLettre]
	set TextSeq $NomSeq 
	if {[info exists TabRSF($NomSeq,creator)]} {
	    append TextSeq " [join [set TabRSF($NomSeq,creator)] " "]"
	}
	if {[info exists TabRSF($NomSeq,descrip)]} {
	    append TextSeq " [join [set TabRSF($NomSeq,descrip)] " "]"
	}
	if {[info exists TabRSF($NomSeq,group)]} {
	    append TextSeq " MacsimsCluster [join [set TabRSF($NomSeq,group)] { }]"
	}
	foreach FeatureType [set TabRSF($NomSeq,LesTypesDeFeatures)] {
	    if {[info exists TabRSF($NomSeq,Type,$FeatureType)]} {
		foreach Donnee [set TabRSF($NomSeq,Type,$FeatureType)] {
		    scan $Donnee "%d %d %d %d %s %s %s" D F dL fL Couleur Forme EmptyFull
		    set XduD [expr $D-1]
		    set XduF [expr $F]
		    set LesTags [list "Seq" $TextSeq $FeatureType $Donnee]
		    if {$WithSeq} {
			set S [string range $Sequences($NomSeq) $XduD $XduF-1]   ;#rR pas sûr du -1
			lappend LesTags $S
		    }
		    $K create rect $XduD $PosMinY $XduF $PosMaxY  -tags $LesTags  -outline $Couleur  -fill $Couleur
		}
	    }
	}
	set SeqGlob $Sequences($NomSeq)
	regsub -all {\.}  $SeqGlob "" SeqLoc
	regsub {^\.+} $SeqGlob "" SeqGlobD
	set D [expr [string length $SeqGlob]-[string length $SeqGlobD]+1]
	regsub {\.+$} $SeqGlobD "" SeqGlobDF
	set Q [expr [string length $SeqGlobD]-[string length $SeqGlobDF]+1]
	set F [expr $MaxLongueurSequence - $Q]
	set XduD [expr $D-1]
	set XduF $F
	set LongLoc [string length $SeqLoc]
	set Couleur "Grey75"
	set Form "square"
	set EmptyFull "solid"
	set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
	set LesTags [list "GlobSeq" $TextSeq GLOBALSEQ $Donnee]
	if {1 && $WithSeq} {
	    lappend LesTags $SeqGlobDF
	}
	$K create rect $XduD $PosMinY $XduF $PosMaxY   -tags $LesTags  -outline $Couleur  -fill $Couleur
	lappend TabRSF($NomSeq,LesTypesDeFeatures) "GLOBALSEQ"

	if {$PourCanVir} {
	    set Couleur "transparent"
	    set Form "square"
	    set EmptyFull "solid"
	    set Donnee "$D $F 1 $LongLoc $Couleur $Form $EmptyFull"
	    set LesTags [list "ShowSequence" $TextSeq SHOWSEQUENCE $Donnee]
	    if {1 && $WithSeq} {
		lappend LesTags $SeqGlobDF
	    }
	    $K create rect $XduD $PosMinY $XduF $PosMaxY   -tags $LesTags  -outline $Couleur  -fill $Couleur
	    lappend TabRSF($NomSeq,LesTypesDeFeatures) "SHOWSEQUENCE"
	    set TabRSF($NomSeq,WholeSeq) $Sequences($NomSeq)
	}
    }
    lappend TabRSF(LesTypesDeFeatures) "GLOBALSEQ"
    if {$PourCanVir} { lappend TabRSF(LesTypesDeFeatures) "SHOWSEQUENCE" }
    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }  
    if {[info exists GrosBoutons]} {
	set Boutons "[$Winfo parent $K].buttons"
	foreach FeatureType $TabRSF(LesTypesDeFeatures) {
	    $Button $Boutons.t_$FeatureType -text "$FeatureType/lower/clear"
	    $Bind   $Boutons.t_$FeatureType <1> "$K raise $FeatureType"
	    $Bind   $Boutons.t_$FeatureType <2> "$K lower $FeatureType"
	    $Bind   $Boutons.t_$FeatureType <3> "$K lower $FeatureType Cadre"
	    $Pack   $Boutons.t_$FeatureType -side left -expand 1
	}
    } else {
	set Clavier "[$Winfo parent $K].buttons"
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "lightgrey"
	TouchePour $Clavier "Description"       "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif"
	TouchePour $Clavier "Taxonomy"          "DessineMoiLaTaxonomy  $NomDuFichierOrigine $NomDuFichierOrigine {} {} $HauteurDUneLettre same"
	TouchePour <2>      "/all"              "AfficheLesDescriptifs $Nom                 Natif     {} {} {OX OC} $Nom"
	TouchePour <3>      "/page"             "AfficheLesDescriptifs $NomDuFichierOrigine MemeOrdre {} {} {OX OC} $Nom"
	TouchePour $Clavier "BilanCilioCarta"   "AfficheBilanCilioCarta $NomDuFichierOrigine"
	set LesTypesDeFeatures $TabRSF(LesTypesDeFeatures)
	set N [llength $LesTypesDeFeatures]
	set BoutonsParClavier [Maxi 3 [expr $N/4]]
	set nBoutons 0
	set PremiereFois 1
	foreach FeatureType $LesTypesDeFeatures {
	    if {$nBoutons%$BoutonsParClavier==0} {
		TouchePour $Clavier NouvelleGamme
		TouchePour $Clavier NouvelleCouleur "green"
		if {$PremiereFois} {
		    TouchePour $Clavier "Clear all" "$K raise Cadre"
		    set PremiereFois 0
		    incr nBoutons
		}
	    }
	    TouchePour $Clavier "$FeatureType" "$K raise $FeatureType"
	    TouchePour <2>      "/low"         "$K lower $FeatureType"
	    TouchePour <3>      "/off"         "$K lower $FeatureType Cadre"
	    incr nBoutons
	}
    }

    if {$PourGif} { return $LesOrdresPourGif }
 
    if { [regexp "expo" $w]} { 
	$K bind all <1>   "DessineMoiUnRSF $RSF $NomDuFichierOrigine NormalWindow" 
	$K scale all 0 0  [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] [expr (1.0*$CanvaScreenX)/$NormalCanvaScreenX] 
	set Memo(LargeurDe$w) [expr $CanvaScreenX+20]
	set Memo(HauteurDe$w) [expr $CanvaScreenY+20]
    } else {
	$K bind "Seq" <1>       "ClickDansSeq $K %x %y"
	$K bind "Seq"    "EntreDansSeq $K %x %y"
	$K bind "Seq"    "SortDeSeq $K %x %y"
	set DessinCourant $K
    }

    if {$PourCanVir} { return [CanvaVirtuel "GetActionsAndReset"] }
    if {$PourGif} { return $LesOrdresPourGif }
    return $w

}

proc DessineOrgaEtSesPlaces {{Fichier ""} {PourGif ""}} {

    global RepertoireDuGenome
    global LesOrdresPourGif
    global LigneOriginePhylo
    
    if {$Fichier==""} { set Fichier "$RepertoireDuGenome/fiches/orgaetsesplaces.tout_le_monde" }
 
    set LesLignes [LesLignesDuFichier $Fichier]
    set n [llength $LesLignes]

    set Titre "PhyloRank"

    set LC 25
    set HL 20

    set nColonnes 13
    set nLignes $n

    set Fonte {Courier 15}
    set TailleTexteOrga [font measure $Fonte [string repeat "M" 26]] 
    set EspacementHorizontal 15
    set EspaceVertical 40
    set PosYEntete [expr $EspaceVertical/2]

    set DecalageDesRectangles [expr $EspacementHorizontal + $TailleTexteOrga + $EspacementHorizontal] 
    set LargeurVoulue [expr $DecalageDesRectangles + $nColonnes*$LC + $EspacementHorizontal]
    set HauteurVoulue [expr $EspaceVertical + ($nLignes+2)*$HL]


    if {$PourGif != ""} {
	set PourGif 1
	set Canvas    NeRienFaire
	set Bind      NeRienFaire
	set Pack      NeRienFaire
	set Fram      NeRienFaire
	set Button    NeRienFaire
	set Scrollbar NeRienFaire
	set Grid      NeRienFaire
	set FonctionRejetteLaBoite "RejetteLaBoite"
	set LesOrdresPourGif {}
	set w "PourGif"
	set K "OrdrePourGif"
    } else {
	set PourGif 0
	set Canvas    canvas
	set Bind      bind
	set Pack      pack
	set Fram      frame
	set Button    button
	set Scrollbar scrollbar
	set Grid      grid
	set FonctionRejetteLaBoite "NeRejettePasLaBoite"
	set K [UnCanva $LargeurVoulue $HauteurVoulue $LargeurVoulue $HauteurVoulue]     
	regsub ".canvas" $K "" w
	wm title $w "$Titre"
	wm iconname $w "$Titre"
    }

    $K configure -background "lightgrey"
    $K create rectangle 0 0 $LargeurVoulue $HauteurVoulue -fill grey -tags [list "Cadre"]

    $K create text  [expr $DecalageDesRectangles/2] [expr $EspaceVertical/2]  -text $Titre  -font {Courier 12}  -anchor c


    set MettreEntete 1
    set iEmeOrga 0
    if {[info exists ValeurMaxiDuTableau]} { unset ValeurMaxiDuTableau }
    foreach Ligne $LesLignes {

	if { ! [regexp -nocase {[a-z]} $Ligne] } { continue }
	if {[regexp "^#" $Ligne] } { continue }
	scan $Ligne "%s" Orga
	set Complet [Glossaire $Orga Complet]
	if { $Orga == "xxxx" } { continue }

	set Phylum [PhylumDuGenome $Complet]
	if {$Phylum=="X"} { set Phylum [PhylumDuOrganisme $Complet] }

	set Couleur "black"
	if {$Phylum=="B"} { set Couleur "darkgreen" }
	if {$Phylum=="A"} { set Couleur "blue" }
	if {$Phylum=="E"} { set Couleur "red" }

	incr iEmeOrga

	set LigneOriginePhylo($K,$Orga) $Ligne
	Espionne $Ligne
	set TexteOrga [string range $Complet 0 25]
	$K create text  $EspacementHorizontal [expr $EspaceVertical + $iEmeOrga*$HL]  -text $TexteOrga  -anchor w  -font $Fonte  -tags [list "$Complet" "$Orga" "TexteOrga" "Ligne_$iEmeOrga"]  -fill $Couleur


	Wup "Attention ces valeurs doivent correspondre a CreeLaTable"
	set OffsetColonne 18
	set ValeurVide "    "
	set LargeurValeur [string length $ValeurVide]

	set Reste [string range $Ligne $OffsetColonne end]
	set Valeurs $Reste
	while {[regexp "  " $Valeurs]} { regsub -all "  " $Valeurs " " Valeurs }
	set ValeurMaxiDeLaLigne [MaxiDeLaListe [lrange [split [string trim $Valeurs] " "] 0 end-1]]
	
	set Colonne 0
	set Rang 0
	while {[regexp {[0-9]} $Reste]} {
	    set SPP [string range $Reste 0 [expr $LargeurValeur-1]]
	    set Reste [string range $Reste [expr $LargeurValeur+1] end]
	    incr Colonne
	    incr Rang
	    if {$MettreEntete} {
		set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
		set Texte $Rang
		$K create text  $PosX $PosYEntete  -width 20  -text $Texte  -font {Courier 6}  -anchor n  -fill "black"
	    }
	    if { $SPP == $ValeurVide} { continue }
	    set PP 0
	    scan $SPP "%d" PP
	    if {$PP==0} { continue }
	    if { ! [info exists ValeurMaxiDuTableau]} { set ValeurMaxiDuTableau $PP }
	    if {$PP>$ValeurMaxiDuTableau} { set PP $ValeurMaxiDuTableau }
	    set DuTableau 0
	    if {$DuTableau} {
		set p [expr (1.*$PP)/$ValeurMaxiDuTableau]
	    } else {
		set p [expr (1.*$PP)/$ValeurMaxiDeLaLigne]
	    }
	    if {[regexp {[0-9]} $Reste]} {
		set Couleur [Nuance [expr $p] 0.5 0.1]
	    } else {
		set Couleur "lightgrey"
	    } 

	    if {$PourGif} {
		set LesTags [list "WebClic" "gscope:AfficheLesConcernesDeCeRang \{$Complet\} $SPP $Rang $Fichier"]
	    } else {
		set LesTagsR [list "$Complet" "$SPP" "$Rang"             "Affichable" "Ligne_$iEmeOrga"]
		set LesTagsT [list "$Complet" "$SPP" "$Rang" "TexteRang" "Affichable" "Ligne_$iEmeOrga"]
	    }

	    set PosX [expr $DecalageDesRectangles + $Colonne*$LC]
	    $K create rect  [expr $PosX-$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL-$HL/3]  [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL+$HL/3]  -tags $LesTagsR  -outline $Couleur  -fill $Couleur
	    $K create text  [expr $PosX+$LC/3] [expr $EspaceVertical + $iEmeOrga*$HL]  -text $PP  -font {Courier 6}  -anchor e  -tags $LesTagsT  -fill "black"
	}
	set MettreEntete 0
    }

    $K configure -height [Mini 800 [expr ($iEmeOrga+1)*$HL]]

    set Boutons $w.buttons
    $Button $Boutons.toggle -text "Hide both/Orga/Rank\nSave order"
      $Bind $Boutons.toggle <1> "ToggleTextePhylo $K Both"
      $Bind $Boutons.toggle <2> "ToggleTextePhylo $K Orga"
      $Bind $Boutons.toggle <3> "ToggleTextePhylo $K Rank"
      $Bind $Boutons.toggle  "SavePhylOrder $K $Fichier"
      $Pack $Boutons.toggle -side left -expand 1

#    $Pack $K

    $K bind "Affichable" <1> "AfficheLesConcernesDeCeRang $K %x %y $Fichier"
    $K bind all  "ChangeOrdrePhylo $K %x %y $HL -1 $iEmeOrga"
    $K bind all  "ChangeOrdrePhylo $K %x %y $HL  1 $iEmeOrga"

    if {$PourGif } { return $LesOrdresPourGif }
    if { 0 && [PourWscope] } {
	return $w
    } else {
	return $K
    }

}

proc DessineUneMontre {{w ""}} {

global maclock
global CanTime

if {$w eq ""} {set w [UnCanva]}
set CanTime $w
#    canvas $w.c -bg black -highlightthickness 0
#    pack $w.c

setLCD
clockSet maclock
showLCD $CanTime $maclock
foreach {- - wd hg} [$CanTime bbox all] break
$CanTime configure -width $wd -height $hg
update idletasks

trace add variable maclock write MetHeureAJour

return

}

proc DessineVrpDe {} {

    global Vrp LNDG

    set s [set Vrp(seqSelName)]
    set i [lsearch [set Vrp(NameList)] $s]
    set Vrp(seqSel) $i
    
    if {$s eq "All"} {set s "GroupeToutLeMonde"}
    if {$s in $LNDG} {
	VrpDeGroupe $s
    } else {
	GenVrpFromData [set Vrp(Seq,$i)]
    }
    DrawVrp

    ColorieVrpSelon "" [set Vrp(UseFeat)]

    return

}

proc Destroy {w} {

    global KanvaCourant
    destroy $w
    return 

}

proc DestroyStack {{OtherStack ""}} {

    global OurCurrentStack OurStacks
    if {$OtherStack!=""} { set OurCurrentStack $OtherStack }
    if { ! [info exists OurCurrentStack]} { return "" }
    if {[info exists OurStacks($OurCurrentStack,StackHeight)]} { 
	while { ! [IsEmptyStack]} { PullFromStack }
	unset OurStacks($OurCurrentStack,StackHeight)
	unset OurCurrentStack
    }

}

proc DetectUnselectedSeqs {} {

    global NomSeqSel LNOrdali SeqsOut

    if {! [info exists NomSeqSel] || [llength $NomSeqSel] <= 3} {return}
    
    foreach p $NomSeqSel {
	lassign [split $p .] y x
	lappend Lsel [lindex $LNOrdali $y-1]
    }
    set Lreste [lor $Lsel $LNOrdali]
    foreach s $Lreste {
	if {[string trim $s] eq ""} {continue}
	set SeqsOut($s) 1
    }

    return

}

proc DetecteCopainsDoublons {} {

    set LesDoubles {}
    foreach Nom [ListeDesPABs] {
	set Fichier [GscopeFile $Nom "tfasdescopains"]
	if {[FileAbsent $Fichier]} { continue }
	if {[info exists DejaVu]} { unset DejaVu }
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp {^>} $Ligne] } { append Seq($AccessCourant) $Ligne ; continue }
	    scan $Ligne "%s" Access
	    if {[info exists DejaVu($Access)]} {
		lappend LesDoublons($Nom) $Access
		lappend LesDoubles $Nom
		lappend LesIduAccess($Access) [incr IduAccess($Access)]
		set AccessCourant "${Access}_$IduAccess($Access)"
	    } else {
		set DejaVu($Access) 1
		set IduAccess($Access) 1
		set AccessCourant "${Access}_$IduAccess($Access)"
	    }
	}
    }
    set LesDoubles [lsort -unique $LesDoubles]
    foreach Double $LesDoubles {
	set LesDoublons($Double) [lsort -unique $LesDoublons($Double)]
	set Seq1 $Seq(${Access}_1)
	set YaDiff($Double) ""
	foreach I $IduAccess($Access) {
	    set AccessCourant "${Access}_$I"jalviewApplet
	    if {$Seq1 ne $Seq($AccessCourant)} { set YaDiff($Double) "YaDiff" }
	    
	}
	lappend LaSortie "$Double [join $LesDoublons($Double) " "] $YaDiff($Double)"
    }
    return [AfficheListe $LaSortie]

}

proc DetecteLesMauvaisOrganismes {Fichier} {

    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp -nocase { [a-z]+ } $Ligne Match]} {
	    Espionne "$Match [string range $Ligne 0 40]"
	} 
    }
    exit

}

proc DetecteTypeFichier {file} {


    set type ""
    set Ll [LesLignesDuFichier $file]
    set i 0
    while {[set l [string trim [lindex $Ll $i]]] eq ""} {
	incr i
    }
    set l [string tolower $l]
    switch -regexp $l {
	{^\<\?xml} {set type "xml"}
	{^!!RICH_} {set type "rsf"}
	{^SQLite}  {set type "ord"}
	{^CLUSTAL} {set type "aln"}
	{^\>}      {set type "tfa"}
	{^msf\: }  {set type "msf"}
    }

    if {$type eq ""} {
	set Lt [lrange $Ll 0 2000]
	set Ix [lsearch -regexp $Lt {MSF:.+Type:.+Check:.+\.\.}]
	if {$Ix != -1} {set type msf}
    }

    return $type

}

proc DetectionDesVariants {{LesDefinitions ""}} {


    Wup "Permet de trier les access dans le cas ou on a des variants decrits dans RefSeq"

    #set LesDefinitions [list [list "NM_212438" "Mus musculus widely-interspaced zinc finger motifs (Wiz), transcript variant 1, mRNA"] [list "NM_001100" "Mus musculus actin skeletal muscle mRNA"] [list "NM_011717" "Mus musculus widely-interspaced zinc finger motifs (Wiz), transcript variant 2, mRNA"] [list "NM_212437" "Mus musculus widely-interspaced zinc finger motifs (Wiz), transcript variant 3, mRNA"] [list "NM_2124" "Mus musculus widely-interspaced zinc finger motifs (Wiz), transcript variant gamma 2, mRNA"] [list "NM_438" "Mus musculus  zinc finger motifs (Wiz), transcript variant 1, mRNA"] [list "M_212438" "Mus musculu widely-interspaced zinc finger motifs (Wiz), transcript variant 1, mRNA"] [list "M_011717" "Mus musculu widely-interspaced zinc finger motifs (Wiz), transcript variant 23, mRNA"] [list "M_212437" "Mus musculu widely-interspaced zinc finger motifs (Wiz), transcript variant 18, mRNA"]]
    
    set Out ""

    #1 Passage des definitions en revus et stockage des types de variants
    set  NbDef [llength $LesDefinitions]
    if {$NbDef=="1"} {return "$Out"}

    foreach AccDef $LesDefinitions {
	#Espionne "$AccDef"
	foreach {Acc Def} $AccDef {
	    set Tmp     ""
	    set Variant ""
	    if {! [info exists TabVariant(LesAccess)]} {
		set     TabVariant(LesAccess) ""
		lappend TabVariant(LesAccess) $Acc
	    } else {
		lappend TabVariant(LesAccess) $Acc
	    }
	    
	    if {[regexp -nocase {transcript variant (.+),} $Def Tmp Variant]} {
		set NewDef ""
		#regsub -nocase $Variant $Def "" NewDef
		regsub  -nocase {transcript variant (.+),} $Def "transcript variant ," NewDef
		#Espionne "$Acc $NewDef"

		set TabVariant($Acc,VariantType) $Variant
		set TabVariant($Acc,Def)         $Def
		set TabVariant($Acc,NewDef)      $NewDef
	    } else {
		set TabVariant($Acc,Def)         $Def
	    }
	}
    }
    
    #2 Test qui est le variant de qui
    foreach AccA [set TabVariant(LesAccess)] {
	if {! [info exists TabVariant($AccA,NewDef)]}     {continue}

	foreach AccB [set TabVariant(LesAccess)] {
	    if {$AccA==$AccB}                             {continue}
	    if {  [info exists TabVariant($AccA,$AccB)]}  {continue}
	    if {  [info exists TabVariant($AccB,$AccA)]}  {continue}
	    if {  [info exists TabVariant($AccB)]}        {continue}
	    if {! [info exists TabVariant($AccB,NewDef)]} {continue}

	    if {[string compare [set TabVariant($AccA,NewDef)] [set TabVariant($AccB,NewDef)]]=="0"} {
		#Espionne "$AccA == $AccB"
		set TabVariant($AccA,$AccB) 1
		set TabVariant($AccB,$AccA) 1
		set TabVariant($AccB)       1
		set TabVariant($AccA)       1
		if {! [info exists TabVariant($AccA,LesVariants)]} {
		    set     TabVariant($AccA,LesVariants) ""
		    lappend TabVariant($AccA,LesVariants) $AccB
		} else {
		    lappend TabVariant($AccA,LesVariants) $AccB
		}
	    }
	}
    }
    
    #3 Reconstruction
    foreach AccC [set TabVariant(LesAccess)] {
	set LesVariants ""
	if {[info exists TabVariant($AccC,LesVariants)]} {
	    set LesVariantTypes ""
	    foreach AccD [set TabVariant($AccC,LesVariants)] {
		if {$AccC==$AccD} {continue}
		lappend LesVariantTypes [set TabVariant($AccD,VariantType)]
	    }
	    set ListeAcc [concat $AccC [set TabVariant($AccC,LesVariants)]]
	    set ListeAcc [join $ListeAcc ";"]

	    lappend Out [list "$ListeAcc" "[set TabVariant($AccC,Def)] and variant [join $LesVariantTypes ","]."]
	    #lappend Out [list "$AccC [join [set TabVariant($AccC,LesVariants)] ";"]" "[set TabVariant($AccC,Def)] and variant [join $LesVariantTypes ","]."]
	    #Espionne "[list "$AccC [join [set TabVariant($AccC,LesVariants)] " "]" "[set TabVariant($AccC,Def)] and variant [join $LesVariantTypes ","].""
	} else {
	    if {[info exists TabVariant($AccC)]}       {continue}
	    lappend Out [list $AccC [set TabVariant($AccC,Def)]]

	    #Espionne "$AccC NoVariant [set TabVariant($AccC,Def)]"
	}
    }

    return "$Out"

}

proc DeterminationAcNum {seqn} {


set idxd [string first ":" $seqn]
# si la chaine contient un double point
if {$idxd != -1} {
set seqn [string range $seqn [expr $idxd+1] end]
} else {
set seqn [string range $seqn 2 end]
}

set fin "end"
set idxf [string first " " $seqn]
if {$idxf != -1} {set fin [expr $idxf-1]}
set acnum [string range $seqn 0 $fin]

return $acnum

}

proc DeterminationDisease {seqn} {


global file1
global file2

set j [lsearch -regexp $seqn "MIM"]
if {$j != -1} {
set idxd [string first ":" $seqn]
set seqn [string range $seqn [expr $idxd+1] end]
set idxf [string first " " $seqn]

if {$idxf == -1} {
set fin "end"
} else {
set fin [expr $idxf-1]
}

set disease [string range $seqn 0 $fin]
} else {
set disease ""
}
return $disease

}

proc DeterminationNbConservationSA {listeCons listeSA} {


    set l1 {}
    set l2 {}
    set l3 {}

    puts "la liste des cons est $listeCons"
    puts "la liste des sa est $listeSA"
    # 1 represente les identites - 2 les conservations - 3 les similarites
    set i 0
    # pour chacun des sites
    foreach e $listeSA {
	set i 0
	# pour chaque type de conservation
	foreach l $listeCons {
	    incr i
	    puts "\nl est $l\n"
	    if { [lsearch -regexp $l $e] != -1 } {
		lappend l$i $e
		puts "j'ai trouve $e dans $i"
		break
	    }
	}
    }

    set lnb {}
    lappend lnb [llength $l1] [llength $l2] [llength $l3]
    #  puts $lnb
    return $lnb

}

proc DeterminationSeuil {Distances DescendDansArbre} {

    #on recherche parmi la liste des distances 
    #quel est le plus grand ecart entre 2 valeurs consecutives

    set Max [expr [llength $Distances]-1]
    for {set i 0} {$i<$Max} {incr i} {
	set Ecart($i) [expr [lindex $Distances [expr $i+1]]-[lindex $Distances $i]]
    }
    set i 0
    set EcartMax 0
    set IndexGrandEcart $Max
    while {$i<$Max} {
	if {[set Ecart($i)]>$EcartMax} {
	    set IndexGrandEcart $i
	    set EcartMax [set Ecart($i)]
	}
	incr i
    }
    #un -1 est rajoute pour le clustering sequences
    if {$DescendDansArbre} {incr IndexGrandEcart -1}
    return [lindex $Distances $IndexGrandEcart]   

}

proc DetermineGroupesEquivalents {liste ldata ln} {


    global Sequences
    global lesTypes

    array set t $liste
    array set d $ldata
    set lFinale {}

    # place dans une liste les clusters de chaque methode de selection
    array set Ref [set t([lindex $lesTypes 0])]
    array set Mou [set t([lindex $lesTypes 1])]
    array set Ban [set t([lindex $lesTypes 2])]
    array set Luc [set t([lindex $lesTypes 3])]

    # pour ne pas tenir compte de la liste qui "GroupeToutLeMonde"
    unset Ref(GroupeToutLeMonde)
    unset Mou(GroupeToutLeMonde)
    unset Ban(GroupeToutLeMonde)
    unset Luc(GroupeToutLeMonde)

    # place dans une liste les info relatives a chaque selection
    array set dRef [set d([lindex $lesTypes 0])]
    array set dMou [set d([lindex $lesTypes 1])]
    array set dBan [set d([lindex $lesTypes 2])]
    array set dLuc [set d([lindex $lesTypes 3])]

    array set Sequences $ln
    set nbCl [llength [array names Ref]]
    set i 1

    foreach Refg [array names Ref] {
	lappend lFinRef $Refg
	lappend lFinRef [llength [set Ref($Refg)]]
	lappend lFinRef ""
	lappend lFinRef [NbIdenGroupe $i [array get dRef]]
	incr i
    }

    lappend lFinale [set lFinRef]

    foreach sel {Mou Ban Luc} {

	set l$sel {}
	set lFin$sel {}
	# pour chaque cluster mis en evidence pour Nature
	foreach Refg [array names Ref] {

	    set liste$sel [array names $sel]
	    # la liste lRefg contient le nom des sequences du cluster traite
	    set lRefg [set Ref($Refg)]
	    set lgCl [llength $lRefg]

	    # on met ses noms tout en majuscules
	    set lRefgU [toUpperList $lRefg]
	    set l$sel$Refg {}
	    # on traite chaque cluster
	    while  { [set liste$sel] != "" } {
		set max 0
		foreach ${sel}g [set liste$sel] {
		    # recupere la liste de sequences du cluster en cours
		    set l${sel}g [set ${sel}([set ${sel}g])]
		    # determine le nombre de communs entre les sq de la ref et les sq du cluster en cours
		    set l${sel}gU [toUpperList [set l${sel}g]]
		    set com [landInd [set l${sel}gU] $lRefgU]
		    set ncom [llength $com]

		    if {$ncom > $max} {
			set max $ncom
			set cmax [set ${sel}g]
			set comp [lindex $lRefg [lindex $com 0]]
		    }
		}

		if {$max != 0} {
		    lappend l$sel$Refg $cmax $max $comp
		    set liste$sel [lreplace [set liste$sel] [lsearch [set liste$sel] $cmax] [lsearch [set liste$sel] $cmax] ]
		} else {
		    set liste$sel ""
		}
	    }

	    lappend l$sel [set l$sel$Refg]
	}

	set lFinale$sel [NettoieListe [set l$sel]]

	for {set k 0} {$k < $nbCl} {incr k} {
	    lappend lFin$sel [lindex [lindex [set lFinale$sel] $k] 0]
	    lappend lFin$sel [lindex [lindex [set lFinale$sel] $k] 1]
	    lappend lFin$sel [lindex [lindex [set lFinale$sel] $k] 2]
	}

	set lFin$sel [DetermineIdenGroupe [set lFin$sel] [array get dRef] [array get d$sel]]

	lappend lFinale [set lFin$sel]

    }
    array set Sequences ""

    return $lFinale

}

proc DetermineIdenGroupe {lCorres lRef lSel} {


    set lFin $lCorres
    set n [expr [llength $lCorres] / 3]
    #set nbcom 0
    for {set i 1} {$i <= $n} {incr i} {
	set nbcom 0
	set comp [lindex $lCorres [expr $i * 3 - 1]]
	if {$comp != ""} {
	    set grRef [TabGroupe $comp $i $lRef]
	    set grSel [TabGroupe $comp [string range [lindex $lCorres [expr $i * 3 - 3]] 3 end] $lSel]
	    if {$grRef != "" && $grSel != ""} {
		set nbcom [llength [land $grRef $grSel]]
	    }
	    set lFin [linsert $lFin [expr $i * 4 - 1] $nbcom]
	} else {
	    set lFin [linsert $lFin [expr $i * 4 - 1] ""]
	}
    }

    return $lFin

}

proc DetermineLeMeilleurNM {ListeNm} {

    set onanm 0
    foreach Acc $ListeNm {
	if {[regexp "NM_" $Acc]} {set onanm 1}
    }
    set premierefois 1
    foreach Acc $ListeNm {
	if {[regexp "XM_" $Acc] && $onanm} {continue}
	set Commande "getz \"\\\[refseq-acc:$Acc\\\]\" \-vf sl"
	set GetzOut [eval exec $Commande]
	set long [lindex [split $GetzOut "\t"] 1]
	#Espionne "$Acc $long"
	if {$premierefois} {
	    set pluslong $long
	    set accpluslong $Acc
	    set premierefois 0
	} else {
	    if {$long>$pluslong} {
		set pluslong $long
		set accpluslong $Acc
	    }
	}
    }
    set MeilleurNm $accpluslong
    return $MeilleurNm

}

proc DetermineLePlusGrand {Liste} {

    set premierefois 1
    foreach elmt $Liste {
	if {$premierefois} {
	    set Max $elmt
	    set premierefois 0
	}
	if {!$premierefois} {
	    if {$elmt>$Max} {
		set Max $elmt
	    }
	}
    }
    return $Max

}

proc DetermineLePlusPetit {Liste} {

    set premierefois 1
    foreach elmt $Liste {
	if {$premierefois} {
	    set Min $elmt
	    set premierefois 0
	}
	if {!$premierefois} {
	    if {$elmt<$Min} {
		set Min $elmt
	    }
	}
    }
    return $Min

}

proc DetermineLeStringLePlusLong {ListeDeString} {

    set premierefois 1
    foreach string $ListeDeString {
	set long [string length $string]
	if {$premierefois} {
	    set Max $long
	    set lelong $string
	    set premierefois 0
	}
	if {!$premierefois} {
	    if {$long>$Max} {
		set Max $long
		set lelong $string
	    }
	}
    }
    return "$lelong\t$Max"

}

proc DetermineLesFragmentsLuc {} {

    global TDesPCI LNOrdali Sequences ListeDesFragments TDesFragments

    set ListeDesFragments {}

    FaireAttendre "Please wait ...\nDetermiining sequences corresponding to fragments"

    foreach n [array names Sequences] {
	lappend Ll $n [string length [string trim [set Sequences($n)] "."]]
    }

    set i 2
    foreach {p a} [lrange $Ll 0 end-2] {	
	foreach {q b} [lrange $Ll $i end] {
	    if {$a > $b} {
		set v [expr {double($a)/$b}]
		set ref1 $p
		set ref2 $q
	    } else {
		set v [expr {double($b)/$a}]
		set ref1 $q
		set ref2 $p
	    }
	    if {$v < 0.8} {CalculeLesPCI "" "" $ref1 $ref2}
	}
	incr i 2
    }

    foreach c [array names TDesPCI] {
	lassign [split $c ,] n1 n2
	lassign [set TDesPCI($c)] pc l1 l2 lg
	set bpc [expr {$pc > 0.6}]
	set blg [expr {$lg < 0.8}]
	set bn1 [expr {$n1 ni $ListePDB}]
	set bn2 [expr {$n2 ni $ListePDB}]
	if { $blg && $bpc && $bn1 && $bn2} {
	    lappend Frag $n1
	}
    }

    if {[info exists Frag]} {
	set ListeDesFragments [lsort -unique $Frag]
	foreach n $ListeDesFragments {
	    set TDesFragments($n) 1
	}
    }

    FaireLaSuite .frag

    return $ListeDesFragments

}

proc DetermineLocUcsc {LocUcscGbRs LocUcscRs} {

    #meme chose que InformeLocUcscPourTous en moins bien mais besoin ds DeterminePourcentageRecouvrement. De toute facon, plus besoin de choisir entre les 2 coord a ce niveau, deja fait avant => faut modifier DeterminePourcentageRecouvrement
    set dsles2 0
    if {![regexp {[0-9]+} $LocUcscGbRs] && ![regexp {[0-9]+} $LocUcscRs]} {
	set LocUcsc "no value"
    } elseif {[regexp {[0-9]+} $LocUcscGbRs] && [regexp {[0-9]+} $LocUcscRs]} {
	set dsles2 1
	if {$LocUcscGbRs == $LocUcscRs} {
	    set LocUcsc $LocUcscGbRs
	} else {
	    set LesMotsGbRs [split $LocUcscGbRs {:- }]
	    set startGbRs [lindex $LesMotsGbRs 1]
	    set stopGbRs [lindex $LesMotsGbRs 2]
	    set longGbRs [expr $stopGbRs-$startGbRs]
	    set LesMotsRs [split $LocUcscRs {:- }]
	    set startRs [lindex $LesMotsRs 1]
	    set stopRs [lindex $LesMotsRs 2]
	    set longRs [expr $stopRs-$startRs]
	    if {$longGbRs < $longRs} {
		set LocUcsc $LocUcscRs/litige/
	    } else {
		set LocUcsc $LocUcscGbRs/litige/
	    }
	}
    } elseif {!$dsles2 && [regexp {[0-9]+} $LocUcscGbRs]} {
	set LocUcsc $LocUcscGbRs
    } elseif {!$dsles2 && [regexp {[0-9]+} $LocUcscRs]} {
	set LocUcsc $LocUcscRs
    }
    return $LocUcsc

}

proc DetermineNbGlobauxCommuns {lR_mounir lR_bandelettes lR_luc lR_nature} {


    set lGlob {}
    foreach type {"_nature" "_mounir" "_bandelettes" "_luc"} {
	set listeGlobCom$type {}
	set i 0
	foreach e [set lR$type] {
	    set lcom [land $e [lindex $lR_nature $i]]
	    set nbCom$type [llength $lcom]
	    lappend listeGlobCom$type [set nbCom$type]
	    incr i
	}
	lappend lGlob [set listeGlobCom$type]
    }

    return $lGlob

}

proc DeterminePourcentageRecouvrement {Version {Liste ""}} {

    set NbNom 0; set Vides 0; set Pleins 0
    set PourCas1 {}; set PourCas2 {}; set PourCas3 {}; set PourCas4 {}
    set PourCas1bis {}; set PourCas2bis {}; set PourCas3bis {}; set PourCas4bis {}
    set total 0; set cas0 0; set cas1 0; set cas2 0; set cas3 0; set cas4 0; set cas5 0
    set atten 0; set ok 0; set pasok 0

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }

    foreach Nom $Liste {
	#Espionne ""
	incr NbNom; 
	set LesProbeAccess {}; set LesLocAffy {}; set LocUcsc ""; set LesLocPs {}

	set Access [AccessEvi $Nom]
	if {$Access==""} {
	    incr Vides
	    continue
	}
	if {$Access!=""} {
	    incr Pleins
	    
	    if {$Version=="03"} {
		set LocUcscGbRs [ExtraitInfo $Nom "LocUcscFrom200503"]
		set LocUcscRs   [ExtraitInfo $Nom "LocUcscRefSeqFrom200503"]
	    }
	    if {$Version=="08"} {
		set LocUcscGbRs [ExtraitInfo $Nom "LocUcscFrom200508"]
		set LocUcscRs   [ExtraitInfo $Nom "LocUcscRefSeqFrom200508"]
	    }
	    set LocUcsc [DetermineLocUcsc $LocUcscGbRs $LocUcscRs]
	    if {$LocUcsc!=""} {
		Espionne ""
		Espionne "$Nom"
		Espionne "Access      =$Access"
		Espionne "LocUcscGbRs =$LocUcscGbRs"
		Espionne "LocUcscRs   =$LocUcscRs"
		Espionne "LocUcsc     =$LocUcsc"
	    } else {continue} 
	    foreach ProbeAccess [lsort -unique [AffyAnno $Access "Probe_Set_ID"]] {
		set unique {}; set pls 0
		set LesLocAffy [AffyAnno $ProbeAccess "Alignments"]
		Espionne "$ProbeAccess"
		#Espionne "$LesLocAffy"
		if {[regexp {^---} $LesLocAffy]} {Espionne "cas0"; incr cas0; continue}

		set LesLocPs [DecortiqueStringAcSeparateurDonne $LesLocAffy]
		set NbDeProbeset [llength $LesLocPs]
		if {$NbDeProbeset>1} {
		    set pls 1
		   Espionne "pls loc pr un probeset"
		    incr atten
		}
		foreach LocPs $LesLocPs {
		    set LesMotsAffy  [split $LocPs {:- }]
		    set numChrAffy   [lindex $LesMotsAffy 0]
		    set startAffy    [lindex $LesMotsAffy 1]
		    set stopAffy     [lindex $LesMotsAffy 2]
		    set longAffy     [expr $stopAffy - $startAffy]
		    if {$LocUcsc!=""} {
			#incr total
			set LesMots [split $LocUcsc {:- }]
			set numChr  [lindex $LesMots 0]
			set start   [lindex $LesMots 1]
			set stop    [lindex $LesMots 2]
			set long    [expr $stop-$start]
			if {$numChrAffy!=$numChr} {continue}
			#Espionne $LocPs
			incr total
			if {$start>=$startAffy && $stop>=$stopAffy && $stopAffy>=$start} {
			    lappend unique 1
			   Espionne "$LocPs"
			   Espionne "cas1"
			    incr cas1
			    set recouv1 [expr $stopAffy - $start]
			    set pourcentage1 [expr ($recouv1 * 100)/$long]
			    lappend PourCas1 $pourcentage1
			    set pourcentage1bis [expr ($recouv1 * 100)/$longAffy]
			    if {$pourcentage1bis<50} {Espionne "ATTENTION"}
			    lappend PourCas1bis $pourcentage1bis
			   Espionne "recouv1= $recouv1"
			   Espionne "pourcentage1= $pourcentage1 %"
			   Espionne "pourcentage1bis= $pourcentage1bis %"
			} elseif {$start>$startAffy && $stop<$stopAffy} {
			    lappend unique 1
			   Espionne "$LocPs"
			   Espionne "cas4"
			    incr cas4
			    set droite4 [expr $stopAffy - $stop]
			    set gauche4 [expr $start - $startAffy]
			    set surplus [expr $droite4 + $gauche4]
			    set pourcentage4 100
			    lappend PourCas4 $pourcentage4
			    set pourcentage4bis [expr ($long * 100)/$longAffy]
			    if {$pourcentage4bis<50} {Espionne "ATTENTION"}
			    lappend PourCas4bis $pourcentage4bis
			    set pourcentage4ter [expr ($surplus * 100)/$longAffy]
			   Espionne "droite4= $droite4"
			   Espionne "gauche4= $gauche4"
			   Espionne "pourcentage4= $pourcentage4 %"
			   Espionne "pourcentage4bis= $pourcentage4bis %"
			   Espionne "pourcentage4ter= $pourcentage4ter %"
			} elseif {$start<=$startAffy && $stop<=$stopAffy && $stop>=$startAffy} {
			    lappend unique 1
			   Espionne "$LocPs"
			   Espionne "cas2"
			    incr cas2
			    set recouv2 [expr $stop - $startAffy]
			    set pourcentage2 [expr ($recouv2 * 100)/$long]
			    lappend PourCas2 $pourcentage2
			    set pourcentage2bis [expr ($recouv2 * 100)/$longAffy]
			    if {$pourcentage2bis<50} {Espionne "ATTENTION"}
			    lappend PourCas2bis $pourcentage2bis
			   Espionne "recouv2= $recouv2"
			   Espionne "pourcentage2= $pourcentage2 %"
			   Espionne "pourcentage2bis= $pourcentage2bis %"
			} elseif {$start<$startAffy && $stop>$stopAffy} {
			    lappend unique 1
			   Espionne "$LocPs"
			   Espionne "cas3"
			    incr cas3
			    set longAffy     [expr $stopAffy - $startAffy]
			    set gauche3 [expr $startAffy - $start]
			    set droite3 [expr $stop - $stopAffy]
			    set surplus3 [expr $droite3 + $gauche3]
			   Espionne "longAffy= $longAffy"
			    set pourcentage3 [expr ($longAffy * 100)/$long]
			    lappend PourCas3 $pourcentage3
			    set pourcentage3bis 100
			    lappend PourCas3bis $pourcentage3bis
			    if {$pourcentage3bis<50} {Espionne "ATTENTION"}
			    set pourcentage3ter [expr ($surplus3 * 100)/$long]
			   Espionne "droite3= $droite3"
			   Espionne "gauche3= $gauche3"
			   Espionne "pourcentage3= $pourcentage3 %"
			   Espionne "pourcentage3bis= $pourcentage3bis %"
			   Espionne "pourcentage3ter= $pourcentage3ter %"
			} else {
			   Espionne "$LocPs"
			    if {$pls} {
				Espionne "n'en tiens pas compte"
				set total [expr $total - 1]
			    } else {
				Espionne "cas5"
				incr cas5
			    }
			}
		    }
		}
		set bobo 0
		if {$pls} {
		    foreach x $unique {
			if {$x==1} {
			    set bobo 1
			    incr ok
			   Espionne "ok, 1 des locs correspond= $ok"
			    break
			}
		    }
		    if {!$bobo} {
			incr pasok
			Espionne "pasok, aucune des locs correspond= $pasok"
		    }
		}
	    }  
	}
    }
   Espionne ""
    if {$PourCas1bis != {}} {
	Espionne "cas1"
	set Result1 [ArrayRecap $PourCas1bis]
	Espionne $Result1
    }
   Espionne ""
    if {$PourCas2bis != {}} {
	Espionne "cas2"
	set Result2 [ArrayRecap $PourCas2bis]
	Espionne $Result2
    }
   Espionne ""
    if {$PourCas3bis != {}} {
	Espionne "cas3"
	set Result3 [ArrayRecap $PourCas3bis]
	Espionne $Result3
    }
   Espionne ""
    if {$PourCas4bis != {}} {
	Espionne "cas4"
	set Result4 [ArrayRecap $PourCas4bis]
	Espionne $Result4
    }

   Espionne ""
   Espionne "NbNom=  $NbNom"
   Espionne "Vides=  $Vides"
   Espionne "Pleins= $Pleins"
   Espionne "nb de localisation de PS (cas1+2+3+4+5) enleve quand chr diff et quand 1 des locs ne correspond pas =  $total"
   Espionne "cas0= $cas0"
   Espionne "cas1= $cas1"
   Espionne "cas2= $cas2"
   Espionne "cas3= $cas3"
   Espionne "cas4= $cas4"
   Espionne "cas5= $cas5"
   Espionne "pls loc pr un probeset= $atten"
   Espionne "ok, 1 des locs correspond= $ok"
   Espionne "pasok, aucune des locs correspond= $pasok"

}

proc DetermineProtSeqGDB {Lignes id} {


    global RepAJourGDB
    global listeARetranscrire	

    set Reste ""
    
    # decoupage du texte pour ne conserver que ce qui contient des donnees relatives aux seq prot
    set Reste [StringSuivant "Protein Sequence Links" dans $Lignes]
    
    if {$Reste != ""} { 
	set idx [string first "" $Reste]
	set Reste [string range $Reste 0 [expr $idx - 1]]

	# si presence d un "show all", chargement de la page qui contient les donnees
	# la procedure est relancee
	if {[string first "Show" $Reste] != -1} {
	    set idxdeb [expr [string first "href" $Reste] + 5]
	    set idxfin [expr [string first "target" $Reste] - 2]
	    set url2 [string range $Reste $idxdeb $idxfin]
	    set newLignes {}
	    HttpCopy $url2 newLignes
	    if {$newLignes != ""} {
		DetermineProtSeqGDB $newLignes $id
		return 1
	    }
	}
	set lAcNum ""
	# recuperation des references de seq prot
	while {1} {
	    set R [ValeurDeLaBalise a Reste]
	    if {$R==""} { break }
	    lappend lAcNum $R
	}
	
	if {[llength $lAcNum] > 0} {
	    # a partir de lAcNum, faut selectionner le bon identifiant
	    DetermineProtSeqLinkGDB $id $lAcNum
	}
    }
	
    return 1   

}

proc DetermineProtSeqLinkGDB {gdb listeAc} {

    
    global RepAJourGDB
    global listeARetranscrire

    # le fichier ChromoWithProtSeq va contenir la liste complete des gdb auxquels une sequence proteique est associee
    # 1 sequence unique est ici associee a chaque gdb
    
    # va recuperer en priorite l'access SP, pis PIR, pis PDB
    set fin ""
    
    if {[lsearch -regexp $listeAc "UniProt"] != -1} {
	set ind [string first "UniProt" $listeAc]
	set part [string range $listeAc [expr $ind + 8] end]
	if {[string index $part 0] == " "} {
	    set part [string range $part 1 end]
	}
	set fin  [string first " " $part]
    } elseif {[lsearch -regexp $listeAc "SWISS-PROT"] != -1} {
	set ind [string first "SWISS-PROT" $listeAc]
	set part [string range $listeAc [expr $ind + 11] end]
	if {[string index $part 0] == " "} {
	    set part [string range $part 1 end]
	}
	set fin  [string first " " $part]
    } elseif { [lsearch -regexp $listeAc "PIR"] != -1} {
	set ind  [string first "PIR" $listeAc]
	set part [string range $listeAc [expr $ind + 4] end]
	set fin  [string first " " $part]
    } elseif {[lsearch -regexp $listeAc "PDB"] != -1} {
	set ind  [string first "PDB" $listeAc]
	set part [string range $listeAc [expr $ind + 15] end]
	set fin  [string first " " $part]
    } 
    
    if {$fin != ""} {
	if {$fin != -1} {
	    set id [string range $part 0 [expr $fin - 1]]
	} else {
	    set id $part
	}
	regsub -all {[[:punct:]]} $id "" id
	set id [string trim $id "\}"]

	# verifie presence croisee dans HGMD
	#set hgmdLink [InterrogeHgmdParGdb [string range $gdb 4 end]]

	if {[lsearch -regexp $listeARetranscrire $gdb] == -1 && [lsearch -regexp $listeARetranscrire $id] == -1} {
	    puts "$gdb\t$id"
	    lappend listeARetranscrire "$id"
	}
    }
    
    return 1

}

proc Detoure {Boite K} {

    global oldCouleurOutLine
    global oldLargeurOutLine

    set Id [$K find withtag $Boite]

    if {[info exists oldCouleurOutLine($K,$Boite)]} {
	$K itemconfigure $Id  -outline [set oldCouleurOutLine($K,$Boite)]  -width [set oldLargeurOutLine($K,$Boite)]
    }
    return [$K itemcget $Id -outline]

}

proc DetruireLaRosace {w} {

    Wup "Kills and erase the rosace from the currentlist"
    global RosaceCourante
    global ParametresDuBoard
    global LesKanvasOuverts
    global KanvaCourant

    set K $w.canvas

    destroy $w

    set LesRosacesEnCours [set ParametresDuBoard(RosacesEnCours)]

    set i [lsearch $LesRosacesEnCours $K]
    if {$i >= 0} {
	set LesRoacesEnCours [lreplace LesRosacesEnCours $i $i]
	set ParametresDuBoard(RosacesEnCours) $LesRosacesEnCours
	if {[info exists RosaceCourante] && $RosaceCourante==$K} {
	    if {[llength $LesRosacesEnCours] > 0} {
		set RosaceCourante [lindex $LesRosacesEnCours end]
	    }
	}
    }
    set i [lsearch $LesKanvasOuverts $K]
    if {$i >= 0} {
	set LesKanvasOuverts [lreplace LesKanvasOuverts $i $i]
	if {[info exists KanvaCourant] && $KanvaCourant==$K} {
	    if {[llength $LesKanvasOuverts] > 0} {
		set KanvaCourant [lindex $LesKanvasOuverts end]
	    }
	}
    }
    return

}

proc DetruireLeBoard {w} {

    Wup "Kills and erase the board from the currentlist"
    global KanvaCourant
    global LesKanvasOuverts

    after 200 destroy $w

    set K $w.canvas

    set i [lsearch $LesKanvasOuverts $K]
    if {$i < 0} { return }
 
    set LesKanvasOuverts [lreplace LesKanvasOuverts $i $i]
    if {[info exists KanvaCourant] && $KanvaCourant==$K} {
	unset KanvaCourant
	if {[llength $LesKanvasOuverts] > 0} {
	    set KanvaCourant [lindex $LesKanvasOuverts end]
	}
    }
    return

}

proc DetruireLeDotPlot {w} {

    global LesDotPlotCourants 

    set K "$w.grid.canva"

    if { ! [OuiOuNon "Do you really want to dismiss this Dotplot ?"]} { return }

    set i [lsearch $LesDotPlotCourants $K]
    set LesDotPlotCourants [lreplace $LesDotPlotCourants $i $i]
    destroy $w
    return 1

}

proc DetruitArbre {{AId ""}} {

    global Abr

    if {$AId eq ""} {
	set Le [set Abr(ListeArbres)]
    } else {
	trace remove variable Abr($AId,TypeTree) write {SwitchTypeTree $AId}
	set Le $AId
    }

    foreach e $Le {
	set t [set Abr(Arbre,$e)]
	set i [lsearch [set Abr(ListeArbres)] $t]
	set Abr(ListeArbres) [lreplace [set Abr(ListeArbres)] $i $i]
	catch {array unset Abr "Arbre,$AId"}
	catch {array unset Abr "$AId,*"}
	catch {array unset Abr "*,$AId"}
	if {[winfo exists .arbre$e]} {
	    wm protocol ".arbre$e" WM_DELETE_WINDOW ""
	    destroy ".arbre$e"
	}
    }
    if {$AId eq ""} {
	catch {unset Abr}
    }

    return

}

proc DetruitBoutonsOrdali {} {

    global FrmBouton

    if {! [ModeI]} {return}

    lassign [grid size $FrmBouton] nc nr
    for {set i 1} {$i < $nc} {incr i} {
	set Lf [grid slaves $FrmBouton -column $i]
	foreach f $Lf {
	    grid forget $f
	    #destroy {*}[winfo children $f]
	    foreach c [winfo children $f] {
		if {[catch {destroy $c}]} {
		    puts "NON $c"
		}
	    }
	    destroy $f
	    update idletasks
	}
    }

    return

}

proc DetruitInfoSeqs {} {

    global {*}[info globals "TD*"]

    unset -nocomplain {*}[info globals "TD*"]
    update

    return

}

proc DetruitLaFeature {f} {

    global EtatBtnFeat TabSF ListeTypesDeFeatures

    set i [lsearch $ListeTypesDeFeatures $f]
    if {$i == -1} {return}

    if {[QuelMode] eq "feature"} {
	set w [BtnDeLaFeature $f]
	if {$w ne ""} {
	    if {[EtatDuBouton $w]} {ColorieSelonFeature $f $w}
	    catch {array unset EtatBtnFeat $w}
	}
    }
    set ListeTypesDeFeatures [lreplace $ListeTypesDeFeatures $i $i]
    catch {array unset TabSF "*,$f"}

    return

}

proc DetruitLeMac {pkm} {

    global db

    # Table mac
    $db eval {delete from mac where pk_mac=$pkm}
    # table ln_mac_seqali
    set Lv [$db eval {select pk_seqali from ln_mac_seqali where pk_mac=$pkm}]
    foreach v $Lv {
	set Lf [$db eval {select pk_featali from ln_seqali_featali where pk_seqali=$v}]
	$db eval "delete from featali where pk_featali in ([join $Lf ,])"
    }
    $db eval "delete from ln_seqali_featali where pk_seqali in ([join $Lv ,])"
    $db eval {delete from ln_mac_seqali where pk_mac=$pkm}
    
    # clusternig/cluster
    # on detruit cluster apres cluster
    set Lpkg [$db eval {select pk_clustering from ln_mac_clustering where pk_mac=$pkm}]
    foreach pkg $Lpkg {
	set Lpkc [$db eval {select pk_cluster from cluster where pk_clustering=$pkg}]
	foreach pkc $Lpkc {
	    $db eval {delete from ln_seqali_cluster where pk_cluster=$pkc}
	    $db eval {delete from cluster where pk_cluster=$pkc}
	}
    }
    $db eval {delete from ln_mac_clustering where pk_mac=$pkm}
    $db eval {delete from clustering where pk_mac=$pkm}

    # colscore
    set Lc [$db eval {select pk_colmeasure from ln_mac_colmeasure where pk_mac=$pkm}]
    $db eval "delete from colmeasure where pk_colmeasure in ([join $Lc ,])"
    $db eval {delete from ln_mac_colmeasure where pk_mac=$pkm}
    set Ll [$db eval "select pk_colscore from colscore where pk_colmeasure in ([join $Lc ,])"]
    $db eval "delete from colscore where pk_colmeasure in ([join $Lc ,])"
    $db eval "delete from ln_cluster_colscore where pk_colscore in ([join $Ll ,])"

    # annotation
    #$db eval {delete from ln_mac_anno where pk_mac=$pkm}

#    $db eval {commit}

    return

}

proc DetruitLesClustersDuClustering {c} {

    $::db eval {delete from cluster where pk_clustering=$c}

    return

}

proc DetruitLesInfosDe {K} {


    Wup "Nettoie les informations liees au canvas qu on a plus besoin"
    Wup "A faire quand le canvas va etre detruit"

    global TabCanvas

    #Espionne "On Decharge $K"

    #Decharge les infos des oligos
    if {[info exists TabCanvas($K,MesFichiersOligo)]} {
	foreach Fichier [lsort -unique [set TabCanvas($K,MesFichiersOligo)]] {
	    InterrogeInfoDeLOligo $Fichier Decharge
	}
	#unset TabCanvas($K,MesFichiersOligo)
    }

    #Decharge les infos des BestHitInDataBase
    if {[info exists TabCanvas($K,MesBlasts)]} {
	foreach Fichier [lsort -unique [set TabCanvas($K,MesBlasts)]] {
	    InterrogeBestHitInDatabase $Fichier Decharge 
	    AskBlast         unsetfile $Fichier
	}
	#unset TabCanvas($K,MesBlasts)
    }

    #Decharge les infos des logs
    if {[info exists TabCanvas($K,MesLogs)]} {
	foreach Fichier [lsort -unique [set TabCanvas($K,MesLogs)]] {
	    InterrogeInfoDuLogDeLOligo $Fichier Decharge
	}
	#unset TabCanvas($K,MesLogs)
    }
    #On supprime les fenetres crees et enregistrees pas K
    DetruitLesWinDe $K

    array unset TabCanvas "$K*"

    if {0} {
	#Old detruit les infos du canvas
	foreach Stocker [list MesDirs MesLogs MesBlasts MonPAB MonFichierQuery MaTailleDeQuery MonAccessQuery] {
	    if {[info exists TabCanvas($K,$Stocker)]} {unset TabCanvas($K,$Stocker)}
	}
    }
    return ""

}

proc DetruitLesWinDe {K} {


    Wup "Tue les autres fenetres associees a K"

    set        LesCanvas [LesInfosDe $K Win]
    #Espionne "$K mes fenetres: $LesCanvas"
    foreach C $LesCanvas {
	if {[winfo exists $C]} {
	    #Espionne "$C mon toplevel: [winfo toplevel $C]"
	    #set C [winfo toplevel $C]
	    #Espionne "Destruction de: $C"
	    destroy $C
	} else {continue}
    }
    return ""

}

proc DetruitLogConsole {what} {

    global Toggle wtlog TexteDuLog

    if {$what eq "clear"} {
	$wtlog delete 1.0 end
	set TexteDuLog ""

	return
    }

    if {[info exists wtlog] && [winfo exists $wtlog]} {
	destroy [winfo toplevel $wtlog]
	unset wtlog
    }

    update

    return

}

proc DetruitOverview {{Id ""}} {

    global Ovw

    if {$Id eq ""} {
	set Le [set Ovw(Liste)]
    } else {
	set Le $Id
    }

    foreach e $Le {
	set i [lsearch [set Ovw(Liste)] $e]
	set Ovw(Liste) [lreplace [set Ovw(Liste)] $i $i]
	
	array unset Ovw "O$e,*"
	wm protocol ".overview$e" WM_DELETE_WINDOW ""
	destroy ".overview$e"
    }
    if {$Id eq "" || $Ovw(Liste) == {}} {
	unset -nocomplain Ovw
	
	trace remove variable ListeTypesDeFeatures write MetAJourFeaturesOverview
    }

    return

}

proc DetruitSeqActive {v} {

    $::db eval {delete from ln_active_seqali where pk_active=$v}
    return

}

proc DetruitSeqVis {v} {

    $::db eval {delete from ln_vis_seqali where pk_vis=$v}
    return

}

proc DetruitSeqlabGroup {g} {

    global LNSeqlab ListeSeqsGroupees NomNomSeq NomTextSeq
    
    set Lixun [list]
    set Ltags [list]
    foreach s $ListeSeqsGroupees($g) {
	set ix [lsearch $LNSeqlab $s]
	lappend Lixun $ix
	set y [expr {$ix+1}]
	lappend Ltags $y.0 "$y.0 lineend"
    }
    if {$Ltags != {} } {
	$NomNomSeq  tag remove TC$g {*}$Ltags
	$NomTextSeq ungroup $Lixun
    }
    unset -nocomplain ListeSeqsGroupees($g)
    
    return

}

proc DetruitUnBoutonDe {w} {

    set LesBoutons {}
    set Bouton [ChoixParmi [LesBoutonsDeLaFrame $w.buttons]]
    if {$Bouton==""} { return "" }
    if { ! [OuiOuNon "Do You want to remove the button $Bouton ?"]} { return "" }
    destroy $Bouton
    return $Bouton

}

proc DetruitUnCluster {c} {

    $::db eval {delete from cluster where pk_cluster=c}
    return

}

proc DetruitUnPDB {pdbid} {

    global db ListePDB

    # detruit objets assicies
    $pdbid deleteObjects
    $pdbid destroy

    $db eval {begin transaction}
    set pkpdb [$::db eval {select pk_pdb from pdb where nom=$pdbid}]
    $db eval {delete from atomes where pk_pdb=$pkpdb}
    $db eval {delete from residues where pk_pdb=$pkpdb}
    $db eval {delete from chaines where pk_pdb=$pkpdb}
    $db eval {delete from pdb where pk_pdb=$pkpdb}
    $db eval {commit}

    set Li [lsearch -regexp -all $ListePDB $pdbid]
    foreach i [lreverse $Li] {
	set ListePDB [lreplace $ListePDB $i $i]
    }

    return

}

proc DetruitVariablesSaufDepart {} {

    global VariablesAuDepart

    set Lv [info globals]
    foreach v $Lv {
	if {$v eq "VariablesAuDepart"} {continue}
	if {$v in $VariablesAuDepart} {continue}
	global $v
	unset -nocomplain $v
    }

    return

}

proc DetruitVecLC {col} {


    global CanvasLC

    set lobj [$CanvasLC find withtag $col]
    eval $CanvasLC delete $lobj

    return

}

proc DetruitVis {v} {

    DetruitSeqVis $v
    $::db eval {delete from vis where pk_vis=$v}

    return

}

proc DeuxMethodesCoordRelAbsInMACSIMS {} {

    #les 2 proc donnent le meme resultat
    foreach Box [ListeDesPABs] {
	Espionne "$Box"
	set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj"
	if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"}
	set Cluster         [ExtraitInfo $Box "Cluster"]
	set LesNames        [InterrogeNames $Cluster Name Mouse]
	set Ref       [ExtraitInfo $Box "Ref"]
	set RefPfam   [ExtraitInfo $Box "RefPfam"]

	set LaRefEtLesNames [concat [list $Box $RefPfam] $LesNames]
	set LaRefEtLesNames [ListeSansDoublon $LaRefEtLesNames]
	#Espionne "tempsA [time {InitPosRel2Abs $FileMacsims $LaRefEtLesNames}]"
	InitPosRel2Abs $FileMacsims $LaRefEtLesNames
	set LesPfamStartStop {}; set LaCourante {}; set TousLesPfamDuneBoite {}
	foreach Chacun $LaRefEtLesNames {
	    if {$Chacun==$Ref} {set Chacun $Box}
	    set LesPfamsChacun [FromMacsims $FileMacsims $Chacun "ConcatPfam"]
	    Espionne "$Chacun"
	    foreach PfamChacun $LesPfamsChacun {
		set MotsPfamChacun [split $PfamChacun "/"]
		set Pfam           [lindex $MotsPfamChacun 0]
		set MotsPfam [split $Pfam " "]
		set Id             [lindex $MotsPfam 0]
		set PfamName       [lindex $MotsPfam 1]
		regsub "PROP_" $Id "" Id
		set PfamNettoye "$Id"
		Espionne "$PfamNettoye"

		FstartFstop $PfamChacun RFstart RFstop
		#Espionne "tempsB [time {DonnePosRA $Chacun $RFstart Absolue}]"
		set Start [DonnePosRA $Chacun $RFstart Absolue] 
		set Stop  [DonnePosRA $Chacun $RFstop Absolue]
		Espionne "1 $RFstart $RFstop $Start $Stop"
		
		set SeqDataName [FromMacsims $FileMacsims $Chacun "SeqData"]
		PositionAbsolueDansAlignement 1 $SeqDataName
		#Espionne "tempsC [time {PositionAbsolueDansAlignement 1 $SeqDataName}]"
		#Espionne "tempsD [time {PositionAbsolueDansAlignement $RFstart}]"
		set Start2 [PositionAbsolueDansAlignement $RFstart]
		set Stop2  [PositionAbsolueDansAlignement $RFstop]
		Espionne "2 $RFstart $RFstop $Start2 $Stop2"

		if {$Start!=$Start2 || $Stop!=$Stop2} {
		    Espionne "attention"
		}
	    }
	}
    }

}

proc DevStagesGeneraux {DevStage} {

    if {[regexp -nocase       {DPC|embryo|coit|egg|P\.C|morula|blastocy} $DevStage]} {
	set NewDevStage "EMBRYO"
    }  elseif {[regexp -nocase {pregnant}                                $DevStage]} {
	set NewDevStage "ADULT"
    } elseif {[regexp -nocase {day|newborn|neonate}                      $DevStage]} {
	set NewDevStage "DAYS"
    } elseif {[regexp -nocase {week|month|year|adult}                    $DevStage]} {
	set NewDevStage "ADULT"
    } elseif {[regexp -nocase {^[E0-9]+\.[0-9]+$}                        $DevStage]} {
	set NewDevStage "EMBRYO"
    } else {
	set NewDevStage "OTHER"
    }
    return $NewDevStage

}

proc Devlpt {} {


    if {[set ::Defauts(Devlpt)]} {
	return 1
    } else {
	return 0
    }

}

proc Devoile {K X Y {EffaceOuNOuAction end-1}} {

    global RepertoireDuGenome

    set EffaceOuN $EffaceOuNOuAction
    set Efface $EffaceOuN
    if {[regexp {end|[0-9]+|GenScan} $EffaceOuN]} {
	set N $EffaceOuN
	set Efface ""
    } 

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Efface!=""} {
	return ""
    }

    set x [$K canvasx $X]
    set y [$K canvasy $Y]
    set x $X
    set y $Y
    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    if {$EffaceOuNOuAction=="GenScan"} {
	set BornesEtChroContigPro [lindex $MesTags end-1]	
	scan $BornesEtChroContigPro "%d %d %s %s %s" D F S ChroContig Prot
	set Fenetre [AfficheGenscanDuContig $ChroContig]
	Illumine "^ *$Prot\\." $Fenetre
	Illumine "_$Prot\\|" $Fenetre
	return $Fenetre
    }

    set Texte [lindex $MesTags $N]
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    place $M -x $x -y [expr $y-20] -anchor w
    return $M

}

proc DevoileLaValeur {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id      [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Texte   [lindex $MesTags 1]

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-40] -anchor $EW
    return $M

}

proc DevoileLeGO {K X Y} {

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Type             [lindex $MesTags 1]
    set GO               [lindex $MesTags 2]
    set LesDefs          [join [lindex $MesTags 4] "\n"]
    set LesParents       [join [lindex $MesTags 5] " "]
    set LesConstituants  [join [lindex $MesTags 6] " "]
    set LesEnfants       [join [lindex $MesTags 7] " "]
    set LesContributions [join [lindex $MesTags 8] " "]
    set LesJumeaux       [join [lindex $MesTags 9] " "]
    set LesAccess        [lindex $MesTags 10]
    set LesProjetsGscope [lindex $MesTags 11]
    set LesNoms          [lindex $MesTags 12]
    set LesBlastP        [lindex $MesTags 13]
    set LesRequetes      [lindex $MesTags 14]
    set LesClusters      [lindex $MesTags 15]

    set nRequetes        [lindex $MesTags 16]

    set Texte "My Name is\n$Type\n\nMy Nickname is\n$GO\n\nI am\n$LesDefs"

    if {$LesJumeaux       != ""} {append Texte "\n\nMy twins are\n$LesJumeaux"}
    if {$LesParents       != ""} {append Texte "\n\nMy Parents are\n$LesParents"}
    if {$LesConstituants  != ""} {append Texte "\n\nI am constituted by\n$LesConstituants"}
    if {$LesEnfants       != ""} {append Texte "\n\nMy children are\n$LesEnfants"}
    if {$LesContributions != ""} {append Texte "\n\nI contribute to\n$LesContributions"}

    if {$nRequetes        != 0 } {append Texte "\n\nNumber of hits : $nRequetes"}

    if {$LesAccess        != ""} {append Texte "\n\n[join $LesAccess        "\n"]"}
    if {$LesProjetsGscope != ""} {append Texte "\n\n[join $LesProjetsGscope "\n"]"}
    if {$LesNoms          != ""} {append Texte "\n\n[join $LesNoms          "\n"]"}
    if {$LesBlastP        != ""} {append Texte "\n\n[join $LesBlastP        "\n"]"}
    if {$LesClusters      != ""} {append Texte "\n\n[join $LesClusters      "\n"]"}
    if {$LesRequetes      != ""} {append Texte "\n\n[join $LesRequetes      "\n"]"}

    return [AfficheVariable $Texte "AvecFormateAvecBlasteAvecRetour"]

}

proc DevoileLePlot {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]
    set Chro [lindex $MesTags 0]
    set TypeCGH [lindex $MesTags 4]
    ### transformation de la val en log base 10 (oligo CGH) en log base 2
    if {$TypeCGH!="CGH"} {
	set Val [format "%.2f" [expr [lindex $MesTags 3] *1.0]]
	set Val [format "%.2f" [expr $Val*log(10)/log(2)] *1.0]
	set Posinf [lindex $MesTags 1]
	set Possup [lindex $MesTags 2]
	regsub -all {^0*} $Posinf "" Posinf
	regsub -all {^0*} $Possup "" Possup
	set PosMid [expr $Posinf + (($Possup*1.0 - $Posinf*1.0)/2)]
    } else {
	set Val [format "%.2f" [expr [lindex $MesTags 2] *1.0]]
	set PosMid [lindex $MesTags 1]
    }
    set Texte "$Chro\nPosMid: $PosMid\nLog2ratio: $Val"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLePlotAffy {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set ProbeSet [lindex $MesTags 0]
    set PosMid [lindex $MesTags 1]
    set Val [format "%.2f" [expr [lindex $MesTags 2] *1.0]]
    if {[lindex $MesTags 3]!="Affy"} {
	set C [lindex $MesTags 3]
	regsub -all "chr" $C " chr" C
	set Texte "$ProbeSet\nPosMid: $PosMid\nVal: $Val\n!!! This probeset is multi-located ($C)!!!"
    } else {
	set Texte "$ProbeSet\nPosMid: $PosMid\nVal: $Val"
    }
    
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLeTaxon {K X Y Action} {

    set H [winfo screenheight .]
    set L [winfo screenwidth  .]

    regsub ".canvas" $K ".message" M
    catch {destroy $M}
    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]
    set LesTaxons      [lindex $MesTags 1]

    set Taxon          [lindex $LesTaxons end]
    if {[llength $LesTaxons] < 2} {set Ancetres ""} else {set Ancetres [join [lrange $LesTaxons 0 end-1] " ; "]}
    set Descendants    [join [lindex $MesTags 2] " ; "]

    set Texte "$Taxon"
    if {$Ancetres    != ""} {append Texte "\n\nPhylum\n$Ancetres"   }
    if {$Descendants != ""} {append Texte "\n\nSous-classe\n$Descendants"}
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 400 -text $Texte -background "lightyellow" -foreground "black"
    
    if {$Y < [expr $H/2]} { 
	set Y [expr $Y + 10];set NS "n"
    } else { 
	set Y [expr $Y - 10];set NS "s"
    }
    if {$X < [expr $L/2]} { 
	set X [expr $X + 10];set EW "w"
    } else { 
	set X [expr $X - 10];set EW "e"
    }
    place $M -x $X -y [expr $Y-40] -anchor "$NS$EW"
    return $M

}

proc DevoileLesBAC {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Id [lindex $MesTags 4]
    set IntId [lindex $MesTags 5]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin\nName: $Nom\nID: $Id\nInternationalID: $IntId"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"

    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLesBandesCytologiques {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set NomBande [lindex $MesTags 0]
    set Taille   [expr round([lindex $MesTags 1])]
    set Texte "$NomBande\n$Taille Mpb"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M

}

proc DevoileLesBoites {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Nom        [lindex $MesTags 0 ]
    set InfoLoc    [lindex $MesTags 1 ]
    set DQ         [lindex $MesTags 7 ]
    set FQ         [lindex $MesTags 8 ]
    set Chrom      [lindex $MesTags 9 ]
    set DSChro     [lindex $MesTags 10]
    set FSChro     [lindex $MesTags 11]
    set Contig     [lindex $MesTags 13]
    set Fragment   [lindex $MesTags 14]
    set DSCont     [lindex $MesTags 15]
    set FSCont     [lindex $MesTags 16]
    set SensChro   [lindex $MesTags 12]
    set SensCont   [lindex $MesTags 18]
    set BCytos     [join [lindex $MesTags 19] " "]
    set Fold       [lindex $MesTags 21]

    if {$Fold == 0} {
	set Texte "$Nom $DQ $FQ\n$InfoLoc\n$Chrom $DSChro $FSChro $SensChro\n${Contig}_$Fragment $DSCont $FSCont $SensCont\n$BCytos"
    } else {
	set Texte "$Nom $DQ $FQ\n$InfoLoc\n$Chrom $DSChro $FSChro $SensChro\n${Contig}_$Fragment $DSCont $FSCont $SensCont\n$BCytos\nExpression $Fold"
    }

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLesContigs {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set NomContig  [lindex $MesTags 0]
    set Debut      [lindex $MesTags 1]
    set Fin        [lindex $MesTags 2]
    set Sens       [lindex $MesTags 3]
    set Version    [lindex $MesTags 4]

    set Texte "$NomContig.$Version\n$Debut $Fin $Sens"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M

}

proc DevoileLesGenes {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]
    ### NB: les deux derniers elements de MesTags sont "Gene current"
    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    
    set Brin [lindex $MesTags 4]
    set Debcds [lindex $MesTags 5]
    set Fincds [lindex $MesTags 6]
    set NbExons [lindex $MesTags 7]
    set ExonStarts [lindex $MesTags 8]
    set ExonEnds [lindex $MesTags 9]
    set ProtID [lindex $MesTags 10]
    set DefProt [lindex $MesTags [expr [llength $MesTags] -3]]

    set Texte "$Nom\n$Chro\nFrom: $Deb\nTo: $Fin\nStrand: $Brin\nStart_cds: $Debcds\nEnd_cds: $Fincds\nNbExons: $NbExons\nProtein_ID: $ProtID\nDef: $DefProt"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLesHistogrammes {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Variable   [lindex $MesTags 0]
    regsub -all "_" $Variable " " Variable
    set Valeur     [lindex $MesTags 1]
    set Unit       [lindex $MesTags 2]
    set Type       [lindex $MesTags 3]

    set Texte "$Variable\n$Valeur $Unit\n$Type"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M

}

proc DevoileLesInfosDeLaBoite {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set DQ     [lindex $MesTags 0]
    set FQ     [lindex $MesTags 1]
    set Strand [lindex $MesTags 4]
    set Type   [lindex $MesTags 5]
    set nType  [lindex $MesTags 6]
    set CtgOumRNA [lindex $MesTags 8]

    if {$CtgOumRNA == "Contig"} {
	set DS     [lindex $MesTags 2]
	set FS     [lindex $MesTags 3]
	set Texte "Type  : $Type $nType\nStrand: $Strand\nmRNA  : $DQ\t$FQ\nContig: $DS\t$FS"
    } else {
	set Texte "Type  : $Type $nType\nStrand: $Strand\nmRNA  : $DQ\t$FQ"
	if {$Type != "ABSENT"} {
	    foreach Subject [lindex $MesTags 2] {
		set DS [lindex $Subject 0]
		set FS [lindex $Subject 1]
		append Texte "\nCtg   : $DS\t$FS"
	    }
	}
    }
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M

}

proc DevoileLesOligo {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Id [lindex $MesTags 4]
    set Access [lindex $MesTags 5]
    set GN [lindex $MesTags 6]
    set Des [lindex $MesTags 7]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin\nName: $Nom\nID: $Id\nAccessions: $Access\nGeneName: $GN\nDescription: $Des"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLesOntologies {K X Y Action} {

    global RepertoireDuGenome
    set H [winfo screenheight .]
    set L [winfo screenwidth  .]

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Type             [lindex $MesTags 1]
    set GO               [lindex $MesTags 2]
    set Niveau           [lindex $MesTags 3]
    set LesDefs          [join [lindex $MesTags 4] "\n"]
    set LesParents       [join [lindex $MesTags 5] " "]
    set LesConstituants  [join [lindex $MesTags 6] " "]
    set LesEnfants       [join [lindex $MesTags 7] " "]
    set LesContributions [join [lindex $MesTags 8] " "]
    set LesJumeaux       [join [lindex $MesTags 9] " "]
    set LesAccess        [join [lindex $MesTags 10] " ; "]
    set LesProjetsGscope [join [lindex $MesTags 11] " ; "] 
    set LesNoms          [join [lindex $MesTags 12] " ; "] 
    set LesBlastP        [join [lindex $MesTags 13] " ; "]
    set LesRequetes      [join [lindex $MesTags 14] " ; "]
    set LesClusters      [join [lindex $MesTags 15] " ; "]
    set nRequetes              [lindex $MesTags 16]

    set Texte "My Name is     $Type\nMy Nickname is $GO\n\nI am\n$LesDefs\n\nI am at level $Niveau"

    if {$LesJumeaux       != ""} {append Texte "\n\nMy twins are\n$LesJumeaux"}
    if {$LesParents       != ""} {append Texte "\n\nMy Parents are\n$LesParents"}
    if {$LesConstituants  != ""} {append Texte "\n\nI am constituted by\n$LesConstituants"}
    if {$LesEnfants       != ""} {append Texte "\n\nMy children are\n$LesEnfants"}
    if {$LesContributions != ""} {append Texte "\n\nI contribute to\n$LesContributions"}


    if {$nRequetes        != 0 } {append Texte "\n\nNumber of hits : $nRequetes"}
    if {$LesAccess        != ""} {append Texte "\n\nAccess\n$LesAccess"}
    if {$LesProjetsGscope != ""} {append Texte "\n\nGscope Project\n$LesProjetsGscope"}
    if {$LesNoms          != ""} {append Texte "\n\nGscope Box\n$LesNoms"}
    if {$LesBlastP        != ""} {append Texte "\n\nBlast\n$LesBlastP"}
    if {$LesClusters      != ""} {append Texte "\n\nClusters\n$LesClusters"}
    if {$LesRequetes      != ""} {append Texte "\n\nRequetes\n$LesRequetes"}

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 400 -text $Texte -background "lightyellow" -foreground "black"
    
    if {$Y < [expr $H/2]} { 
	set Y [expr $Y + 10];set NS "n"
    } else { 
	set Y [expr $Y - 10];set NS "s"
    }
    if {$X < [expr $L/2]} { 
	set X [expr $X + 10];set EW "w"
    } else { 
	set X [expr $X - 10];set EW "e"
    }
    place $M -x $X -y [expr $Y-40] -anchor "$NS$EW"
    return $M

}

proc DevoileLesPartsDeCamembert {K X Y Action} {

    set H [winfo screenheight .]
    set L [winfo screenwidth  .]

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set PetiteLegende             [lindex $MesTags 1]
    set GrandeLegende             [lindex $MesTags 2]

    if {$GrandeLegende != ""} {set Texte $GrandeLegende} else {set Texte $PetiteLegende}

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width [expr $L * 2 / 5] -text $Texte -background "lightyellow" -foreground "black"
    
    if {$Y < [expr $H/2]} { 
	set Y [expr $Y + 10];set NS "n"
    } else { 
	set Y [expr $Y - 10];set NS "s"
    }
    if {$X < [expr $L/2]} { 
	set X [expr $X + 10];set EW "w"
    } else { 
	set X [expr $X - 10];set EW "e"
    }
    place $M -x $X -y [expr $Y-40] -anchor "$NS$EW"
    return $M

}

proc DevoileLesRefSeq {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]
    set Def [lindex $MesTags 5]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin\n$Def"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileLesRegions {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Infos       [join [lindex $MesTags 1] "\n"]
    set Debut       [lindex $MesTags 2]
    set Fin         [lindex $MesTags 3]
    set Sens        [lindex $MesTags 4]

    set Texte "$Infos\nF:$Debut T:$Fin $Sens"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-40] -anchor $EW
    return $M

}

proc DevoileLesValeursHDACroises {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Texte [lindex $MesTags 1]
    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X>400} { set EW "e" } else { set EW "w" }
    if {$Y< 50} { set EW "n$EW" }
    place $M -x $X -y [expr $Y-20] -anchor $EW
    return $M

}

proc DevoileLesmiRNAs {K X Y Action} {

    global RepertoireDuGenome

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Chro [lindex $MesTags 0]
    set Deb [lindex $MesTags 1]
    set Fin [lindex $MesTags 2]
    set Nom [lindex $MesTags 3]

    set Texte "$Nom\n$Chro\nFrom $Deb\nTo $Fin"

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    if {$X<400} { set EW "w"    ; set dX 5 } else { set EW "e"    ; set dX -5 }
    if {$Y<300} { set EW "n$EW" ; set dY 5 } else { set EW "s$EW" ; set dY -5 }
    place $M -x [expr $X + $dX] -y [expr $Y + $dY] -anchor $EW
    return $M

}

proc DevoileSEACI {K X Y Action} {

    set H [winfo screenheight .]
    set L [winfo screenwidth  .]

    regsub ".canvas" $K ".message" M
    catch {destroy $M}

    if {$Action=="Leave"} { return "" }

    set Id [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Info        [lindex $MesTags 1]
    set Categorie   [lindex $MesTags 2]
    set Requete     [lindex $MesTags 3]
    set TextRequete [lindex $MesTags 4]
    set n           [lindex $MesTags 5]
    set nMax        [lindex $MesTags 6]
    set Pourcentage [lindex $MesTags 7]

    set Texte ""
    if {$Info == "Case"} {set Texte "Categorie : $Categorie"}
    if {$Texte != ""} {append Texte     "\n"}
    append Texte     "Requete   : $Requete"
    if {$Requete != $TextRequete} {append Texte "\n            $TextRequete"} 
    if {$Info == "Case"} {append Texte "\nOccurence : $n sur $nMax soit $Pourcentage\%"}

    message $M -borderwidth 3 -font {Courier 8} -relief raise -width 400 -text $Texte -background "lightyellow" -foreground "black"

    if {$Y < [expr $H/2]} { 
	set Y [expr $Y + 10];set NS "n"
    } else { 
 	set Y [expr $Y - 10];set NS "s"
    }
    if {$X < [expr $L/2]} { 
	set X [expr $X + 10];set EW "w"
    } else { 
	set X [expr $X - 10];set EW "e"
    }
    place $M -x $X -y [expr $Y-40] -anchor "$NS$EW"
    return $M

}

proc DiStaf {BorneSup} {


# Répartiteur des Stafs selon leur distance au TSS en vue d'un histogramme. Faire une boucle foreach externe pour enchainer les chromosomes.
# en utilisant ForeachDesDistances.txt


#Déclaration des fichiers
set FichierDesProximites [open "/tmp/Conservation/MappingTotal.txt" "r"]
set FichierLog "/tmp/Conservation/Comptage.log"

# Suppressions des éventuelles versions précédentes des fichiers
if { [file exists $FichierLog] } {
	file delete $FichierLog
}

#Compteurs :
set Compteur 0
set BorneInf [expr $BorneSup - 100]

while { [gets $FichierDesProximites LigneMapping]  >=0 } {
	
	ScanLaListe $LigneMapping ID ChromosomeH StartH EndH Acc DebSBS FinSBS OrientationSBS DistanceAuTSS ExonOuIntron CdsOuPas UtrOuPas OccupationExonOuIntron
	lappend Distances $DistanceAuTSS
}

foreach Distance $Distances {
	if {$Distance > $BorneInf && $Distance <= $BorneSup} {
		incr Compteur
	}
}
AppendAuFichier $FichierLog  "Il y a $Compteur SBS compris entre $BorneInf et $BorneSup"

}

proc DiagnosticQuery {Query LesNoms aBin ColDuMet TailleSeq} {

    upvar $aBin Bin
    set i 1
    set Protru 0
    set LesColProtru [list]
    set LesColRate [list]
    while {$i<$ColDuMet} {
	if {[set Bin($Query,$i)]} {
	    incr Protru
	    lappend LesColProtru $i
	}
	incr i
    }
    set Rate 0
    set PourcentageProtru 0
    if {!$Protru} {
	while {$i<=$TailleSeq} { 
	    if {[set Bin($Query,$i)]} break
	    incr Rate
	    lappend LesColRate $i
	    incr i
	}
	if {$Rate} {
	    set TotalRes [expr [llength $LesColRate]*[llength $LesNoms]]
	    set TotalGap $TotalRes
	    foreach Col $LesColRate {
		foreach Nom $LesNoms {
		    set TotalGap [expr $TotalGap-[set Bin($Nom,$Col)]]
		}
	    }
	    set PourcentageGap [expr ($TotalGap*100) / $TotalRes]
	}
    } else {
	set TotalRes [expr $Protru*[llength $LesNoms]]
	set TotalProtru 0
	foreach Col $LesColProtru {
	    foreach Nom $LesNoms {
		set TotalProtru [expr $TotalProtru+[set Bin($Nom,$Col)]]
	    }
	}
	set PourcentageProtru [expr ($TotalProtru*100) / $TotalRes]
    }
    
    if {!$Rate} {
	return "$Query [format "%3s" +$Protru] [format "%2s" $PourcentageProtru] %"
    } else {
	return "$Query [format "%3s" -$Rate] [format "%2s" $PourcentageGap] %"
    }
    

}

proc DiagnostiqueLesPhylosFolles {} {

    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }

    foreach Boite $ListeDeBoites {
	set Nom    [Box $Boite nom]    

	if { ! [PhyloFolle $Nom] } { continue }

	set Folie [DiagnostiquePhyloFolle $Nom]
	if { $Folie == {} } { continue }
	puts "$Nom [join $Folie " "]"
    }

}

proc DiagnostiquePhyloFolle {Nom} {

    global RepertoireDuGenome
    global PhylosFolles

    set ListeOrgas [Phylon $Nom]
    if {[llength $ListeOrgas] == 0} { return {} }
    foreach Orga $ListeOrgas {
	if {[PyroLike $Orga]} { continue }
	if {[ArkaeaLike $Orga]} { lappend Folie [string toupper $Orga] ; break }
	lappend Folie $Orga
    }
    return $Folie

}

proc Dialog {HostPort args} {

    #rR on va discuter en client avec un serveur Gscope ou Ordali
    DecortiqueIpCafe $HostPort Host Port
    if {[catch {set Sockette [socket $Host $Port]} Message]} {
	return $Message
    }
    set  Question [join $args " "]
    if {$Question=="" || $Question=="GetSocket"} { return $Sockette }  

    append Question "\nFinDeMessage"
    puts  $Sockette $Question
    flush $Sockette
    set LaReponse {}
    while {[gets $Sockette R]>=0} {
	lappend LaReponse $R
    }
    set Reponse [join $LaReponse "\n"]
    return $Reponse

}

proc DialogPort {{Action ""}} {

    #rR Crée un ou plusieurs serveur de socket
    #rR si Action est vide ou GetFirst (on en crée un si nécessaire et) on le rend
    #rR si Action est New on en crée un nouveau
    #rR si Action est un numéro de port on le crée (voir ci-dessous pour les détail s'il existe déjà)

    global DialogPort

    if {$Action==""} { set Action "GetFirst" }

    if {$Action=="GetFirst"} {
	if {[info exists DialogPort(ListOf,Port)]} { return [lindex $DialogPort(ListOf,Port) 0] }
    }
    if {[regexp "GetAll" $Action]} {
	if {[info exists DialogPort(ListOf,Port)]} {
	    return $DialogPort(ListOf,Port)
	} else {
	    if { ! [regexp "Create" $Action] } { return "" }
	    DialogPort
	    return [DialogPort "GetAll"]
	}
    }
    #rR Can be CreateAndDisplayAll
    if {[regexp "DisplayAll" $Action]} {
	if {[info exists DialogPort(ListOf,Port)]} {
	    set ExistingPorts $DialogPort(ListOf,Port)
	    FaireLire "Ports available on [Hostname]\n$ExistingPorts"
	    set BoutonDialog "[Vitrine GetVitrine].dialog"
	    if {[regexp "^\." $BoutonDialog]} {
		$BoutonDialog configure -text "Dialog sur [Hostname] $ExistingPorts /+"
	    }
	    return $DialogPort(ListOf,Port)
	} else {
	    if { ! [regexp "Create" $Action] && ! [OuiOuNon "There is no port available on [Hostname].\nDo I create it ?"]} { return "" }
	    DialogPort
	    return [DialogPort "DisplayAll"]
	}
    }
    set NbTentatives 2
    set StartingPort 21100
    set Port $StartingPort
    if {$Action=="New"} {
	set  ExistingPorts [DialogPort "GetAll"]
	while {[lsearch $Port $ExistingPorts]>=0} { incr Port }
    }
    set ForcePort 0
    if {[regexp {^[0-9]+$} $Action]} {
	set ForcePort 1
	set Port $Action
	set NbTentatives 1
    }
    while {1} {
	if {$NbTentatives < 1 } { return "Error : Trop de tentatives infructueuses de création de socket serveur port $Port" }   
	incr NbTentatives
	if {[catch {set Socket [socket -server CreeOreilleGeneraliste $Port]} Message]} {
	    if {[regexp -nocase "Already in use" $Message]} {
		if {$ForcePort} { return $Message } ;#rR le port existe déjà mais on rend quand même le message d'erreur
		incr Port
		continue
	    }
	}
	lappend DialogPort(ListOf,Port) $Port
	return $Port
    }    

}

proc DiffBlaAli {Nom} {

    global RepertoireDuGenome
    global DiffBlaAli

    if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
    if {[info exists DiffBlaAli]} { return "" }

    set DiffBlaAli("EstCharge") 1

    set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"
    if { ! [file exists $FichierDiffBlaAli]} { return "" }
	
    foreach DBA [LesLignesDuFichier $FichierDiffBlaAli] {
	scan $DBA "%s %s" NomLu Rapport 
	if {[regexp "No(More|Bla|Ali)" $Rapport]} {
	    set DiffBlaAli($NomLu) $Rapport
	    continue
	}

	scan $DBA "%s %s %s %s %s %s %s %s" NomLu BestBla BestAli DisBla DisAli Ecart Rapport Fragments

	set DiffBlaAli($NomLu) "$Rapport $BestBla $BestAli"
    }
    if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
    return ""

}

proc DiffDesXml {} {

    set Lui [ContenuDuFichier "[RepXbgs]/SesTargets.xml"]
    set Moi [ContenuDuFichier "[RepXbgs]/SpineTargetsP10.xml"]
    while 1 {
	set SaTarget [ValeurDeLaBalise "target" Lui]
	set MaTarget [ValeurDeLaBalise "target" Moi]
	regsub -all " " $SaTarget "" SaTarget
	regsub -all " " $MaTarget "" MaTarget
	if {$SaTarget==""} { break }
	foreach SaLigne [split $SaTarget "\n"] MaLigne [split $MaTarget "\n"] {
	    set SaLigne [string trim $SaLigne] 
	    set MaLigne [string trim $MaLigne]
	    if {$SaLigne==$MaLigne} { continue }
	    if { ! [OuiOuNon "Show [string range $MaTarget 0 27] ?\n$SaLigne\n$MaLigne"]} { break }
	    AfficheVariable $SaTarget
	    AfficheVariable $MaTarget "AvecRetour"
	    
	    break
	}
    }

}

proc DiffEntre2RefPfam {} {

    set i 0
    foreach Box [ListeDesPABs] {
	set RefPfamOld [ExtraitInfo $Box "RefPfamOld"]
	set RefPfam    [ExtraitInfo $Box "RefPfam"]
	if {$RefPfamOld!=$RefPfam} {incr i; Espionne "$Box"}
    }
    Espionne $i

}

proc DiffEntreLappendEtLconcat {} {

    set A "Q65"
    set B "Y58 X25"

    puts "lappend"
    lappend liste $A
   # foreach x $liste {puts "++$x"}
    lappend liste $B    
    foreach x $liste {puts "++$x"}
    Espionne "final"
    #lappend liste "AT" 
    #lset liste 1 expr end+1 "AT" 
    Espionne "[lrange $liste 1 2]"
    set nvlistinsert [linsert [lrange $liste 1 2] 2 "AT"]
    foreach x $nvlistinsert {puts "**$x"}
    foreach x $liste {puts "--$x"}

    set nvliste [linsert {one two three four} 0 zero]
    Espionne "$nvliste"

    puts "lconcat"
    LConcat liste2 $A
   # foreach y $liste2 {puts "--$y"}
    LConcat liste2 $B
   # foreach y $liste2 {puts "$y"}

}

proc DiffEntreListEtConcat {} {

    set list1 {AB10 AC10 AD10}
    set list2 {}
    set list3 {NM1 NM2 NM3}
    set Tout [list $list1 $list2 $list3]
    #set Tout [concat $list1 $list2 $list3]
    puts $Tout
    foreach x $Tout { puts "++$x" }

}

proc DiffProt {FileMacsims} {

    #pour chaque LA, rends le nb AA en plus ou en moins en Nter et en Cter par rapport a la ref  
    set Commande "/home/julie/MACSIM_jean/aln_nter $FileMacsims"
    set Result [eval exec $Commande]
    return $Result

}

proc DiffTaillesDesTroisOrthologuesDuMSF {NomOuFichier Bla DbC {Que ""}} {

    global RepertoireDuGenome

    set Nom [file tail $NomOuFichier]
    if {$Que==""} { set Que $Nom }

    if {[regexp "/" $NomOuFichier]} {
	set FichierMSF $NomOuFichier
    } elseif {[EstUnPAB $Nom]} {
	set FichierMSF "$RepertoireDuGenome/msf/$Nom"
    } else {
	set FichierMSF $NomOuFichier
    }	
    if { ! [file exists $FichierMSF]} { return 0 }

    DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences
    if { ! [info exists Sequences($Que)]} {
	set Que [string toupper $Que]
	if { ! [info exists Sequences($Que)]} {
	    return -1
	}
    }
    if { ! [info exists Sequences($Bla)]} {
	set Bla [string toupper $Bla]
	if { ! [info exists Sequences($Bla)]} {
	    return -2
	}
    }
    if { ! [info exists Sequences($DbC)]} {
	set DbC [string toupper $DbC]
	if { ! [info exists Sequences($DbC)]} {
	    return -3
	}
    }

    set SeqQue [set Sequences($Que)]
    set SeqBla [set Sequences($Bla)]
    set SeqDbC [set Sequences($DbC)]

    set lQ 0
    set lB 0
    set lD 0
    set lQB 0
    set lBD 0
    set lDQ 0
    set lQBD 0
    foreach Q [split $SeqQue ""] B [split $SeqBla ""] D [split $SeqDbC ""] {
	if {$Q!="."} { incr lQ }
	if {$B!="."} { incr lB }
	if {$D!="."} { incr lD }
	if {$Q!="." && $B!="."} { incr lQB }
	if {$B!="." && $D!="."} { incr lBD }
	if {$D!="." && $Q!="."} { incr lDQ }
	if {$Q!="." && $B!="." && $D!=0} { incr lQBD }
    }
    set lMax [Maxi [Maxi $lQ $lB] $lD]
    set lMin [Mini [Mini $lQ $lB] $lD]
    set pMinMax [expr (100*$lMin)/$lMax]
    set pQMax [expr (100*$lQ)/$lMax]
    set pBMax [expr (100*$lB)/$lMax]
    set pDMax [expr (100*$lD)/$lMax]
    return "$lQ $lB $lD $lQB $lBD $lDQ $lMax $lMin $pQMax $pBMax $pDMax $pMinMax"

}

proc DiffTaillesDesTroisOrthologuesDuMSFPourTous {} {

    global RepertoireDuGenome

    set LesDiffTailles {}
    foreach Nom [ListeDesPABs] {
	set Rapport [DiffBlaAli $Nom]
	if {$Rapport==""} { continue }
	if {3!=[scan $Rapport "%s %s %s" Etat Bla DbC]} { continue }
	set DiffTailles [DiffTaillesDesTroisOrthologuesDuMSF $Nom $Bla $DbC]
	Espionne "$DiffTailles $Etat"
	lappend LesDiffTailles $DiffTailles
    }
    return $LesDiffTailles

}

proc DifferentColor {{GetWhat ""}} {

    global DifferentColor

    if {$GetWhat==""} { set GetWhat "RGB" }

    set GetWhat [string toupper $GetWhat]

    if {$GetWhat=="RESET"} {
	if {[info exists DifferentColor]} { unset DifferentColor }
	return ""
    }
    #rR on utilise un angle pour Hue 
    if { ! [info exists DifferentColor(Ang)]} { set DifferentColor(Ang) -137.5 }
    if { ! [info exists DifferentColor(Sat)]} { set DifferentColor(Sat) 1.0 }
    if { ! [info exists DifferentColor(Bri)]} { set DifferentColor(Bri) 1.0 }
    set Angle $DifferentColor(Ang)
    set Angle [expr round($Angle+137.5)%360]
    set Hue   [expr  $Angle/360.]
    set DifferentColor(Ang) $Angle
    set DifferentColor(Hue) $Hue

    set Sat $DifferentColor(Sat)
    set Sat [expr $Sat*0.98]
    set DifferentColor(Sat) $Sat
    
    return [ColorFromHSB $DifferentColor(Hue) $DifferentColor(Sat) $DifferentColor(Bri)]

}

proc DifferentielBlastAlignement {Nom} {

    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set AvecShow 0

    set FichierAli "$RepertoireDuGenome/disphy/$Nom"
    if { ! [file exists $FichierAli]} { return "$Nom NoAli" }
    set FichierBla "$RepertoireDuGenome/apns/$Nom"
    if { ! [file exists $FichierBla]} { set FichierBla "$RepertoireDuGenome/blastp/$Nom" }
    if { ! [file exists $FichierAli]} { return "$Nom NoBla" }
    set DescriAli [AfficheLesDescriptifs $FichierAli "MemeOrdre" "LaListe"]
    set LesBonsAli {}
    foreach Ligne $DescriAli {
	if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
	if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
	lappend LesBonsAli $Ligne
    }
    if {$LesBonsAli=={}} { return "$Nom NoMoreAli" }
    set DescriBla [AfficheLesDescriptifs $FichierBla "MemeOrdre" "LaListe"]
    set LesBonsBla {}
    foreach Ligne $DescriBla {
	if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
	if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
	lappend LesBonsBla $Ligne
    }
    if {$LesBonsBla=={}} { return "$Nom NoMoreBla" }

    set Rapport "NotYetValued"

    scan [lindex $LesBonsBla 0] "%s" BestBla
    scan [lindex $LesBonsAli 0] "%s" BestAli
    if {[string equal -nocase $BestBla $BestAli]} {
	set Rapport "Same"
	set Ecart   000
	set DisBla  000
	set DisAli  000
    }

    if {$Rapport!="Same"} {
	FromDisphy $Nom
	set DisBla [FromDisphy $BestBla]
	set DisAli [FromDisphy $BestAli]
	if { ! [regexp {^[0-9]+$} $DisBla] || ! [regexp {^[0-9]+$} $DisAli]} {
	    set DisBla 0
	    set DisAli 0
	    set Ecart  0
	    set Rapport "Problem"
	} else {
	    scan [RapportDuDifferentiel $DisBla $DisAli] "%s %d" Rapport Ecart
	}
    }
    set Fragments ".."
    if {$Rapport!="Same"} {
	set DEBla [ChampDuDescriptif [LeDescriptif $BestBla $Nom] DE]
	set DEAli [ChampDuDescriptif [LeDescriptif $BestAli $Nom] DE]
	set FraBla [regexp -nocase "FRAGMENT" $DEBla]
	set FraAli [regexp -nocase "FRAGMENT" $DEAli]
	if {$FraBla} { set FraBla "F" } else { set FraBla "-" }
	if {$FraAli} { set FraAli "F" } else { set FraAli "-" }
	set Fragments "$FraBla$FraAli"
    }
    set Beau [format "%s %-9s %-9s %3d %3d %3d %-10s %s"  $Nom $BestBla $BestAli $DisBla $DisAli $Ecart $Rapport $Fragments]

    return $Beau


}

proc DifferentielBlastAlignementPourTous {} {

    global RepertoireDuGenome

    set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"

    while {[file exists $FichierDiffBlaAli]} {
	if {[OuiOuNon "The file differential blastp alignment already exists. \n Do I replace it ?"]} {
	    File delete $FichierDiffBlaAli
	    continue
	}
	if {[OuiOuNon "Do I append to it ?"]} {
	    foreach Ligne [LesLignesDuFichier $FichierDiffBlaAli] {
		scan $Ligne "%s" Nom
		set BlaAli($Nom) $Ligne
	    }
	    break
	}
    }

    foreach Nom [ListeDesPABs] {
	if {[info exists BlaAli($Nom)]} { continue }
	set Differentiel [DifferentielBlastAlignement $Nom]
	AppendAuFichier $FichierDiffBlaAli "$Differentiel"
	if { [regexp " Same " $Differentiel]} { continue }
	Espionne "$Differentiel"
    }
    
    return $FichierDiffBlaAli

}

proc DimensionsArbre {AId n xCsg yCsg} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    set OffsetX [set Abr($AId,OffsetX)]
    set OffsetY [expr {[set Abr($AId,OffsetY)]/2+1}]
    set Increment [set Abr($AId,Increment)]

    set l [$t get $n length]
    if {$l != -1} {
	set l [expr {int($l*$Increment+$OffsetX)}]
    }

    set xP $xCsg
    set yP [expr {$yCsg+$OffsetY}]

    set xE [expr {$xCsg+$OffsetX+$l}]
    set yE $yCsg

    set LesAmarres {}
    set Feuille 1
    if {[$t numchildren $n] > 1} {
	set Le [$t children $n]
	if {$n ne "root" && [$t get $n ordre]} {
	    set Le [lreverse $Le]
	}

	foreach f $Le {
	    set Feuille 0
	    set OldyE $yE
	    set yE [lindex [DimensionsArbre $AId $f $xE $yE] 1]

	    lappend LesAmarres [expr {int(($OldyE+$yE)/2)}]
	}
	set yP [expr {int(($yE+$yCsg)/2)}]
    }

    if {$Feuille} {
	set xtxt [font measure TreeFont$AId [NomAffiche $AId $n]]
	set xtst [expr {$xE+$xtxt}]
	set ytst [expr {$yCsg+2*$OffsetY}]
    } else {
	set xtst $xE
	set ytst $yE
    }
    if {$xtst > [set Abr($AId,Xmax)]} {set Abr($AId,Xmax) $xtst}
    if {$ytst > [set Abr($AId,Ymax)]} {set Abr($AId,Ymax) $ytst}

    if {$Feuille} {
	return [list $xE [expr {$yCsg+2*$OffsetY}]]
	#	return [list $xE $yCsg]
    } elseif {! $Feuille && $n ne "root"} {
	return [list $xE $yE]
    }

}

proc DimensionsArbreCirculaire {AId n xCsg yCsg} {

    global Abr
    global deltaA

    set t [set Abr(Arbre,$AId)]
    #    set OffsetX [set Abr($AId,OffsetX)]
    #    set OffsetY [set Abr($AId,OffsetY)]
    set OffsetX 10.
    set OffsetY 10.
    set Increment [set Abr($AId,Increment)]

    set l 0
    if {[$t keyexists $n length]} {
	set l [$t get $n length]
	if {$l != -1} {set l [expr {int($l*$Increment)}]}
    }

    set xP $xCsg
    set yP $yCsg
    set xE [expr {$xCsg+$OffsetX+$l}]
    set yE [expr {$yCsg+$OffsetY}]

    set OlddeltaA $deltaA
    set deltaA [expr {$deltaA+[set Abr($AId,deltaA)]}]

    set LesAmarres {}
    set Feuille 1
    if {[$t numchildren $n] > 1} {
	set Le [$t children $n]
	if {$n ne "root" && [$t get $n ordre]} {set Le [lreverse $Le]}

	#	set nLe [llength $Le]
	set nLe 0
	foreach e $Le {
	    incr nLe [$t size $e]
	}
	set MondeltaA [expr {($nLe-1)*[set Abr($AId,deltaA)]/2.+$deltaA}]
	set Lcor [TourneBoite $xP $yP $xE $yE $MondeltaA]
	lassign $Lcor xE yE
	set Feuille 0
	foreach f $Le {
	    set Lcor [DimensionsArbreCirculaire $AId $f $xE $yE]
	    lassign $Lcor nxE nyE
	    lappend LesAmarres [list $nxE $nyE]
	}
	lappend LesAmarres [list $xE $yE]
    } else {
	set Lcor [TourneBoite $xP $yP $xE $yE $deltaA]
	lassign $Lcor xE yE
	set LesAmarres [list $Lcor]
    }

    foreach e $LesAmarres {
	lassign $e x y
	set ytst $y
	if {$Feuille} {
	    set xtxt [font measure TreeFont$AId [NomAffiche $AId $n]]
	    set xtst [expr {$x+$xtxt}]
	} else {
	    set xtst $x
	}

	set Abr($AId,Xmax) [Maxi [set Abr($AId,Xmax)] $xtst]
	set Abr($AId,Ymax) [Maxi [set Abr($AId,Ymax)] $ytst]
	set Abr($AId,Xmin) [Mini [set Abr($AId,Xmin)] $xtst]
	set Abr($AId,Ymin) [Mini [set Abr($AId,Ymin)] $ytst]
    }

    return [list $xE $yE]

}

proc DimensionsPapier {} {

    global PrmPrt

    switch [set PrmPrt(Papier)] {
	"A4" {
	    set x 21.
	    set y 29.7
	}
	"A3" {
	    set x 29.7
	    set y 42.
	}
	"US" {
	    set x 21.6
	    set y 27.9
	}
	"unlimited" {
	    set x -1
	    set y -1
	}
    }

    if {[set PrmPrt(Orientation)] == "landscape"} {
	set tmp $y
	set y $x
	set x $tmp
    }

    # enleve 1cm de marges
    set x [expr {$x - 2.}]
    set y [expr {$y - 2.}]

    # on est en 72 points par pouces, soit par 2.54 cm
    set xP [expr {int(double($x)/2.54 * 72)}]
    set yP [expr {int(double($y)/2.54 * 72)}]

    return [list $xP $yP]

}

proc DirAbsent {Dir} {

    if {[DirExists $Dir]} { return 0 } else { return 1 }

}

proc DirExists {Dir} {

    return [file exists $Dir]

}

proc DirichletMixtureData {} {

    set dataBrutes "
  1.90787e-01, 1.04790e+00, 8.51607e-01, 1.42468e+00, 1.65837e+00, 1.27624e-01, 7.17342e-01,
  1.32869e+00, 1.58841e+00, 4.76291e-01, 1.50793e-01, 3.46223e-01, 1.07498e+00, 1.22990e-01,
  2.43214e-01, 8.32888e-01, 1.61600e+00, 9.03840e-01, 1.81517e-01, 3.17127e-01, 2.71696e-01,
  2.31348e-01, 1.49669e+00, 9.26283e-01, 5.36734e-01, 5.35590e-01, 2.76149e-01, 6.50695e-01,
  8.51071e-01, 7.44779e-01, 5.23170e-01, 1.51316e+00, 2.41708e+00, 7.80437e-01, 6.87694e-01,
  1.07724e+00, 5.60151e-01, 8.95912e-01, 1.11477e+00, 3.86675e-01, 9.69174e-01, 1.79257e+00,
  6.36828e-02, 4.35462e-01, 6.92698e-02, 3.80381e-02, 2.76147e-02, 1.24846e-01, 7.62577e-02,
  3.95313e-02, 7.14402e-02, 4.93714e-02, 1.45257e+00, 4.17992e+00, 6.13128e-02, 6.70464e-01,
  7.67295e-01, 5.46339e-02, 7.08568e-02, 1.47081e-01, 9.45354e-02, 1.40703e-01, 9.54595e-01,
  1.20260e-01, 1.44133e+00, 1.94333e+00, 5.56915e-01, 1.04866e+00, 4.41589e-02, 1.38008e+00,
  2.65171e+00, 2.69416e-01, 3.37705e-01, 3.63554e-01, 7.12004e-01, 2.55697e+00, 2.02383e-01,
  9.94796e-02, 3.63374e-01, 9.12045e-01, 7.97208e-01, 6.82441e-06, 1.78230e-01, 5.47792e-01,
  6.28833e-02, 1.12917e+00, 7.32940e-02, 6.75998e-02, 4.22075e-02, 3.17997e-01, 6.16088e-02,
  7.12822e-02, 1.66381e-01, 4.35275e-02, 2.03149e+00, 1.37645e+00, 6.12778e-02, 2.74245e-01,
  3.16939e-01, 1.69192e-01, 1.99073e-01, 5.83574e-01, 4.79987e-02, 1.21036e-01, 3.12429e+00,
2.30917e-02, 3.38602e-01, 2.63820e+00, 2.91699e-01, 6.84881e-06, 6.60967e-02, 4.55701e-01,
4.47113e-02, 2.00108e-01, 2.77657e-01, 2.45482e-01, 4.98113e-01, 1.79164e+00, 1.41118e-01,
1.02420e-01, 9.91099e-02, 2.40487e-01, 2.97528e-01, 6.82441e-06, 1.99988e-01, 2.66838e-01,
2.54398e-02, 6.45122e-01, 1.51296e-01, 2.80755e-01, 2.44861e+00, 1.86722e-02, 7.12253e-01,
3.56545e+00, 2.28329e-01, 1.33064e-01, 8.05822e-02, 1.75863e-01, 4.72355e-01, 6.61411e-02,
6.27438e-02, 2.35140e-01, 4.16451e-01, 2.90239e-01, 6.82442e-06, 6.37813e-02, 1.70260e-01,
1.81905e-02, 2.69580e-03, 5.18381e-03, 3.64808e-03, 8.52051e-03, 6.78894e-06, 1.18796e-03,
4.83124e-03, 6.78119e-06, 4.04942e-06, 7.73177e-06, 3.62381e-03, 3.43071e-03, 9.05901e-04,
2.50302e-03, 6.84602e-06, 2.76818e-03, 2.44236e-03, 6.64933e-06, 2.95083e-03, 1.52711e-03,
4.36341e-02, 2.67702e+00, 4.66059e-02, 5.36256e-02, 1.61496e-02, 3.07979e-01, 5.53320e-02,
5.59059e-02, 7.64071e-01, 4.53289e-02, 1.77046e-01, 3.51216e-01, 4.21634e-02, 1.32101e-01,
1.20610e-01, 1.00687e-01, 7.49123e-01, 3.76924e-01, 2.03993e-02, 9.03913e-02, 5.32540e-01,
4.67005e-02, 3.27933e-01, 1.04451e-01, 2.39883e-01, 1.73800e-01, 3.48857e-02, 6.71135e-02,
1.01547e-01, 5.00419e+00, 5.61308e-02, 4.20194e-02, 6.82140e-02, 1.29979e-01, 3.12449e-02,
4.78230e-02, 9.78755e-02, 2.77191e-01, 9.45045e-02, 1.73248e-02, 4.47752e-02, 5.45999e-02,
2.74659e-02, 4.04781e-01, 1.34132e-01, 4.61109e-01, 2.07521e-01, 1.48804e-01, 1.24903e-01,
1.29000e-01, 2.24895e-01, 8.83638e-02, 1.48434e-01, 1.42950e-01, 1.33117e-01, 8.00954e-02,
6.14824e-02, 1.75370e-01, 1.76131e+00, 2.38531e+00, 1.24182e-02, 7.70201e-02, 3.54549e-01,
2.35271e-02, 2.09806e-06, 2.09611e-06, 2.09349e-06, 2.09395e-06, 1.51965e-02, 2.09525e-06,
2.09506e-06, 3.08171e-06, 2.09545e-06, 3.55392e+00, 1.79915e+00, 6.19279e-02, 2.32271e-01,
4.49120e-01, 2.09624e-06, 6.33349e-06, 8.48321e-02, 2.09599e-06, 1.77228e-01, 3.29717e+00,
1.90188e-02, 1.03006e-01, 7.26350e-02, 9.36077e-01, 2.60532e+00, 5.68496e-02, 6.45488e-02,
3.18932e-01, 2.44067e-01, 1.29950e-01, 4.57387e-02, 6.33750e-02, 1.04891e-01, 1.95064e-02,
2.28703e-02, 7.45474e-02, 4.29128e-01, 2.13524e-01, 8.70906e-03, 3.38116e-02, 5.98965e-02,
3.90740e-02, 5.45581e-01, 2.32418e-01, 1.46330e-01, 2.70351e-01, 4.74132e-02, 1.53661e-01,
3.23849e-01, 3.12641e-01, 7.51482e-02, 1.89273e-01, 3.27661e-01, 3.33386e-01, 5.14866e-02,
1.10750e-01, 4.65804e+00, 4.53472e-01, 3.11523e-01, 6.82219e-06, 8.56644e-02, 3.20962e-01,
3.15551e-02, 1.72477e-01, 1.70036e-01, 1.86367e-01, 1.25363e-01, 9.64611e-02, 1.30303e-01,
1.39411e-01, 1.89668e-01, 4.26400e-01, 6.97407e-02, 2.82296e-01, 8.95530e-02, 7.67090e-02,
9.29261e-01, 9.85695e-02, 1.87798e-01, 1.36169e-01, 3.96736e-01, 1.31186e+00, 1.20003e-01,
1.94012e-02, 1.50485e-01, 2.09957e-06, 2.09916e-06, 3.43319e-06, 6.54973e-02, 2.13697e-06,
2.09875e-06, 2.09628e-06, 2.09541e-06, 4.08937e-01, 8.01559e-01, 2.08249e-06, 1.64297e-01,
1.90252e+00, 3.77111e-02, 3.64121e-02, 5.88268e-02, 2.86392e-01, 1.10400e+00, 3.93563e-01,
1.92930e-03, 6.82604e-06, 1.80057e-01, 7.20143e-01, 7.00984e-06, 1.67036e-01, 4.53687e-01,
1.16956e-01, 1.78211e-01, 1.05145e+00, 7.58164e-06, 3.56887e-01, 1.08975e-01, 2.45596e-01,
6.82872e-06, 6.82541e-06, 6.82665e-06, 6.86221e-06, 6.82575e-06, 6.82650e-06, 8.09853e-06,
4.17487e-03, 3.18914e-02, 1.51802e-02, 2.51110e-02, 2.09471e-06, 6.01455e+00, 1.27434e-02,
2.09361e-06, 2.00737e-02, 2.09311e-06, 1.87376e-02, 3.35639e-02, 1.56161e-02, 1.21492e-02,
1.63082e-02, 2.18568e-02, 7.47796e-02, 2.70651e-02, 2.09217e-06, 2.09460e-06, 5.91846e-02,
3.79203e-03, 4.77257e-02, 6.57508e-02, 1.75686e-02, 6.82346e-06, 6.82267e-06, 6.82310e-06,
6.82411e-06, 4.06000e-02, 1.74947e-02, 7.10513e-02, 1.89537e-01, 2.77309e-02, 3.79048e-02,
2.93947e-01, 6.82394e-06, 5.29119e-02, 4.54005e-02, 3.17830e+00, 1.97322e-01, 6.25358e-02,
4.04424e-03, 2.09520e-06, 2.69173e-02, 6.98870e-02, 1.51420e-02, 2.09231e-06, 4.29689e-02,
2.09374e-06, 2.09214e-06, 9.35600e-01, 1.02272e-02, 2.09374e-06, 2.08998e-06, 2.08905e-06,
    5.66085e-03, 1.44082e-02, 3.08847e-02, 1.63193e-02, 2.08622e-06, 4.01371e-02, 1.45572e-02"

    set data [string map [list "\n" " " "," " "] $dataBrutes]
    regsub -all { +} [string trim $data] " " data
    set data [split $data " "]

    return $data

}

proc Dismiss {w} {

    global PagePropre
    if {[info exists PagePropre($w)]} { unset PagePropre($w) }
    if {[PourWscope]} { return "'" }
    catch {after 10 destroy $w}
    return $w    

}

proc DismissDefauts {w} {

    global TmpDef

    unset -nocomplain TmpDef
    destroy [winfo toplevel $w]

    return

}

proc DismissInfoSeq {w} {

    global TEdit 

    unset -nocomplain TEdit

    destroy $w

    return

}

proc DismissSuper {} {


    FinSuper
    DetruitBoutonsOrdali

    return

}

proc DismissToutCePAB {Nom {Force ""}} {

    global LesFenetresDePAB
    global PagePropre

    if {$Nom=="" || ! [info exists LesFenetresDePAB($Nom)]} { return }

    if {$Force == "Force"} { set Force 1 } else { set Force 0 }
    if {$Force || [OuiOuNon "Je DISMISS tout $Nom ? "]} {
	foreach Fenetre [set LesFenetresDePAB($Nom)] {
	    if { ! [winfo exists $Fenetre]} { continue }
	    if {[info exists PagePropre($Fenetre)]} { unset PagePropre($Fenetre) }
	    after 10 destroy $Fenetre
	}
	unset LesFenetresDePAB($Nom)
    }

}

proc DismissToutesLesFenetres {} {

    global LesFenetresDePAB
    
    set Force ""
    if {[OuiOuNon "DO I destroy all windows without confirmation ?"]} { set Force "Force" }
    foreach Nom [array names LesFenetresDePAB] {
	DismissToutCePAB $Nom $Force
    }     


}

proc DispatchCluspack {} {

    set Rep "."
    foreach {I O} [lsort [glob "$Rep/*"]] {
	set Qi [file tail $I]
	set Qo [file tail $O]
	regsub "\.in" $I "" R
	file mkdir $R
	file rename $I $R/$Qi
	file rename $O $R/$Qo
    }

}

proc DispersionDeColonne {p} {

    global ListeDesAcidesAmines Rosace

    if {! [info exists Rosace]} {InitialiseRosace}

    set ListeAA [lrange $ListeDesAcidesAmines 0 end-1]
    set ntot [string length $p]
    
    # compute mean vec of the column
    set Vp [list 0.0 0.0]
    set nvec [list]
    foreach a $ListeAA {
	set n [expr {$ntot - [string length [string map [list $a ""] $p]]}]
	if {$n} {
	    set Vp [V_VV $Vp + [V_SV $n * [set Rosace($a)]]]
	}
	lappend nvec $n
    }
    set nVp [S_nV $Vp]
    
    # now compute angle dispersion 
    set ma 0.0
    set m2a 0.0
    set na 0
    foreach a $ListeAA n $nvec {
	if {$n} {
	    # AngleEntre renvoie angle positif
	    set ang [AngleEntre $Vp [set Rosace($a)]]
	    if {$ang > [Pi]} {
		set ang [expr {[2Pi] - $ang}]
	    }
	    set ma  [expr {$ma + $n*$ang}]
	    set m2a [expr {$m2a + $n*$n*$ang*$ang}]
	    incr na $n
	}
    }
    set ma [expr {$ma/$na}]
    set ect [expr {sqrt($m2a/$na-$ma*$ma)}]
    if {$ma < 0.000001} {set ma 0.0}
    
    return [list $Vp $ma $ect]

}

proc DispersionDesPiliers {ListePil} {

    global ListeDesAcidesAmines Rosace

    if {! [info exists Rosace]} {InitialiseRosace}

    set ListeAA [lrange $ListeDesAcidesAmines 0 end-1]
    set nseq [string length [lindex $ListePil 0]]
    set ThrGap [DefineGapThreshold $nseq]

    set Lres [list]
    foreach pori $ListePil {
	set p [string map {X "" Z "" "." "" " " ""} $pori]

	if {[set ntot [string length $p]] < $ThrGap} {
	    lappend Lres -999.0

	    continue
	}

	lappend Lres [DispersionDeColonne $p]
    }

    return $Lres

}

proc DisplayBilanHDACroises {K Index} {

    global IndexDisplayBilanHDACroises
    
    if { ! [info exists IndexDisplayBilanHDACroises($K)]} { set IndexDisplayBilanHDACroises($K) 2 }

    if {$Index == $IndexDisplayBilanHDACroises($K) } {
	set Efface 1
	set IndexDisplayBilanHDACroises($K) 9999
    } else {
	set Efface 0
	set IndexDisplayBilanHDACroises($K) $Index
    }

    foreach Id [$K find withtag "TexteRang"] {
	if {$Efface} {
	    set Texte " "
	} else {
	    set MesTags [$K gettags $Id]
	    set TexteDevoile [lindex $MesTags 1]
	    set A "coucou"
	    set P "voila"
	    scan $TexteDevoile "%s %s %s %s %s %s" G E F N P A
	    if {$P=="voila"} {
		set A $N
		set P $F
		set N $E
		set F $G
		set E "unknown"
		set G "Unknown"
	    }
	    if {$A=="coucou"} {
		set A $P
		set P $N
		set N $F
		set F $E
		set E "unknown"
		set G "Unknown"
	    }
	    
	    set Texte [lindex [list bidon $N $P $A] $Index]
	}
	$K itemconfigure $Id -text $Texte
    }

}

proc DisplayCallback {toglwin} {

    # Clear Screen And Depth Buffer
    glClear [expr $::GL_COLOR_BUFFER_BIT | $::GL_DEPTH_BUFFER_BIT] 

    # Viewport command is not really needed, but has been inserted for
    # Mac OSX. Presentation framework (Tk) does not send a reshape event,
    # when switching from one demo to another.
    glViewport 0 0 [$toglwin width] [$toglwin height]

    glMatrixMode GL_MODELVIEW
    glLoadIdentity                      

    if {0} {
	gluLookAt  $::pgl(eyeX) $::pgl(eyeY) $::pgl(eyeZ)  $::pgl(xCen) $::pgl(yCen) $::pgl(zCen)  0.0 1.0 0.0
    }

    if {1} {
	glTranslatef 0.0 0.0 [expr {-1.1*$::Rad}]

	set mat [build_rotmatrix $::cQuat]
	#set mat $::TransformList      
	glMultMatrixf $mat
	
	glTranslatef [expr {-1.0*$::pgl(xCen)}] [expr {-1.0*$::pgl(yCen)}] [expr {-1.0*$::pgl(zCen)}]

	EnvoieLesObjets
    } else {
	glTranslatef -1.5 0.0 -6.0          
	# Move Left 1.5 Units And Into The Screen 6.0
	
	glPushMatrix                        
	# NEW: Prepare Dynamic Transform
	glMultMatrixf $::TransformList      
	# NEW: Apply Dynamic Transform
	glColor3f 0.75 0.75 1.0
	# As we use the standard glut torus, rotate it by 90 degrees, so it has the same 
	# orientation as in the original NeHe demo.
	glRotatef 90.0 1.0 0.0 0.0
	glutSolidTorus 0.3 1.0 20 20
	glPopMatrix                         
	# NEW: Unapply Dynamic Transform
	
	glLoadIdentity                      
	# Reset The Current Modelview Matrix
	glTranslatef 1.5 0.0 -6.0           
	# Move Right 1.5 Units And Into The Screen 7.0
	
	glPushMatrix                        
	# NEW: Prepare Dynamic Transform
	glMultMatrixf $::TransformList      
	# NEW: Apply Dynamic Transform
	glColor3f 1.0 0.75 0.75
	gluSphere $::quadric 1.3 20 20
	glPopMatrix                         
	# NEW: Unapply Dynamic Transform
    }
    
    glFlush                             

    $toglwin swapbuffers

    return

}

proc DisplayFrom {s} {

    set s [string trim [string map {"\"" ""} $s] ]
    set ret [string range $s 0 [string first "<" $s]-1]
    if {$ret eq ""} {
	set ret $s
    }

    return $ret

}

proc DisplayMessage {w x y} {

    set w [winfo parent $w]
    set idx [$w index active]
    # Beware : idx starts at 0, uid starts at 1
    set uid [expr {[llength $::TMail(UID)] - $idx}]
    puts ""
    puts "idx $idx uid $uid"
    flush stdout

    ::imap4::fetch $::CMDef(imapID) $uid:$uid FULLBODY
    set body [::imap4::msginfo $::CMDef(imapID) $uid body]
    # parse body parts using MIME
    set token [::mime::initialize -string $body]
    set t [struct::tree]
    set Lparts [mimeGetPartsTree $token]
    $t deserialize $Lparts
    ::mime::finalize $token
    puts ""
    puts "[join $Lparts \n]"
    puts ""

    set Lf [list]
    foreach n [$t leaves] {
	set d [$t depth $n]
	lappend Lf $d $n
    }
    set Lf [lsort -decreasing -integer -stride 2 -index 0 $Lf]
    set c 0
    while {$c < [llength $Lf]} {
	set n [lindex $Lf $c]
	set p [$t parent $n]
	set type [$t attr type $n]
	puts $type
	incr c
    }

    return

    # display message ...
    set WT $::CMDef(WText)
    $WT delete 1.0 end
    $WT insert end $txt
    
    
    
    

    return

}

proc DissimilaritesPositions {LesNoms aBin aDissim aColPleines aColAutres TailleSeq} {

    upvar  $aDissim Dissim 
    upvar  $aBin Bin
    upvar  $aColPleines ColPleines
    upvar  $aColAutres  ColAutres
    global PremiereColPleine
    
    set ColPleines [list]
    set ColAutres  [list]
    set NbSeq [llength $LesNoms]
    #determination des colonnes pleines
    for {set i 1} {$i<=$TailleSeq} {incr i} {
	set Somme 0
	foreach Nom $LesNoms {
	    if {![set Bin($Nom,$i)]} break
	    incr Somme [set Bin($Nom,$i)]
	}
	if {$Somme==$NbSeq} {
	    lappend ColPleines $i
	    set PleinOuNon($i) 1
	} else {
	    lappend ColAutres $i
	    set PleinOuNon($i) 0
	}
    }
    #calcul des dissimilarites entre une colonne pleine et toutes les autres
    if {[llength $ColPleines]>0} {
	set PremiereColPleine [lindex $ColPleines 0]
	set i $PremiereColPleine
	for {set j 1} {$j<=$TailleSeq} {incr j} {
	    if {[set PleinOuNon($j)]} {
		set Dissim($i,$j) 0
		set Dissim($j,$i) 0
	    } else {
		set SommeDiff 0
		foreach Nom $LesNoms {
#		    set SommeDiff [expr $SommeDiff + abs( [set Bin($Nom,$i)] - [set Bin($Nom,$j)] )]
		    set SommeDiff [expr {$SommeDiff +([set Bin($Nom,$i)]^[set Bin($Nom,$j)])}]
		}
		set Dissim($i,$j) $SommeDiff
		set Dissim($j,$i) $SommeDiff
	    }
	}
    } else {
	set PremiereColPleine -1
    }
    #calcul des dissimilarites dans le cas general
    for {set i 1} {$i<=$TailleSeq} {incr i} {
	for {set j [expr $i+1]} {$j<=$TailleSeq} {incr j} {
	    if {[set PleinOuNon($i)]} {
		set Dissim($i,$j) [set Dissim($PremiereColPleine,$j)] 
		set Dissim($j,$i) [set Dissim($j,$PremiereColPleine)]
		continue
	    }
	    if {[set PleinOuNon($j)]} {
		set Dissim($i,$j) [set Dissim($i,$PremiereColPleine)] 
		set Dissim($j,$i) [set Dissim($PremiereColPleine,$i)] 
		continue
	    }
	    set SommeDiff 0
	    foreach Nom $LesNoms {
		#set SommeDiff [expr {$SommeDiff + abs( [set Bin($Nom,$i)] - [set Bin($Nom,$j)] )}]
		set SommeDiff [expr {$SommeDiff +([set Bin($Nom,$i)]^[set Bin($Nom,$j)])}]
	    }
	    set Dissim($i,$j) $SommeDiff
	    set Dissim($j,$i) $SommeDiff
	}
    }

}

proc DissimilaritesSequences {LesNoms aBin aDissim TailleSeq} {

    upvar  $aDissim Dissim
    upvar  $aBin Bin
    
    set LesAutres $LesNoms
    foreach NomA $LesNoms {
	set LesAutres [lrange $LesAutres 1 end]
	foreach NomB $LesAutres {
	    set SommeDiss 0
	    for {set i 1} {$i<=$TailleSeq} {incr i} {
		set SommeDiss [expr $SommeDiss + abs([set Bin($NomA,$i)]- [set Bin($NomB,$i)])]
	    } 
	    set Dissim($NomA,$NomB) $SommeDiss
	    set Dissim($NomB,$NomA) $SommeDiss
	}
    }

}

proc Dist {u v} {

    return [expr {sqrt([Dist2 $u $v])}]

}

proc Dist2 {u v} {

    lassign $u x1 x2 x3
    lassign $v y1 y2 y3
    return [expr {($y1-$x1)**2 + ($y2-$x2)**2 + ($y3-$x3)**2}]

}

proc DistanceDe {A B} {

    
    lassign $A x1 y1 z1 
    lassign $B x2 y2 z2 
    
    return [expr {sqrt($x1*$x2 + $y1*$y2 + $z1*$z2)}]

}

proc DistanceEntreClustersXHda {Cluster1 Cluster2} {

    global DistanceEntreClustersXHda

    if { ! [regexp {^[0-9]+$} $Cluster1]} { set Cluster1 [InfoDuCluster $Cluster1 Numero] }
    if { ! [regexp {^[0-9]+$} $Cluster2]} { set Cluster2 [InfoDuCluster $Cluster2 Numero] }

    if {[info exists DistanceEntreClustersXHda($Cluster1,$Cluster2)]} { return [set DistanceEntreClustersXHda($Cluster1,$Cluster2)] }
    if {[info exists DistanceEntreClustersXHda("EstCharge")]} { return -9 }

    set FichierDPC "[RepertoireDuGenome]/xhda/TousLesBilans_PourNuca.dpc"

    regsub {.dpc$} $FichierDPC ".dst" FichierDistances
    if {[file exists $FichierDistances]} {
	set A -1
	foreach Ligne [LesLignesDuFichier $FichierDistances] {
	    incr A
	    set B -1
	    foreach Dist [split $Ligne " "] {
		incr B
		set DistanceEntreClustersXHda($A,$B) $Dist
	    }
	}
	set  DistanceEntreClustersXHda("EstCharge") 1
	return [DistanceEntreClustersXHda $Cluster1 $Cluster2]
    }
    if { ! [file exists $FichierDistances] && [info exists DistanceEntreClustersXHda("EstCalcule")]} {
	return -2
    }

    if { ! [file exists $FichierDPC]} { return {} }

    regsub {.dpc$} $FichierDPC "" FichierBilan
    if { ! [file exists $FichierBilan]} {
	FaireLire "Il faut aller se plaindre chez Nicolas pour calcul_distances_inter_groupe"
	return {}
    }
    scan [PremiereLigneDuFichier $FichierBilan] "%d %d" nGenes nOrgas
    if {[catch { exec /biolo/secator/calcul_distances_inter_groupes $FichierDPC $nGenes $nOrgas } Message] } {
	FaireLire "Il faut aller se plaindre chez Nicolas pour calcul_distances_inter_groupe\n Message : $Message"
	return {}
    }
    regsub {.dpc$} $FichierDPC ".dst" FichierDistances
    if { ! [file exists $FichierDistances]} {
	FaireLire "Il faut aller se plaindre chez Nicolas pour calcul_distances_inter_groupe\n $FichierDistances non cree."
	return {}
    }
    set  DistanceEntreClustersXHda("EstCalcule") 1
    return [DistanceEntreClustersXHda $Cluster1 $Cluster2]

}

proc DistanceEntreDeuxPhrases {PhraseA PhraseB} {

    set LaPhraseA     [split   [join $PhraseA " "]  " "]
    set LaPhraseB     [split   [join $PhraseB " "]  " "]
    set TaillePhraseA [llength $LaPhraseA        ]
    set TaillePhraseB [llength $LaPhraseB        ]

    set Score 0
    set PosA  -1
    foreach MotA $LaPhraseA {
	incr PosA
	
	set LAiJeTrouve 0
	set PosB -1
	foreach MotB $LaPhraseB {
	    incr PosB
	    if {$MotA != $MotB} {continue}
	    set LAiJeTrouve 1
	    set Score      [expr $Score + abs($PosA-$PosB)]
	    set LaPhraseB [lreplace $LaPhraseB $PosB $PosB ""]
	    break
	}
	if {!$LAiJeTrouve} {set Score [expr $Score + $TaillePhraseA]}
    }
    return $Score

}

proc DistribNbInteract {ParserFile NbGroup} {

    #NbGroup= 5 ou 10
    set BornesDesGroupes(5)  {1 5 10 30 100}
    set BornesDesGroupes(10) {1 5 10 25 50 100 200 300 400 500}
    if {[info exists Case]} {unset Case}
    set Directory [file dirname $ParserFile]
    set SummaryFile "${Directory}/Summary.txt"

    foreach IdString [FromParser ListOf IdString $ParserFile] {
	set IdInitial [FromSummary $IdString IdInitial $SummaryFile]
	set NbInteract [FromParser $IdString NbInteract $ParserFile]
	RangeDansLaCase $NbInteract $BornesDesGroupes($NbGroup) Case
    }
    set MaxNbInteract [FromParser Max NbInteract $ParserFile]

    set LesBornes $BornesDesGroupes($NbGroup)
    foreach D [lrange $LesBornes 0 end] F [concat [lrange $LesBornes 1 end] [list [expr $MaxNbInteract+1]]] {
	set Intervalle "[format %3d $D] <= n"
	append Intervalle " < [format %3d $F]"
	if {![info exists Case($D)]} {set Case($D) 0}
	Espionne "$Intervalle : [format %4d $Case($D)]"
    }

}

proc Distribution {Liste Intervalle {MinLength ""}} {

    #intervalle ]0-1] nomme 1
 #   set Debut 0.05

    set ListeReels [list]
    set LaDistribution [list]
    foreach el $Liste {
        if {$el==""} continue
        lappend ListeReels [expr 1.0*$el]
    }
    set ListeTriee [lsort -real $ListeReels]
    if {$MinLength==""} {
	set Debut [lindex $ListeTriee 0]
    } else {
	set Debut $MinLength
    }
    set Max [lindex $ListeTriee end]
    set i [expr $Intervalle+$Debut]
    while {$i<$Max} {
        set LesIntervalles($i) 0
        set i [expr $i+$Intervalle]
    }
    set LesIntervalles($i) 0
    set i [expr $Intervalle+$Debut]
    
    foreach el $ListeTriee {
        while {$el>$i && [expr $el-$i]>1e-10 } {set i [expr $i+$Intervalle]}
        incr LesIntervalles($i)
    }
    set i [expr $Intervalle+$Debut]
    while {$i<$Max} {
        lappend LaDistribution "$i [set LesIntervalles($i)]"
        set i [expr $i+$Intervalle]
    } 
    lappend LaDistribution "$i [set LesIntervalles($i)]"
    array unset LesIntervalles
    return $LaDistribution

}

proc DistributionDesGenesSurLesBandesCytologiques {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set Fichier "$RepLocalisation/Gene_cyto_Distribution"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {Espionne "$FichierBandesCytos does not exist";return ""}

    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/seq_locus_tr.md"
    set NameFichierGenes  [file tail $FichierGenes]
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des bandes ################
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set nChromosome [NumeroDuChromosome $Chromosome]
	if {![info exists Contigs($nChromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set PosIni 0
	foreach Bande $LesBandesCytologiques {
	    set LesInfos    [set LesBandesCytos($Chromosome,$Bande)]
	    set Position    [lindex $LesInfos 0]
	    set Position    [expr round($Position * 1E6)]
	    set TailleBande [expr round($Position-$PosIni)]
	    set PosIni $Position

	    set Tableau($Bande,NbGenes) 0
	    set Tableau($Bande,Taille)  $TailleBande
	}
    }

    ###########Les genes########################
    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbGenesInCtgNP) 0
	set Tableau($Chromosome,NbGenesInCtgP)  0
	Espionne $Chromosome
	if {[info exists TabMV]} {unset TabMV}
	ChargeFichierMapViewer TabMV $FichierGenes $Chromosome
	if {![info exists TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)]} {continue}
	foreach Gene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)] {
	    set LeGene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,Element,$Gene,LesLocalisations)]
	    set LesInfos [lindex [lsort -integer -decreasing -index 5 $LeGene] 0]
	    set Sens     [lindex $LesInfos 6]
	    if {$Sens == 0 || $Sens == ""} {continue}
	    set Debut    [lindex $LesInfos 3]
	    set Fin      [lindex $LesInfos 4]
	    set LesBandesOccupees [LesBandesCytologiquesDeLaRegion $Chromosome $Debut $Fin]
	    foreach LaBande $LesBandesOccupees {
		set Bande  [lindex $LaBande 0]
		incr Tableau($Bande,NbGenes)
	    }
	}
    }

    #############Texte ################
    set Texte ""
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set NbGenesTot 0
	set nChromosome [NumeroDuChromosome $Chromosome]
	if {![info exists Contigs($nChromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set LaLegende           [list "Chromosome"  "Length"            "Type"      "Var"            ]
	set LesNbGenes          [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbGenes" ]
	set LesTaillesDesBandes [list "$nChromosome" "$TailleChromosome" "Cytologic" "Length"        ]

	foreach Bande $LesBandesCytologiques {
	    lappend LaLegende            $Bande
	    lappend LesNbGenes           [set Tableau($Bande,NbGenes) ]
	    lappend LesTaillesDesBandes  [set Tableau($Bande,Taille)  ]
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenes"     "\t"]      ;append Texte "\n"
	append Texte [join "$LesTaillesDesBandes" "\t"] ;append Texte "\n"    
    }
    Espionne $Texte
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesBandesCytologiques_old {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {Espionne "$FichierBandesCytos does not exist";return ""}

    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/chr_genes.gtf"
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des bandes ################
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set nChromosome [NumeroDuChromosome $Chromosome]
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set PosIni 0
	foreach Bande $LesBandesCytologiques {
	    set LesInfos    [set LesBandesCytos($Chromosome,$Bande)]
	    set Position    [lindex $LesInfos 0]
	    set Position    [expr round($Position * 1E6)]
	    set TailleBande [expr round($Position-$PosIni)]
	    set PosIni $Position

	    set Tableau($Bande,NbGenes) 0
	    set Tableau($Bande,Taille)  $TailleBande
	}
    }

    ###########Les genes########################
    Espionne "Genes\tresearch in cytologic bandes ... please wait"
    foreach Ligne [LesLignesDuFichier $FichierGenes] {
	if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue}
	set LaLigne [split $Ligne "\t"]

	set Chromosome  [lindex $LaLigne 0]
	regsub "^chr" $Chromosome "" Chromosome 
	if {[regexp "\\|" $Chromosome]} {continue}

	set Debut       [lindex $LaLigne 3]
	set Fin         [lindex $LaLigne 4]
	set Info        [lindex $LaLigne 8]
	if {[info exists Gene]} {unset Gene}
	regexp -nocase {; gene \"([0-9a-z_\&\'\@\(\)\:\/\-\.]*)} $Info tmp Gene

	if {![info exists GeneDeRef]} {
	    set GeneDeRef $Gene
	    set DebutDeRef $Debut
	    set FinDeRef   $Fin
	    continue
	}
	if {$GeneDeRef == $Gene} {
	    if {$Debut    < $DebutDeRef} {set DebutDeRef $Debut}
	    if {$FinDeRef < $Fin       } {set FinDeRef   $Fin  } 
	    continue
	} else {
	    set LesBandesOccupees [LesBandesCytologiquesDeLaRegion $Chromosome $DebutDeRef $FinDeRef]
	    foreach LaBande $LesBandesOccupees {
		set Bande  [lindex $LaBande 0]
		incr Tableau($Bande,NbGenes)
	    }
	    set GeneDeRef $Gene
	    set DebutDeRef $Debut
	    set FinDeRef   $Fin
	    continue
	}
    }

    #############Texte ################
    set Texte ""
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set NbGenesTot 0
	set nChromosome [NumeroDuChromosome $Chromosome]
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set LaLegende           [list "Chromosome"  "Length"            "Type"      "Var"            ]
	set LesNbGenes          [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbGenes" ]
	set LesTaillesDesBandes [list "$nChromosome" "$TailleChromosome" "Cytologic" "Length"        ]

	foreach Bande $LesBandesCytologiques {
	    lappend LaLegende            $Bande
	    lappend LesNbGenes           [set Tableau($Bande,NbGenes) ]
	    lappend LesTaillesDesBandes  [set Tableau($Bande,Taille)  ]
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenes"     "\t"]      ;append Texte "\n"
	append Texte [join "$LesTaillesDesBandes" "\t"] ;append Texte "\n"    
    }
    Espionne $Texte
    set Fichier "$RepLocalisation/Gene_cyto_Distribution"
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesChromosomes {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set Fichier "$RepLocalisation/Gene_chr_Distribution"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/seq_locus_tr.md"
    set NameFichierGenes  [file tail $FichierGenes]
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs
    #############Initialisation des chromosomes###########
    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbGenesInCtgNP) 0
	set Tableau($Chromosome,NbGenesInCtgP)  0
	Espionne $Chromosome
	if {[info exists TabMV]} {unset TabMV}
	ChargeFichierMapViewer TabMV $NameFichierGenes $Chromosome
	if {![info exists TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)]} {continue}
	foreach Gene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)] {
	    set LeGene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,Element,$Gene,LesLocalisations)]
	    set Sens   [lindex [lindex $LeGene 0] 6]
	    if {$Sens == ""} {continue}
	    if {$Sens == "0"} {
		incr Tableau($Chromosome,NbGenesInCtgNP)
	    } else {
		incr Tableau($Chromosome,NbGenesInCtgP)
	    }
	}
    }
    #######Tableau#################
    set GenesInCtgPTot  0
    set GenesInCtgNPTot 0
    set TailleTot       0

    set Texte "Chromosome\tLength\tGenesInCtgP\tGenesInCtgNP\tGenesInWCtg"
    foreach Chromosome   [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]] {
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set Taille       [set Contigs($Chromosome,Taille)        ]
	set GenesInCtgP  [set Tableau($Chromosome,NbGenesInCtgP) ]
	set GenesInCtgNP [set Tableau($Chromosome,NbGenesInCtgNP)]
	append Texte "\n$Chromosome\t$Taille\t$GenesInCtgP\t$GenesInCtgNP\t0"
	incr GenesInCtgPTot  $GenesInCtgP
	incr GenesInCtgNPTot $GenesInCtgNP
	incr TailleTot       $Taille
    }
    append Texte "\nRemaining\t0\t0\t0\t0"
    append Texte "\nTotal\t$TailleTot\t$GenesInCtgPTot\t$GenesInCtgNPTot\t0"

    Espionne $Texte

    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesChromosomes_old {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/ctg_genes.gtf"
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs

    #############Initialisation des chromosomes###########
    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbGenesInCtgNP) 0
	set Tableau($Chromosome,NbGenesInCtgP)  0
    }
    set Tableau(NbGenesInWCtg) 0
    
    ###########Nb genes dans chaque chromosome##############
    foreach Ligne [LesLignesDuFichier $FichierGenes] {
	set LaLigne [split $Ligne "\t"]
	set Contig [lindex $LaLigne 0]
	regsub "_" $Contig "" Contig
	
	set Info    [lindex $LaLigne 8]
	if {[info exists Gene]} {unset Gene}
	regexp -nocase {; gene \"([0-9a-z_\&\'\@\(\)\:\-\/\.]*)} $Info tmp Gene

	if {![info exists GeneDeRef]} {
	    set GeneDeRef $Gene
	    if {![info exists Contigs($Contig)]} {
		incr Tableau(NbGenesInWCtg)
		continue
	    } else {
		set LesInfosDuContig [set Contigs($Contig)      ]
		set Sens             [lindex $LesInfosDuContig 3]
		set Chromosome       [lindex $LesInfosDuContig 0]
		if {$Sens == "0"} {
		    incr Tableau($Chromosome,NbGenesInCtgNP)
		} else {
		    incr Tableau($Chromosome,NbGenesInCtgP)
		}
	    }
	    continue
	} elseif {$Gene == $GeneDeRef} {
	    continue
	} else {
	    set GeneDeRef $Gene
	    if {![info exists Contigs($Contig)]} {
		incr Tableau(NbGenesInWCtg)
		continue
	    } else {
		set LesInfosDuContig [set Contigs($Contig)      ]
		set Sens             [lindex $LesInfosDuContig 3]
		set Chromosome       [lindex $LesInfosDuContig 0]
		if {$Sens == "0"} {
		    incr Tableau($Chromosome,NbGenesInCtgNP)
		} else {
		    incr Tableau($Chromosome,NbGenesInCtgP)
		}
	    }
	    continue
	}
    }
    #######Tableau#################
    set GenesInCtgPTot  0
    set GenesInCtgNPTot 0
    set TailleTot       0

    set Texte "Chromosome\tLength\tGenesInCtgP\tGenesInCtgNP\tGenesInWCtg"
    foreach Chromosome   [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]] {
	set Taille       [set Contigs($Chromosome,Taille)        ]
	set GenesInCtgP  [set Tableau($Chromosome,NbGenesInCtgP) ]
	set GenesInCtgNP [set Tableau($Chromosome,NbGenesInCtgNP)]
	append Texte "\n$Chromosome\t$Taille\t$GenesInCtgP\t$GenesInCtgNP\t0"
	incr GenesInCtgPTot  $GenesInCtgP
	incr GenesInCtgNPTot $GenesInCtgNP
	incr TailleTot       $Taille
    }
    set GenesInWCtg      [set Tableau(NbGenesInWCtg)             ]
    append Texte "\nRemaining\t0\t0\t0\t$GenesInWCtg"
    append Texte "\nTotal\t$TailleTot\t$GenesInCtgPTot\t$GenesInCtgNPTot\t$GenesInWCtg"

    Espionne $Texte
    set Fichier "$RepLocalisation/Gene_chr_Distribution"
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesContigs {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set Fichier "$RepLocalisation/Gene_ctg_Distribution"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/seq_locus_tr.md"
    set NameFichierGenes  [file tail $FichierGenes]
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs

    ##########Initialisation des contigs###########
    foreach Contig [set Contigs(LesContigs)] {
	set Tableau($Contig,NbGenesInCtgNP) 0
	set Tableau($Contig,NbGenesInCtgP)  0
    }
    ###########Les genes########################

    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbGenesInCtgNP) 0
	set Tableau($Chromosome,NbGenesInCtgP)  0
	Espionne $Chromosome
	if {[info exists TabMV]} {unset TabMV}
	ChargeFichierMapViewer TabMV $FichierGenes $Chromosome
	if {![info exists TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)]} {continue}
	foreach Gene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)] {
	    set LeGene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,Element,$Gene,LesLocalisations)]
	    set LesInfos [lindex [lsort -integer -decreasing -index 5 $LeGene] 0]
	    set Sens     [lindex $LesInfos 6]
	    if {$Sens == ""} {continue}
	    set Debut    [lindex $LesInfos 3]
	    set Fin      [lindex $LesInfos 4]

	    foreach Contig [set Contigs($Chromosome,LesContigs)] {
		set LeContig [set Contigs($Contig)] 
		set DContig  [lindex $LeContig 1]
		set FContig  [lindex $LeContig 2]

		if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DContig $FContig]} {continue}
		if {$Sens == 0} {
		    incr Tableau($Contig,NbGenesInCtgNP)
		} else {
		    incr Tableau($Contig,NbGenesInCtgP)
		}
	    }
	}
    }
    ###########Texte#######################
    set Texte ""
    set LesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $LesChromosomes {
	set NbGenesTot 0
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($Chromosome,Taille)]

	set LesContigs [set Contigs($Chromosome,LesContigs)]
	set LaLegende            [list "Chromosome"  "Length"            "Type"   "Var"         ]
	set LesNbGenesInCtgP     [list "$Chromosome" "$TailleChromosome" "Contig" "GenesInCtgP" ]
	set LesNbGenesInCtgNP    [list "$Chromosome" "$TailleChromosome" "Contig" "GenesInCtgNP"]
	set LesSensDesContigs    [list "$Chromosome" "$TailleChromosome" "Contig" "Sens"        ]
	set LesTaillesDesContigs [list "$Chromosome" "$TailleChromosome" "Contig" "Length"      ]
	foreach Contig $LesContigs {
	    set LesInfosDuContig        [set Contigs($Chromosome,$Contig)    ]
	    set Debut                   [lindex $LesInfosDuContig 0          ]
	    set Fin                     [lindex $LesInfosDuContig 1          ]
	    set TailleContig            [expr $Fin - $Debut  + 1             ] 
	    set Sens                    [lindex $LesInfosDuContig 2          ]

	    lappend LaLegende            $Contig
	    lappend LesNbGenesInCtgP     [set Tableau($Contig,NbGenesInCtgP) ]
	    lappend LesNbGenesInCtgNP    [set Tableau($Contig,NbGenesInCtgNP)]
	    lappend LesSensDesContigs    $Sens
	    lappend LesTaillesDesContigs $TailleContig
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenesInCtgP"     "\t"];append Texte "\n"
	append Texte [join "$LesNbGenesInCtgNP"    "\t"];append Texte "\n"
	append Texte [join "$LesSensDesContigs"    "\t"];append Texte "\n"
	append Texte [join "$LesTaillesDesContigs" "\t"];append Texte "\n"
    }
    Espionne $Texte
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesContigs_old {{Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/ctg_genes.gtf"
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs

    ##########Initialisation des contigs###########
    set Tableau(NbGenesInWCtg) 0
    foreach Contig [set Contigs(LesContigs)] {
	set Tableau($Contig,NbGenesInCtgNP) 0
	set Tableau($Contig,NbGenesInCtgP)  0
    }
    ###########Les genes########################
    foreach Ligne [LesLignesDuFichier $FichierGenes] {
	set LaLigne [split $Ligne "\t"]

	set Contig  [lindex $LaLigne 0]
	regsub "_" $Contig "" Contig

	set Info    [lindex $LaLigne 8]
	if {[info exists Gene]} {unset Gene}
	regexp -nocase {; gene \"([0-9a-z_\&\'\@\(\)\:\/\-\.]*)} $Info tmp Gene

	if {![info exists GeneDeRef]} {
	    set GeneDeRef $Gene
	    if {![info exists Contigs($Contig)]} {
		incr Tableau(NbGenesInWCtg)
		continue
	    }
	}
	if {$GeneDeRef == $Gene} {
	    continue
	} else {
	    set GeneDeRef $Gene
	    if {![info exists Contigs($Contig)]} {
		incr Tableau(NbGenesInWCtg)
		continue
	    }
	    set LesInfosDuContig [set Contigs($Contig)      ]
	    set Sens             [lindex $LesInfosDuContig 3]
	    if {$Sens == 0} {
		incr Tableau($Contig,NbGenesInCtgNP)
	    } else {
		 incr Tableau($Contig,NbGenesInCtgP)
	    }
	    continue
	}
    }
    ###########Texte#######################
    set Texte ""
    set LesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $LesChromosomes {
	set NbGenesTot 0
	set TailleChromosome [set Contigs($Chromosome,Taille)]

	set LesContigs [set Contigs($Chromosome,LesContigs)]
	set LaLegende            [list "Chromosome"  "Length"            "Type"   "Var"         ]
	set LesNbGenesInCtgP     [list "$Chromosome" "$TailleChromosome" "Contig" "GenesInCtgP" ]
	set LesNbGenesInCtgNP    [list "$Chromosome" "$TailleChromosome" "Contig" "GenesInCtgNP"]
	set LesSensDesContigs    [list "$Chromosome" "$TailleChromosome" "Contig" "Sens"        ]
	set LesTaillesDesContigs [list "$Chromosome" "$TailleChromosome" "Contig" "Length"      ]
	foreach Contig $LesContigs {
	    set LesInfosDuContig        [set Contigs($Chromosome,$Contig)    ]
	    set Debut                   [lindex $LesInfosDuContig 0          ]
	    set Fin                     [lindex $LesInfosDuContig 1          ]
	    set TailleContig            [expr $Fin - $Debut  + 1             ] 
	    set Sens                    [lindex $LesInfosDuContig 2          ]

	    lappend LaLegende            $Contig
	    lappend LesNbGenesInCtgP     [set Tableau($Contig,NbGenesInCtgP) ]
	    lappend LesNbGenesInCtgNP    [set Tableau($Contig,NbGenesInCtgNP)]
	    lappend LesSensDesContigs    $Sens
	    lappend LesTaillesDesContigs $TailleContig
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenesInCtgP"     "\t"];append Texte "\n"
	append Texte [join "$LesNbGenesInCtgNP"    "\t"];append Texte "\n"
	append Texte [join "$LesSensDesContigs"    "\t"];append Texte "\n"
	append Texte [join "$LesTaillesDesContigs" "\t"];append Texte "\n"
    }

    Espionne $Texte
    set Fichier "$RepLocalisation/Gene_ctg_Distribution"
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesRegions {{TailleRegion 1e6} {Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set Fichier "$RepLocalisation/Gene_area${TailleRegion}bp_Distribution"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {Espionne "$FichierBandesCytos does not exist";return ""}

    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/seq_locus_tr.md"
    set NameFichierGenes [file tail $FichierGenes]
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des regions ################
    set TousLesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $TousLesChromosomes {
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($Chromosome,Taille)]
	set Reste            [expr round($TailleChromosome) % round($TailleRegion)]
	set NbRegions        [expr round (($TailleChromosome/$TailleRegion)-0.5)]

	set Tab($Chromosome,DerniereRegion) $Reste

	set DebutRegion 1
	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set FinRegion [expr round($DebutRegion + $TailleRegion - 1)]
	    set Tab($Chromosome,$i,NbGenes) 0
	    
	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion

	    set DebutRegion [expr $FinRegion + 1]
	}
	if {$Reste != 0} {
	    set Tab($Chromosome,NbRegions)  [expr $NbRegions + 1]
	    set FinRegion                   [expr $DebutRegion + $Reste]
	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion
	    set Tab($Chromosome,$i,NbGenes) 0
	} else {
	    set Tab($Chromosome,NbRegions)  $NbRegions
	}
    }
    #########Les Genes#####################

    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbGenesInCtgNP) 0
	set Tableau($Chromosome,NbGenesInCtgP)  0
	Espionne $Chromosome
	if {[info exists TabMV]} {unset TabMV}
	ChargeFichierMapViewer TabMV $FichierGenes $Chromosome
	if {![info exists TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)]} {continue}
	foreach Gene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,LesElements)] {
	    set LeGene [set TabMV($NameFichierGenes,Chromosome,$Chromosome,Element,$Gene,LesLocalisations)]
	    set LesInfos [lindex [lsort -integer -decreasing -index 5 $LeGene ] 0]
	    set Sens     [lindex $LesInfos 6]
	    if {$Sens == 0 || $Sens == ""} {continue}
	    set Debut    [lindex $LesInfos 3]
	    set Fin      [lindex $LesInfos 4]

	    for {set i 1} {$i <= [set Tab($Chromosome,NbRegions)]} {incr i} {
		set DebutRegion  [set Tab($Chromosome,$i,Debut)]
		set FinRegion    [set Tab($Chromosome,$i,Fin)  ]
		if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DebutRegion $FinRegion]} {continue}
		incr Tab($Chromosome,$i,NbGenes)
	    }
	}
    }
    #############Texte ################
    set Texte ""
    foreach Chromosome $TousLesChromosomes {
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	if {![info exists Tab($Chromosome,NbRegions) ]} {continue}
	set NbRegions           [set Tab($Chromosome,NbRegions)]
	set TailleChromosome    [set Contigs($Chromosome,Taille)]
	if {$TailleChromosome == 0} {continue}

	set LaLegende            [list "Chromosome"  "Length"            "Type"  "Var"         ]
	set LesNbGenes           [list "$Chromosome" "$TailleChromosome" "Area${TailleRegion}bp" "NbGenes" ]
	set LesTaillesDesRegions [list "$Chromosome" "$TailleChromosome" "Area${TailleRegion}bp" "Length"      ]
	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set DebutRegion  [set Tab($Chromosome,$i,Debut)  ] 
	    set FinRegion    [set Tab($Chromosome,$i,Fin)    ] 
	    set NbGenes      [set Tab($Chromosome,$i,NbGenes)]
	    
	    if {$i == $NbRegions} {
		set TailleArea [set Tab($Chromosome,DerniereRegion)] 
	    } else {
		set TailleArea $TailleRegion
	    }
	    lappend LaLegende            $i
	    lappend LesNbGenes           $NbGenes
	    lappend LesTaillesDesRegions $TailleArea
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenes"           "\t"];append Texte "\n"
	append Texte [join "$LesTaillesDesRegions" "\t"];append Texte "\n" 
    }
    Espionne $Texte

    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesGenesSurLesRegions_old {{TailleRegion 1e6} {Save ""}} {

    global RepertoireDuGenome

    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {Espionne "$FichierBandesCytos does not exist";return ""}

    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist";return ""}

    set FichierGenes      "$RepLocalisation/chr_genes.gtf"
    if {![file exists $FichierGenes]} {Espionne "$FichierGenes does not exist";return ""}

    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des regions ################
    set TousLesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $TousLesChromosomes {
	set TailleChromosome [set Contigs($Chromosome,Taille)]
	set Reste            [expr round($TailleChromosome) % round($TailleRegion)]
	set NbRegions        [expr round (($TailleChromosome/$TailleRegion)-0.5)]

	set Tab($Chromosome,DerniereRegion) $Reste

	set DebutRegion 1
	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set FinRegion [expr round($DebutRegion + $TailleRegion - 1)]
	    set Tab($Chromosome,$i,NbGenes) 0
	    
	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion

	    set DebutRegion [expr $FinRegion + 1]
	}
	if {$Reste != 0} {
	    set Tab($Chromosome,NbRegions)  [expr $NbRegions + 1]
	    set FinRegion                   [expr $DebutRegion + $Reste]
	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion
	    set Tab($Chromosome,$i,NbGenes) 0
	} else {
	    set Tab($Chromosome,NbRegions)  $NbRegions
	}
    }
    #########Les Genes#####################
    foreach Ligne [LesLignesDuFichier $FichierGenes] {
	if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue}
	set LaLigne [split $Ligne "\t"]

	set Chromosome  [lindex $LaLigne 0]
	regsub "^chr" $Chromosome "" Chromosome 
	if {[regexp "\\|" $Chromosome]} {continue}

	set Debut       [lindex $LaLigne 3]
	set Fin         [lindex $LaLigne 4]
	set Info        [lindex $LaLigne 8]
	if {[info exists Gene]} {unset Gene}
	regexp -nocase {; gene \"([0-9a-z_\&\'\@\(\)\:\/\-\.]*)} $Info tmp Gene

	if {![info exists GeneDeRef]} {
	    set GeneDeRef $Gene
	    set DebutDeRef $Debut
	    set FinDeRef   $Fin
	    continue
	}
	if {$GeneDeRef == $Gene} {
	    if {$Debut    < $DebutDeRef} {set DebutDeRef $Debut}
	    if {$FinDeRef < $Fin       } {set FinDeRef   $Fin  } 
	    continue
	} else {
	    for {set i 1} {$i <= [set Tab($Chromosome,NbRegions)]} {incr i} {
		set DebutRegion  [set Tab($Chromosome,$i,Debut)]
		set FinRegion    [set Tab($Chromosome,$i,Fin)  ]
		if {    ($DebutRegion < $DebutDeRef  && $FinDeRef   <= $FinRegion) || ($DebutRegion < $FinDeRef    && $FinDeRef   <= $FinRegion) || ($DebutRegion < $DebutDeRef  && $DebutDeRef <= $FinRegion) || ($DebutDeRef  < $DebutRegion && $FinRegion  <= $FinDeRef      ) } {
		    incr Tab($Chromosome,$i,NbGenes)
		}
	    }
	    set GeneDeRef $Gene
	    set DebutDeRef $Debut
	    set FinDeRef   $Fin
	    continue
	}
    }
    #############Texte ################
    set Texte ""
    foreach Chromosome $TousLesChromosomes {
	set NbRegions           [set Tab($Chromosome,NbRegions)]
	set TailleChromosome    [set Contigs($Chromosome,Taille)]
	if {$TailleChromosome == 0} {continue}

	set LaLegende            [list "Chromosome"  "Length"            "Type"  "Var"         ]
	set LesNbGenes           [list "$Chromosome" "$TailleChromosome" "Area${TailleRegion}bp" "NbGenes" ]
	set LesTaillesDesRegions [list "$Chromosome" "$TailleChromosome" "Area${TailleRegion}bp" "Length"      ]

	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set DebutRegion  [set Tab($Chromosome,$i,Debut)  ] 
	    set FinRegion    [set Tab($Chromosome,$i,Fin)    ] 
	    set NbGenes      [set Tab($Chromosome,$i,NbGenes)]
	    
	    if {$i == $NbRegions} {
		set TailleArea [set Tab($Chromosome,DerniereRegion)] 
	    } else {
		set TailleArea $TailleRegion
	    }
	    lappend LaLegende            $i
	    lappend LesNbGenes           $NbGenes
	    lappend LesTaillesDesRegions $TailleArea
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbGenes"           "\t"];append Texte "\n"
	append Texte [join "$LesTaillesDesRegions" "\t"];append Texte "\n" 
    }
    Espionne $Texte
    set Fichier "$RepLocalisation/Gene_area${TailleRegion}bp_Distribution"
    if {$Save == "Save"} {
	Sauve $Texte dans "$Fichier"
    } else {
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesSequencesSurLesBandesCytologiques {{Save ""}} {

    global RepertoireDuGenome

    set FichierLocalisation  "$RepertoireDuGenome/Localisation/BoxLocalisation_Human"
    if {![file exists $FichierLocalisation]} {return ""}

    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {
	Espionne "$FichierBandesCytos does not exist"
	return ""
    }
    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {
	Espionne "$FichierContigs does not exist"
	return ""
    }
    set FichierFold "$RepertoireDuGenome/fiches/FoldExpression"
    if {![file exists $FichierFold]} {
	set Fold 0
    } else {
	set Fold 1
	ChargeFoldDesSequences Expression
    }

    ChargeFichierLocalisation   MesSequences $FichierLocalisation
    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des bandes ################
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set nChromosome [NumeroDuChromosome $Chromosome]
	if {![info exists Contigs($nChromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set PosIni 0
	foreach Bande $LesBandesCytologiques {
	    set LesInfos    [set LesBandesCytos($Chromosome,$Bande)]
	    set Position    [lindex $LesInfos 0]
	    set Position    [expr round($Position * 1E6)]
	    set TailleBande [expr round($Position-$PosIni)]
	    set PosIni $Position

	    set Tableau($Bande,NbSeq)   0

	    if {$Fold} {
		set Tableau($Bande,NbSeqPlus)   0
		set Tableau($Bande,NbSeqMinus)  0
		set Tableau($Bande,NbSeqNoInf)  0
	    }
	    set Tableau($Bande,Taille)  $TailleBande
	}
    }
    #########Mes sequences#####################
    Espionne "Seq research in cytologic bandes ... please wait"

    foreach Nom      [set MesSequences($FichierLocalisation,LesNoms)] {
	foreach LInfo [set MesSequences($FichierLocalisation,Nom,$Nom)] {

	    set InfoLoc  [lindex $LInfo 1 ]
	    if {$InfoLoc != "MonoLoc" && $InfoLoc != "MayBePolyLoc"} {continue}
	    set BestLoc  [lindex $LInfo 20]
	    if {$BestLoc != "BestLoc"                              } {continue}

	    set Contig   [lindex $LInfo 13]
	    if {![info exists Contigs($Contig)]                    } {continue}
	    set Sens    [lindex $LInfo 12]
	    if {$Sens == 0                                         } {continue}
	    set Nom      [lindex $LInfo 0 ]
	    if {[info exists TabTmp($Nom)]                         } {continue}
	    set TabTmp($Nom) 1

	    set nChromosome [NumeroDuChromosome [lindex [set Contigs($Contig)] 0]]
	    set Debut   [lindex $LInfo 10]
	    set Fin     [lindex $LInfo 11]

	    set LesBandesOccupees [LesBandesCytologiquesDeLaRegion $nChromosome $Debut $Fin]
	    foreach LaBande $LesBandesOccupees {
		set Bande  [lindex $LaBande 0]
		incr Tableau($Bande,NbSeq)
		
		if {$Fold} {
		    if {[set Expression($Nom)] == "+"} {
			incr Tableau($Bande,NbSeqPlus)
		    } elseif {[set Expression($Nom)] == "-"} {
			incr Tableau($Bande,NbSeqMinus)
		    } else {
			incr Tableau($Bande,NbSeqNoInf)
		    }
		}
		
	    }
	}
    }
    #############Texte ################
    set Texte ""
    foreach Chromosome [set LesBandesCytos(LesChromosomes)] {
	set NbSeqTot 0
	set nChromosome [NumeroDuChromosome $Chromosome]
	if {![info exists Contigs($nChromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($nChromosome,Taille)]

	set LesBandesP             [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]]
	set LesBandesQ             [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]]
	set LesBandesCytologiques  $LesBandesP
	foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ}

	set LaLegende                    [list "Chromosome"  "Length"            "Type"      "Var"            ]
	set LesNbSeq                     [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbSeq"   ]
	if {$Fold} {
	    set LesNbSeqPlus             [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbSeqPlus"]
	    set LesNbSeqMinus            [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbSeqMinus"]
	    set LesNbSeqNoInf            [list "$nChromosome" "$TailleChromosome" "Cytologic" "NbSeqNoInf"]
	}
	set LesTaillesDesBandes [list "$nChromosome" "$TailleChromosome" "Cytologic" "Length"        ]

	foreach Bande $LesBandesCytologiques {
	    lappend LaLegende            $Bande
	    lappend LesNbSeq             [set Tableau($Bande,NbSeq)   ]

	    if {$Fold} {
		lappend LesNbSeqPlus             [set Tableau($Bande,NbSeqPlus)    ]
		lappend LesNbSeqMinus            [set Tableau($Bande,NbSeqMinus)   ]
		lappend LesNbSeqNoInf            [set Tableau($Bande,NbSeqNoInf)   ]
	    }
	    lappend LesTaillesDesBandes  [set Tableau($Bande,Taille)  ]
	}
	append Texte [join "$LaLegende"               "\t"]      ;append Texte "\n"
	append Texte [join "$LesNbSeq"                "\t"]      ;append Texte "\n"

	if {$Fold} {
	    append Texte [join "$LesNbSeqPlus"        "\t"]      ;append Texte "\n"
	    append Texte [join "$LesNbSeqMinus"       "\t"]      ;append Texte "\n"
	    append Texte [join "$LesNbSeqNoInf"       "\t"]      ;append Texte "\n"
	}
	append Texte [join "$LesTaillesDesBandes" "\t"] ;append Texte "\n"    
    }
    Espionne $Texte
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier "$Rep/cyto_Distribution"
    if {$Save == "Save"} {
	if {![file exists $Rep]} {File mkdir $Rep}
	Sauve $Texte dans "$Fichier"
    } else {
	if {![file exists $Rep]} {File mkdir $Rep}
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesSequencesSurLesChromosomes {{Save ""}} {

    global RepertoireDuGenome

    set FichierLocalisation "$RepertoireDuGenome/Localisation/BoxLocalisation_Human"
    if {![file exists $FichierLocalisation]} {
	FaireLire "$FichierLocalisation doesn't exist.\nI am going to create it." 
	return ""
    }
    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {
	Espionne "$FichierContigs does not exist"
	return ""
    }
    set FichierFold "$RepertoireDuGenome/fiches/FoldExpression"
    if {![file exists $FichierFold]} {
	set Fold 0
    } else {
	set Fold 1
	ChargeFoldDesSequences Expression
    }

    ChargeContigsDesChromosomes Contigs      $FichierContigs
    ChargeFichierLocalisation   MesSequences $FichierLocalisation

    #############Initialisation des chromosomes###########
    foreach Chromosome [set Contigs(LesChromosomes)] { 
	set Tableau($Chromosome,NbSeqInCtgNP)   0
	set Tableau($Chromosome,NbSeqInCtgP)    0

	if {$Fold} {
	    set Tableau($Chromosome,NbSeqPlusInCtgNP)    0
	    set Tableau($Chromosome,NbSeqPlusInCtgP)     0
	    set Tableau($Chromosome,NbSeqMinusInCtgNP)   0
	    set Tableau($Chromosome,NbSeqMinusInCtgP)    0
	    set Tableau($Chromosome,NbSeqNoInfInCtgNP)   0
	    set Tableau($Chromosome,NbSeqNoInfInCtgP)    0
	}
    }
    if {$Fold} {
	set Tableau(NbSeqPlusInWCtg)    0
	set Tableau(NbSeqPlusExcl)      0
	set Tableau(NbSeqMinusInWCtg)   0
	set Tableau(NbSeqMinusExcl)     0
	set Tableau(NbSeqNoInfInWCtg)   0
	set Tableau(NbSeqNoInfExcl)     0
    }
    set Tableau(NbSeqInWCtg)        0
    set Tableau(NbSeqExcl)          0
    
    ###########Nb sequences dans chaque chromosome#############
    foreach Nom      [set MesSequences($FichierLocalisation,LesNoms)] {
	foreach LInfo [set MesSequences($FichierLocalisation,Nom,$Nom)] {
	    set Nom      [lindex $LInfo 0 ]
	    set InfoLoc  [lindex $LInfo 1 ]
	    set BestLoc  [lindex $LInfo 20]
	    if {($InfoLoc == "NoLoc" || $InfoLoc == "MayBePolyLoc") && $BestLoc != "BestLoc"} {continue}

	    if {[info exists TabTmp($Nom)]} {continue}
	    set TabTmp($Nom) 1

	    if {    $InfoLoc != "MonoLoc" && $InfoLoc != "MayBePolyLoc"} {
		if {$Fold} {
		    set Expr [set Expression($Nom)]
		    if {      $Expr == "+"} {
			incr Tableau(NbSeqPlusExcl)
		    } elseif {$Expr == "-"} {
			incr Tableau(NbSeqMinusExcl)
		    } else {
			incr Tableau(NbSeqNoInfExcl)
		    }
		}
		incr Tableau(NbSeqExcl)
		continue
	    }
	    set Contig   [lindex $LInfo 13]
	    if {![info exists Contigs($Contig)]} {
		if {$Fold} {
		    set Expr [set Expression($Nom)]
		    if {      $Expr == "+"} {
			incr Tableau(NbSeqPlusInWCtg)
		    } elseif {$Expr == "-"} {
			incr Tableau(NbSeqMinusInWCtg)
		    } else {
			incr Tableau(NbSeqNoInfInWCtg)
		    }
		}
		incr Tableau(NbSeqInWCtg)
		continue
	    } else {
		set LesInfosDuContig [set Contigs($Contig)      ]
		set Sens             [lindex $LesInfosDuContig 3]
		set Chromosome       [lindex $LesInfosDuContig 0]
		if {$Sens == "0"} {
		    if {$Fold} {
			set Expr [set Expression($Nom)]
			if {      $Expr == "+"} {
			    incr Tableau($Chromosome,NbSeqPlusInCtgNP)
			} elseif {$Expr == "-"} {
			    incr Tableau($Chromosome,NbSeqMinusInCtgNP)
			} else {
			    incr Tableau($Chromosome,NbSeqNoInfInCtgNP)
			}
		    }
		    incr Tableau($Chromosome,NbSeqInCtgNP)
		} else {
		    if {$Fold} {
			set Expr [set Expression($Nom)]
			if {      $Expr == "+"} {
			    incr Tableau($Chromosome,NbSeqPlusInCtgP)
			} elseif {$Expr == "-"} {
			    incr Tableau($Chromosome,NbSeqMinusInCtgP)
			} else {
			    incr Tableau($Chromosome,NbSeqNoInfInCtgP)
			}
		    }
		    incr Tableau($Chromosome,NbSeqInCtgP)
		}
	    }
	}
    }
    #######Tableau#################
    set SeqInCtgPTot    0
    set SeqInCtgNPTot   0
    if {$Fold} {
	set SeqPlusInCtgPTot     0
	set SeqPlusInCtgNPTot    0
	set SeqMinusInCtgPTot    0
	set SeqMinusInCtgNPTot   0
	set SeqNoInfInCtgPTot    0
	set SeqNoInfInCtgNPTot   0
    }
    set TailleTot       0

    if {$Fold} {
	set Texte "Chromosome\tLength\tSeqInCtgP\tSeqInCtgNP\tSeqExcl\tSeqInWCtg\tSeqPlusInCtgP\tSeqPlusInCtgNP\tSeqPlusExcl\tSeqPlusInWCtg\tSeqMinusInCtgP\tSeqMinusInCtgNP\tSeqMinusExcl\tSeqMinusInWCtg\tSeqNoInfInCtgP\tSeqNoInfInCtgNP\tSeqNoInfExcl\tSeqNoInfInWCtg"
    } else {
	set Texte "Chromosome\tLength\tSeqInCtgP\tSeqInCtgNP\tSeqExcl\tSeqInWCtg"
    }

    foreach Chromosome   [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]] {
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set Taille       [set Contigs($Chromosome,Taille)        ]
	set SeqInCtgP    [set Tableau($Chromosome,NbSeqInCtgP)   ]
	set SeqInCtgNP   [set Tableau($Chromosome,NbSeqInCtgNP)  ]

	if {$Fold} {
	    set SeqPlusInCtgP    [set Tableau($Chromosome,NbSeqPlusInCtgP)   ]
	    set SeqPlusInCtgNP   [set Tableau($Chromosome,NbSeqPlusInCtgNP)  ]
	    set SeqMinusInCtgP    [set Tableau($Chromosome,NbSeqMinusInCtgP)   ]
	    set SeqMinusInCtgNP   [set Tableau($Chromosome,NbSeqMinusInCtgNP)  ]
	    set SeqNoInfInCtgP    [set Tableau($Chromosome,NbSeqNoInfInCtgP)   ]
	    set SeqNoInfInCtgNP   [set Tableau($Chromosome,NbSeqNoInfInCtgNP)  ]

	    append Texte "\n$Chromosome\t$Taille\t$SeqInCtgP\t$SeqInCtgNP\t0\t0\t$SeqPlusInCtgP\t$SeqPlusInCtgNP\t0\t0\t$SeqMinusInCtgP\t$SeqMinusInCtgNP\t0\t0\t$SeqNoInfInCtgP\t$SeqNoInfInCtgNP\t0\t0"

	    incr SeqPlusInCtgPTot     $SeqPlusInCtgP
	    incr SeqPlusInCtgNPTot    $SeqPlusInCtgNP
	    incr SeqMinusInCtgPTot    $SeqMinusInCtgP
	    incr SeqMinusInCtgNPTot   $SeqMinusInCtgNP
	    incr SeqNoInfInCtgPTot    $SeqNoInfInCtgP
	    incr SeqNoInfInCtgNPTot   $SeqNoInfInCtgNP
	} else {
	    append Texte "\n$Chromosome\t$Taille\t$SeqInCtgP\t$SeqInCtgNP\t0\t0"
	}
	incr SeqInCtgPTot    $SeqInCtgP
	incr SeqInCtgNPTot   $SeqInCtgNP
	incr TailleTot       $Taille
    }
    set SeqInWCtg        [set Tableau(NbSeqInWCtg)               ]
    set SeqExcl          [set Tableau(NbSeqExcl)                 ]
    
    if {$Fold} {
	set SeqPlusInWCtg        [set Tableau(NbSeqPlusInWCtg)               ]
	set SeqPlusExcl          [set Tableau(NbSeqPlusExcl)                 ]
	set SeqMinusInWCtg        [set Tableau(NbSeqMinusInWCtg)               ]
	set SeqMinusExcl          [set Tableau(NbSeqMinusExcl)                 ]
	set SeqNoInfInWCtg        [set Tableau(NbSeqNoInfInWCtg)               ]
	set SeqNoInfExcl          [set Tableau(NbSeqNoInfExcl)                 ]
	append Texte "\nRemaining\t0\t0\t0\t$SeqExcl\t$SeqInWCtg\t0\t0\t$SeqPlusExcl\t$SeqPlusInWCtg\t0\t0\t$SeqMinusExcl\t$SeqMinusInWCtg\t0\t0\t$SeqNoInfExcl\t$SeqNoInfInWCtg"

	append Texte "\nTotal\t$TailleTot\t$SeqInCtgPTot\t$SeqInCtgNPTot\t$SeqExcl\t$SeqInWCtg\t$SeqPlusInCtgPTot\t$SeqPlusInCtgNPTot\t$SeqPlusExcl\t$SeqPlusInWCtg\t$SeqMinusInCtgPTot\t$SeqMinusInCtgNPTot\t$SeqMinusExcl\t$SeqMinusInWCtg\t$SeqNoInfInCtgPTot\t$SeqNoInfInCtgNPTot\t$SeqNoInfExcl\t$SeqNoInfInWCtg"
    } else {
	append Texte "\nRemaining\t0\t0\t0\t$SeqExcl\t$SeqInWCtg"
	append Texte "\nTotal\t$TailleTot\t$SeqInCtgPTot\t$SeqInCtgNPTot\t$SeqExcl\t$SeqInWCtg"
    }

    Espionne $Texte
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier "$Rep/chr_Distribution"
    if {$Save == "Save"} {
	if {![file exists $Rep]} {File mkdir $Rep}
	Sauve $Texte dans "$Fichier"
    } else {
	if {![file exists $Rep]} {File mkdir $Rep}
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesSequencesSurLesContigs {{Save ""}} {

    global RepertoireDuGenome

    set FichierLocalisation "$RepertoireDuGenome/Localisation/BoxLocalisation_Human"
    if {![file exists $FichierLocalisation]} {return ""}

    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {
	Espionne "$FichierContigs does not exist"
	return ""
    }

    set FichierFold "$RepertoireDuGenome/fiches/FoldExpression"
    if {![file exists $FichierFold]} {
	set Fold 0
    } else {
	set Fold 1
	ChargeFoldDesSequences Expression
    }

    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeFichierLocalisation   MesSequences $FichierLocalisation
    ##########Initialisation des contigs###########
    set Tableau(NbSeqExcl)     0
    set Tableau(NbSeqInWCtg)   0

    if {$Fold} {
	set Tableau(NbSeqPlusExcl)      0
	set Tableau(NbSeqPlusInWCtg)    0
	set Tableau(NbSeqMinusExcl)     0
	set Tableau(NbSeqMinusInWCtg)   0
	set Tableau(NbSeqNoInfExcl)     0
	set Tableau(NbSeqNoInfInWCtg)   0
    }

    foreach Contig [set Contigs(LesContigs)] {
	set Tableau($Contig,NbSeqInCtgNP)   0
	set Tableau($Contig,NbSeqInCtgP)    0

	if {$Fold} {
	    set Tableau($Contig,NbSeqPlusInCtgNP)   0
	    set Tableau($Contig,NbSeqPlusInCtgP)    0
	    set Tableau($Contig,NbSeqMinusInCtgNP)   0
	    set Tableau($Contig,NbSeqMinusInCtgP)    0
	    set Tableau($Contig,NbSeqNoInfInCtgNP)   0
	    set Tableau($Contig,NbSeqNoInfInCtgP)    0
	}
    }
    #########Mes sequences#####################
    foreach Nom      [set MesSequences($FichierLocalisation,LesNoms)] {
	foreach LInfo [set MesSequences($FichierLocalisation,Nom,$Nom)] {
	    set Nom      [lindex $LInfo 0 ]
	    if {[info exists TabTmp($Nom)]                         } {continue}
	    set TabTmp($Nom) 1

	    set InfoLoc  [lindex $LInfo 1 ]
	    if {$InfoLoc != "MonoLoc" && $InfoLoc != "MayBePolyLoc"} {
		incr Tableau(NbSeqExcl)
		if {$Fold} {
		    if {[set Expression($Nom)] == "+"} {
			incr Tableau(NbSeqPlusExcl)
		    } elseif {[set Expression($Nom)] == "-"} {
			incr Tableau(NbSeqMinusExcl)
		    } else {
			incr Tableau(NbSeqNoInfExcl)
		    }
		}
		continue
		continue
	    }
	    set BestLoc  [lindex $LInfo 20]
	    if {$BestLoc != "BestLoc"                              } {continue}

	    set Contig   [lindex $LInfo 13]
	    set Sens    [lindex $LInfo 12]
	    if {![info exists Contigs($Contig)]} {
		incr Tableau(NbSeqInWCtg)
		if {$Fold} {
		    if {[set Expression($Nom)] == "+"} {
			incr Tableau(NbSeqPlusInWCtg)
		    } elseif {[set Expression($Nom)] == "-"} {
			incr Tableau(NbSeqMinusInWCtg)
		    } else {
			incr Tableau(NbSeqNoInfInWCtg)
		    }
		}
		continue
	    } else {
		set LesInfosDuContig [set Contigs($Contig)      ]
		set Sens             [lindex $LesInfosDuContig 3]
		if {$Sens == 0} {
		    incr Tableau($Contig,NbSeqInCtgNP)
		    
		    if {$Fold} {
			if {[set Expression($Nom)] == "+"} {
			    incr Tableau($Contig,NbSeqPlusInCtgNP)
			} elseif {[set Expression($Nom)] == "-"} {
			    incr Tableau($Contig,NbSeqMinusInCtgNP)
			} else {
			    incr Tableau($Contig,NbSeqNoInfInCtgNP)
			}
		    }
		} else {
		    incr Tableau($Contig,NbSeqInCtgP)
		    if {$Fold} {
			if {[set Expression($Nom)] == "+"} {
			    incr Tableau($Contig,NbSeqPlusInCtgP)
			} elseif {[set Expression($Nom)] == "-"} {
			    incr Tableau($Contig,NbSeqMinusInCtgP)
			} else {
			    incr Tableau($Contig,NbSeqNoInfInCtgP)
			}
		    }
		}
	    }
	}
    }
    ###########Texte#######################
    set Texte ""
    set LesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $LesChromosomes {
	set NbSeqTot 0
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($Chromosome,Taille)]

	set LesContigs [set Contigs($Chromosome,LesContigs)]
	set LaLegende            [list "Chromosome"  "Length"            "Type"   "Var"         ]
	set LesNbSeqInCtgP       [list "$Chromosome" "$TailleChromosome" "Contig" "SeqInCtgP"   ]
	set LesNbSeqInCtgNP      [list "$Chromosome" "$TailleChromosome" "Contig" "SeqInCtgNP"  ]

	if {$Fold} {
	    set LesNbSeqPlusInCtgP       [list "$Chromosome" "$TailleChromosome" "Contig" "SeqPlusInCtgP"   ]
	    set LesNbSeqPlusInCtgNP      [list "$Chromosome" "$TailleChromosome" "Contig" "SeqPlusInCtgNP"  ]
	    set LesNbSeqMinusInCtgP     [list "$Chromosome" "$TailleChromosome" "Contig" "SeqMinusInCtgP"   ]
	    set LesNbSeqMinusInCtgNP    [list "$Chromosome" "$TailleChromosome" "Contig" "SeqMinusInCtgNP"  ]
	    set LesNbSeqNoInfInCtgP     [list "$Chromosome" "$TailleChromosome" "Contig" "SeqNoInfInCtgP"   ]
	    set LesNbSeqNoInfInCtgNP    [list "$Chromosome" "$TailleChromosome" "Contig" "SeqNoInfInCtgNP"  ]
	}

	set LesSensDesContigs    [list "$Chromosome" "$TailleChromosome" "Contig" "Sens"        ]
	set LesTaillesDesContigs [list "$Chromosome" "$TailleChromosome" "Contig" "Length"      ]
	foreach Contig $LesContigs {
	    set LesInfosDuContig        [set Contigs($Chromosome,$Contig)    ]
	    set Debut                   [lindex $LesInfosDuContig 0          ]
	    set Fin                     [lindex $LesInfosDuContig 1          ]
	    set TailleContig            [expr $Fin - $Debut  + 1             ] 
	    set Sens                    [lindex $LesInfosDuContig 2          ]

	    lappend LaLegende            $Contig
	    lappend LesNbSeqInCtgP       [set Tableau($Contig,NbSeqInCtgP)   ]
	    lappend LesNbSeqInCtgNP      [set Tableau($Contig,NbSeqInCtgNP)  ]

	    if {$Fold} {
		lappend LesNbSeqPlusInCtgP       [set Tableau($Contig,NbSeqPlusInCtgP)   ]
		lappend LesNbSeqPlusInCtgNP      [set Tableau($Contig,NbSeqPlusInCtgNP)  ]
		lappend LesNbSeqMinusInCtgP       [set Tableau($Contig,NbSeqMinusInCtgP)   ]
		lappend LesNbSeqMinusInCtgNP      [set Tableau($Contig,NbSeqMinusInCtgNP)  ]
		lappend LesNbSeqNoInfInCtgP       [set Tableau($Contig,NbSeqNoInfInCtgP)   ]
		lappend LesNbSeqNoInfInCtgNP      [set Tableau($Contig,NbSeqNoInfInCtgNP)  ]
	    }

	    lappend LesSensDesContigs    $Sens
	    lappend LesTaillesDesContigs $TailleContig
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbSeqInCtgP"       "\t"];append Texte "\n"
	append Texte [join "$LesNbSeqInCtgNP"      "\t"];append Texte "\n"

	if {$Fold} {
	    append Texte [join "$LesNbSeqPlusInCtgP"       "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqPlusInCtgNP"      "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqMinusInCtgP"       "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqMinusInCtgNP"      "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqNoInfInCtgP"       "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqNoInfInCtgNP"      "\t"];append Texte "\n"
	}

	append Texte [join "$LesSensDesContigs"    "\t"];append Texte "\n"
	append Texte [join "$LesTaillesDesContigs" "\t"];append Texte "\n"
    }

    Espionne $Texte
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier "$Rep/ctg_Distribution"
    if {$Save == "Save"} {
	if {![file exists $Rep]} {File mkdir $Rep}
	Sauve $Texte dans "$Fichier"
    } else {
	if {![file exists $Rep]} {File mkdir $Rep}
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DistributionDesSequencesSurLesRegions {{TailleRegion 1e6} {Save ""}} {

    global RepertoireDuGenome

    set FichierLocalisation  "$RepertoireDuGenome/Localisation/BoxLocalisation_Human"
    if {![file exists $FichierLocalisation]} {return ""}
    set RepLocalisation      "[HumanGenomeDir]/Localisation"
    set FichierBandesCytos   "$RepLocalisation/CytologicMap"
    if {![file exists $FichierBandesCytos]} {
	Espionne "$FichierBandesCytos does not exist"
	return ""
    }
    set RepLocalisation "[HumanGenomeDir]/Localisation"
    set FichierContigs      "$RepLocalisation/seq_contig.md"
    if {![file exists $FichierContigs]} {
	Espionne "$FichierContigs does not exist"
	return ""
    }
    set FichierFold "$RepertoireDuGenome/fiches/FoldExpression"
    if {![file exists $FichierFold]} {
	set Fold 0
    } else {
	set Fold 1
	ChargeFoldDesSequences Expression
    }

    ChargeFichierLocalisation   MesSequences $FichierLocalisation
    ChargeContigsDesChromosomes Contigs $FichierContigs
    ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos

    #############Initialisation des regions ################
    set TousLesChromosomes [lsort -command CompareSeulementLesNombres [set Contigs(LesChromosomes)]]
    foreach Chromosome $TousLesChromosomes {
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set TailleChromosome [set Contigs($Chromosome,Taille)]
	set Reste            [expr round($TailleChromosome) % round($TailleRegion)]
	set NbRegions        [expr round (($TailleChromosome/$TailleRegion)-0.5)]

	set Tab($Chromosome,DerniereRegion) $Reste

	set DebutRegion 1
	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set FinRegion [expr round($DebutRegion + $TailleRegion - 1)]
	    set Tab($Chromosome,$i,NbSeq)   0
	    
	    if {$Fold} {
		set Tab($Chromosome,$i,NbSeqPlus)    0
		set Tab($Chromosome,$i,NbSeqMinus)   0
		set Tab($Chromosome,$i,NbSeqNoInf)   0
	    }

	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion

	    set DebutRegion [expr $FinRegion + 1]
	}
	if {$Reste != 0} {
	    set Tab($Chromosome,NbRegions)  [expr $NbRegions + 1]
	    set FinRegion                   [expr $DebutRegion + $Reste]
	    set Tab($Chromosome,$i,Debut)   $DebutRegion
	    set Tab($Chromosome,$i,Fin)     $FinRegion
	    set Tab($Chromosome,$i,NbSeq)   0

	    if {$Fold} {
		set Tab($Chromosome,$i,NbSeqPlus)    0
		set Tab($Chromosome,$i,NbSeqMinus)   0
		set Tab($Chromosome,$i,NbSeqNoInf)   0
	    }
	} else {
	    set Tab($Chromosome,NbRegions)  $NbRegions
	}
    }
    #########Mes sequences#####################
    
    foreach Nom      [set MesSequences($FichierLocalisation,LesNoms)] {
	foreach LInfo [set MesSequences($FichierLocalisation,Nom,$Nom)] {
	    set InfoLoc  [lindex $LInfo 1 ]
	    if {$InfoLoc != "MonoLoc" && $InfoLoc != "MayBePolyLoc"} {continue}
	    set BestLoc  [lindex $LInfo 20]
	    if {$BestLoc != "BestLoc"                              } {continue}
	    set Contig   [lindex $LInfo 13]
	    if {![info exists Contigs($Contig)]                    } {continue}
	    set Sens    [lindex $LInfo 12]
	    if {$Sens == 0                                         } {continue}
	    set Chromosome [lindex [set Contigs($Contig)] 0]
	    if {![info exists Contigs($Chromosome,Taille)]         } {continue}
	    set TailleChromosome [set Contigs($Chromosome,Taille)]
	    set Nom      [lindex $LInfo 0 ]
	    if {[info exists TabTmp($Nom)]                         } {continue}
	    set TabTmp($Nom) 1

	    set Debut   [lindex $LInfo 10]
	    set Fin     [lindex $LInfo 11]
	    for {set i 1} {$i <= [set Tab($Chromosome,NbRegions)]} {incr i} {
		set DebutRegion  [set Tab($Chromosome,$i,Debut)]
		set FinRegion    [set Tab($Chromosome,$i,Fin)  ]
		
		if {    ($DebutRegion < $Debut       && $Fin       <= $FinRegion) || ($DebutRegion < $Fin         && $Fin       <= $FinRegion) || ($DebutRegion < $Debut       && $Debut     <= $FinRegion) || ($Debut       < $DebutRegion && $FinRegion <= $Fin      ) } {
		    incr Tab($Chromosome,$i,NbSeq)
		    
		    if {$Fold} {
			if {[set Expression($Nom)] == "+"} {
			    incr Tab($Chromosome,$i,NbSeqPlus)
			} elseif {[set Expression($Nom)] == "-"} {
			    incr Tab($Chromosome,$i,NbSeqMinus)
			} else {
			    incr Tab($Chromosome,$i,NbSeqNoInf)
			}
		    }
		}
	    }
	}
    }
    #############Texte ################
    set Texte ""
    foreach Chromosome $TousLesChromosomes {
	if {![info exists Tab($Chromosome,NbRegions)]} {continue}
	set NbRegions           [set Tab($Chromosome,NbRegions)]
	if {![info exists Contigs($Chromosome,Taille)]} {continue}
	set TailleChromosome    [set Contigs($Chromosome,Taille)]
	if {$TailleChromosome == 0} {continue}

	set LaLegende            [list "Chromosome"  "Length"            "Type"  "Var"         ]
	set LesNbSeq             [list "$Chromosome" "$TailleChromosome" "area${TailleRegion}bp" "NbSeq"   ]
	if {$Fold} {
	    set LesNbSeqPlus     [list "$Chromosome" "$TailleChromosome" "area${TailleRegion}bp" "NbSeqPlus"]
	    set LesNbSeqMinus    [list "$Chromosome" "$TailleChromosome" "area${TailleRegion}bp" "NbSeqMinus"]
	    set LesNbSeqNoInf    [list "$Chromosome" "$TailleChromosome" "area${TailleRegion}bp" "NbSeqNoInf"]
	}
	set LesTaillesDesRegions [list "$Chromosome" "$TailleChromosome" "area${TailleRegion}bp" "Length"      ]

	for {set i 1} {$i <= $NbRegions} {incr i} {
	    set DebutRegion  [set Tab($Chromosome,$i,Debut)  ] 
	    set FinRegion    [set Tab($Chromosome,$i,Fin)    ] 
	    set NbSeq        [set Tab($Chromosome,$i,NbSeq)  ]

	    if {$Fold} {
		set NbSeqPlus        [set Tab($Chromosome,$i,NbSeqPlus)  ]
		set NbSeqMinus       [set Tab($Chromosome,$i,NbSeqMinus)  ]
		set NbSeqNoInf       [set Tab($Chromosome,$i,NbSeqNoInf)  ]
	    }
	    
	    if {$i == $NbRegions} {
		set TailleArea [set Tab($Chromosome,DerniereRegion)] 
	    } else {
		set TailleArea $TailleRegion
	    }
	    lappend LaLegende            $i
	    lappend LesNbSeq             $NbSeq
	    if {$Fold} {
		lappend LesNbSeqPlus             $NbSeqPlus
		lappend LesNbSeqMinus            $NbSeqMinus
		lappend LesNbSeqNoInf            $NbSeqNoInf
	    }

	    lappend LesTaillesDesRegions $TailleArea
	}
	append Texte [join "$LaLegende"            "\t"];append Texte "\n"
	append Texte [join "$LesNbSeq"             "\t"];append Texte "\n"
	if {$Fold} {
	    append Texte [join "$LesNbSeqPlus"             "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqMinus"             "\t"];append Texte "\n"
	    append Texte [join "$LesNbSeqNoInf"             "\t"];append Texte "\n"
	}
	append Texte [join "$LesTaillesDesRegions" "\t"];append Texte "\n" 
    }
    Espionne $Texte
    set Rep "$RepertoireDuGenome/Localisation"
    set Fichier "$Rep/area${TailleRegion}bp_Distribution"
    if {$Save == "Save"} {
	if {![file exists $Rep]} {File mkdir $Rep}
	Sauve $Texte dans "$Fichier"
    } else {
	if {![file exists $Rep]} {File mkdir $Rep}
	if {[OuiOuNon "Would you want to save these Results?\n$Fichier"]} {
	    Sauve $Texte dans "$Fichier"
	}
    }
    return "$Texte\n\nsave in $Fichier"

}

proc DiviseLeFichierDesGenes {FichierGenes} {

    set Rep [file dirname $FichierGenes]
    set F [open $FichierGenes]
    while {[gets $F Ligne]>=0} {
	if {![regexp "^chr" $Ligne]} {continue}
	scan $Ligne "%s " Chromosome
	regexp -nocase {(chr[0-9a-z]*)} $Chromosome tmp Chromosome
	if {![info exists ChromosomeDeRef]} {
	    set GenesDuChromosome ""
	    set ChromosomeDeRef $Chromosome
	}
	if {$Chromosome == $ChromosomeDeRef} {
	    append GenesDuChromosome "$Ligne\n"
	} else {
	    puts "$ChromosomeDeRef"
	    Sauve $GenesDuChromosome dans "$Rep/${ChromosomeDeRef}_genes.gtf"
	    set GenesDuChromosome ""
	    set ChromosomeDeRef $Chromosome
	}
    }
    close $F
    puts "$ChromosomeDeRef"
    Sauve $GenesDuChromosome dans "$Rep/${ChromosomeDeRef}_genes.gtf"
    return ""

}

proc DiviseLeGO {K Type LesGO} {

    set Id      [$K find withtag current]
    set MesTags [$K gettags $Id]

    set Definition           [lindex $MesTags 1]
    scan $Definition "%s %s" GOSelected Definition

    set LesNewGO {}
    foreach GO $LesGO {
	if {$GO != $GOSelected} {lappend LesNewGO $GO;continue}

	set LesDescendants [concat [Onto $Type $GO LesEnfants] [Onto $Type $GO LesContributions]]

	if {$LesDescendants == {}} {return $LesGO}
	foreach GO $LesDescendants {
	    lappend LesNewGO $GO
	}
    }
    set LesGO [ElimineLesRedondancesDansUneListe $LesNewGO]
    IllustreLeCamembertOntologique $Type $LesGO
    return $LesGO

}

proc DmelTransMem {} {

    foreach Fichier [glob "/home/poch/transmbn/AE*"] {
	set OnAttendGi 1
	set OnAttendHP 0
	set Descript ""
	set HP ""
	set PNT -1
	set LaSeq ""
	set L 9999
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    Espionne $Ligne
	    if { ! [regexp -nocase {[A-Z0-9]} $Ligne]} { continue }
	    if {[regexp "Helices Position" $Ligne]} {
		set OnAttendHP 1
		continue
	    }
	    if {[regexp "Predicted Number" $Ligne]} {
		set PNT [IntegerApres ":" dans $Ligne]
		continue
	    }
	    if {$OnAttendHP} {
		if { ! [regexp {^[0-9\,\-]+$} $Ligne]} {
		    FaireLire "$Ligne\nis not a helix position line in\n$Fichier"
		    set HP ""
		} else { 
		    set HP $Ligne
		}
		set OnAttendHP 0
		continue
	    }
	    if {[regexp {^gi\|} $Ligne]} {
		if {$OnAttendGi} { set OnAttendGi 0 ; continue }
		set Sequence [join $LaSeq ""]
		if {[string length $Sequence]!=$L} {
		    FaireLire "$Sequence \nis not ok. != $L"
		}
		CreeTfaDmelTransMem $Descript $Sequence $HP $PNT
		set Descript ""
		set HP ""
		set PNT -1
		set LaSeq ""

		regsub {gi\|} $Ligne "gi:" Ligne
		regsub {\|gb\|} $Ligne " gb:" Ligne
		regsub -all {\|} $Ligne "" Ligne
		set Descript $Ligne
		continue
	    }
	    if {$OnAttendGi} { continue }
	    if {[regexp {Sequence Length\:} $Ligne]} {
		set L [IntegerApres ":" dans $Ligne ]
		continue
	    }
	    if {[regexp -nocase {[^A-Z]} $Ligne]} {
		if { ! [regexp -nocase {[a-z]*\]} $Ligne]} {
		    FaireLire "$Ligne\n is not a sequence\n ... see $Fichier"
		}
		append Descript $Ligne
		continue
	    }
	    lappend LaSeq $Ligne
	}
	CreeTfaDmelTransMem $Descript $Sequence $HP $PNT
     }

}

proc DoAllPourTous {{Premier ""} {Dernier ""}} {

    #rR c'est ici qu'on lance tout ...
    #rR Attention les noms de fiheirs ne sont pas encore spécifique au MappingOfMotifsWithLengtAndCardinality ... A faire.
    if {$Premier==""} { set Premier  1 }
    if {$Dernier==""} { set Dernier 25 }
    CreateChrAnnotFiles
    set LesFicInfos {}
    foreach Chr [ListOfChr] {
	Espionne $Chr
	AnnotXdn $Chr
	AnnotXdnFinal $Chr
	set FicInfos [InfosEtBornesDuFinal $Chr]
	lappend LesFicInfos $FicInfos 
    }
    CreateAllChrFinal
    DecompteGeneral
    CreateMotifsMapping "DoAll"
    return "All is done"

}

proc DoArbre {} {

    global T LNOrdali
    
    set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08]
    array set T [ContenuDuFichier filsde.dat]

    package require struct

    set itree 0
    set inode 0
    for {set i 0} {$i < 8} {incr i} {
	set n1 [lindex $LNOrdali $i]
	if {$i == 7} {
	    set n2 s01
	} else {
	    set n2 [lindex $LNOrdali $i+1]
	}

	foreach k [lsort -dictionary [array names T "$n1,*"]] {
	    lassign [split $k ,] n1 ag1

	    set t [list "tree-$itree" {} [list name "n$n1-$ag1" agent $ag1 seq $n1 score 0.0]]

	    set Lf [lsearch -inline -exact -index 0 -all $T($k) $n2]
	    foreach f $Lf {
		lassign $f n2 ag2 sc2

		lappend t "node-$inode" 0 [list name "n$n2-$ag2" agent $ag2 seq $n2 score [format %6.3f $sc2]]
		incr inode
	    }
	    set nt [::struct::tree "tree-$itree"]
	    $nt deserialize $t

	    incr itree
	}
    }

    puts "$itree arbre pairs done"
    set ::Ltrees [info commands "tree-*"]
    puts "nb arbres [llength $::Ltrees]"

    # on a tous les arbres de type
    # T(n,ag) ((n+1 agi sc) (n+1 agi+1 sc) ...)

    set itree 0
    for {set i 0} {$i < 8} {incr i} {
	set n1 [lindex $LNOrdali $i]
	if {$i == 7} {
	    set n2 s01
	} else {
	    set n2 [lindex $LNOrdali $i+1]
	}

	foreach k [lsort -dictionary [array names T "$n1,*"]] {
	    lassign [split $k ,] n1 ag1
	    
	    set nt "::tree-$itree"
	    set st [$nt serialize]
	    set Lnodes [$nt nodes]
	    foreach l [lrange [$nt leaves] 0 50] {
		set i [lsearch $st $l]
		set lname [$nt get $l name]
		set trl [TreeDeLeaf $lname]
		set Lv [$trl serialize]
		foreach {nl il kl} [lrange $Lv 3 end] {
		    if {$nl in $Lnodes || $nl in $st} {
			puts "  => remplace $nl par node-$inode"
			set nl "node-$inode"
			incr inode
		    }
		    incr il $i
		    lappend st $nl $il $kl
		}
	    }
	    set lts [list]
	    foreach {n i k} $st {
		#puts "$n $i $k"
		if {$n in $lts} {
		    puts "deja dedans"
		    exit
		}
		lappend lts $n
	    }
	    $nt destroy
	    #puts "st \n$st\n"
	    set nt [::struct::tree $nt]
	    $nt deserialize $st
	}
    }

    set nbon 0
    set nseq [llength $LNOrdali]
    set itree 0
    foreach k [lsort -dictionary [array names T "s01,*"]] {
	set t "::tree-$itree"
	foreach l [$t leaves] {
	    set La [$t ancestors $l]
	    if {[llength $La] == $nseq || [llength $La] == ($nses+1)} {
		puts "\n$k\n[$t serialize]"
		incr nbon
	    }
	}
	incr itree
    }
    
    puts "\nnbon $nbon"

    exit
    
    set n1 s01
    set k [lindex [array names T "$n1,*"] 0]
    puts "$k"
    set n2 s02
    set f2 [lindex [lsearch -all -inline -exact -index 0 $T($k) $n2] 0]
    puts "$f2"
    lassign $f2 n2 ag2
    puts [llength $T($n2,$ag2)]
    set n3 s03
    set f3 [lindex [lsearch -all -inline -exact -index 0 $T($n2,$ag2) $n3] 0]
    puts "$f3"
    lassign $f3 n3 ag3

    exit

}

proc DoArrow {} {

    LoadTkAndPackages
    package require LRIPhoto

    set ar1 "0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 2 1 0 0 0 0 0
0 0 0 0 0 0 0 0 1 2 2 1 0 0 0 0
0 0 0 0 0 0 0 0 1 2 2 2 1 0 0 0
1 1 1 1 1 1 1 1 1 2 2 2 2 1 0 0
1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1
1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1
1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
1 1 1 1 1 1 1 1 1 2 2 2 2 1 0 0
0 0 0 0 0 0 0 0 1 2 2 2 1 0 0 0
0 0 0 0 0 0 0 0 1 2 2 1 0 0 0 0
0 0 0 0 0 0 0 0 1 2 1 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0"

set ar2 "1111111111111111
0111111111111110
0122222222222210
0122222222222210
0012222222222100
0012222222222100
0001222222221000
0001222222221000
0000122222210000
0000122222210000
0000012222100000
0000012222100000
0000001221000000
0000001221000000
0000000110000000
0000000110000000"

    foreach f {ar1 ar2} o {arrow1 arrow2} {
	set Lar [split [set $f] \n]
	set ph [image create photo -width 16 -height 16]
	set Ldata [list]
	foreach l $Lar {
	    lappend Ldata [string trim [string map {0 " #ffffff" 1 " #000000" 2 " #00ff00"} $l]]
	}
	$ph put $Ldata
	for {set i 0} {$i < 16} {incr i} {
	    for {set j 0} {$j < 16} {incr j} {
		if {[join [$ph get $i $j] ,] eq "255,255,255"} {
		    $ph transparency set $i $j 1
		}
	    }
	}
	$ph write "$o.gif"
	if {$o eq "arrow2"} {
	    ::LRI::imgtransform $ph -rotate 90
	} else {
	    ::LRI::imgtransform $ph -rotate 90
	}
	$ph write "${o}_rot.gif"
    }

    exit

}

proc DoDimer {system} {

    set sysdir $system
    set fbase [file join [MiSynPatDir] data structures $sysdir]
    set fin [file join $fbase ${system}_mon.pdb]
    set f1  "${system}_mon1.pdb"
    set f2  "${system}_mon2.pdb"
    
    puts ""
    puts "base $fbase"
    puts "fin  $fin"
    puts "f1   $f1"
    puts "f2   $f2"
    puts ""

    set o [open "|moleman " w]
    set chnA " A"
    set chnB " B"
    set cmd "READ
$fin
CHAI
$chnA
0 0
WRIT
$f1
Change chain to $chnA
Y
**
0 0
A
N
Y
N
N
READ
$fin
CHAI
$chnB
0 0
WRIT
$f2
Change chain to $chnB
Y
**
0 0
A
N
Y
N
N
QUIT
"
    puts $o $cmd
    flush $o
    update

    catch {close $o}

    return
    exit

}

proc DoLoop {} {

    global Ln iter

    interp recursionlimit {} 10000
    set iter 0
    set Ln [list s1  s2 s3 s4 s5 s6 s7 s8]
    Looping s1

    return

}

proc DoOneStep {} {

    set ::DoStep [expr {! $::DoStep}]

    return

}

proc DoRPlot {Lx Ly titre {f ""}} {
 
    # put max first
    if {[llength $Ly] > 1} {
	set max -999999.
	set i 0
	foreach y $Ly {
	    lassign $y Lv col lab
	    set mx [::tcl::mathfunc::max {*}$Lv]
	    if {$mx > $max} {
		set max $mx 
		set imax $i
	    }
	}
	set Lmx [lindex $Ly $imax]
	set Ly [lreplace $Ly $imax $imax]
	set Ly [linsert $Ly 0 $Lmx]
    }

    if {$f ne ""} {
	Rpipe "pdf('$f')"
	puts "  file $f"
    } else {
	Rpipe "X11()"
    }
    puts "titre $titre"
    Rpipe "x <- c([join $Lx ,])"
    set i 1
    foreach e $Ly {
	lassign $e Lv col ylab
	Rpipe "y$i <- c([join $Lv ,])"
	if {$i == 1} {
	    Rpipe "plot(x,y$i,main='$titre',type='l',col='$col',ylab='$ylab')"
	} else {
	    Rpipe "lines(x,y$i,col='$col',ylab='$ylab')"
	}
	Rpipe "rm(y$i)"
	incr i
    }
    if {$f ne ""} {
	Rpipe "dev.off()"
    }

    return

}

proc DoSbatch {} {

    global LNOrdali

    cd /home/moumou/Agents/jobs

    # precalcule couple matrix score
    set Lmsw [list]
    foreach score {norm bild thompson sop} {
	if {$score eq "sop"} {
	    set Lmat {blosum62_p blosum62_n pam35 pam15}
	} else {
	    set Lmat blosum62_p
	}
	foreach mat $Lmat {
	    foreach w {0 1} {
		lappend Lmsw $mat $score $w
	    }
	}
    }
    puts "Nbr mat/score/wg [llength $Lmsw]"

    #set Lf [LesFichiersDeBalibase]
    set Lf "../BB11001.xml"
    puts "Nbr fichiers [llength $Lf]"

    set iJob 1
    #set wgt 1
    foreach f $Lf {
	unset -nocomplain LNOrdali
	DecortiqueXmlAgent $f
	set Lbck [CoreBlocksDuXML]
	foreach {deb fin} $Lbck {
	    foreach len {5 7 9 11 13 15 17} {
		#puts ">$deb<  >$fin< $len"
		if {($fin - $deb + 1) < $len} {
		    continue
		}
		
		foreach {mat score wgt} $Lmsw {
		    #set fcmd [format "job%06d" $iJob]
		    set fcmd "job$iJob"
		    if {1} {
			set o [open $fcmd w]
			puts $o "#!/bin/tcsh"
			puts $o "setordalilm"
			puts $o "ordali exe AnalyseFichierBalibase $f $len $deb $fin $mat $score $wgt >& out[format %06d $iJob]w$wgt"
			close $o
			
			#eval exec sbatch $fcmd
		    }
		    incr iJob
		}
	    }
	}
    }
    puts "Nbr jobs $iJob"
    
    set o [open joball w]
    puts $o "#!/bin/tcsh"
    puts $o "tcsh job\$SLURM_ARRAY_TASK_ID"
    puts $o "exit 0"
    close $o

    exec sbatch --array=1-108192 joball 

    exit

}

proc DoctypeForMacsim {} {

    return {

}

}

proc DoctypeForOneSpineTarget {} {

    return {

}

}

proc DoeFetchPeeling {l} {

    global eFiLevel eFLval

    if {$l eq ""} {return}

    set KeysWithChilds [list "GBSet" "GBSeq" "GBSeq_references" "GBReference" "GBReference_authors" "GBSeq_other-seqids" "GBSeq_feature-table" "GBFeature" "GBFeature_intervals" "GBInterval" "GBFeature_quals" "GBQualifier"]
    set KeysWithArrays [list GBSeq GBSeqid GBReference GBAuthor GBXref GBFeature GBInterval GBQualifier]

    set gap [string repeat " " $iLevel]
    set ik 0
    while {$ik < [llength $l]} {
	set k [lindex $l $ik]
	if {$k in $KeysWithChilds} {
	    set bn ""
	    if {$Lval != {} } {
		puts " : [join $Lval]"
		set Lval [list]
		set bn "\n"
	    }
	    puts "${gap}k = $k"

	    incr ik
	    incr iLevel 2
	    set Lv [lindex $l $ik]
	    if {$k in $KeysWithArrays} {
		foreach v $Lv {
		    Peel $v
		}
	    } else {
		Peel $Lv
	    }
	    incr ik
	    incr iLevel -2
	    
	    continue
	}
	
	if {! [regexp {^GB} $k]} {
	    lappend Lval $k
	} else {
	    if {$Lval != {} } {
		puts " : [join $Lval]"
		set Lval [list]
	    }
	    puts -nonewline "${gap}k = $k"
	}
	incr ik
    }

    return

}

proc DoneBlaston {Nom Ou} {

    PasTouche "DoneBlaston$Ou$Nom"
    set FiPat "[RepertoireDuGenome]/pastouche/Blaston$Ou$Nom"
    if {[file exists $FiPat]} {
	if {[catch {file delete $FiPat} Message]} { return "Error. $Message" }
    }
    return "$Nom state is now DoneBlaston$Ou"

}

proc DoneBlastong {Nom} {

    return [DoneBlaston $Nom "g"]

}

proc DoneBlastonh {Nom} {

    return [DoneBlaston $Nom "h"]

}

proc DoneBlastonl {Nom} {

    return [DoneBlaston $Nom "l"]

}

proc DonneAtomePique {x y} {

    global pgl Rad

    glSelectBuffer $::BUFSIZE $::selectBuffer
    glRenderMode GL_SELECT
    set pgl(GLMode) "select"

    set viewport  [tcl3dVector GLint 4]
    glGetIntegerv GL_VIEWPORT $viewport
    set w [$viewport get 2]
    set h [$viewport get 3]

    glMatrixMode GL_PROJECTION
    glPushMatrix
    glLoadIdentity
    # create 5x5 pixel picking region 
    # near cursor location
    gluPickMatrix $x [expr {$h-$y}] 5.0 5.0 $viewport

    set ratX      $pgl(ratioX)
    set ratY      $pgl(ratioY)
    set zoom      $pgl(Zoom)
    set frontclip $pgl(frontclip)
    set backclip  $pgl(backclip)

    glOrtho  [expr {-$ratX*$zoom*($Rad+$pgl(xTra))}] [expr { $ratX*$zoom*($Rad-$pgl(xTra))}] [expr {-$ratY*$zoom*($Rad+$pgl(yTra))}] [expr { $ratY*$zoom*($Rad-$pgl(yTra))}] [expr {$backclip+$pgl(zTra)}]  [expr {$frontclip+$pgl(zTra)}]

    # MODELVIEW
    glMatrixMode GL_MODELVIEW
    glLoadIdentity
    glPushMatrix

    glTranslatef 0.0 0.0 [expr {-1. * $::Rad}]

    set mat [build_rotmatrix $::cQuat]
    glMultMatrixf $mat

    glTranslatef [expr {-1.0*$::pgl(xCen)}] [expr {-1.0*$::pgl(yCen)}] [expr {-1.0*$::pgl(zCen)}]

    EnvoieLesObjets

    glMatrixMode GL_PROJECTION
    glPopMatrix

    set hits [glRenderMode GL_RENDER]
    set pgl(GLMode) "render"

    return $hits

}

proc DonneChainDeAccessPDB {id} {


    if {[string range [string toupper $id] 0 3] eq "PDB_"} {
	set id [string range $id 4 end]
    }

    set u [string first "_" $id]
    if {$u == -1} {
	if {[string length $id] == 5} {
	    return [string index $id 4]
	} else {
	    return ""
	}
    } else {
	set c [string index $id end]
	if {[regexp {_| } $c]} {return ""}
	return $c
    }

}

proc DonneChaineType {Lr} {

    set Lr [DenombreLaListe $Lr]
    lassign [lindex $Lr 0] what n
    if {$what eq "ligand"} {
	if {[llength $Lr] > 1} {
	    lassign [lindex $Lr 1] what n
	}
    }

    return $what

}

proc DonneChainesDe {n1 n2 op} {

    global SP

    set SP(ListeChn) [$SP(Mol) _chains]
    set w $SP(ChnMenu)
    destroy $w
    tk_optionMenu $w SP(LaChn) {*}$SP(ListeChn)
    grid $w -row 1 -column 1 -sticky w

    update

    return

}

proc DonneCompositionDe {n {s ""}} {

    if {$s eq ""} {
	set i [lsearch $::LNOrdali $n]
	set s [lindex $::LSOrdali $i]
    }
    set s [string map [list "-" "" "Z" "" "X" "" "." ""] $s]

    set ln [string length $s]
    if {! $ln} {return ""}
    foreach a {A C D E F G H I K L M N P Q R S T V W Y} {
	set pa [expr {100.*([string length $s] - [string length [string map [list $a ""] $s]])/$ln}]
	lappend Lf $pa
    }

    return $Lf

}

proc DonneDateEtHeure {} {


    return [clock format [clock seconds] -format "%A, %d %B %Y %H\:%M\:%S"]

}

proc DonneDoublons {l} {

    set d [list]
    foreach e $l {
	if {[info exists T($e)]} {
	    lappend d $e
	} else {
	    set T($e) 0
	}
    }

    return [lunique $d]

}

proc DonneGenealogie {fils} {

    set pere ""
    set Lgen [list $fils]
    while {$pere != $::TaxRoot} {
	set pere [$::db eval {select Parent from taxonomy where taxid=$fils}]
	if {! [string is integer -strict $pere]} {
	    return $Lgen
	} 
	lappend Lgen $pere
	set fils $pere
    }

    return $Lgen

}

proc DonneGenealogieMem {fils} {

    if {$fils <= 0} {
	return [list]
    }

    set pere ""
    set Lgen [list $fils]
    while {$pere != $::TaxRoot || $pere != -1} {
#rR a essayé mais marche pas 	if { ! [info exists ::Tx(Parent,$fils)]} { break }
	set pere $::Tx(Parent,$fils)
	if {$pere <= 0 || ! [string is integer -strict $pere]} {
	    return $Lgen
	} 
	lappend Lgen $pere
	set fils $pere
    }

    return $Lgen

}

proc DonneHydrophobicityDe {s} {

    global THydroAA

    set h 0
    set s [string map [list "." "" " " ""] $s]
    foreach a [split $s ""] {
	set h [expr {$h + [set THydroAA($a)]}]
    }
    
    return [expr {$h/[string length $s]}]

}

proc DonneIdDeAccessPDB {id} {


    if {[string range [string toupper $id] 0 3] eq "PDB_"} {
	return [string range $id 4 7]
    } else {
	return [string range $id 0 3]
    }

}

proc DonneListeCleValeur {options} {

    # take argument list and return a list with 
    # key-value pairs in all cases

    if {! [llength $options]} {return [list]}

    set Le [split $options]
    set tmp [list]
    set Lkv [lindex $Le 0]
    foreach e [lrange $Le 1 end] {
	if {[string index $e 0] eq "-"} {
	    lappend Lkv $tmp
	    set tmp [list]
	    lappend Lkv $e
	} else {
	    lappend tmp $e
	}
    }
    lappend Lkv $tmp

    return $Lkv

}

proc DonneLongueurDe {n} {

    global LNOrdali LSOrdali

    set i [lsearch $LNOrdali $n]
    if {$i == -1} {return -1}
    set s [lindex $LSOrdali $i]
    regsub -all -- {\-| |\.|Z} $s "" tmp
    return [string length $tmp]

}

proc DonneMemeLongueur {aTseq} {

    upvar $aTseq Tseq

    set lmx -1
    foreach n [array names Tseq] {
	set s [set Tseq($n)]
	set l [string length [string trim $s]]
	if {$l > $lmx} {set lmx $l}
	lappend Ln $n
	lappend Ls $s
    }

    foreach s $Ls n $Ln {
	set l [string length [string trim $s]]
	if {$l != 0 && $l != $lmx} {
	    set d [expr {$lmx-$l}]
	    set add [string repeat "." $d]
	    append s $add
	}
	set Tseq($n) $s
    }

    return $lmx

}

proc DonneMolWeightDe {s} {

    global TMassesAA

    if {! [info exists TMassesAA]} {InitMasses}

    set s [string map [list "." "" "Z" ""] $s]
    set M 0.0

    foreach a [split $s ""] {
	set M [expr {$M + [set TMassesAA($a)]}]
    }
    set M [expr {$M + [set TMassesAA(H2O)]}]

    return $M

}

proc DonneOptions {} {


    global DefautsPipe
    global HlpPipe

    if {! [info exists DefautsPipe]} {LesDefautsDuPipe}

    set HlpPipe(File,file) "tfa file name of one or more sequences"
    set HlpPipe(File,log)  "to get a log file "
    set HlpPipe(Project,project)  "to compute MS2PH project data < |ms2phdb>"
    set HlpPipe(Blast,d) "blast databank"
    set HlpPipe(Blast,e) "max e-value expect"
    #set HlpPipe(Blast,v) "number of descriptions to print"
    set HlpPipe(Blast,b) "number of alignments to show"
    set HlpPipe(Blast,K) "number of best for region to keep"
    set HlpPipe(Blast,f) "threshold"
    set HlpPipe(Blast,F) "filtre sequences"
    set HlpPipe(Blast,g) "<1|0> gapped blast"
    set HlpPipe(Blast,m) "alignment view options. All the other steps of the Pipe will automatically be set to 0 if the default is amended"
    set HlpPipe(Filter,method) "Blast filtering "
    set HlpPipe(Filter,length) "max sequence length"
    set HlpPipe(Filter,fragment) "<1|0> remove fragments"
    set HlpPipe(Filter,maxseq) "max number of sequences to align"
    set HlpPipe(Filter,expect) "max e-value expect to consider"
    set HlpPipe(Filter,add) "<1|0> add sequences from ballast"
    set HlpPipe(Filter,addpdb) "add pdb sequences "
    set HlpPipe(Filter,varsplic) "<1|0> remove varsplic sequences"
	
    set HlpPipe(DbClustal,propagate) "<1|0> propagate"
    set HlpPipe(DbClustal,output) "output format"
    set HlpPipe(DbClustal,motifs) "<1|0> use motifs"
    
    set HlpPipe(Conservation,method) "Conservation method "

    set HlpPipe(Etapes,blast) "<1|0> blast step"
    set HlpPipe(Etapes,ballast) "<1|0> ballast step"
    set HlpPipe(Etapes,filter) "<1|0> filter step"
    set HlpPipe(Etapes,clustal) "<1|0> dbclustal step"
    set HlpPipe(Etapes,normd1) "<1|0> normd after dbclustal step"
    set HlpPipe(Etapes,rascal) "<1|0> rascal step"
    set HlpPipe(Etapes,normd2) "<1|0> normd after rascal step"
    set HlpPipe(Etapes,leon) "<1|0> leon step"
    set HlpPipe(Etapes,normd3) "<1|0> normd after leon step"
    set HlpPipe(Etapes,cluspack) "<1|0> cluspack step"
    set HlpPipe(Etapes,macsims) "<1|0> macsims step"
    set HlpPipe(Etapes,conservation) "<1|0> conservation step"
    set HlpPipe(Etapes,modelisation) "<1|0> modelisation step"

    Espionne " "
    Espionne "Pipe Options :"
    Espionne "--------------"
    Espionne " "
    Espionne "Usage : pipe \[-batch\] -option=value ...."
    Espionne " "

    set lm 0
    foreach e [array names HlpPipe] {
	set l [string length $e]
	if {$l > $lm} {
	    set lm $l
	}
    }
    
    set lm [expr $lm + 6]

    foreach i {File Blast Filter DbClustal Conservation Etapes} {
	set lo [lsearch -regexp -all -inline [array names HlpPipe] $i]
	foreach e $lo {
	    set v [set DefautsPipe($e)]
	    set Pt [string repeat "." [expr $lm - [string length $e]]]
	    Espionne "   -$e ${Pt}: [set HlpPipe($e)] "
	}
	Espionne " "
    }

    return

}

proc DonnePIDe {n {s ""}} {

    if {$s eq ""} {
	set i [lsearch $::LNOrdali $n]
	set s [lindex $::LSOrdali $i]
    }

    set AspN [regsub -all "D" $s "" tmp]
    set GluN [regsub -all "E" $s "" tmp]
    set CysN [regsub -all "C" $s "" tmp]
    set TyrN [regsub -all "Y" $s "" tmp]
    set HisN [regsub -all "H" $s "" tmp]
    set LysN [regsub -all "K" $s "" tmp]
    set ArgN [regsub -all "R" $s "" tmp]

    set pH 6.5
    set pHprev  0.0
    set pHnext 14.0
    set X 0.0
    set E 0.01
    set temp 0.0
    while {1} {
	set NQ [PIAuPH $AspN $GluN $CysN $TyrN $HisN $LysN $ArgN $pH]
	if {$pH > 14.0} {
	    set NQ -999.
	    FaireLire "Something went wrong while computin\npI for $n !"
	    break
	}

	if {$NQ<0} {
	    set temp $pH
	    set pH [expr {$pH-(($pH-$pHprev)/2)}]
	    set pHnext $temp
	} else {
	    set temp $pH
	    set pH [expr {$pH+(($pHnext-$pH)/2)}]
	    set pHprev $temp
	}

	if {$pH-$pHprev<$E && $pHnext-$pH<$E} {
	    break
	}
    }

    return $pH

}

proc DonnePhysicoChimieDe {n {s ""}} {

    if {$s eq ""} {
	set i [lsearch $::LNOrdali $n]
	set s [lindex $::LSOrdali $i]
    }
    set s [string map [list "-" "" "Z" "" "X" "" "." ""] $s]

    set ln [string length $s]
    if {! $ln} {return ""}
    foreach a {"A|I|L|M|V" "K|R|H" "D|E|Q|N" "F|Y|W" "P|G|S|T"} {
	set pa [expr {100.*[regsub -all "$a" $s "" s]/$ln}]
	lappend Lf $pa
    }

    return $Lf

}

proc DonnePosGS {n x {debug 0}} {

    # Attention ! 
    # renvoie coord avec START=1 !
    #                   ----------

    set o [string length [string map {"." ""} [string range $::Sequences($n) 0 $x]]]
    if {$n in $::ListePDB} {
	set mol [DonneIdDeAccessPDB $n]
	set chn [DonneChainDeAccessPDB $n]
	set lr [$mol _resnumber -chain $chn -polymer]
	if {$o >= [llength $lr]} {
	    set o [lindex $lr end]
	} elseif {$o != 0} {
	    set o [lindex $lr $o-1]
	}
    }
 
   return $o

}

proc DonnePosGS_SL {n w y x {debug 0}} {

    # ==> Pour Mode Seqlab
    #
    # Attention ! 
    # renvoie coord avec START=1 !
    #                   ----------

    set o [string length [string map {"." ""} [string range [$w output [expr {$y-1}]] 0 $x]]]
    if {$n in $::ListePDB} {
	set mol [DonneIdDeAccessPDB $n]
	set chn [DonneChainDeAccessPDB $n]
	set lr [$mol _resnumber -chain $chn -polymer]
	if {$o >= [llength $lr]} {
	    set o [lindex $lr end]
	} elseif {$o != 0} {
	    set o [lindex $lr $o-1]
	}
    }

    return $o

}

proc DonnePosRA {nom pos AorR} {

    global PosRA
    if {$AorR eq "Absolue"} {
	return [set PosRA($nom,Absolue,$pos)]
    }
    if {$AorR eq "Relative"} {
	return [set PosRA($nom,Relative,$pos)]
    }

}

proc DonnePosSG {n x} {

    # Attention !
    # renvoie avec start = 0 !
    #             -----------

    if {$n in $::ListePDB} {
	set mol [DonneIdDeAccessPDB $n]
	set chn [DonneChainDeAccessPDB $n]
	set x [lsearch [$mol _resnumber -chain $chn -polymer] $x]
    }

    return [lindex [lindex [regexp -all -inline -indices {[A-Z]} $::Sequences($n)] $x] 0]



    if {[set v [$::db eval {select gen from corrseqgen where nom=$n and seq=$x}]] ne ""} {
	return $v
    } else {
	puts "Pb SG -> $n $x"
	return -999
    }

}

proc DonneResidueType {r} {

    if {[info exists ::TResidueType([string trim $r],type)]} {
	return [set ::TResidueType([string trim $r],type)]
    } else {
	return "ligand"
    }

}

proc DonneResidueType_OLD {r} {

    if {$r in {ILE LEU MET MSE VAL TYR PTR TRP CYH CYS SEC ARG GLU GLN LYS ASP ASN ALA PHE SER SEP PRO CPR HIS GLY THR TPO} } {
	return "Protein"
    } elseif {$r in {"  A" "  G" "  T" "  U" "  C" "  I" H2U PSU M7G " DA" " DT" " DG" " DC" " DI" } } {
	return "Nucleic"
    } elseif {$r in {HOH WAT H2O} } {
	return "ligand"
    } else {
	return "ligand"
    }

}

proc DonneScoreDe {f {Lmeth ""}} {

    global LNDG SDG LNOrdali LSOrdali Sequences NomSeqSel ListeScore ListeDesPiliersDuGroupe TbScores

    puts "Doing $f"
    if {$Lmeth eq ""} {
	#set Lmeth [list Thompson Entrop1 Liu2 Williamson Kabat RPCA Norm SanderSP Peivar Karlin Valdar Capra Caffrey Wang]
	set Lmeth [list Kabat Williamson Thompson Norm]
    }
    
    set NomSeqSel {}
    
    DecortiqueUnTFA $f LNOrdali Sequences
    set nsites [LongueurDeLAlignement]
    set LNDG [list GroupeToutLeMonde]
    set SDG(GroupeToutLeMonde) $LNOrdali

    if {"Valdar" in $Lmeth || "SanderSP" in $Lmeth} {
	set Lns [list]
	foreach s $LNOrdali {
	    lappend LSOrdali [set Sequences($s)]
	    lappend Lns $s [set Sequences($s)]
	}
	set LPCI [CalculeLesPCIGenerique $Lns]
    }

    CreeLesPiliers
    set Lpil [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]
    
    LesDefauts PCThrGap 0.01
    set TbScores(Lcols) $Lmeth
    foreach m $Lmeth {
	if {$m ne "SanderSP" && $m ne "Valdar"} {
	    set sco [ScoreDe$m $Lpil]
	} else {
	    set sco [ScoreDe$m $Lpil $LNOrdali $LPCI]
	}	    
	set TbScores(Score,$m) $sco
    }
    
    return

}

proc DonneTabFeature {aTab} {

    global ListeTypesDeFeatures Defauts LNOrdali LSOrdali
    upvar $aTab tbf

    #################
    # 
    # !! ATTENTION !!
    # 
    # On prend maintenant les positions 
    # fstart et fstop TELLES QUELLES (position dans
    # la sequence ou pas, et commencent a 1). On transforme 
    # en position absolues quend on cree une vue
    # 
    #################
        
    set ListeTypesDeFeatures {}
    foreach nom $LNOrdali seq $LSOrdali {
	if {! [info exists tbf($nom)]} {continue}

	set lgt [string length [string map [list . ""] $seq]]
	foreach i [set tbf($nom)] {
	    foreach {f v} $i {
		switch $f {
		    "coords" {set y $v}
		    "ftype"  {set t $v}
		    "fstart" {set s $v}
		    "fstop"  {set e $v}
		    "fcolor" {
			if {[regexp {^[0-9]} $v]} {
			    set c [CouleurDuStock $v]
			}  else {
			    set c $v
			}
		    }
		    "fscore" {set r $v}
		    "fnote"  {set n $v}
		    default {lappend nl $f $v}
		}
	    }
	    if {$t eq "STRUCT"} {
		if {[regexp "HELIX" $n]} {
		    set c "red"
		} elseif {[regexp "STRAND" $n]} {
		    set c "green"
		}
	    }
	    # ERRORS in Macsim
	    # 1 - start/stop should not be empty !!
	    if {$e eq "" || $s eq ""} {
		puts "start ou stop vide !"
		continue
	    }
	    # 2 - stop > start !
	    if {$e < $s} {
		#puts "$nom $t | start > stop : $s $e"
		continue
	    }
	    # 3 - start and stop < length
	    if {$y eq "local"} {
		if {$e > $lgt || $s > $lgt} {
		    #puts "$nom $t | start or stop > length : $s $e - $lgt"
		    continue
		}
	    }

	    set nl [list fstart $s fstop $e fcolor $c fscore $r fnote $n fcsys $y]
	    lappend tbf(${nom},$t) $nl
	    lappend ListeTypesDeFeatures $t
	}
    }
    
    set ListeTypesDeFeatures [lsort -unique $ListeTypesDeFeatures]

    return

}

proc DonneTabFeatureDuRsf {aTab} {

    upvar $aTab tb
    global LNOrdali Couleurs Defauts

    FaireAttendre "Please wait ...\nRetrieving feature from RSF file ..."

    set LFS [array names tb "*,Type,*"]

    set csys "global" ; set score 0.0 ; set note ""
    foreach f $LFS {
	set ln [split $f ","]
	set ln [lreplace $ln 1 1]
	set nom [join $ln ","]
	foreach l [set tb($f)] {
	    scan $l "%d %d %d %d %s %s %s" dg fg ds fs col form style
	    set nl [list fstart $dg fstop $fg fcolor $col fscore $score fnote $note fcsys $csys]
	    lappend Ttmp($nom) $nl
	}
    }

    unset -nocomplain tb
    array set tb [array get Ttmp]

    FaireLaSuite .tabf

    return

}

proc DonneesAful {AF} {

    Wup "We used Archeoglobus fulgidus as model for classification" 
    global LesDonneesAful 

    if {$AF == ""} { return {} }

    if { ! [info exists LesDonneesAful]} { ChargeLesDonneesAful }
    if { ! [info exists LesDonneesAful($AF)]} { return {}}
    return [set LesDonneesAful($AF)]

}

proc DontCreateAllOligos {} {

    global DontCreateAllOligos
    set DontCreateAllOligos [OuiOuNonMemo "Do I ask each time to remove some oligos ?" 0]

}

proc DotPlot {Banque {Orga ""} {DesProches ""} {PourGif ""}} {

    global ListeDeBoites
    global DotPlotDesProches
    
    Gs "Canvas"

    while {$Orga=="Ask"} {
	set O [ChoixParmi [FamiliarTaxId LaListeMerci]] 
	if {$O!=""} { scan $O "%s %s %d" G E Orga ; break }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    if {$PourGif!=""} {
	set PourGif 1
	set DesProches "Proches"
    } else {
	set PourGif 0
    }
    
    if {$DesProches == ""} {
	set DotPlotDesProches [OuiOuNon "DotPlot des points proches uniquement ?"]
    } elseif { $DesProches == "Proches"} {
	set DotPlotDesProches 1
    } else {
	set DotPlotDesProches 0
    }
    
    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    if {$Banque == "paby"} {
	return [DotPlotParalogues]
    }
    
    set MinX  99999999
    set MaxX -99999999
    set MinY  99999999
    set MaxY -99999999
    
    set NousEtEux {}
    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { ! [YaPABdans $Nom]} { continue }
	set Moi $Nom
	set LeursPositions [PositionsDesOrthologues $Nom $Banque $Orga]
	if {[llength $LeursPositions] < 1} { continue }
	set PosMoi [Milieu $Moi]
	set MinX [Mini $MinX $PosMoi]
	set MaxX [Maxi $MaxX $PosMoi]
	foreach PosLui $LeursPositions {
	    set MinY [Mini $MinY $PosLui]
	    set MaxY [Maxi $MaxY $PosLui]
	    lappend NousEtEux "$PosMoi.$PosLui $Moi $PosMoi $PosLui"
	}
    }
    if {$NousEtEux=={}} {
	FaireLire "Sorry, I didn't found any $Orga within all homologues"
	return ""
    } 
    if {$DotPlotDesProches} {
	set NousEtEux [lsort -command CompareLesFloatsEnDebut $NousEtEux]  
    }
    foreach Couple $NousEtEux {
	scan $Couple "%f %s %d %d" pml Bibi PosBibi PosLui
	lappend Nous    $Bibi
	lappend Vous    $PosLui
	lappend NosPos  $PosBibi
	lappend VosPos  $PosLui
    }
    if {$PourGif} {
	return [Plotte $Nous $Vous $NosPos $VosPos $MinX $MaxX $MinY $MaxY $Orga "PourGif"]
    } else {
	return [Plotte $Nous $Vous $NosPos $VosPos $MinX $MaxX $MinY $MaxY $Orga]
    }

}

proc DotPlotADN {PosX PosY} {

    global DotPlotDesProches

    set DotPlotDesProches 0

    set lX 512
    set lY $lX

    set F 50
    set SeuilAffichage 50 

    set dX [expr $PosX-$lX]
    set fX [expr $PosX+$lX]
    set dY [expr $PosY-$lY]
    set fY [expr $PosY+$lY]

    for {set i $dX} {$i<$fX} {incr i} {
	set SeqX [BoutADN [expr $i-$F] [expr $i+$F] "F"]
	set LesX [split $SeqX ""]
	for {set j $dY} {$j<$fY} {incr j} {
	    set SeqY [BoutADN [expr $j-$F] [expr $j+$F] "F"]
	    set LesY [split $SeqY ""]
	    set N 0
	    set Z 5
	    foreach X $LesX Y $LesY {
		if {$X==$Y} {
		    incr N
		    set Z 5
		} else {
		    incr Z -1
		}
		if {$Z} { continue }
		break
	    }
	    set Score [expr ($N*100)/(2*$F+1)]
	    if {$Score > $SeuilAffichage } {
		lappend Nous "$SeqX "
		lappend Vous " $SeqY"
		lappend NosPos $i
		lappend VosPos $j
	    }
	}
    }
    return [Plotte $Nous $Vous $NosPos $VosPos]

}

proc DotPlotBlastN {{Fichier ""} {BanqueBlast ""}} {

    global RepertoireDuGenome
    global DotPlotDesProches ; set DotPlotDesProches 0
    global PlottePourBlastN 

    if {$Fichier==""} {
	set LesHomologues [LesLignesDuFichier "$RepertoireDuGenome/fiches/ouonttapelescontigs"]
    } else {
	set LesHomologues [LesHomologiesDuBlastN $Fichier "" $BanqueBlast]
    }

    foreach Homo $LesHomologues {
	set lHomo [split $Homo "\t"]
	set i -1
	set Nom        [lindex $lHomo [incr i]]
	set nCops      [lindex $lHomo [incr i]]
	set nCopsSeq   [lindex $lHomo [incr i]]
	set BanqueId   [lindex $lHomo [incr i]]
	set OrgaHomo   [lindex $lHomo [incr i]]
	set Identities [lindex $lHomo [incr i]]
	set Expect     [lindex $lHomo [incr i]]
	set DebutQuery [lindex $lHomo [incr i]]
	set FinQuery   [lindex $lHomo [incr i]]
	set DebutSbjct [lindex $lHomo [incr i]]
	set FinSbjct   [lindex $lHomo [incr i]]
	set SeqQuery   [lindex $lHomo [incr i]]
	set SeqSbjct   [lindex $lHomo [incr i]]
	
	set LongSbjct [expr abs($FinSbjct-$DebutSbjct)+1]

	if {$LongSbjct<100} { continue }

	if {$DebutSbjct < $FinSbjct} {
	    set OrientSbjct "F"
	} else {
	    set OrientSbjct "R"
	}
	if {$DebutQuery < $FinQuery} {
	    set OrientQuery "F"
	} else {
	    set OrientQuery "R"
	}
	set TexteNous "$DebutSbjct $FinSbjct $Nom $OrientSbjct $OrientQuery $Identities"
	set TexteVous "$DebutQuery $FinQuery"
	regsub -all {  +} $TexteNous " " TexteNous
	regsub -all {  +} $TexteVous " " TexteVous
	lappend Nous $TexteNous
	lappend Nous $TexteNous
	lappend Vous $TexteVous
	lappend Vous $TexteVous
	lappend NosPos "$DebutSbjct"
	lappend NosPos "$FinSbjct"
	lappend VosPos "$DebutQuery"
	lappend VosPos "$FinQuery"
	
    }
    set PlottePourBlastN 1
    Plotte $Nous $Vous $NosPos $VosPos
    unset PlottePourBlastN

}

proc DotPlotDesInteressants {Orga} {

    global RepertoireDuGenome
    global DotPlotDesProches ; set DotPlotDesProches 0
    global PlottePourBlastN 

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/blastn/$Orga.mesinteressants"] {
	scan $Ligne "%s %d %d %s %s %d %d %s %d" MonNom MonD MonF MonO TonNom TonD TonF TonO PI

	lappend Nous "$MonNom $MonD $MonF $MonO"
	lappend Vous "$TonNom $TonD $TonF $TonO $PI"

	if {$MonO=="R"} {
	    set Toto $MonD
	    set MonD $MonF
	    set MonF $Toto
	}
	if {$TonO=="R"} {
	    set Toto $TonD
	    set TonD $TonF
	    set TonF $Toto
	}

	lappend NosPos $MonD
	lappend NosPos $MonF
	lappend VosPos $TonD
	lappend VosPos $TonF
	
    }
    set PlottePourBlastN 1
    Plotte $NosPos $VosPos $NosPos $VosPos
    unset PlottePourBlastN

}

proc DotPlotParalogues {} {

    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    
    set MinX  999999
    set MaxX -999999
    set MinY  999999
    set MaxY -999999

    foreach Boite $ListeDeBoites {
	set Nom [Box $Boite nom]
	if { ! [YaPABdans $Nom]} { continue }
	set Moi $Nom
	set Eux [ParaloguesDe $Nom]
	if {[llength $Eux] < 1} { continue }
	set PosMoi [Milieu $Moi]
	set MinX [Mini $MinX $PosMoi]
	set MaxX [Maxi $MaxX $PosMoi]
	    lappend Nous    $Moi
	    lappend Vous    $Moi
	    lappend NosPos  $PosMoi
	    lappend VosPos  $PosMoi
	foreach Lui $Eux {
	    set PosLui [Milieu $Lui]
	    set MinY [Mini $MinY $PosLui]
	    set MaxY [Maxi $MaxY $PosLui]
	    lappend Nous    $Moi
	    lappend Vous    $Lui
	    lappend NosPos  $PosMoi
	    lappend VosPos  $PosLui
	}
    }
    return [Plotte $Nous $Vous $NosPos $VosPos $MinX $MaxX $MinY $MaxY]

}

proc DoubleFof {} {

    set I 0
    foreach Ligne [LesLignesDuFichier U133p2.fof.200610191217] {
	incr I
	scan $Ligne "%s %s" Ps Fi
	if {[EstUnPAB [file tail $Fi]]} {
	    lappend LeBon $Ligne
	    continue
	}
	if {[info exists DejaVu($Ps)]} {
	    Espionne "\n$I\n$DejaVu($Ps)\n$Ligne"
	    if {[file tail $Fi]!=[file tail $DejaVu($Ps)]} { FaireLire coucou }
	    lappend LeMauvais $Ligne
	} else {
	    lappend LeBon $Ligne
	}
	set DejaVu($Ps) $Fi
    }
    SauveLesLignes $LeBon dans LeNouveauBon2.fof
    SauveLesLignes $LeMauvais dans LesDoublons2.fof
    exit

}

proc Doublet {x y} {

    return [list $x $y]

}

proc DoublonsDansClustersNew {FichierClustersNew} {

    foreach Ligne [LesLignesDuFichier $FichierClustersNew] {
	if {$Ligne==""} {continue}
	set LesDD [split $Ligne " "]
	foreach DD $LesDD {
	    if {![info exists Vu($DD)]} {set Vu($DD) 1} else {Espionne $DD}
	}
    }

}

proc DoublonsDansTaxUniProt {} {


    set UrlPourLaMiseAJour "http://www.uniprot.org/taxonomy/?query=&force=yes&format=tab"

    set TaxDir [TaxDir "UniProt"]
    set Fichier "$TaxDir/taxonomy-all.tab"
    set f [open $Fichier "r"]
    set PrendPremiereLigne 0
    while {[gets $f Ligne]>=0} {
	if {! $PrendPremiereLigne} {
	    #lM premiere ligne contient les noms des champs
	    # Taxon | Mnemonic | Scientific name | Common name | Synonym | Other Names | Reviewed | Rank | Lineage | Parent
	    set PrendPremiereLigne 1
	    continue
	}
	
	set LesChamps [split $Ligne "\t"]
	lassign $LesChamps TaxId Mnemonic Name CommonName Synonym OtherNames Reviewed Rank Lineage Parent
	if {$Name==""} { continue }
	if {[string trim $Rank] eq ""} {
	    set Rank "no rank"
	}
	if {[info exists DejaVu($Name)]} {
	    lappend LesDoublons $Name
	    Espionne "\n[join $DejaVu($Name) \n]\n$Ligne"
	}
	lappend DejaVu($Name) $Ligne 
    }
    return 

}

proc DownloadProteomes {args} {


	global RepertoireDuGenome 
	set listNumUni [list ]
	set listNumRef [list ]

	#recup des demandes
	foreach elt $args {
		regexp {(.*)=(.*)} $elt foo bq tempNum
		#puts "$foo : $bq : $tempNum"
		#sinon
		if {$tempNum!="" && $bq=="uni"} {lappend listNumUni $tempNum}
		if {$tempNum!="" && $bq=="ref"} { lappend listNumRef $tempNum}
		if {$bq!="" && $tempNum==""} {
			puts "    --> erreur de parsing des numeros (refseq/uniprot)"
			puts "        forme demandée : uni=xxx...x ref=xxx...x"
			exit	
		}
	}
	#verif que au moins 1 sp et un tr
	set isUni [llength $listNumUni]
	set isRef [llength $listNumRef]
	if {$isUni==0 || $isRef==0} {
		puts "    --> uni=$isUni x,ref=$isRef x : il faut au moins un ref=xxxxx et un uni=xxxxx"
		exit
	}
	#execution des telechargements
	putLog "########################################"
	putLog "--Telechargement des proteomes via SRS--"
	foreach elt $listNumRef {
		putLog "   -refseq : taxid=$elt"
	}
	foreach elt $listNumUni {
		putLog "   -uniprot : taxid=$elt"
	}
	putLog "########################################"
	putLog ">>> creation des scripts ICARUS"
	CreateIcarusScripts
	putLog "     -->OK"
	putLog ">>> execution icarus pour refseq"
	#telechargement pour les differents num refseq
	foreach elt $listNumRef {
		set icarusComRef "exec icarus Extract_refseq_fasta_seq_full_desc.icarus $elt > $elt-ref-proteome.fasta"
		if {[catch {eval $icarusComRef} message]} {
	    	putLog "Problem with '$icarusComRef'"
	    	putLog "$message"
			exit
		}
	}
	putLog ">>> execution icarus pour uniprotKB/swissprot"
	foreach elt $listNumUni {
		set icarusComSp "exec icarus Extract_uniprotKB-sp_fasta_seq_full_desc.icarus $elt > $elt-sp-proteome.fasta"
		if {[catch {eval $icarusComSp} message]} {
		    putLog "Problem with '$icarusComSp'"
		    putLog "$message"
			exit
		}
		putLog ">>> execution icarus pour uniprotKB/trEMBL"
		set icarusComTr "exec icarus Extract_uniprotKB-tr_fasta_seq_full_desc.icarus $elt > $elt-tr-proteome.fasta"
		if {[catch {eval $icarusComTr} message]} {
		    putLog "Problem with '$icarusComTr'"
		    putLog "$message"
			exit
		}
	}
	putLog "    -->OK"
	putLog ">>> Fusion des 3 banques"
	set countUniSp [list ]
	set countUniTr [list ]
	set countRef [list ]
	set compteur 0
	set output [open "completeProteome.fasta" "w"]
	foreach elt $listNumRef {
		set inputRef [open "$elt-ref-proteome.fasta" "r"]
		while {[gets $inputRef line]!=-1} {
			if {$line=="" || $line=="\n"} {continue}
			if {[string index $line 0]==">"} {incr compteur}
			puts $output $line
		}
		close $inputRef
		lappend countRef $compteur
		set compteur 0
	}
	foreach elt $listNumUni {
		set inputUniSp [open "$elt-sp-proteome.fasta" "r"]
		while {[gets $inputUniSp line]!=-1} {
			if {$line=="" || $line=="\n"} {continue}
			if {[string index $line 0]==">"} {incr compteur}
			puts $output $line
		}
		close $inputUniSp
		lappend countUniSp $compteur
		set compteur 0
		set inputUniTr [open "$elt-tr-proteome.fasta" "r"]
		while {[gets $inputUniTr line]!=-1} {
			if {$line=="" || $line=="\n"} {continue}
			if {[string index $line 0]==">"} {incr compteur}
			puts $output $line
		}
		close $inputUniTr
		lappend countUniTr $compteur
		set compteur 0
	}
	close $output
	putLog "    -->OK"
	putLog "    -->Pour info : "
	set compteur 0
	foreach elt $countRef {
		putLog "        -refseq (taxid=[lindex $listNumRef $compteur]): $elt séquences téléchargées"
		incr compteur
	}
	set compteur 0
	foreach elt $countUniSp {
		putLog "        -uniprotKB/swissprot: (taxid=[lindex $listNumUni $compteur]): $elt séquences téléchargées"
		putLog "        -uniprotKB/trEMBL: (taxid=[lindex $listNumUni $compteur]): [lindex $countUniTr $compteur] séquences téléchargées"
		incr compteur
	}
	putLog "        === >> Séquences dispos au [Maintenant]"
	putLog "    -->fichier de fusion = completeProteome.fasta"



	if {![file exists "gene_refseq_uniprotkb_collab"]} {
		putLog ">>> télechargement du fichier d'équivalence Uniprot/Refseq"
		set equiDownload "exec wget -q ftp://ftp.ncbi.nih.gov/refseq/uniprotkb/gene_refseq_uniprotkb_collab.gz"
		if {[catch {eval $equiDownload} message]} {
		    putLog "Problem with '$equiDownload'"
		    putLog "$message"
		}
		putLog "    --> OK filename=gene_refseq_uniprotkb_collab.gz"
		putLog "           fichier d'équivalence du [Maintenant]"
		putLog ">>> extraction de l'archive du fichier d'équivalence"
		set extractDownload "exec gunzip -f gene_refseq_uniprotkb_collab.gz"
		if {[catch {eval $extractDownload} message]} {
		    putLog "Problem with '$extractDownload'"
		    putLog "$message"
		}
		putLog "    --> OK filename=gene_refseq_uniprotkb_collab"
	}
	putLog ">>> récupération de toutes les équivalences détectées dans le fichier"
	set extractedEqui [SkipKnownEquivalent "gene_refseq_uniprotkb_collab" "completeProteome.fasta"]
	putLog ">>> suppression des équivalents de notre fasta"
	#en faire une sauvegarde
	putLog "    -->sauvegarde de completeProteome.fasta en completeProteome.fasta.backup"
	file copy -force "$RepertoireDuGenome/completeProteome.fasta"  "$RepertoireDuGenome/completeProteome.fasta.backup"
	file delete "$RepertoireDuGenome/completeProteome.fasta"
	set FICOUT [open "$RepertoireDuGenome/completeProteome.fasta" "w"]
	set FICOUT2 [open "$RepertoireDuGenome/deletedByEquival.log" "w"]
	set FICIN [open "$RepertoireDuGenome/completeProteome.fasta.backup" "r"]
	#pour verif lesquels sont dans la liste d'equivalence et pas dans le proteome recupéré par SRS
	set checkList [list ]
	for {set i 0} {$i<[llength $extractedEqui]} {incr i} {
		lappend checkList "0"
	}
	putLog "    -->suppression des equivalents dans completeProteome.fasta"
	set aSuppr 0
	while {[gets $FICIN line]!=-1} {
		#si on a une entete
		if {[string index $line 0]==">"} {
			set infos [split $line "|"]
			#si l'accessNumber est dans la liste des equivalents, on zap les lignes
			set index [lsearch -exact $extractedEqui [lindex $infos 1]]
			if {$index!=-1} {
				set aSuppr 1
				lset checkList $index 1
				puts $FICOUT2 "$line"
			} else {
				#sinon on ecrit dans le fichier
				set aSuppr 0
			}
		}
		if {$aSuppr==0} {puts $FICOUT $line}
	}
	close $FICIN
	close $FICOUT
	close $FICOUT2
	putLog "    -->nombre d'entrées dans l'ancien FASTA : [CountEnteteFASTA completeProteome.fasta.backup]"
	putLog "    -->nombre d'entrées dans le FASTA final : [CountEnteteFASTA completeProteome.fasta]"
	putLog "    -->les equivalences suivantes ont été détéctées, mais sont absentes"
	putLog "       du fichier fasta RefSeq généré par la requete SRS :"
	set compt 0
	set tot 0
	foreach elt $checkList {
		if {$elt==0} {
			putLog "        - [lindex $extractedEqui $compt]"
			incr tot
		}
		incr compt
	}
	putLog "         ---------------------"
	putLog "           $tot éléments"

}

proc DownloadStructures {} {

    global ListePDB StrucAVoir Defauts

    if {! [llength $StrucAVoir]} {return}
    if {[set Defauts(DownloadPDB)] in {"none" "internet"}} {
	return
    }

    foreach s $StrucAVoir {
	set chn [DonneChainDeAccessPDB $s]
	set mol [DonneIdDeAccessPDB $s]

	set Lv [info globals "PDB_${mol}*"]
	foreach v $Lv {eval catch {unset $v}}
    }

    AfficheDownloadPDB

    return

}

proc DpcShow {{FichierDesProfils ""} {FichierTextOnX ""}} {

    
    if {$FichierDesProfils==""} { 
	set RepXHDA "[RepertoireDuGenome]/xhda"
	set FichierDesProfils "$RepXHDA/TousLesBilans_PourNuca.dpc"
    }
    if {! [file exists $FichierDesProfils]} { 
	set FichierDesProfils [ButineArborescence "All"]
	if {$FichierDesProfils==""} { return "" }
    }
    
    if {$FichierTextOnX==""} {
	set FichierTextOnX "[RepertoireDuGenome]/xhda/OrgaOrdonne.nuca"
	if { ! [file exists $FichierTextOnX]} { 
	    set FichierTextOnX ""
	}
    }
    
    Espionne "exec dpc_show $FichierDesProfils $FichierTextOnX &"
    exec dpc_show $FichierDesProfils $FichierTextOnX &


}

proc Dpkg {{Host ""} {Qui ""} {Quoi ""}} {

    global Dpkg
    if {[info exists Dpkg($Host,$Qui,$Quoi)]} { return $Dpkg($Host,$Qui,$Quoi) }
    if {[info exists Dpkg("EstCharge")]} { return "" }
    set Dpkg("EstCharge") 1
    
    cd "[HomeRipp]/sys/pkg"
    set LesH [list "ena" "studio" "moby" "eyear" "virturr" "virtuwr"]
    set LesA [list "A"   "S"      "M"    "E"     "R"       "W"]
    foreach H $LesH {
	set OnAttend 1
	foreach Ligne [LesLignesDuFichier "dpkg.$H.txt"] {
	    if {$OnAttend && ! [regexp {^\+\+\+} $Ligne]} { continue } 
	    if {$OnAttend &&   [regexp {^\+\+\+} $Ligne]} { set OnAttend 0; continue }
	    scan $Ligne "%s %s %s" S P V 
	    lappend LesP $P
	    set D [string trim [StringSuivant $V dans $Ligne]]
	    set Dpkg($H,$P,A) $Ligne
	    set Dpkg($H,$P,I) $P
	    set Dpkg($H,$P,P) $P
	    set Dpkg($H,$P,V) $Ligne
	    set Dpkg($H,$P,D) $Ligne
	    lappend Dpkg(All,ListOf,P) $P
	    lappend Dpkg($H,ListOf,P) $P
	}
    }
    set Dpkg(ListOf,A,)    $LesA 
    set Dpkg(ListOf,H,)    $LesH 
    set Dpkg(All,ListOf,H) $LesH 
    set Dpkg(All,ListOf,P) [lsort -unique $Dpkg(All,ListOf,P)]
    return [Dpkg $Host $Qui $Quoi]

}

proc DpkgShow {} {

    set LesH [Dpkg All ListOf H]
    set LesA [Dpkg All ListOf A]
    foreach P [Dpkg All ListOf P] {
	set LesX {}
	set HostManquant 0
	foreach H $LesH A $LesA {
	    set X $A
	    if {[Dpkg $H $P P]==""} { set HostManquant 1; set X " " }
	    lappend LesX $X
	}
	if {   $HostManquant} { lappend LesDistincts "[join $LesX {}] $P" }
	if { ! $HostManquant} { lappend LesCommuns   "[join $LesX {}] $P" }
    }
    set Hosts [join $LesH " "]
    AfficheListe $LesDistincts "" "$Hosts diff"
    AfficheListe $LesCommuns   "" "$Hosts idem"

}

proc DragArcBall {x y} {

    # Update End Vector And Get Rotation As Quaternion
    tcl3dArcBallDrag $::ArcBall $x $y $::ThisQuat   

    # Convert Quaternion Into Matrix
    tcl3dTrackballBuildRotMatrix $::ThisRot $::ThisQuat

    # Accumulate Last Rotation Into This One
    tcl3dMatfMult $::ThisRot $::LastRot $::Transform
    tcl3dMatfCopy $::Transform $::ThisRot

    set ::TransformList [tcl3dVectorToList $::Transform 16]

    .top.fr.toglwin postredisplay

}

proc DrawAtomsNucleic {cp cyl QObj Lx La Ln} {

    # cp : draw main chain
    # cyl : draw as stick or line
    # QObj : quadric object for stick/ball

    # atoms order in PDB
    # 0P3 P OP1 OP2 O5' C5' C4' O4' C3' O3' C2' C1' 
    set colP [CouleurDeAtome "P"]
    set colN [CouleurDeAtome "N"]
    set colC [CouleurDeAtome "C"]
    set colO [CouleurDeAtome "O"]
    if {$cp} {set first 1} {set first 0}

    foreach rx $Lx rn $La n $Ln {
	if {" OP3"  in $rn} {set off 1} {set off 0}
	if {" O2''" in $rn} {set o2p 1} {set o2p 0}
	set of2 [expr {$off+$o2p}]
	
	if {$cp} {
	    if {$off && $o2p} {
		set Lcl [lassign $rx AOP3 AP AOP1 AOP2 AO5p AC5p AC4p AO4p AC3p AO3p AC2p AO2p AC1p]
	    } elseif {$off && ! $o2p} {
		set Lcl [lassign $rx AOP3 AP AOP1 AOP2 AO5p AC5p AC4p AO4p AC3p AO3p AC2p AC1p]
	    } elseif {! $off && $o2p} {
		set Lcl [lassign $rx AP AOP1 AOP2 AO5p AC5p AC4p AO4p AC3p AO3p AC2p AO2p AC1p]
	    } else {
		set Lcl [lassign $rx AP AOP1 AOP2 AO5p AC5p AC4p AO4p AC3p AO3p AC2p AC1p]
	    }
	} else {
	    set AP   [lindex $rx 0+$off]
	    set AC1p [lindex $rx 10+$of2]
	}

	if {$cp} {
	    # Trace P-OP1 P-OP2 P-O3P O3P-C3P ...
	    if {$off} {
		TraceLiaison $QObj $AP $AOP3 $colP $colO $cyl
	    }
	    
	    TraceLiaison $QObj $AP $AOP1 $colP $colO $cyl
	    TraceLiaison $QObj $AP $AOP2 $colP $colO $cyl
	    TraceLiaison $QObj $AP $AO5p $colP $colO $cyl
	    TraceLiaison $QObj $AO5p $AC5p $colO $colC $cyl
	    TraceLiaison $QObj $AC5p $AC4p $colC $colC $cyl
	    TraceLiaison $QObj $AC4p $AO4p $colC $colO $cyl
	    TraceLiaison $QObj $AO4p $AC1p $colO $colC $cyl
	    TraceLiaison $QObj $AC1p $AC2p $colC $colC $cyl
	    TraceLiaison $QObj $AC2p $AC3p $colC $colC $cyl
	    TraceLiaison $QObj $AC3p $AC4p $colC $colC $cyl
	    TraceLiaison $QObj $AC3p $AO3p $colC $colO $cyl
	    if {$o2p} {
		TraceLiaison $QObj $AC2p $AO2p $colC $colO $cyl
	    }
	} else {
	    TraceLiaison $QObj $AP $AC1p $colP $colC $cyl
	}
	if {[llength $rx] <= 11+$of2} {continue}

	# side chain
	# insert C1' first , as we can have 
	# PSU, purine or pyrimidine that connect C1'
	# in different ways
	# Dans certains PDB, il manque des 
	# atomes. On a LYS et les atomes s'
	# arretent a CB .... Dommage !
	set Lb1 [linsert $Lcl 0 $AC1p]
	set Ll1 [lrange $rn end-[expr {[llength $Lb1]-1}] end]
	
	if {[llength $Lb1] > 2 && [llength $Ll1] > 2} {
	    set i 1
	    foreach a1 [lrange $Lb1 0 end-1] l1 [lrange $Ll1 0 end-1] {
		set c1 [CouleurDeAtome $l1]

		set Lb2 [lrange $Lb1 $i end]
		set Ll2 [lrange $Ll1 $i end]
		foreach a2 $Lb2 l2 $Ll2 {
		    if {[Dist2 $a1 $a2] <= 3.8025} {
			TraceLiaison $QObj $a1 $a2 $c1 [CouleurDeAtome $l2] $cyl
		    }
		}
		incr i
	    }
	}
	if {$cp} {
	    if {$first} {
		set first 0
	    } else {
		TraceLiaison $QObj $AP $Cx $colP $colO $cyl
	    }
	    set Cx $AO3p
	}
    }

    return

}

proc DrawAtomsProtein {cp cyl QObj Lx La Ln} {

    # cp : draw main chain
    # cyl : draw as stick or line
    # QObj : quadric object for stick/ball

    set colCA [CouleurDeAtome "C"]
    if {$cp} {
	set first 1
	set colN  [CouleurDeAtome "N"]
	set colC  $colCA
	set colO  [CouleurDeAtome "O"]
    }
    foreach rx $Lx rn $La n $Ln {
	#if {! [EstUnBonResidu $rn]} {continue}
	
	set ACA [lindex $rx 1]
	if {$cp} {
	    set AN  [lindex $rx 0]
	    set AC  [lindex $rx 2]
	    set AO  [lindex $rx 3]
	    
	    # Trace N-CA CA-C C-O
	    TraceLiaison $QObj $AN $ACA ${colN} ${colCA} $cyl
	    TraceLiaison $QObj $ACA $AC ${colCA} ${colC} $cyl
	    TraceLiaison $QObj $AC $AO ${colC} ${colO} $cyl
	}
	
	if {[llength $rx] > 4} {
	    # CA - CB
	    TraceLiaison $QObj $ACA [lindex $rx 4] $colCA $colCA $cyl
	    if {$n eq "PRO"} {		
		TraceLiaison $QObj [lindex $rx 0] [lindex $rx end] [CouleurDeAtome " N  "] [CouleurDeAtome " C  "] $cyl
	    }
	    if {$n eq "ALA"} {continue}

	    set Lb1 [lrange $rx 4 end-1]
	    set Ll1 [lrange $rn 4 end-1]
	    # Dans certains PDB, il manque des 
	    # atomes. Ex, on a LYS et les atomes s'
	    # arretent a CB .... Dommage !
	    if {[llength $Lb1] > 1 && [llength $Ll1] > 1} {
		set i 5
		foreach a1 $Lb1 l1 $Ll1 {
		    set Lb2 [lrange $rx $i end]
		    set Ll2 [lrange $rn $i end]
		    foreach a2 $Lb2 l2 $Ll2 {
			if {[Dist2 $a1 $a2] <= 3.8025} {
			    TraceLiaison $QObj $a1 $a2 [CouleurDeAtome $l1] [CouleurDeAtome $l2] $cyl
			}
		    }
		    incr i
		}
	    }
	}
	if {$cp} {
	    if {$first} {
		set first 0
	    } else {
		# check for correct distance between
		# contiguous residues
		if {[Dist2 [lindex $rx 0] $Cx] <= 3.8025} {
		    TraceLiaison $QObj [lindex $rx 0] $Cx ${colN} ${colC} $cyl
		}
	    }
	    set Cx [lindex $rx 2]
	}
    }
    
    return

}

proc DrawBlast {{FichierBlast ""} {ExpectMax 1.e200} {NbSubjectMax 1.e200} {IdMin 0.0} {TailleMaxDUneRegionNonAlignee 1.e200}} {

    global TabOptionsDeDrawBlast

    if {[winfo children .] != ""} {
	set       w [NomDe drawblast]
	toplevel $w
	wm title    $w "DrawBlast"
	wm iconname $w "DrawBlast"
    } else {
	set w "."
	$w config -bd 3 -relief flat
	wm title    $w "DrawBlast"
	wm iconname $w "DrawBlast"
    }

    AskOptionsDeDrawBlast set $w ExpectMax                     $ExpectMax
    AskOptionsDeDrawBlast set $w NbSubjectMax                  $NbSubjectMax
    AskOptionsDeDrawBlast set $w IdMin                         $IdMin
    AskOptionsDeDrawBlast set $w FichierBlast                  $FichierBlast
    AskOptionsDeDrawBlast set $w BanqueId                      ""
    AskOptionsDeDrawBlast set $w TailleMaxDUneRegionNonAlignee $TailleMaxDUneRegionNonAlignee

    if {$w == "."} {set w ""}
    set    FrameGeneral                    "${w}.frame"
    set       FramePanel                   "$FrameGeneral.framepanel"
    set          FrameFileBlast            "$FramePanel.framefileblast"
    set             ButtonFileBlast        "$FrameFileBlast.buttonfileblast"
    set             EntryFileBlast         "$FrameFileBlast.entryfileblast"
    set       FrameCanva                   "$FrameGeneral.framecanva"
    set          FrameCanvaMosaic          "$FrameCanva.framecanvamosaic"  
    set          FrameCanvaMapping         "$FrameCanva.framecanvamapping"
    set    BoutonLaunch                    "${w}.boutonlaunch"
    set    BoutonFlatFile                  "${w}.boutonflatfile"
    set    BoutonOptions                   "${w}.boutonoptions"
    set    BoutonReset                     "${w}.boutonreset"
    set    BoutonClose                     "${w}.boutonclose"
    if {$w == ""} {set w "."}
    #############################################################
    frame  $FrameGeneral
    frame     $FramePanel 
    frame        $FrameFileBlast
    button          $ButtonFileBlast       -borderwidth 1 -text "Blast File"
    entry           $EntryFileBlast        -borderwidth 1 -textvariable TabOptionsDeDrawBlast($w,FichierBlast)
    frame     $FrameCanva
    frame        $FrameCanvaMosaic
    frame        $FrameCanvaMapping
    button $BoutonLaunch                   -borderwidth 1 -text "LAUNCH"
    button $BoutonFlatFile                 -borderwidth 1 -text "FLAT FILE"
    button $BoutonOptions                  -borderwidth 1 -text "OPTIONS"
    button $BoutonReset                    -borderwidth 1 -text "RESET MEM"
    button $BoutonClose                    -borderwidth 1 -text "CLOSE"
    
    ######################################################################
    
    pack   $FrameGeneral                   -side top -fill both -expand 1
    pack      $FramePanel                  -side top -fill x -expand 0
    pack         $FrameFileBlast           -side top -fill x -expand 0
    pack            $ButtonFileBlast       -side top -fill x -expand 0
    pack            $EntryFileBlast        -side top -fill x -expand 0
    pack      $FrameCanva                  -fill both -side right -expand 1
    pack         $FrameCanvaMosaic         -fill both -side top   -expand 1
    pack         $FrameCanvaMapping        -fill both -side top   -expand 0
    pack   $BoutonLaunch                   -side left -fill x -expand 1
    pack   $BoutonFlatFile                 -side left -fill x -expand 0
    pack   $BoutonOptions                  -side left -fill x -expand 0
    pack   $BoutonReset                    -side left -fill x -expand 0
    pack   $BoutonClose                    -side left -fill x -expand 1
    
    set LargeurFenetre        [expr [winfo screenwidth  .] * 2.0 / 3]
    set HauteurFenetreMosaic  [expr [winfo screenheight .] * 2.0 / 9]
    set HauteurFenetreMapping [expr [winfo screenheight .] * 4.0 / 9]
    
    AskOptionsDeDrawBlast set $w LargeurFenetre        $LargeurFenetre
    AskOptionsDeDrawBlast set $w HauteurFenetreMosaic  $HauteurFenetreMosaic
    AskOptionsDeDrawBlast set $w FrameCanvaMosaic      $FrameCanvaMosaic
    AskOptionsDeDrawBlast set $w HauteurFenetreMapping $HauteurFenetreMapping
    AskOptionsDeDrawBlast set $w FrameCanvaMapping     $FrameCanvaMapping

    if {$FichierBlast != "" && [file exists $FichierBlast]} {
	DrawMosaic  $FichierBlast    $ExpectMax $NbSubjectMax $IdMin ""               $LargeurFenetre $HauteurFenetreMosaic  $FrameCanvaMosaic  $w
	DrawMapping $FichierBlast "" $ExpectMax $IdMin $TailleMaxDUneRegionNonAlignee $LargeurFenetre $HauteurFenetreMapping $FrameCanvaMapping $w
    } else {
	set K [Canva $LargeurFenetre $HauteurFenetreMosaic  $LargeurFenetre $HauteurFenetreMosaic  "NoY" "" "" $FrameCanvaMosaic]
	$K configure -background white
	set K [Canva $LargeurFenetre $HauteurFenetreMapping $LargeurFenetre $HauteurFenetreMapping "NoY" "" "" $FrameCanvaMapping]
	$K configure -background white
    }

    $ButtonFileBlast  configure -command "ChooseBlastFileDrawBlast $w"
    $BoutonLaunch     configure -command "LaunchOrApplyDrawBlast   $w"
    $BoutonFlatFile   configure -command "FlatFileDrawBlast        $w"
    $BoutonOptions    configure -command "DrawBlastOptions         $w"
    $BoutonReset      configure -command "ResetFenetreDrawBlast    $w"
    $BoutonClose      configure -command "CloseFenetreDrawBlast    $w"
    return $w

}

proc DrawBlastOptions {v} {

    global TabOptionsDeDrawBlast

    if {![AskOptionsDeDrawBlast exists $v FenetreBlastOptions]} {
	AskOptionsDeDrawBlast set $v FenetreBlastOptions [NomDe drawblastoptions]
    }
    set w [AskOptionsDeDrawBlast ask $v FenetreBlastOptions]

    if {![winfo exists $w]} {
	toplevel $w
	set    FrameThreshold        "$w.framethreshold"
	set       LabelExpectMax     "$FrameThreshold.labelexpectmax"
	set       EntryExpectMax     "$FrameThreshold.entryexpectmax"
	set       LabelIdMin         "$FrameThreshold.labelidmax"
	set       EntryIdMin         "$FrameThreshold.entryidmax"
	set       LabelNbSubjectMax  "$FrameThreshold.labelnbsubjectmax"
	set       EntryNbSubjectMax  "$FrameThreshold.entrynbsubjectmax"
	set       LabelCompression   "$FrameThreshold.labelcompression"
	set       EntryCompression   "$FrameThreshold.entrycompression"
	set    BoutonApply           "$w.boutonapply"
	set    BoutonDefaut          "$w.boutondefaut"
	set    BoutonClose           "$w.boutonclose"
	
	frame  $FrameThreshold
	label     $LabelExpectMax        -borderwidth 1 -text "Expect Max"
	entry     $EntryExpectMax        -borderwidth 1 -textvariable TabOptionsDeDrawBlast($v,ExpectMax)
	label     $LabelIdMin            -borderwidth 1 -text "Id Min"
	entry     $EntryIdMin            -borderwidth 1 -textvariable TabOptionsDeDrawBlast($v,IdMin)
	label     $LabelNbSubjectMax     -borderwidth 1 -text "Nb Subject Max"
	entry     $EntryNbSubjectMax     -borderwidth 1 -textvariable TabOptionsDeDrawBlast($v,NbSubjectMax)
	label     $LabelCompression      -borderwidth 1 -text "Compression"
	entry     $EntryCompression      -borderwidth 1 -textvariable TabOptionsDeDrawBlast($v,TailleMaxDUneRegionNonAlignee)
	button $BoutonApply              -borderwidth 1 -text "APPLY"
	button $BoutonDefaut             -borderwidth 1 -text "DEFAULT"
	button $BoutonClose              -borderwidth 1 -text "CLOSE"
	
	pack   $FrameThreshold           -side top -fill both
	grid      $LabelExpectMax        -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $EntryExpectMax        -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $LabelIdMin            -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $EntryIdMin            -row 1 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $LabelNbSubjectMax     -row 2 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $EntryNbSubjectMax     -row 2 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $LabelCompression      -row 3 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid      $EntryCompression      -row 3 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	pack   $BoutonApply              -side left -fill x -expand 1
	pack   $BoutonDefaut             -side left -fill x -expand 1
	pack   $BoutonClose              -side left -fill x -expand 1
	
	$BoutonApply    configure -command "LaunchOrApplyDrawBlast $v"
	$BoutonDefaut   configure -command "DefautOptionsDrawBlast $v"
	$BoutonClose    configure -command "destroy   $w"
    }

}

proc DrawChoixDesBoitesDuProjetGscope {FichierGOPourGscope} {

    if {![file exists $FichierGOPourGscope]} {return}

    set FichierOCADE "[file dirname $FichierGOPourGscope]/Orf2Cluster2Access2Def2Expression"
    set FichierNomsInteressants "[file dirname $FichierGOPourGscope]/LesNomsInteressants"
    if {[file exists $FichierOCADE]} {
	set AiJeUnFichierAvecLesInfosDeChaqueSequence 1
	set LesNomsDuProjet [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms]
    } else {
	set AiJeUnFichierAvecLesInfosDeChaqueSequence 0
	set LesNomsDuProjet [InterrogeGeneOntology $FichierGOPourGscope LesNoms]
    }
    if {[file exists $FichierNomsInteressants]} {
	set LesNomsDuProjet [LesLignesDuFichier $FichierNomsInteressants]
    }

    set LesClustersSelectionnes {}
    if {$AiJeUnFichierAvecLesInfosDeChaqueSequence} {
	set LesClusters         {}
	set LesClustersAffiches {}
	foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] {
	    set Taille [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms]]
	    lappend LesClusters $Cluster
	    lappend LesClustersAffiches [format "Cluster %-4s Length %s" $Cluster $Taille]
	}
        foreach Cluster [DrawEntreDeux $LesClusters $LesClustersAffiches] {set TabClusterSelect($Cluster) 1}
    }

    set LesNoms     {}
    set LesAffiches {}
    foreach Nom $LesNomsDuProjet {
	set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster   ]
	set Texte $Nom
	if {$AiJeUnFichierAvecLesInfosDeChaqueSequence} {
	    if {![info exists TabClusterSelect($Cluster)]} {continue}
	    set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster   ]
	    if {$Cluster != ""} {append Texte [format " Cluster %-4s"  $Cluster]}
	    set Access  [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access    ]
	    if {$Access  != ""} {append Texte [format " Acc %-15s"  $Access ]}
	    set Def     [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition]
	    if {$Def     != ""} {append Texte [format " Def %s" $Def    ]}
	}
	lappend LesNoms $Nom 
	lappend LesAffiches [string trim $Texte]
    }
    set     LesNomsSelectionnes {}
    foreach Nom [DrawEntreDeux $LesNoms $LesAffiches] {lappend LesNomsSelectionnes [list $Nom $FichierGOPourGscope]}
    return  $LesNomsSelectionnes

}

proc DrawChoixDesHitsDuBlast {FichierBlast} {

    global ChoixMultipleRadio
    global validOk
    if {![file exists $FichierBlast]} {return}

    set LesValeurs  {}
    set LesAffiches {}
    foreach LeHit [LesHitsDuBlast $FichierBlast 1e200 1e200] {
	if {$LeHit == ""} {continue}
	set BId [lindex $LeHit 0]
	if {$BId   == "" || [regexp {^[0-9]} $BId]} {continue}
	set Acc [lindex $LeHit 1]
	set Exp [lindex $LeHit 2]
	set Sco [lindex $LeHit 3]

	lappend LesValeurs $BId
	set Texte [string trim [format "%-20s %-15s %-10s %-10s" [string range $BId 0 19] $Acc $Exp $Sco]]
	lappend LesAffiches $Texte

	if {$Exp <= 0.001} {set ChoixMultipleRadio($Texte) p} else {set ChoixMultipleRadio($Texte) a}
	if {$Exp <= 0.001} {set ChoixMultipleRadio($BId) p} else {set ChoixMultipleRadio($BId) a}
    }
    if {$LesValeurs == {}} {return} 
    set validOk 1
    return [DrawEntreDeux $LesValeurs $LesAffiches]

}

proc DrawChoixDesHitsDuClustering {FichierDPCouSecator} {

    if {![file exists $FichierDPCouSecator]} {return}
    
    set LesAccess   {}
    set LesAffiches {}
    foreach Cluster    [InterrogeLesClustersDesMSF $FichierDPCouSecator LesClusters                ] {
	foreach Access [InterrogeLesClustersDesMSF $FichierDPCouSecator Cluster $Cluster LesAccess] {
	    if {$Access   == "" || [regexp {^[0-9]} $Access]} {continue}
	    lappend LesAccess   $Access
	    lappend LesAffiches [string trim [format "Cluster %-5s Access %-20s" $Cluster $Access]]
	}
    }
    if {$LesAccess == {}} {return}
    return [DrawEntreDeux $LesAccess $LesAffiches]

}

proc DrawChoixDesHitsDuMSF {FichierMSF} {

    if {![file exists $FichierMSF]} {return}
    set LesAccess  {}
    if {![DecortiqueUnMSF $FichierMSF LesAccess TabSequences]} {return}
    set LesAccessSansLesPDB {}
    foreach Access $LesAccess {
	if {[regexp {^[0-9]} $Access]} {continue}
	lappend LesAccessSansLesPDB $Access
    }
    return [DrawEntreDeux $LesAccessSansLesPDB]

}

proc DrawChooseFile {{Title ""} {Directory ""}} {

    global CurrentDirectory
    if {![info exists CurrentDirectory]} {set CurrentDirectory [ProgSourceDir]}
    if {$Directory != ""} {set CurrentDirectory $Directory}

    set File [tk_getOpenFile -title $Title  -initialdir $CurrentDirectory]
    set CurrentDirectory [file dirname $File]
    return $File

}

proc DrawEntreDeux {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} {

    ######################################################
    ###MODIFICATION DE LA PROC DE J. MULLER LesPEtA    ###
    ######################################################
    
    Wup "Permet une selection entre plusieurs choix"
    return [lindex [LesPresentsEtAbsents $Liste $ListeDeTextes $Invite] 0]

}

proc DrawFeatSum {nom x0 y xd xf {Etiquette 1}} {

    global EFeat TabSF

    set PAD $EFeat(PAD)
    set Lfeat [list]

    # features to be drawn
    foreach e [array names EFeat "LFeat,*"] {
	lassign [split $e ,] tmp ft
	if {$EFeat($e)} {
	    lappend Lfeat $ft
	}
    }

    # x0 est position a droite du champ nom
    set wl $EFeat(WdtL)

    foreach ft $Lfeat {
	set x $x0
	set yl [expr {$y+$EFeat(HgtL) - 1}]
	if {$Etiquette} {
	    $PAD create text $x $y  -justify right  -anchor ne  -text "$ft"  -font FontFeat
	}
	incr x [expr {2 + 2 + $EFeat(WdtCmpt)}]
	if {! [info exists TabSF($nom,$ft)]} {
	    puts "pas de $ft pour $nom"
	    set y [expr {$yl+1}]
	    continue
	}

	foreach e [set TabSF($nom,$ft)] {
	    DecortiqueUneFeature $e d f col sco not
	    if {$f < $xd} {continue}
	    if {$d > $xf} {continue}

	    if {$d < $xd} {
		set xcd $xd
	    } else {
		set xcd $d
	    }
	    if {$f > $xf} {
		set xcf $xf
	    } else {
		set xcf $f
	    }

	    # xcd et xcf sont en CARACTERES unites
	    # xpd et xpf sont en PIXELS unites
	    set xpd [expr {$x + ($xcd-$xd)*$wl}]
	    set xpf [expr {$x + ($xcf-$xd+1)*$wl}]
	    set id [$PAD create rectangle  $xpd $y $xpf $yl  -fill $col  -outline $col]
	    $PAD itemconfig $id  -tags [list TNote Note$id Tx@$not TCoord@${ft}@${nom}@${d}@$f]
	}
	set y [expr {$yl+1}]
    }

    return $y

}

proc DrawGOTreeBall {{LesGO ""} {LargeurMax ""} {HauteurMax ""} {LargeurFenetre ""} {HauteurFenetre ""} {KCanva ""}} {

    if {$LargeurMax     == ""} {set LargeurMax         [expr [winfo screenwidth  .] * 2.0 / 3]}
    if {$HauteurMax     == ""} {set HauteurMax         [expr [winfo screenheight .] * 2.0 / 3]}
    if {$LargeurFenetre == ""} {set LargeurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}
    if {$HauteurFenetre == ""} {set HauteurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}

    if {$KCanva == ""} {
	if {![GODB EstCharge]} {GODB Load}
	if {![2GO  EstCharge]} {2GO  Load}
	set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "NoY" "Gene Ontology"]
	$KCanva configure -background white
    }

    set BordY              50.0
    set BordX              50.0

    set LesTypes  [GODB LesTypes]
    set TousLesGO [GODB LesGO   ]
    if {$LesGO == ""} {
	set LesGO $TousLesGO
    } else {
	set LesGOSelected {}
	foreach GO      $LesGO {
	    set TabDesGOParticuliers($GO,Ref) 1
	    foreach Type [GODB GO $GO LesTypes] {
		set GODeRef [GODB Type $Type GOSynonyme $GO GODeRef]
		set TabDesGOParticuliers($GODeRef,Ref) 1
		lappend LesGOSelected $GODeRef
	    }
	}
	set LesGOSelected [lsort -unique $LesGOSelected]

	foreach GO       [TousLesAncetresGODesGO $LesGOSelected       ] {lappend LesGOSelected                       $GO}
	foreach GOAbsent [LaDifferenceDeL1AvecL2 $TousLesGO moins $LesGOSelected] {set     TabDesGOParticuliers($GOAbsent,Absent) 0  }
    }

    set NivMax -1e200
    set NivMin  1e200
    foreach Type $LesTypes {
	foreach Niv [GODB Type $Type LesNiveaux] {
	    if {$NivMax < $Niv   } {set NivMax $Niv}
	    if {$Niv    < $NivMin} {set NivMin $Niv}
	}
    }

    set LesGOIni {}
    foreach Type $LesTypes {
	foreach GO [GODB Type $Type Niveau $NivMin LesGO] {
	    if {[info exists TabDesExceptions($GO)]} {continue}
	    lappend LesGOIni $GO
	}
    }
    if {$LesGOIni == ""} {return}
    set LesGOIni [lsort -unique $LesGOIni]

    
    set NbNiv [expr $NivMax - $NivMin + 1]

    set nBulles              [llength $LesGOIni]
    set LargeurMinAffichage                      $BordX
    set LargeurMaxAffichage  [expr $LargeurMax - $BordX]

    set LargeurAffichage     [expr $LargeurMaxAffichage - $LargeurMinAffichage]
    set HauteurAffichage     [expr ($HauteurMax - 2*$BordY)*1.0]
    set EcartDeLargeur       [expr $LargeurAffichage    * 1.0 / $nBulles]

    set TailleDUnNiveau      [expr $HauteurAffichage    * 1.0 / ($NbNiv-1)]
    set YDuPremierNiv        $BordY
    set RayonMaxDUneBalle    [expr $YDuPremierNiv * 1.0 / 4]
    set RayonMinDUneBalle    2
        
    for {set i $NivMin} {$i <= $NivMax} {incr i} {
	set YLine [expr $YDuPremierNiv + $i * $TailleDUnNiveau]
	$KCanva create line $LargeurMinAffichage $YLine $LargeurMaxAffichage $YLine -fill lightgrey
	$KCanva create text $LargeurMinAffichage $YLine -anchor e -text "Level $i" -font "arial 10 bold"
	$KCanva create text $LargeurMaxAffichage $YLine -anchor w -text "Level $i" -font "arial 10 bold"
    }

    FDeX INI $NivMin $RayonMaxDUneBalle $NivMax $RayonMinDUneBalle
    for {set i 0} {$i < $nBulles} {incr i} {
	set GOIni [lindex $LesGOIni $i]
	set XMin  [expr $LargeurMinAffichage + $EcartDeLargeur * $i * 1.0]
	set XMax  [expr $XMin                + $EcartDeLargeur           ]
	DrawOneBall $KCanva $GOIni $NivMin $XMin $XMax $YDuPremierNiv $TailleDUnNiveau TabDesGOParticuliers "" ""
    }

    FDeX unset

    $KCanva bind "Affichable"      "AfficheInfoBulle $KCanva %x %y Enter"
    $KCanva bind "Affichable"      "AfficheInfoBulle $KCanva %x %y Leave"
    $KCanva bind "GO"         <1>         "SelectionDuGOPourDrawGOTreeBall $KCanva %x %y Seul"
    $KCanva bind "GO"            "SelectionDuGOPourDrawGOTreeBall $KCanva %x %y AvecCesDescendants"
    $KCanva bind "GO"          "SelectionDuGOPourDrawTreeOneGO  $KCanva %x %y"
    return $KCanva

}

proc DrawGenesFromZone_AECRIRE {Debut Fin Org Chr {Strand ""} {FromWhere ""}} {

    Wup "Attention UCSC compte a partir de 0"
    set LesGenes [GenesFromZone $Debut $Fin $Org $Chr $Strand $FromWhere]
    foreach Gene $LesGenes {
    
    }
    set K [UnCanva ]

}

proc DrawInfo {args} {

    if {$args == ""} {return}

    set Quoi [lindex $args 0]

    set w ""
    if {[string equal -nocase $Quoi "Access"]} {
	set Qui [lindex $args 1]
	set PageInfo [PageInfoLaTotale $Qui protein]
	set w   [lindex $args 2]
    }
    if {[string equal -nocase $Quoi "Interpro"]} {
	set Qui [lindex $args 1]
	set PageInfo [PageInfoLaTotale $Qui interpro]
	set w   [lindex $args 2]
    }
    if {[string equal -nocase $Quoi "Box"]} {
	set FichierGO [lindex $args 1]
	set Nom       [lindex $args 2]
	set w         [lindex $args 3]
	set FichierHTML "[file dirname $FichierGO]/../BilanHTML/$Nom.html"
	if {![file exists $FichierHTML]} {return}
	set PageInfo [ContenuDuFichier $FichierHTML]
    }
    if {[string equal -nocase $Quoi "Brut"]} {
	set PageInfo [lindex $args 1]
	set w        [lindex $args 2]
    }

    set EstCeQueJeFaisPartiDUneAutreFenetre 1
    if {$w == "" || ![winfo exists $w]} {
	set w [NomDe fenetre]
	toplevel $w
	set EstCeQueJeFaisPartiDUneAutreFenetre 0
    }

    set FrameInfo "$w.frameinfo"
    set ListBox  "$FrameInfo.list"
    if {![winfo exists $FrameInfo]} {
	frame $FrameInfo
	pack  $FrameInfo -side top -expand yes -fill both
	scrollbar $FrameInfo.yscroll -command "$ListBox yview"
	scrollbar $FrameInfo.xscroll -command "$ListBox xview" -orient horizontal 
	set Largeur 82
	set Hauteur 35
	listbox $ListBox -width $Largeur -height $Hauteur -setgrid 1  -yscroll "$FrameInfo.yscroll set"  -xscroll "$FrameInfo.xscroll set"  -selectmode extended  -background "LightGrey"  -foreground "Black"  -selectbackground "LightYellow"  -selectforeground "Black"  -font "courier 10" 
	
	grid $FrameInfo.list    -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid $FrameInfo.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
	grid $FrameInfo.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
	grid rowconfig    $FrameInfo 0 -weight 1 -minsize 0
	grid columnconfig $FrameInfo 0 -weight 1 -minsize 0
    }
    if {[winfo exists $ListBox]} {$ListBox delete 0 end}

    set nLignes 0
    foreach Ligne [split $PageInfo "\n"] {	
	if {[string equal -nocase $Quoi "Box"] || [string equal -nocase $Quoi "interpro"] } {
	    regsub -all "\t" $Ligne " " Ligne
	    regsub -all " | " $Ligne " " Ligne
	    regsub -all {<[^>]+>} $Ligne "" Ligne
	    if {[regexp -nocase "
" $Ligne]} {continue}
	}
	if {![string equal -nocase $Quoi "Brut"] && [string trim $Ligne] == ""} {continue}
	$FrameInfo.list insert end $Ligne
    }

    if {!$EstCeQueJeFaisPartiDUneAutreFenetre} {
	set BoutonExit "$w.buttonexit"
	button       $BoutonExit  -borderwidth 1 -text "CLOSE"
	pack         $BoutonExit   -fill x    -side bottom -expand 0
	$BoutonExit configure -command "destroy $w"
    }
    return $ListBox

}

proc DrawInfoDeDrawBlast {w {Kcanva ""} {PageInfoOuAliouToutLAliouToutLeBlast Ali}} {

    if {![AskOptionsDeDrawBlast exists LesBIdStockeAvecLeurPageInfo]} {
	AskOptionsDeDrawBlast set LesBIdStockeAvecLeurPageInfo {}
    }

    if {[string equal -nocase $w "unset"]} {
	foreach BId [AskOptionsDeDrawBlast ask LesBIdStockeAvecLeurPageInfo] {
	    AskOptionsDeDrawBlast unset $BId PageInfo
	}
	AskOptionsDeDrawBlast set LesBIdStockeAvecLeurPageInfo {}
	return
    }

    set Id           [$Kcanva  find withtag current]
    set MesTags      [$Kcanva  gettags  $Id]
    set FichierBlast [lindex   $MesTags 1  ]
    set BId          [lindex   $MesTags 2  ]
    set Segment      [lindex   $MesTags 3  ]

    if {$PageInfoOuAliouToutLAliouToutLeBlast == "ToutLeBlast"} {
	set Info [ContenuDuFichier $FichierBlast]
    }
    if {$PageInfoOuAliouToutLAliouToutLeBlast == "Ali"     } {
	if {$Segment == "All"} {
	    set Info [AskBlast $FichierBlast BanqueId $BId SubjectBrut]
	} else {
	    set Info [AskBlast $FichierBlast BanqueId $BId Segment $Segment AlignBrut]
	}
    }
    if {$PageInfoOuAliouToutLAliouToutLeBlast == "ToutLAli"} {
	set Info [AskBlast $FichierBlast BanqueId $BId SubjectBrut]
    }
    if {$PageInfoOuAliouToutLAliouToutLeBlast == "PageInfo"} {
	if {![info exists TabOptionsDeDrawBlast($BId,PageInfo)]} {
	    AskOptionsDeDrawBlast append LesBIdStockeAvecLeurPageInfo $BId
	    AskOptionsDeDrawBlast set    $BId PageInfo                [PageInfoLaTotale $BId "unknown"]
	}
	set Info [AskOptionsDeDrawBlast ask    $BId PageInfo]
    }
    if {$Info == ""} {return}
    
    DrawInfo Brut $Info

    return
    if {![AskOptionsDeDrawBlast exists $w ListBox]} {
	AskOptionsDeDrawBlast set $w ListBox [DrawInfo Brut ""]
    }
    set ListBox [AskOptionsDeDrawBlast ask $w ListBox]
    if {![winfo exists $ListBox]} {
	AskOptionsDeDrawBlast set $w ListBox [DrawInfo Brut ""]
    }
    set ListBox [AskOptionsDeDrawBlast ask $w ListBox]

    $ListBox delete 0 end
    foreach Ligne [split $Info "\n"] {$ListBox insert end $Ligne}

}

proc DrawMapping {FichierBlast {BanqueId ""} {ExpectMax 1e200} {IdMin 0.0} {TailleMaxDUneRegionNonAlignee 500} {LargeurFenetre ""} {HauteurFenetre ""} {KCanva ""} {w ""}} {


    if {![file exists $FichierBlast]} {return}
    set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast]
    set Query       [AskBlast $FichierBlast Query      ]
    set TailleQ     [AskBlast $FichierBlast Taille     ]
    if {$TailleQ == ""} {return}


    if {$BanqueId != ""} {
	set NbSegment [AskBlast $FichierBlast BanqueId $BanqueId NbSegment]
	set AiJeRecontreUnSegment 0
	for {set j 1} {$j <= $NbSegment} {incr j} {
	    set Expect     [AskBlast $FichierBlast BanqueId $BanqueId Segment $j Expect    ]
	    set Identities [AskBlast $FichierBlast BanqueId $BanqueId Segment $j Identities]
	    if {$Expect == "" || $Identities == ""} {continue}
	    scan $Identities "%d/%d" n nTot
	    set Id [expr $n*1.0/$nTot]
	    if {$ExpectMax < $Expect} {continue}
	    if {$Id < $IdMin} {continue}
	    set AiJeRecontreUnSegment 1
	    break
	}
	if {!$AiJeRecontreUnSegment} {set BanqueId ""}
    }
    if {$BanqueId == ""} {
	set NbSubject [AskBlast $FichierBlast NbSubject]
	for {set i 1} {$i <= $NbSubject} {incr i} {
	    set BId       [AskBlast $FichierBlast Subject $i]
	    set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment]
	    set AiJeRecontreUnSegment 0
	    for {set j 1} {$j <= $NbSegment} {incr j} {
		set Expect     [AskBlast $FichierBlast BanqueId $BId Segment $j Expect    ]
		set Identities [AskBlast $FichierBlast BanqueId $BId Segment $j Identities]
		if {$Expect == "" || $Identities == ""} {continue}
		scan $Identities "%d/%d" n nTot
		set Id [expr $n*1.0/$nTot]
		if {$ExpectMax < $Expect} {continue}
		if {$Id < $IdMin} {continue}
		
		set AiJeRecontreUnSegment 1
		break
	    }
	    if {!$AiJeRecontreUnSegment} {continue}
	    set BanqueId $BId
	    break
	}
    }
    if {$BanqueId == ""} {
	Canva $LargeurFenetre $HauteurFenetre $LargeurFenetre $HauteurFenetre "NoY" "" "" $KCanva
	$KCanva configure -background white
	return
    }

    set TailleS     [AskBlast $FichierBlast BanqueId $BanqueId Taille   ]
    set NbSegment   [AskBlast $FichierBlast BanqueId $BanqueId NbSegment]
    if {$NbSegment == "" || $TailleS == ""} {return}

    if {$LargeurFenetre == ""} {set LargeurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}
    if {$HauteurFenetre == ""} {set HauteurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}
    set LargeurMax       $LargeurFenetre
    set HauteurMax       $HauteurFenetre
    set BordX            [expr $LargeurFenetre * 1.0 / 4 ]
    set BordY            [expr $HauteurFenetre * 1.0 / 10]
    if {$BordY < 30} {set BordY 40}
    set EcartY           10.0
    set HBox             25.0
    set HSmallBox        15.0
    set LargeurAffichage [expr $LargeurFenetre - 2 * $BordX]
    set FacteurXDeQ      [expr $LargeurAffichage * 1.0 / $TailleQ]
    set FacteurXDeS      [expr $LargeurAffichage * 1.0 / $TailleS]

    set TailleDansLeSensPlus  0
    set TailleDansLeSensMoins 0
    
    set LesRegionsDuSubject        {}
    set LesRegionsUniquesDuSubject {}
    set LesRegionsDeLaQuery        {}
    set LesRegionsUniquesDeLaQuery {}
    for {set Seg 1} {$Seg <= $NbSegment} {incr Seg} {
	set Expect     [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg Expect    ]
	if {$ExpectMax < $Expect} {continue}
	set Identities [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg Identities]
	scan $Identities "%d/%d" n nTot
	set Id [expr $n*1.0/$nTot]
	if {$Id < $IdMin} {continue}

	set Orientation  [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg Orientation]
	if {$Orientation == ""} {set Orientation "Prot / Prot"}

	set Sens [SensDeLaRegion $Orientation]
	set DQ [Mini [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg DQ] [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg FQ]]
	set FQ [Maxi [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg DQ] [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg FQ]]
	set DS [Mini [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg DS] [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg FS]]
	set FS [Maxi [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg DS] [AskBlast $FichierBlast BanqueId $BanqueId Segment $Seg FS]]

	if {$Sens == "+"} {incr TailleDansLeSensPlus [expr $FQ - $DQ + 1]} else {incr TailleDansLeSensMoins [expr $FQ - $DQ + 1]}

	if {![info exists Tab(Query,$DQ,$FQ,RegionOccupee)]} {
	    set     Tab(Query,$DQ,$FQ,RegionOccupee)   1
	    lappend LesRegionsUniquesDeLaQuery [list $DQ $FQ]
	}
	lappend LesRegionsDeLaQuery [list $DQ $FQ $DS $FS $Orientation $Id $Seg]
	if {![info exists Tab(Subject,$DS,$FS,RegionOccupee)]} {
	    set     Tab(Subject,$DS,$FS,RegionOccupee) 1
	    lappend LesRegionsUniquesDuSubject [list $DS $FS]
	}
	lappend LesRegionsDuSubject [list $DS $FS $DQ $FQ $Orientation $Id $Seg]
    }
    if {$LesRegionsDuSubject == {} || $LesRegionsDeLaQuery == {}} {return}
    set SensGeneral "+"
    if {$TailleDansLeSensMoins > $TailleDansLeSensPlus} {set SensGeneral "-"}

    set LesPetitesRegionsUniquesDeLaQuery  [LesPetitesRegionsDesGrandesRegions  $LesRegionsUniquesDeLaQuery]
    foreach LaRegion [LesRegionsAbsentesDesPetitesRegions $LesPetitesRegionsUniquesDeLaQuery 1 $TailleQ] {
	lappend LaRegion "Absente"
	lappend LesPetitesRegionsUniquesDeLaQuery $LaRegion
    }

    set TailleDeLaSeqReduiteQ       0
    set TailleDeLaReduction         0
    foreach LaRegion [lsort -index 0 -real $LesPetitesRegionsUniquesDeLaQuery] {
	set DQ     [lindex $LaRegion 0]
	set FQ     [lindex $LaRegion 1]
	set Type   [lindex $LaRegion 2]

	set Taille [expr   $FQ-$DQ + 1]

	set  DRed                      [expr $DQ - $TailleDeLaReduction]
	set  FRed                      [expr $FQ - $TailleDeLaReduction]
	if {$Type == "Absente" && $TailleMaxDUneRegionNonAlignee < $Taille} {
	    set  FRed                  [expr $DRed + $TailleMaxDUneRegionNonAlignee - 1]
	    incr TailleDeLaReduction   [expr $Taille - $TailleMaxDUneRegionNonAlignee]
	    incr TailleDeLaSeqReduiteQ $TailleMaxDUneRegionNonAlignee
	} else {
	    incr TailleDeLaSeqReduiteQ $Taille
	}
	set TabRed(Query,$DQ) $DRed
	set TabRed(Query,$FQ) $FRed
    }
    
    set FacteurQX [expr $LargeurAffichage * 1.0 / $TailleDeLaSeqReduiteQ]

    set LesFormesAPlacer {}
    lappend LesFormesAPlacer [list text  [expr $LargeurFenetre*1.0/2] [expr $BordY*1.0/3] "center" "QUERY : [string range $Query end-30 end]"]
    lappend LesFormesAPlacer [list text  [expr $LargeurFenetre*1.0/2] [expr $BordY*2.0/3] "center" "BLAST : $TypeDeBlast"                    ]

    set     XMin             $BordX
    set     YMin             $BordY
    set     XMax             [expr $XMin + $LargeurAffichage]
    set     YMax             [expr $YMin + $HBox]
    set     YText            [expr $YMin + ($YMax - $YMin)/2]
    lappend LesFormesAPlacer [list rectangle $XMin           $YMin $XMax $YMax "lightgrey" "black" 3]
    lappend LesFormesAPlacer [list text      [expr $XMin-1]  $YText "e"  1                          ]
    lappend LesFormesAPlacer [list text      [expr $XMax+1]  $YText "w"  $TailleQ                   ]

    set HauteurAffichage [expr $HauteurMax - 2 * ($BordY + $HBox + $EcartY)]
    set YMinDeRef [expr $BordY + $HBox + $EcartY]

    set NiveauMaxDeRef [expr int($HauteurAffichage * 1.0 / ($HSmallBox + $EcartY)/2)]
    set NiveauMin 0
    set NiveauMax 0

    foreach LaRegion $LesRegionsDeLaQuery {
	set DQ  [lindex $LaRegion 0]
	set FQ  [lindex $LaRegion 1]

	if {![info exists Tab(Query,$DQ,$FQ,RegionOccupee)]} {continue}
	if {![info exists TabRed(Query,$DQ)               ]} {continue}
	if {![info exists TabRed(Query,$FQ)               ]} {continue}

	set DQR [set TabRed(Query,$DQ)]
	set FQR [set TabRed(Query,$FQ)]

	set DS     [lindex $LaRegion 2]
	set FS     [lindex $LaRegion 3]
	set Orient [lindex $LaRegion 4]
	set Id     [lindex $LaRegion 5]
	set Seg    [lindex $LaRegion 6]

	set ColorFill    [ColoriageDeLIdDeDrawBlast     $Id    ]
	set ColorOutLine [ColoriageDuMappingDeDrawBlast $Orient]

	set AiJeRencontreUnNiveauAvecDeLaPlace 0
	for {set Niv $NiveauMin} {$Niv <= $NiveauMax} {incr Niv} {
	    if {![info exists TabNiveau($Niv,LesRegions)]} {set TabNiveau($Niv,LesRegions) {}}
	    set AiJeRencontreUnePlaceACeNiveau 1
	    foreach LaRegionDuNiveau [set TabNiveau($Niv,LesRegions)] {
		set DNiv [lindex $LaRegionDuNiveau 0]
		set FNiv [lindex $LaRegionDuNiveau 1]
		if {[CesRegionsSontEllesOverlappantes $DQ $FQ $DNiv $FNiv]} {
		    set AiJeRencontreUnePlaceACeNiveau 0
		    break
		}
	    }
	    if {$AiJeRencontreUnePlaceACeNiveau} {
		set     NiveauVide                         $Niv
		lappend TabNiveau($NiveauVide,LesRegions)  [list $DQ $FQ]
		set     AiJeRencontreUnNiveauAvecDeLaPlace 1
		break
	    }
	}
	if {!$AiJeRencontreUnNiveauAvecDeLaPlace} {
	    incr    NiveauMax
	    set     NiveauVide                        $NiveauMax
	    set     TabNiveau($NiveauVide,LesRegions) {}
	    lappend TabNiveau($NiveauVide,LesRegions) [list $DQ $FQ]
	}

	if {$NiveauMaxDeRef < $NiveauVide} {set NiveauVide $NiveauMaxDeRef}

	set XMin    [expr ($DQR-1)   * $FacteurQX + $BordX]
	set YMin    [expr $YMinDeRef + $NiveauVide * ($HSmallBox + $EcartY)]
	set XMax    [expr $FQR       * $FacteurQX + $BordX]
	set YMax    [expr $YMin      + $HSmallBox                          ]

	set LesTags [list "Box" $FichierBlast $BanqueId $Seg]

	set Tab(DQ,$DQ,FQ,$FQ,LesCoordonnees) [list $XMin $YMax $XMax $YMax]

	lappend LesFormesAPlacer [list rectangle $XMin $YMin $XMax $YMax $ColorFill $ColorOutLine 2 $LesTags]
    }


    set LesPetitesRegionsUniquesDuSubject  [LesPetitesRegionsDesGrandesRegions  $LesRegionsUniquesDuSubject]
    foreach LaRegion [LesRegionsAbsentesDesPetitesRegions $LesPetitesRegionsUniquesDuSubject 1 $TailleS] {
	lappend LaRegion "Absente"
	lappend LesPetitesRegionsUniquesDuSubject $LaRegion
    }

    set TailleDeLaSeqReduiteS       0
    set TailleDeLaReduction         0
    foreach LaRegion [lsort -index 0 -real $LesPetitesRegionsUniquesDuSubject] {
	set DS     [lindex $LaRegion 0]
	set FS     [lindex $LaRegion 1]
	set Type   [lindex $LaRegion 2]

	set Taille [expr   $FS-$DS + 1]

	set  DRed                      [expr $DS - $TailleDeLaReduction]
	set  FRed                      [expr $FS - $TailleDeLaReduction]
	if {$Type == "Absente" && $TailleMaxDUneRegionNonAlignee < $Taille} {
	    set  FRed                  [expr $DRed + $TailleMaxDUneRegionNonAlignee - 1]
	    incr TailleDeLaReduction   [expr $Taille - $TailleMaxDUneRegionNonAlignee]
	    incr TailleDeLaSeqReduiteS $TailleMaxDUneRegionNonAlignee
	} else {
	    incr TailleDeLaSeqReduiteS $Taille
	}
	set TabRed(Subject,$DS) $DRed
	set TabRed(Subject,$FS) $FRed
    }
    set FacteurSX [expr $LargeurAffichage * 1.0 / $TailleDeLaSeqReduiteS]

    set     XMin             $BordX
    set     YMin             [expr $HauteurMax - $BordY - $HBox]
    set     XMax             [expr $XMin + $LargeurAffichage]
    set     YMax             [expr $YMin + $HBox]
    set     YText            [expr $YMin + ($YMax - $YMin)/2]
    lappend LesFormesAPlacer [list rectangle $XMin           $YMin $XMax $YMax "lightgrey" "black" 3]
    lappend LesFormesAPlacer [list text  [expr $LargeurFenetre*1.0/2] [expr $HauteurMax - $BordY*1.0/3] "center" "SBJCT : $BanqueId"]

    if {$SensGeneral == "+"} {
	lappend LesFormesAPlacer [list text      [expr $XMin-1]  $YText "e"  1                          ]
	lappend LesFormesAPlacer [list text      [expr $XMax+1]  $YText "w"  $TailleS                   ]
    } else {
	lappend LesFormesAPlacer [list text      [expr $XMin-1]  $YText "e"  $TailleS                   ]
	lappend LesFormesAPlacer [list text      [expr $XMax+1]  $YText "w"  1                          ]
    }
    foreach LaRegion $LesRegionsDuSubject {
	set DS    [lindex $LaRegion 0]
	set FS    [lindex $LaRegion 1]

	if {![info exists Tab(Subject,$DS,$FS,RegionOccupee)]} {continue}
	if {![info exists TabRed(Subject,$DS)               ]} {continue}
	if {![info exists TabRed(Subject,$FS)               ]} {continue}

	set DSR    [set TabRed(Subject,$DS)]
	set FSR    [set TabRed(Subject,$FS)]
	set DQ     [lindex $LaRegion 2]
	set FQ     [lindex $LaRegion 3]
	set Orient [lindex $LaRegion 4]
	set Id     [lindex $LaRegion 5]
	set Seg    [lindex $LaRegion 6]

	set ColorFill    [ColoriageDeLIdDeDrawBlast    $Id    ]
	set ColorOutLine [ColoriageDuMappingDeDrawBlast $Orient]

	if {$SensGeneral == "-"} {
	    set XMax  [expr $LargeurMax - (($DSR-1) * $FacteurSX + $BordX)]
	    set XMin  [expr $LargeurMax - ($FSR     * $FacteurSX + $BordX)]
	} else {
	    set XMin  [expr ($DSR-1) * $FacteurSX + $BordX]
	    set XMax  [expr $FSR     * $FacteurSX + $BordX]
	}

	set LesTags [list "Box" $FichierBlast $BanqueId $Seg]

	if {![info exists Tab(Subject,Box,$DS,$FS)]} {
	    set     Tab(Subject,Box,$DS,$FS) 1
	    lappend LesFormesAPlacer [list rectangle $XMin $YMin $XMax $YMax $ColorFill $ColorOutLine 2 $LesTags]
	}
	set XLineS1 $XMin
	set YLineS1 $YMin
	set XLineS2 $XMax
	set YLineS2 $YMin

	set LesCoordonnees [set Tab(DQ,$DQ,FQ,$FQ,LesCoordonnees)]
	set XLineQ1 [lindex $LesCoordonnees 0]
	set YLineQ1 [lindex $LesCoordonnees 1]
	set XLineQ2 [lindex $LesCoordonnees 2]
	set YLineQ2 [lindex $LesCoordonnees 3]
	
	lappend LesFormesAPlacer [list line $XLineQ1 $YLineQ1 $XLineS1 $YLineS1 $ColorOutLine]
	lappend LesFormesAPlacer [list line $XLineQ2 $YLineQ2 $XLineS2 $YLineS2 $ColorOutLine]
    }

    #######CREATION DES FORMES##################

    set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "NoY" "BlastTools" "" $KCanva]
    $KCanva configure -background white

    set i 0
    foreach LaForme $LesFormesAPlacer {

	set Forme    [lindex $LaForme 0]
	set XMin     [lindex $LaForme 1]
	set YMin     [lindex $LaForme 2]

	if {$Forme == "text"} {
	    set Anch    [lindex $LaForme 3]
	    set Text    [lindex $LaForme 4]
	    set LesTags [lindex $LaForme 5]

	    $KCanva create text $XMin $YMin -text $Text -anchor $Anch -font "courier 10" -tags $LesTags
	    continue
	}
	set XMax     [lindex $LaForme 3]
	set YMax     [lindex $LaForme 4]
	set Color    [lindex $LaForme 5]
	if {$Forme == "rectangle"} {
	    set COutLine [lindex $LaForme 6]
	    set Width    [lindex $LaForme 7]
	    set LesTags  [lindex $LaForme 8]

	    $KCanva create rectangle $XMin $YMin $XMax $YMax -fill $Color -outline $COutLine -width $Width -tags $LesTags
	    continue
	}
	if {$Forme == "line"} {
	    if {[lindex $LaForme 6] == "dash"} {
		$KCanva create line      $XMin $YMin $XMax $YMax -fill $Color -dash {4 2}
	    } else {
		$KCanva create line      $XMin $YMin $XMax $YMax -fill $Color
	    }
	    continue
	}
    }

    $KCanva bind "Box" <1>     "DrawInfoDeDrawBlast $w $KCanva Ali     "
    $KCanva bind "Box" <2>     "DrawInfoDeDrawBlast $w $KCanva ToutLAli"
    $KCanva bind "Box" <3>     "DrawInfoDeDrawBlast $w $KCanva PageInfo"

}

proc DrawMappingPourDrawBlast {w K} {

    set Id           [$K find withtag current]
    set MesTags      [$K gettags $Id]
    set BId          [lindex $MesTags 2]

    set FichierBlast                  [AskOptionsDeDrawBlast ask $w FichierBlast                 ]
    set ExpectMax                     [AskOptionsDeDrawBlast ask $w ExpectMax                    ]
    set IdMin                         [AskOptionsDeDrawBlast ask $w IdMin                        ]
    set TailleMaxDUneRegionNonAlignee [AskOptionsDeDrawBlast ask $w TailleMaxDUneRegionNonAlignee]
    set LargeurFenetre                [AskOptionsDeDrawBlast ask $w LargeurFenetre               ]
    set FrameCanvaMapping             [AskOptionsDeDrawBlast ask $w FrameCanvaMapping            ]
    set HauteurFenetreMapping         [AskOptionsDeDrawBlast ask $w HauteurFenetreMapping        ]

    AskOptionsDeDrawBlast set $w BanqueId $BId

    if {$FichierBlast == ""} {return}

    DrawMapping $FichierBlast $BId $ExpectMax $IdMin $TailleMaxDUneRegionNonAlignee $LargeurFenetre $HauteurFenetreMapping $FrameCanvaMapping $w

}

proc DrawMosaic {FichierBlast {ExpectMax 1e200} {NbSubjectMax 1e200} {IdMin 0.0} {LesBanqueId ""} {LargeurFenetre ""} {HauteurFenetre ""} {KCanva ""} {w ""}} {


    if {![file exists $FichierBlast]} {return}
    set TailleQ     [AskBlast $FichierBlast Taille]
    set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast]
    set Query       [AskBlast $FichierBlast Query]
    
    if {$TailleQ == ""} {return}

    if {$LargeurFenetre == ""} {set LargeurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}
    if {$HauteurFenetre == ""} {set HauteurFenetre     [expr [winfo screenheight .] * 2.0 / 3]}
    set LargeurMax       $LargeurFenetre
    set HauteurMax       $HauteurFenetre
    set BordX            [expr $LargeurFenetre * 1.0 / 4 ]
    set BordY            [expr $HauteurFenetre * 1.0 / 10]
    if {$BordY < 30} {set BordY 40}

    set EcartY           10.0
    set HBox             25.0
    set HSmallBox        15.0
    set LargeurAffichage [expr $LargeurFenetre - 2 * $BordX]
    set FacteurX         [expr $LargeurAffichage * 1.0 / $TailleQ]

    set LaFrequenceDesPetitesRegionsDuBlast [LaFrequenceDesPetitesRegionsDeLaQueryDuBlast $FichierBlast $ExpectMax $NbSubjectMax $IdMin "No" $LesBanqueId]
    if {$LaFrequenceDesPetitesRegionsDuBlast == {}} {
	Canva $LargeurFenetre $HauteurFenetre $LargeurFenetre $HauteurFenetre "NoY" "" "" $KCanva
	$KCanva configure -background white
	return
    }
    set LesFormesAPlacer {}

    lappend LesFormesAPlacer [list text  [expr $LargeurFenetre*1.0/2] [expr $BordY*1.0/3] "center" "QUERY : [string range $Query end-30 end]"]
    lappend LesFormesAPlacer [list text  [expr $LargeurFenetre*1.0/2] [expr $BordY*2.0/3] "center" "BLAST : $TypeDeBlast"                    ]

    set     YMin             $BordY
    set     XMin             $BordX
    set     YMax             [expr $YMin + $HBox]
    set     XMax             [expr $XMin + $LargeurAffichage]
    set     YText            [expr $YMin + ($YMax - $YMin)/2]

    lappend LesFormesAPlacer [list rectangle $XMin           $YMin $XMax $YMax "lightgrey" "black" 3]
    lappend LesFormesAPlacer [list text      [expr $XMin-1]  $YText "e"  1                                     ]
    lappend LesFormesAPlacer [list text      [expr $XMax+1]  $YText "w"  $TailleQ                              ]
    lappend LesFormesAPlacer [list text      $LargeurFenetre $YMax  "ne" [format "%10s %10s" "Length" "Expect"]]
    
    foreach LaFrequenceDeLaRegion $LaFrequenceDesPetitesRegionsDuBlast {
	set Deb     [lindex $LaFrequenceDeLaRegion 0]
	set Fin     [lindex $LaFrequenceDeLaRegion 1]
	set XMin    [expr ($Deb-1) * $FacteurX + $BordX]
	set XMax    [expr $Fin     * $FacteurX + $BordX]

	set Freq    [lindex $LaFrequenceDeLaRegion 2    ]
	set Couleur [ColoriageDeLaFrequenceDeDrawBlast        $Freq]
	lappend LesFormesAPlacer [list rectangle $XMin $YMin $XMax $YMax $Couleur $Couleur 1]
    }
    set YMinDeRef [expr $YMax + $EcartY]

    foreach BId $LesBanqueId {set TabSelect($BId) 1}

    set k 0
    set NbSubject [AskBlast $FichierBlast NbSubject]
    for {set i 1;set NiveauMinDeRef 1} {$i <= $NbSubject} {incr i;incr NiveauMinDeRef} {
	set BId         [AskBlast $FichierBlast Subject  $i              ]
	set NbSegment   [AskBlast $FichierBlast BanqueId $BId NbSegment  ]
	set TailleS     [AskBlast $FichierBlast BanqueId $BId Taille     ]

	if {$LesBanqueId != "" && ![info exists TabSelect($BId)]} {incr NiveauMinDeRef -1;continue}

	set YLigne [expr $YMinDeRef + ($NiveauMinDeRef-1) * ($HSmallBox + $EcartY) + $EcartY * 1.0 / 2]

	if {[info exists TabNiveau]} {unset TabNiveau}

	set LesFormesAPlacerDuSubject {}
	set NiveauMaxDuSubject $NiveauMinDeRef
	for {set j 1} {$j <= $NbSegment} {incr j} {
	    set Expect [AskBlast $FichierBlast BanqueId $BId Segment $j Expect]
	    if {$ExpectMax  < $Expect} {continue}

	    set Identities [AskBlast $FichierBlast BanqueId $BId Segment $j Identities]
	    scan $Identities "%d/%d" n nTot
	    set Id [expr $n*1.0/$nTot]
	    if {$Id < $IdMin} {continue}

	    set ColorFill  [ColoriageDeLIdDeDrawBlast $Id]
	    
	    set TypeRegion [AskBlast $FichierBlast BanqueId $BId Segment $j Orientation]
	    if {$TypeRegion == "" && [regexp "BLASTP" $TypeDeBlast]} {set TypeRegion "Prot / Prot"}
	    set ColorOutLine [ColoriageDuMappingDeDrawBlast $TypeRegion]

	    set DQ [Mini [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]]
	    set FQ [Maxi [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]]

	    set AiJeRencontreUnNiveauAvecDeLaPlace 0
	    for {set Niv $NiveauMinDeRef} {$Niv <= $NiveauMaxDuSubject} {incr Niv} {
		if {![info exists TabNiveau($Niv,LesRegions)]} {set TabNiveau($Niv,LesRegions) {}}
		set AiJeRencontreUnePlaceACeNiveau 1
		foreach LaRegion [set TabNiveau($Niv,LesRegions)] {
		    set DR [lindex $LaRegion 0]
		    set FR [lindex $LaRegion 1]
		    if {[CesRegionsSontEllesOverlappantes $DQ $FQ $DR $FR]} {
			set AiJeRencontreUnePlaceACeNiveau 0
			break
		    }
		}
		if {$AiJeRencontreUnePlaceACeNiveau} {
		    set     AiJeRencontreUnNiveauAvecDeLaPlace 1
		    lappend TabNiveau($Niv,LesRegions) [list $DQ $FQ]
		    set     NiveauVide                         $Niv
		    break
		}
	    }
	    if {!$AiJeRencontreUnNiveauAvecDeLaPlace} {
		incr    NiveauMaxDuSubject
		set     NiveauVide                        $NiveauMaxDuSubject
		set     TabNiveau($NiveauVide,LesRegions) {}
		lappend TabNiveau($NiveauVide,LesRegions) [list $DQ $FQ]
	    }

	    set XMin [expr ($DQ-1) * $FacteurX + $BordX]
	    set YMin [expr $YMinDeRef + $NiveauVide * ($HSmallBox + $EcartY) - $HSmallBox]
	    set XMax [expr  $FQ    * $FacteurX + $BordX]
	    set YMax [expr $YMin      + $HSmallBox                                      ]

	    if {$HauteurMax < $YMax} {set HauteurMax $YMax}

	    set LesTags   [list "Box" $FichierBlast $BId $j]
	    lappend LesFormesAPlacerDuSubject [list rectangle $XMin $YMin $XMax $YMax $ColorFill $ColorOutLine 2 $LesTags]
	}
	if {$LesFormesAPlacerDuSubject == {}} {incr NiveauMinDeRef -1;continue}

	incr k
	if {$NbSubjectMax < $k} {break}

	set NiveauMinDeRef $NiveauMaxDuSubject

	set Expect [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect]
	
	set LesTags   [list "Box" $FichierBlast $BId All]

	set XMin 0
	set XMax $LargeurFenetre
	lappend LesFormesAPlacer [list line $XMin $YLigne $XMax $YLigne "black" "dash"]
	lappend LesFormesAPlacer [list text $XMin [expr $YLigne+1] "nw" $BId                                  $LesTags]
	lappend LesFormesAPlacer [list text $XMax [expr $YLigne+1] "ne" [format "%10s %10s" $TailleS $Expect] $LesTags]

	foreach LaForme $LesFormesAPlacerDuSubject {
	    lappend LesFormesAPlacer $LaForme
	}
    }
    #######CREATION DES FORMES##################
    set HauteurMax [expr $HauteurMax + $EcartY]
    set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "NoY" "BlastTools" "" $KCanva]
    $KCanva configure -background white

    set i 0
    foreach LaForme $LesFormesAPlacer {
	set Forme    [lindex $LaForme 0]
	set XMin     [lindex $LaForme 1]
	set YMin     [lindex $LaForme 2]

	if {$Forme == "text"} {
	    set Anch    [lindex $LaForme 3]
	    set Text    [lindex $LaForme 4]
	    set LesTags [lindex $LaForme 5]

	    $KCanva create text $XMin $YMin -text $Text -anchor $Anch -font "courier 12" -tags $LesTags
	    continue
	}
	set XMax     [lindex $LaForme 3]
	set YMax     [lindex $LaForme 4]
	set Color    [lindex $LaForme 5]
	if {$Forme == "rectangle"} {
	    set COutLine [lindex $LaForme 6]
	    set Width    [lindex $LaForme 7]
	    set LesTags  [lindex $LaForme 8]

	    $KCanva create rectangle $XMin $YMin $XMax $YMax -fill $Color -outline $COutLine -width $Width -tags $LesTags
	    continue
	}
	if {$Forme == "line"} {
	    if {[lindex $LaForme 6] == "dash"} {
		$KCanva create line      $XMin $YMin $XMax $YMax -fill $Color -dash {4 2}
	    } else {
		$KCanva create line      $XMin $YMin $XMax $YMax -fill $Color
	    }
	    continue
	}
    }

    $KCanva bind "Box" <1>          "DrawInfoDeDrawBlast      $w $KCanva Ali     "
    $KCanva bind "Box" <2>          "DrawInfoDeDrawBlast      $w $KCanva ToutLAli"
    $KCanva bind "Box" <3>          "DrawInfoDeDrawBlast      $w $KCanva PageInfo"
    $KCanva bind "Box"     "DrawMappingPourDrawBlast $w $KCanva" 

}

proc DrawOneBall {K GO Niveau XMin XMax Y TailleDUnNiveau aTabDesGOParticuliers {XPere ""} {PartOfouSubclassOf ""}} {

    upvar $aTabDesGOParticuliers TabDesGOParticuliers

    ##########################################################
    #####INFORMATION SPECIFIQUE DE CHAQUE GO SUR L'ARBRE######
    #####TAGS#################################################
    set LeTexte        {}
    set LesTypes       [GODB GO $GO LesTypes]
    set LesDefinitions {}
    set LesGO          {}
    set LesGOChild     {}
    foreach Type $LesTypes {
	set GO [GODB Type $Type GOSynonyme $GO GODeRef]
	if {[info exists TabTmp($GO)]} {continue}
	set     TabTmp($GO) 1
	lappend LesGO $GO
	foreach GOSynonyme [GODB Type $Type GO $GO LesSynonymes] {
	    if {[info exists TabTmp($GOSynonyme)]} {continue}
	    set     TabTmp($GOSynonyme) 1
	    lappend LesGO $GOSynonyme
	}
    }
    foreach GO [lsort -unique $LesGO] {
	foreach Type [GODB GO $GO LesTypes] {
	    foreach Definition [GODB Type $Type GO $GO LesDefinitions] {
		if {[info exists TabTmp($Definition)]} {continue}
		set     TabTmp($Definition) 1
		lappend LesDefinitions      $Definition
	    }
	    foreach GOSynonyme [GODB Type $Type GO $GO LesSynonymes] {
		if {[info exists TabTmp($GOSynonyme)]} {continue}
		set     TabTmp($GOSynonyme) 1
		lappend LesGO $GOSynonyme
	    }
	    foreach GOChild [GODB Type $Type GO $GO LesContributions] {
		if {[info exists TabDesGOParticuliers($GOChild,Absent)]} {continue}
		if {[info exists TabTmp($GOChild)]} {continue}
		set TabTmp($GOChild) 1
		lappend LesGOChild [list $GOChild "PartOf"     $Type]
	    }
	    foreach GOChild [GODB Type $Type GO $GO LesEnfants      ] {
		if {[info exists TabDesGOParticuliers($GOChild,Absent)]} {continue}
		if {[info exists TabTmp($GOChild)]} {continue}
		set TabTmp($GOChild) 1
		lappend LesGOChild [list $GOChild "SubclassOf" $Type]
	    }
	}
    }
    if {![info exists TabTmp]} {unset TabTmp}
    
    lappend LeTexte         "Type       : [join $LesTypes " "]"
    lappend LeTexte         "Name       : [join $LesGO    " "]"
    lappend LeTexte         "Definition :"
    foreach Definition $LesDefinitions {lappend LeTexte "$Definition"}
    
    if {[GOUsersDB ask LesGO] != ""} {
	set LesAccess       {}
	set LesRequetes     {}
	set LesBoites       {}
	foreach GO $LesGO {
	    foreach Access  [lsort -unique [GOUsersDB ask GO $GO LesAccess      ]] {lappend LesAccess   $Access } 
	    foreach Requete [lsort -unique [GOUsersDB ask GO $GO LesRequetes    ]] {lappend LesRequetes $Requete}
	    foreach LaBoite [lsort -unique [GOUsersDB ask GO $GO LesBoitesGscope]] {lappend LesBoites   $LaBoite}
	}
	lappend     LeTexte "UsersSelection"
	if {$LesAccess   != ""} {
	    lappend LeTexte "Access     : [join $LesAccess   " "]"
	}
	if {$LesRequetes != ""} {
	    lappend LeTexte "Links      : [join $LesRequetes " "]"
	}
	if {$LesBoites   != ""} {
	    lappend LeTexte "GscopeBox  :"
	    foreach LaBoite $LesBoites {
		set Nom  [lindex $LaBoite 0]
		set File [lindex $LaBoite 1]
		lappend LeTexte "   $Nom $File"
	    }
	}
    }
    set LeTexteDefinitif {}
    foreach Ligne $LeTexte {
	while {100 < [string length $Ligne]} {
	    lappend LeTexteDefinitif [string range $Ligne 0  59 ]
	    set     Ligne            [string range $Ligne 60 end]
	}
	if {[string length $Ligne] != 0} {lappend LeTexteDefinitif $Ligne}
    }
    set ListeDesTags [list "Affichable" [join $LeTexteDefinitif "\n"] "GO" $LesGO]
    ##########################################################
    set Definition [lindex $LesDefinitions 0]

    set DiffX      [expr ($XMax          -  $XMin )]
    set X          [expr $DiffX * 1.0 /2 +  $XMin  ]

    set Rayon1     [FDeX Calc               $Niveau]
    set Rayon2     [expr $DiffX / 6                ] 
    if {$Rayon2 < $Rayon1} {set Rayon $Rayon2} else {set Rayon $Rayon1}

    set XMinCercle [expr $X              -  $Rayon ]
    set YMinCercle [expr $Y              -  $Rayon ]
    set XMaxCercle [expr $X              +  $Rayon ]
    set YMaxCercle [expr $Y              +  $Rayon ]
 
    set  Color      "Green"
    if {[string equal -nocase $PartOfouSubclassOf "PartOf"    ]} {set Color "blue"}
    if {[string equal -nocase $PartOfouSubclassOf "SubclassOf"]} {set Color "red" }
    foreach GO $LesGO {if {[info exists TabDesGOParticuliers($GO,Ref)]} {set Color "Orange";break}}

    if {300 < [expr $XMax - $XMin]} {
	set Definition [string range $Definition 0 50]
	set Police     "arial 12"
    } elseif {200 < [expr $XMax - $XMin]} {
	set Definition [string range $Definition 0 30]
	set Police     "arial 10"
    } elseif {100 < [expr $XMax - $XMin]} {
	set Definition [string range $Definition 0 20]
	set Police     "arial 9"
    } elseif {70 < [expr $XMax - $XMin]} {
	set Definition [string range $Definition 0 10]
	set Police     "arial 8"
    } elseif {40 < [expr $XMax - $XMin]} {
	set Definition [string range $Definition 0 10]
	set Police     "arial 7"
    } else {
	set  Definition ""
    }
	
    $K create oval $XMinCercle $YMinCercle $XMaxCercle $YMaxCercle -fill $Color -tags $ListeDesTags
    if {$XPere != ""} {
	$K lower [$K create line $XPere [expr $Y-$TailleDUnNiveau] $X $Y -fill $Color -tags $ListeDesTags]
    }
    if {$Definition != ""} {
	$K raise [$K create text $X [expr $Y - $Rayon] -anchor s -text $Definition -fill $Color -font $Police -tags $ListeDesTags]
    }
 
    ###################################################################
    if {$LesGOChild == {}} {return}

    set YChild          [expr $Y  +  $TailleDUnNiveau]
    set nBulles         [llength          $LesGOChild]
    set EcartDeX        [expr $DiffX * 1.0 / $nBulles]
    incr Niveau
    for {set i 0} {$i < $nBulles} {incr i} {
	set LeGOChild          [lindex $LesGOChild $i]
	set GOChild            [lindex $LeGOChild 0]
	set PartOfouSubclassOf [lindex $LeGOChild 1]
	set Type               [lindex $LeGOChild 2]
	set XMinChild          [expr $XMin      + $EcartDeX * $i]
	set XMaxChild          [expr $XMinChild + $EcartDeX     ]

	DrawOneBall $K $GOChild $Niveau $XMinChild $XMaxChild $YChild $TailleDUnNiveau TabDesGOParticuliers $X $PartOfouSubclassOf
    }
    return

}

proc DrawOpenCloseArrow {w x y Etat} {

    set xm [expr {$x-10}]
    set ym [expr {$y-10}]
    set xx [expr {$x+10}]
    set yx [expr {$y+10}]

    if {$Etat} {
	# open ; arrow head bottom
	set Lc [list $xm $ym $xx $ym $x $yx]
	set col green1
    } else {
	# clsoe ; arrow head horizontal
	set Lc [list $xm $ym $xx $y $xm $yx]
	set col orange
    }
    
    set Id [$w create polygon $Lc  -fill $col  -outline black  -width 2  -tags {Arrow}
	   ]
    
    return $Id

}

proc DrawRibbonNucleic {Lpts Lcol} {

    
    puts "Lpts [llength $Lpts] [llength $Lcol]"
    #return
    set QObj [gluNewQuadric]
    gluQuadricDrawStyle $QObj GLU_FILL
    gluQuadricNormals   $QObj GLU_SMOOTH
    gluQuadricTexture   $QObj GL_TRUE

    set p0 [lindex $Lpts 0]
    set c0 [lindex $Lpts 0]
    set Rad 1.0
    foreach pt [lrange $Lpts 1 end] cl [lrange $Lcol 1 end] {
	TraceCylindre "" $QObj $p0 $pt $c0 $cl $Rad $Rad
	glPushMatrix
	glTranslatef {*}$p0
	glColor4fv $cl
	gluSphere $QObj 1.0 32 32
	glPopMatrix
	set p0 $pt
	set c0 $cl
    }
    glPushMatrix
    glTranslatef {*}$pt
    glColor4fv $cl
    gluSphere $QObj 1.0 32 32
    glPopMatrix

    gluDeleteQuadric $QObj

    return

}

proc DrawRibbonProtein {LesVecs} {


    #use_light
    set wr 0
    set zcol {0.2 0.2 1.0 1.0}

    foreach {n1 c1 v1 n2 c2 v2 n3 c3 v3} $LesVecs {
	glBegin GL_TRIANGLES
	glColor4f {*}$c1 1.0
	glNormal3fv $n1
	glVertex3fv $v1
	glNormal3fv $n2
	glVertex3fv $v2
	glNormal3fv $n3
	glVertex3fv $v3
	glEnd
    }

    return

}

proc DrawScore {{Lmeth ""}} {

    global TbScores

    set K [UnCanva 600 600]
    $K configure -background black
    
    if {$Lmeth eq ""} {
	set Lmeth [set TbScores(Lcols)]
    }

    set ZeMin  9999999999999.
    set ZeMax -9999999999999.
    foreach m $Lmeth {
	set Lval [list]
	foreach v $TbScores(Score,$m) {
	    if {$v != -999.0} {
		lappend Lval $v
	    }
	}
	#set Lval [Standardise $Lval]

	set Lt [lsort -unique -increasing -real $Lval]
	set min [lindex $Lt 0]
	set max [lindex $Lt end]
	if {$min < $ZeMin} {set ZeMin $min}
	if {$max > $ZeMax} {set ZeMax $max}
	
	set Nrm($m) $Lval
	puts [format "%s %6.4f %6.4f" $m $min $max]
    }

    set N 200
    set step [expr {double(($ZeMax - $ZeMin))/$N}]

    set maxY -999999.
    set maxM ""
    foreach m $Lmeth {
	#set aT [CreeHistogramme $Nrm($m) 100 "" $K "" $m $ZeMin $ZeMax $step]
	set aT [CreeHistogramme $Nrm($m) 100 "" $K "" $m]
	set Ls [lsort -integer -index 1 -stride 2 $aT]
	puts "$m [lrange $aT 0 7]"
	if {[lindex $Ls end] > $maxY} {
	    set maxY [lindex $Ls end]
	    set maxM $m
	}
	set THis($m) [lsort -index 0 -stride 2 -real $aT]
    }
    set i [lsearch $Lmeth $maxM]
    set tmp [lindex $Lmeth 0]
    lset Lmeth $i $tmp
    lset Lmeth 0 $maxM

    set Lcolor [list orange cyan green1 white magenta yellow ]
    set icol 0
    foreach m $Lmeth {
	set color [lindex $Lcolor $icol]
	set TbScores(Color,$m) $color
	set LesX [list] ; set LesY [list]
	foreach {x y} $THis($m) {
	    lappend LesX $x
	    lappend LesY $y
	}
	set Ltag [lrepeat [llength $LesX] $m]
	Graphe $LesX $LesY $K $color 600 600 "" "" "" $Ltag
	incr icol
    }	    
    
    return $K

}

proc DrawTaxo {{toSee ""}} {

    set w $::Tx(PAD)
    $w delete all

    array set ::HExstModel [HashExiste $::LModelId]
    array set ::HExstUser  [HashExiste $::LUserId]
    array set ::HExstSel   [HashExiste $::LTaxSelected]

    DrawTaxoNode $::TaxRoot 20 20
    
    $w raise Arrow
    $w lower Rleaf
    $w lower RectInt
    $w lower Line

    lassign [$w bbox all] x1 y1 x2 y2
    set dx [expr {$x2-$x1+50}]
    set dy [expr {$y2-$y1+50}]
    if {$dx < $::Tx(PADWdt)} {set dx $::Tx(PADWdt)}
    if {$dy < $::Tx(PADHgt)} {set dy $::Tx(PADHgt)}
    $w configure -scrollregion [list 0 0 $dx $dy]
    
    if {$toSee ne ""} {
	CanvasSee $w $toSee
    }

    return

}

proc DrawTaxoHTML {} {

    global Lhtml HExstModel HExstUser HExstSel db

    set Lhtml [list]
    lappend Lhtml [SoTOLHtmlSetup head]

    array set HExstModel [HashExiste $::LModelId]
    array set HExstUser  [HashExiste $::LUserId]
    array set HExstSel   [HashExiste $::LTaxSelected]

    DrawTaxoNodeHTML $::TaxRoot 0
    lappend Lhtml "
"
    puts "fin recursif DrawTaxoNodeHTML"
    
    lappend Lhtml [SoTOLHtmlSetup tail]

    #lappend Lhtml [join $::LTaxSelected \n]
    if {0} {
	file delete sotol_web.html tax_in.txt
	set fo [open "sotol_web.html" w]
	puts $fo [join $::LTaxSelected \n]
	$db eval {begin transaction}
	foreach id $::LSelectableId {
	    set nc [$db eval {select count(taxid) from taxonomy where Parent=$id}]
	    if {$nc} {
		puts $fo "[format %7d $id] $nc | $::Tx(Name,$id)"
	    }
	}
	$db eval {commit}
	puts $fo [join $Lhtml \n]
	close $fo
    }	

    puts "Lhtml [llength $Lhtml]"
    return "[join $Lhtml \n]"

}

proc DrawTaxoNode {n xCsg yCsg} {
 
    global Tx

    if {! $Tx(hasSel,$n)} {
	return [list $xCsg $yCsg]
    }

    if {$Tx(Etat,$n)} {
	set Lchild [set Tx(ChildD,$n)]
    } else {
	set Lchild [list]
    }

    set OffsetX $Tx(OffsetX)
    set OffsetY $Tx(OffsetY)

    set xDeb $xCsg
    set yDeb $yCsg
    set xFin $xCsg

    if {$Tx(isInt,$n) && ! $Tx(ShowInt,$n)} {
	set yFin $yCsg
    } else {
	set yFin [expr {$yCsg + $OffsetY}]
	set nom [set Tx(Name,$n)]
	WriteTaxName $n $nom $xFin $yFin
    }

    set LAnchors [list]
    foreach f $Lchild {
	if {$Tx(isInt,$f) && ! $Tx(ShowInt,$f)} {
	    set xDrw $xDeb
	} else {
	    set xDrw [expr {$xDeb + $OffsetX}]
	}
	lappend LAnchors [list $xDrw $yFin]
	set yFin [lindex [DrawTaxoNode $f $xDrw $yFin] 1]
    }

    # line linking brothers
    if {[llength [lunique $LAnchors]] > 1} {
	lassign [lindex $LAnchors 0]   x0 y0
	lassign [lindex $LAnchors end] x1 y1
	incr y0 [expr {$OffsetY}]
	incr y1 [expr {$OffsetY}]
	$Tx(PAD) create line [list $x0 $y0 $x1 $y1]  -fill $Tx(fgCan)  -width 1  -tags {Line}
    }

    return [list $xFin $yFin]

}

proc DrawTaxoNodeHTML {n doBaton} {

    lappend ::Lhtml [WriteTaxNameHTML $n $doBaton]

    set Lchild $::Tx(ChildD,$n)
    set nChild [expr {[llength $Lchild]-1}]
    set ic 0
    foreach f $Lchild {
	if {$ic < $nChild} {
	    set doBaton 1
	} else {
	    set doBaton 0
	}

	DrawTaxoNodeHTML $f $doBaton
	lappend ::Lhtml "
"

	incr ic
    }

    return

}

proc DrawTreeAllGO {KTree {LesGO ""} {OpenOuClose Close} {CheminIni ""}} {

    global TabAiJeVuCetteBranche

    set TousLesGO [GODB LesGO]
    if {$LesGO == ""} {
	set LesGO $TousLesGO
	set LesTypes [GODB LesTypes]
    } else {
	foreach GO [TousLesAncetresGODesGO $LesGO] {lappend LesGO $GO}
	set LesTypes [LesTypesDesGO $LesGO]
	foreach GOAbsent [LaDifferenceDeL1AvecL2 $TousLesGO moins $LesGO] {set TabDesExceptions($GOAbsent) 0}
    }
    
    foreach Type [GODB LesTypes] {
	set Chemin "$CheminIni/$Type"
	if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
    }

    ImageDirectory   idir
    ImageFile        ifile

    set NiveauPremierGO 0
    foreach Type $LesTypes {
	set Chemin "$CheminIni/$Type"

	set TabAiJeVuCetteBranche($KTree,$Chemin) 1

	Tree:newitem    $KTree $Chemin -image idir
	TreeOpenOuClose $KTree $Chemin $OpenOuClose

	foreach GO [GODB Type $Type Niveau $NiveauPremierGO LesGO] {
	    if {[info exists TabDesExceptions($GO)]} {continue}
	    PlaceNoeudDansTreeAllGO $KTree $Type $GO $Chemin "" TabDesExceptions $OpenOuClose
	}
    }
    if {[info exists TabTmp]} {unset TabTmp}   
    update

}

proc DrawTreeOneGO {KTree {GO ""}} {

    global TabAiJeVuCetteBranche

    if {$GO == ""} {set GO [lindex [GODB Type [lindex [GODB LesTypes] 0] Niveau 0 LesGO] 0]} 

    set LesTypes [GODB GO $GO LesTypes]

    set LesGO {}
    foreach Type $LesTypes {
	set GO [GODB Type $Type GOSynonyme $GO GODeRef]
	if {[info exists TabTmp($GO)]} {continue}
	set TabTmp($GO) 1
	lappend LesGO $GO

	foreach GOSynonyme [GODB Type $Type GO $GO LesSynonymes] {
	    if {[info exists TabTmp($GOSynonyme)]} {continue}
	    set TabTmp($GOSynonyme) 1
	    lappend LesGO $GOSynonyme
	}
    }
    if {![info exists TabTmp]} {unset TabTmp}

    set LesDefinitions {}
    set LesRequetes    {}
    foreach GO $LesGO {
	lappend LesDescendantsEtAncetres $GO
	foreach Type [GODB GO $GO LesTypes] {
	    foreach Definition [GODB Type $Type GO $GO LesDefinitions] {
		regsub -all " |\/" $Definition "_" Definition
		if {[info exists TabTmp($Definition)]} {continue}
		set TabTmp($Definition) 1
		lappend LesDefinitions $Definition
	    }
	}
	foreach Requete [2GO $GO LesLiens] {
	    if {[info exists TabTmp($Requete)]} {continue}
	    set WhatIsIt [2GO $Requete WhatIsIt]

	    lappend LesRequetes [list $WhatIsIt $Requete]

	    set TabTmp($Requete) 1
	}
    }

    if {![info exists TabTmp]} {unset TabTmp}
    set LesRequetes [lsort -index 0 $LesRequetes]

    set LesParents     [concat [TousLesAncetresGODesGO    $LesGO] $LesGO]
    ###############################################################################
    
    ImageDirectory   idir
    ImageFile        ifile

    set Chemin "/GO"
    if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
    set TabAiJeVuCetteBranche($KTree,$Chemin) 1
    foreach GO $LesGO {
	Tree:createallchildren $KTree [list [list "GO" "Open" idir] [list $GO "Open" ifile]]
    }
  
    set Chemin "/GO_Definitions"
    if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
    set TabAiJeVuCetteBranche($KTree,$Chemin) 1
    foreach Definition $LesDefinitions {
	Tree:createallchildren $KTree [list [list "GO_Definitions" "Open" idir] [list $Definition "Open" ifile]]
    }
    
    set Chemin "/GO_Links"
    if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
    set TabAiJeVuCetteBranche($KTree,$Chemin) 1
    foreach LaRequete $LesRequetes {
	set Banque  [lindex $LaRequete 0]
	set Requete [lindex $LaRequete 1]
	Tree:createallchildren $KTree [list [list "GO_Links" "Open" idir] [list $Banque "Close" idir] [list $Requete "Open" ifile]]
    }

    set Chemin "/GO_ParentTerms"
    if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
    if {$LesParents != ""} {
	set TabAiJeVuCetteBranche($KTree,$Chemin) 1
	Tree:newitem    $KTree $Chemin -image idir
	TreeOpenOuClose $KTree $Chemin   Open
	DrawTreeAllGO $KTree $LesParents Open $Chemin
    }

    if {[GOUsersDB ask LesGO] != ""} {
	set Chemin "/GO_UsersSelection"
	if {[info exists TabAiJeVuCetteBranche($KTree,$Chemin)]} {Tree:delitem  $KTree $Chemin}
	set TabAiJeVuCetteBranche($KTree,$Chemin) 1
	foreach GO $LesGO {
	    set LesAccess       [lsort -unique [GOUsersDB ask GO $GO LesAccess      ]]
	    set LesRequetes     [lsort -unique [GOUsersDB ask GO $GO LesRequetes    ]]
	    set LesBoitesGscope [lsort -unique [GOUsersDB ask GO $GO LesBoitesGscope]]
	    if {$LesAccess != ""} {
		foreach Access $LesAccess {
		    Tree:createallchildren $KTree [list [list "GO_UsersSelection" "Open" idir] [list "Access" "Open" idir] [list $Access "Close" ifile]]
		    foreach Requete [GOUsersDB ask Access $Access LesRequetes] {
			regsub -all  " |\/" $Requete "_" Requete

			Tree:createallchildren $KTree [list [list "GO_UsersSelection" "Open" idir] [list "Access" "Open" idir] [list $Access "Close" ifile] [list $Requete "Close" ifile]]
		    }
		}
	    }
	    if {$LesRequetes != ""} {
		foreach Requete $LesRequetes {
		    regsub -all  " |\/" $Requete "_" Requete
		    Tree:createallchildren $KTree [list [list "GO_UsersSelection" "Open" idir] [list "DomainsKeywords" "Open" idir] [list $Requete "Open" ifile]]
		}
	    }
	    if {$LesBoitesGscope != ""} {
		set CheminBox "$Chemin/GscopeBox"
		foreach LaBoite $LesBoitesGscope {
		    set Nom       [lindex $LaBoite 0]
		    set FichierGO [lindex $LaBoite 1]
		    regsub -all "\/" $FichierGO "|" TexteFichierGO

		    Tree:createallchildren $KTree [list [list "GO_UsersSelection" "Open" idir] [list "GscopeBox" "Open" idir] [list $TexteFichierGO "Open" idir] [list $Nom "Close" ifile]]
		    foreach Access [GOUsersDB ask Gscope $FichierGO Nom $Nom LesAccess] {
			Tree:createallchildren $KTree [list [list "GO_UsersSelection" "Open" idir] [list "GscopeBox" "Open" idir] [list $TexteFichierGO "Open" idir] [list $Nom "Close" ifile] [list $Access "Close" ifile]]
		    }
		}

	    }
	}
    }
    if {[info exists TabTmp]} {unset TabTmp}
    update

}

proc DrawTrigNorm {t n1 n2 n3 c} {

    lassign $t v1 v2 v3
    glColor4fv $c
    glBegin GL_LINES
    glVertex3fv $v1
    glVertex3fv $v2
    glVertex3fv $v3
    glVertex3fv $v1
    glEnd
    glColor4f 1.0 0.2 0.2 1.0
    glBegin GL_LINES
    glVertex3fv $v1
    set nv [V_VV $v1 + $n1]
    glVertex3fv $nv
    glEnd
    glBegin GL_LINES
    glVertex3fv $v2
    set nv [V_VV $v2 + $n2]
    glVertex3fv $nv
    glEnd
    glBegin GL_LINES
    glVertex3fv $v3
    set nv [V_VV $v3 + $n3]
    glVertex3fv $nv
    glEnd


    return

}

proc DrawVrp {} {

    global Vrp

    set w .fvrp.f

    set Vrp(Scale) 1.0
    set c $Vrp(WCanvas)

    if {! [set Vrp(Overwrite)]} {
	$c delete all
	set Vrp(VId) 0
    } else {
	lassign [$c coords l0_0] xv yv t h
	$c move all [expr {-1.*$xv}] [expr {-1.*$yv}]
	incr Vrp(VId)
    }

    set xprev 0.0
    set yprev 0.0
    set first 1
    for {set i 0} {$i < $Vrp(Sz)} {incr i} {
	set x [lindex $Vrp(X) $i]
	set y [lindex $Vrp(Y) $i]
	if {$first} {
	    set col red
	    set d [expr {2*$Vrp(DotSz)}]
	    set first 0
	} else {
	    set d $Vrp(DotSz)
	    set col $Vrp(colDot)
	}
	$c create line $xprev $yprev $x $y  -tags [list ligne "l${Vrp(VId)}_$i"]
	set item [$c create oval  [expr {$xprev-$d}]  [expr {$yprev-$d}]  [expr {$xprev+$d}]  [expr {$yprev+$d}]  -width 1 -outline black  -fill $col  -tags [list "p${Vrp(VId)}_$i" dot]]
	set xprev $x
	set yprev $y
    }
    $c raise dot

    if {! [set Vrp(Overwrite)]} {
	set cx [expr {($Vrp(MinX) + $Vrp(MaxX))/2.0}]
	set cy [expr {($Vrp(MinY) + $Vrp(MaxY))/2.0}]
    } else {
	lassign [$c bbox all] Vrp(MinX) Vrp(MinY) Vrp(MaxX) Vrp(MaxY)
	set Vrp(Cmx) [expr {($Vrp(MinX) + $Vrp(MaxX))/2.0}]
	set Vrp(Cmy) [expr {($Vrp(MinY) + $Vrp(MaxY))/2.0}]
    }
    set Vrp(CX) $Vrp(CmX)
    set Vrp(CY) $Vrp(CmY)

    set item [$c create line $Vrp(MinX) $Vrp(MinY) $Vrp(MaxX) $Vrp(MaxY)  -fill [$c cget -background] ]

    $c addtag scrollregion withtag $item
    ShowCenter $c $Vrp(CX) $Vrp(CY)

    set szx2 [expr {$Vrp(Width)/2.0}]
    set szy2 [expr {$Vrp(Height)/2.0}]

    $c move all [expr {$szx2 - $Vrp(CmX)}] [expr {$szy2 - $Vrp(CmY)}]

    set Vrp(CX) $szx2
    set Vrp(CY) $szy2

    ConfigureVrp $c

    # show the sequence
    set t $Vrp(WText)
    $t configure -state normal
    $t delete 0.0 end
    $t insert 1.0 $Vrp(seqAA1)
    $t configure -state disabled -insertwidth 0

    return

}

proc DuFinal {Chr D {F ""}} {

    if {$F==""} { set F [expr $D+5000] }
    set Final [ContenuDuFichier "[AnnotRep]/${Chr}_Final"]
    set Xdn3  [ContenuDuFichier "[AnnotRep]/${Chr}_Xdn3"]
    Espionne [string range $Xdn3 $D $F]
    set XdnX  [ContenuDuFichier "[AnnotRep]/${Chr}_XdnX"]
    Espionne [string range $XdnX $D $F]
    return [string range $Final $D $F]

}

proc DuGrec {Fichier} {

    foreach C [split [ContenuDuFichier $Fichier] ""] {
	if {$C > "z" || $C == "?"} {
	    Espionne "Grec >$C< [string range $Nouveau end-10 end]"
	    if { ! [info exists Remplace($C)]} {
		set Remplace($C) [Entre]
	    }
	    set C [set Remplace($C)]
	}
	lappend Nouveau $C
    }
    Espionne [Sauve [join $Nouveau ""] dans $Fichier.nouveau]
    exit

}

proc DuPlotteCourant {K X Y Qui} {

    set LesIds [$K find withtag current]
    foreach Id $LesIds {
	set Moi [lindex [$K gettags $Id] 0]
	set Toi [lindex [$K gettags $Id] 1]
	if {[regexp -nocase {[a-z]} $Toi]} { continue }
	if {$Qui == "PAB"} {
	    return $Moi
	} else {
	    return $Toi
	}
    }

}

proc DuRSF {TexteOuFichierRSF Quoi} {

    set N [DecortiqueUnRSF $TexteOuFichierRSF LesNomsDesSequencesDansLOrdre Sequences TabRSF "" "AvecBornesLocales"]
    set TabRSF(N) $N
    if {[info exists TabRSF($Quoi)]} { return $TabRSF($Quoi) }
    return "NExistePas"

}

proc DumpBiotext {} {

    set Ls [$::NomTextSeq output all]
    set Ns [list]
    foreach s $Ls {
	lappend Ns [split $s ""]
    }
    set ::LSSeqlab $Ns

    return

}

proc DumpCbl {} {

    array set Cbl [InitPAM35]
    parray Cbl

    set laa [split $Cbl(laa) ""]
    set i 0
    set spc "     "
    foreach a1 $laa {
	set s "$a1 [string repeat $spc $i]"
	foreach a2 [lrange $laa $i end] {
	    append s [format %5.1f $Cbl($a2,$a1)]
	}
	incr i
	puts $s
    }
    exit

}

proc DumpFunction {w pos} {

    set pos [$w index $pos]
    lassign [split $pos .] y x
    set line [$w get $y.0 "$y.0 lineend"]
    set func [string trim [string range $line 0 [string first " " $line]]]

    set Ldump [::profiler::dump "::$func"]
    puts "\n Function : $func"
    foreach {k v} $Ldump {
	if {[llength $v] == 1} {
	    puts " $k : $v"
	} else {
	    puts " $k :"
	    foreach {k2 v2} $v {
		puts "    $k2 : $v2"
	    }
	}
    }
    puts ""

    return

}

proc DumpIt {AId} {

    global Abr
    set PAD $Abr($AId,PAD)
    foreach id [$PAD find all] {
	if {[$PAD type $id] eq "text"} {
	    puts "[$PAD itemcget $id -text] [$PAD coords $id] | [$PAD itemcget $id -angle]"
	}
    }
    return

}

proc DumpLeCarre {xd yd xf yf} {

    global TabSF PrmPrt

    set Ltags [list]
    if {[QuelMode] ne "feature"} {
	return $Ltags
    }

    set Lf [LesBoutonsEnfonces]
    puts "Lf $Lf"
    puts "yd $yd yf $yf"
    set i $yd
    foreach n [lrange $PrmPrt(LNoms) $yd $yf] {
	foreach ft $Lf {
	    if {! [info exists TabSF($n,$ft)]} {
		continue
	    }
	    foreach f [set TabSF($n,$ft)] {
		DecortiqueUneFeature $f dg fg col sco note
		if {$dg <= $xf && $fg >= $xd} {
		    if {$dg < $xd} {
			set x1 $xd
		    } else {
			set x1 $dg
		    }
		    if {$fg > $xf} {
			set x1 $xf
		    } else {
			set x2 $fg
		    }
		    lappend Ltags [list $i $x1 $x2 $col]
		}
	    }
	}
	incr i
    }
    puts [join $Ltags \n]

    return $Ltags


    set dump ""
    set dptg ""
    set dptx ""
    for {set i $yd} {$i <= $yf} {incr i} {
	
	set d [$NomTextSeq dump -text -tag $i.$xd $i.$xf]
	set TOn 0
	foreach {k v ix} $d {
	    if {! [regexp {\.} $ix]} {
		set ix "$i.$ix"
	    }
	    switch $k {
		"tagon" {
		    if {$v eq "Back"} {continue}
		    if {! [regexp {^FX_} $v] && ! [regexp {^Tag} $v]} {continue}
		    set TOn 1
		}
		"tagoff" {
		    if {$v eq "Back"} {continue}
		    if {! [regexp {^FX_} $v] && ! [regexp {^Tag} $v]} {continue}
		    if {! $TOn} {lappend LDump $k $v "$i.$xd"}
		    set TOn 0
		}
	    }
	    #puts "$k $v $ix"
	    lappend LDump $k $v $ix
	}
	if {$TOn} {lappend LDump $k $v "$i.$xf"}
    }

    return $LDump

}

proc DumpOrdali {{FichierDump ""}} {


    global NomTextSeq
    global NomNomSeq
    global WTextSequence
    global Defauts
    global OrdTmpDir

    if {$FichierDump==""} {
	if {![set Defauts(Dump)]} {
	    set FichierDump "DumpOrdali"
	} else {
	    set FichierDump [set Defauts(Dump)]
	}
    }

    set parent [winfo parent $NomTextSeq]
    set wregle $parent.regle

    # sort la regle puis les noms puis les seqquences

    set DumpRegle [$wregle     dump -tag -text 1.0 end]
    set DumpNoms  [$NomNomSeq  dump -tag -text 1.0 end]
    set DumpTexte [$NomTextSeq dump -tag -text 1.0 end]

    set ltag [$NomTextSeq tag names]
    set ltag [lsort -unique $ltag]
    set fnt [$NomTextSeq cget -font ]
    foreach t $ltag {
	set fre [$NomTextSeq tag cget $t -foreground ]
	set bck [$NomTextSeq tag cget $t -background ]
	lappend lct "$t $fre $bck"
    }

    EnvoieDump "OpenFile" $FichierDump
    EnvoieDump font $fnt
    EnvoieDump tags $lct
    EnvoieDump regle $DumpRegle
    EnvoieDump noms  $DumpNoms
    EnvoieDump texte $DumpTexte
    EnvoieDump "CloseFile"

    return

}

proc DumpSVG {can} {

    puts "entre sumpSVG"
    source [file join $::OrdLibDir uriencode.tcl]
    source [file join $::OrdLibDir tinyfileutils.tcl]
    source [file join $::OrdLibDir can2svg.tcl]

    puts "Fait le dump"
    can2svg::canvas2file $csn can.svg
    puts "Fin SVG"
    return

}

proc DumpSqliteDB {{fdb ""}} {

    global db

    catch {puts "\n########################\n[info level -1]\n"}

    if {$fdb ne ""} {
	if {! [file exists $fdb]} {
	    puts "$fdb does not exists"
	    return
	}
	set db root
	package require sqlite3
	sqlite3 $db $fdb
    }
    $db eval {begin transaction}
    set Lt [$db eval {select tbl_name from sqlite_master}]
    foreach table $Lt {
	set result {}
	$db eval "PRAGMA TABLE_INFO($table)" row { lappend result $row(name) $row(type) $row(pk) }
	puts "$table"
	foreach {n t pk} $result {
	    set v [$db eval "select count($n) from $table "]
	    if {$pk} {
		set pk "PK"
	    } else {
		set pk "  "
	    }
	    puts "\t$n $pk $t $v"
	}
    }
    $db eval {commit}
    puts "\n########################\n"
    
    return

}

proc DumpSqliteDB_VOIRdansORDALI {{fdb ""}} {

    global db

    catch {puts "\n########################\n[info level -1]\n"}

    if {$fdb ne ""} {
	set db root
	sqlite3 $db $fdb
    }
    $db eval {begin transaction}
    set Lt [$db eval {select tbl_name from sqlite_master}]
    foreach table $Lt {
	set result {}
	$db eval "PRAGMA TABLE_INFO($table)" row { lappend result $row(name) }
	puts "$table"
	foreach n $result {
	    set v [$db eval "select count($n) from $table "]
	    puts "\t$n $v"
	}
    }
    $db eval {commit}
    puts "\n########################\n"
    
    return

}

proc DumpTree {AId {info none}} {

    global Abr

    set A [set Abr(Arbre,$AId)]
    puts ""
    puts "Dump Tree $A"
    puts "==========[string repeat = [string length $A]]"
    puts ""
    if {0} {
	foreach n [$A nodes] {
	    set Lk [lsort [$A keys $n]]
	    puts "Norud $n :"
	    foreach k $Lk {
		if {$k eq "name" || $k eq "AngAbs"} {continue}
		puts [format "\t%s %s" $k [$A get $n $k]]
	    }
	    puts ""
	}
	puts "\n"
    }

    puts "Arbre :"
    puts "======="
    DumpTreeRecur $AId root 0 $info
    puts "\n"

    return

}

proc DumpTreeRecur {AId n niv {info non}} {

    global Abr

    set t [set Abr(Arbre,$AId)]
    set pre [string repeat "\t" $niv]
    set res "$pre$n"
    if {$info ne "none"} {
	foreach k $info {
	    if {[$t keyexists $n $k]} {
		append res "|[$t get $n $k]"
	    }
	}
    }
    puts "$res"
    if {[$t isleaf $n]} {return}

    incr niv
    foreach e [$t children $n] {
	DumpTreeRecur $AId $e $niv $info
    }

    return

}

proc Dumple {} {

    
    puts [.t.t dump -tag -text 1.1 1.7]
    puts [.t.t dump -tag -text 3.1 3.7]
    puts [.t.t dump -tag -text 5.1 5.7]
    puts [.t.t dump -tag 7.1 7.6]

    return

}

proc DupliqueLaBaseGscope {{RepDestin ""}} {

    global RepertoireDuGenome

    while {1} {
	if {$RepDestin==""} { set RepDestin "${RepertoireDuGenome}COPY" }
	
	if { ! [regexp "/" $RepDestin]} {
	    set RepDestin "[file dirname $RepertoireDuGenome]/$RepDestin"
	}
	if { ! [OuiOuNon "Ok to duplicate \n $RepertoireDuGenome\n to  $RepDestin\n  ?"]} {
	    set RepDestin [Entre $RepDestin]
	}
	if {$RepDestin!=""} { break } 
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    while {! [file exists $RepDestin]} {
	if {[OuiOuNon "Please create the directory of the new gscope database \n $RepDestin OK ?"]} { continue }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    foreach Rep {"beton" "nuctfa" "nucembl" "prottfa" "protembl" "infos" "trnadir" "codonw"} {
	set Source "$RepertoireDuGenome/$Rep"
	set Destin "$RepDestin/$Rep"
	if { ! [file exists $Source]} { continue }
	Espionne "$Source to $Destin"
	if { ! [info exists $Destin]} { File mkdir $Destin }
	foreach Fichier [glob -nocomplain "$Source/*"] {
	    set Nom [file tail $Fichier]
	    File copy $Fichier "$Destin/$Nom"
	}
    }
    set Source "$RepertoireDuGenome/fiches"
    set Destin "$RepDestin/fiches"
    if { ! [file exists $Destin]} { File mkdir $Destin }
    if {[file exists $Source]} {
	foreach F {  bornesdesarns  bornesdesglimmers  bornesdespabs  bornesdestrnas  codonstartpossible  codonstoppossible  coglimmer  compositionenatgc  createurdespabs  lesorganismestresproches  narcisse  sd_bons  sd_loin  sd_mets  sd_sans  similarite  spectregc  spectregcxy  startcodon_summary } {
	    if { ! [file exists $Source/$F]} { continue }
	    Espionne "$Source/$F to $Destin/$F"
	    File copy "$Source/$F" "$Destin/$F"
	}
    }
    return 

}

proc EBIWebService {baseUrl query} {

    set urlrun "$baseUrl/run/"
    set ok [HttpCopy $urlrun jobid $query]
    if {! $ok} {
	puts "Error sending EBI run request !"
	return ""
    }
    
    # get job status
    set urlstatus "$baseUrl/status/$jobid"
    set status "RUNNING"
    while {$status eq "RUNNING"} {
	set ok [HttpCopy $urlstatus status]
	if {! $ok} {
	    puts "Error getting EBI job status !"
	    return ""
	} elseif {$status eq "RUNNING"} {
	    after 5000
	}
    }
    if {$status ne "FINISHED"} {
	puts "Error ! EBI job status $status !"
	return ""
    }
    
    # get results
    set urlresult "$baseUrl/result/$jobid/out"
    set ok [HttpCopy $urlresult result]
    if {! $ok} {
	puts "Error getting EBI job restults !"
	return ""
    }

    return "[join $result " "]"

}

proc ECDominant {LesECs Seuil} {

    set X ""
    set M ""
    set LesXs ""
    set LesMs ""
    for {set i 4} {$i>0} {incr i -1} {
	set Meilleur [MeilleurEC $LesECs $X $M $Seuil]
	if {$Meilleur!=""} { break }
	lappend LesXs "(\[0-9\]|-)+"
	lappend LesMs "-"
	set X "[join $LesXs "."]\$"
	set M "[join $LesMs "."]"
    }
    return $Meilleur

}

proc ECduPapa {EC} {

    regsub -all {[^0-9\.\-]} $EC "" EC
    append EC ".-"
    regsub {(^|\.)[0-9]+\.\-} $EC ".-" EC
    return $EC

}

proc ECtoGO {EC} {

    set FichierECtoGO "/home/perrodou/ec2go"
    set JaiEC 0
    foreach Ligne [LesLignesDuFichier $FichierECtoGO] {
	scan $Ligne "%s" ECLu
	regsub "EC:" $ECLu "" ECcourt
	if {$ECcourt == $EC} {
	    set Suite [StringSuivant "$ECLu > " dans $Ligne]
	    set Reste [split $Suite ";"]
	    ScanLaListe $Reste DefinitionGO GO
	    set DefinitionGO [string trim $DefinitionGO]
	    set GO [string trim $GO]
	    lappend LaListe "$GO $DefinitionGO"
	    set JaiEC 1
	}
    }
    if {! $JaiEC} {return -1}
    set LaListe [join $LaListe]
    return $LaListe

}

proc EFFamily {} {

    set Source "/home/legrand/Documents/EF_family/EF_family_id.txt"
    set RepDestin "/genomics/link/EFFamily/DeBaptiste"
    file mkdir "$RepDestin/pdb"
    file mkdir "$RepDestin/embl"
    file mkdir "$RepDestin/tfa"

    set i 0
    foreach Ligne [LesLignesDuFichier "/home/legrand/Documents/EF_family/EF_family_id.txt"] {
	incr i; set Nom [format "EF%3.3d" $i]

	if {[regexp {([0-9]+)} [string range $Ligne 4 end] Match Domain ]} {
	    InformeSansDemander $Nom "HasDomain: $Domain"
	}

	scan $Ligne "%s" ACCESSPDB
	if {$ACCESSPDB=="1QLAA2"} { set ACCESSPDB "2BS2_A" }
	
	set AccessPDB [string tolower $ACCESSPDB]
	if {[regexp -nocase {^([0-9][A-Z0-9]{3})([A-Z]?)} $AccessPDB Match Acc Chain]} {
	    set AccessPDB ${Acc}
	    if {$Chain!=""} { append AccessPDB "_$Chain" }
	}
	set Pdb [TextePDB $AccessPDB]
	if {$Pdb==""} {
	    Espionne "$ACCESSPDB $AccessPDB ???????????????????????????????"
	    continue
	}
	Espionne "$ACCESSPDB $AccessPDB OK"
	set Embl [EMBLduPDB $AccessPDB]
	set Tfa [SequenceFormatTFA $Embl "" "embl"]
	#Affiche "$Embl\n\n$Tfa" "AvecRetour"
	set FichierPdb  [Sauve $Pdb  dans "$RepDestin/pdb/$AccessPDB"]
	set FichierEmbl [Sauve $Embl dans "$RepDestin/embl/EF_$AccessPDB.embl"]
	set FichierTfa  [Sauve $Tfa  dans "$RepDestin/tfa/EF_$AccessPDB.tfa"]
	lappend LaListe "$AccessPDB $FichierTfa"
    }
    return [SauveLesLignes $LaListe dans "$RepDestin/liste.txt"] 

}

proc EMBLdeGscope {Access {ACFirst ""}} {


    if {$ACFirst=="ACFirst"} { set ACFirst 1 } else { set ACFirst 0 }

    if {[regexp {[\:_]} $Access Car]} {
	set Nom [StringApres $Car dans $Access]
    } else {
	set Nom $Access
    }
    set G [GenomeDu $Nom]
    if {$G==""} {return ""}
    set FicEmbl "$G/protembl/$Nom"
    if { ! [file exists $FicEmbl]} { return "" }

    if { ! $ACFirst} { return [ContenuDuFichier $FicEmbl] }

    set LigneAC ""
    set LesLignesEmblSansAC {}
    foreach Ligne [LesLignesDuFichier $FicEmbl] {
	if {[regexp "^AC   " $Ligne]} {
	    set LigneAC $Ligne
	    continue
	}
	lappend LesLignesEmblSansAC $Ligne
    }
    if {$LigneAC==""} {
	FaireLire "I can't find a line 'AC   something' in $FicEmbl"
    }
    return "$LigneAC\n[join $LesLignesEmblSansAC "\n"]"

}

proc EMBLduPDB {aPDB {ACFirst ""}} {


    Wup "Calls TFADuPDB which calls fastacmd"
    Wup "if no answer searches in /catalog/blast/pdb"

    if {$ACFirst=="ACFirst"} { set ACFirst 1 } else { set ACFirst 0 }

    set OS [OrganismeDuPDB $aPDB]
    set OC [OCduOS $OS]
    set GN [MoleculeDuPDB $aPDB]

    if {$ACFirst} {
	lappend LeEMBL "AC   $aPDB"
	lappend LeEMBL "ID   $aPDB created by Gscope with pdb entry $aPDB"
    } else {
	lappend LeEMBL "ID   $aPDB created by Gscope with pdb entry $aPDB"
	lappend LeEMBL "AC   $aPDB"
    }
    lappend LeEMBL "OS   $OS"
    lappend LeEMBL "OC   $OC"

    set TFA [string trim [TFADuPDB $aPDB] " \n"]
    regsub {[^ ]* } [lindex [split $TFA "\n"] 0] "" DE
    if {$TFA==""} {
#	return ""
	set TFA [TfaDeLaBanqueBlast "/catalog/blast/pdb" $aPDB]
    }
    if {$TFA==""} { return "" }

    if {$DE==""} {
	set DE [TextePDB $aPDB "KEYWDS"]
    }
    if {[regexp {\.{2,} *$} $DE]} { regsub {\.{2,} *$} $DE "" DE } 
    if {$DE!=""} { lappend LeEMBL "DE   $DE" }
    if {$GN!=""} { lappend LeEMBL "GN   $GN" }

    set Seq [join [lrange [split $TFA "\n"] 1 end] "\n"]
    regsub -all -nocase {[^A-Z]} $Seq "" Seq 

    lappend LeEMBL [QueSequenceFormatEMBL $Seq "AvecSQ"]

    return [join $LeEMBL "\n"]


}

proc EMBLtoTFA {TexteEMBL Entete} {

    set LesLignesEMBL [split $TexteEMBL "\n"]
    return [LignesEMBLtoTFA $LesLignesEMBL $Entete]

}

proc EPDDir {args} {

    ### Information de la localisation du directory contenant EPD ###
    set Rep "/home/lardenoi/DB_Promoteurs/EPD/78"
    set FirstArg [lindex $args 0]
    if {$FirstArg == ""         } { return $Rep                }
    if {$FirstArg == "TFAs"     } { return "$Rep/epd78.seq"    }
    if {$FirstArg == "DBBlast"  } { return "$Rep/epd78.seq"    }
    if {$FirstArg == "EPDOrgas" } { return "$Rep/EPD_Orga2Organism2OrganismLong"}
    if {$FirstArg == "EPDIdOrga"} { return "$Rep/EPD_Id2Orga2Organism2OrganismLong"}
    return $Rep

}

proc ESTOuPas {FichierDesPABs FichierSortie} {

    #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts
    set L [CreeListePourFichierAUneColonne $FichierDesPABs]
    Espionne [llength $L]
    foreach Nom $L {
	Espionne $Nom
	set est 0
	set FichierBlastnest "[RepertoireDuGenome]/blastnest/$Nom"
	#set FichierBlastnest "[RepertoireDuGenome]/blastnest-human/$Nom"
	if {![file exists $FichierBlastnest]} {Espionne "$FichierBlastnest doesn't exist"}
	set LesProchesEST [ac_LesProchesDansLeBlastBis $FichierBlastnest 0.90 0 0]
	if {$LesProchesEST!="" && $LesProchesEST==1} {set est 1}
	lappend Liste "$Nom\t$est"
    }
    Espionne [llength $Liste]
    set ListeTriee [lsort -unique $Liste]
    Espionne [llength $ListeTriee]
    SauveLesLignes $ListeTriee dans $FichierSortie

}

proc ESTs {FichierClusters} {

    set Liste [ListeMinimumDesJR $FichierClusters]
    set n 0
    foreach Nom $Liste {
	set LesCops [LesMeilleursCopainsDuBlast $Nom "blastnest"]
	if {$LesCops=={} ||[lindex $LesCops 0]=="File not yet available" ||[lindex $LesCops 0]=="No value" ||[lindex $LesCops 0]=="No hit"} {
	    continue
	} else {incr n}
    }
    return $n

}

proc ESTsOuGenemblPourLesLocsSansProteine {FichierClusters {Banque blastnest}} {

    set Liste [ListeMinimumDesJR $FichierClusters]
    set n 0
    set RepProttfa "[RepertoireDuGenome]/prottfa"
    Espionne $Banque
    foreach Nom $Liste {
	if {[PolyLocalise $Nom]!="NoLocalization"} {
	    set Fichier "$RepProttfa/$Nom"
	    if {![file exists $Fichier]} {
		set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
		if {$LesCops=={} ||[lindex $LesCops 0]=="File not yet available" ||[lindex $LesCops 0]=="No value" ||[lindex $LesCops 0]=="No hit"} {
		    continue
		} else {incr n}
	    }
	}
    }
    return $n

}

proc ESTsPourLesLocs {FichierClusters} {

    set Liste [ListeMinimumDesJR $FichierClusters]
    set n 0
    foreach Nom $Liste {
	if {[PolyLocalise $Nom]!="NoLocalization"} {
	    set LesCops [LesMeilleursCopainsDuBlast $Nom "blastnest"]
	    if {$LesCops=={} ||[lindex $LesCops 0]=="File not yet available" ||[lindex $LesCops 0]=="No value" ||[lindex $LesCops 0]=="No hit"} {
		continue
	    } else {incr n}
	}
    }
    return $n

}

proc EcartType {l} {

    if {! [llength $l]} {return -1}
    set sd 0. ; set s2x 0.
    set n [llength $l]
    foreach e $l {
	set sx [expr {$sx+$e}]
	set s2x [expr {$s2x+$e*$e}]
    }
    set mx [expr {$sx/$n}]
    set ex [expr {sqrt($s2x/$n-$mx*$mx)}]

    return $ex

}

proc EcartTypeDeLaListe {Liste} {

    set Var [VarianceDeLaListe $Liste]
    return [expr sqrt($Var)]

}

proc Echange {aA aB} {

    upvar $aA A
    upvar $aB B
    set W $A
    set A $B
    set B $W
    return

}

proc Echo {Nom} {

    return $Nom

}

proc Ecorttype {l} {

    set m [Moyenne $l]
    set n [llength $l]
    set s2 0.
    foreach e $l {
	set s2 [expr {$s2+$e*$e}]
    }
    return [expr {sqrt($s2/$n -$m*$m)}]

}

proc EcritClustersRRPS {Lfin Lgr} {

    set o [open clusters.dat w]
    foreach i $Lfin {
	set ig [string range [lindex $i 0] 2 end]
	set gr [lindex $Lgr $ig]
	puts $o "cluster $ig"
	foreach le $gr {
	    set str [format %5d [lindex $le 0]]
	    foreach e [lrange $le 1 end] {
		append str [format " %6.1f" [expr {$e*100}]]
	    }
	    puts $o $str
	}
    }
    close $o

    return

}

proc EcritData {rfile} {

    global TDesTaxId
    global TDesDescriptifs
    global TDesOrganismes
    global LNOrdali
    global LesSequencesAssocieesClassesCanon
    global S2T

    set Dat1 "${rfile}.dat1"
    set d1 [open $Dat1 w]
    foreach d {eukaryota archaea bacteria} c {"#ff0000" "#0000ff" "#ffff00"} {
	foreach s [set LesSequencesAssocieesClassesCanon($d)] {
	    set t [set S2T($s)]
	    puts $d1 "$t\t$c"
	}
    }
    close $d1

    return

}

proc EcritEnfonctionDuSeuil {Seuil} {


	foreach I [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y] {
		Espionne "Fichier Chromosome $I"
		set FichierEntree [open "/genomics/link/STAF/fiches/VDR/Conservation/Conservation-Chr$I-mouse.gapless" "r"]
		set FichierSortie  [open "/genomics/link/STAF/fiches/VDR/Conservation/Conservation-Chr$I-mouse.best" "w"]
		while { [gets $FichierEntree Ligne]  >=0 } {
			ScanLaListe $Ligne Chromosome ID DR Start End Orientation Sequence ConsensusH NbMM QuelMM  HitSouris GeneH
			set DetailSouris [split $HitSouris "/"]
			set Score [lindex $DetailSouris 5]
			if { $Score >= $Seuil } {
				puts $FichierSortie $Ligne
			}
		}
		close $FichierEntree
		close $FichierSortie
	}

}

proc EcritFichier {Liste NomFichier} {

    set  f [open $NomFichier w]
    foreach el $Liste {
	puts $f $el
    }
    close $f

}

proc EcritGrapheContacts {fpdb mol chn} {

    
    DecortiqueUnPDB $fpdb
    set Cnct [ResiduesEnContact $mol $chn]
    set f [open "${mol}_contact.txt" w]
    puts $f "${mol}_${chn}"
    puts $f [join $Cnct "\n"]
    close $f
    
    return

}

proc EcritLeBilanConservation {ft} {

    global Defauts TabSF Couleurs TypeCons TypeText LNDG

    set NbGrp [expr {[llength $LNDG]-2}]
    set LesVals {}
    set LesCpl [array get TabSF "*,$ft"]
    foreach {s e} $LesCpl {
	set LesVals [concat $LesVals $e]
    }
    set LesVals [lsort -unique $LesVals]

    AuLog ""
    AuLog "Ordali results summary : Residues between braces are Ordali points"
    AuLog "========================"
    AuLog "Method : $ft"

    set aecrire ""
    foreach t $TypeCons {
	set NP 0
	set NA 0

	set Lidx [lsearch -all -regexp $LesVals $t]
	foreach idx $Lidx {
	    set f [lindex $LesVals $idx]
	    DecortiqueUneFeature $f dg fg col score note

	    if {[EstCeUnPoint $dg $t]} {
		set lav "($dg)"
		incr NP
	    } else {
		set lav $dg
		incr NA
	    }
	    if {$aecrire eq ""} {
		set nsep [expr {19-[string length [set TypeText($t)]]}]
		set entete "[set TypeText($t)] [string repeat "." $nsep]:"
		set aecrire "$entete $lav"
	    } else {
		set lg [expr {[string length $aecrire]+[string length " ,$lav"]}]
		set nnl [regsub "\n" $aecrire "" tmp]
		if {$lg-$lg*$nnl > 80} {
		    append aecrire "\n ,$lav"
		} else {
		    append aecrire " ,$lav"
		}
	    }
	}
	if {$aecrire ne ""} {
	    AuLog $aecrire
	    set aecrire ""
	}
    }

    return

}

proc EcritLePDB {id Fichier} {

    global PDB_[set id]_NomAtm
    global PDB_[set id]_NomRes
    global PDB_[set id]_NmrRes
    global PDB_[set id]_ChnIdn
    global PDB_[set id]_AtmXYZ
    global PDB_[set id]_AtmBQ
    global PDB_[set id]_Header
    
    if {$Fichier eq ""} {set Fichier [DemandeEtSauveFichier "pdb"]}
    
    set f [open $Fichier w]
    puts $f [join [set PDB_[set id]_Header] "\n"]
    
    set i 1
    foreach c [set PDB_[set id]_ChnIdn] {
	if {$i != 1} {puts $f "TER "}
	foreach nmr [set PDB_[set id]_NomRes($c)] nbr [set PDB_[set id]_NmrRes($c)] lan [set PDB_[set id]_NomAtm($c)] lax [set PDB_[set id]_AtmXYZ($c)] lab [set PDB_[set id]_AtmBQ($c)] {
	    foreach lx $lax lb $lab n $lan {
		lassign $lx x y z
		lassign $lb b q
		set chn $c
		if {$c eq "a"} {set chn " "}
		set NomR [AutreCodeLuc $nmr]
		set ligne [format "%6s%5d %4s %3s %1s%4d    %8.3f%8.3f%8.3f%6.2f%6.2f" "ATOM  " $i $n $NomR $chn $nbr $x $y $z $q $b]
		puts $f $ligne
		incr i
	    }
	}
    }
    puts $f "END"
    close $f
    
    return

}

proc EcritLeTfa {FilOut LesNoms LesSequences} {

    if {$FilOut eq ""} {
	set FilOut [DemandeEtSauveFichier "tfa" 1]
    }
    if {$FilOut eq ""} {return}

    set f [open $FilOut w]
    foreach Nm $LesNoms s $LesSequences {
	if {[string trim $Nm] eq ""} {continue}
	puts $f ">$Nm"
	set D 0
	while {$D < [string length $s]} {
	    set F [expr {$D + 59}]
	    set Linit [string range $s $D $F]
	    set L [string map {Z - . -} $Linit]
	    puts $f "$L"
	    incr D 60
	}
    }

    close $f

    return

}

proc EcritListeScore {{f ""}} {


    global ListeScore

    if {$f == ""} {set f "brute.dat"}
    set f [open $f w]
    set i 1
    foreach e $ListeScore {
	set le [join $e " "]
	puts $f "$i $le"
	incr i
    }
    close $f

    return

}

proc EcritNom {AId n x1 y1 x2 y2} {

    global Abr

    set NAff [NomAffiche $AId $n]

    set PAD [set Abr($AId,PAD)]
    set xi [SurGrille $x1]
    set yi [SurGrille $y1]
    set xf [SurGrille $x2]
    set yf [SurGrille $y2]
    set ym [expr {($yi+$yf)/2 +1}]
    if {$xi != $xf} {
	set id [$PAD create line $xi $yi $xf $yi  -fill black  -width 2  -tags "line-$n"]
    }
    set id [$PAD create text [expr {$xf+1}] $ym  -font "TreeFont$AId"  -fill black  -text "$NAff"  -anchor w -justify left  -tags "feuille-$n"]
    set Lc [$PAD bbox $id]
    set Id [$PAD create rectangle $Lc  -fill white  -outline white  -tags "Rfeuille-$n"]

    $PAD lower $Id

    return

}

proc EcritNomCart {AId n x y Angle} {

    global Abr

    while {$Angle >=  [2Pi]} {set Angle [expr {$Angle-[2Pi]}]}
    while {$Angle <= -[2Pi]} {set Angle [expr {$Angle+[2Pi]}]}
    set Angle [expr {$Angle*-180./[Pi]}]
    if {$Angle < 0.} {set Angle [expr {$Angle+360.}]}

    set NAff [NomAffiche $AId $n]
    set PAD [set Abr($AId,PAD)]

    if {$Angle > 90. && $Angle < 270.} {
	set anc e
	set jus right
	set Angle [expr {$Angle+180.}]
    } else {
	set anc w
	set jus left
    }

    set id1 [$PAD create text $x $y  -text " $NAff "  -font "TreeFont$AId"  -justify $jus  -anchor $anc]
    set bb [$PAD bbox $id1]
    $PAD delete $id1
    lassign $bb x1 y1 x2 y2
    set Lp [list $x1 $y1 $x1 $y2 $x2 $y2 $x2 $y1]

    set id [$PAD create text $x $y  -text " $NAff"  -anchor $anc  -font "TreeFont$AId"  -angle $Angle  -tags "feuille-$n"]

    set Angle [expr {-1.*$Angle}]
    foreach {xp yp} $Lp {
	lassign [TourneBoiteD $x $y $xp $yp $Angle] nx ny
	lappend Lc $nx $ny
    }
    set Id [$PAD create polygon $Lc  -fill white  -outline white  -width 0  -tags "Rfeuille-$n"]

    $PAD lower $Id

    return

}

proc EcritNomCart85 {AId n x y Angle} {

    global Abr

    set sz [set Abr($AId,FontSize)]

    while {$Angle >=  [2Pi]} {set Angle [expr {$Angle-[2Pi]}]}
    while {$Angle <= -[2Pi]} {set Angle [expr {$Angle+[2Pi]}]}
    if {$Angle < 0.} {set Angle [expr {$Angle+[2Pi]}]}

    set NAff [NomAffiche $AId $n]
    set PAD [set Abr($AId,PAD)]
    set xg $x
    set yg $y

    set f [set Abr($AId,pixfont)]
    lassign [pixfont measure $f $sz $NAff] w h1 h2
    set Off 2
    #    set h $sz
    set h [expr {$sz+$Off}]

    set AngOri $Angle

    if {$Angle <= [PiS2]} {
	set Pxy [list $x [expr {$y-$h/2}] $x [expr {$y+$h/2}] [expr {$x+$w}] [expr {$y+$h/2}] [expr {$x+$w}] [expr {$y-$h/2}]]
    } elseif {$Angle > [PiS2] && $Angle < [Pi]} {
	set Angle [expr {$Angle+[Pi]}]
	set Pxy [list $x [expr {$y-$h/2}] $x [expr {$y+$h/2}] [expr {$x-$w}] [expr {$y+$h/2}] [expr {$x-$w}] [expr {$y-$h/2}]]
    } elseif {$Angle > [Pi] && $Angle < 3.*[PiS2]} {
	set Angle [expr {$Angle+[Pi]}]
	set Pxy [list $x [expr {$y-$h/2}] $x [expr {$y+$h/2}] [expr {$x-$w}] [expr {$y+$h/2}] [expr {$x-$w}] [expr {$y-$h/2}]]
    } else {
	set Pxy [list $x [expr {$y-$h/2}] $x [expr {$y+$h/2}] [expr {$x+$w}] [expr {$y+$h/2}] [expr {$x+$w}] [expr {$y-$h/2}]]
    }

    if {$Angle > [Pi]} {set Angle [expr {$Angle-[2Pi]}]}

    set xmin 99999 ; set xmax -999999
    set ymin 99999 ; set ymax -999999
    foreach {xp yp} $Pxy {
	lassign [TourneBoite $x $y $xp $yp $Angle] nx ny
	set nx [expr {round($nx)}]
	set ny [expr {round($ny)}]
	set xmin [expr {$nx<$xmin?$nx:$xmin}]
	set ymin [expr {$ny<$ymin?$ny:$ymin}]
	set xmax [expr {$nx>$xmax?$nx:$xmax}]
	set ymax [expr {$ny>$ymax?$ny:$ymax}]
	lappend Lc $nx $ny
    }
    set w2 [expr {abs($xmax-$xmin+0*$Off)}]
    set h2 [expr {abs($ymax-$ymin+0*$Off)}]

    set dy 0
    set dx 0
    set sh2 [expr {round(($h2+$Off)/4)}]
    set sw2 [expr {round(($w2+$Off)/4)}]
    #    set sz2 [expr {round($sz/2)}]
    #    set sz2 $sz
    set ian [expr {int(floor($AngOri/[PiS16]))}]
    switch $ian {
	30 {set anc "w" ; set dy -$sh2}
	31 - 32 - 0 {set anc "w"}
	1 {set anc "w" ; set dy $sh2}

	2 {set anc "nw" ; set dy 0}
	3 - 4 {set anc "nw"}
	5 {set anc "nw" ; set dy 0}

	6 {set anc "n" ; set dx $sw2}
	7 -  8 {set anc "n"}
	9 {set anc "n" ; set dx -$sw2}

	10 {set anc "ne" ; set dy 0}
	11 - 12 {set anc "ne"}
	13 {set anc "ne" ; set dy 0}

	14 {set anc "e" ; set dy $sh2}
	15 - 16 {set anc "e"}
	17 {set anc "e" ; set dy -$sh2}

	18 {set anc "se" ; set dy 0}
	19 - 20 {set anc "se"}
	21 {set anc "se" ; set dy 0}

	22 {set anc "s" ; set dx -$sw2}
	23 - 24 {set anc "s"}
	25 {set anc "s" ; set dx $sw2}

	26 {set anc "sw" ; set dy 0}
	27 - 28 {set anc "sw"}
	29 {set anc "sw" ; set dy 0}
    }

    set INAff [ImgDeNomPIX $f $sz $w2 $h2 $NAff $Angle]

    # ORIGINE image en xg yg
    set id [$PAD create image [expr {$x+$dx}] [expr {$y+$dy}]  -anchor $anc  -image $INAff  -tags "feuille-$n"]

    set Id [$PAD create polygon $Lc  -fill white  -outline white  -width 0  -tags "Rfeuille-$n"]

    $PAD lower $Id

    return

}

proc EcritNomCirculaire {AId n x1 y1 x2 y2 Angle} {

    global Abr
    global TextFeuille MemoXY

    if { ! [info exists TextFeuille]} { set TextFeuille -1 }
    incr TextFeuille

    set fm [font configure TreeFont$AId -family]
    regsub -all " " $fm "" fm
    set sz [font configure TreeFont$AId -size]
    set md [font configure TreeFont$AId -weight]

    set NAff [NomAffiche $AId $n]
    #    set NAff $TextFeuille

    set PAD [set Abr($AId,PAD)]
    set xi [SurGrille $x1]
    set yi [SurGrille $y1]
    set xf [SurGrille $x2]
    set yf [SurGrille $y2]

    set yg $yf
    if {$Angle <= acos(0)} {
	set anc "nw"
	set xg $xf
    } elseif {$Angle > acos(0) && $Angle < acos(-1)} {
	set xg $xf
	set anc "ne"
	set Angle [expr {$Angle+acos(-1)}]
    } elseif {$Angle > acos(-1.) && $Angle < asin(-1)+2*acos(-1)} {
	set xg $xf
	set anc "se"
	set Angle [expr {$Angle+acos(-1)}]
    } else {
	set xg [expr {$xf+2}]
	set anc "sw"
    }
    set Angle [expr {-1.*$Angle}]
    set INAff [ImgDeNom $NAff $fm $sz $md $Angle]
    OpacifieImage $INAff white 0

    set yTF $yf
    if {[info exists MemoXY($xf,$yf)]} {set yTF [expr {$yf + 10}] }
    set MemoXY($xf,$yf) 1

    set id [$PAD create line $xi $yi $xf $yf  -fill black  -width 2]


    set id [$PAD create image $xg $yg  -anchor $anc -image $INAff  -tags "feuille-$n"]
    set Lc [$PAD bbox $id]
    set Id [$PAD create rectangle $Lc  -fill white  -outline white  -tags "Rfeuille-$n"]

    $PAD lower $Id

    return

}

proc EcritPourDPC {{filout ""}} {

    global OrdTmpDir ListeScore

    if {$filout eq ""} {set filout [file join $OrdTmpDir "ficdpc.dat"]}
    set f [open $filout w]

    set nv [expr {[llength [lindex $ListeScore 0]] - 1}]
    set comp [llength $ListeScore]
    puts $f "$comp\t$nv"
    puts $f ""
    foreach s $ListeScore {
	puts $f [join $s "\t"]
    }

    close $f

    return

}

proc EcritSpheres {mol} {


global ListeDesObjetsDansO
global Defauts

if {! [info exists ListeDesObjetsDansO]} {return}
if {[set Defauts(SphPts)]} {
if {[info exists ListeDesObjetsDansO(PTS)] != 0} {
IlFautVoir "DebutDb ${mol}sf"
IlFautVoir "begin ${mol}sf"
IlFautVoir "colour white"
} else {
return
}
foreach s [set ListeDesObjetsDansO(PTS)] {
IlFautVoir $s
}
IlFautVoir "end"
IlFautVoir "FinDbMc"

return
}

foreach col [array names ListeDesObjetsDansO] {

if {[regexp {\_} $col]} {
set IdxU [string last "_" $col]
set ColOut [string range $col [expr $IdxU + 1] [expr $IdxU + 6]]
} else {
set ColOut $col
}

if {$col == "PTS"} {set ColOut "pts"}

IlFautVoir "DebutDb ${mol}sf"
IlFautVoir "begin ${mol}sf"
if {$col == "PTS"} {
IlFautVoir "colour white"
} else {
IlFautVoir "colour $col"
}

foreach sph [set ListeDesObjetsDansO($col)] {
IlFautVoir $sph
}

IlFautVoir "end"
IlFautVoir "FinDbMc"
}

return

}

proc EcritTableDistances {aT f} {

    upvar $aT T

    set foo [open $f w]

    set Ln [array names T]
    foreach e $Ln {
	set Le [join [split $e ,]]
	lappend Lnom {*}$Le
    }
    set Lnom [lsort -unique $Lnom]
    set pl [PlusLongEltDe $Lnom]

    puts $foo [format "%5d" [llength $Lnom]]
    foreach n1 $Lnom {
	set ent [format "%${pl}s" $n1]
	set i 0
	foreach n2 $Lnom {
	    lassign [set T($n1,$n2)] pc l1 l2 lsl
	    set dst [expr {1.-$pc}]
	    append ent [format "%8.4f" $dst]
	    incr i
	    if {$i == 8} {
		puts $foo $ent
		set ent [string repeat " " $pl]
		set i 0
	    }
	}
	puts $foo $ent
    }
    close $foo

    return

}

proc EcritUnArbre {AId {fout ""}} {

    global Abr

    if {$fout eq ""} {
	set fout [DemandeEtSauveFichier ph 1]
	if {$fout eq ""} {return}
    }

    set Abr($AId,OutPH) ""
    EcritUnNoeud $AId root
    append Abr($AId,OutPH) ";"

    set o [open $fout w]
    puts $o $Abr($AId,OutPH)
    close $o

    puts "\n$Abr($AId,OutPH)"

    return

}

proc EcritUnNoeud {AId n} {

    global Abr
#lululu
    set t [set Abr(Arbre,$AId)]
    append Abr($AId,OutPH) "("
    
    set ic 1
    set nc [llength [$t children $n]]
    foreach c [$t children $n] {
	if {[$t isleaf $c]} {
	    append Abr($AId,OutPH) "[$t get $c name]:[$t get $c length]"
	} else {
	    EcritUnNoeud $AId $c
	}
	if {$ic < $nc} {
	    append Abr($AId,OutPH) ","
	}
	incr ic
    }
    append Abr($AId,OutPH) ")"
    
    if {$n ne "root"} {
	if {$Abr($AId,BootDone)} {
	    append Abr($AId,OutPH) "[$t get $n nboot]"
	}
	append Abr($AId,OutPH) ":[$t get $n length]"
    }
    
    return

}

proc EditAndShow {Texte {FichierPourSave ""} {Maniere ""}} {

    return [AfficheVariable [EntreTexte $Texte] "AvecFormate$Maniere" $FichierPourSave]

}

proc EditFeatureItem {} {

    global EFeat LNOrdali TabSF

    set EFeat(COk) 0
    if {$EFeat(LItemSel) == {} } {
	FaireLire "Please select features before to edit them !"

	return
    }

    set Lx1x2  [list]
    set Lcolor [list]
    set Lscore [list]
    set Lnote  [list]
    foreach e $EFeat(LItemSel) {
	lassign $e zones noteRef ft
	foreach {p1 p2} $zones {
	    lassign [split $p1 .] y x1
	    lassign [split $p2 .] y x2
	    incr x2 -1

	    set nom [lindex $LNOrdali $y-1]
	    foreach e [set TabSF(${nom},$ft)] {
		DecortiqueUneFeature $e d f col score note csys
		lappend Lcolor $col
		lappend Lnote $note
		lappend Lscore $score
		if {$d == $x1 && $f == $x2} {
		    lappend Lx1x2 [list $x1 $x2]
		}
	    }
	}
    }

    set Lx1x2  [lsort -unique -integer -index 0 $Lx1x2]
    set Lcolor [lsort -unique $Lcolor]
    set Lscore [lsort -unique -real $Lscore]
    set Lnote  [lsort -unique $Lnote]

    set EFeat(Lx1x2)  [linsert $Lx1x2 0 "Select"]
    set EFeat(Lcolor) [linsert $Lcolor 0 "Select"]
    set EFeat(Lnote)  [linsert $Lnote 0 "Select"]
    set EFeat(Lscore) [linsert $Lscore 0 "Select"]

    WindowEditItem edit
    
    ChangeFeatureForEditing

    return

}

proc EditInfoSeq {} {

    global LNOrdali TDesSeqnames
    global nseqCombo TEdit nold

    if {[TypeAli] eq "pasdali"} {return}
    if {[QuelMode] eq "seqlab"} {
	FaireLire "Not available in Editor mode !"
	return
    }

    # already open ..
    set w ".editinfoseq"
    if {[winfo exists $w]} {
	raise $w

	return
    }

    if {[winfo exists $w]} {
	raise $w
	return
    }

    if {[VueEditee]} {
	EnregistreLeMac
	VueEditee 0
    }

    set Ln [list]
    foreach n $LNOrdali {
	if {[string trim $n] eq ""} {continue}
	lappend Ln $n
	set TEdit(corr,$n) $n
    }
    set nseqCombo [lindex $Ln 0]
    set nold $nseqCombo

    set LMx [PlusLongEltDe $Ln]
    set LMx [expr {$LMx>20?$LMx:20}]
    set TEdit(mode) "edit"

    toplevel $w
    wm title $w "Edit Sequences Information"
    wm protocol $w WM_DELETE_WINDOW KillParLaCroix

    set wf "$w.f"
    frame $wf
    grid $wf -row 0 -column 0 -sticky news
    grid columnconfig $w 0 -weight 1
    grid rowconfig    $w 0 -weight 1

    frame $wf.top
    grid $wf.top -row 0 -column 0 -sticky news -pady 15 -padx 10
    label $wf.top.lab  -text "Sequence  "
    set TEdit(nseqCombo) [lindex $Ln 0]
    ttk::combobox $wf.top.seq  -background white  -width $LMx  -values $Ln  -state readonly  -textvariable TEdit(nseqCombo)
    $wf.top.seq index 0
    bind $wf.top.seq <> [list InfosDeLaSeq %W VientDuCombo]
    grid $wf.top.lab -row 0 -column 0 -sticky w
    grid $wf.top.seq -row 0 -column 1 -sticky w

    frame $wf.edt -bd 2 -relief groove
    label $wf.edt.lsqn  -text "Sequence Name : "  -anchor e -justify right
    entry $wf.edt.esqn  -bg white  -textvariable TEdit(seqname)
    label $wf.edt.lacc  -text "Accession : "  -anchor e -justify right
    entry $wf.edt.eacc  -bg white  -textvariable TEdit(access)
    label $wf.edt.lnid  -text "Bank Id : "  -anchor e -justify right
    entry $wf.edt.enid  -bg white  -textvariable TEdit(bid)
    set TEdit(tdes) "$wf.edt.edes"
    set l [LgtDescriptif]
    set nl [expr {$l/20+1>3?$l/20+1:3}]
    label $wf.edt.ldes  -text "Description : "  -anchor e -justify right
    text $wf.edt.edes  -relief sunken  -width $LMx  -height $nl  -bg white
    label $wf.edt.lorg  -text "Organism : "  -anchor e -justify right
    entry $wf.edt.eorg  -bg white  -textvariable TEdit(orga)
    label $wf.edt.llfd  -text "Life domain : "  -anchor e -justify right
    entry $wf.edt.elfd  -bg white  -textvariable TEdit(lifed)
    label $wf.edt.ltxd  -text "Taxa Id : "  -anchor e -justify right
    entry $wf.edt.etxd  -bg white  -textvariable TEdit(taxid)
    label $wf.edt.lec  -text "E.C. : "  -anchor e -justify right
    entry $wf.edt.eec  -bg white  -textvariable TEdit(ec)
    
    grid $wf.edt.lsqn -row 0 -column 0 -sticky e 
    grid $wf.edt.esqn -row 0 -column 1 -sticky w
    grid $wf.edt.lacc -row 1 -column 0 -sticky e
    grid $wf.edt.eacc -row 1 -column 1 -sticky w
    grid $wf.edt.lnid -row 2 -column 0 -sticky e
    grid $wf.edt.enid -row 2 -column 1 -sticky w
    grid $wf.edt.ldes -row 3 -column 0 -sticky ne
    grid $wf.edt.edes -row 3 -column 1 -sticky w
    grid $wf.edt.lorg -row 4 -column 0 -sticky e
    grid $wf.edt.eorg -row 4 -column 1 -sticky w
    grid $wf.edt.llfd -row 5 -column 0 -sticky e
    grid $wf.edt.elfd -row 5 -column 1 -sticky w
    grid $wf.edt.ltxd -row 6 -column 0 -sticky e
    grid $wf.edt.etxd -row 6 -column 1 -sticky w
    grid $wf.edt.lec  -row 7 -column 0 -sticky e
    grid $wf.edt.eec  -row 7 -column 1 -sticky w
    grid columnconfig $wf.edt 1 -weight 1
    grid $wf.edt -row 1 -column 0 -sticky news -padx 10 -pady 5

    frame $wf.btn
    button $wf.btn.dis  -background red  -text "Cancel"  -command "DismissInfoSeq $w"
    button $wf.btn.ok  -bg green1  -text " OK "  -command "AcceptInfoSeq $w"
    grid $wf.btn.dis -row 0 -column 0 -sticky w -padx 20
    grid $wf.btn.ok  -row 0 -column 1 -sticky e -padx 20
    grid $wf.btn -row 2 -column 0 -sticky ew -pady 15
    grid columnconfig $wf.btn all -weight 1
    
    InfosDeLaSeq "" $nseqCombo
    
    MesCouleurs $w
    FenetreAuCentre $w
    grab $w

    tkwait window $wf

    return

}

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 EditeClusterEntry {w} {

    if {$::Clus(NewEntry)} {
	$w delete 0 end
	set $::Clus(NewEntry) 0
    }

    return

}

proc EditeEtCreeFichier {{Fichier ""} {Defo ""} {Ask ""}} {

    set Texte [EntreTexte $Defo]
    if {$Texte==""} { return "" }
    if {$Texte=="\n"} {
	if {[OuiOuNon "Do I cancel EditeEtCreeFichier ?"]} { return "" }
	if {[OuiOuNon "Do I save as an empty string (without \\n) ?"]} { set Texte "" }
    }
    if {$Fichier=="" || $Ask!=""} { set Fichier [FichierPourSaveAs $Fichier] }
    if {$Fichier==""} { return "" }
    return [Sauve $Texte dans $Fichier]

}

proc EditeNoteIndel {} {


    set laa {A C D E Fa Fb G H I L M N P R S T V W Y}
    set base "_lastfinal.xml"
    set out "_lastfinal2.xml"

    foreach a $laa {
	set f "${a}$base"
	set o [open "${a}$out" w]
	set Ll [LesLignesDuFichier $f]
	foreach l $Ll {
	    if {[regexp {fnote} $l] && [regexp {type} $l]} {
		set l [string map [list "insertion_" ""] $l]
		set l [string map [list "type_" "type"] $l]
		set l [string map [list "type" "indel_type"] $l]
	    }
	    puts $o $l
	}
	close $o
    }

    exit

}

proc EditeSeq {quoi} {

    global db NomSeqSel LNOrdali

    $db eval {begin transaction}

    set pk_vue [VueCourante index]
    set pkvo   [VisCourante]
    set pkvm [$db eval {select pk_vis_mere from vis where pk_vis=$pkvo}]
    if {! $pkvm} {
	# Peut pas revenir plus en amont !! Return !
	$db eval {commit}
	return
    }

    set Lnow [$db eval {select pk_seqali from ln_vis_seqali where pk_vis=$pkvo order by pos}]
    set Lold [$db eval {select pk_seqali from ln_vis_seqali where pk_vis=$pkvm order by pos}]

    LesDefauts IxVisCourante $pkvm
    DetruitVis $pkvo

    $db eval {commit}

    RafraichitAffichage

    set NomSeqSel {}
    if {[llength $Lnow] < [llength $Lold]} {
	set Loff [lor $Lnow $Lold]
	set Laof [LesAccessDesSeqali $Loff]
	foreach n $Laof {
	    lappend NomSeqSel "[expr {[lsearch $LNOrdali $n]+1}].0"
	}
	TagNomsSelectionnes
    }
    
    return

}

proc EditorMappingData {} {

    if {[info exists ::TypeSeq] && $::TypeSeq eq "DNA"} {
	set Lignes "A white red
    G black orange
    C white blue
    T black green1
    U black green1
    X black white
    N white black
    . black dimgrey
    Space white white"
    } else {
	set Lignes "I white magenta
    J white magenta
    L white magenta
    M white magenta
    V white magenta
    R white blue
    K white blue
    F white red
    Y white red
    W white red
    D white forestgreen
    B white forestgreen
    E white forestgreen
    Z black green1
    Q black green1
    P white black
    G black orange
    H black cyan
    N black cyan
    S white darkviolet
    T white darkviolet
    A white darkviolet
    U white darkviolet
    C white darkviolet
    X black dimgrey
    . black dimgrey
    0 black white
    1 black white
    2 black white
    3 black white
    4 black white
    5 black white
    6 black white
    7 black white
    8 black white
    9 black white
    Space white white"
    }

    set Lmap [list]
    foreach l [split $Lignes \n] {
	lassign [split [string trim $l] " "] n f b
	if {$n eq "Space"} {set n " "}
	lappend Lmap [list $n $f $b]
    }

    return $Lmap

}

proc EffaceCourant {w} {

    global TexteMontreCourant
    if {[info exists TexteMontreCourant($w)]} { 
	$w delete $TexteMontreCourant($w)
	unset TexteMontreCourant($w)
    }

}

proc EffaceLeLog {LBLog} {


    Wup "Permet d effacer  le log du panel general"

    global $LBLog
    
    if {$LBLog==""} {return ""}
    
    $LBLog configure -state normal
    $LBLog delete    0.0    end
    $LBLog configure -state disabled
    return ""

}

proc EffaceLesBoitesDuCanvas {K} {

 
    Wup "Permet d effacer tout sauf l entete du Illustreoligo cad les graphes et la query"

    set LesIds [$K find withtag {!("OligoGraph"^"Entete")}]
 
    foreach Ids $LesIds {
	$K delete $Ids
    }
    return ""

}

proc EffacePositionOligoPourTous {K X Y} {

    
    Wup "Affiche a droite et a gauche la position de tous les oligos par rapport a la query"

    global PositionExisteDeja 
    
    set Texte " "
    set         LesIds [$K find withtag "Positionner"] 
    foreach Id $LesIds {
	if {! [info exists PositionExisteDeja($K,$Id)]} {
	    set PositionExisteDeja($K,$Id) 0
	} else {
	    set PositionExisteDeja($K,$Id) 0
	}
    }
    set     Id ""
    foreach Id [$K find withtag "Position"] {$K itemconfigure $Id -text $Texte}
    return ""

}

proc EffaceWNomsWSeqs {} {

    global NomTextSeq NomNomSeq

    $NomNomSeq configure -state normal
    $NomNomSeq tag delete {*}[$NomNomSeq  tag names]
    $NomNomSeq delete 1.0 end
    $NomNomSeq configure -state disabled
    
    if {[QuelMode] ne "seqlab"} {
	$NomTextSeq configure -state normal
	$NomTextSeq tag delete {*}[$NomTextSeq tag names]
	$NomTextSeq delete 1.0 end
	$NomTextSeq configure -state disabled
    }

    TagsGenerauxFenetre

    return

}

proc EffectifDUnElementDansLesBanques {Quoi {Banque genbank} {Field des}} {

    set Banque [string tolower $Banque]
    if {[string equal -nocase $Banque "genembl"]} {set Banque "genbankfull"}
    if {[string equal -nocase $Banque "genbank"]} {set Banque "genbankfull"}
    ###WARNING WARNING WARNING###############
    #if {[string equal -nocase $Banque "genbankfull"]} {set Banque "genbank"}
    ###WARNING WARNING WARNING###############

    if {$Banque == "genbankfull"} {
	##Mise en attente si la banque est en mise à jour
	set FileUpdateGenbank "/gcg/Update/.genbank_update"
	if {[file exists $FileUpdateGenbank]} {
	    Espionne "SRS is updating the genbank database, please wait"
	    AttendreTantQueExiste "/gcg/Update/.genbank_update"
	    Espionne "The genbank database updating is done"
	}
    }
    set Commande "[ProgPathway getz] \"\\\[$Banque-$Field:$Quoi\\\]\" -wc"
    catch {set GetzOut [eval exec $Commande]} Message
    if {![info exists GetzOut] || $GetzOut == ""} {return}
    return $GetzOut

}

proc EffectifDuFtdDansLaBanque {Requete {Banque est} {Orga ""}} {

    set Commande "[ProgPathway getz] \"\("

    regsub -all -nocase {[^a-z0-9]} $Requete " " Requete
    set Requete [string trim $Requete]
    while {[regexp "  " $Requete]} {regsub -all "  " $Requete " " Requete}

    set LesRequetes [split $Requete " "]
    set nRequetes   [llength $LesRequetes]
    for {set i 0} {$i < $nRequetes} {incr i} {
	set Mot [lindex $LesRequetes $i]
	append Commande " \\\[$Banque-ftd:$Mot\\\] "
	if {[expr $i+1] < $nRequetes} {append Commande " \& "}
    }
    append Commande "\)>$Banque"
    if {$Orga != ""} {append Commande " \& \\\[$Banque-org:$Orga\\\]"}
    append Commande "\" -c"
    #Espionne $Commande
    set n [eval exec $Commande]
    return $n

}

proc EffectifsDesGO {FichierGO} {

    if {![file exists $FichierGO]} {return "File does not exists!"}
    set LesGeneOntology {}

    set F [open $FichierGO]
    while {[gets $F Ligne] >= 0} {
	if {$Ligne == ""} {continue}
	set LaLigne [split $Ligne "\t"] 
	set Type    [lindex $LaLigne 3]

	if {![info exists TabTmp($Type,nAccess)]} {
	    set TabTmp($Type,nAccess) 0
	}

	set GO      [lindex $LaLigne 4]
	set Access  [lindex $LaLigne 2]
	
	set Nom     [lindex $LaLigne 0]

	set LesGO [list $GO]
	foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {
	    lappend LesGO $Ancetre
	}
	foreach GO [lsort -unique $LesGO] {
	    if {$GO == ""} {continue}
	    if {![info exists TabTmp($GO)]} {
		lappend LesGeneOntology $GO
		set TabTmp($GO) 0
	    }
	    if {![info exists TabTmp($Access,$Nom,$Type)]} {
		incr TabTmp($Type,nAccess)
		set TabTmp($Access,$Nom,$Type) 1
	    }
	    if {![info exists TabTmp($Access,$Nom,$GO)]} {
		incr TabTmp($GO)
		set  TabTmp($Access,$Nom,$GO) 1
	    }
	}
    }
    set LesGO {}
    foreach GO $LesGeneOntology {
	if {$GO == "GO:0003673"} {continue}
	set Type    [Onto $GO Type  ]
	if {$Type == ""} {continue}
	set n       [set TabTmp($GO)]
	set nAccess [set TabTmp($Type,nAccess)]

	set Def     [lindex [Onto $Type $GO LesDefinitions] 0]
	lappend LesGO [list $Type $GO $n $nAccess [expr $n * 1.0 / $nAccess] $Def]
    }
    close $F
    return [lsort -index 0 [lsort -index end-1 -decreasing -real $LesGO]]

}

proc EleCoherence {} {

    set LesX [EleGen Chr22 X ListOf Gn]
    set LesF [EleGen Chr22 F ListOf Gn]
    set LesN [ListsComplement $LesF $LesX]
    Espionne $LesN
    exit

}

proc EleGen {{Chr ""} {Type ""} {Qui ""} {Quoi ""}} {

    global EleGen
    #rR EleGen permet d'interrgoger les annotations des ELEments du GENome 
    #rR EleGen Chr01 X ListOf Gn
    #rR EleGen Chr01 X NOTCH2 ListOfD
    #rR EleGen Chr01 X NOTCH2 ListOfF
    #rR EleGen Chr01 X NOTCH2 ListOfId
    #rR EleGen Chr01 X ListOf Id
    #rR EleGen Chr01 X ListOf All
    #rR EleGen Chr01 X exon:57053 D
    #rR
    #rR EleGen Chr01 6 ListOf Id
    #rR              ^ the type can be 0 1 2 3 4 5 6 7 8 9 X
    #rR use AnnotType ListOf T  to get the possible list of one letter types
    #rR and AnnotType 6 Type to get the Type
    #rR  or AnnotType 6 Type to get its Code
    #rR use AnnotType ListOf Code to get the possible codes
    #rR use AnnotType ListOf Type to get the possible types
    #rR 
    #rR Chr01 to Chr25 (it's also possible to use ChrX=Chr23, ChrY=Chr24, ChrM=Chr25) 
    #rR 2017/02/24
    #rR             Raymond 

    if {$Chr==""} { set Chr "Help" }
    if {[string equal -nocase $Chr "Help"]} {
	foreach Ligne [split [info body EleGen] "\n"] {
	    if { ! [regexp "^ +#rR " $Ligne]} { continue }
	    regsub "^ +#rR " $Ligne "" Ligne
	    lappend LeHelp $Ligne
	}
	return [join $LeHelp "\n"]
    }

    regsub -nocase "Chr" $Chr "Chr" Chr
    if {[regexp -nocase {^Chr([1-9])$} $Chr Match N]} { set Chr "Chr0$N" }
    regsub -nocase "ChrX" $Chr "Chr23"
    regsub -nocase "ChrY" $Chr "Chr24"
    regsub -nocase "ChrM" $Chr "Chr25"


    set T [AnnotType $Type T]

    if {[info exists EleGen($Chr,$T,$Qui,$Quoi)]} {
	if {[PourWscope]} { return "
[join $EleGen($Chr,$T,$Qui,$Quoi) \n]\n
" }
	return $EleGen($Chr,$T,$Qui,$Quoi)
    }
    if {[info exists EleGen($Chr,$T,EstCharge)]}  { return "" }
    set EleGen($Chr,$T,EstCharge) 1

    # 176049 176602	chr12	176049	176602	554	+	exon:415858	uc001qhw.2	440073	IQSEC3	hg19_genes_exons
    set FicInfo "[AnnotRep]/${Chr}_Infos$T"
    if {[FileAbsent $FicInfo]} { return "" }
    set EleGen($Chr,$T,Filename,) $FicInfo
    foreach Ligne [LesLignesDuFichier $FicInfo] {
	set LesMots [LesMotsDeLaLigne $Ligne]
	if {$T=="F"} {
	    lassign $LesMots D F E DO FO C Start Stop Length Brin Id Ucsc Gi Gn Type
	} else {
	    lassign $LesMots D F         C Start Stop Length Brin Id Ucsc Gi Gn Type
	    set E $T
	    set DO $Start
	    set FO $Stop
	}
	lappend EleGen($Chr,$T,ListOf,Id) $Id
	lappend EleGen($Chr,$T,ListOf,Gn) $Gn
	lappend EleGen($Chr,$T,ListOf,D) $D
	lappend EleGen($Chr,$T,ListOf,F) $F
	set EleGen($Chr,$T,$Id,D)  $D
	set EleGen($Chr,$T,$Id,F)  $F
	set EleGen($Chr,$T,$Id,Gn) $Gn
	set EleGen($Chr,$T,$Id,E)  $E
	set EleGen($Chr,$T,$D,D)   $D
	set EleGen($Chr,$T,$D,F)   $F
	set EleGen($Chr,$T,$D,Id)  $Id
	set EleGen($Chr,$T,$D,Gn)  $Gn
	set EleGen($Chr,$T,$D,E)   $E
	set EleGen($Chr,$T,$F,D)   $D
	set EleGen($Chr,$T,$F,F)   $F
	set EleGen($Chr,$T,$F,Id)  $Id
	set EleGen($Chr,$T,$F,Gn)  $Gn
	set EleGen($Chr,$T,$F,E)   $E
	lappend EleGen($Chr,$T,$Gn,ListOfId) $Id
	lappend EleGen($Chr,$T,$Gn,ListOfD) $D 
	lappend EleGen($Chr,$T,$Gn,ListOfF) $F
	lappend EleGen($Chr,$T,$E,ListOfId) $Id
	lappend EleGen($Chr,$T,$E,ListOfD) $D 
	lappend EleGen($Chr,$T,$E,ListOfF) $F
	set EleGen($Chr,$T,$D,Info) $Ligne
	lappend EleGen($Chr,$T,ListOf,All) "$C $D $F [expr $F-$D+1] $E $Id $Gn $Type"
	lappend EleGen($Chr,$T,ListOf,Info) "$C $E $Ligne"
    }
    set EleGen($Chr,$T,ListOf,Id) [lsort -unique $EleGen($Chr,$T,ListOf,Id)]
    set EleGen($Chr,$T,ListOf,Gn) [lsort -unique $EleGen($Chr,$T,ListOf,Gn)]
    return [EleGen $Chr $T $Qui $Quoi]

}

proc ElimineChampdansInfos {Champ {Liste ""}} {


    Wup "ElimineChampdansInfos Domaines: EVI00020"

    if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    if {$Liste==""} { set Liste [ListeDesPABs] }

    foreach Nom $Liste {
	Espionne $Nom
	InformeParSuppressionDuChamp $Nom $Champ
    }

}

proc ElimineLesEnterres {} {

    global RepertoireDuGenome

    ChargeLesPABs

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {
	scan $Ligne "%s" Nom 

	if {[Enterre $Nom]} {
	    lappend ListeDesEnterres $Ligne
	} else {
	    lappend ListeDesBornesDesPABs  $Ligne
	}
    }

    set ListeDesEnterres [lsort $ListeDesEnterres]
    set ListeDesBornesPABs [lsort -command CompareLesMilieux $ListeDesBornesDesPABs]

    Espionne [SauveLesLignes $ListeDesEnterres   dans "$RepertoireDuGenome/fiches/bornesdesenterres.arenommer"]
    Espionne [SauveLesLignes $ListeDesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs.arenommer"]

}

proc ElimineLesFichiersContenant {Texte} {

    set LesFichiers {}
    foreach Fichier [glob -nocomplain *] {
	if {[regexp "$Texte" [ContenuDuFichier $Fichier]]} {
	    Espionne $Fichier
	    lappend LesFichiers $Fichier
	} else {
	    continue
	}
    }
    if {$LesFichiers != {} } {
	if { [OuiOuNon "Voulez-vous vraiment effacer les fichiers?"]} {
	    foreach Fichier $LesFichiers {
		file delete $Fichier
	    }
	} 
    }
    return "The End"

}

proc ElimineLesFichiersNeContenantPas {Texte} {

    set LesFichiers {}
    foreach Fichier [glob -nocomplain *] {
	if {![regexp "$Texte" [ContenuDuFichier $Fichier]]} {
	    Espionne $Fichier
	    lappend LesFichiers $Fichier
	} else {
	    continue
	}
    }

    if {$LesFichiers != {} } {
	if { [OuiOuNon "Voulez-vous vraiment effacer les fichiers?"]} {
	    foreach Fichier $LesFichiers {
		file delete $Fichier
	    }
	} 
    }
    return "The End"

}

proc ElimineLesJRAyantLesMemesAccessDeProtOuDemRNA {FichierClusters} {

    #Autres jumeaux = JR ayant le meme access proteine ou mRNA.
    set LesAccessProt {}
    foreach Nom [ListeDesJR $FichierClusters] {
	set LesAccessProt [InterrogeProtAndmRNA $Nom Rang 1 LesProteines]
	
	if {$LesAccessProt !=""} {
	    foreach AccessProt $LesAccessProt {
		lappend LesAccessNom "$AccessProt $Nom"
	    }
	} else {
	    set LesAccessRNA [InterrogeProtAndmRNA $Nom Rang 1 LesmRNAs]
	    if {$LesAccessRNA!=""} {
		foreach AccessRNA $LesAccessRNA {
		    lappend LesAccessNom "$AccessRNA $Nom"
		}
	    } else {
		#ni prot ni mRNA
		lappend LesSans $Nom
	    }
	}
	
    }
    set LesAccessNomTries [lsort -dictionary $LesAccessNom]
    set AccessPrec ""
    set ListeSansDoublons {}
    set NomPrec ""
    foreach AccessNom $LesAccessNomTries {
	set Nom [lindex $AccessNom end]
	set Access [lindex $AccessNom 0]
	if {$Access!=$AccessPrec && $Nom!=$NomPrec} {
	    lappend ListeSansDoublons $Nom
	}
	set AccessPrec $Access
	set NomPrec $Nom
    }
    #Espionne "lessans : [llength $LesSans]"
    #Espionne ""
    #Espionne "lesavecuniques : [llength $ListeSansDoublons]"
    return $ListeSansDoublons

}

proc ElimineLesMacsimsIncomplets {} {

    set Rep [RepertoireDuGenome]
    set I 0
    set N 0
    foreach Nom [ListeDesPABs] {
	if {([incr I]%100)==0} { Espionne "au $I eme il y a deja $N problemes" }
	if {0 && $Nom > "HSAP99999"} { break }
	set FLL "leonLog/$Nom"
	if {[FileAbsent $Rep/$FLL]} { continue } 
	set FLM "msfLeon/$Nom"
	set FLX "msfLeon/$Nom.xml"
	set FMX "macsimXml/$Nom"
	set FMR "macsimRsf/$Nom"
#	set NR [llength [glob -nocomplain "$Rep/$FMR*"]]
	if {[file exists $Rep/$FLM] && [file exists $Rep/$FLX] && [file exists $Rep/$FMX]  && [file exists $Rep/$FMR]     && [file exists $Rep/$FMR.tfa]  && [file exists $Rep/$FMR.txt] && [file exists $Rep/$FMR.html]  && ! [file exists $Rep/$FMR.log]} { continue }
	incr N
	lappend LeBilan "$Nom [file exists $Rep/$FLM] [file exists $Rep/$FLX] [file exists $Rep/$FMX] [file exists $Rep/$FMR] [file exists $Rep/$FMR.tfa] [file exists $Rep/$FMR.txt] [file exists $Rep/$FMR.html]  [file exists $Rep/$FMR.log]"
    }
    set R [AfficheListe $LeBilan "AvecRetour"]
    foreach Ligne $R {
	scan $Ligne "%s" Nom
	foreach D [list msfLeon macsimXml macsimRsf leonLog] {
	    foreach F [glob -nocomplain "$Rep/$D/$Nom*"] {
		if {[OuiOuNonMemo "Ok to delete all wrong files in macsimXml macsimRsf leonLog msfLeon"]} {
		    file delete $F
		    Espionne "file delete $F"
		} else {
		    Espionne "file to delete $F"
		}
	    }
	}
    }
    return $R    

}

proc ElimineLesRedondancesDansUnFichier {Fichier} {

    if {![file exists $Fichier]} {return ""}
    set NouveauContenu ""
    set Contenu [ContenuDuFichier $Fichier] 
    foreach Ligne [LesLignesDuTexte $Contenu] {
	set PasEncoreVu 1
	foreach Ligne2 [LesLignesDuTexte $NouveauContenu] {
	    if {$Ligne == $Ligne2} {set PasEncoreVu 0} 
	}
	if {$PasEncoreVu == 1} {append NouveauContenu "$Ligne\n"}
    }
    Espionne $NouveauContenu

    if {[OuiOuNon "Voulez vous sauvez ces lignes\?"]} {
	set NewFile [SauveLeFichierSous $Fichier]
	Sauve $NouveauContenu dans $Fichier
    }
    return "$NouveauContenu"

}

proc ElimineLesRedondancesDansUneListe {Liste} {

    if {$Liste == {}} {return {}}
    set NewListe {}
    foreach Element $Liste {
	if {[info exists DejaVu($Element)]} { continue }
	set DejaVu($Element) 1
	lappend NewListe $Element
    }
    return $NewListe

}

proc ElmConserveOuNon {{Qui ""} {Quoi ""}} {
 
    global ElmConserveOuNon
    
    if {[info exists ElmConserveOuNon($Qui,$Quoi)]} {return $ElmConserveOuNon($Qui,$Quoi)}  
    Espionne "onpassela"
    if {[info exists ElmConserveOuNon("EstCharge")]} {return ""}
    set ElmConserveOuNon("EstCharge") 1

    foreach Box [ListeDesPABs] {
	#set Box [lindex [split $Qui "-"] 0]
	Espionne ""
	Espionne "Box $Box"
	set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit.elm"
	if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit.elm"}
	set LesNamesRef [CopsDunName $FileMacsims $Box] 
	Espionne "$LesNamesRef"
	#set GroupRef    [GroupDunName $FileMacsims $Box]
	#set LesNamesRef [NamesDunGroup $FileMacsims $GroupRef]	
        InitPosRel2Abs $FileMacsims $LesNamesRef

	set LesElmInfoRef [FromMacsims $FileMacsims $Box "ConcatElm"]
	
	foreach InfoRef $LesElmInfoRef {
	    #Espionne "InfoRef $InfoRef"
	    lassign $InfoRef ElmRef RFstart RFstop
	    set nbref 0; set nbconserv 0
	    set AbsRFstart [DonnePosRA $Box $RFstart Absolue] 
	    set AbsRFstop  [DonnePosRA $Box $RFstop Absolue]
	    set AbsInfoRef [list ${ElmRef} ${AbsRFstart} ${AbsRFstop}]
	    #Espionne "AbsInfoRef $AbsInfoRef"
	    foreach Name $LesNamesRef {
		if {[regexp "LA0AAA" $Name]} {continue}
		incr nbref
	#	Espionne "$nbref $Name"
		set LesElmInfoName [FromMacsims $FileMacsims $Name "ConcatElm"]
		foreach InfoName $LesElmInfoName {
                    lassign $InfoName ElmName Fstart Fstop
		    set AbsFastart [DonnePosRA $Name $Fstart Absolue]
		    set AbsFstop   [DonnePosRA $Name $Fstop Absolue]
		    
		    if {$ElmRef eq $ElmName && $AbsRFstart==$AbsFastart && $AbsRFstop==$AbsFstop} {
			incr nbconserv
			#Espionne "$nbconserv $InfoRef $Name $InfoName"
			break
		    }
		}
	    }
	    set pourcentage [expr {((100*$nbconserv)/$nbref)}]
	    Espionne "$ElmRef $AbsRFstart $AbsRFstop $nbconserv sur $nbref (${pourcentage}%)"
	    if {$pourcentage>70} {
		set ElmConserveOuNon($Box-[join $AbsInfoRef "-"],conservation) OUI
	    } else {
		set ElmConserveOuNon($Box-[join $AbsInfoRef "-"],conservation) NON
	    }
	}
    }
#LesDefauts
#AfficheProfileResults
    return [ElmConserveOuNon $Qui $Quoi]

}

proc EmblInfo {AccessOuTexteOuLesLignesEMBL {K ""} {GetWhat ""}} {

    if {[regexp "\n" $AccessOuTexteOuLesLignesEMBL]} {
	set LesLignesEMBL [split $AccessOuTexteOuLesLignesEMBL "\n"]
    } elseif {[regexp " " $AccessOuTexteOuLesLignesEMBL]} {
	set LesLignesEMBL AccessOuTexteLesLignesEMBL
    } else {
	set Access $AccessOuTexteOuLesLignesEMBL
	set LesLignesEMBL [LaSequenceDesBanques $Access]
    }
    if {$LesLignesEMBL==""} { return "" }

    if {$GetWhat==""} { set GetWhat "GetList" }
    set ListOfInfo [DecortiqueLesLignesEMBL $LesLignesEMBL]
    if {$K==""} { return $ListOfInfo }
    array set AllInfo $ListOfInfo
    if { ! [info exists AllInfo($K)]} { return "" }
    if {$GetWhat=="GetText"} { return [join $AllInfo($K) " "] }
    return $AllInfo($K)

}

proc Empreinte {pab} {

    
    global DefautsPipe
    global PipeCollection
    global lBestPdb
    global NQuery
    
    if {$PipeCollection} {
	set fileTfa      [file join [RepertoireDuGenome] "prottfa" $pab]
	set fileNormd    [file join [RepertoireDuGenome] "normd" $pab]
	set fileMsf      [file join [RepertoireDuGenome] "msf" $pab]
	set fileRascal   [file join [RepertoireDuGenome] "rascal" $pab]
	set fileLeon     [file join [RepertoireDuGenome] "leon" $pab]
	set fileBestMsf  [file join [RepertoireDuGenome] "empreinte" $pab.msf]
	# si une empreinte a deja ete calculee, on passe cette etape
	if {[file exists [file join [RepertoireDuGenome] "empreinte" ${pab}_1.empreinte]]} {
	    return 1
	}
    } else {
	set fileTfa     "$pab"
	set fileNormd   "[file rootname $pab].normd"
	set fileMsf     "[file rootname $pab].msf"
	set fileRascal  "[file rootname $pab].rascal.msf"
	set fileLeon    "[file rootname $pab].leon.msf"
	set fileBestMsf "[file rootname $pab].best.msf"
    }
    set NQuery [VerifieInputTfa $fileTfa]
    
    # Selection du meilleur msf
    if {[file exists $fileNormd]} {
	set bmsf [DefineBestMsfPipe $fileNormd]

	puts "bmsf est $bmsf"
	# si on a 1 best MSF 
	if {$bmsf ne "no file"} {
	    if {$bmsf == "Leon"} {
		if {$lBestPdb != ""} {
		    foreach pdb $lBestPdb {
			# Verifie la presence du BestPDB si le meilleur msf est leon
			set test [VerifPresencePDB $fileLeon $pdb]
			if {$test == 0} {
			    catch {set bmsf [DefineBestMsfClRasPipe $fileNormd]}
			}    
		    }
		}
	    }
	    
	    AjouteAuLogPipe "rbest vaut $bmsf"
	    #puts "best msf : $bmsf"
	    file copy -force [set file$bmsf] $fileBestMsf 
	    # creation de l alignement de la query avec le template
	    if {$lBestPdb != ""} {
		#puts "bestPDB = ok"
		CreeEmpreintePipe $pab $NQuery
	    }
	}
	return 1
    } else {
	return 0
    }

}

proc EmulationSeqLab {} {

    global NomNomSeq NomTextSeq LockSeqs
    global LNOrdali LSOrdali LNSeqlab LSSeqlab
    global Defauts ListeSeqsGroupees

    #bind $NomTextSeq "" ""
    bindtags $NomTextSeq ""
    #bind $NomNomSeq  "" ""
    bindtags $NomNomSeq ""
    update idletasks

    FaireAttendre "Entering Edition mode ...\nPlease wait ..."

    # Contenu fenetre
    set sep [string repeat "." [LongueurDeLAlignement ordali]]
    foreach s $LSOrdali n $LNOrdali {
	if {$n eq ""} {
	    lappend Ltmp $sep
	    lappend LSSeqlab [split $sep ""]
	} else {
	    lappend Ltmp $s
	    lappend LSSeqlab [split [string trim $s] ""]
	}
    }
    set LNSeqlab $LNOrdali
    array set ListeSeqsGroupees {}

    # repere position ascenceur
    lassign [$::TScrollY get] yscr tmp
    lassign [$::TScrollX get] tmp  xscr

    # change et remplit widget biotext
    set LockSeqs $Defauts(LockSeqs)
    AfficheFenetreSeqlab

    $NomTextSeq configure -foreground black -background DimGray
    #$NomTextSeq configure -foreground black -background white
    $NomTextSeq sequences $Ltmp
    $NomTextSeq mapping [set Defauts(Mapping)]
    $NomTextSeq map on
    $NomTextSeq configure -state normal

    update idletasks

    FaireLaSuite .sqat
    SeqlabFont

    # remet ascenceur
    CoupleY moveto $yscr
    CoupleX moveto $xscr

    return

}

proc EnMajuscule {Fichier {Action toupper}} {

    foreach Ligne [LesLignesDuFichier $Fichier] {
	lappend Sortie [string $Action $Ligne]
    }
    Espionne [SauveLesLignes $Sortie dans $Fichier.$Action]
    exit

}

proc EncadrementDeTexte_WordML {Texte {Bold 0} {Italic 0} {UnderLine 0} {Size 10} {Couleur black} {SurLignage white}} {

    global PoliceParDefautPourWordML

    set LeTexte {}
    lappend LeTexte ""
    if {$Bold                 } {lappend LeTexte [Bold_WordML     ]}
    if {$Italic               } {lappend LeTexte [Italic_WordML   ]}
    if {$UnderLine            } {lappend LeTexte [UnderLine_WordML]}

    lappend LeTexte [SurLignage_WordML $SurLignage]
    lappend LeTexte [Couleur_WordML    $Couleur   ]
    lappend LeTexte [Size_WordML       $Size      ]
    lappend LeTexte [Texte_WordML      $Texte     ]
    lappend LeTexte ""
    return [join $LeTexte "\n"]

}

proc EndTLog2HTML {} {

    global DebutBodyHTML

    Html_BodyToEnd

    # incsere la CSS 
    set CSS ""
    if {$CSS ne ""} {
	Html_Insert $DebutBodyHTML $CSS
    }

    return [Html_Get]

}

proc EndTLog2Text {} {

    global TextOut

    lappend TextOut ""

    return [join $TextOut \n]

}

proc EndWarning2HTML {} {

    Html_Append "
"
    Html_Append "
"
    Html_BR
    
    return

}

proc EnfonceBtnFeature {w} {


    $w configure  -relief sunken  -background red  -foreground white
    LesFeaturesUtilisees [$w cget -text] 1

    return

}

proc EnleveColonnesGaps {{LNom ""} {LSeq ""}} {

    global LNSeqlab LSSeqlab LNOrdali LSOrdali

    set qMode [QuelMode]
    if {$LNom eq ""} {
	if {$qMode eq "seqlab"} {
	    set LNom $LNSeqlab
	    set LSeq $LSSeqlab
	} else {
	    set LNom $LNOrdali
	    set LSeq $LSOrdali
	}
    }
    set LSeqIn $LSeq

    if {$qMode ne "seqlab"} {
	set new [list]
	foreach s $LSeq {
	    lappend new [split $s ""]
	}
	set LSeq $new
    }

    # Longueur de sequence
    set i -1
    foreach n $LNom {
	incr i
	if {[string trim $n] eq ""} {continue}
	set Long [llength [lindex $LSeq $i]]
	break
    }

    for {set i 0} {$i < $Long} {incr i} {
	set p$i 1
    }

    foreach s $LSeq n $LNom {
	if {[string trim $n] eq ""} {continue}

	set i 0
	foreach c $s {
	    if {$c ne "."} {set p$i 0}
	    incr i
	}
    }

    set lnew [list] ; set Li [list]
    set NOtes 0 ; set ltmp $LSeq
    for {set i 0} {$i < $Long} {incr i} {
	if {[set p$i]} {lappend Li $i}
    }

    set Li [lreverse [lsort -integer $Li]]
    set NOtes [llength $Li]
    if {! $NOtes} {return $LSeqIn}

    foreach s $LSeq n $LNom {
	if {[string trim $n] ne ""} {
	    foreach i $Li {
		set s [lreplace $s $i $i]
	    }
	}
	if {$qMode ne "seqlab"} {
	    set s [join $s ""]
	}
	lappend lnew $s
    }
    set LSeq $lnew

    return $LSeq

}

proc EnleveConservation {} {

    global ListeTypesDeFeatures Toggle

    set Li [lsearch -regexp -all $ListeTypesDeFeatures "Cons-"]
    if {$Li == {}} {return}

    set Li [lsort -integer -decreasing $Li]
    foreach i $Li {
	set f [lindex $ListeTypesDeFeatures $i]
	DetruitLaFeature $f
	DessineLesScores ""
    }

    if {[set Toggle(Feature)] && [QuelMode] eq "feature"} {
	DetruitBoutonsOrdali
	AfficheBoutonsFeatures
    }
    if {[set Toggle(Scores)]} {
	#lululu
    }

    return

}

proc EnleveConservationGlobale {} {

    global ConsMeth TbScores

    set LExc [concat [set ConsMeth(IdenGlob)] [set ConsMeth(ConsGlob)]]
    #puts "LExc $LExc"
    foreach e $LExc {
	foreach m $TbScores(Lcols) {
	    lset TbScores(Score,$m) $e -999.0
	}
    }

    return

}

proc EnleveDoublonOfString {File} {

    foreach Ligne [LesLignesDuFichier $File] {
	set LesMots [split $Ligne "\t"]
	set Initial [lindex $LesMots 1]
	set Copain  [lindex $LesMots 3]
	set Score   [lindex $LesMots 4]
	set Detail  [lindex $LesMots 5]
	set ScoreDetail "$Score $Detail"
	if {[info exists DejaVu($Copain-$Initial)]} {
	    if {$DejaVu($Copain-$Initial)!= $ScoreDetail} {
		Espionne "attention doublon diff pour $Copain $Initial:"
		Espionne "$ScoreDetail"
		Espionne "$DejaVu($Copain-$Initial)"
	    }
	} else {
	    set DejaVu($Initial-$Copain) $ScoreDetail
	    lappend LesLignesNettoyees $Ligne
	}
    }
    SauveLesLignes $LesLignesNettoyees dans $File

}

proc EnleveExtension {CheminDuRepertoire} {

    foreach F [glob -nocomplain "$CheminDuRepertoire/*"] {
	regsub {\.[^\.]+$} $F "" NewF
	file rename -force $F $NewF
    }

}

proc EnleveExtensionParticuliere {} {

    set RepXml "[RepertoireDuGenome]/macsimXml"
    set RepRsf "[RepertoireDuGenome]/macsimRsf"
    foreach F [glob -nocomplain "$RepXml/*.xml"] {
	set QueueF [file tail $F]
	set LesMotsF [split $QueueF "."]
	set NomF [lindex $LesMotsF 0]
	file rename -force $F "$RepXml/$NomF"
    }
    foreach D [glob -nocomplain "$RepRsf/*.rsf"] {
	set QueueD [file tail $D]
	set LesMotsD [split $QueueD "."]
	set NomD [lindex $LesMotsD 0]
	file rename -force $D "$RepRsf/$NomD"
    }

}

proc EnleveHeader {L} {

    set ia [lsearch -regexp $L {^ATOM  }]
    if {$ia != -1} {
	set L [lrange $L $ia end]
    }
    
    return $L

}

proc EnleveLaDerniereExtension {NameFile {EXT ""}} {

    if {$EXT == ""} {
	regsub -all {\.[^\.]+$} $NameFile "" NameFile
    } else {
	regsub -nocase -all "\.$EXT$" $NameFile "" NameFile
    }
    return $NameFile

}

proc EnleveLaSequenceDeMonOrganisme {Nom Sequences} {

    set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml"
    if {! [file exists $Fichier]} {return}
    ParseMACSIMS $Fichier macsims
    set MonOS [NotreOS]
    foreach Sequence $Sequences {
	set Organisme $macsims($Sequence,Organisme)
	if {[regexp "$MonOS" $Organisme]} {continue}
	lappend ListeDesSequences $Sequence
    }
    return $ListeDesSequences

}

proc EnleveLesLignesVidesDunFichier {Fichier} {

    set NouveauFichier ""
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne==""} {continue}
	append NouveauFichier "$Ligne\n"
    }
    return $NouveauFichier

}

proc EnleveLesPoints {} {


    global NomNomSeq
    global NomTextSeq
    global LNOrdali
    global LSSeqlab

    set Etat [$NomTextSeq cget -state]
    $NomTextSeq configure -state normal

    set Ls {}
    if {[QuelMode] eq "seqlab"} {
	set Ls $LSSeqlab
    }

    set Ln [split [$NomNomSeq get 1.0 end] "\n"]
    set i 0
    foreach n $Ln {
	incr i
	if {[string trim $n] ne ""} {continue}
	set s [$NomTextSeq get $i.0 "$i.0 lineend"]
	if {! [regexp {\*} $s]} {continue}
	$NomTextSeq delete $i.0 "$i.0 lineend - 1 chars"
	if {$Ls != {}} {
	    set Ls [lreplace $Ls [expr {$i+1}] [expr {$i+1}] " "]
	}
    }

    if {[QuelMode] eq "seqlab"} {
	set LSSeqlab $Ls
    }

    $NomTextSeq tag delete PtBack
    $NomTextSeq configure -state $Etat

    return

}

proc EnleveLigneVideDuFichier {Fichier} {

    set LesLignesFinal {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$Ligne!=""} {
	    lappend LesLignesFinal $Ligne
	}
    }
    SauveLesLignes $LesLignesFinal dans $Fichier

}

proc EnleveLignesVides {Liste} {

    if {$Liste=={}} {set LesLignes {}}
    foreach Ligne $Liste {
	if {[string trim $Ligne]==""} {continue}
	lappend LesLignes $Ligne
    }
    return $LesLignes

}

proc EnlevePrefixeBank {l} {

    if {! [info exists ::Defauts] || ! [set ::Defauts(RemoveBankPrefix)]} {return $l}

    set l [string map [list ">" "" "lcl|" ""] $l]
    set ul [string toupper $l]

    set s [string index $l 0]
    if {$s ne ">"} {
	set s ""
    }

    set done 0
    foreach b [set ::Defauts(PrefixesBank)] {
	set ub [string toupper $b]
	#lm Attention !
	#lm enleve "_" comme separateur de prefixe car peut
	#lm poser des probleme avec access swissprot !
	#
	#lm longueur du pattern
	set d [expr {[string length $s]+[string length $ub] +1}]
	foreach t {"\\\|" "\\\:"} {
	    set m "${s}${ub}${t}"
	    
	    if {[regexp -nocase "^$m" $ul]} {
		if {$ub ne "PDB" && [regexp -nocase {[a-z]} [string index $ul $d]]} {
		    set l [string range $l $d end]
		    set done 1
		    break
		}
	    }
	}
	if {$done} {
	    break
	}
    }

    return $l

}

proc EnlevePrefixeBankVOIR_DANS_GSCOPE_SEQUENCES {l} {


    if {! [info exists ::Defauts] || ! [set ::Defauts(RemoveBankPrefix)]} {return $l}

    set l [string map [list ">lcl|" ">"] $l]
    set ul [string toupper $l]

    set s [string index $l 0]
    if {$s ne ">"} {set s ""}

    foreach b [set ::Defauts(PrefixesBank)] {
	set ub [string toupper $b]
	foreach t {"\\\|" "\\\:" "\\\_"} {
	    set m "${s}${ub}${t}"
	    set d [expr {[string length $m] -1}]

	    if {[regexp -nocase "^${m}" $ul]} {
		if {$ub ne "PDB" && [regexp -nocase {[a-z]} [string index $ul [expr {$d+1}]]]} {
		    set l [string range $l $d end]
		    break
		}
	    }
	}
    }

    return $l

}

proc EnlevePrefixeFastacmd {l} {


    regsub {^>lcl\|} $l ">" l

    return $l

}

proc EnleveRedondanceEntreLesRefseq {} {

    set FichierNew "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata"
    set FichierRel "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata" 
    foreach LigneNew [LesLignesDuFichier $FichierNew] {
	if {[regexp "\>" $LigneNew]} {
	    set AccNew [lindex [split $LigneNew " "] 1]
	    lappend LesNews $AccNew
	}
    }
    foreach LigneRel [LesLignesDuFichier $FichierRel] {
	if {[regexp "\>" $LigneRel]} {
	    set trouve 0
	    set AccRel [lindex [split $LigneRel " "] 1]
	    foreach New $LesNews {
		if {$AccRel==$New} {
		    set trouve 1
		    break
		}
	    }
	    if {$trouve} {
		Espionne "$AccRel present dans les 2"
	    }
	}
	if {!$trouve} {
	    lappend LesLignesSelect $LigneRel
	}
    }
    SauveLesLignes $LesLignesSelect dans "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/NEWrefseq-rel-proteic_Vertebrata" 
    # renomme refseq-rel-proteic_Vertebrata en refseq-rel-proteic_Vertebrata_RedondAcNew
    # renomme NEWrefseq-rel-proteic_Vertebrata en refseq-rel-proteic_Vertebrata

}

proc EnleveRedondanceRefSeq_UMCU {file Out} {


    Wup "Permet de supprimer la redondance existante dans Refseq sur SRS"
    Wup "Pb non traites par les administrateurs des banques"
    
    #Attention si il y a des doublons on garde la sequence et l entete du dernier (+ recent dans RefSeq)

    set Tab(LesAccess) ""

    set F  [open "$file"]
    while {[gets $F Ligne]>=0} {
	#>refseq|NM_001718|NM_001718 Homo sapiens bone morphogenetic protein 6 (BMP6), mRNA. 
	if {  [string range $Ligne 0 0] == ">"} {
	    set Entete $Ligne
	    
	    set Access ""
	    regexp -nocase {refseq\|([a-z]+_[0-9]+)\|} $Ligne tmp Access
	    
	    lappend Tab(LesAccess)        $Access
	    set     Tab($Access,Entete)   "$Entete"
	    set     Tab($Access,Sequence) ""
	    continue
	}
	lappend Tab($Access,Sequence) $Ligne 
    }
    close $F

    set Liste ""
    set Liste [set Tab(LesAccess)]
    Espionne "Nb sequences:[llength $Liste]"
    set Liste [lsort -unique $Liste]
    Espionne "Nb sequences:[llength $Liste]"

    set ToWrite ""
    foreach E $Liste {
	lappend ToWrite       [set Tab($E,Entete)]
	lappend ToWrite [join [set Tab($E,Sequence)] "\n"]
    }
    
    if {[file exists $Out]} {file delete -force $Out}
    AppendAuFichier $Out [join $ToWrite "\n"]

    return ""

}

proc EnleveSpaceSeq {} {

    global NomTextSeq NomNomSeq NomSeqSel LSOrdali LNOrdali LNSeqlab LSSeqlab Defauts TScrollY

    if {[TypeAli] eq "pasdali"} {return}
    if {[llength $NomSeqSel] != 1} {
	FaireLire "Please select the sequence below which the separator should be removed !"
	return
    }

    if {[QuelMode] ne "seqlab"} {
	set LNoms $LNOrdali
    } else {
	set LNoms $LNSeqlab
    }

    lassign [split $NomSeqSel .] y x 
    set i [expr {$y+1}]
    if {$i >= [llength $LNoms]} {return}
    if {[lindex $LNoms $y] ne ""} {return}

    # strore Y-scroll position
    lassign [$TScrollY get] ysc tmp

    $NomNomSeq configure -state normal
    $NomNomSeq delete $i.0 "$i.0 lineend + 1c"
    $NomNomSeq configure -state disabled

    if {[QuelMode] ne "seqlab"} {
	VueEditee 1

	$NomTextSeq configure -state normal
	$NomTextSeq delete $i.0 "$i.0 lineend + 1c"
	$NomTextSeq configure -state disabled
	
	set LNOrdali [lreplace $LNOrdali $y $y]
	set LSOrdali [lreplace $LSOrdali $y $y]
    } else {
	# Beware ! Delete AT INDEX POSITION
	$NomTextSeq delete rows $y
	set LNSeqlab [lreplace $LNSeqlab $y $y]
	set LSSeqlab [lreplace $LSSeqlab $y $y]
    }

    MetAJourGroupes
    ChangeNomsAff $Defauts(NomsAffiches)
    AfficheNomsEtSeqs
    RepeintNomsEtSeqs

    # re-position at original Y
    CoupleY moveto $ysc

    return

}

proc EnleveVersionDeAccess {acc} {

    if {[set i [string first "." $acc]] != -1} {
	set suf [string range $acc $i+1 end]
	if {[string is integer -strict $suf]} {
	    set acc [string range $acc 0 $i-1]
	}
    }

    return $acc

}

proc EnleverACTACAN {Path} {

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EnleverACTACAN : Start"
	set FichierIn [open "$Path.best" "r"]
	set FichierOut [open "$Path.best18" "w"]
	set I 0
	while { [gets $FichierIn Ligne]  >=0} {
		ScanLaListe $Ligne ID Chromosome SBSStart SBSEnd SBSOrientation
		set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
		Espionne "$timestamp|EnleverACTACAN : sequence $ID"
		#regsub -all -nocase {chr} $Chromosome "" Chromosome
			if { $SBSOrientation == "+"} {
				set Start [expr $SBSStart + 7]
				set End [expr $SBSEnd]
			} else {
				set Start [expr $SBSEnd]
				set End [expr $SBSStart - 7]
			}
			#set Sequence  [string toupper [BoutAdnDeUcscBoost $Start $End $SBSOrientation "Homo_sapiens" $Chromosome "bigZips200603" ]]
			puts $FichierOut "$ID $Chromosome $Start $End $SBSOrientation"
	}
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EnleverACTACAN : End"
	close $FichierOut

}

proc EnregistreAnnotation {vue nom txt zon} {

    $::db eval {insert into anno values (NULL, '$txt', '$zon')}

    return

}

proc EnregistreCluster {pk_clustering Ls name} {

    global db

    $db eval {insert into cluster values (NULL, $pk_clustering, $name)}

    set lastCst [$db last_insert_rowid]
    set pos 0
    foreach i $Li {
	$db eval {insert into ln_seqali_cluster values ($i,$LastCst,$pos)}
	incr pos
    }

    return

}

proc EnregistreClustering {titre LNSG} {

    global ZoneClusterisation Clus

    $db eval {begin transaction}
    $db eval "insert into clustering values(NULL,[VueCourante index],'$titre','[set Clus(Method)]','$ZoneClusterisation')"
    set lastClu [$db eval {select max(pk_clus) from clustering}]
    foreach {g ls} $LNSG {
	EnregistreCluster $LastClu
    }

    $db eval {commit}

    return

}

proc EnregistreInfosSeqs {} {

    global db LNOrdali TDesSeqnames TDesAccess TDesBId TDesDescriptifs TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesPhylum TDesGO TDuLineage TDesHydro TDespI

    $db eval {begin transaction}
    set pkm [MacCourant]
    foreach n $LNOrdali {
	if {$n eq ""} {continue}

	set pksi [$db eval {select pk_seqinfo from seqinfo where seqname=$n}]

    	foreach t {TDesSeqnames TDesAccess TDesBId TDesDescriptifs TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesPhylum TDesGO TDuLineage TDesHydro TDespI} c {seqname access bid description organism taxid fragment cgroup ec complex phylum go lineage hydrophobicity isoelectric} {
	    set v [set ${t}($n)]
	    #puts "$n $pksi c= $c v= >>$v<<"
	    if {! [string is integer -strict $v] && ! [string is double -strict $v]} {
		if {$v eq ""} {
		    $db eval "update seqinfo set $c=NULL where pk_seqinfo = $pksi"
		} else {
		    set v [string map [list "'" "''"] $v]
		    $db eval "update seqinfo set ${c} = '${v}' where pk_seqinfo = $pksi "
		}
	    } else {
		$db eval "update seqinfo set $c = $v where pk_seqinfo = $pksi"
	    }
	}
    }

    $db eval {commit}

    return

}

proc EnregistreLeMac {{titre ""} {desc ""}} {

    global db LNOrdali LSOrdali LNDG SDG ScoreMeth TDesSeqnames TabSF

    # Speed up the bordel
    $db eval {begin transaction}
    
    if {$titre eq ""} {
	set atitre [MacCourant name]
	set adesc  [DescriptionDuMac]
	set ctitre [ClusteringDuMac name]
	set cdesc  ""
	set new 0
    } else {
	set atitre "M[NumeroNewMac] - $titre"
	set adesc  $desc
	set ctitre [ClusteringDuMac name]
	set cdesc  ""
	set new 1
    }

    # Detruit mac a remplacer si besoin est
    if {! $new} {
	DetruitLeMac [MacCourant]
    }

    # C'est parti !
    # Creation du Mac
    # Devient le mac courant
    $db eval {insert into mac values (NULL, $atitre, $adesc)}
    set pkm [$db last_insert_rowid]
    LesDefauts IxMacCourant $pkm
    LesDefauts NmMacCourant $atitre

    VerifSeqs

    # Remplit seqs du mac
    # Remplit features du mac
    set pos 0
    foreach n $LNOrdali s $LSOrdali {
	if {$n eq ""} {continue}

	set sqn [set TDesSeqnames($n)]
	set pksi [$db eval {select pk_seqali from seqali where seqname=$sqn and seq=$s}]
	$db eval {insert into ln_mac_seqali values ($pkm, $pksi, $pos)}

	# remplit features a partir de TabSF
	if {! [info exists TabSF] || [set Lf [array names TabSF "${n},*"]] == {} } {
	    incr pos
	    continue
	}

	foreach e $Lf {
	    lassign [split $e ,] tmp ftype
	    foreach f [set TabSF($e)] {
		DecortiqueUneFeature $f fstart fstop fcolor fscore fnote fcsys
		$db eval {insert into featali values(NULL, $ftype, $fstart, $fstop, $fcolor, $fscore, $fnote, $fcsys)}
		set pkfi [$db last_insert_rowid]
		$db eval {insert into ln_seqali_featali values($pksi,$pkfi)}
	    }
	}
	incr pos
    }

    # Remplit clusters
    $db eval {insert into clustering values(NULL, $pkm, $ctitre, $cdesc,$::ZoneClusterisation)}
    set pkg [$db last_insert_rowid]
    $db eval {insert into ln_mac_clustering values ($pkm,$pkg,$pkg)}
    foreach g $LNDG {
	if {$g eq "bidon"} {continue}
	if {$g eq "grise"} {continue}
	
	set Lix [LesIndexsDesSeqnames [set SDG($g)]]
	if {$g eq "GroupeToutLeMonde"} {set g "all"}
	$db eval {insert into cluster values(NULL, $pkg, $g)}
	set pkc [$db last_insert_rowid]
	set pos 0
	foreach i $Lix {
	    $db eval {insert into ln_seqali_cluster values ($i,$pkc,$pos)}
	    incr pos
	}
    }

    # Remplit colscore
    set Ls [array names ScoreMeth "Cons-*,Edit"]
    foreach e $Ls {
	if {[set ScoreMeth($e)]} {continue}

	lassign [split $e ,] ft edt
	set name $ft
	if {[regexp "Cons-T" $ft]} {
	    set type int
	    set absent -999
	} else {
	    set type float
	    set absent -999.0
	}
	set root [string range $ft 5 end]
	if {[string last "_" $root] != -1} {
	    set root [string range $root 0 [string last _ $ft]-1]
	}
	$db eval {insert into colmeasure values (NULL,$ft,$root)}
	set pk_meas [$db last_insert_rowid]

	$db eval {insert into ln_mac_colmeasure values ($pkm,$pk_meas)}
	if {! [info exists ScoreMeth($ft,ListeGrps)]} {
	    set ScoreMeth($ft,ListeGrps) [list]
	}
	foreach g [set ScoreMeth($ft,ListeGrps)] {
	    set data {}
	    if {$g eq "GroupeToutLeMonde" || $g eq "all"} {
		set owner "all"
	    } else {
		set owner "group_[string range $g 5 end]"
	    }

	    # recupere index colonnes ayant 1 score
	    set Lx {}
	    set Li [array names ScoreMeth ${ft},$g,*]
	    if {$Li == {} } {continue}
	    foreach v $Li {
		lassign [split $v ,] t m i 
		lappend Lx $i
	    }
	    # insere -999. aux colonnes manquantes
	    set c 0
	    foreach i [lsort -integer $Lx] {
		while {$c != $i} {
		    lappend data $absent
		    incr c
		}
		set v $ScoreMeth(${ft},$g,$i)
		lappend data $v
		incr c
	    }
	    set data [join $data ,]
	    $db eval {insert into colscore values(NULL, $pk_meas, $name, $owner, $type, $owner, $data)}
	    set pkc [$db last_insert_rowid]
	    if {$g eq "GroupeToutLeMonde"} {set g all}
	    set pkt [$db eval {select pk_cluster from cluster where name=$g and pk_clustering=$pkm}]
	    $db eval {insert into ln_cluster_colscore values ($pkt,$pkc)}
	}
    }

    # termine !
    $db eval {commit}
    $db eval {vacuum}

    return

}

proc EnregistreVis {Ln quoi {Lo ""}} {

    global db

    $db eval {begin transaction}

    set pk_vue [VueCourante index]
    set pkvo   [VisCourante]
    $db eval {insert into vis values (NULL,$pk_vue, 'tmp', $pkvo)}
    set pk_vis [$db eval {select max(pk_vis) from vis}]
    set Ls [LesIndexsDesSeqs $Ln]
    set Li [$db eval {select pk_seqali from ln_vis_seqali where pk_vis=$pkvo order by pos}]
    switch $quoi {
	"cut" {
	    set Lvis [lor $Li $Ls]
	    set pos 0
	    foreach i $Lvis {
		$db eval {insert into ln_vis_seqali values ($pk_vis,$i,$pos)}
		incr pos
	    }
	    set Lg [LesClusterDeVueClus [VueCourante index] [ClusteringCourant index] index]
	    foreach g $Lg {
		$db eval "delete from ln_seqali_cluster where pk_cluster=$g and pk_seqali in ([join $Ls ,])"
		if {[$db eval {select count(pk_seqali) from ln_seqali_cluster where pk_cluster=$g}] == 0} {
		    $db eval {delete from cluster where pk_cluster=$g}
		}
	    }
	}
	"copy" {}
	"paste" {
	    set Lp [TraiteSequencesAInserer $pkvo $Lo $pk_vue]
	    set pos 0
	    foreach i $Li {
		$db eval {insert into ln_vis_seqali values ($pk_vis,$i,$pos)}
		if {$i eq $Ls} {
		    foreach x $Lp {
			incr pos
			$db eval {insert into ln_vis_seqali values ($pk_vis,$x,$pos)}
		    }
		}
		incr pos
	    }
	    set c [ClusteringCourant index]
	    set g [$db eval {select c.pk_cluster from cluster as c, ln_seqali_cluster as lsc 
	    where lsc.pk_seqali = $Ls 
	    and  lsc.pk_cluster = c.pk_cluster 
	    and c.pk_clustering = $c}]
	    set Li [$db eval {select pk_seqali from ln_seqali_cluster where pk_cluster=$g order by pos}]
	    $db eval {delete from ln_seqali_cluster where pk_cluster=$g}
	    set pos 0
	    foreach i $Li {
		$db eval {insert into ln_seqali_cluster values ($i,$g,$pos)}
		if {$i eq $Ls} {
		    foreach x $Lp {
			incr pos
			$db eval {insert into ln_seqali_cluster values ($x,$g,$pos)}
		    }
		}
		incr pos
	    }
	}
    }
    $db eval {commit}
    
    LesDefauts IxVisCourante $pk_vis

    return

}

proc Enregistrement {acide} {

    global CULSecDir Wobble_[set acide] classes dateheurelancement
    set liste_codons {}
    set nom_fichier  "$acide.csv"
    set fichier [open res/$dateheurelancement/$nom_fichier w]
    puts -nonewline $fichier "codon"
    foreach classe [lsort $classes] {
	puts -nonewline $fichier ";$classe"
    }
    set nbclasses [llength $classes]
    set momo $nbclasses
    foreach indices [lsort [array names Wobble_[set acide]]] {
	set indices_liste [split $indices ","]
	set codon [lindex $indices_liste 0]
	if {$momo == $nbclasses} {
	    puts -nonewline $fichier "\n$codon" 
	    puts -nonewline $fichier ";[set Wobble_[set acide]($indices)]"
	    set momo 1
	} else {
	    puts -nonewline $fichier ";[set Wobble_[set acide]($indices)]"
	    incr momo
	}
    }
    puts -nonewline $fichier "\n"
    close $fichier
    return

}

proc EnrichiAccessToKeepOrNotToKeep {Access} {

    
    global MesAccessInterressants

    if {! [info exists MesAccessInterressants]} {MesAccessInterressants}
    
    if {[info exists MesAccessInterressants($Access)]} {Espionne "Pas Enrichi de $Access";return ""} else {
	Espionne "Enrichi de $Access"
	set MesAccessInterressants($Access) 1; return ""}

}

proc EnrichirEpouvanBlast {Rep} {


	# Recupere l'organisme et le NM à partir des Blast faits sur RefSeqP : EpouvanBlast2.csv en sortie

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EnrichirEpouvanBlast : Start"
	set FichierIn [open "$Rep/EpouvanBlast.csv" "r"]
	set FichierOut [open "$Rep/EpouvanBlastEnriched.csv" "w"]
	set FichierOut2 [open "$Rep/EpouvanBlastEnrichedOnlyWithGoodSpecies.csv" "w"]
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EnrichirEpouvanBlast : Building and executing RS queries"
	set CompteurLus 0
	set CompteurGoodEcrits 0
	set CompteurEcrits 0
	set Trouves 0
	set NonTrouves 0
	while { [gets $FichierIn Ligne]  >=0 } {
			#ScanLaListe $Ligne numero NM Org Entry Acc Expect DB
			ScanLaListe $Ligne DB numero NP XP Expect Identities IndetityPercentage Positive PositivePercentage Score Gaps GapsPercentage DebutQuery FinQuery DebutTarget FinTarget"
			incr CompteurLus
			set FichierDesRequetes [open "/tmp/EnrichirEpouvanBlast$NP.bql" "w"]
			puts $FichierDesRequetes "ID $XP DB REFSEQ"
			puts $FichierDesRequetes "FD OS,DBSOURCE"
			puts $FichierDesRequetes "LM 1"
			puts $FichierDesRequetes "//"
			close $FichierDesRequetes
			set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
		
			exec /biolo/bird/bin/birdql_client.sh "/tmp/EnrichirEpouvanBlast$NP.bql" bird "/tmp/EnrichirEpouvanBlast$NP.res"
			
			file delete $FichierDesRequetes		
			set FichierDesRequetesExecutees [open "/tmp/EnrichirEpouvanBlast$NP.res" "r"]
			#set FichierDesRequetes3 [open "/tmp/NpToCoord$numero.bql3" "w"]
			while { [gets $FichierDesRequetesExecutees Ligne2]  >=0 } {
				if {$Ligne2 != "" } {
					set NMt [string trim [lindex [split $Ligne2 " "] 2]]	
					gets $FichierDesRequetesExecutees Ligne2
					set Organism [string trim [lindex [split $Ligne2 "="] 1]]
					regsub -all -nocase " " $Organism "_" Organism	
					puts $FichierOut "$Ligne $NMt $Organism" 
					incr CompteurEcrits
					if { $Organism == "Drosophilia_melanogaster" || $Organism == "Caenorhabditis_elegans" || $Organism == "Pan troglodytes" ||  $Organism == "Danio_rerio" || $Organism == "Mus_musculus" } {
						puts $FichierOut2 "$Ligne $NMt $Organism" 
						incr CompteurGoodEcrits
					}
					incr Trouves
				 }  else {
					incr NonTrouves
				}
			}
			close $FichierDesRequetesExecutees
			file delete $FichierDesRequetes
	}
	
	close $FichierOut
	close $FichierOut2
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EnrichirEpouvanBlast : Lus : $CompteurLus"
	Espionne "$timestamp|EnrichirEpouvanBlast : Ecrits : $CompteurLus ($Trouves found | $NonTrouves unfound)"
	Espionne "$timestamp|EnrichirEpouvanBlast : dont des 4 organismes: $CompteurGoodEcrits"
	Espionne "End"

}

proc EnrichitUnArbrePhylo {{TreeIn ""} {TreeOut ""} {Quoi "Species Definition"} {DeQui Default}} {


    Wup "Permet d enrichir un fichier sortie de Phylip au format NH en un fichier compatible NHX (New Hampshire eXtented)."
    Wup "Ce format lisible par ATV (viewer d arbre phylo) permet de visualiser d autres infos."
    
    #Pour Quoi on peut prendre:
    #Species
    #Definition
    #Categories
    #EC       
    #TaxID    
    #Sachant que Definition Categories et EC sont en concurrences

    if {$TreeIn  == ""} {
	set TreeIn  "[RepertoireDuGenome]/phylos/ARP47"
    }
    if {$TreeOut == ""} {
	set TreeOut "[RepertoireDuGenome]/phylos/ARP49"
    }

    set F [open "$TreeIn"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+}  $Ligne]} {continue}
	set  i        0
	set tmp       ""
	set DF        ""
	set LigneTmp  ""
	set AddedInfo ""

	while {[regexp -start $i -indices -nocase {([a-z0-9_]{5,}):\-*[0-9]+} $Ligne tmp DF]} {
	    #1-0 On recupere l access
	    #########################
	    set Acc [string range $Ligne [lindex $DF 0] [lindex $DF 1]]
	    
	    set OldTaille [string length $Ligne]
	    set i         [lindex $DF 1]
	    set tmp       ""
	    set DF        ""
	    set Def       ""
	    set Dist      ""

	    #2-0 On recupere la distance
	    ############################
	    set expr "$Acc\\:(\\\-*\[0-9\]+\\\.\[a-z0-9-\]+)"
	    regexp -all -indices -nocase $expr $Ligne tmp DF

	    set Dist [string range $Ligne [lindex $DF 0] [lindex $DF 1]]
	    set i    [lindex $DF 1]

	    #3-0 On va chercher les informations supplementaires de nos access
	    ##################################################################
	    set AddedInfo [LesInfosSupplementairesPourATV [string toupper $Acc] $Dist $Quoi $DeQui]

	    #4-0 On ajoute les informations supplementaires dans la ligne
	    #############################################################
	    set ToSearch "${Acc}:${Dist}"
	    regsub -nocase "$ToSearch" $Ligne "${AddedInfo}" Ligne
	  
	    #5-0 On repositionne le curseur au bon endroit dans la ligne
	    ############################################################
	    set NewTaille [string length $Ligne]
	    set i [expr $i + ($NewTaille - $OldTaille) + 1]

	    set tmp  ""
	    set DF   ""
	}
	lappend LesLignes $Ligne
	#Espionne "$Ligne"
    }
    close $F

    AppendAuFichier $TreeOut [join $LesLignes "\n"]

    return ""

}

proc EnrichrWebService {Lids} {

    package require json

    set baseUrl "http://amp.pharm.mssm.edu/"

    # add list
    set url "$baseUrl/Enrichr/addList"
    set sid [join $Lids "\n"]
    set query [::http::formatQuery list $sid]
    set ok [HttpCopy $url result $query]
    if {! $ok} {
	puts "Error submitting list to Enrichr!"
	return ""
    }
    # result is json
    set result [join $result " "]
    set dict [::json::json2dict $result]
    set jobid [dict get $result userListId]

    # check job
    set url "$baseUrl/Enrichr/enrich?userListId=$jobid&background=GO_Biological_Process_2015"
    set ok [HttpCopy $url result]
    if {! ok} {
	puts "Error getting Enrichr results !"
	return ""
    }

}

proc EnsoleilleLaSelection {Selection} {

    global GalerieCourante
    global ExpoCourante

    set ExpoCourante [NomDe expo]
    set GalerieCourante $ExpoCourante[NomDe galerie]

    CreeGalerie $GalerieCourante

    foreach Ligne [split $Selection "\n"] {
	set Access [lindex [split [string trim $Ligne] " "] 0]
	EtudieAccess $Access
    }

    ClosGalerieCourante
    ClosExpoCourante

}

proc EntammePourMeltingTemp {Seq TmVoulu {TmSiFinGC ""}} {

    # TmVoulu peut contenir les deux
    if {[regexp {([0-9\.]+) +([0-9\.]+)} $TmVoulu Match TmATGC TmGC]} {
	set TmVoulu   $TmATGC
	set TmSiFinGC $TmGC
    }

    if {$TmSiFinGC==""} { set TmSiFinGC $TmVoulu }

    set Seq [string toupper $Seq]

    set Entamme ""
    foreach Base [split $Seq ""] {
	append Entamme $Base
	if { ! [regexp {[ATGC]} $Base]} { continue }
	set TM [TMDeLaSequence $Entamme]
	if {$TM >= $TmVoulu} { break }
	if {$TM >= $TmSiFinGC && ($Base=="G" || $Base=="C")} { break }
    }
    return $Entamme

}

proc EnterBox {K X Y} {

    global CouleurEnEntree oldText

    set Id [$K find withtag current]
    set CouleurEnEntree [lindex [$K itemconfig $Id -fill] 4]
    $K itemconfigure $Id -fill [Fard $K $X $Y]
#   ShowBox $K $X $Y "Enter"

}

proc Enterre {Nom} {


    set Valeur [ExtraitInfo $Nom "Enterre"]
    if { $Valeur == "" } { return 0 }
    if {[regexp -nocase -- "oui" $Valeur]} {
	return 1
    } else {
	return 0
    }   

}

proc EnterrerLesAncetresGO {LesGO} {

    set LesGOTmp $LesGO;set LesGOExclus {}

    foreach GO $LesGOTmp {
	set GO [string toupper $GO]
	if {[info exists TabDejaVu($GO)]} {continue}
	if {0 <= [lsearch -exact $LesGOExclus $GO]} {continue}
	foreach Type [GODB GO $GO LesTypes] {
	    set TousLesAncetres [TousLesAncetresGO $Type $GO]
	    foreach GOBis $LesGOTmp {
		if {$GO == $GOBis || 0 <= [lsearch -exact $LesGOExclus $GOBis]} {continue}
		foreach Ancetre $TousLesAncetres {
		    if {$GOBis == $Ancetre} {
			lappend LesGOExclus $GOBis
			set     TabDejaVu($GOBis) 1 
			break
		    }
		}
	    }
	}
    }
    return [ListsComplement $LesGO $LesGOExclus]

}

proc EnterrerLesAncetresOntologiques {LesGO} {

    set LesGOTmp $LesGO;set LesGOExclus {}
    foreach GO $LesGOTmp {
	set GO [string toupper $GO]
	if {0 <= [lsearch -exact $LesGOExclus $GO]} {continue}

	set Type            [Onto $GO Type]
	set TousLesAncetres [TousLesAncetresOntologiques $Type $GO]
	
	foreach GOBis $LesGOTmp {
	    if {$GO == $GOBis || 0 <= [lsearch -exact $LesGOExclus $GOBis]} {continue}
	    foreach Ancetre $TousLesAncetres {
		if {$GOBis == $Ancetre} {
		    lappend LesGOExclus $GOBis
		    break
		}
	    }
	}
    }
    return [ListsComplement $LesGO $LesGOExclus]

}

proc EnteteARPAnno_ResultHTML {Texte {AvecOuSansRefresh SansRefresh} {URL ""}} {


    Wup "Permet d avoir une entete HTML jolie pour la page de resultats"
    
    #regsub -all "\n" $Texte "
" Texte

    set     LeTexte {}
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""

    #lappend LeTexte ""
    lappend LeTexte ""
    if {$AvecOuSansRefresh == "AvecRefresh"} {
	if {$URL != ""} {
	    lappend LeTexte ""
	} else {
	    lappend LeTexte ""
	}
    }
    lappend LeTexte ""
    lappend LeTexte ""

    lappend LeTexte ""
    #Banniere IGBMC ou BIPS
    #######################
    if {[regexp -nocase "bips" [WebServer_Address]]} {
	#lappend LeTexte ""
	lappend LeTexte ""
	lappend LeTexte ""
	lappend LeTexte "   "
	
	lappend LeTexte ""
	lappend LeTexte ""
    }
    lappend LeTexte "   "
    lappend LeTexte "      "
    lappend LeTexte "         "
    lappend LeTexte "      "
    lappend LeTexte "      "
    lappend LeTexte "         "
    lappend LeTexte "      "
    lappend LeTexte "      "
    #lappend LeTexte "         "
    lappend LeTexte "         "
    lappend LeTexte "      "
    lappend LeTexte "      "
    lappend LeTexte "         "
    #lappend LeTexte "         "
    lappend LeTexte "      "
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte "" 
    lappend LeTexte ""
    lappend LeTexte "
ARPAnno
Go back to ARPAnno
$Texte
$Texte
Help and Supplementary information
Go back to ARPAnno
"
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte ""
    lappend LeTexte "
"
    lappend LeTexte "
"
    lappend LeTexte ""
    lappend LeTexte "Muller et al (2005) Mol. Biol. Cell. doi: 10.1091/mbc.E05-06-0508"
    lappend LeTexte ""
    lappend LeTexte "
"
    lappend LeTexte "
"
    lappend LeTexte "
"

    #lappend LeTexte "   "
    lappend LeTexte "   
"
    lappend LeTexte "   If you have any problems or questions, please, feel free to contact us at jean.muller@igbmc.u-strasbg.fr"
    lappend LeTexte "   
"
    lappend LeTexte ""
    lappend LeTexte ""

    return [join $LeTexte "\n"]

}

proc EnteteDesPagesWebDesICDS {Title} {

    set Doctype   [Html_Doctype]
    set HtmlBegin [Html_BeginHtmlManu "white" "Courier"]
    set Head      [Html_Header $Title]
    set DebutBody [Html_BeginBody]
    lappend Entete $Doctype
    lappend Entete $HtmlBegin
    lappend Entete $Head
    lappend Entete $DebutBody
    set Entete [join $Entete "\n"]
    return $Entete

}

proc EnteteDuFichierTFA {Fichier {Quoi all}} {

    return [EnteteDuTexteTFA [ContenuDuFichier $Fichier] $Quoi]

}

proc EnteteDuTexteTFA {Texte {Quoi all}} {

    set Entete ""
    foreach Ligne [split $Texte "\n"] {
	if {[regexp ">" $Ligne]} { set Entete $Ligne ; break }
    }
    if {[string tolower $Quoi]=="all"} { return $Entete }

    regsub ">" $Entete "" Entete
    set Access ""
    scan $Entete "%s" Access
    return $Access

}

proc Entier {} {

    global TokCourant
    
    set Courant ""
    if {[regexp {[0-9]} $TokCourant]} {
	set Courant $TokCourant
    }
    if {$Courant==""} {    
	return "EntierNonValideCarNonNumeriqueEnDebut"
    }
    while {[regexp {[0-9]} [Tok]]} {
	append Courant $TokCourant
    }
    return $Courant

}

proc Entoure {Boite K} {

    global oldCouleurOutLine
    global oldLargeurOutLine

    if {[regexp "rond" $K]} { return "" }

    set Id [$K find withtag $Boite]

    set oldCouleurOutLine($K,$Boite) [$K itemcget $Id -outline] 
    set oldLargeurOutLine($K,$Boite) [$K itemcget $Id -width] 
    $K itemconfigure $Id -outline "pink" -width 8

    return [$K itemcget $Id -outline]

}

proc Entre {{Defo ""}} {

    global RetourEntre
    
    global EntreToujoursDefaut
    
    if {[info exists EntreToujoursDefaut] && $EntreToujoursDefaut} { return $Defo } 
    
    set w [NomDe fenetre]
    toplevel $w
    wm title $w "To validate     or  "
    wm iconname $w ""
    wm geometry $w +300+300
    
    entry    $w.e -width 80 -borderwidth 10 -background red -foreground white -font {Courier 14}
    if { $Defo != "" } { $w.e  insert 0 $Defo }
    pack     $w.e -expand 1 -fill x
    focus    $w.e
    bind     $w.e  "set RetourEntre($w) \[$w.e get\]"
    bind     $w.e    "set RetourEntre($w) \[$w.e get\]"
    tkwait variable RetourEntre($w)
    destroy $w
    set Retour [set RetourEntre($w)]
    unset RetourEntre($w)
    return $Retour

}

proc Entre0Et2PI {Angle} {

    set PI 3.14159
    while {$Angle < 0} { set Angle [expr $Angle + 2*$PI] }
    while {$Angle >= 2*$PI} { set Angle [expr $Angle - 2*$PI] }
    return $Angle

}

proc Entre0Et360 {Angle} {

    while {$Angle < 0} { set Angle [expr $Angle + 360] }
    while {$Angle >= 360} { set Angle [expr $Angle - 360] }
    return $Angle

}

proc EntreDansCoeur {K X Y {Propagate ""}} {


    if {$Propagate==""} { set Propagate "Propagate" }
    if {[regexp {ShowAlso_(.+)} $Propagate Match IdTag]} {
	set Id [$K find withtag $IdTag]
	set SmallBox 1
    } else {
	set Id [$K find withtag current]
	set SmallBox 0
    }
    set Moi [lindex [$K gettags $Id] 0]
    set Toi [lindex [$K gettags $Id] 1]
#rR    set Texte "$Moi $Toi"
    set LesTags [$K gettags $Id]
    set C [lindex $LesTags end]
    if {$C=="current"} {
	set X [lindex $LesTags end-2]
	set Y [lindex $LesTags end-1]
    } else {
	set X [lindex $LesTags end-1]
	set Y [lindex $LesTags end]
    }
    if { ! [regexp {[0-9.]+} "$X$Y"] } { return "" }
    set Texte [join $LesTags " "]
    if {$SmallBox} {
	set R [$K create oval [expr $X-10] [expr $Y-10] [expr $X+10] [expr $Y+10] -outline "black"]
	GraphesEnStock "HighlightId" $K $R
#	append Texte " _$R"
    }
    regsub ".canvas" $K ".message" M
    catch {destroy $M}
    message $M -borderwidth 3 -font {Courier 12} -relief raise -width 300 -text $Texte -background "lightyellow" -foreground "black"
    set AncreH ""
    set AncreV "s"
    if {$Y<500} { set AncreV "n" }

    if {$X<128} { set AncreH "e" }
    if {$X>384} { set AncreH "w" }
    set Ancre "${AncreV}${AncreH}"
    set XT [expr $X+30]
    set YT [Maxi 100 [expr $Y-30]]
    place $M -x [expr $X+10] -y [Maxi 100 [expr $Y-10]] -anchor $Ancre
    $K create text $XT $YT -text $Texte -fill red -tags "MessageAffiche"
    
    if {[string equal -nocase $Propagate "Propagate"]} {
	foreach KK [GraphesEnStock] {
	    if {$KK==$K} { continue }
	    EntreDansCoeur $KK "" "" "ShowAlso_$Moi"
	}
    }

    return $M

}

proc EntreDansSeq {K X Y} {

    global TitreOrigine
    set Id [$K find withtag current]
    set NomSeq [lindex [$K gettags $Id] 1]
    if {! [info exists TitreOrigine($K)] } {
	set TitreOrigine($K) [wm title [winfo toplevel $K]]
    }
    wm title [winfo toplevel $K] "$NomSeq [$K canvasx $X]"

}

proc EntreDeux {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} {


    Wup "Permet une selection entre plusieurs choix"

    return [lindex [LesPEtA $Liste $ListeDeTextes $Invite] 0]

}

proc EntreMinEtMax {Angle m M} {

    set D [expr $M-$m]
    while {$Angle < $m} { set Angle [expr $Angle + $D] }
    while {$Angle >= $M} { set Angle [expr $Angle - $D] }
    return $Angle

}

proc EntreTexte {{Defo ""} {BoutonsEnPlus ""} {FichierOriginePourInforme ""}} {

    global RetourEntreTexte
    global FenetreInfoOuverte
    global PolicePourEntreTexte

    if {[PourWscope]} {
	set Maniere $BoutonsEnPlus
	return [AfficheVariable $Defo $Maniere $FichierOriginePourInforme]
    }

    set w [NomDe fenetre]
    toplevel $w
    wm title $w "You can edit this text ... "
    wm iconname $w "Edit"
    
    set LesLignesDuTexte [split $Defo "\n"]
    set PremiereLigne [lindex $LesLignesDuTexte 0]
    if {[regexp {^Nom\: } $PremiereLigne]} {
	scan $PremiereLigne "%s %s" Bidon Nom
	set FenetreInfoOuverte($Nom) $w
    }
    
    set Hauteur [Maxi 10 [Mini 30 [llength $LesLignesDuTexte]]]
    set Largeur 80
    foreach Ligne $LesLignesDuTexte {
	set Largeur [Maxi $Largeur [string length $Ligne]]
    }
    set Largeur [Mini $Largeur 180]

    

    set Police 12
    if {[info exists PolicePourEntretexte]} { set Police $PolicePourEntreTexte }
    text  $w.text -wrap none -relief sunken -bd 2  -font [list Courier $Police]  -xscrollcommand "$w.xscroll set"  -yscrollcommand "$w.yscroll set"  -background "lightgreen"  -width $Largeur -height $Hauteur
          $w.text insert 0.0 $Defo
    focus $w.text
    
    frame  $w.buttons
    pack   $w.buttons -side bottom -fill x -pady 2m
    
    button $w.buttons.dismiss -background red -text "Dismiss"
      bind $w.buttons.dismiss <1> "set RetourEntreTexte($w) \"\""
      pack $w.buttons.dismiss -side left -expand 1
    button $w.buttons.saveas -text "Save All/ Sel."
      bind $w.buttons.saveas <1> "SaveAs \[$w.text get 1.0 end\]"
      bind $w.buttons.saveas <2> "SaveAs \[$w.text get sel.first sel.last\]"
      pack $w.buttons.saveas -side left -expand 1
    button $w.buttons.search -text "Next/Top/New" -background yellow -foreground black
      bind $w.buttons.search <1> "LocaText $w.text Next"
      bind $w.buttons.search <2> "LocaText $w.text Top" 
      bind $w.buttons.search <3> "LocaText $w.text New"
      pack $w.buttons.search -side left -expand 1
    button $w.buttons.aspect -text "Font"
      bind $w.buttons.aspect <1> "PolicePourEntreTexte Ask $w"
      pack $w.buttons.aspect -side left -expand 1
    button $w.buttons.browse -text "Replace/Append/Choose\n(with other file)"
      bind $w.buttons.browse <1> "ButineEtRemplace $w.text"
      bind $w.buttons.browse <2> "ButineEtAjoute $w.text"
      bind $w.buttons.browse <3> "ChoisiEtAjouteChampsInfo $w.text"
      pack $w.buttons.browse -side left -expand 1
    button $w.buttons.accept -text "Accept All / Selection" -background green -foreground black
      bind $w.buttons.accept <1> "set RetourEntreTexte($w) \[$w.text get 1.0 end\]"
      bind $w.buttons.accept <2> "set RetourEntreTexte($w) \[$w.text get sel.first sel.last\]"
      pack $w.buttons.accept -side left -expand 1
    if {$BoutonsEnPlus!=""} {
	set I 0
	foreach {T C} $BoutonsEnPlus { 
	    incr I
	    button $w.buttons.plus$I -text $T -background orange -foreground black
	      bind $w.buttons.plus$I <1> $C
	      pack $w.buttons.plus$I -side left -expand 1
	}
    }
    
    scrollbar $w.xscroll -command "$w.text xview" -orient "horizontal"
         pack $w.xscroll -side bottom -fill x
    scrollbar $w.yscroll -command "$w.text yview"
         pack $w.yscroll -side right -fill y
    
    pack $w.text -expand yes -fill both

    tkwait variable RetourEntreTexte($w)
    if {[info exists RetourEntreTexte($w)]} {
	set Retour [set RetourEntreTexte($w)]
	unset RetourEntreTexte($w)
    } else {
	set Retour ""
    }
    destroy $w
    regsub {\n$} $Retour "" Retour
    return $Retour

}

proc EntreeNCBI {} {

    #rentre la ligne obtenue sur le site NCBI
    #voir GiToAccessWithBird qui fait la meme chose
    set long [llength [InterrogeListTau ListOf GI]]
    set GIs [join [InterrogeListTau ListOf GI] " OR "]
    #OR set GIs [join [InterrogeListTauControl ListOf GI] " OR "]
    Espionne "$GIs"
    Espionne "$long"

}

proc Entropy {LesNbDesClusters} {

    set NbTot 0
    foreach Nb $LesNbDesClusters {set NbTot [expr $NbTot + $Nb]}

    set Entropy 0
    foreach NbDuCluster $LesNbDesClusters {
	if {$NbDuCluster == 0} {continue}
	set Pi     [expr $NbDuCluster * 1.0 / $NbTot]
	set PiLnPi [expr -1 * $Pi * log($Pi)/log(2)]
	set Entropy [expr $Entropy + $PiLnPi]
    }
    return $Entropy

}

proc EnvVars {} {

    global env
    #rR attention cet env est celui du cafedessciences et pas du cgi ... :'(
    foreach {K V} [array get env] {
	lappend KVs "$K=$V="
    }
    set Text [join $KVs "\n"]
    return [Html_DuTexteTelQuel $Text]

}

proc Environ {{Comment ""} {Quoi ""}} {

    if {$Comment==""} { set Comment "Short" }
    if {$Comment=="Short"} {
	set Quoi "WithoutEnv"
	set Comment "GetIt"
    }
    return [AfficheLEnvironnementDeGscope $Comment $Quoi] 

}

proc EnvoieDump {Quoi {Valeur ""}} {

    global CanalDuDump

    if {$Quoi == "CloseFile"} {
	if {[info exists CanalDuDump]} {
	    close $CanalDuDump
	    unset CanalDuDump
	}
	return
    }
    if {$Quoi == "Canal"} {
	set CanalDuDump $Valeur
	return $CanalDuDump
    }
    if {$Quoi == "OpenFile"} {
	set CanalDuDump [open $Valeur w]
	return $CanalDuDump
    }

    if {![info exists CanalDuDump]} {set CanalDuDump stdout}
    if {$Quoi == "Retourne"} {
	set PutOuLap "lappend"
	set CanalDuDump "Retour"
    } else {
	set PutOuLap "puts"
    }

    $PutOuLap $CanalDuDump "<$Quoi>"
    $PutOuLap $CanalDuDump "$Valeur"
    $PutOuLap $CanalDuDump ""

    if {$Quoi == "Retourne"} {
	return [join $Retour "\n"]
    } else {
	return
    }

}

proc EnvoieLesObjets {} {

    if {$::pgl(GLMode) eq "select"} {
	MakeOpenglSelection
    } else {
	foreach i $::StrucAVoir {
	    set nom [DonneIdDeAccessPDB $i]
	    $nom display
	}
    }

    return

}

proc EnvoieLesObjets2 {} {

    global Ltrig Lnorm TSlist Vlist

    if {0} {
	if {[info exists Vlist]} {
	    glCallList $Vlist
	} else {
	    set Vlist [glGenLists 1]
	    glNewList $Vlist GL_COMPILE
	    foreach t $Ltrig n $Lnorm {
		glBegin GL_LINES
		glColor4f 0.5 0.5 0.9 1.0
		TraceTriangle {*}$t $n $n $n
		glEnd
	    }
	    glEndList
	    glCallList $Vlist
	}
    } else {
	if {[info exists TSlist]} {
	    glCallList $TSlist
	} else {
	    set TSlist [glGenLists 1]
	    glNewList $TSlist GL_COMPILE
	    if {[info exists ::FBidon]} {
		glPushMatrix
		set Lball [list  [list 0.0 0.0 0.0 0.3]  [list 2.0 0.0 0.0 0.6]  [list 0.0 2.0 0.0 1.0]  [list 0.0 0.0 2.0 1.5]]
		set Lcyl [list 0.1 0.3 2.0 12 1]
		set Laxe [list 0  [list  90. 0.0 1.0 0.0]  [list -90. 1.0 0.0 0.0]  [list   0. 0.0 0.0 1.0]]
		set Lcol [list  [list 1.0 1.0 1.0]  [list 1.0 0.0 0.0]  [list 0.0 0.6 0.0]  [list 0.0 0.0 1.0] ]

		set QObj [gluNewQuadric]
		gluQuadricDrawStyle $QObj GLU_FILL
		gluQuadricNormals   $QObj GLU_SMOOTH
		foreach v $Lball c $Lcol a $Laxe {
		    lassign $v x y z r
		    lappend c 1.0
		    glMaterialfv GL_FRONT GL_SPECULAR {1.0 1.0 1.0 1.0}
		    glMaterialfv GL_FRONT GL_SHININESS 110.
		    glMaterialfv GL_FRONT GL_EMISSION {0. 0. 0. 1.}
		    glMaterialfv GL_FRONT GL_AMBIENT   $c
		    glMaterialfv GL_FRONT GL_DIFFUSE   $c
		    
		    glPushMatrix
		    glTranslatef $x $y $z
		    glColor4fv $c
		    gluSphere $QObj $r 16 16
		    glPopMatrix
		    
		    if {$a != 0} {
			glPushMatrix
			glRotatef {*}$a
			glColor4f 1.0 1.0 1.0 1.0
			gluCylinder $QObj {*}$Lcyl
			glPopMatrix
		    }
		}
		gluDeleteQuadric $QObj		
		#glPopMatrix
	    }
	    
	    #
	    # Surface 
	    #

	    #glDisable GL_DEPTH_TEST
	    glEnable GL_BLEND
	    glBlendFunc GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA
	    glDisable GL_LIGHTING	    	    
	    #glDisable GL_COLOR_MATERIAL

	    #glPushMatrix
	    foreach t $Ltrig {n n n} $Lnorm {
		lassign $t v1 v2 v3
		glBegin GL_TRIANGLES
		glColor4f 0.5 0.5 0.9 0.2
		glNormal3fv $n
		glVertex3fv $v1
		glNormal3fv $n
		glVertex3fv $v2
		glNormal3fv $n
		glVertex3fv $v3
		glEnd
	    }

	    if {0} {
		#glEnable GL_DEPTH_TEST
		#glBlendFunc GL_SRC_ALPHA GL_ZERO
		#glClearDepth 1.0
		#glBlendFunc GL_SRC_ALPHA GL_ONE
		#glDisable GL_COLOR_MATERIAL
		glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE {0.0 0.0 0.0 0.0}
		glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR {1.0 1.0 1.0 1.0}
		glMaterialfv GL_FRONT GL_SHININESS 110.
		glEnable GL_LIGHTING	    	    
		glDepthFunc GL_EQUAL
		#glEnable GL_DEPTH_TEST
		
		foreach t $Ltrig {n n n} $Lnorm {
		    lassign $t v1 v2 v3
		    glBegin GL_TRIANGLES
		    glColor4f 0.5 0.5 0.9 0.1
		    glNormal3fv $n
		    glVertex3fv $v1
		    glNormal3fv $n
		    glVertex3fv $v2
		    glNormal3fv $n
		    glVertex3fv $v3
		    glEnd
		}
		glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE {1.0 1.0 1.0 1.0}
		glDepthFunc GL_LEQUAL
		glEnable GL_COLOR_MATERIAL
	    }

	    glEnable GL_LIGHTING
	    glDisable GL_BLEND

	    glPopMatrix
	    glEndList

	    glCallList $TSlist
	}
    }
    
    return

}

proc EnvoieLesObjets3 {} {

    global Ltrig Lnorm TSlist Vlist OrdEtcDir

    if {[info exists TSlist]} {
	glCallList $TSlist
	
	return
    }
    
    set TSlist [glGenLists 1]
    glNewList $TSlist GL_COMPILE
    
    set Lball [list  [list 0.0 0.0 0.0 0.3]  [list 2.0 0.0 0.0 0.6]  [list 0.0 2.0 0.0 1.0]  [list 0.0 0.0 2.0 1.5]]
    set Lcyl [list 0.1 0.3 2.0 12 1]
    set Laxe [list 0  [list  90. 0.0 1.0 0.0]  [list -90. 1.0 0.0 0.0]  [list   0. 0.0 0.0 1.0]]
    set Lcol [list  [list 1.0 1.0 1.0]  [list 1.0 0.0 0.0]  [list 0.0 0.6 0.0]  [list 0.0 0.0 1.0] ]
    # Trace les boules
    if {1} {
	set QObj [gluNewQuadric]
	gluQuadricDrawStyle $QObj GLU_FILL
	gluQuadricNormals   $QObj GLU_SMOOTH
	foreach v $Lball c $Lcol a $Laxe {
	    lassign $v x y z r
	    lappend c 1.0
	    glMaterialfv GL_FRONT GL_SPECULAR {1.0 1.0 1.0 1.0}
	    glMaterialfv GL_FRONT GL_SHININESS 110.
	    glMaterialfv GL_FRONT GL_EMISSION {0. 0. 0. 1.}
	    glMaterialfv GL_FRONT GL_AMBIENT   $c
	    glMaterialfv GL_FRONT GL_DIFFUSE   $c
	    
	    glPushMatrix
	    glTranslatef $x $y $z
	    glColor4fv $c
	    gluSphere $QObj $r 16 16
	    glPopMatrix
	    
	    if {$a != 0} {
		glPushMatrix
		glRotatef {*}$a
		glColor4f 1.0 1.0 1.0 1.0
		gluCylinder $QObj {*}$Lcyl
		glPopMatrix
	    }
	}
	gluDeleteQuadric $QObj		
    }

    if {0} {
	set col [list 0.5 0.5 0.8 1.0]
	foreach t $Ltrig {n1 n2 n3} $Lnorm {
	    DrawTrigNorm $t $n1 $n2 $n3 $col
	}
    } else {
	
	#
	# Surface 
	#

	#glDisable GL_LIGHTING
	#glDisable GL_COLOR_MATERIAL
	#glDisable GL_LIGHT0

	glEnable GL_CULL_FACE
	glCullFace GL_BACK
	glEnable GL_BLEND
	glBlendFunc GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA
	glPolygonMode GL_FRONT_AND_BACK GL_FILL
	glHint GL_PERSPECTIVE_CORRECTION_HINT GL_NICEST
	glEnable GL_TEXTURE_2D
	
	#set FileTex "test.bmp"
	#set FileTex "gold.jpg"
	#set FileTex "glass.jpg"
	set FileTex [file join $OrdEtcDir "fond.png"]
	set phImg [image create photo -file $FileTex]
	set imgH  [image height $phImg]
	set imgW  [image width $phImg]
        set imgData [tcl3dVectorFromPhoto $phImg 1]
        image delete $phImg
	set latex [tcl3dVector GLuint 1]
	glGenTextures 1 $latex

	glBindTexture GL_TEXTURE_2D [$latex get 0]
	gluBuild2DMipmaps GL_TEXTURE_2D $::GL_ALPHA $imgW $imgH $::GL_ALPHA GL_UNSIGNED_BYTE $imgData
	$imgData delete
	#glTexImage2D GL_TEXTURE_2D 0 $::GL_ALPHA $imgW $imgH 0 $::GL_ALPHA GL_UNSIGNED_BYTE $imgData

	glEnable GL_TEXTURE_GEN_S
	glEnable GL_TEXTURE_GEN_T
	glTexEnvi GL_TEXTURE_ENV GL_TEXTURE_ENV_MODE $::GL_REPLACE

	glTexParameteri GL_TEXTURE_2D GL_TEXTURE_MIN_FILTER $::GL_LINEAR
	glTexParameteri GL_TEXTURE_2D GL_TEXTURE_MAG_FILTER $::GL_LINEAR
	glTexParameteri GL_TEXTURE_2D GL_TEXTURE_WRAP_S $::GL_REPEAT
	glTexParameteri GL_TEXTURE_2D GL_TEXTURE_WRAP_T $::GL_REPEAT
	
	#glTexGenfv GL_S GL_EYE_PLANE {1.0 0.0 0.0}
	#glTexGenfv GL_T GL_EYE_PLANE {0.0 0.0 1.0}
	glTexGeni  GL_S GL_TEXTURE_GEN_MODE $::GL_SPHERE_MAP
	glTexGeni  GL_T GL_TEXTURE_GEN_MODE $::GL_SPHERE_MAP
	
	#glMaterialfv GL_BACK GL_SPECULAR {0.0 0.0 0.0 1.0}
	glLightModelfv GL_LIGHT_MODEL_TWO_SIDE 0.0
	glLightModeli  GL_LIGHT_MODEL_COLOR_CONTROL $::GL_SEPARATE_SPECULAR_COLOR
	#glEnable GL_ALPHA_TEST
	#glAlphaFunc GL_GREATER 0
	
	glColor4f 0.2 0.2 0.05 0.05
	if {1} {
	    foreach t $Ltrig {n1 n2 n3} $Lnorm {
		lassign $t v1 v2 v3
		glBegin GL_TRIANGLES
		glNormal3fv $n1
		glVertex3fv $v1
		glNormal3fv $n2
		glVertex3fv $v2
		glNormal3fv $n3
		glVertex3fv $v3
		glEnd
	    }
	} else {
	    glPushMatrix 
	    glTranslatef 0.0 0.0 -10.0
	    glutSolidTeapot 2.0
	    glPopMatrix
	}
	
	glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR {1.0 1.0 1.0 1.0}
	glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE {1.0 1.0 1.0 1.0}
	glLightModelfv GL_LIGHT_MODEL_TWO_SIDE 1.0
	#glEnable GL_COLOR_MATERIAL
	glLightModeli  GL_LIGHT_MODEL_COLOR_CONTROL $::GL_SINGLE_COLOR
	
	glDisable GL_BLEND
	glDisable GL_TEXTURE_GEN_S
	glDisable GL_TEXTURE_GEN_T
	glDisable GL_TEXTURE_2D
	glDisable GL_CULL_FACE
	#glEnable GL_LIGHTING
	#glEnable GL_LIGHT0
    }

    #glPopMatrix
    glEndList
	
    glCallList $TSlist

    return

}

proc EnvoieLesObjets4 {} {

    global tRNAlist Lpts pgl

    if {[info exists tRNAlist]} {
	glCallList $tRNAlist
	return
    }

    set tRNAlist [glGenLists 1]
    glNewList $tRNAlist GL_COMPILE_AND_EXECUTE

    set QObj [gluNewQuadric]
    gluQuadricDrawStyle $QObj GLU_FILL
    gluQuadricNormals   $QObj GLU_SMOOTH
    gluQuadricTexture   $QObj GL_TRUE

    set col [list 1.0 0.3 0.6 1.0]
    set p0 [lindex $Lpts 0]
    set Rad 1.0
    foreach pt [lrange $Lpts 1 end] {
	TraceCylindre "" $QObj $p0 $pt $col $col $Rad $Rad
	glPushMatrix
	glTranslatef {*}$p0
	glColor4fv $col
	gluSphere $QObj 1.0 32 32
	glPopMatrix
	set p0 $pt
    }
    glPushMatrix
    glTranslatef {*}$pt
    glColor4fv $col
    gluSphere $QObj 1.0 16 16
    glPopMatrix

    gluDeleteQuadric $QObj
    
    glEndList

    return

}

proc EnvoieLesObjets5 {} {

    global ptlist Lpts Llbl Lnrm pgl

    if {[info exists ptlist]} {
	glCallList $ptlist
	#AfficheLabels $Lpts $Llbl
	return
    }

    set ptlist [glGenLists 1]
    glNewList $ptlist GL_COMPILE_AND_EXECUTE

    puts "Lpts [llength $Lpts]"
    foreach {p1 p2 p3} $Lpts {n1 n2 n3} $Lnrm {
	glBegin GL_LINES
	glVertex3fv $p1
	glVertex3fv $p2
	glVertex3fv $p2
	glVertex3fv $p3
	glVertex3fv $p3
	glVertex3fv $p1

	glVertex3fv $p1
	glVertex3fv $n1
	glVertex3fv $p2
	glVertex3fv $n2
	glVertex3fv $p3
	glVertex3fv $n3
	glEnd
    }
    glEndList

    #AfficheLabels $Lpts $Llbl

    return

}

proc EnvoieLesObjetsTmp {} {

    return

}

proc EnvoiePrf3DDisplay {} {

    global FrmPref
    global TmpDef

    set td $FrmPref
    $td configure -text "3D Display"

    label $td.lcv -text "Default background Color :"
    button $td.bco -background [set TmpDef(CoulVariable)] -command [list ChangeCouleurVariable $td.bco]

    label $td.ps -text "Precompute Surface :"
    radiobutton $td.ysf -text "yes"  -highlightthickness 0  -relief flat  -variable TmpDef(PrecomputeSrf)  -value 1
    radiobutton $td.nsf -text "no"  -highlightthickness 0  -relief flat  -variable TmpDef(PrecomputeSrf)  -value 0

    label $td.lramp -text "Ramp Color :"
    frame $td.framp
    set i 0
    foreach c [GammeDeCouleursRVB 10] {
	set w "$td.framp.bcol$i"
	button $w -bg $c  -width 1 -height 1  -command [list ChangeCouleurDeLaGamme $w]
	grid $w -row 0 -column $i -ipadx 0
	incr i
    }
    

    grid $td.lcv   -row 0 -column 0 -sticky w -pady 10
    grid $td.bco   -row 0 -column 1 -sticky w
    grid $td.ps    -row 1 -column 0 -sticky w -pady 10
    grid $td.ysf   -row 1 -column 1 -sticky w
    grid $td.nsf   -row 1 -column 2 -sticky w
    grid $td.lramp -row 2 -column 0 -sticky w -pady {10 1}
    grid $td.framp -row 3 -column 0 -columnspan 2 -sticky ew

    return

}

proc EnvoiePrfConservation {} {

    global TypeText CoulTmp TypeCons FrmPref TmpDef

    set pcns $FrmPref
    $pcns configure -text Conservation

    grid columnconfig $pcns {1 2} -weight 1

    label $pcns.lbl -text "Click on the buttons to change the colors assigned\nto the different conservation types" -anchor w -justify left
    set i 0
    foreach Type [lrange $TypeCons 0 2] {
	incr i
	lassign [set CoulTmp($Type)] fg bg
	label  $pcns.l$Type -text [set TypeText($Type)] -anchor w
	button $pcns.f$Type -bg $fg -activebackground $fg -width 4 -command "ChangeCouleur $Type $fg $pcns.f$Type"
	button $pcns.b$Type -bg $bg -activebackground $bg -width 4 -command "ChangeCouleur $Type $bg $pcns.b$Type"

	grid $pcns.l$Type -row $i -column 0 -sticky w
	grid $pcns.f$Type -row $i -column 1 -sticky w
	grid $pcns.b$Type -row $i -column 2 -sticky w
    }
    grid $pcns.lbl -row 0 -column 0 -columnspan 3 -sticky we -pady {10 0}

    label $pcns.lblm -text "For the Threshold Method :\nDefine the threshold above which a column is said\nto be conserved" -justify left
    label $pcns.sclb -text "Threshold " -anchor w -justify left
    scale $pcns.scal -from 0 -to 100  -orient horiz -showvalue true  -variable TmpDef(Threshold)  -width 8 -length 75
    grid $pcns.lblm -row 4 -column 0 -columnspan 3 -sticky ew -pady {20 5}

    grid $pcns.sclb -row 5 -column 0 -columnspan 1 -sticky w
    grid $pcns.scal -row 5 -column 1 -columnspan 2 -sticky news

    label $pcns.sim -text "Use similarity" -anchor w -justify left
    radiobutton $pcns.simy -text "Yes" -variable TmpDef(SimiGris) -relief flat -value "1" -highlightthickness 0
    radiobutton $pcns.simn -text "No" -variable TmpDef(SimiGris) -relief flat -value "0" -highlightthickness 0

    grid $pcns.sim  -row 6 -column 0 -sticky w
    grid $pcns.simy -row 6 -column 1
    grid $pcns.simn -row 6 -column 2

    return

}

proc EnvoiePrfDatabases {} {

    global TmpDef FrmPref

    set pdbs $FrmPref
    $pdbs configure -text Databases

    label $pdbs.ldbs -justify left -anchor w -text "Ordalie retrieves some information using distant\n databases. You may change the defaults ones to\n yours. IMPORTANT ! The XXXX stands for the Id\n to be retrieved, and it must be specified in your url !" -font "Helvetica 12"

    label $pdbs.lpdb -text "Protein Data Bank (PDB) location :" -justify left -anchor w
    entry $pdbs.epd1 -bg white -textvariable TmpDef(UrlPdbWorld)
    entry $pdbs.epd2 -bg white -textvariable TmpDef(UrlPdbHome)

    label $pdbs.lsrs -text "Sequence Retrieval System (SRS) location :" -justify left -anchor w
    entry $pdbs.esr1 -bg white -textvariable TmpDef(UrlSRSWorld)
    entry $pdbs.esr2 -bg white -textvariable TmpDef(UrlSRSHome)

    label $pdbs.lbrd -text "Biological Information Retrieval Database (BIRD) location :" -justify left -anchor w
    entry $pdbs.ebr1 -bg white -textvariable TmpDef(UrlPdbHoan)

    grid $pdbs.ldbs -row 0 -column 0 -sticky news -pady {10 5}
    grid $pdbs.lpdb -row 1 -column 0 -sticky news -pady {20 1}
    grid $pdbs.epd1 -row 2 -column 0 -sticky news
    grid $pdbs.epd2 -row 3 -column 0 -sticky news
    grid $pdbs.lsrs -row 4 -column 0 -sticky news -pady {20 1}
    grid $pdbs.esr1 -row 5 -column 0 -sticky news
    grid $pdbs.esr2 -row 6 -column 0 -sticky news
    grid $pdbs.lbrd -row 7 -column 0 -sticky news -pady {20 1}
    grid $pdbs.ebr1 -row 8 -column 0 -sticky news -pady {0 10}

    return

}

proc EnvoiePrfEditor {} {

    global TmpDef FrmPref TmpMap

    set fe $FrmPref
    $fe configure -text Editor
    
    # lock sequences
    frame $fe.floc 
    grid $fe.floc -row 0 -column 0 -sticky ew -pady 10
    label $fe.floc.loc -text "Lock Sequences :" -anchor w -justify left -fg blue
    radiobutton $fe.floc.lcy -text "Yes" -variable TmpDef(LockSeqs) -relief flat -value "1" -highlightthickness 0
    radiobutton $fe.floc.lcn -text "No" -variable TmpDef(LockSeqs) -relief flat -value "0" -highlightthickness 0
    
    grid $fe.floc.loc -row 0 -column 0 -sticky w
    grid $fe.floc.lcy -row 1 -column 0 -sticky w -padx 10
    grid $fe.floc.lcn -row 1 -column 1 -sticky w
    
    # Mapping
    frame $fe.fmp
    grid $fe.fmp -row 2 -column 0 -sticky ew -pady 10
    label $fe.fmp.lmap -text "Residue Mapping Colors :" -anchor w -justify left -fg blue
    grid $fe.fmp.lmap -row 0 -column 0 -columnspan 9 -sticky w
    set r -1
    set p 0
    foreach l [set TmpDef(Mapping)] {
	lassign $l n f b
	set TmpMap($n,fg) $f
	set TmpMap($n,bg) $b
	if {! ($p % 9)} {
	    incr r
	}
	if {! ($p % 3)} {
	    label $fe.fmp.lmap$p -text "$n" -anchor w -justify left
	} else {
	    button $fe.fmp.bf$p -bg $f -activebackground $f -width 2 -command "ChangeCouleurMapping $f $fe.bf$r '$n' fg"
	    button $fe.fmp.bb$p -bg $b -activebackground $b -width 1 -command "ChangeCouleurMapping $b $fe.bb$r '$n' bg"
	}
	incr p
    }
    set r 0
    for {set i 0} {$i < $p} {incr i} {
	if {! ($i % 9)} {
	    incr r
	    set c 0
	}
	if {! ($i % 3)} {
	    set wd "lmap" ; set pd [list 2 1]
	} elseif {($i % 3) == 1} {
	    set wd "bf" ; set pd [list 1 1]
	} else {
	    set wd "bb" ; set pd [list 1 2]
	}
	grid $fe.fmp.${wd}$i -row $r -column $c -padx $pd
	incr c
    }

    return

}

proc EnvoiePrfGeneral {} {

    global TmpDef FrmPref

    set pgen $FrmPref
    $pgen configure -text "General"

    label $pgen.lac  -text "Application background color : "  -anchor w -justify left
    button $pgen.bac  -bg [set TmpDef(BackAppli)]  -height 1  -command "ChangeCouleurAppli $pgen.bac"
    button $pgen.bca  -text "Apply"  -background green1  -height 1  -command "AppliqueBackColor"
    
    label $pgen.whl -text "Mouse Wheel controls :" -anchor w -justify left
    label $pgen.lwy -text "Vertical scrolling " -anchor w -justify left
    entry $pgen.ewy -width 3 -bg white -textvariable TmpDef(DeltaYScroll) -justify right
    label $pgen.wuy -text " line(s)" -anchor w -justify left

    label $pgen.lwx -text "Horizontal scrolling " -anchor w -justify left
    entry $pgen.ewx -width 3 -bg white -textvariable TmpDef(DeltaXScroll) -justify right
    label $pgen.wux -text " character(s)" -anchor w -justify left

    grid $pgen.lac  -row 0 -column 0 -columnspan 2 -ipady 30 -sticky ew
    grid $pgen.bac  -row 0 -column 2 -sticky ew
    grid $pgen.bca  -row 0 -column 3 -sticky ew
    grid $pgen.whl  -row 1 -column 0 -columnspan 4 -pady {30 5} -sticky news
    grid $pgen.lwy  -row 2 -column 1 -sticky news
    grid $pgen.ewy  -row 2 -column 2 -sticky news
    grid $pgen.wuy  -row 2 -column 3 -sticky news
    grid $pgen.lwx  -row 3 -column 1 -sticky news
    grid $pgen.ewx  -row 3 -column 2 -sticky news
    grid $pgen.wux  -row 3 -column 3 -sticky news

    # Fontes
    frame $pgen.fft
    grid $pgen.fft -row 4 -column 0 -columnspan 4 -sticky ew -pady 10
    label $pgen.fft.lfnt -text "Editor font :" -anchor w -justify left -fg blue
    # search all fixed fonts
    set Lfont [list]
    foreach f [font families] {
	set fx [font metrics [list $f 10] -fixed]
	if {$fx} {lappend Lfont $f}
    }	
    set Lfont [lsort $Lfont]
    tk_optionMenu $pgen.fft.ffml TmpDef(SeqFontFaml) {*}$Lfont
    tk_optionMenu $pgen.fft.fsiz TmpDef(SeqFontSize) 4 6 8 10 12 14 16 18
    tk_optionMenu $pgen.fft.fwgh TmpDef(SeqFontWght) normal bold

    grid $pgen.fft.lfnt -row 0 -column 0 -sticky w
    grid $pgen.fft.ffml -row 1 -column 0 -sticky ew
    grid $pgen.fft.fsiz -row 1 -column 1 -sticky ew
    grid $pgen.fft.fwgh -row 1 -column 2 -sticky ew

    return

}

proc EnvoiePrfSequences {} {

    global Defauts FrmPref TmpDef

    set root $FrmPref
    $root configure -text "Sequences"

    # Bank Prefix
    set pbp "$root.bp"
    frame $pbp
    label $pbp.prf -text "Remove bank prefix :" -anchor w -justify left -fg blue
    radiobutton $pbp.pry -text "Yes" -variable TmpDef(RemoveBankPrefix) -relief flat -value "1"
    radiobutton $pbp.prn -text "No"  -variable TmpDef(RemoveBankPrefix) -relief flat -value "0"

    grid $pbp.prf -row 0 -column 0 -sticky w
    grid $pbp.pry -row 0 -column 1
    grid $pbp.prn -row 0 -column 2

    # Ajout nouveau Prefix
    set paj "$root.faj"
    set wd [PlusLongEltDe [set Defauts(PrefixesBank)]]
    frame $paj
    label   $paj.alst -text "Bank prefixes :" -fg blue -anchor w -justify left
    frame   $paj.fls
    listbox $paj.fls.lpr  -width $wd -height 5  -highlightthickness 0  -disabledforeground black  -bg white -fg black  -yscrollcommand "$paj.fls.scr set"

    scrollbar $paj.fls.scr -width 8   -command "$paj.fls.lpr yview"
    $paj.fls.lpr insert end {*}[set Defauts(PrefixesBank)]
    $paj.fls.lpr configure -state disabled

    grid $paj.fls.lpr -row 0 -column 0 -sticky ew
    grid $paj.fls.scr -row 0 -column 1 -sticky ns

    label  $paj.lnew -text "Type prefix to be added :"
    entry  $paj.ent -bg white -width 15
    button $paj.badd -text " Add "  -bg cyan  -command [list AjouteNouveauPrefixe $paj.ent $paj.fls.lpr]

    grid $paj.alst -row 0 -column 0 -columnspan 3 -sticky w
    grid $paj.fls  -row 1 -column 0 -rowspan 3 -sticky ew
    grid $paj.lnew -row 2 -column 1 -columnspan 2 -sticky w -padx {10 1}
    grid $paj.ent  -row 3 -column 1 -sticky w -padx {10 1}
    grid $paj.badd -row 3 -column 2 -sticky ew

    # Couleurs euka-arke-bacte
    set pcl "$root.fpc"
    frame $pcl
    label $pcl.llif -text "Life Domain Colors :" -fg blue -anchor w -justify left
    button $pcl.beuk -text "Eukaryota"  -fg [set TmpDef(FgEukaryota)]  -bg [set TmpDef(BgEukaryota)]  -command [list ChangeCouleurLifeDomain $pcl.beuk]
    button $pcl.bark -text " Archaea "  -fg [set TmpDef(FgArchaea)]  -bg [set TmpDef(BgArchaea)]  -command [list ChangeCouleurLifeDomain $pcl.bark]
    button $pcl.bbac -text "Bacteria"  -fg [set TmpDef(FgBacteria)]  -bg [set TmpDef(BgBacteria)]  -command [list ChangeCouleurLifeDomain $pcl.bbac]
    button $pcl.bvir -text " Viruses "  -fg [set TmpDef(FgViruses)]  -bg [set TmpDef(BgViruses)]  -command [list ChangeCouleurLifeDomain $pcl.bvir]
    
    grid $pcl.llif -row 0 -column 0 -columnspan 3 -sticky w
    grid $pcl.beuk -row 1 -column 0 -sticky ew
    grid $pcl.bark -row 1 -column 1 -sticky ew
    grid $pcl.bbac -row 1 -column 2 -sticky ew

    grid $pbp -row 0 -column 0 -sticky ew -padx 5 -pady {20 5}
    grid $paj -row 1 -column 0 -sticky ew -padx 5 -pady 10
    grid $pcl -row 2 -column 0 -sticky ew -padx 5 -pady 5

    return

}

proc EnvoiePrfTrees {} {

    global FrmPref
    global TmpDef

    set ft $FrmPref
    $ft configure -text Trees

    label $ft.lgpr -text "Gap Removal :"
    radiobutton $ft.gppw -text "Pairwise"  -highlightthickness 0  -relief flat  -variable TmpDef(TypeGapTree)  -value "pairwise"
    radiobutton $ft.gpgb -text "Global"  -highlightthickness 0  -relief flat  -variable TmpDef(TypeGapTree)  -value "global" 

    label $ft.tytr -text "Type of Tree :"
    radiobutton $ft.tydn -text "Dendrogram"    -variable TmpDef(TypeTree) -relief flat -value "dendrogram" -highlightthickness 0
    radiobutton $ft.tycl -text "Circular Tree" -variable TmpDef(TypeTree) -relief flat -value "cricular" -highlightthickness 0

    label $ft.fntt -text "Tree font :"
    tk_optionMenu $ft.fsiz TmpDef(FontSizeTree) 6 8 10 12 14 16
    tk_optionMenu $ft.fwgh TmpDef(FontWghtTree) normal bold

    label $ft.boot -text "Bootstrap :"
    radiobutton $ft.boty -text "Yes"  -highlightthickness 0  -relief flat  -value 1  -variable TmpDef(TreeBoot)
    radiobutton $ft.botn -text "No"  -highlightthickness 0  -relief flat  -variable TmpDef(TreeBoot)  -value 0

    grid $ft.lgpr -row 0 -column 0 -pady 10 -sticky w
    grid $ft.gppw -row 0 -column 1 -sticky w
    grid $ft.gpgb -row 0 -column 2 -sticky w

    grid $ft.tytr -row 1 -column 0 -pady 10 -sticky w
    grid $ft.tydn -row 1 -column 1 -sticky w
    grid $ft.tycl -row 1 -column 2 -sticky w

    grid $ft.fntt -row 2 -column 0 -pady 10 -sticky w
    grid $ft.fsiz -row 2 -column 1 -sticky w
    grid $ft.fwgh -row 2 -column 2 -sticky w

    grid $ft.boot -row 3 -column 0 -pady 10 -sticky w
    grid $ft.boty -row 3 -column 1 -sticky w
    grid $ft.botn -row 3 -column 2 -sticky w

    return

}

proc EnvoieZoneACloner {} {


    global ZoneSuperposition
    global LNOrdali
    global NomNomSeq
    global Sequences

    if {! [info exists ZoneSuperposition]} {return}

    set ns [llength [array names Sequences]]
    set NmSl {}
    set NmSl [$NomNomSeq tag ranges SelN]
    if {[llength $NmSl] != 0} {
	foreach {a b} $NmSl {
	    scan $a "%d.%d" y x
	    lappend SeqARendre $y
	}
    } else {
	for {set i 1} {$i <= $ns} {incr i} {
	    lappend SeqARendre $i
	}
    }

    foreach e $ZoneSuperposition {
	set x1 [lindex $e 0]
	set x2 [lindex $e 1]

	foreach y $SeqARendre {
	    set p1 "$y.$x1"
	    set p2 "$y.$x2"

	    set nom [lindex $LNOrdali [expr $y-1]]

	    set E1 [EquivPosGenPosSeq $p1]
	    set s1 [lindex $E1 1]
	    set E2 [EquivPosGenPosSeq $p2]
	    set s2 [lindex $E2 1]

	    lappend Bornes [list $nom $s1 $s2]
	}
    }

    AuLog " "
    AuLog "Zone limits for selected organisms :"
    AuLog "------------------------------------"
    foreach e $Bornes {
	AuLog "[lindex $e 0] [lindex $e 1] [lindex $e 2]"
    }

    return $Bornes

}

proc EnzymeCommission {EC {Def ""}} {

    global EnzymeCommission
    if {$EC=="1.1.-.-"} { set Spion 1 }
    set EC [FormateEC $EC]
    if {[info exists EnzymeCommission($EC)]} { return $EnzymeCommission($EC) }
    if {$Def=="" && [info exists EnzymeCommission("EstCharge")]} { return "" } 
    if { ! [info exists EnzymeCommission("EstCharge")]} {
	set EnzymeCommission("EstCharge") 1
	ChargeEnzymeCommission
	return [EnzymeCommission $EC]
    }
    set Papa [ECduPapa $EC]
    if {[regexp {[0-9]} $Papa]} {
	set Ancetres [EnzymeCommission $Papa]
	set EnzymeCommission($EC) [concat $Ancetres [list $EC $Def]]
    } else {
	set EnzymeCommission($EC) [list $EC $Def]
    }
    return $EnzymeCommission($EC)

}

proc Eponine {FichierTFA FichierOUT {Threshold 0.999}} {

    ### Execution du programme de recherche de TSS, Eponine, sur la sequence d'un fichier TFA ###
    if {![file exists $FichierTFA]} { return }
    set FileEponine /home/lardenoi/Programmes_Promoteurs/Eponine/eponine-scan.jar
    catch {exec java -jar $FileEponine -seq $FichierTFA -threshold $Threshold  >& $FichierOUT} Message
    return

}

proc EpouvanBlast {Rep {ExpectMax 1e-4}} {


	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	set FichierOut [open "$Rep/EpouvanBlast.csv" "w"]
	set FichierOut2 [open "$Rep/EpouvanFlat.csv" "w"]
	Espionne "$timestamp|EvouvanBlast : Start"
	set Liste [glob -nocomplain -directory "$Rep/" "*.blast"]
	foreach FichierBlast $Liste {
		
		array unset Tableau
		DepouilleLeBlast Tableau $FichierBlast
		for {set i 1} {$i <= $Tableau(NbSubject)} {incr i} {
			set ID $Tableau($i)
			if {$Tableau($ID,1,Expect) <= $ExpectMax} {
				# L'expect d'un hit est le premier segment d'un hit d'ou le 1
				set numero [lindex [split [file tail $FichierBlast] "."] 0]
				set NM [lindex [split [file tail $FichierBlast] "."] 1]	
				set DB [lindex [split $ID ":"] 0]
				set Entry [lindex [split [lindex [split $ID ":"] 1] "_"] 0]
				set Org [lindex [split [lindex [split $ID ":"] 1] "_"] 1]
				set Acc $Tableau($ID,Access)				
				set Expect $Tableau($ID,1,Expect)
				set Identities $Tableau($ID,1,Identities)
				set Positive $Tableau($ID,1,Positives)
				set Score $Tableau($ID,1,Score)
				regsub -all " " $Score "_" Score
				set Gaps $Tableau($ID,1,Gaps)
				set DebutQuery $Tableau($ID,1,DQ)
				set FinQuery $Tableau($ID,1,FQ)
				set DebutTarget $Tableau($ID,1,DS)
				set FinTarget $Tableau($ID,1,FS)
				if {$Gaps == "" || $Gaps == " " || $Gaps == "  "} {
					set Gaps "0/all 0%"
				}
				
				#if { $Org == "MOUSE" || $Org == "DANRE" || $Org == "DROME" || $Org == "PANTR"} {
				if { [string range $DB 0 5] == "REFSEQ"} {
					if {$DB == "REFSEQPREL" } {
						set LigneOut "$DB $numero $NM $Acc $Expect $Identities $Positive $Score $Gaps $DebutQuery $FinQuery $DebutTarget $FinTarget"
						regsub -all {\(|\)} $LigneOut "" LigneOut
						puts $FichierOut $LigneOut
					}
				} else {
					puts $FichierOut "$DB $numero $NM $Org $Entry $Acc $Expect $Identities $Positive $Score $Gaps $DebutQuery $FinQuery $DebutTarget $FinTarget" 
				}
				#}
			}
		}	
	}
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EvouvanBlast : End"

}

proc EpurerCS {FichierIn FichierOut} {

	# Filtre les resultats du mapping ChIP-SEQ en virant la qualite et proposant des coordonnees chromosomiqies
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "EpurerCS : Start"
	set FileIn [open "$FichierIn" "r"]
	set FileOut [open "$FichierOut" "w"]
	while { [gets $FileIn Ligne]  >=0 } {
		ScanLaListe $Ligne IDQualLen Sequence MM Coord
		set Longueur [lindex [split $IDQualLen ":"] 2]
		set NomLong [lindex [split $IDQualLen ":"] 0]
		set Nom [lindex [split $NomLong "_"] 0]
		regsub -all -nocase {Homo\_sapiens\.NCBI36\.51\.dna\_rm\.chromosome\.} $Coord "" Coord
		regsub -all -nocase {\:|\.} $Coord " " Coord
		set Chrom [lindex [split $Coord " "] 0]
		set Start [lindex [split $Coord " "] 2]
		regsub -all -nocase {\_|\@|[A-Z][0-9]} $Start "" Start
		set End [expr $Start + $Longueur - 1]
		puts $FileOut "$Nom-$Longueur chr$Chrom-$Start-$End $Sequence $MM"
	}
	close $FileIn
	close $FileOut
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "EpurerCS : End"

}

proc EquivPosGenPosSeq {pxy} {


    global NomNomSeq
    global NomTextSeq
    global NomEtSeqAssPDB
    global Sequences

    lassign [split [$NomTextSeq index $pxy] "."] y x 
    set noms [string trim [$NomNomSeq get $y.0 "$y.0 lineend"]]
    set nomstatus $noms

    if {[regexp "PDB_" $noms]} {
	# recherche seq attachee au pdb. C'est la premiere non-odb
	# en remontant la liste
	set mol [string range $noms 4 7]
	set ny [expr {$y-1}]
	set tst [string range [$NomNomSeq get $ny.0 "$ny.0 lineend"] 0 3]
	while {$tst eq "PDB_"} {
	    incr ny -1
	    set tst [string range [$NomNomSeq get $ny.0 "$ny.0 lineend"] 0 3]
	}
	set idx [lsearch -regexp $NomEtSeqAssPDB $mol]
	set n [lindex $NomEtSeqAssPDB $idx]
	scan $n "%s %s %s" PDBin NmSeqAss MolId
	set chn [string index $MolId 5]
	global PDB_[set mol]_SecStr
	global PDB_[set mol]_Sequence
	set SeqAss [set Sequences($NmSeqAss)]
	set SeqAlignee [lindex [set PDB_[set mol]_Sequence($chn)] 1]
	set nomsqas [lindex $LesNom $ny]
	set SeqAss [lindex $LesSeq $ny]

	set cxseq [CorrespondanceAliPDB $MolId $x $x $SeqAss $SeqAlignee]
	scan $cxseq "%d %s %s" xseq tmp tmp1
    } else {
	set s [string range [lindex $LesSeq [expr {$y-1}]] 0 $x]
	regsub -all {\.} $s "" lsp
	regsub -all " " $lsp "" lnet
	set xseq [string length $lnet]
    }

    return [list $x $xseq]

}

proc Equivalence {seq} {

    global LNOrdali

    set test [string toupper $seq]
    set Idx [lsearch $LNOrdali $test]
    if {$Idx != -1} {return $Idx}

    set test [string tolower $seq]
    set Idx [lsearch $LNOrdali $test]
    if {$Idx != -1} {return $Idx}

    FaireLire "Error ! No associated sequence !"

    return

}

proc EquivalentDansMSF {FichierMSF Pos Ref Autre} {

    set G  [PositionDansMSF Global $FichierMSF $Pos $Ref]
    return [PositionDansMSF Local  $FichierMSF $G $Autre]

}

proc ErPHICS {OrganismeQuery Chromosome Clade {Projet Fichier} {LongueurVoulueDeChaqueCote 0} {DR ""} {SequenceQuery ""}} {


# A partir d'une séquence d'un organisme, récuopére les séquences alignées par l'UCSC dans tous les organismes dispos
# /!\ Vérifier les MAJ UCSC opour utiliser les derniéres versions des alignements ou pour intégrer de nouveaux alignements /! 
# Gestion des paths d'alignements é explorer en fonction de l'organisme query
	set I 1
	set CompteurEcrit 0
	set ResultatPHICS ""
	set ListeDeSortie {}
	if { $DR != "" } {
		set DRnumero [string range $DR 2 2]
	}
	set Chromotexte "-Chr"
	set FichierDesCoordonnees [open "/tmp/Conservation/$Projet-DR3S-MM1-Chr$Chromosome.pro" "r"]
 	set FichierDesConservations [open "/tmp/Conservation/$Projet-Conservation-MM1-Chr$Chromosome-$Clade.txt" "w"] 
	set FichierDesRepechesHuman [open "/tmp/Conservation/$Projet-RepechesHuman-Conservation-MM1-Chr$Chromosome.txt" "w"]
	set FichierDesRepechesMouse [open "/tmp/Conservation/$Projet-RepechesMouse-Conservation-MM1-Chr$Chromosome.txt" "w"]
		
	set ListeDeSortie {}

	if { $Clade == "mouse" } {
		set Alignement$I "/genomics/link/UCSCAlignements/mm9/"
		set Espece$I "mm9"
		incr I
	}
		
	# Boucle de stockage du fichier de Coordonnees dans une liste
	while { [gets $FichierDesCoordonnees LigneCoordonnees]  >=0 } {
		lappend ListeCoordonnees $LigneCoordonnees
	}
		close $FichierDesCoordonnees
		unset FichierDesCoordonnees
	
	#Routine de chargement des fichiers
	for {set Espece 1} {$Espece < $I} {incr Espece} {
		set NomEspece [set Espece$Espece]
		set NomAlignement [set Alignement$Espece]
		set Path "$NomAlignement chr $Chromosome .hg18. $NomEspece .net.axt"
		regsub -all -nocase {\s} $Path "" Path
		set AlignementChromosome [open "$Path" "r"]
		set ListeDesAlignementsDeCetteEspece {}
		
		Espionne "Stockage des alignements du chromosome $Chromosome $OrganismeQuery avec $Clade"
		while { [gets $AlignementChromosome LigneAli]  >=0 } {
			if {$LigneAli != "" } {
				ScanLaListe $LigneAli SeqNum ChromosomeH AlignementStartQ EndH AlignementChromosomeT AlignementStartT AlignementEndT AlignementOrientationT ScoreAli
				set LigneEntete [string range $ChromosomeH 0 2 ]
				if {  $LigneEntete == "chr" } {
					set FullLine "$ChromosomeH $AlignementStartQ $EndH $AlignementChromosomeT $AlignementStartT $AlignementEndT $AlignementOrientationT $ScoreAli"
					gets $AlignementChromosome SeqH
					ScanLaListe $SeqH SequenceH
					gets $AlignementChromosome SeqM
					ScanLaListe $SeqM SequenceM
					set FullLine "$FullLine $SequenceH $SequenceM" 
					lappend ListeDesAlignementsDeCetteEspece $FullLine
					set $ChromosomeH ""
				}
			}	
		}

		close $AlignementChromosome
		unset AlignementChromosome
		set NumeroLigneEntree -1
		set PlusAucuneChanceDeTrouver "Faux"
		
		Espionne "Balayage des coordonnees en entree"
		foreach Coordonnee $ListeCoordonnees {
			set DRQuery "DR3"
			incr NumeroLigneEntree
			set NomEspece [set Espece$Espece]
			set QuelMismatchs1 " "
			set QuelMismatchs1 " "
			set alias1 ""
			set alias2 ""
			set alias3 "" 
			set alias4 "" 
			set alias5 "" 
			set alias6 "" 
			set alias7 "" 
			set alias8 "" 
			set alias9 ""
			ScanLaListe $Coordonnee Acc Deb Fin Orientation Prot Distance ExonOutron UtrOuCDS DebutExonOutron FinExonOuIntron DebutOuFinExonOuIntron DistanceAlaBorneDeExonOuIntron ChromosomeQuery StartQuery EndQuery OrientationQuery SequenceQuery gID displayID alias
			set CoordonneeCopy $Coordonnee
			set Coordonnee "$ChromosomeQuery $StartQuery $EndQuery $OrientationQuery $SequenceQuery"
			set LongueurQ [string length $SequenceQuery]
			set Stockage $ResultatPHICS
			set input 0
			set RandomOuPas "NON"
			set Conservation 0
			set ConservesSansGap 0
			set ConservesMaisGap 0
			set NonConserves 0
			set ConservesTotaux 0
			set Retenus 0
			set NonRetenus 0
			set LongueurSequenceTotale [expr $EndQuery - $StartQuery]
			foreach Alignement $ListeDesAlignementsDeCetteEspece {
				set Conservation 0
				ScanLaListe $Alignement ChromosomeH AlignementStartQ AlignementEndQ AlignementChromosomeT AlignementStartT AlignementEndT AlignementOrientationT ScoreAli SeQ SeT
				set RandomOuPas "Complet"
				if { [regexp -- {random} $AlignementChromosomeT] } {
					set RandomOuPas "Random"
				}
				
				if { $StartQuery >= $AlignementStartQ && $EndQuery <= $AlignementEndQ} {
					if { $OrientationQuery == "-" } {
						set SequenceRegexp [NucToReverseAndComplementNuc $SequenceQuery]
					} else {
						set SequenceRegexp $SequenceQuery
					}
					set ListeDistanceAvantQueryAvecGaps [regexp -indices -all -inline -nocase "$SequenceRegexp" $SeQ]
					Espionne $ListeDistanceAvantQueryAvecGaps
					
					# Si on ne retrouve pas la séquence humaine, il y a un gap chez human
					# On récup alors une portion plus large que la séquence souris qu'on passera au crible du pattern
					# si on retrouve une signature VDR (2 MM allowed) , on garde.
					
					if { [llength $ListeDistanceAvantQueryAvecGaps] == 0 } {
						break
					}
					
					# Si une séquence occure plusieurs fois dans le meme alignement, on scan pour chaque occurence
					# On aura donc des séquences traitées autant de fois qu'elles ont de duplicons donc des doublons dans 
					# le fichier en sortie mais donnannt une idée des génes multirégulés
					
					set Multi 0
					foreach HitRegexp $ListeDistanceAvantQueryAvecGaps {
						incr Multi
						if { $Multi > 1 } {
							Espionne "Multiii !"
						}
						ScanLaListe $HitRegexp StartExp EndExp
						set DistanceAvantQueryAvecGaps $StartExp
						set DistanceAvantTargetAvecGaps $StartExp
						set SequenceAvantQueryAvecGaps [string range $SeQ 0 [expr $DistanceAvantQueryAvecGaps - 1]]
						set SequenceAvantTargetAvecGaps [string range $SeT 0 [expr $DistanceAvantQueryAvecGaps - 1]]
											
						regsub -all -nocase {\-} $SequenceAvantQueryAvecGaps "" SequenceAvantQuerySansGaps
						regsub -all -nocase {\-} $SequenceAvantTargetAvecGaps "" SequenceAvantTargetSansGaps
						
						set DistanceAvantQuerySansGaps [ llength [split $SequenceAvantQuerySansGaps "" ]]
						set DistanceAvantTargetSansGaps [ llength [split $SequenceAvantTargetSansGaps "" ]]

						set NbGapsBeforeQ [expr $DistanceAvantQueryAvecGaps - $DistanceAvantQuerySansGaps]
						set NbGapsBeforeT [expr $DistanceAvantTargetAvecGaps - $DistanceAvantTargetSansGaps]
						
						set SequenceQ [string range $SeQ $DistanceAvantQueryAvecGaps [expr $DistanceAvantQueryAvecGaps - 1 + $LongueurQ] ]
						set SequenceT [string range $SeT $DistanceAvantQueryAvecGaps [expr $DistanceAvantQueryAvecGaps - 1 + $LongueurQ] ]
						
						set ReverseQ [NucToReverseAndComplementNuc $SequenceQ]
						set ReverseT [NucToReverseAndComplementNuc $SequenceT]
						set StartT [expr $AlignementStartT + $DistanceAvantTargetSansGaps]
						set EndT [expr $StartT + $LongueurQ - 1]
						if { $AlignementOrientationT == "-" } {
							set ChromoSize [ChromoSize $Clade "mm9" $AlignementChromosomeT]
							set StartT [ expr $ChromoSize - $StartT]
							set EndT [expr $StartT + $LongueurQ - 1]
						}
						set DRQuery "DR3"
						if { [ regexp -- {-} $SequenceT ] } {
							# S'il y a des gaps peu nombreux et centrés, éa peut juste changer la classe de DR ==> On les stocke
								break
						} else {
							set GapsChezMouse 0
						}
							
						if { !$GapsChezMouse } {
							set DRnumero [string range $DRQuery 2 2]
							set ConsensusCheck "X/X/X"
							set GapsOuPas "SansGaps"
						} else {
							set ConsensusCheck "X/X/X"
							set GapsOuPas "AvecGaps"
						}
						set ResultatPHICS "$AlignementChromosomeT:$StartT-$EndT/$AlignementOrientationT/$GapsOuPas/$SequenceT/$SequenceQ/$ConsensusCheck"
						break
					}
					unset ListeDistanceAvantQueryAvecGaps
				}
			}
			
			
			lappend ListeDeSortie "$Coordonnee $ResultatPHICS $gID $displayID $alias"
		}
		set Long [llength $ListeDeSortie]
		Espionne $Long
		unset ListeDesAlignementsDeCetteEspece
	}
	
	#Routine de vidage de la liste de sortie dans le fichier de sortie
	foreach LigneSortie $ListeDeSortie {
		puts $FichierDesConservations $LigneSortie
	}
	close $FichierDesConservations
	close $FichierDesRepechesMouse
	close $FichierDesRepechesHuman

}

proc ErPattern {chr MM} {


# Recherche un motif en générant un mismatch (adapté récepteurs nucléaires)

	set Chromosome "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200603/chr$chr.fa"
	set DR3 0
	
	array unset SeqTFA
	array set SeqTFA [readFasta $Chromosome 0]
	set Acc [lindex $SeqTFA(index) 0]
	set RegExp {AGGTCA[ATCG][ATCG][ATCG]TGACCT}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]ACTGGA}
	
if { $MM > 0 } {

#Mutation dans le premier hémis-site sur le brin +
	append RegExp {|[TGC]GGTCA[ATCG][ATCG][ATCG]TGACCT}
	append RegExp {|A[TAC]GTCA[ATCG][ATCG][ATCG]TGACCT}
	append RegExp {|AG[TAC]TCA[ATCG][ATCG][ATCG]TGACCT}
	append RegExp {|AGG[GAC]CA[ATCG][ATCG][ATCG]TGACCT}
	append RegExp {|AGGT[GAT]A[ATCG][ATCG][ATCG]TGACCT}
	append RegExp {|AGGTC[GCT][ATCG][ATCG][ATCG]TGACCT}
#Mutation dans le second hémi-site sur le brin +
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG][GAC]GACCT}
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG]T[TAC]ACCT}
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG]TG[GTC]CCT}
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG]TGA[GAT]CT}
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG]TGAC[GAT]T}
	append RegExp {|AGGTCA[ATCG][ATCG][ATCG]TGACC[GAC]}	
	
#Mutation dans le premier hémi-site sur le brin -	
	append RegExp  {|[ACG]CCACT[ATCG][ATCG][ATCG]ACTGGA}
	append RegExp  {|T[GAT]CACT[ATCG][ATCG][ATCG]ACTGGA}
	append RegExp  {|TC[GAT]ACT[ATCG][ATCG][ATCG]ACTGGA}
	append RegExp  {|TCC[GCT]CT[ATCG][ATCG][ATCG]ACTGGA}
	append RegExp  {|TCCA[GAT]T[ATCG][ATCG][ATCG]ACTGGA}
	append RegExp  {|TCCAC[GAC][ATCG][ATCG][ATCG]ACTGGA}
#Mutation dans le second hémi-site sur le brin -	
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG][TCG]CTGGA}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]A[ATG]TGGA}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]AC[ACG]GGA}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]ACT[ACT]GA}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]ACTG[ACT]A}
	append RegExp  {|TCCACT[ATCG][ATCG][ATCG]ACTGG[GCT]}	

}
	
	set ListeDesPositions [regexp -indices -all -inline "$RegExp" $SeqTFA($Acc,sequence)]
	
	set DR3f [open "/tmp/Conservation/Marc-DR3-MM$MM-Chr$chr.txt" "w"] 

	foreach PaireDeBornes $ListeDesPositions {
		set NewStart [expr [lindex $PaireDeBornes 0] + 1]
		set NewEnd [expr [lindex $PaireDeBornes 1] + 1]
		set Sequence [BoutADNDeUcscBoost $NewStart $NewEnd "+" "Homo_Sapiens" $chr]
		puts $DR3f "chr$chr $NewStart $NewEnd $Sequence"
	}
	close $DR3f
	

}

proc ErStrander {chr} {


set FichierEntree [open "/tmp/Conservation/Marc-DR3-MM0-Chr$chr.txt" "r"] 
set FichierSortie [open "/tmp/Conservation/Marc-DR3S-MM0-Chr$chr.txt" "w"] 
	while { [gets $FichierEntree Ligne]  >=0 } {
		ScanLaListe $Ligne Chromosome Start End Sequence
		set RegExp1 {^AGGTCA}
		set RegExp2 {TGACCT$}
		set ListeDesPlus1 [regexp -indices -all -inline "$RegExp1" $Ligne]
		set ListeDesPlus2 [regexp -indices -all -inline "$RegExp2" $Ligne]

		if { [llength $ListeDesPlus1] != 0 || [llength $ListeDesPlus2] != 0 } {
			puts $FichierSortie "$Chromosome $Start $End + $Sequence"
		} else {
			puts $FichierSortie "$Chromosome $Start $End - $Sequence"
		}
	}

}

proc EraseLeCanva {K {ListeDeTags ""} {Demander ""}} {

    if {$Demander==""} { set Demander 0 }
    if {$ListeDeTags==""} {
	set ListeDeTags [list "all"]
	if {[OuiOuNon "Do I erase ALL widgets ?"]} {
	    set Demander 0
	} elseif {[OuiOuNon "Do I ask for each widget ?"]} { 
	    set Demander 1
	}
    }

    set IdCadre [$K find withtag "Cadre"]

    foreach Tag $ListeDeTags {
	set LesIds [$K find withtag $Tag]
	foreach Id $LesIds {
	    if {$Id==$IdCadre} { continue }
	    set Type [$K type $Id]
	    if {$Demander && ! [OuiOuNon "Erase $Type ?"]} { 
		continue
	    }
	    $K delete $Id
	}
    }
    return $K

}

proc ErreurMath3D {Texte} {

    error "Error from Math3D $Texte"

}

proc ErreurString {} {

    CanalSqlString
    set Sql "select protein_id,annotation, preferred_name from items.proteins where preferred_name ilike 'Olfr%' and species_id = 10090 order by preferred_name;"
    set LesAPN [SqlExec $Sql "GetList"]
    foreach {P A PN} $LesAPN {
	if { ! [regexp {Olfr[0-9]+} $PN]} { continue }
	if { ! [regexp {olfactory receptor ([0-9]+)(;|$)} $A Match N]} { continue }
	if { $PN=="Olfr$N" } { continue }
	Espionne "$P $A $PN"
	lappend LesFaux "$P $A $PN"
    }
    AfficheListe $LesFaux

}

proc EspeceNormalisee {Texte} {

    set ListeDesMots [split $Texte " "]
    if { [llength $ListeDesMots] == 0 } { set Retour $Texte }
    if { [llength $ListeDesMots] == 1 } { set Retour [lindex $ListeDesMots 0] }
    if { [llength $ListeDesMots] >  1 } { set Retour [join [lrange $ListeDesMots 0 1] " "]}
    return [string trim $Retour "\."]

}

proc Espionne {{Texte ""}} {

    global EspionneNon

    if {$Texte=="SetEspionneNON"} { set EspionneNon 1 }
    if {$Texte=="SetEspionneOUI"} { set EspionneNon 0 }

    if {[info exists EspionneNon] && $EspionneNon} { return }

    puts $Texte
    return $Texte

}

proc EspionneL {{Liste ""}} {

    Espionne [join $Liste "\n"]

}

proc EspionneL_CACHEparRR {{Liste ""}} {

    #rR a copie ici le 19/10/2006
    Espionne [join $Liste "\n"]

}

proc Espionne_CACHEparRR {{Texte ""}} {

    #rR a copie ici le 19/10/2006
    global EspionneNon

    if {[info exists EspionneNon] && $EspionneNon} { return }

    puts $Texte

}

proc EssaiAttriDesSsDnaAcProt {} {

    set Fichier "[RepertoireDuGenome]/essai_QqAccProt.txt"
    set LesAcc [LesLignesDuFichier $Fichier]
    foreach Acc $LesAcc {
	set Commande "getz \"\\\[protein-acc:$Acc\\\]\" \-f id"
	set GetzOut [eval exec $Commande]
	#puts "$Acc=>$GetzOut"
	set LesMots [split $GetzOut " "]
	set Id [lindex $LesMots 3]
	set NM [LocUcsc $Id]
	puts "$Acc=>$Id=>$NM"
	if  {![regexp {^NM_[0-9]+$} $NM]} {
	    puts "attention pas numero NM"
	}
    }

}

proc EssaiAttriDesSsDnaSsProt {} {

    set FichierLigne "[RepertoireDuGenome]/ligssacc" 
    set Lignes [LesLignesDuFichier $FichierLigne]
    foreach Ligne $Lignes {
	set descri [RetChip $Ligne description_memorec]
	set descri2 [RetChip $Ligne description_customer]
	#puts "$Ligne=>descriavant=$descri"
	set descri [string range $descri 0 [expr [string first ":" $descri] - 1 ]]
	#puts "$Ligne=>descriapres=$descri"
	lappend LaSortie "$Ligne descri2avant=$descri2"
	if {[regexp { } $descri2]} {puts "$Ligne=>descri2=$descri2"}
    }
    AfficheVariable [join $LaSortie "\n"]

}

proc EssaiAttriToutProt {} {

    set D 0
    set K 0
    set J 0
    foreach I [RetChip2 ListOf Index] {  
	set Des1 [RetChip2 $I "description_customer"]
	set Des2 [RetChip2 $I "description_memorec"]
	set Ac1 [RetChip2 $I "DNA_acc"]
	set Ac2 [RetChip2 $I "refseq_PIQOR"]
	set Ac3 [RetChip2 $I "prot_acc"]
	set Ac4 [RetChip2 $I "prot_acc_PIQOR"]

	if { [regexp {^RA[0-9]+} $Des1] } {continue}

	if { $Ac1=="" && $Ac2=="" && ($Ac3!="" || $Ac4!="")} {
	    #Ac3=prot_acc Ac4=prot_acc_piqor
	    incr D
	    set jaitrouveprot 1
	    puts "ligne $I Ac3=$Ac3 Ac4=$Ac4"
	    
	    if { [regexp "," $Ac3] || [regexp "," $Ac4] } {
		set pls 1 
		incr K
	    } else { 
		incr J 
	    }
	    
	    set LesAcs3 [split $Ac3 ","]
	    set LesAcs4 [split $Ac4 ","]
	    set SesAcs [concat $LesAcs3 $LesAcs4]
	}
    }
    Espionne "$D =nombre de prot"
    Espionne "$K =nombre de prot ac virgules"
    Espionne "$J =nombre de prot ss virgules"

}

proc EssaiCamemberts {N} {

    set Liste [list  [list coucou   [list 3 blue tonton tonta] [list 4 red toutou  tonta] [list 2 green toutou  tonta]]  [list coucou2  [list 9 blue tonton tonta] [list 2 red toutou  tonta] [list 2 green toutou  tonta]]  [list coucou3   [list 3 blue tonton tonta] [list 4 red toutou  tonta] [list 2 green toutou  tonta]]  [list coucou4  [list 9 blue tonton tonta] [list 2 red toutou  tonta] [list 2 green toutou  tonta]]  [list coucou5  [list 3 blue tonton tonta] [list 4 red toutou  tonta] [list 2 green toutou  tonta]]  [list coucou6  [list 9 blue tonton tonta] [list 2 red toutou  tonta] [list 2 green toutou  tonta]]]
    IllustreLesCamemberts_bis  $Liste $N Yes

}

proc EssaiConcat {} {

    set list1 {AB10 AC10 AD10}
    set list2 {}
    set list3 {NM1 NM2 NM3}
    set Tout [concat $list1 $list2 $list3]
    foreach x $Tout { puts "++$x" }

}

proc EssaiExtraitDefinitionRNA {Nom} {

    set ResultatRechercheRNA [ExtraitDefinitionRNADesInfosAutomatiques $Nom]
    regsub -all {\[.*\]} $ResultatRechercheRNA " " ResultatRechercheRNA
    regsub -all {\{.*\}} $ResultatRechercheRNA " " ResultatRechercheRNA
    regsub -all {\(.*\)} $ResultatRechercheRNA " " ResultatRechercheRNA
    set LesMotsDeLaDef [split $ResultatRechercheRNA " "]
    set LesBons {}
    foreach mot $LesMotsDeLaDef {
	if {![regexp -nocase "Homo" $mot] && ![regexp -nocase "sapiens" $mot] && ![regexp -nocase "mRNA" $mot] && ![regexp -nocase "complete" $mot] && ![regexp -nocase "cds" $mot] && ![regexp -nocase "protein" $mot]&& ![regexp -nocase "clone" $mot] && ![regexp -nocase "image" $mot]&& ![regexp -nocase "mgc:" $mot]} {
	    lappend LesBons $mot
	} else {continue}
    }
    regsub -all "{}" $LesBons "" LesBons
    return $LesBons

}

proc EssaiHisto {} {

    set Liste [list "toto" [list "coucou" "red" 3 1] [list "cici" "blue" 6 1.5] [list "caca" "green" 9 1] [list "coco" "pink" -5 1] [list "coucou" "red" 3 1] [list "cici" "blue" 6 1.5] [list "caca" "green" 9 1] [list "coco" "pink" -5 1]]
    IllustreLHistogramme $Liste

}

proc EssaiLappendEtLconcat {} {

    set A "Q65"
    set B "Y58 X25"

    puts "lappend"
    lappend liste $A
    foreach x $liste {puts "++$x"}
    lappend liste $B    
    foreach x $liste {puts "$x"}

    puts "lconcat"
    LConcat liste2 $A
    foreach y $liste2 {puts "--$y"}
    LConcat liste2 $B
    foreach y $liste2 {puts "$y"}

}

proc EssaiPhraseConsensus {{NbIndiv 20} {NbMilliSecMax 1000}} {

    set LesPhrases [list "chat court dans champs" "champs vert etait grand" "chien aime chat" "chien aime chat"]
    LesPhrasesMemorisees $LesPhrases
    PhraseConsensus $LesPhrases $NbIndiv $NbMilliSecMax

}

proc EssaiRefseq {} {

    set ListeFinal {NM_008361 NM_010897 NM_011113}
    foreach ChaqueFinal $ListeFinal {
	set GetzOut ""
	set GetzOut2 ""
	set Commande "getz \"\\\[refseq-acc:$ChaqueFinal\\\]\" \-f id" 
	set GetzOut [eval exec $Commande]
	set Commande2 "getz \"\\\[refseq-acc:$ChaqueFinal\\\]\" \-view FastaSeqs" 
	set GetzOut2 [eval exec $Commande2]
	set GetzOut2 [string range $GetzOut2 [string last ">" $GetzOut2] end]
	if { [regexp {^>ref.+>ref} $GetzOut2] } {
	    puts "ATTENTION AU - 2 SEQ FASTA"
	}
	puts $GetzOut
	puts $GetzOut2
    }

}

proc EssaiTcl {} {

    puts $::RepertoireDuGenome
    exit

}

proc EssaiToileDAraignee {} {

    IllustreLaToileDAraignee [list [list cucu 0 -2 5] [list cici 4 -2 5] [list caca 5 -2 5]] cc

}

proc EssaiToilesDAraignee {N} {

    set Liste [list  [list coucou  [list titi  2 0 9] ]  [list coucou2 [list titi  2 0 9] [list titi2  6 0 21] [list titi3  0 -10 9]]  [list coucou3 [list titi  2 0 9] [list titi2  6 0 21] [list titi3  0 -10 9]]  [list coucou4 [list titi  2 0 9] [list titi2  6 0 21] [list titi3  0 -10 9]]  [list coucou5 [list titi  2 0 9] [list titi2  6 0 21] [list titi3  0 -10 9]]  [list coucou6 [list titi  2 0 9] [list titi2  6 0 21] [list titi3  0 -10 9]]]
    IllustreLesToilesDAraignee $Liste $N 1 1 1 1

}

proc Essaitax {} {

    set Fichier "[RepertoireDuGenome]/fichesannotation/mycobacterium_bovis.total"
    set Nb 0
    set Total 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	incr Total
	scan $Ligne "%s %s" A B
	if {$B == 1} {
	    incr Nb
	}
    }
    Espionne "$Nb $Total"

}

proc EstCeDeLADN {FichierTFA} {
 
    if {![file exists $FichierTFA]} {return ""}
    return [EstCeDeLADN_Seq [ContenuDuFichier $FichierTFA]]

}

proc EstCeDeLADN_Seq {Seq} {
 
    foreach Ligne [split $Seq "\n"] {
	if {[string index $Ligne 0] == ">"} {continue}
	regsub -all " " $Ligne "" Ligne
	if {[regexp -nocase {[^ATGCNXMKRSYWVHDB]} $Ligne]} {return "0"}
    }
    return "1"

}

proc EstCeQueCeMotEstInterdit {Mot} {

    global TabDesMotsInterdits

    if {![info exists TabDesMotsInterdits]} {
	set LesMotsInterdits [list "WEAKLY" "SIMILAR" "HYPOTHETICAL" "RIKEN" "CDNA" "GENE" "FULL-LENGTH" "PUTATIVE" "ENRICHED" "LIBRARY" "CLONE" "PRODUCT" "GENE" "SUPPORTED" "UNKNOWN" "EST" "UNCLASSIFIABLE"] 
	foreach MotInterdit $LesMotsInterdits {set TabDesMotsInterdits($MotInterdit) 1}
    }
    set Mot [string toupper $Mot]
    if {[info exists TabDesMotsInterdits($Mot)]} {return 1}
    return 0

}

proc EstCeQueGO1EstUnEnfantDeGO2 {GO1 GO2} {

    foreach Type [GODB GO $GO1 LesTypes] {
        foreach Ancetre [TousLesAncetresGO $Type $GO2] {if {$Ancetre == $GO2} {return 1}}
    }
    return 0

}

proc EstCeQueGO1EstUnParentDeGO2 {GO1 GO2} {

    foreach Type [GODB GO $GO1 LesTypes] {
	foreach Ancetre [TousLesAncetresGO $Type $GO2] {if {$Ancetre == $GO1} {return 1}}
    }
    return 0

}

proc EstCeQueLaCompositionDeLaSequenceEstConvenable {FichierTFA {Threshold_PN 25} {Threshold_PX 50} {Threshold_PXX 75}} {

    if {![file exists $FichierTFA]} {return 0}
    set LesBiais [CalculDesBiaisEnCompositionDuFichierTFA $FichierTFA]
    if {$LesBiais == ""} {return 0}
    if {$Threshold_PN < [lindex $LesBiais 1]} {return 0}
    if {    $Threshold_PX < [lindex $LesBiais 3] || $Threshold_PX < [lindex $LesBiais 5] ||  $Threshold_PX < [lindex $LesBiais 7] || $Threshold_PX < [lindex $LesBiais 9]} {return 0}
    if {        $Threshold_PXX < [lindex $LesBiais 11] || $Threshold_PXX < [lindex $LesBiais 13] ||  $Threshold_PXX < [lindex $LesBiais 15] || $Threshold_PXX < [lindex $LesBiais 17] ||  $Threshold_PXX < [lindex $LesBiais 19] || $Threshold_PXX < [lindex $LesBiais 21]} {return 0}
    return 1

}

proc EstCeQueLaSequenceEstConvenable {Seq ADNOuPROT NbBasesContigues} {

    if {$ADNOuPROT == "ADN"} {
	if {[regexp -nocase {[ACGTURYMKWSBDHV]{$NbBasesContigues}}        $Seq]} {return 1} else {return 0}
    } else {
	if {[regexp -nocase {[ARNDCQEGHILKMFPSTWYVBZ]{$NbBasesContigues}} $Seq]} {return 1} else {return 0}
    }

}

proc EstCeQueLeClusterEstSpecifiqueDesCategories {Cluster LesCategoriesSpecifiques {LesCategories ""} {Var 0.05}} {

    if {$LesCategories == {}} {set LesCategories [MorceauxChoisis [lsort [O2C2O LesCategories]]]}
    if {$LesCategories == "CategoriesInteressantes"} {set LesCategories [LesCategoriesInteressantes]}
    if {$LesCategories == {}} {return 0}

    set LesOrgasSpecifiques {}
    foreach CatSpe $LesCategoriesSpecifiques {
	set TabTmp($CatSpe) 1
	foreach OrgaSpe [O2C2O Categorie $CatSpe LesOrganismesLongs] {
	    lappend LesOrgasSpecifiques $OrgaSpe
	    set TabTmp($OrgaSpe) 1
	}
    }
    set LesOrgasSpecifiques [ElimineLesRedondancesDansUneListe $LesOrgasSpecifiques]
    set P [PresenceDesOrganismesDansCluster $Cluster $LesOrgasSpecifiques]
    
    set SuisJeMauvais 0
    foreach Cat $LesCategories {
	set LesOrgasDeLaCat [O2C2O Categorie $Cat LesOrganismesLongs]
	set NbTotOrga       [llength $LesOrgasDeLaCat]
	set NbOrgasSpeDansCat 0
	foreach OrgaDeLaCat $LesOrgasDeLaCat {
	    if {[info exists TabTmp($OrgaDeLaCat)]} {incr NbOrgasSpeDansCat}
	}

	set PTheo   [expr $P     * $NbOrgasSpeDansCat / $NbTotOrga]
	set PresMin [expr $PTheo * (1 - $Var)]
	set PresMax [expr $PTheo * (1 + $Var)]
	if {$PTheo == 0}  {set PresMax [expr $Var * 100]}

	set PDeCat [O2C2O Cluster $Cluster Categorie $Cat Presence]

	Espionne "$Cat $NbOrgasSpeDansCat $NbTotOrga $P"
	Espionne "$Cat $PresMin $PTheo $PresMax $PDeCat"
	if { [info exists TabTmp($Cat)] && $PDeCat  <= $PresMin} {Espionne "$Cat $PDeCat pas bon";set SuisJeMauvais 1;continue}
	if {![info exists TabTmp($Cat)] && $PresMax < $PDeCat } {Espionne "$Cat $PDeCat pas bon";set SuisJeMauvais 1;continue}

	if {0} {
	    if { [info exists TabTmp($Cat)] && $PDeCat  <= $PresMin} {return 0}
	    if {![info exists TabTmp($Cat)] && $PresMax < $PDeCat } {return 0}
	}
    }

    if {$SuisJeMauvais} {return 0}
    if {[info exists TabTmp]} {unset TabTmp}
    return 1

}

proc EstCeQueLeFichierTFAEstConvenable {FichierTFA} {

    if {![EstUnFichierTFA $FichierTFA]} {return 0}
    set Seq [QueLaSequenceDuTFA $FichierTFA]
    regsub -all -nocase {n|x} $Seq "" Seq
    if {[string length $Seq] < 10} {return 0}
    return 1

}

proc EstCeQueLeTFAEstConvenable {FileTFA ADNOuPROT NbBasesContigues} {

    set Seq [TFA2SEQ $FileTFA]
    return [EstCeQueLaSequenceEstConvenable $Seq $ADNOuPROT $NbBasesContigues]

}

proc EstCeUnNomInteressant {Nom} {

    set Reponse 0
    foreach N [LesNoms NomsInteressants] {if {$N == $Nom} {return 1}}
    return $Reponse

}

proc EstCeUnNombre {Variable} {

    if {![regexp {[^e0-9\-\+\.]}  $Variable] } {return 1}
    return 0

}

proc EstCeUnPoint {pos t} {

    global LesPointsDuGroupe LNDG

    # ici on travaille avec string index --> commence a 0
    incr pos -1
    set ng [expr {[llength $LNDG]-2}]
    if {$ng > 3	&& [regexp "CoulG" $t]} {
	set nb [string range $t 5 end]
	set g [lindex $LNDG $nb]
	set str [set LesPointsDuGroupe($g)]

	if {[string index $str $pos] != " "} {
	    return 1
	} else {
	    return 0
	}
    }

    if {$ng <= 3} {
	foreach n [lrange $LNDG 1 end-1 ] {
	    set str [set LesPointsDuGroupe($n)]
	    if {[string index $str $pos] != " "} {
		return 1
	    }
	}
    }

    return 0

}

proc EstCeUnTFAOuUnTFAS {{Fichier ""}} {


    Wup "Test si le fichier est un tfa multiple ou pas"
    Wup "Retourne le nombre de chevrons par fichier"

    if {$Fichier == "" || ! [file exists $Fichier]} {return ""}

    set nbChevrons 0
    set nbLigne    0
    set F [open "$Fichier"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	incr nbLigne
	if {  [string range $Ligne 0 0] == ">"} {
	    incr nbChevrons
	}
	#Attention on doit trouver au moins un chevron dans les 3 premieres lignes
	if {$nbChevrons=="0" && $nbLigne > 3} {break}
    }
    close $F

    return "$nbChevrons"

}

proc EstCeUneBandePrecise {Bande} {

    set DernierCaractere [string index $Bande end]
    if {![regexp -nocase {[a-z]} $Bande]} {return 0}
    if {[regexp -nocase {[a-z]} $DernierCaractere] && $DernierCaractere!="r"} {
	return 0
    } else {return 1}

}

proc EstCeUnmRNACompleteCDS {BanqueId Access} {

    set FicheInfoDuHit [PageInfo $Access genbankfull]
    if {$FicheInfoDuHit == ""} {set FicheInfoDuHit [PageInfo $BanqueId genbankfull]}	
    return [EstCeUnmRNACompleteCDS_PageInfo $FicheInfoDuHit]

}

proc EstCeUnmRNACompleteCDS_PageInfo {FicheInfoDuHit} {

    if {$FicheInfoDuHit == ""} {return 0}

    set LOCUS      [InfoDuChampsDeLaPageGenBank $FicheInfoDuHit LOCUS     ]
    set DEFINITION [InfoDuChampsDeLaPageGenBank $FicheInfoDuHit DEFINITION]
    set KEYWORDS   [InfoDuChampsDeLaPageGenBank $FicheInfoDuHit KEYWORDS  ]
    ##############################

    if {![regexp -nocase "mRNA|DNA"                             $LOCUS         ]} {return 0}


    if { [regexp         "EST"                                  $KEYWORDS      ]} {return 0}
    if { [regexp -nocase "HTG|GSS"                              $KEYWORDS      ]} {return 0}
    if { [regexp -nocase "HTG"                                  $LOCUS         ]} {return 0}
    if { [regexp -nocase {exon [0-9]+}                          $DEFINITION    ]} {return 0}
    if { [regexp -nocase "partial cds"                          $DEFINITION    ]} {return 0}

    if {![regexp         {     CDS      [ ]*[0-9]+\.[ ]*\.[0-9]+[ ]*}  $FicheInfoDuHit]} {return 0}
    if { [regexp         {     gene     [ ]*[a-z<]+}               $FicheInfoDuHit]} {return 0}
    if { [regexp         {     mRNA     [ ]*[a-z<]+}               $FicheInfoDuHit]} {return 0}
    if { [regexp         {     intron   [ ]*[0-9]}                 $FicheInfoDuHit]} {return 0}
    if { [regexp         {     TATA_signal  }                      $FicheInfoDuHit]} {return 0}
    if { [regexp         {     CAAT_signal  }                      $FicheInfoDuHit]} {return 0}
    if { [regexp         {     prim_transcript }                   $FicheInfoDuHit]} {return 0}
    if { [regexp         {     protein_bind   }                    $FicheInfoDuHit]} {return 0}

    return 1

}

proc EstCeVraimentUneNouvelleSequence {TFA {NucOuPro ""}} {

    set Rep ""
    if {[regexp "nuc" $NucOuPro]} { set Rep "nuctfa" }
    if {[regexp "pro" $NucOuPro]} { set Rep "prottfa" }
    set LesMemesAlias {} 
    set LesMemesSeq {}
    set LesMemesAliasEtSeq {} 
    set SeqNouveau [QueLaSequenceDuTexteTFA $TFA]
    
    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	set Access [EnteteDuTexteTFA $TFA "access"]
	set Seq [QueLaSequenceDuPAB $Nom $Rep]
	set MemeAlias [string equal -nocase $Access $Alias]
	set MemeSeq   [string equal -nocase $Seq    $SeqNouveau]
	if {$MemeAlias} { set MemeAliasText "SameAlias" } else { set MemeAliasText "DifferentAlias" }  
	if {$MemeSeq}   { set MemeSeqText   "SameSeq"   } else { set MemeSeqText   "DifferentSeq" }  
	set Message "$Nom $Alias $Access $MemeAliasText $MemeSeqText"
        if {$MemeAlias}               { lappend LesMemesAlias      $Message }
        if {$MemeSeq}                 { lappend LesMemesSeq        $Message }
        if {$MemeAlias && $MemeSeq}   { lappend LesMemesAliasEtSeq $Message }
    }
    if {$LesMemesAlias=={} && $LesMemesSeq=={}} { return 1 }
    set FA ""; set FS ""; set FX ""
    if {$LesMemesAlias!={}}                     { set FA [AfficheListe $LesMemesAlias      "" "SameAlias"] }
    if {$LesMemesSeq  !={}}                     { set FS [AfficheListe $LesMemesSeq        "" "SameSequence"] }
    if {$LesMemesAlias!={} && $LesMemesSeq!={}} { set FX [AfficheListe $LesMemesAliasEtSeq "" "SameAliasAndSequence"] }
    set Reponse [OuiOuNon "The new sequence exists already \n Please find the hits in the displayed lists\nDo I use it as a new sequence"]
    if {$FA!=""} { destroy $FA }
    if {$FS!=""} { destroy $FS }
    if {$FX!=""} { destroy $FX }
    return $Reponse

}

proc EstLeBonFormat {file format} {

    set format [string toupper $format]
    set fmt [FormatDuFichierSequence $file]
    if {$fmt eq $format} {
	return 1
    } else {
	return 0
    }

}

proc EstPABouTROUouTRNAouARN {Texte} {

    if {[EstUnPAB $Texte]} { return 1 }
    if {[regexp {^(TROU|TRNA|ARN)[0-9]+[nN]?} $Texte]} { return 1 }
    return 0

}

proc EstProteineDeFusion {header} {

    if {[llength $header] == 1} {
	set Lheader [split $header \n]
    } else {
	set Lheader $header
    }
    set res 0
    foreach ligne $Lheader {
	# On fait la recherche dans la partie "COMPND"
	if {[string range $ligne 0 5] ne "COMPND"} {continue}

	set ligne [string tolower $ligne]
	#Si le mot "Fusion" est mentionné, on arrête
	if {[string first "fusion" $ligne] != -1} {
	    return 1
	}
    }

    return 0

}

proc EstSimilaire {AA1 AA2} {


    Wup "Permet de rendre si un residu est similaire a un auzre ou pas (ou identique)"

    global TabSimilarite

    if {! [info exists TabSimilarite]} {
	set        LesGroupesDAA [list [list A I L M V] [list F Y W] [list D E Q N] [list K R H] [list P G S T] [list C]]
	foreach L $LesGroupesDAA {
	    foreach  LesAA $L {
		foreach AA $L {
		    set TabSimilarite($LesAA,$AA) 1
		}
	    }
	}
    }
    if {[info exists TabSimilarite($AA1,$AA2)]} {return 1} else {return 0}

}

proc EstTropLong {d maxl} {


    global NbLg

    set i [expr [string first "Length = " $d] + 9]
    set pl1 [string range $d $i end]
    set ib [string first " " $pl1]
    if {$ib == -1} {set ib "end"}
    set l [string trim [string range $pl1 0 $ib]]
    if {$l > $maxl || [regexp {[^0-9]} $l] || $l == ""} {
	incr NbLg
	return 1
    } else {
	return 0
    }

}

proc EstUnAccUniProt {Access} {

    #lm taken from :
    #lm http://www.uniprot.org/manual/accession_numbers
    #rR il peut y avoir un numero de version optionnel .3 ou .12 a la fin
    #
    #lm ajoute nouveau format d accession number sur 10 chars
    #lm pris de http://www.uniprot.org/help/accession_numbers
    if {[regexp -nocase {^[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}(\.[0-9]+)?$} $Access]} {
	return 1
    } else {
	return 0
    }

    #lm ancien :
    if {[regexp -nocase {^([A-NR-Z][0-9][A-Z][A-Z0-9][A-Z0-9][0-9]|[OPQ][0-9][A-Z0-9][A-Z0-9][A-Z0-9][0-9])(\.[0-9]+)?$} $Access]} {
	return 1
    } else {
	return 0
    }

}

proc EstUnAccessDUneBanqueBlastPDeGscope {Access} {

    if {[regexp -nocase {[A-Z]+AllProt[\:_]} $Access]} { return 1 }
    return 0

}

proc EstUnAccessDeHumanContig {AccessouId} {

    if {[regexp -nocase {^HS[0-9]{2}\:nt[0-9]{6}} $AccessouId]} {return 1}
    if {[regexp -nocase {^nt[0-9]{6}_[0-9]{,3}}   $AccessouId]} {return 1}
    if {[regexp -nocase {^nt[0-9]{6}$}            $AccessouId]} {return 1}
    return 0

}

proc EstUnAccessDeQuelleBanque {Access Banque {Banques ""}} {


    Wup "Permet de savoir si une sequence appartient a telle ou telle banque"

    if {$Banques==""} {
	set Banques "{swissprot sptrembl sptnew}"
    }

    set Typ1 id
    set Typ2 acc
    
    set Commande "getz -vf acc \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\])\""
    catch {set GetzOut [eval exec $Commande]} Message
    
    if {! [info exists GetzOut] || $GetzOut == ""} {
	return "0"
    } else {
	if {[regexp -nocase "$Banque" $GetzOut]} {return 1} else {return 0}
    }
    
    
    if {0} {
	set Type    [list "acc" "id"] 
	set OnARien 0
	foreach Typ $Type {
	    set Commande "getz -vf acc \"\\\[$Banques-$Typ: $Access\\\]\""
	    catch {set GetzOut [eval exec $Commande]} Message
	    if {! [info exists GetzOut]} {continue}
	    
	    if {$OnARien==0 && $GetzOut == ""} {
		continue
	    } else {
		if {[regexp -nocase "$Banque" $GetzOut]} {return 1} else {return 0}
		break
	    }
	}
    }

    return 0

}

proc EstUnAccessINTERPRO {Access} {

    if {[regexp -nocase {^ipr[0-9]{6}$} $Access]} {return 1}
    return 0

}

proc EstUnAccessPDB {Access} {


    if {[regexp -nocase {^PDB(\||\:|_[0-9])} $Access ]} { return 1 }
    set Access [EnlevePrefixeBank $Access]
    #lm On fait au plus strict
    #lm Un access PDB ne peut pas etre plus long que 
    #lm 6 caracteres : XXXX_X 
    if {[string length $Access] > 6} {return 0}
    if { ! [regexp -nocase {^[0-9][a-z0-9]{3}($|_$|_.$|_..$)} $Access] } { return 0 }
    if {   [regexp -nocase {_[0-9a-z]{3,}}       $Access] } { return 0 }
    return 1

}

proc EstUnAccessPDBVOIR_DANS_GSCOPE_SEQUENCES {Access} {


    set Access [EnlevePrefixeBank $Access]

    if {! [regexp -nocase {^[0-9][a-z0-9]{3}_.{0,1}$} $Access]} {return 0}
    if {[regexp -nocase {_[0-9a-z]{3,}} $Access] } { return 0}

    return 1

}

proc EstUnAccessPDB_CACHEparRR {Access} {

    #rR a copie ici le 19/10/2006
    if {[regexp -nocase {^PDB\|} $Access ]} { return 1 }
    if {[regexp -nocase {^PDB\:} $Access ]} { return 1 }
    if {[regexp -nocase {^PDB_[0-9]} $Access ]} { return 1 }
    if { ! [regexp -nocase {^[0-9][a-z0-9]{3}_?} $Access] } { return 0 }
    if {[regexp -nocase {_[0-9a-z]{3,}} $Access] } { return 0 }
    return 1

}

proc EstUnAccessRefseq {Access} {


    if {[regexp -nocase {^ref\|} $Access ]} { return 1}

    return 0

}

proc EstUnAccessSwissprot {Access} {

    if {[regexp -nocase "^SW\:" $Access]} { return 1 } else { return 0}

}

proc EstUnAccessVARSPLIC {AccessouId} {

    if {[regexp -nocase {^varsplic\:}             $AccessouId]} {return 1}
    if {[regexp -nocase {^[0-9a-z]{6,8}\-[1-9]+} $AccessouId]} {return 1}
    return 0

}

proc EstUnAccessVarSplic {Access} {

    if {[regexp -nocase {^VARSPLIC} $Access ]} { return 1}
    if {[regexp -nocase {^[a-z0-9]{6}-{1,2}$} $Access]} { return 1}
    return 0

}

proc EstUnBonAccess {Access} {

    global Commandes
    if { ! [regexp {[a-zA-Z0-9_]} $Access] } { return 0 }
    if { [string length $Access] > 70 } { return 0 }
    Warne "J'examine $Access"
    set NombreDeSequencesOK [FetchTest $Access]
    return $NombreDeSequencesOK

}

proc EstUnBonPattern {motif} {

    if {$motif eq ""} {return 0}
    set motif [string toupper $motif]
    if {[regexp {[^0123456789ACDEFGHIKLMNPQRSTUVWXY,~\(\)\{\}\<\>]} $motif]} {
	FaireLire "Error ! Unallowed character in motif !"
	return 0
    }
    set npo [regsub -all {\(} $motif "" tmp]
    set npf [regsub -all {\)} $motif "" tmp]
    set nco [regsub -all {\{} $motif "" tmp]
    set ncf [regsub -all {\}} $motif "" tmp]
    if {$npo != $npf} {
	FaireLire "Problem with parenthesis in motif !"
	return 0
    }
    if {$nco != $ncf} {
	FaireLire "Problem with curly braces in motif !"
	return 0
    }
    set ndb [regsub -all "<" $motif "" tmp]
    set nfn [regsub -all ">" $motif "" tmp]
    if {$ndb > 1} {
	FaireLire "Only one '<' allowed in motif !"
	return 0
    }
    if {$nfn > 1} {
	FaireLire "Only one '>' allowed in motif !"
	return 0
    }
    if {[regsub -all {,,+} $motif "" tmp]} {
	FaireLire "Too many commas in motif !"
	return 0
    }

    # traite NOT operateur
    if {[regsub -all {~~+} $motif "" tmp]} {
	FaireLire "Too many tildes in motif !"
	return 0
    }
    if {[set Lt [regexp -all -inline -indices {~} $motif]] != {}} {
	set fpred 0
	set newmotif ""
	foreach pi $Lt {
	    lassign $pi i i
	    append newmotif "[string range $motif $fpred $i-1]\[^"
	    if {[string index $motif $i+1] eq "("} {
		set if [expr {[string first ")" $motif $i]-1}]
		set id [expr {$i+2}]
		set fpred [expr {$if+2}]
	    } else {
		set id [expr {$i+1}]
		set if [expr {$i+1}]
		set fpred [expr {$if+1}]
	    }
	    set cnt [string map [list "," ""] [string range $motif $id $if]]
	    append newmotif "${cnt}\]"
	}
	append newmotif [string range $motif $fpred end]
	set motif $newmotif
    }
    #puts "motif til : $motif"

    # Traite parentheses
    # element a repeter ou OR
    set Lp [regexp -all -inline -indices {\(|\)} $motif]
    if {$Lp != {} } {
	set fpred 0
	set newmotif ""
	foreach {po pf} $Lp {
	    lassign $po o o 
	    lassign $pf f f 
	    if {[string index $motif $o] ne "(" || [string index $motif $f] ne ")"} {
		FaireLire "Badly balanced parentheses in motif !"
		return 0
	    }
	    if {($f - $o) == 1} {
		FaireLire "Empty parentheses in motif !"
		return 0
	    }
	    append newmotif [string range $motif $fpred $o-1]
	    
	    # analyse contenu parentheses
	    set cnt [string range $motif $o+1 $f-1]
	    if {[string index $cnt 0] eq "," || [string index $cnt end] eq ","} {
		FaireLire "Missing symbol before or after ',' in parentheses !"
		return 0
	    }
	    if {[regexp {[^ACDEFGHIKLMNPQRSTVWXY,]} $cnt]} {
		FaireLire "Bad symbol in parenthesis !"
		return 0
	    }
	    append newmotif "\[[string map [list "," ""] $cnt]\]"
	    set fpred [expr {$f+1}]
	}
	append newmotif [string range $motif $fpred end]
	set motif $newmotif
    }

    # Traite curly braces
    # Nombre de fois
    set Lp [regexp -all -inline -indices {\{|\}} $motif]
    if {$Lp != {} } {
	set fpred 0
	set newmotif ""
	foreach {po pf} $Lp {
	    lassign $po o o 
	    lassign $pf f f 
	    if {[string index $motif $o] ne "{" || [string index $motif $f] ne "}"} {
		FaireLire "Badly balanced curly braces !"
		return 0
	    }
	    append newmotif [string range $motif $fpred $o]
	    
	    if {($f - $o) == 1} {
		append newmotif "0-350000"
	    } else {
		# analyse contenu curly braces
		set cnt [string range $motif $o+1 $f-1]
		if {[regexp {[^0123456789,]} $cnt]} {
		    FaireLire "Bad symbol in curly braces !"
		    return 0
		}
		set cnt [string map [list "," "-"] $cnt]
		append newmotif $cnt
	    }
	    set fpred $f
	}
	append newmotif [string range $motif $f end]
	set motif $newmotif
    }

    # on cree le motif pour regexp
    set motif [string map [list "<" "^" ">" "$" "X" "."] $motif]

    puts "motif out : $motif"
    return $motif

}

proc EstUnBonResidu {La} {

    if {" N  " in $La && " CA " in $La && " C  " in $La && " O  " in $La} {return 1}
    if {" P  " in $La && " OP1" in $La && " O5'" in $La && " C5'" in $La && " C4'" in $La} {return 1}
    
    return 0

}

proc EstUnDebutActivite {Demande} {

    set Clef ""
    scan $Demande "%s" Clef
    return [string equal $Clef "DebutActivite"]

}

proc EstUnEC {e} {

    if {[string trim $e] eq ""} {return 1}

    set Le [split $e .]
    if {[llength $Le] != 4} {return 0}
    foreach e $Le {
	if {! [string is integer $e]} {return 0}
	if {$e < 0} {return 0}
    }

    return 1

}

proc EstUnEtatDesLieux {Demande} {

    return [string equal $Demande "EtatDesLieux"]

}

proc EstUnEucaryote {TaxId} {

    if {[regexp -nocase {[a-z]} $TaxId]} { set TaxId [Tax $TaxId] }

    set Class [TaxClass $TaxId "" "" TaxId] 
    return [regexp " 2759;" $Class]

}

proc EstUnFairePart {Demande} {

    set Clef ""
    scan $Demande "%s" Clef
    return [string equal $Clef "Adieu"]

}

proc EstUnFichierBlastP {Fichier} {

    set PremierMot [join [LesPremieresLignesDuFichier $Fichier 3] ""]
    Espionne $PremierMot
    return [regexp -nocase {^[ \t\n]*BLASTP} $PremierMot]

}

proc EstUnFichierImage {Fichier} {

    return [regexp -nocase {\.jpe?g$|\.gif$|.tif$|\.tiff$|\.pnm$|\.pbm$|\.tga$} $Fichier]

}

proc EstUnFichierTFA {Fichier {OuTFAs ""}} {

    if { $Fichier == "" } {return 0}

    set OuTFAs [string equal $OuTFAs "OuTFAs"]

    set f [open $Fichier r]
    if {[gets $f Ligne]<0 || ! [EstUneEnteteTFA $Ligne] } { close $f ; return 0} 

    set OnExigeSequence 1
    set nChevrons 1
    while {[gets $f Ligne]>=0} {
	if { ! [regexp -nocase {[^a-z \t]} $Ligne]} {
	    set OnExigeSequence 0
	    continue
	}
	if {[regexp {>} $Ligne]} {
	    incr nChevrons
	    if { $OnExigeSequence || ! $OuTFAs} { close $f ; return 0 }
	    if { ! [EstUneEnteteTFA $Ligne]   } { close $f ; return 0} 
	    set OnExigeSequence 1
	    continue
	} else {
	    close $f ; return 0
	}
    }
    close $f ; return $nChevrons

}

proc EstUnFinActivite {Demande} {

    set Clef ""
    scan $Demande "%s" Clef
    return [string equal $Clef "FinActivite"]

}

proc EstUnFragment {BID {Access ""} {DE ""}} {

    if {$DE!=""} { return [regexp -nocase "FRAGMENT" $DE] }
    return 0

}

proc EstUnFragmentGrid {d} {


    global NbFrg

    if {[regexp -nocase "fragment" $d]} {
	incr NbFrg
	return 1
    } else {
	return 0
    }

}

proc EstUnGI {Access} {

    return [string is integer -strict $Access]

}

proc EstUnIdOuAccSwissprot {IdOuAccess} {

    if {[exec getz "\[UNIPROT_SWISSPROT-id:$IdOuAccess\] | \[UNIPROT_SWISSPROT-acc:$IdOuAccess\]" -f id] == ""} {
	return 0
    } else {
	return 1
    }

}

proc EstUnIdSwissProt {Access} {

    #rR il n'y a que 5 caracteres pour l'Id
    if {[regexp -nocase {^[A-Z0-9]{1,5}_[A-Z0-9]{1,5}$} $Access]} { return 1 } 
    return 0

}

proc EstUnIdUniprot {Access} {

    #rR il y a jusqu'à 6 caracteres pour l'Id (c'est souvent le Acc)
    if {[regexp -nocase {^[A-Z0-9]{1,6}_[A-Z0-9]{1,5}$} $Access]} { return 1 } 
    return 0

}

proc EstUnP {P} {

    return [regexp {^P[0-9]+$} $P]

}

proc EstUnPAB {Texte} {

    if {[OnTraite "REFUNI" "NonStrict"] && [regexp {^(AGAM|SCER|XTRO)[0-9\.]+} $Texte]} { return 1 }
    return [regexp "^[ExpressionReguliereDesPABs]$" $Texte]

}

proc EstUnPABMute {PAB} {

    return [regexp {^mutation of } [ExtraitInfo $PAB "Muted"]]

}

proc EstUnRefseq {Access} {

    return [regexp -nocase {^(REFSEQ.?\:)?(AC|AP|NC|NG|NM|NM|NP|NP|NR|NT|NW|NW|XM|XM|XP|XP|XR|YP|YP|ZP|NS)_[0-9]{6,9}(\.[0-9]+)?$} $Access]

}

proc EstUnSignal {Mot} {

    global LesSignauxConnus
    global RepertoireDuGenome

    if { ! [info exists LesSignauxConnus]} {
	set LesSignauxConnus [LesSignauxDuFichier "$RepertoireDuGenome/signaux/signaux.tfa" Si Se]
	lappend LesSignauxConnus "TOPONcoI"
	lappend LesSignauxConnus "AttB1Adapter"
	lappend LesSignauxConnus "AttB2Adapter"
    }
    if {[lsearch -exact $LesSignauxConnus $Mot]<0} {
	return 0
    } else {
	return 1
    }

}

proc EstUnSpikeRNA_ActiChip {Acc} {


    Wup "Permet de savoir si un access est un des SpikeRNA de la puce ActiChip"
    
    global SpikeRNA

    if {[info exists SpikeRNA] && [info exists SpikeRNA($Acc)]} {
	return [set SpikeRNA($Acc)]
    } else {
	set LesSpikeRNA [list rca rcp1 rcbl xcp2 ltp6 ltp4 cab nac1 tim PRKase]
	foreach S $LesSpikeRNA {
	    set SLow [string tolower $S]
	    set SUp  [string toupper $S]
	    set SpikeRNA($S)    1
	    set SpikeRNA($SLow) 1
	    set SpikeRNA($SUp)  1
	}
    }

    if {[info exists SpikeRNA] && [info exists SpikeRNA($Acc)]} {
	return [set SpikeRNA($Acc)]
    } else {
	return "0"
    }

}

proc EstUnUniProt {Access} {

    #lM y a mieux mais c'est plus cher
    if {[EstUnAccUniProt  $Access]} { return 1 }
    if {[EstUnIdUniprot   $Access]} { return 1 }
    if {[EstUnIdSwissProt $Access]} { return 1 }
    return 0

}

proc EstUnVarSplic {n} {


    if {[regexp {^VARSPLIC} $n]} {
	return 1
    } else {
	return 0
    }

}

proc EstUneBacterie {TaxId} {

    if {[regexp -nocase {[a-z]} $TaxId]} { set TaxId [Tax $TaxId] }

    set Class [TaxClass $TaxId "" "" TaxId] 
    return [regexp " 2;" $Class]

}

proc EstUneEnteteTFA {Ligne} {

    set PremierMot ""
    scan $Ligne "%s" PremierMot
    return [regexp {^>[^>]*$} $PremierMot]

}

proc EstUneFeuille {Arbre} {

    return [expr [llength $Arbre] == 1]

}

proc EstUneFusion {Nom} {

    return [expr ! [string equal [Fusion $Nom] ""]]
    Wup "Rest is obsolete"
    if {$Nom>="MS50000"} { return 1 } else { return 0 }

}

proc EstUneProtease {P} {

    foreach PP [list "Thrombin" "TEV2" "TEVS" "Protease3C"] {
	if {$P==$PP} { return 1 }
    }
    return 0

}

proc EstUneScience {Demande} {

    return [regexp -nocase {[a-z]+[a-z_0-9]*} $Demande]

}

proc EstUneVariableGlobaleGenerale {variable} {

    if { ! [regexp {^[A-Z]} $variable]} { return 1 }
    if {[regexp "^Fichier"  $variable]} { return 1 }
    if {[regexp "^Gscope"   $variable]} { return 1 }
    if {[regexp  "Wscope"   $variable]} { return 1 }
    if {[regexp "^WithPack" $variable]} { return 1 }
    if {[regexp "^Commande" $variable]} { return 1 }
    if {[regexp "^LesBouto" $variable]} { return 1 }
    if {[regexp "Glossaire" $variable]} { return 1 }
    if {[regexp "Secret"    $variable]} { return 1 }
    if {$variable=="OutsideCSTB"} { return 1 }
    if {$variable=="VersionDeGscope"} { return 1 }
    if {$variable=="VariableADetruire"} { return 1 }
    if {$variable=="RepertoireDeTravail"} { return 1 } 
    if {$variable=="QuidSeqEstDisponible"} { return 1 }
    if {$variable=="ChoixParmiDansListBox"} { return 1 }
    if {$variable=="OrthographeCanonique"} { return 1 } 
    if {$variable=="OrthographeCanoniqueInverse"} { return 1 } 
    return 0

}

proc EstUpDown {UD} {

    return [regexp -nocase {^\+?(Up|Down|Here|\-?[0-9]+)$} $UD]

}

proc EtatBouton {b} {


    if {[$b cget -relief] eq "raised"} {
	return 0
    } else {
	return 1
    }

}

proc EtatDesLieuxRedondanceRefseq {} {

    set FichierRn "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata"
    set FichierRr "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata"
    set Fichier $FichierRn
    set i 0; set j 0; set k 0
    foreach AccessRn [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" ForceAccessFirst] {
	set AccessCourtRn [string range $AccessRn [expr [string first ":" $AccessRn] + 1 ] end]
	lappend LesRns $AccessCourtRn
	set TFA [LaSequenceDuTFAs $Fichier $AccessRn]
	set Seq [string toupper [QueLaSequenceDuTexteTFA $TFA]]
	set Rn($AccessCourtRn) $Seq
    }
    set Fichier $FichierRr
    foreach AccessRr [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" ForceAccessFirst] {
	set trouve 0; set memeseq 0
	set AccessCourtRr [string range $AccessRr [expr [string first ":" $AccessRr] + 1 ] end]
	foreach AccessCourtRn $LesRns {
	    if {$AccessCourtRr==$AccessCourtRn} {
		set trouve 1
		set TFA [LaSequenceDuTFAs $Fichier $AccessRr]
		set Seq [string toupper [QueLaSequenceDuTexteTFA $TFA]]
		if {[string equal $Rn($AccessCourtRn) $Seq ]} {set memeseq 1}
		break
	    }
	}
	if {$trouve} {
	    incr i
	    if {$memeseq} {
		incr j
		Espionne "$AccessCourtRr present dans les 2 avec meme sequence"
	    } else {
		incr k
		Espionne "$AccessCourtRr present dans les 2 sans meme sequence"
	    }
	}
    }
    Espionne "$i cas $j meme $k diff"

}

proc EtatDuBouton {btn} {


    if {[$btn cget -relief] == "raised"} {
	return 0
    } else {
	return 1
    }

}

proc EtatLockSeqs {} {

    global LockSeqs NomTextSeq

    if {[QuelMode] ne "seqlab"} {return}
    $NomTextSeq lock $LockSeqs

    return

}

proc EtatSeqsOut {quoi} {

    global LNOrdali SeqsOut NomSeqSel

    if {! [info exists NomSeqSel] || $NomSeqSel == {} } {return}

    if {$quoi eq "bloque"} {
	set Etat 1
    } else {
	set Etat 0
    }

    foreach e $NomSeqSel {
	lassign [split $e .] y x
	set seqass [string trim [lindex $LNOrdali $y]]
	if {$seqass eq ""} {
	    continue
	} else {
	    set SeqsOut($seqass) $Etat
	}
    }

    return

}

proc EtatsDesVE {{Qui ""} {Quoi ""} {Quoi2 ""}} {

    global EtatsDesVE 

    if {$Qui=="MeilleurTask"} {
	set ME [EtatsDesVE Meilleur [EtatsDesVE EtatDu $Quoi] [EtatsDesVE EtatDu $Quoi2]]
	return [EtatsDesVE TaskDu $ME]
    }
    if {$Qui=="Meilleur"} {
	set I1 [lsearch -exact [EtatsDesVE LesEtatsUnis] $Quoi]
	set I2 [lsearch -exact [EtatsDesVE LesEtatsUnis] $Quoi2]
	if {$I1<$I2} { return $Quoi2 }
	return $Quoi
    }

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

    set LesEtats     [list Cloned Expression_tested Soluble Purified Crystallization Crystal Structure Stopped]
    set LesEtatsUnis [list Cloned Expression_tested Soluble Purified Crystallization Crystal Structure]    
    set LesTasks     [list Clon   Expr              Solu    Puri     InCr            Crys    PDB       STOP]
    set LesReverseEtats     [RetourneLaListe $LesEtats]
    set LesReverseEtatsUnis [RetourneLaListe $LesEtatsUnis]

    set EtatsDesVE(LesEtats)            $LesEtats
    set EtatsDesVE(LesEtatsUnis)        $LesEtatsUnis
    set EtatsDesVE(LesTasks)            $LesTasks
    set EtatsDesVE(LesReverseEtats)     $LesReverseEtats
    set EtatsDesVE(LesReverseEtatsUnis) $LesReverseEtatsUnis
    
    foreach Task $LesTasks Etat $LesEtats {
	set EtatsDesVE(EtatDu,$Task) $Etat
	set EtatsDesVE(TaskDu,$Etat) $Task
    }
    return [EtatsDesVE $Qui $Quoi $Quoi2]

}

proc EtendAuBonMet {Nom PositionDuMet} {

    global RepertoireDuGenome

    set Debut  [Box $Nom debut]
    set Fin    [Box $Nom fin]
    set Orient [Box $Nom orient]

    if {$Orient == "F"} {
	set EtendDebut   $PositionDuMet
	set EtendFin     [expr $Debut-1]
	set NouveauDebut $PositionDuMet
	set NouvelleFin  $Fin
    } else {
	set EtendDebut   [expr $Fin+1]
	set EtendFin     $PositionDuMet
	set NouveauDebut $Debut
	set NouvelleFin  $PositionDuMet
    }

    set EtendNuc [BoutADN $EtendDebut $EtendFin $Orient]
    set LongEtendNuc [string length $EtendNuc]
    set EtendPro [SeqNucToSeqPro $EtendNuc]
    set LongEtendPro [string length $EtendPro]
    if { $LongEtendPro < 30 } {
	set EtendTxt "Extend $LongEtendPro aas  $EtendPro"
    } else {
	set EtendTxt "Extend $LongEtendPro aas  [string range $EtendPro 0 12] to [string range $EtendPro [expr $LongEtendPro-13] end]"
    }

    set SeqNuc [BoutADN $NouveauDebut $NouvelleFin $Orient]
    set SeqPro [SeqNucToSeqPro $SeqNuc]

    set NUC [SequenceFormatTFA $SeqNuc "$Nom $NouveauDebut $NouvelleFin $Orient Extend $LongEtendNuc bases" "nucbrut"]

    if {0} {
	Espionne "$Nom $NouveauDebut $NouvelleFin $Orient Extend $LongEtendNuc bases"
   } else {
	if {[file exists "$RepertoireDuGenome/nuctfa/$Nom"]} {
	    file copy -force "$RepertoireDuGenome/nuctfa/$Nom" "$RepertoireDuGenome/nuctfaorig/$Nom"
	}
	Espionne [Sauve $NUC dans "$RepertoireDuGenome/nuctfa/$Nom"]
	
	set TFA [SequenceFormatTFA $SeqPro "$Nom $NouveauDebut $NouvelleFin $Orient $EtendTxt" "protbrut"]
	if {[file exists "$RepertoireDuGenome/prottfa/$Nom"]} {
	    file copy -force "$RepertoireDuGenome/prottfa/$Nom" "$RepertoireDuGenome/prottfaorig/$Nom"
	}
	Espionne [Sauve $TFA dans "$RepertoireDuGenome/prottfa/$Nom"]
    }
    return "$Nom $NouveauDebut $NouvelleFin $Orient"


}

proc EtendAuBonMetPourTous {} {


    Wup "Uses 'CSP: M -18 issu de Met MTVFS' which is created by CreeExtendCodonStart"
    Wup " creates the line 'ExtendedCodonStart: ...'"
    Wup " removes the line CSP: M -18 ..."

    set NouvellesBornesDesPABs {} 
    set NouvellesBornesDesPABsSeules {} 
    foreach Nom [ListeDesPABs] {

	set Debut  [Box $Nom debut]
	set Fin    [Box $Nom fin]
	set Orient [Box $Nom orient]

	set NewCodonStart [ExtraitInfo $Nom "CSP"]
	Espionne "$Nom $NewCodonStart"
	if {[regexp {^ *[A-Z] \-[0-9]+( issu de )?} $NewCodonStart Match]} {
	    scan $NewCodonStart "%s %d" AA Position

	    set SeqPro [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	    set AncienneEntamme [string range $SeqPro 0 8]
	    set AncienStart     [string index $SeqPro 0]
	    set AnciennePosition [expr -$Position + 1]
	    set Texte "=ExtendedCodonStart: $AncienStart $AnciennePosition from $AncienneEntamme"
	    Espionne $Texte
	    InformeSansDemander $Nom $Texte
	    Informe $Nom $Texte
	    set ChampASupprimer "CSP: $NewCodonStart"
	    regsub -all {\-} $ChampASupprimer {\-} ChampASupprimer
	    InformeParSuppressionDuChamp $Nom $ChampASupprimer
	} else {
	    lappend NouvellesBornesDesPABs "$Nom $Debut $Fin $Orient"
	    continue
	}

	if { $Orient == "F" } {
	    set PositionAbs [expr $Debut + ($Position)*3] 
	} else {
	    set PositionAbs [expr $Fin - ($Position)*3] 	    
	}
	
	set NomDebutFinOrient [EtendAuBonMet $Nom $PositionAbs]
	ExtraireDe $NomDebutFinOrient N D F O
	Box $Nom debut  $D
	Box $Nom fin    $F
	Box $Nom orient $O
	lappend NouvellesBornesDesPABsSeules $NomDebutFinOrient
	lappend NouvellesBornesDesPABs       $NomDebutFinOrient
    }
    set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
    Garde $FichierBornes
    SauveLesLignes $NouvellesBornesDesPABs dans $FichierBornes
    ChargeListeDeBoites
    return $NouvellesBornesDesPABsSeules

}

proc EtendAuxDerniersTermes {LesTermes} {

    if {[llength $LesTermes]<=1} { return $LesTermes }
    set Premier [lindex $LesTermes 0]
    foreach Terme $LesTermes {
	if {$Terme==""} { set Terme $Premier }
	lappend LesBonsTermes $Terme
    }
    return $LesBonsTermes

}

proc EtendAuxPremiersTermes {LesTermes} {

    if {[llength $LesTermes]<=1} { return $LesTermes }
    if {[lindex $LesTermes 0]!=""} { return $LesTermes }
    set LaSuite [EtendAuxPremiersTermes [lrange $LesTermes 1 end]]
    set Premier [lindex $LaSuite 0]
    return [concat [list $Premier] $LaSuite]

}

proc Etiquette {Texte} {

    return [format "%-30s" $Texte]

}

proc EtudeCodonStart {{CommenceIci ""}} {

    global PagePropre
    set Moi [FrappeQuUnCoup $CommenceIci "set"]

    foreach Nom [ListeDesPABs] {
	if {[FrappeQuUnCoup $Nom $Moi] } { continue }
	if {[set CS [CodonStart $Nom]]==""} { continue }
	set F [TestCodonStartEtDeletionDuMSF $Nom]
	MetIt $Nom "Ask"
	catch {unset PagePropre($F) ; after 10 Destroy $F ; FermeFenetre}
	if {[JArreteDeBosser $Moi]} { return "JArreteDeBosser" }
    }

}

proc EtudeDeLaLongueurDesNonLocalises {FichierClusters} {

    set n 0
    set Lmini 10000
    set Lmaxi 0
    set Somme 0
    foreach JR [ListeMinimumDesJR $FichierClusters] {
	if {[PolyLocalise $JR]=="NoLocalization"} {
	    incr n
	    set Longueur [SeqLength $JR]
	    if {$Longueur==0} {continue}
	    set Somme [expr $Somme+$Longueur]
	    if {$Longueur<$Lmini} {set Lmini $Longueur}
	    if {$Longueur>$Lmaxi} {set Lmaxi $Longueur}
	}
    }
    set Moyenne [expr $Somme/$n]
    return "min:$Lmini max:$Lmaxi moyenne:$Moyenne"

}

proc EtudeDuMaskingDesNonLocalises {FichierClusters} {

    set NbNo 0
    set NbPart 0
    set NbTotal 0
    foreach JR [ListeMinimumDesJR $FichierClusters] {
	if {[PolyLocalise $JR]=="NoLocalization"} {
	    if {[QuelMasqueApresReMasking $JR]=="NoRepeatToMRM"} {incr NbNo}
	    if {[QuelMasqueApresReMasking $JR]=="PartiallyMRM"} {incr NbPart}
	    if {[QuelMasqueApresReMasking $JR]=="TotallyMRM"} {incr NbTotal}
	}
    }
    return "norepeat:$NbNo partial:$NbPart total:$NbTotal"

}

proc EtudieAccess {Access} {

    set Orga [OrgaDuFetcheAccess $Access]
    if { $Orga == "Inconnu" } {
	Warne "$Access organisme inconnu .........."
	return
    } 
    set GN $Access
    if {[regexp ":" $Access]} {
	set GN [lindex [split $Access ":"] 1]
    }
    set gn [string tolower $GN]
    GrapheLesBouts [glob /chop/ripp/fodbs/topdb/$Orga/bout/$gn-topdb]

}

proc EtudieCourant {w} {

    set Access [NomDuCourant $w]
    EtudieAccess $Access

}

proc EtudieLesNucleiquesDe {GenomeCourant} {

    global RepertoireDuGenome
    global ListeDeBoites
    
    Gs "Frame"
    
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
    set Fichiers "$RepertoireDuGenome/nuctfa/*"
    set Page [join [lsort [glob $Fichiers]] "\n"]
    return [AfficheVariable $Page "" "$Fichiers"]

}

proc EtudieLesProteinesDe {GenomeCourant} {

    global RepertoireDuGenome
    global ListeDeBoites
    
    Gs "Frame"
    
    if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
    set FichiersPABs [glob "$RepertoireDuGenome/gcgs/*"]
    set FichiersTROUs [glob "$RepertoireDuGenome/trousgcgs/*"]
    set Page [join [lsort [concat $FichiersPABs $FichiersTROUs]] "\n"]
    return [AfficheVariable $Page "" "gcgs et trous"]

}

proc EtudieUneSortieMSF {{NomDuFichier ""}} {

    global RepertoireDuGenome
    Gs "Frame"
    
    if { $NomDuFichier == "" } {
	set NomDuFichier [ButineArborescence "All"]
	if { $NomDuFichier == "" } { return }
    }
    return [AfficheFichier $NomDuFichier "GrandeLargeurAvecLogAvecEtudeMSF"]

}

proc EvalScores {f} {

    global LNDG SDG LNOrdali LSOrdali Sequences NomSeqSel ListeScore ListeDesPiliersDuGroupe TbScores TableScore

    set NomSeqSel {}

    DecortiqueUnTFA $f LNOrdali Sequences
    set nsites [LongueurDeLAlignement]
    set LNDG [list GroupeToutLeMonde]
    set SDG(GroupeToutLeMonde) $LNOrdali

    set Lmeth [list BILD Thompson Entrop1 Liu2 Williamson Kabat RPCA Norm SanderSP Peivar Karlin Valdar Capra Caffrey Wang]
    #set Lmeth [list BILD Kabat Norm Thompson]
    set Lmeth [list Karlin]
    if {"SanderSP" in $Lmeth || "Valdar" in $Lmeth} {
	set Lns [list]
	foreach s $LNOrdali {
	    lappend LSOrdali [set Sequences($s)]
	    lappend Lns $s [set Sequences($s)]
	}
	set LPCI [CalculeLesPCIGenerique $Lns]
    }

    CreeLesPiliers
    set Lpil [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]
    
    set lgt [PlusLongEltDe $Lmeth]
    LesDefauts PCThrGap 0.01
    set TbScores(Lcols) $Lmeth
    foreach m $Lmeth {
	if {$m ne "SanderSP" && $m ne "Valdar"} {
	    set t [time {set sco [ScoreDe$m $Lpil]}]
	} else {
	    set t [time {set sco [ScoreDe$m $Lpil $LNOrdali $LPCI]}]
	}	    
	set t [lindex [split [string trim $t] " "] 0]
	set TbScores(Time,$m) $t
	set TbScores(Score,$m) $sco
    }
    
    #timing
    puts ""
    foreach {k v} [lsort -integer -stride 2 -index 1 [array get TbScores "Time,*"]] {
	lassign [split $k ,] tmp mt
	puts [format "%-${lgt}s %d" $mt $v]
    }

    # resultats
    if {1} {
	puts ""
	set unit " %6.3f"
	set fmt "%-${lgt}s |[string repeat $unit $nsites]"
	foreach a [lsort [array names TbScores "Score,*"]] {
	    set m [lindex [split $a ,] 1]
	    puts [format $fmt $m {*}[set TbScores($a)]]
	}
    }

    # Histogramme
    if {0} {
	set K [UnCanva 600 600]
	$K configure -background black
	
	set Lmeth [list Thompson Kabat Williamson Norm]
	set Lcolor [list orange cyan green1 white magenta yellow ]
	set icol 0
	foreach m $Lmeth {
	    set color [lindex $Lcolor $icol]
	    set Lval [list]
	    foreach v $TbScores(Score,$m) {
		if {$v != -999.0} {
		    lappend Lval $v
		}
	    }
	    set Lval [Standardise $Lval]
	    
	    CreeHistogramme $Lval 100 graph $K $color
	    set Lval [lsort -real $Lval]
	    puts "$m [lindex $Lval 0] [lindex $Lval end]"
	    incr icol
	}	    
    }

    return
    #exit

}

proc Evaluation {LIndividu} {

    set PremierMot   [lindex $LIndividu 1  ]
    set BonusPremier [InterrogeLesEffectifsDesMots Mot $PremierMot nPremier]
    set DernierMot   [lindex $LIndividu end]
    set BonusDernier [InterrogeLesEffectifsDesMots Mot $PremierMot nDernier]

    set Score        [expr $BonusPremier + $BonusDernier]
    set ScoreNegatif [expr -1 * [llength [InterrogeLesEffectifsDesMots LesMots]]]
    set LeNouvelIndividu $LIndividu
    set ValPrec ""
    foreach Val [lrange $LIndividu 1 end] {
	if {$ValPrec == ""} {set ValPrec $Val;continue}
	if {![info exists Couple($ValPrec,$Val)]} {set Couple($ValPrec,$Val) 0}
	
	if {[InterrogeLesEffectifsDesMots Couple $ValPrec $Val nMax] == ""} {
	    set Score [expr $Score + $ScoreNegatif]
	} else {
	    set Score [expr $Score + [InterrogeLesEffectifsDesMots Couple $ValPrec $Val nMax] - [set Couple($ValPrec,$Val)]]
	}
	incr Couple($ValPrec,$Val)  	
	set ValPrec $Val
    }
    return [lreplace $LeNouvelIndividu 0 0 $Score]

}

proc EvalueLeDesign {PAB Dir} {


    Wup "Petit test rapide pour savoir si le design c bien passe en utilisant le fichier .log"
    Wup "Utiliser dans IllustreOligo et GUI pour mettre un warning si necessaire au design"
    Wup "Attention on ne recalcule rien sinon voir ReturnBestHitInDatabase ou CheckForBestHitInDatabase"

    set FichierLog   "$Dir/${PAB}.log"
    set NomDeFenetre ""
    set NoAccess     0
    set i            0
    if {[file exists $FichierLog]} {
	set F [open "$FichierLog"]
	while {[gets $F Ligne]>=0} {
	    if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue}
	    incr i
	    if {[regexp -nocase "Query has no equivalent sequence" $Ligne]} {set NoAccess 1;break}
	    if {$i=="6"} {break}
	}
	close $F
	
	if {$NoAccess} {
	    set  TailleTotale  [expr 35 + [string length $Dir] + [string length $PAB]]
	    if {$TailleTotale < 65} {
		set TailleSurDeux [expr (65 -9)/2]
	    } elseif {$TailleTotale > 134} {
		set TailleTotale 134
		set TailleSurDeux [format "%.0f" [expr $TailleTotale/2 -4.5]]
	    } else {
		set TailleSurDeux [format "%.0f" [expr $TailleTotale/2 -4.5]]
	    }
	    set Texte " [string repeat "-" $TailleSurDeux] Warning [string repeat "-" $TailleSurDeux]\n Be careful with the design of $PAB in $Dir.\n No reliable access found in blast searches.\n You should check yourself the Blast results or use Check Best Hit.\n If it is verified, you should only trust the white (oligo) boxes."
	    set NomDeFenetre [FaireSavoir_Multi $Texte "Warning"]
	}
    }
    return "$NomDeFenetre"

}

proc EvalueSiBidir {} {


	# Verifie si les candidats a la bidir attitude sont sur le meme chromosome et a quelle distance

	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EvalueSiBidir : Start"
	set FichierIn [open "$Rep/ReapparierLesBidir.csv" "r"]
	set FichierOut [open "$Rep/EvalueSiBidir.csv" "r"]
	set Lus 0
	set Ecrits 0
	set Bidir 0
	set SameStrand 0
	set OtherChromosom 0
	while { [gets $FichierIn Ligne]  >=0 } {
		ScanLaListe $Ligne Access1 Access2 Distance numero1 NM1 NP1 NMt1 Organism1 Expect1 chrom1 start1 end1 strand1 numero2 NM2 NP2 NMt2 Organism2 Expect2 chrom2 start2 end2 strand2
		incr Lus		
		if {$chrom1 == $chrom2 } {
			if { $strand1 != $strand2 } {
				if {$strand1 == "+" && $strand2 == "-"} {
					set DistanceP [expr $start1 - $end2]
				} elseif {$strand1 == "-" && $strand2 == "+"} {
					set DistanceP [expr $start2 - $end1]
				}
				
		
			} else { 
				set DistanceP "SameStrand"
				incr SameStrand
			}
		} else {
				set DistanceP "OtherChromosom"
				incr OtherChromosom
		}
		set LigneOut "$Access1 $Access2 $Distance $DistanceP $numero1 $NM1 $NP1 $NMt1 $Organism1 $Expect1 $chrom1 $start1 $end1 $strand1 $numero2 $NM2 $NP2 $NMt2 $Organism2 $Expect2 $chrom2 $start2 $end2 $strand2"
		puts $FichierOut $Ligneout 
		incr Ecrits	
	}
	close $FichierIn
	close $FichierOut
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EvalueSiBidir : End"
	Espionne "$timestamp|EvalueSiBidir : Read = $Lus"
	Espionne "$timestamp|EvalueSiBidir : Ecrits = $Ecrits"
	Espionne "$timestamp|EvalueSiBidir :     * Bidir: $Bidir"
	Espionne "$timestamp|EvalueSiBidir :     * SameStrand: $SameStrand"
	Espionne "$timestamp|EvalueSiBidir :     * OtherChromosom = $OtherChromosom"

}

proc EvaluerRGKTSA {Path} {


# Détecte les fichiers avec deux MM et un blanc entre les deux et les recolle (bidouille)
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EvaluerRGKTSA : Start"
	set FichierEntree [open "$Path.prom" "r"] 
	set FichierSortie [open "$Path.coord" "w"] 
	while { [gets $FichierEntree Ligne]  >=0 } {
		ScanLaListe $Ligne DR ID chrom start end strand sequence
		set score [RGKTSA $sequence $DR]
		puts $FichierSortie "$DR $ID $chrom $start $end $strand $sequence $score"
	
	}
	set timestamp [clock format [clock seconds] -format "%H:%M:%S"]
	Espionne "$timestamp|EvaluerRGKTSA : End"
	close $FichierEntree
	close $FichierSortie

}

proc EvaluerXP {Path} {


	# Sert à évaluer les SBS validés expérimentalement grace à la fonction de score de STAF

	Espionne "EvaluerXP: Start"
	set I 0	
	set ScoreTotal 0
	set Score 0
	set ScoreMoyen 0
	set FichierDesSequences [open "$Path.seq" "r"]
	set FichierDesSequencesScorees [open "$Path.lsco" "w"]
	while { [gets $FichierDesSequences Ligne]  >=0 } {
		ScanLaListe $Ligne Sequence
		set Score [StafLogScoreFunction $Sequence]
		if { $Score > 0  } {
			incr I
		}
			Espionne $Score
			puts $FichierDesSequencesScorees $Score
			set ScoreTotal [expr $ScoreTotal + $Score]
	}
	set ScoreMoyen [expr $ScoreTotal/ $I]
	Espionne "EvaluerXP: Av. Score = $ScoreMoyen (on $I sequences) "
	Espionne "EvaluerXP: End"
	close $FichierDesSequencesScorees
	close $FichierDesSequences

}

proc EventNullPourNoms {} {

    global NomNomSeq

    $NomNomSeq insert 1.0 "x"
    $NomNomSeq delete 1.0
    $NomNomSeq edit separator

    return

}

proc EventNullPourSeqs {} {

    global NomTextSeq

    $NomTextSeq insert 1.0 "x"
    $NomTextSeq delete 1.0
    $NomTextSeq edit separator

    return

}

proc EviSummary {{GN ""}} {

    set LesLignes {}
    foreach Nom [ListeDesPABs] {
	if { ! [regexp -nocase $GN [ExtraitInfo $Nom "ValiGN"]]} { continue }
	set DE [ExtraitInfo $Nom "ValiDE"]
	set OS [ExtraitInfo $Nom "Organism"]
	set Ligne "$Nom;$GN;$OS;$DE"
	lappend LesLignes $Ligne
    }
    return [join $LesLignes "\n"]

}

proc EvolHHuProDir {} {

    return "[HomeRipp]/EvolHHuPro"

}

proc EvolutionDesDDAvecProteineNotHuman {FichierBestOverlapAvecDef FichierLoc FichierEST FichierSortie} {

    foreach DD [ListeDesPABs] {
	set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD"
	if {![file exists $FichierProttfa]} {continue}
	set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa]
	if {![regexp "from Homo sapiens" $EnteteProttfa]} {lappend Liste $DD}
    }
    Espionne [llength $Liste]
    set L [lsort -unique $Liste]
    Espionne [llength $L]
    
    
    foreach Nom $L {
	set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom"
	if {![file exists $FichiermRNAHs]} {lappend LesNotHuman $Nom} else {lappend LesHumanHomolog $Nom}
    }
    Espionne "nb not human: [llength $LesNotHuman] - nb human homolog: [llength $LesHumanHomolog]"
    #return $LesHumanHomolog
    #return $LesNotHuman
    #SauveLesLignes $ListeTriee dans $FichierSortie
    foreach Nom $LesNotHuman {
	set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom]
	if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} else {lappend LesNoLoc $Nom}
    }
    Espionne "[llength $LesNoLoc] noloc"
    set L [lsort -unique $LesNoLoc]
    Espionne [llength $L]
    SauveLesLignes $L dans $FichierSortie
    exit
    #Espionne "[llength $LesLocalises] localises "
    #return $LesLocalises

    Espionne [llength [lsort -unique $LesNotHuman]]
    foreach Nom $LesNoLoc {
	set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess]
	if {$EST!=""} {lappend LesEST $Nom} 
    }
    Espionne $LesEST
    Espionne [llength $LesEST]
    set Ltriee [lsort -unique $LesEST]
    Espionne [llength $Ltriee]

    foreach Nom $LesNoLoc {
	set NM [InterrogeFichierBestNMavecDef $FichierBestOverlapAvecDef $Nom NM]
	if {$NM=="" || $NM==" "} {lappend LesSansRefSeq $Nom} else {Espionne "avec nm: $Nom $NM"}
    }
    Espionne [llength $LesSansRefSeq]
    set L [lsort -unique $LesSansRefSeq]
    Espionne [llength $L]
    #return $Ltriee

}

proc ExamSupOutliers {mref mrot d f} {

    global db StrucAVoir

    set Lf $::TabSF($mref,PFAM-A)
    puts "Domaines PFAM"
    foreach f $Lf {
	DecortiqueUneFeature $f d f col score note
	set ds [DonnePosGS $mref $d]
	set fs [DonnePosGS $mref $f]
	puts "$note $ds $fs"
    }
    $db eval {begin transaction}
    # reference
    set iref  [DonneIdDeAccessPDB $mref]
    set cref [DonneChainDeAccessPDB $mref]
    set Lref [$db eval {select a.x,a.y,a.z,r.rnbr from atoms as a, chains as c, pdb as p, residues as r where  p.name=$iref and  c.pk_pdb=p.pk_pdb and  c.name=$cref and  a.pk_chains=c.pk_chains and  a.aname = ' CA ' and  a.pk_residues = r.pk_residues and  r.type = 'Protein'}]
    # rotated
    set irot  [DonneIdDeAccessPDB $mrot]
    set crot [DonneChainDeAccessPDB $mrot]
    set Lrot [$db eval {select a.x,a.y,a.z,r.rnbr from atoms as a, chains as c, pdb as p, residues as r where  p.name=$irot and  c.pk_pdb=p.pk_pdb and  c.name=$crot and  a.pk_chains=c.pk_chains and  a.aname = ' CA ' and  a.pk_residues = r.pk_residues and  r.type = 'Protein'}]

    $db eval {commit}
    # compute
    set moy 0.0 ; set m2  0.0 
    set rms 0.0
    set nat 0
    foreach {xr yr zr nr} $Lref {xo yo zo no} $Lrot {
	incr nat
	set xd [expr {$xo-$xr}]
	set yd [expr {$yo-$yr}]
	set zd [expr {$zo-$zr}]
	set d [expr {sqrt($xd**2+$yd**2+$zd**2)}]
	set T($nr,$no) $d
	
	set moy [expr {$moy + $d}]
	set m2  [expr {$m2 + $d*$d}]
	set rms [expr {$rms + $d*$d}]
    }
    set moy [expr {1.0*$moy/$nat}]
    set m2  [expr {1.0*$m2/$nat}]
    set rms [expr {sqrt(1.0*$rms/$nat)}]
    set sd  [expr {1.0*$m2 - $moy*$moy}]

    puts [format "stats\nnatoms $nat moy %6.3f sd %6.3f rms %6.3f" $moy $sd $rms]
    set Lsd [list] ; set Lrms [list]
    foreach k [array names T] {
	lassign [split $k ,] n1 n2
	set n1 [string trimleft $n1 0]
	set d $T($k)
	if {$d > ($moy + 1.5*$sd)} {
	    lappend Lsd $n1
	}
	if {$d > (1.5*$rms)} {
	    lappend Lrms $n1
	}
    }
    puts "> moy + 1.5 * sd :"
    set Lsd [lsort -integer $Lsd]
    set d -1 ; set f -1 ; set dep 1
    set res ""
    foreach e $Lsd {
	if {$e != ($f + 1)} {
	    if {! $dep} {
		if {$d != $f} {
		    append res "$d-$f "
		} else {
		    append res "$d "
		}
	    }
	    set d $e
	    set f $e
	} else {
	    set f $e
	}
	set dep 0
    }
    puts "$res"

    puts "> 1.5 * rms:"
    set Lrms [lsort -integer $Lrms]
    set d -1 ; set f -1 ; set dep 1
    set res ""
    foreach e $Lrms {
	if {$e != ($f + 1)} {
	    if {! $dep} {
		if {$d != $f} {
		    append res "$d-$f "
		} else {
		    append res "$d "
		}
	    }
	    set d $e
	    set f $e
	} else {
	    set f $e
	}
	set dep 0
    }
    puts "$res"

    return

}

proc ExchangeColumns {FilIn {FilOut ""}} {

    if {$FilOut==""} {
	set FileOut $FilIn
	set Ext ".txt"
	regexp {\.[^\.]+$} $FilOut Ext
	regsub {\.[^\.]+$} $FilOut "" FilOut
	append FilOut "_OK_$Ext"
    }
    foreach Ligne [LesLignesDuFichier $FilIn] {
	if { ! [regexp {\s} $Ligne Sep]} { lappend LeOut $Ligne ; continue }
	scan $Ligne "%s %s" A B
	lappend LeOut "$B$Sep$A"
    }
    return [SauveLesLignes $LeOut dans $FilOut]

}

proc ExecPath {prog} {

#    set paths(blastall) "/biolo/ncbi/bin/blastall"
    set paths(blastall) "blastall"
    set paths(ballast) "ballast"
    set paths(clustalw) "/biolo/clustal/bin/clustalw"
    set paths(rascal) "/biolo/rascal/rascal"
    set paths(normd) "/biolo/normd/normd"
    set paths(leon) "/biolo/leon/leon"
    set paths(cluspack) "/biolo/cluspack/bin/cluspack"
    set paths(macsim) "/biolo/macsim/macsim"
    set paths(cap3) "/biolo/cap3/cap3"

    return $paths($prog)

}

proc Execute {Commande} {

    return [eval $Commande]    

}

proc ExecuteLaSelectionDeCheck {Selection} {


    set LesCommandes {}
    foreach Ligne [split $Selection "\n"] {
	if { ! [regexp " run " $Ligne]} { continue }
	lappend LesCommandes [StringSuivant " run " dans  $Ligne]
    }

    set N [llength $LesCommandes]

    if {$N==0} { return 0 }

    if {$N==1 && ! [OuiOuNon "Do I execute $LesCommandes ?"]} {
	return [expr -$N]
    }

    if {$N>1 && ! [OuiOuNon "Do I execute all these commands\n[join $LesCommandes "\n"]\n ?"]} {
	FaireLire "Please select the right one and retry."
	return [expr -$N]
    }
    
    foreach Commande $LesCommandes {
	eval exec gscope $Commande &
    }
    return $N

}

proc ExecuteMacsim {FichierMsf FichierRsf} {

    Wup "On retourne vide si ca se passe bien, Message d'erreur si non"
#    exec /biolo/macsim/macsim $FichierMsf $FichierRsf
    set Nom [file tail $FichierMsf]
    regsub {\..*} $Nom "" Nom
    if {$Nom=="HSAP08771"} {
	Espionne "ExecuteMacsim $FichierMsf $FichierRsf \nen [pwd]"
	set RepTest "/genomics/link/CilioCarta/test"
	if {[catch {exec $RepTest/mon_macsim  $FichierMsf $FichierRsf >& $RepTest/$Nom.log } Message]} {
	    return $Message
	}
	return ""
    }
Espionne "/biolo/macsim/macsim $FichierMsf $FichierRsf"
    if {[catch {exec /biolo/macsim/macsim $FichierMsf $FichierRsf >& /dev/null } Message]} { return $Message }
    return ""

}

proc ExecuteUnBoutonDe {w} {

    set Tabulation [string repeat " " [string length "Button"]]
    set Sel ""
    catch {set Sel [selection get]}
    foreach Bouton [LesBoutonsDeLaFrame $w.buttons] {
	set Texte [lindex [$Bouton configure -text] 4]
	regsub -all "\n" $Texte " ++ " Texte
	lappend LesActions "Button $Bouton $Texte"
	foreach SeqAct [QueFaitLeBouton $Bouton] {
	    regsub -nocase {<[a-z0-9\-]*> } $SeqAct "" Act
	    regsub {\[selection get\]} $Act "\{$Sel\}" Act
	    lappend LesActions "$Tabulation $Act"
	}
    }
    set Action [ChoixParmi $LesActions]
    if {$Action=="" || [regexp "^Button" $Action]} { return "" }
    return [eval $Action]

}

proc ExisteAABizarres {nseq} {

    set ya 0
    if {[info exists ::Warn($nseq)] && $::Warn($nseq)} {
	return 1
    } else {
	return 0
    }

}

proc ExisteAussiDansZCB {} {

    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ExisteAussiDansZCB.lst"] {
	scan $Ligne "%s %s %s %s %d" Nom B H P N
	set Nar [Narcisse $Nom]
	if {$N==0} {
	    Espionne "$Nom $Nar"
	    lappend LesNulsParNom "$Nom $Nar"
	    lappend LesNulsParNar "$Nar $Nom"
	    continue 
	}
	set Bla [ContenuDuFichier "[RepertoireDuGenome]/blastnAllnucZCB/$Nom"]
	set Hit [StringApres "AllnucZCB:" dans $Bla]
	set NCB [QuestionDeScience ZCB "ret Narcisse $Hit"]

	Espionne "$Nom $Nar $Hit $NCB"
	lappend LesHitsParNom "$Nom $Nar $Hit $NCB"
	lappend LesHitsParNar "$Nar $Nom $Hit $NCB"
	lappend LesHitsParHit "$Hit $NCB $Nom $Nar "
	lappend LesHitsParNCB "$NCB $Hit $Nar $Nom "
    }
    set LesHitsParNom [lsort $LesHitsParNom]
    set LesHitsParNar [lsort $LesHitsParNar]
    set LesHitsParHit [lsort $LesHitsParHit]
    set LesHitsParNCB [lsort $LesHitsParNCB]
    set LesNulsParNom [lsort $LesNulsParNom]
    set LesNulsParNar [lsort $LesNulsParNar]

    SauveLesLignes $LesHitsParNom dans "[RepertoireDuGenome]/fiches/LesHitsParNomGC"
    SauveLesLignes $LesHitsParNar dans "[RepertoireDuGenome]/fiches/LesHitsParGC"
    SauveLesLignes $LesHitsParHit dans "[RepertoireDuGenome]/fiches/LesHitsParNomCB"
    SauveLesLignes $LesHitsParNCB dans "[RepertoireDuGenome]/fiches/LesHitsParCB"
    SauveLesLignes $LesNulsParNom dans "[RepertoireDuGenome]/fiches/LesNulsParNomGC"
    SauveLesLignes $LesNulsParNar dans "[RepertoireDuGenome]/fiches/LesNulsParNarGC"
    exit

}

proc ExisteOrthologueDans {Orga Nom} {

    global OrthologueDans
    global RepertoireDuGenome

    if { ! [info exists OrthologueDans]} { ChargeOrthologueDans }

    if { [info exists OrthologueDans($Orga,$Nom)] && [set OrthologueDans($Orga,$Nom)] } {
	return 1
    } else {
	return 0
    }

}

proc ExistingKoAnnoAccess {Access} {


    set RepParent [OnGoingDir]

    set FichierXml "$RepParent/$Access.xml"
    if {[FileAbsent $FichierXml]} {
	set FichierXml [CreeXmlAnnoteParTousPourUnAccess $Access $RepParent]
    }
    if {$FichierXml==""} {
	return "Sorry,but something went wrong. I didn't get a result."
    }
    set Query "HtmlFromXmlMacsim&$FichierXml&Ftype_AllPredictions"
    set Url "[WscopeScience]&$Query"
    return [HttpCopy $Url]

}

proc ExistingKoAnnoMsf {NomMsf} {


    set RepParent "[OnGoingDir]/$NomMsf"

    set FichierMsf "$RepParent/$NomMsf.msf"
    set FichierXml "$RepParent/$NomMsf.xml"
    if {[FileAbsent $FichierXml]} {
	set FichierXml [CreeXmlAnnotePourUnMsf $FichierMsf $RepParent]
    }
    if {$FichierXml==""} {
	return "Sorry,but something went wrong. I didn't get a result."
    }
    set Query "HtmlFromXmlMacsim&$FichierXml"
    set Url "[WscopeScience]&$Query"
    return [HttpCopy $Url]

}

proc ExistingKoAnnoResults {Access {Rep ""}} {

    if {$Rep==""} { set Rep "[OnGoingDir]/$Access" }
    set LesRefText {}
    foreach FichierResultat [glob -nocomplain "$Rep/{$Access}_*"] {
	regsub -nocase {Resultat\.html$} $FichierResultat "" AP
	set P [StringApres "${Access}_" dans $AP]
	if {[QuelAnnoteXmlPour $P]==""} { continue }
	set P [BonneOrthographePour $P]
	set Queue [StringSuivant "OnGoing/" dans $FichierResultat] 
	set Ref "[WscopeScience]&FileMoi&OnGoing&$Queue&TelQuel"
	lappend LesRefText $Ref
	lappend LesRefText $P
    }
    return [Html_ListOfRefs $LesRefText "Disorder predictions for $Access"]

}

proc ExitProg {} {

    exit

}

proc ExonAspRS {} {

    set ldf "572 698
    699 798
    799 865
    866 967
    968 1063
    1064 1187
    1188 1234
    1235 1341
    1342 1411
    1412 1591
    1592 1699
    1700 1762
    1763 1915
    1916 2134
    2135 2245
    2246 2321
    2322 2509"
    
    set Lv [split $ldf \n]
    set o [open exon_human.feat w]
    puts $o "FEATURE Exons"
    set i 0
    set d0 [lindex [lindex $Lv 0] 0]
    incr d0 -1
    
    foreach l $Lv {
	lassign [string trim $l] d f
	if {($d - $d0) == 1} {
	    set d 1
	} else {
	    set d [expr {($d-$d0)/3}]
	}
	set f [expr {(($f-$d0)-2)/3}]
	if {! ($i%2)} {
	    set col green1
	} else {
	    set col yellow
	}
	puts $o "Q6PI48;LOCAL;$d;$f;$col;0.0;exon_[expr {$i+1}]"
	incr i
    }
    close $o
    exit

}

proc ExonicMapHuman {FileTFA FileBlast FileOut {AvecBlastOuSansBlast SansBlast} {var 0.05} {SeuilId 0.0} {SplitWithGap Yes} {AlertId 0.95} {TailleMin 10} {NbSubject 150} {ExpectDeRef 0.001}} {

    set FichierQuery     $FileTFA
    set FichierBlast     $FileBlast
    set FichierOut       $FileOut

    if {![file exists $FichierBlast]} {return}
    if {![file exists $FichierQuery]} {return}

    Espionne "$FileTFA -> Opening the blast file"
    set NbSubject [AskBlast $FichierBlast NbSubject]
    if {$NbSubject == "" || $NbSubject == 0} {Espionne "$FileTFA -> $FichierBlast no hits found";return}

    set TailleQuery [AskBlast $FichierBlast Taille     ]
    set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast]

    Espionne "$FileTFA -> Scanning all the contig"
    set NbMax     0
    set NbMax_Min [expr $NbMax * (1 - $var)]
    set LesBanqueId {}
    for {set i 1} {$i <= $NbSubject} {incr i} {
	set BId [AskBlast $FichierBlast Subject $i]
	if {![string equal -nocase "hs" [string range $BId 0 1]]} {continue}
	regexp -nocase {([0-9a-z_]*):([0-9a-z]*)} $BId tmp Chromosome Contig
	if {[info exists TabTmp($BId,Nb)                       ]} {continue}
	set TabTmp($BId,Nb)  0

	Espionne "$FileTFA -> $BId"

	foreach Base [LeProfilDeLAlignementDeLaQuery $FichierBlast $BId "BothSens"] {if {$Base != 0} {incr TabTmp($BId,Nb)}}

	if {[set TabTmp($BId,Nb)] < $NbMax_Min} {continue}
	lappend LesBanqueId $BId
	if {[set TabTmp($BId,Nb)] < $NbMax    } {continue}

	set NbMax     [set TabTmp($BId,Nb)]
	set NbMax_Min [expr $NbMax * (1 - $var)]
	set LesVieuxBanqueId $LesBanqueId
	set LesBanqueId      {}
	foreach BId $LesVieuxBanqueId {
	    if {[set TabTmp($BId,Nb)] < $NbMax_Min} {continue}
	    lappend LesBanqueId  $BId
	}
    }
    if {[info exists TabTmp]} {unset TabTmp}
    Espionne "$FileTFA -> done"
    
    Espionne "$FileTFA -> Computing the long area"
    set LesGrandesRegions [LesGrandesRegionsDeLaQueryDuBlast $FichierBlast $ExpectDeRef $NbSubject $SeuilId Yes $LesBanqueId]
    Espionne "$FileTFA -> Computing the short area"
    set LesPetitesRegions [LesPetitesRegionsDesGrandesRegions $LesGrandesRegions                ]
    Espionne "$FileTFA -> Computing the informations of the short area"
    set LesInfos          [LesInfosDesRegionsDansLeBlast $FichierBlast $LesPetitesRegions $LesBanqueId $SeuilId "Contig"]
    set LesInfos          [lsort -integer -index 0 $LesInfos]

    Espionne "$FileTFA -> done"
    set LesInfos          [LaConservationDesMeilleuresRegionsRepetees $LesInfos $var $TailleMin]

    if {0} {
	Espionne ""
	Espionne $LesGrandesRegions
	Espionne ""
	Espionne $LesPetitesRegions
	Espionne ""
	Espionne $LesInfos
    }

    Espionne "$FileTFA -> Computing the best alignment for the exonic map"
    set i 0
    set EstCeQuIlYAUneDiff 1
    while {$EstCeQuIlYAUneDiff} {
	incr i
	if {$i == 20} {break}
	set LesRegionsUniquesParContig  {}
	set LesRegionsRepeteesParContig {}

	foreach LInfoDeLaRegion $LesInfos {
	    set NbArea  [lindex $LInfoDeLaRegion 3]
	    if {1 == $NbArea} {lappend LesRegionsUniquesParContig  $LInfoDeLaRegion}
	    if {1 <  $NbArea} {lappend LesRegionsRepeteesParContig $LInfoDeLaRegion}
	}
	set LesRegionsDansLeBonOrdreDesContigs [LesRegionsUniquesDesContigsDansLeBonOrdre $LesRegionsUniquesParContig]
	set LesRegionsUniquesEtRepetees [LInsertionDesRegionsRepetees $LesRegionsRepeteesParContig $LesRegionsDansLeBonOrdreDesContigs $TailleQuery]

	set AiJeVuUneDiff 0
	if {$LesInfos != $LesRegionsUniquesEtRepetees} {set AiJeVuUneDiff 1}
	if {$AiJeVuUneDiff} {
	    set LesInfos $LesRegionsUniquesEtRepetees
	} else {
	    set EstCeQuIlYAUneDiff 0
	}

	if {0} {
	    Espionne "#########ITERATION $i###########"
	    EspionneL $LesInfos
	    Espionne ""
	    EspionneL $LesRegionsUniquesParContig
	    Espionne ""
	    EspionneL $LesRegionsDansLeBonOrdreDesContigs
	    Espionne ""
	    EspionneL $LesRegionsUniquesEtRepetees
	}
    }
    Espionne "$FileTFA -> done"

    set LesRegionsUniquesRepeteesEtAbsentes [LInsertionDesRegionsAbsentes $LesRegionsUniquesEtRepetees $TailleQuery]

    if {$AvecBlastOuSansBlast == "AvecBlast" && $TypeDeBlast == "BLASTN"} {
	set LesRegionsUniquesRepeteesEtAbsentes [LesRegionsAvecLesRegionsAbsentesBlastees $FichierQuery $LesRegionsUniquesRepeteesEtAbsentes $TailleQuery 10 1e5]
	set LesRegionsUniquesRepeteesEtAbsentes [LInsertionDesRegionsAbsentes $LesRegionsUniquesRepeteesEtAbsentes $TailleQuery]
    }
    set LesRegionsFusionnees [LesRegionsUniquesFusionneesDesContigs $LesRegionsUniquesRepeteesEtAbsentes $TailleMin]
   
    ###Diminue le score en ne considerant pas les regions repetees => diminue le score des retropseudogenes qui n'ont pas regions repetees
    set LesRegionsFusionnees [LesRegionsAvecScoreModifieEnFonctionDesRegionsRepetees $LesRegionsFusionnees]

    if {0} {
	Espionne ""
	EspionneL $LesRegionsUniquesEtRepetees
	Espionne ""
	EspionneL $LesRegionsUniquesEtRepetees
	Espionne ""
	EspionneL $LesRegionsUniquesRepeteesEtAbsentes
	Espionne ""
    }
    if {0} {
	EspionneL $LesRegionsFusionnees
    }

    set Texte [TexteExonicMap $FichierBlast $FichierQuery $LesRegionsFusionnees $AlertId $i]
    Sauve $Texte dans $FichierOut
    return $Texte

}

proc ExpandCollapseAllTaxa {what action} {

    if {$what eq "internal"} {
	set key "ShowInt"
    } else {
	set key "Etat"
    }
    if {$action eq "collapse"} {
	set val 0
    } else {
	set val 1
    }

    foreach k [array names ::Tx "$key,*"] {
	set ::Tx($k) $val
    }

    DrawTaxo

    return

}

proc ExpandMask {aT rx ry rz} {

    upvar $aT T

    array set Q [array get T]

    # rajoute 1 rangee en -1 et au bord sup
    # en Z
    for {set i 0} {$i < $rx} {incr i} {
	for {set j 0} {$j < $ry} {incr j} {
	    set T($i,$j,$rz) 0
	    set T($i,$j,-1) 0
	}
    }
    # en Y
    for {set i 0} {$i < $rx} {incr i} {
	for {set k 0} {$k < $rz} {incr k} {
	    set T($i,$ry,$k) 0
	    set T($i,-1,$k) 0
	}
    }
    # en X
    for {set j 0} {$j < $ry} {incr j} {
	for {set k 0} {$k < $rz} {incr k} {
	    set T($rx,$j,$k) 0
	    set T(-1,$j,$k) 0
	}
    }

    
    for {set i 0} {$i < $rx} {incr i} {
	for {set j 0} {$j < $ry} {incr j} {
	    for {set k 0} {$k < $rz} {incr k} {
		set Q($i,$j,$k) [expr {[set T([expr {$i-1}],$j,$k)] || [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T([expr {$i+1}],$j,$k)] || [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,[expr {$j-1}],$k)] || [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,[expr {$j+1}],$k)] || [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,$j,[expr {$k-1}])] || [set Q($i,$j,$k)]}]
		set Q($i,$j,$k) [expr {[set T($i,$j,[expr {$k+1}])] || [set Q($i,$j,$k)]}]
	    }
	}
    }

    unset T
    array set T [array get Q]

    return

}

proc Expe {Texte} {

#    LogExpe $Texte
#    puts $Texte
    return $Texte
    return

}

proc ExplodeUcsc {CoordonneesUCSC} {

	
	# Separe les coordonnees UCSC
	set Chromosome ""
	set Start ""
	set End ""
	set Strand ""
	set Strand [lindex [split $CoordonneesUCSC " "] 1]
	set Chromosome [lindex [split $CoordonneesUCSC ":"] 0]
	set Start [lindex [split [lindex [split [lindex [split $CoordonneesUCSC " "] 0] ":"] 1] "-"] 0]
	set End [lindex [split [lindex [split [lindex [split $CoordonneesUCSC " "] 0] ":"] 1] "-"] 1]
	set Retour "$Chromosome $Start $End"
	return $Retour

}

proc ExploseLeTFAs {FichierTFAs {Dir ""} {Nommage ""} {Ext ""}} {

    if {$Dir ==""} { set Dir "." }
    if {$Nommage==""} { set Nommage "UseFirstWord" }
    regsub {^\.+} $Ext "." Ext
    set LesCrees {}
    foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "" "ForceAccessFirst"] {
	set Nom $Access
	regsub -all -nocase {[^a-z0-9\-\_\+]} $Nom "_" Nom
	set Fic "$Dir/$Nom$Ext"
	set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
	lappend LesCrees [Sauve $TFA dans $Fic]
    }
    return $LesCrees

}

proc Expose {w} {

    global GalerieCourante
    global ExpoCourante

    if {[info exists GalerieCourante]} {
	Colle $w
    } else {
	pack $w -side bottom
    }   

}

proc ExpressionReguliereDesPABs {} {

    global ConfigChargee
    if { ! [info exists ConfigChargee] || ! $ConfigChargee } { return "EXPRESSION_REGULIERE_DES_PABS_NON_VALIDE" }
    return "^[PreFixe]\[0-9\\.\]+"

}

proc ExtDbEntry {Accession} {

    return $Accession

}

proc ExtendFeatTo {to} {

    global NomTextSeq SDG TabSF EFeat Sequences LNOrdali GroupeDeLaSequence
    
    if {$EFeat(LItemSel) == {} } {
	FaireLire "No features items selected !"
	return
    }

    if {[llength $EFeat(LItemSel)] > 1} {
	FaireLire "Beware !\nMultiple Items have been selected !\nPlease selected only ONE item to be propagated !"
	return
    }
    lassign [lindex $EFeat(LItemSel) 0] zones noteRef ft
    if {[llength $zones] > 2} {
	FaireLire "Beware !\nMultiple Items have been selected !\nPlease selected only ONE item to be propagated !"
	return
    }

    # search for the true items inside the selected
    set BonFt [list]
    lassign $zones p1 p2
    lassign [split $p1 .] y x1
    lassign [split $p2 .] y x2
    incr x2 -1
    set nom [lindex $LNOrdali $y-1]
    foreach f [set TabSF($nom,$ft)] {
	DecortiqueUneFeature $f dg fg col sco note csys
	if {$note ne ""} {
	    set nsp ${ft}_[string map [list " " _] $note]
	} else {
	    set nsp ""
	}
	if {$x1 == $dg && $x2 == $fg && $nsp eq $noteRef} {
	    lappend BonFt [list $nom $f]
	}
    }

    # propagation
    # to = 'group' or 'all'
    foreach e $BonFt {
	lassign $e nomRef feat
	if {$to eq "group"} {
	    set gref [set GroupeDeLaSequence($nomRef)]
	} else {
	    set gref GroupeToutLeMonde
	}
	foreach n [set SDG($gref)] {
	    if {$n eq $nomRef} {
		continue
	    }
	    lappend TabSF($n,$ft) $feat
	}
    }

    ChangeFeatureForEditing

    return

}

proc ExtractFirstLinesFromBlast {blast} {

	set lines [split $blast "\n"]
	set out {}
	set i 0
	while { $i < [llength $lines] && ![regexp "Sequences producing significant alignments" [lindex $lines $i]] } {
		incr i
	}
	incr i 2

	while { $i < [llength $lines] && [lindex $lines $i] != "" } {
		lappend out [lindex $lines $i]
		incr i
	}

	return $out

}

proc ExtractFromRefseq {Access Racine Repertoire {Action ""}} {


    set FichierLog "$Repertoire/ExtractFromRefseq$Racine.log" 
    set FichierFof "$Repertoire/ExtractFromRefseq$Racine.fof" 
    set RepSeq     "$Repertoire/sequences$Racine"
    if {[FileAbsent $RepSeq]} {file mkdir $RepSeq}
    set FichierNuc "$RepSeq/$Access.nuctfa"

    if {$Action!="GetDefinition" && [file exists $FichierNuc]} { return "$Access already extracted" }


    set Texte [Getz $Access refseq]
    if {$Texte==""} {
	set Message "$Access was not found"
	AppendAuFichier $FichierLog $Message
	return $Message
    }

    set F  "NoCDSFound"
    set GN "NotFound"
    set OS "UnknownOS"

    set LaDE {}
    set DansDef 0
    foreach Ligne [split $Texte "\n"] {
	if {$DansDef} {
	    if {[regexp {^ +} $Ligne]} {
		set DE [string trim $Ligne]
		lappend LaDE $DE
		continue
	    }
	    set DansDef 0
	}

	if {[regexp "     CDS" $Ligne]} {
	    if {$F!="NoCDSFound"} { continue }
	    regsub -all {[^0-9]} $Ligne " " Limites
	    scan $Limites "%d %d" D F
	    continue
	}
	if {[regexp "/gene=" $Ligne]} {
	    if {$GN!="NotFound"} { continue }
	    set GN [StringApres "/gene=" dans $Ligne]
	    regsub -all {\"} $GN "" GN
	    continue
	}
	if {[regexp {^DEFINITION} $Ligne]} {
	    set DansDef 1
	    set DE [StringSuivant "DEFINITION" dans $Ligne]
	    lappend LaDE $DE
	    continue
	}
	if {[regexp {^ *ORGANISM} $Ligne]} {
	    if {$OS!="UnknownOS"} { continue }
	    set OS [StringSuivant "ORGANISM" dans $Ligne]
	    set OS [string trim $OS]
	    continue
	}
    }
    if {$F=="NoCDSFound"} { 
	set Message "$Access no CDS found"
	AppendAuFichier $FichierLog $Message
	return $Message
    }
    if {$GN=="NootFound"} { set GN $Access }
    set DE [string trim [join $LaDE " "]]
    if {$Action=="GetDefinition"} { return $DE }  
    exit

    set NucSeqTotale [QueLaSequenceADNDuTexteGenbank $Texte]
    set DernierCodon [string range "n$NucSeqTotale" [expr $F-2] $F]]
    if {[CodonStopPossible  $DernierCodon]} { incr F -3 }
    set NucSeq [string range "n$NucSeqTotale" $D $F]
    set ProSeq [SeqNucToSeqPro $NucSeq]

    set GeneName $GN
    if {[regexp {transcript variant ([0-9]+)} $DE Match V]} {
	append GeneName "-V$V"
    }

    set OSDE "$OS $DE"
    if {[regexp "^$OS" $DE]} { set OSDE $DE }
    set Header "$GeneName $OSDE from $Access"
    set N [SequenceFormatTFA $NucSeq $Header nucbrut]
    set P [SequenceFormatTFA $ProSeq $Header protbrut]
    regsub ".nuctfa$" $FichierNuc "" FichierPro
    append FichierPro ".prottfa"
    set FichierProOk [Sauve $P dans $FichierPro]
    set FichierNucOk [Sauve $N dans $FichierNuc]
    AppendAuFichier $FichierFof $FichierNucOk
    return "$GeneName $FichierNucOk"

}

proc ExtractFromRefseqPourTous {Fichier} {

    set Repertoire "/genomics/link/MiRNA"
    set Racine [file tail $Fichier]
    regsub {\.lst} $Racine "" Racine
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" Access
	Espionne "I'll extract $Access"
	set Status [ExtractFromRefseq $Access $Racine $Repertoire]
	Espionne $Status
    }

}

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 "Phenotype" $Table]} { set Table [ValeurDeLaBalise "table" Texte] }
    Espionne [string range $Table 0 100]
    set Entete [ValeurDeLaBalise "tr" Table]
    set LesTetes {}
    while 1 {
	set Tete [ValeurDeLaBalise "th" Entete]
	if {$Tete==""} { break }
	regsub -all {\n}      $Tete "" Tete
	regsub -all {<[^>]+>} $Tete "" Tete
	regsub -all {\&}  $Tete " and " Tete
	regsub -all { +}      $Tete " " Tete
	regsub -all " "       $Tete "_" Tete
	lappend LesTetes $Tete
	Espionne "Tete $Tete"
    }
    set I 0
    while 1 {
	set Ligne [ValeurDeLaBalise "tr" Table]
	if {$Ligne==""} { break }
	foreach Tete $LesTetes {
	    set Valeur [ValeurDeLaBalise "td" Ligne]
	    while {[set B [ProchaineBalise Valeur "" "NePasRogner"]]!=""} {
		set Valeur [ValeurDeLaBalise $B Valeur]
	    }
	    regsub -all "\n" $Valeur " " Valeur
	    regsub -all {]*>} $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 ExtractPartsFromEMBL {Fichier {I ""} {J ""}} {

    global ExtractPartsFromEMBL

    if {$I==""} { set I 0 }
    if {$J==""} { set J 9999999 }

    set LesParts {} 
    while {[info exists ExtractPartsFromEMBL]} {
	if {$ExtractPartsFromEMBL(filename)!=$Fichier || $I=="close" || $ExtractPartsFromEMBL(Vu) >= $I} {
	   catch { close $ExtractPartsFromEMBL(f) }
           unset ExtractPartsFromEMBL
	   if {$I=="close"} { return }
	   break
	}
	set f  $ExtractPartsFromEMBL(f) 
	set Vu $ExtractPartsFromEMBL(Vu)
	break
    }	
    if { ! [info exists ExtractPartsFromEMBL]} {
	set f [open $Fichier "r"]
	set ExtractPartsFromEMBL(f)        $f
	set ExtractPartsFromEMBL(filename) $Fichier
	set Vu -1
    }
    set Prends 0
    set LeCourant {}
    while {[gets $f Ligne]>=0} {
	if {[regexp {^ID   } $Ligne]} {
	    incr Vu 
	    if {$J  < $Vu} { break }
	    if {$Vu < $I } { continue }
	    set Prends 1
	    lappend LeCourant $Ligne
	    continue
	}
	if { ! $Prends } { continue }
	lappend LeCourant $Ligne
	if {[regexp "^//" $Ligne]} {
	    lappend LesParts [join $LeCourant "\n"]
	    set LeCourant {}
	    if {$J == $Vu} { break }
	}
    }
    set ExtractPartsFromEMBL(Vu) $Vu
    return $LesParts

}

proc ExtractPartsFromGenBank {Fichier {I ""} {J ""}} {

    global ExtractPartsFromGenBank

    if {$I==""} { set I 0 }
    if {$J==""} { set J 99999999 }

    set LesParts {} 
    while {[info exists ExtractPartsFromGenBank]} {
	if {$ExtractPartsFromGenBank(filename)!=$Fichier || $I=="close" || $ExtractPartsFromGenBank(Vu) >= $I} {
	   catch { close $ExtractPartsFromGenBank(f) }
           unset ExtractPartsFromGenBank
	   if {$I=="close"} { return }
	   break
	}
	set f  $ExtractPartsFromGenBank(f) 
	set Vu $ExtractPartsFromGenBank(Vu)
	break
    }	
    if { ! [info exists ExtractPartsFromGenBank]} {
	set f [open $Fichier "r"]
	set ExtractPartsFromGenBank(f)        $f
	set ExtractPartsFromGenBank(filename) $Fichier
	set Vu -1
    }
    set Prends 0
    set LeCourant {}
    while {[gets $f Ligne]>=0} {
	if {[regexp {^LOCUS} $Ligne]} {
	    incr Vu 
	    if {$J  < $Vu} { break }
	    if {$Vu < $I } { continue }
	    set Prends 1
	    lappend LeCourant $Ligne
	    continue
	}
	if { ! $Prends } { continue }
	lappend LeCourant $Ligne
	if {[regexp "^//" $Ligne]} {
	    lappend LesParts [join $LeCourant "\n"]
	    set LeCourant {}
	    if {$J == $Vu} { break }
	}
    }
    set ExtractPartsFromGenBank(Vu) $Vu
    return $LesParts

}

proc ExtractRNAFromSeqGivenLoc {seq loc} {

    # treat location
    set loc [string trim [string map [list "(" " " ")" " " ">" "" "<" ""] $loc]]
    set cmpt [regexp -nocase "complement" $loc]
    set lloc [split $loc]
    set df [string map [list ".." " "] [lindex $lloc end]]
    lassign [split $df] deb fin
    incr deb -1
    incr fin -1

    # reversed
    set rev 0
    if {$fin < $deb} {
	set tmp $fin
	set fin $deb
	set deb $tmp
	set rev 1
    }
    set rna [string range $seq $deb $fin]

    if {$cmpt} {
	set rna [ComplementDNA $rna]
	set rna [string reverse $rna]
    }

    puts "d=$deb f=$fin l=[expr {$fin-$deb+1}] | [string range $rna 0 11] [string range $rna end-11 end] $cmpt $rev"

    return $rna

}

proc ExtractRandomLinesFromFile {Fichier N {Seed ""} {Start ""} {Stop ""} {GetWhat ""}} {

    if {$GetWhat==""} { set GetWhat "GetText" }
    set LesLignes [LesLignesDuFichier $Fichier]
    if {$Stop!=""}  { set LesLignes [lrange $LesLignes 0 $Stop] } 
    if {$Start!=""} { set LesLignes [lrange $LesLignes $Start end] } 
    set Size [llength $LesLignes]
    if {$Seed==""} {
	set Seed [expr round(1000 * rand())]
	expr srand($Seed)
    }
    set Selection {}
    while {1} {
	set I [expr round(rand()*$Size)]
	if {[info exists DejaVu($I)]} { continue }
	set DejaVu($I) 1
	set Ligne [lindex $LesLignes $I]
	lappend Selection $Ligne
	if { ! [incr N -1] } { break }
    }
    if {$GetWhat=="GetText"} { return [join $Selection "\n"] }
    return $Selection

}

proc ExtractionDeMaSequenceDuMSF {Nom} {

    set FichierMsf    "[RepertoireDuGenome]/annotation/$Nom.msf.temp"
    set FichierSortie "[RepertoireDuGenome]/annotation/$Nom.msf"
    set SequenceAEnlever [AccessDeMonOrganisme $Nom]
    
    foreach Ligne [LesLignesDuFichier $FichierMsf] {
	if {[regexp $SequenceAEnlever $Ligne]} {continue}
	if {$Ligne == ""} {continue}
	AppendAuFichier $FichierSortie "$Ligne"
    }

}

proc ExtraireCoordonnees {} {


	# A partir d'entete fastA, recupere leds access et interroge GeCo pour avoir les coordonnees
	Espionne "ExtraireCoordonnees: Debut"
	foreach Numero { 16 17 18 19 20 } {
		Espionne "ExtraireCoordonnees: Fichier $Numero"
		set FichierDesEntetes [open "[Fiches]/NonBiDir/NonBidir$Numero.nb" "r"]
		set FichierDesCoordonnees [open "[Fiches]/NonBiDir/NonBidir$Numero.coord" "w"]
		set FichierDesRequetes [open "/tmp/Access.bql" "w"]
		Espionne "ExtraireCoordonnees: Decorticage des Entetes"
		while { [gets $FichierDesEntetes Ligne] >=0 } {
			set Liste [split $Ligne "."]
			set Access [string trim [string range [lindex $Liste 0] 1 10]]
			puts $FichierDesRequetes "ID * DB UCSC"
			puts $FichierDesRequetes "WH SQLNATIVE SELECT access, chrom, txStart, txEnd, strand FROM ucschuman.GeCo WHERE access='$Access' AND pseudogene='no' "
			puts $FichierDesRequetes "LM 1"
			puts $FichierDesRequetes "//"	
		}
		close $FichierDesRequetes
		close $FichierDesEntetes
		Espionne "ExtraireCoordonnees: Recuperation des coordonnees"
		exec /biolo/bird/bin/birdql_client.sh /tmp/Access.bql bird /tmp/Access.res
		Espionne "ExtraireCoordonnees: Ecriture"
		set FichierDesRequetesExecutees [open "/tmp/Access.res" "r"]
		while { [gets $FichierDesRequetesExecutees LigneE] >=0 } {
			ScanLaPipe $LigneE Access Start End Strand
			puts $FichierDesCoordonnees "$Access $Start $End $Strand"
		}
		close $FichierDesRequetesExecutees	
	}	
	Espionne "ExtraireCoordonnees: Fin"


}

proc ExtraireDe {Ligne aNom aDebut aFin aOrient} {

    upvar $aNom    Nom
    upvar $aDebut  Debut
    upvar $aFin    Fin
    upvar $aOrient Orient

    regsub ">" $Ligne "" Ligne
    set nChampsLus [scan $Ligne "%s %d %d %s" Nom Debut Fin Orient]
    if {$nChampsLus == 1} {
	if {[OuiOuNonMemo "I couldn't read 'Debut Fin Orient' reading fiches/bornesdespabs\n Do I use default values 0 999 F ?"]} {
	    set Debut 0
	    set Fin 999
	    set Orient "F"
	} else {
	    if {[OuiOuNon "Do I exit ?"]} { Boum }
	    return 
	}
    }
    if { $nChampsLus == 3 } { 
	set Orient "F"
	if { [expr $Fin < $Debut] } {
	    set Temp  $Debut
	    set Debut $Fin
	    set Fin   $Temp
	    set Orient "R"
	}
    }
    return

}

proc ExtraitAccessDuRNA {Nom} {

    global RepertoireDuGenome
    set RepInfosAuto "$RepertoireDuGenome/InfosAutomatiques"
    set Vu 0
    set Fichier "$RepertoireDuGenome/InfosAutomatiques/$Nom"
    if {![file exists $Fichier]} {return ""}
    foreach Ligne [LesLignesDuFichier "$RepInfosAuto/$Nom"] {
	if {[regexp -nocase "    mRNA\\ " $Ligne]} {
	    set Refsuite [lindex $Ligne 2] 
	    return $Refsuite
	} else {continue}
    }

}

proc ExtraitBornesDesSS {ref} {

    global Sequences ListePDB
    
    set liste {}
    set idx [lsearch -index 0 $ListePDB $ref]
    set n [lindex $ListePDB $idx]
    lassign $n MolCh fnom
    set chn   [DonneChainDeAccessPDB $MolCh]
    set MolId [DonneIdDeAccessPDB $MolCh]
    if {$chn eq ""} {set chn "a"}    
    set nom [BonAccess ${MolId}_$chn]

    global PDB_[set MolId]_SecStr
    
    set SeqAss [set Sequences($nom)]
    
    foreach ss [set PDB_[set MolId]_SecStr($chn)] {
	DecortiqueSS $ss Elt NomChnDep NomResDep NomResFin Rmk
	if {$Elt eq "Coil"} {continue}
	set DebAli [CorrespondancePDBGen $nom $NomResDep]
	set FinAli [CorrespondancePDBGen $nom $NomResFin]

	lappend liste [list $Elt $DebAli $FinAli $NomResDep $NomResFin]
    }

    return $liste

}

proc ExtraitDRDeUniProt {Ll {what EMBL}} {

    set ldr {}
    foreach l $Ll {
	if {[string range $l 0 2] ne "DR "} {
	    continue
	}

	set l [string map {";" ""} $l]
	regsub { +} [string trim $l] " " l
	set le [split $l " "]
	if {[lindex $le 1] ne $what} {continue}
	foreach e [lrange $le 2 end] {
	    if {$e eq "-" || $e eq "ALT_INIT" || $e eq "ALT_SEQ" || $e eq "JOINED"} {
		break
	    }
	    if {$what eq "RefSeq"} {
		if {[string index $e 1] ne "M"} {
		    continue
		} elseif {[string index $e end] eq "."} {
		    set e [string range $e 0 end-1]
		}
	    }
	    lappend ldr $e
	}
    }

    return $ldr

}

proc ExtraitDbRefDuPdb {Lignes chncou} {

    
    set idx -1
    set nmw1 ""
    set nmw2 ""
    foreach l $Lignes {
	if {! [regexp {^DBREF} $l]} {continue}

	set chn [string index $l 12]
	set type [string range $l 26 30]
	set type [string trim $type]
	if {$chn == $chncou && ($type eq "SWS" || $type eq "UNP")} {
	    set nmw1 [string range $l 33 40]
	    set nmw2 [string range $l 42 53]
	    set nmw1 [string trim $nmw1]
	    set nmw2 [string trim $nmw2]
	}
    }
    
    return [list $nmw1 $nmw2]

}

proc ExtraitDefinitionRNADesInfosAutomatiques {Nom RepCollection} {

    set RepertoireDeTravail [RepertoireDuGenome]
    set RepertoireRacine [file dirname $RepertoireDeTravail]
    if {$RepCollection==""} {
	set RepertoireDeTravail $RepertoireDeTravail
    } else {
	set RepertoireDeTravail "$RepertoireRacine/$RepCollection"
    }
    set FichierInfosAuto "$RepertoireDeTravail/InfosAutomatiques/$Nom"
    if {![file exists $FichierInfosAuto]} {return ""}
    set Vu 0
    foreach Ligne [LesLignesDuFichier $FichierInfosAuto] {
	if {[regexp -nocase "    mRNA\\ " $Ligne]} {
	    set Ref [lindex $Ligne 1]
	    set Refsuite [lindex $Ligne 2] 
	    #Espionne $Ref
	    #Espionne $Refsuite
	    set Vu 1
	    continue
	}
	if {$Vu==1 && [regexp -nocase "  DEFINITION:" $Ligne]} {
	    regsub -all "              DEFINITION:" $Ligne "" Ligne
	    return "$Ligne" 
	}
    }

}

proc ExtraitDocDe {file} {


    set Ll [LesLignesDuFichier $file]
    set txt {}
    set deb 0
    foreach l $Ll {
	if {[regexp "" $l]} {break}
	if {! $deb && ! [regexp "
" $l]}  {
	    continue
	} else {
	    set deb 1
	}
	regsub -all "
" $l "" l
	regsub -all "
"  $l "" l
	regsub -all "
" $l "" l
	if {[regexp "
" $l]} {
	    regsub -all "
"  $l "" l
	    regsub -all "
" $l "" l
	    append l "\n"
	}
	if {[regexp "
" $l]} {
	    regsub -all "
"  $l "" l
	    regsub -all "
" $l "" l
	    append l "\n"
	}
	if {[regexp "
" $l]} {
	    regsub -all "
"  $l "" l
	    regsub -all "
" $l "" l
	    append l "\n"
	}
	lappend txt $l
    }

    set letexte [join $txt "\n"]
    puts "file : $file"
    puts $letexte

    return $letexte

}

proc ExtraitDonneesAffymetrix_ActiChip {{AffyResultFile ""} {OutFile ""}} {


    Wup "Permet d extraire les donnees Affymetrix en fonction des genes de ActiChip2"

    set RepAffy "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/"

    if {$AffyResultFile==""} {
	set AffyResultFile "$RepAffy/Partial_Data_GV2.txt"
    }

    set F  [open "$AffyResultFile"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}

	if {[regexp "^Probe" $Ligne]} {
	    lappend LesLignes $Ligne
	    continue
	}
	
	set LigneSplitee [split $Ligne "\t"]
	
	set ProbeSet   [lindex $LigneSplitee 0]
	set  AccGscope [InterrogeActiChip2Affy $ProbeSet AccessGscope]
	if {$AccGscope == ""} {continue}
	
	set Tab($AccGscope) 1
	set LigneSplitee [linsert $LigneSplitee 0 $AccGscope]

	#Espionne "[join $LigneSplitee "\t"]"

	lappend LesLignes [join $LigneSplitee "\t"]
    }
    close $F
    
    foreach PAB [InterrogeActiChip2Affy LesAccessGscope] {
	if {[info exists  Tab($PAB)]} {continue}
	
	lappend LesLignes $PAB
    }

    AppendAuFichier $OutFile "[join $LesLignes "\n"]"

    return ""

}

proc ExtraitDonneesUMCU_ActiChip {{UMCUResultFile ""} {OutFile ""}} {


    Wup "Permet d extraire les donnees UMCU (du fichier .gpr) en tenant compte de ActiChip2." 

    set RepUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU"

    if {$UMCUResultFile==""} {
	set UMCUResultFile "$RepUMCU/Partial_Data_GV2.txt"
    }

    set SurLEntete 1
    set LesLignes ""

    set F  [open "$UMCUResultFile"]
    while {[gets $F Ligne]>=0} {
	if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue}

	if {$SurLEntete} {
	    if {[regexp "^Block" $Ligne] || [regexp "^\"Block\"\t" $Ligne]} {
		#On quitte l entete et on sauve la derniere ligne
		set SurLEntete 0
		
		set LigneSplitee [split $Ligne "\t"]
		set AccGscope "\"AccessGscope\""
		set LigneSplitee  [linsert $LigneSplitee 0 $AccGscope]
		lappend LesLignes [join $LigneSplitee "\t"]
		continue
	    } else {
		#On est toujours sur l entete donc on garde
		lappend LesLignes $Ligne
		continue
	    }
	}
	
	set LigneSplitee [split $Ligne "\t"]
	
	set  UMCU_ID   ""
	set  AccGscope ""
	set  UMCU_ID   [lindex $LigneSplitee 4]
	if {[regexp {\"} $UMCU_ID]} {
	    regsub -all {\"} $UMCU_ID "" UMCU_ID
	}
	if {$UMCU_ID   == ""} {continue}
	set  AccGscope [InterrogeActiChip2UMCU $UMCU_ID AccessGscope]
	#Espionne "$UMCU_ID -- $AccGscope"
	if {$AccGscope == ""} {continue}
	
	set Tab($AccGscope) 1

	set LigneSplitee [linsert $LigneSplitee 0 $AccGscope]

	#Espionne "[join $LigneSplitee "\t"]"

	lappend LesLignes [join $LigneSplitee "\t"]
    }
    close $F
    
    foreach PAB [InterrogeActiChip2UMCU LesAccessGscope] {
	if {[info exists  Tab($PAB)]} {continue}
	lappend LesLignes $PAB
    }

    AppendAuFichier $OutFile "[join $LesLignes "\n"]"

    return ""

}

proc ExtraitDuTableauPresenceAbsence {FichierIni FichierTabFinal FichierSortie} {

    #FichierIni=OVERLAP931NEW/Les33DDcorreles_3_1
    foreach Ligne [LesLignesDuFichier $FichierIni] {
	if {$Ligne==""} {continue}
	set DD $Ligne
	set Vu($DD) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierTabFinal] {
	if {$Ligne==""} {continue}
	set Nom [lindex [split $Ligne "\t"] 0 ]
	if {[info exists Vu($Nom)]} {lappend Liste $Ligne}
    }
    Espionne [llength $Liste]
    SauveLesLignes $Liste dans $FichierSortie

}

proc ExtraitFeatures {Nom {QueryOuGroupeOuAlignement ""} {AvecOuSansOrganismeEtudie ""} {TypeFeature ""}} {

    set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml"
    ParseMACSIMS $Fichier macsims
    if {$QueryOuGroupeOuAlignement == "Query"} {
	set LesSequences $Nom
    }
    if {$QueryOuGroupeOuAlignement == "Groupe"} {
	if {$AvecOuSansOrganismeEtudie == "Sans"} {
	    set LesSequences [LesSequencesDuGroupeMacsims $Nom "Sans"]
	}
	if {$AvecOuSansOrganismeEtudie == ""} {
	    set LesSequences [LesSequencesDuGroupeMacsims $Nom ""]
	}
    }
    if {$QueryOuGroupeOuAlignement == ""} {
	set LesSequences $macsims(Noms)
	if {$AvecOuSansOrganismeEtudie == "Sans"} {
	    set LesSequences [EnleveLaSequenceDeMonOrganisme $Nom $LesSequences]
	}
    }
    set LesFeatures [ExtraitFeaturesDesSequences $Nom $LesSequences $TypeFeature]
    return "$LesFeatures"

}

proc ExtraitFeaturesDesSequences {Nom ListeSequences {TypeDeFeature ""}} {

    set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml"
    ParseMACSIMS $Fichier macsims
    set ListeFeatures {}
    foreach Sequence $ListeSequences {
	set NbFeatures $macsims($Sequence,NbFeatures)
	for {set i 1} {$i <= $NbFeatures} {incr i} {
	    set Type            $macsims($Sequence,Features,$i,Type)
	    set Note            $macsims($Sequence,Features,$i,Note)
	    set LongueurFeature $macsims($Sequence,Features,$i,Longueur)
	    
	    if {$TypeDeFeature == ""} {
		if {[regexp "PFAM" $Type]} {
		    set PFAMTaite [TraitementDesPFAMs $Sequence $Type $Note $LongueurFeature]
		    lappend ListeFeatures $PFAMTaite
		}
		if {[regexp "REGION" $Type] || [regexp "BLOCK" $Type] || [regexp "PHYLOBLOCK" $Type]} {
		    set RegionTraitee [TraitementDesRegionsEtBlocks $Sequence $Type $Note $LongueurFeature]
		    lappend ListeFeatures $RegionTraitee
		}
	    } else {
		if {$TypeDeFeature == $Type} {
		    if {[regexp "PFAM" $Type]} {
			set PFAMTaite [TraitementDesPFAMs $Sequence $Type $Note $LongueurFeature]
			lappend ListeFeatures "$PFAMTaite"
		    }
		    if {[regexp "REGION" $Type] || [regexp "BLOCK" $Type] || [regexp "PHYLOBLOCK" $Type]} {
			set RegionTraitee [TraitementDesRegionsEtBlocks $Sequence $Type $Note $LongueurFeature]
			lappend ListeFeatures "$RegionTraitee"
		    }
		}
	    }
	}
    }
    return $ListeFeatures

}

proc ExtraitGenesDuGlimmer {FichierAdn FichierGlimmer Prefixe Repertoire} {

    # on met x au debut pour avoir une numerotation a partir de 1 (et non pas 0)
    set SeqAdn "x"
    foreach Ligne [LesLignesDuFichier $FichierAdn] {
	if {[regexp ">" $Ligne]} { continue }
	regsub -all -nocase {[^A-Z]} $Ligne "" Ligne 
	append SeqAdn $Ligne
    }

    set LesFichiersCrees {}   
    foreach Ligne [LesLignesDuFichier $FichierGlimmer] {
	scan $Ligne "%d %d %d %s" N Debut Fin Frame
	if {[regexp {\+} $Frame]} { set Orient "F" } else { set Orient "R" }
	set Nom [format "%s%4.4d" $Prefixe $N]
	if {$Debut>$Fin} { set w $Debut; set Debut $Fin; set Fin $w }
	set Sequence [string range $SeqAdn $Debut $Fin]

	#il manque quelque chose ici

	set Long [string length $Sequence]
	set Entete ">$Nom $Debut $Fin $Orient $Long bp"
	set Texte $Entete
	set SeqRestante $Sequence
	while {[set Morceau [string range $SeqRestante 0 59]] != ""} {
	    append Texte "\n$Morceau"
	    set SeqRestante [string range $SeqRestante 60 end]
	}
	set FichierCree "$Repertoire/$Nom"
#	Sauve $Texte dans $FichierCree
	lappend LesFichiersCrees $FichierCree
    }
    return $LesFichiersCrees

}

proc ExtraitHeadDuPDB {LesLignesTmp} {

    
    set head {}
    set i 0
    set iLA1 -1
    set iLA2 -1
    foreach l $LesLignesTmp {
	set IdxAtom [string first "ATOM " $l]
	if {$IdxAtom == -1} {
	    if {[string first "HETATM" $l] != -1} {set iLA1 $i}
	    if {[string first "MSE" $l] != -1} {set iLA2 $i}
	}
	
	if {$IdxAtom == -1 || $IdxAtom > 0} {
	    lappend head $l
	} else {
	    break
	}
	incr i
    }
    
    if {$i == [llength $LesLignesTmp]} {
	if {$iLA1 != -1} {
	    set head [lrange $head 0 [expr {$iLA1-1}]]
	}
    }
    
    return $head

}

proc ExtraitHeadDuPDB2 {LesLignesTmp} {

    
    set head {}
    set IAtm [lsearch -regexp $LesLignesTmp {^ATOM |^HETATM}]
    if {$IAtm == -1} {set IAtm "end"}
    set head [lrange $LesLignesTmp 0 $IAtm]
    
    return $head

}

proc ExtraitIdDuTableau {CompleteId Fichier} {

    if {![file exists $Fichier]} {
	Espionne "$Fichier doesn't exist"
	return ""
    }
    set Id "NoId"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set LaLigne [split $Ligne "\t"]
	if {    ![regexp {^[0-9]} [lindex $LaLigne 0]] } {
	    continue
	} else {
	    if {$CompleteId != [lindex $LaLigne 1]} {
		continue
	    } else {set Id [lindex $LaLigne 2]}
	}  
    }
    while {[regexp " " $Id] } {regsub " " $Id "" Id}
    return $Id

}

proc ExtraitInfo {Nom {Champ ""}} {

    global RepertoireDuGenome
    global ListeDeBoites
    global InfoEnMemoire
    global ListeDesContenuInfo
    global LesInfosRestentSurDisque

    if { ! [regexp -nocase {[a-z]} $Nom]} { return "" }

    if {0 && [info exists LesInfosRestentSurDisque]} {
	if { ! [file exists "$RepertoireDuGenome/infos/$Nom"]} { return "" }
	set Info [ContenuDuFichier "$RepertoireDuGenome/infos/$Nom"]
    } else {
	if { ! [info exists InfoEnMemoire($Nom)]} {
	    if { ! [info exists InfoEnMemoire(Temoin)]} {
		foreach Boite [ListeDeBoites] {
		    if { ! [regexp -nocase {[a-z]} $Boite]} { continue }
		    set FichierInfo "$RepertoireDuGenome/infos/$Boite"
		    if {[file exists $FichierInfo]} {
			set InfoEnMemoire($Boite) [ContenuDuFichier $FichierInfo]
			lappend ListeDesContenuInfo [string toupper [set InfoEnMemoire($Boite)]] 
		    } else {
			lappend ListeDesContenuInfo [string toupper "Nom: $Boite"] 
		    }
		}
		set InfoEnMemoire(Temoin) "Info est charge en memoire"
	    }
	    if {! [info exists InfoEnMemoire($Nom)]} { 
		set FichierInfo "$RepertoireDuGenome/infos/$Nom"
		if {[file exists $FichierInfo]} {
		    set InfoEnMemoire($Nom) [ContenuDuFichier $FichierInfo]
		} else {
		    set InfoEnMemoire($Nom) ""
		}
	    }
	}
	set Info [set InfoEnMemoire($Nom)]
    }

#rR Attention tout est en majuscule si AllInfos
    if {$Nom=="AllInfos"} { return [join $ListeDesContenuInfo "\n"] }

    regsub {\:$} $Champ "" Champ

    if { $Champ == "" } { return $Info }

    set LesValeurs {}
    foreach Ligne [split $Info "\n"] {
	if { ! [regexp -nocase -- "^$Champ\: *" $Ligne] } { continue }
	regsub -nocase -- "^$Champ\: *" $Ligne "" Valeur
	lappend LesValeurs $Valeur
    }
    set Valeur [join $LesValeurs " / "]
    return $Valeur

    set Valeur ""
    set Separateur ""
    foreach Ligne [split $Info "\n"] {
	if {[regexp -nocase -- "^$Champ\:" $Ligne] } {
	    set iValeur [expr [string first ":" $Ligne]+1]
	    append Valeur "${Separateur}[string trim [string range $Ligne $iValeur end]]"
	    set Separateur " / "
	}
    }
    return $Valeur

}

proc ExtraitInfoDeSortieWebDeKEGG {FichierSortieKEGG} {

    set Vu 0
    foreach Ligne [LesLignesDuFichier $FichierSortieKEGG] {
	if {[regexp "\\*" $Ligne]} {
	    #FaireLire $Ligne
	    string trim $Ligne
	    regsub "\\*" $Ligne "" Ligne
	    #FaireLire $Ligne
	    set Pathway $Ligne
	    set Vu 1
	}
	if {[regexp "\t" $Ligne] && $Vu==1} {
	    set GNetc [lindex [split $Ligne "\t"] 1]
	    set GN [lindex [split $GNetc "\; "] 0]
	    #Espionne $GNetc
	    #Espionne $GN
	    set GN [string tolower $GN]
	    set PCA [InterrogeGeneName GeneName $GN LesNoms]
	    #Espionne "pca=$PCA"
	    #lappend L $PCA
	    foreach Nom $PCA {
		lappend Liste "$Nom\t$GN\t$Pathway" 
	    }
	    
	}
    }
    #set L [join $L " "]
    #Espionne [llength $L]
    #set Lu [lsort -unique $L]
    #Espionne [llength $Lu]
    #Espionne [llength $Liste]
    set Lu [lsort -unique $Liste]
    #Espionne [llength $Lu]
    return $Lu

}

proc ExtraitKOZAK {Nom} {

    set AccessRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Mus musculus" "mRNA" Access]
    if {$AccessRNA==""} {return}
    set LesCoord [LesCoordonneesDuCDSDumRNA $AccessRNA]
    if {$LesCoord==""} {return}
    #transcription start site : ATG
    set TSS [lindex $LesCoord 0]
    set FichiermRNAtfa "[RepertoireDuGenome]/mrnatfa_Mus_musculus/$Nom"
    set Kozak [ExtraitPartieDuTfa $FichiermRNAtfa [expr $TSS-9] [expr $TSS+3]]
    return $Kozak

}

proc ExtraitLaNouvelleLocalisationApresReMasking {Nom} {

    global RepertoireDuGenome
    set Fichier "$RepertoireDuGenome/fiches/polylocalise.lesremasques"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s" GscopeCode Loc
	if {$GscopeCode==$Nom} {
	    return $Loc
	    exit
	}
    }

}

proc ExtraitLaProteineDesInfosAutomatiques {Nom RepCollection} {

    set RepertoireDeTravail [RepertoireDuGenome]
    set RepertoireRacine [file dirname $RepertoireDeTravail]
    if {$RepCollection==""} {
	set RepertoireDeTravail $RepertoireDeTravail
    } else {
	set RepertoireDeTravail "$RepertoireRacine/$RepCollection"
    }
    set FichierInfosAuto "$RepertoireDeTravail/InfosAutomatiques/$Nom"
    if {![file exists $FichierInfosAuto]} {return ""}
    set Vu 0
    foreach Ligne [LesLignesDuFichier $FichierInfosAuto] {
	if {[regexp  " PROTEIN\\  " $Ligne]} {
	    #Espionne $Ligne
	    set Ref [lindex $Ligne 1]
	    set Vu 1
	    continue
	}
	if {$Vu==1 && [regexp -nocase "  DEFINITION:" $Ligne]} {
	    regsub -all "           DEFINITION:" $Ligne "" Ligne
	    return "$Ligne"
	}
    }

}

proc ExtraitLeGroupeDesSeqs {id aLGS} {


    global LNOrdali
    upvar $aLGS LeGroupe

    set LeGroupe {}
    set RId [$id documentElement]

    foreach n $LNOrdali {
	set n [string trim $n]
	if {$n eq ""} {continue}
	if {[EstUnAccessPDB $n]} {set n [EnlevePrefixeBank $n]}
	set qds "//*\[string(seq-name)='$n'\]/descendant::*\[name()='group'\]"
	set nds [$RId selectNodes "$qds"]
	if {$nds ne ""} {
	    set d [[lindex $nds 0] selectNodes string(.)]
	    lappend LeGroupe $d
	}
    }

    return $LeGroupe

}

proc ExtraitLes45DuFichierGPO {FichierGPO} {

    set FichierPop "[RepertoireDuGenome]/ANALYSE/GO_45_MA/Les45DD"
    foreach Nom [CreeListePourFichierAUneColonne $FichierPop] {
	set Vu($Nom) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierGPO] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set DD [lindex $LesElts 0]
	if {![info exists Vu($DD)]} {continue} else {lappend L $Ligne}
    }
    #Espionne [llength $L]
    return $L

}

proc ExtraitLesDescriptifs {id aLDes} {


    global LNOrdali
    global TDesDescriptifs

    set TDesDescriptifs {}
    set RId [$id documentElement]

    set TDesDescriptifs {}
    foreach n $LNOrdali {
	set qds "//*\[string(seq-name)='$n'\]/descendant::*\[name()='definition'\]"
	set nds [$RId selectNodes "$qds"]
	if {$nds != ""} {
	    set d [$nds selectNodes string(.)]
	    set TDesDescriptifs($n) $d
	}
    }

    return

}

proc ExtraitLesDonneesUMCU_ActiChip {{Dir ""}} {


    Wup "Permet d extraire les donnees UMCU (du fichier .gpr) en tenant compte de ActiChip2." 

    if {$Dir == ""} {
	set Dir "[RepertoireDuGenome]/Autres_Puces/UMCU"
    }
    
    set LesFichiers [glob -nocomplain -directory "$Dir" "*.gpr"]

    foreach File $LesFichiers {
	set OutFile "$File"
	regsub -nocase ".gpr$" $OutFile "_modified.gpr" OutFile
	ExtraitDonneesUMCU_ActiChip $File $OutFile
    }
    
    return ""

}

proc ExtraitLesDoublons {} {

    set FichierAvecDoublons "/home/carles/genomes/DD2/1432.txt"
    #le fichier est trie  
    set n 0
    set Doublons ""
    set ClonePrecedent ""
    foreach Ligne [LesLignesDuFichier $FichierAvecDoublons] {
	scan $Ligne "%s" Clone
	if {$Clone==$ClonePrecedent} {
	    incr n 
	    append Doublons "$Clone\n"
	}
	set ClonePrecedent $Clone
    }
#Espionne $n
return $Doublons

}

proc ExtraitLesLignesDunFichierPourUneListeDeDD {FichierListeDesDD FichierOuExtraire} {

    #ListeDesDD de la forme: "DD0001 DD0002" par ex
    foreach Nom [CreeListePourFichierAUneColonne $FichierListeDesDD] {
	set Vu($Nom) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierOuExtraire] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set DD [lindex $LesElts 1]
	if {![info exists Vu($DD)]} {continue} else {lappend L $Ligne}
    }
    #Espionne [llength $L]
    return $L

}

proc ExtraitLesLignesDunFichierPourUneListeDonnee {FichierListe FichierOuExtraire FichierSortie} {

    #pour extraire par ex les lignes du fichier loc/best correspondant a une sous liste de noms gscope 
    foreach Nom [CreeListePourFichierAUneColonne $FichierListe] {
	set Vu($Nom) 1
    }
    foreach Ligne [LesLignesDuFichier $FichierOuExtraire] {
	if {$Ligne==""} {continue}
	set LesElts [split $Ligne "\t"]
	set Nom [lindex $LesElts 0]
	if {![info exists Vu($Nom)]} {continue} else {lappend L $Ligne}
    }
    Espionne [llength $L]
    #return $L
    SauveLesLignes $L dans $FichierSortie

}

proc ExtraitLesPoids {id aLWgt} {


    global LNOrdali
    upvar $aLWgt LnonesPoidsDesSeqs

    set LesPoidsDesSeqs {}
    set RId [$id documentElement]

    set LesPoidsDesSeqs {}
    foreach n $LNOrdali {
	set qds "//*\[string(seq-name)='$n'\]/descendant::*\[name()='weight'\]"
	set nds [$RId selectNodes "$qds"]
	if {$nds != ""} {
	    set d [$nds selectNodes string(.)]
	    lappend LesPoidsDesSeqs $d
	}
    }

    return $LesPoidsDesSeqs

}

proc ExtraitLesSeqTFADeLaPageHTMLDeEGAD {CompleteId Id PageHTML {SaveTheSeqTFAFile yes} {RepSeqTFA ""}} {

    if {$RepSeqTFA == ""} {
	set RepSeqTFA [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"]
    } else {
	if {![file exists $RepSeqTFA]} {return ""}
    }

    set SuisJeSurLaSequence 0
    set VoiciLaSeq ""
    set LesLignesDeLaPageHTML [split $PageHTML "\n"]
    foreach Ligne $LesLignesDeLaPageHTML {
	if {[regexp -nocase {[a-z]} $Ligne]} {
	    if {    $SuisJeSurLaSequence &&  ![regexp "protein:" $Ligne] } {
		append VoiciLaSeq "$Ligne\n"
	    }
	    
	    if {[regexp "nucleotide:" $Ligne]} {set SuisJeSurLaSequence 1}
	    
	    if {[regexp "protein:" $Ligne]}    {set SuisJeSurLaSequence 0}
	} else {continue}   

    }
    
    set InitialId "$CompleteId"
    if {$Id != "NoId"} {set CompleteId "$CompleteId : $Id"}

    if {$VoiciLaSeq == "" } {
	set Entete ">$CompleteId No Sequence found in DataBase\!"
	Espionne $Entete
	if {$SaveTheSeqTFAFile == "yes"} {
	    Sauve $Entete dans "$RepSeqTFA/InitialId.tfa"
	}
	return "$Entete"
    }
    
    set Entete ">$CompleteId"
    set SeqTFA [SequenceFormatTFA $VoiciLaSeq $Entete]

    if {$SaveTheSeqTFAFile == "yes"} {
	Sauve $SeqTFA dans "$RepSeqTFA/$InitialId.tfa"
    }
    return $SeqTFA

}

proc ExtraitLesSeqTFADeLaPageHTMLDeGB {CompleteId Id PageHTML {SaveTheSeqTFAFile yes} {RepSeqTFA ""}} {

    if {$RepSeqTFA == ""} {
	set RepSeqTFA [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"]
    } else {
	if {![file exists $RepSeqTFA]} {return ""}
    }

    set InitialId "$CompleteId"
    if {$Id != "NoId"} {set CompleteId "$CompleteId : $Id"}

    set SuisJeSurLaSequence 0
    set VoiciLaSeq ""
    set LesLignesDeLaPageHTML [split $PageHTML "\n"]
    foreach Ligne $LesLignesDeLaPageHTML {
	if {    $SuisJeSurLaSequence  &&  ![regexp "
" $Ligne]&& ![regexp "
" $Ligne]} {
	    append VoiciLaSeq "$Ligne\n"
	}	
	if {[regexp "
" $Ligne]} {
	    set Entete ">$CompleteId"
	    set SuisJeSurLaSequence 1
	}
	if {[regexp "
" $Ligne]} {set SuisJeSurLaSequence 0 }
    } 
    regsub -all -nocase {[^a-z]} $VoiciLaSeq "" VoiciLaSeq
    regsub -all -nocase "\n" $VoiciLaSeq "" VoiciLaSeq

    if {![regexp -nocase {[a-z]} $VoiciLaSeq]} {
	set Entete "$CompleteId No sequence found"

	if {$SaveTheSeqTFAFile == "yes"} {
	    Sauve $Entete dans "$RepSeqTFA/$InitialId.tfa"
	}
	return ""
    }
    set Entete ">$CompleteId"
    set SeqTFA [SequenceFormatTFA $VoiciLaSeq $Entete]
    if {$SaveTheSeqTFAFile == "yes"} {
	Sauve $SeqTFA dans "$RepSeqTFA/$InitialId.tfa"
    }
    return $SeqTFA

}

proc ExtraitLesSeqTFADeLaPageHTMLDeTIGR {CompleteId Id PageHTML {SaveTheSeqTFAFile yes} {RepSeqTFA ""}} {

    if {$RepSeqTFA == ""} {
	set RepSeqTFA [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"]
    } else {
	if {![file exists $RepSeqTFA]} {return ""}
    }

    set InitialId "$CompleteId"
    if {$Id != "NoId"} {set CompleteId "$CompleteId : $Id"}

    set SuisJeSurLaSequence 0
    set VoiciLaSeq ""
    set LesLignesDeLaPageHTML [split $PageHTML "\n"]
    foreach Ligne $LesLignesDeLaPageHTML {
	if { $SuisJeSurLaSequence && [regexp "" $Ligne]} {
	    regsub -all "" $Ligne "" Ligne
	}
	if { $SuisJeSurLaSequence && [regexp "" $Ligne]} {
	    regsub -all "" $Ligne "" Ligne
	}
	if {    $SuisJeSurLaSequence  &&  ![regexp "

" $Ligne] } { append VoiciLaSeq "$Ligne\n" } if {[regexp "

>" $Ligne]} {
	    set Entete ">$CompleteId"
	    set SuisJeSurLaSequence 1
	}
	if {[regexp "

" $Ligne]} {set SuisJeSurLaSequence 0 } } if {$VoiciLaSeq == "" } { set Entete ">$CompleteId No Sequence found in DataBase\!" if {$SaveTheSeqTFAFile == "yes"} { Sauve $Entete dans "$RepSeqTFA/$InitialId.tfa" } return "" } set Entete ">$CompleteId" set VoiciLaSeq [SequenceFormatTFA $VoiciLaSeq $Entete] if {$SaveTheSeqTFAFile == "yes"} { Sauve $VoiciLaSeq dans "$RepSeqTFA/$InitialId.tfa" } return $VoiciLaSeq } proc ExtraitLesSeqTFADeLaPageXMLDeGB {CompleteId Id PageXML {SaveTheSeqTFAFile yes} {RepSeqTFA ""}} { if {$RepSeqTFA == ""} { set RepSeqTFA [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"] } else { if {![file exists $RepSeqTFA]} {return ""} } set Seq [ChercheDansPageXML "IUPACna" $PageXML] if { ! [regexp -nocase {[a-z]} $Seq]} { return "No sequence found" } set InitialId "$CompleteId" if {$Id != "NoId"} {set CompleteId "$CompleteId : $Id"} if {![regexp -nocase {[a-z]} $Seq]} { set Entete "$CompleteId No sequence found" if {$SaveTheSeqTFAFile == "yes"} { Sauve $Entete dans "$RepSeqTFA/$InitialId.tfa" } return "" } set Entete ">$CompleteId" set SeqTFA [SequenceFormatTFA $Seq $Entete] if {$SaveTheSeqTFAFile == "yes"} { Sauve $SeqTFA dans "$RepSeqTFA/$InitialId.tfa" } return $SeqTFA } proc ExtraitLesSeqTFADesFichiersHTML {{FichierTableau ""} {RepHTML ""} {SaveTheSeqTFAFile yes} {RepSeq ""}} { if {$FichierTableau == ""} { set FichierTableau [ButineArborescence All [pwd]] } else { if {![file exists $FichierTableau]} {return ""} } if {$RepHTML == ""} { set RepHTML [ChoisirUnRepertoire "Choose The HTML file directory"] } else { if {![file exists $RepHTML]} {return ""} } if {$RepSeq == ""} { set RepSeq [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"] } else { if {![file exists $RepSeq]} {return ""} } if {$SaveTheSeqTFAFile == "yes"} {set Save "yes"} else {set Save "no"} foreach File [glob -nocomplain "$RepHTML/*.html"] { Espionne "$File in progress" set SeqTFA [ExtraitLesSeqTFADuFichierHTML $File $FichierTableau $Save $RepSeq] } } proc ExtraitLesSeqTFADuFichierHTML {{FichierHTML ""} {FichierTableau ""} {SaveTheSeqTFAFile yes} {RepSeq ""}} { if {$FichierHTML == ""} { set FichierHTML [ButineArborescence All [pwd]] } else { if {![file exists $FichierHTML]} {return ""} } if {$FichierTableau == ""} { set FichierTableau [ButineArborescence All [pwd]] } else { if {![file exists $FichierTableau]} {return ""} } if {$RepSeq == ""} { set RepSeq [ChoisirUnRepertoire "Choose The Saving Directory for the sequence"] } else { if {![file exists $RepSeq]} {return ""} } if {$SaveTheSeqTFAFile=="yes"} {set Save "yes"} else {set Save "no"} set CompleteId [file tail $FichierHTML] regsub ".html" $CompleteId "" CompleteId set Id [ExtraitIdDuTableau $CompleteId $FichierTableau] set PageHTML [ContenuDuFichier "$FichierHTML"] if {[regexp -nocase "ET" $CompleteId]} { ######################EGAD################################## set SeqTFA [ExtraitLesSeqTFADeLaPageHTMLDeEGAD $CompleteId $Id $PageHTML $Save $RepSeq] return "$SeqTFA" } elseif {[regexp -nocase "TC" $CompleteId]} { ######################TIGR############################## if {[regexp -nocase "data could not be found in TIGR" $PageHTML]} { set Entete ">$CompleteId data could not be found in TIGR" if {$Save == "yes"} {Sauve $Entete dans "$RepSeq/$CompleteId.tfa"} return "$Entete" } elseif {[regexp -nocase "It split into" $PageHTML]} { set JusteLeId [CorrigeId $CompleteId] foreach Ligne [split $PageHTML "\n"] { regsub "$JusteLeId" $Ligne "" Ligne while {[regexp "HREF=\"/docs/tigr-scripts/" $Ligne]} { regexp ">(TC\[0-9]*)<" $Ligne tmp NewId regsub "HREF=\"/docs/tigr-scripts/" $Ligne "" Ligne regsub ">(TC\[0-9]*)<" $Ligne "" Ligne lappend AllNewId $NewId } } set Entete ">$CompleteId split into" foreach NewId $AllNewId { append Entete " $NewId" } if {$Save == "yes"} {Sauve $Entete dans "$RepSeq/$CompleteId.tfa"} return "$Entete" } set SeqTFA [ExtraitLesSeqTFADeLaPageHTMLDeTIGR $CompleteId $Id $PageHTML $Save $RepSeq] return $SeqTFA } elseif { [regexp -nocase "AFFX" $CompleteId] || [regexp -nocase "Msa" $CompleteId]} { ######################AFFX et Msa######################## regsub ".html" $FichierHTML ".xml" FichierXML if {[regexp -nocase "The sequence has been intentionally withdrawn" $PageHTML]} { set Entete ">$CompleteId The Sequence has been intentionally withdrawn" if {$Save == "yes"} {Sauve $Entete dans "$RepSeq/$CompleteId.tfa"} return "$Entete" } #set PageXML [ContenuDuFichier "$FichierXML"] set PageHTML [ContenuDuFichier "$FichierHTML"] #set SeqTFA [ExtraitLesSeqTFADeLaPageXMLDeGB $CompleteId $Id $PageXML $Save $RepSeq] #if {$SeqTFA == "No sequence found"} { set SeqTFA [ExtraitLesSeqTFADeLaPageHTMLDeGB $CompleteId $Id $PageHTML $Save $RepSeq] #} return $SeqTFA } else { ######################GB################################ regsub ".html" $FichierHTML ".xml" FichierXML if {[regexp -nocase "The sequence has been intentionally withdrawn" $PageHTML]} { set Entete ">$CompleteId The Sequence has been intentionally withdrawn" if {$Save == "yes"} {Sauve $Entete dans "$RepSeq/$CompleteId.tfa"} return "$Entete" } #set PageXML [ContenuDuFichier "$FichierXML"] set PageHTML [ContenuDuFichier "$FichierHTML"] #set SeqTFA [ExtraitLesSeqTFADeLaPageXMLDeGB $CompleteId $Id $PageXML $Save $RepSeq] #if {$SeqTFA == "No sequence found"} { set SeqTFA [ExtraitLesSeqTFADeLaPageHTMLDeGB $CompleteId $Id $PageHTML $Save $RepSeq] #} return $SeqTFA } } proc ExtraitLesSequencesDuTFAs {FichierTFAs LesAccess} { if {$LesAccess=={}} { return "" } set E [open $FichierTFAs "r"] set LesACCESS "turlututu" foreach Access $LesAccess { set ACCESS [string toupper $Access] set Beau($ACCESS) $Access lappend LesACCESS $ACCESS } lappend LesACCESS "turlututu" set ACCESSES [join $LesACCESS "="] while {[gets $E Ligne]>=0} { if { ! [regexp "^>" $Ligne]} { if { [info exists Courant]} { lappend Sequences($Courant) $Ligne } continue } if {[info exists Courant]} { unset Courant } regsub ">" $Ligne "" LigneSansChevron scan $LigneSansChevron "%s" AccessLu set ACCESSLU [string toupper $AccessLu] if { ! [regexp "=$ACCESSLU=" $ACCESSES]} { continue } set Courant [set Beau($ACCESSLU)] lappend Sequences($Courant) $Ligne } set Sortie {} foreach Access $LesAccess { set ACCESS [string toupper $Access] if {[info exists DejaVu($ACCESS)]} { continue } set DejaVu($ACCESS) 1 if { ! [info exists Sequences($Access)]} { continue } lappend Sortie [join [set Sequences($Access)] "\n"] } return [join $Sortie "\n"] } proc ExtraitLesTFAsDesProbeSet {{FichierAffy ""} {FichierOut ""} {LesProbeSetID ""}} { Wup "Lit et extrait les ProbeSetID des puces Affymetrix au format fasta" Wup "On utilise le fichier .sif de la release Affymetrix d une puce" #/genomics/AffyProbes/Affymetrix/Full/HG-U133_Plus_2-LibFiles/HG-U133_Plus_2.sif #/genomics/AffyProbes/Affymetrix/Full/Mouse430_2/LibFiles/Mouse430_2.sif if {$FichierAffy == "" || $FichierOut == "" || $LesProbeSetID == ""} {return ""} if {[file exists $LesProbeSetID]} { set F [open "$LesProbeSetID"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} scan $Ligne "%s" ProbeSetID set Tab($ProbeSetID) 1 } close $F } else { set LesProbeSetID [split $LesProbeSetID " "] #On charge les sequences a recherchees foreach PSId $LesProbeSetID { set Tab($PSId) 1 } } set ProbeSetIDIDOk 0 set F [open "$FichierAffy"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} #L entete if { [string range $Ligne 0 0] == ">"} { set ProbeSetID "" scan $Ligne "%s" ProbeSetID regsub {\>} $ProbeSetID "" ProbeSetID #Espionne "$ProbeSetID" if {[info exists Tab($ProbeSetID)]} { AppendAuFichier $FichierOut $Ligne set ProbeSetIDIDOk 1 continue } set ProbeSetIDIDOk 0 } #La sequence if {$ProbeSetIDIDOk} { AppendAuFichier $FichierOut $Ligne } set ProbeSetIDIDOk 0 } close $F return "" } proc ExtraitLesTaxId {id aLTax} { global LesSequencesAssocieesClassesCanon global LNOrdali upvar $aLTax LesTaxId set LesTaxId {} set RId [$id documentElement] set LesSequencesAssocieesClassesCanon(eukaryota) {} set LesSequencesAssocieesClassesCanon(bacteria) {} set LesSequencesAssocieesClassesCanon(archaea) {} set LesSequencesAssocieesClassesCanon(viruses) {} set LesSequencesAssocieesClassesCanon(undefined) {} set LClass [list eukaryota archaea bacteria viruses] foreach n $LNOrdali { if {[regexp {^[0-9]} $n]} {continue} set tid "" set qds "//*\[string(seq-name)='$n'\]/descendant::*\[name()='lifedomain'\]" set nds [$RId selectNodes "$qds"] if {$nds != ""} { set tid [string tolower [$nds selectNodes string(.)]] if {[lsearch $LClass $tid] == -1 || $tid == ""} {set tid "undefined"} lappend LesTaxId ${tid} lappend LesSequencesAssocieesClassesCanon($tid) $n } else { lappend LesTaxId "undefined" lappend LesSequencesAssocieesClassesCanon(undefined) $n } } return $LesTaxId } proc ExtraitLignesAtomesDuPDB {LesLignesTmp} { set LesLignes {} # NMR structure --> PREND 1er MODELE !! set lafin "END" set idx [lsearch -regexp $LesLignesTmp "EXPDTA"] if {$idx != -1} { set ya [string first "NMR" [lindex $LesLignesTmp $idx]] if {$ya != -1} {set lafin "ENDMDL"} } # lit les atomes foreach l $LesLignesTmp { if {[regexp "^${lafin}" $l]} {break} # if {[regexp {^TER} $l]} {continue} if {[regexp {^ATOM|^HETATM|^TER} $l]} {lappend LesLignes $l} } if {[llength $LesLignes] == 0} { FaireLire "I can't find the ATOM record in your PDB file !!" } return $LesLignes } proc ExtraitListeDeListe {l n} { set nl [list] foreach e $l { lappend nl [lindex $e $n] } return $nl } proc ExtraitListeItemFeatures {id aLItFeat} { upvar $aLItFeat ListeItemFeatures set RId [$id documentElement] set LNoeudFeatures [$RId selectNodes //fitem/*] foreach n $LNoeudFeatures { set f [$n selectNodes name(.)] lappend ListeItemFeatures $f } set ListeItemFeatures [lsort -unique $ListeItemFeatures] return $ListeItemFeatures } proc ExtraitListeTypesFeatures {id aLFeat} { upvar $aLFeat ListeTypesFeatures set RId [$id documentElement] set LNoeudFeatures [$RId selectNodes //ftype] foreach n $LNoeudFeatures { set f [$n selectNodes string(.)] lappend ListeTypesFeatures $f } set ListeTypesFeatures [lsort -unique $ListeTypesFeatures] return $ListeTypesFeatures } proc ExtraitMesGOInterressants {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set Liste [split $Ligne "\} \{"] EspionneL $Liste } set MesGOs "" set MesIPRs "" foreach element $Liste { if {[regexp "GO:" $element]} {lappend MesGOs $element} if {[regexp "IPR" $element]} {lappend MesIPRs $element} } EspionneL $MesGOs EspionneL $MesIPRs return "" } proc ExtraitNoDuGroupe {a} { if {$a == ""} {return -1} set i -1 set isnb 0 while {! $isnb && $i < [string length $a]} { incr i set isnb [string is integer [string index $a $i]] } if {$isnb} { return [string range $a $i end] } else { return -1 } } proc ExtraitOligoDuTFA {PAB Oligo {Dir ""}} { Wup "Pour recuperer la sequence tfa de l oligo du PAB voulu" set Fichier "$Dir/${PAB}.oligo" if {! [file exists $Fichier]} { set Fichier "$Dir/$PAB" if {! [file exists $Fichier]} {return ""} } set MonTFAOligo "" set JeLaTiens 0 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} { continue } if { [string range $Ligne 0 0] == ">"} { if {! [regexp -nocase $Oligo $Ligne]} {continue} lappend MonTFAOligo $Ligne set JeLaTiens 1 continue } if {! $JeLaTiens} {continue} lappend MonTFAOligo $Ligne break } close $F return $MonTFAOligo } proc ExtraitOligoDuTFA2 {PAB Oligo {Dir ""} {Fichier ""}} { Wup "Pour recuperer la sequence tfa de l oligo du PAB voulu" if {$Fichier ==""} { set Fichier "$Dir/${PAB}.oligo" } else { set Fichier "$Dir/$Fichier" } if {! [file exists $Fichier]} { set Fichier "$Dir/$PAB" if {! [file exists $Fichier]} {return ""} } set MonTFAOligo "" set JeLaTiens 0 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} { continue } if { [string range $Ligne 0 0] == ">"} { if {! [regexp -nocase $Oligo $Ligne]} {continue} lappend MonTFAOligo $Ligne set JeLaTiens 1 continue } if {! $JeLaTiens} {continue} lappend MonTFAOligo $Ligne break } close $F return $MonTFAOligo } proc ExtraitPartieDuTfa {FichierTfa {Debut ""} {Fin ""}} { #attention au debut #string range commence a 0 set QueLaSequence [QueLaSequenceDuTFA $FichierTfa] set SequenceExtraite [string range $QueLaSequence [expr $Debut-1] [expr $Fin-1]] return $SequenceExtraite } proc ExtraitRNADeRefSeqXML {Lxml refseq prot} { set rna "" if {0} { set f [open toto w] puts $f $Lxml #$doc asXML -channel $f close $f } global TParser set TParser(S) {} set TParser(inKey) 0 set TParser(target) $prot set TParser(readV) 0 set TParser(seq) "" set TParser(loc) "" set p [expat -elementstartcommand Prsel -characterdatacommand Prsch -elementendcommand Prsee ] if [catch {$p parse $Lxml} res] { puts "ERROR while parsing XML ! " puts "$res" return "" } if {$TParser(seq) ne "" && $TParser(loc) ne ""} { puts "[string range $TParser(seq) 0 10] $TParser(loc)" set rna [ExtractRNAFromSeqGivenLoc $TParser(seq) $TParser(loc)] } else { set rna "" } unset -nocomplain TParser return $rna } proc ExtraitRadicalDuGroupe {a} { set i -1 set pasnb 0 while {! $pasnb} { incr i set pasnb [regexp {[0-9]} [string index $a $i]] } set ea [string range $a 0 [expr {$i-1}]] return $ea } proc ExtraitSecStrucDuPDB {Fichier {mol TRUC}} { set MolId [DonneIdDeAccessPDB $mol] set chn [DonneChainDeAccessPDB $mol] if {$chn eq ""} {set chn "a"} global PDB_[set MolId]_SecStr global PDB_[set MolId]_SSBin global PDB_[set MolId]_Header global PDB_[set MolId]_ChnIdn set LesLignes [set PDB_[set MolId]_Header] foreach chn [set PDB_[set MolId]_ChnIdn] { set ssbh [string repeat "0" [LongueurAlignement]] set ssbs [string repeat "0" [LongueurAlignement]] set SStmp {} set lhelix "PasBon" foreach l $LesLignes { set t [string range $l 0 4] switch $t { "HELIX" {set lhelix [LitHelixDansPDB $l $chn]} "SHEET" {set lhelix [LitSheetDansPDB $l $chn]} "TURN " {set lhelix [LitTurnDansPDB $l $chn]} default {continue} } if {$lhelix eq "PasBon"} {continue} set ss [OteLesBlancsEnTrop $lhelix] DecortiqueSS $ss Elmt NomChnDep NomResDep NomResFin Rmk set DebAli [CorrespondancePDBGen $mol $NomResDep] set FinAli [CorrespondancePDBGen $mol $NomResFin] lappend SStmp $ss switch $Elmt { "Alpha" { set ssbh [MetDesUnsDansSS $ssbh $DebAli $FinAli] } "Sheet" { set ssbs [MetDesUnsDansSS $ssbs $DebAli $FinAli] } } } set SStmp [lsort -integer -index 4 $SStmp] set SStmp [CombleSSParCoil $SStmp $MolId $chn] set PDB_[set MolId]_SecStr($chn) $SStmp set PDB_[set MolId]_SSBin($chn) $ssbh lappend PDB_[set MolId]_SSBin($chn) $ssbs } return } proc ExtraitSeqEtStrDuPdb {Fichier name {SeqPdb ""}} { global LNOrdali Sequences OrdTmpDir Defauts set cherchemaxcc 0 set VerifChn 0 set MolId [DonneIdDeAccessPDB $name] set chn [DonneChainDeAccessPDB $name] if {[regexp {[a-z]} $chn] || $chn eq ""} { set VerifChn 1 } if {[string trim $chn] eq ""} {set chn "a"} set rep [DecortiqueUnPDB $Fichier $MolId] if {! $rep} { if {[ModeI]} { FaireLire "Problem with PDB file !" } return 0 } global PDB_[set MolId]_NomRes1l global PDB_[set MolId]_ChnIdn global PDB_[set MolId]_Sequence set LesChaines [set PDB_${MolId}_ChnIdn] foreach cc $LesChaines { if {[lsearch [array names PDB_[set MolId]_NomRes1l] $cc] == -1} { set idx [lsearch [set PDB_[set MolId]_ChnIdn] $cc] set PDB_[set MolId]_ChnIdn [lreplace [set PDB_[set MolId]_ChnIdn] $idx $idx] } } set LesChaines [set PDB_[set MolId]_ChnIdn] if {$VerifChn} { if {[lsearch $LesChaines $chn] == -1} { FaireLire "Can't find chain $chn in pdb file $MolId !" return 0 } } set str [join [set PDB_[set MolId]_NomRes1l($chn)] ""] set PDB_[set MolId]_Sequence($chn) $str return 1 } proc ExtraitSiteActifDuPDB {lignes} { set ncou "" set lsite {} foreach l $lignes { set l " $l" if {[string range $l 1 6] != "SITE "} {continue} # site name set ns [string trim [string range $l 12 14]] if {$ns != $ncou} { if {$ncou != ""} { set site($ncou) $lsite set lsite {} } } foreach i {0 1 2 3} { set p [expr {$i * 11}] set nm$i [string range $l 19+$p 21+$p] set ch$i [string range $l 23+$p 23+$p] set rn$i [string range $l 24+$p 27+$p] set rn$i [string trim [set rn$i]] if {[set rn$i] ne ""} { lappend lsite [set rn$i] [set ch$i] [set nm$i] } } set ncou $ns } if {$lsite != {} } {set site($ncou) $lsite} set ltab {} if {[info exists site]} {set ltab [array get site]} return $ltab } proc ExtraitSourceFromRefSeqPXML {Lxml {deb 0}} { set src [ValeurDeLaBalise "Textseq-id_accession" Lxml] if {[regexp -nocase {^.(M|C|W|Z)_} $src]} { return $src } else { return "" } set rep "" if {$sdb ne ""} { set rep [$sdb selectNode string(.)] } if {$deb} { set f [open pxml w] $Id asXML -channel $f close $f } $Id delete return $rep } proc ExtraitTable {type} { global OrdEtcDir set file [file join $OrdEtcDir "table_couleurs.dat"] set LesLignes [LesLignesDuFichier $file] if {$type eq "seqlab"} {set type "Protein"} set type ">$type" set idx1 [lsearch $LesLignes $type] set sear [expr {$idx1+1}] set idx2 [lsearch -regexp [lrange $LesLignes $sear end] ">"] if {$idx2 == -1} {set idx2 end} return [lrange $LesLignes $sear $idx2] } proc ExtraitTouteInfo {Nom} { return [ExtraitInfo $Nom] } proc ExtraitYDesPos {liste} { foreach {p1 p2} $liste { lassign $p1 y x lappend ly $y } return $ly } proc ExtraitmRNADesInfosAutomatiques {Nom} { global RepertoireDuGenome set RepInfosAuto "$RepertoireDuGenome/InfosAutomatiques" if {![file exists $RepInfosAuto]} {return ""} set Vu 0 foreach Ligne [LesLignesDuFichier "$RepInfosAuto/$Nom"] { if {[regexp -nocase " mRNA\\ " $Ligne]} { set Ref [lindex $Ligne 1] set Refsuite [lindex $Ligne 2] set Vu 1 continue } if {$Vu==1 && [regexp -nocase " DEFINITION:" $Ligne]} { regsub -all " DEFINITION:" $Ligne "" Ligne return "$Ref $Refsuite $Ligne" } } } proc EyePos {} { global pgl if {$::eyepos eq "zero"} { set pgl(eyeZ) $::Rad set ::eyepos "rad" } else { set pgl(eyeZ) 0. set ::eyepos "zero" } update Update3DMatrices $::pgl(wogl) postredisplay return } proc FDeX {args} { if {$args == ""} {return} #Ini X1 Y1 X2 Y2 #Calc X #unset global aDeLEquationLineaire bDeLEquationLineaire set PremierArg [lindex $args 0] if {[string equal -nocase $PremierArg "ini"]} { set X1 [lindex $args 1] set Y1 [lindex $args 2] set X2 [lindex $args 3] set Y2 [lindex $args 4] set aDeLEquationLineaire [expr ($Y2 - $Y1) * 1.0 / ($X2 - $X1)] set bDeLEquationLineaire [expr $Y1 - $aDeLEquationLineaire * $X1] return [list $aDeLEquationLineaire $bDeLEquationLineaire] } if {![info exists aDeLEquationLineaire]} {return} if {![info exists bDeLEquationLineaire]} {return} if {[string equal -nocase $PremierArg "Calc"]} { set X [lindex $args 1] return [expr $aDeLEquationLineaire * $X + $bDeLEquationLineaire] } if {[string equal -nocase $PremierArg "unset"]} { unset aDeLEquationLineaire unset bDeLEquationLineaire } return } proc FNduLNgcg {N} { return [SNvsLNgcg $N fn] } proc FNduSNgcg {N} { return [SNvsLNgcg $N fn] } proc FOFtoTFAs {FichierDeNomsDeFichier {UseFilename ""}} { return [LOFtoTFAs [LesLignesDuFichier $FichierDeNomsDeFichier]] } proc FabriqueDeTables {stab {db ""} {fdb ""} {add 0} {drop 0}} { global OrdTmpDir if {$fdb eq "memory"} { set fdb ":memory:" } if {! $add && ! $drop} { if {$fdb ne ""} { if {[file exists $fdb]} { file delete -force $fdb } } } else { if {! [file exists $fdb]} { FaireLire "File $fdb does not exists !" return } } if {$db eq ""} { set db "rootDB_[pid]_[clock scan now]" } sqlite3 $db $fdb set Lignes [split $stab "\n"] foreach elt $Lignes { set e [string trim $elt] set pC [string index $e 0] # comment line if {$e eq "" || $pC eq "#"} { continue } elseif {$pC eq "-"} { set Luniq [list] set nom [StringApres "-" dans $e] } elseif {$pC eq "\}"} { if {$drop} { $db eval "drop table if exists $nom" } set cmd "create table $nom (" set virgule 0 foreach {c tp} $Lcle { set openp 0 set Ltype [split $tp ""] CheckGoodDBType $Ltype set Lgt [llength $Ltype] foreach telt $Ltype { switch -regexp -- $telt { "P" { if {$Lgt == 1} { set type "INTEGER PRIMARY KEY" } else { append type " PRIMARY KEY" } } "I" {set type "INTEGER"} "T" {set type "TEXT"} "R" {set type "REAL"} "V" { set type "VARCHAR(" set openp 1 } {[0-9]} { append type $telt } "F" {append type " FOREIGN KEY"} "U" {lappend Luniq $c} } } if {$openp} { append type ")" set openp 0 } if {! $virgule} { append cmd "$c $type" set virgule 1 } else { append cmd ", $c $type" } } if {$Luniq != {} } { append cmd ", unique ([join $Luniq ,])" } append cmd ")" update idletasks $db eval "$cmd" set cmd "" set Lcle {} } elseif {$pC eq "."} { set cle [StringApres "." dans $e] set type [StringApres "$cle" dans $e] lappend Lcle $cle $type } } return $db } proc FacesDuCube {c a1 b1 c1 d1 a2 b2 c2 d2} { # Face haut glBegin GL_QUADS glColor4f {*}$c set n [NormaleDe $a1 $b1 $c1] glNormal3fv $n glVertex3fv $a1 glVertex3fv $b1 glVertex3fv $c1 glVertex3fv $d1 # Face bas glColor4f {*}$c set n [NormaleDe $a1 $c2 $b2] glNormal3fv $n glVertex3fv $a2 glVertex3fv $b2 glVertex3fv $c2 glVertex3fv $d2 glColor4f {*}$c set n [NormaleDe $a1 $b1 $c1] glNormal3fv $n glVertex3fv $a1 glVertex3fv $b1 glVertex3fv $b2 glVertex3fv $a2 glColor4f {*}$c set n [NormaleDe $b1 $c1 $b2] glNormal3fv $n glVertex3fv $b1 glVertex3fv $c1 glVertex3fv $c2 glVertex3fv $b2 glColor4f {*}$c set n [NormaleDe $c1 $d1 $d2] glNormal3fv $n glVertex3fv $c1 glVertex3fv $d1 glVertex3fv $d2 glVertex3fv $c2 glColor4f {*}$c set n [NormaleDe $d1 $a1 $a2] glNormal3fv $n glVertex3fv $d1 glVertex3fv $a1 glVertex3fv $a2 glVertex3fv $d2 glEnd return } proc Factoriel {n} { if {165 < $n} {return 1e+300} if {$n < 20} { set NFact $n for {set i 2} {$i < $n} {incr i} {set NFact [expr $NFact * $i]} } else { set e 2.718 set pi 3.141592 set NFact [expr sqrt(2*$pi*$n)*pow($n*1.0/$e,$n)] } return $NFact } proc FaireAFaire {{CeQuIlFautFaire ""}} { global FichierAFaire global FichierDejaFait if {$CeQuIlFautFaire == ""} { set AFaire [LesLignesDuFichier $FichierAFaire] } else { set AFaire $CeQuIlFautFaire } foreach Ligne $AFaire { if {[regexp "^Log " $Ligne]} { regsub "^Log " $Ligne "" Texte if {[catch {eval set Texte $Texte} Message]} { AppendAuFichier $FichierDejaFait "WscopeServerError >" AppendAuFichier $FichierDejaFait "$Message" AppendAuFichier $FichierDejaFait "< WscopeServerError" } else { AppendAuFichier $FichierDejaFait $Texte } AppendAuFichier $FichierDejaFait $Ligne continue } if {[catch {eval $Ligne} Message]} { AppendAuFichier $FichierDejaFait "WscopeServerError >" AppendAuFichier $FichierDejaFait "$Message" AppendAuFichier $FichierDejaFait "< WscopeServerError" } AppendAuFichier $FichierDejaFait $Ligne } if {$CeQuIlFautFaire == ""} { File delete $FichierAFaire } } proc FaireAttendre {tx {AvecPB 0}} { global tcl_platform TFAt Defauts FAPG if {! [ModeI] && ! $Defauts(MarcheForcee)} {return} if {[info exists TFAt(WtLabel)]} { lappend TFAt(WtMsg) [$TFAt(WtLabel) cget -text] lappend TFAt(WithPB) [winfo ismapped $TFAt(WtPbar)] $TFAt(WtLabel) configure -text $tx if {$AvecPB} { grid .fattendre.f.pbar -row 1 -column 0 -sticky ew -padx 10 -pady {1 10} .fattendre.f.pbar start } else { grid forget .fattendre.f.pbar } update idletasks return } set TFAt(oldFocus) [focus] set w .fattendre toplevel $w wm title $w "Please Wait ..." wm protocol $w WM_DELETE_WINDOW KillParLaCroix wm attributes $w -topmost 1 wm resizable $w 0 0 # wm overrideredirect $w 1 if {$tcl_platform(platform) eq "macintosh"} { unsupported1 style $w dBoxProc } set FAPG 0. set TFAt(Top) $w set TFAt(WtLabel) ".fattendre.f.label" set TFAt(WtPbar) ".fattendre.f.pbar" frame $w.f label $w.f.label -background cyan -justify left -anchor nw -text $tx ttk::progressbar $w.f.pbar -variable FAPG grid $w.f.label -row 0 -column 0 -sticky news -padx 10 -pady {10 5} grid $w.f.pbar -row 1 -column 0 -sticky ew -padx 10 -pady {0 10} grid rowconfig $w.f 0 -weight 1 -minsize 0 grid columnconfig $w.f all -weight 1 -minsize 0 grid $w.f -row 0 -column 0 -sticky news grid columnconfig $w all -weight 1 grid rowconfig $w all -weight 1 if {"FontFAtt" ni [font names]} { set fdef [$w.f.label cget -font] set fml [font configure $fdef -family] set size [font configure $fdef -size] font create FontFAtt -family $fml -size $size } $w.f.label configure -font FontFAtt if {! $AvecPB} { grid forget $w.f.pbar $w.f.pbar stop } else { $w.f.pbar start } update idletasks bind $w {raise [winfo toplevel %W] ; wm attributes [winfo toplevel %W] -topmost} FenetreAuCentre $w set TFAt(oldGrab) [grab current $w] if {$TFAt(oldGrab) ne ""} { set TFAt(grabStatus) [grab status $TFAt(oldGrab)] } else { set TFAt(grabStatus) "" } grab $w focus $w MesCouleurs $w raise $w update idletasks return } proc FaireAttendreAnnaick {w ti tx} { Wup "Permet de faire attendre le user pendant que le prog travaille" Wup "Fait apparaitre une boite de dialogue pour dire ce qui se passe" global oldGrab global oldFocus global grabStatus catch {destroy $w} toplevel $w wm title $w $ti if {[winfo viewable [winfo toplevel [winfo parent $w]]] } { wm transient $w [winfo toplevel [winfo parent $w]] } label $w.label -background red -text $tx -justify left pack $w.label -padx 10 -pady 10 wm withdraw $w set x [expr {[winfo screenwidth $w]/2 - [winfo reqwidth $w]/2 - [winfo vrootx [winfo parent $w]]}] set y [expr {[winfo screenheight $w]/2 - [winfo reqheight $w]/2 - [winfo vrooty [winfo parent $w]]}] wm geom $w +$x+$y wm deiconify $w update idletasks set oldFocus [focus] set oldGrab [grab current $w] if {[string compare $oldGrab ""]} { set grabStatus [grab status $oldGrab] } grab $w focus $w #update idletasks update #tkwait visibility $w.label return "" } proc FaireLaSuite {{w ""}} { global TFAt Defauts if {! [ModeI] && ! $Defauts(MarcheForcee)} {return} if {[info exists TFAt(WtMsg)]} { $TFAt(WtLabel) configure -text [lindex $TFAt(WtMsg) end] if {[lindex $TFAt(WithPB) end]} { grid .fattendre.f.pbar -row 1 -column 0 -sticky news -padx 10 -pady {1 10} .fattendre.f.pbar start } else { grid forget .fattendre.f.pbar } set TFAt(WtMsg) [lreplace $TFAt(WtMsg) end end] set TFAt(WithPB) [lreplace $TFAt(WithPB) end end] if {! [llength $TFAt(WtMsg)]} { array unset TFAt "WtMsg" array unset TFAt "WithPB" } update return } wm protocol .fattendre WM_DELETE_WINDOW "" if {[winfo exists TFAt(oldFocus)]} { focus $TFAt(oldFocus) } else { array unset TFAt oldFocus } destroy .fattendre if {$TFAt(oldGrab) ne ""} { if {$TFAt(grabStatus) ne "global"} { catch {grab $TFAt(oldGrab)} } else { catch {grab -global $TFAt(oldGrab)} } } unset TFAt update idletasks return } proc FaireLaSuiteAnnaick {w} { Wup "Permet de faire attendre le user pendant que le prog travaille" Wup "Fait diapparaitre la boite de dialogue et remet le focus sur la precedente fenetre" global oldGrab global oldFocus global grabStatus catch {focus $oldFocus} catch {destroy $w} if {[string compare $oldGrab ""]} { if {[string compare $grabStatus "global"]} { catch {grab $oldGrab} } else { catch {grab -global $oldGrab} } } update idletasks return "" } proc FaireLesToiles {} { set FichierToilesAFaire "[Fiches]/ToilesAFaire.txt" set Liste [LesLignesDuFichier "[Fiches]/ToilesAFaire.txt"] FaireLire "I'll create the jpg for $Liste\n After creation please verify and delete $FichierToilesAFaire" CreeLesToilesPourTous $Liste if {[OuiOuNon "Do I delete $FichierToilesAFaire ?"]} { file delete $FichierToilesAFaire } } proc FaireLire {Message {Force ""}} { global FaireLireNon if {[info commands "PourWscope"]!={} && [info commands "OnTraite"]!={} && [PourWscope] && [OnTraite "RetGene"]} { return [AfficheVariable $Message] } set Force [regexp -nocase "1|Force" $Force] if { ! $Force && [info exists FaireLireNon] && $FaireLireNon} { return } if {[string length $Message] > 1500} { set Message "[string range $Message 0 499]\n ... \n ... [string range $Message end-499 end]" } package require Tk #rR 2014/08/13 rajout de NomDe set FL [NomDe faireLire] after idle [list $FL.msg configure -wraplength 10i -foreground white -background red] tk_dialog $FL "Please press OK" "$Message" {} 0 Acknowledge catch {destroy $FL} update } proc FaireSavoir {{Texte ""} {Titre ""}} { Wup "Petite boite de dialogue qui attend sa reponse sans bloquer tout le monde" Wup "Permet de retourner qq chose mais ne peut etre lance plusieurs fois car vwait fait attendre le suivant" global NomDeRetour set w [NomDe fenetre] if {$Titre==""} {set Titre $w} toplevel $w wm geometry $w +300+100 wm title $w "$Titre" wm resizable $w false false wm protocol $w WM_DELETE_WINDOW "destroy $w" if {[string length $Texte] > 1000} { set Texte "[string range $Texte 0 499]\n ... \n ... [string range $Texte end-499 end]" } set frameLabel "$w.framelabel" set frameButton "$w.framebutton" set Label "$frameLabel.label" set Button "$frameButton.b" frame $frameLabel -borderwidth "3" -relief "flat" -pady "2" -padx "10" frame $frameButton -borderwidth "3" -relief "flat" -pady "2" -padx "10" label $Label -borderwidth "1" -relief "flat" -pady "4" -padx "5" -background "red" -text "$Texte" -wraplength "10i" -justify left -font "Courier -12 bold" button $Button -text "Ok" -command "set NomDeRetour($w) $w" # button $Button -text "Ok" -command " # set w \[winfo toplevel $Button\]; # set NomDeRetour(\$w) \$w; # set Retour \[set NomDeRetour(\$w)\]; # unset NomDeRetour(\$w); # after 10 destroy \$w; # return 1" pack $frameLabel -fill both -expand true pack $frameButton -fill both -expand true pack $Label -fill x -side top -expand true pack $Button -side top vwait NomDeRetour($w) if {[info exists NomDeRetour($w)]} { set Retour [set NomDeRetour($w)] unset NomDeRetour($w) } else { set Retour "" } destroy $w return $Retour } proc FaireSavoir_Multi {{Texte ""} {Titre ""}} { Wup "Petite boite de dialogue qui attend sa reponse sans bloquer tout le monde" Wup "Attention permet de le lancer plusieurs fois en meme temps mais pas de return sous Windows" global NomDeRetour set w [NomDe fenetre] if {$Titre==""} {set Titre $w} toplevel $w wm geometry $w +300+100 wm title $w "$Titre" wm resizable $w false false wm protocol $w WM_DELETE_WINDOW "after 10 destroy $w" if {[string length $Texte] > 1000} { set Texte "[string range $Texte 0 499]\n ... \n ... [string range $Texte end-499 end]" } set frameLabel "$w.framelabel" set frameButton "$w.framebutton" set Label "$frameLabel.label" set Button "$frameButton.b" frame $frameLabel -borderwidth "3" -relief "flat" -pady "2" -padx "10" frame $frameButton -borderwidth "3" -relief "flat" -pady "2" -padx "10" label $Label -borderwidth "1" -relief "flat" -pady "4" -padx "5" -background "red" -text "$Texte" -wraplength "10i" -justify left -font "Courier -12 bold" button $Button -text "Ok" -command "eval \[wm protocol $w WM_DELETE_WINDOW\]" pack $frameLabel -fill both -expand true pack $frameButton -fill both -expand true pack $Label -fill x -side top -expand true pack $Button -side top return "$w" } proc FaireStopVMD {} { global CanalV global ListeTypeDeFeatures global clients sock catch {close $sock} catch {unset clients($sock)} catch {close $CanalV} catch {unset CanalV} trace remove variable ListeTypeDeFeatures write UpdateVMDFeatures return } proc FaitACP {} { global ListeScore set nlgn [llength $ListeScore] set ncol [llength [lindex $ListeScore 0]] set X "2 $nlgn $ncol" foreach l $ListeScore { foreach e $l { lappend X $e } } EspionneL $X nist_pca $X exit } proc FaitArbreEtData {} { global VODep LitRef set VODep [info globals] foreach s [ListeDesPABs] { puts "Traite $s" DataPourItol $s ClearVar } exit } proc FaitLignesA60 {s} { set rep "" set D 0 while {$D < [string length $s]} { set F [expr {$D + 59}] set Linit [string range $s $D $F] set L [string map [list Z - . -] $Linit] append rep "$L\n" incr D 60 } return $rep } proc FaitSuperposition {{Init 0}} { global StrucAVoir EquivalenceZone ListePDB ZoneSuperposition LNOrdali LSOrdali if {[ModeI]} { FinSuper } if {! [info exists StrucAVoir] || $Init} { ChoixPlusieursPDB } if {[llength $StrucAVoir] == 0} { return } unset -nocomplain EquivalenceZone # Verifie que les bornes des zones a superposees # existent dans les differents pdb set Nsup [VerifieZonesSuperposition] if {$Nsup < 3} { if {$Nsup == 0} { set txt "No zone" } else { set txt "Too few atomes" } FaireLire "Beware !! $txt defined to superpose structures !!" return } # Zones verified # zones in general coords. if {[llength $StrucAVoir] == 1} { set molref $StrucAVoir } else { if {[ModeI]} { set molref [ChoixPDBReference] } else { set molref [lindex $StrucAVoir 0] } } if {$molref == -1} {return} FaireAttendre "Please wait ...\nSuperposing structures ..." # Met le referent en debut de liste set i [lsearch $StrucAVoir $molref] set StrucAVoir [lreplace $StrucAVoir $i $i] set StrucAVoir [linsert $StrucAVoir 0 $molref] # Associe zone superposition en coord. generales # aux zones en coord. PDB foreach mol $StrucAVoir { set spdb [BonNomPDB $mol] set MolId [DonneIdDeAccessPDB $mol] set chn [DonneChainDeAccessPDB $mol] # boucle sur zone. # Exclue prot qui ont pas la zone foreach z $ZoneSuperposition { lassign $z x1 x2 Exc if {$mol in $Exc} { lappend EquivalenceZone($mol) "exclue" } else { lappend EquivalenceZone($mol) [list [list [DonnePosGS $spdb $x1] [DonnePosGS $spdb $x2]] $chn $spdb $Exc $x1 $x2] } } } # ecrit au Log AuLog @begin table AuLog @title Superposition zones AuLog @begin tabular AuLog @titlecols [list molecules "positions ranges"] lappend ligne "pos. alignment" foreach z [set EquivalenceZone($molref)] { set x1 [lindex $z 4] set x2 [lindex $z 5] set chn [lindex $z 1] set cx1 [string trim "$chn$x1"] set cx2 [string trim "$chn$x2"] lappend ligne "$cx1-$cx2" } AuLog @row $ligne foreach m [array names EquivalenceZone] { set ligne [list $m] foreach z [set EquivalenceZone($m)] { if {[lsearch [lindex $z 0] "exclue"] != -1} { lappend ligne "Discarded" } else { set x1 [lindex [lindex $z 0] 0] set x2 [lindex [lindex $z 0] 1] set chn [lindex $z 1] if {$chn == "a"} {set chn " "} set cx1 [string trim "$chn$x1"] set cx2 [string trim "$chn$x2"] lappend ligne "$cx1-$cx2" } } AuLog @row $ligne } AuLog @end AuLog @end # Do superposition SuperAvecOrdali AppliqueSuperposition FaireLaSuite return } proc FaitTaxSelection {} { global db LModelId Tx LTaxSelected TaxRoot LUserId LSelectableId set LTaxSelected [list] # check ... set Lsel [list] foreach id $LSelectableId { if {$Tx(NbKeep,$id) > 0} { lappend Lsel $id } } set LTaxSelected $Lsel # Add model organisms if required if {$Tx(-addmodel)} { puts "\nAdd Models : TaxRoot $TaxRoot" foreach m $LModelId { if {$TaxRoot in [DonneGenealogieMem $m]} { lappend LTaxSelected $m } } } set LTaxSelected [lsort -unique -integer $LTaxSelected] puts "Selected TaxIds : [llength $LTaxSelected]" puts "-----------------" foreach i $LTaxSelected { puts "[format %7d $i] | $Tx(Rank,$i) $Tx(Name,$i)" foreach a [DonneGenealogieMem $i] { set Tx(Etat,$a) 1 } set Tx(Etat,$i) -1 } return } proc FaitTracage {what} { global TypeRep DListCou pgl TSList Rad RadMol Rc LesVecs mol set TypeRep $what set w $pgl(wogl) if {[info exists TSList($what)]} { set DListCou [set TSList($what)] set Rad [set Rc($what)] } else { switch $what { "ribbon" { if {$LesVecs == {} } {return} set TSList($what) [glGenLists 1] set DListCou [set TSList($what)] glNewList [set TSList($what)] GL_COMPILE use_light glBegin GL_TRIANGLES set k 0 foreach {v1 v2 v3} $LesVecs { glNormal3fv $v1 light_color3f {*}$v2 glVertex3fv $v3 if {$k < 3} { puts [format "v1 %8.3f %8.3f %8.3f" {*}$v1] puts [format "v3 %8.3f %8.3f %8.3f" {*}$v3] puts "" incr k } } glEnd set Rad $RadMol set Rc($what) $RadMol } "stick" { set TSList($what) [glGenLists 1] set DListCou [set TSList($what)] glNewList [set TSList($what)] GL_COMPILE CalculeStick [set TSList($what)] $mol set Rad $RadMol set Rc($what) $RadMol } "fildefer" { set TSList($what) [glGenLists 1] set DListCou [set TSList($what)] glNewList [set TSList($what)] GL_COMPILE CalculeFilDeFer [set TSList($what)] $mol set Rad $RadMol set Rc($what) $RadMol } "benjilamalice" { use_light set pgl(xCen) 0.0 set pgl(yCen) 0.0 set pgl(zCen) 0.0 set Rc($what) 2. set Rad 2. set TSList($what) [glGenLists 1] set DListCou [set TSList($what)] glNewList [set TSList($what)] GL_COMPILE_AND_EXECUTE BenjiLaMalice trace puts "j'ai fait la benji experience !" } } glEndList } Update3DMatrices $pgl(wogl) postredisplay return } proc FaitTrieListe {} { lappend LesLignes "Chr2 9963 10526 1" lappend LesLignes "Chr1 15963 16526 1" lappend LesLignes "Chr1 10963 12526 1" lappend LesLignes "Chr1 14963 15526 1" lappend LesLignes "Chr1 20963 21526 1" lappend LesLignes "Chr2 12596 13526 1" lappend LesLignes "Chr2 15423 16526 1" set LesLignes [lsort -command TrieList -increasing $LesLignes] return $LesLignes } proc FamiliarOrganism {Genre {Espece ""}} { global FamiliarOrganism global RepertoireDuGenome if {$Espece==""} { set O $Genre } else { set O "$Genre $Espece" } if {[info exists FamiliarOrganism($O)]} { return [set FamiliarOrganism($O)] } set Orga [Glossaire $O Complet] if {$Orga==""} { set Orga $O } if {[info exists FamiliarOrganism($Orga)]} { return [set FamiliarOrganism($Orga)] } if {[info exists FamiliarOrganism ]} { return [set FamiliarOrganism("NotFound")] } set Fichier "$RepertoireDuGenome/fiches/familiar_organism" if {[file exists $Fichier]} { Wup "We do it first for the most common used" foreach G [LesGenomesComplets] { set C [Glossaire $G Court] set FamiliarOrganism($G) 0 set FamiliarOrganism($C) 0 } set FamiliarOrganism(LaListeMerci) {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } if {[regexp {^ *\#} $Ligne]} { continue } set OrgaLu [string trim $Ligne] if {[Glossaire $OrgaLu Court]==""} { if {[regexp -nocase {^ERROR} [set Bon [Tax $OrgaLu "Name"]]]} { FaireLire "For familiar organism\nI don't know the organism \n$OrgaLu\n I'll skip it" continue } set OrgaLu $Bon } lappend FamiliarOrganism(LaListeMerci) $OrgaLu set FamiliarOrganism($OrgaLu) 1 set FamiliarOrganism([Glossaire $OrgaLu Court]) 1 } set FamiliarOrganism("NotFound") 0 return [FamiliarOrganism $O] } set LaFamille {} while {[OuiOuNon "Do You want to define 'Familiar Organisms' ?"]} { if {[OuiOuNon "Do You want to copy or link an other 'FamiliarOrganism' file ?"]} { set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."] if {$Autre==""} { continue } if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} { exec ln -s $Autre $Fichier } elseif {[OuiOuNon "Do I copy it ?"]} { File copy $Autre $Fichier } return [FamiliarOrganism $O] } set LaFamille [ChoixDesPresents [LesGenomesComplets]] set Other "" while {[OuiOuNon "Do You want to add other organisms to the familiar organisms list ?" 0]} { set Other [Entre $Other] set BonOther [Glossaire $Other Complet] if {$BonOther==""} { FaireLire "I don't know the organism $Other" } else { lappend LaFamille $BonOther } } if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break } } if {$LaFamille=={}} { if { ! [OuiOuNon "Do You want to save 'Familiar Organisms' as an empty list ?"]} { set FamiliarOrganism("NotFound") 0 set FamiliarOrganism(LaListeMerci) {} return [FamiliarOrganism $O] } } SauveLesLignes $LaFamille dans $Fichier return [FamiliarOrganism $O] } proc FamiliarOrganismsInMSF {Nom} { set Nom [file tail $Nom] set FichierMSF "[RepertoireDuGenome]/msf/$Nom" DecortiqueUnMSF $FichierMSF LesAccess set LesAccessInteressants {} foreach Access $LesAccess { set TaxIds [TaxIdDuAccess $Access $Nom] if {$TaxIds==""} { continue } foreach TaxId [split $TaxIds " "] { if {$TaxId==""} { continue } if {[FamiliarTaxId $TaxId]} { lappend LesAccessInteressants $Access break } } } return $LesAccessInteressants } proc FamiliarTaxId {TaxId {Quoi ""}} { global FamiliarTaxId if {$Quoi==""} { set Quoi "Test" } if {[info exists FamiliarTaxId($TaxId,$Quoi)]} { return [set FamiliarTaxId($TaxId,$Quoi)] } if {[info exists FamiliarTaxId("TaxIdEstCharge")]} { return 0 } set FamiliarTaxId("TaxIdEstCharge") 1 set FichierFOWTI "[RepertoireDuGenome]/fiches/familiar_organism_with_taxid" while { ! [file exists $FichierFOWTI]} { if { ! [OuiOuNon "Can I create the file\n$FichierFOWTI\nusing familiar_organism ?"]} {return 0} TaxIdOfFamiliarOrganisms } foreach Ligne [LesLignesDuFichier $FichierFOWTI] { scan $Ligne "%s %s %d" G E OX set FamiliarTaxId($OX,All) $Ligne set FamiliarTaxId($OX,Test) 1 lappend FamiliarTaxId(LaListeMerci,Test) $Ligne } return [FamiliarTaxId $TaxId $Quoi] } proc Family {Nom} { return [ExtraitInfo $Nom "Family"] } proc Fantome {Nom} { set Valeur [ExtraitInfo $Nom "Fantome"] if { $Valeur == "" } { return 0 } if {[regexp -nocase -- "oui" $Valeur]} { return 1 } else { return 0 } } proc Fantomise {Nom {Ordre ""}} { global InformeSansDemander if {$Ordre=="Ask"} { Informe $Nom "Fantome: oui " return [Fantome $Nom] } if {[regexp "ParDecret" $Ordre]} { InformeSansDemander $Nom "Fantome: oui $Ordre date [Date Nice]" return $Ordre } set Raison "" set NCops [NombreDeCopainsDansBlast $Nom] if {$NCops>3} { return "" } if {$NCops==0} { append Raison " NoOrtholog" } if {[regexp "AloneIsEnough" $Ordre] && [regexp "NoOrtholog" $Raison]} { set Rapport "$Ordre $Raison" InformeSansDemander $Nom "Fantome: oui $Rapport" return $Rapport } set Ovl [Overlap $Nom] foreach Zone [LesZonesEnOverlap $Nom] { scan $Zone "%d %d %d %s" P D F Voisin if {[Fantome $Voisin]} { continue } if {$NCops >= [NombreDeCopainsDansBlast $Voisin]} { continue } if {$P > 98} { append Raison "FullOverlapedByBetterORF" break } if {$P > 90} { append Raison "OverlapedByBetterORF" break } } if {[regexp "Alone" $Ordre] && [regexp "NoOrtholog" $Raison] && [regexp "FullOverlapedByBetterORF" $Raison]} { set Rapport "$Ordre $Raison" PositionneEtInforme $Nom "" "SansInforme" Informe $Nom "Fantome: oui $Rapport" return $Rapport } if {[regexp "Alone" $Ordre] && [regexp "NoOrtholog" $Raison] && [regexp "OverlapedByBetterORF" $Raison]} { set Rapport "$Ordre $Raison" PositionneEtInforme $Nom "" "SansInforme" Informe $Nom "Fantome: oui $Rapport" return $Rapport } foreach Multiple [LesZonesEnOverlapMultiple $Nom] { scan $Multiple "%d %d %d" P D F if {$P > 75} { append Raison "OverlapedBySetOfORFs" break } } if {[regexp "AloneAndOverlapedBySetOfORFs" $Ordre] && [regexp "NoOrtholog" $Raison] && [regexp "OverlapedBySetOfORFs" $Raison]} { set Rapport "$Ordre $Raison" PositionneEtInforme $Nom "" "SansInforme" Informe $Nom "Fantome: oui $Rapport" return $Rapport } if {[regexp "LessThan3Orthologs" $Ordre] && [NombreDeCopainsDansBlast $Nom] < 3 && [regexp "FullOverlapedByBetterORF" $Raison]} { append Raison "LessThan3Orthologs" set Rapport "$Ordre $Raison" PositionneEtInforme $Nom "" "SansInforme" Informe $Nom "Fantome: oui $Rapport" return $Rapport } return "" } proc FantomisePourTous {{Ordre ""} {CommenceIci ""}} { set Moi [FrappeQuUnCoup $CommenceIci "set"] if {$Ordre==""} { set LesChoix [list "Ask" "" "Ask for each" "AloneIsEnough" "" "All orf without ortholog become Ghost is ENOUGH" "AloneAndOverlapedByBetter" "" "All orf without ortholog become Ghost if OVERLAPED by better orf" "AloneAndOverlapedBySetOfORFs" "" "All orf without ortholog become Ghost if OVERLAPED by a set of better orfs"] set Ordre [ChoixParmiJoliDansListe $LesChoix] } foreach Nom [ListeDesPABs] { if {[FrappeQuUnCoup $Nom $Moi] } { continue } if {[Fantome $Nom]} { continue } set Status [Fantomise $Nom $Ordre] if {[JArreteDeBosser $Moi]} { return "JArreteDeBosser" } if {$Status==""} { continue } Espionne "$Nom $Status" } } proc Fard {K X Y} { global TypeFard global KanvaAColorer set Nom [Box [BoiteDuCourant $K $X $Y] nom] set KanvaAColorer $K set Couleur [CouleurParTypeEtNom [set TypeFard($K)] $Nom $K] unset KanvaAColorer return $Couleur } proc FastAllStar {} { array set tableau [readFasta "/genomics/link/STAF/Raphael/RaphaelAllSequences.tfa"] foreach Entete $tableau(index) { set fh [open "/genomics/link/STAF/Raphael/$Entete.tfa" w] puts $fh [formatFasta $tableau($Entete,header) $tableau($Entete,sequence) 60] close $fh } } proc FastMEExe {} { global tcl_platform global OrdBinDir global env if {[info exists env(GRILLE)] && $env(GRILLE)} { return "./fastme" } if {[set tcl_platform(platform)] != "windows"} { if {[info exists OrdBinDir]} { return [file join $OrdBinDir "fastme"] } else { return "/biolo/fastme/bin/fastme" } } else { set lexe [file join $OrdBinDir "fastme.exe"] regsub "Program Files" $lexe "PROGRA~1" lexe return $lexe } } proc FastaCmd {LesAcc {Complet ""} {AvecAffichage 1} {Banque ""}} { Wup "Pour les access unigene on recupere la definition par fastacmd" #Il faudrait mettre un defaut commme genbank par exemple set Results "" foreach Acc $LesAcc { if { [regexp "UG:Hs" $Acc]} { set CommandeFastaCmd "fastacmd -d unigenehs -s $Acc" } elseif {[regexp "RSHUM:" $Acc]} { set CommandeFastaCmd "fastacmd -d rshuman -s $Acc" } elseif {$Banque != ""} { set CommandeFastaCmd "fastacmd -d $Banque -s $Acc" } else { set CommandeFastaCmd "" #Espionne "Default fastacmd pour $Acc" continue } if {$CommandeFastaCmd==""} {continue} set FastaCmdOut "" if {[catch {set FastaCmdOut [eval exec $CommandeFastaCmd]} Message]} { #Espionne "$Message" } if {![info exists FastaCmdOut]} {continue} if {$FastaCmdOut == ""} {set FastaCmdOut "No Result for $Acc"} if {$Complet == ""} { lappend Results [lindex [split $FastaCmdOut "\n"] 0] } else {lappend Results $FastaCmdOut} } if {$AvecAffichage} { return "[AfficheVariable [join $Results "\n"] "AvecFormateAvecBlaste" "FastaCmd search result"]" } else { return "[join $Results "\n"]" } } proc FastaCmd_Affymetrix {Acc {Complet ""}} { Wup "Pour les access presents dans Affymetrix on recupere la definition par fastacmd" set RepAffy "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/" set RepBanque "$RepAffy/Banque_Blast" set CommandeFastaCmd "fastacmd -d \"$RepBanque/HG-U133A_2\" -s $Acc" set FastaCmdOut "" catch {set FastaCmdOut [eval exec $CommandeFastaCmd]} Message if {! [info exists FastaCmdOut]} {return ""} if {$FastaCmdOut==""} {set FastaCmdOut "No Result for $Acc"} if {$Complet ==""} { lappend Results [lindex [split $FastaCmdOut "\n"] 0] } else {lappend Results $FastaCmdOut} return "[AfficheVariable [join $Results "\n"] "AvecFormateAvecBlaste"]" } proc FastaCmd_Ontario {LesAcc {Complet ""}} { Wup "Pour les access presents dans EST on recupere la definition par fastacmd" #set CommandeFastaCmd "fastacmd -d \"[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/Banque_Blast/HG-U133A_2\" -s $Acc" set CommandeFastaCmd "fastacmd -d EST_Chips -s $Acc" set FastaCmdOut "" catch {set FastaCmdOut [eval exec $CommandeFastaCmd]} Message if {! [info exists FastaCmdOut]} {return ""} if {$FastaCmdOut==""} {set FastaCmdOut "No Result for $Acc"} if {$Complet ==""} { lappend Results [lindex [split $FastaCmdOut "\n"] 0] } else {lappend Results $FastaCmdOut} return "[AfficheVariable [join $Results "\n"] "AvecFormateAvecBlaste"]" } proc FastaCmd_UMCU {LesAcc {Complet ""}} { Wup "Pour les access presents dans UMCU on recupere la definition par fastacmd" set CommandeFastaCmd "fastacmd -d UMCU_HUMANV2 -s $Acc" set FastaCmdOut "" catch {set FastaCmdOut [eval exec $CommandeFastaCmd]} Message if {! [info exists FastaCmdOut]} {return ""} if {$FastaCmdOut==""} {set FastaCmdOut "No Result for $Acc"} if {$Complet ==""} { lappend Results [lindex [split $FastaCmdOut "\n"] 0] } else {lappend Results $FastaCmdOut} return "[AfficheVariable [join $Results "\n"] "AvecFormateAvecBlaste"]" } proc FastaForBlast {{Qui ""} {Quoi ""} {FastaFile ""} {NewFastaFile ""}} { global FastaForBlast set RemovePipeFromHeader [OuiOuNon "Do I replace >sp|ac|id with >ID AC" 0 ] #rR on lit le fichier fasta fourni par Uniprot et si RemeovePipeFromHeader on modifie sp|ac|id en SPT:ID AC #rR on rajoute aussi OX=9606 en fin d'entete (attentio avant j'avais OX: ... !) #rR les statistiques peuvent se faire apres création du nouveau fasta avec StatFromFasta ci-dessous set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {$Qui=="-"} { set Qui "" } if {$Quoi=="-"} { set Quoi "" } if {$FastaFile!=""} { if {[info exists FastaForBlast(FASTAFILE,)]} { if {$FastaForBlast(FASTAFILE,)!=$FastaFile} { unset FastaForBlast } } set FastaFileToSet $FastaFile set NewFastaFileToSet $NewFastaFile } if {[info exists FastaForBlast($Qui,$Quoi)]} { return $FastaForBlast($Qui,$Quoi) } if {[info exists FastaForBlast("EstCharge")]} { if {[info exists FastaForBlast($Qui,ID)]} { set ID [string toupper $FastaForBlast($Qui,ID)] if {[info exists FastaForBlast($ID,$Quoi)]} { return $FastaForBlast($ID,$Quoi) } } if {[info exists FastaForBlast($Qui,TAXID)]} { set TID $FastaForBlast($Qui,TAXID) if {[info exists FastaForBlast($TID,$Quoi)]} { return $FastaForBlast($TID,$Quoi) } } return "" } if { ! [info exists FastaFileToSet]} { FaireLire "Please give the name of the FastaFile" return "" } set FastaForBlast(FASTAFILE,) $FastaFileToSet set FastaForBlast(NEWFASTAFILE,) $NewFastaFileToSet set FastaForBlast("EstCharge") 1 set FastaFile $FastaForBlast(FASTAFILE,) set Queue [file tail $FastaFile] set OnGarde 1 set LeTFAACreer {} set FlushSize 10000 set iFlush 0 set DejaStocke 0 if {$FastaForBlast(NEWFASTAFILE,)==""} { set CreateNew 0 } else { set CreateNew 1 if {[file exists $FastaForBlast(NEWFASTAFILE,)]} { if {[OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I overwrite"]} { file delete $FastaForBlast(NEWFASTAFILE,) } else { if { ! [OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I append"]} { return "" } } } } set MaxiPourTestons -10000 ;#rR 100 pour limité, -100 pour illimité set F [open $FastaForBlast(FASTAFILE,) "r"] while {1} { set OnBreak [expr [gets $F Ligne] < 0 ] if { ! $OnBreak } { regsub -all " +" $Ligne " " Ligne set Ligne [string trim $Ligne] if {$Ligne==""} { continue } #rR dans sequence if { ! [regexp "^>" $Ligne]} { lappend LeTFAACreer $Ligne continue } } #rR on a un chevron #rR on traite d'abord le précédent if {[info exists Courant]} { if {$OnGarde} { if {[incr MaxiPourTestons -1]==0} { set OnBreak 1 } set ID [string toupper $Id] set COURANT [string toupper $Courant] lappend FastaForBlast(LISTOF,IDS) $Id lappend FastaForBlast(LISTOF,ACS) $Ac lappend FastaForBlast($MemoTaxId,IDS) $Id lappend FastaForBlast($MemoTaxId,ACS) $Ac if { ! $CreateNew} { #set FastaForBlast($COURANT,TFA) [join $LeTFACourant "\n"] set FastaForBlast($ID,ID) $Id set FastaForBlast($ID,AC) $Ac set FastaForBlast($ID,TAXID) $MemoTaxId } incr iFlush if {$CreateNew && ($iFlush>=$FlushSize || ($iFlush>0 && $OnBreak))} { AppendAuFichier $FastaForBlast(NEWFASTAFILE,) [join $LeTFAACreer "\n"] incr DejaStocke $iFlush Espionne "$DejaStocke sequences already done." set LeTFAACreer {} set iFlush 0 } } } if {$OnBreak} { break } #rR on traite l'entête if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} { FaireLire "pas bon $Ligne" lappend LeNew $Ligne continue } set TexteTaxId "" if {[regexp {\|} $Ligne]} { #rR on espere >Banque|Ac|Id Definition... (attention à l'ordre) set ResteDeLaLigne "" regexp {^>([^ ]+) (.+)} $Ligne Match BAI ResteDeLaLigne set Banque "" set Ac "" set Id "" lassign [split $BAI "|"] Banque Ac Id if {$Ac==""} { set Ac $BAI } if {$Id==""} { set Id $Ac } if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } } else { #rR on espere >Banque:Id Ac Definition... (Attention à l'ordre Id avant Ac) set Banque "" set Id "" set Ac "" set ResteDeLaLigne "" regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac ResteDeLaLigne if {[regexp {([^\:]+)\:(.+)} $Id Match B I]} { set Banque $B set Id $I } if {$Ac==""} { set Ac $Id } if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } } set TexteBanque "" # on laisse comme c'est if {[string equal -nocase "sp" $Banque]} { set Banque "SW" } # on laisse comme c'est if {[string equal -nocase "tr" $Banque]} { set Banque "TR" } #rR supprimé 20160708 *************************************************** if {$Banque!=""} { set TexteBanque "$Banque:" } set Gn "" regexp {GN=([^ ]+)} $Ligne Match Gn set TextGn "" if {$Gn!=""} { set TextGn " GN=$Gn" } set FullOs "Unknown unknown" if {[regexp { OS=(.+)} $Ligne Match FullOsWithJunk]} { regsub {[A-Z][A-Z]=.*} $FullOsWithJunk "" FullOs set FullOs [string trim $FullOs] } set TexteTaxId "" set TaxId [TaxParQdsMemo $FullOs] if {$TaxId!=""} { lappend LesTaxId $TaxId set TexteTaxId " OX=$TaxId" set FastaForBlast($TaxId,FULLOS) $FullOs } if {$RemovePipeFromHeader} { set Entete ">$TexteBanque$Id $Ac $ResteDeLaLigne$TexteTaxId" } else { set Entete "$Ligne$TexteTaxId" } lappend LeTFAACreer $Entete set Courant $Id set COURANT [string toupper $Courant] set MemoTaxId $TaxId set ID [string toupper $Id] set AC [string toupper $Ac] if { ! $CreateNew} { if {$ID!=$AC} { set FastaForBlast($AC,ID) $ID } set FastaForBlast($ID,FULLOS) $FullOs } set FULLOS [string toupper $FullOs] set FastaForBlast($FULLOS,TAXID) $TaxId } set LesTaxId [lsort -unique $LesTaxId] set FastaForBlast(LISTOF,TAXID) $LesTaxId foreach TaxId $LesTaxId { if { ! [info exists FastaForBlast($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } set FullOs $FastaForBlast($TaxId,FULLOS) lappend FastaForBlast(LISTOF,FULLOS) "$FullOs" lappend FastaForBlast(LISTOF,TAXIDOS) "${TaxId}_$FullOs" set nOK [llength $FastaForBlast($TaxId,IDS)] lappend FastaForBlast(LISTOF,COUNT) "$nOK $TaxId $FullOs" } set FastaForBlast(LISTOF,TAXID) [join $FastaForBlast(LISTOF,TAXID) "\n"] set FastaForBlast(LISTOF,TAXIDOS) [join $FastaForBlast(LISTOF,TAXIDOS) "\n"] set FastaForBlast(LISTOF,FULLOS) [join $FastaForBlast(LISTOF,FULLOS) "\n"] set FastaForBlast(LISTOF,COUNT) [join $FastaForBlast(LISTOF,COUNT) "\n"] if {$CreateNew} { set FichierStat "$FastaForBlast(NEWFASTAFILE,).stat" set FastaForBlast(STAT,FILENAME) [Sauve $FastaForBlast(LISTOF,COUNT) dans $FichierStat] } return [FastaForBlast $Qui $Quoi] } proc FastaLineWidth {{W ""}} { global FastaLineWidth set Default 60 if {$W!=""} { set FastaLineWidth $W } if {[regexp -nocase "Default" $W]} { set FastaLineWidth $Default } if { ! [info exists FastaLineWidth]} { set FastaLineWidth $Default } return $FastaLineWidth } proc FastaMARegionExtractionThroughMAF {FastaMAFile Ordered_ProjectedMAFFile RefSeqFile DMA FMA} { ### Extrait un ali fasta de la region definie par DQ et FQ ### #RefSeqFile == File containing the Reference Sequence for the MAF File #puts "DQ: $DQ ; FQ: $FQ ; DMA: $DMA ; FMA: $FMA" set ReducedFastaMAFile "$FastaMAFile\_$DMA\_$FMA.tfaMAreduced" Maf2fasta $RefSeqFile $Ordered_ProjectedMAFFile $ReducedFastaMAFile fasta $DMA $FMA] return $ReducedFastaMAFile } proc FastaN {FichierTFA {FichierTFAOuBanque human} {FichierFasta ""} {Expect 0.001} {m 0} {N ""} {AddOpt ""}} { if {![file exists $FichierTFA]} {return ""} if { [string equal -nocase $FichierTFAOuBanque "genbank"]} { set Banque "%B" } elseif {[string equal -nocase $FichierTFAOuBanque "genembl"]} { set Banque "%B" } elseif {[string equal -nocase $FichierTFAOuBanque "est" ]} { set Banque "%C" } elseif {[string equal -nocase $FichierTFAOuBanque "genomes"]} { set Banque "%E" } elseif {[string equal -nocase $FichierTFAOuBanque "human" ]} { set Banque "%F" } elseif {[file exists $FichierTFAOuBanque]} { set Banque $FichierTFAOuBanque } else { set Banque "$FichierTFAOuBanque 12" } set NomFichier [file tail $FichierTFA] if {$FichierFasta == ""} {set FichierFasta "$FichierTFA.fastan"} Espionne "$FichierTFA against $FichierTFAOuBanque DataBase : $Banque" if {$N != ""} { set ParN "-N $N" } else { set ParN "" } set CommandeFastaN "exec /gcg/extensions/bin/fasta_t -z 0 -H -E $Expect -m $m $AddOpt $ParN -O $FichierFasta -q $FichierTFA \"$Banque\"" #eval $CommandeFastaN if {![catch {eval $CommandeFastaN} Message]} {Espionne $Message} return $FichierFasta } proc FastaNAvecAffichage {FichierTFA {FichierTFAOuBanque human} {FichierFasta ""} {Expect 0.001} {m 0} {N ""}} { set Fichier [FastaN $FichierTFA $FichierTFAOuBanque $FichierFasta $Expect $N $m] Espionne "$FichierTFA displaying ..." AfficheVariable [ContenuDuFichier $Fichier] AvecSegAlignement $Fichier return $Fichier } proc FastaNToBlastN {FichierFasta FichierBlast} { set MaxLongNomSbjct 39 if {![file exists $FichierFasta]} {return ""} set SuisJeSurLEnteteDeFasta 1 set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaDescriptionDeLaBanque 0 set SuisJeSurLEnteteDesSequences 0 set SuisJeSurLaDescriptionDeLAlignement 0 set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaDescriptionDuSubject 0 set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaSequenceDuSubject 0 set SuisJeSurLaSequenceDesBarres 0 set LesSbjctDansEntete {} set LesSbjctDansAli {} set F [open $FichierFasta] while {[gets $F Ligne]>=0} { if {[regexp ">>><<<" $Ligne]} {break} if {![regexp -nocase {[a-z:]} $Ligne]} {continue} if {!$SuisJeSurLaDescriptionDeLaQuery && [regexp {, ([0-9]*) nt$} $Ligne tmp TailleSequence]} { set SuisJeSurLaDescriptionDeLaQuery 1 regsub $tmp $Ligne "" Ligne set NomQuery [string trim $Ligne] continue } if {$SuisJeSurLaDescriptionDeLaQuery && ([regexp " vs " $Ligne] && [regexp " library" $Ligne])} { set SuisJeSurLaDescriptionDeLaBanque 1 regsub -nocase " vs " $Ligne "" Ligne regsub -nocase " library" $Ligne "" Ligne set NomBanque [string trim $Ligne] set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaDescriptionDeLaBanque 1 continue } if {$SuisJeSurLaDescriptionDeLaBanque && [regexp {([0-9]+) residues in ([ 0-9]+)} $Ligne tmp NbLetters NbSequences]} { set NbSequences [string trim NbSequences] set SuisJeSurLaDescriptionDeLaBanque 0 continue } if {!$SuisJeSurLEnteteDesSequences && [regexp "^The best scores are: " $Ligne]} { set SuisJeSurLEnteteDeFasta 0 set SuisJeSurLEnteteDesSequences 1 continue } if {$SuisJeSurLEnteteDeFasta} {continue} if { $SuisJeSurLEnteteDesSequences && ![regexp "^>" $Ligne]} { regsub -all {(gnl\|BL_ORD_ID\|[0-9]+ +|lcl\|)} $Ligne "" Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] set NomSbjct [string range [lindex $Ligne 0] 0 $MaxLongNomSbjct] if {![regexp -nocase {[0-9a-z]} $NomSbjct]} {unset NomSbjct;continue} if {![info exists TabEntete($NomSbjct)]} { lappend LesSbjctDansEntete $NomSbjct set TailleSbjct [lindex $LaLigne end-3] regsub "\\(" $TailleSbjct "" TailleSbjct regsub "\\)" $TailleSbjct "" TailleSbjct set TabEntete($NomSbjct,Taille) $TailleSbjct set TabEntete($NomSbjct,Des) [join [lrange $LaLigne 1 end-3] " "] set TabEntete($NomSbjct) 0 } incr TabEntete($NomSbjct) set i [set TabEntete($NomSbjct)] set TabEntete($NomSbjct,$i,Score) [lindex $LaLigne end-1] set TabEntete($NomSbjct,$i,Expect) [lindex $LaLigne end ] if {[info exists NomSbjct]} {unset NomSbjct} continue } if {[regexp {^>{3}} $Ligne]} {continue} if {[regexp {^>{2}} $Ligne]} { regsub {^>{2}} $Ligne "" Ligne if {[info exists NomSbjct]} { set i [set TabAli($NomSbjct)] set SeqBarres [set TabAli($NomSbjct,$i,SeqBarres)] set PosIni [string first ":" $SeqBarres] set PosFin [string last ":" $SeqBarres] regsub -all {\-} $SeqBarres " " SeqBarres set SeqBarres [string range $SeqBarres $PosIni $PosFin] set SeqQuery [string range [set TabAli($NomSbjct,$i,SeqQuery)] $PosIni $PosFin] set SeqSbjct [string range [set TabAli($NomSbjct,$i,SeqSbjct)] $PosIni $PosFin] set DQ [set TabAli($NomSbjct,$i,DQ)] set FQ [set TabAli($NomSbjct,$i,FQ)] set DS [set TabAli($NomSbjct,$i,DS)] set FS [set TabAli($NomSbjct,$i,FS)] set Alignement [string tolower "$SeqQuery\n$SeqBarres\n$SeqSbjct"] set TabAli($NomSbjct,$i,Alignement) [AliFastaToAliBlast $Alignement $DQ $FQ $DS $FS] unset NomSbjct } set EnAiJeDejaVuUn 0 set SuisJeSurLEnteteDesSequences 0 set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaSequenceDuSubject 0 set SuisJeSurLaSequenceDesBarres 0 set SuisJeSurLaDescriptionDeLAlignement 1 regsub -all {(gnl\|BL_ORD_ID\|[0-9]+ +|lcl\|)} $Ligne "" Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split [string trim $Ligne] " "] set NomSbjct [string range [lindex $LaLigne 0] 0 $MaxLongNomSbjct] set Description [join [lrange $LaLigne 1 end] " "] if {![info exists TabAli($NomSbjct)]} { set TabAli($NomSbjct) 0 set TabAli($NomSbjct,Description) $Description #Espionne "set TabAli($NomSbjct,Description) $Description" lappend LesSbjctDansAli $NomSbjct } incr TabAli($NomSbjct) set i [set TabAli($NomSbjct)] set TabAli($NomSbjct,$i,SeqQuery) "" set TabAli($NomSbjct,$i,SeqBarres) "" set TabAli($NomSbjct,$i,SeqSbjct) "" continue } if {[regexp -nocase {; al_cons} $Ligne]} { set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaDescriptionDuSubject 0 set SuisJeSurLaSequenceDuSubject 0 set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaSequenceDesBarres 1 continue } if {[regexp {^>{1}} $Ligne]} { set SuisJeSurLaDescriptionDeLAlignement 0 if {$EnAiJeDejaVuUn} { set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaDescriptionDuSubject 1 set SuisJeSurLaSequenceDuSubject 0 } else { set SuisJeSurLaDescriptionDeLaQuery 1 set SuisJeSurLaDescriptionDuSubject 0 set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaSequenceDuSubject 0 } set EnAiJeDejaVuUn 1 continue } if {$SuisJeSurLaDescriptionDeLAlignement} { set i [set TabAli($NomSbjct)] if {[regexp -nocase {fa_frame: ([rf])} $Ligne tmp Frame]} { if {$Frame == "f"} {set TabAli($NomSbjct,$i,Sens) "Plus / Plus" ;continue} if {$Frame == "r"} {set TabAli($NomSbjct,$i,Sens) "Plus / Minus";continue} } if {[regexp -nocase {fa_z-score:[ ]+([e0-9\.\+]*)} $Ligne tmp Score]} { set TabAli($NomSbjct,$i,Score) $Score continue } if {[regexp -nocase {fa_expect:[ ]+([e0-9\.\-\+]*)} $Ligne tmp Expect]} { set TabAli($NomSbjct,$i,Expect) $Expect continue } if {[regexp -nocase {fa_ident:[ ]+([0-9\.]*)} $Ligne tmp Identity]} { set TabAli($NomSbjct,$i,Identity) [expr $Identity*100] continue } if {[regexp -nocase {sw_ident:[ ]+([0-9\.]*)} $Ligne tmp Identity]} { set TabAli($NomSbjct,$i,Identity) [expr $Identity*100] continue } continue } if {$SuisJeSurLaDescriptionDeLaQuery} { set i [set TabAli($NomSbjct)] if {[regexp -nocase {al_start:[ ]+([0-9]+)} $Ligne tmp DQ]} { set TabAli($NomSbjct,$i,DQ) $DQ continue } if {[regexp -nocase {al_stop:[ ]+([0-9]+)} $Ligne tmp FQ]} { set TabAli($NomSbjct,$i,FQ) $FQ continue } if {[regexp -nocase {al_display_start:[ ]+([0-9]+)} $Ligne tmp Start]} { set TabAli($NomSbjct,$i,QueryStart) $Start set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaSequenceDeLaQuery 1 continue } continue } if {$SuisJeSurLaDescriptionDuSubject} { set i [set TabAli($NomSbjct)] set Sens [set TabAli($NomSbjct,$i,Sens)] if {[regexp -nocase {al_start:[ ]+([0-9]+)} $Ligne tmp DS]} { set TabAli($NomSbjct,$i,DS) $DS if {[set TabAli($NomSbjct,Taille)] < $DS} {set TabAli($NomSbjct,Taille) $DS} continue } if {[regexp -nocase {al_stop:[ ]+([0-9]+)} $Ligne tmp FS]} { set TabAli($NomSbjct,$i,FS) $FS if {[set TabAli($NomSbjct,Taille)] < $FS} {set TabAli($NomSbjct,Taille) $FS} continue } if {[regexp -nocase {al_display_start: ([0-9]+)} $Ligne tmp Start]} { set TabAli($NomSbjct,$i,SbjctStart) $Start set SuisJeSurLaDescriptionDuSubject 0 set SuisJeSurLaDescriptionDeLaQuery 0 set SuisJeSurLaSequenceDeLaQuery 0 set SuisJeSurLaSequenceDuSubject 1 continue } if {![info exists TabAli($NomSbjct,Taille)] && [regexp -nocase {sq_len:[ ]+([0-9]+)} $Ligne tmp Taille]} { set TabAli($NomSbjct,Taille) $Taille continue } continue } if {$SuisJeSurLaSequenceDeLaQuery} { set i [set TabAli($NomSbjct)] append TabAli($NomSbjct,$i,SeqQuery) $Ligne continue } if {$SuisJeSurLaSequenceDuSubject} { set i [set TabAli($NomSbjct)] append TabAli($NomSbjct,$i,SeqSbjct) $Ligne continue } if {$SuisJeSurLaSequenceDesBarres} { set i [set TabAli($NomSbjct)] append TabAli($NomSbjct,$i,SeqBarres) $Ligne continue } } close $F if {[info exists NomSbjct]} { set i [set TabAli($NomSbjct)] set SeqBarres [set TabAli($NomSbjct,$i,SeqBarres)] set PosIni [string first ":" $SeqBarres] set PosFin [string last ":" $SeqBarres] regsub -all {\-} $SeqBarres " " SeqBarres set SeqBarres [string range $SeqBarres $PosIni $PosFin] set SeqQuery [string range [set TabAli($NomSbjct,$i,SeqQuery)] $PosIni $PosFin] set SeqSbjct [string range [set TabAli($NomSbjct,$i,SeqSbjct)] $PosIni $PosFin] set DQ [set TabAli($NomSbjct,$i,DQ)] set FQ [set TabAli($NomSbjct,$i,FQ)] set DS [set TabAli($NomSbjct,$i,DS)] set FS [set TabAli($NomSbjct,$i,FS)] set Alignement [string tolower "$SeqQuery\n$SeqBarres\n$SeqSbjct"] set TabAli($NomSbjct,$i,Alignement) [AliFastaToAliBlast $Alignement $DQ $FQ $DS $FS] } ####DESCRIPTION DU BLAST############### set LeTextBlast {} lappend LeTextBlast "BLASTN from FASTAn \[Dec-14-2001\]\n\n" lappend LeTextBlast "Reference: FASTAn converted in BLASTn format.\n" lappend LeTextBlast "Query= $NomQuery" lappend LeTextBlast " \($TailleSequence letters\)\n" lappend LeTextBlast "Database: $NomBanque" lappend LeTextBlast " $NbSequences sequences; $NbLetters total letters\n" lappend LeTextBlast "Searching...................................................done\n\n" if {$LesSbjctDansAli == {}} { lappend LeTextBlast " ***** No hits found ******" } else { lappend LeTextBlast " Score E" lappend LeTextBlast "Sequences producing significant alignments: (bits) Value\n" ####LES HITS DU BLAST############### foreach Sbjct [ElimineLesRedondancesDansUneListe $LesSbjctDansEntete] { set Description [set TabAli($Sbjct,Description)] set Entete "$Sbjct $Description" if {[string length $Entete] < 67} { set Taille [string length $Entete] set nDiff [expr 67 - $Taille] append Entete [string repeat " " $nDiff] } else { set Entete [string range $Entete 0 66] } set Score [set TabAli($Sbjct,1,Score)] set Expect [set TabAli($Sbjct,1,Expect)] set ScoreEtExpect [format " %5s %-6s" $Score $Expect] append Entete $ScoreEtExpect lappend LeTextBlast [string trim $Entete] } lappend LeTextBlast "" ####LES ALIGNEMENTS DU BLAST############### foreach Sbjct [ElimineLesRedondancesDansUneListe $LesSbjctDansAli] { set Taille [set TabAli($Sbjct,Taille)] set Description [set TabAli($Sbjct,Description)] lappend LeTextBlast "\n>$Sbjct $Description" lappend LeTextBlast " Length = $Taille\n" set n [set TabAli($Sbjct)] for {set i 1} {$i <= $n} {incr i} { set Score [set TabAli($Sbjct,$i,Score)] set Expect [set TabAli($Sbjct,$i,Expect)] lappend LeTextBlast " Score = $Score bits, Expect = $Expect" set Identity [set TabAli($Sbjct,$i,Identity)] set NbBases [expr abs([set TabAli($Sbjct,$i,FQ)] - [set TabAli($Sbjct,$i,DQ)]) + 1] set NbBasesCorrectes [expr round($NbBases * $Identity / 100)] lappend LeTextBlast " Identities = $NbBasesCorrectes/$NbBases ($Identity\%)" set Sens [set TabAli($Sbjct,$i,Sens)] lappend LeTextBlast " Strand = $Sens\n\n" set Alignement [set TabAli($Sbjct,$i,Alignement)] lappend LeTextBlast "$Alignement" } } } lappend LeTextBlast " Database: $NomBanque" Sauve [join $LeTextBlast "\n"] dans $FichierBlast return $FichierBlast } proc FastaPourGscope {Fichier {Sortie ""} {GenreDef ""} {EspeceDef ""}} { FaireLire "Attention il y a mieux ... voir FromOrthoInspector" #rR ceci doit etre réécrit car l'os est mal traité on n'a pas le strain # c'est surtout pour orthoinspector où il y a 2 type de fasta if {$GenreDef==""} { set GenreDef "Unknown" } if {$EspeceDef==""} { set EspeceDef "unknown" } if {$Sortie==""} { set Sortie "$Fichier.NEW" } Espionne $Fichier foreach Ligne [LesLignesDuFichier $Fichier] { regsub -all " +" $Ligne " " Ligne set Ligne [string trim $Ligne] if {$Ligne==""} { continue } # if {[regexp "Trichoplax" $Ligne]} { Espionne $Ligne } if {[regexp ">" $Ligne]} { if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} { # FaireLire "pas bon $Ligne" lappend LeNew $Ligne continue } regsub { OS=.*} $D "" D regsub { GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] set Ac "" set Id "" lassign [split $AI "|"] Banque Ac Id if {$Ac==""} { set Ac $AI } if {$Id==""} { set Id $Ac } set Genre $GenreDef set Espece $EspeceDef set Gn "" regexp {GN=([^ ]+)} $Ligne Match Gn set TextGn "" if {$Gn!=""} { set TextGn " GN=$Gn" } set Entete ">$Id $Ac $Genre $Espece $D $TextGn" lappend LeNew $Entete } else { lappend LeNew $Ligne } } if {$Sortie=="GetList"} { return $LeNew } if {$Sortie=="GetText"} { return [join $LeNew "\n"] } return [SauveLesLignes $LeNew dans $Sortie] } proc FastaPourGscopePourTous {DirSource DirDestin} { foreach Fichier [glob -nocomplain "$DirSource/*.fasta"] { set Queue [file tail $Fichier] set Destin "$DirDestin/$Queue" set N [FastaPourGscope $Fichier $Destin] Espionne $N lappend LesNouveaux $N } return $LesNouveaux } proc FastaProteomeConverter {inputFile outputFile} { puts "########################################" puts "--Convertion des fasta pour Gscope--" puts "########################################" puts ">>> modification des entetes" #compteur set n 0 #open input file set fasta_file [open $inputFile "r"] #create output file set FIC [open "$outputFile.fasta" "w"] #reads input line by line while {[gets $fasta_file line]!=-1} { if {$line==""} { continue } #header, correct it ############################################## ### CAS OU ON A DE l'UNIPROT if {[string index $line 0]==">" && ([string index $line 1]=="s" || [string index $line 1]=="t")} { incr n set oldLine $line set newLine "" #vars set orga "" set geneName "" set tout "" #separation by | set infos1 [split $oldLine "|"] lassign $infos1 origin accessNumber description #search of OS (organism), comments and GN (gene name) in description variable regexp {\[(.*? .*?)\]} $description tout orga set mots [split $orga " "] set orga [concat [lindex $mots 0] [lindex $mots 1]] regexp {\](.*)} $description tout seul #composition of the new line append newLine ">$accessNumber $orga $seul" #"puts "'$newLine'" puts $FIC "$newLine" ############################################## ### CAS OU ON A DU REFSEQ (via icarus) } elseif {[string index $line 0]==">" && ([string index $line 1]=="r")} { incr n set oldLine $line set newLine "" #vars set orga "" set geneName "" set def "" #separation by | set infos1 [split $oldLine "|"] lassign $infos1 origin accessNumber description #search of OS (organism), comments and GN (gene name) in description variable regexp {\[(.*? .*?)\]} $description tout orga set mots [split $orga " "] set orga [concat [lindex $mots 0] [lindex $mots 1]] regexp {\](.*)} $description tout seul #composition of the new line append newLine ">$accessNumber $orga $seul" #"puts "'$newLine'" puts $FIC "$newLine" } else { #no header, just write puts $FIC "$line" } } close $fasta_file close $FIC puts " -->OK : $n entetes fasta converties." } proc FastacmdExe {} { global tcl_platform global OrdBinDir global env if {[info exists env(GRILLE)] && $env(GRILLE)} { return "./fastacmd" } if {[set tcl_platform(platform)] != "windows"} { if {[info exists OrdBinDir]} { return [file join $OrdBinDir "fastacmd"] } else { return "/biolo/ncbi/bin/fastacmd" } } else { set lexe [file join $OrdBinDir "fastacmd.exe"] regsub "Program Files" $lexe "PROGRA~1" lexe return $lexe } } proc FeatureSequence {Seq} { #rR on cree une list BeforeSeq 1 3, Seq_1 4 8, Gap_1 8 12, Seq_2 13 20, AfterSeq 20 30 set DansEntame 1 set DansQueue 0 set FinEntame 0 set LesFeatures {} set I 0 set L 0 set DebCourant 1 set DebLocal 0 set FinLocal 0 foreach AA [split $Seq ""] { incr I set IsSeq [regexp -nocase {[a-z]} $AA] if {$IsSeq} { incr L ; incr FinLocal } if { ! [info exists WasSeq]} { set WasSeq [expr ! $IsSeq] } if { $IsSeq==$WasSeq } { incr FinCourant ; set WasSeq $IsSeq; continue } if {[info exists FinCourant]} { lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal" } set DebCourant $I set FinCourant $I set DebLocal $L set FinLocal $L set WasSeq $IsSeq } if { ! [info exists WasSeq]} { return {} } lappend LesFeatures "$WasSeq $DebCourant $FinCourant $DebLocal $FinLocal" set LesFeatureSequence {} set NS 0 set NG -1 set Last [llength $LesFeatures] set I 0 set L 0 foreach F $LesFeatures { incr I scan $F "%d %d %d %d %d" T D F DL FL if {$T==1} { incr NS ; incr L; lappend LaFeatureSequence "Seq_$NS $D $F $DL $FL" ; continue } if {$NS==0} { if {$NG==-1} { lappend LaFeatureSequence "BeforeSeq $D $F $DL $FL" ; set NG 0; continue } } else { incr NG if {$I==$Last} { lappend LaFeatureSequence "AfterSeq $D $F $DL $FL" } else { lappend LaFeatureSequence "Gap_$NG $D $F $DL $FL" } } } return $LaFeatureSequence } proc FeatureSummary {} { global EFeat NomSeqSel LNOrdali LSOrdali Defauts ListeTypesDeFeatures TabSF if {! [info exists TabSF]} { FaireLire "No features in this alignment !" return } set w ".fitsum" if {[winfo exists $w]} { raise $w return } set EFeat(SumWindow) $w toplevel $w wm title $w "Features Summary" wm iconname $w "Feat. Sum." wm protocol $w WM_DELETE_WINDOW KillParLaCroix if {[winfo exists .fattendre]} {lower $w .fattendre} # inits set EFeat(ShowNote) 0 set EFeat(FontSize) [set Defauts(FontSizeTree)] set EFeat(FontWght) [set Defauts(FontWghtTree)] if {"FontFeat" ni [font names]} { font create FontFeat -family "Courier" -size $EFeat(FontSize) } # frame canvas + scrollbars frame $w.fc set EFeat(PADWdt) [set Defauts(CanvasWSFeat)] set EFeat(PADHgt) [set Defauts(CanvasHSFeat)] set EFeat(FWidth) [set Defauts(FWidthSFeat)] set EFeat(FHeight) [set Defauts(FHeightSFeat)] set wc "$w.fc.c" set EFeat(PAD) $wc set wdt [PlusLongEltDe $LNOrdali] set wdt [expr {$wdt < 20 ? $wdt : 20}] set EFeat(Listbox) $w.fc.lsb set EFeat(ListboxListe) [list] listbox $w.fc.lsb -listvariable EFeat(ListboxListe) -width $wdt -font SeqFont -selectmode extended -yscrollcommand "$w.fc.vb set" bind $w.fc.lsb <> {PickSeq [%W curselection]} scrollbar $w.fc.vb -command "$w.fc.lsb yview" -width 8 entry $w.fc.ent -background white -bd 2 -relief groove -font SeqFont -width $wdt -textvariable EFeat(SearchNom) bind $w.fc.ent [list ChercheNomDansListe] canvas $w.fc.c -width [set EFeat(FWidth)] -height [set EFeat(FHeight)] -scrollregion [list 0 0 [set EFeat(PADWdt)] [set EFeat(PADHgt)]] -cursor hand2 -background white -relief groove -xscrollcommand "$w.fc.hs set" -yscrollcommand "$w.fc.vs set" scrollbar $w.fc.vs -command "$wc yview" -width 8 scrollbar $w.fc.hs -orient horiz -command "$wc xview" -width 8 grid $w.fc.lsb -row 0 -column 0 -sticky ns grid $w.fc.ent -row 1 -column 0 -sticky ew grid $w.fc.vb -row 0 -column 1 -sticky ns -padx {0 5} grid $w.fc.c -row 0 -column 2 -sticky news grid $w.fc.vs -row 0 -column 3 -sticky ns grid $w.fc.hs -row 1 -column 2 -sticky ew grid $w.fc -row 0 -column 0 -sticky news -padx 5 -pady {5 1} grid rowconfig $w.fc 0 -weight 1 grid columnconfig $w.fc {0 2} -weight 1 # Frame control frame $w.fb -bd 2 -relief groove # frame noms set wn $w.fb.fnm frame $wn label $wn.shw -text "Show " -anchor w -justify left spinbox $wn.nsf -readonlybackground white -state readonly -textvariable EFeat(NomsAff) -width 9 -values {"Seq. Name" Accession "Bank Id"} -command [list UpdateListboxSeqFeat] set EFeat(NomsAff) Accession label $wn.lsz -text "Font size " -anchor w -justify left spinbox $wn.ssz -width 3 -readonlybackground white -state normal -textvariable EFeat(FontSize) -values {6 8 10 12 14 16 18 20 22 24} -command [list ChangeFontEFeat %s] grid $wn.shw -row 0 -column 0 -sticky w grid $wn.nsf -row 0 -column 1 -sticky e -padx {1 5} grid $wn.lsz -row 0 -column 2 -sticky e -padx {5 1} grid $wn.ssz -row 0 -column 3 -sticky w grid $wn -row 0 -column 0 -sticky nw -pady 2 -padx 2 grid columnconfig $wn {1 3} -weight 1 # frame features set wb $w.fb.fft frame $wb set wdt [PlusLongEltDe $ListeTypesDeFeatures] menubutton $wb.mft -relief raised -width $wdt -text "Features" -menu $wb.mft.feat menu $wb.mft.feat -tearoff 0 # Switch on features used foreach f [ListeDesFeaturesUtilisees] { set EFeat(LFeat,$f) 1 } foreach f $ListeTypesDeFeatures { $wb.mft.feat add checkbutton -label "$f" -variable EFeat(LFeat,$f) -onvalue 1 -offvalue 0 -command [list TracageFeatureSummary] } grid $wb.mft -column 0 -row 0 -sticky ew grid $wb -row 0 -column 1 -sticky new -padx 2 -pady 2 grid columnconfig $w.fb.fft all -weight 1 # Control : show note set wn $w.fb.fctrl frame $wn checkbutton $wn.ckn -relief flat -anchor w -justify left -text "Notes as Balloon " -onvalue 1 -offvalue 0 -variable EFeat(ShowNote) -command {ShowFeatNote} grid $wn.ckn -row 0 -column 0 -columnspan 2 -sticky ew grid $wn -column 2 -row 0 -sticky w -pady 2 -padx 5 # frame buttons set wp $w.fb.fokpt frame $wp button $wp.bok -background green1 -text " Close " -command [list RetourFeatSummary] button $wp.prt -background yellow -text " Print " -command [list PrintCanvas $wc png] grid $wp.prt -column 0 -row 0 -sticky ew grid $wp.bok -column 1 -row 0 -sticky ew grid columnconfig $wp 0 -weight 1 grid $wp -row 0 -column 3 -sticky nse -pady 2 -padx 2 grid $w.fb -row 1 -column 0 -sticky ew -padx 5 -pady 5 grid columnconfig $w.fb 3 -weight 1 grid columnconfig $w 0 -weight 1 grid rowconfig $w 0 -weight 1 # bindings divers (et d'ete) set PAD [set EFeat(PAD)] bind $PAD {%W scan mark %x %y} bind $PAD {%W scan dragto %x %y 1} bind $PAD <4> {eval %W yview scroll -1 units} bind $PAD <5> {eval %W yview scroll 1 units} bind $PAD {eval %W xview scroll -1 units} bind $wc {eval %W xview scroll 1 units} $PAD bind TNote {CentreAliOnFeat %x %y} # initialize listbox # seq. selected in main window are set here too set EFeat(ListboxListe) $LNOrdali foreach n $LNOrdali { if {$n ne ""} { set EFeat(LMSeq,$n) 0 set EFeat(NSeq,$n) $n } } foreach e $NomSeqSel { lassign [split $e .] y x set n [lindex $LNOrdali $y-1] set EFeat(LMSeq,$n) 1 $EFeat(Listbox) itemconfigure $y -background black -foreground white } TracageFeatureSummary MesCouleurs $w FenetreAuCentre $w return $w } proc FeaturesDesPfam {aFeatures LesPf LesFe} { #LesFe peut être block or prosite #donne les blocks ou les prosites d un pfam upvar $aFeatures Features foreach Fe $LesFe { lassign [split $Fe "/-"] FeName Deb Fin scan $FeName "%s" FeName regsub -nocase {^PROP_} $FeName "" FeName foreach x [NombresEntre $Deb $Fin] { lappend YaFe($x) [list $FeName $Deb $Fin] } } foreach Pf $LesPf { set Features($Pf) {} if {![regexp {^[PRO]*_?PF[0-9]+ [^/]+/([0-9]+)\-([0-9]+)} $Pf Match Deb Fin]} {continue} foreach x [NombresEntre $Deb $Fin] { if {![info exists YaFe($x)]} {continue} LConcat Features($Pf) $YaFe($x) } set Features($Pf) [ListeSansDoublon $Features($Pf)] set Features($Pf) [lsort -command CompareIntegerInFeaturesDesPfam $Features($Pf)] } return } 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 FenetreAjoutePDB {} { if {[TypeAli] eq "pasdali" || [QuelMode] eq "seqlab"} { return } global ListePDB WAP set w .apdb if {[winfo exists $w]} { raise $w return } set Lid [list] foreach e $ListePDB { lappend Lid [DonneIdDeAccessPDB $e] } set Lid [lsort -unique $Lid] set Lid [linsert $Lid 0 "Choose"] set WAP(Win) $w toplevel $w wm title $w "Add PDB" grid columnconfig $w 0 -weight 1 set wf $w.ffile frame $wf grid columnconfig $wf 1 -weight 1 set WAP(File) "" label $wf.lbl -text "File : " -relief flat entry $wf.ent -background white -textvariable WAP(File) button $wf.but -text "Browse" -background cyan -command "set WAP(File) \[DemandeEtOuvreFichier PDB\]" grid $wf.lbl -row 0 -column 0 -sticky w grid $wf.ent -row 0 -column 1 -sticky ew grid $wf.but -row 0 -column 2 -sticky ew grid $wf -row 0 -column 0 -sticky ew -padx 5 -pady 5 set wr $w.frad frame $wr set WAP(Replace) 0 radiobutton $wr.rre -text "Replace PDB " -relief flat -value 1 -variable WAP(Replace) ttk::combobox $wr.cbb -state readonly -background white -width 6 -values $Lid -textvariable WAP(Id) radiobutton $wr.ren -relief flat -text "PDB Id :" -value 0 -variable WAP(Replace) entry $wr.eid -bg white -width 4 -textvariable WAP(NewId) grid $wr.ren -row 0 -column 0 -sticky w -padx {1 10} grid $wr.eid -row 0 -column 1 -sticky ew grid $wr.rre -row 1 -column 0 -sticky w -padx {1 10} grid $wr.cbb -row 1 -column 1 -sticky ew set pad [expr {round([winfo reqwidth $wf.lbl])}] grid $wr -row 1 -column 0 -sticky w -padx $pad -pady {1 5} $wr.cbb current 0 set wb $w.but frame $wb button $wb.dis -text "Cancel" -background red -command [list AjoutePDB dismiss] button $wb.ok -text " OK " -background green1 -command [list AjoutePDB ok] grid $wb.dis -row 0 -column 0 -sticky w -padx 10 grid $wb.ok -row 0 -column 1 -sticky e -padx 10 grid columnconfig $wb all -weight 1 grid $wb -row 2 -column 0 -sticky ew -padx 5 -pady {15 10} FenetreAuCentre $w tkwait window $w return } proc FenetreAuCentre {f} { # wm protocol [winfo toplevel $f] WM_DELETE_WINDOW { } # wm withdraw [winfo toplevel $f] # update idletasks lassign [TotalWSize $f] w h set x [expr {[winfo screenwidth $f]/2 - $w/2}] set y [expr {[winfo screenheight $f]/2 - $h/2}] if {$x < 0} {set x 10} if {$y < 0} {set y 10} wm geom [winfo toplevel $f] +$x-$y return } proc FenetreControlesRasMol {} { global StrucAVoir global RasM global ListeTypesDeFeatures MetAJourFeaturesRasmol set RasM(FeatWidth) [PlusLongEltDe [set RasM(LFeat)]] set RasM(LStyle) [list "cartoon" "wireframe" "trace" "ribbons"] set RasM(StyleWidth) [PlusLongEltDe [set RasM(LStyle)]] set tw .fcviewer toplevel $tw wm title $tw "Rasmol Control" wm protocol $tw WM_DELETE_WINDOW KillParLaCroix frame $tw.f pack $tw.f -padx 5 -pady 5 label $tw.f.lbl -text "RasMol Control Panel" -anchor w -justify center -font "Helvetica 12 bold" pack $tw.f.lbl -side top -expand 1 -fill x -pady 10 frame $tw.f.c pack $tw.f.c -side top -expand 1 -fill both set w "$tw.f.c" set i 1 set r 0 foreach elt $StrucAVoir { set RasM(mol$r,Name) $elt set RasM(mol$r,Style) [lindex [set RasM(LStyle)] 0] set RasM(mol$r,PrevFeat) [lindex [set RasM(LFeat)] 0] set RasM(mol$r,PrevStyle) [lindex [set RasM(LStyle)] 0] set RasM(mol$r,Feat) [lindex [set RasM(LFeat)] 0] set RasM(mol$r,See) 1 lappend RasM(LMols) [list $r $i] label $w.li$i -text "$i" -width 1 -justify left checkbutton $w.ck$i -variable RasM(mol$r,See) -command [list ShowMoleculeDansRasMol $r $i] -onvalue 1 -offvalue 0 label $w.ln$i -text "$elt" -width 6 -justify left combobox $w.cs$i -background white -editable false -height 0 -textvariable RasM(mol$r,Style) -command [list StructStyleDansRasMol $r $i] -width $RasM(StyleWidth) -listvar RasM(LStyle) combobox $w.cf$i -background white -editable false -height 0 -textvariable RasM(mol$r,Feat) -command [list DessineFeatureDansRasMol $r $i] -width $RasM(FeatWidth) -listvar RasM(LFeat) grid $w.li$i -row $r -column 0 -rowspan 1 -columnspan 1 grid $w.ck$i -row $r -column 1 -rowspan 1 -columnspan 1 -padx 0 grid $w.ln$i -row $r -column 2 -rowspan 1 -columnspan 1 -padx 5 grid $w.cs$i -row $r -column 3 -rowspan 1 -columnspan 1 -padx 5 grid $w.cf$i -row $r -column 4 -rowspan 1 -columnspan 1 -padx 5 incr r incr i } set fb "$tw.f.fbt" frame $fb pack $fb -side bottom -fill both -expand 1 -pady 20 button $fb.print -text "Print" -background yellow -command [list PrintRasMol] button $fb.close -text "Close" -background green1 -command [list CloseRasMol] set RasM(AtLabel) " " label $fb.lab -bg white -anchor w -justify left -relief sunken -textvariable RasM(AtLabel) button $fb.centre -text "Centre" -width 6 -bg cyan -command [list CentreRasMol ] grid rowconfig $fb {0 1} -weight 1 grid columnconfig $fb 1 -weight 1 grid $fb.print -row 1 -column 0 grid $fb.close -row 1 -column 2 grid $fb.lab -row 0 -column 0 -columnspan 2 -sticky we grid $fb.centre -row 0 -column 2 MesCouleurs .fcviewer wm geometry .fcviewer +0+0 trace add variable LFeatCourantes write UpdateDessinRasmol trace add variable ListeTypesDeFeatures write MetAJourFeaturesRasmol return } proc FenetreVrp {} { global ListeTypesDeFeatures Vrp set w .fvrp catch {destroy $w} toplevel $w wm title $w "Ordalie Vrp ..." wm iconname $w "vrp" grid columnconfig $w 0 -weight 1 grid rowconfig $w 0 -weight 1 frame $w.f grid $w.f -row 0 -column 0 -sticky news grid columnconfig $w.f 0 -weight 1 grid rowconfig $w.f 0 -weight 1 set w .fvrp.f # frame canvas du vrp frame $w.vrp set c $w.vrp.c set Vrp(WCanvas) $c scrollbar $w.vrp.vscroll -command "$c yview" -width 8 scrollbar $w.vrp.hscroll -orient horiz -command "$c xview" -width 8 canvas $c -scrollregion [list 0 0 $Vrp(Width) $Vrp(Height)] -width $Vrp(Width) -height $Vrp(Height) -cursor hand2 -background white -xscrollcommand "$w.vrp.hscroll set" -yscrollcommand "$w.vrp.vscroll set" grid $w.vrp.c -row 0 -column 0 -sticky news grid $w.vrp.vscroll -row 0 -column 1 -sticky ns grid $w.vrp.hscroll -row 1 -column 0 -sticky ew grid $w.vrp -row 0 -column 0 -sticky news -padx 5 -pady 5 grid rowconfig $w.vrp 0 -weight 1 -minsize 0 grid columnconfig $w.vrp 0 -weight 0 -minsize 0 grid columnconfig $w.vrp 1 -weight 0 -minsize 0 # Frame de controle set w $w.bot frame $w # frame de la sequence de la proteine set t $w.text frame $t set Vrp(WText) $t.txt text $t.txt -xscrollcommand "txtScroll $t" -setgrid true -height 1 -wrap none -background white # show residue number begin end label $t.resbeg -text [format "%4d" $Vrp(BegRes)] -width 4 label $t.resend -text [format "%-4d" $Vrp(EndRes)] -width 4 scrollbar $t.scroll -orient horiz -command "scrollTxt $t" -width 8 grid $t.resbeg -row 0 -column 0 -sticky e grid $t.txt -row 0 -column 1 -sticky ew grid $t.resend -row 0 -column 2 -sticky w grid $t.scroll -row 1 -column 1 -sticky ew grid $t -row 0 -column 0 -columnspan 2 -sticky ew -pady {2 5} grid columnconfig $t 1 -weight 1 # frame seq et feat set wb $w frame $wb.sf -relief groove label $wb.sf.lseq -text "Sequence " set wsq [PlusLongEltDe [set Vrp(NameList)]] ttk::combobox $wb.sf.cseq -background white -state readonly -textvariable Vrp(seqSelName) -width $wsq -values $Vrp(NameList) $wb.sf.cseq index 0 bind $wb.sf.cseq <> [list DessineVrpDe] checkbutton $wb.sf.over -text "Overdraw " -anchor w -justify left -onvalue 1 -offvalue 0 -variable Vrp(Overwrite) label $wb.sf.lfeat -text "Feature" set wft [PlusLongEltDe $ListeTypesDeFeatures] set Vrp(ListFeat) [linsert $ListeTypesDeFeatures 0 "None"] set Vrp(UseFeat) [lindex $Vrp(ListFeat) 0] ttk::combobox $wb.sf.cfea -background white -state readonly -textvariable Vrp(UseFeat) -width $wft -values $Vrp(ListFeat) $wb.sf.cfea index 0 bind $wb.sf.cfea <> [list ColorieVrpSelon %W VientDuCombo] grid $wb.sf.lseq -row 0 -column 0 -sticky ew grid $wb.sf.cseq -row 0 -column 1 -sticky ew grid $wb.sf.over -row 1 -column 0 -columnspan 2 -sticky w grid $wb.sf.lfeat -row 0 -column 2 -sticky ew -padx {10 1} grid $wb.sf.cfea -row 0 -column 3 -sticky ew grid $wb.sf -row 1 -column 0 -sticky w grid columnconfig $wb.sf {1 3} -weight 1 # frame boutons frame $wb.fb button $wb.fb.circle -text "Circle" -bg cyan -command [list VrpCircle] button $wb.fb.print -text "Print" -bg yellow -command [list Printcanvas $Vrp(WCanvas) png] button $wb.fb.close -text "Close" -bg green1 -command [list destroy .fvrp] grid $wb.fb.circle -row 0 -column 0 -sticky ew -ipadx 2 grid $wb.fb.print -row 0 -column 1 -sticky ew -ipadx 2 grid $wb.fb.close -row 0 -column 2 -sticky ew -ipadx 2 grid $wb.fb -row 1 -column 1 -sticky e grid $w -row 1 -column 0 -sticky ew -padx 5 -pady 5 grid columnconfig $w all -weight 1 BindingsVrp $Vrp(WCanvas) $Vrp(WText) MesCouleurs .fvrp FenetreAuCentre .fvrp update idletasks return } proc FermeFichier {{DoSave nosave}} { global NomNomSeq NomTextSeq VariablesAuDepart db Defauts CompteurDeMac # DoSave = if {$DoSave eq "save" && [VueEditee]} { set chx [tk_dialog .chx "Warning" "Warning !\nThis alignment has not been saved !\nDo you want to save it before to quit Ordalie ?" "" 0 "Yes" "No" "Cancel"] switch $chx { 0 { SauveLAlignement } 1 { if {[TypeAli] eq "ORD"} { file rename -force $Defauts(FichierOBK) $Defauts(FichierORD) } } 2 {return} } } catch {$db close} set CompteurDeMac 0 if {[info exists ::ListePDB]} { foreach a $::ListePDB { lassign $a mol tmp set mol "::[DonneIdDeAccessPDB $mol]" if {[info commands "::$mol"] ne ""} { $mol destroy } } update } DetruitInfoSeqs if {[ModeI]} { $NomNomSeq configure -state normal $NomNomSeq delete 1.0 end $NomNomSeq edit reset bindtags $NomNomSeq $NomNomSeq foreach b [bind $NomNomSeq] { bind $NomNomSeq $b "" } bindtags $NomNomSeq [list $NomNomSeq Text . all] $NomNomSeq configure -state disabled $NomTextSeq configure -state normal $NomTextSeq delete 1.0 end $NomTextSeq edit reset bindtags $NomTextSeq $NomTextSeq foreach b [bind $NomTextSeq] { bind $NomTextSeq $b "" } bindtags $NomTextSeq [list $NomTextSeq Text . all] $NomTextSeq configure -state disabled } # remember if we arrive as interactive or batch mode set Mode [ModeI] #DetruitVariablesSaufDepart foreach v {Sequences LNOrdali LSOrdali LNSeqlab LSSeqlab TabSF LNDG SDG ListeTypesDeFeatures TColScore} { global $v unset -nocomplain $v } LesDefauts LesDefauts Mode $Mode if {[ModeI]} { $::WOrdali(combomac) configure -values [list] DetruitBoutonsOrdali AfficheBoutonsOrdali LesDefauts dispmode "ordali" #BindModeNormal } # inits ... set ::Threshold [set Defauts(Threshold)] set ::ListeTypesDeFeatures {} set ::NomSeqSel {} set ::BufferSeq {} set ::LongueurTotale 0 set ::ListeTypesDeFeatures [list] array set ::TabSF {} set ::BufNTimes "" DefinitionPreferences InitialiseCouleurs PrintSetup "defauts" update return } proc FermeFichierPipe {} { global VariablesAuDepart set Lv [info globals] foreach v $Lv { if {$v eq "VariablesAuDepart"} {continue} if {[lsearch $VariablesAuDepart $v] != -1} {continue} global $v if {[info exists $v]} {unset $v} } update return } proc FetchCat {Access {Quoi ""}} { #rR completement obsolete car fetch n'existe plus return "" return [exec fetchcat $Access $Quoi] } proc FetchContig {Selection} { global RepertoireDuGenome foreach Ligne [split $Selection "\n"] { if { ! [regexp -nocase {[a-z0-9]+\:[a-z0-9_]+} $Ligne BanqueId]} { continue } set GCG [FetchCat $BanqueId] if {$GCG==""} { continue } AfficheVariable $GCG "AvecFormate" $BanqueId } } proc FetchDeLaSelection {K} { set Liste [$K find withtag current] foreach Id $Liste { set BId [lindex [$K gettags $Id] 0] AfficheFetch $BId OnVeutNature } } proc FetchInfosSeqs {{Liste ""}} { global LNOrdali ListePDB {*}[info globals "TD*"] if {[TypeAli] eq "pasdali" && $Liste eq ""} { return } if {[QuelMode] eq "seqlab"} { FaireLire "Not available in Editor mode !" return } if {$Liste eq ""} { set Liste $LNOrdali } set Lid [list] set Lref [list] set Luni [list] foreach n $Liste { if {$n eq "" || $n in $ListePDB} { continue } # refseq/GI if {[EstUnRefseq $n] || [string is integer $n]} { lappend Lref $n } elseif {[EstUnUniProt $n]} { lappend Luni $n } else { lappend Lother $n } lappend Lid $n } # for refseq array set R [InfosFromRefSeq $Lref] foreach acc $Lref { if {! [info exists R($acc,Desc)]} { continue } foreach t {TDesDescriptifs TDesTaxId TDuLineage TDesOrganismes TDesPhylum} k {Desc TaxId Lineage Organism Phylum} { set ${t}($acc) [set R($acc,$k)] } if {[set TDesAccess($acc)] eq [set TDesSeqnames($acc)]} { set TDesAccess($acc) [set R($acc,GI)] } } # from UniProt #puts "Luni \n[join $Luni \n]" array set T [InfosFromUniProt $Luni] #parray T foreach acc $Luni { if {! [info exists T($acc,Desc)]} { continue } foreach t {TDesDescriptifs TDesTaxId TDuLineage TDesOrganismes TDesPhylum} k {Desc TaxId Lineage Organism Phylum} { set ${t}($acc) [set T($acc,$k)] } } return } proc FetchNoms {Access} { #rR completement obsolete car fetch n'existe plus return "" return [FetchCat $Access LesNoms] } proc FetchService {} { global LNOrdali ListePDB if {0} { EB-eye : http://www.ebi.ac.uk/ebisearch/service.ebi?wsdl biomart http://webservices.genouest.org/typedservices/BioMart.wsdl } set Lrefseq [list] ; set Luniprot [list] foreach n $LNOrdali { if {$n eq ""} {continue} if {$n in $ListePDB} {continue} if {[EstUnRefseq $n]} { lappend Lrefseq $n } else { lappend Luniprot $n } } if {$Lrefseq != {}} { } return } proc FetchTest {Access} { #rR completement obsolete car fetch n'existe plus return 0 return [FetchCat $Access "LeTest"] } proc FetchUniprotPost {Lid} { set url "http://www.uniprot.org/batch/" set file tmp set type "text/plain" set res [form-data::post $url "file" $type $Lid [list file $file format txt]] set Lembl [SplitLesEMBL $res] return $Lembl } proc Fetche {Access} { global RepertoireDuGenome global Commandes LogWscope "Dans Fetche $Access" return [SequenceDesBanques $Access] if {[file exists $Access]} { return [ContenuDuFichier $Access] } if {[regexp "^PAB" $Access] && [file exists "$RepertoireDuGenome/../casimir/protembl/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/../casimir/protembl/$Access"] } if {[regexp {^AFF[0-9]{5}$} $Access] && [file exists "$RepertoireDuGenome/../AffyHS/nucembl/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/../AffyHS/nucembl/$Access"] } if {[regexp {PAE[0-9]+} $Access] && [file exists "$RepertoireDuGenome/../Pyrobac/protembl/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/../Pyrobac/protembl/$Access"] } if {[regexp "PFUR" $Access] && [file exists "$RepertoireDuGenome/../Pfuriosus/protembl/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/../Pfuriosus/protembl/$Access"] } if {[regexp "PFOK" $Access] && [file exists "$RepertoireDuGenome/../Pfuriok/protembl/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/../Pfuriok/protembl/$Access"] } if { ([YaPABenDebutDe $Access] || [regexp "/[ExpressionReguliereDesPABs]$" $Access]) && [file exists "$RepertoireDuGenome/prottfa/[file tail $Access]"]} { return [ContenuDuFichier "$RepertoireDuGenome/prottfa/[file tail $Access]"] } if { [regexp {^TROU[0-9]+[A-F]$} $Access] || [regexp "/[ExpressionReguliereDesPABs]\[A-F\]$" $Access] } { return [ContenuDuFichier "$RepertoireDuGenome/trousprottfa/[file tail $Access]"] } if { [regexp {^TROU[0-9]+N$} $Access] || [regexp "/[ExpressionReguliereDesPABs]N$" $Access] } { return [ContenuDuFichier "$RepertoireDuGenome/nuctfa/[file tail $Access]"] } if {[regsub -- {_$} $Access {} AccessTronque] && [file exists "$RepertoireDuGenome/tmpdir/$AccessTronque"]} { return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/$AccessTronque"] } if {[file exists "$RepertoireDuGenome/prrpgcgs/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/prrpgcgs/$Access"] } if {[file exists "$RepertoireDuGenome/tmpdir/$Access"]} { return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/$Access"] } if {[file exists "$RepertoireDuGenome/tmpdir/[string tolower $Access]"]} { return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/[string tolower $Access]"] } if {[file exists $Access]} { return [ContenuDuFichier $Access] } if {[EstUnBonAccess $Access]} { return [FetchCat $Access] } if {[regsub -- {_$} $Access {} AccessTronque]} { return [Fetche $AccessTronque] } if { ! [regexp {[:/]} $Access]} { return [Fetche ":$Access"] } if { [regexp {[:]} $Access] && ! [regexp "protein" $Access] } { regsub -- {[a-zA-Z_^:]*:} $Access "protein:" AccessDansBanqueGCG return [Fetche "$AccessDansBanqueGCG"] } return "" } proc FetcheBox {K X Y {Quoi Show}} { global RepertoireDuGenome if {[YaPABouTROUouTRNAouARNdans $X]} { set Boite $X } else { set Boite [BoiteDuCourant $K $X $Y] } if { $Boite == "" } { return } set Nom [Box $Boite nom] if {[regexp "GLIMMER" $Nom]} { return [AfficheNuc $Nom] } return [SeeAby $Quoi $Nom] set Fichier "BidonBidon" if { [YaPABdans $Nom] } { set Fichier "$RepertoireDuGenome/msf/$Nom" } if { [regexp {TROU[0-9]*[A-F]} $Nom] } { set Fichier "$RepertoireDuGenome/trousmsf/$Nom" } if { [regexp {TROU[0-9]*N} $Nom] } { set Fichier "$RepertoireDuGenome/trousmsf/$Nom" } if { [regexp {TRNA|ARN} $Nom] } { set Fichier "$RepertoireDuGenome/msf/$Nom" } if {[file exists $Fichier]} { return [SeeAby Show $Nom] } if { [YaPABdans $Nom] } { set Fichier "$RepertoireDuGenome/prottfa/$Nom" } if { [regexp {TROU[0-9]*[A-F]} $Nom] } { set Fichier "$RepertoireDuGenome/trousprottfa/$Nom" } if { [regexp {TROU[0-9]*N} $Nom] } { set Fichier "$RepertoireDuGenome/nuctfa/$Nom" } if { [regexp {TRNA|ARN} $Nom] } { set Fichier "$RepertoireDuGenome/nuctfa/$Nom" } if {[file exists $Fichier]} { return [AfficheFichier $Fichier "AvecSeeBlastAvecBlasteAvecFormate"] } if { [YaPABdans $Nom] } { set Fichier "$RepertoireDuGenome/ver/$Nom" } if { [regexp {TROU[0-9]*[A-F]} $Nom] } { set Fichier "$RepertoireDuGenome/trousprottfa/$Nom" } if { [regexp {TROU[0-9]*N} $Nom] } { set Fichier "$RepertoireDuGenome/nuctfa/$Nom" } if { [regexp {TRNA|ARN} $Nom] } { set Fichier "$RepertoireDuGenome/nuctfa/$Nom" } if {[file exists $Fichier]} { return [AfficheFichier $Fichier "AvecSeeBlastAvecBlasteAvecFormate"] } } proc FetcheCourant {w} { return [AfficheFetch [NomDuCourant $w]] } proc FeuilleDist {} { global TokCourant set LabelFeuille [AlphaNum] if {[regexp "NonValide" $LabelFeuille]} { return "FeuilleDistNonValideCar$LabelFeuille" } set ValeurDist [ValeurDist] if {[regexp "NonValide" $ValeurDist]} { return "FeuilleDistNonValideCar$ValeurDist" } return [list $LabelFeuille $ValeurDist] } proc FiSeqOl {P} { if {$P=="LaListeMerci"} { foreach F [glob -nocomplain "[RepertoireDuGenome]/oligos/P*.tfa"] { set NomP [file tail $F] regsub ".tfa$" $NomP "" NomP lappend LesPs $NomP } return $LesPs } return "[RepertoireDuGenome]/oligos/$P.tfa" } proc FiabiliteFonction {Nom} { set FF [string range [ExtraitInfo $Nom "Fonction"] 0 0] if { $FF == "" } { return 0 } return $FF } proc FicheDefDuBlastX {} { set Sortie [list] foreach ORF [LesPABsDansLOrdre] { lappend Sortie "$ORF [ExtraitInfo $ORF "DE_BLASTX"]" } EcritFichier $Sortie "[RepertoireDuGenome]/fiches/defdublastx.out" } proc FicheEMBLPourProttfaVidePourTous {} { foreach F [glob -nocomplain "[RepertoireDuGenome]/protemblVide/*"] { set Nom [file tail $F] Espionne "$Nom" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set LesLignes [LesLignesDuFichier $FichierProttfa] set PremiereLigne [lindex $LesLignes 0] set LesMots [LesMotsDeLaLigne $PremiereLigne] set IndexProt [expr [llength $LesMots] -1] set AccessProt [lindex $LesMots $IndexProt] Espionne "**$AccessProt" set LesLignesEMBL [LaSequenceDesBanques $AccessProt "OnVeutEMBL"] Espionne "--$LesLignesEMBL" if {$LesLignesEMBL == {}} { continue } set FichierEMBL "[GscopeFile $Nom protembl]" set D [SauveLesLignes $LesLignesEMBL dans $FichierEMBL] Espionne "$Nom $AccessProt [file tail $D]\n[join $LesLignesEMBL "\n"]" } } proc FicheInfos_PG16_140Seq {{FichierTableau ""}} { global RepertoireDuGenome if {$FichierTableau == ""} { FaireLire "Choisir le fichier contenant le tableau" set FichierTableau [ButineArborescence All [pwd]] } set Owner "TL" set i 0 set F [open $FichierTableau] while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} incr i if {$i == 1} {continue} set Info "" set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 4] set AFFY [lindex $LaLigne 5] set Access [lindex $LaLigne 1] append Info "Nom: $Nom\nCodeClone: $Access\nAffymetrix: $AFFY\nOwnerOfCDNA: $Owner\n" set WT1 [lindex $LaLigne 6 ] set WT2 [lindex $LaLigne 8 ] set AvWT [lindex $LaLigne 10] set RD11 [lindex $LaLigne 11] set RD12 [lindex $LaLigne 13] set AvRD [lindex $LaLigne 15] set WTRD1 [lindex $LaLigne 16] set RD1WT [lindex $LaLigne 17] set PR [lindex $LaLigne 18] set Brain [lindex $LaLigne 20] set PRBrain [lindex $LaLigne 22] set Description [lindex $LaLigne 23] append Info "Expression WT: 35d_WT_1 $WT1\t35d_WT_2 $WT2\tAverage_WT $AvWT\n" append Info "Expression RD1: 35d_rd1_1 $RD11\t35d_rd1_2 $RD12\tAverage_rd1 $AvRD\n" append Info "Expression PR: $PR\n" append Info "Expression BRAIN: $Brain\n" append Info "FOLD: WT/rd1 $WTRD1\trd1/WT $RD1WT\tPR/BRAIN $PRBrain\n" append Info "Description: $Description\n" set FileInfo "$RepertoireDuGenome/infos/$Nom" Sauve $Info dans $FileInfo Espionne $Info } close $F return "" } proc FicheInfos_bbkkvv {{FichierTableau ""}} { global RepertoireDuGenome if {$FichierTableau == ""} { FaireLire "Choisir le fichier contenant le tableau" set FichierTableau [ButineArborescence All [pwd]] } set Owner "TL" set i 0 set F [open $FichierTableau] while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} incr i if {$i == 1} {continue} set Info "" set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 4] set CodeClone "[lindex $LaLigne 1] [lindex $LaLigne 5]" append Info "Nom: $Nom\nCodeClone: $CodeClone\nOwnerOfCDNA: $Owner\n" set WT1 [lindex $LaLigne 6 ] set WT2 [lindex $LaLigne 8 ] set AvWT [lindex $LaLigne 10] set RD11 [lindex $LaLigne 11] set RD12 [lindex $LaLigne 13] set AvRD [lindex $LaLigne 15] set Fold [lindex $LaLigne 16] set PR [lindex $LaLigne 17] set Brain [lindex $LaLigne 19] set Description [lindex $LaLigne 21] append Info "Expression: Fold=$Fold ; wt 1=$WT1 ; wt 2=$WT2 ; Average wt=$AvWT ; rd1 1=$RD11 ; rd1 2=$RD12 ; Average rd=$AvRD ; PR=$PR ; Brain=$Brain\n" append Info "Description: $Description\n" set FileInfo "$RepertoireDuGenome/infos/$Nom" Sauve $Info dans $FileInfo Espionne $Info } close $F return "" } proc FicheMoi {{Qui ""} {Comment ""}} { PourWscope 1 if {$Qui==""} { set LesFiches [lsort [glob "[RepertoireDuGenome]/fiches/*"]] set LesRefText {} foreach Fichier $LesFiches { set Fiche [file tail $Fichier] lappend LesRefText "[WscopeScience]&FicheMoi&$Fiche" $Fiche } return [Html_ListOfRefs $LesRefText "

Please click to see the corresponding file

"] } if {$Comment==""} { set Comment "EnHTML" } set LesProbable {} lappend LesProbable "[RepertoireDuGenome]/fiches/$Qui" #rR on peut en rajouter d'autres ici ##################################################rR" if {[regexp "^rR/" $Qui]} { regsub "^rR/" $Qui "[HomeRipp]/" Qui lappend LesProbable $Qui } foreach Probable $LesProbable { if {[FileAbsent $Probable]} { continue } set Titre "[file tail [RepertoireDuGenome]]/fiches/$Qui" set Texte [ContenuDuFichier $Probable] #rR un peu de pudeur ... if {[file tail $Qui]=="gscope_canalsql.tcl"} { regsub -all {\{ *set Password [^\}]*\}} $Texte "{ set Password xxxxxx }" Texte } if {[regexp {\.html?$} $Qui]} { return $Texte } return [Html_DuTexteTelQuel $Texte $Titre] } return "Sorry, I can't find the file $Qui" } proc Fiches {{Fichier ""}} { if {$Fichier==""} { return "[RepertoireDuGenome]/fiches" } return "[RepertoireDuGenome]/fiches/$Fichier" } proc FichesInfosGscope_Table {{FichierTableau ""} {Save yes}} { global RepertoireDuGenome if {![file exists "$RepertoireDuGenome/beton/miniconfig"]} {return ""} foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/beton/miniconfig"] { if {![regexp "^PrefixeDesORFs " $Ligne]} {continue} regsub "^PrefixeDesORFs " $Ligne "" Ligne set BoxName [string trim $Ligne] break } if {$BoxName == ""} {return ""} if {$FichierTableau == ""} {set FichierTableau [ButineArborescence All [pwd]] } set RepTFA "$RepertoireDuGenome/nuctfa" set RepInfos "$RepertoireDuGenome/mRNAAndProt/EnteteInfos" if {![file exists $RepInfos]} {File mkdir "$RepInfos"} if {![file exists $FichierTableau ]} {return ""} foreach Ligne [LesLignesDuFichier $FichierTableau] { set NewInfos "" set LesInfos [split $Ligne "\t"] if {![regexp {^[0-9]} [lindex $LesInfos 0]] } { set PosCompleteId [lsearch $LesInfos "Probe set name"] set PosAccess [lsearch $LesInfos "Access" ] set PosBanque [lsearch $LesInfos "Banque" ] set PosRefGscope [lsearch $LesInfos "Ref Gscope" ] set PosDescription [lsearch $LesInfos "Description" ] set PosCategory [lsearch $LesInfos "Category" ] set PosSeqInfos [lsearch $LesInfos "Seq infos" ] set PosAverageWT [lsearch $LesInfos "Average WT" ] set PosAWT [lsearch $LesInfos "A WT" ] set PosAverageRd1 [lsearch $LesInfos "Average Rd1" ] set PosARd1 [lsearch $LesInfos "A Rd1" ] set PosFold [lsearch $LesInfos "Fold" ] continue } elseif {[regexp -nocase "No File" $Ligne]} { continue } else { set RefGscope [lindex $LesInfos $PosRefGscope] regexp "^($BoxName\[0-9]*)" $RefGscope tmp IdGscope set IdGscope [string trim $IdGscope] set IdGscopeDeRef $IdGscope set Owner "TL" set SeqInfos [lindex $LesInfos $PosSeqInfos] set CompleteId [lindex $LesInfos $PosCompleteId] set Access [lindex $LesInfos $PosAccess] set Banque [lindex $LesInfos $PosBanque] set AverageWT [lindex $LesInfos $PosAverageWT] set AWT [lindex $LesInfos $PosAWT] set AverageRd1 [lindex $LesInfos $PosAverageRd1] set ARd1 [lindex $LesInfos $PosARd1] set Fold [lindex $LesInfos $PosFold] set DescriptionTL [lindex $LesInfos $PosDescription] set CategoryTL [lindex $LesInfos $PosCategory] set InfoDeBoiteRef "Nom: $IdGscope\nCompleteId: $CompleteId\nAccess: $Access\nBanque: $Banque\nOwner of cDNA: $Owner\nExpression: Average WT=$AverageWT ; A WT=$AWT ; Average Rd1=$AverageRd1 ; A Rd1=$ARd1 ; Fold=$Fold\nDescription TL: $DescriptionTL\nCategory TL: $CategoryTL" set LesRefGscopesDesSplittes {} set LesAccessDesSplittes {} if {[regexp "split into" $RefGscope] && [regexp "Split into" $SeqInfos]} { regsub "$IdGscope split into " $RefGscope "" RefGscope append InfoDeBoiteRef "\nSplit into: $RefGscope" set LesRefGscopesDesSplittes [split $RefGscope " "] regsub "Split into " $SeqInfos "" SeqInfos set LesAccessDesSplittes [split $SeqInfos " "] if {[llength $LesRefGscopesDesSplittes] != [llength $LesAccessDesSplittes]} { Espionne "$IdGscope: ERROR" } } if {$Save == "yes"} {Sauve $InfoDeBoiteRef dans "$RepInfos/$IdGscope"} for {set i 0} {$i < [llength $LesAccessDesSplittes]} {incr i} { set Access [lindex $LesAccessDesSplittes $i] set IdGscope [lindex $LesRefGscopesDesSplittes $i] set IdGscope [string trim $IdGscope] set InfoDeBoiteRef "Nom: $IdGscope\nCompleteId: $CompleteId\nAccess: $Access\nBanque: $Banque\nOwner of cDNA: $Owner\nExpression: Average WT=$AverageWT ; A WT=$AWT ; Average Rd1=$AverageRd1 ; A Rd1=$ARd1 ; Fold=$Fold\nDescription TL: $DescriptionTL\nCategory TL: $CategoryTL" append InfoDeBoiteRef "\nFrom: $IdGscopeDeRef" if {$Save == "yes"} {Sauve $InfoDeBoiteRef dans "$RepInfos/$IdGscope"} } } } } proc FichierAccess2FichierTFAs {FichierAccess FichierTFAs} { if {![file exists $FichierAccess]} {return} set F [open $FichierAccess] set i 0 while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} scan $Ligne "%s" Access incr i Espionne "$Access\t$i" set SeqTFA [PageInfo $Access "genbank" "seq"] if {$SeqTFA == ""} {set SeqTFA ">$Access not found"} regsub "^>" $SeqTFA "" SeqTFA set PosAutreSeq [string first ">" $SeqTFA] if {0 < $PosAutreSeq} {set SeqTFA [string range $SeqTFA 0 [expr $PosAutreSeq - 1]]} set SeqTFA [SequenceFormatTFA [QueLaSequenceDuTexteTFA ">$SeqTFA"] ">$Access"] AppendAuFichier $FichierTFAs $SeqTFA } close $F return } proc FichierAjoutePN6et7_TL {File1 File2 FileOut} { set F [open $File1] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Access [string toupper [lindex $LaLigne 0]] if {$Access == ""} {continue} set Tab($Access,PN6,rd1) [lindex $LaLigne 2] set Tab($Access,PN7,rd1) [lindex $LaLigne 3] set Tab($Access,PN6,wt) [lindex $LaLigne 4] set Tab($Access,PN7,wt) [lindex $LaLigne 5] } close $F Espionne OK set n 0 set LeTexte {} set F [open $File2] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} incr n set LaLigne [split $Ligne "\t"] if {$n == 1} { set NbColDeRef [llength $LaLigne] lappend LeTexte "$Ligne\t6d wt\t6d rd1\t7d wt\t7d rd1" continue } set NbCol [llength $LaLigne] if {$NbCol < $NbColDeRef} { for {set i $NbCol} {$i < $NbColDeRef} {incr i} { lappend LaLigne "" } } set Access [string toupper [lindex $LaLigne 3]] if {$Access == ""} {continue} Espionne $Access if {[info exists Tab($Access,PN6,wt)]} { lappend LaLigne [set Tab($Access,PN6,wt)] } else { lappend LaLigne "" } if {[info exists Tab($Access,PN6,rd1)]} { lappend LaLigne [set Tab($Access,PN6,rd1)] } else { lappend LaLigne "" } if {[info exists Tab($Access,PN7,wt)]} { lappend LaLigne [set Tab($Access,PN7,wt)] } else { lappend LaLigne "" } if {[info exists Tab($Access,PN7,rd1)]} { lappend LaLigne [set Tab($Access,PN7,rd1)] } else { lappend LaLigne "" } lappend LeTexte [join $LaLigne "\t"] } close $F Sauve [join $LeTexte "\n"] dans $FileOut return } proc FichierAnchorsPour {Nom} { global RepertoireDuGenome global OptionsBallastPourJulie set FichierAnchors "$RepertoireDuGenome/ballast/$Nom.anchors" if {[file exists $FichierAnchors]} { return $FichierAnchors } Wup "Il faut le creer" set FichierBlastP "$RepertoireDuGenome/blastp/$Nom" if { ! [file exists $FichierBlastP]} { return "" } if { ! [info exists OptionsBallastPourJulie] && [file exists "$RepertoireDuGenome/ballast/$Nom"]} { set FichierBallast "$RepertoireDuGenome/ballast/$Nom" } else { set FichierBallast [Ballast $FichierBlastP] } if {$FichierBallast != "" && [regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} { set FichierBallast "" } if {$FichierBallast==""} { return "" } return "$FichierBallast.anchors" } proc FichierBestGeneOntologyPourTous {{LesNoms ""} {FileGOOut ""} {P 0.8} {FractionDuMax 0.5} {NormMDMin 0.3} {NbGOParTypePourLesMSF ""}} { if {$FileGOOut == ""} {set FileGOOut "[RepertoireDuGenome]/fiches/GeneOntology"} set FileGOProttfa "[RepertoireDuGenome]/fiches/GeneOntology_prottfa" set FileGOMSF "[RepertoireDuGenome]/fiches/GeneOntology_clustersdesmsf" set RepMSF "[RepertoireDuGenome]/msf" if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set LesOntologies {} foreach Nom $LesNoms { Espionne $Nom set FileMSF "$RepMSF/$Nom" ###Determination du cluster du msf contenant notre proteine###### set Cluster "" set AiJeVuUneProt 0 foreach AccessProttfa [InterrogeGeneOntology $FileGOProttfa $Nom LesAccess] { set AiJeVuUneProt 1 set Cluster [InterrogeGeneOntology $FileGOMSF $Nom Access $AccessProttfa Groupe] if {$Cluster == ""} { AppendAuFichier "[RepertoireDuGenome]/fiches/GeneOntology.log" "$Nom $AccessProttfa" break } } if {!$AiJeVuUneProt} {continue} if {$Cluster == "" } { set LesAccess [InterrogeGeneOntology $FileGOMSF $Nom LesAccess] } else { set LesAccess [InterrogeGeneOntology $FileGOMSF $Nom Groupe $Cluster LesAccess] } ###Calcul du NormMD des selectionnes###### set NormMD -9999.0 if {[file exists $FileMSF]} {set NormMD [MDScoreAvecSelectionDuFichier $FileMSF $LesAccess]} ###Selection des GO les plus representatifs de ce cluster####### ###On y ajoute les GO de notre proteine afin d'avoir les GO les plus precis possibles en considerant que les GO de notre proteine sont les meilleurs### set LesGO [InterrogeGeneOntology $FileGOProttfa $Nom LesGO] set TousLesGO $LesGO if {$NormMDMin <= $NormMD} { foreach Access $LesAccess { foreach GO [InterrogeGeneOntology $FileGOMSF Access $Access LesGO] { if {$GO == ""} {continue} lappend TousLesGO $GO } } set LesGO [concat $LesGO [LaSelectionDesMeilleursGO $TousLesGO $P $FractionDuMax $NbGOParTypePourLesMSF]] } if {$LesGO == {}} { lappend LesOntologies [join [list $Nom $Cluster $Nom "NoOntologyFound"] "\t"] continue } ###On elimine les ancetres et les doublons### foreach GO [EnterrerLesAncetresOntologiques [ElimineLesRedondancesDansUneListe $LesGO]] { set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set LesAncetres [TousLesAncetresOntologiques $Type $GO] set Ontologie [join [list $Nom $Cluster $Nom "$Type" "$GO" "$Def" "[join $LesAncetres "\t"]"] "\t"] Espionne $Ontologie lappend LesOntologies $Ontologie } } Sauve [join $LesOntologies "\n"] dans $FileGOOut return } proc FichierBestLocalisation {{LesNoms ""} {NameFichierOUT BestLocalisation_Human} {IdMin 0.8}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} if {![file exists "[RepertoireDuGenome]/Localisation"]} {file mkdir "[RepertoireDuGenome]/Localisation"} set TailleFragment 100000 set FichierOUT "[RepertoireDuGenome]/Localisation/$NameFichierOUT" set FLocmRNAHsap "[RepertoireDuGenome]/Localisation/mRNAHsapLocalisation_Human" if {[file exists $FLocmRNAHsap]} {set LocmRNAHsapExiste 1} else {set LocmRNAHsapExiste 0} set FLocProttfa "[RepertoireDuGenome]/Localisation/ProttfaLocalisation_Human" if {[file exists $FLocProttfa ]} {set LocProttfaExiste 1} else {set LocProttfaExiste 0} set FLocBox "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human" if {[file exists $FLocBox ]} {set LocBoxExiste 1} else {set LocBoxExiste 0} set LeTexte {} foreach Nom $LesNoms { set EstCeQueLaProteineEstOK 1 set EstCeQueLemRNAHumanEstOK 1 if { [file exists "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis"] || [file exists "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis"]} { #Validite de la proteine de ref (sequence presente et bon %Id avec seq initiale) if { ([InterrogeProtAndmRNAChoisis $Nom SeqChoisie ] != "SeqOK" || [InterrogeProtAndmRNAChoisis $Nom InfoSeqChoisie] != "") && ([InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK" || [InterrogeProtAndContigChoisis $Nom InfoSeqChoisie] != "") } { set EstCeQueLaProteineEstOK 0 } } if { [file exists "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga"] } { #Validite du mrna humain (sequence presente et bon %Id avec proteine de ref) set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccessmRNA == "" || [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] < $IdMin} { set EstCeQueLemRNAHumanEstOK 0 } } set LesLoc [InterrogeLocalisation $FLocBox Nom $Nom] set LesLocProt [InterrogeLocalisation $FLocProttfa Nom $Nom] set LesLocmRNA [InterrogeLocalisation $FLocmRNAHsap Nom $Nom] #si la proteine est bonne et le mrna humain est bon on utilise la localisation du mrna humain #si seulement la proteine est bonne on utilise la localisation de la proteine de ref #si ni la proteine de ref ni le mrna humain ne sont valides, on utilise la localisation de la sequence par defaut if {$EstCeQueLemRNAHumanEstOK && $LocmRNAHsapExiste && $LesLocmRNA != {}} { set LesLoc $LesLocmRNA } elseif {$EstCeQueLaProteineEstOK && $LocProttfaExiste && $LesLocProt != {}} { set LesLoc $LesLocProt } foreach LaLoc $LesLoc { if {0} { set Chrom [NumeroDuChromosome [lindex $LaLoc 9]] set DChrom [lindex $LaLoc 10] set FChrom [lindex $LaLoc 11] set BC [join [LesBandesCytologiquesDeLaRegion $Chrom $DChrom $FChrom] " "] set LaLoc [lreplace $LaLoc 19 19 $BC] } set Ligne [join $LaLoc "\t"] Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierBestProteinAndmRNAForeachOrgaPourTous {{LesNoms ""} {IdDesProtId 0.99} {IdMinStrict 0.3}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierOut "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" set RepMSF "[RepertoireDuGenome]/msf" set Continue 0 if {[file exists $FichierOut]} { if {[OuiOuNon "$FichierOut exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FichierOut] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Orga [lindex $LaLigne 1] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} if {![info exists DejaVu($Nom,$Orga)]} {set DejaVu($Nom,$Orga) 1} } } else { if {[OuiOuNon "$FichierOut exists.\nWould you want to deltree this file?"]} { File delete -force $FichierOut } } } foreach Nom $LesNoms { if {[info exists DejaVu($Nom)]} {continue} set FichierMSF "$RepMSF/$Nom" if {![file exists $FichierMSF ]} {continue} if {![DecortiqueUnMSF $FichierMSF LesAccess Sequences]} {continue} set Tab($Nom,LesOrgas) {} Espionne $Nom foreach Access $LesAccess { set Access [string toupper $Access] if {$Access == $Nom } {continue} if {[EstUnAccessPDB $Access]} {continue} set Id1 [IDdansMSF $FichierMSF $Query $Access SelonB] if {$Id1 < $IdMinStrict} {continue} set Id2 [IDdansMSF $FichierMSF $Query $Access SelonA] if {$Id2 < $IdMinStrict} {continue} if {$Id1 < $Id2} {set Id $Id1} else {set Id $Id2} foreach Orga [lsort -unique [LesOrgasDeLAccess $Access]] { if {[info exists Tab($Nom,$Orga,$Access)]} {continue} set Tab($Nom,$Orga,$Access) [list $Access $Id] if {![info exists Tab($Nom,$Orga,LesProteines)]} { set Tab($Nom,$Orga,LesProteines) {} lappend Tab($Nom,LesOrgas) $Orga } lappend Tab($Nom,$Orga,LesProteines) [list $Access $Id] } } foreach Orga [lsort -unique [set Tab($Nom,LesOrgas)]] { if {$Continue && [info exists DejaVu($Nom,$Orga)]} {continue} set LesProteines [set Tab($Nom,$Orga,LesProteines)] set LaProteine [lindex [lsort -index end -real -decreasing $LesProteines] 0] set AccessDeRef [lindex $LaProteine 0] set LesProteinesSelect {} set LesmRNAsSelect {} foreach LaProteine $LesProteines { set AccessProt [lindex $LaProteine 0] set IdAvecAccessDeRef [IDdansMSF $FichierMSF $AccessDeRef $AccessProt SelonB] if {$IdAvecAccessDeRef < $IdDesProtId} {continue} set IdAvecAccessDeRef [IDdansMSF $FichierMSF $AccessDeRef $AccessProt SelonA] if {$IdAvecAccessDeRef < $IdDesProtId} {continue} set PageInfoProt [PageInfo $AccessProt protein] set SeqProtDeRef [string toupper [string trim [LaSequenceDuTexteEMBL $PageInfoProt]]] regsub -nocase {^[M]*} $SeqProtDeRef "" SeqProtDeRef set TailleProt [TailleDeLaProt_PageInfo $PageInfoProt] lappend LesProteinesSelect [list $AccessProt $Id $TailleProt $PageInfoProt] foreach AccessGB [LesmRNAsDeLaProt_PageInfo $PageInfoProt] { set PageInfoGB [PageInfo $AccessGB genbankfull] if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfoGB]} {continue} set EstCeLeMemeOrga 0 foreach OrgaDumRNA [LesOrgasDeLaPage_PageInfo $PageInfoGB] { if {[string equal -nocase $OrgaDumRNA $Orga]} {set EstCeLeMemeOrga 1;break} } if {!$EstCeLeMemeOrga} {continue} set SeqProtDumRNA [string toupper [string trim [SeqProtDumRNA_PageInfo $PageInfoGB]]] regsub -nocase {^[M]*} $SeqProtDumRNA "" SeqProtDumRNA set EstCeLaMemeProt 0 if {$SeqProtDumRNA == $SeqProtDeRef} {set EstCeLaMemeProt 1} set Taille [TailleDeLAcNuc_PageInfo $PageInfoGB ] lappend LesmRNAsSelect [list $AccessGB $Taille $PageInfoGB $AccessProt $Id $TailleProt $PageInfoProt $EstCeLaMemeProt] } } if {$LesProteinesSelect == {}} {continue} if {$LesmRNAsSelect == {}} { set LaProteine [lindex [lsort -index 2 -real -decreasing $LesProteinesSelect] 0] set AccessProt [lindex $LaProteine 0] set Id [IDdansMSF $FichierMSF $Nom $AccessProt SelonA] set TailleDeLaProt [lindex $LaProteine 2] set PageInfoProt [lindex $LaProteine 3] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " "] Espionne "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" AppendAuFichier $FichierOut "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" continue } else { set LemRNA [lindex [lsort -index 7 -real -decreasing [lsort -index 1 -real -decreasing $LesmRNAsSelect] ] 0] set AccessGB [lindex $LemRNA 0] set TailleGB [lindex $LemRNA 1] set PageInfoGB [lindex $LemRNA 2] set DefGB [join [LaDefinitionDeLAcNuc_PageInfo $PageInfoGB] " "] set AccessProt [lindex $LemRNA 3] set Id [IDdansMSF $FichierMSF $Nom $AccessProt SelonA] set TailleProt [lindex $LemRNA 5] set PageInfoProt [lindex $LemRNA 6] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " "] set EstCeLaMemeProt [lindex $LemRNA 7] if {!$EstCeLaMemeProt} {set QuEstCe "Variant"} else {set QuEstCe ""} Espionne "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" AppendAuFichier $FichierOut "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" Espionne "$Nom\t$Orga\tmRNA\t$AccessGB\t$TailleGB\t$Id\t$DefGB\t$QuEstCe" AppendAuFichier $FichierOut "$Nom\t$Orga\tmRNA\t$AccessGB\t$TailleGB\t$Id\t$DefGB\t$QuEstCe" } } if {[info exists Sequences]} {unset Sequences} if {[info exists LesAccess]} {unset LesAccess} if {[info exists Tab ]} {unset Tab} } return } proc FichierBilanClustersXHdaFusionnes {{SeuilDistance 200}} { set Fichier "[RepertoireDuGenome]/fiches/bilan_fusionclustersXHda_seuilDistanceDPC$SeuilDistance" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_ClustersXHda" set LesInfos {} foreach Cl1 [O2C2O LesClusters] { foreach Cl2 [O2C2O LesClusters] { if {$Cl1 == $Cl2} {continue} if {$Cl1 == 114 || $Cl2 == 114} {continue} if {[info exists TabTmp($Cl1,$Cl2)] || [info exists TabTmp($Cl2,$Cl1)]} {continue} set TabTmp($Cl1,$Cl2) 1;set TabTmp($Cl2,$Cl1) 1 Espionne "$Cl1 $Cl2" set Dist [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 Distance] if {$Dist > $SeuilDistance} {continue} if {[info exists Tab($Cl1,CE)] && [info exists Tab($Cl2,CE)]} { set CEDeCl1 [set Tab($Cl1,CE)] set CEDeCl2 [set Tab($Cl2,CE)] if {$CEDeCl1 == $CEDeCl2} {continue} #if {![info exists Tab($CEDeCl2,LesCE)]} {set Tab($Cl2,CE) [set Tab($CEDeCl2,CE)]} foreach Cluster [set Tab($CEDeCl2,LesCE)] { set Tab($Cluster,CE) [set Tab($Cl1,CE)] lappend Tab($CEDeCl1,LesCE) $Cluster } lappend Tab($CEDeCl1,LesCE) $CEDeCl2 if {[info exists Tab($CEDeCl2,LesCE)]} {unset Tab($CEDeCl2,LesCE)} continue } if {[info exists Tab($Cl1,CE)] && ![info exists Tab($Cl2,CE)]} { set CEDeCl1 [set Tab($Cl1,CE)] lappend Tab($CEDeCl1,LesCE) $Cl2 set Tab($Cl2,CE) $CEDeCl1 continue } if {[info exists Tab($Cl2,CE)] && ![info exists Tab($Cl1,CE)]} { set CEDeCl2 [set Tab($Cl2,CE)] lappend Tab($CEDeCl2,LesCE) $Cl1 set Tab($Cl1,CE) $CEDeCl2 continue } set Tab($Cl1,CE) $Cl1 set Tab($Cl2,CE) $Cl1 set Tab($Cl1,LesCE) [list $Cl1 $Cl2] } } set NbClusters 0 set NbOrfsFusionnees 0 foreach Cl [O2C2O LesClusters] { if {![info exists Tab($Cl,CE)]} {lappend LesInfos $Cl;incr NbClusters} if { [info exists Tab($Cl,LesCE)]} { set LesCE [lsort -unique [set Tab($Cl,LesCE)]] lappend LesInfos [join $LesCE "\t"] incr NbClusters foreach CE $LesCE { set TCl [O2C2O Cluster $CE TailleCluster] set NbOpCl [O2C2O Cluster $CE NbOperonsDansCluster] set PAllOrga [O2C2O Cluster $CE Categorie AllOrganism Presence] set POrgasInt [O2C2O Cluster $CE Categorie OrganismeInteressant Presence] set PBact [O2C2O Cluster $CE Categorie Bacteria Presence] set PFirm [O2C2O Cluster $CE Categorie Firmicutes Presence] set PProteo [O2C2O Cluster $CE Categorie Proteobacteria Presence] set PArchaea [O2C2O Cluster $CE Categorie Archaea Presence] set PEu [O2C2O Cluster $CE Categorie Eukaryota Presence] incr NbOrfsFusionnees $TCl set InfoCl "$CE\t$TCl\t$NbOpCl\t$PAllOrga\t$POrgasInt\t$PBact\t$PFirm\t$PProteo\t$PArchaea\t$PEu" foreach Def [InterrogeGeneOntology $FichierGO Groupe $CE Type "process" LesDefinitions] { append InfoCl "\t$Def"} lappend LesInfos $InfoCl } } } Espionne $NbClusters Espionne $NbOrfsFusionnees EspionneL $LesInfos Sauve [join $LesInfos "\n"] dans $Fichier return } proc FichierBilanGOTissueTypeDevStageDomainesSurClusters_AL {FichierOUT} { set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierGOProteo "[GODBDir]/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" Espionne "Populations des clusters" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set Tab(Cluster,$Cluster,LesIndividusGO) {} set Tab(Cluster,$Cluster,LesIndividusTT) {} set Tab(Cluster,$Cluster,LesIndividusDS) {} set Tab(Cluster,$Cluster,LesIndividusDO) {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $Cluster LesNoms] { if {1} { ####Tissue Type#################################### set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusTT) $LIndividu } ####Dev Stage#################################### set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusDS) $LIndividu } } if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu } } if {1} { ###Domaines####################################### set LIndividu {} foreach LeDom [InterrogeDomaines $Nom LesDomaines] { set Type [lindex $LeDom 0] set Dom [lindex $LeDom 1] set Def [lindex $LeDom 2] if {$Def == ""} {continue} lappend LIndividu $Dom set Tab(Dom,$Dom,Def) $Def set Tab(Dom,$Dom,Type) $Type } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusDO) $LIndividu } } } } Espionne "OK" if {[info exists TabDeJaVu]} {unset TabDeJaVu} set LesIndividusGODeLaPop1 {} set LesIndividusTTDeLaPop1 {} set LesIndividusDSDeLaPop1 {} set LesIndividusDODeLaPop1 {} Espionne "Populations totales selectionnees" foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesNoms] { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {1} { ####Tissue Type#################################### set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]] if {$LIndividu != {}} { lappend LesIndividusTTDeLaPop1 $LIndividu } ####Dev Stage#################################### set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]] if {$LIndividu != {}} { lappend LesIndividusDSDeLaPop1 $LIndividu } } if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu != {}} { set LIndividu [lsort -unique $LIndividu] lappend LesIndividusGODeLaPop1 $LIndividu } } if {1} { ###Domaines####################################### set LIndividu {} foreach LeDom [InterrogeDomaines $Nom LesDomaines] { set Type [lindex $LeDom 0] set Dom [lindex $LeDom 1] set Def [lindex $LeDom 2] if {$Def == ""} {continue} lappend LIndividu $Dom set Tab(Dom,$Dom,Def) $Def set Tab(Dom,$Dom,Type) $Type } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend LesIndividusDODeLaPop1 $LIndividu } } } Espionne OK Espionne "Lecture Du FichierGO du Proteome" #Gene Ontology du proteome humain##### set LesIndividusGODeLaPop2 {} if {1} { foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu] } } Espionne "OK" Espionne "Calcul" set LeTexte {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)] set LesIndividusTT [set Tab(Cluster,$Cluster,LesIndividusTT)] set LesIndividusDS [set Tab(Cluster,$Cluster,LesIndividusDS)] set LesIndividusDO [set Tab(Cluster,$Cluster,LesIndividusDO)] ###GO GO GO GO################ foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop1] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } ####Tissue Type##################### foreach LeTT [LesZscoreDesRequetesDuGroupe $LesIndividusTT $LesIndividusTTDeLaPop1] { set TT [lindex $LeTT 0] set r [lindex $LeTT 2] if {$r <= 0} {continue} set Stat [join [lrange $LeTT 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat" } ###Dev Stage##################### foreach LeDS [LesZscoreDesRequetesDuGroupe $LesIndividusDS $LesIndividusDSDeLaPop1] { set DS [lindex $LeDS 0] set r [lindex $LeDS 2] if {$r <= 0} {continue} set Stat [join [lrange $LeDS 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat" } ###Domaines##################### foreach LeDO [LesZscoreDesRequetesDuGroupe $LesIndividusDO $LesIndividusDODeLaPop1] { set DO [lindex $LeDO 0] set r [lindex $LeDO 2] if {$r <= 0} {continue} set Def [set Tab(Dom,$DO,Def)] set Type [set Tab(Dom,$DO,Type)] set Stat [join [lrange $LeDO 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" } } Espionne "OK" Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierBilanMaskingPourTous {{LesNoms ""}} { set File "[RepertoireDuGenome]/fiches/BilanMasking" if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set LeTexte {} foreach Nom $LesNoms { foreach Ligne [BilanMasking $Nom] {lappend LeTexte $Ligne} } if {$LeTexte == {}} {return} Sauve [join $LeTexte "\n"] dans $File return $LeTexte } proc FichierBilanProteinesPourTous_PO_OLD {{FichierOut ""}} { #!!! Procedure transformee en proc FichierBilanProteines_ComparaisonDDExperiencesPourTous_PO #set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_573.200408031437" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_DD2_2254.20041029" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set LeTexte {} lappend LeTexte [join [list Name ID Cluster GeneName MeanDef GPOFunc GPOProc GPOComp Method AccessProt DefProt TailleProt OrgaProt AccessmRNA DefmRNA TaillemRNA OrgamRNA AccessContig OrgaContig ID_VSSeqIni ID_ContigVSProt] "\t"] Espionne $FichierOCADE foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set FileProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {[info exists TabDeJaVu($Cluster,$Nom) ]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} set Ligne [join [FichierBilanProteines_PO $Nom] "\t"] Espionne $Ligne lappend LeTexte $Ligne } } if {$FichierOut != ""} {Sauve [join $LeTexte "\n"] dans $FichierOut} return } proc FichierBilanProteines_ComparaisonDDExperiencesPourTous_PO {} { set FichierOut "[RepertoireDuGenome]/fiches/BilanProteines_ComparaisonDDExperiences" set LesDDExperiences [list DD1 DD2] set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set LeTexte {} lappend LeTexte [join [list Name ID DDExperience Cluster LesDDExperiences LesJumelles GeneName MeanDef GPOFunc GPOProc GPOComp Method AccessProt DefProt TailleProt OrgaProt AccessmRNA DefmRNA TaillemRNA OrgamRNA AccessContig OrgaContig ID_VSSeqIni ID_ContigVSProt] "\t"] ###Premier cyle de boucles pour rassembler les infos sur les jumelles entre DDExperience### Espionne "Premier cycle" foreach DDExperience $LesDDExperiences { Espionne "$DDExperience" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_$DDExperience" if {![file exists $FichierOCADE]} {Espionne "$FichierOCADE does not exists" ; return} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { #LesDDExperiences pour Nom if {![info exists TabJumelleDDExperiences($Nom,LesDDExperiences)]} { set TabJumelleDDExperiences($Nom,LesDDExperiences) {} } if {![info exists TabJumelleDDExperiences($Nom,$DDExperience)]} { set TabJumelleDDExperiences($Nom,$DDExperience) 1 lappend TabJumelleDDExperiences($Nom,LesDDExperiences) $DDExperience } #LesDDExperiences pour chaque proteine jumelle foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] { if {[info exists TabJumelleDDExperiences($Jum,$DDExperience)]} {continue} if {![info exists TabJumelleDDExperiences($Jum,LesDDExperiences)]} { set TabJumelleDDExperiences($Jum,LesDDExperiences) {} } set TabJumelleDDExperiences($Jum,$DDExperience) 1 lappend TabJumelleDDExperiences($Jum,LesDDExperiences) $DDExperience } #Espionne "Nom,$Nom: [set TabJumelleDDExperiences($Nom,LesDDExperiences)]" foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] { #Espionne "Jum,$Jum: [set TabJumelleDDExperiences($Jum,LesDDExperiences)]" } } } } ###Second cyle de boucles pour ecrire les infos dans le fichier de sortie### ###On insere l'info LesDDExperiences dans la sortie de la proc FichierBilanProteines_ComparaisonDDExperiences_PO Espionne "Second cycle" foreach DDExperience $LesDDExperiences { Espionne $DDExperience set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_$DDExperience" if {![file exists $FichierOCADE]} {Espionne "$FichierOCADE does not exists" ; return} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { Espionne $Cluster foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { #Pour une DDExperience, l'info est ajoutee dans le fichier pour seulement une des prot jumelles # si plusieurs jumelles sont presentes dans un meme cluster de la meme DDExperience if {[info exists TabDeJaVu($DDExperience,$Cluster,$Nom) ]} {continue} set TabDeJaVu($DDExperience,$Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] { set TabDeJaVu($DDExperience,$Cluster,$Jum) 1 } set LesInfos [FichierBilanProteines_ComparaisonDDExperiences_PO $Nom $FichierOCADE $DDExperience] set LesDDExperiences [set TabJumelleDDExperiences($Nom,LesDDExperiences)] set LesInfos [linsert $LesInfos 4 $LesDDExperiences] set Ligne [join $LesInfos "\t"] Espionne $Ligne lappend LeTexte $Ligne } } } Sauve [join $LeTexte "\n"] dans $FichierOut InterrogeProteinesJumelles unset return } proc FichierBilanProteines_ComparaisonDDExperiences_PO {Nom FichierOCADE DDExperience} { set FileGOXML "[RepertoireDuGenome]/GeneOntology/$Nom.xml" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] set AccessIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] ###LesProteinesJumelles### set LesJumelles [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] ###Les noms des genes des proteines du même cluster de msf que la proteine de ref### set GeneNameTxt "" if {[InterrogeGeneName $Nom LesGeneNames] != ""} { set LesGeneNames {} foreach GN [InterrogeGeneName $Nom LesGeneNames] { if {$GN == ""} {continue} set N [InterrogeGeneName $Nom GeneName $GN n] regsub -nocase {^[a-z0-9]+\=} [string trim $GN] "" GN lappend LesGeneNames [list $GN $N] } if {$LesGeneNames != {}} { set LesGeneNamesEtLeurEffectif {} foreach LeGN [lsort -index 1 -decreasing -integer $LesGeneNames] { lappend LesGeneNamesEtLeurEffectif "[lindex $LeGN 0] ([lindex $LeGN 1])" } set GeneNameTxt [join $LesGeneNamesEtLeurEffectif " ; "] } } ###Mean Definition### set MeanDefTxt [InterrogeDefinitionsConsensus $Nom Definition] ###Commencons maintenant le boulot pour la meilleure proteine trouvee#### set MethodTxt "" set AccessProtTxt "" set DefProtTxt "" set LengthProtTxt "" set OrgaProtTxt "" set AccessmRNATxt "" set DefmRNATxt "" set LengthmRNATxt "" set OrgamRNATxt "" set PID1Txt "" set PID2Txt "" set AccessContTxt "" set OrgaContTxt "" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set TailleProt [TailleDeLaSequenceDuFichierTFA $FichierProttfa] set InfoSeq [InterrogeProtAndmRNAChoisis $Nom SeqChoisie] if {$InfoSeq != ""} { if {$InfoSeq == "SeqOK"} { set MethodTxt "ProtAndmRNA" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {![string equal -nocase $AccessProt "NoProtein"]} { set AccessProtTxt $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProtTxt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LengthProtTxt [TailleDeLaProt_PageInfo $PageInfoProt] set OrgaProtTxt [join [LesOrgasDeLaPage_PageInfo $PageInfoProt] " ; "] } if {![string equal -nocase $AccessmRNA "NomRNA"]} { set AccessmRNATxt $AccessmRNA set PageInfomRNA [PageInfo $AccessmRNA genbankfull "id acc des org"] set DefmRNATxt [join [LaDefinitionDeLAcNuc_PageInfo $PageInfomRNA] " " ] set OrgamRNATxt [join [LesOrgasDeLaPage_PageInfo $PageInfomRNA] " ; "] set LengthmRNATxt [TailleDeLAcNuc_PageInfo $PageInfomRNA] } set Rang 1 set Id [InterrogeProtAndmRNA $Nom Rang $Rang Id] if {$Id != ""} {set PID1Txt [format "%.1f" [expr $Id * 100]]} } else { set AccessProt [string toupper [InterrogeContigAndProt $Nom Protein Access]] if {$AccessProt != ""} { set MethodTxt "Contig" set AccessProtTxt $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProtTxt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LengthProtTxt [TailleDeLaProt_PageInfo $PageInfoProt] set OrgaProtTxt [join [LesOrgasDeLaPage_PageInfo $PageInfoProt] " ; "] set AccessContTxt [string toupper [InterrogeContigAndProt $Nom Contig Access]] set OrgaContTxt [InterrogeContigAndProt $Nom Contig Organisme] set Id [InterrogeContigAndProt $Nom Contig Identity ] if {$Id != ""} {set PID1Txt [format "%.1f" [expr $Id * 100]]} set Id [InterrogeContigAndProt $Nom Protein Identity ] if {$Id != ""} {set PID2Txt [format "%.1f" [expr $Id * 100]]} } } } set GPOFuncTxt "" set GPOProcTxt "" set GPOCompTxt "" foreach Type [list "function" "process" "component"] { set LeTexte {} foreach GO [AskGOAnalyse $FileGOXML Methode GPO Type $Type LesGO] { set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] lappend LeTexte $Def } if {$Type == "function" } {set GPOFuncTxt [join $LeTexte " ; "]} if {$Type == "process" } {set GPOProcTxt [join $LeTexte " ; "]} if {$Type == "component"} {set GPOCompTxt [join $LeTexte " ; "]} } return [list $Nom $AccessIni $DDExperience $Cluster $LesJumelles $GeneNameTxt $MeanDefTxt $GPOFuncTxt $GPOProcTxt $GPOCompTxt $MethodTxt $AccessProtTxt $DefProtTxt $LengthProtTxt $OrgaProtTxt $AccessmRNATxt $DefmRNATxt $LengthmRNATxt $OrgamRNATxt $AccessContTxt $OrgaContTxt $PID1Txt $PID2Txt] } proc FichierBilanProteines_PO_OLD {Nom} { #!!! Procedure transformee en proc FichierBilanProteines_ComparaisonDDExperiences_PO #set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_573.200408031437" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression_DD2_2254.20041029" set FileGOXML "[RepertoireDuGenome]/GeneOntology/$Nom.xml" set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] set AccessIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] ###Les noms des genes des proteines du même cluster de msf que la proteine de ref### set GeneNameTxt "" if {[InterrogeGeneName $Nom LesGeneNames] != ""} { set LesGeneNames {} foreach GN [InterrogeGeneName $Nom LesGeneNames] { if {$GN == ""} {continue} set N [InterrogeGeneName $Nom GeneName $GN n] regsub -nocase {^[a-z0-9]+\=} [string trim $GN] "" GN lappend LesGeneNames [list $GN $N] } if {$LesGeneNames != {}} { set LesGeneNamesEtLeurEffectif {} foreach LeGN [lsort -index 1 -decreasing -integer $LesGeneNames] { lappend LesGeneNamesEtLeurEffectif "[lindex $LeGN 0] ([lindex $LeGN 1])" } set GeneNameTxt [join $LesGeneNamesEtLeurEffectif " ; "] } } ###Mean Definition### set MeanDefTxt [InterrogeDefinitionsConsensus $Nom Definition] ###Commencons maintenant le boulot pour la meilleure proteine trouvee#### set MethodTxt "" set AccessProtTxt "" set DefProtTxt "" set LengthProtTxt "" set OrgaProtTxt "" set AccessmRNATxt "" set DefmRNATxt "" set LengthmRNATxt "" set OrgamRNATxt "" set PID1Txt "" set PID2Txt "" set AccessContTxt "" set OrgaContTxt "" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set TailleProt [TailleDeLaSequenceDuFichierTFA $FichierProttfa] set InfoSeq [InterrogeProtAndmRNAChoisis $Nom SeqChoisie] if {$InfoSeq != ""} { if {$InfoSeq == "SeqOK"} { set MethodTxt "ProtAndmRNA" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {![string equal -nocase $AccessProt "NoProtein"]} { set AccessProtTxt $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProtTxt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LengthProtTxt [TailleDeLaProt_PageInfo $PageInfoProt] set OrgaProtTxt [join [LesOrgasDeLaPage_PageInfo $PageInfoProt] " ; "] } if {![string equal -nocase $AccessmRNA "NomRNA"]} { set AccessmRNATxt $AccessmRNA set PageInfomRNA [PageInfo $AccessmRNA genbankfull "id acc des org"] set DefmRNATxt [join [LaDefinitionDeLAcNuc_PageInfo $PageInfomRNA] " " ] set OrgamRNATxt [join [LesOrgasDeLaPage_PageInfo $PageInfomRNA] " ; "] set LengthmRNATxt [TailleDeLAcNuc_PageInfo $PageInfomRNA] } set Rang 1 set Id [InterrogeProtAndmRNA $Nom Rang $Rang Id] if {$Id != ""} {set PID1Txt [format "%.1f" [expr $Id * 100]]} } else { set AccessProt [string toupper [InterrogeContigAndProt $Nom Protein Access]] if {$AccessProt != ""} { set MethodTxt "Contig" set AccessProtTxt $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProtTxt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LengthProtTxt [TailleDeLaProt_PageInfo $PageInfoProt] set OrgaProtTxt [join [LesOrgasDeLaPage_PageInfo $PageInfoProt] " ; "] set AccessContTxt [string toupper [InterrogeContigAndProt $Nom Contig Access]] set OrgaContTxt [InterrogeContigAndProt $Nom Contig Organisme] set Id [InterrogeContigAndProt $Nom Contig Identity ] if {$Id != ""} {set PID1Txt [format "%.1f" [expr $Id * 100]]} set Id [InterrogeContigAndProt $Nom Protein Identity ] if {$Id != ""} {set PID2Txt [format "%.1f" [expr $Id * 100]]} } } } set GPOFuncTxt "" set GPOProcTxt "" set GPOCompTxt "" foreach Type [list "function" "process" "component"] { set LeTexte {} foreach GO [AskGOAnalyse $FileGOXML Methode GPO Type $Type LesGO] { set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] lappend LeTexte $Def } if {$Type == "function" } {set GPOFuncTxt [join $LeTexte " ; "]} if {$Type == "process" } {set GPOProcTxt [join $LeTexte " ; "]} if {$Type == "component"} {set GPOCompTxt [join $LeTexte " ; "]} } return [list $Nom $AccessIni $Cluster $GeneNameTxt $MeanDefTxt $GPOFuncTxt $GPOProcTxt $GPOCompTxt $MethodTxt $AccessProtTxt $DefProtTxt $LengthProtTxt $OrgaProtTxt $AccessmRNATxt $DefmRNATxt $LengthmRNATxt $OrgamRNATxt $AccessContTxt $OrgaContTxt $PID1Txt $PID2Txt] } proc FichierBlastPDuPAB {Nom} { global RepertoireDuGenome return "$RepertoireDuGenome/blastp/$Nom" } proc FichierBlastReduit {FichierBlast NewFichierBlast {EnFonctionDe Expect} {SeuilOuValeurs 0.001} {Keep ""}} { #EnFonctionDe -> # LesBIdToKeep # LesBIdToEliminate # LesSegmentsDesBIdToKeep # LesAccessToKeep # LesAccessToEliminate # LesOrgaToKeep # LesOrgaToEliminate # LesmRNAsToKeep # LesmRNAsToEliminate # SensToKeep # SensToEliminate # Expect # Score # JusteLePremierAlignementDesSubjects # LesRegionsToEliminate (Elimination des segments possedant ces regions) # LesRegionsToKeep (Segments possedant les regions a conserver) # NbSubjectMax # NbAliMax # TailleAlignementMin # TailleAlignementMax # Positives # PositivesWithoutFilter # Identity # IdentityWithoutFilter # NbPositivesSurTailleQuery # NbPositivesSurTailleQueryWithoutFilter # RegionsAligneesSurRegionsAlignables # RegionsAligneesSurRegionsDansAlignement # RegionsAligneesSurRegionsDansAlignementSubject # RegionsAligneesSurTailleQuery # RegionsAligneesSurTailleSubject # RegionsAligneesSurTailleQueryDansLeMeilleurDesSens # RegionsAligneesSurTailleSubjectDansLeMeilleurDesSens set FichierTmp "[TmpFile].reduceblast" if {$FichierBlast != $NewFichierBlast} { if {[file exists $NewFichierBlast]} { if {$Keep == ""} { #if {[OuiOuNon "$NewFichierBlast exists, Would you want to conserv it?"]} {set Keep 1} else {set Keep 0} set Keep 0 } if {$Keep == 1 } {return} File delete -force $NewFichierBlast } } set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] set LesBId {} foreach LeSubject [LaSelectionDesSegmentsDuBlast $FichierBlast $EnFonctionDe $SeuilOuValeurs] { set BId [lindex $LeSubject 0] lappend LesBId $BId set ExpectDeRef 1e200 set ScoreDeRef 0 set LesSegments [lindex $LeSubject 1] set TabTmp($BId) $LesSegments foreach Segment $LesSegments { set TabTmp($BId,$Segment) 1 set Score [AskBlast $FichierBlast BanqueId $BId Segment $Segment Score ] set Expect [AskBlast $FichierBlast BanqueId $BId Segment $Segment Expect] scan $Score "%f" Score if {$Expect < $ExpectDeRef} {set ExpectDeRef $Expect} if {$ScoreDeRef < $Score } {set ScoreDeRef $Score } } set TabTmp($BId,Score) $ScoreDeRef set TabTmp($BId,Expect) $ExpectDeRef } set F [open $FichierBlast] set LeTexte {} while {[gets $F Ligne]>=0} { lappend LeTexte $Ligne if {$LesBId == {} && [regexp -nocase "^Searching......." $Ligne]} {break} if {[regexp -nocase "^Sequences producing significant" $Ligne] } {break} } close $F AppendAuFichier $FichierTmp "[join $LeTexte "\n"]\n" if {$LesBId == {}} { AppendAuFichier $FichierTmp "\n***** No hits found ******\n" } else { set LeTexte {} foreach BId $LesBId { set Access [AskBlast $FichierBlast BanqueId $BId Access] set Definition [AskBlast $FichierBlast BanqueId $BId Definition] set Score [set TabTmp($BId,Score)] set Expect [set TabTmp($BId,Expect)] set Entete "$BId $Access $Definition" if {[string length $Entete] < 67} { set Taille [string length $Entete] set nDiff [expr 67 - $Taille] append Entete [string repeat " " $nDiff] } else { set Entete [string range $Entete 0 66] } set ScoreEtExpect [format " %5s %-6s" $Score $Expect] append Entete $ScoreEtExpect lappend LeTexte $Entete } AppendAuFichier $FichierTmp [join $LeTexte "\n"] set LeTexte {} foreach BId $LesBId { set Access [AskBlast $FichierBlast BanqueId $BId Access] set Definition [AskBlast $FichierBlast BanqueId $BId Definition] set Taille [AskBlast $FichierBlast BanqueId $BId Taille] set Description "\n>$BId $Access $Definition" set AiJeDejaEcris 0 while {$Description != ""} { if {$AiJeDejaEcris} {set Description " $Description"} set n [string length $Description] if {$n < 80} { lappend LeTexte "$Description" set Description "" } else { lappend LeTexte [string range $Description 0 80] set Description [string range $Description 81 end] } set AiJeDejaEcris 1 } lappend LeTexte " Length = $Taille\n" if {![info exists TabTmp($BId)]} {continue} foreach Seg [set TabTmp($BId)] { lappend LeTexte [AskBlast $FichierBlast BanqueId $BId Segment $Seg AlignBrut] } } AppendAuFichier $FichierTmp [join $LeTexte "\n"] } if {[info exists TabTmp]} {unset TabTmp} AskBlast unsetfile $FichierBlast set F [open $FichierBlast] set LeTexte {} set SuisJeSurLaFinDuBlast 0 while {[gets $F Ligne]>=0} { if {[regexp -nocase "^ Database: " $Ligne]} {set SuisJeSurLaFinDuBlast 1} if {$SuisJeSurLaFinDuBlast} {lappend LeTexte $Ligne} } close $F AppendAuFichier $FichierTmp [join $LeTexte "\n"] File rename -force $FichierTmp $NewFichierBlast return $NewFichierBlast } proc FichierBlastReduitPourTous {RepBlast RepBlastOut {EnFonctionDe Expect} {SeuilOuValeurs 0.001} {Keep ""}} { if {$Keep == ""} {if {[OuiOuNon "if some files exists in $RepBlastOut, Would you want to conserv them?"]} {set Keep 1} else {set Keep 0}} if {![file exists $RepBlastOut]} {File mkdir $RepBlastOut} foreach File [glob -nocomplain "$RepBlast/*"] { if {![file exists $File]} {continue} Espionne $File set NameFile [file tail $File] set FileNew "$RepBlastOut/$NameFile" FichierBlastReduit $File $FileNew $EnFonctionDe $SeuilOuValeurs $Keep } return "" } proc FichierBoxLocalisation {{NameFileLoc BoxLocalisation_Human} {NameRepBlast blastnhuman} {ExpectMax 0.001} {NbSbjctMax 250}} { global RepertoireDuGenome set RepLocHuman "[HumanGenomeDir]/Localisation" set FichierContigs "$RepLocHuman/seq_contig.md" if {![file exists $FichierContigs]} { Espionne "$FichierContigs does not exist" return "" } set FichierBandesCytos "$RepLocHuman/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set RepLoc "$RepertoireDuGenome/Localisation" if {![file exists $RepLoc]} {File mkdir "$RepLoc"} set FileLoc "$RepertoireDuGenome/Localisation/$NameFileLoc" set RepBlast "$RepertoireDuGenome/$NameRepBlast" ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos ChargeContigsDesChromosomes Contigs $FichierContigs set TailleContig 100000 set LesNoms [ListeDesPABs] if {[file exists $FileLoc]} { if {[OuiOuNon "$FileLoc exists.\nIf the file is not finished would you want to continue?"]} { set F [open $FileLoc] while {[gets $F Ligne]>=0} { scan $Ligne "%s" Nom if {[info exists TabTmp($Nom)]} {continue} set TabTmp($Nom) 1 } close $F set LesNoms {} foreach Nom [ListeDesPABs] { if {[info exists TabTmp($Nom)]} {continue} lappend LesNoms $Nom } if {[info exists TabTmp]} {unset TabTmp} } } foreach Nom $LesNoms { set FichierBlastGenome "$RepBlast/$Nom" if {![file exists $FichierBlastGenome]} {AppendAuFichier $FileLoc [list $Nom NoBlastFile];continue} if {[info exists TabBlast]} {unset TabBlast} DepouilleLeBlast TabBlast $FichierBlastGenome $ExpectMax $NbSbjctMax set NbSubjectDansBlast [set TabBlast(NbSubject)] if {![info exists TabBlast(NbSubject)]} {AppendAuFichier $FileLoc [list $Nom NoLoc];continue} if {[set TabBlast(NbSubject)] == 0} {AppendAuFichier $FileLoc [list $Nom NoLoc];continue} ### Definition des variables de references pour definir la monolocalisation####### set ContigDeRef [set TabBlast(1)] set LeContigDeRef [LeContig $ContigDeRef] set ChromDeRef [lindex $LeContigDeRef 0] set AccessDeRef [lindex $LeContigDeRef 1] set NbFragment [lindex $LeContigDeRef 3] set BorneFragment [expr $NbFragment*$TailleContig] set ScoreDeRef [set TabBlast($ContigDeRef,1,Score) ] regexp {^([e0-9\.\+]*) bits} $ScoreDeRef tmp ScoreDeRef set ExpectDeRef [set TabBlast($ContigDeRef,1,Expect)] set DQDeRef [set TabBlast($ContigDeRef,1,DQ)] set FQDeRef [set TabBlast($ContigDeRef,1,FQ)] set DSDeRef [expr [set TabBlast($ContigDeRef,1,DS)] + $BorneFragment] set FSDeRef [expr [set TabBlast($ContigDeRef,1,FS)] + $BorneFragment] if {$FSDeRef < $DSDeRef} {set tmp $FSDeRef;set FSDeRef $DSDeRef;set DSDeRef $tmp} ##########Determination de la monolocalisation################################# set LesSubjectsPoly {} set ListePoly {} set ListeMayBe {} set NbSubjct 0 set LesContigs {} set AiJeDejaVuLaRef 0 for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set Contig [set TabBlast($i)] set Expect [set TabBlast($Contig,1,Expect)] if {$ExpectMax < $Expect} {continue} incr NbSubjct if {$NbSbjctMax <= $NbSubjct} {break} set Score [set TabBlast($Contig,1,Score)] lappend LesContigs $Contig set LeContig [LeContig $Contig] set Access [lindex $LeContig 1] set NbFragment [lindex $LeContig 3] if {![info exists TabBlast($Access,ExpectDeRef)]} {set TabBlast($Access,ExpectDeRef) $Expect} if {![info exists TabBlast($Access,ScoreDeRef) ]} {set TabBlast($Access,ScoreDeRef) $Score} set BorneFragment [expr $NbFragment*$TailleContig] set Score [set TabBlast($Contig,1,Score) ] regexp {^([e0-9\.\+]*) bits} $Score tmp Score set DQ [set TabBlast($Contig,1,DQ) ] set FQ [set TabBlast($Contig,1,FQ) ] set DS [expr [set TabBlast($Contig,1,DS)] + $BorneFragment] set FS [expr [set TabBlast($Contig,1,FS)] + $BorneFragment] if {$FS < $DS} {set tmp $FS;set FS $DS;set DS $tmp} if {$Access == $AccessDeRef} { if { $ExpectDeRef <= $Expect && $ScoreDeRef <= $Score && $DQ == $DQDeRef && $FQ == $FQDeRef } { if { $AiJeDejaVuLaRef && $DSDeRef != $DS && $FSDeRef != $FS} { lappend ListePoly $Access lappend LesSubjectsPoly $i } if { !$AiJeDejaVuLaRef && $DSDeRef == $DS && $FSDeRef == $FS} { lappend ListePoly $Access lappend LesSubjectsPoly $i set AiJeDejaVuLaRef 1 } } } else { if {$ExpectDeRef <= $Expect && $ScoreDeRef <= $Score} { lappend ListePoly $Access lappend LesSubjectsPoly $i } else { lappend ListeMayBe $Access } } } set nPoly [llength $ListePoly] set nMayBe [llength $ListeMayBe] if {$nPoly == 1 && $nMayBe == 0} { set InfoLocalisation "MonoLoc" } elseif {$nPoly == 1 && $nMayBe != 0} { set InfoLocalisation "MayBePolyLoc" } elseif {1 < $nPoly} { set InfoLocalisation "PolyLoc" } elseif {$nPoly == 0 && $nMayBe == 0} { set InfoLocalisation "NoLoc" } if {$InfoLocalisation == "NoLoc"} {AppendAuFichier $FileLoc [list $Nom NoLoc];continue} ############################################################## if {[info exists TabTmp]} {unset TabTmp} set LesLocalisations {} set i 0 foreach Contig $LesContigs { incr i set LeContig [LeContig $Contig] set Chromosome [lindex $LeContig 0] set Access [lindex $LeContig 1] set Fragment [lindex $LeContig 2] set NbFragment [lindex $LeContig 3] set BorneFragment [expr $NbFragment*$TailleContig] set ExpectDeRef [set TabBlast($Access,ExpectDeRef)] set ScoreDeRef [set TabBlast($Access,ScoreDeRef)] regexp {^([e0-9\.\+]*) bits} $ScoreDeRef tmp ScoreDeRef set NbSegment [set TabBlast($Contig,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { set PId [PourcentageDIdentiteDuSegmentDeLId_TabBlast TabBlast $Contig $j] set Expect [set TabBlast($Contig,$j,Expect)] if {$ExpectMax < $Expect} {continue} set Info "" if {($InfoLocalisation == "MonoLoc" || $InfoLocalisation == "MayBePolyLoc") && $i == 1 && $j == 1} { set Info "BestLoc" } elseif { $InfoLocalisation == "PolyLoc" && [regexp $i [join $LesSubjectsPoly " "]] && $j == 1} { set Info "BestPolyLoc" } set Score [set TabBlast($Contig,$j,Score) ] regexp {^([e0-9\.\+]*) bits} $Score tmp Score set Orientation [set TabBlast($Contig,$j,Orientation)] set Sens [SensDeLaRegion $Orientation] set DQ [set TabBlast($Contig,$j,DQ) ] set FQ [set TabBlast($Contig,$j,FQ) ] if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp} set DS [expr [set TabBlast($Contig,$j,DS)] + $BorneFragment] set FS [expr [set TabBlast($Contig,$j,FS)] + $BorneFragment] if {$FS < $DS} {set tmp $FS;set FS $DS;set DS $tmp} if {[info exists TabTmp($DQ,$FQ,$DS,$FS)]} {continue} set TabTmp($DQ,$FQ,$DS,$FS) 1 set LesBandesCytologiques [LesBandesCytologiquesDeLaLocalisation $Access $DS $FS ] set LesCoordonnees [CoordonneesSurChromosome $Access $DS $FS $Sens] set DSurChr [lindex $LesCoordonnees 1] set FSurChr [lindex $LesCoordonnees 2] set SensSurChr [lindex $LesCoordonnees 3] lappend LesLocalisations [list $Nom $InfoLocalisation $ExpectDeRef $Expect $ScoreDeRef $Score [format "%.2f" $PId] $DQ $FQ $Chromosome $DSurChr $FSurChr $SensSurChr $Access $Fragment $DS $FS $Orientation $Sens [join $LesBandesCytologiques " "] $Info] } } foreach Loc [lsort -index 9 [lsort -index 13 [lsort -index 4 -real -decreasing [lsort -integer -index 7 [lsort -integer -index 8 $LesLocalisations]]]]] { Espionne $Loc AppendAuFichier $FileLoc [join $Loc "\t"] } } return $FileLoc } proc FichierCaracteristiquesClustersFusionnesParDistanceDPC {{SeuilDistance 200}} { set Fichier "[RepertoireDuGenome]/fiches/caracteristiques_clXHda_fusionnnes_DistanceDPC$SeuilDistance" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_ClustersXHda" set LesInfos {} set NbDoublons 0 foreach Cl1 [O2C2O LesClusters] { foreach Cl2 [O2C2O LesClusters] { set LInfo {} if {[info exists TabTmp($Cl1,$Cl2)] || [info exists TabTmp($Cl2,$Cl1)]} {continue} if {$Cl1 == $Cl2} {continue} set TabTmp($Cl1,$Cl2) 1 set TabTmp($Cl2,$Cl1) 1 set Dist [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 Distance] if {$Dist > $SeuilDistance} {continue} set Dist [format "%.1f" $Dist] incr NbDoublons set NbCommonOp [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 NbOperonsCommuns] Espionne "$Cl1\t$Cl2\t$Dist\t$NbCommonOp" lappend LesInfos "$Cl1\t$Cl2\t$Dist\t$NbCommonOp" foreach Cluster [list $Cl1 $Cl2] { set TCl [O2C2O Cluster $Cluster TailleCluster] set NbOpCl [O2C2O Cluster $Cluster NbOperonsDansCluster] set PAllOrga [O2C2O Cluster $Cluster Categorie AllOrganism Presence] set POrgasInt [O2C2O Cluster $Cluster Categorie OrganismeInteressant Presence] set PBact [O2C2O Cluster $Cluster Categorie Bacteria Presence] set PFirm [O2C2O Cluster $Cluster Categorie Firmicutes Presence] set PProteo [O2C2O Cluster $Cluster Categorie Proteobacteria Presence] set PArchaea [O2C2O Cluster $Cluster Categorie Archaea Presence] set PEu [O2C2O Cluster $Cluster Categorie Eukaryota Presence] set Info "$Cluster\t$TCl\t$NbOpCl\t$PAllOrga\t$POrgasInt\t$PBact\t$PFirm\t$PProteo\t$PArchaea\t$PEu" foreach Def [InterrogeGeneOntology $FichierGO Groupe $Cluster Type "process" LesDefinitions] {append Info "\t$Def"} Espionne $Info lappend LesInfos $Info } } } Espionne $NbDoublons Sauve [join $LesInfos "\n"] dans $Fichier return } proc FichierCategoriesPhylogenetiques {{LesOrganismes ""}} { global RepertoireDuGenome set LeTexte {} if {$LesOrganismes == {}} {set LesOrganismes [LesGenomesComplets]} foreach Organisme $LesOrganismes { set LOrga {} set OrgaCourt [Glossaire $Organisme Court] set OC [OCduOS $Organisme] if {$OC == "ClassUnknown" && $Organisme == "Buchnera sp."} {set OC [OCduOS "Buchnera aphidicola"]} regsub "\.$" $OC "" OC regsub -all "; " $OC ";" OC set LesTaxons [split $OC ";"] lappend LOrga $Organisme lappend LOrga $OrgaCourt foreach Taxon $LesTaxons {lappend LOrga $Taxon} if {[FamiliarOrganism $Organisme]} {lappend LOrga "OrganismeInteressant"} lappend LeTexte [join $LOrga "\t"] } EspionneL $LeTexte set Fichier "$RepertoireDuGenome/fiches/categories_phylogenetiques" Sauve [join $LeTexte "\n"] dans $Fichier return $Fichier } proc FichierChiffresMaskingDesClusters_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" if {![file exists $Fichier]} {return} set LesNoms [LesNoms $PABouNomsInteressantsouListeouFichier] set FichierOut "[RepertoireDuGenome]/PourTL/ChiffresMaskingDesClusters" set Tab(All,LesNoms) $LesNoms set Tab(All,NbSeqTot) 0 set Tab(All,NbSeqContig) 0 set Tab(All,NbSeqmRNA) 0 set Tab(All,NbSeqNoProt) 0 set Tab(All,TailleSeqTot) 0 set Tab(All,TailleSeqContig) 0 set Tab(All,TailleSeqmRNA) 0 set Tab(All,TailleSeqNoProt) 0 foreach Etat [InterrogeBilanMasking LesEtats] { set Tab(All,$Etat,NbSeqTot) 0 set Tab(All,$Etat,NbSeqTot50) 0 set Tab(All,$Etat,NbSeqTot90) 0 set Tab(All,$Etat,NbRepeatTot) 0 set Tab(All,$Etat,PMaskingTot) 0 set Tab(All,$Etat,NbSeqmRNA) 0 set Tab(All,$Etat,NbSeqmRNA50) 0 set Tab(All,$Etat,NbSeqmRNA90) 0 set Tab(All,$Etat,NbRepeatmRNA) 0 set Tab(All,$Etat,PMaskingmRNA) 0 set Tab(All,$Etat,NbSeqContig) 0 set Tab(All,$Etat,NbSeqContig50) 0 set Tab(All,$Etat,NbSeqContig90) 0 set Tab(All,$Etat,NbRepeatContig) 0 set Tab(All,$Etat,PMaskingContig) 0 set Tab(All,$Etat,NbSeqNoProt) 0 set Tab(All,$Etat,NbSeqNoProt50) 0 set Tab(All,$Etat,NbSeqNoProt90) 0 set Tab(All,$Etat,NbRepeatNoProt) 0 set Tab(All,$Etat,PMaskingNoProt) 0 } foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {![info exists Tab($Cluster,LesNoms)]} { Espionne "Cluster $Cluster" lappend LesClusters $Cluster set Tab($Cluster,LesNoms) {} set Tab($Cluster,NbSeqTot) 0 set Tab($Cluster,NbSeqContig) 0 set Tab($Cluster,NbSeqmRNA) 0 set Tab($Cluster,NbSeqNoProt) 0 set Tab($Cluster,TailleSeqTot) 0 set Tab($Cluster,TailleSeqContig) 0 set Tab($Cluster,TailleSeqmRNA) 0 set Tab($Cluster,TailleSeqNoProt) 0 foreach Etat [InterrogeBilanMasking LesEtats] { set Tab($Cluster,$Etat,NbSeqTot) 0 set Tab($Cluster,$Etat,NbSeqTot50) 0 set Tab($Cluster,$Etat,NbSeqTot90) 0 set Tab($Cluster,$Etat,NbRepeatTot) 0 set Tab($Cluster,$Etat,PMaskingTot) 0 set Tab($Cluster,$Etat,NbSeqmRNA) 0 set Tab($Cluster,$Etat,NbSeqmRNA50) 0 set Tab($Cluster,$Etat,NbSeqmRNA90) 0 set Tab($Cluster,$Etat,NbRepeatmRNA) 0 set Tab($Cluster,$Etat,PMaskingmRNA) 0 set Tab($Cluster,$Etat,NbSeqContig) 0 set Tab($Cluster,$Etat,NbSeqContig50) 0 set Tab($Cluster,$Etat,NbSeqContig90) 0 set Tab($Cluster,$Etat,NbRepeatContig) 0 set Tab($Cluster,$Etat,PMaskingContig) 0 set Tab($Cluster,$Etat,NbSeqNoProt) 0 set Tab($Cluster,$Etat,NbSeqNoProt50) 0 set Tab($Cluster,$Etat,NbSeqNoProt90) 0 set Tab($Cluster,$Etat,NbRepeatNoProt) 0 set Tab($Cluster,$Etat,PMaskingNoProt) 0 } } lappend Tab($Cluster,LesNoms) $Nom set TailleBoite [string length [QueLaSequenceDuTFA "[RepertoireDuGenome]/nuctfa/$Nom"]] incr Tab($Cluster,TailleSeqTot) $TailleBoite incr Tab($Cluster,NbSeqTot) incr Tab(All,TailleSeqTot) $TailleBoite incr Tab(All,NbSeqTot) foreach Etat [InterrogeBilanMasking $Nom LesEtats] { set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] if {$P == "" || $P <= 0} {continue} set n [llength [InterrogeBilanMasking $Nom Etat $Etat LesRepeats]] set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] incr Tab($Cluster,$Etat,NbSeqTot) incr Tab($Cluster,$Etat,NbRepeatTot) $n set Tab($Cluster,$Etat,PMaskingTot) [expr [set Tab($Cluster,$Etat,PMaskingTot)] + $P] if {50 <= $P} {incr Tab($Cluster,$Etat,NbSeqTot50)} if {90 <= $P} {incr Tab($Cluster,$Etat,NbSeqTot90)} incr Tab(All,$Etat,NbSeqTot) incr Tab(All,$Etat,NbRepeatTot) $n if {50 <= $P} {incr Tab(All,$Etat,NbSeqTot50)} if {90 <= $P} {incr Tab(All,$Etat,NbSeqTot90)} set Tab(All,$Etat,PMaskingTot) [expr [set Tab($Cluster,$Etat,PMaskingTot)] + $P] } if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] == "SeqOK"} { incr Tab($Cluster,NbSeqmRNA) incr Tab($Cluster,TailleSeqmRNA) $TailleBoite incr Tab(All,NbSeqmRNA) incr Tab(All,TailleSeqmRNA) $TailleBoite foreach Etat [InterrogeBilanMasking $Nom LesEtats] { set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] if {$P == "" || $P <= 0} {continue} set n [llength [InterrogeBilanMasking $Nom Etat $Etat LesRepeats]] set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] incr Tab($Cluster,$Etat,NbSeqmRNA) incr Tab($Cluster,$Etat,NbRepeatmRNA) $n set Tab($Cluster,$Etat,PMaskingmRNA) [expr [set Tab($Cluster,$Etat,PMaskingmRNA)] + $P] if {50 <= $P} {incr Tab($Cluster,$Etat,NbSeqmRNA50)} if {90 <= $P} {incr Tab($Cluster,$Etat,NbSeqmRNA90)} incr Tab(All,$Etat,NbSeqmRNA) if {50 <= $P} {incr Tab(All,$Etat,NbSeqmRNA50)} if {90 <= $P} {incr Tab(All,$Etat,NbSeqmRNA90)} incr Tab(All,$Etat,NbRepeatmRNA) $n set Tab(All,$Etat,PMaskingmRNA) [expr [set Tab($Cluster,$Etat,PMaskingmRNA)] + $P] } } elseif {[InterrogeProtAndContigChoisis $Nom SeqChoisie] == "SeqOK"} { incr Tab($Cluster,NbSeqContig) incr Tab($Cluster,TailleSeqContig) $TailleBoite incr Tab(All,NbSeqContig) incr Tab(All,TailleSeqContig) $TailleBoite foreach Etat [InterrogeBilanMasking $Nom LesEtats] { set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] if {$P == "" || $P <= 0} {continue} set n [llength [InterrogeBilanMasking $Nom Etat $Etat LesRepeats]] set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] incr Tab($Cluster,$Etat,NbSeqContig) incr Tab($Cluster,$Etat,NbRepeatContig) $n set Tab($Cluster,$Etat,PMaskingContig) [expr [set Tab($Cluster,$Etat,PMaskingContig)] + $P] if {50 <= $P} {incr Tab($Cluster,$Etat,NbSeqContig50)} if {90 <= $P} {incr Tab($Cluster,$Etat,NbSeqContig90)} incr Tab(All,$Etat,NbSeqContig) if {50 <= $P} {incr Tab(All,$Etat,NbSeqContig50)} if {90 <= $P} {incr Tab(All,$Etat,NbSeqContig90)} incr Tab(All,$Etat,NbRepeatContig) $n set Tab(All,$Etat,PMaskingContig) [expr [set Tab($Cluster,$Etat,PMaskingContig)] + $P] } } else { incr Tab($Cluster,NbSeqNoProt) incr Tab($Cluster,TailleSeqNoProt) $TailleBoite incr Tab(All,NbSeqNoProt) incr Tab(All,TailleSeqNoProt) $TailleBoite foreach Etat [InterrogeBilanMasking $Nom LesEtats] { set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] if {$P == "" || $P <= 0} {continue} set n [llength [InterrogeBilanMasking $Nom Etat $Etat LesRepeats]] set P [InterrogeBilanMasking $Nom Etat $Etat PMasked] incr Tab($Cluster,$Etat,NbSeqNoProt) incr Tab($Cluster,$Etat,NbRepeatNoProt) $n set Tab($Cluster,$Etat,PMaskingNoProt) [expr [set Tab($Cluster,$Etat,PMaskingNoProt)] + $P] if {50 <= $P} {incr Tab($Cluster,$Etat,NbSeqNoProt50)} if {90 <= $P} {incr Tab($Cluster,$Etat,NbSeqNoProt90)} incr Tab(All,$Etat,NbSeqNoProt) if {50 <= $P} {incr Tab(All,$Etat,NbSeqNoProt50)} if {90 <= $P} {incr Tab(All,$Etat,NbSeqNoProt90)} incr Tab(All,$Etat,NbRepeatNoProt) $n set Tab(All,$Etat,PMaskingNoProt) [expr [set Tab($Cluster,$Etat,PMaskingNoProt)] + $P] } } } set LesInfos {} lappend LesClusters "All" foreach Cluster $LesClusters { Espionne $Cluster set Type "mRNA/Prot" set NbSeq [set Tab($Cluster,NbSeqmRNA)] set Taille [expr [set Tab($Cluster,TailleSeqmRNA)] * 1.0 / $NbSeq] set LInfo [list $Cluster $Type $NbSeq $Taille] foreach Etat [InterrogeBilanMasking LesEtats] { set NbSeqM [set Tab($Cluster,$Etat,NbSeqmRNA)] set NbSeqM50 [set Tab($Cluster,$Etat,NbSeqmRNA50)] set NbSeqM90 [set Tab($Cluster,$Etat,NbSeqmRNA90)] if {$NbSeqM == 0} {lappend LInfo $Etat 0 0 0 0 0;continue} set NbRepeatMoyen [expr [set Tab($Cluster,$Etat,NbRepeatmRNA)] * 1.0 / $NbSeqM] set PMasking [expr [set Tab($Cluster,$Etat,PMaskingmRNA)] * 1.0 / $NbSeqM] lappend LInfo $Etat $NbSeqM $NbSeqM50 $NbSeqM90 $NbRepeatMoyen $PMasking } lappend LesInfos [join $LInfo "\t"] set Type "Contig" set NbSeq [set Tab($Cluster,NbSeqContig)] set Taille [expr [set Tab($Cluster,TailleSeqContig)] * 1.0 / $NbSeq] set LInfo [list $Cluster $Type $NbSeq $Taille] foreach Etat [InterrogeBilanMasking LesEtats] { set NbSeqM [set Tab($Cluster,$Etat,NbSeqContig)] set NbSeqM50 [set Tab($Cluster,$Etat,NbSeqContig50)] set NbSeqM90 [set Tab($Cluster,$Etat,NbSeqContig90)] if {$NbSeqM == 0} {lappend LInfo $Etat 0 0 0 0 0;continue} set NbRepeatMoyen [expr [set Tab($Cluster,$Etat,NbRepeatContig)] * 1.0 / $NbSeqM] set PMasking [expr [set Tab($Cluster,$Etat,PMaskingContig)] * 1.0 / $NbSeqM] lappend LInfo $Etat $NbSeqM $NbSeqM50 $NbSeqM90 $NbRepeatMoyen $PMasking } lappend LesInfos [join $LInfo "\t"] set Type "NoProt" set NbSeq [set Tab($Cluster,NbSeqNoProt)] set Taille [expr [set Tab($Cluster,TailleSeqNoProt)] * 1.0 / $NbSeq] set LInfo [list $Cluster $Type $NbSeq $Taille] foreach Etat [InterrogeBilanMasking LesEtats] { set NbSeqM [set Tab($Cluster,$Etat,NbSeqNoProt)] set NbSeqM50 [set Tab($Cluster,$Etat,NbSeqNoProt50)] set NbSeqM90 [set Tab($Cluster,$Etat,NbSeqNoProt90)] if {$NbSeqM == 0} {lappend LInfo $Etat 0 0 0 0 0;continue} set NbRepeatMoyen [expr [set Tab($Cluster,$Etat,NbRepeatNoProt)] * 1.0 / $NbSeqM] set PMasking [expr [set Tab($Cluster,$Etat,PMaskingNoProt)] * 1.0 / $NbSeqM] lappend LInfo $Etat $NbSeqM $NbSeqM50 $NbSeqM90 $NbRepeatMoyen $PMasking } lappend LesInfos [join $LInfo "\t"] set Type "Tot" set NbSeq [set Tab($Cluster,NbSeqTot)] set Taille [expr [set Tab($Cluster,TailleSeqTot)] * 1.0 / $NbSeq] set LInfo [list $Cluster $Type $NbSeq $Taille] foreach Etat [InterrogeBilanMasking LesEtats] { set NbSeqM [set Tab($Cluster,$Etat,NbSeqTot)] set NbSeqM50 [set Tab($Cluster,$Etat,NbSeqTot50)] set NbSeqM90 [set Tab($Cluster,$Etat,NbSeqTot90)] if {$NbSeqM == 0} {lappend LInfo $Etat 0 0 0 0 0;continue} set NbRepeatMoyen [expr [set Tab($Cluster,$Etat,NbRepeatTot)] * 1.0 / $NbSeqM] set PMasking [expr [set Tab($Cluster,$Etat,PMaskingTot)] * 1.0 / $NbSeqM] lappend LInfo $Etat $NbSeqM $NbSeqM50 $NbSeqM90 $NbRepeatMoyen $PMasking } lappend LesInfos [join $LInfo "\t"] } EspionneL $LesInfos Sauve [join $LesInfos "\n"] dans $FichierOut return } proc FichierChiffresSurDensiteChromosomique_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set FichierOUT "[RepertoireDuGenome]/PourTL/DensiteChromosomique" set FRepartGenes "[HumanGenomeDir]/Localisation/RepartitionDesGenes" set FRepartSeq "[RepertoireDuGenome]/Localisation/RepartitionSurGenome" if {![file exists $FRepartGenes] || ![file exists $FRepartSeq]} {return} set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" if {![file exists $Fichier]} {return} set LesClusters [lsort -unique [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters]] set LesNoms [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] foreach Nom $LesNoms {set Tab($Nom) 1} set LeTexte {} set NbSeqTotAllCluster [llength $LesNoms] set NbGenesTot [llength [lsort -unique [InterrogeRepartitionSurGenome $FRepartGenes LesElements]]] foreach Chromosome [InterrogeRepartitionSurGenome $FRepartGenes LesChromosomes] { foreach TypeDeRegion [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome LesTypesDeRegion] { foreach Region [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome TypeDeRegion $TypeDeRegion LesRegions] { set NbGenes [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Region NbElements] set Taille [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Region Taille] set D [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Region Debut] set F [InterrogeRepartitionSurGenome $FRepartGenes Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Region Fin] set NbSeqAllCluster 0 set PGenes [expr $NbGenes * 1.0 / $NbGenesTot] set EspacesGenes 0 if {$NbGenes != 0} {set EspaceGenes [expr $Taille * 1.0 / $NbGenes]} foreach ClusterDeRef $LesClusters { set NbSeqTot [llength [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $ClusterDeRef LesNoms]] set NbSeq 0 foreach Nom [InterrogeRepartitionSurGenome $FRepartSeq Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Region LesElements] { if {![info exists Tab($Nom)]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {$Cluster != $ClusterDeRef} {continue} incr NbSeqAllCluster incr NbSeq } set PSeq 0 if {$NbSeqTot != 0} {set PSeq [expr $NbSeq * 1.0 / $NbSeqTot]} set EspaceSeq 0 if {$NbSeq != 0} {set EspaceSeq [expr $Taille * 1.0 / $NbSeq]} if {$NbSeqTot == 0 || $NbGenes == 0} { set Biais 0 } else { set Biais [expr $NbGenesTot * $NbSeq * 100.0 / ($NbSeqTot * $NbGenes * 1.0)] } Espionne "$ClusterDeRef\t$Chromosome\t$TypeDeRegion\t$Region\t$D\t$F\t$Taille\t$NbSeq\t$NbSeqTot\t$PSeq\t$EspaceSeq\t$NbGenes\t$NbGenesTot\t$PGenes\t$EspaceGenes\t$Biais" lappend LeTexte "$ClusterDeRef\t$Chromosome\t$TypeDeRegion\t$Region\t$D\t$F\t$Taille\t$NbSeq\t$NbSeqTot\t$PSeq\t$EspaceSeq\t$NbGenes\t$NbGenesTot\t$PGenes\t$EspaceGenes\t$Biais" } set PSeq 0 if {$NbSeqTotAllCluster != 0} {set PSeq [expr $NbSeqAllCluster * 1.0 / $NbSeqTotAllCluster]} set EspaceSeq 0 if {$NbSeqAllCluster != 0} {set EspaceSeq [expr $Taille * 1.0 / $NbSeqAllCluster]} if {$NbSeqTotAllCluster == 0 || $NbGenes == 0} { set Biais 0 } else { set Biais [expr $NbGenesTot * $NbSeqAllCluster * 100.0 / ($NbSeqTotAllCluster * $NbGenes * 1.0)] } Espionne "AllCluster\t$Chromosome\t$TypeDeRegion\t$Region\t$D\t$F\t$Taille\t$NbSeqAllCluster\t$NbSeqTotAllCluster\t$PSeq\t$EspaceSeq\t$NbGenes\t$NbGenesTot\t$PGenes\t$EspaceGenes\t$Biais" lappend LeTexte "AllCluster\t$Chromosome\t$TypeDeRegion\t$Region\t$D\t$F\t$Taille\t$NbSeqAllCluster\t$NbSeqTotAllCluster\t$PSeq\t$EspaceSeq\t$NbGenes\t$NbGenesTot\t$PGenes\t$EspaceGenes\t$Biais" } } } Sauve [join $LeTexte "\n"] dans $FichierOUT } proc FichierChiffresSurDomainesDesClusters_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants} {IdMinDesDomaines 0.75}} { set FichierOut "[RepertoireDuGenome]/PourTL/ChiffresDomainesDesClusters" set LesNoms [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set N 0 set LesClusters {} foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] != "SeqOK" && [InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK"} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {![info exists Tab($Cluster,R)]} { lappend LesClusters $Cluster set Tab($Cluster,R) 0 set Tab($Cluster,LesDomaines) {} } foreach LeDomaine [InterrogeDomaines $Nom LesDomaines] { set Id [lindex $LeDomaine end] if {$Id < $IdMinDesDomaines} {continue} set Type [lindex $LeDomaine 0 ] if {$Type == "FEATURE" } {continue} set Def [lindex $LeDomaine 2 ] if {$Def == "" } {continue} set Domaine [lindex $LeDomaine 1 ] if {[info exists TabDejaVu($Nom,$Domaine)]} {continue} set TabDejaVu($Nom,$Domaine) 1 set Tab($Domaine,Def) $Def if {![info exists Tab($Domaine,n)]} {set Tab($Domaine,n) 0} if {![info exists Tab($Cluster,$Domaine,r)]} { lappend Tab($Cluster,LesDomaines) $Domaine set Tab($Cluster,$Domaine,r) 0 } incr Tab($Domaine,n) incr Tab($Cluster,$Domaine,r) } incr Tab($Cluster,R) incr N } set LeTexte {} foreach Cluster $LesClusters { set R [set Tab($Cluster,R)] foreach Domaine [set Tab($Cluster,LesDomaines)] { set Def [set Tab($Domaine,Def)] set n [set Tab($Domaine,n)] set r [set Tab($Cluster,$Domaine,r)] set Zscore [ZScore $r $R $n $N] lappend LeTexte "$Cluster\t$Domaine\t$Def\t$r\t$R\t$n\t$N\t$Zscore" Espionne "$Cluster\t$Domaine\t$Def\t$r\t$R\t$n\t$N\t$Zscore" } } Sauve [join $LeTexte "\n"] dans $FichierOut return } proc FichierChiffresSurGODesClusters_AL {FichierGO FichierGOProteo FichierOut {NiveauGOMin 0} {ZscoreMin 0} {nMin 1}} { set LesNoms [ListeDesPABs] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set N 0 InterrogeOrf2Cluster2Access2Def2Expression unset InterrogeProteinesJumelles unset InterrogeGeneOntology unset Espionne "GO Projet" #Gene Ontology du projet#### foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} incr N #Espionne "$Cluster $Nom" if {![info exists Tab(Cluster,$Cluster,R) ]} { set Tab(Cluster,$Cluster,R) 0 set Tab(Cluster,$Cluster,LesGO) {} } incr Tab(Cluster,$Cluster,R) set LesGO {} foreach GO [lsort -unique [InterrogeGeneOntology $FichierGO $Nom LesGO]] { foreach Type [GODB GO $GO LesTypes] { set Tab($GO,Type) $Type set Niveau [lindex [lsort -integer [GODB Type $Type GO $GO LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GO} foreach GOAncetre [lsort -unique [InterrogeGeneOntology $FichierGO GO $GO LesAncetres]] { set Tab($GOAncetre,Type) $Type set Niveau [lindex [lsort -integer [GODB Type $Type GO $GOAncetre LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GOAncetre} } } } foreach GO [lsort -unique $LesGO] { if {![info exists Tab(GO,$GO,n) ]} {set Tab(GO,$GO,n) 0} if {![info exists Tab(GO,$GO,Cluster,$Cluster,r)]} { set Tab(GO,$GO,Cluster,$Cluster,r) 0 lappend Tab(Cluster,$Cluster,LesGO) $GO } incr Tab(GO,$GO,Cluster,$Cluster,r) incr Tab(GO,$GO,n) } } Espionne "GO Proteome humain" if {1} { #Gene Ontology du proteome humain##### set NProteo 0 foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { incr NProteo set LesGO {} foreach GO [lsort -unique [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO]] { foreach Type [GODB GO $GO LesTypes] { set Tab($GO,Type) $Type set Niveau [lindex [lsort -integer [GODB Type $Type GO $GO LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GO} foreach GOAncetre [lsort -unique [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres]] { set Niveau [lindex [lsort -integer [GODB Type $Type GO $GOAncetre LesNiveaux]] 0] set Tab($GOAncetre,Type) $Type if {$NiveauGOMin <= $Niveau} {lappend LesGO $GOAncetre} } } } foreach GO [lsort -unique $LesGO] { if {![info exists Tab(GO,$GO,nProteo)]} {set Tab(GO,$GO,nProteo) 0} incr Tab(GO,$GO,nProteo) } } } set LeTexte {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set R [set Tab(Cluster,$Cluster,R)] Espionne $Cluster set LesGO {} foreach GO [set Tab(Cluster,$Cluster,LesGO)] { set r [set Tab(GO,$GO,Cluster,$Cluster,r)] set n [set Tab(GO,$GO,n)] set Zscore [ZScore $r $R $n $N] if {$Zscore < $ZscoreMin || $n < $nMin} {continue} lappend LesGO $GO foreach Type [GODB GO $GO LesTypes] { set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set rSurR [expr $r * 1.0 / $R] set nSurN [expr $n * 1.0 / $N] set nMoinsr [expr $n - $r] set NMoinsR [expr $N - $R] set nMoinsrSurNMoinsR [expr $nMoinsr * 1.0 / $NMoinsR] if {1} { set ZscoreProteo 0 set nProteo 0 set nSurNProteo 0 set nMoinsrProteo 0 set NMoinsRProteo 0 set nMoinsrSurNMoinsRProteo 0 if {[info exists Tab(GO,$GO,nProteo)]} { set nProteo [set Tab(GO,$GO,nProteo)] set ZscoreProteo [ZScore $r $R $nProteo $NProteo] set nSurNProteo [expr $nProteo * 1.0 / $NProteo] set nMoinsrProteo [expr $nProteo - $r] set NMoinsRProteo [expr $NProteo - $R] set nMoinsrSurNMoinsRProteo [expr $nMoinsrProteo * 1.0 / $NMoinsRProteo] } set Ligne "$Cluster\t$Type\t$GO\t$r\t$R\t$rSurR\t$n\t$N\t$nSurN\t$nMoinsr\t$NMoinsR\t$nMoinsrSurNMoinsR\t$Zscore\t$nProteo\t$NProteo\t$nSurNProteo\t$nMoinsrProteo\t$NMoinsRProteo\t$nMoinsrSurNMoinsRProteo\t$ZscoreProteo\t$Def" } else { set Ligne "$Cluster\t$Type\t$GO\t$r\t$R\t$rSurR\t$n\t$N\t$nSurN\t$nMoinsr\t$NMoinsR\t$nMoinsrSurNMoinsR\t$Zscore\t$Def" } set Tab($GO,Ligne) $Ligne } } foreach GO $LesGO { set r [set Tab(GO,$GO,Cluster,$Cluster,r)] set EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui 0 foreach GO2 $LesGO { if {$GO == $GO2} {continue} set r2 [set Tab(GO,$GO2,Cluster,$Cluster,r)] if {[EstCeQueGO1EstUnParentDeGO2 $GO $GO2] && $r == $r2} { set EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui 1 } } set Ligne [set Tab($GO,Ligne)] if {$EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui} {set Ligne "$Ligne\tParent"} lappend LeTexte $Ligne #Espionne $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOut InterrogeOrf2Cluster2Access2Def2Expression unset InterrogeProteinesJumelles unset InterrogeGeneOntology unset return } proc FichierChiffresSurGODesClusters_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants} {NiveauGOMin 0} {ZscoreMin 1} {nMin 5}} { set FichierOut "[RepertoireDuGenome]/PourTL/ChiffresDesClustersSurGO.new" set LesNoms [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" set FichierGOProteo "[RepertoireDuGenome]/../Ontology/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set N 0 #Gene Ontology du projet#### foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] != "SeqOK" && [InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK"} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} incr N #Espionne "$Cluster $Nom" if {![info exists Tab(Cluster,$Cluster,R)]} { set Tab(Cluster,$Cluster,R) 0 set Tab(Cluster,$Cluster,LesGO) {} } incr Tab(Cluster,$Cluster,R) set LesGO {} foreach GO [lsort -unique [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierGO $Nom LesGO]]] { set Type [Onto $GO Type] set Tab($GO,Type) $Type set Niveau [lindex [lsort -integer [Onto $Type $GO LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GO} foreach GOAncetre [TousLesAncetresOntologiques $Type $GO] { set Tab($GOAncetre,Type) $Type set Niveau [lindex [lsort -integer [Onto $Type $GOAncetre LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GOAncetre} } } foreach GO [lsort -unique $LesGO] { if {![info exists Tab(GO,$GO,n) ]} {set Tab(GO,$GO,n) 0} if {![info exists Tab(GO,$GO,Cluster,$Cluster,r)]} { set Tab(GO,$GO,Cluster,$Cluster,r) 0 lappend Tab(Cluster,$Cluster,LesGO) $GO } incr Tab(GO,$GO,Cluster,$Cluster,r) incr Tab(GO,$GO,n) } } if {1} { #Gene Ontology du proteome humain##### set NProteo 0 foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { incr NProteo set LesGO {} foreach GO [lsort -unique [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO]]] { set Type [Onto $GO Type] set Tab($GO,Type) $Type set Niveau [lindex [lsort -integer [Onto $Type $GO LesNiveaux]] 0] if {$NiveauGOMin <= $Niveau} {lappend LesGO $GO} foreach GOAncetre [TousLesAncetresOntologiques $Type $GO] { set Niveau [lindex [lsort -integer [Onto $Type $GOAncetre LesNiveaux]] 0] set Tab($GOAncetre,Type) $Type if {$NiveauGOMin <= $Niveau} {lappend LesGO $GOAncetre} } } foreach GO [lsort -unique $LesGO] { if {![info exists Tab(GO,$GO,nProteo)]} {set Tab(GO,$GO,nProteo) 0} incr Tab(GO,$GO,nProteo) } } } set LeTexte {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set R [set Tab(Cluster,$Cluster,R)] Espionne $Cluster set LesGO {} foreach GO [set Tab(Cluster,$Cluster,LesGO)] { set r [set Tab(GO,$GO,Cluster,$Cluster,r)] set n [set Tab(GO,$GO,n)] set Zscore [ZScore $r $R $n $N] if {$Zscore < $ZscoreMin || $n < $nMin} {continue} lappend LesGO $GO set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set rSurR [expr $r * 1.0 / $R] set nSurN [expr $n * 1.0 / $N] set nMoinsr [expr $n - $r] set NMoinsR [expr $N - $R] set nMoinsrSurNMoinsR [expr $nMoinsr * 1.0 / $NMoinsR] if {1} { set ZscoreProteo 0 set nProteo 0 set nSurNProteo 0 set nMoinsrProteo 0 set NMoinsRProteo 0 set nMoinsrSurNMoinsRProteo 0 if {[info exists Tab(GO,$GO,nProteo)]} { set nProteo [set Tab(GO,$GO,nProteo)] set ZscoreProteo [ZScore $r $R $nProteo $NProteo] set nSurNProteo [expr $nProteo * 1.0 / $NProteo] set nMoinsrProteo [expr $nProteo - $r] set NMoinsRProteo [expr $NProteo - $R] set nMoinsrSurNMoinsRProteo [expr $nMoinsrProteo * 1.0 / $NMoinsRProteo] } set Ligne "$Cluster\t$Type\t$GO\t$r\t$R\t$rSurR\t$n\t$N\t$nSurN\t$nMoinsr\t$NMoinsR\t$nMoinsrSurNMoinsR\t$Zscore\t$nProteo\t$NProteo\t$nSurNProteo\t$nMoinsrProteo\t$NMoinsRProteo\t$nMoinsrSurNMoinsRProteo\t$ZscoreProteo\t$Def" } else { set Ligne "$Cluster\t$Type\t$GO\t$r\t$R\t$rSurR\t$n\t$N\t$nSurN\t$nMoinsr\t$NMoinsR\t$nMoinsrSurNMoinsR\t$Zscore\t$Def" } set Tab($GO,Ligne) $Ligne } foreach GO $LesGO { set r [set Tab(GO,$GO,Cluster,$Cluster,r)] set EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui 0 foreach GO2 $LesGO { if {$GO == $GO2} {continue} set r2 [set Tab(GO,$GO2,Cluster,$Cluster,r)] if {[EstCeQueGO1EstUnParentDeGO2 $GO $GO2] && $r == $r2} { set EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui 1 } } set Ligne [set Tab($GO,Ligne)] if {$EstCeQueJeSuisLAncetreDUnAutreGOEtMonEffectifProvientIlUniquementDeLui} {set Ligne "$Ligne\tParent"} lappend LeTexte $Ligne Espionne $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOut return } proc FichierChiffresSurLesProteinesTrouveesPourChaqueCluster {{PABouNomsInteressantsouListeouFichier PAB}} { set FichierOUT "[RepertoireDuGenome]/fiches/ChiffresSurLesProteinesTrouveesPourChaqueCluster" set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierIPO "[RepertoireDuGenome]/fiches/GeneOntology_prottfa" set FichierGPO "[RepertoireDuGenome]/fiches/GeneOntology" set NbSeq 0 set NbEST 0 set NbProtTot 0 set NbProtFrommRNA 0 set NbProtFrommRNAOK 0 set NbProtFrommRNANo 0 set NbProtFromContig 0 set NbProtTotUniques 0 set LesProteinesUniquesPourChaqueCluster {} foreach Nom [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set Access [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Access] if {![info exists Tab($Cluster,NbSeq)]} { set Tab($Cluster,NbSeq) 0 set Tab($Cluster,NbEST) 0 set Tab($Cluster,NbProtTot) 0 set Tab($Cluster,NbProtFrommRNA) 0 set Tab($Cluster,NbProtFrommRNAOK) 0 set Tab($Cluster,NbProtFrommRNANo) 0 set Tab($Cluster,NbProtFromContig) 0 set Tab($Cluster,NbProtTotUniques) 0 set Tab($Cluster,NbProtWithGOTermsIPO) 0 set Tab($Cluster,NbGOTermsIPO) 0 set Tab($Cluster,NbProtWithGOTermsGPO) 0 set Tab($Cluster,NbGOTermsGPO) 0 } incr NbSeq incr Tab($Cluster,NbSeq) if {0} { set Info [PageInfo $Access est acc] Espionne "$Nom\t$Info" if {$Info != ""} { incr NbEST incr Tab($Cluster,NbEST) } } #On ne considere que les proteines# if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] != "SeqOK" && [InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK"} {continue} incr NbProtTot set LesJumeaux [lsort -unique [InterrogeProteinesJumelles $Nom LesProteinesJumelles]] if {![info exists TabDeJaVu($Nom)]} { set TabDeJaVu($Nom) 1 incr NbProtTotUniques foreach Jum $LesJumeaux {set TabDeJaVu($Jum) 1} } if {![info exists TabDeJaVu($Cluster,$Nom)]} { set TabDeJaVu($Cluster,$Nom) 1 lappend LesProteinesUniquesPourChaqueCluster $Nom incr Tab($Cluster,NbProtTotUniques) foreach Jum $LesJumeaux {set TabDeJaVu($Cluster,$Jum) 1} } incr Tab($Cluster,NbProtTot) if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] == "SeqOK"} { incr NbProtFrommRNA if {[InterrogeProtAndmRNAChoisis $Nom InfoSeqChoisie] == ""} { incr Tab($Cluster,NbProtFrommRNAOK) incr NbProtFrommRNAOK } else { incr Tab($Cluster,NbProtFrommRNANo) incr NbProtFrommRNANo } incr Tab($Cluster,NbProtFrommRNA) } if {[InterrogeProtAndContigChoisis $Nom SeqChoisie] == "SeqOK"} { incr NbProtFromContig incr Tab($Cluster,NbProtFromContig) } } set NbGOTermsIPO 0 set NbProtWithGOTermsIPO 0 set NbGOTermsGPO 0 set NbProtWithGOTermsGPO 0 set Tab(LesTypes) {} foreach Nom $LesProteinesUniquesPourChaqueCluster { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] foreach Type [Onto LesTypes] { if {![info exists Tab($Type,NbProtWithGOTermsIPO) ]} {set Tab($Type,NbProtWithGOTermsIPO) 0} if {![info exists Tab($Cluster,$Type,NbProtWithGOTermsIPO)]} {set Tab($Cluster,$Type,NbProtWithGOTermsIPO) 0} if {![info exists Tab($Type,NbProtWithGOTermsGPO) ]} {set Tab($Type,NbProtWithGOTermsGPO) 0} if {![info exists Tab($Cluster,$Type,NbProtWithGOTermsGPO)]} {set Tab($Cluster,$Type,NbProtWithGOTermsGPO) 0} } set LesIPO [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierIPO $Nom LesGO]] if {$LesIPO != ""} { incr NbProtWithGOTermsIPO incr Tab($Cluster,NbProtWithGOTermsIPO) foreach IPO $LesIPO { set Type [Onto $IPO Type] if {![info exists Tab($Type,NbGOTermsIPO)]} {set Tab($Type,NbGOTermsIPO) 0} if {![info exists Tab($Cluster,$Type,NbGOTermsIPO)]} {set Tab($Cluster,$Type,NbGOTermsIPO) 0} incr NbGOTermsIPO incr Tab($Type,NbGOTermsIPO) incr Tab($Cluster,NbGOTermsIPO) incr Tab($Cluster,$Type,NbGOTermsIPO) } } foreach Type [lsort -unique [InterrogeGeneOntology $FichierIPO $Nom LesTypes]] { incr Tab($Type,NbProtWithGOTermsIPO) incr Tab($Cluster,$Type,NbProtWithGOTermsIPO) } set LesGPO [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierGPO $Nom LesGO]] if {$LesGPO != ""} { incr NbProtWithGOTermsGPO incr Tab($Cluster,NbProtWithGOTermsGPO) foreach GPO $LesGPO { set Type [Onto $GPO Type] if {![info exists Tab($Type,NbGOTermsGPO)]} {set Tab($Type,NbGOTermsGPO) 0} if {![info exists Tab($Cluster,$Type,NbGOTermsGPO)]} {set Tab($Cluster,$Type,NbGOTermsGPO) 0} incr NbGOTermsGPO incr Tab($Type,NbGOTermsGPO) incr Tab($Cluster,NbGOTermsGPO) incr Tab($Cluster,$Type,NbGOTermsGPO) } } foreach Type [lsort -unique [InterrogeGeneOntology $FichierGPO $Nom LesTypes]] { incr Tab($Type,NbProtWithGOTermsGPO) incr Tab($Cluster,$Type,NbProtWithGOTermsGPO) } } set LeTexte "" lappend LeTexte "NbSeq\t$NbSeq" lappend LeTexte "NbEST\t$NbEST" lappend LeTexte "NbProtTot\t$NbProtTot" lappend LeTexte "NbProtTot From mRNAorProt\t$NbProtFrommRNA" lappend LeTexte "NbProtTot From mRNAorProt OK\t$NbProtFrommRNAOK" lappend LeTexte "NbProtTot From mRNAorProt Warning\t$NbProtFrommRNANo" lappend LeTexte "NbProtTot From Contig\t$NbProtFromContig" lappend LeTexte "NbProtTot Uniques\t$NbProtTotUniques" lappend LeTexte "NbProtTot Uniques Avec IPO terms\t$NbProtWithGOTermsIPO" lappend LeTexte "NbProtTot Uniques Avec GPO terms\t$NbProtWithGOTermsGPO" lappend LeTexte "Nb IPO terms Tot\t$NbGOTermsIPO" lappend LeTexte "Nb GPO terms Tot\t$NbGOTermsGPO" foreach Type [Onto LesTypes] { lappend LeTexte "NbProt with $Type IPO terms\t[set Tab($Type,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProt with $Type GPO terms\t[set Tab($Type,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb $Type IPO terms\t[set Tab($Type,NbGOTermsIPO)]" lappend LeTexte "Nb $Type GPO terms\t[set Tab($Type,NbGOTermsGPO)]" } lappend LeTexte "" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { lappend LeTexte "Cluster $Cluster" lappend LeTexte "NbSeq\t[set Tab($Cluster,NbSeq)]" lappend LeTexte "NbProtTot\t[set Tab($Cluster,NbProtTot)]" lappend LeTexte "NbProtTot From mRNAorProt\t[set Tab($Cluster,NbProtFrommRNA)]" lappend LeTexte "NbProtTot From mRNAorProt OK\t[set Tab($Cluster,NbProtFrommRNAOK)]" lappend LeTexte "NbProtTot From mRNAorProt Warning\t[set Tab($Cluster,NbProtFrommRNANo)]" lappend LeTexte "NbProtTot From Contig\t[set Tab($Cluster,NbProtFromContig)]" lappend LeTexte "NbProtTot Uniques\t[set Tab($Cluster,NbProtTotUniques)]" lappend LeTexte "NbProtTot Uniques Avec IPO Terms\t[set Tab($Cluster,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProtTot Uniques Avec GPO Terms\t[set Tab($Cluster,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb IPO terms Tot\t[set Tab($Cluster,NbGOTermsIPO)]" lappend LeTexte "Nb GPO terms Tot\t[set Tab($Cluster,NbGOTermsGPO)]" foreach Type [Onto LesTypes] { lappend LeTexte "NbProt with $Type IPO terms\t[set Tab($Cluster,$Type,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProt with $Type GPO terms\t[set Tab($Cluster,$Type,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb $Type IPO terms\t[set Tab($Cluster,$Type,NbGOTermsIPO)]" lappend LeTexte "Nb $Type GPO terms\t[set Tab($Cluster,$Type,NbGOTermsGPO)]" } lappend LeTexte "" } Sauve [join $LeTexte "\n"] dans $FichierOUT EspionneL $LeTexte return } proc FichierChiffresSurLesProteinesTrouveesPourChaqueCluster_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set FichierOUT "[RepertoireDuGenome]/PourTL/ChiffresSurLesProteinesTrouveesPourChaqueCluster" set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierIPO "[RepertoireDuGenome]/fiches/GeneOntology_prottfa" set FichierGPO "[RepertoireDuGenome]/fiches/GeneOntology" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set NbSeq 0 set NbEST 0 set NbProtTot 0 set NbProtFrommRNA 0 set NbProtFrommRNAOK 0 set NbProtFrommRNANo 0 set NbProtFromContig 0 set NbProtTotUniques 0 set LesProteinesUniquesPourChaqueCluster {} foreach Nom [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set Access [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Access] if {![info exists Tab($Cluster,NbSeq)]} { set Tab($Cluster,NbSeq) 0 set Tab($Cluster,NbEST) 0 set Tab($Cluster,NbProtTot) 0 set Tab($Cluster,NbProtFrommRNA) 0 set Tab($Cluster,NbProtFrommRNAOK) 0 set Tab($Cluster,NbProtFrommRNANo) 0 set Tab($Cluster,NbProtFromContig) 0 set Tab($Cluster,NbProtTotUniques) 0 set Tab($Cluster,NbProtWithGOTermsIPO) 0 set Tab($Cluster,NbGOTermsIPO) 0 set Tab($Cluster,NbProtWithGOTermsGPO) 0 set Tab($Cluster,NbGOTermsGPO) 0 } incr NbSeq incr Tab($Cluster,NbSeq) if {1} { set Info [PageInfo $Access est acc] Espionne "$Nom\t$Info" if {$Info != ""} { incr NbEST incr Tab($Cluster,NbEST) } } #On ne considere que les proteines# if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] != "SeqOK" && [InterrogeProtAndContigChoisis $Nom SeqChoisie] != "SeqOK"} {continue} incr NbProtTot set LesJumeaux [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] if {![info exists TabDeJaVu($Nom)]} { set TabDeJaVu($Nom) 1 incr NbProtTotUniques foreach Jum $LesJumeaux {set TabDeJaVu($Jum) 1} } if {![info exists TabDeJaVu($Cluster,$Nom)]} { set TabDeJaVu($Cluster,$Nom) 1 lappend LesProteinesUniquesPourChaqueCluster $Nom incr Tab($Cluster,NbProtTotUniques) foreach Jum $LesJumeaux {set TabDeJaVu($Cluster,$Jum) 1} } incr Tab($Cluster,NbProtTot) if {[InterrogeProtAndmRNAChoisis $Nom SeqChoisie] == "SeqOK"} { incr NbProtFrommRNA if {[InterrogeProtAndmRNAChoisis $Nom InfoSeqChoisie] == ""} { incr Tab($Cluster,NbProtFrommRNAOK) incr NbProtFrommRNAOK } else { incr Tab($Cluster,NbProtFrommRNANo) incr NbProtFrommRNANo } incr Tab($Cluster,NbProtFrommRNA) } if {[InterrogeProtAndContigChoisis $Nom SeqChoisie] == "SeqOK"} { incr NbProtFromContig incr Tab($Cluster,NbProtFromContig) } } set NbGOTermsIPO 0 set NbProtWithGOTermsIPO 0 set NbGOTermsGPO 0 set NbProtWithGOTermsGPO 0 set Tab(LesTypes) {} foreach Nom $LesProteinesUniquesPourChaqueCluster { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] foreach Type [Onto LesTypes] { if {![info exists Tab($Type,NbProtWithGOTermsIPO) ]} {set Tab($Type,NbProtWithGOTermsIPO) 0} if {![info exists Tab($Cluster,$Type,NbProtWithGOTermsIPO)]} {set Tab($Cluster,$Type,NbProtWithGOTermsIPO) 0} if {![info exists Tab($Type,NbProtWithGOTermsGPO) ]} {set Tab($Type,NbProtWithGOTermsGPO) 0} if {![info exists Tab($Cluster,$Type,NbProtWithGOTermsGPO)]} {set Tab($Cluster,$Type,NbProtWithGOTermsGPO) 0} } set LesIPO [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierIPO $Nom LesGO]] if {$LesIPO != ""} { incr NbProtWithGOTermsIPO incr Tab($Cluster,NbProtWithGOTermsIPO) foreach IPO $LesIPO { set Type [Onto $IPO Type] if {![info exists Tab($Type,NbGOTermsIPO)]} {set Tab($Type,NbGOTermsIPO) 0} if {![info exists Tab($Cluster,$Type,NbGOTermsIPO)]} {set Tab($Cluster,$Type,NbGOTermsIPO) 0} incr NbGOTermsIPO incr Tab($Type,NbGOTermsIPO) incr Tab($Cluster,NbGOTermsIPO) incr Tab($Cluster,$Type,NbGOTermsIPO) } } foreach Type [lsort -unique [InterrogeGeneOntology $FichierIPO $Nom LesTypes]] { incr Tab($Type,NbProtWithGOTermsIPO) incr Tab($Cluster,$Type,NbProtWithGOTermsIPO) } set LesGPO [EnterrerLesAncetresOntologiques [InterrogeGeneOntology $FichierGPO $Nom LesGO]] if {$LesGPO != ""} { incr NbProtWithGOTermsGPO incr Tab($Cluster,NbProtWithGOTermsGPO) foreach GPO $LesGPO { set Type [Onto $GPO Type] if {![info exists Tab($Type,NbGOTermsGPO)]} {set Tab($Type,NbGOTermsGPO) 0} if {![info exists Tab($Cluster,$Type,NbGOTermsGPO)]} {set Tab($Cluster,$Type,NbGOTermsGPO) 0} incr NbGOTermsGPO incr Tab($Type,NbGOTermsGPO) incr Tab($Cluster,NbGOTermsGPO) incr Tab($Cluster,$Type,NbGOTermsGPO) } } foreach Type [lsort -unique [InterrogeGeneOntology $FichierGPO $Nom LesTypes]] { incr Tab($Type,NbProtWithGOTermsGPO) incr Tab($Cluster,$Type,NbProtWithGOTermsGPO) } } set LeTexte {} lappend LeTexte "NbSeq\t$NbSeq" lappend LeTexte "NbEST\t$NbEST" lappend LeTexte "NbProtTot\t$NbProtTot" lappend LeTexte "NbProtTot From mRNAorProt\t$NbProtFrommRNA" lappend LeTexte "NbProtTot From mRNAorProt OK\t$NbProtFrommRNAOK" lappend LeTexte "NbProtTot From mRNAorProt Warning\t$NbProtFrommRNANo" lappend LeTexte "NbProtTot From Contig\t$NbProtFromContig" lappend LeTexte "NbProtTot Uniques\t$NbProtTotUniques" lappend LeTexte "NbProtTot Uniques Avec IPO terms\t$NbProtWithGOTermsIPO" lappend LeTexte "NbProtTot Uniques Avec GPO terms\t$NbProtWithGOTermsGPO" lappend LeTexte "Nb IPO terms Tot\t$NbGOTermsIPO" lappend LeTexte "Nb GPO terms Tot\t$NbGOTermsGPO" foreach Type [Onto LesTypes] { lappend LeTexte "NbProt with $Type IPO terms\t[set Tab($Type,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProt with $Type GPO terms\t[set Tab($Type,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb $Type IPO terms\t[set Tab($Type,NbGOTermsIPO)]" lappend LeTexte "Nb $Type GPO terms\t[set Tab($Type,NbGOTermsGPO)]" } lappend LeTexte "" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { lappend LeTexte "Cluster $Cluster" lappend LeTexte "NbSeq\t[set Tab($Cluster,NbSeq)]" lappend LeTexte "NbProtTot\t[set Tab($Cluster,NbProtTot)]" lappend LeTexte "NbProtTot From mRNAorProt\t[set Tab($Cluster,NbProtFrommRNA)]" lappend LeTexte "NbProtTot From mRNAorProt OK\t[set Tab($Cluster,NbProtFrommRNAOK)]" lappend LeTexte "NbProtTot From mRNAorProt Warning\t[set Tab($Cluster,NbProtFrommRNANo)]" lappend LeTexte "NbProtTot From Contig\t[set Tab($Cluster,NbProtFromContig)]" lappend LeTexte "NbProtTot Uniques\t[set Tab($Cluster,NbProtTotUniques)]" lappend LeTexte "NbProtTot Uniques Avec IPO Terms\t[set Tab($Cluster,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProtTot Uniques Avec GPO Terms\t[set Tab($Cluster,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb IPO terms Tot\t[set Tab($Cluster,NbGOTermsIPO)]" lappend LeTexte "Nb GPO terms Tot\t[set Tab($Cluster,NbGOTermsGPO)]" foreach Type [Onto LesTypes] { lappend LeTexte "NbProt with $Type IPO terms\t[set Tab($Cluster,$Type,NbProtWithGOTermsIPO)]" lappend LeTexte "NbProt with $Type GPO terms\t[set Tab($Cluster,$Type,NbProtWithGOTermsGPO)]" lappend LeTexte "Nb $Type IPO terms\t[set Tab($Cluster,$Type,NbGOTermsIPO)]" lappend LeTexte "Nb $Type GPO terms\t[set Tab($Cluster,$Type,NbGOTermsGPO)]" } lappend LeTexte "" } Sauve [join $LeTexte "\n"] dans $FichierOUT EspionneL $LeTexte return } proc FichierChiffresSurTissueTypeEtDevStageDesClusters_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set FichierOut "[RepertoireDuGenome]/PourTL/ChiffresTissueTypeDevStageDesClusters" set LesNoms [lsort -unique [LesNoms $PABouNomsInteressantsouListeouFichier]] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set N [llength $LesNoms] set LesClusters {} foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {![info exists Tab($Cluster,R)]} { set Tab($Cluster,R) 0 set Tab($Cluster,LesTissues) {} set Tab($Cluster,LesDS) {} lappend LesClusters $Cluster } incr Tab($Cluster,R) set LesTissues {} foreach TissueTypeOld [InterrogeTissueType $Nom LesTissues] { if {1} { set TissueType [TissueTypesGeneraux $TissueTypeOld [list EYE BRAIN]] } else { set TissueType [TissueTypesGeneraux $TissueTypeOld] } lappend LesTissues $TissueType } foreach TissueType [lsort -unique $LesTissues] { if {![info exists Tab(TissueType,$TissueType,n)]} {set Tab(TissueType,$TissueType,n) 0} if {![info exists Tab($Cluster,TissueType,$TissueType,r)]} { set Tab($Cluster,TissueType,$TissueType,r) 0 lappend Tab($Cluster,LesTissues) $TissueType } incr Tab(TissueType,$TissueType,n) incr Tab($Cluster,TissueType,$TissueType,r) } set LesDS {} foreach DSOld [InterrogeDevStage $Nom LesDevStages] {lappend LesDS [DevStagesGeneraux $DSOld]} foreach DS [lsort -unique $LesDS] { if {![info exists Tab(DevStage,$DS,n)]} {set Tab(DevStage,$DS,n) 0} if {![info exists Tab($Cluster,DevStage,$DS,r)]} { set Tab($Cluster,DevStage,$DS,r) 0 lappend Tab($Cluster,LesDS) $DS } incr Tab(DevStage,$DS,n) incr Tab($Cluster,DevStage,$DS,r) } } set LeTexte {} foreach Cluster $LesClusters { set R [set Tab($Cluster,R)] foreach Tissue [set Tab($Cluster,LesTissues)] { set n [set Tab(TissueType,$Tissue,n) ] set r [set Tab($Cluster,TissueType,$Tissue,r)] set Zscore [ZScore $r $R $n $N] lappend LeTexte "$Cluster\tTissueType\t$Tissue\t$r\t$R\t$n\t$N\t$Zscore" Espionne "$Cluster\tTissueType\t$Tissue\t$r\t$R\t$n\t$N\t$Zscore" } foreach DS [set Tab($Cluster,LesDS)] { set n [set Tab(DevStage,$DS,n) ] set r [set Tab($Cluster,DevStage,$DS,r)] set Zscore [ZScore $r $R $n $N] lappend LeTexte "$Cluster\tDevStage\t$DS\t$r\t$R\t$n\t$N\t$Zscore" Espionne "$Cluster\tDevStage\t$DS\t$r\t$R\t$n\t$N\t$Zscore" } } Sauve [join $LeTexte "\n"] dans $FichierOut return } proc FichierCl1Cl2OperonsCommuns {} { global RepertoireDuGenome set Fichier "$RepertoireDuGenome/fiches/cl1_cl2_operons_communs" set LesInfos {} foreach Cluster1 [O2C2O LesClusters] { #Espionne $Cluster1 foreach Cluster2 [O2C2O LesClusters] { if {[info exists TabTmp($Cluster1,$Cluster2)]} {continue} if {$Cluster1 == $Cluster2} {continue} set TabTmp($Cluster1,$Cluster2) 1 set TabTmp($Cluster2,$Cluster1) 1 set LesOperonsCommuns [LesOperonsCommunsEntreClusters $Cluster1 $Cluster2] set NbOperonsCommuns [llength $LesOperonsCommuns] lappend LesInfos "$Cluster1\t$Cluster2\t$NbOperonsCommuns\t[join $LesOperonsCommuns "\t"]" } } #Espionne $LesInfos Sauve [join $LesInfos "\n"] dans $Fichier if {[info exists TabTmp]} {unset TabTmp} return $Fichier } proc FichierClusters {Fichier} { #Cree le fichier "clusters" et le sauve dans fiches #ce fichier est celui qui sera lu dans proc CreeLesNouvellesBornesDesPABs #Complete le fichier des jumeaux (qui est deja trie) : jumeaux_Overlap par ex set TexteComplete [CompleteLeFichierDesJumeaux $Fichier] set FichierDesClusters "[RepertoireDuGenome]/fiches/clusters" if {![file exists $FichierDesClusters] || [file exists $FichierDesClusters] && [OuiOuNon "Do you want to replace the file clusters ?"]} { Sauve $TexteComplete dans $FichierDesClusters } if {[OuiOuNon "Do you want to run again BornesDesPABs?"]} { CreeLesNouvellesBornesDesPABs "[RepertoireDuGenome]/fiches/clusters" } } proc FichierClustersFinal {FichierClusters} { set TexteDuNouveauFichier "" foreach JR [ListeDesJR $FichierClusters] { if {[info exists Vu($JR)]} {continue} set LesJumeauxDuJR {} set LesJRIdentiques {} set LesJumeaux {} set lesJumeauxTries {} set LesJumeauxDesJRIdentiques {} set LesJumeauxDuJumeauR {} set LesJumeauxDuJR [LesJumeauxDuPAB $JR $FichierClusters] set LesJRIdentiques [LesJRsAvecMemesAccessDeProtOuDemRNAPourUnPAB $JR $FichierClusters] foreach JumeauR $LesJRIdentiques { set Vu($JumeauR) 1 set LesJumeauxDuJumeauR [LesJumeauxDuPAB $JumeauR $FichierClusters] set LesJumeauxDesJRIdentiques [concat $LesJumeauxDesJRIdentiques $LesJumeauxDuJumeauR] } set LesJumeaux [concat $JR $LesJumeauxDuJR $LesJRIdentiques $LesJumeauxDesJRIdentiques] set lesJumeauxTries [TrieLesJumeauxParLongueurDecroissante $LesJumeaux] if {$lesJumeauxTries!=""} { append TexteDuNouveauFichier "$lesJumeauxTries\n" } } return $TexteDuNouveauFichier } proc FichierClustersFusionnes {DistanceMax NbOperonsCommunsMin ZscoreMinDuCluster DiffZscoreMinClusterEtClusterFusionne {NiveauGOMin_process ""} {NiveauGOMin_function ""} {NiveauGOMin_component ""}} { Wup "ATTENTION il faut mettre une valeur dans au moins un des types d'ontology pour obtenir un resultat" set File "[RepertoireDuGenome]/fiches/ClustersApresFusion" set i 0 set LesClustersFusionnes {} foreach Cluster [O2C2O LesClusters] { if {[info exists TabTmp($Cluster)]} {continue} set TabTmp($Cluster) 1 set LesClustersProches [LesClustersProchesDuCluster $Cluster $DistanceMax $NbOperonsCommunsMin $ZscoreMinDuCluster $DiffZscoreMinClusterEtClusterFusionne $NiveauGOMin_process $NiveauGOMin_function $NiveauGOMin_component] incr i set nNouveauCluster [expr $i - 1] lappend LesClustersFusionnes "$nNouveauCluster\t[join [lsort $LesClustersProches] "\t"]" foreach Cluster $LesClustersProches {set TabTmp($Cluster) 1} } Espionne "NbCluster $i" Sauve [join $LesClustersFusionnes "\n"] dans $File return $LesClustersFusionnes } proc FichierComparaisonsDesGODesDeuxClusters {C1 C2 TypeDeRef FichierOrf2Cluster FichierCompare FichierGO} { set LesGO {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster LesNoms] { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom Cluster] if {$Cluster != $C1 && $Cluster != $C2} {continue} if {1} { if {$Cluster == $C1} { set Fold [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom PointTemporel 8d Fold rd1 sur wt] if {$Fold == "" || $Fold <3} {continue} } if {$Cluster == $C2} { set Fold [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom PointTemporel 8d Fold rd1 sur wt] if {$Fold == "" || $Fold <3} {continue} } } if {![info exists Tab($Cluster,NbProtAvecGO)]} { set Tab($Cluster,NbProtAvecGO) 0 } if {[InterrogeGeneOntology $FichierGO $Nom LesGO] != {}} { incr Tab($Cluster,NbProtAvecGO) } Espionne "$Nom $Cluster" foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [Onto $GO Type] if {$TypeDeRef != $Type} {continue} Espionne $GO if {![info exists Tab($GO)]} { set Tab($GO) 0 lappend LesGO $GO } if {![info exists Tab($Cluster,NbGO)]} { set Tab($Cluster,NbGO) 0 } if {![info exists Tab($GO,$Cluster)]} { set Tab($GO,$Cluster) 0 } incr Tab($Cluster,NbGO) incr Tab($GO,$Cluster) } } set NbProtDansC1 [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster Cluster $C1 LesNoms]] set NbProtDansC2 [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster Cluster $C2 LesNoms]] foreach GO $LesGO { set Type [Onto $GO Type] set Definition [lindex [Onto $Type $GO LesDefinitions] 0] set nC1 0 if {[info exists Tab($GO,$C1)]} {set nC1 [set Tab($GO,$C1)]} set nC2 0 if {[info exists Tab($GO,$C2)]} {set nC2 [set Tab($GO,$C2)]} set NbGOC1 0 if {[info exists Tab($C1,NbGO)]} {set NbGOC1 [set Tab($C1,NbGO)]} set NbGOC2 0 if {[info exists Tab($C2,NbGO)]} {set NbGOC2 [set Tab($C2,NbGO)]} set NbProtAvecGODansC1 0 if {[info exists Tab($C1,NbProtAvecGO)]} {set NbProtAvecGODansC1 [set Tab($C1,NbProtAvecGO)]} set NbProtAvecGODansC2 0 if {[info exists Tab($C2,NbProtAvecGO)]} {set NbProtAvecGODansC2 [set Tab($C2,NbProtAvecGO)]} Espionne "$GO\t$Definition\t$nC1\t$NbProtAvecGODansC1\t$NbProtDansC1\t$NbGOC1\t$nC2\t$NbProtAvecGODansC2\t$NbProtDansC2\t$NbGOC2" AppendAuFichier $FichierCompare "$GO\t$Definition\t$nC1\t$NbProtAvecGODansC1\t$NbProtDansC1\t$NbGOC1\t$nC2\t$NbProtAvecGODansC2\t$NbProtDansC2\t$NbGOC2" } return } proc FichierComparaisonsEntreOperonsEtClusters {} { global RepertoireDuGenome set LesInfos {} Wup "Operon Number of ORFs in operon Number of clusters in operon Cluster Number of ORFs in cluster Number of operons in cluster Percentage of presence of the total organisms Percentage of presence of the Diabacs Percentage of presence of the Bacteria Percentage of presence of the Firmicutes Percentage of presence of the Proteobacteria Percentage of presence of the Archaebacteria Percentage of presence of the Eukaryota Cluster 2 Percentage of presence of the total organisms Distance between cluster and cluster 2 Number of common ORFs between cluster and operon Common ORF between cluster and operon Definition of common ORF between cluster and operon" set LesOperons [lsort -integer [O2C2O LesOperons]] foreach Operon $LesOperons { set LesClustersDeLOperon [lsort -integer [O2C2O Operon $Operon LesClusters]] set nClInOp [O2C2O Operon $Operon NbClustersDansOperon] set TOp [O2C2O Operon $Operon TailleOperon] foreach Cluster $LesClustersDeLOperon { set TCl [O2C2O Cluster $Cluster TailleCluster] set nOpInCl [O2C2O Cluster $Cluster NbOperonsDansCluster] set LesOrfsEnCommun [lsort [O2C2O Cluster $Cluster Operon $Operon LesOrfsEnCommun]] set nOrfsEnCommun [O2C2O Cluster $Cluster Operon $Operon NbOrfsEnCommun] set LesDefinitions {} set PresenceOrgas [O2C2O Cluster $Cluster Categorie AllOrganism Presence] set PresenceDiabacs [O2C2O Cluster $Cluster Categorie OrganismeInteressant Presence] set PresenceBacteries [O2C2O Cluster $Cluster Categorie Bacteria Presence] set PresenceFirmicutes [O2C2O Cluster $Cluster Categorie Firmicutes Presence] set PresenceProteobacteries [O2C2O Cluster $Cluster Categorie Proteobacteria Presence] set PresenceArchaebacteries [O2C2O Cluster $Cluster Categorie Archaea Presence] set PresenceEucaryotes [O2C2O Cluster $Cluster Categorie Eukaryota Presence] foreach Orf $LesOrfsEnCommun { lappend LesDefinitions [O2C2O Orf $Orf Definition] } foreach Cluster2 $LesClustersDeLOperon { set Distance [format "%.1f" [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 Distance]] set PresenceOrgas2 [O2C2O Cluster $Cluster2 Categorie AllOrganism Presence] foreach OrfEnCommun $LesOrfsEnCommun Definition $LesDefinitions { Espionne [set Info [list $Operon $TOp $nClInOp $Cluster $TCl $nOpInCl $PresenceOrgas $PresenceDiabacs $PresenceBacteries $PresenceFirmicutes $PresenceProteobacteries $PresenceArchaebacteries $PresenceEucaryotes $Cluster2 $PresenceOrgas2 $Distance $nOrfsEnCommun $OrfEnCommun $Definition ]] lappend LesInfos $Info } } } } set LeTexte {} foreach LInfo [lsort -integer -index 0 $LesInfos] { lappend LeTexte [join $LInfo "\t"] } set Fichier "$RepertoireDuGenome/fiches/comparaisons_operons_clusters" Sauve [join $LeTexte "\n"] dans $Fichier set LeTexte {} foreach LInfo [lsort -integer -index 3 $LesInfos] { lappend LeTexte [join $LInfo "\t"] } set Fichier "$RepertoireDuGenome/fiches/comparaisons_clusters_operons" Sauve [join $LeTexte "\n"] dans $Fichier return $Fichier } proc FichierContigAndProtPourTous {{LesNoms ""} {APartirDe ""} {IdMin 0.8}} { set Fichier "[RepertoireDuGenome]/fiches/ContigAndProt" if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set Continue 0 if {[file exists $Fichier]} { if {[OuiOuNon "$Fichier exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $Fichier] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } if {[info exists DejaVu($Nom)]} {unset DejaVu($Nom)} } else { if {[OuiOuNon "$Fichier exists.\nWould you want to deltree this file?"]} { File delete -force $Fichier } } } set LAiJeVu 0 foreach Nom $LesNoms { Espionne $Nom if {$APartirDe != ""} { if {$Nom == $APartirDe} {set LAiJeVu 1} if {!$LAiJeVu} {continue} } if {[file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} #if {[file exists "[RepertoireDuGenome]/prottfa/$Nom"] && ![regexp -nocase "CONTIG" [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]]} {continue} if {$Continue && [info exists DejaVu($Nom)]} {continue} set LaProt [LaMeilleureProteineDuMeilleurContig $Nom 0.001 0.05 10000 $IdMin] if {$LaProt == {}} { AppendAuFichier $Fichier "$Nom\tNoContigFound" } else { AppendAuFichier $Fichier [join $LaProt "\t"] } } FichierTFADesProteinesDesContigsPourTous $LesNoms $IdMin return $Fichier } proc FichierDeClassificationTaxonomique {} { global RepertoireDuGenome set FichierTaxon "[RepTaxonomie]/ClassificationTaxonomique" foreach Orga [Glossaire "" EntierComplet] { regsub {\.$} $Orga "" Orga if {[info exists TabTaxon($Orga)]} {continue} set Taxon [OCduOS $Orga] if {$Taxon == "ClassUnknown"} {continue} regsub {\.$} $Taxon "" Taxon regsub -all { *; *} $Taxon ";" Taxon set LesTaxons [linsert [split $Taxon ";"] 0 "LUCA"] lappend LesTaxons $Orga Espionne $LesTaxons for {set i 1} {$i < [llength $LesTaxons]} {incr i} { set Taxon [lindex $LesTaxons $i ] set LesAncetres [lrange $LesTaxons 0 [expr $i - 1]] set IndexAncetres [join $LesAncetres ","] if {![info exists TabTaxon($IndexAncetres,LesDescendants)]} {set TabTaxon($IndexAncetres,LesDescendants) {}} if {![info exists TabTaxon($IndexAncetres,$Taxon)]} { lappend TabTaxon($IndexAncetres,LesDescendants) $Taxon set TabTaxon($IndexAncetres,$Taxon) 1 } } } set LeTexte [AjouteLesTaxonsAuFichierDeClassificationTaxonomique TabTaxon [list "LUCA"]] Sauve [join $LeTexte "\n"] dans $FichierTaxon return $LeTexte } proc FichierDefinitionDesProteinesPourTous {FichierOut FichierO2C2A2D2E {Id 0.98}} { if {![file exists $FichierO2C2A2D2E]} {return} set LesDefinitions {} set LesNoms [ListeDesPABs] foreach Nom $LesNoms { Espionne "$Nom" set AccessClone [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Access ] set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Cluster ] set Def [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Definition] set Fold35dRd1Wt [format "%.1f" [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel 35 Fold rd1 sur wt ]] set Fold35dWtRd1 [format "%.1f" [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel 35 Fold wt sur rd1]] set Fold8dRd1Wt [format "%.1f" [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel 8 Fold rd1 sur wt ]] set Fold8dWtRd1 [format "%.1f" [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel 8 Fold wt sur rd1]] set FichierProtTFA "[RepertoireDuGenome]/prottfa/$Nom" if {![file exists $FichierProtTFA]} { Espionne "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t\t\t\t$Def" lappend LesDefinitions "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t\t\t\t$Def" continue } if {[info exists TabFeuille]} {unset TabFeuille} if {[info exists TabAncetre]} {unset TabAncetre} set Info [InterrogeProtAndmRNAChoisis $Nom InfoSeqChoisie] if {$Info == "NoSeq"} { Espionne "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t\t\t\t$Def" lappend LesDefinitions "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t\t\t\t$Def" continue } set LesAccess {} set Access [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {![string equal -nocase $Access "NoProtein"]} { lappend LesAccess $Access } set FileMSF "[RepertoireDuGenome]/msf/$Nom" if {[file exists $FileMSF]} { set LesAccess [concat $LesAccess [LesAccessDesProteinesIdentiquesDansMSF $FileMSF $Nom $Id]] } foreach Access [ElimineLesRedondancesDansUneListe $LesAccess] { set PageInfo [PageInfo $Access protein "ID ORG DES"] if {$PageInfo == ""} {continue} set DefProt [string trim [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "]] if {$DefProt == ""} {continue} if {[info exists TabTmp($Nom,$DefProt)]} {continue} set TabTmp($Nom,$DefProt) 1 set Orgas [join [LesOrgasDeLaPage_PageInfo $PageInfo] " "] Espionne "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t$Access\t$Orgas\t$DefProt\t$Def" lappend LesDefinitions "$Nom\t$Cluster\t$AccessClone\t$Fold35dRd1Wt\t$Fold35dWtRd1\t$Fold8dRd1Wt\t$Fold8dWtRd1\t$Access\t$Orgas\t$DefProt\t$Def" } } if {[info exists TabTmp]} {unset TabTmp} Sauve [join $LesDefinitions "\n"] dans $FichierOut return } proc FichierDefinitionsConsensusPourTous {{LesNoms ""} {IdDesProtId 0.98} {NormMDMin 0.5} {NbMilliSecMax 30000} {NbIndiv 20}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FileBestDef "[RepertoireDuGenome]/fiches/DefinitionsConsensus" if {![file exists $FileBestDef]} {File delete -force $FileBestDef} set Continue 0 if {[file exists $FileBestDef]} { if {[OuiOuNon "$FileBestDef exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FileBestDef] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } } else { if {[OuiOuNon "$FileBestDef exists.\nWould you want to deltree this file?"]} { File delete -force $FileBestDef } } } foreach Nom $LesNoms { Espionne $Nom if {$Continue && [info exists DejaVu($Nom)]} {continue} set FileMSF "[RepertoireDuGenome]/msf/$Nom" set FileClust "${FileMSF}.clust" set Def "$Nom\t[DefinitionConsensus $Nom $FileMSF $FileClust $IdDesProtId $NormMDMin $NbMilliSecMax $NbIndiv]" Espionne $Def AppendAuFichier $FileBestDef $Def } return } proc FichierDesBoitesSelectionneesPourArticle_TL {FileOCADE FileBoiteSelected FileGOSelected FileGO FileOut {PABouNomsInteressantsouListeouFichier NomsInteressants}} { set LesNoms [LesNoms $PABouNomsInteressantsouListeouFichier] set F [open $FileBoiteSelected] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set TabBoxToKeep($Ligne) 1 } close $F set F [open $FileGOSelected] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Cluster [lindex $LaLigne 0] set GO [lindex $LaLigne 2] set TabGOToKeep($Cluster,$GO) 1 } close $F set LesBoitesSelect {} foreach Nom $LesNoms { if {[info exists TabBoxToKeep($Nom)]} {lappend LesBoitesSelect $Nom;continue} set FileProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {![file exists $FileProttfa]} {continue} set Entete [EnteteDuFichierTFA $FileProttfa] if {[regexp -nocase "from contig" $Entete]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE $Nom Cluster ] set LAiJeTrouve 0 foreach GO [InterrogeGeneOntology $FileGO $Nom LesGO] { if {[info exists TabGOToKeep($Cluster,$GO)]} { set LAiJeTrouve 1 break } foreach Type [GODB GO $GO LesTypes] { foreach GOAncetre [TousLesAncetresGO $Type $GO] { if {[info exists TabGOToKeep($Cluster,$GOAncetre)]} { set LAiJeTrouve 1 break } } if {$LAiJeTrouve} {break} } if {$LAiJeTrouve} {break} } if {!$LAiJeTrouve} {continue} lappend LesBoitesSelect $Nom } set LeTexte {} set LesPointsTemporels [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE LesPointsTemporels] set LesConditions [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE LesConditions] set LaLigne [list Name Cluster Access] foreach When $LesPointsTemporels { foreach What $LesConditions { lappend LaLigne "$When $What" } } lappend LaLigne "Mean Definition" lappend LaLigne "GO Definitions" lappend LeTexte [join $LaLigne "\t"] foreach Nom [lsort -unique $LesBoitesSelect] { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE $Nom Cluster ] set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE $Nom Access ] set LaLigne [list $Nom $Cluster $AccIni] foreach When $LesPointsTemporels { foreach What $LesConditions { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FileOCADE $Nom PointTemporel $When Condition $What Expression] lappend LaLigne $Expr } } set GODef "" foreach GO [InterrogeGeneOntology $FileGO $Nom LesGO] { set Def [join [InterrogeGeneOntology $FileGO GO $GO LaDefinition] " "] if {$GODef != ""} {append GODef " ; $Def";continue} append GODef $Def } lappend LaLigne $MeanDef lappend LaLigne $GODef lappend LeTexte [join $LaLigne "\t"] } Sauve [join $LeTexte "\n"] dans $FileOut return } proc FichierDevStagePourTous {NameRepBlastnEST {AllOrgaouJustMyOrga AllOrga} {IdDeRef 0.95} {LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierDevStage "[RepertoireDuGenome]/fiches/DevStage" set Continue 0 if {[file exists $FichierDevStage]} { if {[OuiOuNon "$FichierDevStage exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FichierDevStage] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Access [lindex $LaLigne 1] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} set DejaVu($Nom,$Access) 1 } if {[info exists DejaVu($Nom)]} {unset DejaVu($Nom)} } else { if {[OuiOuNon "$FichierDevStage exists.\nWould you want to deltree this file?"]} { File delete -force $FichierDevStage } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} set FichierBlastnEST "[RepertoireDuGenome]/$NameRepBlastnEST/$Nom" if {![file exists $FichierBlastnEST]} {continue} if {[info exists TabBlast]} {unset TabBlast} DepouilleLeBlast TabBlast $FichierBlastnEST if {![info exists TabBlast(NbSubject)]} {continue} set OrgaDeRef [OrganismeDuPAB $Nom] set NbSubject [set TabBlast(NbSubject)] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set TabBlast($i)] set Access [set TabBlast($BId,Access)] if {$Continue && [info exists DejaVu($Nom,$Access)]} {continue} Espionne "$Nom\t$BId\t$Access" set PAlignees [PourcentageDesBasesAligneesSurToutesLesBasesAlignables_TabBlast TabBlast $BId] if {$PAlignees < $IdDeRef} {continue} set PAlignables [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables_TabBlast TabBlast $BId] if {$PAlignables < $IdDeRef} {continue} set Page [PageInfo $BId est] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] if {$AllOrgaouJustMyOrga != "AllOrga"} { set EstCeUnDesOrga 0 foreach Orga $LesOrgas { if {[string equal -nocase $Orga $OrgaDeRef]} {set EstCeUnDesOrga 1;break} } if {!$EstCeUnDesOrga} {continue} } set LesDevStages [LesDevStageDeLAcNuc_PageInfo $Page] if {$LesDevStages == {}} {continue} foreach DevStage $LesDevStages { foreach Orga $LesOrgas { Espionne "$Nom\t$Access\t$Orga\t$DevStage" AppendAuFichier $FichierDevStage "$Nom\t$Access\t$Orga\t$DevStage" } } } } return } proc FichierDistancesPondereesParPresencesEntreTousLesClusters {} { set LesClusters [O2C2O LesClusters] global RepertoireDuGenome set RepDPP "$RepertoireDuGenome/DistancesPondereesParPresence" if {![file exists $RepDPP]} {file mkdir $RepDPP} foreach Categorie [O2C2O LesCategories] { Espionne "Categorie : $Categorie" set LeTexte {} set FichierDPP "$RepDPP/$Categorie" set LesOrganismes [O2C2O Categorie $Categorie LesOrganismesLongs] foreach Cluster1 $LesClusters { set P1 [O2C2O Cluster $Cluster1 Categorie $Categorie Presence] set LesDistancesPondereesParPresences {} foreach Cluster2 $LesClusters { set P2 [O2C2O Cluster $Cluster2 Categorie $Categorie Presence] set D [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] lappend LesDistancesPondereesParPresences [expr ($D / 100) * abs($P1 - $P2)] } lappend LeTexte [join $LesDistancesPondereesParPresences " "] } EspionneL $LeTexte Sauve [join $LeTexte "\n"] dans $FichierDPP } return } proc FichierDomainesPourTous {{LesNoms ""} {IdDesProtId 0.98} {NormMDMin 0.5} {ProportionMinDuDomaineDeLaQuery 0.75}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set RepMSF "[RepertoireDuGenome]/msf" set FileDomaines "[RepertoireDuGenome]/fiches/Domaines" ###Pour reprendre si le programme s'est arrete##### if {![file exists $FileDomaines]} {File delete -force $FileDomaines} set Continue 0 if {[file exists $FileDomaines]} { if {[OuiOuNon "$FileDomaines exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FileDomaines] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } } else { if {![OuiOuNon "$FileDomaines exists.\nWould you want to Keep this file?"]} { File delete -force $FileDomaines } else { return } } } foreach Nom $LesNoms { Espionne $Nom if {[info exists Tab]} {unset Tab} if {$Continue && [info exists DejaVu($Nom)]} {continue} set File "$RepMSF/$Nom" if {![file exists $File]} {continue} foreach LeDomaineDeRef [LesDomainesDeLaBoite $Nom $IdDesProtId $NormMDMin $ProportionMinDuDomaineDeLaQuery] { Espionne $LeDomaineDeRef AppendAuFichier $FileDomaines [join $LeDomaineDeRef "\t"] } } return } proc FichierEMBL2TFA {FichierEMBL FichierTFA Entete} { if {![file exists $FichierEMBL]} {return} set TexteEMBL [ContenuDuFichier $FichierEMBL] Sauve [EMBLtoTFA $TexteEMBL $Entete] dans $FichierTFA return } proc FichierEffectifDesDevStageTrouvesDansLaBanque {FichierDevStage {Orga ""} {Banque est}} { if {![file exists $FichierDevStage]} {return} set FichierEffectifDesDevStage "[RepertoireDuGenome]/fiches/EffectifsDesDevStage" set LesInfos {} foreach DevStage [lsort -unique [InterrogeDevStage LesDevStages]] { set n [EffectifDuFtdDansLaBanque $DevStage $Banque $Orga] if {$n == ""} {set n 0} Espionne "$DevStage\t$n" lappend LesInfos "$DevStage\t$n" } Sauve [join $LesInfos "\n"] dans $FichierEffectifDesDevStage return } proc FichierEffectifDesTissueTypeTrouvesDansLaBanque {FichierTissueType {Orga ""} {Banque est}} { if {![file exists $FichierTissueType]} {return} set FichierEffectifDesTissueType "[RepertoireDuGenome]/fiches/EffectifsDesTissueType" set LesInfos {} foreach Tissue [lsort -unique [InterrogeTissueType LesTissues]] { set n [EffectifDuFtdDansLaBanque $Tissue $Banque $Orga] if {$n == ""} {set n 0} Espionne "$Tissue\t$n" lappend LesInfos "$Tissue\t$n" } Sauve [join $LesInfos "\n"] dans $FichierEffectifDesTissueType return } proc FichierEffectifsDesGOs_TousLesClustersXHda {prottfaORblastpORclustersdesmsf} { set Fichiern "[RepertoireDuGenome]/fiches/EffectifsDesGOs_nGO_$prottfaORblastpORclustersdesmsf" set FichierP "[RepertoireDuGenome]/fiches/EffectifsDesGOs_pourcentageGO_$prottfaORblastpORclustersdesmsf" set FichierGO "[RepertoireDuGenome]/OntologyDesClustersXHda/GeneOntology_${prottfaORblastpORclustersdesmsf}_clusterXhda" set Tab(LesTypes) {} set Tab(LesGOs) {} set Tab(LesDefinitions) {} foreach Cluster [O2C2O LesClusters] { Espionne $Cluster set FichierGODuClust "${FichierGO}_$Cluster" if {![file exists $FichierGODuClust]} {Espionne $FichierGODuClust;continue} foreach LInfoGO [EffectifsDesGO $FichierGODuClust] { set Type [lindex $LInfoGO 0] if {$Type == ""} {Espionne $LInfoGO} set GO [lindex $LInfoGO 1] set nGO [lindex $LInfoGO 2] set nAccess [lindex $LInfoGO 3] set PourcentageGO [lindex $LInfoGO 4] set DefGO [lindex $LInfoGO 5] if {![info exists Tab(Cluster,$Cluster,LesTypes)]} { set Tab(Cluster,$Cluster,LesTypes) {} set Tab(Cluster,$Cluster,LesGOs) {} set Tab(Cluster,$Cluster,LesDefinitions) {} } if {![info exists Tab(Cluster,$Cluster,Type,$Type,LesGOs)]} { set Tab(Cluster,$Cluster,Type,$Type,LesGOs) {} set Tab(Cluster,$Cluster,Type,$Type,LesDefinitions) {} lappend Tab(Cluster,$Cluster,LesTypes) $Type set Tab(Cluster,$Cluster,Type,$Type,nAccess) $nAccess } lappend Tab(Cluster,$Cluster,LesGOs) $GO lappend Tab(Cluster,$Cluster,Type,$Type,LesGOs) $GO lappend Tab(Cluster,$Cluster,Type,$Type,LesDefinitions) $DefGO lappend Tab(Cluster,$Cluster,LesDefinitions) $DefGO set Tab(Cluster,$Cluster,GO,$GO,n) $nGO set Tab(Cluster,$Cluster,GO,$GO,Pourcentage) $PourcentageGO if {![info exists Tab(Type,$Type,LesGOs)]} { lappend Tab(LesTypes) $Type set Tab(Type,$Type,LesGOs) {} } if {![info exists Tab(GO,$GO,Definition)]} { set Tab(GO,$GO,Definition) $DefGO lappend Tab(LesGOs) $GO } if {![info exists Tab(Type,$Type,GO,$GO,LesClusters)]} { lappend Tab(Type,$Type,LesGOs) $GO } lappend Tab(Type,$Type,GO,$GO,LesClusters) $Cluster } } if {[set Tab(LesTypes)] == {}} {return} set LeTexten {} set LeTexteP {} foreach Type [set Tab(LesTypes)] { foreach GO [set Tab(Type,$Type,LesGOs)] { set Lignen [list $Type $GO] set LigneP [list $Type $GO] foreach Cluster [O2C2O LesClusters] { if {![info exists Tab(Cluster,$Cluster,GO,$GO,n)]} { set n 0 } else { set n [set Tab(Cluster,$Cluster,GO,$GO,n)] } if {![info exists Tab(Cluster,$Cluster,GO,$GO,Pourcentage)]} { set P 0 } else { set P [format "%.1f" [expr 100 * [set Tab(Cluster,$Cluster,GO,$GO,Pourcentage)]]] } lappend Lignen $n lappend LigneP $P } Espionne $Lignen Espionne $LigneP lappend LeTexten [join $Lignen "\t"] lappend LeTexteP [join $LigneP "\t"] } } Sauve [join $LeTexten "\n"] dans $Fichiern Sauve [join $LeTexteP "\n"] dans $FichierP return } proc FichierEnrichissementDesClusters {FichierOUT} { set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierGOProteo "[GODBDir]/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" Espionne "Populations des clusters" set Tab(LesNoms) {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { if {$Cluster == "PN10"} {continue} Espionne "Cluster: $Cluster" foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $Cluster LesNoms] { lappend Tab(LesNoms) $Nom if {1} { ####Tissue Type#################################### Espionne "Tissue Type" set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusTT) $LIndividu } ####Dev Stage#################################### Espionne "Dev Stage" set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusDS) $LIndividu } } if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## Espionne "GO" set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu } } if {1} { ###Domaines####################################### Espionne "Domaines" set LIndividu {} foreach LeDom [InterrogeDomaines $Nom LesDomaines] { set Type [lindex $LeDom 0] set Dom [lindex $LeDom 1] set Def [lindex $LeDom 2] if {$Def == ""} {continue} lappend LIndividu $Dom set Tab(Dom,$Dom,Def) $Def set Tab(Dom,$Dom,Type) $Type } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusDO) $LIndividu } } } } Espionne "OK" if {[info exists TabDeJaVu]} {unset TabDeJaVu} Espionne "Populations totales selectionnees" set LesIndividusGODeLaPop1 {} set LesIndividusTTDeLaPop1 {} set LesIndividusDSDeLaPop1 {} set LesIndividusDODeLaPop1 {} foreach Nom [set Tab(LesNoms)] { if {1} { ####Tissue Type#################################### Espionne "Tissue Type" set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType]] if {$LIndividu != {}} { lappend LesIndividusTTDeLaPop1 $LIndividu } ####Dev Stage#################################### Espionne "Dev Stage" set LIndividu [lsort -unique [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage]] if {$LIndividu != {}} { lappend LesIndividusDSDeLaPop1 $LIndividu } } if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## Espionne "GO" set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu != {}} { set LIndividu [lsort -unique $LIndividu] lappend LesIndividusGODeLaPop1 $LIndividu } } if {1} { ###Domaines####################################### Espionne "Domaines" set LIndividu {} foreach LeDom [InterrogeDomaines $Nom LesDomaines] { set Type [lindex $LeDom 0] set Dom [lindex $LeDom 1] set Def [lindex $LeDom 2] if {$Def == ""} {continue} lappend LIndividu $Dom set Tab(Dom,$Dom,Def) $Def set Tab(Dom,$Dom,Type) $Type } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend LesIndividusDODeLaPop1 $LIndividu } } } Espionne "OK" Espionne "Lecture Du FichierGO du Proteome" #Gene Ontology du proteome humain##### set LesIndividusGODeLaPop2 {} if {1} { foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu] } } Espionne "OK" Espionne "Calcul" set LeTexte {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { if {$Cluster == "PN10"} {continue} set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)] set LesIndividusTT [set Tab(Cluster,$Cluster,LesIndividusTT)] set LesIndividusDS [set Tab(Cluster,$Cluster,LesIndividusDS)] set LesIndividusDO [set Tab(Cluster,$Cluster,LesIndividusDO)] ###GO GO GO GO################ Espionne "Calcul GO" foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop1] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } ####Tissue Type##################### Espionne "Calcul Tissue Type" foreach LeTT [LesZscoreDesRequetesDuGroupe $LesIndividusTT $LesIndividusTTDeLaPop1] { set TT [lindex $LeTT 0] set r [lindex $LeTT 2] if {$r <= 0} {continue} set Stat [join [lrange $LeTT 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tTissue Type\t\t\t\t$TT\t\t$Stat" } ###Dev Stage##################### Espionne "Calcul Dev Stage" foreach LeDS [LesZscoreDesRequetesDuGroupe $LesIndividusDS $LesIndividusDSDeLaPop1] { set DS [lindex $LeDS 0] set r [lindex $LeDS 2] if {$r <= 0} {continue} set Stat [join [lrange $LeDS 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tDev Stage\t\t\t\t$DS\t\t$Stat" } ###Domaines##################### Espionne "Calcul Domaines" foreach LeDO [LesZscoreDesRequetesDuGroupe $LesIndividusDO $LesIndividusDODeLaPop1] { set DO [lindex $LeDO 0] set r [lindex $LeDO 2] if {$r <= 0} {continue} set Def [set Tab(Dom,$DO,Def)] set Type [set Tab(Dom,$DO,Type)] set Stat [join [lrange $LeDO 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tDomaines\tType\t$Type\t\t$DO\t$Def\t$Stat" } } Espionne "OK" Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierEnrichissementGODesClusters {FichierOUT} { ### Reduction de la proc FichierEnrichissementDesClusters a la GO seulement set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierGOProteo "[GODBDir]/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" Espionne "Populations des clusters" set Tab(LesNoms) {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { Espionne "Cluster: $Cluster" foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $Cluster LesNoms] { lappend Tab(LesNoms) $Nom if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## #Espionne "GO" set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } set LIndividu [lsort -unique $LIndividu] if {$LIndividu != {}} { lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu } } } } Espionne "OK" if {[info exists TabDeJaVu]} {unset TabDeJaVu} Espionne "Populations totales selectionnees" set LesIndividusGODeLaPop1 {} foreach Nom [set Tab(LesNoms)] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} if {1} { #####GO GO GO GO######################################## Espionne "GO" set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu != {}} { set LIndividu [lsort -unique $LIndividu] lappend LesIndividusGODeLaPop1 $LIndividu } } } Espionne "OK" Espionne "Lecture Du FichierGO du Proteome" #Gene Ontology du proteome humain##### set LesIndividusGODeLaPop2 {} if {1} { foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu] } } Espionne "OK" Espionne "Calcul" set LeTexte {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)] ###GO GO GO GO################ Espionne "Calcul GO" foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop1] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tAll\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] { set GO [lindex $LeGO 0] set r [lindex $LeGO 2] if {$r <= 0} {continue} set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] Espionne "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" lappend LeTexte "Cluster $Cluster\tHumanProteome\tGO\tType\t$Type\t$Niv\t$GO\t$Def\t$Stat" } } Espionne "OK" Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierExisteGrid {fquery} { global PipeCollection if {$PipeCollection} { set fquery [file join "[RepertoireDuGenome]" "prottfa" "${fquery}"] } return [file exists $fquery] } proc FichierExonicMapHuman {Nom RepTFA RepBlast RepOut {AvecBlastOuSansBlast SansBlast} {var 0.05} {SeuilId None} {SplitWithGap Yes} {AlertId 0.95} {TailleMin 10}} { set FichierOut "$RepOut/$Nom" set FichierQuery "$RepTFA/$Nom" set FichierBlast "$RepBlast/$Nom" set FichierOut "$RepOut/$Nom" if {![file exists $FichierBlast]} {return} if {![file exists $FichierQuery]} {return} set NbSubject 50 set ExpectDeRef 1e-3 set TailleMin 10 Espionne "$Nom -> Opening the blast file" DepouilleLeBlast TabBlast $FichierBlast $ExpectDeRef $NbSubject if {![info exists TabBlast(NbSubject)]} {Espionne "$Nom -> $FichierBlast no hits found";return ""} set TailleQuery [set TabBlast(Taille)] set TypeDeBlast [set TabBlast(TypeDeBlast)] Espionne "$Nom -> Scanning all the contig" set NbMax 0 set NbMax_Min [expr $NbMax * (1 - $var)] set LesBanqueId {} set NbSubject [set TabBlast(NbSubject)] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set TabBlast($i)] if {![string equal -nocase "hs" [string range $BId 0 1]]} {continue} regexp -nocase {([0-9a-z_]*):([0-9a-z]*)} $BId tmp Chromosome Contig if {[info exists TabTmp($BId,Nb) ]} {continue} set TabTmp($BId,Nb) 0 Espionne "$Nom -> $BId" foreach Base [LeProfilDeLAlignementDeLaQuery_TabBlast TabBlast $BId "BothSens"] {if {$Base != 0} {incr TabTmp($BId,Nb)}} if {[set TabTmp($BId,Nb)] < $NbMax_Min} {continue} lappend LesBanqueId $BId if {[set TabTmp($BId,Nb)] < $NbMax } {continue} set NbMax [set TabTmp($BId,Nb)] set NbMax_Min [expr $NbMax * (1 - $var)] set LesVieuxBanqueId $LesBanqueId set LesBanqueId {} foreach BId $LesVieuxBanqueId { if {[set TabTmp($BId,Nb)] < $NbMax_Min} {continue} lappend LesBanqueId $BId } } if {[info exists TabTmp]} {unset TabTmp} Espionne "$Nom -> done" Espionne "$Nom -> Computing the long area" set LesGrandesRegions [LesGrandesRegionsDuBlast TabBlast $LesBanqueId $SeuilId $SplitWithGap] Espionne "$Nom -> Computing the short area" set LesPetitesRegions [LesPetitesRegionsDesGrandesRegions $LesGrandesRegions ] Espionne "$Nom -> Computing the informations of the short area" set LesInfos [LesInfosDesRegionsDansLeBlast_TabBlast TabBlast $LesPetitesRegions $LesBanqueId $SeuilId "Contig"] set LesInfos [lsort -integer -index 0 $LesInfos] Espionne "$Nom -> done" set LesInfos [LaConservationDesMeilleuresRegionsRepetees $LesInfos $var $TailleMin] Espionne "$Nom -> Computing the best alignment for the exonic map" set i 0 set EstCeQuIlYAUneDiff 1 while {$EstCeQuIlYAUneDiff} { incr i if {$i == 10} {break} set LesRegionsUniquesParContig {} set LesRegionsRepeteesParContig {} foreach LInfoDeLaRegion $LesInfos { set NbArea [lindex $LInfoDeLaRegion 3] if {1 == $NbArea} {lappend LesRegionsUniquesParContig $LInfoDeLaRegion} if {1 < $NbArea} {lappend LesRegionsRepeteesParContig $LInfoDeLaRegion} } set LesRegionsDansLeBonOrdreDesContigs [LesRegionsUniquesDesContigsDansLeBonOrdre $LesRegionsUniquesParContig] set LesRegionsUniquesEtRepetees [LInsertionDesRegionsRepetees $LesRegionsRepeteesParContig $LesRegionsDansLeBonOrdreDesContigs $TailleQuery] set AiJeVuUneDiff 0 if {$LesInfos != $LesRegionsUniquesEtRepetees} {set AiJeVuUneDiff 1} if {$AiJeVuUneDiff} { set LesInfos $LesRegionsUniquesEtRepetees } else { set EstCeQuIlYAUneDiff 0 } if {0} { Espionne "#########ITERATION $i###########" EspionneL $LesInfos Espionne "" EspionneL $LesRegionsUniquesParContig Espionne "" EspionneL $LesRegionsDansLeBonOrdreDesContigs Espionne "" EspionneL $LesRegionsUniquesEtRepetees } } Espionne "$Nom -> done" set LesRegionsUniquesRepeteesEtAbsentes [LInsertionDesRegionsAbsentes $LesRegionsUniquesEtRepetees $TailleQuery] if {$AvecBlastOuSansBlast == "AvecBlast" && $TypeDeBlast == "BLASTN"} { set LesRegionsUniquesRepeteesEtAbsentes [LesRegionsAvecLesRegionsAbsentesBlastees $FichierQuery $LesRegionsUniquesRepeteesEtAbsentes $TailleQuery 10 1e5] set LesRegionsUniquesRepeteesEtAbsentes [LInsertionDesRegionsAbsentes $LesRegionsUniquesRepeteesEtAbsentes $TailleQuery] } set LesRegionsFusionnees [LesRegionsUniquesFusionneesDesContigs $LesRegionsUniquesRepeteesEtAbsentes $TailleMin] if {0} { Espionne "" EspionneL $LesRegionsUniquesEtRepetees Espionne "" EspionneL $LesRegionsUniquesEtRepetees Espionne "" EspionneL $LesRegionsUniquesRepeteesEtAbsentes Espionne "" EspionneL $LesRegionsFusionnees Espionne "" EspionneL $LesRegionsFusionnees } set Texte [TexteExonicMap_TabBlast TabBlast $Nom $FichierQuery $FichierBlast $LesRegionsFusionnees $AlertId $i] Espionne $Texte Sauve $Texte dans $FichierOut return $Texte } proc FichierExonicMapHumanPourTous {{NameRepTFA ""} {NameRepBlast ""} {DNAOrPROTEIN DNA} {AvecBlastOuSansBlast SansBlast} {LesNoms ""} {var 0.05} {SeuilId None} {SplitWithGap Yes} {AlertIdMin 0.8} {AlertIdMax 0.95} {Expect 0.001} {NbSubject 50} {TailleMin 10}} { set Banque "human" set Keep 0 if {[OuiOuNon "If some files exists. Would you want to conserve them?"]} {set Keep 1} set RepTFA "[RepertoireDuGenome]/$NameRepTFA" if {$NameRepBlast == ""} { if {$DNAOrPROTEIN == "DNA"} { set RepBlast "[RepertoireDuGenome]/${NameRepTFA}_blastn$Banque" } else { set RepBlast "[RepertoireDuGenome]/${NameRepTFA}_tblastn$Banque" } } else { set RepBlast "[RepertoireDuGenome]/$NameRepBlast" } if {![file exists $RepBlast]} {File mkdir $RepBlast} set RepOut "[RepertoireDuGenome]/${NameRepTFA}_exonicmap" if {![file exists $RepOut]} {File mkdir $RepOut } if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne "$Nom -> exonic map" set FileTFA "$RepTFA/$Nom" set FileTFAm "${FileTFA}.m" set FileBlast "$RepBlast/$Nom" set FileOut "$RepOut/$Nom" if {![file exists $FileTFA]} {continue} if {![EstCeQueLeFichierTFAEstConvenable $FileTFA]} {continue} set AlertId $AlertIdMax if {![regexp -nocase "Homo sapiens" [EnteteDuFichierTFA $FileTFA]]} {set AlertId $AlertIdMin} Espionne "$Nom -> blast against human genome" if {!$Keep || ![file exists $FileBlast]} { if {$DNAOrPROTEIN == "DNA"} { if {!$Keep || ![file exists $FileTFAm]} { set SeqTFA [MasqueLesRepeatsDuFichier $FileTFA] set Entete [EnteteDuTexteTFA $SeqTFA] set Seq [QueLaSequenceDuTexteTFA $SeqTFA] set LesRegions {} set LesRegions [concat $LesRegions [MasquePolyN $Seq "A" 9]] set LesRegions [concat $LesRegions [MasquePolyN $Seq "T" 9]] set LesRegions [concat $LesRegions [MasquePolyN $Seq "C" 9]] set LesRegions [concat $LesRegions [MasquePolyN $Seq "G" 9]] set SeqTFA [SequenceFormatTFA [MasqueLesRegions $Seq $LesRegions "N"] $Entete] Sauve $SeqTFA dans $FileTFAm } BlastNDuFichier $FileTFAm $Banque $FileBlast T $NbSubject $Expect 0 } else { TBlastNDuFichier $FileTFA $Banque 1 $FileBlast } } Espionne "$Nom -> exonic map in progress..." if {!$Keep || ![file exists $FileOut]} { FichierExonicMapHuman $Nom $RepTFA $RepBlast $RepOut $AvecBlastOuSansBlast $var $SeuilId $SplitWithGap $AlertId $TailleMin } } return } proc FichierFOF {Selection {Tmp ""}} { global RepertoireDuGenome global AccessDejaVus global FOFDejaVu Wup "Creates a file of filenames, each of one contains one of the sequences listed in the text Selection" JeMeSignale if { $Tmp == "" } { set FOF "tmp.[pid][NomDe ""].fof" } else { set FOF "$Tmp.fof" } if { [FormatDeLaSequence $Selection] == "tfas" } { TFAStoGCGs $Selection dans $FOF return "$FOF" } if {[info exists FOFDejaVu($Selection)]} { Sauve $FOFDejaVu($Selection) dans $FOF return "$FOF" } set Liste [split $Selection "\n"] catch {unset AccessDejaVus} foreach Ligne $Liste { if { [regexp "^Query=" $Ligne] } { set Access [QueryDeLaLigne $Ligne] lappend ListeFOF $Access set QueryAccess [file tail $Access] continue } set AccessOuFichier [lindex [split [string trim $Ligne] " "] 0] if { $AccessOuFichier == "" } { continue } set ListeDeFichiers [glob -nocomplain -- $AccessOuFichier] if { $ListeDeFichiers != "" } { foreach f $ListeDeFichiers { if {[file exists $f]} { lappend ListeFOF $f } } continue } if {[regexp {\*} $AccessOuFichier]} { set ListeDeAccess [split [FetchNoms $AccessOuFichier] " "] if { [llength $ListeDeAccess] != 0 } { foreach f $ListeDeAccess { lappend ListeFOF [Sauve [FetchCat "$f"] dans "[RepertoireDetravail]/$f"] } } continue } set Access $AccessOuFichier if {[regexp {^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+[ !]* [a-zA-Z0-9_]+} $Ligne]} { set Access [AccessDUneLigneBlast $Ligne] if {[regexp {/} $Access]} { lappend ListeFOF $Access continue } } if { [regexp {\:} $Access] } { set Banque [lindex [split $Access ":"] 0] set NomDeAccess [lindex [split $Access ":"] 1] } else { set NomDeAccess $Access } if {[info exists Banque]} { set Sequence [Fetche "$Banque:$NomDeAccess"] if { $Sequence != "" } { lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"] continue } } set Sequence [Fetche "protein:$NomDeAccess"] if { $Sequence != "" } { lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"] continue } set Sequence [Fetche "$NomDeAccess"] if { $Sequence != "" } { lappend ListeFOF [Sauve $Sequence dans "[RepertoireDeTravail]/$NomDeAccess"] continue } } Sauve [join $ListeFOF "\n"] dans $FOF set FOFDejaVu($Selection) [ContenuDuFichier $FOF] return "$FOF" } proc FichierFirstEFPourTous {NameRepTFA {LesNoms ""}} { set RepTFA "[RepertoireDuGenome]/$NameRepTFA" if {![file exists $RepTFA]} {continue} if {$LesNoms == "" } {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne $Nom set FichierTFA "$RepTFA/$Nom" if {![file exists $FichierTFA]} {continue} set FichierOUT "$FichierTFA.firstef" FirstEF $FichierTFA $FichierOUT } return } proc FichierFusionClXHDAParDistanceEtZscore {{SeuilDistance 300} {SeuilZscore 8} {SeuilDiffZScore 0} {LesTypes process}} { set FichierDonnees "[RepertoireDuGenome]/fiches/ZScoreDesClustersFusionnesParBestOntologyProttfaEtClusters" set FichierOut "[RepertoireDuGenome]/fiches/FusionClXHDAParDistanceEtZscore_${SeuilDistance}_${SeuilZscore}" set TypeDeRef [join $LesTypes " "] set F [open $FichierDonnees] set LesInfos {} while {[gets $F Ligne] >= 0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Cl1 [lindex $LaLigne 0 ] set Cl2 [lindex $LaLigne 1 ] if {$Cl1 == $Cl2 } {continue} set Type [lindex $LaLigne 4 ] if {$LesTypes != ""} {if {![regexp $Type $TypeDeRef]} {continue}} set Dist [lindex $LaLigne 2 ] if {$Dist > $SeuilDistance } {continue} set Z1 [lindex $LaLigne 6 ] if {$Z1 < $SeuilZscore } {continue} set DiffZ [lindex $LaLigne 8 ] if {$DiffZ < $SeuilDiffZScore} {continue} set GO [lindex $LaLigne 5 ] if {![info exists Tab($Cl1,LesClustersProches)]} { set Tab($Cl1,LesClustersProches) {} set Tab($Cl1,LesGOEnCommunAvecLesClustersProches) {} } if {![info exists Tab($Cl1,$Cl2,LesGOEnCommun)]} { lappend Tab($Cl1,LesClustersProches) $Cl2 set Tab($Cl1,$Cl2,LesGOEnCommun) {} } if {![info exists Tab($Cl1,$GO,LesClustersProches)]} { set Tab($Cl1,$GO,LesClustersProches) {} lappend Tab($Cl1,LesGOEnCommunAvecLesClustersProches) $GO } if {![info exists TabTmp($Cl1,$Cl2,$GO)]} { set TabTmp($Cl1,$Cl2,$GO) 1 lappend Tab($Cl1,$GO,LesClustersProches) $Cl2 lappend Tab($Cl1,$Cl2,LesGOEnCommun) $GO } } if {[info exists TabTmp]} {unset TabTmp} close $F set LesInfos {} foreach Cl1 [O2C2O LesClusters] { if {![info exists Tab($Cl1,LesGOEnCommunAvecLesClustersProches)]} {continue} foreach GO [set Tab($Cl1,LesGOEnCommunAvecLesClustersProches)] { if {![info exists Tab($Cl1,$GO,LesClustersProches)]} {continue} set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set LesClustersProchesReciproquement {} foreach Cl2 [lsort -unique [set Tab($Cl1,$GO,LesClustersProches)]] { if {![info exists Tab($Cl2,LesClustersProches)]} {continue} set AiJeVuMonCl1 0 foreach ClusterProcheDeCl2 [set Tab($Cl2,LesClustersProches)] { if {$ClusterProcheDeCl2 == $Cl1} {set AiJeVuMonCl1 1;break} } if {$AiJeVuMonCl1} {lappend LesClustersProchesReciproquement $Cl2} } if {$LesClustersProchesReciproquement == {}} {continue} set Clusters [join $LesClustersProchesReciproquement "\t"] Espionne "$Cl1\t$Type\t$GO\t$Def\t$Clusters" lappend LesInfos "$Cl1\t$Type\t$GO\t$Def\t$Clusters" } } Sauve [join $LesInfos "\n"] dans $FichierOut return } proc FichierFusionDeClustersXHdaDansOperonsParDistanceDPC {{SeuilDistanceDPCEntreClusters 200}} { global RepertoireDuGenome set FileClustersFusionnes "$RepertoireDuGenome/fiches/clustersXHda_dansoperons_fusionnes_distanceDPC" set LesInfos {} set LesClustersFusionnes {} set i 0 foreach Operon [O2C2O LesOperons] { Espionne $Operon foreach Cluster1 [O2C2O Operon $Operon LesClusters] { foreach Cluster2 [O2C2O Operon $Operon LesClusters] { set LInfo {} if {[info exists TabTmp($Cluster1,$Cluster2)]} {continue} if {$Cluster1 == $Cluster2} {continue} set TabTmp($Cluster1,$Cluster2) 1 set TabTmp($Cluster2,$Cluster1) 1 set Distance [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] if {$Distance > $SeuilDistanceDPCEntreClusters} {continue} lappend LesInfos "$Operon\t$Cluster1\t$Cluster2\t$Distance" lappend LesClustersFusionnes $Cluster1 lappend LesClustersFusionnes $Cluster2 incr i } } } #EspionneL $LesInfos Espionne $i set LesClustersFusionnes [lsort -unique $LesClustersFusionnes] Espionne $LesClustersFusionnes Espionne [llength $LesClustersFusionnes] set NbOrfsClustersFusionnes 0 foreach ClusterFusionne $LesClustersFusionnes { set NbOrfs [O2C2O Cluster $ClusterFusionne TailleCluster] incr NbOrfsClustersFusionnes $NbOrfs } Espionne $NbOrfsClustersFusionnes Sauve [join $LesInfos "\n"] dans $FileClustersFusionnes if {[info exists TabTmp]} {unset TabTmp} return $FileClustersFusionnes } proc FichierFusionDeClustersXHdaParDistanceDPC {{SeuilDistanceDPCEntreClusters 200}} { global RepertoireDuGenome set FileClustersFusionnes "$RepertoireDuGenome/fiches/clustersXHdafusionnes_distanceDPC" set LesInfos {} set LesClustersFusionnes {} set i 0 foreach Cluster1 [O2C2O LesClusters] { foreach Cluster2 [O2C2O LesClusters] { set LInfo {} if {[info exists TabTmp($Cluster1,$Cluster2)]} {continue} if {$Cluster1 == $Cluster2} {continue} set TabTmp($Cluster1,$Cluster2) 1 set TabTmp($Cluster2,$Cluster1) 1 set Distance [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] if {$Distance > $SeuilDistanceDPCEntreClusters} {continue} lappend LesInfos "$Cluster1\t$Cluster2\t$Distance" Espionne "$Cluster1\t$Cluster2\t$Distance" lappend LesClustersFusionnes $Cluster1 lappend LesClustersFusionnes $Cluster2 incr i } } set LesClustersFusionnes [lsort -unique $LesClustersFusionnes] Espionne $LesClustersFusionnes Espionne [llength $LesClustersFusionnes] set NbOrfsClustersFusionnes 0 foreach ClusterFusionne $LesClustersFusionnes { set NbOrfs [O2C2O Cluster $ClusterFusionne TailleCluster] incr NbOrfsClustersFusionnes $NbOrfs } Espionne $NbOrfsClustersFusionnes Sauve [join $LesInfos "\n"] dans $FileClustersFusionnes if {![info exists TabTmp]} {unset TabTmp} return $FileClustersFusionnes } proc FichierFusionDesClXHDA {{SeuilD 300} {SeuilZ 8} {SeuilDiffZ 0}} { set FichierOut "[RepertoireDuGenome]/fiches/FusionClXHDAParDistanceEtZscore_${SeuilDistance}_${SeuilZscore}" set ToutesLesFusionsDeClusters {} foreach Cluster [O2C2O LesClusters] { if {[info exists TabTmp($Cluster)]} {continue} set LesClustersProches [list $Cluster] set LesClustersProches [LesClustersProches $Cluster $SeuilD $SeuilZ $SeuilDiffZ] foreach ClusterProche $LesClustersProches { set TabTmp($Cluster) 1 } lappend ToutesLesFusionsDeClusters $LesClustersProches } set LesClustersFusionnesTot [linsert $] set TypeDeRef [join $LesTypes " "] set F [open $FichierDonnees] set LesInfos {} while {[gets $F Ligne] >= 0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Cl1 [lindex $LaLigne 0 ] set Cl2 [lindex $LaLigne 1 ] if {$Cl1 == $Cl2 } {continue} set Type [lindex $LaLigne 4 ] if {$LesTypes != ""} {if {![regexp $Type $TypeDeRef]} {continue}} set Dist [lindex $LaLigne 2 ] if {$Dist > $SeuilDistance } {continue} set Z1 [lindex $LaLigne 6 ] if {$Z1 < $SeuilZscore } {continue} set DiffZ [lindex $LaLigne 8 ] if {$DiffZ < $SeuilDiffZScore} {continue} set GO [lindex $LaLigne 5 ] if {![info exists Tab($Cl1,LesClustersProches)]} { set Tab($Cl1,LesClustersProches) {} set Tab($Cl1,LesGOEnCommunAvecLesClustersProches) {} } if {![info exists Tab($Cl1,$Cl2,LesGOEnCommun)]} { lappend Tab($Cl1,LesClustersProches) $Cl2 set Tab($Cl1,$Cl2,LesGOEnCommun) {} } if {![info exists Tab($Cl1,$GO,LesClustersProches)]} { set Tab($Cl1,$GO,LesClustersProches) {} lappend Tab($Cl1,LesGOEnCommunAvecLesClustersProches) $GO } if {![info exists TabTmp($Cl1,$Cl2,$GO)]} { set TabTmp($Cl1,$Cl2,$GO) 1 lappend Tab($Cl1,$GO,LesClustersProches) $Cl2 lappend Tab($Cl1,$Cl2,LesGOEnCommun) $GO } } if {[info exists TabTmp]} {unset TabTmp} close $F set LesInfos {} foreach Cl1 [O2C2O LesClusters] { if {![info exists Tab($Cl1,LesGOEnCommunAvecLesClustersProches)]} {continue} foreach GO [set Tab($Cl1,LesGOEnCommunAvecLesClustersProches)] { if {![info exists Tab($Cl1,$GO,LesClustersProches)]} {continue} set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set LesClustersProchesReciproquement {} foreach Cl2 [lsort -unique [set Tab($Cl1,$GO,LesClustersProches)]] { if {![info exists Tab($Cl2,LesClustersProches)]} {continue} set AiJeVuMonCl1 0 foreach ClusterProcheDeCl2 [set Tab($Cl2,LesClustersProches)] { if {$ClusterProcheDeCl2 == $Cl1} {set AiJeVuMonCl1 1;break} } if {$AiJeVuMonCl1} {lappend LesClustersProchesReciproquement $Cl2} } if {$LesClustersProchesReciproquement == {}} {continue} set Clusters [join $LesClustersProchesReciproquement "\t"] Espionne "$Cl1\t$Type\t$GO\t$Def\t$Clusters" lappend LesInfos "$Cl1\t$Type\t$GO\t$Def\t$Clusters" } } Sauve [join $LesInfos "\n"] dans $FichierOut return } proc FichierGO2Type {FichierGO} { set Type "" regsub {\.ontology} [file tail $FichierGO] "" Type return $Type } proc FichierGOPourPlessy {FichierAcc FichierOut {NiveauGOMin 2}} { set LesAccess {} set LeTexte {} set F [open $FichierAcc] set i 0 while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set Access $Ligne if {![info exists Tab($Access,LesGO)]} { lappend LesAccess $Access set Tab($Access,LesGO) {} } else { continue } incr i #if {10<$i} {break} set LesAccessProt [LesIdDeLaBanqueRelieALAccess $Access de genbankfull dans protein] set AiJeVuUneProt 0 foreach AccessProt $LesAccessProt { set AiJeVuUneProt 1 set AiJeVuDeGO 0 foreach GO [Access2GO $AccessProt] { foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Ligne "$Access\t$AccessProt\t$Type\t$GO\t$Def" Espionne $Ligne lappend LeTexte $Ligne set AiJeVuDeGO 1 lappend Tab($Access,LesGO) $GO } } if {$AiJeVuDeGO} {continue} set Ligne "$Access\t$AccessProt" Espionne $Ligne lappend LeTexte $Ligne } if {$AiJeVuUneProt} {continue} set Ligne $Access Espionne $Ligne lappend LeTexte $Ligne } close $F set LesGODeRef {} set LesAccess [lsort -unique $LesAccess] set NbAccess [llength $LesAccess] set NbAccessAvecGO 0 set NbGO 0 foreach Access $LesAccess { set LesGO [lsort -unique [EnterrerLesAncetresGO [set Tab($Access,LesGO)]]] if {$LesGO == {}} {continue} incr NbAccessAvecGO set LesGO [lsort -unique [concat $LesGO [TousLesAncetresGODesGO $LesGO]]] foreach GO $LesGO { Espionne "$Access $GO" if {![info exists Tab($GO,n)]} { lappend LesGODeRef $GO set Tab($GO,n) 0 } incr Tab($GO,n) incr NbGO } } foreach GO $LesGODeRef { set n [set Tab($GO,n)] foreach Type [GODB GO $GO LesTypes] { set Niv [lindex [lsort -real [GODB Type $Type GO $GO LesNiveaux]] 0] if {$Niv < $NiveauGOMin} {continue} set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] Espionne "$Type\t$GO\t$Niv\t$n\t$NbGO\t$NbAccessAvecGO\t$NbAccess\t$Def" lappend LeTexte "$Type\t$GO\t$Niv\t$n\t$NbGO\t$NbAccessAvecGO\t$NbAccess\t$Def" } } Sauve [join $LeTexte "\n"] dans $FichierOut return } proc FichierGeneNamePourTous {{LesNoms ""} {IdDesProtId 0.98} {NormMDMin 0.5}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierGeneName "[RepertoireDuGenome]/fiches/GeneName" set Continue 0 if {[file exists $FichierGeneName]} { if {[OuiOuNon "$FichierGeneName exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FichierGeneName] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Access [lindex $LaLigne 1] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} set DejaVu($Nom,$Access) 1 } if {[info exists DejaVu($Nom)]} {unset DejaVu($Nom)} } else { if {[OuiOuNon "$FichierGeneName exists.\nWould you want to deltree this file?"]} { File delete -force $FichierGeneName } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} foreach Access [LesAccessProchesDeLaProteineDeRef $Nom $IdDesProtId AvecCluster $NormMDMin] { if {[EstUnAccessPDB $Access]} {continue} set Page [PageInfo $Access protein] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] foreach GeneName [LesGeneNameDeLAccess_PageInfo $Page] { foreach Orga $LesOrgas { Espionne "$Nom\t$Access\t$Orga\t$GeneName" AppendAuFichier $FichierGeneName "$Nom\t$Access\t$Orga\t$GeneName" } } } } return } proc FichierGeneOntologyChoisi {FichierGO {FichierGOOut ""} {FichierOrf2Cluster ""} {FichierGOChoisi ""}} { if {$FichierGOOut == ""} {set FichierGOOut "[RepertoireDuGenome]/fiches/GeneOntology_choosen"} if {$FichierGOChoisi == ""} {set FichierGOChoisi "[RepertoireDuGenome]/fiches/ChoosenOntology"} if {![file exists $FichierGOChoisi ]} {return} if {$FichierOrf2Cluster == ""} {set FichierOrf2Cluster "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"} if {![file exists $FichierOrf2Cluster]} {return} if {![file exists $FichierGO ]} {return} foreach Nom [ListeDesPABs] { Espionne $Nom set LesGOChoisis {} set LesGO {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGO $GO foreach GOPere [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LesGO $GOPere } } foreach GO [ElimineLesRedondancesDansUneListe $LesGO] { if {[InterrogeChoosenGeneOntology $FichierGOChoisi GOChoisi $GO Type] == ""} {continue} lappend LesGOChoisis $GO } if {$LesGOChoisis == {}} { set Tab($Nom,LesGOChoisis) {} continue } set Tab($Nom,LesGOChoisis) [EnterrerLesAncetresOntologiques [ElimineLesRedondancesDansUneListe $LesGOChoisis]] } foreach Nom [ListeDesPABs] { Espionne $Nom set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom Cluster] if {![info exists Tab($Nom,LesGOChoisis)]} { AppendAuFichier $FichierGOOut "$Nom\t$Cluster\t$Nom\tNoOntologyFound" continue } if {[set Tab($Nom,LesGOChoisis)] == ""} { AppendAuFichier $FichierGOOut "$Nom\t$Cluster\t$Nom\tNoOntologyFound" continue } foreach GO [set Tab($Nom,LesGOChoisis)] { set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set Ancetres [join [TousLesAncetresOntologiques $Type $GO] "\t"] AppendAuFichier $FichierGOOut "$Nom\t$Cluster\t$Nom\t$Type\t$GO\t$Def\t$Ancetres" } } return } proc FichierGeneOntologyDesBlastPPourTous {{Expect 1e-10} {NbSubject 10} {LesNoms ""}} { set RepBlastP "[RepertoireDuGenome]/blastp" set FichierOntology "[RepertoireDuGenome]/fiches/GeneOntology_blastp" if {$LesNoms == {}} {set LesNoms [ListeDesPABs]} set Continue 0 if {[file exists $FichierOntology]} { if {[OuiOuNon "$FichierOntology exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" set LesLignes {} foreach Ligne [LesLignesDuFichier $FichierOntology] { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {$Nom == ""} {continue} if {[lindex $LaLigne 2] == "NoProteinFound"} {continue} lappend LesLignes $Ligne if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } Sauve [join $LesLignes "\n"] dans $FichierOntology } else { if {[OuiOuNon "$FichierOntology exists.\nWould you want to deltree this file?"]} { File delete -force $FichierOntology } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} set FichierBlast "$RepBlastP/$Nom" Espionne "$Nom -> Gene Ontology of blastp $FichierBlast" if {![file exists $FichierBlast]} {continue} set LesHits [LesHitsDuBlast_FC $FichierBlast $Expect 1e200] if {$LesHits == {}} {continue} set i 0 set LesOntologies {} foreach LeHit $LesHits { set BId [lindex $LeHit 0] if {[EstUnAccessPDB $BId]} {continue} incr i if {$NbSubject < $i} {break} set AccessProt [string toupper [lindex $LeHit 1]] Espionne $AccessProt foreach LOntologie [GeneOntologyDeLAccess $AccessProt] { AppendAuFichier $FichierOntology "$Nom\t$i\t[join $LOntologie "\t"]" } } } return } proc FichierGeneOntologyDesClustersDeMSFPourTous {{LesNoms ""}} { set RepMSF "[RepertoireDuGenome]/msf" set FichierOntology "[RepertoireDuGenome]/fiches/GeneOntology_clustersdesmsf" if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set Continue 0 if {[file exists $FichierOntology]} { if {[OuiOuNon "$FichierOntology exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" set LesLignes {} foreach Ligne [LesLignesDuFichier $FichierOntology] { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {$Nom == ""} {continue} if {[lindex $LaLigne 2] == "NoProteinFound"} {continue} lappend LesLignes $Ligne if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } Sauve [join $LesLignes "\n"] dans $FichierOntology } else { if {[OuiOuNon "$FichierOntology exists.\nWould you want to deltree this file?"]} { File delete -force $FichierOntology } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} set FichierClust "$RepMSF/${Nom}.clust" Espionne "$Nom -> Gene Ontology of clusters of msf $FichierClust" if {![file exists $FichierClust]} {continue} set LesClusters [InterrogeLesClustersDesMSF $FichierClust LesClusters] if {$LesClusters == {}} {continue} foreach Cluster [lsort $LesClusters] { set LesAccess [InterrogeLesClustersDesMSF $FichierClust Cluster $Cluster LesAccess] if {$LesAccess == {}} {continue} foreach Access $LesAccess { #Elimine les pdb### if {[EstUnAccessPDB $Access]} {continue} set SuisJeSurLaQuery 0 if {$Access == $Nom} { set Access [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {[string equal -nocase $Access "NoProtein"]} { set Access [InterrogeContigAndProt $Nom Protein Access] } if {$Access == ""} {continue} set SuisJeSurLaQuery 1 } Espionne "$Nom $Cluster $Access" foreach LOntologie [GeneOntologyDeLAccess $Access] { if {$SuisJeSurLaQuery} {set LOntologie [lreplace LOntologie 0 0 $Nom]} AppendAuFichier $FichierOntology "$Nom\t$Cluster\t[join $LOntologie "\t"]" } } } InterrogeLesClustersDesMSF unset } return } proc FichierGeneOntologyDesClustersFusionnesPourTous {FichierGO {LesNoms ""} {FileGOOut ""} {P 0.70} {FractionDuMax 0.7} {NbGOParTypePourLesMSF ""}} { if {$FileGOOut == ""} {set FileGOOut "[RepertoireDuGenome]/fiches/GeneOntology_ClustersFusionnes"} if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne $Nom set ClusterXHDA [O2C2O Orf $Nom Cluster] set ClusterFusionne [O2C2O Cluster $ClusterXHDA ClusterFusionne] if {![info exists TabGO($ClusterFusionne,LesGO)]} {set TabGO($ClusterFusionne,LesGO) {}} ###Determination du cluster du msf contenant notre proteine###### foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {$GO == ""} {continue} lappend TabGO($ClusterFusionne,LesGO) $GO } } set LesOntologies {} foreach ClusterFusionne [O2C2O LesClustersFusionnes] { if {![info exists TabGO($ClusterFusionne,LesGO)]} { lappend LesOntologies [join [list $ClusterFusionne $ClusterFusionne $ClusterFusionne "NoOntologyFound"] "\t"] continue } set LesGO [set TabGO($ClusterFusionne,LesGO)] ###Selection des GO les plus representatifs de ce cluster####### set LesGO [LaSelectionDesMeilleursGO $LesGO $P $FractionDuMax $NbGOParTypePourLesMSF] if {$LesGO == {}} { lappend LesOntologies [join [list $ClusterFusionne $ClusterFusionne $ClusterFusionne "NoOntologyFound"] "\t"] continue } ###On elimine les ancetres et les doublons### foreach GO [EnterrerLesAncetresOntologiques [ElimineLesRedondancesDansUneListe $LesGO]] { set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set LesAncetres [TousLesAncetresOntologiques $Type $GO] set Ontologie [join [list $ClusterFusionne $ClusterFusionne $ClusterFusionne $Type $GO $Def [join $LesAncetres "\t"]] "\t"] Espionne $Ontologie lappend LesOntologies $Ontologie } } Sauve [join $LesOntologies "\n"] dans $FileGOOut return } proc FichierGeneOntologyDesClustersXHDAPourTous {FichierGO {LesNoms ""} {FileGOOut ""} {P 0.70} {FractionDuMax 0.7} {NbGOParTypePourLesMSF ""}} { if {$FileGOOut == ""} {set FileGOOut "[RepertoireDuGenome]/fiches/GeneOntology_ClustersXHda"} if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne $Nom set ClusterXHDA [O2C2O Orf $Nom Cluster] if {![info exists TabGO($ClusterXHDA,LesGO)]} {set TabGO($ClusterXHDA,LesGO) {}} ###Determination du cluster du msf contenant notre proteine###### foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {$GO == ""} {continue} lappend TabGO($ClusterXHDA,LesGO) $GO } } set LesOntologies {} foreach ClusterXHDA [O2C2O LesClusters] { if {![info exists TabGO($ClusterXHDA,LesGO)]} { lappend LesOntologies [join [list $ClusterXHDA $ClusterXHDA $ClusterXHDA "NoOntologyFound"] "\t"] continue } set LesGO [set TabGO($ClusterXHDA,LesGO)] ###Selection des GO les plus representatifs de ce cluster####### set LesGO [LaSelectionDesMeilleursGO $LesGO $P $FractionDuMax $NbGOParTypePourLesMSF] if {$LesGO == {}} { lappend LesOntologies [join [list $ClusterXHDA $ClusterXHDA $ClusterXHDA "NoOntologyFound"] "\t"] continue } ###On elimine les ancetres et les doublons### foreach GO [EnterrerLesAncetresOntologiques [ElimineLesRedondancesDansUneListe $LesGO]] { set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set LesAncetres [TousLesAncetresOntologiques $Type $GO] set Ontologie [join [list $ClusterXHDA $ClusterXHDA $ClusterXHDA $Type $GO $Def [join $LesAncetres "\t"]] "\t"] Espionne $Ontologie lappend LesOntologies $Ontologie } } Sauve [join $LesOntologies "\n"] dans $FileGOOut return } proc FichierGeneOntologyDesNomsInteressants_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set FichierOUT "[RepertoireDuGenome]/fiches/GeneOntology_NomsInteressants" foreach Nom [LesNoms $PABouNomsInteressantsouListeouFichier] {set Tab($Nom) 1} set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" set LeTexte {} set F [open $FichierGO] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set Nom [lindex [split $Ligne "\t"] 0] if {![info exists Tab($Nom)]} {continue} Espionne $Ligne AppendAuFichier $FichierOUT $Ligne } close $F return } proc FichierGeneOntologyDesProttfaPourTous {{LesNoms ""} {Id 0.98}} { set FichierOntology "[RepertoireDuGenome]/fiches/GeneOntology_prottfa" if {$LesNoms == {}} {set LesNoms [ListeDesPABs]} set ToutesLesOntologies {} set Continue 0 if {[file exists $FichierOntology]} { if {[OuiOuNon "$FichierOntology exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FichierOntology] { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] if {$Nom == ""} {continue} if {[lindex $LaLigne 2] == "NoProteinFound"} {continue} lappend ToutesLesOntologies $LaLigne if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} } } else { if {[OuiOuNon "$FichierOntology exists.\nWould you want to deltree this file?"]} { File delete -force $FichierOntology } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} Espionne "$Nom -> Gene Ontology of prottfa" set FichierProtTFA "[RepertoireDuGenome]/prottfa/$Nom" if {![file exists $FichierProtTFA]} {continue} if {[info exists TabFeuille]} {unset TabFeuille} if {[info exists TabAncetre]} {unset TabAncetre} set Access [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {[string equal -nocase $Access "NoProtein"]} { set Access [InterrogeContigAndProt $Nom Protein Access] } set FileMSF "[RepertoireDuGenome]/msf/$Nom" set LesAccess {} if {$Access != ""} {lappend LesAccess $Access} if {[file exists $FileMSF]} { set LesAccess [concat $LesAccess [LesAccessDesProteinesIdentiquesDansMSF $FileMSF $Nom $Id]] } if {$LesAccess == {}} {continue} set LesOntologies {} foreach Access [ElimineLesRedondancesDansUneListe $LesAccess] { if {$Access == ""} {continue} foreach LOntologie [GeneOntologyDeLAccess $Access] { set LOntologie [linsert $LOntologie 0 $Nom] set LOntologie [linsert $LOntologie 1 1] set GO [lindex $LOntologie 4] set TabFeuille($GO) 0 foreach Ancetre [lindex $LOntologie 6] { set TabAncetre($Ancetre) 1 } lappend LesOntologies $LOntologie } } if {$LesOntologies == {}} {continue} foreach LOntologie $LesOntologies { set GO [lindex $LOntologie 4] if {[info exists TabAncetre($GO)]} {continue} set n [set TabFeuille($GO)] if {1 <= $n} {continue} Espionne $LOntologie incr TabFeuille($GO) lappend ToutesLesOntologies $LOntologie } } set LeTexte {} foreach LOntology [lsort -index 0 [lsort -index 1 $ToutesLesOntologies]] { lappend LeTexte [join $LOntology "\t"] } Sauve [join $LeTexte "\n"] dans $FichierOntology return $ToutesLesOntologies } proc FichierGeneOntologyDuProteome {FichierOut {Organism "Homo sapiens"}} { Espionne "Database searches running ..." set Commande "[ProgPathway getz] \"\\\[swissprot\-org:$Organism\\\] \| \\\[sptrembl\-org:$Organism\\\] \" \-f id" #set Commande "[ProgPathway getz] \"\\\[swissprot\-org:$Organism\\\] \" \-f id" if {[catch {set Out [eval exec $Commande]} Message]} {Espionne $Message;return} Espionne "Database searches OK ..." set LePaquetDId {} set LesPaquetsDId {} set NbIdParPaquets 1000 set i 0 foreach Ligne [split $Out "\n"] { set BId [BanqueIdDeLaProt_PageInfo $Ligne] if {$BId == ""} {continue} incr i if {$i < $NbIdParPaquets} {lappend LePaquetDId $BId;continue} lappend LePaquetDId $BId lappend LesPaquetsDId $LePaquetDId set i 0 set LePaquetDId {} } if {$LePaquetDId != {}} {lappend LesPaquetsDId $LePaquetDId} set LeTexte {} set NbProt 0 foreach LePaquetDId $LesPaquetsDId { AskLesPagesInfos load $LePaquetDId protein foreach BId $LePaquetDId { set Page [AskLesPagesInfos ask $BId] if {$Page == ""} {continue} set LesAccess [LesAccessDeLaPageInfo $Page] set LAiJeDejaVu 0 foreach Access $LesAccess { if {[info exists TabDejaVu($Access)]} {set LAiJeDejaVu 1} set TabDejaVu($Access) 1 } if {$LAiJeDejaVu} {continue} incr NbProt set LesGO [PageInfo2GO $Page] if {$LesGO == {}} { set Ligne "$BId\t$NbProt\t$BId\tNoOntologyFound" Espionne $Ligne lappend LeTexte $Ligne continue } foreach GO $LesGO { foreach Type [GODB GO $GO LesTypes] { set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Ancetres [join [TousLesAncetresGO $Type $GO] "\t"] set Ligne "$BId\t$NbProt\t$BId\t$Type\t$GO\t$Def\t$Ancetres" Espionne $Ligne lappend LeTexte $Ligne } } } AskLesPagesInfos unset } if {$LeTexte == {}} {return} Sauve [join $LeTexte "\n"] dans $FichierOut return } proc FichierGenomesEukaryotes {} { global RepertoireDuGenome global LesGenomesComplets set LesOrgaEukaryotes {} foreach Orga $LesGenomesComplets { set Phylum [PhylumDuOrganisme $Orga] if {$Phylum != "E"} {continue} lappend LesOrgaEukaryotes $Orga } lappend LesOrgaEukaryotes "Homo sapiens" set File "$RepertoireDuGenome/fiches/lesgenomeseukaryotes" if {$LesOrgaEukaryotes == {}} {return ""} Sauve [join $LesOrgaEukaryotes "\n"] dans $File return $File } proc FichierHTML {Nom} { set Fichier "[RepertoireDuGenome]/bilan/$Nom" set NomFichier [file tail $Fichier] set TexteHtml [Html_DuTexteTelQuel $Fichier $NomFichier] set Fichier_html "[RepertoireDuGenome]/BilanHTML/$NomFichier.html" Sauve $TexteHtml dans $Fichier_html } proc FichierHTMLPourTous {Prefix} { foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/bilan/$Prefix*"] { Espionne $Fichier set NomFichier [file tail $Fichier] set TexteHtml [Html_DuTexteTelQuel $Fichier $NomFichier] if {![file exists "[RepertoireDuGenome]/bilan/html_nolink"]} {File mkdir "[RepertoireDuGenome]/bilan/html_nolink"} set Fichier_html "[RepertoireDuGenome]/bilan/html_nolink/$NomFichier.html" Sauve $TexteHtml dans $Fichier_html } } proc FichierKEGGPourTous {{LesNoms ""} {IdDesProtId 0.98} {NormMDMin 0.5}} { set FichierKEGG "[RepertoireDuGenome]/fiches/Kegg" if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set JeContinue 0 if {[file exists $FichierKEGG] && [OuiOuNon "$FichierKEGG exists. Would you want to continue?"]} { set JeContinue 1 foreach Ligne [LesLignesDuFichier $FichierKEGG] { if {$Ligne == ""} {continue} scan $Ligne "%s" Nom set TabDejaVu($Nom) 1 } } set FichierGeneOntology [ChoixParmi [glob -nocomplain "[RepertoireDuGenome]/fiches/GeneOntology*"]] foreach Nom $LesNoms { if {$JeContinue && [info exists TabDejaVu($Nom)]} {continue} Espionne $Nom set FileMSF "[RepertoireDuGenome]/msf/$Nom" set FileClust "${FileMSF}.clust" foreach Ligne [KEGG $Nom $FileMSF $FileClust $IdDesProtId $NormMDMin] { AppendAuFichier $FichierKEGG $Ligne } } return } proc FichierLMS {Nom ReInitialise} { global RepertoireDuGenome set FichierTFA "$RepertoireDuGenome/prottfa/$Nom" if {![file exists $FichierTFA]} { Espionne "$Nom -> $FichierTFA does not exist." return "" } if {[QueLaSequenceDuTFA $FichierTFA] == ""} { Espionne "$Nom -> $FichierTFA empty" return "" } set RepLMS "$RepertoireDuGenome/lms" if {![file exists $RepLMS]} {File mkdir $RepLMS} set FichierLMS "$RepLMS/$Nom" if {[file exists $FichierLMS] && $ReInitialise == 0} {return ""} set Rep [RepertoireDeTravail] set FichierBlast "$Rep/${Nom}.blastp" set EditCommand 0 set Banque "protall" set Expect 10000 set Filtre 1 set ShowSubject 10000 Espionne "$Nom -> blastp" BlastPPourBallast $FichierTFA $FichierBlast $EditCommand $Banque $Expect $Filtre $ShowSubject if {[file exists $FichierBlast]} {Espionne "$FichierBlast exists"} Espionne "$Nom -> ballast" BallastUnBlastP $FichierBlast $Rep set FichierBallast $FichierBlast Espionne "$Nom -> Extracting the number of LMS for all the Access" set Texte [FichierLMSDesAccessDuBallast $FichierBallast] Espionne "$Nom -> Saving the results in $FichierLMS" Sauve $Texte dans "$FichierLMS" Espionne "$Nom -> Destroying the ballast files" foreach File [glob -nocomplain "$Rep/$FichierBallast"] { File delete -force "$File" File delete -force "$File.anchors" File delete -force "$File.anclist" File delete -force "$File.list" File delete -force "$File.mask" File delete -force "$File.motifs" File delete -force "$File.msf" File delete -force "$File.prof" } return "" } proc FichierLMSDesAccessDuBallast {FichierBallast} { global RepertoireDuGenome if {![file exists $FichierBallast]} { Espionne "$FichierBallast does not exist." return "" } set FichierMotifs "$FichierBallast.motifs" if {![file exists $FichierMotifs]} { Espionne "$FichierMotifs does not exist." return "" } set FichierAnchors "$FichierBallast.anchors" if {![file exists $FichierAnchors]} { Espionne "$FichierAnchors does not exist." return "" } set LesLMS {} set nLMS 0 foreach Ligne [LesLignesDuFichier $FichierMotifs] { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} if {[regexp "Suggested Words" $Ligne]} {continue} set Ligne [string trim $Ligne] scan $Ligne "%d %s %d" DebutLMS Separateur FinLMS incr nLMS lappend LesLMS [list "$DebutLMS" "$FinLMS" "$nLMS"] } set LesAccess {} foreach Ligne [LesLignesDuFichier $FichierAnchors] { if {![regexp -nocase "seq:" $Ligne]} {continue} if {[info exists LMS]} {unset LMS} if {[info exists Access] } {unset Access } if {[info exists Position]} {unset Position} scan $Ligne "%s %s %s %s %d %s %d" Seq Query Access Pos Pos1 Beg Position if {![info exists TabAccess($Access)]} { lappend LesAccess $Access set TabAccess($Access) {} } set TrouveLeLMS 0 foreach LeLMS $LesLMS { set Debut [lindex $LeLMS 0] set Fin [lindex $LeLMS 1] if { $Debut <= $Position && $Position <= $Fin} { set nLMS [lindex $LeLMS 2] lappend TabAccess($Access) $nLMS set TrouveLeLMS 1 break } } if {$TrouveLeLMS == 0} { Espionne "$Nom -> ERROR $Access $Position ERROR" } } set Texte "" foreach Access $LesAccess { append Texte "ID $Access\n" set LesnLMSs [set TabAccess($Access)] set NbCar 0 append Texte "CA " foreach nLMS $LesnLMSs { set n [string length $nLMS] set NbCar [expr $NbCar + $n] if {100 < $NbCar} {set NbCar 0;append Texte "\nCA "} append Texte "$nLMS;" } append Texte "\nDR prot;$Access;prot." append Texte "\n//\n" } return $Texte } proc FichierLMSPourTous {{LesNoms ""}} { global RepertoireDuGenome set RepLMS "$RepertoireDuGenome/lms" if {![file exists $RepLMS]} {File mkdir $RepLMS} set ReInitialise 1 if {0 < [llength [glob -nocomplain "$RepLMS/*"]]} { if {[OuiOuNon "Some files exists in $RepLMS\nDo I conserv them?"]} {set ReInitialise 0} } if {$LesNoms == {} } {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { FichierLMS $Nom $ReInitialise } return "" } proc FichierLesOperons {} { ###Creation du fichier contenant tous les operons### set FileOperons "[RepertoireDuGenome]/fiches/operons" if {[file exists $FileOperons]} { set LesOperons [LesLignesDuFichier $FileOperons] return $LesOperons } set LesOperons {} set LOperon {} set PremierDejaMis 0 set i 0 foreach Orf [ListeDesPABs] { set Liste [ListeDesOrganismesAyantMemeOperon $Orf] set Voisin [lindex $Liste 0] set LesOrgas [lrange $Liste 1 end] set SuisJeDansUnOperon 0 foreach Orga $LesOrgas { if { [TooCloseOrganism $Orga]} { continue } if { ![OrgaInteressant $Orga]} { continue } set SuisJeDansUnOperon 1 } if {$SuisJeDansUnOperon} { if { ! $PremierDejaMis } { incr i lappend LOperon $i $Voisin set PremierDejaMis 1 } lappend LOperon $Orf } else { if {[llength $LOperon] > 1} { Espionne $LOperon lappend LesOperons $LOperon } set PremierDejaMis 0 set LOperon {} } } if {[llength $LOperon] > 1} { Espionne $LOperon lappend LesOperons $LOperon } Sauve [join $LesOperons "\n"] dans $FileOperons return $LesOperons } proc FichierMacsimPourTous {{LesNoms ""}} { set RepRSF "[RepertoireDuGenome]/rsf" if {![file exists $RepRSF]} {File mkdir $RepRSF} set RepMSF "[RepertoireDuGenome]/msf" set Keep 1 if {[OuiOuNon "If some files exists in $RepRSF, Do you want to delete them?"]} {set Keep 0} if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne $Nom set FileRSF "$RepRSF/$Nom" set FileMSF "$RepMSF/$Nom" if {![file exists $FileMSF]} {continue} if {$Keep && [file exists $FileRSF]} {continue} Macsim $FileMSF $FileRSF } return } proc FichierMemeNomMaisDifferent {} { set Rep1 [ChoisirUnRepertoire "Choisir Le Repertoire 1"] set Rep2 [ChoisirUnRepertoire "Choisir Le Repertoire 2"] foreach File1 [glob -nocomplain "$Rep1/*"] { set Name [file tail $File1] if {![file exists "$Rep2/Name"]} {continue} set File2 "$Rep2/Name" if {[ContenuDuFichier $File1] == [ContenuDuFichier $File2]} { continue } else { Espionne $Name } } } proc FichierMiniConfig {} { global RepertoireDuGenome return "$RepertoireDuGenome/beton/miniconfig" } proc FichierModAssocie {NomSeq3d FiMsf3d} { set Rep [file dirname $FiMsf3d] set FichierMod "$Rep/$NomSeq3d/${NomSeq3d}_20.mod" if {[file exists $FichierMod]} { return $FichierMod } Wup "the Lego mod file doesn't exist. We'll create it" set RepForSeq "$Rep/$NomSeq3d" set FiPdb "$RepForSeq/${NomSeq3d}.pdb" set FiMod "$RepForSeq/${NomSeq3d}_20.mod" set FiFa "$RepForSeq/${NomSeq3d}.fa" Lego FiPdb FiMod FiFa if {[file exists $FiMod]} { return $FiMod } FaireLire "I can't create the .mod file for \n$NomSeq3d $FiMsf3d" return "" } proc FichierMsfPourGOAnno {Nom AvecOuSansOrganismeEtudie} { set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml" set FichierSortie "[RepertoireDuGenome]/annotation/$Nom.msf.temp" set FichierSortie2 "[RepertoireDuGenome]/annotation/$Nom.msf" exec clustalw -infile=$Fichier -output=gcg -convert -outfile=$FichierSortie if {! [file exists $Fichier]} {return} if {$AvecOuSansOrganismeEtudie == "Sans"} { ExtractionDeMaSequenceDuMSF $Nom if {! [file exists $FichierSortie]} {return} file copy -force $FichierSortie $FichierSortie2 file delete -force $FichierSortie } else { if {! [file exists $FichierSortie]} {return} file copy -force $FichierSortie $FichierSortie2 file delete -force $FichierSortie } } proc FichierNbGOParBoite {FichierGO {FichierOrf2Cluster ""} {FichierEffectif ""}} { if {$FichierOrf2Cluster == ""} {set FichierOrf2Cluster "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression"} if {$FichierEffectif == ""} {set FichierEffectif "[RepertoireDuGenome]/fiches/NbGOParBoite"} if {![file exists $FichierGO]} {return} foreach Nom [ListeDesPABs] { Espionne $Nom set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom Cluster] set Access [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster $Nom Access ] foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [Onto $GO Type ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] if {![info exists Tab($Nom,$Type,n)]} { set Tab($Nom,$Type,n) 0 set Tab($Nom,$Type,LesDefs) {} } incr Tab($Nom,$Type,n) lappend Tab($Nom,$Type,LesDefs) $Def } foreach Type [InterrogeGeneOntology $FichierGO LesTypes] { set n 0 set Def "" if {[info exists Tab($Nom,$Type,n) ]} { set n [set Tab($Nom,$Type,n) ] set Def [join [set Tab($Nom,$Type,LesDefs)] ";"] } Espionne "$Nom\t$Cluster\t$Access\t$Type\t$n\t$Def" AppendAuFichier $FichierEffectif "$Nom\t$Cluster\t$Access\t$Type\t$n\t$Def" } } return } proc FichierNewOCADE_TL {FileIn FileOut} { if {$FileIn == $FileOut} {return} foreach Nom [LesNoms NomsInteressants] {set TabOK($Nom) 1} set i 0 set F [open $FileIn] set LesLignes {} while {[gets $F Ligne]>=0} { if {[regexp {^\#} $Ligne]} {lappend LesLignes $Ligne} set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Def [lindex $LaLigne 3] if {![info exists TabOK($Nom)]} {continue} incr i set Ext [format "%4.4d" $i] set NewNom "RA$Ext" set NewDef "$Nom $Def" set LaLigne [lreplace $LaLigne 0 0 $NewNom] set LaLigne [lreplace $LaLigne 3 3 $NewDef] Espionne $LaLigne lappend LesLignes [join $LaLigne "\t"] } close $F if {$LesLignes == {}} {return} Sauve [join $LesLignes "\n"] dans $FileOut return } proc FichierNomLocMethodeMeanDefGeneName_TL {{PABouNomsInteressantsouListeouFichier NomsInteressants}} { set FichierOUT "[RepertoireDuGenome]/PourTL/Nom_Clust_Loc_Methode_Access_Orga_Def_MeanDef_GeneName" set LesNoms [LesNoms $PABouNomsInteressantsouListeouFichier] set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set LeTexte {} foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster ] set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Access ] set DefIni [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Definition] ###GeneName######### set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName " ; "] ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] ###AccessDeProt#### set Def "" set Methode "Prot/mRNA" set Access [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {$Access == "NOPROTEIN" || $Access == ""} { set Methode "Contig" set Access [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$Access == "NOPROTEIN" || $Access == ""} { set Access "" set Methode "NoProtein" } } set Orgas "" if {$Access != ""} { set PI [PageInfo $Access protein "id acc des org"] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] " "] } set LesLoc {} foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } Espionne "$Nom\t$Cluster\t$AccIni\t$DefIni\t[join $LesLoc " ; "]\t$Methode\t$Access\t$Orgas\t$Def\t$MeanDef\t$GN" lappend LeTexte "$Nom\t$Cluster\t$AccIni\t$DefIni\t[join $LesLoc " ; "]\t$Methode\t$Access\t$Orgas\t$Def\t$MeanDef\t$GN" } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierNomLocTissueDSMethodeMeanDefGeneNameGO {FichierOUT} { set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" #Espionne "Lecture du Fichier $FichierOCADE" set LesAccess {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} #Espionne "Lecture du Fichier $FichierGO" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] ####EST########################## set LesTissues {} foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n] lappend LesTissues [list "$Tissue ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { incr i if {$i > 5} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDS {} foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DS n] lappend LesDS [list "$DS ($n)" $n] } set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDS] { incr i if {$i > 5} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] ";"] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] lappend LesAcc $AccessProche lappend LesDef $Def lappend LesOrgas $Orgas } set Acc [join $LesAcc ";"] set Def [join $LesDef ";"] set Orgas [join $LesOrgas ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i #if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## set LesGO {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] } set GO [join $LesGO ";"] ####LOCALISATION####################### set LesLoc {} if {1} { foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] } set Ligne "$Nom\t$Cluster\t$AccIni\t$DefIni\t$Loc\t$Tissues\t$DS\t$Methode\t$Acc\t$Orgas\t$Def\t$MeanDef\t$GN\t$GO" regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierNomLocTissueDSMethodeMeanDefGeneNameGO_Gretta {FichierBoitesSelectionnees FichierPValue FichierOUT} { set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" set NbCluster 6 set F [open $FichierPValue] while {[gets $F Ligne]>=0} { if {[string trim $Ligne] == ""} {continue} set LaLigne [split $Ligne "\t"] set Affy [lindex $LaLigne 0] set Cluster [lindex $LaLigne 1] set LesValues [lrange $LaLigne 2 6] set Tab($Affy,$Cluster,LesValues) $LesValues } close $F #Espionne "Lecture du Fichier $FichierBoitesSelectionnees" set F [open $FichierBoitesSelectionnees] set i 0 while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set Ligne [split $Ligne "\t"] set Affy [lindex $Ligne 0] set Cluster [lindex $Ligne 1] incr i set TabAffy($Cluster,$Affy) 1 } close $F set LesAccess {} #Espionne "Lecture du Fichier $FichierOCADE" foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] { set Affy [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] set LesExpressions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions] for {set i 0} {$i < $NbCluster} {incr i} { set Cluster [expr $i + 1] if {![info exists Tab(Cluster,$Cluster,LesNoms)]} { set Tab(Cluster,$Cluster,LesNoms) {} lappend Tab(LesClusters) $Cluster } set Expr [lindex $LesExpressions $i] if {$Expr < 0} {continue} if {![info exists TabAffy($Cluster,$Affy)]} {continue} set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode lappend Tab(Cluster,$Cluster,LesNoms) $Nom } } foreach Cluster [set Tab(LesClusters)] { if {![info exists Tab(Cluster,$Cluster,LesNoms)]} {continue} foreach Nom [set Tab(Cluster,$Cluster,LesNoms)] { if {[info exists TabTmp($Nom)]} {continue} set TabTmp($Nom) 1 set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} #Espionne "Lecture du Fichier $FichierGO" foreach Cluster [set Tab(LesClusters)] { if {![info exists Tab(Cluster,$Cluster,LesNoms)]} {continue} foreach Nom [set Tab(Cluster,$Cluster,LesNoms)] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] set LesValues [set Tab($AccIni,$Cluster,LesValues)] set PValue [join $LesValues "\t"] ####EST########################## set LesTissues {} foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n] lappend LesTissues [list "$Tissue ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { incr i if {$i > 5} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDS {} foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DS n] lappend LesDS [list "$DS ($n)" $n] } set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDS] { incr i if {$i > 5} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] ";"] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] lappend LesAcc $AccessProche lappend LesDef $Def lappend LesOrgas $Orgas } set Acc [join $LesAcc ";"] set Def [join $LesDef ";"] set Orgas [join $LesOrgas ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i #if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## set LesGO {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] } set GO [join $LesGO ";"] ####LOCALISATION####################### set LesLoc {} foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] set Ligne "$Nom\t$Cluster\t$AccIni\t$PValue\t$DefIni\t$Loc\t$Tissues\t$DS\t$Methode\t$Acc\t$Orgas\t$Def\t$MeanDef\t$GN\t$GO" regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierNomTousLocTissueDSMethodeMeanDefGeneNameGO {FichierOUT} { # proc de Frederic Chalmel acev modification pour compter TOUS des ESTs # (par tissues et developmental stages, l'original donne des 5 plus frequents) # modification par wr, 31/10/05 set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" #Espionne "Lecture du Fichier $FichierOCADE" set LesAccess {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} #Espionne "Lecture du Fichier $FichierGO" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] ####EST########################## set LesTissues {} foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n] lappend LesTissues [list "$Tissue ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { incr i ##orig de Fred donne des 5 plus frequents: ## if {$i > 5} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDS {} foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DS n] lappend LesDS [list "$DS ($n)" $n] } set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDS] { incr i ##orig de Fred donne des 5 plus frequents: ## if {$i > 5} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] ";"] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] lappend LesAcc $AccessProche lappend LesDef $Def lappend LesOrgas $Orgas } set Acc [join $LesAcc ";"] set Def [join $LesDef ";"] set Orgas [join $LesOrgas ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i #if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## set LesGO {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] } set GO [join $LesGO ";"] ####LOCALISATION####################### set LesLoc {} if {1} { foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] } set Ligne "$Nom\t$Cluster\t$AccIni\t$DefIni\t$Loc\t$Tissues\t$DS\t$Methode\t$Acc\t$Orgas\t$Def\t$MeanDef\t$GN\t$GO" regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierNomTousLocTissueDSMethodeMeanDefGeneNameSepGO {FichierOUT} { # proc de Frederic Chalmel acev modification pour compter TOUS des ESTs # (par tissues et developmental stages, l'original donne des 5 plus frequents) # modification par wr, 31/10/05 set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" #Espionne "Lecture du Fichier $FichierOCADE" set LesAccess {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } # close foreach Nom } # close foreach Cluster Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} #Espionne "Lecture du Fichier $FichierGO" foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] ####EST########################## set LesTissues {} foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n] lappend LesTissues [list "$Tissue ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { incr i ##orig de Fred donne des 5 plus frequents: ## if {$i > 5} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDS {} foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DS n] lappend LesDS [list "$DS ($n)" $n] } set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDS] { incr i ##orig de Fred donne des 5 plus frequents: ## if {$i > 5} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] ";"] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] lappend LesAcc $AccessProche lappend LesDef $Def lappend LesOrgas $Orgas } set Acc [join $LesAcc ";"] set Def [join $LesDef ";"] set Orgas [join $LesOrgas ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i #if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## Espionne "$Nom -> start GO section" # ... \t$Def\t$MeanDef\t$GN\t$GO -> $MeanDef\t$GN\t$GOfu\t$GOco\t$GOpr" set LesGO {} set GO {} set GOfu {} set GOco {} set GOpr {} # foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { # orig de Fred # lappend LesGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] # orig de Fred # } # orig de Fred # set GO [join $LesGO ";"] # orig de Fred # new code, wr 20/10/06 Espionne "$Nom -> GO, start new" set FileGOXML "[RepertoireDuGenome]/GeneOntology/$Nom.xml" set LesGOAvecLiens {} set LesTypes [AskGOAnalyse $FileGOXML Methode GPO LesTypes] if {$LesTypes != {}} { foreach Type $LesTypes { Espionne "check current type: $Type" foreach GO [AskGOAnalyse $FileGOXML Methode GPO Type $Type LesGO] { set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] #set TexteType [format "%-9s" $Type] set GoEtDef "$GO $Def" #regsub -all {\{} $GoEtDef "" GoEtDef #regsub -all {\}} $GoEtDef "" GoEtDef # above 2 lines should remove "{" and "}" if {[regexp "function" $Type]} {lappend GOfu "$GoEtDef"} if {[regexp "component" $Type]} {lappend GOco "$GoEtDef"} if {[regexp "process" $Type]} {lappend GOpr "$GoEtDef"} } } } ####LOCALISATION####################### set LesLoc {} if {1} { foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] } set Ligne "$Nom\t$Cluster\t$AccIni\t$DefIni\t$Loc\t$Tissues\t$DS\t$Methode\t$Acc\t$Orgas\t$Def\t$MeanDef\t$GN\t$GOfu\t$GOco\t$GOpr" regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } # close foreach Cluster from "Lecture du Fichier $FichierGO" Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierOMIMPourTous {{LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierOUT "[RepertoireDuGenome]/fiches/OMIM" set FichierLoc [ChoixDuFichierLocalisationHuman] set LeTexte {} foreach Nom $LesNoms { foreach LaLoc [InterrogeLocalisation $FichierLoc Nom $Nom] { if {![regexp -nocase "best" [lindex $LaLoc 20]]} {continue} set Chrom [lindex $LaLoc 9] set DS [Mini [lindex $LaLoc 10] [lindex $LaLoc 11]] set FS [Maxi [lindex $LaLoc 10] [lindex $LaLoc 11]] foreach LeOMIM [LesOMIMDeLaRegion $Chrom $DS $FS] { set LesGeneName [lindex $LeOMIM 5] set Qui [string trim [string toupper [lindex $LesGeneName 0]]] regsub -all -nocase {[^0-9a-z_]} $Qui "" Qui set Quoi "OMIM" if {[InterrogeRetNet RetNet $Qui LesInfos] != ""} {set Quoi "RetNet"} set LesBornes [lindex $LeOMIM 2] set DOMIM [lindex $LesBornes 0] set FOMIM [lindex $LesBornes 1] if {1000000 < [expr $FOMIM - $DOMIM]} {continue} set Def [join [concat [list [lindex $LeOMIM 9]] [lindex $LeOMIM 10]] ", "] Espionne "$Nom\t$Chrom\t$DS\t$FS\t$Quoi\t$Qui\t$Def\t$DOMIM\t$FOMIM" lappend LeTexte "$Nom\t$Chrom\t$DS\t$FS\t$Quoi\t$Qui\t$Def\t$DOMIM\t$FOMIM" } } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierOntologyDesAccess {FichierAccessouLesAccess FileSave} { if {[file exists $FichierAccess]} { set LesAccess [LesLignesDuFichier $FichierAccess] } else { set LesAccess $FichierAccessouLesAccess } set LesOntologies {} foreach Ligne $LesAccess { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} scan $Ligne "%s" Access Espionne "$Access" set NewLine "" set LesGO [Access2GO $Access] if {$LesGO == {}} { set NewLine "$Access\tNoOntologyFound\tNoOntologyFound\tNoOntologyFound" lappend LesOntologies $NewLine Espionne $NewLine } else { foreach Type [LesTypesOntologiques] { foreach GO $LesGO { if {![OntoExists $Type $GO LesDefinitions]} {continue} foreach Definition [Onto $Type $GO LesDefinitions] { set NewLine "$Access\t$Type\t$GO\t$Definition" lappend LesOntologies $NewLine Espionne $NewLine } } } } } Sauve [join $LesOntologies "\n"] dans $FileSave return $LesOntologies } proc FichierOperons2ClustersNourrisParDesOperonsCommuns {} { global RepertoireDuGenome set LesInfos {} Wup "Operon Distance between cluster1 and cluster2 Considered operon Cluster1 Orf belonging to the considered operon and to cluster1 Cluster2 Orf belonging to the considered operon and to cluster2" set LesOperons [O2C2O LesOperons] foreach Operon $LesOperons { set LesClusters [O2C2O Operon $Operon LesClusters] foreach Cluster1 $LesClusters { foreach Cluster2 $LesClusters { if {$Cluster1 == $Cluster2} {continue} set Distance [format "%.1f" [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance]] set LesOrfs1 [O2C2O Cluster $Cluster1 LesOrfs] foreach Orf1 $LesOrfs1 { set Operon1 [O2C2O Orf $Orf1 Operon] if {$Operon1 == ""} {continue} set LesOrfs2 [O2C2O Cluster $Cluster2 LesOrfs] foreach Orf2 $LesOrfs2 { set Operon2 [O2C2O Orf $Orf2 Operon] if {$Operon2 == "" || $Operon1 != $Operon2} {continue} if {[info exists TabTmp(Operon,$Operon,Cl1,$Cluster1,Orf1,$Orf1,Cl2,$Cluster2,Orf2,$Orf2)]} {continue} set TabTmp(Operon,$Operon,Cl1,$Cluster1,Orf1,$Orf1,Cl2,$Cluster2,Orf2,$Orf2) 1 if {[info exists TabTmp(Operon,$Operon,Cl1,$Cluster2,Orf1,$Orf2,Cl2,$Cluster1,Orf2,$Orf1)]} {continue} set TabTmp(Operon,$Operon,Cl1,$Cluster2,Orf1,$Orf2,Cl2,$Cluster1,Orf2,$Orf1) 1 Espionne [set Info [list $Operon $Distance $Operon1 $Cluster1 $Orf1 $Cluster2 $Orf2]] lappend LesInfos $Info } } } } } set LeTexte {} foreach LInfo [lsort -integer -index 0 $LesInfos] { lappend LeTexte [join $LInfo "\t"] } set Fichier "$RepertoireDuGenome/fiches/clusters_nourris_par_operons_communs" Sauve [join $LeTexte "\n"] dans $Fichier return $Fichier } proc FichierOperons2DistancesEntreClustersPondereesParPresences {} { global RepertoireDuGenome set LesInfos {} set LesOrganismes [O2C2O LesOrganismesLongs] set LesDiabacs [O2C2O Categorie OrganismeInteressant LesOrganismesLongs] set LesBacteries [O2C2O Categorie Bacteria LesOrganismesLongs] set LesFirmicutes [O2C2O Categorie Firmicutes LesOrganismesLongs] set LesProteobacteries [O2C2O Categorie Proteobacteria LesOrganismesLongs] set LesArchaebacteries [O2C2O Categorie Archaea LesOrganismesLongs] set LesEucaryotes [O2C2O Categorie Eukaryota LesOrganismesLongs] Espionne "LesOrganismes : $LesOrganismes \n" Espionne "LesDiabacs : $LesDiabacs \n" Espionne "LesBacteries : $LesBacteries \n" Espionne "LesFirmicutes : $LesFirmicutes \n" Espionne "LesProteobacteries : $LesProteobacteries \n" Espionne "LesArchaebacteries : $LesArchaebacteries \n" Espionne "LesEucaryotes : $LesEucaryotes \n" Wup "Operon Distance between cluster1 and cluster2 Cluster1 Cluster2 Distance between the clusters balanced according to the presence of the total organisms Distance between the clusters balanced according to the presence of the Diabacs Distance between the clusters balanced according to the presence of the Bacteria Distance between the clusters balanced according to the presence of the Firmicutes Distance between the clusters balanced according to the presence of the Proteobacteria Distance between the clusters balanced according to the presence of the Archaebacteria Distance between the clusters balanced according to the presence of the Eukaryota Orf belonging to the considered operon and to the cluster1 Orf belonging to the considered operon and to the cluster2" set LesOperons [O2C2O LesOperons] foreach Operon $LesOperons { set LesClusters [O2C2O Operon $Operon LesClusters] foreach Cl $LesClusters { #Bact pour Bacteries, Firm pour Firmicutes, Proteo pour Proteobacteries # Archae pour Archaebacteries, Eu pour Eucaryotes set TabP($Cl,Orgas) [O2C2O Cluster $Cl Categorie AllOrganism Presence] set TabP($Cl,Diabacs) [O2C2O Cluster $Cl Categorie OrganismeInteressant Presence] set TabP($Cl,Bact) [O2C2O Cluster $Cl Categorie Bacteria Presence] set TabP($Cl,Firm) [O2C2O Cluster $Cl Categorie Firmicutes Presence] set TabP($Cl,Proteo) [O2C2O Cluster $Cl Categorie Proteobacteria Presence] set TabP($Cl,Archae) [O2C2O Cluster $Cl Categorie Archaea Presence] set TabP($Cl,Eu) [O2C2O Cluster $Cl Categorie Eukaryota Presence] } foreach Cl1 $LesClusters { set LesOrfsEnCommunCl1 [O2C2O Operon $Operon Cluster $Cl1 LesOrfsEnCommun] set Orf1 [lindex $LesOrfsEnCommunCl1 0] foreach Cl2 $LesClusters { if {$Cl1 == $Cl2} {continue} set Dist [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 Distance] set LesOrfsEnCommunCl2 [O2C2O Operon $Operon Cluster $Cl2 LesOrfsEnCommun] set Orf2 [lindex $LesOrfsEnCommunCl2 0] #DPD signifie Distance Ponderee Par Presences set DPP_Orgas [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Diabacs [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Bact [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Firm [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Proteo [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Archae [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set DPP_Eu [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 DistancePondereeParPresences]] set Dist [format "%.1f" [O2C2O Cluster1 $Cl1 Cluster2 $Cl2 Distance]] Espionne [set Info [list $Operon $Dist $Cl1 $Cl2 $DPP_Orgas $DPP_Diabacs $DPP_Bact $DPP_Firm $DPP_Proteo $DPP_Archae $DPP_Eu $Orf1 $Orf2]] lappend LesInfos $Info } } } set LeTexte {} foreach LInfo [lsort -integer -index 0 $LesInfos] { lappend LeTexte [join $LInfo "\t"] } set Fichier "$RepertoireDuGenome/fiches/operons2distances_ponderees_par_presences" Sauve [join $LeTexte "\n"] dans $Fichier return $Fichier } proc FichierOrf2Cluster2Access2Def2Expression {} { set FichierSave "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set Entete "#Nom \tCluster \tAccess \tDefinition" AppendAuFichier $FichierSave $Entete set LesQuery [lsort -increasing [ListeDesPABs]] LesAccessEtDefDesActins TabActin "[RepertoireDuGenome]/DeLBMAGM/TousLesGenes.txt" set Cluster none foreach PAB $LesQuery { set Corps "" set Access [OwnerOfCDNA $PAB] if {[info exists TabActin($Access)]} { set Definition [set TabActin($Access)] } else {set Definition "No Definition"} lappend Corps $PAB lappend Corps $Cluster lappend Corps $Access lappend Corps $Definition set Corps [join $Corps "\t"] AppendAuFichier $FichierSave $Corps } return "" } proc FichierOrf2Cluster2Operon {} { global RepertoireDuGenome set FileOrf2Cluster2Operon "$RepertoireDuGenome/fiches/orf2cluster2operon" set FileCluster2Orf2Operon "$RepertoireDuGenome/fiches/cluster2orf2operon" set LInfoGlobale {} set LInfoGlobaleBis {} foreach Orf [ListeDesPABs] { set Cluster [InfoDuCluster $Orf Numero] if {$Cluster == "" || [regexp -nocase "No info available for " $Cluster]} { set Cluster "Not in Cluster" set TailleCluster "Not in Cluster" } else { set TailleCluster [InfoDuCluster $Orf Taille] } set Operon [Operon $Orf Numero] if {$Operon == ""} { set Operon "Not in Operon" set TailleOperon "Not in Operon" } else { set TailleOperon [Operon $Orf Taille] } set Definition [DefinitionApproximative $Orf] regsub -nocase "\\\(taken from database\\\)" $Definition "" Definition set Definition [string trim $Definition] Espionne "$Orf\t$Cluster\t$TailleCluster\t$Operon\t$TailleOperon\t$Definition" lappend LInfoGlobale "$Orf\t$Cluster\t$TailleCluster\t$Operon\t$TailleOperon\t$Definition" lappend LInfoGlobaleBis "$Cluster\t$TailleCluster\t$Orf\t$Operon\t$TailleOperon\t$Definition" } #Sauve [join $LInfoGlobale "\n"] dans $FileOrf2Cluster2Operon set LInfoGlobaleBis [lsort -index 0 $LInfoGlobaleBis] Espionne $LInfoGlobaleBis Sauve [join $LInfoGlobaleBis "\n"] dans $FileCluster2Orf2Operon return $LInfoGlobaleBis } proc FichierOrgImportantsDesEukaryotes {} { global RepertoireDuGenome set File "$RepertoireDuGenome/fiches/orgimportant" set FileGenomesEukaryotes "$RepertoireDuGenome/fiches/lesgenomeseukaryotes" set Texte "" set LesOrganismes {} if {[OuiOuNon "Would you want to add all eukaryotic organism having a complete genome ?"]} { if {![file exists $FileGenomesEukaryotes] && [OuiOuNon "Would you want to create the file with the eukaryotic organism having a complete genome ?"]} { FichierGenomesEukaryotes } if {[file exists $FileGenomesEukaryotes]} { foreach Orga [LesGenomesEukaryotes] {lappend LesOrganismes $Orga } } } if {[OuiOuNon "Would you want to add your favorite organisms ?"]} { foreach Orga [LaSelectionDeNoe] { lappend LesOrganismes $Orga } } while {[OuiOuNon "Would you want to add an other organism to that list ?"]} { set Orga [Entre] set BonOrg [Glossaire $Orga Complet] if {$BonOrg==""} { if {![OuiOuNon "The organism $Orga doesn't exist\nDo you want to select it?"]} { continue } } elseif {$BonOrg!=$Orga} { if {[OuiOuNon "Your organism $Orga \n seems to be \n $BonOrg \n Do I keep $BonOrg ?"]} { set Orga $BonOrg } else { if {![OuiOuNon "Do I keep $Orga ?"]} { continue } } } if {$Orga != "" } {lappend LesOrganismes $Orga} } if {$LesOrganismes == {}} {return ""} Sauve [join [ElimineLesRedondancesDansUneListe $LesOrganismes] "\n"] dans $File return $File } proc FichierPathway {Pathway {OrganismeOuOrgaCourt ""} {Extension conf}} { if {$OrganismeOuOrgaCourt != ""} { set OrgaC [InterrogeGenomeKEGG Organisme $OrganismeOuOrgaCourt OrgaCourt] if {$OrgaC == ""} {set OrgaC $OrganismeOuOrgaCourt} } else { set OrgaC "map" } set File "[KEGGDir $OrgaC]/${OrgaC}${Pathway}.${Extension}" if {[file exists $File]} {return $File} set File "[KEGGDir $OrgaC]/${OrgaC}${Pathway}hsa.${Extension}" if {[file exists $File]} {return $File} foreach File [glob -nocomplain "[KEGGDir $OrgaC]/${OrgaC}${Pathway}*.${Extension}"] { return $File } return "[KEGGDir $OrgaC]/${OrgaC}${Pathway}.${Extension}" } proc FichierPolyLocalise {FichierLocalisation} { global RepertoireDuGenome global FichierPolyLocaliseDefaut if {![file exists $FichierLocalisation]} {return ""} foreach Ligne [LesLignesDuFichier $FichierLocalisation] { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} set LaLigne [split $Ligne "\t"] set Info [lindex $LaLigne end] if {$Info == "BestLoc" || $Info == "BestPolyLoc"} { set Nom [lindex $LaLigne 0] set InfoLoc [lindex $LaLigne 1] if {[info exists TabLoc($Nom)]} {continue} if {$InfoLoc == "MonoLoc"} { set NewInfo "MonoLocalization" } elseif {$InfoLoc == "MayBePolyLoc"} { set NewInfo "MayBePolyLocalization" } elseif {$InfoLoc == "PolyLoc"} { set NewInfo "PolyLocalization" } elseif {$InfoLoc == "NoLoc"} { set NewInfo "NoLocalization" } else { set NewInfo "NoBlastFile" } set TabLoc($Nom) $NewInfo } } set LeNewPolyLocalise "" foreach Nom [ListeDesPABs] { if {![info exists TabLoc($Nom)]} {set NewInfo "NoLocalization"} else {set NewInfo [set TabLoc($Nom)]} lappend LeNewPolyLocalise "$Nom $NewInfo" } EspionneL $LeNewPolyLocalise set FichierPolyLocaliseDefaut "$RepertoireDuGenome/fiches/polylocalise" Sauve [join $LeNewPolyLocalise "\n"] dans $FichierPolyLocaliseDefaut return "" } proc FichierPourDPC_bbkkvv {FichierPourDPC {FichierTableau ""}} { if {$FichierTableau == ""} { FaireLire "Choisir le fichier contenant le tableau" set FichierTableau [ButineArborescence All [pwd]] } set Texte "" set nBox 0 set i 0 set F [open $FichierTableau] while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} incr i if {$i == 1} {continue} set LaLigne [split $Ligne "\t"] set Info [lindex $LaLigne 3 ] if {$Info == "Not found" || $Info == "Not DNA"} {continue} incr nBox set Nom [lindex $LaLigne 4 ] set AvWT [lindex $LaLigne 10] set AvRD [lindex $LaLigne 15] set PR [lindex $LaLigne 17] set Brain [lindex $LaLigne 19] append Texte "$Nom\t$AvRD\t$AvWT\t$PR\t$Brain\n" } close $F set Texte "$nBox\t4\n$Texte" Sauve $Texte dans $FichierPourDPC return $Texte } proc FichierPourSaveAs {{RepertoireEtFichier ""}} { global RepertoireInitial if {[info exists OuiOuNonToujoursParDefaut] && $OuiOuNonToujoursParDefaut} { if { $RepertoireEtFichier!="" && ! [file isdirectory $RepertoireEtFichier]} { return $RepertoireEtFichier } } if {$RepertoireEtFichier==""} { set RepertoireEtFichier "unnamed" } if {[regexp {/$} $RepertoireEtFichier]} { regsub {/$} $RepertoireEtFichier "" Rep set Fic "" } else { set Rep [file dirname $RepertoireEtFichier] set Fic [file tail $RepertoireEtFichier] } if {$Rep!=""} { set RepertoireInitial $Rep } if {$Fic!=""} { set FichierInitial "$Fic" } if { ! [info exists RepertoireInitial]} { set RepertoireInitial [pwd] } if { ! [info exists FichierInitial]} { set FichierInitial "unnamed"} set Fichier [tk_getSaveFile -title "File to create" -initialfile $FichierInitial -initialdir $RepertoireInitial] if { $Fichier == "" } { return ""} set RepertoireInitial [file dirname $Fichier] return $Fichier } proc FichierPourWolfgang {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set LaLigne {} set AccessmRNA [AccessEvi $Nom] set LesProbeSetId {} foreach ProbeSetId [lsort -unique [AffyAnno $AccessmRNA "Probe_Set_ID"]] { lappend LesProbeSetId $ProbeSetId } if {$LesProbeSetId=={}} { continue } else { set PSI [join $LesProbeSetId ","] lappend LaLigne $Nom lappend LaLigne $PSI } set Ligne [join $LaLigne ";"] Espionne $Ligne lappend LesLignes $Ligne } #return $LesLignes } proc FichierPpcrSansAttBAdapter {Fichier} { set Entete [EnteteDuFichierTFA $Fichier "all"] if { ! [regexp {AttB[12]_?Adapter} $Entete]} { return $Fichier } set Seq [QueLaSequenceDuFichierTFA $Fichier] if { ! [regexp -nocase [SEQAttB1Adapter] $Seq] && ! [regexp -nocase [SEQAttB2Adapter] $Seq]} { return $Fichier } if { ! [regexp [SEQAttB1] $Seq]} { regsub -nocase [SEQAttB1Adapter] $Seq [SEQAttB1] Seq } if { ! [regexp [SEQAttB2] $Seq]} { regsub -nocase [SEQAttB2Adapter] $Seq [SEQAttB2] Seq } regsub -nocase {AttB1_?Adapter} $Entete "AttB1" Entete regsub -nocase {AttB2_?Adapter} $Entete "AttB2" Entete return [Sauve [SequenceFormatTFA $Seq $Entete "nucbrut"] dans "[TmpFile].tfa"] } proc FichierPresenceDesOrganismesDansTousLesClusters {} { global RepertoireDuGenome set Fichier "$RepertoireDuGenome/fiches/presences_tous_clusters" set LesCategories [O2C2O LesCategories] set Info ">Cluster" foreach Categorie $LesCategories {append Info "\t$Categorie"} set LesInfos [list $Info] foreach Cluster [O2C2O LesClusters] { Espionne $Cluster set LInfo [list $Cluster] foreach Categorie $LesCategories { set LesOrgas [O2C2O Categorie $Categorie LesOrganismesLongs] lappend LInfo [PresenceDesOrganismesDansCluster $Cluster $LesOrgas] } Espionne $LInfo lappend LesInfos [join $LInfo "\t"] } EspionneL $LesInfos Sauve [join $LesInfos "\n"] dans $Fichier return $Fichier } proc FichierProtAndmRNA {Nom {IdMin 0.8} {IdMax 0.95} {ExpectMax 0.001} {NbSubject 500}} { set RepOut "[RepertoireDuGenome]/ProtAndmRNA" if {![file exists $RepOut]} {File mkdir $RepOut} set FileOut "$RepOut/$Nom" set FBmRNA "[RepertoireDuGenome]/blastnmrna/$Nom" if {![file exists $FBmRNA]} { Espionne "$Nom -> $FBmRNA does not exist.\nPlease create it with \'BlastNmRNAPourTous\'." return } set FBProt "[RepertoireDuGenome]/blastx/$Nom" if {![file exists $FBProt]} { Espionne "$Nom -> $FBProt does not exist. Please create it." return } set OrgaDeRef [OrganismeDuPAB $Nom] Espionne "$Nom -> Prot. extraction" DepouilleLeBlast TabBlastX $FBProt $ExpectMax $NbSubject set LesProteinesBrutes [LesProteinesDuBlast_TabBlast TabBlastX] Espionne "$Nom -> mRNA extraction" DepouilleLeBlast TabBlastN $FBmRNA $ExpectMax $NbSubject set LesmRNAsBruts [LesmRNAsDuBlast_TabBlast TabBlastN] set LesmRNAs {} set LesProteines {} set LesCandidatsTmp {} ###Elimine les mRNAs et les proteines identiques############################################# ###Elimine les mRNAs codant pour les memes proteines et ceux references par la meme proteine### foreach LemRNA $LesmRNAsBruts { set Access [lindex $LemRNA 1 ] set Orga [lindex $LemRNA 12] if {[info exists TabTmp($Orga,$Access)]} {continue} set TabTmp($Orga,$Access) 1 set LesProtsDumRNA [lindex $LemRNA 14] set LesProteinesEquivalentes $LesProtsDumRNA set LesmRNAsEquivalents $Access foreach UnAutremRNA $LesmRNAsBruts { set Orga2 [lindex $UnAutremRNA 12 ] set Access2 [lindex $UnAutremRNA 1 ] if {![string equal -nocase $Orga $Orga2] || [string equal -nocase $Access $Access2]} {continue} set AiJeUneProtEnCommun 0 foreach Prot2 [lindex $UnAutremRNA 14] { foreach Prot $LesProtsDumRNA {if {$Prot == $Prot2} {set AiJeUneProtEnCommun 1;break}} if {$AiJeUneProtEnCommun} {break} } if {!$AiJeUneProtEnCommun} {continue} lappend LesmRNAsEquivalents $Access2 set TabTmp($Orga,$Access2) 1 foreach Prot2 [lindex $UnAutremRNA 14] {lappend LesProteinesEquivalentes $Prot2} } foreach UneProteine $LesProteinesBrutes { set Orga2 [lindex $UneProteine 12] if {$Orga2 != $Orga} {continue} set Access2 [lindex $UneProteine 1 ] set SuisJeUnDeSesmRNAs 0 foreach mRNA2 [lindex $UneProteine 14] {if {$mRNA2 == $Access} {set SuisJeUnDeSesmRNAs 1;break}} if {!$SuisJeUnDeSesmRNAs} {continue} lappend LesProteinesEquivalentes $Access2 foreach mRNA2 [lindex $UneProteine 14] { lappend LesmRNAsEquivalents $mRNA2 set TabTmp($Orga,$mRNA2) 1 } } set LemRNA [lreplace $LemRNA 14 14 [ElimineLesRedondancesDansUneListe $LesProteinesEquivalentes]] set LemRNA [lreplace $LemRNA 1 1 [ElimineLesRedondancesDansUneListe $LesmRNAsEquivalents ]] lappend LesmRNAs $LemRNA lappend LesCandidatsTmp $LemRNA } ###Elimine les Proteines codees par les memes mRNAs et celles referencees par le meme mRNA### foreach LaProt $LesProteinesBrutes { set Access [lindex $LaProt 1 ] set Orga [lindex $LaProt 12 ] if {[info exists TabTmp($Orga,$Access)]} {continue} set TabTmp($Orga,$Access) 1 set LesmRNAsDeLaProt [lindex $LaProt 14] set LesmRNAsEquivalents $LesmRNAsDeLaProt set LesProteinesEquivalentes $Access foreach UneAutreProt $LesProteinesBrutes { set Orga2 [lindex $UneAutreProt 12] set Access2 [lindex $UneAutreProt 1 ] if {$Orga != $Orga2 || $Access == $Access2} {continue} set AiJeUnmRNAEnCommun 0 foreach mRNA2 [lindex $UneAutreProt 14] { foreach mRNA $LesmRNAsDeLaProt {if {$mRNA == $mRNA2} {set AiJeUnmRNAEnCommun 1;break}} if {$AiJeUnmRNAEnCommun} {break} } if {!$AiJeUnmRNAEnCommun} {continue} lappend LesProteinesEquivalentes $Access2 set TabTmp($Orga,$Access2) 1 foreach mRNA2 [lindex $UneAutreProt 14] {lappend LesmRNAsEquivalents $mRNA2} } foreach UnmRNA $LesmRNAsBruts { set Orga2 [lindex $UnmRNA 12] if {$Orga2 != $Orga} {continue} set Access2 [lindex $UnmRNA 1 ] set SuisJeUneDeSesProteines 0 foreach Prot2 [lindex $UnmRNA 14] {if {$Prot2 == $Access} {set SuisJeUneDeSesProteines 1;break}} if {!$SuisJeUneDeSesProteines} {continue} lappend LesmRNAsEquivalents $Access2 foreach Prot2 [lindex $UnmRNA 14] { lappend LesProteinesEquivalentes $Prot2 set TabTmp($Orga,$Prot2) 1 } } set LaProt [lreplace $LaProt 14 14 [ElimineLesRedondancesDansUneListe $LesmRNAsEquivalents ]] set LaProt [lreplace $LaProt 1 1 [ElimineLesRedondancesDansUneListe $LesProteinesEquivalentes]] lappend LesProteines $LaProt lappend LesCandidatsTmp $LaProt } ###################################################################################################### #########Elimination des proteines ou des mRNAs homologues ######################### set LesCandidatsTmp [lsort -integer -decreasing -index 10 $LesCandidatsTmp] set LesCandidatsTmp [lsort -real -decreasing -index 7 $LesCandidatsTmp] set LesCandidatsTmp [lsort -integer -decreasing -index 8 $LesCandidatsTmp] if {[info exists TabTmp]} {unset TabTmp} set LesCandidats {} foreach LeCandidat $LesCandidatsTmp { set Orga [lindex $LeCandidat 12] set LesAccess [lindex $LeCandidat 1] set EnAiJeDejaVuUn 0 foreach Access $LesAccess { if {![info exists TabTmp($Orga,$Access)]} {set TabTmp($Orga,$Access) 1;continue} set EnAiJeDejaVuUn 1;break } if {$EnAiJeDejaVuUn} {continue} set EnAiJeDejaVuUn 0 foreach Ref [lindex $LeCandidat 14] { if {![info exists TabTmp($Orga,$Ref)]} {set TabTmp($Orga,$Ref) 1;continue} set EnAiJeDejaVuUn 1;break } if {$EnAiJeDejaVuUn} {continue} lappend LesCandidats $LeCandidat } ############################################################################### #######PRESENTATION DU FICHIER################################################# set LeTexte "" set Taille 0 if {[info exists TabBlastX(Taille)]} { set Taille [set TabBlastX(Taille)] } elseif {[info exists TabBlastN(Taille)]} { set Taille [set TabBlastN(Taille)] } lappend LeTexte "Box: $Nom" lappend LeTexte "LengthBox: $Taille" PourcentagesDeMasking Repeat $Nom if {[info exists Repeat(Masking)] } { lappend LeTexte "Masking: [set Repeat(Masking)]"} if {[info exists Repeat(ReMasking)]} { lappend LeTexte "ReMasking: [set Repeat(ReMasking)]" } if {[info exists Repeat(MRM)] } { lappend LeTexte "MRM: [set Repeat(MRM)]" } set i 0 foreach LeCandidat $LesCandidats { incr i set BId [lindex $LeCandidat 0 ] set LesAccess [lindex $LeCandidat 1 ] set Taille [lindex $LeCandidat 2 ] set TailleCDS [lindex $LeCandidat 3 ] set Sens [lindex $LeCandidat 4 ] set Expect [lindex $LeCandidat 5 ] set Score [lindex $LeCandidat 6 ] set Id [lindex $LeCandidat 7 ] set Nb [lindex $LeCandidat 8 ] set NbIn5UTR [lindex $LeCandidat 9 ] set NbInCDS [lindex $LeCandidat 10 ] set NbIn3UTR [lindex $LeCandidat 11 ] set Orga [lindex $LeCandidat 12 ] set Def [lindex $LeCandidat 13 ] set LesRefs [lindex $LeCandidat 14 ] set QuiSuisJe [lindex $LeCandidat end] set EstCeNotreOrga 0 set EstCeUnParalogue 0 set SuisJeDansLeCDS 0 set LesRefsAbsentes {} set LesAccessAbsents {} if {$Orga == $OrgaDeRef} {set EstCeNotreOrga 1 } if {$EstCeNotreOrga } {set IdDeRef $IdMax} else {set IdDeRef $IdMin} if {$Id < $IdDeRef } {set EstCeUnParalogue 1 } if {$NbInCDS != 0 } {set SuisJeDansLeCDS 1 } if {$QuiSuisJe == "PROTEIN"} { set AutreType "mRNA" ;set LesAutres $LesmRNAsBruts ;set LesMemes $LesProteinesBrutes } else { set AutreType "PROTEIN";set LesAutres $LesProteinesBrutes;set LesMemes $LesmRNAsBruts } foreach Ref $LesRefs { set LAiJeVu 0 foreach UnAutre $LesAutres { if {$Orga != [lindex $UnAutre 12]} {continue} if {$Ref == [lindex $UnAutre 1 ]} {set LAiJeVu 1;break} } if {!$LAiJeVu} {lappend LesRefsAbsentes $Ref } } foreach Jumeau $LesAccess { set LAiJeVu 0 foreach UnMeme $LesMemes { if {$Orga != [lindex $UnMeme 12]} {continue} if {$Jumeau == [lindex $UnMeme 1 ]} {set LAiJeVu 1;break} } if {!$LAiJeVu} {lappend LesAccessAbsents $Jumeau} } lappend LeTexte "" lappend LeTexte "Rank: $i" lappend LeTexte "Type: $QuiSuisJe" lappend LeTexte "BanqueId_Access: $BId [lindex $LesAccess 0]" if {1 < [llength $LesAccess]} { lappend LeTexte "EquivalentAccess: [join [lrange $LesAccess 1 end] " "]" } if {$LesAccessAbsents != {}} { lappend LeTexte "AbsentAccess: [join $LesAccessAbsents " "]" } lappend LeTexte "Definition: $Def" lappend LeTexte "Organism: $Orga" lappend LeTexte "Length: $Taille" if {$LesRefs != {}} { lappend LeTexte "[format "%-20s" "$AutreType:"] [join $LesRefs " "]" } if {$SuisJeDansLeCDS && $LesRefsAbsentes != {}} { lappend LeTexte "[format "%-20s" "Absent$AutreType:"] [join $LesRefsAbsentes " "]" } if {$QuiSuisJe == "PROTEIN"} { lappend LeTexte "NTot: $Nb" } else { lappend LeTexte "NTot_5UTR_CDS_3UTR: [format "%-6s%-6s%-5s%-6s" $Nb $NbIn5UTR $NbInCDS $NbIn3UTR]" } lappend LeTexte "Expect_Score_Id: [format "%-8s%-8.1f%.2f" $Expect $Score $Id]" if {$EstCeUnParalogue} { lappend LeTexte "WARNING: MayBeAParalogue ([expr round($Id*100)]%)" } } Sauve [join $LeTexte "\n"] dans $FileOut return $LeTexte } proc FichierProtAndmRNAPourTous {{LesNoms ""} {IdMin 0.8} {IdMax 0.95} {ExpectMax 0.001} {NbSubject 500}} { set RepOut "[RepertoireDuGenome]/ProtAndmRNA" if {![file exists $RepOut]} {File mkdir $RepOut} set Keep 0 if {0 < [llength [glob -nocomplain "$RepOut/*"]]} { if {[OuiOuNon "Some Files exist in $RepOut\nDo you want to keep these files?"]} {set Keep 1} } if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne "$Nom..." if {$Keep && [file exists "$RepOut/$Nom"]} {continue} FichierProtAndmRNA $Nom $IdMin $IdMax $ExpectMax $NbSubject } FichierTFADesProteinesChoisiesPourTous $LesNoms 1 return } proc FichierProteinesHypothetical {} { set LesInfos {} set LesOrfsHypothetical {} set i 0 foreach Orf [O2C2O LesOrfs] { if {[regexp -nocase "hypothetical" [O2C2O Orf $Orf Definition]]} { incr i lappend LesOrfsHypothetical $Orf } } Sauve [join [lsort -unique $LesOrfsHypothetical] "\n"] dans "[RepertoireDuGenome]/fiches/hypothetical_proteins" return $LesOrfsHypothetical } proc FichierProteinesJumelles {{IdDesProtId 0.98} {LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierOUT "[RepertoireDuGenome]/fiches/ProteinesJumelles" if {[OuiOuNon "Two proteins are considered equal if the identity between them is [expr $IdDesProtId*100] %\nWould you want to change this threshold?"]} { set IdDesProtId [Entre $IdDesProtId] } set LesNoms [lsort -unique $LesNoms] foreach Nom $LesNoms { if { ! [regexp -nocase {[a-z]} $Nom]} { continue } set Tab($Nom,LesAccess) {} Espionne $Nom set FileMSF "[RepertoireDuGenome]/msf/$Nom" if {![file exists $FileMSF]} {continue} AskMSF unset if {[AskMSF $FileMSF $Nom] != ""} { set Query $Nom } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" } else { continue } foreach Access [LesProteinesIdentiquesDuMSF $FileMSF $Query $IdDesProtId] { if {$Access == $Query} {continue} set Access [string toupper $Access] if {![info exists Tab($Access,LesNoms)]} {set Tab($Access,LesNoms) {}} lappend Tab($Nom,LesAccess) $Access set Tab($Nom,$Access) 1 lappend Tab($Access,LesNoms) $Nom } AskMSF unset } set LeTexte {} foreach Nom $LesNoms { if { ! [regexp -nocase {[a-z]} $Nom]} { continue } if {[info exists DejaVu($Nom)]} {continue} set LesAccess [set Tab($Nom,LesAccess)] if {$LesAccess == {}} {continue} set LesJumeaux [list $Nom] ##Je regarde les boites ayant vu ces proteines foreach Access $LesAccess { foreach NomJum [set Tab($Access,LesNoms)] { lappend LesJumeaux $NomJum set DejaVu($NomJum) 1 foreach Access [set Tab($NomJum,LesAccess)] { foreach NomJum2 [set Tab($Access,LesNoms)] { lappend LesJumeaux $NomJum2 set DejaVu($NomJum2) 1 } } } } set Ligne [join [lsort -unique $LesJumeaux] "\t"] lappend LeTexte $Ligne Espionne $Ligne } return [Sauve [join $LeTexte "\n"] dans $FichierOUT] } proc FichierProttfaLocalisation {{LesNoms ""} {NameFile ProttfaLocalisation_Human}} { if {![file exists "[RepertoireDuGenome]/Localisation"]} {file mkdir "[RepertoireDuGenome]/Localisation"} set FileLoc "[RepertoireDuGenome]/Localisation/$NameFile" if {[file exists $FileLoc]} { if {[OuiOuNon "$FileLoc exists. Would you want to keep this file ?"]} {return} File delete -force $FileLoc } set TailleFragment 100000 set LeTexte {} if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { set FileEM "[RepertoireDuGenome]/prottfa_exonicmap/$Nom" if {![file exists $FileEM]} {continue} set LesRangs [InterrogeFichierExonicMap $FileEM LesRangs] set BestLoc "BestLoc" set InfoLoc "MonoLoc" if {1 < [llength $LesRangs]} {set InfoLoc "PolyLoc";set BestLoc "BestPolyLoc"} foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FileEM Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FileEM Rang $Rang Contig ] set LesContigsFrag [InterrogeFichierExonicMap $FileEM Rang $Rang ContigFragments] set nChiffresFragContig [string length [lindex $LesContigsFrag 0]] set NbExonicAreas [InterrogeFichierExonicMap $FileEM Rang $Rang NbExonicAreas] if {$NbExonicAreas <= 0} {continue} set LesRegions {} for {set i 1} {$i <= $NbExonicAreas} {incr i} { set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i nAli ] set Id [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i Identity] lappend LesRegions [list $i $nAli $Id] } set LesRegions [lsort -index 1 -real -decreasing [lsort -index 2 -real -decreasing $LesRegions]] set nAliMax [lindex [lindex $LesRegions 0] 1] set EstCeLePremier 1 foreach LaRegion $LesRegions { set Info "" if {$EstCeLePremier} {set Info $BestLoc;set EstCeLePremier 0} set ExonArea [lindex $LaRegion 0] set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea nAli ] set Id [expr [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Identity]/100] set DQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DQ ] set FQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FQ ] set DS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DS ] set FS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FS ] set Orient [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Orientation] set Sens [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Sens ] set Fragments "" if {0 < $nChiffresFragContig} { set FragmentMin [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Mini $DS $FS] / $TailleFragment)]] set FragmentMax [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Maxi $DS $FS] / $TailleFragment)]] set Fragments $FragmentMin if {$FragmentMin != $FragmentMax} {set Fragments [string trim "$FragmentMin $FragmentMax"]} } set LaLocSurLeChrom [CoordonneesSurChromosome $Contig $DS $FS $Sens] set DChrom [lindex $LaLocSurLeChrom 1] set FChrom [lindex $LaLocSurLeChrom 2] set SensChrom [lindex $LaLocSurLeChrom 3] set BandesCyto {} foreach LaBC [LesBandesCytologiquesDeLaRegion [NumeroDuChromosome $Chromosome] $DChrom $FChrom] { lappend BandesCyto [lindex $LaBC 0] } set BandesCyto [join $BandesCyto " "] set EMax "" set E "" set Ligne "$Nom\t$InfoLoc\t$EMax\t$E\t$nAliMax\t$nAli\t$Id\t$DQ\t$FQ\t$Chromosome\t$DChrom\t$FChrom\t$SensChrom\t$Contig\t$Fragments\t$DS\t$FS\t$Orient\t$Sens\t$BandesCyto\t$Info\tprottfa" Espionne $Ligne lappend LeTexte $Ligne } } InterrogeFichierExonicMap unset } Sauve [join $LeTexte "\n"] dans $FileLoc return } proc FichierRecapExp2PsClus {PkExperiment} { #abandon genere trop gros fichier, choisit de le faire a la volee CanalSqlBioArrayBase set FichierSortie "[RepertoireDuGenome]/transcriptomique/ConeSpe/FichierClusterExp2" set LesLignes {} foreach {Ps Ex SoAn SoCl Cl} [SqlExec "select p.probeset_id, e.pk_experiment, a.name, c.clu_description, lncep.clusternumber from retinobase3.ln_clu_exp_pro lncep, retinobase3.cluster c, retinobase3.analysissoftware a, retinobase3.experiment e, retinobase3.probeset p where lncep.pk_experiment = e.pk_experiment and lncep.pk_probeset = p.pk_probeset and lncep.pk_cluster = c.pk_cluster and lncep.pk_software = a.pk_software and e.pk_experiment = '$PkExperiment' order by e.pk_experiment, a.name, c.clu_description" "GetList"] { lappend LesLignes "$Ps\t$Ex\t$SoAn\t$SoCl\t$Cl" } CanalSqlDisconnect Sauve [join $LesLignes "\n"] dans $FichierSortie } proc FichierRecapitulatif {Nom {IdMin 0.8} {IdMax 0.95}} { set LesAccessAvecDesLiens {} set RepRecap "[RepertoireDuGenome]/BilanHTML" if {![file exists $RepRecap]} {File mkdir $RepRecap} set FichierRecap "$RepRecap/$Nom.html" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom" set FichierBoxLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human" set FichierProtLoc "[RepertoireDuGenome]/Localisation/ProttfaLocalisation_Human" set FichiermRNALoc "[RepertoireDuGenome]/Localisation/mRNAHsapLocalisation_Human" set FichierBestLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set FichierIPO "[RepertoireDuGenome]/fiches/GeneOntology_prottfa" set FichierGPO "[RepertoireDuGenome]/fiches/GeneOntology" set FichierProttfaExonicMap "[RepertoireDuGenome]/prottfaexonicmap/$Nom" set FichierClustMSF "[RepertoireDuGenome]/msf/$Nom.clust" set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" InterrogeBilanMasking unset InterrogeSelectedEST unset if {0} { InterrogeTissueType unset InterrogeDevStage unset } InterrogeLocalisation unset InterrogeGeneName unset InterrogeDefinitionsConsensus unset InterrogeProtAndmRNAChoisis unset InterrogeProtAndmRNA unset InterrogeContigAndProt unset InterrogeProtAndContigChoisis unset InterrogeLesClustersDesMSF unset InterrogeBestProteinAndmRNAForeachOrga unset InterrogeDomaines unset AskGOAnalyse unset InterrogeMesKEGG unset AskMSF unset AskBlast unset if {[AskMSF $FichierMSF $Nom] != ""} { set NameQueryProt $Nom } elseif {[AskMSF $FichierMSF "QUERY_PROTEIN"] != ""} { set NameQueryProt "QUERY_PROTEIN" } else { set NameQueryProt "" } Espionne "$Nom -> Name ; Access ; Definition ; Length ; Organism" set LeTexte {} lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Initial DATA"]] H3] royalblue ] lappend LeTexte "" lappend LeTexte [H_Bold "Name: $Nom"] if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] != ""} { set AccessSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] lappend LeTexte "Access: $AccessSeq" lappend LesAccessAvecDesLiens $AccessSeq } if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] != ""} { set DefinitionSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] lappend LeTexte "Definition: $DefinitionSeq" } if {[file exists $FichierNuctfa]} { set TailleSeq [TailleDeLaSequenceDuFichierTFA $FichierNuctfa] lappend LeTexte "Length: $TailleSeq pb" } set OrganismeSeq [OrganismeDuPAB $Nom] lappend LeTexte "Organism: $OrganismeSeq" if {$OrganismeSeq == "Homo sapiens"} {set IdDeRef $IdMax} else {set IdDeRef $IdMin} set PIdDeRef [format "%.1f" [expr $IdDeRef * 100]] set PIdMin [format "%.1f" [expr $IdMin * 100]] ###Cluster dans lequel se trouve la sequence#### Espionne "$Nom -> cluster" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] != ""} { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] lappend LeTexte "Cluster: $Cluster" } ###Les expressions sur les puces affymetrix##### Espionne "$Nom -> expression" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions] != ""} { set LesTemps [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesPointsTemporels] set LesConditions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesConditions ] set LaLigneTemps [list [format "%-10s" ""]] foreach Temps $LesTemps {lappend LaLigneTemps [format "%-6s" $Temps]} lappend LeTexte "" lappend LeTexte [H_Bold "Expression:"] lappend LeTexte [join $LaLigneTemps ""] foreach Condition $LesConditions { set LaLigneCondition [list [format "%-10s" $Condition]] foreach Temps $LesTemps { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Condition $Condition PointTemporel $Temps Expression] if {$Expr == ""} {lappend LaLigneCondition [format "%-6s" ""];continue} lappend LaLigneCondition [format "%-6.0f" $Expr] } lappend LeTexte [join $LaLigneCondition ""] } } ###Les informations relatives au masking, remasking et mrm#### Espionne "$Nom -> Masking ; ReMasking ; Masking and ReMasking" if {[InterrogeBilanMasking $Nom LesEtats] != ""} { lappend LeTexte "" foreach Etat [InterrogeBilanMasking $Nom LesEtats] { if {[InterrogeBilanMasking $Nom Etat $Etat PMasked] == ""} {continue} set PMasked [InterrogeBilanMasking $Nom Etat $Etat PMasked ] set NbRepeat [InterrogeBilanMasking $Nom Etat $Etat NbRepeat] lappend LeTexte [H_Bold "Masking of the Eukaryotic Repeats:"] if {$NbRepeat != 0} { lappend LeTexte [H_Color "$Etat PMasked: ${PMasked}%" red] lappend LeTexte [H_Color "$Etat NbRepeat: $NbRepeat" red] } else { lappend LeTexte "$Etat PMasked: ${PMasked}%" lappend LeTexte "$Etat NbRepeat: $NbRepeat" } set LesRepeatsEtLeurEffectif {} foreach Repeat [InterrogeBilanMasking $Nom Etat $Etat LesRepeats] { set n [InterrogeBilanMasking $Nom Etat $Etat Repeat $Repeat n] lappend LesRepeatsEtLeurEffectif [list $Repeat $n] } set LesRepeats {} foreach LeRepeat [lsort -index 1 -integer -decreasing $LesRepeatsEtLeurEffectif] { lappend LesRepeats "[lindex $LeRepeat 0] ([lindex $LeRepeat 1])" } if {$LesRepeats != {}} { lappend LeTexte "$Etat Repeat:" lappend LeTexte [join $LesRepeats " ; "] } } } lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Expression DATA"]] H3] royalblue ] lappend LeTexte "" lappend LeTexte [H_Bold "Tissue Type:"] ###Tissue Type######### Espionne "$Nom -> Tissue Type" if {[InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] != ""} { set LesTissues {} foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] { if {$Tissue == ""} {continue} lappend LesTissues [list $Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n]] } if {$LesTissues != {}} { set LesTissuesEtLeurEffectif {} foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { lappend LesTissuesEtLeurEffectif "[lindex $LeTissue 0] ([lindex $LeTissue 1])" } lappend LeTexte [join $LesTissuesEtLeurEffectif " ; "] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } ###Development Stage######### Espionne "$Nom -> Development stage" lappend LeTexte "" lappend LeTexte [H_Bold "Development Stage:"] if {[InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] != ""} { set LesDevStage {} foreach DevStage [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] { if {$DevStage == ""} {continue} lappend LesDevStage [list $DevStage [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DevStage n]] } if {$LesDevStage != {}} { set LesDevStageEtLeurEffectif {} foreach LeDevStage [lsort -index 1 -decreasing -integer $LesDevStage] { lappend LesDevStageEtLeurEffectif "[lindex $LeDevStage 0] ([lindex $LeDevStage 1])" } lappend LeTexte [join $LesDevStageEtLeurEffectif " ; "] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } if {0} { ###Tissue Type######### Espionne "$Nom -> Tissue Type" if {[InterrogeTissueType $Nom LesTissues] != ""} { set LesTissues {} foreach Tissue [InterrogeTissueType $Nom LesTissues] { if {$Tissue == ""} {continue} lappend LesTissues [list $Tissue [InterrogeTissueType $Nom Tissue $Tissue n]] } if {$LesTissues != {}} { set LesTissuesEtLeurEffectif {} foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { lappend LesTissuesEtLeurEffectif "[lindex $LeTissue 0] ([lindex $LeTissue 1])" } lappend LeTexte [join $LesTissuesEtLeurEffectif " ; "] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } ###Development Stage######### Espionne "$Nom -> Development stage" lappend LeTexte "" lappend LeTexte [H_Bold "Development Stage:"] if {[InterrogeDevStage $Nom LesDevStages] != ""} { set LesDevStage {} foreach DevStage [InterrogeDevStage $Nom LesDevStages] { if {$DevStage == ""} {continue} lappend LesDevStage [list $DevStage [InterrogeDevStage $Nom DevStage $DevStage n]] } if {$LesDevStage != {}} { set LesDevStageEtLeurEffectif {} foreach LeDevStage [lsort -index 1 -decreasing -integer $LesDevStage] { lappend LesDevStageEtLeurEffectif "[lindex $LeDevStage 0] ([lindex $LeDevStage 1])" } lappend LeTexte [join $LesDevStageEtLeurEffectif " ; "] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } } ###Localisation de la sequence sur le genome humain### lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Closest complete genome locations"]] H3] royalblue ] Espionne "$Nom -> localisation on human genome" set AiJeAuMoinsUneLoc 0 set LesLocalisations_Texte {} if {[file exists $FichierBoxLoc]} { set AiJeAuMoinsUneLoc 1 if {[InterrogeLocalisation $FichierBoxLoc Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierBoxLoc Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] set Warning "" if {$InfoLoc != "MonoLoc"} {set Warning $InfoLoc} foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation 20] != "BestLoc" && [lindex $LaLocalisation 20] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10] set F [lindex $LaLocalisation 11] set Sens [lindex $LaLocalisation 12] set Contig [lindex $LaLocalisation 13] set BCyto [lindex $LaLocalisation 19] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] if {$Id < $IdDeRef} { if {$Warning != ""} {set Warning "$Warning ;"} set Warning "$Warning Id < $PIdDeRef%" } lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Query" $Chromosome $D $F $Sens $Contig $BCyto $PId [H_Color $Warning red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Query" "" "" "" "" "" "" "" [H_Color "Not found" red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Query" "" "" "" "" "" "" "" [H_Color "No file" orange]] } if {[file exists $FichierProtLoc]} { set AiJeAuMoinsUneLoc 1 if {[InterrogeLocalisation $FichierProtLoc Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierProtLoc Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] set Warning "" if {$InfoLoc != "MonoLoc"} {set Warning $InfoLoc} foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation 20] != "BestLoc" && [lindex $LaLocalisation 20] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10] set F [lindex $LaLocalisation 11] set Sens [lindex $LaLocalisation 12] set Contig [lindex $LaLocalisation 13] set BCyto [lindex $LaLocalisation 19] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] if {$Id < $IdDeRef} { if {$Warning != ""} {set Warning "$Warning ;"} set Warning "$Warning Id < $PIdDeRef%" } lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Protein" $Chromosome $D $F $Sens $Contig $BCyto $PId [H_Color $Warning red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Protein" "" "" "" "" "" "" "" [H_Color "Not found" red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Protein" "" "" "" "" "" "" "" [H_Color "No file" orange]] } if {[file exists $FichiermRNALoc]} { set AiJeAuMoinsUneLoc 1 if {[InterrogeLocalisation $FichiermRNALoc Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichiermRNALoc Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] set Warning "" if {$InfoLoc != "MonoLoc"} {set Warning $InfoLoc} foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation 20] != "BestLoc" && [lindex $LaLocalisation 20] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10] set F [lindex $LaLocalisation 11] set Sens [lindex $LaLocalisation 12] set Contig [lindex $LaLocalisation 13] set BCyto [lindex $LaLocalisation 19] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] if {$Id < $IdDeRef} { if {$Warning != ""} {set Warning "$Warning ;"} set Warning "$Warning Id < $PIdDeRef%" } lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "mRNA Human" $Chromosome $D $F $Sens $Contig $BCyto $PId [H_Color $Warning red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "mRNA Human" "" "" "" "" "" "" "" [H_Color "Not found" red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "mRNA Human" "" "" "" "" "" "" "" [H_Color "No file" orange]] } if {[file exists $FichierBestLoc]} { set AiJeAuMoinsUneLoc 1 if {[InterrogeLocalisation $FichierBestLoc Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierBestLoc Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] set Warning "" if {$InfoLoc != "MonoLoc"} {set Warning $InfoLoc} foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation 20] != "BestLoc" && [lindex $LaLocalisation 20] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10] set F [lindex $LaLocalisation 11] set Sens [lindex $LaLocalisation 12] set Contig [lindex $LaLocalisation 13] set BCyto [lindex $LaLocalisation 19] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] if {$Id < $IdDeRef} { if {$Warning != ""} {set Warning "$Warning ;"} set Warning "$Warning Id < $PIdDeRef%" } lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Best" $Chromosome $D $F $Sens $Contig $BCyto $PId [H_Color $Warning red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Best" "" "" "" "" "" "" "" [H_Color "Not found" red]] } } else { lappend LesLocalisations_Texte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Best" "" "" "" "" "" "" "" [H_Color "No file" orange]] } lappend LeTexte "" lappend LeTexte [H_Bold "Locations on Human genome:"] if {$AiJeAuMoinsUneLoc} { lappend LeTexte [format "%-12s %-10s %-10s %-10s %-7s %-10s %-10s %-6s %s" "Sequence" "Chromosome" "From" "to" "strand" "Contig" "CytoBand" "Id (%)" "Warning"] foreach TexteLoc $LesLocalisations_Texte {lappend LeTexte $TexteLoc} } lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Protein definition"]] H3] royalblue ] ###Les noms des genes des proteines du meme cluster de msf que la proteine de ref### Espionne "$Nom -> Gene name" lappend LeTexte "" lappend LeTexte [H_Bold "Gene Name:"] if {[InterrogeGeneName $Nom LesGeneNames] != ""} { set LesGeneNames {} foreach GN [InterrogeGeneName $Nom LesGeneNames] { if {$GN == ""} {continue} lappend LesGeneNames [list $GN [InterrogeGeneName $Nom GeneName $GN n]] } if {$LesGeneNames != {}} { set LesGeneNamesEtLeurEffectif {} foreach LeGN [lsort -index 1 -decreasing -integer $LesGeneNames] { lappend LesGeneNamesEtLeurEffectif "[lindex $LeGN 0] ([lindex $LeGN 1])" } lappend LeTexte [join $LesGeneNamesEtLeurEffectif " ; "] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } ###Mean Definition### Espionne "$Nom -> MeanDefinition" lappend LeTexte "" lappend LeTexte [H_Bold "Mean Definition:"] set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] if {$MeanDef != ""} { lappend LeTexte [H_Bold "$MeanDef"] } else { lappend LeTexte [H_Color "Warning -> None" orange] } ###Commencons maintenant le boulot pour la meilleure proteine trouvee#### Espionne "$Nom -> best protein found" set AccessDuChoisi "" set InfoSeq [InterrogeProtAndmRNAChoisis $Nom SeqChoisie] set TailleProt [TailleDeLaSequenceDuFichierTFA $FichierProttfa] set AiJeTrouveUneProteineDeRef 0 if {$InfoSeq != ""} { if {$InfoSeq == "SeqOK"} { set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {![string equal -nocase $AccessProt "NoProtein"]} { set AccessDuChoisi $AccessProt lappend LesAccessAvecDesLiens $AccessDuChoisi set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LesOrganismes [LesOrgasDeLaPage_PageInfo $PageInfoProt] if {$LesOrganismes == ""} { set LesOrganismes [list [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]] } } if {[string equal -nocase $AccessProt "NoProtein"] && ![string equal -nocase $AccessmRNA "NomRNA"]} { set AccessProt "NoAccess" set DefProt "NoDef" set LesOrganismes [list [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]] set From "mRNA complete CDS of BLASTN against genembl DB" lappend LesAccessAvecDesLiens $AccessmRNA set AccessDuChoisi $AccessmRNA } if {![string equal -nocase $AccessProt "NoProtein"] || ![string equal -nocase $AccessmRNA "NomRNA"]} { set Rang [lindex [InterrogeProtAndmRNA $Nom Access $AccessDuChoisi LesRangs] 0] set Type [InterrogeProtAndmRNA $Nom Rang $Rang Type ] if {$Type == "mRNA"} {set From "mRNA complete CDS from BLASTN against genembl DB"} else {set From "BLASTX against protein DB"} lappend LeTexte "" lappend LeTexte [H_Bold "Closest neigbour protein:"] lappend LeTexte "Protein Access: $AccessProt" lappend LeTexte "Protein Definition: $DefProt" lappend LeTexte "Protein Organisms: [join $LesOrganismes " ; "]" lappend LeTexte "Protein Length: $TailleProt AA" lappend LeTexte "Protein From: $From" set AiJeTrouveUneProteineDeRef 1 set DejaVu($AccessProt) 1 lappend LesAccessAvecDesLiens $AccessProt set IdDeLaProtAvecSeq $IdMin foreach Orga $LesOrganismes { if {$Orga == $OrganismeSeq} {set IdDeLaProtAvecSeq $IdMax} } set PIdDeLaProtAvecSeq [format "%.1f" [expr $IdDeLaProtAvecSeq * 100]] set Id [InterrogeProtAndmRNA $Nom Rang $Rang Id] if {$Id != ""} { set PId [format "%.1f" [expr $Id * 100]] if {$Type != "mRNA"} { lappend LeTexte "Protein Identity: $PId%" if {$Id != "" && $Id < $IdDeLaProtAvecSeq} { lappend LeTexte [H_Color "WARNING the identity with the sequence is only $PId% (< $PIdDeLaProtAvecSeq%)" red] } } } if {$AccessmRNA != "NomRNA" && $Type == "mRNA"} { lappend LesAccessAvecDesLiens $AccessmRNA set PageInfomRNA [PageInfo $AccessmRNA genbankfull "id acc des org"] set DefmRNA [join [LaDefinitionDeLAcNuc_PageInfo $PageInfomRNA] " " ] set Organismes [join [LesOrgasDeLaPage_PageInfo $PageInfomRNA] " ; "] set TaillemRNA [TailleDeLAcNuc_PageInfo $PageInfomRNA] lappend LeTexte "" lappend LeTexte [H_Bold "mRNA:"] lappend LeTexte "mRNA Access: $AccessmRNA" lappend LeTexte "mRNA Definition: $DefmRNA" lappend LeTexte "mRNA Organisms: $Organismes" lappend LeTexte "mRNA Length: $TaillemRNA pb" if {$Id != ""} { lappend LeTexte "mRNA Identity: $PId%" if {$Id < $IdDeLaProtAvecSeq} { lappend LeTexte [H_Color "WARNING the identity with the sequence is only $PId% (< $PIdDeLaProtAvecSeq%)" red] } } lappend LesAccessAvecDesLiens $AccessmRNA set DejaVu($AccessmRNA) 1 } } InterrogeProtAndmRNA unset } else { set AccessProt [string toupper [InterrogeContigAndProt $Nom Protein Access]] if {$AccessProt != ""} { lappend LesAccessAvecDesLiens $AccessProt set AccessDuChoisi $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LesOrganismes [LesOrgasDeLaPage_PageInfo $PageInfoProt] set Organismes [join $LesOrganismes " ; " ] set From "Contig from BLASTN against genembl DB" set AccessContig [string toupper [InterrogeContigAndProt $Nom Contig Access]] lappend LesAccessAvecDesLiens $AccessContig set TailleContig [InterrogeContigAndProt $Nom Contig Taille ] set OrgaContig [InterrogeContigAndProt $Nom Contig Organisme] lappend LeTexte "" lappend LeTexte [H_Bold "Closest neighbour protein:"] lappend LeTexte "Protein Access: $AccessProt" lappend LeTexte "Protein Definition: $DefProt" lappend LeTexte "Protein Organisms: $Organismes" lappend LeTexte "Protein Length: $TailleProt AA" lappend LeTexte "Protein From: $From" set AiJeTrouveUneProteineDeRef 1 set DejaVu($AccessProt) 1 set Id [InterrogeContigAndProt $Nom Protein Identity ] set PId [format "%.1f" [expr $Id * 100]] set IdDeRefDeLaProtAvecContig $IdMin foreach Orga $LesOrganismes { if {$Orga == $OrgaContig} {set IdDeRefDeLaProtAvecContig $IdMax} } set PIdDeRefDeLaProtAvecContig [format "%.1f" [expr $IdDeRefDeLaProtAvecContig * 100]] lappend LeTexte "Identity with Contig: $PId%" if {$Id < $IdDeRefDeLaProtAvecContig} { lappend LeTexte [H_Color "WARNING the identity with the sequence is only $PId% (< $PIdDeRefDeLaProtAvecContig%)" red] } lappend LeTexte "" lappend LeTexte [H_Bold "CONTIG:"] lappend LeTexte "Contig Access: $AccessContig" lappend LeTexte "Contig Organism: $OrgaContig" lappend LeTexte "Contig Length: $TailleContig pb" set DejaVu($AccessContig) 1 set Id [InterrogeContigAndProt $Nom Contig Identity ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte "Identity with sequence: $PId%" if {$Id < $IdDeRef} { lappend LeTexte [H_Color "WARNING the identity with the sequence is only $PId% (< $PIdDeRef%)" red] } } } } if {!$AiJeTrouveUneProteineDeRef} { lappend LeTexte [H_Color "Warning -> Not found" red] } ###Recherche des proteines identiques a 98%" set LesAccessDesChoisi {} if {$AccessDuChoisi != ""} {lappend LesAccessDesChoisi $AccessDuChoisi} Espionne "$Nom -> other proteins with at least 98% of identity with the best protein" lappend LeTexte "" lappend LeTexte [H_Bold "Others Proteins with at least 98% of identity with the closest neighbour protein:"] set LesAccessDesProteinesIdentiquesDansMSF [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt 0.98] if {$LesAccessDesProteinesIdentiquesDansMSF != ""} { AskLesPagesInfos load $LesAccessDesProteinesIdentiquesDansMSF protein set LesAccessDesIdentiques {} foreach Access $LesAccessDesProteinesIdentiquesDansMSF { set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} {continue} set Access [string toupper $Access] if {[info exists DejaVu($Access)]} {continue} set DejaVu($Access) 1 lappend LesAccessAvecDesLiens $Access lappend LesAccessDesChoisi $Access set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] set Taille [TailleDeLaProt_PageInfo $PageInfo] foreach Orga $LesOrgas { lappend LesAccessDesIdentiques "$Access ; Protein ; $Taille AA ; $Orga ; $Def" } } if {$LesAccessDesIdentiques != {}} { foreach LAccessIdentique $LesAccessDesIdentiques { lappend LeTexte $LAccessIdentique } } else { lappend LeTexte [H_Color "Warning -> None" orange] } AskLesPagesInfos unset } else { lappend LeTexte [H_Color "Warning -> None" orange] } if {0} { ###recherche des mRNAs et des proteines CrossLinked#### Espionne "$Nom -> mRNAs and proteins cross-linked" lappend LeTexte "" lappend LeTexte [H_Bold "Others CrossLinked Protein and mRNA complete CDS Accession:"] if {$LesAccessDesChoisi != {}} { set LesAccessCrossLinked [LesCrossLinkedDesAccess $LesAccessDesChoisi] if {$LesAccessCrossLinked != {}} { set LeTexteDesCrossLinked {} foreach LAccessCL [lsort -index 1 $LesAccessCrossLinked] { set Access [string toupper [lindex $LAccessCL 0]] if {[info exists DejaVu($Access)]} {continue} set DejaVu($Access) 1 lappend LesAccessAvecDesLiens $Access set Quoi [lindex $LAccessCL 1] set Taille [lindex $LAccessCL 2] if {$Quoi == "mRNA" } {set Taille "$Taille bp"} if {$Quoi == "Protein"} {set Taille "$Taille AA"} set Orga [lindex $LAccessCL 3] set Def [lindex $LAccessCL 4] lappend LeTexteDesCrossLinked "$Quoi ; $Access ; $Taille ; $Orga ; $Def" } if {$LeTexteDesCrossLinked != {}} { set LeTexte [concat $LeTexte $LeTexteDesCrossLinked] } else { lappend LeTexte [H_Color "Warning -> None" orange] } } } else { lappend LeTexte [H_Color "Warning -> None" orange] } } lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Multiple Alignment of Complete Sequences (MACS)"]] H3] royalblue ] ###Enfin le MSF c'etait pas trop tot#### Espionne "$Nom -> informations about multiple alignment" lappend LeTexte "" lappend LeTexte [H_Bold "MACS:"] set AvecMSF 0 if {[file exists $FichierMSF] && [DecortiqueUnMSF $FichierMSF LesAccess Sequences]} { set AvecMSF 1 set NbAccess [llength $LesAccess ] set NormMDTot [MDScore $FichierMSF "CalculeMoi"] lappend LeTexte "Nb proteins: $NbAccess" lappend LeTexte "NormMD: $NormMDTot" if { $NormMDTot < 0.3} {lappend LeTexte [H_Color "WARNING the quality of the alignment is bad" red] } if {0.3 <= $NormMDTot && $NormMDTot < 0.5} {lappend LeTexte [H_Color "WARNING the quality of the alignment is medium" orange]} } else { lappend LeTexte [H_Color "Warning -> MSF file is not valid or does not exist" orange] } lappend LeTexte "" lappend LeTexte [H_Bold "MACS Clustering (sub-family determination) :"] if {[InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] != "" && $AvecMSF} { set LesClusters [InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] set NbClusters [llength $LesClusters] set ClusterDeLaProt [InterrogeLesClustersDesMSF $FichierClustMSF Access $NameQueryProt Cluster ] set LesAccess [InterrogeLesClustersDesMSF $FichierClustMSF Cluster $ClusterDeLaProt LesAccess] set NbAccess [llength $LesAccess] set NormMDDuClust [MDScoreAvecSelectionDuFichier $FichierMSF $LesAccess] lappend LeTexte "Nb clusters: $NbClusters" lappend LeTexte "Cluster of our protein: $ClusterDeLaProt" lappend LeTexte "Nb proteins in our cluster: $NbAccess" lappend LeTexte "NormMD of our Cluster: $NormMDDuClust" if { $NormMDDuClust < 0.3} {lappend LeTexte [H_Color "WARNING the quality of the alignment is bad" red]} if {0.3 <= $NormMDDuClust && $NormMDDuClust < 0.5} {lappend LeTexte [H_Color "WARNING the quality of the alignment is medium" orange]} InterrogeLesClustersDesMSF unset } else { lappend LeTexte [H_Color "Warning -> No sub-family determination detected" orange] } ###Human prot and mRNA found in MACS lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Closest Human protein and mRNA complete CDS (MACS)"]] H3] royalblue ] lappend LeTexte "" lappend LeTexte [H_Bold "Closest Human Protein :"] if {[InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access] != ""} { set AccessProtHsap [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access] set Definition [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProtHsap Definition] set Identity [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProtHsap Identity ] set Taille [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProtHsap Taille ] set Orgas [join [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProtHsap LesOrganismes] ";"] set PId [format "%.1f" [expr $Identity * 100]] lappend LesAccessAvecDesLiens $AccessProtHsap lappend LeTexte "Protein Access: $AccessProtHsap" lappend LeTexte "Protein Definition: $Definition" lappend LeTexte "Protein Organisms: $Orgas" lappend LeTexte "Protein Length: $Taille AA" lappend LeTexte "Protein Identity: $PId %" if {$Identity < $IdMin} { lappend LeTexte [H_Color "WARNING the identity with the sequence is only $PId% (< $PIdMin%)" red] } #mRNA human lappend LeTexte "" lappend LeTexte [H_Bold "Closest Human mRNA complete CDS :"] if {[InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "mRNA" Access] != ""} { set AccessmRNAHsap [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "mRNA" Access] set Definition [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProtHsap Definition] set Taille [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNAHsap Taille ] set Orgas [join [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProtHsap LesOrganismes] ";"] lappend LesAccessAvecDesLiens $AccessmRNAHsap lappend LeTexte "mRNA Access: $AccessmRNAHsap" lappend LeTexte "mRNA Definition: $Definition" lappend LeTexte "mRNA Organisms: $Orgas" lappend LeTexte "mRNA Length: $Taille bp" } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } ###Domaines### lappend LeTexte "" lappend LeTexte "" lappend LeTexte [H_Color [H_Balise [H_Bold [H_Center "Propagation of the information of the MACS"]] H3] royalblue ] lappend LeTexte "" lappend LeTexte [H_Bold "Domains with at least 80 % of similarity :"] if {[InterrogeDomaines $Nom LesDomaines] != ""} { foreach LeDomaine [lsort -index 0 [lsort -index 3 -real [InterrogeDomaines $Nom LesDomaines]]] { set Type [lindex $LeDomaine 0] if {$Type == "FEATURE"} {continue} set Id [lindex $LeDomaine 5] if {$Id < $IdMin} {continue} set TexteId "[format "%.1f" [expr $Id*100]] %" set Domaine [lindex $LeDomaine 1] set Def [lindex $LeDomaine 2] set Debut [lindex $LeDomaine 3] set Fin [lindex $LeDomaine 4] if {$Type == "INTERPRO"} {lappend LesAccessAvecDesLiens $Domaine} lappend LeTexte [format "%-10s %-10s from %-6s to %-6s with %-8s : %s" $Type $Domaine $Debut $Fin $TexteId $Def] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } ###Initial Protein Ontology et Global Protein Ontology#### Espionne "$Nom -> IPO" set FileGOXML "[RepertoireDuGenome]/GeneOntology/$Nom.xml" set LesGOAvecLiens {} lappend LeTexte "" lappend LeTexte [H_Bold "Initial Protein GENE ONTOLOGY (IPO) :"] set LesTypes [AskGOAnalyse $FileGOXML Methode IPO LesTypes] if {$LesTypes != {}} { foreach Type $LesTypes { foreach GO [AskGOAnalyse $FileGOXML Methode IPO Type $Type LesGO] { set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] set TexteType [format "%-9s" $Type] lappend LeTexte "$TexteType $GO $Def" lappend LesGOAvecLiens $GO } } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } Espionne "$Nom -> GPO" lappend LeTexte "" lappend LeTexte [H_Bold "Global Protein GENE ONTOLOGY (GPO) :"] set LesTypes [AskGOAnalyse $FileGOXML Methode GPO LesTypes] if {$LesTypes != {}} { foreach Type $LesTypes { foreach GO [AskGOAnalyse $FileGOXML Methode GPO Type $Type LesGO] { set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] set TexteType [format "%-9s" $Type] lappend LeTexte "$TexteType $GO $Def" lappend LesGOAvecLiens $GO } } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } AskGOAnalyse unset if {0} { Espionne "$Nom -> KEGG" lappend LeTexte "" lappend LeTexte [H_Bold "KEGG : KEGG"] if {[InterrogeMesKEGG $Nom LesKegg] != ""} { foreach Kegg [InterrogeMesKEGG $Nom LesKegg] { set Def [InterrogeMesKEGG Kegg $Kegg Definition] lappend LeTexte [format "%-8s %-8s %s" "KEGG" $Kegg $Def] } foreach Pathway [InterrogeMesKEGG $Nom LesPathway] { set Def [InterrogeMesKEGG Pathway $Pathway Definition] lappend LeTexte [format "%-8s %-8s %s" "PATHWAY" $Pathway $Def] } } else { lappend LeTexte [H_Color "Warning -> Not found" orange] } } Espionne "$Nom -> mise en forme" set TexteEnForme {} foreach Ligne $LeTexte { lappend TexteEnForme $Ligne lappend TexteEnForme [H_BR] } while {[regexp -all -nocase {<[a-z0-9]+[ ]{2}} $TexteEnForme tmp]} { set tmpnew [string trim $tmp] regsub -all $tmp $TexteEnForme "$tmpnew " TexteEnForme } while {[regexp {[ ]{2}} $TexteEnForme tmp]} { regsub -all " " $tmp "\\\\\\ " tmpnew regsub -all $tmp $TexteEnForme $tmpnew TexteEnForme } set TexteEnForme [join $TexteEnForme "\n"] foreach Access [lsort -unique $LesAccessAvecDesLiens] { set Access [string toupper $Access] if {[info exists TabDejaVu($Access)]} {continue} set TabDejaVu($Access) 1 regsub -nocase -all $Access $TexteEnForme [H_HrefGetz $Access $Access "PROTEIN GENBANKFULL INTERPRO" acc] TexteEnForme } foreach GO [lsort -unique $LesGOAvecLiens] { regsub -nocase -all $GO $TexteEnForme [H_HrefGetz $GO $GO "GO" id] TexteEnForme } set TexteEnForme [H_Font $TexteEnForme] Html_ZeroToBody Html_Append $TexteEnForme Html_BodyToEnd set Texte [Html_Get] Sauve $Texte dans $FichierRecap return } proc FichierRecapitulatifControl {} { set Ligne "GI;ProteinNameFromRam;AccessionNumber;ProteinIDPoulet;PreferredNamePoulet;ProteinIDHomme;PreferredNameHomme;ProteinIDMouse;PreferredNameMouse" lappend LesLignes $Ligne Espionne "$LesLignes" foreach GI [InterrogeListTauControl ListOf GI] { set ProteinName [InterrogeListTauControl $GI ProteinName] set GetzOutpdb ""; set GetzOut ""; set SeqGbTfa ""; set TfaProt "" set Access [InterrogeSortieNcbiControl $GI Access] set DB [InterrogeSortieNcbiControl $GI DB] if {[regexp "pdb" $DB]} { set FichierRequete "/genomics/link/Tau/GSTControl/entreepdb.bql" set FichierSortie "/genomics/link/Tau/GSTControl/sortiepdb.txt" set Elmt [split $Access "_"] set accesspdb [lindex $Elmt 0] set chain [lindex $Elmt 1] lappend LesLignesBird "ID * DB PDB" lappend LesLignesBird "WH SQLNATIVE SELECT distinct dr.dbaccession from pdb.header as h , pdb.dbref as dr where h.idcode='$accesspdb' and dr.chainid='$chain' and h.oid=dr.key_fk" lappend LesLignesBird "FM CSV" SauveLesLignes $LesLignesBird dans $FichierRequete BirdForceHoan $FichierRequete $FichierSortie foreach LigneFic [LesLignesDuFichier $FichierSortie] { if {[regexp "Query" $LigneFic]} {continue} set NvAcc $LigneFic } set FichierTfaPoulet "/genomics/link/Tau/GSTControl/BlastpSurStringPoulet/fastaquery/$NvAcc" set PIDPoulet [BlastPStringMoi $FichierTfaPoulet 9031] set PNPoulet [PreferedNameStringFromProteins $PIDPoulet] set FichierTfaHomme "/genomics/link/Tau/GSTControl/BlastpSurStringHomme/fastaquery/$NvAcc" set PIDHomme [BlastPStringMoi $FichierTfaHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaMouse "/genomics/link/Tau/GSTControl/BlastpSurStringMouse/fastaquery/$NvAcc" set PIDMouse [BlastPStringMoi $FichierTfaMouse 10090] set PNMouse [PreferedNameStringFromProteins $PIDMouse] set Ligne "$GI;$ProteinName;$Access/$NvAcc;$PIDPoulet;$PNPoulet;$PIDHomme;$PNHomme;$PIDMouse;$PNMouse" lappend LesLignes $Ligne } else { set FichierTfaPoulet "/genomics/link/Tau/GSTControl/BlastpSurStringPoulet/fastaquery/$Access" set PIDPoulet [BlastPStringMoi $FichierTfaPoulet 9031] set PNPoulet [PreferedNameStringFromProteins $PIDPoulet] set FichierTfaHomme "/genomics/link/Tau/GSTControl/BlastpSurStringHomme/fastaquery/$Access" set PIDHomme [BlastPStringMoi $FichierTfaHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaMouse "/genomics/link/Tau/GSTControl/BlastpSurStringMouse/fastaquery/$Access" set PIDMouse [BlastPStringMoi $FichierTfaMouse 10090] set PNMouse [PreferedNameStringFromProteins $PIDMouse] set Ligne "$GI;$ProteinName;$Access;$PIDPoulet;$PNPoulet;$PIDHomme;$PNHomme;$PIDMouse;$PNMouse" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "/genomics/link/Tau/GSTControl/FichierRecapitulatifControl.txt" } proc FichierRecapitulatifDes1500PourOligo {} { set Repertoire "/genomics/link/EVImm/Arnaud/nuctfa1500Final" foreach File [glob -nocomplain "$Repertoire/*"] { set Nom [file tail $File] set Access [StringApres ":" dans [lindex [LesLignesDuFichier $File] 0]] set Ligne "$Nom $Access" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/Arnaud/FichierFinalDes1500" } proc FichierRecapitulatifDesClusters_PO {FichierOUT} { set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set PMaskingMax 0.95 set LesClusters [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] set LesNoms [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] set NbNoms [llength $LesNoms] set RepMasked "[RepertoireDuGenome]/nucmask" set RepProttfa "[RepertoireDuGenome]/prottfa" set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set LeTexte {} lappend LeTexte "Cluster\tNumber of Sequences\tNumber of Sequences after masking\tNumber of Proteins\tNumber of Non redundant Proteins\tNumber of Protein annotated in terms of Process GO\tNumber of Protein annotated in terms of Function GO\tNumber of Protein annotated in terms of Component GO\tNumber of Full-length mRNA" set LeTextePourcentage {} lappend LeTextePercent "Cluster\tSequences/All Sequences\tSAM/Sequences\tProteins/SAM\tNRP/Proteins\tProcess/NRP\tFunction/NRP\tComponent/NRP\tmRNA/NRP" foreach Cluster $LesClusters { set LesNoms [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] set NbTot [llength $LesNoms] set NbNonMasked 0 set NbProt 0 set NbProtNonRedondantes 0 set NbmRNAHsap 0 set NbProtAvecGOProcess 0 set NbProtAvecGOFunction 0 set NbProtAvecGOComponent 0 foreach Nom $LesNoms { Espionne "$Cluster -> $Nom" set FileMasked "$RepMasked/$Nom" set PMasking [PourcentageDeSequenceMasquee $FileMasked] if {$PMasking != "" && $PMasking < $PMaskingMax} {incr NbNonMasked} if {![file exists "$RepProttfa/$Nom"]} {continue} incr NbProt if {[info exists TabTmp($Nom)]} {continue} set TabTmp($Nom) 1 incr NbProtNonRedondantes foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] { set ClusterJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster] if {$Cluster != $ClusterJum} {continue} set TabTmp($Jum) 1 } set GOProcess 0 set GOFunction 0 set GOComponent 0 foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] if {$Type == "process" && $GOProcess == 0} { incr GOProcess incr NbProtAvecGOProcess } if {$Type == "function" && $GOFunction == 0} { incr GOFunction incr NbProtAvecGOFunction } if {$Type == "component" && $GOComponent == 0} { incr GOComponent incr NbProtAvecGOComponent } } if {![file exists "$RepmRNA/$Nom"]} {continue} incr NbmRNAHsap } set PTot [format "%.2f" [expr $NbTot * 100.0 / $NbNoms ]] set PNonMasked [format "%.2f" [expr $NbNonMasked * 100.0 / $NbTot ]] set PProt [format "%.2f" [expr $NbProt * 100.0 / $NbNonMasked ]] set PProtNonRedondantes [format "%.2f" [expr $NbProtNonRedondantes * 100.0 / $NbProt ]] set PmRNAHsap [format "%.2f" [expr $NbmRNAHsap * 100.0 / $NbProtNonRedondantes]] set PProtAvecGOProcess [format "%.2f" [expr $NbProtAvecGOProcess * 100.0 / $NbProtNonRedondantes]] set PProtAvecGOFunction [format "%.2f" [expr $NbProtAvecGOFunction * 100.0 / $NbProtNonRedondantes]] set PProtAvecGOComponent [format "%.2f" [expr $NbProtAvecGOComponent * 100.0 / $NbProtNonRedondantes]] lappend LeTexte "$Cluster\t$NbTot\t$NbNonMasked\t$NbProt\t$NbProtNonRedondantes\t$NbProtAvecGOProcess\t$NbProtAvecGOFunction\t$NbProtAvecGOComponent\t$NbmRNAHsap" lappend LeTextePercent "$Cluster\t$PTot\t$PNonMasked\t$PProt\t$PProtNonRedondantes\t$PProtAvecGOProcess\t$PProtAvecGOFunction\t$PProtAvecGOComponent\t$PmRNAHsap" } if {$LeTexte == {}} {return} set Texte [join $LeTexte "\n"] set TextePercent [join $LeTextePercent "\n"] regsub -all {\.} $TextePercent "," TextePercent Sauve "$Texte\n\nNRP\tNon Redundant Proteins\nSAM\tSequences After Masking\n$TextePercent" dans $FichierOUT return } proc FichierRecapitulatifDesZscoreDesGODesClusters_PO {FichierRecapitulatifGODesClusters} { Espionne "RecapitulatifDesZscoreDesGODesClusters running ..." if {![file exists $FichierRecapitulatifGODesClusters]} {return} set Tab(LesGO) {} set Tab(LesClusters) {} set Tab(LesPop) {} set F [open $FichierRecapitulatifGODesClusters] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Cluster [lindex $LaLigne 0] set Pop [lindex $LaLigne 1] set GO [lindex $LaLigne 2] set Type [lindex $LaLigne 3] set Niv [lindex $LaLigne 4] set Def [lindex $LaLigne 5] set r [lindex $LaLigne 6] set R [lindex $LaLigne 7] set n [lindex $LaLigne 8] set N [lindex $LaLigne 9] set Zscore [lindex $LaLigne 10] regsub {\,} $Zscore "." Zscore regsub {^Cluster } $Cluster "" Cluster set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster if {![info exists TabTmp($Cluster)]} { set TabTmp($Cluster) 1 lappend Tab(LesClusters) $Cluster } regsub {^Pop } $Pop "" Pop if {$Pop == "HumanProteome"} { set Pop "${Pop}_$BigCluster" } if {![info exists Tab($Pop,LesClusters)]} { set Tab($Pop,LesClusters) {} set Tab($Pop,LesGO) {} lappend Tab(LesPop) $Pop } if {![info exists TabTmp($Pop,$Cluster)]} { set TabTmp($Pop,$Cluster) 1 lappend Tab($Pop,LesClusters) $Cluster } if {![info exists TabTmp($Pop,$GO)]} { set TabTmp($Pop,$GO) 1 lappend Tab($Pop,LesGO) $GO } set Tab($GO,Info) "$GO\t$Type\t$Niv\t$Def" set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore) $Zscore set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,r) $r #Espionne "r: [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,r)]" set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,R) $R set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,n) $n set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,N) $N } close $F foreach Pop [set Tab(LesPop)] { set Tab($Pop,LeTexte) {} set Tab($Pop,Entete) [list GO Type Level Definition Population] foreach Cluster [set Tab($Pop,LesClusters)] { lappend Tab($Pop,Entete) "$Cluster Zscore r R n N" } lappend Tab($Pop,Entete) "ZscoreMax" set Tab($Pop,Entete) [join [set Tab($Pop,Entete)] "\t"] } foreach Pop [set Tab(LesPop)] { foreach GO [set Tab($Pop,LesGO)] { set Info [set Tab($GO,Info)] set ZscoreMax -1e200 set LaLigne [list $Info] lappend LaLigne $Pop foreach Cluster [set Tab($Pop,LesClusters)] { if {![info exists Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore)]} { set Zscore "" } else { set Zscore [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore)] if {$ZscoreMax < $Zscore} {set ZscoreMax $Zscore} lappend LaLigne $Zscore ###################################################################################### # 20050429 # J'en suis la, cette info n'existe pas, je ne sais pas pourquoi!!!!!!!!!!!!!!!!! ###################################################################################### set r [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,r)] lappend LaLigne $r set R [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,R)] lappend LaLigne $R set n [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,n)] lappend LaLigne $n set N [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore,$Zscore,N)] lappend LaLigne $N } } lappend LaLigne $ZscoreMax lappend Tab($Pop,LeTexte) $LaLigne } set LeTexte {} lappend LeTexte [set Tab($Pop,Entete)] foreach LaLigne [lsort -decreasing -real -index end [set Tab($Pop,LeTexte)]] { set Ligne [join $LaLigne "\t"] #Espionne $Ligne lappend LeTexte $Ligne } set Texte [join $LeTexte "\n"] regsub -all {\.} $Texte "," Texte Sauve $Texte dans "$FichierRecapitulatifGODesClusters.$Pop" } return } proc FichierRecapitulatifDesZscoreDesGODesClusters_PO_OLD {FichierRecapitulatifGODesClusters} { if {![file exists $FichierRecapitulatifGODesClusters]} {return} set Tab(LesGO) {} set Tab(LesClusters) {} set Tab(LesPop) {} set F [open $FichierRecapitulatifGODesClusters] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Cluster [lindex $LaLigne 0] set Pop [lindex $LaLigne 1] set GO [lindex $LaLigne 2] set Type [lindex $LaLigne 3] set Niv [lindex $LaLigne 4] set Def [lindex $LaLigne 5] set Zscore [lindex $LaLigne 6] regsub {\,} $Zscore "." Zscore regsub {^Cluster } $Cluster "" Cluster set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster if {![info exists TabTmp($Cluster)]} { set TabTmp($Cluster) 1 lappend Tab(LesClusters) $Cluster } regsub {^Pop } $Pop "" Pop if {$Pop == "HumanProteome"} { set Pop "${Pop}_$BigCluster" } if {![info exists Tab($Pop,LesClusters)]} { set Tab($Pop,LesClusters) {} set Tab($Pop,LesGO) {} lappend Tab(LesPop) $Pop } if {![info exists TabTmp($Pop,$Cluster)]} { set TabTmp($Pop,$Cluster) 1 lappend Tab($Pop,LesClusters) $Cluster } if {![info exists TabTmp($Pop,$GO)]} { set TabTmp($Pop,$GO) 1 lappend Tab($Pop,LesGO) $GO } set Tab($GO,Info) "$GO\t$Type\t$Niv\t$Def" set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore) $Zscore } close $F foreach Pop [set Tab(LesPop)] { set Tab($Pop,LeTexte) {} set Tab($Pop,Entete) [list GO Type Level Definition Population] foreach Cluster [set Tab($Pop,LesClusters)] { lappend Tab($Pop,Entete) "$Cluster Zscore" } lappend Tab($Pop,Entete) "ZscoreMax" set Tab($Pop,Entete) [join [set Tab($Pop,Entete)] "\t"] } foreach Pop [set Tab(LesPop)] { foreach GO [set Tab($Pop,LesGO)] { set Info [set Tab($GO,Info)] set ZscoreMax -1e200 set LaLigne [list $Info] lappend LaLigne $Pop foreach Cluster [set Tab($Pop,LesClusters)] { if {![info exists Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore)]} { set Zscore "" } else { set Zscore [set Tab($GO,Cluster,$Cluster,Pop,$Pop,Zscore)] if {$ZscoreMax < $Zscore} {set ZscoreMax $Zscore} } lappend LaLigne $Zscore } lappend LaLigne $ZscoreMax lappend Tab($Pop,LeTexte) $LaLigne } set LeTexte {} lappend LeTexte [set Tab($Pop,Entete)] foreach LaLigne [lsort -decreasing -real -index end [set Tab($Pop,LeTexte)]] { set Ligne [join $LaLigne "\t"] Espionne $Ligne lappend LeTexte $Ligne } set Texte [join $LeTexte "\n"] regsub -all {\.} $Texte "," Texte Sauve $Texte dans "$FichierRecapitulatifGODesClusters.$Pop" } return } proc FichierRecapitulatifGODesClusters_PO {FichierOUT {nMin 3} {ZscoreMin 1} {NivMin 3} {RapportEntreNbIndivEtTaillePopMin 0.05}} { set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierGOProteo "[GODBDir]/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" Espionne "Populations des clusters" set Tab(LesNoms) {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set Tab(Cluster,$Cluster,LesIndividusGO) {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $Cluster LesNoms] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 lappend Tab(LesNoms) $Nom foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} set LIndividu [lsort -unique $LIndividu] lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu } } Espionne "OK" if {[info exists TabDeJaVu]} {unset TabDeJaVu} set LesBigClusters {} Espionne "Populations totales selectionnees" foreach Nom [set Tab(LesNoms)] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster if {![info exists TabLesIndividusGODeLaPop($BigCluster)]} { set TabLesIndividusGODeLaPop($BigCluster) {} } if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu != {}} { set LIndividu [lsort -unique $LIndividu] lappend TabLesIndividusGODeLaPop($BigCluster) $LIndividu } } Espionne "OK" Espionne "Lecture Du FichierGO du Proteome" #Gene Ontology du proteome humain##### set LesIndividusGODeLaPop2 {} foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu] } Espionne "OK" Espionne "Calcul" set LeTexte {} set LeTexteRed {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)] set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster ###GO GO GO GO################ set LesIndividusGODeLaPop [set TabLesIndividusGODeLaPop($BigCluster)] foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop] { set GO [lindex $LeGO 0] set Z [lindex $LeGO 1] set r [lindex $LeGO 2] set R [lindex $LeGO 3] set n [lindex $LeGO 4] set N [lindex $LeGO 5] set Stat [join [lrange $LeGO 1 end] "\t"] set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] if {$r <= 0 || $n <= 0} {continue} set Ligne "Cluster $Cluster\tPop $BigCluster\t$GO\t$Type\t$Niv\t$Def\t$r\t$R\t$n\t$N\t$Stat" lappend LeTexte $Ligne if {$NivMin <= $Niv && $RapportEntreNbIndivEtTaillePopMin <= [expr $r * 1.0 / $R] && $nMin <= $n && $ZscoreMin <= $Z} { #Espionne $Ligne lappend LeTexteRed $Ligne } } foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] { set GO [lindex $LeGO 0] set Z [lindex $LeGO 1] set r [lindex $LeGO 2] set R [lindex $LeGO 3] set n [lindex $LeGO 4] set N [lindex $LeGO 5] set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] if {$r <= 0 || $n <= 0} {continue} set Ligne "Cluster $Cluster\tPop HumanProteome\t$GO\t$Type\t$Niv\t$Def\t$r\t$R\t$n\t$N\t$Stat" lappend LeTexte $Ligne if {$NivMin <= $Niv && $RapportEntreNbIndivEtTaillePopMin <= [expr $r * 1.0 / $R] && $nMin <= $n && $ZscoreMin <= $Z} { #Espionne $Ligne lappend LeTexteRed $Ligne } } } Espionne "OK" set Texte [join $LeTexte "\n"] regsub -all {\.} $Texte "," Texte SaveInFile $Texte $FichierOUT set Texte [join $LeTexteRed "\n"] regsub -all {\.} $Texte "," Texte SaveInFile $Texte "$FichierOUT.red" FichierRecapitulatifDesZscoreDesGODesClusters_PO $FichierOUT FichierRecapitulatifDesZscoreDesGODesClusters_PO "$FichierOUT.red" return } proc FichierRecapitulatifGODesClusters_PO_OLD {FichierOUT} { set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierGOProteo "[GODBDir]/GeneOntology_HUMAN" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set NivMin 3 set RapportEntreNbIndivEtTaillePopMin 0.05 #set nMin 10 set nMin 3 #set ZscoreMin 1 set ZscoreMin 1 Espionne "Populations des clusters" set Tab(LesNoms) {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set Tab(Cluster,$Cluster,LesIndividusGO) {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $Fichier Cluster $Cluster LesNoms] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 lappend Tab(LesNoms) $Nom foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} set LIndividu [lsort -unique $LIndividu] lappend Tab(Cluster,$Cluster,LesIndividusGO) $LIndividu } } Espionne "OK" if {[info exists TabDeJaVu]} {unset TabDeJaVu} set LesBigClusters {} Espionne "Populations totales selectionnees" foreach Nom [set Tab(LesNoms)] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster if {![info exists TabLesIndividusGODeLaPop($BigCluster)]} { set TabLesIndividusGODeLaPop($BigCluster) {} } if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} #####GO GO GO GO######################################## set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu != {}} { set LIndividu [lsort -unique $LIndividu] lappend TabLesIndividusGODeLaPop($BigCluster) $LIndividu } } Espionne OK Espionne "Lecture Du FichierGO du Proteome" #Gene Ontology du proteome humain##### set LesIndividusGODeLaPop2 {} foreach GeneProteo [lsort -unique [InterrogeGeneOntology $FichierGOProteo LesNoms]] { set LIndividu {} foreach GO [InterrogeGeneOntology $FichierGOProteo $GeneProteo LesGO] { lappend LIndividu $GO foreach GOAncetre [InterrogeGeneOntology $FichierGOProteo GO $GO LesAncetres] { lappend LIndividu $GOAncetre } } if {$LIndividu == {}} {continue} lappend LesIndividusGODeLaPop2 [lsort -unique $LIndividu] } Espionne "OK" Espionne "Calcul" set LeTexte {} set LeTexteRed {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier LesClusters] { set LesIndividusGO [set Tab(Cluster,$Cluster,LesIndividusGO)] set BigCluster "" regexp -nocase {^([^_]+)_} $Cluster tmp BigCluster ###GO GO GO GO################ set LesIndividusGODeLaPop [set TabLesIndividusGODeLaPop($BigCluster)] foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop] { set GO [lindex $LeGO 0] set Z [lindex $LeGO 1] set r [lindex $LeGO 2] set R [lindex $LeGO 3] set n [lindex $LeGO 4] set N [lindex $LeGO 5] set Stat [join [lrange $LeGO 1 end] "\t"] set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] if {$r <= 0 || $n <= 0} {continue} set Ligne "Cluster $Cluster\tPop $BigCluster\t$GO\t$Type\t$Niv\t$Def\t$Stat" lappend LeTexte $Ligne if {$NivMin <= $Niv && $RapportEntreNbIndivEtTaillePopMin <= [expr $r * 1.0 / $R] && $nMin <= $n && $ZscoreMin <= $Z} { Espionne $Ligne lappend LeTexteRed $Ligne } } foreach LeGO [LesZscoreDesRequetesDuGroupe $LesIndividusGO $LesIndividusGODeLaPop2] { set GO [lindex $LeGO 0] set Z [lindex $LeGO 1] set r [lindex $LeGO 2] set R [lindex $LeGO 3] set n [lindex $LeGO 4] set N [lindex $LeGO 5] set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] set Niv [lindex [GODB Type $Type GO $GO LesNiveaux ] 0] set Stat [join [lrange $LeGO 1 end] "\t"] if {$r <= 0 || $n <= 0} {continue} set Ligne "Cluster $Cluster\tPop HumanProteome\t$GO\t$Type\t$Niv\t$Def\t$Stat" lappend LeTexte $Ligne if {$NivMin <= $Niv && $RapportEntreNbIndivEtTaillePopMin <= [expr $r * 1.0 / $R] && $nMin <= $n && $ZscoreMin <= $Z} { Espionne $Ligne lappend LeTexteRed $Ligne } } } Espionne "OK" set Texte [join $LeTexte "\n"] regsub -all {\.} $Texte "," Texte Sauve $Texte dans $FichierOUT set Texte [join $LeTexteRed "\n"] regsub -all {\.} $Texte "," Texte Sauve $Texte dans "$FichierOUT.red" FichierRecapitulatifDesZscoreDesGODesClusters_PO $FichierOUT FichierRecapitulatifDesZscoreDesGODesClusters_PO "$FichierOUT.red" return } proc FichierRecapitulatifPourTous {{LesNoms ""} {IdMin 0.8} {IdMax 0.95}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set RepRecap "[RepertoireDuGenome]/BilanHTML" if {![file exists $RepRecap]} {File mkdir $RepRecap} set Keep 0 if {[OuiOuNon "If some file exists in $RepRecap, Do you want to conserv them?"]} {set Keep 1} set LeTexteIndex {} foreach Nom $LesNoms { Espionne $Nom if {[file exists "$RepRecap/$Nom.html"] && $Keep} {continue} Espionne "$Nom -> Bilan" FichierRecapitulatif $Nom $IdMin $IdMax Espionne "$Nom -> Bilan done" } return } proc FichierRecapitulatifRedondanceDesProteinesInterClusters_PO {FichierOUT} { ####ATTENTION La redondance est calculee par rapport au nombre de proteines identifiees dans le cluster #### et non pas par rapport au nombre de sequences dans ce cluster set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set LesNoms [lsort -unique [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms]] set LesClusters [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] foreach C1 $LesClusters { foreach C2 $LesClusters { set Tab($C1,$C2) 0 } } set RepProttfa "[RepertoireDuGenome]/prottfa" foreach Nom $LesNoms { if {![file exists "$RepProttfa/$Nom"]} {continue} Espionne $Nom set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] #Elimine les redondances des jumeaux dans 1 cluster donne if {[info exists TabTmp($Cluster,$Nom)]} {continue} set TabTmp($Cluster,$Nom) 1 incr Tab($Cluster,$Cluster) foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] { set ClusterJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster] if {$ClusterJum == $Cluster} {set TabTmp($Cluster,$Jum) 1;continue} #Elimine les redondances dans les autres clusters avec lesquels le cluster etudie se compare if {[info exists TabTmp($Cluster,$Nom,$ClusterJum)]} {continue} set TabTmp($Cluster,$Nom,$ClusterJum) 1 incr Tab($Cluster,$ClusterJum) } } set LeTexte {} set LaLigne {} lappend LaLigne "Cluster" foreach Cluster $LesClusters {lappend LaLigne $Cluster} lappend LeTexte [join $LaLigne "\t"] set LeTexteP {} set LaLigneP {} lappend LaLigneP "Cluster" foreach Cluster $LesClusters {lappend LaLigneP $Cluster} lappend LeTexteP [join $LaLigneP "\t"] set LeTexteP2 {} set LaLigneP2 {} lappend LaLigneP2 "Cluster" foreach Cluster $LesClusters {lappend LaLigneP2 $Cluster} lappend LeTexteP2 [join $LaLigneP2 "\t"] foreach C1 $LesClusters { set NTot [set Tab($C1,$C1)] set LaLigne {} set LaLigneP {} set LaLigneP2 {} lappend LaLigne $C1 lappend LaLigneP $C1 lappend LaLigneP2 $C1 foreach C2 $LesClusters { set NTot2 [set Tab($C2,$C2)] set n [set Tab($C1,$C2)] lappend LaLigne $n lappend LaLigneP [format "%.2f" [expr $n * 100.0 / $NTot ]] lappend LaLigneP2 [format "%.2f" [expr $n * 100.0 / ($NTot + $NTot2 - $n)]] } lappend LeTexte [join $LaLigne "\t"] lappend LeTexteP [join $LaLigneP "\t"] lappend LeTexteP2 [join $LaLigneP2 "\t"] } if {$LeTexte == {}} {return} set Texte [join $LeTexte "\n"] set TexteP [join $LeTexteP "\n"] set TexteP2 [join $LeTexteP2 "\n"] regsub -all {\.} $TexteP "," TexteP regsub -all {\.} $TexteP2 "," TexteP2 Sauve "$Texte\n\n\n$TexteP\n\n\n$TexteP2" dans $FichierOUT return } proc FichierRecapitulatifTau {} { set Ligne "GI;ProteinNameFromRam;AccessionNumber;ProteinIDPoulet;PreferredNamePoulet;ProteinIDHomme;PreferredNameHomme;ProteinIDMouse;PreferredNameMouse" lappend LesLignes $Ligne Espionne "$LesLignes" foreach GI [InterrogeListTau ListOf GI] { set ProteinName [InterrogeListTau $GI Name] set GetzOutpdb ""; set GetzOut ""; set SeqGbTfa ""; set TfaProt "" set Access [InterrogeSortieNcbi $GI Access] set DB [InterrogeSortieNcbi $GI DB] if {[regexp "pdb" $DB]} { set FichierRequete "/genomics/link/Tau/GSTRdCVF/entreepdb.bql" set FichierSortie "/genomics/link/Tau/GSTRdCVF/sortiepdb.txt" set Elmt [split $Access "_"] set accesspdb [lindex $Elmt 0] set chain [lindex $Elmt 1] lappend LesLignesBird "ID * DB PDB" lappend LesLignesBird "WH SQLNATIVE SELECT distinct dr.dbaccession from pdb.header as h , pdb.dbref as dr where h.idcode='$accesspdb' and dr.chainid='$chain' and h.oid=dr.key_fk" lappend LesLignesBird "FM CSV" SauveLesLignes $LesLignesBird dans $FichierRequete BirdForceHoan $FichierRequete $FichierSortie foreach LigneFic [LesLignesDuFichier $FichierSortie] { if {[regexp "Query" $LigneFic]} {continue} set NvAcc $LigneFic } set FichierTfaPoulet "/genomics/link/Tau/GSTRdCVF/BlastpSurStringPoulet/fastaquery/$NvAcc" set PIDPoulet [BlastPStringMoi $FichierTfaPoulet 9031] set PNPoulet [PreferedNameStringFromProteins $PIDPoulet] set FichierTfaHomme "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/fastaquery/$NvAcc" set PIDHomme [BlastPStringMoi $FichierTfaHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaMouse "/genomics/link/Tau/GSTRdCVF/BlastpSurStringMouse/fastaquery/$NvAcc" set PIDMouse [BlastPStringMoi $FichierTfaMouse 10090] set PNMouse [PreferedNameStringFromProteins $PIDMouse] set Ligne "$GI;$ProteinName;$Access/$NvAcc;$PIDPoulet;$PNPoulet;$PIDHomme;$PNHomme;$PIDMouse;$PNMouse" lappend LesLignes $Ligne } else { set FichierTfaPoulet "/genomics/link/Tau/GSTRdCVF/BlastpSurStringPoulet/fastaquery/$Access" set PIDPoulet [BlastPStringMoi $FichierTfaPoulet 9031] set PNPoulet [PreferedNameStringFromProteins $PIDPoulet] set FichierTfaHomme "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/fastaquery/$Access" set PIDHomme [BlastPStringMoi $FichierTfaHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaMouse "/genomics/link/Tau/GSTRdCVF/BlastpSurStringMouse/fastaquery/$Access" set PIDMouse [BlastPStringMoi $FichierTfaMouse 10090] set PNMouse [PreferedNameStringFromProteins $PIDMouse] set Ligne "$GI;$ProteinName;$Access;$PIDPoulet;$PNPoulet;$PIDHomme;$PNHomme;$PIDMouse;$PNMouse" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "/genomics/link/Tau/GSTRdCVF/FichierRecapitulatif.txt" } proc FichierRecapitulatifTotal_PO {FichierOUT} { #Nom Cluster JumMemeCluster nJumMemeCluster JumClust2 nJumClust2 JumClust3 nJumClust3 .... DefIni Loc Tissue DS Methode MeanDef GeneName GO set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set NbTissuesEtDSMax 10 set NbGeneNameMax 5 set LesClusters [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] set LesNoms [lsort -unique [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms ]] foreach Cluster $LesClusters {set Tab(Cluster,$Cluster,LesNomsDeRef) {}} foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] if {[info exists TabTmp($Nom)]} {continue} if {![info exists Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles)]} { set TabTmp($Nom) 1 ###INI### set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) 0 foreach Clust $LesClusters { set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$Clust) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$Clust) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$Clust) 0 } ######### lappend Tab(Cluster,$Cluster,LesNomsDeRef) $Nom incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$Cluster) incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) } foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] { if {$Nom == $Jum} {continue} set ClusterJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster] set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Access ] if {$Cluster == $ClusterJum} {set TabTmp($Jum) 1} lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$ClusterJum) $AccIni lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$ClusterJum) $Jum lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles) $Jum incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$ClusterJum) incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) } } if {[info exists TabTmp]} {unset TabTmp} set LesAccess {} foreach Cluster $LesClusters { foreach Nom [set Tab(Cluster,$Cluster,LesNomsDeRef)] { set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} set LaLigne [list GScopeID Cluster ID HumanLoc Tissues DevStages Method ProtID Organism Definition MeanDefinition GeneNames "GO Process" "GO Function" "GO Component"] foreach ClusterJum $LesClusters { lappend LaLigne "Cluster $ClusterJum Twins" "Cluster $ClusterJum TwinsID" "Cluster $ClusterJum NbTwins" } lappend LaLigne "Total Twins" "Total NbTwins" lappend LeTexte [join $LaLigne "\t"] #Espionne "Lecture du Fichier $FichierGO" foreach Cluster $LesClusters { foreach Nom [set Tab(Cluster,$Cluster,LesNomsDeRef)] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] #set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] set LesJumelles [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$Cluster)] lappend LesJumelles $Nom ####EST########################## set LesTissues {} set LesDS {} foreach Jum $LesJumelles { foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Jum LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Jum TissueType $Tissue n] if {![info exists TabTmp($Nom,$Tissue,n)]} { set TabTmp($Nom,$Tissue,n) 0 lappend LesTissues $Tissue } incr TabTmp($Nom,$Tissue,n) $n } foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Jum LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Jum DevStage $DS n] if {![info exists TabTmp($Nom,$DS,n)]} { set TabTmp($Nom,$DS,n) 0 lappend LesDS $DS } incr TabTmp($Nom,$DS,n) $n } } set LesTissuesAvecEffectifs {} foreach Tissue $LesTissues { set n [set TabTmp($Nom,$Tissue,n)] lappend LesTissuesAvecEffectifs [list "$Tissue ($n)" $n] } set LesDSAvecEffectifs {} foreach DS $LesDS { set n [set TabTmp($Nom,$DS,n)] lappend LesDSAvecEffectifs [list "$DS ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissuesAvecEffectifs] { incr i if {$i > $NbTissuesEtDSMax} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDSAvecEffectifs] { incr i if {$i > $NbTissuesEtDSMax} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] foreach Def [LaDefinitionDeLaProt_PageInfo $PI] { set Def [string trim $Def] if {$Def == ""} {continue} lappend LesDef $Def } foreach Orga [LesOrgasDeLaPage_PageInfo $PI] { set Orga [string trim $Orga] lappend LesOrgas $Orga } lappend LesAcc $AccessProche } set Acc [join $LesAcc ";"] set Def [join [lsort -unique $LesDef ] ";"] set Orgas [join [lsort -unique $LesOrgas] ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i if {$i > $NbGeneNameMax} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## set LesGOProcess {} set LesGOFunction {} set LesGOComponent {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] if {$Type == "function" } {lappend LesGOFunction $DefGO} if {$Type == "process" } {lappend LesGOProcess $DefGO} if {$Type == "component"} {lappend LesGOComponent $DefGO} } set GOProcess [join $LesGOProcess ";"] set GOFunction [join $LesGOFunction ";"] set GOComponent [join $LesGOComponent ";"] ####LOCALISATION####################### set LesLoc {} foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] set LaLigne [list $Nom $Cluster $AccIni $Loc $Tissues $DS $Methode $Acc $Orgas $Def $MeanDef $GN $GOProcess $GOFunction $GOComponent] foreach ClusterJum $LesClusters { set AccIni [join [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$ClusterJum)] ";"] set Jum [join [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$ClusterJum)] ";"] set n [set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$ClusterJum)] lappend LaLigne $Jum $AccIni $n } set Jum [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles)] set n [set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles)] lappend LaLigne $Jum $n set Ligne [join $LaLigne "\t"] regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierRecapitulatifTotal_RSEtUG_Affy {FichierOUT} { Wup "Creation d un fichier recapitulatif pour les projet Morphine et Marker" Wup "Utilisation du fichier BilanRecapitulatifTotal, Annotation Affymetrix de la puce en question Mouse430_2" #Nom Cluster JumMemeCluster nJumMemeCluster JumClust2 nJumClust2 JumClust3 nJumClust3 .... DefIni Loc Tissue DS Methode MeanDef GeneName GO set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set NbTissuesEtDSMax 10 set NbGeneNameMax 5 set LesClusters [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] set LesNoms [lsort -unique [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms ]] foreach Cluster $LesClusters { set Tab(Cluster,$Cluster,LesNomsDeRef) {} } foreach Nom $LesNoms { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] lappend Tab(Cluster,$Cluster,LesNomsDeRef) $Nom if {[info exists TabTmp($Nom)]} {continue} if {![info exists Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles)]} { set TabTmp($Nom) 1 ###INI### set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) 0 foreach Clust $LesClusters { set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$Clust) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$Clust) {} set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$Clust) 0 } ######### #lappend Tab(Cluster,$Cluster,LesNomsDeRef) $Nom incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$Cluster) incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) } foreach Jum [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles] { if {$Nom == $Jum} {continue} set ClusterJum [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Cluster] set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Jum Access ] if {$Cluster == $ClusterJum} {set TabTmp($Jum) 1} lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$ClusterJum) $AccIni lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$ClusterJum) $Jum lappend Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles) $Jum incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$ClusterJum) incr Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles) } } if {[info exists TabTmp]} {unset TabTmp} Espionne "$LesNoms" Espionne "[llength $LesNoms]" foreach Cluster $LesClusters { Espionne "[lsort [set Tab(Cluster,$Cluster,LesNomsDeRef)]]" Espionne "[llength [set Tab(Cluster,$Cluster,LesNomsDeRef)]]" } set LesAccess {} foreach Cluster $LesClusters { foreach Nom [set Tab(Cluster,$Cluster,LesNomsDeRef)] { set Methode "Protein" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { if {$AccessmRNA != "NOMRNA" && $AccessmRNA != ""} { set Methode "mRNA" set AccessProt $AccessmRNA } else { set Methode "Contig" set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt == "NOPROTEIN" || $AccessProt == ""} { set AccessProt "" set Methode "NoProtein" } } } if {$AccessProt != "" && ![info exists TabTmp($AccessProt)]} { set TabTmp($AccessProt) 1 lappend LesAccess $AccessProt } set Tab($Nom,Access) $AccessProt set Tab($Nom,Methode) $Methode set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set NameQueryProt "QUERY_PROTEIN" set Id 0.98 set LesAccessProches [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $NameQueryProt $Id] Espionne "\n$Nom\n$LesAccessProches" set Tab($Nom,LesAccessProches) {} foreach AccessProt $LesAccessProches { set TabTmp($AccessProt) 1 lappend Tab($Nom,LesAccessProches) $AccessProt lappend LesAccess $AccessProt } AskMSF $FichierMSF unset } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} set LaLigne [list GScopeID Cluster ID "Affymetrix initial Def" "Affymetrix Def" HumanLoc Tissues DevStages RefSeq RefSeqDefinition Unigene Uniseq UnigeneDefinition "RS UG Twins" Method ProtID Organism Definition MeanDefinition GeneNames "GO Process" "GO Function" "GO Component"] foreach ClusterJum $LesClusters { lappend LaLigne "Cluster $ClusterJum Twins" "Cluster $ClusterJum TwinsID" "Cluster $ClusterJum NbTwins" } lappend LaLigne "Total Twins" "Total NbTwins" lappend LeTexte [join $LaLigne "\t"] #Espionne "Lecture du Fichier $FichierGO" foreach Cluster $LesClusters { foreach Nom [set Tab(Cluster,$Cluster,LesNomsDeRef)] { set AccIni [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access ] #set DefIni [join [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] ""] #MODIF JEAN if {[info exists Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$Cluster)]} { set LesJumelles [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$Cluster)] lappend LesJumelles $Nom } else { set LesJumelles $Nom } ####EST########################## set LesTissues {} set LesDS {} foreach Jum $LesJumelles { foreach Tissue [InterrogeSelectedEST $FichierSelectedEST Nom $Jum LesTissueType] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Jum TissueType $Tissue n] if {![info exists TabTmp($Nom,$Tissue,n)]} { set TabTmp($Nom,$Tissue,n) 0 lappend LesTissues $Tissue } incr TabTmp($Nom,$Tissue,n) $n } foreach DS [InterrogeSelectedEST $FichierSelectedEST Nom $Jum LesDevStage] { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Jum DevStage $DS n] if {![info exists TabTmp($Nom,$DS,n)]} { set TabTmp($Nom,$DS,n) 0 lappend LesDS $DS } incr TabTmp($Nom,$DS,n) $n } } set LesTissuesAvecEffectifs {} foreach Tissue $LesTissues { set n [set TabTmp($Nom,$Tissue,n)] lappend LesTissuesAvecEffectifs [list "$Tissue ($n)" $n] } set LesDSAvecEffectifs {} foreach DS $LesDS { set n [set TabTmp($Nom,$DS,n)] lappend LesDSAvecEffectifs [list "$DS ($n)" $n] } set LesTissuesDefinitifs {} set i 0 foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissuesAvecEffectifs] { incr i if {$i > $NbTissuesEtDSMax} {break} lappend LesTissuesDefinitifs [lindex $LeTissue 0] } set Tissues [join $LesTissuesDefinitifs ";"] set LesDSDefinitifs {} set i 0 foreach LeDS [lsort -index 1 -decreasing -integer $LesDSAvecEffectifs] { incr i if {$i > $NbTissuesEtDSMax} {break} lappend LesDSDefinitifs [lindex $LeDS 0] } set DS [join $LesDSDefinitifs ";"] ####PROT############################# set Methode [set Tab($Nom,Methode)] set Def "" set Orgas "" set Acc [set Tab($Nom,Access)] if {$Acc != ""} { set PI [AskLesPagesInfos ask $Acc] set Def [string trim [join [LaDefinitionDeLaProt_PageInfo $PI] ";"]] set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] } if {$Def == ""} { if {$Acc != ""} {lappend LesAcc $Acc} set LesAcc {} set LesDef {} set LesOrgas {} set Methode "ClosestProt" foreach AccessProche [lsort -unique [set Tab($Nom,LesAccessProches)]] { set PI [AskLesPagesInfos ask $AccessProche] foreach Def [LaDefinitionDeLaProt_PageInfo $PI] { set Def [string trim $Def] if {$Def == ""} {continue} lappend LesDef $Def } foreach Orga [LesOrgasDeLaPage_PageInfo $PI] { set Orga [string trim $Orga] lappend LesOrgas $Orga } lappend LesAcc $AccessProche } set Acc [join $LesAcc ";"] set Def [join [lsort -unique $LesDef ] ";"] set Orgas [join [lsort -unique $LesOrgas] ";"] } ###DefinitionMoyenne##### set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i if {$i > $NbGeneNameMax} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName ";"] ####GO########## set LesGOProcess {} set LesGOFunction {} set LesGOComponent {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] if {$Type == "function" } {lappend LesGOFunction $DefGO} if {$Type == "process" } {lappend LesGOProcess $DefGO} if {$Type == "component"} {lappend LesGOComponent $DefGO} } set GOProcess [join $LesGOProcess ";"] set GOFunction [join $LesGOFunction ";"] set GOComponent [join $LesGOComponent ";"] ####LOCALISATION####################### set LesLoc {} foreach Loc [InterrogeLocalisation $FichierLoc Nom $Nom] { set Info [lindex $Loc 1 ] if {![regexp -nocase {MayBePolyLoc|PolyLoc|MonoLoc} $Info]} {continue} set InfoBest [lindex $Loc 20] if {![regexp -nocase "best" $InfoBest]} {continue} set LesBC {} foreach BC [split [lindex $Loc 19] " "] {lappend LesBC $BC} set Chrom [lindex $Loc 9] set Deb [Mini [lindex $Loc 10] [lindex $Loc 11]] set Fin [Maxi [lindex $Loc 10] [lindex $Loc 11]] set Sens [lindex $Loc 12] lappend LesLoc "$Chrom [join $LesBC " "] $Deb $Fin $Sens" } set Loc [join $LesLoc ";"] #### REFSEQ et UNIGENE set LesAccRefSeq [InterrogeLesAccRSEtUG_Affymetrix $Nom AccRefSeq] set DefRefSeq [InterrogeLesAccRSEtUG_Affymetrix $Nom DefRefSeq] set LesAccUnigene [InterrogeLesAccRSEtUG_Affymetrix $Nom AccUnigene] set LesAccUniseq [InterrogeLesAccRSEtUG_Affymetrix $Nom AccUniseq] set DefUnigene [InterrogeLesAccRSEtUG_Affymetrix $Nom DefUniseq] #Espionne "$Nom -- $LesAccRefSeq $DefRefSeq $LesAccUnigene $LesAccUniseq $DefUnigene" set OriDefAffy "" set DefAffy "" set OriDefAffy [InterrogeOriginalAnnotAffymetrix Mouse430_2 $AccIni "Gene Title"] set DefAffy [InterrogeLesAnnotAffymetrix Mouse430_2 $AccIni "Gene Title"] set JumeauRSetUG [JumeauLesAccRSEtUG_Affymetrix $Nom LesPAB] if { $JumeauRSetUG == ""} { set JumeauRSetUG "None" } ###################### set LaLigne [list $Nom $Cluster $AccIni $OriDefAffy $DefAffy $Loc $Tissues $DS $LesAccRefSeq $DefRefSeq $LesAccUnigene $LesAccUniseq $DefUnigene $JumeauRSetUG $Methode $Acc $Orgas $Def $MeanDef $GN $GOProcess $GOFunction $GOComponent] #MODIF JEAN if {[info exists Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles)]} { foreach ClusterJum $LesClusters { set AccIni [join [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesAccIniDesJumellesDuCluster,$ClusterJum)] ";"] set Jum [join [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumellesDuCluster,$ClusterJum)] ";"] set n [set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumellesDuCluster,$ClusterJum)] lappend LaLigne $Jum $AccIni $n } set Jum [set Tab(Cluster,$Cluster,NomDeRef,$Nom,LesJumelles)] set n [set Tab(Cluster,$Cluster,NomDeRef,$Nom,NbJumelles)] lappend LaLigne $Jum $n } set Ligne [join $LaLigne "\t"] regsub -all ";" $Ligne " ; " Ligne Espionne $Ligne lappend LeTexte $Ligne } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierRecapitulatifTp180 {} { set Ligne "Box;Name;ProteinIDHomme;PreferredNameHomme;ProteinIDLevure;PreferredNameLevure" lappend LesLignes $Ligne set FichierDesSelectionnes "[RepertoireDuGenome]/string/YesScNoTb.tfa" foreach Ligne [LesLignesDuFichier $FichierDesSelectionnes] { if {[regexp "^TP" $Ligne]} { set Box [lindex [split $Ligne " "] 0] set Name [InfHomolog $Box infogetlocus] set FichierTfaHomme "[RepertoireDuGenome]/prottfa/$Box" set FichierOutHomme "[RepertoireDuGenome]/string/BlastpSurStringHomme/resultblast/$Box.blastp" set PIDHomme [BlastPStringGeneral $FichierTfaHomme $FichierOutHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaLevure [InfHomolog $Box filename] set FichierOutLevure "[RepertoireDuGenome]/string/BlastpSurStringLevure/resultblast/$Box.blastp" set PIDLevure [BlastPStringGeneral $FichierTfaLevure $FichierOutLevure 4932] set PNLevure [PreferedNameStringFromProteins $PIDLevure] set Ligne "$Box;$Name;$PIDHomme;$PNHomme;$PIDLevure;$PNLevure" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/string/FichierRecapitulatif.txt" } proc FichierRecapitulatifTp80 {} { set Ligne "Box;Name;ProteinIDHomme;PreferredNameHomme;ProteinIDLevure;PreferredNameLevure" lappend LesLignes $Ligne set FichierDesSelectionnes "[RepertoireDuGenome]/string/80/bilanP62.csv" foreach Ligne [LesLignesDuFichier $FichierDesSelectionnes] { set LesMotsDeLaLigne [split $Ligne ";"] set Box [lindex $LesMotsDeLaLigne 2] if {![regexp "^TP" $Box]} {continue} set Name [InfHomolog $Box infogetlocus] set FichierTfaHomme "[RepertoireDuGenome]/prottfa/$Box" set FichierOutHomme "[RepertoireDuGenome]/string/80/BlastpSurStringHomme/resultblast/$Box.blastp" set PIDHomme [BlastPStringGeneral $FichierTfaHomme $FichierOutHomme 9606] set PNHomme [PreferedNameStringFromProteins $PIDHomme] set FichierTfaLevure [InfHomolog $Box filename] set FichierOutLevure "[RepertoireDuGenome]/string/80/BlastpSurStringLevure/resultblast/$Box.blastp" set PIDLevure [BlastPStringGeneral $FichierTfaLevure $FichierOutLevure 4932] set PNLevure [PreferedNameStringFromProteins $PIDLevure] set Ligne "$Box;$Name;$PIDHomme;$PNHomme;$PIDLevure;$PNLevure" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/string/80/FichierRecapitulatif.txt" } proc FichierRepartitionDesBoitesSurGenome {{FichierLoc ""}} { set FichierOUT "[RepertoireDuGenome]/Localisation/RepartitionSurGenome" if {$FichierLoc == ""} {set FichierLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human"} set LesChromosomes [InterrogeBandesCytologiques LesChromosomes] set LeTexte {} foreach Chromosome $LesChromosomes { set Chromo [NumeroDuChromosome $Chromosome] set TailleChr [InterrogeContigsDesChromosomes $Chromo Taille] set LesNomsDuChromosome {} set JusteLesNomsDuChromosome {} foreach Nom [lsort -unique [InterrogeLocalisation $FichierLoc Chromosome $Chromosome LesNoms]] { if {$Nom == ""} {continue} foreach LaLoc [InterrogeLocalisation $FichierLoc Chromosome $Chromosome $Nom] { set Info [lindex $LaLoc 20] if {![string equal -nocase "BestLoc" $Info]} {continue} set DMin [Mini [lindex $LaLoc 10] [lindex $LaLoc 11]] set FMax [Maxi [lindex $LaLoc 10] [lindex $LaLoc 11]] lappend LesNomsDuChromosome [list $Nom $DMin $FMax] lappend JusteLesNomsDuChromosome $Nom } } ###Distribution sur le chromosome set TypeDeRegion "Chromosome" set Debut 1 set Fin $TailleChr set n [llength $LesNomsDuChromosome] Espionne "$Chromosome\t$TypeDeRegion\t$Chromosome\t$Debut\t$Fin\t$n\t[join $JusteLesNomsDuChromosome "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Chromosome\t$Debut\t$Fin\t$n\t[join $JusteLesNomsDuChromosome "\t"]" ####Distribution sur les cytoband##### set TypeDeRegion "CytoBand" set LesBandesP [lsort -unique -decreasing [InterrogeBandesCytologiques $Chromosome LesBandesP]] set LesBandesQ [lsort -unique -increasing [InterrogeBandesCytologiques $Chromosome LesBandesQ]] set Debut 1 foreach Bande [concat $LesBandesP $LesBandesQ] { set LesInfos [InterrogeBandesCytologiques $Chromosome $Bande] set Fin [lindex $LesInfos 0] set Fin [expr round($Fin * 1E6)] set TailleBande [expr round($Fin - $Debut + 1)] set LesNoms {} foreach LeNom $LesNomsDuChromosome { set Nom [lindex $LeNom 0] set DMin [lindex $LeNom 1] set FMax [lindex $LeNom 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesNoms $Nom } set n [llength $LesNoms] Espionne "$Chromosome\t$TypeDeRegion\t$Bande\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Bande\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" set Debut [expr $Fin + 1] } ###Distribution sur les contigs set TypeDeRegion "Contig" set LesNoms {} foreach Contig [InterrogeContigsDesChromosomes $Chromo LesContigs] { set LesInfos [InterrogeContigsDesChromosomes $Chromo $Contig] set Debut [Mini [lindex $LesInfos 0] [lindex $LesInfos 1]] set Fin [Maxi [lindex $LesInfos 0] [lindex $LesInfos 1]] set Sens [lindex $LesInfos 2] if {$Sens == 0} {continue} set LesNoms {} foreach LeNom $LesNomsDuChromosome { set Nom [lindex $LeNom 0] set DMin [lindex $LeNom 1] set FMax [lindex $LeNom 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesNoms $Nom } set n [llength $LesNoms] Espionne "$Chromosome\t$TypeDeRegion\t$Contig\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Contig\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" } ###Distribution sur Region de 1e6bp### set TypeDeRegion "1e6bp" set TailleRegion 1e6 set NbRegions [expr round (($TailleChr/$TailleRegion)-0.5)] set Reste [expr round($TailleChr) % round($TailleRegion)] set Area 0 set LesRegions {} set Debut 1 for {set i 1} {$i <= $NbRegions} {incr i} { incr Area set Fin [expr round($Debut + $TailleRegion - 1)] lappend LesRegions [list $Area $Debut $Fin] set Debut [expr $Fin + 1] } if {$Reste != 0} { incr Area lappend LesRegions [list $Area $Debut $TailleChr] } foreach LaRegion $LesRegions { set Area [lindex $LaRegion 0] set Debut [lindex $LaRegion 1] set Fin [lindex $LaRegion 2] set LesNoms {} foreach LeNom $LesNomsDuChromosome { set Nom [lindex $LeNom 0] set DMin [lindex $LeNom 1] set FMax [lindex $LeNom 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesNoms $Nom } set n [llength $LesNoms] Espionne "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" } ###Distribution sur Region de 1e7bp### set TypeDeRegion "1e7bp" set TailleRegion 1e7 set NbRegions [expr round (($TailleChr/$TailleRegion)-0.5)] set Reste [expr round($TailleChr) % round($TailleRegion)] set Area 0 set LesRegions {} set Debut 1 for {set i 1} {$i <= $NbRegions} {incr i} { incr Area set Fin [expr round($Debut + $TailleRegion - 1)] lappend LesRegions [list $Area $Debut $Fin] set Debut [expr $Fin + 1] } if {$Reste != 0} { incr Area lappend LesRegions [list $Area $Debut $TailleChr] } foreach LaRegion $LesRegions { set Area [lindex $LaRegion 0] set Debut [lindex $LaRegion 1] set Fin [lindex $LaRegion 2] set LesNoms {} foreach LeNom $LesNomsDuChromosome { set Nom [lindex $LeNom 0] set DMin [lindex $LeNom 1] set FMax [lindex $LeNom 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesNoms $Nom } set n [llength $LesNoms] Espionne "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesNoms "\t"]" } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierRepartitionDesGenesSurGenome {} { set FichierOUT "[HumanGenomeDir]/Localisation/RepartitionDesGenes" set NFLocus "seq_locus_tr.md" set LesChromosomes [InterrogeBandesCytologiques LesChromosomes] set LeTexte {} foreach Chromosome $LesChromosomes { set Chromo [NumeroDuChromosome $Chromosome] set TailleChr [InterrogeContigsDesChromosomes $Chromo Taille] set LesGenesDuChromosome {} foreach Gene [lsort -unique [InterrogeFichierMapViewer $NFLocus Chromosome $Chromo LesElements]] { if {$Gene == ""} {continue} set DMin "" set FMax "" set LesInfos [InterrogeFichierMapViewer $NFLocus Chromosome $Chromo Element $Gene LesLocalisations] foreach LInfo $LesInfos { set D [Mini [lindex $LInfo 3] [lindex $LInfo 4]] if {$DMin == ""} {set DMin $D} set F [Maxi [lindex $LInfo 3] [lindex $LInfo 4]] if {$FMax == ""} {set FMax $F} if {$D < $DMin} {set DMin $D} if {$FMax < $F } {set FMax $F} } if {$DMin == "" || $FMax == ""} {continue} lappend LesGenesDuChromosome [list $Gene $DMin $FMax] } ###Distribution sur le chromosome set TypeDeRegion "Chromosome" set Debut 1 set Fin $TailleChr set n [llength $LesGenesDuChromosome] Espionne "$Chromosome\t$TypeDeRegion\t$Chromosome\t$Debut\t$Fin\t$n\t[join $LesGenesDuChromosome "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Chromosome\t$Debut\t$Fin\t$n\t[join $LesGenesDuChromosome "\t"]" ####Distribution sur les cytoband##### set TypeDeRegion "CytoBand" set LesBandesP [lsort -unique -decreasing [InterrogeBandesCytologiques $Chromosome LesBandesP]] set LesBandesQ [lsort -unique -increasing [InterrogeBandesCytologiques $Chromosome LesBandesQ]] set Debut 1 foreach Bande [concat $LesBandesP $LesBandesQ] { set LesInfos [InterrogeBandesCytologiques $Chromosome $Bande] set Fin [lindex $LesInfos 0] set Fin [expr round($Fin * 1E6)] set TailleBande [expr round($Fin - $Debut + 1)] set LesGenes {} foreach LeGene $LesGenesDuChromosome { set Gene [lindex $LeGene 0] set DMin [lindex $LeGene 1] set FMax [lindex $LeGene 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesGenes $Gene } set n [llength $LesGenes] Espionne "$Chromosome\t$TypeDeRegion\t$Bande\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Bande\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" set Debut [expr $Fin + 1] } ###Distribution sur les contigs set TypeDeRegion "Contig" set LesGenes {} foreach Contig [InterrogeContigsDesChromosomes $Chromo LesContigs] { set LesInfos [InterrogeContigsDesChromosomes $Chromo $Contig] set Debut [Mini [lindex $LesInfos 0] [lindex $LesInfos 1]] set Fin [Maxi [lindex $LesInfos 0] [lindex $LesInfos 1]] set Sens [lindex $LesInfos 2] if {$Sens == 0} {continue} set LesGenes {} foreach LeGene $LesGenesDuChromosome { set Gene [lindex $LeGene 0] set DMin [lindex $LeGene 1] set FMax [lindex $LeGene 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesGenes $Gene } set n [llength $LesGenes] Espionne "$Chromosome\t$TypeDeRegion\t$Contig\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Contig\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" } ###Distribution sur Region de 1e6bp### set TypeDeRegion "1e6bp" set TailleRegion 1e6 set NbRegions [expr round (($TailleChr/$TailleRegion)-0.5)] set Reste [expr round($TailleChr) % round($TailleRegion)] set Area 0 set LesRegions {} set Debut 1 for {set i 1} {$i <= $NbRegions} {incr i} { incr Area set Fin [expr round($Debut + $TailleRegion - 1)] lappend LesRegions [list $Area $Debut $Fin] set Debut [expr $Fin + 1] } if {$Reste != 0} { incr Area lappend LesRegions [list $Area $Debut $TailleChr] } foreach LaRegion $LesRegions { set Area [lindex $LaRegion 0] set Debut [lindex $LaRegion 1] set Fin [lindex $LaRegion 2] set LesGenes {} foreach LeGene $LesGenesDuChromosome { set Gene [lindex $LeGene 0] set DMin [lindex $LeGene 1] set FMax [lindex $LeGene 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesGenes $Gene } set n [llength $LesGenes] Espionne "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" } ###Distribution sur Region de 1e7bp### set TypeDeRegion "1e7bp" set TailleRegion 1e7 set NbRegions [expr round (($TailleChr/$TailleRegion)-0.5)] set Reste [expr round($TailleChr) % round($TailleRegion)] set Area 0 set LesRegions {} set Debut 1 for {set i 1} {$i <= $NbRegions} {incr i} { incr Area set Fin [expr round($Debut + $TailleRegion - 1)] lappend LesRegions [list $Area $Debut $Fin] set Debut [expr $Fin + 1] } if {$Reste != 0} { incr Area lappend LesRegions [list $Area $Debut $TailleChr] } foreach LaRegion $LesRegions { set Area [lindex $LaRegion 0] set Debut [lindex $LaRegion 1] set Fin [lindex $LaRegion 2] set LesGenes {} foreach LeGene $LesGenesDuChromosome { set Gene [lindex $LeGene 0] set DMin [lindex $LeGene 1] set FMax [lindex $LeGene 2] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DMin $FMax]} {continue} lappend LesGenes $Gene } set n [llength $LesGenes] Espionne "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" lappend LeTexte "$Chromosome\t$TypeDeRegion\t$Area\t$Debut\t$Fin\t$n\t[join $LesGenes "\t"]" } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierRequeteSEACI {FichierSortie {TypeRequete Interpro} {FichierDistribution ""}} { global RepertoireDuGenome set RepertoireSEACI "$RepertoireDuGenome/srsSEACI" set Texte "Foreach:\$I=getz \'\[seaci\-cat:\*\]\' \-lv\| cut \-d \' \' \-f 5 \| sort \-n" if {$TypeRequete == "Interpro"} { append Texte "\nSeparator:;" append Texte "\n\$R1=\(\[seaci\-cat:\$I\]\)\n\$R2=protein" append Texte "\nDisplay:\-f dbxref \|grep InterPro\|perl \-e \'while\(<>\)\{~s/DR InterPro;//g;print;\}\' \|cut \-d \" \" \-f2" append Texte "\nOutput:>$FichierSortie" set SiDistribution "\nDistribution:\[protein\-dbxref:ipr\*]\nDistribution_output:$FichierDistribution" } elseif {$TypeRequete == "EC"} { append Texte "\nSeparator:)" append Texte "\n\$R1=\(\[seaci\-cat:\$I\]\)\n\$R2=protein" append Texte "\nDisplay:\-f des\|grep \'EC \'\|perl \-e \'while\(<>\)\{~s/DE //g;print;\}'\|ec_extract.tcl" #append Texte "\nDisplay:\-f des\|grep \'EC \'\|perl \-e \'while\(<>\)\{~s/DE //g;print;\}'\|ec_extract.tcl" append Texte "\nOutput:>$FichierSortie" set SiDistribution "\nDistribution:\[protein\-des:/^ec /\]\nDistribution_output:$FichierDistribution" #set SiDistribution "\nDistribution:\[protein\-des:/^\[0\-9\\\\-\]\+\\\\.\[0\-9\\\\-\]\+\\\\.\[0\-9\\\\-\]\+\\\\.\[0\-9\\\\-\]\+\$/\]\nDistribution_output:$FichierDistribution" } elseif {$TypeRequete == "Keywords" } { append Texte "\nSeparator:\.\;" append Texte "\n\$R1=\(\[seaci\-cat:\$I\]\)\n\$R2=protein" append Texte "\nDisplay:\-f key\|perl \-e \'while\(<>\)\{~s/KW //g;print;\}\'" append Texte "\nOutput:>$FichierSortie" set SiDistribution "\n\Distribution:\[protein\-key:\*\]\nDistribution_output:$FichierDistribution" } if {$FichierDistribution != ""} {append Texte $SiDistribution} append Texte "\nQuery:\(\(\$R1\)>\(\$R2\)\)" return $Texte } proc FichierRetNetPourTous {{LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierOUT "[RepertoireDuGenome]/fiches/RetNet" set FichierLoc [ChoixDuFichierLocalisationHuman] set LeTexte {} foreach Nom $LesNoms { foreach LaLoc [InterrogeLocalisation $FichierLoc Nom $Nom] { if {![regexp -nocase "best" [lindex $LaLoc end]]} {continue} set Chrom [lindex $LaLoc 9] set DS [Mini [lindex $LaLoc 10] [lindex $LaLoc 11]] set FS [Maxi [lindex $LaLoc 10] [lindex $LaLoc 11]] foreach LeOMIM [LesOMIMDeLaRegion $Chrom $DS $FS] { set LesGeneName [lindex $LeOMIM 5] set Qui [string trim [string toupper [lindex $LesGeneName 0]]] regsub -all -nocase {[^0-9a-z_]} $Qui "" Qui set Quoi "OMIM" if {[InterrogeRetNet RetNet $Qui LesInfos] != ""} {set Quoi "RetNet"} if {$Quoi != "RetNet"} {continue} set LesBornes [lindex $LeOMIM 2] set DOMIM [lindex $LesBornes 0] set FOMIM [lindex $LesBornes 1] if {50000000 < [expr $FOMIM - $DOMIM]} {continue} set Def [join [concat [list [lindex $LeOMIM 9]] [lindex $LeOMIM 10]] ", "] Espionne "$Nom\t$Chrom\t$DS\t$FS\t$Quoi\t$Qui\t$Def\t$DOMIM\t$FOMIM" lappend LeTexte "$Nom\t$Chrom\t$DS\t$FS\t$Quoi\t$Qui\t$Def\t$DOMIM\t$FOMIM" } foreach LeRetNet [LesRetNetDeLaRegion $Chrom $DS $FS] { set Qui [string trim [string toupper [lindex $LeRetNet 0]]] regsub -all -nocase {[^0-9a-z_]} $Qui "" Qui set LesBornes [lindex $LeRetNet 2] set DRetNet [lindex $LesBornes 0] set FRetNet [lindex $LesBornes 1] if {50000000 < [expr $FRetNet - $DRetNet]} {continue} set Def [lindex $LeRetNet 5] Espionne "$Nom\t$Chrom\t$DS\t$FS\tRetNet\t$Qui\t$Def\t$DRetNet\t$FRetNet" lappend LeTexte "$Nom\t$Chrom\t$DS\t$FS\tRetNet\t$Qui\t$Def\t$DRetNet\t$FRetNet" } } } Sauve [join $LeTexte "\n"] dans $FichierOUT return } proc FichierSDT {} { set LesLignes {} set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set Repertoire "/genomics/link/EVImm/Arnaud/nuctfa1500Final" set Ligne "GscopeId;mRNA GeneName;Synonyms;mRNA Description;mRNA AccessionNumber;Localisation;Cytoband;Status;Protein GeneName;Protein Description;Protein AccessionNumber;GoComponent;GoFunction;GoProcess;IdMGI" lappend LesLignes $Ligne foreach File [glob -nocomplain "$Repertoire/*"] { set Ligne "" set Nom [file tail $File] set AccessNuc [StringApres ":" dans [lindex [LesLignesDuFichier $File] 0]] set Access [AccessEvi $Nom] if {$AccessNuc!=$Access} { Espionne "$Nom" } set GnmRNA [ExtraitInfo $Nom "ValiGN"] set Alias [RecupereSynonyms $Nom] set Des [ExtraitInfo $Nom "ValiDE"] set AccARN [AccessEvi $Nom] set LocUcsc [ExtraitInfo $Nom "LocUcscFrom200602"] set CytoBand [ExtraitInfo $Nom "CytoBand"] set Status [ExtraitInfo $Nom "Status"] set Status [string range $Status 0 [expr [string first "\(" $Status] - 1]] set GnProt [ExtraitInfo $Nom "ValiGNProt"] set DesProt [ExtraitInfo $Nom "ValiDEProt"] set IdAccProt [ExtraitInfo $Nom "IdAccProt"] set LesProt [split $IdAccProt " "] set AccProt [lindex $LesProt 1] set IdMgi [ExtraitInfo $Nom "MGI"] regsub -all ";" $GnmRNA "," GnmRNA regsub -all ";" $Alias "," Alias regsub -all ";" $Des "," Des regsub -all ";" $AccARN "," AccARN regsub -all ";" $LocUcsc "," LocUcsc regsub -all ";" $CytoBand "," CytoBand regsub -all ";" $Status "," Status regsub -all ";" $GnProt "," GnProt regsub -all ";" $DesProt "," DesProt regsub -all ";" $AccProt "," AccProt if {$Nom=="EVI08520" || $Nom=="EVI08530" || $Nom=="EVI22270" || $Nom=="EVI24960" || $Nom=="EVI18700" || $Nom=="EVI24390" || $Nom=="EVI02810" || $Nom=="EVI07650" || $Nom=="EVI07660" || $Nom=="EVI14380" || $Nom=="EVI17090" || $Nom=="EVI24420" || $Nom=="EVI25020" || $Nom=="EVI25030" || $Nom=="EVI25040"} { set Ligne "$Nom;$GnmRNA;$Alias;$Des;$AccARN;$LocUcsc;$CytoBand;$Status;;;;;;;$IdMgi" lappend LesLignes $Ligne continue } set LesComponent {}; set LesFunction {}; set LesProcess {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] set IdEtDefGO "$GO:$DefGO" if {[regexp {component} $Type]} {lappend LesComponent $IdEtDefGO} if {[regexp {function} $Type]} {lappend LesFunction $IdEtDefGO} if {[regexp {process} $Type]} {lappend LesProcess $IdEtDefGO} } set LesComponent [ListeSansDoublon $LesComponent] set LesFunction [ListeSansDoublon $LesFunction] set LesProcess [ListeSansDoublon $LesProcess] set comp [join $LesComponent ","] set func [join $LesFunction ","] set proce [join $LesProcess ","] set Ligne "$Nom;$GnmRNA;$Alias;$Des;$AccARN;$LocUcsc;$CytoBand;$Status;$GnProt;$DesProt;$AccProt;$comp;$func;$proce;$IdMgi" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/Arnaud/STD" } proc FichierSizeMSF {} { global RepertoireDuGenome set File "$RepertoireDuGenome/fiches/sizemsf" set atleast 40 if {[OuiOuNon "At least $atleast first sequences are studied\n Would you want to change this number?"]} { set atleast [Entre] } set nOrgInt 70 if {[OuiOuNon "$nOrgInt sequences of your favorite organism will be study\n Would you want to change this number?"]} { set nOrgInt [Entre] } set nPDB 30 if {[OuiOuNon "$nPDB pdb will be study\n Would you want to change this number?"]} { set nPDB [Entre] } set Expect 0.001 if {[OuiOuNon "The threshold of the expect value is $Expect\n Would you want to change this number?"]} { set Expect [Entre] } set Texte "$atleast $nOrgInt $nPDB $Expect respectively : at_least max_with_complete_genomes max_pdb expect" Sauve $Texte dans $File return $File } proc FichierSwDuPdb {Lignes chnin} { global LNOrdali set idx -1 set noms [ExtraitDbRefDuPdb $Lignes $chnin] set nom1 [lindex $noms 0] set nom2 [lindex $noms 1] if {$nom1 != "" && $nom2 != ""} { set idx "none" if {[lsearch $LNOrdali $nom1] != -1} { set idx [lsearch $LNOrdali $nom1] } if {[lsearch $LNOrdali $nom2] != -1} { set idx [lsearch $LNOrdali $nom2] } } if {$idx == "none"} { return $nom1 } if {[regexp {[0-9]} $idx]} { return $idx } return -1 } proc FichierTFA2EST {FichierTFA Organism ProgrammeConsensus {IDMin 0.95} {IDMax 0.95} {TailleAliMin 50}} { ############################################################################################# ### ### ### Reconstruction du mRNA full-length a partir d'une sequence de type DNA (ou proteine?) ### ### ### ############################################################################################# if {![file exists $FichierTFA]} {return} set FichierTFAMasked "$FichierTFA.masked" set FichierBlastnEST "$FichierTFA.blastnest" set FichierBlastnESTReduced "$FichierTFA.blastnest.reduced" set FichierTFAsEST "$FichierTFA.esttfas" set FichierEST "$FichierTFA.est" set FichierMSF "$FichierTFA.msf" set FichierTFAConsensus "$FichierTFA.consensustfa" set FichierESTInfo "$FichierTFA.estinfos" ###Initialisation du tableau servant à la creation du fichierout contenant le sort de chaque EST CreerFichierInfoESTConstructionmRNAFullLength "ini" ########################################################################## ### Selection de la population d'EST correspondant à la sequence query ### ########################################################################## ### 1- Elimination des repeats sur la sequence initiale ### Espionne "Repeat masker running..." if {![file exists $FichierTFAMasked]} { set MaskedTFA [MasqueLesRepeatsDuFichier $FichierTFA $Organism] Sauve $MaskedTFA dans $FichierTFAMasked } Espionne "Repeat masker done." ### 2- BlastnEST filtre du TFA masque contre la banque d'EST ### Espionne "BlastnEST running ..." if {![file exists $FichierBlastnEST]} { set Commande "eval exec blastall -p blastn -i \$FichierTFAMasked -o \$FichierBlastnEST -d /blast/est -v 2000 -K 0 -b 2000 -e 0.1 -F T" if {[catch {eval $Commande} Message]} {Espionne "$Message\nProblem with $FichierBlastnEST"} } Espionne "BlastnEST done." ###Met tous les BId dans le tableau et les considere selectionnes pour l'instant ###Changera cette info lors de chaque etape de selection set LesBIdDesESTTot [LesBanqueIdDuBlast $FichierBlastnEST 1e200 1e200] foreach BId $LesBIdDesESTTot {CreerFichierInfoESTConstructionmRNAFullLength Id $BId "Selected"} ### 3- Recherche des EST du TFA avec Id min, TailleAliMin et meme Orga ### Espionne "BlastnEST reduction running ..." if {![file exists $FichierBlastnESTReduced]} {set FichierBlastnESTReduced [BlastDesMeilleursESTDuBlast $FichierBlastnEST $FichierTFA $Organism $IDMax $TailleAliMin]} Espionne "BlastnEST reduction done." #Determination des BId des EST elimines lors de cette etape de selection set LesBIdDesEST [LesBanqueIdDuBlast $FichierBlastnESTReduced 1e200 1e200] set LesBIdDesESTElimines [LaDifferenceDeL1AvecL2 $LesBIdDesESTTot Moins $LesBIdDesEST] #Dans le tableau pour construire le fichierout precise la raison de l'elimination de chacun de ces EST foreach BId $LesBIdDesESTElimines { CreerFichierInfoESTConstructionmRNAFullLength Id $BId "Eliminated through blastnest selection (Bad ID, Organism or too small alignment)" } #Les EST selectionnes a cette etape sont ceux presents dans le blastnEST reduced set LesBIdDesESTTot $LesBIdDesEST ############################################################################################## ### Selection des EST participant a la creation du consensus, cad elimination de ceux ### ### ayant une extension après une queue polyA ou T en dehors de l'alignement avec la query ### ############################################################################################## ### 1- Ajout de la query aux EST du fichier d'entree du programme de consensus ### set LesSeqTFAs [list [SequenceFormatTFA [QueLaSequenceDuTFA $FichierTFA] "QUERY"]] ### 2-Elimination des EST ayant une extension (ex: debut 5' UTR autre mRNA) apres la queue polyA ou T### #On tolere une extension de 10 nucleotides derriere la queue polyA ou polyT Espionne "EST with extension after polyA/T elimination running ..." set ExtensionMax 10 set LesBIdDesEST {} foreach SeqTFA [LesSeqTFAsDesBanqueId $LesBIdDesESTTot est $Organism] { if { [info exists BId]} {unset BId} scan $SeqTFA ">%s" BId if {![info exists BId] || [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 Orientation] == ""} {continue} ### Detection des queues poly A et T sur chaque EST selectionne set LesRegionsPolyA [LesRegionsDetecteesPolyNDuTFA $SeqTFA A 10 0.95 2 5] set LesRegionsPolyT [LesRegionsDetecteesPolyNDuTFA $SeqTFA T 10 0.95 2 5] ### Reverse and complement des EST en minus ### Creation nouvelle sequence "reverse and complement" au format TFA pour ces EST set Entete $BId set Seq [QueLaSequenceDuTexteTFA $SeqTFA] if {[SensDeLaRegion [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 Orientation]] == "-"} { set Entete "$BId reverse and complement" set Seq [NucToReverseAndComplementNuc $Seq ] } set SeqTFA [SequenceFormatTFA $Seq $Entete] ### Conservation des EST ne contenant ni queue polyA ni queue polyT parmi les EST selectionnes if {$LesRegionsPolyA == "" && $LesRegionsPolyT == ""} { lappend LesBIdDesEST $BId lappend LesSeqTFAs $SeqTFA continue } ##### Traitement des EST ayant une queue polyA et/ou T ##### #Coordonnees de l'alignement query/EST dans blast selon la sequence de l'EST, sachant que #le debut DS est la plus petite position #la fin FS est la plus grande position set DS [Mini [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 DS] [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 FS]] set FS [Maxi [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 DS] [AskBlast $FichierBlastnESTReduced BanqueId $BId Segment 1 FS]] set TailleS [AskBlast $FichierBlastnESTReduced BanqueId $BId Taille] # Selection de la region polyA ou T la plus longue parmi toutes les regions detectees pour un EST set LesRegionsPolyAouT [concat $LesRegionsPolyA $LesRegionsPolyT] set LaRegionPolyAouT [lindex [lsort -real -decreasing -index 2 $LesRegionsPolyAouT] 0] #D Debut de la region polyA ou T selectionnee set D [lindex $LaRegionPolyAouT 0] #F Fin de la region polyA ou T selectionnee set F [lindex $LaRegionPolyAouT 1] set PolyQuoi [lindex $LaRegionPolyAouT 3] #Attention, on n'espionne que les BId des EST ayant une region poly A ou T Espionne "BId : $BId" ###Elimination des EST ayant une extension en aval de la queue poly A ### de taille > tolerance de 10 nucleotides ### et dont le polyA n'est pas present dans l'alignement de la query avec cet EST ###Elimination des EST ayant une extension et une queue polyA en amont de l'alignement avec la query if {$PolyQuoi == "A"} { if {($ExtensionMax < [expr $TailleS - $F + 1] && $FS < $F ) || $F < $DS} {continue} Espionne "EST OK" } ###Elimination des EST ayant une extension en amont de la queue poly T > tolerance de 10 nucl ### et dont le polyT n'est pas present dans l'alignement de la query avec cet EST ###Elimination des EST ayant une extension et une queue polyT en aval de l'alignement avec la query if {$PolyQuoi == "T"} { if {($ExtensionMax < [expr $D - 1] && $D < $DS) || $FS < $D } {continue} Espionne "EST OK" } #Stockage des BId des EST selectionnes lappend LesBIdDesEST $BId lappend LesSeqTFAs $SeqTFA } if {[AskBlast $FichierBlastnESTReduced Exists]} {AskBlast unsetfile $FichierBlastnESTReduced} Espionne "EST with extension after polyA/T elimination done." #Dans le tableau pour construire le fichierout precise la raison de l'elimination de chacun de ces EST set LesBIdDesESTElimines [LaDifferenceDeL1AvecL2 $LesBIdDesESTTot Moins $LesBIdDesEST] foreach BId $LesBIdDesESTElimines { CreerFichierInfoESTConstructionmRNAFullLength Id $BId "Eliminated due to a supplementary extension after/before polyA/T" } Sauve [join $LesSeqTFAs "\n"] dans $FichierTFAsEST ####################################### Modification ################################ ######## Ordonne les EST par query puis taille croissante ########################### ######## dans le fichier d'entree du programme de consensus pour le msf ########### Espionne "Modification running..." set LesTFAs [split [ContenuDuFichier $FichierTFAsEST] ">"] set LesTailles {} foreach TFA $LesTFAs { if {$TFA == ""} {continue} set TFA ">$TFA" if {[info exists BId]} {unset BId} scan $TFA ">%s" BId #Espionne "BId: $BId" set SeqTFA [QueLaSequenceDuTexteTFA $TFA ] #Espionne "SeqTFA: $SeqTFA" set TailleTFA [string length $SeqTFA] #Espionne "TailleTFA:$TailleTFA" lappend LesTaillesTFA [list $BId $TailleTFA] set Tab($BId,SeqTFA) $SeqTFA if {$BId == "QUERY"} {set Tab(QUERY,SeqTFA) $SeqTFA} } set LesSeqTFA {} lappend LesSeqTFA [SequenceFormatTFA [set Tab(QUERY,SeqTFA)] "QUERY"] foreach LaTailleDuBId [lsort -index 1 -real -increasing $LesTaillesTFA] { set BId [lindex $LaTailleDuBId 0 ] set SeqTFA [set Tab($BId,SeqTFA) ] set UneSeqTFA [SequenceFormatTFA $SeqTFA $BId] if {$BId == "QUERY"} {continue} lappend LesSeqTFA $UneSeqTFA } Sauve [join $LesSeqTFA "\n"] dans $FichierTFAsEST Espionne "Modification done." ################## Fin Modification ############################### ####################################################################################### ### Creation et selection du consensus a partir de la query et des EST selectionnes ### ### par le programme de consensus specifie en argument ### ####################################################################################### #############Pour POA################# if {[string equal -nocase $ProgrammeConsensus "POA"]} { ### 1- Execution de POA avec creation de consensus ### if {[string equal -nocase $ProgrammeConsensus "POA"]} { Espionne "POA with the selected EST running ..." POADuTFAs $FichierTFAsEST $FichierMSF 1 MSF Espionne "POA with the selected EST done." } ### 2- Identification de query, des EST et des consensus dans le msf ### Espionne "POA EST and consensus selection running ..." ###Selection des sequences d'EST et consensus dans le MSF DecortiqueUnMSF $FichierMSF LesId Sequences set LesConsensus {} set TousLesEST {} Espionne "Les Id du MSF : $LesId" foreach Id $LesId { if {[string equal -nocase $Id "QUERY"]} {continue} if {[regexp -nocase "^CONSEN" $Id ]} {lappend LesConsensus $Id;continue} lappend TousLesEST $Id } Espionne "TousLesConsensus $LesConsensus" ### 3- Selection des bons consensus: seuil d'identite (ID) avec query ### set LesBonsConsensus {} Espionne "Consensus selection running..." foreach Consensus [ElimineLesRedondancesDansUneListe $LesConsensus] { set IdDuConsensus [IDdansMSF $FichierMSF "QUERY" $Consensus "SelonA"] set SequenceConsensus [set Sequences($Consensus) ] regsub -nocase -all {[^atcg]} $SequenceConsensus "" SequenceConsensus set TailleConsensus [string length $SequenceConsensus ] Espionne "$Consensus $IdDuConsensus $TailleConsensus" Espionne "$SequenceConsensus" if {$IdDuConsensus < $IDMax} {continue} lappend LesBonsConsensus $Consensus } Espionne "Consensus selection done." if {$LesBonsConsensus == {}} { Espionne "Best Consensus : $LesBonsConsensus" Espionne "No consensus selected, ID lower than the threshold $IDMax" return } Espionne "Best Consensus : $LesBonsConsensus" ### 4- Determination des seq TFA des bons consensus ### set SeqTFADuCons "" set NbMaxEST 0 foreach Consensus $LesBonsConsensus { set Seq [set Sequences($Consensus)] regsub -nocase -all {[^atcg]} $Seq "" Seq Espionne "$Consensus" #Espionne "Taille [string length $Seq]" lappend LesSeqTFADesCons [SequenceFormatTFA $Seq $Consensus] ### 5- Selection du meilleur consensus #Identification des EST de chaque bon consensus: seuil ID avec le consensus ### set Tab(Consensus,$Consensus,LesEST) {} foreach EST $TousLesEST { Espionne "coucou2" set IdDeLEST [IDdansMSF $FichierMSF $EST $Consensus "SelonA"] #Espionne "$Consensus $EST $IdDeLEST" #Les EST ayant servi a la creation du consensus ont au moins IDMin d'identite avec ce consensus if {$IdDeLEST < $IDMin} {continue} lappend Tab(Consensus,$Consensus,LesEST) $EST } set LesEST [set Tab(Consensus,$Consensus,LesEST)] set NbEST [llength $LesEST] #Selection du consensus ayant ete construit a partir du plus grand nombre d'EST if {$NbEST <= $NbMaxEST} {continue} set LeConsensusSelectionne $Consensus Espionne "Le Consensus selectionne : $LeConsensusSelectionne" set SeqTFADuCons [SequenceFormatTFA $Seq $Consensus] set NbMaxEST $NbEST set LesESTSelectionnes $LesEST Espionne "Les EST du consensus selectionne : $LesEST" } Espionne "POA consensus and EST selection done." set SeqConsensusSelectionne [set Sequences($LeConsensusSelectionne)] regsub -nocase -all {[^atcg]} $SeqConsensusSelectionne "" SeqConsensusSelectionne set TailleConsensusSelectionne [string length $SeqConsensusSelectionne] Espionne "Consensus Selectionne : $LeConsensusSelectionne $TailleConsensusSelectionne" #Dans le tableau pour construire le fichierout precise la raison de l'elimination de chacun de ces EST set LesESTElimines [LaDifferenceDeL1AvecL2 $TousLesEST Moins $LesESTSelectionnes] foreach BId $LesESTElimines { CreerFichierInfoESTConstructionmRNAFullLength Id $BId "Eliminated because not in the selected consensus" } #Creation du fichierout a partir du tableau prealablement rempli a chaque etape CreerFichierInfoESTConstructionmRNAFullLength "write" $FichierESTInfo Sauve $SeqTFADuCons dans $FichierTFAConsensus } #############Pour CAP3################# if {[string equal -nocase $ProgrammeConsensus "CAP3"]} { ### 1- Execution de CAP3 avec creation de consensus ### if {[string equal -nocase $ProgrammeConsensus "CAP3"]} { Espionne "CAP3 with the selected EST running ..." CAP3DuTFAs $FichierTFAsEST Espionne "CAP3 with the selected EST done." } } AskBlast "unset" return } proc FichierTFADeLaProteineDuContig {Nom {IdMin 0.8}} { set RepProtTFA "[RepertoireDuGenome]/prottfa" if {![file exists $RepProtTFA]} {File mkdir $RepProtTFA} set FichierProtTFA "$RepProtTFA/$Nom" set FichierAccDesProtEtDesContigsChoisis "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis" set Prot [InterrogeContigAndProt $Nom Protein Access] if {$Prot == ""} {return} set Contig [InterrogeContigAndProt $Nom Contig Access] set IdProt [InterrogeContigAndProt $Nom Protein Identity] if {$IdProt < $IdMin} {return} set OrgaContig [InterrogeContigAndProt $Nom Contig Organisme] set OrgaProt [InterrogeContigAndProt $Nom Protein Organisme] set IdProt [InterrogeContigAndProt $Nom Protein Identity] set Identity [expr round($IdProt * 100)] set Entete "$Nom PROTEIN $Prot from $OrgaProt from CONTIG $Contig from $OrgaContig ${Identity}%" Espionne $Entete set Warning "" AppendAuFichier $FichierAccDesProtEtDesContigsChoisis "$Nom\t$Prot\t$Contig\t$OrgaProt\tSeqOK\t$Warning" if {1} { set Def [PageInfo $Prot protein "des"] set SeqProt [SequenceDeLAccess $Prot protein] set SeqTFA [SequenceFormatTFA $SeqProt $Entete] Sauve $SeqTFA dans $FichierProtTFA return $SeqTFA } } proc FichierTFADesOrganismes {{LesOrganismes Noe} {mRNAouProtein mRNA} {LesNoms ""} {IdMin 0.8}} { if {$LesOrganismes == "Noe"} {set LesOrganismes [LaSelectionDeNoe ]} if {$LesOrganismes == "" } {set LesOrganismes [MorceauxChoisis [lsort [InterrogeBestProteinAndmRNAForeachOrga LesOrganismes]]]} if {$LesOrganismes == "" } {return} if {$LesNoms == ""} {set LesNoms [InterrogeBestProteinAndmRNAForeachOrga LesNoms]} if {$mRNAouProtein == "mRNA"} { foreach Organisme $LesOrganismes { regsub -all " " $Organisme "_" OrgaTexte set RepTFA "[RepertoireDuGenome]/mrnatfa_$OrgaTexte" if {![file exists $RepTFA]} {File mkdir $RepTFA} } set Banque "genbank" } else { foreach Organisme $LesOrganismes { regsub -all " " $Organisme "_" OrgaTexte set RepTFA "[RepertoireDuGenome]/prottfa_$OrgaTexte" if {![file exists $RepTFA]} {File mkdir $RepTFA} } set Banque "protein" } set Keep 1 if {![OuiOuNon "if some files exist, do you want to conserve them?"]} {set Keep 0} foreach Organisme $LesOrganismes { regsub -all " " $Organisme "_" OrgaTexte if {$mRNAouProtein == "mRNA" } {set RepTFA "[RepertoireDuGenome]/mrnatfa_$OrgaTexte"} if {$mRNAouProtein == "Protein"} {set RepTFA "[RepertoireDuGenome]/prottfa_$OrgaTexte"} foreach Nom $LesNoms { Espionne "$Nom $Organisme" set FileTFA "$RepTFA/$Nom" if {[file exists $FileTFA] && $Keep} {continue} set Access [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme $Organisme $mRNAouProtein Access] if {$Access == ""} {continue} set SeqTFA [PageInfo $Access $Banque seq] if {$SeqTFA == ""} {continue} set Id [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $Access Identity] if {$Id < $IdMin} {set Warning " WARNING the percent of identity with the query protein is $Id (< $IdMin)"} else {set Warning ""} set SeqTFA [SequenceFormatTFA [QueLaSequenceDuTexteTFA $SeqTFA] "$Nom $mRNAouProtein $Access from ${Organisme}$Warning"] Espionne $SeqTFA Sauve $SeqTFA dans $FileTFA } } return } proc FichierTFADesProteinesChoisiesPourTous {{LesNoms ""} {Rang 1}} { if {$LesNoms == {}} {set LesNoms [ListeDesPABs]} set RepProtTFA "[RepertoireDuGenome]/prottfa" if {![file exists $RepProtTFA]} {File mkdir $RepProtTFA} set FichierAccDesProtEtDesmRNAsChoisis "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis" if {[file exists $FichierAccDesProtEtDesmRNAsChoisis]} { if {![OuiOuNon "$FichierAccDesProtEtDesmRNAsChoisis exists\nDo you want to conserv them?"]} { File delete -force $FichierAccDesProtEtDesmRNAsChoisis } } set Keep 0 if {0 < [glob -nocomplain "$RepProtTFA/*"]} { if {[OuiOuNon "Some files exist in $RepProtTFA.\nWould you want to conserv them?"]} {set Keep 1} } foreach Nom $LesNoms { set FichierProtTFA "$RepProtTFA/$Nom" if {[file exists $FichierProtTFA] && $Keep} {continue} Espionne [TFADeLaProteineChoisie $Nom $Rang] } return } proc FichierTFADesProteinesDesContigsPourTous {{LesNoms ""} {IdMin 0.80}} { if {$LesNoms == {}} {set LesNoms [ListeDesPABs]} set RepProtTFA "[RepertoireDuGenome]/prottfa" if {![file exists $RepProtTFA]} {File mkdir $RepProtTFA} set FichierAccDesProtEtDesContigsChoisis "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis" set Keep 1 if {0 < [llength [glob -nocomplain "$RepProtTFA/*"]]} { if {![OuiOuNon "Some files exist in $RepProtTFA.\nWould you want to conserv them?"]} { if {[file exists $FichierAccDesProtEtDesContigsChoisis]} {File delete -force $FichierAccDesProtEtDesContigsChoisis} set Keep 0 } } foreach Nom $LesNoms { set FichierProtTFA "$RepProtTFA/$Nom" if {[file exists $FichierProtTFA] && $Keep} {continue} FichierTFADeLaProteineDuContig $Nom $IdMin } return } proc FichierTFADesRegionsPromotricesPourTous {NameRepTFAIni {TailleFenetreMin 10000} {TailleFenetreMax 10000} {LesNoms ""}} { set RepTFA "[RepertoireDuGenome]/$NameRepTFAIni" set RepExonicMap "[RepertoireDuGenome]/${NameRepTFAIni}_exonicmap" if {![file exists $RepTFA] || ![file exists $RepExonicMap]} {return} set RepPromoteur "[RepertoireDuGenome]/${NameRepTFAIni}_promoter" if {![file exists $RepPromoteur]} {File mkdir $RepPromoteur} if {$LesNoms == "" } {set LesNoms [MorceauxChoisis [ListeDesPABs]]} if {0 < [llength [glob -nocomplain "$RepPromoteur/*"]]} { if {[OuiOuNon "Some files exist in $RepPromoteur, would you want to conserv them?"]} { set Keep 1 } else { set Keep 0 } } else { set Keep 1 } foreach Nom $LesNoms { set FichierCExon "$RepExonicMap/$Nom" if {![file exists $FichierCExon]} {continue} set FichierPromoteur "$RepPromoteur/$Nom" if {$Keep && [file exists $FichierPromoteur]} {continue} set SeqTFA [TFADeLaRegionPromotrice $Nom $FichierCExon $TailleFenetreMin $TailleFenetreMax] if {$SeqTFA == ""} {continue} Sauve $SeqTFA dans $FichierPromoteur } return "" } proc FichierTFAsAleatoireTIGR {FileId FileTFAs FileTFAsOut {NbSeq 1000}} { if {![file exists $FileId ]} {return} if {![file exists $FileTFAs]} {return} set LesId {} set F [open $FileId] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {![regexp -nocase {^>([0-9a-z]+)} $Ligne tmp Id]} {continue} lappend LesId $Id } close $F set LesIdSelect {} set n 0 while {$n < $NbSeq} { set LesIdOld $LesId set NbId [llength $LesIdOld] set i [Aleatoire 0 [expr $NbId - 1]] set Id [lindex $LesIdOld $i] if {[info exists TabDejaVu($Id]} {continue} set TabDejaVu($Id) 1 lappend LesIdSelect $Id set LesId {} if {0 < $i } {set LesId [concat $LesId [lrange $LesIdOld 0 [expr $i - 1] ] ]} if {$i < [expr $NbId - 1]} {set LesId [concat $LesId [lrange $LesIdOld [expr $i + 1] [expr $NbId - 1] ] ]} incr n } Espionne [llength $LesIdSelect] set LesTFAs {} foreach SeqTFA [split [ContenuDuFichier $FileTFAs] ">"] { set SeqTFA [string trim $SeqTFA] if {$SeqTFA == ""} {continue} set SeqTFA ">$SeqTFA" if {![regexp -nocase {^>([0-9a-z]+)} $SeqTFA tmp Id]} {continue} if {![info exists TabDejaVu($Id)]} {continue} lappend LesTFAs $SeqTFA } Espionne [llength $LesTFAs] Sauve [join $LesTFAs "\n"] dans $FileTFAsOut return } proc FichierTFAsDeTousLesVariants {FichierOUT {AvecOuSansSeqIni Sans}} { #Entree : FichierOUT = NomDuFichierDeSortie # AvecOuSansSeqIni = "Avec" ou "Sans" la sequence initiale de l'id avec les variants #Sortie : Le fichier au format TFA des toutes les sequences des variants #Si le fichier existe je le supprime if {[file exists $FichierOUT]} {file delete -force $FichierOUT} ##Commande de getz pour extraire toutes les sequences possédant le champs "alternative products" dans CC set Commande "[ProgPathway getz] \"\\\[protein\-all:alternative products\\\]\"" catch {set Out [eval exec $Commande]} Message #Pour chaque Id que getz me renvoie foreach Id [split $Out "\n"] { #Je ne les utilise qu'une fois if {[info exists TabDejaVu($Id)]} {continue} else {set TabDejaVu($Id) 1} Espionne $Id #Appelle de la procedure LesSeqTFADesVariants qui retourne toutes les sequences TFA des variants d'un access set LesSeqTFA [LesSeqTFADesVariants $Id $AvecOuSansSeqIni] #Il doit y avoir au moins une sequence sans compter la sequence initiale set NbSeqTFA [llength $LesSeqTFA] if { ($NbSeqTFA < 1 && [string equal -nocase $AvecOuSansSeqIni "Sans"]) || ($NbSeqTFA <= 1 && [string equal -nocase $AvecOuSansSeqIni "Avec"])} {continue} #Pour chacune de ces sequences, je les enregistre dans le Fichier de sortie foreach SeqTFA $LesSeqTFA { Espionne $SeqTFA AppendAuFichier $FichierOUT $SeqTFA } } return } proc FichierTFAsDesHitsDuBallast {FichierTFAs FichierBallast {NbHitsMax 2000} {NbPDBMax 30} {AvecFragment 0}} { set LesTFAs [LesTFAsDesHitsDuBallast $FichierBallast $NbHitsMax $NbPDBMax $AvecFragment] if {$LesTFAs != {}} {Sauve [join $LesTFAs "\n"] dans $FichierTFAs} return } proc FichierTFAsDesNucTFASelected {FileOut} { set LesNoms [LesNoms NomsInteressants] set LesTFAs {} foreach Nom $LesNoms { set nuctfa "[RepertoireDuGenome]/nuctfa/$Nom" if {![file exists $nuctfa]} {continue} set Entete [EnteteDuFichierTFA $nuctfa] regsub {>[^ ]+ \: } $Entete ">" Entete Espionne $Entete set Seq [QueLaSequenceDuFichierTFA $nuctfa] lappend LesTFAs [SequenceFormatTFA $Seq $Entete] } if {$LesTFAs == {}} {return} Sauve [join $LesTFAs "\n"] dans $FileOut } proc FichierTFAsNonRedondant {FichierTFAs {NouveauFichier ""}} { if {$NouveauFichier==""} { set NouveauFichier $FichierTFAs } foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "@"] { if {[regexp "@" $Access]} { continue } Espionne $Access lappend LeNouveau [LaSequenceDuTFAs $FichierTFAs $Access] } return [SauveLesLignes $LeNouveau dans $NouveauFichier] } proc FichierTabDomain {{listeSequence ""} TypeDeDomain} { set IdenticalInformation {} set Concat "" set Rep "" set listeDomain {} #creation d'un repertoire #definir le fichier de sauvegarde dans le switch switch $TypeDeDomain { "pfam" { set Concat "ConcatPfam" set Rep "[RepertoireDuGenome]/GPfam" } "domain" { set Concat "ConcatDomain" set Rep "[RepertoireDuGenome]/GDomain" } "region" { set Concat "ConcatRegion" set Rep "[RepertoireDuGenome]/GRegion" } } #prends uniquement le fichier PUZ set domainByGroupe {} foreach Seqcible $listeSequence { set newFile "$Rep/$Seqcible" append newFile "Tab" #faire un test si contien color alors continu #if {[regexp {PUZ[0-9]+Color} $fichier] || [regexp {PUZ[0-9]+Length} $fichier]} { # continue #} Espionne "-->$Seqcible" set fichier "$Rep/$Seqcible" #faut sauvegarder dans ce repertoire les images et les py mais sous quel nom je gere les groupes avec des chiffres? set mes_lignes [LesLignesDuFichier $fichier] #parcours le fichier chaque ligne correspond à une liste de protein qui ont les meme domaines foreach ligne $mes_lignes { #recupere les proteins par groupe de domaine set proteins [split [lindex [split $ligne "="] 1] ";"] foreach protName $proteins { set lignebyProt "" if { [file exists "[RepertoireDuGenome]/macsimXml/$Seqcible.aj"]} { set fileMacsim "[RepertoireDuGenome]/macsimXml/$Seqcible.aj" } else { set fileMacsim "[RepertoireDuGenome]/macsimXml/$Seqcible" } #voir si je dois modifie la partie sue la recherche de l'organisme set OS [OrgaDuAccess $protName] if {$OS=="Inconnu inconnu"} { set OS [FromMacsims $fileMacsim $protName "OrganismLong"] } if {$OS=="" || $OS=="Inconnu inconnu" || $OS==" "} { set OS [getOrgaTfasDesCopains "" $Seqcible $protName] } #recupere la taille de la sequence set lengthSeq [FromMacsims $fileMacsim $protName "Length"] #Espionne "prot: $protName; Orga: $OS" append lignebyProt "$OS;$protName;$lengthSeq" #ici recupere les pfams set annotation [FromMacsims $fileMacsim $protName $Concat] #boucle sur ces annotations foreach an $annotation { #recupere les positions pour chaque annotation set pos [split [lindex [split $an "/"] 1] "-"] set deb [lindex $pos 0] set end [lindex $pos 1] #AJOUT ICI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! la ligne de dessous verifie!!!!! set an [lindex [split $an " "] 0] #test ici---------------- #set inf [lindex [split $an "/"] 0] if {[regexp {(.*)from.*} $an a p]} { set an $p } elseif {[regexp {(.*)/.*} $an a p] } { set an $p } #ne le faire que si y a un _ sinon provoque des erreurs if {[regexp {^PROP_(.*)} $an a p]} { set an $p } #et faire le append dans lignebyprot sous la forme -> ;$domain|$deb-$fin append lignebyProt ";$an|$deb-$end" } lappend domainByGroupe $lignebyProt } lappend domainByGroupe "#" } } #ici sauvegarde ce nouveia fichier SauveLesLignes $domainByGroupe dans $newFile } proc FichierTabDomainPourTous {{directory ""} TypeDeDomain} { #type de domain peut etre Domain ou Pfam etc... #faire le boulot pour l'ensemble des TAFs if {$directory==""} {set directory [RepertoireDuGenome]/tfasdescopains} set r [glob -directory $directory *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } FichierTabDomain $f $TypeDeDomain FinPasTouche $f } } proc FichierTableauTXT2HTML {FichierTableau FichierOut} { set LeTexteHTML {} lappend LeTexteHTML "" lappend LeTexteHTML "" lappend LeTexteHTML "" lappend LeTexteHTML "" lappend LeTexteHTML "

Supplementary Information

" lappend LeTexteHTML "" set LesStylesHTML {} set LesCasesHTML {} set i 0 set F [open $FichierTableau] while {[gets $F Ligne]>=0} { if {[string trim $Ligne] == ""} {continue} incr i Espionne $Ligne set LaLigne [split $Ligne "\t"] set LaLigneDuTableau [list ""] for {set j 0} {$j < [llength $LaLigne]} {incr j} { set Style "style$j" set Element [string trim [lindex $LaLigne $j]] if {$Element == ""} {set Element " "} if {$i <= 1} { lappend LesStylesHTML "" lappend LaLigneDuTableau "" continue } if {$j == 0 && [file exists "./${Element}.html"]} { lappend LaLigneDuTableau "" } else { lappend LaLigneDuTableau "" } } if {$i <= 1} {lappend LaLigneDuTableau ""} lappend LesCasesHTML [join $LaLigneDuTableau ""] } close $F foreach LigneDeStyle $LesStylesHTML {lappend LeTexteHTML $LigneDeStyle} foreach LigneDuTab $LesCasesHTML {lappend LeTexteHTML $LigneDuTab} lappend LeTexteHTML "

$Element	$Element	$Element

" lappend LeTexteHTML "" Sauve [join $LeTexteHTML "\n"] dans $FichierOut return } proc FichierTfaFromFichierTfaWithoutNumbers {FichierTFA {NouveauFichierTFA ""}} { if {$NouveauFichierTFA==""} { set NouveauFichierTFA [FichierPourSaveAs $FichierTFA] } if {$NouveauFichierTFA=="SameFile"} { set NouveauFichierTFA $FichierTFA } set TexteTFA [ContenuDuFichier $FichierTFA] set NouveauTFA [TexteTfaFromTexteTfaWithoutNumbers $TexteTFA] return [Sauve $NouveauTFA dans $NouveauFichierTFA] } proc FichierTissueTypePourTous {NameRepBlastnEST {AllOrgaouJustMyOrga AllOrga} {IdDeRef 0.95} {LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} set FichierTissueType "[RepertoireDuGenome]/fiches/TissueType" set Continue 0 if {[file exists $FichierTissueType]} { if {[OuiOuNon "$FichierTissueType exists.\nWould you want to continue?"]} { set Continue 1 set Nom "" foreach Ligne [LesLignesDuFichier $FichierTissueType] { set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Access [lindex $LaLigne 1] if {![info exists DejaVu($Nom)]} {set DejaVu($Nom) 1} set DejaVu($Nom,$Access) 1 } if {[info exists DejaVu($Nom)]} {unset DejaVu($Nom)} } else { if {[OuiOuNon "$FichierTissueType exists.\nWould you want to deltree this file?"]} { File delete -force $FichierTissueType } } } foreach Nom $LesNoms { if {$Continue && [info exists DejaVu($Nom)]} {continue} set FichierBlastnEST "[RepertoireDuGenome]/$NameRepBlastnEST/$Nom" if {![file exists $FichierBlastnEST]} {continue} if {[info exists TabBlast]} {unset TabBlast} DepouilleLeBlast TabBlast $FichierBlastnEST if {![info exists TabBlast(NbSubject)]} {continue} set OrgaDeRef [OrganismeDuPAB $Nom] set NbSubject [set TabBlast(NbSubject)] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set TabBlast($i)] set Access [set TabBlast($BId,Access)] if {$Continue && [info exists DejaVu($Nom,$Access)]} {continue} Espionne "$Nom\t$BId\t$Access" set PAlignees [PourcentageDesBasesAligneesSurToutesLesBasesAlignables_TabBlast TabBlast $BId] if {$PAlignees < $IdDeRef} {continue} set PAlignables [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables_TabBlast TabBlast $BId] if {$PAlignables < $IdDeRef} {continue} set Page [PageInfo $BId est] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] if {$AllOrgaouJustMyOrga != "AllOrga"} { set EstCeUnDesOrga 0 foreach Orga $LesOrgas { if {[string equal -nocase $Orga $OrgaDeRef]} {set EstCeUnDesOrga 1;break} } if {!$EstCeUnDesOrga} {continue} } set LesTissues [LesTissuesDeLAcNuc_PageInfo $Page] if {$LesTissues == {}} {continue} foreach Tissue $LesTissues { foreach Orga $LesOrgas { Espionne "$Nom\t$Access\t$Orga\t$Tissue" AppendAuFichier $FichierTissueType "$Nom\t$Access\t$Orga\t$Tissue" } } } } return } proc FichierValidationDPC {FileDPC NMin} { set F [open $FileDPC] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Taille [llength $LaLigne] if {$Taille <=2} {continue} set Id [lindex $LaLigne 0] if {$Taille < $NMin} { Espionne "$Id taille $Taille < $NMin" } set AiVuUneValeurDiffDeZero 0 for {set i 1} {$i < $Taille} {incr i} { set V [lindex $LaLigne $i] if {$V != 0.0} {set AiVuUneValeurDiffDeZero 1;break} } if {!$AiVuUneValeurDiffDeZero} { Espionne "$Id que des 0" Espionne [PageInfo $Id protein des] Espionne $Ligne return } } close $F } proc FichierZScoreDesGODesClusters {FichierOrf2Cluster FichierGO FichierOut} { if {![file exists $FichierOrf2Cluster ]} {return} if {![file exists $FichierGO ]} {return} set LesGO {} if {![info exists Tab(NbGO)]} {set Tab(NbGO) 0} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster LesClusters] { if {![info exists Tab($Cluster,NbGO)]} {set Tab($Cluster,NbGO) 0} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster Cluster $Cluster LesNoms] { set LesGODeLaBoite {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGODeLaBoite $GO foreach GOAncetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend LesGODeLaBoite $GO } } foreach GO [lsort -unique $LesGODeLaBoite] { incr Tab(NbGO) incr Tab($Cluster,NbGO) if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} incr Tab($Cluster,$GO,n) if {![info exists Tab($GO,n)]} { lappend LesGO $GO set Tab($GO,n) 0 } incr Tab($GO,n) } } } set LesGODesClusters {} foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOrf2Cluster LesClusters] { foreach GO $LesGO { if {$GO == "GO:0003673"} {continue} Espionne "$Cluster $GO" set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set r 0 if {[info exists Tab($Cluster,$GO,n)]} {set r [set Tab($Cluster,$GO,n)]} set n 0 if {[info exists Tab($GO,n) ]} {set n [set Tab($GO,n) ]} set R 0 if {[info exists Tab($Cluster,NbGO) ]} {set R [set Tab($Cluster,NbGO) ]} set N 0 if {[info exists Tab(NbGO) ]} {set N [set Tab(NbGO) ]} set ZScore [ZScore $r $R $n $N] lappend LesGODesClusters [list $Cluster $Type $GO $Def $r $R $n $N $ZScore] } } if {$LesGODesClusters == {}} {continue} foreach LInfo [lsort -index 0 [lsort -index 8 -real -decreasing $LesGODesClusters]] { Espionne $LInfo AppendAuFichier $FichierOut [join $LInfo "\t"] } return } proc FichierZScoreDesGeneOntologyDesClustersSurGOBoites {FichierGO FichierOut} { foreach Cluster [O2C2O LesClusters] { set Tab($Cluster,LesGO) {} foreach Nom [O2C2O Cluster $Cluster LesOrfs] { set LesGO {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend LesGO $GO foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] {lappend LesGO $Ancetre} } foreach GO [lsort -unique $LesGO] { set Type [Onto $GO Type] if {![info exists Tab($Type,NbGO) ]} {set Tab($Type,NbGO) 0} incr Tab($Type,NbGO) if {![info exists Tab($Type,$Cluster,NbGO)]} {set Tab($Type,$Cluster,NbGO) 0} incr Tab($Type,$Cluster,NbGO) if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} incr Tab($GO,n) if {![info exists Tab($Cluster,$GO,n)]} { lappend Tab($Cluster,LesGO) $GO set Tab($Cluster,$GO,n) 0 } incr Tab($Cluster,$GO,n) } } } foreach Cluster [O2C2O LesClusters] { set LesGOEtLeurZScore {} foreach GO [set Tab($Cluster,LesGO)] { set Type [Onto $GO Type] set r [set Tab($Cluster,$GO,n) ] set n [set Tab($GO,n) ] set R [set Tab($Type,$Cluster,NbGO)] set N [set Tab($Type,NbGO) ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set ZScore [ZScore $r $R $n $N] #if {$ZScore <= 0} {continue} lappend LesGOEtLeurZScore [list $Cluster $Type $GO $Def $r $R $n $N $ZScore] } foreach LeGO [lsort -index 1 [lsort -real -decreasing -index end $LesGOEtLeurZScore]] { Espionne $LeGO AppendAuFichier $FichierOut [join $LeGO "\t"] } } return } proc FichierZScoreDesGeneOntologyDesClustersSurGOClusters {FichierGO FichierOut} { foreach Cluster [lsort -unique [InterrogeGeneOntology $FichierGO LesGroupes]] { set Tab($Cluster,LesGO) {} foreach GO [InterrogeGeneOntology $FichierGO Groupe $Cluster LesGO] { lappend Tab($Cluster,LesGO) $GO foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend Tab($Cluster,LesGO) $Ancetre } } foreach GO [lsort -unique [set Tab($Cluster,LesGO)]] { set Type [Onto $GO Type] if {![info exists Tab($Type,NbGO) ]} {set Tab($Type,NbGO) 0} incr Tab($Type,NbGO) if {![info exists Tab($Type,$Cluster,NbGO)]} {set Tab($Type,$Cluster,NbGO) 0} incr Tab($Type,$Cluster,NbGO) if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} incr Tab($GO,n) if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} incr Tab($Cluster,$GO,n) } } foreach Cluster [InterrogeGeneOntology $FichierGO LesGroupes] { set LesGOEtLeurZScore {} foreach GO [lsort -unique [set Tab($Cluster,LesGO)]] { set Type [Onto $GO Type] set r [set Tab($Cluster,$GO,n) ] set n [set Tab($GO,n) ] set R [set Tab($Type,$Cluster,NbGO)] set N [set Tab($Type,NbGO) ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set ZScore [ZScore $r $R $n $N] #if {$ZScore <= 0} {continue} lappend LesGOEtLeurZScore [list $Cluster $Type $GO $Def $r $R $n $N $ZScore] } foreach LeGO [lsort -index 1 [lsort -real -decreasing -index end $LesGOEtLeurZScore]] { Espionne $LeGO AppendAuFichier $FichierOut [join $LeGO "\t"] } } return } proc FichierZscoreDesClustersFusionnes {{ZscoreMinDuCluster 0} {NiveauGOMin_process ""} {NiveauGOMin_function ""} {NiveauGOMin_component ""}} { set FichierBestGOProttfa "[RepertoireDuGenome]/fiches/GeneOntology" set FichierGOClustersFusionnes "[RepertoireDuGenome]/fiches/GeneOntology_ClustersFusionnes" set FichierOut "[RepertoireDuGenome]/fiches/ZScoreDesClustersFusionnes" set LesClustersFusionnes [O2C2O LesClustersFusionnes] foreach ClusterFusionne $LesClustersFusionnes { ### Selection des GO en fonction de leur niveau dans l'arbre ### ### Premier niveau interessant est 3 en process et 2 en function ### foreach GO [InterrogeGeneOntology $FichierGOClustersFusionnes Groupe $ClusterFusionne LesGO] { set Type [Onto $GO Type] ### on n'etudie que les types pour lesquels on a determine un seuil minimal ### if {$Type == "" || ![info exists NiveauGOMin_$Type]} {continue} set NiveauGOMin [set NiveauGOMin_$Type ] set NiveauDuGO [NiveauMinDuGO $GO $Type] if {$NiveauDuGO == "" || $NiveauGOMin == "" || $NiveauDuGO < $NiveauGOMin} {continue} set TabTmp(Cluster,$ClusterFusionne,$GO) 1 foreach Ancetre [InterrogeGeneOntology $FichierGOClustersFusionnes GO $GO LesAncetres] { set NiveauDuGO [NiveauMinDuGO $Ancetre $Type] if {$NiveauDuGO == "" || $NiveauGOMin == "" || $NiveauDuGO < $NiveauGOMin} {continue} set TabTmp(Cluster,$ClusterFusionne,$Ancetre) 1 } } ### Liste de tous les GO interessants d'un cluster, chaque GO est mis autant de fois ### qu'il est present dans le cluster ### set TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,LesGO) {} foreach Clust [O2C2O ClusterFusionne $ClusterFusionne LesClusters] { foreach Nom [O2C2O Cluster $Clust LesOrfs] { foreach GO [InterrogeGeneOntology $FichierBestGOProttfa $Nom LesGO] { if {[info exists TabTmp($Nom,$GO)]} {continue} set TabTmp($Nom,$GO) 1 if {[info exists TabTmp(Cluster,$ClusterFusionne,$GO)]} { lappend TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,LesGO) $GO } foreach Ancetre [InterrogeGeneOntology $FichierBestGOProttfa GO $GO LesAncetres] { if {[info exists TabTmp($Nom,$Ancetre)]} {continue} set TabTmp($Nom,$Ancetre) 1 if {[info exists TabTmp(Cluster,$Clust,$Ancetre)]} { lappend TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,LesGO) $Ancetre } } } } } ### Determine les differents effectifs de GO necessaires pour le calcul du Zscore ### foreach GO [set TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,LesGO)] { set Type [Onto $GO Type] if {![info exists TabZScoreDesGeneOntologyDesClustersFusionnes($Type,NbGO)]} { set TabZScoreDesGeneOntologyDesClustersFusionnes($Type,NbGO) 0 } ### N ### incr TabZScoreDesGeneOntologyDesClustersFusionnes($Type,NbGO) if {![info exists TabZScoreDesGeneOntologyDesClustersFusionnes($Type,$ClusterFusionne,NbGO)]} { set TabZScoreDesGeneOntologyDesClustersFusionnes($Type,$ClusterFusionne,NbGO) 0 } ### R ### incr TabZScoreDesGeneOntologyDesClustersFusionnes($Type,$ClusterFusionne,NbGO) if {![info exists TabZScoreDesGeneOntologyDesClustersFusionnes($GO,n) ]} { set TabZScoreDesGeneOntologyDesClustersFusionnes($GO,n) 0 } ### n ### incr TabZScoreDesGeneOntologyDesClustersFusionnes($GO,n) if {![info exists TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,$GO,n) ]} { set TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,$GO,n) 0 } ### r ### incr TabZScoreDesGeneOntologyDesClustersFusionnes($ClusterFusionne,$GO,n) } } if {[info exists TabTmp]} {unset TabTmp} ### GO du cluster d'interet conserve si zscore >= seuil ### set LeTexte {} foreach Cluster $LesClustersFusionnes { set LesGODuCluster {} foreach GO [lsort -unique [set TabZScoreDesGeneOntologyDesClustersFusionnes($Cluster,LesGO)]] { set Type [Onto $GO Type] set r [set TabZScoreDesGeneOntologyDesClustersFusionnes($Cluster,$GO,n) ] set R [set TabZScoreDesGeneOntologyDesClustersFusionnes($Type,$Cluster,NbGO) ] set n [set TabZScoreDesGeneOntologyDesClustersFusionnes($GO,n) ] set N [set TabZScoreDesGeneOntologyDesClustersFusionnes($Type,NbGO) ] set ZScore [ZScore $r $R $n $N ] if {$ZScore < $ZscoreMinDuCluster} {continue} set Def [lindex [Onto $Type $GO LesDefinitions] 0] lappend LesGODuCluster [list $Cluster $Type $GO $Def $r $R $n $N $ZScore] } foreach LeGODuCluster [lsort -index 1 [lsort -decreasing -real -index end $LesGODuCluster]] { lappend LeTexte [join $LeGODuCluster "\t"] } } Sauve [join $LeTexte "\n"] dans $FichierOut return $LeTexte } proc Fichier_4_ChiffresSurLesProteinesTrouveesDeRetPolyQ_These {Fichier} { set Rep [RepertoireDuGenome] set FichierOCADE "$Rep/fiches/Orf2Cluster2Access2Def2Expression" set LesNoms [AskClust_Gretta LesNoms ] set LesClusters [AskClust_Gretta LesClusters] lappend LesClusters "Total" foreach Cluster $LesClusters { set Tab($Cluster,NbSeq) 0 set Tab($Cluster,NoProt) 0 set Tab($Cluster,NbProtTot) 0 set Tab($Cluster,NbProtContig) 0 set Tab($Cluster,NbProt) 0 set Tab($Cluster,NbProtCont,moinsde1000) 0 set Tab($Cluster,NbProtCont,1001a2000) 0 set Tab($Cluster,NbProtCont,2001a3000) 0 set Tab($Cluster,NbProtCont,3001a4000) 0 set Tab($Cluster,NbProtCont,4001a5000) 0 set Tab($Cluster,NbProtCont,plusde5000) 0 set Tab($Cluster,NbProt,5UTR) 0 set Tab($Cluster,NbProt,CDS) 0 set Tab($Cluster,NbProt,3UTR) 0 set Tab($Cluster,NbProt,5UTRCDS) 0 set Tab($Cluster,NbProt,CDS3UTR) 0 set Tab($Cluster,NbProt,5UTRCDS3UTR) 0 set Tab($Cluster,Prot,Mouse) 0 set Tab($Cluster,Prot,Human) 0 set Tab($Cluster,Prot,Rat) 0 set Tab($Cluster,Prot,Other) 0 } foreach Cluster $LesClusters { if {$Cluster == "Total"} { set LesN $LesNoms } else { set LesN [AskClust_Gretta Cluster $Cluster LesNoms] } foreach Nom $LesN { Espionne "$Cluster $Nom" incr Tab($Cluster,NbSeq) set FTFA "$Rep/prottfa/$Nom" if {![file exists $FTFA]} {incr Tab($Cluster,NoProt);continue} incr Tab($Cluster,NbProtTot) set AccProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {($AccProt != "NOPROTEIN" && $AccmRNA != "") || ($AccmRNA != "NOMRNA" && $AccmRNA != "")} { incr Tab($Cluster,NbProt) set CDS [InterrogeProtAndmRNA $Nom Rang 1 NbElementsDeLaQuery DansLeCDS ] set 5UTR [InterrogeProtAndmRNA $Nom Rang 1 NbElementsDeLaQuery DansLe5UTR] set 3UTR [InterrogeProtAndmRNA $Nom Rang 1 NbElementsDeLaQuery DansLe3UTR] set ID [InterrogeProtAndmRNA $Nom Rang 1 Id ] set Orga [InterrogeProtAndmRNA $Nom Rang 1 Organism ] if {$Orga == "Mus musculus"} { incr Tab($Cluster,Prot,Mouse) } elseif {$Orga == "Homo sapiens"} { incr Tab($Cluster,Prot,Human) } elseif {$Orga == "Rattus norvegicus"} { incr Tab($Cluster,Prot,Rat) } else { incr Tab($Cluster,Prot,Other) } if {$5UTR != 0 && $CDS == 0 && $3UTR == 0} {incr Tab($Cluster,NbProt,5UTR) } if {$5UTR == 0 && $CDS != 0 && $3UTR == 0} {incr Tab($Cluster,NbProt,CDS) } if {$5UTR == 0 && $CDS == 0 && $3UTR != 0} {incr Tab($Cluster,NbProt,3UTR) } if {$5UTR != 0 && $CDS != 0 && $3UTR == 0} {incr Tab($Cluster,NbProt,5UTRCDS) } if {$5UTR == 0 && $CDS != 0 && $3UTR != 0} {incr Tab($Cluster,NbProt,CDS3UTR) } if {$5UTR != 0 && $CDS != 0 && $3UTR != 0} {incr Tab($Cluster,NbProt,5UTRCDS3UTR)} continue } set AccessProt [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$AccessProt != ""} { incr Tab($Cluster,NbProtContig) set Orga [InterrogeContigAndProt $Nom Contig Organisme] set ID [InterrogeContigAndProt $Nom Protein Identity ] set DIST [InterrogeContigAndProt $Nom Protein Distance ] if {$DIST <= 1000 } {incr Tab($Cluster,NbProtCont,moinsde1000)} if {1001 <= $DIST && $DIST < 2000} {incr Tab($Cluster,NbProtCont,1001a2000) } if {2001 <= $DIST && $DIST < 3000} {incr Tab($Cluster,NbProtCont,2001a3000) } if {3001 <= $DIST && $DIST < 4000} {incr Tab($Cluster,NbProtCont,3001a4000) } if {4001 <= $DIST && $DIST < 5000} {incr Tab($Cluster,NbProtCont,4001a5000) } if {5001 <= $DIST } {incr Tab($Cluster,NbProtCont,plusde5000) } if {$Orga == "Mus musculus"} { incr Tab($Cluster,Prot,Mouse) } elseif {$Orga == "Homo sapiens"} { incr Tab($Cluster,Prot,Human) } elseif {$Orga == "Rattus norvegicus"} { incr Tab($Cluster,Prot,Rat) } else { incr Tab($Cluster,Prot,Other) } continue } } } set LeTexte {} lappend LeTexte "Cluster\tNombre de sequences\tPas de proteines\tNombre de Proteines\tNombre de proteines souris\tNombre de proteines rat\tNombre de proteines humaine\tNombre de proteines appartenant a d'autres organismes\tNombre de proteines trouvees par les deux protocoles classiques\t5'UTR\t5'UTR et CDS\tCDS\tCDS et 3'UTR\t3'UTR\t5'UTR, CDS et 3'UTR\tNombre de proteines trouvees par le protocole indirect\tmoins de 1000\t1001 a 2000\t2001 a 3000\t3001 a 4000\t4001 a 5000\tplus de 5000" foreach Cluster $LesClusters { set NbSeq [set Tab($Cluster,NbSeq) ] set NoProt [set Tab($Cluster,NoProt) ] set NbProtTot [set Tab($Cluster,NbProtTot) ] set NbProtContig [set Tab($Cluster,NbProtContig) ] set NbProt [set Tab($Cluster,NbProt) ] set Nbmoinsde1000 [set Tab($Cluster,NbProtCont,moinsde1000)] set Nb1001a2000 [set Tab($Cluster,NbProtCont,1001a2000) ] set Nb2001a3000 [set Tab($Cluster,NbProtCont,2001a3000) ] set Nb3001a4000 [set Tab($Cluster,NbProtCont,3001a4000) ] set Nb4001a5000 [set Tab($Cluster,NbProtCont,4001a5000) ] set Nbplusde5000 [set Tab($Cluster,NbProtCont,plusde5000) ] set NbProt5UTR [set Tab($Cluster,NbProt,5UTR) ] set NbProtCDS [set Tab($Cluster,NbProt,CDS) ] set NbProt3UTR [set Tab($Cluster,NbProt,3UTR) ] set NbProt5UTRCDS [set Tab($Cluster,NbProt,5UTRCDS) ] set NbProtCDS3UTR [set Tab($Cluster,NbProt,CDS3UTR) ] set NbProt5UTRCDS3UTR [set Tab($Cluster,NbProt,5UTRCDS3UTR) ] set NbMouse [set Tab($Cluster,Prot,Mouse) ] set NbHuman [set Tab($Cluster,Prot,Human) ] set NbRat [set Tab($Cluster,Prot,Rat) ] set NbOther [set Tab($Cluster,Prot,Other) ] lappend LeTexte "$Cluster\t$NbSeq\t$NoProt\t$NbProtTot\t$NbMouse\t$NbRat\t$NbHuman\t$NbOther\t$NbProt\t$NbProt5UTR\t$NbProt5UTRCDS\t$NbProtCDS\t$NbProtCDS3UTR\t$NbProt3UTR\t$NbProt5UTRCDS3UTR\t$NbProtContig\t$Nbmoinsde1000\t$Nb1001a2000\t$Nb2001a3000\t$Nb3001a4000\t$Nb4001a5000\t$Nbplusde5000" } Sauve [join $LeTexte "\n"] dans $Fichier return } proc Fichier_6_ChiffresSurApportDeGOAnnoDesProteinesDeRetPolyQ_These {Fichier} { set Rep [RepertoireDuGenome] set FichierOCADE "$Rep/fiches/Orf2Cluster2Access2Def2Expression" set RepGOXML "$Rep/GeneOntology" set LesNoms [AskClust_Gretta LesNoms] #set LesClusters [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] set LesClusters [AskClust_Gretta LesClusters] lappend LesClusters "Total" foreach Cluster $LesClusters { set Tab($Cluster,NbProtIPO) 0 set Tab($Cluster,NbProtIPO_Func) 0 set Tab($Cluster,NbProtIPO_Proc) 0 set Tab($Cluster,NbProtIPO_Comp) 0 set Tab($Cluster,NbAnnoIPO) 0 set Tab($Cluster,NbAnnoIPO_Func) 0 set Tab($Cluster,NbAnnoIPO_Proc) 0 set Tab($Cluster,NbAnnoIPO_Comp) 0 set Tab($Cluster,NbProtGPO) 0 set Tab($Cluster,NbProtGPO_Func) 0 set Tab($Cluster,NbProtGPO_Proc) 0 set Tab($Cluster,NbProtGPO_Comp) 0 set Tab($Cluster,NbAnnoGPO) 0 set Tab($Cluster,NbAnnoGPO_Func) 0 set Tab($Cluster,NbAnnoGPO_Proc) 0 set Tab($Cluster,NbAnnoGPO_Comp) 0 set Tab($Cluster,NbProt) 0 } foreach Cluster $LesClusters { if {$Cluster == "Total"} { set LesN $LesNoms } else { set LesN [AskClust_Gretta Cluster $Cluster LesNoms] } foreach Nom $LesN { Espionne "$Cluster $Nom" set FileGOXML "$Rep/GeneOntology/$Nom.xml" set FPTFA "$Rep/prottfa/$Nom" AskGOAnalyse unset if {![file exists $FPTFA ]} {continue} incr Tab($Cluster,NbProt) if {![file exists $FileGOXML]} {continue} set nIPOTot 0 set nGPOTot 0 set Func 0 set Proc 0 set Comp 0 #function set LesIPO [AskGOAnalyse $FileGOXML Methode IPO Type "function" LesGO] set nIPO [llength $LesIPO] set LesGPO [AskGOAnalyse $FileGOXML Methode GPO Type "function" LesGO] set nGPO [llength $LesGPO] if {$nGPO < $nIPO} {set nGPO $nIPO} if {0 < $nIPO} {incr Tab($Cluster,NbProtIPO_Func)} if {0 < $nGPO} {incr Tab($Cluster,NbProtGPO_Func)} incr nIPOTot $nIPO incr nGPOTot $nGPO incr Tab($Cluster,NbAnnoIPO_Func) $nIPO incr Tab($Cluster,NbAnnoGPO_Func) $nGPO #process set LesIPO [AskGOAnalyse $FileGOXML Methode IPO Type "process" LesGO] set nIPO [llength $LesIPO] set LesGPO [AskGOAnalyse $FileGOXML Methode GPO Type "process" LesGO] set nGPO [llength $LesGPO] if {$nGPO < $nIPO} {set nGPO $nIPO} if {0 < $nIPO} {incr Tab($Cluster,NbProtIPO_Proc)} if {0 < $nGPO} {incr Tab($Cluster,NbProtGPO_Proc)} incr nIPOTot $nIPO incr nGPOTot $nGPO incr Tab($Cluster,NbAnnoIPO_Proc) $nIPO incr Tab($Cluster,NbAnnoGPO_Proc) $nGPO #component set LesIPO [AskGOAnalyse $FileGOXML Methode IPO Type "component" LesGO] set nIPO [llength $LesIPO] set LesGPO [AskGOAnalyse $FileGOXML Methode GPO Type "component" LesGO] set nGPO [llength $LesGPO] if {$nGPO < $nIPO} {set nGPO $nIPO} if {0 < $nIPO} {incr Tab($Cluster,NbProtIPO_Comp)} if {0 < $nGPO} {incr Tab($Cluster,NbProtGPO_Comp)} incr nIPOTot $nIPO incr nGPOTot $nGPO incr Tab($Cluster,NbAnnoIPO_Comp) $nIPO incr Tab($Cluster,NbAnnoGPO_Comp) $nGPO #All if {0 < $nIPOTot} {incr Tab($Cluster,NbProtIPO)} if {0 < $nGPOTot} {incr Tab($Cluster,NbProtGPO)} incr Tab($Cluster,NbAnnoIPO) $nIPOTot incr Tab($Cluster,NbAnnoGPO) $nGPOTot } AskGOAnalyse unset } set LeTexte {} lappend LeTexte "Groupe\tNombre de proteines\tNombre de proteines annotees avec IPO\tNombre de proteines annotees avec GPO\tNombre de proteines annotees avec IPO en processus\tNombre de proteines annotees avec GPO en processus\tNombre de proteines annotees avec IPO en fonction\tNombre de proteines annotees avec GPO en fonction\tNombre de proteines annotees avec IPO en compartiment cellulaire\tNombre de proteines annotees avec GPO en compartiment cellulaire\tNombre de termes GO trouves avec IPO\tNombre de termes GO trouves avec GPO\tNombre de termes GO trouves avec IPO en processus\tNombre de termes GO trouves avec GPO en processus\tNombre de termes GO trouves avec IPO en fonction\tNombre de termes GO trouves avec GPO en fonction\tNombre de termes GO trouves avec IPO en compartiment cellulaire\tNombre de termes GO trouves avec GPO en compartiment cellulaire" foreach Cluster $LesClusters { set NbProtIPO [set Tab($Cluster,NbProtIPO) ] set NbProtIPO_Func [set Tab($Cluster,NbProtIPO_Func)] set NbProtIPO_Proc [set Tab($Cluster,NbProtIPO_Proc)] set NbProtIPO_Comp [set Tab($Cluster,NbProtIPO_Comp)] set NbAnnoIPO [set Tab($Cluster,NbAnnoIPO) ] set NbAnnoIPO_Func [set Tab($Cluster,NbAnnoIPO_Func)] set NbAnnoIPO_Proc [set Tab($Cluster,NbAnnoIPO_Proc)] set NbAnnoIPO_Comp [set Tab($Cluster,NbAnnoIPO_Comp)] set NbProtGPO [set Tab($Cluster,NbProtGPO) ] set NbProtGPO_Func [set Tab($Cluster,NbProtGPO_Func)] set NbProtGPO_Proc [set Tab($Cluster,NbProtGPO_Proc)] set NbProtGPO_Comp [set Tab($Cluster,NbProtGPO_Comp)] set NbAnnoGPO [set Tab($Cluster,NbAnnoGPO) ] set NbAnnoGPO_Func [set Tab($Cluster,NbAnnoGPO_Func)] set NbAnnoGPO_Proc [set Tab($Cluster,NbAnnoGPO_Proc)] set NbAnnoGPO_Comp [set Tab($Cluster,NbAnnoGPO_Comp)] set NbProt [set Tab($Cluster,NbProt) ] lappend LeTexte "$Cluster\t$NbProt\t$NbProtIPO\t$NbProtGPO\t$NbProtIPO_Proc\t$NbProtGPO_Proc\t$NbProtIPO_Func\t$NbProtGPO_Func\t$NbProtIPO_Comp\t$NbProtGPO_Comp\t$NbAnnoIPO\t$NbAnnoGPO\t$NbAnnoIPO_Proc\t$NbAnnoGPO_Proc\t$NbAnnoIPO_Func\t$NbAnnoGPO_Func\t$NbAnnoIPO_Comp\t$NbAnnoGPO_Comp" } set Texte [join $LeTexte "\n"] Sauve $Texte dans $Fichier return $Texte } proc FichiermRNAHsapLocalisation {{LesNoms ""} {NameFile mRNAHsapLocalisation_Human}} { if {![file exists "[RepertoireDuGenome]/Localisation"]} {file mkdir "[RepertoireDuGenome]/Localisation"} set FileLoc "[RepertoireDuGenome]/Localisation/$NameFile" if {[file exists $FileLoc]} { if {[OuiOuNon "$FileLoc exists. Would you want to keep this file ?"]} {return} File delete -force $FileLoc } set TailleFragment 100000 set LeTexte {} if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { set FileEM "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_exonicmap/$Nom" if {![file exists $FileEM]} {continue} set LesRangs [InterrogeFichierExonicMap $FileEM LesRangs] set BestLoc "BestLoc" set InfoLoc "MonoLoc" if {1 < [llength $LesRangs]} {set InfoLoc "PolyLoc";set BestLoc "BestPolyLoc"} foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FileEM Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FileEM Rang $Rang Contig ] set LesContigsFrag [InterrogeFichierExonicMap $FileEM Rang $Rang ContigFragments] set nChiffresFragContig [string length [lindex $LesContigsFrag 0]] set NbExonicAreas [InterrogeFichierExonicMap $FileEM Rang $Rang NbExonicAreas] if {$NbExonicAreas <= 0} {continue} set LesRegions {} for {set i 1} {$i <= $NbExonicAreas} {incr i} { set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i nAli ] set Id [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i Identity] lappend LesRegions [list $i $nAli $Id] } set LesRegions [lsort -index 1 -real -decreasing [lsort -index 2 -real -decreasing $LesRegions]] set nAliMax [lindex [lindex $LesRegions 0] 1] set EstCeLePremier 1 foreach LaRegion $LesRegions { set Info "" if {$EstCeLePremier} {set Info $BestLoc;set EstCeLePremier 0} set ExonArea [lindex $LaRegion 0] set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea nAli ] set Id [expr [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Identity]/100] set DQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DQ ] set FQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FQ ] set DS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DS ] set FS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FS ] set Orient [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Orientation] set Sens [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Sens ] set Fragments "" if {0 < $nChiffresFragContig} { set FragmentMin [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Mini $DS $FS] / $TailleFragment)]] set FragmentMax [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Maxi $DS $FS] / $TailleFragment)]] set Fragments $FragmentMin if {$FragmentMin != $FragmentMax} {set Fragments [string trim "$FragmentMin $FragmentMax"]} } set LaLocSurLeChrom [CoordonneesSurChromosome $Contig $DS $FS $Sens] set DChrom [lindex $LaLocSurLeChrom 1] set FChrom [lindex $LaLocSurLeChrom 2] set SensChrom [lindex $LaLocSurLeChrom 3] set BandesCyto {} foreach LaBC [LesBandesCytologiquesDeLaRegion [NumeroDuChromosome $Chromosome] $DChrom $FChrom] { lappend BandesCyto [lindex $LaBC 0] } set BandesCyto [join $BandesCyto " "] set EMax "" set E "" set Ligne "$Nom\t$InfoLoc\t$EMax\t$E\t$nAliMax\t$nAli\t$Id\t$DQ\t$FQ\t$Chromosome\t$DChrom\t$FChrom\t$SensChrom\t$Contig\t$Fragments\t$DS\t$FS\t$Orient\t$Sens\t$BandesCyto\t$Info\tmrnatfa_Homo_sapiens" Espionne $Ligne lappend LeTexte $Ligne } } InterrogeFichierExonicMap unset } Sauve [join $LeTexte "\n"] dans $FileLoc return } proc FichiersGeneOntologyParClusterXHda {FichierGO} { if {![file exists $FichierGO]} {return} set RepOntologyClustersXHda "[RepertoireDuGenome]/OntologyDesClustersXHda" if {![file exists $RepOntologyClustersXHda]} {file mkdir $RepOntologyClustersXHda} set NomFichier [file tail $FichierGO] set Fichier "$RepOntologyClustersXHda/$NomFichier" set F [open $FichierGO] while {[gets $F Ligne] >= 0} { set LaLigne [split $Ligne "\t"] set Orf [lindex $LaLigne 0] set Cluster [O2C2O Orf $Orf Cluster] set FichierOut "${Fichier}_clusterXhda_$Cluster" AppendAuFichier $FichierOut $Ligne } close $F return } proc FichiersHTMLAvecLiens {Nom {Prefix ""}} { if {$Nom==""} {return ""} set Fichier_html "[RepertoireDuGenome]/bilan/html_nolink/$Nom.html" Espionne $Fichier_html set NomFichierHtml [file tail $Fichier_html] set LesTexteRef {} if {$Prefix=="SSH"} { lappend LesTexteRef "Forschungszentrum Karlsruhe" "http://www.fzk.de/" lappend LesTexteRef "Chromosomal localisation:" "localisation_SSH.gif" } if {$Prefix=="HNK"} { lappend LesTexteRef "IGBMC" "http://www-igbmc.u-strasbg.fr/" lappend LesTexteRef "Chromosomal localisation:" "localisation_HNK.gif" } if {$Prefix=="PROS"} { lappend LesTexteRef "ProteoSys" "http://www.proteosys.com/" lappend LesTexteRef "Chromosomal localisation:" "localisation_PROS.gif" } lappend LesTexteRef "ProCureBioPharm" "http://www-igbmc.u-strasbg.fr/projets/ProCureBioPharm/" lappend LesTexteRef "Access/Clone:" "sequences/$NomFichierHtml" lappend LesTexteRef "Multiple alignment:" "msf/$NomFichierHtml" set Page [ContenuDuFichierAvecReferences $Fichier_html $LesTexteRef] #set TexteHtml [Html_DuTexteTelQuel $Page $Nom] Sauve $Page dans "[RepertoireDuGenome]/bilan/$NomFichierHtml" } proc FichiersHTMLAvecLiensPourTous {Prefix} { foreach Fichier_html [glob -nocomplain "[RepertoireDuGenome]/bilan/html_nolink/*.html"] { Espionne $Fichier_html set NomFichierHtml [file tail $Fichier_html] #Espionne $NomFichierHtml regsub ".html" $NomFichierHtml "" Nom #Espionne $Nom set LesTexteRef {} if {$Prefix=="SSH"} { lappend LesTexteRef "Forschungszentrum Karlsruhe" "http://www.fzk.de/" lappend LesTexteRef "Chromosomal localisation:" "localisation_SSH.gif" } if {$Prefix=="HNK"} { lappend LesTexteRef "IGBMC" "http://www-igbmc.u-strasbg.fr/" lappend LesTexteRef "Chromosomal localisation:" "localisation_HNK.gif" } if {$Prefix=="PROS"} { lappend LesTexteRef "ProteoSys" "http://www.proteosys.com/" lappend LesTexteRef "Chromosomal localisation:" "localisation_PROS.gif" } lappend LesTexteRef "ProCureBioPharm" "http://www-igbmc.u-strasbg.fr/projets/ProCureBioPharm/" lappend LesTexteRef "Access/Clone:" "sequences/$Nom" lappend LesTexteRef "Multiple alignment:" "msf/$Nom" set Page [ContenuDuFichierAvecReferences $Fichier_html $LesTexteRef] Sauve $Page dans "[RepertoireDuGenome]/bilan/$NomFichierHtml" } } proc FichiersModifiesParMRM {} { global RepertoireDuGenome set Tableau "" set AncienNom "" foreach Ligne [LesLignesDuFichier "${RepertoireDuGenome}/CompareMaskReMask.txt"] { scan $Ligne "%s %d %d %d %s" Nom Taille masking remasking suite if {[regexp " ReMasked " $Ligne] && $AncienNom != $Nom} { set LigneDuTableau [format "%s %4s\n" $Nom $Taille] append Tableau $LigneDuTableau set AncienNom $Nom } else {continue} } Espionne $Tableau if {[OuiOuNon "Do I save these Results ?"]} { set Fichier [FichierPourSaveAs "${RepertoireDuGenome}/BilanMRM/BilanMRM.txt"] if {$Fichier!=""} { Sauve $Tableau dans $Fichier } } } proc FichiersPrimers_TL {FichierNom RepPrimer RepPrimerSelect} { if {![file exists $RepPrimerSelect]} {file mkdir $RepPrimerSelect} foreach Nom [LesLignesDuFichier $FichierNom] { set Nom [string trim $Nom] if {$Nom == ""} {continue} foreach File [glob -nocomplain -directory $RepPrimer "$Nom*"] { set NameFile [file tail $File] set FileOut "$RepPrimerSelect/$NameFile" if {[file exists $FileOut]} {continue} Espionne "$Nom : $File -> $FileOut" file copy -force $File $FileOut } } return } proc FichiersRecapitulatifs_PO {} { set RepData "[RepertoireDuGenome]/DataAnalysis" if {![file exists $RepData]} {file mkdir $RepData} FichierRecapitulatifTotal_PO "$RepData/1_RecapitulatifTotal.txt" FichierRecapitulatifDesClusters_PO "$RepData/2_RecapitulatifDesClusters.txt" FichierRecapitulatifRedondanceDesProteinesInterClusters_PO "$RepData/3_RecapitulatifRedondanceDesProteinesInterClusters.txt" FichierRecapitulatifGODesClusters_PO "$RepData/4_RecapitulatifGODesClusters.txt" return } proc FichiersSEACI2FichierGO {FichierSansExtension {Sauve 1}} { set Fichier $FichierSansExtension set FichierGO "${Fichier}.go" Charge2GO Tab2GO foreach File [list "${Fichier}.ipr" "${Fichier}.ec" "${Fichier}.kw"] { if {![file exists $File]} {Warne "$File does not exist";continue} ChargeLesResultatsDeSEACI TabSEACI $File } if {![info exists TabSEACI(LesCategories)]} {return ""} set LesCategoriesAvecGO {} foreach Cat [set TabSEACI(LesCategories)] { if { ![info exists TabSEACI($Cat,LesRequetes)]} {continue} foreach Requete [set TabSEACI($Cat,LesRequetes)] { set n [set TabSEACI($Cat,$Requete)] set Requete [CorrigeLaRequete $Requete] if {![info exists Tab2GO($Requete)]} {continue} if {![info exists TabTmp($Cat)]} { set Tableau($Cat,LesRequetes) {} lappend LesCategoriesAvecGO $Cat set TabTmp($Cat) 1 } foreach GO [set Tab2GO($Requete)] { if {![info exists Tableau($Cat,$GO)]} { lappend Tableau($Cat,LesRequetes) $GO set Tableau($Cat,$GO) 0 } incr Tableau($Cat,$GO) $n } } } if {[info exists TabTmp]} {unset TabTmp} set Texte "" foreach Cat $LesCategoriesAvecGO { if {![info exists Tableau($Cat,LesRequetes)]} {continue} append Texte "\n$Cat\n" set TexteRequetes "" set EntryCount 0 foreach Requete [set Tableau($Cat,LesRequetes)] { set n [set Tableau($Cat,$Requete)] incr EntryCount $n append TexteRequetes " \n" append TexteRequetes " $Requete\n" append TexteRequetes " $n\n" append TexteRequetes " \n" } append Texte "$EntryCount\n" append Texte $TexteRequetes append Texte "\n" } if {$Sauve} {Sauve $Texte dans $FichierGO} return $Texte } proc FichiersSEACI2FichierGOPourTous {{LesNoms ""}} { global RepertoireDuGenome set FichierDistributionSansExt "$RepertoireDuGenome/lms/Distribution" FichiersSEACI2FichierGO $FichierDistributionSansExt if {$LesNoms == {}} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne "$Nom -> Requete 2 GO" set FichierSansExt "$RepertoireDuGenome/lms/$Nom" FichiersSEACI2FichierGO $FichierSansExt } return "" } proc FichiersTFADesDDDesSousRep {} { # DD pour Differential Display # ### Conversion des seq de clones de DD en format TFA ### ### Renomme les fichiers selon le nom de repertoire dans lequel ils sont ### ### Attention modifier i selon la numerotation voulue ### ### En une seule etape fait un fichier tfas ds le rep . des seq presentes dans les differents ### ### sous repertoires ### ### !!! Qd des seq de x exp diff sont donnees le meme jour ### ### !!! Qd on commence un projet car i est a 0 pour tous les repertoires ### set n 2 # Fichier de correspondances: clone - fichier ini - nouvel access - fichierTFA # set LesCorrespondances {} foreach Rep [list "20040324_ICBP_Down" "20040324_ICBP_Up" "20040324_TOPO_Down" "20040324_TOPO_Up"] { if {$Rep == "20040324_ICBP_Down"} {set NameDeRef "ICBP_D"} if {$Rep == "20040324_ICBP_Up" } {set NameDeRef "ICBP_U"} if {$Rep == "20040324_TOPO_Down"} {set NameDeRef "TOPO_D"} if {$Rep == "20040324_TOPO_Up" } {set NameDeRef "TOPO_U"} set i 0 # Pour tous les fichiers .seq des repertoires donnes foreach File [glob -nocomplain "./$Rep/*.seq"] { incr i # Numerotation des sequences tfa set Name [format "%s%${n}.${n}d" $NameDeRef $i] set Clone [file tail $File] regsub -nocase {\.seq$} $Clone "" Clone set Entete "$Name $Clone" set FileTFA "./$Name.tfa" set Seq "" foreach Ligne [LesLignesDuFichier $File] {append Seq [string trim $Ligne]} set SeqTFA [SequenceFormatTFA $Seq $Entete] #Espionne "$FileTFA $Entete\n$SeqTFA" Sauve $SeqTFA dans $FileTFA lappend LesCorrespondances "$Clone\t$File\t$Name\t$FileTFA" } } Sauve [join $LesCorrespondances "\n"] dans "./Correspondances.txt" return } proc FichiersTFADesDDDuSousRep {SousRep NameDeRef i} { # DD pour Differential Display # ### Conversion des seq de clones de DD en format TFA ### ### Renomme les fichiers selon le nom de repertoire dans lequel ils sont ### ### Attention, modifier i selon la numerotation voulue, == numero de derniere seq existante de cette exp ### ### Attention, modifier NameDeRef selon l'appellation des seq voulue == type d'exp ### ### En une seule etape fait un fichier tfas ds le rep . des seq presentes dans le SousRepertoire ### ### Qd des seq d'une seule exp sont donnees le meme jour ### #ex NameDeRef "ICBP_U" set n 2 # Fichier de correspondances: clone - fichier ini - nouvel access - fichierTFA # set LesCorrespondances {} # Pour tous les fichiers .seq du sous repertoire ou sont les seq foreach File [glob -nocomplain "./$SousRep/*.seq"] { Espionne $File incr i # Numerotation des sequences tfa set Name [format "%s%${n}.${n}d" $NameDeRef $i] set Clone [file tail $File] regsub -nocase {\.seq$} $Clone "" Clone set Entete "$Name $Clone" set FileTFA "./$Name.tfa" set Seq "" foreach Ligne [LesLignesDuFichier $File] {append Seq [string trim $Ligne]} set SeqTFA [SequenceFormatTFA $Seq $Entete] #Espionne "$FileTFA $Entete\n$SeqTFA" Sauve $SeqTFA dans $FileTFA lappend LesCorrespondances "$Clone\t$File\t$Name\t$FileTFA" } #Espionne [join $LesCorrespondances "\n"] Espionne "Correspondances_$NameDeRef.txt" Sauve [join $LesCorrespondances "\n"] dans "./Correspondances_$NameDeRef.txt" return } proc FichiersTFADuTableau {{FichierTable ""}} { if {$FichierTable == ""} { set FichierTable [ButineArborescence All [pwd]] } elseif {![file exists $FichierTable]} { return "" } set OneFilePerAccess 0 if {[OuiOuNon "Would you want to save each TFA sequence?"] } { set OneFilePerAccess 1 set RepTFAs [ChoisirUnRepertoire "Choose The Directory"] } set OneFileForAllAccess 0 if {[OuiOuNon "Would you want to save all your TFA sequence in AllSequence.tfa?"] } { if {![file exists $RepTFAs]} {[ChoisirUnRepertoire "Choose The Directory"]} set OneFileForAllAccess 1 } set ToutesLesSequencesTFA "" foreach Ligne [LesLignesDuFichier $FichierTable] { set LaLigne [split $Ligne "\t"] if {![regexp {[0-9]} [lindex $LaLigne 0]]} {continue} if {[lindex $LaLigne 3] != "GB"} { Espionne [lindex $LaLigne 1] continue } set Access [lindex $LaLigne 2] set Seq [SequenceDeLAccess $Access] if {$Seq == ""} { Espionne "$Access not found in database" set SeqTFA ">$Access not found" } else { set Entete ">$Access" set SeqTFA [SequenceFormatTFA $Seq $Entete] } if {$OneFilePerAccess == 1} { Espionne "$RepTFAs/$Access.tfa" Sauve $SeqTFA dans "$RepTFAs/$Access.tfa" } append ToutesLesSequencesTFA "$SeqTFA\n" } if {$OneFileForAllAccess == 1} {Sauve $ToutesLesSequencesTFA dans "$RepTFAs/AllSequence.tfa"} return $ToutesLesSequencesTFA } proc FilDeFerDe {liste pdbid} { global Tbond global PDB_[set pdbid]_AtmXYZ global PDB_[set pdbid]_NomAtm global PDB_[set pdbid]_NomRes # set Lch [lrange [array names PDB_[set pdbid]_AtmXYZ] 1 end] set Lch "A" foreach c $Lch { set LNat [set PDB_[set pdbid]_NomAtm($c)] set LNrs [set PDB_[set pdbid]_NomRes($c)] set Lxyz [set PDB_[set pdbid]_AtmXYZ($c)] set first 1 foreach Lx $Lxyz La $LNat r1 $LNrs { set r [AutreCodeLuc $r1] foreach a $La x $Lx { set Ar([string trim $a]) $x } foreach bd [set Tbond($r)] { lassign $bd a b if {$a eq "C-" || $b eq "C-"} {continue} set col1 [CouleurDeAtome $a] set col2 [CouleurDeAtome $b] TraceLigne $liste [set Ar($a)] [set Ar($b)] $col1 $col2 } if {$first} { set first 0 } else { TraceLigne $liste [set Ar(N)] $Cx [CouleurDeAtome "N"] [CouleurDeAtome "C"] } set Cx [set Ar(C)] unset Ar } } return } proc FilDeFerDe2 {liste pdbid} { global Tbond global PDB_[set pdbid]_AtmXYZ global PDB_[set pdbid]_NomAtm global PDB_[set pdbid]_NomRes # set Lch [lrange [array names PDB_[set pdbid]_AtmXYZ] 1 end] set Lch "A" foreach c $Lch { set LNat [set PDB_[set pdbid]_NomAtm($c)] set LNrs [set PDB_[set pdbid]_NomRes($c)] set Lxyz [set PDB_[set pdbid]_AtmXYZ($c)] set first 1 set colN [CouleurDeAtome "N"] set colCA [CouleurDeAtome "C"] set colC ${colCA} set colO [CouleurDeAtome "O"] foreach Lx $Lxyz La $LNat r1 $LNrs { set r [AutreCodeLuc $r1] # Trace N-CA CA-C C-O TraceLigne $liste [lindex $Lx 0] [lindex $Lx 1] ${colN} ${colCA} TraceLigne $liste [lindex $Lx 1] [lindex $Lx 2] ${colCA} ${colC} TraceLigne $liste [lindex $Lx 2] [lindex $Lx 3] ${colC} ${colO} if {$r ne "GLY"} { TraceLigne $liste [lindex $Lx 1] [lindex $Lx 4] ${colC} ${colC} if {$r ne "ALA"} { set Lb1 [lrange $Lx 4 end-1] set Ll1 [lrange $La 4 end-1] set i 5 foreach a1 $Lb1 l1 $Ll1 { set Lb2 [lrange $Lx $i end] set Ll2 [lrange $La $i end] foreach a2 $Lb2 l2 $Ll2 { if {[Dist2 $a1 $a2] <= 3.8025} { TraceLigne $liste $a1 $a2 [CouleurDeAtome $l1] [CouleurDeAtome $l2] } } incr i } } } if {$first} { set first 0 } else { TraceLigne $liste [lindex $Lx 0] $Cx ${colN} ${colC} } set Cx [lindex $Lx 2] } } return } proc File {Commande args} { Wup "Copyright 1999 Raymond Ripp" Wup "Tcl8.2 accepts much more 'file' commands then earlier versions" Wup " I wrote 'File' to try to run with these old versions" if {[info tclversion] >= 8.2} { return [eval file $Commande $args] } else { set Args $args if {[regexp -nocase "win" $tcl_platform(os)]} { if {[lindex $Args 0]=="-force"} { set Args [lreplace $args 0 0 "/Y"] } switch $Commande { "delete" { set Commande "erase" } } } else { if {[lindex $Args 0]=="-force"} { set Args [lreplace $args 0 0 "-f"] } switch $Commande { "delete" { set Commande "rm" } "rename" { set Commande "mv" } "copy" { set Commande "cp" } } } return [eval exec $Commande $Args] } } proc File2Line {File} { return [split [File2Text $File] "\n"] } proc File2Text {File} { if {![file exists $File]} {return} set f [open $File r] set Text [read -nonewline $f] close $f return $Text } proc FileAbsent {Fichier} { if {[FileExists $Fichier]} { return 0 } else { return 1 } } proc FileAttributeNode {} { set FileDw "/genomics/link/STRING_DW/STRING/10090" set FileUp "/genomics/link/STRING_UP/STRING/10090" set i 0 foreach Dw [LesLignesDuFichier $FileDw] { incr i set PNDw [PreferedNameStringFromProteins $Dw] if {[regexp "^ENS" $PNDw]} { set GnFromEnsembl [GnDesFromEnsembl $PNDw peptide Mus_musculus Gn] if {$GnFromEnsembl!=""} { set PNDw "$PNDw/$GnFromEnsembl" } else { set DesFromEnsembl [GnDesFromEnsembl $PNDw peptide Mus_musculus Des] if {$DesFromEnsembl!=""} {set PNDw "$PNDw/$DesFromEnsembl"} } } Espionne "$i $Dw $PNDw DW" set Ligne "$Dw\t$PNDw\tDW" lappend LesLignes $Ligne } foreach Up [LesLignesDuFichier $FileUp] { incr i set PNUp [PreferedNameStringFromProteins $Up] if {[regexp "^ENS" $PNUp]} { set GnFromEnsembl [GnDesFromEnsembl $PNUp peptide Mus_musculus Gn] if {$GnFromEnsembl!=""} { set PNUp "$PNUp/$GnFromEnsembl" } else { set DesFromEnsembl [GnDesFromEnsembl $PNUp peptide Mus_musculus Des] if {$DesFromEnsembl!=""} {set PNUp "$PNUp/$DesFromEnsembl"} } } Espionne "$i $Up $PNUp UP" set Ligne "$Up\t$PNUp\tUP" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans "/genomics/link/STRING_DW/STRING_DWUP/AttributeNode" } proc FileBilan {Liste} { Espionne "Creation du fichier BilanGeneral" set file {} if { ! [file exists "[RepertoireDuGenome]/Bilan/Summary"]} { File mkdir [RepertoireDuGenome]/Bilan/Summary } lappend file "SU;Nb of orthologs;Nb of Pfam;Nb of PDB;Nb of Interaction" foreach fichier $Liste { set n [split $fichier "/"] set filename [lindex $n [llength $n]-1] append line "$filename;" #Espionne "file: $filename" #modification ne pas prendre se fichier pas complet (ou faux) utiliser les fichiers du repertoires NewTfasDesCopains #set nbOrtho [expr [comptNbOrtho "[RepertoireDuGenome]/OrthoResult/$filename.fasta"] -1] set nbOrtho [expr [comptNbOrtho "[RepertoireDuGenome]/NewTfasDesCopains/$filename"] -1] append line "$nbOrtho;" set nbPfam [NBPfam "[RepertoireDuGenome]/macsimXml/$filename"] append line "$nbPfam;" set nbPDB [NbPdb [RepertoireDuGenome]/pdb/$filename] append line "$nbPDB;" #Resourdre le probleme des nomns de fichier pour String... corresponds pas aux codes utiliser actulement PUZ... #comment connaitre le nom du repertoire dans StringRep... set rep [glob -directory [RepertoireDuGenome]/StringRep *] foreach re $rep { #Espionne "$re/$filename" set nbInt [NbInt $re/$filename] append line "$nbInt;" } lappend file $line set line "" } set fileResult "[RepertoireDuGenome]/Bilan/Summary/bilan.csv" SauveLesLignes $file dans $fileResult } proc FileBilanPourTous {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/tfasdescopains} set r [glob -directory $directory *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } lappend listSeq $fichier FinPasTouche $f } FileBilan $listSeq } proc FileDBTSS {Nom NameRepTFA {IdMin 0.3} {Expect 0.001} {NbSubject 20} {Filter F}} { ###Execute la recherche dans DBTSS sur la sequence d'un fichier TFA set FileTFA "[RepertoireDuGenome]/$NameRepTFA/$Nom" if {![file exists $FileTFA]} { return } set FileDBTSS "$FileTFA.DBTSS" FileDBTSSSearches $FileTFA $FileDBTSS $IdMin $Expect $NbSubject $Filter return } proc FileDBTSS2DBBlast {} { ###Conversion des fichiers hspromoter.seq et mmpromoter.seq de DBTSS en fichiers .tfas### ###Insertion de l'info organisme dans l'entete de la sequence, HSA ou MMU### set LesSequencesTFAs {} foreach FichiersSeqDBTSS [DBTSSDir "Seq"] { Espionne $FichiersSeqDBTSS set NameFile [file tail $FichiersSeqDBTSS] if {[regexp "^mm" $NameFile]} { set Org "MMU" set Organism "Mus musculus" } elseif {[regexp "^hs" $NameFile]} { set Org "HSA" set Organism "Homo sapiens" } else { set Org "UNK" set Organism "Unknown unknown" } Espionne "$FichiersSeqDBTSS $Organism $Org" set F [open $FichiersSeqDBTSS] while {[gets $F Ligne]>=0} { set LesInfos [split $Ligne "\t" ] set Entete [string trim [lrange $LesInfos 0 8]] #Espionne $Entete if {[regexp -nocase {^>([0-9_a-z]+)} $Entete tmp Access]} { regsub ">$Access" $Entete ">$Org:$Access $Access" Entete } #Espionne $Entete set Seq [string trim [lindex $LesInfos 9]] set SeqTFA [SequenceFormatTFA $Seq $Entete] #Espionne $SeqTFA lappend LesSequencesTFAs $SeqTFA } close $F } if {$LesSequencesTFAs == {}} {return} Sauve [join $LesSequencesTFAs "\n"] dans [DBTSSDir "TFAs"] TFAs2DB [DBTSSDir "TFAs"] return } proc FileDBTSSPourTous {NameRepTFA {LesNoms ""} {IdMin 0.3} {Expect 0.001} {NbSubject 20} {Filter F}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne "$Nom -> DBTSS searches" FileDBTSS $Nom $NameRepTFA $IdMin $Expect $NbSubject $Filter } return } proc FileDPC2FileGO {FichierDPC {FichierGODesDPC ""}} { if {![file exists $FichierDPC]} {Warne "$FichierDPC does not exist";return ""} set TexteOnto "" set F [open $FichierDPC] while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} if {[regexp "^Number of clusters" $Ligne]} {continue} if {[regexp {^Cluster [0-9]*} $Ligne]} {scan $Ligne "%s %d" Clust nClust;continue} scan $Ligne "%s" Access set LesGO [Access2GO $Access] if {$LesGO == {} } { set Texte "$nClust\t$Access\tNoOntologyFound\n" Espionne $Texte append TexteOnto $Texte } else { foreach GO $LesGO { set Type [Onto $GO Type] set Definition [lindex [Onto $Type $GO LesDefinitions] 0] set Ancetres [join [TousLesAncetresOntologiques $Type $GO] "\t"] set Texte "$nClust\t$Access\t$Type\t$GO\t$Definition\t$Ancetres\n" Espionne $Texte append TexteOnto $Texte } } } close $F if {$FichierGODesDPC != ""} { Espionne $TexteOnto Sauve $TexteOnto dans $FichierGODesDPC } else { if {[OuiOuNon "Would You want to save these results ?"]} { set FichierGODesDPC "${FichierDPC}.ontology" if {[OuiOuNon "Would You want to save these results in $FichierGODesDPC ?"]} { Sauve $TexteOnto dans $FichierGODesDPC } else { FaireLire "Choose the name file" set FichierGODesDPC [Entre $FichierGODesDPC] if {![regexp -nocase {[0-9a-z]} $FichierGODesDPC]} {return $TexteOnto} Sauve $TexteOnto dans $FichierGODesDPC } } } return $TexteOnto } proc FileEPDIdOrga {{FileEPDTFAs ""} {FileOUT ""}} { ### Creation du fichier EPD_Id2Orga2Organism2OrganismLong dans [EPDDir ""] ### AskEPDOrgas unset # FileEPDTFAs == db avec les seq TFA de EPD if {$FileEPDTFAs == ""} {set FileEPDTFAs [EPDDir "TFAs" ]} if {$FileOUT == ""} {set FileOUT [EPDDir "EPDIdOrga"]} set LesInfos {} # Pour chaque access du fichier TFAs foreach EPDId [LaSequenceDuTFAs $FileEPDTFAs "LaListeDesAccess"] { # Extraction du TFA correspondant set TFA [LaSequenceDuTFAs $FileEPDTFAs $EPDId] if {$TFA == ""} {continue} set Entete [EnteteDuTexteTFA $TFA] set LEntete [split $Entete " "] set EPDId [regsub ">" [lindex $LEntete 0] ""] regexp -nocase {^[^\(\[]+} [lindex $LEntete 2] OrgaEPDId set OrganismEPDId [AskEPDOrgas EPDOrga $OrgaEPDId EPDOrganism ] set OrganismLongEPDId [AskEPDOrgas EPDOrga $OrgaEPDId EPDOrganismLong] lappend LesInfos "$EPDId\t$OrgaEPDId\t$OrganismEPDId\t$OrganismLongEPDId" #Espionne "$EPDId\t$OrgaEPDId\t$OrganismEPDId\t$OrganismLongEPDId" } #Espionne [join $LesInfos "\n"] AskEPDOrgas unset Sauve [join $LesInfos "\n"] dans $FileOUT return } proc FileEPDOrgas {{FileEPDOrgasTxt ""} {FileOUT ""}} { ### Creation du fichier EPD_Orga2Organism2OrganismLong dans [EPDDir ""] ### #FileEPDOrgasTxt == EPD_Species_Codes.txt qui est fait a la main if {$FileEPDOrgasTxt == ""} {set FileEPDOrgasTxt [EPDDir ""]/EPD_Species_Codes.txt} if {$FileOUT == ""} {set FileOUT [EPDDir "EPDOrgas"]} set LesInfos {} foreach Ligne [LesLignesDuFichier $FileEPDOrgasTxt] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne " "] set EPDOrga [lindex $LaLigne 0] set EPDOrganism [join [lrange $LaLigne 1 2 ]] set EPDOrganismLong [join [lrange $LaLigne 1 end]] lappend LesInfos "$EPDOrga\t$EPDOrganism\t$EPDOrganismLong" } #Espionne [join $LesInfos "\n"] Sauve [join $LesInfos "\n"] dans $FileOUT return } proc FileExists {Fichier} { return [file exists $Fichier] } proc FileFirstEF {Nom NameRepTFA {IdMin 0.3} {Expect 0.001} {NbSubject 20} {Filter F}} { ###Execute la recherche dans FirstEF sur la sequence d'un fichier TFA set FileTFA "[RepertoireDuGenome]/$NameRepTFA/$Nom" if {![file exists $FileTFA]} { return } set FileFirstEF "$FileTFA.FirstEF" FirstEF $FileTFA $FileFirstEF return } proc FileFirstEFPourTous {NameRepTFA {LesNoms ""} {IdMin 0.3} {Expect 0.001} {NbSubject 20} {Filter F}} { if {$LesNoms == ""} {set LesNoms [ListeDesPABs]} foreach Nom $LesNoms { Espionne "$Nom -> FirstEF searches" FileFirstEF $Nom $NameRepTFA $IdMin $Expect $NbSubject $Filter } return } proc FileInfosDuFileTFAs {FileTFAs FileOUT} { ### Creation d'un fichier contenant l'ensemble des infos du fileTFAs ### ### Ces infos sont: SeqName Id SeqLength Entete ### if {![file exists $FileTFAs]} {Espionne "FileTFAs $FileTFAs does not exists" ;return} set LesInfos {} set i 0 foreach TFA [LesTFADuFileTFAs $FileTFAs] { if {$TFA == ""} {continue} incr i ### 1- Extraction de l'information du FileTFAs ### set Entete [TFA2Header $TFA ] set Seq [TFA2SEQ $TFA ] #set LesRes [split $Seq "" ] set TailleSeq [string length [string trim $Seq]] ### Avant le scan car si le scan ne donne rien la variable Id n'est pas creee set TFAEntete ">$Entete" set Id $Entete scan $TFAEntete ">%s" Id set SeqName "Seq$i" ### 2- Stockage de l'information du FileTFAs dans le FileOUT ### #set Infos "$SeqName\t$Entete\t$Id\t$Seq\t$TailleSeq\t$LesRes" set Infos "$SeqName\t$Id\t$TailleSeq\t$Entete" lappend LesInfos $Infos } SaveInFile [join $LesInfos "\n"] $FileOUT return } proc FileMaskedAndReMasked {Nom} { global RepertoireDuGenome set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom" set FichierTFAMasque "$RepertoireDuGenome/nucmask/$Nom.m" set FichierTFAReMasque "$RepertoireDuGenome/nucmask/$Nom.rm" set FichierTFAMasqueEtReMasque "$RepertoireDuGenome/nucmask/$Nom.mrm" if { ! [file exists $FichierTFA ] || ! [file exists $FichierTFAMasque ] || ! [file exists $FichierTFAReMasque ] || ! [file exists $FichierTFAMasqueEtReMasque]} { return "" } AfficheVariable "[ContenuDuFichier $FichierTFA]\n [ContenuDuFichier $FichierTFAMasque]\n [ContenuDuFichier $FichierTFAReMasque]\n [ContenuDuFichier $FichierTFAMasqueEtReMasque]" } proc FileMoi {{Quoi ""} {Qui ""} {Comment ""}} { if {[regexp " " $Quoi] && $Qui==""} { set Qui [split $Quoi " "] set Quoi "SearchList" } PourWscope 1 set AboutRetinalGene 0 set LesRefText {} if {$Quoi=="InterrogeCopainsDesCompulsory"} { set TexteHtml [InterrogeCopainsDesCompulsory $Qui] if {$TexteHtml!=""} { return $TexteHtml } } if {($Quoi=="" && $Qui=="") || $Quoi=="BaList" || $Quoi=="SearchList" || $Quoi=="GscopeIdsList" || $Quoi=="RetinalGeneList"} { if {$Quoi=="BaList"} { set Liste [BaList $Qui] set Quoi "" set Qui "" } elseif {$Quoi=="GscopeIdsList"} { set Liste [split $Qui " "] set Quoi "" set Qui "" } elseif {$Quoi=="SearchList"} { set Liste [RepereBox $Qui "AllPlease"] set Quoi "" set Qui "" } elseif {$Quoi=="RetinalGeneList"} { set Liste [RetinalGene "ListAll" "GscopeIds"] set AboutRetinalGene 1 set Quoi "" set Qui "" } else { set Liste [ListeDesPABs] } if {[PourWscope]} { foreach Nom $Liste { if {[OnTraiteSpine]} { set SurNom [SpineID $Nom] } elseif {$AboutRetinalGene} { set SurNom [RetinalGene "GeneNameOf" $Nom] } else { set SurNom [Alias $Nom] if {$SurNom==""} { set SurNom [ExtraitInfo $Nom "ValiGN"] } } set Info "$Nom\t$SurNom\t[string range [DefinitionRapide $Nom] 0 80]" if {[OnTraiteEVImm] || [OnTraiteGGmm] || [OnTraiteGGWmm] || [OnTraiteEVIhs] || [OnTraiteGGhs] || [OnTraiteGGWhs]} { set RRC [RecapitulatifRetChipCourt $Nom] if {$RRC!=""} { regsub -all ";" $RRC " " RRC } lappend LesRefText "[WscopeScience]&GeneIdentityCard&$Nom" $Info } else { lappend LesRefText "[WscopeScience]&FileMoi&$Nom" $Info } } if {$Comment=="TelQuel"} { return [join $LesRefText "\n"] } return [Html_ListOfRefs $LesRefText "

Please click on a [PreFixe]

" "PleaseSplitText"] } foreach Nom $Liste { set Info [format "%s %-8s %s" $Nom [Alias $Nom] [DefinitionRapide $Nom]] lappend LesNoms $Nom lappend LesInfos $Info } set Qui [ChoixParmiJoli $LesNoms {} $LesInfos] if {$Qui==""} { return "" } return [FileMoi $Qui] } if {[EstUnPAB $Quoi]} { set W $Qui set Qui $Quoi set Quoi $W } set PosMacsim 0 if {$Quoi==""} { if {[PourWscope]} { DerniereVisite $Qui set MacsimHtml 0 set LesRefText {} LConcat LesRefText [WscopeLinks "FileMoi" $Qui] set PosMacsim [llength $LesRefText] foreach Rep [lsort [LesRepertoiresPossiblesPour $Qui "HtmlAussi" "Vite"]] { if {$Rep=="macsimHtml"} { set MacsimHtml 1 } set DescDuRepertoire [DescDuRepertoire $Rep] lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$Qui" "$Rep\t$DescDuRepertoire" if {$Rep=="macsimXml" } { set Rep "macsimHtml" set DescDuRepertoire [DescDuRepertoire $Rep] set R "[WscopeScience]&FileMoi&$Rep&$Qui" set T "$Rep\t$DescDuRepertoire" lappend LesRefText $R $T set LesRefText [linsert $LesRefText $PosMacsim $R $T] set RepJal "macsimJalview" set DescDuRepertoire [DescDuRepertoire $RepJal] set R "[WscopeScience]&JalviewHtml&$Qui" set T "$RepJal\t$DescDuRepertoire" lappend LesRefText $R $T set LesRefText [linsert $LesRefText $PosMacsim $R $T] } if {[regexp "phylo" $Rep] } { set Rep "AtvOf$Rep" set DescDuRepertoire [DescDuRepertoire $Rep] lappend LesRefText "[WscopeScience]&ATV&$Qui" "$Rep\t$DescDuRepertoire" } if {$Rep=="msf" } { set Rep "msfToHtml" set DescDuRepertoire [DescDuRepertoire $Rep] lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$Qui" "$Rep\t$DescDuRepertoire" continue } if {[regexp "msf" $Rep] } { set RepOri $Rep set Rep "msfToHtml" set DescDuRepertoire [DescDuRepertoire $Rep] lappend LesRefText "[WscopeScience]&FileMoi&$Rep&$RepOri/$Qui" "${RepOri}ToHtml\t$DescDuRepertoire" } } if {$LesRefText=={}} { return "I didn't found any file about $Qui" } return [Html_ListOfRefs $LesRefText "

$Qui [Alias $Qui] [DefinitionRapide $Qui]
please click

" "PleaseSplitText"] } set Quoi [ChoixParmi [LesRepertoiresPossiblesPour $Qui]] if {$Quoi==""} { return "" } } if {$Quoi!="" && $Qui==""} { return "Sorry Target not available" } if {$Comment==""} { set Comment "EnHTML" } set Titre "[file tail [RepertoireDuGenome]]/$Quoi/$Qui" set EstUnJpg 0 set EstDejaEnHtml 0 set Probable "[RepertoireDuGenome]/$Quoi/$Qui" while 1 { if {[regexp {^[0-9][0-9][0-9]$} $Quoi] && [string equal [string range [Date] 6 8] $Quoi] } { if {[file exists $Qui]} { set Probable $Qui } } if {[file exists $Probable]} { set EstDejaEnHtml [regexp -nocase {\.html?$} $Probable] break } if {[file exists "$Probable.html"]} { append Probable ".html" set EstDejaEnHtml 1 break } if {$Quoi=="^AtvOf"} { set TexteHtml [ATV $Qui] if {$TexteHtml!=""} { return $TexteHtml } } if {$Quoi=="msfToHtml"} { set TexteHtml [HtmlFromMsf $Qui] if {$TexteHtml!=""} { return $TexteHtml } } if {$Quoi=="macsimHtml"} { set TexteHtml [HtmlFromXmlMacsim $Qui] if {$TexteHtml!=""} { return $TexteHtml } } if {[regexp "jpg_of_" $Quoi] } { set Type [StringApres "jpg_of" dans $Quoi] set ProPro "$Probable$Type.jpg" if {[FileExists $ProPro]} { append Probable "$Type.jpg" set EstUnJpg 1 break } } if {[regexp -nocase ".jpg$" $Probable] } { set EstUnJpg 1 break } return "Sorry $Quoi/$Qui does not exist or cannot be created" } if { [regexp -nocase "TelQuel" $Comment] || $EstDejaEnHtml } { set R [ContenuDuFichier $Probable] if { ! $EstDejaEnHtml & [regexp -nocase "AvecPre" $Comment] } { return "

$R

" } return $R } if {$EstUnJpg} { return [Html_DuFichierJpg $Probable] } if {[EstUnPAB $Qui]} { return [SeeAby $Quoi $Qui] } return [Html_DuTexteTelQuel [ContenuDuFichierAvecReferences $Probable] $Titre] return [Html_DuTexteTelQuel [ContenuDuFichier $Probable] $Titre] } proc FileMoiAlias {{Qui ""} {Quoi ""} {Comment ""}} { #rR Attention Qui Quoi et non pas Quoi Qui" if {[set Nom [NomDuAlias $Qui]]==""} { return [Html_DuTexteTelQuel "Sorry, I found nothing about $Qui"] } return [FileMoi $Quoi $Nom $Comment] } proc FileMoiRetinalGene {{Qui ""} {Quoi ""} {Comment ""}} { #rR Attention Qui Quoi et non pas Quoi Qui" if {[set Nom [lindex [RetinalGene GscopeIdsOf $Qui] 0]]==""} { return [Html_DuTexteTelQuel "Sorry, I found nothing about $Qui"] } return [FileMoi $Quoi $Nom $Comment] } proc FileMoiSearchList {{Qui ""} {Comment ""}} { return [FileMoi "SearchList" $Qui $Comment] } proc FileMoiSignalIntensityImages {Nom} { set Titre "All images for Signal Intensityof $Nom" Html_ZeroToBody Html_Banner Wscope Html_Append $Titre foreach FicImage [glob -nocomplain "[RepertoireDuGenome]/transcriptomique/SignalIntensityImages/$Nom*.png"] { set Queue [file tail $FicImage] Html_Append "
" Html_Append "" } return [Html_Get] } proc FileNom2Cluster2Access2Def2Expressions_DDdata {FichierCorrespondances RepData ITini} { #################################################################################### ### Aide a l'elaboratiuon du fichier Orf2Cluster2Access2Def2Expression ### ### pour le projet Gscope ICBP_TOPO a partir des donnees de differential display ### #################################################################################### if {![file exists $FichierCorrespondances]} {Espionne "Warning: Matching file $FichierCorrespondances does not exists" ; return } set F [open $FichierCorrespondances] set LesInfos {} while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Clone [lindex $LaLigne 0] set FileSeq [lindex $LaLigne 1] set Name [lindex $LaLigne 2] set FileTFA [lindex $LaLigne 3] #Espionne "Clone: $Clone\nFileSeq: $FileSeq\nName: $Name\nFileTFA: $FileTFA" if {$ITini< 1000} {set Nom "IT0$ITini"} else {set Nom "IT$ITini"} if {[regexp "ICBP_D" $Name]} {set Cluster "ICBP_D"} if {[regexp "ICBP_U" $Name]} {set Cluster "ICBP_U"} if {[regexp "TOPO_D" $Name]} {set Cluster "TOPO_D"} if {[regexp "TOPO_U" $Name]} {set Cluster "TOPO_U"} #Espionne "$Name $Cluster" set Def "$Nom $Name $Clone" if {$Cluster == "ICBP_D"} {set LesExpressions "1\t-1\t-1\t-1"} if {$Cluster == "ICBP_U"} {set LesExpressions "-1\t1\t-1\t-1"} if {$Cluster == "TOPO_D"} {set LesExpressions "-1\t-1\t1\t-1"} if {$Cluster == "TOPO_U"} {set LesExpressions "-1\t-1\t-1\t1"} lappend LesInfos "$Nom\t$Cluster\t$Clone\t$Def\t$LesExpressions" incr ITini #EspionneL $LesInfos } set FileOUT "$RepData/Nom2Cluster2Access2Def2Expressions_$Cluster" Sauve [join $LesInfos "\n"] dans $FileOUT return } proc FileTFADNA2Prot {FileTFA FileOut {Frame1ou2ou3 Frame1}} { if {![file exists $FileTFA]} {return} set TFA [File2Text $FileTFA] set TFAProt [TFADNA2Prot $TFA $Frame1ou2ou3] Sauve $TFAProt dans $FileOut return $TFAProt } proc FileTFAsDesGenesStat3AComparer_Gretta {FileGene FileTFAsOUT} { set LesTFAs {} set F [open $FileGene] set i 0 while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] set Ligne [split $Ligne "\t"] set Gene [lindex $Ligne 0] Espionne $Gene if {[info exists GetzOut]} {unset GetzOut} set Commande "[ProgPathway getz] \" \( \\\[protein-gen:$Gene*\\\] & \\\[protein-org:Mus musculus\\\] \)>\\\[genbankfull-des:mRNA\\\] \" -f seq -sf fasta" catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut] || $GetzOut == ""} { set Commande "[ProgPathway getz] \" \( \\\[protein-gen:$Gene*\\\] & \\\[protein-org:Rattus norvegicus\\\] \)>\\\[genbankfull-des:mRNA\\\] \" -f seq -sf fasta" catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut] || $GetzOut == ""} { Espionne "$Gene Not found" lappend LesTFAs ">$Gene Stat3 No sequence found" continue } } set i 0 foreach TFA [split $GetzOut ">"] { set TFA [string trim $TFA] if {$TFA == ""} {continue} incr i set TFA ">$Gene\$$i Stat3 $TFA" lappend LesTFAs $TFA } } close $F Sauve [join $LesTFAs "\n"] dans $FileTFAsOUT return } proc FilesPromAn {FileContigTFA DebutFirstExonPrediction FinFirstExonPrediction SensFirstExonPrediction FileAllPromAn FileSelectedPromAn {BorneDebutRechercheMotifs 2500} {BorneFinRechercheMotifs 500} {LesPattern ""} {Access ""} {Organism "Homo sapiens"} {IdMin 0.3} {Expect 0.001} {NbSubject 20} {Filter F} {nVar 0.05}} { ##### Creation du fichier d'analyse de promoteur a partir d'une séquence d'ARNm +/- x pb ##### #LesInfos : Type Debut Fin Sens TSSLoc TSSDist Identity Name Orga LesInfosSup if {![file exists $FileContigTFA]} { Espionne "$FileContigTFA does not exists" ; return } ############################### Sequence genomique ini et premier exon ############################### ### 1- Informations sur la sequence genomique de depart Espionne "GenomicSequence" PromAnPanel ini $FileAllPromAn "GenomicSequence" PromAnPanel ini $FileSelectedPromAn "GenomicSequence" foreach LaLigne [LaSequenceGenomiquePourPromAn $FileContigTFA $DebutFirstExonPrediction $Access $Organism] { PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] PromAnPanel add $FileSelectedPromAn [join $LaLigne "\t"] } ### 2- Informations sur le premier exon provenant de la carte exonique Espionne "FirstExon" PromAnPanel ini $FileAllPromAn "FirstExon" PromAnPanel ini $FileSelectedPromAn "FirstExon" foreach LaLigne [LePremierExonDumRNAPourPromAn $DebutFirstExonPrediction $FinFirstExonPrediction $SensFirstExonPrediction $Access $Organism] { PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] PromAnPanel add $FileSelectedPromAn [join $LaLigne "\t"] ###TSSDeRefFinal = le TSS de reference final suite au 1er exon, DBTSS et EPD pour la selection du meilleur eponine... ###par defaut = celui du 1er exon, le restera si pas de DBTSS et pas de EPD selectionnes set Tab(TSSDeRef,TSSDeRefFinal) [lindex $LaLigne 5] Espionne "First exon, TSSDeRef: [set Tab(TSSDeRef,TSSDeRefFinal)]" } ############################### Localisation du promoteur, du TSS ou du premier exon ############################### ### 3- Information sur les hits DBTSS Espionne "DBTSS" PromAnPanel ini $FileAllPromAn "DBTSS" PromAnPanel ini $FileSelectedPromAn "DBTSS" set nMax 0 set LesLignes {} foreach LaLigne [LesEPDouDBTSSSelectedPourPromAn $FileContigTFA "DBTSS" $IdMin $Expect $NbSubject $Filter $DebutFirstExonPrediction $nVar] { if {$LaLigne == ""} { continue } PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] ### Selection selon le sens if {[lindex $LaLigne 4] == "-"} { continue } ### Calcul de nMax set n [expr [lindex $LaLigne 7] * 1.0 / [TailleSequenceEPDOuDBTSS "DBTSS"]] if {$n > $nMax} {set nMax $n} lappend LesLignes $LaLigne } ### Selection selon nMax set LesSelectedTSSDist {} set LesSelectedLignes {} foreach LaLigne $LesLignes { set n [expr [lindex $LaLigne 7] * 1.0 / [TailleSequenceEPDOuDBTSS "DBTSS"]] if {$n < [expr $nMax * (1 - $nVar)]} { continue } lappend LesSelectedTSSDist [expr abs([lindex $LaLigne 6])] lappend LesSelectedLignes $LaLigne } #### Si plusieurs hits selectionnes, garde au final celui avec la TSSDist minimum foreach SelectedLigne $LesSelectedLignes { if {[expr abs([lindex $SelectedLigne 6])] != [MiniDeLaListe $LesSelectedTSSDist]} { continue } PromAnPanel add $FileSelectedPromAn [join $SelectedLigne "\t"] ###Si une DBTSS est selectionne, le TSSDeRefFinal devient le TSS de DBTSS set Tab(TSSDeRef,TSSDeDBTSS) [lindex $SelectedLigne 5] set Tab(TSSDeRef,TSSDistDeDBTSS) [lindex $SelectedLigne 6] set VATSSDistDeDBTSS [expr abs([set Tab(TSSDeRef,TSSDistDeDBTSS)])] #Espionne "VATSSDistDeDBTSS: $VATSSDistDeDBTSS" set Tab(TSSDeRef,TSSDeRefFinal) [set Tab(TSSDeRef,TSSDeDBTSS)] set Tab(TSSDeRef,$VATSSDistDeDBTSS,TSSLoc) [set Tab(TSSDeRef,TSSDeDBTSS)] break } #Espionne "DBTSS TSSDeRef,TSSDeDBTSS: [set Tab(TSSDeRef,TSSDeDBTSS)]" #Espionne "DBTSS TSSDeRef,TSSDistDeDBTSS: [set Tab(TSSDeRef,TSSDistDeDBTSS)]" #Espionne "DBTSS TSSDeRef,TSSDeRefFinal: [set Tab(TSSDeRef,TSSDeRefFinal)]" #Espionne "DBTSS TSSDeRef,TSSDistDBTSS,TSSLoc: $VATSSDistDeDBTSS [set Tab(TSSDeRef,$VATSSDistDeDBTSS,TSSLoc)]" ### 4- Information sur les hits EPD Espionne "EPD" PromAnPanel ini $FileAllPromAn "EPD" PromAnPanel ini $FileSelectedPromAn "EPD" set nMax 0 set LesLignes {} foreach LaLigne [LesEPDouDBTSSSelectedPourPromAn $FileContigTFA "EPD" $IdMin $Expect $NbSubject $Filter $DebutFirstExonPrediction $nVar] { if {$LaLigne == ""} { continue } PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] ###Selection selon le sens et selon nMax if {[lindex $LaLigne 4] == "-"} { continue } ###Calcul de nMax set n [expr [lindex $LaLigne 7] * 1.0 / [TailleSequenceEPDOuDBTSS "EPD"]] if {$n > $nMax} {set nMax $n} lappend LesLignes $LaLigne } set LesSelectedEPDDist {} set LesSelectedLignes {} foreach LaLigne $LesLignes { set n [expr [lindex $LaLigne 7] * 1.0 / [TailleSequenceEPDOuDBTSS "EPD"]] if {$n < [expr $nMax * (1 - $nVar)]} { continue } lappend LesSelectedEPDDist [expr abs([lindex $LaLigne 6])] lappend LesSelectedLignes $LaLigne } ####Si plusieurs hits selectionnes, garde au final celui avec la EPDDist minimum foreach SelectedLigne $LesSelectedLignes { if {[expr abs([lindex $SelectedLigne 6])] != [MiniDeLaListe $LesSelectedEPDDist]} { continue } PromAnPanel add $FileSelectedPromAn [join $SelectedLigne "\t"] ###Si pas de DBTSS selectionne, le TSS de ref devient celui du EPD selectionne set Tab(TSSDeRef,TSSDeEPD) [lindex $SelectedLigne 5] set Tab(TSSDeRef,TSSDistDeEPD) [lindex $SelectedLigne 6] set VATSSDistDeEPD [expr abs([set Tab(TSSDeRef,TSSDistDeEPD)])] #Espionne "VATSSDistDeEPD: $VATSSDistDeEPD" set Tab(TSSDeRef,$VATSSDistDeEPD,TSSLoc) [set Tab(TSSDeRef,TSSDeEPD)] if {![info exists Tab(TSSDeRef,TSSDeDBTSS)]} { set Tab(TSSDeRef,TSSDeRefFinal) [set Tab(TSSDeRef,TSSDeEPD)] } ###Si DBTSS et EPD selectionnes, le TSSDeRef devient celui le plus proche du TSS initial du 1er exon if {[info exists Tab(TSSDeRef,TSSDeDBTSS)] && [info exists Tab(TSSDeRef,TSSDeEPD)]} { #set TSSDistMin [Mini [set Tab(TSSDeRef,TSSDistDeDBTSS)] [set Tab(TSSDeRef,TSSDistDeEPD)]] set TSSDistMin [Mini $VATSSDistDeDBTSS $VATSSDistDeEPD] #Espionne "TSSDistMin: $TSSDistMin" set Tab(TSSDeRef,TSSDeRefFinal) [set Tab(TSSDeRef,$TSSDistMin,TSSLoc)] } break } #Espionne "EPD TSSDeRef,TSSDeEPD: [set Tab(TSSDeRef,TSSDeEPD)]" #Espionne "EPD TSSDeRef,TSSDistDeEPD: [set Tab(TSSDeRef,TSSDistDeEPD)]" #Espionne "EPD TSSDeRef,TSSDistEPD,TSSLoc: $VATSSDistDeEPD [set Tab(TSSDeRef,$VATSSDistDeEPD,TSSLoc)]" ###Determination de la localisation du TSS de reference set TSSDeRefLoc [set Tab(TSSDeRef,TSSDeRefFinal)] Espionne "TSSDeRefLoc: $TSSDeRefLoc" ### 5- Information sur la localisation du premier exon selon FirstEF Espionne "FirstEF" PromAnPanel ini $FileAllPromAn "FirstEF" PromAnPanel ini $FileSelectedPromAn "FirstEF" PromAnPanel ini $FileAllPromAn "FirstEFCpG" PromAnPanel ini $FileSelectedPromAn "FirstEFCpG" set LesFirstEFTypes {} foreach Ligne [LesFirstEFSelectedPourPromAn $FileContigTFA $DebutFirstExonPrediction] { set FirstEFType [lindex $Ligne 0] if {![info exists Tab(FirstEFType,$FirstEFType)]} { set Tab(FirstEFType,$FirstEFType) 1 lappend LesFirstEFTypes $FirstEFType } } foreach FirstEFType $LesFirstEFTypes { Espionne "FirstEFType: $FirstEFType" set Tab($FirstEFType,LesSensSelectedLignes) {} set Tab($FirstEFType,MinTSSDeRefDist) 1e200 foreach Ligne [LesFirstEFSelectedPourPromAn $FileContigTFA] { if {[lindex $Ligne 0] != $FirstEFType} {continue} PromAnPanel add $FileAllPromAn [join $Ligne "\t"] ###Selection selon le sens, elimination des "-" if {[lindex $Ligne 4] == "-"} { continue } lappend Tab($FirstEFType,LesSensSelectedLignes) $Ligne ###Calcul de la distance minimale du TSS predit par rapport a la TSSDeRefLoc deduite du protocole, DBTSS et EPD set Tab($FirstEFType,TSSDeRefDist) [expr abs([lindex $Ligne 5] - $TSSDeRefLoc)] if {[set Tab($FirstEFType,TSSDeRefDist)] < [set Tab($FirstEFType,MinTSSDeRefDist)]} {set Tab($FirstEFType,MinTSSDeRefDist) [set Tab($FirstEFType,TSSDeRefDist)]} } Espionne "MinTSSDeRefDist: [set Tab($FirstEFType,MinTSSDeRefDist)]" } foreach FirstEFType $LesFirstEFTypes { foreach SensSelectedLigne [set Tab($FirstEFType,LesSensSelectedLignes)] { set TSSDeRefDist [expr abs([lindex $Ligne 5] - $TSSDeRefLoc)] if {$TSSDeRefDist != [set Tab($FirstEFType,MinTSSDeRefDist)]} {continue} PromAnPanel add $FileSelectedPromAn [join $SensSelectedLigne "\t"] break } } ### 6- Information sur la localisation du TSS selon Eponine Espionne "Eponine" PromAnPanel ini $FileAllPromAn "Eponine" PromAnPanel ini $FileSelectedPromAn "Eponine" set LesSensSelectedLignes {} set MinTSSDeRefDist 1e200 set LEponineSelected {} foreach Ligne [LesEponineSelectedPourPromAn $FileContigTFA $DebutFirstExonPrediction] { PromAnPanel add $FileAllPromAn [join $Ligne "\t"] ###Selection selon le sens, elimination des "-" if {[lindex $Ligne 4] == "-"} { continue } lappend LesSensSelectedLignes $Ligne ###Calcul de la distance minimale du TSS predit par rapport a la TSSDeRefLoc deduite du protocole, DBTSS et EPD set TSSDeRefDist [expr abs([lindex $Ligne 5] - $TSSDeRefLoc)] if {$MinTSSDeRefDist <= $TSSDeRefDist} {continue} set LEponineSelected $Ligne } if {$LEponineSelected != {}} { PromAnPanel add $FileSelectedPromAn [join $LEponineSelected "\t"] } ### 7- Information sur la structure du gene selon GenScan Espionne "GenScan" PromAnPanel ini $FileAllPromAn "GenScan" PromAnPanel ini $FileSelectedPromAn "GenScan" foreach LaLigne [LesGenScanSelectedPourPromAn $FileContigTFA $DebutFirstExonPrediction] { PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] ###Selection selon le sens, elimination des "-" if {[lindex $LaLigne 4] != "-"} { PromAnPanel add $FileSelectedPromAn [join $LaLigne "\t"] } } ############################### Localisation de motifs stricts et de leur reverse ############################### ### 8- Information sur les pattern exactement localises Espionne "Pattern" set LesLignes {} foreach Pattern $LesPattern { PromAnPanel ini $FileAllPromAn $Pattern PromAnPanel ini $FileSelectedPromAn $Pattern foreach LaLigne [LesPatternSelectedPourPromAn $FileContigTFA $Pattern $DebutFirstExonPrediction] { PromAnPanel add $FileAllPromAn [join $LaLigne "\t"] ###Selection des motifs entre -$BorneDebutRechercheMotifs/+$BorneFinRechercheMotifs par rapport au TSS de ref determine par protocole Freddy sans tenit compte de DBTSS ni de EPD set LocDebutRechercheMotifs [expr $DebutFirstExonPrediction - $BorneDebutRechercheMotifs] set LocFinRechercheMotifs [expr $DebutFirstExonPrediction + $BorneFinRechercheMotifs] set Debut [lindex $LaLigne 2] set Fin [lindex $LaLigne 3] if {$Debut < $LocDebutRechercheMotifs || $Fin > $LocFinRechercheMotifs} {continue} PromAnPanel add $FileSelectedPromAn [join $LaLigne "\t"] } } ############################### TFBS (Transcription Factor Binding Site) search ############################### ### 9- Information sur les TFBS localises par le programme Match sur la DB Transfac professional Espionne "Match" set MinTSSDeRefDist 1e200 set LesProfile [list MinFN MinFNGood MinFP MinFPGood MinSum MinSumGood] ###Recherche de TFBS entre $DebutMatchSeq et $FinMatchSeq par rapport au TSS determine par protocole Freddy # Donc Masking de la sequence TFA ini au dela de$DebutMatchSeq et $FinMatchSeq -> seq d'entree de Match # # -1 car si DebutMatchSeq = 2500, on masque jusqu'a la base precedente # +1 car masque par ex a partir de 101 si $FinMatchSeq = 100 set DebutMatchSeq $BorneDebutRechercheMotifs set FinMatchSeq $BorneFinRechercheMotifs set FinRegionGaucheAMasquer [expr $DebutFirstExonPrediction - $DebutMatchSeq -1] set DebutRegionDroiteAMasquer [expr $DebutFirstExonPrediction + $FinMatchSeq +1] set TailleSeqTFA [TailleDeLaSequenceDuFichierTFA $FileContigTFA] set LesRegionsAMasquer [list [list 1 $FinRegionGaucheAMasquer] [list $DebutRegionDroiteAMasquer $TailleSeqTFA]] #Masking set FileTFAMatchMasked "$FileContigTFA.Match.masked" MasqueLesRegionsDuFichierTFA $FileContigTFA $FileTFAMatchMasked $LesRegionsAMasquer "N" foreach Profile $LesProfile { Espionne "Match -> $Profile" PromAnPanel ini $FileAllPromAn "Match_$Profile" PromAnPanel ini $FileSelectedPromAn "Match_$Profile" foreach Ligne [LesMatchTFBSSelectedPourPromAn $FileTFAMatchMasked $Profile $DebutFirstExonPrediction] { PromAnPanel add $FileAllPromAn [join $Ligne "\t"] PromAnPanel add $FileSelectedPromAn [join $Ligne "\t"] } } return } proc FilesPromAnPourTous {BorneDebutRechercheMotifs BorneFinRechercheMotifs {LesNoms ""}} { if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [ListeDesPABs]]} set RepContigTFA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_promoter" set RepEM "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_exonicmap" InterrogeFichierExonicMap unset InterrogeBestProteinAndmRNAForeachOrga unset set LesPattern [list "TATAAA" "ATTGG"] set Organism "Homo sapiens" set IdMin 0.3 set Expect 0.001 set NbSubject 20 set Filter F set nVar 0.05 foreach Nom $LesNoms { set FileContigTFA "$RepContigTFA/$Nom" set FileEM "$RepEM/$Nom" set FileAllPromAn "$RepContigTFA/$Nom.AllPromAn" set FilePromAn "$RepContigTFA/$Nom.PromAn" if {[file exists $FilePromAn]} {continue} if {![file exists $FileEM] || ![file exists $FileContigTFA]} {continue} set Access [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme $Organism "mRNA" Access] Espionne "$Nom -> PromAn $Access $Organism" set Entete [EnteteDuFichierTFA $FileContigTFA] set DebutFirstExon 10000 regexp {BeforeStart ([0-9]+)} $Entete tmp DebutFirstExon set DebutFirstExon [expr $DebutFirstExon + 1] set DQ [InterrogeFichierExonicMap $FileEM Rang 1 ExonArea 1 DQ] set FQ [InterrogeFichierExonicMap $FileEM Rang 1 ExonArea 1 FQ] set TailleExon [expr $FQ - $DQ + 1] set FinFirstExon [expr $DebutFirstExon + $TailleExon - 1] set Sens "+" FilesPromAn $FileContigTFA $DebutFirstExon $FinFirstExon $Sens $FileAllPromAn $FilePromAn $BorneDebutRechercheMotifs $BorneFinRechercheMotifs $LesPattern $Access $Organism $IdMin $Expect $NbSubject $Filter $nVar } InterrogeFichierExonicMap unset InterrogeBestProteinAndmRNAForeachOrga unset return } proc FilesTFADuDBTSSTFAs {FileTFAs} { ### Creation d'autant de fichier TFA qu'il y a de seq dans un fichier TFAs ### ### Utilisation: seqlab ne prend pas de fichier tfas... ### ###attention, ajouter en automatique le mkdir!!!### if {[regexp ".DBTSS.tfa" $FileTFAs]} { set Rep [regsub ".DBTSS.tfas" $FileTFAs "" ] #Espionne "Rep $Rep" } foreach TFA [split [ContenuDuFichier $FileTFAs] ">"] { if {$TFA == ""} {continue} set TFA ">$TFA" set Entete [EnteteDuTexteTFA $TFA] #Espionne $Entete set Id [lindex $Entete 0] regsub ">" $Id "" Id #Espionne $Id set FileOUT "$Rep/$Id.tfa" Espionne $FileOUT Sauve $TFA dans $FileOUT } return } proc FilesTFADuFileTFAs {FileTFAs} { foreach TFA [LesTFADuFileTFAs $FileTFAs] { set Entete [TFA2Header $TFA] regsub ">" $Entete "" Entete set FileTFA "$Entete.tfa" SaveInFile $TFA $FileTFA Espionne "$FileTFA\n$TFA" } return } proc FillTheBox {aT i j k an} { upvar $aT T foreach v [set ::SpS($an)] { lassign $v a b c set T([expr {$i+$a}],[expr {$j+$b}],[expr {$k+$c}]) 1 } return if {0} { foreach a {-1 0 1} { foreach b {-1 0 1} { foreach c {-1 0 1} { set T([expr {$i+$a}],[expr {$j+$b}],[expr {$k+$c}]) 5 } } } } else { foreach a {-1 0 1} { set T([expr {$i+$a}],$j,$k) 5 } foreach b {-1 0 1} { set T($i,[expr {$j+$b}],$k) 5 } foreach c {-1 0 1} { set T($i,$j,[expr {$k+$c}]) 5 } } return } proc FilsDe {n1 ag1} { global T LNOrdali DeuxTours set i [lsearch -exact $LNOrdali $n1] if {$i == ([llength $LNOrdali] - 1)} { set i -1 set DeuxTours 1 } set nf [lindex $LNOrdali $i+1] set Lf [lsearch -inline -all -exact -index 0 $T($n1,$ag1) $nf] set res [list] foreach f $Lf { lassign $f nf agf scf if {[llength $T($nf,$agf)] > 0} { lappend res $f } } return $res } proc FilsDeRR {P} { global T LNOrdali DeuxTours if { ! [info exists T]} { set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08] array set T [ContenuDuFichier "/home/moumou/Agents/filsde.dat"] } lassign [split $P ,] n1 ag1 set i [lsearch -exact $LNOrdali $n1] if {$i == ([llength $LNOrdali] - 1)} { set i -1 set DeuxTours 1 } set nf [lindex $LNOrdali $i+1] set Lf [lsearch -inline -all -exact -index 0 [lrange $T($n1,$ag1) 0 end] $nf] set res [list] foreach f $Lf { lassign $f nf agf scf if {[llength $T($nf,$agf)] > 0} { lappend res "$nf,$agf" } } return $res } proc FilsDeRROLD {P} { set FilsDe(A) { B C D E} set FilsDe(B) { C E} set FilsDe(C) {A E} set FilsDe(D) { C E} set FilsDe(E) {A D } if {[info exists FilsDe($P)]} { return $FilsDe($P) } return "" } proc FilterGrid {NomATraiter} { global PipeQuery global PipeCollection global DefautsPipe global lBestPdb global laddSeq if {$PipeCollection} { set fquery [file join [RepertoireDuGenome] prottfa $NomATraiter] set fblast [file join [RepertoireDuGenome] blastp $NomATraiter] set balfile [file join [RepertoireDuGenome] ballast "${NomATraiter}"] set balancf [file join [RepertoireDuGenome] ballast "${NomATraiter}.anchors"] set outfile [file join [RepertoireDuGenome] tfasdescopains $NomATraiter] set toAddFile [file join [RepertoireDuGenome] tfasdescopainsAdd $NomATraiter] } else { set fquery "$NomATraiter" set fblast "[file rootname $NomATraiter].blastp" set balfile "[file rootname $NomATraiter].ballast" set balancf "[file rootname $NomATraiter].ballast.anchors" set outfile "[file rootname $NomATraiter].copains" set toAddFile "[file rootname $NomATraiter].copainsAdd" } set lBestPdb "" if {[file exists $outfile]} { return 1 } global NbLg global NbFrg set NbLg 0 set NbFrg 0 set Bank [set DefautsPipe(Filter,bank)] set method [set DefautsPipe(Filter,method)] set MaxLength [set DefautsPipe(Filter,length)] set VerifFrag [set DefautsPipe(Filter,fragment)] set MaxListe [set DefautsPipe(Filter,maxseq)] set SeuilExpect [set DefautsPipe(Filter,expect)] set EnleveVarSplic [set DefautsPipe(Filter,varsplic)] set AddPdb [set DefautsPipe(Filter,addpdb)] # Traite BLAST set queryname $PipeQuery set Lqueryseq [lrange [LesLignesDuFichier $fquery] 1 end] set LBlast [LesLignesDuFichier $fblast] DecortiqueBlastGrid $LBlast 9999. 5000 Query lBanqueId lAccess lDE lProfil lPN "LongDescription" set N10m3 0 set LesElus {} set nBId {} set nAcc {} set nPN {} set nDE {} foreach acc $lAccess bid $lBanqueId des $lDE pn $lPN { if {$pn > $SeuilExpect} {break} incr N10m3 if {[EstTropLong $des $MaxLength]} {continue} if {$VerifFrag && [EstUnFragmentGrid $des]} {continue} if {$EnleveVarSplic && [EstUnVarSplic $bid]} {continue} if {[EstUnAccessPDB [EnlevePrefixeBank $bid]] || [EstUnAccessRefseq [EnlevePrefixeBank $bid]]} { set acc [EnlevePrefixeBank $bid] } if {$pn == 0.} {set pn "1e-200"} lappend nAcc $acc lappend nBId $bid lappend nPN $pn lappend nDE $des } puts "la meth de filtre est $method" switch $method { "none" {set LesElus [TriNature $SeuilExpect $MaxListe $nBId $nPN]} "mounir" {set LesElus [TriMounir $SeuilExpect $MaxListe $nBId $nPN]} "fdd" {set LesElus [TriFDD $SeuilExpect $MaxListe $nBId $nPN]} "alea" {set LesElus [TriAlea $SeuilExpect $MaxListe $nBId $nPN]} "strips" {set LesElus [TriStrips $SeuilExpect $MaxListe $nBId $nBId $nPN $nDE]} "euca" {set LesElus [TriEuca $SeuilExpect $MaxListe $nBId $nPN]} "meta" {set LesElus [TriMeta $SeuilExpect $MaxListe $nBId $nPN]} "vert" {set LesElus [TriVert $SeuilExpect $MaxListe $nBId $nPN]} "cami" {set LesElus [TriCami $SeuilExpect $MaxListe $nBId $nPN]} "splice" {set LesElus [TriSplice $SeuilExpect $MaxListe $nBId $nAcc $nPN $nDE]} default {set LesElus [TriNature $SeuilExpect $MaxListe $nBId $nPN]} } # ATTENTION ! LesElus contient des BankID !! set nElus [llength $LesElus] if {! $nElus} { Espionne "ERROR ! No sequences selected !" AjouteAuLogPipe "filter failed" return 0 } set ap $nAcc set bp $nBId if {[file exists $balfile]} { if {[set DefautsPipe(Filter,add)]} { set LesElus [RajoutBallastGrid $balfile $LesElus $SeuilExpect $MaxListe $MaxLength nBId nAcc] } } set LesElus [lunique $LesElus] if {[QuelProjet] eq "ms2phdb"} { set lBestPdb [TrouveBestPDB $NomATraiter] puts "lbestpdb est $lBestPdb" # ote les pdb template de la liste des elus # seront rajoute par la suite foreach pdb $lBestPdb { set ic [lsearch $LesElus "PDB:$pdb"] puts "ic vaut $ic" if {$ic != -1} { set LesElus [lreplace $LesElus $ic $ic] } } } if {$AddPdb ne ""} { if {[EstUnAccessPDB $AddPdb]} { set ic [lsearch $LesElus $AddPdb] if {$ic != -1} { set LesElus [lreplace $LesElus $ic $ic] } } } # Recupere les sequences bases sur leur bid # variable res contient tout l'output set o [open "[pid]_toto.lst" w] puts $o [join $LesElus "\n"] close $o set res {} catch {exec [FastacmdExe] -i [pid]_toto.lst -d $Bank} Msg if {[string first "\[fastacmd\]" $Msg] != -1} { Espionne "Error in Fastacmd ! Aborting \n$Msg" AjouteAuLogPipe "filter failed" return 0 } file delete -force [pid]_toto.lst # Recupere les noms pour l'instant set ls [split $Msg "\n"] foreach l $ls { if {[string index $l 0] ne ">"} {continue} set l [EnlevePrefixeFastacmd $l] if {[regexp -nocase {gi\|} [EnlevePrefixeBank $l]]} { set l [split $l "|"] set Ac "[lindex $l 2]|[lindex $l 3]|" set bid $Ac } else { set ib [PremierBlanc $l] if {$ib ne "end"} {incr ib -1} set bid [string range $l 1 $ib] set Ac [lindex $nAcc [lsearch $nBId $bid]] if {$Ac eq ""} {set Ac $bid} } set Var [regexp {^VARSPLIC} $bid] set Swp [regexp {^SW} $bid] set Spt [regexp {^SPT} $bid] if {$Var} { set tmp $Ac set Ac $bid set bid $tmp } set Ac [EnlevePrefixeBank $Ac] set bid [EnlevePrefixeBank $bid] if {[info exists SeqPris($Ac)]} { if {$Var} {set SeqPris($Ac) [linsert [set SeqPris($Ac)] end $bid]} if {$Swp} {set SeqPris($Ac) [linsert [set SeqPris($Ac)] 0 $bid]} if {$Spt} {set SeqPris($Ac) [linsert [set SeqPris($Ac)] 0 $bid]} } else { if {$Var} { set SeqPris($Ac) $Ac } else { set SeqPris($Ac) $bid } } } puts "SeqPris($Ac) est du coup [set SeqPris($Ac)]" # Tableau SeqPris est indexe par Accession foreach e [array names SeqPris] { set L [set SeqPris($e)] set i 0 foreach s $L { if {! $i} { set SeqPris($s) $e } else { set nom "${e}__$i" set SeqPris($s) $nom } incr i } } # set YaQuery [info exists SeqPris($queryname)] set lAcOut {} foreach l $ls { if {[string index $l 0] eq ">"} { set l [EnlevePrefixeFastacmd $l] if {[regexp -nocase {gi\|} [EnlevePrefixeBank $l]]} { set l [split $l "|"] set Ac "[lindex $l 2]|[lindex $l 3]|" set bid $Ac } else { set ib [PremierBlanc $l] if {$ib ne "end"} {incr ib -1} set bid [string range $l 1 $ib] } if {[EstUnVarSplic $bid]} { set Ac [EnlevePrefixeBank $bid] } else { set Ac [set SeqPris([EnlevePrefixeBank $bid])] } if { [regexp "UniRef90" $Ac] } { regsub "UniRef90_" $Ac "" Ac } lappend lAcOut $Ac set l ">${Ac}" } lappend res $l } if {[file exists $balancf]} { DecortiqueAncresBallast $balancf Qu Ob Ps B1 B2 Ln Wg set fout [open $balancf w] puts $fout "Ballast 0.000000" foreach q $Qu o $Ob p $Ps d $B1 f $B2 l $Ln w $Wg { set o [EnlevePrefixeBank $o] if { [regexp "UniRef90" $o] } { regsub "UniRef90_" $o "" o } if {[lsearch $lAcOut $o] == -1} { if {[info exists SeqPris($o)]} {set o [set SeqPris($o)]} } set fmt [format "seq: %15s %15s\tpos: %10d\tbeg: %10d %10d\tlen: %6d\tweight: %6.2f\n" $q $o $p $d $f $l $w] puts $fout $fmt } close $fout } if {$AddPdb ne ""} { if {[EstUnAccessPDB $AddPdb]} { set AddPdb [EnlevePrefixeBank $AddPdb] set idPdb [DonneIdDeAccessPDB $AddPdb] set seq [creePDBAvecX $idPdb $AddPdb] # si la recuperation de la sequence s est bien passee if {[llength $seq] > 10} { set seq [join $seq ""] lappend res ">[EnlevePrefixeBank $AddPdb]" lappend res $seq } } } #AF if {[QuelProjet] eq "ms2phdb"} { if {$lBestPdb != {}} { foreach pdb $lBestPdb { set idPdb [DonneIdDeAccessPDB $pdb] catch {set seq [creePDBAvecX $idPdb $pdb]} if {$seq ne "Error"} { set seq [join $seq ""] lappend res ">$pdb" lappend res $seq } else { puts "pb recuperation PDB $pdb" } } } } # possibilite de fournir un fichier contenant des sequences # a ajouter a l alignement - contient des sequences au format fasta # on va le definir quand le projet est intitule addSeq if {[QuelProjet] eq "addSeq"} { # ajoute ces sequences dans la liste qui va remplir le fichier copains # cree une liste qui va contenir l ensemble des sequences qui devront etre presentes dans l'alignement final set laddSeq "" if {[file exists $toAddFile]} { set lignes [LesLignesDuFichier $toAddFile] set toW 0 foreach lg $lignes { if {[regexp {^>} $lg]} { regsub {> +} $lg {>} lg if {[lsearch -exact $res "$lg"] == -1} { lappend res [lindex $lg 0] lappend laddSeq [string range [lindex $lg 0] 1 end] set toW 1 } else { set toW 0 } } elseif {$toW == 1} { lappend res $lg } } } } ## if {[lsearch -exact $res ">${queryname}"] == -1} { set letfa [concat ">$queryname" $Lqueryseq $res] } else { set letfa $res } if {$queryname eq ""} { set x [lsearch -exact $letfa ">$queryname"] set letfa [lreplace $letfa $x $x ">query"] set PipeQuery "query" } set letfa [join $letfa "\n"] set f [open $outfile w] puts $f $letfa close $f #si le fichier copains existe et qu il contient plus d une sequence if {[file exists $outfile] && [llength [lsearch -regexp -all $letfa "^>"]] > 1} { AjouteAuLogPipe "filter = ok" return 1 } else { # si on a 1 seul copain, le pipe doit s arreter! AjouteAuLogPipe "filter failed" return 0 } } proc FilterLeaf {t n} { $t isleaf $n } proc FilterTax2Draw {} { global db LTaxSelected LTaxIds Tx LUserId Lfeuilles LModelId LSelectableId puts "Filter :" puts "LModel [llength $LModelId]" puts "LSelected [llength $LTaxSelected]" puts "LUserId [llength $LUserId]\n" set LShowId $LSelectableId set LTaxIds [lsort -unique -integer [concat $LTaxSelected $LShowId]] puts "-> LTaxIds : [llength $LTaxIds]" return } proc FilterWithAny {FicWithAny ListOrFile TaxId IdentifiersFile {NewFile ""}} { JeMeSignale if {$NewFile == ""} { set NewFile $FicWithAny } set LesNvLignes {} foreach Ligne [LesLignesDuFichier $FicWithAny] { if {[regexp "^PIDInitial" $Ligne]} { lappend LesNvLignes $Ligne continue } set IdInteractant [lindex [split $Ligne "\t"] 2] if {[FromStringList $IdInteractant $IdentifiersFile]} { lappend LesNvLignes $Ligne continue } if {[FromUserList $IdInteractant $ListOrFile $TaxId]} { lappend LesNvLignes $Ligne } } return [SauveLesLignes $LesNvLignes dans $NewFile] } proc FiltrageListeGC {liste} { # verification de l existence d une entree HGMD pour chacun des genes # a savoir que le nom de gene peut differer d une banque a l autre # on fait donc une double verification # - existence du lien sur la fiche GeneCards # - sinon, on verifie qu une entree HGMD avec le nom de gene courant n existe pas # recuperation de l identifiant Uniprot associe a chaque gene GC # retourne la liste des access Uniprot OK pour integrer MS2PH-db global RepAJourGC set fileRecap [file join $RepAJourGC "recapGene"] set fileListe [file join $RepAJourGC "listeProtGC"] set url1 "http://www.genecards.org/cgi-bin/carddisp.pl?gene=XXXX" set newList "" set rf [open $fileRecap w] set lf [open $fileListe w] puts $rf "GeneCards\tUniprot\tHGMD" # pour chaque element de la liste foreach e $liste { set idUniprot "" set idHgmd "" # creation de l url qui va bien, fonction du gene courant regsub "XXXX" $url1 $e newurl set LeslignesGC "" # copie des lignes de l url set x [HttpCopy $newurl LesLignesGC] # si la copie s'est bien deroulee if {$x == 1} { set idxHgmd [lsearch -regexp $LesLignesGC "Human Gene Mutation Database"] if {$idxHgmd != -1} { # si on a un lien direct vers la HGMD # recuperation du nom de gene utilise dans HGMD set ligne [lindex $LesLignesGC $idxHgmd] set ligne [string range $ligne [string first "Human Gene Mutation Database" $ligne] end] set idxbeg [expr [string first "('aaa')\">" $ligne] + 11] set idxend [expr [string first "" $ligne] - 1] set idHgmd [string trim [string range $ligne $idxbeg $idxend]] } #recuperation de l'id uniprot set idxUniprot [lsearch -regexp $LesLignesGC "UniProt/Swiss-Prot: " $ligne] + 11] set idxend [expr [string first "" $ligne] - 1] set idHgmd [string trim [string range $ligne $idxbeg $idxend]] } else { set idxOmim [lsearch -regexp $LesLignesGC "OMIM:"] if {$idxOmim != -1} { set idHgmd "aa" } else { # si on a pas de lien vers HGMD dans la fiche GC # on verifie qu il n existe pas une fiche HGMD avec le nom de gene GC ### --> probleme de restriction d acces via lbgi.fr ... #set url "http://www.hgmd.cf.ac.uk/ac/gene.php?gene=$e" #set Leslignes {} # copie des lignes de l url #set x [HttpCopy $url LesLignes] # si la copie s'est bien deroulee #if {$x == 1 } {} # on verifie que la page ne presente pas un message d'erreur # if {[lsearch -regex $LesLignes "We are sorry."] == -1} {} #set idHgmd $e # {} #{} } } #recuperation de l'id uniprot set idxUniprot [lsearch -regexp $LesLignesGC "UniProt/Swiss-Prot: 1} {set seuil [expr {$seuil/100.}]} set thr [expr {int($seuil*$lga)}] set i 0 foreach p [set ListeDesPiliersDuGroupe($gtm)] { set l [string length [string map [list "." ""] $p]] if {$l >= $thr} { set ok 1 } else { set ok 0 } foreach g $LNDG { if {$ok} { lappend Npil($g) [lindex [set ListeDesPiliersDuGroupe($g)] $i] } else { lappend Npil($g) [set pgap($g)] } } incr i } unset -nocomplain ListeDesPiliersDuGroupe array set ListeDesPiliersDuGroupe [array get Npil] return } proc FiltreMaladies {nom liste} { set LaCentrale "[MagosDir]/Centrale" set ficMs2ph [file join $LaCentrale "listeMs2ph_new"] set ficHomol [file join $LaCentrale "listeHomol_new"] source $ficMs2ph source $ficHomol set FileOut "$nom.disease" set f [open $FileOut w] foreach e $liste { if {[info exists ExistsM($e)]} { puts $f "ms2ph\t$e" continue } if {[info exists ExistsH($e)]} { puts $f "homologues\t$e" } } close $f return 1 } proc FiltrerLesOrganismes {Rep} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|FiltrerLesOrganismes : Start" set FichierIn [open "$Rep/NpToCoord.csv" "r"] set FichierOut [open "$Rep/EpouvanBlast2.csv" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] set CompteurLus 0 while { [gets $FichierIn Ligne] >=0 } { if { [regexp {troglodytes|Drosophila_melanogaster|Caenorhabditis|Danio|Mus} $Ligne] } { puts $FichierOut $Ligne } } close $FichierIn close $FichierOut Espionne "$timestamp|FiltrerLesOrganismes : End" } proc FinAfficheAskAddSeq {what} { global TAddS if {$what eq "dismiss"} { set TAddS(ok) 0 update destroy .affas return "" } # check sequence file set file $TAddS(File) if {$file eq "" || ! [file exists $file]} { FaireLire "The file >$file< does not exists !" return } set format [FormatDuFichierSequence $file] if {$format ni {MSF TFA ALN}} { FaireLire "Beware ! You can only add sequence(s) as a TFA, MSF or CLUSTAL (ALN) file !" return } set TAddS(ok) 1 update destroy .affas return } proc FinAfficheDownloadPDB {{quoi ""} {w ""}} { global DwnPDB StrucAVoir ListePDB if {$quoi eq "dismiss"} { destroy $w return } foreach i [array names DwnPDB] { set n [set DwnPDB($i)] if {$n eq ""} {return} if {! [file exists $n]} { FaireLire "Error !\nThe file :\n${n}\ndoes not exist !" return } } set i 1 foreach s $StrucAVoir { set Nom [string trim [set DwnPDB($i)]] set ix [lsearch -regexp $ListePDB $s] set m [lindex $ListePDB $ix] set pdbid [DonneIdDeAccessPDB $m] set chn [DonneChainDeAccessPDB $m] if {[info commands $pdbid] ne ""} { $pdbid destroy } set cok [LoadNouveauPDB $pdbid $Nom] } return } proc FinCentreAtome {args} { set ::AtomePique "" $::pgl(BoutonCenter) configure -fg cyan bind $::pgl(wogl) {set ::BQx %x ; set ::BQy %y} return } proc FinCherche {} { global NomTextSeq Chrc if {$Chrc(prevMode) eq "seqlab"} { $NomTextSeq tag state off $NomTextSeq map on } $NomTextSeq tag delete Cherche $NomTextSeq configure -background white -foreground black unset -nocomplain Chrc update idletasks DetruitBoutonsOrdali return } proc FinChoixNbCluster {quoi} { if {$quoi eq "dismiss"} {set ::NbGr -1} DetruitBoutonsOrdali return } proc FinChoixPDBReference {quoi} { global Retour global chxmolref if {$chxmolref eq "" && $quoi eq "OK"} {return} if {$quoi eq "OK"} {set Retour $chxmolref} {set Retour -1} return } proc FinChoixPlusieursPDB {w {quoi ""}} { global Retour Defauts lesbts StrucAVoir NomEtSeqAssPDB set StrucAVoir {} if {$quoi eq "dismiss"} { set Retour 1 return } set LSel {} foreach l $lesbts { set v [$l cget -variable] global $v if {[set $v] ne ""} {lappend LSel [set $v]} } if {! [llength $LSel]} { set Retour 1 return } if {[set Defauts(Viewer)] eq "RasMol" && [llength $LSel] > 5} { FaireLire "Error !\nRasMol accepts a maximum of 5 molecules !" return } set StrucAVoir $LSel set Retour 1 return } proc FinColorieSSParams {quoi} { global PSS if {$PSS(MeanRef) eq "ref" && $PSS(PDBRef) eq ""} { return } set w $PSS(Top) destroy $w if {$quoi ne "ok"} { unset PSS } update return } proc FinDBProfile {} { global TPS if {! [info exists TPS]} { #puts "==> Pas de TPS <==" return } foreach v [array names TPS "*,fois"] { set i [join [lrange [split $v ,] 0 end-1] ,] set res [expr {1.0*[set TPS($i,time)]/[set TPS($v)]}] set sql [lsort -unique [set TPS($i,sql)]] lappend LR [list $i [set TPS($v)] $res $sql] } set LR [lsort -real -index 2 $LR] puts "\n== PROFILING DB ===" puts "===================" foreach e $LR { lassign $e s i t q puts "" puts [format "%s %d %10.1f %s" $s $i $t $q] } return } proc FinDemandeTitre {quoi w} { global TiDe if {$quoi eq "save"} { set titre [$TiDe(Wtitre) get 1.0 end] if {[string trim $titre] eq ""} {return} } else { set titre "" } set TiDe(titre) $titre set TiDe(desc) [$TiDe(Wdesc) get 1.0 end] set TiDe(ctitre) [$TiDe(Wctitre) get 1.0 end] set TiDe(cdesc) [$TiDe(Wcdesc) get 1.0 end] foreach v [array names TiDe] { if {[string index [set TiDe($v)] end] eq "\n"} {set TiDe($v) [string range [set TiDe($v)] 0 end-1]} } destroy $w return } proc FinDemarrage {{w ""}} { if {! [ModeI]} { return } if {$w eq ""} { catch {destroy $w.dmg} } else { destroy [winfo toplevel $w.dmg] } update idletasks return } proc FinDoc_WordML {{PortaitOrLandscape Landscape}} { set LeTexte {} if {$PortaitOrLandscape == "Landscape"} { lappend LeTexte "" lappend LeTexte "" lappend LeTexte "" } lappend LeTexte "" lappend LeTexte "" return [join $LeTexte "\n"] } proc FinJob {nom} { global PipTmpDir set lf [glob -nocomplain $nom*] foreach f $lf { exec gzip $f } set lf [glob -nocomplain $nom*.gz] catch {eval exec tar -cf $nom.tar $lf} Message catch {eval file delete -force $lf} Message return } proc FinNewObj {quoi} { global NwOj NwOjR if {$quoi eq "ok"} { # check if we have a new name set NwOj(Obj) [string trim $NwOj(Obj)] if {$NwOj(Obj) eq "objname" || $NwOj(Obj) eq ""} { FaireLire "Please give a name to the new object !" return } regsub -all -- {-|\.|:} $NwOj(Obj) "_" NwOj(Obj) set mol $NwOj(Mol) set pdb "::$mol" if {! $NwOj(Edit)} { if {[ObjectAlreadyExists $NwOj(Obj)]} { FaireLire "This object already exists !\nPlease give an other name !" return } # define the object $pdb newObj $NwOj(Obj) } $pdb assignSelection $NwOj(Obj) [array get NwOjR] $pdb render $NwOj(Obj) if {! $NwOj(Edit)} { AddFObj $mol } VueEditee 1 } update idletasks destroy $NwOj(Toplevel) unset NwOj unset -nocomplain NwOjR $::pgl(wogl) postredisplay return } proc FinPCI {} { DetruitBoutonsOrdali AfficheBoutonsOrdali return } proc FinPasTouche {Nom} { PasTouche $Nom "fin" } proc FinSauvePDBParams {quoi} { global SP if {$quoi eq "ok"} { if {$SP(ChnAll) eq "all"} { set chn "all" } else { set chn $SP(LaChn) } if {$SP(ResAll) eq "all"} { set d "all" ; set f "all" } else { if {! [string is integer -strict $SP(ResFrom)] || ! [string is integer -strict $SP(ResTo)]} { FaireLire "Warning !\nPlease supply a valid residue range !" return } set d $SP(ResFrom) set f $SP(ResTo) } set nom [DonneIdDeAccessPDB $SP(Mol)] $nom save $chn $d $f } trace remove variable SP(Mol) write DonneChainesDe destroy $SP(Top) unset SP return } proc FinSuper {} { global NomTextSeq PositionInitiale $NomTextSeq tag remove slct 1.0 end bind $NomTextSeq <1> bind $NomTextSeq <2> bind $NomTextSeq <3> bind $NomTextSeq $NomTextSeq tag bind Hel $NomTextSeq tag bind H31 $NomTextSeq tag bind She $NomTextSeq tag bind Tur return } proc FindAgentFriend {n1 a1 n2} { global TAg set scmax -99999999. set agmax "skip" set Lasc [list] foreach a2 $TAg($n2) { if {! $TAg($a2,$n2,active)} {continue} lassign [ScoreAgentsPair $n1 $a1 $n2 $a2] score seuil if {$score ne "skip"} { lappend Lasc $score $seuil $a2 } } if {[llength $Lasc] == 0} { return [list "skip" -999999 -999999] } set Lasc [lrange [lsort -decreasing -real -stride 3 -index 0 $Lasc] 0 19] return [list [lindex $Lasc 2] [lindex $Lasc 0] [lindex $Lasc 1]] set scref [lindex $Lasc 0] set Lscag [list $scref [lindex $Lasc 1]] foreach {sc ix} [lrange $Lasc 2 end] { if {($scref-$sc) > 0.2*$scref} { lappend Lscag $sc $ix } } # indexes starts at 0, so -1 set max [expr {[llength $Lscag]/2 - 1}] # rand() gives float entre (0,1) inclusifs set ix [expr {2 * round(rand() * $max)}] set ag [lindex $Lscag $ix+1] set sc [lindex $Lscag $ix] return [list $ag $sc] } proc FindDiscriDe {f} { global TabSF LNOrdali SDG LNDG ListeDesPiliersDuGroupe ListeScore ConsMeth TbScores # Inits Ordali LesDefauts TypeAli "XML" LesDefauts FichierXML $f # Load file DecortiqueUnXml2 $f InitSequences InitInfoSeqs AssignSeqToGroup DonneTabFeature TabSF global {*}[info globals "TD*"] CreeLesPiliers LesDefauts PCThrGap 0.1 unset -nocomplain ListeScore array unset TbScores "Score,*" update set Lmscore [list Kabat Norm] set Lmscore [list Kabat] set TbScores(Lcols) $Lmscore foreach mscore $Lmscore { set sco [ScoreDe$mscore [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] if {[llength $Lmscore] > 1} { set sco [ReScale $sco] } set TbScores(Score,$mscore) $sco } CreeListeScore set Lval $ListeScore puts [join [lrange $Lval 0 5] "\n"] puts "" set Lval [lsort -index 1 -real $Lval] puts [join [lrange $Lval 0 3] "\n"] puts "..." puts [join [lrange $Lval end-3 end] "\n"] puts "" set Lval $ListeScore # Fait conservation globales set Lres [list] set Lgr [Tclcluspack $Lval -dt coordinates -cm hierar -nbc secator -wc] set Lres [TraiteResultatClusteringTcl $Lgr ""] set Ltrouve [lindex $Lres 1] # efface les conserves puts "ConsMeth IdenGlob [llength $ConsMeth(IdenGlob)] | $ConsMeth(IdenGlob)" set ConsMeth(ConsGlob) [list] puts "" # recup cons-t80 pre-calcule set n [lindex $SDG(GroupeToutLeMonde) 0] set Liden [list] ; set Lcons [list] foreach ft [set TabSF($n,Cons-T80)] { DecortiqueUneFeature $ft d f c tmp note if {[regexp "IdenGlob" $note]} { lappend Liden [expr {$d - 1}] } if {[regexp "ConsGlob" $note]} { lappend Lcons [expr {$d - 1}] } } # 498 qspQ # 521 R foreach i $Liden { puts "$i [lindex $ListeDesPiliersDuGroupe(GroupeToutLeMonde) $i]" } set Liden [lsort -integer $Liden] set Lcons [lsort -integer $Lcons] puts "Iden :" puts "Liden $Liden" puts "Liden [llength $Liden] Ltrou [llength $Ltrouve]" puts "land [llength [land $Liden $Ltrouve]]" puts "" puts "Cons :" puts "Lcons [llength $Lcons] Ltrou [llength $Ltrouve]" puts "land [llength [land $Lcons $Ltrouve]]" #exit puts "" # pour chaque groupe on calcule conservation unset -nocomplain TbScores set TbScores(Lcols) Kabat foreach gr [lrange $LNDG 1 end] { set Lsco [ScoreDeKabat $ListeDesPiliersDuGroupe($gr)] set TbScores(Score,Kabat) $Lsco CreeListeScore $gr set Lval $ListeScore set Lgr [Tclcluspack $Lval -dt coordinates -cm hierar -nbc secator -wc] set Lres [TraiteResultatClusteringTcl $Lgr "" $gr] set Ltrouve [lindex $Lres 1] puts "\nGroupe $gr" puts "trouve $Ltrouve" puts "ConsMeth $ConsMeth($gr)" set i 0 foreach p $ListeDesPiliersDuGroupe($gr) s1 $Lsco s2 $TbScores(Score,Kabat) { puts [format "%4d %6.2f %6.2f %s" $i $s1 $s2 $p] incr i } unset -nocomplain ListeScore } # Definit discriminant # Pour chaque groupe # - prend conserve du groupe, son score Norm # - regarde si il est conserve dans autres groupe, et prend # son core Norm set Ldis [list] foreach g1 [lrange $LNDG 1 end] { puts "Group 1 $g1" set Lp1 [set ConsMeth($g1)] puts "Lp1 $Lp1" foreach p1 $Lp1 { if {$p1 in $Ldis} {continue} set pil1 [lindex $ListeDesPiliersDuGroupe($g1) $p1] puts [format "%4d %s" $p1 $pil1] lassign [DispersionDeColonne $pil1] v1 ang1 ec1 puts [format " V1 %6.3f %6.3f | ang1 %5.2f | ec1 %5.2f" {*}[V_nV $v1] $ang1 $ec1] set isOverlap 0 foreach g2 [lrange $LNDG 1 end] { if {$g1 eq $g2} {continue} set nseq [string length [lindex $ListeDesPiliersDuGroupe($g2) 0]] set ThrGap [DefineGapThreshold $nseq] puts " Group 2 $g2" # on prend colonne correspondante dans groupe 2 set pil2 [lindex $ListeDesPiliersDuGroupe($g2) $p1] if {[string length [string map {"." ""} $pil2]] < $ThrGap} { continue } puts [format " %4d %s" $p1 $pil2] lassign [DispersionDeColonne $pil2] v2 ang2 ec2 puts [format " V2 %6.3f %6.3f | ang2 %5.2f | ec2 %5.2f" {*}[V_nV $v2] $ang2 $ec2] set over [ColonneOverlap $v1 $v2 $ang1 $ang2 $ec1 $ec2] incr isOverlap $over if {$over} { puts "overlap" } else { puts "discri" } } if {! $isOverlap} { lappend Ldis $p1 lappend Tdis($g1) $p1 } } } # recupere discri du xml foreach gr [lrange $LNDG 1 end] { set n [lindex $SDG($gr) 0] foreach ft [set TabSF($n,Discri)] { DecortiqueUneFeature $ft d f c tmp note if {! [regexp -nocase {^indel} $note]} { for {set i $d} {$i <= $f} {incr i} { lappend TX($gr) $i lappend Ld $i } } } } puts "" set Ldis [lsort -unique -integer $Ldis] puts "Ldis [llength $Ldis] | $Ldis" set Ld [lsort -unique -integer $Ld] puts "Ld [llength $Ld] | $Ld" puts "land [llength [land $Ldis $Ld]]" foreach g [lrange $LNDG 1 end] { puts "" puts "Groupe $g" set Lg [list] if {[info exists Tdis($g)]} { set Lg $Tdis($g) puts "Tdis [lsort -unique -integer $Tdis($g)]" } set Lx [list] if {[info exists TX($g)]} { set Lx $TX($g) puts "TX [lsort -unique -integer $TX($g)]" } puts "land [llength [land $Lg $Lx]]" } exit return } proc FindNbEspece {t} { set Rank [$::db eval {select Rank from taxonomy where taxid=$t}] if {$Rank eq "Species"} { incr ::nSpecies return } set Lfils [$::db eval {select taxid from taxonomy where Parent=$t}] puts "Lfils [llength $Lfils]" foreach f $Lfils { FindNbEspece $f } return } proc FindNode {Value T} { #returns the first node with that value return [lindex [PathToNode $Value $T "value"] end] } proc FindOligosForSerena {} { foreach Ligne [LesLignesDuFichier [RepertoireDuGenome]/AllStopOligosForSerena.txt] { scan $Ligne "%s" P set IGBMC [StringApres ">" dans [ContenuDuFichier [RepertoireDuGenome]/blastnoligo20060518/$P]] Espionne "$IGBMC [Oli $P Description]" } exit } proc FindPatternDansADNetRAC {Pattern} { global ADN TDN RAC if { ! [info exists ADN]} { ChargeADNetTDNetRAC } set PatternPourRegexp $Pattern regsub -all {[oO]} $PatternPourRegexp "\[GC\]" PatternPourRegexp regsub -all {[iI]} $PatternPourRegexp "\[AT\]" PatternPourRegexp regsub -all {[nN]} $PatternPourRegexp "\[ATGCX\]" PatternPourRegexp set Courant 0 while {[regexp -nocase -indices $PatternPourRegexp [string range $ADN $Courant end] Indices]} { foreach {Debut Fin} $Indices { incr Debut $Courant incr Fin $Courant puts "F [string range $ADN [expr $Debut-6] [expr $Debut -1]] [string range $ADN [expr $Debut] [expr $Fin]] [string range $ADN [expr $Fin+1] [expr $Fin+6]] $Debut $Fin" } set Courant [incr Debut 1] } set lRAC [string length $RAC] set Courant 0 while {[regexp -nocase -indices $PatternPourRegexp [string range $RAC $Courant end] Indices]} { foreach {Debut Fin} $Indices { incr Debut $Courant incr Fin $Courant puts "R [string range $RAC [expr $Debut-6] [expr $Debut - 1]] [string range $RAC [expr $Debut] [expr $Fin]] [string range $RAC [expr $Fin+1] [expr $Fin+6]] [expr $lRAC - $Debut] [expr $lRAC - $Fin]" } set Courant [incr Debut 1] } } proc FindRedundancy {redundantSequencesL fileName minIdentity} { ## Liste des sequences redondantes ## niveau 0 : groupes de sequences redondantes ## niveau 1 : sequences redondantes entre elles upvar $redundantSequencesL redundantSequences set mainBlastTab [DecortiqueBlastCommeBlat $fileName] set hitCompteur 0 foreach hit $mainBlastTab { #puts "''''''$hit'''''''''''" #puts " ------------ analyse hit $hitCompteur ------------" incr hitCompteur # si le query hit sur lui meme on passe if {[lindex $hit 2]==[Alias [lindex $hit 0]]} { #puts "yop! on zappe le blast vers lui meme" continue } #on compare si %identity superieur à minIdentity set identity [lindex $hit 7] set identQuery 0 set identHit 0 set foo 0 regexp {(.*)/(.*?)} $identity foo identQuery identHit set identValue [expr 100.*$identQuery/$identHit] #puts "% identite : $identValue" if { $identValue>=$minIdentity } { # on va verifier si le hit respect le %identite # si oui, et qu'il est de taille inferieure à la query, c un redondant set queryLength [lindex $hit 1] set hitLength [lindex $hit 4] set leftHit [lindex $hit 11] set rightHit [lindex $hit 12] if {$leftHit==1 && $rightHit==$hitLength} { #puts "longueur query/hit : $leftHit : $rightHit==$hitLength" #AddARedundant redundantSequences hit # on a une redondance entre A et B # on cree le couple {A B} si il n'existe pas encore set A [lindex $hit 0] set B [NomDuAlias [lindex $hit 2]] if {![info exists redundantSequences($A,$B)]} { set redundantSequences($A,$B) 1 } } #if {$queryLength>=$hitLength} { # #creation du couple de redondance # AddARedundant redundantSequences hit #} } } } proc FindTcl {fic {dir .}} { set LesTrouves {} set LesF [lsort [glob -nocomplain -- [file join $dir $fic]]] foreach F $LesF { lappend LesTrouves $F } set Ld [lsort [glob -directory $dir -type d -nocomplain -- *]] foreach d $Ld { if {[file type $d]=="link"} { continue } set LesR [FindTcl $fic $d] foreach R $LesR { lappend LesTrouves $R } } return $LesTrouves } proc FindTclAll {fic {dir .}} { global ResFind set r [glob -directory $dir -nocomplain -- $fic] if {$r != ""} { lappend ResFind $r } set Ld [glob -directory $dir -type d -nocomplain -- *] foreach dir $Ld { set r [FindTcl $fic $dir] if {$r != ""} {lappend ResFind $r} } if {[info exists ResFind]} { return $ResFind } else { return "" } } proc FindVector {V} { global FindVector set V [string toupper $V] if {[info exists FindVector($V)]} { return $FindVector($V) } if {[info exists FindVector("EstCharge")]} { return "" } foreach File [LesVecteurs] { set Vec [file tail $File] regsub {\..*} $Vec "" Vec set VEC [string toupper $Vec] set FindVector($Vec) $File set FindVector($VEC) $File set FindVector(NAMEOF_$Vec) $Vec set FindVector(NAMEOF_$VEC) $Vec } set FindVector("EstCharge") 1 return [FindVector $V] } proc FinsFlo {} { foreach F [glob "sc*gene.tfa"] { set Seq [QueLaSequenceDuFichierTFA $F] set Fin [string range $Seq end-53 end] set RAC [NucToReverseAndComplementNuc $Fin] set Nom [string range $F 2 5] Espionne "$Nom $Fin $RAC" } exit } proc FirstEF {FichierTFA FichierOUT} { ### Execution du programme FirstEF sur la sequence d'un fichier TFA ### if {![file exists $FichierTFA]} {return} catch {exec /gcg/extensions/bin/firstef $FichierTFA $FichierOUT} Message return } proc FirstElementFromSerial {Texte} { set LesKV [ListFromSerial $Texte] set V [lindex $LesKV 0] return $V } proc FittingParRotation {Ev1 Ev2 Ev3 Av1 Av2 Av3 {Cen 0} {MAE 0}} { if {$Cen} { for {set i 1} {$i < 4} {incr i} { set Ev$i [CentreVecteur [set Ev$i]] set Av$i [CentreVecteur [set Av$i]] if {$MAE} { set Av$i [MiseALEchelle [set Ev$i] [set Av$i]] } } } set i 1 foreach x1 $Ev1 y1 $Ev2 z1 $Ev3 x2 $Av1 y2 $Av2 z2 $Av3 { set W($i) 1. set XX(1,$i,1) $x1 set XX(2,$i,1) $y1 set XX(3,$i,1) $z1 set XX(1,$i,2) $x2 set XX(2,$i,2) $y2 set XX(3,$i,2) $z2 incr i } set Ni [expr $i - 1] set resup [COMPARORTHO XX W Rot Trans] set rms [lindex $resup 0] set mxd [lindex $resup 1] puts "Evec <---> Vaa :: rms = $rms ; max dev = $mxd" set MRot [M_T Rot] set VTrans [V_T Trans] set NVa1 {} set NVa2 {} set NVa3 {} foreach x $Av1 y $Av2 z $Av3 { set v [list $x $y $z] set Ln [AppliqueRotation $v $MRot $VTrans] lassign $Ln nx ny nz lappend NVa1 $nx lappend NVa2 $ny lappend NVa3 $nz } puts "" puts "X = Coef.Corr eigenvec et NVa [CoefficientCorrelation $Ev1 $NVa1]" puts "Y = Coef.Corr eigenvec et NVa [CoefficientCorrelation $Ev2 $NVa2]" puts "Z = Coef.Corr eigenvec et NVa [CoefficientCorrelation $Ev3 $NVa3]" puts "" set laa [split "ARNDCQEGHILKMFPSTWYV" ""] foreach x $NVa1 y $NVa2 z $NVa3 a $laa { puts [format "%s | %7.4f" $a [S_nV [list $x $y $z]]] } puts "" puts "V1 $NVa1" puts "V2 $NVa2" puts "V3 $NVa3" puts "" return } proc FlagFeatureScore {e} { foreach f [array names ::ScoreMeth "*,Edit"] { set ::ScoreMeth($f) $e } return } proc FlatFileDrawBlast {w} { set FichierBlast [AskOptionsDeDrawBlast ask $w FichierBlast] if {![file exists $FichierBlast]} {return} if {![AskOptionsDeDrawBlast exists $w ListBox]} { AskOptionsDeDrawBlast set $w ListBox [DrawInfo Brut ""] } set ListBox [AskOptionsDeDrawBlast ask $w ListBox] if {![winfo exists $ListBox] } { AskOptionsDeDrawBlast set $w ListBox [DrawInfo Brut ""] } set ListBox [AskOptionsDeDrawBlast ask $w ListBox] $ListBox delete 0 end foreach Ligne [LesLignesDuFichier $FichierBlast] {$ListBox insert end $Ligne} return } proc Fleche {K DebX DebY FinX FinY args} { Wup "Je crains que Fleche demande un canvas avec X et Y de meme nature ... isotropes" Wup " => meme facteurs d'echelle sur X et Y." set Width 6. set Fill "grey" set OutLineWidth 1 set OutLine "black" set ArrowWidth 2 set ArrowDirection "end" set FlatSide "none" foreach {Option Valeur} $args { if {$Valeur==""} { set Valeur "\"\"" } switch -regexp -- $Option { "-width$" { set Width $Valeur } "-outlinewidth$" { set OutLineWidth $Valeur } "-outline$" { set OutLine $Valeur } "-fill$" { set Fill $Valeur } "-arrowwidth$" { set ArrowWidth $Valeur } "-arrowwidthstart$" { set ArrowWidthStart $Valeur } "-arrowwidthend$" { set ArrowWidthEnd $Valeur } "-arrowdirection$" { set ArrowDirection $Valeur } "-flatside$" { set FlatSide $Valeur } } } if { ! [info exists ArrowWidthStart]} { if {[regexp "both|start" $ArrowDirection]} { set ArrowWidthStart $ArrowWidth } else { set ArrowWidthStart 0 } } if { ! [info exists ArrowWidthEnd]} { if {[regexp "both|end" $ArrowDirection]} { set ArrowWidthEnd $ArrowWidth } else { set ArrowWidthEnd 0 } } set w [expr $Width/2.] set fStart [expr -$ArrowWidthStart*$w] set fEnd [expr $ArrowWidthEnd*$w] set Long [expr sqrt(($FinX-$DebX)*($FinX-$DebX) + ($FinY-$DebY)*($FinY-$DebY))] if {$Long==0} { return "" } if {[expr abs($fStart)] > $Long} { set fStart [expr $Long*$fStart/abs($fStart)] } if {[expr abs($fEnd)] > $Long} { set fEnd [expr $Long*$fEnd /abs($fEnd)] } if {[expr abs($fEnd)+abs($fStart)] > $Long} { set fEnd [expr $Long*$fEnd /(2*abs($fEnd)) ] set fStart [expr $Long*$fStart/(2*abs($fStart))] set w [expr abs($fEnd)] } set AxeX [expr ($FinX-$DebX)/$Long] set AxeY [expr ($FinY-$DebY)/$Long] set PerX [expr -$AxeY] set PerY [expr $AxeX] set MemoPerY $PerY set aX [expr $DebX+$w*$PerX] set aY [expr $DebY+$w*$PerY] set GardeS 0 Wup "Si on fait une fleche arriere et si ... " set sX [expr ($DebX+$FinX)/2] set sY [expr ($DebY+$FinY)/2] set mX [expr $DebX-$fStart*$AxeX] set mY [expr $DebY-$fStart*$AxeY] if {[expr ($DebX-$sX)*($DebX-$sX)+($DebY-$sY)*($DebY-$sY)] < [expr ($DebX-$mX)*($DebX-$mX)+($DebY-$mY)*($DebY-$mY)]} { set sX $mX set sY $mY set GardeS 1 } set f $fEnd set mX [expr $FinX-$f*$AxeX] set mY [expr $FinY-$f*$AxeY] if { ! $GardeS } { set sX [expr ($DebX+$FinX)/2] set sY [expr ($DebY+$FinY)/2] if {[expr ($FinX-$sX)*($FinX-$sX)+($FinY-$sY)*($FinY-$sY)] < [expr ($FinX-$mX)*($FinX-$mX)+($FinY-$mY)*($FinY-$mY)]} { set sX $mX set sY $mY set GardeS 1 } } if {[regexp "right$" $FlatSide]} { set PerY 0 } lappend Trace [expr $sX+$w*$PerX] lappend Trace [expr $sY+$w*$PerY] lappend Trace [expr $mX+$w*$PerX] lappend Trace [expr $mY+$w*$PerY] lappend Trace [expr $mX+$f*$PerX] lappend Trace [expr $mY+$f*$PerY] lappend Trace $FinX lappend Trace $FinY set PerY $MemoPerY if {[regexp "left$" $FlatSide]} { set PerY 0 } lappend Trace [expr $mX-$f*$PerX] lappend Trace [expr $mY-$f*$PerY] lappend Trace [expr $mX-$w*$PerX] lappend Trace [expr $mY-$w*$PerY] set f [expr $fStart] set w [expr -$w] set mX [expr $DebX-$f*$AxeX] set mY [expr $DebY-$f*$AxeY] if { ! $GardeS} { set sX [expr ($DebX+$FinX)/2] set sY [expr ($DebY+$FinY)/2] if {[expr ($DebX-$sX)*($DebX-$sX)+($DebY-$sY)*($DebY-$sY)] < [expr ($DebX-$mX)*($DebX-$mX)+($DebY-$mY)*($DebY-$mY)]} { set sX $mX set sY $mY } } set PerY $MemoPerY if {[regexp "^left" $FlatSide]} { set PerY 0 } lappend Trace [expr $sX+$w*$PerX] lappend Trace [expr $sY+$w*$PerY] lappend Trace [expr $mX+$w*$PerX] lappend Trace [expr $mY+$w*$PerY] lappend Trace [expr $mX+$f*$PerX] lappend Trace [expr $mY+$f*$PerY] lappend Trace $DebX lappend Trace $DebY set PerY $MemoPerY if {[regexp "^right" $FlatSide]} { set PerY 0 } lappend Trace [expr $mX-$f*$PerX] lappend Trace [expr $mY-$f*$PerY] lappend Trace [expr $mX-$w*$PerX] lappend Trace [expr $mY-$w*$PerY] lappend Trace [lindex $Trace 0] lappend Trace [lindex $Trace 1] return [eval $K create polygon $Trace -width $OutLineWidth -fill $Fill -outline $OutLine] } proc FlecheSurArc {R Id {Orientation F}} { Wup "Puts an arrow at the end of the arc Id (clock-wize if Forward ...)" set PI 3.14159 set DeltaAnglePourFlecheDeg 1.5 set DeltaAnglePourFlecheRad [expr $DeltaAnglePourFlecheDeg*$PI/180.] scan [$R coords $Id] "%f %f %f %f" G H D B set Rayon [expr ($D-$G)/2] set InRayon [expr $Rayon*(1-0.9*$DeltaAnglePourFlecheRad)] set OutRayon [expr $Rayon*(1+0.9*$DeltaAnglePourFlecheRad)] set Start [$R itemcget $Id -start] set Extent [$R itemcget $Id -extent] set Couleur [$R itemcget $Id -outline] Espionne "$Start $Extent" if {$Extent>0} { set NewExtent [expr $Extent-$DeltaAnglePourFlecheDeg] if {$Orientation=="F"} { set NewStart [expr $Start+$DeltaAnglePourFlecheDeg] set Pointe $Start set Queue $NewStart } else { set NewStart $Start set Queue [expr $Start+$NewExtent] set Pointe [expr $Start+$Extent] } } else { set NewExtent [expr $Extent+$DeltaAnglePourFlecheDeg] if {$Orientation=="F"} { set NewStart $Start set Queue [expr $Start+$NewExtent] set Pointe [expr $Start+$Extent] } else { set NewStart [expr $Start+$DeltaAnglePourFlecheDeg] set Pointe $Start set Queue $NewStart } } set Queue [expr $Queue*$PI/180] set Pointe [expr $Pointe*$PI/180] $R itemconfigure $Id -start $NewStart -extent $NewExtent set InQueueX [expr ($G+$D)/2 + $InRayon*cos($Queue)] set InQueueY [expr ($H+$B)/2 - $InRayon*sin($Queue)] set OutQueueX [expr ($G+$D)/2 + $OutRayon*cos($Queue)] set OutQueueY [expr ($H+$B)/2 - $OutRayon*sin($Queue)] set PointeX [expr ($G+$D)/2 + $Rayon*cos($Pointe)] set PointeY [expr ($H+$B)/2 - $Rayon*sin($Pointe)] $R create polygon $PointeX $PointeY $InQueueX $InQueueY $OutQueueX $OutQueueY $PointeX $PointeY -fill $Couleur -outline $Couleur -tags "Fleche" } proc Flo {} { set FichierHtml "[RepertoireDuGenome]/nucleardbpdblist.html" set FichierTxt "[RepertoireDuGenome]/nucleardbpdblist.txt" set Texte [ContenuDuFichier nucleardbpdblist.html] set Table [ValeurDeLaBalise Table Texte] set Li 0 set LesEnregistrements {} while 1 { set Ligne [ValeurDeLaBalise tr Table] incr Li if {$Ligne==""} { break } set Co 0 set LesMots {} while {1} { set Cellule [ValeurDeLaBalise td Ligne] incr Co if {$Cellule==""} { break } set Span [ValeurDeLaBalise span Cellule] regsub -all "\n" $Span " " Span regsub {} $Span "" Span if {[regexp -nocase {" $Sequence]]==0} { if {[set iDL [string first "\n" $Sequence 1]]>1} { if {[string first ">" $Sequence $iDL]>0} { return "tfas" } else {return "tfa"} } } if {[regexp "^ID " $Sequence]} { if {[regexp {[^p\.]\.\.[ \t]*\n} $Sequence]} { return "gcg" } return "embl" } if {[regexp {[^\.]\.\.[ \t]*\n} $Sequence]} { return "gcgmaybe" } if {[regexp -nocase {[^a-zA-Z0-9\.\n\t \*]} $Sequence]} { return "Inconnu" } if {[regexp -nocase {[^ATGCX0-9\.\n\t \*]} $Sequence]} { return "protbrut" } return "nucbrut" } proc FormatDeLaSequenceDuFichier {Fichier} { return [FormatDeLaSequence [ContenuDuFichier $Fichier]] } proc FormatDeLaSequence_l {Sequence} { return [FormatDeLaSequence [join $Sequence "\n"]] } proc FormatDesNumerosPourCollection {{OrfNumbering ""}} { global RepertoireDuGenome global FormatDesNumerosPourCollection if {$OrfNumbering!="" && [info exists FormatDesNumerosPourCollection]} { unset FormatDesNumerosPourCollection } if {[info exists FormatDesNumerosPourCollection]} { return $FormatDesNumerosPourCollection } set Fichier "$RepertoireDuGenome/fiches/format_orf_numbering" if {[file exists $Fichier]} { scan [ContenuDuFichier $Fichier] "%s" FormatDesNumerosPourCollection return $FormatDesNumerosPourCollection } set FormatDesNumerosPourCollection "" while {$FormatDesNumerosPourCollection==""} { if {$OrfNumbering==""} { FaireLire "Howmany digits do we use for ORF numbering ? \n(1 from 1 to 9, 2 from 01 to 99, 3 from 001 to 999, etc.)" set N [Entre 3] } else { set N $OrfNumbering } if {[regexp {^[1-9]+$} $N]} { break } if {$OrfNumbering!=""} { FaireLire "Illegal OrfNumbering $OrfNumbering. I'll ask you for a correct value." } set OrfNumbering "" } set FormatDesNumerosPourCollection "$N.${N}d" Sauve $FormatDesNumerosPourCollection dans $Fichier return $FormatDesNumerosPourCollection } proc FormatDesNumerosPourCollectionDuGenome {{Genome ""}} { if {$Genome==""} { set Genome [RepertoireDuGenome] } if { ! [regexp "/" $Genome]} { set Genome "[GscopeDatabaseDir $Genome]" } set Fichier "$Genome/fiches/format_orf_numbering" if {[FileExists $Fichier]} { scan [ContenuDuFichier $Fichier] "%s" F return $F } set FichierBornes "$Genome/fiches/bornesdespabs" scan [ContenuDuFichier $FichierBornes] "%s" PremierNom if { ! [regexp {[0-9]+$} $PremierNom Match]} { return "" } set N [string length $Match] return "$N.${N}d" } proc FormatDesNumerosPourCollectionDuProjet {{Projet ""}} { return [FormatDesNumerosPourCollectionDuGenome $Projet] } proc FormatDuFichierSequence {file} { if {[file exists $file]} { set l [ContenuDuFichier $file] } else { set l $file } set l [string trimleft $l "\n"] set Entete [string range $l 0 5] switch -regexp $Entete { {^\<\?xml } {set fmt XML} {^\} {set fmt TFA} {^SQLite} {set fmt ORD} {^CLUSTA} {set fmt ALN} default {set fmt "unknown"} } if {$fmt eq "unknown"} { set Lt [split [string range $l 0 2000] "\n"] set Ix [lsearch -regexp $Lt {MSF:.+Type:.+Check:.+\.\.}] if {$Ix != -1} {set fmt MSF} } return $fmt } proc FormatMode {mode} { array set modes { 0 --- 1 --x 2 -w- 3 -wx 4 r-- 5 r-x 6 rw- 7 rwx } set mode [format %o [expr $mode & 07777]] set owner $modes([string index $mode 0]) set group $modes([string index $mode 1]) set world $modes([string index $mode 2]) return "${owner}${group}${world}" } proc FormatSize {size} { set string "" while { $size > 0 } { set rem [expr $size % 1000] set size [expr $size / 1000] if { $size > 0 } { set rem [format "%03d" $rem] } if { $string != "" } { set string "$rem,$string" } else { set string "$rem" } } return $string } proc FormatageEntete {Entete {PourQui ""} {P ""}} { JeMeSignale set BelleEntete $Entete if {[regexp "sequencing oligo" $Entete]} { set LesSeqOli {} foreach E [split $Entete "+"] { scan $E "%s" SeqOli if {$LesSeqOli!={}} { regsub {SeqOli(Rac|)_} $SeqOli " " SeqOli } lappend LesSeqOli $SeqOli } if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" } append BelleEntete [join $LesSeqOli " "] return $BelleEntete } if {[regexp "mutation oligo" $Entete]} { set LesMutOli {} foreach E [split $Entete "+"] { scan $E "%s" MutOli if {$LesMutOli!={}} { regsub {MutOli(Rac|)_} $MutOli " " MutOli } lappend LesMutOli $MutOli } if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" } append BelleEntete [join $LesMutOli " "] return $BelleEntete } if {$PourQui==""} { set PourQui "PourCommande" } set TM "" if {[regexp { tm[53]p_[0-9]+} $Entete Match]} { set TM [string trim $Match] } set LesLis [DecomposeLaLigne $Entete] Espionne $LesLis set LesSujets [lindex $LesLis 0] set LesAvs [lindex $LesLis 1] set LesAps [lindex $LesLis 2] set Sujet [join $LesSujets " "] set SigAv [join $LesAvs "_"] set SigAp [join $LesAps "_"] if {[regexp "PourOligo" $PourQui]} { if {$SigAv!=""} { if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} { set SigAvNB [StringApres " replaces " dans $Entete] Espionne $SigAvNB if {$SigAvNB==""} { FaireLire "Ca merde avec le BrocOli $Entete" } else { set SigAv $SigAvNB } } set BelleEntete "$P 5' oligo with signal $SigAv for $Sujet" } if {$SigAp!=""} { if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} { set SigApNB [StringApres " replaces " dans $Entete] if {$SigApNB==""} { FaireLire "Ca merde avec le BrocOli $Entete" } else { set SigAp $SigApNB } } set BelleEntete "$P 3' oligo with signal $SigAp for $Sujet" } if {$SigAv=="" && $SigAp==""} { set BelleEntete "$P oligo without signal for $Sujet" } if {[regexp "BrocOli" $Entete]} { if {[regexp "PourOligoNonBrocOli" $PourQui]} { set CuttedSignal [StringApres "BrocOli with" dans $Entete] set FullSignal [StringApres " replaces " dans $Entete] set TexteBrocOli "RebuildedBrockenOli of $CuttedSignal" } else { set TexteBrocOli "BrocOli [StringSuivant "BrocOli " dans $Entete] seeFull AfterMe" } append BelleEntete " $TexteBrocOli" } } if {$PourQui=="PourCommande"} { set PremierSujet [lindex $LesSujets 0] set Racine "trululuturlu" if {[regexp {^[^\-]+\-} $PremierSujet Match]} { set Racine $Match } set LesAutresSujets {} foreach AutreSujet [lrange $LesSujets 1 end] { regsub $Racine $AutreSujet "" AutreSujet lappend LesAutresSujets $AutreSujet } set AutresSujets "[join $LesAutresSujets " "]" if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" } set TexteBrocOli "" if {[regexp "BrocOli" $Entete]} { set TexteBrocOli " BrocOli [StringSuivant "BrocOli " dans $Entete]" } if {$SigAv!=""} { append BelleEntete "${SigAv}_$PremierSujet $AutresSujets $TexteBrocOli $TM" } if {$SigAp!=""} { append BelleEntete "${PremierSujet}_$SigAp $AutresSujets $TexteBrocOli $TM" } if {$SigAv=="" && $SigAp==""} { append BelleEntete "$PremierSujet $AutresSujets $TexteBrocOli $TM" } } return $BelleEntete } proc FormateEC {EC} { regsub -all {[^0-9\.\-]} $EC "" EC return $EC } proc FormateLeFichierTFA {{FichierTFA ""} {FichierOut ""} {Modification 1}} { Wup "Permet d ajouter comme access query_protein et de retourner le vrai access dans le fichier TFA" if {! [file exists $FichierTFA] || $FichierTFA == ""} {return "-1"} #Creation du Fichier TFA utilise pour l alignement #On recupere l access (premier mot apres le chevron ">") #On ajoute query_protein a la place qui sera utilise par clustalw #Si modification est a 1 on ecrit dans le fichier set FileTmp "${FichierTFA}_tmp" if {[file exists $FileTmp]} { file delete -force $FileTmp } set LesLignes "" set F [open "$FichierTFA"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {[string first ">" $Ligne]=="0"} { set LigneSplitee [split $Ligne " "] set Access [lindex $LigneSplitee 0] regsub "^>" $Access "" Access set Access [string tolower $Access] if {$Modification && $Access!="query_protein"} { regsub -nocase "^>$Access" $Ligne ">query_protein $Access" Ligne } } lappend LesLignes $Ligne } close $F AppendAuFichier $FileTmp [join $LesLignes "\n"] regsub -all {\|} $Access "_" Access #On supprime le fichier original et on le remplace par le nouveau avec query_protein if {$FichierOut == ""} { file delete -force $FichierTFA file copy -force $FileTmp $FichierTFA } else { file copy -force $FileTmp $FichierOut } file delete -force $FileTmp return $Access } proc FormateLesCoordonnees {args} { foreach aC $args { upvar $aC C set LeF {} foreach N [split $C " "] { set FN [format "%.1f" $N] lappend LeF $FN } set C [join $LeF " "] } return } proc FormateSequence {Sequence {NouveauFormat ""} {AncienFormat ""}} { if {$AncienFormat==""} { set AncienFormat [FormatDeLaSequence $Sequence] } if {$NouveauFormat==""} { set LesNouveauxPossibles [list "to-TFA-without-numbers" "to-TFA" "to-EMBL" "to-GCG" "nuc-to-prot-TFA" "nuc-to-prot-EMBL" "nuc-to-prot-GCG" "TFA-to-reverse-TFA" "TFA-to-complement-TFA" "TFA-to-rev-and-comp-TFA" "nuc-to-reverse" "nuc-to-complement" "nuc-to-rev-and-comp" ] set N [llength $LesNouveauxPossibles] set I [ChoixParmiJoli [NombresEntre 1 $N] "" $LesNouveauxPossibles] if {$I==""} { return "" } set NouveauFormat [lsearch $LesNouveauxPossibles [expr $I-1]] } if { $AncienFormat == "tfas" && $NouveauFormat == "to-GCG" } { FaireLire "Multiple TFA to GCG is not yet possible" return "" } set II 0 if { $I==[incr II]} { return [TexteTfaFromTexteTfaWithoutNumbers $Sequence]} if { $I==[incr II]} { return [SequenceFormatTFA $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [SequenceFormatEMBL $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [SequenceFormatGCG $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [NucToProtTFA $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [NucToProtEMBL $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [NucToProtGCG $Sequence "" $AncienFormat]} if { $I==[incr II]} { return [TFAToReverseTFA $Sequence ""]} if { $I==[incr II]} { return [TFAToComplementTFA $Sequence ""]} if { $I==[incr II]} { return [TFAToReverseAndComplementTFA $Sequence ""]} if { $I==[incr II]} { return [NucToReverseNuc $Sequence]} if { $I==[incr II]} { return [NucToComplementNuc $Sequence]} if { $I==[incr II]} { return [NucToReverseAndComplementNuc $Sequence]} return "" } proc FormeBidon {} { set Lx [list [list [list 0.0 0.0 0.0] [list 2.0 0.0 0.0] [list 0.0 2.0 0.0] [list 0.0 0.0 2.0]]] set La [list [list 1 29 29 29]] set bb [list 0.0 2.0 0.0 2.0 0.0 2.0] set Lc [list 1.0 1.0 1.0] set Laai [list] foreach rx $Lx lna $La { foreach v $rx an $lna { lassign $v x y z lappend Laai [list $x $y $z $an 1] } } package require tsurf global Ltrig Lnorm Lvert lassign [tsurf -expand 2 -contract 2 -smooth -connolly $Laai] Lvec Lnrm foreach {a b c d e f g h i} $Lvec { set v1 [list $a $b $c] set v2 [list $d $e $f] set v3 [list $g $h $i] lappend Lvert $v1 $v2 $v3 set t [list $v1 $v2 $v3] lappend Ltrig $t } set Lnorm [list] foreach {x y z} $Lnrm { lappend Lnorm [list $x $y $z] } #lassign [SortTriangles $Ltrig $Lnorm] Ltrig Lnorm return #Atomes2Grille $bb $Lc $Lx $La #exit } proc FormulaireOliWeb {} { set LH {} lappend LH [H_Open [H_BalAtt [H_Pivot] FORM "ACTION [WscopeServer]?ProGS&TraiteOliWebOrder METHOD post"]] lappend LH "Select all 5' signals" lappend LH [H_BR] lappend LH [H_MorceauxChoisis [LesSignaux] "SigAv"] lappend LH [H_BR] lappend LH "Cut and Paste your nucleic sequence" lappend LH [H_BR] lappend LH [H_TexteArea "" "Sequence"] lappend LH [H_BR] lappend LH "If necessary give fragment limits" lappend LH [H_TexteArea "" "Fragment" 1 20] lappend LH " please use following conventions" lappend LH [H_Open [H_Balise [H_Pivot] PRE]] lappend LH "Counting AMINO ACIDS :" lappend LH " 25 58 (from Amino acid 25 to Amino Acid 58) ***USE ONLY NUMBERS***)" lappend LH "or G25 H58 (from Glycine 25 to Histidine 58 ***USE UPPERCASE LETTERS***)" lappend LH "Counting NUCLEIC BASES :" lappend LH " g62 n97 (from guanine 62 to base 97 ***USE LOWERCASE LETTERS***)" lappend LH [H_Close] lappend LH "Select all 3' signals" lappend LH [H_MorceauxChoisis [LesSignaux] "SigAp"] lappend LH [H_BalAtt "" INPUT "VALUE Reset TYPE reset"] lappend LH [H_BalAtt "" INPUT "VALUE Submit TYPE submit"] lappend LH [H_Close] return [join $LH "\n"] } proc FouR {Debut Fin} { if {$Debut <= $Fin} { return "F" } else { return "R" } } proc FouinePourLesAccess {LesAccess {RepParent ""}} { if {$RepParent==""} { set RepParent "." } set TousLesFichiersCrees {} foreach Access $LesAccess { set Rep "$RepParent/$Access" if { ! [file exists $Rep]} { file mkdir $Rep } set MesFichiersCrees [FouinePourUnAccess $Access $Rep] if {[regexp "^Show" $MesFichiersCrees]} { return $MesFichiersCrees } LConcat TousLesFichiersCrees $MesFichiersCrees } return $TousLesFichiersCrees } proc FouinePourLesAccessX {LesAccess {RepParent ""}} { if {$RepParent==""} { set RepParent "." } set TousLesFichiersCrees {} foreach Access $LesAccess { set Rep "$RepParent/$Access" if { ! [file exists $Rep]} { file mkdir $Rep } set MesFichiersCrees [FouinePourUnAccessX $Access $Rep] if {[regexp "^Show" $MesFichiersCrees]} { return $MesFichiersCrees } LConcat TousLesFichiersCrees $MesFichiersCrees } return $TousLesFichiersCrees } proc FouinePourUnAccess {{Access ""} {Rep ""}} { if {$Rep==""} { set Rep "." } if {$Access==""} { FaireLire "Please give an accession number of a protein" set Access [Entre "P10827"] } set Sequence "" catch { set TexteEmbl [join [LaSequenceDesBanques $Access] "\n"] set Sequence [QueLaSequenceDuTexteEMBL $TexteEmbl] } #GLOBPLOT #http://globplot.embl.de/cgiDict.py?key=process&SP_entry=PRIO_HUMAN #http://globplot.embl.de/cgiDict.py?key=process&sequence_string=SEQ #modifie pour avoir la sequence au lieu du SP?? set Site "http://globplot.embl.de/cgiDict.py" set Url $Site append Url "?key=" append Url "process" append Url "&SP_entry=" append Url $Access append Url "&sequence_string=" append Url "" append Url "¶ms=" append Url "RL" append Url "&peak_frame_dis=" append Url 5 append Url "&join_frame_dis=" append Url 4 append Url "&do_smart=" append Url "true" append Url "&peak_frame_dom=" append Url 74 append Url "&join_frame_dom=" append Url 15 append Url "&plot_title=" append Url "titreduplot" #Perform SMART/Pfam domain prediction #les parametres ne sont pas les meme que les parametres par defaut du site web #ici les valeurs sont 5 et 5 , sur le site 10 et 10 append Url "&smooth_frame_1=" append Url 10 append Url "&smooth_frame_2=" append Url 10 set LesLignes {} Espionne "Je surfe sur $Url" if {[catch {HttpCopy $Url LesLignes} Message]} { return "Show $Message" } if {$LesLignes!={}} { set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_GlobPlotResultat.html"] lappend LesFichiersCrees $Fic } #DisEMBL set Site "http://dis.embl.de/cgiDict.py" set LesCVs {} lappend LesCVs "key=process" lappend LesCVs "SP_entry=$Access" lappend LesCVs "sequence_string=" lappend LesCVs "smooth_frame=8" lappend LesCVs "peak_frame=8" lappend LesCVs "join_frame=4" lappend LesCVs "fold_coils=1.20" lappend LesCVs "fold_rem465=1.20" lappend LesCVs "fold_hotloops=1.40" lappend LesCVs "plot_title=" lappend LesCVs "doApplet=true" lappend LesCVs "tango_PH=7.40" lappend LesCVs "tango_T=278.15" lappend LesCVs "tango_I=0.05" lappend LesCVs "tango_TFE=0.00" lappend LesCVs "fold_tango=1.00" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} Espionne "Je surfe sur $Url" catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_DisEmblResultat.html"] lappend LesFichiersCrees $Fic } #Disopred if {0} { set Site "http://bioinf.cs.ucl.ac.uk:8000/servlet/DisoPack.jonservlet" set LesCVs {} lappend LesCVs "Sequence=$Sequence" lappend LesCVs "falseRate=2" lappend LesCVs "SecStructPred=on" lappend LesCVs "Output=opnone" lappend LesCVs "Email=brelivet@igbmc.u-strasbg.fr" lappend LesCVs "ShortName=toto" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} Espionne "Je surfe sur $Url" # catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_DisopredResultat.html"] lappend LesFichiersCrees $Fic } } #FoldIndex if {$Sequence!=""} { set Site "http://bip.weizmann.ac.il/fldbin/findex" set LesCVs {} lappend LesCVs "fn=zzz" lappend LesCVs "w=51" lappend LesCVs "t=1" lappend LesCVs "sq=$Sequence" lappend LesCVs "ys=1.0" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} #Espionne "Je surfe sur $Url" catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_FoldindexResultat.html"] lappend LesFichiersCrees $Fic } } #Ronn if {$Sequence!=""} { set Site "http://www.strubi.ox.ac.uk/RONN" set Query [::http::formatQuery sequence $Sequence display_probs n] set LesLignes {} #Espionne "Je surfe sur $Site\npar post de\n$Query" catch {HttpCopy $Site LesLignes $Query} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_RonnResultat.html"] lappend LesFichiersCrees $Fic } } #Norsp if {0} { set Site "http://cubic.bioc.columbia.edu/cgi-bin/var/database/norsp/submit" set LesCVs {} lappend LesCVs "usr-email=brelivet@igbmc.u-strasbg.fr" lappend LesCVs "sequence=$Sequence" lappend LesCVs "opt-nors-verbose=1" lappend LesCVs "opt-ret-html=0" lappend LesCVs "opt-ret-store=1" lappend LesCVs "opt-esp-nors-ws=70" lappend LesCVs "opt-exp-nors-seccut=12" lappend LesCVs "opt-exp-nors-acclen=0" set CVs [join $LesCVs "&"] set Url $Site set Query $CVs #Espionne "Je surfe sur $Url" # catch {HttpCopy $Url LesLignes $Query} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_NorspResultat.html"] lappend LesFichiersCrees $Fic } } return $LesFichiersCrees } proc FouinePourUnAccessX {{Access ""} {Rep ""}} { if {$Rep==""} { set Rep "." } if {$Access==""} { FaireLire "Please give an accession number of a protein" set Access [Entre "P10827"] } set Sequence "" catch { set TexteEmbl [join [LaSequenceDesBanques $Access] "\n"] set Sequence [QueLaSequenceDuTexteEMBL $TexteEmbl] } if {$Sequence==""} { set list [split $Rep "/"] set Fichier [RepertoireDuGenome]/tfasdescopains/[lindex $list [llength $list]-2] #Espionne "Fichier: $Fichier" set TFA [LaSequenceDuTFAs $Fichier $Access] set Sequence [QueLaSequenceDuTexteTFA $TFA] #Espionne "Sequence: $Sequence" # set ::attente 0 # after 3000 {set ::attente 1} # vwait ::attente } #GLOBPLOT #http://globplot.embl.de/cgiDict.py?key=process&SP_entry=PRIO_HUMAN #http://globplot.embl.de/cgiDict.py?key=process&sequence_string=SEQ #modifie pour avoir la sequence au lieu du SP?? set Site "http://globplot.embl.de/cgiDict.py" set Url $Site append Url "?key=" append Url "process" append Url "&SP_entry=" append Url $Access append Url "&sequence_string=" #modif avant append Url "" append Url $Sequence append Url "¶ms=" append Url "RL" append Url "&peak_frame_dis=" append Url 5 append Url "&join_frame_dis=" append Url 4 append Url "&do_smart=" append Url "true" append Url "&peak_frame_dom=" append Url 74 append Url "&join_frame_dom=" append Url 15 append Url "&plot_title=" append Url "titreduplot" #Perform SMART/Pfam domain prediction #les parametres ne sont pas les meme que les parametres par defaut du site web #ici les valeurs sont 5 et 5 , sur le site 10 et 10 append Url "&smooth_frame_1=" append Url 10 append Url "&smooth_frame_2=" append Url 10 set LesLignes {} #Espionne "Je surfe sur $Url" if {[catch {HttpCopy $Url LesLignes} Message]} { return "Show $Message" } if {$LesLignes!={}} { set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_GlobPlotResultat.html"] lappend LesFichiersCrees $Fic #Espionne "SauveLesLignes globplot" } #DisEMBL set Site "http://dis.embl.de/cgiDict.py" set LesCVs {} lappend LesCVs "key=process" lappend LesCVs "SP_entry=$Access" lappend LesCVs "sequence_string=$Sequence" lappend LesCVs "smooth_frame=8" lappend LesCVs "peak_frame=8" lappend LesCVs "join_frame=4" lappend LesCVs "fold_coils=1.20" lappend LesCVs "fold_rem465=1.20" lappend LesCVs "fold_hotloops=1.40" lappend LesCVs "plot_title=" lappend LesCVs "doApplet=true" lappend LesCVs "tango_PH=7.40" lappend LesCVs "tango_T=278.15" lappend LesCVs "tango_I=0.05" lappend LesCVs "tango_TFE=0.00" lappend LesCVs "fold_tango=1.00" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} #Espionne "Je surfe sur $Url" catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_DisEmblResultat.html"] lappend LesFichiersCrees $Fic } #Disopred if {0} { set Site "http://bioinf.cs.ucl.ac.uk:8000/servlet/DisoPack.jonservlet" set LesCVs {} lappend LesCVs "Sequence=$Sequence" lappend LesCVs "falseRate=2" lappend LesCVs "SecStructPred=on" lappend LesCVs "Output=opnone" lappend LesCVs "Email=brelivet@igbmc.u-strasbg.fr" lappend LesCVs "ShortName=toto" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} #Espionne "Je surfe sur $Url" # catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_DisopredResultat.html"] lappend LesFichiersCrees $Fic } } #FoldIndex if {$Sequence!=""} { set Site "http://bip.weizmann.ac.il/fldbin/findex" set LesCVs {} lappend LesCVs "fn=zzz" lappend LesCVs "w=51" lappend LesCVs "t=1" lappend LesCVs "sq=$Sequence" lappend LesCVs "ys=1.0" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} #Espionne "Je surfe sur $Url" catch {HttpCopy $Url LesLignes} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_FoldindexResultat.html"] lappend LesFichiersCrees $Fic } } #Ronn if {$Sequence!=""} { set Site "http://www.strubi.ox.ac.uk/RONN" set Query [::http::formatQuery sequence $Sequence display_probs n] set LesLignes {} #Espionne "Je surfe sur $Site\npar post de\n$Query" catch {HttpCopy $Site LesLignes $Query} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_RonnResultat.html"] lappend LesFichiersCrees $Fic } } #Norsp if {0} { set Site "http://cubic.bioc.columbia.edu/cgi-bin/var/database/norsp/submit" set LesCVs {} lappend LesCVs "usr-email=brelivet@igbmc.u-strasbg.fr" lappend LesCVs "sequence=$Sequence" lappend LesCVs "opt-nors-verbose=1" lappend LesCVs "opt-ret-html=0" lappend LesCVs "opt-ret-store=1" lappend LesCVs "opt-esp-nors-ws=70" lappend LesCVs "opt-exp-nors-seccut=12" lappend LesCVs "opt-exp-nors-acclen=0" set CVs [join $LesCVs "&"] set Url $Site set Query $CVs #Espionne "Je surfe sur $Url" # catch {HttpCopy $Url LesLignes $Query} if {$LesLignes!={}} { #EspionneL $LesLignes set Fic [SauveLesLignes $LesLignes dans "$Rep/${Access}_NorspResultat.html"] lappend LesFichiersCrees $Fic } } return $LesFichiersCrees } proc FouinePourUnMsf {FichierMsf {RepParent ""}} { if {$RepParent==""} { set RepParent "." } set NombreDeSequences [DecortiqueUnMSF $FichierMsf LesSequencesDansLOrdre] set TousLesFichiers [FouinePourLesAccess $LesSequencesDansLOrdre $RepParent] } proc FouinePourUnMsfX {FichierMsf {RepParent ""}} { if {$RepParent==""} { set RepParent "." } set NombreDeSequences [DecortiqueUnMSF $FichierMsf LesSequencesDansLOrdre] #est-ce que le set sert à quelque chose. set TousLesFichiers [FouinePourLesAccessX $LesSequencesDansLOrdre $RepParent] } proc FourBasesOverlap {} { foreach f [glob "/genomics/*/fiches/overlap"] { set Genome [file tail [file dirname [file dirname $f]]] set L [llength [LesLignesDuFichier $f]] if {$L==0} { continue } set N [regexp -all " 4 bases. I begin" [ContenuDuFichier $f]] set P [expr (100*$N)/$L] lappend Sortie [format "%2d%s %s" $P "%" $Genome] } return $Sortie } proc Fourmis {{X ""} {Y ""} {S ""} {H ""} {L ""} {W ""}} { LesDefauts source /home/ripp/gscope/gscope_fourmis.tcl global TFB if {$X!=""} { set TFB(dimX) $X } if {$Y!=""} { set TFB(dimY) $Y } if {$S!=""} { set TFB(step) $S } if {$H!=""} { set TFB(headFourmi) $H } if {$L!=""} { set TFB(lenFourmi) $L } if {$W!=""} { set TFB(widFourmi) $W } return [DrawFourmis] } proc Fournisseur {P {Val ""}} { global Fournisseur if {$Val!=""} { if { ! [info exists Fournisseur($P)]} { set Fournisseur($P) $Val lappend Fournisseur(LaListeDesPs) $P } else { append Fournisseur($P) $Val } return [set Fournisseur(LaListeDesPs)] } if {[info exists Fournisseur($P)]} { return [set Fournisseur($P)] } if {[info exists Fournisseur("EstCharge")]} { return "" } set Fournisseur("EstCharge") 1 array set Fournisseur [LesLignesDuFichier "[RepertoireDuGenome]/fiches/fournisseur"] foreach PLu [array names Fournisseur] { scan [set Fournisseur($PLu)] "%s" Fournis lappend Fournisseur($Fournis) $PLu lappend Fournisseur(LaListeDesPs) $PLu } return [Fournisseur $P] } proc FragFrom {Nom {Start ""} {StopVoulu ""}} { if {$Start==""} { set Start [Entre 1] } if {$StopVoulu==""} { set StopVoulu 999999 } scan $Start "%d %d" Start StopVoulu set Seq "n[QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]" set Frag [string range $Seq $Start end] set Stop [expr $Start+2] set YaStop 0 set NewNuc "" foreach {A B C} [split "${Frag}zzz" ""] { if {$C=="z"} { break } set Codon "$A$B$C" append NewNuc $Codon if {[CodonStopPossible $Codon]} { if {$Stop<$StopVoulu && [OuiOuNon "I found a Stop at $Stop < your stop $StopVoulu\nDo I ignore it ?"]} { } else { set YaStop 1 break } } if {$StopVoulu<=$Stop} { break } incr Stop 3 } set Entete "$Nom-$Start-$Stop" if { ! $YaStop} { append Entete " stop not in the original sequence" } set NewPro [SeqNucToSeqPro $NewNuc] set ProTFA [SequenceFormatTFA $NewPro $Entete "protbrut"] set NucTFA [SequenceFormatTFA $NewNuc $Entete "nucbrut"] regsub -all " " $Entete "_" E set FN [AfficheVariable $NucTFA "AvecFormate" "Nucleic_Fragment_of_$E"] set FP [AfficheVariable $ProTFA "AvecFormate" "Proteic_Fragment_of_$E"] return $FN } proc FragmentDuFichierTFA {FichierTFA {Debut ""} {Fin ""} {Comment ""} {FichierSortie ""}} { set Entete [EnteteDuFichierTFA $FichierTFA] set Seq [QueLaSequenceDuFichierTFA $FichierTFA] set Long [string length $Seq] while {$Debut==""} { set DF [Entre "1 $Long"] set Fin "" scan $DF "%d %d" Debut Fin if {$Fin==""} { set Debut "" } } set D $Debut set F $Fin incr D -1 incr F -1 set Frag [string range $Seq $D $F] regsub { |$} $Entete "-$Debut-$Fin " NouvelleEntete set TFA [SequenceFormatTFA $Frag "$NouvelleEntete" brut] if {[string equal -nocase $Comment "sequence"]} { return $Frag } if {[string equal -nocase $Comment "tfa"]} { return $TFA } if {[string equal -nocase $Comment "file"]} { if {$FichierSortie==""} { set FichierSortie [FichierPourSaveAs]} return [Sauve $TFA dans $FichierSortie] } return $TFA } proc FrappeQuUnCoup {Nom Qui {Liste ""}} { global FrappeQuUnCoup if {[info exists FrappeQuUnCoup($Qui,Indice)]} { set Indice [set FrappeQuUnCoup($Qui,Indice)] if {$Indice<0} { return 0 } set Liste [set FrappeQuUnCoup($Qui,Liste)] set IndiceDeNom [lsearch -exact $Liste $Nom] return [expr $IndiceDeNom < $Indice] } if {$Qui=="set"} { set Moi [NomDe "Frappeur"] if {$Nom=="AskWhereToBegin"} { if {[OuiOuNon "Do you want to begin with a given [PreFixe] ?"]} { if {$Liste==""} { set Liste [ListeDesPABs] } set Nom [ChoixParmi $Liste] } } if {$Nom==""} { set Indice -1 } else { if {$Liste==""} { set Liste [ListeDesPABs] } set FrappeQuUnCoup($Moi,Liste) $Liste set Indice [lsearch -exact $Liste $Nom] } set FrappeQuUnCoup($Moi,Indice) $Indice return $Moi } return 0 } proc Frechin {} { foreach Ligne [LesLignesVitales AllGat.txt] { if {[regexp ".txt" $Ligne]} { set Ftxt $Ligne continue } scan $Ligne "%s" Access set Seq [QueLaSequenceDuFichierTFA $Ftxt] set TFA [SequenceFormatTFA $Seq $Ligne "nucbrut"] Espionne $TFA Sauve $TFA dasn "$Access.tfa" lappend LesNouveaux "$Access /genomics/link/ProGS/atelier/Frechin/$Access.tfa" } return $LesNouveaux } proc FreewrapGscope {{GscopeExeDestin ""} {RepDestin ""} {RepRepDestin ""}} { if { ! [OuiOuNon "Ok to create gscope.exe with freewrap ?"]} { return ""} while {$GscopeExeDestin==""} { set GscopeExeDestin [FichierPourSaveAs "[GscopeDir]/gscope.exe"] if {$GscopeExeDestin!=""} { break } if {[OuiOuNon "Do I cancel freewrap of gscope ?"]} { return ""} } set LesSourcesDeGscope [LesSourcesDeGscope "Relatif" "AvecMain"] set RepSource [GscopeDir] while {$RepDestin=="" || [regexp " " $RepDestin] } { set RepDestin [TmpFile GscopeToWrap $RepRepDestin] if {[regexp " " $RepDestin]} { FaireLire "It seems that the name of the temporary directory\n$RepDestin\n contains unwanted characters (' '). Please browse for a directory where I can create this directory." set RepRepDestin [ChoixDuRepertoire] } } set LesBonsSourcesDeGscope {} foreach Source $LesSourcesDeGscope { set FicSource "$RepSource/$Source" if { ! [file exists $FicSource]} { FaireLire "I can't find $Fichier. \nI'll skipp" } regsub $RepSource $FicSource $RepDestin FicDestin set Rep [file dirname $FicDestin] while {[CreeLeRepertoire $Rep]==""} { if {[OuiOuNon "I can't create $Rep. Do I stop ?"]} { return "" } } file copy $FicSource $FicDestin lappend LesBonsSourcesDeGscope $Source } set GscopeExe "$RepDestin/gscope.exe" NousAllonsAuBoulot $RepDestin SauveLesLignes $LesBonsSourcesDeGscope dans "LesSourcesPourFreewrap.txt" exec c:/bin/freewrap/freewrapBLT.exe -f LesSourcesPourFreewrap.txt OnRevientDuBoulot if { ! [file exists $GscopeExe]} { FaireLire "$GscopeExe\nwas not created. I'll cancel" return "" } while {[catch {file copy -force $GscopeExe $GscopeExeDestin} Message]} { if { ! [OuiOuNon "I couldn't copy \n $GscopeExe \n to \n $GscopeExeDestin\n Do I try again ?" 0]} { return "Error $GscopeExe not copied to $GscopeExeDestin" } } return $GscopeExeDestin } proc Friedlander {FichierFriedlander NotreFichierTot FichierSeqSelect FichierOUT} { foreach Nom [lsort -unique [LesNoms NomsInteressants]] {set Tab(Nom,$Nom) 1} set F [open $FichierSeqSelect] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Nom [string toupper [string trim [lindex $LaLigne 0]]] if {![info exists Tab(Nom,$Nom)]} {continue} set Affy [string toupper [string trim [lindex $LaLigne 4]]] set Tab(AffySelected,$Affy) $Nom } set F [open $NotreFichierTot] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Affy [string toupper [lindex $LaLigne 4]] set Acc [string toupper [lindex $LaLigne 3]] set Tab(NosDonnees,$Affy) $Ligne set Tab(NosDonnees,$Acc) $Ligne } close $F set i 0 set LesLignes {} set F [open $FichierFriedlander] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set AiJeRencontrePouA 0 set AiJeRencontreAffy 0 set PosDePouA -1 set PouA "" set Affy "" foreach Element $LaLigne { if {!$AiJeRencontrePouA} {incr PosDePouA} if {!$AiJeRencontrePouA && $Element == "\"\"\"P\"\"\""} { set PouA "P" set AiJeRencontrePouA 1 } if {!$AiJeRencontrePouA && $Element == "\"\"\"A\"\"\"" } { set PouA "A" set AiJeRencontrePouA 1 } if {!$AiJeRencontreAffy && [regexp -nocase {_at$|_st$} $Element]} { set AiJeRencontreAffy 1 set Access $ElementDAvant set Affy $Element break } set ElementDAvant $Element } if {$Access == ""} {set Access $Affy} set Access [string trim [string toupper $Access]] set Affy [string trim [string toupper $Affy ]] set LesExpressions [lrange $LaLigne [expr $PosDePouA] [expr $PosDePouA + 8]] if {!$AiJeRencontrePouA} {Espionne coucou; break} if {!$AiJeRencontreAffy} {Espionne coucou; break} if {![info exists Tab(NosDonnees,$Affy)]} { if {![info exists Tab(NosDonnees,$Acc)]} { Espionne $Ligne continue } else { set InfosDeNosDonnees [set Tab(NosDonnees,$Acc)] } } else { set InfosDeNosDonnees [set Tab(NosDonnees,$Affy)] } incr i set Selected "" if {[info exists Tab(AffySelected,$Affy)]} { set Selected [set Tab(AffySelected,$Affy)] } set Expressions [join $LesExpressions "\t"] lappend LesLignes "$InfosDeNosDonnees\t$Access\t$Affy\t$Expressions\t$Selected" } close $F Espionne $i Sauve [join $LesLignes "\n"] dans $FichierOUT return } proc FroMac {args} { if {[PourWscope]} { return [FromMacsim {*}$args] } set Commande "ret FromMacsim [join $args { }]" set Res [QuestionDeScience Zero $Commande] return $Res } proc FromDbClustalToLeon {Nom} { set FichierDbClustal "[RepertoireDuGenome]/msfdbclustal/$Nom" set FichierRascal "[RepertoireDuGenome]/msfrascal/$Nom" set FichierLeon "[RepertoireDuGenome]/msfleon/$Nom" if {[]} {} } proc FromDisphy {NomOuFichier} { global RepertoireDuGenome global FromDisphy Wup "returns the list of all accesses and stores the distances in memory" set M [string toupper $NomOuFichier] if {[info exists FromDisphy($M)]} { return [set FromDisphy($M)] } if {[info exists FromDisphy]} { unset FromDisphy } set Nom [file tail $NomOuFichier] set FichierDisphy $NomOuFichier if { ! [file exists $FichierDisphy]} { set FichierDisphy "$RepertoireDuGenome/disphy/$Nom" } if { ! [file exists $FichierDisphy]} { return {} } set LesAccess {} foreach Ligne [LesLignesDuFichier $FichierDisphy] { set Access "" scan $Ligne "%s %s %s" Orga Dis Access if {$Access==""} { continue } set ACCESS [string toupper $Access] set FromDisphy($ACCESS) $Dis lappend LesAccess $Access } set FromDisphy($NomOuFichier) $LesAccess return $LesAccess } proc FromDisphyOf {A B} { FromDisphy $A return [FromDisphy $B] } proc FromDumpOrdaliToCanvasOrHtml {Dump {KorH ""} {DecalX 0} {DecalY 0} {aExtremeX ""} {aExtremeY ""}} { global CouleurTag global GaucheOrdali if {$aExtremeX!=""} { upvar $aExtremeX ExtremeX } if {$aExtremeY!=""} { upvar $aExtremeY ExtremeY } set TexteHTML "" if {[regexp {^\.} $KorH] && ![regexp "/" $$KorH]} { set K $KorH set OnCanva 1 set OnHTML 0 } else { set FichierHTML $KorH set K "" if {$FichierHTML==""} { set FichierHTML "[TmpFile ordali].html" } set OnCanva 0 set OnHTML 1 } set CouleurTag "CouleurTagParDefaut" set LeDump [split $Dump "\n"] set Fonte [ValeurDeLaBalise "font" Dump "Rogner"] set Tags [ValeurDeLaBalise "tags" Dump "Rogner"] set Regle [ValeurDeLaBalise "regle" Dump "Rogner"] set Noms [ValeurDeLaBalise "noms" Dump "Rogner"] set Texte [ValeurDeLaBalise "texte" Dump "Rogner"] regsub -all "\n" $Regle "" Regle regsub -all "\n" $Noms "" Noms regsub -all "\n" $Texte "" Texte eval set LesCouleurs [list $Tags] if {$OnCanva} { CouleurOrdali "Create" $LesCouleurs } if {$OnHTML } { append TexteHTML "" CouleurOrdali "CreateHTML" $LesCouleurs TexteHTML append TexteHTML "\n

"
    }

    set AttendFermante 0
    set ExtremeX $DecalX
    set ExtremeY $DecalY
    
    foreach {Action TexteDesToken} [list  "Nommer" $Noms   "RegleH" $Regle  "Taguer" $Texte  "RegleB" $Regle ] {
	foreach Token [split $TexteDesToken " "] {
	    if {[regexp {\}$} $Token]} {
		set AttendFermante 0
		if {[info exists Mot]} {
		    append Mot " $Token"
		} else {
		    set Mot $Token
		}
	    }
	    if {$AttendFermante} {
		append Mot " $Token"
		continue
	    }
	    if { ! [info exists Mot] && [regexp {^\{} $Token]} {
		set AttendFermante 1
		set Mot $Token
		continue
	    }
	    
	    if { ! [info exists Mot]} {
		set Mot $Token
	    }
	    
	    if { ! [info exists Key]} {
		set Key $Mot
		unset Mot
		continue
	    }
	    if { ! [info exists Value]} {
		set Value $Mot
		unset Mot
		continue
	    }
	    set Index $Mot
	    
	    switch $Key {
		"tagon"   { Tagon  $Value $Index $K } 
		"tagoff"  { Tagoff $Value $Index $K } 
		"text"    {
		    if {$OnCanva} { set LoinXY [TextOnCanva $Value $Index $K $DecalX $DecalY]}
		    if {$OnHTML } {
			if {$Action=="RegleH"} { set Index [expr -$Index] }
			if {$Action=="RegleB"} { set Index [expr  $Index + 9999.0] }
			if {$Action=="Nommer"} {
			    set Y [expr int($Index)]
			    regsub -all -nocase {[^a-z0-9_]} $Value "" Nom
			    set GaucheOrdali($Y) $Nom
			} else {
			    set LoinXY [TextOnHTML  $Value $Index TexteHTML]
			    scan $LoinXY "%d %d" LoinX LoinY
			    set ExtremeX [Maxi $ExtremeX $LoinX]
			    set ExtremeY [Maxi $ExtremeY $LoinY]
			}
		    }
		} 
		"default" { }
	    }
	    unset Key Value Index Mot
	}
    }
    incr ExtremeX 1
    incr ExtremeY 1
    if {$OnHTML} {
	append TexteHTML "\n

\n\n" if {$FichierHTML=="RetourneTexteHTML"} { return $TexteHTML } else { return [Sauve $TexteHTML dans $FichierHTML] } } return $K } proc FromEutilsNCBI {Id {Db ""} {Format ""}} { if {$Db=="" && [regexp {^rs([0-9]+)$} $Id Match N]} { set Id $N set Db "snp" } if {$Format==""} { set Format "XML" } set Query "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=$Db&id=$Id&report=$Format" set Page [HttpGetTextFromUrl $Query] return $Page regsub -nocase {^.+]*>\n*} $Page "" Page regsub -nocase {.*} $Page "" Page regsub -all {\<} $Page "<" Page regsub -all {\>} $Page ">" Page regsub -all {\"} $Page "\"" Page return $Page } proc FromFasta {FichierTFA {FichierGCG ""}} { if {![file exists $FichierTFA]} { return "" } set FicGCG "[TmpFile].gcg" exec clustalw $FichierTFA -convert -output=gcg -outfile=$FicGCG if {[file exists $FicGCG]} { file copy -force $FicGCG $FichierGCG file delete $FicGCG return FichierGCG } FaireLire "FromFasta n'existe plus" #suite obsolete set FichierTFATmp "[TmpFile].tfa" file copy $FichierTFA $FichierTFATmp exec fromfasta -NUC $FichierTFATmp -LIS if {![file exists "fromfasta.list"]} {return ""} foreach Ligne [LesLignesDuFichier "fromfasta.list"] { if { ! [regexp {Begin:[0-9]} $Ligne]} {continue} scan $Ligne "%s" FichierGCGCree } file delete -force "fromfasta.list" if {![file exists $FichierGCGCree]} {return ""} if {$FichierGCG==""} { return $FichierGCGCree } file copy -force $FichierGCGCree $FichierGCG return $FichierGCG } proc FromInfoOfGenBankToEMBL {LesInfosGenBank {OnVeut ""}} { EspionneL $LesInfosGenBank Wup "Maybe it will work only if there is ONE gene in the file" Wup " Otherwise it takes the last" set Gene "" set Product "" set OS "Inconnu inconnu" set OC "Unknown class" set Access "Unknown" foreach Ligne $LesInfosGenBank { if {[regexp "/Access=" $Ligne]} { set Access [StringSuivant "/Access=" dans $Ligne] } if {[regexp "/OS=" $Ligne]} { set OS [StringSuivant "/OS=" dans $Ligne] regsub {\.$} $OS "" OS } if {[regexp "/OC=" $Ligne]} { set OC [StringSuivant "/OC=" dans $Ligne] } if {[regexp "/DEFINITION=" $Ligne]} { set Definition [StringSuivant "/DEFINITION=" dans $Ligne] set Definition [string trim $Definition] } if {[regexp "/DNA=" $Ligne]} { set SeqNuc [StringSuivant "/DNA=" dans $Ligne] } if {[regexp "/translation=" $Ligne]} { set SeqPro [StringSuivant "/translation=" dans $Ligne] } if {[regexp "/gene=" $Ligne]} { set Gene [StringSuivant "/gene=" dans $Ligne] } if {[regexp "/product=" $Ligne]} { set Product [StringSuivant "/product=" dans $Ligne] } if {[regexp "/note=" $Ligne]} { set Note [StringSuivant "/note=" dans $Ligne] } } if {$Product=="" && [info exists Definition]} { set Product $Definition } if {$OnVeut=="prot" && ! [info exists SeqPro]} { if {[info exists SeqNuc] && [regexp -nocase {[^ATGC]} $SeqNuc]} { set SeqPro $SeqNuc unset SeqNuc } } if {$OnVeut=="" && [info exists SeqPro] && [info exists SeqNuc]} { set OnVeut "nuc" } if {$OnVeut=="" && [info exists SeqPro] && ! [info exists SeqNuc]} { set OnVeut "prot" } if {$OnVeut=="" && ! [info exists SeqPro] && [info exists SeqNuc]} { set OnVeut "nuc" } if {[info exists SeqPro] && $OnVeut=="prot"} { set ProtEMBL "" set LongP [expr [string length $SeqPro]] append ProtEMBL "ID $Access PRELIMINARY; PRT; $LongP AA." append ProtEMBL "\nAC $Access" append ProtEMBL "\nOS $OS." append ProtEMBL "\nOC $OC" if {$Product!=""} { append ProtEMBL "\nDE $Product" } if {$Gene!=""} { append ProtEMBL "\nGN $Gene" } append ProtEMBL "\nCC -!- taken by Gscope from a GenBank file" append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]" return $ProtEMBL } if {[info exists SeqNuc] && $OnVeut=="nuc"} { set NucEMBL "" set LongN [expr [string length $SeqNuc]] append NucEMBL "ID $Access PRELIMINARY; DNA; $LongN bases." append NucEMBL "\nAC $Access" append NucEMBL "\nOS $OS." append NucEMBL "\nOC $OC" if {$Product!=""} { append NucEMBL "\nDE $Product" } if {$Gene!=""} { append NucEMBL "\nGN $Gene" } append NucEMBL "\nCC -!- taken by Gscope from a GenBank file" append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]" return $NucEMBL } return "" } proc FromInterproWeb {} { package require http set Url "http://www.biomart.org/biomart/martservice?type=registry" set LaQuery [list ATTRIBUTES entry.default.entry_attributes.entry_id|entry.default.entry_attributes.entry_short_name|entry.default.entry_attributes.entry_name|entry.default.entry_attributes.entry_type|entry.default.entry_attributes.pos_from|entry.default.entry_attributes.protein_ac|entry.default.entry_attributes.protein_name|entry.default.entry_attributes.pos_to|entry.default.entry_attributes.match_score|entry.default.entry_attributes.protein_database_name|entry.default.entry_attributes.protein_tax_id FILTERS "entry.default.filter_page.protein_ac.\"P12345,P12346\"" formatter TSV ] set Query [::http::formatQuery {*}$LaQuery] # append Url "&ATTRIBUTES=entry.default.entry_attributes.entry_id|entry.default.entry_attributes.entry_short_name|entry.default.entry_attributes.entry_name|entry.default.entry_attributes.entry_type|entry.default.entry_attributes.pos_from|entry.default.entry_attributes.protein_ac|entry.default.entry_attributes.protein_name|entry.default.entry_attributes.pos_to|entry.default.entry_attributes.match_score|entry.default.entry_attributes.protein_database_name|entry.default.entry_attributes.protein_tax_id&FILTERS=entry.default.filter_page.protein_ac.P12345&FORMAT=TSV" # append Url "&ATTRIBUTES=entry.default.entry_attributes.entry_id&FILTERS=entry.default.filter_page.protein_ac.P12345&FORMAT=TSV" append Url "&$Query" set R [ContenuDuFichier $Url] return $R } proc FromList {Liste {GetWhat ""} {ExprFunction ""}} { if {$GetWhat=="Iterate"} { set LeNew {} foreach V $Liste { set N [expr [set ExprFunction]($V)] lappend LeNew $N } return $LeNew } set Sum 0 set Length 0 set Min [lindex $Liste 0] set Max [lindex $Liste 0] foreach X $Liste { incr Length set Sum [expr $Sum + $X] if {$Min > $X} { set Min $X } if {$Max < $X} { set Max $X } } if {$Length==0} { return "" } set Average [expr 1.0*$Sum/$Length] set SumDeviation 0 foreach X $Liste { set SumDeviation [expr $SumDeviation + ($Average-$X)*($Average-$X)] } if {$Length==1} { set Deviation 0.0 } else { set Deviation [expr sqrt(1.0*$SumDeviation/($Length-1))] } if {[info exists $GetWhat]} { set Valeur [set $GetWhat] if {$ExprFunction!=""} { set Valeur [expr [set ExprFunction]($Valeur)] } return $Valeur } return "$Average $Deviation $Min $Max $Sum $Length" } proc FromMacsim {{Qui ""} {Quoi ""} {Quid ""}} { LogWscope "FromMacsim =$Qui=$Quoi=$Quid=" #rR Attention Laetita a elle un FromMacsims avec s #rR Mis à jour par Raymond 2016/04/06 #rR FromMacsim permet d'interroger n'importe quel macsims au format XML #rR On utilise DecortiqueUnMacsimXml qui crée pleins de variables globales #rR La liste des variables globales existantes est accessible par #rR FromMacsim FichierMacsims ListOfList #rR FromMacsim FichierMacsims ListOfArray #rR On indexe tout par le nom du fichier ou par le MD5 du Texte xml s'il est fourni #rR Quand on interroge un Projet Gscope particulier (par exemple CilioCarta2014) le nom CIL123 suffit #rR FromMacsim CIL006 ListOfList (rend la liste des listes qu'on peut interroger) #rR FromMacsim CIL006 AlnName #rR FromMacsim CIL006 LNOrdali #rR FromMacsim CIL006 ListOfNames (rend la liste des noms des sequences) #rR FromMacsim CIL006 ListOfFeatureType #rR FromMacsim CIL006 Sequences get (rend la liste cle valeur cle valeur ...) #rR FromMacsim CIL006 Sequences G1PUE7_MYOLU (rend la sequence) ....... les array sont créés à la première demande puis stockés ;) #rR FromMacsim CIL006 BLOCK G1PUE7_MYOLU (rend les features BLOCK) #rR Les couleurs sont valables pour tous les macsims ;) #rR FromMacsim MacsimsColor (rend la liste cle valeur cle valeur des Colorations utilisées) #rR FromMacsim MacsimsColor names (rend les cles des Colorations utilisées) #rR FromMacsim MacsimsColor ConsGlob (rend le couple foreground background pour les Conservation Globales) #rR FromMacsim MacsimsColor Stock (rend les couleurs utilisées pour les Features) #rR FromMacsim MacsimsColor 4 (rend la quatrième couleur utilisée pour les Features) #rR On peut mettre un nom complet de fichier #rR FromMacsim /ici/ou/la/toto.xml #rR ou pour tout projet Gscope #rR FromMacsim ProjetGscope/Prefixe12345 (qui évite de mettre /genomics/link/ProjetGscope/macsimXml/Prefixe12345) if {$Qui==""} { set Qui "Help" } global FromMacsim global Defauts Couleurs if { ! [info exists Couleurs] } { LesDefauts DefinitionPreferences set FromMacsim(MacsimsColor) [array get Couleurs] } if {$Qui=="MacsimsColor"} { if {$Quoi=="" || $Quoi=="get"} { return $FromMacsim(MacsimsColor) } if {$Quoi=="names"} { return [array names Couleurs] } if {[info exists Couleurs($Quoi)]} { return $Couleurs($Quoi) } if {[regexp {^[0-9]+$} $Quoi]} { return [lindex $Couleurs(Stock) $Quoi] } return "" } if { ! [info exists FromMacsim(PackageMD5Loaded)]} { package require md5 set FromMacsim(PackageLoaded) 1 } if {$Qui=="Color"} { set LeHelp {} foreach Ligne [split [info body FromMacsim] "\n"] { if { ! [regexp " +#rR" $Ligne]} { continue } lappend LeHelp $Ligne } return [join $LeHelp "\n"] } if {$Qui=="Help"} { set LeHelp {} foreach Ligne [split [info body FromMacsim] "\n"] { if { ! [regexp " +#rR" $Ligne]} { continue } lappend LeHelp $Ligne } return [join $LeHelp "\n"] } if {$Qui=="UnsetAll"} { array unset FromMacsim set FromMacsim(PackageLoaded) 1 return "" } if {[regexp "\n" $Qui]} { set MD5 [::md5::md5 -hex $Qui] } else { set MD5 $Qui } if {$Quoi=="unset"} { if { ! [info exists FromMacsim($MD5,MD5)]} { return "" } foreach Arr $FromMacsim($MD5,ListOfMemArr) { array unset $Arr } array unset FromMacsim "$MD5,*" return "" } if {[info exists FromMacsim($MD5,$Quoi)]} { if {$Quid==""} { return $FromMacsim($MD5,$Quoi) } else { #rR Attention, là on fait un traitement spécial ... on crée les array à la demande et on les mémorise pour plus tard ;) if {[info exists FromMacsim($MD5,$Quoi,$Quid)]} { return $FromMacsim($MD5,$Quoi,$Quid) } if {$Quid=="get"} { return $FromMacsim($MD5,$Quoi) } if { ! [info exists FromMacsim($MD5,Array_$Quoi)]} { set Arr "Array_[::md5::md5 -hex Array_${Quoi}_$MD5]" lappend FromMacsim($MD5,ListOfMemArr) $Arr set FromMacsim($MD5,Array_$Quoi) $Arr global [set Arr] #rR 20170112 set ::[set Arr]($Quid) $FromMacsim($MD5,$Quoi) ;#rR a verifier c'est louche !!!!!!!!!!je ne comprends plus !!!!!!!!!!!!!!!!!!!!!!!! array set ::[set Arr] $FromMacsim($MD5,$Quoi) } if {[info exists FromMacsim($MD5,Array_$Quoi)]} { set Arr $FromMacsim($MD5,Array_$Quoi) if {$Quid=="names"} { return [array names ::[set Arr]] } if {[info exists ::[set Arr]($Quid)]} { return [set ::[set Arr]($Quid)] } return "" } } } if {[info exists FromMacsim($MD5,$Quoi)]} { return $FromMacsim($MD5,$Quoi) } if {[info exists FromMacsim($MD5,EstCharge)]} { return "" } if {[regexp "\n" $Qui]} { set Xml $Qui } else { set Xml "" if {[FileExists $Qui]} { set Xml [ContenuDuFichier $Qui] } elseif {[FileAbsent $Qui] && [file exists [GscopeFile $Qui "macsimXml"]]} { set Qui [GscopeFile $Qui "macsimXml"] set Xml [ContenuDuFichier $Qui] } elseif {[regexp -nocase {^([^/]+)/(.+)$} $Qui Match Rep Pab]} { if {[FileExists "/genomics/link/$Rep/macsimXml/$Pab"]} { set Xml [ContenuDuFichier "/genomics/link/$Rep/macsimXml/$Pab"] } } if {$Xml==""} { return "" } } set FromMacsim($MD5,MD5) $MD5 set FromMacsim($MD5,EstCharge) 1 set MacsimsVariables [DecortiqueUnMacsimXml $Xml] lassign $MacsimsVariables LesL LesT foreach L $LesL { set FromMacsim($MD5,$L) [set ::$L] } foreach T $LesT { set FromMacsim($MD5,$T) [array get ::$T] } set FromMacsim($MD5,ListOfList) $LesL set FromMacsim($MD5,ListOfArray) $LesT set LesFeatureType {} foreach {K V} [array get ::TabSF] { if {$K=="Imito_Homo.sapi"} { EspionneL $V } foreach Feature $V { set LesMots [split $Feature " "] lassign $LesMots coord LG ftype FT fstart FStart fstop Fstop fcolor FColor fscore FScore fnote set FNote [join [lrange $V 13 end] " "] lappend LesFeatureType $FT lappend FromMacsim($MD5,$FT) $Feature lappend FromMacsim($MD5,$FT,$K) $Feature } } set FromMacsim($MD5,ListOfFeatureType) [lsort -unique $LesFeatureType] set FromMacsim($MD5,ListOfNames) $::LNOrdali lappend FromMacsim($MD5,ListOfList) ListOfFeatureType ListOfNames # attention on triche un peu là if {$Quoi=="MacsimsColor"} { return [FromMacsim $Quoi $Quid] } return [FromMacsim $MD5 $Quoi $Quid] } proc FromMacsims {FichierMacsim Qui Quoi} { #pour un name dans un fichier macsims global CarDuMacs set FichierMacsim [TheTrueMacsimsFile $FichierMacsim] # if {$Qui==""} {return "il me faut un name"} if {[info exists CarDuMacs(FichierMacsim)] && $CarDuMacs(FichierMacsim)!=$FichierMacsim} { unset CarDuMacs } if {[info exists CarDuMacs($Qui,$Quoi)]} { return $CarDuMacs($Qui,$Quoi) } if {[info exists CarDuMacs("EstCharge")]} { return "" } set CarDuMacs("EstCharge") 1 set CarDuMacs(FichierMacsim) $FichierMacsim package require tdom set fh [open $FichierMacsim "r"] dom parse -channel $fh doc close $fh $doc documentElement root set LesSeq [$root selectNodes "//sequence"] foreach seq $LesSeq { set Name [$seq selectNodes "string(./seq-name)"] lappend LesNames $Name set LesConcatMacsims {}; set LesPFAMMacsims {} set LesConcatDOMAIN {}; set LesDOMAINMacsims {} set LesConcatSTRUCT {}; set LesSTRUCTMacsims {} set LesConcatREGION {}; set LesREGIONMacsims {} set LesConcatPROSITE {}; set LesPROSITEMacsims {} set LesConcatELM {}; set LesELMMacsims {} set LesConcatBLOCK {}; set LesBLOCKMacsims {} set LesConcatKOANNO {}; set LesKOANNOMacsims {} set SeqData [$seq selectNodes "string(./seq-data)"] regsub -all {\-} $SeqData "" SeqDataSansGap set SeqDataSansGap [string trim $SeqDataSansGap] if {[regexp "^ENS" $Name] || [regexp "^GST" $Name]} { set Organism [lindex [split $Name "_"] 1] set OrganismLong "" if {[regexp "^ENS" $Name]} { set ENS [string range $Name 0 5] if {[regexp {[0-9]} $ENS]} { set ENS [string range $Name 0 2] } set OrganismLong [InterrogeCorresEnsEtOS $ENS OS] } } else { set TextOrganism [$seq selectNodes "string(./seq-info/organism)"] set TextOrganism [string trim $TextOrganism] set LesMotsOrganism [split $TextOrganism " "] set Organism [lindex $LesMotsOrganism 0] set OrganismLong "[lindex $LesMotsOrganism 0] [lindex $LesMotsOrganism 1]" } set Group [$seq selectNodes "string(./seq-info/group)"] set Length [$seq selectNodes "string(./seq-info/length)"] foreach noeud_PFAM [$seq selectNodes ".//fitem\[ftype=\"PFAM-A\"\]"] { set PFAMMacsims [$noeud_PFAM selectNodes "string(./fnote)"] set StartMacsims [$noeud_PFAM selectNodes "string(./fstart)"] set StopMacsims [$noeud_PFAM selectNodes "string(./fstop)"] #foreach noeud_PFAM [$seq selectNodes ".//fitem\[ftype=\"PFAM-A\"\]/fnote"] #lappend LesPFAMMacsims [$noeud_PFAM selectNodes "string(./text())"] lappend LesConcatMacsims "$PFAMMacsims/$StartMacsims-$StopMacsims" lappend LesPFAMMacsims $PFAMMacsims } foreach noeud_DOMAIN [$seq selectNodes ".//fitem\[ftype=\"DOMAIN\"\]"] { set DOMAINMacsims [$noeud_DOMAIN selectNodes "string(./fnote)"] set StartDOMAIN [$noeud_DOMAIN selectNodes "string(./fstart)"] set StopDOMAIN [$noeud_DOMAIN selectNodes "string(./fstop)"] lappend LesConcatDOMAIN "$DOMAINMacsims/$StartDOMAIN-$StopDOMAIN" lappend LesDOMAINMacsims $DOMAINMacsims } foreach noeud_STRUCT [$seq selectNodes ".//fitem\[ftype=\"STRUCT\"\]"] { set STRUCTMacsims [$noeud_STRUCT selectNodes "string(./fnote)"] set StartSTRUCT [$noeud_STRUCT selectNodes "string(./fstart)"] set StopSTRUCT [$noeud_STRUCT selectNodes "string(./fstop)"] lappend LesConcatSTRUCT "$STRUCTMacsims/$StartSTRUCT-$StopSTRUCT" lappend LesSTRUCTMacsims $STRUCTMacsims } foreach noeud_REGION [$seq selectNodes ".//fitem\[ftype=\"REGION\"\]"] { set REGIONMacsims [$noeud_REGION selectNodes "string(./fnote)"] set StartREGION [$noeud_REGION selectNodes "string(./fstart)"] set StopREGION [$noeud_REGION selectNodes "string(./fstop)"] lappend LesConcatREGION "$REGIONMacsims/$StartREGION-$StopREGION" lappend LesREGIONMacsims $REGIONMacsims } foreach noeud_PROSITE [$seq selectNodes ".//fitem\[ftype=\"PROSITE\"\]"] { set PROSITEMacsims [$noeud_PROSITE selectNodes "string(./fnote)"] set StartPROSITE [$noeud_PROSITE selectNodes "string(./fstart)"] set StopPROSITE [$noeud_PROSITE selectNodes "string(./fstop)"] lappend LesConcatPROSITE "$PROSITEMacsims/$StartPROSITE-$StopPROSITE" lappend LesPROSITEMacsims $PROSITEMacsims } foreach noeud_ELM [$seq selectNodes ".//fitem\[ftype=\"ELM\"\]"] { set ELMMacsims [string toupper [$noeud_ELM selectNodes "string(./fnote)"]] set StartELM [$noeud_ELM selectNodes "string(./fstart)"] set StopELM [$noeud_ELM selectNodes "string(./fstop)"] lappend LesConcatELM [list $ELMMacsims $StartELM $StopELM] lappend LesELMMacsims $ELMMacsims } foreach noeud_BLOCK [$seq selectNodes ".//fitem\[ftype=\"BLOCK\"\]"] { set BLOCKMacsims [$noeud_BLOCK selectNodes "string(./fnote)"] set StartBLOCK [$noeud_BLOCK selectNodes "string(./fstart)"] set StopBLOCK [$noeud_BLOCK selectNodes "string(./fstop)"] lappend LesConcatBLOCK "$BLOCKMacsims/$StartBLOCK-$StopBLOCK" lappend LesBLOCKMacsims $BLOCKMacsims } foreach noeud_KOANNO [$seq selectNodes ".//fitem\[ftype=\"KOANNO\"\]"] { set KOANNOMacsims [$noeud_KOANNO selectNodes "string(./fnote)"] set StartKOANNO [$noeud_KOANNO selectNodes "string(./fstart)"] set StopKOANNO [$noeud_KOANNO selectNodes "string(./fstop)"] lappend LesConcatKOANNO "$KOANNOMacsims/$StartKOANNO-$StopKOANNO" lappend LesKOANNOMacsims $KOANNOMacsims } #trie les features du Nter vers Cter set LesConcatMacsims [lsort -increasing -command CompareIntegerFromMacsims $LesConcatMacsims] set LesConcatDOMAIN [lsort -increasing -command CompareIntegerFromMacsims $LesConcatDOMAIN] set LesConcatSTRUCT [lsort -increasing -command CompareIntegerFromMacsims $LesConcatSTRUCT] set LesConcatREGION [lsort -increasing -command CompareIntegerFromMacsims $LesConcatREGION] set LesConcatPROSITE [lsort -increasing -command CompareIntegerFromMacsims $LesConcatPROSITE] set LesConcatELM [lsort -increasing -command CompareIntegerFromMacsims $LesConcatELM] set LesConcatBLOCK [lsort -increasing -command CompareIntegerFromMacsims $LesConcatBLOCK] set LesConcatKOANNO [lsort -increasing -command CompareIntegerFromMacsims $LesConcatKOANNO] set CarDuMacs($Name,JustPfam) $LesPFAMMacsims set CarDuMacs($Name,ConcatPfam) $LesConcatMacsims set CarDuMacs($Name,SeqDataSansGap) $SeqDataSansGap set CarDuMacs($Name,SeqData) $SeqData set CarDuMacs($Name,Organism) $Organism set CarDuMacs($Name,OrganismLong) $OrganismLong set CarDuMacs($Name,Group) $Group set CarDuMacs($Name,Length) $Length set CarDuMacs($Name,JustElm) $LesELMMacsims set CarDuMacs($Name,ConcatElm) $LesConcatELM set CarDuMacs($Name,JustBlock) $LesBLOCKMacsims set CarDuMacs($Name,ConcatBlock) $LesConcatBLOCK set CarDuMacs($Name,JustDomain) $LesDOMAINMacsims set CarDuMacs($Name,ConcatDomain) $LesConcatDOMAIN set CarDuMacs($Name,JustStruct) $LesSTRUCTMacsims set CarDuMacs($Name,ConcatStruct) $LesConcatSTRUCT set CarDuMacs($Name,JustRegion) $LesREGIONMacsims set CarDuMacs($Name,ConcatRegion) $LesConcatREGION set CarDuMacs($Name,JustProsite) $LesPROSITEMacsims set CarDuMacs($Name,ConcatProsite) $LesConcatPROSITE set CarDuMacs($Name,JustKoanno) $LesKOANNOMacsims set CarDuMacs($Name,ConcatKoanno) $LesConcatKOANNO } $doc delete set CarDuMacs(ListOf,Names) $LesNames return [FromMacsims $FichierMacsim $Qui $Quoi] } proc FromMenu {w mode} { if {[QuelMode] in {"ordali" "feature"}} { ChangeMode $mode } return } proc FromNCBI {Id {Db ""} {Format ""}} { if {$Db==""} { set Db "nucleotide" if {[regexp "^NP" $Id]} { set Db "protein" } } set Query "http://www.ncbi.nlm.nih.gov/entrez/viewer.fcgi?db=$Db&val=$Id" set Page [HttpGetTextFromUrl $Query] regsub -nocase -nocase {^.+]*>\n*} $Page "" Page regsub -nocase -nocase {.*} $Page "" Page regsub -all {\<} $Page "<" Page regsub -all {\>} $Page ">" Page regsub -all {\"} $Page "\"" Page return $Page } proc FromNCBI2 {Id {Db ""} {Format ""}} { if {$Db==""} { set Db "nucleotide" if {[regexp "^NP" $Id]} { set Db "protein" } } set Query "http://www.ncbi.nlm.nih.gov/entrez/viewer.fcgi?db=$Db&val=$Id" set Page [HttpCopy $Query] regsub -nocase {^.+

\n*} $Page "" Page
    regsub -nocase {

.*} $Page "" Page regsub -all {\<} $Page "<" Page regsub -all {\>} $Page ">" Page regsub -all {\"} $Page "\"" Page return $Page } proc FromOrthoInspector {{Qui ""} {Quoi ""}} { #rR Lit les fasta de OrthoInspector #rR global FromOrthoInspector set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {[info exists FromOrthoInspector($Qui,$Quoi)]} { return $FromOrthoInspector($Qui,$Quoi) } if {[info exists FromOrthoInspector("EstCharge")]} { if {[info exists FromOrthoInspector($Qui,ID)]} { set ID [string toupper $FromOrthoInspector($Qui,ID)] if {[info exists FromOrthoInspector($ID,$Quoi)]} { return $FromOrthoInspector($ID,$Quoi) } } if {[info exists FromOrthoInspector($Qui,TAXID)]} { set TID $FromOrthoInspector($Qui,TAXID) if {[info exists FromOrthoInspector($TID,$Quoi)]} { return $FromOrthoInspector($TID,$Quoi) } } return "" } set FromOrthoInspector("EstCharge") 1 set OnGarde 0 set Rep [OrganismFromOrthoInspector Rep] set FromOrthoInspector(REP,) $Rep set LesTaxId [OrganismFromOrthoInspector ListOf TaxId] set Testons 0 ;#rR pour test ******** if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] } set FromOrthoInspector(LISTOF,TAXID) [join $LesTaxId "\n"] foreach TaxId $LesTaxId { set OsDuFichier [OrganismFromOrthoInspector $TaxId FullOs] set OsCourtDuFichier [OrganismFromOrthoInspector $TaxId Os] lappend FromOrthoInspector(LISTOF,FULLOS) $OsDuFichier set FromOrthoInspector($TaxId,FULLOS) $OsDuFichier set Fichier [OrganismFromOrthoInspector $TaxId Filename] set Queue [file tail $Fichier] set LeTFACourant {} set LesLignes [LesLignesDuFichier $Fichier] lappend LesLignes ">CESTFINIPOURCEFICHIER" set OsDansFichier "" set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout if {[info exists Courant]} { unset Courant } foreach Ligne $LesLignes { if {$Testons && [incr MaxiPourTestons -1]==0} { break } regsub -all " +" $Ligne " " Ligne set Ligne [string trim $Ligne] if {$Ligne==""} { continue } #rR dans sequence if { ! [regexp "^>" $Ligne]} { if {[regexp -nocase {[^A-Z]} $Ligne]} { if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] } if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} { #rR la, il y a meme autre chose lappend FromOrthoInspector(LISTOF,BAD) "$Queue $Courant $Ligne" FaireLire "Dans $Queue $Courant \n$Ligne" set OnGarde 0 continue } if {[regexp -nocase {\*} $Ligne Match]} { #FaireLire "Dans $Queue $Courant \n$Ligne" lappend FromOrthoInspector(LISTOF,OSWHITHSTAR) $Queue lappend FromOrthoInspector($TaxId,STAR) $Courant set OnGarde 0 continue } } if {$Ligne!=""} { set OnGarde 1 lappend LeTFACourant $Ligne } continue } #rR on a un chevron #rR on traite d'abord le précédent if {[info exists Courant]} { if {$OnGarde} { set ID [string toupper $Id] set COURANT [string toupper $Courant] set FromOrthoInspector($COURANT,TFA) [join $LeTFACourant "\n"] set FromOrthoInspector($ID,ID) $Id set FromOrthoInspector($ID,AC) $Ac lappend FromOrthoInspector(LISTOF,IDS) $Id lappend FromOrthoInspector(LISTOF,ACS) $Ac lappend FromOrthoInspector($TaxIdDuCourant,IDS) $Id lappend FromOrthoInspector($TaxIdDuCourant,ACS) $Ac set FromOrthoInspector($ID,TAXID) $TaxIdDuCourant } } if {$Ligne==">CESTFINIPOURCEFICHIER"} { break } #rR on traite l'entête if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} { FaireLire "pas bon $Ligne" lappend LeNew $Ligne continue } set TexteBanque "" if {[regexp {\|} $Ligne]} { regexp {^>([^ ]+) (.+)} $Ligne Match AI D set Banque "" set Ac "" set Id "" lassign [split $AI "|"] Banque Ac Id if {$Ac==""} { set Ac $AI } if {$Id==""} { set Id $Ac } regsub {OS=.*} $D "" D regsub {GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } if {$Banque!=""} { set TexteBanque " BANK=$Banque" } } else { regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D regsub {OS=.*} $D "" D regsub {GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } #rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id } if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac } } set Gn "" regexp {GN=([^ ]+)} $Ligne Match Gn set TextGn "" if {$Gn!=""} { set TextGn " GN=$Gn" } regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN set FullOs "Unknown unknown" set OsDansEntete "" if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} { regsub -all " " $FullOs "_" FullOs regsub -all "/" $FullOs "and" FullOs set OsDansEntete $FullOs } lassign [split $FullOs "_"] G E set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque" set LeTFACourant [list $Entete] if {$OsDansEntete==""} { set OsDansFichier $FullOs } if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} { set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier" if {0 && ! [info exists MessageLu($Message)]} { FaireLire "$Message" set MessageLu($Message) 1 } } set Courant $Id set COURANT [string toupper $Courant] set TaxIdDuCourant $TaxId set ID [string toupper $Id] set AC [string toupper $Ac] if {$ID!=$AC} { set FromOrthoInspector($AC,ID) $ID } set FromOrthoInspector($ID,FULLOS) $FullOs set FULLOS [string toupper $FullOs] set FromOrthoInspector($FULLOS,TAXID) $TaxId } set FromOrthoInspector([string toupper $OsDuFichier],TAXID) $TaxId } set FromOrthoInspector(LISTOF,STAR) {} set FromOrthoInspector(LISTOF,COUNTSTAR) {} foreach TaxId $LesTaxId { if { ! [info exists FromOrthoInspector($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } set FullOs $FromOrthoInspector($TaxId,FULLOS) lappend FromOrthoInspector(LISTOF,TAXIDOS) "${TaxId}_$FullOs" set nOK [llength $FromOrthoInspector($TaxId,IDS)] lappend FromOrthoInspector(LISTOF,COUNT) "$nOK $TaxId $FullOs" if {[info exists FromOrthoInspector($TaxId,STAR)]} { set nKO [llength $FromOrthoInspector($TaxId,STAR)] lappend FromOrthoInspector(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs" } } set FromOrthoInspector(LISTOF,TAXIDOS) [join $FromOrthoInspector(LISTOF,TAXIDOS) "\n"] set FromOrthoInspector(LISTOF,FULLOS) [join $FromOrthoInspector(LISTOF,FULLOS) "\n"] set FromOrthoInspector(LISTOF,COUNT) [join $FromOrthoInspector(LISTOF,COUNT) "\n"] set FromOrthoInspector(LISTOF,STAR) [join $FromOrthoInspector(LISTOF,STAR) "\n"] set FromOrthoInspector(LISTOF,COUNTSTAR) [join $FromOrthoInspector(LISTOF,COUNTSTAR) "\n"] return [FromOrthoInspector $Qui $Quoi] } proc FromParser {{Qui ""} {Quoi ""} {ParserFile ""}} { global FromParser if {$ParserFile==""} { if { ! [info exists FromParser(ParserFile)]} { return "" } set ParserFile $FromParser(ParserFile) } set FromParser(ParserFile) $ParserFile if {[info exists FromParser($Qui,$Quoi,$ParserFile)]} { return $FromParser($Qui,$Quoi,$ParserFile) } if {[info exists FromParser("EstCharge",$ParserFile)]} { return "" } set FromParser("EstCharge",$ParserFile) 1 set MaxNbInteract 0 foreach Ligne [LesLignesDuFichier $ParserFile] { foreach {IdString PN NbInteract MyNbInteract bidon2 bidon3} [split $Ligne "\t"] { set MaxNbInteract [expr max($MaxNbInteract,$NbInteract)] lappend FromParser(ListOf,IdString,$ParserFile) $IdString set FromParser($IdString,NbInteract,$ParserFile) $NbInteract set FromParser($IdString,MyNbInteract,$ParserFile) $MyNbInteract } } set FromParser(Max,NbInteract,$ParserFile) $MaxNbInteract return [FromParser $Qui $Quoi $ParserFile] } proc FromProtUrl {url lolo papa} { #rR merci de me dupliquer dans misynpat_tools.tcl et gscope_outils.tcl foreach X {lolo papa} { if {[regexp {^([0-9]+)([^0-9].+)$} [set $X] M K V]} { set N "" foreach p [split $K ""] { append N [string index $V $p] } set $X $N } } #rR from D. J. Hagberg Wiki Tcl set auth "Basic [Base64Encode $lolo:$papa]" set headerl [list Authorization $auth] set tok [http::geturl $url -headers $headerl] set res [http::data $tok] http::cleanup $tok return $res } proc FromRef {Ref Champ} { if { ! [regexp -nocase {[a-z_0-9]} $Ref]} { return "" } set Liste {} foreach Ligne [split $Ref "\n"] { if {[regexp "^$Champ" $Ligne]} { regsub "$Champ " $Ligne "" Texte lappend Liste [string trim $Texte] } } return [join $Liste " "] } proc FromRetnetForAffy {Qui {Quoi ""}} { #attention le gene name doit etre en majuscules global FromRetnetForAffy if {[info exists FromRetnetForAffy($Qui,$Quoi)]} { return $FromRetnetForAffy($Qui,$Quoi) } if {[info exists FromRetnetForAffy("EstCharge")]} { return "" } set FromRetnetForAffy("EstCharge") 1 foreach Ligne [LesLignesDuFichier "/genomics/link/EVImm/parser2008/FromRetNet/RetNet_Symbols_Diseases_UTF8.csv"] { if {[regexp ^RetNet $Ligne]} {continue} if {[regexp ^Symbol $Ligne]} {continue} set elmt [split $Ligne ";"] set Gn [lindex $elmt 0] set Dis1 [lindex $elmt 1] set Dis2 [lindex $elmt 2] set FromRetnetForAffy($Gn,Dis1) $Dis1 set FromRetnetForAffy($Gn,Dis2) $Dis2 lappend FromRetnetForAffy(ListOf,Gn) $Gn } return [FromRetnetForAffy $Qui $Quoi] } proc FromScrollYBiotext2Names {args} { # le widget biotext envoie un ordre pour que la scrollbar # se reajuste EN TANT QUE WIDGET, pas qu'elle renvoie les # infos aux widget auxquels elle est attaché, sinon on # ferait une boucle ! # mais il faut quand meme mettre à jour le widget noms $::NomNomSeq yview moveto [lindex $args 0] $::TScrollY set {*}$args return } proc FromStringList {Qui {File ""}} { global FromStringList if {$File!=""} { if {[info exists FromStringList(CurrentFile)]} { if {$File==$FromStringList(CurrentFile)} { return [FromStringList $Qui] } } if {[info exists FromStringList]} { unset FromStringList } set FromStringList(CurrentFile) $File foreach Ligne [LesLignesDuFichier $File] { set IdString [string trim $Ligne] set FromStringList($IdString) 1 lappend FromStringList(ListOf) $IdString } } if {[info exists FromStringList($Qui)]} { return $FromStringList($Qui) } return 0 } proc FromSummary {{Qui ""} {Quoi ""} {SummaryFile ""}} { global FromSummary if {$SummaryFile==""} { if { ! [info exists FromSummary(SummaryFile)]} { return "" } set SummaryFile $FromSummary(SummaryFile) } set FromSummary(SummaryFile) $SummaryFile if {[info exists FromSummary($Qui,$Quoi,$SummaryFile)]} { return $FromSummary($Qui,$Quoi,$SummaryFile) } if {[info exists FromSummary("EstCharge",$SummaryFile)]} { return "" } set FromSummary("EstCharge",$SummaryFile) 1 foreach Ligne [LesLignesDuFichier $SummaryFile] { foreach {IdInitial IdString PN Bidon} [split $Ligne ";"] { if {$IdInitial=="Initial"} {continue} lappend FromSummary($IdString,PN,$SummaryFile) $PN lappend FromSummary($IdString,IdInitial,$SummaryFile) $IdInitial lappend FromSummary($IdInitial,IdString,$SummaryFile) $IdString lappend FromSummary($IdInitial,PN,$SummaryFile) $PN lappend FromSummary($PN,IdInitial,$SummaryFile) $IdInitial lappend FromSummary($PN,IdString,$SummaryFile) $IdString lappend FromSummary(ListOf,IdInitial,$SummaryFile) $IdInitial lappend FromSummary(ListOf,IdString,$SummaryFile) $IdString } } ListeSansDoublon $FromSummary($IdString,PN,$SummaryFile) ListeSansDoublon $FromSummary($IdString,IdInitial,$SummaryFile) ListeSansDoublon $FromSummary($IdInitial,IdString,$SummaryFile) ListeSansDoublon $FromSummary($IdInitial,PN,$SummaryFile) ListeSansDoublon $FromSummary(ListOf,IdInitial,$SummaryFile) ListeSansDoublon $FromSummary(ListOf,IdString,$SummaryFile) return [FromSummary $Qui $Quoi $SummaryFile] } proc FromTkCol {{Qui ""} {Quoi ""}} { #rR TkCol connait toutes les couleurs TkCol(aquamarine) = 127 255 212 #rR FromTkCol fournit l'un en fonction de l'autre et aussi les listes #rR nom est le nom de la couleur n le meme sans blanc #rR FromTkCol répond même avec une mauvaise casse ;-) global TkCol FromTkCol set Quoi [string tolower $Quoi] if {[info exists FromTkCol($Qui,$Quoi)]} { return $FromTkCol($Qui,$Quoi) } if {[info exists FromTkCol("EstCharge")]} { set QUI [string toupper $Qui] regsub -all " " $QUI "" QUI if {[info exists FromTkCol($QUI,$Quoi)]} { return $FromTkCol($QUI,$Quoi) } return "" } set FromTkCol("EstCharge") 1 if { ! [info exists TkCol]} { InitTkCol } foreach {Nom Rgb} [array get TkCol] { regsub -all " " $Nom "" n set NOM [string toupper $Nom] set N [string toupper $n] set FromTkCol($Nom,rgb) $Rgb set FromTkCol($n,rgb) $Rgb set FromTkCol($NOM,rgb) $Rgb set FromTkCol($N,rgb) $Rgb set FromTkCol($Nom,nom) $Nom set FromTkCol($n,nom) $Nom set FromTkCol($NOM,nom) $Nom set FromTkCol($N,nom) $Nom set FromTkCol($Nom,n) $n set FromTkCol($n,n) $n set FromTkCol($NOM,n) $n set FromTkCol($N,n) $n lappend FromTkCol($Rgb,nom) $Nom lappend FromTkCol($Rgb,n) $n lappend FromTkCol(LISTOF,nom) $Nom lappend FromTkCol(LISTOF,n) $n lappend FromTkCol(LISTOF,rgb) $Rgb } set FromTkCol(LISTOF,nom) [concat $FromTkCol(LISTOF,nom) $FromTkCol(LISTOF,n)] set FromTkCol(LISTOF,nom) [lsort -unique $FromTkCol(LISTOF,nom)] set FromTkCol(LISTOF,n) [lsort -unique $FromTkCol(LISTOF,n)] return [FromTkCol $Qui $Quoi] } proc FromUserList {Qui {ListOrFile ""} {TaxId ""}} { global FromUserList if {$ListOrFile!=""} { if {[info exists FromUserList(CurrentFile)]} { if {$ListOrFile==$FromUserList(CurrentFile)} { return [FromUserList $Qui] } } if {[info exists FromUserList]} { unset FromUserList } set FromUserList(CurrentFile) $ListOrFile if {[file isfile $ListOrFile]} { set LesLignes [LesLignesDuFichier $ListOrFile] } else { set LesLignes $ListOrFile } foreach Ligne $LesLignes { set Nom [string trim $Ligne " \"\'"] set Source "FromGn" if {[regexp -nocase {^[0-9]+$} $Nom]} { set Source "FromString" } if {[regexp -nocase {_at} $Nom]} { set Source "FromAffy" } if {[regexp -nocase {^(NM|NP)[_0-9\.]+} $Nom]} { set Source "FromNM" } switch $Source { "FromAffy" { set IdString [ProtIDStringFromAffx $Nom $TaxId] } "FromNM" { set IdString [ProtIDStringFromNM $Nom $TaxId] } "FromGn" { set IdString [ProtIDStringFromGn $Nom $TaxId] } "FromString" { set IdString $Nom } } if {$IdString!=""} { set NOM [string toupper $Nom] set FromUserList($NOM) 1 set FromUserList($IdString) 1 lappend FromUserList(LISTOF) $Nom lappend FromUserList(LISTOF) $IdString } } set FromUserList(LISTOF) [lsort -unique $FromUserList(LISTOF)] } set QUI [string toupper $Qui] if {[info exists FromUserList($QUI)]} { return $FromUserList($QUI) } return 0 } proc FromYannis {{Qui ""} {Quoi ""}} { #rR Lit les fasta de Yannis #rR en utilisant OrganismFromYannis qui lit tous les ficheirs d'un repertoire global FromYannis set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {[info exists FromYannis($Qui,$Quoi)]} { return $FromYannis($Qui,$Quoi) } if {[info exists FromYannis("EstCharge")]} { if {[info exists FromYannis($Qui,ID)]} { set ID [string toupper $FromYannis($Qui,ID)] if {[info exists FromYannis($ID,$Quoi)]} { return $FromYannis($ID,$Quoi) } } if {[info exists FromYannis($Qui,TAXID)]} { set TID $FromYannis($Qui,TAXID) if {[info exists FromYannis($TID,$Quoi)]} { return $FromYannis($TID,$Quoi) } } return "" } set FromYannis("EstCharge") 1 set OnGarde 0 set Rep [OrganismFromYannis Rep] set FromYannis(REP,) $Rep set LesTaxId [OrganismFromYannis ListOf TaxId] set Testons 0 ;#rR pour test ******** if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] } set FromYannis(LISTOF,TAXID) [join $LesTaxId "\n"] foreach TaxId $LesTaxId { set OsDuFichier [OrganismFromYannis $TaxId FullOs] set OsCourtDuFichier [OrganismFromYannis $TaxId Os] lappend FromYannis(LISTOF,FULLOS) $OsDuFichier set FromYannis($TaxId,FULLOS) $OsDuFichier set Fichier [OrganismFromYannis $TaxId Filename] set Queue [file tail $Fichier] set LeTFACourant {} set LesLignes [LesLignesDuFichier $Fichier] lappend LesLignes ">CESTFINIPOURCEFICHIER" set OsDansFichier "" set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout if {[info exists Courant]} { unset Courant } foreach Ligne $LesLignes { if {$Testons && [incr MaxiPourTestons -1]==0} { break } regsub -all " +" $Ligne " " Ligne set Ligne [string trim $Ligne] if {$Ligne==""} { continue } #rR dans sequence if { ! [regexp "^>" $Ligne]} { if {[regexp -nocase {[^A-Z]} $Ligne]} { if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] } if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} { #rR la, il y a meme autre chose lappend FromYannis(LISTOF,BAD) "$Queue $Courant $Ligne" FaireLire "Dans $Queue $Courant \n$Ligne" set OnGarde 0 continue } if {[regexp -nocase {\*} $Ligne Match]} { #FaireLire "Dans $Queue $Courant \n$Ligne" lappend FromYannis(LISTOF,OSWHITHSTAR) $Queue lappend FromYannis($TaxId,STAR) $Courant set OnGarde 0 continue } } if {$Ligne!=""} { set OnGarde 1 lappend LeTFACourant $Ligne } continue } #rR on a un chevron #rR on traite d'abord le précédent if {[info exists Courant]} { if {$OnGarde} { set ID [string toupper $Id] set COURANT [string toupper $Courant] set FromYannis($COURANT,TFA) [join $LeTFACourant "\n"] set MemoTaxId $MemoTaxIdDuCourant($COURANT) set FromYannis($ID,ID) $Id set FromYannis($ID,AC) $Ac lappend FromYannis(LISTOF,IDS) $Id lappend FromYannis(LISTOF,ACS) $Ac lappend FromYannis($MemoTaxId,IDS) $Id lappend FromYannis($MemoTaxId,ACS) $Ac set FromYannis($ID,TAXID) $MemoTaxId } } if {$Ligne==">CESTFINIPOURCEFICHIER"} { break } #rR on traite l'entête if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} { FaireLire "pas bon $Ligne" lappend LeNew $Ligne continue } set TexteBanque "" if {[regexp {\|} $Ligne]} { regexp {^>([^ ]+) (.+)} $Ligne Match AI D set Banque "" set Ac "" set Id "" lassign [split $AI "|"] Banque Ac Id if {$Ac==""} { set Ac $AI } if {$Id==""} { set Id $Ac } regsub {OS=.*} $D "" D regsub {GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } if {$Banque!=""} { set TexteBanque " BANK=$Banque" } } else { regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D regsub {OS=.*} $D "" D regsub {GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] if {[regexp "_" $Ac] && ! [regexp "_" $Id]} { set W $Id set Id $Ac set Ac $W } #rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id } if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac } } set Gn "" regexp {GN=([^ ]+)} $Ligne Match Gn set TextGn "" if {$Gn!=""} { set TextGn " GN=$Gn" } regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN set FullOs "Unknown unknown" set OsDansEntete "" if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} { regsub -all " " $FullOs "_" FullOs regsub -all "/" $FullOs "and" FullOs set OsDansEntete $FullOs } lassign [split $FullOs "_"] G E set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque" set LeTFACourant [list $Entete] if {$OsDansEntete==""} { set OsDansFichier $FullOs } if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} { set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier" if {0 && ! [info exists MessageLu($Message)]} { FaireLire "$Message" set MessageLu($Message) 1 } } set Courant $Id set COURANT [string toupper $Courant] set MemoTaxIdDuCourant($COURANT) $TaxId set ID [string toupper $Id] set AC [string toupper $Ac] if {$ID!=$AC} { set FromYannis($AC,ID) $ID } set FromYannis($ID,FULLOS) $FullOs set FULLOS [string toupper $FullOs] set FromYannis($FULLOS,TAXID) $TaxId } set FromYannis([string toupper $OsDuFichier],TAXID) $TaxId } set FromYannis(LISTOF,STAR) {} set FromYannis(LISTOF,COUNTSTAR) {} foreach TaxId $LesTaxId { if { ! [info exists FromYannis($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } set FullOs $FromYannis($TaxId,FULLOS) lappend FromYannis(LISTOF,TAXIDOS) "${TaxId}_$FullOs" set nOK [llength $FromYannis($TaxId,IDS)] lappend FromYannis(LISTOF,COUNT) "$nOK $TaxId $FullOs" if {[info exists FromYannis($TaxId,STAR)]} { set nKO [llength $FromYannis($TaxId,STAR)] lappend FromYannis(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs" } } set FromYannis(LISTOF,TAXIDOS) [join $FromYannis(LISTOF,TAXIDOS) "\n"] set FromYannis(LISTOF,FULLOS) [join $FromYannis(LISTOF,FULLOS) "\n"] set FromYannis(LISTOF,COUNT) [join $FromYannis(LISTOF,COUNT) "\n"] set FromYannis(LISTOF,STAR) [join $FromYannis(LISTOF,STAR) "\n"] set FromYannis(LISTOF,COUNTSTAR) [join $FromYannis(LISTOF,COUNTSTAR) "\n"] return [FromYannis $Qui $Quoi] } proc FstartFstop {Info aFstart aFstop} { upvar $aFstart Fstart upvar $aFstop Fstop # set LesChamps [split $Info "/"] # set FF [lindex $LesChamps 1] set FF [lindex [split $Info "/"] 1] # regsub {\-} $FF " " FF # scan $FF "%d %d" Fstart Fstop lassign [split $FF -] Fstart Fstop return $FF } proc FstartFstop2 {Info} { set FF [lindex [split $Info "/"] 1] lassign [split $FF -] Fstart Fstop return [list $Fstart $Fstop] } proc FusioFile {} { # Ajoute le contenu d'un fichier é un autre de meme taille (ajoute la séquence aux localisations) set FichierDes230000 [open "/tmp/Conservation/MappingTotalNV3.txt" "r"] set FichierDesRallonges [open "/tmp/Conservation/SequencesDes230000rallongeesDe7Upstream.txt" "r"] set FichierDes230000enrichi "/tmp/Conservation/PourPhilippe.txt" set PathOut $FichierDes230000enrichi if { [file exists $FichierDes230000enrichi] } { file delete $FichierDes230000enrichi } while { [gets $FichierDesRallonges LigneRallongee] >=0 } { ScanLaListe $LigneRallongee ID SequenceRallongee gets $FichierDes230000 Ligne AppendAuFichier $FichierDes230000enrichi " $SequenceRallongee $Ligne" } Espionne "Execution terminee. Le fichier a été écrit dans $PathOut" } proc FusioLignes {Chromosome} { while { [gets $FichierEntree1 Ligne1] >=0 } { set MM1 " " set MM2 " " ScanLaListe $Ligne1 ChroX DRX IDX StartX EndX BrinX SequenceX ScoreX NbMismatchsX MM1 MM2 gets $FichierEntree2 Ligne2 ScanLaListe $Ligne2 ID Chro Start Fin AccessG1 StartG1 FinG1 Brin1 DTSS1 Exon1 UTR1 ExonStart ExonFin BorneProche DEXON AccessG2 StartG2 EndG2 BrinG2 DTSS2 Avis1 AccessG3 StartG3 EndG3 BrinG3 DTSS3 Avis2 puts $FichierSortie "$ChroX $DRX $IDX $StartX $EndX $BrinX $SequenceX $AccessG1 $StartG1 $FinG1 $Brin1 $DTSS1 $Exon1 $UTR1 $ExonStart $ExonFin $BorneProche $DEXON $AccessG2 $StartG2 $EndG2 $BrinG2 $DTSS2 $Avis1 $AccessG3 $StartG3 $EndG3 $BrinG3 $DTSS3 $Avis2 $ScoreX $NbMismatchsX $MM1@$MM2" puts $FichierSortie "$ChroX $DRX $IDX $StartX $EndX $BrinX $SequenceX $AccessG1 $StartG1 $FinG1 $Brin1 $DTSS1 $Exon1 $UTR1 $ExonStart $ExonFin $BorneProche $DEXON $AccessG2 $StartG2 $EndG2 $BrinG2 $DTSS2 $Avis1 $AccessG3 $StartG3 $EndG3 $BrinG3 $DTSS3 $Avis2 $ScoreX $NbMismatchsX $MM1@$MM2" } close $FichierEntree1 close $FichierEntree2 close $FichierSortie } proc FusioMismatchs {} { set FichierIn [open "/tmp/VDR/VDR.coord" "r"] set FichierOut [open "/tmp/VDR/VDR.coo" "w"] while { [gets $FichierIn Ligne] >= 0 } { set MM1 "" set MM2 "" ScanLaListe $Ligne Chromosome DR ID Start End Strand Sequence Score NbMM MM1 MM2 set MM "M" if { $MM1 != ""} { set MM "$MM@$MM1" } if { $MM2 != ""} { set MM "$MM@$MM2" } set LigneOut "$DR $ID $Chromosome $Start $End $Strand $Sequence $Score $NbMM $MM" puts $FichierOut $LigneOut } close $FichierIn close $FichierOut } proc Fusion {Nom} { return [ExtraitInfo $Nom "Fusion"] } proc Fusion5P {{Qui ""} {Quoi ""}} { global Fusion5P if {$Qui==""} { set Qui "LaListeDes" set Quoi "Fusions" } if {$Quoi==""} { set Quoi "Description" } if {$Quoi=="Sequence"} { set Fichier [Fusion5P $Qui "Fichier"] if {$Fichier==""} { return "" } return [QueLaSequenceDuFichierTFA $Fichier] } if {[info exists Fusion5P($Qui,$Quoi)]} { return [set Fusion5P($Qui,$Quoi)] } if {[info exists Fusion5P("EstCharge")]} { return [set Fusion5P("EstCharge")] } set FichierFusion5P "[RepertoireDuGenome]/fiches/fusion" set Fusion5P("EstCharge") "" if {[file exists $FichierFusion5P]} { array set Fusion5P [LesLignesDuFichier $FichierFusion5P] return [Fusion5P $Qui $Quoi] } set Fusion5P(LaListeDes,Fichiers) {} set Fusion5P(LaListeDes,Fusions) {} foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/fusion/*"] { set Queue [file tail $Fichier] set Entete [EnteteDuFichierTFA $Fichier] if {$Entete==""} { continue } set Fus [EnteteDuFichierTFA $Fichier "access"] regsub "Fus_" $Fus "" R2 set Fusion5P($Fus,Rec2) $R2 lappend Fusion5P(LaListeDes,Fichiers) $Fichier lappend Fusion5P(LaListeDes,Fusions) $Fus } set Fusion5P(LaListeDes,Fichiers) [lsort [set Fusion5P(LaListeDes,Fichiers)]] set Fusion5P(LaListeDes,Fusions) [lsort [set Fusion5P(LaListeDes,Fusions)]] SauveLesLignes [array get Fusion5P] dans $FichierFusion5P return [Fusion5P $Qui $Quoi] } proc FusionMM {Path} { # Détecte les fichiers avec deux MM et un blanc entre les deux et les recolle (bidouille) set FichierEntree [open "$Path.pro" "r"] set FichierSortie [open "$Path.pro" "w"] gets $FichierEntree Ligne set Reste1 "" set Reste2 "" set Reste3 "" while { [gets $FichierEntree Ligne] >=0 } { ScanLaListe $Ligne Acc Deb Fin Orientation Distance ExonOutron UtrOuCDS DebutExonOutron FinExonOuIntron DebutOuFinExonOuIntron DistanceAlaBorneDeExonOuIntron ChromosomeQuery DRQuery IdQuery StartQuery EndQuery OrientationQuery SequenceQuery ScoreQuery NbMismatchQuery MM1 MM2 Reste1 Reste2 Reste3 if { $NbMismatchQuery > 0} { set MM1 "M@$MM1@$MM2" set MM2 "" } else { set MM1 "M@" set MM2 "" } puts $FichierSortie "$Acc $Deb $Fin $Orientation $Distance $ExonOutron $UtrOuCDS $DebutExonOutron $FinExonOuIntron $DebutOuFinExonOuIntron $DistanceAlaBorneDeExonOuIntron $ChromosomeQuery $DRQuery $IdQuery $StartQuery $EndQuery $OrientationQuery $SequenceQuery $ScoreQuery $NbMismatchQuery $MM1 $MM2 $Reste1 $Reste2 $Reste3 " } } proc FusionMMdansDRx {Path} { Espionne "FusionMMdansDRx: Start" set FichierEntree [open "$Path.coo" "r"] set FichierSortie [open "$Path.coord" "w"] while { [gets $FichierEntree Ligne] >=0 } { regsub -all -nocase {\sS} $Ligne "@" LigneOut puts $FichierSortie $LigneOut } Espionne "FusionMMdansDRx: End" } proc FusionneLesBornes {} { global RepertoireDuGenome set Ancien "$RepertoireDuGenome/fiches/bornesdespabs" set Apport "$RepertoireDuGenome/fiches/bornesdespabsarajouter" foreach Ligne [LesLignesDuFichier $Apport] { scan $Ligne "%s" A set NouvelleLigne($A) $Ligne } foreach Ligne [LesLignesDuFichier $Ancien] { scan $Ligne "%s" A if {[info exists NouvelleLigne($A)]} { lappend Sortie [set NouvelleLigne($A)] } else { lappend Sortie $Ligne } } set SortieTriee [lsort -command CompareLesMilieux $Sortie] puts [join $SortieTriee "\n"] } proc FusionneLesGenscan {LeGscA LeGscB TailleTroncon} { set Offset $TailleTroncon set Coupure [DernierPointDeCoupure $LeGscA $LeGscB $TailleTroncon] Espionne $Coupure if {$Coupure==-1} { set A [lindex $LeGscA 0] set B [lindex $LeGscB 0] FaireLire "I cannot merge these two GenScan outputs\n $A \ $B" return "" } set OldP "" foreach Ligne $LeGscA { if {[regexp "^Sequence" $Ligne]} { scan $Ligne "%s %s" S Access set Ligne "$S $Access Genscan outputs from overlapping contigs merged by Gscope after $Coupure" lappend Sortie $Ligne continue } if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} { lappend Sortie $Ligne continue } scan $Ligne "%s %s %s %d %d" PE Type Sens D F if {$D >= $Coupure} { break } scan [split $PE "."] "%d %d" P E if {$OldP!=$P} { lappend LesPremiersPs $P } set OldP $P set DernierP $P lappend Sortie $Ligne } set OnAttend 1 set NouveauP $DernierP set OldP "" foreach Ligne $LeGscB { if { $OnAttend && ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} { continue } if {[regexp "Predicted peptide" $Ligne]} { lappend Sortie $Ligne lappend Sortie " " break } if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} { lappend Sortie $Ligne continue } scan $Ligne "%s %s %s %d %d" PE Type Sens D F set NouveauD [expr $D + $Offset] set NouveauF [expr $F + $Offset] if {$NouveauD<$Coupure} { continue } set OnAttend 0 scan [split $PE "."] "%d %d" P E if {$P!=$OldP} { incr NouveauP lappend LesSecondsPs $P lappend LesNouveauxPs $NouveauP } regsub $P $Ligne $NouveauP Ligne set OldP $P regsub " $D " $Ligne " $NouveauD " Ligne regsub " $F " $Ligne " $NouveauF " Ligne lappend Sortie $Ligne } DecortiqueGenScan All All Numbers [join $LeGscA "\n"] foreach P $LesPremiersPs { set Texte [DecortiqueGenScan $P All "TFAo"] lappend Sortie $Texte lappend Sortie " " } DecortiqueGenScan All All Numbers [join $LeGscB "\n"] foreach P $LesSecondsPs N $LesNouveauxPs { set Texte [DecortiqueGenScan $P All "TFAo"] regsub "predicted_peptide_$P" $Texte "predicted_peptide_$N" Texte lappend Sortie $Texte lappend Sortie " " } return $Sortie } proc FusionneLesRepEnUnSeul_PO {RepIni RepFin FileO2C2A2D2E FileCorrespondances} { ### A servi a mettre ttes les DDseq (et les fichiers du masking) des differents repertoires indexes pas date dans un seul repertoire ### ### Fusionne ts les fichiers contenus dans le RepIni dans le RepFin ### ### Stocke ttes les infos concernant les DDseq dans le FileCorrespondance ### # Lit le fichier O2C2A2D2E, stocke les correspondances entre BOXGscope, BOXProject, BOXIniSeq et les infos correspondantes # set F [open $FileO2C2A2D2E] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set LaDef [split [lindex $LaLigne 3] " "] set BOXGscope [lindex $LaDef 0] set BOXProject [lindex $LaDef 1] set BOXIniSeq [lindex $LaDef 2] if {[info exists Tab($BOXProject,BOXGscope)]} {Espionne "Gros PBL avec $Ligne";exit} set Tab($BOXProject,BOXGscope) $BOXGscope set Tab($BOXProject,BOXIniSeq) $BOXIniSeq set Tab($BOXProject,LesInfos) $LaLigne } close $F # Ds le repertoire ini, considere tous les repertoires commencant par 20 # # Creation du fichier de correspondances avec ttes les infos dispo sur chaque DDseq # set LeTexte {} set NbSeq 0 set NbSeqI 0 foreach Rep [glob -nocomplain "$RepIni/20*"] { set NameRep [file tail $Rep] set Date "" regexp {^([0-9]+)} $NameRep tmp Date Espionne "DIRECTORY $NameRep $Date" foreach TypeFichier [list "ICBP_D" "ICBP_U" "TOPO_D" "TOPO_U"] { foreach File [glob -nocomplain "$Rep/$TypeFichier*"] { set NameFile [file tail $File] set n "ERREUR" regexp {_[DU]{1}([0-9]+)} $NameFile tmp n if {$n == "ERREUR"} { Espionne "GROS PBL avec $File" exit } set BOXProject "$TypeFichier$n" if {[regexp {\.tfa\.masking\.infos$} $File]} { # determination des infos du masking # set VRG [join [LesInfosDuVRGMasking $File] "\t"] incr NbSeqI # definition de ttes les infos concernant les DDseq # set BOXGscope [set Tab($BOXProject,BOXGscope)] set BOXIniSeq [set Tab($BOXProject,BOXIniSeq)] set LesInfosDeOCADE [set Tab($BOXProject,LesInfos)] set Cluster [lindex $LesInfosDeOCADE 1 ] set Def [lindex $LesInfosDeOCADE 3 ] set Expr [join [lrange $LesInfosDeOCADE 4 end] "\t"] set Ligne "$BOXGscope\t$BOXProject\t$BOXIniSeq\tHomo sapiens\t$Date\t$Cluster\t$Def\t$VRG\t$Expr" Espionne $Ligne lappend LeTexte $Ligne } if {[regexp {\.tfa$} $File]} {incr NbSeq} File copy -force $File "$RepFin/$NameFile" } } } Sauve [join $LeTexte "\n"] dans $FileCorrespondances Espionne $NbSeq Espionne $NbSeqI return } proc FusionneLesResultatsDeAffy_TL {FileOut FileIdAffy RepIdProtAffy ExtensionIdProtAffy} { set i 0 set iProt 0 foreach File [lsort -unique [glob -nocomplain -directory $RepIdProtAffy "*.$ExtensionIdProtAffy"]] { Espionne $File set F [open $File] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {![regexp {^[0-9]+} $Ligne]} {continue} set LaLigne [split $Ligne "\t"] set Id [lindex $LaLigne 0] if {[info exists TabDejaVu($Id)]} {continue} set TabDejaVu($Id) 1 incr i set Prots [lindex $LaLigne 1] if {$Prots == "---"} {continue} regsub -all " /// " $Prots " " Prots set LesProts [split $Prots " "] set Tab($Id) $LesProts incr iProt } close $F } Espionne $i Espionne $iProt set LeTexte {} set F [open $FileIdAffy] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set Id $Ligne if {![info exists Tab($Id)]} { lappend LeTexte "$Id" } else { set Prots [join [set Tab($Id)] "\t"] lappend LeTexte "$Id\t$Prots" } } close $F EspionneL $LeTexte Sauve [join $LeTexte "\n"] dans $FileOut return } 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 FusionneMutationMTMPourTous {} { foreach Type [MutationMTM ListOf Possible Type] { FusionneMutationMTM $Type } } proc FusionnerLesCSV {Tail} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|FusionnerLesCSV: Start" set nbLignesOut 0 set FichierEntete [open "chrY$Tail.csv" "r"] set FichierSortie [open "Total$Tail.csv" "w"] gets $FichierEntete Entete puts $FichierSortie $Entete incr nbLignesOut close $FichierEntete foreach I {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 "X" "Y"} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|FusionnerLesCsv: Adding chr$I data" set FichierCsv [open "chr$I$Tail.csv" "r"] gets $FichierCsv Entete while { [gets $FichierCsv Ligne] >=0 } { incr nbLignesOut puts $FichierSortie $Ligne } close $FichierCsv } close $FichierSortie set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|FusionnerLesCSV: End ($nbLignesOut written)" } proc FusionnerSelonMM2 {} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "FusionnerSelonMM2 : Start" foreach J {0 1 2 3 4 5 6} { foreach I {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y} { set Fichier1MM [open "/genomics/link/RGKTSA/Coordonnees/unperfect/chr$I-$J-repeatless-1MM.coord" "r"] set Fichier2MM [open "/genomics/link/RGKTSA/Coordonnees/unperfect/chr$I-$J-repeatless-2MM.coord" "r"] set FichierOut [open "/genomics/link/RGKTSA/Coordonnees/unperfect/chr$I-$J-repeatless-unperfect.coord" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "FusionnerSelonMM2 : DR$J / Chromosome $I => Ajout des MM1" while { [gets $Fichier1MM Ligne1] >=0 } { puts $FichierOut $Ligne1 } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "FusionnerSelonMM2 : DR$J / Chromosome $I => Ajout des MM2" while { [gets $Fichier2MM Ligne2] >=0 } { puts $FichierOut $Ligne2 } close $Fichier1MM close $Fichier2MM close $FichierOut file delete "/genomics/link/RGKTSA/Coordonnees/unperfect/chr$I-$J-repeatless-1MM.coord" file delete "/genomics/link/RGKTSA/Coordonnees/unperfect/chr$I-$J-repeatless-2MM.coord" } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "FusionnerSelonMM2 : End" } proc GAR {} { global db GR LoadTkAndPackages ChangeTkOptions option add *Label.background black option add *Label.foreground white set GR(Lcm) [linsert $GR(Lcm) 0 "All"] set GR(Lgap) [linsert $GR(Lgap) 0 "All"] font create GRFont -family Helvetica -size 22 -weight bold ttk::style configure Combobox -font GRFont ttk::style configure TLabel -font GRFont ttk::style configure TButton -font GRFont set w .gar frame $w -bg black grid $w -row 0 -column 0 -sticky news grid columnconfig . all -weight 1 grid rowconfig . all -weight 1 frame $w.fchx -bg black grid $w.fchx -row 0 -column 0 -sticky ew label $w.fchx.lcm -font GARFont -text "Clus. Meth." -anchor w -justify right set GR(cm) [lindex $GR(Lcm) 0] ttk::combobox $w.fchx.ccm -state readonly -values $GR(Lcm) -textvariable GR(cm) label $w.fchx.lgp -font GARFont -text "Gap Thr." -anchor w -justify right set GR(gap) [lindex $GR(Lgap) 0] ttk::combobox $w.fchx.cgp -state readonly -values $GR(Lgap) -textvariable GR(gap) label $w.fchx.llm -font GARFont -text "Limits" -anchor w -justify right set GR(lim) [lindex $GR(Llim) 0] ttk::combobox $w.fchx.clm -state readonly -values $GR(Llim) -textvariable GR(lim) grid $w.fchx.lcm -row 0 -column 0 -sticky w grid $w.fchx.ccm -row 0 -column 1 -sticky ew grid $w.fchx.lgp -row 0 -column 2 -sticky w grid $w.fchx.cgp -row 0 -column 3 -sticky ew grid $w.fchx.llm -row 0 -column 4 -sticky w grid $w.fchx.clm -row 0 -column 5 -sticky ew frame $w.fbou -bg black grid $w.fbou -row 1 -column 0 -sticky ew button $w.fbou.brun -font GARFont -bg green1 -text "\nRUN\n" -command {TrieBCMRes cree} button $w.fbou.bsns -font GARFont -bg cyan -text "Sensibility" -command {TrieBCMRes sens} button $w.fbou.bspc -font GARFont -bg cyan -text "Specifity" -command {TrieBCMRes spec} button $w.fbou.bpwr -font GARFont -bg cyan -text "Power" -command {TrieBCMRes power} label $w.fbou.lbi -font "Courier 12 bold" -bg black -fg white -textvariable GR(LabelInfo) -justify left -anchor w grid $w.fbou.brun -row 0 -column 0 -sticky w -padx {10 50} grid $w.fbou.bsns -row 0 -column 1 -sticky w grid $w.fbou.bspc -row 0 -column 2 -sticky w grid $w.fbou.bpwr -row 0 -column 3 -sticky w grid $w.fbou.lbi -row 1 -column 0 -columnspan 4 -sticky ew set GR(text) $w.txt text $w.txt -font "Courier 12 bold" -bg black -fg white grid $w.txt -row 3 -column 0 -sticky news grid columnconfigure $w all -weight 1 grid rowconfigure $w 3 -weight 1 return } proc GCContent {Nom} { return [CompositionEn GC $Nom] } proc GCGtoTFA {TexteGCG {Entete ""}} { return [SequenceFormatTFA $Texte "Entete" "gcg"] } proc GCGtoTFAPourToutLeRepertoire {} { foreach F [glob "*.nuc"] { set Nom [file tail $F] regsub {\.nuc} $Nom "" Nom set TFA [SequenceFormatTFA [ContenuDuFichier $F] "$Nom Cloning vector $Nom" "gcg"] Espionne [Sauve $TFA dans "$Nom.tfa"] } exit } proc GCLevel {Nom} { set GC [CompositionEn GC $Nom] return [QuelInterval $GC [LesSeuilsGC] [LesSeuilsGC "SignificationMerci"]] } proc GCPanel {LeCanvasPere} { Wup "Panel de choix d affichage et de couleur du graphes du meilleur GC" set LesTmpGraphes [LesGraphesDeLOligo $LeCanvasPere] if {$LesTmpGraphes==""} {return ""} set GrapheTopLevel "$LeCanvasPere.bestgcgraphe" if {[winfo exists $GrapheTopLevel]} { wm deiconify $GrapheTopLevel raise $GrapheTopLevel return "" } else {toplevel $GrapheTopLevel} wm geometry $GrapheTopLevel +300+100 wm title $GrapheTopLevel "Best GC Selection" wm resizable $GrapheTopLevel false false set FrameGraphe "$GrapheTopLevel.bestgcframe" frame $FrameGraphe -borderwidth "3" -relief "groove" pack $FrameGraphe -expand "true" -side "top" -fill "both" set NbGraph [llength $LesTmpGraphes] set NbRow 0 set IndGraph 0 set LesGraphes "" foreach G $LesTmpGraphes { if {$G=="GC"} { set LesGraphes [linsert $LesGraphes 0 $G] continue } lappend LesGraphes $G } foreach Graphe $LesGraphes { incr IndGraph incr NbRow set TagOrId $Graphe set Graphe [string tolower $Graphe] set PetiteFrameGraphe "$FrameGraphe.f$Graphe" set LGraph "$PetiteFrameGraphe.l$Graphe" set BGrOn "$PetiteFrameGraphe.bgon$Graphe" set BGrOff "$PetiteFrameGraphe.bgoff$Graphe" set BMoyOn "$PetiteFrameGraphe.bmoyon$Graphe" set BMoyOff "$PetiteFrameGraphe.bmoyoff$Graphe" set BColor1 "$PetiteFrameGraphe.bcolor1$Graphe" set BColor2 "$PetiteFrameGraphe.bcolor2$Graphe" frame $PetiteFrameGraphe -borderwidth "0" -relief "groove" label $LGraph -text "$TagOrId" -padx "2" -borderwidth "3" -relief "groove" -background "orange" button $BGrOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere ${TagOrId}Lines" button $BGrOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere ${TagOrId}Lines" button $BMoyOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere ${TagOrId}Plot" button $BMoyOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere ${TagOrId}Plot" button $BColor1 -text "Color" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -background deepskyblue2 -command "LePanneauDeCouleursDuGraph $BColor1 $LeCanvasPere ${TagOrId}Lines" button $BColor2 -text "Color" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -background deepskyblue2 -command "LePanneauDeCouleursDuGraph $BColor1 $LeCanvasPere ${TagOrId}Plot" grid $PetiteFrameGraphe -sticky ewns grid $LGraph -row $NbRow -column 0 -sticky ewns -rowspan 2 grid $BGrOn -row $NbRow -column 1 -sticky ewns grid $BGrOff -row $NbRow -column 2 -sticky ewns grid $BMoyOn -row $NbRow -column 3 -sticky ewns grid $BMoyOff -row $NbRow -column 4 -sticky ewns incr NbRow grid $BColor1 -row $NbRow -column 1 -sticky ewns -columnspan 2 grid $BColor2 -row $NbRow -column 3 -sticky ewns -columnspan 2 if {$IndGraph==1} { set DismissB "$PetiteFrameGraphe.destroybutton" set LDuGraph "$PetiteFrameGraphe.ldugraph" set LDuMoyenne "$PetiteFrameGraphe.ldumoyenne" button $DismissB -text "Exit" -anchor "center" -padx "3" -background "red" -borderwidth "2" -relief groove -activebackground "red" -overrelief "sunken" -command "destroy $GrapheTopLevel" label $LDuGraph -text "Lines" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief groove label $LDuMoyenne -text "Plot" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief groove grid $DismissB -row 0 -column 0 -sticky ewns grid $LDuGraph -row 0 -column 1 -sticky ewns -columnspan 2 grid $LDuMoyenne -row 0 -column 3 -sticky ewns -columnspan 2 } if {$IndGraph==$NbGraph} { set LAllDuGr "$PetiteFrameGraphe.lalldugraph" set BAllGrOn "$PetiteFrameGraphe.ballgon" set BAllGrOff "$PetiteFrameGraphe.ballgoff" label $LAllDuGr -text "Both" -anchor "center" -padx "2" -relief "groove" -background "green3" -borderwidth "3" button $BAllGrOn -text "On" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Raiser $LeCanvasPere OligoGraph" button $BAllGrOff -text "Off" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Lower $LeCanvasPere OligoGraph" incr NbRow grid $LAllDuGr -row $NbRow -column 0 -sticky ewns grid $BAllGrOn -row $NbRow -column 1 -sticky ewns -columnspan 2 grid $BAllGrOff -row $NbRow -column 3 -sticky ewns -columnspan 2 } grid columnconfigure $PetiteFrameGraphe 0 -weight 1 grid columnconfigure $PetiteFrameGraphe 1 -weight 0 grid columnconfigure $PetiteFrameGraphe 2 -weight 0 grid columnconfigure $PetiteFrameGraphe 3 -weight 0 grid columnconfigure $PetiteFrameGraphe 4 -weight 0 } return "" } proc GCrna {} { LitLeTFA 250ori_rna.tfa Lor Sor set fmt "%-20s %6.2f %6.2f %6.2f %6.2f" puts "Protein Name A C G T " foreach n $::LNOrdali { if {$n ne ""} {lappend LNO $n} } foreach l [LesLignesDuFichier 250ori.corr] { lassign [split $l "\t"] gi prot nuc lappend Lcor [list $gi $prot $nuc] } foreach n $Lor o $LNO { set i [lsearch -index 2 $Lcor $n] lassign [lindex $Lcor $i] gi prot nuc lassign [ContenuEnGC [set Sor($n)]] a c g t if {[set phy [set ::TDesPhylum($o)]] eq ""} { set phy "unknown" } set org [set ::TDesOrganismes($o)] set Lorg [split $org " "] if {[string index [lindex $Lorg 1] 0] ne "("} { set org [join [lrange $Lorg 0 1] " "] } lappend Lrst [list $gi $phy $org $o $n $a $c $g $t] } foreach e [lsort -index 7 -real -decreasing $Lrst] { lassign $e gi phy org o n a c g t puts "$gi ($phy) $org | $o" puts [format $fmt $n $a $c $g $t] } exit } proc GIDeBanqueIdAccess {BanqueId Access} { set Version [PageInfo $BanqueId genbankfull gid] if {$Version == ""} { set Version [PageInfo $Access genbankfull gid] } set GI "" regexp " GI:(\[0-9]*)" $Version tmp GI return $GI } proc GIDeLAccess {BIdOuAccess} { set Version [PageInfo $BIdOuAccess genbankfull gid] if {$Version == ""} { set Version [PageInfo $BIdOuAccess genbankfull gid] } set GI "" regexp " GI:(\[0-9]*)" $Version tmp GI return $GI } proc GNdeAful {Nom} { if {[scan [lindex [DonneesAful [NomDuMeilleurAful $Nom]] 0] "%s %s %s %s" AF RoFa Orga GN] == 4 } { return $GN } else { return "zzzz" } } proc GNduMarque {Marque} { set tid [lindex [split $Marque :] 0] set tc [lindex [split $Marque :] 1] return [lindex [split [$tc itemcget [expr $tid +1] -text ] "\n"] 0] } proc GOAnalyse {AccessQuery FichierMSF FichierClust FichierOUT {NomQuery QUERY_PROTEIN} {IdMin 0.98} {NorMDMin 0.3} {PMin 0.8} {FMin 0.5}} { Espionne "GO -> IPO" set LesGOIPO [IPO $AccessQuery ] Espionne "GO -> PPO" set LesGOPPO [PPO $FichierMSF $NomQuery $IdMin ] Espionne "GO -> MSO" set LesGOMSO [MSO $FichierClust $FichierMSF $NomQuery $NorMDMin $PMin $FMin] Espionne "GO -> GPO" set LesTypes [GODB LesTypes] set TabGO(IPO,LesGO) {} set TabGO(PPO,LesGO) {} set TabGO(MSO,LesGO) {} foreach Type $LesTypes { set TabGO(IPO,Type,$Type,LesGO) {} set TabGO(PPO,Type,$Type,LesGO) {} set TabGO(MSO,Type,$Type,LesGO) {} set TabGO(GPO,Type,$Type,LesGO) {} } #########IPO IPO IPO############# foreach LeGO $LesGOIPO { set GO [lindex $LeGO 0] set Type [lindex $LeGO 1] set Def [lindex $LeGO 2] regsub -all -nocase {[^0-9a-z\.\-_\:]} $Def " " Def if {![info exists TabGO(IPO,Type,$Type,GO,$GO,nAccess)]} { set TabGO(IPO,Type,$Type,GO,$GO,nAccess) 1 set TabGO(IPO,Type,$Type,GO,$GO,LesAccess) {} lappend TabGO(IPO,Type,$Type,LesGO) $GO lappend TabGO(IPO,LesGO) $GO } if {![info exists TabGO(Type,$Type,GO,$GO,Definition)]} { set TabGO(Type,$Type,GO,$GO,Definition) $Def } lappend TabGO(IPO,Type,$Type,GO,$GO,LesAccess) $AccessQuery } #########PPO PPO PPO############# foreach LeGO $LesGOPPO { set GO [lindex $LeGO 0] set Type [lindex $LeGO 1] set Def [lindex $LeGO 2] regsub -all -nocase {[^0-9a-z\.\-_\:]} $Def " " Def set nAcc [lindex $LeGO 3] set LesAcc [lindex $LeGO 4] if {![info exists TabGO(PPO,Type,$Type,GO,$GO,nAccess)]} { set TabGO(PPO,Type,$Type,GO,$GO,nAccess) $nAcc set TabGO(PPO,Type,$Type,GO,$GO,LesAccess) {} lappend TabGO(PPO,Type,$Type,LesGO) $GO lappend TabGO(PPO,LesGO) $GO } if {![info exists TabGO(Type,$Type,GO,$GO,Definition)]} { set TabGO(Type,$Type,GO,$GO,Definition) $Def } foreach Acc $LesAcc {lappend TabGO(PPO,Type,$Type,GO,$GO,LesAccess) $Acc} } #########MSO MSO MSO############# foreach LeGO $LesGOMSO { set GO [lindex $LeGO 0] set Type [lindex $LeGO 1] set Def [lindex $LeGO 2] regsub -all -nocase {[^0-9a-z\.\-_\:]} $Def " " Def set nAcc [lindex $LeGO 3] set LesAcc [lindex $LeGO 4] if {![info exists TabGO(MSO,Type,$Type,GO,$GO,nAccess)]} { set TabGO(MSO,Type,$Type,GO,$GO,nAccess) $nAcc set TabGO(MSO,Type,$Type,GO,$GO,LesAccess) {} lappend TabGO(MSO,Type,$Type,LesGO) $GO lappend TabGO(MSO,LesGO) $GO } if {![info exists TabGO(Type,$Type,GO,$GO,Definition)]} { set TabGO(Type,$Type,GO,$GO,Definition) $Def } foreach Acc $LesAcc {lappend TabGO(MSO,Type,$Type,GO,$GO,LesAccess) $Acc} } #########GPO GPO GPO############# foreach LeGO [GPO [set TabGO(IPO,LesGO)] [set TabGO(PPO,LesGO)] [set TabGO(MSO,LesGO)]] { set GO [lindex $LeGO 0] set Type [lindex $LeGO 1] set Def [lindex $LeGO 2] regsub -all -nocase {[^0-9a-z\.\-_\:]} $Def " " Def if {![info exists TabGO(GPO,Type,$Type,GO,$GO,nAccess)]} { set TabGO(GPO,Type,$Type,GO,$GO,nAccess) 0 set TabGO(GPO,Type,$Type,GO,$GO,LesAccess) {} lappend TabGO(GPO,Type,$Type,LesGO) $GO } if {![info exists TabGO(Type,$Type,GO,$GO,Definition)]} { set TabGO(Type,$Type,GO,$GO,Definition) $Def } } #######Fichier XML####################### set LeTexte {} lappend LeTexte "" ###DTD interne ########################### lappend LeTexte "" lappend LeTexte "\t" lappend LeTexte "\t\t" lappend LeTexte "\t\t" lappend LeTexte "\t\t\t" lappend LeTexte "\t\t\t" lappend LeTexte "\t\t" set Types [join $LesTypes ", "] lappend LeTexte "\t\t\t" lappend LeTexte "\t\t\t" lappend LeTexte "\t\t\t" lappend LeTexte "\t\t\t" foreach Type $LesTypes { lappend LeTexte "\t\t\t\t" lappend LeTexte "\t\t\t\t\t" lappend LeTexte "\t\t\t\t\t" lappend LeTexte "\t\t\t\t\t\t" } lappend LeTexte "\]>" ###DTD interne ########################### lappend LeTexte "" lappend LeTexte "\t" if {[file exists $FichierMSF ]} {lappend LeTexte "\t\t$FichierMSF" } if {[file exists $FichierClust]} {lappend LeTexte "\t\t$FichierClust"} lappend LeTexte "\t" lappend LeTexte "\t

" lappend LeTexte "\t\t" foreach Type $LesTypes { lappend LeTexte "\t\t\t<$Type>" foreach GO [set TabGO(IPO,Type,$Type,LesGO)] { set NbAccess [set TabGO(IPO,Type,$Type,GO,$GO,nAccess)] set Def [set TabGO(Type,$Type,GO,$GO,Definition) ] lappend LeTexte "\t\t\t\t" foreach Acc [set TabGO(IPO,Type,$Type,GO,$GO,LesAccess)] { lappend LeTexte "\t\t\t\t\t$Acc" } lappend LeTexte "\t\t\t\t" } lappend LeTexte "\t\t\t" } lappend LeTexte "\t\t" lappend LeTexte "\t\t" foreach Type $LesTypes { lappend LeTexte "\t\t\t<$Type>" foreach GO [set TabGO(PPO,Type,$Type,LesGO)] { set NbAccess [set TabGO(PPO,Type,$Type,GO,$GO,nAccess)] set Def [set TabGO(Type,$Type,GO,$GO,Definition) ] lappend LeTexte "\t\t\t\t" foreach Acc [set TabGO(PPO,Type,$Type,GO,$GO,LesAccess)] { lappend LeTexte "\t\t\t\t\t$Acc" } lappend LeTexte "\t\t\t\t" } lappend LeTexte "\t\t\t" } lappend LeTexte "\t\t" lappend LeTexte "\t\t" foreach Type $LesTypes { lappend LeTexte "\t\t\t<$Type>" foreach GO [set TabGO(MSO,Type,$Type,LesGO)] { set NbAccess [set TabGO(MSO,Type,$Type,GO,$GO,nAccess)] set Def [set TabGO(Type,$Type,GO,$GO,Definition) ] lappend LeTexte "\t\t\t\t" foreach Acc [set TabGO(MSO,Type,$Type,GO,$GO,LesAccess)] { lappend LeTexte "\t\t\t\t\t$Acc" } lappend LeTexte "\t\t\t\t" } lappend LeTexte "\t\t\t" } lappend LeTexte "\t\t" lappend LeTexte "\t\t" foreach Type $LesTypes { lappend LeTexte "\t\t\t<$Type>" foreach GO [set TabGO(GPO,Type,$Type,LesGO)] { set NbAccess [set TabGO(GPO,Type,$Type,GO,$GO,nAccess)] set Def [set TabGO(Type,$Type,GO,$GO,Definition) ] lappend LeTexte "\t\t\t\t" foreach Acc [set TabGO(GPO,Type,$Type,GO,$GO,LesAccess)] { lappend LeTexte "\t\t\t\t\t$Acc" } lappend LeTexte "\t\t\t\t" } lappend LeTexte "\t\t\t" } lappend LeTexte "\t\t" lappend LeTexte "\t

" lappend LeTexte "" Sauve [join $LeTexte "\n"] dans $FichierOUT return $FichierOUT } proc GOCommunsEntreClusters {Cl1 Cl2 FichierGO TypeGO} { if {$FichierGO == ""} {return} set LesInfos {} foreach Groupe [InterrogeGeneOntology $FichierGO LesGroupes] { if {$Groupe != $Cl1 && $Groupe != $Cl2} {continue} } foreach Cl [list $Cl1 $Cl2] { set LesGODuCl [InterrogeGeneOntology $FichierGO Groupe $Cl LesGO] foreach GODuCl $LesGODuCl { set Type [InterrogeGeneOntology $FichierGO GO $GODuCl Type] Espionne "$Cl $GODuCl $Type" lappend Tab($Cl,$Type,LesGO) $GODuCl } } set LesTypes [InterrogeGeneOntology $FichierGO LesTypes] Espionne $LesTypes foreach Cl [list Cl1 Cl2] { foreach Type $LesTypes { set LesGO [set Tab($Cl,$Type,LesGO)] lappend LesInfos "$Cl\t$Type\t$LesGO" } } Espionne $LesInfos if {0} { foreach Linfo $LesInfos { set Cluster [lindex $Linfo 0] set LesGO [lindex $Linfo 1 end] foreach GO $LesGO { set LesAncetres [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] } } } return } proc GODB {args} { # OPTIONS de GODB # Load # Exists (...) # set (...) valeur # append (...) valeur # unset (...) # unset # LesTypes # LesGO # Type $Type LesGO # GO $GO LesTypes # Type $Type GO $GO LesSynonymes # Type $Type GOSynonyme $Synonyme GODeRef # Type $Type GO $GO LesNiveaux # Type $Type LesNiveaux # Type $Type Niveau $Niveau LesGO # Type $Type GO $GO LesEC # Type $Type GO $GO LesParents # Type $Type GO $GO LesConstituants # Type $Type GO $GO LesContributions # Type $Type GO $GO LesEnfants # Type $Type GO $GO LesDefinitions # set GONothing "GO:nothing" # Type $Type Nothing # Type $Type GO $GONothing LesSynonymes # Type $Type GO $GONothing LesNiveaux # Type $Type GO $GONothing LesEC # Type $Type GO $GONothing LesParents # Type $Type GO $GONothing LesConstituants # Type $Type GO $GONothing LesContributions # Type $Type GO $GONothing LesEnfants # Type $Type TousLesGO # Type $Type LesNiveaux global TableauArbreGeneOntology set FirstArg [lindex $args 0] if {[string equal -nocase $FirstArg "Exists"]} { if {![info exists TableauArbreGeneOntology]} {return 0} set Quoi [join [lrange $args 1 end] ","] if {$Quoi == ""} {return 0} return [info exists TableauArbreGeneOntology($Quoi)] } if {[string equal -nocase $FirstArg "append"]} { if {![info exists TableauArbreGeneOntology]} {return} set Quoi [join [lrange $args 1 end-1] ","] set Valeur [lindex $args end] if {$Quoi == ""} {return} return [lappend TableauArbreGeneOntology($Quoi) $Valeur] } if {[string equal -nocase $FirstArg "set"]} { if {![info exists TableauArbreGeneOntology]} {return} set Quoi [join [lrange $args 1 end-1] ","] set Valeur [lindex $args end] if {$Quoi == ""} {return} return [set TableauArbreGeneOntology($Quoi) $Valeur] } if {[string equal -nocase $FirstArg "unset"]} { if {![info exists TableauArbreGeneOntology]} {return} set Quoi [join [lrange $args 1 end] ","] if {$Quoi == ""} { return [info exists TableauArbreGeneOntology] } else { catch {unset TableauArbreGeneOntology($Quoi)} } return } if {[string equal -nocase $FirstArg "Load"] && ![info exists TableauArbreGeneOntology(EstCharge)]} { if {[info exists TableauArbreGeneOntology]} {unset TableauArbreGeneOntology} set TableauArbreGeneOntology(EstCharge) 1 LoadGODB TableauArbreGeneOntology return } set Quoi [join $args ","] if {[info exists TableauArbreGeneOntology($Quoi)]} {return [set TableauArbreGeneOntology($Quoi)] } if {[info exists TableauArbreGeneOntology(EstCharge)]} {return} LoadGODB TableauArbreGeneOntology set TableauArbreGeneOntology(EstCharge) 1 if {[info exists TableauArbreGeneOntology($Quoi)]} { return [set TableauArbreGeneOntology($Quoi)] } return } proc GODBDir {} { global RepGODBDir global RepertoireDuGenome if {[info exists RepertoireDuGenome]} { set Rep "[OntologyDir]" if {![file exists $Rep]} {return} set RepGODBDir $Rep } else { set Rep "[ProgSourceDir]/GODB" if {![file exists $Rep]} {return} set RepGODBDir $Rep } return $RepGODBDir } proc GOEnrichmentWebService {Lids} { set url "http://david.abcc.ncifcrf.gov/api.jsp?" set Largs [list] set tool "chartReport" lappend Largs "tool=$tool" set type "UNIPROT_ID" set type "UNIPROT_ID" lappend Largs "type=$type" set annot "GOTERM_BP_ALL,GOTERM_CC_ALL,GOTERM_MF_ALL" lappend Largs "annot=$annot" set sid [join $Lids ,] lappend Largs "ids=$sid" set args [join $Largs "&"] append url "$args" puts "$url" if {[string length $url] > 2048} { puts "url length [string length $url]" exit } set res [HttpCopy $url] return $res } proc GOPanel {{w ""}} { global LesAccessPourLeGO global AccessPourLeGO global LesProjGscopePourLeGO global ProjGscopePourLeGO global LesBoxGscopePourLeGO global BoxGscopePourLeGO global LesBlastPPourLeGO global BlastPPourLeGO global LesFichiersDPC2GO global FichierDPC2GO global LesGOPourLeGO global GOPourLeGO global LesRequetesPourLeGO global RequetePourLeGO global TabValidationDesGO global TypeSelectionne global OptionsSelect global DensitySelect set DensitySelect "No" set TypeSelectionne [lindex [LesTypesOntologiques] 0] set OptionsSelect "OnlyMyGO" set LesAccessPourLeGO {} set LesProjGscopePourLeGO {} set LesBoxGscopePourLeGO {} set LesBlastPPourLeGO {} set LesGOPourLeGO {} set LesRequetesPourLeGO {} set LesFichiersDPC2GO {} if {$w == ""} {set w "."} else {toplevel $w} wm geometry $w +300+100 wm title $w "ONTOLOGY PANEL" wm resizable $w false false if {$w == "."} {set w ""} set FRequetes "$w.frequetes" set FType "$w.ftype" set FDensity "$w.fdensity" set FOptions "$w.foptions" set FBoutons "$w.fboutons" frame $FRequetes -borderwidth 3 -relief ridge frame $FType -borderwidth 3 -relief ridge frame $FDensity -borderwidth 3 -relief ridge frame $FOptions -borderwidth 3 -relief ridge frame $FBoutons -borderwidth 3 -relief ridge pack $FRequetes -side top -fill both pack $FType -fill x pack $FDensity -fill x pack $FOptions -fill x pack $FBoutons -fill x set LTitre "$FRequetes.ltitre" label $LTitre -text "ONTOLOGY" -borderwidth 3 -relief ridge pack $LTitre -side top -fill x ###Access### set FAccess "$FRequetes.faccess" set LAccess "$FAccess.laccess" set EAccess "$FAccess.eaccess" set BAccess "$FAccess.baccess" frame $FAccess label $LAccess -text "Access or Id" -background yellow -width 20 -anchor w entry $EAccess -textvariable AccessPourLeGO button $BAccess -text "ADD" -background RoyalBlue -command { set AccessPourLeGO [string toupper $AccessPourLeGO] if { ![info exists TabValidationDesGO($AccessPourLeGO)] && [regexp -nocase {[0-9a-z]} $AccessPourLeGO]} { Espionne $AccessPourLeGO set TabValidationDesGO($AccessPourLeGO) 1 lappend LesAccessPourLeGO $AccessPourLeGO set AccessPourLeGO "" } } ###Gscope### set FProjGscope "$FRequetes.fprojgscope" set LProjGscope "$FProjGscope.lprojgscope" set EProjGscope "$FProjGscope.eprojgscope" set BProjGscope "$FProjGscope.bprojgscope" frame $FProjGscope label $LProjGscope -text "Gscope DataBase" -background yellow -width 20 -anchor w entry $EProjGscope -textvariable ProjGscopePourLeGO button $BProjGscope -text "ADD" -background RoyalBlue -command { if { [file exists [GscopeDatabaseDir $ProjGscopePourLeGO]] && ![info exists TabValidationDesGO($ProjGscopePourLeGO)] && [regexp -nocase {[0-9a-z]} $ProjGscopePourLeGO]} { Espionne $ProjGscopePourLeGO set TabValidationDesGO($ProjGscopePourLeGO) 1 lappend LesProjGscopePourLeGO $ProjGscopePourLeGO set ProjGscopePourLeGO "" } } ###Gscope Box### set FBoxGscope "$FRequetes.fboxgscope" set LBoxGscope "$FBoxGscope.lboxgscope" set EBoxGscope "$FBoxGscope.eboxgscope" set BBoxGscope "$FBoxGscope.bboxgscope" frame $FBoxGscope label $LBoxGscope -text "Gscope Box" -background yellow -width 20 -anchor w entry $EBoxGscope -textvariable BoxGscopePourLeGO button $BBoxGscope -text "ADD" -background RoyalBlue -command { if { ![info exists TabValidationDesGO($BoxGscopePourLeGO)] && [regexp -nocase {[0-9a-z]} $BoxGscopePourLeGO]} { Espionne $BoxGscopePourLeGO set TabValidationDesGO($BoxGscopePourLeGO) 1 lappend LesBoxGscopePourLeGO $BoxGscopePourLeGO set BoxGscopePourLeGO "" } } ###BlastP### set FBlastP "$FRequetes.fblastp" set LBlastP "$FBlastP.lblastp" set EBlastP "$FBlastP.eblastp" set BBlastP "$FBlastP.bblastp" frame $FBlastP label $LBlastP -text "Blast P or X or Ballast" -background yellow -width 20 -anchor w entry $EBlastP -textvariable BlastPPourLeGO button $BBlastP -text "ADD" -background RoyalBlue -command { if { [file exists $BlastPPourLeGO] && ![info exists TabValidationDesGO($BlastPPourLeGO)] && [regexp -nocase {[0-9a-z]} $BlastPPourLeGO]} { Espionne $BlastPPourLeGO set TabValidationDesGO($BlastPPourLeGO) 1 lappend LesBlastPPourLeGO $BlastPPourLeGO set BlastPPourLeGO "" } } ###FichierDPC### set FFichierDPC "$FRequetes.ffichierdpc" set LFichierDPC "$FFichierDPC.lfichierdpc" set EFichierDPC "$FFichierDPC.efichierdpc" set BFichierDPC "$FFichierDPC.bfichierdpc" frame $FFichierDPC label $LFichierDPC -text "Fichier DPC to GO" -background yellow -width 20 -anchor w entry $EFichierDPC -textvariable FichierDPC2GO button $BFichierDPC -text "ADD" -background RoyalBlue -command { if { [file exists $FichierDPC2GO] && ![info exists TabValidationDesGO($FichierDPC2GO)] && [regexp -nocase {[0-9a-z]} $FichierDPC2GO]} { Espionne $FichierDPC2GO set TabValidationDesGO($FichierDPC2GO) 1 lappend LesFichiersDPC2GO $FichierDPC2GO set FichierDPC2GO "" } } ###GO### set FGO "$FRequetes.fgo" set LGO "$FGO.lgo" set EGO "$FGO.ego" set BGO "$FGO.bgo" frame $FGO label $LGO -text "access GO" -background yellow -width 20 -anchor w entry $EGO -textvariable GOPourLeGO button $BGO -text "ADD" -background RoyalBlue -command { if { ![info exists TabValidationDesGO($GOPourLeGO)] && [regexp -nocase {[0-9a-z]} $GOPourLeGO]} { Espionne $GOPourLeGO set TabValidationDesGO($GOPourLeGO) 1 lappend LesGOPourLeGO $GOPourLeGO set GOPourLeGO "" } } ###requete### set Frequete "$FRequetes.frequete" set Lrequete "$Frequete.lrequete" set Erequete "$Frequete.erequete" set Brequete "$Frequete.brequete" frame $Frequete label $Lrequete -text "EC or IPR or Keywords" -background yellow -width 20 -anchor w entry $Erequete -textvariable RequetePourLeGO button $Brequete -text "ADD" -background RoyalBlue -command { if { ![info exists TabValidationDesGO(RequetePourLeGO)] && [regexp -nocase {[0-9a-z]} $RequetePourLeGO]} { Espionne $RequetePourLeGO set TabValidationDesGO($RequetePourLeGO) 1 lappend LesRequetesPourLeGO $RequetePourLeGO set RequetePourLeGO "" } } ##Choix Type##### label "$FType.ltype" -text "Select the ontology type" -anchor center pack "$FType.ltype" -fill both -side top foreach UnType [LesTypesOntologiques] { radiobutton "$FType.rb$UnType" -text "$UnType" -variable TypeSelectionne -value "$UnType" pack configure "$FType.rb$UnType" -side left -fill x } ###Choix Density#### label "$FDensity.ldensity" -text "Select the density options" -anchor center pack "$FDensity.ldensity" -fill both -side top radiobutton "$FDensity.rboption1" -text "Access" -variable DensitySelect -value "Access" pack configure "$FDensity.rboption1" -side left -fill x radiobutton "$FDensity.rboption2" -text "Box" -variable DensitySelect -value "Box" pack configure "$FDensity.rboption2" -side left -fill x radiobutton "$FDensity.rboption3" -text "Requetes" -variable DensitySelect -value "Requetes" pack configure "$FDensity.rboption3" -side left -fill x radiobutton "$FDensity.rboption4" -text "All" -variable DensitySelect -value "All" pack configure "$FDensity.rboption4" -side left -fill x radiobutton "$FDensity.rboption5" -text "None" -variable DensitySelect -value "No" pack configure "$FDensity.rboption5" -side left -fill x ##Choix Options##### label "$FOptions.loptions" -text "Select the drawing options" -anchor center pack "$FOptions.loptions" -fill both -side top radiobutton "$FOptions.rboption1" -text "Only My GO" -variable OptionsSelect -value "OnlyMyGO" pack configure "$FOptions.rboption1" -side left -fill x radiobutton "$FOptions.rboption2" -text "All and My GO" -variable OptionsSelect -value "AllAndMyGO" pack configure "$FOptions.rboption2" -side left -fill x radiobutton "$FOptions.rboption3" -text "Not My GO" -variable OptionsSelect -value "NotDisplayMyGO" pack configure "$FOptions.rboption3" -side left -fill x ####Bouton#### set BFermer "$FBoutons.bfermer" button $BFermer -text "DISMISS" -background red -command "destroy $w" set BReset "$FBoutons.breset" button $BReset -text "RESET" -background orange -command "ResetMesGO" set BAfficherCheese "$FBoutons.baffichercheese" button $BAfficherCheese -text "DRAW Pie-chart" -background green -command {ChargeLesGO $TypeSelectionne $OptionsSelect $DensitySelect Cheese} set BAfficherTree "$FBoutons.baffichertree" button $BAfficherTree -text "DRAW Tree" -background green -command {ChargeLesGO $TypeSelectionne $OptionsSelect $DensitySelect Tree} pack $FAccess -side top -fill x pack $LAccess -side left -fill both pack $EAccess -side left -fill both pack $BAccess -side left -fill both pack $FProjGscope -side top -fill x pack $LProjGscope -side left -fill both pack $EProjGscope -side left -fill both pack $BProjGscope -side left -fill both pack $FBoxGscope -side top -fill x pack $LBoxGscope -side left -fill both pack $EBoxGscope -side left -fill both pack $BBoxGscope -side left -fill both pack $FBlastP -side top -fill x pack $LBlastP -side left -fill both pack $EBlastP -side left -fill both pack $BBlastP -side left -fill both pack $FFichierDPC -side top -fill x pack $LFichierDPC -side left -fill both pack $EFichierDPC -side left -fill both pack $BFichierDPC -side left -fill both pack $FGO -side top -fill x pack $LGO -side left -fill both pack $EGO -side left -fill both pack $BGO -side left -fill both pack $Frequete -side top -fill x pack $Lrequete -side left -fill both pack $Erequete -side left -fill both pack $Brequete -side left -fill both pack $BFermer -side left pack $BReset -side left pack $BAfficherTree -side right pack $BAfficherCheese -side right return "" } proc GOPanelFindProtein {{w ""} {Option ""}} { if {[string equal -nocase $Option "exit"]} { GOUsersDB unset destroy $w if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w ".panelfindprotein" if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOPanelFindProtein" wm iconname $w "GOPanelFindProtein" global ListBoxDePanleFindProtein if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} if {$w == "."} {set w ""} set FrameChoix "$w.framechoix" set FrameLaunch "$w.framelaunch" set Combo "$FrameChoix.combo" set Entry "$FrameChoix.entry" set ButtonOK "$FrameChoix.bok" set ButtonDel "$FrameChoix.bdel" set ButtonVal "$FrameLaunch.blaunch" frame $FrameChoix frame $FrameLaunch combobox $Combo -borderwidth 1 -textvariable QuelTypeDEntryPourLaGeneOntology -editable false -highlightthickness 1 -width 25 entry $Entry -borderwidth 1 -textvariable QuelEntryPourLaGeneOntology button $ButtonOK -borderwidth 1 -text "OK" button $ButtonDel -borderwidth 1 -text "DEL" button $ButtonVal -borderwidth 1 -text "LAUNCH" pack $FrameChoix -fill x -side top pack $FrameLaunch -fill x -side top pack $Combo -fill both -side left pack $Entry -fill both -side left pack $ButtonOK -fill both -side left pack $ButtonDel -fill both -side left pack $ButtonVal -fill both -side bottom foreach Element [list "GO term" "GO file" "Exactly this Keywords" "Containing this Keywords" "Organism"] {$Combo list insert end $Element} $Combo configure -width 25 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLaGeneOntology]} { set QuelEntryPourLaGeneOntology [DrawChooseFile "Choose the $QuelTypeDEntryPourLaGeneOntology" "."] } ComboboxEndOfCommand } set LabelLog "$w.labellog" label $LabelLog -text "Log information" pack $LabelLog -side top -expand 0 -fill x set FrameInfo "$w.frameinfo" frame $FrameInfo pack $FrameInfo -side top -expand yes -fill both set ListBox "$FrameInfo.list" set ListBoxDePanleFindProtein $ListBox scrollbar $FrameInfo.yscroll -command "$ListBox yview" scrollbar $FrameInfo.xscroll -command "$ListBox xview" -orient horizontal set Largeur 60 set Hauteur 10 listbox $ListBox -width $Largeur -height $Hauteur -setgrid 1 -yscroll "$FrameInfo.yscroll set" -xscroll "$FrameInfo.xscroll set" -selectmode extended -background "LightGrey" -foreground "Black" -selectbackground "LightYellow" -selectforeground "Black" -font "courier 10" grid $FrameInfo.list -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $FrameInfo.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $FrameInfo.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $FrameInfo 0 -weight 1 -minsize 0 grid columnconfig $FrameInfo 0 -weight 1 -minsize 0 $ButtonOK configure -command { if {$QuelTypeDEntryPourLaGeneOntology == "GO term" } {set Type "GO" } if {$QuelTypeDEntryPourLaGeneOntology == "GO file" } {set Type "GOF"} if {$QuelTypeDEntryPourLaGeneOntology == "Exactly this Keywords" } {set Type "EKW" } if {$QuelTypeDEntryPourLaGeneOntology == "Containing this Keywords"} {set Type "CKW" } if {$QuelTypeDEntryPourLaGeneOntology == "Organism" } {set Type "OS" } set Entry $QuelEntryPourLaGeneOntology AjouteLesInfoDansLaListeBox "$ListBoxDePanleFindProtein" [list "\#Entry $Type $Entry"] set QuelEntryPourLaGeneOntology "" } $ButtonDel configure -command { set QuelEntryPourLaGeneOntology "" } $ButtonVal configure -command { ValidLaListeBoxDePanelFindProtein "$ListBoxDePanleFindProtein" set QuelEntryPourLaGeneOntology "" } set BoutonReset "$w.buttonresetlog" button $BoutonReset -borderwidth 1 -text "Reset the Log information" pack $BoutonReset -fill x -side top -expand 0 $BoutonReset configure -command "$ListBox delete 0 end" ##Boutons de sauvegarde################## set FrameSauve "$w.framesauve" frame $FrameSauve pack $FrameSauve -fill x -side top -expand 0 set BoutonSauveLog "$FrameSauve.buttonsavelog" button $BoutonSauveLog -borderwidth 1 -text "Save all the Log info" pack $BoutonSauveLog -fill x -side left -expand 1 $BoutonSauveLog configure -command "SauveContenuDeLaListeDuPanelFindProtein $ListBox All" set BoutonSauveId "$FrameSauve.buttonsaveid" button $BoutonSauveId -borderwidth 1 -text "Save all the ID" pack $BoutonSauveId -fill x -side left -expand 1 $BoutonSauveId configure -command "SauveContenuDeLaListeDuPanelFindProtein $ListBox JustID" set BoutonSauveTFA "$FrameSauve.buttonsavetfa" button $BoutonSauveTFA -borderwidth 1 -text "Save all the TFAs" pack $BoutonSauveTFA -fill x -side left -expand 1 $BoutonSauveTFA configure -command "SauveContenuDeLaListeDuPanelFindProtein $ListBox JustTFA" #################################################### set BoutonExit "$w.buttonexit" button $BoutonExit -borderwidth 1 -text "CLOSE" pack $BoutonExit -fill x -side bottom -expand 0 if {$w == ""} {set w "."} $BoutonExit configure -command "GOPanelFindProtein $w exit" } proc GOPanelGOEnrichment {{w ""} {Option ""}} { if {[string equal -nocase $Option "exit"]} { destroy $w GOUsersDB unset if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w ".panelgoenrichment" if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOPanelGOEnrichment" wm iconname $w "GOPanelGOEnrichment" if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} global LePanelPrincipalDuGOEnrichment ChefDOrchestreDuCalculDEnrichissement ini ChefDOrchestreDuCalculDEnrichissement append w $w if {$w == "."} {set w ""} set FrameGroupe "$w.framegroupe" set LabelGroupe "$FrameGroupe.label" set ComboGroupe "$FrameGroupe.combo" set EntryGroupe "$FrameGroupe.entry" set ButtonOKGroupe "$FrameGroupe.bok" set ButtonDelGroupe "$FrameGroupe.bdel" set FramePop "$w.framepopulation" set LabelPop "$FramePop.label" set ComboPop "$FramePop.combo" set EntryPop "$FramePop.entry" set ButtonOKPop "$FramePop.bok" set ButtonDelPop "$FramePop.bdel" set FrameLaunch "$w.framelaunch" set ButtonVal "$FrameLaunch.blaunch" ################################################" set FrameThreshold "$w.framethreshold" set LabelMin "$FrameThreshold.lmin" set LabelMax "$FrameThreshold.lmax" set Labelr "$FrameThreshold.lr" set EntryrMin "$FrameThreshold.ermin" set EntryrMax "$FrameThreshold.ermax" set LabelR "$FrameThreshold.lgrandr" set EntryRMin "$FrameThreshold.egrandrmin" set EntryRMax "$FrameThreshold.egrandrmax" set Labeln "$FrameThreshold.ln" set EntrynMin "$FrameThreshold.enmin" set EntrynMax "$FrameThreshold.enmax" set LabelN "$FrameThreshold.lgrandn" set EntryNMin "$FrameThreshold.egrandnmin" set EntryNMax "$FrameThreshold.egrandnmax" set LabelZscore "$FrameThreshold.lzscore" set EntryZscoreMin "$FrameThreshold.ezscoremin" set EntryZscoreMax "$FrameThreshold.ezscoremax" ################################################## set FrameCanva "$w.framecanva" frame $FrameGroupe label $LabelGroupe -text "Group" -width 15 -anchor w combobox $ComboGroupe -borderwidth 1 -textvariable QuelTypeDEntryPourLeGroupe -editable false -highlightthickness 1 -width 25 entry $EntryGroupe -borderwidth 1 -textvariable QuelEntryPourLeGroupe button $ButtonOKGroupe -borderwidth 1 -text "OK" button $ButtonDelGroupe -borderwidth 1 -text "DEL" frame $FramePop label $LabelPop -text "Population" -width 15 -anchor w combobox $ComboPop -borderwidth 1 -textvariable QuelTypeDEntryPourLaPop -editable false -highlightthickness 1 -width 25 entry $EntryPop -borderwidth 1 -textvariable QuelEntryPourLaPop button $ButtonOKPop -borderwidth 1 -text "OK" button $ButtonDelPop -borderwidth 1 -text "DEL" frame $FrameLaunch button $ButtonVal -borderwidth 1 -text "LAUNCH" ########THRESHOLD########################################### frame $FrameThreshold -borderwidth 1 label $LabelMin -text "Threshold min" label $LabelMax -text "Threshold Max" label $Labelr -text "r" entry $EntryrMin -borderwidth 1 -textvariable rMin entry $EntryrMax -borderwidth 1 -textvariable rMax label $LabelR -text "R" entry $EntryRMin -borderwidth 1 -textvariable RMin entry $EntryRMax -borderwidth 1 -textvariable RMax label $Labeln -text "n" entry $EntrynMin -borderwidth 1 -textvariable nMin entry $EntrynMax -borderwidth 1 -textvariable nMax label $LabelN -text "N" entry $EntryNMin -borderwidth 1 -textvariable NMin entry $EntryNMax -borderwidth 1 -textvariable NMax label $LabelZscore -text "z score" entry $EntryZscoreMin -borderwidth 1 -textvariable ZscoreMin entry $EntryZscoreMax -borderwidth 1 -textvariable ZscoreMax ####################################### frame $FrameCanva pack $FrameGroupe -fill x -side top pack $LabelGroupe -fill both -side left pack $ComboGroupe -fill both -side left pack $EntryGroupe -fill both -side left pack $ButtonOKGroupe -fill both -side left pack $ButtonDelGroupe -fill both -side left pack $FramePop -fill x -side top pack $LabelPop -fill both -side left pack $ComboPop -fill both -side left pack $EntryPop -fill both -side left pack $ButtonOKPop -fill both -side left pack $ButtonDelPop -fill both -side left set BoutonReset "$w.buttonresetlog" button $BoutonReset -borderwidth 1 -text "Reset All" pack $BoutonReset -fill x -side top -expand 0 pack $FrameLaunch -fill x -side top pack $ButtonVal -fill both -side bottom ############Threshold#################### pack $FrameThreshold -fill x -side top -expand 0 grid $LabelMin -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelMax -row 0 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $Labelr -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryrMin -row 1 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryrMax -row 1 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelR -row 2 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryRMin -row 2 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryRMax -row 2 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $Labeln -row 3 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntrynMin -row 3 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntrynMax -row 3 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelN -row 4 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryNMin -row 4 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryNMax -row 4 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelZscore -row 5 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryZscoreMin -row 5 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryZscoreMax -row 5 -column 2 -rowspan 1 -columnspan 1 -sticky nsew $EntryrMin delete 0 end $EntryrMax delete 0 end $EntryRMin delete 0 end $EntryRMax delete 0 end $EntrynMin delete 0 end $EntrynMax delete 0 end $EntryNMin delete 0 end $EntryNMax delete 0 end $EntryZscoreMin delete 0 end $EntryZscoreMax delete 0 end $EntryrMin insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur rMin ] $EntryrMax insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur rMax ] $EntryRMin insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur RMin ] $EntryRMax insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur RMax ] $EntrynMin insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur nMin ] $EntrynMax insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur nMax ] $EntryNMin insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur NMin ] $EntryNMax insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur NMax ] $EntryZscoreMin insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur ZscoreMin] $EntryZscoreMax insert 0 [ChefDOrchestreDuCalculDEnrichissement set Valeur ZscoreMax] ####################################### pack $FrameCanva -fill both -side top -expand 1 set BoutonExit "$w.buttonexit" button $BoutonExit -borderwidth 1 -text "CLOSE" pack $BoutonExit -fill x -side bottom -expand 0 #set BoutonSauve "$w.buttonsave" #button $BoutonSauve -borderwidth 1 -text "Save results as" #pack $BoutonSauve -fill x -side bottom -expand 0 if {$w == ""} {set w "."} set HauteurMax [expr [winfo screenheight .] * 1.0 / 2] set LargeurMax [expr [winfo screenwidth .] * 2.0 / 3] set HauteurFenetre [expr [winfo screenheight .] * 1.0 / 2] set LargeurFenetre [expr [winfo screenwidth .] * 2.0 / 3] set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre NoY "" "" $FrameCanva] set LePanelPrincipalDuGOEnrichment [list $KCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre $FrameCanva] $KCanva configure -background white ##################################################### foreach Element [ChefDOrchestreDuCalculDEnrichissement "LesTypesDEntry"] { $ComboPop list insert end $Element $ComboGroupe list insert end $Element } $ComboGroupe configure -width 25 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLeGroupe]} { set QuelEntryPourLeGroupe [DrawChooseFile "Choose the $QuelTypeDEntryPourLeGroupe" "."] } ComboboxEndOfCommand } $ComboPop configure -width 25 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLaPop]} { set QuelEntryPourLaPop [DrawChooseFile "Choose the $QuelTypeDEntryPourLaPop" "."] } ComboboxEndOfCommand } $BoutonExit configure -command "GOPanelGOEnrichment $w exit" #$BoutonSauve configure -command "" $BoutonReset configure -command { ChefDOrchestreDuCalculDEnrichissement "Unset" set QuelEntryPourLeGroupe "" set QuelEntryPourLaPop "" } $ButtonDelGroupe configure -command { ChefDOrchestreDuCalculDEnrichissement "UnsetGroup" set QuelEntryPourLeGroupe "" } $ButtonDelPop configure -command { ChefDOrchestreDuCalculDEnrichissement "UnsetPopulation" set QuelEntryPourLaPop "" } $ButtonOKGroupe configure -command { ChefDOrchestreDuCalculDEnrichissement "AppendGroup" $QuelTypeDEntryPourLeGroupe $QuelEntryPourLeGroupe set QuelEntryPourLeGroupe "" } $ButtonOKPop configure -command { ChefDOrchestreDuCalculDEnrichissement "AppendPopulation" $QuelTypeDEntryPourLaPop $QuelEntryPourLaPop set QuelEntryPourLaPop "" } $ButtonVal configure -command { ChefDOrchestreDuCalculDEnrichissement "append" Valeur rMin $rMin ChefDOrchestreDuCalculDEnrichissement "append" Valeur rMax $rMax ChefDOrchestreDuCalculDEnrichissement "append" Valeur RMin $RMin ChefDOrchestreDuCalculDEnrichissement "append" Valeur RMax $RMax ChefDOrchestreDuCalculDEnrichissement "append" Valeur nMin $nMin ChefDOrchestreDuCalculDEnrichissement "append" Valeur nMax $nMax ChefDOrchestreDuCalculDEnrichissement "append" Valeur NMin $NMin ChefDOrchestreDuCalculDEnrichissement "append" Valeur NMax $NMax ChefDOrchestreDuCalculDEnrichissement "append" Valeur ZscoreMin $ZscoreMin ChefDOrchestreDuCalculDEnrichissement "append" Valeur ZscoreMax $ZscoreMax set LesZscore [ChefDOrchestreDuCalculDEnrichissement "Calcul" ] set KCanva [ChefDOrchestreDuCalculDEnrichissement "Affiche" $LesZscore] if {$KCanva != ""} { $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Enter" $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Leave" } set QuelEntryPourLeGroupe "" set QuelEntryPourLaPop "" } $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Enter" $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Leave" return } proc GOPanelHisto {{w ""} {Option ""}} { if {[string equal -nocase $Option "exit"]} { destroy $w GOUsersDB unset if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w ".panelgohisto" if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOPanelHisto" wm iconname $w "GOPanelHisto" if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} global LePanelPrincipalDuGOHisto ChefDOrchestreDuGOHisto ini ChefDOrchestreDuGOHisto append w $w if {$w == "."} {set w ""} set FrameGroupe "$w.framegroupe" set LabelGroupe "$FrameGroupe.label" set ComboGroupe "$FrameGroupe.combo" set EntryGroupe "$FrameGroupe.entry" set ButtonOKGroupe "$FrameGroupe.bok" set ButtonDelGroupe "$FrameGroupe.bdel" set FrameLaunch "$w.framelaunch" set ButtonVal "$FrameLaunch.blaunch" ################################################" set FrameThreshold "$w.framethreshold" set LabelMin "$FrameThreshold.lmin" set LabelMax "$FrameThreshold.lmax" set Labeln "$FrameThreshold.ln" set EntrynMin "$FrameThreshold.enmin" set EntrynMax "$FrameThreshold.enmax" set LabelNiv "$FrameThreshold.lniv" set EntryNivMin "$FrameThreshold.enivmin" set EntryNivMax "$FrameThreshold.enivmax" ################################################## set FrameCanva "$w.framecanva" frame $FrameGroupe label $LabelGroupe -text "Group" -width 15 -anchor w combobox $ComboGroupe -borderwidth 1 -textvariable QuelTypeDEntryPourLeGroupe -editable false -highlightthickness 1 -width 25 entry $EntryGroupe -borderwidth 1 -textvariable QuelEntryPourLeGroupe button $ButtonOKGroupe -borderwidth 1 -text "OK" button $ButtonDelGroupe -borderwidth 1 -text "DEL" frame $FrameLaunch button $ButtonVal -borderwidth 1 -text "LAUNCH" ########THRESHOLD########################################### frame $FrameThreshold -borderwidth 1 label $LabelMin -text "Threshold min" label $LabelMax -text "Threshold Max" label $Labeln -text "n" entry $EntrynMin -borderwidth 1 -textvariable nMin entry $EntrynMax -borderwidth 1 -textvariable nMax label $LabelNiv -text "Niveau" entry $EntryNivMin -borderwidth 1 -textvariable NivMin entry $EntryNivMax -borderwidth 1 -textvariable NivMax ####################################### frame $FrameCanva pack $FrameGroupe -fill x -side top pack $LabelGroupe -fill both -side left pack $ComboGroupe -fill both -side left pack $EntryGroupe -fill both -side left pack $ButtonOKGroupe -fill both -side left pack $ButtonDelGroupe -fill both -side left set BoutonReset "$w.buttonresetlog" button $BoutonReset -borderwidth 1 -text "Reset All" pack $BoutonReset -fill x -side top -expand 0 pack $FrameLaunch -fill x -side top pack $ButtonVal -fill both -side bottom ############Threshold#################### pack $FrameThreshold -fill x -side top -expand 0 grid $LabelMin -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelMax -row 0 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $Labeln -row 3 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntrynMin -row 3 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntrynMax -row 3 -column 2 -rowspan 1 -columnspan 1 -sticky nsew grid $LabelNiv -row 4 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryNivMin -row 4 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $EntryNivMax -row 4 -column 2 -rowspan 1 -columnspan 1 -sticky nsew $EntrynMin delete 0 end $EntrynMax delete 0 end $EntryNivMin delete 0 end $EntryNivMax delete 0 end $EntrynMin insert 0 [ChefDOrchestreDuGOHisto set Valeur nMin ] $EntrynMax insert 0 [ChefDOrchestreDuGOHisto set Valeur nMax ] $EntryNivMin insert 0 [ChefDOrchestreDuGOHisto set Valeur NivMin ] $EntryNivMax insert 0 [ChefDOrchestreDuGOHisto set Valeur NivMax ] ####################################### pack $FrameCanva -fill both -side top -expand 1 set BoutonExit "$w.buttonexit" button $BoutonExit -borderwidth 1 -text "CLOSE" pack $BoutonExit -fill x -side bottom -expand 0 set BoutonSauve "$w.buttonsave" button $BoutonSauve -borderwidth 1 -text "Save results as" pack $BoutonSauve -fill x -side bottom -expand 0 if {$w == ""} {set w "."} set HauteurMax [expr [winfo screenheight .] * 1.0 / 2] set LargeurMax [expr [winfo screenwidth .] * 2.0 / 3] set HauteurFenetre [expr [winfo screenheight .] * 1.0 / 2] set LargeurFenetre [expr [winfo screenwidth .] * 2.0 / 3] set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre NoY "" "" $FrameCanva] set LePanelPrincipalDuGOHisto [list $KCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre $FrameCanva] $KCanva configure -background white ##################################################### foreach Element [ChefDOrchestreDuGOHisto "LesTypesDEntry"] { $ComboGroupe list insert end $Element } $ComboGroupe configure -width 25 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLeGroupe]} { set QuelEntryPourLeGroupe [DrawChooseFile "Choose the $QuelTypeDEntryPourLeGroupe" "."] } ComboboxEndOfCommand } $BoutonExit configure -command "GOPanelHisto $w exit" #$BoutonSauve configure -command "" $BoutonReset configure -command { ChefDOrchestreDuGOHisto "Unset" set QuelEntryPourLeGroupe "" } $ButtonDelGroupe configure -command { ChefDOrchestreDuGOHisto "UnsetGroup" set QuelEntryPourLeGroupe "" } $ButtonOKGroupe configure -command { ChefDOrchestreDuGOHisto "AppendGroup" $QuelTypeDEntryPourLeGroupe $QuelEntryPourLeGroupe set QuelEntryPourLeGroupe "" } $BoutonSauve configure -command { ChefDOrchestreDuGOHisto "append" Valeur nMin $nMin ChefDOrchestreDuGOHisto "append" Valeur nMax $nMax ChefDOrchestreDuGOHisto "append" Valeur NivMin $NivMin ChefDOrchestreDuGOHisto "append" Valeur NivMax $NivMax set TousLesGO [ChefDOrchestreDuGOHisto "Calcul"] ChefDOrchestreDuGOHisto "Save" $TousLesGO } $ButtonVal configure -command { ChefDOrchestreDuGOHisto "append" Valeur nMin $nMin ChefDOrchestreDuGOHisto "append" Valeur nMax $nMax ChefDOrchestreDuGOHisto "append" Valeur NivMin $NivMin ChefDOrchestreDuGOHisto "append" Valeur NivMax $NivMax set TousLesGO [ChefDOrchestreDuGOHisto "Calcul" ] set KCanva [ChefDOrchestreDuGOHisto "Affiche" $TousLesGO] if {$KCanva != ""} { $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Enter" $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Leave" } set QuelEntryPourLeGroupe "" } $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Enter" $KCanva bind "GO" "AfficheInfoBulle $KCanva %x %y Leave" return } proc GOPanelTree {{w ""} {Option ""}} { global TreeAllGODePanelTree global TreeOneGODePanelTree if {[string equal -nocase $Option "exit"]} { GOUsersDB unset destroy $w if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w ".paneltree" if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOPanelTree" wm iconname $w "GOPanelTree" if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} GOUsersDB "ini" if {$w == "."} {set w ""} set FrameChoix "$w.framechoix" set FrameLaunch "$w.framelaunch" set Combo "$FrameChoix.combo" set Entry "$FrameChoix.entry" set ButtonOK "$FrameChoix.bok" set ButtonDel "$FrameChoix.bdel" set ButtonVal "$FrameLaunch.blaunch" frame $FrameChoix frame $FrameLaunch combobox $Combo -borderwidth 1 -textvariable QuelTypeDEntryPourLaGeneOntology -editable false -highlightthickness 1 entry $Entry -borderwidth 1 -textvariable QuelEntryPourLaGeneOntology button $ButtonOK -borderwidth 1 -text "OK" button $ButtonDel -borderwidth 1 -text "DEL" button $ButtonVal -borderwidth 1 -text "LAUNCH" pack $FrameChoix -fill x -side top pack $FrameLaunch -fill x -side top pack $Combo -fill both -side left pack $Entry -fill both -side left pack $ButtonOK -fill both -side left pack $ButtonDel -fill both -side left pack $ButtonVal -fill both -side bottom foreach Element [GOUsersDB "LesTypesDEntry"] {$Combo list insert end $Element} $Combo configure -width 30 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLaGeneOntology]} { set QuelEntryPourLaGeneOntology [DrawChooseFile "Choose the $QuelTypeDEntryPourLaGeneOntology" "."] } ComboboxEndOfCommand } $ButtonOK configure -command { GOUsersDB "append" $QuelTypeDEntryPourLaGeneOntology $QuelEntryPourLaGeneOntology set QuelEntryPourLaGeneOntology "" } $ButtonDel configure -command { set QuelEntryPourLaGeneOntology "" GOUsersDB "unset" } $ButtonVal configure -command { set KTreeAllGO $TreeAllGODePanelTree set KTreeOneGO $TreeOneGODePanelTree set LesGO [GOUsersDB "valid"] set OpenOuClose "Close" if {$LesGO != ""} {set OpenOuClose "Open"} DrawTreeAllGO $KTreeAllGO $LesGO $OpenOuClose "" DrawTreeOneGO $KTreeOneGO "" set QuelEntryPourLaGeneOntology "" } set FrameTree "$w.frametree" frame $FrameTree pack $FrameTree -fill both -expand 1 -side top if {1} { set KLeft "$FrameTree.frameleft" set KTreeAllGO "$KLeft.wtree" set TreeAllGODePanelTree $KTreeAllGO if {![winfo exists $KLeft]} { frame $KLeft -bg grey pack $KLeft -fill both -expand 1 -side left ############All GO -> frame left######################### Tree:create $KTreeAllGO -width 400 -height 600 -yscrollcommand "$KLeft.sby set" -xscrollcommand "$KLeft.sbx set" scrollbar $KLeft.sby -orient vertical -command "$KTreeAllGO yview" scrollbar $KLeft.sbx -orient horizontal -command "$KTreeAllGO xview" grid $KTreeAllGO -row 0 -column 0 -sticky news grid $KLeft.sby -row 0 -column 1 -sticky news grid $KLeft.sbx -row 1 -column 0 -sticky news grid rowconfigure $KLeft 0 -weight 1 grid columnconfigure $KLeft 0 -weight 1 ######################################################### $KTreeAllGO bind x <1> { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl set lbl [file tail $lbl] if {[regexp -nocase {(GO:[0-9]+)} $lbl tmp GO]} { set KTreeOneGO "$TreeOneGODePanelTree" DrawTreeOneGO $KTreeOneGO $GO } } $KTreeAllGO bind x { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl if {[regsub -all "/" $lbl "" tmp] <= 5} {Tree:open %W $lbl} else {Tree:openallchildren %W $lbl} set lbl [file tail $lbl] if {[regexp -nocase {(GO:[0-9]+)} $lbl tmp GO]} { set KTreeOneGO "$TreeOneGODePanelTree" DrawTreeOneGO $KTreeOneGO $GO } } $KTreeAllGO bind x { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl if {[regsub -all "/" $lbl "" tmp] <= 5} {Tree:open %W $lbl} else {Tree:closeallchildren %W $lbl} set lbl [file tail $lbl] if {[regexp -nocase {(GO:[0-9]+)} $lbl tmp GO]} { set KTreeOneGO "$TreeOneGODePanelTree" DrawTreeOneGO $KTreeOneGO $GO } } $KTreeAllGO bind x { Tree:open %W [Tree:labelat %W %x %y] } } ######################################################### DrawTreeAllGO $KTreeAllGO "" Close "" ######################################################### } if {1} { set KRight "$w.frametree.frameright" set KTreeOneGO "$KRight.wtree" set TreeOneGODePanelTree $KTreeOneGO if {![winfo exists $KRight]} { ######################################################### frame $KRight -bg grey pack $KRight -fill y -expand 0 -side right ############One GO -> frame right######################### Tree:create $KTreeOneGO -width 400 -height 600 -yscrollcommand "$KRight.sby set" -xscrollcommand "$KRight.sbx set" scrollbar $KRight.sby -orient vertical -command "$KTreeOneGO yview" scrollbar $KRight.sbx -orient horizontal -command "$KTreeOneGO xview" grid $KTreeOneGO -row 0 -column 0 -sticky news grid $KRight.sby -row 0 -column 1 -sticky news grid $KRight.sbx -row 1 -column 0 -sticky news grid rowconfigure $KRight 0 -weight 1 grid columnconfigure $KRight 0 -weight 1 ######################################################### $KTreeOneGO bind x <1> { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl set lbl [file tail $lbl ] if {[regexp -nocase {(GO:[0-9]+)} $lbl tmp GO]} { set KTreeOneGO "$TreeOneGODePanelTree" DrawTreeOneGO $KTreeOneGO $GO } } $KTreeOneGO bind x <3> { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl set dir [file dirname $lbl ] set lbl [file tail $lbl ] set lblPere [file tail $dir ] set lblGdPere [file tail [file dirname $dir]] if {[string equal -nocase $lblPere "access"]} { DrawInfo Access $lbl } if {[string equal -nocase $lblGdPere "gscopebox"]} { regsub -all "\\|" $lblPere "/" lblPere DrawInfo Box $lblPere $lbl } if {[regexp -nocase {^ipr[0-9]+$} $lbl]} { DrawInfo Interpro $lbl } } $KTreeOneGO bind x { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl Tree:openallchildren %W $lbl } $KTreeOneGO bind x { set lbl [Tree:labelat %W %x %y] Tree:setselection %W $lbl Tree:closeallchildren %W $lbl } $KTreeOneGO bind x { Tree:open %W [Tree:labelat %W %x %y] } } ######################################################### DrawTreeOneGO $KTreeOneGO "" ######################################################### } set FrameExit "$w.frameexit" if {$w == ""} {set w "."} frame $FrameExit pack $FrameExit -fill x -side bottom -expand 1 set BoutonExit "$FrameExit.buttonexit" button $BoutonExit -borderwidth 1 -text "CLOSE" pack $BoutonExit -fill x -side bottom -expand 0 $BoutonExit configure -command "GOPanelTree $w Exit" } proc GOPanelTreeBall {{w ""} {Option ""}} { if {[string equal -nocase $Option "exit"]} { GOUsersDB unset destroy $w if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w ".paneltreeball" if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOPanelTreeBall" wm iconname $w "GOPanelTreeBall" global AiJeUnCanvaAfficheSurLePanelPrincipal global LePanelPrincipalDuTreeBall if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} GOUsersDB "ini" if {$w == "."} {set w ""} set FrameChoix "$w.framechoix" set FrameLaunch "$w.framelaunch" set Combo "$FrameChoix.combo" set Entry "$FrameChoix.entry" set ButtonOK "$FrameChoix.bok" set ButtonDel "$FrameChoix.bdel" set ButtonVal "$FrameLaunch.blaunch" frame $FrameChoix frame $FrameLaunch combobox $Combo -borderwidth 1 -textvariable QuelTypeDEntryPourLaGeneOntology -editable false -highlightthickness 1 entry $Entry -borderwidth 1 -textvariable QuelEntryPourLaGeneOntology button $ButtonOK -borderwidth 1 -text "OK" button $ButtonDel -borderwidth 1 -text "DEL" button $ButtonVal -borderwidth 1 -text "LAUNCH" pack $FrameChoix -fill x -side top pack $FrameLaunch -fill x -side top pack $Combo -fill both -side left pack $Entry -fill both -side left pack $ButtonOK -fill both -side left pack $ButtonDel -fill both -side left pack $ButtonVal -fill both -side bottom set FrameCanva "$w.framecanva" frame $FrameCanva pack $FrameCanva -fill both -side top foreach Element [GOUsersDB "LesTypesDEntry"] {$Combo list insert end $Element} $Combo configure -width 30 -command { ComboboxStartOfCommand if {[regexp " file$" $QuelTypeDEntryPourLaGeneOntology]} { set QuelEntryPourLaGeneOntology [DrawChooseFile "Choose the $QuelTypeDEntryPourLaGeneOntology" "."] } ComboboxEndOfCommand } $ButtonOK configure -command { GOUsersDB "append" $QuelTypeDEntryPourLaGeneOntology $QuelEntryPourLaGeneOntology set QuelEntryPourLaGeneOntology "" } $ButtonDel configure -command { set QuelEntryPourLaGeneOntology "" GOUsersDB "unset" } $ButtonVal configure -command { set LesGO [GOUsersDB "valid"] Espionne $LesGO set LargeurMax [lindex $LePanelPrincipalDuTreeBall 1] set HauteurMax [lindex $LePanelPrincipalDuTreeBall 2] set LargeurFenetre [lindex $LePanelPrincipalDuTreeBall 3] set HauteurFenetre [lindex $LePanelPrincipalDuTreeBall 4] if {$AiJeUnCanvaAfficheSurLePanelPrincipal} { DrawGOTreeBall $LesGO $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre } else { set AiJeUnCanvaAfficheSurLePanelPrincipal 1 set KCanva [lindex $LePanelPrincipalDuTreeBall 0] DrawGOTreeBall $LesGO $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre $KCanva } set QuelEntryPourLaGeneOntology "" } set HauteurMax [expr [winfo screenheight .] * 2.0 / 3] set LargeurMax [expr [winfo screenwidth .] * 2.0 / 3] set HauteurFenetre [expr [winfo screenheight .] * 2.0 / 3] set LargeurFenetre [expr [winfo screenwidth .] * 2.0 / 3] set KCanva [Canva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre NoY "" "" $FrameCanva] $KCanva configure -background white set LePanelPrincipalDuTreeBall [list $KCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set AiJeUnCanvaAfficheSurLePanelPrincipal 0 set FrameExit "$w.frameexit" frame $FrameExit pack $FrameExit -fill x -side bottom -expand 1 set BoutonExit "$FrameExit.buttonexit" button $BoutonExit -borderwidth 1 -text "CLOSE" pack $BoutonExit -fill x -side bottom -expand 0 if {$w == ""} {set w "."} $BoutonExit configure -command "GOPanelTreeBall $w Exit" return } proc GOSearchPourTous_Gretta {FichierBoitesSelectionnees FichierOut LesGODeRef {LesClustersDeRef ""}} { AskLesPagesInfos unset set LeTexte {} foreach GO $LesGODeRef { set Type [lindex [GODB GO $GO LesTypes ] 0] set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] foreach Ligne [GOSearch_Gretta $FichierBoitesSelectionnees $GO $LesClustersDeRef] { set Ligne "$GO\t$Def\t$Ligne" Espionne $Ligne lappend LeTexte $Ligne } } AskLesPagesInfos unset Sauve [join $LeTexte "\n"] dans $FichierOut return } proc GOSearch_Gretta {FichierBoitesSelectionnees LesGODeRef {LesClustersDeRef ""}} { set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles" set NbCluster 6 foreach CDeRef $LesClustersDeRef {set TabTmp($CDeRef) 1} foreach GO $LesGODeRef {set TabTmp($GO) 1} #Espionne "Lecture du Fichier $FichierBoitesSelectionnees" set F [open $FichierBoitesSelectionnees] set i 0 while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set Ligne [split $Ligne "\t"] set Affy [lindex $Ligne 0] set Cluster [lindex $Ligne 1] incr i set TabAffy($Cluster,$Affy) 1 } close $F set LesAccess {} set Tab(LesClusters) {} #Espionne "Lecture du Fichier $FichierOCADE" foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesNoms] { set Affy [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] set LesExpressions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions] for {set i 0} {$i < $NbCluster} {incr i} { set Cluster [expr $i + 1] if {![info exists Tab(Cluster,$Cluster,LesNoms)]} { set Tab(Cluster,$Cluster,LesNoms) {} lappend Tab(LesClusters) $Cluster } set Expr [lindex $LesExpressions $i] if {$Expr < 0} {continue} if {![info exists TabAffy($Cluster,$Affy)]} {continue} set Access [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {$Access == "NOPROTEIN" || $Access == ""} { set Methode "Contig" set Access [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] if {$Access == "NOPROTEIN" || $Access == ""} { set Access "" set Methode "NoProtein" } } if {$Access != "" && [AskLesPagesInfos ask $Access] == ""} {lappend LesAccess $Access} set Tab($Nom,Access) $Access lappend Tab(Cluster,$Cluster,LesNoms) $Nom } } Espionne "Database is loading..." AskLesPagesInfos load $LesAccess protein Espionne "Database loaded..." set LeTexte {} #Espionne "Lecture du Fichier $FichierGO" foreach Cluster [set Tab(LesClusters)] { if {![info exists Tab(Cluster,$Cluster,LesNoms)]} {continue} foreach Nom [set Tab(Cluster,$Cluster,LesNoms)] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} if {[info exists TabDeJaVu($Cluster,$Nom) ]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] {set TabDeJaVu($Cluster,$Jum) 1} set LAiJeTrouve 0 foreach HigherGO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {[info exists TabTmp($HigherGO)]} {set LAiJeTrouve 1;break} foreach LowerGO [InterrogeGeneOntology $FichierGO GO $HigherGO LesAncetres] { if {[info exists TabTmp($LowerGO)]} {set LAiJeTrouve 1;break} } if {$LAiJeTrouve} {break} } if {$LAiJeTrouve} { set MeanDef [InterrogeDefinitionsConsensus $Nom Definition] set LesGN {} foreach GeneName [InterrogeGeneName $Nom LesGeneNames] { if {$GeneName == ""} {continue} set n [InterrogeGeneName $Nom GeneName $GeneName n] lappend LesGN [list "$GeneName ($n)" $n] } #seulement les 3 premiers GN set LesGeneName {} set i 0 foreach LeGN [lsort -index 1 -decreasing -integer $LesGN] { incr i if {$i > 3} {break} lappend LesGeneName [lindex $LeGN 0] } set GN [join $LesGeneName " ; "] set AccessProt [set Tab($Nom,Access)] set PI [AskLesPagesInfos ask $AccessProt] set Orgas "" set Def "" if {$AccessProt != ""} { set Orgas [join [LesOrgasDeLaPage_PageInfo $PI] ";"] set Def [join [LaDefinitionDeLaProt_PageInfo $PI] " "] } set Access [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] lappend LeTexte "$Nom\t$Access\t$Cluster\t$AccessProt\t$Orgas\t$Def\t$GN\t$MeanDef" } } } return $LeTexte } proc GOToKeepOrNotToKeep {Access} { global MesGOInterressants if {! [info exists MesGOInterressants]} {MesGOInterressants} if {[info exists MesGOInterressants($Access)]} {return 0} else {return 1} } proc GOTools {{w ""} {Option ""}} { #lm rajout package require combobox catch {namespace import ::combobox::*} if {[string equal -nocase $Option "exit"]} { destroy $w if {[winfo children .] == ""} {exit} return } if {[winfo children .] != ""} { set w [NomDe gotools] if {[winfo exists $w]} {return} toplevel $w } else { set w "." $w config -bd 3 -relief flat } wm title $w "GOTools" wm iconname $w "GOTools" if {![GODB EstCharge]} {GODB Load} if {![2GO EstCharge]} {2GO Load} if {$w == "."} {set w ""} set BoutonTree "${w}.boutontree" set BoutonTreeBall "${w}.boutontreeball" set BoutonFindProtein "${w}.boutonfindprotein" set BoutonGOEnrichment "${w}.boutongoenrichment" set BoutonGOHisto "${w}.boutongohisto" set BoutonClose "${w}.boutonclose" if {$w == ""} {set w "."} button $BoutonTree -borderwidth 1 -text "GO Tree" button $BoutonTreeBall -borderwidth 1 -text "GO Tree Ball" button $BoutonFindProtein -borderwidth 1 -text "Find Protein" button $BoutonGOEnrichment -borderwidth 1 -text "GO Enrichement" button $BoutonGOHisto -borderwidth 1 -text "GO Histo" button $BoutonClose -borderwidth 1 -text "CLOSE" pack $BoutonTree -side top -fill both -expand 1 pack $BoutonTreeBall -side top -fill both -expand 1 pack $BoutonFindProtein -side top -fill both -expand 1 pack $BoutonGOEnrichment -side top -fill both -expand 1 pack $BoutonGOHisto -side top -fill both -expand 1 pack $BoutonClose -side top -fill both -expand 1 $BoutonTree configure -command "GOPanelTree" $BoutonTreeBall configure -command "GOPanelTreeBall" $BoutonFindProtein configure -command "GOPanelFindProtein" $BoutonGOEnrichment configure -command "GOPanelGOEnrichment" $BoutonGOHisto configure -command "GOPanelHisto" $BoutonClose configure -command "GOTools $w exit" return } proc GOTotalObserve {Fichier {GO ""} {Distribution 0}} { if {$Distribution==1} { set Fichier "/home/carles/genomes/AffyHS/lms/Distribution.go" } else { if {$Fichier=="/home/carles/genomes/AffyHS/lms/Distribution.go"} {return ""} } if {[ContenuDuFichier $Fichier]==""} {return ""} #Espionne $Fichier set Total 0 set Vu 0 foreach Ligne [LesLignesDuFichier $Fichier] { if {$Vu==1} { if {[regexp "\" $Ligne]} { regsub "\" $Ligne "" Ligne regsub "\" $Ligne "" Ligne set Total [expr $Ligne + $Total] set Vu 0 continue } } if {[regexp "text" $Ligne]} { regsub "\" $Ligne "" Ligne regsub "\" $Ligne "" Ligne regsub -all " " $Ligne "" Ligne set AccessGO $Ligne #Espionne $AccessGO if {$AccessGO==$GO} { set Vu 1 } } } return $Total } proc GOTotalTheorique {Fichier {Distribution 0}} { if {$Distribution==1} { set Fichier "/home/carles/genomes/AffyHS/lms/Distribution.go" } else { if {$Fichier=="/home/carles/genomes/AffyHS/lms/Distribution.go"} {return ""} } if {[ContenuDuFichier $Fichier]==""} {return ""} #Espionne $Fichier set Total 0 foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "entry_count" $Ligne]} { #chaque LMS regsub "\" $Ligne "" Ligne regsub "\" $Ligne "" Ligne #Espionne $Ligne set Total [expr $Total+ $Ligne] } } return $Total } proc GOUsersDB {args} { #LesTypesDEntry #ini #append $TypeDEntry $Entry #Valid #unset #ask GO $GO LesAccess #ask GO $GO LesRequetes #ask GO $GO LesBoitesGscope #ask Access $Access lesRequetes #ask Gscope $FichierGOBoiteGscope Nom $Nom LesAccess global TabLesLiensPourLaGeneOntology set FirstElet [lindex $args 0] if {$FirstElet == ""} {return} if {[string equal -nocase $FirstElet "LesTypesDEntry"]} { return [list "GO term" "GO term file" "Access" "Access file" "Links2GO (Domains, Keywords)" "Blast file" "MSF file" "Clustering file" "Gscope GO file"] } if {[string equal -nocase $FirstElet "ini"]} { set TabLesLiensPourLaGeneOntology(LesGO) {} set TabLesLiensPourLaGeneOntology(LesAccess) {} set TabLesLiensPourLaGeneOntology(LesRequetes) {} set TabLesLiensPourLaGeneOntology(LesBoitesGscope) {} return } if {[string equal -nocase $FirstElet "unset"]} { if {[info exists TabLesLiensPourLaGeneOntology]} {unset TabLesLiensPourLaGeneOntology} GOUsersDB Ini return } if {![info exists TabLesLiensPourLaGeneOntology]} {return} if {[string equal -nocase $FirstElet "valid"]} { set LesGOSelectionnes {} foreach LaBoite [set TabLesLiensPourLaGeneOntology(LesBoitesGscope)] { set Nom [lindex $LaBoite 0] set FichierGO [lindex $LaBoite 1] Espionne "Gscope Box : $Nom from $FichierGO" set TousLesGODeLaBoite {} set LesAccessAvecUnLien {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { lappend TousLesGODeLaBoite $GO lappend LesGOSelectionnes $GO foreach Type [GODB GO $GO LesTypes] { set GO [string toupper [GODB Type $Type GOSynonyme $GO GODeRef]] if {$GO == ""} {continue} foreach GOParent [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { set GOParent [string toupper [GODB Type $Type GOSynonyme $GOParent GODeRef]] if {$GOParent == ""} {continue} lappend TousLesGODeLaBoite $GOParent } } } foreach GO [lsort -unique $TousLesGODeLaBoite] { if {![info exists TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess) ]} { set TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess) {} } if {![info exists TabLesLiensPourLaGeneOntology(GO,$GO,LesBoitesGscope)]} { set TabLesLiensPourLaGeneOntology(GO,$GO,LesBoitesGscope) {} } if {![info exists TabTmp($FichierGO,$Nom,$GO)]} { set TabTmp($FichierGO,$Nom,$GO) 1 lappend TabLesLiensPourLaGeneOntology(GO,$GO,LesBoitesGscope) $LaBoite } foreach Access [InterrogeGeneOntology $FichierGO $Nom LesAccess] { if {$Access == $Nom || $Access == "QUERY_PROTEIN"} {continue} lappend TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess) $Access } } set TabLesLiensPourLaGeneOntology(Gscope,$FichierGO,Nom,$Nom,LesAccess) [lsort -unique $LesAccessAvecUnLien] } foreach Access [set TabLesLiensPourLaGeneOntology(LesAccess)] { Espionne "Access : $Access" set LesGODeLAccess {} set LesRequetesAvecUnLien {} foreach Requete [Access2Requetes $Access] { foreach GO [2GO $Requete LesLiens] { foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {$GO == ""} {continue} lappend LesRequetesAvecUnLien $Requete lappend LesGODeLAccess [string toupper $GO] } } } set TabLesLiensPourLaGeneOntology(Access,$Access,LesRequetes) [lsort -unique $LesRequetesAvecUnLien] set LesGO [lsort -unique $LesGODeLAccess] foreach GO $LesGO {lappend LesGOSelectionnes [string toupper $GO]} foreach GO [concat $LesGO [lsort -unique [TousLesAncetresGODesGO $LesGO]]] { if {![info exists TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess)]} {set TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess) {}} lappend TabLesLiensPourLaGeneOntology(GO,$GO,LesAccess) $Access } } foreach Requete [set TabLesLiensPourLaGeneOntology(LesRequetes)] { regsub "EC |EC:" $Requete "" Requete Espionne "Domains or Keywords : $Requete" set LesGODeLaRequete {} foreach GO [2GO $Requete LesLiens] { foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {$GO == ""} {continue} lappend LesGOSelectionnes [string toupper $GO] } } foreach GO [lsort -unique [concat [2GO $Requete LesLiens] [TousLesAncetresGODesGO [2GO $Requete LesLiens]]]] { foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {$GO == ""} {continue} if {![info exists TabLesLiensPourLaGeneOntology(GO,$GO,LesRequetes)]} {set TabLesLiensPourLaGeneOntology(GO,$GO,LesRequetes) {}} lappend TabLesLiensPourLaGeneOntology(GO,$GO,LesRequetes) $Requete } } } foreach GO [set TabLesLiensPourLaGeneOntology(LesGO)] { Espionne "GO term : $GO" foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {$GO == ""} {continue} lappend LesGOSelectionnes [string toupper $GO] } } set LesGOSelectionnes [EnterrerLesAncetresGO [lsort -unique $LesGOSelectionnes]] set TabLesLiensPourLaGeneOntology(LesGO) $LesGOSelectionnes return $LesGOSelectionnes } if {[string equal -nocase $FirstElet "append"]} { set QuelTypeDEntryPourLaGeneOntology [string trim [lindex $args 1]] set QuelEntryPourLaGeneOntology [string trim [lindex $args 2]] if {$QuelEntryPourLaGeneOntology == "" || $QuelTypeDEntryPourLaGeneOntology == ""} {return} if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "GO term"]} { lappend TabLesLiensPourLaGeneOntology(LesGO) $QuelEntryPourLaGeneOntology } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "GO term file"]} { if {![file exists $QuelEntryPourLaGeneOntology]} {return} foreach GO [DrawEntreDeux [LesLignesDuFichier $QuelEntryPourLaGeneOntology]] { scan $GO "%s" GO lappend TabLesLiensPourLaGeneOntology(LesGO) $GO } } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Access"]} { lappend TabLesLiensPourLaGeneOntology(LesAccess) $QuelEntryPourLaGeneOntology } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Access file"]} { if {![file exists $QuelEntryPourLaGeneOntology]} {return} foreach Access [DrawEntreDeux [LesLignesDuFichier $QuelEntryPourLaGeneOntology]] { scan $Access "%s" Access lappend TabLesLiensPourLaGeneOntology(LesAccess) $Access } } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Links2GO (Domains, Keywords)"]} { lappend TabLesLiensPourLaGeneOntology(LesRequetes) $QuelEntryPourLaGeneOntology } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Blast file" ]} { foreach Access [DrawChoixDesHitsDuBlast $QuelEntryPourLaGeneOntology] { lappend TabLesLiensPourLaGeneOntology(LesAccess) $Access } } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Clustering file"]} { foreach Access [DrawChoixDesHitsDuClustering $QuelEntryPourLaGeneOntology] { lappend TabLesLiensPourLaGeneOntology(LesAccess) $Access } } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "MSF file" ]} { foreach Access [DrawChoixDesHitsDuMSF $QuelEntryPourLaGeneOntology] { Espionne $Access lappend TabLesLiensPourLaGeneOntology(LesAccess) $Access } } if {[string equal -nocase $QuelTypeDEntryPourLaGeneOntology "Gscope GO file" ]} { foreach LaBoiteGscope [DrawChoixDesBoitesDuProjetGscope $QuelEntryPourLaGeneOntology] { lappend TabLesLiensPourLaGeneOntology(LesBoitesGscope) $LaBoiteGscope } } return } if {[string equal -nocase $FirstElet "ask"]} { set args [join [lrange $args 1 end] ","] if {$args == "" || ![info exists TabLesLiensPourLaGeneOntology($args)]} {return} return [set TabLesLiensPourLaGeneOntology($args)] } return } proc GPG {{Qui ""} {Quoi ""}} { global GPG if {$Quoi=="pk_gpaintgene"} { set Quoi "pk" } if {[info exists GPG($Qui,$Quoi)]} { return $GPG($Qui,$Quoi) } if {[info exists GPG("EstCharge")]} { return "" } set GPG("EstCharge") 1 CanalSqlGenoret #rR attention pk_gpaintgene devient pk set Headers "pk_gpaintgene gpid name description accessnum entrezid rnaprobe orientation hybridtemp washtemp stage strain sectionplane resol dissecdate dissectime textoriginal" set Sql "select * from imanno.gpaintgene" set R [SqlExec $Sql "GetList"] set GPG(ListOf,keys) [list pk gpid name accessnum entrezid rnaprobe description] set Bidon 12345 set Seed 12345; expr srand($Seed) set Method "SRAND" set GPG(ListOf,Random) {} foreach {pk gpid name description accessnum entrezid rnaprobe orientation hybridtemp washtemp stage strain sectionplane resol dissecdate dissectime textoriginal} $R { if {$Method=="SRAND"} { set Random [expr rand()] while {[info exists DejaVu($Random)]} { set Random [expr rand()] } } else { if {$entrezid=="" || $rnaprobe=="" || [regexp {[^0-9]} $entrezid] || [regexp {[^0-9]} $rnaprobe]} { set Random [expr [incr Bidon]*13+[incr Bidon]*7] } else { set Random [expr $entrezid*13+$rnaprobe*7] } set Random [string range $Random 1 end-1] while {[info exists DejaVu($Random)]} { Espionne "Rand deja vu $Random" ; set Random [expr $Random*17] } } set DejaVu($Random) 1 lappend GPG(ListOf,Random) $Random if {[info exists DejaVu($name)]} { FaireLire "DejaVu $name" } foreach K $GPG(ListOf,keys) { set GPG($pk,$K) [set $K] set GPG($name,$K) [set $K] lappend GPG(ListOf,$K) [set $K] } set GPG($Random) $pk } set GPG(ListOf,Random) [lsort $GPG(ListOf,Random)] foreach K $GPG(ListOf,keys) { set GPG(ListOf,$K) [lsort -unique $GPG(ListOf,$K)] } lappend GPG(ListOf,keys) nom set LesRandomises {} set I 10000 foreach Random $GPG(ListOf,Random) { set pk $GPG($Random) incr I 10 set nom [format "IA%5.5d" $I] set GPG($pk,nom) $nom set LesValeurs {} foreach K $GPG(ListOf,keys) { lappend LesValeurs $GPG($pk,$K) } lappend GPG(ListOf,NomName) "$GPG($pk,nom) $GPG($pk,name)" lappend LesRandomises $LesValeurs } set GPG(Get,All) $LesRandomises CanalSqlDisconnect return [GPG $Qui $Quoi] } proc GPL13607GPL14550 {} { #est ce que toutes les ps de GPL13607 se retrouvent bien dans GPL14550 set First "[HomeRipp]/GxHome/AgilentAnnot/GPL13607_family.soft" set Second "[HomeRipp]/GxHome/AgilentAnnot/GPL14550_family.soft" set LetsGo 0 set PremiereFois 1 set S [open $Second r] while {[gets $S Ligne] >= 0} { if {[regexp "^!platform_table_begin" $Ligne]} {set LetsGo 1; continue} if {[regexp "^!platform_table_end" $Ligne]} {break} if {!$LetsGo} {continue} if {$PremiereFois} { set PremiereFois 0 continue } set LesMots [split $Ligne "\t"] set PsS [lindex $LesMots 1] set VuDansS($PsS) 1 } set LetsGo 0 set PremiereFois 1 set F [open $First r] while {[gets $F Ligne] >= 0} { if {[regexp "^!platform_table_begin" $Ligne]} {set LetsGo 1; continue} if {[regexp "^!platform_table_end" $Ligne]} {break} if {!$LetsGo} {continue} if {$PremiereFois} { set PremiereFois 0 continue } set LesMots [split $Ligne "\t"] set PsF [lindex $LesMots 1] if {![info exists VuDansS($PsF)]} { Espionne "on trouve pas $PsF"} } } proc GPO {LesGODeIPO LesGODePPO LesGODeMSO} { #OUT = [list GOTerm1 GOTerm2 ....] #GPO Global Protein Ontology set LesGOSelected {} foreach GO [EnterrerLesAncetresGO [lsort -unique [concat $LesGODeIPO $LesGODePPO $LesGODeMSO]]] { foreach Type [GODB GO $GO LesTypes] { set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] lappend LesGOSelected [list $GO $Type $Def 0 $Def] } } return [lsort -index 1 $LesGOSelected] } proc GPS {Path {GPStype VDR} {Organisme human} {Typegene all} {Database pureGene} {Limite 2000}} { # Prend le gène le plus proche des SBS , qu'importe le sens, en 3' ou en 5', et recalcule la distance au TSS en vu d'un mapping # V2.0 : Génère au préalable toutes les requétes BIRD, les envoie, puis les traite #Compteurs : set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Start" set CompteurLus 0 set CompteurImprobables 0 set CompteurAmont 0 set CompteurIn 0 set Ecrit 0 set CompteurExons 0 set LigneP "" set LigneG "" set FirstTime "Oui" set Moins "-" set Plus "+" # Générer les requetes à partir des coordonnées # ============================================= set FichierDesCoordonnees [open "$Path.coo" "r"] set FichierDesRequetes [open "/tmp/$Path.bql" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Building queries" #Premiere requetes a DOPA pour savoir quels organismes elle contient puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT DISTINCT(ali_organismet) FROM ucsc$Organisme.alignements ORDER BY ali_organismet ASC" puts $FichierDesRequetes "#" set queryCount 1 while { [gets $FichierDesCoordonnees LigneCoordonnees] >=0 } { set LigneCoordonnees [string trim $LigneCoordonnees] if {$GPStype == "VDR"} { ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH MM1 MM2 SequenceH set DR [lindex [regexp -inline {\DR[0-6]} $Path] 0] } if {$GPStype == "STAF"} { ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH ActacaH SequenceH ScoreH UpstreamH DownstreamH } if {$GPStype == "Classic"} { ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH } if { $Typegene == "protein" } { set Operateur "=" set Operand "\'protein\'" } if { $Typegene == "noncoding" } { set Operateur "<>" set Operand "\'Protein\'" } if { $Typegene == "all" } { set Operateur "<>" set Operand "' '" } if {[lindex [string range $ChromosomeH 0 0] 0] != "c" } { set Chromosome "chr$ChromosomeH" } else { set Chromosome "$ChromosomeH" } #In puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.$Database WHERE chrom='$Chromosome' and txStart<=$StartH and txEnd>=$EndH and typegene$Operateur$Operand and pseudogene='no' ORDER BY txStart DESC fetch first 1 rows only" puts $FichierDesRequetes "//" #AP puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.$Database WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Plus' and typegene$Operateur$Operand and pseudogene='no' ORDER BY txSTART ASC fetch first 1 rows only" puts $FichierDesRequetes "//" #AI puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.$Database WHERE chrom='$Chromosome' and $EndH<=txStart and strand='$Moins' AND typegene$Operateur$Operand and pseudogene='no' ORDER BY txSTART ASC fetch first 1 rows only" puts $FichierDesRequetes "//" #BI puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.$Database WHERE chrom='$Chromosome' and $StartH>=txEnd and strand='$Plus' AND typegene$Operateur$Operand and pseudogene='no' ORDER BY txEND DESC fetch first 1 rows only" puts $FichierDesRequetes "//" #BP puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.$Database WHERE chrom='$Chromosome' and $StartH>=txEnd and strand='$Moins' AND typegene$Operateur$Operand and pseudogene='no' ORDER BY txEND DESC fetch first 1 rows only" puts $FichierDesRequetes "//" #PHICS puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT * FROM ucsc$Organisme.alignements WHERE ali_chroq='$Chromosome' AND ali_startq <= $StartH AND ali_endq >= $EndH ORDER BY ali_genomet DESC" puts $FichierDesRequetes "//" set queryCount [expr $queryCount + 5] } close $FichierDesRequetes close $FichierDesCoordonnees # Envoyer et réceptionner les requetes # ==================================== set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Executing $queryCount queries" set FichierDesRequetes [open "/tmp/$Path.bql" "r"] exec /biolo/bird/bin/birdql_client.sh "/tmp/$Path.bql" "bird" "/tmp/$Path.res" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Deleting query file" file delete "/tmp/$Path.bql" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Parsing results" set FichierDesCoordonnees [open "$Path.coo" "r"] set FichierDesAccessFavorables [open "$Path.favo" "w"] set FichierTotal [open "$Path.csv" "w"] if {$GPStype == "VDR"} { set EnteteOut "BS|ID;BS|Type;BS|Chrom;BS|Start;BS|End;BS|strand;BS|Sequence;BS|repeat;BS|P1;BS|P2;BS|P3;BS|P4;BS|P5;BS|P6;BS|P7;BS|P8;BS|P9;BS|P10;BS|P11;BS|P12;NearestGene|Access;NearestGene|Start;NearestGene|End;NearestGene|Strand;NearestGene|ExonOuIntron;NearestGene|ExonOuIntronNum;NearestGene|UtrOuCDS;NearestGene|DebutExonOuIntron;NearestGene|FinExonOuIntron;NearestGene|DebutOuFinExonOuIntron;NearestGene|DistanceAlaBorneDeExonOuIntron;NearestGene|id;NearestGene|name;NearestGene|mRNA;NearestGene|spID;NearestGene|spDisplayID;NearestGene|geneSymbol;NearestGene|protAcc;NearestGene|description;NearestGene|typegene;NearestGene|pseudogene;NearestGene|span;NearestGene|spanloc;NearestGene|confidence;NearestGene|dTSS;GeneOnMinus|Access;GeneOnMinus|Start;GeneOnMinus|End;GeneOnMinus|strand;GeneOnMinus|id;GeneOnMinus|name;GeneOnMinus|mRNA;GeneOnMinus|spID;GeneOnMinus|spDisplayID;GeneOnMinus|geneSymbol;GeneOnMinus|protAcc;GeneOnMinus|description;GeneOnMinus|typegene;GeneOnMinus|pseudogene;GeneOnMinus|span;GeneOnMinus|spanloc;GeneOnMinus|confidence;GeneOnMinus|dTSS;GeneOnMinus|Guess;GeneOnPlus|Access;GeneOnPlus|Start;GeneOnPlus|End;GeneOnPlus|strand;GeneOnPlus|id;GeneOnPlus|name;GeneOnPlus|mRNA;GeneOnPlus|spID;GeneOnPlus|spDisplayID;GeneOnPlus|geneSymbol;GeneOnPlus|protAcc;GeneOnPlus|description;GeneOnPlus|typegene;GeneOnPlus|pseudogene;GeneOnPlus|span;GeneOnPlus|spanloc;GeneOnPlus|confidence;GeneOnPlus|dTSS;GeneOnPlus|Guess" } if {$GPStype == "STAF"} { set EnteteOut "BS|ID;BS|Chrom;BS|Start;BS|End;BS|strand;BS|Actaca;BS|Sequence;BS|Upstream;BS|Downstream;BS|Score;BS|LogScore;NearestGene|Access;NearestGene|Start;NearestGene|End;NearestGene|Strand;NearestGene|ExonOuIntron;NearestGene|ExonOuIntronNum;NearestGene|UtrOuCDS;NearestGene|DebutExonOuIntron;NearestGene|FinExonOuIntron;NearestGene|DebutOuFinExonOuIntron;NearestGene|DistanceAlaBorneDeExonOuIntron;NearestGene|id;NearestGene|name;NearestGene|mRNA;NearestGene|spID;NearestGene|spDisplayID;NearestGene|geneSymbol;NearestGene|protAcc;NearestGene|description;NearestGene|typegene;NearestGene|pseudogene;NearestGene|span;NearestGene|spanloc;NearestGene|confidence;NearestGene|dTSS;GeneOnMinus|Access;GeneOnMinus|Start;GeneOnMinus|End;GeneOnMinus|strand;GeneOnMinus|id;GeneOnMinus|name;GeneOnMinus|mRNA;GeneOnMinus|spID;GeneOnMinus|spDisplayID;GeneOnMinus|geneSymbol;GeneOnMinus|protAcc;GeneOnMinus|description;GeneOnMinus|typegene;GeneOnMinus|pseudogene;GeneOnMinus|span;GeneOnMinus|spanloc;GeneOnMinus|confidence;GeneOnMinus|dTSS;GeneOnMinus|Guess;GeneOnPlus|Access;GeneOnPlus|Start;GeneOnPlus|End;GeneOnPlus|strand;GeneOnPlus|id;GeneOnPlus|name;GeneOnPlus|mRNA;GeneOnPlus|spID;GeneOnPlus|spDisplayID;GeneOnPlus|geneSymbol;GeneOnPlus|protAcc;GeneOnPlus|description;GeneOnPlus|typegene;GeneOnPlus|pseudogene;GeneOnPlus|span;GeneOnPlus|spanloc;GeneOnPlus|confidence;GeneOnPlus|dTSS;GeneOnPlus|Guess" } if {$GPStype == "Classic"} { set EnteteOut "BS|ID;BS|Chrom;BS|Start;BS|End;BS|strand;NearestGene|Access;NearestGene|Start;NearestGene|End;NearestGene|Strand;NearestGene|ExonOuIntron;NearestGene|ExonOuIntronNum;NearestGene|UtrOuCDS;NearestGene|DebutExonOuIntron;NearestGene|FinExonOuIntron;NearestGene|DebutOuFinExonOuIntron;NearestGene|DistanceAlaBorneDeExonOuIntron;NearestGene|id;NearestGene|name;NearestGene|mRNA;NearestGene|spID;NearestGene|spDisplayID;NearestGene|geneSymbol;NearestGene|protAcc;NearestGene|description;NearestGene|typegene;NearestGene|pseudogene;NearestGene|span;NearestGene|spanloc;NearestGene|confidence;NearestGene|dTSS;GeneOnMinus|Access;GeneOnMinus|Start;GeneOnMinus|End;GeneOnMinus|strand;GeneOnMinus|id;GeneOnMinus|name;GeneOnMinus|mRNA;GeneOnMinus|spID;GeneOnMinus|spDisplayID;GeneOnMinus|geneSymbol;GeneOnMinus|protAcc;GeneOnMinus|description;GeneOnMinus|typegene;GeneOnMinus|pseudogene;GeneOnMinus|span;GeneOnMinus|spanloc;GeneOnMinus|confidence;GeneOnMinus|dTSS;GeneOnMinus|Guess;GeneOnPlus|Access;GeneOnPlus|Start;GeneOnPlus|End;GeneOnPlus|strand;GeneOnPlus|id;GeneOnPlus|name;GeneOnPlus|mRNA;GeneOnPlus|spID;GeneOnPlus|spDisplayID;GeneOnPlus|geneSymbol;GeneOnPlus|protAcc;GeneOnPlus|description;GeneOnPlus|typegene;GeneOnPlus|pseudogene;GeneOnPlus|span;GeneOnPlus|spanloc;GeneOnPlus|confidence;GeneOnPlus|dTSS;GeneOnPlus|Guess" } set FichierDesRequetesExecutees [open "/tmp/$Path.res" "r"] # Recuperation des divers organismes de Dopa en prévision des enetetes @L gets $FichierDesRequetesExecutees EntetePHICS set Organismes {} while {[gets $FichierDesRequetesExecutees organism] >= 0} { set isQuery [string range $organism 0 4] if { $isQuery != "Query"} { if { $GPStype == "Classic"} { set EnteteOut "$EnteteOut;$organism|genome;$organism|chrom;$organism|start;$organism|end;$organism|strand;$organism|sequence" } if { $GPStype == "STAF"} { set EnteteOut "$EnteteOut;$organism|genome;$organism|chrom;$organism|start;$organism|end;$organism|strand;$organism|BestProbScoreSeq;$organism|proba;$organism|ProbShift;$organism|BestLogScoreSeq;$organism|logScore;$organism|LogShift;$organism|DDLS" } if { $GPStype == "VDR"} { set EnteteOut "$EnteteOut;$organism|genome;$organism|chrom;$organism|start;$organism|end;$organism|strand;$organism|BestProbScoreSeq;$organism|proba;$organism|ProbShift" } set TableauP($organism,genomet) "@" set TableauP($organism,chroT) "@" set TableauP($organism,StartT) "@" set TableauP($organism,EndT) "@" set TableauP($organism,strandT) "@" set TableauP($organism,sequenceEvalueeProba) "@" set TableauP($organism,scoreTarget) "@" set TableauP($organism,decalageProba) "@" set TableauP($organism,sequenceEvalueeLog) "@" set TableauP($organism,logScoreTarget) "@" set TableauP($organism,decalageLog) "@" set TableauP($organism,DDLS) "@" lappend Organismes $organism } else { break } } puts $FichierTotal $EnteteOut # Suppressions des éventuelles versions précédentes des fichiers # ============================================================== #Balayage du fichier de coordonées en entrée. Chaque lecture entraine 5 lectures du fichier de résultat BQL (1 "IN", 2 "Before" et 2 "After") set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Scanning coordinates" set bs 0 while { [gets $FichierDesCoordonnees LigneCoordonnees] >=0 } { #Initialisations #--------------- set Separator ";" set LocAI "EMPTY" set LocAI2 "EMPTY" set accessAI "@" set txStartAI "@" set txEndAI "@" set strandAI "@" set LocAP "EMPTY" set LocAP2 "EMPTY" set accessAP "@" set txStartAP "@" set txEndAP "@" set strandAP "@" set LocBI "EMPTY" set LocBI2 "EMPTY" set accessBI "@" set txStartBI "@" set txEndBI "@" set strandBI "@" set LocBP "EMPTY" set LocBP2 "EMPTY" set accessBP "@" set txStartBP "@" set txEndBP "@" set strandBP "@" set LocIn "EMPTY" set AccIn "@" set txStartIn "@" set txEndIn "@" set OrientationIn "@" set ExonOuIntron "@" set UtrOuCDS "@" set DebutExonOuIntron "@" set FinExonOuIntron "@" set DebutOuFinExonOuIntron "@" set DistanceAlaBorneDeExonOuIntron "@" set descriptionBI "@" set descriptionBP "@" set descriptionAI "@" set descriptionBP "@" set descriptionIn "@" #Staf: #---- #ScanLaListe $LigneCoordonnees DR ID ChromosomeH StartH EndH OrientationH SequenceH Score NbMismatch Mismatchs if {$GPStype == "VDR"} { set P1 "N" set P2 "N" set P3 "N" set P4 "N" set P5 "N" set P6 "N" set P7 "N" set P8 "N" set P9 "N" set P10 "N" set P11 "N" set P12 "N" ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH MM1 MM2 SequenceH if {[regexp {[a t c g N]} $SequenceH]} { set repeat "Y" } else { set repeat "N" } set DR [lindex [regexp -inline {DR[0-6]} $Path] 0] Espionne "DR$DR" set Nb1 [lindex [split $MM1 "@"] 0] set Nb2 [lindex [split $MM2 "@"] 0] if {$Nb1 == 1} { set Position1MM1 [lindex [split [lindex [split $MM1 "@"] 1] "/"] 1] set P$Position1MM1 "O" } if {$Nb1 == 2} { set Position1MM1 [lindex [split [lindex [split $MM1 "@"] 1] "/"] 1] set P$Position1MM1 "O" set Position2MM1 [lindex [split [lindex [split $MM1 "@"] 1] "/"] 2] set P$Position2MM1 "O" } if {$Nb2 == 1} { set Position1MM2 [lindex [split [lindex [split $MM1 "@"] 1] "/"] 1] set P$Position1MM2 "O" } if {$Nb1 == 2} { set Position1MM2 [lindex [split [lindex [split $MM2 "@"] 1] "/"] 1] set Position1MM2 [expr $Position1MM2 + 6] set P$Position1MM2 "O" set Position2MM2 [lindex [split [lindex [split $MM2 "@"] 1] "/"] 2] set Position2MM2 [expr $Position2MM2 + 6] set P$Position2MM2 "O" } set mistakeMap "$P1;$P2;$P3;$P4;$P5;$P6;$P7;$P8;$P9;$P10;$P11;$P12" set LigneCoordonnees "$ID $ChromosomeH $StartH $EndH $OrientationH $SequenceH $mistakeMap" } #GPS CLASSIC: if {$GPStype == "STAF"} { ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH ActacaH SequenceH ScoreH UpstreamH DownstreamH set LogScoreH [StafLogScoreFunction $SequenceH] } if {$GPStype == "Classic"} { ScanLaListe $LigneCoordonnees ID ChromosomeH StartH EndH OrientationH } regsub -all -nocase "," $LigneCoordonnees "." LigneCoordonnees #Resultats du In #--------------- if {[info exist LigneResultat]} { ScanLaListe $LigneResultat QueryIDin regsub -all -nocase {Query\[|\]} $QueryIDin "" QueryIDin } gets $FichierDesRequetesExecutees LigneResultat if { $LigneResultat != "EMPTY" } { ScanLaPipe $LigneResultat binIn accessIn chromIn strandIn txStartIn txEndIn cdsStartIn cdsEndIn exonCountIn exonStartsIn exonEndsIn idIn name2In cdsStartStatIn cdsEndStatIn exonFramesIn nameIn mRNAIn spIDIn spDisplayIDIn geneSymbolIn refseqIn protAccIn descriptionIn typegeneIn pseudogeneIn spanIn spanlocIn confidenceIn referenceIn regsub -all -nocase {[\s;\|\(\)]} $descriptionIn "." descriptionIn regsub -all -nocase {[\s;\|\(\)]} $confidenceIn "." confidenceIn regsub -all -nocase {[\s;\|\(\)]} $spanIn "." spanIn regsub -all -nocase {[\s;\|\(\)]} $spanlocIn "." spanlocIn if { $typegeneIn == "protein" } { set LocIne "$accessIn;$chromIn;$txStartIn;$txEndIn;$strandIn;$exonStartsIn;$exonEndsIn;$exonCountIn;$cdsStartIn;$cdsEndIn" set LocInBQL [LocInBQL $StartH $LocIne $Separator] set LocIn "$LocInBQL;$idIn;$name2In;$mRNAIn;$spIDIn;$spDisplayIDIn;$geneSymbolIn;$protAccIn;$descriptionIn;$typegeneIn;$pseudogeneIn;$spanIn;$spanlocIn;$confidenceIn" } else { set LocIn "$accessIn;$txStartIn;$txEndIn;$strandIn;@;@;@;@;@;@;@;$idIn;$name2In;@;@;@;@;@;$descriptionIn;$typegeneIn;$pseudogeneIn;$spanIn;$spanlocIn;$confidenceIn" } } else { set LocIn "EMPTY" set accessIn "@" set txStartIn "999999999999" set txEndIn "999999999999" set strandIn "@" set idIn "@" set name2In "@" set descriptionIn "@" set typegeneIn "@" set pseudogeneIn "@" set spanIn "@" set spanlocIn "@" set confidenceIn "@" } #Resultats du AP #--------------- gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat QueryIDBeforeI gets $FichierDesRequetesExecutees LigneResultat if { $LigneResultat != "EMPTY" } { ScanLaPipe $LigneResultat binAP accessAP chromAP strandAP txStartAP txEndAP cdsStartAP cdsEndAP exonCountAP exonStartsAP exonEndsAP idAP name2AP cdsStartStatAP cdsEndStatAP exonFramesAP nameAP mRNAAP spIDAP spDisplayIDAP geneSymbolAP refseqAP protAccAP descriptionAP typegeneAP pseudogeneAP spanAP spanlocAP confidenceAP referenceAP regsub -all -nocase {[\s;\|\(\)]} $descriptionAP "." descriptionAP regsub -all -nocase {[\s;\|\(\)]} $confidenceAP "." confidenceAP regsub -all -nocase {[\s;\|\(\)]} $spanAP "." spanAP regsub -all -nocase {[\s;\|\(\)]} $spanlocAP "." spanlocAP if { $typegeneAP != "protein" && $typegeneAP != "Protein"} { set LocAP "$accessAP;$txStartAP;$txEndAP;$strandAP;$idAP;$name2AP;@;@;@;@;@;$descriptionAP;$typegeneAP;$pseudogeneAP;$spanAP;$spanlocAP;$confidenceAP" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocAP2 "$accessAP;$txStartAP;$txEndAP;$strandAP;@;@;@;@;@;@;@;$idAP;$name2AP;@;@;@;@;@;$descriptionAP;$typegeneAP;$pseudogeneAP;$spanAP;$spanlocAP;$confidenceAP" } else { set LocAP "$accessAP;$txStartAP;$txEndAP;$strandAP;$idAP;$name2AP;$mRNAAP;$spIDAP;$spDisplayIDAP;$geneSymbolAP;$protAccAP;$descriptionAP;$typegeneAP;$pseudogeneAP;@;@;@" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocAP2 "$accessAP;$txStartAP;$txEndAP;$strandAP;@;@;@;@;@;@;@;$idAP;$name2AP;$mRNAAP;$spIDAP;$spDisplayIDAP;$geneSymbolAP;$protAccAP;$descriptionAP;$typegeneAP;$pseudogeneAP;@;@;@" } } else { set accessAP "@" set txStartAP "999999999999" set txEndAP "999999999999" set strandAP "@" set idAP "@" set name2AP "@" set descriptionAP "@" set typegeneAP "@" set pseudogeneAP "@" set spanAP "@" set spanlocAP "@" set confidenceAP "@" } #Resultats du AI #--------------- gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat QueryIDBeforeP gets $FichierDesRequetesExecutees LigneResultat if { $LigneResultat != "EMPTY" } { ScanLaPipe $LigneResultat binAI accessAI chromAI strandAI txStartAI txEndAI cdsStartAI cdsEndAI exonCountAI exonStartsAI exonEndsAI idAI name2AI cdsStartStatAI cdsEndStatAI exonFramesAI nameAI mRNAAI spIDAI spDisplayIDAI geneSymbolAI refseqAI protAccAI descriptionAI typegeneAI pseudogeneAI spanAI spanlocAI confidenceAI referenceAI regsub -all -nocase {[\s;\|\(\)]} $descriptionAI "." descriptionAI regsub -all -nocase {[\s;\|\(\)]} $confidenceAI "." confidenceAI regsub -all -nocase {[\s;\|\(\)]} $spanAI "." spanAI regsub -all -nocase {[\s;\|\(\)]} $spanlocAI "." spanlocAI if { $typegeneAI != "protein" } { set LocAI "$accessAI;$txStartAI;$txEndAI;$strandAI;$idAI;$name2AI;@;@;@;@;@;$descriptionAI;$typegeneAI;$pseudogeneAI;$spanAI;$spanlocAI;$confidenceAI" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocAI2 "$accessAI;$txStartAI;$txEndAI;$strandAI;@;@;@;@;@;@;@;$idAI;$name2AI;@;@;@;@;@;$descriptionAI;$typegeneAI;$pseudogeneAI;$spanAI;$spanlocAI;$confidenceAI" } else { set LocAI "$accessAI;$txStartAI;$txEndAI;$strandAI;$idAI;$name2AI;$mRNAAI;$spIDAI;$spDisplayIDAI;$geneSymbolAI;$protAccAI;$descriptionAI;$typegeneAI;$pseudogeneAI;@;@;@" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocAI2 "$accessAI;$txStartAI;$txEndAI;$strandAI;@;@;@;@;@;@;@;$idAI;$name2AI;$mRNAAI;$spIDAI;$spDisplayIDAI;$geneSymbolAI;$protAccAI;$descriptionAI;$typegeneAI;$pseudogeneAI;@;@;@" } } else { set accessAI "@" set txStartAI "999999999999" set txEndAI "999999999999" set strandAI "@" set idAI "@" set name2AP "@" set descriptionAI "@" set typegeneAI "@" set pseudogeneAI "@" set spanAI "@" set spanlocAI "@" set confidenceAI "@" } #Resultats du BI #--------------- gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat QueryIDAfterI gets $FichierDesRequetesExecutees LigneResultat if { $LigneResultat != "EMPTY" } { ScanLaPipe $LigneResultat binBI accessBI chromBI strandBI txStartBI txEndBI cdsStartBI cdsEndBI exonCountBI exonStartsBI exonEndsBI idBI name2BI cdsStartStatBI cdsEndStatBI exonFramesBI nameBI mRNABI spIDBI spDisplayIDBI geneSymbolBI refseqBI protAccBI descriptionBI typegeneBI pseudogeneBI spanBI spanlocBI confidenceBI referenceBI regsub -all -nocase {[\s;\|\(\)]} $descriptionBI "." descriptionBI regsub -all -nocase {[\s;\|\(\)]} $confidenceBI "." confidenceBI regsub -all -nocase {[\s;\|\(\)]} $spanBI "." spanBI regsub -all -nocase {[\s;\|\(\)]} $spanlocBI "." spanlocBI if { $typegeneBI != "protein" } { set LocBI "$accessBI;$txStartBI;$txEndBI;$strandBI;$idBI;$name2BI;@;@;@;@;@;$descriptionBI;$typegeneBI;$pseudogeneBI;$spanBI;$spanlocBI;$confidenceBI" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocBI2 "$accessBI;$txStartBI;$txEndBI;$strandBI;@;@;@;@;@;@;@;$$idBI;$name2BI;@;@;@;@;@;$descriptionBI;$typegeneBI;$pseudogeneBI;$spanBI;$spanlocBI;$confidenceBI" } else { set LocBI "$accessBI;$txStartBI;$txEndBI;$strandBI;$idBI;$name2BI;$mRNABI;$spIDBI;$spDisplayIDBI;$geneSymbolBI;$protAccBI;$descriptionBI;$typegeneBI;$pseudogeneBI;@;@;@" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocBI2 "$accessBI;$txStartBI;$txEndBI;$strandBI;@;@;@;@;@;@;@;$idBI;$name2BI;$mRNABI;$spIDBI;$spDisplayIDBI;$geneSymbolBI;$protAccBI;$descriptionBI;$typegeneBI;$pseudogeneBI;@;@;@" } } else { set accessBI "@" set txStartBI "999999999999" set txEndBI "999999999999" set strandBI "@" set idBI "@" set name2BI "@" set descriptionBI "@" set typegeneBI "@" set pseudogeneBI "@" set spanBI "@" set spanlocBI "@" set confidenceBI "@" } #Resultats du BP #---------------- gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat QueryIDAfterP gets $FichierDesRequetesExecutees LigneResultat if { $LigneResultat != "EMPTY" } { ScanLaPipe $LigneResultat binBP accessBP chromBP strandBP txStartBP txEndBP cdsStartBP cdsEndBP exonCountBP exonStartsBP exonEndsBP idBP name2BP cdsStartStatBP cdsEndStatBP exonFramesBP nameBP mRNABP spIDBP spDisplayIDBP geneSymbolBP refseqBP protAccBP descriptionBP typegeneBP pseudogeneBP spanBP spanlocBP confidenceBP referenceBP regsub -all -nocase {[\s;\|\(\)]} $descriptionBP "." descriptionBP regsub -all -nocase {[\s;\|\(\)]} $confidenceBP "." confidenceBP regsub -all -nocase {[\s;\|\(\)]} $spanBP "." spanBP regsub -all -nocase {[\s;\|\(\)]} $spanlocBP "." spanlocBP if { $typegeneBP != "protein" } { set LocBP "$accessBP;$txStartBP;$txEndBP;$strandBP;$idBP;$name2BP;@;@;@;@;@;$descriptionBP;$typegeneBP;$pseudogeneBP;$spanBP;$spanlocBP;$confidenceBP" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocBP2 "$accessBP;$txStartBP;$txEndBP;$strandBP;@;@;@;@;@;@;@;$idBP;$name2BP;@;@;@;@;@;$descriptionBP;$typegeneBP;$pseudogeneBP;$spanBP;$spanlocBP;$confidenceBP" } else { set LocBP "$accessBP;$txStartBP;$txEndBP;$strandBP;$idBP;$name2BP;$mRNABP;$spIDBP;$spDisplayIDBP;$geneSymbolBP;$protAccBP;$descriptionBP;$typegeneBP;$pseudogeneBP;@;@;@" #Duplication en laissant la place pour un comportement "LocIn" s'il gagne le combat CandidatProx set LocBP2 "$accessBP;$txStartBP;$txEndBP;$strandBP;@;@;@;@;@;@;@;$idBP;$name2BP;$mRNABP;$spIDBP;$spDisplayIDBP;$geneSymbolBP;$protAccBP;$descriptionBP;$typegeneBP;$pseudogeneBP;@;@;@" } } #Resultats de PHICS #------------------ gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat QueryIDPHICS gets $FichierDesRequetesExecutees LigneResultat set isQuery [string range $LigneResultat 0 4] while { $isQuery != "Query" && $isQuery != "" } { if {$isQuery != "EMPTY"} { set TableauP($organism,genomet) "@" set TableauP($organism,chroT) "@" set TableauP($organism,StartT) "@" set TableauP($organism,EndT) "@" set TableauP($organism,strandT) "@" set TableauP($organism,sequenceEvalueeProba) "@" set TableauP($organism,scoreTarget) "@" set TableauP($organism,decalageProba) "@" set TableauP($organism,sequenceEvalueeProba) "@" if { $GPStype == "STAF"} { set TableauP($organism,logScoreTarget) "@" set TableauP($organism,decalageLog) "@" set TableauP($organism,DDLS) "@" } set genomet "@" set chroT "@" set StartT "@" set EndT "@" set strandT "@" set sequenceTargetDesiree "@" set sequenceEvalueeProba "@" set sequenceEvalueeLog "@" set scoreTarget "@" set decalageProba "@" set logScoreTarget "@" set decalageLog "@" set DDLS "@" set sequenceG "@" set sequenceD "@" ScanLaPipe $LigneResultat access genomeq genomet id organismet chroq startq endq chrot startt endt strandt score sequenceq sequencet #On positionne la sequence query comme si elle ne contenait pas de gaps set startDansAliIdeal [expr $StartH - $startq] set longueurQuery [expr $EndH - $StartH + 1] set sequenceAvantQueryIdeale [string range $sequenceq 0 [expr $startDansAliIdeal - 1]] set nbGapsAvantQueryIdeale 0 set nbGapstotal 0 #Astuce : On remplace les gaps par des gaps, en utilisant un compteur pour savoir combien il y en a avant ce start idéal. # Ce nombre permettra de se deplacer d'autant vers la droite pour se positionner correctement. #Au fur et a mesure qu'on avance dans la sequence pour enlever les gaps on continue de les compter et d'avancer dans la sequence set nbGapsAvantQueryIdeale [regexp -all -nocase {\-} $sequenceAvantQueryIdeale] set startDecaleDansAli [expr $startDansAliIdeal + $nbGapsAvantQueryIdeale] set nbGapstotal $nbGapsAvantQueryIdeale set nbGapstrans $nbGapstotal set condition "TRUE" while {$condition == "TRUE"} { set nbGapsAvantQueryIdeale 0 set sequenceAvantQueryIdeale [string range $sequenceq 0 [expr $startDecaleDansAli - 1]] set nbGapsAvantQueryIdeale [regexp -all -nocase {\-} $sequenceAvantQueryIdeale] set nbGapstotal $nbGapsAvantQueryIdeale if {$nbGapstotal == $nbGapstrans} { set sequenceQueryDecalee [string range $sequenceq $startDecaleDansAli [expr $startDecaleDansAli + $longueurQuery -1]] set condition "FALSE" } else { set nbGapstrans $nbGapstotal set startDecaleDansAli [expr $startDansAliIdeal + $nbGapsAvantQueryIdeale] } } # Il se peut toujours qu'on tombe sur un gap en première instance. # Donc on se ballade sur cette nouvelle query et on compte le nombre de gaps qu'on rencontre avant de trouver une reelle base set nbGapsAuDebutQueryDecalee 0 for {set c 0} {$c < $longueurQuery} {incr c} { set base [string range $sequenceQueryDecalee $c $c] if {$base == "-"} { incr nbGapsAuDebutQueryDecalee } else { break } } # Enfin le bon start : set startQueryDecaleeSansGapsAuDepart [expr $startDecaleDansAli + $nbGapsAuDebutQueryDecalee] # ... mais pas tout a fait la bonne sequence... set sequenceQueryDecaleeAvecBonStart [string range $sequenceq $startQueryDecaleeSansGapsAuDepart [expr $startQueryDecaleeSansGapsAuDepart + $longueurQuery - 1]] # ... en effet, il peut demeurer des gaps dans la query, rien de bien grave mais ça décale le "end" # donc on compte ces gaps: set nbGapsDansQueryDecaleeAvecBonStart 0 set nbGapsDansQueryDecaleeAvecBonStart [regexp -all -nocase {\-} $sequenceQueryDecaleeAvecBonStart] # et voila le bon End: set longueurCorrecte [expr $longueurQuery + $nbGapsDansQueryDecaleeAvecBonStart] # Du coup, la bonne sequence query finale devient : set sequenceQueryDesiree [string range $sequenceq $startQueryDecaleeSansGapsAuDepart [expr $startQueryDecaleeSansGapsAuDepart + $longueurCorrecte - 1]] set sequenceQueryDesiree [string toupper $sequenceQueryDesiree] if { $nbGapsDansQueryDecaleeAvecBonStart > 0 } { set precisionGapsHuman $nbGapsDansQueryDecaleeAvecBonStart } else { set precisionGapsHuman "" } # Protocole inverse pour la target : on commence par recuperer la sequence alignee avec le bon start set sequenceTargetDesiree [string toupper [string range $sequencet $startQueryDecaleeSansGapsAuDepart [expr $startQueryDecaleeSansGapsAuDepart + $longueurQuery - 1]]] set sequenceG [string toupper [string range $sequencet [expr $startQueryDecaleeSansGapsAuDepart - 1 ] [expr $startQueryDecaleeSansGapsAuDepart + $longueurQuery - 2]]] set sequenceD [string toupper [string range $sequencet [expr $startQueryDecaleeSansGapsAuDepart + 1 ] [expr $startQueryDecaleeSansGapsAuDepart + $longueurQuery]]] set sequenceTargetDesireeR [NucToReverseAndComplementNuc $sequenceTargetDesiree] set sequenceGR [NucToReverseAndComplementNuc $sequenceG] set sequenceDR [NucToReverseAndComplementNuc $sequenceD] regsub -all {\-} $sequenceTargetDesiree "_" sequenceTargetDesiree regsub -all {\-} $sequenceG "_" sequenceG regsub -all {\-} $sequenceD "_" sequenceD regsub -all {\-} $sequenceTargetDesireeR "_" sequenceTargetDesireeR regsub -all {\-} $sequenceGR "_" sequenceGR regsub -all {\-} $sequenceDR "_" sequenceDR # Scoring set decalageProba "C" set sequenceEvalueeProba $sequenceTargetDesiree if {$GPStype == "STAF"} { set scoreTarget [StafScoreFunctionFois $sequenceTargetDesiree] set scoreG [StafScoreFunctionFois $sequenceG] set scoreD [StafScoreFunctionFois $sequenceD] set scoreTargetR [StafScoreFunctionFois $sequenceTargetDesireeR] set scoreGR [StafScoreFunctionFois $sequenceGR] set scoreDR [StafScoreFunctionFois $sequenceDR] set logScoreTarget [StafLogScoreFunction $sequenceTargetDesiree] set logScoreG [StafLogScoreFunction $sequenceG] set logScoreD [StafLogScoreFunction $sequenceD] set logScoreTargetR [StafLogScoreFunction $sequenceTargetDesireeR] set logScoreGR [StafLogScoreFunction $sequenceGR] set logScoreDR [StafLogScoreFunction $sequenceDR] if {$logScoreTarget <$logScoreTarget && ![regexp -all -nocase {\-} $sequenceTargetDesireeR]} { set logScoreTarget $logScoreTargetR set decalageLog "R" set sequenceEvalueeLog $sequenceTargetDesireeR } if {$logScoreTarget < $logScoreG && ![regexp -all -nocase {\-} $sequenceG]} { set logScoreTarget $logScoreG set decalageLog "G" set sequenceEvalueeLog $sequenceG } if {$logScoreTarget < $logScoreD && ![regexp -all -nocase {\-} $sequenceD]} { set logScoreTarget $logScoreD set decalageLog "D" set sequenceEvalueeLog $sequenceD } if {$logScoreTarget < $logScoreGR && ![regexp -all -nocase {\-} $sequenceGR]} { set logScoreTarget $logScoreGR set decalageLog "GR" set sequenceEvalueeLog $sequenceGR } if {$logScoreTarget < $logScoreDR && ![regexp -all -nocase {\-} $sequenceDR]} { set logScoreTarget $logScoreDR set decalageLog "DR" set sequenceEvalueeLog $sequenceDR } } if {$GPStype == "VDR"} { Espionne "yataaa" flush stdout set scoreTarget [lindex [split [RGKTSA $sequenceTargetDesiree $DR] " "] 0] set scoreG [lindex [split [RGKTSA $sequenceG $DR] " "] 0] set scoreD [lindex [split [RGKTSA $sequenceD $DR] " "] 0] set scoreTargetR [lindex [split [RGKTSA $sequenceTargetDesireeR $DR] " "] 0] set scoreGR [lindex [split [RGKTSA $sequenceGR $DR] " "] 0] set scoreDR [lindex [split [RGKTSA $sequenceDR $DR] " "] 0] if {$scoreTarget < $scoreTargetR && ![regexp -all -nocase {\-} $sequenceTargetDesireeR] } { set scoreTarget $scoreTargetR set decalageProba "R" set sequenceEvalueeProba $sequenceTargetDesireeR } if {$scoreTarget < $scoreG && ![regexp -all -nocase {\-} $sequenceG] } { set scoreTarget $scoreG set decalageProba "G" set sequenceEvalueeProba $sequenceG } if {$scoreTarget < $scoreD && ![regexp -all -nocase {\-} $sequenceD]} { set scoreTarget $scoreD set decalageProba "D" set sequenceEvalueeProba $sequenceD } if {$scoreTarget < $scoreGR && ![regexp -all -nocase {\-} $sequenceGR] } { set scoreTarget $scoreGR set decalageProba "GR" set sequenceEvalueeProba $sequenceGR } if {$scoreTarget < $scoreDR && ![regexp -all -nocase {\-} $sequenceDR]} { set scoreTarget $scoreDR set decalageProba "DR" set sequenceEvalueeProba $sequenceDR } } # et la sequence qui la précède pour compter les gaps : set sequenceTargetAvantDesiree [string range $sequencet 0 $startQueryDecaleeSansGapsAuDepart] set nbGapsAvantTarget 0 set nbGapsAvantTarget [regexp -all -nocase {\-} $sequenceTargetAvantDesiree] # Si on tombe sur un Gap, on prend la coordonnee d'avant # Le reel Start de la target devient (CM = CH - GH - AH + AM - GM): set StartT [expr $StartH - $startq + $nbGapsAvantQueryIdeale + $nbGapsAuDebutQueryDecalee + $startt - $nbGapsAvantTarget] # pour connaitre le reel End fin de la target, il faut ajouter la longueur mais retirer les gaps interieurs eventuels, qu'il convient de calculer set nbGapsDansTarget [regexp -all -nocase {\-} $sequenceTargetDesiree] set EndT [ expr $StartT + $longueurQuery - $nbGapsDansTarget -1] set TableauP($organismet,genomet) $genomet set TableauP($organismet,chroT) $chrot set TableauP($organismet,StartT) $StartT set TableauP($organismet,EndT) $EndT set TableauP($organismet,strandT) $strandt regsub -all -nocase {\-} $sequenceTargetDesiree "Z" sequenceTargetDesiree set TableauP($organismet,sequenceEvalueeProba) $sequenceEvalueeProba set TableauP($organismet,scoreTarget) $scoreTarget set TableauP($organismet,decalageProba) $decalageProba if {$GPStype == "STAF"} { set TableauP($organismet,sequenceEvalueeLog) $sequenceEvalueeLog set TableauP($organismet,logScoreTarget) $logScoreTarget set TableauP($organismet,decalageLog) $decalageLog set TableauP($organismet,DDLS) [expr abs($LogScoreH - $logScoreTarget)] } gets $FichierDesRequetesExecutees LigneResultat set isQuery [string range $LigneResultat 0 4] } else { gets $FichierDesRequetesExecutees LigneResultat set isQuery [string range $LigneResultat 0 4] } } set LigneP "" foreach organism $Organismes { if {$GPStype == "STAF"} { set LigneP "$LigneP$TableauP($organism,genomet);$TableauP($organism,chroT);$TableauP($organism,StartT);$TableauP($organism,EndT);$TableauP($organism,strandT);$TableauP($organism,sequenceEvalueeProba);$TableauP($organism,scoreTarget);$TableauP($organism,decalageProba);$TableauP($organism,sequenceEvalueeLog);$TableauP($organism,logScoreTarget);$TableauP($organism,decalageLog);$TableauP($organism,DDLS);" } if {$GPStype == "Classic"} { set LigneP "$LigneP$TableauP($organism,genomet);$TableauP($organism,chroT);$TableauP($organism,StartT);$TableauP($organism,EndT);$TableauP($organism,strandT);$TableauP($organism,sequenceEvalueeProba);" } if {$GPStype == "VDR"} { set LigneP "$LigneP$TableauP($organism,genomet);$TableauP($organism,chroT);$TableauP($organism,StartT);$TableauP($organism,EndT);$TableauP($organism,strandT);$TableauP($organism,sequenceEvalueeProba);$TableauP($organism,scoreTarget);$TableauP($organism,decalageProba);" } } if { $LocAP == "EMPTY" || $LocAP == ""} { set txStartAP 999999999999999 set txEndAP 999999999999999 } if { $LocAI == "EMPTY" || $LocAI == ""} { set txStartAI 999999999999999 set txEndAI 999999999999999 } if { $LocBP == "EMPTY" || $LocBP == "" } { set txStartBP -99999999999999 set txEndBP -99999999999999 } if { $LocBI == "EMPTY" || $LocBI == "" } { set txStartBI -99999999999999 set txEndBI -99999999999999 } set DistanceBP [expr $StartH - $txEndBP] set DistanceBI [expr $StartH - $txEndBI] set DistanceAP [expr $txStartAP - $EndH] set DistanceAI [expr $txStartAI - $EndH] #Espionne "Tata $DistanceAP $DistanceBP $DistanceAI $DistanceBI" if { $DistanceAI >= $DistanceAP } { set DistanceAfter "-$DistanceAP" set DistanceAfterDeCalcul $DistanceAP set CandidatAfterBQL "$LocAP2;$DistanceAfter" } else { set DistanceAfter $DistanceAI set DistanceAfterDeCalcul $DistanceAI set CandidatAfterBQL "$LocAI2;$DistanceAfter" } if { $DistanceBI >= $DistanceBP } { set DistanceBefore "-$DistanceBP" set DistanceBeforeDeCalcul $DistanceBP set CandidatBeforeBQL "$LocBP2;$DistanceBefore" } else { set DistanceBefore $DistanceBI set DistanceBeforeDeCalcul $DistanceBI set CandidatBeforeBQL "$LocBI2;$DistanceBefore" } # Définition du candidat à la proximité # ------------------------------------- if { $LocIn == "EMPTY" || $LocIn == "" } { if { $DistanceBeforeDeCalcul > $DistanceAfterDeCalcul } { set CandidatProx $CandidatAfterBQL } else { set CandidatProx $CandidatBeforeBQL } } else { if {$OrientationIn == "-"} { set DistanceIn [expr $txEndIn - $StartH] } else { set DistanceIn [expr $StartH - $txStartIn] } set CandidatProx "$LocIn;$DistanceIn" if { $DistanceIn <= $Limite } { set LigneG "$CandidatProx" #regsub -all -nocase {\s} $LigneG "\t" LigneG puts $FichierDesAccessFavorables $LigneG } } # Définition des candidats à la régulation # ---------------------------------------- # Test si cette séquence régule le gène sur le brin + # --------------------------------------------------- if { $LocAP != "EMPTY" && $LocAP != "" } { set CandidatRegul1 "$LocAP;-$DistanceAP" if { $DistanceAP <= $Limite } { set Avis1 "Favorable" set LigneG "$CandidatRegul1" regsub -all -nocase {\s} $LigneG "\t" LigneG puts $FichierDesAccessFavorables $LigneG } else { set Avis1 "Unfavorable" } } else { set CandidatRegul1 "@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@" set Avis1 "@" } # Test si cette séquence régule le gène sur le brin - # --------------------------------------------------- if { $LocBP != "EMPTY" && $LocBP != "" } { set CandidatRegul2 "$LocBP;-$DistanceBP" if { $DistanceBP <= $Limite } { set Avis2 "Favorable" set LigneG "$CandidatRegul2" regsub -all -nocase {\s} $LigneG "\t" LigneG puts $FichierDesAccessFavorables $LigneG } else { set Avis2 "Unfavorable" } } else { set CandidatRegul2 "@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@;@" set Avis2 "@" } # On veut toujours le gène avant sur le brin moins et le gène aprés sur le brin plus. La procédure ne tient pas compte des orientations des gènes. Donc : # --> Si le SBS est en ori "-" : on veut le gène qui suit (pour la proc, le gène qui précéde en "-") et le gène qui débute (qui suit en "+" pour la proc) aprés sur l'autre brin. # --> Si le SBS eWhatIsMyUCSC est en ori "+" : on veut le gène qui suit (pour la proc, le gène qui suit en "+") et le gène qui débute (qui précéde en "-" pour la proc) avant sur l'autre brin. #Donc dans tous les cas, on veut le précédent "-" et le suivant "+". set LigneG "$CandidatProx;$CandidatRegul1;$Avis1;$CandidatRegul2;$Avis2" regsub -all -nocase {\t|\s} $LigneG " " LigneG if {$GPStype == "STAF"} { regsub -all -nocase {\-} $ActacaH "Z" ActacaH regsub -all -nocase {\-} $SequenceH "Z" SequenceH regsub -all -nocase {\-} $DownstreamH "Z" $DownstreamH regsub -all -nocase {\-} $UpstreamH "Z" UpstreamH puts $FichierTotal "$ID;$ChromosomeH;$StartH;$EndH;$OrientationH;$ActacaH;$SequenceH;$UpstreamH;$DownstreamH;$ScoreH;$LogScoreH;$LigneG;$LigneP" } if {$GPStype == "Classic"} { puts $FichierTotal "$ID;$ChromosomeH;$StartH;$EndH;$OrientationH;$LigneG;$LigneP" } if {$GPStype == "VDR"} { puts $FichierTotal "$ID;$DR;$ChromosomeH;$StartH;$EndH;$OrientationH;$SequenceH;$repeat;$mistakeMap;$LigneG;$LigneP" } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : Closing and deleting files" file delete "/tmp/$Path.res" close $FichierDesAccessFavorables close $FichierTotal set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|GPS : End" } proc GUIAgents {} { global NbSeq LNOrdali Sref iTag set iTag 0 #set ::Start 0 set ::DoStep 0 #set ::StepMode 1 set ::FaireLireNon 1 if {! $::WithGUI} { set ::Start 1 return } LoadTkAndPackages label .l -background black -foreground white -font "CourierNew 24 bold" -justify left -anchor w -textvariable ::Lab text .t -height $NbSeq -bd 2 -background black -foreground white -font "Courier 24 bold" -wrap none -xscrollcommand ".scr set " scrollbar .scr -orient horiz -command ".t xview " -width 8 text .tref -height $NbSeq -bd 2 -background black -foreground white -font "Courier 24 bold" -wrap none frame .fbut -background black button .fbut.ss -text " Start/Stop " -bg green -fg white -command StartStop button .fbut.gr -text " Graphe " -bg cyan -command GrapheScore checkbutton .fbut.cks -fg white -bg black -text "Step by Step" -onvalue 1 -offvalue 0 -variable ::StepMode button .fbut.bsp -fg white -bg "#550a0a" -text "One Step" -command [list DoOneStep] grid .fbut.gr -row 0 -column 0 -sticky n -padx 10 -pady 10 grid .fbut.ss -row 1 -column 0 -sticky n -padx 10 -pady 10 grid .fbut.cks -row 2 -column 0 -sticky n grid .fbut.bsp -row 3 -column 0 -sticky n set ic -1 #incr ic #grid .fbut -column $ic -row 0 -rowspan 3 -sticky ns -padx 10 incr ic grid .l -column $ic -row 0 -sticky ew grid .t -column $ic -row 1 -sticky ew -ipady 5 grid .scr -column $ic -row 2 -sticky ew grid .tref -column $ic -row 3 -sticky ew grid columnconfig . all -weight 1 grid rowconfig . all -weight 1 #wm attributes . -fullscreen 1 focus .t bind all SeeTag bind all GrapheScore bind all StartStop bind all ToggleStepMode bind all DoOneStep #bind .t [list SpyAgent %W @%x,%y] #bind .t [list ClearSpy] bind .t {.t xview scroll -[set Defauts(DeltaXScroll)] units ; break} bind .t {.t xview scroll [set Defauts(DeltaXScroll)] units ; break} trace add variable Lscores write GrapheScore set Tref [list] foreach n $LNOrdali { lappend Tref $Sref($n) } set Tref [join $Tref \n] .tref insert end $Tref FenetreAuCentre [winfo toplevel .t] return } proc GUISampleTOL {} { global Tx db TaxRoot InitTaxDB LoadTkAndPackages ChangeTkOptions GUITaxInitialise ChangeTkOptions if {[winfo children .] == {} } { # create a general frame set wroot . set w .guitax frame $w grid $w -row 0 -column 0 -sticky news } else { # SampleTOLGUI is launched from another application set w .guitax set wroot $w toplevel $w } wm title $wroot "Sample TOL GUI" wm iconname $wroot "SampleTOL" wm protocol $wroot WM_DELETE_WINDOW KillParLaCroix wm withdraw $wroot # title frame frame $w.ftit grid $w.ftit -row 0 -column 0 -sticky w -pady {5 30} label $w.ftit.lb1 -font "Helvetica 20 bold italic" -text "SoTOL " -anchor w -justify left label $w.ftit.lb2 -text "Parameters for sampling taxa of the Tree Of Life" -font "Helvetica 10 bold" -anchor w -justify left grid $w.ftit.lb1 -row 0 -column 0 -sticky w grid $w.ftit.lb2 -row 0 -column 1 -sticky w -padx 20 # compulsory items frame $w.fcp grid $w.fcp -row 1 -column 0 -sticky ew label $w.fcp.lbnb -text "Number of samples : " -justify right -anchor w -font TaxFontWdgBold set Tx(-ntaxa) "" entry $w.fcp.ennb -bg white -font TaxFontWdg -textvariable Tx(-ntaxa) label $w.fcp.lbro -text "Root : " -font TaxFontWdgBold -justify right -anchor w entry $w.fcp.enro -bg white -font TaxFontWdg -textvariable Tx(-root) label $w.fcp.lbmo -text "Model Organisms : " -justify right -anchor w -font TaxFontWdgBold button $w.fcp.btmo -bg cyan -font TaxFontWdg -text "Show list ..." -command ShowModelOrganismsList grid $w.fcp.lbnb -row 0 -column 0 -sticky e -pady 2 grid $w.fcp.ennb -row 0 -column 1 -sticky ew -pady 2 grid $w.fcp.lbro -row 1 -column 0 -sticky e -pady 2 grid $w.fcp.enro -row 1 -column 1 -sticky ew -pady 2 grid $w.fcp.lbmo -row 2 -column 0 -sticky e -pady 2 grid $w.fcp.btmo -row 2 -column 1 -sticky ew -pady 2 grid columnconfig $w.fcp 1 -weight 1 # frame add models frame $w.fad grid $w.fad -row 2 -column 0 -sticky ew -pady {30 10} label $w.fad.lbad -text "Add Model Organisms : " -font TaxFontWdgBold -justify left -anchor w set Tx(chxmodel) 1 radiobutton $w.fad.rad -text "Add to selection" -font TaxFontWdg -relief flat -value 1 -highlightthickness 0 -variable Tx(chxmodel) radiobutton $w.fad.rin -text "Pick in selection" -font TaxFontWdg -relief flat -value 0 -highlightthickness 0 -variable Tx(chxmodel) radiobutton $w.fad.rdc -text "Don't care " -font TaxFontWdg -relief flat -value -1 -highlightthickness 0 -variable Tx(chxmodel) grid $w.fad.lbad -row 0 -column 0 -columnspan 3 -sticky w grid $w.fad.rad -row 1 -column 0 -sticky e grid $w.fad.rin -row 1 -column 1 -sticky e grid $w.fad.rdc -row 1 -column 2 -sticky e grid columnconfig $w.fad all -weight 1 # frame 'all' or 'representative' organisms frame $w.far grid $w.far -row 3 -column 0 -sticky ew -pady {30 10} label $w.far.lbad -text "Organisms to use : " -font TaxFontWdgBold -justify left -anchor w set Tx(-useorgs) "representative" radiobutton $w.far.rad -text "Use ALL complete genomes" -font TaxFontWdg -relief flat -value "all" -highlightthickness 0 -variable Tx(-useorgs) radiobutton $w.far.rin -text "Use a repreesntative for each Species" -font TaxFontWdg -relief flat -value "representative" -highlightthickness 0 -variable Tx(-useorgs) grid $w.far.lbad -row 0 -column 0 -columnspan 3 -sticky w grid $w.far.rad -row 1 -column 0 -sticky e grid $w.far.rin -row 1 -column 1 -sticky e grid columnconfig $w.far all -weight 1 # User Organisms List frame $w.fus grid $w.fus -row 4 -column 0 -sticky ew -pady 10 label $w.fus.lus -text "User selected taxa Ids : " -justify right -anchor w -font TaxFontWdgBold set Tx(-userids) "" set Tx(-UserFile) "" entry $w.fus.eus -bg white -font TaxFontWdg -textvariable Tx(-UserFile) button $w.fus.bus -text "Browse ..." -font TaxFontWdg -bg cyan -command BrowseUserSelectedTaxIdFile label $w.fus.lsh -text "Show taxa Ids : " -justify right -anchor w -font TaxFontWdgBold set Tx(-ShowFile) "" entry $w.fus.esh -bg white -font TaxFontWdg -textvariable Tx(-ShowFile) button $w.fus.bsh -text "Browse ..." -font TaxFontWdg -bg cyan -command BrowseShowTaxIdFile grid $w.fus.lus -row 0 -column 0 -sticky e grid $w.fus.eus -row 0 -column 1 -sticky ew grid $w.fus.bus -row 0 -column 2 -sticky e grid $w.fus.lsh -row 1 -column 0 -sticky e grid $w.fus.esh -row 1 -column 1 -sticky ew grid $w.fus.bsh -row 1 -column 2 -sticky e grid columnconfig $w.fus 1 -weight 1 # frame controls frame $w.fct grid $w.fct -row 5 -column 0 -sticky ew -pady {100 10} button $w.fct.bdi -text "Exit" -font TaxFontWdg -bg red -command "destroy $wroot" button $w.fct.bok -text " OK " -font TaxFontWdg -bg green1 -command {SampleTOL gui} grid $w.fct.bdi -row 0 -column 0 -sticky w -padx 30 grid $w.fct.bok -row 0 -column 1 -sticky e -padx 30 grid columnconfig $w.fct all -weight 1 grid columnconfig $w all -weight 1 grid columnconfig $wroot all -weight 1 wm deiconify $wroot MesCouleurs $wroot FenetreAuCentre $wroot return } proc GUITaxInitialise {} { global Tx Defauts # Init fonts and drawing parameters if {"TaxFont" ni [font names]} { font create TaxFont -family Helvetica -size [set Defauts(FontSizeTree)] -weight [set Defauts(FontWghtTree)] } if {"TaxFontWdgBold" ni [font names]} { font create TaxFontWdgBold -family Helvetica -size 10 -weight bold font create TaxFontWdg -family Helvetica -size 10 -weight normal } if {"BalloonFont" ni [font names]} { font create BalloonFont -family Helvetica -size [set Defauts(FontSizeTree)] -weight [set Defauts(FontWghtTree)] } LesDefauts BackAppli "#995533" LesDefauts ForeAppli "white" # Allow use of FaireAttendre LesDefauts MarcheForcee 1 # dimensions set Tx(PADWdt) [set Defauts(CanvasWTree)] set Tx(PADHgt) [set Defauts(CanvasHTree)] set Tx(FWidth) [set Defauts(FWidthTree)] set Tx(FHeight) [set Defauts(FHeightTree)] set Tx(FontSize) [set Defauts(FontSizeTree)] set Tx(FontWght) [set Defauts(FontWghtTree)] set Tx(NfoisX) 1. set Tx(NfoisY) 1.1 set Tx(ScaleR) 1. set Tx(Rotate) 0. set Tx(OffsetX) [expr {10 + [font measure TaxFont "55555"]}] set Tx(OffsetY) [expr {int([set Tx(NfoisY)]*[lindex [font metrics TaxFont] 5])}] set Increment 100. set Tx(Increment) $Increment parray Tx return } proc GUIViewSampleTOL {} { global Tx db TaxRoot InitTaxDB LoadTkAndPackages ChangeTkOptions # define if we come from gui or command line if {[winfo exists .guitax]} { if {[winfo toplevel .guitax] eq ".guitax"} { destroy .guitax } else { destroy {*}[winfo children .] } } # create window if {[winfo children .] == {} } { # create a general frame set wroot . set w .gtax frame $w grid $w -row 0 -column 0 -sticky news } else { # SampleTOLGUI is launched from another application set w .gtax set wroot $w toplevel $w } wm title $wroot "Sample TOL GUI" wm iconname $wroot "SampleTOL" wm protocol $wroot WM_DELETE_WINDOW QuitSampleTOL wm withdraw $wroot # title frame frame $w.ftit grid $w.ftit -row 0 -column 0 -sticky w label $w.ftit.lb1 -font "Helvetica 20 bold italic" -text "SoTOL" -anchor w -justify left label $w.ftit.lb2 -text "Sampled taxa of the Tree Of Life" -font "Helvetica 12 bold" -anchor w -justify left grid $w.ftit.lb1 -row 0 -column 0 -sticky w grid $w.ftit.lb2 -row 0 -column 1 -sticky w -padx 20 # frame text frame $w.ftxt grid $w.ftxt -row 1 -column 0 -sticky ew -pady 5 set Tx(WLin) $w.ftxt.lbl set Tx(WLin,text) "" label $w.ftxt.lbl -height 2 -bg yellow -fg black -bd 2 -relief groove -anchor w -justify left -textvariable Tx(WLin,text) grid $w.ftxt.lbl -row 0 -column 0 -sticky ew grid columnconfig $w.ftxt 0 -weight 1 # search frame frame $w.fsea grid $w.fsea -row 2 -column 0 -sticky ew label $w.fsea.lbl -text "Search taxa ID/Name : " -bg white set Tx(SearchEnt) "" entry $w.fsea.ent -textvariable Tx(SearchEnt) -bg white button $w.fsea.bdo -text "Search" -bg green1 -command SearchTaxIdOrName button $w.fsea.bnx -text "Next" -bg cyan -command {DoTaxaSearch next} button $w.fsea.bpr -text "Prev" -bg cyan -command {DoTaxaSearch prev} button $w.fsea.bet -text "Expand All Taxo" -bg green1 -fg white -command {ExpandCollapseAllTaxa taxa expand} button $w.fsea.bct -text "Collapse All Taxa" -bg orange -fg white -command {ExpandCollapseAllTaxa taxa collapse} button $w.fsea.bei -text "Expand All Internals" -bg blue -fg white -command {ExpandCollapseAllTaxa internal expand} button $w.fsea.bci -text "Collapse All Internals" -bg magenta -fg white -command {ExpandCollapseAllTaxa internal collapse} grid $w.fsea.lbl -row 0 -column 0 -sticky w grid $w.fsea.ent -row 0 -column 1 -sticky w grid $w.fsea.bdo -row 0 -column 2 -sticky w grid $w.fsea.bnx -row 0 -column 3 -sticky w -padx {40 2} grid $w.fsea.bpr -row 0 -column 4 -sticky w -padx 1 grid $w.fsea.bet -row 0 -column 5 -sticky e -padx {20 1} grid $w.fsea.bct -row 0 -column 6 -sticky e -padx {1 20} grid $w.fsea.bei -row 0 -column 7 -sticky e -padx {20 1} grid $w.fsea.bci -row 0 -column 8 -sticky e -padx {1 20} bind $w.fsea.ent SearchTaxIdOrName # frame canvas set Tx(PAD) $w.fcan.c set Tx(ContextMenu) $w.fcan.c.ctxmn set Tx(fgCan) white set Tx(bgCan) black frame $w.fcan grid $w.fcan -row 3 -column 0 -sticky news canvas $w.fcan.c -height [set Tx(FHeight)] -width [set Tx(FWidth)] -scrollregion [list 0 0 [set Tx(PADWdt)] [set Tx(PADHgt)]] -cursor hand2 -background $Tx(bgCan) -relief groove -xscrollcommand "$w.fcan.hs set" -yscrollcommand "$w.fcan.vs set" scrollbar $w.fcan.vs -command "$w.fcan.c yview" -width 8 scrollbar $w.fcan.hs -orient horiz -command "$w.fcan.c xview" -width 8 grid $w.fcan.c -row 0 -column 0 -sticky news grid $w.fcan.vs -row 0 -column 1 -sticky ns grid $w.fcan.hs -row 1 -column 0 -sticky ew grid rowconfig $w.fcan 0 -weight 1 grid columnconfig $w.fcan 0 -weight 1 grid columnconfig $w.fcan 1 -weight 0 # control frame, buttons, etc ... frame $w.fctr grid $w.fctr -row 4 -column 0 -sticky ew -pady 5 -padx 5 # frame font frame $w.fctr.ffnt -relief groove -bd 2 grid $w.fctr.ffnt -row 0 -column 0 -sticky w label $w.fctr.ffnt.ftsize -text "Font size" -anchor w -justify left spinbox $w.fctr.ffnt.fsz -readonlybackground white -width 6 -state readonly -values {6 8 10 12 14 16 18 20 22 24} -command [list TaxFontMode size %s] label $w.fctr.ffnt.ftwght -text "Font weight" -anchor w -justify left spinbox $w.fctr.ffnt.fwh -readonlybackground white -width 6 -state readonly -values [list normal bold] -command [list TaxFontMode weight %s] grid $w.fctr.ffnt.ftsize -row 0 -column 0 -sticky w grid $w.fctr.ffnt.fsz -row 0 -column 1 -sticky w grid $w.fctr.ffnt.ftwght -row 1 -column 0 -sticky w grid $w.fctr.ffnt.fwh -row 1 -column 1 -sticky w # frame show taxa frame $w.fctr.fsht -relief groove -bd 2 grid $w.fctr.fsht -row 0 -column 1 -sticky w -padx 5 set Tx(-toshow) "def" radiobutton $w.fctr.fsht.ral -text "all taxa" -justify left -relief flat -value "all" -highlightthickness 0 -variable Tx(-toshow) -command {ChangeTaxa2Show} radiobutton $w.fctr.fsht.rde -text "defined" -justify left -relief flat -value "def" -highlightthickness 0 -variable Tx(-toshow) -command {ChangeTaxa2Show} grid $w.fctr.fsht.ral -row 0 -column 0 -sticky w grid $w.fctr.fsht.rde -row 1 -column 0 -sticky w # sub-frame buttons frame $w.fctr.fprc grid $w.fctr.fprc -row 0 -column 2 -sticky w button $w.fctr.fprc.print -text "Print" -background yellow -command "PrintCanvas $w.fcan.c png" button $w.fctr.fprc.save -text "Save" -background cyan -command {WriteSelectedTaxId} button $w.fctr.fprc.reset -text "Reset" -background white -command {} button $w.fctr.fprc.close -text "Close" -background red -command "QuitSampleTOL $w" grid $w.fctr.fprc.print -row 0 -column 0 grid $w.fctr.fprc.save -row 1 -column 0 grid $w.fctr.fprc.reset -row 0 -column 1 grid $w.fctr.fprc.close -row 1 -column 1 grid rowconfig $w.fctr.fprc all -weight 0 grid columnconfig $w.fctr.fprc all -weight 0 grid rowconfig $w.fctr all -weight 0 grid columnconfig $w.fctr all -weight 0 grid rowconfigure $w all -weight 0 grid rowconfigure $w 3 -weight 1 grid columnconfigure $w all -weight 1 if {$w ne $wroot} { grid rowconfigure $wroot all -weight 1 grid columnconfigure $wroot all -weight 1 } MesCouleurs $wroot update idletasks # bindings bind all {QuitSampleTOL} set PAD $Tx(PAD) bind $PAD {%W scan mark %x %y} bind $PAD {%W scan dragto %x %y 1} bind $PAD <4> {%W yview scroll -1 units} bind $PAD <5> {%W yview scroll 1 units} bind $PAD {%W xview scroll -1 units} bind $PAD {%W xview scroll 1 units} #InitTax2Draw puts "start drawing" DrawTaxo puts "end drawing" #AfficheProfileResults wm attributes $wroot -fullscreen 1 wm deiconify $wroot lassign [$PAD bbox all] x1 y1 x2 y2 #$PAD move all [expr {-$x1+20}] [expr {-$y1+20}] set dx [expr {$x2-$x1+50}] set dy [expr {$y2-$y1+50}] if {$dx < $Tx(PADWdt)} {set dx $Tx(PADWdt)} if {$dy < $Tx(PADHgt)} {set dy $Tx(PADHgt)} $PAD configure -scrollregion [list 0 0 $dx $dy] # contextual menu : add/remove from selection CreateContextMenuTax bind $PAD [list ShowContextMenuTax %W %x %y] $PAD bind Arrow {ToggleTaxArrow %W} $PAD bind IntFlag {ToggleTaxInternal %W} $PAD bind sensor [list ShowLineage %W %x %y] $PAD bind sensor [list ShowRankOfNode %W %x %y] $PAD bind sensor {%W delete crank} #BindRankToTaxaItem update idletasks if {0} { source uriencode.tcl source tinyfileutils.tcl source can2svg.tcl can2svg::canvas2file $PAD can.svg } return } proc Gag {} { Gs "WindowText" # Cette procedure retourne la page du labo return [ContenuDuFichier "./logag.html"] } proc GagneOuPerdUnBinding {GardeOuNonUnPfamQcq} { #peut etre a adapter car fait apres BilanPerteGainPfam {WithWhat} #ne considere que les LA CONTIG entier #GardeOuNonUnPfamQcq OUI ou NON set BoxWithBinding 0; set BoxConcernes 0 foreach Box [ListeDesPABs] { set LesLignesFic {}; set trouveAuMoinsUnBinding 0; set nbLA 0; set nbannule 0; set nbinvariant 0 if {[info exists InfoPfamRef]} { unset InfoPfamRef } set LesPfamRef {} if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set Org Mouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set Org Rat } else { set Org SpliRet } set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set LesNames [InterrogeNames $Cluster Name $Org] set RefPfam [ExtraitInfo $Box "RefPfam"] set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims] set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} set LaRefEtLesNames [concat [list $Box $RefPfam] $LesNames] set LaRefEtLesNames [ListeSansDoublon $LaRefEtLesNames] set LesPfamStartStop {}; set LesPfamStartStopNonRedondant {} set LesPfamStartStop [LesPfamStartStop $FileMacsims $LaRefEtLesNames $Box $Ref] if {$LesPfamStartStop=={}} {continue} set LesPfamStartStopNonRedondant [LesPfamStartStopNonRedondant $LesPfamStartStop] set NbPfamDuneBoite [llength $LesPfamStartStopNonRedondant] #Espionne "$Box $LesPfamStartStopNonRedondant $NbPfamDuneBoite" foreach PfamDuneBoite $LesPfamStartStopNonRedondant { set PfamDuneBoite [lindex [split $PfamDuneBoite " "] 0] #AVANT #set Des [InterrogePfamDesFrom1500 $PfamDuneBoite Des] #if {[regexp "binding" $Des]} { #&& [regexp "DNA" $Des] #set trouveAuMoinsUnBinding 1 #set PfamBinding($PfamDuneBoite) 1 #} else { #set PfamBinding($PfamDuneBoite) 0 #} set Des [InterrogeBindingPfamDesFromGo $PfamDuneBoite Des] if {$Des==""} { set PfamBinding($PfamDuneBoite) 0 } else { set PfamBinding($PfamDuneBoite) 1 set trouveAuMoinsUnBinding 1 } } if {!$trouveAuMoinsUnBinding} {continue} if {$NbPfamDuneBoite<=1} {continue} incr BoxWithBinding #Espionne "" #Espionne "$Box $Cluster" set LesPfamInfoRef [FromMacsims $FileMacsims $RefPfam "ConcatPfam"] set SeqDataRef [FromMacsims $FileMacsims $RefPfam "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataRef #Espionne "$FileMacsims" #Espionne "LesNames $LesNames" #Espionne "RefPfam $RefPfam $NbPFAMRef" #EspionneL "$LesPfamInfoRef" foreach InfoRef $LesPfamInfoRef { if {[regexp "ERROR" $InfoRef]} { #ds le cas ou j'ai ERROR dans InfoRef regsub -nocase {^ERROR_} $InfoRef "" InfoRef } scan $InfoRef "%s" PfamRef if {[regexp "/" $PfamRef]} { #ds le cas ou j'ai ERROR dans InfoRef set PfamRef [lindex [split $PfamRef "/"] 0] } set PfamRef [string toupper $PfamRef] regsub -nocase {^PROP_} $PfamRef "" PfamRef lappend LesPfamRef $PfamRef lappend InfoPfamRef($PfamRef) $InfoRef FstartFstop $InfoRef RFstart RFstop set AbsRef($RFstart) [PositionAbsolueDansAlignement $RFstart] set AbsRef($RFstop) [PositionAbsolueDansAlignement $RFstop] } set LesPfamRef [lsort -unique $LesPfamRef] #Espionne "LesPfamRef:$LesPfamRef" foreach Name $LesNames { if {![regexp "^LA" $Name]} {continue} if {[regexp "CONTIG5$" $Name] || [regexp "CONTIG3$" $Name]} {continue} incr nbLA set differe 0; set perdu 0 if {[info exists InfoPfamName]} { unset InfoPfamName } if {[info exists DejaVu]} { unset DejaVu } if {$Name==$Ref} {set Name $Box} set LesPfamInfoName [FromMacsims $FileMacsims $Name "ConcatPfam"] set SeqDataName [FromMacsims $FileMacsims $Name "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataName #Espionne "$Box $Name" set LesPfamInfoName [ListeSsElmtVide $LesPfamInfoName] #EspionneL "$LesPfamInfoName" #Espionne "LesGainsPertes:" if {$LesPfamInfoName=={}} { set differe 1 set perdu $NbPFAMRef foreach PfamRef $LesPfamRef { if {!$PfamBinding($PfamRef)} {continue} foreach InfoRef $InfoPfamRef($PfamRef) { FstartFstop $InfoRef RFstart RFstop set ResultPerdu [SitePerdu Pfam $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)] [PositionRelativeDansAlignement $AbsRef($RFstop)]] if {$GardeOuNonUnPfamQcq=="NON"} { set LigneFic "$ResultPerdu" lappend LesLignesFic $LigneFic } } } } else { foreach InfoName $LesPfamInfoName { scan $InfoName "%s" PfamName set PfamName [string toupper $PfamName] regsub -nocase {^PROP_} $PfamName "" PfamName if {!$PfamBinding($PfamName)} {continue} lappend InfoPfamName($PfamName) $InfoName FstartFstop $InfoName Fstart Fstop set AbsFstart [PositionAbsolueDansAlignement $Fstart] set AbsFstop [PositionAbsolueDansAlignement $Fstop] if { ! [info exists InfoPfamRef($PfamName)]} { set differe 1 set ResultGagne [SiteGagne Pfam $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] set LigneFic "$ResultGagne" lappend LesLignesFic $LigneFic } } #Espionne "InfoPfamName: [array names InfoPfamName]" foreach PfamRef $LesPfamRef { if {!$PfamBinding($PfamRef)} {continue} foreach InfoRef $InfoPfamRef($PfamRef) { FstartFstop $InfoRef RFstart RFstop if { ! [info exists InfoPfamName($PfamRef)]} { #if {[info exists DejaVu($PfamRef)]} { continue } set differe 1 set ResultPerdu [SitePerdu Pfam $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)] [PositionRelativeDansAlignement $AbsRef($RFstop)]] incr perdu set LigneFic "$ResultPerdu" lappend LesLignesFic $LigneFic lappend DejaVu($PfamRef) "$AbsRef($RFstart) $AbsRef($RFstop)" } else { set TousAbsents 1 foreach InfoName $InfoPfamName($PfamRef) { FstartFstop $InfoName Fstart Fstop set AbsFstart [PositionAbsolueDansAlignement $Fstart] set AbsFstop [PositionAbsolueDansAlignement $Fstop] #Espionne "$AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop" if {[Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop]} { set TousAbsents 0 break } } if { $TousAbsents } { set differe 1 set ResultPerdu [SitePerdu Pfam $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)] [PositionRelativeDansAlignement $AbsRef($RFstop)]] incr perdu set LigneFic "$ResultPerdu" lappend LesLignesFic $LigneFic } } } } } #Espionne "" #Espionne "$Box $Cluster" #Espionne "$FileMacsims" #Espionne "LesNames $LesNames" #Espionne "RefPfam $RefPfam $NbPFAMRef" #EspionneL "$LesPfamInfoRef" #Espionne "differe $differe" if {!$differe} { incr nbinvariant #Espionne " $Name rien gagne rien pris en BindingPfam" #set LigneFic " $Name rien gagne rien perdu en BindingPfam" #lappend LesLignesFic $LigneFic } else { #Espionne "$Name a perdu $perdu BindingPFAM" if {$GardeOuNonUnPfamQcq=="OUI"} { if {$perdu==$NbPFAMRef} { incr nbannule #Espionne "a annule" } } } } set nbnulle [expr $nbinvariant + $nbannule] if {$LesLignesFic!={} && $nbLA!=$nbnulle} { incr BoxConcernes Espionne "" Espionne "$Box $Cluster" EspionneL "$LesLignesFic" } #SauveLesLignes $LesLignesFic dans "$RepertoireOut/$Box" } Espionne "" Espionne "BoxWithBinding $BoxWithBinding" Espionne "BoxConcernes $BoxConcernes" } proc GammeDeCouleurBlancVersRouVouB {RouVouB NbCouleurs} { set pi 3.141592 if {$NbCouleurs <=1} { if {$RouVouB == "R"} {return [list red ]} if {$RouVouB == "B"} {return [list blue ]} if {$RouVouB == "G"} {return [list green]} } set BHexa [Deci2Hexa 255] set VHexa [Deci2Hexa 255] set RHexa [Deci2Hexa 255] set LesCouleurs {} for {set i $NbCouleurs} {0 <= $i} {incr i -1} { set Couleur [expr round(255.0/$NbCouleurs * $i)] set HexaCouleur [Deci2Hexa $Couleur] if {[string length $HexaCouleur] == 1} {set HexaCouleur "0$HexaCouleur"} if {$RouVouB == "R"} {set VHexa $HexaCouleur;set BHexa $HexaCouleur} if {$RouVouB == "V"} {set BHexa $HexaCouleur;set RHexa $HexaCouleur} if {$RouVouB == "B"} {set VHexa $HexaCouleur;set RHexa $HexaCouleur} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } return $LesCouleurs } proc GammeDeCouleurRouVouB {RouVouB NbCouleurs} { set pi 3.141592 if {$NbCouleurs <=1} { if {$RouVouB == "R"} {return [list red ]} if {$RouVouB == "B"} {return [list blue ]} if {$RouVouB == "G"} {return [list green]} } set BHexa "0[Deci2Hexa 0]" set VHexa "0[Deci2Hexa 0]" set RHexa "0[Deci2Hexa 0]" set LesCouleurs {} for {set i 0} {$i <= $NbCouleurs} {incr i} { set Couleur [expr round(255.0/$NbCouleurs * $i)] set HexaCouleur [Deci2Hexa $Couleur] if {[string length $HexaCouleur] == 1} {set HexaCouleur "0$HexaCouleur"} if {$RouVouB == "R"} {set RHexa $HexaCouleur} if {$RouVouB == "V"} {set VHexa $HexaCouleur} if {$RouVouB == "B"} {set BHexa $HexaCouleur} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } return $LesCouleurs } proc GammeDeCouleursDeGris {NbCouleurs {Ordre Degrade}} { if {$NbCouleurs <= 1} {return [list "white"]} set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Val [expr {255 - round($i * 255.0 / $NbCouleurs)}] set HexaVal [Deci2Hexa $Val] lappend LesCouleurs "\#$HexaVal$HexaVal$HexaVal" } if {$Ordre eq "Random"} { return [lsort -command TrieAleatoirement $LesCouleurs] } else { return $LesCouleurs } } proc GammeDeCouleursDeGris_CHALMEL {NbCouleurs {Ordre Degrade}} { Wup "Ordre Degrade, Random" set pi 3.141592 if {$NbCouleurs <=1} {return [list "white"]} # set AngleEcart [expr ($pi/2) / ($NbCouleurs - 1)] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { if {0} { set Angle [expr $AngleEcart * $i * 1.0] set Val [expr round(sin($Angle + $pi/2) * 255.0)] set HexaVal [Deci2Hexa $Val] if {[string length $HexaVal] == 1} {set HexaVal "0$HexaVal"} } set Val [expr 255 - round($i * 255.0 / $NbCouleurs)] set HexaVal [Deci2Hexa $Val] if {[string length $HexaVal] == 1} {set HexaVal "0$HexaVal"} lappend LesCouleurs "\#$HexaVal$HexaVal$HexaVal" } if {$Ordre == "Random"} { return [lsort -command TrieAleatoirement $LesCouleurs] } else { return $LesCouleurs } } proc GammeDeCouleursRNV {NbCouleurs} { set pi 3.141592 set B 0 set BHexa [Deci2Hexa $B] if {[string length $BHexa] == 1} {set BHexa "0$BHexa"} if {$NbCouleurs <=1} {return [list "black"]} set AngleEcart [expr 2 * $pi / (($NbCouleurs - 1))] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Angle [expr $AngleEcart * $i] if {$Angle < [expr $pi]} { set V 0 set R [expr round((cos($Angle)/2+0.5) * 255)] } else { set R 0 set V [expr round((cos($Angle)/2+0.5) * 255)] } set RHexa [Deci2Hexa $R] if {[string length $RHexa] == 1} {set RHexa "0$RHexa"} set VHexa [Deci2Hexa $V] if {[string length $VHexa] == 1} {set VHexa "0$VHexa"} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } return $LesCouleurs } proc GammeDeCouleursRV {NbCouleurs} { set pi 3.141592 set B 0 set BHexa [Deci2Hexa $B] if {[string length $BHexa] == 1} {set BHexa "0$BHexa"} if {$NbCouleurs <=1} {return [list "black"]} set AngleEcart [expr $pi / (($NbCouleurs - 1))] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Angle [expr $AngleEcart * $i] if {0 < [expr sin($Angle) ]} {set R [expr round(sin($Angle) * 0.67 * 255)]} else {set R 0} if {0 < [expr sin($Angle-$pi/2) ]} {set V [expr round(sin($Angle-$pi/2) * 255)]} else {set V 0} set RHexa [Deci2Hexa $R] if {[string length $RHexa] == 1} {set RHexa "0$RHexa"} set VHexa [Deci2Hexa $V] if {[string length $VHexa] == 1} {set VHexa "0$VHexa"} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } return $LesCouleurs } proc GammeDeCouleursRVB {NbCouleurs {Ordre Degrade}} { if {$NbCouleurs <= 1} {return [list "blue"]} set AngleEcart [expr {[Pi] / ($NbCouleurs - 1)}] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Angle [expr {$AngleEcart * $i}] if {0 < sin($Angle+[PiS2])} {set R [expr {round(sin($Angle+[PiS2])* 255)}]} else {set R 0} if {0 < sin($Angle)} {set V [expr {round(sin($Angle) * 255)}]} else {set V 0} if {0 < sin($Angle-[PiS2])} {set B [expr {round(sin($Angle-[PiS2])* 255)}]} else {set B 0} set RHexa [Deci2Hexa $R] set VHexa [Deci2Hexa $V] set BHexa [Deci2Hexa $B] lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } if {$Ordre == "Random"} { return [lsort -command TrieAleatoirement $LesCouleurs] } else { return $LesCouleurs } } proc GammeDeCouleursRVB_CHALMEL {NbCouleurs {Ordre Degrade}} { Wup "Ordre Degrade, Random" set pi 3.141592 if {$NbCouleurs <=1} {return [list "blue"]} set AngleEcart [expr $pi / ($NbCouleurs - 1)] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Angle [expr $AngleEcart * $i] if {0 < [expr sin($Angle+$pi/2) ]} {set R [expr round(sin($Angle+$pi/2)* 255)]} else {set R 0} if {0 < [expr sin($Angle) ]} {set V [expr round(sin($Angle) * 255)]} else {set V 0} if {0 < [expr sin($Angle-$pi/2 )]} {set B [expr round(sin($Angle-$pi/2)* 255)]} else {set B 0} set RHexa [Deci2Hexa $R] if {[string length $RHexa] == 1} {set RHexa "0$RHexa"} set VHexa [Deci2Hexa $V] if {[string length $VHexa] == 1} {set VHexa "0$VHexa"} set BHexa [Deci2Hexa $B] if {[string length $BHexa] == 1} {set BHexa "0$BHexa"} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } if {$Ordre == "Random"} { return [lsort -command TrieAleatoirement $LesCouleurs] } else { return $LesCouleurs } } proc GammeDeCouleursVBR {NbCouleurs {Ordre Degrade}} { Wup "Ordre Degrade, Random" set pi 3.141592 if {$NbCouleurs <=1} { return [list "green"]} set AngleEcart [expr $pi / ($NbCouleurs - 1)] set LesCouleurs {} for {set i 0} {$i < $NbCouleurs} {incr i} { set Angle [expr $AngleEcart * $i] if {0 < [expr sin($Angle+$pi/2) ]} {set V [expr round(sin($Angle+$pi/2)* 255)]} else {set V 0} if {0 < [expr sin($Angle) ]} {set B [expr round(sin($Angle) * 255)]} else {set B 0} if {0 < [expr sin($Angle-$pi/2 )]} {set R [expr round(sin($Angle-$pi/2)* 255)]} else {set R 0} set VHexa [Deci2Hexa $V] if {[string length $VHexa] == 1} {set VHexa "0$VHexa"} set BHexa [Deci2Hexa $B] if {[string length $BHexa] == 1} {set BHexa "0$BHexa"} set RHexa [Deci2Hexa $R] if {[string length $RHexa] == 1} {set RHexa "0$RHexa"} lappend LesCouleurs "\#$RHexa$VHexa$BHexa" } if {$Ordre == "Random"} { return [lsort -command TrieAleatoirement $LesCouleurs] } else { return $LesCouleurs } } proc GappedSeqAAFromGappedSeq3d {GappedSeq3d FichierOuListeA5 {Seq3d ""}} { if {[llength $FichierOuListeA5]==1} { ScanLaListe [Seq3dAndA5From $Fichier$FichierOuListeA5] Seq3d LesA5 } else { set LesA5 $FichierOuListeA5 } set i 0 set GappedSeqAA "" foreach G [split $GappedSeq3d ""] { if {[regexp -nocase {[a-z]} $G]} { set A5 [lindex $LesA5 $i] set AA [string range $A5 0 1] if {$Seq3d!=""} { set D [string index $Seq3d $i] if { ! [string equal -nocase $G $D]} { FaireLire "Problem in GappedSeqAAFromGappedSeq3d\n $G should be $D" } } incr i } else { set AA "$G$G" } append GappedSeqAA $AA } return $GappedSeqAA } proc Garde {Fichier {Granularity Seconde} {AndDelete ""}} { if { ! [file exists $Fichier]} { return "" } if {[regexp -nocase "AndDelete" $Granularity]} { set AndDelete $Granularity set Ganularity "" } if {$Granularity=="Minute"} { set Time 60000 set Extension [Date] } else { set Time 1000 set Extension [Date "Seconds"] } set Nouveau "$Fichier.$Extension" if {[file exists $Nouveau]} { after $Time ; return [Garde $Fichier $Granularity $AndDelete] } File copy -force $Fichier $Nouveau if {[file exists $Nouveau]} { if {[regexp -nocase "AndDelete" $AndDelete] && [file exists $Fichier]} { file delete $Fichier } return $Nouveau } return "" } proc GardeClustering {{quoi new}} { global Clus SDG LNDG MetAJourGroupes if {$quoi eq "new"} { lassign [DemandeTitreEtDescDuMac] titre desc ctitre cdesc set Clus(Titre) $titre EnregistreLeMac $titre "[DescriptionDuMac]" MetAJourWMacs } else { EnregistreLeMac } set Clus(NewEntry) 1 set Clus(Method) "User" LogClustering return } proc GardePierre {} { global CanalPierre NomDuFichierPierre ClosPierre if { [file exists $NomDuFichierPierre] } { if {[Garde $NomDuFichierPierre]==""} { FaireLire "I Couldn't make a backup of $NomDuFichierPierre" } File delete -force $NomDuFichierPierre } } proc GardeQueLesMinusculesDesDescriptifs {} { Wup "Avant les descriptifs etaient essentiellement en majuscule" Wup " S'il y a conflit ... je ne garde que le minuscule." set OldAccess "" set OldLigne "" foreach Ligne [LesLignesDuFichier "lesdescriptifs"] { set iEgal [string first "=" $Ligne] set Access [string range $Ligne 0 [incr iEgal -1]] set Descriptif [string range $Ligne [incr iEgal 2] end] if {$OldAccess==$Access} { set OldLigne "" } if {$OldLigne!=""} { lappend BonnesLignes $OldLigne } set OldAccess "" set OldLigne $Ligne set OldAccess $Access set OldDescriptif $Descriptif } if {$Ligne!=""} { lappend BonnesLignes $Ligne } SauveLesLignes $BonnesLignes dans "lesdescriptifs.nouveau" } proc GardeUnBindingETPerdUnNonBinding {} { #peut etre a adapter car fait apres BilanPerteGainPfam {WithWhat} set BoxWithBinding 0; set BoxConcernes 0 foreach Box [ListeDesPABs] { set LesLignesFic {}; set trouveAuMoinsUnBinding 0; set nbLA 0; set nbannule 0; set nbinvariant 0 if {[info exists InfoPfamRef]} { unset InfoPfamRef } set LesPfamRef {} if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set Org Mouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set Org Rat } else { set Org SpliRet } set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set LesNames [InterrogeNames $Cluster Name $Org] set RefPfam [ExtraitInfo $Box "RefPfam"] set RefPfam "NM_011624" set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims] set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} set LaRefEtLesNames [concat [list $Box $RefPfam] $LesNames] set LaRefEtLesNames [ListeSansDoublon $LaRefEtLesNames] set LesPfamStartStop {}; set LesPfamStartStopNonRedondant {} set LesPfamStartStop [LesPfamStartStop $FileMacsims $LaRefEtLesNames $Box $Ref] if {$LesPfamStartStop=={}} {continue} set LesPfamStartStopNonRedondant [LesPfamStartStopNonRedondant $LesPfamStartStop] set NbPfamDuneBoite [llength $LesPfamStartStopNonRedondant] #Espionne "" #Espionne "$Box $TousLesPfamDuneBoite $NbPfamDuneBoite" foreach PfamDuneBoite $LesPfamStartStopNonRedondant { set PfamDuneBoite [lindex [split $PfamDuneBoite " "] 0] set Des [InterrogeBindingPfamDesFromGo $PfamDuneBoite Des] if {$Des==""} { set PfamBinding($PfamDuneBoite) 0 } else { set PfamBinding($PfamDuneBoite) 1 set trouveAuMoinsUnBinding 1 } } if {!$trouveAuMoinsUnBinding} {continue} if {$NbPfamDuneBoite<=1} {continue} incr BoxWithBinding #Espionne "$Box $Cluster" set LesPfamInfoRef [FromMacsims $FileMacsims $RefPfam "ConcatPfam"] set SeqDataRef [FromMacsims $FileMacsims $RefPfam "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataRef #Espionne "$FileMacsims" #Espionne "LesNames $LesNames" #Espionne "RefPfam $RefPfam $NbPFAMRef" #EspionneL "$LesPfamInfoRef" foreach InfoRef $LesPfamInfoRef { if {[regexp "ERROR" $InfoRef]} { #ds le cas ou j'ai ERROR dans InfoRef regsub -nocase {^ERROR_} $InfoRef "" InfoRef } scan $InfoRef "%s" PfamRef if {[regexp "/" $PfamRef]} { #ds le cas ou j'ai ERROR dans InfoRef set PfamRef [lindex [split $PfamRef "/"] 0] } set PfamRef [string toupper $PfamRef] regsub -nocase {^PROP_} $PfamRef "" PfamRef lappend LesPfamRef $PfamRef lappend InfoPfamRef($PfamRef) $InfoRef FstartFstop $InfoRef RFstart RFstop set AbsRef($RFstart) [PositionAbsolueDansAlignement $RFstart] set AbsRef($RFstop) [PositionAbsolueDansAlignement $RFstop] } set LesPfamRef [lsort -unique $LesPfamRef] #Espionne "LesPfamRef:$LesPfamRef" foreach Name $LesNames { if {![regexp "^LA" $Name]} {continue} if {[regexp "CONTIG5$" $Name] || [regexp "CONTIG3$" $Name]} {continue} incr nbLA set LesLignesFicTemp {} set differe 0; set perdu 0; set gardebinding 0; set gagnebinding 0; set perdPfamAutre 0 if {[info exists InfoPfamName]} { unset InfoPfamName } if {[info exists DejaVu]} { unset DejaVu } if {$Name==$Ref} {set Name $Box} set LesPfamInfoName [FromMacsims $FileMacsims $Name "ConcatPfam"] set SeqDataName [FromMacsims $FileMacsims $Name "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataName #Espionne #Espionne "$Name" set LesPfamInfoName [ListeSsElmtVide $LesPfamInfoName] #EspionneL "$LesPfamInfoName" #Espionne "LesGainsPertes:" if {$LesPfamInfoName=={}} { set differe 1 set perdu $NbPFAMRef #Espionne "$Name a tout perdu" #set LigneFic "$Name a tout perdu" #lappend LesLignesFic $LigneFic } else { foreach InfoName $LesPfamInfoName { #gagne un binding scan $InfoName "%s" PfamName set PfamName [string toupper $PfamName] regsub -nocase {^PROP_} $PfamName "" PfamName lappend InfoPfamName($PfamName) $InfoName FstartFstop $InfoName Fstart Fstop set AbsFstart [PositionAbsolueDansAlignement $Fstart] set AbsFstop [PositionAbsolueDansAlignement $Fstop] if {!$PfamBinding($PfamName)} {continue} if { ! [info exists InfoPfamRef($PfamName)]} { set differe 1 set gagnebinding 1 set ResultGagne [SiteGagne Pfam $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] set LigneFic "$ResultGagne" lappend LesLignesFicTemp $LigneFic } } #Espionne "InfoPfamName: [array name InfoPfamName]" foreach PfamRef $LesPfamRef { if {$PfamBinding($PfamRef)} { #Espionne "$PfamRef est un binding" if {[info exists InfoPfamName($PfamRef)]} { set gardebinding 1 foreach InfoName $InfoPfamName($PfamRef) { FstartFstop $InfoName Fstart Fstop set AbsFstart [PositionAbsolueDansAlignement $Fstart] set AbsFstop [PositionAbsolueDansAlignement $Fstop] foreach InfoRef $InfoPfamRef($PfamRef) { FstartFstop $InfoRef RFstart RFstop if {[Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop]} { set ResultGarde [SitePfamGarde $InfoName $Name $AbsFstart $AbsFstop $Fstart $Fstop] #Espionne "$ResultGarde" set LigneFic "$ResultGarde" lappend LesLignesFicTemp $LigneFic } } } } continue } else { #Espionne "$PfamRef n est pas un binding" #perd un PFAM non binding foreach InfoRef $InfoPfamRef($PfamRef) { #Espionne "InfoRef $InfoRef $PfamRef" FstartFstop $InfoRef RFstart RFstop if { ! [info exists InfoPfamName($PfamRef)]} { #Espionne "\t entre1" set differe 1 set perdPfamAutre 1 set ResultPerdu [SitePerdu Pfam $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)] [PositionRelativeDansAlignement $AbsRef($RFstop)]] incr perdu #Espionne "$ResultPerdu" set LigneFic "$ResultPerdu" lappend LesLignesFicTemp $LigneFic lappend DejaVu($PfamRef) "$AbsRef($RFstart) $AbsRef($RFstop)" } else { set TousAbsents 1 foreach InfoName $InfoPfamName($PfamRef) { FstartFstop $InfoName Fstart Fstop set AbsFstart [PositionAbsolueDansAlignement $Fstart] set AbsFstop [PositionAbsolueDansAlignement $Fstop] #Espionne "$AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop" if {[Recouvrement $AbsRef($RFstart) $AbsRef($RFstop) $AbsFstart $AbsFstop]} { set TousAbsents 0 break } } if { $TousAbsents } { #Espionne "\t entre2" set differe 1 set perdPfamAutre 1 set ResultPerdu [SitePerdu Pfam $InfoRef $Name $AbsRef($RFstart) $AbsRef($RFstop) [PositionRelativeDansAlignement $AbsRef($RFstart)] [PositionRelativeDansAlignement $AbsRef($RFstop)]] incr perdu #Espionne "$ResultPerdu" set LigneFic "$ResultPerdu" lappend LesLignesFicTemp $LigneFic } } } } } } #Espionne "" #Espionne "$Box $Cluster" #Espionne "$FileMacsims" #Espionne "LesNames $LesNames" #Espionne "RefPfam $RefPfam $NbPFAMRef" #EspionneL "$LesPfamInfoRef" #Espionne "differe $differe gardebinding $gardebinding perdPfamAutre $perdPfamAutre perdu $perdu" if {!$differe} { incr nbinvariant #Espionne "$Name pasinterressant" #Espionne " $Name pas interressant" #set LigneFic " $Name pas interressant" #lappend LesLignesFic $LigneFic } else { #Espionne "$Name a perdu $perdu PFAM non binding" if {$gardebinding && $perdPfamAutre} { #Espionne "$Name bon" LConcat LesLignesFic $LesLignesFicTemp } else { incr nbannule #Espionne "a annule" } } } #Espionne "nbLA= $nbLA nbinvariant= $nbinvariant nbannule= $nbannule" set nbnulle [expr $nbinvariant + $nbannule] if {$LesLignesFic!={} && $nbLA!=$nbnulle} { incr BoxConcernes Espionne "" Espionne "$Box $Cluster" EspionneL "$LesLignesFic" } } Espionne "" Espionne "BoxWithBinding $BoxWithBinding" Espionne "BoxConcernes $BoxConcernes" } proc GaussProbability {x mean stdev} { set exponent [expr {exp(-(pow($x-$mean,2)/(2*pow($stdev,2))))}] return [expr {(1 / (sqrt(2*acos(-1.)) * $stdev)) * $exponent}] } proc GbEnStock {GB} { global GbEnStock if {[info exists GbEnStock($GB)]} { return $GbEnStock($GB) } if {[info exists GbEnStock("EstCharge")]} { return "" } set GbEnStock("EstCharge") 1 set FichierGbEnStock "[Fiches]/GbEnStock" set Redondance 0 foreach Ligne [LesLignesDuFichier $FichierGbEnStock] { if { ! [regexp -nocase {[a-z0-9/]} $Ligne]} { continue } if {[regexp {^LOCUS +[A-Z]} $Ligne]} { set GbLu [StringApres LOCUS dans $Ligne] if {[info exists GbEnStock($GbLu)]} { set Redondance 1 ; unset GbEnStock($GbLu)} set GbCourant $GbLu set GbEnStock($GbCourant) $Ligne lappend LesGbLus $GbLu continue } if {[regexp {^ACCESSION +[A-Z]} $Ligne]} { set GbEnStock($GbCourant,Accession) [StringApres "ACCESSION" dans $Ligne] } append GbEnStock($GbCourant) "\n$Ligne" if {[regexp "//" $Ligne] && [info exists GbEnStock($GbCourant,Accession)]} { set GbEnStock($GbEnStock($GbCourant,Accession)) $GbEnStock($GbCourant) } } if {$Redondance} { set FichierGbEnStockNew [TmpFile] foreach GbLu $LesGbLus { AppendAuFichier $FichierGbEnStockNew $GbEnStock($GbLu) } Garde $FichierGbEnStock file rename -force $FichierGbEnStockNew $FichierGbEnStock } return [GbEnStock $GB] } proc GbsParLigne {I} { global GbsParLigne if {[info exists GbsParLigne($I)]} { return $GbsParLigne($I) } if {[info exists GbsParLigne("EstCharge")]} { return {} } set GbsParLigne("EstCharge") 1 set FichierGbsParLigne "[Fiches]/GbsParLigne" array set GbsParLigne [LesLignesDuFichier $FichierGbsParLigne] foreach {C Vs} [array get GbsParLigne] { foreach V [split $Vs " "] { if {[info exists GbsParLigne($V)]} { lappend GbsParLigne(GbMultiple) $V } lappend GbsParLigne($V) $C } } set GbsParLigne(GbMultiple) [lsort -unique $GbsParLigne(GbMultiple)] set GbsParLigne(Vide) {} foreach L [RetChip ListOf Index] { if {[GbsParLigne $L]=={}} { lappend GbsParLigne(Vide) $L } } return [GbsParLigne $I] } proc GeEsFrom {OS} { #rR Normalement on prend Hom sa #rR Mais traitement spécial pour les bactéries qui commencent pas Bac (comme Bacteri Bacill ...) if {[string index [OiDomain] 0]=="B" && [string range [string totitle $Ge] 0 2]=="Bac"} { set Ge "B" set FinOS [string range $OS [string first " " $OS] end] regsub -all " " $FinOS "" FinOS regsub -all -nocase {[^a-z0-9]} $FinOS "" FinOS regsub -all {[0-9]} $FinOS "d" FinOS append FinOS "xxxxxx" set Es [string range $FinOS 0 3] } else { scan $OS "%s %s" Ge Es set Ge [string range $Ge 0 2] set Es [string range $Es 0 1] } set GeEs [string totitle "$Ge$Es"] regsub -all {[0-9]} $GeEs "d" GeEs return $GeEs } proc GenBankToEMBL {FichierOuListeOuTexte {FichierEMBL ""}} { set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierOuListeOuTexte]] "\n"] if {$FichierEMBL!=""} { SauveLesLignes $LesLignesEMBL dans $FichierEMBL } return [join $LesLignesEMBL "\n"] } proc GenPeptDuNcbi {Id} { #retourne Fiche GenPept du NCBI nettoye(sans balise, sans lien) set Url "http://www.ncbi.nlm.nih.gov/entrez/viewer.fcgi?db=protein&id=" set UrlId "$Url$Id" set Texte [ContenuDuFichier $UrlId] set Fiche [ValeurDeLaBalise "pre" Texte] foreach {regMatch contenu} [regexp -all -line -inline {]*)?>([^<]*?)} $Fiche] { #Espionne "--[regsub -all {[\[\]\{\}\(\)\\\.\+\*\?]} $regMatch {\\\0}]--" regsub [regsub -all -line {[\[\]\{\}\(\)\\\.\+\*\?]} $regMatch {\\\0}] $Fiche $contenu Fiche #Espionne "++$regMatch++" #Espionne "--$contenu--" } #exit #regsub -all -line {]*)?>(.*?)} $Fiche {&1} Fiche return $Fiche } proc GenScan {FichierTFAOuTexte {FichierGSC ""} {TailleTroncon 300000} {TailleOverlap 300000}} { set Previens 1 if {$FichierGSC==""} { set RetourFichierGSC 0 } else { set RetourFichierGSC 1 } if {$FichierGSC=="ReturnTmpfilePlease"} { set FichierGSC "" } if {$FichierGSC!="" && [file exists $FichierGSC]} { if { ! [OuiOuNon "$FichierGSC already exists. Overwrite ?"]} { return $FichierGSC } } if {[regexp "^>" $FichierTFAOuTexte]} { set CleanTFA 1 set FichierTFA [Sauve $FichierTFAOuTexte dans "[TmpFile].tfa"] if {$FichierGSC==""} { regsub "\.tfa$" $FichierTFA ".gsc" FichierGSC } } else { set CleanTFA 0 set FichierTFA $FichierTFAOuTexte } if {$FichierGSC==""} { set FichierGSC "[TmpFile].gsc" } Espionne "$FichierTFA $FichierGSC" set MaxSizeForGenScan [expr $TailleTroncon + $TailleOverlap + 10000] if {[string length [QueLaSequenceDuTFA $FichierTFA]] < $MaxSizeForGenScan} { set Message "" catch {exec genscan "/biolo/genscan/HumanIso.smat" $FichierTFA > $FichierGSC} Message } else { foreach FichierTronconTFA [TronconneLeFichierTFA $FichierTFA $TailleTroncon $TailleOverlap "UseSameNameOnTmp"] { regsub ".tfa$" $FichierTronconTFA "" FichierTronconGSC set FichierTronconGSC "$FichierTronconGSC.gsc" GenScan $FichierTronconTFA $FichierTronconGSC $TailleTroncon $TailleOverlap lappend LesTronconsGSC $FichierTronconGSC } ReassembleLesTronconsGenscan $LesTronconsGSC $TailleTroncon $FichierGSC } if { ! [file exists $FichierGSC]} { if {$Previens} { Espionne "GenScan didn't work. See $FichierTFA" return "" } set GSG "" } set GSC [ContenuDuFichier $FichierGSC] if {$Previens && ! [regexp -nocase {[a-z]} $GSC]} { FaireLire "Genscan produced an empty output $FichierGSC\nand the following error message : \n$Message" } if {$CleanTFA} { File delete -force $FichierTFA } if {$RetourFichierGSC} { return $FichierGSC } File delete -force $FichierGSC return $GSC } proc GenScanEnStock {Access {GSC ""}} { global RepertoireDuGenome set RetourFileNamePlease 0 if {[regexp -nocase "^FileNamePlease" $GSC]} { set RetourFileNamePlease 1 set GSC "" } set Access [AccessDuContigDuFragment $Access] regsub {\:} $Access "_" Access set Access [string toupper $Access] set Stock "[RepertoireDuGenome]/stockgenscan" while { ! [file exists $Stock]} { if {[OuiOuNon "$Stock doesn't exist.\nDo I link to an existing directory ?"]} { set Ancien [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]/.."] if {$Ancien==""} { continue } exec ln -s $Ancien $Stock continue } if {[OuiOuNon "$Stock doesn't exist.\nDo I create directory ?"]} { File mkdir $Stock continue } } set Fichier "$Stock/$Access" if {$GSC==""} { if {[file exists $Fichier]} { if {$RetourFileNamePlease} { return $Fichier } else { return [ContenuDuFichier $Fichier] } return "" } } else { if { ! [regexp -nocase "^GENSCAN" $GSC] && ! [OuiOuNon "This text :\n [string range $GSC 0 100]\n...\n doesn't look like a GenScan text.\n Are You sure to want to store it in $Fichier ?" 0]} { return "" } return [Sauve $GSC dans $Fichier] } } proc GenScanEnStockPourTous {{Contig ""}} { global RepertoireDuGenome if {$Contig==""} { set Liste [glob "$RepertoireDuGenome/stockcontigs/*"] } else { set Liste [list "$RepertoireDuGenome/stockcontigs/$Contig"] } foreach FichierTFA $Liste { set Contig [file tail $FichierTFA] set FichierGSC "$RepertoireDuGenome/stockgenscan/$Contig" if {[file exists $FichierGSC]} { continue } Espionne [GenScan $FichierTFA $FichierGSC] } } proc GenScanExec {FichierTFA FichierOUT} { ### Execution du programme GenScan sur la sequence d'un fichier TFA ### if {![file exists $FichierTFA]} { return } catch {exec genscan "/biolo/genscan/HumanIso.smat" $FichierTFA > $FichierOUT} Message return } proc GenVrpFromData {laseq} { global Vrp VrpC set seq [string map [list . ""] $laseq] set xprev 0.0 ; set yprev 0.0 set cmx 0.0 ; set cmy 0.0 set minX 99999. ; set minY 99999. set maxX -99999. ; set maxY -99999. set Vrp(seqgen) $laseq set Vrp(seqAA1) $seq set Vrp(seqSS) {} set Vrp(SS) {} set Vrp(AA1) [split $seq ""] set newX {} ; set newY {} set Vrp(Sz) [llength $Vrp(AA1)] set Vrp(Nb) {} for {set i 0} {$i < $Vrp(Sz)} {incr i} { set aa [lindex $Vrp(AA1) $i] set hx $VrpC(HydX,$aa) set hy $VrpC(HydY,$aa) set x [expr {$Vrp(ScaleOrig)*$hx + $xprev}] set y [expr {$Vrp(ScaleOrig)*$hy + $yprev}] lappend newX $x lappend newY $y lappend Vrp(Nb) [expr {$i + 1}] set xprev $x set yprev $y set cmx [expr {$cmx + $x}] set cmy [expr {$cmy + $y}] } set minX [expr min([join $newX ,])] set minY [expr min([join $newY ,])] set maxX [expr max([join $newX ,])] set maxY [expr max([join $newY ,])] set Vrp(X) $newX set Vrp(Y) $newY set Vrp(CmX) [expr {$cmx / ($Vrp(Sz)+1)}] set Vrp(CmY) [expr {$cmy / ($Vrp(Sz)+1)}] set Vrp(MinX) $minX set Vrp(MinY) $minY set Vrp(MaxX) $maxX set Vrp(MaxY) $maxY set Vrp(SzX) [expr {($Vrp(MaxX) - $Vrp(MinX))/2}] set Vrp(SzY) [expr {($Vrp(MaxY) - $Vrp(MinY))/2}] return } proc GeneEtendu {Nom {Quoi ""}} { global GeneEtendu global RepertoireDuGenome Wup "Quoi can be Old, Color, Signification" if {$Quoi==""} { set Quoi "Ancien" } if {[info exists GeneEtendu($Nom,$Quoi)]} { return [set GeneEtendu($Nom,$Quoi)] } if {[info exists GeneEtendu("EstCharge",$Quoi)]} { return [set GeneEtendu("EstCharge",$Quoi)] } set Fichier "$RepertoireDuGenome/fiches/genesetendus.diff" if { ! [file exists $Fichier]} { set GeneEtendu("EstCharge",Old) "NoFile" set GeneEtendu("EstCharge",Color) "white" set GeneEtendu("EstCharge",Signification) "NoFile" set GeneEtendu(LaListeMerci,Old) "NoFile" set GeneEtendu(LaListeMerci,Color) "white" set GeneEtendu(LaListeMerci,Signification) "NoFile" return [GeneEtendu $Nom $Quoi] } foreach {Old New} [LesLignesDuFichier $Fichier] { scan $Old "%s" NomLu regsub -nocase {[a-z]*} $NomLu [PreFixe] NomLu set GeneEtendu($NomLu,Old) $Old set GeneEtendu($NomLu,Color) "red" set GeneEtendu($NomLu,Signification) "GeneWasExtended" lappend GeneEtendu(LaListeMerci,Old) $Old } set GeneEtendu("EstCharge",Old) "NoExtension" set GeneEtendu("EstCharge",Color) "green" set GeneEtendu("EstCharge",Signification) "NoExtension" set GeneEtendu(LaListeMerci,Color) [list "green" "red" "white"] set GeneEtendu(LaListeMerci,Signification) [list "NoExtension" "GeneWasExtended" "NoFile"] return [GeneEtendu $Nom $Quoi] } proc GeneIdWithGoDict {{Bdd ""}} { } proc GeneIdentityCard {Nom} { set NomOrigine $Nom if { ! [EstUnPAB $Nom]} { set LesIds [GscopeIdsOfGeneName $Nom "WithSynonyms"] set Nom [lindex $LesIds 0] } if { ! [EstUnPAB $Nom]} { if {[PourWscope]} { return [Html_DuTexteTelQuel "Sorry, I didn't find $NomOrigine"] } return "" } set Gn [ExtraitInfo $Nom "ValiGN"] set GnProt [ExtraitInfo $Nom "ValiGNProt"] set Alias [RecupereSynonyms $Nom] set Des [ExtraitInfo $Nom "ValiDE"] set DesProt [ExtraitInfo $Nom "ValiDEProt"] set DesUcsc [ExtraitInfo $Nom "ValiDEUcsc"] set AccARN [AccessEvi $Nom] set IdAccProt [ExtraitInfo $Nom "IdAccProt"] set LesProt [split $IdAccProt " "] set AccProt [lindex $LesProt 1] set Status [ExtraitInfo $Nom "Status"] set RetChip [ExtraitInfo $Nom "RetChip"] set Homologene [ExtraitInfo $Nom "HomologeneId"] set LocUcsc [ExtraitInfo $Nom "LocUcscFrom200602"] set LocCourt [lindex [split $LocUcsc " "] 0] set RetinaEst [ExtraitInfo $Nom "TissueType"] set ProbeSet [ExtraitInfo $Nom "ProbeSetId"] set ADNc [ExtraitInfo $Nom "BanqueADNc"] set IdMgi [ExtraitInfo $Nom "MGI"] set Pathway [ExtraitInfo $Nom "Pathways"] set FileMagos "[RepertoireDuGenome]/fiches/MagosLesRetinalFateHuman" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set LesGnEtAlias [split $Alias ","] lappend LesGnEtAlias $Gn set GnEtAlias [string trim [join [lsort -unique $LesGnEtAlias] ","] ","] if {$GnEtAlias==""} { set GnEtAlias "NoGeneNameNoAliasFound" } set RnaExpressionProfiles "http://www.tigem.it/RPexp/gene_data.php?gene_symbol=[string toupper $Gn]" set ImAnnoReference "[GenoretUrl]/Project/phrame.php?action=imannoShowAllConceptAnnot&cadre=1&organ=1&names=$GnEtAlias" set EurExpressReference "http://www.eurexpress.org/ee/databases/tdbsearch?mode=search&page=&searchField=All&searchValue=$Gn&Submit=Go" InterrogeGeneOntology unset set LesComponent {}; set LesFunction {}; set LesProcess {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] set IdDefGO "$GO:$DefGO" if {[regexp {component} $Type]} {lappend LesComponent $IdDefGO} if {[regexp {function} $Type]} {lappend LesFunction $IdDefGO} if {[regexp {process} $Type]} {lappend LesProcess $IdDefGO} } set LesComponent [ListeSansDoublon $LesComponent] set LesFunction [ListeSansDoublon $LesFunction] set LesProcess [ListeSansDoublon $LesProcess] set comp [join $LesComponent ","] set func [join $LesFunction ","] set proce [join $LesProcess ","] #set Repertoire "[RepertoireDuGenome]/GeneIdentityCard" #if {![file exists $Repertoire]} {File mkdir $Repertoire} #set Fichier "$Repertoire/$Nom.html" set trouvehom 0 foreach Ligne [LesLignesDuFichier $FileMagos] { set LesElmts [split $Ligne "\t"] set NomEvi [lindex $LesElmts 1] set HumanProt [lindex $LesElmts 2] if {$Nom==$NomEvi} { set trouvehom 1 set HumanProt [lindex $LesElmts 2] break } } if {!$trouvehom} {set HumanProt ""} # set LienProteomic [GenoretProteomicsLinks $Nom All] #set LienProteomic [join $LienProteomic "\n"] #if {$LienProteomic==""} {set LienProteomic "proteomic data not yet established"} set Titre "Gene Identity Card for $Nom" Html_ZeroToBody $Titre Html_Append "

Gene Identity Card: $Nom - $Gn

" Html_Append "
" Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "General Information"]] H2] Html_Append "" Html_Append "

"
    Html_Append [MiseEnLigne Name                    : "$Nom" "b"]

    Html_Append [MiseEnLigne "mRNA Gene Name"        : $Gn "b"]
    Html_Append [MiseEnLigne "Protein Gene Name"     : $GnProt]
    Html_Append [MiseEnLigne "Aliases Gene Name"     : $Alias]
    Html_Append [MiseEnLigne] 
    Html_Append [MiseEnLigne "mRNA Description"      : $Des]
    Html_Append [MiseEnLigne "Ucsc Description"      : $DesProt]
    Html_Append [MiseEnLigne "Protein Description"   : $DesUcsc]
    Html_Append [MiseEnLigne] 
    Html_Append [MiseEnLigne "mRNA Accession Number" :  "$AccARN"]
    Html_Append [MiseEnLigne  "Prot Accession Number" :  "$AccProt"]
    Html_Append [MiseEnLigne] 
    Html_Append [MiseEnLigne  "Status" : $Status]
    Html_Append [MiseEnLigne  "RetChip" : $RetChip] 
    Html_Append 

Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "External Links"]] H2] Html_Append "" Html_Append "

"
    Html_Append [MiseEnLigne "Localisation" :  "$LocUcsc"]
    Html_Append [MiseEnLigne "Homologene" :  "$Homologene"]
    Html_Append [MiseEnLigne "MGI" :  "$IdMgi"]
    Html_Append [MiseEnLigne "GeneCards" :  "$Gn"]
    Html_Append [MiseEnLigne "UCSC" :  "$Gn"]
    Html_Append "

" Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "Internal Data"]] H2] Html_Append "" Html_Append "

"
    Html_Append "Gene Ontology with GoAnno:"
    Html_Append [MiseEnLigne "component" : $comp "" 4]
    Html_Append [MiseEnLigne "function" : $func "" 4]
    Html_Append [MiseEnLigne "process" : $proce "" 4]
    Html_Append "

" Html_Append "

"

    Html_Append "Expression Data:"
    Html_Append [MiseEnLigne "Transcriptomic" :  "$ProbeSet  See all radars  Create Radar for all experiments"  "" 4]
    Html_Append [MiseEnLigne "EST" :  "$RetinaEst" "" 4]
    Html_Append [MiseEnLigne "cDNA" :  "$ADNc" "" 4]
    Html_Append [MiseEnLigne "ISH Embryo 14.5" :  "ImAnno" "" 4]
    Html_Append [MiseEnLigne "EurExpress" :  "EurExpress" "" 4]
    Html_Append [MiseEnLigne "RNA profile" :  "Retinis Pigmentosa Genes Expression Atlas Database" "" 4]

    set LesRef [GenoretProteomicsLinks $Nom Ref]

    if {$LesRef=={}} {
	Html_Append [MiseEnLigne "Proteomic" : "proteomic data not yet established" "" 4]
    } else {
	set Clef "Proteomic"
	foreach Ref $LesRef {
	    set LienProteomic "$Ref [join [GenoretProteomicsLinks $Nom$Ref Columns] " / "]"
	    Html_Append [MiseEnLigne $Clef : $LienProteomic "" 4]
	    regsub -all {.} $Clef " " Clef
	}
    }
    Html_Append "

" Html_Append "

"
    Html_Append [MiseEnLigne "Pathways" : $Pathway]
    Html_Append [MiseEnLigne "DevStage" :  "DevStage"]
    Html_Append "

" Html_Append "

"
    Html_Append [MiseEnLigne "MACSIMS" :  "Html Jalview"]
    if {$HumanProt!=""} {
	Html_Append [MiseEnLigne "MAGOS with Human prot" :  "$HumanProt"]
    }    
    if {$HumanProt==""} {
	Html_Append [MiseEnLigne "MAGOS with Human prot" : "No corresponding human protein in MS2PH-db"]
    }
    set XpertComment [ExtraitInfo $Nom "XpertComment:"]
    regsub -all " / " $XpertComment "\n" XpertComment
    if {$XpertComment!=""} {
	foreach Ligne [split $XpertComment "\n"] {
	    Html_Append [MiseEnLigne "XpertComment" : "$Ligne"]
	}
    }
    Html_Append [MiseEnLigne "XpertComment" : "Add your comment"]    

    Html_Append "

" Html_BR Html_BR #Html_Append "" Html_BodyToEnd set Texte [Html_Get "ZeroIt"] if { ! [PourWscope]} { return [AfficheVariable [SansBalises $Texte] "" "GeneIdentityCard/$Nom"] } return $Texte } proc GeneIdentityCardAnnaick {Nom} { set Gn [ExtraitInfo $Nom "ValiGN"] set Des [ExtraitInfo $Nom "ValiDE"] set BAcc [ExtraitInfo $Nom "BAcc"] set AccARN [lindex [split $BAcc ":"] 1] set IdAccProt [ExtraitInfo $Nom "IdAccProt"] set LesProt [split $IdAccProt " "] set AccProt [lindex $LesProt 1] set Homologene [ExtraitInfo $Nom "HomologeneId"] set LocUcsc [ExtraitInfo $Nom "LocUcsc"] set LocCourt [lindex [split $LocUcsc " "] 0] set ProbeSet [ExtraitInfo $Nom "ProbeSetId"] set Interaction [ExtraitInfo $Nom "Interaction"] set FichierKegg "[RepertoireDuGenome]/fiches/Kegg" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" InterrogeGeneOntology unset set LesComponent {}; set LesFunction {}; set LesProcess {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] set IdDefGO "$GO:$DefGO" if {[regexp {component} $Type]} {lappend LesComponent $IdDefGO} if {[regexp {function} $Type]} {lappend LesFunction $IdDefGO} if {[regexp {process} $Type]} {lappend LesProcess $IdDefGO} } set LesComponent [ListeSansDoublon $LesComponent] set LesFunction [ListeSansDoublon $LesFunction] set LesProcess [ListeSansDoublon $LesProcess] set comp [join $LesComponent ","] set func [join $LesFunction ","] set proce [join $LesProcess ","] #set Repertoire "[RepertoireDuGenome]/GeneIdentityCard" #if {![file exists $Repertoire]} {File mkdir $Repertoire} #set Fichier "$Repertoire/$Nom.html" set LesPath {} foreach NumeroPathway [InterrogeMesKEGG $Nom LesPathway] { set DefPathway [InterrogeMesKEGG Pathway $NumeroPathway Definition] set NumDefPath "$NumeroPathway: $DefPathway" lappend LesPath $NumDefPath } set Pathway [join $LesPath ","] set Titre "Gene Identity Card for $Nom" Html_ZeroToBody $Titre Html_Append "

Gene Identity Card: $Gn

" Html_BR #Html_Append [H_Color toto red] Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "General Information"]] H2] Html_Append "" Html_Append "

"
    Html_Append [MiseEnLigne Name                    : "$Nom" "b"]

    Html_Append [MiseEnLigne "Gene Name"        : $Gn "b"]
    Html_Append [MiseEnLigne "Description"      : $Des]
    Html_Append [MiseEnLigne "mRNA Accession Number" :  "$AccARN"]
    Html_Append [MiseEnLigne  "Prot Accession Number" :  "$AccProt"]
    Html_Append 

Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "External Links"]] H2] Html_Append "" Html_Append "

"
    Html_Append [MiseEnLigne "Localisation" :  "$LocUcsc"]
    Html_Append [MiseEnLigne "GeneCards" :  "$Gn"]
    Html_Append "

" Html_Append "" Html_Append [H_Balise [H_Bold [H_Center "Internal Data"]] H2] Html_Append "" Html_Append "

"
    Html_Append "Gene Ontology with GoAnno:"
    Html_Append [MiseEnLigne "component" : $comp "" 4]
    Html_Append [MiseEnLigne "function" : $func "" 4]
    Html_Append [MiseEnLigne "process" : $proce "" 4]
    Html_Append "

" Html_Append "

"
    Html_Append "EST:"
    Html_Append [MiseEnLigne "TissueType" :  "TissueType" "" 4]
    Html_Append [MiseEnLigne "DevStage" :  "DevStage" "" 4]
    Html_Append "

" Html_Append "

"
    Html_Append [MiseEnLigne "ProbesetId" : $ProbeSet]
    Html_Append "

" Html_Append "

"
    Html_Append [MiseEnLigne "Pathways" : $Pathway]
    Html_Append [MiseEnLigne "Interaction" : $Interaction]
    Html_Append "

" Html_Append "

"
    Html_Append [MiseEnLigne "MACSIMS" :  "Html Jalview"]
    Html_Append "

" Html_BR Html_BR #Html_Append "" Html_BodyToEnd return [Html_Get "ZeroIt"] } proc GeneNameDeLaListe {Fichier} { set LesAccessAliasDefinition {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z]} $Ligne]} {continue} scan $Ligne "%s" Access set LesLignesEMBL [LaSequenceDesBanques $Access "OnVeutEMBL"] set EMBL [join $LesLignesEMBL "\n"] set ChampsInteressants [ChampsInteressantsDansTexteEMBL $EMBL] set GN "" set DE "" set LaDE {} foreach Champ [split $ChampsInteressants "\n"] { if {[regexp "^GN " $Champ]} { set GN [VraiGNDeLaLigneGN $Champ] } if {[regexp "^DE " $Champ]} { regsub "^DE *" $Champ "" DE lappend LaDE $DE } } set DE [join $LaDE " "] Espionne "$Access $GN $DE" lappend LesAccessAliasDefinition "$Access $GN $DE" } Espionne [SauveLesLignes $LesAccessAliasDefinition dans "[HomeRipp]/MS2PH.txt"] } proc GeneOntology {Nom FichierGOXML {IPOouPPOouMSOouGPO GPO}} { if {![file exists $FichierGOXML]} {return} AskGOAnalyse unset set Query [AskGOAnalyse $FichierGOXML Query Name] if {$Query == ""} {return} set FileClust [AskGOAnalyse $FichierGOXML Fichier CLUST] set Cluster [InterrogeLesClustersDesMSF $FileClust Access $Query Cluster] set LeTexte {} foreach Type [AskGOAnalyse $FichierGOXML Methode $IPOouPPOouMSOouGPO LesTypes] { foreach GO [AskGOAnalyse $FichierGOXML Methode $IPOouPPOouMSOouGPO Type $Type LesGO] { set Def [AskGOAnalyse $FichierGOXML Type $Type GO $GO Definition] set LesAncetres [TousLesAncetresGO $Type $GO] lappend LeTexte [concat [list $Nom $Cluster $Nom $Type $GO $Def] $LesAncetres] } } return $LeTexte } proc GeneOntologyDeLAccess {AccessProt} { set AccessProt [string toupper $AccessProt] set LesGO [Access2GO $AccessProt] if {$LesGO == {}} {return [list [list $AccessProt "NoOntologyFound"]]} set LesOntologies {} foreach GO [EnterrerLesAncetresOntologiques $LesGO] { set Type [Onto $GO Type] set Definition [lindex [Onto $Type $GO LesDefinitions] 0] set LesAncetres [TousLesAncetresOntologiques $Type $GO] lappend LesOntologies [list $AccessProt "$Type" "$GO" "$Definition" "[join $LesAncetres "\t"]"] } return [lsort -index 0 $LesOntologies] } proc GeneQuid {args} { #rR AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAttention if {[Hostname]=="bob"} { return [ContenuDuFichier "http://lbgi.fr/wscoperr?GeneQuid&[join $args &]"] } set R [QuestionDeScience "GeneQuid" "ret [join $args { }]"] LogWscope $R return $R } proc GenemapKey {} { set Texte " 1 - Numbering system, in the format Chromosome.Map_Entry_Number 2 - Month entered 3 - Day entered 4 - Year entered 5 - Cytogenetic location 6 - Gene Symbols 7 - Gene Status 8 - Title 9 - Title, cont. 10 - MIM Number 11 - Method 12 - Comments 13 - Comments, cont. 14 - Disorders each disorder is followed by its MIM number, if different from that of the locus, and phenotype mapping method (see below. Allelic disorders are separated by a semi-colon. 15 - Disorders, cont. 16 - Disorders, cont. 17 - Mouse correlate 18 - Reference" return $Texte } proc GenenameDesAccess {Liste {GetWhat ""} {Database ""}} { if {$Database==""} { set Database "uniprot" } if {$GetWhat==""} { set GetWhat "ListOfGN" } set LesAG {} set LesGN {} if {[regexp {[ \,\;\n\t]} $Liste]} { regsub -all {[ \,\;\n\t]+} $Liste "," Liste set Liste [split [string trim $Liste ","] ","] } foreach Ligne $Liste { if { ! [regexp -nocase {[a-z]} $Ligne]} {continue} scan $Ligne "%s" Access set GN [BirdWeb $Database $Access "GN"] regsub {\;.*} $GN "" GN if {[regexp {=(.+)} $GN Match Name]} { set GN $Name } lappend LesAG $Access $GN lappend LesAeG "$Access=$GN" if {$GN!=""} { lappend LesGN $GN } } set R $LesAG if {[regexp -nocase "ListOfAeG" $GetWhat]} { set R $LesAeG } if {[regexp -nocase "ListOfGN" $GetWhat]} { set R $LesGN } if {[regexp -nocase "AsText" $GetWhat]} { return [join $R ","] } return $R } proc Generaliste {CanalClient} { #rR procedure par défaut qui discute en tant que serveur de socket set CloseCanal 0 #rR le while ne sert qu'à faire break puisqu'on fait return à chaque fois ... #rR j'ai dû bidouiller pour que le php recoive quelque chose ...il faut fermer le canal ... mais attention y a eu modif ... while {[gets $CanalClient Question] >= 0} { #Espionne "Question en entree =$Question=" if {[regexp "\n?FinDeMessage\n?$" $Question]} { regsub "\n?FinDeMessage\n?$" $Question "" Question set CloseCanal 1 if {$Question==""} { break } } # puts $CanalClient "Question=$Question=" # flush $CanalClient if {$Question=="CloseCanal"} { set CloseCanal 1 ; break } # set R [eval $Question] #Espionne "Vais faire eval de =$Question=" if {[catch {set R [eval $Question]} Message]} { Espionne "recu message $Message" puts $CanalClient $Message close $CanalClient return $Message } #Espionne "Vais envoyer =$R=" puts $CanalClient $R flush $CanalClient if {$CloseCanal} { close $CanalClient } return $R } if {$CloseCanal || [eof $CanalClient]} { # puts $CanalClient "Salut" # flush $CanalClient close $CanalClient } return "$CanalClient is closed" } proc GenereCases {LissageOK TailleSeq} { global GpesColonnes TailleFenetre NbPos global sommes_col LesCases TabCol GpeCases #attribue un numero de gpe aux colonnes (tableau TabCol qui commence a 1) if {!$LissageOK} { set nListe 0 foreach Liste $GpesColonnes { foreach i $Liste { set TabCol($i) $nListe } incr nListe } } else { for {set i 1} {$i<=$NbPos} {incr i} { set Numero [lsearch -regexp $GpesColonnes $i] for {set j 1} {$j<=$TailleFenetre} {incr j} { set TabCol([expr ($i-1)*$TailleFenetre+$j]) $Numero } } } #creation de la liste de cases #les colonnes appartenant a un meme groupe et contigues forment une case set LesCases [list] set GpeCases [list] set i 1 while {$i<=$TailleSeq} { set ListeIntermed [list $i] while {$i<$TailleSeq && ([set TabCol($i)]==[set TabCol([expr $i+1])])} { incr i lappend ListeIntermed $i } lappend GpeCases [set TabCol($i)] lappend LesCases $ListeIntermed incr i } } proc GenereFragments {{Comment ""} {Fichier ""} {PAB ""} {FichierTFAs ""}} { while {$Comment==""} { if {[OuiOuNon "Do You want to used an already created fragment file ?"]} { set Fichier [ButineArborescence "All" $Fichier] if {$Fichier!=""} { set Comment "FromExisting" break } } if {[OuiOuNon "Do You have a file with predefined fragments ?\n ... containing lines as follow : \nPGS048 2 234\nPGS048 56 234\nPGS050 1 565"]} { set Comment "Predefinis" break } if {[OuiOuNon "Do You have a file with limits for one sequence ?\n ... containing lines as follow : \n1\n24\n55\n777"]} { set Comment "AvecLimites" break } if {[OuiOuNon "Do You want to give the limits ?"]} { set Fichier "AskForLimits" set Comment "AvecLimites" break } if {[OuiOuNon "Do I cancel ?"]} { return "" } } set LeTFAs {} set LesFicN {} set LesFicP {} if {$Comment=="Predefinis"} { while {$Fichier==""} { FaireLire "Please browse for the file containing the fragment limits (PGS Start End(must be +1) Alias)." set Fichier [ButineArborescence "All" "."] if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" } } FaireLire "Please choose the directory to store the all isolate files (nuctfa and prottfa)" set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."] set LesNomDuAlias {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue } set Frag "" set Alias "" set AliasBis "" scan $Ligne "%s %s %s %s %s" PAB Debut Fin Alias AliasBis Espionne "PAB $PAB Debut $Debut Fin $Fin Alias $Alias AliasBis $AliasBis" if { ! [regexp {^b?[0-9]+$} $Debut]} { set Frag $Debut set Debut $Fin set Fin $Alias set Alias $AliasBis } if {$Alias==""} { set Alias [AliasPourClonage $PAB] } if {$Fin=="end"} { set FicN "[RepertoireDuGenome]/nuctfa/$PAB" set SeqN [QueLaSequenceDuFichierTFA $FicN] set L [string length $SeqN] set CodonEnd [string range $SeqN end-2 end] if {[CodonStopPossible $CodonEnd]} { set Fin [expr $L-3] } else { set Fin $L } set Fin [expr $Fin/3] } regexp {^([^_])+} $Alias NomDuAlias if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias } set DejaVu($NomDuAlias) 1 Espionne "$PAB $Frag $Debut $Fin $Alias" set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"] ScanLaListe $LesSequencesNP SeqN SeqP set FicN "$Rep/$Alias-$Debut-$Fin.nuctfa" set FicP "$Rep/$Alias-$Debut-$Fin.prottfa" set EnteteN "$Alias-$Debut-$Fin [string length $SeqN] bases" set EnteteP "$Alias-$Debut-$Fin [string length $SeqP] AAs" set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"] lappend LeTFAs $TfaN lappend LesFicN [Sauve $TfaN dans $FicN] if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } { set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"] lappend LesFicP [Sauve $TfaP dans $FicP] } } } elseif {$Comment=="AvecLimites" || $Comment=="FromExisting"} { set LesFragments {} if {$Comment=="FromExisting"} { set LesFragments [LesLignesDuFichier $Fichier] } if {$LesFragments=={} } { if {$Fichier=="" && [OuiOuNon "can You browse for a file with limits ?"]} { set Fichier [ButineArborescence "All" "./"] } if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" } while {$PAB==""} { FaireLire "Please enter a [PreFixe] number" set PAB [Entre [PreFixe]] set FichierTfa "[RepertoireDuGenome]/nuctfa/$PAB" if {[file exists $FichierTfa]} { break } if {[OuiOuNon "$FichierTfa\doesn't exists.\nDo I cancel ?"]} { return "" } set PAB "" } if {$Fichier=="AskForLimits"} { set Bornes "" while {$Bornes==""} { set SeqN [QueLaSequenceDuFichierTFA $FichierTfa] set Start [string range $SeqN 0 2] set Stop [string range $SeqN end-2 end] set AvantStop [string range $SeqN end-2 end] set Commentaire "($Start ... $Stop [AAduCodon $Start] [AAduCodon $Stop]) Please give the end position + 1" set D 1 set F [string length $SeqN] set Dp [expr ($D-1)/3+1] set Fp [expr ($F-3)/3+1] set Bornes [Entre "$Dp $Fp $Commentaire"] if {$Bornes=="" && [OuiOuNon "Do I cancel ?"]} { return "" } } regsub { *\(.*$} $Bornes "" Bornes Espionne $Bornes while {[regexp " " $Bornes]} { regsub -all " " $Bornes " " Bornes } set LesBornesDesFragments [split [string trim $Bornes] " "] } else { set LesBornesDesFragments [LesLignesDuFichier $Fichier] } set LesFragments {} while {$LesFragments=={}} { set LesFragments [CombineLesFragments $PAB $LesBornesDesFragments] if {$LesFragments=={} && [OuiOuNon "Do I cancel GenereFragments ? "]} { return "" } } if {[OuiOuNon "Do I save these fragments in a file ?"]} { set FicFrags [FichierPourSaveAs "./[Alias $PAB].frag"] if {$FicFrags==""} { return "" } SauveLesLignes $LesFragments dans $FicFrags } } FaireLire "Please choose the directory to store the isolate files (nuctfa and prottfa)" set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."] set LesNomDuAlias {} foreach Fragment $LesFragments { scan $Fragment "%s %s %s %s" PAB Frag Debut Fin Espionne "$PAB $Frag $Debut $Fin" set Alias [AliasPourClonage $PAB] set NomDuAlias "" regexp {^([^_])+} $Alias NomDuAlias if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias } set DejaVu($NomDuAlias) 1 set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"] ScanLaListe $LesSequencesNP SeqN SeqP Espionne "SeqN $PAB $Frag $Debut $Fin $SeqN" Espionne "SeqP $PAB $Frag $Debut $Fin $SeqP" set FicN "$Rep/$Alias-$Debut-$Fin.nuctfa" set FicP "$Rep/$Alias-$Debut-$Fin.prottfa" set EnteteN "$Alias-$Debut-$Fin [string length $SeqN] bases" set EnteteP "$Alias-$Debut-$Fin [string length $SeqP] AAs" set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"] lappend LeTFAs $TfaN lappend LesFicN [Sauve $TfaN dans $FicN] if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } { set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"] lappend LesFicP [Sauve $TfaP dans $FicP] } } } set NomConstruction [join $LesNomDuAlias "-"] while {$FichierTFAs==""} { FaireLire "Please give a name for the TFAs construction file" set FichierTFAs [FichierPourSaveAs "./$NomConstruction.tfa"] if {$FichierTFAs=="" && [OuiOuNon "Do I cancel GenereFragments ?"]} { return "" } } SauveLesLignes $LeTFAs dans $FichierTFAs return $FichierTFAs } proc GenereOligos {{Construction ""} {SavSapFavFap ""}} { Wup "Construction is the name of a TFAs file" Wup "SavSapFavFap a list of LesAvants LesApres FichierDesAvants FichierDesApres" while {$SavSapFavFap==""} { set SavSapFavFap [ChoisisFichierSignauxEtSignaux] if {$SavSapFavFap=={} && [OuiOuNon "Do You want an empty list of signals ?"]} { break } if {$SavSapFavFap=={} && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} } } if {$Construction==""} { FaireLire "Please choose only ONE construction file" set Construction [lindex [LesFichiersDeType "Construction"] 0] if {$Construction=="" && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} } } set Sortie [OligosEtProduitsPCR $Construction $SavSapFavFap] return $Sortie } proc GenereTabSeq {LesNoms aTabSeq} { global GpesSequences upvar $aTabSeq TabSeq #Attribue un numero de groupes aux sequences (TabSeq($seq)) #Constitue une liste (NbSeqGpe) avec le nombre de seq par groupe foreach seq $LesNoms { set TabSeq($seq) [lsearch -regexp $GpesSequences $seq] } } proc GenererMatrice {LongueurDesSequences} { # Générateur de matrice de poids é partir d'une liste de séquences set Carac "" set SequencesTFA [open "/genomics/link/UCSCAlignements/g11/STAF/fiches/HMM/XP" "r"] set FichierTransfac "[Fiches]/Profile/Transfac.lib" if { [file exists $FichierTransfac] } { file delete $FichierTransfac } set I 1 set NbLignes 0 set Un 0 #AppendAuFichier $FichierTransfac "A T C G" AppendAuFichier $FichierTransfac "AC STAF" AppendAuFichier $FichierTransfac "ID STAF" AppendAuFichier $FichierTransfac "NA STAF" AppendAuFichier $FichierTransfac "MATR_LENGTH $LongueurDesSequences" AppendAuFichier $FichierTransfac "CORE_START 3" AppendAuFichier $FichierTransfac "CORE_LENGTH 3xé" AppendAuFichier $FichierTransfac "MAXIMAL 7234.2041" AppendAuFichier $FichierTransfac "MINIMAL 0.0000" AppendAuFichier $FichierTransfac "THRESHOLD 0.6624" AppendAuFichier $FichierTransfac "WEIGHTS" array unset Tableau foreach base [list "A" "C" "G" "T"] { for {set I 1} {$I<=$LongueurDesSequences} {incr I} { set Tableau($I,$base) 0 } } while { [gets $SequencesTFA Ligne] >=0 } { for {set I 1} {$I<=$LongueurDesSequences} {incr I} { set Carac [string index $Ligne [expr $I - 1] ] incr Tableau($I,$Carac) } } for {set I 1} {$I<=$LongueurDesSequences} {incr I} { set ligne {} # set ConsensusPos [string index $Consensus [expr $I - 1] ] foreach base [list "A" "C" "G" "T"] { lappend ligne "$base:$Tableau($I,$base)" } AppendAuFichier $FichierTransfac "$I $ligne" } AppendAuFichier $FichierTransfac "//" } proc GenesDansLesSegmentsOligoAmplifOuDelet {LimInf LimSup {LesPos ""} {LesNoms ""}} { # liste les genes Refseq et Genbank selon le fichier UCSC refLink.txt (MaJ Jan 2007) # et elmimine la redondance # Liste des cas set LesCas {Oligo806 Oligo807 Oligo809 Oligo810 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo817 Oligo818 Oligo819 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825 Oligo826 Oligo827} Espionne [llength $LesCas] # Liste chromosomes set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} ################## UCSC ################### # Remarque : UCSC regroupe des access Genbank et des access Refseq # Version Genome Humain : NCBI Build 36 # Version UCSC : April 2006 pour knownGene.txt (position des genes) # Version UCSC : Jan 2007 pour refLink.txt (lien entre NM et NP) # ftp://hgdownload.cse.ucsc.edu/goldenPath/currentGenomes/Homo_sapiens/database ########################################### # Position des genes set FichierLocGenes "[RepertoireDuGenome]/PRIMA_Affichage/HumanAllGenesUCSC" if {![file exists $FichierLocGenes] || $FichierLocGenes == ""} {return ""} foreach Chromosome $ListeChro { ChargeFichierLoc TabG $FichierLocGenes $Chromosome $LesNoms if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabG($FichierLocGenes,Chromosome,$Chromosome,$Nom)] { set DebutGene [lindex $LInfo 1] set FinGene [lindex $LInfo 2] set Deb($Chromosome,$Nom) $DebutGene set Fin($Chromosome,$Nom) $FinGene } } } } # pour chaque fichier CGH Segmente foreach NomFichier $LesCas { set NomFichierSeg "$NomFichier\.seg" set FichierSeg "[RepertoireDuGenome]/PRIMA_CGH_SEG/$NomFichierSeg" # Pour chaque chromosome foreach Chromosome $ListeChro { set x [InterrogeFichierSEG $FichierSeg "unset"] ChargeFichierSEG TabS $FichierSeg $Chromosome $LesPos if {[info exists TabS($FichierSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabS($FichierSeg,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabS($FichierSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] set Val [format "%.2f" [expr $Val*1.0]] #($Val>0 && $Val>=$LimSup) || ($Val<0 && $Val<=$LimInf) if {($Val>0 && $Val>=$LimSup) || ($Val<0 && $Val<=$LimInf)} { # Quels genes? if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} { # Pour chaque Gene foreach Name [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] { # Soit le gene est : |-------------| # 1 : a cheval sur le debut du segment ***** # 2 : a cheval sur la fin du segment | ***** # 3 : au sein du segment | ***** | # 4 : par dela le segment ******************* # remarque: le cas 4 n'est pas rencontre ds les tests faits if {$PosInf>=$Deb($Chromosome,$Name) && $PosInf<=$Fin($Chromosome,$Name) || $PosSup>=$Deb($Chromosome,$Name) && $PosSup<=$Fin($Chromosome,$Name) || $PosInf<=$Deb($Chromosome,$Name) && $PosSup>=$Fin($Chromosome,$Name) || $PosInf>=$Deb($Chromosome,$Name) && $PosSup<=$Fin($Chromosome,$Name)} { lappend LesGenes $Name } } } } } } } } } Espionne [llength $LesGenes] set LesGenesU [lsort -unique $LesGenes] Espionne [llength $LesGenesU] #return $LesGenes set LesGbSansRef "" set LesGenesUniques "" foreach Gene $LesGenesU { if {[regexp "NM" $Gene]} { if {![info exists Vu($Gene)]} {set Vu($Gene) 1; lappend LesGenesUniques $Gene} } else { #Espionne $Gene set Commande "getz \"\\\[genbankfull-acc:$Gene\\\]\\\>\\\[refseq-org:Homo sapiens\\\]\" \-vf acc" set GetzOut [eval exec $Commande] if {$GetzOut==""} { lappend LesGbSansRef $Gene #Espionne "no seq for $Gene" } else { set LesElts [split $GetzOut "\t"] foreach Elt $LesElts { if {[regexp "\:" $Elt]} { continue } elseif {![info exists Vu($Elt)]} { set Vu($Elt) 1 lappend LesGenesUniques $Elt } } } } } SauveLesLignes $LesGbSansRef dans "/genomics/link/Procure/LesGbSansRef" SauveLesLignes $LesGenesUniques dans "/genomics/link/Procure/LesGenesCGHOligoSEG06_uniq" return } proc GenesFromOmimHitsFromFile {{File ""} {WithinGeneList ""}} { set WithAllGenes 1 if {$WithinGeneList!=""} { set WithAllGenes 0 if {[llength $WithinGeneList]==1 && [file exists $WithinGeneList]} { set WithinGeneList [LesLignesDuFichier $WithinGeneList] } foreach Ligne $WithinGeneList { regsub -all {[ \,/]+} $Ligne " " Ligne foreach Gn [split [string trim $Ligne] " "] { set GN [string toupper $Gn] set WithGene($GN) 1 lappend LesGN $GN } } set LesGN [lsort -unique $LesGN] FaireLire "il y a [llength $LesGN] genes differents dans $WithinGeneList" } set LaSortie {} foreach O [OmimHitsFromFile $File "ListOf" "O"] { foreach Gn [MorbidMap $O "Gn"] { lappend LesGn $Gn lappend LesOduGn($Gn) $O } } set LesGn [lsort -unique $LesGn] foreach Gn $LesGn { if { ! $WithAllGenes } { set GN [string toupper $Gn] if { ! [info exists WithGene($GN)]} { continue } } set LesOduGn($Gn) [lsort -unique $LesOduGn($Gn)] foreach O $LesOduGn($Gn) { set Dis [join [MorbidMap $O "Di"] " /// "] lappend LaSortie "$Gn\t$O\t$Dis" } } return $LaSortie } proc GenesFromZone {Debut Fin Org Chr {Strand ""} {FromWhere ""}} { Wup "Attention UCSC compte a partir de 0" if {$FromWhere==""} { set FromWhere "refGene" } set org [string tolower $Org] set fromwhere [string tolower $FromWhere] set Where "chrom='$Chr' and txstart>=$Debut and txend<=$Fin" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select NAME, TXSTART, TXEND, STRAND from ucsc$org.$fromwhere where $Where order by TXSTART" set Racine [Bird $Query "documentelement"] set LesLignes {} foreach Noeud [$Racine selectNodes "resultset"] { set TxStart [$Noeud selectNodes "string(TXSTART)"] set TxEnd [$Noeud selectNodes "string(TXEND)"] set Strand [$Noeud selectNodes "string(STRAND)"] set Name [$Noeud selectNodes "string(NAME)"] set Ligne "$TxStart $TxEnd $Strand $Name" lappend LesLignes $Ligne } return $LesLignes } proc GenesJamaisExprimes {} { set nomtotal 0; set nomssps 0; set nomsspsMG430 0 set nomattention 0; set nommerdique 0 set nomfalse 0; set nomtrue 0 set nomplusdefalse 0; set nomplusdetrue 0 set nomquoi 0 set LesLignes [NomLigne ListeDes Lignes] set nblignes 0 set unnom 0; set plsnom 0 foreach Ligne $LesLignes { incr nblignes set ListeDesNoms {}; set BonneListeDesNoms {} set TousLesNoms [NomLigne $Ligne Noms] set ListeDesNoms [split $TousLesNoms " "] set NbDeNomPrUneLigne [llength $ListeDesNoms] if {[llength $ListeDesNoms]==1} { incr unnom set BonneListeDesNoms $ListeDesNoms } if {[llength $ListeDesNoms]>1} { incr plsnom set BonneListeDesNoms [split [RangeMoi get EviOf $Ligne] " "] } Espionne "" Espionne "Ligne $Ligne" foreach Nom $BonneListeDesNoms { Espionne "" set pssscall 0; set LesCallcgrma {} incr nomtotal set false 0; set true 0 set Gn [ExtraitInfo $Nom "ValiGN"] set ProbesSet [ExtraitInfo $Nom "ProbeSetId"] if {$ProbesSet=="no value" || $ProbesSet==""} { incr nomssps Espionne "$Nom n'a pas probeset" continue } set LesProbesSet [split $ProbesSet ","] Espionne "$Nom" foreach Ps $LesProbesSet { set Ligne {} set Callcgrma [TrouveLesJamaisExprimes $Ps OuiNon] Espionne "$Ps $Callcgrma" lappend LesCallcgrma $Callcgrma #EspionneL "1LesCallcgrma $LesCallcgrma" if {$Callcgrma=="FALSE"} {incr false} if {$Callcgrma=="TRUE"} {incr true} } Espionne "nbfalse= $false" Espionne "nbtrue = $true" set LesCallcgrma [ListeSsElmtVide $LesCallcgrma] #EspionneL "LesCallcgrma $LesCallcgrma" if {$true=="0" && $false=="0" && $LesCallcgrma== {} } { incr nomsspsMG430 Espionne "$Nom pas probeset MG430" } elseif {$true=="0" && $false=="0"} { incr nomattention Espionne "$Nom est attention" } elseif {$true==$false} { incr nommerdique Espionne "$Nom est merdique" } elseif {$true=="0"} { incr nomfalse Espionne "$Nom est false" } elseif {$false=="0"} { incr nomtrue Espionne "$Nom est true" } elseif {$true<$false} { set nbcallF [expr $true + $false] set pourcentagedefaulse [expr ($false*100)/$nbcallF] lappend Lespourcentagedefaulse $pourcentagedefaulse incr nomplusdefalse Espionne "$Nom est plus false $pourcentagedefaulse" } elseif {$true>$false} { set nbcallT [expr $true + $false] set pourcentagedetrue [expr ($true*100)/$nbcallT] lappend Lespourcentagedetrue $pourcentagedetrue incr nomplusdetrue Espionne "$Nom est plus true $pourcentagedetrue" } else { incr nomquoi Espionne "$Nom est quoi" } } } set Lespourcentagedefaulse [ListeSansDoublon $Lespourcentagedefaulse] set Lespourcentagedetrue [ListeSansDoublon $Lespourcentagedetrue] Espionne "nblignes $nblignes" Espionne "nomtotal $nomtotal" Espionne "nomssps $nomssps" Espionne "nomsspsMG430 $nomsspsMG430" Espionne "nomattention $nomattention" Espionne "nommerdique $nommerdique" Espionne "nomfalse $nomfalse" Espionne "nomtrue $nomtrue" Espionne "nomplusdefalse $nomplusdefalse" Espionne "nomplusdetrue $nomplusdetrue" Espionne "nomquoi $nomquoi" Espionne "Lespourcentagedefaulse $Lespourcentagedefaulse" Espionne "Lespourcentagedetrue $Lespourcentagedetrue" } proc GenesSurPlamides {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } scan $Ligne "%s %s %s %s" FichPlasmide SeqPrimer NomDuPrimer NouCter set Sens "Direct" set PosN [PositionDuPatternDansFichierTFA $SeqPrimer $FichPlasmide $Sens "NA" "Circulaire"] if {$PosNuc==-1} { set Sens "RaC" set PosN [PositionDuPatternDansFichierTFA $SeqPrimer $FichPlasmide $Sens "NA" "Circulaire"] } if {$PosNuc==-1} { FaireLire "I didn't find $SeqPrimer in $FichPlasmide" continue } Espionne "$Ligne $PosNuc $Sens" } exit } proc GenomeDu {Nom} { global RepertoireDuGenome global GenomeDu regsub -all {[0-9]} $Nom "" Prefixe if {[info exists GenomeDu($Prefixe)]} { return [set GenomeDu($Prefixe)] } if {[regexp "^TRNA|^ARN|^GLIMMER" $Nom]} { FaireLire "Desole. Je ne puis trouver le genome de $Nom." return "" } if {[info exists GenomeDu("EstCharge")]} { return "" } foreach FichierBornes [glob "/genomics/link/*/fiches/bornesdespabs"] { set NomGscope [file tail [file dirname [file dirname $FichierBornes]]] if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue } scan [PremiereLigneDuFichier $FichierBornes] "%s" NomLu regsub -all {[0-9]} $NomLu "" PrefixeLu regsub "/fiches/bornesdespabs" $FichierBornes "" Genome lappend GenomeDu($PrefixeLu) $Genome } set GenomeDu("EstCharge") "EstCharge" return [GenomeDu $Nom] } proc Genomics {} { global Genomics if {[info exists Genomics]} { return $Genomics } set Genomics "/genomics" if {[file exists $Genomics]} { return $Genomics } global RepertoireDuGenome if { [info exists RepertoireDuGenome]} { set Genomics [file dirname $RepertoireDuGenome] if { ! [regexp {/g[0-9][0-9]?$} $Genomics] && [file exists $Genomics]} { return $Genomics } } set Genomics [tk_chooseDirectory -mustexist 1 -title "Please browse for the genomics directory which should contain your Gscope project"] return $Genomics } proc GenomicsFree {{Qui ""}} { set LesDisques [GenomicsPossibles] lappend LesDisques "/" foreach GG $LesDisques { if {[FileAbsent $GG]} { continue } set G [file tail $GG] if {$G==""} { set G "/" } if {$GG!="/" && ! [regexp {^g[0-9]+$} $G]} {continue } set df [exec df -P -k $GG] set LesMots [LesMotsDeLaLigne $df] set LesBons [lrange $LesMots end-4 end] set g "/" ScanLaListe $LesBons T U F g set FF [format "%5.1f" [expr (1.0*$F)/1000000]] if {$Qui==$G} { return $FF } lappend LesFree "$GG $FF" } set Free [join $LesFree "\n"] if {[PourWscope]} { return "

$Free

" } if {$Qui=="GetText"} { return $Free } return $LesFree } proc GenomicsLinks {{DoIt ""}} { if {$DoIt==""} { set DoIt "Ask" } if {[string equal -nocase $DoIt "Ask"]} { set DoIt [OuiOuNon "Dans /genomics/link\nj'enleve les liens inexistants, je cree les manquants. \nSi tu n'es pas sûr, on fait d'abord un tour pour rien, je te repose la question à la fin.\n Je le fais pour de bon tout de suite ?" 0] } else { set DoIt [string equal -nocase $DoIt "DoIt"] } cd /genomics set LesLinks [glob -type link "/genomics/link/*"] set LesDelete {} set LesNouveaux {} set LesExistants {} if { ! $DoIt} { lappend LesNouveaux "cd /genomics/link" } foreach Link $LesLinks { if {[file type $Link]!="link"} { continue } set File [file readlink $Link] if {[file exists $File]} { lappend LesExistants $File; continue } Espionne "file delete $Link" if {$DoIt} { file delete $Link ; lappend LesDelete $Link } else { lappend LesDelete "rm $Link" } } cd /genomics/link set LesRepPossible {} LConcat LesRepPossible [glob -nocomplain -type d "/gstock/*"] LConcat LesRepPossible [glob -nocomplain -type d "/gstock/ProGscope/*/*"] LConcat LesRepPossible [glob -nocomplain -type d "/gstock/user/*/*"] foreach F $LesRepPossible { set Queue [file tail $F] if {[regexp {lost\+found} $Queue]} { continue } if {[regexp Projets_Manu $F]} { continue } #rR pour ne pas relinker les /genomics/g... if {[info exists DejaVu($Queue)]} { FaireLire "$F\n deja vu \n$DejaVu($Queue)" } set DejaVu($Queue) $F set Link "/genomics/link/$Queue" if {[file exists $Link]} { continue } Espionne "ln -sf $F" if {$DoIt} { exec ln -sf $F lappend LesNouveaux $Link lappend LesExistants $Link } else { lappend LesNouveaux "ln -sf $F" } } set Message "ToDo" AfficheListe $LesDelete "" "LesDelete $Message" AfficheListe $LesNouveaux "" "LesNouveaux $Message" AfficheListe $LesExistants "" "LesExistants" if { ! $DoIt && [OuiOuNon "Je refais un tour pour exécuter toutes les instructions ?"]} { return [GenomicsLinks "DoIt"] } return $LesExistants } proc GenomicsPossibles {} { set Possible [list "[Genomics]/link"] return $Possible } proc GenomicsSubDir {Dir} { set Queue [file tail $Dir] foreach Possible [GenomicsPossibles] { if {[file isdirectory $Possible/$Queue]} { return $Possible } } if {[file exists $Dir]} { return $Dir } return "[Genomics]" } proc GenomiqueComparativeParBlast {{RepBlast ""}} { set LaRecap {} set Libre [string repeat " " 35] if { ! [PourWscope]} { set Vide "" foreach Nom [ListeDesPABs] { lappend LaRecap "$Libre$Vide $Nom [Alias $Nom]" append Vide " " } } lappend LaRecap "$Libre 1 2 3 4 5" lappend LaRecap "$Libre 12345678901234567890123456789012345678901234567890" # set LO [OrganismesPourGenomiqueComparative] set LO [OrganismePresent RankedListOf AllOrganisms $RepBlast] set I 0 foreach RO $LO { incr I scan $RO "%s %s %s" R G E if {$E==""} { set E $G ; set G $R; set R $I } set O "$G $E" Espionne $O set C [OCduOS $O] set Recap "[format "%4d %-30s" $R $O] " foreach Nom [ListeDesPABs] { if {[OrganismePresent $Nom $O]==""} { append Recap " " } else { append Recap "X" } } append Recap " $C" lappend LaRecap $Recap } set Recap [join $LaRecap "\n"] set Bank [file tail $RepBlast] if {[PourWscope]} { set Header "

Genomique Comparative pour [PreFixe] par $Bank

" append Header "\nSee all [PreFixe] in an other window." return [Html_DuTexteTelQuel $Recap "GenomiqueComparative_$Bank" $Header] } set F [AfficheVariable $Recap "AvecRecap" "GenomiqueComparative_$Bank"] return $F } proc GenoretGenesUrl {} { set GenoretGenesUrl "http://genoret.lbgi.fr/GenoretGenes" return $GenoretGenesUrl } proc GenoretProteomicsLinks {{Qui ""} {Quoi ""}} { global GenoretProteomicsLinks if {$Qui == "Reset" && [info exists GenoretProteomicsLinks]} { unset GenoretProteomicsLinks ; return "" } if {$Qui==""} { set Qui "ListOf"; set Quoi "EVI" } if {$Quoi == ""} { set Quoi "All" } if {[info exists GenoretProteomicsLinks($Qui,$Quoi)]} { return $GenoretProteomicsLinks($Qui,$Quoi) } if {[info exists GenoretProteomicsLinks("EstCharge")]} { return "" } set GenoretProteomicsLinks("EstCharge") 1 set GenoretProteomicsLinks(ListOf,EVI) {} foreach Ligne [LesLignesDuFichier "[HomeRipp]/GenoretWww/Proteomics/GenoretGenesLinks.txt"] { scan $Ligne "%s %s" Nom Queue regsub { " $Ligne]} { lappend LesHeaders $Ligne } } } set LaListe {} set Organisme "" foreach Ligne $LesHeaders { if { ! [regexp -nocase {[a-z]+} $Ligne ]} { continue } regsub ">" $Ligne "" Ligne set Ligne [string toupper $Ligne] scan $Ligne "%s" BanqueNIdNF if { ! [regexp ":" $BanqueNIdNF] && [info exists BonBA($BanqueNIdNF)]} { regsub "^$BanqueNIdNF" $Ligne [set BonBA($BanqueNIdNF)] Ligne set BanqueNIdNF $BanqueNIdNF } set DebutFragment 1 if {[regexp "FROM BASE" $Ligne]} { set DebutFragment [IntegerApres "FROM BASE" dans $Ligne] } if {[regexp "from:" $Ligne]} { set DebutFragment [IntegerApres "FROM:" dans $Ligne] } ScanLaListe [split $BanqueNIdNF ":"] BanqueN IdNF set BanqueN [string toupper $BanqueN] set BanqueNIdNF "$BanqueN:$IdNF" regexp -nocase {[a-z]+} $BanqueN Banque set Nba 0 if {[regexp {[0-9]+} $BanqueN Nlu]} { set Nba $Nlu } set OriginalBanqueN($Banque,$Nba) $BanqueN set F 0 set IdN $IdNF if {[regexp "_" $IdNF]} { ScanLaListe [split $IdNF "_"] IdN F } regexp -nocase {[a-z]+} $IdN Id set Nid 0 if {[regexp -nocase {[0-9]+} $IdN Nlu]} { set Nid [Base10 $Nlu] } set OriginalIdN($Banque,$Nba,$Id,$Nid) $IdN set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $IdNF set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $BanqueNIdNF if { ! [info exists OrganismeDe($Banque)]} { set Organisme "" if {[regexp -nocase { [A-Za-z0-9_]+ [A-Z][a-z]+ [a-z]+\.?} $Ligne Match]} { regsub -nocase { [A-Za-z0-9_]+ } $Match "" Organisme set Organisme [Glossaire $Organisme Complet] } if {$Organisme==""} { if {$Banque=="BUCH"} { set Organisme "Buchnera sp" } if {$Banque=="BBURG"} { set Organisme "Borrelia burgdorferi" } if {$Banque=="BBUR"} { set Organisme "Borrelia burgdorferi" } if {$Banque=="DRA"} { set Organisme "Deinococcus radiodurans" } if {$Banque=="STYP"} { set Organisme "Salmonella typhi" } if {$Banque=="SYNE"} { set Organisme "Synechocystis sp" } if {$Banque=="AERO"} { set Organisme "Aeropyrum pernix" } if {$Banque=="YE"} { set Organisme "Saccharomyces cerevisiae" } if {$Organisme!=""} { set Organisme [Glossaire $Organisme Complet] } } if {$Organisme==""} { set Organisme [Glossaire $Banque Complet] } while {$Organisme==""} { FaireLire "$Ligne\n no organism detected.\n Please help me ..." set OrganismePropose [Entre] set Organisme [Glossaire $OrganismePropose Complet] if {$Organisme!=""} { break } if {[OuiOuNon "I don't know $OrganismePropose as organism name\n Do You want to keep it ?" ]} { set Organisme $OrganismePropose break } } set OrganismeDe($Banque) $Organisme } Espionne "$Banque $Nba $Id $Nid $F $DebutFragment $Organisme" lappend LaListe [list $Banque $Nba $Id $Nid $F $DebutFragment] } set LaListeBanque [lsort -index 0 $LaListe] set LaListe {} foreach Element $LaListeBanque { ScanLaListe $Element Banque Nba Id Nid F DebutFragment if {[lsearch -exact $LesGenomesEnSouches $Banque]!=-1} { set OriIdN [set OriginalIdN($Banque,$Nba,$Id,$Nid)] set OriIdNF [set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F)] set OriLign [set OriginalLigne($Banque,$Nba,$Id,$Nid,$F)] set OriginalIdN($Banque,$Nba,$Id,$Nid) $OriIdN set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $OriIdNF set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $OriLign } if {[lsearch -exact $LesGenomesEnSouchesChromosomiques $Banque]!=-1} { set OriIdN [set OriginalIdN($Banque,$Nba,$Id,$Nid)] set OriIdNF [set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F)] set OriLign [set OriginalLigne($Banque,$Nba,$Id,$Nid,$F)] set Nid $Nba set Nba 0 set OriginalIdN($Banque,$Nba,$Id,$Nid) $OriIdN set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $OriIdNF set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $OriLign } lappend LaListe [list $Banque $Nba $Id $Nid $F $DebutFragment] } foreach Element [lsort -index 0 $LaListe] { ScanLaListe $Element Banque Nba Id Nid F DebutFragment lappend SaListe($Banque) [list $Banque $Nba $Id $Nid $F $DebutFragment] if {[info exists DejaVu($Banque)]} { continue } set DejaVu($Banque) 1 lappend LesBanquesDansLOrdre $Banque } foreach Banque $LesBanquesDansLOrdre { foreach Element [lsort -index 2 [set SaListe($Banque)]] { ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment lappend SaListe($BanqueLu,$Id) [list $BanqueLu $Nba $Id $Nid $F $DebutFragment] if {[info exists DejaVu($BanqueLu,$Id)]} { continue } set DejaVu($BanqueLu,$Id) 1 lappend LesBanquesIdDansLOrdre "$BanqueLu,$Id" } } foreach BanqueId $LesBanquesIdDansLOrdre { foreach Element [lsort -integer -index 3 [set SaListe($BanqueId)]] { ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment lappend SaListe($BanqueLu,$Id,$Nid) [list $BanqueLu $Nba $Id $Nid $F $DebutFragment] # Espionne "BanqueIdN $BanqueLu $Nba $Id $Nid $F $DebutFragment" if {[info exists DejaVu($BanqueLu,$Id,$Nid)]} { continue } set DejaVu($BanqueLu,$Id,$Nid) 1 lappend LesBanquesIdNDansLOrdre "$BanqueLu,$Id,$Nid" } } ScanLaListe {-1 -1 -1 -1 -1 -1} oBanqueLu oNba oId oNid oF oDebutFragment foreach BanqueIdN $LesBanquesIdNDansLOrdre { set SaListe($BanqueIdN) [lsort -integer -index 5 [set SaListe($BanqueIdN)]] foreach Element [set SaListe($BanqueIdN)] { ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment if {$BanqueLu != $oBanqueLu || $Nba != $oNba} { set Offset 0 } if {$BanqueLu == $oBanqueLu && $Nba == $oNba && ($Id != $oId || $Nid != $oNid)} { set Offset [expr $oDebutFragment + 200000] } set NewDebutFragment [expr $Offset+$DebutFragment] set OffsetDuFragment [expr $NewDebutFragment - 1] set Organisme [set OrganismeDe($BanqueLu)] set BA [set OriginalLigne($BanqueLu,$Nba,$Id,$Nid,$F)] set B [lindex [split $BA ":"] 0] Espionne "$B $BA" set TaxId [TaxIdDuGenomeComplet $B] while {$TaxId==""} { if {[info exists DejaDemandeTaxID($B)]} { set TaxId [set DejaDemandeTaxID($B)] break } set OB [Glossaire $B "Complet"] set TOB [Tax $OB] FaireLire "I couldn't find TaxIdDuGenomeComplet $B\nPlease help me. $B could be '$OB'\nits TaxId is '$TOB'" set TaxId [Entre $TOB] } set DejaDemandeTaxID($B) $TaxId if { ! [info exists DejaVerifie($TaxId)]} { set Name [Tax $TaxId Name] if { ! [regexp $Organisme $Name]} { FaireLire "$TaxId = $Name is not $Organisme" } set DejaVerifie($TaxId) $Organisme } else { if {[set DejaVerifie($TaxId)]!=$Organisme} { FaireLire "$TaxId was [set DejaVerifie($TaxId)] now I found $Organisme" } } lappend Sortie "$BA $BanqueLu $Nba $Id $Nid $F $DebutFragment $OffsetDuFragment $Organisme $TaxId" set oElement $Element ScanLaListe $oElement oBanqueLu oNba oId oNid oF set oDebutFragment $NewDebutFragment } } return [SauveLesLignes $Sortie dans $FichierFragments] } proc GereLesZoneEtiquettee {K x y ItemType Action} { global DernierXDeZoneEtiquettee DernierYDeZoneEtiquettee global DernierStartDeZoneEtiquettee global ZoneEtiquetteeTouchee global LesCouleursDeZoneEtiquettee global LesTaillesDeZoneEtiquettee global CouleurDuFond global ParametresDuBoard set PI 3.14159 set X [$K canvasx $x] set Y [$K canvasy $y] set xFin [set ParametresDuBoard($K,xFin)] set CentreX [set ParametresDuBoard($K,CentreX)] set CentreY [set ParametresDuBoard($K,CentreY)] if { ! [info exists LesCouleursDeZoneEtiquettee] } { set LesCouleursDeZoneEtiquettee {} lappend LesCouleursDeZoneEtiquettee "black" lappend LesCouleursDeZoneEtiquettee "grey" lappend LesCouleursDeZoneEtiquettee "white" lappend LesCouleursDeZoneEtiquettee "blue" lappend LesCouleursDeZoneEtiquettee "lightblue" lappend LesCouleursDeZoneEtiquettee "yellow" lappend LesCouleursDeZoneEtiquettee "green" lappend LesCouleursDeZoneEtiquettee "orange" lappend LesCouleursDeZoneEtiquettee "red" lappend LesCouleursDeZoneEtiquettee "purple" lappend LesCouleursDeZoneEtiquettee $CouleurDuFond set LesTaillesDeZoneEtiquettee {"Raise" "Lower" "Extent" "Copy" "Other" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20} } if {$Action == "Motion"} { if { $ItemType=="arc" } { set DeltaX [expr $x-$DernierXDeZoneEtiquettee] set DeltaY [expr $y-$DernierYDeZoneEtiquettee] set DernierStartDeZoneEtiquettee [expr $DernierStartDeZoneEtiquettee + $DeltaX] $K itemconfigure $ZoneEtiquetteeTouchee -start $DernierStartDeZoneEtiquettee } else { $K move $ZoneEtiquetteeTouchee [expr $x-$DernierXDeZoneEtiquettee] [expr $y-$DernierYDeZoneEtiquettee] } set DernierXDeZoneEtiquettee $x set DernierYDeZoneEtiquettee $y return } set ZoneEtiquetteeTouchee [$K find withtag current] if {$Action == "Point"} { set ZoneEtiquetteeTouchee [$K find withtag current] set DernierXDeZoneEtiquettee $x set DernierYDeZoneEtiquettee $y if { $ItemType=="arc"} { set DernierStartDeZoneEtiquettee [$K itemcget $ZoneEtiquetteeTouchee -start] } return } if {$Action == "Erase"} { if { ! [OuiOuNon "Do you really want to erase this $ItemType"]} { return 0 } $K delete $ZoneEtiquetteeTouchee return 1 } if {$Action == "ModifCouleur"} { set Couleur [ChoixParmi [concat $LesCouleursDeZoneEtiquettee "NewColor"] [concat $LesCouleursDeZoneEtiquettee "white"]] if {$Couleur == ""} { return "" } if {$Couleur == "NewColor"} { set Couleur [PaletteDeCouleurs] if {$Couleur == ""} { return "" } lappend LesCouleursDeZoneEtiquettee $Couleur } if { $ItemType=="polygone"} { $K itemconfigure $ZoneEtiquetteeTouchee -fill $Couleur $K itemconfigure $ZoneEtiquetteeTouchee -outline $Couleur return $Couleur } if { $ItemType=="arc"} { $K itemconfigure $ZoneEtiquetteeTouchee -outline $Couleur return $Couleur } if { $ItemType=="text" || $ItemType=="line"} { $K itemconfigure $ZoneEtiquetteeTouchee -fill $Couleur return $Couleur } } if {$Action == "ModifTaille"} { set Taille [ChoixParmi $LesTaillesDeZoneEtiquettee] if {$Taille == ""} { return "" } if {$ItemType == "arc" && $Taille == "Copy"} { set Extent [$K itemcget $ZoneEtiquetteeTouchee -extent] $K itemconfigure $ZoneEtiquetteeTouchee -extent [expr $Extent*[Entre 0.9]] return } if {$ItemType == "arc" && $Taille == "Extent"} { set Extent [$K itemcget $ZoneEtiquetteeTouchee -extent] $K itemconfigure $ZoneEtiquetteeTouchee -extent [expr $Extent*[Entre 0.9]] return } if {$Taille == "Raise"} { $K raise $ZoneEtiquetteeTouchee return "Raise" } if {$Taille == "Lower"} { $K raise $ZoneEtiquetteeTouchee return "Lower" } if {$ItemType == "line" && $Taille == "Arrow"} { set AvAr [$K itemcget $ZoneEtiquetteeTouchee -arrow] if {$AvAr=="first"} { set AvAr "last" } else { set AvAr "first" } $K itemconfigure $ZoneEtiquetteeTouchee -arrow $AvAr return } if {$Taille == "Other"} { set Taille [Entre 21] if {$Taille == ""} { return "" } lappend LesTaillesDeZoneEtiquettee $Taille } if { $ItemType=="arc" || $ItemType=="line" } { $K itemconfigure $ZoneEtiquetteeTouchee -width $Taille return $Taille } if { $ItemType=="text"} { $K itemconfigure $ZoneEtiquetteeTouchee -font [list Courier $Taille] return $Taille } } if {$Action == "ModifTexte"} { set Texte [Entre] if {$Texte == ""} { return "" } if { $ItemType=="text"} { $K itemconfigure $ZoneEtiquetteeTouchee -text $Texte return $Texte } } } proc GestionDesClones {} { set LesEtapes [MorceauxChoisis [list 10_MutateSequence 11_CreateOligosForMutation 13_CreateOligosForSequencing 15_GenereFragments 16_GenereOligos 22_CommandeOligos 23_StockeOligos 31_RecombinaisonPremiere 32_DepartSequencage 33_VerificationSequencage 41_RecombinaisonSeconde 42_Extension5Prime 51_AfficheFusionEtCoupure 52_CoupureDesADNCirculaires 55_OligAuto 60_WebOrder 70_AnalyseDesSequences] "" "Please select one or more steps to perform."] set SortieMutateSequence "" set SortieCreateOligosForMutation "" set SortieGenereFragments "" set SortieGenereOligos "" set FichierOligos "" set FichierProduitsPCR "" set FichierStockeOligos "" set SortieCommandeOligos "" set SortieStockeOligos "" set SortieRecombinaisonPremiere "" set SortieRecombinaisonSeconde "" set SortieExtension5Prime "" set SortieDepartSequencage "" set SortieVerificationSequencage "" set SortieCoupureDesADNCirculaires "" set OldEtape "" foreach Etape [lsort $LesEtapes] { regsub {[0-9A-Z]+_} $Etape "" Etape if {$Etape=="StockeOligos" && $OldEtape=="CommandeOligos"} { continue } if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForMutation"} { continue } if {$Etape=="GenereOligos" && $OldEtape=="CreateOligosForMutation"} { continue } if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForSequencing"} { continue } if {$Etape=="GenereOligos" && $OldEtape=="CreateOligosForSequencing"} { continue } set OldEtape $Etape switch -regexp $Etape { "MutateSequence" { while 1 { set FichierDesMutations "" if {[OuiOuNon "Can You browse for a file with lines containing\n PGS018 PGS518 S379R -M1 ( creates PGS518 alias hRAR-M1 )\n PGS018 PGS618 S379R E245A -M2 ( creates PGS618 alias hRAR-M2 )\n PGS025 PGS525 S379R E245A =MutedRARg ( creates PGS525 alias MutedRARg )"]} { set FichierDesMutations [ButineArborescence "All"] if {$FichierDesMutations==""} { continue } break } else { if {[OuiOuNon "Do You want to enter [PreFixe] and mutation code ?"]} { break } if {[OuiOuNon "Do we cancel MutateSequence ?"]} { continue } if {[OuiOuNon "Do we cancel the whole process ?"]} { return "" } } } if {$FichierDesMutations==""} { set SortieMutateSequence [MutateSequence] } else { set SortieMutateSequence [MutateSequencesListedIn $FichierDesMutations] } while {[OuiOuNon "Do I save the description file of these mutations ?"]} { regsub {\.codemut.*$} $FichierDesMutations "" FichierDesMutationsFaites set FichierDesMutationsFaites "$FichierDesMutationsFaites.mutedone" set FichierDesMutationsFaites [FichierPourSaveAs $FichierDesMutationsFaites] if {$FichierDesMutationsFaites==""} { continue } Sauve $SortieMutateSequence dans $FichierDesMutationsFaites break } } "CreateOligosForMutation" { set FichierOuTexteOliMut "" if {$SortieMutateSequence!=""} { set FichierOuTexteOliMut $SortieMutateSequence } else { if {[OuiOuNon "can You browse for a file with lines containing\n PGS018 PGS518 S379R\n PGS018 PGS618 S379R E245A\n PGS025 PGS525 Q334T I289W P345LL"]} { set FichierOuTexteOliMut [ButineArborescence All] } } set SortieCreateOligosForMutation [CreateOligosForMutation $FichierOuTexteOliMut] set FichierOligos $SortieCreateOligosForMutation } "CreateOligosForSequencing" { set FichierOuTexteOliSeq "" while 1 { if {[OuiOuNon "Do You have a file with [PreFixe]s or fragments to sequence ?"]} { set FichierOuTexteOliSeq [ButineArborescence All] } elseif {[OuiOuNon "Do You want to enter it ?"]} { FaireLire "Remember that you can add lines with (AA count)\n PGS160 SeqCheck\n PGS161 120 989" set CancelOFOFS 0 while { $FichierOuTexteOliSeq==""} { set FichierOuTexteOliSeq [string trim [EntreTexte] "\n"] Espionne $FichierOuTexteOliSeq if {$FichierOuTexteOliSeq==""} { if {[OuiOuNon "May be You forgot to Validate\nTry again ?"]} { continue } if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} { set CancelOFOFS 1 break } } } if {$CancelOFOFS} { break } } if {$FichierOuTexteOliSeq!=""} { break } if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} { break } } if {$FichierOuTexteOliSeq==""} { set SortieCreateOligosForSequencing "" } else { set SortieCreateOligosForSequencing [CreateOligosForSequencing $FichierOuTexteOliSeq] } set FichierOligos $SortieCreateOligosForSequencing } "GenereFragments" { set SortieGenereFragments [GenereFragments] } "GenereOligos" { set SortieGenereOligos [GenereOligos $SortieGenereFragments] set FichierOligos [lindex $SortieGenereOligos 0] set FichierProduitsPCR [lindex $SortieGenereOligos 1] } "CommandeOligos|StockeOligos" { if {$FichierOligos==""} { set LesFichiersOligos [LesFichiersDeType "Oligo"] } else { set LesFichiersOligos [list $FichierOligos] } set StockeOnly "" if {[regexp "StockeOligos" $Etape]} { set StockeOnly "StockeOnly" } set SortieCommandeOligos [CommandeOligos $LesFichiersOligos $StockeOnly] } "RecombinaisonPremiere" { set RepPPCR "[RepertoireDuGenome]/ppcr" if {$FichierProduitsPCR==""} { set LesFichiersUnProduitPCR {} foreach FichierProduitsPCR [LesFichiersDeType "Ppcr"] { if {[regexp "ppcr_virtuels" $FichierProduitsPCR]} { set LesNouveauxFichiersUnProduitPCR [list $FichierProduitsPCR] } else { if {[OuiOuNonMemo "Do I keep the filenames for single TFA file instead of Use_access"]} { if {[string first ">" [ContenuDuFichier $FichierProduitsPCR] 2]>-1} { FaireLire "Attention there are more than 1 sequence in $FichierProduitsPCR\n I'll split it, using the access as filename" set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR $RepPPCR "Use_access_but_remove_signals"] } else { set LesNouveauxFichiersUnProduitPCR $FichierProduitsPCR } } else { set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR $RepPPCR "Use_access_but_remove_signals"] } } LConcat LesFichiersUnProduitPCR $LesNouveauxFichiersUnProduitPCR } } else { set LesFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR $RepPPCR "Use_access_but_remove_signals"] } set FichierVecteur [LesFichiersDeType "pDONR"] set NomVec [file tail $FichierVecteur] regsub ".tfa$" $NomVec "" NomVec set LesFichiersRecombinaisonPremiere {} foreach FichierUnPPCR $LesFichiersUnProduitPCR { set Queue [file tail $FichierUnPPCR] regsub "\.tfa$" $Queue "" Queue set FichierRecombinaison "[RepertoireDuGenome]/rec1/${Queue}_$NomVec" lappend LesFichiersRecombinaisonPremiere [Recombinaison $FichierUnPPCR $FichierVecteur $FichierRecombinaison "" "Premiere"] } set SortieRecombinaisonPremiere $LesFichiersRecombinaisonPremiere Rec1 ReLoad } "DepartSequencage" { if {$SortieRecombinaisonPremiere!=""} { set Source $SortieRecombinaisonPremiere } else { set Source "" } set SortieDepartSequencage [DepartSequencage $Source] } "VerificationSequencage" { set Source [ChoixParmi [list "GATC" "GetMacSeq" "AskForSequence"]] set BanqueSpecif "" while {[OuiOuNon "Do I use a [PreFixe] specific blast database for all sequences You'll choose" 0]} { while 1 { set SpecifPGS [Entre [PreFixe]] if {[EstUnPAB $SpecifPGS]} { break } set SpecifPGS [NomDuAlias $SpecifPGS] if {[EstUnPAB $SpecifPGS]} { break } } if {$SpecifPGS==""} { continue } set BanqueSpecif "Specif_$SpecifPGS" set BanqueSpecif [CreeLaBanqueBlastClonage $BanqueSpecif $SpecifPGS] break } set SortieVerificationSequencage [VerificationSequencage $Source $BanqueSpecif] } "RecombinaisonSeconde" { if {$SortieRecombinaisonPremiere!=""} { set LesFichiersRecombinaisonPremiere $SortieRecombinaisonPremiere } else { set LesFichiersRecombinaisonPremiere [LesFichiersDeType "Rec1"] } set LesFichierVecteur [LesFichiersDeType "pDEST"] set LesFichiersRecombinaisonSeconde {} foreach FichierRec1 $LesFichiersRecombinaisonPremiere { foreach FichierVecteur $LesFichierVecteur { set NomVecteur [file tail $FichierVecteur] regsub ".tfa$" $NomVecteur "" NomVecteur regsub "/rec1/" $FichierRec1 "/rec2/" FichierRec2 regsub ".tfa$" $FichierRec2 "" FichierRec2 append FichierRec2 "_$NomVecteur" lappend LesFichiersRecombinaisonSeconde [Recombinaison $FichierRec1 $FichierVecteur $FichierRec2 "" "Seconde"] } } set SortieRecombinaisonSeconde $LesFichiersRecombinaisonSeconde Rec2 ReLoad } "Extension5Prime" { if {$SortieRecombinaisonSeconde!=""} { set LesFichiersRecombinaisonSeconde $SortieRecombinaisonSeconde } else { set LesFichiersRecombinaisonSeconde [LesFichiersDeType "Rec2"] } set LesFiFuN {} foreach FichierRec2 $LesFichiersRecombinaisonSeconde { set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $FichierRec2] if {$FiFuNP!=""} { scan $FiFuNP "%s" FiFuN lappend LesFiFuN $FiFuN } } set SortieExtension5Prime $LesFiFuN } "AfficheFusionEtCoupure" { if {$SortieExtension5Prime!=""} { set LesFiFuN $SortieExtension5Prime } else { set LesFiFuN [LesFichiersDeType "Fusion"] } if {$LesFiFuN!=""} { set LesPep [AffichePeptideSortPourLesFusions $LesFiFuN "Ask"] } } "CoupureDesADNCirculaires" { set SortieCoupureDesADNCirculaires [CoupureDesADNCirculaires] } "OligAuto" { set SortieOligAuto [OligAuto] } "WebOrder" { set SortieWebOrder [WebOrder] } } } } proc GetAbsolutePath {dir} { set saved [pwd] cd $dir set path [pwd] cd $saved return $path } proc GetEnsemblWeb {url} { set t [::http::geturl $url] upvar #0 $t state set i [lsearch $state(meta) "Location"] set new [lindex $state(meta) $i+1] set pre [string range $url 0 [string first "g" $url]+1] set url ${pre}$new ::http::cleanup $t set t [::http::geturl $url] upvar #0 $t state set res $state(body) ::http::cleanup $t return $res } proc GetEnsemblWebMARIE {url} { #rR le lele est chez poidevin set t [::http::geturl $url] upvar #0 $t state set i [lsearch $state(meta) "Location"] set new [lindex $state(meta) $i+1] set pre [string range $url 0 [string first "g" $url]+1] set url ${pre}$new ::http::cleanup $t set t [::http::geturl $url] upvar #0 $t state set res $state(body) ::http::cleanup $t return $res } proc GetEquivNonBiDir {Sort} { # Recupere pour chaque promoteur bidir de longuer N un promoteur non-bidir de taille identique Espionne "GetEquivNonBiDir : Start" set ListeDesDistancesNatives {} set ListeDesDistancesCroissantes {} set ListeDesDistancesDecroissantes {} Espionne "GetEquivNonBiDir : Stockage des distances" set FichierDesDistances [open "/genomics/link/STAF/fiches/Bidir/1000/TaillesIntergenes.bidir" "r"] while { [gets $FichierDesDistances LigneD] >= 0 } { lappend ListeDesDistancesNatives $LigneD lappend ListeDesDistancesCroissantes $LigneD lappend ListeDesDistancesDecroissantes $LigneD } close $FichierDesDistances lsort -increasing $ListeDesDistancesCroissantes lsort -decreasing $ListeDesDistancesDecroissantes foreach NumNonBidir { 01 02 03 04 05 06 07 08 09 10 } { set I 0 set nbLignes 0 set FichierDesNonBidir [open "/genomics/link/STAF/fiches/NonBiDir/NonBidir.847.$NumNonBidir.nb" "r"] if {$Sort == "Natif" } { set FichierDesSequencesNonBidirNatives [open "/genomics/link/STAF/fiches/NonBiDir/NonBiDir$NumNonBidir.n.pnb" "w"] set FichierDesSequencesNonBidirNativesEtendues [open "/genomics/link/STAF/fiches/NonBiDir/NonBiDir$NumNonBidir.n.pnbe" "w"] } if {$Sort == "Croissant" } { set FichierDesSequencesNonBidirCroissantes [open "/genomics/link/STAF/fiches/NonBiDir/NonBiDir$NumNonBidir.c.pnb" "w"] set FichierDesSequencesNonBidirCroissantesEtendues [open "/genomics/link/STAF/fiches/NonBiDir/NonBiDir$NumNonBidir.c.pnbe" "w"] } if {$Sort == "Decroissant" } { set FichierDesSequencesNonBidirDecroissantes [open "/genomics/link/STAF/fiches/NonBiDir/NonBidir$NumNonBidir.d.pnb" "w"] set FichierDesSequencesNonBidirDecroissantesEtendues [open "/genomics/link/STAF/fiches/NonBiDir/NonBidir$NumNonBidir.d.pnbe" "w"] } Espionne "GetEquivNonBiDir : Fichier $NumNonBidir" while { [gets $FichierDesNonBidir LigneNB] >= 0} { incr nbLignes Espionne "GetEquivNonBiDir ($NumNonBidir): Ligne $nbLignes" ScanLaListe $LigneNB AccessNB ChromNB StartNB EndNB StrandNB set DistanceNative [lindex $ListeDesDistancesNatives $I] set DistanceCroissante [lindex $ListeDesDistancesCroissantes $I] set DistanceDecroissante [lindex $ListeDesDistancesDecroissantes $I] if { $StrandNB == "-" } { set Temp $EndNB set EndNB $StartNB set StartNB $Temp set StartPromoteurNatif $StartNB set EndPromoteurNatif [expr $StartPromoteurNatif + $DistanceNative] set StartPromoteurNatifEtendu [expr $StartPromoteurNatif - 400] set EndPromoteurNatifEtendu [expr $EndPromoteurNatif + 400] set StartPromoteurCroissant $StartNB set EndPromoteurCroissant [expr $StartPromoteurCroissant + $DistanceCroissante] set StartPromoteurCroissantEtendu [expr $StartPromoteurCroissant - 400] set EndPromoteurCroissantEtendu [expr $EndPromoteurCroissant + 400] set StartPromoteurDecroissant $StartNB set EndPromoteurDecroissant [expr $StartPromoteurDecroissant + $DistanceDecroissante] set StartPromoteurDecroissantEtendu [expr $StartPromoteurDecroissant - 400] set EndPromoteurDecroissantEtendu [expr $EndPromoteurDecroissant + 400] } else { set EndPromoteurNatif $StartNB set StartPromoteurNatif [expr $EndPromoteurNatif - $DistanceNative] set EndPromoteurNatifEtendu [expr $EndPromoteurNatif + 400] set StartPromoteurNatifEtendu [expr $StartPromoteurNatif - 400] set EndPromoteurCroissant $StartNB set StartPromoteurCroissant [expr $EndPromoteurCroissant - $DistanceCroissante] set EndPromoteurCroissantEtendu [expr $EndPromoteurCroissant + 400] set StartPromoteurCroissantEtendu [expr $StartPromoteurCroissant - 400] set EndPromoteurDecroissant $StartNB set StartPromoteurDecroissant [expr $EndPromoteurDecroissant - $DistanceDecroissante] set EndPromoteurDecroissantEtendu [expr $EndPromoteurDecroissant + 400] set StartPromoteurDecroissantEtendu [expr $StartPromoteurDecroissant - 400] } regsub -all {chr} $ChromNB "" ChromNB if {$Sort == "Natif" } { set SequenceNative [BoutAdnDeUcscBoost $StartPromoteurNatif $EndPromoteurNatif $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] set SequenceNativeEtendue [BoutAdnDeUcscBoost $StartPromoteurNatifEtendu $EndPromoteurNatifEtendu $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] regsub -all {a|t|c|g} $SequenceNative "N" SequenceNative regsub -all {a|t|c|g} $SequenceNativeEtendue "N" SequenceNativeEtendue puts $FichierDesSequencesNonBidirNatives ">$AccessNB" puts $FichierDesSequencesNonBidirNatives $SequenceNative puts $FichierDesSequencesNonBidirNativesEtendues ">$AccessNB" puts $FichierDesSequencesNonBidirNativesEtendues $SequenceNativeEtendue flush $FichierDesSequencesNonBidirNatives flush $FichierDesSequencesNonBidirNativesEtendues } if {$Sort == "Croissant" } { set SequenceCroissante [BoutAdnDeUcscBoost $StartPromoteurCroissant $EndPromoteurCroissant $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] set SequenceCroissanteEtendue [BoutAdnDeUcscBoost $StartPromoteurCroissantEtendu $EndPromoteurCroissantEtendu $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] regsub -all {a|t|c|g} $SequenceCroissante "N" SequenceCroissante regsub -all {a|t|c|g} $SequenceCroissanteEtendue "N" SequenceCroissanteEtendue puts $FichierDesSequencesNonBidirCroissantes ">$AccessNB" puts $FichierDesSequencesNonBidirCroissantes $SequenceCroissante puts $FichierDesSequencesNonBidirCroissantesEtendues ">$AccessNB" puts $FichierDesSequencesNonBidirCroissantesEtendues $SequenceCroissanteEtendue flush $FichierDesSequencesNonBidirCroissantes flush $FichierDesSequencesNonBidirCroissantesEtendues } if {$Sort == "Decroissant" } { set SequenceDecroissante [BoutAdnDeUcscBoost $StartPromoteurDecroissant $EndPromoteurDecroissant $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] set SequenceDecroissanteEtendue [BoutAdnDeUcscBoost $StartPromoteurDecroissantEtendu $EndPromoteurDecroissantEtendu $StrandNB "Homo_sapiens" $ChromNB "bigZips200603" ] regsub -all {a|t|c|g} $SequenceDecroissante "N" SequenceDecroissante regsub -all {a|t|c|g} $SequenceDecroissanteEtendue "N" SequenceDecroissanteEtendue puts $FichierDesSequencesNonBidirDecroissantes ">$AccessNB" puts $FichierDesSequencesNonBidirDecroissantes $SequenceDecroissante puts $FichierDesSequencesNonBidirDecroissantesEtendues ">$AccessNB" puts $FichierDesSequencesNonBidirDecroissantesEtendues $SequenceDecroissanteEtendue flush $FichierDesSequencesNonBidirDecroissantes flush $FichierDesSequencesNonBidirDecroissantesEtendues } incr I } if {$Sort == "Natif" } { close $FichierDesSequencesNonBidirNatives close $FichierDesSequencesNonBidirNativesEtendues } if {$Sort == "Croissant" } { close $FichierDesSequencesNonBidirCroissantes close $FichierDesSequencesNonBidirCroissantesEtendues } if {$Sort == "Decroissant" } { close $FichierDesSequencesNonBidirDecroissantes close $FichierDesSequencesNonBidirDecroissantesEtendues } close $FichierDesNonBidir } Espionne "GetEquivNonBiDir : End" } proc GetExons {Path Organisme Database {BirdVersion bird} {DateGenome 200603}} { set FichierDesCoordonnees [open "$Path.txt" "r"] set FichierDesCoordonnees [open "$Path.txt" "r"] set FichierDesRequetes [open "$Path.sql" "w"] set I 0 set J 0 set OldName "" while { [gets $FichierDesCoordonnees LigneCoordonnee] >=0 } { ScanLaListe $LigneCoordonnee Gene Chromosome Start End Strand set Start [expr $Start - 1] set End [expr $End + 1] puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE select access, name, chrom, cdsStart, cdsEnd, exoncount, exonStarts, exonEnds, strand from ucsc$Organisme.$Database Where txStart >= $Start AND txEnd <= $End AND chrom='$Chromosome'" puts $FichierDesRequetes "LM 1" puts $FichierDesRequetes "//" } close $FichierDesRequetes close $FichierDesCoordonnees Espionne "GetExons : Execution des requetes" BirdFetch "$Path.sql" "$BirdVersion" "$Path.result" set FichierDesRequetesExecutees [open "$Path.result" "r"] Espionne "GetExons : Traitement des resultats" while { [gets $FichierDesRequetesExecutees LigneResultat] >=0 } { set SequenceExonsConcatenes "" incr J gets $FichierDesRequetesExecutees LigneResultat set LigneResultat [split $LigneResultat "|"] ScanLaListe $LigneResultat Access Name Chromosome cdsStart cdsEnd ExonCount LesExonStarts LesExonEnds Strand if { $Name != "Pseudogene"} { if { $Access != $OldName && $J != 1 } { set FichierDesExonsConcatenes [open "$Path.$Access.concat" "w"] set SequenceExonsConcatenes "" } set ListeDesStarts [split $LesExonStarts ","] set ListeDesEnds [split $LesExonEnds ","] for {set I 1} {$I <= $ExonCount} {incr I} { set StartE [lindex $ListeDesStarts $I] set EndE [lindex $ListeDesEnds $I] if {$StartE != "" && $End !=""} { Espionne "Traitement de l'Exon $I de $Access" regsub -all {chr} $Chromosome "" Chrox #Espionne "$StartE $EndE $Strand $Organisme $Chrox" #set Sequence [BoutAdnDeUcscBoost $StartE $EndE $Strand $Organisme $Chrox "bigZips$DateGenome"] set SequenceExonsConcatenes "$SequenceExonsConcatenes$Sequence" #set FichierTfaMonoExon [open "$Path.$Access.Exon$I.tfa" "w"] #puts $FichierTfaMonoExon ">$Access Exon$I $Chromosome:$StartE-$EndE" if { $StartE >= $cdsStart && $EndE <= $cdsEnd} { set UTRouCDS "CDS" } elseif { $StartE <= $cdsStart && $EndE <= $cdsEnd} { set UTRouCDS "Half5" } elseif { $StartE >= $cdsStart && $EndE >= $cdsEnd } { set UTRouCDS "Half3" } elseif { $StartE > $cdsEnd } { set UTRouCDS "3-UTR" } elseif { $EndE < $cdsStart } { set UTRouCDS "5-UTR" } else { Espionen "Erreur CDS/UTR" } puts $FichierTfaMonoExon "ID $Access Exon$I $Chromosome $StartE $EndE $strand UTRouCDS" #puts $FichierTfaMonoExon "$Sequence" #close $FichierTfaMonoExon } } Espionne "$Name $OldName $J" if { $Access != $OldName && $J != 1 } { Espionne "Ecriture du fichier des exons de $Name" puts $FichierDesExonsConcatenes ">$Access ExonConcatenes" puts $FichierDesExonsConcatenes $SequenceExonsConcatenes close $FichierDesExonsConcatenes } set OldName $Access } } } proc GetExons2 {Path {Organisme human} {Database GeCo} {DateGenome 200603}} { set FichierDesCoordonnees [open "/tmp/$Path.coord" "w"] set FichierDesRequetes [open "/tmp/$Path.sql" "w"] set I 0 set J 0 set ID 0 set OldName "" CanalSqlUcscHuman foreach LigneResultat [SqlExec "SELECT access, name, chrom, cdsStart, cdsEnd, exoncount, exonStarts, exonEnds, strand FROM ucsc$Organisme.$Database Where typeGene='protein' and pseudogene='no' ORDER BY chrom, txStart" "-list"] { ScanLaListe $LigneResultat Access Name Chromosome cdsStart cdsEnd ExonCount LesExonStarts LesExonEnds Strand set ListeDesStarts [split $LesExonStarts ","] set ListeDesEnds [split $LesExonEnds ","] for {set I 1} {$I <= $ExonCount} {incr I} { set StartE [lindex $ListeDesStarts $I] set EndE [lindex $ListeDesEnds $I] if {$StartE != "" && $EndE !=""} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] #Espionne "$timestamp|GetExon: Traitement de l'Exon $I de $Access" if { $StartE >= $cdsStart && $EndE <= $cdsEnd} { set UTRouCDS "CDS" } elseif { $StartE <= $cdsStart && $EndE <= $cdsEnd} { set UTRouCDS "Half5" } elseif { $StartE >= $cdsStart && $EndE >= $cdsEnd } { set UTRouCDS "Half3" } elseif { $StartE > $cdsEnd } { set UTRouCDS "3-UTR" } elseif { $EndE < $cdsStart } { set UTRouCDS "5-UTR" } elseif { $StartE < $cdsStart && $EndE > $cdsEnd} { set UTRouCDS "Spanning" } else { Espionne "Erreur CDS/UTR $StartE-$EndE ?? $cdsStart-$cdsEnd" set UTRouCDS "Error" } if { $Strand == "+" } { set StartP [expr $StartE - 500] set EndP [expr $StartE - 1] set StartP2 [expr $EndE + 1] set EndP2 [expr $StartE + 500] } else { set StartP $EndE set EndP [expr $EndE + 500] set StartP2 [expr $StartE - 500] set EndP2 [expr $StartE - 1] } regsub -all -nocase {chr} $Chromosome "" Chrox #set SequenceB [BoutAdnDeUcscBoost $StartP $EndP $Strand $Organisme $Chrox "bigZips$DateGenome"] #set SequenceA [BoutAdnDeUcscBoost $StartP2 $EndP2 $Strand $Organisme $Chrox "bigZips$DateGenome"] incr ID #puts $FichierDesCoordonnees "$ID $Access Exon$I $Chromosome $StartE $EndE $Strand $UTRouCDS $SequenceB $SequenceA" puts $FichierDesCoordonnees "$ID $Access Exon$I $Chromosome $StartE $EndE $Strand $ExonCount" } } } close $FichierDesCoordonnees } proc GetFastaHeadersForPABs {listeDesPABs} { set lesPABs [split $listeDesPABs ", "] set res "pas bon" foreach PAB $lesPABs { #AppendAuFichier [LogDir]/bibib $PAB append res "[BenEnteteTFA $PAB]," } return $res } proc GetFreetextFromSql {Nom} { set Retour [SqlExec "select FREETEXT from MACSIMS where FREETEXT like '%GscopeID $Nom\n%'" "GetFirstValue"] Espionne $Retour exit } proc GetFromGATC {{SourceDir ""} {LocalDir ""}} { if {$LocalDir==""} { FaireLire "Please browse for the local directory to store the .tfa files" set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"] if {$LocalDir==""} { return "" } } if {$SourceDir==""} { FaireLire "Please browse for the directory containing the .seq sequences" set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"] if {$Rep==""} { return "" } set SourceDir $Rep } set LesDispos [lsort [glob -nocomplain -type f "$SourceDir/*.seq"]] set LesChoix [MorceauxChoisis $LesDispos] set LesFichiersTFA {} set LesSeq {} foreach Choix $LesChoix { set Queue [file tail $Choix] regsub ".seq$" $Queue "" NomDeBapteme set Destin "$LocalDir/$NomDeBapteme.tfa" if {[file exists $Destin]} { if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue } } set Seq [ContenuDuFichier $Choix] if {[regexp "edited with PhredPhrap" $Seq]} { set ID [StringApres "ID: " dans $Seq] if {$ID==$NomDeBapteme} { regsub ">" $Seq ">$ID " Seq } else { FaireLire "$Choix contains no ID with $ID\n$Seq" } set FichierTFA [Sauve $Seq dans $Destin] } else { FaireLire "I didn't find 'edited with PhredPhrap' in $Choix\nI'll continue expecting fastaformat, gcgformat or raw sequence" if {[regexp {^>} $Seq]} { set TFA $Seq } elseif {[regexp {\.\. *\n} $Seq]} { set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"] } else { regsub -all {[ \n\t0-9]} $Seq "" Seq if {[regexp -nocase {[^ATGCN]} $Seq]} { FaireLire "The sequence file $Choix contains illegal characters\n$Seq" } set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"] } set FichierTFA [Sauve $TFA dans $Destin] } lappend LesFichiersTFA $FichierTFA } return $LesFichiersTFA } proc GetGlobal {Var} { global $Var if { ! [info exists $Var]} { return "NotExists" } return [set $Var] } proc GetInfosOfTaxIds {LidIn} { unset -nocomplain ::db set db [InitTaxDB] set db "dbtaxo" set dbtaxo "/genomics/link/taxonomy/uniprot_taxonomy/uniprot_taxonomy.sql" package require sqlite3 sqlite3 $db $dbtaxo set Lid [list] foreach id $LidIn { if {[string is integer -strict $id]} { lappend Lid $id } } set Ldata [$db eval "select taxid,Name,Lineage from taxonomy where taxid in ([join $Lid ,])"] $db close update return $Ldata } proc GetMacSeq {{SourceDir ""} {LocalDir ""} {User ""}} { set RepDe(huet) "titus:/us1/user/SEQUENCEUR/HUET_Tiphaine" set RepDe(eiler) "titus:/us1/user/SEQUENCEUR/EILER_Sylvia" set RepDe(dock) "titus:/us1/user/SEQUENCEUR/Dock-Bregeon" set RepDe(wassim) "titus:/us1/user/SEQUENCEUR/ABDULRAHMAN_Wassim" set RepDe(fmichel) "titus:/us1/user/SEQUENCEUR/MICHEL_Fabrice" set RepDe(djbusso) "titus:/us1/user/SEQUENCEUR/BUSSO_Didier" set RepDe(arnaud) "titus:/us1/user/SEQUENCEUR/POTERSZMAN_Arnaud" set RepDe(flatter) "titus:/us1/user/SEQUENCEUR/FLATTER_Eric" set RepDe(desseric) "titus:/us1/user/SEQUENCEUR/DESSERICH_Vincent" set RepDe(brelivet) "titus:/us1/user/SEQUENCEUR/BRELIVET_Yann" set RepDe(bey) "titus:/us1/user/SEQUENCEUR/BEY_Gilbert" set RepDe(iwema) "titus:/us1/user/SEQUENCEUR/IWEMA_Thomas" set RepDe(billas) "titus:/us1/user/SEQUENCEUR/BILLAS_Isabelle" set RepDe(flatter) "titus:/us1/user/SEQUENCEUR/FLATTER_Eric" set RepDe(ruff) "titus:/us1/user/SEQUENCEUR/RUFF_Marc" set RepDe(eddy) "titus:/us1/user/SEQUENCEUR/TROESCH_Edouard" set RepDe(troffer) "titus:/us1/user/SEQUENCEUR/TROFFER-Nathalie" set RepDe(uhring) "titus:/us1/user/SEQUENCEUR/UHRING_Muriel" set RepDe(ripp) "titus:[HomeRipp]/SEQUENCAGE" foreach U [lsort [array names RepDe]] { lappend LesRepDe [set RepDe($U)] } lappend LesRepDe "Other" if {$LocalDir==""} { FaireLire "Please browse for the local directory to store the tfa files" set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"] if {$LocalDir==""} { return "" } } if {[regexp "titus\:" $SourceDir] || ($SourceDir=="" && [OuiOuNon "Do I connect to titus to search for sequences ?"])} { global env if {$User==""} { set User [set env(USER)] } while { ! [OuiOuNon "Do I use User $User to connect to Titus ?"]} { set User [Entre $User] if {$User=="" && [OuiOuNon "Do I cancel GetMacSeq ?"]} { return "" } } set SourceDir "titus:/us1/user/SEQUENCEUR/[string totitle $User]" if {[info exists RepDe($User)]} { set SourceDir [set RepDe($User)] } while { ! [OuiOuNon "Do I search in \n$SourceDir directory ?"]} { set SourceDir [ChoixParmi $LesRepDe] if {$SourceDir!="Other" && $SourceDir!=""} { break } set SourceDir [Entre $SourceDir] if {$SourceDir=="" && [OuiOuNon "Do I cancel GetMacSeq ?" ]} { return "" } } regsub "^titus\:" $SourceDir "" UserDir set Dispos [exec rsh titus -l $User ls $UserDir/*.seq] if {$Dispos==""} { return "" } } elseif { $SourceDir!="" || [OuiOuNon "Do I browse for raw DNA files ?"]} { set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"] if {$Rep==""} { return "" } set Dispos [join [lsort [glob -nocomplain -type f "$Rep/*.seq"]] "\n"] } set LesChoix [MorceauxChoisis [split $Dispos "\n"]] set LesFichiersTFA {} set LesSeq {} foreach Choix $LesChoix { set Queue [file tail $Choix] regsub ".seq$" $Queue "" NomDeBapteme set Destin "$LocalDir/$NomDeBapteme.tfa" if {[file exists $Destin]} { if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue } } set ChromaSurTitus "" if {[regexp "^titus\:" $SourceDir]} { set FichierSurTitus "$SourceDir/$Queue" Espionne $FichierSurTitus regsub ".seq$" $FichierSurTitus ".ab1" ChromaSurTitus set FiSeq [TmpFile].seq exec rcp $FichierSurTitus $FiSeq if { ! [file exists $FiSeq]} { FaireLire "Problem executing\nrcp $FichierSurTitus [TmpFile].seq" continue } set Seq [ContenuDuFichier $FiSeq] File delete -force $FiSeq } else { set Seq [ContenuDuFichier $Choix] } if {[regexp {\.\. *\n} $Seq]} { set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"] } else { regsub -all {[ \n\t0-9]} $Seq "" Seq if {[regexp -nocase {[^ATGCN]} $Seq]} { FaireLire "The sequence file $Choix contains illegal characters\n$Seq" } set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"] } set FichierTFA [Sauve $TFA dans $Destin] if {$ChromaSurTitus!=""} { regsub ".tfa$" $FichierTFA "" ChromaIci append ChromaIci ".ab1" if {[catch { exec rcp $ChromaSurTitus $ChromaIci } Message]} { FaireLire "I tried \nexec rcp $ChromaSurTitus $ChromaIci\and got the message\n$Message" } } lappend LesFichiersTFA $FichierTFA } return $LesFichiersTFA } proc GetMacsimSFromSql {Nom} { set Retour [SqlExec "select MACSIMSXML from MACSIMS where FREETEXT like '%GscopeID $Nom\n%'" "GetFirstValue"] Espionne $Retour exit } proc GetMailsFromDB {first last} { global db CMDef TMail set Lrep [$db eval {select m.uid, m.sender, m.subject, m.date, m.attachment, m.read, m.answered from mail as m, folder as f where f.pk_mailbox = $CMDef(pk_mailbox) and f.name = $CMDef(currFolder) and m.pk_folder = f.pk_folder and m.uid > $first and m.uid <= $last}] set Lmail [list] foreach {uid send subj date atta read answ} $Lrep { set send [DisplayFrom $send] set date [clock format $date -format "%G/%m/%d %H:%M:%S"] lappend Lmail [list $send $subj $date] lappend TMail(Read) $read lappend TMail(Answ) $answ lappend TMail(Atta) $atta lappend TMail(UID) $uid } return $Lmail } proc GetMailsFromServer {first last} { global CMDef db TMail FaireAttendre "Please wait ...\nLoading messages from server ..." set imapID $CMDef(imapID) set LfieldsIn [list uid from: to: Subject: date: flags bodystructure] set Lminfo [::imap4::fetch $imapID $first:$last -inline {*}$LfieldsIn] # now fill database and table set Lmails [list] $db eval {begin transaction} foreach Linfo $Lminfo { set Warn 0 lassign $Linfo uid from to subject date flags bodystructure # Treat infomation for both database and display set Lfrom [lmap w [split $from " "] { DecodeWord $w }] set from [join $Lfrom] set fromDis [DisplayFrom $from] set from [string map {' ''} $from] # get the epoch corresponding to date-time set date [string trim $date] if {$date ne ""} { #set date [::mime::parsedatetime $date clock] set date [::rfc2822::parseDate $date] set dateDis [clock format $date -format "%G/%m/%d %H:%M:%S"] } else { set dateDis "" set Warn 1 } # Subject: set subject [::mime::field_decode $subject] set subjectDis $subject set subject [string map {' ''} $subject] # treat flags set read 0 ; set answered 0 foreach flag $flags { switch -regexp -- $flag { {Seen} {set read 1} {Answered} {set answered 1} {Forwarded} {set forwarded 1} {Recent} {set read 0} default { puts "unkflag $flag" } } } # is there an attachment set isAtta [CheckAttachment $bodystructure] # To: set to [string map {' ''} $to] if {$isAtta} { # bullet \u2022 set v "*" } else { set v "" } # debug if {$Warn} { puts "\n$from\n$to\n$subject\n$flags" } # for display use lappend Lmails [list $v $fromDis $subjectDis $dateDis] lappend TMail(Read) $read lappend TMail(Answ) $answered lappend TMail(Atta) $isAtta lappend TMail(UID) $uid # for database insertion $db eval {insert into mail values(NULL,$CMDef(currFolderPk),$uid,$from,$to,$subject,$date,$isAtta,$read,$answered)} } $db eval {commit} FaireLaSuite return $Lmails } proc GetOrderOfAlignment {TexteOuNomOuFichierRSF {WhichOne ""}} { set Order [DessineMoiUnRSF $TexteOuNomOuFichierRSF "" "" "GetOrder"] if {$WhichOne==""} { set WhichOne "Normal" } if {[regexp -nocase "Alpha" $WhichOne]} { set Order [lsort -dictionary $Order] } if {[regexp -nocase "Rever" $WhichOne]} { set Order [lreverse $Order] } if {[regexp {[0-9]+} $WhichOne Match]} { set Order [lrange $Order 0 [incr Match -1]] } return $Order } proc GetOrga {PAB} { set entete [BenEnteteTFA $PAB] set mots [split $entete " "] set orga [concat [lindex $mots 2] [lindex $mots 3]] return $orga } proc GetPdbForNgl {{Access ""}} { return [TextePDB $Access All "" "OnTheWeb"] } proc GetPicture {} { foreach Ligne [LesLignesDuFichier GetPicture.html] { set F $Ligne set J [file tail $F] set D [file dirname $F] regsub ".JPG" $J ".jpg" j Espionne "$D/www*/thumbs/$j" set T [glob -nocomplain "$D/www*/thumbs/$j"] Espionne "T $T" if {$T==""} { continue } lappend LeHtml "" lappend LeHtml "
" lappend LeHtml " " lappend LeHtml "
" } SauveLesLignes $LeHtml dans GP.html exit } proc GetQS {Fichier} { set WQuery 1 set Query "" set Sujet "" foreach Ligne [LesLignesDuFichier $Fichier] { if {$WQuery && ! [regexp {^Query\:} $Ligne] } { continue } set WQuery 0 if {[regexp {^>} $Ligne]} { break } if {[regexp {^Query\:} $Ligne]} { scan $Ligne "%s %d %s %d" bidon D Q F append Query $Q continue } if {[regexp {^Sbjct\:} $Ligne]} { scan $Ligne "%s %d %s %d" bidon D S F append Sujet $S continue } } return [list $Query $Sujet] } proc GetRad {l} { global RadMol xc yc zc pgl foreach a {xc yc zc xm ym zm xx yx zx} { set $a 0.0 } foreach {a x} {xm 1. ym 1. zm 1. xx -1. yx -1. zx -1.} { set $a [expr {$x*999.0}] } foreach e $l { lassign $e x y z foreach a {x y z} b {xm ym zm} c {xx yx zx} { if {[set $a] < [set $b]} {set $b [set $a]} if {[set $a] > [set $c]} {set $c [set $a]} } } foreach a {xc yc zc} b {xm ym zm} c {xx yx zx} { set $a [expr {0.5 * ([set $c] + [set $b])}] } set RadMol -999999. set RadMol [expr {sqrt(($xx-$xm)**2 + ($yx-$ym)**2 + ($zx-$zm)**2) / 2.}] if {0} { foreach {xt yt zt} [list $xm $ym $zm $xx $yx $zx] { set d [expr {sqrt(($xt-$xc)*($xt-$xc) + ($yt-$yc)*($yt-$yc) + ($zt-$zc)*($zt-$zc))}] if {$d > $RadMol} {set RadMol $d} } } set pgl(xMin) $xm set pgl(yMin) $ym set pgl(zMin) $zm set pgl(xMax) $xx set pgl(yMax) $yx set pgl(zMax) $zx set pgl(xc) $xc set pgl(yc) $yc set pgl(zc) $zc if {0} { puts "radius : $RadMol" set fmt [format "Centre : %6.2f %6.2f %6.2f" $pgl(xc) $pgl(yc) $pgl(zc)] puts "$fmt" set fmt [format "Minimum : %6.2f %6.2f %6.2f" $pgl(xMin) $pgl(yMin) $pgl(zMin)] puts "$fmt" set fmt [format "Maximum : %6.2f %6.2f %6.2f" $pgl(xMax) $pgl(yMax) $pgl(zMax)] puts "$fmt" } return $RadMol } proc GetSignification {Couleur K} { global SignificationEnStock if {$Couleur == "ToutesLesCouleursPossibles"} { if {[info exists SignificationEnStock($K)]} { return [set SignificationEnStock($K)] } else { return "" } } if {[info exists SignificationEnStock($Couleur,$K)]} { return [set SignificationEnStock($Couleur,$K)] } else { return "" } } proc GetTables {{NameStart ""}} { return [$::db eval "select distinct(tbl_name) from sqlite_master where (type = \"table\") and (tbl_name like \"${NameStart}%\")"] } proc Get_covered {MAFFile1 MAFFile2 Get_coveredMafFile} { ### Execution du programme get_covered ### # prend deux fichiers maf en entree # # ? # if {![file exists $File1]} {Espionne "File1: $File1 does not exists" ; return} if {![file exists $File2]} {Espionne "File2: $File2 does not exists" ; return} #set Commande "exec [PATH get_covered] $File1 $File2 > $Get_coveredMafFile" set Commande "exec get_covered $File1 $File2 > $Get_coveredMafFile" if {[catch {eval $Commande} Message]} {Espionne $Message;return} return $Get_coveredMafFile } proc Getz {Access args} { set Tous [regexp {\|} $Access] set LesOptions {} if {$args=={}} { # set Banques "\{swissprot sptrembl\}" set Banques "\{uniprot\}" } else { set LesBanques {} set YaOption 0 foreach Banque $args { if {$YaOption} { set YaOption 0 lappend LesOptions $Banque continue } if {[regexp {^\-} $Banque]} { set YaOption 1 lappend LesOptions $Banque continue } set Banque [string tolower $Banque] if {[info exists DejaVu($Banque)]} { continue } set DejaVu($Banque) 1 lappend LesBanques "$Banque" } set Banques "\\{[join $LesBanques " "]\\}" } if {$LesOptions=={}} { set Options "-e" } else { set Options [join $LesOptions " "] } if {[regexp -nocase "Decrypthon" $Banques]} { set LesClefs [list "DR" "AccNumber" "ID" "DBxref"] } else { set LesClefs [list "AccNumber" "ID" "DBxref"] } foreach Clef $LesClefs] { if {$Clef=="DBxref" && ! [regexp -nocase {[A-Z]{3}[0-9]{4,}} $Access]} { return "" } if {$Clef=="DBxref"} { set Etoile "*" } else { set Etoile "" } set Commande "getz $Options \"\\\[$Banques-$Clef: $Access$Etoile\\\]\"" if {[info exists GetzOut]} { unset GetzOut } catch {set GetzOut [eval exec $Commande]} Message if {[info exists GetzOut] && [regexp -nocase {[a-z]} $GetzOut]} { if {$Tous || [regexp -nocase "Decrypthon" $Banques]} { return $GetzOut } else { return [UnSeulGetz $GetzOut] } } } return "" } proc GetzUniseq_GUI {K Access {Banques uniseq} {Link genbank} {Option AccessDef}} { Wup "Affiche grace a getz les liens dans Link pour les Access dans Banques" Wup "Option EntreeComplete == sortie getz de toute l entree" Wup "Option AccessDef == sortie getz avec juste Id et Def" set GetzOut [LeGetzUniseq $Access $Banques $Link $Option] if {$GetzOut==""} {set GetzOut "No link from $Banques to $Link available for [join $Access " "]"} set Fen [AfficheVariable $GetzOut "AvecFormateAvecBlaste" "$Banques to $Link"] if {$Link=="genbank"} { set FenB "$Fen.buttons" TouchePour $FenB NouvelleGamme TouchePour $FenB NouvelleCouleur "white" set B [TouchePour $FenB "Link GenBank To" ""] TouchePour $FenB NouvelleCouleur "green" TouchePour $FenB "Protein Sel" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\] genbank protein All\]}" TouchePour <2> "/Id" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[selection get\] genbank protein\]}" TouchePour <3> "/All" "catch {SauveLesInfosDe $K Win \[GetzUniseq_GUI $K \[set PagePropre($Fen)\] genbank protein\]}" set Texte [format "%-10s" "To Link Genbank access to Protein access"] append Texte [format "\n%-10s" "Allows to retrieve access only (Id and all) or complete entry (Sel.)"] set_balloon $B "$Texte" $B configure -state disabled -disabledforeground "black" } return $Fen } proc GiToAccessWithBird {FichierEntree} { #set Fichier "/home/poch/pab87_rajout.liste" foreach Ligne [LesLignesDuFichier $FichierEntree] { if {$Ligne==""} { continue } lappend ListeGI [lindex $Ligne 0] } set LesGI [join $ListeGI ","] lappend LesLignes "ID $LesGI DB Entrez_protein" lappend LesLignes "FM FLAT" set FileBql [SauveLesLignes $LesLignes dans "[TmpFile].bql"] set FileTxt [TmpFile].txt BirdForceHoan $FileBql $FileTxt foreach LigneFic [LesLignesDuFichier $FileTxt] { if {[regexp "LOCUS" $LigneFic]} { lappend LesLignesResult $LigneFic } if {[regexp "DEFINITION" $LigneFic]} { lappend LesLignesResult $LigneFic } if {[regexp "VERSION" $LigneFic]} { lappend LesLignesResult $LigneFic lappend LesLignesResult "" } } SauveLesLignes $LesLignesResult dans "GiToAccess.txt" file delete $FileBql file delete $FileTxt } proc GiToAccessWithBirdOLD {} { # Nv database pour GI: Entrez_nucleotide et Entrez_protein set ListeGI [InterrogeListTau ListOf GI] set LesGI [join $ListeGI ","] lappend LesLignes "ID $LesGI DB Entrez_nucleotide" lappend LesLignes "FM FLAT" SauveLesLignes $LesLignes dans "/genomics/link/EVImm/Tau/requeteessaiNuc.bql" } proc GiveMeThisOrthologs {nomRepertoireDesBlast {listeDesOrgasAAnalyser ""} {outputType ""} {seuilExpect ""} {proteomeFasta ""}} { global RepertoireDuGenome set listeBlast [ListeDesPABs2] set RepBlast "$RepertoireDuGenome/$nomRepertoireDesBlast" array set putOrtho {} array set putOrthoOrga {} array set putOrthoAnalysed {} array set noHomology {} array set noHitsIn {} #Variables par défaut if {$seuilExpect==""} {set seuilExpect 0.001} if {$proteomeFasta==""} {set proteomeFasta "proteomeToBlast.fasta"} if {$outputType=="" || $outputType=="toLogs"} {set outputType 1} if {$outputType=="toScreen"} {set outputType 0} #pour essais, limitation des boucles set debut 0 set fin [llength $listeBlast] #set aTester {{0 100} {15000 15100} {30000 30100}} #set aTester {{76733 76738}} set aTester [list [list 0 $fin]] set enModeTest 0 puts "###debut : [Maintenant]" #l'analyse va se faire en plusieurs temps #on va la faire plusieurs fois, chaque fois par rapport à un autre organisme #on aura donc pr chaque proteine d'un orga Oj, les relation de paralogie vis #à vis de O1,O2...Oj ############################################################################# set listeOrgas [ConcernedOrganisms $proteomeFasta] puts " -->Voici la liste des organismes détectés :" foreach o $listeOrgas { puts " - $o" } puts " Si l'un des organismes apparait plusieurs fois, corrigez vos fichiers !" puts " ex: Xenopus (Silurana) ==>> Xenopus tropicalis" #Si on ne veut que certains des organismes if {$listeDesOrgasAAnalyser!=""} { if {[llength $listeDesOrgasAAnalyser]<2} { puts "ERREUR !!!!! vous devez spécifier AU MOINS 2 organismes valides" exit } #on vérif que tous les orgas donnés existent bien dans les protéomes initiaux foreach elt $listeDesOrgasAAnalyser { if {[lsearch -exact $listeOrgas $elt]==-1} { puts "ERREUR !!!!! un des organismes n'est pas dans la base --> $elt" exit } } set listeOrgas $listeDesOrgasAAnalyser } puts " -->Voici la liste des organismes demandés pour l'analyse :" foreach o $listeOrgas { puts " - $o" } #chargement des bornes des organismes puts " -->Chargement des bornes des organismes (/fiches/lienspabparorga)" set FICBORNES [open "$RepertoireDuGenome/fiches/lienspabparorga" "r"] while {[gets $FICBORNES line]!=-1} { if {[string index $line 0]=="#"} {continue} set infos [split $line ";"] set bornes([lindex $infos 0]) [list [lindex $infos 2] [lindex $infos 3]] } close $FICBORNES #liste des numéros de pab qui vont être analysés (seulement ceux des organismes concernés set listeComplete {} foreach couple $aTester { puts " * Rangs à analyser : $couple" for {set i [lindex $couple 0]} {$i<[lindex $couple 1]} {incr i} { lappend listeComplete $i } } if {$enModeTest!=1} { set listeComplete {} foreach {key val} [array get bornes] { if {[lsearch -exact $listeOrgas $key]!=-1} { puts " $key : blasts [lindex $bornes($key) 0] à [lindex $bornes($key) 1]" for {set i [lindex $bornes($key) 0]} {$i<[expr [lindex $bornes($key) 1]+1]} {incr i} { lappend listeComplete $i } } } } puts " --> [llength $listeComplete] sorties blast vont etre analysées" puts "#####################################################################" puts " --> Analyse des hits des blasts" foreach num $listeComplete { #variables d'état set sameOrga 1 set previousOrga "" if {![info exists onEstSur] } {set onEstSur ""} set hitOrthoNum 1 array set tabHit {} #analyse du blast set i $num set queryPAB [lindex $listeBlast [expr $i-1]] set fileName "$RepBlast/$queryPAB" set resumeDuBlast [LesHitsDuBlast $fileName $seuilExpect] #extraction infos query ######################## set queryDescription [BenEnteteTFA $queryPAB] set mots [split $queryDescription " "] set queryOrga [concat [lindex $mots 2] [lindex $mots 3]] set queryAccess [lindex $mots 1] #si le blast n'est pas d'une proteine dans notre liste d'organismes if {[lsearch -exact $listeOrgas $queryOrga]==-1} {continue} if {$queryOrga!=$onEstSur} { puts " - Passage aux blasts de $queryOrga [Maintenant]" } set onEstSur $queryOrga #analyse des hits ################### ## comme on ne considere pas certains organisme; le numero du hit sera donc décalé set decalage 0 for {set hitNum 1} {$hitNum<[expr [llength $resumeDuBlast]+1]} {incr hitNum} { set currentHit [lindex $resumeDuBlast [expr $hitNum-1]] #extraction infos du hit set hitPAB [lindex $currentHit 0] set hitAccess [lindex $currentHit 1] set mots [split $currentHit " "] set hitOrga [concat [lindex $mots 2] [lindex $mots 3]] set currentExpect [lindex $mots end] #si le hits n'est pas sur un organisme à analyser, on zappe if {[lsearch -exact $listeOrgas $hitOrga]==-1} { incr decalage -1 continue } #comparaison organismes : des qu'on arrive dans un hit sur un orga different #on passe à 0. Permet de reperer les eventuels in-paralogues if {$queryOrga!=$hitOrga} {set sameOrga 0} #si le hit est vers lui-meme, on zappe if {$queryPAB==$hitPAB} {continue} #On note quel est l'organisme en question, on incrementera le compteur #quand on a un autre hit pour cette organisme if {![info exists countOrga($hitOrga)] || ($countOrga($hitOrga)==0)} { set countOrga($hitOrga) 1 } else { incr countOrga($hitOrga) } #si on respect le seuil d'expect if {$currentExpect<=$seuilExpect} { #si orga different if {!$sameOrga && $queryOrga!=$hitOrga} { #si c'est le premier hit sur un organisme particulier, #putOrthoAnalysed($queryPAB,$hitPAB) n'existe pas, on le note 1 #le second (putOrthoAnalysed($queryPAB,$hitPAB) existe) est noté 2 ... etc ... if {[info exists putOrthoAnalysed($queryPAB,$hitPAB)]} { continue } set putOrthoAnalysed($queryPAB,$hitPAB) [list [expr $hitNum+$decalage] $countOrga($hitOrga) $hitOrga] lappend putOrtho($queryPAB) $hitPAB #puts "putOrtho($queryPAB) $hitPAB : $putOrtho($queryPAB)" lappend putOrthoOrga($queryPAB) $hitOrga #puts "putOrthoOrga($queryPAB) $hitOrga : $putOrthoOrga($queryPAB)" #puts "putOrthoAnalysed($queryPAB,$hitPAB) [expr $hitNum+$decalage] $countOrga($hitOrga) $hitOrga" } } } #si un des organisme n'est pas visé par la query, son countOrga($key) #sera toujours à zero ou non initialisé foreach orga $listeOrgas { if {$orga==$queryOrga} {continue} if {[info exists putOrthoOrga($queryPAB)]} { if {[lsearch -exact $putOrthoOrga($queryPAB) $orga]==-1} { lappend noHitsIn($queryPAB) $orga } } } #si putOrtho($queryPAB) n'existe pas, on a pas de hit vers un organisme autre #on retient les proteines qui n'ont donc pas d'homologie du tout if {![info exists putOrtho($queryPAB)]} { set noHomology($queryPAB) 1 #puts "noHomology($queryPAB) : $noHomology($queryPAB)" } #remise à 0 du compteur d'organismes après chaque blast foreach {key val} [array get countOrga] { set countOrga($key) 0 } } #Alignements pipealin #LaunchPipesForGroups putInPara putOrtho $debut $fin puts " --> Création des couples d'orthologues avec RBH" #Recherche des groupes d'ortho avec best hit reciproque #le tableau se presente comme suit : # tab(A,B)= {orga1 orga2} la query A (orga1) a fait best hit reciproque sur le hit B (orga2) # tab(B,A)= {orga2 orga1} est juste le symetrique array set reciprocalHitOrtho {} foreach PABs $listeBlast { if {[info exists putOrtho($PABs)]} { foreach PAB $putOrtho($PABs) { #pour zapper le best hit dans le sens inverse if {[info exists reciprocalHitOrtho($PABs,$PAB)] || [info exists reciprocalHitOrtho($PAB,$PABs)]} {continue} #si les hits dans les 2 sens existent et qu'ils sont les bests (=1) if {[info exists putOrthoAnalysed($PABs,$PAB)] && [info exists putOrthoAnalysed($PAB,$PABs)] && ([lindex $putOrthoAnalysed($PABs,$PAB) 1]==1) && ([lindex $putOrthoAnalysed($PAB,$PABs) 1]==1)} { lappend reciprocalHitOrtho($PABs,$PAB) [lindex $putOrthoAnalysed($PAB,$PABs) 2] lappend reciprocalHitOrtho($PABs,$PAB) [lindex $putOrthoAnalysed($PABs,$PAB) 2] lappend reciprocalHitOrtho($PAB,$PABs) [lindex $putOrthoAnalysed($PABs,$PAB) 2] lappend reciprocalHitOrtho($PAB,$PABs) [lindex $putOrthoAnalysed($PAB,$PABs) 2] } } } } #puts " --> Création des tri-clusters d'orthologues" #Creation des Regroupements par 3 array set triCluster {} #foreach A $listeBlast { # if {[info exists putOrtho($A)]} { # foreach Xa $putOrtho($A) { # foreach Xb $putOrtho($A) { # if {[info exists reciprocalHitOrtho($Xa,$Xb)] && [info exists reciprocalHitOrtho($Xb,$Xa)] } { # if {[info exists reciprocalHitOrtho($Xa,$A)] && [info exists reciprocalHitOrtho($A,$Xa)] # && [info exists reciprocalHitOrtho($Xb,$A)] && [info exists reciprocalHitOrtho($Xa,$Xb)]} { # #on cree le tri-cluster # set triCluster($A,$Xa,$Xb) [list [info exists reciprocalHitOrtho($A,$Xa)] # [info exists reciprocalHitOrtho($Xa,$A)] # [info exists reciprocalHitOrtho($Xb,$A)]] # } # } # } # } # } #} puts "###fin de l'algorithme: [Maintenant]" puts "###creation du fichier homology.csv + orthology.csv" puts "###creation du fichier no_homology.csv + no_orthology.csv" CreateOrthologyDatas reciprocalHitOrtho putOrthoAnalysed noHomology noHitsIn puts "###creation du fichier achevée [Maintenant]" puts "###affichage/creation des logs des résultats" ShowOrthologyResults reciprocalHitOrtho triCluster putOrthoAnalysed $outputType puts "###fin des affichage/creation [Maintenant]" } proc GiveMeThisParalogs {nomRepertoireDesBlast listeDesOrgasAAnalyser {outputType ""} {pipealign ""} {seuilExpect ""} {proteomeFasta ""}} { global RepertoireDuGenome set listeBlast [ListeDesPABs2] set RepBlast "$RepertoireDuGenome/$nomRepertoireDesBlast" #Variables par défaut if {$outputType=="" || $outputType=="toLogs"} {set outputType 1} if {$outputType=="toScreen"} {set outputType 0} if {$pipealign==""} {set $pipealign "F"} if {$seuilExpect==""} {set seuilExpect 0.001} if {$proteomeFasta==""} {set proteomeFasta "$RepertoireDuGenome/proteomeToBlast.fasta"} #pour essais, limitation des boucles set debut 0 set fin [llength $listeBlast] #set aTester {{1938 1940} {2765 2767} {22395 22397} {32525 32527} {34401 34403}} #set aTester {{1900 1903}} set aTester [list [list 0 $fin]] set enModeTest 0 puts "###debut : [Maintenant]" #l'analyse va se faire en plusieurs temps #on va la faire plusieurs fois, chaque fois par rapport à un autre organisme #on aura donc pr chaque proteine d'un orga Oj, les relation de paralogie vis #à vis de O1,O2...Oj ############################################################################# set listeOrgas [ConcernedOrganisms $proteomeFasta] puts " -->Voici la liste des organismes disponibles :" foreach o $listeOrgas {puts " - $o"} puts " Si l'un des organismes apparait plusieurs fois, corrigez vos fichiers !" puts " ex: Xenopus (Silurana) ==>> Xenopus tropicalis" #Si on ne veut que certains des organismes if {$listeDesOrgasAAnalyser!=""} { if {[llength $listeDesOrgasAAnalyser]<2} { puts "ERREUR !!!!! vous devez spécifier AU MOINS 2 organismes valides" exit } #on vérif que tous les orgas donnés existent bien dans les protéomes initiaux foreach elt $listeDesOrgasAAnalyser { if {[lsearch -exact $listeOrgas $elt]==-1} { puts "ERREUR !!!!! un des organismes n'est pas dans la base --> $elt" exit } } set listeOrgas $listeDesOrgasAAnalyser } puts " -->Voici la liste des organismes demandés pour l'analyse :" foreach o $listeOrgas {puts " - $o" } #chargement des bornes des organismes puts " -->Chargement des bornes des organismes (/fiches/lienspabparorga)" set FICBORNES [open "$RepertoireDuGenome/fiches/lienspabparorga" "r"] while {[gets $FICBORNES line]!=-1} { if {[string index $line 0]=="#"} {continue} set infos [split $line ";"] set bornes([lindex $infos 0]) [list [lindex $infos 2] [lindex $infos 3]] } close $FICBORNES #liste des numéros de pab qui vont être analysés (seulement ceux des organismes concernés) set listeComplete {} foreach couple $aTester { puts " * Rangs à analyser : $couple" for {set i [lindex $couple 0]} {$i<[lindex $couple 1]} {incr i} { lappend listeComplete $i } } if {$enModeTest!=1} { set listeComplete {} foreach {key val} [array get bornes] { if {[lsearch -exact $listeOrgas $key]!=-1} { puts " $key : blasts [lindex $bornes($key) 0] à [lindex $bornes($key) 1]" for {set i [lindex $bornes($key) 0]} {$i<[expr [lindex $bornes($key) 1]+1]} {incr i} { lappend listeComplete $i } } } } puts " --> [llength $listeComplete] sorties blast vont etre analysées" ################################################################################################### puts "#####################################################################" puts " --> Analyse des hits des blasts (étape trèèèès longue, environ 1h pour 30000 blast)" foreach num $listeComplete { set i $num #variables d'état set previousOrga "" if {![info exists onEstSur] } {set onEstSur ""} set fileName "$RepBlast/[lindex $listeBlast [expr $i-1]]" #puts $fileName array set tabBlast {} array set tabHit {} #analyse du blast DepouilleLeBlast2 tabBlast $fileName #extraction infos query set queryDescription $tabBlast(Query) set mots [split $queryDescription " "] set queryOrga [concat [lindex $mots 2] [lindex $mots 3]] ###PATCH###################################################################### if {$queryOrga=="Xenopus (Silurana)" || $queryOrga=="Xenopus _Silurana_"} {set queryOrga "Xenopus tropicalis"} ###/PATCH###################################################################### set queryPAB [lindex $mots 0] set queryAccess [lindex $mots 1] #si le blast n'est pas d'une proteine dans notre liste d'organismes if {[lsearch -exact $listeOrgas $queryOrga]==-1} {continue} if {$queryOrga!=$onEstSur} { puts " - Passage aux blasts de $queryOrga [Maintenant]" } set onEstSur $queryOrga puts [expr $tabBlast(NbSubject)+1] #analyse des hits ################### ## comme on ne considere pas certains organisme; le numero du hit sera donc décalé set decalage 0 for {set hitNum 1} {$hitNum<[expr $tabBlast(NbSubject)+1]} {incr hitNum} { #extraction infos du hit set ID $tabBlast($hitNum) set hitAccess $tabBlast($ID,Access) set hitBrut $tabBlast($ID,SubjectBrut) set mots [split $hitBrut " "] regexp {>(.*)} [lindex $mots 0] foo hitPAB set hitDefinition $tabBlast($ID,Definition) set mots [split $hitDefinition " "] set hitOrga [concat [lindex $mots 0] [lindex $mots 1]] ###PATCH###################################################################### if {$hitOrga=="Xenopus (Silurana)" || $hitOrga=="Xenopus _Silurana_"} {set hitOrga "Xenopus tropicalis"} ###/PATCH###################################################################### #si le hits n'est pas sur un organisme à analyser, on zappe if {[lsearch -exact $listeOrgas $hitOrga]==-1} { incr decalage -1 continue } set description "" for {set m 2} {$m<[llength $mots]} {incr m} { append description "[lindex $mots $m]" } #on ajoute ce hit à la liste complete des PAB rencontrés pour ce blast lappend tabHit($queryPAB) $hitPAB lappend tabHitOrga($queryPAB) $hitOrga #On note quel est l'organisme en question, on incrementera le compteur #quand on a un autre hit pour cette organisme #si l'organisme n'a pas encore été rencontré ou si c un nouveau blast, on part à 1 if {![info exists countOrga($hitOrga)] || ($countOrga($hitOrga)==0)} { set countOrga($hitOrga) 1 } else { incr countOrga($hitOrga) } #tests sur les segments HSP for {set hsp 1} {$hsp<[expr $tabBlast($ID,NbSegment)+1]} {incr hsp} { #si on respect le seuil d'expect if {$tabBlast($ID,$hsp,Expect)<=$seuilExpect} { #servira a la creation de no_hits_in_orga if {[info exists matrice([expr $hitNum+$decalage],$countOrga($hitOrga),$hitOrga)]} {continue} if {![info exists expectOK($queryPAB,[expr $hitNum+$decalage])]} { set expectOK($queryPAB,[expr $hitNum+$decalage]) $tabBlast($ID,$hsp,Expect) } set matrice([expr $hitNum+$decalage],$countOrga($hitOrga),$hitOrga) $hitPAB #puts "[expr $hitNum+$decalage], $countOrga($hitOrga), $hitOrga : # $hitPAB : $tabBlast($ID,$hsp,Expect) < $seuilExpect" } } } #tous les hits pour ce PAB sont analysés ############################################### #remise à 0 du compteur lié aux organismes foreach {key val} [array get countOrga] {set countOrga($key) 0} #remise à 0 du décalage set decalage 0 #création des listes d'inPara/orgas #################################### #les listes résultantes seront de la forme #listeDesRapportsInPara(PAB,organismeSeuil)={PAB1, PAB2, PAB3,...} array set listeDesRapportsInPara {} foreach orga $listeOrgas { #si c'est lui meme, on zappe if {$orga==$queryOrga} {continue} #si il n'y avait aucun hit tout court if {![info exists tabHit($queryPAB)]} {continue} set nbreHit [llength $tabHit($queryPAB)] set limitFounded 0 for {set i 0} {$i<$nbreHit} {incr i} { #si on tombe sur l'orga seuil, on quitte la boucle if {[info exists matrice([expr $i+1],1,$orga)]} {set limitFounded 1} #si la premiere occurence de l'orga seuil arrive lorsque qu'on a deja #depassé le seuil d'expect, c'est comme si il n'était pas là if {[info exists expectOK($queryPAB,[expr $i+1])]} { if {$limitFounded && $expectOK($queryPAB,[expr $i+1])>$seuilExpect} { #puts "aucun hit sur $orga pour $queryPAB, PAR LIMITE DE SEUIL" array unset listeDesRapportsInPara "$queryPAB,$orga" } } #sinon on rempli la liste if {!$limitFounded} { #si c bien une seq du meme orga if {[lindex $tabHitOrga($queryPAB) $i]==$queryOrga} { #si le seuil a été respecté (on met i+1 car les hits sont comptabilisés de 1 à n precedement) if {[info exists expectOK($queryPAB,[expr $i+1])]} { if {$expectOK($queryPAB,[expr $i+1])<=$seuilExpect} { lappend listeDesRapportsInPara($queryPAB,$orga) [lindex $tabHit($queryPAB) $i] } } } } else {break} } } #passage au PAB suivant array unset matrice array unset expectOK } #regroupement des differents rapports pour valider l'in-paralogie ################################################################################ #tri des relation ou + que 1 vers lui-meme foreach {key liste} [array get listeDesRapportsInPara] { set keys [split $key ","] if {[lindex $keys 0]!=[lindex $liste 0]} { putLog "ca sent le roussi : $key --> '$liste'" "caSentLeRoussi.log" } if {[llength $liste]!=1} { set listeDesRapportsInPara($key) [lsort -dictionary $liste] #on marque qu'il a été trié set rapportsInParaTries($key) 1 } } #recherche des listes communes organisme par organisme array set rapportsInParaValides {} array set rapportsInParaRejetes {} array set sansRapportsInPara {} foreach {key val} [array get rapportsInParaTries] { if {[info exists listeDesRapportsInPara($key)]} { set celuiDeBase [lindex [split $key ","] 0] set orga [lindex [split $key ","] 1] set listeAAnalyser $listeDesRapportsInPara($celuiDeBase,$orga) #si les inparas ont déjà été validé par un autre $celuiDeBase if {[info exists rapportsInParaValides($listeAAnalyser,$orga)]} {continue} #on recherche si pour chaque element Xn de la liste A , la liste B correspondant à ce #meme element Xn est similaire set countOK 0 foreach PAB1 $listeAAnalyser { #on zappe lui-meme if {$PAB1==$celuiDeBase} { incr countOK continue } if {[info exists listeDesRapportsInPara($PAB1,$orga)]} { #on cherche si une meme liste/ss-liste existe pour chaque PAB de la liste set countOKpourSL 0 foreach PAB2 $listeAAnalyser { if {[lsearch -exact $listeDesRapportsInPara($PAB1,$orga) $PAB2]!=-1} { incr countOKpourSL } } #si le nombre dans la sous-liste correspond bien au nombre de la liste #c'est qu'on a vérif toutes les correspondances avec succés #on a donc un un succés de plus pour la listeAAnalyser if {$countOKpourSL==[llength $listeAAnalyser]} {incr countOK} } } #tri selon le résultat $countOK/$aTrouver set aTrouver [llength $listeAAnalyser] if {$countOK==$aTrouver && $aTrouver>1} { set rapportsInParaValides($listeAAnalyser,$orga) "$countOK/$aTrouver" #puts "rapportsInParaValides($listeAAnalyser,$orga) $countOK/$aTrouver" } elseif {$aTrouver==1} { set sansRapportsInPara($celuiDeBase,$orga) "$countOK/$aTrouver" } else { set rapportsInParaRejetes($celuiDeBase,$listeAAnalyser,$orga) "$countOK/$aTrouver" } } } puts "###fin des calculs [Maintenant]" puts "###creation des fichiers paralogy.csv / no_paralogy.csv / partial_paralogy.csv" CreateParalogyDatas rapportsInParaValides rapportsInParaRejetes sansRapportsInPara puts "###creation du fichier achevée [Maintenant]" puts "###affichage/creation des logs des résultats" ShowParalogyResults rapportsInParaValides rapportsInParaRejetes sansRapportsInPara $outputType puts "###fin des affichage/creation [Maintenant]" ### Option pipealign CREATION DES ALIGNEMENTS POUR TOUS LES GROUPES D'IN-PARA ############################################################################### if {$pipealign=="T"} { puts " et debut du pipe: [Maintenant]" LaunchPipesForInParas sansDoublons puts "###fin du pipe: [Maintenant]" } } proc Glimmer {{NomNumeroDuDernier ""}} { global RepertoireDuGenome global FichierSequenceADN set Codons "_" if { [CodonStartPossible "ATG"] } { append Codons "M" } if { [CodonStartPossible "GTG"] } { append Codons "V" } if { [CodonStartPossible "TTG"] } { append Codons "L" } if {![CodonStopPossible "TGA"] } { append Codons "_TGA" } if {$Codons=="_"} { set Codons "" } set Result "$RepertoireDuGenome/glimmer/result" if { ! [file exists "$Result.coord"] || [OuiOuNon "$Result.coord already exists.\n Do I recalculate it ? "]} { set CommandeGlimmer "run-glimmer$Codons $FichierSequenceADN $Result" while { ! [OuiOuNon "I will run \n$CommandeGlimmer\nOK ?"]} { if {[OuiOuNon "Do I abort Glimmer ?"]} { return "" } if {[OuiOuNon "Do I exit ?"]} { exit } set CommandeGlimmer [Entre $CommandeGlimmer] } if {$CommandeGlimmer!=""} { set RepGlimmer "$RepertoireDuGenome/glimmer" if { ! [file exists $RepGlimmer]} { file mkdir $RepGlimmer } NousAllonsAuBoulot $RepGlimmer if {[catch {eval exec $CommandeGlimmer} Message]} { if { ! [OuiOuNon "Glimmer sent me following message\n$Message\n \nCan I scan its output ?"]} { OnRevientDuBoulot return "" } } OnRevientDuBoulot } } if {[regexp "GLIMMER" $NomNumeroDuDernier]} { SauveLesLignes [LesBornesDeGlimmer $NomNumeroDuDernier] dans "$RepertoireDuGenome/fiches/bornesdesglimmers" } return 1 } proc Glimmer2 {{NomNumeroDuDernier ""}} { global RepertoireDuGenome global FichierSequenceADN # set Codons "_" # if { [CodonStartPossible "ATG"] } { append Codons "M" } # if { [CodonStartPossible "GTG"] } { append Codons "V" } # if { [CodonStartPossible "TTG"] } { append Codons "L" } # if {![CodonStopPossible "TGA"] } { append Codons "_TGA" } # # if {$Codons=="_"} { set Codons "" } set Result "$RepertoireDuGenome/glimmer2/result" if { ! [file exists "$Result.coord"] || [OuiOuNon "$Result.coord already exists.\n Do I recalculate it ? "]} { set CommandeGlimmer "/biolo/glimmer2.13/run-glimmer2 $FichierSequenceADN $Result" while { ! [OuiOuNon "I will run \n$CommandeGlimmer\nOK ?"]} { if {[OuiOuNon "Do I abort Glimmer2 ?"]} { return "" } if {[OuiOuNon "Do I exit ?"]} { exit } set CommandeGlimmer [Entre $CommandeGlimmer] } if {$CommandeGlimmer!=""} { set RepGlimmer "$RepertoireDuGenome/glimmer2" if { ! [file exists $RepGlimmer]} { file mkdir $RepGlimmer } NousAllonsAuBoulot $RepGlimmer if {[catch {eval exec $CommandeGlimmer} Message]} { if { ! [OuiOuNon "Glimmer2 sent me following message\n$Message\n \nCan I scan its output ?"]} { OnRevientDuBoulot return "" } } OnRevientDuBoulot } } if {[regexp "GLIMMER" $NomNumeroDuDernier]} { SauveLesLignes [LesBornesDeGlimmer $NomNumeroDuDernier] dans "$RepertoireDuGenome/fiches/bornesdesglimmers2" } return 1 } proc Glimmer3 {{NomNumeroDuDernier ""}} { global RepertoireDuGenome global FichierSequenceADN # set Codons "_" # if { [CodonStartPossible "ATG"] } { append Codons "M" } # if { [CodonStartPossible "GTG"] } { append Codons "V" } # if { [CodonStartPossible "TTG"] } { append Codons "L" } # if {![CodonStopPossible "TGA"] } { append Codons "_TGA" } # # if {$Codons=="_"} { set Codons "" } set Result "$RepertoireDuGenome/glimmer3/result" if { ! [file exists "$Result.coord"] || [OuiOuNon "$Result.coord already exists.\n Do I recalculate it ? "]} { set CommandeGlimmer "/home/perrodou/glimmer3.01/scripts/g3-iterated.csh $FichierSequenceADN $Result" while { ! [OuiOuNon "I will run \n$CommandeGlimmer\nOK ?"]} { if {[OuiOuNon "Do I abort Glimmer3 ?"]} { return "" } if {[OuiOuNon "Do I exit ?"]} { exit } set CommandeGlimmer [Entre $CommandeGlimmer] } if {$CommandeGlimmer!=""} { set RepGlimmer "$RepertoireDuGenome/glimmer3" if { ! [file exists $RepGlimmer]} { file mkdir $RepGlimmer } NousAllonsAuBoulot $RepGlimmer if {[catch {eval exec $CommandeGlimmer} Message]} { if { ! [OuiOuNon "Glimmer3 sent me following message\n$Message\n \nCan I scan its output ?"]} { OnRevientDuBoulot return "" } } OnRevientDuBoulot } } if {[regexp "GLIMMER" $NomNumeroDuDernier]} { SauveLesLignes [LesBornesDeGlimmer $NomNumeroDuDernier] dans "$RepertoireDuGenome/fiches/bornesdesglimmers2" } return 1 } proc GlimmersPerdus {{Quoi LesPerdus}} { set n 0 foreach G [ListeDesGLIMMERs] { if { ! [regexp "EstCharge" [CoGlimmer $G]]} { continue } lappend LesPerdus $G set Debut [Box $G debut] set Fin [Box $G fin] set Orient [Box $G orient] set Long [expr abs($Fin-$Debut+1)] if {$Long<300} { lappend LesPerdusPetits "$G $Long" } else { lappend LesPerdusGrands "$G $Long" } } return "[set $Quoi]\n[llength [set $Quoi]]" } proc GlobRecursif {{Pattern ""} {Directory ""} {DirOnly ""} {FollowLinks ""}} { set FollowLinks [string equal -nocase $FollowLinks "FollowLinks"] if {$Directory==""} { set Directory "." } if {$Pattern==""} { set Pattern "*" } set GlobRecursif {} if {$DirOnly=="DirOnly"} { foreach Dir [glob -nocomplain -type "d" -- [file join $Directory $Pattern]] { if { ! $FollowLinks && [file type $Dir]=="link"} { continue } lappend GlobRecursif $Dir } } else { #ici on peut aussi choper les dir si pattern matche une dir foreach Local [lsort -unique [glob -nocomplain -- [file join $Directory $Pattern]]] { if {! $FollowLinks && [file type $Local]=="link"} { continue } set Local [encoding convertto [encoding system] $Local] lappend GlobRecursif $Local } } foreach Dir [lsort -unique [glob -nocomplain -type "d" -- [file join $Directory *]]] { if { ! $FollowLinks && [file type $Dir]=="link"} { continue } set Dir [encoding convertto [encoding system] $Dir] foreach SousLocal [GlobRecursif $Pattern $Dir $DirOnly] { lappend GlobRecursif $SousLocal } } return $GlobRecursif } proc Glossaire {{Organisme ""} {Champ ""} {ChampSiOrgaSur2 ""}} { global Glossaire FichierGlossaire global GlossaireDesClasses global OrganismePrioritaire #rR Pour plus qu'il se plante on rend la meme chose if {[FileAbsent $FichierGlossaire]} { return $Organisme } if {$Organisme==""} { set Organisme "ListOf"; set Champ "All" } set OOri $Organisme; set COri $Champ; if {$Organisme=="Reset"} { if {[info exists Glossaire]} { unset Glossaire } return "" } if {$ChampSiOrgaSur2!=""} { set Organisme "$Organisme $Champ" set Champ $ChampSiOrgaSur2 } if {$Champ==""} { set Champ "Complet" } regsub " sp$" $Organisme " sp." Organisme regsub -all -nocase {[^a-z0-9_\-'\.]} $Organisme " " Organisme set Organisme [OrthographeCanonique $Organisme] set Organisme [OrganismePrioritaire $Organisme] if {$Organisme=="" || $Organisme=="Unknown unknown" || $Organisme=="uunk" || $Organisme=="unkn" } { set Organisme "Inconnu inconnu" } regsub " " $Organisme "_" OrgaUnderscore if {[info exists Glossaire($OrgaUnderscore,$Champ)]} { return [set Glossaire($OrgaUnderscore,$Champ)] } set OrgaUnderscore [string totitle $OrgaUnderscore] if {[info exists Glossaire($OrgaUnderscore,$Champ)]} { return [set Glossaire($OrgaUnderscore,$Champ)] } set ORGANISME [string toupper $Organisme] if {[info exists Glossaire($ORGANISME,MonComplet)]} { return [Glossaire $Glossaire($ORGANISME,MonComplet) $Champ] } if {[info exists Glossaire("EstCharge")]} { return "" } set Glossaire("EstCharge") 1 #rR Attention: if Organisme has : it's a list of organisms if {0 && [regexp ":" $Organisme]} { foreach O [SplitOrgas $Organisme] { lappend GlosO [Glossaire $O $Champ] } return [join $GlosO ":"] } set Espece "" scan $Organisme "%s %s" Genre Espece set Organisme $Genre if {$Espece!=""} { append Organisme " $Espece" } if {[regexp -nocase {(^hsp|^H\.sp)[\.]*$} $Organisme]} { set Organisme "Halobacterium sp" } if {[regexp -nocase {(^bsp|^B\.sp)[\.]*$} $Organisme]} { set Organisme "Buchnera sp" } if {[regexp -nocase {(^ssp|^S\.sp)[\.]*$} $Organisme]} { set Organisme "Synechocystis sp" } if {[regexp -nocase {(^mtub|^M\.tub)$} $Organisme]} { set Organisme "Mycobacterium tuberculosis" } if {[regexp -nocase {(^rpro|^R\.pro)$} $Organisme]} { set Organisme "Rickettsia prowazekii" } if {[regexp -nocase {(^mthe|^M\.the)$} $Organisme]} { set Organisme "Methanobacterium thermoautotrophicum" } if {[regexp -nocase {^M.thermoautotrop} $Organisme]} { set Organisme "Methanobacterium thermoautotrophicum" } if {[regexp -nocase {^paer$} $Organisme]} { set Organisme "Pseudomonas aeruginosa" } if {[regexp -nocase {^pae$} $Organisme]} { set Organisme "Pyrobaculum aerophilum" } if {[regexp -nocase {^upar$} $Organisme]} { set Organisme "Ureaplasma urealyticum" } if {[regexp -nocase {^rmel$} $Organisme]} { set Organisme "Sinorhizobium meliloti" } if {[regexp -nocase {^rlot$} $Organisme]} { set Organisme "Mesorhizobium loti" } # if {[info exists Glossaire($Organisme,$Champ)]} { return [set Glossaire($Organisme,$Champ)] } foreach Ligne [LesLignesDuFichier "$FichierGlossaire.classes"] { scan $Ligne "%s %s" Genre Espece set Classe [join [lrange [split $Ligne " "] 2 end] " "] set GlossaireDesClasses(${Genre}_$Espece) $Classe } set i 0 set ListeDuGlossaire [LesLignesDuFichier $FichierGlossaire] set LongGlossaire [llength $ListeDuGlossaire] foreach Ligne $ListeDuGlossaire { lappend Glossaire(ListOf,All) $Ligne set lili [split $Ligne "\t"] set Court [lindex $lili 0] set Complet [lindex $lili 1] set COMPLET [string toupper $Complet] set Pointe [lindex $lili 2] set Demi [lindex $lili 3] set Couleur [Nuance [expr {[incr i]*1.0/$LongGlossaire}]] set Angle [expr {$i*2*3.141592/$LongGlossaire}] regsub " " $Complet "_" Orga regsub {\.$} $Court "" Court set Glossaire($Orga,Orga) $Orga set Glossaire($Orga,Court) $Court set Glossaire($Orga,Complet) $Complet set Glossaire($Orga,COMPLET) $COMPLET set Glossaire($Orga,Pointe) $Pointe set Glossaire($Orga,Demi) $Demi set Glossaire($Orga,Couleur) $Couleur set Glossaire($Orga,Angle) $Angle set Glossaire($Orga,Tout) ":$Court:$Complet:$COMPLET:$Pointe:$Demi:$Orga:" if {[info exists GlossaireDesClasses($Orga)]} { set Classe [set GlossaireDesClasses($Orga)] } else { set Classe "ClassUnknown" } set Glossaire($Orga,Classe) $Classe lappend Glossaire(ListOf,Organismes) $Orga lappend Glossaire(ListOf,Complet) [set Glossaire($Orga,Complet)] lappend Glossaire(ListOf,Entier) [set Glossaire($Orga,Tout)] } set Glossaire(Pyrobaculum_aerophilum,Court) "pae" set Orga "Inconnu_inconnu" set Glossaire($Orga,Orga) $Orga set Glossaire($Orga,Court) "iinc" set Glossaire($Orga,Complet) "Inconnu inconnu" set Glossaire($Orga,COMPLET) "INCONNU INCONNU" set Glossaire($Orga,Pointe) "I.inconnu" set Glossaire($Orga,Demi) "Inco.incon" set Glossaire($Orga,Couleur) grey set Glossaire($Orga,Angle) 5. set Glossaire($Orga,Tout) ":Inconnu:Inconnu inconnu:INCONNU INCONNU:I.inconnu:Inco.incon:$Orga:" set Glossaire($Orga,Classe) "ClassUnknown" lappend Glossaire(ListOf,Organismes) $Orga lappend Glossaire(ListOf,Complet) [set Glossaire($Orga,Complet)] lappend Glossaire(ListOf,Entier) [set Glossaire($Orga,Tout)] foreach Orga $Glossaire(ListOf,Organismes) { if { ! [regexp -nocase {[a-z]} $Orga]} { continue } foreach Field [split $Glossaire($Orga,Tout) ":"] { if {$Field==""} { continue } set FIELD [string toupper $Field] if {$FIELD==[string toupper $Orga]} { continue } lappend Glossaire(ListOf,FIELD) $FIELD set Glossaire($FIELD,MonComplet) $Orga } } set Glossaire(ListOf,FIELD) [lsort -unique $Glossaire(ListOf,FIELD)] if {[string equal -nocase $Champ "Couleur"] } { return "grey" } return [Glossaire $OOri $COri] #rR ****************************************************** Wup "Faudra faire la suite proprement" set OrgaInconnu "Inconnu_inconnu" if {[info exists Glossaire($OrgaInconnu,$Champ)]} { return [set Glossaire($OrgaInconnu,$Champ)] } return "" } proc GnDesFromEnsembl {IdEnsemblProt TypeEnsembl Orga Quoi {Short ""}} { #avant utilisais [ContenuDuFichier $UrlId] mais ne marche plus avec une adresse incomplete (http://www.ensembl.org/Homo_sapiens/Gene/Summary?g=ENSG00000211592) mais que avec l'adresse complete (http://www.ensembl.org/Homo_sapiens/Gene/Summary?g=ENSG00000211592;r=2:89156674-89157196;t=ENST00000390237) Mais on ne connait pas cette 2eme partie de l'adresse donc ca ne marche plus, donc luc a cree GetEnsemblWeb pour regler ce probleme global GnDesFromEnsembl if {$TypeEnsembl==""} { set TypeEnsembl "test" } set TypeEnsembl [string tolower $TypeEnsembl] if {[regexp -nocase "Gn" $Quoi] && [info exists GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Gn)]} { return $GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Gn) } if {[regexp -nocase "Des" $Quoi] && [info exists GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Des)]} { return $GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Des) } #Orga peut etre Gallus_gallus, Homo_sapiens, Mus_musculus, Saccharomyces_cerevisiae #Quoi peut etre Gn Des ou GnDes on rend le premier trouve set type "" if {[regexp -nocase "gene" $TypeEnsembl]} { set type "g" } if {[regexp -nocase "transcript" $TypeEnsembl]} { set type "t" } if {[regexp -nocase "protein" $TypeEnsembl]} { set type "p" } if {[regexp -nocase "test" $TypeEnsembl]} { if {[regexp -nocase {ENS[A-Z]*([A-Z])[0-9]+} $IdEnsemblProt Match Lettre]} { set type [string tolower $Lettre] } } if {$type==""} {FaireLire "TypeEnsembl must be gene or transcript or protein or test ($IdEnsemblProt)"; return ""} set Site "http://www.ensembl.org" set Url "$Site/$Orga/Gene/Summary?$type=" set UrlId "$Url$IdEnsemblProt" #set Texte [ContenuDuFichier $UrlId] set Texte [GetEnsemblWeb $UrlId] if {[regexp -nocase "Gn" $Quoi]} { set Panel [StringSuivant "class=\"panel js_panel" dans $Texte] set Zone [StringSuivant "

Name

" dans $Panel] set Ligne [ValeurDeLaBalise "a" Zone] set Gn $Ligne #set Gn [lindex [split $Ligne " "] 1] #set Gn [string trim $Gn " \n\t"] if {$Short=="Short"} { regsub -all -nocase {[^a-z0-9_\-\+\(\)]} [string range $Gn 0 19] "_" Gn } set GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Gn) $Gn if {$Gn!=""} { return $Gn } } if {[regexp -nocase "Des" $Quoi]} { set Content [StringSuivant "class=\"content\"" dans $Texte] set Des [ValeurDeLaBalise "dd" Content] set Des [string range $Des 0 [string first "\[" $Des]-1] set Des [string trim $Des " \n\t"] if {$Short=="Short"} { regsub -all -nocase {[^a-z0-9_\-\+\(\)]} [string range $Des 0 34] "_" Des } set GnDesFromEnsembl($IdEnsemblProt,$TypeEnsembl,$Orga,Des) $Des return $Des } return "" } proc GnFromUniprotData {{FicAc ""} {FicGn ""}} { foreach Ac [LesLignesDuFichier $FicAc] { set GN [QuestionDeScience GeneQuid "ret UniprotData $Ac GN"] if {$GN==""} { continue } set Name [StringApres "Name=" dans $GN] regsub ";" $Name "" Gn lappend LesGn $Gn } return [SauveLesLignes $LesGn dans $FicGn] } proc GoAncestors {Id {Quoi ""} {JoinCar ""} {RecordsJoinCar ""}} { return [GoGetFromGo $Id $Quoi $JoinCar $RecordsJoinCar "Up"] } proc GoChildren {IdOrNameOrAcc {Quoi ""} {JoinCar ""} {RecordsJoinCar ""}} { set Id "" if {[regexp {^[0-9]+$} $IdOrNameOrAcc]} { set Id $IdOrNameOrAcc } if {$Id==""} { set Id [GoInfo $IdOrNameOrAcc "id"] } if {$Id==""} { regsub -all "_" $IdOrNameOrAcc " " Name set Id [GoInfo $Name "id"] } if {$Id==""} { return "" } return [GoNext "Down" $Id $Quoi $JoinCar $RecordsJoinCar] } proc GoCollectInfo {Info} { global GoCollectInfo if {$Info=="ReSeT"} { if {[info exists GoCollectInfo]} { unset GoCollectInfo } return {} } if {$Info=="GeTiT"} { if {[info exists GoCollectInfo]} { return $GoCollectInfo } return {} } LConcat GoCollectInfo $Info return $GoCollectInfo } proc GoGetAncestorsForSet {{GoSet ""} {GetWhat ""} {WhatJoinCar ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""}} { set UpDown "Bidon" UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar ListJoinCar if {[regexp "/" $GoSet]} { set GoSet [split $GoSet "/"] } #rR par defaut on rend GO=GOacc name@Goparent name@GOacc name puis à la ligne etc. if {$GetWhat==""} { set GetWhat "GOacc,name" } if {$WhatJoinCar ==""} { set WhatJoinCar " " } if {$JoinCar ==""} { set JoinCar "@" } if {$RecordsJoinCar==""} { set RecordsJoinCar "=" } if {$ListJoinCar ==""} { set ListJoinCar "\n" } set LesGo {} foreach Ligne $GoSet { scan $Ligne "%s" Go if {$Go=="" || $Go=="all"} { continue } lappend LesGo $Go set Id [GoInfo $Go Id] set InSet($Id) 1 lappend LesId $Id set IdDuGo($Go) $Id } set IdDuAll [GoInfo "all" GOid] foreach Id $LesId { foreach A [GoAncestors $Id] { if {$A=="" || $A==$IdDuAll} { continue } if { ! [info exists InSet($Id)]} { continue } lappend KeepedAncestors($Id) [GoInfo $A $GetWhat $WhatJoinCar] } } set LeResultat {} foreach Go $LesGo { set Id $IdDuGo($Go) lappend LeResultat [join [list $Go [join $KeepedAncestors($Id) $JoinCar]] $RecordsJoinCar] } return [join $LeResultat $ListJoinCar] } proc GoGetEnrichment {{GenesA ""} {GenesB ""} {GetWhat ""}} { if {$GenesA==""} { set GenesA [ContenuDuFichier "[GoStore]/genesA.txt"] } if {$GenesB==""} { set GenesB [ContenuDuFichier "[GoStore]/genesB.txt"] } #Sauve $GenesA dans [HomeRipp]/geneA.txt #Sauve $GenesB dans [HomeRipp]/geneB.txt if {$GetWhat=="" && [PourWscope]} { set GetWhat "GetText" } set LesGenesA [split $GenesA ","] set LesGenesB [split $GenesB ","] set LA [Maxi 1 [llength $LesGenesA]] set LB [Maxi 1 [llength $LesGenesB]] set LesInfosA [GoGetInfosFromGeneListByGO $GenesA "GetGoCountGenes" "GOacc,name" Up] set LesInfosB [GoGetInfosFromGeneListByGO $GenesB "GetGoCountGenes" "GOacc,name" Up] set LesGo {} set LesGoA {} set LesGoB {} foreach Infos $LesInfosA { set GoInfo [lindex $Infos 0] set N [lindex $Infos 1] set GnA [lindex $Infos 2] set Go [scan $GoInfo "%s"] lappend LesGo $Go lappend LesGoA $Go set CountADe($Go) $N set InfoADe($Go) $GoInfo set InfoDe($Go) $GoInfo set GnADe($Go) $GnA } foreach Infos $LesInfosB { set GoInfo [lindex $Infos 0] set N [lindex $Infos 1] set GnB [lindex $Infos 2] set Go [scan $GoInfo "%s"] lappend LesGo $Go lappend LesGoB $Go set CountBDe($Go) $N set InfoBDe($Go) $GoInfo set InfoDe($Go) $GoInfo set GnBDe($Go) $GnB } set LesGo [lsort -unique $LesGo] foreach Go $LesGo { set GnAB {} if {[info exists GnADe($Go)] && [info exists GnBDe($Go)]} { set GnAB [ListsIntersection $GnADe($Go) $GnBDe($Go)] } set NAB [llength $GnAB] set NA 0 ; if {[info exists CountADe($Go)]} { set NA $CountADe($Go) } set NB 0 ; if {[info exists CountBDe($Go)]} { set NB $CountBDe($Go) } set SA [expr int(floor((1000.*$NA)/$LA+0.5))] set SB [expr int(floor((1000.*$NB)/$LB+0.5))] if {$SB==0} { set AB 99.99 } else { set AB [expr 1.0*$SA/$SB] } lappend LeR [format "Q/R %5.2f = %4d / %4d %4d %4d %4d %s" $AB $SA $SB $NA $NB $NAB $InfoDe($Go)] } set LeR [lsort -decreasing -command CompareGoCounts $LeR] if {$GetWhat=="GetText"} { return [join $LeR "\n"] } return $LeR } proc GoGetFromGene {{Qui ""} {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {UpDown ""}} { UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar CanalSqlGeneOntology if {$Quoi==""} { set Quoi "GO" } if { ! [regexp -nocase "^GO" $Quoi]} { set Sql "select $Quoi from gene_product g where symbol='$Qui' and species_id=[GoSpecies]" #Espionne $Sql set R [SqlExec $Sql] if {$R=={}} { set Sql "select g.$Quoi from gene_product g, gene_product_synonym s where g.species_id=[GoSpecies] and s.product_synonym='$Qui' and s.gene_product_id=g.id" set R [SqlExec $Sql] } if {$JoinCar!=""} { set R [join $R $JoinCar] } return $R } set DoUp [expr {[string equal -nocase $UpDown "Up"] && [regexp -nocase "^GO" $Quoi]}] regsub -nocase "^GO" $Quoi "" Quoi if {$Quoi==""} { set Quoi "id" } set GpId [lindex [GoGetFromGene $Qui "id"] 0] if {$GpId==""} { return "" } set LesTQ {} foreach Q [split $Quoi ","] { set TQ "t.$Q" if {[regexp {\.} $Q]} { set TQ $Q } lappend LesTQ $TQ } set TQs [join $LesTQ ","] set Sql "select distinct $TQs from term t, gene_product g, association a where $GpId=g.id and g.id=a.gene_product_id and a.is_not=0 and a.term_id=t.id and t.term_type in [GoTermTypeIn] ;" #LogWscope $Sql set FlatOuList "" set DoList [expr ! [string equal $RecordsJoinCar ""] || ! [string equal $JoinCar ""]] if {$DoList} { if {$RecordsJoinCar=="GetList"} { set RecordsJoinCar "" } set FlatOuList "-list" } set R [SqlExec $Sql $FlatOuList] if {$DoUp} { set LeNouveauR {} foreach r $R { lappend LeNouveauR $r set r [lindex $r 0] set LesAncetres [GoGetFromGo $r $Quoi "" "" Up] foreach a $LesAncetres { lappend LeNouveauR $a } } set LeNouveauR [lsort -unique $LeNouveauR] set R $LeNouveauR } if {$DoList} { set LesRecords {} foreach r $R { if {$JoinCar!=""} { set r [join $r $JoinCar] } lappend LesRecords $r } set R $LesRecords set JoinCar $RecordsJoinCar } if {$JoinCar!=""} { set R [join $R $JoinCar] } return $R } proc GoGetFromGeneList {List {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""} {UpDown ""}} { JeMeSignale UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar ListJoinCar set List [string trim $List " ,;"] if {[regexp {[\,;]} $List]} { set List [split $List ",;"] } else { set List [list $List] } package require md5 set MD5 [md5::md5 -hex $List] set GoStoreFile "[GoStore]/$MD5.txt" if {[FileExists $GoStoreFile]} { LogWscope "On va utiliser $GoStoreFile pour une liste de longueur [llength $List]" set LeGV [ContenuDuFichier $GoStoreFile] } else { LogWscope "On va faire GoGetFromGeneList sur une liste de longueur [llength $List]" set LeGV {} foreach Gene $List { LogWscope $Gene set GV "$Gene=[GoGetFromGene $Gene $Quoi $JoinCar $RecordsJoinCar $UpDown]" lappend LeGV $GV } if {[llength $List]>10} { Sauve $LeGV dans $GoStoreFile } } LogWscope "GoGetFromGeneList va renvoyer [llength $LeGV] records" if {$ListJoinCar=="" || $ListJoinCar=="GetList"} { return $LeGV } return [join $LeGV $ListJoinCar] } proc GoGetFromGeneListAsLists {LesGenes {Quoi ""} {UpDown ""}} { if {$UpDown==""} { set UpDown "Up" } if {$Quoi==""} { set Quoi "GOacc,name" } set JC "@" set RJ "!" if {[PourWscope]} { set LesGosParGene [GoGetFromGeneList $LesGenes $Quoi $JC $RJ GetList $UpDown] } else { #rR attention il faudrait appeler la bonne science BON, GOMF ou EVImm set LesGosParGene [QuestionDeScience EVImm "ret GoGetFromGeneList $LesGenes $Quoi $JC $RJ GetList $UpDown"] } set LesGeneAvecGos {} foreach GeneGosInfos $LesGosParGene { if { ! [regexp {([^=]+)=(.*)} $GeneGosInfos Match Gene GosInfos]} { continue } set LesGosInfos [split $GosInfos $RJ] set LesInfos {} foreach GoInfos $LesGosInfos { set LesInfosDuGo [split $GoInfos $JC] lappend LesInfos $LesInfosDuGo } lappend LesGeneAvecGos [list $Gene $LesInfos] } return $LesGeneAvecGos } proc GoGetFromGo {{IdOrNameOrAcc ""} {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {UpDown ""}} { UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar if {$UpDown ==""} { set UpDown "Here" } if {$Quoi ==""} { set Quoi "GOid" } if {$IdOrNameOrAcc==""} { set IdOrNameOrAcc "molecular_function" } CanalSqlGeneOntology set Id "" if {[regexp {^[0-9]+$} $IdOrNameOrAcc]} { set Id $IdOrNameOrAcc } if {$Id==""} { set Id [GoInfo $IdOrNameOrAcc "id"] } if {$Id==""} { regsub -all "_" $IdOrNameOrAcc " " Name set Id [GoInfo $Name "id"] } if {$Id==""} { return "" } GoCollectInfo "ReSeT" set MaxLevel "" set Moi "0" if {[regexp {^\+} $UpDown]} { set Moi "+0" regsub {^\+} $UpDown "" UpDown } if {[regexp {^\-?[0-9]+$} $UpDown Level]} { if {$Level<0} { set UpDown "Up" } else { set UpDown "Down" } set MaxLevel [expr abs($Level)] if {$MaxLevel==0} { set UpDown "Here" } } GoWalk $UpDown $Id $Moi $Quoi $MaxLevel $JoinCar set LesInfos [GoCollectInfo "GeTiT"] set LesUniques {} if {$JoinCar==""} { foreach LesSousInfos $LesInfos { foreach Info $LesSousInfos { lappend LesUniques $Info } } } else { set LesUniques $LesInfos } # set LesUniques [lsort -unique $LesUniques] set LesUniques [ListeSansDoublon $LesUniques] if {$RecordsJoinCar!="" && $RecordsJoinCar!="GetList" } { set LesUniques [join $LesUniques $RecordsJoinCar] } return $LesUniques } proc GoGetFromGoList {List {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""} {UpDown ""}} { UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar ListJoinCar set List [string trim $List " ,;"] if {[regexp ";" $List]} { set List [split $List ";"] } elseif {[regexp "\," $List]} { if {[regexp {^([0-9]+|GO\:[0-9]+)(\,([0-9]+|GO\:[0-9]+))*$} $List]} { set List [split $List ","] } } else { set List [list $List] } set LeGV {} foreach Go $List { lappend LeGV "$Go=[GoGetFromGo $Go $Quoi $JoinCar $RecordsJoinCar $UpDown]" } if {$ListJoinCar=="" || $ListJoinCar=="GetList"} { return $LeGV } return [join $LeGV $ListJoinCar] } proc GoGetFromPfam {{Qui ""} {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {UpDown ""}} { UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar CanalSqlGeneOntology if {$Quoi==""} { set Quoi "GO" } if { ! [regexp -nocase "^GO" $Quoi]} { set Sql "select $Quoi from dbxref where xref_key='$Qui' and xref_dbname = 'Pfam'" set R [SqlExec $Sql] if {$JoinCar!=""} { set R [join $R $JoinCar] } return $R } regsub -nocase "^GO" $Quoi "" Quoi if {$Quoi==""} { set Quoi "id" } set DbId [lindex [GoGetFromPfam $Qui "id"] 0] if {$DbId==""} {return ""} set LesTQ {} foreach Q [split $Quoi ","] { set TQ "t.$Q" if {[regexp {\.} $Q]} { set TQ $Q } lappend LesTQ $TQ } set TQs [join $LesTQ ","] set Sql "select distinct $TQs from dbxref d, term_dbxref l, term t where $DbId=d.id and d.id=l.dbxref_id and l.term_id=t.id and t.term_type in [GoTermTypeIn] ;" set FlatOuList "" set DoList [expr ! [string equal $RecordsJoinCar ""] || ! [string equal $JoinCar ""]] if {$DoList} { if {$RecordsJoinCar=="GetList"} { set RecordsJoinCar "" } set FlatOuList "-list" } set R [SqlExec $Sql $FlatOuList] if {$DoList} { set LesRecords {} foreach r $R { if {$JoinCar!=""} { set r [join $r $JoinCar] } lappend LesRecords $r } set R $LesRecords set JoinCar $RecordsJoinCar } if {$JoinCar!=""} { set R [join $R $JoinCar] } return $R } proc GoGetFromPfamList {List {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""} {UpDown ""}} { UpDownCommeIlFaut UpDown JoinCar RecordsJoinCar ListJoinCar set List [string trim $List " ,;"] if {[regexp {[\,;]} $List]} { set List [split $List ",;"] } else { set List [list $List] } set LePV {} foreach Pfam $List { lappend LePV "$Gene=[GoGetFromPfam $Pfam $Quoi $JoinCar $RecordsJoinCar $UpDown]" } if {$ListJoinCar=="" || $ListJoinCar=="GetList"} { return $LePV } return [join $LePV $ListJoinCar] } proc GoGetInFile {Fichier args} { #rR c'est trop long de passer par Wscope, on memorise direct dans un fichier ... Pour GO2000 en particulier set Res [eval $args] return [Sauve $Res dans $Fichier] } proc GoGetInfosFromGeneListByGO {LesGenes {GetWhat ""} {Quoi ""} {UpDown ""}} { if {$GetWhat==""} { set GetWhat "GetGoCountGenes" } set LesGeneAvecGos [GoGetFromGeneListAsLists $LesGenes $Quoi $UpDown] set LesGo {} foreach GeneGosInfos $LesGeneAvecGos { lassign $GeneGosInfos Gene LesInfos foreach GoInfos $LesInfos { set Go [lindex $GoInfos 0] lappend LesGo $Go lappend GenesFrom($Go) $Gene set Infos($Go) $GoInfos } } set LesGos [lsort -unique $LesGo] set LesGoCount {} set LesGoCountGenes {} foreach Go $LesGos { set MyGenes [lsort -unique $GenesFrom($Go)] set N [llength $MyGenes] set Info [join $Infos($Go) " "] lappend LesGoCount [list $Info $N] lappend LesGoCountGenes [list $Info $N $MyGenes] } if {$GetWhat=="GetGoCount"} { return $LesGoCount } if {$GetWhat=="GetGoCountGenes"} { return $LesGoCountGenes } return $LesGoCountGenes } proc GoGetShowFromGeneList {LesGn} { set GeneNames [join $LesGn ","] set LesGnGO [GoGetFromGeneList $GeneNames "GOacc,name" "" "\t"] foreach GnGO $LesGnGO { if {[regexp {^([^=]+)=(.*)$} $GnGO Match Gn GOsPropres]} { set GOs $GOsPropres lappend LesGenesEtLeursGOs "\n$Gn *************" } foreach GO [split $GOs "\t"] { lassign $GO GoAcc GoName lappend LesGoAcc $GoAcc lappend LesGoName $GoName set GoAccName "$GoAcc $GoName" lappend LesGenesEtLeursGOs "$Gn $GoAccName" lappend LesGenesDu($GoAccName) $Gn set LesGenesDu($GoAccName) [lsort -unique $LesGenesDu($GoAccName)] } } set LesNombres {} set LesGOsEtLeursGenes [list "#GeneCount GO Genes"] foreach {GoAccName Genes} [array get LesGenesDu] { set Nombre [llength $Genes] lappend LesNombres $Nombre lappend LesGoDeLaLongueur($Nombre) $GoAccName } set LesNombres [lsort -integer -unique -decreasing $LesNombres] foreach Nombre $LesNombres { foreach GoAccName $LesGoDeLaLongueur($Nombre) { lappend LesGOsEtLeursGenes " $Nombre $GoAccName" set Genes [join $LesGenesDu($GoAccName) " "] set TexteAAfficher $Genes while {[string length $TexteAAfficher]>80} { set Debut [string range $TexteAAfficher 0 79] set iDBlanc [string last " " $Debut] set BonDebut [string range $TexteAAfficher 0 $iDBlanc-1] set TexteAAfficher [string range $TexteAAfficher $iDBlanc+1 end] lappend LesGOsEtLeursGenes "[string repeat { } 40] $BonDebut" } if {$TexteAAfficher != ""} { lappend LesGOsEtLeursGenes "[string repeat { } 40] $TexteAAfficher" } } } set LesFenetres {} #set F [AfficheListe $LesGenesEtLeursGOs "GrandeLargeur" "Genes With their GOs"] lappend LesFenetres [AfficheListe $LesGOsEtLeursGenes "GrandeLargeur" "GOs with their genes"] return $LesFenetres } proc GoInfo {Id Keys {JoinCar ""} {RecordsJoinCar ""}} { regsub -all "'" $Id "''" Id if {$Id==""} { set Id "NotFindableId" } set LesValeurs {} CanalSqlGeneOntology if {[regexp -nocase "^PFAM" $Keys]} { regsub -nocase "PFAM" $Keys "" Keys if {$Keys==""} { set Keys "xref_key" } set LesK {} set ListeVide {} foreach K [split $Keys ","] { set TK "d.$K" if {[regexp {\.} $K]} { set TK $K } lappend LesTK $TK lappend ListeVide "" } set TKs [join $LesTK ","] set Sql "select $TKs from dbxref d, term_dbxref td, term t where t.id = $Id and t.id = td.term_id and td.dbxref_id = d.id and (d.xref_dbname = 'Pfam' or d.xref_dbname = 'PfamB');" } elseif {[regexp -nocase "^GENE" $Keys]} { regsub -nocase "GENE" $Keys "" Keys if {$Keys==""} { set Keys "symbol" } set LesK {} set ListeVide {} foreach K [split $Keys ","] { set TK "g.$K" if {[regexp {\.} $K]} { set TK $K } lappend LesTK $TK lappend ListeVide "" } set TKs [join $LesTK ","] set SpeciesId [GoSpecies] set Sql "select $TKs from term t, gene_product g, association a where g.species_id=$SpeciesId and a.gene_product_id=g.id and a.is_not=0 and a.term_id=t.id and t.id=$Id;" } else { regsub "^GO" $Keys "" Keys if {$Keys==""} { set Keys "id" } set LesK {} set ListeVide {} foreach K [split $Keys ","] { set TK "$K" if {[regexp {\.} $K]} { set TK $K } lappend LesTK $TK lappend ListeVide "" } set Where "where name='notFindableGo'" if {[regexp {[a-z]} $Id]} { set Where "where name='$Id' and is_obsolete=0" } if {[regexp {^[0-9]+$} $Id]} { set Where "where id=$Id and is_obsolete=0" } if {[regexp {^GO\:} $Id]} { set Where "where acc='$Id' and is_obsolete=0" } set Sql "select $Keys from term $Where;" } set LesValeurs [SqlExec $Sql "-list"] if {$JoinCar==""} { if {$LesValeurs=={}} { return {} } return [list $LesValeurs] } if {$LesValeurs=={}} { set LesValeursJointes [join $ListeVide $JoinCar] } else { set LesValeursJointes {} foreach LesChamps $LesValeurs { set Valeur [join $LesChamps $JoinCar] lappend LesValeursJointes $Valeur } } if {$RecordsJoinCar=="" || $RecordsJoinCar=="GetList"} { return $LesValeursJointes } if {$RecordsJoinCar=="GetFirstvalue"} { return [lindex $LesValeursJointes 0]} return [join $LesValeursJointes $RecordsJoinCar] } proc GoNext {UpDown Id {Quoi ""} {JoinCar ""} {RecordsJoinCar ""}} { CanalSqlGeneOntology if {$Id=="" || $Id=="{}"} { return {} } if {[string equal -nocase $UpDown "Down"]} { set Source "term1_id" set Destin "term2_id" } else { set Source "term2_id" set Destin "term1_id" } regsub -nocase "^GO" $Quoi "" Quoi if {$Quoi==""} { set Quoi "id" } set LesTQ {} foreach Q [split $Quoi ","] { set TQ "t.$Q" if {[regexp {\.} $Q]} { set TQ $Q } lappend LesTQ $TQ } set TQs [join $LesTQ ","] if { ! [regexp {^[0-9]+$} $Id]} { set Id [GoInfo $Id "id"] } set FlatOuList "-flatlist" if {$JoinCar!=""} { set FlatOuList "-list" } set IsA [SqlExec "select id from term where name='is_a'"] set PartOf [SqlExec "select id from term where name='part_of'"] set Relatives [SqlExec "select $TQs from term t, term2term l where l.$Source=$Id and l.$Destin=t.id and (l.relationship_type_id=$IsA or l.relationship_type_id=$PartOf) and t.is_obsolete=0;" $FlatOuList] if {$JoinCar!=""} { set LesR {} foreach R $Relatives { set Champ [join $R $JoinCar] lappend LesR $Champ } set Relatives $LesR } if {$RecordsJoinCar!=""} { set Relatives [join $Relatives $RecordsJoinCar] } return $Relatives } proc GoOntology {Go} { CanalSqlGeneOntology if { ! [regexp {^GO\:[0-9]+$} $Go]} { set Go [GoGetFromGo $Go "GOacc"] } set Sql "select term_type from term where acc='$Go'" set O [SqlExec $Sql] return $O } proc GoParents {IdOrNameOrAcc {Quoi ""} {JoinCar ""} {RecordsJoinCar ""}} { set Id "" if {[regexp {^[0-9]+$} $IdOrNameOrAcc]} { set Id $IdOrNameOrAcc } if {$Id==""} { set Id [GoInfo $IdOrNameOrAcc "id"] } if {$Id==""} { regsub -all "_" $IdOrNameOrAcc " " Name set Id [GoInfo $Name "id"] } if {$Id==""} { return "" } return [GoNext "Up" $Id $Quoi $JoinCar $RecordsJoinCar] } proc GoSpecies {{Qui ""} {Quoi ""} {JoinCar ""} {RecordsJoinCarNeSertPasEncore ""}} { global GoSpecies if {$Quoi=="All"} { set Quoi "*" } if {$Qui=="" && [info exists GoSpecies]} { return $GoSpecies } set DefSpe "" if {$DefSpe=="" && [regexp -nocase "hu" [RepertoireDuGenome]]} { set DefSpe "Homo sapiens" } ;#rR a ameliorer !! if {$DefSpe=="" && [OnTraite "BON"]} { set DefSpe "Homo sapiens" } if {$DefSpe=="" && [OnTraite "GOSc"]} { set DefSpe "Saccharomyces cerevisiae S288c" } if {$DefSpe=="" && [NotreOX]!=""} { set DefSpe "ncbi_taxa_id_[NotreOX]" } if {$DefSpe==""} { set DefSpe "Mus musculus" } if {$Qui==""} { set Qui $DefSpe } if {$Quoi==""} { set Quoi "id" } set SetDefault [expr [string equal -nocase $Quoi "SetDefault"]] if {$SetDefault} { set Quoi "id" } CanalSqlGeneOntology if {[regexp "select " $Qui]} { return [SqlExec $Sql] } set Where "id=$Qui" if {[regexp -nocase "^ncbi_taxa_id" $Qui]} { regsub -all {[^0-9]} $Qui "" NcbiTaxaId set Where "ncbi_taxa_id=$NcbiTaxaId" } elseif {[regexp {[ _]} $Qui]} { regsub "_" $Qui " " Qui scan $Qui "%s" Genre regsub "$Genre " $Qui "" Espece set Where "genus='$Genre' and species='$Espece'" } set Sql "select $Quoi from species where $Where" set R [SqlExec $Sql] if {$JoinCar!=""} { set R [join $R $JoinCar] } if {$SetDefault} { set GoSpecies $R } return $R } proc GoStore {} { return "[HomeRipp]/GxWww/GoStore" } proc GoTermType {} { if {[OnTraite "GOMF"]} { return [list "molecular_function"] } if {[OnTraite "BON"]} { return [list "molecular_function"] } return [list "biological_process" "cellular_component" "molecular_function"] } proc GoTermTypeIn {} { set Types [join [GoTermType] "','"] set In "('$Types')" return $In } proc GoTestAll {} { Espionne [GoSpecies] Espionne [GoSpecies] Espionne [GoSpecies "Homo sapiens" "SetDefault"] Espionne [GoSpecies] Espionne [GoSpecies "Mus musculus" "SetDefault"] Espionne [GoSpecies] Espionne [GoSpecies "ncbi_taxa_id9606" "SetDefault"] Espionne [GoSpecies] Espionne [GoSpecies "Mus musculus" "SetDefault"] #rR et ca marche sans quote avec underscore ( _ est mieux pour le web) Espionne [GoSpecies Mus_musculus "genus,species,common_name"] Espionne [GoGetFromGo "cyclin protein" GENE] Espionne [GoGetFromGo "cyclin protein" PFAM] Espionne [GoGetFromGo "cyclin binding" "GENEsymbol,full_name" "="] EspionneL [GoGetFromGene pax6 "GOacc,name,a.assocdate" "" "GetList"] } proc GoWalk {UpDown Id Level Keys {MaxLevel ""} {JoinCar ""}} { if {$MaxLevel==""} { set MaxLevel 999999 } #Espionne "Walk [string repeat " " $Level] $Id [GoInfo $Id "acc,name" "=" "GetFirstValue"]" #rR on met +1 pour ne pas prendre le starting GO mais que les fils if {[regexp {^\+} $Level]} { regsub {^\+} $Level "" Level } else { GoCollectInfo [GoInfo $Id $Keys $JoinCar] } if {[string equal -nocase $UpDown "Here"]} { return } incr Level if {$Level>$MaxLevel} { return } set Relatives [GoNext $UpDown $Id] foreach R $Relatives { if {$R==1} { continue } GoWalk $UpDown $R $Level $Keys $MaxLevel $JoinCar } return } proc GoldArchaea {{Qui ""} {Quoi ""}} { global GoldArchaea if {[info exists GoldArchaea($Qui,$Quoi)]} { return $GoldArchaea($Qui,$Quoi) } if {[info exists GoldArchaea($Qui,Go)]} { set Go $GoldArchaea($Qui,Go) if {[info exists GoldArchaea($Go,$Quoi)]} { return $GoldArchaea($Go,$Quoi) } } if {[info exists GoldArchaea("EstCharge")]} { return "" } set GoldArchaea("EstCharge") 1 set Fichier "/home/ripp/gscope/archaeaTax.txt" foreach Ligne [LesLignesDuFichier $Fichier] { lassign [split $Ligne "\t"] Go OS Dom OX Date set Go [string trim $Go] set OS [string trim $OS] set OX [string trim $OX] set Dom [string trim $Dom] set Date [string trim $Date] set GoldArchaea($Go,Go) $Go set GoldArchaea($Go,OS) $OS set GoldArchaea($Go,OX) $OX set GoldArchaea($Go,Dom) $Dom set GoldArchaea($Go,Date) $Date lappend GoldArchaea(ListOf,Go) $Go lappend GoldArchaea(ListOf,OS) $OS lappend GoldArchaea(ListOf,OX) $OX set GoldArchaea($OS,Go) $Go set GoldArchaea($OX,Go) $Go } return [GoldArchaea $Qui $Quoi] } proc Gonfle {w Tag {ScaleX gonfle} {ScaleY 1.0}} { global ScaleCumuleDeGonfle OrigXCumuleDeGonfle OrigYCumuleDeGonfle global ScrollRectangleOriginal IdScrollRectangle Gs "UpdateK" if {[regexp "rond" $w]} { FaireLire "Sorry, the Zoom doesn't work for Rosace." return } set K $w.canvas set ScroHor $w.hscroll set ScroVer $w.vscroll scan "[$ScroHor get]" "%f %f" g d scan "[$ScroVer get]" "%f %f" b h set RatioHor [expr ($g + $d)/2] set RatioVer [expr ($b + $h)/2] scan [$K cget -scrollregion] "%f %f %f %f" xMin yMin xMax yMax set CentreHor [expr $xMin + $RatioHor*($xMax-$xMin)] set CentreVer [expr $yMin + $RatioVer*($yMax-$yMin)] if {[regexp "expo" $K]} { set CentreHor 0 set CentreVer 0 } if {[PourWscope]} { set ScaleGonfle 2.0 } else { set ScaleGonfle 1.1 } if { $ScaleY == "gonfle" } { set Scaley $ScaleGonfle } if { $ScaleY == "degonfle" } { set Scaley [expr 1./$ScaleGonfle] } if { $ScaleX == "gonfle" } { set Scalex $ScaleGonfle set Scaley 1.0 } else { set Scalex $ScaleX set Scaley 1.0 } if { $ScaleX == "degonfle" } { set Scalex [expr 1./$ScaleGonfle] set Scaley 1.0 } if { $ScaleY != "1.0"} { set Scaley $ScaleY } if { $ScaleY == "gonfle" } { set Scaley $ScaleGonfle } if { $ScaleY == "degonfle" } { set Scaley [expr 1./$ScaleGonfle] } if { $ScaleX == "reset" } { scan [$K coords [set IdScrollRectangle($K)]] "%f %f %f %f" xMin yMin xMax yMax scan [set ScrollRectangleOriginal($K)] "%f %f %f %f" xMinO yMinO xMaxO yMaxO set Scalex [expr ($xMaxO-$xMinO)*1.0/($xMax-$xMin)] set Scaley [expr ($yMaxO-$yMinO)*1.0/($yMax-$yMin)] } $K scale $Tag $CentreHor $CentreVer $Scalex $Scaley $K configure -scrollregion [$K coords [set IdScrollRectangle($K)]] return $K } proc GoodAccessForHam {} { set Fichier "all_172.tfas" set Texte [ContenuDuFichier $Fichier] regsub ".tfas$" $Fichier "_OK.tfas" NewFichier regsub -all -nocase {(>[a-z0-9\-_\+]+)([\,\.]+)} $Texte {\1} BonTexte return [Sauve $BonTexte dans $NewFichier] } 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 GoodUnixFileNames {{Rep ""}} { if {$Rep==""} { set Rep "./" } foreach F [lsort [glob -nocomplain "$Rep/*"]] { regsub -nocase -all {[^A-Z0-9_\-\.\+\#\~\\]} $F "_" G Espionne "$F\n$G" file rename $F $G } return } proc GrandFrereDuMutant {Nom} { return [LesMutantsDe $Nom "SonGrandFrere"] } proc GraphDesTaillesPourLesNoLoc {FichierClusters} { foreach JR [ListeMinimumDesJR $FichierClusters] { if {[PolyLocalise $JR]=="NoLocalization"} { set L [SeqLength $JR] if {$L==0} { continue } set L [expr $L/100] lappend LesLongueurs $L } } Histogramme $LesLongueurs Graphe } proc GraphDesTaillesPourTous {} { foreach Nom [ListeDesPABs] { set L [SeqLength $Nom] if {$L==0} { continue } set L [expr $L/100] lappend LesLongueurs $L } Histogramme $LesLongueurs Graphe } proc GraphDesTaillesPourTousLesJR {FichierClusters} { foreach JR [ListeDesJR $FichierClusters] { set L [SeqLength $JR] if {$L==0} { continue } set L [expr $L/100] lappend LesLongueurs $L } Histogramme $LesLongueurs Graphe } proc GraphMLPourTous {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/tfasdescopains} set r [glob -directory $directory *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } set fileIn "[RepertoireDuGenome]/StringRep/String/$f" set fileOut "[RepertoireDuGenome]/StringRep/String/$f.xml" CreationGrpahML $fileIn $fileOut FinPasTouche $f } } proc Graph_Panel {LeCanvasPere} { Wup "Panel de choix d affichage et de couleur des differents graphes Tm GC ID NbSeq" set LesGraphes [LesGraphesDeLOligo $LeCanvasPere] if {$LesGraphes==""} {return ""} set GrapheTopLevel "$LeCanvasPere.graphepanel" if {[winfo exists $GrapheTopLevel]} { wm deiconify $GrapheTopLevel raise $GrapheTopLevel return "" } else {toplevel $GrapheTopLevel} wm geometry $GrapheTopLevel +300+100 wm title $GrapheTopLevel "Graph Selection" wm resizable $GrapheTopLevel false false set FrameGraphe "$GrapheTopLevel.lesgraphesframe" frame $FrameGraphe -borderwidth "3" -relief "groove" pack $FrameGraphe -expand "true" -side "top" -fill "both" set IndGraph 0 set NbGraph [llength $LesGraphes] #Trie pour avoir GC et Tm devant les autres if {[regexp "GC" $LesGraphes]} {set GraphesOrdonnes "GC"} foreach G $LesGraphes { if {[regexp -nocase "Tm" $G]} {lappend GraphesOrdonnes $G} else {continue} } foreach G $LesGraphes { if {$G=="GC" || [regexp -nocase "Tm" $G]} {continue} else {lappend GraphesOrdonnes $G} } set LesGraphes $GraphesOrdonnes unset GraphesOrdonnes foreach Graphe $LesGraphes { incr IndGraph set TagOrId $Graphe set Graphe [string tolower $Graphe] set PetiteFrameGraphe "$FrameGraphe.f$Graphe" set LGr "$PetiteFrameGraphe.l$Graphe" set BGrOn "$PetiteFrameGraphe.bgon$Graphe" set BGrOff "$PetiteFrameGraphe.bgoff$Graphe" set BMoyOn "$PetiteFrameGraphe.bmoyon$Graphe" set BMoyOff "$PetiteFrameGraphe.bmoyoff$Graphe" set BColor "$PetiteFrameGraphe.bcolor$Graphe" frame $PetiteFrameGraphe -borderwidth "0" -relief "groove" label $LGr -text "$TagOrId" -padx "2" -borderwidth "3" -relief "groove" -background "orange" button $BGrOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere $TagOrId" button $BGrOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere $TagOrId" button $BMoyOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere Average${TagOrId}" button $BMoyOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere Average${TagOrId}" button $BColor -text "C" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -background "#808FFF" #bind $LGr "LePanneauDeCouleursDuGraph $LGr $K $TagOrId" #bind $BColor "LePanneauDeCouleursDuGraph $BColor $K $TagOrId" bind $BColor <1> "LePanneauDeCouleursDuGraph $BColor $LeCanvasPere $TagOrId" grid $PetiteFrameGraphe -sticky ewns grid $LGr -row 1 -column 0 -sticky ewns grid $BGrOn -row 1 -column 1 -sticky ewns grid $BGrOff -row 1 -column 2 -sticky ewns grid $BMoyOn -row 1 -column 3 -sticky ewns grid $BMoyOff -row 1 -column 4 -sticky ewns grid $BColor -row 1 -column 5 -sticky ewns if {$IndGraph==1} { set DismissB "$PetiteFrameGraphe.destroybutton" set LDuGraph "$PetiteFrameGraphe.ldugraph" set LDuMoy "$PetiteFrameGraphe.ldumoyenne" set LDeDeco "$PetiteFrameGraphe.ldedeco" button $DismissB -text "Exit" -anchor "center" -padx "3" -background "red" -borderwidth "2" -relief "groove" -activebackground "red" -overrelief "sunken" -command "destroy $GrapheTopLevel" label $LDuGraph -text "Graph" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief "groove" label $LDuMoy -text "Average" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief "groove" label $LDeDeco -text "" -anchor "center" -padx "2" -background "green3" -borderwidth "3" -relief "groove" grid $DismissB -row 0 -column 0 -sticky ewns grid $LDuGraph -row 0 -column 1 -sticky ewns -columnspan 2 grid $LDuMoy -row 0 -column 3 -sticky ewns -columnspan 2 grid $LDeDeco -row 0 -column 5 -sticky ewns } if {$IndGraph==$NbGraph} { set LAllDuGr "$PetiteFrameGraphe.lalldugraph" set BAllGrOn "$PetiteFrameGraphe.ballgon" set BAllGrOff "$PetiteFrameGraphe.ballgoff" set BAllAvOn "$PetiteFrameGraphe.ballaon" set BAllAvOff "$PetiteFrameGraphe.ballaoff" set LDeDeco "$PetiteFrameGraphe.ldedeco2" label $LAllDuGr -text "All" -anchor "center" -padx "2" -relief "groove" -background "green3" -borderwidth "3" button $BAllGrOn -text "On" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Raiser $LeCanvasPere OligoGraph" button $BAllGrOff -text "Off" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Lower $LeCanvasPere OligoGraph" button $BAllAvOn -text "On" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "RaiseLesAverageDeLOligo $LeCanvasPere" button $BAllAvOff -text "Off" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "LowerLesAverageDeLOligo $LeCanvasPere" label $LDeDeco -text "" -anchor "center" -padx "2" -relief "groove" -background "green3" -borderwidth "3" grid $LAllDuGr -row 2 -column 0 -sticky ewns grid $BAllGrOn -row 2 -column 1 -sticky ewns grid $BAllGrOff -row 2 -column 2 -sticky ewns grid $BAllAvOn -row 2 -column 3 -sticky ewns grid $BAllAvOff -row 2 -column 4 -sticky ewns grid $LDeDeco -row 2 -column 5 -sticky ewns } grid columnconfigure $PetiteFrameGraphe 0 -weight 1 grid columnconfigure $PetiteFrameGraphe 1 -weight 0 grid columnconfigure $PetiteFrameGraphe 2 -weight 0 grid columnconfigure $PetiteFrameGraphe 3 -weight 0 grid columnconfigure $PetiteFrameGraphe 4 -weight 0 } return "" } proc Graphe {LesX {LesY ""} {K ""} {Couleur ""} {Largeur ""} {Hauteur ""} {CigCsd ""} {AvecAxes ""} {Titre ""} {LaListeDesTags ""} {DotOnly ""} {BindOnly ""} {LargeurMax ""} {HauteurMax ""}} { global BornesDuGraphe if {$BindOnly!=""} { set LesBind [split $BindOnly "_"] set BindOnly 1 } else { set BindOnly 0 } set DotOnly [string equal -nocase "DotOnly" $DotOnly] set EnBatons 0 if {$LesY=="EnBatons"} { set LesY {} ; set EnBatons 1 } if {$LesY=="Regulier"} { set LesY {}} if {$Couleur==""} { set Couleur "black" } if {$Largeur==""} { if {$K==""} { set Largeur 512 } else { set Largeur [lindex [$K configure -width] 4] } } if {$Hauteur==""} { if {$K==""} { set Hauteur 512 } else { set Hauteur [lindex [$K configure -height] 4] } } if {$CigCsd=={}} { set CigCsd [list [expr $Largeur*0.05] [expr $Hauteur*0.05] [expr $Largeur*0.95] [expr $Hauteur*0.95]] } ScanLaListe $CigCsd GaucheX BasY DroiteX HautY if {$LargeurMax==""} { set LargeurMax $Hauteur } if {$HauteurMax==""} { set HauteurMax $Hauteur } set LongX [llength $LesX] if {$LongX==0} { return "" } if {$LesY=={}} { set LesY $LesX if {$EnBatons} { set LesY [lreplace $LesY -1 -1 0] } set LongY [llength $LesY] set LesX [NombresEntre 0 [expr $LongY-1]] } if {[info exists BornesDuGraphe($K)]} { ScanLaListe [set BornesDuGraphe($K)] MinX MinY MaxX MaxY } else { set MinX [MiniDeLaListe $LesX] set MaxX [MaxiDeLaListe $LesX] set MinY [MiniDeLaListe $LesY] set MaxY [MaxiDeLaListe $LesY] set NoDistorsion 0 if {$NoDistorsion} { set MinX [Mini $MinX $MinY] set MinY $MinX set MaxX [Maxi $MaxX $MaxY] set MaxY $MaxX } set BornesDuGrapheCourant [list $MinX $MinY $MaxX $MaxY] } if {$MinX==$MaxX} { set PlageX 1 } else { set PlageX [expr $MaxX - $MinX] } if {$MinY==$MaxY} { set PlageY 1 } else { set PlageY [expr $MaxY - $MinY] } set AX [expr 1.0*($DroiteX-$GaucheX)/$PlageX] set AY [expr 1.0*($HautY -$BasY )/$PlageY] set BX [expr $GaucheX-$AX*$MinX] set BY [expr $BasY -$AY*$MinY] if {$K==""} { if {$EnBatons} { set K [UnCanva $LargeurMax $HauteurMax $Hauteur $Largeur "" $Titre] } else { set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur "" $Titre] } set BornesDuGraphe($K) $BornesDuGrapheCourant GraphesEnStock $K } foreach X $LesX Y $LesY { lappend Lesx [expr $AX*$X + $BX] lappend Lesy [expr $AY*$Y + $BY] } set Zerox [expr $AX*0 + $BX] set Zeroy [expr $AY*0 + $BY] set Oldx [lindex $Lesx 0] set OldyM [expr $HauteurMax-[lindex $Lesy 0]] set Prems 1 set MargeX 0 set MargeY 0 set BatonColors [list LightGreen LightBlue] set iBC 0 set nBC [llength $BatonColors] set os 4 Espionne $HauteurMax foreach x $Lesx y $Lesy X $LesX Y $LesY LesTags $LaListeDesTags { set yM [expr $HauteurMax-($y)] lappend LesTags "|" $X $Y $x $yM if {$EnBatons} { set Color [lindex $BatonColors [expr [incr iBC]%$nBC]] $K create rectangle [expr $Zeroy + $MargeY] [expr $Oldx + $MargeX] [expr $y + $MargeY] [expr $x + $MargeX] -fill $Color if {[lindex $LesTags 0]!="|"} { $K create text [expr $Zeroy + $MargeY +10] [expr $x + $MargeX -2] -text [lindex $LesTags 0] -anchor nw -tag "tissue" } } else { $K create oval [expr $x-$os] [expr $yM-$os] [expr $x+$os] [expr $yM+$os] -fill $Couleur -outline $Couleur -tag [linsert $LesTags 1 oval] if { ! $DotOnly} { $K create line $Oldx [expr $OldyM] $x [expr $yM] -fill $Couleur -tag [linsert $LesTags 1 line] } } set Oldx $x set OldyM $yM } if {$BindOnly} { foreach B $LesBind { $K bind $B "EntreDansCoeur $K %x %y" $K bind $B "SortDeCoeur $K %x %y" } } else { $K bind "all" "EntreDansCoeur $K %x %y" $K bind "all" "SortDeCoeur $K %x %y" } $K raise "tissue" return $K } proc GrapheDesFrequences {File} { foreach Ligne [LesLignesDuFichier $File] { scan $Ligne "%d %d" x y lappend Lesx $x lappend Lesy $y } Graphe $Lesx $Lesy } proc GrapheDuFichier {{Fichier ""}} { if {$Fichier!=""} { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%f %f" X Y lappend LesX $X lappend LesY $Y } return [Graphe $LesX $LesY "" "blue" 800 600] } } proc GrapheDuPourcentageDeNPourLesNoLoc {FichierClusters} { foreach JR [ListeMinimumDesJR $FichierClusters] { if {[PolyLocalise $JR]=="NoLocalization"} { set Longueur [SeqLength $JR] if {$Longueur==0} {continue} set Sequence [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/$JR"] set LesLettres [split $Sequence ""] set n 0 foreach Lettre $LesLettres { if {$Lettre=="N"} {incr n} } set Pourcent [expr $n*100/$Longueur] set P [expr $Pourcent/1] lappend LesPourcentagesDeN $P } } Histogramme $LesPourcentagesDeN Graphe } proc GrapheDuPourcentageDeNPourTousLesLocs {FichierClusters} { foreach JR [ListeMinimumDesJR $FichierClusters] { if {[PolyLocalise $JR]!="NoLocalization"} { set Longueur [SeqLength $JR] if {$Longueur==0} {continue} set Sequence [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/$JR"] set LesLettres [split $Sequence ""] set n 0 foreach Lettre $LesLettres { if {$Lettre=="N"} {incr n} } set Pourcent [expr $n*100/$Longueur] set P [expr $Pourcent/1] lappend LesPourcentagesDeN $P } } Histogramme $LesPourcentagesDeN Graphe } proc GrapheExpressedTissuesOLD {} { set LesSi [string trim [string repeat "100 400 800 400 000 400 400 800 400 000 " 7]] set K [Graphe $LesSi "EnBatons" "" "" 1000 500 "" "" "ExpressTiss" $LesSi] $K create text 300 10 -text "Signal Intensities" -font {Arial 14} } proc GrapheScore {{a ""} {b ""} {op ""}} { global Lscores K if {[info exists K]} { destroy $K } set K [Graphe $Lscores] bind all {destroy $k} $K configure -background black $K itemconfig Cadre -fill black #return set Lv [lsort -real $Lscores] set max [lindex $Lv end] set min [lindex $Lv 0] puts "\nScores : [llength $Lscores] $min $max" $K itemconfig oval -fill white return } proc GrapheVecItem {Fichier} { foreach XYZP [VecItem $Fichier] { foreach {x y z pl} $XYZP { Espionne $XYZP lappend LesX $x lappend LesY $y } Graphe $LesX $LesY } } proc GraphesEnStock {{Quoi ""} {K ""} {R ""}} { global GraphesEnStock global GraphesEnStockInfo if {$Quoi==""} { set Quoi "GetList" } if { ! [info exists GraphesEnStock]} { set GraphesEnStock {} } if {[string equal -nocase "GetList" $Quoi]} { return $GraphesEnStock } if {[string equal -nocase "Reset" $Quoi]} { set Old $GraphesEnStock set GraphesEnStock {} return $Old } if {[string equal -nocase "HighlightId" $Quoi]} { if {$R==""} { if {[info exists GraphesEnStockInfo($K,HighlightId)]} { return $GraphesEnStockInfo($K,HighlightId) } else { return "" } } set GraphesEnStockInfo($K,HighlightId) $R return $GraphesEnStockInfo($K,HighlightId) } if {[string equal -nocase "Remove" $Quoi]} { set I [lsearch $GraphesEnStock $K] set GraphesEnStock [lreplace $GraphesEnStock $I $I] return $GraphesEnStock } if {[regexp "^\." $Quoi]} { set K $Quoi if { ! [regexp {(.*).canvas} $K Match w]} { return $GraphesEnStock} set D "$w.buttons.dismiss" $D configure -command "GraphesEnStock Remove $K; destroy $w" lappend GraphesEnStock $Quoi return $GraphesEnStock } return $GraphesEnStock } proc Graphiste {LesOrdresPourGIF ValWidth ValHeight X1 Y1 X2 Y2 CheminGIF {OnVeutLeTexte 1} {OnVeutLesArcs 1}} { global CommandeCanvart global GraphisteDir set ValWidth [expr int($ValWidth)] set ValHeight [expr int($ValHeight)] set RepertoireLog "" if {[info exists GraphisteDir]} { set RepertoireLog "$GraphisteDir/log" } if {$RepertoireLog=="" || ! [file writable $RepertoireLog]} { set RepertoireLog "[RepertoireDeTravail]/log" } if { ![file exists $RepertoireLog] } { file mkdir $RepertoireLog } if {[regexp "/gd" $CommandeCanvart]} { set OrdrePourGIF [string trim [join $LesOrdresPourGIF "\n"]] set f [open "|$CommandeCanvart $ValWidth $ValHeight $X1 $Y1 $X2 $Y2 $CheminGIF $OnVeutLeTexte 2>/dev/null" "w"] puts $f $OrdrePourGIF flush $f close $f return "OK" } if {[regexp "^java" $CommandeCanvart]} { if {$OnVeutLeTexte} { set TexteOuNon "yes" } else { set TexteOuNon "no" } if {$OnVeutLesArcs} { set ArcsOuNon "yes" } else { set ArcsOuNon "no" } set AvecLog 1 if {$AvecLog} { set fico [open "$RepertoireLog/entreecanvart.log" "w"] puts $fico [string trim [join $LesOrdresPourGIF "\n"]] close $fico } set f [open "|$CommandeCanvart -width $ValWidth -height $ValHeight -box $X1 $Y1 $X2 $Y2 -output $CheminGIF -nodecompose -text $TexteOuNon -arc $ArcsOuNon >& $RepertoireLog/sortiecanvart.log" "w"] puts $f [string trim [join $LesOrdresPourGIF "\n"]] flush $f close $f return "OK" } } proc Grave {VariableDeGrave} { upvar $VariableDeGrave ContenuVariableDeGrave set Pierre [AppendPierre] puts $Pierre "" puts $Pierre "#Debut $VariableDeGrave" set lElements [uplevel "array names $VariableDeGrave"] if {[llength $lElements]==0} { puts $Pierre "set $VariableDeGrave [list $ContenuVariableDeGrave]" } else { foreach e $lElements { puts $Pierre "set $VariableDeGrave\($e\) [list $ContenuVariableDeGrave($e)]" } } puts $Pierre "#Fin $VariableDeGrave" } proc Grid2Gscope {dirGrid dirGscope PGS {NJob 0}} { if {! [file exists $dirGscope]} {file mkdir $dirGscope} cd $dirGscope set GPtmp [file join $dirGscope tmp] set GPlog [file join $dirGscope log] set GPfiches [file join $dirGscope fiches] set GPbeton [file join $dirGscope beton] set GPprottfa [file join $dirGscope prottfa] set GPtfa [file join $dirGscope tfasdescopains] set GPblastp [file join $dirGscope blastp] set GPballast [file join $dirGscope ballast] set GPmsf [file join $dirGscope msf] set GPinout [file join $dirGscope inout] set GPleon [file join $dirGscope leon] set GPrascal [file join $dirGscope rascal] set GPnormd [file join $dirGscope normd] set GPcluspack [file join $dirGscope cluspack] foreach v [info locals GP*] { if {! [file exists $v]} {file mkdir [set $v]} } set Lfile [glob -directory $dirGrid -nocomplain -- *.tar] set Lfile [lsort -command TrieFileGrid $Lfile] set nd [string length [llength $Lfile]] set format "%s%0${nd}d" foreach f $Lfile { set fdel [glob -nocomplain -directory "$dirGscope/tmp" -- *] foreach e $fdel { file delete -force $e } file copy -force $f [file join $dirGscope tmp $f] cd [file join $dirGscope tmp] catch {exec tar -xf $f} set lgz [glob -nocomplain *.gz] foreach e $lgz { exec gunzip -f $e } set No [NumeroDuJob $PGS] set PGSN "$PGS$No" Espionne "Traite $PGSN" set prefix "" set ltfa [glob -nocomplain *.tfa] foreach f $ltfa { if {[regexp {\-} $f]} {continue} set prefix [string range $f 0 end-4] break } # Traitement prottfa if {[file exists "${prefix}.tfa"]} { file rename -force "${prefix}.tfa" "$GPprottfa/$PGSN" } # Traitement tfas des copains set filroot "${prefix}-filter-OUT" if {[file exists "$filroot"]} { file rename -force "$filroot" "$GPtfa/$PGSN" } # Traitement blast set blaroot "${prefix}-blastall-OUT" if {[file exists "$blaroot.blastp"]} { file rename -force "$blaroot.blastp" "$GPblastp/$PGSN" } # Traitement ballast set balroot "${prefix}-ballast-OUT" if {[file exists $balroot]} { file rename -force $balroot "$GPballast/$PGSN" } if {[file exists "${balroot}.anchors"]} { file rename -force "${balroot}.anchors" "$GPballast/$PGSN.anchors" } if {[file exists "${balroot}.prof"]} { file rename -force "${balroot}.prof" "$GPballast/$PGSN.prof" } if {[file exists "${balroot}.motifs"]} { file rename -force "${balroot}.motifs" "$GPballast/$PGSN.motifs" } # traitement clustalw set clusroot "${prefix}-clustalw-OUT.msf" if {[file exists $clusroot]} { file rename -force "$clusroot" "$GPmsf/$PGSN" } # Traitement de rascal set rasroot "${prefix}-rascal-OUT.msf" if {[file exists $rasroot]} { file rename -force "$rasroot" "$GPrascal/$PGSN" } # Traitement de leon set leonroot "${prefix}-leon-OUT.msf" if {[file exists $leonroot]} { file rename -force "$leonroot" "$GPleon/$PGSN" } # Traitement de leon set norroot "${prefix}-normd-OUT.list" if {[file exists $norroot]} { file rename -force "$norroot" "$GPnormd/$PGSN" } # Traitement de Cluspack set croot "${prefix}cluspackOUT.clu" if {[file exists $croot]} { file rename -force "$croot" "$GPcluspack/$PGSN" } } exit } proc GrilladesEnCours {{Qui ""} {Quoi ""}} { global GEC #rR Attention c'est pas très clair : OI utilise surtout les liens et ici on se sert des fiheirs dans fiches. A CLARIFIER !!!" if {[info exists GEC($Qui,$Quoi)]} { if {[PourWscope]} { return [join $GEC($Qui,$Quoi) "\n"] } return $GEC($Qui,$Quoi) } if {[info exists GEC("EstCharge")]} { return "" } set GEC("EstCharge") 1 set GEC(ListOf,Science) {} set GEC(ListOf,PP) {} set GEC(ListOf,PassePlat) {} #rR les passeplats sont tries ... du coup c'est le dernier qui est pris en compte pour une science set LesFichesPassePlats [lsort [glob -nocomplain "/genomics/link/*/fiches/PassePlat_*"]] set LesScience {} foreach FichePassePlat $LesFichesPassePlats { Espionne $FichePassePlat set Science [file tail [file dirname [file dirname $FichePassePlat]]] set PassePlat [ContenuDuFichier $FichePassePlat] set GEC($Science,PassePlat) $PassePlat set PP [file tail $PassePlat] set GEC($PP,Science) $Science lappend GEC(ListOf,Science) $Science lappend GEC(ListOf,PP) $PP lappend GEC(ListOf,PassePlat) $PassePlat } set GEC(ListOf,Info) {} foreach Science $GEC(ListOf,Science) { set LienPP "/genomics/link/$Science/fiches/passeplat" set PassePlat $GEC($Science,PassePlat) set NbGrillades [llength [glob -nocomplain "$PassePlat/blastp/*"]] set GEC($Science,NbGrillades) $NbGrillades if { ! [file exists $LienPP]} { if {[OuiOuNon "$LienPP does not exist. Do I create it ?" 0] } { file link -symbolic $LienPP "$PassePlat/blastp" } } lappend GEC(ListOf,Info) [format "%-10s %6d on %s" $Science $NbGrillades $PassePlat] } set GEC(,) [join $GEC(ListOf,Info) "\n"] return [GrilladesEnCours $Qui $Quoi] } proc GrilladinPourOi {{ProjName ""} {FastaFile ""} {BlastDatabase ""} {OptionsBlast ""}} { if {$ProjName==""} { set ProjName "BlastongOi" } if {$FastaFile==""} { set FastaFile [GscopeFile $ProjName "oip"] } if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] } #f {$OptionsBlast==""} { set OptionsBlast "-W 3 -e 1.0e-5 -v 5000 -b 5000 -K 0 -F F -C 2" } if {$OptionsBlast==""} { set OptionsBlast "-word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2" } set PassePlat "" if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} { set ProjNameWithDate "${ProjName}_[Date]" set DBSizeTxt [BlastDatabaseSize $BlastDatabase] scan $DBSizeTxt "%d" DBSize Espionne "Grillade::creerPoeleBlastOi ProjectName $ProjNameWithDate Input $FastaFile DB $BlastDatabase DBsize $DBSize BlastOpts $OptionsBlast" set PassePlat [Grillade::creerPoeleBlastOi ProjectName $ProjNameWithDate Input $FastaFile DB $BlastDatabase DBsize $DBSize BlastOpts $OptionsBlast] if {[regexp -nocase "^Error" $PassePlat]} { set Message "Error. Something is wrong with Grilladin. I got the error message $PassePlat" } #rR Ici on fait DEUX choses : on crée un lien et on crée un fichier dans fiches ........................... c'est le lien qui est bon ! #rR Tcl ne veut pas pointer si la cible n'existe pas :file link -symbolic "[RepertoireDuGenome]/passeplat" "$PassePlat/blastp" exec ln -sf "$PassePlat" "[RepertoireDuGenome]/PassePlat_$ProjNameWithDate" AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat set Message "Warning. I launched Grilladin for $ProjName. Blast files will be available at $PassePlat" return $Message } else { set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin" } return $Message } proc GrosGetz {Fichier} { set LesAccess [LesLignesDuFichier $Fichier] foreach Access $LesAccess { set ACCESS [string toupper $Access] set MoiAussi($ACCESS) 1 } set Accesses [join $LesAccess "|"] # Espionne [QuestionDeScience QuidSeq "QuidOSsOfACs $Accesses"] # exit set CommandeGetz "getz -e \"\\\[\{swissprot sptrembl\}-acc: $Accesses\\\]\"" set Texte [eval exec $CommandeGetz] set LaSeq {} foreach Ligne [split $Texte "\n"] { if {[regexp "^AC " $Ligne]} { regsub -all "\;" $Ligne " " Ligne set LesAccessRecus [split $Ligne " "] set AccessOK "Inconnu" foreach Access $LesAccessRecus { set ACCESS [string toupper $Access] if {[info exists MoiAussi($ACCESS)]} { set AccessOK $Access } } } if {[regexp "^//" $Ligne]} { lappend LaSeq $Ligne set Seq [join $LaSeq "\n"] lappend LesSeqs $Seq set MaSeq($AccessOK) $Seq set LaSeq {} } else { lappend LaSeq $Ligne } } foreach Access $LesAccess { set ACCESS [string toupper $Access] Espionne "\n$Access" if { ! [info exists MaSeq($ACCESS)]} { Espionne "$Access ................................................ non trouve" } else { Espionne [set MaSeq($ACCESS)] } } exit } proc GroupDeMaSelection {Box} { set RepertoireProches "[RepertoireDuGenome]/ProchesQuery85" if {[regexp -nocase "Mouse" [RepertoireDuGenome]] || [regexp -nocase "Rat" [RepertoireDuGenome]]} { set FileProches "$RepertoireProches/${Box}.proches" set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} } else { set Cluster [ExtraitInfo $Box "Cluster"] set FileProches "$RepertoireProches/${Cluster}.proches" set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new"} } foreach Name [LesLignesDuFichier $FileProches] { set Group [FromMacsims $FileMacsims $Name Group] lappend LesGroup $Group #Espionne "\t $Name $Group" } set LesGroup [ListeSansDoublon $LesGroup] #Espionne "\t \t LesGroup $LesGroup" return $LesGroup } proc GroupDunName {FileMacsims NameVoulu} { set FileMacsims [TheTrueMacsimsFile $FileMacsims] set fh [open $FileMacsims "r"] dom parse -channel $fh doc close $fh $doc documentElement root foreach seq [$root selectNodes "//sequence"] { set Name [$seq selectNodes "string(./seq-name)"] set Group [$seq selectNodes "string(./seq-info/group)"] if {$Name == $NameVoulu} { $doc delete return $Group } } $doc delete } proc GroupEtNonSubgroupDansXml {} { foreach Nom [ListeDesPABs] { set Fichier "[RepertoireDuGenome]/macsimXml/$Nom" if { ! [file exists $Fichier]} { continue } set LesBonnes {} foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "" $Ligne]} { continue } lappend LesBonnes $Ligne } SauveLesLignes $LesBonnes dans $Fichier } exit } proc GroupMacsimsAvecFnote {{In ""} {Ou ""}} { set I 0 set LeNew {} foreach Ligne [LesLignesDuFichier $In] { if {[regexp {} $Ligne]} { set PreviousI $I ; set LigneDuGroup $Ligne} if {[regexp {Group([0-9]+)} $Ligne Match G]} { if { ! [info exists DejaVu($PreviousI)]} { regsub {[0-9]+} $LigneDuGroup "$G" NewG set LeNew [lreplace $LeNew $PreviousI $PreviousI $NewG] set DejaVu($PreviousI) 1 } } lappend LeNew $Ligne incr I } return [SauveLesLignes $LeNew dans $Ou] } proc GroupeDpc {Nom {Query SameAs} {InOut Out}} { global GroupeDpc Wup "Attention GroupeDpc ne calcule pas il ne donne que la valeur" Wup "il faut avoir fait GroupeSecator en positionnant ExecutableSecator a dpc" Wup "Ca devrait marcher si il y a le FichierSortieDpc" set OnAppend 0 if {$Query=="" || $Query=="SameAs"} { set Query $Nom } set QueryEstNom [string equal -nocase $Query $Nom] set OnVeutToutLeMonde 0 set OnVeutToutLeMondeAvecGroupe 0 if {$InOut=="ToutLeMonde"} { set OnVeutToutLeMonde 1 set Query "CacheToiQueryQuOnNeTeTrouvePas" } elseif {$InOut=="ToutLeMondeAvecGroupe"} { set OnVeutToutLeMondeAvecGroupe 1 set Query "CacheToiQueryQuOnNeTeTrouvePas" } else { set OutQuery [string equal -nocase $InOut "Out"] } set QUERY [string toupper $Query] if {[info exists GroupeDpc($QUERY)]} { set LeGroupe [set GroupeDpc($QUERY)] if {$OutQuery} { return $LeGroupe } else { return [lappend LeGroupe $Query] } } if {$QueryEstNom && [info exists GroupeDpc("EstCharge")]} { if {$OutQuery} { return {} } else { return [list $Query] } } set FichierGroupeDpc "[RepertoireDuGenome]/fiches/groupedpc" if {[file exists $FichierGroupeDpc]} { foreach Ligne [LesLignesDuFichier $FichierGroupeDpc] { scan $Ligne "%s" NomLu set NomLu [string toupper $NomLu] set GroupeDpc($NomLu) [lrange [split [string trim $Ligne] " "] 1 end] } if { ! $OnAppend} { set GroupeDpc("EstCharge") 1 return [GroupeDpc $Nom $Query $InOut] } } set LeGroupe {} set OnLeTient 0 set FichierSortieDpc "[RepertoireDuGenome]/dpc/$Nom" if { [FileAbsent $FichierSortieDpc] } { foreach Ext [list ".dpc" ".clu"] { set Possible $FichierSortieDpc$Ext if {[FileExists $Possible]} { set FichierSortieDpc $Possible ; break } } append FichierSortieDpc ".dpc" } if { [FileAbsent $FichierSortieDpc] } { return {} } foreach Ligne [LesLignesDuFichier $FichierSortieDpc] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne]} { if {$OnLeTient} { break } set Numero "" scan $Ligne "%s %s" Groupe Numero if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 } set LeGroupe {} continue } scan $Ligne "%s" Access if {[string toupper $Access]==[string toupper $Query]} { set OnLeTient 1 if {$OutQuery} { continue } } lappend ToutLeMondeAvecGroupe "$Access $Numero" lappend ToutLeMonde $Access lappend LeGroupe $Access } if {$OnVeutToutLeMonde} { return $ToutLeMonde } if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe } if {$Groupe=="unclustered"} { return $ToutLeMonde } else { return $LeGroupe } } proc GroupeLesSequences {} { # 1 on supprime tous les groupes touches, et on cree un nouveau groupes avec les sequences selectionness # ==> 'create and delete' # # 2 on cree un nouveau groupe avec les seq s selectionnees et on les enleve de leur groupe d'origine # ==> 'create and keep' # # 3 on fait un groupe avec les seqs selectionnes + toutes celles des groupes qu'elles touchent # ==> 'fusion' global NomNomSeq NomTextSeq NomSeqSel Couleurs ListeSeqsGroupees LNSeqlab WNSeqlab if {[llength $NomSeqSel] < 2} { FaireLire "Please select at least 2 sequences first !" return } # 1 : find a name for the new group set i 1 set gcou "G$i" while {[info exists ListeSeqsGroupees($gcou)]} { incr i set gcou "G$i" } set iGrp $i set bcoul [CouleurO2Ordali [CouleurDuGroupe $iGrp]] # define tag for new group $NomNomSeq configure -state normal $NomNomSeq tag configure TC$gcou -background $bcoul -foreground black # 2 : analyse selected sequences set Liy {} ; set Ly {} set InGroups {} # yw : y dans widget, yl y dans LNSeqlab set Lseqi {} foreach e $NomSeqSel { set ing "G0" lassign [split $e .] yw x lappend Lyw $yw set yl [expr {$yw-1}] lappend Lyl $yl set seqass [lindex $LNSeqlab $yl] foreach g [array names ListeSeqsGroupees] { if {$seqass in [set ListeSeqsGroupees($g)]} { lappend InGroups $seqass $yw $yl $g set ing $g break } } lappend Lseqi $seqass $yw $yl $ing } ClearSelectionNoms if {[llength $InGroups] == 0} { # creation simple d'un groupe CreeSeqlabGroup $gcou $Lseqi set NomSeqSel {} $NomNomSeq configure -state disabled return } # Selected sequences already belong to a/some # groups. Merge or create new group # # 1 how many groups are touched ? set Lg [list] foreach {s yw yl g} $InGroups { lappend Lg $g } set Lg [lsort -unique -dictionary $Lg] set choix [tk_dialog .chx "Merge/Create" "Some sequences already belong to groups.\nDo you want to :" "" -1 "Create and Delete" "Create and Keep" "Fusion" "Cancel"] # Create and Delete if {$choix == 0} { # Create and Delete # ungroup all seqs of selected groups set Lixun {} foreach g $Lg { DetruitSeqlabGroup $g } # puts selected seqs in a new group CreeSeqlabGroup $gcou $Lseqi } elseif {$choix == 1} { # Create and Keep # remove seqs from their actual group set Lixun {} ; set Ltag {} foreach {s yw yl g} $InGroups { lappend Lixun $yl $NomNomSeq tag remove TC$g $yw.0 "$yw.0 lineend" set ig [lsearch -exact $ListeSeqsGroupees($g) $s] set ListeSeqsGroupees($g) [lreplace $ListeSeqsGroupees($g) $ig $ig] update } $NomTextSeq ungroup $Lixun # check for groups with only one sequence foreach g $Lg { if {[llength $ListeSeqsGroupees($g)] <= 1} { DetruitSeqlabGroup $g } } # create a new group with selected seqs CreeSeqlabGroup $gcou $Lseqi } else { # Fusion # search for group with lower name set pg [lindex $Lg 0] # delete groups set Lgi {} foreach g [lrange $Lg 1 end] { foreach s $ListeSeqsGroupees($g) { set yl [lsearch -exact $LNSeqlab $s] set yw [expr {$yl+1}] lappend Lgi $s $yw $yl } DetruitSeqlabGroup $g } # add all to lower group set Lyl {} ; set Ltag {} foreach {s yw yl} $Lgi { lappend Lyl $yl lappend ListeSeqsGroupees($pg) $s lappend Ltag $yw.0 "$yw.0 lineend" } # add seq with no group foreach {s yw yl g} $Lseqi { if {$g eq "G0"} { lappend Lyl $yl lappend ListeSeqsGroupees($pg) $s lappend Ltag $yw.0 "$yw.0 lineend" } } set ipg [string range $pg 1 end] $NomNomSeq tag add TC$pg {*}$Ltag $NomTextSeq group $ipg $Lyl } set NomSeqSel {} $NomNomSeq configure -state disabled return } proc GroupeOumy {Nom {Query SameAs} {InOut Out}} { global GroupeOumy Wup "Attention GroupeOumy ne calcule pas il ne donne que la valeur" Wup "il faut avoir fait GroupeSecator en positionnant ExecutableSecator a Oumy" Wup "Ca devrait marcher si il y a le FichierSortieOumy" set OnAppend 0 if {$Query=="" || $Query=="SameAs"} { set Query $Nom } set QueryEstNom [string equal -nocase $Query $Nom] set OnVeutToutLeMonde 0 set OnVeutToutLeMondeAvecGroupe 0 if {$InOut=="ToutLeMonde"} { set OnVeutToutLeMonde 1 set Query "CacheToiQueryQuOnNeTeTrouvePas" } elseif {$InOut=="ToutLeMondeAvecGroupe"} { set OnVeutToutLeMondeAvecGroupe 1 set Query "CacheToiQueryQuOnNeTeTrouvePas" } else { set OutQuery [string equal -nocase $InOut "Out"] } set QUERY [string toupper $Query] if {[info exists GroupeOumy($QUERY)]} { set LeGroupe [set GroupeOumy($QUERY)] if {$OutQuery} { return $LeGroupe } else { return [lappend LeGroupe $Query] } } if {$QueryEstNom && [info exists GroupeOumy("EstCharge")]} { if {$OutQuery} { return {} } else { return [list $Query] } } set FichierGroupeOumy "[RepertoireDuGenome]/fiches/groupeoumy" if {[file exists $FichierGroupeOumy]} { foreach Ligne [LesLignesDuFichier $FichierGroupeOumy] { scan $Ligne "%s" NomLu set NomLu [string toupper $NomLu] set GroupeOumy($NomLu) [lrange [split [string trim $Ligne] " "] 1 end] } if { ! $OnAppend} { set GroupeOumy("EstCharge") 1 return [GroupeOumy $Nom $Query $InOut] } } set LeGroupe {} set OnLeTient 0 set FichierSortieOumy "[RepertoireDuGenome]/Oumy/$Nom" if { ! [file exists $FichierSortieOumy]} { append FichierSortieOumy ".Oumy" } if { ! [file exists $FichierSortieOumy]} { return {} } foreach Ligne [LesLignesDuFichier $FichierSortieOumy] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne]} { if {$OnLeTient} { break } set Numero "" scan $Ligne "%s %s" Groupe Numero if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 } set LeGroupe {} continue } scan $Ligne "%s" Access if {[string toupper $Access]==[string toupper $Query]} { set OnLeTient 1 if {$OutQuery} { continue } } lappend ToutLeMondeAvecGroupe "$Access $Numero" lappend ToutLeMonde $Access lappend LeGroupe $Access } if {$OnVeutToutLeMonde} { return $ToutLeMonde } if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe } if {$Groupe=="unclustered"} { return $ToutLeMonde } else { return $LeGroupe } } proc GroupeRestant {as al LR} { upvar $as SG upvar $al LG global LNOrdali NomSeqSel # Donne toutes les sequences qui : # - n'ont pas ete selectionnees pour clustering # - ont ete miises dans le groupe poubelle # all seqs set i 1 foreach n $LNOrdali { set TLi($i) 1 incr i } # remove selected foreach p $NomSeqSel { lassign [split $p .] y x set TLi($y) 0 } # add garbage seqs foreach i $LR { incr i set TLi($i) 1 } # take the rest set i 1 set Laisse [list] foreach n $LNOrdali { if {$n ne "" && [set TLi($i)]} { lappend Laisse $n } incr i } if {[llength $Laisse]} { lappend LG "GroupSeqOut" set SG(GroupSeqOut) $Laisse puts "===> GroupeRestant \n[join $Laisse \n]" } return } proc GroupeSecator {NomOuMSFOuAutre {Query SameAs} {InOut Out} {Calculate ""} {OutFile ""}} { global GroupeSecator Wup "InOut can be In, Out or ToutLeMonde, ToutLeMondeAvecGroupe," Wup "or AppendAuGroupeSecator if you want to complete the file groupesecator" Wup "OutFile can be a filename but it works only with ToCalculate." set OutQuery 0 set Racine "TrululuTrala" if {$NomOuMSFOuAutre=="AppendAuGroupeSecator"} { set OnAppend 1 set Nom "Bidon" } else { set OnAppend 0 } set NomOuMSF $NomOuMSFOuAutre set MayBeMSF $NomOuMSF set Nom [file tail $NomOuMSF] if {[file exists $MayBeMSF] && (! [EstUnPAB $Nom] || $Query!="SameAs")} { set FichierMSF $MayBeMSF if { ! [regexp "^/" $FichierMSF]} { set FichierMSF "[pwd]/$MayBeMSF" } set Calculate "ToCalculate" } if {$Query=="" || $Query=="SameAs"} { set Query $Nom } set QueryEstNom [string equal -nocase $Query $Nom] set ToCalculate [string equal -nocase $Calculate "ToCalculate"] set OnVeutToutLeMonde 0 set OnVeutToutLeMondeAvecGroupe 0 set UnGroupe 1 if {$InOut=="ToutLeMonde"} { set OnVeutToutLeMonde 1 set UnGroupe 0 set Query "CacheToiQueryQuOnNeTeTrouvePas" set ToCalculate 1 } elseif {$InOut=="ToutLeMondeAvecGroupe"} { set OnVeutToutLeMondeAvecGroupe 1 set UnGroupe 0 set Query "CacheToiQueryQuOnNeTeTrouvePas" set ToCalculate 1 } else { set OutQuery [string equal -nocase $InOut "Out"] } set QUERY [string toupper $Query] if { ! [info exists FichierMSF] || ! [file exists $FichierMSF]} { if {[info exists GroupeSecator($QUERY)]} { set LeGroupe [set GroupeSecator($QUERY)] if {$OutQuery} { return $LeGroupe } else { return [lappend LeGroupe $Query] } } if {$QueryEstNom && [info exists GroupeSecator("EstCharge")]} { if {$OutQuery} { return {} } else { return [list $Query] } } set FichierGroupeSecator "[RepertoireDuGenome]/fiches/groupesecator" if { ! $ToCalculate && [file exists $FichierGroupeSecator]} { foreach Ligne [LesLignesDuFichier $FichierGroupeSecator] { scan $Ligne "%s" NomLu set NOMLU [string toupper $NomLu] set GroupeSecator($NOMLU) [lrange [split [string trim $Ligne] " "] 1 end] } if { ! $OnAppend} { set GroupeSecator("EstCharge") 1 return [GroupeSecator $Nom $Query $InOut] } } if { $OnAppend || ! $ToCalculate && [OuiOuNonMemo "Do I create the file $FichierGroupeSecator ?" 0]} { foreach PAB [ListeDesPABs] { if {[info exists GroupeSecator($PAB)]} { continue } set FichierMSF "[RepertoireDuGenome]/msf/$PAB" if { ! [file exists $FichierMSF]} { continue } set PL [PremiereLigneDuFichier $FichierMSF] if {[regexp "Clustalw inutile|NoSequence" $PL]} { continue } set LeGroupe [GroupeSecator $PAB $PAB "Out" "ToCalculate"] set Texte "$PAB [join $LeGroupe " "]" AppendAuFichier $FichierGroupeSecator $Texte Espionne "I appended : $Texte" } return [GroupeSecator $Nom $Query $InOut] } set FichierMSF "[RepertoireDuGenome]/msf/$Nom" if { ! [file exists $FichierMSF]} { return {} } } set FichierSortie [Secator $FichierMSF] if {$FichierSortie==""} { return {} } regsub {\.[a-z]+$} $FichierSortie "" Racine set LeGroupe {} set OnLeTient 0 set Numero -1 foreach Ligne [LesLignesDuFichier $FichierSortie] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster [0-9]|^unclustered } $Ligne]} { if { ! $OnVeutToutLeMondeAvecGroupe && ! $OnVeutToutLeMonde && $OnLeTient} { break } set Numero "" scan $Ligne "%s %s" Groupe Numero if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 } set LeGroupe {} continue } scan $Ligne "%s" Access if {[string toupper $Access]==[string toupper $Query]} { set OnLeTient 1 if {$OutQuery} { continue } } lappend ToutLeMondeAvecGroupe "$Access $Numero" lappend ToutLeMonde $Access lappend LeGroupe $Access } if {[regexp "tmp" $Racine]} { foreach Fichier [glob -nocomplain "$Racine*"] { file delete $Fichier } } set Resultat $LeGroupe if {$OnVeutToutLeMonde} { set Resultat $ToutLeMonde } if {$OnVeutToutLeMondeAvecGroupe} { set Resultat $ToutLeMondeAvecGroupe } if {$UnGroupe && $Groupe=="unclustered"} { set Resultat $ToutLeMonde } if {$OutFile==""} { return $Resultat } return [SauveLesLignes $Resultat dans $OutFile] } proc GroupesDpc {aL aT how {NbGr -1}} { upvar $aL NomsGrpDpc upvar $aT LesNomsSeqGrpDpc unset -nocomplain NomsGrpDpc LesNomsSeqGrpDpc if {$how eq "ordali"} { set NmG "dpcordali" set nbc 3 } else { set NmG "dpc" if {$NbGr != -1} { set nbc dpc } else { set nbc $NbGr } } set cm kmeans set LReste [AlignementDesSelections "" SAli] if {! [llength $SAli]} { puts "GroupesZones : Pb creation ali selections" return } if {$LReste != {}} { puts "GroupesZones : [llength [lindex $LReste 1]] seqs virees, pas de seq" } set Lres [Tclcluspack $SAli -dt alignment -cm $cm -nbc $nbc -fd 0.001] ClusterSeqsDeCluspackTcl $Lres LesNomsSeqGrpDpc NomsGrpDpc return $LReste } proc GroupesPhylum {aL aT} { global LaClasseAssocieeAuxSequences LNOrdali LesSequencesAssocieesClassesCanon upvar $aL NomsGrpPhylum upvar $aT LesNomsSeqGrpPhylum set NomsGrpPhylum [list] if {! [info exists LesSequencesAssocieesClassesCanon]} { FaireLire "No phylum information available !" return 0 } set ng 1 set asso [list] foreach c {eukaryota archaea bacteria viruses undefined} { if {$c in [array names LesSequencesAssocieesClassesCanon]} { set Nm "Group$ng" lappend NomsGrpPhylum $Nm lappend asso $Nm $c set LesNomsSeqGrpPhylum($Nm) [set LesSequencesAssocieesClassesCanon($c)] incr ng } } if {$ng == 1} { FaireLire "Life domain information not available !" return 0 } if {$ng == 2} { FaireLire "Beware ! Your alignment contain only [join [array names LesNomsSeqGrpPhylum]]" return 0 } AuLog @begin blob AuLog @title Phylum Clustering : AuLog @text [MacCourant name] foreach {g c} $asso { AuLog @text $g : $c [llength [set LesNomsSeqGrpPhylum($g)]] AuLog @text [set LesNomsSeqGrpPhylum($g)] } AuLog @end ColorieNomsSelonPhylum show return 1 } proc GroupesSecator {aL aT how} { global OrdTmpDir upvar $aL NomsGrpSecator upvar $aT LesNomsSeqGrpSecator unset -nocomplain NomsGrpSecator LesNomsSeqGrpSecator set LReste [AlignementDesSelections "" SAli] if {! [llength $SAli]} { puts "GroupesZones : Pb creation ali selections" return } if {$LReste != {}} { puts "GroupesZones : [llength [lindex $LReste 1]] seqs virees, pas de seq" } set cm hierar if {$how eq "ordali"} { set NmG "secord" set nbc 3 } else { set NmG "secator" set nbc secator } set Lres [Tclcluspack $SAli -dt alignment -cm $cm -nbc $nbc -fd 0.001] ClusterSeqsDeCluspackTcl $Lres LesNomsSeqGrpSecator NomsGrpSecator return $LReste } proc GroupesZones {aL aT quoi {NbGr -1}} { upvar $aL NomsGrp upvar $aT LesNomsSeqGrp global LNOrdali OrdTmpDir ZoneSelect ZoneClusterisation catch {unset NomsGrp} catch {unset LesNomsSeqGrp} set ZoneClusterisation $ZoneSelect set LReste [AlignementDesSelections $ZoneClusterisation SAli] if {! [llength $SAli]} { puts "GroupesZones : Pb creation ali selections" return } if {$LReste != {}} { puts "GroupesZones : [llength [lindex $LReste 1]] seqs virees, pas de seq" } if {$quoi eq "dpc"} { set nbc secator set cm hierar } else { set nbc dpc set cm kmeans } set Lres [Tclcluspack $SAli -dt alignment -cm $cm -nbc $nbc -fd 0.001] ClusterSeqsDeCluspackTcl $Lres LesNomsSeqGrp NomsGrp return $LReste } proc Gs {TypeDeRetour} { # Differents types de retour : # Rien # Text # Frame } proc Gscope {{V ""} {Top ""}} { global RepertoireDuGenome global FichierMiniConfig global FichierMiniConfigSansGenome global GscopeAideSurLesBoutons global VersionDeGscopeAuBigBang VersionDeGscope if { ! [info exists RepertoireDuGenome]} {RepertoireDuGenome} if { ! [info exists CurrentGenome]} {CurrentGenome} if { ! [info exists RepertoireDeTravail]} {RepertoireDeTravail} CommandesExecPossibles if {[info exists GscopeAideSurLesBoutons] && $GscopeAideSurLesBoutons} { bind Button "+TuMontrerasCeQueFaitLeBouton %W" bind Button "+LacheLeBouton %W" } while {! [info exists VersionDeGscopeAuBigBang]} { if {[info exists FichierMiniConfig] && [file exists $FichierMiniConfig]} { ChargeMiniConfig continue } else { Glossaire hsap Court lappend LePrelude "It seems you want to create a new Gscope Project." lappend LePrelude "Gscope can manage different kinds of projects :" lappend LePrelude " - a complete genome, starting with the DNA, creating the proteome" lappend LePrelude " - a collection of proteins, genes, cDNAs, or any type of sequences, etc. " lappend LePrelude "" lappend LePrelude "Gscope can manage proteins, nucleic sequences or BOTH :" lappend LePrelude " Gscope will ask you some questions about that." lappend LePrelude "" lappend LePrelude "Gscope starts reading you original data :" lappend LePrelude " it can be " lappend LePrelude " - a fasta file containing the genome" lappend LePrelude " - a fasta file containing all your sequences" lappend LePrelude " - a file with AccessNumbers" lappend LePrelude " - a file of filenames linking to your sequencess" lappend LePrelude " - a genbank file" lappend LePrelude " - etc." lappend LePrelude "" lappend LePrelude "It's very important to provide all important information concerning your sequences" lappend LePrelude " when you start the project. Gscope integrates easily organism name, genename," lappend LePrelude " gene description, etc., if it is available in your files." lappend LePrelude " For example if your fasta files are as follow" lappend LePrelude ">Genename Organism Definition" lappend LePrelude ">AaEcR-A Aedes aegypti Ecdysone receptor isoforme-A" lappend LePrelude " or your file of filenames" lappend LePrelude "AaEcr-A /home/yourdir/seq/Ecdy.tfa" lappend LePrelude "" lappend LePrelude " Good luck ! (for any question phone to Raymond : 03 88 65 33 05)" set Prelude [join $LePrelude "\n"] FaireLire $Prelude if {[OuiOuNon "Do you have a genomic dna sequence ?"]} { CreeLaBase } elseif {[OuiOuNon "Is it a collection of proteins, genes, dna sequences, mRNAs, etc. ?"]} { CreeLaCollection } else { if {[OuiOuNon "Do I start with \n$FichierMiniConfigSansGenome\n\n[ContenuDuFichier $FichierMiniConfigSansGenome]"]} { set FichierMiniConfig $FichierMiniConfigSansGenome continue } else { if {[OuiOuNon "Do we try later ... ?"]} { exit } } } } } LesOrganismesTresProches if {$V=="NoVitrine"} { return } set Vitrine [Vitrine $V $Top] update idletasks if {0} { catch {Parle "Gscope est chargé. On peut commencer. Mais ! Malédiction ! Ils ont fait un crochet ... ils nous avaient donc repérés." "fr"} } return $Vitrine } proc GscopeBin {} { global GscopeBin return $GscopeBin } proc GscopeBoard {{Titre ""} {PourGif ""}} { global RepertoireDuGenome global ListeDeBoites global ScaleCumuleDeGonfle OrigXCumuleDeGonfle OrigYCumuleDeGonfle global ScrollRectangleOriginal IdScrollRectangle global bVisuPepCurrentGenome bVisuBlastCurrentGenome bVisuMSFCurrentGenome global CouleurDuFond global KanvaCourant global LesKanvasOuverts global Org1 Org2 global LesOrdresPourGif if {$Titre==""} { set Titre "GscopeBoard" } Gs "Canvas" if {$PourGif != ""} { set PourGif 1 set Canvas NeRienFaire set Bind NeRienFaire set Pack NeRienFaire set Fram NeRienFaire set Button NeRienFaire set Scrollbar NeRienFaire set Grid NeRienFaire set FonctionRejetteLaBoite "RejetteLaBoite" set LesOrdresPourGif {} set w "PourGif" set K "OrdrePourGif" } else { set PourGif 0 set Canvas canvas set Bind bind set Pack pack set Fram frame set Button button set Scrollbar scrollbar set Grid grid set FonctionRejetteLaBoite "NeRejettePasLaBoite" set w [NomDe board] catch {destroy $w} toplevel $w wm title $w "$Titre" wm iconname $w "$Titre" set K $w.canvas JeMeSignale "Patience" } if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites } set ScroHor $w.hscroll set ScroVer $w.vscroll set KShSv $w.grid set Boutons $w.buttons set Clavier $w.buttons scan [BoundingBox $ListeDeBoites] "%d %d" xDebut xFin set xDebut [Maxi 0 [expr $xDebut-3000]] incr xFin 1000 set CanvaSizeX [expr $xFin - $xDebut] set CanvaScroMinX [expr $xDebut] set CanvaScroMaxX [expr $xFin ] set CanvaScreenX 1024 set TxtCenX 0 set BoxMinY -20 set BoxMaxY 20 set DeltaY [expr 0.9*($BoxMaxY-$BoxMinY)] set BordHaut [expr 1.5*($BoxMaxY-$BoxMinY)] set EcraseLaFrame(a) 0.8 set EcraseLaFrame(b) 0.8 set EcraseLaFrame(c) 0.8 set EcraseLaFrame(A) 0.8 set EcraseLaFrame(B) 0.8 set EcraseLaFrame(C) 0.8 set EcraseLaFrame(T) 1.0 set EcraseLaFrame(N) 0.7 set EcraseLaFrame(Z) 1.0 set EcraseLaFrame(n) 0.7 set EcraseLaFrame(t) 1.0 set EcraseLaFrame(D) 0.8 set EcraseLaFrame(E) 0.8 set EcraseLaFrame(F) 0.8 set EcraseLaFrame(d) 0.8 set EcraseLaFrame(e) 0.8 set EcraseLaFrame(f) 0.8 set PositionDeLaFrame(a) [expr $BordHaut + 0.0*$DeltaY] set PositionDeLaFrame(b) [expr $BordHaut + 1.0*$DeltaY] set PositionDeLaFrame(c) [expr $BordHaut + 2.0*$DeltaY] set PositionDeLaFrame(A) [expr $BordHaut + 0.5*$DeltaY] set PositionDeLaFrame(B) [expr $BordHaut + 1.5*$DeltaY] set PositionDeLaFrame(C) [expr $BordHaut + 2.5*$DeltaY] set PositionDeLaFrame(T) [expr $BordHaut + 3.0*$DeltaY] set PositionDeLaFrame(N) [expr $BordHaut + 3.2*$DeltaY] set PositionDeLaFrame(Z) [expr $BordHaut + 3.5*$DeltaY] set PositionDeLaFrame(n) [expr $BordHaut + 3.8*$DeltaY] set PositionDeLaFrame(t) [expr $BordHaut + 4.0*$DeltaY] set PositionDeLaFrame(D) [expr $BordHaut + 5.5*$DeltaY] set PositionDeLaFrame(E) [expr $BordHaut + 6.5*$DeltaY] set PositionDeLaFrame(F) [expr $BordHaut + 7.5*$DeltaY] set PositionDeLaFrame(d) [expr $BordHaut + 5.0*$DeltaY] set PositionDeLaFrame(e) [expr $BordHaut + 6.0*$DeltaY] set PositionDeLaFrame(f) [expr $BordHaut + 7.0*$DeltaY] if {[OnTraiteUnGenome]} { set PositionDuSpectre [expr $BordHaut + 9.0*$DeltaY] set PosLineY [expr ($PositionDeLaFrame(a)+$PositionDeLaFrame(f))/2] } else { set PositionDuSpectre [expr $BordHaut + 2.0*$DeltaY] } set TxtCenY 0 set PosSecheLingeMinY 10 set PosSecheLingeMaxY 30 # set yHaut [expr $PositionDeLaFrame(a)-2*$BoxMinY] # set yBas [expr $PositionDeLaFrame(f)+2*$BoxMaxY] # set CanvaSizeY [expr $yBas-$yHaut] # set CanvaScroMinY [expr $yHaut - 0.1*$CanvaSizeY] # set CanvaScroMaxY [expr $yBas + 0.1*$CanvaSizeY] set CanvaScroMinY 0 set CanvaScroMaxY [expr $PositionDuSpectre + 1.2*$DeltaY] set CanvaScreenY [expr $CanvaScroMaxY-$CanvaScroMinY] set CanvaSizeY $CanvaScreenY $Fram $Boutons $Pack $Boutons -side bottom -fill x -pady 2m TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "red" set ToucheDismiss [TouchePour $Clavier "Dismiss" "DetruireLeBoard $w"] $Bind $ToucheDismiss "MainLeveeSurUnCanva $K" TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "lightgrey" TouchePour $Clavier "Zoom" "Gonfle $w all " TouchePour <2> "/UnZoom" "Gonfle $w all degonfle" TouchePour <3> "/Reset" "Gonfle $w all reset reset" if { ! [PourWscope]} { TouchePour $Clavier "Vis PNG" "CanvaEnPNG $K Visible AskForFile" TouchePour <2> "/Postscr" "CanvaEnPostscript $K Visible AskForFile" TouchePour <3> "/print" "CanvaEnImpression $K Visible" TouchePour $Clavier "All PNG" "CanvaEnPNG $K OnVeutTout AskForFile" TouchePour <2> "/Postscr" "CanvaEnPostscript $K OnVeutTout AskForFile" TouchePour <3> "/print" "CanvaEnImpression $K OnVeutTout" } TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "yellow" TouchePour $Clavier "Color ORFs" "RedefinirLaCouleur $K" TouchePour <2> "/Banner" "RedefinirLaCouleurDuLinge $K" TouchePour <3> "/Which" "FaireLire \[SignificationLingeFrameFard $K\]" TouchePour $Clavier "Colors display" "AfficheLesCouleursEtSignifications $K" TouchePour <2> "/to file" "CreeLeFichierAssocieAuxCouleurs $K" TouchePour <3> " /On enter" "RedefinirLeFard $K" if { ! [PourWscope]} { TouchePour $Clavier "Action ORF-Enter" "ShowBoxAction Enter" TouchePour <2> "/Clic" "ShowBoxAction Clic" TouchePour <3> "/Show" "ShowBoxAction Which" } TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "green" TouchePour $Clavier "Search" "RepereBox \[Entre \"Nom: [PreFixe]\"\] $K" TouchePour <2> "/Next" "RepereBox Salut $K NextSansInforme" TouchePour <3> "/Info" "RepereBox Salut $K Next" TouchePour $Clavier "Nuc pos." "RepereNuc \[Entre \] $K" TouchePour <2> " /sequence" "RepereNuc \[ChoixParmi \[LocaliseSurADN\]\]\" $K" TouchePour <3> "/ Bird" "BirdGscopeSearch" TouchePour $Clavier "Chromo" "IllustreLesChromosomes" TouchePour <2> "/Histo" "ChoixHistogramme" TouchePour <3> "/Narcisse" "RepereBox \"Nom: \[Narcisse \[Entre\]\]\" $K" if { ! [PourWscope]} { TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "lightgrey" TouchePour $Clavier "Sel. to file" "Presente \[LesNomsPiques\]" TouchePour <2> "/to disp" "Presente \[LesNomsPiques\]" TouchePour <3> "/Reset" "Deselecte $K" TouchePour $Clavier "Text font" "Scene $K toggle font" TouchePour <2> "/color" "Scene $K toggle fill" TouchePour $Clavier "Toggle text" "ToggleCanva $K TEXTE" TouchePour <2> "/upper line" "ToggleCanva $K Linge" } if { ! [PourWscope]} { TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "lightblue" TouchePour $Clavier "Blast: X zone" "BlastXsurZone $K" TouchePour <2> "/6P zone" "SixBlastPsurZone $K" TouchePour <3> "/6P sel Prot" "SixBlastPsurPiques \[LesNomsPiques\]" TouchePour $Clavier "Create DNA seq" "CreeLaSequenceDeLaZone $K" TouchePour <2> "/Extend DNA" "VoisinADNDeLaZone $K" TouchePour $Clavier "Create Family" "CreeLesFamillesDesSelectionnes" } # $Button $Boutons.liste -text "List\nTFA/Blast/MSF" # -background "green" -foreground "black" # $Bind $Boutons.liste <1> "$bVisuPepCurrentGenome invoke" # $Bind $Boutons.liste <2> "$bVisuBlastpCurrentGenome invoke" # $Bind $Boutons.liste <3> "$bVisuMSFCurrentGenome invoke" # $Pack $Boutons.liste -side left -expand 1 $Fram $KShSv $Scrollbar $ScroHor -orient horiz -command "$K xview" $Scrollbar $ScroVer -command "$K yview" set BetterCanvaScroMaxY $CanvaScroMaxY if {[OnTraiteDesClones]} { set BetterCanvaScroMaxY 3000 } $Canvas $K -relief sunken -borderwidth 2 -width $CanvaScreenX -height $CanvaScreenY -scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $BetterCanvaScroMaxY] -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" $Pack $KShSv -expand yes -fill both -padx 1 -pady 1 $Grid rowconfig $KShSv 0 -weight 1 -minsize 0 $Grid columnconfig $KShSv 0 -weight 1 -minsize 0 $Grid $K -in $KShSv -padx 1 -pady 1 -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky news $Grid $ScroVer -in $KShSv -padx 1 -pady 1 -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky news $Grid $ScroHor -in $KShSv -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky news set CouleurDuFond "cadetblue" $K configure -background $CouleurDuFond set IdScrollRectangle($K) [$K create rectangle $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $BetterCanvaScroMaxY -outline $CouleurDuFond -tag [list "Cadre"]] set ScrollRectangleOriginal($K) "[$K coords [set IdScrollRectangle($K)]]" if {[OnTraiteUnGenome]} { $K create line $CanvaScroMinX $PosLineY $CanvaScroMaxX $PosLineY -fill "black" } set Patientons [$K create text 10 20 -text "Merci de patienter ... " -font {Courier 12} -anchor w] if { ! $PourGif && ! [PourWscope] && [OnTraiteUnGenome]} { AfficheLeSpectreGC $K [expr $PositionDuSpectre - $DeltaY] [expr $PositionDuSpectre + $DeltaY] } #rR set LesBoites [concat [ListeDesGLIMMERs] [ListeDesPABs] [ListeDesTRNAs] [ListeDesARNs] [ListeDesTROUs] [ListeDesFusions]] set LesBoites [concat [ListeDesPABs] [ListeDesTRNAs] [ListeDesARNs] [ListeDesTROUs] [ListeDesFusions]] foreach Boite $LesBoites { if {[$FonctionRejetteLaBoite $Boite]} { continue } set Nom [Box $Boite nom] set Frame [Box $Boite frame] set PosY [set PositionDeLaFrame($Frame)] if {[OnTraiteDesClones]} { set PosY [set PositionDeLaFrame(a)] set DebFinOri "[Box $Boite deb]_[Box $Boite fin]_[Box $Boite ori]" if { ! [info exists DejaPlace($DebFinOri)]} { set DejaPlace($DebFinOri) -1 } set IemePosY [incr DejaPlace($DebFinOri)] set PosY [expr $PosY + $IemePosY*0.9*($BoxMaxY-$BoxMinY)] } set PosMinY [expr $PosY + $BoxMinY*[set EcraseLaFrame($Frame)]] set PosMaxY [expr $PosY + $BoxMaxY*[set EcraseLaFrame($Frame)]] set PosTxtY [expr $PosY + $TxtCenY] set PosMinX [Box $Boite debut] set PosMaxX [Box $Boite fin] set PosTxtX [expr ($PosMinX+$PosMaxX)/2 + $TxtCenX] set Forme "rect" if {[regexp "TROU" $Nom] && ! [PourWscope]} { set Forme "oval" } if {[EstUneFusion $Nom]} { set Forme "oval" } if {[Fantome $Nom]} { set CouleurTrait "white" } else { set CouleurTrait "black" } if {[regexp "GLIMMER" $Nom]} { if {[regexp "^is " [CoGlimmer $Nom]]} { continue } set DecalageY 10 } else { set GlimmerOK [regexp "^is " [CoGlimmer $Nom]] set GlimmerNO [regexp "EstCharge" [CoGlimmer $Nom]] set DecalageY 0 } if {[YaPABenDebutDe $Nom] && $GlimmerNO} { $K create $Forme $PosMinX $PosMinY $PosMaxX [expr $PosMaxY+$DecalageY+10] -fill "lightgrey" -outline "black" -tags [list "Box" "Fantome_$Boite" "FetchMe"] } $K create $Forme $PosMinX $PosMinY $PosMaxX [expr $PosMaxY+$DecalageY] -fill $CouleurDuFond -outline $CouleurTrait -tags [list "Box" "$Boite" "FetchMe"] set TexteOrgAvant "" set TexteOrgApres "" if {0 && [YaPABenDebutDe $Nom] && ! [ExisteOrthologueDans $Org1 $Nom]} { set TexteOrgAvant "+ " } if {0 && [YaPABenDebutDe $Nom] && ! [ExisteOrthologueDans $Org2 $Nom]} { set TexteOrgApres " +" } if {1} { $K create text $PosTxtX $PosTxtY -text "${TexteOrgAvant}[NomDeScene $Boite]${TexteOrgApres}" -fill $CouleurTrait -font {Courier 8} -anchor center -tags [list "TEXTE" "Txt_$Nom" "FetchMe" "DispMe"] } if {[regexp "GLIMMER" $Nom]} { continue } $K create rectangle $PosMinX $PosSecheLingeMinY $PosMaxX $PosSecheLingeMaxY -tags [list "Linge" "Linge$Boite"] } Wup " ............................................et GscopeBoard crea les boites" if { ! $PourGif } { DefinirLaCouleurAuLancement $K } if {[OnTraiteUnGenome] && ! [PourWscope]} { RelieLesOperons $K $PosLineY } $K delete $Patientons if {[PourWscope]} { $K bind "FetchMe" <1> "FetcheBox $K %x %y" } else { $K bind "DispMe" "ShowBox $K %x %y Enter" $K bind "DispMe" "ShowBox $K %x %y Leave" $K bind "Box" "EnterBox $K %x %y" $K bind "Box" "LeaveBox $K %x %y" $K bind "FetchMe" <1> "FetcheBox $K %x %y" $K bind "FetchMe" "FetcheBox $K %x %y MSF" $K bind "FetchMe" "Informe \[NomDuCourant $K\]" $Bind $K <2> "$K scan mark %x %y" if {[OnTraiteDesCDNAs]} { $K bind "Box" <2> "VoirLaMeilleureLocalisationDuCDNA \[NomDuCourant $K\]" } $Bind $K "$K scan dragto %x %y" $K bind "Box" "SautParalogue $K %x %y" $K bind "Box" <3> "PiqueBox $K %x %y Fixe" $Bind $K "ShowNuc $K %x %y Point" $Bind $K "ShowNuc $K %x %y Motion" } if {$PourGif } { return $LesOrdresPourGif } ShowBoxAction EnterDefaults Gonfle $w all 0.1 set KanvaCourant $K lappend LesKanvasOuverts $K JeMeSignale "FinPatience" if {0 && [PourWscope] } { return $w } else { return $K } } proc GscopeCode {CodeClone} { global RepertoireDuGenome set Rep "$RepertoireDuGenome/nuctfa" foreach Fichier [ glob -nocomplain "$Rep/*" ] { set Contenu [ ContenuDuFichier $Fichier] scan $Contenu "%s %s" CodeGscope Clone if {$CodeClone == $Clone} { regsub -all ">" $CodeGscope "" CodeGscope return $CodeGscope } } } proc GscopeCodeAffymetrix {CodeClone} { set Rep "[RepertoireDuGenome]/nuctfa" if {[RepertoireDuGenome]=="[GscopeDatabaseDir Affy]"} { set Rep "[GscopeDatabaseDir AffyTarget]/nuctfa" } foreach Fichier [glob -nocomplain "$Rep/*" ] { set Contenu [ContenuDuFichier $Fichier] scan $Contenu "%s" Nom regsub -all ">" $Nom "" Nom set Code [ExtraitInfo $Nom "CodeClone"] if {$CodeClone == $Code} { return $Nom exit } } } proc GscopeContrib {} { global GscopeContrib if { ! [info exists GscopeContrib]} { return "" } return $GscopeContrib } proc GscopeDatabaseDir {{Dir ""} {Ask ""} {IfExists ""}} { global GscopeDatabaseDir if {$Dir==""} { return [RepertoireDuGenome] } set Queue [file tail $Dir] if {$Queue=="fem"} { return [GscopeDatabaseDir FEM] } foreach Possible [GenomicsPossibles] { set PossibleQueue $Possible/$Queue if {[file exists $PossibleQueue]} { return $PossibleQueue } } if {[string equal -nocase $Ask "Ask"]} { set GDD [ChoixDuRepertoire [Genomics]] if {$GDD!=""} { return $GDD } } if {[string equal -nocase $IfExists "IfExists"]} { return "" } return $Queue return "[GenomicsSubDir $Queue]/$Queue" } proc GscopeDir {} { global GscopeDir return $GscopeDir } proc GscopeEtc {} { global GscopeEtc return $GscopeEtc } proc GscopeEvaluates {LesMotsDeLaCommande {Master ""}} { LogWscope "dans GscopeEvaluates $LesMotsDeLaCommande" if {$Master==""} { set Master "Gscope" } set UseTk 1 if {[lindex $LesMotsDeLaCommande 0]=="-notk"} { set UseTk 0 set LesMotsDeLaCommande [lreplace $LesMotsDeLaCommande 0 0] } if {[lindex $LesMotsDeLaCommande 0]=="data"} { set RG [lindex $LesMotsDeLaCommande 1] RepertoireDuGenome $RG set LesMotsDeLaCommande [lreplace $LesMotsDeLaCommande 0 1] } if {[lindex $LesMotsDeLaCommande 0]=="PourWscope"} { PourWscope 1 set UseTk 0 set LesMotsDeLaCommande [lreplace $LesMotsDeLaCommande 0 0 yes] } if {[regexp -nocase {[a-z]} $LesMotsDeLaCommande]} { set QuoiFaire [lindex $LesMotsDeLaCommande 0] if { ! [regexp "CreeLaCollection|CreeFichierMiniConfig|InitProject" [lrange $LesMotsDeLaCommande 0 1]]} { ChargeConfig } if {$QuoiFaire == "only"} { set Sortie [eval [lrange $LesMotsDeLaCommande 1 end]] return $Sortie } if {$UseTk} { set Commande [join $LesMotsDeLaCommande " "] set PreFixe "" if {[info procs "PreFixe"]!=""} { set PreFixe [PreFixe] } set Process "$Master $PreFixe on [info hostname]\n pid [pid] since [Date Nice]" package require Tk if { ! [winfo exists .] } { wm title . "$PreFixe [string range $Commande 0 20]" button .kill -text "$Process\n\nStop execution of : \n\n$Commande\n\nby pressing Me or killing this window" -background "yellow" -command "exit" pack .kill -fill both } } if {[regexp "^yes" $QuoiFaire]} { InteractiveMode "Off" regsub "^yes" $QuoiFaire "" QuoiFaire if {$QuoiFaire==""} { set QuoiFaire "exe" } if {$QuoiFaire=="con"} { set QuoiFaire "" set LesMotsDeLaCommande [lrange $LesMotsDeLaCommande 1 end] } } set GoAhead 0 if {[regexp -nocase "(and)*continue(and)*" $QuoiFaire]} { regsub -nocase "(and)*continue(and)*" $QuoiFaire "" QuoiFaire set GoAhead 1 } if {$QuoiFaire == "puts" || $QuoiFaire == "putb" || $QuoiFaire == "putl" || $QuoiFaire == "exe"} { set Sortie [eval [lrange $LesMotsDeLaCommande 1 end]] if {$QuoiFaire == "putb" } { fconfigure stdout -translation binary; puts stdout $Sortie ; exit } if {$QuoiFaire == "putl" && $Sortie!=""} { if {[string is list $Sortie]} { set Sortie [join $Sortie "\n"] set QuoiFaire "puts" } } if {$QuoiFaire == "puts" } { puts $Sortie } if {$GoAhead} { return } exit } eval $LesMotsDeLaCommande } return } proc GscopeFile {Nom {SousRep ""}} { #rR Si Nom est vide onrend repertoire avec / a la fin if {$SousRep==""} { if {[OnTraiteDesProteines]} { set SousRep "prottfa" } else { set SousRep "nuctfa" } } return "[GscopeSubDir $SousRep]/$Nom" } proc GscopeFileContent {Nom {SousRep ""} {EnPre ""} {I ""} {J ""}} { #rR on peut lire de la ligne I à J set EnPre [regexp -nocase "Pre" $EnPre] if {$Nom==""} { return "" } set Fichier [GscopeFile $Nom $SousRep] if {[FileAbsent $Fichier]} { return "" } set Contenu [ContenuDuFichier $Fichier] if {[regexp {^[0-9]+$} $I]} { if { ! [regexp {^[0-9]+$} $J]} { set J $I } set Contenu [join [lrange [split $Contenu "\n"] $I $J] "\n"] } if {$EnPre} { return "

$Contenu

" } return $Contenu } proc GscopeID {SpineID} { global GscopeID if {[info exists GscopeID($SpineID)]} { return $GscopeID($SpineID) } if {[info exists GscopeID("EstCharge")]} { return "" } set GscopeID("EstCharge") 1 foreach Nom [ListeDesPABs] { if {[EstUnPABMute $Nom]} {continue} set S [SpineID $Nom] if {$S==""} { continue } set GscopeID($S) $Nom } return [GscopeID $SpineID] } proc GscopeIdsOfGeneName {Gn {WithSynonyms ""}} { global GscopeIdsOfGeneName set WithSynonyms [regexp -nocase "WithSynonym" $WithSynonyms] set GN [string toupper $Gn] if {[info exists GscopeIdsOfGeneName($GN)]} { return $GscopeIdsOfGeneName($GN) } if {[info exists GscopeIdsOfGeneName("EstCharge")]} { return {} } set GscopeIdsOfGeneName("EstCharge") 1 set GscopeIdsOfGeneName(LISTOFGENENAMES) {} foreach Nom [ListeDesPABs] { set ValiGN [ValiGN $Nom] if {$ValiGN==""} {continue} lappend GscopeIdsOfGeneName(LISTOFGENENAMES) $ValiGN lappend GscopeIdsOfGeneName([string toupper $ValiGN]) $Nom set LesAliasGn [AliasGeneNames $Nom] foreach GnLu $LesAliasGn { set GNLU [string toupper $GnLu] lappend GscopeIdsOfGeneName($GNLU) $Nom } lappend GscopeIdsOfGeneName(LISTOFGENENAMES) $GnLu if {$WithSynonyms} { foreach Synonym [SynonymsOfGscopeId $Nom] { set SYNONYM [string toupper $Synonym] lappend GscopeIdsOfGeneName($SYNONYM) $Nom } } } set GscopeIdsOfGeneName(LISTOFGENENAMES) [lsort -unique $GscopeIdsOfGeneName(LISTOFGENENAMES)] return [GscopeIdsOfGeneName $Gn] } proc GscopeIdsOfIdAccArnm {accarnm} { global GscopeIdsOfIdAccArnm if {[info exists GscopeIdsOfIdAccArnm($accarnm)]} { return $GscopeIdsOfIdAccArnm($accarnm) } if {[info exists GscopeIdsOfIdAccArnm("EstCharge")]} { return {} } set GscopeIdsOfIdAccArnm("EstCharge") 1 foreach Nom [ListeDesPABs] { set Acc [AccessEvi $Nom] lappend GscopeIdsOfIdAccArnm($Acc) $Nom } return [GscopeIdsOfIdAccArnm $accarnm] } proc GscopeIdsOfIdAccProt {Iap} { global GscopeIdsOfIdAccProt set IAP [string toupper $Iap] if {[info exists GscopeIdsOfIdAccProt($IAP)]} { return $GscopeIdsOfIdAccProt($IAP) } if {[info exists GscopeIdsOfIdAccProt("EstCharge")]} { return {} } set GscopeIdsOfIdAccProt("EstCharge") 1 foreach Nom [ListeDesPABs] { foreach IapLu [split [ExtraitInfo $Nom "IdAccProt:"] " "] { set IapLu [string trim $IapLu] set IAPLU [string toupper $IapLu] lappend GscopeIdsOfIdAccProt($IAPLU) $Nom lappend GscopeIdsOfIdAccProt(LISTOFIDACCPROTS) $IapLu } } set GscopeIdsOfIdAccProt(LISTOFIDACCPROTS) [lsort -unique $GscopeIdsOfIdAccProt(LISTOFIDACCPROTS)] return [GscopeIdsOfIdAccProt $Iap] } proc GscopeIdsOfProbeSet {Ps} { global GscopeIdsOfProbeSet if {[info exists GscopeIdsOfProbeSet($Ps)]} { return $GscopeIdsOfProbeSet($Ps) } if {[info exists GscopeIdsOfProbeSet("EstCharge")]} { return {} } set GscopeIdsOfProbeSet("EstCharge") 1 foreach Nom [ListeDesPABs] { set LaLigneProbesSet [ExtraitInfo $Nom "ProbeSetId:"] regsub -all "/" $LaLigneProbesSet "-OU-" LaLigneProbesSet set LesProbesSet [split $LaLigneProbesSet ","] foreach PsLu $LesProbesSet { lappend GscopeIdsOfProbeSet($PsLu) $Nom lappend GscopeIdsOfProbeSet(LISTOFProbeSet) $PsLu } } return [GscopeIdsOfProbeSet $Ps] } proc GscopeIsOpen {} { global GscopeIsOpen if {[info exists GscopeIsOpen]} { return $GscopeIsOpen } set GscopeIsOpen [InsideCSTB] return $GscopeIsOpen } proc GscopeLangue {{Langue ""}} { set Langue [string tolower $Langue] global GscopeLangue if {$Langue!=""} { set LesPossibles [list gscope english francais elsassich] if {[lsearch $LesPossibles $Langue]<0} { set Langue "" } set GscopeLangue $Langue } if { ! [info exists GscopeLangue] || $GscopeLangue==""} { set GscopeLangue "english" } return $GscopeLangue } proc GscopeSubDir {SousRep} { return "[RepertoireDuGenome]/$SousRep" } proc GscopeSynonyms {{Qui ""} {Quoi ""}} { global GscopeSynonyms if {$Qui==""} { set Qui "ListOf" } if {$Quoi==""} { set Quoi "Synonyms" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {[info exists GscopeSynonyms($Qui,$Quoi)]} { return $GscopeSynonyms($Qui,$Quoi) } if {[info exists GscopeSynonyms("EstCharge")]} { return "" } set GscopeSynonyms("EstCharge") 1 set GscopeSynonyms(LISTOF,SYNONYMS) {} foreach Nom [ListeDesPABs] { set LesSyn [Synonyms $Nom] foreach Syn $LesSyn { set SYN [string toupper $Syn] lappend GscopeSynonyms(LISTOF,SYNONYMS) $Syn lappend GscopeSynonyms($SYN,GSCOPEIDS) $Nom foreach S $LesSyn { lappend GscopeSynonyms($SYN,SYNONYMS) $S } } } set GscopeSynonyms(LISTOF,SYNONYMS) [lsort -unique $GscopeSynonyms(LISTOF,SYNONYMS)] foreach Syn $GscopeSynonyms(LISTOF,SYNONYMS) { set SYN [string toupper $Syn] set GscopeSynonyms($SYN,SYNONYMS) [ListeSansDoublon $GscopeSynonyms($SYN,SYNONYMS) "" "NoEmpty"] } return [GscopeSynonyms $Qui $Quoi] } proc GuideMoi {{Message ""}} { if {$Message==""} { set Message "Please choose ..." } set Science [file tail [RepertoireDuGenome]] PourWscope 1 set WikiRef "[LbgiUrl]/wikili/index.php/Gscope" if {[Science]=="ProGS"} { set WikiRef "[LbgiUrl]/wikili/index.php/Gscope_Clonage" } set N [llength [ListeDesPABs]] if {[OnTraite MSP]} { lappend LesRefText "[WscopeScience]&OuSontLesMutations" "OuSontLesMutations ?" } lappend LesRefText "[LbgiUrl]/wikili/index.php/Gscope" "Get help from Wiki" lappend LesRefText "[WscopeScience]&RechercheMoi" "Search for a gene, a description, etc..." lappend LesRefText "[WscopeScience]&FileMoi" "List all $N sequences [PreFixe]" lappend LesRefText "[WscopeScience]&FicheMoi" "List information files" lappend LesRefText "[WscopeScience]&SynonymsPourTous&&GetHtml&GscopeSyn" "List all $N sequences Synonyms" lappend LesRefText "[WscopeScience]&SynonymsPourTous&&GetHtml&SynGscope" "List all Synonyms GscopeIds" lappend LesRefText "[WscopeScience]&Environ" "Show environment" lappend LesRefText "[WscopeScience]&Inventaire" "Inventory" LConcat LesRefText [WscopeLinks] if {[PreFixe]=="HNR"} { foreach FiTxt [lsort [glob -nocomplain "[Fiches]/OrganismesPresents-*.txt"]] { regsub "[Fiches]/OrganismesPresents\-" $FiTxt "" Bank regsub ".txt" $Bank "" Bank lappend LesRefText "[WscopeServer]?HNR&GenomiqueComparativeParBlast&$Bank" "Genomique Comparative par $Bank" } } if {[Science]=="RetGene"} { lappend LesRefText "" "" lappend LesRefText "[WscopeScience]&RetGeneMutationOnWeb" "Summary of all mutations" } if {[OnTraiteUCSCGenomes]} { lappend LesRefText "" "" lappend LesRefText "[WscopeScience]&CytoBandUcsc&ListOf&Organisms" "List of available organisms for CytoBandUcsc" lappend LesRefText "[WscopeScience]&CytoBandUcsc&Human&List&Of&CytoBands" "Human CytoBands" lappend LesRefText "[WscopeScience]&CytoBandUcsc&Mouse&List&Of&CytoBands" "Mouse CytoBands" } return [Html_ListOfRefs $LesRefText "

$Message

"] } proc GxAffyGeneArrayHeaders {Qui {Quoi ""}} { global GxAffyHeaders if {[info exists GxAffyHeaders($Qui,$Quoi)]} { return $GxAffyHeaders($Qui,$Quoi) } if {[info exists GxAffyHeaders("EstCharge")]} { return "" } set GxAffyHeaders("EstCharge") 1 set Col -1 foreach Ligne [LesLignesDuFichier "/genomics/link/affyArrayAnnot/GxAffyGeneArrayHeaders.txt"] { scan $Ligne "%s" Gx if {$Gx!="genename" && $Gx!="genedescription" && $Gx!="cytoband" && $Gx!="entrezgene"} {incr Col} if {$Gx=="-"} { continue } set Affy [string trim [StringSuivant "$Gx " dans $Ligne]] lappend GxAffyHeaders($Gx,Col) $Col lappend GxAffyHeaders($Gx,Affy) $Affy set GxAffyHeaders($Affy,Gx) $Gx set GxAffyHeaders($Affy,Col) $Col lappend GxAffyHeaders(ListOf,Col) $Col lappend GxAffyHeaders(ListOf,Gx) $Gx lappend GxAffyHeaders(ListOf,Affy) $Affy } set GxAffyHeaders(ListOf,Gx) [ListeSansDoublon $GxAffyHeaders(ListOf,Gx)] return [GxAffyHeaders $Qui $Quoi] } proc GxAffyHeaders {Qui {Quoi ""}} { global GxAffyHeaders if {[info exists GxAffyHeaders($Qui,$Quoi)]} { return $GxAffyHeaders($Qui,$Quoi) } if {[info exists GxAffyHeaders("EstCharge")]} { return "" } set GxAffyHeaders("EstCharge") 1 set Col -1 foreach Ligne [LesLignesDuFichier "/genomics/link/affyArrayAnnot/GxAffyHeaders.txt"] { scan $Ligne "%s" Gx if {$Gx!="cytoband"} {incr Col} if {$Gx=="-"} { continue } set Affy [string trim [StringSuivant "$Gx " dans $Ligne]] set GxAffyHeaders($Gx,Col) $Col set GxAffyHeaders($Gx,Affy) $Affy set GxAffyHeaders($Affy,Gx) $Gx set GxAffyHeaders($Affy,Col) $Col lappend GxAffyHeaders(ListOf,Col) $Col lappend GxAffyHeaders(ListOf,Gx) $Gx lappend GxAffyHeaders(ListOf,Affy) $Affy } return [GxAffyHeaders $Qui $Quoi] } proc GxAgilentHeaders {Qui {Quoi ""} File} { global GxAgilentHeaders if {[info exists GxAgilentHeaders($Qui,$Quoi,$File)]} { return $GxAgilentHeaders($Qui,$Quoi,$File) } if {[info exists GxAgilentHeaders("EstCharge")]} { return "" } set GxAgilentHeaders("EstCharge") 1 set Col -1 # File"/genomics/link/agilentArrayAnnot/GxAgilentHeaders.txt" foreach Ligne [LesLignesDuFichier $File] { scan $Ligne "%s" Gx if {$Gx!="cytoband"} {incr Col} if {$Gx=="-"} { continue } set Agilent [string trim [StringSuivant "$Gx " dans $Ligne]] lappend GxAgilentHeaders($Gx,Col,$File) $Col lappend GxAgilentHeaders($Gx,Agilent,$File) $Agilent set GxAgilentHeaders($Agilent,Gx,$File) $Gx set GxAgilentHeaders($Agilent,Col,$File) $Col lappend GxAgilentHeaders(ListOf,Col,$File) $Col lappend GxAgilentHeaders(ListOf,Gx,$File) $Gx lappend GxAgilentHeaders(ListOf,Agilent,$File) $Agilent } set GxAgilentHeaders(ListOf,Gx,$File) [ListeSansDoublon $GxAgilentHeaders(ListOf,Gx,$File)] return [GxAgilentHeaders $Qui $Quoi $File] } proc GxData {{Value ""}} { global GxData if {$Value!=""} { set GxData $Value } if { ! [info exists GxData]} { GxData "[GxHome]/GxData" } return $GxData } proc GxDbInput {{Quoi ""} {Qui ""} {AvecWS ""}} { if {[regexp {^0 } $Qui]} { set Qui "" } if {[regexp {[ \n]} $Qui]} { set Qui [split $Qui " \n"] } if {[llength $Quoi]>1} { set LeR {} foreach Q $Quoi { set R [GxDbInput $Q $Qui] lappend LeR $R } return $LeR } if {$AvecWS==""} { set AvecWS "AvecWS" } set AvecWS [string equal -nocase $AvecWS "AvecWS"] set WithWS [WithWebService "Gx" $AvecWS] set LesPossibles [list "SourceProbesetInput" "ArraytypeInput" "ProbesetInput"] if {$Quoi=="GetList"} { return $LesPossibles } if {$Quoi==""} { set Quoi [ChoixParmi $LesPossibles] } if {$Quoi==""} { return "" } if {[lsearch $LesPossibles $Quoi]<0} { return "$Quoi is not yet possible" } set R [$Quoi $Qui] return $R } proc GxDbSqlExec {Query {Quoi ""} {Clear ""}} { #webservice ne marche pas if {0 && [WithWebService "Gx"]} { set GetWhatKey "trululu" set GetWhat "trululu" if {$Quoi!=""} { set GetWhatKey "getwhatfromserial"; set GetWhat $Quoi } set Retour [WebService "Gx" GxDbSqlExec querytext $Query $GetWhatKey $GetWhat] } else { CanalSqlGxDb set Retour [SqlExec $Query $Quoi $Clear] CanalSqlDisconnect } return $Retour } proc GxGenesFromRealExp {RealExp {AnaSoft ""} {Tag ""} {Min ""} {Max ""}} { if {$AnaSoft==""} { set AnaSoft 0 } set GeneNames [WebService "Gx" Execute querytext "PW::GXSignalIntensity&&0&$AnaSoft&$RealExp&&$Tag&$Min&$Max&GeneAsText"] set LesGeneNames {} foreach Ligne [split $GeneNames "\n"] { regsub -all {[ /]+} $Ligne " " Ligne foreach G [split [string trim $Ligne] " "] { lappend LesGeneNames $G } } set LesGeneNames [lsort -unique $LesGeneNames] return $LesGeneNames } proc GxHome {{Value ""}} { global GxHome if {$Value!=""} { set GxHome $Value } if { ! [info exists GxHome]} { GxHome "[HomeRipp]/GxHome" } return $GxHome } proc GxIlluminaHeaders {Qui {Quoi ""}} { global GxIlluminaHeaders if {[info exists GxIlluminaHeaders($Qui,$Quoi)]} { return $GxIlluminaHeaders($Qui,$Quoi) } if {[info exists GxIlluminaHeaders("EstCharge")]} { return "" } set GxIlluminaHeaders("EstCharge") 1 set Col -1 foreach Ligne [LesLignesDuFichier "/genomics/link/illuminaArrayAnnot/GxIlluminaHeaders.txt"] { scan $Ligne "%s" Gx incr Col if {$Gx=="-"} { continue } set Illumina [string trim [StringSuivant "$Gx " dans $Ligne]] lappend GxIlluminaHeaders($Gx,Col) $Col lappend GxIlluminaHeaders($Gx,Illumina) $Illumina set GxIlluminaHeaders($Illumina,Gx) $Gx set GxIlluminaHeaders($Illumina,Col) $Col lappend GxIlluminaHeaders(ListOf,Col) $Col lappend GxIlluminaHeaders(ListOf,Gx) $Gx lappend GxIlluminaHeaders(ListOf,Illumina) $Illumina } set GxIlluminaHeaders(ListOf,Gx) [ListeSansDoublon $GxIlluminaHeaders(ListOf,Gx)] return [GxIlluminaHeaders $Qui $Quoi] } proc HGNC {{Qui ""} {Quoi ""}} { global HGNC if {[string equal -nocase $Quoi "GeneName"]} { set Quoi "Approved_Symbol" } if {$Qui==""} { set Qui "ListOf" } if {$Quoi=="" && [string equal -nocase $Qui "ListOf"]} { set Quoi "Header" } if {$Quoi==""} { set Quoi "AllTxt" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} { set LeTout [HGNC $Qui All] if {$LeTout==""} { return "" } foreach T [HGNC ListOf Header] V $LeTout { lappend LeRetour [format "%45s : %s" $T $V] } if {$Quoi=="ALLLIST"} { return $LeRetour } set Retour [join $LeRetour "\n"] if {$Quoi=="ALLHTML" || [PourWscope]} { return "

\n$Retour\n

" } if {$Quoi=="ALLTXT"} { return $Retour } return $Retour } if {[info exists HGNC($Qui,$Quoi)]} { return $HGNC($Qui,$Quoi) } if {[info exists HGNC("EstCharge")]} { if {[info exists HGNC($Qui,REFERENCES)]} { set FirstRef [lindex $HGNC($Qui,REFERENCES) 0] return [HGNC $FirstRef $Quoi] } return "" } set HGNC("EstCharge") 1 set FichierHGNC "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/HGNC.txt" set Q [file tail $FichierHGNC] regsub -nocase {\.[^\.]+$} $Q "" Q LoadTxl $FichierHGNC Txl -1 "\t" set HGNC(FILE,NAME) $FichierHGNC set HGNC(FILE,QUEUE) $Q set HGNC(LISTOF,HEADER) $Txl(ListHeaderPlease,$Q) lappend HGNC(LISTOF,HEADER) "Source_of_information" lappend HGNC(LISTOF,HEADER) "HttpReference" set HGNC(LISTOF,INDEX) $Txl(ListAllPlease,$Q) foreach I $Txl(ListAllPlease,$Q) { set HGNCID "$Txl($I,HGNC_ID)" if { ! [regexp {^HGNC\:} $HGNCID]} { set HGNCID "HGNC:$HGNCID" } set Txl($I,HGNC_ID) $HGNCID set AS $Txl($I,Approved_Symbol) if {[info exists Txl($I,Aliases)]} { set Aliases $Txl($I,Aliases) } if {[info exists Txl($I,Synonyms)]} { set Aliases $Txl($I,Synonyms) } lappend HGNC(LISTOF,SYNOTXT) $Aliases set Previous $Txl($I,Previous_Symbols) set HGNC($AS,HGNC_ID) $I if {[info exists DejaVu($AS)]} { FaireLire "I saw already $AS $I $DejaVu($AS)" } set DejaVu($AS) $I lappend HGNC(LISTOF,APPROVED_SYMBOL) $AS set LesAlias [split $Aliases ","] set LesPrevious [split $Previous ","] set LesAliasEtPrevious [lsort -unique [concat $LesAlias $LesPrevious]] set HGNC($HGNCID,SYNONYMS) {} foreach Alias $LesAliasEtPrevious { regsub -all " " $Alias "" Alias lappend HGNC($HGNCID,LISTOFSYNONYM) $Alias lappend HGNC($AS,LISTOFSYNONYM) $Alias set ALIAS [string toupper $Alias] lappend HGNC($ALIAS,REFERENCES) $HGNCID lappend HGNC(LISTOF,ALIAS) $Alias } set LeTout {} foreach T $Txl(ListHeaderPlease,$Q) { lappend LeTout $Txl($I,$T) set HGNC($HGNCID,[string toupper $T]) $Txl($I,$T) set HGNC($AS,[string toupper $T]) $Txl($I,$T) } set HGNC($HGNCID,SOURCE_OF_INFORMATION) "Created by Gscope with download from http://www.genenames.org" lappend LeTout $HGNC($HGNCID,SOURCE_OF_INFORMATION) regsub -all {[^0-9]} $HGNCID "" HGNCIDnu set Ref "http://www.genenames.org/data/hgnc_data.php?hgnc_id=$HGNCIDnu" set TexteRef $Ref if {[PourWscope]} { set TexteRef "$Ref" } set HGNC($HGNCID,HTTPREFERENCE) $TexteRef lappend LeTout $HGNC($HGNCID,HTTPREFERENCE) set HGNC($HGNCID,ALL) $LeTout set HGNC($AS,ALL) $LeTout lappend HGNC(LISTOF,HGNC_ID) $HGNCID } set HGNC(LISTOF,SYNOTXT) [lsort -unique $HGNC(LISTOF,SYNOTXT)] set HGNC(LISTOF,ALIAS) [lsort -unique $HGNC(LISTOF,ALIAS)] set HGNC(LISTOF,SYNONYM) $HGNC(LISTOF,ALIAS) return [HGNC $Qui $Quoi] } proc HIDDEN_MiseAJourHtml {{W ""} {Action Append}} { #rR ne sert certainement a rien ..... a supprimer global MiseAJourHtml if {$W==""} { if {[info exists MiseAJourHtml]} { return $MiseAJourHtml } else { return {} } } if {$Action=="Append"} { return [lappend MiseAJourHtml $W] } if {$Action=="Reset"} { set Old [MiseAJourHtml] set MiseAJourHtml {} return $Old } } proc HMMVerif {} { # Vérifie si les séquences d'origine se retrouvent dans une sortie blast-like de HMM set FichierDesHMM [open "/genomics/link/UCSCAlignements/g11/STAF/fiches/HMM/19vs19fs" "r"] set FichierDesTrain [open "/genomics/link/UCSCAlignements/g11/STAF/fiches/HMM/ProfileUnfoundTotal.seq" "r"] set FichierDesOrphelins "[Fiches]/HMM/Profile-HMM-unfound.fa" set FichierDesTrouves "[Fiches]/HMM/Profile-HMM-found.fa" if { [file exists $FichierDesOrphelins] } { file delete $FichierDesOrphelins } if { [file exists $FichierDesTrouves] } { file delete $FichierDesTrouves } set Trouves 0 set Total 0 set NonTrouves 0 set Log "" while { [gets $FichierDesHMM LigneHMM] >=0 } { set Log [concat $Log $LigneHMM] } while { [gets $FichierDesTrain Ligne] >=0 } { ScanLaListe $Ligne Sequence incr Total 1 if {[regexp $Sequence $Log]} { incr Trouves 1 AppendAuFichier $FichierDesTrouves ">Staf$Trouves" AppendAuFichier $FichierDesTrouves "$Sequence" } else { incr NonTrouves 1 AppendAuFichier $FichierDesOrphelins ">Staf$NonTrouves" AppendAuFichier $FichierDesOrphelins "$Sequence" } } Espionne "Trouvés : $Trouves/$Total" } proc HTGDeLaSequenceTFA {FichierBlastnHTGReduced FichierTFA Organism} { ##################### Selection du HTG qui "centre" au mieux la sequence query ##################### ###########Ask Blast ############ if {[AskBlast $FichierBlastnHTGReduced NbSubject] == ""} { set NbSubject 0 set TailleQuery [TailleDeLaSequenceDuFichierTFA $FichierTFA] } else { set NbSubject [AskBlast $FichierBlastnHTGReduced NbSubject] set TailleQuery [AskBlast $FichierBlastnHTGReduced Taille ] } if {[AskBlast $FichierBlastnHTGReduced NbSubject]} { for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlastnHTGReduced Subject $i ] set TailleS [AskBlast $FichierBlastnHTGReduced BanqueId $BId Taille ] set NbSegment [AskBlast $FichierBlastnHTGReduced BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment $j DQ] set FQ [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment $j FQ] set DS [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment $j DS] set FS [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment $j FS] } } } ### Longueur des segments du HTG prolongeant la sequence query pour chaque subject ### ### Selection du HTG ayant le plus grand plus petit prolongement ### set LesBId [LesBanqueIdDuBlast $FichierBlastnHTGReduced] set LesPetitProlongements {} foreach BId $LesBId { Espionne $BId set TailleSubject [AskBlast $FichierBlastnHTGReduced BanqueId $BId Taille ] set NbSegment [AskBlast $FichierBlastnHTGReduced BanqueId $BId NbSegment ] set DSPremierSegment [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment 1 DS] set FSDernierSegment [AskBlast $FichierBlastnHTGReduced BanqueId $BId Segment $NbSegment FS] set TaillePremierProlongement [expr $DSPremierSegment -1 ] #Espionne $TaillePremierProlongement set TailleSecondProlongement [expr $TailleSubject - $FSDernierSegment] #Espionne $TailleSecondProlongement set PetitProlongement [MiniDeLaListe [list $TaillePremierProlongement $TailleSecondProlongement]] Espionne $PetitProlongement set TabPetitProlongement($BId,PetitProlongement) $PetitProlongement set TabPetitProlongement(PetitProlongement,$PetitProlongement,BId) $BId lappend LesPetitProlongements $PetitProlongement } Espionne $LesPetitProlongements set MeilleurPetitProlongement [MaxiDeLaListe $LesPetitProlongements] Espionne "MeilleurPetitProlongement : $MeilleurPetitProlongement" set MeilleurHTG [set TabPetitProlongement(PetitProlongement,$MeilleurPetitProlongement,BId)] Espionne "Meilleur HTG : $MeilleurHTG" AskBlast "unset" return $MeilleurHTG } proc HTMLBoard {} { foreach Ordre [GscopeBoard TitreBidon "PourGIF"] { Espionne [join [DecoupeEnSousOrdresPourGif $Ordre] "\n"] } exit } proc H_AskAndGetFile {} { } proc H_BR {} { return "
" } proc H_BalAtt {Texte Balise {LesAttVal ""}} { set BalAtt "<$Balise" foreach {Attribut Valeur} $LesAttVal { if {$Attribut eq "ValueOnly"} { append BalAtt " $Valeur" } else { append BalAtt " $Attribut=\"$Valeur\"" } } append BalAtt ">" append BalAtt $Texte append BalAtt "" return $BalAtt } proc H_Balise {Texte Balise} { set B "<$Balise>\n$Texte\n" } proc H_Balises {Texte LesBalises} { if {$LesBalises=={}} { return $Texte } set Bal [lindex $LesBalises 0] return "<$Bal>\n[H_Balises $Texte [lrange $LesBalises 1 end]]\n" } proc H_Bold {Texte} { return [H_Balise $Texte "b"] } proc H_Center {Texte} { return [H_Balise $Texte "center"] } proc H_ChoixParmi {Liste Name {AvecReset ""} {AvecSubmit ""}} { if {[regexp -nocase "AvecReset" $AvecReset] } { set AvecReset 1 } else { set AvecReset 0 } if {[regexp -nocase "AvecSubmit" $AvecSubmit]} { set AvecSubmit 1 } else { set AvecSubmit 0 } set LeTexteCP {} lappend LeTexteCP [H_Open [H_BalAtt [H_Pivot] SELECT "NAME $Name"]] lappend LeTexteCP [H_BalAtt ". . . . . . ." OPTION] foreach Ligne $Liste { lappend LeTexteCP [H_BalAtt $Ligne OPTION] } lappend LeTexteCP [H_Close] if {$AvecReset} { lappend LeTexteCP [H_BalAtt "" INPUT "VALUE Reset TYPE reset"] } if {$AvecSubmit} { lappend LeTexteCP [H_BalAtt "" INPUT "VALUE Submit TYPE submit"] } return [join $LeTexteCP "\n"] } proc H_Close {} { global H_OpenClose Wup "H_Open and H_Close allows to encapsulate a text. See Test_H_Open_Close" set Close [lindex $H_OpenClose end] set H_OpenClose [lrange $H_OpenClose 0 end-1] return $Close } proc H_Color {Texte {Couleur ""}} { if {$Couleur==""} { set Couleur "red" } set Hexa [ColorHexa $Couleur] set Color [H_BalAtt $Texte "font" [list "color" "$Hexa"]] return $Color } proc H_ColoredLetters {LesLettres LesCouleurs} { set TexteColore "" foreach Lettre $LesLettres Couleur $LesCouleurs { append TexteColore "$Lettre" } return $TexteColore } proc H_Face {Texte {Fonte ""}} { return [H_Font $Texte $Fonte] } proc H_Font {Texte {Fonte ""}} { if {$Fonte==""} { set Fonte "Courier New,Courier" } set Font [H_BalAtt $Texte "font" [list "face" "$Fonte"]] return $Font } proc H_Href {Texte Url {AutresAttributs ""}} { if {[string trim $Texte]==""} { return " "; } if {$Url==""} { set HrefUrl "href=\"#\"" } else { set HrefUrl "href=\"$Url\"" } set Href "$Texte" return $Href } proc H_HrefGetz {Texte Access Banque {AccOuId Acc}} { while {[regexp " " $Banque]} {regsub -all " " $Banque " " Banque} regsub -all " " $Banque "_SP_" Banque set URL "http://bips.u-strasbg.fr/srsbin/cgi-bin/wgetz?-newId+-e+\[{$Banque}-$AccOuId:'$Access'\]" return [H_Href $Texte $URL] } proc H_Italic {Texte} { return [H_Balise $Texte "i"] } proc H_JavascriptPourWaliLite {} { set LeJs {} lappend LeJs "" set Js [join $LeJs "\n"] return $Js } proc H_LogoBInG {} { return [H_Center [H_Href "" "[LbgiUrl]/~ripp/logoBInG.html"]] } proc H_MorceauxChoisis {Liste NomGeneric {AvecReset ""} {AvecSubmit ""} {MaxCandidats ""}} { if {[regexp -nocase "AvecReset" $AvecReset] } { set AvecReset 1 } else { set AvecReset 0 } if {[regexp -nocase "AvecSubmit" $AvecSubmit]} { set AvecSubmit 1 } else { set AvecSubmit 0 } if {$MaxCandidats==""} { set MaxCandidats 9 } set LeTexteHMC {} for {set C 1} {$C<$MaxCandidats} {incr C} { set Name [format "%s%3.3d" $NomGeneric $C] lappend LeTexteHMC [H_ChoixParmi $Liste $Name] lappend LeTexteHMC [H_BR] } if {$AvecReset} { lappend LeTexteHMC [H_BalAtt "" INPUT "VALUE Reset TYPE reset"] } if {$AvecSubmit} { lappend LeTexteHMC [H_BalAtt "" INPUT "VALUE Submit TYPE submit"] } return [join $LeTexteHMC "\n"] } proc H_Open {Texte} { global H_OpenClose Wup "H_Open and H_Close allows to encapsulate a text. See Test_H_Open_Close" set Pivot [H_Pivot] set i [string first [H_Pivot] $Texte] set Open [string range $Texte 0 [expr $i-1]] set Close [string range $Texte [expr $i+[string length $Pivot]] end] lappend H_OpenClose $Close return $Open } proc H_Pivot {} { return "JeSuIsLePiVoT" } proc H_Redirect {Url {Texte ""}} { if {$Texte==""} { set Texte "Please visit $Url" } return [H_Href $Texte $Url] } proc H_StyleClassePourBalise {Balise LesClassesValeurs {WithElement ""}} { if {[regexp {WithElement_(.+)} $WithElement Match Element]} { set WithElement 1 } else { set WithElement 0 } lappend Local "" return [join $Local "\n"] } proc H_StyleDesCouleursColSco {} { lappend LesClassesValeurs "cs0" "color:black ; background:lightgrey;" lappend LesClassesValeurs "cs1" "color:white ; background:black;" return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"] } proc H_StyleDesCouleursFtype {} { foreach Couleur [CouleurSeqlab "LaListeMerci"] { set N [CouleurSeqlab $Couleur] if {$N<0} { set N 999 } set Classe "C$N" set Fg "Magenta" set FgBg [LesCouleursSeqlabDesAAs "fg_and_bg_of_bg_$Couleur"] scan $FgBg "%s" Fg lappend LesClassesValeurs $Classe "color:$Fg ; background:$Couleur;" } return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"] } proc H_StyleDesCouleursSeqlab {} { foreach {A F B} [LesCouleursSeqlabDesAAs LaListeMerci] { lappend LesClassesValeurs $A "color:$F ; background:$B;" } return [H_StyleClassePourBalise "span" $LesClassesValeurs "WithElement_a"] } proc H_StyleImageTransdot {} { lappend LesClassesValeurs "transdot" "background-image: url(http://www-bio3d-igbmc.u-strasbg.fr/transdot.gif)" return [H_StyleClassePourBalise "img" $LesClassesValeurs] } proc H_StyleSpanPadding {} { lappend LesClassesValeurs "" "padding-top:3px; padding-bottom:3px" return [H_StyleClassePourBalise "span" $LesClassesValeurs] } proc H_TexteArea {{Texte ""} Name {Rows 5} {Cols 80}} { return [H_BalAtt $Texte TEXTAREA "name $Name rows $Rows cols $Cols"] } proc HandleZoom {n win} { global pgl if {$pgl(Zoom) > 1.} { set pgl(Zoom) [expr {$pgl(Zoom) + $n/$pgl(Zoom)}] } else { set pgl(Zoom) [expr {$pgl(Zoom) + $n*$pgl(Zoom)}] } if {$pgl(Zoom) < 0.0001} {set pgl(Zoom) 0.0001} Update3DMatrices $pgl(wogl) postredisplay return } proc HasBranches {Tree} { return [DataSet hasBranches $Tree] } proc HashExiste {l {aT ""}} { foreach v $l { set HExst($v) 1 } return [array get HExst] } proc HauteurDe {w} { global Memo return [set Memo(HauteurDe$w)] } proc HeaderFileAffy {Qui} { #exemple de Qui "/genomics/link/affyArrayAnnot/AffyAnno20080708/Mouse430_2.na26.annot.csv" foreach Ligne [LesLignesDuFichier $Qui] { if {[regexp "^#%" $Ligne]} { lappend LesLignes $Ligne } } return $LesLignes } proc HeightMode {AId val} { global Abr set Abr($AId,OffsetY) [expr {[set Abr($AId,OffsetY)] + $val}] if {$val > 0} {set quoi hplus} {set quoi hmoins} ChangeCurseur $AId $quoi OnReDessineArbre $AId set PAD [set Abr($AId,PAD)] bind $PAD [list HeightMode $AId $val] bind $PAD {} return } proc HeightOfTree {Tree} { if {[IsLeaf $Tree]} { return 1 } set Highest 0 foreach B [Branches $Tree] { set H [HeightOfTree $B] if {$H>$Highest} { set Highest $H } } return [incr Highest] } proc HelpIDMapping {{args ""}} { global TIDMap InitIDMapping puts "\nIDMapping :" puts "-----------" puts "\nIDMapping is a tool that convert a list of IDs from/to a database from/to UniProt database. Below is the list of available databases, with their abbreviation :" set lgtName [PlusLongEltDe $TIDMap(Ldbs)] foreach key [array names TIDMap "*,ID"] { lappend LID $TIDMap($key) } set lgtID [PlusLongEltDe $LID] set fmt "%-${lgtName}s %-${lgtID}s %4s" foreach cat $TIDMap(Lcat) { puts "\nCategory : $cat" foreach db $TIDMap($cat) { puts [format $fmt $db $TIDMap($db,ID) $TIDMap($db,sens)] } } puts "" puts "Usage :" puts "IDMapping " puts "\nNote : As this tool converts FROM/TO UniProt database, \t- FROM should be one of ACC+ID, ACC, ID OR \t- TO should be one of ACC or ID " exit } proc HelpSampleTOL {} { puts "\nUsage :" puts "" puts "Arguments are in the form . The following keys are available :" puts "" puts " -ntaxa : number of taxo to choose. Default 100" puts " -root : id/name of the root from which the selection should be done. Default 'cellular organism'" puts " -weighted : the number of taxa to be taken in each branch depends of the weight of this branch. Default 1" puts " -addmodel : Add model organisms to the ntaxa selected. Default 0" puts " -modelsin : The Model Organisms should be included inside the n taxa to be selected. Default 0" puts "\nNote: -addmodel and -modelsin can't be set simultaneously." puts "" puts "Model Organisms :" puts "-----------------" foreach {t n} [$::db eval {select taxid,Name from gold where Model=1}] { puts [format "%6d | %s" $t $n] } puts "" return } proc HeureDansRosace {R X {Y ""} {CentreX ""} {CentreY ""}} { set PI 3.14159 return [Entre0Et2PI [expr $PI/2+[AngleDansRosace $R $X $Y $CentreX $CentreY] ]] } proc HeureDePosADN {PosADN {Orga ""}} { Wup "Returns the clock-wize angle in radian starting at 12:00" set PI 3.14159 if {$Orga==""} { return [expr $PosADN*2*$PI/[LongueurADN]] } return [expr $PosADN*2*$PI/[LongueurADN $Orga]] } proc Hexa2Deci {Hexa {base 32}} { # Ramene valeur hexadecimale a la base donnee # 32 bits -> val entre 0 et 255 # 64 bits -> val entre 0 et 65536 # Surtout utilise pour les couleurs set div [expr {$base/4}] if {! [regexp {^0x} $Hexa]} {set Hexa "0x$Hexa"} return [expr {1.*$Hexa/((2**$div)-1)}] } proc HexaToAscii {Hex} { regsub "^%" $Hex "" Hex regsub -nocase "^ox" $Hex "" Hex set Ascii [format "%c" 0x$Hex] return $Ascii } proc HideGridedFrame {Frame} { Wup "Permet d oublier une frame griddee et de s en rappeller le moment venu" global PosFramePerdue if {[info exists PosFramePerdue] && [info exists PosFramePerdue($Frame)]} { grid $Frame unset PosFramePerdue($Frame) return "" } set PosFramePerdue($Frame) 1 grid remove $Frame return "" } proc HighlightChar {t index} { global Vrp set tg "show_$index" if {$Vrp(oldTag1) ne "" } { $t tag configure $Vrp(oldTag1) -background $Vrp(oldChar) } if {$Vrp(oldTag2) ne "" } { $t tag configure $Vrp(oldTag2) -background [$t cget -background] } $t tag add $tg 1.$index $t tag configure $tg -background $Vrp(showChar) set Vrp(oldTag2) $Vrp(oldTag1) set Vrp(oldTag1) $tg return } proc HighlightClade {Fenetre Action} { set Clade "" if {$Action=="Current"} { set Clade [CladeCourant] } if {$Action=="New"} { set Clade [CladeCourant "New"] } if {$Action=="See"} { return [CladeCourant "See"] } set Clade [Tax $Clade "TaxId"] set LesIllumines {} set Max -10 foreach Ligne [split [PagePropre $Fenetre] "\n"] { if {[incr Max -1]==0} { break } set TaxId "" scan $Ligne "%s %s %d" E S TaxId if { ! [JeSuisTonAncetre $Clade $TaxId]} { continue } lappend LesIllumines " $TaxId " } if {$LesIllumines=={}} { return {} } return [IllumineLaListe $LesIllumines $Fenetre ] } proc HistoDelta {{Clade ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} { if {$Clade==""} { set Clade [SelectClade] } set EnTest [regexp {^(ripp|scherb)$} [Login]] # set EnTest 0 if {$UseExpect==""} { set UseExpect "UseScore" } set UseExp [string equal -nocase "UseExpect" $UseExpect] if {$GetWhat==""} { set GetWhat "Show" } if {$Seuil==""} { set Seuil 99999 } if {$Clade==""} { set Clade [ReferenceClade] } regsub -all " " $Clade "_" CladeUnderscore set Echantillonage 100 if {[OnTraite CiloCarta Like]} { set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"] } elseif {[OnTraite OI2017 Like]} { set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"] } else { FaireLire "Désolé. Il faut êrte CiloCarta LIke ou OI2017 Like" } if {[set i [lsearch $LesTaxIdsInteressants 9606]]>=0} { set LesTaxIdsInteressants [lreplace $LesTaxIdsInteressants $i $i] } set NbTaxId [llength $LesTaxIdsInteressants] foreach TaxId $LesTaxIdsInteressants { set SommeDesDeltasPour($TaxId) 0.0 set NbDeltasPour($TaxId) 0 } set LesMeilleurs {} set NbNom 0 foreach Nom [ListeDesPABs] { if {0 && $EnTest && $Nom > "HSAP20193"} { break } set LesHitsAvecDelta [LesHitsAvecDelta $Nom $LesTaxIdsInteressants $Seuil "GetList" $SelectMethod $UseExpect] if {1 && $NbNom%1000==0} { Espionne $Nom ; EspionneL $LesHitsAvecDelta } if {$LesHitsAvecDelta=={}} { continue } incr NbNom foreach HitAvecDelta $LesHitsAvecDelta { lassign $HitAvecDelta Delta Expect Score TaxId OS Reste regsub -all "\t" $OS " " OS MemOlym $Nom-$TaxId Delta $Delta MemOlym $Nom-$TaxId Info $HitAvecDelta set SommeDesDeltasPour($TaxId) [expr $SommeDesDeltasPour($TaxId)+$Delta] ;#rR attention ici on additionne des carottes et des navets !!!!!!!! car Nom différents set InfoDu($TaxId) "$OS\t$Reste" incr NbDeltasPour($TaxId) lappend LesDeltasDe($TaxId) $Delta lappend LesNomsDe($TaxId,$Delta) $Nom MemOlym $TaxId-$Delta ListOfNom $Nom MemoDelta $TaxId $Delta $Nom set BeauDelta [format "%6.0f" $Delta] if {$Delta!=$BeauDelta} { MemOlym $TaxId-$BeauDelta ListOfNom $Nom ; MemoDelta $TaxId $Delta $Nom} } } foreach TaxId $LesTaxIdsInteressants { if {$NbDeltasPour($TaxId)==0} { set Moyenne -999 } else { set Moyenne [expr $SommeDesDeltasPour($TaxId)/$NbDeltasPour($TaxId)] } set MoyenneDesDeltasPour($TaxId) $Moyenne lappend LesMoyennesDesDeltas $Moyenne lappend LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) $TaxId } if {$UseExp} { set LesMoyennesDesDeltas [lsort -unique -real $LesMoyennesDesDeltas] } else { set LesMoyennesDesDeltas [lsort -decreasing -unique -real $LesMoyennesDesDeltas] } set LaSortie [list "# TailleP NombreDeDelta Moyenne TaxId Nom_de_l'espece "] foreach Moyenne $LesMoyennesDesDeltas { foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) { set BelleMoyenne [format "%6.0f" $Moyenne] if { ! [info exists InfoDu($TaxId)]} { continue } lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPour($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)\t$Moyenne" } } EspionneL $LaSortie set AvecHisto 0 if {$AvecHisto} { set LargeurMax 4000 set HauteurMax 5000 set Largeur 3000 set Hauteur 2000 set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur] global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400] } set MinAllDelta 9999999 set MaxAllDelta -9999999 set IemeTaxId -1 foreach TaxId $LesTaxIdsInteressants { if { ! [info exists LesDeltasDe($TaxId)]} { continue } set OS [Tax $TaxId Name] regsub -all " " $OS "_" OSUnderscore incr IemeTaxId set MinAllDelta 9999999 set MaxAllDelta -9999999 foreach Delta $LesDeltasDe($TaxId) { set MinAllDelta [Mini $Delta $MinAllDelta] set MaxAllDelta [Maxi $Delta $MaxAllDelta] } } set IntAllDelta [expr ($MaxAllDelta - $MinAllDelta)/$Echantillonage] set IemeTaxId -1 foreach TaxId $LesTaxIdsInteressants { if { ! [info exists LesDeltasDe($TaxId)]} { continue } set OS [Tax $TaxId Name] regsub -all " " $OS "_" OSUnderscore incr IemeTaxId if {[info exists Cumul]} { unset Cumul } set MinDelta 9999999 set MaxDelta -9999999 foreach Delta $LesDeltasDe($TaxId) { set MinDelta [Mini $Delta $MinDelta] set MaxDelta [Maxi $Delta $MaxDelta] } set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage] set MinDeltaDe($TaxId) $MinDelta set MaxDeltaDe($TaxId) $MaxDelta set IntervalDeltaDe($TaxId) $IntDelta set MinCase 9999 set MaxCase -9999 foreach Delta $LesDeltasDe($TaxId) { if {$IntDelta<0.0000001} { set Case 0 } else { #set Case [expr round(($Delta - $MinDelta)/$IntDelta)] set Case [expr round(($Delta - $MinAllDelta)/$IntAllDelta)] } set MinCase [Mini $MinCase $Case] set MaxCase [Maxi $MaxCase $Case] if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 } incr Cumul($Case) set Tag($Case) $Delta foreach Nom [MemoDelta $TaxId $Delta] { set BeauDelta [format "%6.0f" $Delta] set BelleMoyenne [format "%6.0f" $Moyenne] MemoInfo $TaxId $Case "$Nom [string trim $BeauDelta] $BelleMoyenne" } } set LesX {} set LesY {} set LesTags {} set LaDistrib [list "#Delta Nb Case TaxId OS Reference_Clade"] set LesBornesDeCases [NombresEntre $MinCase $MaxCase] if { ! $UseExp} { set LesBornesDeCases [lreverse $LesBornesDeCases] } foreach Case $LesBornesDeCases { if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 } if {$Cumul($Case)==0} { continue } if { ! [info exists Tag($Case)]} { set Tag($Case) "0.0" } if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" } set X [expr $MinAllDelta + $Case*$IntAllDelta] lappend LesX $X lappend LesY $Cumul($Case) lappend LesTags "[format %6.0f $X]:$Cumul($Case) $OS" lappend LaDistrib "[format %6.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore" } MemoCase $TaxId LaDistrib $LaDistrib if {$AvecHisto} { set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]] Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax } else { # set F [AfficheListe $LaDistrib "AvecCase" $OS] # set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"] # $B configure -background "Magenta" } } if {$GetWhat=="Show"} { set F [AfficheListe $LaSortie "" "Delta distribution for $Clade $Seuil $SelectMethod $UseExpect"] set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"] $B configure -background "Magenta" } return $LaSortie } proc HistoDesSpineTasks {{SpineOnly ""} {Action ""}} { if {$Action==""} { set Action "Show" } if {$SpineOnly==""} { set SpineOnly "AllToGether" } set SpineOnly [regexp -nocase "SpineOnly" $SpineOnly] set Page [SpineSummary "RetourneTexte"] foreach Ligne [split $Page "\n"] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or # if {[EstUnPABMute $X]} { continue } if { $SpineOnly && ! $SpOk } { continue } if {$SpTsk=="?"} { set SpTsk "Sele" } if { ! [info exists H($SpTsk)]} { set H($SpTsk) 0 } incr H($SpTsk) } set Cumul 0 foreach {NiceSpTsk R SpTsk} [LaListeDesTasks "Reverse"] { if { ! [info exists H($SpTsk)]} { continue } incr Cumul [set H($SpTsk)] lappend Sortie [format "%3d %s" $Cumul $NiceSpTsk] } set LesLignesHisto [RetourneLaListe $Sortie] set Histo [join $LesLignesHisto "\n"] if {$Action=="Show"} { return [AfficheVariable $Histo "" "Our_Spine_status"] } return $Histo } proc HistoJulie {} { foreach Ligne [LesLignesDuFichier /genomics/link/Balibase30/all.seqcount] { scan $Ligne "%d" X lappend LesX $X } Histogramme $LesX Nombre } proc HistoLongueur {} { set dcdn "toto" sqlite3 $dcdn wobble.sql set db [rrps_setup] set Ltables [lsort [$dcdn eval {select tbl_name from sqlite_master}]] set Lpk [$dcdn eval "select pk_items from [lindex $Ltables 0]"] set Lseq [$db eval "select seqpdb from items where pk_items in ([join $Lpk ,])"] set Lg [list] foreach seq $Lseq { set seq [string map {- "" X "" 0 ""} $seq] lappend Lg [string length $seq] } set LesBornes [list 0 20 20 50 50 100 100 200 200 300 300 400 400 500 500 10000] set i 0 foreach {a b} $LesBornes { set N$i 0 incr i } foreach lgt $Lg { set i 0 foreach {a b} $LesBornes { if {$lgt > $a && $lgt <= $b} { incr N$i break } incr i } } set fout [open ./ToPrint/distri_lgt.html w] puts $fout "Length distribution :

"
    set out1 ""
    set out2 ""
    set i 0
    foreach {a b} $LesBornes {
	append out1 [format "%4d - %4d |" $a $b]
	append out2 [format "    %4d    |" [set N$i]]
	incr i
    }

    puts $fout $out1
    puts $fout $out2
    puts $fout "

" close $fout exit } proc HistoPremier {{Clade ""} {Seuil ""} {GetWhat ""}} { if {$GetWhat==""} { set GetWhat "Show" } if {$Seuil==""} { set Seuil 0.001 } if {$Clade==""} { set Clade [ReferenceClade] } if {[OnTraite CiloCarta Like]} { set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"] } elseif {[OnTraite OI2017 Like]} { set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"] } else { FaireLire "Désolé il faut être LioCarta Like ou OI2017 Like" } set LesMeilleurs {} set N 0 foreach Nom [ListeDesPABs] { if {$N%100==0} { Espionne "$N $Nom" } if {$Nom>"HSAP01000"} { break } set LesPremiers [TousLesPremiersDuClade $Nom $LesTaxIdsInteressants "" "GetList"] if {$LesPremiers=={}} { continue } incr N set P [lindex $LesPremiers 0] lassign $P PN TaxId OS if { ! [info exists Cumul($TaxId)]} { set Cumul($TaxId) 0 lappend LesMeilleurs $TaxId } incr Cumul($TaxId) } set LesMeilleurs [lsort -unique $LesMeilleurs] foreach Meilleur $LesMeilleurs { set C $Cumul($Meilleur) lappend LesCumularsDe($C) $Meilleur } set LesC [array names LesCumularsDe] set LesMeilleursTries {} foreach C [lsort -decreasing -integer $LesC] { LConcat LesMeilleursTries $LesCumularsDe($C) } foreach Meilleur $LesMeilleursTries { lappend LaSortie "$Cumul($Meilleur) $Meilleur [Tax $Meilleur Name]" } return $LaSortie EspionneL $LaSortie SauveLesLignes [array get LesCumularsDe] dans "/home/scherb/gscoperso/Cumulars.txt" set LesC {} foreach C [lsort -integer [array names LesCumularsDe]] { lappend LesC $C lappend LesNC [llength $LesCumularsDe($C)] } Espionne $LesC Espionne $LesNC return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"] } proc HistoPremierMemo {{FichierCumulars ""}} { if {$FichierCumulars=={}} { set FichierCumulars "/home/scherb/gscoperso/Cumulars.txt" } array set LesCumularsDe [LesLignesDuFichier $FichierCumulars] parray LesCumularsDe set LesC {} foreach C [lsort -integer [array names LesCumularsDe]] { lappend LesC $C lappend LesNC [llength $LesCumularsDe($C)] } Espionne $LesC Espionne $LesNC return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"] } proc Histogramme {ListeDeNombres {Sortie ""}} { if {$Sortie==""} { set Sortie "Term" } set MaxLargeur 80 set MaxnN -9999 foreach n $ListeDeNombres { if { ! [info exists nN($n)] } { set nN($n) 0 } incr nN($n) if { [set nN($n)] > $MaxnN } { set MaxnN [set nN($n)] } } set ListeDeNombresTriee [lsort -integer $ListeDeNombres] set Debut [lindex $ListeDeNombresTriee 0] set Fin [lindex $ListeDeNombresTriee end] set LesN [NombresEntre $Debut $Fin] foreach n $LesN { set x 0 if {[info exists nN($n)]} { set x [set nN($n)] } if {$Sortie=="Nombre"} { if {$x==0} { continue } Espionne "[format %3d $n] $x" continue } if {$Sortie=="Term"} { set Largeur [expr int(1.0*$x*$MaxLargeur/$MaxnN)] Espionne "[format %3d $n] [string repeat "." $Largeur]" continue } if {1 || $Sortie=="Graphe"} { lappend LesY $x continue } } if {$Sortie=="Graphe"} { return [Graphe $LesN $LesY] } return [list $LesN $LesY] } proc HistogrammeDesChromosomes {{LesVariables ""} {SplitScreen 0}} { global RepertoireDuGenome set FichierFold "$RepertoireDuGenome/fiches/FoldExpression" if {![file exists $FichierFold]} {set Fold 0} else {set Fold 1} ChargeDistributionsSurChromosomes Tab chr set LesChromosomesAffiches [set Tab(LesChromosomesAffiches)] ChoixDesVariablesDeLHistogramme TabVar $LesVariables set LesVariablesDemandees {} foreach VariableDemandee [set TabVar(LesVariables)] { regsub -all " " $VariableDemandee "_" VariableDemandee lappend LesVariablesDemandees $VariableDemandee set Variable [set TabVar($VariableDemandee)] Espionne $Variable foreach Chromosome $LesChromosomesAffiches { set Valeur [set Tab($Chromosome,$Variable)] if {![info exists VMax]} {set VMax $Valeur;continue} if { $VMax < $Valeur } {set VMax $Valeur } } set Tab($VariableDemandee,Max) $VMax unset VMax } ##########AFFICHAGE################################## set LargeurMax [expr [winfo screenwidth .] - 200] set HauteurMax [expr [winfo screenheight .] - 300] set LargeurFenetre [expr [winfo screenwidth .] - 200 ] set HauteurFenetre [expr [winfo screenheight .] - 300] set BordX 50.0 set BordY 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set PoliceChromo "Courier 9 bold" set nChromosomes [llength $LesChromosomesAffiches] set nVariables [llength $LesVariablesDemandees] set LargeurChromo [expr $LargeurAffichage/(2*$nChromosomes-1)] set LargeurHisto [expr $LargeurChromo/$nVariables] set EcartEntreChromo $LargeurChromo set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K configure -background white set PosYMax [expr $HauteurMax - $BordY] set PosXMinDeRef $BordX set PosXMaxDeRef [expr $PosXMinDeRef+$LargeurChromo] if {$SplitScreen} { set HauteurAffichageTmp [expr ($PosYMax - $BordY)/2] set PosYDeRef [expr $HauteurAffichageTmp + $BordY] } else { set PosYDeRef $PosYMax set HauteurAffichageTmp [expr $PosYMax - $BordY] } foreach Chromosome $LesChromosomesAffiches { set i 0 set PosYTexte [expr $HauteurMax - $BordY/2] set PosXTexte [expr ($PosXMaxDeRef+$PosXMinDeRef)/2] $K create text $PosXTexte $PosYTexte -text "$Chromosome" -font "$PoliceChromo" foreach VariableDemandee $LesVariablesDemandees { set VMax [set Tab($VariableDemandee,Max) ] if {$VMax != 0} { set Facteur [expr $HauteurAffichageTmp*1.0/$VMax ] } else { set Facteur 0 } set Variable [set TabVar($VariableDemandee) ] set Valeur [set Tab($Chromosome,$Variable) ] set ColorFill [set TabVar($Variable,Couleur) ] set Unit [set TabVar($Variable,Unit) ] if {$SplitScreen && [regexp -nocase {moins|minus} $Variable]} { set PosYMin $PosYDeRef set PosYMax [expr $PosYDeRef + $Facteur*$Valeur] } else { set PosYMin [expr $PosYDeRef - $Facteur*$Valeur] set PosYMax $PosYDeRef } set PosXMin [expr $PosXMinDeRef + $i*$LargeurHisto] set PosXMax [expr $PosXMin + $LargeurHisto ] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$VariableDemandee" "$Valeur" "$Unit" "$Chromosome" "Variable"] incr i } set PosXMinDeRef [expr $PosXMax + $EcartEntreChromo] set PosXMaxDeRef [expr $PosXMinDeRef+$LargeurChromo] } $K create line $BordX $PosYDeRef [expr $LargeurMax-$BordX] $PosYDeRef -fill black $K bind "Variable" "DevoileLesHistogrammes $K %x %y Enter" $K bind "Variable" "DevoileLesHistogrammes $K %x %y Leave" regsub {\.canvas} $K "" w if {$Fold} { set B [BoutonneLaFenetre $w "Change Parameters\nSplitScreen On/Off\nNew Histogramm"] bind $B <1> "HistogrammeDesChromosomes {} $SplitScreen" bind $B "HistogrammeDesChromosomes \"$LesVariables\" 1" bind $B "HistogrammeDesChromosomes \"$LesVariables\" 0" bind $B "ChoixHistogramme" } else { set B [BoutonneLaFenetre $w "Change Parameters\nNew Histogramm"] bind $B <1> "HistogrammeDesChromosomes {}" bind $B "ChoixHistogramme" } return } proc HistogrammeDesGC {} { set Cumul 0 foreach Nom [ListeDesPABs] { set GC [CompositionEn GC $Nom] set Cumul [expr $Cumul + $GC] lappend Liste $GC } scan [MoyenneEcartMinMaxCumulLong $Liste] "%f %f %d %d" Mo Ec Mi Ma Espionne "$Mo $Ec [expr $Mo-2*$Ec] [expr $Mo+2*$Ec]" Histogramme $Liste exit } proc HistogrammeDesRegions {{LesChromosomesDeRef All} {TypeRegion ctg} {LesVariables ""} {EchelleVariablesId Yes} {EchelleChromoId Yes}} { global RepertoireDuGenome if {$TypeRegion == "chr"} {HistogrammeDesChromosomes} set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierContigs "$RepLocalisation/seq_contig.md" if {![file exists $FichierContigs]} {Espionne "$FichierContigs does not exist" ;return ""} set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {Espionne "$FichierBandesCytos does not exist";return ""} set FichierFold "$RepertoireDuGenome/fiches/FoldExpression" if {![file exists $FichierFold]} {set Fold 0} else {set Fold 1} ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {$LesChromosomesDeRef == "All"} {set LesChromosomesDeRef [set LesBandesCytos(LesChromosomes)]} ##########AFFICHAGE################################## set PolicePetite "Courier 8" set Police "Courier 8" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set HauteurFenetre [expr [winfo screenheight .] - 200] set nChromo [llength $LesChromosomesDeRef] set LaRepartition [Pavage $nChromo $LargeurMax $HauteurMax] set nChromSurX [lindex $LaRepartition 0] set nChromSurY [lindex $LaRepartition 1] set LargeurAffichage [expr $LargeurMax * 1.0 / $nChromSurX] set HauteurAffichage [expr $HauteurMax * 1.0 / $nChromSurY] set BordX [expr $LargeurAffichage * 0.1 ] set BordY [expr $HauteurAffichage * 0.1 ] set LargeurChromo [expr $LargeurAffichage * 0.04 ] set LargeurBoite [expr $LargeurAffichage * 0.01 ] set EcartEntreRepresentations [expr $LargeurAffichage * 0.1 ] set LargeurHistoMax [expr $LargeurAffichage * 4 / 15] set TailleMaxBrasP [set LesBandesCytos(TaillePMax) ] set TailleMaxBrasQ [set LesBandesCytos(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set Facteur [expr ($HauteurAffichage - 2 * $BordY) / $TailleMaxChromo] ChoixDesVariablesDeLHistogramme TabVar $LesVariables set LesVariables [set TabVar(LesVariables)] foreach VariableDemandee $LesVariables { regsub -all " " $VariableDemandee "_" VariableDemandee lappend LesVariablesDemandees $VariableDemandee set Variable [set TabVar($VariableDemandee)] #######Determination du VMax##### if {[info exists VMax]} {unset VMax} foreach ChromosomeDeRef $LesChromosomesDeRef { ChargeDistributionsSurRegions Tab $ChromosomeDeRef $TypeRegion set LesRegions [set Tab($ChromosomeDeRef,LesRegions)] foreach Region $LesRegions { if {![info exists Tab($ChromosomeDeRef,$Region,$Variable)]} {continue} set Valeur [set Tab($ChromosomeDeRef,$Region,$Variable)] if {![info exists VMax]} {set VMax $Valeur;continue} if { $VMax < $Valeur } {set VMax $Valeur } } if {$EchelleVariablesId != "Yes" && [info exists VMax]} { set Tab($ChromosomeDeRef,$VariableDemandee,Max) $VMax unset VMax } } if {$EchelleVariablesId == "Yes"} { foreach ChromosomeDeRef $LesChromosomesDeRef { set Tab($ChromosomeDeRef,$VariableDemandee,Max) $VMax } if {[info exists VMax]} {unset VMax} } ################################## set Titre [string toupper $VariableDemandee] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "GonfleAussiY" "$Titre"] $K configure -background white set nX 0 set nY 1 foreach ChromosomeDeRef $LesChromosomesDeRef { incr nX if {$nChromSurX < $nX} {set nX 1;incr nY} set HAfficheMin [expr ($nY - 1) * $HauteurAffichage] set HAfficheMax [expr $nY * $HauteurAffichage] set LAfficheMin [expr ($nX - 1) * $LargeurAffichage] set LAfficheMax [expr $nX * $LargeurAffichage] set TailleP [set LesBandesCytos($ChromosomeDeRef,TailleP)] set TailleQ [set LesBandesCytos($ChromosomeDeRef,TailleQ)] set TailleChromo [expr $TailleP + $TailleQ] if {$EchelleChromoId == "No"} { set Facteur [expr ($HauteurAffichage - 2 * $BordY) / ($TailleP + $TailleQ)] set TailleMaxBrasP $TailleP } set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordY + $HAfficheMin] set HPremiereRegion [expr $PosYDuCentromer - $Facteur * $TailleP] set XTexte [expr ($LAfficheMax - $LAfficheMin) / 2 + $LAfficheMin] set YTexte [expr $HAfficheMin + $BordY / 2] $K create text $XTexte $YTexte -text "$ChromosomeDeRef" -fill "blue" $K create line $LAfficheMin $PosYDuCentromer $LAfficheMax $PosYDuCentromer -fill red #$K create rectangle $LAfficheMin $HAfficheMin $LAfficheMax $HAfficheMax -outline black set XHistoMin [expr ($LAfficheMax - $LAfficheMin) * 2 / 3 + $LAfficheMin] set XChromo [expr ($LAfficheMax - $LAfficheMin) / 3 + $LAfficheMin] set PosY $PosYDuCentromer set PosXMin [expr $XChromo - $LargeurChromo / 2] set PosXMax [expr $XChromo + $LargeurChromo / 2] ####Affichage des bandes cytologiques####### set LesBandesP [lsort [set LesBandesCytos($ChromosomeDeRef,LesBandesP)]] foreach BandeP $LesBandesP { set LesInfos [set LesBandesCytos($ChromosomeDeRef,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set PosYMinAxe $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set LesBandesCytos($ChromosomeDeRef,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set LesBandesCytos($ChromosomeDeRef,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set PosYMaxAxe $PosYMax set XTaille $PosXMin $K create text $XTaille $PosYMinAxe -text "0 Mpb" -fill "green" -anchor e -font $PolicePetite $K create text $XTaille $PosYMaxAxe -text "[expr round($TailleChromo)] Mpb" -fill "green" -anchor e -font $PolicePetite ####################################### ####Affichage Des Histogrammes############ $K create line $XHistoMin $PosYMinAxe $XHistoMin $PosYMaxAxe -fill black -width 2 set LesRegions [set Tab($ChromosomeDeRef,LesRegions)] set VMax [set Tab($ChromosomeDeRef,$VariableDemandee,Max) ] if {$VMax == 0} {continue} set ColorFill [set TabVar($Variable,Couleur) ] set Unit [set TabVar($Variable,Unit) ] set FacteurX [expr $LargeurHistoMax / $VMax] set PosXMin $XHistoMin set PosYMin $HPremiereRegion $K create line $PosXMin $PosYMin [expr $PosXMin+$LargeurHistoMax] $PosYMin -fill black set TexteVMax "$VMax" $K create text [expr $PosXMin+$LargeurHistoMax] $PosYMin -text "$TexteVMax" -anchor s -font $PolicePetite foreach Region $LesRegions { if {![info exists Tab($ChromosomeDeRef,$Region,Taille)]} {continue} set Taille [expr [set Tab($ChromosomeDeRef,$Region,Taille)] / 1e6] set Valeur [set Tab($ChromosomeDeRef,$Region,$Variable) ] set PosYMax [expr $Facteur * $Taille + $PosYMin] if {$Valeur == 0} {set PosYMin $PosYMax ; continue} set PosXMax [expr $XHistoMin + $FacteurX * $Valeur] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline $ColorFill -fill $ColorFill -tags [list "$VariableDemandee" "$Valeur" "$Unit" "$Region" "Variable"] set PosYMin $PosYMax } } $K bind "Variable" "DevoileLesHistogrammes $K %x %y Enter" $K bind "Variable" "DevoileLesHistogrammes $K %x %y Leave" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K" regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "Change Parameters/New Histo\nScale Variable Id./Diff.\nScale Chromo Id./Diff."] bind $B <1> "HistogrammeDesRegions \"$LesChromosomesDeRef\" $TypeRegion \{\} $EchelleVariablesId $EchelleChromoId" bind $B <2> "ChoixHistogramme" bind $B "HistogrammeDesRegions \"$LesChromosomesDeRef\" $TypeRegion \"$LesVariables\" Yes $EchelleChromoId" bind $B "HistogrammeDesRegions \"$LesChromosomesDeRef\" $TypeRegion \"$LesVariables\" No $EchelleChromoId" bind $B "HistogrammeDesRegions \"$LesChromosomesDeRef\" $TypeRegion \"$LesVariables\" $EchelleVariablesId Yes" bind $B "HistogrammeDesRegions \"$LesChromosomesDeRef\" $TypeRegion \"$LesVariables\" $EchelleVariablesId No" } return "" } proc HistogrammeDuCAI {} { foreach Nom [ListeDesPABs] { set x [CAI $Nom] if {$x!=""} { lappend LesCAI [expr round (100*$x)] } } Histogramme $LesCAI Graphe } proc HistogrammeDuFichier {Fichier {Sortie ""}} { set Liste {} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%d" N lappend Liste $N } return [Histogramme $Liste $Sortie] } proc HistogrammeDuNombreDeCopainsDansBlast {} { global NombreDeCopainsDansBlast if { ! [info exists NombreDeCopainsDansBlast] } { ChargeNombreDeCopainsDansBlast } foreach {Nom ValNombreDeCopainsDansBlast} [array get NombreDeCopainsDansBlast] { set nCops $ValNombreDeCopainsDansBlast if { $nCops > 2 } { lappend Liste $nCops } } Histogramme $Liste } proc HistogrammeDuNombreDeParalogues {{Format Graphe}} { foreach Nom [ListeDesPABs] { set n [NombreDeParaloguesDe $Nom] if {$n>0} { lappend LesNombres $n } } Histogramme $LesNombres $Format } proc HistogrammeDuNombreDesHomologues {{Type homo}} { foreach Nom [ListeDesPABs] { lappend LaListe [NombreDeHomologues $Nom $Type] } Histogramme $LaListe } proc HistogrammeDuTas {Fichier {LesTabs ""}} { if {$LesTabs==""} { set LesTabs {10 20 30 40 50 60 70 80 90 100} } set LesSCs {} foreach Ligne [lrange [LesLignesDuFichier $Fichier] 2 end] { if { ! [YaPABdans $Ligne]} { continue } scan $Ligne "%s %d %s %d" Nom FF SC PI if {$Fichier == "rr-phor.tas" || $Fichier == "rr-pfur.tas" } { set SC XX } if {[lsearch $LesSCs $SC] < 0 } { lappend LesSCs $SC } set OldTab -1 foreach Tab $LesTabs { if {$OldTab < $PI && $PI <= $Tab} { if {[info exists Histo($SC,$Tab)]} { incr Histo($SC,$Tab) } else { set Histo($SC,$Tab) 1 } break } set OldTab $Tab } } foreach SC $LesSCs { foreach Tab $LesTabs { if {[info exists Histo($SC,$Tab)]} { puts "$SC $Tab [set Histo($SC,$Tab)]" } else { puts "$SC $Tab 0" } } } } proc HistogrammePourLePlusProcheVoisinPourTous {{OldW ""}} { global RepertoireDuGenome if {$OldW!=""} {catch {after 10 Destroy $OldW}} set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set PoliceChromo "Courier 7 bold" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] ChargeBandesCytologiques Genome $FichierBandesCytos set TailleMaxBrasP [set Genome(TaillePMax)] set TailleMaxBrasQ [set Genome(TailleQMax)] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo [expr $LargeurChromo*4] set LargeurBoite [expr $EcartEntreChromo/2] set Facteur [expr $HauteurAffichage / ($TailleMaxChromo*3)] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY] $K configure -background "white" set Titre "The nearest neighbour" $K create text [expr $LargeurAffichage/2] 20 -text "$Titre" -font "courrier 12 bold" ################################################################## set LaSerie1 {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08} lappend Les3Series $LaSerie1 set LaSerie2 {HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16} lappend Les3Series $LaSerie2 set LaSerie3 {HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} lappend Les3Series $LaSerie3 set s 0 foreach Serie $Les3Series { #Espionne $Serie incr s set PosX $BordX foreach Chromosome $Serie { set LesBandes [LesBandesPourTousLesClustersDunChromo $Chromosome] foreach Bande $LesBandes { if {[lindex $Bande 1]==""} { set Vu($Bande) 1 } else { set LesBandesContigues [split $Bande " "] foreach band $LesBandesContigues { set Vu($band) 1 } } } ##fonction de la serie if {$s==1} { set PosY $PosYDuCentromer } if {$s==2} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60] } if {$s==3} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60] } #### set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set TailleChromosome [expr $TailleBrasP+$TailleBrasQ] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] $K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" ##histo## set ChromDeRef [NumeroDuChromosome $Chromosome] set PosXMaxHisto [expr $PosXMax + 2*$EcartEntreChromo] set PosAxeHisto [expr $PosXMax+10] ######### set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] if {![info exists Vu($BandeP)]} { continue } else { $K create rectangle $PosAxeHisto $PosYMin [expr $PosXMaxHisto-$EcartEntreChromo] $PosYMax -outline "blue" -fill "blue" } } set ExtremiteDuChromosome $PosYMin ##fonction de la serie if {$s==1} { set PosY $PosYDuCentromer } if {$s==2} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60] } if {$s==3} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60] } set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline "black" -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] if {![info exists Vu($BandeQ)]} { continue } else { $K create rectangle $PosAxeHisto $PosYMin [expr $PosXMaxHisto-$EcartEntreChromo] $PosYMax -outline "blue" -fill "blue" } } set ExtremiteBasseDuChromo $PosYMax $K create line $PosAxeHisto $ExtremiteDuChromosome $PosAxeHisto $ExtremiteBasseDuChromo -fill "black" -width 2 } ##PosYfonction de la serie if {$s==1} { set PosY $PosYDuCentromer } if {$s==2} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + $PosYDuCentromer+60] } if {$s==3} { set PosY [expr $TailleMaxBrasP * $Facteur + $BordYSup + ($PosYDuCentromer *2)+60+60] } $K create line $BordX $PosY [expr $LargeurMax-$BordX] $PosY -fill red } regsub {\.canvas} $K "" w #ces 2 lignes sont necessaires pour affichage #lors du passage de la souris sur chaque region de l histo #$K bind "Variable" "DevoileLesHistogrammes $K %x %y Enter" #$K bind "Variable" "DevoileLesHistogrammes $K %x %y Leave" $K bind "Chromosome" <1> "ChromosomeSelectionne $K" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "Histogramme"] bind $B <1> "ChoixHistogramme" set Boutons "$w.buttons" } proc HitCounts {RepertoireParent} { set HitCounts [exec /home/poidevin/bin/phix -LOGIN ripp -FEDINSTANCE gx StringFun::StringInteractomeDisplay $RepertoireParent] set Reste [StringSuivant "WithAny interactions:" dans $HitCounts] lappend LesLignesHitCounts "WithAny interactions:" foreach Ligne [split $Reste "\n"] { regsub "
" $Ligne "" Ligne regsub "

" $Ligne "" Ligne regsub "

" $Ligne "" Ligne if {[regexp "Your query genes and their interactions" $Ligne]} {break} if {$Ligne !=""} {lappend LesLignesHitCounts $Ligne} } set Reste $HitCounts foreach Ligne [split $Reste "\n"] { if {[regexp "^Changing name from" $Ligne]} { lappend LesLignesHitCounts $Ligne } } return [join $LesLignesHitCounts "\n"] } proc HitMultiple {Nom} { global HitMultiple if {[info exists HitMultiple($Nom)]} { return [set HitMultiple($Nom)] } if {[info exists HitMultiple("EstCharge")]} { return {} } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesHitsMultiples"] { scan $Ligne "%s %s %s" NomLu Autre Hit lappend HitMultiple($NomLu) "$Autre $Hit" } set HitMultiple("EstCharge") 1 return [HitMultiple $Nom] } proc HitPointIndex {t index} { global Vrp set c $Vrp(WCanvas) set elt "p${Vrp(VId)}_$index" AddLabel $c $elt $index return } proc HitPointXY {c x y} { set Lt [$c gettags current] if {$Lt == {}} {return} set rex "^p${::Vrp(VId)}_\[0-9\]+\$" foreach elt $Lt { if {[regexp $rex $elt]} { AddRemoveLabel $c $elt } } return } proc HomeLinksPlanbis {} { file mkdir "/planbis/maison/homeLinks" NousAllonsAuBoulot "/maison/homeLinks" set LesLiens [glob -nocomplain *] set LesNews {} foreach Lien $LesLiens { if {[file type $Lien]!="link"} { continue } set Target [file readlink $Lien] Espionne "$Lien pointe sur $Target" regsub "^/maison" $Target "/planbis/maison" New set Queue [file tail $New] set NewLink "/planbis/maison/homeLinks/$Queue" exec ln -s $New "/planbis/maison/homeLinks/$Queue" lappend LesNews $NewLink } return $LesNews } proc HomeRipp {} { return "/home/ripp" } proc HomologDetectionAgreement {Nom {Quoi Value}} { global HomologDetectionAgreement if {$Nom=="Reset" || $Quoi=="Reset"} { if {[info exists HomologDetectionAgreement]} { unset HomologDetectionAgreement } ChoixDesGenomesCompletsPresentsAbsents Ask [LesGenomesComplets] return } if { ! [info exists HomologDetectionAgreement(Value,Value)]} { set VaCoSi [list "NoValue" "white" "HomDetectionAgree NoValue" "AllAbsent" "red" "HomDetectionAgree AllAbsent" "AllPresent" "green" "HomDetectionAgree AllPresent" "AtLeastOneMistake" "yellow" "HomDetectionAgree AtLeastOneMistake" "Variable" "orange" "HomDetectionAgree Variable" "IncoherentValue" "grey" "HomDetectionAgree IncoherentValue" ] foreach {Va Co Si} $VaCoSi { set HomologDetectionAgreement($Va,Value) $Va set HomologDetectionAgreement($Va,Color) $Co set HomologDetectionAgreement($Va,Signif) $Si } } if {[info exists HomologDetectionAgreement($Nom,Value)]} { set V [set HomologDetectionAgreement($Nom,Value)] return [set HomologDetectionAgreement($V,$Quoi)] } if {[info exists HomologDetectionAgreement("EstCharge",Value)]} { set V [set HomologDetectionAgreement("EstCharge",Value)] return [set HomologDetectionAgreement($V,$Quoi)] } set LesGENO [ChoixDesGenomesCompletsPresentsAbsents] set LesGeno {} foreach G $LesGENO { lappend LesGeno [string totitle $G] } Espionne "I'll create HomologDetectionAgreement for [join $LesGeno " "]" foreach NomLu [ListeDesPABs] { set OoN " [ORGAorgaDesTBlastNs $NomLu] " set OoP " [ORGAorgaDesBlastPs $NomLu] " set OoMA " [ORGAorgaDesMSFs $NomLu] " if {[info exists R]} { unset R } if {[info exists OldAbsent]} { unset OldAbsent } if {[info exists OldPresent]} { unset OldPresent } set Absent 0 set Present 0 set Autre 1 foreach GENO $LesGENO Geno $LesGeno { set N [regexp " $GENO " $OoN] set P [regexp " $GENO " $OoP] set M [regexp " $Geno " $OoMA] set A [regexp " $GENO " $OoMA] if {$A} { set P 1 } if { ! $N && ! $P } { continue } set Absent [expr !$P && !$N && !$A] set Present [expr $P && $N && $A] set Mistake [expr !$P && $N && !$A] set Autre [expr !$Absent && !$Present && !$Mistake] if { $Mistake } { set R "AtLeastOneMistake" ; break } if { $Autre } { set R "Variable" ; continue } if { ! [info exists OldAbsent]} { set OldAbsent $Absent } if { ! [info exists OldPresent]} { set OldPresent $Present } if {$Absent !=$OldAbsent} { set R "Variable" ; continue } if {$Present!=$OldPresent} { set R "Variable" ; continue } } if { ! [info exists R]} { if {$Absent } { set R "AllAbsent" } if {$Present} { set R "AllPresent" } if { $Autre } { set R "Variable" } } set HomologDetectionAgreement($NomLu,Value) $R } set HomologDetectionAgreement("EstCharge",Value) "NoValue" return [HomologDetectionAgreement $Nom $Quoi] } proc HomologeneIdAcGenecard {Nom} { set NM [AccessEvi $Nom] set SiteGeneCard "http://www.genecards.org/" if {[catch { set Texte [HttpGetUrl "$SiteGeneCard/cgi-bin/cardsearch.pl?search=$NM&search_type=kwd&speed=fast&mini=yes"]}] } { return "Error during HttpGetUrl" } set LesLignes [split $Texte "\n"] foreach Ligne $LesLignes { if {[regexp -nocase "homologene" $Ligne]} { set LesElts [split $Ligne "|"] foreach Elt $LesElts { if {[regexp -nocase "homologeneid" $Elt]} { set IdHomologene [StringApres "HomologeneId=" dans $Elt] #Espionne"$Nom= $IdHomologene" return $IdHomologene } } } } } proc Hostname {} { return $::env(HOST) } proc HotdogPourOi {{ProjName ""} {FastaFile ""} {BlastDatabase ""} {OptionsBlast ""}} { if {$ProjName==""} { set ProjName "BlastonhOi" } if {$FastaFile==""} { set FastaFile [GscopeFile $ProjName "oip"] } if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] } #f {$OptionsBlast==""} { set OptionsBlast "-W 3 -e 1.0e-5 -v 5000 -b 5000 -K 0 -F F -C 2" } if {$OptionsBlast==""} { set OptionsBlast "-word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2" } set PassePlat "" if {[ValidBlastDatabaseForHotdog $BlastDatabase]} { set ProjNameWithDate "${ProjName}_[Date]" set DBSizeTxt [BlastDatabaseSize $BlastDatabase] scan $DBSizeTxt "%d" DBSize if {1} { Espionne "Grillade::creerPoeleBlastOiHpc ProjectName $ProjNameWithDate Input $FastaFile DB $BlastDatabase DBsize $DBSize BlastOpts $OptionsBlast" set PassePlat [Grillade::creerPoeleBlastOiHpc ProjectName $ProjNameWithDate Input $FastaFile DB $BlastDatabase DBsize $DBSize BlastOpts $OptionsBlast] } else { Espionne "" set PassePlat "/tempor/grid/poeles/$ProjName" } if {[regexp -nocase "^Error" $PassePlat]} { set Message "Error. Something is wrong with Hotdog. I got the error message $PassePlat" } #rR Tcl ne veut pas pointer si la cible n'existe pas.ON est obligé de faire un exec :(" exec ln -sf "$PassePlat" "[RepertoireDuGenome]/PassePlat_$ProjNameWithDate" AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat set Message "Warning. I launched Hotdog for $ProjName. Blast files will be available at $PassePlat" return $Message } else { set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin" } return $Message } proc HoteCourt {{N 3}} { return [string range [Hostname] 0 [incr N -1]] } proc HrefPourGetz {Access {Banque ""}} { if {$Banque==""} { set Banque "protein" } } proc HsapiensGeneDefLoc {Query {Quoi ""}} { global HsapiensGeneDefLoc global GscopeDir set QUOI [string toupper [string index $Quoi 0]] set QUERY [string toupper $Query] if {$QUOI=="" && [regexp " " $Query]} { set QUOI G } if {$QUOI=="" && ! [regexp " " $Query]} { set QUOI D } if {[regexp "LISTEGN" $QUERY]} { set QUOI "G" } if {[regexp "LISTEDEF" $QUERY]} { set QUOI "D" } if {[info exists HsapiensGeneDefLoc($QUERY,$QUOI)]} {return [set HsapiensGeneDefLoc($QUERY,$QUOI)]} if {[info exists HsapiensGeneDefLoc] && $Quoi!="ChooseDef"} { return "" } if {[info exists HsapiensGeneDefLoc] && $Quoi=="ChooseDef"} { set LesPossibles {} set LesPossiblesAvecGn {} set LesClefs [split $Query " "] foreach Def $HsapiensGeneDefLoc(LISTEDEF,D) { set TousSontLa 1 foreach Clef $LesClefs { if { ! [regexp -nocase $Clef $Def]} { set TousSontLa 0 ; break } } if {$TousSontLa} { set DEF [string toupper $Def] lappend LesPossiblesAvecGn "[set HsapiensGeneDefLoc($DEF,G)] $Def" lappend LesPossibles $Def } } set Bonne [ChoixParmiJoli $LesPossibles "" $LesPossiblesAvecGn] return [HsapiensGeneDefLoc $Bonne G] } foreach Ligne [LesLignesDuFichier "$GscopeDir/gscope_hs_gn_def_loc.txt"] { if {[regexp "^Symbol" $Ligne]} { continue } while {[regsub -all { |\t} $Ligne " " Ligne]} {} set Ligne [string trim $Ligne] set LesMots [split $Ligne " "] set Gn [lindex $LesMots 0] set PMID [lindex $LesMots end] if {[regexp {^[0-9]{5,}$} $PMID]} { set LaDefLoc [lrange $LesMots 1 end-1] } else { set LaDefLoc [lrange $LesMots 1 end] set PMID "" } set Loc [lindex $LaDefLoc end] if {[regexp {^(X|Y|[0-9]{1,2})[pq]} $Loc] || [regexp "reserved" $Loc] || [regexp {^[0-9]+$} $Loc]} { set Def [join [lrange $LaDefLoc 0 end-1] " "] } else { set Loc "" set Def [join [lrange $LaDefLoc 0 end] " "] } set DEF [string toupper $Def] set GN [string toupper $Gn] set HsapiensGeneDefLoc($GN,D) $Def set HsapiensGeneDefLoc($GN,L) $Loc set HsapiensGeneDefLoc($DEF,G) $GN lappend HsapiensGeneDefLoc(LISTEGN,G) $Gn lappend HsapiensGeneDefLoc(LISTEDEF,D) $Def } return [HsapiensGeneDefLoc $Query $Quoi] } proc Html2Char {l} { puts $l set Li [regexp -all -inline -indices {\\[0-9]{3}} $l] if {$Li == {} } { return $l } foreach xy [lreverse $Li] { lassign $xy x y set l [string replace $l $x $y [MapCharSet octal char [string range $l $x $y]]] } return $l } proc HtmlAuthorize {NomDeProc} { if { ! [regexp -nocase {^[a-z_\:]+[\:a-z_0-9]*$} $NomDeProc]} { return 0 } return 1 } proc HtmlBlastDatabaseInventory {} { BlastDatabaseInventory "ResetAll" set LesBases [BlastDatabaseInventory ListOf ProBestFirst] set LL {} set lesClefs [list BlastDatabase Type NbSequences NbLetters DBLIST] lappend LL $lesClefs set lesTailles [dbSize [lindex $LesBases 1]] foreach base $LesBases { set type [BlastDatabaseInventory $base Type] set size [BlastDatabaseInventory $base Size] set NbSequences "" set NbLetters "" scan $size "%d %s %d %s" NbSequences sequences NbLetters letters set dbList [BlastDatabaseInventory $base DBLIST] lappend LL [list $base $type $NbSequences $NbLetters $dbList] } set lesLignes {} lappend lesLignes "" lappend lesLignes " " set PremiereLigne 1 foreach L $LL { lappend lesLignes " " foreach k $lesClefs e $L { set Cadrage "" if {$PremiereLigne} { if {$e=="DBLIST"} { set Cadrage "style='text-align:left;' " } lappend lesLignes " " } else { if {[regexp {^[0-9]+$} $e]} { set Cadrage "style='text-align:right;' " } if {$e==0} {set e ""} if {$k=="BlastDatabase"} {set BaseCourante $e} set ligne "" lappend lesLignes $ligne } } set PremiereLigne 0 lappend lesLignes " " } lappend lesLignes " " lappend lesLignes "

$e	$e

" set Table [join $lesLignes "\n"] return $Table } proc HtmlBlastIllustre {{BlastFile ""} {Site ""} {ExpectDeRef ""} {NbSubject ""} {LesBIdsAutorises ""} {SelectedOrganism ""}} { if {$Site==""} { set Site [ZincrSite] } set ParamScience "science=[Science]&" if {[regexp "^palignupload" $BlastFile]} { regsub "^palignupload" $BlastFile "/tempor/palign/upload" BlastFile } if {[regexp "^palignarchive" $BlastFile]} { regsub "^palignarchive" $BlastFile "/tempor/palign/archive" BlastFile } if {[regexp "^paligndepot" $BlastFile]} { regsub "^paligndepot" $BlastFile "/tempor/palign/depot" BlastFile } if {[regexp "^palignsessions" $BlastFile]} { regsub "^palignsessions" $BlastFile "/tempor/palign/sessions" BlastFile } set Svg [IllustreLeBlast $BlastFile $ExpectDeRef $NbSubject $LesBIdsAutorises $SelectedOrganism "PourSvgFromHtmlBlastIllustre"] if {[regexp "^Sorry" $Svg]} { return $Svg } set ScriptBlastIllustre [Chabada "TemplateBlastIllustre.js" "_site_=$Site" "_paramscience_=$ParamScience"] set Html [Chabada "TemplateBlastIllustre.html" "ScriptBlastIllustre=$ScriptBlastIllustre" "Svg=$Svg" "site=$Site"] if {[regexp -nocase scope $Site]} { set Html [Chabada $Html "SpecificCss=[CssWscope]"] } return $Html } proc HtmlCompatibleColor {Color} { if {[regexp -nocase {^#[a-z0-9]{12}$} $Color]} { lassign [split $Color ""] D a b c d e f g h i j k l return "#$a$b$e$f$i$j" } package require Tk catch {set Color [ColorHexa $Color]} return $Color } proc HtmlFromMsf {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""}} { set Nom [file tail $NomOuFichier] while 1 { set FichierMsf $NomOuFichier if {[regexp "/" $FichierMsf] && [file exists $FichierMsf]} { break } if { ! [EstUnPAB $Nom]} { break } if {[regexp "^/" $NomOuFichier]} { break } set FichierMsf "[RepertoireDuGenome]/$NomOuFichier" if {[file exists $FichierMsf]} { break } set FichierMsf "[RepertoireDuGenome]/msf/$Nom" if {[file exists $FichierMsf]} { break } return "" } set FichierXml "[TmpFile $Nom].xml" if {[catch {exec clustalw $FichierMsf -convert -outfile=$FichierXml -output=macsim} Message]} { return "$Message" } if { ! [file exists $FichierXml]} { return "" } return [HtmlFromXmlMacsim $FichierXml $Format $FichierHtml $TitreDeLaPage] } proc HtmlFromXmlMACS {NomOuFichier {Format ""} {FichierHtml ""}} { Wup "Permet la conversion d un fichier XML au format de la dtd de MACSIM en fichier HTML" Wup "Il ajoute egalement l entete et le pied de page de l interface de ARPAnno" Wup "Il colorie les residus en fonction de leur positions (voir AnnoteLeXMLDesARPs)" package require tdom Html_Zero set AvecZones 0 if {[regexp -nocase "AvecZones" $Format]} { set AvecZones 1 regsub -nocase "AvecZones" $Format "" Format } if {$Format==""} { set Format "Normal" } set CouleurNormal [string equal -nocase $Format "Normal"] set CouleurSeqLab [string equal -nocase $Format "SeqLab"] set CouleurFtype [regexp -nocase "^Ftype_(.+)" $Format Match Ftype] set DescriptionOnly [string equal -nocase "Description" $Format] set Nom [file tail $NomOuFichier] set FichierXml $NomOuFichier set Famille [file tail $FichierXml] set Famille_tmp "" regsub -nocase ".xml" $Famille "" Famille regexp -nocase {_([a-z]{2,4}[0-9]{1,2}|actin|orphans)$} $Famille tmp Famille_tmp if {$Famille_tmp != ""} {set Famille $Famille_tmp} set MacsimXml [ContenuDuFichier $FichierXml] set NoeudMacsim [[dom parse $MacsimXml] documentElement] set FichierMSF [file tail $FichierXml] regsub -nocase ".xml$" $FichierMSF ".msf" FichierMSF set Titre "ARPAnno: MACS" set Header "" set CouleurColSco 1 if {$CouleurColSco} { append Header "\n[H_StyleDesCouleursColSco]" } if {$CouleurSeqLab} { append Header "\n[H_StyleDesCouleursSeqlab]" } if {$CouleurFtype} { append Header "\n[H_StyleDesCouleursFtype]" } #Html_ZeroToBody $Titre $Header #Html_Header $Titre $Header Html_ARPAnno_BEGIN $Header set NoeudAli [$NoeudMacsim selectNodes "alignment"] set AlnName [$NoeudAli selectNodes "string(aln-name)"] #Html_Banner #Html_BackTo Html_Append "
" Html_Append "Multiple alignment results with $Famille family" Html_Append "
" Html_Append "
" Html_Append "View MSF Output File" Html_Append "
" Html_Append "
" set TexteColoring "with $Format colors" if {$Format=="Normal"} { set TexteColoring "without coloring" } if {$DescriptionOnly} { Html_BaliseOpen "span" "style='font-family:courier'" Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='2'" set MettreRegleAvant 0 } else { Html_BaliseOpen "span" "style='font-family:courier'" Html_BaliseOpen "table" "border='0' cellpadding='0' cellspacing='0'" set MettreRegleAvant 1 } if {$AvecZones} {set MettreRegleAvant 0} set TousLesColumnScore {} foreach NoeudColumnScore [$NoeudAli selectNodes "column-score"] { if {$AvecZones || $DescriptionOnly} { break } set ColscoName [$NoeudColumnScore selectNodes "string(colsco-name)"] set ColscoOwner [$NoeudColumnScore selectNodes "string(colsco-owner)"] if {$ColscoOwner!=0} { continue } set ColscoType [$NoeudColumnScore selectNodes "string(colsco-type)"] set ColscoData [$NoeudColumnScore selectNodes "string(colsco-data)"] set LesColonnes {} if {[regexp {core.?block} $ColscoName]} { foreach Score [split [string trim $ColscoData] " "] { set Car "?" if {$Score=="-1"} { set Car "." } if {$Score=="0"} { set Car "-" } if {$Score=="1"} { set Car "|" } lappend LesColonnes $Car } } else { if {[string equal -nocase $ColscoType "int"]} { set LesCarPourInt "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" foreach Score [split $ColscoData " "] { set Car [lindex $LesCarPourInt $Score] if {$Car==""} { set Car "?" } lappend LesColonnes $Car } } } set Colonnes [join $LesColonnes ""] if {$Colonnes!="" && $MettreRegleAvant} { set MettreRegleAvant 0 set LargeurAlignement [llength $LesColonnes] Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } Html_BaliseOpen "tr" Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'" Html_Append "$ColscoName" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'Column score $ColscoName\\')'" Html_Append $Colonnes Html_BaliseClose "td" Html_BaliseClose "tr" } set TousLesFtype {} foreach NoeudSequence [$NoeudAli selectNodes "sequence"] { set SeqName [$NoeudSequence selectNodes "string(seq-name)"] set NoeudInfo [$NoeudSequence selectNodes "seq-info"] set Accession [$NoeudInfo selectNodes "string(accession)"] set Definition [$NoeudInfo selectNodes "string(definition)"] set Organisme [$NoeudInfo selectNodes "string(organism)"] if {[EstUnAccessPDB $Accession]} { set Acc $Accession regsub {_.*} $Acc "" Acc } else { set Acc "uniprot:$Accession" } #Permet de ne pas mettre de lien sur les titres ou separateurs if {! [regexp {\-\-\-\-} $Acc]} { set Url [WgetzSurWeb "$Acc" "" "GetUrl"] } else { set Url "" } set SeqData [$NoeudSequence selectNodes "string(seq-data)"] regsub -all -nocase {[^\.\-a-z]} $SeqData "" SeqData set SeqData [string toupper $SeqData] set NoeudFtable [$NoeudInfo selectNodes "ftable"] if {$NoeudFtable==""} { set MesFtype {} set Ftable "" } else { set MesFtype [LaFtableDansLOrdre $NoeudFtable "TypeList"] LConcat TousLesFtype $MesFtype if {$CouleurFtype} { set Ftable [LaFtableDansLOrdre $NoeudFtable "$Ftype"] } } if {$MettreRegleAvant} { set MettreRegleAvant 0 set LargeurAlignement [string length $SeqData] Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } Html_BaliseOpen "tr" if {$AvecZones} { } else { Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'" #Permet de ne pas mettre de lien sur les titres ou separateurs if {$Url != ""} { Html_Href $SeqName $Url "title='$Definition'" } else { if {[regexp {\-\-\-\-Les} $SeqName]} { regsub {\-\-\-\-Les} $SeqName "\-\-\-\-" SeqName } Html_Append $SeqName } Html_BaliseClose "td" } if {$DescriptionOnly} { Html_BaliseOpen "td" "bgcolor='lightgreen' nowrap='nowrap'" Html_Append " $Definition " Html_BaliseClose "td" Html_BaliseOpen "td" "bgcolor='green' nowrap='nowrap'" Html_Append " $Organisme " Html_BaliseClose "td" } else { Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'$SeqName $Definition $Organisme\\')'" if {$CouleurNormal} { Html_Append [LaSequenceColoree $SeqData "Normal"] } if {$CouleurSeqLab} { Html_Append [LaSequenceColoree $SeqData "Seqlab"] } if {$CouleurFtype} { Html_Append [LaSequenceColoree $SeqData "Ftype" $Ftable $AvecZones] } Html_BaliseClose "td" } Html_BaliseClose "tr" } if { ! $DescriptionOnly && ! $AvecZones} { Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } Html_BaliseClose "table" Html_BaliseClose "span" #Html_Append " $Texte" Html_Append "" Html_ARPAnno_END #Html_BodyToEnd if {$FichierHtml=="GetHtml"} { return [Html_Get] } if {$FichierHtml=="ShowHtml"} { return [AfficheVariable [Html_Get] "" "macsimHtml/$Nom"] } return [Sauve [Html_Get] dans $FichierHtml] } proc HtmlFromXmlMacsim {NomOuFichier {Format ""} {FichierHtml ""} {TitreDeLaPage ""} {RacineForAll ""} {LinkToPipealign ""}} { global MemoXmlMacsim package require tdom set PathToXmlFile $NomOuFichier regsub "^paligndepot" $PathToXmlFile "/tempor/palign/depot" PathToXmlFile #rR il y a des - pour pouvoir mettre des defauts non vides if {$Format=="-"} { set Format "" } if {$FichierHtml=="-"} { set FichierHtml "" } if {$TitreDeLaPage=="-"} { set TitreDeLaPage "" } if {$RacineForAll=="-"} { set RacineForAll "" } if {$LinkToPipealign=="-"} { set LinkToPipealign "" } set WithoutHeader [regexp -nocase "WithoutHeader" $FichierHtml] if {$WithoutHeader} { regsub -nocase "WithoutHeader" $FichierHtml "" FichierHtml } set WithLinkToPipealign 0 if {$LinkToPipealign!=""} { set WithLinkToPipealign 1} set AvecZones 0 if {[regexp -nocase "AvecZones" $Format]} { set AvecZones 1 regsub -nocase "AvecZones" $Format "" Format } if {$Format==""} { set Format "Normal" } set CouleurNormal [string equal -nocase $Format "Normal"] set CouleurSeqLab [string equal -nocase $Format "SeqLab"] set CouleurFtype [regexp -nocase "^Ftype_(.+)" $Format Match Ftype] set DescriptionOnly [string equal -nocase "Description" $Format] set Nom [file tail $NomOuFichier] while 1 { set FichierXml $PathToXmlFile if {[regexp "/" $FichierXml]} { break } if { ! [EstUnPAB $Nom]} { break } set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom" if {[file exists $FichierXml]} { break } set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom.xml" if {[file exists $FichierXml]} { break } return "" } set LinkToRivet 0 if {[regexp -nocase "WithLinkToRivet_(.*)" $FichierHtml Match RivetLink]} { set LinkToRivet 1 set FichierHtml "DisplayHtml" } set LinkToHtml 0 if {[regexp -nocase "WithLinkToHtml_(.*)" $FichierHtml]} { set LinkToHtml 1 regsub -nocase "WithLinkToHtml_" $FichierHtml "" FichierHtml } set CreateAllHtml 0 if {[regexp "CreateAllHtml" $FichierHtml]} { if {$RacineForAll=="" || $RacineForAll=="-"} { set RacineForAll "${FichierHtml}_" } set CreateAllHtml 1 } if {$FichierHtml=="" || $FichierHtml=="-" } { set FichierHtml "GetHtml" } if {$FichierHtml=="macsimHtml"} { if {[regexp "/macsimXml/" $FichierXml]} { regsub "/macsimXml/" $FichierXml "/macsimHtml/" FichierHtml } else { set FichierHtml $FichierXml } regsub ".xml$" $FichierHtml "" FichierHtml append FichierHtml ".html" } if {0 && [info exists MemoXmlMacsim($FichierXml)]} { set NoeudMacsim $MemoXmlMacsim($FichierXml) } else { set MacsimXml [ContenuDuFichier $FichierXml] set NoeudMacsim [[dom parse $MacsimXml] documentElement] set MemoXmlMacsim($FichierXml) $NoeudMacsim } set TexteColoring "with $Format colors" if {$Format=="Normal"} { set TexteColoring "without coloring" } if {[info proc OnTraiteSpine]!="" && [OnTraiteSpine]} { set Titre "Gscope summary of $Nom for Spine" } else { set Titre $TitreDeLaPage if {$Titre=="" || $Titre=="-"} { set DateEnvoi " created [Date Nice]" set Titre "Wali-lite Macsim's output of $Nom [Alias $Nom] ($TexteColoring) $DateEnvoi" } else { append Titre " ($TexteColoring)" } } set Header "" set CouleurColSco 1 if {$CouleurColSco} { append Header "\n[H_StyleDesCouleursColSco]" } if {$CouleurSeqLab} { append Header "\n[H_StyleDesCouleursSeqlab]" } if {$CouleurFtype} { append Header "\n[H_StyleDesCouleursFtype]" } if { ! $AvecZones} { append Header "\n[H_StyleSpanPadding]" } append Header "\n[H_JavascriptPourWaliLite]" Html_ZeroToBody $Titre $Header set NoeudAli [$NoeudMacsim selectNodes "alignment"] set AlnName [$NoeudAli selectNodes "string(aln-name)"] Html_Append "

" Html_Append "Scroll " Html_Append "-100" Html_Append "-10" Html_Append "-1" Html_Append "" Html_Append "+1" Html_Append "+10" Html_Append "+100" Html_Append "

" Html_Append "" set PositionPourHeaderFixe [Html_GetPosition] Html_Append "

" if { ! $WithoutHeader } { Html_Banner Wscope } if { ! $LinkToHtml && ! $CreateAllHtml } { if {[OnTraiteSpine]} { set SpineID [ExtraitInfo $Nom "SpineID"] set SpineRef [ExtraitInfo $Nom "SpineRef"] set SpineDef [ExtraitInfo $Nom "SpineDef"] set Entete $Titre regsub "Wali\-lite" $Entete "" Entete set Entete " Wali-lite    $Entete" Html_Append [H_BalAtt $Entete "h4" "align='centre'"] lappend Liste 2 lappend Liste "border='1' cellpadding='1' cellspacing='1'" lappend Liste "" lappend Liste "bgcolor='green' nowrap='nowrap'" lappend Liste "bgcolor='orange' nowrap='nowrap'" lappend Liste "GscopeID" $Nom lappend Liste "SpineID" $SpineID lappend Liste "SpineRef" [H_Href $SpineRef [WgetzSurWeb $SpineRef "" "GetUrl"]] lappend Liste "SpineDef" $SpineDef Html_TableFromList $Liste } } set Entete $Titre regsub "Wali-lite" $Entete "" Entete set Entete " Wali-lite    $Entete" append Entete "    " append Entete "-" append Entete "  " append Entete "FontSize 12 px" append Entete "  " append Entete "+" append Entete "  " append Entete "1" append Entete "  " append Entete "5" append Entete "  " append Entete "8" append Entete "  " append Entete "10" append Entete "  " append Entete "12" append Entete "  " append Entete "14" append Entete "  " append Entete "18" Html_Append [H_BalAtt $Entete "h4"] set LaHaut [Html_GetPosition] Html_Append "

" Html_Append "" set DivAroundTheTable 0 Html_BaliseOpen "div" "id='divAlignement' style='font-family:courier; font-size:12px;'" if {$DescriptionOnly} { Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='2'" set MettreRegleAvant 0 } else { set DivAroundTheTable 1 Html_BaliseOpen "div" "border='3' style='margin:5px;'" Html_BaliseOpen "table" "border='0' cellpadding='0' cellspacing='0'" set MettreRegleAvant 1 } if {$AvecZones} {set MettreRegleAvant 0} set TousLesColumnScore {} foreach NoeudColumnScore [$NoeudAli selectNodes "column-score"] { if {$AvecZones || $DescriptionOnly} { break } set ColscoName [$NoeudColumnScore selectNodes "string(colsco-name)"] set ColscoOwner [$NoeudColumnScore selectNodes "string(colsco-owner)"] if {$ColscoOwner!=0} { continue } set ColscoType [$NoeudColumnScore selectNodes "string(colsco-type)"] set ColscoData [$NoeudColumnScore selectNodes "string(colsco-data)"] set LesColonnes {} if {[regexp {core.?block} $ColscoName]} { foreach Score [split [string trim $ColscoData] " "] { set Car "?" if {$Score=="-1"} { set Car "." } if {$Score=="0"} { set Car "-" } if {$Score=="1"} { set Car "|" } lappend LesColonnes $Car } } else { if {[string equal -nocase $ColscoType "int"]} { set LesCarPourInt "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" foreach Score [split $ColscoData " "] { set Car [lindex $LesCarPourInt $Score] if {$Car==""} { set Car "?" } lappend LesColonnes $Car } } } set Colonnes [join $LesColonnes ""] if {$Colonnes!="" && $MettreRegleAvant} { set MettreRegleAvant 0 set LargeurAlignement [llength $LesColonnes] Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } Html_BaliseOpen "tr" Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'" Html_Append "$ColscoName" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'Column score $ColscoName\\')'" Html_Append $Colonnes Html_BaliseClose "td" Html_BaliseClose "tr" } set TousLesFtype {} set PreviousGroup "" foreach NoeudSequence [$NoeudAli selectNodes "sequence"] { set SeqName [$NoeudSequence selectNodes "string(seq-name)"] set NoeudInfo [$NoeudSequence selectNodes "seq-info"] set Accession [$NoeudInfo selectNodes "string(accession)"] set Definition [$NoeudInfo selectNodes "string(definition)"] set Organisme [$NoeudInfo selectNodes "string(organism)"] set Group [$NoeudInfo selectNodes "string(group)"] if {[EstUnAccessPDB $Accession]} { set Acc $Accession regsub {_.*} $Acc "" Acc } else { set Acc "uniprot:$Accession" } #rR attention a verifier car j'y ai mis Uniprot pour depanner. set Url [WgetzSurWeb "$Acc" "" "GetUrl"] set SeqData [$NoeudSequence selectNodes "string(seq-data)"] regsub -all -nocase {[^\.\-a-z]} $SeqData "" SeqData set SeqData [string toupper $SeqData] set NoeudFtable [$NoeudInfo selectNodes "ftable"] if {$NoeudFtable==""} { set MesFtype {} set Ftable "" } else { set MesFtype [LaFtableDansLOrdre $NoeudFtable "TypeList"] LConcat TousLesFtype $MesFtype if {$CouleurFtype} { set Ftable [LaFtableDansLOrdre $NoeudFtable "$Ftype"] } } if {$MettreRegleAvant} { set MettreRegleAvant 0 set LargeurAlignement [string length $SeqData] Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } if {$PreviousGroup!=$Group} { Html_BaliseOpen "tr" Html_BaliseOpen "td" "style='text-align:right;'" Html_Append "Group $Group" Html_BaliseClose "td" Html_BaliseClose "tr" } set PreviousGroup $Group Html_BaliseOpen "tr" if {$AvecZones} { } else { Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'" Html_Href $SeqName $Url "title='$Definition' target='_blank'" Html_BaliseClose "td" } if {$DescriptionOnly} { Html_BaliseOpen "td" "bgcolor='lightgreen' nowrap='nowrap'" Html_Append " $Definition " Html_BaliseClose "td" Html_BaliseOpen "td" "bgcolor='green' nowrap='nowrap'" Html_Append " $Organisme " Html_BaliseClose "td" } else { Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap' onClick='javascript:alert(\\'$SeqName $Definition $Organisme\\')'" if {$CouleurNormal} { Html_Append [LaSequenceColoree $SeqData "Normal"] } if {$CouleurSeqLab} { Html_Append [LaSequenceColoree $SeqData "Seqlab"] } if {$CouleurFtype} { Html_Append [LaSequenceColoree $SeqData "Ftype" $Ftable $AvecZones] } Html_BaliseClose "td" } Html_BaliseClose "tr" } if { ! $DescriptionOnly && ! $AvecZones} { Html_BaliseOpen "tr" Html_BaliseOpen "td" Html_BaliseClose "td" Html_BaliseOpen "td" "color='black' bgcolor='white' nowrap='nowrap'" Html_Append [ReglePourAli $LargeurAlignement] Html_BaliseClose "td" Html_BaliseClose "tr" } if {$DivAroundTheTable} { Html_BaliseClose "div" } Html_BaliseClose "table" Html_BaliseClose "span" set AvecATV [file exists "[RepertoireDuGenome]/phylos"] set AvecAutresBoutons [expr $WithLinkToPipealign || [OnTraiteSpine] || [OnTraiteBalibase] || [OnTraitePeroxisome] || [MacsimExiste] || [OnTraite "KoAnno"]] set LesBoutons {} if {$AvecAutresBoutons} { if { ! $LinkToHtml && ! $CreateAllHtml } { lappend LesBoutons "Other infos" "FileMoi $Nom" lappend LesBoutons "Description" "HtmlFromXmlMacsim $Nom Description" if {$AvecATV} { lappend LesBoutons "ATV PhyloTree" "ATV $Nom" } } #rR je ne comprends pas bien comment c'était foutu avant car le if de AvecAutresBoutons couvrait toute la création des boutons Ftype :( } lappend LesBoutons "No colors" "HtmlFromXmlMacsim $NomOuFichier - $FichierHtml $TitreDeLaPage $RacineForAll $LinkToPipealign" lappend LesBoutons "AA colors" "HtmlFromXmlMacsim $NomOuFichier SeqLab $FichierHtml $TitreDeLaPage $RacineForAll $LinkToPipealign" set TousLesFtype [lsort -unique $TousLesFtype] foreach Ftype $TousLesFtype { lappend LesBoutons "$Ftype" "HtmlFromXmlMacsim $NomOuFichier Ftype_$Ftype $FichierHtml $TitreDeLaPage $RacineForAll $LinkToPipealign" } Html_NewLine set LeMenu {} lappend LeMenu [Html_BaliseOpen "table" "border='1' cellpadding='1' cellspacing='3'"] lappend LeMenu [Html_BaliseOpen "tr"] foreach {Text Action} $LesBoutons { if {$LinkToHtml || $CreateAllHtml} { set Quoi [lindex [split $Action " "] 2] set Queue [file tail $RacineForAll] set RfA $RacineForAll if {$RfA=="-"} { set RfA "" } if {$Queue=="-"} { set Queue "" } set UrlAction "${Queue}_$Quoi.html" if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} { set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" } lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RfA}_$Quoi.html" $TitreDeLaPage $RacineForAll] set DejaFait($Quoi) 1 } } elseif {$WithLinkToPipealign} { set UrlAction "$LinkToPipealign?$Action" regsub -all " " $UrlAction {\&} UrlAction } elseif {$LinkToRivet} { set UrlAction "$RivetLink?$Action WithLinkToRivet_$RivetLink" } else { regsub -all " " $Action {\&} Action set UrlAction "[WscopeScience]&$Action" } lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"] lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"] lappend LeMenu [Html_BaliseClose "td"] } lappend LeMenu [Html_BaliseClose "tr"] lappend LeMenu [Html_BaliseOpen "tr"] foreach {Text Action} $LesBoutons { if {[regexp "Ftype_" $Action]} { regsub "Ftype_" $Action "AvecZonesFtype_" Action set Text "no text" } if {$LinkToHtml || $CreateAllHtml} { set Quoi [lindex [split $Action " "] 2] set Queue [file tail $RacineForAll] set UrlAction "${Queue}_$Quoi.html" if {$CreateAllHtml && ! [info exists DejaFait($Quoi)]} { set WH "" ; if {$WithoutHeader} { set WH "WithoutHeader" } lappend AllHtml [HtmlFromXmlMacsim $FichierXml $Quoi "${WH}WithLinkToHtml_${RacineForAll}_$Quoi.html" $TitreDeLaPage $RacineForAll] } } elseif {$WithLinkToPipealign} { set UrlAction "$LinkToPipealign?$Action" regsub -all " " $UrlAction {\&} UrlAction } elseif {$LinkToRivet} { set UrlAction "$RivetLink/$Action WithLinkToRivet_$RivetLink" } else { regsub -all " " $Action {\&} Action set UrlAction "[WscopeScience]&$Action" } lappend LeMenu [Html_BaliseOpen "td" "bgcolor='yellow' nowrap='nowrap'"] lappend LeMenu [Html_Href $Text $UrlAction "title='Reload alignment'"] lappend LeMenu [Html_BaliseClose "td"] } lappend LeMenu [Html_BaliseClose "tr"] lappend LeMenu [Html_BaliseClose "table"] lappend LeMenu [Html_NewLine] Html_Insert $LaHaut [join $LeMenu "\n"] #rR la fin du if AvecAutresBoutons était là !!!!!!!!!!!!!!!!! pourquoi ?????? set HtmlDejaFait [Html_Get] if {[regexp {(.*)} $HtmlDejaFait Match HeaderMobile]} { regsub "

" Html_BaliseOpen "html" Html_BaliseOpen "head" Html_Title "ARPAnno results" Html_Append "" if {$Header_style != ""} { Html_Append "$Header_style" } #Html_Append "" Html_Append "" Html_Append "" Html_Append "" #Banniere IGBMC ou BIPS ####################### if {[regexp -nocase "bips" [WebServer_Address]]} { #lappend LeTexte "" Html_Append "" Html_Append "" Html_Append " " Html_Append "" Html_Append "" } Html_Append " " Html_Append " " Html_Append " " Html_Append " " Html_Append " " Html_Append " " Html_Append " " Html_Append " " #Html_Append " " #Html_Append " " Html_Append " " Html_Append " " Html_Append " " #Html_Append " " Html_Append " " #Html_Append "

ARPAnno
Go back to ARPAnno
$Texte	$Texte	" return [Html_Get] } proc Html_ARPAnno_END {} { Wup "ARPAnno fin de la page de presentation" Wup "Debut (Html_ARPAnno_BEGIN) TEXTE Fin (Html_ARPAnno_END)" Html_Append "
Help and Supplementary information	Go back to ARPAnno

" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "" Html_Append "

" Html_Append " " Html_Append "" Html_Append "Muller et al (2005) Mol. Biol. Cell. doi: 10.1091/mbc.E05-06-0508" Html_Append "" Html_Append " " Html_Append "

" Html_Append "" Html_Append "" Html_Append "" Html_Append "

---

" Html_Append " If you have any problems or questions, please, feel free to contact us at jean.muller@igbmc.u-strasbg.fr" Html_Append "

---

" Html_BaliseClose "body" Html_BaliseClose "html" return [Html_Get] } proc Html_Append {Texte} { global H lappend H $Texte return $Texte } proc Html_BR {} { return [Html_Append "
"] } proc Html_BackTo {{Nom ""}} { if {$Nom==""} { set Nom [DerniereVisite] } set BackTo {} if {1} { lappend BackTo [Html_Append ""] lappend BackTo [Html_Append "Back to "] } if {[OnTraiteEVImm] || [OnTraiteGGmm] || [OnTraiteGGWmm] || [OnTraiteEVIhs] || [OnTraiteGGhs] || [OnTraiteGGWhs] || [OnTraiteRetGene]} { lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href " Genoret" [GenoretUrl] "title='GenoretDatabase home page'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href " GenoretGenes" [GenoretGenesUrl] "title='GenoretGenes home page'"] } if {1} { lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href " ICube" "http://icube.unistra.fr" "title='ICube - home page'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href " CSTB" "http://icube-cstb.unistra.fr" "title='Complex Systems and Translational Bioinformatics - home page'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href " LBGI" [LbgiUrl] "title='LBGI BioInformatique et Génomique Intégratives - home page'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "WelcomeToWscope" "[WscopeScience]&WelcomeToWscope" "title='Lists all Gscope Projects'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "[Science]" "[WscopeScience]" "title='[Science] general information entry point'"] lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "List" "[WscopeScience]&FileMoi" "title='all entry points for [Science]'"] if {$Nom!=""} { lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "$Nom" "[WscopeScience]&FileMoi&$Nom" "title='See all available data about $Nom'"] } lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "Search" "[WscopeScience]&RechercheMoi" "title='search any word in (the infos files of) [Science]'"] } if {[OnTraiteBalibase]} { lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "BAliBASE home page" "/balibase/index.html"] } if {[OnTraite "KoAnno"]} { lappend BackTo [Html_Append " • "] lappend BackTo [Html_Href "KoAnno home page" "http://lbgi.fr/~brelivet/KoAnno"] } if {1} { lappend BackTo [Html_Append ""] lappend BackTo [Html_NewLine] } return [join $BackTo "\n"] } proc Html_Balise {Texte Balise {Attributs ""}} { set Local {} lappend Local [Html_BaliseOpen $Balise $Attributs] lappend Local [Html_Append $Texte] lappend Local [Html_BaliseClose $Balise] return [join $Local "\n"] } proc Html_BaliseClose {Balise} { return [Html_Append ""] } proc Html_BaliseOpen {Balise {Attributs ""}} { if {$Attributs==""} { set Local "<$Balise>" } else { regsub -all {\\'} $Attributs "SiMpLeQuOtE" Attributs regsub -all {\'} $Attributs "\"" Attributs regsub -all "SiMpLeQuOtE" $Attributs "'" Attributs set Local "<$Balise $Attributs>" } return [Html_Append $Local] } proc Html_Banner {{Qui ""}} { if {$Qui==""} { set Qui "Wscope" } set Banner {} if {$Qui=="Bips"} { lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append "

"] lappend Banner [Html_Append "

"] return $Banner } if {$Qui=="Wscope" && [Science]!="Actinome"} { lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append " "] lappend Banner [Html_Append " "] lappend Banner [Html_Append " "] lappend Banner [Html_Append ""] lappend Banner [Html_Append ""] lappend Banner [Html_Append " "] lappend Banner [Html_Append " "] lappend Banner [Html_Append ""] lappend Banner [Html_Append "

"] lappend Banner [Html_Append " "] lappend Banner [Html_Append "	This page is generated on the fly by Wscope from the Gscope Database [Science]	"] lappend Banner [Html_Append " "] lappend Banner [Html_Append "
	"] lappend Banner [Html_BackTo] lappend Banner [Html_Append "
	[CaVa]

"] lappend Banner [Html_Append ""] set FichierHelp "[Fiches]/help.html" if {[FileAbsent $FichierHelp]} { set FichierHelp "[Fiches]/help.html" } ; #rR ????? faut trouver autre chose !! if {[FileExists $FichierHelp]} { set QueueHelp [file tail $FichierHelp] lappend Banner [Html_Append "

Get Help

"] } return [join $Banner "\n"] } } proc Html_BeginBody {} { global WithLogoBing set BeginBody "" if {[info exists WithLogoBing] && $WithLogoBing=="WithLogoBing"} { append BeginBody "\n[H_LogoBInG]" } return [Html_Append $BeginBody] } proc Html_BeginHtml {} { return [Html_Append ""] } proc Html_BeginHtmlManu {BgColor Font} { set Begin "" # set Doctype "" set Doctype "" return [Html_Append $Doctype] } proc Html_DuFichierJpg {Fichier} { #attention ne marche pas ..... set Queue [file tail $Fichier] lappend H "Content-type: image/jpeg" lappend H "Content-Disposition: inline; filename=\"$Queue\"" lappend H "Content-Transfer-Encoding: binary" lappend H "" lappend H [ContenuDuFichier $Fichier] return [join $H "\n"] } proc Html_DuScript {ScriptOuFichier} { if {$ScriptOuFichier==""} { return "" } if {[regexp " " $ScriptOuFichier]} { set Script $ScriptOuFichier } else { set Script [ContenuDuFichier $ScriptOuFichier] } lappend ToutScript "" set ToutScript [join $Script "\n"] return [Html_Append $ToutScript] } proc Html_DuTexteTelQuel {TexteOuNomDuFichier {Titre ""} {Header ""} {RefDocType ""}} { if {[regexp " " $TexteOuNomDuFichier] || ! [file exists $TexteOuNomDuFichier]} { set NomDuFichier "Raw text" set Texte $TexteOuNomDuFichier } else { set NomDuFichier $TexteOuNomDuFichier set Texte [ContenuDuFichier $NomDuFichier] } if {$Titre==""} { set Titre $NomDuFichier } if {[regexp {^ *<\?xml} $Texte]} { return $Texte } lappend Local [Html_Zero] lappend Local [Html_Doctype $RefDocType] lappend Local [Html_BeginHtml] lappend Local [Html_Header $Titre $Header] lappend Local [Html_BeginBody] lappend Local [Html_Teletype $Texte] lappend Local [Html_EndBody] lappend Local [Html_EndHtml] Html_Zero return [join $Local "\n"] } proc Html_Encapsule {TexteHtml {Titre ""} {Header ""} {RefDocType ""}} { lappend Local [Html_ZeroToBody $Header $RefDocType] lappend Local [Html_Append $TexteHtml] lappend Local [Html_BodyToEnd] return [join $Local "\n"] } proc Html_EndBody {} { return [Html_Append ""] } proc Html_EndHtml {} { return [Html_Append ""] } proc Html_Get {{ZeroIt ""}} { return [join [Html_lGet $ZeroIt] "\n"] } proc Html_GetPosition {} { global H return [llength $H] } proc Html_Header {{Titre ""} {Header ""}} { lappend Local [Html_Append ""] lappend Local [Html_Append ""] lappend Local [Html_Title "$Titre"] lappend Local [Html_UTF8] if {$Header!=""} { lappend Local [Html_Append $Header] } if {[PourWscope]} { lappend Local [Html_Append [CssWscope]] } lappend Local [Html_Append ""] return [join $Local "\n"] } proc Html_Href {Texte Url {AutresAttributs ""}} { return [Html_Append [H_Href $Texte $Url $AutresAttributs]] } proc Html_Insert {Ici Texte} { global H set H [linsert $H $Ici $Texte] return $Texte } proc Html_ListOfRefs {LesRefText {Titre ""} {PleaseSplitText ""}} { if {$PleaseSplitText=="PleaseSplitText"} { set PleaseSplitText 1 } else { set PleaseSplitText 0 } Html_ZeroToBody Html_Banner Wscope # Html_Append "

" # Html_Append "

" Html_Append $Titre lassign $LesRefText Ref0 Text0 set NbColonnes 1 if {$PleaseSplitText} { set NbColonnes [llength [split $Text0 "\t"]] } lappend Liste $NbColonnes lappend Liste "border='1' font-size='75%' cellpadding='3' cellspacing='1' class='wscope_table' style='margin:0 auto'" lappend Liste "" foreach I [NombresEntre 1 $NbColonnes] { set Couleur [CouleurDuNuancier $I $NbColonnes 0.3 0.1 "hexa" 0.7] lappend Liste "bgcolor='$Couleur' nowrap='nowrap'" } foreach {Ref Text} $LesRefText { if {$PleaseSplitText} { set PremiereFois 1 foreach Champ [split $Text "\t"] { if {$PremiereFois} { lappend Liste [H_Href $Champ $Ref] set PremiereFois 0 continue } lappend Liste $Champ } } else { lappend Liste [H_Href $Text $Ref] } } Html_TableFromList $Liste # Html_Append "

" Html_BodyToEnd return [Html_Get] } proc Html_Listbox {Texte {Fenetre ""} {Titre ""} {Maniere ""}} { global VariableToSetForWscope set VariableToSet "" if {[info exists VariableToSetForWscope]} { set VariableToSet $VariableToSetForWscope } set ClasseDuSelect "" if {[regexp "AvecRetour" $Maniere]} { set ClasseDuSelect "style='background:lightgreen;'" } set LesOptions {} set BonTexte [Html_Teletype $Texte "WithoutPre"] set Width 50 set NbLignes 5 foreach Ligne [split $BonTexte "\n"] { set Width [Maxi $Width [string length $Ligne]] regsub -all " " $Ligne {\ } LigneAvecBlanc regsub -all {\*} $Ligne "\%2A" Ligne lappend LesOptions "$LigneAvecBlanc" incr NbLignes } set Options [join $LesOptions "\n"] incr Width 2 if {$Width >70} { set Width 70 } set Height $NbLignes if {$Height>40} { set Height 40 } regsub -all {[\.\-]} $Fenetre "_" Fenetre lappend Local "" lappend Local "

" lappend Local "

" lappend Local "" lappend Local "" lappend Local "" lappend Local "" lappend Local "" lappend Local "" lappend Local "" lappend Local "

" lappend Local [Html_TouchePour [TouchePourWscope "LesBoutonsDeLaFenetre" $Fenetre]] lappend Local "

" if {[regexp "PourInforme" $Maniere]} { lappend Local "" lappend Local $BonTexte lappend Local "" } else { lappend Local "" lappend Local $Options lappend Local "" } lappend Local "

" lappend Local "

" lappend Local "

" return [join $Local "\n"] } proc Html_NewLine {{Texte ""}} { return [Html_Append "
\n$Texte"] } proc Html_SymTree {LesGD} { #rR Crée un html avec deux colonnes, celle de gauche cadrée à droite et inversement (en sapin). set Css " " set LeHtml {} lappend LeHtml $Css lappend LeHtml "" lappend LeHtml " " foreach {G D} $LesGD { if {$G==""} { set G " " } if {$D==""} { set D " " } lappend LeHtml " " lappend LeHtml " " lappend LeHtml " " lappend LeHtml " " } lappend LeHtml " " lappend LeHtml "

" lappend LeHtml $G lappend LeHtml "

" lappend LeHtml $D lappend LeHtml "

" set Html [join $LeHtml "\n"] return $Html } proc Html_TableFromList {Liste} { set NbColonnes [lindex $Liste 0] set AttTable [lindex $Liste 1] set AttLigne [lindex $Liste 2] foreach C [NombresEntre 0 [expr $NbColonnes - 1]] { set AttColon($C) [lindex $Liste [expr $C + 3]] } set DebutValeurs [expr $NbColonnes + 3] lappend Local [Html_BaliseOpen "table" $AttTable] set C 0 foreach Valeur [lrange $Liste $DebutValeurs end] { if {$C==0} { set TdTh "td" if {[regexp "^Please_TH_" $Valeur]} { regsub "^Please_TH_" $Valeur "" Valeur set TdTh "th" } lappend Local [Html_BaliseOpen "tr" $AttLigne] } lappend Local [Html_BaliseOpen $TdTh $AttColon($C)] lappend Local [Html_Append $Valeur] lappend Local [Html_BaliseClose $TdTh] set C [expr ($C+1)%$NbColonnes] if {$C==0} { lappend Local [Html_BaliseClose "tr"]} } lappend Local [Html_BaliseClose "table"] return [join $Local "\n"] } proc Html_Teletype {Texte {WithoutPre ""}} { set BonTexte $Texte set Remettre 0 set LesD {} set LesX {} while {[set D [string first "<<=0} { set Remettre 1 set F [string first "KeepChevrons>>>" $BonTexte] incr F [string length "KeepChevrons>>>"] set X [string range $BonTexte $D $F] regsub "<<>>" $X "" X set BonTexte [string replace $BonTexte $D $F "ChevronsARemettreIciMerci"] lappend LesX $X } regsub -all "&" $BonTexte {\&} BonTexte regsub -all "<" $BonTexte {\<} BonTexte regsub -all ">" $BonTexte {\>} BonTexte if {$Remettre} { foreach X $LesX { set D [string first "ChevronsARemettreIciMerci" $BonTexte] set F [expr $D + [string length "ChevronsARemettreIciMerci"] - 1] set BonTexte [string replace $BonTexte $D $F $X] } } if {[string equal -nocase $WithoutPre "WithoutPre"]} { return $BonTexte } set Teletype "

\n$BonTexte\n

" return [Html_Append $Teletype] } proc Html_TextToListbox {{TexteOuNomDuFichier ""} {Fenetre ""} {Titre ""} {Header ""} {RefDocType ""} {Maniere ""}} { if {[regexp " " $TexteOuNomDuFichier] || ! [file exists $TexteOuNomDuFichier]} { set NomDuFichier "Raw text" set Texte $TexteOuNomDuFichier } else { set NomDuFichier $TexteOuNomDuFichier set Texte [ContenuDuFichier $NomDuFichier] } if {$Titre==""} { set Titre $NomDuFichier } lappend Local [Html_Zero] lappend Local [Html_Doctype $RefDocType] lappend Local [Html_BeginHtml] lappend Local [Html_Header $Titre $Header] lappend Local [Html_BeginBody] lappend Local [Html_Banner Wscope] lappend Local [Html_Append "

$Titre

"] lappend Local [Html_Listbox $Texte $Fenetre $Titre $Maniere] lappend Local [Html_EndBody] lappend Local [Html_EndHtml] Html_Zero return [join $Local "\n"] } proc Html_TheEnd {} { set TheEnd "\n" return [Html_Append $TheEnd] } proc Html_Title {{Titre ""}} { if {$Titre==""} { set Titre "[Science] Wscope" } lappend Local [Html_Append ""] return [join $Local "\n"] } proc Html_TouchePour {LesBoutons} { set Local {} lappend Local "

" set CreateDiv 1 set CloseDiv 0 foreach Bouton $LesBoutons { lassign $Bouton Clavier Texte Commande Maniere Couleur if {$Couleur=="grey"} { set Couleur "lightgrey" } if {$Couleur=="green"} { set Couleur "lightgreen" } if {$Clavier=="NouvelleGamme"} { if {$CloseDiv} { lappend Local "

" ; set CloseDiv 0 } set CreateDiv 1 continue } regsub "^ */" $Texte "" NiceTexte set W1 "30ex" set W21 "16ex" ; set W22 "14ex" set W31 "16ex" ; set W32 "8ex" ; set W33 "6ex" set OnClique "onclick='jeClique(\"$NiceTexte\");'" if {[regexp "^onclick='" $Commande]} { regsub "^onclick='" $Commande "onclick='jeClique(\"$NiceTexte\");" OnClique } set B "" if {[regexp "^ */" $Texte]} { set OldB [lindex $Local end] if {[regexp "width:$W1;" $OldB]} { regsub "width:$W1;" $OldB "width:$W21;" NewOldB set Local [lreplace $Local end end] regsub "width:$W1;" $B "width:$W22;" B set B $NewOldB$B } if {[regexp "width:$W22;" $OldB]} { regsub "width:$W22;" $OldB "width:$W32;" OldB regsub "width:$W21;" $OldB "width:$W31;" OldB set Local [lreplace $Local end end] regsub "width:$W1;" $B "width:$W33;" B set B $OldB$B } lappend Local $B continue } if {$CreateDiv} { lappend Local "

" set CloseDiv 1 set CreateDiv 0 } else { lappend Local "
" } lappend Local $B } if {$CloseDiv} { lappend Local "

" ; set CloseDiv 0} lappend Local "

" return [join $Local "\n"] } proc Html_TranscriptVariants {Box {FromBodyToEnd ""}} { #set refpfaminitial 0 Espionne "$Box" set FromBodyToEnd [regexp -nocase "FromBodyToEnd" $FromBodyToEnd] if {$FromBodyToEnd} { set Titre "Transcript Variants" Html_ZeroToBody $Titre Html_Append "

$Titre

" Html_Append "
" } if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set Org Mouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set Org Rat } else { set Org SpliRet } if {$Org=="SpliRet"} { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit"} } else { #set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit" set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" #if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"} if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} set FileBilan "[RepertoireDuGenome]/BilanPerteGain/$Box" } set LesPfamNettoyeDeLaRef {}; set LesPfamStartStop {}; array unset DejaVu; set LesNamesTotal {}; array unset LesLongueurs set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set Tag [ExtraitInfo $Box "Tag"] set Gn [ExtraitInfo $Box "ValiGN"] set GN [string toupper $Gn] set Des [ExtraitInfo $Box "ValiDE"] Html_Append "" Html_Append [H_Balise [H_Bold "$Cluster $Box ($Tag)"] H2] Html_Append "" Html_Append "[H_Bold $Gn]" Html_Append "     GeneCards" Html_Append "     ECgene" Html_Append "      $Des" Html_Append "
" Html_Append "
" if {![file exists $FileMacsims]} { Html_Append "no macsims" Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" set Texte [Html_Get] return $Texte } set LesNames [InterrogeNames $Cluster Name $Org] set RefPfam [ExtraitInfo $Box "RefPfam"] #set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims] LConcat LesNamesTotal $LesNames LConcat LesNamesTotal $RefPfam LConcat LesNamesTotal $Box set LesNamesTotal [ListeSansDoublon $LesNamesTotal] InitPosRel2Abs $FileMacsims $LesNamesTotal set LesPfamInfoRef [FromMacsims $FileMacsims $RefPfam "ConcatPfam"] #Html_Append "$LesPfamInfoRef" #Html_Append "
" foreach PfamInfoRef $LesPfamInfoRef { set MotsPfamInfoRef [split $PfamInfoRef "/"] set Pfam [lindex $MotsPfamInfoRef 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id" lappend LesPfamNettoyeDeLaRef $PfamNettoye FstartFstop $PfamInfoRef RFstart RFstop set Start [DonnePosRA $RefPfam $RFstart Absolue] set Stop [DonnePosRA $RefPfam $RFstop Absolue] set PfSS "$Id $Start $Stop" lappend LesPfamStartStop $PfSS set PossedePfSS($RefPfam,$PfSS) 1 } foreach PfamNettoyeDeLaRef $LesPfamNettoyeDeLaRef { if {[info exists DejaVu($PfamNettoyeDeLaRef)]} { incr DejaVu($PfamNettoyeDeLaRef) } else { set DejaVu($PfamNettoyeDeLaRef) 1 } } Html_Append "[H_Bold "Reference PFAM:"] $RefPfam" Html_Append "
" foreach Clef [array names DejaVu] { #Espionne "$Clef $DejaVu($Clef)" set Des [InterrogePfamDesFrom1500 $Clef Des] Html_Append "$DejaVu($Clef) $Clef: $Des" Html_Append "
" } foreach Name $LesNames { if {$Name==$Ref} {set Name $Box} #if {$Name==$RefPfam} {set refpfaminitial 1} set LesPfamInfoName [FromMacsims $FileMacsims $Name "ConcatPfam"] foreach PfamInfoName $LesPfamInfoName { set MotsPfamInfoName [split $PfamInfoName "/"] set Pfam [lindex $MotsPfamInfoName 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id $PfamName" FstartFstop $PfamInfoName RFstart RFstop set Start [DonnePosRA $Name $RFstart Absolue] set Stop [DonnePosRA $Name $RFstop Absolue] set PfSS "$Id $Start $Stop" lappend LesPfamStartStop $PfSS set PossedePfSS($Name,$PfSS) 1 } } set LesPfamStartStop [lsort -unique $LesPfamStartStop] set LesPfamStartStop [lsort -command TriePfSS $LesPfamStartStop] set LaCourante $LesPfamStartStop set collapse 1 while {$collapse} { if {[llength $LaCourante]<2} {break} set lA [lrange $LaCourante 0 end-1] set lB [lrange $LaCourante 1 end] set i -1 foreach A $lA B $lB { DecortiquePfSS $A PfA StartA StopA DecortiquePfSS $B PfB StartB StopB if {$PfA!=$PfB || ! [Recouvrement $StartA $StopA $StartB $StopB]} { set collapse 0 incr i continue } set StartN [Mini $StartA $StartB] set StopN [Maxi $StopA $StopB] set N "$PfA $StartN $StopN" lappend LesAnciens($N) $A $B if {[info exists LesAnciens($A)]} { #Espionne "A existe: $A values= $LesAnciens($A)" set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($A)]] } if {[info exists LesAnciens($B)]} { #Espionne "B existe: $B values= $LesAnciens($B)" set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($B)]] } foreach Ancien [array names LesAnciens] { #Espionne "$Ancien=$LesAnciens($Ancien)" } set collapse 1 break } if { ! $collapse } { break } set LaCourante [lreplace $LaCourante [expr $i+1] [expr $i+2] $N] #Espionne "LaCourante $LaCourante" } set LesPfamStartStopCollapse $LaCourante #Espionne "LesPfamStartStopCollapse $LesPfamStartStopCollapse" foreach Ancien [array names LesAnciens] { #Espionne "$Ancien=$LesAnciens($Ancien)" } #Espionne "" Html_Append "

"
    set TextePfSS [join $LesPfamStartStopCollapse "\t"]
    set TextePfSS [regsub -all " " $TextePfSS "-"]
    set TextePfSS [regsub -all "\t" $TextePfSS "....."]
    Html_Append [MiseEnLigneTR "AllPFAMs" : $TextePfSS "b"]
#	Html_Append [MiseEnLigneTR [H_Bold "AllPfam"] : $TextePfSS]

    foreach PfSS $LesPfamStartStopCollapse {
	if {[info exists LesAnciens($PfSS)]} {
	    set Result [DetermineLeStringLePlusLong $LesAnciens($PfSS)]
	    set longmax [lindex [split $Result "\t"] 1]
	    set LesLongueurs($PfSS) $longmax
	} else {
	    set longmax [string length $PfSS]
	    set LesLongueurs($PfSS) $longmax
	}
    }
    
    set LaRefEtLesNames [concat [list $RefPfam] $LesNames]
    set LaRefEtLesNames [ListeSansDoublon $LaRefEtLesNames]
    foreach Chacun $LaRefEtLesNames {
	#Espionne ""
	#Espionne "Chacun $Chacun"
	set Met ""
	#if $Chacun!=$RefPfam || $refpfaminitial 
	if {$Chacun!=$RefPfam} {
	    set PremierAA [YatilUneMet $Org $Cluster $Chacun]
	    if {$PremierAA=="M"} {set Met "AcMet"}
	    if {$PremierAA!="M"} {set Met "SsMet"}
	}
	if {$Chacun==$Ref} {set Chacun $Box}
	set  LesPfamStartStopDeChacun {}
	foreach PfSS $LesPfamStartStopCollapse {
	    set Mot $PfSS
	    #Espionne "1er Mot $Mot"
	    if { ! [info exists PossedePfSS($Chacun,$PfSS)]} {
		#Espionne "onentre"
		set Mot [string repeat "." $LesLongueurs($PfSS)]
		#Espionne "Mot $Mot"
	    }
	    if {[info exists LesAnciens($PfSS)]} {
		#Espionne "on entre2"
		foreach Ancien $LesAnciens($PfSS) {
		    #Espionne "Ancien $Ancien"
		    if {[info exists PossedePfSS($Chacun,$Ancien)]} {
			#Espionne "on entre3"
			#Espionne "Mot $Mot"
			set Mot [string range "$Ancien......." 0 [expr $LesLongueurs($PfSS) - 1]]
			#Espionne "Mot $Mot"
			break
		    }
		}
	    }
	    lappend LesPfamStartStopDeChacun $Mot
	}
	#Espionne "LesPfamStartStopDeChacun $LesPfamStartStopDeChacun"
	set TextePfSSDeChacun [join $LesPfamStartStopDeChacun "\t"]
	set TextePfSSDeChacun [regsub -all " " $TextePfSSDeChacun "-"]
	set TextePfSSDeChacun [regsub -all "\t" $TextePfSSDeChacun "....."]
	#[H_Italic $Met]
	if {$Chacun==$Box} {
	    Html_Append [MiseEnLigneTR "$Chacun ($Ref) $Met" : $TextePfSSDeChacun]
	} else {
	    Html_Append [MiseEnLigneTR "$Chacun $Met" : $TextePfSSDeChacun]
	}
    }
    if {![file exists $FileBilan]} {
	Html_Append "

" Html_Append "

"
	Html_Append "Summary not made"
    } else {
	set PerdPfam "No"; set GagnePfam "No"; set PerdBlockDsPfam "No"; set PerdPrositeDsPfam "No"
	set PerdFragmentEntreBlockDsPfam "No"; set PerdFragmentDsBlockDsPfam "No"; set PerdFragmentDsPrositeDsPfam "No"
	foreach Line [LesLignesDuFichier $FileBilan] {
	    set LesMots [split $Line " "]
	    if {[lindex $LesMots 1] == "gagne" && [regexp "^\"PF" [lindex $LesMots 2]]} {
		set GagnePfam "Yes"
	    }
	    if {[lindex $LesMots 1] == "perd"} {
		if {[regexp "^\"PF" [lindex $LesMots 2]]} {
		    set PerdPfam "Yes"
		} elseif {[regexp "BLOCK" [lindex $LesMots 2]]} {
		    set PerdBlockDsPfam "Yes"
		} elseif {[regexp "^\"PS" [lindex $LesMots 2]]} {
		    set PerdPrositeDsPfam "Yes"
		} elseif {[regexp "^\"Fragment" [lindex $LesMots 2]]} {
		    if {[lindex $LesMots 4] == "entre"} {
			set PerdFragmentEntreBlockDsPfam "Yes"
		    } elseif {[lindex $LesMots 4] == "dans"} {
			if {[regexp "BLOCK" [lindex $LesMots 5]]} {
			    set PerdFragmentDsBlockDsPfam "Yes"
			} elseif {[regexp "^PS" [lindex $LesMots 5]]} {
			    set PerdFragmentDsPrositeDsPfam "Yes"
			}
		    }
		}
	    }
	}
	Html_Append "

" Html_Append "

"
	Html_Append "Summary:"
	Html_Append "PerdPfam                      $PerdPfam"
	Html_Append "GagnePfam                     $GagnePfam"
	Html_Append "PerdBlockDsPfam               $PerdBlockDsPfam"
	Html_Append "PerdPrositeDsPfam             $PerdPrositeDsPfam"
	Html_Append "PerdFragmentEntreBlockDsPfam  $PerdFragmentEntreBlockDsPfam"
	Html_Append "PerdFragmentDsBlockDsPfam     $PerdFragmentDsBlockDsPfam"
	Html_Append "PerdFragmentDsPrositeDsPfam   $PerdFragmentDsPrositeDsPfam"
    }
    Html_Append "

" Html_Append "Details" Html_Append "
" Html_Append "MACSIMS with Jalview" Html_Append "      Create Radar for all experiments with software RMA" Html_Append " or dChip" if {$FromBodyToEnd} { Html_BodyToEnd set Texte [Html_Get "ZeroIt"] } else { Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" set Texte [Html_Get] } return $Texte } proc Html_TranscriptVariantsOld {Box {FromBodyToEnd ""}} { set refpfaminitial 0 set FromBodyToEnd [regexp -nocase "FromBodyToEnd" $FromBodyToEnd] if {$FromBodyToEnd} { set Titre "Transcript Variants" Html_ZeroToBody $Titre Html_Append "

$Titre

" Html_Append "
" } if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set Org Mouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set Org Rat } else { set Org SpliRet } if {$Org=="SpliRet"} { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit"} } else { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"} } set LesPfamNettoyeDeLaRef {}; set LesPfamStartStop {}; array unset DejaVu set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set LesNames [InterrogeNames $Cluster Name $Org] set RefPfam [ExtraitInfo $Box "RefPfam"] set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims] set Gn [ExtraitInfo $Box "ValiGN"] set Des [ExtraitInfo $Box "ValiDE"] Html_Append "" Html_Append [H_Balise [H_Bold "$Cluster $Box"] H2] Html_Append "" Html_Append "[H_Bold $Gn]" Html_Append "     GeneCards" Html_Append "      $Des" Html_Append "
" Html_Append "
" set LesPfamInfoRef [FromMacsims $FileMacsims $RefPfam "Concat"] set SeqDataRef [FromMacsims $FileMacsims $RefPfam "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataRef #Html_Append "$LesPfamInfoRef" #Html_Append "
" foreach PfamInfoRef $LesPfamInfoRef { set MotsPfamInfoRef [split $PfamInfoRef "/"] set Pfam [lindex $MotsPfamInfoRef 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id $PfamName" lappend LesPfamNettoyeDeLaRef $PfamNettoye FstartFstop $PfamInfoRef RFstart RFstop set Start [PositionAbsolueDansAlignement $RFstart] set Stop [PositionAbsolueDansAlignement $RFstop] set PfSS "$Id $Start $Stop" lappend LesPfamStartStop $PfSS set PossedePfSS($RefPfam,$PfSS) 1 } foreach PfamNettoyeDeLaRef $LesPfamNettoyeDeLaRef { if {[info exists DejaVu($PfamNettoyeDeLaRef)]} { incr DejaVu($PfamNettoyeDeLaRef) } else { set DejaVu($PfamNettoyeDeLaRef) 1 } } Html_Append "[H_Bold "PFAMs of Reference:"] $RefPfam" Html_Append "
" foreach Clef [array names DejaVu] { set MotsClef [split $Clef " "] set Id [lindex $MotsClef 0] Html_Append "$DejaVu($Clef) $Clef" Html_Append "
" } foreach Name $LesNames { if {$Name==$Ref} {set Name $Box} if {$Name==$RefPfam} {set refpfaminitial 1} set LesPfamInfoName [FromMacsims $FileMacsims $Name "Concat"] set SeqDataName [FromMacsims $FileMacsims $Name "SeqData"] PositionAbsolueDansAlignement 1 $SeqDataName foreach PfamInfoName $LesPfamInfoName { set MotsPfamInfoName [split $PfamInfoName "/"] set Pfam [lindex $MotsPfamInfoName 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id $PfamName" lappend LesPfamNettoyeDeLaName $PfamNettoye FstartFstop $PfamInfoName RFstart RFstop set Start [PositionAbsolueDansAlignement $RFstart] set Stop [PositionAbsolueDansAlignement $RFstop] set PfSS "$Id $Start $Stop" lappend LesPfamStartStop $PfSS set PossedePfSS($Name,$PfSS) 1 } } set LesPfamStartStop [lsort -unique $LesPfamStartStop] set LesPfamStartStop [lsort -command TriePfSS $LesPfamStartStop] set LaCourante $LesPfamStartStop set collapse 1 while {$collapse} { if {[llength $LaCourante]<2} {break} set lA [lrange $LaCourante 0 end-1] set lB [lrange $LaCourante 1 end] set i -1 foreach A $lA B $lB { DecortiquePfSS $A PfA StartA StopA DecortiquePfSS $B PfB StartB StopB if {$PfA!=$PfB || ! [Recouvrement $StartA $StopA $StartB $StopB]} { set collapse 0 incr i continue } set StartN [Mini $StartA $StartB] set StopN [Maxi $StopA $StopB] set N "$PfA $StartN $StopN" lappend LesAnciens($N) $A $B set collapse 1 break } if { ! $collapse } { break } set LaCourante [lreplace $LaCourante [expr $i+1] [expr $i+2] $N] } set LesPfamStartStopCollapse $LaCourante Html_Append "

"
    set TextePfSS [join $LesPfamStartStopCollapse "\t"]
    set TextePfSS [regsub -all " " $TextePfSS "-"]
    set TextePfSS [regsub -all "\t" $TextePfSS "....."]
    Html_Append [MiseEnLigneTR "AllPFAMs" : $TextePfSS "b"]
#	Html_Append [MiseEnLigneTR [H_Bold "AllPfam"] : $TextePfSS]
    
    set LaRefEtLesNames [concat [list $RefPfam] $LesNames]
    set LaRefEtLesNames [ListeSansDoublon $LaRefEtLesNames]
    foreach Chacun $LaRefEtLesNames {
	set Met ""
	if {$Chacun!=$RefPfam || $refpfaminitial} {
	    set PremierAA [YatilUneMet $Cluster $Chacun]
	    if {$PremierAA=="M"} {set Met "AcMet"}
	    if {$PremierAA!="M"} {set Met "SsMet"}
	}
	if {$Chacun==$Ref} {set Chacun $Box}
	set  LesPfamStartStopDeChacun {}
	foreach PfSS $LesPfamStartStopCollapse {
	    set Mot $PfSS
	    if { ! [info exists PossedePfSS($Chacun,$PfSS)]} {set Mot [regsub -all "." $Mot "."]}
	    if {[info exists LesAnciens($PfSS)]} {
		foreach Ancien $LesAnciens($PfSS) {
		    if {[info exists PossedePfSS($Chacun,$Ancien)]} {
			set Mot [string range "$Ancien......." 0 [expr [string length $PfSS]-1]]
			break
		    }
		}
	    }
	    lappend LesPfamStartStopDeChacun $Mot
	}
	set TextePfSSDeChacun [join $LesPfamStartStopDeChacun "\t"]
	set TextePfSSDeChacun [regsub -all " " $TextePfSSDeChacun "-"]
	set TextePfSSDeChacun [regsub -all "\t" $TextePfSSDeChacun "....."]
	#[H_Italic $Met]
	if {$Chacun==$Box} {
	    Html_Append [MiseEnLigneTR "$Chacun ($Ref) $Met" : $TextePfSSDeChacun]
	} else {
	    Html_Append [MiseEnLigneTR "$Chacun $Met" : $TextePfSSDeChacun]
	}
    }
    Html_Append "

" Html_Append "Resume" Html_Append "
" Html_Append "MACSIMS with Jalview" Html_Append "      Create Radar for all experiments with software RMA" Html_Append " or dChip" if {$FromBodyToEnd} { Html_BodyToEnd set Texte [Html_Get "ZeroIt"] } else { Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" Html_Append "
" set Texte [Html_Get] } return $Texte } proc Html_UTF8 {} { return [Html_Append ""] } proc Html_Zero {} { global H set H {} return {} } proc Html_ZeroToBody {{Titre ""} {Header ""} {RefDocType ""}} { lappend Local [Html_Zero] lappend Local [Html_Doctype $RefDocType] lappend Local [Html_BeginHtml] lappend Local [Html_Header $Titre $Header] lappend Local [Html_BeginBody] return [join $Local "\n"] } proc Html_lGet {{ZeroIt ""}} { global H if {$ZeroIt!="ZeroIt"} { return $H } set Tmp $H set H {} return $Tmp } proc HttpCopy {url {aliste ""} {Query ""} {args ""}} { #rR existe dans ordali/src/ordali_web.tcl et gscope/gscope_html.tcl #rR si aliste est vide on return la liste sinon #rR on return 1 et la liste dans liste #rR moumou traite aussi les redirections (jusqu'a 5 imbriquees) #rR Si jamais ca ne marche pas voir s'il n'y a pas un autre #rR HttpCopy dans un gscopublic ... #lm #lm change tous les retours pour inclure #lm ::http::cleanup qui libere la memoire #lm voir wiki if {[string range $url 0 4] eq "https"} { package require tls ::tls::init -ssl2 false -ssl3 false -tls1 true http::register https 443 tls::socket } if {$aliste eq ""} { set NothingFound "" } else { set NothingFound 0 upvar $aliste liste set liste {} } set timeout 30000 # query est une string retour de formatQuery if {$Query ne ""} { #set err [catch {set token [::http::geturl $url -timeout $timeout -query $Query]} Msg] set err [catch {set token [::http::geturl $url -query $Query]} Msg] } else { #set err [catch {set token [::http::geturl $url -timeout $timeout]} Msg] set err [catch {set token [::http::geturl $url]} Msg] } if {[info exists token]} { ::http::wait $token set Dtoken $token set ncode [::http::ncode $token] set status [::http::status $token] if {$status eq "timeout"} { set err 1 } } else { set Dtoken "none" set status "Not applicable" set ncode "No token" } #puts "ncode $ncode" #puts "status $status" #puts "Dtoken $Dtoken" if {$err || ($ncode < 200 || $ncode > 302)} { # we should clean anyway ... if {[info exists token]} { ::http::cleanup $token # ncode = 400 is a 'Bad request' if {$ncode == 400} { unset -nocomplain ::TryErrorNTimes return $NothingFound } } incr ::TryErrorNTimes if {$::TryErrorNTimes > 5} { Espionne "\n----------------------------" Espionne "Msg : $Msg" Espionne "Url : $url" Espionne "Query : $Query" Espionne "Status: $status" Espionne "Code : $ncode" Espionne "Lev 0 : [info level 0]" catch {Espionne "Lev-1 : [info level -1]"} Espionne "----------------------------\n" unset -nocomplain ::TryErrorNTimes update return $NothingFound } after 3000 update # same player shoot again return [HttpCopy $url $aliste $Query] } set WithLocation [regexp -nocase {(^| )Location ([^ ]+)( |$)} [::http::meta $token] Match a urlLocation] if { ! $WithLocation} { #rR Cas general # Data de la page set liste [split [::http::data $token] "\n"] ::http::cleanup $token unset -nocomplain ::TryHttpCopyNTimes update if {$aliste ne ""} { return 1 } else { return [join $liste "\n"] } } #rR the following is to handle URL redirects set Location $urlLocation #lm on va re-creer un token, clean this one ::http::cleanup $token update incr ::TryHttpCopyNTimes if {$::TryHttpCopyNTimes > 5} { unset -nocomplain ::TryHttpCopyNTimes update return $NothingFound } set RetourRecursif [HttpCopy [string trim $Location] $aliste $Query] unset -nocomplain ::TryHttpCopyNTimes update return $RetourRecursif } proc HttpCopyRR {url {aliste ""} {Query ""}} { #rR existe dans ordali/ordali_web.tcl et gscope/gscope_html.tcl #rR si aliste est vide on return la liste sinon #rR on return 1 et la liste dans liste #rR moumou traite aussi les redirections (jusqu'a 5 imbriquees) #rR Si jamais ca ne marche pas voir s'il n'y a pas un autre #rR HttpCopy dans un gscopublic ... #lm #lm change tous les retours pour inclure #lm ::http::cleanup qui libere la memoire #lm voir wiki if {$aliste eq ""} {set NothingFound 0} {set NothingFound ""} if {$aliste ne ""} {upvar $aliste liste} if {$Query ne ""} { set token [::http::geturl $url -query $Query] } else { set token [::http::geturl $url] } upvar #0 $token state set liste [split $state(body) "\n"] set iLocation [lsearch -exact $state(meta) "location"] #Espionne $state(meta) set SansLocation [expr {$iLocation < 0}] if { $SansLocation} { #rR Cas general ::http::cleanup $token if {$aliste ne ""} { return 1 } else { if {[info exists ::TryHttpCopyNTimes]} { unset ::TryHttpCopyNTimes } return [join $liste "\n"] } } #rR the following is to handle URL redirects set Location [lindex $state(meta) [incr iLocation]] incr ::TryHttpCopyNTimes if {$::TryHttpCopyNTimes > 5} { ::http::cleanup $token unset ::TryHttpCopyNTimes return $NothingFound } ::http::cleanup $token set RetourRecursif [HttpCopy [string trim $Location] $aliste] unset ::TryHttpCopyNTimes return $RetourRecursif } proc HttpCopyVieuxDeMoumou {url {aliste ""}} { global Ntimes if {$aliste!=""} { upvar $aliste liste } if {[catch {::http::geturl $url} token]} { #puts "Error $url : bad url or no network" return 0 } upvar #0 $token state unset token set liste [split $state(body) "\n"] foreach {name value} $state(meta) { if {[regexp -nocase ^location$ $name]} { if {! [info exists Ntimes]} { set Ntimes 1 } else { if {$Ntimes < 5} { incr Ntimes } else { return 0 } } # Handle URL redirects puts "Location: $value" unset state return [HttpCopy [string trim $value] liste] } } unset state # return 1 #rR prefererait liste au lieu de 1 return $liste } proc HttpGetTextFromUrl {Url} { set token [::http::geturl $Url -timeout 1000000] upvar #0 $token State ::http::cleanup $token unset token return $State(body) } proc HttpGetTextFromUrlRR {Url} { set token [::http::geturl $Url -timeout 1000000] upvar #0 $token State unset token return $State(body) } proc HttpGetUrl {{Url ""} {Query ""}} { if {$Url==""} { set Url "http://www.lbgi.fr/" } if {$Query==""} { set token [::http::geturl $Url -timeout 1000000 ] } else { # Quand on met -query il fait un POST sinon GET set token [::http::geturl $Url -query $Query -timeout 1000000 ] } return [::http::data $token] } proc HttpProgress {args} { puts -nonewline stderr . ; flush stderr return } proc HttpProgressRR {args} { puts -nonewline stderr . ; flush stderr return } proc HttpReferer {} { package require http set referer [::http::header "Referer"] return $referer } proc HumanFromMouse {{Qui ""} {Quoi ""}} { if {$Qui==""} { set Qui "ListOf" } if {[string equal -nocase $Qui "ListOf"]} { if {[string equal -nocase $Quoi "MouseHeader"]} { return [MGI ListOf Header] } if {[string equal -nocase $Quoi "HumanHeader"]} { return [HGNC ListOf Header] } } set M [MGI $Qui MGIID] Espionne "M $M" set H [MGIHGNC $M HGNCID] Espionne "H $H" if {$H==""} { set H [MGIHGNC $Qui HGNCID] } if {$H==""} { set H [HGNC $Qui HGNC_ID]} return [HGNC $H $Quoi] } proc HumanGenomeDir {{Repertoire ""}} { global env global HumanGenomeDir if {$Repertoire!=""} { set HumanGenomeDir $Repertoire } if { ! [info exists HumanGenomeDir]} { if {[info exists env(HUMANGENOMEDIR)]} { set HumanGenomeDir $env(HUMANGENOMEDIR) } else { set HumanGenomeDir "[GscopeDatabaseDir HumanGenome]" } } return $HumanGenomeDir } proc HumanGenomeUcsc {} { set I [open "HumanUCSC_Build37_hg17_May2004_origine" "r"] set O [open "HumanUCSC_Build37_hg17_May2004" "w"] while {[gets $I Ligne]>=0} { if {[regexp {>([^ ]+)} $Ligne Match X]} { set Ligne NotationUCSC($X,Header) } puts $O $Ligne } close $I close $O exit } proc HumanMutationDisease {{Qui ""} {Quoi ""}} { global HumanMutationDisease if {$Qui==""} { set Qui "ListOf" ; set Quoi "Gn" } if {$Quoi==""} { set Quoi "Di" } if {$Quoi=="Disease"} { set Quoi "Di" } if {$Qui!="ListOf"} { set Qui [string toupper $Qui] } if {[info exists HumanMutationDisease($Qui,$Quoi)]} { return $HumanMutationDisease($Qui,$Quoi) } if {[info exists HumanMutationDisease($Qui,Ix)]} { set LeResultat {} foreach Ix $HumanMutationDisease($Qui,Ix) { if {[info exists HumanMutationDisease($Ix,$Quoi)]} { LConcat LeResultat $HumanMutationDisease($Ix,$Quoi) } } set LeResultat [lsort -unique $LeResultat] return [join $LeResultat "///"] } if {[info exists HumanMutationDisease("EstCharge")]} { Espionne $Qui; return "" } set HumanMutationDisease("EstCharge") 1 set RepKb "/genomics/link/AmdKb" set FichierHumanMutationDisease "$RepKb/DeSM2PH/humsavar.txt" set Ix -1 foreach Ligne [LesLignesDuFichier $FichierHumanMutationDisease] { incr Ix set HumanMutationDisease($Ix,Line) $Ligne set Gn [set Ac ""] scan $Ligne "%s %s %s %s %s %s" Gn Ac Id Mu VT Rs if {$Gn=="" || $Ac==""} { continue } set Di [string range $Ligne 74 end] set Om "" regexp {\[MIM\:([^\]]+)\]} $Di Match Om lappend HumanMutationDisease($Ix,Ix) $Ix lappend HumanMutationDisease($Ix,Gn) $Gn lappend HumanMutationDisease($Ix,Ac) $Ac lappend HumanMutationDisease($Ix,Id) $Id lappend HumanMutationDisease($Ix,VT) $VT lappend HumanMutationDisease($Ix,Rs) $Rs lappend HumanMutationDisease($Ix,Di) $Di lappend HumanMutationDisease($Ix,Om) $Om lappend HumanMutationDisease($Ix,AM) "$Ac $Mu" lappend HumanMutationDisease(ListOf,Ix) $Ix lappend HumanMutationDisease(ListOf,Gn) $Gn lappend HumanMutationDisease(ListOf,Ac) $Ac lappend HumanMutationDisease(ListOf,Id) $Id lappend HumanMutationDisease(ListOf,VT) $VT lappend HumanMutationDisease(ListOf,Rs) $Rs lappend HumanMutationDisease(ListOf,Di) $Di lappend HumanMutationDisease(ListOf,Om) $Om lappend HumanMutationDisease(ListOf,AM) "$Ac $Mu" if {[info exists HumanMutationDisease($Ac,Gn)] && $HumanMutationDisease($Ac,Gn)!=$Gn} { #rR ne sert pas (theoriquement) ! FaireLire "$Ac $Gn $HumanMutationDisease($Ac,Gn)" } set HumanMutationDisease($Ac,Gn) $Gn lappend HumanMutationDisease($Ac,Ix) $Ix lappend HumanMutationDisease($Ac,Mu) $Mu lappend HumanMutationDisease($Ac,Di) $Di lappend HumanMutationDisease($Ac,Om) $Om lappend HumanMutationDisease($Ac,Rs) $Rs lappend HumanMutationDisease($Ac,VT) $VT lappend HumanMutationDisease($Gn,Ac) $Ac lappend HumanMutationDisease($Gn,Ix) $Ix lappend HumanMutationDisease($Gn,AM) "$Ac $Mu" lappend HumanMutationDisease($Gn,Di) $Di lappend HumanMutationDisease($Gn,Om) $Om lappend HumanMutationDisease($Gn,Rs) $Rs lappend HumanMutationDisease($Gn,VT) $VT lappend HumanMutationDisease($Om,Ix) $Ix } set HumanMutationDisease(ListOf,Gn) [lsort -unique $HumanMutationDisease(ListOf,Gn)] set HumanMutationDisease(ListOf,Ac) [lsort -unique $HumanMutationDisease(ListOf,Ac)] set HumanMutationDisease(ListOf,Id) [lsort -unique $HumanMutationDisease(ListOf,Id)] set HumanMutationDisease(ListOf,VT) [lsort -unique $HumanMutationDisease(ListOf,VT)] set HumanMutationDisease(ListOf,Rs) [lsort -unique $HumanMutationDisease(ListOf,Rs)] set HumanMutationDisease(ListOf,Di) [lsort -unique $HumanMutationDisease(ListOf,Di)] set HumanMutationDisease(ListOf,Om) [lsort -unique $HumanMutationDisease(ListOf,Om)] set HumanMutationDisease(ListOf,AM) [lsort -unique $HumanMutationDisease(ListOf,AM)] foreach Gn $HumanMutationDisease(ListOf,Gn) { set HumanMutationDisease($Gn,Di) {} foreach Ac $HumanMutationDisease($Gn,Ac) { LConcat HumanMutationDisease($Gn,Di) $HumanMutationDisease($Ac,Di) } set HumanMutationDisease($Gn,AM) [lsort -unique $HumanMutationDisease($Gn,AM)] set HumanMutationDisease($Gn,Rs) [lsort -unique $HumanMutationDisease($Gn,Rs)] set HumanMutationDisease($Gn,VT) [lsort -unique $HumanMutationDisease($Gn,VT)] set HumanMutationDisease($Gn,Di) [lsort -unique $HumanMutationDisease($Gn,Di)] set HumanMutationDisease($Gn,Di) [join $HumanMutationDisease($Gn,Di) "\n"] } foreach Ac $HumanMutationDisease(ListOf,Ac) { set HumanMutationDisease($Ac,Mu) [lsort -unique $HumanMutationDisease($Ac,Mu)] set HumanMutationDisease($Ac,Rs) [lsort -unique $HumanMutationDisease($Ac,Rs)] set HumanMutationDisease($Ac,VT) [lsort -unique $HumanMutationDisease($Ac,VT)] set HumanMutationDisease($Ac,Di) [lsort -unique $HumanMutationDisease($Ac,Di)] set HumanMutationDisease($Ac,Di) [join $HumanMutationDisease($Ac,Di) "\n"] } return [HumanMutationDisease $Qui $Quoi] } proc HumanSynonyms {G} { set H [HGNC $G "HGNC_ID"] if {$H==""} { return {} } set O [HGNC $H "Approved_Symbol"] set All [concat [list $O] [HGNC $H "Synonyms"]] set All [ListeSansDoublon $All] return $All } proc Hv_ChangeUnderline {args} { .hv.h.h config -underlinehyperlinks $::hv_underlineHyper Hv_RefreshFile } proc Hv_ClearBigImages {} { global ::hv_BigImages foreach b [array names ::hv_BigImages] { image delete $::hv_BigImages($b) } catch {unset ::hv_BigImages} } proc Hv_ClearOldImages {} { global ::hv_OldImages foreach fn [array names ::hv_OldImages] { image delete $::hv_OldImages($fn) } catch {unset ::hv_OldImages} } proc Hv_ClearScreen {} { set w .hv.h.h $w clear catch {unset ::hv_hotkey} Hv_ClearBigImages Hv_ClearOldImages foreach fn [array names ::hv_Images] { set ::hv_OldImages($fn) $::hv_Images($fn) } catch {unset ::hv_Images} } proc Hv_FillerImages {} { image create photo ::hv_biggray -data { R0lGODdhPAA+APAAALi4uAAAACwAAAAAPAA+AAACQISPqcvtD6OctNqLs968+w+G4kiW5omm 6sq27gvH8kzX9o3n+s73/g8MCofEovGITCqXzKbzCY1Kp9Sq9YrNFgsAO/// } image create photo ::hv_smgray -data { R0lGODdhOAAYAPAAALi4uAAAACwAAAAAOAAYAAACI4SPqcvtD6OctNqLs968+w+G4kiW5omm 6sq27gvH8kzX9m0VADv/ } image create photo ::hv_nogifbif -data { R0lGODdhJAAkAPEAAACQkADQ0PgAAAAAACwAAAAAJAAkAAACmISPqcsQD6OcdJqKM71PeK15 AsSJH0iZY1CqqKSurfsGsex08XuTuU7L9HywHWZILAaVJssvgoREk5PolFo1XrHZ29IZ8oo0 HKEYVDYbyc/jFhz2otvdcyZdF68qeKh2DZd3AtS0QWcDSDgWKJXY+MXS9qY4+JA2+Vho+YPp FzSjiTIEWslDQ1rDhPOY2sXVOgeb2kBbu1AAADv/ } image create photo ::hv_nogifsm -data { R0lGODdhEAAQAPEAAACQkADQ0PgAAAAAACwAAAAAEAAQAAACNISPacHtD4IQz80QJ60as25d 3idKZdR0IIOm2ta0Lhw/Lz2S1JqvK8ozbTKlEIVYceWSjwIAO/// } } proc Hv_FromEntities {txt} { return [string map [array get ::hv_froment] $txt] } proc Hv_GetArg {argname args} { foreach { keyword value } $args { if {[string index $keyword 0] == "-" } { set argum [string range $keyword 1 end] if { $argname == $argum } { return $value } } } return "" } proc Hv_HrefBinding {x y} { # koba & dg marking text .hv.h.h selection clear # set ::tkhtml::Priv(mark) $x,$y set list [.hv.h.h href $x $y] if {![llength $list]} {return} foreach {new target} $list break if {$new!=""} { global hv_LastFile set pattern $hv_LastFile# set len [string length $pattern] incr len -1 if {[string range $new 0 $len] eq $pattern} { incr len .hv.h.h yview [string range $new $len end] } else { Hv_LoadFile $new } } } proc Hv_InitIsoHtml {} { array unset ::hv_froment array unset ::hv_toent array set escapes { iexcl \xa1 cent \xa2 pound \xa3 curren \xa4 yen \xa5 brvbar \xa6 sect \xa7 uml \xa8 copy \xa9 ordf \xaa laquo \xab not \xac shy \xad reg \xae hibar \xaf deg \xb0 plusmn \xb1 sup2 \xb2 sup3 \xb3 acute \xb4 micro \xb5 para \xb6 middot \xb7 cedil \xb8 sup1 \xb9 ordm \xba raquo \xbb frac14 \xbc frac12 \xbd frac34 \xbe iquest \xbf Agrave \xc0 Aacute \xc1 Acirc \xc2 Atilde \xc3 Auml \xc4 Aring \xc5 AElig \xc6 Ccedil \xc7 Egrave \xc8 Eacute \xc9 Ecirc \xca Euml \xcb Igrave \xcc Iacute \xcd Icirc \xce Iuml \xcf ETH \xd0 Ntilde \xd1 Ograve \xd2 Oacute \xd3 Ocirc \xd4 Otilde \xd5 Ouml \xd6 times \xd7 Oslash \xd8 Ugrave \xd9 Uacute \xda Ucirc \xdb Uuml \xdc Yacute \xdd THORN \xde szlig \xdf agrave \xe0 aacute \xe1 acirc \xe2 atilde \xe3 auml \xe4 aring \xe5 aelig \xe6 ccedil \xe7 egrave \xe8 eacute \xe9 ecirc \xea euml \xeb igrave \xec iacute \xed icirc \xee iuml \xef eth \xf0 ntilde \xf1 ograve \xf2 oacute \xf3 ocirc \xf4 otilde \xf5 ouml \xf6 divide \xf7 oslash \xf8 ugrave \xf9 uacute \xfa ucirc \xfb uuml \xfc yacute \xfd thorn \xfe yuml \xff } # Convert into a form that we can use with [string map] foreach key [array names escapes] { set ::hv_froment(&$key\;) $escapes($key) } foreach { key value } [array get escapes] { set ::hv_toent($value) &$key\; } } proc Hv_LoadArgv {} { set ::hv_file {} foreach a $::argv { if {[regexp {^debug=} $a]} { scan $a "debug=0x%x" ::HtmlTraceMask } else { set ::hv_file $a } } } proc Hv_LoadBin {{binpath ""}} { if { $binpath != "" } { load $binpath Tkhtml } else { foreach f { ./tkhtml.so /usr/lib/tkhtml.so /usr/local/lib/tkhtml.so ./tkhtml.dll } { if {[file exists $f]} { if {[catch {load $f Tkhtml}]==0} break } } } } proc Hv_LoadFile {name} { set html [Hv_ReadFile $name] if {$html==""} return # translate ISO chars to HTML entities set html [Hv_ToEntities $html] Hv_ClearScreen set ::hv_LastFile $name .hv.h.h config -base $name .hv.h.h parse $html Hv_ClearOldImages } proc Hv_MainWindow {{withmenu ""} {closebutton ""} {horizbar ""} {linkcolor #0000FF} {bgcolor #FFFFFF}} { global Defauts frame .hv.mbar -bd 2 -relief raised if { $withmenu == 1 } { pack .hv.mbar -side top -fill x } menubutton .hv.mbar.file -text File -underline 0 -menu .hv.mbar.file.m pack .hv.mbar.file -side left -padx 5 set m [menu .hv.mbar.file.m] $m add command -label Open -underline 0 -command Hv_UserLoad $m add command -label Refresh -underline 0 -command Hv_RefreshFile $m add separator $m add command -label Exit -underline 1 -command exit menubutton .hv.mbar.view -text View -underline 0 -menu .hv.mbar.view.m pack .hv.mbar.view -side left -padx 5 set m [menu .hv.mbar.view.m] set ::hv_underlineHyper 1 $m add checkbutton -label {Underline Hyperlinks} -variable ::hv_underlineHyper trace add variable ::hv_underlineHyper write Hv_ChangeUnderline set ::hv_showTableStruct 0 $m add checkbutton -label {Show Table Structure} -variable ::hv_showTableStruct trace add variable ::hv_showTableStruct write Hv_ShowTableStruct set ::hv_showImages 1 $m add checkbutton -label {Show Images} -variable ::hv_showImages trace add variable ::hv_showImages write Hv_RefreshFile # Construct the main HTML viewer # frame .hv.h pack .hv.h -side top -fill both -expand 1 html .hv.h.h -yscrollcommand {.hv.h.vsb set} -xscrollcommand {.hv.f2.hsb set} -padx 5 -pady 9 -formcommand FormCmd -imagecommand ImageCmd -scriptcommand ScriptCmd -appletcommand AppletCmd -underlinehyperlinks 1 -bg $bgcolor -tablerelief flat -visitedcolor $linkcolor -unvisitedcolor $linkcolor -fontcommand Hv_PickFont # If the tracemask is not 0, then draw the outline of all # tables as a blank line, not a 3D relief. # if {$::HtmlTraceMask} { .hv.h.h config -tablerelief flat } bind .hv.h.h.x <1> {Hv_HrefBinding %x %y} # Pack the HTML widget into the main screen. # pack .hv.h.h -side left -fill both -expand 1 scrollbar .hv.h.vsb -width 8 -orient vertical -command {.hv.h.h yview} pack .hv.h.vsb -side left -fill y bind HtmlClip <4> {%W yview scroll -[set Defauts(DeltaYScroll)] units} bind HtmlClip <5> {%W yview scroll [set Defauts(DeltaYScroll)] units} frame .hv.f2 frame .hv.f2.sp -width [winfo reqwidth .hv.h.vsb] -bd 2 -relief raised scrollbar .hv.f2.hsb -orient horizontal -command {.hv.h.h xview} if { $horizbar == 1 } { pack .hv.f2.sp -side right -fill y pack .hv.f2.hsb -side top -fill x pack .hv.f2 -side top -fill x } # add close button if { $closebutton != "" } { frame .hv.bot pack .hv.bot -side bottom -fill x button .hv.bot.close -text $closebutton -command {destroy .hv} -width -12 -background green1 pack .hv.bot.close -side right -padx [winfo reqwidth .hv.h.vsb] -pady 7 } # # configure link color # .hv.h.h configure -visitedcolor $linkcolor -unvisitedcolor $linkcolor # # configure background color # .hv.h.h configure -background $bgcolor # If an argument was specified, read it into the HTML widget. # update if {$::hv_file!=""} { Hv_LoadFile $::hv_file } # This binding changes the cursor when the mouse move over # top of a hyperlink. # bind HtmlClip { set parent [winfo parent %W] set url [$parent href %x %y] if {[string length $url] > 0} { $parent configure -cursor hand2 } else { $parent configure -cursor {} } } MesCouleurs .hv FenetreAuCentre .hv } proc Hv_MoveBigImage {b} { if {![info exists ::hv_BigImages($b)]} return $b copy $::hv_BigImages($b) image delete $::hv_BigImages($b) unset ::hv_BigImages($b) update } proc Hv_PickFont {size attrs} { # puts "FontCmd: $size $attrs" set a [expr {-1<[lsearch $attrs fixed]?{courier}:{charter}}] set b [expr {-1<[lsearch $attrs italic]?{italic}:{roman}}] set c [expr {-1<[lsearch $attrs bold]?{bold}:{normal}}] set d [expr {int(12*pow(1.2,$size-4))}] list $a $d $b $c } proc Hv_ReadFile {name} { if {[catch {open $name r} fp]} { tk_messageBox -icon error -message $fp -type ok return {} } else { fconfigure $fp -translation binary set r [read $fp [file size $name]] close $fp return $r } } proc Hv_RefreshFile {args} { if {![info exists ::hv_LastFile]} return Hv_LoadFile $::hv_LastFile } proc Hv_Run {args} { set title "HTML File Viewer" set iconname "HV" set menubar "" set closebutton "" set loadargv "" set readfile "" set horizbar "" set linkcolor "" set title [eval Hv_GetArg title $args] set iconname [eval Hv_GetArg iconname $args] set menubar [eval Hv_GetArg menubar $args] set closebutton [eval Hv_GetArg closebutton $args] set loadargv [eval Hv_GetArg loadargv $args] set readfile [eval Hv_GetArg readfile $args] set horizbar [eval Hv_GetArg horizbar $args] set linkcolor [eval Hv_GetArg linkcolor $args] set bgcolor [eval Hv_GetArg bgcolor $args] set ::hv_lastDir [pwd] set ::HtmlTraceMask 0 if { $loadargv == 1 } { Hv_LoadArgv } if { $readfile != "" } { set ::hv_file $readfile } Hv_FillerImages Hv_InitIsoHtml trace remove variable ::hv_underlineHyper write Hv_ChangeUnderline trace remove variable ::hv_showImages write Hv_RefreshFile trace remove variable ::hv_showTableStruct write Hv_ShowTableStruct destroy .hv toplevel .hv wm title .hv $title wm iconname .hv $iconname set Cmd "" foreach a {menubar closebutton horizbar linkcolor bgcolor} { if {[set $a] != ""} { append Cmd [set $a] } } Hv_MainWindow 0 "Close" # eval Hv_MainWindow $Cmd } proc Hv_ShowTableStruct {args} { if {$::hv_showTableStruct} { set ::HtmlTraceMask [expr {$::HtmlTraceMask|0x8}] .hv.h.h config -tablerelief flat } else { set ::HtmlTraceMask [expr {$::HtmlTraceMask&~0x8}] .hv.h.h config -tablerelief raised } Hv_RefreshFile } proc Hv_ToEntities {txt} { return [string map [array get ::hv_toent] $txt] } proc Hv_UserLoad {} { set filetypes { {{Html Files} {.html .htm}} {{All Files} *} } set f [tk_getOpenFile -initialdir $::hv_lastDir -filetypes $filetypes] if {$f!=""} { Hv_LoadFile $f set ::hv_lastDir [file dirname $f] } } proc Hydrophobicities {Fichier {DuParalogue ""}} { global RepertoireDuGenome if {$DuParalogue==""} { set Rep "$RepertoireDuGenome/msf" } else { set Rep "$RepertoireDuGenome/msfparalogues" } set Nom [file tail $Fichier] if { ! [file exists $Fichier]} { set Fichier "$Rep/$Nom" } if { ! [file exists $Fichier]} { return {} } if {[catch {set Texte [eval exec "gesscale $Fichier -v"]} Message]} { return "" } return $Texte } proc Hydrophobicity {Nom {Quoi nHelices}} { global RepertoireDuGenome global Hydrophobicity Wup "Quoi can be nHelices Hydro or OwnHydro" if {[info exists Hydrophobicity($Nom,$Quoi)]} { return [set Hydrophobicity($Nom,$Quoi)] } if {[info exists Hydrophobicity]} { return -999 } set FichierHydrophobicity "$RepertoireDuGenome/fiches/hydrophobicity" if {[file exists $FichierHydrophobicity]} { foreach Ligne [LesLignesDuFichier $FichierHydrophobicity] { scan $Ligne "%s %d %f %f" NomLu nHelices Hydro OwnHydro set Hydrophobicity($NomLu,nHelices) $nHelices set Hydrophobicity($NomLu,OwnHydro) $OwnHydro set Hydrophobicity($NomLu,Hydro) $Hydro } set Hydrophobicity(EstChargee) 1 return [Hydrophobicity $Nom $Quoi] } if { ! [OuiOuNon "Do I calculate all hydrophobicities ?"]} { set Hydrophobicity(EstChargee) 1 return [Hydrophobicity $Nom $Quoi] } foreach PAB [ListeDesPABs] { set Texte [Hydrophobicities $PAB] if {$Texte==""} { set Hydro -2 set SonHydro -2 set nHelices -2 } else { foreach Ligne [split [Hydrophobicities $PAB] "\n"] { if {[regexp "\[ \t\]$PAB\[ \t\]+" $Ligne]} { scan $Ligne "%s %f %f %d %d" Bidon SonHydro P Long nHelices } if {[regexp "^GES " $Ligne]} { scan $Ligne "%s %f" Bidon Hydro } } } set Hydrophobicity($PAB,OwnHydro) $SonHydro set Hydrophobicity($PAB,Hydro) $Hydro set Hydrophobicity($PAB,nHelices) $nHelices lappend LesHydros "$PAB $nHelices $Hydro $SonHydro" } SauveLesLignes $LesHydros dans $FichierHydrophobicity return [Hydrophobicity $Nom $Quoi] } proc IDAndMeanPIDInMACS {{LesFichiers ""} {ARPMSFDir ""} {FichierOut ""}} { Wup "Permet de calculer le pourcentage d identite moyen au sein d un groupe de sequence" Wup "Affiche en dernier le Mean ID et le % ID de tous les access les uns contre les autres" #Format d entree du fichier #Fichier rsm msf ... #/home/julie/bin/calc_meanid Actin_Complet3_1_Propre.rsf set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/" if {$ARPMSFDir == ""} { set ARPMSFDir "$ARPHomeDir/ARPAnno/ARP_MACS/" set ARPMSFDir "$ARPHomeDir/Resultat/alignement/" set ARPMSFDir "$ARPHomeDir/Resultat/test/" } set Mean_ID "/home/julie/bin/calc_meanid" if {$FichierOut == ""} {set FichierOut "IDetPIDDesARPs"} if {$LesFichiers == ""} { set LesFichiers [glob -nocomplain -directory "$ARPMSFDir" "Actin_Complet5_0_Propre_A*"] } set LesFamilles "" Espionne $LesFichiers foreach Fichier $LesFichiers { if {[regexp "4\_3" $Fichier]} {continue} set LesResidus "" set Result "" Espionne "$Fichier" set Famille [file tail $Fichier] regsub -all {.[a-z]{2,3}$} $Famille "" Famille lappend LesFamilles $Famille AppendAuFichier $FichierOut "$Fichier" if {[catch {set LesResidus [exec $Mean_ID $Fichier]} Message]} { Espionne ">>>IDAndMeanPIDInMACS $Fichier" Espionne "pb $Message" #return "-1" } else { foreach Result [split $LesResidus "\n"] { set Result [join [string trim $Result] "\t"] AppendAuFichier $FichierOut $Result } #return "1" } } return "" } proc IDDeLaFicheEMBL {AcOuId} { package require textutil set fiche [BirdEntry $AcOuId] #if {$fiche eq ""} {error "$AcOuId: Fiche non trouvée."} if {$fiche eq ""} {return ""} #if {[llength $fiche] > 1} {error "$AcOuId: Plusieurs fiches trouvées."} if {[llength $fiche] > 1} {return ""} set fiche [lindex $fiche 0] foreach ligne [split $fiche "\n"] { if {[string range $ligne 0 1] eq "ID"} { return [lindex [string trim [string range $ligne 2 end]] 0] } } return "" } proc IDMapping {from to LId} { set LId [CheckIdsAsList $LId] # returns the converted list with converted IDs # IDs not found are replaced by the empty string # # BEWARE ! IDMapping only works from or to a # uniprot accession/bankid !! # # For the list of abbreviations of available # databases, see # http://www.uniprot.org/help/programmatic_access#id_mapping_examples # for updated available databases # Also reported below #lm 08/04/2016 # # uniprot ID/ACC = ACC+ID # uniprot ID = ID # uniprot acc = ACC # UniRef100 = NF100 # UniRef90 = NF90 # UniRef50 = NF50 # pdb = PDB_ID # refseq protein = P_REFSEQ_AC # refseq nucleot = REFSEQ_NT_ID # GI number = P_GI # set Ldbs [list ACC ID UPARC NF50 NF90 NF100 GENENAME EMBL_ID EMBL PIR UNIGENE_ID P_ENTREZGENEID P_GI P_REFSEQ_AC REFSEQ_NT_ID PDB_ID DISPROT_ID BIOGRID_ID DIP_ID MINT_ID STRING_ID CHEMBL_ID DRUGBANK_ID GUIDETOPHARMACOLOGY_ID SWISSLIPIDS_ID ALLERGOME_ID ESTHER_ID MEROPS_ID MYCOCLAP_ID PEROXIBASE_ID REBASE_ID TCDB_ID BIOMUTA_ID DMDM_ID WORLD_2DPAGE_ID DNASU_ID ENSEMBL_ID ENSEMBL_PRO_ID ENSEMBL_TRS_ID ENSEMBLGENOME_ID ENSEMBLGENOME_PRO_ID ENSEMBLGENOME_TRS_ID GENEDB_ID P_ENTREZGENEID KEGG_ID PATRIC_ID UCSC_ID VECTORBASE_ID WBPARASITE_ID ARACHNOSERVER_ID CCDS_ID CGD CONOSERVER_ID DICTYBASE_ID ECHOBASE_ID ECOGENE_ID EUHCVDB_ID EUPATHDB_ID FLYBASE_ID GENECARDS_ID H_INVDB_ID HGNC_ID HPA_ID LEGIOLIST_ID LEPROMA_ID MAIZEGDB_ID MIM_ID MGI_ID NEXTPROT_ID ORPHANET_ID PHARMGKB_ID POMBASE_ID PSEUDOCAP_ID RGD_ID SGD_ID TAIR_ID TUBERCULIST_ID WORMBASE_ID WORMBASE_TRS_ID WORMBASE_PRO_ID XENBASE_ID ZFIN_ID EGGNOG_ID GENETREE_ID HOGENOM_ID HOVERGEN_ID KO_ID OMA_ID ORTHODB_ID TREEFAM_ID BIOCYC_ID REACTOME_ID UNIPATHWAY_ID CLEANEX_ID COLLECTF_ID CHITARS_ID GENOMERNAI_ID GENEWIKI_ID NEXTBIO_ID] # check arguments if {$from ni $Ldbs && $from ne "ACC+ID"} { return [lrepeat [llength $LId] ""] } if {$to ni $Ldbs} { return [lrepeat [llength $LId] ""] } #global TIDMap #InitIDMapping # Bunches of 200 queries set url "http://www.uniprot.org/mapping/" set Lres [list] set paquets 200 set ni [expr {int([llength $LId]/$paquets)+1}] for {set i 0} {$i < $ni} {incr i} { set d [expr {$i*$paquets}] set f [expr {($i+1)*$paquets-1}] set query [::http::formatQuery from "$from" to "$to" format "tab" query "[join [lrange $LId $d $f] ,]"] set rep [HttpCopy $url "" $query] if {! [regexp {^From} $rep]} { puts "ERROR in IDMapping :" puts "Url : $url" puts "Query : $query" puts "" puts "$rep" return "" } set Lrep [split $rep \n] foreach l [lrange $Lrep 1 end] { lassign [split $l \t] in out set To($in) $out } update } set Lret [list] foreach i $LId { if {[info exists To($i)]} { set out [set To($i)] } else { set out "" } lappend Lret $out } return $Lret } proc IDdansMSF {FichierMSF ProtA ProtB {SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB SelonLePLusPetit}} { set LesAccess [AskMSF $FichierMSF LesAccess] set NombreDeSequences [llength $LesAccess] if {$NombreDeSequences<2} {return} foreach Access $LesAccess { if {[string equal -nocase $Access $ProtA]} { set SeqProtA [AskMSF $FichierMSF $Access] } if {[string equal -nocase $Access $ProtB]} { set SeqProtB [AskMSF $FichierMSF $Access] } } if {![info exists SeqProtA] || ![info exists SeqProtB]} {return -9999.9999} set SeqProtA [string toupper $SeqProtA] set SeqProtB [string toupper $SeqProtB] set nProtA [string length $SeqProtA] set nProtB [string length $SeqProtB] set CumulId 0 set LongVraieProtA 0 set LongVraieProtB 0 for {set i 0} {$i < $nProtA} {incr i} { if {$i >= $nProtB} { break } set AProtA [string range $SeqProtA $i $i] set BProtB [string range $SeqProtB $i $i] if { $AProtA != "." && $AProtA != "-"} { incr LongVraieProtA } if { $BProtB != "." && $BProtB != "-"} { incr LongVraieProtB } if { $AProtA == $BProtB } { if {$AProtA != "." && $AProtA != "-"} { incr CumulId } } } if {[string equal -nocase $SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB "SelonA" ]} { set Taille $LongVraieProtA } if {[string equal -nocase $SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB "SelonB" ]} { set Taille $LongVraieProtB } if {[string equal -nocase $SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB "SelonLePlusPetit"]} { set Taille [Maxi 1 [Mini $LongVraieProtA $LongVraieProtB]] } if {[string equal -nocase $SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB "SelonLePlusGrand"]} { set Taille [Maxi 1 [Maxi $LongVraieProtA $LongVraieProtB]] } if {[string equal -nocase $SelonAouSelonBouSelonLePlusPetitouSelonLePlusGrandouSelonAEtB "SelonAEtB" ]} { return [list [expr $CumulId * 1.0 / $LongVraieProtA] [expr $CumulId * 1.0 / $LongVraieProtB]] } return [expr $CumulId * 1.0 / $Taille] } proc IPO {Access} { #OUT = [list [list GOTerm1 Type Def 1 [list Access]] [list GOTerm2 Type Def 1 [list Access]]] #IPO Initial Protein Ontology Espionne "Access $Access -> 2GO" if {[EstUnAccessPDB $Access]} {return} set LesGOSelected {} foreach GO [Access2GO $Access] { foreach Type [GODB GO $GO LesTypes] { set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] lappend LesGOSelected [list $GO $Type $Def 1 [list $Access]] } } return [lsort -index 1 [lsort -index 3 -real -decreasing $LesGOSelected]] } proc IPRToKeepOrNotToKeep {Access} { global MesIPRInterressants if {! [info exists MesIPRInterressants]} {MesIPRInterressants} if {[info exists MesIPRInterressants($Access)]} {return 0} else {return 1} } proc IUPAC {B} { if {[string length $B] > 1} { set Tout "" foreach C [split $B ""] { append Tout [IUPAC $C] } return $Tout } set B [string toupper $B] if {$B=="A"} { return "A" } if {$B=="G"} { return "G" } if {$B=="C"} { return "C" } if {$B=="T"} { return "T" } if {$B=="U"} { return "T" } if {$B=="M"} { return "\[AC\]" } if {$B=="R"} { return "\[AG\]" } if {$B=="W"} { return "\[AT\]" } if {$B=="S"} { return "\[CG\]" } if {$B=="Y"} { return "\[CT\]" } if {$B=="K"} { return "\[GT\]" } if {$B=="V"} { return "\[ACG\]" } if {$B=="H"} { return "\[ACT\]" } if {$B=="D"} { return "\[AGT\]" } if {$B=="B"} { return "\[CGT\]" } if {$B=="N"} { return "\[ACGT\]" } return $B } proc IUPACcheck {IUPAC sequence} { set mistakesArray {} set tabIUPAC [split $IUPAC ""] set tabSequence [split $sequence ""] set regExp "" set mistakes 0 set num 0 foreach letterIUPAC $tabIUPAC { set lettre [lindex $tabSequence $num] #Espionne "IUPAC $letterIUPAC lettre $lettre" set lettre [lindex $tabSequence $num] if { $letterIUPAC != "" } { set position [expr $num + 1] if {$letterIUPAC == "A" && $lettre != "A" && $lettre != "a"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "T" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "C" && $lettre != "C" && $lettre != "c"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "G" && $lettre != "G" && $lettre != "g" } { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "R" && $lettre != "A" && $lettre != "a" && $lettre != "G" && $lettre != "g"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "Y" && $lettre != "C" && $lettre != "c" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "M" && $lettre != "C" && $lettre != "c" && $lettre != "A" && $lettre != "a"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "K" && $lettre != "T" && $lettre != "t" && $lettre != "G" && $lettre != "g"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "W" && $lettre != "A" && $lettre != "a" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "S" && $lettre != "C" && $lettre != "c" && $lettre != "G" && $lettre != "g"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "B" && $lettre != "C" && $lettre != "c" && $lettre != "G" && $lettre != "g" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "D" && $lettre != "A" && $lettre != "a" && $lettre != "G" && $lettre != "g" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "H" && $lettre != "A" && $lettre != "a" && $lettre != "C" && $lettre != "c" && $lettre != "T" && $lettre != "t"} { incr mistakes lappend mistakesArray $position } if {$letterIUPAC == "V" && $lettre != "A" && $lettre != "a" && $lettre != "C" && $lettre != "c" && $lettre != "G" && $lettre != "g"} { incr mistakes lappend mistakesArray $position } } incr num } return $mistakesArray } proc IUPACtoRegExp {IUPAC} { set tab [split $IUPAC ""] set regExp "" foreach letter $tab { if {$letter == "A"} { append regExp "_A" } elseif {$letter == "T"} { append regExp "_T" } elseif {$letter == "C"} { append regExp "_C" } elseif {$letter == "G"} { append regExp "_G" } elseif {$letter == "R"} { append regExp {_[AG]} } elseif {$letter == "Y"} { append regExp {_[CT]} } elseif {$letter == "M"} { append regExp {_[CA]} } elseif {$letter == "K"} { append regExp {_[TG]} } elseif {$letter == "W"} { append regExp {_[AT]} } elseif {$letter == "S"} { append regExp {_[CG]} } elseif {$letter == "B"} { append regExp {_[CTG]} } elseif {$letter == "D"} { append regExp {_[ATG]} } elseif {$letter == "H"} { append regExp {_[ATC]} } elseif {$letter == "V"} { append regExp {_[ACG]} } elseif {$letter == "N"} { append regExp {_[ATCG]} } else { Espionne "Erreur IUPACtoRegExp" } } return $regExp; } proc IUPACtoReverseAndComplementIUPAC {IUPAC} { set compIUPAC [compIUPAC $IUPAC] set reverseCompIUPAC [NucToReverseNuc $compIUPAC] return $reverseCompIUPAC; } proc IdAcChiffresOuiOuNon {Org} { if {[regexp -nocase "Mouse" $Org]} { set RepertoireSourisOthers "/genomics/link/SpliRetMouse/FichiersInitial/SOURIS_others" set RepertoireSourisTfactor "/genomics/link/SpliRetMouse/FichiersInitial/SOURIS_Tfactor" set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers] } if {[regexp -nocase "Rat" $Org]} { set RepertoireRatOthers "/genomics/link/SpliRetRat/FichiersInitial/RAT_others" set RepertoireRatTfactor "/genomics/link/SpliRetRat/FichiersInitial/RAT_Tfactor" set LesRepertoires [list $RepertoireRatTfactor $RepertoireRatOthers] } set i 0 foreach Repertoire $LesRepertoires { foreach FileST [glob -nocomplain "$Repertoire/*"] { incr i set nbtot 0; set nb 0 set cluster [lindex [split [file tail $FileST] "."] 0] set PAB [InterrogeBox $cluster Box] foreach Ligne [LesLignesDuFichier $FileST] { if {[regexp "^>" $Ligne]} { incr nbtot } if {[regexp "^>NM" $Ligne] || [regexp "^>XM" $Ligne] || [regexp "^>ENS" $Ligne] || [regexp "^>LA" $Ligne]} { incr nb } } if {$nbtot!=$nb} { Espionne "$PAB $cluster"} } } Espionne "i $i" } proc IdAcGn {{Orga ""} {Qui ""} {Quoi ""}} { global IdAcGn regsub " " $Orga "_" Orga if {$Orga==""} { set Orga "Homo_sapiens" } # if {$Orga==""} { set Orga "Saccharomyces_cerevisiae" } set Save 1 set Test 0 if {$Orga=="Test"} { set Test 1; set Save 0; set Orga "Homo_sapiens" } if {$Orga=="Save"} { set Test 1; set Save 1; set Orga "Homo_sapiens" } set FileName "[GscopeDatabaseDir Common]/fiches/IdAcGn_$Orga.txt" set SaveName "[GscopeDatabaseDir Common]/fiches/IdAcGn_$Orga-Save.txt" if {$Qui=="ReLoad"} { if {[file exists $SaveName]} { file delete $SaveName } if {[info exists IdAcGn]} { unset IdAcGn } set Qui "SaveName" } if {[info exists IdAcGn($Orga,$Qui,$Quoi)]} { return $IdAcGn($Orga,$Qui,$Quoi) } if {[info exists IdAcGn("EstCharge")]} { set QUI [string toupper $Qui] if {[info exists IdAcGn($Orga,$QUI,$Quoi)]} { return $IdAcGn($Orga,$QUI,$Quoi) } return "" } set IdAcGn("EstCharge") 1 set IdAcGn($Orga,FileName,) $FileName set IdAcGn($Orga,SaveName,) $SaveName if { ! $Test && [file exists $IdAcGn($Orga,SaveName,)]} { array set IdAcGn [LesLignesDuFichier $IdAcGn($Orga,SaveName,)] return [IdAcGn $Orga $Qui $Quoi] } set Id "ID_UNKNOWN"; set Ac "AC_UNKNOWN"; set Gn "GN_UNKNOWN" set I 0 foreach Ligne [LesLignesDuFichier $IdAcGn($Orga,FileName,)] { set Ligne [string toupper $Ligne] set LigneOriginale $Ligne regsub -all {[ ;]+} $Ligne " " Ligne set Ligne [string trim $Ligne] set LesMots [split $Ligne " "] lassign $LesMots K V1 V2 V3 if {$K eq "//"} { incr I if {0 && [incr I]> 333} { break } ;#rR attention on teste ici !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! lappend LesId $Id LConcat LesAc $LesA lappend LesGn $Gn lappend LesLe $Le set IdAcGn($Orga,$Id,Id) $Id set IdAcGn($Orga,$Id,Le) $Le set IdAcGn($Orga,$Id,Gn) $Gn set IdAcGn($Orga,$Id,Acs) $LesA set Ac [lindex $LesA 0] set IdAcGn($Orga,$Id,Ac) $Ac if {[info exists DejaVu($Id)]} { FaireLire "$Id $Ac deja vu pour $DejaVu($Id)" } foreach A $LesA { if {[info exists DejaVu($A)]} { lappend IdAcGn($Orga,Ambiguous,Ac) "$A $Id $Gn already seen in : $DejaVu($A)" } lappend DejaVu($A) "$Id $Gn" } set DejaVu($Id) $Ac lappend IdAcGn($Orga,$Gn,LeId) "$Le $Id" lappend IdAcGn($Orga,$Gn,Ids) $Id lappend IdAcGn($Orga,$Le,Ids) $Id foreach A $LesA { set IdAcGn($Orga,$A,Ac) $A set IdAcGn($Orga,$A,Id) $Id set IdAcGn($Orga,$A,Gn) $Gn lappend IdAcGn($Orga,$A,Ids) $Id lappend IdAcGn($Orga,$A,Gns) $Gn lappend IdAcGn($Orga,$Gn,Acs) $A } set Id "ID_UNKNOWN"; set Ac "AC_UNKNOWN"; set Gn "GN_UNKNOWN" continue } if {$K eq "ID"} { set Id $V1; set Le $V3; continue } if {$K eq "AC"} { set LesA [lrange $LesMots 1 end] if {[llength $LesA]>6} { set LesBonsA {} foreach A $LesA { if {[string length $A]>6} { lappend LesBonsA [string range $A 0 5] [string range $A 5 end] } else { lappend LesBonsA $A } } set LesA $LesBonsA } } if {$K eq "GN"} { set Gn $V1 regsub "NAME=" $Gn "" Gn regsub -all "/" $Gn "-" Gn regsub -all {[^a-zA-Z0-9_\-\+]} $Gn "" Gn set LesS {} if {[regexp {SYNONYMS=([^;]+);} $LigneOriginale Match Synonyms]} { if {$Gn=="ERGIC3"} { Espionne "$LigneOriginale" } regsub -all {[ /\,;]+} $Synonyms " " Synonyms ;#rR / devient separateur set LesSynonyms [split [string trim $Synonyms] " "] if {$Gn=="ERGIC3"} { Espionne $LesSynonyms } foreach Sy $LesSynonyms { regsub -all {[^a-zA-Z0-9_\.\-\+]} $Sy "" Sy lappend LesS $Sy if {[info exists IdAcGn($Orga,$Sy,GnOfSy)]} { #rR attention on ne teste plus rien si on l'a deja rencontre # if {$IdAcGn($Orga,$Sy,GnOfSy)==$Gn} { continue } # FaireLire "DejaVuSynonym $Sy de $Gn mais pour $IdAcGn($Orga,$Sy,GnOfSy)" continue } set IdAcGn($Orga,$Sy,GnOfSy) $Gn lappend LesSy $Sy } set IdAcGn($Orga,$Gn,Sys) $LesSynonyms } set LesO {} if {[regexp {ORFNAMES=([^;]+);} $LigneOriginale Match OrfNames]} { regsub -all {[ /\,;]+} $OrfNames " " OrfNames ;#rR / devient separateur set LesOrfNames [split [string trim $OrfNames] " "] foreach On $LesOrfNames { regsub -all {[^a-zA-Z0-9_\.\-\+]} $On "" On lappend LesO $On if {[info exists IdAcGn($Orga,$On,GnOfOn)]} { #rR attention on ne teste plus rien si on l'a deja rencontre # if {$IdAcGn($Orga,$On,GnOfOn)==$On} { continue } # FaireLire "DejaVuSynonym $On de $Gn mais pour $IdAcGn($Orga,$On,GnOfOn)" continue } set IdAcGn($Orga,$On,GnOfOn) $Gn lappend LesOn $On } set IdAcGn($Orga,$Gn,Ons) $LesOrfNames } } } set IdAcGn($Orga,ListOf,On) [lsort -unique $LesOn] set IdAcGn($Orga,ListOf,Sy) [lsort -unique $LesSy] set IdAcGn($Orga,ListOf,Id) [lsort -unique $LesId] set IdAcGn($Orga,ListOf,Ac) [lsort -unique $LesAc] set IdAcGn($Orga,ListOf,Gn) [lsort -unique $LesGn] set IdAcGn($Orga,ListOf,Le) [lsort -unique -integer $LesLe] set IdAcGn($Orga,NumberOf,Id) $I set IdAcGn($Orga,NumberOf,Ac) [llength $IdAcGn($Orga,ListOf,Ac)] foreach Gn $IdAcGn($Orga,ListOf,Gn) { set IdAcGn($Orga,$Gn,LeId) [lsort -decreasing -command CompareLesIntegersEnDebut $IdAcGn($Orga,$Gn,LeId)] set LeId [lindex $IdAcGn($Orga,$Gn,LeId) 0] scan $LeId "%d %s" Le Id set Ac $IdAcGn($Orga,$Id,Ac) set IdAcGn($Orga,$Gn,Gn) $Gn set IdAcGn($Orga,$Gn,Le) $Le set IdAcGn($Orga,$Gn,Id) $Id set IdAcGn($Orga,$Gn,Ac) $Ac lappend IdAcGn($Orga,ListOf,MajorId) $Id lappend IdAcGn($Orga,ListOf,MajorAc) $Ac } foreach Sy $IdAcGn($Orga,ListOf,Sy) { if {[info exists IdAcGn($Orga,$Sy,Id)]} { continue } set Gn $IdAcGn($Orga,$Sy,GnOfSy) ;#rR attention on rajoute les synonymes aux Gn set IdAcGn($Orga,$Sy,Gn) $Sy set IdAcGn($Orga,$Sy,Le) $IdAcGn($Orga,$Gn,Le) set IdAcGn($Orga,$Sy,Id) $IdAcGn($Orga,$Gn,Id) set IdAcGn($Orga,$Sy,Ac) $IdAcGn($Orga,$Gn,Ac) lappend IdAcGn($Orga,ListOf,Gn) $Sy } foreach On $IdAcGn($Orga,ListOf,On) { if {[info exists IdAcGn($Orga,$On,Id)]} { continue } set Gn $IdAcGn($Orga,$On,GnOfOn) ;#rR attention on rajoute les OrfNames aux Gn set IdAcGn($Orga,$On,Gn) $On set IdAcGn($Orga,$On,Le) $IdAcGn($Orga,$Gn,Le) set IdAcGn($Orga,$On,Id) $IdAcGn($Orga,$Gn,Id) set IdAcGn($Orga,$On,Ac) $IdAcGn($Orga,$Gn,Ac) lappend IdAcGn($Orga,ListOf,Gn) $On } set IdAcGn($Orga,ListOf,Gn) [lsort -unique $IdAcGn($Orga,ListOf,Gn)] set IdAcGn($Orga,NumberOf,Gn) [llength $IdAcGn($Orga,ListOf,Gn)] set IdAcGn($Orga,GN_UNKNOWN,Id) "ID_UNKNOWN" set IdAcGn($Orga,GN_UNKNOWN,Ac) "AC_UNKNOWN" set IdAcGn($Orga,GN_UNKNOWN,Gn) "GN_UNKNOWN" set IdAcGn($Orga,ID_UNKNOWN,Id) "ID_UNKNOWN" set IdAcGn($Orga,ID_UNKNOWN,Ac) "AC_UNKNOWN" set IdAcGn($Orga,ID_UNKNOWN,Gn) "GN_UNKNOWN" set IdAcGn($Orga,AC_UNKNOWN,Id) "ID_UNKNOWN" set IdAcGn($Orga,AC_UNKNOWN,Ac) "AC_UNKNOWN" set IdAcGn($Orga,AC_UNKNOWN,Gn) "GN_UNKNOWN" set Tout [array get IdAcGn] if { ! $Save } { SauveLesLignes $Tout dans $IdAcGn($Orga,SaveName,) } return [IdAcGn $Orga $Qui $Quoi] } proc IdAcGnForList {{Liste ""} {Quoi ""} {Orga ""} {GetWhat ""}} { if {$GetWhat==""} { set GetWhat "GetList" } if {[regexp {[ \,\;\n]} $Liste]} { set Liste [regsub -all {[ \,\;\n]+} $Liste ","] set Liste [string trim $Liste] set Liste [split $Liste ","] } if {$Liste=="AllId"} { set Liste [IdAcGn $Orga "ListOf" "Id"] } if {$Liste=="AllAc"} { set Liste [IdAcGn $Orga "ListOf" "Ac"] } if {$Liste=="AllGn"} { set Liste [IdAcGn $Orga "ListOf" "Gn"] } set R {} foreach Qui $Liste { set W [list $Qui] foreach Q [split $Quoi ","] { if {$Q=="Qu"} { set X $Qui } else { set X [IdAcGn $Orga $Qui $Q] } regsub -all " " $X "," X lappend W $X } lappend R [join $W ":"] } if {$GetWhat=="GetList"} { return $R } if {$GetWhat=="GetLines"} { return [join $R "\n"] } return [join $R "/"] } proc IdCard {Document {Quoi ""}} { #rR Attention je triche pour les retour a la ligne qui compte pour 2 carac en php mais pas en tcl #rR Attention je triche en php en faisant utf8_decode pour tout les chmaps global IdCard if {$Quoi==""} { set Quoi "ListOfFields" } if {[info exists IdCard($Document,$Quoi)]} { return $IdCard($Document,$Quoi) } if {[info exists IdCard($Document,"EstCharge")]} { return "" } set IdCard($Document,"EstCharge") 1 set Url "[LbgiUrl]/puzz/phpRR/lance.php?action=IdCard::card&document=$Document&getwhat=GetCard" set Serial [ContenuDuFichier $Url] regsub -all "\n" $Serial "@!" Serial ArrayFromSerial $Serial TabCard set LesT {} set LesC {} foreach i [lsort -integer [array names TabCard]] { lassign $TabCard($i) t T c C set T [lindex $T 1] set C [lindex $C 1] regsub -all "@!" $C "\n" C lappend IdCard($Document,ListOfFields) $T set IdCard($Document,$T) $C } return [IdCard $Document $Quoi] } proc IdDBTSS2Organism {Id} { ###A partir de l'Id long de DBTSS, donne le nom de l'organisme### if {[regexp -nocase "^HSA" $Id]} {return "Homo sapiens"} if {[regexp -nocase "^MMU" $Id]} {return "Mus musculus"} return "Unknown unknown" } proc IdDuAc {AC} { set LesLignesEMBL [LaSequenceDesBanques $AC "" "OnVeutEMBL"] if {$LesLignesEMBL==""} { return "" } set ID [StringApres "ID " dans [lindex $LesLignesEMBL 0]] return $ID } proc IdDuProt {AC} { set Commande "getz \"\\\[protein-acc:$AC\\\]\" \-f id" set GetzOut [eval exec $Commande] if { $GetzOut == "" } { set IdLu "" return $IdLu exit } set Lu "" set IdLu "" scan $GetzOut "%s %s" Lu IdLu return $IdLu } proc IdDuProt_AEffacer {AC} { set Commande "getz \"\\\[protein-acc:$AC\\\]\" \-f id" set GetzOut [eval exec $Commande] if { $GetzOut == "" } { set IdLu "" return $IdLu exit } set Lu "" set IdLu "" scan $GetzOut "%s %s" Lu IdLu return $IdLu } proc IdentifiantDunIdString {protId} { foreach {Id So} [SqlExec "select protein_name, source from items.proteins_names where protein_id = '$protId';" "GetList"] { if {$So == "Ensembl" && [regexp "^ENSG" $Id]} { lappend LesIds $Id } } return $LesIds } proc IdentificationDeSavant {} { global IdentificationDeSavant if { ! [info exists IdentificationDeSavant]} { set IdentificationDeSavant 0 } incr IdentificationDeSavant if {$IdentificationDeSavant>99999} { set IdentificationDeSavant 1 } return $IdentificationDeSavant } proc IdentifieLeMeilleurBLAST {LesFichiersBLASTs AccessQuery {FichierLog ""}} { Wup "Permet de classer les resultats de BLAST dans les 10 sous familles pour une query" set RepARP "[RepARPAnno]" set RepBanque "$RepARP/ARP_BLAST" set RepARP_Results "[RepARPAnnoWeb]" set RepBlastResults "$RepARP_Results" if { $FichierLog == ""} { set FichierLog "[RepARPAnnoWeb]/IdentifieLeMeilleurBLAST.log" } #PERMET DE METTRE LA FAMILLE SI ON CONNAIT DEJA LA FAMILLE set Categorie [InterrogeLesInfosDesARPs [string toupper $AccessQuery] Categorie] regsub -all {\-\-\-\-} $Categorie "" Categorie regsub "Les" $Categorie "" Categorie if {[Verbose_Mode]} { set TextLog ">< 1- BLAST step ><" AjouteAuARPLog "$TextLog" } #L entete des resultats if {! [file exists $FichierLog]} { set Ligne "Access\tCategorie" foreach BLAST $LesFichiersBLASTs { set Famille_tmp "" set tmp "" #Query_test.tfa_ARP1 set Famille [file tail $BLAST] regexp -nocase {_([a-z]{2,4}[0-9]{1,2}|actin|orphans).blastp$} $Famille tmp Famille_tmp if {$Famille_tmp != ""} { set Famille $Famille_tmp } append Ligne "\t$Famille" } AppendAuFichier $FichierLog $Ligne } set ListeFamilleIdentity "" set Ligne "$AccessQuery\t$Categorie" foreach BLAST $LesFichiersBLASTs { #On recupere le nom de la famille qui est contenu dans le fichier BLAST set Famille_tmp "" set tmp "" set Famille [file tail $BLAST] regsub -nocase {.blastp$} $Famille "" Famille regexp -nocase {_([a-z]{2,4}[0-9]{1,2}|actin|orphans)$} $Famille tmp Famille_tmp if {$Famille_tmp != ""} { set Famille $Famille_tmp } if {[Verbose_Mode]} { set TextLog ">BLAST for $Famille" AjouteAuARPLog "$TextLog" } #Charge les resultats du Blast ############################## set BestIdGlobal 0.0 set BestCoverG 0.0 set BestBId "None" set NbSubject [AskBlast $BLAST NbSubject] #Test de la presence de la Query dans le blast ############################################## #On va rechercher le meilleur pourcentage d identite global pour chaque BLAST if {$NbSubject>0} { set MaxCoverQOverS "0.2" set PCoverSubject "" #Faut il mettre une limite au nombre de hits utilises pour la recherche du meilleur hit ? set NbSubjectLimit 50 if {[regexp -nocase "actin" $Famille]} { set NbSubjectLimit 10 } if {$NbSubject>$NbSubjectLimit} {set NbSubject $NbSubjectLimit} for {set i 1} {$i <=$NbSubject} {incr i} { set BId "" set IdGlobal "" set PCoverSubject "" set BId [AskBlast $BLAST Subject $i] #Pourcentage d identite global: Aligne sur Total dans les alignements set IdGlobal [format "%.2f" [PourcentageDIdentiteGlobal $BLAST $BId]] if {$IdGlobal > $BestIdGlobal} { #Recouvrement de Q sur S ou inversement #PCoverQuery Query par rapport au Subject #PCoverSubject Subject par rapport au Query #set PCoverQuery [PourcentageDeRecouvrement $BLAST $BId "Query"] set PCoverSubject [format "%.2f" [PourcentageDeRecouvrement $BLAST $BId "Subject"]] if {$PCoverSubject < $MaxCoverQOverS} { #Si le recouvrement de la query sur le subject est trop faible on ne le retient pas continue } else { #On garde les ID et BId du meilleur hit set BestIdGlobal $IdGlobal set BestCoverG $PCoverSubject set BestBId $BId } #Espionne "$BId -- $IdGlobal -- $PCoverSubject" continue } } } else { set BestIdGlobal "0.0" set BestIdGlobal "0.0" set BestCoverG "0.0" set BestBId "None" } set BestIdGlobal [format "%.2f" $BestIdGlobal] set BestCoverG [format "%.2f" $BestCoverG] if {[Verbose_Mode]} { set TextLog "[format "%6s %4.2f %4.2f" $BestBId $BestIdGlobal $BestCoverG]" AjouteAuARPLog "$TextLog" } append Ligne "\t${BestIdGlobal}_${BestCoverG}" lappend ListeFamilleIdentity [list $Famille $BestIdGlobal $BestCoverG] AskBlast unsetfile $BLAST } AppendAuFichier $FichierLog $Ligne set ListeFamilleIdentity [lsort -decreasing -real -index 1 $ListeFamilleIdentity] return "$ListeFamilleIdentity" } proc IdentifieLesZonesBLATPourTous {DirIn} { if {! [file exists "[RepertoireDuGenome]/${DirIn}"]} { Espionne "Problem input directory do not exists." return "" } #set LesPABs [ListeDesPABs] set LesPABs [glob -nocomplain -directory "$DirIn" -tails "*"] foreach PAB $LesPABs { IdentifieLesZonesBLAT "$DirIn/$PAB" } return "" } proc IdentifieLesZonesUCSC {Input {Quoi RefSeq}} { Wup "Identifie a partir d un blast ou d un blat les zones d identite importante sur le genome UCSC" Wup "Fait le lien avec les annotations disponibles et determine la ou les annotations pertinentes" Wup "Utilise 3 cutoff, PId du HSP, Cover du HSP avec un gene, Cover des HSP pour un gene" set Genome "mouse" #1- Chargement des infos du Blast ou du Blat set TailleQuery [AskBlast $Input Taille] set NomQuery [AskBlast $Input Query] set NbSbjct [AskBlast $Input NbSubject] if {$NbSbjct=="0" || $NbSbjct==""} {Espionne ">>>[file tail $Input]\tNo blat hit";return ""} set Profile_Base "[string repeat "0" $TailleQuery]" #Espionne ">>Q: $NomQuery -- $TailleQuery -- NbSbjct $NbSbjct" #2- Boucle sur les differents subjects set LesIDs "" set LesIDs_Sel "" set FinalCoverCutOff "70.0" for {set i 1} {$i <=$NbSbjct} {incr i} { #Le recouvrement doit etre maximal de notre Query vers Subject #A l inverse on peut etre plus souple dans le sens S vers Q set LesIDs "" set BId [AskBlast $Input Subject $i] set NbSegment [AskBlast $Input BanqueId $BId NbSegment] set Chromosome [string trim $BId] regsub "chr" $Chromosome "" Chromosome #Espionne ">> $BId -- $NbSegment -- $Chromosome" #2-1 Boucle sur les differents HSPs for {set j 1} {$j <=$NbSegment} {incr j} { #Espionne "\n numsegmt $j" set LesIDs_Tmp "" set DS "" set FS "" set DS_Tmp "" set FS_Tmp "" set Aln "" set AlnQ "" set nbN "0" set Sens "" set SensQ "" set SensS "" set PId "0.0" set PId_Tmp "" set nbId "" set nbTot "" set DQ "" set FQ "" set DQ_Tmp "" set FQ_Tmp "" set TailleHSP "" #2-1-1 Recuperation des debut et fin, PId set DS_Tmp [AskBlast $Input BanqueId $BId Segment $j DS] set FS_Tmp [AskBlast $Input BanqueId $BId Segment $j FS] set PId_Tmp [AskBlast $Input BanqueId $BId Segment $j Identities] #Espionne "DS_Tmp $DS_Tmp FS_Tmp $FS_Tmp PId_Tmp $PId_Tmp" set Aln [AskBlast $Input BanqueId $BId Segment $j AlignLineaire] set Aln [lindex [split $Aln "\n"] 0] regexp {^Query:[ ]+[0-9]+ ([a-z\-]+) [0-9]+} $Aln tmp AlnQ #Espionne "$AlnQ" set nbN [regexp -all -indices {[n]} $AlnQ] #166/201 (83%) regexp {([0-9]+)/([0-9]+) \([0-9]+%\)} $PId_Tmp Tmp nbId nbTot if {$nbId == "" || $nbTot == ""} { #Espionne "Pb avec le PId de $BId" } else { #On ajoute aux bases identiques le nombre de bases N pour palier aux pertes d identite set nbId [expr $nbId + $nbN] set PId [expr ($nbId*100.0)/$nbTot] #Espionne "PId $PId -- $nbId + nbN $nbN / $nbTot" } set Sens [AskBlast $Input BanqueId $BId Segment $j Orientation] scan $Sens "%s / %s" SensQ SensS set DQ_Tmp [AskBlast $Input BanqueId $BId Segment $j DQ] set FQ_Tmp [AskBlast $Input BanqueId $BId Segment $j FQ] if {$DQ_Tmp>$FQ_Tmp} { set FQ $DQ_Tmp set DQ $FQ_Tmp set TailleHSP [expr $DQ_Tmp - $FQ_Tmp + 1] } else { set DQ $DQ_Tmp set FQ $FQ_Tmp set TailleHSP [expr $FQ_Tmp - $DQ_Tmp + 1] } #Espionne "DQ $DQ FQ $FQ $TailleHSP" #Espionne "$BId - $PId - $DS - $FS - $Sens = $SensQ _ $SensS" #2-1-2 Corrections liees au sens sur le chromosome # Attention check a faire pour si on es Minus / Plus auquel cas on intervertit # Ceci est du a un probleme de sens biologique des sequences sondes if {$SensQ=="Plus"} {set SensQ "+"} else {set SensQ "-"} if {$SensS=="Plus"} {set SensS "+"} else {set SensS "-"} if {$SensQ == "-" && $SensS == "+"} { set SensQ "+" set SensS "-" } #Espionne "SensQ $SensQ SensS $SensS" #2-1-3 Inversion des positions selon le sens if {$FS_Tmp > $DS_Tmp} { set FS $FS_Tmp set DS $DS_Tmp } else { set FS $DS_Tmp set DS $FS_Tmp } #Espionne "Test for $DS ($DQ) $FS ($FQ) ($TailleQuery) in $Chromosome $SensS $PId" #2-1-4 Recuperation des informations presentes sur cette localisation # Utilisation a la fois le pourcentage d identite du HSP et du recouvrement # avec les genes mappes sur le genome pour decider si un HSP correspond a ce gene ou non if {$Quoi=="RefSeq"} { set LesIDs_Tmp [LocaliseLesBornesPourRefSeqMoi $DS $FS $Chromosome $SensS $PId $Genome] #Espionne "RefSeq LesIDs_Tmp $LesIDs_Tmp" } elseif {$Quoi=="All"} { set LesIDs_Tmp [LocaliseLesBornesPourRefSeqMoi $DS $FS $Chromosome $SensS $PId $Genome All] #Espionne "All LesIDs_Tmp $LesIDs_Tmp" } else { Espionne "Problem with LocaliseLesBornesPourRefSeq no Quoi (RefSeq ou All)" return "" } if {$LesIDs_Tmp != ""} { #2-1-5 Creation pour chaque ID trouve du recouvrement de la query qui sera ensuite cumulee foreach ID_Tmp $LesIDs_Tmp { #set HSPCover [expr ($TailleHSP * 100.0)/$TailleQuery] set ProfileHSP "" set ProfileHSP "[string repeat "0" [expr $DQ-1]]" append ProfileHSP "[string repeat "1" $TailleHSP]" if {$TailleQuery == $FQ} { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ-1]]" } else { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ]]" } #Espionne "$ProfileHSP" #Espionne "$TailleQuery [string length $ProfileHSP]" #lappend Tab($ID_Tmp,CoverQ) $HSPCover #lappend Tab($ID_Tmp,CoverQ) [list $DQ $FQ] if {! [info exists Tab($ID_Tmp,CoverQ)]} { set Tab($ID_Tmp,CoverQ) "" } lappend Tab($ID_Tmp,CoverQ) $ProfileHSP } set LesIDs [concat $LesIDs $LesIDs_Tmp] } } #2-1-6 Reconstruction pour chaque ID de tous les profils cumules et calcul du recouvrement de la query # Decision final basee sur le FinalCover voir $FinalCoverCutOff foreach UnID [lsort -unique $LesIDs] { set Profile_Tmp "$Profile_Base" set NbTrouve "" #Rq: Ok -- Attention si l addition depasse 9 if {! [info exists Tab($UnID,CoverQ)]} {continue} foreach Profile [set Tab($UnID,CoverQ)] { set Profile_Tmp2 "" foreach a [split $Profile_Tmp ""] b [split $Profile ""] { if {$a=="1"} {append Profile_Tmp2 1; continue} if {$b=="1"} {append Profile_Tmp2 1; continue} if {$b=="0" && $a=="0"} {append Profile_Tmp2 0; continue} } set Profile_Tmp $Profile_Tmp2 } set NbTrouve [regexp -all -indices {[1-9]} $Profile_Tmp] set FinalCover [expr ($NbTrouve*100.0)/$TailleQuery] #Espionne "$Profile_Tmp" #Espionne "$UnID -- NbTrouve: $NbTrouve / $TailleQuery = $FinalCover" if {$FinalCover > $FinalCoverCutOff} {lappend LesIDs_Sel $UnID} } } AskBlast unsetfile $Input set LesIDs_Sel [lsort -unique $LesIDs_Sel] if { $LesIDs_Sel == ""} { set LesIDs_Sel "No IDs found" } Espionne ">>>$NomQuery\t$LesIDs_Sel" return "$LesIDs_Sel" } proc IdentifieLesZonesUCSCPourTous {DirIn} { set total 0; set identique 0; set diff 0; set identiqueAll 0; set diffAll 0 set LesPABs [glob -nocomplain -directory "$DirIn" -tails "*"] foreach PAB $LesPABs { incr total Espionne "" set LesIds [IdentifieLesZonesUCSC "$DirIn/$PAB"] set LesIdsAll [IdentifieLesZonesUCSC "$DirIn/$PAB" All] Espionne "LesIds $LesIds" Espionne "LesIdsAll $LesIdsAll" set AccessExistant [AccessEvi $PAB] Espionne "AccessExistant $AccessExistant" set Gn [ExtraitInfo $PAB "ValiGN"] set AliasGnRna [ExtraitInfo $PAB "AliasGnRna"] set Des [ExtraitInfo $PAB "ValiDE"] Espionne "Gn $Gn" Espionne "AliasGnRna $AliasGnRna" Espionne "Des $Des" set DesUcsc [kgXrefUcscMouse $AccessExistant Des] set GnUcsc [kgXrefUcscMouse $AccessExistant Gn] Espionne "GnUcsc $GnUcsc" Espionne "DesUcsc $DesUcsc" set IdAccProt [ExtraitInfo $PAB "IdAccProt"] set LesProt [split $IdAccProt " "] set AccProt [lindex $LesProt 1] set Texte ""; set Texte2 "" if {$AccProt!=""} { set Commande "getz \"\\\[protein-acc:$AccProt\\\]\" \-vf gen" set Texte [eval exec $Commande] set Commande2 "getz \"\\\[protein-acc:$AccProt\\\]\" \-vf des" set Texte2 [eval exec $Commande2] } set AliasGnProt [ExtraitInfo $PAB "AliasGnProt"] Espionne "GnProt $Texte" Espionne "AliasGnProt $AliasGnProt" Espionne "DesProt $Texte2" if {[regexp $AccessExistant $LesIds]} { incr identique Espionne "c'estlememe" } else { Espionne "attention" incr diff } if {[regexp $AccessExistant $LesIdsAll]} { incr identiqueAll Espionne "c'estlememeAll" } else { Espionne "attentionAll" incr diffAll } } Espionne "total $total identique $identique diff $diff identiqueAll $identiqueAll diffAll $diffAll" return "" } proc IdentifieLesZones_UCSC {Input} { Wup "Identifie a partir d un blast ou d un blat les zones d identite importante sur le genome UCSC" Wup "Fait le lien avec les annotations disponibles et determine la ou les annotations pertinentes" Wup "Utilise 3 cutoff, PId du HSP, Cover du HSP avec un gene, Cover des HSP pour un gene" #0- Recuperation des infos diverses #0-1 Nom de la puce set GoodChip "" foreach AffyChip [Affymetrix_Chips] { if {[regexp -nocase $AffyChip $Input]} {set GoodChip $AffyChip} } #0-2 Nom du genome set Genome "" if { [regexp "^HG" $GoodChip]} { set Genome "human" } elseif {[regexp "^MG" $GoodChip]} { set Genome "mouse" } if {$Genome==""} {return ""} #1- Chargement des infos du Blast ou du Blat set TailleQuery [AskBlast $Input Taille] set NomQuery [AskBlast $Input Query] set NbSbjct [AskBlast $Input NbSubject] if {$NbSbjct=="0" || $NbSbjct==""} {Espionne ">>>[file tail $Input]\tNo blat hit\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery RefSeq]\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery Description]";return ""} set Profile_Base "[string repeat "0" $TailleQuery]" Espionne ">>Q: $NomQuery -- $TailleQuery -- NbSbjct $NbSbjct" #2- Boucle sur les differents subjects set LesIDs "" set LesIDs_Sel "" set FinalCoverCutOff "70.0" for {set i 1} {$i <=$NbSbjct} {incr i} { #Le recouvrement doit etre maximal de notre Query vers Subject #A l inverse on peut etre plus souple dans le sens S vers Q set LesIDs "" set BId [AskBlast $Input Subject $i] set NbSegment [AskBlast $Input BanqueId $BId NbSegment] set Chromosome [string trim $BId] regsub "chr" $Chromosome "" Chromosome #Espionne ">> $BId -- $NbSegment -- $Chromosome" #2-1 Boucle sur les differents HSPs for {set j 1} {$j <=$NbSegment} {incr j} { set LesIDs_Tmp "" set DS "" set FS "" set DS_Tmp "" set FS_Tmp "" set Aln "" set AlnQ "" set nbN "0" set Sens "" set SensQ "" set SensS "" set PId "0.0" set PId_Tmp "" set nbId "" set nbTot "" set DQ "" set FQ "" set DQ_Tmp "" set FQ_Tmp "" set TailleHSP "" #2-1-1 Recuperation des debut et fin, PId set DS_Tmp [AskBlast $Input BanqueId $BId Segment $j DS] set FS_Tmp [AskBlast $Input BanqueId $BId Segment $j FS] set PId_Tmp [AskBlast $Input BanqueId $BId Segment $j Identities] set Aln [AskBlast $Input BanqueId $BId Segment $j AlignLineaire] set Aln [lindex [split $Aln "\n"] 0] #Espionne "$Aln" regexp {^Query:[ ]+[0-9]+ ([a-z\-]+) [0-9]+} $Aln tmp AlnQ set nbN [regexp -all -indices {[n]} $AlnQ] #166/201 (83%) regexp {([0-9]+)/([0-9]+) \([0-9]+%\)} $PId_Tmp Tmp nbId nbTot if {$nbId == "" || $nbTot == ""} { Espionne "Pb avec le PId de $BId" } else { #On ajoute aux bases identiques le nombre de bases N pour palier aux pertes d identite set nbId [expr $nbId + $nbN] set PId [expr ($nbId*100.0)/$nbTot] #Espionne "$PId -- $nbId + $nbN / $nbTot" } set Sens [AskBlast $Input BanqueId $BId Segment $j Orientation] scan $Sens "%s / %s" SensQ SensS set DQ_Tmp [AskBlast $Input BanqueId $BId Segment $j DQ] set FQ_Tmp [AskBlast $Input BanqueId $BId Segment $j FQ] if {$DQ_Tmp>$FQ_Tmp} { set FQ $DQ_Tmp set DQ $FQ_Tmp set TailleHSP [expr $DQ_Tmp - $FQ_Tmp + 1] } else { set DQ $DQ_Tmp set FQ $FQ_Tmp set TailleHSP [expr $FQ_Tmp - $DQ_Tmp + 1] } #Espionne "$BId - $PId - $DS - $FS - $Sens = $SensQ _ $SensS" #2-1-2 Corrections liees au sens sur le chromosome # Attention check a faire pour si on es Minus / Plus auquel cas on intervertit # Ceci est du a un probleme de sens biologique des sequences sondes if {$SensQ=="Plus"} {set SensQ "+"} else {set SensQ "-"} if {$SensS=="Plus"} {set SensS "+"} else {set SensS "-"} if {$SensQ == "-" && $SensS == "+"} { set SensQ "+" set SensS "-" } #2-1-3 Inversion des positions selon le sens if {$FS_Tmp > $DS_Tmp} { set FS $FS_Tmp set DS $DS_Tmp } else { set FS $DS_Tmp set DS $FS_Tmp } #Espionne "Test for $DS ($DQ) $FS ($FQ) ($TailleQuery) in $Chromosome $SensS $PId" #2-1-4 Recuperation des informations presentes sur cette localisation # Utilisation a la fois le pourcentage d identite du HSP et du recouvrement # avec les genes mappes sur le genome pour decider si un HSP correspond a ce gene ou non set LesIDs_Tmp [LocaliseLesBornesPourRefSeq $DS $FS $Chromosome $SensS $PId $Genome] #set LesIDs_Tmp [LocaliseLesBornesPourRefSeq $DS $FS $Chromosome $SensS $PId] if {$LesIDs_Tmp != ""} { #2-1-5 Creation pour chaque ID trouve du recouvrement de la query qui sera ensuite cumulee foreach ID_Tmp $LesIDs_Tmp { #set HSPCover [expr ($TailleHSP * 100.0)/$TailleQuery] set ProfileHSP "" set ProfileHSP "[string repeat "0" [expr $DQ-1]]" append ProfileHSP "[string repeat "1" $TailleHSP]" if {$TailleQuery == $FQ} { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ-1]]" } else { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ]]" } #Espionne "$ProfileHSP" #Espionne "$TailleQuery [string length $ProfileHSP]" #lappend Tab($ID_Tmp,CoverQ) $HSPCover #lappend Tab($ID_Tmp,CoverQ) [list $DQ $FQ] if {! [info exists Tab($ID_Tmp,CoverQ)]} { set Tab($ID_Tmp,CoverQ) "" } lappend Tab($ID_Tmp,CoverQ) $ProfileHSP } set LesIDs [concat $LesIDs $LesIDs_Tmp] } } #2-1-6 Reconstruction pour chaque ID de tous les profils cumules et calcul du recouvrement de la query # Decision final basee sur le FinalCover voir $FinalCoverCutOff foreach UnID [lsort -unique $LesIDs] { set Profile_Tmp "$Profile_Base" set NbTrouve "" #Rq: Ok -- Attention si l addition depasse 9 if {! [info exists Tab($UnID,CoverQ)]} {continue} foreach Profile [set Tab($UnID,CoverQ)] { set Profile_Tmp2 "" foreach a [split $Profile_Tmp ""] b [split $Profile ""] { if {$a=="1"} {append Profile_Tmp2 1; continue} if {$b=="1"} {append Profile_Tmp2 1; continue} if {$b=="0" && $a=="0"} {append Profile_Tmp2 0; continue} } set Profile_Tmp $Profile_Tmp2 } set NbTrouve [regexp -all -indices {[1-9]} $Profile_Tmp] set FinalCover [expr ($NbTrouve*100.0)/$TailleQuery] Espionne "$Profile_Tmp" Espionne "$UnID -- NbTrouve: $NbTrouve / $TailleQuery = $FinalCover" if {$FinalCover > $FinalCoverCutOff} {lappend LesIDs_Sel $UnID} } } AskBlast unsetfile $Input set LesIDs_Sel [lsort -unique $LesIDs_Sel] if { $LesIDs_Sel == ""} { set LesIDs_Sel "No IDs found" } Espionne ">>>$NomQuery\t$LesIDs_Sel\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery RefSeq]\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery Description]" return "$LesIDs_Sel" } proc IdentiteEtSimilariteDansMSF {FichierMSF {OrgaDeReference ""}} { global RepertoireDuGenome global MatriceDeSimilarite global NotreOS global NotreOrga if { ! [info exists MatriceDeSimilarite] } { set OnAttendPP 1 set FichierSimilariteDefaut "[GscopeEtc]/gscope_similarite" set FichierSimilarite "[RepertoireDuGenome]/fiches/similarite" if { ! [file exists $FichierSimilarite]} { set FichierSimilarite $FichierSimilariteDefaut } foreach Ligne [LesLignesDuFichier $FichierSimilarite] { if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue } if {[regexp {\.\.} $Ligne]} { regsub {\.\.} $Ligne "" Ligne while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne } set LesAAs [split [string trim $Ligne] " "] set LesAAsRestants $LesAAs set OnAttendPP 0 continue } if {$OnAttendPP} { continue } set Ligne [string toupper $Ligne] set AACourant [lindex $LesAAsRestants 0] while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne } set nRestants [llength $LesAAsRestants] set LesScores [lrange [split [string trim $Ligne] " "] 0 [incr nRestants -1]] foreach AA $LesAAsRestants Score $LesScores { set MatriceDeSimilarite($AACourant,$AA) $Score set MatriceDeSimilarite($AA,$AACourant) $Score } set LesAAsRestants [lrange $LesAAsRestants 1 end] } foreach AA $LesAAs { set Ligne "" foreach BB $LesAAs { append Ligne " [format "%4.1f" [set MatriceDeSimilarite($AA,$BB)]]" } } } if {$OrgaDeReference==""} { set OrgaDeReference $NotreOrga } set Nom [file tail $FichierMSF] set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences] if {$NombreDeSequences<2} { return {} } set MaxLongueurSequence [string length [set Sequences([lindex $LesSequencesDansLOrdre 0])]] if {$OrgaDeReference == "QueryInFirstPlace"} { set SeqPAB $Sequences([lindex $LesSequencesDansLOrdre 0]) } elseif {$OrgaDeReference == $NotreOrga} { if { ! [info exists Sequences($Nom)]} { return {} } set SeqPAB [set Sequences($Nom)] } else { set iOrgaRef [lsearch -regexp $LesSequencesDansLOrdre $OrgaDeReference] if {$iOrgaRef < 0} { return {} } set SeqPAB [set Sequences([lindex $LesSequencesDansLOrdre $iOrgaRef])] } set lSeqPAB [string length $SeqPAB] foreach NomSeq $LesSequencesDansLOrdre { set Seq [string toupper [set Sequences($NomSeq)]] set lSeq [string length $Seq] set CumulScore 0 set nCumulScore 0 set CumulId 0 set nCumulId 0 set Commun "" set LongVraiePAB 0 set LongVraieSeq 0 set nLesDeuxSansPoints 0 set nAuMoinsUnSansPoint 0 set PS_LongVraiePAB 0 set PS_LongVraieSeq 0 set PS_nLesDeuxSansPoints 0 set PS_nAuMoinsUnSansPoint 0 for {set i 0} {$i<$lSeqPAB} {incr i} { if {$i >= $lSeq} { break } set AA [string range $SeqPAB $i $i] set BB [string range $Seq $i $i] if { $AA!="." } { incr LongVraiePAB } if { $BB!="." } { incr LongVraieSeq } if { $AA!="." && $BB!="." } { incr nLesDeuxSansPoints } if { $AA!="." || $BB!="." } { incr nAuMoinsUnSansPoint } if { $AA!="." && $AA==$BB } { incr CumulId } if {[info exists MatriceDeSimilarite($AA,$BB)]} { if { $AA!="." } { incr PS_LongVraiePAB } if { $BB!="." } { incr PS_LongVraieSeq } if { $AA!="." && $BB!="." } { incr PS_nLesDeuxSansPoints } if { $AA!="." || $BB!="." } { incr PS_nAuMoinsUnSansPoint } set Score [set MatriceDeSimilarite($AA,$BB)] set CumulScore [expr $CumulScore + $Score] } } set PI($NomSeq) [expr $CumulId*100/[Maxi 1 $nLesDeuxSansPoints]] # set PI($NomSeq) [expr $CumulId*100/[Maxi 1 $nAuMoinsUnSansPoint] # set PI($NomSeq) [expr $CumulId*100/[Maxi 1 [Mini $LongVraiePAB $LongVraieSeq]]] set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 $PS_nLesDeuxSansPoints]] # set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 $PS_nAuMoinsUnSansPoint] # set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 [Mini $PS_LongVraiePAB $PS_LongVraieSeq]]] lappend LesPIs "$NomSeq [format "%6.3f" [set PI($NomSeq)]]" lappend LesPSs "$NomSeq [format "%6.3f" [set PS($NomSeq)]]" lappend LesPIPSs "$NomSeq [format "%6.3f" [set PI($NomSeq)]] [format "%6.3f" [set PS($NomSeq)]]" } Wup "Choisir le bon .................!!!! " return $LesPIPSs return $LesPIs return $LesPSs } proc IdentityProfileGUI {} { global LNDG SDG LNOrdali ListeDesPiliersDuGroupe PrI ScoreMeth ListeTypesDeFeatures TabSF LongueurTotale Sequences PrI set ret 0 set w .prmip toplevel $w wm title $w "Identity Profile" wm iconname $w "Profile" wm protocol $w WM_DELETE_WINDOW KillParLaCroix grid columnconfig $w all -weight 1 grid rowconfig $w all -weight 1 set wf $w.f frame $wf grid $wf -row 0 -column 0 label $wf.lb -text "Identity Profile :" -font "Helvetica 14 bold" set ws $wf.fs frame $ws label $ws.lbw -text "Sliding window : " set Lgw [list 10 20 50 100] ttk::combobox $ws.cbw -state readonly -background white -width 6 -values $Lgw -textvariable PrI(win) $ws.cbw current 0 label $ws.lbs -text "Jump step size : " set Lgs [list 1 5 10 20 50] ttk::combobox $ws.cbs -state readonly -background white -width 6 -values $Lgs -textvariable PrI(jump) $ws.cbs current 0 label $ws.lbg -text "Groups : " set Lgr [list "All" "Global" {*}[lrange LNDG 1 end]] ttk::combobox $ws.cbg -state readonly -background white -width 10 -values $Lgr -textvariable PrI(grp) $ws.cbg current 0 set PrI(CSV) 0 checkbutton $ws.cks -text "Save profile data as CSV" -variable PrI(CSV) -relief flat -highlightthickness 0 -onvalue 1 -offvalue 0 grid $ws.lbw -row 0 -column 0 -sticky e -pady {10 2} grid $ws.cbw -row 0 -column 1 -sticky w -pady {10 2} grid $ws.lbs -row 1 -column 0 -sticky e -pady 2 grid $ws.cbs -row 1 -column 1 -sticky w -pady 2 grid $ws.lbg -row 2 -column 0 -sticky e -pady 2 grid $ws.cbg -row 2 -column 1 -sticky w -pady 2 grid $ws.cks -row 3 -column 0 -columnspan 2 -sticky w -pady {5 10} grid columnconfig $ws all -weight 1 set wb $wf.fb frame $wb button $wb.bok -text " OK " -background green1 -command {set PrI(ret) 1 ; destroy .prmip} button $wb.bdis -text "Dismiss" -background red -command {set PrI(ret) 0 ; destroy .prmip} grid $wb.bdis -row 0 -column 0 -sticky w grid $wb.bok -row 0 -column 1 -sticky e grid columnconfig $wb all -weight 1 grid $wf.lb -row 0 -column 0 -padx 10 -pady 10 grid $ws -row 1 -column 0 -padx 10 -pady {5 10} grid $wb -row 2 -column 0 -padx 10 -pady 10 -sticky ew FenetreAuCentre $w tkwait window $w update idletasks if {! $PrI(ret)} {return} LanceIdentityProfile if {[QuelMode] eq "feature"} { DetruitBoutonsOrdali update foreach f [grid slaves $::FrmBouton] { puts "f= $f" foreach s [grid slaves $f] { puts " s= $s" foreach q [grid slaves $s] { puts " q= $q" } } } AfficheBoutonsFeatures } return } proc IemeLigneDuFichier {Fichier i} { return [lindex [LesLignesDuFichier $Fichier] [incr i -1]] } proc IlFautVoir {cmd} { global VersViewer global COmac global Cras # O macro file if {$VersViewer == "VersOmac"} { if {[regexp "DebutDb" $cmd]} { global LCOTmp global NomDb global NomMc set LCOTmp {} set NomDb [string trim [string range $cmd 8 end]] set NomMc "" return } if {[regexp "DebutMc" $cmd]} { global LCOTmp global NomMc global NomDb set LCOTmp {} set NomMc [string trim [string range $cmd 8 end]] set NomDb "" return } if {$cmd == "FinDbMc"} { global COmac global LCOTmp global NomDb global NomMc set nl [llength $LCOTmp] if {$NomDb == ""} { set nom "@$NomMc" } else { set nom "$NomDb" } puts $COmac "$nom T $nl 50" foreach c $LCOTmp { puts $COmac $c } unset LCOTmp set NomDb "" set NomMc "" return } if {$cmd == "FinOMac"} { close $COmac } else { global LCOTmp if {![info exists LCOTmp]} { puts $COmac $cmd } else { lappend LCOTmp $cmd } } return } $VersViewer $cmd return } proc Illumine {Mot Fenetre} { if {[PourWscope]} { return } if {[regexp ".list$" $Fenetre]} { set FenetreListBox $Fenetre } else { set FenetreListBox $Fenetre.frame.list } set i 0 set AttendDebutDeSequence 1 foreach Ligne [$FenetreListBox get 0 end] { if { [regexp $Mot $Ligne] } { if {$AttendDebutDeSequence && [regexp "$Mot\[ \.\]+\[A-Z\]" $Ligne]} { set Position $i set AttendDebutDeSequence 0 } $FenetreListBox selection set $i $FenetreListBox see $i } incr i } if {[info exists Position]} { set Position [Maxi 0 [expr $Position-20]] $FenetreListBox see $Position } } proc IllumineLaListe {Liste Fenetre} { set BonneListe {} foreach Element $Liste { regsub -all {\|} $Element "\\|" Element lappend BonneListe $Element } set Mot [join $BonneListe "|"] Illumine $Mot $Fenetre } proc IllumineLeGroupeDe {Nom Fenetre {Ask ""} {Maniere ""}} { if {$Ask==""} { set Ask "Secator" } if {$Ask=="Ask"} { set Ask [ChoixParmi [list "Secator" "Dpc" "Oumy" "SecatorSelect" "DpcSelect" "OumySelect"]] } if {$Ask==""} { return "" } if {[regexp "Select" $Ask]} { set Select 1 regsub "Select" $Ask "" Ask } else { set Select 0 } foreach Access [Groupe$Ask $Nom $Nom "In"] { Illumine $Access $Fenetre } if { ! $Select} { return $Fenetre } global PagePropre set Page [set PagePropre($Fenetre)] return [AfficheRognure $Page [selection get] "GrandeLargeur$Maniere" "${Ask}_group_selection_of/$Nom"] } proc IllumineSuivantLesGroupes {LesAGs Fenetre} { set OldG Bidon set Lumiere 0 foreach Ligne $LesAGs { scan $Ligne "%s %s" A G if {$OldG!=$G} { set Lumiere [expr ! $Lumiere] } set OldG $G if {$Lumiere} { Illumine $A $Fenetre } } } proc IllustreArborescenceDeLOntology {{LesGO ""} {LesTypes ""}} { global PosYSurArbreGO if {$LesTypes == "All"} {set LesTypes [Onto LesTypes]} if {$LesGO == "All"} { set LesGO {} foreach Type $LesTypes { foreach GO [Onto $Type LesGO] {lappend LesGO $GO} } } set HauteurFenetre [expr [winfo screenheight .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set BordX [expr $LargeurFenetre * 1.0 / 20] set BordY [expr $HauteurFenetre * 1.0 / 20] set EcartX 30 set EcartY 15 set PosYSurArbreGO $BordY set Police "arial 10" set TabGOSelectionnes(LesGO) {} set TabGOSelectionnes(LesTypes) $LesTypes foreach Type $LesTypes {set TabGOSelectionnes($Type) 1} foreach GO $LesGO { set Type [Onto $GO Type] if {[info exists TabGOSelectionnes($GO)]} {continue} lappend TabGOSelectionnes(LesGO) $GO set TabGOSelectionnes($GO) 1 set TabGOSelectionnes($GO,Color) "darkgreen" foreach Ancetre [TousLesAncetresOntologiques $Type $GO] { if {[info exists TabGOSelectionnes($Ancetre)]} {continue} lappend TabGOSelectionnes(LesGO) $Ancetre set TabGOSelectionnes($Ancetre) 1 } } set LesInfos [LesInfosDesGOSurLArborescence "GO:0003673" $BordX "black" {} TabGOSelectionnes] set LargeurMax $LargeurFenetre set HauteurMax [expr 2 * $BordY + [llength $LesInfos] * $EcartY] if {$HauteurMax < $HauteurFenetre} {set HauteurMax $HauteurFenetre} set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY] foreach LInfo $LesInfos { set GO [lindex $LInfo 0] set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set X [lindex $LInfo 1] set Y [lindex $LInfo 2] if {[info exists TabGOSelectionnes($GO,Color)]} { set Color [set TabGOSelectionnes($GO,Color)] set PoliceGO "$Police bold" } else { set PoliceGO $Police set Color [lindex $LInfo 3] } $K create text $X $Y -text "$GO : $Def" -anchor w -fill $Color -font $PoliceGO set TabDejaVu($X,$Y) 1 if {$X <= $BordX} {continue} set OldX [expr $X - $EcartX] set OldY [expr $Y - $EcartY] while {![info exists TabDejaVu($OldX,$OldY)]} { if {$OldY <= $BordY} {break} set OldY [expr $OldY - $EcartY] } $K create line $X $Y $OldX $Y -fill $Color $K create line $OldX $Y $OldX $OldY -fill $Color } return } proc IllustreArbreTaxonsSelectionnes {} { set LesTaxonsInteressants [MorceauxChoisis [lsort [O2C2O LesCategories]]] IllustreLArbreTaxonomique $LesTaxonsInteressants return } proc IllustreBACCGH {Cas {LesPos ""} {LesNoms ""}} { # liste des cas if {$Cas!="meta" && $Cas!="nometa"} { set LesCas $Cas Espionne $LesCas } if {$Cas=="meta"} { set LesCas {BAC806 BAC807 BAC810 BAC817 BAC818 BAC819 BAC826 BAC827} } elseif {$Cas=="nometa"} {set LesCas {BAC808 BAC809 BAC811 BAC812 BAC814 BAC815 BAC816 BAC820 BAC821 BAC822 BAC823 BAC825}} set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoite 10 set EcartEntreRepresentations 100 #en fct du nb de plots- plus grande val- apres ascenseur. set HauteurMax [expr $BordY + [expr [llength $LesCas]-1]*$HauteurBoite + [llength $LesCas]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosXMin $BordX set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0) + ($TailleChromo*1.0)] } set Facteur [expr ($LargeurAffichage*1.0)/ ($TailleGenome*1.0)] # pour chaque fichier BAC foreach BAC $LesCas { Espionne $BAC if {$Cas!="meta" && $Cas!="nometa"} { set FichierCourbeBAC $BAC } else { set FichierCourbeBAC "[RepertoireDuGenome]/PRIMA_CGH/$BAC" } set NomFichierBAC [file tail $FichierCourbeBAC] # HR: #set VMax 3.12 #set VMin -1.29 # meta: set VMax 2.74 set VMin -2.85 set VMaxf $VMax set VMinf $VMin set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] if {[info exists TabC]} {unset TabC} ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set DebutCentro [expr $DebutCentro*1.0 + $TailleChroCum*1.0] set FinCentro [expr $FinCentro*1.0 + $TailleChroCum*1.0] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] { set PosMid [Base10 [lindex $LInfo 1]] #tenir compte des chros precedents set PosMid [expr $PosMid*1.0 + $TailleChroCum*1.0] set Val [lindex $LInfo 2] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro} { # x1 est avant le debut du centro et x2 dedans set X1 $PosMid set Y1 $Value continue } if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { # aucun point dans le centromere set X1 $PosMid set Y1 $Value } if {($X1>=$DebutCentro && $X1<=$FinCentro) && ($PosMid>=$DebutCentro && $PosMid<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } if {$X1<=$FinCentro && $PosMid>=$FinCentro && $X1>=$DebutCentro} { # x1 est avant la fin du centro et x2 apres le centromere set X1 $PosMid set Y1 $Value } set PosX1 [expr $BordX + ($X1*$Facteur*1.0)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY*1.0) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur*1.0)] set PosY2 [expr $PosYMin + ($Value*$FacteurY*1.0) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $LesCas "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierBAC CGH plot " -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr ($TailleChroCum*1.0) + ($TailleChromo*1.0)] } set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] } #### fin boucle ### LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneCGH $K" regsub {\.canvas} $K "" w #set B [BoutonneLaFenetre $w "WithMapViewer/WithoutMapViewer\nOnlyBestLoc/All"] #bind $B <1> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithMapViewer" #bind $B <2> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithoutMapViewer" #set C [BoutonneLaFenetre $w "Histogramm"] #bind $C <1> "ChoixHistogramme" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreBACCGHseg {Cas {LesPos ""} {LesNoms ""}} { if {$Cas!="" && $Cas!="null"} { set LesCas $Cas Espionne $LesCas } set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoite 10 set EcartEntreRepresentations 100 #en fct du nb de plots- plus grande val- apres ascenseur. set HauteurMax [expr $BordY + [expr [llength $LesCas]-1]*$HauteurBoite + [llength $LesCas]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0) + ($TailleChromo*1.0)] } # Attention au *1.0 !!! indispensable pour windows! (sinon taille du genome, negative! donc facteur negatif) set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] # pour chaque fichier BAC foreach BAC $LesCas { Espionne $BAC set FichierCourbeBACSeg $BAC set NomFichierBACSeg [file tail $FichierCourbeBACSeg] # HR: set VMax 1.76 set VMin -0.89 # meta: #set VMax 1.93 #set VMin -2.23 set VMaxf $VMax set VMinf $VMin set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierSEG TabO $FichierCourbeBACSeg $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [expr [lindex $LInfo 3]+ $TailleChroCum] set PosSup [expr [lindex $LInfo 4]+ $TailleChroCum] set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $LesCas "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierBACSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum + $TailleChromo] } set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] } LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" #$K bind "Chromosome" <1> "ac_ChromosomeSelectionneSEG $K" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneCGH_seg $K" regsub {\.canvas} $K "" w bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreCGH {{LesPos ""} {LesNoms ""} {w ""}} { ##################### Compulsory files ############################### set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" if {![file exists $FichierPosCentro] || ![file exists $FichierChros]} { Espionne "Either \"PosCentromeres\" or \"chromInfo\" or both files does/do not exist" return } set FichierReadme "[RepertoireDuGenome]/CGHviewer.readme" if {[file exists $FichierReadme]} { set Contenu [ContenuDuFichier $FichierReadme] ac_AfficheVariable "$Contenu" "" "CGHviewer.readme" } else { FaireLire "! WARNING !\n \"CGHviewer.readme\" does not exist" } ###################### Welcome Canva ####################################### set w ".canva" if {[winfo exists $w]} { wm deiconify $w raise $w return "" } else { toplevel $w } wm geometry $w +300+100 wm title $w "Welcome" wm resizable $w true false wm protocol $w WM_DELETE_WINDOW "destroy $w" set FParameters "$w.fparameters" frame $FParameters -relief "groove" pack $FParameters -fill both -expand no set Nom "Bienvenue" set FSetup "$FParameters.fsetup${Nom}" set LSetup "$FSetup.lsetup" frame $FSetup -background "#808080" -relief "groove" -padx "0" pack $FSetup -side top -fill both -expand no label $LSetup -background "#808FFF" -relief "groove" -text "Welcome to CGHviewer!" -font "Courier 20" -width "24" -anchor "center" pack $LSetup -side left -fill both -expand no ###################### Retrieve the CGH data ############################### ## 1) file BAC set n 0 if {[OuiOuNon "Do you have BAC-CGH-array data?"]} { if {[OuiOuNon "Is your file a tab-delimited text file?"]} { FaireLire "Please, Choose your BAC CGH-array file. Thank you!" set FichierCourbeBAC [tk_getOpenFile -title "BAC CGH-array file to open"] set NomFichierCourbeBAC [file tail $FichierCourbeBAC] regsub "$NomFichierCourbeBAC" $FichierCourbeBAC "" DirFileToOpen if {[regexp "\:" $DirFileToOpen]} {regsub {[A-Z]\:} $DirFileToOpen "" DirFileToOpen} set DirFileToOpen "\"$DirFileToOpen\"" Espionne $DirFileToOpen # ds FichierCourbeBAC y a le chemin du fichier (FaireLire $FichierCourbeBAC) # tests verifs # si fichier deja ok (le mien) passer les controles foreach Ligne [LesLignesDuFichier $FichierCourbeBAC] { incr n set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp "^HS" $Ligne]} { set RepFichierLocCGHBAC "PRIMA_CGH" set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_Localisation" break } elseif {[regexp -nocase "LOG" $Ligne]} { set Num $n FaireLire "The line $n contains the column titles" # Chro(HS) Deb Fin (PosMid) Log2Ratio (CopyNb) Nom Id (Other) # la premiere ligne contiendrait les titres de colonnes si excel-> tab-delimited file FaireLire "Which column contains the chromosome number?" set nChro [Entre 8] FaireLire "Which column contains the chromosome start position?" set nStart [Entre 9] FaireLire "Which column contains the chromosome end position?" set nEnd [Entre 10] FaireLire "Which column contains the logratio?" set nLogRatio [Entre 16] FaireLire "Which column contains the BAC ID?" set nID [Entre 6] } if {[info exists Num]} { if {$n>$Num} { set LesElts [split $Ligne "\t"] set Chro [lindex $LesElts [expr $nChro -1]] if {[regexp {^[a-z]+} $Chro]} {set Chro [string toupper $Chro]} elseif {$Chro<10} {set Chro "0$Chro"} set Chromosome "HS$Chro" set Start [lindex $LesElts [expr $nStart -1]] set End [lindex $LesElts [expr $nEnd -1]] set PosMid [expr $Start + (($End*1.0 - $Start*1.0)/2)] set LogRatio [lindex $LesElts [expr $nLogRatio -1]] if {[regexp "," $LogRatio]} {regsub "," $LogRatio "." LogRatio} if {$LogRatio=="#N/A"} {set LogRatio ""} set ID [lindex $LesElts [expr $nID -1]] lappend LeFichierCourbeBAC "$Chromosome\t$PosMid\t$LogRatio" lappend LeFichierBACLocalisation "$Chromosome\t$Start\t$End\t$ID" } } } if {[info exists LeFichierCourbeBAC] && [info exists LeFichierBACLocalisation]} { set LeFichierCourbeBAC [lsort -command CompareChroDebut $LeFichierCourbeBAC] #set LeFichierCourbeBAC [lsort -increasing $LeFichierCourbeBAC] set LeFichierBACLocalisation [lsort -command CompareChroDebut $LeFichierBACLocalisation] set LeFichierBACLocalisation [lsort -command CompareChroFin $LeFichierBACLocalisation] #set LeFichierBACLocalisation [lsort -increasing $LeFichierBACLocalisation] set RepFichierCrees "[RepertoireDuGenome]/FichiersCrees" if {![file exists $RepFichierCrees]} {File mkdir $RepFichierCrees} set FichierCourbeBAC "$RepFichierCrees/$NomFichierCourbeBAC" set RepFichierLocCGHBAC "FichiersCrees" set FichierLocCGHBAC "$RepFichierCrees/CGH_BAC_Localisation" if {![file exists $FichierLocCGHBAC]} { SauveLesLignes $LeFichierBACLocalisation dans $FichierLocCGHBAC } SauveLesLignes $LeFichierCourbeBAC dans $FichierCourbeBAC } } else { FaireLire "Please, if you have a MS Excel file, save it as a tab-delimited text file.\nThank you" exit } set BACdata 1 } else { Espionne "No BAC data" set BACdata 0 set FichierCourbeBAC "null" set RepFichierLocCGHBAC "null" } if {[info exists Num]} {unset Num} ## 2) File oligo set n 0 if {[OuiOuNon "Do you have Oligo-CGH-array data?"]} { if {[OuiOuNon "Is your file a tab-delimited text file?"]} { FaireLire "Please, Choose your Oligo CGH-array file. Thank you!" set FichierCourbeOligo [tk_getOpenFile -title "Oligo CGH-array file to open"] set NomFichierCourbeOligo [file tail $FichierCourbeOligo] regsub "$NomFichierCourbeOligo" $FichierCourbeOligo "" DirFileToOpen if {[regexp "\:" $DirFileToOpen]} {regsub {[A-Z]\:} $DirFileToOpen "" DirFileToOpen} set DirFileToOpen "\"$DirFileToOpen\"" Espionne $DirFileToOpen # verifs data # si fichier deja ok (le mien) passer les controles foreach Ligne [LesLignesDuFichier $FichierCourbeOligo] { incr n set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp "^HS" $Ligne]} { set RepFichierLocCGHOligo "PRIMA_CGH" set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_Localisation" break } elseif {[regexp "^FEATURES" $Ligne] && [regexp -nocase "LOG" $Ligne]} { set Num $n FaireLire "The line $n contains the titles" # Chro Deb Fin Nom Id Access GN Def Log10Ratio (Error Pvalue) Access ProbeName (GeneName Des) # la 10 ieme ligne commencant par "FEATURES" contient les titres des colonnes FaireLire "Which column contains the chromosome number?" set nChro [Entre 12] FaireLire "Which column contains the chromosome start position?" set nStart [Entre 12] FaireLire "Which column contains the chromosome end position?" set nEnd [Entre 12] FaireLire "Which column contains the logratio?" set nLogRatio [Entre 16] FaireLire "Which column contains the probe name?" set nID [Entre 10] } if {[info exists Num]} { if {$n>$Num} { set LesElts [split $Ligne "\t"] if {$nChro==$nStart && $nStart==$nEnd} { # chro debut fin sont ensemble set Loc [lindex $LesElts [expr $nChro -1]] if {[regexp "^chr" $Loc]} { set LesEltsLoc [split $Loc ":"] set Chro [lindex $LesEltsLoc 0] if {[regexp "chr" $Chro]} {regsub "chr" $Chro "" Chro} if {$Chro<10} {set NewChro "HS0$Chro"} else {set NewChro "HS$Chro"} set Bornes [lindex $LesEltsLoc 1] set LesBornes [split $Bornes "-"] set Debut [lindex $LesBornes 0] #regsub -all {^0*} $Debut "" Debut set Debut [Base10 $Debut] set Fin [lindex $LesBornes 1] #regsub -all {^0*} $Fin "" Fin set Fin [Base10 $Fin] set PosMid [expr $Debut + (($Fin*1.0 - $Debut*1.0)/2)] } else {continue} } # else ?? set LogRatio [lindex $LesElts [expr $nLogRatio -1]] if {[regexp "," $LogRatio]} {regsub "," $LogRatio "." LogRatio} if {$LogRatio=="#N/A"} {set LogRatio ""} if {[regexp "^e" $LogRatio]} {set LogRatio "1$LogRatio"} scan $LogRatio "%f" Val set ID [lindex $LesElts [expr $nID -1]] lappend LeFichierCourbeOligo "$NewChro\t$Debut\t$Fin\t$Val" lappend LeFichierOligoLocalisation "$NewChro\t$Debut\t$Fin\t$ID" } } } if {[info exists LeFichierCourbeOligo] && [info exists LeFichierOligoLocalisation]} { # tri par ordre croissant set LeFichierCourbeOligo [lsort -command CompareChroDebut $LeFichierCourbeOligo] set LeFichierCourbeOligo [lsort -command CompareChroFin $LeFichierCourbeOligo] #set LeFichierCourbeOligo [lsort -increasing $LeFichierCourbeOligo] set LeFichierOligoLocalisation [lsort -command CompareChroDebut $LeFichierOligoLocalisation] set LeFichierOligoLocalisation [lsort -command CompareChroFin $LeFichierOligoLocalisation] #set LeFichierOligoLocalisation [lsort -increasing $LeFichierOligoLocalisation] set RepFichierCrees "[RepertoireDuGenome]/FichiersCrees" if {![file exists $RepFichierCrees]} {File mkdir $RepFichierCrees} set FichierCourbeOligo "$RepFichierCrees/$NomFichierCourbeOligo" set RepFichierLocCGHOligo "FichiersCrees" set FichierLocCGHOligo "$RepFichierCrees/CGH_Oligo_Localisation" SauveLesLignes $LeFichierCourbeOligo dans $FichierCourbeOligo if {![file exists $FichierLocCGHOligo]} { SauveLesLignes $LeFichierOligoLocalisation dans $FichierLocCGHOligo } } } else { FaireLire "Please, if you have a MS Excel file, save it as a tab-delimited text file.\nThank you" exit } set OligoData 1 } else { Espionne "No Oligo data" set OligoData 0 set FichierCourbeOligo "null" set RepFichierLocCGHOligo "null" } if {$BACdata==0 && $OligoData==0} {return} FaireAttendreAnnaick .fenetre "Running" "Please wait..." # Either BAC plot or Oligo plot or both plots will be displayed if {$BACdata==0} { set NomFichierOligo [file tail $FichierCourbeOligo] set NomFichierBAC "null" } if {$OligoData==0} { set NomFichierBAC [file tail $FichierCourbeBAC] set NomFichierOligo "null" } if {$BACdata!=0 && $OligoData!=0} { set NomFichierOligo [file tail $FichierCourbeOligo] set NomFichierBAC [file tail $FichierCourbeBAC] } ############################### Variables ################################## # Remark: for the article : the texte was done in Adobe Illustrator set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoite + 2*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 3076781887.0 # (TailleGenome was obtained by summing the chromosomes sizes) set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] ######################## Plot CGH BAC ####################################### if {$BACdata!=0} { set VMin [InterrogeFichierCourbeCGH $FichierCourbeBAC VMin] set VMax [InterrogeFichierCourbeCGH $FichierCourbeBAC VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set DebutCentro [expr $DebutCentro*1.0 + $TailleChroCum*1.0] set FinCentro [expr $FinCentro*1.0 + $TailleChroCum*1.0] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] { set PosMid [Base10 [lindex $LInfo 1]] #tenir compte des chros precedents set PosMid [expr $PosMid*1.0 + $TailleChroCum*1.0] set Val [lindex $LInfo 2] if {$Val==""} {continue} set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro} { # x1 est avant le debut du centro et x2 dedans set X1 $PosMid set Y1 $Value continue } if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { # aucun point dans le centromere set X1 $PosMid set Y1 $Value } if {($X1>=$DebutCentro && $X1<=$FinCentro) && ($PosMid>=$DebutCentro && $PosMid<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } if {$X1<=$FinCentro && $PosMid>=$FinCentro && $X1>=$DebutCentro} { # x1 est dans le centromere et x2 apres le centromere set X1 $PosMid set Y1 $Value } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 # Echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] # Ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} # Lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 # Texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeBAC $FichierCourbeOligo $RepFichierLocCGHBAC $RepFichierLocCGHOligo "Chromosome"] # Petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 # Val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" # Val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" # Echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierBAC CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum + $TailleChromo] } } ######################## Plot CGH Oligo ####################################### if {$OligoData!=0} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set x [InterrogeFichierCourbeCGH $FichierCourbeOligo "unset"] set y [InterrogeFichierCentromere $FichierPosCentro "unset"] set VMin [InterrogeFichierCourbeCGH $FichierCourbeOligo VMin] set VMax [InterrogeFichierCourbeCGH $FichierCourbeOligo VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierCourbeCGH TabO $FichierCourbeOligo $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] # NB: Positions centromere, Tenir compte des chromosomes precedents! set DebutCentro [expr $DebutCentro*1.0 + $TailleChroCum*1.0] set FinCentro [expr $FinCentro*1.0 + $TailleChroCum*1.0] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] { set Pos10 [Base10 $Pos] set PosMid [expr $Pos10*1.0 + $TailleChroCum*1.0] foreach LInfo [set TabO($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] { set Val [lindex $LInfo 3] if {$Val==""} {continue} set Val [expr $Val*log(10)/log(2)] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro} { # x1 est avant le debut du centro et x2 dedans set X1 $PosMid set Y1 $Value continue } if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { # aucun point dans le centromere set X1 $PosMid set Y1 $Value } if {($X1>=$DebutCentro && $X1<=$FinCentro) && ($PosMid>=$DebutCentro && $PosMid<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } if {$X1<=$FinCentro && $PosMid>=$FinCentro && $X1>=$DebutCentro} { # x1 est ds le centromere et x2 apres le centromere set X1 $PosMid set Y1 $Value } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 # Echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] # Ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} # Lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 # Texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeBAC $FichierCourbeOligo $RepFichierLocCGHBAC $RepFichierLocCGHOligo "Chromosome"] # Petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 # Val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" # Val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" # Echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierOligo CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum*1.0 + $TailleChromo*1.0] } } ############################## Display, buttons ################################################## LesNomsEnStock $K $LesNoms $K bind "CGHOligo" "DevoileLePlot $K %x %y Enter" $K bind "CGHOligo" "DevoileLePlot $K %x %y Leave" $K bind "CGHOligo" <1> "AfficheLePlot $K" if {$BACdata!=0} { $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "CGH" <1> "AfficheLePlot $K" } $K bind "Chromosome" <1> "ac_ChromosomeSelectionne $K" regsub {\.canvas} $K "" w set D [BoutonneLaFenetre $w "All_seg"] $D configure -background "yellow" bind $D <1> "IllustreCGHAll_seg $DirFileToOpen" set C [BoutonneLaFenetre $w "All"] $C configure -background "orange" bind $C <1> "IllustreCGHAll $DirFileToOpen" set B [BoutonneLaFenetre $w "CBS"] $B configure -background "#808FFF" bind $B <1> "IllustreCGH_seg $NomFichierBAC $NomFichierOligo $DirFileToOpen" set A [BoutonneLaFenetre $w "WithCBS"] $A configure -background "green" bind $A <1> "IllustreCGHAvtEtApresSeg $DirFileToOpen" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" FaireLaSuiteAnnaick .fenetre return $K } proc IllustreCGHAll {DirFileToOpen} { if {$DirFileToOpen==""} {set DirFileToOpen $RepertoireDuGenome} if {[OuiOuNon "Do you want to display CGH-BAC data?"]} { FaireLire "Please, download your first file. Thank you!" set FichierCourbeBAC [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersBAC $FichierCourbeBAC while {[OuiOuNon "Do you have an other file to download?"]} { set FichierCourbeBAC [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersBAC $FichierCourbeBAC } IllustreBACCGH $LesFichiersBAC } elseif {[OuiOuNon "Do you want to display CGH-Oligo data?"]} { FaireLire "Please, download your first file. Thank you!" set FichierCourbeOligo [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersOligo $FichierCourbeOligo while {[OuiOuNon "Do you have an other file to download?"]} { set FichierCourbeOligo [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersOligo $FichierCourbeOligo } IllustreOligoCGH $LesFichiersOligo } } proc IllustreCGHAll_seg {DirFileToOpen} { if {$DirFileToOpen==""} {set DirFileToOpen $RepertoireDuGenome} if {[OuiOuNon "Do you want to display aCGH BAC segmented data?"]} { FaireLire "Please, download your first file. Thank you!" set FichierCourbeBACseg [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersBACseg $FichierCourbeBACseg while {[OuiOuNon "Do you have an other file to download?"]} { set FichierCourbeBACseg [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersBACseg $FichierCourbeBACseg } IllustreBACCGHseg $LesFichiersBACseg } elseif {[OuiOuNon "Do you want to display aCGH Oligo segmented data?"]} { FaireLire "Please, download your first file. Thank you!" set FichierCourbeOligoseg [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersOligoseg $FichierCourbeOligoseg while {[OuiOuNon "Do you have an other file to download?"]} { set FichierCourbeOligoseg [tk_getOpenFile -title "File to open" -initialdir $DirFileToOpen] lappend LesFichiersOligoseg $FichierCourbeOligoseg } IllustreOligoCGHseg $LesFichiersOligoseg } } proc IllustreCGHAvtEtApresSeg {DirFileToOpen {LesPos ""} {LesNoms ""}} { # afficher la courbe CGH avant et apres segmentation, qu'elle soit BAC ou Oligo. if {$DirFileToOpen==""} {set DirFileToOpen $RepertoireDuGenome} FaireLire "Please, download your raw data file. Thank you!" set FichierCourbeCGH [tk_getOpenFile -title "Raw data file to open" -initialdir $DirFileToOpen] FaireLire "Please, download your CBS data file. Thank you!" set FichierCourbeSEG [tk_getOpenFile -title "CBS data file to open" -initialdir $DirFileToOpen] if {![file exists $FichierCourbeCGH] || $FichierCourbeCGH == ""} {return ""} set NomFichierCGH [file tail $FichierCourbeCGH] if {![file exists $FichierCourbeSEG] || $FichierCourbeSEG == ""} {return ""} set NomFichierSEG [file tail $FichierCourbeSEG] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] #set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoite + 2*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0)+($TailleChromo*1.0)] } set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] ######################## Courbe CGH avant segmentation ############################# set x [InterrogeFichierCourbeCGH $FichierCourbeCGH "unset"] set VMin [InterrogeFichierCourbeCGH $FichierCourbeCGH VMin] set VMax [InterrogeFichierCourbeCGH $FichierCourbeCGH VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierCourbeCGH TabC $FichierCourbeCGH $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)] { set PosMid $Pos set PosMid [expr $PosMid + $TailleChroCum] foreach LInfo [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,$Pos)] { #tenir compte des chros precedents if {[regexp "Oligo" $NomFichierCGH] || [regexp "CL" $NomFichierCGH]} { set Val [lindex $LInfo 3] set Val [expr $Val*log(10)/log(2)] } else { set Val [lindex $LInfo 2] } set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { set X1 $PosMid set Y1 $Value continue } if {($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro)} { set X1 $PosMid set Y1 $Value continue } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin -0 set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeCGH $FichierCourbeSEG "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierCGH CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum + $TailleChromo] } ######################## Courbe CGH SEG ####################################### set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set x [InterrogeFichierSEG $FichierCourbeSEG "unset"] set VMin [InterrogeFichierSEG $FichierCourbeSEG VMin] set VMax [InterrogeFichierSEG $FichierCourbeSEG VMax] #set VMin [LaValeurMinCGHSeg $FichierCourbeSEG $Chromosome] #set VMax [LaValeurMaxCGHSeg $FichierCourbeSEG $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierSEG TabO $FichierCourbeSEG $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeSEG,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeSEG,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabO($FichierCourbeSEG,Chromosome,$Chromosome,$Pos)] { set PosInf [expr [lindex $LInfo 3]+ $TailleChroCum] set PosSup [expr [lindex $LInfo 4]+ $TailleChroCum] set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin -0 set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeCGH $FichierCourbeSEG "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierSEG CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum + $TailleChromo] } LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneAvtEtApresSeg $K" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreCGH_seg {NomFichierBAC NomFichierOligo DirFileToOpen {LesPos ""} {LesNoms ""}} { if {$DirFileToOpen==""} {set DirFileToOpen $RepertoireDuGenome} # afficher la(les) courbe(s) CGH apres segmentation. #FaireLire "BAC file = x$NomFichierBAC x" set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] #set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoite + 2*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" ### modif MG: pb avec la taille des chromos plus bas... set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0) + ($TailleChromo*1.0)] } # Attention au *1.0 !!! indispensable pour windows! (sinon taille du genome, negative! donc facteur negatif) set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] if {[OuiOuNon "Do you have a BAC CBS file?"]} { set FichierCourbeBACSeg [tk_getOpenFile -title "CBS BAC file to open" -initialdir $DirFileToOpen] set NomFichierBACSeg [file tail $FichierCourbeBACSeg] } else {set FichierCourbeBACSeg "null"} if {[OuiOuNon "Do you have a Oligo CBS file?"]} { set FichierCourbeOligoSeg [tk_getOpenFile -title "CBS oligo file to open" -initialdir $DirFileToOpen] set NomFichierOligoSeg [file tail $FichierCourbeOligoSeg] } else {set FichierCourbeOligoSeg "null"} ######################## Courbe CGH BAC apres segmentation ############################# # modif MG if {$FichierCourbeBACSeg!="null"} { set x [InterrogeFichierSEG $FichierCourbeBACSeg "unset"] set VMin [InterrogeFichierSEG $FichierCourbeBACSeg VMin] set VMax [InterrogeFichierSEG $FichierCourbeBACSeg VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierSEG TabO $FichierCourbeBACSeg $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabO($FichierCourbeBACSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [expr [lindex $LInfo 3]+ $TailleChroCum] set PosSup [expr [lindex $LInfo 4]+ $TailleChroCum] set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin -0 set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeBACSeg $FichierCourbeOligoSeg "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierBACSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr $TailleChroCum + $TailleChromo] } } ######################## Courbe CGH Oligo Seg ####################################### if {$FichierCourbeOligoSeg!="null"} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set x [InterrogeFichierSEG $FichierCourbeOligoSeg "unset"] set VMin [InterrogeFichierSEG $FichierCourbeOligoSeg VMin] set VMax [InterrogeFichierSEG $FichierCourbeOligoSeg VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] #set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierSEG TabO $FichierCourbeOligoSeg $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [expr [lindex $LInfo 3]+ $TailleChroCum] set PosSup [expr [lindex $LInfo 4]+ $TailleChroCum] if {$PosSup<0} {Espionne "posinf=$PosInf et possup=$PosSup"} set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin -0 set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo*1.0 + $TailleChroCum*1.0) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo*1.0 + $TailleChroCum*1.0) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo*1.0 +$TailleChroCum*1.0)* $Facteur)-($TailleChromo*1.0*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $FichierCourbeBACSeg $FichierCourbeOligoSeg "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierOligoSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr ($TailleChroCum*1.0) + ($TailleChromo*1.0)] if {$TailleChroCum<0} {FaireLire "Attention TailleChroCum=$TailleChroCum"} } } LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneSEG $K" regsub {\.canvas} $K "" w bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreDevStage {{LesNoms ""} {nParLigne 3} {FichierSelectedEST ""}} { if {$FichierSelectedEST == ""} {set FichierSelectedEST [tk_getOpenFile -title "SelectedEST File" -initialdir "[RepertoireDuGenome]/fiches"]} if {![file exists $FichierSelectedEST]} {return} if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [InterrogeSelectedEST $FichierSelectedEST LesNoms]]} set Liste {} foreach Nom $LesNoms { if { ! [regexp -nocase {[a-z]} $Nom]} { continue } set LesDevStagesDeLaBoiteOrdonnes [list "DevStage expression in $Nom"] set nMin 0 set nMax 0 set LesDevStagesDeLaBoite {} set LesDevStages [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] foreach DevStage $LesDevStages { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DevStage n] if {$nMax < $n} {set nMax $n} lappend LesDevStagesDeLaBoite [list $DevStage $n $nMin] } set NbDevStage [llength $LesDevStagesDeLaBoite] if {$NbDevStage <=1} {continue} if {$NbDevStage < 3} { for {set i 1} {$i <= [expr 3-$NbDevStage]} {incr i} { lappend LesDevStagesDeLaBoite [list "" 0 0 $nMax] } } foreach LeDevStage [lsort -index 1 -real -decreasing $LesDevStagesDeLaBoite] { lappend LeDevStage $nMax lappend LesDevStagesDeLaBoiteOrdonnes $LeDevStage } lappend Liste $LesDevStagesDeLaBoiteOrdonnes } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} return [IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1] } proc IllustreDevStageDesClusters {FichierCluster {LesClusters ""} {nParLigne 1} {FichierSelectedEST ""}} { if {$FichierSelectedEST == ""} {set FichierSelectedEST [tk_getOpenFile -title "SelectedEST File" -initialdir "[RepertoireDuGenome]/fiches"]} if {$LesClusters == ""} {set LesClusters [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierCluster LesClusters]]} set Liste {} foreach Cluster $LesClusters { #je calcule le tableau et les effectifs pour chaque DevStage et pour chaque groupe set Tab(Cluster,$Cluster,LesDevStages) {} set NbDevStageTot 0 foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierCluster Cluster $Cluster LesNoms] { set LesDevStages [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesDevStage] foreach DevStage $LesDevStages { if {$DevStage == ""} {continue} if {![info exists Tab(Cluster,$Cluster,DevStage,$DevStage,n)]} { set Tab(Cluster,$Cluster,DevStage,$DevStage,n) 0 lappend Tab(Cluster,$Cluster,LesDevStages) $DevStage } #set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom DevStage $DevStage n] set n 1 incr Tab(Cluster,$Cluster,DevStage,$DevStage,n) $n incr NbDevStageTot $n } } set LesDevStagesDeLaBoiteOrdonnes [list "DevStage expression in Cluster $Cluster"] set nMin 0 set nMax 0 set LesDevStagesDeLaBoite {} foreach DevStage [set Tab(Cluster,$Cluster,LesDevStages)] { set n [set Tab(Cluster,$Cluster,DevStage,$DevStage,n)] if {$nMax < $n} {set nMax $n} lappend LesDevStagesDeLaBoite [list $DevStage $n $nMin] } set NbDevStage [llength $LesDevStagesDeLaBoite] if {$NbDevStage <=1} {continue} if {$NbDevStage < 3} { for {set i 1} {$i <= [expr 3-$NbDevStage]} {incr i} { lappend LesDevStagesDeLaBoite [list "" 0 0 $nMax] } } foreach LeDevStage [lsort -index 1 -real -decreasing $LesDevStagesDeLaBoite] { lappend LeDevStage $nMax lappend LesDevStagesDeLaBoiteOrdonnes $LeDevStage } lappend Liste $LesDevStagesDeLaBoiteOrdonnes } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} return [IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1] } proc IllustreDistanceDesClustersAvecLesAutres {{SeuilMax 800} {nParLigne 3} {LesClusters ""} {LesAutresClusters ""}} { if {$LesClusters == {}} {set LesClusters [O2C2O LesClusters]} if {$LesAutresClusters == {}} {set LesAutresClusters [O2C2O LesClusters]} set ListeDeTousLesClusters {} foreach Cluster1 $LesClusters { set Liste [list "Dist Clust $Cluster1 with the others"] foreach Cluster2 $LesAutresClusters { set D [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] if {$D == "" || $SeuilMax < $D} {continue} lappend Liste [list $Cluster2 $D 0 $SeuilMax] } if {$Liste == {}} {return} lappend ListeDeTousLesClusters $Liste } IllustreLesToilesDAraignee $ListeDeTousLesClusters $nParLigne 1 0 0 0 0 return } proc IllustreDistanceDuClusterAvecDAutresChoisis {Cluster1 {LesAutresClusters ""} {SeuilMax 800}} { set Liste {} if {$LesAutresClusters == ""} { set LesAutresClusters [MorceauxChoisis [O2C2O LesClusters]] } foreach Cluster2 $LesAutresClusters { if {$Cluster1 == $Cluster2} {continue} set D [format "%.1f" [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance]] if {$D == ""} {continue} lappend Liste [list $Cluster2 $D 0 $SeuilMax] } if {$Liste == {}} {return} IllustreLaToileDAraignee $Liste "Distance of Cluster $Cluster1 with the others" 1 1 1 0 0 return } proc IllustreDistanceDuClusterAvecLesClustersDuMemeOperon {Cluster Operon} { set Liste {} foreach Cluster2 [O2C2O Operon $Operon LesClusters] { set D [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 Distance] if {$D == ""} {continue} lappend Liste [list $Cluster2 $D 0 740] } if {$Liste == {}} {return} IllustreLaToileDAraignee $Liste "Distance of Cluster $Cluster with the others" 1 1 1 1 1 return } proc IllustreDistanceDuClusterAvecTousLesAutres {Cluster1 {SeuilGroupe 10} {SeuilMax 800} {nParLigne 2}} { set LesGroupesDeClusters {} set ListeDistanceAvecTousLesClusters {} set i 0 set UnGroupeDeClusters "" foreach Cluster [O2C2O LesClusters] { Espionne "Cluster: $Cluster" incr i Espionne $i if {$i < $SeuilGroupe} { append UnGroupeDeClusters "$Cluster\t" if {$Cluster == 167} {lappend LesGroupesDeClusters $UnGroupeDeClusters} } else { append UnGroupeDeClusters "$Cluster\t" lappend LesGroupesDeClusters $UnGroupeDeClusters set i 0 set UnGroupeDeClusters "" } } Espionne [join $LesGroupesDeClusters "\n"] foreach GroupeDeClusters $LesGroupesDeClusters { set Liste [list "Distance of the cluster $Cluster1 with:"] foreach Cluster2 $GroupeDeClusters { #if {$Cluster1 == $Cluster2} {continue} set D [format "%.1f" [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance]] if {$D == ""} {continue} lappend Liste [list $Cluster2 $D 0 $SeuilMax] } lappend ListeDistanceAvecTousLesClusters $Liste } EspionneL ListeDistanceAvecTousLesClusters IllustreLesToilesDAraignee $ListeDistanceAvecTousLesClusters $nParLigne 1 1 1 0 1 return } proc IllustreDistancesPondereesDesClustersParPresences {{LesClusters ""} {LesCategories ""} {nParLigne 3} {DPPMin ""} {DPPMax ""}} { if {$LesClusters == {}} { set LesClusters [MorceauxChoisis [O2C2O LesClusters ]] } if {$LesCategories == {}} {set LesCategories [MorceauxChoisis [lsort [O2C2O LesCategories]]]} if {$LesCategories == "CategoriesInteressantes"} {set LesCategories [LesCategoriesInteressantes]} if {$LesClusters == {} || $LesCategories == {}} {return} ChargeLesDPPDesCategories TabCat $LesCategories set ListeDPPDesClusters {} foreach Cl1 $LesClusters { foreach Cl2 $LesClusters { if {$Cl1 == $Cl2} {continue} EspionneL "Cluster $Cl1 Cluster $Cl2" set Liste [list "DPP : clust $Cl1 ([O2C2O Cluster $Cl1 TailleCluster]) and $Cl2 ([O2C2O Cluster $Cl2 TailleCluster])"] foreach Cat $LesCategories { if {![info exists TabCat(Categorie,$Cat,Cluster1,$Cl1,Cluster2,$Cl2,DPP)]} { Espionne "Pas de DPP entre $Cl1 et $Cl2, bizarre!!!!" continue } set DPP [expr round([set TabCat(Categorie,$Cat,Cluster1,$Cl1,Cluster2,$Cl2,DPP)])] if {$DPP == ""} {continue} if {$DPPMin == ""} {set DPPMin [set TabCat(Categorie,$Cat,DPPMin)]} if {$DPPMax == ""} {set DPPMax [set TabCat(Categorie,$Cat,DPPMax)]} if {$DPPMax < $DPP } {set DPP $DPPMax} if {$DPP < $DPPMin} {set DPP $DPPMin} if {$Cat == "OrganismeInteressant"} {set Cat "Diabacs"} lappend Liste [list $Cat $DPP $DPPMin $DPPMax] } lappend ListeDPPDesClusters $Liste } } IllustreLesToilesDAraignee $ListeDPPDesClusters $nParLigne 1 1 1 0 1 return } proc IllustreFichierDPC {FichierDPC {MoyenneOuMediane Mediane} {AvecMemeEchelleY 1} {nParLigne 2}} { if {![file exists $FichierDPC]} {return} set Tab(LesClusters) {} set F [open $FichierDPC] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Qui [lindex $LaLigne 0] set i [expr [string first " " $Qui] -1] if {0 <= $i} { set PremierMot [string range $Qui 0 $i] if {$PremierMot == "Number"} {continue} if {$PremierMot == "Cluster"} { if {![info exists nClust]} {set nClust 0} else {incr nClust} Espionne "Cluster $nClust" lappend Tab(LesClusters) $nClust set Tab($nClust,NbSeq) 0 set Tab($nClust,LesConditions) {} continue } } if {![info exists nClust]} {continue} incr Tab($nClust,NbSeq) set LesValeurs [lrange $LaLigne 1 end] set Condition 0 foreach Val $LesValeurs { if {![info exists Tab($nClust,$Condition,LesValeurs)]} { lappend Tab($nClust,LesConditions) $Condition set Tab($nClust,$Condition,LesValeurs) {} } lappend Tab($nClust,$Condition,LesValeurs) $Val incr Condition } } close $F set LesClusters [set Tab(LesClusters)] set LesCouleurs [GammeDeCouleursRVB_CHALMEL [llength $LesClusters]] if {$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} set ToutesLesCourbes {} foreach Cluster [set Tab(LesClusters)] { set Couleur [lindex $LesCouleurs $Cluster] set NbSeq [set Tab($Cluster,NbSeq)] set LesConditions [set Tab($Cluster,LesConditions)] if {!$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} set LesPoints {} foreach What $LesConditions { if {![info exists Tab($Cluster,$What,LesValeurs)]} {continue} if {$MoyenneOuMediane == "Moyenne"} { set LesStats [MoyenneEcartMinMaxCumulLong [set Tab($Cluster,$What,LesValeurs)]] set Moyenne [lindex $LesStats 0] set ET [lindex $LesStats 1] if {[expr $Moyenne - $ET] < $ValYMin } {set ValYMin [expr $Moyenne - $ET]} if {$ValYMax < [expr $Moyenne + $ET]} {set ValYMax [expr $Moyenne + $ET]} lappend LesPoints [list $What $Moyenne $ET] } else { set LesStats [MedianeInterQuartileMinInterQuartileMaxExtremeMinExtremeMax [set Tab($Cluster,$What,LesValeurs)]] set Mediane [lindex $LesStats 0] set QuartMin [lindex $LesStats 1] set QuartMax [lindex $LesStats 2] set ExtrMin [lindex $LesStats 3] set ExtrMax [lindex $LesStats 4] if {$ExtrMin < $ValYMin} {set ValYMin $ExtrMin} if {$ValYMax < $ExtrMax} {set ValYMax $ExtrMax} lappend LesPoints [list $What $Mediane $QuartMin $QuartMax $ExtrMin $ExtrMax] } } Espionne "Cluster $Cluster NbSeq $NbSeq" lappend ToutesLesCourbes [list "Cluster $Cluster NbSeq $NbSeq" $ValYMin $ValYMax [list $What $Couleur $LesPoints]] } if {$ToutesLesCourbes == {}} {return} if {$AvecMemeEchelleY} { set ToutesLesCourbes_old $ToutesLesCourbes set ToutesLesCourbes {} foreach LesCourbes $ToutesLesCourbes_old { set LesCourbes [lreplace $LesCourbes 1 1 $ValYMin] set LesCourbes [lreplace $LesCourbes 2 2 $ValYMax] lappend ToutesLesCourbes $LesCourbes } } if {$MoyenneOuMediane == "Moyenne"} { IllustreLesCourbes $ToutesLesCourbes $nParLigne } else { IllustreLesCourbesAvecInterQuartile $ToutesLesCourbes $nParLigne } return } proc IllustreGCCount {} { Wup "Interface du BestGCCount" Wup "Montre le graphe cumule des valeurs de GC pour les sequences ou boites choisies" Wup "Permet de choisir, de montrer et sauver des bornes" Wup "26-04-2005 Modif pour tenir compte de step et SlidingWindow modifiable et affichage de ces infos" #Charge les Resultats set LesResultats [LesResultatsGCCount] if {$LesResultats==""} {Espionne "No results to show";return ""} set w "[NomDe fenetre]" if {[winfo exists $w]} {wm deiconify $w;raise $w;return ""} else {toplevel $w} wm geometry $w +300+100 wm title $w "Best GC analysis" #wm resizable $w false false #Frame contenant le graphe et les scrollbar ########################################### set FInfo "$w.frameinfo" frame $FInfo -borderwidth "3" -relief "groove" set Police {-family "arial" -size 12 -weight bold} set LargeurFenetre [expr [winfo screenwidth .] * 2/3] set HauteurFenetre [expr [winfo screenheight .] * 1/2] set XMilieu [expr $LargeurFenetre/2] set BordureX 50.0 set BordureY 50.0 set Intervalle 10.0 set EpaisseurBoite 15.0 #Position du Graph content set XDebutGraph [expr 0.0 + $BordureX] set XFinGraph [expr $LargeurFenetre - $BordureX -20] set YDebutGraph [expr 0.0 + $BordureY] set YFinGraph [expr $HauteurFenetre - $BordureY] set TailleXGraph [expr $XFinGraph - $XDebutGraph] set TailleYGraph [expr $YFinGraph - $YDebutGraph] #Traite les Resultats set TmpResultat "" foreach {a b} $LesResultats { switch $a { "GCMax" {set XMax $b} "GCMin" {set XMin $b} "GCMoyenne" {set GCMoyenne $b} "GCTotal" {} "NbGC" {set NbGCCalcules $b} "NbSeq" {set NbSeq $b} "default" {lappend TmpResultat [list $a $b]} } } set TailleEnX [expr $XMax - $XMin] set LesResultats [lsort -decreasing -integer -index 1 $TmpResultat] set YMax [lindex [lindex $LesResultats 0] 1] set YMin [lindex [lindex $LesResultats end] 1] set TailleEnY [expr $YMax - $YMin] #Nombre de pixel pour un pourcent de GC set RapportEnX [expr ($TailleXGraph)/($TailleEnX)] set RapportEnY [expr ($TailleYGraph)/($TailleEnY)] set K "$FInfo.canvas" set ScroHor "$FInfo.xscroll" set ScroVer "$FInfo.yscroll" scrollbar $ScroVer -command "$K yview" scrollbar $ScroHor -command "$K xview" -orient "horizontal" #Canvas pour le graphe canvas $K -width $LargeurFenetre -height $HauteurFenetre -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" $K configure -background "grey" $K configure -scrollregion [list 0.0 0.0 $XFinGraph $YFinGraph] #Rectangle de masque pour les graphes $K create rectangle [expr $XDebutGraph -2] [expr $YDebutGraph -2] [expr $XFinGraph +2] [expr $YFinGraph +2] -fill "gray97" -outline "gray97" -tags [list "" "Masque"] set ColorLine "deepskyblue2" set n 0 set LesResultats [lsort -increasing -real -index 0 $TmpResultat] foreach GCNb $LesResultats { scan $GCNb "%f %d" x y set X [expr $XDebutGraph + [expr $x * $RapportEnX] - [expr $XMin * $RapportEnX]] set Y [expr $YFinGraph - [expr $y * $RapportEnY] + [expr $YMin * $RapportEnY]] incr n if {$n > 1} { $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y -tags [list "" "GC $x Nb $y" "Affichable" "OligoGraph" "GC" "GCLines"] -fill $ColorLine set n 1 } set Coordonnees(VraiY) $y set Coordonnees(LastX) $X set Coordonnees(LastY) $Y $K create oval [expr $X-1] [expr $Y-1] [expr $X+1] [expr $Y+1] -width "3" -outline "darkviolet" -fill "darkviolet" -tags [list "" "GC $x Nb $y" "Affichable" "OligoGraph" "GC" "GCPlot"] } #La moyenne set XMoyenne [expr $XDebutGraph + [expr $GCMoyenne * $RapportEnX] - [expr $XMin * $RapportEnX]] $K create line $XMoyenne [expr $YFinGraph +1] $XMoyenne $YDebutGraph -tags [list "" "Mean $GCMoyenne" "Affichable" "OligoGraph" "Moyenne" "MoyenneLines"] -fill "red" $K create oval [expr $XMoyenne -1] [expr $YDebutGraph -1] [expr $XMoyenne +1] [expr $YDebutGraph +1] -width "3" -outline "red" -fill "red" -tags [list "" "Mean" "Affichable" "OligoGraph" "Moyenne" "MoyennePlot"] $K create oval [expr $XMoyenne -1] [expr $YFinGraph -1] [expr $XMoyenne +1] [expr $YFinGraph +1] -width "3" -outline "red" -fill "red" -tags [list "" "Mean" "Affichable" "OligoGraph" "Moyenne" "MoyennePlot"] $K create text $XMoyenne [expr $YFinGraph +15] -font "$Police" -text "[format "%.1f" $GCMoyenne]" -fill "yellow" -anchor "center" -tags [list "" "Mean" "OligoGraph" "Moyenne" "MoyennePlot"] #Axe des ordonnees $K create line $XDebutGraph $YFinGraph $XDebutGraph [expr $YDebutGraph -20] -arrow last -tags [list "" "Y (Nb) Axes" "Affichable" "Axes"] -width 2 $K create text $XDebutGraph [expr $YDebutGraph -25] -text "Count" -tags [list "" "Y title" "Affichable" "Edges"] -anchor "center" $K create text [expr $XDebutGraph -10] [expr $YFinGraph] -text "$YMin" -tags [list "" "Nb Min" "Affichable" "Edges"] -anchor "e" $K create text [expr $XDebutGraph -10] [expr $YDebutGraph] -text "$YMax" -tags [list "" "Nb Max" "Affichable" "Edges"] -anchor "e" #Axe des abscisses $K create line $XDebutGraph $YFinGraph [expr $XFinGraph +20] $YFinGraph -arrow last -tags [list "" "X (GC) Axes" "Affichable" "Axes"] -width 2 $K create text [expr $XFinGraph +25] $YFinGraph -text "GC %" -tags [list "" "X title" "Affichable" "Edges"] -anchor "w" $K create text [expr $XDebutGraph] [expr $YFinGraph +15] -text "$XMin" -tags [list "" "GC Min" "Affichable" "Edges"] -anchor "center" $K create text [expr $XFinGraph] [expr $YFinGraph +15] -text "$XMax" -tags [list "" "GC Max" "Affichable" "Edges"] -anchor "center" #La fiche contenant les infos set FicheInfo "" set TextFrame "$w.textframe" set Text "$TextFrame.text" #set ListBoxSBH "$TextFrame.xscroll" set ListBoxSBV "$TextFrame.yscroll" frame $TextFrame -borderwidth "3" -relief "groove" #scrollbar $ListBoxSBH -orient "horizontal" -command "$Text xview" scrollbar $ListBoxSBV -orient "vertical" -command "$Text yview" #text $Text -height "3" -state "disabled" -wrap "word" -font "courier 10" -xscrollcommand "$ListBoxSBH set" -yscrollcommand "$ListBoxSBV set" text $Text -height "3" -state "disabled" -wrap "word" -font "courier 10" -yscrollcommand "$ListBoxSBV set" set Step [LesParametresDuDesign Step "LaValeurMerci"] if {$Step ==""} {set Step 10} set SlidingWindow [LesParametresDuDesign LengthOligo "LaValeurMerci"] if {$SlidingWindow==""} {set SlidingWindow 60} set FicheInfo [list "$NbGCCalcules GC values measured for $NbSeq sequence(s) submitted\n" "Sliding Window: $SlidingWindow nt(s)\n" "Step: $Step nt(s)"] foreach element $FicheInfo { $Text configure -state normal $Text insert "end" "$element" $Text configure -state disabled } #Les boutons set ButtonFrame "$w.buttonframe" set ActionButton "$ButtonFrame.button1" set DestroyButton "$ButtonFrame.button2" set LCharpente1 "$ButtonFrame.lcharpente1" set LCharpente2 "$ButtonFrame.lcharpente2" set ZoneButton1 "$ButtonFrame.zbutton1" set ZoneButton2 "$ButtonFrame.zbutton2" set ZoneButton3 "$ButtonFrame.zbutton3" frame $ButtonFrame -borderwidth "3" -relief "groove" button $ActionButton -background "orange" -text "Graph Panel" bind $ActionButton <1> "GCPanel $K" set Texte [format "%-10s" "Panel to change graph display (order,color)"] set_balloon $ActionButton "$Texte" button $DestroyButton -background "red" -text "Close" -command "destroy $w" button $ZoneButton1 -background "green" -text "Area Draw / Clear / Save" bind $ZoneButton1 <1> "MontreLesZonesDeGC $K $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $ZoneButton1 <2> "ClearLesZones $K" bind $ZoneButton1 <3> "SauveLesZonesDeGC $K" set Texte [format "%-10s" "Allow to show (defined), clear or save a GC area"] set_balloon $ZoneButton1 "$Texte" button $ZoneButton2 -background "green" -text "Reset" bind $ZoneButton2 <1> "ResetLesZonesDeGC $K" set Texte [format "%-10s" "Allow to clear saved GC area"] set_balloon $ZoneButton2 "$Texte" button $ZoneButton3 -background "yellow" -text "Zoom In / Out / Reset" bind $ZoneButton3 <1> "zoom $K 1.25 1.25" bind $ZoneButton3 <2> "zoom $K 0.8 0.8" bind $ZoneButton3 <3> "ResetZoom $K" label $LCharpente1 -background "#808FFF" -relief "groove" label $LCharpente2 -background "#808FFF" -relief "groove" pack $FInfo -fill both -expand true pack $ScroVer -fill y -side right pack $ScroHor -fill x -side bottom pack $K -fill both -side top -expand true pack $ButtonFrame -fill both -side top pack $LCharpente1 -fill both -side left -expand true pack $DestroyButton -side left pack $ZoneButton3 -side left pack $ActionButton -side left pack $ZoneButton1 -side left pack $ZoneButton2 -side left pack $LCharpente2 -fill both -side left -expand true pack $TextFrame -fill both -side top pack $ListBoxSBV -fill y -side right #pack $ListBoxSBH -fill x -side bottom pack $Text -fill both -side top -expand true Raiser $K "GCPlot" Lower $K "Edges" Lower $K "Axes" Lower $K "Masque" $K bind "Affichable" "AfficheInfoBulle $K %x %y Enter" $K bind "Affichable" "AfficheInfoBulle $K %x %y Leave" bind $K "PositionneLesZonesDeGC $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $K "ViseurDeGC $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $K "ViseurDeGC $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" #Binding pour permettre de zoomer en utilisant le 3eme bouton bind $K <3> "zoomMark $K %x %y" bind $K "zoomStroke $K %x %y" bind $K "zoomArea $K %x %y" return "" } proc IllustreGODuSelectionne {K X Y MesGO Density} { set Id [$K find withtag current] set MesTags [$K gettags $Id] set Type [lindex $MesTags 1] set GO [lindex $MesTags 2] set Niveau [lindex $MesTags 3] IllustreOntology $Type $MesGO $Density $GO $Niveau return "" } proc IllustreGeneOntology {{LesNoms ""} {LesTypes ""} {nParLigne 3} {FichierGeneOntology ""}} { if {$FichierGeneOntology == ""} { set FichierGeneOntology [ChoixParmi [glob -nocomplain "[RepertoireDuGenome]/fiches/GeneOntology*"]] } if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [InterrogeGeneOntology $FichierGeneOntology LesNoms]]} if {$LesTypes == ""} {set LesTypes [MorceauxChoisis [LesTypesOntologiques]]} set Liste {} foreach Nom $LesNoms { foreach Type $LesTypes { set LesGODeLaBoiteOrdonnes [list "Gene ontology of $Nom : $Type"] set nMin 0 set nMax 0 set LesGODeLaBoite {} set LesGO [InterrogeGeneOntology $FichierGeneOntology $Nom LesGO] foreach GO $LesGO { if {$Type != [InterrogeGeneOntology $FichierGeneOntology GO $GO Type]} {continue} set n [InterrogeGeneOntology $FichierGeneOntology $Nom GO $GO n] set Def [join [InterrogeGeneOntology $FichierGeneOntology GO $GO LaDefinition] ""] if {$nMax < $n} {set nMax $n} lappend LesGODeLaBoite [list $Def $n $nMin] } set NbGO [llength $LesGODeLaBoite] if {$NbGO < 3} { for {set i 1} {$i <= [expr 3-$NbGO]} {incr i} { lappend LesGODeLaBoite [list "" 0 0 1] } } foreach LeGO [lsort -index 1 -real -decreasing $LesGODeLaBoite] { lappend LeGO $nMax lappend LesGODeLaBoiteOrdonnes $LeGO } lappend Liste $LesGODeLaBoiteOrdonnes } } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1 return } proc IllustreGeneOntologyDesClusters {FichierO2C2A2D2E {LesClusters ""} {LesTypes ""} {nParLigne 1} {FichierGeneOntology ""}} { if {$FichierGeneOntology == ""} { set FichierGeneOntology [ChoixParmi [glob -nocomplain "[RepertoireDuGenome]/fiches/GeneOntology*"]] } if {$LesClusters == ""} {set LesClusters [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesClusters]]} if {$LesTypes == ""} {set LesTypes [MorceauxChoisis [InterrogeGeneOntology $FichierGeneOntology LesTypes]]} set Liste {} foreach Cluster $LesClusters { foreach Type $LesTypes { set LesGODuClusterOrdonnes [list "Gene ontology of Cluster $Cluster : $Type"] set nMin 0 set nMax 0 set LesGODuCluster {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] { set LesGO [InterrogeGeneOntology $FichierGeneOntology $Nom LesGO] if {$LesGO == ""} {continue} foreach GO $LesGO { set TypeDuGO [InterrogeGeneOntology $FichierGeneOntology GO $GO Type] if {$Type != $TypeDuGO} {continue} if {![info exists Tab($Cluster,$GO,n)]} { set Tab($Cluster,$GO,n) 0 lappend LesGODuCluster $GO } incr Tab($Cluster,$GO,n) if {$nMax < [set Tab($Cluster,$GO,n)]} {set nMax [set Tab($Cluster,$GO,n)]} } } set LesGO $LesGODuCluster set LesGODuCluster {} foreach GO $LesGO { set n [set Tab($Cluster,$GO,n)] set Def [join [InterrogeGeneOntology $FichierGeneOntology GO $GO LaDefinition] ""] if {$nMax < $n} {set nMax $n} lappend LesGODuCluster [list $Def $n $nMin $nMax] } set NbGO [llength $LesGODuCluster] if {$NbGO < 3} { for {set i 1} {$i <= [expr 3-$NbGO]} {incr i} { lappend LesGODuCluster [list "" 0 0 1] } } foreach LeGO [lsort -index 1 -real -decreasing $LesGODuCluster] { lappend LeGO $nMax lappend LesGODuClusterOrdonnes $LeGO } lappend Liste $LesGODuClusterOrdonnes } } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1 return } proc IllustreGeneOntologyDesClustersDeMSF {{LesNoms ""} {LesTypes ""} {nParLigne 3} {FichierGeneOntology ""}} { if {$FichierGeneOntology == ""} { set FichierGeneOntology [ChoixParmi [glob -nocomplain "[RepertoireDuGenome]/fiches/GeneOntology*"]] } if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [InterrogeGeneOntology $FichierGeneOntology LesNoms]]} if {$LesTypes == ""} {set LesTypes [MorceauxChoisis [LesTypesOntologiques]]} set Liste {} foreach Nom $LesNoms { foreach Groupe [InterrogeGeneOntology $FichierGeneOntology $Nom LesGroupes] { foreach Type $LesTypes { set LesGODeLaFamilleOrdonnes [list "Gene ontology of Family $Groupe of $Nom : $Type"] set nMin 0 set nMax 0 set LesGODeLaFamille {} set LesGO [InterrogeGeneOntology $FichierGeneOntology $Nom Groupe $Groupe LesGO] foreach GO $LesGO { if {$Type != [InterrogeGeneOntology $FichierGeneOntology GO $GO Type]} {continue} set n [InterrogeGeneOntology $FichierGeneOntology $Nom Groupe $Groupe GO $GO n] set Def [join [InterrogeGeneOntology $FichierGeneOntology GO $GO LaDefinition] ""] if {$nMax < $n} {set nMax $n} lappend LesGODeLaFamille [list $Def $n $nMin] } set NbGO [llength $LesGODeLaFamille] if {$NbGO < 3} { for {set i 1} {$i <= [expr 3-$NbGO]} {incr i} { lappend LesGODeLaFamille [list "" 0 0 1] } } foreach LeGO [lsort -index 1 -real -decreasing $LesGODeLaFamille] { lappend LeGO $nMax lappend LesGODeLaFamilleOrdonnes $LeGO } lappend Liste $LesGODeLaFamilleOrdonnes } } } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1 return } proc IllustreLArbreTaxonomique {{LesTaxonsSelectionnes ""} {Qui OnlySelectedTaxons} {aTabTaxon ""}} { if {$aTabTaxon != ""} {upvar $aTabTaxon TabTaxon} if {![info exists TabTaxon]} {ChargeLaClassificationTaxonomique TabTaxon} if {$LesTaxonsSelectionnes == {}} { if {[OuiOuNon "Would you want to select some taxons?\nif not all will be selected."]} { set LesTaxonsSelectionnes [MorceauxChoisis [lsort [set TabTaxon(LesTaxons)]]] } } set LesPhylumsSelectionnes {} foreach TaxonSelect $LesTaxonsSelectionnes { if {![info exists TabTaxon($TaxonSelect,LesPhylums)]} {continue} lappend LesPhylumsSelectionnes [set TabTaxon($TaxonSelect,LesPhylums)] } set HauteurMax [expr [winfo screenheight .] * 2.0 /3] set LargeurMax [expr [winfo screenwidth .] * 2.0 /3] set HauteurFenetre [expr [winfo screenheight .] * 2.0 /3] set LargeurFenetre [expr [winfo screenwidth .] * 2.0 /3] set BordY 50.0 set BordX 50.0 set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set PoliceTitre "Arial 14 bold" set PoliceNiveau "Arial 12 bold" set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K create text [expr $LargeurFenetre/2] [expr $BordY/2] -text "Taxonomic Tree" -font $PoliceTitre set nNiveaux [set TabTaxon(NbNiveaux)] set EcartY [expr $HauteurAffichage * 1.0 / ($nNiveaux-1)] set XMin $BordX set XMax [expr $BordX + $LargeurAffichage] for {set i 1} {$i <= $nNiveaux} {incr i} { if {![info exists Y]} {set Y [expr $BordY + $HauteurAffichage]} else {set Y [expr $Y - $EcartY]} $K create text [expr $BordX /2] $Y -text "Niv $i" -font $PoliceNiveau $K create text [expr $LargeurAffichage+$BordX*3/2] $Y -text "Niv $i" -font $PoliceNiveau $K create line $XMin $Y $XMax $Y -fill grey set TabCoord($i,Y) $Y } set TabCoord(LUCA,XMin) $XMin set TabCoord(LUCA,XMax) $XMax set TabCoord(RayonMax) [expr $EcartY / 4] PlaceLesNoeudsTaxonomiquesSurLArbre $K TabCoord TabTaxon "LUCA" $LesPhylumsSelectionnes $Qui regsub {\.canvas} $K "" w $K bind "Taxon" "DevoileLeTaxon $K %x %y Enter" $K bind "Taxon" "DevoileLeTaxon $K %x %y Leave" $K bind "Taxon" <1> "IllustreLArbreTaxonomiqueDuTaxonSelectionne $K %x %y TabTaxon $Qui" set B [BoutonneLaFenetre $w "Who JustMySelectedTaxons/All"] bind $B <1> "IllustreLArbreTaxonomique $LesTaxonsSelectionnes OnlySelectedTaxons" bind $B <2> "IllustreLArbreTaxonomique $LesTaxonsSelectionnes AllTaxons" return } proc IllustreLArbreTaxonomiqueDuTaxonSelectionne {K X Y {aTabTaxon ""} {Qui OnlySelectedTaxons}} { set Id [$K find withtag current] set MesTags [$K gettags $Id] set Taxon [lindex [lindex $MesTags 1] end] if {$aTabTaxon != ""} { upvar $aTabTaxon TabTaxon IllustreLArbreTaxonomique $Taxon $Qui TabTaxon } else { IllustreLArbreTaxonomique $Taxon $Qui } return } proc IllustreLHistogramme {Liste {VerticalOuHorizontal Vertical}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set K [UnCanva $Largeur $Hauteur $Largeur $Hauteur WithY] set K [PlaceLHistogramme $Liste $K 0 $Hauteur 0 $Largeur $VerticalOuHorizontal] return $K } proc IllustreLaCarteExonique {NomOuFichiermRNATFA NomOuFichierExoniqueMap {LiensAvecExons Yes} {LiensAvecRepeats No} {LiensEntreExons Yes}} { global RepertoireDuGenome set FichierExoniqueMap "$RepertoireDuGenome/mrnaexonicmap/$NomOuFichierExoniqueMap" if {![file exists $FichierExoniqueMap]} { set FichierExoniqueMap $NomOuFichierExoniqueMap if {![file exists $FichierExoniqueMap]} { Espionne "$FichierExoniqueMap does not exist" return "" } } set FichiermRNATFA "$RepertoireDuGenome/mrnahuman/$NomOuFichiermRNATFA" if {![file exists $FichiermRNATFA]} { set FichiermRNATFA $NomOuFichiermRNATFA if {![file exists $FichiermRNATFA]} { Espionne "$FichiermRNATFA does not exist" return "" } } set Nom [file tail $FichierExoniqueMap] set FichierBlast "$RepertoireDuGenome/mrnablastnhuman/$Nom" if {![file exists $FichierBlast]} { set PresenceFichierBlast 0 } else { set PresenceFichierBlast 1 } set LargeurMax [expr [winfo screenwidth . ] - 200] set HauteurMax [expr [winfo screenheight .] / 2 ] set LargeurFenetre [expr [winfo screenwidth . ] - 200] set HauteurFenetre [expr [winfo screenheight .] / 2 ] set HBox 25.0 set BordY 50.0 set BordX 125.0 ChargeCarteExonique TabExon $FichierExoniqueMap if {![info exists TabExon(NbArea)] || [set TabExon(NbArea)] == 0} {return ""} set NbArea [set TabExon(NbArea) ] set Nom [set TabExon(Nom) ] set Entete [set TabExon($Nom,Entete)] set TaillemRNA [set TabExon($Nom,Taille)] set Chromosome [set TabExon(Chromosome) ] set Contig [set TabExon(Contig) ] set Strand [set TabExon(Strand) ] set Sens [set TabExon(Sens) ] set SeqmRNA [string toupper [QueLaSequenceDuTFA $FichiermRNATFA]] if {[info exists TabExon(Exon,1,nArea)]} { set nArea [set TabExon(Exon,1,nArea)] if {$nArea == 1} {set Ecart 1000} else {set Ecart 10000} } for {set nArea 1} {$nArea <= $NbArea} {incr nArea} { if { [set TabExon(Area,$nArea,Type)] == "ABSENT"} { continue } elseif {[set TabExon(Area,$nArea,Type)] == "REPEAT"} { set nSubject [set TabExon(Area,$nArea,nSubject)] for {set i 1} {$i <= $nSubject} {incr i} { set DS [set TabExon(Area,$nArea,$i,DS)] set FS [set TabExon(Area,$nArea,$i,FS)] if {![info exists DSMin]} {set DSMin $DS} if {![info exists FSMax]} {set FSMax $FS} if {$FSMax < $FS } {set FSMax $FS} if {$DS < $DSMin } {set DSMin $DS} } } else { set DS [set TabExon(Area,$nArea,DS)] set FS [set TabExon(Area,$nArea,FS)] if {![info exists DSMin]} {set DSMin $DS} if {![info exists FSMax]} {set FSMax $FS} if {$FSMax < $FS } {set FSMax $FS} if {$DS < $DSMin } {set DSMin $DS} } } set TailleRecouvrement [expr $FSMax - $DSMin + 1 ] set TailleRegion [expr $TailleRecouvrement + 2 * $Ecart ] set RapportRegion [expr ($LargeurMax - 2 * $BordX) / $TailleRegion] set RapportmRNA [expr ($LargeurMax - 2 * $BordX) / $TaillemRNA ] set LesBoites {} for {set nArea 1} {$nArea <= $NbArea} {incr nArea} { set Type [set TabExon(Area,$nArea,Type) ] set Couleur [ColoriageDesExons $Type $Sens ] set DQ [set TabExon(Area,$nArea,DQ) ] set XDQ [expr $BordX + $DQ * $RapportmRNA] set FQ [set TabExon(Area,$nArea,FQ) ] set XFQ [expr $BordX + $FQ * $RapportmRNA] if {$Type == "ABSENT"} { set nAbsent [set TabExon($DQ,$FQ,nAbsent)] set EnteteDuTFA "$Nom $DQ $FQ Absent region $nAbsent" set Seq [string range $SeqmRNA $DQ $FQ] set SeqTFA [SequenceFormatTFA $Seq $EnteteDuTFA] lappend LesBoites [list "$Type" "$DQ" "$FQ" "$XDQ" "$XFQ" {} "$Couleur" "$nAbsent" "$SeqTFA"] continue } elseif {$Type == "REPEAT"} { set nSubject [set TabExon(Area,$nArea,nSubject)] set nRepeat [set TabExon($DQ,$FQ,nRepeat)] set EnteteDuTFA "$Nom $DQ $FQ Repeated region $nRepeat" set Seq [string range $SeqmRNA $DQ $FQ] set SeqTFA [SequenceFormatTFA $Seq $EnteteDuTFA] set LesSubjects {} for {set i 1} {$i <= $nSubject} {incr i} { set DS [set TabExon(Area,$nArea,$i,DS)] set FS [set TabExon(Area,$nArea,$i,FS)] if {$Sens == "+"} { set XDS [expr $BordX + ($DS - $DSMin + 1 + $Ecart) * $RapportRegion] set XFS [expr $BordX + ($FS - $DSMin + 1 + $Ecart) * $RapportRegion] } else { set XFS [expr $BordX + ($TailleRegion - ($DS - $DSMin + 1 + $Ecart)) * $RapportRegion] set XDS [expr $BordX + ($TailleRegion - ($FS - $DSMin + 1 + $Ecart)) * $RapportRegion] } lappend LesSubjects [list "$DS" "$FS" "$XDS" "$XFS"] } lappend LesBoites [list "$Type" "$DQ" "$FQ" "$XDQ" "$XFQ" "$LesSubjects" "$Couleur" "$nRepeat" "$SeqTFA"] } else { set LesSubjects {} set DS [set TabExon(Area,$nArea,DS)] set FS [set TabExon(Area,$nArea,FS)] set nExon [set TabExon($DQ,$FQ,nExon)] set EnteteDuTFA "$Nom $DQ $FQ Exonic region $nExon" set Seq [string range $SeqmRNA $DQ $FQ] set SeqTFA [SequenceFormatTFA $Seq $EnteteDuTFA] if {$Sens == "+"} { set XDS [expr $BordX + ($DS - $DSMin + 1 + $Ecart) * $RapportRegion] set XFS [expr $BordX + ($FS - $DSMin + 1 + $Ecart) * $RapportRegion] } else { set XFS [expr $BordX + ($TailleRegion - ($DS - $DSMin + 1 + $Ecart)) * $RapportRegion] set XDS [expr $BordX + ($TailleRegion - ($FS - $DSMin + 1 + $Ecart)) * $RapportRegion] } lappend LesSubjects [list "$DS" "$FS" "$XDS" "$XFS"] lappend LesBoites [list "$Type" "$DQ" "$FQ" "$XDQ" "$XFQ" "$LesSubjects" "$Couleur" "$nExon" "$SeqTFA"] continue } } set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K configure -background white set Police "Courier 10" set XTexteGauche [expr $BordX/2] set XTexteDroite [expr $LargeurMax - $BordX/2] set XMilieu [expr $LargeurMax/2] set YNom [expr $BordY /3 ] set YEntete [expr $BordY * 2 / 3 ] set YDQ $BordY set YFQ [expr $YDQ + $HBox ] set YMilieuQ [expr $YDQ + ($YFQ - $YDQ)/2] $K create text $XMilieu $YNom -text "$Nom" -font "$Police" $K create text $XMilieu $YEntete -text "$Entete\t$Strand" -font "$Police" $K create text $XTexteGauche $YMilieuQ -text "1" -font "$Police" $K create text $XTexteDroite $YMilieuQ -text "$TaillemRNA" -font "$Police" set YContig [expr $HauteurMax - $BordY + $BordY / 2] set YDS [expr $HauteurMax - $BordY - $HBox ] set YFS [expr $HauteurMax - $BordY ] set YMilieuS [expr $YDS + ($YFS - $YDS)/2 ] $K create text $XMilieu $YContig -text "$Chromosome:$Contig" -font "$Police" if {$Sens == "+"} { $K create text $XTexteGauche $YMilieuS -text [expr $DSMin - $Ecart] -font "$Police" $K create text $XTexteDroite $YMilieuS -text [expr $FSMax + $Ecart] -font "$Police" set ColorFillLine "blue" } else { $K create text $XTexteGauche $YMilieuS -text [expr $FSMax + $Ecart] -font "$Police" $K create text $XTexteDroite $YMilieuS -text [expr $DSMin - $Ecart] -font "$Police" set ColorFillLine "red" } $K create line $BordX $YMilieuS [expr $LargeurMax - $BordX] $YMilieuS -fill $ColorFillLine set YMinArc [expr $YFS - $HBox/2] set YMaxArc [expr $YMinArc + $HBox] foreach LaBoite $LesBoites { set Type [lindex $LaBoite 0] set DQ [lindex $LaBoite 1] set FQ [lindex $LaBoite 2] set XDQ [lindex $LaBoite 3] set XFQ [lindex $LaBoite 4] set LesSubjects [lindex $LaBoite 5] set Couleur [lindex $LaBoite 6] set nTypeRegion [lindex $LaBoite 7] set SeqTFA [lindex $LaBoite 8] $K create rectangle $XDQ $YDQ $XFQ $YFQ -outline $Couleur -fill $Couleur -tags [list "$DQ" "$FQ" "$LesSubjects" "$LesSubjects" "$Strand" "$Type" "$nTypeRegion" "$SeqTFA" "mRNA"] if {$Type == "ABSENT"} { continue } else { foreach UnSubject $LesSubjects { set DS [lindex $UnSubject 0] set FS [lindex $UnSubject 1] set XDS [lindex $UnSubject 2] set XFS [lindex $UnSubject 3] $K create rectangle $XDS $YDS $XFS $YFS -outline $Couleur -fill $Couleur -tags [list "$DQ" "$FQ" "$DS" "$FS" "$Strand" "$Type" "$nTypeRegion" "" "Contig"] if { $Type == "EXON" && $LiensAvecExons == "Yes" && $Sens == "+"} { $K create line $XDQ $YFQ $XDS $YDS -fill $ColorFillLine $K create line $XFQ $YFQ $XFS $YDS -fill $ColorFillLine } elseif {$Type == "EXON" && $LiensAvecExons == "Yes" && $Sens == "-"} { $K create line $XDQ $YFQ $XFS $YDS -fill $ColorFillLine $K create line $XFQ $YFQ $XDS $YDS -fill $ColorFillLine } elseif {$Type == "REPEAT" && $LiensAvecRepeats == "Yes" && $Sens == "-"} { $K create line $XDQ $YFQ $XFS $YDS -fill $Couleur $K create line $XFQ $YFQ $XDS $YDS -fill $Couleur } elseif {$Type == "REPEAT" && $LiensAvecRepeats == "Yes" && $Sens == "+"} { $K create line $XDQ $YFQ $XDS $YDS -fill $Couleur $K create line $XFQ $YFQ $XFS $YDS -fill $Couleur } if {$LiensEntreExons == "Yes" && $Type == "EXON"} { if {![info exists XMinArc]} {set XMinArc $XFS;continue} set XMaxArc $XDS $K create arc $XMinArc $YMinArc $XMaxArc $YMaxArc -extent -180. -style arc -outline purple -width 2 set XMinArc $XFS } } } } $K bind "mRNA" <1> "AfficheLaSeqTFA $K Enter" $K bind "mRNA" "DevoileLesInfosDeLaBoite $K %x %y Enter" $K bind "mRNA" "DevoileLesInfosDeLaBoite $K %x %y Leave" $K bind "Contig" "DevoileLesInfosDeLaBoite $K %x %y Enter" $K bind "Contig" "DevoileLesInfosDeLaBoite $K %x %y Leave" regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "LiaisonsExons On/Off\nLiaisonsRepeat On/Off\nArc On/Off"] bind $B <1> "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap Yes $LiensAvecRepeats $LiensEntreExons" bind $B <2> "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap No $LiensAvecRepeats $LiensEntreExons" bind $B "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap $LiensAvecExons Yes $LiensEntreExons" bind $B "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap $LiensAvecExons No $LiensEntreExons" bind $B "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap $LiensAvecExons $LiensAvecRepeats Yes" bind $B "IllustreLaCarteExonique $FichiermRNATFA $FichierExoniqueMap $LiensAvecExons $LiensAvecRepeats No" if {$PresenceFichierBlast} { set C [BoutonneLaFenetre $w "Other ExonicMap\nShow the ExonicMap File\nShow the blast"] bind $C <1> "ChoixCarteExonique" bind $C "AfficheFichier $FichierExoniqueMap" bind $C "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs" } else { set C [BoutonneLaFenetre $w "Other ExonicMap\nShow the ExonicMap File"] bind $C <1> "ChoixCarteExonique" bind $C "AfficheFichier $FichierExoniqueMap" } } proc IllustreLaCourbe {Liste} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set K [UnCanva $Largeur $Hauteur $Largeur $Hauteur WithY] set K [PlaceLaCourbe $Liste $K 0 $Hauteur 0 $Largeur] return $K } proc IllustreLaCourbeAvecInterQuartile {Liste} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set K [UnCanva $Largeur $Hauteur $Largeur $Hauteur WithY] set K [PlaceLaCourbeAvecInterQuartile $Liste $K 0 $Hauteur 0 $Largeur] return $K } proc IllustreLaToileDAraignee {Liste {Titre ""} {AvecTitre 1} {AvecLegende 1} {AvecVal 1} {AvecValEchelle 1} {AvecLigne 1}} { #if {[llength $Liste] <= 2} {return} set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set K [UnCanva $Largeur $Hauteur $Largeur $Hauteur WithY] PlaceLaToileDAraignee $Liste $K 0 $Hauteur 0 $Largeur $Titre $AvecTitre $AvecLegende $AvecVal $AvecValEchelle $AvecLigne regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "Avec / Sans Titre\nAvec / Sans Legende\nAvec / Sans Ligne"] bind $B <1> "IllustreLaToileDAraignee \{$Liste\} $Titre 1 $AvecLegende $AvecVal $AvecValEchelle $AvecLigne" bind $B <2> "IllustreLaToileDAraignee \{$Liste\} $Titre 0 $AvecLegende $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre 1 $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre 0 $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende $AvecVal $AvecValEchelle 1" bind $B "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende $AvecVal $AvecValEchelle 0" set C [BoutonneLaFenetre $w "Avec / Sans Val\nAvec / Sans ValEchelle"] bind $C <1> "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende 1 $AvecValEchelle $AvecLigne" bind $C <2> "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende 0 $AvecValEchelle $AvecLigne" bind $C "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende $AvecVal 1 $AvecLigne" bind $C "IllustreLaToileDAraignee \{$Liste\} $Titre $AvecTitre $AvecLegende $AvecVal 0 $AvecLigne" return $K } proc IllustreLeBlast {{FichierBlast ""} {ExpectDeRef ""} {NbSubject ""} {LesBIdsAutorises ""} {SelectedOrganism ""} {PourSvg ""}} { #rR IllustreLeBlast a remplacé IllustreLeBlastCanva dans /home/chalmel/gscopublic/blast.tcl #rR Ecrit par Frederic Chalmel #rR Modifié par Raymond pour qu'il crée un fichier Svg pour le web ;) Espionne $PourSvg #rR pour facilietr les tests foreach Param [list FichierBlast ExpectDeRef NbSubject LesBIdsAutorises SelectedOrganism] { if {[regexp "PourSvg" [set $Param]]} { set PourSvg [set $Param] set $Param "" } } if {$PourSvg==""} { set PourSvg [PourWscope] } #rR Ca semble tordu mais c'est pour permettre l'appel depuis Affiche où on ne fait que IllustreLeBlast FichierBlast if { $PourSvg!=0 && ! [regexp "FromHtmlBlastIllustre" $PourSvg]} { return [HtmlBlastIllustre $FichierBlast "/zscope" $ExpectDeRef $NbSubject $LesBIdsAutorises $SelectedOrganism] } #rR HtmlBlastIllustre appellera IllustreLeBlast en mettant PourSvgFromHtmlBlastIllustre if {[regexp "PourSvg" $PourSvg]} { set PourSvg 1 } if {$PourSvg==""} { set PourSvg [PourWscope] } if {$ExpectDeRef ==""} { set ExpectDeRef "NoLimit" } if {$NbSubject ==""} { set NbSubject "NoLimit" } if {$SelectedOrganism==""} { set SelectedOrganism "None" } if {$FichierBlast ==""} { set FichierBlast "/home/ripp/bac/b25.blast" } # if {$FichierBlast ==""} { set FichierBlast "/genomics/link/CilioCarta/blastp/HSAP00001" } if { ! [file exists $FichierBlast]} { if {[EstUnPAB $FichierBlast]} { set FB [GscopeFile $FichierBlast "blastp"] if {[file exists $FB]} { set FichierBlast $FB } } else { return "Sorry. $FichierBlast does not exist." } } set TailleQuery [TailleDeLaQueryDuBlast $FichierBlast] if {$TailleQuery == 0} {return "Sorry. The query length is 0."} if {$ExpectDeRef == "" } {set ExpectDeRef "1e-3" } elseif {$ExpectDeRef == "NoLimit"} {set ExpectDeRef "1e200"} if {$NbSubject == "" } {set NbSubject "250" } elseif {$NbSubject == "NoLimit"} {set NbSubject "1e200"} DepouilleLeBlast TabBlast $FichierBlast $ExpectDeRef $NbSubject set FichierTFA "" if {[EstUnPAB [file tail $FichierBlast]]} { set Nom [file tail $FichierBlast] set Dir [file dirname $FichierBlast] if {$Dir == "."} {set Dir [pwd]} set DirDuRepertoireDuGenome [lindex [split $Dir "/"] end] if {[regexp "^blastn|^blastx" $DirDuRepertoireDuGenome]} { set FichierTFA "[RepertoireDuGenome]/nucmask/$Nom" if {![file exists $FichierTFA]} { set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom" } } elseif {[regexp "^blastp|^tblastn" $DirDuRepertoireDuGenome]} { if {[file exists "[RepertoireDuGenome]/genscanpredictions/$Nom"]} { set FichierTFA "[RepertoireDuGenome]/genscanpredictions/$Nom" } else { set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom" } } elseif {[regexp "^mrnablast" $DirDuRepertoireDuGenome]} { set FichierTFA "[RepertoireDuGenome]/mrnahuman/$Nom" } } if {![file exists $FichierTFA]} {set FichierTFA ""} if { $SelectedOrganism == "ToPreserve"} { set LesOrganismesAConserver [LaSelectionDeNoe 1 NoSave] set LesOrganismesAEliminer {} } elseif {$SelectedOrganism == "ToEliminate"} { set LesOrganismesAEliminer [LaSelectionDeNoe 1 NoSave] set LesOrganismesAConserver {} } else { set LesOrganismesAConserver {} set LesOrganismesAEliminer {} } if {$PourSvg} { set LargeurMax 1600 set HauteurMax 1600 set LargeurFenetre $LargeurMax set HauteurFenetre $HauteurMax } else { set LargeurMax [expr [winfo screenwidth .]*1/3 - 50] set HauteurMax [expr [winfo screenheight .]*2/3 ] set LargeurFenetre [expr [winfo screenwidth .]*1/3 - 50] set HauteurFenetre [expr [winfo screenheight .]*2/3 ] } set HBox 25.0 set HSmallBox 15.0 set BordY 50.0 set BordX 200.0 set EcartY 10.0 set YTypeDeBlast [expr $BordY/4] set YNomQuery [expr $BordY*2/3] set CentreX [expr $LargeurMax/2] set XTexteGauche [expr $BordX/2] set XTexteDroite [expr $LargeurMax - $BordX/2] set YDebut $BordY set YFin [expr $YDebut + $HBox] set YTaille [expr $YDebut + ($YFin - $YDebut)/2] set TailleMaxNomQuery 100 set Police "Courier 10" set ColorOutLine "White" set ColorFillLine "black" set Rapport [expr ($LargeurMax - 2 * $BordX) / $TailleQuery] set LesRegionsMasquees [LesRegionsMasqueesDeLaQuery $FichierTFA ] set LesPetitesRegionsDuBlast [LesRegionsDuTabBlast TabBlast] set OldDebutGdeRegion 0 set OldFinGdeRegion 0 set LesGdesRegionsDuBlast {} set LesPetitesRegionsOccupees {} foreach LaPetiteRegion $LesPetitesRegionsDuBlast { set Pos [lindex $LaPetiteRegion 0] set Frequence [lindex $LaPetiteRegion 1] set Debut [lindex $LaPetiteRegion 2] set Fin [lindex $LaPetiteRegion 3] set DebutGdeRegion [lindex $LaPetiteRegion 4] set FinGdeRegion [lindex $LaPetiteRegion 5] if {$FinGdeRegion < $DebutGdeRegion} { set tmp $FinGdeRegion;set FinGdeRegion $DebutGdeRegion;set DebutGdeRegion $tmp } lappend LesPetitesRegionsOccupees [list "$Debut" "$Fin"] if {$OldDebutGdeRegion == $DebutGdeRegion && $OldFinGdeRegion == $FinGdeRegion} {continue} lappend LesGdesRegionsDuBlast [list "$DebutGdeRegion" "$FinGdeRegion"] set OldDebutGdeRegion $DebutGdeRegion set OldFinGdeRegion $FinGdeRegion } foreach UneRegionMasquee $LesRegionsMasquees { set Debut [lindex $UneRegionMasquee 0] set Fin [lindex $UneRegionMasquee 1] lappend LesPetitesRegionsDuBlast [list "0" "N" "$Debut" "$Fin"] lappend LesPetitesRegionsOccupees [list "$Debut" "$Fin"] } set LesRegionsVides [LesRegionsVidesDeLaListe $LesPetitesRegionsOccupees $TailleQuery] foreach UneRegionVide $LesRegionsVides { set Debut [lindex $UneRegionVide 0] set Fin [lindex $UneRegionVide 1] lappend LesPetitesRegionsDuBlast [list "0" "0" "$Debut" "$Fin"] } set TousBIdAutorises 1 if { $LesBIdsAutorises != "" } { set TousBIdAutorises 0 foreach BId $LesBIdsAutorises {set BIdAutorise($BId) 1} } if {![info exists TabBlast(NbSubject)]} {Espionne "NbSubject n'existe pas" ; return ""} set NbSubjectDansBlast [set TabBlast(NbSubject) ] set NomQuery [set TabBlast(Query) ] set TypeDeBlast "[set TabBlast(TypeDeBlast)]: [set TabBlast(Database)]" set PetitNomQuery $NomQuery if {$TailleMaxNomQuery < [string length $NomQuery]} { set PetitNomQuery [string range $NomQuery 0 $TailleMaxNomQuery] append PetitNomQuery "..." } set EmpilementTotal 0 set LesBIds {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] if {$TousBIdAutorises || [info exists BIdAutorise($BId)]} { lappend LesBIds $BId } } set LesBanquesId {} set i 0 foreach BId $LesBIds { incr i if {$ExpectDeRef < [set TabBlast($BId,1,Expect)] || $NbSubject < $i} {break} set Access [set TabBlast($BId,Access) ] set EstCeUnDesOrga 0 if {$LesOrganismesAEliminer != "" || $LesOrganismesAConserver != ""} { foreach Orga [LesOrganismesEnStock $BId $Access] { Espionne "$BId\t$Access\t$Orga" if { $LesOrganismesAEliminer != "" && [regexp -nocase $Orga [join $LesOrganismesAEliminer "\t"]]} { set EstCeUnDesOrga 1 break } if { $LesOrganismesAConserver != "" && [regexp -nocase $Orga [join $LesOrganismesAConserver "\t"]]} { set EstCeUnDesOrga 1 break } } if {!$EstCeUnDesOrga && $SelectedOrganism == "ToPreserve" } {continue} if { $EstCeUnDesOrga && $SelectedOrganism == "ToEliminate"} {continue} } lappend LesBanquesId $BId set NbSegment [set TabBlast($BId,NbSegment)] set NMaxSubject 0 for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set DS [set TabBlast($BId,$j,DS)] set FS [set TabBlast($BId,$j,FS)] if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp} set LesPetitesRegionsRecouvertes {} set NMaxSegment 0 foreach UneRegion $LesPetitesRegionsDuBlast { set Frequence [lindex $UneRegion 1] set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] if {$Frequence == 0 || $Frequence == "N" } {continue} if {![info exists Empilement($DebutPetiteRegion,$FinPetiteRegion)]} { set Empilement($DebutPetiteRegion,$FinPetiteRegion) 0 } if {$DQ <= $DebutPetiteRegion && $FinPetiteRegion <= $FQ} { incr Empilement($DebutPetiteRegion,$FinPetiteRegion) if {$NMaxSegment < [set Empilement($DebutPetiteRegion,$FinPetiteRegion)]} { set NMaxSegment [set Empilement($DebutPetiteRegion,$FinPetiteRegion)] } lappend LesPetitesRegionsRecouvertes $UneRegion } } foreach UneRegion $LesPetitesRegionsRecouvertes { set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] set Empilement($DebutPetiteRegion,$FinPetiteRegion) $NMaxSegment } set PosYSurEtagereDe($BId,$j) [expr $EmpilementTotal + $NMaxSegment] if {$NMaxSubject < $NMaxSegment} {set NMaxSubject $NMaxSegment} } set EmpilementTotal [expr $EmpilementTotal + $NMaxSubject] foreach UneRegion $LesPetitesRegionsDuBlast { set Frequence [lindex $UneRegion 1] set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] if {$Frequence == 0 || $Frequence == "N" } {continue} unset Empilement($DebutPetiteRegion,$FinPetiteRegion) } } set HauteurMax [expr 2 * $BordY + $HBox + $EmpilementTotal * ($EcartY + $HSmallBox)] if {$HauteurMax < $HauteurFenetre} { set HauteurFenetre $HauteurMax } #rR Creation du Svg ******************************************************************************** if {$PourSvg} { set K "CanvaAsSvg" set Bind "BindSvg" set BoutonneLaFenetre "BoutonneLaFenetreSvg" $K create svg $LargeurMax $HauteurMax $FichierBlast } else { set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set Bind "bind" set BoutonneLaFenetre "BoutonneLaFenetre" } $K configure -background white LesBanquesIdEnStock $K $LesBanquesId set Milieu [expr $LargeurMax/2] FormateLesCoordonnees Milieu XTexteGauche XTexteDroite YTypeDeBlast YNomQuery YTaille YTaille $K create text $Milieu $YTypeDeBlast -text "$TypeDeBlast" -font "$Police" -tags [list common "$FichierBlast" "" "" "AvecTypeDeBlast"] $K create text $Milieu $YNomQuery -text "$PetitNomQuery" -font "$Police" -tags [list common "$FichierBlast" "" "" "AvecNomQuery"] $K create text $XTexteGauche $YTaille -text "1" -font "$Police" -tags [list common "$FichierBlast" "" "" "Avec1"] $K create text $XTexteDroite $YTaille -text "$TailleQuery" -font "$Police" -tags [list common "$FichierBlast" "" "" "AvecTailleQuery"] foreach UneRegion [lsort -increasing -integer -index 2 $LesPetitesRegionsDuBlast] { set Frequence [lindex $UneRegion 1] set Debut [lindex $UneRegion 2] set Fin [lindex $UneRegion 3] set XDebut [expr $BordX + $Debut * $Rapport ] set XFin [expr $BordX + $Fin * $Rapport ] set ColorFill [ColoriageDeLaFrequence $Frequence] set PositionX($Debut) $XDebut set PositionX($Fin) $XFin set ColorFill [HtmlCompatibleColor $ColorFill] FormateLesCoordonnees XDebut YDebut XFin YFin $K create rectangle $XDebut $YDebut $XFin $YFin -outline $ColorFill -fill $ColorFill -tags [list query "$FichierBlast" "$Frequence" "" "AvecQueryFrequence"] } set YIni [expr $BordY + $HBox + $EcartY] set m 0 foreach BId [LesBanquesIdEnStock $K] { set NbSegment [set TabBlast($BId,NbSegment) ] set Expect [set TabBlast($BId,1,Expect) ] set Subject [set TabBlast($BId,SubjectBrut)] set TailleSbjct [set TabBlast($BId,Taille) ] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set AlignementBrut [set TabBlast($BId,$j,AlignBrut)] set TypeRegion [set TabBlast($BId,$j,Orientation)] if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp} if {$TypeRegion == "" && [regexp "BLASTP" $TypeDeBlast]} {set TypeRegion "Prot / Prot"} set ColorFill [ColoriageDuMapping $TypeRegion] set ColorFill [HtmlCompatibleColor $ColorFill] set n [set PosYSurEtagereDe($BId,$j)] set YDebut [expr $YIni + $n * ($EcartY + $HSmallBox)] set YFin [expr $YDebut + $HSmallBox] set XDebut [set PositionX($DQ)] set XFin [set PositionX($FQ)] FormateLesCoordonnees XDebut YDebut XFin YFin $K create rectangle $XDebut $YDebut $XFin $YFin -outline black -fill $ColorFill -tags [list "$BId-$j" "$FichierBlast" "$AlignementBrut" "" "AvecAlignement"] } set XDebutLine 0 set XFinLine $LargeurMax set n [set PosYSurEtagereDe($BId,1)] set YLine [expr $YIni + $n * ($EcartY + $HSmallBox) - $EcartY/2] set YTexte [expr $YIni + $n * ($EcartY + $HSmallBox) + $HSmallBox /2] FormateLesCoordonnees XDebutLine YLine XTexteGauche YTexte XTexteDroite $K create line $XDebutLine $YLine $XFinLine $YLine -fill $ColorFillLine $K create text $XTexteGauche $YTexte -text "$BId" -font "$Police" -tags [list "$BId" "$FichierBlast" "" "$Subject" "AvecAccess" ] $K create text $XTexteDroite $YTexte -text "$TailleSbjct $Expect" -font "$Police" -tags [list "$BId" "$FichierBlast" "" "" "AvecSubject" ] } regsub {\.canvas} $K "" w if {[info exists Nom]} { set B [$BoutonneLaFenetre $w "BLAST\nShow / Browse / Other"] $Bind $B <1> "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs" $Bind $B <2> "IllustreLeBlast \[ButineArborescence\]" $Bind $B <3> "IllustreLeBlast \[ChoisirUnBlast $Nom\]" } else { set B [$BoutonneLaFenetre $w "BLAST\nShow / Browse"] $Bind $B <1> "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs" $Bind $B <2> "IllustreLeBlast \[ButineArborescence\]" } set C [$BoutonneLaFenetre $w "APPEARANCES\nColor Subject/Query\nDefault" ] $Bind $C <1> "CouleursDesBoites" $Bind $C <2> "CouleursDesFrequences" $Bind $C "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K UnSet\]" set S [$BoutonneLaFenetre $w "OPTIONS\nNbSubject 250 / x /NoLimit\nExpect 1e-3/ x /NoLimit\nOrga Keep/Elim/Default"] $Bind $S <1> "IllustreLeBlast $FichierBlast $ExpectDeRef {} \[LesBanquesIdEnStock $K\]" $Bind $S <2> "IllustreLeBlast $FichierBlast $ExpectDeRef \[Entre\] \[LesBanquesIdEnStock $K\]" $Bind $S <3> "IllustreLeBlast $FichierBlast $ExpectDeRef NoLimit {}" $Bind $S "IllustreLeBlast $FichierBlast {} $NbSubject \[LesBanquesIdEnStock $K\]" $Bind $S "IllustreLeBlast $FichierBlast \[Entre\] $NbSubject \[LesBanquesIdEnStock $K\]" $Bind $S "IllustreLeBlast $FichierBlast NoLimit $NbSubject {}" $Bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K\] ToPreserve" $Bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K\] ToEliminate" $Bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject" $K bind "AvecAccess" <1> "MappingDeLaSelection $K" $K bind "AvecAccess" <2> "SubjectDeLaSelection $K" $K bind "AvecAccess" <3> "FetchDeLaSelection $K" $K bind "AvecSubject" <1> "MappingDeLaSelection $K" $K bind "AvecSubject" <2> "SubjectDeLaSelection $K" $K bind "AvecSubject" <3> "FetchDeLaSelection $K" $K bind "AvecAlignement" <1> "AlignementDeLaSelection $K" $K bind "AvecAlignement" <2> "SubjectDeLaSelection $K" $K bind "AvecAlignement" <3> "FetchDeLaSelection $K" if {$PourSvg} { $K close svg return [$K ContentOf svg] } regexp {^\.[^\.]+} $K w regsub {.canvas$} $K ".buttons.dismiss" BoutonDismiss $BoutonDismiss configure -command "LesBanquesIdEnStock $K UnSet ;destroy $w" return $K } proc IllustreLeBlastCanva {FichierBlast {ExpectDeRef NoLimit} {NbSubject NoLimit} {LesBIdsAutorises ""} {SelectedOrganism None}} { global RepertoireDuGenome if {![file exists $FichierBlast]} {return ""} set TailleQuery [TailleDeLaQueryDuBlast $FichierBlast] if {$TailleQuery == 0} {return ""} if {$ExpectDeRef == "" } {set ExpectDeRef "1e-3" } elseif {$ExpectDeRef == "NoLimit"} {set ExpectDeRef "1e200"} if {$NbSubject == "" } {set NbSubject "250" } elseif {$NbSubject == "NoLimit"} {set NbSubject "1e200"} DepouilleLeBlast TabBlast $FichierBlast $ExpectDeRef $NbSubject set FichierTFA "" if {[EstUnPAB [file tail $FichierBlast]]} { set Nom [file tail $FichierBlast] set Dir [file dirname $FichierBlast] if {$Dir == "."} {set Dir [pwd]} set DirDuRepertoireDuGenome [lindex [split $Dir "/"] end] if {[regexp "^blastn|^blastx" $DirDuRepertoireDuGenome]} { set FichierTFA "$RepertoireDuGenome/nucmask/$Nom" if {![file exists $FichierTFA]} { set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom" } } elseif {[regexp "^blastp|^tblastn" $DirDuRepertoireDuGenome]} { if {[file exists "$RepertoireDuGenome/genscanpredictions/$Nom"]} { set FichierTFA "$RepertoireDuGenome/genscanpredictions/$Nom" } else { set FichierTFA "$RepertoireDuGenome/prottfa/$Nom" } } elseif {[regexp "^mrnablast" $DirDuRepertoireDuGenome]} { set FichierTFA "$RepertoireDuGenome/mrnahuman/$Nom" } } if {![file exists $FichierTFA]} {set FichierTFA ""} if { $SelectedOrganism == "ToPreserve"} { set LesOrganismesAConserver [LaSelectionDeNoe 1 NoSave] set LesOrganismesAEliminer {} } elseif {$SelectedOrganism == "ToEliminate"} { set LesOrganismesAEliminer [LaSelectionDeNoe 1 NoSave] set LesOrganismesAConserver {} } else { set LesOrganismesAConserver {} set LesOrganismesAEliminer {} } set LargeurMax [expr [winfo screenwidth .] - 50] set HauteurMax [expr [winfo screenheight .]*2/3] set LargeurFenetre [expr [winfo screenwidth .] - 50] set HauteurFenetre [expr [winfo screenheight .]*2/3] set HBox 25.0 set HSmallBox 15.0 set BordY 50.0 set BordX 200.0 set EcartY 10.0 set YTypeDeBlast [expr $BordY/4] set YNomQuery [expr $BordY*2/3] set CentreX [expr $LargeurMax/2] set XTexteGauche [expr $BordX/2] set XTexteDroite [expr $LargeurMax - $BordX/2] set YDebut $BordY set YFin [expr $YDebut + $HBox] set YTaille [expr $YDebut + ($YFin - $YDebut)/2] set TailleMaxNomQuery 100 set Police "Courier 10" set ColorOutLine "White" set ColorFillLine "black" set Rapport [expr ($LargeurMax - 2 * $BordX) / $TailleQuery] set LesRegionsMasquees [LesRegionsMasqueesDeLaQuery $FichierTFA ] set LesPetitesRegionsDuBlast [LesRegionsDuTabBlast TabBlast] set OldDebutGdeRegion 0 set OldFinGdeRegion 0 set LesGdesRegionsDuBlast {} set LesPetitesRegionsOccupees {} foreach LaPetiteRegion $LesPetitesRegionsDuBlast { set Pos [lindex $LaPetiteRegion 0] set Frequence [lindex $LaPetiteRegion 1] set Debut [lindex $LaPetiteRegion 2] set Fin [lindex $LaPetiteRegion 3] set DebutGdeRegion [lindex $LaPetiteRegion 4] set FinGdeRegion [lindex $LaPetiteRegion 5] if {$FinGdeRegion < $DebutGdeRegion} { set tmp $FinGdeRegion;set FinGdeRegion $DebutGdeRegion;set DebutGdeRegion $tmp } lappend LesPetitesRegionsOccupees [list "$Debut" "$Fin"] if {$OldDebutGdeRegion == $DebutGdeRegion && $OldFinGdeRegion == $FinGdeRegion} {continue} lappend LesGdesRegionsDuBlast [list "$DebutGdeRegion" "$FinGdeRegion"] set OldDebutGdeRegion $DebutGdeRegion set OldFinGdeRegion $FinGdeRegion } foreach UneRegionMasquee $LesRegionsMasquees { set Debut [lindex $UneRegionMasquee 0] set Fin [lindex $UneRegionMasquee 1] lappend LesPetitesRegionsDuBlast [list "0" "N" "$Debut" "$Fin"] lappend LesPetitesRegionsOccupees [list "$Debut" "$Fin"] } set LesRegionsVides [LesRegionsVidesDeLaListe $LesPetitesRegionsOccupees $TailleQuery] foreach UneRegionVide $LesRegionsVides { set Debut [lindex $UneRegionVide 0] set Fin [lindex $UneRegionVide 1] lappend LesPetitesRegionsDuBlast [list "0" "0" "$Debut" "$Fin"] } set TousBIdAutorises 1 if { $LesBIdsAutorises != "" } { set TousBIdAutorises 0 foreach BId $LesBIdsAutorises {set BIdAutorise($BId) 1} } if {![info exists TabBlast(NbSubject)]} {Espionne "NbSubject n'existe pas" ; return ""} set NbSubjectDansBlast [set TabBlast(NbSubject) ] set NomQuery [set TabBlast(Query) ] set TypeDeBlast "[set TabBlast(TypeDeBlast)]: [set TabBlast(Database)]" set PetitNomQuery $NomQuery if {$TailleMaxNomQuery < [string length $NomQuery]} { set PetitNomQuery [string range $NomQuery 0 $TailleMaxNomQuery] append PetitNomQuery "..." } set EmpilementTotal 0 set LesBIds {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] if {$TousBIdAutorises || [info exists BIdAutorise($BId)]} { lappend LesBIds $BId } } set LesBanquesId {} set i 0 foreach BId $LesBIds { incr i if {$ExpectDeRef < [set TabBlast($BId,1,Expect)] || $NbSubject < $i} {break} set Access [set TabBlast($BId,Access) ] set EstCeUnDesOrga 0 if {$LesOrganismesAEliminer != "" || $LesOrganismesAConserver != ""} { foreach Orga [LesOrganismesEnStock $BId $Access] { Espionne "$BId\t$Access\t$Orga" if { $LesOrganismesAEliminer != "" && [regexp -nocase $Orga [join $LesOrganismesAEliminer "\t"]]} { set EstCeUnDesOrga 1 break } if { $LesOrganismesAConserver != "" && [regexp -nocase $Orga [join $LesOrganismesAConserver "\t"]]} { set EstCeUnDesOrga 1 break } } if {!$EstCeUnDesOrga && $SelectedOrganism == "ToPreserve" } {continue} if { $EstCeUnDesOrga && $SelectedOrganism == "ToEliminate"} {continue} } lappend LesBanquesId $BId set NbSegment [set TabBlast($BId,NbSegment)] set NMaxSubject 0 for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set DS [set TabBlast($BId,$j,DS)] set FS [set TabBlast($BId,$j,FS)] if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp} set LesPetitesRegionsRecouvertes {} set NMaxSegment 0 foreach UneRegion $LesPetitesRegionsDuBlast { set Frequence [lindex $UneRegion 1] set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] if {$Frequence == 0 || $Frequence == "N" } {continue} if {![info exists Empilement($DebutPetiteRegion,$FinPetiteRegion)]} { set Empilement($DebutPetiteRegion,$FinPetiteRegion) 0 } if {$DQ <= $DebutPetiteRegion && $FinPetiteRegion <= $FQ} { incr Empilement($DebutPetiteRegion,$FinPetiteRegion) if {$NMaxSegment < [set Empilement($DebutPetiteRegion,$FinPetiteRegion)]} { set NMaxSegment [set Empilement($DebutPetiteRegion,$FinPetiteRegion)] } lappend LesPetitesRegionsRecouvertes $UneRegion } } foreach UneRegion $LesPetitesRegionsRecouvertes { set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] set Empilement($DebutPetiteRegion,$FinPetiteRegion) $NMaxSegment } set PosYSurEtagereDe($BId,$j) [expr $EmpilementTotal + $NMaxSegment] if {$NMaxSubject < $NMaxSegment} {set NMaxSubject $NMaxSegment} } set EmpilementTotal [expr $EmpilementTotal + $NMaxSubject] foreach UneRegion $LesPetitesRegionsDuBlast { set Frequence [lindex $UneRegion 1] set DebutPetiteRegion [lindex $UneRegion 2] set FinPetiteRegion [lindex $UneRegion 3] if {$Frequence == 0 || $Frequence == "N" } {continue} unset Empilement($DebutPetiteRegion,$FinPetiteRegion) } } set HauteurMax [expr 2 * $BordY + $HBox + $EmpilementTotal * ($EcartY + $HSmallBox)] if {$HauteurMax < $HauteurFenetre} { set HauteurFenetre $HauteurMax } set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K configure -background white LesBanquesIdEnStock $K $LesBanquesId $K create text [expr $LargeurMax/2] $YTypeDeBlast -text "$TypeDeBlast" -font "$Police" $K create text [expr $LargeurMax/2] $YNomQuery -text "$PetitNomQuery" -font "$Police" $K create text $XTexteGauche $YTaille -text "1" -font "$Police" $K create text $XTexteDroite $YTaille -text "$TailleQuery" -font "$Police" foreach UneRegion [lsort -increasing -integer -index 2 $LesPetitesRegionsDuBlast] { set Frequence [lindex $UneRegion 1] set Debut [lindex $UneRegion 2] set Fin [lindex $UneRegion 3] set XDebut [expr $BordX + $Debut * $Rapport ] set XFin [expr $BordX + $Fin * $Rapport ] set ColorFill [ColoriageDeLaFrequence $Frequence] set PositionX($Debut) $XDebut set PositionX($Fin) $XFin $K create rectangle $XDebut $YDebut $XFin $YFin -outline $ColorFill -fill $ColorFill } set YIni [expr $BordY + $HBox + $EcartY] set m 0 foreach BId [LesBanquesIdEnStock $K] { set NbSegment [set TabBlast($BId,NbSegment) ] set Expect [set TabBlast($BId,1,Expect) ] set Subject [set TabBlast($BId,SubjectBrut)] set TailleSbjct [set TabBlast($BId,Taille) ] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set AlignementBrut [set TabBlast($BId,$j,AlignBrut)] set TypeRegion [set TabBlast($BId,$j,Orientation)] if {$FQ < $DQ} {set tmp $FQ;set FQ $DQ;set DQ $tmp} if {$TypeRegion == "" && [regexp "BLASTP" $TypeDeBlast]} {set TypeRegion "Prot / Prot"} set ColorFill [ColoriageDuMapping $TypeRegion] set n [set PosYSurEtagereDe($BId,$j)] set YDebut [expr $YIni + $n * ($EcartY + $HSmallBox)] set YFin [expr $YDebut + $HSmallBox] set XDebut [set PositionX($DQ)] set XFin [set PositionX($FQ)] # $K create rectangle $XDebut $YDebut $XFin $YFin -outline black -fill $ColorFill -tags [list "$BId" "$FichierBlast" "$AlignementBrut" "$Subject" "AvecAlignement"] $K create rectangle $XDebut $YDebut $XFin $YFin -outline black -fill $ColorFill -tags [list "$BId" "$FichierBlast" "$AlignementBrut" "" "AvecAlignement"] } set XDebutLine 0 set XFinLine $LargeurMax set n [set PosYSurEtagereDe($BId,1)] set YLine [expr $YIni + $n * ($EcartY + $HSmallBox) - $EcartY/2] set YTexte [expr $YIni + $n * ($EcartY + $HSmallBox) + $HSmallBox /2] $K create line $XDebutLine $YLine $XFinLine $YLine -fill $ColorFillLine $K create text $XTexteGauche $YTexte -text "$BId" -font "$Police" -tags [list "$BId" "$FichierBlast" "" "$Subject" "AvecAccess" ] $K create text $XTexteDroite $YTexte -text "$TailleSbjct $Expect" -font "$Police" -tags [list "$BId" "$FichierBlast" "" "" "AvecSubject" ] } regsub {\.canvas} $K "" w if {[info exists Nom]} { set B [BoutonneLaFenetre $w "BLAST\nShow / Browse / Other"] bind $B <1> "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs" bind $B <2> "IllustreLeBlast \[ButineArborescence\]" bind $B <3> "IllustreLeBlast \[ChoisirUnBlast $Nom\]" } else { set B [BoutonneLaFenetre $w "BLAST\nShow / Browse"] bind $B <1> "AfficheFichier $FichierBlast AvecSegAlignementAvecAligneurs" bind $B <2> "IllustreLeBlast \[ButineArborescence\]" } set C [BoutonneLaFenetre $w "APPEARANCES\nColor Subject/Query\nDefault" ] bind $C <1> "CouleursDesBoites" bind $C <2> "CouleursDesFrequences" bind $C "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K UnSet\]" set S [BoutonneLaFenetre $w "OPTIONS\nNbSubject 250 / x /NoLimit\nExpect 1e-3/ x /NoLimit\nOrga Keep/Elim/Default"] bind $S <1> "IllustreLeBlast $FichierBlast $ExpectDeRef {} \[LesBanquesIdEnStock $K\]" bind $S <2> "IllustreLeBlast $FichierBlast $ExpectDeRef \[Entre\] \[LesBanquesIdEnStock $K\]" bind $S <3> "IllustreLeBlast $FichierBlast $ExpectDeRef NoLimit {}" bind $S "IllustreLeBlast $FichierBlast {} $NbSubject \[LesBanquesIdEnStock $K\]" bind $S "IllustreLeBlast $FichierBlast \[Entre\] $NbSubject \[LesBanquesIdEnStock $K\]" bind $S "IllustreLeBlast $FichierBlast NoLimit $NbSubject {}" bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K\] ToPreserve" bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject \[LesBanquesIdEnStock $K\] ToEliminate" bind $S "IllustreLeBlast $FichierBlast $ExpectDeRef $NbSubject" $K bind "AvecAccess" <1> "MappingDeLaSelection $K" $K bind "AvecAccess" <2> "SubjectDeLaSelection $K" $K bind "AvecAccess" <3> "FetchDeLaSelection $K" $K bind "AvecSubject" <1> "MappingDeLaSelection $K" $K bind "AvecSubject" <2> "SubjectDeLaSelection $K" $K bind "AvecSubject" <3> "FetchDeLaSelection $K" $K bind "AvecAlignement" <1> "AlignementDeLaSelection $K" $K bind "AvecAlignement" <2> "SubjectDeLaSelection $K" $K bind "AvecAlignement" <3> "FetchDeLaSelection $K" regexp {^\.[^\.]+} $K w regsub {.canvas$} $K ".buttons.dismiss" BoutonDismiss $BoutonDismiss configure -command "LesBanquesIdEnStock $K UnSet ;destroy $w" return $K } proc IllustreLeBlastSurLArbreTaxonomique {FichierBlast} { if {![file exists $FichierBlast]} {return} set LesAccess {} foreach LAccess [LesHitsDuBlast_FC $FichierBlast] {lappend LesAccess [lindex $LAccess 0]} IllustreLesAccessSurLArbreTaxonomique $LesAccess return "" } proc IllustreLeCamembert {Titre LesParts {AvecLesLegendes Yes}} { Wup "LesParts liste du type [list [list effectif Couleur PetiteLegende GrandeLegende]]" set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set K [UnCanva $Largeur $Hauteur $Largeur $Hauteur WithY] set K [PlaceLeCamembert $LesParts $K 0 $Hauteur 0 $Largeur $Titre $AvecLesLegendes] return $K } proc IllustreLeCamembertOntologique {Type {LesGO ""}} { set Titre "ONTOLOGY : $Type" if {$LesGO == {}} {set Niveau 0;set LesGO [Onto $Type $Niveau]} set GONothing [Onto $Type Nothing] set LesParts {} foreach GO $LesGO { set nRequetes 0 set LesJumeaux {} set LesBlastP {} set LesAccess {} set LesClusters {} set LesRequetes {} set LesProjetsGscope {} set LesNoms {} if {[OntoExists $Type $GO LesJumeaux ]} {set LesJumeaux [Onto $Type $GO LesJumeaux]} if {[OntoMesGOExists $Type $GO LesBlastP ]} {set LesBlastP [OntoMesGO $Type $GO LesBlastP]} if {[OntoMesGOExists $Type $GO LesAccess ]} {set LesAccess [OntoMesGO $Type $GO LesAccess]} if {[OntoMesGOExists $Type $GO LesClusters]} {set LesClusters [OntoMesGO $Type $GO LesClusters]} if {[OntoMesGOExists $Type $GO LesRequetes]} {set LesRequetes [OntoMesGO $Type $GO LesRequetes]} if {[OntoMesGOExists $Type $GO LesNoms ]} {set LesNoms [OntoMesGO $Type $GO LesNoms]} if {[OntoMesGOExists $Type $GO LesProjetsGscope]} {set LesProjetsGscope [OntoMesGO $Type $GO LesProjetsGscope]} set ToutesLesRequetes [concat $LesBlastP $LesAccess $LesRequetes $LesNoms] set nRequetes [llength $ToutesLesRequetes] if {$nRequetes == 0} {continue} set LesEnfants [Onto $Type $GO LesEnfants ] set LesContributions [Onto $Type $GO LesContributions] set LesParents [Onto $Type $GO LesParents ] set LesConstituants [Onto $Type $GO LesConstituants ] set LesDefinitions [Onto $Type $GO LesDefinitions ] set Definition [lindex $LesDefinitions 0] set PetiteLegende "$GO $Definition" set GrandeLegende "My Name is\n$Type\n\nMy Nickname is\n$GO\n\nI am\n[join $LesDefinitions "\n"]" if {$LesJumeaux != ""} {append GrandeLegende "\n\nMy twins are\n[join $LesJumeaux " ; "]"} if {$LesParents != ""} {append GrandeLegende "\n\nMy Parents are\n[join $LesParents " ; "]"} if {$LesConstituants != ""} {append GrandeLegende "\n\nI am constituted by\n[join $LesConstituants " ; "]"} if {$LesEnfants != ""} {append GrandeLegende "\n\nMy children are\n[join $LesEnfants " ; "]"} if {$LesContributions != ""} {append GrandeLegende "\n\nI contribute to\n[join $LesContributions " ; "]"} if {$nRequetes != 0 } {append GrandeLegende "\n\nNumber of hits : $nRequetes"} if {$LesAccess != ""} {append GrandeLegende "\n\n[join $LesAccess " ; "]"} if {$LesProjetsGscope != ""} {append GrandeLegende "\n\n[join $LesProjetsGscope " ; "]"} if {$LesNoms != ""} {append GrandeLegende "\n\n[join $LesNoms " ; "]"} if {$LesBlastP != ""} {append GrandeLegende "\n\n[join $LesBlastP " ; "]"} if {$LesClusters != ""} {append GrandeLegende "\n\n[join $LesClusters " ; "]"} if {$LesRequetes != ""} {append GrandeLegende "\n\n[join $LesRequetes " ; "]"} set Color "" if {$GO == $GONothing} {set Color "white"} lappend LesParts [list "$nRequetes" "$PetiteLegende" "$GrandeLegende" "$Color"] } if {$LesParts == {} } {return ""} set LesPartsDeCamembert {} foreach LaPart $LesParts Color [GammeDeCouleursRVB_CHALMEL [llength $LesParts] Random] { if {[lindex $LaPart 3] == ""} { set LaPart [linsert $LaPart 1 $Color ] } else { set LaPart [linsert $LaPart 1 [lindex $LaPart 3]] } lappend LesPartsDeCamembert $LaPart } set K [IllustreLeCamembert $Titre $LesPartsDeCamembert] regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "Ontology function/process/component\nReset all my GO"] bind $B <1> "IllustreLeCamembertOntologique function " bind $B <2> "IllustreLeCamembertOntologique process " bind $B <3> "IllustreLeCamembertOntologique component" bind $B "ResetMesGO" $K bind "Part" <1> "DiviseLeGO $K $Type \"$LesGO\"" } proc IllustreLeCamembertOntologiqueDesBoitesGscope {LesNoms {Type ""}} { if {$Type == ""} {set Type [ChoixParmi [LesTypesOntologiques]]} Espionne "LOADING ONTOLOGY..." ChargeLesGODeLaBoiteGscope $LesNoms Espionne "ONTOLOGY LOADED..." IllustreLeCamembertOntologique $Type } proc IllustreLeCamembertOntologiqueDuCluster {FichierO2C2A2D2E {Cluster ""} {Type ""}} { if {$Cluster == ""} {set Cluster [ChoixParmi [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesClusters]]} if {$Type == ""} {set Type [ChoixParmi [LesTypesOntologiques]]} set LesNoms [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] Espionne "LOADING ONTOLOGY..." Espionne $LesNoms ChargeLesGODeLaBoiteGscope $LesNoms Espionne "ONTOLOGY LOADED..." IllustreLeCamembertOntologique $Type } proc IllustreLeFichierDAccessSurLArbreTaxonomique {FichierAccess} { if {![file exists $FichierAccess]} {return} IllustreLesAccessSurLArbreTaxonomique [LesLignesDuFichier $FichierAccess] return } proc IllustreLeFichierDOrganismesSurLArbreTaxonomique {FichierOrga} { if {![file exists $FichierOrga]} {return} IllustreLArbreTaxonomique [LesLignesDuFichier $FichierOrga] return } proc IllustreLePathway {Pathway {Organisme ""} {LesElementsParticuliers ""}} { set FichierGif [FichierPathway $Pathway $Organisme "gif" ] if {![file exists $FichierGif]} {set FichierGif [FichierPathway $Pathway "" "gif"]} if {![file exists $FichierGif]} {return} foreach Elet $LesElementsParticuliers {set TabTmp($Elet) 1} set FichierConf [FichierPathway $Pathway $Organisme "conf"] set FichierConfMap [FichierPathway $Pathway "" "conf"] set PhotoPathway "Pathway_$Pathway" image create photo $PhotoPathway -file $FichierGif set LargeurMax [image width $PhotoPathway] set HauteurMax [image height $PhotoPathway] set LargeurFenetre [expr [winfo screenwidth .] * 4/5] set HauteurFenetre [expr [winfo screenheight .] * 4/5] if {$LargeurMax < $LargeurFenetre} {set LargeurFenetre $LargeurMax} if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set Definition [lindex [InterrogePathway $FichierConf Definition] 0] if {$Definition == ""} { set Definition [lindex [InterrogePathway $FichierConfMap Definition] 0] } set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre NoZoom $Definition 1] $K create image 0 0 -image $PhotoPathway -anchor nw set i 0 ####Les objects du pathway appartenant à l'organisme##### foreach LaCoord [concat [InterrogePathway $FichierConf LesCoordonnees] [InterrogePathway $FichierConfMap LesCoordonnees]] { incr i set Forme [lindex $LaCoord 0] set XMin [lindex $LaCoord 1] set YMin [lindex $LaCoord 2] set XMax [lindex $LaCoord 3] set YMax [lindex $LaCoord 4] if {[info exists TabTmp($Forme,$XMin,$YMin,$XMax,$YMax)]} {continue} set LesConcernes [InterrogePathway $FichierConf Forme $Forme XMin $XMin YMin $YMin XMax $XMax YMax $YMax LesConcernes] set LesConcernesMap [InterrogePathway $FichierConfMap Forme $Forme XMin $XMin YMin $YMin XMax $XMax YMax $YMax LesConcernes] if {$LesConcernesMap != ""} {set LesConcernes [lsort -unique [concat $LesConcernes $LesConcernesMap]]} if {$LesConcernes == {}} {continue} set TabTmp($Forme,$XMin,$YMin,$XMax,$YMax) 1 set Couleur [lindex [lindex $LesConcernes 0] end] foreach LeConcerne $LesConcernesMap { set Qui [lindex $LeConcerne 1] if {[info exists TabTmp($Qui)]} {set Couleur "red";break} } ###JE PREPARE LE TEXTE QUI VA ETRE AFFICHE DANS INFOBULLE############ set Def [InterrogeKEGG Pathway $Pathway Definition] set LesNoms {} set LeTexte {} lappend LeTexte "Pathway: $Pathway" lappend LeTexte "$Def" if {$Organisme != "" || $Organisme != "map"} {lappend LeTexte "Organism: $Organisme"} foreach LeConcerne [lsort -unique -index 0 $LesConcernes] { set Qui [lindex $LeConcerne 1] set Quoi [lindex $LeConcerne 0] set LesDefinitions [lindex $LeConcerne 3] set LesLiens {} set LesPathway {} set LesPAB [InterrogeMesKEGG $Quoi $Qui LesNoms ] if {$LesPAB != ""} {set LesNoms [concat $LesNoms $LesPAB]} if {$Quoi == "Kegg"} { set LesLiens [InterrogeKEGG Kegg $Qui LesLiens ] set LesPathway [InterrogeKEGG Kegg $Qui LesPathway ] } if {$Quoi == "EC" } { set LesPathway [InterrogeECCpdRn Element $Qui LesPathway ] } if {$Quoi == "Compound"} { set LesPathway [InterrogeECCpdRn Element $Qui LesPathway] } foreach Pathway $LesPathway { set LesPAB [InterrogeMesKEGG Pathway $Qui LesNoms ] if {$LesPAB != ""} {set LesNoms [concat $LesNoms $LesPAB]} } lappend LeTexte "" lappend LeTexte "$Quoi: $Qui" foreach Def $LesDefinitions {lappend LeTexte "$Def"} foreach Link $LesLiens {lappend LeTexte "Links: $Link"} if {$LesPathway != {}} {lappend LeTexte "Linked Pathway: [join $LesPathway " "]"} } lappend LeTexte "" set LesNoms [lsort -unique $LesNoms] if {$LesNoms != {}} {lappend LeTexte "Gscope Box: [join $LesNoms " "]"} set Texte [join $LeTexte "\n"] ###FIN : JE PREPARE LE TEXTE QUI VA ETRE AFFICHE DANS INFOBULLE############ if {$Forme != "oval"} { set PhotoObject "${PhotoPathway}_Object$i" image create photo $PhotoObject $PhotoObject copy $PhotoPathway -from $XMin $YMin $XMax $YMax $K create image $XMin $YMin -image $PhotoObject -anchor nw -tags [list "Object" $Texte $Pathway $Organisme $LesConcernes $LesElementsParticuliers] $K create $Forme $XMin $YMin $XMax $YMax -outline $Couleur -width 2 } else { $K create $Forme $XMin $YMin $XMax $YMax -fill $Couleur -tags [list "Object" $Texte $Pathway $Organisme $LesConcernes $LesElementsParticuliers] } } if {[info exists TabTmp]} {unset TabTmp} InterrogePathway unset $K bind "Object" <1> "IllustreLesPathwayLies $K " $K bind "Object" "AfficheInfoBulle $K %x %y Enter" $K bind "Object" "AfficheInfoBulle $K %x %y Leave" return $K } proc IllustreLePathway_AEffacer {Pathway {Organisme ""} {LesElementsParticuliers ""}} { set FichierGif [FichierPathway $Pathway $Organisme "gif" ] if {![file exists $FichierGif]} {set FichierGif [FichierPathway $Pathway "" "gif"]} if {![file exists $FichierGif]} {return} foreach Elet $LesElementsParticuliers {set TabTmp($Elet) 1} set FichierConf [FichierPathway $Pathway $Organisme "conf"] set FichierConfMap [FichierPathway $Pathway "" "conf"] set PhotoPathway "Pathway_$Pathway" image create photo $PhotoPathway -file $FichierGif set LargeurMax [image width $PhotoPathway] set HauteurMax [image height $PhotoPathway] set LargeurFenetre [expr [winfo screenwidth .] * 4/5] set HauteurFenetre [expr [winfo screenheight .] * 4/5] if {$LargeurMax < $LargeurFenetre} {set LargeurFenetre $LargeurMax} if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set Definition [lindex [InterrogePathway $FichierConf Definition] 0] if {$Definition == ""} { set Definition [lindex [InterrogePathway $FichierConfMap Definition] 0] } set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre NoZoom $Definition 1] $K create image 0 0 -image $PhotoPathway -anchor nw set i 0 ####Les objects du pathway appartenant à l'organisme##### foreach LaCoord [concat [InterrogePathway $FichierConf LesCoordonnees] [InterrogePathway $FichierConfMap LesCoordonnees]] { incr i set Forme [lindex $LaCoord 0] set XMin [lindex $LaCoord 1] set YMin [lindex $LaCoord 2] set XMax [lindex $LaCoord 3] set YMax [lindex $LaCoord 4] if {[info exists TabTmp($Forme,$XMin,$YMin,$XMax,$YMax)]} {continue} set LesConcernes [InterrogePathway $FichierConf Forme $Forme XMin $XMin YMin $YMin XMax $XMax YMax $YMax LesConcernes] set LesConcernesMap [InterrogePathway $FichierConfMap Forme $Forme XMin $XMin YMin $YMin XMax $XMax YMax $YMax LesConcernes] if {$LesConcernesMap != ""} {set LesConcernes [lsort -unique [concat $LesConcernes $LesConcernesMap]]} if {$LesConcernes == {}} {continue} set TabTmp($Forme,$XMin,$YMin,$XMax,$YMax) 1 set Couleur [lindex [lindex $LesConcernes 0] end] foreach LeConcerne $LesConcernesMap { set Qui [lindex $LeConcerne 1] if {[info exists TabTmp($Qui)]} {set Couleur "red";break} } ###JE PREPARE LE TEXTE QUI VA ETRE AFFICHE DANS INFOBULLE############ set Def [InterrogeKEGG Pathway $Pathway Definition] set LesNoms {} set LeTexte {} lappend LeTexte "Pathway: $Pathway" lappend LeTexte "$Def" if {$Organisme != "" || $Organisme != "map"} {lappend LeTexte "Organism: $Organisme"} foreach LeConcerne [lsort -unique -index 0 $LesConcernes] { set Qui [lindex $LeConcerne 1] set Quoi [lindex $LeConcerne 0] set LesDefinitions [lindex $LeConcerne 3] set LesLiens {} set LesPathway {} set LesPAB [InterrogeMesKEGG $Quoi $Qui LesNoms ] if {$LesPAB != ""} {set LesNoms [concat $LesNoms $LesPAB]} if {$Quoi == "Kegg"} { set LesLiens [InterrogeKEGG Kegg $Qui LesLiens ] set LesPathway [InterrogeKEGG Kegg $Qui LesPathway ] } if {$Quoi == "EC" } { set LesPathway [InterrogeECCpdRn Element $Qui LesPathway ] } if {$Quoi == "Compound"} { set LesPathway [InterrogeECCpdRn Element $Qui LesPathway] } foreach Pathway $LesPathway { set LesPAB [InterrogeMesKEGG Pathway $Qui LesNoms ] if {$LesPAB != ""} {set LesNoms [concat $LesNoms $LesPAB]} } lappend LeTexte "" lappend LeTexte "$Quoi: $Qui" foreach Def $LesDefinitions {lappend LeTexte "$Def"} foreach Link $LesLiens {lappend LeTexte "Links: $Link"} if {$LesPathway != {}} {lappend LeTexte "Linked Pathway: [join $LesPathway " "]"} } lappend LeTexte "" set LesNoms [lsort -unique $LesNoms] if {$LesNoms != {}} {lappend LeTexte "Gscope Box: [join $LesNoms " "]"} set Texte [join $LeTexte "\n"] ###FIN : JE PREPARE LE TEXTE QUI VA ETRE AFFICHE DANS INFOBULLE############ if {$Forme != "oval"} { set PhotoObject "${PhotoPathway}_Object$i" image create photo $PhotoObject $PhotoObject copy $PhotoPathway -from $XMin $YMin $XMax $YMax $K create image $XMin $YMin -image $PhotoObject -anchor nw -tags [list "Object" $Texte $Pathway $Organisme $LesConcernes $LesElementsParticuliers] $K create $Forme $XMin $YMin $XMax $YMax -outline $Couleur -width 2 } else { $K create $Forme $XMin $YMin $XMax $YMax -fill $Couleur -tags [list "Object" $Texte $Pathway $Organisme $LesConcernes $LesElementsParticuliers] } } if {[info exists TabTmp]} {unset TabTmp} InterrogePathway unset $K bind "Object" <1> "IllustreLesPathwayLies $K " $K bind "Object" "AfficheInfoBulle $K %x %y Enter" $K bind "Object" "AfficheInfoBulle $K %x %y Leave" return $K } proc IllustreLesAccessSurLArbreTaxonomique {LesAccessOuBanqueId} { set LesOrgas {} AskLesPagesInfos load $LesAccessOuBanqueId foreach Access $LesAccessOuBanqueId { set Page [AskLesPagesInfos ask $Access] if {$Page == ""} {continue} foreach Orga [LesOrgasDeLaPage_PageInfo $Page] { Espionne "$Access\t$Orga" lappend LesOrgas $Orga } } AskLesPagesInfos unset if {$LesOrgas == {}} {return} IllustreLArbreTaxonomique [ElimineLesRedondancesDansUneListe $LesOrgas] return } proc IllustreLesCamemberts {LesListes {AvecLesLegendes Yes} {nParLigne 1}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set nTot [llength $LesListes] set LesCoords [CoordonneesDesPavesVerticaux $nParLigne $nTot $Hauteur $Largeur] set LesCoords [lsort -real -decreasing -index 4 $LesCoords] set K [UnCanva $Largeur [lindex [lindex $LesCoords 0] 4] $Largeur $Hauteur WithY] foreach Liste $LesListes LaCoord [lsort -integer -index 0 $LesCoords] { ScanLaListe $LaCoord n LMin HMin LMax HMax PlaceLeCamembert [lrange $Liste 1 end] $K $HMin $HMax $LMin $LMax [lindex $Liste 0] $AvecLesLegendes } return $K } proc IllustreLesChromosomes {{LesNoms ""} {Qui OnlyTheBest} {OldW ""} {Titre ""}} { if {$OldW!=""} { catch {after 10 Destroy $OldW} } set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierLocalisation [ChoixDuFichierLocalisationHuman] if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {return ""} ChargeFoldDesSequences Expression ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms ChargeBandesCytologiques Genome $FichierBandesCytos set PoliceChromo "Courier 9 bold" set PoliceBande "Courier 4" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] set TailleMaxBrasP [set Genome(TaillePMax) ] set TailleMaxBrasQ [set Genome(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo $LargeurChromo set LargeurBoite [expr $EcartEntreChromo/3] set Facteur [expr $HauteurAffichage / $TailleMaxChromo] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY $Titre] set LesChromosomes [set Genome(LesChromosomes)] set PosX $BordX foreach Chromosome $LesChromosomes { set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] set PosY $PosYDuCentromer set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set ExtremiteDuChromosome $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set EnAiJeVuAuMoinsUn 0 if {![info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} {continue} foreach Nom [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [expr [lindex $LInfo 10 ]/1.e6] set Fin [expr [lindex $LInfo 11]/1.e6] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set EnAiJeVuAuMoinsUn 1 set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set ColorFill [CouleurDuFold $Fold] set Var 0 if {$Qui != "OnlyTheBest" && $Info == ""} {set Var [expr $LargeurBoite * 1.5]} set PosYMin [expr $ExtremiteDuChromosome + $Debut*$Facteur] set PosYMax [expr $ExtremiteDuChromosome + $Fin *$Facteur] ##Les sequences dans le sens - par rapport au genome seront du côté gauche if {$Sens == "-"} { $K create oval [expr $PosXMin-$LargeurBoite-$Var] $PosYMin [expr $PosXMin-$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } elseif {$Sens == "+"} { ##Les sequences dans le sens + par rapport au genome seront du côté droit $K create oval [expr $PosXMax+$Var] $PosYMin [expr $PosXMax+$LargeurBoite+$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } } } set ColorText "black" if {$EnAiJeVuAuMoinsUn} {set ColorText "Red"} $K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] } $K create line $BordX $PosYDuCentromer [expr $LargeurMax-$BordX] $PosYDuCentromer -fill red LesNomsEnStock $K $LesNoms regsub {\.canvas} $K "" w $K bind "Chromosome" <1> "ChromosomeSelectionne $K \[LesNomsEnStock $K\] $Qui" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "OnlyBestLoc/All"] bind $B <1> "IllustreLesChromosomes \[LesNomsEnStock $K\] OnlyTheBest" bind $B <2> "IllustreLesChromosomes \[LesNomsEnStock $K\] All " set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" set Boutons "$w.buttons" return $K } proc IllustreLesChromosomesMouse {{LesNoms ""} {Qui OnlyTheBest} {OldW ""} {Titre ""}} { if {$OldW!=""} { catch {after 10 Destroy $OldW} } #set RepLocalisation "[HumanGenomeDir]/Localisation" set RepLocalisation "/genomics/link/UCSCGenomes/Mus_musculus/database" set FichierLocalisation [ChoixDuFichierLocalisationMouse] if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {return ""} ChargeFoldDesSequences Expression ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms ChargeBandesCytologiquesMouse Genome $FichierBandesCytos set PoliceChromo "Courier 9 bold" set PoliceBande "Courier 4" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] set TailleMaxBrasP [set Genome(TaillePMax) ] set TailleMaxBrasQ [set Genome(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo $LargeurChromo set LargeurBoite [expr $EcartEntreChromo/3] set Facteur [expr $HauteurAffichage / $TailleMaxChromo] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY $Titre] set LesChromosomes [set Genome(LesChromosomes)] set PosX $BordX foreach Chromosome $LesChromosomes { set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] set PosY $PosYDuCentromer set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set ExtremiteDuChromosome $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set EnAiJeVuAuMoinsUn 0 if {![info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} {continue} foreach Nom [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [expr [lindex $LInfo 10 ]/1.e6] set Fin [expr [lindex $LInfo 11]/1.e6] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set EnAiJeVuAuMoinsUn 1 set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set ColorFill [CouleurDuFold $Fold] set Var 0 if {$Qui != "OnlyTheBest" && $Info == ""} {set Var [expr $LargeurBoite * 1.5]} set PosYMin [expr $ExtremiteDuChromosome + $Debut*$Facteur] set PosYMax [expr $ExtremiteDuChromosome + $Fin *$Facteur] ##Les sequences dans le sens - par rapport au genome seront du côté gauche if {$Sens == "-"} { $K create oval [expr $PosXMin-$LargeurBoite-$Var] $PosYMin [expr $PosXMin-$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } elseif {$Sens == "+"} { ##Les sequences dans le sens + par rapport au genome seront du côté droit $K create oval [expr $PosXMax+$Var] $PosYMin [expr $PosXMax+$LargeurBoite+$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } } } set ColorText "black" if {$EnAiJeVuAuMoinsUn} {set ColorText "Red"} $K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] } $K create line $BordX $PosYDuCentromer [expr $LargeurMax-$BordX] $PosYDuCentromer -fill red LesNomsEnStock $K $LesNoms regsub {\.canvas} $K "" w $K bind "Chromosome" <1> "ChromosomeSelectionne $K \[LesNomsEnStock $K\] $Qui" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "OnlyBestLoc/All"] bind $B <1> "IllustreLesChromosomes \[LesNomsEnStock $K\] OnlyTheBest" bind $B <2> "IllustreLesChromosomes \[LesNomsEnStock $K\] All " set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" set Boutons "$w.buttons" return $K } proc IllustreLesChromosomes_AL {{PABouNomsInteressantsouListeouFichier PAB} {Qui OnlyTheBest} {OldW ""} {Titre ""}} { InterrogeOrf2Cluster2Access2Def2Expression unset set LesNoms [LesNoms $PABouNomsInteressantsouListeouFichier] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" if {$OldW!=""} { catch {after 10 Destroy $OldW} } set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierLocalisation [ChoixDuFichierLocalisationHuman] if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {return ""} ChargeFoldDesSequences Expression ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms ChargeBandesCytologiques Genome $FichierBandesCytos set ColorCluster(0) "green" set ColorCluster(2) "orange" set ColorCluster(4) "blue" set ColorCluster(5) "red" set ColorCluster(ICBP_D) "green" set ColorCluster(ICBP_U) "orange" set ColorCluster(TOPO_U) "blue" set ColorCluster(TOPO_D) "red" set PoliceChromo "Courier 15 bold" set PoliceBande "Courier 4" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] set TailleMaxBrasP [set Genome(TaillePMax) ] set TailleMaxBrasQ [set Genome(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo $LargeurChromo set LargeurBoite [expr $EcartEntreChromo/1.3] set Facteur [expr $HauteurAffichage / $TailleMaxChromo] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY $Titre] $K configure -background white set LesChromosomes [set Genome(LesChromosomes)] set PosX $BordX foreach Chromosome $LesChromosomes { set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] set PosY $PosYDuCentromer set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique_TL $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set ExtremiteDuChromosome $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique_TL $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set EnAiJeVuAuMoinsUn 0 set LesNomsDuChromosome {} if {[info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} { set LesNomsDuChromosome [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] } foreach Nom $LesNomsDuChromosome { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set ColorFill [set ColorCluster($Cluster)] foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [expr [lindex $LInfo 10 ]/1E6] set Fin [expr [lindex $LInfo 11]/1E6] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set EnAiJeVuAuMoinsUn 1 set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set Var 0 if {$Qui != "OnlyTheBest" && $Info == ""} {set Var [expr $LargeurBoite * 1.5]} set PosYMin [expr $ExtremiteDuChromosome + $Debut*$Facteur] set PosYMax [expr $ExtremiteDuChromosome + $Fin *$Facteur] ##Les sequences du cluster 0 ou 2 ou ICBP_D ou ICBP_U seront du côté gauche if {$Cluster == 0 || $Cluster == 2 || $Cluster == "ICBP_D" || $Cluster == "ICBP_U"} { $K create oval [expr $PosXMin-$LargeurBoite-$Var] $PosYMin [expr $PosXMin-$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } else { $K create oval [expr $PosXMax+$Var] $PosYMin [expr $PosXMax+$LargeurBoite+$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } } } set ColorText "black" if {$EnAiJeVuAuMoinsUn} {set ColorText "Red"} #$K create text $PosXNomChromo $PosYNomChromoSup -text [NumeroDuChromosome $Chromosome] -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text [NumeroDuChromosome $Chromosome] -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] } $K create line $BordX $PosYDuCentromer [expr $LargeurMax-$BordX] $PosYDuCentromer -fill black -dash {1 1} LesNomsEnStock $K $LesNoms regsub {\.canvas} $K "" w $K bind "Chromosome" <1> "ChromosomeSelectionne $K \[LesNomsEnStock $K\] $Qui" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "OnlyBestLoc/All"] bind $B <1> "IllustreLesChromosomes \[LesNomsEnStock $K\] OnlyTheBest" bind $B <2> "IllustreLesChromosomes \[LesNomsEnStock $K\] All " set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" set Boutons "$w.buttons" InterrogeOrf2Cluster2Access2Def2Expression unset return $K } proc IllustreLesChromosomes_Human {{LesNoms ""} {Qui OnlyTheBest} {OldW ""} {Titre ""}} { #replique de IllustreLesChromosomes de chalmel if {$OldW!=""} { catch {after 10 Destroy $OldW} } set FichierLocalisation "/genomics/link/HNR/Localisation/BestLocalisation_Human" if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} set RepLocalisation "/genomics/link/UCSCGenomes/Homo_sapiens/database" set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {return ""} ChargeFoldDesSequences Expression ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms ChargeBandesCytologiques Genome $FichierBandesCytos set PoliceChromo "Courier 9 bold" set PoliceBande "Courier 4" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] set TailleMaxBrasP [set Genome(TaillePMax) ] set TailleMaxBrasQ [set Genome(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo $LargeurChromo set LargeurBoite [expr $EcartEntreChromo/3] set Facteur [expr $HauteurAffichage / $TailleMaxChromo] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY $Titre] set LesChromosomes [set Genome(LesChromosomes)] set ListeDesChromosomes [split $LesChromosomes " "] foreach elmt $ListeDesChromosomes { if {[regexp {chr[0-9]?$} $elmt]} { lappend LesUns $elmt } elseif {[regexp {chr[0-9]{2}$} $elmt]} { lappend LesDeux $elmt } else {lappend LesSexes $elmt} } set ListeDesChromosomesRangee [concat $LesUns $LesDeux $LesSexes] set LesChromosomes [join $ListeDesChromosomesRangee " "] set PosX $BordX foreach Chromosome $LesChromosomes { set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] set PosY $PosYDuCentromer set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set ExtremiteDuChromosome $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set EnAiJeVuAuMoinsUn 0 if {![info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} { $K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] continue } foreach Nom [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [expr [lindex $LInfo 10 ]/1.e6] set Fin [expr [lindex $LInfo 11]/1.e6] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set EnAiJeVuAuMoinsUn 1 set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set ColorFill [CouleurDuFold $Fold] set Var 0 if {$Qui != "OnlyTheBest" && $Info == ""} {set Var [expr $LargeurBoite * 1.5]} set PosYMin [expr $ExtremiteDuChromosome + $Debut*$Facteur] set PosYMax [expr $ExtremiteDuChromosome + $Fin *$Facteur] ##Les sequences dans le sens - par rapport au genome seront du cote gauche if {$Sens == "-"} { $K create oval [expr $PosXMin-$LargeurBoite-$Var] $PosYMin [expr $PosXMin-$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } elseif {$Sens == "+"} { ##Les sequences dans le sens + par rapport au genome seront du cote droit $K create oval [expr $PosXMax+$Var] $PosYMin [expr $PosXMax+$LargeurBoite+$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } } } set ColorText "black" if {$EnAiJeVuAuMoinsUn} {set ColorText "Red"} $K create text $PosXNomChromo $PosYNomChromoSup -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text "$Chromosome" -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] } $K create line $BordX $PosYDuCentromer [expr $LargeurMax-$BordX] $PosYDuCentromer -fill red LesNomsEnStock $K $LesNoms regsub {\.canvas} $K "" w $K bind "Chromosome" <1> "ChromosomeSelectionne $K \[LesNomsEnStock $K\] $Qui" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "OnlyBestLoc/All"] bind $B <1> "IllustreLesChromosomes \[LesNomsEnStock $K\] OnlyTheBest" bind $B <2> "IllustreLesChromosomes \[LesNomsEnStock $K\] All " set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" set Boutons "$w.buttons" return $K } proc IllustreLesChromosomes_TL {{PABouNomsInteressantsouListeouFichier PAB} {Qui OnlyTheBest} {OldW ""} {Titre ""}} { set LesNoms [LesNoms $PABouNomsInteressantsouListeouFichier] set Fichier "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" if {$OldW!=""} { catch {after 10 Destroy $OldW} } set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierLocalisation [ChoixDuFichierLocalisationHuman] if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} {return ""} ChargeFoldDesSequences Expression ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms ChargeBandesCytologiques Genome $FichierBandesCytos set ColorCluster(0) "green" set ColorCluster(2) "orange" set ColorCluster(4) "blue" set ColorCluster(5) "red" set ColorCluster(ICBP_D) "green" set ColorCluster(ICBP_U) "orange" set ColorCluster(TOPO_U) "blue" set ColorCluster(TOPO_D) "red" set PoliceChromo "Courier 15 bold" set PoliceBande "Courier 4" set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurMax [expr [winfo screenheight .] - 200] set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set BordX 50.0 set BordYInf 50 set BordYSup 50 set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurAffichage [expr ($HauteurMax - ($BordYInf+$BordYSup))*1.0] set TailleMaxBrasP [set Genome(TaillePMax) ] set TailleMaxBrasQ [set Genome(TailleQMax) ] set TailleMaxChromo [expr $TailleMaxBrasP + $TailleMaxBrasQ] set NbChromosomes [set Genome(NbChromosomes)] set LargeurChromo [expr $LargeurAffichage/($NbChromosomes*3.0)] set EcartEntreChromo $LargeurChromo set LargeurBoite [expr $EcartEntreChromo/3] set Facteur [expr $HauteurAffichage / $TailleMaxChromo] set PosYDuCentromer [expr $TailleMaxBrasP * $Facteur + $BordYSup] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre WithY $Titre] $K configure -background white set LesChromosomes [set Genome(LesChromosomes)] set PosX $BordX foreach Chromosome $LesChromosomes { set LesBandesP [lsort [set Genome($Chromosome,LesBandesP)]] set PosY $PosYDuCentromer set PosXMin [expr $PosX + $EcartEntreChromo] set PosXMax [expr $PosXMin + $LargeurChromo] set PosXBande $PosX set PosX [expr $PosXMax + $EcartEntreChromo] set TailleBrasP [set Genome($Chromosome,TailleP)] set TailleBrasQ [set Genome($Chromosome,TailleQ)] set PosXNomChromo [expr ($PosXMax + $PosXMin)/2] set PosYNomChromoSup [expr $PosY - ($TailleBrasP * $Facteur) - 20] set PosYNomChromoInf [expr $PosY + ($TailleBrasQ * $Facteur) + 20] set Position($Chromosome) [list "$PosXMin" "$PosXMax"] foreach BandeP $LesBandesP { set LesInfos [set Genome($Chromosome,$BandeP)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique_TL $Type] set PosYMin [expr $PosY - $Taille*$Facteur] set PosYMax $PosY set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMin $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeP" "$Taille" "BandesCytologiques"] } set ExtremiteDuChromosome $PosYMin set PosY $PosYDuCentromer set LesBandesQ [lsort [set Genome($Chromosome,LesBandesQ)]] foreach BandeQ $LesBandesQ { set LesInfos [set Genome($Chromosome,$BandeQ)] set Taille [lindex $LesInfos 1] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique_TL $Type] set PosYMin $PosY set PosYMax [expr $PosY + $Taille*$Facteur] set PosYBande [expr ($PosYMin+$PosYMax)/2] set PosY $PosYMax $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$BandeQ" "$Taille" "BandesCytologiques"] } set EnAiJeVuAuMoinsUn 0 set LesNomsDuChromosome {} if {[info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} { set LesNomsDuChromosome [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] } foreach Nom $LesNomsDuChromosome { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $Fichier $Nom Cluster] set ColorFill [set ColorCluster($Cluster)] foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [expr [lindex $LInfo 10 ]/1E6] set Fin [expr [lindex $LInfo 11]/1E6] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set EnAiJeVuAuMoinsUn 1 set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set Var 0 if {$Qui != "OnlyTheBest" && $Info == ""} {set Var [expr $LargeurBoite * 1.5]} set PosYMin [expr $ExtremiteDuChromosome + $Debut*$Facteur] set PosYMax [expr $ExtremiteDuChromosome + $Fin *$Facteur] ##Les sequences du cluster 0 ou 2 ou ICBP_D ou ICBP_U seront du côté gauche if {$Cluster == 0 || $Cluster == 2 || $Cluster == "ICBP_D" || $Cluster == "ICBP_D"} { $K create oval [expr $PosXMin-$LargeurBoite-$Var] $PosYMin [expr $PosXMin-$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } else { $K create oval [expr $PosXMax+$Var] $PosYMin [expr $PosXMax+$LargeurBoite+$Var] $PosYMax -outline $ColorFill -fill $ColorFill -tags $LInfo } } } set ColorText "black" if {$EnAiJeVuAuMoinsUn} {set ColorText "Red"} #$K create text $PosXNomChromo $PosYNomChromoSup -text [NumeroDuChromosome $Chromosome] -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] $K create text $PosXNomChromo $PosYNomChromoInf -text [NumeroDuChromosome $Chromosome] -font "$PoliceChromo" -fill $ColorText -tags [list $Chromosome $FichierLocalisation "Chromosome"] } $K create line $BordX $PosYDuCentromer [expr $LargeurMax-$BordX] $PosYDuCentromer -fill black -dash {1 1} LesNomsEnStock $K $LesNoms regsub {\.canvas} $K "" w $K bind "Chromosome" <1> "ChromosomeSelectionne $K \[LesNomsEnStock $K\] $Qui" $K bind "Chromosome" <2> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Box" <1> "AfficheFicheInfo $K" set B [BoutonneLaFenetre $w "OnlyBestLoc/All"] bind $B <1> "IllustreLesChromosomes \[LesNomsEnStock $K\] OnlyTheBest" bind $B <2> "IllustreLesChromosomes \[LesNomsEnStock $K\] All " set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" set Boutons "$w.buttons" return $K } proc IllustreLesCourbes {LesListes {nParLigne 1}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set nTot [llength $LesListes] set LesCoords [CoordonneesDesPavesVerticaux $nParLigne $nTot $Hauteur $Largeur] set LesCoords [lsort -real -decreasing -index 4 $LesCoords] set K [UnCanva $Largeur [lindex [lindex $LesCoords 0] 4] $Largeur $Hauteur WithY] foreach Liste $LesListes LaCoord [lsort -integer -index 0 $LesCoords] { ScanLaListe $LaCoord n LMin HMin LMax HMax set K [PlaceLaCourbe $Liste $K $HMin $HMax $LMin $LMax] } return $K } proc IllustreLesCourbesAvecInterQuartile {LesListes {nParLigne 1}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set nTot [llength $LesListes] set LesCoords [CoordonneesDesPavesVerticaux $nParLigne $nTot $Hauteur $Largeur] set LesCoords [lsort -real -decreasing -index 4 $LesCoords] set K [UnCanva $Largeur [lindex [lindex $LesCoords 0] 4] $Largeur $Hauteur WithY] foreach Liste $LesListes LaCoord [lsort -integer -index 0 $LesCoords] { ScanLaListe $LaCoord n LMin HMin LMax HMax set K [PlaceLaCourbeAvecInterQuartile $Liste $K $HMin $HMax $LMin $LMax] } return $K } proc IllustreLesDomaines {Nom {AvecOuSansLegende AvecLegende} {JusteIPR 0}} { ###titre avec access et definition de la prot de ref set AccessDuChoisi "" set InfoSeq [InterrogeProtAndmRNAChoisis $Nom SeqChoisie] if {$InfoSeq != "" && $InfoSeq == "SeqOK"} { set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {$AccessProt != "NoProtein"} {set AccessDuChoisi $AccessProt} } else { set AccessProt [string toupper [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access]] if {$AccessProt != "" } {set AccessDuChoisi $AccessProt} } set DefProt "" if {$AccessDuChoisi != ""} { set DefProt [join [LaDefinitionDeLaProt_PageInfo [PageInfo $AccessDuChoisi protein]] " " ] set Titre "$Nom $AccessDuChoisi $DefProt" } else { set Titre "$Nom NoAccess" } Espionne "$Titre $AccessDuChoisi" set NbCarParLigne 100 set LeTitre {} while {$NbCarParLigne <= [string length $Titre]} { lappend LeTitre [string range $Titre 0 [expr $NbCarParLigne-1]] set Titre [string range $Titre $NbCarParLigne end] } if {0 < [string length $Titre]} {lappend LeTitre $Titre} set Titre [join $LeTitre "\n"] ###################################################### set LargeurFenetre [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set Bord 100 set LargeurAffichage [expr $LargeurFenetre - 2 * $Bord] if {0} { set LargeurBoite 10 set LargeurProt 20 set Ecart 25 } else { set LargeurBoite 20 set LargeurProt 30 set Ecart 40 } set File "[RepertoireDuGenome]/msf/$Nom" if {![file exists $File]} {return} DecortiqueUnMSF $File LesSequences Sequences if {[info exists Sequences($Nom)]} { set Query $Nom } elseif {[info exists Sequences(QUERY_PROTEIN)]} { set Query "QUERY_PROTEIN" } else { return } set SeqProt [string toupper [set Sequences($Query)]] regsub -all {[^A-Z]} $SeqProt "" SeqProtSansPoint set SeqTFAProt [SequenceFormatTFA $SeqProtSansPoint [string trim "$Nom $AccessDuChoisi"]] set LaSeqProt [split $SeqProt ""] set LaSeqProtSansPoint [split $SeqProtSansPoint ""] set TailleProt [llength $LaSeqProtSansPoint ] set TabColorDuType(INTERPRO) red set TabColorDuType(PFAM) blue set TabColorDuType(FEATURE) darkgreen set LaGammeDeRouge [GammeDeCouleurRouVouB R 100] set LaGammeDeVert [GammeDeCouleurRouVouB V 100] set LaGammeDeBleu [GammeDeCouleurRouVouB B 100] for {set i 0} {$i < $TailleProt} {incr i} {set TabProfil($i) 0} set Facteur [expr $LargeurAffichage * 1.0 / $TailleProt] set LesDomaines {} foreach LeDomaine [InterrogeDomaines $Nom LesDomaines] { set Type [lindex $LeDomaine 0] if {$JusteIPR && $Type != "INTERPRO"} {continue} set Domaine [lindex $LeDomaine 1] set Def [lindex $LeDomaine 2] set Debut [lindex $LeDomaine 3] set Fin [lindex $LeDomaine 4] set Id [lindex $LeDomaine 5] set Taille [expr $Fin - $Debut + 1 ] set DX [expr $Bord + $Facteur * $Debut] set FX [expr $Bord + $Facteur * $Fin ] set Seq [join [lrange $LaSeqProtSansPoint [expr $Debut-1] [expr $Fin-1]] ""] lappend LesDomaines [list $Type $Domaine $Def $Debut $Fin $Taille $Id $Seq $DX $FX] } set XMinProt [expr $Bord + $Facteur * 1 ] set XMaxProt [expr $Bord + $Facteur * $TailleProt] set YMinProt $Bord set YMaxProt [expr $YMinProt + $LargeurProt] set YDeRef [expr $YMaxProt + $Ecart] set YMax $YDeRef set LesDomainesAvecToutesLesCoordonnees {} set TypeDeRef "" set ValMaxDeMax -1e300 foreach LeDomaine [lsort -index 0 -decreasing [lsort -index 5 -real $LesDomaines]] { set Type [lindex $LeDomaine 0 ] set Domaine [lindex $LeDomaine 1 ] set Def [lindex $LeDomaine 2 ] set Debut [lindex $LeDomaine 3 ] set Fin [lindex $LeDomaine 4 ] set Id [lindex $LeDomaine 6 ] set Seq [lindex $LeDomaine 7 ] if {$TypeDeRef == "" } {set TypeDeRef $Type} if {$TypeDeRef != $Type} { for {set i 0} {$i < $TailleProt} {incr i} {set TabProfil($i) $ValMaxDeMax} } set ValMax -1e300 for {set i [expr $Debut-1]} {$i < $Fin} {incr i} { set Val [set TabProfil($i)] if {$ValMax < $Val} {set ValMax $Val} } if {$ValMaxDeMax <= $ValMax} {set ValMaxDeMax [expr $ValMax + 1]} set YMin [expr $YDeRef + $ValMax * ($LargeurBoite + $Ecart)] set YMax [expr $YMin + $LargeurBoite ] #Espionne "$TypeDeRef $Type $Domaine $Debut $Fin $Taille $YMin $YMax $ValMaxDeMax" lappend LeDomaine $YMin $YMax lappend LesDomainesAvecToutesLesCoordonnees $LeDomaine incr ValMax for {set i [expr $Debut-1]} {$i < $Fin} {incr i} {set TabProfil($i) $ValMax} set TypeDeRef $Type } set HauteurMax [expr $YMax + $Bord] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K create text [expr $LargeurFenetre/2] [expr $Bord/2] -text $Titre -font "Arial 12 bold" -tags [list $Nom Box] $K create rectangle $XMinProt $YMinProt $XMaxProt $YMaxProt -fill darkgrey -outline grey -tags [list $Nom "" "" "" "" "" "SeqTFA" $SeqTFAProt] $K create text [expr $Bord/2] [expr $YMinProt + ($YMaxProt-$YMinProt)/2] -text "1" -font "Courier 12 bold" -tags [list $Nom Box] $K create text [expr $LargeurFenetre - $Bord/2] [expr $YMinProt + ($YMaxProt-$YMinProt)/2] -text "$TailleProt" -font "Courier 12 bold" -tags [list $Nom Box] set TypeDeRef "" set YOld $YDeRef foreach LeDomaine [lsort -index 10 -real $LesDomainesAvecToutesLesCoordonnees] { set Type [lindex $LeDomaine 0 ] set Domaine [lindex $LeDomaine 1 ] set Def [lindex $LeDomaine 2 ] set Debut [lindex $LeDomaine 3 ] set Fin [lindex $LeDomaine 4 ] set Id [lindex $LeDomaine 6 ] set Seq [lindex $LeDomaine 7 ] set XMin [lindex $LeDomaine 8 ] set XMax [lindex $LeDomaine 9 ] set YMin [lindex $LeDomaine 10] set YMax [lindex $LeDomaine 11] set Color [set TabColorDuType($Type)] if {![info exists Tab($Type)]} { set Tab($Type) 1 $K create text [expr $Bord/2] [expr $YMin + ($YMax-$YMin)/2] -text $Type -fill $Color -font "Courier 11 bold" } if {$TypeDeRef == "" } {set TypeDeRef $Type} if {$TypeDeRef != $Type} { set YLine [expr $YOld + ($YMin - $YOld) / 2] $K create line $XMinProt $YLine $XMaxProt $YLine -dash {2 4} -fill $Color } set PId [expr round($Id * 100)] if {$Type == "INTERPRO"} {set Couleur [lindex $LaGammeDeRouge [expr $PId - 1]]} if {$Type == "PFAM" } {set Couleur [lindex $LaGammeDeBleu [expr $PId - 1]]} if {$Type == "FEATURE" } {set Couleur [lindex $LaGammeDeVert [expr $PId - 1]]} set SeqTFA [SequenceFormatTFA $Seq "$Nom $Type $Domaine ($PId%) from $Debut to $Fin Definition $Def"] set Texte "$Type $Domaine\n$Def\nFrom $Debut to $Fin\nIdentity with this Domain : $PId %\n\n$SeqTFA" if {$AvecOuSansLegende == "AvecLegende"} { $K create text [expr $XMin + ($XMax-$XMin)/2] [expr $YMax + $Ecart/2] -text "$Type $Domaine\n$Def" -font {courier 11 bold} } #Espionne "$TypeDeRef $Type $Domaine $Debut $Fin $Taille $YMin $YMax $ValMaxDeMax $Id" $K create rectangle $XMin $YMin $XMax $YMax -fill $Couleur -outline $Color -tags [list Domaine $Texte "" "" "" "" "SeqTFA" $SeqTFA] set TypeDeRef $Type set YOld $YMax } if {[info exists Tab]} {unset Tab} $K bind "Box" <1> "AfficheFicheInfo $K" $K bind "SeqTFA" <1> "AfficheLaSeqTFA $K Enter" $K bind "Domaine" "DevoileLaValeur $K %x %y Enter" $K bind "Domaine" "DevoileLaValeur $K %x %y Leave" return } proc IllustreLesExpression {FichierO2C2A2D2E {AvecNormalisation 0} {AvecMemeEchelleY 0} {LesNoms ""} {LesConditions ""} {LesPointsTemporels ""} {nParLigne 3}} { if {![file exists $FichierO2C2A2D2E]} {return} if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [ListeDesPABs]]} if {$LesConditions == ""} {set LesConditions [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesConditions]]} if {$LesPointsTemporels == ""} {set LesPointsTemporels [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesPointsTemporels]]} set LesCouleurs [GammeDeCouleursRVB_CHALMEL [llength $LesConditions]] if {$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} set ToutesLesCourbes {} foreach Nom $LesNoms { if {$AvecNormalisation} { set LesStats [MoyenneEcartMinMaxCumulLong [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom LesExpressions]] set ExprMoyenne [lindex $LesStats 0] set ExprET [lindex $LesStats 1] } set Def [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Definition] set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Cluster] set i 0 set LesCourbes [list "$Nom\n$Def"] if {!$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} foreach What $LesConditions { if {$What == ""} {continue} set LesPoints {} foreach When $LesPointsTemporels { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel $When Condition $What Expression] if {$Expr == ""} {continue} if {$AvecNormalisation} { set Expr [expr $Expr - $ExprMoyenne] if {$ExprET != 0} {set Expr [expr $Expr / $ExprET]} } if {$Expr < $ValYMin} {set ValYMin $Expr} if {$ValYMax < $Expr } {set ValYMax $Expr} lappend LesPoints [list $When $Expr 0] } if {$LesPoints == {}} {continue} set Couleur [lindex $LesCouleurs $i] incr i lappend LesCourbes [list $What $Couleur $LesPoints] } if {[llength $LesCourbes] <= 1} {continue} set LesCourbes [linsert $LesCourbes 1 $ValYMin] set LesCourbes [linsert $LesCourbes 2 $ValYMax] lappend ToutesLesCourbes $LesCourbes } if {$AvecMemeEchelleY} { set ToutesLesCourbes_old $ToutesLesCourbes set ToutesLesCourbes {} foreach LesCourbes $ToutesLesCourbes_old { set LesCourbes [lreplace $LesCourbes 1 1 $ValYMin] set LesCourbes [lreplace $LesCourbes 2 2 $ValYMax] lappend ToutesLesCourbes $LesCourbes } } IllustreLesCourbes $ToutesLesCourbes $nParLigne return } proc IllustreLesExpressionDesClusters {FichierO2C2A2D2E {MoyenneOuMediane ""} {AvecTousLesClones ""} {AvecMemeEchelleY 1} {LesClusters ""} {LesConditions ""} {LesPointsTemporels ""}} { if {![file exists $FichierO2C2A2D2E]} {return} if {$MoyenneOuMediane == ""} {set MoyenneOuMediane [ChoixParmi "Moyenne Mediane"]} if {$AvecTousLesClones == ""} { set AvecTousLesClones [ChoixParmi [list "AvecLesClones" "SansLesClones"]] if {$AvecTousLesClones == "" || $AvecTousLesClones == "SansLesClones"} { set AvecTousLesClones 0 } else { set AvecTousLesClones 1 } } if {$LesClusters == ""} {set LesClusters [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesClusters]]} if {$LesConditions == ""} {set LesConditions [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesConditions]]} if {$LesPointsTemporels == ""} {set LesPointsTemporels [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesPointsTemporels]]} set nClusters [llength $LesClusters ] set nParLigne [llength $LesConditions] set NbCouleursDExpr 100 set LesCouleursDExpression [GammeDeCouleursRNV_CHALMEL $NbCouleursDExpr] set LesCouleurs [GammeDeCouleursRVB_CHALMEL $nParLigne ] set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] if {!$AvecTousLesClones} { set LargeurGraph [expr $Largeur * 1.0 / $nParLigne ] set LargeurMax $Largeur } else { set LargeurGraph [expr $Largeur * 1.0 / ($nParLigne + 1)] set LargeurMax [expr $Largeur + $LargeurGraph] } set HauteurGraph $LargeurGraph set NbPointsTemporels [llength $LesPointsTemporels] ### +2 car bord de gauche et de droite##### set LargeurCarre [expr $LargeurGraph * 1.0 / ($NbPointsTemporels + 2)] set HauteurCarre 10 if {$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} set HauteurMax 0 foreach Cluster $LesClusters { set nBox [llength [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms]] set HauteurMax [expr $HauteurMax + $HauteurGraph] if {$AvecTousLesClones} {set HauteurMax [expr $HauteurMax + $HauteurCarre * $nBox]} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] { set LesExpressions {} set Tab($Nom,ExprMin) 1e200 set Tab($Nom,ExprMax) -1e200 foreach What $LesConditions { foreach When $LesPointsTemporels { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel $When Condition $What Expression] if {$Expr == ""} {continue} if {$Expr < [set Tab($Nom,ExprMin)]} {set Tab($Nom,ExprMin) $Expr} if {$Expr > [set Tab($Nom,ExprMax)]} {set Tab($Nom,ExprMax) $Expr} lappend LesExpressions $Expr } } if {$LesExpressions == {}} {continue} set LesStats [MoyenneEcartMinMaxCumulLong $LesExpressions] set ExprMoyenne [lindex $LesStats 0] set ExprET [lindex $LesStats 1] foreach What $LesConditions { foreach When $LesPointsTemporels { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel $When Condition $What Expression] if {$Expr == ""} {continue} set Expr [expr $Expr - $ExprMoyenne] if {$ExprET != 0} {set Expr [expr $Expr / $ExprET]} if {![info exists Tab($Cluster,$What,$When,LesExpr)]} {set Tab($Cluster,$What,$When,LesExpr) {}} lappend Tab($Cluster,$What,$When,LesExpr) $Expr } } } foreach What $LesConditions Couleur $LesCouleurs { if {$What == ""} {continue} set LesPointsMoyens {} if {!$AvecMemeEchelleY} {set ValYMin 1e200;set ValYMax -1e200} foreach When $LesPointsTemporels { if {![info exists Tab($Cluster,$What,$When,LesExpr)]} {continue} if {$MoyenneOuMediane == "Moyenne"} { set LesStats [MoyenneEcartMinMaxCumulLong [set Tab($Cluster,$What,$When,LesExpr)]] set Moyenne [lindex $LesStats 0] set ET [lindex $LesStats 1] if {[expr $Moyenne - $ET] < $ValYMin } {set ValYMin [expr $Moyenne - $ET]} if {$ValYMax < [expr $Moyenne + $ET]} {set ValYMax [expr $Moyenne + $ET]} lappend LesPointsMoyens [list $When $Moyenne $ET] } else { set LesStats [MedianeInterQuartileMinInterQuartileMaxExtremeMinExtremeMax [set Tab($Cluster,$What,$When,LesExpr)]] set Mediane [lindex $LesStats 0] set QuartMin [lindex $LesStats 1] set QuartMax [lindex $LesStats 2] set ExtrMin [lindex $LesStats 3] set ExtrMax [lindex $LesStats 4] if {$ExtrMin < $ValYMin} {set ValYMin $ExtrMin} if {$ValYMax < $ExtrMax} {set ValYMax $ExtrMax} lappend LesPointsMoyens [list $When $Mediane $QuartMin $QuartMax $ExtrMin $ExtrMax] } } Espionne "Cluster $Cluster NbSeq $nBox Condition $What" set Tab(Cluster,$Cluster,Condition,$What,LaCourbe) [list "Cluster $Cluster NbSeq $nBox Condition $What" $ValYMin $ValYMax [list $What $Couleur $LesPointsMoyens]] } } if {$AvecMemeEchelleY} { foreach Cluster $LesClusters { foreach What $LesConditions { if {![info exists Tab(Cluster,$Cluster,Condition,$What,LaCourbe)]} {continue} set LaCourbe [set Tab(Cluster,$Cluster,Condition,$What,LaCourbe)] set LaCourbe [lreplace $LaCourbe 1 1 $ValYMin] set LaCourbe [lreplace $LaCourbe 2 2 $ValYMax] set Tab(Cluster,$Cluster,Condition,$What,LaCourbe) $LaCourbe } } } set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur WithY] set YDeRef 0 foreach Cluster $LesClusters { set XDeRef 0 set HMin $YDeRef set HMax [expr $HMin + $HauteurGraph] set YDeRef $HMax foreach What $LesConditions { if {![info exists Tab(Cluster,$Cluster,Condition,$What,LaCourbe)]} { set XDeRef [expr $XDeRef + $LargeurGraph] continue } set LaCourbe [set Tab(Cluster,$Cluster,Condition,$What,LaCourbe)] set LMin $XDeRef set LMax [expr $LMin + $LargeurGraph] set XDeRef $LMax if {$MoyenneOuMediane == "Moyenne"} { set K [PlaceLaCourbe $LaCourbe $K $HMin $HMax $LMin $LMax] } else { set K [PlaceLaCourbeAvecInterQuartile $LaCourbe $K $HMin $HMax $LMin $LMax] } } if {!$AvecTousLesClones} {continue} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] { if {![info exists Tab($Nom,ExprMin)]} {continue} set ExprMin [set Tab($Nom,ExprMin)] set ExprMax [set Tab($Nom,ExprMax)] if {$ExprMax <= $ExprMin} { set FactExpr 0 } else { set FactExpr [expr ($NbCouleursDExpr - 1) * 1.0 / ($ExprMax - $ExprMin)] } set HMin $YDeRef set HMax [expr $HMin + $HauteurCarre] set XDeRef 0 foreach What $LesConditions { set LMin [expr $XDeRef + $LargeurCarre] set XDeRef [expr $XDeRef + $LargeurGraph] foreach When $LesPointsTemporels { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom PointTemporel $When Condition $What Expression] if {$Expr == ""} { set LMin [expr $LMin + $LargeurCarre] continue } set LMax [expr $LMin + $LargeurCarre] if {![info exists TabTmp($Cluster,$What,$When)]} { set TabTmp($Cluster,$What,$When) 1 $K create text [expr ($LMax - $LMin) * 1.0 / 2 + $LMin] $HMin -text $When -anchor s -tags [list "$Nom" "Box"] } set i [expr round(($Expr - $ExprMin) * $FactExpr)] $K create rectangle $LMin $HMin $LMax $HMax -fill [lindex $LesCouleursDExpression $i] -tags [list "$Nom" "Box"] set LMin $LMax } } set Texte "$Cluster $Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E $Nom Definition]" $K create text $XDeRef $YDeRef -text $Texte -anchor nw -tags [list "$Nom" "Box"] set YDeRef $HMax } } $K bind "Box" <1> "AfficheFicheInfo $K" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return } proc IllustreLesHistogrammes {LesListes {nParLigne 1} {VerticalOuHorizontal Vertical}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set nTot [llength $LesListes] set LesCoords [CoordonneesDesPavesVerticaux $nParLigne $nTot $Hauteur $Largeur] set LesCoords [lsort -real -decreasing -index 4 $LesCoords] set K [UnCanva $Largeur [lindex [lindex $LesCoords 0] 4] $Largeur $Hauteur WithY] foreach Liste $LesListes LaCoord [lsort -integer -index 0 $LesCoords] { ScanLaListe $LaCoord n LMin HMin LMax HMax set K [PlaceLHistogramme $Liste $K $HMin $HMax $LMin $LMax $VerticalOuHorizontal] } return $K } proc IllustreLesOrgasDesARPs {} { set LesCategories [InterrogeLesInfosDesARPs LesCategories] foreach Cat $LesCategories { FaireLire "Categorie $Cat" set LesAccess [InterrogeLesInfosDesARPs $Cat LesAccess] IllustreLesAccessSurLArbreTaxonomique $LesAccess } } proc IllustreLesPathwayDeLAccess {Access} { set LesPathway {} set LesRequetes {} foreach LaReq [Access2Kegg $Access] { Espionne $LaReq set Quoi [lindex $LaReq 0] set Qui [lindex $LaReq 1] lappend LesRequetes $Qui if {$Quoi != "Pathway"} {continue} lappend LesPathway $Qui } set LesK {} foreach Pathway $LesPathway { lappend LesK [IllustreLePathway $Pathway "" $LesRequetes] } return $LesK } proc IllustreLesPathwayDeLAccess_AEffacer {Access} { set LesPathway {} set LesRequetes {} foreach LaReq [Access2Kegg $Access] { Espionne $LaReq set Quoi [lindex $LaReq 0] set Qui [lindex $LaReq 1] lappend LesRequetes $Qui if {$Quoi != "Pathway"} {continue} lappend LesPathway $Qui } foreach Pathway $LesPathway { IllustreLePathway $Pathway "" $LesRequetes } return } proc IllustreLesPathwayDeLaBoite {Nom} { set LesRequetes [InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC] set LesK {} foreach Pathway [InterrogeMesKEGG $Nom LesPathway ] { lappend LesK [IllustreLePathway $Pathway "" $LesRequetes] } return $LesK } proc IllustreLesPathwayDeLaBoiteEtCreeLesJpg {Nom {CreateJpg ""}} { set Rep "[RepertoireDuGenome]/jpg_of_pathways" if {! [file exists $Rep]} {file mkdir $Rep} set CreateJpg [string equal -nocase $CreateJpg "CreateJpg"] if {$CreateJpg} { package require Img } set LesRequetes [InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC] foreach Pathway [InterrogeMesKEGG $Nom LesPathway ] { set FichierImage "$Rep/${Nom}_$Pathway.jpg" set K [IllustreLePathway $Pathway "" $LesRequetes] if {$CreateJpg} { regsub "\.canvas$" $K "" w wm iconify . focus $w update idletasks CanvaEnJpg $K $FichierImage after 5000 destroy $w } } return } proc IllustreLesPathwayDeLaBoite_AEffacer {Nom} { set LesRequetes [InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC] foreach Pathway [InterrogeMesKEGG $Nom LesPathway ] { #IllustreLePathway $Pathway "" $LesRequetes set K [IllustreLePathway $Pathway "" $LesRequetes] } return $K } proc IllustreLesPathwayLies {K} { regsub ".canvas" $K ".message" M catch {destroy $M} set Id [$K find withtag current] set MesTags [$K gettags $Id] set Pathway [lindex $MesTags 2] set Organisme [lindex $MesTags 3] set LesConcernes [lindex $MesTags 4] set LesElementsParticuliers [lindex $MesTags 5] if {$LesConcernes == {}} {return} set FichierConf [FichierPathway $Pathway $Organisme "conf"] set FichierConfMap [FichierPathway $Pathway "" "conf"] if {![file exists $FichierConf] && ![file exists $FichierConfMap]} {return} lappend LesElementsParticuliers $Pathway foreach LeConcerne $LesConcernes { set Qui [lindex $LeConcerne 1] lappend LesElementsParticuliers $Qui set Quoi [lindex $LeConcerne 0] if {$Quoi == "Kegg"} { foreach Lien [InterrogeKEGG Kegg $Qui LesLiens] { lappend LesElementsParticuliers $Lien } } } set LesElementsParticuliers [lsort -unique $LesElementsParticuliers] EspionneL $LesConcernes Espionne $LesElementsParticuliers foreach LeConcerne $LesConcernes { set Quoi [lindex $LeConcerne 0] if {$Quoi == ""} {continue} set Qui [lindex $LeConcerne 1] set OrgaC [lindex $LeConcerne 2] set OrgaL [InterrogeGenomeKEGG OrgaCourt $OrgaC Organisme] if {$OrgaL == ""} {set OrgaL $Organisme} if {$OrgaL == "map"} {set OrgaL ""} if {$Quoi == "Pathway"} { if {$Qui == $Pathway || [info exists TabTmp($Qui)]} {continue} set TabTmp($Qui) 1 IllustreLePathway $Qui $OrgaL $LesElementsParticuliers continue } if {$Quoi == "Compound"} { foreach NewPathway [InterrogeECCpdRn Element $Qui LesPathway] { if {$NewPathway == $Pathway || [info exists TabTmp($NewPathway)]} {continue} set TabTmp($NewPathway) 1 IllustreLePathway $NewPathway $OrgaL $LesElementsParticuliers } continue } if {$Quoi == "Kegg"} { foreach NewPathway [InterrogeKEGG Kegg $Qui LesPathway] { if {$NewPathway == $Pathway || [info exists TabTmp($NewPathway)]} {continue} set TabTmp($NewPathway) 1 IllustreLePathway $NewPathway $OrgaL $LesElementsParticuliers } foreach Lien [InterrogeKEGG Kegg $Qui LesLiens] { foreach NewPathway [InterrogeECCpdRn Element $Lien LesPathway] { if {$NewPathway == $Pathway || [info exists TabTmp($NewPathway)]} {continue} set TabTmp($NewPathway) 1 IllustreLePathway $NewPathway $OrgaL $LesElementsParticuliers } continue } } if {$Quoi == "EC"} { foreach NewPathway [InterrogeECCpdRn Element $Qui LesPathway] { if {$NewPathway == $Pathway || [info exists TabTmp($NewPathway)]} {continue} set TabTmp($NewPathway) 1 IllustreLePathway $NewPathway $OrgaL $LesElementsParticuliers } continue } } if {[info exists TabTmp]} {unset TabTmp} return } proc IllustreLesPrimers {{PAB ""}} { Wup "Illustre une sortie de design de primer de PCR" #1/12/2003 if {$PAB==""} {return "Correct syntax is IllustreUneSequence PAB"} #Attention il faut une query, sinon pas de taille .... set Repnuctfa "[RepertoireDuGenome]/nuctfa" set FichierQuery $PAB if {[regexp {/} $PAB]} {set PAB [file tail $PAB]} if {[file exists $FichierQuery]} { set FichierQuery $FichierQuery } elseif {[file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } else {Espionne "No Input File for the Query ($PAB)";return ""} set Police "Courier 12" set Police2 {-family "arial" -size 12 -weight bold} set CouleurOutline "black" set LargeurMax [expr [winfo screenwidth .] - 200] set HauteurMax [expr [winfo screenheight .] * 1/2] set LargeurFenetre [expr [winfo screenwidth .] - 200] set HauteurFenetre [expr [winfo screenheight .] * 1/2] set XMilieu [expr $LargeurMax/2] set BordureX 50.0 set BordureY 50.0 set Intervalle 15.0 set EpaisseurBoite 15.0 #Position du Graph content set YDebutGraph [expr 0 + $BordureY] set YFinGraph [expr $YDebutGraph + 100] #Position de la query set XDebutQuery [expr 0 + 2 * $BordureX] set YDebutQuery [expr $YFinGraph + 10] set XFinQuery [expr $LargeurMax - $BordureX] set YFinQuery [expr $YDebutQuery + $EpaisseurBoite] #Besoin de la taille de la query pour conversion et affichage set AccessQuery [AccessDuTFADumRNA $FichierQuery] set SeqQuery [QueLaSequenceDuFichierTFA $FichierQuery] if {$SeqQuery==""} {Espionne "$FichierQuery no sequence available";return ""} set TailleQueryNt [string length $SeqQuery] #Rapport du nombre de pixel pour un nt set OneNtPixel [expr ($XFinQuery-$XDebutQuery)/($TailleQueryNt-1)] #Attention on commence au premier nt #Debut des Oligos set YDebutDeOligo [expr $YFinQuery + $Intervalle] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "" "Primer $PAB"] $K configure -background "grey" #Rectangle de masque pour les graphes $K create rectangle [expr $XDebutQuery-40] [expr $YDebutGraph-4] [expr $XFinQuery+5] [expr $YFinGraph+4] -fill "gray97" -outline "gray97" -tags [list "" "Masque"] #Affiche la query $K create rectangle $XDebutQuery $YDebutQuery $XFinQuery $YFinQuery -outline "$CouleurOutline" -fill "red" -tags [list "" "Query"] $K create text [expr $XDebutQuery-3.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "1" -font $Police2 -anchor "e" $K create text [expr $XFinQuery+3.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "$TailleQueryNt ([expr $TailleQueryNt/3])" -font $Police2 -anchor "w" $K create text $XMilieu [expr 1*$BordureY/3] -text "Primers from $PAB" -font $Police2 -anchor "center" -justify "center" #Affiche la petite aide $K create oval [expr $XDebutQuery-30] [expr $YDebutGraph-30] [expr $XDebutQuery-10] [expr $YDebutGraph-10] -fill "green" -outline "white" $K create text [expr $XDebutQuery-20] [expr $YDebutGraph-20] -text "?" -tags [list "" "[AfficheHelpDuPrimer]" "Affichable"] -anchor "center" #Affichage du Tm content set TmResults "" set TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] if {$TmResults !=""} { AfficheLeSpectreTmDUneListe $K $TmResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel "orange" "Tm" } #Affichage du GC content set GCResults "" set GCResults [CreeLesFichiersSpectreDesGC $SeqQuery SpectreGCXY 30] if {$GCResults !=""} { AfficheLeSpectreGCDUneListe $K $GCResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel } #Construction des boites des Primers #################################### set LesPrimerSeqs "" if {0} { array set LesPPCRsADessiner [LesLignesDuFichier "[RepertoireDuGenome]/fiches/lesppcrsadessiner"] foreach Trio [set LesPPCRsADessiner($PAB)] { scan $Trio "%s %d %d %s %d %d %s %d %d" Frag dF fF A dA fA B dB fB lappend LesPrimerSeqs [list $Frag $dF $fF] lappend LesPrimerSeqs [list $A $dA $fA] lappend LesPrimerSeqs [list $B $dB $fB] } } else { set LesPrimerSeqs [InterrogeInfoDePrimer $PAB] } set NbPrimer 0 set DejaFait 0 set NomDuChef "" set YFinDeOligo [expr $YDebutDeOligo + $EpaisseurBoite] foreach PrimerSeq $LesPrimerSeqs { incr NbPrimer set NomOligo [lindex $PrimerSeq 0] set LaSequence [Oli $NomOligo SeqSubject] set XDebutDeOligoNt [lindex $PrimerSeq 1] set XFinDeOligoNt [lindex $PrimerSeq 2] set TailleOligo [expr $XFinDeOligoNt - $XDebutDeOligoNt + 1] set TailleSignal "N/A" set TaillePrimer "N/A" set GC "" set Tm "" set DirOligo "toto" #Pour le dessin des boites et repecter les tailles if {$NbPrimer=="1"} { #Une boite plus epaisse pour la sequence set DebutFrag $XDebutDeOligoNt set FinFrag $XFinDeOligoNt set LaSequence [string range $SeqQuery [expr $XDebutDeOligoNt-1] [expr $XFinDeOligoNt-1]] set NomDuChef $NomOligo } else { if {$DejaFait == "0"} { set YDebutDeOligo [expr $YDebutDeOligo +2] set YFinDeOligo [expr $YFinDeOligo -2] set DejaFait 1 } } #Nom different pour les primers if {$NbPrimer=="2" || $NbPrimer=="3"} { append NomOligo "_${NomDuChef}" set TaillePrimer [string length $LaSequence] set TailleSignal [expr $TailleOligo - $TaillePrimer] } if {$LaSequence!=""} { if {$TailleOligo == ""} {set TailleOligo [string length $LaSequence]} if {$TailleOligo>$TailleQueryNt} {set TailleOligo $TailleQueryNt} if { $GC == ""} { if {$NbPrimer=="2" || $NbPrimer=="3"} { set GC [format "%.2f" [expr (([NombreDeBaseDe $LaSequence "G|C"])/($TaillePrimer*1.0))*100.0]] } else { set GC [format "%.2f" [expr (([NombreDeBaseDe $LaSequence "G|C"])/($TailleOligo*1.0))*100.0]] } } if {$Tm == ""} { set TmWallace [CalculTmDeLaSeq $LaSequence "" "" Wallace] set TmNN [CalculTmDeLaSeq $LaSequence "" "" NearestNeighbor] set TmDNADNA [CalculTmDeLaSeq $LaSequence "" "" DNADNA] } } set CouleurBoite [CouleurDuPrimer $NbPrimer] set Texte [format "%-11s%-10s" "Id-Primer:" "$NomOligo"] append Texte [format "\n%-11s" "Length:"] append Texte [format "\n%-11s%-3s %5s" "-Signals" "$TailleSignal" "nt(s)"] append Texte [format "\n%-11s%-3s %5s" "-Primer" "$TaillePrimer" "nt(s)"] append Texte [format "\n%-11s%-3s %5s" "-Total" "$TailleOligo" "nt(s)"] append Texte [format "\n%-11s%3.2f %1s" "GC:" "$GC" "%"] append Texte [format "\n%-11s" "Tm:"] append Texte [format "\n%-11s%3.2f %5s" "-Wallace" "$TmWallace" "degree(s)"] append Texte [format "\n%-11s%3.2f %5s" "-NN" "$TmNN" "degree(s)"] append Texte [format "\n%-11s%3.2f %5s" "-DNA-DNA" "$TmDNADNA" "degree(s)"] append Texte [format "\n%-11s%3d %5s" "Begin:" "$XDebutDeOligoNt" "/ $TailleQueryNt"] append Texte [format "\n%-11s%3d %5s" "End:" "$XFinDeOligoNt" "/ $TailleQueryNt"] #Calcul positions de l oligo sur la query set XDebutDeOligo [expr $XDebutQuery + $OneNtPixel * $XDebutDeOligoNt - $OneNtPixel] set XFinDeOligo [expr $XDebutDeOligo + $OneNtPixel * $TailleOligo - $OneNtPixel] #On dessine la boite de l oligo $K create rectangle $XDebutDeOligo $YDebutDeOligo $XFinDeOligo $YFinDeOligo -outline "white" -fill "$CouleurBoite" -tags [list "" $Texte [expr (($XDebutDeOligoNt-1)/3)+1] [expr $XFinDeOligoNt/3] $NomOligo $DirOligo Affichable Positionner Boite] ##-tags [list "" $Texte $XDebutDeOligoNt $XFinDeOligoNt $NomOligo $DirOligo Affichable Positionner Boite] if {$NbPrimer=="3"} { set NbPrimer 0 set DejaFait 0 #On ajoute de l espace pour la deuxieme ligne set YDebutDeOligo [expr $YFinDeOligo + $Intervalle] set YFinDeOligo [expr $YDebutDeOligo + $EpaisseurBoite] } } PasDeCadre $K $K configure -height $YDebutDeOligo #Pour accorder la scrollbar au dernier oligo affiche $K configure -scrollregion [list 0 0 $LargeurMax $YDebutDeOligo] $K bind "Query" <1> "AfficheVariable \[LesInfosDeBaseDeMaSequence $SeqQuery \[list AvecSeqFormate AvecTaille AvecStatNuc AvecTm\]\]" $K bind "Query" <2> "AfficheFetch $AccessQuery OnVeutNature" $K bind "Query" <3> "AfficheLaQuery $K $FichierQuery" $K bind "Affichable" "AfficheInfoBulle $K %x %y Enter" $K bind "Affichable" "AfficheInfoBulle $K %x %y Leave" $K bind "Positionner" <1> "AffichePositionOligo $K %x %y Show" $K bind "Positionner" <2> "ShowPrimer $K $PAB" $K bind "Positionner" <3> "AfficheLaSequenceDeLOligo $K $PAB" $K bind "Positionner" "SelectionneOligo $K" $K bind "Positionner" "SelectionneOligoCroisee $K" regsub ".canvas$" $K "" F set B [BoutonneLaFenetre $F "Positions Show / Hide\nHelp Main / Color\nChange Acc Separator"] bind $B <1> "AffichePositionOligoPourTous $K %x %y Show" bind $B <2> "EffacePositionOligoPourTous $K %x %y" bind $B "AfficheHelpDuPrimer DuBouton" bind $B "SignificationDesCouleursDuPrimer" bind $B "ChangeDebutAccessDeDir" set I [BoutonneLaFenetre $F "Graph Panel\nSearch / Clear"] bind $I <1> "GraphPanel $K" bind $I "TrouveDansLesInfos $K" bind $I "DeselectionneLesTrouves $K" bind $K "ViseurDeSeq $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YDebutDeOligo $OneNtPixel" bind $K "ViseurDeSeq $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YDebutDeOligo $OneNtPixel" return "" } proc IllustreLesTaxonsDesARPs {} { Wup "Permet de Relire les access et les TaxId des differentes categories d ARP" Wup "Reunit les resultats dans un tableau delimite par des tabulations" set FichierSave "[RepertoireDuGenome]/BilanOrganisme" #Recuperation des categories (par ex: ----LesARP1s----) set LesCategories [InterrogeLesInfosDesARPs LesCategories] set TousLesTaxons "" #Recupeartion des organismes des categories foreach Cat $LesCategories { if {[regexp "Actin" $Cat]} {continue} set LesTaxons "" set LesTaxons [InterrogeLesInfosDesARPs $Cat LesTaxons] foreach T $LesTaxons { set Tab($Cat,$T) 1 lappend TousLesTaxons $T } } set TousLesTaxons [lsort -unique $TousLesTaxons] #Espionne "LesTaxonsTotal: [llength $TousLesTaxons] -- $TousLesTaxons" #Charge les correspondances entre le TaxId et le nom scientifique de l organisme set MesTaxons [join $TousLesTaxons " "] LesOrgasDeMesTaxID "Charge" "$MesTaxons" #Prepare l entete avec les noms scientifiques des organismes set Entete "LesCategories" foreach Tax $TousLesTaxons { set Name [LesOrgasDeMesTaxID $Tax Name] if {$Name==""} {set Name "$Tax not found"} lappend Entete $Name } #Espionne "[join $Entete "\t"]" AppendAuFichier $FichierSave "[join $Entete "\t"]" foreach Cat $LesCategories { if {[regexp "Actin" $Cat]} {continue} set Result "" foreach Taxon $TousLesTaxons { if {[info exists Tab($Cat,$Taxon)]} { lappend Result "X" } else { lappend Result "O" } } #Espionne "[join [concat $Cat [join $Result ""]] "\t"]" AppendAuFichier $FichierSave "[join [concat $Cat $Result] "\t"]" } return "" } proc IllustreLesToilesDAraignee {LesListes {nParLigne 1} {AvecTitre 1} {AvecLegende 1} {AvecVal 1} {AvecValEchelle 1} {AvecLigne 1}} { set Largeur [expr [winfo screenwidth .] - 200] set Hauteur [expr [winfo screenheight .] - 300] set nTot [llength $LesListes] set LesCoords [CoordonneesDesPavesVerticaux $nParLigne $nTot $Hauteur $Largeur] set LesCoords [lsort -real -decreasing -index 4 $LesCoords] set K [UnCanva $Largeur [lindex [lindex $LesCoords 0] 4] $Largeur $Hauteur WithY] foreach Liste $LesListes LaCoord [lsort -integer -index 0 $LesCoords] { ScanLaListe $LaCoord n LMin HMin LMax HMax PlaceLaToileDAraignee [lrange $Liste 1 end] $K $HMin $HMax $LMin $LMax [lindex $Liste 0] $AvecTitre $AvecLegende $AvecVal $AvecValEchelle $AvecLigne } regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "Avec / Sans Titre\nAvec / Sans Legende\nAvec / Sans Ligne"] bind $B <1> "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne 1 $AvecLegende $AvecVal $AvecValEchelle $AvecLigne" bind $B <2> "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne 0 $AvecLegende $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre 1 $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre 0 $AvecVal $AvecValEchelle $AvecLigne" bind $B "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende $AvecVal $AvecValEchelle 1" bind $B "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende $AvecVal $AvecValEchelle 0" set C [BoutonneLaFenetre $w "Avec / Sans Val\nAvec / Sans ValEchelle"] bind $C <1> "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende 1 $AvecValEchelle $AvecLigne" bind $C <2> "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende 0 $AvecValEchelle $AvecLigne" bind $C "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende $AvecVal 1 $AvecLigne" bind $C "IllustreLesToilesDAraignee \{$LesListes\} $nParLigne $AvecTitre $AvecLegende $AvecVal 0 $AvecLigne" return $K } proc IllustreOligo {{PAB ""} {Directories ""}} { Wup "Illustre une sortie de design d Oligo " #Version pour visualiser plusieurs oligos de plusieurs banques en simultanee. #Refonte pour la visualisation de plusieurs oligos sur la meme ligne. #Addon GC content, Help, Color, Color Help, Id content, Nb Seq, Tm content. #Selection des oligos, sauvegarde et affichage des selectionnes et des X-selectionnes #Modif algo de visualisation avec InterrogeInfoOligo #Modif pour vider la memoire et gerer plusieurs repertoires simultanement #Modif pour chercher dans les infos de l oligo #Modif pour l absence des infos et valeurs par defaut #Modif pour ajout des coordonnees du CDS et de la carte exonique #Modif pour detruire toutes les infos en memoire #15/02/2004 set OnAPeutEtreExonicMap 0 set OnADejaFaitLesSpike 0 if {$PAB==""} {return "Correct syntax is IllustreOligo PAB ProbesDir\nfor ex: IllustreOligo ACT0001\n"} set RepOligo "[RepertoireDuGenome]/Probes" if {$Directories==""} { if {[file exists $RepOligo]} { set LesDirs "" set LaListe "" foreach File [glob -nocomplain -directory $RepOligo -types d "*"] { lappend LaListe [file tail $File] } set LaListe [EntreDeux [lsort $LaListe]] if {$LaListe==""} {AjouteAuLog "No Directories found";return ""} foreach Dir $LaListe { lappend LesDirs "$RepOligo/$Dir" } } else {AjouteAuLog "No Directories specified";return ""} } else {set LesDirs $Directories} #Attention il faut une query, sinon pas de taille .... set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set Repnuctfa "[RepertoireDuGenome]/nuctfa" set RepRefSeq "[RepertoireDuGenome]/Probes/RefSeq_TFA" set FichierQuery $PAB if {[regexp {/} $PAB]} {set PAB [file tail $PAB]} if {[file exists $FichierQuery]} { set FichierQuery $FichierQuery } elseif { [file exists "$RepmRNA/$PAB"]} { set FichierQuery "$RepmRNA/$PAB" set OnAPeutEtreExonicMap 1 } elseif { [file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } elseif { [regexp {^NM[0-9]{4,}} $PAB]} { set FichierQuery "$RepRefSeq/$PAB" } else {Espionne "No Input File for the Query ($PAB)";return ""} if {! [file exists "$FichierQuery"]} {Espionne "$FichierQuery does not exists ($PAB)";return ""} if {[regexp {\.masked$} $PAB]} {regsub -all {\.masked$} $PAB "" PAB} #Pour le design particulier de la banque RefSeq totale if {[regexp {^NM[0-9]{4,}} $PAB]} { set Dir "[RepertoireDuGenome]/Probes/RefSeq_Design" if {[regexp "RefSeq_Design" $LesDirs]} { set NMDIR [LeRepertoireDeRefSeq $PAB] regsub -all "RefSeq_Design" $LesDirs "RefSeq_Design/$NMDIR" LesDirs } } set Police "Courier 12" set Police2 {-family "arial" -size 12 -weight bold} set CouleurOutline "black" set LargeurMax [expr [winfo screenwidth .] - 200] set HauteurMax [expr [winfo screenheight .] * 1/2] set LargeurFenetre [expr [winfo screenwidth .] - 200] set HauteurFenetre [expr [winfo screenheight .] * 1/2] set XMilieu [expr $LargeurMax/2] set BordureX 50.0 set BordureY 50.0 set Intervalle 10.0 set EpaisseurBoite 15.0 #Position du Graph content set YDebutGraph [expr 0 + $BordureY] set YFinGraph [expr $YDebutGraph + 100] #Position de la query set XDebutQuery [expr 0 + $BordureX] #set YDebutQuery [expr $YFinGraph + 10] set YDebutQuery [expr $YFinGraph + 20] set XFinQuery [expr $LargeurMax - $BordureX] set YFinQuery [expr $YDebutQuery + $EpaisseurBoite] #Besoin de la taille de la query pour conversion et affichage set AccessQuery [AccessDuTFADumRNA $FichierQuery] set SeqQuery [QueLaSequenceDuFichierTFA $FichierQuery] if {$SeqQuery==""} {Espionne "$FichierQuery no sequence available";return ""} set TailleQueryNt [string length $SeqQuery] #Rapport du nombre de pixel pour un nt set OneNtPixel [expr ($XFinQuery-$XDebutQuery)/($TailleQueryNt-1)] #Attention on commence au premier nt #Debut des Oligos set YDebutDeOligo [expr $YFinQuery + $Intervalle] set K [UnCanvaDe $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "Illustre Oligo Design $PAB"] #set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "" "Illustre Oligo Design $PAB"] $K configure -background "grey" #On modifie le comportement lors de la destruction de la fenetre principale #Ceci pour tuer toutes les autres fenetres crees set w [winfo toplevel $K] wm iconify $w wm protocol $w WM_DELETE_WINDOW "DetruitLesInfosDe $K;after 10 destroy $w" #Rectangle de masque pour les graphes $K create rectangle [expr $XDebutQuery-40] [expr $YDebutGraph-4] [expr $XFinQuery+5] [expr $YFinGraph+4] -fill "gray97" -outline "gray97" -tags [list "" "Masque" "Entete"] #Affiche la query $K create rectangle $XDebutQuery $YDebutQuery $XFinQuery $YFinQuery -outline "$CouleurOutline" -fill "red" -tags [list "" "Query" "Entete"] $K create text [expr $XDebutQuery-3.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "1" -tags [list "" "Entete"] -font $Police2 -anchor "e" $K create text [expr $XFinQuery+3.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "$TailleQueryNt" -tags [list "" "Entete"] -font $Police2 -anchor "w" $K create text $XMilieu [expr 1*$BordureY/3] -text "Design from $PAB" -tags [list "" "Entete"] -font $Police2 -anchor "center" -justify "center" #Coordonnees du CDS #set CDS [LesCoordonneesDuCDSDumRNA $AccessQuery] set CDS "" if {$CDS != ""} { set DCDS [expr $XDebutQuery + $OneNtPixel * [lindex $CDS 0] - $OneNtPixel] set FCDS [expr $XDebutQuery + $OneNtPixel * [lindex $CDS 1] - $OneNtPixel] $K create line $DCDS [expr $YDebutQuery-10] $DCDS $YFinQuery -width "3" -fill "black" -tags [list "" "CDS\nBegin [lindex $CDS 0]" "Affichable" "Entete"] $K create line $FCDS [expr $YDebutQuery-10] $FCDS $YFinQuery -width "3" -fill "black" -tags [list "" "CDS\nEnd [lindex $CDS 1]" "Affichable" "Entete"] $K create text [expr $FCDS - (($FCDS-$DCDS)/2)] [expr $YDebutQuery-7] -text "CDS" -tags [list "" "Entete"] -anchor "center" -font "$Police2" } #Carte exonique #####WARNING set OnAPeutEtreExonicMap 1 set OnAPeutEtreExonicMap 0 if {$OnAPeutEtreExonicMap} { set RepExonicMap "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_exonicmap" if {[file exists "$RepExonicMap/$PAB"]} { set LesCoordonnees [LesCoordonneesExonicMap "$RepExonicMap/$PAB"] set i 0 foreach DF $LesCoordonnees { incr i set DQ [expr $XDebutQuery + $OneNtPixel * [lindex $DF 0] - $OneNtPixel] set FQ [expr $XDebutQuery + $OneNtPixel * [lindex $DF 1] - $OneNtPixel] $K create rectangle $DQ [expr $YDebutQuery +5] $FQ [expr $YFinQuery -5] -fill yellow -tags [list "" "Exon $i\nD [lindex $DF 0] F [lindex $DF 1]" "Affichable" "Entete"] } } } #Affiche la petite aide $K create oval [expr $XDebutQuery-30] [expr $YDebutGraph-30] [expr $XDebutQuery-10] [expr $YDebutGraph-10] -fill "green" -tags [list "" "Entete"] -outline "white" $K create text [expr $XDebutQuery-20] [expr $YDebutGraph-20] -text "?" -tags [list "" "[AfficheHelp]" "Affichable" "Entete"] -anchor "center" #Affichage du Tm content #On recupere la methode de Tm par defaut choisie et on la remet apres set TmDefault [LesParametresDuDesign TmMethod "LaValeurMerci"] LesParametresDuDesign TmMethod "NearestNeighbor" "Positionne" set TmResults [PosEtTmDeLaRegion $SeqQuery $TailleQueryNt] if {$TmResults !=""} { AfficheLeSpectreTmDUneListe $K $TmResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel "orange" "TmNN" } LesParametresDuDesign TmMethod $TmDefault "Positionne" #Affichage du GC content set GCResults "" set GCResults [PosEtGCDeLaRegion $SeqQuery $TailleQueryNt] if {$GCResults !=""} { AfficheLeSpectreGCDUneListe $K $GCResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel } #Dessine les boites des differentes sources ########################################### set IdDuGraph 0 set LesFichiersBlast "" set LesLogs "" set LesFichiersOligo "" foreach DirOligo $LesDirs { set DB [file tail $DirOligo] incr IdDuGraph set FichierBlast "$DirOligo/${PAB}.blastn" lappend LesFichiersBlast $FichierBlast if {0&&[file exists $FichierBlast]} { lappend LesFichiersBlast $FichierBlast #Affichage du Id content du blast set IdResults "" set IdResults [PosEtPIdAligneeDeLaRegion $FichierBlast] if {$IdResults !=""} { AfficheLeSpectreIdDUneListe $K $IdResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel "red" "Id$IdDuGraph" } #Affichage du nb de sequence du blast set NbSeqResults "" set NbSeqResults [PosEtNbSequenceAligneeDeLaRegion $FichierBlast] if {$NbSeqResults !=""} { AfficheLeSpectreNbSequenceDUneListe $K $NbSeqResults $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel "deepskyblue2" "NbSeq$IdDuGraph" } UnsetLesTableauxDesGraphAvecBlast } #Charge le fichier pour obtenir les infos sur les oligos ######################################################## set FichierLog "$DirOligo/$PAB.log" set FichierACharger "$DirOligo/$PAB.oligo" if {[file exists $FichierLog]} {lappend LesLogs $FichierLog} if {[file exists $FichierACharger]} {lappend LesFichiersOligo $FichierACharger} set lesXDebutFinDeOligo [InterrogeInfoDeLOligo $FichierACharger LesDebutFin] if {$lesXDebutFinDeOligo == ""} { if { [InterrogeInfoDeLOligo $FichierACharger NotDone]=="1"} { set Message "No Oligo calculated for $PAB in $DirOligo" } elseif {[InterrogeInfoDeLOligo $FichierACharger NoOligo]=="1"} { set Message "No Oligo available for $PAB in $DirOligo" } else {set Message "Petit probleme"} $K create text $XMilieu $YDebutDeOligo -text "$Message" -font "$Police2" set YDebutDeOligo [expr $YDebutDeOligo + 20] continue } #Construction des boites des Oligos #Classement des bornes du Nt vers Ct (3prime vers 5prime) #Creation des boites avec plus de 40 d ecart ######################################################### if {$OnADejaFaitLesSpike == "0" && [regexp -nocase "spike" $DirOligo]} { set OnADejaFaitLesSpike 1 set RepSpike "[RepertoireDuGenome]/Probes/Spike_Athaliana" set OligoDuSpike "$RepSpike/${PAB}.oligo" if {[file exists $OligoDuSpike]} { set lesXDebutFinDesSpikes [InterrogeInfoDeLOligo $OligoDuSpike LesDebutFin] foreach UnDebutFinDesSpikes [lsort -real -increasing -index 0 $lesXDebutFinDesSpikes] { set YFinDeOligo [expr $YDebutDeOligo + $EpaisseurBoite] set NbUnrelated "" set NomOligo [InterrogeInfoDeLOligo $OligoDuSpike [lindex $UnDebutFinDesSpikes 0] [lindex $UnDebutFinDesSpikes 1] NomOligo] set LaSequence [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo Sequence] set TailleOligo [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo Taille] set GC [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo GC] set Tm [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo Tm] set ExpTm [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo ExpTm] set XDebutDeOligoNt [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo Debut] set XFinDeOligoNt [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo Fin] set NbCandidats [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo NbCandidats] set NbContigues [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo NbContigues] set LesCandidats [InterrogeInfoDeLOligo $OligoDuSpike $NomOligo LesCandidats] if {$TailleOligo == ""} {set TailleOligo [string length $LaSequence]} if {$TailleOligo>$TailleQueryNt} {set TailleOligo $TailleQueryNt} if { $GC == ""} { set GC [format "%.1f" [expr (([NombreDeBaseDe $LaSequence "G|C"])/($TailleOligo*1.0))*100.0]] } if {$Tm == ""} {set Tm [CalculTmDeLaSeq $LaSequence "" "" NearestNeighbor]} if {$ExpTm == ""} {set ExpTm [CalculTmDeLaSeq $LaSequence "" "" DNADNA]} if {$XDebutDeOligoNt == ""} {set XDebutDeOligoNt 1} if {$XFinDeOligoNt == ""} {set XFinDeOligoNt $TailleOligo} if {$NbCandidats == ""} {set NbCandidats "-1"} if {$NbContigues == ""} {set NbContigues "-1"} if {$NbUnrelated == ""} {set NbUnrelated "0"} set CouleurBoite "black" #Les infos contenues dans l info bulle #set Texte [format "%-10s%-10s" "Id-Oligo:" "$NomOligo"] set Texte [format "%-4s%-10s" "Id:" "$NomOligo"] append Texte [format "\n%-10s%-10s" "Database:" "$DB"] append Texte [format "\n%-10s%-3d %5s" "Length:" "$TailleOligo" "nt(s)"] append Texte [format "\n%-10s%3.1f %1s" "GC:" "$GC" "%"] append Texte [format "\n%-10s%3.1f %5s" "NN-Tm:" "$Tm" "degree(s)"] append Texte [format "\n%-10s%3.1f %5s" "Ex-Tm:" "$ExpTm" "degree(s)"] append Texte [format "\n%-10s%3d %5s" "Begin:" "$XDebutDeOligoNt" "/ $TailleQueryNt nt(s)"] append Texte [format "\n%-10s%3d %5s" "End:" "$XFinDeOligoNt" "/ $TailleQueryNt nt(s)"] append Texte [format "\n%-15s%2d" "X-Detected:" "$NbCandidats"] append Texte [format "\n%-15s%2d" "Contiguous:" "$NbContigues"] append Texte [format "\n%-15s%2d" "Unrelated Acc:" "$NbUnrelated"] #Calcul positions de l oligo sur la query set XDebutDeOligo [expr $XDebutQuery + $OneNtPixel * $XDebutDeOligoNt - $OneNtPixel] set XFinDeOligo [expr $XDebutDeOligo + $OneNtPixel * $TailleOligo - $OneNtPixel] #On dessine la boite de l oligo $K create rectangle $XDebutDeOligo $YDebutDeOligo $XFinDeOligo $YFinDeOligo -outline "white" -fill "$CouleurBoite" -tags [list "" $Texte $XDebutDeOligoNt $XFinDeOligoNt $NomOligo $RepSpike Affichable Positionner Boite] set YDebutDeOligo [expr $YFinDeOligo + $Intervalle] } set YDebutDeOligo [expr $YFinDeOligo + $Intervalle] } } while {1} { if {$lesXDebutFinDeOligo==""} {break} set YFinDeOligo [expr $YDebutDeOligo + $EpaisseurBoite] set OldDebut -40 foreach UnDebutFinDeOligo [lsort -real -increasing -index 0 $lesXDebutFinDeOligo] { set NbUnrelated "" set NomOligo [InterrogeInfoDeLOligo $FichierACharger [lindex $UnDebutFinDeOligo 0] [lindex $UnDebutFinDeOligo 1] NomOligo] set LaSequence [InterrogeInfoDeLOligo $FichierACharger $NomOligo Sequence] set TailleOligo [InterrogeInfoDeLOligo $FichierACharger $NomOligo Taille] set GC [InterrogeInfoDeLOligo $FichierACharger $NomOligo GC] set Tm [InterrogeInfoDeLOligo $FichierACharger $NomOligo Tm] set ExpTm [InterrogeInfoDeLOligo $FichierACharger $NomOligo ExpTm] set XDebutDeOligoNt [InterrogeInfoDeLOligo $FichierACharger $NomOligo Debut] set XFinDeOligoNt [InterrogeInfoDeLOligo $FichierACharger $NomOligo Fin] set NbCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbCandidats] set NbContigues [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbContigues] set LesCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo LesCandidats] set NbUnrelated [regexp -all {NG[0-9]+} $LesCandidats] if {$TailleOligo == ""} {set TailleOligo [string length $LaSequence]} if {$TailleOligo>$TailleQueryNt} {set TailleOligo $TailleQueryNt} if { $GC == ""} { set GC [format "%.1f" [expr (([NombreDeBaseDe $LaSequence "G|C"])/($TailleOligo*1.0))*100.0]] } if {$Tm == ""} {set Tm [CalculTmDeLaSeq $LaSequence "" "" NearestNeighbor]} if {$ExpTm == ""} {set ExpTm [CalculTmDeLaSeq $LaSequence "" "" DNADNA]} if {$XDebutDeOligoNt == ""} {set XDebutDeOligoNt 1} if {$XFinDeOligoNt == ""} {set XFinDeOligoNt $TailleOligo} if {$NbCandidats == ""} {set NbCandidats "-1"} if {$NbContigues == ""} {set NbContigues "-1"} if {$NbUnrelated == ""} {set NbUnrelated "0"} set CouleurBoite [CouleurDeLOligo $NbCandidats] #Les infos contenues dans l info bulle #set Texte [format "%-10s%-10s" "Id-Oligo:" "$NomOligo"] set Texte [format "%-4s%-10s" "Id:" "$NomOligo"] append Texte [format "\n%-10s%-10s" "Database:" "$DB"] append Texte [format "\n%-10s%-3d %5s" "Length:" "$TailleOligo" "nt(s)"] append Texte [format "\n%-10s%3.1f %1s" "GC:" "$GC" "%"] append Texte [format "\n%-10s%3.1f %5s" "NN-Tm:" "$Tm" "degree(s)"] append Texte [format "\n%-10s%3.1f %5s" "Ex-Tm:" "$ExpTm" "degree(s)"] append Texte [format "\n%-10s%3d %5s" "Begin:" "$XDebutDeOligoNt" "/ $TailleQueryNt nt(s)"] append Texte [format "\n%-10s%3d %5s" "End:" "$XFinDeOligoNt" "/ $TailleQueryNt nt(s)"] append Texte [format "\n%-15s%2d" "X-Detected:" "$NbCandidats"] append Texte [format "\n%-15s%2d" "Contiguous:" "$NbContigues"] append Texte [format "\n%-15s%2d" "Unrelated Acc:" "$NbUnrelated"] #Calcul positions de l oligo sur la query set XDebutDeOligo [expr $XDebutQuery + $OneNtPixel * $XDebutDeOligoNt - $OneNtPixel] set XFinDeOligo [expr $XDebutDeOligo + $OneNtPixel * $TailleOligo - $OneNtPixel] if {[expr $XDebutDeOligo > [expr $OldDebut+40.0]] =="1"} { #On dessine la boite de l oligo $K create rectangle $XDebutDeOligo $YDebutDeOligo $XFinDeOligo $YFinDeOligo -outline "white" -fill "$CouleurBoite" -tags [list "" $Texte $XDebutDeOligoNt $XFinDeOligoNt $NomOligo $DirOligo Affichable Positionner Boite] set OldDebut $XFinDeOligo set index [lsearch $lesXDebutFinDeOligo $UnDebutFinDeOligo] set lesXDebutFinDeOligo [lreplace $lesXDebutFinDeOligo $index $index] } } #On ajoute de l espace pour la deuxieme ligne set YDebutDeOligo [expr $YFinDeOligo + $Intervalle] } set YDebutDeOligo [expr $YDebutDeOligo + 15] #Separateur entre chaque design $K create text $XDebutQuery [expr $YDebutDeOligo-8] -text "$IdDuGraph: $DB" -font {-family "arial" -size 10 -weight bold} -anchor "w" $K create line $XDebutQuery $YDebutDeOligo $XFinQuery $YDebutDeOligo -fill "black" -width 2 set YDebutDeOligo [expr $YDebutDeOligo+$Intervalle] } #Sauve les informations importantes du canvas SauveLesInfosDe $K MonFichierQuery $FichierQuery SauveLesInfosDe $K MonAccessQuery $AccessQuery SauveLesInfosDe $K MaTailleDeQuery $TailleQueryNt SauveLesInfosDe $K MesDirs $LesDirs SauveLesInfosDe $K MesBlasts $LesFichiersBlast SauveLesInfosDe $K MesLogs $LesLogs SauveLesInfosDe $K MesFichiersOligo $LesFichiersOligo SauveLesInfosDe $K MonPAB $PAB #Pour accorder la taille de la fenetre selon la taille des resultats affiches if {$YDebutDeOligo < [winfo screenheight .] } {$K configure -height $YDebutDeOligo} #Pour accorder la scrollbar au dernier oligo affiche $K configure -scrollregion [list 0 0 $LargeurMax $YDebutDeOligo] set InfosDeBase [list AvecSeqFormate AvecTaille AvecStatNuc AvecTm] $K bind "Query" <1> "SauveLesInfosDe $K Win \[AfficheVariable \[LesInfosDeBaseDeMaSequence $SeqQuery \"$InfosDeBase\"\]\]" $K bind "Query" <2> "SauveLesInfosDe $K Win \[AfficheFetch $AccessQuery OnVeutNature\]" $K bind "Query" <3> "SauveLesInfosDe $K Win \[AfficheLaQuery $K $FichierQuery\]" $K bind "Affichable" "AfficheInfoBulle $K %x %y Enter" $K bind "Affichable" "AfficheInfoBulle $K %x %y Leave" $K bind "Positionner" <1> "AffichePositionOligo $K %x %y Show" $K bind "Positionner" <2> "SauveLesInfosDe $K Win \[AfficheLesAutresCandidats $K $PAB\]" $K bind "Positionner" <3> "SauveLesInfosDe $K Win \[AfficheLaSequenceDeLOligo $K $PAB\]" $K bind "Positionner" "SauveLesInfosDe $K Win \[AfficheLesAutresCandidatsComplet $K $PAB\]" $K bind "Positionner" "SelectionneOligo $K" $K bind "Positionner" "SelectionneOligoCroisee $K" regsub ".canvas$" $K "" F set B [BoutonneLaFenetre $F "Position Show / Hide\nHelp Main / Color\nChange Acc Separator"] bind $B <1> "AffichePositionOligoPourTous $K %x %y Show" bind $B <2> "EffacePositionOligoPourTous $K %x %y" bind $B "AfficheHelp DuBouton" bind $B "SignificationDesCouleursDeLOligo" bind $B "ChangeDebutAccessDeDir" set Texte [format "%-10s" "Display the nt positions among the query"] append Texte [format "\n%-10s" "Help for program and coloring scheme"] append Texte [format "\n%-10s" "Accession from database are stored on one line\nex:RSHUM_myprot1 RSHUM_myprot2\nIf the program does not how to separate them,\n you can help it, here it is RSHUM_"] set_balloon $B "$Texte" set C [BoutonneLaFenetre $F "Show Blast / Mosaic\nShow Log / Oligo File\nBest Hit / Self-Comp."] bind $C <1> "SauveLesInfosDe $K Win \[AfficheFichier \[ChoixParmi \[LesInfosDe $K MesBlasts\]\] AvecSegAlignement\]" bind $C <2> "IllustreLeBlast \[ChoixParmi \[LesInfosDe $K MesBlasts\]\]" bind $C <3> "SauveLesInfosDe $K Win \[DrawBlast \[ChoixParmi \[LesInfosDe $K MesBlasts\]\]\]" bind $C "SauveLesInfosDe $K Win \[AfficheFichier \[ChoixParmi \[LesInfosDe $K MesLogs\]\]\]" bind $C "SauveLesInfosDe $K Win \[AfficheFichier \[ChoixParmi \[LesInfosDe $K MesFichiersOligo\]\] t\]" bind $C "CheckForBestHitInDatabase $PAB \[ChoixParmi \[LesInfosDe $K MesDirs\]\]" bind $C "SauveLesInfosDe $K Win \[SelfComplementarity_GUI $K $PAB\]" set Texte [format "%-10s" "Display BLAST file and friendly output"] append Texte [format "\n%-10s" "Display .log or .oligo file"] append Texte [format "\n%-10s" "Check best hit in database, Self-complementarity"] set_balloon $C "$Texte" set D [BoutonneLaFenetre $F "Graph Panel\nGraph Add / Delete\nSearch / Clear"] bind $D <1> "Graph_Panel $K" bind $D "AjouteUnGraph $K $FichierQuery $XDebutQuery $XFinQuery $YDebutGraph $YFinGraph $OneNtPixel" bind $D "SupprimeUnGraph $K" bind $D "TrouveDansLesInfos $K" bind $D "DeselectionneLesTrouves $K" set Texte [format "%-10s" "Panel to change graph display (order,color)"] append Texte [format "\n%-10s" "Allow to add or delete graph"] append Texte [format "\n%-10s" "Allow to search items in oligo display text"] set_balloon $D "$Texte" set E [BoutonneLaFenetre $F "Selected / Reset / Save\nX-Selected / Reset / Save\nAuto Selection / X-Selection"] bind $E <1> "AllumeLaSelection $K $PAB \[LesInfosDe $K MesDirs\]" bind $E <2> "DeselectionneLesSelectionnes $K" bind $E <3> "SauveLesSelectionnes $K $PAB \[LesInfosDe $K MesDirs\]" bind $E "AllumeLaXSelection $K $PAB \[LesInfosDe $K MesDirs\]" bind $E "DeselectionneLesXSelectionnes $K" bind $E "SauveLesXSelectionnes $K $PAB \[LesInfosDe $K MesDirs\]" bind $E "SelectionDesOligos_GUI $PAB \[ChoixParmi \[LesInfosDe $K MesDirs\]\]" bind $E "SelectionCroiseeDesOligos_GUI $PAB \[ChoixParmi \[LesInfosDe $K MesDirs\]\] $DirOligo" set Texte [format "%-10s" "Allow to display, hide or save Selected oligo"] append Texte [format "\n%-10s" "Allow to display, hide or save X-Selected oligo"] append Texte [format "\n%-10s" "Do Selection or X-Selection"] set_balloon $E "$Texte" set F [BoutonneLaFenetre $F "Draw again / Erase / Reset\nTo Excel Sel / Project\nComplete another"] bind $F <1> "RestrictedParameter_Panel $K" bind $F <2> "EffaceLesBoitesDuCanvas $K" bind $F <3> "InterrogeInfoDeLOligo \[ChoixParmi \[LesInfosDe $K MesFichiersOligo\]\] Decharge" bind $F "UnOligoPourExcel_GUI $K $PAB" bind $F "LesOligosPourExcel_GUI \[ChoixParmi \[LesInfosDe $K MesDirs\]\]" bind $F "CompleteLaListeDesOligos_GUI $K $PAB \[ChoixParmi \[LesInfosDe $K MesDirs\]\]" set Texte [format "%-10s" "Allow to redraw results with restricted parameters"] append Texte [format "\n%-10s" "Allow to save under tab delimited file (excel)"] append Texte [format "\n%-10s" "Complete results from another design with selected oligo"] set_balloon $F "$Texte" bind $K "ViseurDeSeq $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YDebutDeOligo $OneNtPixel" bind $K "ViseurDeSeq $K %x %y $XDebutQuery $XFinQuery $YDebutGraph $YDebutDeOligo $OneNtPixel" wm deiconify $w #Check le design pour la presence de la query dans le blast #Pop up une boite de dialogue le cas echeant set FEvalue "" foreach Dir $LesDirs { set FEvalue [EvalueLeDesign $PAB $Dir] if {$FEvalue!=""} { raise $FEvalue $w SauveLesInfosDe $K Win $FEvalue } set FEvalue "" } #Binding pour permettre de zoomer en utilisant le 3eme bouton bind $K <3> "zoomMark $K %x %y" bind $K "zoomStroke $K %x %y" bind $K "zoomArea $K %x %y" return "" } proc IllustreOligoArray {{PAB ""} {Directories ""}} { Wup "Illustre une sortie OligoArray 1.0 pour l'instant" #Version pour visualiser plusieurs oligos de plusieurs banques en simultanee. #Addon GC content, Help #21/02/2003 if {$PAB==""} {return "Correct syntax is IllustreOligoArray PAB ProbesDir\nfor ex: IllustreOligoArray ACT0001"} set RepOligo "[RepertoireDuGenome]/Probes" if {$Directories!=""} { foreach Dir $Directories { if {[regexp {/} $Dir]} { lappend LesDirs [file tail $Dir] } else {lappend LesDirs $Dir} } } else { set LesDirs {} set LesDirectories "[glob -nocomplain $RepOligo/*]" foreach File $LesDirectories { if {! [file isdirectory $File]} {continue} else {lappend LaListe [file tail $File]} } set LesDirs [ChoixDesPresents $LaListe] } #Attention il faut une query, sinon pas de taille .... set RepmRNA "[RepertoireDuGenome]/mrnahuman" set Repnuctfa "[RepertoireDuGenome]/nuctfa" if {[file exists "$RepmRNA/$PAB"]} { set FichierQuery "$RepmRNA/$PAB" } elseif {[file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } else {Espionne "No File for the Query ($PAB)";return ""} set Police "Courier 12" set CouleurOutline "black" set LargeurMax [expr [winfo screenwidth .] - 200] set HauteurMax [expr [winfo screenheight .]*2/4] set LargeurFenetre [expr [winfo screenwidth .] - 200] set HauteurFenetre [expr [winfo screenheight .]*1/2] set XMilieu [expr $LargeurMax/2] set BordureX 50.0 set BordureY 50.0 set Intervalle 10.0 set EpaisseurBoite 15.0 #Position du GC content set YDebutGC [expr 0 + $BordureY] set YFinGC [expr $YDebutGC + 50] #Position de la query set XDebutQuery [expr 0 + $BordureX] set YDebutQuery [expr $YFinGC + 10] set XFinQuery [expr $LargeurMax - $BordureX] set YFinQuery [expr $YDebutQuery + $EpaisseurBoite] #Besoin de la taille de la query pour conversion et affichage set AccessQuery [AccessDuTFADumRNA $FichierQuery] set SeqQuery [QueLaSequenceDuFichierTFA $FichierQuery] set TailleQueryNt [string length $SeqQuery] set OneNtPixel [expr ($XFinQuery-$XDebutQuery)/$TailleQueryNt] #Debut des Oligos set YDebutDeOligo [expr $YFinQuery + $Intervalle] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "" "IllustreOligoArray"] $K configure -background white #Affichage du GC content set GCResults [CreeLesFichiersSpectreDesGC $SeqQuery SpectreGCXY 30] if {$GCResults !={}} { AfficheLeSpectreGCDUneListe $K $GCResults $XDebutQuery $XFinQuery $YDebutGC $YFinGC $OneNtPixel } #Affiche la query $K create rectangle $XDebutQuery $YDebutQuery $XFinQuery $YFinQuery -outline "$CouleurOutline" -fill "red" -tags "Query" $K create text [expr $XDebutQuery-5.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "1" -font "$Police" -anchor e $K create text [expr $XFinQuery+5.0] [expr $YDebutQuery + ($EpaisseurBoite/2.0)] -text "$TailleQueryNt" -font "$Police" -anchor w $K create text $XMilieu [expr 1*$BordureY/3] -text "Oligo de $PAB dans $LesDirs" #Affiche la petite aide $K create oval [expr $XFinQuery-20] 20 $XFinQuery 40 -fill "green" -outline "green" $K create text [expr $XFinQuery-10] [expr 1*$BordureY-20] -text "?" -tags [list "" "[AfficheHelpOligoArray]" "Affichable"] #Dessine les boites des differentes sources set i 0 set LesOligos {} foreach DirOligo [lsort -unique $LesDirs] { set LesCouleurs [list "green" "blue" "grey" "black"] if {$i>3} {break} #Lit le fichier OligoArray pour obtenir les oligos set LesOligos [LitSortieOligoArray $PAB "$RepOligo/$DirOligo"] if {$LesOligos == "-1"} { $K create text $XMilieu $YDebutDeOligo -text "No Oligo Available for $PAB in $DirOligo" -font "10" set YDebutDeOligo [expr $YDebutDeOligo + 20] continue } if {$LesOligos == "-2"} { $K create text $XMilieu $YDebutDeOligo -text "No Oligo calculated for $PAB in $DirOligo" -font "10" set YDebutDeOligo [expr $YDebutDeOligo + 20] continue } set CouleurBoite [lindex $LesCouleurs $i] incr i foreach Oligo $LesOligos { set NomOligo "" set TailleOligo "" set PositionOligoDebut "" set Tm "" set TmStructure "" set DistanceDu3End "" if { ! [regexp -nocase {[a-z]+ || [0-9]+} $Oligo]} {continue} ScanLaListe $Oligo NomOligo TailleOligo Tm TmStructure DistanceDu3End ExpTm set Texte "Nom:$NomOligo\nDB:$DirOligo\nTaille:$TailleOligo nt\nTm:$Tm Degree\nExpTm:$ExpTm Degree\nTm Structure:$TmStructure Degree" #Positions de oligo set PositionOligoDebut [expr $TailleQueryNt - $DistanceDu3End] set XFinDeOligoNt [expr $PositionOligoDebut + $TailleOligo] #Calcul positions de l'oligo sur la query set XDebutDeOligo [expr $XDebutQuery + $OneNtPixel * $PositionOligoDebut] set XFinDeOligo [expr $XDebutDeOligo + $OneNtPixel * $TailleOligo] set YFinDeOligo [expr $YDebutDeOligo + $EpaisseurBoite] $K create rectangle $XDebutDeOligo $YDebutDeOligo $XFinDeOligo $YFinDeOligo -outline "$CouleurOutline" -fill "$CouleurBoite" -tags [list "" $Texte $PositionOligoDebut $XFinDeOligoNt $NomOligo $DirOligo "Affichable" "Positionner"] set YDebutDeOligo [expr $YFinDeOligo + $Intervalle] } } #Pour accorder la scrollbar au dernier oligo affiche $K configure -scrollregion [list 0 0 $LargeurMax $YDebutDeOligo] $K bind "Query" <2> "AfficheFetch $AccessQuery OnVeutNature" $K bind "Query" <3> "AfficheLaQuery $K $PAB" $K bind "Affichable" "AfficheInfoDeLOligo $K %x %y Enter" $K bind "Affichable" "AfficheInfoDeLOligo $K %x %y Leave" $K bind "Positionner" <1> "AffichePositionOligo $K %x %y Show" $K bind "Positionner" <2> "AfficheLesAutresCandidatsOligoArray $K $PAB" $K bind "Positionner" <3> "AfficheExtraitOligoDuTFA $K $PAB" regsub ".canvas$" $K "" F set B [BoutonneLaFenetre $F "Coordinates Show/Hide\nHelp"] bind $B <1> "AffichePositionOligoPourTous $K %x %y Show" bind $B <2> "AffichePositionOligoPourTous $K %x %y Hide" bind $B "AfficheHelpOligoArray DuBouton" return "" } proc IllustreOligoArrayPourTous {LesDirs {AvecPosition 0}} { Wup "Affiche pour tous les ACT present dans Dir les oligos illustre" set LesPABs {} foreach Dir $LesDirs { set UneListe [glob -nocomplain "[RepertoireDuGenome]/Probes/$Dir/*"] foreach PAB $UneListe {lappend LesPABs [file tail $PAB]} } set LesPABs [lsort -unique $LesPABs] foreach Dir $LesDirs { if {$AvecPosition} { set FichierPosition "[RepertoireDuGenome]/PositionOligo" AppendAuFichier $FichierPosition "[file tail $Dir]" } foreach PAB $LesPABs { set Queue [file tail $PAB] IllustreOligoArray $Queue $Dir $AvecPosition } } } proc IllustreOligoCGH {Cas {LesPos ""} {LesNoms ""}} { # liste des cas if {$Cas!="meta" && $Cas!="nometa" && $Cas!="cl"} { set LesCas $Cas } if {$Cas=="cl"} {set LesCas {CL_PC3 CL_DU145 CL_22rv1 CL_LNCaP} } #if {$Cas!="meta" && $Cas!="nometa"} {return} if {$Cas=="meta"} { set LesCas {Oligo806 Oligo807 Oligo810 Oligo817 Oligo818 Oligo819 Oligo826 Oligo827} } if {$Cas=="nometa"} {set LesCas {Oligo809 Oligo811 Oligo812 Oligo814 Oligo815 Oligo816 Oligo820 Oligo821 Oligo822 Oligo823 Oligo825}} Espionne $LesCas set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoite 10 set EcartEntreRepresentations 100 #en fct du nb de plots- plus grande val- apres ascenseur. set HauteurMax [expr $BordY + [expr [llength $LesCas]-1]*$HauteurBoite + [llength $LesCas]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosXMin $BordX set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0) + ($TailleChromo*1.0)] } set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] # pour chaque fichier Oligo foreach Oligo $LesCas { if {$Cas!="meta" && $Cas!="nometa" && $Cas!="cl"} { set FichierCourbeOligo $Oligo } else { set FichierCourbeOligo "[RepertoireDuGenome]/PRIMA_CGH/$Oligo" } Espionne $Oligo set NomFichierOligo [file tail $FichierCourbeOligo] # HR: set VMax 5.98 set VMin -4.68 # meta: #set VMax 6.59 #set VMin -4.07 set VMaxf $VMax set VMinf $VMin set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] if {[info exists TabC]} {unset TabC} ChargeFichierCourbeCGH TabC $FichierCourbeOligo $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set DebutCentro [expr $DebutCentro*1.0 + $TailleChroCum*1.0] set FinCentro [expr $FinCentro*1.0 + $TailleChroCum*1.0] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabC($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} { set n 1 foreach Pos [set TabC($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] { if {$n==1} {incr n;continue} if {$n==2} {incr n;continue} if {$n==3} {incr n;continue} if {$n==4} {incr n;continue} if {$n==5} {set n 1} set Pos10 [Base10 $Pos] set PosMid [expr $Pos10 + $TailleChroCum] foreach LInfo [set TabC($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] { set Val [lindex $LInfo 3] set Val [expr $Val*log(10)/log(2)] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro} { # x1 est avant le debut du centro et x2 dedans set X1 $PosMid set Y1 $Value continue } if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { # aucun point dans le centromere set X1 $PosMid set Y1 $Value } if {($X1>=$DebutCentro && $X1<=$FinCentro) && ($PosMid>=$DebutCentro && $PosMid<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } if {$X1<=$FinCentro && $PosMid>=$FinCentro && $X1>=$DebutCentro} { # x1 est avant la fin du centro et x2 apres le centromere set X1 $PosMid set Y1 $Value } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo + $TailleChroCum) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo +$TailleChroCum)* $Facteur)-($TailleChromo*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $LesCas "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierOligo CGH plot " -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr ($TailleChroCum*1.0) + ($TailleChromo*1.0)] } set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] } #### fin boucle ### LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneCGH $K" regsub {\.canvas} $K "" w bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreOligoCGHseg {Cas {LesPos ""} {LesNoms ""}} { if {$Cas!="" && $Cas!="null"} { set LesCas $Cas Espionne $LesCas } set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoite 10 set EcartEntreRepresentations 100 #en fct du nb de plots- plus grande val- apres ascenseur. set HauteurMax [expr $BordY + [expr [llength $LesCas]-1]*$HauteurBoite + [llength $LesCas]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set PosYMin [expr $HauteurMax - $BordY] set PosYMax [expr $HauteurMax - $BordY] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set ListeChro {HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY} set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleGenome 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleGenome [expr ($TailleGenome*1.0) + ($TailleChromo*1.0)] } # Attention au *1.0 !!! indispensable pour windows! (sinon taille du genome, negative! donc facteur negatif) set Facteur [expr ($LargeurAffichage*1.0)/($TailleGenome*1.0)] # pour chaque fichier oligo seg foreach Oligo $LesCas { Espionne $Oligo set FichierCourbeOligoSeg $Oligo set NomFichierOligoSeg [file tail $FichierCourbeOligoSeg] # HR: #set VMax 3.52 #set VMin -2.18 # meta: set VMax 2.13 set VMin -2.39 set VMaxf $VMax set VMinf $VMin set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set TailleChroCum 0 foreach Chromosome $ListeChro { set nChromosome [NumeroDuChromosome $Chromosome] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] ChargeFichierSEG TabO $FichierCourbeOligoSeg $Chromosome $LesPos set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set X1 0;set Y1 0 set LeChromo ""; lappend LeChromo $Chromosome; lappend LeChromo "Chr" if {[info exists TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabO($FichierCourbeOligoSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [expr [lindex $LInfo 3]+ $TailleChroCum] set PosSup [expr [lindex $LInfo 4]+ $TailleChroCum] if {$PosSup<0} {Espionne "posinf=$PosInf et posusp=$PosSup"} set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX + (($TailleChromo*1.0 + $TailleChroCum*1.0) * $Facteur)] $PosYCenter [expr $BordX + (($TailleChromo*1.0 + $TailleChroCum*1.0) * $Facteur)] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 1 #texte chro $K create text [expr $BordX + (($TailleChromo*1.0 +$TailleChroCum*1.0)* $Facteur)-($TailleChromo*1.0*$Facteur)/2] [expr $PosYCenter + 10] -text "$nChromosome" -font "$Police" -fill "Mediumblue" -tags [list $Chromosome $LesCas "Chromosome"] #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 20] -text "$NomFichierOligoSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" set TailleChroCum [expr ($TailleChroCum*1.0) + ($TailleChromo*1.0)] } set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] } LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Chromosome" <1> "ac_ChromosomeSelectionneCGH_seg $K" regsub {\.canvas} $K "" w bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreOntology {Type {MesGO NotDisplayMyGO} {Density No} {GOIni All} {PremierNiveau ""}} { Wup "MesGO options `OnlyMyGO` `AllAndMyGO` `NotDisplayMyGO` 'Density'" set HauteurMax [expr [winfo screenheight .] - 130] set LargeurMax [expr [winfo screenwidth .] - 100] set HauteurFenetre [expr [winfo screenheight .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100] set BordY 50.0 set BordX 50.0 set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set PoliceTitre "Arial 14 bold" set PoliceNiveau "Arial 12 bold" set LesNiveaux [Onto $Type LesNiveaux] if {$PremierNiveau == ""} {set PremierNiveau [lindex $LesNiveaux 0]} if {$GOIni == "All"} {set GOIni [lindex [Onto $Type $PremierNiveau] 0]} if {![OntoExists $Type $GOIni LesNiveaux]} {return ""} set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] $K configure -background white $K create text [expr $LargeurFenetre/2] [expr $BordY/2] -text "Gene Ontology : $Type" -font $PoliceTitre set nNiveaux [llength $LesNiveaux] set EcartY [expr $HauteurAffichage * 1.0 / ($nNiveaux-1)] set XMin $BordX set XMax [expr $BordX + $LargeurAffichage] foreach Niveau $LesNiveaux { if {![info exists Y]} { set Y [expr $BordY + $HauteurAffichage] } else { set Y [expr $Y - $EcartY] } $K create text [expr $BordX /2] $Y -text "Niv $Niveau" -font $PoliceNiveau $K create text [expr $LargeurAffichage+$BordX*3/2] $Y -text "Niv $Niveau" -font $PoliceNiveau $K create line $XMin $Y $XMax $Y -fill lightgrey set TabCoord($Niveau,Y) $Y } set TabCoord(XMin) $XMin set TabCoord(XMax) $XMax set TabCoord(RayonMax) [expr $EcartY / 4] PlaceLesGOSurLArbre $K TabCoord $Type $PremierNiveau $GOIni "" $MesGO $Density regsub {\.canvas} $K "" w set C [BoutonneLaFenetre $w "GO Function/Process/Component\nMyGO NotThem/JustThem/AllAndThem\nReset All My GO"] bind $C <1> "IllustreOntology function $MesGO $Density All " bind $C <2> "IllustreOntology process $MesGO $Density All " bind $C <3> "IllustreOntology component $MesGO $Density All " bind $C "IllustreOntology $Type NotDisplayMyGO $Density All " bind $C "IllustreOntology $Type OnlyMyGO $Density All " bind $C "IllustreOntology $Type AllAndMyGO $Density All " bind $C "ResetMesGO" set B [BoutonneLaFenetre $w "Density Access/Box/Requetes\nDensity All/None"] bind $B <1> "IllustreOntology $Type $MesGO Access All" bind $B <2> "IllustreOntology $Type $MesGO Box All" bind $B <3> "IllustreOntology $Type $MesGO Requetes All" bind $B "IllustreOntology $Type $MesGO All All" bind $B "IllustreOntology $Type $MesGO No All" $K bind "GO" "DevoileLesOntologies $K %x %y Enter" $K bind "GO" "DevoileLesOntologies $K %x %y Leave" $K bind "GO" <1> "IllustreGODuSelectionne $K %x %y $MesGO $Density " $K bind "GO" <3> "DevoileLeGO $K %x %y" $K bind "GO" "SelectionDesGODansFichier $K %x %y" return "" } proc IllustreOntologyDesAccess {LesAccess {Type ""}} { if {$Type == ""} {set Type [ChoixParmi [LesTypesOntologiques]]} foreach Access $LesAccess { Espionne $Access ChargeLesGODeLAccess $Access } if { $LesAccess != {}} { IllustreOntology $Type "OnlyMyGO" } else { IllustreOntology $Type } return "" } proc IllustreOntologyDesBoitesGscope {LesNoms {Type ""}} { if {$Type == ""} {set Type [ChoixParmi [LesTypesOntologiques]]} Espionne "LOADING ONTOLOGY..." ChargeLesGODeLaBoiteGscope $LesNoms Espionne "ONTOLOGY LOADED..." if { $LesNoms != {}} { IllustreOntology $Type "OnlyMyGO" } else { IllustreOntology $Type } return "" } proc IllustreOntologyDesGO {LesGO {Type ""}} { if {$Type == ""} {set Type [ChoixParmi [LesTypesOntologiques]]} Espionne "LOADING ONTOLOGY..." ChargeLesGODuGO $LesGO Espionne "ONTOLOGY LOADED..." IllustreOntology $Type "OnlyMyGO" return "" } proc IllustrePSORTII {{LesPABs ""}} { Wup "Permet de visualiser les localisations de PSORTII" Wup "Faire attention aux localisations cellulaires dans la liste possible" if {$LesPABs == ""} {set LesPABs [MorceauxChoisis [ListeDesPABs]]} set LesListeLoc "" foreach PAB $LesPABs { set FichierPsort "[RepertoireDuGenome]/psort/$PAB" if {! [file exists $FichierPsort]} { if {[file exists $PAB]} { set FichierPsort $PAB } } set LesLocsDuPAB [InterrogeInfoDePSORTII $FichierPsort LesLocalisations] set LesLocs [LesLocalisationDesPSORTII] #Si une localisation est manquante foreach MaLoc $LesLocsDuPAB { if {![regexp -nocase $MaLoc $LesLocs]} {lappend LesLocs $MaLoc} } set ListeLoc "" foreach Loc $LesLocs { set Percent "" set Percent [InterrogeInfoDePSORTII $FichierPsort $Loc] if {$Percent == ""} { lappend ListeLoc [list $Loc 0 0.0 100.0] continue } lappend ListeLoc [list $Loc $Percent 0.0 100.0] } set ListeLoc [linsert $ListeLoc 0 $PAB] lappend LesListeLoc $ListeLoc } set Titre "PSORTII - Localisation results for $PAB" set AvecTitre 1 set AvecLegende 1 set AvecVal 1 set AvecValEchelle 0 set AvecLigne 1 IllustreLesToilesDAraignee $LesListeLoc 3 $AvecTitre $AvecLegende $AvecVal $AvecValEchelle $AvecLigne return "" } proc IllustrePresencesDesClusters {{LesClusters ""} {nParLigne 2}} { if {$LesClusters == {}} {set LesClusters [O2C2O LesClusters]} set ListePresencesDeTousLesClusters {} set LesCategories [MorceauxChoisis [lsort [O2C2O LesCategories]]] foreach Cluster $LesClusters { Espionne $Cluster set Liste [list "Presence in cluster $Cluster"] foreach Categorie $LesCategories { set ValeurPresence [O2C2O Cluster $Cluster Categorie $Categorie Presence] if {$ValeurPresence == ""} {continue} lappend Liste [list $Categorie $ValeurPresence 0 100] } lappend ListePresencesDeTousLesClusters $Liste } EspionneL $ListePresencesDeTousLesClusters IllustreLesToilesDAraignee $ListePresencesDeTousLesClusters $nParLigne 1 1 0 0 1 return } proc IllustreSEACI {FichierSEACI {AvecPourcentage 1} {AvecDefinition 1}} { if {![file exists $FichierSEACI]} {return ""} Espionne "LOADING $FichierSEACI ..." ChargeLesResultatsDeSEACI SEACI $FichierSEACI Espionne "$FichierSEACI LOADED..." if { ![info exists SEACI(LesRequetes)] || ![info exists SEACI(LesCategories)] || [set SEACI(LesRequetes)] == {} || [set SEACI(LesCategories)] == {}} { return "" } set LesRequetes [set SEACI(LesRequetes) ] set nRequetes [llength $LesRequetes] set LesCategories [set SEACI(LesCategories)] set nCategories [llength $LesCategories] set NbMax [set SEACI(NbMax)] set NbCouleursTot $NbMax if {100 < $NbCouleursTot} {set NbCouleursTot 100} if {$AvecPourcentage} {set NbMax 100} set LesCouleurs [GammeDeCouleursRV [expr $NbCouleursTot + 1]] set ColorOutLine "yellow" ################### FENETRE ######################### set Bord 200;set PetitBord 50 set TailleBoite 25 set Ecart 0 set LargeurFenetre [expr [winfo screenwidth .] *2/3] set HauteurFenetre [expr [winfo screenheight .]*2/3] set LargeurMax [expr $nCategories * $TailleBoite + ($nCategories + 1) * $Ecart + 2 * $Bord] if {$LargeurMax < $LargeurFenetre} {set LargeurFenetre $LargeurMax} set HauteurMax [expr $nRequetes * $TailleBoite + ($nRequetes + 1) * $Ecart + 2 * $Bord] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre "GonfleAussiY" "$FichierSEACI"] $K configure -background white ################### CATEGORIE ###################### set XReq1 0 set XReq2 $LargeurMax set YCat1 [expr $Bord * 0.67 - $Ecart ] set YCat2 [expr $HauteurMax - $Bord * 0.67 - $Ecart] set Xmin [expr $Bord + $Ecart] foreach Categorie $LesCategories { set Xmax [expr $Xmin + $TailleBoite] set XCat [expr ($Xmax - $Xmin)/2 + $Xmin] set Ymin [expr $Bord + $Ecart] $K create text $XCat $YCat1 -text "$Categorie" -anchor n $K create text $XCat $YCat2 -text "$Categorie" -anchor s set nMax [set SEACI($Categorie)] foreach Requete $LesRequetes { set Ymax [expr $Ymin + $TailleBoite] set n 0 if {[info exists SEACI($Categorie,$Requete)]} {set n [set SEACI($Categorie,$Requete)]} set nCouleurs $n if {$NbCouleursTot < $nCouleurs } {set nCouleurs $NbCouleursTot} set Couleur [lindex $LesCouleurs $nCouleurs] set Pourcentage [expr round($n*100.0/$nMax)] if {$AvecPourcentage} {set Couleur [lindex $LesCouleurs $Pourcentage]} set TextRequete $Requete if {$AvecDefinition} { if {[regexp -nocase "^GO:" $Requete]} { if {![info exists TabTmp($Requete,Definition)]} { set TabTmp($Requete,Definition) 1 set TypeGO [Onto $Requete Type] set TextRequete [lindex [Onto $TypeGO $Requete LesDefinitions] 0] } } if {[regexp -nocase {^ipr[0-9]*} $Requete]} { if {![info exists TabTmp($Requete,Definition)]} { set TabTmp($Requete,Definition) 1 set TextRequete [DefinitionInterpro $Requete] } } } if {![info exists TabTmp($Requete)]} { set TabTmp($Requete) 1 set YReq [expr ($Ymax - $Ymin)/2 + $Ymin] $K create text $XReq1 $YReq -text "$TextRequete" -anchor w -tags [list "SEACI" "Text" "$Categorie" "$Requete" "$TextRequete" "$n" "$nMax" "$Pourcentage"] $K create text $XReq2 $YReq -text "$TextRequete" -anchor e -tags [list "SEACI" "Text" "$Categorie" "$Requete" "$TextRequete" "$n" "$nMax" "$Pourcentage"] } $K create rectangle $Xmin $Ymin $Xmax $Ymax -fill $Couleur -outline $ColorOutLine -tags [list "SEACI" "Case" "$Categorie" "$Requete" "$TextRequete" "$n" "$nMax" "$Pourcentage"] set Ymin [expr $Ymax + $Ecart] } set Xmin [expr $Xmax + $Ecart] } ############## ECHELLE ############################################## set YEchelleMin1 [expr $Bord * 0.33 - $Ecart - $TailleBoite / 2] set YEchelleMax1 [expr $YEchelleMin1 + $TailleBoite] set YTexteEchelle1 [expr $YEchelleMin1 - $Ecart] set YEchelleMin2 [expr $HauteurMax - $Bord * 0.33 - $Ecart - $TailleBoite / 2] set YEchelleMax2 [expr $YEchelleMin2 + $TailleBoite] set YTexteEchelle2 [expr $YEchelleMax2 + $Ecart] set NbValSurEchelle 10 if {$NbCouleursTot < $NbValSurEchelle} {set NbValSurEchelle $NbCouleursTot} set Inter [expr $NbCouleursTot * 1.0 / $NbValSurEchelle] set TailleEchelle [expr ($LargeurFenetre - 2 * $PetitBord) * 1.0 / $NbValSurEchelle] for {set i 0} {$i < $NbValSurEchelle} {incr i} { set XEchelleMin [expr $PetitBord + $Ecart + $i * $TailleEchelle] set XEchelleMax [expr $XEchelleMin + $TailleEchelle] set Val [expr round(($i + 1) * $Inter)] set nCouleurs $Val if {$NbCouleursTot < $nCouleurs} {set nCouleurs $NbCouleursTot} set Couleur [lindex $LesCouleurs $nCouleurs] $K create text $XEchelleMax $YTexteEchelle1 -text $Val -anchor s $K create rectangle $XEchelleMin $YEchelleMin1 $XEchelleMax $YEchelleMax1 -fill $Couleur -outline $ColorOutLine $K create text $XEchelleMax $YTexteEchelle2 -text $Val -anchor n $K create rectangle $XEchelleMin $YEchelleMin2 $XEchelleMax $YEchelleMax2 -fill $Couleur -outline $ColorOutLine set XEchelleMin $XEchelleMax } ################ BOUTONS ########################################### regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "Pourcentage Avec/Sans\nDefinition Avec/Sans\nOther"] bind $B <1> "IllustreSEACI $FichierSEACI 1 $AvecDefinition" bind $B <2> "IllustreSEACI $FichierSEACI 0 $AvecDefinition" bind $B "IllustreSEACI $FichierSEACI $AvecPourcentage 1" bind $B "IllustreSEACI $FichierSEACI $AvecPourcentage 0" bind $B "IllustreSEACI \[ButineArborescence\] $AvecPourcentage" $K bind "SEACI" "DevoileSEACI $K %x %y Enter" $K bind "SEACI" "DevoileSEACI $K %x %y Leave" return "" } proc IllustreTissueType {{LesNoms ""} {nMaxTissueParBoite ""} {nParLigne 3} {FichierSelectedEST ""}} { if {$FichierSelectedEST == ""} {set FichierSelectedEST [tk_getOpenFile -title "SelectedEST File" -initialdir "[RepertoireDuGenome]/fiches"]} if {$LesNoms == ""} {set LesNoms [MorceauxChoisis [InterrogeSelectedEST $FichierSelectedEST LesNoms]]} set Liste {} foreach Nom $LesNoms { if { ! [regexp -nocase {[a-z]} $Nom]} { continue } set LesTissuesDeLaBoiteOrdonnes [list "Tissue expression in $Nom"] set nMin 0 set nMax 0 set LesTissuesDeLaBoite {} set LesTissues [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] set LesTissuesDeLaBoite {} foreach Tissue $LesTissues { set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $Tissue n] if {$nMax < $n} {set nMax $n} lappend LesTissuesDeLaBoite [list $Tissue $n $nMin] } if {$LesTissuesDeLaBoite == {}} {continue} set LesTissuesDeLaBoite [lsort -index 1 -real -decreasing $LesTissuesDeLaBoite] if {$nMaxTissueParBoite != ""} {set LesTissuesDeLaBoite [lrange $LesTissuesDeLaBoite 0 [expr $nMaxTissueParBoite - 1]]} set NbTissue [llength $LesTissuesDeLaBoite] if {$NbTissue < 1} {continue} if {$NbTissue < 3} { for {set i 1} {$i <= [expr 3-$NbTissue]} {incr i} { lappend LesTissuesDeLaBoite [list "" 0 0 $nMax] } } foreach LeTissue [lsort -index 1 -real -decreasing $LesTissuesDeLaBoite] { lappend LeTissue $nMax lappend LesTissuesDeLaBoiteOrdonnes $LeTissue } lappend Liste $LesTissuesDeLaBoiteOrdonnes } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} if {$Liste == {}} {return} return [IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1] } proc IllustreTissueTypeDesClusters {FichierO2C2A2D2E {LesClusters ""} {nMaxTissueParCluster ""} {nMaxTissueParBoite ""} {nParLigne 1} {FichierSelectedEST ""}} { if {$FichierSelectedEST == ""} {set FichierSelectedEST [tk_getOpenFile -title "SelectedEST File" -initialdir "[RepertoireDuGenome]/fiches"]} if {$LesClusters == ""} {set LesClusters [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesClusters]]} set Liste {} foreach Cluster $LesClusters { #je calcule le tableau et les effectifs pour chaque tissue et pour chaque groupe set Tab(Cluster,$Cluster,LesTissues) {} set NbTissueTot 0 foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] { set LesAllTissues [InterrogeSelectedEST $FichierSelectedEST Nom $Nom LesTissueType] #if {$nMaxTissueParBoite != ""} {if {$nMaxTissueParBoite < [llength $LesTissues]} {continue}} set LesTissues {} foreach TS $LesAllTissues { set Tissue [string toupper $TS] #if {$Tissue == "THYMUS" || $Tissue == "MAMMARY GLAND" || $Tissue == "TESTIS"} {continue} if {[regexp -nocase {^WHOLE EMBRYO INCLUDING|^INFILTRATING DUCTAL|^HEMATOPOIETIC} $Tissue]} {continue} if {$Tissue == ""} {continue} set n [InterrogeSelectedEST $FichierSelectedEST Nom $Nom TissueType $TS n] lappend LesTissues [list $Tissue $n] } if {$LesTissues == {}} {continue} set LesTissues [lsort -index 1 -real -decreasing $LesTissues] if {$nMaxTissueParBoite != ""} {set LesTissues [lrange $LesTissues 0 [expr $nMaxTissueParBoite - 1]]} foreach LeTissue $LesTissues { set Tissue [lindex $LeTissue 0] if {![info exists Tab(Cluster,$Cluster,Tissue,$Tissue,n)]} { set Tab(Cluster,$Cluster,Tissue,$Tissue,n) 0 lappend Tab(Cluster,$Cluster,LesTissues) $Tissue } #set n [lindex $LeTissue 1] set n 1 incr Tab(Cluster,$Cluster,Tissue,$Tissue,n) $n incr NbTissueTot $n } } set LesTissuesDuClusterOrdonnes [list "Tissue expression in Cluster $Cluster"] set nMin 0 set nMax 0 set LesTissuesDuCluster {} foreach Tissue [set Tab(Cluster,$Cluster,LesTissues)] { set n [set Tab(Cluster,$Cluster,Tissue,$Tissue,n)] Espionne "$Cluster $Tissue $n" if {$nMax < $n} {set nMax $n} lappend LesTissuesDuCluster [list $Tissue $n $nMin] } set NbTissue [llength $LesTissuesDuCluster] if {$NbTissue <=1} {continue} if {$NbTissue < 3} { for {set i 1} {$i <= [expr 3-$NbTissue]} {incr i} { lappend LesTissuesDuCluster [list "" 0 0 $nMax] } } foreach LeTissue [lrange [lsort -index 1 -real -decreasing $LesTissuesDuCluster] 0 [expr $nMaxTissueParCluster - 1]] { lappend LeTissue $nMax lappend LesTissuesDuClusterOrdonnes $LeTissue } lappend Liste $LesTissuesDuClusterOrdonnes } if {[llength $Liste] < $nParLigne} {set nParLigne [llength $Liste]} return [IllustreLesToilesDAraignee $Liste $nParLigne 1 1 1 0 1] } proc IllustreTmCount {} { Wup "Interface du BestTmCount" Wup "Montre le graphe cumule des valeurs de Tm pour les sequences ou boites choisies" Wup "Permet de choisir, de montrer et sauver des bornes" Wup "26-04-2005 Modif pour tenir compte de step, SlidingWindow et TmMethode modifiable et affichage de ces infos" #Charge les Resultats set LesResultats [LesResultatsTmCount] if {$LesResultats==""} {Espionne "No results to show";return ""} set w "[NomDe fenetre]" if {[winfo exists $w]} {wm deiconify $w;raise $w;return ""} else {toplevel $w} wm geometry $w +300+100 wm title $w "Best Tm analysis" #wm resizable $w false false #Frame contenant le graphe et les scrollbar ########################################### set FInfo "$w.frameinfo" frame $FInfo -borderwidth "3" -relief "groove" set Police {-family "arial" -size 12 -weight bold} set LargeurFenetre [expr [winfo screenwidth .] * 2/3] set HauteurFenetre [expr [winfo screenheight .] * 1/2] set XMilieu [expr $LargeurFenetre/2] set BordureX 50.0 set BordureY 50.0 set Intervalle 10.0 set EpaisseurBoite 15.0 #Position du Graph content set XDebutGraph [expr 0.0 + $BordureX] set XFinGraph [expr $LargeurFenetre - $BordureX -20] set YDebutGraph [expr 0.0 + $BordureY] set YFinGraph [expr $HauteurFenetre - $BordureY] set TailleXGraph [expr $XFinGraph - $XDebutGraph] set TailleYGraph [expr $YFinGraph - $YDebutGraph] #Traite les Resultats set TmpResultat "" foreach {a b} $LesResultats { switch $a { "TmMax" {set XMax $b} "TmMin" {set XMin $b} "TmMoyenne" {set TmMoyenne $b} "TmTotal" {} "NbTm" {set NbTmCalcules $b} "NbSeq" {set NbSeq $b} "default" {lappend TmpResultat [list $a $b]} } } set TailleEnX [expr $XMax - $XMin] set LesResultats [lsort -decreasing -integer -index 1 $TmpResultat] set YMax [lindex [lindex $LesResultats 0] 1] set YMin [lindex [lindex $LesResultats end] 1] set TailleEnY [expr $YMax - $YMin] #Nombre de pixel pour un degre ou un nombre set RapportEnX [expr ($TailleXGraph)/($TailleEnX)] set RapportEnY [expr ($TailleYGraph)/($TailleEnY)] set K "$FInfo.canvas" set ScroHor "$FInfo.xscroll" set ScroVer "$FInfo.yscroll" scrollbar $ScroVer -command "$K yview" scrollbar $ScroHor -command "$K xview" -orient "horizontal" #Canvas pour le graphe canvas $K -width $LargeurFenetre -height $HauteurFenetre -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" $K configure -background "grey" #$K configure -scrollregion [list 0.0 0.0 $XFinGraph $YFinGraph] $K configure -scrollregion [list 0.0 0.0 $LargeurFenetre $HauteurFenetre] #Rectangle de masque pour les graphes $K create rectangle [expr $XDebutGraph -2] [expr $YDebutGraph -2] [expr $XFinGraph +2] [expr $YFinGraph +2] -fill "gray97" -outline "gray97" -tags [list "" "Masque"] set ColorLine "deepskyblue2" set n 0 set LesResultats [lsort -increasing -real -index 0 $TmpResultat] foreach TmNb $LesResultats { scan $TmNb "%f %d" x y set X [expr $XDebutGraph + [expr $x * $RapportEnX] - [expr $XMin * $RapportEnX]] set Y [expr $YFinGraph - [expr $y * $RapportEnY] + [expr $YMin * $RapportEnY]] incr n if {$n > 1} { $K create line [set Coordonnees(LastX)] [set Coordonnees(LastY)] $X $Y -tags [list "" "Tm $x Nb $y" "Affichable" "OligoGraph" "Tm" "TmLines"] -fill $ColorLine set n 1 } set Coordonnees(VraiY) $y set Coordonnees(LastX) $X set Coordonnees(LastY) $Y $K create oval [expr $X-1] [expr $Y-1] [expr $X+1] [expr $Y+1] -width "3" -outline "darkviolet" -fill "darkviolet" -tags [list "" "Tm $x Nb $y" "Affichable" "OligoGraph" "Tm" "TmPlot"] } #La moyenne set XMoyenne [expr $XDebutGraph + [expr $TmMoyenne * $RapportEnX] - [expr $XMin * $RapportEnX]] $K create line $XMoyenne [expr $YFinGraph +1] $XMoyenne $YDebutGraph -tags [list "" "Mean $TmMoyenne" "Affichable" "OligoGraph" "Moyenne" "MoyenneLines"] -fill "red" $K create oval [expr $XMoyenne -1] [expr $YDebutGraph -1] [expr $XMoyenne +1] [expr $YDebutGraph +1] -width "3" -outline "red" -fill "red" -tags [list "" "Mean" "Affichable" "OligoGraph" "Moyenne" "MoyennePlot"] $K create oval [expr $XMoyenne -1] [expr $YFinGraph -1] [expr $XMoyenne +1] [expr $YFinGraph +1] -width "3" -outline "red" -fill "red" -tags [list "" "Mean" "Affichable" "OligoGraph" "Moyenne" "MoyennePlot"] $K create text $XMoyenne [expr $YFinGraph +15] -font "$Police" -text "[format "%.1f" $TmMoyenne]" -fill "yellow" -anchor "center" -tags [list "" "Mean" "OligoGraph" "Moyenne" "MoyennePlot"] #Axe des ordonnees $K create line $XDebutGraph $YFinGraph $XDebutGraph [expr $YDebutGraph -20] -arrow last -tags [list "" "Y (Nb) Axes" "Affichable" "Axes"] -width 2 $K create text $XDebutGraph [expr $YDebutGraph -25] -text "Count" -tags [list "" "Y title" "Affichable" "Edges"] -anchor "center" $K create text [expr $XDebutGraph -10] [expr $YFinGraph] -text "$YMin" -tags [list "" "Nb Min" "Affichable" "Edges"] -anchor "e" $K create text [expr $XDebutGraph -10] [expr $YDebutGraph] -text "$YMax" -tags [list "" "Nb Max" "Affichable" "Edges"] -anchor "e" #Axe des abscisses $K create line $XDebutGraph $YFinGraph [expr $XFinGraph +20] $YFinGraph -arrow last -tags [list "" "X (Tm) Axes" "Affichable" "Axes"] -width 2 $K create text [expr $XFinGraph +25] $YFinGraph -text "Tm \°C" -tags [list "" "X title" "Affichable" "Edges"] -anchor "w" $K create text [expr $XDebutGraph] [expr $YFinGraph +15] -text "$XMin" -tags [list "" "Tm Min" "Affichable" "Edges"] -anchor "center" $K create text [expr $XFinGraph] [expr $YFinGraph +15] -text "$XMax" -tags [list "" "Tm Max" "Affichable" "Edges"] -anchor "center" #La fiche contenant les infos set FicheInfo "" set TextFrame "$w.textframe" set Text "$TextFrame.text" #set ListBoxSBH "$TextFrame.xscroll" set ListBoxSBV "$TextFrame.yscroll" frame $TextFrame -borderwidth "3" -relief "groove" #scrollbar $ListBoxSBH -orient "horizontal" -command "$Text xview" scrollbar $ListBoxSBV -orient "vertical" -command "$Text yview" #text $Text -height "4" -state "disabled" -wrap "word" -font "courier 10" -xscrollcommand "$ListBoxSBH set" -yscrollcommand "$ListBoxSBV set" text $Text -height "4" -state "disabled" -wrap "word" -font "courier 10" -yscrollcommand "$ListBoxSBV set" set Step [LesParametresDuDesign Step "LaValeurMerci"] if {$Step ==""} {set Step 10} set SlidingWindow [LesParametresDuDesign LengthOligo "LaValeurMerci"] if {$SlidingWindow==""} {set SlidingWindow 60} set TmMethode [LesParametresDuDesign TmMethod "LaValeurMerci"] if {$TmMethode ==""} {set TmMethode "NearestNeighbor"} set FicheInfo [list "$NbTmCalcules Tm values measured for $NbSeq sequence(s) submitted\n" "Tm Method: $TmMethode\n" "Sliding Window: $SlidingWindow nt(s)\n" "Step: $Step nt(s)"] foreach element $FicheInfo { $Text configure -state normal $Text insert "end" "$element" $Text configure -state disabled } #Les boutons set ButtonFrame "$w.buttonframe" set ActionButton "$ButtonFrame.button1" set DestroyButton "$ButtonFrame.button2" set LCharpente1 "$ButtonFrame.lcharpente1" set LCharpente2 "$ButtonFrame.lcharpente2" set ZoneButton1 "$ButtonFrame.zbutton1" set ZoneButton2 "$ButtonFrame.zbutton2" set ZoneButton3 "$ButtonFrame.zbutton3" frame $ButtonFrame -borderwidth "3" -relief "groove" button $ActionButton -background "orange" -text "Graph Panel" bind $ActionButton <1> "TmPanel $K" set Texte [format "%-10s" "Panel to change graph display (order,color)"] set_balloon $ActionButton "$Texte" button $DestroyButton -background "red" -text "Close" -command "destroy $w" button $ZoneButton1 -background "green" -text "Area Draw / Clear / Save" bind $ZoneButton1 <1> "MontreLesZonesDeTm $K $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $ZoneButton1 <2> "ClearLesZones $K" bind $ZoneButton1 <3> "SauveLesZonesDeTm $K" set Texte [format "%-10s" "Allow to show (defined), clear or save a Tm area"] set_balloon $ZoneButton1 "$Texte" button $ZoneButton2 -background "green" -text "Range +/-5 / Reset" bind $ZoneButton2 <1> "RangeTm $K $TmMoyenne 5 5 $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $ZoneButton2 <2> "ResetLesZonesDeTm $K" set Texte [format "%-10s" "Allow to display 5°C range, clear saved Tm area"] set_balloon $ZoneButton2 "$Texte" button $ZoneButton3 -background "yellow" -text "Zoom In / Out / Reset" bind $ZoneButton3 <1> "zoom $K 1.25 1.25" bind $ZoneButton3 <2> "zoom $K 0.8 0.8" bind $ZoneButton3 <3> "ResetZoom $K" label $LCharpente1 -background "#808FFF" -relief "groove" label $LCharpente2 -background "#808FFF" -relief "groove" pack $FInfo -fill both -expand true pack $ScroVer -fill y -side right pack $ScroHor -fill x -side bottom pack $K -fill both -side top -expand true pack $ButtonFrame -fill both -side top pack $LCharpente1 -fill both -side left -expand true pack $DestroyButton -side left pack $ZoneButton3 -side left pack $ActionButton -side left pack $ZoneButton1 -side left pack $ZoneButton2 -side left pack $LCharpente2 -fill both -side left -expand true pack $TextFrame -fill both -side top pack $ListBoxSBV -fill y -side right #pack $ListBoxSBH -fill x -side bottom pack $Text -fill both -side top -expand true Raiser $K "TmPlot" Lower $K "Edges" Lower $K "Axes" Lower $K "Masque" $K bind "Affichable" "AfficheInfoBulle $K %x %y Enter" $K bind "Affichable" "AfficheInfoBulle $K %x %y Leave" bind $K "PositionneLesZonesDeTm $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $K "ViseurDeTm $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" bind $K "ViseurDeTm $K %x %y $XDebutGraph $XFinGraph $YDebutGraph $YFinGraph $RapportEnX $XMin" #Binding pour permettre de zoomer en utilisant le 3eme bouton bind $K <3> "zoomMark $K %x %y" bind $K "zoomStroke $K %x %y" bind $K "zoomArea $K %x %y" return "" } proc IllustreToileDevStage {Nom {CreateJpg ""}} { set Rep "[RepertoireDuGenome]/jpg_of_DevStage" if {! [file exists $Rep]} {file mkdir $Rep} set CreateJpg [string equal -nocase $CreateJpg "CreateJpg"] if {$CreateJpg} { package require Img } set FichierImage "$Rep/${Nom}_DevStage.jpg" set K [IllustreDevStage [list $Nom] 3 [Fiches]/SelectedEST] if {$K==""} {return ""} if {$CreateJpg} { regsub "\.canvas$" $K "" w wm iconify . focus $w update idletasks tkwait visibility $K CanvaEnJpg $K $FichierImage destroy $w } return $K } proc IllustreToileTissType {Nom {CreateJpg ""}} { set Rep "[RepertoireDuGenome]/jpg_of_TissType" if {! [file exists $Rep]} {file mkdir $Rep} set CreateJpg [string equal -nocase $CreateJpg "CreateJpg"] if {$CreateJpg} { package require Img } set FichierImage "$Rep/${Nom}_TissType.jpg" set K [IllustreTissueType [list $Nom] {} 3 [Fiches]/SelectedEST] if {$K == ""} {return ""} if {$CreateJpg} { regsub "\.canvas$" $K "" w wm iconify . focus $w update idletasks CanvaEnJpg $K $FichierImage destroy $w } return $K } proc IllustreUnChromosome {Chromosome {LesNoms ""} {Qui OnlyTheBest} {WithoutOrWithMapViewer WithoutMapViewer}} { set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierLocalisation [ChoixDuFichierLocalisationHuman] if {![file exists $FichierLocalisation] || $FichierLocalisation == ""} {return ""} ChargeFichierLocalisation Tab $FichierLocalisation $Chromosome $LesNoms ChargeFoldDesSequences Expression set nChromosome [NumeroDuChromosome $Chromosome] if {$WithoutOrWithMapViewer == "WithMapViewer"} { set FichierMV [ChoixParmi [glob -nocomplain "[HumanGenomeDir]/Localisation/*.md"]] } set FichierBandesCytos "$RepLocalisation/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierContigs "$RepLocalisation/seq_contig.md" if {![file exists $FichierContigs]} { Espionne "$FichierContigs does not exist" return "" } set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 if {$WithoutOrWithMapViewer != "WithMapViewer" || $FichierMV == ""} { set HauteurMax [expr $BordY + $HauteurBoiteChromo + 2*$HauteurBoite + 3*$EcartEntreRepresentations] } else { set HauteurMax [expr $BordY + $HauteurBoiteChromo + 3*$HauteurBoite + 4*$EcartEntreRepresentations] } if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set Chromo [NumeroDuChromosome $Chromosome] ChargeContigsDesChromosomes Contigs $FichierContigs $Chromo set TailleChromo [set Contigs($Chromo,Taille)] set Taille [expr round($TailleChromo*1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set i 0 set PosIni 0 foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set LesContigs [set Contigs($Chromo,LesContigs)] foreach Contig $LesContigs { set LesInfos [set Contigs($Chromo,$Contig)] set Debut [lindex $LesInfos 0] set Fin [lindex $LesInfos 1] set Sens [lindex $LesInfos 2] if {$Sens == 0} {continue} set Version [lindex $LesInfos 3] set ColorFill [CouleurDuSens $Sens] if {$Sens == "-"} { set PosYM [expr $PosYMax + $HauteurBoite] set PosYm [expr $PosYMin + $HauteurBoite] } elseif {$Sens == "+"} { set PosYM [expr $PosYMax - $HauteurBoite] set PosYm [expr $PosYMin - $HauteurBoite] } else { set PosYM $PosYMax set PosYm $PosYMin } set PosXMin [expr $BordX + ($Debut*$Facteur)] set PosXMax [expr $BordX + ($Fin*$Facteur)] $K create rectangle $PosXMin $PosYm $PosXMax $PosYM -outline white -fill $ColorFill -tags [list "$Contig" "$Debut" "$Fin" "$Sens" "$Version" "Contig"] } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "red" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "red" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "Contigs" -font "$PoliceTitre" -fill "red" set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set Tab($FichierLocalisation,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set Tab($FichierLocalisation,Chromosome,$Chromosome,$Nom)] { set Debut [lindex $LInfo 10 ] set Fin [lindex $LInfo 11] set Sens [lindex $LInfo 12] set Info [lindex $LInfo 20] if {($Qui == "OnlyTheBest" && $Info == "") || $Sens == 0} {continue} set Fold [set Expression($Nom)] lappend LInfo $Fold lappend LInfo "Box" set ColorFill [CouleurDuFold $Fold] set PosXMin [expr $BordX + ($Debut*$Facteur)] set PosXMax [expr $BordX + ($Fin*$Facteur)] if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} $K create oval $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "orange" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "orange" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "My sequences" -font "$PoliceTitre" -fill "orange" } if {$WithoutOrWithMapViewer == "WithMapViewer" && $FichierMV != ""} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] ChargeFichierMapViewer TabMV $FichierMV $nChromosome set NameFichierMV [file tail $FichierMV] set i 0 if {[info exists TabMV($NameFichierMV,Chromosome,$nChromosome,LesElements)]} { foreach Element [set TabMV($NameFichierMV,Chromosome,$nChromosome,LesElements)] { if {![info exists TabMV($NameFichierMV,Chromosome,$nChromosome,Element,$Element,LesLocalisations)]} {continue} set LesRegionsDeLEl [set TabMV($NameFichierMV,Chromosome,$nChromosome,Element,$Element,LesLocalisations)] if {5 < $i} {set i 0} foreach UneRegionDeLEl [lsort -integer -index 5 -decreasing $LesRegionsDeLEl] { set SensEl [lindex $UneRegionDeLEl 6] if {$SensEl == 0} {continue} set WhoIsIt [lindex $UneRegionDeLEl 0] set LesInfos [lindex $UneRegionDeLEl 1] set DebutEl [lindex $UneRegionDeLEl 3] set FinEl [lindex $UneRegionDeLEl 4] set ColorFill [CouleurDuSens $SensEl] set PosYM [expr $PosYMax - $i*$HauteurBoite] set PosYm [expr $PosYMin - $i*$HauteurBoite] set PosXMin [expr $BordX + ($DebutEl*$Facteur)] set PosXMax [expr $BordX + ($FinEl *$Facteur)] $K create rectangle $PosXMin $PosYm $PosXMax $PosYM -outline "dark$ColorFill" -fill $ColorFill -tags [list "$WhoIsIt" "$LesInfos" "$DebutEl" "$FinEl" "$SensEl" "MapViewer"] } incr i } } $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*2/3] -text "MapViewer $NameFichierMV" -font "$PoliceTitre" -fill black if {[info exists TabMV]} {unset TabMV} } LesNomsEnStock $K $LesNoms $K bind "Contig" "DevoileLesContigs $K %x %y Enter" $K bind "Contig" "DevoileLesContigs $K %x %y Leave" $K bind "Box" "DevoileLesBoites $K %x %y Enter" $K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" $K bind "Contig" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" $K bind "Box" <1> "AfficheFicheInfo $K" if {$WithoutOrWithMapViewer == "WithMapViewer"} { $K bind "MapViewer" "DevoileLesRegions $K %x %y Enter" $K bind "MapViewer" "DevoileLesRegions $K %x %y Leave" } regsub {\.canvas} $K "" w set B [BoutonneLaFenetre $w "WithMapViewer/WithoutMapViewer\nOnlyBestLoc/All"] bind $B <1> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] $Qui WithMapViewer" bind $B <2> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] $Qui WithoutMapViewer" bind $B "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] OnlyTheBest $WithoutOrWithMapViewer" bind $B "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] All $WithoutOrWithMapViewer" set C [BoutonneLaFenetre $w "Histogramm"] bind $C <1> "ChoixHistogramme" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc IllustreZScoreDesGeneOntologyDesClusters {FichierGO {LesClusters ""} {LesTypesDeGO ""} {GOChoisiOuAll GOChoisi} {ZScoreMin 1} {NiveauGOMin 2}} { set FichierO2C2A2D2E "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" if {![file exists $FichierO2C2A2D2E]} {return} if {![file exists $FichierGO ]} {return} if {$LesClusters == ""} {set LesClusters [MorceauxChoisis [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E LesClusters]]} if {$LesTypesDeGO == ""} {set LesTypesDeGO [MorceauxChoisis [InterrogeGeneOntology $FichierGO LesTypes]]} if {$GOChoisiOuAll == "GOChoisi"} { set FichierChoosenGO "[RepertoireDuGenome]/fiches/ChoosenOntology" ChargeChoosenGeneOntology TabGOChoisi $FichierChoosenGO set LesGO [set TabGOChoisi($FichierChoosenGO,LesGOChoisis)] } else { set LesGO [Onto TousLesGO] } foreach GO $LesGO {set TabGOSelectionne($GO) 1} set LesCouleurs [GammeDeCouleursRVB_CHALMEL [llength $LesTypesDeGO]] foreach Couleur $LesCouleurs Type $LesTypesDeGO {set TabTypeOK($Type) $Couleur} set Tab(LesGO) {} foreach Cluster $LesClusters { Espionne $Cluster if {![info exists Tab($Cluster,LesGO)]} {set Tab($Cluster,LesGO) {}} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierO2C2A2D2E Cluster $Cluster LesNoms] { foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [Onto $GO Type] if {![info exists TabTypeOK($Type)]} {continue} if {[NiveauMinDuGO $GO $Type] < $NiveauGOMin} {continue} if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} if {![info exists Tab($Nom,$GO)] && [info exists TabGOSelectionne($GO)]} { set Tab($Nom,$GO) 1 incr Tab($GO,n) incr Tab($Cluster,$GO,n) lappend Tab($Cluster,LesGO) $GO lappend Tab(LesGO) $GO } foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { if {[NiveauMinDuGO $Ancetre] < $NiveauGOMin} {continue} if {![info exists Tab($Ancetre,n) ]} {set Tab($Ancetre,n) 0} if {![info exists Tab($Cluster,$Ancetre,n)]} {set Tab($Cluster,$Ancetre,n) 0} if {![info exists Tab($Nom,$Ancetre)] && [info exists TabGOSelectionne($Ancetre)]} { set Tab($Nom,$Ancetre) 1 incr Tab($Ancetre,n) incr Tab($Cluster,$Ancetre,n) lappend Tab($Cluster,LesGO) $Ancetre lappend Tab(LesGO) $Ancetre } } } } } set LesHisto {} set N [llength [set Tab(LesGO)]] foreach Cluster $LesClusters { set R [llength [set Tab($Cluster,LesGO)]] set LesValeurs {} foreach GO [lsort -unique [set Tab($Cluster,LesGO)]] { set n [set Tab($GO,n) ] set r [set Tab($Cluster,$GO,n)] set ZScore [ZScore $r $R $n $N] if {$ZScore < $ZScoreMin} {continue} set ZScore [expr ($r * 1.0 / $R) / ($n * 1.0 / $N)] #if {$r == 1} {continue} set Type [Onto $GO Type] set Def [lindex [Onto $Type $GO LesDefinitions] 0] set Couleur [set TabTypeOK($Type)] lappend LesValeurs [list "$Def $Type $GO $r $R $n $N [format "%.1f" $ZScore]" $Couleur $ZScore 0] } if {$LesValeurs == {}} {continue} set LHisto [list "Cluster $Cluster"] foreach LaValeur [lsort -index 2 -real -decreasing $LesValeurs] {lappend LHisto $LaValeur} lappend LesHisto $LHisto } if {$LesHisto == {}} {return} IllustreLesHistogrammes $LesHisto return } proc IlpTree {{Qui ""} {Quoi ""} {Fichier ""}} { global IlpTree if {$Fichier==""} { set Fichier "[HomeRipp]/rules.txt"} regsub "\.txt$" $Fichier "" FichierTsv append FichierTsv ".tsv" if {[info exists IlpTree($Qui,$Quoi)]} { return $IlpTree($Qui,$Quoi) } if {[info exists IlpTree("EstCharge")]} { return "" } set IlpTree("EstCharge") 1 set LesHeaders {} set Min 999. foreach Ligne [LesLignesDuFichier $Fichier] { regsub -all "\t\t" $Ligne "\t" Ligne set LesMots [split $Ligne "\t"] if {$LesHeaders=={}} { set LesHeaders [lrange $LesMots 1 end-1] continue } set KL [lindex $LesMots 0] set LesValeurs [lrange $LesMots 1 end-1] foreach V $LesValeurs KC $LesHeaders { # Espionne "kl=$KL= kc=$KC= $V" if {$V=="N"} { set V 0.0 } if {$V==""} {continue; set V $IlpTree($KC,$KL) } set D [expr 1. - $V] if {$D!=0.0} { set Min [Mini $Min $D] } set IlpTree($KL,$KC) $D } } set IlpTree(ListOf,Headers) $LesHeaders set LesLignes {} lappend LesLignes [join $LesHeaders "\t"] foreach KL $LesHeaders { set LaLigne {} foreach KC $LesHeaders { if { ! [info exists IlpTree($KL,$KC)]} { set IlpTree($KL,$KC) $IlpTree($KC,$KL) } set D $IlpTree($KL,$KC) # if {$D!=0.0} { set D [expr $D - $Min*0.8]} lappend LaLigne [format "%5.3f" $D] } lappend LesLignes [join $LaLigne "\t"] } if {$Qui=="GetTreeFile" || $Qui=="GetTsv"} { set TsvFile [SauveLesLignes $LesLignes dans $FichierTsv] if {$Qui=="GetTsv"} {return $TsvFile } set PhFile [ImAnnoTissueTree $TsvFile] return $PhFile } return [IlpTree $Qui $Quoi] } proc ImAnnoImage {} { set Image [ContenuDuFichier "http://zoom.gwdg.de/?fif=038/EG00002617_00007B.fpx&obj=iip,1.0&wid=501&hei=802&rgn=0.3125,0.3125,0.12500000,0.12500000&lng=en_US&vtrx=1&cvt=jpeg"] return [Sauve $Image dans "[HomeRipp]/ImAnnoImage.jpg"] } proc ImAnnoRefPour {Nom} { global ListOfRetChipAnnotated set UrlGenoretServer [GenoretServer] if { ! [info exists ListOfRetChipAnnotated]} { set ListOfRetChipAnnotated [HttpGetUrl "$UrlGenoretServer?Genoret&ListOfRetChipAnnotated"] } set R "" foreach Syno [RecupereSynonyms $Nom "AvecGN" " "] { if {[lsearch $ListOfRetChipAnnotated $Syno] >= 0} { set R $Syno ; break } } if {$R ne ""} { set Ref "$R" } else { set Ref "-" } return $Ref } proc ImAnnoTissueTree {{MatrixFile ""}} { package require fastme if {$MatrixFile==""} { set MatrixFile "[HomeRipp]/GenoretWww/ImAnno/ImAnnoEar/CorrelationMatrix.tsv" } set PhFile $MatrixFile regsub {\.tsv} $PhFile "" PhFile append PhFile ".ph" set LesLignes [LesLignesDuFichier $MatrixFile] set LesDistances {} foreach Ligne $LesLignes { if { ! [info exists LesNoms]} { regsub -all {\-} $Ligne " " Ligne set LesNoms [split $Ligne "\t"] continue } LConcat LesDistances [split $Ligne "\t"] } Espionne [llength $LesNoms] Espionne [llength $LesDistances] set Ph [fastme $LesNoms $LesDistances] return [Sauve $Ph dans $PhFile] } proc ImageCmd {args} { if {!$::hv_showImages} { return ::hv_smgray } set fn [lindex $args 0] if {[info exists ::hv_OldImages($fn)]} { set ::hv_Images($fn) $::hv_OldImages($fn) unset ::hv_OldImages($fn) return $::hv_Images($fn) } if {[catch {image create photo -file $fn} img]} { return ::hv_smgray } if {[image width $img]*[image height $img]>20000} { global ::hv_BigImages set b [image create photo -width [image width $img] -height [image height $img]] set ::hv_BigImages($b) $img set img $b after idle "Hv_MoveBigImage $b" } set ::hv_Images($fn) $img return $img } proc ImageDirectory {aImageDirect} { global DejaVuDir_$aImageDirect if {[info exists DejaVuDir_$aImageDirect]} {return $aImageDirect} set DejaVuDir_$aImageDirect 1 image create photo $aImageDirect -data { R0lGODdhEAAQAPIAAAAAAHh4eLi4uPj4APj4+P///wAAAAAAACwAAAAAEAAQAAADPVi63P4w LkKCtTTnUsXwQqBtAfh910UU4ugGAEucpgnLNY3Gop7folwNOBOeiEYQ0acDpp6pGAFArVqt hQQAO/// } return $aImageDirect } proc ImageExpand {image coef} { # check coef if {$coef < 1.0} { error "bad coef \"$coef\": should not be less than 1.0" } if {$coef - int($coef) < 1.e-4} { return [optim $image [expr {int($coef)}]] } # get the old image content set width [image width $image] set height [image height $image] if {$width * $height == 0} { error "bad image" } # create corresponding planes for {set y 0} {$y < $height} {incr y} { set r:row {} set g:row {} set b:row {} for {set x 0} {$x < $width} {incr x} { foreach {r g b} [$image get $x $y] break foreach c {r g b} { lappend $c:row [set $c] } } foreach c {r g b} { lappend $c:data [set $c:row] } } # compute the new image content set Width [expr {round($width * $coef)}] set Height [expr {round($height * $coef)}] set ey 0 set y2 0 set cy2 $Height for {set Y 0} {$Y < $Height} {incr Y} { set r:Row {} set g:Row {} set b:Row {} # y1 is the top coordinate in the old image set y1 $y2 set cy1 [expr {$Height - $cy2}] incr ey $height set y2 [expr {$ey / $Height}] set cy2 [expr {$ey % $Height}] if {$y1 == $y2} { set cy1 $cy2 } set ex 0 set x2 0 set cx2 $Width for {set X 0} {$X < $Width} {incr X} { set x1 $x2 set cx1 [expr {$Width - $cx2}] incr ex $width set x2 [expr {$ex / $Width}] set cx2 [expr {$ex % $Width}] if {$x1 == $x2} { set cx1 $cx2 } # compute pixel foreach c {r g b} { set $c 0; set _$c 0 } for {set y $y1} {$y <= $y2} {incr y} { # compute y coef switch $y $y1 { set cy $cy1 } $y2 { set cy $cy2 } default { set cy $height } if {$cy == 0} { continue } if {$cy > $height} { set cy $height } for {set x $x1} {$x <= $x2} {incr x} { # compute x coef switch $x $x1 { set cx $cx1 } $x2 { set cx $cx2 } default { set cx $width } if {$cx == 0} { continue } if {$cx > $width} { set cx $width } # weight each initial pixel by cx & cy set cxy [expr {$cx * $cy / double($width) / $height}] foreach c {r g b} { set comp [lindex [set $c:data] $y $x] incr $c [expr {round($comp * $cxy)}] set _$c [expr {[set _$c] + $cxy}] } } } set _ {} foreach c {r g b} { set comp [set $c] if {$comp > 255} { set comp 255 } lappend $c:Row $comp lappend _ [set _$c] } } foreach c {r g b} { lappend $c:Data [set $c:Row] } } # crisping for {set Y 0} {$Y < $Height} {incr Y} { set Row {} for {set X 0} {$X < $Width} {incr X} { if {$X == 0 || $X == $Width - 1 || $Y == 0 || $Y == $Height - 1} { foreach c {r g b} { set $c [lindex [set $c:Data] $Y $X] } } else { foreach c {r g b} { set c00 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X - 1}]] set c01 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X - 0}]] set c02 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X + 1}]] set c10 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X - 1}]] set c11 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X - 0}]] set c12 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X + 1}]] set c20 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X - 1}]] set c21 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X - 0}]] set c22 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X + 1}]] set cc [expr {int(1.4 * $c11 - 0.05 * ($c00 + $c01 + $c02 + $c10 + $c12 + $c20 + $c21 + $c22))}] if {$cc < 0} { set cc 0 } if {$cc > 255} { set cc 255 } set $c $cc } } lappend Row [format #%02x%02x%02x $r $g $b] } lappend Data $Row } # create the new image set Image [image create photo] # fill the new image $Image put $Data # return the new image return $Image } proc ImageExpand2 {image coef} { # check coef if {$coef < 1.0} { error "bad coef \"$coef\": should not be less than 1.0" } if {$coef - int($coef) < 1.e-4} { return [optim $image [expr {int($coef)}]] } # get the old image content set width [image width $image] set height [image height $image] if {$width * $height == 0} { error "bad image" } # create corresponding planes for {set y 0} {$y < $height} {incr y} { set r:row {} set g:row {} set b:row {} set t:row {} for {set x 0} {$x < $width} {incr x} { foreach {r g b} [$image get $x $y] break set t [$image transparency get $x $y] set t [expr {$t * 256}] foreach c {r g b t} { lappend $c:row [set $c] } } foreach c {r g b t} { lappend $c:data [set $c:row] } } # compute the new image content set Width [expr {round($width * $coef)}] set Height [expr {round($height * $coef)}] set ey 0 set y2 0 set cy2 $Height for {set Y 0} {$Y < $Height} {incr Y} { set r:Row {} set g:Row {} set b:Row {} set t:Row {} # y1 is the top coordinate in the old image set y1 $y2 set cy1 [expr {$Height - $cy2}] incr ey $height set y2 [expr {$ey / $Height}] set cy2 [expr {$ey % $Height}] if {$y1 == $y2} { set cy1 $cy2 } set ex 0 set x2 0 set cx2 $Width for {set X 0} {$X < $Width} {incr X} { set x1 $x2 set cx1 [expr {$Width - $cx2}] incr ex $width set x2 [expr {$ex / $Width}] set cx2 [expr {$ex % $Width}] if {$x1 == $x2} { set cx1 $cx2 } # compute pixel foreach c {r g b t} { set $c 0; set _$c 0 } for {set y $y1} {$y <= $y2} {incr y} { # compute y coef switch $y $y1 { set cy $cy1 } $y2 { set cy $cy2 } default { set cy $height } if {$cy == 0} { continue } if {$cy > $height} { set cy $height } for {set x $x1} {$x <= $x2} {incr x} { # compute x coef switch $x $x1 { set cx $cx1 } $x2 { set cx $cx2 } default { set cx $width } if {$cx == 0} { continue } if {$cx > $width} { set cx $width } # weight each initial pixel by cx & cy set cxy [expr {$cx * $cy / double($width) / $height}] foreach c {r g b t} { set comp [lindex [set $c:data] $y $x] incr $c [expr {round($comp * $cxy)}] set _$c [expr {[set _$c] + $cxy}] } } } set _ {} foreach c {r g b t} { set comp [set $c] if {$comp > 255} { set comp 255 } lappend $c:Row $comp lappend _ [set _$c] } } foreach c {r g b t} { lappend $c:Data [set $c:Row] } } # crisping for {set Y 0} {$Y < $Height} {incr Y} { set Row {} set tRow {} for {set X 0} {$X < $Width} {incr X} { if {$X == 0 || $X == $Width - 1 || $Y == 0 || $Y == $Height - 1} { foreach c {r g b} { set $c [lindex [set $c:Data] $Y $X] } } else { foreach c {r g b t} { set c00 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X - 1}]] set c01 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X - 0}]] set c02 [lindex [set $c:Data] [expr {$Y - 1}] [expr {$X + 1}]] set c10 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X - 1}]] set c11 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X - 0}]] set c12 [lindex [set $c:Data] [expr {$Y + 0}] [expr {$X + 1}]] set c20 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X - 1}]] set c21 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X - 0}]] set c22 [lindex [set $c:Data] [expr {$Y + 1}] [expr {$X + 1}]] set cc [expr {int(1.4 * $c11 - 0.05 * ($c00 + $c01 + $c02 + $c10 + $c12 + $c20 + $c21 + $c22))}] if {$cc < 0} { set cc 0 } if {$cc > 255} { set cc 255 } set $c $cc } } lappend Row [format #%02x%02x%02x $r $g $b] lappend tRow [expr {round($t)}] } lappend Data $Row lappend tData $tRow } # create the new image set Image [image create photo] # fill the new image $Image put $Data # set transparency for {set Y 0} {$Y < $Height} {incr Y} { for {set X 0} {$X < $Width} {incr X} { set t [lindex $tData $Y $X] set t [expr {$t > 128 ? 1 : 0}] $Image transparency set $X $Y $t } } # return the new image return $Image } proc ImageFile {aImageFile} { global DejaVuFile_$aImageFile if {[info exists DejaVuFile_$aImageFile]} {return $aImageFile} set DejaVuFile_$aImageFile 1 image create photo $aImageFile -data { R0lGODdhEAAQAPIAAAAAAHh4eLi4uPj4+P///wAAAAAAAAAAACwAAAAAEAAQAAADPkixzPOD yADrWE8qC8WN0+BZAmBq1GMOqwigXFXCrGk/cxjjr27fLtout6n9eMIYMTXsFZsogXRKJf6u P0kCADv/ } return $aImageFile } proc ImageGroupeDom {{directory ""} TypeDeDomain {position ""} {option ""}} { #modifie faire le boulot pour les pfam et les domains et autres informations.... set Concat "" set Rep "" #creation d'un repertoire #Ajoute le cas DomPfam!! Espionne "ImageGroupeDom TypeDomain: $TypeDeDomain" switch $TypeDeDomain { "pfam" { if { ! [file exists "GroupeDomain/PfamInformation"]} { File mkdir [RepertoireDuGenome]/GroupeDomain/PfamInformation } #set Concat "ConcatPfam" set Rep "GroupeDomain/PfamInformation" if {$directory==""} {set directory [RepertoireDuGenome]/GPfam} } "domain" { if { ! [file exists "GroupeDomain/DomainInformation"]} { File mkdir [RepertoireDuGenome]/GroupeDomain/DomainInformation } #set Concat "ConcatDomain" set Rep "GroupeDomain/DomainInformation" if {$directory==""} {set directory [RepertoireDuGenome]/GDomain} } "region" { if { ! [file exists "GroupeDomain/RegionInformation"]} { File mkdir [RepertoireDuGenome]/GroupeDomain/RegionInformation } #set Concat "ConcatDomain" set Rep "GroupeDomain/RegionInformation" if {$directory==""} {set directory [RepertoireDuGenome]/GRegion} } "DomPfam" { if { ! [file exists "GroupeDomain/DomPfamInformation"]} { File mkdir [RepertoireDuGenome]/GroupeDomain/DomPfamInformation } set Rep "GroupeDomain/DomPfamInformation" if {$directory==""} {set directory [RepertoireDuGenome]/GDomPfam} } } set r [glob -directory $directory *] foreach fichier $r { #faire un test si contien color alors continue if {[regexp {PUZ[0-9]+Color} $fichier] || [regexp {PUZ[0-9]+Length} $fichier] || [regexp {PUZ[0-9]+Tab} $fichier] || [regexp {PUZ[0-9]+DomMax} $fichier]} { continue } Espionne "-->$fichier" #recupere que le nom du fichier set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if { ! [file exists "[RepertoireDuGenome]/$Rep/$f"]} { File mkdir [RepertoireDuGenome]/$Rep/$f } #faut sauvegarder dans ce repertoire les images et les py mais sous quel nom je gere les groupes avec des chiffres? set mes_lignes [LesLignesDuFichier $fichier] set numgroupe 1 foreach ligne $mes_lignes { if { ! [file exists "[RepertoireDuGenome]/$Rep/$f/$numgroupe"]} { File mkdir [RepertoireDuGenome]/$Rep/$f/$numgroupe } set proteins [split [lindex [split $ligne "="] 1] ";"] foreach protName $proteins { Espionne "La protein en cours: $protName" SchematicViewNew $f $protName $TypeDeDomain $option $position if { [file exists "[RepertoireDuGenome]/macsimXml/$f.aj"]} { set fileMacsim "[RepertoireDuGenome]/macsimXml/$f.aj" } else { set fileMacsim "[RepertoireDuGenome]/macsimXml/$f" } #Espionne "apres les if else avant la recherche d'orga" #recuperation de l'organisme de la sequence set OS [OrgaDuAccess $protName] if {$OS=="Inconnu inconnu"} { set OS [FromMacsims $fileMacsim $protName "OrganismLong"] } if {$OS=="" || $OS=="Inconnu inconnu" || $OS==" "} { set OS [getOrgaTfasDesCopains "" $f $protName] } #ajouter l'espece dans le nom du fichier switch $TypeDeDomain { "pfam" { set protName ${protName}Pfam } "domain" { set protName ${protName}Domain } "region" { set protName ${protName}Region } "DomPfam" { set protName ${protName}DomPfam } } if {$position == "position"} { append protName "P" } set newProtname "$OS-$protName" #Espionne "------> scriptpython avec $protName.py" exec python $protName.py #Espionne "mv des images creer" exec mv [RepertoireDuGenome]/$protName.py [RepertoireDuGenome]/$Rep/$f/$numgroupe/$newProtname exec mv /home/luudao/www/ms2phdb/tmp/$protName.png [RepertoireDuGenome]/$Rep/$f/$numgroupe/$newProtname.png } incr numgroupe } } } proc ImagePC {image percent} { set deno [gcd $percent 100] set zoom [expr {$percent/$deno}] set subsample [expr {100/$deno}] set im1 [image create photo] $im1 copy $image -zoom $zoom set im2 [image create photo] $im2 copy $im1 -subsample $subsample image delete $im1 return im2 } proc ImagePartOf {aImageSubclassOf} { global DejaVuPartOf_$aImageSubclassOf if {[info exists DejaVuPartOf_$aImageSubclassOf]} {return $aImageSubclassOf} set DejaVuPartOf_$aImageSubclassOf 1 set FileGIF "[GODBDir]/SubclassOf.gif" if {![file exists $FileGIF]} {return} image create photo $aImageSubclassOf -file $FileGIF return $aImageSubclassOf } proc ImageShrink3 {Image coef {TargetImage ""}} { # check coef if {$coef > 1.0} { error "bad coef \"$coef\": should not be greater than 1.0" } # get the old image content set Width [image width $Image] set Height [image height $Image] if {$Width==0 || $Height==0} { error "bad image" } if {$TargetImage eq ""} { # create new image set image [image create photo] } else { set image $TargetImage } if {abs($coef - 1.0) < 1.e-4} { $image copy $Image return $image } set Factor [expr {double($Width)*$Height}] # Extract the data from the source - experiment indicates that this is the fastest way foreach row [$Image data] { set rdata {} foreach pixel $row { lappend rdata [scan $pixel "#%2x%2x%2x"] } lappend DATA $rdata } # compute the new image content set width [expr {round($Width * $coef)}] set height [expr {round($Height * $coef)}] set ey 0 set Y2 0 set cy2 $height for {set y 0} {$y < $height} {incr y} { # Y1 is the top coordinate in the old image set Y1 $Y2 set cy1 [expr {$height - $cy2}] incr ey $Height set Y2 [expr {$ey / $height}] set cy2 [expr {$ey % $height}] if {$Y1 == $Y2} { set cy1 $cy2 } set ex 0 set X2 0 set cx2 $width set row {} for {set x 0} {$x < $width} {incr x} { set X1 $X2 set cx1 [expr {$width - $cx2}] incr ex $Width set X2 [expr {$ex / $width}] set cx2 [expr {$ex % $width}] if {$X1 == $X2} { set cx1 $cx2 } # compute pixel set r 0.0 set g 0.0 set b 0.0 for {set Y $Y1} {$Y <= $Y2} {incr Y} { # compute y coef if {$Y == $Y1} { if {$cy1 == 0} continue set cy [expr {$cy1>$Height ? $Height : $cy1}] } elseif {$Y == $Y2} { if {$cy2 == 0} continue set cy [expr {$cy2>$Height ? $Height : $cy2}] } else { set cy $height } for {set X $X1} {$X <= $X2} {incr X} { # compute x coef if {$X == $X1} { if {$cx1 == 0} continue set cx [expr {$cx1>$Width ? $Width : $cx1}] } elseif {$X == $X2} { if {$cx2 == 0} continue set cx [expr {$cx2>$Width ? $Width : $cx2}] } else { set cx $width } # weight each initial pixel by cx & cy set cxy [expr {$cx * $cy / $Factor}] set pixel [lindex $DATA $Y $X] set r [expr {$r+([lindex $pixel 0] * $cxy)}] set g [expr {$g+([lindex $pixel 1] * $cxy)}] set b [expr {$b+([lindex $pixel 2] * $cxy)}] } } lappend row [format "#%02x%02x%02x" [expr {$r>255.0 ? 255 : round($r)}] [expr {$g>255.0 ? 255 : round($g)}] [expr {$b>255.0 ? 255 : round($b)}]] } lappend data $row } # fill the new image $image blank $image put $data # return the new image return $image } proc ImageSubclassOf {aImagePartOf} { global DejaVuSubclassOf_$aImagePartOf if {[info exists DejaVuSubclassOf_$aImagePartOf]} {return $aImagePartOf} set DejaVuSubclassOf_$aImagePartOf 1 set FileGIF "[GODBDir]/PartOf.gif" if {![file exists $FileGIF]} {return} image create photo $aImagePartOf -file $FileGIF return $aImagePartOf } proc Imap {} { package require imap4 package require tls #set user luc.moulinier set user raymond.ripp #set pass "#Derry5#" set pass "bmifb123" #set server mailserver.u-strasbg.fr set server 130.79.200.160 set FOLDER "INBOX.Labo" # Connect to server set ::imap4::use_ssl 1 set imap [::imap4::open $server 993] puts "imap $imap" ::imap4::login $imap $user $pass puts "login done" set Lfold [::imap4::folders $imap -inline] puts "[join $Lfold \n]" ::imap4::select $imap $FOLDER # Output all the information about that mailbox foreach info [::imap4::mboxinfo $imap] { puts "$info -> [::imap4::mboxinfo $imap $info]" } # fetch 3 records inline set fields {from: to: subject: size text fintextewwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww} foreach rec [::imap4::fetch $imap 2:5 -inline {*}$fields] { puts -nonewline "#[incr idx])" for {set j 0} {$j<[llength $fields]} {incr j} { puts "\t[lindex $fields $j] [lindex $rec $j]" } } # Show all the information available about the message ID 1 puts "Available info about message 1: [::imap4::msginfo $imap 1]" # Use the capability stuff puts "Capabilities: [::imap4::isableto $imap]" puts "Is able to imap4rev1? [::imap4::isableto $imap imap4rev1]" # Cleanup ::imap4::cleanup $imap return } proc ImgDeNom {t fm sz md ang} { global FontAsc if {! [info exists FontAsc]} {LoadFontesAscii} if {$t eq ""} {return} set Lt [split $t ""] set x0 0 set dst [image create photo] foreach c $Lt { if {![info exists FontAsc($fm,$sz,$md,$c)]} {set c " "} set phi [image create photo -data $FontAsc($fm,$sz,$md,$c)] set wdi [expr {[image width $phi]-3}] set hgi [image height $phi] set i $x0 for {set p 3} {$p < $wdi} {incr p} { for {set j 1} {$j < $hgi} {incr j} { if {! [$phi transparency get $p $j]} { $dst put [eval format #%02x%02x%02x [$phi get $p $j]] -to $i $j } } incr i } incr x0 [expr {$wdi-3}] } OpacifieImage $dst white RotateImage $dst $ang OpacifieImage $dst white 1 return $dst } proc ImgDeNomBLT {txt fm sz md angle} { package require BLT # Pour arbre radial, on se met en bold, un point c'est tout ! set md "bold" if {$angle > 90. && $angle < 270.} {set jus right} {set jus left} set fm [string trim $fm] regsub -all " " $fm "" fm set fmt "*-family-mode-R-Normal-*-size-*" regsub "family" $fmt "$fm" fmt regsub "mode" $fmt "$md" fmt regsub "size" $fmt "$sz" fmt set i 0 while {1} { if {! [::blt::bitmap exists "BltImg$i"]} {break} incr i } ::blt::bitmap compose "BltImg$i" "$txt" -font "$fmt" -rotate $angle return "BltImg$i" } proc ImgDeNomPIX {f sz w h txt angle} { set t2 [image create photo] set d [pixane create -tkphoto $t2] pixane resize $d $w $h pixane blank $d pixane color $d black pixane text $d [expr {$w/2}] [expr {$h/2}] -text $txt -font $f -size $sz -align center -valign middle -angle $angle set bon [RogneImage $t2] # OpacifieImage $bon white 0 pixane delete $d return $bon } proc ImprimeLeFichier {Fichier {Commande ""}} { global CommandePrint Gs "Ignorer" if { ! [info exists CommandePrint]} { set CommandePrint "renoir" } if {$Commande==""} { set Commande $CommandePrint } set CommandePrint "$Commande $Fichier" if {[OuiOuNon "$CommandePrint\n\nDo You want to edit this print command ?" 0]} { set CommandePrint [Entre $CommandePrint] } eval exec $CommandePrint return $Fichier } proc ImprimeLeTexte {Texte {Commande ""}} { set Fichier "[TmpFile].txt" set Fichier [Sauve $Texte dans $Fichier] if {$Fichier==""} { FaireLire "I couldn't create $Fichier for printing" return "" } if {$Commande==""} { set Commande "renoir" } return [ImprimeLeFichier $Fichier $Commande] } proc ImprimeLesOrgaEtSesPlaces {} { global RepertoireDuGenome NousAllonsAuBoulot foreach Fichier [glob "$RepertoireDuGenome/fiches/orgaetsesplaces.*"] { set Texte "\n$Fichier\n\n[ContenuDuFichier $Fichier]" set FichierTmp "tmp.[file tail $Fichier]" Sauve $Texte dans $FichierTmp eval exec renoir -l $FichierTmp } OnRevientDuBoulot exit } proc Improvement {AId n {Step 0}} { global Abr sum set PAD [set Abr($AId,PAD)] set t [set Abr(Arbre,$AId)] foreach e [$t children $n] { Improvement $AId $e $Step } puts stderr "$n" set Rep [NewMaxLR $AId $n] if {1 && $Rep} { AngleLRAncetres $AId $n set tmp $sum set sum [AjusteAngles2 $AId $n] puts [format "===> dsum %5.3f sum %5.3f | %s" [expr {$sum-$tmp}] $sum $n] puts "" if {$Step && ! [$t isleaf $n]} { $PAD delete all RetraceToutCart $AId root # Entre JAttends } } return $sum } proc InLineOptions {args} { global DefautsPipe global Defauts LesDefautsDuPipe LesDefauts if {[llength $args] == 0} {return} set loptions [array names DefautsPipe] set largs [split [string trim [lindex $args 0]] " "] foreach e $largs { set ov [split [string range $e 1 end] "="] if {[lsearch $loptions [lindex $ov 0]] == -1} {continue} LesDefautsDuPipe [lindex $ov 0] [lindex $ov 1] } return } proc InStaf {Position Org Chr {FROMWHERE ""}} { global LocInStaf if {$FROMWHERE==""} { set FROMWHERE "Ucsc" } set Foc "$FROMWHERE$Org$Chr" if { ! [info exists LocInStaf($Foc)]} { if {$FROMWHERE=="Ucsc"} { set LocInStaf($Foc) [LocUcStaf ListOf$Org$Chr "StartEndName"] } if {$FROMWHERE=="Affy"} { set LocInStaf($Foc) [LocAffy ListOf$Org$Chr "StartEndName"] } } set D 0 set F [expr [llength $LocInStaf($Foc)] - 1] if {$F<$D} { return "Error NoStartEndNameAvailable" } set SENDeb [lindex $LocInStaf($Foc) 0] set SENFin [lindex $LocInStaf($Foc) end] if {$SENDeb==""||$SENFin==""} { return "Error NoGenome" } if {$Position<[lindex $SENDeb 0] || $Position>[lindex $SENFin 1]} { return "Outside $SENDeb $SENFin" } set OldAvant $SENDeb set OldApres $SENFin while 1 { #puts "$OldAvant $OldApres" #puts "$D $F" if {$F<$D} { #puts "$F $D" return "Between $OldAvant $OldApres" } set M [expr ($D+$F)/2] set SEN [lindex $LocInStaf($Foc) $M] #puts "$M $SEN" set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$Start<=$Position && $Position<=$End} { set LesIns [list "In $SEN"] #Espionne "$M $SEN" set MM $M while 1 { incr MM -1 set SEN [lindex $LocInStaf($Foc) $MM] set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$End==""} { break } if {$Position>$End} { break } if {$Position<$Start || $End<$Position} { continue } #Espionne "$MM $SEN" lappend LesIns "In $SEN" } set MM $M while 1 { incr MM 1 set SEN [lindex $LocInStaf($Foc) $MM] set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$Start==""} { break } if {$Position<$Start} { break } if {$Position<$Start || $End<$Position} { continue } #Espionne "$MM $SEN" lappend LesIns "In $SEN" } set LesIns [lsort -unique $LesIns] return [join $LesIns " "] } if {$D==$F} { if {$Position<$Start} {set OldApres $SEN} if {$End<$Position} {set OldAvant $SEN} return "Between $OldAvant $OldApres" } if {$Position<$Start} {set OldApres $SEN set F [expr $M -1]} if {$End<$Position} {set OldAvant $SEN set D [expr $M +1]} } } proc IndexDeClustering {c} { return [$::db eval {select pk_clus from clustering where name=$c}] } proc IndexDeMac {mac} { return [$::db eval {select pk_mac from mac where name=$mac}] } proc IndexDuCluster {c} { set m [MacCourant] return [$::db eval {select c.pk_cluster from cluster as c, clustering as g where c.name=$c and c.pk_clustering=g.pk_clustering and g.pk_mac=$m}] } proc IndexDuDescrCustom {OldNew Valeur} { global IndexDuDescrCustom if {[info exists IndexDuDescrCustom($OldNew,$Valeur)]} { return $IndexDuDescrCustom($OldNew,$Valeur) } if {[info exists IndexDuDescrCustom("EstCharge")]} { return "" } set IndexDuDescrCustom("EstCharge") 1 foreach IndexA [RetChip2 ListOf Index] { set VA [RetChip2 $IndexA "description_customer"] lappend IndexDuDescrCustom(Ancien,$VA) $IndexA } foreach IndexB [RetChip3 ListOf Index] { set VB [RetChip3 $IndexB "description_customer"] lappend IndexDuDescrCustom(Nouveau,$VB) $IndexB } return [IndexDuDescrCustom $OldNew $Valeur] } proc IndexationParAccess {} { global {*}[info globals "TD*"] LesSeqsDuGroupe SDG ListeItemFeatures LesSequencesAssocieesClassesCanon Sequences LNOrdali TabSF # Verifie qu'on a un access/bid pour tout le monde foreach n [lunique $LNOrdali] { if {! [info exists TDesAccess($n)]} { set TDesAccess($n) $n } if {! [info exists TDesBId($n)]} { set TDesBId($n) $n } } # et que les access ne sont pas en double set Lacc [list] foreach n [lunique $LNOrdali] { lappend Lacc [set TDesAccess($n)] } set l1 [lsort $Lacc] set l2 [lsort -unique $Lacc] if {[llength $l1] != [llength $l2]} { FaireLire "Beware !\nThere are duplicated access, Ordalie may not work properly :\n[join [lor $l1 $l2] " "]" } # pour coloriage selon phylum dans tree, etc... foreach a [array names LesSequencesAssocieesClassesCanon] { set Ls [set LesSequencesAssocieesClassesCanon($a)] unset LesSequencesAssocieesClassesCanon($a) foreach s $Ls { if {$s ne "" && ! [EstUnAccessPDB $s]} { lappend LesSequencesAssocieesClassesCanon($a) [set TDesAccess($s)] } else { lappend LesSequencesAssocieesClassesCanon($a) $s } } } # idem pour groupes <-> sequences foreach a [array names LesSeqsDuGroupe] { set Ls [set LesSeqsDuGroupe($a)] unset LesSeqsDuGroupe($a) foreach s $Ls { if {$s eq "" || [EstUnAccessPDB $s]} { lappend LesSeqsDuGroupe($a) $s } else { lappend LesSeqsDuGroupe($a) [set TDesAccess($s)] } } } # Tableau des sequences aa foreach a [array names Sequences] { set s [set Sequences($a)] unset Sequences($a) set Sequences([set TDesAccess($a)]) $s } # et pour les pre-features foreach a [array names TabSF] { set v [set TabSF($a)] unset TabSF($a) set TabSF([set TDesAccess($a)]) $v } # Et pour tous les tableaux set Ltmp [lunique $LNOrdali] set LNOrdali [list] foreach sqn $Ltmp { set acc [set TDesAccess($sqn)] lappend LNOrdali $acc foreach t [info globals "TD*"] { if {! [info exists ${t}($sqn)]} {continue} set r [set ${t}($sqn)] unset ${t}($sqn) set ${t}($acc) $r } } return } proc InfHomolog {{Qui ""} {Quoi ""} {Ou ""}} { if {$Ou==""} { set Ou "Sc" } if {$Quoi==""} { set Quoi "GscopeId" } set R [ExtraitInfo $Qui "Reciproc1_blastp$Ou:"] if {[regexp -nocase "^No" $R]} { return "" } if {$Quoi=="GscopeId"} { return $R } set FicTfa "[RepertoireDuGenome]/prottfa$Ou/$R" if {[FileAbsent $FicTfa]} { return "" } if {[string equal -nocase $Quoi "Filename"]} { return $FicTfa } if {[string equal -nocase $Quoi "TFA"]} { return [ContenuDuFichier $FicTfa] } if {[regexp -nocase "Info" $Quoi]} { set Entete [PremiereLigneDuFichier $FicTfa] if {[regexp -nocase "Show" $Quoi]} { return [YEAHshowYeast $Entete "Show"] } set Info [YEAHshowYeast $Entete "Get"] if {[regexp -nocase "Get" $Quoi]} { if {[regexp -nocase "Locus" $Quoi]} { return [StringApres "Locus_Name...:" dans $Info] } if {[regexp -nocase "Desc" $Quoi]} { return [StringApres "Description..:" dans $Info] } if {[regexp -nocase "ORF" $Quoi]} { return [StringApres "ORF_Name.....:" dans $Info] } return $Info } return $Info } return "" } proc InfoBidir {} { # Recupere via BIRD/GeCo les infos complementaires sur les genes bidir Espionne "InfoBidir : Debut" set FichierDesAccess [open "/genomics/link/STAF/fiches/Bidir/1000/LesAccessDesGenesNonBidir.txt" "r"] #set FichierDesAccess [open "/genomics/link/STAF/fiches/Bidir/1000/LesNonBidir.nb" "r"] set FichierDesRequetes [open "/tmp/BirdInfoNonBidir.bql" "w"] set FichierDesInfos [open "/genomics/link/STAF/fiches/Bidir/1000/LesInfosNonBidir.info" "w"] set Executees "/tmp/BirdInfoBidir.res" Espionne "InfoBidir : Constitution des requetes" set accessOld "" while { [gets $FichierDesAccess Ligne] >=0 } { ScanLaListe $Ligne access chrom start end strand exonCount typegene if { $access != $accessOld } { puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT access, exonCount, chrom, txStart, TxEnd, strand, cdsStart, cdsEnd FROM ucschuman.GeCo WHERE access='$access'" puts $FichierDesRequetes "LM 1" puts $FichierDesRequetes "#" } set accessOld $access } close $FichierDesRequetes Espionne "InfoBidir : Execution des requetes" BirdFetch "/tmp/BirdInfoNonBidir.bql" "/tmp/BirdInfoNonBidir.res" set FichierDesRequetesExecutees [open "/tmp/BirdInfoNonBidir.res" "r"] Espionne "InfoBidir : Post-traitement" while { [gets $FichierDesRequetesExecutees Ligne] >=0 } { set isQuery [string range $Ligne 0 4] if { $isQuery != "Query"} { Espionne "Probleme $isQuery !" } gets $FichierDesRequetesExecutees Ligne ScanLaPipe $Ligne access exonCount chrom txStart txEnd strand cdsStart cdsEnd set geneSize [expr $txEnd - $txStart] if { $strand == "+"} { set dTssCds [expr $cdsStart - $txStart] } else { set dTssCds [expr $txEnd - $cdsEnd] } puts $FichierDesInfos "$access $geneSize $exonCount $dTssCds" } Espionne "InfoBidir : Fin" close $FichierDesInfos close $FichierDesRequetesExecutees } proc InfoDeLaPage {BanqueId Access CATEGORIE} { set FicheInfoDeLAccess [join [LaSequenceDesBanques $BanqueId $Access AccessOk "OnVeutNature"] "\n"] set InfoDuChamps [InfoDuChampsDeLaPage $FicheInfoDeLAccess $CATEGORIE ] return $InfoDuChamps } proc InfoDeLaPageGenBank {BanqueId Access CATEGORIE} { set FicheInfoDeLAccess [join [LaSequenceDesBanques $BanqueId $Access AccessOk "OnVeutNature"] "\n"] set InfoDuChamps [InfoDuChampsDeLaPageGenBank $FicheInfoDeLAccess $CATEGORIE ] return $InfoDuChamps } proc InfoDeLaPageProteine {BanqueId Access CATEGORIE} { set FicheInfoDeLAccess [join [LaSequenceDesBanques $BanqueId $Access AccessOk "OnVeutNature"] "\n"] set InfoDuChamps [InfoDuChampsDeLaPageProteine $FicheInfoDeLAccess $CATEGORIE ] return $InfoDuChamps } proc InfoDeLaZone {Chr T Debut} { foreach D [EleGen $Chr $T ListOf D] F [EleGen $Chr $T ListOf F] { if {$D<=$Debut && $Debut <=$F} { return [EleGen $Chr $T $D Info] } } return "" } proc InfoDuChampDeLAccess {Access CHAMPS} { set Page [join [LaSequenceDesBanques $Access $Access AccessOk "OnVeutNature"] "\n"] set Definition [InfoDuChampsDeLaPage $Page $CHAMPS] return $Definition } proc InfoDuChampsDeLaPage {Page CATEGORIE} { set InfoDuChamps [InfoDuChampsDeLaPageProteine $Page $CATEGORIE] if {[string trim $InfoDuChamps] == ""} { set InfoDuChamps [InfoDuChampsDeLaPageGenBank $Page $CATEGORIE ] } return "$InfoDuChamps" } proc InfoDuChampsDeLaPageGenBank {PageGenBank NOMDUCHAMPS} { global RepertoireDuGenome set LesInfosNettoyes {} foreach Ligne [LeChampsDeLaPageGenBank $PageGenBank $NOMDUCHAMPS] { regsub "$NOMDUCHAMPS [ ]*" $Ligne "" Ligne set Ligne [string trim $Ligne] while {[regexp " " $Ligne] } {regsub " " $Ligne " " Ligne} lappend LesInfosNettoyes $Ligne } return [join $LesInfosNettoyes " "] } proc InfoDuChampsDeLaPageProteine {PageProteine NOMDUCHAMPS} { global RepertoireDuGenome set LesInfosNettoyes {} foreach Ligne [LeChampsDeLaPageProteine $PageProteine $NOMDUCHAMPS] { regsub "^$NOMDUCHAMPS [ ]*" $Ligne "" Ligne set Ligne [string trim $Ligne] while {[regexp " " $Ligne] } {regsub " " $Ligne " " Ligne} while {[regexp "^ " $Ligne] } {regsub "^ " $Ligne "" Ligne} lappend LesInfosNettoyes $Ligne } return [join $LesInfosNettoyes " "] } proc InfoDuCluster {{ClusterOuNom ""} {Quoi ""}} { Wup "Rend les membres du cluster Numero X ou du PAB X, sa taille, son numero" global RepertoireDuGenome global MemoTaille MemoLesMembres MemoClusterOuNom MemoNumero if {$ClusterOuNom=="LaListeMerci"} { set Quoi "LaListeMerci" } if {$ClusterOuNom==""} {return "No Query"} if {$Quoi==""} {set Quoi "Membres"} if {$Quoi!="Membres" && $Quoi!="Taille" && $Quoi!="Numero" && $Quoi!="LaListeMerci"} { return "Quoi must be Membres, Taille or Numero" } if {$Quoi=="Membres" && [info exists MemoLesMembres] && $MemoClusterOuNom==$ClusterOuNom} { return $MemoLesMembres } if {$Quoi=="Numero" && [info exists MemoNumero] && $MemoClusterOuNom==$ClusterOuNom} { return $MemoNumero } if {$Quoi=="Taille" && [info exists MemoTaille] && $MemoClusterOuNom==$ClusterOuNom} { return $MemoTaille } set FichierDesClusters "$RepertoireDuGenome/xhda/TousLesBilans_PourNuca.dpc" set LesMembresDuCluster {} set StopSurCluster 0 foreach Ligne [LesLignesDuFichier $FichierDesClusters] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster} $Ligne]} { if {$StopSurCluster} { break } set LesMembresDuCluster {} scan $Ligne "%s %s %s" Groupe Numero Taille lappend LesNumeros $Numero regsub "$Groupe +$Numero +; +size=" $Ligne "" Taille #if {! [expr $Numero==$ClusterOuNom]} {continue} if {! [string equal $Numero $ClusterOuNom]} {continue} set StopSurCluster 1 continue } scan $Ligne "%s" PAB lappend LesMembresDuCluster $PAB if {[string equal $PAB $ClusterOuNom]} { set StopSurCluster 1} # if {$PAB==$ClusterOuNom} { set StopSurCluster 1} } if {$Quoi=="LaListeMerci"} {return [lsort -integer -unique $LesNumeros]} if {! [string equal $Numero $ClusterOuNom] && [expr [lsearch -exact $LesMembresDuCluster $ClusterOuNom]<0]} { return "No info available for $ClusterOuNom" } set MemoNumero $Numero set MemoMembres $LesMembresDuCluster set MemoTaille $Taille set MemoClusterOuNom $ClusterOuNom if {$Quoi=="Numero"} {return $Numero} if {$Quoi=="Taille"} {return $Taille} if {$Quoi=="Membres"} {return $LesMembresDuCluster} } proc InfoEmbl {{Qui ""} {Quoi ""}} { global InfoEmbl if {$Quoi=="Delete"} { if { ! [info exists InfoEmbl($Qui,EstCharge)]} { return 0 } set N 0 foreach QQ $InfoEmbl($Qui,Data) { incr N unset InfoEmbl($QQ) } return $N } if {[info exists InfoEmbl($Qui,$Quoi)]} { return $InfoEmbl($Qui,$Quoi) } if {[info exists InfoEmbl($Qui,EstCharge)]} { return "" } set InfoEmbl($Qui,EstCharge) "" set LesLignesEmbl [LaSequenceDesBanques $Qui $Qui AccessOk "OnVeutEMBL"] if {$LesLignesEmbl=={}} { return "" } set Embl [join $LesLignesEmbl "\n"] set InfoEmbl($Qui,Embl) $Embl set InfoEmbl($Qui,AccessOk) $AccessOk set AllInfo [DecortiqueLesLignesEMBL $LesLignesEmbl ID AC DE GN OS OC OX SQ] foreach {K V} $AllInfo { set InfoEmbl($Qui,Info$K) $V } set SQ [string toupper $SQ] set InfoEmbl($Qui,ID) $ID set InfoEmbl($Qui,AC) $AC set InfoEmbl($Qui,DE) $DE set InfoEmbl($Qui,GN) $GN set InfoEmbl($Qui,OS) $OS set InfoEmbl($Qui,OC) $OC set InfoEmbl($Qui,OX) $OX set InfoEmbl($Qui,SQ) $SQ set InfoEmbl($Qui,Length) [string length $SQ] foreach A [split $SQ ""] { incr InfoEmbl($Qui,n$A) lappend InfoEmbl($Qui,ListOfAA) $A } set InfoEmbl($Qui,ListOfAA) [lsort -unique $InfoEmbl($Qui,ListOfAA)] set AllP {} foreach A $InfoEmbl($Qui,ListOfAA) { set InfoEmbl($Qui,p$A) [expr (100.*$InfoEmbl($Qui,n$A))/$InfoEmbl($Qui,Length)] lappend AllP "$A [format %4.1f $InfoEmbl($Qui,p$A)]" } set InfoEmbl($Qui,AllP) $AllP set InfoEmbl($Qui,AllPSort) [lsort -decreasing -index 1 -real $AllP] foreach QQ [array names InfoEmbl] { if {[regexp "^$Qui\," $QQ]} { lappend InfoEmbl($Qui,Data) $QQ } } return [InfoEmbl $Qui $Quoi] } proc InfoFromAnalysissoftwareInput {{Qui ""} {Quoi ""} {Fichier ""}} { global InfoFromAnalysissoftwareInput if {$Qui==""} { set Qui "ListOf" } if {$Quoi==""} { set Quoi "Name" } if {$Fichier==""} { if {[info exists InfoFromAnalysissoftwareInput(Courant)]} { set Fichier $InfoFromAnalysissoftwareInput(Courant) } else { set Fichier "[GxData]/ToGx/AnalysissoftwareInput.txt" } } set InfoFromAnalysissoftwareInput(Courant) $Fichier if {[info exists InfoFromAnalysissoftwareInput($Qui,$Quoi,$Fichier)]} { return $InfoFromAnalysissoftwareInput($Qui,$Quoi,$Fichier) } if {[info exists InfoFromAnalysissoftwareInput(EstCharge,$Fichier)]} { return "" } set InfoFromAnalysissoftwareInput(EstCharge,$Fichier) 1 set InfoFromAnalysissoftwareInput(ListOf,Key,$Fichier) {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {([a-z]+) (.*)?} $Ligne Match Key Value]} { continue } if {$Key=="name"} { set NameCourant $Value lappend InfoFromAnalysissoftwareInput(ListOf,Name,$Fichier) $NameCourant } lappend InfoFromAnalysissoftwareInput(ListOf,Key,$Fichier) $Key set InfoFromAnalysissoftwareInput($NameCourant,$Key,$Fichier) $Value } set InfoFromAnalysissoftwareInput(ListOf,Key,$Fichier) [lsort -unique -command TrieKey $InfoFromAnalysissoftwareInput(ListOf,Key,$Fichier)] return [InfoFromAnalysissoftwareInput $Qui $Quoi $Fichier] } proc InfoFromArraytypeInput {{Qui ""} {Quoi ""} {Fichier ""}} { global InfoFromArraytypeInput if {$Qui==""} { set Qui "ListOf" } if {$Quoi==""} { set Quoi "Name" } if {$Fichier==""} { if {[info exists InfoFromArraytypeInput(Courant)]} { set Fichier $InfoFromArraytypeInput(Courant) } else { set Fichier "[GxData]/ToGx/ArraytypeInput.txt" } } set InfoFromArraytypeInput(Courant) $Fichier if {[info exists InfoFromArraytypeInput($Qui,$Quoi,$Fichier)]} { return $InfoFromArraytypeInput($Qui,$Quoi,$Fichier) } if {[info exists InfoFromArraytypeInput(EstCharge,$Fichier)]} { return "" } set InfoFromArraytypeInput(EstCharge,$Fichier) 1 set InfoFromArraytypeInput(ListOf,Key,$Fichier) {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {([a-z]+) (.*)?} $Ligne Match Key Value]} { continue } if {$Key=="name"} { set NameCourant $Value lappend InfoFromArraytypeInput(ListOf,Name,$Fichier) $NameCourant } if {$Key=="composition"} { foreach Chip [split $Value ","] { lappend InfoFromArraytypeInput(ListOfMultiChip,$Chip,$Fichier) $NameCourant } } lappend InfoFromArraytypeInput(ListOf,Key,$Fichier) $Key set InfoFromArraytypeInput($NameCourant,$Key,$Fichier) $Value } set InfoFromArraytypeInput(ListOf,Key,$Fichier) [lsort -unique -command TrieKey $InfoFromArraytypeInput(ListOf,Key,$Fichier)] return [InfoFromArraytypeInput $Qui $Quoi $Fichier] } proc InfoFromClusteringInput {{Qui ""} {Quoi ""} {Fichier ""}} { global InfoFromClusteringInput if {$Qui==""} { set Qui "ListOf" } if {$Quoi==""} { set Quoi "Name" } if {$Fichier==""} { if {[info exists InfoFromClusteringInput(Courant)]} { set Fichier $InfoFromClusteringInput(Courant) } else { set Fichier "[GxData]/ToGx/ClusteringmethodInput.txt" } } set InfoFromClusteringInput(Courant) $Fichier if {[info exists InfoFromClusteringInput($Qui,$Quoi,$Fichier)]} { return $InfoFromClusteringInput($Qui,$Quoi,$Fichier) } if {[info exists InfoFromClusteringInput(EstCharge,$Fichier)]} { return "" } set InfoFromClusteringInput(EstCharge,$Fichier) 1 set InfoFromClusteringInput(ListOf,Key,$Fichier) {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {([a-z]+) (.*)?} $Ligne Match Key Value]} { continue } if {$Key=="name"} { set NameCourant $Value lappend InfoFromClusteringInput(ListOf,Name,$Fichier) $NameCourant } lappend InfoFromClusteringInput(ListOf,Key,$Fichier) $Key set InfoFromClusteringInput($NameCourant,$Key,$Fichier) $Value } set InfoFromClusteringInput(ListOf,Key,$Fichier) [lsort -unique $InfoFromClusteringInput(ListOf,Key,$Fichier)] return [InfoFromClusteringInput $Qui $Quoi $Fichier] } proc InfoFromClustersoftwareInput {{Qui ""} {Quoi ""} {Fichier ""}} { global InfoFromClustersoftwareInput if {$Qui==""} { set Qui "ListOf" } if {$Quoi==""} { set Quoi "Name" } if {$Fichier==""} { if {[info exists InfoFromClustersoftwareInput(Courant)]} { set Fichier $InfoFromClustersoftwareInput(Courant) } else { set Fichier "[GxData]/ToGx/ClustersoftwareInput.txt" } } set InfoFromClustersoftwareInput(Courant) $Fichier if {[info exists InfoFromClustersoftwareInput($Qui,$Quoi,$Fichier)]} { return $InfoFromClustersoftwareInput($Qui,$Quoi,$Fichier) } if {[info exists InfoFromClustersoftwareInput(EstCharge,$Fichier)]} { return "" } set InfoFromClustersoftwareInput(EstCharge,$Fichier) 1 set InfoFromClustersoftwareInput(ListOf,Key,$Fichier) {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {([a-z]+) (.*)?} $Ligne Match Key Value]} { continue } if {$Key=="namecm"} { set NameCourant $Value lappend InfoFromClustersoftwareInput(ListOf,Name,$Fichier) $NameCourant } lappend InfoFromClustersoftwareInput(ListOf,Key,$Fichier) $Key lappend InfoFromClustersoftwareInput($NameCourant,$Key,$Fichier) $Value } set InfoFromClustersoftwareInput(ListOf,Name,$Fichier) [lsort -unique $InfoFromClustersoftwareInput(ListOf,Name,$Fichier)] set InfoFromClustersoftwareInput(ListOf,Key,$Fichier) [lsort -unique $InfoFromClustersoftwareInput(ListOf,Key,$Fichier)] return [InfoFromClustersoftwareInput $Qui $Quoi $Fichier] } proc InfoInteressante {Ligne} { if {[regexp {^CNS-Adresse:} $Ligne]} { return 0 } if {[regexp {^CNS-Sequence:} $Ligne]} { return 0 } if {[regexp {^CNS-VieuxNom:} $Ligne]} { return 0 } if {[regexp {^CNS} $Ligne]} { return 1 } return 0 } proc InfoOrthologs {Nom} { set Id [ExtraitInfo $Nom "ID:"] set LesTFAsDesOrtho [OiLesTFAsDesOrthologs $Id] set LesOId {} set LesOAc {} foreach Ligne $LesTFAsDesOrtho { set O "" if { ! [regexp {^>([^ ]+) ([^$]+)} $Ligne Match O D]} {continue} lassign [split $O "|"] B Ac Id regsub { OS=.*} $D "" D regsub { GN=.*} $D "" D regsub { PE=.*} $D "" D regsub { SV=.*} $D "" D set Genre "" set Espece "" regexp {OS=([^ ]+) ([^ ]+)} $Ligne Match Genre Espece set Gn "" regexp {GN=([^ ]+)} $Ligne Match Gn # Gn / Os récupérées mais pas utilisées if {$Id!=""} { lappend LesOId $Id } if {$Ac!=""} { lappend LesOAc $Ac } } if {$LesOId=={}} { return "" } if {$LesOAc=={}} { return "" } set LesOId [lsort -unique $LesOId] set LesOAc [lsort -unique $LesOAc] set TOId "=OrthologsId: [join $LesOId " "]" set TOAc "=OrthologsAc: [join $LesOAc " "]" InformeSansDemander $Nom $TOId InformeSansDemander $Nom $TOAc return $TOId } proc InfoOrthologsPourTous {} { set LeTout {} foreach Nom [ListeDesPABs] { set TO [InfoOrthologs $Nom] lappend LeTout "$Nom $TO" } return $LeTout } 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) {} 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"] Sauve [array get InfoPubmed] dans $Fic return [InfoPubmed $Pmids $Qui $Quoi] } proc InfoScript {} { global InfoScript if {[info exists InfoScript]} { return $InfoScript } return "" } proc InfoSurMasking {SequenceDuCDNAMasquee NombreDeBasesMasquees LesNomsDesRepeats} { #################################################### global RepertoireDuGenome set TailleDeLaSequence [string length $SequenceDuCDNAMasquee] set PourcentMasque [PourcentageArrondiSup $NombreDeBasesMasquees $TailleDeLaSequence] if {$PourcentMasque==0} { set Annotation "NoRepeatToMask EndMask" } else { if {$PourcentMasque==-1} { set Annotation "NoSequenceToMask EndMask" } else { set SeuilPourcentage 90.0 if {[expr $PourcentMasque > $SeuilPourcentage]} { set Annotation "TotallyMasked" } else { set Annotation "PartiallyMasked" } } } if {$PourcentMasque==0} { set Annotation "$Annotation" } else { set NomsDesRepeats [join $LesNomsDesRepeats " "] set Annotation "$Annotation ${PourcentMasque}% $NomsDesRepeats EndMask" } return $Annotation } proc InfoSurRemasking {SequenceDuCDNARemasquee NombreDeBasesRemasquees LesNomsDesRepeats} { #################################################### global RepertoireDuGenome # Espionne ">$LesNomsDesRepeats<" set TailleDeLaSequence [string length $SequenceDuCDNARemasquee] set PourcentReMasque [PourcentageArrondiSup $NombreDeBasesRemasquees $TailleDeLaSequence] if {$PourcentReMasque==0} { set Annotation "NoRepeatToReMask EndReMask" } else { if {$PourcentReMasque==-1} { set Annotation "NoSequenceToReMask EndReMask" } else { set SeuilPourcentage 90.0 if {[expr $PourcentReMasque > $SeuilPourcentage]} { set Annotation "TotallyReMasked" } else { set Annotation "PartiallyReMasked" } } } if {$PourcentReMasque==0} { set Annotation "$Annotation" } else { set NomsDesRepeats [join $LesNomsDesRepeats " "] set Annotation "$Annotation ${PourcentReMasque}% $NomsDesRepeats EndReMask" } return $Annotation } proc InfoUniprotMito {} { set Lacc "Q9BW92 SYTM Q5T160 SYRM Q96I59 SYNM Q96GW9 SYMM Q6PI48 SYDM Q15031 SYLM Q9NSE4 SYIM Q7L3T8 SYPM P49590 SYHM Q9UGM6 SYWM Q9Y2Z4 SYYM Q9NP81 SYSM Q5JPH6 SYEM CytoSpliced SYKM CytoMLS SYGM Q9HA77 SYCM Q5JTZ9 SYAM Q5ST30 SYVM O95363 SYFM" cd [MiSynPatDir]/data/structures set Ld [lsort [glob -type d "*ars*"]] set Lacc [string map {"\n" " "} $Lacc] regsub -all { +} $Lacc " " Lacc set Lacc [split $Lacc] set Lacc [lsort -stride 2 -index 1 $Lacc] set Luni [list] foreach {acc what} $Lacc { lappend Luni $acc } array set T [InfosFromUniProt $Luni] array set T [InfosFromRefSeq $Luni] set Kseq "mltqaavrlvrgslrktswaewghrelrlgqlapftaphkdksfsdqgselkrrlkaekkvaekeakqkelsekqlsqataaatnhttdngvgpeeesvdpnqyykirsqaihqlkvngedpyphkfhvdisltdfiqkyshlqpgdhltditlkvagrihakrasggklifydlrgegvklqvmansrnykseeefihinnklrrgdiigvqgnpgktkkgelsiipyeitllspclhmlphlhfglkdketryrqryldlilndfvrqkfiirskiityirsfldelgfleietpmmniipggavakpfityhneldmnlymriapelyhkmlvvggidrvyeigrqfrnegidlthnpefttcefymayadyhdlmeitekmvsgmvkhitgsykvtyhpdgpegqaydvdftppfrrinmveelekalgmklpetnlfeteetrkilddicvakavecppprttarlldklvgeflevtcinptficdhpqimsplakwhrskeglterfelfvmkkeicnaytelndpmrqrqlfeeqakakaagddeamfidenfctaleyglpptagwgmgidrvamfltdsnnikevllfpamkpedkkenvattdtlesttvgssv" set Kseq [string toupper $Kseq] set Gseq "--------------------------------mlraggarrfrrhplwtaqgrrlmpsprpvllrgaraalllllpprllarpslllrrslsaascapislpaaasrssmdgagaeevlaplrlavrqqgdlvrklkedkap--qvdvdkavaelkarkrvle-akelalqpkd----------divdrakmedtlkrrffydqafaiyggvsglydfgpvgcalknniiqtwrqhfiq-eeqi-leidctmltpepvlktsghvdkfadfmvkdvkngecfradhllkahlqklms--------------------------------------dkk---------------------------------csvekkse-----mesvlaqldnygqqeladlfvnynvkspitgndls---ppvsfnlmfktfigpggnmp------------------------------gylrpetaqgiflnfkrllef-nqgklpfaaaqignsfrneisprsglirvreftmaeiehfvdpsekdhpkfqnvadlhlylysakaqvsgqsar-----kmrlgdaveqgvinntvlgyfi-griylyltkvgispdklrfrqhmenemahyacdcwdaeskts-yg--wieivgcadrscydlschara---------------tkvplvaekplkepktvnvvqfepskgaigkaykkdaklvmeylaicde--cyitememllnekgeft--ietegktf---------------------------qltkd--minvkrfqktlyveevvpnviepsfglgrimytvfehtfhvreg----------------------------------------------deqrtffsfpavvapfkcsvlplsqnqe-fmpfvkelsealtrhgv-shkvddssgsigrryartdeigvafgvtidfdtvnktp-------htatlrdrdsmrqiraeiselpsivqdlang---nitwadvearyplfegqetgkketiee------------" set Gseq [string toupper [string map {- ""} $Gseq]] set fall [open "all_aars_mito.tfa" w] foreach d $Ld { cd $d set sys [string toupper [string index $d 0]] # cherche access correspondant set found 0 foreach {acc what} $Lacc { if {[string index $what 2] eq $sys} { set found 1 break } } if {! $found} { puts ">> PB $sys not found" cd .. continue } set tfa "$acc.tfa" set f [open $tfa w] switch $what { "SYGM" {set seq $Gseq} "SYKM" {set seq $Kseq} default {set seq $T($acc,Sequence)} } puts "\n$acc $what" puts "-----------" #puts "$seq" puts $f ">$acc $what" puts $f "$seq" close $f puts $fall ">$acc $what" puts $fall "$seq" #set Lres [split [DbFetchGET uniprot $Luni] \n] #set Lembl [SplitLesEMBL $Lres] cd .. } close $fall exit } proc Informe {Nom {Append ""}} { global RepertoireDuGenome global FenetreInfoOuverte global FenetreSignal global LesKanvasOuverts global ListeDesContenuInfo global InfoEnMemoire global InformeSansDemander global TypeCouleur global TypeCouleurDuLinge global RetourEntreTexte Gs "Text" # if {[PourWscope]} { return [XpertComment $Nom] } set FichierInfo "$RepertoireDuGenome/infos/$Nom" if {[regexp "\n" $Append]} { foreach Ligne [split $Append "\n"] { if {[regexp "^Nom: " $Ligne]} { continue } set Inf [Informe $Nom $Ligne] } return $Inf } if {[regexp "^=CopyOf_" $Append]} { set Source [StringApres "_" dans $Append] return [Informe $Nom [ExtraitInfo $Source]] } set Remplace [regexp "^=" $Append] regsub {^[=+]} $Append "" Append if { ! [PourWscope] && [info exists FenetreInfoOuverte($Nom)]} { raise [set FenetreInfoOuverte($Nom)] if {$Append == ""} { return "[ContenuDuFichier $FichierInfo]" } if {[OuiOuNon "$Append\n doit etre rajoute a la page info $Nom\n La page info est deja ouverte.\n Dois-je abandonner ?"]} { return -1 } if {[OuiOuNon "Dois-je le faire maintenant ?"]} { [set FenetreInfoOuverte($Nom)].text insert end "$Append\n" return -2 } FaireLire "Vous ferez, plus tard, le couper-coller pour moi. Merci." return -3 } set FenetreInfoOuverte($Nom) $Nom if {! [file exists $FichierInfo] || [file size $FichierInfo]==0} { set Information "Nom: $Nom" if {[file exists "$RepertoireDuGenome/beton/infomodele"]} { append Information "\n[ContenuDuFichier $RepertoireDuGenome/beton/infomodele]" } Sauve $Information dans $FichierInfo } if {$Remplace} { scan $Append "%s" Champ set VieuxTextePurge [InformeParSuppressionDuChamp $Nom $Champ "PourVoir"] } else { set VieuxTextePurge [ContenuDuFichier $FichierInfo] } if { [info exists InformeSansDemander] && $InformeSansDemander } { set BonTexte "$VieuxTextePurge\n$Append" } else { if {[PourWscope]} { return [EntreTexte "$VieuxTextePurge\n$Append" "AvecRetourPourInforme" $FichierInfo] } set BonTexte [EntreTexte "$VieuxTextePurge\n$Append" [list "Show $Nom" "SeeAby Show $Nom"]] } if { $BonTexte != "" } { set TexteOk [Censure "$BonTexte"] Sauve $TexteOk dans $FichierInfo set InfoEnMemoire($Nom) $TexteOk if {[info exists ListeDesContenuInfo]} { set iTrouve [lsearch -regexp $ListeDesContenuInfo [string toupper "^Nom: $Nom"]] set ListeDesContenuInfo [lreplace $ListeDesContenuInfo $iTrouve $iTrouve [string toupper $TexteOk]] } if {[PourWscope]} { return $TexteOk } if {[info exists LesKanvasOuverts]} { foreach K $LesKanvasOuverts { if { ! [info exists TypeCouleur($K)]} { continue } RetexteUneBoite $Nom [NomDeScene $Nom] $K OnColorieLesFrames 1 RecoloreUneBoite $Nom [set TypeCouleur($K)] $K OnColorieLesFrames 0 RecoloreUnLinge $Nom [set TypeCouleurDuLinge($K)] $K } } } if {[info exists FenetreSignal($Nom)]} { destroy [set FenetreSignal($Nom)] unset FenetreSignal($Nom) } unset FenetreInfoOuverte($Nom) return $BonTexte } proc InformeAccessFromHeaderPourTous {} { foreach Nom [ListeDesPABs] { set Access [AccessFromHeader $Nom] if {$Access==""} { continue } Espionne "$Nom [Alias $Nom] $Access" InformeSansDemander $Nom "AccessRefseq: $Access" } } proc InformeAccessProt {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set sansaccess 0 foreach Nom $Liste { set F "[RepertoireDuGenome]/prottfa/$Nom" set IdProt ""; set AccessProt "" set LesLignes [LesLignesDuFichier $F] set PremiereLigne [lindex $LesLignes 0] set LesMots [LesMotsDeLaLigne $PremiereLigne] set Nom [lindex $LesMots 0] regsub ">" $Nom "" Nom set compte -1 foreach Mot $LesMots { incr compte if {[string equal $Mot "from"]} { set IndexFrom $compte set IdProt [lindex $LesMots [expr $IndexFrom + 1]] set AccessProt [lindex $LesMots [expr $IndexFrom -1]] break } } if {$IdProt=="" && $AccessProt==""} { set AccessProt [lindex $LesMots 1] } if {$AccessProt==""} { #set AccessProt [AcDuId $IdProt] FaireLire "Horreur $Nom ss accessprot" } InformeSansDemander $Nom "IdAccprot: $IdProt $AccessProt" } } proc InformeAccessProtOld {} { set sansaccess 0 foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfa/*"] { set IdProt ""; set AccessProt "" Espionne $F set LesLignes [LesLignesDuFichier $F] set PremiereLigne [lindex $LesLignes 0] set LesMots [LesMotsDeLaLigne $PremiereLigne] set Nom [lindex $LesMots 0] regsub ">" $Nom "" Nom set compte -1 foreach Mot $LesMots { incr compte if {[string equal $Mot "from"]} { set IndexFrom $compte set IdProt [lindex $LesMots [expr $IndexFrom + 1]] set AccessProt [lindex $LesMots [expr $IndexFrom -1]] break } } if {$IdProt=="" && $AccessProt==""} { set AccessProt [lindex $LesMots 1] } if {$AccessProt==""} { #set AccessProt [AcDuId $IdProt] FaireLire "Horreur $Nom ss accessprot" } InformeSansDemander $Nom "Id et Access prot: $IdProt $AccessProt" } } proc InformeAffyPourTous {} { foreach Nom [ListeDesPABs] { set LesProbeAccess {} set LesProbeLocUcsc {} set LocUcsc {} set LesLocAffy {} set Access [AccessEvi $Nom] if {$Access!=""} { set LocUcsc [LocUcscEvi $Access "From200503"] foreach ProbeAccess [lsort -unique [AffyAnno $Access "Probe_Set_ID"]] { lappend LesProbeAccess $ProbeAccess lappend LesLocAffy [AffyAnno $ProbeAccess "Alignments"] } set LesProbeLocUcsc [AffyAnno $LocUcsc "Probe_Set_ID"] } Espionne "" Espionne "$Nom" Espionne "Access =$Access" Espionne "ProbeAccess =$LesProbeAccess" Espionne "ProbeLocUcsc=$LesProbeLocUcsc" Espionne "LocUcsc =$LocUcsc" Espionne "LocAffy =$LesLocAffy" } } proc InformeAffyPourTousChezMoi {} { set NbNom 0; set Vides 0; set Pleins 0 set NbAcPs 0; set sit1 0; set sit2 0; set NbSsPs 0; set PSLocUcsc 0; set NbSsLoc 0; set ajeter 0 foreach Nom [ListeDesPABs] { Espionne "" incr NbNom; set LesProbeAccess {}; set LesProbeLocUcsc {}; set LesLocAffy {} set Loc ""; set LocUcsc ""; set dsles2 0 set LesLocs {}; set LesPs {} set Access [AccessEvi $Nom] if {$Access==""} { incr Vides continue } if {$Access!=""} { incr Pleins set LocUcscGbRs [ExtraitInfo $Nom "LocUcscFrom200503"] set LocUcscRs [ExtraitInfo $Nom "LocUcscRefSeqFrom200503"] if {![regexp {[0-9]+} $LocUcscGbRs] && ![regexp {[0-9]+} $LocUcscRs]} {set LocUcsc03 ""} if {[regexp {[0-9]+} $LocUcscGbRs] && [regexp {[0-9]+} $LocUcscRs]} { set dsles2 1 if {$LocUcscGbRs == $LocUcscRs} { set LocUcsc03 $LocUcscGbRs } else { set LesMotsGbRs [split $LocUcscGbRs {:- }] set startGbRs [lindex $LesMotsGbRs 1] set stopGbRs [lindex $LesMotsGbRs 2] set longGbRs [expr $stopGbRs-$startGbRs] set LesMotsRs [split $LocUcscRs {:- }] set startRs [lindex $LesMotsRs 1] set stopRs [lindex $LesMotsRs 2] set longRs [expr $stopRs-$startRs] if {$longGbRs < $longRs} { set LocUcsc03 $LocUcscRs/litige/ } else { set LocUcsc03 $LocUcscGbRs/litige/ } } } if {!$dsles2 && [regexp {[0-9]+} $LocUcscGbRs]} {set LocUcsc03 $LocUcscGbRs} if {!$dsles2 && [regexp {[0-9]+} $LocUcscRs]} {set LocUcsc03 $LocUcscRs} foreach ProbeAccess [lsort -unique [AffyAnno $Access "Probe_Set_ID"]] { lappend LesProbeAccess $ProbeAccess lappend LesLocAffy [AffyAnno $ProbeAccess "Alignments"] } set LesLocAffy [lsort -unique $LesLocAffy] set LesProbeLocUcsc [AffyAnno $LocUcsc03 "Probe_Set_ID"] set LesProbeLocUcsc [lsort -unique $LesProbeLocUcsc] } Espionne "$Nom" Espionne "Access =$Access" Espionne "LocUcscGbRs =$LocUcscGbRs" Espionne "LocUcscRs =$LocUcscRs" Espionne "LocUcsc03 =$LocUcsc03" Espionne "ProbeAccess =$LesProbeAccess" Espionne "ProbeLocUcsc=$LesProbeLocUcsc" Espionne "LocAffy =$LesLocAffy" if {$LesProbeAccess!={}} { incr NbAcPs if {$LesProbeLocUcsc!={}} { set LongLesProbeAccess [llength $LesProbeAccess] set LongLesProbeLocUcsc [llength $LesProbeLocUcsc] if {$LongLesProbeAccess > $LongLesProbeLocUcsc} { incr sit1 foreach x $LesProbeLocUcsc { set jaitrouve1 0 foreach y $LesProbeAccess { if {$x==$y} {set jaitrouve1 1; break} } if {!$jaitrouve1} { Espionne "$x n'est pas ds lesprobesaccess" } } } if {$LongLesProbeLocUcsc > $LongLesProbeAccess} { incr sit2 foreach y $LesProbeAccess { set jaitrouve2 0 foreach x $LesProbeLocUcsc { if {$y==$x} {set jaitrouve2 1; break} } if {!$jaitrouve2} { Espionne "$y n'est pas ds lesprobeslocucsc" } } } } } if {[regexp {[0-9]} $LocUcsc03]} { set chr ""; set deb ""; set fin "" set LesMots [split $LocUcsc03 {:- }] set chr [lindex $LesMots 0] set deb [lindex $LesMots 1] set fin [lindex $LesMots 2] for {set i $deb} {$i<=$fin} {incr i} { set Loc [LocInBetween $i Mouse $chr Affy] lappend LesLocs $Loc } set LesLocs [ListeSansDoublon $LesLocs] foreach x $LesLocs { Espionne "1" Espionne "$x" if {[regexp {^In} $x]} { set LesParts [split $x "In"] foreach Part $LesParts { Espionne "++$Part" string trim $Part Espionne "--$Part" lappend LesPs $Part } } if {[regexp {^Between} $x]} { lappend LesPs $x } } set LesPs [ListeSansDoublon $LesPs] foreach y $LesPs { Espionne "2" Espionne "$y" } } if {$LesProbeAccess=={}} { #Espionne "$Nom" #Espionne "Access =$Access" #Espionne "ProbeAccess =$LesProbeAccess" #Espionne "ProbeLocUcsc=$LesProbeLocUcsc" #Espionne "LocUcscGbRs =$LocUcscGbRs" #Espionne "LocUcscRs =$LocUcscRs" #Espionne "LocUcsc =$LocUcsc" #Espionne "LocAffy =$LesLocAffy" #Espionne "LocAcStart= $Loc" #Espionne "LocAcStop= $Loc" #Espionne "" incr NbSsPs if {$LesProbeLocUcsc!={}} {incr PSLocUcsc} if {![regexp {[0-9]} $LocUcsc]} {incr NbSsLoc} if {[regexp {[0-9]} $LocUcsc]} { incr ajeter #Espionne "$Nom" #Espionne "Access =$Access" #Espionne "LocUcsc =$LocUcsc" #Espionne "LocAcStart= $Loc" #Espionne "LocAcStop= $Loc" #Espionne "" } } } Espionne "" Espionne "nb total = $NbNom" Espionne "nb vide = $Vides" Espionne "nb plein = $Pleins" Espionne "" Espionne "nb ac ps = $NbAcPs" Espionne "" Espionne "nb ss ps = $NbSsPs" Espionne "nb ss ps ac pslocucsc = $PSLocUcsc" Espionne "nb ss locucsc = $NbSsLoc" Espionne "" Espionne "sit1= $sit1" Espionne "sit2= $sit2" } proc InformeAliasWithACIfNotGNPourTous {MauvaisAlias MauvaisGN} { #rR Si l'actuel Alias contient $MauvaisAlias on prend GN sauf s'il contient MauvaisGN, par defaut on prond AC foreach Nom [ListeDesPABs] { set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]] set Alias [ExtraitInfo $Nom Alias] if {[regexp $MauvaisAlias $Alias]} { set Alias [ExtraitInfo $Nom "GN:"] } if {[regexp $MauvaisGN $Alias]} { set Alias [ExtraitInfo $Nom "AC:"] } Espionne "$Nom $Alias" InformeSansDemander $Nom "=Alias: $Alias" } } proc InformeAvecDaedalusHitPourTous {{Quoi ""} {Qui ""}} { if {$Quoi==""} { set Quoi "OS_OC_GN_DE" } if {[regexp "OS" $Quoi]} { set FichierOrganismesDesPABs "[RepertoireDuGenome]/fiches/organismesdespabs" if {[file exists $FichierOrganismesDesPABs]} { foreach Ligne [LesLignesDuFichier $FichierOrganismesDesPABs] { scan $Ligne "%s" NomLu set DejaVu($NomLu,OS) 1 } } } if {$Qui==""} { set Qui [ListeDesPABs] } if {[EstUnPAB $Qui]} { set Qui [list $Qui] } foreach Nom $Qui { if {[EstUnPABMute $Nom]} { continue } Espionne "I'll examine $Nom" if {[regexp "OS" $Quoi] && [info exists DejaVu($Nom,OS)]} { continue } set Narcisse [Narcisse $Nom] if {[regexp "OS" $Quoi] && [regexp "^cio" $Narcisse]} { set Valeur "7719 <>" set Ligne "$Nom $Valeur" InformeSansDemander $Nom "=Organism: $Valeur" AppendAuFichier $FichierOrganismesDesPABs $Ligne if {[regexp "OC" $Quoi]} { scan $Valeur "%s" TaxId set Classe [TaxClass $TaxId "" "" Name] if {$Classe!=""} { Espionne "$Nom Taxonomy: $Classe" InformeSansDemander $Nom "=Taxonomy: $Classe" } } continue } set FHit "[RepertoireDuGenome]/daedalushits/$Nom" if { ! [file exists $FHit]} { continue } set Texte [ContenuDuFichier $FHit] set OX "" if {[info exists ExistePlusLoin]} { unset ExistePlusLoin } while {[set BH [ValeurDeLaBalise "BlastHit" Texte]]!=""} { set AC [ValeurDeLaBalise AC BH NePasRogner] set ID [ValeurDeLaBalise ID BH NePasRogner] set OX [ValeurDeLaBalise OX BH NePasRogner] set GN [ValeurDeLaBalise GN BH NePasRogner] if {[regexp "Name=" $GN]} { regsub -all ";" $GN " " set GN [StringApres "Name=" dans $GN] } set DE [ValeurDeLaBalise DE BH NePasRogner] if {[EstUnAccessPDB $Narcisse] || [string equal -nocase $ID $Narcisse] || [regexp -nocase $Narcisse $AC]} { break } if { ! [info exists ExistePlusLoin]} { set ExistePlusLoin [regexp -nocase $Narcisse $Texte] } if {$ExistePlusLoin} { continue } if { 0 && [OuiOuNon "For $Nom ID=$ID AC=$AC the hit \n$BH\nis not Narcisse $Narcisse\nDo I continue parsing\n [string range $Texte 0 500] ?"]} { continue } break } if {[regexp "OS" $Quoi] && $OX!=""} { set LesNames {} foreach TaxId [split $OX " "] { lappend LesNames "<[Tax $TaxId]>" } set Valeur "$OX <[join $LesNames "+"]>" set Ligne "$Nom $Valeur" AppendAuFichier $FichierOrganismesDesPABs $Ligne InformeSansDemander $Nom "=Organism: $Valeur" if {[regexp "OC" $Quoi]} { scan $OX "%s" TaxId set Classe [TaxClass $TaxId "" "" Name] if {$Classe!=""} { Espionne "$Nom Taxonomy: $Classe" InformeSansDemander $Nom "=Taxonomy: $Classe" } } } if {[regexp "GN" $Quoi] && $GN!=""} { InformeSansDemander $Nom "ValiGN: $GN" } if {[regexp "DE" $Quoi] && $DE!=""} { InformeSansDemander $Nom "ValiDE: $DE" } } if {[regexp "OS" $Quoi]} { return $FichierOrganismesDesPABs } return } proc InformeBathy {} { foreach Nom [ListeDesPABs] { set Entete [EnteteDuFichierTFA [GscopeFile $Nom nuctfa]] set Description [StringSuivant " " dasn $Entete] # InformeSansDemander $Nom "OriginalDescription: $Description" scan $Description "%s" Alias InformeSansDemander $Nom "Alias: $Alias" if {[regexp "^CL" $Alias]} { set Reads [BathyCompositionContig $Alias "Reads"] set Libraries [BathyCompositionContig $Alias "Libraries"] InformeSansDemander $Nom "Reads: [join $Reads " "]" InformeSansDemander $Nom "Libraries: [join $Libraries " "]" } if {[regexp "^IN0ACC" $Alias]} { set Library "" scan $Description "%s %s" Bidon Library InformeSansDemander $Nom "Reads: $Alias" InformeSansDemander $Nom "Libraries: $Library" } if {[regexp "^SSH" $Alias]} { set Library "" scan $Description "%s %s" Bidon Library InformeSansDemander $Nom "Reads: $Alias" InformeSansDemander $Nom "Libraries: $Library" } if {[regexp "^IN0ACA" $Alias]} { set Library "" scan $Description "%s %s" Bidon Library InformeSansDemander $Nom "Reads: $Alias" InformeSansDemander $Nom "Libraries: $Library" } } } 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 InformeCilioCarta {} { FaireLire "Merci de vérifier cette proc, elle est peut-être obsolète" foreach Nom [ListeDesPABs] { set FicTfa [GscopeFile $Nom prottfa] scan [PremiereLigneDuFichier $FicTfa] "%s %s" N Gn set GN [CilioPep $Gn GN] if {$Gn!=$GN} { FaireLire "Ca merde pour $Nom $Gn!=$GN" } #AC ID GN GI TI PI DE SO PM CS LO CN SQ FA" foreach K [CilioPep ListOf Header] G [CilioPep ListOf GscopeHeader] { if {$G==""} { continue } set V [CilioPep $GN $K] InformeSansDemander $Nom "$G: $V" } } return } proc InformeClassePourTous {} { foreach Nom [ListeDesPABs] { set TaxOS [OrganismeDuPAB $Nom] if {$TaxOS==""} { continue } scan $TaxOS "%d" TaxId set Classe [TaxClass $TaxId "" "" Name] Espionne "$Nom Taxonomy: $Classe" InformeSansDemander $Nom "Taxonomy: $Classe" } } proc InformeCytoBand {{Liste ""}} { set total 0 set cas1 0; set cas2 0; set cas3 0; set cas4 0; set cas5 0; set cas6 0; set cas7 0; set cas8 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set LesCytoBand {} incr total #Espionne $Nom set yena2 0 set LocUcsc ""; set CytoBand1 ""; set CytoBand2 ""; set CytoBand ""; set CytoBand1bis ""; set CytoBand2bis "" set CytoBand [ExtraitInfo $Nom "CytoBand:"] set LocUcsc [ExtraitInfo $Nom "LocUcscFrom200602:"] set Attention [ExtraitInfo $Nom "SeqWarning:"] #Espionne "$LocUcsc" if {$CytoBand == ""} { if {$LocUcsc=="" || $LocUcsc=="no value"} { #Espionne "cas1" incr cas1 #Espionne "$Nom CytoBand: no value" InformeSansDemander $Nom "CytoBand: no value" } if {$LocUcsc!="" && $LocUcsc!="no value"} { #Espionne "cas2" incr cas2 #Espionne "$LocUcsc" set LesMotsLocUcsc [split $LocUcsc {:- +/}] set chrLocUcsc [lindex $LesMotsLocUcsc 0] set startLocUcsc [lindex $LesMotsLocUcsc 1] set stopLocUcsc [lindex $LesMotsLocUcsc 2] #Espionne "$chrLocUcsc $startLocUcsc $stopLocUcsc" set CytoBand1 [CytoBandUcsc Mouse $chrLocUcsc $startLocUcsc] set CytoBand2 [CytoBandUcsc Mouse $chrLocUcsc $stopLocUcsc] #Espionne "CytoBand1 $CytoBand1" #Espionne "CytoBand2 $CytoBand2" if {[regexp {/} $LocUcsc]} { set chrLocUcscbis [lindex $LesMotsLocUcsc 5] set startLocUcscbis [lindex $LesMotsLocUcsc 6] set stopLocUcscbis [lindex $LesMotsLocUcsc 7] #Espionne "$chrLocUcscbis $startLocUcscbis $stopLocUcscbis" set CytoBand1bis [CytoBandUcsc Mouse $chrLocUcscbis $startLocUcscbis] set CytoBand2bis [CytoBandUcsc Mouse $chrLocUcscbis $stopLocUcscbis] #Espionne "CytoBand1bis $CytoBand1bis" #Espionne "CytoBand2bis $CytoBand2bis" } if {$CytoBand1=="" && $CytoBand2=="" && $CytoBand1bis=="" && $CytoBand2bis==""} { #Espionne "cas3" incr cas3 #Espionne "$Nom CytoBand: no value" InformeSansDemander $Nom "CytoBand: no value" continue } if {$CytoBand1bis!="" || $CytoBand2bis!=""} { #Espionne"cas4" incr cas4 set LesCytoBand {} if {$CytoBand1!=""} {lappend LesCytoBand $CytoBand1} if {$CytoBand2!=""} {lappend LesCytoBand $CytoBand2} if {$CytoBand1bis!=""} {lappend LesCytoBand $CytoBand1bis} if {$CytoBand2bis!=""} {lappend LesCytoBand $CytoBand2bis} set LesCytoBand [ListeSansDoublon $LesCytoBand] set CytoBand [join $LesCytoBand " et "] #Espionne "$Nom CytoBand: $CytoBand" InformeSansDemander $Nom "CytoBand: $CytoBand" continue } if {$CytoBand1!="" && $CytoBand2!="" && $CytoBand1 == $CytoBand2} { #Espionne "cas5" incr cas5 set yena2 1 set CytoBand $CytoBand1 #Espionne "$Nom CytoBand: $CytoBand" InformeSansDemander $Nom "CytoBand: $CytoBand" } if {$CytoBand1!="" && $CytoBand2!="" && $CytoBand1 != $CytoBand2} { #Espionne"cas6" incr cas6 set yena2 1 set CytoBand "$CytoBand1 et $CytoBand2" #Espionne "$Nom CytoBand: $CytoBand" InformeSansDemander $Nom "CytoBand: $CytoBand" } if {!$yena2 && $CytoBand1!=""} { #Espionne"cas7" incr cas7 set CytoBand $CytoBand1 #Espionne "$Nom CytoBand: $CytoBand" InformeSansDemander $Nom "CytoBand: $CytoBand" } if {!$yena2 && $CytoBand2!=""} { #Espionne"cas8" incr cas8 set CytoBand $CytoBand2 #Espionne "$Nom CytoBand: $CytoBand" InformeSansDemander $Nom "CytoBand: $CytoBand" } } #set CytoBand [ExtraitInfo $Nom "CytoBand:"] } } #Espionne"$total" #Espionne"cas1 $cas1"; Espionne"cas2 $cas2"; Espionne"cas3 $cas3"; Espionne"cas4 $cas4"; Espionne"cas5 $cas5"; Espionne"cas6 $cas6"; Espionne"cas7 $cas7"; Espionne"cas8 $cas8" } proc InformeCytoband {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { Espionne "" Espionne "$Nom" set LesCytoBand {} set Localisation [ExtraitInfo $Nom "Localisation:"] Espionne "Localisation $Localisation" if {$Localisation=="nolocalisation"} { set CytoBand1 "nocytoband" set CytoBand2 "nocytoband" lappend LesCytoBand $CytoBand1 lappend LesCytoBand $CytoBand2 Espionne "CytoBand1 $CytoBand1" Espionne "CytoBand2 $CytoBand2" } else { set LesLocalisations [split $Localisation ","] foreach Loc $LesLocalisations { Espionne "Loc $Loc" set elmtloc [split $Loc " "] set chr [lindex $elmtloc 0] set start [lindex $elmtloc 1] set stop [lindex $elmtloc 2] set CytoBand1 [CytoBandUcsc Human $chr $start] set CytoBand2 [CytoBandUcsc Human $chr $stop] lappend LesCytoBand $CytoBand1 lappend LesCytoBand $CytoBand2 Espionne "CytoBand1 $CytoBand1" Espionne "CytoBand2 $CytoBand2" } } set LesCytoBand [ListeSansDoublon $LesCytoBand] set LesCytoBand [ListeSsElmtVide $LesCytoBand] if {[llength $LesCytoBand]>1} {Espionne "attention"} set LaCytoBand [join $LesCytoBand " AND "] Espionne "$Nom $LaCytoBand" InformeSansDemander $Nom "Cytoband: $LaCytoBand" } } proc InformeDEFromProttfaPourTous {} { #rR On traite ici le cas >Nom BID AC DE1 DE2 DE3 DEi OS= #rR et non pas le cas >Nom BID AC Genre Espesce DE1 DE2 DE3 DEi foreach Nom [ListeDesPABs] { set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]] set DE [lrange [split $Entete " "] 3 end] if {[set iOS [string first "OS=" $DE]]>=0} { set DE [string range $DE 0 $iOS-1] } set DE [string trim $DE] Espionne "$Nom $DE" # FaireLire "$Nom $DE" if {$DE==""} { InformeParSuppressionDuChamp $Nom "DE:" } else { InformeSansDemander $Nom "=DE: $DE" } } } proc InformeDESansOSPourTous {} { foreach Nom [ListeDesPABs] { set DE [ExtraitInfo $Nom "DE:"] if {[set iOS [string first "OS=" $DE]]>=0} { set DE [string trim [string range $DE 0 $iOS-1]] Espionne "$Nom $DE" if {$DE==""} { InformeParSuppressionDuChamp $Nom "DE:" } else { InformeSansDemander $Nom "=DE: $DE" } } } } proc InformeDesUcsc {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set AccessExistant [AccessEvi $Nom] if {$AccessExistant!=""} { set DesUcsc [kgXrefUcscMouse $AccessExistant Des] set DesUcsc [join $DesUcsc ""] #Espionne $DesUcsc set GnUcsc [kgXrefUcscMouse $AccessExistant Gn] if {$GnUcsc!=""} { #InformeSansDemander $Nom "ValiGNUcsc: $GnUcsc" } else { #InformeSansDemander $Nom "ValiGNUcsc: no value" } if {$DesUcsc!=""} { InformeSansDemander $Nom "ValiDEUcsc: $DesUcsc" } else { InformeSansDemander $Nom "ValiDEUcsc: no value" } } else { #InformSansDemander $Nom "ValiGNUcsc: no value" InformeSansDemander $Nom "ValiDEUcsc: no value" } } } proc InformeEFFamily {} { foreach Nom [ListeDesPABs] { set LL [LesLignesDuFichier [GscopeFile $Nom "protembl"]] DecortiqueLesLignesEMBL $LL ID AC DE GN OS InformeSansDemander $Nom "Alias: $AC" InformeSansDemander $Nom "Organism: $OS" } } proc InformeFromOiPourTous {} { if { ! [OuiOuNon "Merci de vérifier cette proc, elle est peut-être obsolète. Il faut peut etre mettre ValiGN ou GN DraftGN. \nJe le fais quand même ?"]} { return "" } foreach Nom [ListeDesPABs] { set FicTfa [GscopeFile $Nom prottfa] set Header [PremiereLigneDuFichier $FicTfa] set Gn [StringApres "GN=" dans $Header] if {[regexp "DRAFT_" $Gn]} { InformeSansDemander $Nom "=DraftGN: $Gn" ; set Gn "" } if {$Gn=="Fragment"} { set Gn "" } regsub "GN=.+" $Header "" Debut set LesMots [LesMotsDuTexte $Debut] set Id [lindex $LesMots 1] set Ac [lindex $LesMots 2] set De [join [lrange $LesMots 5 end] " "] if {[regexp {\|} $Id]} { lassign [split $Id "|"] B A I set Id $I set Ac $A set Ba $B set De [join [lrange $LesMots 2 end] " "] } if {$Id!=""} { InformeSansDemander $Nom "=ID: $Id" } if {$Ac!=""} { InformeSansDemander $Nom "=AC: $Ac" } if {$Gn!=""} { InformeSansDemander $Nom "=GN: $Gn" ; InformeSansDemander $Nom "=Alias: $Gn"} if {$De!=""} { InformeSansDemander $Nom "=DE: $De" } } return "" } proc InformeGeneNameForPerox {Selection} { if {[regexp "\n" $Selection]} { foreach Sel [split $Selection "\n"] { InformeGeneNameForPerox $Sel } return } scan $Selection "%s" Nom set Possible [string trim [StringSuivant $Nom dans $Selection]] if {$Possible==""} { return "" } return [Informe $Nom "ValiGN: $Possible"] } proc InformeGnEtDesProt {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { #Espionne "$Nom" set IdAccProt [ExtraitInfo $Nom "IdAccProt"] set IdAccProt [split $IdAccProt " "] set AccProt [lindex $IdAccProt 1] set Texte ""; set Texte2 "" if {$AccProt!=""} { set Commande "getz \"\\\[protein-acc:$AccProt\\\]\" \-vf gen" set Texte [eval exec $Commande] set LesMotsTexte [split $Texte "\t"] set GnProt [lindex $LesMotsTexte 1] set Commande2 "getz \"\\\[protein-acc:$AccProt\\\]\" \-vf des" set Texte2 [eval exec $Commande2] set LesMotsTexte2 [split $Texte2 "\t"] set DesProt [lindex $LesMotsTexte2 1] regsub -all "\n" $DesProt " " DesProt if {$GnProt!=""} { InformeSansDemander $Nom "ValiGNProt: $GnProt" } else { InformeSansDemander $Nom "ValiGNProt: no value" } if {$DesProt!=""} { InformeSansDemander $Nom "ValiDEProt: $DesProt" } else { InformeSansDemander $Nom "ValiDEProt: no value" } } else { InformeSansDemander $Nom "ValiGNProt: no value" InformeSansDemander $Nom "ValiDEProt: no value" } } } proc InformeGoPourTous {{LesNoms ""}} { #rR 2017/02/10 onne met plus dans les info car il aciste MyGOsFromGene et MyGenesFromGO if {$LesNoms==""} { set LesNoms [ListeDesPABs] } if {[regexp {[ \n\,\t\;\r]} $LesNoms]} { set LesNoms [LesMotsDuTexte $LesNoms] } set N 0 set LesGOs {} foreach Nom $LesNoms { Espionne $Nom set Gn "" if {$Gn==""} { set Gn [ExtraitInfo $Nom "ValiGN:"] } if {$Gn==""} { set Gn [ExtraitInfo $Nom "GN:"] } if {$Gn==""} { set Gn [ExtraitInfo $Nom "DraftGN:"] } if {$Gn==""} { continue } regsub -all {\'} $Gn "prime" Gn set GOs "" # set GOs [ExtraitInfo $Nom "GOs:"] if {$GOs==""} { set GOs [GoGetFromGene $Gn GoAcc "" "" Up] } Espionne $GOs if {[incr N]%100==0} { Espionne "$Nom:Gn:$Gn GOs: $GOs" } if {$GOs==""} { continue } #InformeSansDemander $Nom "=GOs: $GOs" lappend LesGOs "$Nom:$Gn:GOs: $GOs" } return [SauveLesLignes $LesGOs dans [Fiches "NomGnGOs.txt"]] } proc InformeHomologeneId {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set HomologeneId "" #Espionne $Nom set HomologeneId [HomologeneIdAcGenecard $Nom] if {$HomologeneId==""} { #Espionne "$Nom HomologeneId: no value" InformeSansDemander $Nom "HomologeneId: no value" } else { #Espionne "$Nom HomologeneId: $HomologeneId" InformeSansDemander $Nom "HomologeneId: $HomologeneId" } } } proc InformeIdEtAcPourTous {} { if { ! [OuiOuNon "On suppose que les prottfa sont de la forme \n>Box Id Ac"]} { return "" } set TestIt [OuiOuNon "Do I do a test only" 0] foreach Nom [ListeDesPABs] { set FicTfa [GscopeFile $Nom "prottfa"] set Entete [EnteteDuFichierTFA $FicTfa] set Id "" set Ac "" regexp {^>[^ ]+ ([^ ]+) ([^ ]+)} $Entete Match Id Ac if {$Id!="" && ! $TestIt} { InformeSansDemander $Nom "Id: $Id" } if {$Ac!="" && ! $TestIt} { InformeSansDemander $Nom "Ac: $Ac" } lappend LesIdAc "$Nom Id=$Id Ac=$Ac" } return $LesIdAc } proc InformeIdOiAndAcOiPourTous {} { set DoIt [OuiOuNon "Do I write to info files"] set leLog {} foreach Nom [ListeDesPABs] { set Id [ExtraitInfo $Nom "Id:"] set Ac [ExtraitInfo $Nom "Ac:"] set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Id tfa"] set DejaVu($Id) 1 set IdOi "" if {$TFA!=""} { set IdOi $Id } else { foreach I [UniprotHistory $Ac "IdHis"] { if {[info exists DejaVu($I)]} { continue } set DejaVu($I) 1 set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $I tfa"] if {$TFA!=""} { set IdOi $I ; break } } } unset DejaVu set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Ac tfa"] set DejaVu($Ac) 1 set AcOi "" if {$TFA!=""} { set AcOi $Ac } else { foreach A [UniprotHistory $Ac "AcHis"] { if {[info exists DejaVu($A)]} { continue } set DejaVu($A) 1 set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $A tfa"] if {$TFA!=""} { set AcOi $A ; break } } } unset DejaVu set Warning "" if {$Id!=$IdOi || $Ac!=$AcOi} { set Warning "********" } lappend LeLog "$Nom\t$Ac\t$AcOi\t$Id\t$IdOi\t$Warning" if {$IdOi!="" && $DoIt} { InformeSansDemander $Nom "IdOi: $IdOi" } if {$AcOi!="" && $DoIt} { InformeSansDemander $Nom "AcOi: $AcOi" } } return $LeLog } proc InformeIdRefAndAcRefPourTous {} { set TestIt [OuiOuNon "Do I do a test only" 0] set leLog {} foreach Nom [ListeDesPABs] { set Id [ExtraitInfo $Nom "Id:"] set Ac [ExtraitInfo $Nom "Ac:"] set IdAcRef [UniprotHistory $Ac "IdAcRef"] set IdRef "" set AcRef "" scan $IdAcRef "%s %s" IdRef AcRef set Warning "" if {$Id!=$IdRef || $Ac!=$AcRef} { set Warning "********" } lappend LeLog "$Nom\t$Ac\t$AcRef\t$Id\t$IdRef\t$Warning" if {$IdRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdRef: $IdRef" } if {$AcRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcRef: $AcRef" } } return $LeLog } proc InformeIdYaAndAcYaPourTous {} { #rR ne sert pas pour le moment car c'est les mêmes que Oi set TestIt [OuiOuNon "Do I do a test only" 0] set leLog {} foreach Nom [ListeDesPABs] { set Id [ExtraitInfo $Nom "Id:"] set Ac [ExtraitInfo $Nom "Ac:"] set TFA [QuestionDeScience EVImm "ret FromYannis $Id tfa"] set DejaVu($Id) 1 set IdYa "" if {$TFA!=""} { set IdYa $Id } else { foreach I [UniprotHistory $Ac "IdHis"] { if {[info exists DejaVu($I)]} { continue } set DejaVu($I) 1 set TFA [QuestionDeScience EVImm "ret FromYannis $I tfa"] if {$TFA!=""} { set IdYa $I ; break } } } unset DejaVu set TFA [QuestionDeScience EVImm "ret FromYannis $Ac tfa"] set DejaVu($Ac) 1 set AcYa "" if {$TFA!=""} { set AcYa $Ac } else { foreach A [UniprotHistory $Ac "AcHis"] { if {[info exists DejaVu($A)]} { continue } set DejaVu($A) 1 set TFA [QuestionDeScience EVImm "ret FromYannis $A tfa"] if {$TFA!=""} { set AcYa $A ; break } } } unset DejaVu set Warning "" if {$Id!=$IdYa || $Ac!=$AcYa} { set Warning "********" } lappend LeLog "$Nom\t$Ac\t$AcYa\t$Id\t$IdYa\t$Warning" if {$IdYa!="" && ! $TestIt} { InformeSansDemander $Nom "IdYa: $IdYA" } if {$AcYa!="" && ! $TestIt} { InformeSansDemander $Nom "AcYa: $AcYa" } } return $LeLog } proc InformeIdYaRefAndAcYaRefPourTous {} { #rR ne sert pas pour le moment car c'est les mêmes que Oi set TestIt [OuiOuNon "Do I do a test only" 0] set leLog {} foreach Nom [ListeDesPABs] { set Id [ExtraitInfo $Nom "Id:"] set Ac [ExtraitInfo $Nom "Ac:"] set IdAcRef [UniprotHistory $Ac "IdAcRef"] set IdYaRef "" set AcYaRef "" scan $IdAcRef "%s %s" IdYaRef AcYaRef set Warning "" if {$Id!=$IdYaRef || $Ac!=$AcYaRef} { set Warning "********" } lappend LeLog "$Nom\t$Ac\t$AcYaRef\t$Id\t$IdYaRef\t$Warning" if {$IdYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdYaRef: $IdYaRef" } if {$AcYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcYaRef: $AcYaRef" } } return $LeLog } proc InformeIdentitesDuCDNA {Nom} { global RepertoireDuGenome set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom" if { ! [file exists $FichierTFA]} { return "" } set CC "" set Ow "" set Entete [PremiereLigneDuFichier $FichierTFA] if {[OnTraiteDesAffymetrix]} { scan $Entete "%s %s" NomLu AC set NomAccesAliases [lindex [split $Entete ":"] 0] set Definition [lindex [split $Entete ":"] 1] set LesAliases [lrange [split $NomAccesAliases " "] 2 end] set CC "[join $LesAliases " "]" InformeSansDemander $Nom "=AffymetrixAccess: $AC" InformeSansDemander $Nom "=OwnerOfCDNA: Affymetrix" InformeSansDemander $Nom "=GBtagsDefinition: $Definition" } else { scan $Entete "%s %s %s" NomLu CC Ow if {$Ow!=""} { InformeSansDemander $Nom "=OwnerOfCDNA: $Ow" } if {$CC==""} { return "" } } return [InformeSansDemander $Nom "=CodeClone: $CC"] } proc InformeIdentitesDuCDNAPourTous {} { foreach Nom [ListeDesPABs] { Espionne [InformeIdentitesDuCDNA $Nom] } } proc InformeLaFusionAvecProttfa {Nom} { set Fichier "[RepertoireDuGenome]/prottfafusion/$Nom" if { ! [file exists $Fichier]} { return "" } set Entete [EnteteDuFichierTFA $Fichier] regsub ">" $Entete "" Entete regsub "$Nom " $Entete "" TexteF set TexteF "Fusion: $TexteF" set Info [InformeSansDemander $Nom $TexteF] set A [StringApres "obtained by fusion of " dans $Entete] set TexteA "PartAofFusion: $Entete" InformeSansDemander $A $TexteA if {[regexp "because frameshift between" $Entete]} { set B [StringApres "obtained by fusion of $A and " dans $Entete] set TexteB "PartBofFusion: $Entete" InformeSansDemander $B $TexteB } return $Info } proc InformeLaFusionAvecProttfaPourTous {} { foreach Nom [ListeDesFusions] { if { ! [EstUneFusion $Nom]} { continue } set Info [InformeLaFusionAvecProttfa $Nom] Espionne "$Nom\n$Info" } } proc InformeLeCopain {NomAccess {Append ""}} { global RepertoireDuGenome global FenetreInfoOuverte global InformeSansDemander set Access [file tail $NomAccess] set Nom [file tail [file dirname $NomAccess]] set FichierInfo "$RepertoireDuGenome/coinfos/$Nom/$Access" if {[info exists FenetreInfoOuverte($Nom,$Access)]} { raise [set FenetreInfoOuverte($Nom,$Access)] if {$Append == ""} { return "[ContenuDuFichier $FichierInfo]" } if {[OuiOuNon "$Append\n doit etre rajoute a la page info $Nom/$Access\n La page info est deja ouverte.\n Dois-je abandonner ?"]} { return -1 } if {[OuiOuNon "Dois-je le faire maintenant ?"]} { [set FenetreInfoOuverte($Nom,$Access)].text insert end "$Append\n" return -2 } FaireLire "Vous ferez, plus tard, le couper-coller pour moi. Merci." return -3 } set FenetreInfoOuverte($Nom,$Access) "$Nom,$Access" if {! [file exists $FichierInfo]} { set Information "Nom: $Nom $Access" if {[file exists "$RepertoireDuGenome/beton/infocopainmodele"]} { append Information "\n[ContenuDuFichier $RepertoireDuGenome/beton/infocopainmodele]" } Sauve $Information dans $FichierInfo } if { [info exists InformeSansDemander] && $InformeSansDemander } { set BonTexte "[ContenuDuFichier $FichierInfo]\n$Append" } else { set BonTexte [EntreTexte "[ContenuDuFichier $FichierInfo]\n$Append"] } if { $BonTexte != "" } { set TexteOk [Censure "$BonTexte"] Sauve $TexteOk dans $FichierInfo } unset FenetreInfoOuverte($Nom,$Access) return $BonTexte } proc InformeLeCopainSansDemander {NomAccess {Append ""}} { global InformeSansDemander if {[info exists InformeSansDemander]} { set Memo $InformeSansDemander } set InformeSansDemander 1 set Retour [InformeLeCopain $NomAccess $Append] if {[info exists Memo]} { set InformeSansDemander $Memo } return $Retour } proc InformeLesClasses {} { global RepertoireDuGenome global ListeDesPABs global InformeSansDemander set InformeSansDemander 1 if { ! [info exists ListeDesPABs]} { ChargeLesPABs } foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/classes"] { scan $Ligne "%s %s %s" Nom AA Classe set Classes($Nom) $Classe } foreach Nom $ListeDesPABs { Informe $Nom "Class: [set Classes($Nom)]" } } proc InformeLesCopainsDeThetase {{Liste ""}} { global RepertoireDuGenome global InformeSansDemander set InformeSansDemander 1 if {$Liste=={}} { set Liste [ListeDesPABs] } foreach Nom $Liste { foreach FichierCopain [glob -nocomplain "$RepertoireDuGenome/copains/$Nom/*"] { set Access [file tail $FichierCopain] set LesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"] if {$LesEMBL=={}} { InformeLeCopain "$Nom/$Access" "=AltAccess: not found" continue } set SeqCopain [LaSequenceDesLignesEMBL [LesLignesDuFichier $FichierCopain]] set SeqBanque [LaSequenceDesLignesEMBL $LesEMBL] if {[string equal -nocase $SeqCopain $SeqBanque] || [string equal -nocase [string range $SeqCopain 1 end] $SeqBanque]} { InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK" } else { InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK but with no identical sequence" } } } } proc InformeLesMetsCorriges {} { global ListeDeBoites global RepertoireDuGenome global InformeSansDemander Wup "Je lis le fichier metscorriges qui n'est que les 1eres lignes" Wup " des fichiers gcgs contenant 'Cut ...'" set InformeSansDemander 1 foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/metscorriges"] { set Nom [lindex [split $Ligne " "] 0] set iCut [string first "Cut" $Ligne] # set iFin [expr [string first "Length" $Ligne]-1] set Zone [string range $Ligne $iCut end] set Append "NewStartCodon: $Zone" Informe $Nom $Append Espionne "\n$Nom\n$Append" } } proc InformeLocUcscEvi {{FromWhere ""} {Liste ""}} { # cas ou sup a 2 pas traiter set cas1 0; set cas2 0; set cas3 0; set cas4 0; set cas5 0; set cas6 0; set cas7 0; set cas8 0; set cas9 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set Access "" set Ligne ""; set Lignes {} set Access [AccessEvi $Nom] #Espionne "$Nom $Access" if {$Access==""} { #Espionne "cas1" incr cas1 #Espionne "$Nom LocUcscKg$FromWhere: no value" InformeSansDemander $Nom "LocUcscKg$FromWhere: no value" continue } set Lignes [LocUcscEvi $Nom $FromWhere AllLoc] set Lignes [ListeSansDoublon $Lignes] #EspionneL $Lignes if { $Lignes== ":- ()" } { #Espionne "cas2" incr cas2 #Espionne "$Nom LocUcscKg$FromWhere : no value" InformeSansDemander $Nom "LocUcscKg$FromWhere: no value" continue } set long [llength $Lignes] if {$long == 0} { #Espionne "cas3" incr cas3 #Espionne "erreur" } if {$long == 1} { #Espionne "cas4" incr cas4 set Ligne [lindex $Lignes 0] set Ligne [join [LesMotsDeLaLigne $Ligne] " "] #Espionne "$Nom LocUcscKg$FromWhere : $Ligne" InformeSansDemander $Nom "LocUcscKg$FromWhere: $Ligne" } if {$long == 2} { #Espionne "cas5" incr cas5 set Ligne [join $Lignes "/"] #Espionne "$Ligne" set 1rLocal [lindex $Lignes 0] set 2mLocal [lindex $Lignes 1] set LesMots1 [split $1rLocal ":"] set LesMots2 [split $2mLocal ":"] set chrom1 [lindex $LesMots1 0] set chrom2 [lindex $LesMots2 0] if {[regexp {random} $chrom1]} { set LesMots4 [split $chrom1 "_"] set ssrandom [lindex $LesMots4 0] if {$ssrandom == $chrom2} { # Espionne "A 2mLocal= $2mLocal" # Espionne "$Nom LocUcscKg$FromWhere: $2mLocal" InformeSansDemander $Nom "LocUcscKg$FromWhere: $2mLocal" continue } } if {[regexp {random} $chrom2]} { set LesMots5 [split $chrom2 "_"] set ssrandom2 [lindex $LesMots5 0] if {$ssrandom2 == $chrom1} { #Espionne "A 1rLocal= $1rLocal" #Espionne "$Nom LocUcscKg$FromWhere : $1rLocal" InformeSansDemander $Nom "LocUcscKg$FromWhere: $1rLocal" continue } } if {$chrom1==$chrom2} { #Espionne "cas6" incr cas6 #Espionne "$Nom LocUcscKg$FromWhere : $Ligne" InformeSansDemander $Nom "LocUcscKg$FromWhere: $Ligne" continue } if {$chrom1!=$chrom2} { if {[regexp {^NM} $Access]} { #Espionne "cas7" incr cas7 set Commande "getz \"\\\[refseq-acc:$Access\\\] > \\\[refseq_features-ftk:source\\\]\" \-t | grep chromosome" set GetzOut [eval exec $Commande] set LesMots3 [split $GetzOut {\"}] set Numero [lindex $LesMots3 1] Espionne "NCBI= chr$Numero" regsub "chr" $chrom1 "" chrom1 regsub "chr" $chrom2 "" chrom2 if {$Numero==$chrom1} { #Espionne "B 1rLocal= $1rLocal" #Espionne "$Nom LocUcscKg$FromWhere : $1rLocal" InformeSansDemander $Nom "LocUcscKg$FromWhere: $1rLocal" } if {$Numero==$chrom2} { #Espionne "B 2mLocal= $2mLocal" #Espionne "$Nom LocUcscKg$FromWhere : $2mLocal" InformeSansDemander $Nom "LocUcscKg$FromWhere: $2mLocal" } } else { #Espionne "cas8" incr cas8 #Espionne "$Nom LocUcscKg$FromWhere : $Ligne" InformeSansDemander $Nom "LocUcscKg$FromWhere: $Ligne" continue } } } if {$long > 2} { #Espionne "cas9" incr cas9 #Espionne "$Nom $Access plus de 2" EspionneL $Lignes InformeSansDemander $Nom "LocUcscKg$FromWhere: $Ligne" } } #Espionne "" #Espionne "cas1 $cas1";Espionne "cas2 $cas2";Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6";Espionne "cas7 $cas7";Espionne "cas8 $cas8";Espionne "cas9 $cas9" } proc InformeLocUcscPourTous {{Liste ""}} { set total 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set cas1 0; set cas2 0; set cas3 0; set cas4 0; set cas5 0; set cas6 0; set cas7 0; set cas8 0; set cas9 0; set cas10 0 foreach Nom $Liste { incr total set LocUcsc "" set LocUcscGbRs [ExtraitInfo $Nom "LocUcscKgFrom200602"] set LocUcscRs [ExtraitInfo $Nom "LocUcscRsFrom200602"] #Espionne "$Nom" #Espionne "$LocUcscGbRs" #Espionne "$LocUcscRs" set dsles2 0 if {![regexp {[0-9]+} $LocUcscGbRs] && ![regexp {[0-9]+} $LocUcscRs]} { #Espionne "cas1" incr cas1 set LocUcsc "no value" InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } elseif {[regexp {[0-9]+} $LocUcscGbRs] && [regexp {[0-9]+} $LocUcscRs]} { #Espionne "cas2" incr cas2 set dsles2 1 if {$LocUcscGbRs == $LocUcscRs} { #Espionne "cas3" incr cas3 set LocUcsc $LocUcscGbRs InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } else { if {[regexp "/" $LocUcscGbRs]} { #Espionne "cas4" incr cas4 set LesLocs [split $LocUcscGbRs {/}] foreach Loc $LesLocs { if {$Loc==$LocUcscRs} { set LocUcsc $LocUcscRs break } } #Espionne "$LocUcsc" InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" if {$LocUcsc==""} {Espionne "attention cas pas traite" } continue } if {[regexp "/" $LocUcscRs]} { #Espionne "cas5" incr cas5 set LesLocs [split $LocUcscRs {/}] foreach Loc $LesLocs { if {$Loc==$LocUcscGbRs} { set LocUcsc $LocUcscGbRs break } } #Espionne "$LocUcsc" InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" if {$LocUcsc==""} {Espionne "attention cas pas traite" } continue } #Espionne "cas6" incr cas6 set LesMotsGbRs [split $LocUcscGbRs {:- }] set startGbRs [lindex $LesMotsGbRs 1] set stopGbRs [lindex $LesMotsGbRs 2] set longGbRs [expr $stopGbRs-$startGbRs] set LesMotsRs [split $LocUcscRs {:- }] set startRs [lindex $LesMotsRs 1] set stopRs [lindex $LesMotsRs 2] set longRs [expr $stopRs-$startRs] if {$longGbRs < $longRs} { #Espionne "cas7" incr cas7 set LocUcsc $LocUcscRs*litige* InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } else { #Espionne "cas8" incr cas8 set LocUcsc $LocUcscGbRs*litige* InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } } } elseif {!$dsles2 && [regexp {[0-9]+} $LocUcscGbRs]} { #Espionne "cas9" incr cas9 set LocUcsc $LocUcscGbRs InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } elseif {!$dsles2 && [regexp {[0-9]+} $LocUcscRs]} { #Espionne "cas10" incr cas10 set LocUcsc $LocUcscRs InformeSansDemander $Nom "LocUcscFrom200602: $LocUcsc" } #Espionne "$LocUcsc" } #Espionne "$total" #Espionne "cas1 $cas1";Espionne "cas2 $cas2";Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6";Espionne "cas7 $cas7";Espionne "cas8 $cas8";Espionne "cas9 $cas9";Espionne "cas10 $cas10" } proc InformeLocUcscRefSeqEvi {{FromWhere ""} {Liste ""}} { set cas1 0; set cas2 0; set cas3 0; set cas4 0; set cas5 0; set cas6 0; set cas7 0; set cas8 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { #Espionne "" set Ligne ""; set Lignes {} set Access [AccessEvi $Nom] #Espionne "$Nom $Access" if {$Access==""} { #Espionne "cas1" incr cas1 #Espionne "$Nom LocUcscRs$FromWhere: no value" InformeSansDemander $Nom "LocUcscRs$FromWhere: no value" continue } set Lignes [LocUcscRefSeqEvi $Access $FromWhere AllLoc] set Lignes [ListeSansDoublon $Lignes] #EspionneL $Lignes if { $Lignes== ":- ()" } { #Espionne "cas2" incr cas2 #Espionne "$Nom LocUcscRs$FromWhere : no value" InformeSansDemander $Nom "LocUcscRs$FromWhere: no value" continue } set long [llength $Lignes] if {$long == 0} { #Espionne "cas3" incr cas3 #Espionne "erreur" } if {$long == 1} { #Espionne "cas4" incr cas4 set Ligne [lindex $Lignes 0] set Ligne [join [LesMotsDeLaLigne $Ligne] " "] #Espionne "$Nom LocUcscRs$FromWhere : $Ligne" InformeSansDemander $Nom "LocUcscRs$FromWhere: $Ligne" } if {$long == 2} { #Espionne "cas5" incr cas5 set Ligne [join $Lignes "/"] #Espionne "$Ligne" set 1rLocal [lindex $Lignes 0] set 2mLocal [lindex $Lignes 1] set LesMots1 [split $1rLocal ":"] set LesMots2 [split $2mLocal ":"] set chrom1 [lindex $LesMots1 0] set chrom2 [lindex $LesMots2 0] if {[regexp {random} $chrom1]} { set LesMots4 [split $chrom1 "_"] set ssrandom [lindex $LesMots4 0] if {$ssrandom == $chrom2} { #Espionne "A 2mLocal= $2mLocal" #Espionne "$Nom LocUcscRs$FromWhere : $2mLocal" InformeSansDemander $Nom "LocUcscRs$FromWhere: $2mLocal" continue } } if {[regexp {random} $chrom2]} { set LesMots5 [split $chrom2 "_"] set ssrandom2 [lindex $LesMots5 0] if {$ssrandom2 == $chrom1} { #Espionne "A 1rLocal= $1rLocal" #Espionne "$Nom LocUcscRs$FromWhere : $1rLocal" InformeSansDemander $Nom "LocUcscRs$FromWhere: $1rLocal" continue } } if {$chrom1==$chrom2} { #Espionne "cas6" incr cas6 #Espionne "$Nom LocUcscRs$FromWhere : $Ligne" InformeSansDemander $Nom "LocUcscRs$FromWhere: $Ligne" continue } if {$chrom1!=$chrom2} { #Espionne "cas7" incr cas7 set Commande "getz \"\\\[refseq-acc:$Access\\\] > \\\[refseq_features-ftk:source\\\]\" \-t | grep chromosome" set GetzOut [eval exec $Commande] set LesMots3 [split $GetzOut {\"}] set Numero [lindex $LesMots3 1] #Espionne "NCBI= chr$Numero" regsub "chr" $chrom1 "" chrom1 regsub "chr" $chrom2 "" chrom2 if {$Numero==$chrom1} { #Espionne "B 1rLocal= $1rLocal" #Espionne "$Nom LocUcscRs$FromWhere : $1rLocal" InformeSansDemander $Nom "LocUcscRs$FromWhere: $1rLocal" } if {$Numero==$chrom2} { #Espionne "B 2mLocal= $2mLocal" #Espionne "$Nom LocUcscRs$FromWhere : $2mLocal" InformeSansDemander $Nom "LocUcscRs$FromWhere: $2mLocal" } } } if {$long > 2} { #Espionne "cas8" incr cas8 #Espionne "$Nom $Access plus de 2" #EspionneL $Lignes InformeSansDemander $Nom "LocUcscRs$FromWhere: $Ligne" } } #Espionne "" #Espionne "cas1 $cas1";Espionne "cas2 $cas2";Espionne "cas3 $cas3";Espionne "cas4 $cas4";Espionne "cas5 $cas5";Espionne "cas6 $cas6";Espionne "cas7 $cas7";Espionne "cas8 $cas8" } proc InformeLocandCytoband {} { #InformeSansDemander PR001 "LocUcsc: chr22:41892572-41913051 (-)" #InformeSansDemander PR002 "LocUcsc: chr13:43905660-44048701 (-)" #InformeSansDemander PR003 "LocUcsc: chr8:59150669-59223896 (+)" #InformeSansDemander PR001 "CytoBand: 22q13" #InformeSansDemander PR002 "CytoBand: 13q14" #InformeSansDemander PR003 "CytoBand: 8q12" InformeSansDemander PR001 "Interaction: LRCH4" InformeSansDemander PR002 "Interaction: beta-estradiol,CLEC11A,CTNNB1,CYP1A1,ERBB2,PAX3,TSC22D4" InformeSansDemander PR003 "Interaction: TRIM24" } proc InformeMGI {{Liste ""}} { #attention pour les nd de mito ca marche pas if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set LesMGI {}; set LesLignesResultat {} set Acc [AccessEvi $Nom] if { [regexp {^NM_} $Acc] || [regexp {^XM_} $Acc] || [regexp {^NR_} $Acc]} { set CommandeRs "getz \"\\\[refseq-acc:$Acc\\\]\" \-f Gene | grep /db_xref=\"MGI" if {[catch {set GetzOutRs [eval exec $CommandeRs]}]} {set GetzOutRs ""} if {$GetzOutRs==""} { InformeSansDemander $Nom "MGI: no value" continue } #Espionne $GetzOutRs set LesLignesResultat [split $GetzOutRs "\n"] foreach LigneResultat $LesLignesResultat { lappend LesMGI [StringApres ":" dans $LigneResultat] } } else { set CommandeGb "getz \"\\\[genbankfull-acc:$Acc\\\]\" \-f Gene | grep /db_xref=\"MGI" if {[catch {set GetzOutGb [eval exec $CommandeGb]}]} { set GetzOutGb "" } if {$GetzOutGb==""} { InformeSansDemander $Nom "MGI: no value" continue } set LesLignesResultat [split $GetzOutGb "\n"] foreach LigneResultat $LesLignesResultat { lappend LesMGI [StringApres ":" dans $LigneResultat] } } set LesMGI [ListeSansDoublon $LesMGI] #EspionneL "$LesMGI" if {[llength $LesMGI]>1} {Espionne "$Nom attention pls MGI"} set MGI [lindex $LesMGI 0] regsub -all "\"" $MGI "" MGI InformeSansDemander $Nom "MGI: $MGI" #Espionne "$Nom $Acc $MGI" } } proc InformeMGU4302 {} { foreach Ligne [LesLignesDuFichier [RepertoireDuGenome]/MGU4302.fof] Nom [ListeDesPABs] { scan $Ligne "%s %s" PS F set Queue [file tail $F] regsub "_$PS$" $Queue "" Acc InformeSansDemander $Nom "Alias: $PS" InformeSansDemander $Nom "Probeset: $PS" InformeSansDemander $Nom "Acc: $Acc" } } 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 InformeOrganisme {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set total 0; set lessans 0; set lesavec 0; set passeq 0; set erreur 0 set lessouris 0; set leshommes 0; set lessaispas 0 foreach Nom $Liste { #Espionne "" incr total set GetzOutRs ""; set GetzOutGb ""; set orga "" set Acc [AccessEvi $Nom] #Espionne "$Nom" if {$Acc==""} { # Espionne "passeq" incr passeq continue } #Espionne "$Acc" if {[regexp {^NM_} $Acc] || [regexp {^XM_} $Acc] || [regexp {^NR_} $Acc]} { set CommandeRs "getz \"\\\[refseq-acc:$Acc\\\]\" \-vf org" if {[catch {set GetzOutRs [eval exec $CommandeRs]}]} {set GetzOutRs ""} if {$GetzOutRs!=""} { set orga [StringSuivant "\t" dans $GetzOutRs] #Espionne "$GetzOutRs" #Espionne "$orga" #Espionne "oui" incr lesavec if {[regexp {^Mus} $orga]} { incr lessouris #Espionne "souris" } elseif {[regexp {^Homo sapiens} $orga]} { incr leshommes #Espionne "homme" } else {incr lessaispas #Espionne "saispas" } InformeSansDemander $Nom "Organism: $orga" } if {$GetzOutRs==""} { #Espionne "pas" incr lessans InformeSansDemander $Nom "Organism: no value" } } else { set CommandeGb "getz \"\\\[genbankfull-acc:$Acc\\\]\" \-vf org" if {[catch {set GetzOutGb [eval exec $CommandeGb]}]} { set GetzOutGb "" } if {$GetzOutGb!=""} { set orga [StringSuivant "\t" dans $GetzOutGb] #Espionne "$GetzOutGb" #Espionne "$orga" #Espionne "oui" incr lesavec if {[regexp {^Mus} $orga]} { incr lessouris #Espionne "souris" } elseif {[regexp {^Homo sapiens} $orga]} { incr leshommes #Espionne "homme" } else { incr lessaispas #Espionne "saispas" } InformeSansDemander $Nom "Organism: $orga" } if {$GetzOutGb==""} { #Espionne "pas" incr lessans InformeSansDemander $Nom "Organism: no value" } } } #Espionne "total $total" #Espionne "passeq $passeq" #Espionne "lessans $lessans" #Espionne "erreur $erreur" #Espionne "lesavec $lesavec" #Espionne "lessouris $lessouris" #Espionne "leshommes $leshommes" #Espionne "lessaispas $lessaispas" } proc InformeOrganismePourBSD {{Source ""}} { if {$Source == ""} { set Source"organismesdespabs" } if {[regexp -nocase "descriptif" $Source]} { set Source "descriptif" } if {$Source == "organismesdespabs"} { set FichierOrganisme "[RepertoireDuGenome]/fiches/organismesdespabs" while {[FileAbsent $FichierOrganisme]} { if {[OuiOuNon "$FichierOrganisme n'existe pas\nDois-je stopper ?"]} { exit } set FichierOrganisme [Entre $FichierOrganisme] } foreach Ligne [LesLignesDuFichier $FichierOrganisme] { Espionne $Ligne scan $Ligne "%s" Nom regsub "$Nom " $Ligne "" Orga InformeSansDemander $Nom "OS: $Orga" } return } if {$Source == "descriptif"} { foreach Nom [ListeDesPABs] { set FichierDescriptif [GscopeFile $Nom "descriptifs"] if {[FileAbsent $FichierDescriptif]} { set OS "Unknown unknown" } else { set Meilleur [PremiereLigneDuFichier $FichierDescriptif] set OS [ChampDuDescriptif $Meilleur "OS"] } InformeSansDemander $Nom "OS: $OS" } return } } proc InformePDB {} { set Fichier "[RepXbgs]/PdbOfNuclearReceptorsIGBMC.list" foreach Ligne [LesLignesDuFichier $Fichier] { set Alias "" scan $Ligne "%s %s" aPDB Alias if {$Alias==""} { continue } lappend LesPdbsDuAlias($Alias) $aPDB } set LesPDBsOk {} foreach PAB [ListeDesPABs] { set Alias [Alias $PAB] if { ! [info exists LesPdbsDuAlias($Alias)]} { continue } foreach aPDB [set LesPdbsDuAlias($Alias)] { set FichierBlast "[RepertoireDuGenome]/blastp/$PAB" if { ! [file exists $FichierBlast]} { FaireLire "no blastp for $PAB" ; continue } set Fen [AfficheFichier $FichierBlast "AvecSegAlignement"] Illumine $aPDB $Fen set Info [Informe $PAB "PDB: $aPDB"] if {$Info==""} { continue } lappend LesPDBsOk "$PAB $Alias $aPDB" } } SauveLesLignes $LesPDBsOk dans LesPDBsOk return $LesPDBsOk } proc InformeParChangementEnteteDuChamp {Ancien Nouveau} { foreach Nom [ListeDesPABs] { set Valeur [ExtraitInfo $Nom $Ancien] if {$Valeur==""} { continue } Espionne "$Nom $Nouveau: $Valeur" InformeParSuppressionDuChamp $Nom $Ancien InformeSansDemander $Nom "$Nouveau: $Valeur" } } proc InformeParClonage {Nom {GenomeOrigine ""} {Champ ""}} { global RepertoireDuGenome global GenomeACloner PrefixeDuGenomeACloner if {$GenomeOrigine!=""} { set GenomeACloner $GenomeOrigine if { ! [file exists $GenomeACloner]} { set GenomeACloner "$RepertoireDuGenome/../[file tail $GenomeACloner]" set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner] } if { ! [file exists $GenomeACloner]} { if { [OuiOuNon "$GenomeOrigine\n and \n$GenomeACloner\n don't exist.\n Do I cancel ?"]} { return "Cancel" } unset GenomeACloner } } while { ! [info exists GenomeACloner]} { FaireLire "Please select the genome from which the info have to be taken." set GenomeACloner [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."] if {$GenomeACloner==""} { if {[OuiOuNon "Do I cancel ?"]} { return "Cancel" } continue } set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner] break } if {[file tail $GenomeACloner]==[file tail $RepertoireDuGenome]} { FaireLire "You want to clone myself ... I cancel." return "Cancel" } regsub "^[PreFixe]" $Nom $PrefixeDuGenomeACloner PAB set FichierInfo "$GenomeACloner/infos/$PAB" if { ! [file exists $FichierInfo]} { return "" } set OnAttendLeBon 1 set LesTextes {} foreach Ligne [LesLignesDuFichier $FichierInfo] { if {$OnAttendLeBon && $Ligne=="Nom: $PAB"} { set OnAttendLeBon 0 continue } if {$OnAttendLeBon} { if {[OuiOuNon "$PAB is wrong, Do You want to see the info file ?"]} { AfficheFichier $FichierInfo "SansFetch" } if {[OuiOuNon "$PAB is wrong, Do I cancel ?"]} { return "Cancel"} if {[OuiOuNon "$PAB is wrong, Do I skipp it ?"]} { return ""} if { ! [OuiOuNon "$PAB is wrong, Do I accept it ?"]} { exit } set OnAttendLeBon 0 } if {$PrefixeDuGenomeACloner!=[PreFixe]} { while {[regexp "$PrefixeDuGenomeACloner\[0-9\]+" $Ligne Match]} { regsub $PrefixeDuGenomeACloner $Match [PreFixe] NouveauMatch regsub -all $Match $Ligne $NouveauMatch Ligne } } if {$Champ!="" && ! [regexp "^$Champ: " $Ligne]} { continue } lappend LesTextes $Ligne } if {$LesTextes=={}} { return "" } set Textes [join $LesTextes "\n"] Espionne "Clonage de $PAB vers $Nom $Textes" return [InformeSansDemander $Nom $Textes] } proc InformeParClonagePourTous {{GenomeOrigine ""} {Champ ""}} { foreach Nom [ListeDesPABs] { if {[InformeParClonage $Nom $GenomeOrigine $Champ]=="Cancel"} { return "Cancel" } } } proc InformeParMiseAJourPourTous {{Commande ""} {Champ ""} {Test 0} {Ask 0}} { global RepertoireDuGenome global InformeSansDemander Wup "Evals Commande and appends it to info, field Champ if not empty." Wup "If Test is 1 nothing happends" set Test [expr $Test != 0] set Ask [expr $Ask != 0] if {$Commande==""} { set Commande [Entre "\[PutHereTheCommand \$Nom\]"] if {$Commande==""} { return "" } } if { ! [info exists InformeSansDemander]} { set InformeSansDemander 0 } set MemoInformeSansDemander $InformeSansDemander set InformeSansDemander [expr ! $Ask] set n 0 foreach Boite [ListeDeBoites] { set Nom [Box $Boite nom] eval set Valeur $Commande if {$Valeur==""} { continue } incr n if {$Champ!=""} { set Append "$Champ: $Valeur" } else { set Append $Valeur } if {$Test} { Espionne "$Nom ... $Append" } else { Informe $Nom $Append } } set InformeSansDemander $MemoInformeSansDemander return "$n infos/ files were updated" } proc InformeParNarcisse {Nom} { set Nar [Narcisse $Nom] if {$Nar==""} { Espionne "$Nom ++++" ;return "" } set Ref [RefOfAC $Nar] if {$Ref==""} { Espionne "$Nom ----" ;return "" } Espionne "$Nom $Nar" foreach Champ [LesChampsInteressantsDeNarcisse] { set Texte "${Champ}_Narcisse: [FromRef $Ref $Champ]" lappend LesTextes $Texte } set Textes [join $LesTextes "\n"] return [InformeSansDemander $Nom $Textes] } proc InformeParNarcissePourTous {} { foreach Nom [ListeDesPABs] { InformeParNarcisse $Nom } } proc InformeParProtemblPourTous {{DoIt ""}} { if {$DoIt==""} { if {[OuiOuNon "Do I really do the updates"]} { set DoIt "DoIt" } } set DoIt [string equal -nocase $DoIt "DoIt"] foreach Nom [ListeDesPABs] { set FicEmbl [GscopeFile $Nom protembl] set LesLignesEMBL [LesLignesDuFichier $FicEmbl] DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX set LesK [list ID AC DE GN OS OC OX] foreach K $LesK { set V [set $K] if {$V==""} { continue } set ClefInfo $K if {$K=="ID"} { if {$ID==$Nom} { #rR pour CilioCarta on va chercher l'ID dans le prottfa set FicTfa [GscopeFile $Nom prottfa] set Header [PremiereLigneDuFichier $FicTfa] scan $Header "%s %s" N I set A "" ; set B ""; set C "" lassign [split $I "|"] A B C if {$C!=""} { set ID $C } elseif {$B!=""} { set ID $B } else { set ID $A } } set V $ID set ClefInfo "Id" } if {$K=="AC"} { set ClefInfo "Ac" } if {$K=="DE"} { set ClefInfo "ValiDE" } if {$K=="GN"} { set ClefInfo "ValiGN" } if {$DoIt} { InformeSansDemander $Nom "=$ClefInfo: $V" } else { Espionne "InformeSansDemander $Nom =$ClefInfo: $V" } lappend LesInfos "$Nom =$ClefInfo: $V" } } return $LesInfos } proc InformeParSpinePourTous {} { foreach Nom [ListeDesPABs] { set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"] set E $Entete foreach Clef {SpineID SpineDef SpineRef} { if {[set iDeb [string first "$Clef (" $E]]<0} { continue } set iFin [string last ")" $E] set Val [string range $E $iDeb [incr iFin -1]] set Old [ExtraitInfo $Nom $Clef] regsub "$Clef \\(" $Val "" Val set Val [string trim $Val] set Valeur($Clef) $Val set E [string range $E 0 [incr iDeb -1]] Espionne "$Clef $Val" if {$Old==$Val} { continue } if {$Old!="" && [OuiOuNon "For $Nom I had $Clef: \n$Old and got \n$Val\nDo I keep ?"]} { continue } if {$Clef=="SpineRef"} { InformeSansDemander $Nom "SpineRef: $Val" } if {$Clef=="SpineID"} { InformeSansDemander $Nom "SpineID: $Val" } if {$Clef=="SpineDef"} { InformeSansDemander $Nom "SpineDef: $Val" } }source /biolo/srs/setsrs.com } } proc InformeParSuppressionDuChamp {Nom Champ {PourVoir ""}} { global RepertoireDuGenome if {$PourVoir==""} { set PourVoir 0 } else { set PourVoir 1 } Wup "Deletes all fields begining with 'Champ' in the infos files (Champ can be with or without ':' )" Wup "Attention use 'ABC:' to remove the Champ ABC (and not ABCD ...)" if {[regexp {\:} $Champ]} { regsub {\:} $Champ {\:} Champ } set FichierInfo "$RepertoireDuGenome/infos/$Nom" if { ! [file exists $FichierInfo]} { return "" } set NouvellesLignes {} set YaSuppression 0 foreach Ligne [LesLignesDuFichier $FichierInfo] { if {[regexp "^$Champ" $Ligne]} { set YaSuppression 1 continue } lappend NouvellesLignes $Ligne } if { ! $PourVoir && $YaSuppression} { SauveLesLignes $NouvellesLignes dans $FichierInfo } return [join $NouvellesLignes "\n"] } proc InformeParSuppressionDuChampPourTous {Champ} { foreach Boite [ListeDeBoites] { set Nom [Box $Boite nom] InformeParSuppressionDuChamp $Nom $Champ } return } proc InformePourTous {{Clef ""} {Commande ""}} { foreach Nom [ListeDesPABs] { set Valeur "" if {$Commande!=""} { set Valeur [eval $Commande $Nom] } #rR if {$Valeur==""} { continue } Espionne "$Nom $Clef: $Valeur" if {$Clef!=""} { InformeSansDemander $Nom "$Clef: $Valeur" } else { InformeSansDemander $Nom "" } } } proc InformePourUnNuc {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { #prevoir message quand erreur InformeRetinalTargetsAcTfa $Nom InformeRetinalTargetsSuite $Nom #ProtParGeneNamePourTous cree TabCorres ProtParGeneNamePourTous $Nom DeProtEmblVersProtTfaEvi $Nom RangeProt $Nom InformeOrganisme $Nom InformeAccessProt $Nom InformeGnEtDesProt $Nom InformeDesUcsc $Nom #InformeProbeSetID cree fichier affyanno InformeProbeSetID $Nom InformeLocUcscEvi From200602 $Nom InformeLocUcscRefSeqEvi From200602 $Nom InformeLocUcscPourTous $Nom InformeCytoBand $Nom InformeHomologeneId $Nom InformeMGI $Nom InformeSynonyms $Nom } } proc InformePourUneProt {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { InformeAccessProt $Nom DeProtVersNuc $Nom InformeRetinalTargetsAcTfa $Nom InformeRetinalTargetsSuite $Nom InformeOrganisme $Nom InformeGnEtDesProt $Nom InformeDesUcsc $Nom #InformeProbeSetID cree fichier affyanno InformeProbeSetID $Nom InformeLocUcscEvi From200602 $Nom InformeLocUcscRefSeqEvi From200602 $Nom InformeLocUcscPourTous $Nom InformeCytoBand $Nom InformeHomologeneId $Nom InformeMGI $Nom InformeSynonyms $Nom } } proc InformeProbeSetID {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set AccessmRNA [AccessEvi $Nom] set LesProbeSetId {} #verif que cest la derniere version foreach ProbeSetId [lsort -unique [AffyAnno $AccessmRNA "Probe_Set_ID"]] { lappend LesProbeSetId $ProbeSetId } if {$LesProbeSetId=={}} { InformeSansDemander $Nom "ProbeSetId: no value" } else { set PSI [join $LesProbeSetId ","] InformeSansDemander $Nom "ProbeSetId: $PSI" } } } proc InformeRDH12 {} { set Nom [NomDuAlias "RDH12"] foreach BP [RDH12 ListOf Mutations] { InformeSansDemander $Nom "GAL: $BP" } } proc InformeRefPfam {} { foreach Box [ListeDesPABs] { set RefPfam [InterrogeRefPfam $Box RefPfam] InformeSansDemander $Box "RefPfam: $RefPfam" } } proc InformeReferencePourBSD {} { foreach Nom [ListeDesPABs] { set Alias [Alias $Nom] set GI [References [string toupper $Alias]] InformeSansDemander $Nom "OldGI: $GI" } } proc InformeRetinalTargets {} { foreach Nom [ListeDesPABs] { set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"] if {[regexp "bidon" $Entete]} { set Raison [StringSuivant "bidon" dans $Entete] InformeSansDemander $Nom "SeqWarning: No sequence available $Raison" continue } set iP [string last "(" $Entete] set GN "" if {$iP>0} { set iF [string last ")" $Entete] set GN [string range $Entete [incr iP] [incr iF -1]] if {[regexp " " $GN]} { set GN "" } if {[regexp -nocase "Fragment" $GN]} { set GN "" } } if {$GN!=""} { InformeSansDemander $Nom "ValiGN: $GN" } scan $Entete "%s %s %s %s" N BId Genre Espece if {$Genre=="M."} { set Genre "Mus" } InformeSansDemander $Nom "Organism: $Genre $Espece" InformeSansDemander $Nom "BId: $BId" set DE [StringSuivant " " dans $Entete] if {$DE!=""} { InformeSansDemander $Nom "DE: $DE" } } exit } proc InformeRetinalTargetsAcTfa {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { #Espionne $Nom set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"] #Espionne "1 $Entete" if {[regexp "bidon" $Entete]} { set Raison [StringSuivant "bidon" dans $Entete] InformeSansDemander $Nom "SeqWarning: No sequence available $Raison" continue } scan $Entete "%s %s %s %s" N BAcc Genre Espece if {$Genre=="M."} { set Genre "Mus" } #InformeSansDemander $Nom "Organism: $Genre $Espece" #cest mieux de faire comme apres InformeSansDemander $Nom "BAcc: $BAcc" set index [string first ":" $Entete] set i [string first " " $Entete $index] #Espionne "2 $Entete" set DE [string range $Entete [expr $i + 1] end] #Espionne "3 $DE" if {$DE!=""} { InformeSansDemander $Nom "ValiDE: $DE" } } } proc InformeRetinalTargetsSuite {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set GetzOutRs ""; set GetzOutGb ""; set LeGeneName "" set Acc [AccessEvi $Nom] #Espionne "$Nom $Acc" if { [regexp {^NM_} $Acc] || [regexp {^XM_} $Acc] || [regexp {^NR_} $Acc]} { set CommandeRs "getz \"\\\[refseq-acc:$Acc\\\]\" \-f Gene | grep /gene" if {[catch {set GetzOutRs [eval exec $CommandeRs]}]} {set GetzOutRs ""} if {$GetzOutRs!=""} { set LeGeneName [string range $GetzOutRs [expr [string first = $GetzOutRs] + 2] [expr [string first \" $GetzOutRs [expr [string first = $GetzOutRs] + 2]] - 1]] #Espionne "$GetzOutRs" #Espionne "$Acc $LeGeneName" if {$LeGeneName!=""} { InformeSansDemander $Nom "ValiGN: $LeGeneName" } } } else { set CommandeGb "getz \"\\\[genbankfull-acc:$Acc\\\]\" \-f Gene | grep /gene=" if {[catch {set GetzOutGb [eval exec $CommandeGb]}]} { set GetzOutGb "" } if {$GetzOutGb!=""} { set LeGeneName [string range $GetzOutGb [expr [string first = $GetzOutGb] + 2] [expr [string first \" $GetzOutGb [expr [string first = $GetzOutGb] + 2]] - 1]] #Espionne "$GetzOutGb" #Espionne "$Acc $LeGeneName" if {$LeGeneName!=""} { InformeSansDemander $Nom "ValiGN: $LeGeneName" } } } } } proc InformeSansDemander {Nom {Append ""}} { global InformeSansDemander if { ! [info exists InformeSansDemander]} { set InformeSansDemander 0 } set SauveInformeSansDemander $InformeSansDemander set InformeSansDemander 1 set Retour [Informe $Nom $Append] set InformeSansDemander $SauveInformeSansDemander return $Retour } proc InformeSansDemanderParWscope {Nom Page} { InformeSansDemander $Nom $Page return [Informe $Nom] } proc InformeSeqCheck {Selection Page} { Wup "First we take from Selectio then from Page" set Tout "$Selection\n$Page" set PGS "" set FichierBlast "BlastfileNotFound" set CodeSeqFile "CodeSequenceFileNotFound" set P "NoOligoFound" foreach Ligne [split $Tout "\n"] { if {$FichierBlast=="BlastfileNotFound" && [regexp ".blast$" $Ligne]} { set FichierBlast $Ligne set CodeSeqFile [file tail $FichierBlast] regsub {\.blast$} $CodeSeqFile "" CodeSeqFile } if {[regexp "^ PGS " $Ligne] && $PGS==""} { scan $Ligne "%s %s" Bidon PGS } if {[regexp "^ Oli " $Ligne] && $P=="NoOligoFound"} { scan $Ligne "%s %s" Bidon P } if {$FichierBlast!="BlastfileNotFound" && $CodeSeqFile!="CodeSequenceFileNotFound" && $P!="NoOligoFound"} { break } } global TextePourInformeVerificationSequencage if {[info exists TextePourInformeVerificationSequencage]} { set Bornes $TextePourInformeVerificationSequencage } else { set Bornes "" } set SeqCheck "SeqCheck: $CodeSeqFile $P $Bornes" if {$PGS==""} { return "" } if { ! [OuiOuNon "Ok to inform '$PGS' with \n$SeqCheck"]} { return "" } return [Informe $PGS $SeqCheck] } proc InformeSpineDefPourTous {} { foreach Nom [ListeDesPABs] { set DE [SpineDefinition $Nom] if {$DE==""} { continue } Espionne "$Nom $DE" InformeSansDemander $Nom "SpineDef: $DE" } } proc InformeSpineIDPourTous {} { if {[PreFixe]!="PGS" && [OuiOuNon "Attention InformeSpineIDPourTous ne marche que pour ProGS. Je stoppe ?"]} { return } CreateTargetId "Reset" foreach PGS [ListeDesPABs] { if {[EstUnPABMute $PGS]} { continue } set ProbableSpineID [CreateTargetId $PGS] if { ! [SpineOK $PGS]} { continue } set NomSpine [QuestionDeScience Spine "ret GscopeID $ProbableSpineID"] set SpineID [QuestionDeScience Spine "ret SpineID $NomSpine Full"] if {$SpineID==""} { continue } scan $SpineID "%s" NomDuSpineID if {$NomDuSpineID!=$ProbableSpineID} { FaireLire "$Nom $ProbableSpineID $SpineID" } Espionne "$PGS $SpineID $NomSpine" InformeSansDemander $PGS "=SpineID: $SpineID" InformeSansDemander $PGS "SpineGscopeName: $NomSpine" } exit } proc InformeSpliRet {Org} { if {[regexp -nocase "Mouse" $Org]} { set LesRepertoires [LesRepertoires "Mouse" "Mod"] set Org "Mus_musculus" } if {[regexp -nocase "Rat" $Org]} { set LesRepertoires [LesRepertoires "Rat" "Mod"] set Org "Rattus_norvegicus" } set nbfic 0 foreach Repertoire $LesRepertoires { if {[regexp "others" $Repertoire]} {set Tag "other"} if {[regexp "Tfactor" $Repertoire]} {set Tag "TF"} if {[regexp "NO_ALT" $Repertoire]} {set Tag "noalt"} foreach FileInitial [glob -nocomplain "$Repertoire/*"] { set Cluster [file tail $FileInitial] regsub {\.[^\.]+$} $Cluster "" Cluster set Box [InterrogeBox $Cluster Box] set Ref [InterrogeBox $Box Ref] if {[regexp "^ENS" $Ref]} { set Gn [GnDesFromEnsembl $Ref transcript $Org Gn] set Des [GnDesFromEnsembl $Ref transcript $Org Des] } if {[regexp "^NM" $Ref] || [regexp "^XM" $Ref]} { set Names {} set CommandeDes "getz \"\\\[refseq-acc:$Ref\\\]\" \-vf des" set GetzOutDes [eval exec $CommandeDes] set Des [lindex [split $GetzOutDes "\t"] 1] set CommandeGn "getz \"\\\[refseq-acc:$Ref\\\]\" \-vf Gene" set GetzOutGn [eval exec $CommandeGn] set LesLignes [split $GetzOutGn "\n"] foreach Ligne $LesLignes { set LesMots [split $Ligne "\t"] set Nb [llength $LesMots] lappend Names [lindex $LesMots [expr $Nb-1]] } set Names [lsort -unique $Names] if {[llength $Names] > 1 } { Espionne "attention" } set Gn [lindex $Names 0] } InformeSansDemander $Box "Cluster: $Cluster" InformeSansDemander $Box "Ref: $Ref" InformeSansDemander $Box "ValiGN: $Gn" InformeSansDemander $Box "ValiDE: $Des" InformeSansDemander $Box "Tag: $Tag" InformeSansDemander $Box "Organism: $Org" } } } proc InformeStaf {} { set L 1 foreach I [Staf ListOf Index] { incr L set Nm [string trim [Staf $I "h_Id_number"]] set Gene [string trim [Staf $I "gene"]] if {$Gene==""} { set Gene "Unknown$I" } set Name [string trim [Staf $I "name"]] set HPos [string trim [Staf $I "h_pos."]] set Seq [string trim [Staf $I "human_sequence"]] regsub -all -nocase {[^A-Z]} $Seq "" Seq set Nm2 [string trim [Staf $I "h_Id_number2"]] set Loc [string trim [Staf $I "chromosome_and_localization"]] set Orient [string trim [Staf $I "ori."]] if {$Orient=="+"} { set Orient "F" } else { set Orient "R" } set Ali [string trim [ Staf $I "alignment_human_vs_mouse"]] set CpG [string trim [ Staf $I "CpG"]] if {$CpG=="+"} { set CpG "Y" } if {$CpG=="-"} { set CpG "N" } if {$CpG=="nd"} { set CpG "U" } Espionne "$I $Nm $Gene $Name $Loc $HPos $Orient $Seq" set Alias $Gene if {[info exists DejaVu($Alias)]} { incr DejaVu($Alias) set Alias "$Gene-$DejaVu($Alias)" } else { set DejaVu($Alias) 1 } set Nom [format "[PreFixe]%4.4d" $L] set GN [ValiGN $Nom] if {[string first $Gene $GN]!=0} { FaireLire "Probleme avec $I $Gene $GN" } InformeSansDemander $Nom "ExcelLine: $L" InformeSansDemander $Nom "ExcelNm: $Nm" InformeSansDemander $Nom "ExcelDE: $Name" InformeSansDemander $Nom "ExcelHPos: $HPos" InformeSansDemander $Nom "ExcelLoc200405: $Loc" InformeSansDemander $Nom "ExcelOrient: $Orient" InformeSansDemander $Nom "ExcelAli: $Ali" InformeSansDemander $Nom "ExcelCpG: $CpG" } } proc InformeStatus {} { set tout 0; set comp 0; set optio 0; set pasassign 0 foreach Nom [ListeDesPABs] { set LesProclameurs {} incr tout Espionne "$Nom" set jaitrouve 0 regsub "EVI" $Nom "" NomSsEvi set ligne [string range $NomSsEvi 0 end-1] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] } } } #Espionne "$ligne" set LesTetes [RetChip5 ListOf Header] set lignecomplete [RetChip5 $ligne WholeLine] set LesMots [split $lignecomplete ";"] for {set i 10} {$i<=33} {incr i} { set info "" set info [lindex $LesMots $i] if {[regexp "x" $info]} {lappend LesProclameurs [lindex $LesTetes $i]} } EspionneL $LesProclameurs if {$LesProclameurs=={}} { incr pasassign Espionne "attention pas assignation" } set Qui [join $LesProclameurs ","] if {[regexp "x" [RetChip5 $ligne "retinal_fate"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "important" [RetChip5 $ligne "remark_S.T."]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Grimm"]] && [regexp -nocase "HIF" [RetChip5 $ligne "description_memorec"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Grimm"]] && [regexp -nocase "SOCS" [RetChip5 $ligne "description_memorec"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Grimm"]] && [regexp -nocase "C1q" [RetChip5 $ligne "description_memorec"]]} { incr comp Espionne "$Nom -" set jaitrouve 1 InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Grimm"]] && [regexp -nocase "CFH" [RetChip5 $ligne "description_memorec"]]} { incr comp Espionne "$Nom -" set jaitrouve 1 InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Grimm"]] && [regexp -nocase "PEDF" [RetChip5 $ligne "description_memorec"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "marigo"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Schraermeyer"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Schraermeyer2"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "van_Heyningen"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Thierry"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Guilloneau"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Goureau"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Wissinger"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $ligne "Banfi"]]} { incr comp set jaitrouve 1 Espionne "$Nom -" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {$jaitrouve==0} { incr optio Espionne "$Nom +" InformeSansDemander $Nom "Status: optional($Qui)" } } Espionne "tout= $tout" Espionne "comp= $comp" Espionne "optio= $optio" Espionne "pasassign= $pasassign" } proc InformeStatus2 {} { set tout 0; set comp 0; set optio 0; set pasassign 0 set LesLignesExl [NomLigne ListeDes Lignes] foreach LigneExl $LesLignesExl { set TousLesNoms [NomLigne $LigneExl Noms] set ListeDesNoms [split $TousLesNoms " "] set NbDeNomPrUneLigne [llength $ListeDesNoms] if {[llength $ListeDesNoms]==1} { set BonneListeDesNoms $ListeDesNoms } if {[llength $ListeDesNoms]>1} { set BonneListeDesNoms [split [RangeMoi get EviOf $LigneExl] " "] } #Espionne "" #Espionne "$LigneExl" #Espionne "$ListeDesNoms" #Espionne "$BonneListeDesNoms" foreach Nom $ListeDesNoms { Espionne $Nom set LesProclameurs {} incr tout set jaitrouve 0 # set StatusActuel [ExtraitInfo $Nom "Status"] # Espionne "$Nom StatusActuel: $StatusActuel" set LesTetes [RetChip5 ListOf Header] set lignecomplete [RetChip5 $LigneExl WholeLine] set LesMots [split $lignecomplete ";"] for {set i 10} {$i<=33} {incr i} { set info "" set info [lindex $LesMots $i] if {[regexp "x" $info]} {lappend LesProclameurs [lindex $LesTetes $i]} } #EspionneL $LesProclameurs if {$LesProclameurs=={}} { incr pasassign Espionne "attention pas assignation" } set Qui [join $LesProclameurs ","] if {[regexp "x" [RetChip5 $LigneExl "retinal_fate"]]} { incr comp set jaitrouve 1 # Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "important" [RetChip5 $LigneExl "remark_S.T."]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Grimm"]] && [regexp -nocase "HIF" [RetChip5 $LigneExl "description_memorec"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Grimm"]] && [regexp -nocase "SOCS" [RetChip5 $LigneExl "description_memorec"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Grimm"]] && [regexp -nocase "C1q" [RetChip5 $LigneExl "description_memorec"]]} { incr comp #Espionne "$Nom -" set status compulsory($Qui) set jaitrouve 1 Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Grimm"]] && [regexp -nocase "CFH" [RetChip5 $LigneExl "description_memorec"]]} { incr comp #Espionne "$Nom -" set jaitrouve 1 set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Grimm"]] && [regexp -nocase "PEDF" [RetChip5 $LigneExl "description_memorec"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" Espionne "$Nom Status: compulsory($Qui)" set status compulsory($Qui) InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "marigo"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Schraermeyer"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Schraermeyer2"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "van_Heyningen"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Thierry"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Guilloneau"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Goureau"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Wissinger"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {[regexp "x" [RetChip5 $LigneExl "Banfi"]]} { incr comp set jaitrouve 1 #Espionne "$Nom -" set status compulsory($Qui) Espionne "$Nom Status: compulsory($Qui)" InformeSansDemander $Nom "Status: compulsory($Qui)" continue } if {$jaitrouve==0} { incr optio #Espionne "$Nom +" set status optional($Qui) Espionne "$Nom Status: optional($Qui)" InformeSansDemander $Nom "Status: optional($Qui)" } #if {$status!=$StatusActuel} #Espionne "lesstatusdiffere" #set StatusActuelDebut [string range $StatusActuel 0 [expr [string first "\(" $StatusActuel] - 1]] #set statusdebut [string range $status 0 [expr [string first "\(" $status] - 1]] #if {$statusdebut!=$StatusActuelDebut} #Espionne "compul_opt" } } } proc InformeSynonyms {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set Acc [AccessEvi $Nom] if {$Acc==""} {continue} if { [regexp {^NM_} $Acc] || [regexp {^XM_} $Acc] || [regexp {^NR_} $Acc] } { set Commande "getz \"\\\[refseq-acc:$Acc\\\]\" \-e" set Texte [eval exec $Commande] set LesLignes [split $Texte "\n"] set AliasGnRna [RecupereAliasGn $LesLignes] InformeSansDemander $Nom "AliasGnRna: $AliasGnRna" } if { ![regexp {^NM_} $Acc] && ![regexp {^XM_} $Acc] && ![regexp {^NR_} $Acc]} { set Commande "getz \"\\\[genbankfull-acc:$Acc\\\]\" \-e" set Texte [eval exec $Commande] set LesLignes [split $Texte "\n"] set AliasGnRna [RecupereAliasGn $LesLignes] InformeSansDemander $Nom "AliasGnRna: $AliasGnRna" } set IdetAcc [ExtraitInfo $Nom "IdAccProt"] if {$IdetAcc==""} {continue} set ListeProt [split $IdetAcc " "] if {[llength $ListeProt]>1} {set AccProt [lindex $ListeProt 1]} if {[llength $ListeProt]==1} {set AccProt [lindex $ListeProt 0]} if { ![regexp {^NP_} $AccProt] && ![regexp {^XP_} $AccProt]} { set Commande "getz \"\\\[protein-acc:$AccProt\\\]\" \-e" set Texte [eval exec $Commande] set LesLignes [split $Texte "\n"] set AliasGnProt [RecupereGeneNameAliasProt $LesLignes] InformeSansDemander $Nom "AliasGnProt: $AliasGnProt" } } AppendAuFichier [Fiches]/Alias.log "AliasGnRna: $AliasGnRna AliasGnProt: $AliasGnProt" } proc InformeValiDEPourTous {} { if { ! [OuiOuNon "On suppose que les prottfa sont de la forme \n>Box Id Ac Genre Espece Definition\n(on enlevera OS= et GN=)"]} { return "" } set TestIt [OuiOuNon "Do I do a test only" 0] foreach Nom [ListeDesPABs] { set FicTfa [GscopeFile $Nom "prottfa"] set Entete [EnteteDuFichierTFA $FicTfa] set D "" if { ! [regexp {^>[^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ (.+)} $Entete Match D]} { continue } if {$D==""} { continue } regsub { OS=.*} $D "" D regsub { GN=.*} $D "" D regsub -all ";" $D " " D set D [string trim $D " _,"] if {$D!="" && ! $TestIt} { InformeSansDemander $Nom "ValiDE: $D" } lappend LesDE "$Nom ValiDE=$D" } return $LesDE } proc InformeValiGNParAlias {} { foreach Nom [ListeDesPABs] { set ValiGN [ExtraitInfo $Nom "ValiGN"] if {$ValiGN!=""} { continue } set Alias [Alias $Nom] if {$Alias==""} { continue } InformeSansDemander $Nom "=ValiGN: $Alias" } } proc InformeValiGNPourTous {} { if { ! [OuiOuNon "On suppose que les prottfa contiennent GN=\nSinon on cherche dans les banques"]} { return "" } set TestIt [OuiOuNon "Do I do a test only" 0] foreach Nom [ListeDesPABs] { set FicTfa [GscopeFile $Nom "prottfa"] set Entete [EnteteDuFichierTFA $FicTfa] set Gn "" if {[regexp {GN=([^ ]+)} $Entete Match GnLu]} { set Gn $GnLu } else { set IdRef [ExtraitInfo $Nom "IdRef:"] set AcRef [ExtraitInfo $Nom "AcRef:"] set EMBL [SequenceDesBanques $IdRef $AcRef AccessOk "OnVeutEMBL"] if {[regexp {\nGN ([^\n]+)\n} $EMBL Match GnLu]} { set Gn $GnLu } } regsub "^Name=" $Gn "" Gn regsub {\;.*} $Gn "" Gn set Gn [string trim $Gn " ;.\n"] if {$Gn!="" && ! $TestIt} { InformeSansDemander $Nom "ValiGN: $Gn" } lappend LesGn "$Nom $Gn" } return $LesGn } proc InfosClonesPhrap {FichierSequence} { set fichierOut "$FichierSequence.phrap" array set tfa [readFasta $FichierSequence] set out [open $fichierOut "w"] foreach name $tfa(index) { Espionne $name if {![regexp {^(.*)(F|R)M\d\.SCF$} $name regMatch tpl dir]} {Espionne "OUPS"; exit 1} if {$dir == "F"} {set dir "fwd"} else {set dir "rev"} puts $out [formatFasta "$tfa($name,header) TEMPLATE: $tpl DIRECTION: $dir" $tfa($name,sequence)] } close $out } proc InfosDeLaSeq {w nseqCombo {quoi edit}} { global TEdit nold {*}[info globals "TD*"] global ListeDesAcidesAmines GroupeDeLaSequence if {$nseqCombo eq "VientDuCombo"} { set nseqCombo $TEdit(nseqCombo) } if {[set TEdit(mode)] ne "edit"} { set ww [set TEdit(FWarn)] if {[winfo exists ${ww}.wrn]} { grid forget ${ww}.wrn destroy ${ww}.wrn } set nseq [set TEdit(corr,$nseqCombo)] if {[ExisteAABizarres $nseq]} { label ${ww}.wrn -background red -foreground white -text "Warning !\n The values given below\nare only indicative as this sequence\ncontains unhandled amino acids" -justify left -anchor w grid ${ww}.wrn -column 2 -row 0 -pady 10 -padx 10 -sticky w } } if {$w ne "" && [set TEdit(mode)] eq "edit"} { # nold is seqname set TEdit(desc,$nold) [string trim [[set TEdit(tdes)] get 1.0 end]] set TEdit(seqname,$nold) [set TEdit(seqname)] set TEdit(access,$nold) [set TEdit(access)] set TEdit(bid,$nold) [set TEdit(bid)] set TEdit(ec,$nold) [set TEdit(ec)] set TEdit(taxid,$nold) [set TEdit(taxid)] set TEdit(orga,$nold) [set TEdit(orga)] set TEdit(lifed,$nold) [set TEdit(lifed)] if {$nseqCombo eq ""} {return} } # nseq corrspond alors a l'access set nseq [set TEdit(corr,$nseqCombo)] set TEdit(seqname) [set TDesSeqnames($nseq)] set TEdit(access) [set TDesAccess($nseq)] set TEdit(bid) [set TDesBId($nseq)] set TEdit(desc) [set TDesDescriptifs($nseq)] set TEdit(ec) [set TDesEC($nseq)] set TEdit(groupe) [set TDuGroupeDesSeqs($nseq)] set TEdit(orga) [set TDesOrganismes($nseq)] set TEdit(frag) [set TDesFragment($nseq)] set TEdit(lifed) [set TDesPhylum($nseq)] set TEdit(taxid) [set TDesTaxId($nseq)] set TEdit(lineage) [join [set TDuLineage($nseq)]] set TEdit(pi) [format %.2f [set TDespI($nseq)]] set TEdit(molw) [format %.2f [set TDesMolW($nseq)]] set TEdit(hydro) [set TDesHydro($nseq)] set TEdit(length) [DonneLongueurDe $nseq] set TEdit(comppc) [set TDesCompos($nseq,pc)] foreach a $ListeDesAcidesAmines v [set TDesCompos($nseq,aa)] { if {$v eq ""} {set v 0.0} set TEdit(compaa,$a) [format "%5.1f" $v] } foreach a {"AILMV" "KRH" "DEQN" "FYW" "PGST"} v [set TDesCompos($nseq,pc)] { if {$v eq ""} {set v 0.0} set TEdit(compaa,$a) [format "%5.1f" $v] } foreach {a p} [CompositionAADuGroupe [set GroupeDeLaSequence($nseq)]] { set TEdit(compGrp,$a) [format %5.1f $p] } if {[set TEdit(mode)] eq "edit"} { set TEdit(seqname,$nseqCombo) [set TDesSeqnames($nseq)] set TEdit(access,$nseqCombo) [set TDesAccess($nseq)] set TEdit(bid,$nseqCombo) [set TDesBId($nseq)] set TEdit(desc,$nseqCombo) [set TDesDescriptifs($nseq)] set TEdit(ec,$nseqCombo) [set TDesEC($nseq)] set TEdit(taxid,$nseqCombo) [set TDesTaxId($nseq)] set TEdit(groupe,$nseqCombo) [set TDuGroupeDesSeqs($nseq)] set TEdit(orga,$nseqCombo) [set TDesOrganismes($nseq)] set TEdit(frag,$nseqCombo) [set TDesFragment($nseq)] set TEdit(lifed,$nseqCombo) [set TDesPhylum($nseq)] } set nold $nseqCombo if {[info exists TEdit(tdes)] && [set TEdit(mode)] eq "edit"} { [set TEdit(tdes)] delete 1.0 end [set TEdit(tdes)] insert end [set TEdit(desc,$nseqCombo)] } if {[info exists TEdit(tdes)] && [set TEdit(mode)] ne "edit"} { [set TEdit(tdes)] configure -state normal [set TEdit(tdes)] delete 1.0 end [set TEdit(tdes)] insert end [set TEdit(desc)] [set TEdit(tdes)] configure -state disabled [set TEdit(tlin)] configure -state normal [set TEdit(tlin)] delete 1.0 end [set TEdit(tlin)] insert end [set TEdit(lineage)] [set TEdit(tlin)] configure -state disabled } update idletasks return } proc InfosDesPDB {} { if {$::Defauts(DownloadPDB) eq "dont"} { return } foreach e $::ListePDB { set mol [DonneIdDeAccessPDB $e] set chn [DonneChainDeAccessPDB $e] $mol PDBInfos $chn } return } proc InfosDesProteinesRetNet {} { foreach RetNet [InterrogeRetNet LesRetNet] { Espionne "" Espionne $RetNet set Commande "[ProgPathway getz] \"\\\[protein-gen:$RetNet\\\] \& \\\[protein-org:Homo sapiens\\\]\" -f \"id acc org des seq\"" catch {set Page [eval exec $Commande]} Message if {$Page == ""} {continue} Espionne $Page } return } proc InfosDuMac {} { set w .macinfo if {[winfo exists $w]} {destroy $w} toplevel $w wm protocol $w WM_DELETE_WINDOW KillParLaCroix wm resizable $w 0 0 wm title $w "Alignment Title" wm attributes $w -topmost label $w.l -text "TO BE DONE" button $w.b -text " OK " -bg green1 -command [list QuitteInfosMac %W] pack $w.l $w.b -side top tkwait window $w return frame $w.f grid $w.f -row 0 -column 0 -sticky news -padx 5 -pady 5 label $w.f.lb -text "Alignment Information" -font "Helvetica 14 bold" -justify left -anchor w label $w.f.ltitre -text "Title" -justify left -anchor w label $w.f.titre -text "[MacCourant name]" -justify left -anchor w label $w.f.ldesc -text "Description" -justify left -anchor w text $w.f.desc -bg [set ::Defauts(BackAppli)] -wrap word label $w.f.lclu -text "Clustering" -justify left -anchor w label $w.f.clu -text "[ClusteringDuMac]" -justify left -anchor w label $w.f.ldclu -text "Method" -justify left -anchor w text $w.f.dclu -text "[ClusteringDuMac method]" -justify left -anchor w label $w.f.zone label $w.f.ngrp label $w.f.nseq label $w.f.long Title Description return } proc InfosEtBornesDuFinal {Chr {Ultime ""}} { if {$Ultime!=""} { set Ultime ".[string trim $Ultime .]" } set Final [ContenuDuFichier "[AnnotRep]/${Chr}_Final"] set Previous "." set D -1 set F $D set Sauve 0 foreach X [split $Final ""] { if {$X ne $Previous} { if {$Previous ne "."} { set Info [EleGen $Chr $Previous $D Info] if {$Info==""} { set Info [EleGen $Chr $Previous $F Info] if {$Info==""} { set Info [InfoDeLaZone $Chr $Previous $D] } } lappend LesBornes "$D $F $Previous" lappend LesInfos "$D $F $Previous $Info" set Sauve 1 } set D $F incr D incr F } else { set Sauve 0 incr F } set Previous $X } if { ! $Sauve } { set Info [EleGen $Chr $Previous $D Info] if {$Info==""} { set Info [EleGen $Chr $Previous $F Info] if {$Info==""} { set Info [InfoDeLaZone $Chr $Previous $D] } } lappend LesBornes "$D $F $Previous" lappend LesInfos "$D $F $Previous $Info" } set FicBornes [SauveLesLignes $LesBornes dans "${Chr}_BornesF$Ultime"] set FicInfos [SauveLesLignes $LesInfos dans "${Chr}_InfosF$Ultime"] return $FicInfos } proc InfosEtBornesDuFinalPourTous {{Premier ""} {Dernier ""}} { foreach Chr [ListOfChr $Premier $Dernier] { Espionne [InfosEtBornesDuFinal $Chr] } } proc InfosFromRefSeq {Lid} { if {$Lid == {} } {return {} } set Lxml [eFetchREST protein $Lid tiny] #puts "$Lxml" set RId [dom parse [join $Lxml]] set doc [$RId documentElement] array set T [list] set Ltid [list] set Lacc [list] foreach ns [$doc selectNodes //TSeq] { set tid [$ns selectNode string(./TSeq_taxid)] set acc [$ns selectNode string(./TSeq_accver)] set acc [EnleveVersionDeAccess $acc] set gi [$ns selectNode string(./TSeq_gi)] set org [$ns selectNode string(./TSeq_orgname)] set def [$ns selectNode string(./TSeq_defline)] set seq [$ns selectNode string(./TSeq_sequence)] set T($acc,TaxId) $tid set T($acc,Desc) $def set T($acc,Organism) $org set T($acc,currAC) $acc set T($acc,BId) $gi set T($acc,Sequence) $seq set T($acc,Lineage) "" set T($acc,Phylum) "" lappend Ltid $tid lappend Lacc $acc } $RId delete if {$Ltid != {} } { set o [eFetchREST taxonomy $Ltid] array set Tx $o foreach t $Ltid acc $Lacc { if {[info exists Tx($t,Lineage)]} { set Llin [split $Tx($t,Lineage) ";"] set T($acc,Lineage) $Tx($t,Lineage) if {[set ph [string trim [lindex $Llin 0]]] ne "cellular organisms"} { set T($acc,Phylum) $ph } else { set T($acc,Phylum) [string trim [lindex $Llin 1]] } } } } return [array get T] } proc InfosFromUniProt {Luni {Lsqn ""}} { if {$Luni == {} } {return {} } set Luni [lupper $Luni] set Lres [split [DbFetchGET uniprot $Luni] \n] set Lembl [SplitLesEMBL $Lres] array set T [list] foreach em $Lembl { if {[string trim $em] eq ""} {continue} unset -nocomplain tutu array set tutu [DecortiqueLesLignesEMBL $em ID AC DE GN OS OC OX Seq LaDETotal GNTotal] # access: take all of them, if we have an obsolete one set AC [string map {";" ""} [join $tutu(AC)]] regsub -all { +} [string trim $AC] " " AC set AC [split $AC] # current AC is the first of the list. set currAC [lindex $AC 0] # ID set currID $ID # find original access set acOri "" if {[set idx [lsearch -glob $Luni "$ID*"]] != -1} { set acOri [lindex $Luni $idx] } else { foreach elt $AC { if {[set idx [lsearch -glob $Luni "$elt*"]] != -1} { set acOri [lindex $Luni $idx] break } } if {$acOri eq ""} { puts "can't find $AC $ID" puts "" puts "[join $em \n]" puts "" continue } } set T($acOri,currAC) $currAC set T($acOri,BId) $ID set T($acOri,Desc) $DE set T($acOri,TaxId) $OX set T($acOri,Lineage) $OC set T($acOri,Organism) $OS set T($acOri,Sequence) $Seq set Llin [split $OC ";"] if {[set phy [string trim [lindex $Llin 0]]] ne "cellular organisms"} { set T($acOri,Phylum) $phy } else { set T($acOri,Phylum) [string trim [lindex $Llin 1]] } } return [array get T] } proc InfosSurOrdali {} { global VersionDeOrdali OrdEtcDir set fm [file join $OrdEtcDir "MACSIM_100px_transparent.gif"] image create photo imacs imacs read $fm -shrink set hgt [expr {[imacs cget -height] / 10}] set w ".info" toplevel $w wm title $w "About Ordalie ..." wm iconname $w "Info" wm resizable $w 0 0 wm protocol $w WM_DELETE_WINDOW KillParLaCroix frame $w.f pack $w.f -side top -expand 1 -fill both label $w.f.l -image imacs -height [imacs cget -height] pack $w.f.l -side left -padx 10 text $w.f.t -borderwidth 0 -font "Helvetica 14 bold" -bg "#ffffffffe0e0" -takefocus 0 -width 40 pack $w.f.t -side right -padx 10 set wt "$w.f.t" button $w.b -text " Close " -bg green1 -command "destroy $w" pack $w.b -side bottom -pady 15 $wt tag configure TresGrosGras -font "Helvetica 20 bold" $wt tag configure GrosGras -font "Helvetica 14 bold" $wt tag configure normal -font "Helvetica 12" $wt tag configure souli -underline on $wt insert end "\nOrdali " TresGrosGras $wt insert end "Version : $VersionDeOrdali\n\n\n" GrosGras $wt insert end "\251 1997-2006 Luc Moulinier and LBGI\n\n" normal $wt insert end "Bugs and comments should be address to\n" normal $wt insert end "moumou@igbmc.u-strasbg.fr" souli set hgt [expr {[regsub -all "\n" [$wt get 1.0 end] "" tmp] + 2}] $wt configure -state disabled -height $hgt MesCouleurs $w FenetreAuCentre $w tkwait window $w return } proc IniRosace {} { set lRosace [list "-3.40,A" "0.90,R" "-1.70,N" "-3.40,D" "-1.85,C" "-1.45,Q" "-3.40,E" "-5.15,G" "1.80,H" "1.50,I" "2.85,L" "-0.45,K" "2.05,M" "5.70,F" "-5.15,P" "-2.32,S" "-1.95,T" "7.45,W" "7.55,Y" "0.10,V" "0.40,A" "-4.25,R" "-1.60,N" "-2.45,D" "5.30,C" "-2.40,Q" "-1.50,E" "0.70,G" "-2.70,H" "2.75,I" "2.90,L" "-3.35,K" "2.10,M" "0.75,F" "-0.50,P" "0.20,S" "1.45,T" "-1.85,W" "-0.15,Y" "2.80,V"] return $lRosace } proc IniVolPol {} { # Tire directement de MAFFT : set lvolpol " A 31.0 8.1 R 124.0 10.5 N 56.0 11.6 D 54.0 13.0 C 55.0 5.5 Q 85.0 10.5 E 83.0 12.3 G 3.0 9.0 H 96.0 10.4 I 111.0 5.2 L 111.0 4.9 K 119.0 11.3 M 105.0 5.7 F 132.0 5.2 P 32.5 8.0 S 32.0 9.2 T 61.0 8.6 W 170.0 5.4 Y 136.0 6.2 V 84.0 5.9" # Volume/Polarite de MAFFT. # Met a l'echelle, rotation pour fitter les axes # du VRP. if {0} { set lvolpol "A -4.148493661429663 0.15375170408070496 C -2.2708161909098723 1.9304380623466315 D -2.3490527521815303 -3.1946187403435418 E -0.08019247530344983 -2.716280105425793 F 3.7533990270077893 2.135440334454238 G -6.339117377036085 -0.46125511224211607 H 0.9368828212281034 -1.4179323820776153 I 2.1104312403029724 2.135440334454238 K 2.736323730476236 -2.0329391984004364 L 2.1104312403029724 2.340442606561845 M 1.641011872673025 1.79376988094156 N -2.1925796296382143 -2.2379414705080425 P -4.031138819522176 0.22208579478324036 Q 0.07628064723986605 -1.4862664727801507 R 3.1275065368345256 -1.4862664727801507 S -4.070257100158005 -0.5979232936471869 T -1.8013968232799247 -0.18791874943197326 V -0.0019559140317918933 1.6571016995364887 W 6.7263883553307915 1.9987721530491669 Y 4.066345272094421 1.4520994274288819" } return $lvolpol } proc InitASA {} { global ASAaa ASAan set ASAaa(A) 239.0 set ASAaa(R) 384.1 set ASAaa(N) 293.2 set ASAaa(D) 282.4 set ASAaa(C) 270.2 set ASAaa(Q) 320.2 set ASAaa(E) 333.9 set ASAaa(G) 209.6 set ASAaa(H) 333.5 set ASAaa(I) 312.5 set ASAaa(L) 317.7 set ASAaa(K) 358.2 set ASAaa(M) 335.1 set ASAaa(F) 359.2 set ASAaa(P) 269.1 set ASAaa(S) 250.1 set ASAaa(T) 274.9 set ASAaa(W) 414.4 set ASAaa(Y) 371.6 set ASAaa(V) 286.3 set ASAan(A) 524.7 set ASAan(T) 479.6 set ASAan(C) 485.1 set ASAan(G) 517.1 set ASAan(U) 476.1 return } proc InitAffichage {} { if {[TypeAli] eq "pasdali"} {return} if {! [ModeI]} {return} InitWRegle AfficheRegle set menustatus "Reading File finished" MiseAJourMac MontreStrSecDansAlignement return } proc InitAgents {} { global LNOrdali TAg nAgents unset -nocomplain TAg set nAG 0 foreach n $LNOrdali { set TAg($n) [list] incr nAG [UpdateAgentsOfSeq $n] } set nAgents $nAG if {$::debug} { puts "Nombre d'agents : $nAG" } return } proc InitAgentsAnaBal {} { global LNOrdali Sequences MotifLen TAg set nAgents 0 foreach n $LNOrdali { set iAG 0 set s $Sequences($n) set lgt [string length $s] for {set i 0} {$i <= ($lgt - $MotifLen)} {incr i} { set fin [expr {$i + $MotifLen -1}] set ags [string range $s $i $fin] lappend TAg($n) $iAG set TAg($iAG,$n,active) 1 set TAg($iAG,$n,nseq) $n set TAg($iAG,$n,seq) $ags set TAg($iAG,$n,dep) $i set TAg($iAG,$n,fin) $fin set TAg($iAG,$n,mil) [expr {int(1.*(($i + $fin)/2))}] incr iAG } incr nAgents $iAG } puts "nombre d'agents : $nAgents" return $nAgents } proc InitArcBall {x y} { tcl3dMatfCopy $::ThisRot $::LastRot ; # Set Last Static Rotation To Last Dynamic One tcl3dArcBallClick $::ArcBall $x $y ; # Update Start Vector And Prepare For Dragging .top.fr.toglwin postredisplay } proc InitBalloonOnItem {w tag text} { $w bind $tag [list ShowBalloonOnItem $w $text %x %y] $w bind $tag [list after 1 $w delete cballoon] } proc InitBootstrap {AId} { global Abr HashRef set t [set Abr(Arbre,$AId)] unset -nocomplain HashRef TSum CreeBootstrapRef $t root $t set root nboot 0 return } proc InitCBS {} { global DCBS set DCBS(Tables) " - livre : { . pk_livre P . bid I . auteur V128 . titre T . genre V64 . duree V16 . resume T } " return } proc InitCBSDB {} { global DCBS db InitCBS file delete cbs.sql set db [FabriqueDeTables $DCBS(Tables) "" cbs.sql] ParseCatalogue $db close exit } proc InitCentreOverview {Id} { global NomTextSeq NomNomSeq WTexteRegle Ovw # At overview creation, # creates the mark on the overview of the center of the # center of the visible zone of the alignment, # and the square of the visible region set wc [set Ovw(O$Id,w)] set Wdt [$wc cget -width] set Hgt [$wc cget -height] # draw the visible zone of the alignment on the overview lassign [VisiblePartOfAlignment] xm ym xx yx # back to canvas coords set xcm [expr {round(1.0*$xm/[set Ovw(O$Id,Width)] *$Wdt)}] set ycm [expr {round(1.0*$ym/[set Ovw(O$Id,Height)]*$Hgt)}] set xcx [expr {round(1.0*$xx/[set Ovw(O$Id,Width)] *$Wdt)}] set ycx [expr {round(1.0*$yx/[set Ovw(O$Id,Height)]*$Hgt)}] if {[info exists Ovw(O$Id,TagRegion)]} {$wc delete [set Ovw(O$Id,TagRegion)]} set Ovw(O$Id,TagRegion) [$wc create rectangle $xcm $ycm $xcx $ycx -dash {3 3} -outline black -width 2 -tag algtRegion] # center of the region set x [expr {round($xcm + ($xcx-$xcm)/2)/[set Ovw(O$Id,Width)]*$Wdt}] set y [expr {round($ycm + ($ycx-$ycm)/2)/[set Ovw(O$Id,Height)]*$Hgt}] # create a mark for the new centre on the overview if {[info exists Ovw(O$Id,TagCentre)]} {$wc delete [set Ovw(O$Id,TagCentre)]} set Ovw(O$Id,TagCentre) [$wc create oval [expr {$x-2}] [expr {$y-2}] [expr {$x+2}] [expr {$y+2}] -fill white -outline black -tags algtCentre] return } proc InitCharsetHtml {} { set Ll [LesLignesDuFichier [file join $::OrdEtcDir charset.txt]] foreach l $Ll { if {[string first "#" $l] == 0 || [set l [string trim $l]] eq ""} { continue } regsub -all { +} $l " " l if {[string index $l 0] eq "\\"} { set l "NULL $l" } lassign $l keyboard octal hex unicode html char lappend LCharSet [list $keyboard $octal $hex $unicode $html $char] } return $LCharSet } proc InitChemicals {} { global Chm set Chm(Ac,na) 89 set Chm(Ac,nm) Actinium set Chm(Ac,wg) 227 set Chm(Ac,vdw) 0 set Chm(Ag,na) 47 set Chm(Ag,nm) Silver set Chm(Ag,wg) 107.8682 set Chm(Ag,vdw) 1.72 set Chm(Al,na) 13 set Chm(Al,nm) Aluminum set Chm(Al,wg) 26.9815 set Chm(Al,vdw) 1.7 set Chm(Am,na) 95 set Chm(Am,nm) Americium set Chm(Am,wg) 243 set Chm(Am,vdw) 0 set Chm(Ar,na) 18 set Chm(Ar,nm) Argon set Chm(Ar,wg) 39.948 set Chm(Ar,vdw) 1.88 set Chm(As,na) 33 set Chm(As,nm) Arsenic set Chm(As,wg) 74.9216 set Chm(As,vdw) 1.85 set Chm(At,na) 85 set Chm(At,nm) Astatine set Chm(At,wg) 210 set Chm(At,vdw) 0 set Chm(Au,na) 79 set Chm(Au,nm) Gold set Chm(Au,wg) 196.9665 set Chm(Au,vdw) 1.66 set Chm(B,na) 5 set Chm(B,nm) Boron set Chm(B,wg) 10.811 set Chm(B,vdw) 1.7 set Chm(Ba,na) 56 set Chm(Ba,nm) Barium set Chm(Ba,wg) 137.327 set Chm(Ba,vdw) 0 set Chm(Be,na) 4 set Chm(Be,nm) Beryllium set Chm(Be,wg) 9.0122 set Chm(Be,vdw) 1.7 set Chm(Bh,na) 107 set Chm(Bh,nm) Bohrium set Chm(Bh,wg) 264 set Chm(Bh,vdw) 0 set Chm(Bi,na) 83 set Chm(Bi,nm) Bismuth set Chm(Bi,wg) 208.9804 set Chm(Bi,vdw) 0 set Chm(Bk,na) 97 set Chm(Bk,nm) Berkelium set Chm(Bk,wg) 247 set Chm(Bk,vdw) 0 set Chm(Br,na) 35 set Chm(Br,nm) Bromine set Chm(Br,wg) 79.904 set Chm(Br,vdw) 1.85 set Chm(C,na) 6 set Chm(C,nm) Carbon set Chm(C,wg) 12.0107 set Chm(C,vdw) 1.70 set Chm(Ca,na) 20 set Chm(Ca,nm) Calcium set Chm(Ca,wg) 40.078 set Chm(Ca,vdw) 2.23 set Chm(Cd,na) 48 set Chm(Cd,nm) Cadmium set Chm(Cd,wg) 112.411 set Chm(Cd,vdw) 1.58 set Chm(Ce,na) 58 set Chm(Ce,nm) Cerium set Chm(Ce,wg) 140.116 set Chm(Ce,vdw) 0 set Chm(Cf,na) 98 set Chm(Cf,nm) Californium set Chm(Cf,wg) 251 set Chm(Cf,vdw) 0 set Chm(Cl,na) 17 set Chm(Cl,nm) Chlorine set Chm(Cl,wg) 35.453 set Chm(Cl,vdw) 1.75 set Chm(Cm,na) 96 set Chm(Cm,nm) Curium set Chm(Cm,wg) 247 set Chm(Cm,vdw) 0 set Chm(Co,na) 27 set Chm(Co,nm) Cobalt set Chm(Co,wg) 58.9332 set Chm(Co,vdw) 2.23 set Chm(Cr,na) 24 set Chm(Cr,nm) Chromium set Chm(Cr,wg) 51.9961 set Chm(Cr,vdw) 2.23 set Chm(Cs,na) 55 set Chm(Cs,nm) Cesium set Chm(Cs,wg) 132.9055 set Chm(Cs,vdw) 0 set Chm(Cu,na) 29 set Chm(Cu,nm) Copper set Chm(Cu,wg) 63.546 set Chm(Cu,vdw) 1.4 set Chm(Db,na) 105 set Chm(Db,nm) Dubnium set Chm(Db,wg) 262 set Chm(Db,vdw) 0 set Chm(Dy,na) 66 set Chm(Dy,nm) Dysprosium set Chm(Dy,wg) 162.5 set Chm(Dy,vdw) 0 set Chm(Er,na) 68 set Chm(Er,nm) Erbium set Chm(Er,wg) 167.259 set Chm(Er,vdw) 0 set Chm(Es,na) 99 set Chm(Es,nm) Einsteinium set Chm(Es,wg) 252 set Chm(Es,vdw) 0 set Chm(Eu,na) 63 set Chm(Eu,nm) Europium set Chm(Eu,wg) 151.964 set Chm(Eu,vdw) 0 set Chm(F,na) 9 set Chm(F,nm) Fluorine set Chm(F,wg) 18.9984 set Chm(F,vdw) 1.47 set Chm(Fe,na) 26 set Chm(Fe,nm) Iron set Chm(Fe,wg) 55.845 set Chm(Fe,vdw) 2.23 set Chm(Fm,na) 100 set Chm(Fm,nm) Fermium set Chm(Fm,wg) 257 set Chm(Fm,vdw) 0 set Chm(Fr,na) 87 set Chm(Fr,nm) Francium set Chm(Fr,wg) 223 set Chm(Fr,vdw) 0 set Chm(Ga,na) 31 set Chm(Ga,nm) Gallium set Chm(Ga,wg) 69.723 set Chm(Ga,vdw) 1.87 set Chm(Gd,na) 64 set Chm(Gd,nm) Gadolinium set Chm(Gd,wg) 157.25 set Chm(Gd,vdw) 0 set Chm(Ge,na) 32 set Chm(Ge,nm) Germanium set Chm(Ge,wg) 72.64 set Chm(Ge,vdw) 0 set Chm(H,na) 1 set Chm(H,nm) Hydrogen set Chm(H,wg) 1.0079 set Chm(H,vdw) 1.2 set Chm(He,na) 2 set Chm(He,nm) Helium set Chm(He,wg) 4.0026 set Chm(He,vdw) 1.4 set Chm(Hf,na) 72 set Chm(Hf,nm) Hafnium set Chm(Hf,wg) 178.49 set Chm(Hf,vdw) 0 set Chm(Hg,na) 80 set Chm(Hg,nm) Mercury set Chm(Hg,wg) 200.59 set Chm(Hg,vdw) 1.55 set Chm(Ho,na) 67 set Chm(Ho,nm) Holmium set Chm(Ho,wg) 164.9303 set Chm(Ho,vdw) 0 set Chm(Hs,na) 108 set Chm(Hs,nm) Hassium set Chm(Hs,wg) 277 set Chm(Hs,vdw) 0 set Chm(I,na) 53 set Chm(I,nm) Iodine set Chm(I,wg) 126.9045 set Chm(I,vdw) 1.98 set Chm(In,na) 49 set Chm(In,nm) Indium set Chm(In,wg) 114.818 set Chm(In,vdw) 1.93 set Chm(Ir,na) 77 set Chm(Ir,nm) Iridium set Chm(Ir,wg) 192.217 set Chm(Ir,vdw) 0 set Chm(K,na) 19 set Chm(K,nm) Potassium set Chm(K,wg) 39.0983 set Chm(K,vdw) 2.75 set Chm(Kr,na) 36 set Chm(Kr,nm) Krypton set Chm(Kr,wg) 83.8 set Chm(Kr,vdw) 2.02 set Chm(La,na) 57 set Chm(La,nm) Lanthanum set Chm(La,wg) 138.9055 set Chm(La,vdw) 0 set Chm(Li,na) 3 set Chm(Li,nm) Lithium set Chm(Li,wg) 6.941 set Chm(Li,vdw) 1.82 set Chm(Lr,na) 103 set Chm(Lr,nm) Lawrencium set Chm(Lr,wg) 262 set Chm(Lr,vdw) 0 set Chm(Lu,na) 71 set Chm(Lu,nm) Lutetium set Chm(Lu,wg) 174.967 set Chm(Lu,vdw) 0 set Chm(Md,na) 101 set Chm(Md,nm) Mendelevium set Chm(Md,wg) 258 set Chm(Md,vdw) 0 set Chm(Mg,na) 12 set Chm(Mg,nm) Magnesium set Chm(Mg,wg) 24.305 set Chm(Mg,vdw) 1.73 set Chm(Mn,na) 25 set Chm(Mn,nm) Manganese set Chm(Mn,wg) 54.938 set Chm(Mn,vdw) 2.23 set Chm(Mo,na) 42 set Chm(Mo,nm) Molybdenum set Chm(Mo,wg) 95.94 set Chm(Mo,vdw) 0 set Chm(Mt,na) 109 set Chm(Mt,nm) Meitnerium set Chm(Mt,wg) 268 set Chm(Mt,vdw) 0 set Chm(N,na) 7 set Chm(N,nm) Nitrogen set Chm(N,wg) 14.0067 set Chm(N,vdw) 1.55 set Chm(Na,na) 11 set Chm(Na,nm) Sodium set Chm(Na,wg) 22.9897 set Chm(Na,vdw) 2.27 set Chm(Nb,na) 41 set Chm(Nb,nm) Niobium set Chm(Nb,wg) 92.9064 set Chm(Nb,vdw) 0 set Chm(Nd,na) 60 set Chm(Nd,nm) Neodymium set Chm(Nd,wg) 144.24 set Chm(Nd,vdw) 0 set Chm(Ne,na) 10 set Chm(Ne,nm) Neon set Chm(Ne,wg) 20.1797 set Chm(Ne,vdw) 0 set Chm(Ni,na) 28 set Chm(Ni,nm) Nickel set Chm(Ni,wg) 58.6934 set Chm(Ni,vdw) 1.63 set Chm(No,na) 102 set Chm(No,nm) Nobelium set Chm(No,wg) 259 set Chm(No,vdw) 0 set Chm(Np,na) 93 set Chm(Np,nm) Neptunium set Chm(Np,wg) 237 set Chm(Np,vdw) 0 set Chm(O,na) 8 set Chm(O,nm) Oxygen set Chm(O,wg) 15.9994 set Chm(O,vdw) 1.52 set Chm(Os,na) 76 set Chm(Os,nm) Osmium set Chm(Os,wg) 190.23 set Chm(Os,vdw) 0 set Chm(P,na) 15 set Chm(P,nm) Phosphorus set Chm(P,wg) 30.9738 set Chm(P,vdw) 1.8 set Chm(Pa,na) 91 set Chm(Pa,nm) Protactinium set Chm(Pa,wg) 231.0359 set Chm(Pa,vdw) 0 set Chm(Pb,na) 82 set Chm(Pb,nm) Lead set Chm(Pb,wg) 207.2 set Chm(Pb,vdw) 2.02 set Chm(Pd,na) 46 set Chm(Pd,nm) Palladium set Chm(Pd,wg) 106.42 set Chm(Pd,vdw) 1.63 set Chm(Pm,na) 61 set Chm(Pm,nm) Promethium set Chm(Pm,wg) 145 set Chm(Pm,vdw) 0 set Chm(Po,na) 84 set Chm(Po,nm) Polonium set Chm(Po,wg) 209 set Chm(Po,vdw) 0 set Chm(Pr,na) 59 set Chm(Pr,nm) Praseodymium set Chm(Pr,wg) 140.9077 set Chm(Pr,vdw) 0 set Chm(Pt,na) 78 set Chm(Pt,nm) Platinum set Chm(Pt,wg) 195.078 set Chm(Pt,vdw) 1.75 set Chm(Pu,na) 94 set Chm(Pu,nm) Plutonium set Chm(Pu,wg) 244 set Chm(Pu,vdw) 0 set Chm(Ra,na) 88 set Chm(Ra,nm) Radium set Chm(Ra,wg) 226 set Chm(Ra,vdw) 0 set Chm(Rb,na) 37 set Chm(Rb,nm) Rubidium set Chm(Rb,wg) 85.4678 set Chm(Rb,vdw) 0 set Chm(Re,na) 75 set Chm(Re,nm) Rhenium set Chm(Re,wg) 186.207 set Chm(Re,vdw) 0 set Chm(Rf,na) 104 set Chm(Rf,nm) Rutherfordium set Chm(Rf,wg) 261 set Chm(Rf,vdw) 0 set Chm(Rh,na) 45 set Chm(Rh,nm) Rhodium set Chm(Rh,wg) 102.9055 set Chm(Rh,vdw) 0 set Chm(Rn,na) 86 set Chm(Rn,nm) Radon set Chm(Rn,wg) 222 set Chm(Rn,vdw) 0 set Chm(Ru,na) 44 set Chm(Ru,nm) Ruthenium set Chm(Ru,wg) 101.07 set Chm(Ru,vdw) 0 set Chm(S,na) 16 set Chm(S,nm) Sulfur set Chm(S,wg) 32.065 set Chm(S,vdw) 1.8 set Chm(Sb,na) 51 set Chm(Sb,nm) Antimony set Chm(Sb,wg) 121.76 set Chm(Sb,vdw) 0 set Chm(Sc,na) 21 set Chm(Sc,nm) Scandium set Chm(Sc,wg) 44.9559 set Chm(Sc,vdw) 2.23 set Chm(Se,na) 34 set Chm(Se,nm) Selenium set Chm(Se,wg) 78.96 set Chm(Se,vdw) 1.9 set Chm(Sg,na) 106 set Chm(Sg,nm) Seaborgium set Chm(Sg,wg) 266 set Chm(Sg,vdw) 0 set Chm(Si,na) 14 set Chm(Si,nm) Silicon set Chm(Si,wg) 28.0855 set Chm(Si,vdw) 2.1 set Chm(Sm,na) 62 set Chm(Sm,nm) Samarium set Chm(Sm,wg) 150.36 set Chm(Sm,vdw) 0 set Chm(Sn,na) 50 set Chm(Sn,nm) Tin set Chm(Sn,wg) 118.71 set Chm(Sn,vdw) 2.17 set Chm(Sr,na) 38 set Chm(Sr,nm) Strontium set Chm(Sr,wg) 87.62 set Chm(Sr,vdw) 0 set Chm(Ta,na) 73 set Chm(Ta,nm) Tantalum set Chm(Ta,wg) 180.9479 set Chm(Ta,vdw) 0 set Chm(Tb,na) 65 set Chm(Tb,nm) Terbium set Chm(Tb,wg) 158.9253 set Chm(Tb,vdw) 0 set Chm(Tc,na) 43 set Chm(Tc,nm) Technetium set Chm(Tc,wg) 98 set Chm(Tc,vdw) 0 set Chm(Te,na) 52 set Chm(Te,nm) Tellurium set Chm(Te,wg) 127.6 set Chm(Te,vdw) 2.06 set Chm(Th,na) 90 set Chm(Th,nm) Thorium set Chm(Th,wg) 232.0381 set Chm(Th,vdw) 0 set Chm(Ti,na) 22 set Chm(Ti,nm) Titanium set Chm(Ti,wg) 47.867 set Chm(Ti,vdw) 2.23 set Chm(Tl,na) 81 set Chm(Tl,nm) Thallium set Chm(Tl,wg) 204.3833 set Chm(Tl,vdw) 1.96 set Chm(Tm,na) 69 set Chm(Tm,nm) Thulium set Chm(Tm,wg) 168.9342 set Chm(Tm,vdw) 0 set Chm(U,na) 92 set Chm(U,nm) Uranium set Chm(U,wg) 238.0289 set Chm(U,vdw) 1.86 set Chm(V,na) 23 set Chm(V,nm) Vanadium set Chm(V,wg) 50.9415 set Chm(V,vdw) 2.23 set Chm(W,na) 74 set Chm(W,nm) Tungsten set Chm(W,wg) 183.84 set Chm(W,vdw) 0 set Chm(Xe,na) 54 set Chm(Xe,nm) Xenon set Chm(Xe,wg) 131.293 set Chm(Xe,vdw) 2.16 set Chm(Y,na) 39 set Chm(Y,nm) Yttrium set Chm(Y,wg) 88.9059 set Chm(Y,vdw) 0 set Chm(Yb,na) 70 set Chm(Yb,nm) Ytterbium set Chm(Yb,wg) 173.04 set Chm(Yb,vdw) 0 set Chm(Zn,na) 30 set Chm(Zn,nm) Zinc set Chm(Zn,wg) 65.39 set Chm(Zn,vdw) 1.39 set Chm(Zr,na) 40 set Chm(Zr,nm) Zirconium set Chm(Zr,wg) 91.224 set Chm(Zr,vdw) 0 foreach v [array names Chm *,na] { set na [set Chm($v)] lassign [split $v ,] n tmp set r [set Chm($n,vdw)] set Chm(${na},vdw) $r } SampleVdW InitResidueTypes return } proc InitClustalMatrix {mat {positive 0} {scale 100} {Centre 0}} { # Taken from matrices.h from ClustalW source sode # with kind permissions of J.D. Thompson. set amino_acid_order "ABCDEFGHIKLMNPQRSTVWXYZ" set Tmat(blosum30) " 4, 0, 5, -3, -2, 17, 0, 5, -3, 9, 0, 0, 1, 1, 6, -2, -3, -3, -5, -4, 10, 0, 0, -4, -1, -2, -3, 8, -2, -2, -5, -2, 0, -3, -3, 14, 0, -2, -2, -4, -3, 0, -1, -2, 6, 0, 0, -3, 0, 2, -1, -1, -2, -2, 4, -1, -1, 0, -1, -1, 2, -2, -1, 2, -2, 4, 1, -2, -2, -3, -1, -2, -2, 2, 1, 2, 2, 6, 0, 4, -1, 1, -1, -1, 0, -1, 0, 0, -2, 0, 8, -1, -2, -3, -1, 1, -4, -1, 1, -3, 1, -3, -4, -3, 11, 1, -1, -2, -1, 2, -3, -2, 0, -2, 0, -2, -1, -1, 0, 8, -1, -2, -2, -1, -1, -1, -2, -1, -3, 1, -2, 0, -2, -1, 3, 8, 1, 0, -2, 0, 0, -1, 0, -1, -1, 0, -2, -2, 0, -1, -1, -1, 4, 1, 0, -2, -1, -2, -2, -2, -2, 0, -1, 0, 0, 1, 0, 0, -3, 2, 5, 1, -2, -2, -2, -3, 1, -3, -3, 4, -2, 1, 0, -2, -4, -3, -1, -1, 1, 5, -5, -5, -2, -4, -1, 1, 1, -5, -3, -2, -2, -3, -7, -3, -1, 0, -3, -5, -3, 20, 0, -1, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, -2, -1, -4, -3, -6, -1, -2, 3, -3, 0, -1, -1, 3, -1, -4, -2, -1, 0, -2, -1, 1, 5, -1, 9, 0, 0, 0, 0, 5, -4, -2, 0, -3, 1, -1, -1, -1, 0, 4, 0, -1, -1, -3, -1, 0, -2, 4" set Tmat(blosum40) " 5, -1, 5, -2, -2, 16, -1, 6, -2, 9, -1, 1, -2, 2, 7, -3, -3, -2, -4, -3, 9, 1, -1, -3, -2, -3, -3, 8, -2, 0, -4, 0, 0, -2, -2, 13, -1, -3, -4, -4, -4, 1, -4, -3, 6, -1, 0, -3, 0, 1, -3, -2, -1, -3, 6, -2, -3, -2, -3, -2, 2, -4, -2, 2, -2, 6, -1, -3, -3, -3, -2, 0, -2, 1, 1, -1, 3, 7, -1, 4, -2, 2, -1, -3, 0, 1, -2, 0, -3, -2, 8, -2, -2, -5, -2, 0, -4, -1, -2, -2, -1, -4, -2, -2, 11, 0, 0, -4, -1, 2, -4, -2, 0, -3, 1, -2, -1, 1, -2, 8, -2, -1, -3, -1, -1, -2, -3, 0, -3, 3, -2, -1, 0, -3, 2, 9, 1, 0, -1, 0, 0, -2, 0, -1, -2, 0, -3, -2, 1, -1, 1, -1, 5, 0, 0, -1, -1, -1, -1, -2, -2, -1, 0, -1, -1, 0, 0, -1, -2, 2, 6, 0, -3, -2, -3, -3, 0, -4, -4, 4, -2, 2, 1, -3, -3, -3, -2, -1, 1, 5, -3, -4, -6, -5, -2, 1, -2, -5, -3, -2, -1, -2, -4, -4, -1, -2, -5, -4, -3, 19, 0, -1, -2, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -2, -1, -1, 0, 0, -1, -2, -1, -2, -3, -4, -3, -2, 4, -3, 2, 0, -1, 0, 1, -2, -3, -1, -1, -2, -1, -1, 3, -1, 9, -1, 2, -3, 1, 5, -4, -2, 0, -4, 1, -2, -2, 0, -1, 4, 0, 0, -1, -3, -2, -1, -2, 5" set Tmat(blosum45) " 5, -1, 4, -1, -2, 12, -2, 5, -3, 7, -1, 1, -3, 2, 6, -2, -3, -2, -4, -3, 8, 0, -1, -3, -1, -2, -3, 7, -2, 0, -3, 0, 0, -2, -2, 10, -1, -3, -3, -4, -3, 0, -4, -3, 5, -1, 0, -3, 0, 1, -3, -2, -1, -3, 5, -1, -3, -2, -3, -2, 1, -3, -2, 2, -3, 5, -1, -2, -2, -3, -2, 0, -2, 0, 2, -1, 2, 6, -1, 4, -2, 2, 0, -2, 0, 1, -2, 0, -3, -2, 6, -1, -2, -4, -1, 0, -3, -2, -2, -2, -1, -3, -2, -2, 9, -1, 0, -3, 0, 2, -4, -2, 1, -2, 1, -2, 0, 0, -1, 6, -2, -1, -3, -1, 0, -2, -2, 0, -3, 3, -2, -1, 0, -2, 1, 7, 1, 0, -1, 0, 0, -2, 0, -1, -2, -1, -3, -2, 1, -1, 0, -1, 4, 0, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 2, 5, 0, -3, -1, -3, -3, 0, -3, -3, 3, -2, 1, 1, -3, -3, -3, -2, -1, 0, 5, -2, -4, -5, -4, -3, 1, -2, -3, -2, -2, -2, -2, -4, -3, -2, -2, -4, -3, -3, 15, 0, -1, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, -2, -1, -2, -2, -3, -2, -2, 3, -3, 2, 0, -1, 0, 0, -2, -3, -1, -1, -2, -1, -1, 3, -1, 8, -1, 2, -3, 1, 4, -3, -2, 0, -3, 1, -2, -1, 0, -1, 4, 0, 0, -1, -3, -2, -1, -2, 4" set Tmat(blosum62) " 8, -4, 8, 0, -6, 18, -4, 8, -6, 12, -2, 2, -8, 4, 10, -4, -6, -4, -6, -6, 12, 0, -2, -6, -2, -4, -6, 12, -4, 0, -6, -2, 0, -2, -4, 16, -2, -6, -2, -6, -6, 0, -8, -6, 8, -2, 0, -6, -2, 2, -6, -4, -2, -6, 10, -2, -8, -2, -8, -6, 0, -8, -6, 4, -4, 8, -2, -6, -2, -6, -4, 0, -6, -4, 2, -2, 4, 10, -4, 6, -6, 2, 0, -6, 0, 2, -6, 0, -6, -4, 12, -2, -4, -6, -2, -2, -8, -4, -4, -6, -2, -6, -4, -4, 14, -2, 0, -6, 0, 4, -6, -4, 0, -6, 2, -4, 0, 0, -2, 10, -2, -2, -6, -4, 0, -6, -4, 0, -6, 4, -4, -2, 0, -4, 2, 10, 2, 0, -2, 0, 0, -4, 0, -2, -4, 0, -4, -2, 2, -2, 0, -2, 8, 0, -2, -2, -2, -2, -4, -4, -4, -2, -2, -2, -2, 0, -2, -2, -2, 2, 10, 0, -6, -2, -6, -4, -2, -6, -6, 6, -4, 2, 2, -6, -4, -4, -6, -4, 0, 8, -6, -8, -4, -8, -6, 2, -4, -4, -6, -6, -4, -2, -8, -8, -4, -6, -6, -4, -6, 22, 0, -2, -4, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -4, -2, -2, 0, 0, -2, -4, -2, -4, -6, -4, -6, -4, 6, -6, 4, -2, -4, -2, -2, -4, -6, -2, -4, -4, -4, -2, 4, -2, 14, -2, 2, -6, 2, 8, -6, -4, 0, -6, 2, -6, -2, 0, -2, 6, 0, 0, -2, -4, -6, -2, -4, 8" set Tmat(blosum80) " 7, -3, 6, -1, -6, 13, -3, 6, -7, 10, -2, 1, -7, 2, 8, -4, -6, -4, -6, -6, 10, 0, -2, -6, -3, -4, -6, 9, -3, -1, -7, -2, 0, -2, -4, 12, -3, -6, -2, -7, -6, -1, -7, -6, 7, -1, -1, -6, -2, 1, -5, -3, -1, -5, 8, -3, -7, -3, -7, -6, 0, -7, -5, 2, -4, 6, -2, -5, -3, -6, -4, 0, -5, -4, 2, -3, 3, 9, -3, 5, -5, 2, -1, -6, -1, 1, -6, 0, -6, -4, 9, -1, -4, -6, -3, -2, -6, -5, -4, -5, -2, -5, -4, -4, 12, -2, -1, -5, -1, 3, -5, -4, 1, -5, 2, -4, -1, 0, -3, 9, -3, -2, -6, -3, -1, -5, -4, 0, -5, 3, -4, -3, -1, -3, 1, 9, 2, 0, -2, -1, -1, -4, -1, -2, -4, -1, -4, -3, 1, -2, -1, -2, 7, 0, -1, -2, -2, -2, -4, -3, -3, -2, -1, -3, -1, 0, -3, -1, -2, 2, 8, -1, -6, -2, -6, -4, -2, -6, -5, 4, -4, 1, 1, -5, -4, -4, -4, -3, 0, 7, -5, -8, -5, -8, -6, 0, -6, -4, -5, -6, -4, -3, -7, -7, -4, -5, -6, -5, -5, 16, -1, -3, -4, -3, -2, -3, -3, -2, -2, -2, -2, -2, -2, -3, -2, -2, -1, -1, -2, -5, -2, -4, -5, -5, -6, -5, 4, -6, 3, -3, -4, -2, -3, -4, -6, -3, -4, -3, -3, -3, 3, -3, 11, -2, 0, -7, 1, 6, -6, -4, 0, -6, 1, -5, -3, -1, -2, 5, 0, -1, -2, -4, -5, -1, -4, 6" set Tmat(pam20) " 6, -5, 6, -8,-14, 10, -4, 6,-16, 8, -3, 0,-16, 2, 8, -9,-12,-15,-17,-16, 9, -3, -4,-11, -4, -5,-10, 7, -8, -2, -8, -5, -6, -7,-10, 9, -6, -7, -7, -9, -6, -3,-13,-11, 9, -8, -3,-16, -6, -5,-16, -8, -8, -7, 7, -7,-10,-17,-15,-10, -4,-12, -7, -2, -9, 7, -6,-12,-16,-13, -8, -5,-10,-13, -2, -3, 0, 11, -5, 6,-13, 1, -3,-10, -4, -1, -6, -2, -8,-11, 8, -2, -8, -9, -9, -7,-11, -7, -5,-10, -8, -8, -9, -7, 8, -5, -4,-16, -4, 0,-15, -8, 0, -9, -4, -6, -5, -5, -4, 9, -8, -9, -9,-12,-11,-10,-11, -3, -6, -1,-10, -5, -7, -5, -2, 9, -1, -2, -4, -5, -5, -7, -3, -7, -8, -5, -9, -6, -1, -3, -6, -4, 7, -1, -4, -9, -6, -7,-10, -7, -8, -3, -4, -8, -5, -3, -5, -7, -8, 0, 7, -3, -9, -7, -9, -8, -9, -7, -7, 1,-10, -3, -2, -9, -7, -8, -9, -8, -4, 7, -16,-11,-18,-17,-19, -6,-17, -8,-16,-14, -7,-15, -9,-16,-15, -3, -6,-15,-18, 13, -4, -6,-11, -7, -6, -9, -6, -6, -6, -6, -7, -6, -4, -6, -6, -7, -4, -5, -6,-13, -6, -9, -7, -5,-13, -9, 1,-16, -4, -7,-10, -8,-13, -5,-16,-14,-11, -8, -7, -8, -6, -9, 10, -4, -1,-16, 0, 6,-16, -6, -2, -7, -5, -8, -6, -4, -5, 7, -5, -6, -7, -8,-17, -6,-11, 6" set Tmat(pam60) " 5, -2, 5, -5, -9, 9, -2, 5,-10, 7, -1, 2,-10, 3, 7, -6, -8, -9,-11,-10, 8, 0, -2, -7, -2, -2, -7, 6, -5, 0, -6, -2, -3, -4, -6, 8, -3, -4, -4, -5, -4, -1, -7, -6, 7, -5, -1,-10, -2, -3,-10, -5, -4, -4, 6, -4, -7,-11, -9, -7, -1, -8, -4, 0, -6, 6, -3, -6,-10, -7, -5, -2, -6, -7, 1, 0, 2, 10, -2, 5, -7, 2, 0, -6, -1, 1, -4, 0, -5, -6, 6, 0, -4, -6, -5, -3, -7, -4, -2, -6, -4, -5, -6, -4, 7, -3, -1,-10, -1, 2, -9, -5, 2, -5, -1, -3, -2, -2, -1, 7, -5, -5, -6, -6, -6, -7, -7, 0, -4, 2, -6, -2, -3, -2, 0, 8, 1, 0, -1, -2, -2, -5, 0, -4, -4, -2, -6, -4, 1, 0, -3, -2, 5, 1, -2, -5, -3, -4, -6, -3, -5, -1, -2, -5, -2, -1, -2, -4, -4, 1, 6, -1, -5, -4, -6, -4, -5, -4, -5, 3, -6, -1, 0, -5, -4, -5, -5, -4, -1, 6, -10, -8,-12,-11,-12, -3,-11, -5,-10, -8, -4, -9, -6,-10, -9, 0, -4, -9,-11, 13, -2, -3, -6, -3, -3, -5, -3, -3, -3, -3, -4, -3, -2, -3, -3, -4, -2, -2, -3, -8, -3, -6, -5, -2, -8, -7, 3,-10, -2, -4, -7, -5, -7, -3,-10, -8, -8, -5, -5, -5, -3, -5, 9, -2, 1,-10, 2, 5,-10, -3, 0, -4, -2, -5, -4, -1, -2, 6, -2, -3, -4, -5,-11, -3, -7, 5" set Tmat(pam120) " 3, 0, 4, -3, -6, 9, 0, 4, -7, 5, 0, 3, -7, 3, 5, -4, -5, -6, -7, -7, 8, 1, 0, -4, 0, -1, -5, 5, -3, 1, -4, 0, -1, -3, -4, 7, -1, -3, -3, -3, -3, 0, -4, -4, 6, -2, 0, -7, -1, -1, -7, -3, -2, -3, 5, -3, -4, -7, -5, -4, 0, -5, -3, 1, -4, 5, -2, -4, -6, -4, -3, -1, -4, -4, 1, 0, 3, 8, -1, 3, -5, 2, 1, -4, 0, 2, -2, 1, -4, -3, 4, 1, -2, -4, -3, -2, -5, -2, -1, -3, -2, -3, -3, -2, 6, -1, 0, -7, 1, 2, -6, -3, 3, -3, 0, -2, -1, 0, 0, 6, -3, -2, -4, -3, -3, -5, -4, 1, -2, 2, -4, -1, -1, -1, 1, 6, 1, 0, 0, 0, -1, -3, 1, -2, -2, -1, -4, -2, 1, 1, -2, -1, 3, 1, 0, -3, -1, -2, -4, -1, -3, 0, -1, -3, -1, 0, -1, -2, -2, 2, 4, 0, -3, -3, -3, -3, -3, -2, -3, 3, -4, 1, 1, -3, -2, -3, -3, -2, 0, 5, -7, -6, -8, -8, -8, -1, -8, -3, -6, -5, -3, -6, -4, -7, -6, 1, -2, -6, -8, 12, -1, -1, -4, -2, -1, -3, -2, -2, -1, -2, -2, -2, -1, -2, -1, -2, -1, -1, -1, -5, -2, -4, -3, -1, -5, -5, 4, -6, -1, -2, -5, -2, -4, -2, -6, -5, -5, -3, -3, -3, -2, -3, 8, -1, 2, -7, 3, 4, -6, -2, 1, -3, -1, -3, -2, 0, -1, 4, -1, -1, -2, -3, -7, -1, -5, 4" set Tmat(pam250) " 2, 0, 3, -2, -4, 12, 0, 3, -5, 4, 0, 3, -5, 3, 4, -3, -4, -4, -6, -5, 9, 1, 0, -3, 1, 0, -5, 5, -1, 1, -3, 1, 1, -2, -2, 6, -1, -2, -2, -2, -2, 1, -3, -2, 5, -1, 1, -5, 0, 0, -5, -2, 0, -2, 5, -2, -3, -6, -4, -3, 2, -4, -2, 2, -3, 6, -1, -2, -5, -3, -2, 0, -3, -2, 2, 0, 4, 6, 0, 2, -4, 2, 1, -3, 0, 2, -2, 1, -3, -2, 2, 1, -1, -3, -1, -1, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 1, -5, 2, 2, -5, -1, 3, -2, 1, -2, -1, 1, 0, 4, -2, -1, -4, -1, -1, -4, -3, 2, -2, 3, -3, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, -3, 1, -1, -1, 0, -3, -2, 1, 1, -1, 0, 2, 1, 0, -2, 0, 0, -3, 0, -1, 0, 0, -2, -1, 0, 0, -1, -1, 1, 3, 0, -2, -2, -2, -2, -1, -1, -2, 4, -2, 2, 2, -2, -1, -2, -2, -1, 0, 4, -6, -5, -8, -7, -7, 0, -7, -3, -5, -3, -2, -4, -4, -6, -5, 2, -2, -5, -6, 17, 0, -1, -3, -1, -1, -2, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, 0, 0, -1, -4, -1, -3, -3, 0, -4, -4, 7, -5, 0, -1, -4, -1, -2, -2, -5, -4, -4, -3, -3, -2, 0, -2, 10, 0, 2, -5, 3, 3, -5, 0, 2, -2, 0, -3, -2, 1, 0, 3, 0, 0, -1, -2, -6, -1, -4, 3" set Tmat(pam350) " 2, 1, 3, -2, -5, 18, 1, 3, -6, 4, 1, 3, -6, 4, 4, -4, -5, -5, -6, -6, 13, 2, 1, -4, 1, 1, -6, 5, -1, 1, -4, 1, 1, -2, -2, 7, 0, -2, -3, -2, -2, 2, -2, -2, 5, -1, 1, -6, 1, 0, -6, -1, 1, -2, 5, -2, -4, -7, -4, -4, 3, -4, -2, 4, -3, 8, -1, -2, -6, -3, -2, 1, -3, -2, 3, 0, 5, 6, 0, 2, -4, 2, 2, -4, 1, 2, -2, 1, -3, -2, 2, 1, 0, -3, 0, 0, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 2, -6, 2, 3, -5, -1, 3, -2, 1, -2, -1, 1, 1, 4, -1, 0, -4, -1, 0, -5, -2, 2, -2, 4, -3, 0, 1, 0, 2, 7, 1, 1, 0, 1, 0, -4, 1, -1, -1, 0, -3, -2, 1, 1, 0, 0, 1, 1, 0, -2, 0, 0, -3, 1, -1, 0, 0, -2, -1, 1, 1, 0, -1, 1, 2, 0, -2, -2, -2, -2, -1, -1, -2, 4, -2, 3, 2, -2, -1, -2, -3, -1, 0, 5, -7, -6,-10, -8, -8, 1, -8, -3, -6, -4, -2, -5, -5, -7, -5, 4, -3, -6, -7, 27, 0, 0, -3, -1, 0, -2, -1, 0, 0, -1, -1, 0, 0, 0, 0, -1, 0, 0, 0, -5, -1, -4, -4, 1, -5, -5, 11, -6, 0, 0, -5, 0, -2, -3, -6, -5, -5, -3, -3, -2, 1, -2, 14, 0, 2, -6, 3, 3, -6, 0, 2, -2, 1, -3, -2, 2, 0, 3, 1, 0, 0, -2, -7, 0, -5, 3" set Tmat(idmat) " 10, 0, 10, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,10" set Tmat(gon40) " 92, 0, 0, -31, 0, 163, -56, 0,-135, 111, -37, 0,-140, 16, 105, -92, 0, -64,-152,-143, 126, -32, 0, -91, -51, -76,-152, 105, -65, 0, -67, -41, -40, -50, -81, 145, -76, 0, -87,-150,-106, -39,-158, -94, 104, -54, 0,-132, -47, -13,-127, -79, -34, -86, 103, -68, 0, -85,-155,-108, -13,-141, -85, 5, -85, 89, -45, 0, -63,-130, -80, -16,-114, -60, 10, -57, 16, 140, -62, 0, -83, 6, -38,-104, -40, -7, -99, -20,-112, -91, 115, -37, 0,-137, -69, -60,-128, -87, -71,-108, -62, -83,-119, -78, 124, -43, 0,-113, -32, 10,-100, -71, 0, -91, 2, -60, -35, -25, -46, 118, -61, 0, -86, -77, -50,-130, -69, -31,-103, 19, -84, -81, -47, -73, -6, 112, 0, 0, -35, -36, -41,-111, -37, -48, -95, -43, -95, -64, -11, -35, -35, -51, 99, -25, 0, -59, -47, -52, -90, -85, -46, -51, -34, -78, -44, -27, -42, -39, -52, 13, 100, -22, 0, -43,-133, -74, -58,-122, -98, 28, -82, -18, -22,-103, -86, -79, -88, -74, -25, 97, -120, 0, -68,-171,-131, -6,-108, -70, -93,-127, -71, -72,-119,-149, -87, -63, -98,-120,-115, 181, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -95, 0, -56, -98,-107, 31,-129, 5, -76, -88, -64, -66, -62,-106, -81, -75, -69, -87, -73, 1, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon80) " 75, 0, 0, -10, 0, 154, -31, 0, -93, 96, -17, 0, -94, 31, 88, -64, 0, -39,-111,-102, 114, -11, 0, -61, -26, -47,-115, 97, -39, 0, -43, -17, -17, -26, -53, 127, -43, 0, -54,-106, -73, -15,-114, -64, 86, -30, 0, -88, -21, 4, -89, -50, -12, -59, 85, -43, 0, -55,-109, -75, 7,-104, -57, 22, -58, 77, -26, 0, -39, -88, -53, 3, -83, -38, 25, -37, 31, 117, -34, 0, -55, 21, -13, -75, -18, 9, -71, -2, -79, -62, 97, -16, 0, -93, -42, -35, -93, -58, -45, -75, -37, -58, -78, -48, 114, -22, 0, -76, -9, 23, -70, -44, 14, -60, 17, -39, -19, -6, -24, 95, -36, 0, -60, -44, -23, -90, -43, -10, -71, 33, -58, -53, -22, -45, 11, 97, 14, 0, -15, -14, -19, -77, -16, -25, -62, -20, -64, -41, 5, -14, -15, -27, 78, -5, 0, -34, -24, -27, -62, -52, -24, -28, -15, -49, -25, -7, -20, -18, -27, 25, 81, -6, 0, -21, -89, -51, -31, -86, -65, 41, -54, 3, 1, -69, -57, -51, -60, -43, -9, 80, -87, 0, -43,-124, -98, 16, -81, -43, -63, -89, -44, -45, -86,-112, -62, -41, -72, -87, -80, 173, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -65, 0, -32, -69, -74, 49, -94, 21, -47, -60, -35, -37, -39, -76, -53, -50, -46, -58, -47, 23, 0, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon120) " 59, 0, 0, -1, 0, 144, -18, 0, -69, 82, -9, 0, -68, 35, 72, -48, 0, -26, -87, -78, 102, -3, 0, -45, -14, -31, -92, 90, -26, 0, -31, -7, -6, -14, -37, 110, -27, 0, -36, -80, -55, -3, -87, -48, 72, -19, 0, -64, -8, 11, -67, -34, -2, -44, 69, -30, 0, -39, -82, -57, 15, -82, -42, 28, -44, 66, -17, 0, -26, -64, -40, 11, -65, -28, 29, -27, 34, 95, -20, 0, -41, 26, -1, -58, -7, 14, -55, 5, -61, -46, 80, -6, 0, -68, -28, -22, -72, -41, -31, -56, -24, -44, -56, -32, 105, -12, 0, -56, 1, 25, -53, -30, 17, -43, 20, -30, -14, 1, -14, 74, -23, 0, -45, -27, -10, -68, -30, -1, -53, 36, -44, -38, -10, -30, 16, 83, 16, 0, -7, -5, -9, -58, -6, -14, -44, -10, -47, -29, 10, -5, -7, -15, 60, 2, 0, -21, -13, -15, -47, -35, -14, -17, -6, -34, -16, 0, -10, -9, -16, 26, 64, 0, 0, -11, -65, -38, -17, -65, -47, 42, -39, 13, 10, -50, -42, -36, -44, -28, -3, 65, -68, 0, -29, -96, -78, 27, -66, -28, -46, -68, -29, -31, -68, -89, -49, -30, -57, -67, -59, 166, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -48, 0, -20, -53, -56, 55, -74, 26, -31, -44, -20, -22, -28, -59, -38, -37, -35, -42, -33, 33, 0, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon160) " 46, 0, 0, 3, 0, 135, -11, 0, -53, 70, -4, 0, -52, 34, 59, -38, 0, -18, -70, -62, 91, 2, 0, -34, -7, -21, -76, 82, -18, 0, -23, -1, -1, -7, -27, 93, -18, 0, -25, -62, -43, 3, -70, -37, 59, -12, 0, -48, -1, 13, -53, -24, 2, -35, 55, -22, 0, -29, -65, -45, 19, -67, -32, 30, -34, 57, -12, 0, -19, -50, -31, 14, -52, -21, 29, -21, 34, 76, -12, 0, -31, 26, 5, -47, -2, 15, -44, 8, -48, -36, 65, -1, 0, -52, -19, -14, -58, -30, -22, -43, -16, -35, -42, -22, 96, -7, 0, -42, 6, 23, -41, -21, 17, -32, 20, -24, -12, 5, -8, 56, -16, 0, -35, -16, -3, -53, -21, 3, -41, 35, -35, -29, -4, -21, 17, 71, 16, 0, -2, 0, -3, -45, -1, -8, -33, -4, -36, -23, 11, 0, -2, -9, 44, 5, 0, -14, -6, -8, -36, -24, -8, -12, -2, -24, -11, 3, -4, -4, -9, 23, 50, 1, 0, -6, -49, -30, -8, -52, -35, 40, -30, 17, 14, -38, -32, -27, -34, -20, 0, 53, -55, 0, -21, -78, -64, 32, -55, -19, -34, -54, -20, -22, -55, -74, -40, -24, -47, -54, -45, 158, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -37, 0, -13, -42, -44, 56, -60, 27, -20, -35, -11, -13, -22, -48, -29, -29, -28, -32, -24, 38, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon250) " 24, 0, 0, 5, 0, 115, -3, 0, -32, 47, 0, 0, -30, 27, 36, -23, 0, -8, -45, -39, 70, 5, 0, -20, 1, -8, -52, 66, -8, 0, -13, 4, 4, -1, -14, 60, -8, 0, -11, -38, -27, 10, -45, -22, 40, -4, 0, -28, 5, 12, -33, -11, 6, -21, 32, -12, 0, -15, -40, -28, 20, -44, -19, 28, -21, 40, -7, 0, -9, -30, -20, 16, -35, -13, 25, -14, 28, 43, -3, 0, -18, 22, 9, -31, 4, 12, -28, 8, -30, -22, 38, 3, 0, -31, -7, -5, -38, -16, -11, -26, -6, -23, -24, -9, 76, -2, 0, -24, 9, 17, -26, -10, 12, -19, 15, -16, -10, 7, -2, 27, -6, 0, -22, -3, 4, -32, -10, 6, -24, 27, -22, -17, 3, -9, 15, 47, 11, 0, 1, 5, 2, -28, 4, -2, -18, 1, -21, -14, 9, 4, 2, -2, 22, 6, 0, -5, 0, -1, -22, -11, -3, -6, 1, -13, -6, 5, 1, 0, -2, 15, 25, 1, 0, 0, -29, -19, 1, -33, -20, 31, -17, 18, 16, -22, -18, -15, -20, -10, 0, 34, -36, 0, -10, -52, -43, 36, -40, -8, -18, -35, -7, -10, -36, -50, -27, -16, -33, -35, -26, 142, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -22, 0, -5, -28, -27, 51, -40, 22, -7, -21, 0, -2, -14, -31, -17, -18, -19, -19, -11, 41, 0, 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon300) " 16, 0, 0, 5, 0, 104, -1, 0, -24, 37, 1, 0, -23, 23, 27, -18, 0, -5, -37, -31, 60, 5, 0, -15, 3, -4, -42, 58, -6, 0, -10, 5, 4, 0, -10, 45, -6, 0, -7, -30, -21, 11, -36, -16, 33, -2, 0, -21, 6, 11, -26, -7, 5, -17, 24, -9, 0, -10, -32, -22, 19, -36, -14, 25, -17, 33, -5, 0, -6, -24, -16, 15, -28, -10, 22, -11, 24, 31, -1, 0, -14, 18, 9, -25, 5, 10, -22, 8, -24, -17, 27, 3, 0, -23, -4, -2, -30, -11, -8, -20, -3, -18, -19, -6, 66, -1, 0, -18, 9, 14, -20, -6, 9, -15, 13, -13, -8, 7, -1, 18, -4, 0, -17, 0, 5, -25, -6, 6, -19, 22, -18, -13, 4, -6, 13, 37, 8, 0, 1, 5, 3, -22, 4, -1, -14, 2, -17, -11, 7, 4, 2, 0, 15, 5, 0, -3, 1, 1, -17, -7, -1, -4, 2, -9, -5, 4, 2, 1, -1, 11, 17, 0, 0, 1, -23, -15, 4, -26, -15, 26, -13, 17, 15, -17, -14, -12, -15, -8, 0, 26, -29, 0, -7, -42, -36, 36, -34, -5, -13, -28, -4, -6, -30, -41, -23, -14, -27, -28, -19, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17, 0, -3, -22, -22, 46, -33, 18, -3, -17, 3, 1, -12, -25, -14, -14, -15, -15, -7, 40, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set Tmat(gon350) " 10, 0, 0, 4, 0, 93, 0, 0, -19, 29, 1, 0, -17, 19, 20, -14, 0, -3, -30, -25, 51, 5, 0, -12, 4, -2, -35, 51, -4, 0, -8, 5, 4, 1, -7, 33, -4, 0, -5, -24, -17, 11, -29, -13, 27, -1, 0, -16, 6, 9, -21, -4, 5, -13, 18, -7, 0, -7, -25, -18, 18, -30, -11, 22, -14, 28, -4, 0, -4, -19, -13, 14, -23, -8, 19, -9, 21, 23, 0, 0, -11, 15, 9, -20, 5, 8, -18, 7, -19, -14, 20, 3, 0, -18, -2, 0, -25, -7, -5, -16, -2, -15, -14, -3, 56, 0, 0, -14, 8, 11, -16, -4, 7, -11, 10, -11, -7, 6, 0, 12, -2, 0, -13, 2, 6, -20, -4, 6, -15, 18, -14, -11, 4, -4, 10, 28, 6, 0, 1, 5, 3, -18, 5, 0, -11, 2, -13, -9, 6, 4, 2, 1, 10, 4, 0, -2, 2, 1, -13, -5, -1, -3, 2, -7, -4, 4, 2, 1, 0, 8, 11, 0, 0, 2, -18, -12, 5, -21, -11, 22, -10, 16, 14, -13, -11, -9, -12, -6, 0, 21, -24, 0, -4, -35, -29, 35, -30, -3, -9, -23, -1, -3, -24, -34, -19, -12, -22, -23, -14, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, -1, -18, -17, 42, -27, 15, -1, -14, 5, 2, -10, -20, -11, -12, -12, -12, -4, 39, 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0" set val [set Tmat($mat)] set val [string map [list "\n" "" " " ""] $val] set Lv [split $val ,] set Laa [split $amino_acid_order ""] #lappend Laa "" set naa [llength $Laa] set ix 0 ; set min 99999999. ; set ave 0.0 for {set i 0} {$i < $naa} {incr i} { set a [lindex $Laa $i] for {set j 0} {$j <= $i} {incr j} { set b [lindex $Laa $j] set v [lindex $Lv $ix] set min [expr {$v<$min?$v:$min}] if {$a != $b} { set ave [expr {$ave + $v}] } set mtx($a,$b) [expr {$v * $scale}] set mtx($b,$a) [expr {$v * $scale}] incr ix } } set mtx(average) [expr {-1.0*$ave/($naa*($naa-1.)/2.)}] set min [expr {$min*$scale}] if {$positive && $min < 0.} { foreach k [array names mtx "*,*"] { set nv [expr {[set mtx($k)] - $min}] set mtx($k) $nv } } set mtx(laa) $amino_acid_order if {$Centre} { set M [list] foreach a $Laa { set tmp [list] foreach b $Laa { lappend tmp [set mtx($a,$b)] } lappend M $tmp } set M [CentreMatrice $M] foreach a $Laa l $M { foreach b $Laa c $l { set mtx($a,$b) $c } } } return [array get mtx] } proc InitCode3l1l {} { global AutreCodeLuc set Lcd {I ILE L LEU M MET M MSE V VAL Y TYR Y PTR W TRP C CYH C CYS C SEC R ARG E GLU Q GLN K LYS K LYX D ASP N ASN A ALA F PHE S SER S SEP P PRO P CPR H HIS G GLY T THR T TPO O HOH} foreach {Nom AA} $Lcd { set AutreCodeLuc($AA) $Nom if {$AA eq "MSE" || $AA eq "CPR" || $AA eq "CYH" || $AA eq "SEC" || $AA eq "PTR" || $AA eq "SEP" || $AA eq "TPO"} {continue} set AutreCodeLuc($Nom) $AA } return } proc InitComparaison {} { global ListeDesSimilarites ListeDesAcidesAmines # liste acides amines de Clustal set ListeDesAcidesAmines {A B C D E F G H I K L M N P Q R S T V W X Y Z} #set ListeDesAcidesAmines {A C D E F G H I K L M N P Q R S T V W Y Z} set ListeDesSimilarites {1 2 3 4 5 Z} # 1 = A,I,L,M,V # 2 = P,A,G,S,T # 3 = D,E,Q,N # 4 = F,Y,W # 5 = K,R,H # Z si sequence manquante return } proc InitConsensus {} { global ListeDesConsensusDuGroupe LNDG LongueurTotale set Cs [string repeat "#" $LongueurTotale] unset -nocomplain ListeDesConsensusDuGroupe foreach NomDeGroupe $LNDG { set ListeDesConsensusDuGroupe($NomDeGroupe) $Cs } return } proc InitContextMenu {} { global OrdEtcDir image create photo PT -file [file join $OrdEtcDir hand14.gif] image create photo ZP -file [file join $OrdEtcDir loupeplus.gif] image create photo ZM -file [file join $OrdEtcDir loupemoins.gif] image create photo RP -file [file join $OrdEtcDir rotateplus.gif] image create photo RM -file [file join $OrdEtcDir rotatemoins.gif] image create photo WE -file [file join $OrdEtcDir noeudecarte.gif] image create photo WS -file [file join $OrdEtcDir noeudserre.gif] image create photo HE -file [file join $OrdEtcDir heightecarte.gif] image create photo HS -file [file join $OrdEtcDir heightserre.gif] return } proc InitCouleursGroupes {} { global LNDG TypeCons TypeText Couleurs set NombreDeGroupes [llength $LNDG] if {$NombreDeGroupes > 1} { set ListeCol [Nuancier $NombreDeGroupes] set i 1 foreach col $ListeCol { lappend TypeCons "CoulG$i" set TypeText(CoulG$i) "Identity Group $i" set Couleurs(CoulG$i) $col incr i } } return } 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 InitDataProfile {} { global LPV set LPV {} set Lcalls [::profiler::sortFunctions calls] foreach e $Lcalls { lassign $e p v set ProcP($p) $v } set Larun [::profiler::sortFunctions avgRuntime] foreach e $Larun { lassign $e p v lappend ProcP($p) $v } set Ltrun [::profiler::sortFunctions totalRuntime] foreach e $Ltrun { lassign $e p v lappend ProcP($p) $v } set Lexrn [::profiler::sortFunctions exclusiveRuntime] foreach e $Lexrn { lassign $e p v lappend ProcP($p) $v } set Laern [::profiler::sortFunctions avgExclusiveRuntime] foreach e $Laern { lassign $e p v lappend ProcP($p) $v } foreach n [array names ProcP] { lassign [set ProcP($n)] c a t x e if {! $c} {continue} if {$a == ""} {set a 0} if {$t == ""} {set t 0} if {$x == ""} {set x 0} if {$e == ""} {set e 0} set lv [list [string range $n 2 end] $c $a $t $x $e] lappend LPV $lv } return } proc InitEtAfficheNomSeqSecStr {widget} { global NomEtSeqAssPDB global Sequences global LNOrdali set TextAffiche "" foreach elt $NomEtSeqAssPDB { scan $elt "%s %s %s" PDB NomSeqAss MolId if {[regexp {^[0-9]} $NomSeqAss]} { set NomSeq [lindex $LNOrdali $NomSeqAss] } else { set NomSeq $NomSeqAss } set TextAffiche "[set TextAffiche][set NomSeq]\nPDB_[set MolId]\nSec. Str.\n\n" } $widget delete 0.0 end $widget insert end [set TextAffiche] $widget configure -state disabled return } proc InitFolders {folder} { global db imapID mb foreach info [::imap4::mboxinfo $imapID] { set mb($folder,$info) [::imap4::mboxinfo $imapID $info] } # Now read get the total number of messages # Carefull, this may be an empty box if {[info exists mb($folder,exists)]} { set nbMess $mb($folder,exists) } elseif {[info exists mb($folder,uidnext)]} { set nbMess [expr {$mb($folder,uidnext) - 1}] } else { set nbMess 0 } if {$nbMess == 0} {return} # fetch flags for all messages set Lf [::imap4::fetch $imapID 1:$nbMess from to subject date bodystructure] foreach {from to subject date bodystructure} $Lf { } return } proc InitFourmis {} { global TFB PAD set taille [expr {($TFB(lenFourmi) + $TFB(headFourmi))/2}] for {set i 0} {$i < $TFB(nFourmis)} {incr i} { set ok 0 while {! $ok} { set x [expr {round($TFB(dimX)*rand())}] set y [expr {round($TFB(dimY)*rand())}] # y a t il qq chose dans la boite # qui va contenir la fourmi ? set x1 [expr {$x - $taille}] set x2 [expr {$x + $taille}] set y1 [expr {$y - $taille}] set y2 [expr {$y + $taille}] if {[$PAD find overlapping $x1 $y1 $x2 $y2] == {}} { set ok 1 } } set x1 [expr {$x - $TFB(lenFourmi)/2}] set x2 [expr {$x + $TFB(lenFourmi)/2}] set y1 [expr {$y - $TFB(widFourmi)/2}] set y2 [expr {$y + $TFB(widFourmi)/2}] $PAD create polygon $x1 $y1 $x1 $y2 $x2 $y2 $x2 $y1 -fill $TFB(colFourmi) -outline $TFB(colFourmi) -tags [list fourmi corps "F$i"] set xc $x2 ; set yc $y set x1 [expr {$xc - $TFB(headFourmi)/2}] set x2 [expr {$xc + $TFB(headFourmi)/2}] set y1 [expr {$yc - $TFB(headFourmi)/2}] set y2 [expr {$yc + $TFB(headFourmi)/2}] $PAD create polygon $x1 $y1 $x2 $yc $x1 $y2 -fill $TFB(colFourmi) -outline $TFB(colFourmi) -tags [list fourmi tete "F$i"] set TFB(F$i,oldAng) 0 set TFB(F$i,angle) [BonAngle [expr {359.*rand()}]] set TFB(F$i,hasBall) 0 set TFB(F$i,lastBall) -1 set TFB(F$i,col) "" set TFB(F$i,angle) 45. TourneFourmi "F$i" OnSortPas "F$i" lappend TFB(LFourmis) $i } return } proc InitGeneticCode {} { global CodeGen set tcode " XXX X XXX PHE F TTT TTC LEU L TTA TTG CTT CTC CTA CTG ILE I ATT ATC ATA MET M ATG VAL V GTT GTC GTA GTG SER S TCT TCC TCA TCG AGT AGC PRO P CCT CCC CCA CCG THR T ACT ACC ACA ACG ALA A GCT GCC GCA GCG TYR Y TAT TAC HIS H CAT CAC GLN Q CAA CAG ASN N AAT AAC LYS K AAA AAG ASP D GAT GAC GLU E GAA GAG CYS C TGT TGC TRP W TGG TGA ARG R CGT CGC CGA CGG AGA AGG GLY G GGT GGC GGA GGG " set Lc [split $tcode \n] foreach l $Lc { if {$l eq ""} {continue} set Lv [split [string trim $l] " "] set aa3 [lindex $Lv 0] set aa1 [lindex $Lv 1] foreach cdn [lrange $Lv 2 end] { lappend CodeGen($aa3) $cdn set CodeGen($cdn) $aa1 } } return } proc InitGon250 {} { set lgon [list "# benner-gonnet matrix" "# pam := 250" "# print (DayhoffM (NewLogPAM1, pam));" "# DayMatrix(Peptide, pam=250, Simil: max=14.152, min=-5.161, max offdiag=5.080," "# del=-19.814-1.396*(k-1))" " A R N D C Q E G H I L K M F P S T W Y V B Z X *" " 2.4 -0.6 -0.3 -0.3 0.5 -0.2 0.0 0.5 -0.8 -0.8 -1.2 -0.4 -0.7 -2.3 0.3 1.1 0.6 -3.6 -2.2 0.1 0.0 0.0 0.0 -5.2" " -0.6 4.7 0.3 -0.3 -2.2 1.5 0.4 -1.0 0.6 -2.4 -2.2 2.7 -1.7 -3.2 -0.9 -0.2 -0.2 -1.6 -1.8 -2.0 0.0 0.0 0.0 -5.2" " -0.3 0.3 3.8 2.2 -1.8 0.7 0.9 0.4 1.2 -2.8 -3.0 0.8 -2.2 -3.1 -0.9 0.9 0.5 -3.6 -1.4 -2.2 0.0 0.0 0.0 -5.2" " -0.3 -0.3 2.2 4.7 -3.2 0.9 2.7 0.1 0.4 -3.8 -4.0 0.5 -3.0 -4.5 -0.7 0.5 0.0 -5.2 -2.8 -2.9 0.0 0.0 0.0 -5.2" " 0.5 -2.2 -1.8 -3.2 11.5 -2.4 -3.0 -2.0 -1.3 -1.1 -1.5 -2.8 -0.9 -0.8 -3.1 0.1 -0.5 -1.0 -0.5 0.0 0.0 0.0 0.0 -5.2" " -0.2 1.5 0.7 0.9 -2.4 2.7 1.7 -1.0 1.2 -1.9 -1.6 1.5 -1.0 -2.6 -0.2 0.2 0.0 -2.7 -1.7 -1.5 0.0 0.0 0.0 -5.2" " 0.0 0.4 0.9 2.7 -3.0 1.7 3.6 -0.8 0.4 -2.7 -2.8 1.2 -2.0 -3.9 -0.5 0.2 -0.1 -4.3 -2.7 -1.9 0.0 0.0 0.0 -5.2" " 0.5 -1.0 0.4 0.1 -2.0 -1.0 -0.8 6.6 -1.4 -4.5 -4.4 -1.1 -3.5 -5.2 -1.6 0.4 -1.1 -4.0 -4.0 -3.3 0.0 0.0 0.0 -5.2" " -0.8 0.6 1.2 0.4 -1.3 1.2 0.4 -1.4 6.0 -2.2 -1.9 0.6 -1.3 -0.1 -1.1 -0.2 -0.3 -0.8 2.2 -2.0 0.0 0.0 0.0 -5.2" " -0.8 -2.4 -2.8 -3.8 -1.1 -1.9 -2.7 -4.5 -2.2 4.0 2.8 -2.1 2.5 1.0 -2.6 -1.8 -0.6 -1.8 -0.7 3.1 0.0 0.0 0.0 -5.2" " -1.2 -2.2 -3.0 -4.0 -1.5 -1.6 -2.8 -4.4 -1.9 2.8 4.0 -2.1 2.8 2.0 -2.3 -2.1 -1.3 -0.7 0.0 1.8 0.0 0.0 0.0 -5.2" " -0.4 2.7 0.8 0.5 -2.8 1.5 1.2 -1.1 0.6 -2.1 -2.1 3.2 -1.4 -3.3 -0.6 0.1 0.1 -3.5 -2.1 -1.7 0.0 0.0 0.0 -5.2" " -0.7 -1.7 -2.2 -3.0 -0.9 -1.0 -2.0 -3.5 -1.3 2.5 2.8 -1.4 4.3 1.6 -2.4 -1.4 -0.6 -1.0 -0.2 1.6 0.0 0.0 0.0 -5.2" " -2.3 -3.2 -3.1 -4.5 -0.8 -2.6 -3.9 -5.2 -0.1 1.0 2.0 -3.3 1.6 7.0 -3.8 -2.8 -2.2 3.6 5.1 0.1 0.0 0.0 0.0 -5.2" " 0.3 -0.9 -0.9 -0.7 -3.1 -0.2 -0.5 -1.6 -1.1 -2.6 -2.3 -0.6 -2.4 -3.8 7.6 0.4 0.1 -5.0 -3.1 -1.8 0.0 0.0 0.0 -5.2" " 1.1 -0.2 0.9 0.5 0.1 0.2 0.2 0.4 -0.2 -1.8 -2.1 0.1 -1.4 -2.8 0.4 2.2 1.5 -3.3 -1.9 -1.0 0.0 0.0 0.0 -5.2" " 0.6 -0.2 0.5 0.0 -0.5 0.0 -0.1 -1.1 -0.3 -0.6 -1.3 0.1 -0.6 -2.2 0.1 1.5 2.5 -3.5 -1.9 0.0 0.0 0.0 0.0 -5.2" " -3.6 -1.6 -3.6 -5.2 -1.0 -2.7 -4.3 -4.0 -0.8 -1.8 -0.7 -3.5 -1.0 3.6 -5.0 -3.3 -3.5 14.2 4.1 -2.6 0.0 0.0 0.0 -5.2" " -2.2 -1.8 -1.4 -2.8 -0.5 -1.7 -2.7 -4.0 2.2 -0.7 0.0 -2.1 -0.2 5.1 -3.1 -1.9 -1.9 4.1 7.8 -1.1 0.0 0.0 0.0 -5.2" " 0.1 -2.0 -2.2 -2.9 0.0 -1.5 -1.9 -3.3 -2.0 3.1 1.8 -1.7 1.6 0.1 -1.8 -1.0 0.0 -2.6 -1.1 3.4 0.0 0.0 0.0 -5.2" " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -5.2" " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -5.2" " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -5.2" " -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 -5.2 1"] return $lgon } proc InitHydroAA {} { global THydroAA array set THydroAA {A -1.6 B 0.0 C -2.0 D 9.2 E 8.2 F -3.7 G -1.0 H 3.0 I -3.1 J 0.0 K 8.8 L -2.8 M -3.4 N 4.8 O 0.0 P 0.2 Q 4.1 R 12.3 S -0.6 T -1.2 U 0.0 V -2.6 W -1.9 X 0.0 Y 0.7 Z 0.0} return } proc InitIDMapping {} { global TIDMap if {[info exists TIDMap]} { return } set Ll [LesLignesDuFichier [file join $::OrdSrcDir idmapping.txt]] set TIDMap(Lcat) [list] set TIDMap(Ldbs) [list] set TIDMap(Lids) [list] foreach l $Ll { set l [string trim $l] if {[string index $l 0] eq "#" || $l eq ""} { continue } if {[string range $l 0 8] eq "Category:"} { set cat [string range $l 9 end] lappend TIDMap(Lcat) $cat set TIDMap($cat) [list] continue } set Lv [split $l \t] lassign $Lv name id sens lappend TIDMap($cat) $name lappend TIDMap(Ldbs) $name lappend TIDMap(Lids) $id set TIDMap($name,ID) $id set TIDMap($name,sens) $sens } return } proc InitInfoArrays {} { global TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW TDesStatus TDesWeight TDesSense TDesScore TDesScore TDesLength foreach t {TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW} { unset -nocomplain $t array set $t [list] } return } proc InitInfoSeqs {{liste ""}} { global {*}[info globals "TD*"] LNOrdali LNSeqlab set Ltab [info globals "TD*"] if {$liste == {}} { if {[QuelMode] ne "seqlab"} { set liste $LNOrdali } else { set liste $LNSeqlab } } array set Tid [list] foreach n $liste { if {$n eq ""} {continue} foreach t $Ltab { if {! [info exists ${t}($n)]} { if {$t eq "TDesFragment" || $t eq "TDesComplex" || $t eq "TDesTaxId"} { set v 0 } elseif {$t eq "TDesHydro" || $t eq "TDesMolW" || $t eq "TDespI"} { set v 0.0 } elseif {$t eq "TDesAccess" || $t eq "TDesSeqnames" || $t eq "TDesBId"} { set v $n } else { set v "" } set ${t}($n) $v } } if {[set TDesOrganismes($n)] eq ""} { set id [set TDesTaxId($n)] if {[string is integer -strict $id] && $id > 0} { lappend Tid(Lid) $id lappend Tid(Ln) $n } } } if {[array names Tid] != {} } { array set Tres [eSummaryREST taxonomy $Tid(Lid)] foreach id $Tid(Lid) n $Tid(Ln) { if {[info exists Tres($id,ScientificName)]} { set TDesOrganismes($n) [set Tres($id,ScientificName)] } } } update return } proc InitLesDefauts {} { global OrdaliDir OrdTmpDir OrdEtcDir OrdHlpDir OrdLibDir OrdBinDir OuiOuNonToujoursParDefaut GenomeOuCollection if {[info exists env(ORDALITMP)]} { set OrdTmpDir $env(ORDALITMP) } else { if {[info exists env(TEMP)]} { set OrdTmpDir $env(TEMP) } elseif {[info exists env(TMP)]} { set OrdTmpDir $env(TMP) } else { set OrdTmpDir "." } } set OrdHlpDir [file join $OrdaliDir help] set OrdEtcDir [file join $OrdaliDir etc] set OrdBinDir [file join $OrdaliDir bin] set OuiOuNonToujoursParDefaut 0 set GenomeOuCollection "Collection" LesDefauts return } proc InitMasses {} { global TMassesAA set TMassesAA(A) 71.0788 set TMassesAA(R) 156.1875 set TMassesAA(N) 114.1038 set TMassesAA(D) 115.0886 set TMassesAA(C) 103.1388 set TMassesAA(E) 129.1155 set TMassesAA(Q) 128.1307 set TMassesAA(G) 57.0519 set TMassesAA(H) 137.1411 set TMassesAA(I) 113.1594 set TMassesAA(L) 113.1594 set TMassesAA(K) 128.1741 set TMassesAA(M) 131.1926 set TMassesAA(F) 147.1766 set TMassesAA(P) 97.1167 set TMassesAA(S) 87.0782 set TMassesAA(T) 101.1051 set TMassesAA(W) 186.2132 set TMassesAA(Y) 163.1760 set TMassesAA(V) 99.1326 set TMassesAA(U) 150.0388 set TMassesAA(O) 237.3018 set TMassesAA(B) [expr {($TMassesAA(D)+$TMassesAA(N))/2.}] set TMassesAA(Z) [expr {($TMassesAA(E)+$TMassesAA(Q))/2.}] set TMassesAA(J) [expr {($TMassesAA(I)+$TMassesAA(L))/2.}] set TMassesAA(X) 0.0 set TMassesAA(x) 0.0 set TMassesAA(H2O) 18.01524 return } proc InitMatrix {matrix} { global Cbl Mbl array set Cbl [InitPAM35] switch $matrix { "pam15" {array set Mbl [InitPAM15]} "pam35" {array set Mbl [InitPAM35]} "blosum62_p" {array set Mbl [InitClustalMatrix blosum62 1 1.]} "blosum62_n" {array set Mbl [InitClustalMatrix blosum62 0 1.]} } return } proc InitPAM15 {} { set pam "Default scoring matrix used by GAP for the comparison of protein sequences. GAP uses the method of Needleman/Wunsch/Sellers to make alignments. Dayhoff table (Schwartz, R. M. and Dayhoff, M. O. \[1979\] in Atlas of Protein Sequence and Structure, Dayhoff, M. O. Ed, pp. 353-358, National Biomedical Research Foundation, Washington D.C.) rescaled by dividing each value by the sum of its row and column, and normalizing to a mean of 0 and standard deviation of 1.0. The value for FY (Phe-Tyr) = RW = 1.425. Perfect matches are set to 1.5 and no matches on any row are better than perfect matches. Table used by Gribskov and Burgess NAR 14(16) 6745-6763 December 29, 1986 12:46 A B C D E F G H I K L M N P Q R S T V W Y Z .. 1.5 0.2 0.3 0.3 0.3 -0.5 0.7 -0.1 0.0 0.0 -0.1 0.0 0.2 0.5 0.2 -0.3 0.4 0.4 0.2 -0.8 -0.3 0.2 A 1.1 -0.4 1.1 0.7 -0.7 0.6 0.4 -0.2 0.4 -0.5 -0.3 1.1 0.1 0.5 0.1 0.3 0.2 -0.2 -0.7 -0.3 0.6 B 1.5 -0.5 -0.6 -0.1 0.2 -0.1 0.2 -0.6 -0.8 -0.6 -0.3 0.1 -0.6 -0.3 0.7 0.2 0.2 -1.2 1.0 -0.6 C 1.5 1.0 -1.0 0.7 0.4 -0.2 0.3 -0.5 -0.4 0.7 0.1 0.7 0.0 0.2 0.2 -0.2 -1.1 -0.5 0.9 D 1.5 -0.7 0.5 0.4 -0.2 0.3 -0.3 -0.2 0.5 0.1 0.7 0.0 0.2 0.2 -0.2 -1.1 -0.5 1.1 E 1.5 -0.6 -0.1 0.7 -0.7 1.2 0.5 -0.5 -0.7 -0.8 -0.5 -0.3 -0.3 0.2 1.3 1.4 -0.7 F 1.5 -0.2 -0.3 -0.1 -0.5 -0.3 0.4 0.3 0.2 -0.3 0.6 0.4 0.2 -1.0 -0.7 0.3 G 1.5 -0.3 0.1 -0.2 -0.3 0.5 0.2 0.7 0.5 -0.2 -0.1 -0.3 -0.1 0.3 0.5 H 1.5 -0.2 0.8 0.6 -0.3 -0.2 -0.3 -0.3 -0.1 0.2 1.1 -0.5 0.1 -0.2 I 1.5 -0.3 0.2 0.4 0.1 0.4 0.8 0.2 0.2 -0.2 0.1 -0.6 0.4 K 1.5 1.3 -0.4 -0.3 -0.1 -0.4 -0.4 -0.1 0.8 0.5 0.3 -0.2 L 1.5 -0.3 -0.2 0.0 0.2 -0.3 0.0 0.6 -0.3 -0.1 -0.1 M 1.5 0.0 0.4 0.1 0.3 0.2 -0.3 -0.3 -0.1 0.4 N 1.5 0.3 0.3 0.4 0.3 0.1 -0.8 -0.8 0.2 P 1.5 0.4 -0.1 -0.1 -0.2 -0.5 -0.6 1.1 Q 1.5 0.1 -0.1 -0.3 1.4 -0.6 0.2 R 1.5 0.3 -0.1 0.3 -0.4 0.0 S 1.5 0.2 -0.6 -0.3 0.1 T 1.5 -0.8 -0.1 -0.2 V 1.5 1.1 -0.8 W 1.5 -0.6 Y 1.1 Z" set pam [split $pam \n] set header 0 set go 0 foreach l $pam { set l [string trim $l] if {$l eq ""} { continue } if {[string range $l end-1 end] eq "\.\."} { set go 1 set laa [string range $l 0 end-2] regsub -all { +} $laa " " laa set laa [split $laa " "] set i 0 continue } if {! $go} { continue } # lit scores regsub -all { +|\t} $l " " l set l [split $l " "] set a [lindex $laa $i] foreach b [lrange $laa $i end] v [lrange $l 0 end-1] { set mtx($a,$b) $v set mtx($b,$a) $v } incr i } set mtx(laa) [join $laa ""] return [array get mtx] } proc InitPAM35 {} { set pam " Default symbol comparison table used by GAP for the comparison of protein sequences. GAP uses the method of Needleman/Wunsch/Sellers to make alignments. Dayhoff table (Schwartz, R. M. and Dayhoff, M. O. (1979) in Atlas of Protein Sequence and Structure, Dayhoff, M. O. Ed, pp. 353-358, National Biomedical Research Foundation, Washington D.C.) rescaled by dividing each value by the sum of its row and column, and normalizing to a mean of 0 and standard deviation of 1.0. The value for FY (Phe-Tyr) = RW = 1.425. Perfect matches are set to 3.5 and no matches on any row are better than perfect matches. Table used by Gribskov and Burgess NAR 14(16) 6745-6763 December 29, 1986 12:46 A B C D E F G H I K L M N P Q R S T V W Y Z .. 3.5 0.2 0.3 0.3 0.3 -0.5 0.7 -0.1 0.0 0.0 -0.1 0.0 0.2 0.5 0.2 -0.3 0.4 0.4 0.2 -0.8 -0.3 0.2 A 1.1 -0.4 1.1 0.7 -0.7 0.6 0.4 -0.2 0.4 -0.5 -0.3 1.1 0.1 0.5 0.1 0.3 0.2 -0.2 -0.7 -0.3 0.6 B 3.5 -0.5 -0.6 -0.1 0.2 -0.1 0.2 -0.6 -0.8 -0.6 -0.3 0.1 -0.6 -0.3 0.7 0.2 0.2 -1.2 1.0 -0.6 C 3.5 1.0 -1.0 0.7 0.4 -0.2 0.3 -0.5 -0.4 0.7 0.1 0.7 0.0 0.2 0.2 -0.2 -1.1 -0.5 0.9 D 3.5 -0.7 0.5 0.4 -0.2 0.3 -0.3 -0.2 0.5 0.1 0.7 0.0 0.2 0.2 -0.2 -1.1 -0.5 1.1 E 3.5 -0.6 -0.1 0.7 -0.7 1.2 0.5 -0.5 -0.7 -0.8 -0.5 -0.3 -0.3 0.2 1.3 1.4 -0.7 F 3.5 -0.2 -0.3 -0.1 -0.5 -0.3 0.4 0.3 0.2 -0.3 0.6 0.4 0.2 -1.0 -0.7 0.3 G 3.5 -0.3 0.1 -0.2 -0.3 0.5 0.2 0.7 0.5 -0.2 -0.1 -0.3 -0.1 0.3 0.5 H 3.5 -0.2 0.8 0.6 -0.3 -0.2 -0.3 -0.3 -0.1 0.2 1.1 -0.5 0.1 -0.2 I 3.5 -0.3 0.2 0.4 0.1 0.4 0.8 0.2 0.2 -0.2 0.1 -0.6 0.4 K 3.5 1.3 -0.4 -0.3 -0.1 -0.4 -0.4 -0.1 0.8 0.5 0.3 -0.2 L 3.5 -0.3 -0.2 0.0 0.2 -0.3 0.0 0.6 -0.3 -0.1 -0.1 M 3.5 0.0 0.4 0.1 0.3 0.2 -0.3 -0.3 -0.1 0.4 N 3.5 0.3 0.3 0.4 0.3 0.1 -0.8 -0.8 0.2 P 3.5 0.4 -0.1 -0.1 -0.2 -0.5 -0.6 1.1 Q 3.5 0.1 -0.1 -0.3 0.2 -0.6 0.2 R 3.5 0.3 -0.1 0.3 -0.4 0.0 S 3.5 0.2 -0.6 -0.3 0.1 T 3.5 -0.8 -0.1 -0.2 V 3.5 1.1 -0.8 W 3.5 -0.6 Y 1.1 Z " set pam [split $pam \n] set header 0 set go 0 foreach l $pam { set l [string trim $l] if {$l eq ""} { continue } if {[string range $l end-1 end] eq "\.\."} { set go 1 set laa [string range $l 0 end-2] regsub -all { +} $laa " " laa set laa [split $laa " "] set i 0 continue } if {! $go} { continue } # lit scores regsub -all { +|\t} $l " " l set l [split $l " "] set a [lindex $laa $i] foreach b [lrange $laa $i end] v [lrange $l 0 end-1] { set mtx($a,$b) $v set mtx($b,$a) $v } incr i } set mtx(laa) [join $laa ""] return [array get mtx] } proc InitPETMatrix {} { # The 250 PAM PET91 matrix (Jones et al., 1992) # LIT:1814076 PMID:1633570 # Jones, D.T., Taylor, W.R. and Thornton, J.M. # The rapid generation of mutation data matrices from protein sequences # CABIOS 8, 275-282 (1992) # rows = ARNDCQEGHILKMFPSTWYV, cols = ARNDCQEGHILKMFPSTWYV set t " 2. -1.,5. 0.,0.,3. 0.,-1.,2.,5. -1.,-1.,-1.,-3.,11. -1.,2.,0.,1.,-3.,5. -1.,0.,1.,4.,-4.,2.,5. 1.,0.,0.,1.,-1.,-1.,0.,5. -2.,2.,1.,0.,0.,2.,0.,-2.,6. 0.,-3.,-2.,-3.,-2.,-3.,-3.,-3.,-3.,4. -1.,-3.,-3.,-4.,-3.,-2.,-4.,-4.,-2.,2.,5. -1.,4.,1.,0.,-3.,2.,1.,-1.,1.,-3.,-3.,5. -1.,-2.,-2.,-3.,-2.,-2.,-3.,-3.,-2.,3.,3.,-2.,6. -3.,-4.,-3.,-5.,0.,-4.,-5.,-5.,0.,0.,2.,-5.,0.,8. 1.,-1.,-1.,-2.,-2.,0.,-2.,-1.,0.,-2.,0.,-2.,-2.,-3.,6. 1.,-1.,1.,0.,1.,-1.,-1.,1.,-1.,-1.,-2.,-1.,-1.,-2.,1.,2. 2.,-1.,1.,-1.,-1.,-1.,-1.,-1.,-1.,1.,-1.,-1.,0.,-2.,1.,1.,2. -4.,0.,-5.,-5.,1.,-3.,-5.,-2.,-3.,-4.,-2.,-3.,-3.,-1.,-4.,-3.,-4.,15. -3.,-2.,-1.,-2.,2.,-2.,-4.,-4.,4.,-2.,-1.,-3.,-2.,5.,-3.,-1.,-3.,0.,9. 1.,-3.,-2.,-2.,-2.,-3.,-2.,-2.,-3.,4.,2.,-3.,2.,0.,-1.,-1.,0.,-3.,-3.,4. " set lt [split $t "\n"] set aa "ARNDCQEGHILKMFPSTWYV" set laa [split $aa ""] set i 0 foreach a $laa { set l [lindex $lt $i] set l [split $l ,] set j 0 foreach b [lrange $laa 0 $i] { set T($a,$b) [lindex $l $j] set T($b,$a) [lindex $l $j] incrj } incr i } set Lm [array get T] set Lm [AddBJToMatrix $Lm] return $Lm } proc InitPoints {} { global LesPointsDuGroupe LNDG LongueurTotale unset -nocomplain LesPointsDuGroupe set nb [string repeat " " $LongueurTotale] foreach NomDeGroupe $LNDG { set LesPointsDuGroupe($NomDeGroupe) $nb } return } proc InitPop {NbIndiv} { set LesIndividus {} #pour chaque individu de la population for {set i 0} {$i < $NbIndiv} {incr i} { #on cree un individu aleatoire #on l'evalue set LIndividu [CreeIndividu] if {[Appartient $LIndividu $LesIndividus]} {continue} lappend LesIndividus $LIndividu } #on classe les individus de la population dans l'ordre return [LesIndividusClasses $LesIndividus] } proc InitPosRel2Abs {fic Ln} { global PosRA if {[info exists PosRA]} {unset PosRA} foreach n $Ln { set SeqGap [FromMacsims $fic $n "SeqData"] regsub -all -nocase {[^A-Z]} $SeqGap "" Seq set PosRelative 0 set PosAbsolue 0 foreach C [split $SeqGap ""] { incr PosAbsolue if {$C ne "-"} { incr PosRelative #set PosRA($n,Relative,$PosRelative) $PosAbsolue set PosRA($n,Absolue,$PosRelative) $PosAbsolue } #set PosRA($n,Absolue,$PosAbsolue) $PosRelative set PosRA($n,Relative,$PosAbsolue) $PosRelative } } return } proc InitPosSeqGenGenSeq {} { return global Sequences ListePDB db TPGS TPSG if {[info exists TPGS]} { unset TPGS TPSG } lassign [Ccode_InitPosSGGS [array get Sequences]] TPosGS TPosSG foreach {n k v} $TPosGS { set TPGS($n@$k) $v } foreach {n k v} $TPosSG { set TPSG($n@$k) $v } foreach nt $ListePDB { lassign $nt n tmp if {! [info exists Sequences($n)]} {continue} set n [BonNomPDB $n] array unset TPSG "${n}@*" array unset TPGS "${n}@*" set mol [DonneIdDeAccessPDB $n] set chn [DonneChainDeAccessPDB $n] set sp [$mol _resnumber -chain $chn -polymer] set lgg [llength $sp] set sg [set Sequences($n)] set i -1 ; set c -1 ; set v [lindex $sp 0] foreach a [split $sg ""] { incr i if {$a ne "."} { incr c # c could not be greater than $lgg # it may happen if the sp != sg degape if {$c < $lgg} { set v [lindex $sp $c] } else { set v [lindex $sp end] } set TPSG($n@$v) $i } set TPGS($n@$i) $v } set TPSG($n@-1) $lgg set TPGS($n@-1) $lgg } return } proc InitPosSeqGenGenSeq_OLD {} { global Sequences TPosGS TPosSG ListePDB if {[info exists TPosSG]} { unset TPosSG TPosGS } lassign [Ccode_InitPosSGGS [array get Sequences]] TPosGS TPosSG foreach nt $ListePDB { if {! [info exists Sequences($nt)]} {continue} lassign $nt n tmp set n [BonNomPDB $n] set TPosSG [dict remove $TPosSG $n] set TPosGS [dict remove $TPosGS $n] set mol [DonneIdDeAccessPDB $n] set chn [DonneChainDeAccessPDB $n] set sp [$mol _resnumber -chain $chn -polymer] set sg [set Sequences($n)] set lgg [llength $sp] dict set TPosSG $n lgt $lgg dict set TPosGS $n lgt $lgg set i -1 set c -1 set v 0 foreach a [split $sg ""] { incr i if {$a ne "."} { incr c dict set TPosSG $n [set v [lindex $sp $c]] $i } dict set TPosGS $n $i $v } } return foreach {n seq} [array get Sequences] { #set seq [set Sequences($n)] set tmp [string map [list Z "" . ""] $seq] set lg [string length $tmp] dict set TPosSG $n lgt $lg dict set TPosGS $n lgt $lg set c -1 set i -1 foreach a [split $seq ""] { incr i if {$a ne "."} { incr c dict set TPosSG $n $c $i } dict set TPosGS $n $i $c } } return $i } proc InitPremierGroupe {} { global NombreDeGroupes LNDG SDG LNOrdali # already here, do nothing if {[info exists LNDG] && "GroupeToutLeMonde" in $LNDG} { return } set LNDG {} unset -nocomplain SDG set LNDG "GroupeToutLeMonde" foreach Nom $LNOrdali { if {[string trim $Nom] ne ""} { lappend tmp $Nom } } set SDG(GroupeToutLeMonde) $tmp set NombreDeGroupes 1 set NumeroDeGroupe 1 return } proc InitRPCA {} { set lpca "-0.03321226115344578 -0.11387825720514409 -0.22416505603164735 -0.20918526423622633 0.20138722682215107 -0.15137648641007362 -0.14400440513856536 -0.42777360088067506 -0.019577591705696975 0.2532802673970912 0.29919512078613575 -0.2134906880145011 0.09557293424375313 0.3791053228772117 -0.1283964403623 -0.21500354107131917 -0.16441814984544625 0.39728684887162297 0.22747378232324078 0.1911802387338345 0.22805692460681184 -0.0062771564423803 -0.015913385336226146 -0.005792371664023655 0.10264273871909664 -0.03090518610436776 -0.033938370405318136 0.18274445484841986 -0.17578830526813807 0.083108732593751 0.019193250960873705 0.007636490622739857 -0.025374878078663884 -0.16515347581850442 0.08174128951967097 0.12683154820269357 0.030620696769400806 -0.3398491801590555 -0.1789062118645277 0.1153223942977476 -0.009534124621060316 -0.22563399392023 0.027957348993080455 0.04512231840752419 0.34453460416856857 -0.09609904083263208 -0.25661141737339377 0.5360106253844271 -0.14136970178315464 -0.07892902460086294 -0.14428327504767074 -0.18774744259553774 -0.0614222195759302 0.02624689724748815 -0.05150025840387371 0.013382957062699822 0.1293802637083716 0.10336605301238586 0.011297589492219524 0.015831841277580794 " set lpca "-0.2550000000000008 -5.155000000000001 -6.0550000000000015 -5.455000000000002 8.945 -5.155000000000001 -6.355000000000001 -6.655000000000001 -2.3550000000000004 6.645 7.145 -7.5550000000000015 2.044999999999998 10.244999999999997 -3.755000000000001 -5.455000000000002 -3.3550000000000004 10.844999999999999 5.844999999999999 5.844999999999999 2.7570499999999996 -0.3539500000000011 0.35304999999999964 0.48104999999999976 1.5870499999999996 -0.26695000000000135 -0.6899500000000014 4.321049999999999 -2.3729500000000012 0.2650499999999987 -0.7429500000000004 0.11104999999999876 -0.6469500000000004 -2.7079500000000003 1.1250499999999999 1.995049999999999 1.0130499999999998 -4.642950000000001 -2.5829500000000003 0.9990499999999987 -0.10749999999999998 -0.3675 0.1825 0.2025 0.5025 -0.0875 -0.3975 1.1725 -0.1775 -0.3275 -0.4475 -0.2475 -0.15749999999999997 -0.07749999999999999 -0.06749999999999999 0.0825 0.3225 0.14250000000000002 -0.017499999999999988 -0.1275" return $lpca } proc InitResBox {x y n} { set c $::NwOj(Can) set x1 [expr {$x+7}] set y1 [expr {$y-20}] $c create rectangle $x $y1 $x1 $y -fill black -outline black -tags [list BgRes Nbr$n] return } proc InitResidueTypes {} { global OrdEtcDir TResidueType set Ll [LesLignesDuFichier [file join $OrdEtcDir "comp.txt"]] foreach l $Ll { lassign [split $l \t] res type tmp code set TResidueType($res,code1l) $code set type [string trim [string map [list ' "" \" "" - " "] $type]] if {[regexp {LINKING|TERMINUS} $type]} { if {[regexp {PEPTIDE} $type]} { set TResidueType($res,type) "Protein" } elseif {[regexp {RNA|DNA} $type]} { set TResidueType($res,type) "Nucleic" } else { set TResidueType($res,type) "ligand" } } else { set TResidueType($res,type) "ligand" } lappend Lt $type } return } proc InitScoreDeBILD {} { global BILDback BILDweight BILDalpha BILDAlpha package require math set data [DirichletMixtureData] set cmp -1 set weight [list] set Alpha [list] set alpha [list] for {set m 0} {$m < 20} {incr m} { incr cmp lappend weight [lindex $data $cmp] set sAlpha 0.0 set lalpha [list] for {set i 0} {$i < 20} {incr i} { incr cmp set v [lindex $data $cmp] lappend lalpha $v set sAlpha [expr {$sAlpha + $v}] } lappend alpha $lalpha lappend Alpha $sAlpha } set BILDback [list] for {set i 0} {$i < 20} {incr i} { set sBack 0.0 for {set m 0} {$m < 20} {incr m} { set sBack [expr {$sBack + [lindex $weight $m] * [lindex [lindex $alpha $m] $i] / [lindex $Alpha $m]}] } lappend BILDback $sBack } return [list $BILDback $weight $alpha $Alpha] } proc InitSeqsOut {{Etat ""}} { global Defauts SeqsOut LNOrdali LNSeqlab if {$Etat eq ""} {set Etat $Defauts(LockSeqs)} foreach s $LNOrdali { set SeqsOut($s) $Etat } return } proc InitSequences {} { global Defauts LNOrdali LSOrdali Sequences global SeqOri LesNomsDesSeqOri global NombreDeSequences LongueurTotale global OrdEtcDir Warn PBV PBW global LesPCI ListeDesFragments global ListePDB BadPDB NomEtSeqAssPDB set NombreDeSequences [llength $LNOrdali] if {! $NombreDeSequences} { return 0 } DefinitTypeAlignement LesDefauts Mapping [EditorMappingData] if {[set Defauts(RemoveQuery)]} { set iquery [lsearch -regexp -nocase $LNOrdali "query"] if {$iquery != -1} { set Qry [lindex $LNOrdali $iquery] unset Sequences($Qry) set LNOrdali [lreplace $LNOrdali $iquery $iquery] } } # Nettoyage Nom et sequences set ListePDB {} set PBV 0. set PBW "Cleaning Sequences and Names ..." set Ns [llength $LNOrdali] set LiVide [list] set i 0 foreach n $LNOrdali { set s [set Sequences($n)] set s [BonneSequencePourAlignement $s] set Sequences($n) $s set nogap [string map {"." "" " " "" "~" "" "-" ""} $s] if {! [string length $nogap]} { lappend Warn(Vide) $n set Warn($n) 1 lappend LiVide $i } incr i set PBV [expr {$PBV+100./$Ns}] } # Enleve sequences vides foreach i [lsort -integer -decreasing $LiVide] { set s [lindex $LNOrdali $i] set LNOrdali [lreplace $LNOrdali $i $i] unset Sequences($s) } foreach n $LNOrdali { lappend LSOrdali [set Sequences($n)] } lappend LNOrdali {} lappend LSOrdali {} # # Traitement PDB # TraitePDBDeLAlignement # Enleve mauvais PDB if {$BadPDB != {}} { foreach i [lsort -decreasing -integer $BadPDB] { set e [lindex $LNOrdali $i] set Molid [DonneIdDeAccessPDB $e] set Chn [DonneChainDeAccessPDB $e] set newe "bsq${Molid}_$Chn" lset LNOrdali $i $newe set seq [lindex $LSOrdali $i] unset Sequences($e) set Sequences($newe) $seq } } # traite AA bizarres (Seleno Cysteine, B et Z) TraiteAABizarres # Info generales sur alignement set NombreDeSequences [llength $LNOrdali] set Premiere [lindex $LNOrdali 0] set LongueurTotale [string length [set Sequences($Premiere)]] set NPDB [llength $ListePDB] array set SeqOri [array get Sequences] set LesNomsDesSeqOri $LNOrdali # Determine fragments set ListeDesFragments [DetermineLesFragmentsLuc] if {$ListeDesFragments != ""} { MetDesZDansSequencesDeFragments } # sec. str., setups ... des PDB InfosDesPDB # not implemented yet ... AssigneLesPoids CalculeComposition CalculePI CalculeMolecularWeight WarningsDesSeqs return 1 } proc InitSeuils {} { global Mbl Cbl foreach classe {{P A G S T} {I L M V} {D E Q N} {K R H} {F Y W}} { # calcule sum identities set sumId 0.0 foreach aa $classe { set sumId [expr {$sumId + $Cbl($aa,$aa)}] } set seuil 0.0 ; set seuilC 0.0 set nv 0 # i=1 : on tient compte de Mbl(F,F) dans # la moyenne. LE SEUIL EST PLUS HAUT # i=1 : on n'a que les couples croisés set i 1 #set i 0 foreach c1 [lrange $classe 0 end] { foreach c2 [lrange $classe $i end] { set seuil [expr {$seuil + $Mbl($c1,$c2)}] set seuilC [expr {$seuilC + $Cbl($c1,$c2)}] incr nv } incr i } puts "\nClasse : $classe" set nb [llength $classe] puts " [format [string repeat %5s $nb] {*}$classe]" set i 0 set spc " " foreach a1 [lrange $classe 0 end] { set s "$a1 [string repeat $spc $i]" foreach a2 [lrange $classe $i end] { append s [format %5.2f $Cbl($a1,$a2)] } incr i puts $s } puts "seuil ori : $seuilC" #set seuilC [expr {$seuilC + $sumId/[llength $classe]}] #set seuilC [expr {2. * $seuilC}] puts "seuil Id : $seuilC" set seuil [expr {$seuil / $nv}] set seuilC [expr {$seuilC / ($nv - 0)}] puts "seuil fin : $seuilC" foreach c $classe { set Mbl($c,classe) $seuil set Cbl($c,classe) $seuilC } } set Mbl(C,classe) $Mbl(C,C) set Cbl(C,classe) $Cbl(C,C) return } proc InitSolventArea {} { global pKa Surf SA #Residue Volume Surface Area Side Chain pKa set strSA " A 88.6 115. -999. R 173.4 225. ~12 D 111.1 150. 4.5 N 114.1 160. -999. # C a pk entre 9.1 et 9.5 -> 9.3 C 108.5 135. 9.3 E 138.4 190. 4.6 Q 143.8 180. -999. G 60.1 75. -999. H 153.2 195. 6.2 I 166.7 175. -999. L 166.7 170. -999. K 168.6 200. 10.4 M 162.9 185. -999. F 189.9 210. -999. P 112.7 145. -999. S 89.0 115. -999. T 116.1 140. -999. W 227.8 255. -999. Y 193.6 230. 9.7 V 140.0 155. -999. #a-amino pKa = 6.8 - 7.9, a-carboxyl pKa = 3.5 - 4.3 " set LSA [split $strSA \n] foreach l $LSA { set l [string trim $l] if {$l eq ""} {continue} if {[string index $l 0] eq "#"} {continue} set Lv [split $l "\t"] lassign $Lv aa surf area pka set SA($aa) $area set pKa($aa) $pka set Surf($aa) $surf } foreach aa [lsort [array names SA]] { #puts "SA($aa) >$SA($aa)<" } # References if {0} { References Volume: A.A. Zamyatin, Protein Volume in Solution, Prog. Biophys. Mol. Biol. 24(1972)107-123. Accessible surface area (calculated for the residue X in the tripeptide G-X-G) C. Chotia, The Nature of the Accessible and Buried Surfaces in Proteins, J. Mol. Biol., 105(1975)1-14. pKa: C. Tandford, Adv. Protein Chem. 17(1962)69-165. } return } proc InitTBlosum {{mat blosum62} {positive 0}} { global ListeDesAcidesAmines DistBlosum OrdEtcDir # Checked against julie's routine : OK !! array set TBlosum [InitClustalMatrix $mat $positive] #set ListeAA [lrange $ListeDesAcidesAmines 0 end-1] #set ListeAA $ListeDesAcidesAmines set ListeDesAcidesAmines $TBlosum(laa) set ListeAA $TBlosum(laa) set i 1 foreach a [lrange $ListeAA 0 end] { set DistBlosum($a,$a) 0.0 foreach b [lrange $ListeAA $i end] { set d 0. foreach c $ListeAA { set diff [expr {([set TBlosum($a,$c)]-[set TBlosum($b,$c)])/1000.}] set d [expr {$d + $diff*$diff}] } set DistBlosum($a,$b) [expr {sqrt($d)}] set DistBlosum($b,$a) [expr {sqrt($d)}] } incr i } return } proc InitTLog2HTML {} { global DebutBodyHTML Html_ZeroToBody # css de base .... Html_Append [CssBaseOrdalie] set DebutBodyHTML [Html_GetPosition] #Html_Append "

[file rootname [set ::Defauts(Fichier[TypeAli])]]

" Html_Append "

Ordalie Version $::VersionDeOrdali

" Html_Teletype "[DonneDateEtHeure]" Html_Append "

---

" return } proc InitTLog2Text {} { global TextOut if {[TypeAli] ne "pasdali"} { set tf "[file rootname [set ::Defauts(Fichier[TypeAli])]]" } else { set tf "Output" } lappend TextOut $tf lappend TextOut [string repeat "=" [string length $tf]] lappend TextOut "" lappend TextOut "Ordalie Version $::VersionDeOrdali" lappend TextOut "[DonneDateEtHeure]" lappend TextOut "" return } proc InitTaxDB {} { global db TaxRoot TaxDir # db already loaded if {[info exists db] && ([info command $db] ne "")} { return $db } set TaxDir [TaxDir UniProt] set TaxDir "/genomics/link/Common/fiches/TaxUniProt.20140916" set TaxDir "/home/moumou/SoTOL/" #puts "TaxDir $TaxDir" # search the database sqlite file set file sotol.sql set fileDB [file join $TaxDir $file] if {[file exists $fileDB]} { set fdb $fileDB } elseif {[file exists sotol.sql]} { set fdb sotol.sql } package require sqlite3 set db "rootTaxo" sqlite3 $db $fdb set TaxRoot 131567 #set TaxRoot [$db eval {select taxid from taxonomy where Name = "cellular organisms"}] set Lv [lsort -unique [$db eval {select var from sotol}]] #puts "\nLv $Lv\n" global {*}$Lv foreach {var key val} [$db eval {select * from sotol}] { if {$key eq ""} { set $var $val } else { set ${var}($key) $val } } foreach v $Lv { if {[array exists $v]} { #parray $v } else { #puts "$v [set $v]" } } return $db } proc InitTaxoTables {} { global db TaxDir set table " - taxonomy : uniprot { . taxid P . Mnemonic V32 . Name V32 . CommonName V32 . Synonymous V32 . OtherNames V32 . Rank V32 . Lineage T . Parent I . NbChild I . NbChildCum I . isInt I . NbInt I . isGold I . NbGold I . NbKeep I } - gold : gold table { . pk_gold P . taxid I . Goldid V16 . LegalGoldid V16 . Name V64 . NCBIProjectName V128 . NCBIBioProject V128 . ProjectType V128 . SeqStatus V64 . Status V32 . Center V128 . Funding V128 . Contact V128 . Domaine V32 . Kingdom V32 . Phylum V32 . Classe V32 . Ordrr V32 . Family V32 . Genre V32 . Espece V32 . model I } " set fdb [file join $TaxDir sotol.sql] if {[file exists $fdb]} { file delete $fdb } package require sqlite3 set db [FabriqueDeTables $table "" $fdb] return $db } proc InitTkCol {} { global TkCol ListeTkCol set TkCol(alice\ blue) [list 240 248 255] set TkCol(AliceBlue) [list 240 248 255] set TkCol(antique\ white) [list 250 235 215] set TkCol(AntiqueWhite) [list 250 235 215] set TkCol(AntiqueWhite1) [list 255 239 219] set TkCol(AntiqueWhite2) [list 238 223 204] set TkCol(AntiqueWhite3) [list 205 192 176] set TkCol(AntiqueWhite4) [list 139 131 120] set TkCol(aquamarine) [list 127 255 212] set TkCol(aquamarine1) [list 127 255 212] set TkCol(aquamarine2) [list 118 238 198] set TkCol(aquamarine3) [list 102 205 170] set TkCol(aquamarine4) [list 69 139 116] set TkCol(azure) [list 240 255 255] set TkCol(azure1) [list 240 255 255] set TkCol(azure2) [list 224 238 238] set TkCol(azure3) [list 193 205 205] set TkCol(azure4) [list 131 139 139] set TkCol(beige) [list 245 245 220] set TkCol(bisque) [list 255 228 196] set TkCol(bisque1) [list 255 228 196] set TkCol(bisque2) [list 238 213 183] set TkCol(bisque3) [list 205 183 158] set TkCol(bisque4) [list 139 125 107] set TkCol(black) [list 0 0 0] set TkCol(blanched\ almond) [list 255 235 205] set TkCol(BlanchedAlmond) [list 255 235 205] set TkCol(blue) [list 0 0 255] set TkCol(blue\ violet) [list 138 43 226] set TkCol(blue1) [list 0 0 255] set TkCol(blue2) [list 0 0 238] set TkCol(blue3) [list 0 0 205] set TkCol(blue4) [list 0 0 139] set TkCol(BlueViolet) [list 138 43 226] set TkCol(brown) [list 165 42 42] set TkCol(brown1) [list 255 64 64] set TkCol(brown2) [list 238 59 59] set TkCol(brown3) [list 205 51 51] set TkCol(brown4) [list 139 35 35] set TkCol(burlywood) [list 222 184 135] set TkCol(burlywood1) [list 255 211 155] set TkCol(burlywood2) [list 238 197 145] set TkCol(burlywood3) [list 205 170 125] set TkCol(burlywood4) [list 139 115 85] set TkCol(cadet\ blue) [list 95 158 160] set TkCol(CadetBlue) [list 95 158 160] set TkCol(CadetBlue1) [list 152 245 255] set TkCol(CadetBlue2) [list 142 229 238] set TkCol(CadetBlue3) [list 122 197 205] set TkCol(CadetBlue4) [list 83 134 139] set TkCol(chartreuse) [list 127 255 0] set TkCol(chartreuse1) [list 127 255 0] set TkCol(chartreuse2) [list 118 238 0] set TkCol(chartreuse3) [list 102 205 0] set TkCol(chartreuse4) [list 69 139 0] set TkCol(chocolate) [list 210 105 30] set TkCol(chocolate1) [list 255 127 36] set TkCol(chocolate2) [list 238 118 33] set TkCol(chocolate3) [list 205 102 29] set TkCol(chocolate4) [list 139 69 19] set TkCol(coral) [list 255 127 80] set TkCol(coral1) [list 255 114 86] set TkCol(coral2) [list 238 106 80] set TkCol(coral3) [list 205 91 69] set TkCol(coral4) [list 139 62 47] set TkCol(cornflower\ blue) [list 100 149 237] set TkCol(CornflowerBlue) [list 100 149 237] set TkCol(cornsilk) [list 255 248 220] set TkCol(cornsilk1) [list 255 248 220] set TkCol(cornsilk2) [list 238 232 205] set TkCol(cornsilk3) [list 205 200 177] set TkCol(cornsilk4) [list 139 136 120] set TkCol(cyan) [list 0 255 255] set TkCol(cyan1) [list 0 255 255] set TkCol(cyan2) [list 0 238 238] set TkCol(cyan3) [list 0 205 205] set TkCol(cyan4) [list 0 139 139] set TkCol(dark\ blue) [list 0 0 139] set TkCol(dark\ cyan) [list 0 139 139] set TkCol(dark\ goldenrod) [list 184 134 11] set TkCol(dark\ gray) [list 169 169 169] set TkCol(dark\ green) [list 0 100 0] set TkCol(dark\ grey) [list 169 169 169] set TkCol(dark\ khaki) [list 189 183 107] set TkCol(dark\ magenta) [list 139 0 139] set TkCol(dark\ olive\ green) [list 85 107 47] set TkCol(dark\ orange) [list 255 140 0] set TkCol(dark\ orchid) [list 153 50 204] set TkCol(dark\ red) [list 139 0 0] set TkCol(dark\ salmon) [list 233 150 122] set TkCol(dark\ sea\ green) [list 143 188 143] set TkCol(dark\ slate\ blue) [list 72 61 139] set TkCol(dark\ slate\ gray) [list 47 79 79] set TkCol(dark\ slate\ grey) [list 47 79 79] set TkCol(dark\ turquoise) [list 0 206 209] set TkCol(dark\ violet) [list 148 0 211] set TkCol(DarkBlue) [list 0 0 139] set TkCol(DarkCyan) [list 0 139 139] set TkCol(DarkGoldenrod) [list 184 134 11] set TkCol(DarkGoldenrod1) [list 255 185 15] set TkCol(DarkGoldenrod2) [list 238 173 14] set TkCol(DarkGoldenrod3) [list 205 149 12] set TkCol(DarkGoldenrod4) [list 139 101 8] set TkCol(DarkGray) [list 169 169 169] set TkCol(DarkGreen) [list 0 100 0] set TkCol(DarkGrey) [list 169 169 169] set TkCol(DarkKhaki) [list 189 183 107] set TkCol(DarkMagenta) [list 139 0 139] set TkCol(DarkOliveGreen) [list 85 107 47] set TkCol(DarkOliveGreen1) [list 202 255 112] set TkCol(DarkOliveGreen2) [list 188 238 104] set TkCol(DarkOliveGreen3) [list 162 205 90] set TkCol(DarkOliveGreen4) [list 110 139 61] set TkCol(DarkOrange) [list 255 140 0] set TkCol(DarkOrange1) [list 255 127 0] set TkCol(DarkOrange2) [list 238 118 0] set TkCol(DarkOrange3) [list 205 102 0] set TkCol(DarkOrange4) [list 139 69 0] set TkCol(DarkOrchid) [list 153 50 204] set TkCol(DarkOrchid1) [list 191 62 255] set TkCol(DarkOrchid2) [list 178 58 238] set TkCol(DarkOrchid3) [list 154 50 205] set TkCol(DarkOrchid4) [list 104 34 139] set TkCol(DarkRed) [list 139 0 0] set TkCol(DarkSalmon) [list 233 150 122] set TkCol(DarkSeaGreen) [list 143 188 143] set TkCol(DarkSeaGreen1) [list 193 255 193] set TkCol(DarkSeaGreen2) [list 180 238 180] set TkCol(DarkSeaGreen3) [list 155 205 155] set TkCol(DarkSeaGreen4) [list 105 139 105] set TkCol(DarkSlateBlue) [list 72 61 139] set TkCol(DarkSlateGray) [list 47 79 79] set TkCol(DarkSlateGray1) [list 151 255 255] set TkCol(DarkSlateGray2) [list 141 238 238] set TkCol(DarkSlateGray3) [list 121 205 205] set TkCol(DarkSlateGray4) [list 82 139 139] set TkCol(DarkSlateGrey) [list 47 79 79] set TkCol(DarkTurquoise) [list 0 206 209] set TkCol(DarkViolet) [list 148 0 211] set TkCol(deep\ pink) [list 255 20 147] set TkCol(deep\ sky\ blue) [list 0 191 255] set TkCol(DeepPink) [list 255 20 147] set TkCol(DeepPink1) [list 255 20 147] set TkCol(DeepPink2) [list 238 18 137] set TkCol(DeepPink3) [list 205 16 118] set TkCol(DeepPink4) [list 139 10 80] set TkCol(DeepSkyBlue) [list 0 191 255] set TkCol(DeepSkyBlue1) [list 0 191 255] set TkCol(DeepSkyBlue2) [list 0 178 238] set TkCol(DeepSkyBlue3) [list 0 154 205] set TkCol(DeepSkyBlue4) [list 0 104 139] set TkCol(dim\ gray) [list 105 105 105] set TkCol(dim\ grey) [list 105 105 105] set TkCol(DimGray) [list 105 105 105] set TkCol(DimGrey) [list 105 105 105] set TkCol(dodger\ blue) [list 30 144 255] set TkCol(DodgerBlue) [list 30 144 255] set TkCol(DodgerBlue1) [list 30 144 255] set TkCol(DodgerBlue2) [list 28 134 238] set TkCol(DodgerBlue3) [list 24 116 205] set TkCol(DodgerBlue4) [list 16 78 139] set TkCol(firebrick) [list 178 34 34] set TkCol(firebrick1) [list 255 48 48] set TkCol(firebrick2) [list 238 44 44] set TkCol(firebrick3) [list 205 38 38] set TkCol(firebrick4) [list 139 26 26] set TkCol(floral\ white) [list 255 250 240] set TkCol(FloralWhite) [list 255 250 240] set TkCol(forest\ green) [list 34 139 34] set TkCol(ForestGreen) [list 34 139 34] set TkCol(gainsboro) [list 220 220 220] set TkCol(ghost\ white) [list 248 248 255] set TkCol(GhostWhite) [list 248 248 255] set TkCol(gold) [list 255 215 0] set TkCol(gold1) [list 255 215 0] set TkCol(gold2) [list 238 201 0] set TkCol(gold3) [list 205 173 0] set TkCol(gold4) [list 139 117 0] set TkCol(goldenrod) [list 218 165 32] set TkCol(goldenrod1) [list 255 193 37] set TkCol(goldenrod2) [list 238 180 34] set TkCol(goldenrod3) [list 205 155 29] set TkCol(goldenrod4) [list 139 105 20] set TkCol(gray) [list 190 190 190] set TkCol(gray0) [list 0 0 0] set TkCol(gray1) [list 3 3 3] set TkCol(gray2) [list 5 5 5] set TkCol(gray3) [list 8 8 8] set TkCol(gray4) [list 10 10 10] set TkCol(gray5) [list 13 13 13] set TkCol(gray6) [list 15 15 15] set TkCol(gray7) [list 18 18 18] set TkCol(gray8) [list 20 20 20] set TkCol(gray9) [list 23 23 23] set TkCol(gray10) [list 26 26 26] set TkCol(gray11) [list 28 28 28] set TkCol(gray12) [list 31 31 31] set TkCol(gray13) [list 33 33 33] set TkCol(gray14) [list 36 36 36] set TkCol(gray15) [list 38 38 38] set TkCol(gray16) [list 41 41 41] set TkCol(gray17) [list 43 43 43] set TkCol(gray18) [list 46 46 46] set TkCol(gray19) [list 48 48 48] set TkCol(gray20) [list 51 51 51] set TkCol(gray21) [list 54 54 54] set TkCol(gray22) [list 56 56 56] set TkCol(gray23) [list 59 59 59] set TkCol(gray24) [list 61 61 61] set TkCol(gray25) [list 64 64 64] set TkCol(gray26) [list 66 66 66] set TkCol(gray27) [list 69 69 69] set TkCol(gray28) [list 71 71 71] set TkCol(gray29) [list 74 74 74] set TkCol(gray30) [list 77 77 77] set TkCol(gray31) [list 79 79 79] set TkCol(gray32) [list 82 82 82] set TkCol(gray33) [list 84 84 84] set TkCol(gray34) [list 87 87 87] set TkCol(gray35) [list 89 89 89] set TkCol(gray36) [list 92 92 92] set TkCol(gray37) [list 94 94 94] set TkCol(gray38) [list 97 97 97] set TkCol(gray39) [list 99 99 99] set TkCol(gray40) [list 102 102 102] set TkCol(gray41) [list 105 105 105] set TkCol(gray42) [list 107 107 107] set TkCol(gray43) [list 110 110 110] set TkCol(gray44) [list 112 112 112] set TkCol(gray45) [list 115 115 115] set TkCol(gray46) [list 117 117 117] set TkCol(gray47) [list 120 120 120] set TkCol(gray48) [list 122 122 122] set TkCol(gray49) [list 125 125 125] set TkCol(gray50) [list 127 127 127] set TkCol(gray51) [list 130 130 130] set TkCol(gray52) [list 133 133 133] set TkCol(gray53) [list 135 135 135] set TkCol(gray54) [list 138 138 138] set TkCol(gray55) [list 140 140 140] set TkCol(gray56) [list 143 143 143] set TkCol(gray57) [list 145 145 145] set TkCol(gray58) [list 148 148 148] set TkCol(gray59) [list 150 150 150] set TkCol(gray60) [list 153 153 153] set TkCol(gray61) [list 156 156 156] set TkCol(gray62) [list 158 158 158] set TkCol(gray63) [list 161 161 161] set TkCol(gray64) [list 163 163 163] set TkCol(gray65) [list 166 166 166] set TkCol(gray66) [list 168 168 168] set TkCol(gray67) [list 171 171 171] set TkCol(gray68) [list 173 173 173] set TkCol(gray69) [list 176 176 176] set TkCol(gray70) [list 179 179 179] set TkCol(gray71) [list 181 181 181] set TkCol(gray72) [list 184 184 184] set TkCol(gray73) [list 186 186 186] set TkCol(gray74) [list 189 189 189] set TkCol(gray75) [list 191 191 191] set TkCol(gray76) [list 194 194 194] set TkCol(gray77) [list 196 196 196] set TkCol(gray78) [list 199 199 199] set TkCol(gray79) [list 201 201 201] set TkCol(gray80) [list 204 204 204] set TkCol(gray81) [list 207 207 207] set TkCol(gray82) [list 209 209 209] set TkCol(gray83) [list 212 212 212] set TkCol(gray84) [list 214 214 214] set TkCol(gray85) [list 217 217 217] set TkCol(gray86) [list 219 219 219] set TkCol(gray87) [list 222 222 222] set TkCol(gray88) [list 224 224 224] set TkCol(gray89) [list 227 227 227] set TkCol(gray90) [list 229 229 229] set TkCol(gray91) [list 232 232 232] set TkCol(gray92) [list 235 235 235] set TkCol(gray93) [list 237 237 237] set TkCol(gray94) [list 240 240 240] set TkCol(gray95) [list 242 242 242] set TkCol(gray96) [list 245 245 245] set TkCol(gray97) [list 247 247 247] set TkCol(gray98) [list 250 250 250] set TkCol(gray99) [list 252 252 252] set TkCol(gray100) [list 255 255 255] set TkCol(green) [list 0 255 0] set TkCol(green\ yellow) [list 173 255 47] set TkCol(green1) [list 0 255 0] set TkCol(green2) [list 0 238 0] set TkCol(green3) [list 0 205 0] set TkCol(green4) [list 0 139 0] set TkCol(GreenYellow) [list 173 255 47] set TkCol(grey) [list 190 190 190] set TkCol(grey0) [list 0 0 0] set TkCol(grey1) [list 3 3 3] set TkCol(grey2) [list 5 5 5] set TkCol(grey3) [list 8 8 8] set TkCol(grey4) [list 10 10 10] set TkCol(grey5) [list 13 13 13] set TkCol(grey6) [list 15 15 15] set TkCol(grey7) [list 18 18 18] set TkCol(grey8) [list 20 20 20] set TkCol(grey9) [list 23 23 23] set TkCol(grey10) [list 26 26 26] set TkCol(grey11) [list 28 28 28] set TkCol(grey12) [list 31 31 31] set TkCol(grey13) [list 33 33 33] set TkCol(grey14) [list 36 36 36] set TkCol(grey15) [list 38 38 38] set TkCol(grey16) [list 41 41 41] set TkCol(grey17) [list 43 43 43] set TkCol(grey18) [list 46 46 46] set TkCol(grey19) [list 48 48 48] set TkCol(grey20) [list 51 51 51] set TkCol(grey21) [list 54 54 54] set TkCol(grey22) [list 56 56 56] set TkCol(grey23) [list 59 59 59] set TkCol(grey24) [list 61 61 61] set TkCol(grey25) [list 64 64 64] set TkCol(grey26) [list 66 66 66] set TkCol(grey27) [list 69 69 69] set TkCol(grey28) [list 71 71 71] set TkCol(grey29) [list 74 74 74] set TkCol(grey30) [list 77 77 77] set TkCol(grey31) [list 79 79 79] set TkCol(grey32) [list 82 82 82] set TkCol(grey33) [list 84 84 84] set TkCol(grey34) [list 87 87 87] set TkCol(grey35) [list 89 89 89] set TkCol(grey36) [list 92 92 92] set TkCol(grey37) [list 94 94 94] set TkCol(grey38) [list 97 97 97] set TkCol(grey39) [list 99 99 99] set TkCol(grey40) [list 102 102 102] set TkCol(grey41) [list 105 105 105] set TkCol(grey42) [list 107 107 107] set TkCol(grey43) [list 110 110 110] set TkCol(grey44) [list 112 112 112] set TkCol(grey45) [list 115 115 115] set TkCol(grey46) [list 117 117 117] set TkCol(grey47) [list 120 120 120] set TkCol(grey48) [list 122 122 122] set TkCol(grey49) [list 125 125 125] set TkCol(grey50) [list 127 127 127] set TkCol(grey51) [list 130 130 130] set TkCol(grey52) [list 133 133 133] set TkCol(grey53) [list 135 135 135] set TkCol(grey54) [list 138 138 138] set TkCol(grey55) [list 140 140 140] set TkCol(grey56) [list 143 143 143] set TkCol(grey57) [list 145 145 145] set TkCol(grey58) [list 148 148 148] set TkCol(grey59) [list 150 150 150] set TkCol(grey60) [list 153 153 153] set TkCol(grey61) [list 156 156 156] set TkCol(grey62) [list 158 158 158] set TkCol(grey63) [list 161 161 161] set TkCol(grey64) [list 163 163 163] set TkCol(grey65) [list 166 166 166] set TkCol(grey66) [list 168 168 168] set TkCol(grey67) [list 171 171 171] set TkCol(grey68) [list 173 173 173] set TkCol(grey69) [list 176 176 176] set TkCol(grey70) [list 179 179 179] set TkCol(grey71) [list 181 181 181] set TkCol(grey72) [list 184 184 184] set TkCol(grey73) [list 186 186 186] set TkCol(grey74) [list 189 189 189] set TkCol(grey75) [list 191 191 191] set TkCol(grey76) [list 194 194 194] set TkCol(grey77) [list 196 196 196] set TkCol(grey78) [list 199 199 199] set TkCol(grey79) [list 201 201 201] set TkCol(grey80) [list 204 204 204] set TkCol(grey81) [list 207 207 207] set TkCol(grey82) [list 209 209 209] set TkCol(grey83) [list 212 212 212] set TkCol(grey84) [list 214 214 214] set TkCol(grey85) [list 217 217 217] set TkCol(grey86) [list 219 219 219] set TkCol(grey87) [list 222 222 222] set TkCol(grey88) [list 224 224 224] set TkCol(grey89) [list 227 227 227] set TkCol(grey90) [list 229 229 229] set TkCol(grey91) [list 232 232 232] set TkCol(grey92) [list 235 235 235] set TkCol(grey93) [list 237 237 237] set TkCol(grey94) [list 240 240 240] set TkCol(grey95) [list 242 242 242] set TkCol(grey96) [list 245 245 245] set TkCol(grey97) [list 247 247 247] set TkCol(grey98) [list 250 250 250] set TkCol(grey99) [list 252 252 252] set TkCol(grey100) [list 255 255 255] set TkCol(honeydew) [list 240 255 240] set TkCol(honeydew1) [list 240 255 240] set TkCol(honeydew2) [list 224 238 224] set TkCol(honeydew3) [list 193 205 193] set TkCol(honeydew4) [list 131 139 131] set TkCol(hot\ pink) [list 255 105 180] set TkCol(HotPink) [list 255 105 180] set TkCol(HotPink1) [list 255 110 180] set TkCol(HotPink2) [list 238 106 167] set TkCol(HotPink3) [list 205 96 144] set TkCol(HotPink4) [list 139 58 98] set TkCol(indian\ red) [list 205 92 92] set TkCol(IndianRed) [list 205 92 92] set TkCol(IndianRed1) [list 255 106 106] set TkCol(IndianRed2) [list 238 99 99] set TkCol(IndianRed3) [list 205 85 85] set TkCol(IndianRed4) [list 139 58 58] set TkCol(ivory) [list 255 255 240] set TkCol(ivory1) [list 255 255 240] set TkCol(ivory2) [list 238 238 224] set TkCol(ivory3) [list 205 205 193] set TkCol(ivory4) [list 139 139 131] set TkCol(khaki) [list 240 230 140] set TkCol(khaki1) [list 255 246 143] set TkCol(khaki2) [list 238 230 133] set TkCol(khaki3) [list 205 198 115] set TkCol(khaki4) [list 139 134 78] set TkCol(lavender) [list 230 230 250] set TkCol(lavender\ blush) [list 255 240 245] set TkCol(LavenderBlush) [list 255 240 245] set TkCol(LavenderBlush1) [list 255 240 245] set TkCol(LavenderBlush2) [list 238 224 229] set TkCol(LavenderBlush3) [list 205 193 197] set TkCol(LavenderBlush4) [list 139 131 134] set TkCol(lawn\ green) [list 124 252 0] set TkCol(LawnGreen) [list 124 252 0] set TkCol(lemon\ chiffon) [list 255 250 205] set TkCol(LemonChiffon) [list 255 250 205] set TkCol(LemonChiffon1) [list 255 250 205] set TkCol(LemonChiffon2) [list 238 233 191] set TkCol(LemonChiffon3) [list 205 201 165] set TkCol(LemonChiffon4) [list 139 137 112] set TkCol(light\ blue) [list 173 216 230] set TkCol(light\ coral) [list 240 128 128] set TkCol(light\ cyan) [list 224 255 255] set TkCol(light\ goldenrod) [list 238 221 130] set TkCol(light\ goldenrod\ yellow) [list 250 250 210] set TkCol(light\ gray) [list 211 211 211] set TkCol(light\ green) [list 144 238 144] set TkCol(light\ grey) [list 211 211 211] set TkCol(light\ pink) [list 255 182 193] set TkCol(light\ salmon) [list 255 160 122] set TkCol(light\ sea\ green) [list 32 178 170] set TkCol(light\ sky\ blue) [list 135 206 250] set TkCol(light\ slate\ blue) [list 132 112 255] set TkCol(light\ slate\ gray) [list 119 136 153] set TkCol(light\ slate\ grey) [list 119 136 153] set TkCol(light\ steel\ blue) [list 176 196 222] set TkCol(light\ yellow) [list 255 255 224] set TkCol(LightBlue) [list 173 216 230] set TkCol(LightBlue1) [list 191 239 255] set TkCol(LightBlue2) [list 178 223 238] set TkCol(LightBlue3) [list 154 192 205] set TkCol(LightBlue4) [list 104 131 139] set TkCol(LightCoral) [list 240 128 128] set TkCol(LightCyan) [list 224 255 255] set TkCol(LightCyan1) [list 224 255 255] set TkCol(LightCyan2) [list 209 238 238] set TkCol(LightCyan3) [list 180 205 205] set TkCol(LightCyan4) [list 122 139 139] set TkCol(LightGoldenrod) [list 238 221 130] set TkCol(LightGoldenrod1) [list 255 236 139] set TkCol(LightGoldenrod2) [list 238 220 130] set TkCol(LightGoldenrod3) [list 205 190 112] set TkCol(LightGoldenrod4) [list 139 129 76] set TkCol(LightGoldenrodYellow) [list 250 250 210] set TkCol(LightGray) [list 211 211 211] set TkCol(LightGreen) [list 144 238 144] set TkCol(LightGrey) [list 211 211 211] set TkCol(LightPink) [list 255 182 193] set TkCol(LightPink1) [list 255 174 185] set TkCol(LightPink2) [list 238 162 173] set TkCol(LightPink3) [list 205 140 149] set TkCol(LightPink4) [list 139 95 101] set TkCol(LightSalmon) [list 255 160 122] set TkCol(LightSalmon1) [list 255 160 122] set TkCol(LightSalmon2) [list 238 149 114] set TkCol(LightSalmon3) [list 205 129 98] set TkCol(LightSalmon4) [list 139 87 66] set TkCol(LightSeaGreen) [list 32 178 170] set TkCol(LightSkyBlue) [list 135 206 250] set TkCol(LightSkyBlue1) [list 176 226 255] set TkCol(LightSkyBlue2) [list 164 211 238] set TkCol(LightSkyBlue3) [list 141 182 205] set TkCol(LightSkyBlue4) [list 96 123 139] set TkCol(LightSlateBlue) [list 132 112 255] set TkCol(LightSlateGray) [list 119 136 153] set TkCol(LightSlateGrey) [list 119 136 153] set TkCol(LightSteelBlue) [list 176 196 222] set TkCol(LightSteelBlue1) [list 202 225 255] set TkCol(LightSteelBlue2) [list 188 210 238] set TkCol(LightSteelBlue3) [list 162 181 205] set TkCol(LightSteelBlue4) [list 110 123 139] set TkCol(LightYellow) [list 255 255 224] set TkCol(LightYellow1) [list 255 255 224] set TkCol(LightYellow2) [list 238 238 209] set TkCol(LightYellow3) [list 205 205 180] set TkCol(LightYellow4) [list 139 139 122] set TkCol(lime\ green) [list 50 205 50] set TkCol(LimeGreen) [list 50 205 50] set TkCol(linen) [list 250 240 230] set TkCol(magenta) [list 255 0 255] set TkCol(magenta1) [list 255 0 255] set TkCol(magenta2) [list 238 0 238] set TkCol(magenta3) [list 205 0 205] set TkCol(magenta4) [list 139 0 139] set TkCol(maroon) [list 176 48 96] set TkCol(maroon1) [list 255 52 179] set TkCol(maroon2) [list 238 48 167] set TkCol(maroon3) [list 205 41 144] set TkCol(maroon4) [list 139 28 98] set TkCol(medium\ aquamarine) [list 102 205 170] set TkCol(medium\ blue) [list 0 0 205] set TkCol(medium\ orchid) [list 186 85 211] set TkCol(medium\ purple) [list 147 112 219] set TkCol(medium\ sea\ green) [list 60 179 113] set TkCol(medium\ slate\ blue) [list 123 104 238] set TkCol(medium\ spring\ green) [list 0 250 154] set TkCol(medium\ turquoise) [list 72 209 204] set TkCol(medium\ violet\ red) [list 199 21 133] set TkCol(MediumAquamarine) [list 102 205 170] set TkCol(MediumBlue) [list 0 0 205] set TkCol(MediumOrchid) [list 186 85 211] set TkCol(MediumOrchid1) [list 224 102 255] set TkCol(MediumOrchid2) [list 209 95 238] set TkCol(MediumOrchid3) [list 180 82 205] set TkCol(MediumOrchid4) [list 122 55 139] set TkCol(MediumPurple) [list 147 112 219] set TkCol(MediumPurple1) [list 171 130 255] set TkCol(MediumPurple2) [list 159 121 238] set TkCol(MediumPurple3) [list 137 104 205] set TkCol(MediumPurple4) [list 93 71 139] set TkCol(MediumSeaGreen) [list 60 179 113] set TkCol(MediumSlateBlue) [list 123 104 238] set TkCol(MediumSpringGreen) [list 0 250 154] set TkCol(MediumTurquoise) [list 72 209 204] set TkCol(MediumVioletRed) [list 199 21 133] set TkCol(midnight\ blue) [list 25 25 112] set TkCol(MidnightBlue) [list 25 25 112] set TkCol(mint\ cream) [list 245 255 250] set TkCol(MintCream) [list 245 255 250] set TkCol(misty\ rose) [list 255 228 225] set TkCol(MistyRose) [list 255 228 225] set TkCol(MistyRose1) [list 255 228 225] set TkCol(MistyRose2) [list 238 213 210] set TkCol(MistyRose3) [list 205 183 181] set TkCol(MistyRose4) [list 139 125 123] set TkCol(moccasin) [list 255 228 181] set TkCol(navajo\ white) [list 255 222 173] set TkCol(NavajoWhite) [list 255 222 173] set TkCol(NavajoWhite1) [list 255 222 173] set TkCol(NavajoWhite2) [list 238 207 161] set TkCol(NavajoWhite3) [list 205 179 139] set TkCol(NavajoWhite4) [list 139 121 94] set TkCol(navy) [list 0 0 128] set TkCol(navy\ blue) [list 0 0 128] set TkCol(NavyBlue) [list 0 0 128] set TkCol(old\ lace) [list 253 245 230] set TkCol(OldLace) [list 253 245 230] set TkCol(olive\ drab) [list 107 142 35] set TkCol(OliveDrab) [list 107 142 35] set TkCol(OliveDrab1) [list 192 255 62] set TkCol(OliveDrab2) [list 179 238 58] set TkCol(OliveDrab3) [list 154 205 50] set TkCol(OliveDrab4) [list 105 139 34] set TkCol(orange) [list 255 165 0] set TkCol(orange\ red) [list 255 69 0] set TkCol(orange1) [list 255 165 0] set TkCol(orange2) [list 238 154 0] set TkCol(orange3) [list 205 133 0] set TkCol(orange4) [list 139 90 0] set TkCol(OrangeRed) [list 255 69 0] set TkCol(OrangeRed1) [list 255 69 0] set TkCol(OrangeRed2) [list 238 64 0] set TkCol(OrangeRed3) [list 205 55 0] set TkCol(OrangeRed4) [list 139 37 0] set TkCol(orchid) [list 218 112 214] set TkCol(orchid1) [list 255 131 250] set TkCol(orchid2) [list 238 122 233] set TkCol(orchid3) [list 205 105 201] set TkCol(orchid4) [list 139 71 137] set TkCol(pale\ goldenrod) [list 238 232 170] set TkCol(pale\ green) [list 152 251 152] set TkCol(pale\ turquoise) [list 175 238 238] set TkCol(pale\ violet\ red) [list 219 112 147] set TkCol(PaleGoldenrod) [list 238 232 170] set TkCol(PaleGreen) [list 152 251 152] set TkCol(PaleGreen1) [list 154 255 154] set TkCol(PaleGreen2) [list 144 238 144] set TkCol(PaleGreen3) [list 124 205 124] set TkCol(PaleGreen4) [list 84 139 84] set TkCol(PaleTurquoise) [list 175 238 238] set TkCol(PaleTurquoise1) [list 187 255 255] set TkCol(PaleTurquoise2) [list 174 238 238] set TkCol(PaleTurquoise3) [list 150 205 205] set TkCol(PaleTurquoise4) [list 102 139 139] set TkCol(PaleVioletRed) [list 219 112 147] set TkCol(PaleVioletRed1) [list 255 130 171] set TkCol(PaleVioletRed2) [list 238 121 159] set TkCol(PaleVioletRed3) [list 205 104 127] set TkCol(PaleVioletRed4) [list 139 71 93] set TkCol(papaya\ whip) [list 255 239 213] set TkCol(PapayaWhip) [list 255 239 213] set TkCol(peach\ puff) [list 255 218 185] set TkCol(PeachPuff) [list 255 218 185] set TkCol(PeachPuff1) [list 255 218 185] set TkCol(PeachPuff2) [list 238 203 173] set TkCol(PeachPuff3) [list 205 175 149] set TkCol(PeachPuff4) [list 139 119 101] set TkCol(peru) [list 205 133 63] set TkCol(pink) [list 255 192 203] set TkCol(pink1) [list 255 181 197] set TkCol(pink2) [list 238 169 184] set TkCol(pink3) [list 205 145 158] set TkCol(pink4) [list 139 99 108] set TkCol(plum) [list 221 160 221] set TkCol(plum1) [list 255 187 255] set TkCol(plum2) [list 238 174 238] set TkCol(plum3) [list 205 150 205] set TkCol(plum4) [list 139 102 139] set TkCol(powder\ blue) [list 176 224 230] set TkCol(PowderBlue) [list 176 224 230] set TkCol(purple) [list 160 32 240] set TkCol(purple1) [list 155 48 255] set TkCol(purple2) [list 145 44 238] set TkCol(purple3) [list 125 38 205] set TkCol(purple4) [list 85 26 139] set TkCol(red) [list 255 0 0] set TkCol(red1) [list 255 0 0] set TkCol(red2) [list 238 0 0] set TkCol(red3) [list 205 0 0] set TkCol(red4) [list 139 0 0] set TkCol(rosy\ brown) [list 188 143 143] set TkCol(RosyBrown) [list 188 143 143] set TkCol(RosyBrown1) [list 255 193 193] set TkCol(RosyBrown2) [list 238 180 180] set TkCol(RosyBrown3) [list 205 155 155] set TkCol(RosyBrown4) [list 139 105 105] set TkCol(royal\ blue) [list 65 105 225] set TkCol(RoyalBlue) [list 65 105 225] set TkCol(RoyalBlue1) [list 72 118 255] set TkCol(RoyalBlue2) [list 67 110 238] set TkCol(RoyalBlue3) [list 58 95 205] set TkCol(RoyalBlue4) [list 39 64 139] set TkCol(saddle\ brown) [list 139 69 19] set TkCol(SaddleBrown) [list 139 69 19] set TkCol(salmon) [list 250 128 114] set TkCol(salmon1) [list 255 140 105] set TkCol(salmon2) [list 238 130 98] set TkCol(salmon3) [list 205 112 84] set TkCol(salmon4) [list 139 76 57] set TkCol(sandy\ brown) [list 244 164 96] set TkCol(SandyBrown) [list 244 164 96] set TkCol(sea\ green) [list 46 139 87] set TkCol(SeaGreen) [list 46 139 87] set TkCol(SeaGreen1) [list 84 255 159] set TkCol(SeaGreen2) [list 78 238 148] set TkCol(SeaGreen3) [list 67 205 128] set TkCol(SeaGreen4) [list 46 139 87] set TkCol(seashell) [list 255 245 238] set TkCol(seashell1) [list 255 245 238] set TkCol(seashell2) [list 238 229 222] set TkCol(seashell3) [list 205 197 191] set TkCol(seashell4) [list 139 134 130] set TkCol(sienna) [list 160 82 45] set TkCol(sienna1) [list 255 130 71] set TkCol(sienna2) [list 238 121 66] set TkCol(sienna3) [list 205 104 57] set TkCol(sienna4) [list 139 71 38] set TkCol(sky\ blue) [list 135 206 235] set TkCol(SkyBlue) [list 135 206 235] set TkCol(SkyBlue1) [list 135 206 255] set TkCol(SkyBlue2) [list 126 192 238] set TkCol(SkyBlue3) [list 108 166 205] set TkCol(SkyBlue4) [list 74 112 139] set TkCol(slate\ blue) [list 106 90 205] set TkCol(slate\ gray) [list 112 128 144] set TkCol(slate\ grey) [list 112 128 144] set TkCol(SlateBlue) [list 106 90 205] set TkCol(SlateBlue1) [list 131 111 255] set TkCol(SlateBlue2) [list 122 103 238] set TkCol(SlateBlue3) [list 105 89 205] set TkCol(SlateBlue4) [list 71 60 139] set TkCol(SlateGray) [list 112 128 144] set TkCol(SlateGray1) [list 198 226 255] set TkCol(SlateGray2) [list 185 211 238] set TkCol(SlateGray3) [list 159 182 205] set TkCol(SlateGray4) [list 108 123 139] set TkCol(SlateGrey) [list 112 128 144] set TkCol(snow) [list 255 250 250] set TkCol(snow1) [list 255 250 250] set TkCol(snow2) [list 238 233 233] set TkCol(snow3) [list 205 201 201] set TkCol(snow4) [list 139 137 137] set TkCol(spring\ green) [list 0 255 127] set TkCol(SpringGreen) [list 0 255 127] set TkCol(SpringGreen1) [list 0 255 127] set TkCol(SpringGreen2) [list 0 238 118] set TkCol(SpringGreen3) [list 0 205 102] set TkCol(SpringGreen4) [list 0 139 69] set TkCol(steel\ blue) [list 70 130 180] set TkCol(SteelBlue) [list 70 130 180] set TkCol(SteelBlue1) [list 99 184 255] set TkCol(SteelBlue2) [list 92 172 238] set TkCol(SteelBlue3) [list 79 148 205] set TkCol(SteelBlue4) [list 54 100 139] set TkCol(tan) [list 210 180 140] set TkCol(tan1) [list 255 165 79] set TkCol(tan2) [list 238 154 73] set TkCol(tan3) [list 205 133 63] set TkCol(tan4) [list 139 90 43] set TkCol(thistle) [list 216 191 216] set TkCol(thistle1) [list 255 225 255] set TkCol(thistle2) [list 238 210 238] set TkCol(thistle3) [list 205 181 205] set TkCol(thistle4) [list 139 123 139] set TkCol(tomato) [list 255 99 71] set TkCol(tomato1) [list 255 99 71] set TkCol(tomato2) [list 238 92 66] set TkCol(tomato3) [list 205 79 57] set TkCol(tomato4) [list 139 54 38] set TkCol(turquoise) [list 64 224 208] set TkCol(turquoise1) [list 0 245 255] set TkCol(turquoise2) [list 0 229 238] set TkCol(turquoise3) [list 0 197 205] set TkCol(turquoise4) [list 0 134 139] set TkCol(violet) [list 238 130 238] set TkCol(violet\ red) [list 208 32 144] set TkCol(VioletRed) [list 208 32 144] set TkCol(VioletRed1) [list 255 62 150] set TkCol(VioletRed2) [list 238 58 140] set TkCol(VioletRed3) [list 205 50 120] set TkCol(VioletRed4) [list 139 34 82] set TkCol(wheat) [list 245 222 179] set TkCol(wheat1) [list 255 231 186] set TkCol(wheat2) [list 238 216 174] set TkCol(wheat3) [list 205 186 150] set TkCol(wheat4) [list 139 126 102] set TkCol(white) [list 255 255 255] set TkCol(white\ smoke) [list 245 245 245] set TkCol(WhiteSmoke) [list 245 245 245] set TkCol(yellow) [list 255 255 0] set TkCol(yellow\ green) [list 154 205 50] set TkCol(yellow1) [list 255 255 0] set TkCol(yellow2) [list 238 238 0] set TkCol(yellow3) [list 205 205 0] set TkCol(yellow4) [list 139 139 0] set TkCol(YellowGreen) [list 154 205 50] set ListeTkCol [array names TkCol] return $ListeTkCol } proc InitTypeScore {type} { switch $type { "sop" { set body [info body ScoreAgentsPair] } "thompson" { set body { global Wg Sequences TAg Mbl debug Cbl MblNeg set s1 $TAg($a1,$n1,seq) set s2 $TAg($a2,$n2,seq) set Lp {} foreach c1 [split $s1 ""] c2 [split $s2 ""] { lappend Lp "$c1$c2" } set Lv [ScoreDeThompson $Lp 0] set sc 0.0 set i 0 set lg [llength $Lv] foreach v $Lv { set sc [expr {$sc + $Wg($lg,$i) * $v}] incr i } set sc [expr {$sc / $Wg($lg)}] return [list $sc 0.0] } } "bild" { set body { global Wg Sequences TAg Mbl debug Cbl MblNeg set s1 $TAg($a1,$n1,seq) set s2 $TAg($a2,$n2,seq) set Lp {} foreach c1 [split $s1 ""] c2 [split $s2 ""] { lappend Lp "$c1$c2" } set Lv [ScoreDeBILD $Lp 0] set sc 0.0 set i 0 set lg [llength $Lv] foreach v $Lv { set sc [expr {$sc + $Wg($lg,$i) * $v}] incr i } set sc [expr {$sc / $Wg($lg)}] return [list $sc 0.0] } } "norm" { set body { set s1 $::TAg($a1,$n1,seq) set s2 $::TAg($a2,$n2,seq) set score [scoreNormAgents $s1 $s2] return [list $score 0.0] } } } proc ::ScoreMotifAgents {n1 a1 n2 a2} "$body" return } proc InitWLC {lfile} { global CanvasLC global FBOnLC global FBOffLC global MaxX MaxY MinX MinY Max global Delta WinX WinY CentX CentY Radius WinScale global lcol set font -*-Helvetica-Medium-R-Normal--*-140-*-*-*-*-*-* set Max [Maxi $MaxX $MaxY] set Delta 10 set Radius 200 set WinScale [expr {($Radius-2*$Delta)/$Max}] set WinX 400 set WinY 400 set CentX 200 set CentY 200 set w .lulu toplevel $w frame $w.fc grid $w.fc -row 0 -column 0 -sticky news set c $w.fc.c set CanvasLC $c canvas $c -scrollregion "0 0 $WinX $WinY" -width $WinX -height $WinY -relief raise -borderwidth 2 -background black grid $c -row 0 -column 0 -sticky news set x1 $Delta set y1 $Delta set x2 [expr $WinX - $Delta] set y2 [expr $WinY - $Delta] $c create oval $x1 $y1 $x2 $y2 -outline white -width 1 $c create line $CentX $Delta $CentX [expr $WinY-$Delta] -fill white $c create line $Delta $CentY [expr $WinX-$Delta] $CentY -fill white set FBout $w.fbout frame $FBout -bg black grid $FBout -row 0 -column 1 -sticky news button $FBout.exit -text "EXIT" -command "exit" grid $FBout.exit -row 0 -column 0 -sticky ew set cl 1 foreach f $lfile { set col [lindex $lcol [lsearch $lfile $f]] set tf [file rootname $f] button $FBout.b$tf -text " $tf " -bg $col -command [list TraceVecLC $f $col] grid $FBout.b$tf -row $cl -column 0 -sticky ew incr cl } grid columnconfig $w 0 -weight 1 grid rowconfig $w 0 -weight 1 return } proc InitWRegle {} { set Lgt [LongueurDeLAlignement [QuelMode]] set Tirets [string repeat " " [expr {$Lgt + 1}]] set Comptr [string repeat " " [expr {$Lgt + 1}]] set Points [string repeat "." [expr {$Lgt + 1}]] for {set i 1} {$i <= $Lgt} {incr i 10} { if {$i != 1} { set li [string length $i] set Tirets [string replace $Tirets [expr {$i-1}] [expr {$i-1}] "|"] set Comptr [string replace $Comptr [expr {$i-1}] [expr {$i-1+$li-1}] $i] } } set ::TexteWRegle(Points) $Points set ::TexteWRegle(Tirets) $Tirets set ::TexteWRegle(Comptr) $Comptr return } proc InitWebServices {} { package require WS::Client # NCBI service # eUtils services set ret [::WS::Client::GetAndParseWsdl "http://www.ncbi.nlm.nih.gov/entrez/eutils/soap/v2.0/eutils.wsdl"] ::WS::Client::CreateStubs eUtilsService # NCBI service # eFetch services # Only works with refseq or GI accession set ret [::WS::Client::GetAndParseWsdl "http://www.ncbi.nlm.nih.gov/entrez/eutils/soap/v2.0/efetch_seq.wsdl"] ::WS::Client::CreateStubs eFetchSequenceService return } proc InitWg {DoIt} { global Wg MotifLen set len $MotifLen if {! $DoIt} { foreach k {3 5 7 9 11 13 15 17 19 21} { for {set i 0} {$i < $k} {incr i} { set Wg($k,$i) 1.0 } set Wg($k) $k. } } else { # poids gaussiens a 1.0sigme set step [expr {2./($len-1)}] set max [GaussProbability 0.0 0.0 1.0] set sum 0.0 for {set i 0} {$i < $len} {incr i} { set v [expr {-1.0 + $i * $step}] set x [GaussProbability $v 0.0 1.0] set v [expr {$x/$max}] set sum [expr {$sum + $v}] set Wg($len,$i) $v } set Wg($len) $sum if {0} { set Wg(3,0) 0.75 set Wg(3,1) 1.0 set Wg(3,2) 0.75 set Wg(3) 2.5 set Wg(5,0) 0.5 set Wg(5,1) 0.75 set Wg(5,2) 1.0 set Wg(5,3) 0.75 set Wg(5,4) 0.5 set Wg(5) 3.5 set Wg(7,0) 0.3 set Wg(7,1) 0.7 set Wg(7,2) 0.85 set Wg(7,3) 1.0 set Wg(7,4) 0.85 set Wg(7,5) 0.7 set Wg(7,6) 0.3 set Wg(7) 4.7 } } return } proc Init_C_Boot {} { return tcc::reset tcc::ccode { #include #include #include static double SeqMatch(char *seq1, char *seq2, int l) { int r, i; r = 0; for (i=0;i #include #include static double SeqMatch(char *seq1, char *seq2, int l) { int r, i; r = 0; for (i=0;i #include #include #include #include } tcc::ccommand Crand {dummy interp objc objv} { int i, seed, ip, alen; double rd; Tcl_Obj *Lrd; Tcl_GetIntFromObj(interp,objv[1],&alen); Tcl_GetIntFromObj(interp,objv[2],&seed); printf("seed %d\n",seed); fflush(stdout); srand(seed); Lrd = Tcl_NewListObj(0,NULL); for (i=0;i= 62 # A R N D C Q E G H I L K M F P S T W Y V 0.0215 0.0023 0.0178 0.0019 0.0020 0.0141 0.0022 0.0016 0.0037 0.0213 0.0016 0.0004 0.0004 0.0004 0.0119 0.0019 0.0025 0.0015 0.0016 0.0003 0.0073 0.0030 0.0027 0.0022 0.0049 0.0004 0.0035 0.0161 0.0058 0.0017 0.0029 0.0025 0.0008 0.0014 0.0019 0.0378 0.0011 0.0012 0.0014 0.0010 0.0002 0.0010 0.0014 0.0010 0.0093 0.0032 0.0012 0.0010 0.0012 0.0011 0.0009 0.0012 0.0014 0.0006 0.0184 0.0044 0.0024 0.0014 0.0015 0.0016 0.0016 0.0020 0.0021 0.0010 0.0114 0.0371 0.0033 0.0062 0.0024 0.0024 0.0005 0.0031 0.0041 0.0025 0.0012 0.0016 0.0025 0.0161 0.0013 0.0008 0.0005 0.0005 0.0004 0.0007 0.0007 0.0007 0.0004 0.0025 0.0049 0.0009 0.0040 0.0016 0.0009 0.0008 0.0008 0.0005 0.0005 0.0009 0.0012 0.0008 0.0030 0.0054 0.0009 0.0012 0.0183 0.0022 0.0010 0.0009 0.0012 0.0004 0.0008 0.0014 0.0014 0.0005 0.0010 0.0014 0.0016 0.0004 0.0005 0.0191 0.0063 0.0023 0.0031 0.0028 0.0010 0.0019 0.0030 0.0038 0.0011 0.0017 0.0024 0.0031 0.0009 0.0012 0.0017 0.0126 0.0037 0.0018 0.0022 0.0019 0.0009 0.0014 0.0020 0.0022 0.0007 0.0027 0.0033 0.0023 0.0010 0.0012 0.0014 0.0047 0.0125 0.0004 0.0003 0.0002 0.0002 0.0001 0.0002 0.0003 0.0004 0.0002 0.0004 0.0007 0.0003 0.0002 0.0008 0.0001 0.0003 0.0003 0.0065 0.0013 0.0009 0.0007 0.0006 0.0003 0.0007 0.0009 0.0008 0.0015 0.0014 0.0022 0.0010 0.0006 0.0042 0.0005 0.0010 0.0009 0.0009 0.0102 0.0051 0.0016 0.0012 0.0013 0.0014 0.0012 0.0017 0.0018 0.0006 0.0120 0.0095 0.0019 0.0023 0.0026 0.0012 0.0024 0.0036 0.0004 0.0015 0.0196 " set i 0 foreach l [split $blosum62f \n] { set l [string map {"\t" "" "\n" ""} [string trim $l]] if {[string index $l 0] eq "#" || $l eq ""} { continue } regsub -all { +} $l " " l set l [split $l " "] set a [lindex $Laa $i] for {set j 0} {$j <= $i} {incr j} { set b [lindex $Laa $j] set v [lindex $l $j] set M($a,$b) $v set M($b,$a) $v } incr i } set M(laa) $laa return [array get M] } proc InitialiseCouleurs {} { global OrdEtcDir Lookup_Couleurs set frgb [file join $OrdEtcDir "color_rgb.dat"] set fnms [file join $OrdEtcDir "color_names.dat"] set LesRGB [LesLignesDuFichier $frgb] set LesRGB [lrange $LesRGB 1 end] set LesRGB [string trim [join $LesRGB ""]] set LesRGB [split $LesRGB] set LesNms [LesLignesDuFichier $fnms] set LesNms [lrange $LesNms 1 end] set NbV [expr {3*[llength $LesNms]}] foreach {r g b} $LesRGB lacol $LesNms { set lacol [string trim $lacol] set lacolo [CouleurO2Ordali $lacol] set r [expr {int(floor($r * 255))}] set g [expr {int(floor($g * 255))}] set b [expr {int(floor($b * 255))}] set Lookup_Couleurs(${lacolo}) [list $r $g $b] set Lookup_Couleurs(${lacol}) [list $r $g $b] } return } proc InitialiseFenetreOrdali {{behave slave} w} { global Defauts VersionDeOrdali NomFenetreOrdali AExecuter APutser if {[TypeAli] ne "pasdali"} { set file [file tail [set Defauts(Fichier[TypeAli])]] set wtitle "$file - Ordalie Version $VersionDeOrdali" } else { set wtitle "Ordalie Version $VersionDeOrdali" } # pour rR set DialogPorts [DialogPort "GetAll"] if {$DialogPorts ne ""} { append wtitle " Port $DialogPorts" } if {$behave eq "slave"} { catch {destroy $w} set top "${w}_[pid]_[clock scan now]" toplevel $top } else { # master, toplevel is '.' set top . } if {! [info exists NomFenetreOrdali] || $NomFenetreOrdali eq ""} { set NomFenetreOrdali $w } wm title $top $wtitle wm iconname $top "Ordalie" wm maxsize $top [winfo screenwidth $top] [winfo screenheight $top] wm protocol $top WM_DELETE_WINDOW AdieuOrdali grid columnconfig $top 0 -weight 1 grid rowconfig $top 0 -weight 1 wm withdraw $top frame $w grid $w -row 0 -column 0 -sticky news grid rowconfig $w 0 -weight 1 grid columnconfig $w 0 -weight 1 AfficheFenetreOrdali MetAJourWMacs MesCouleurs $w FenetreAuCentre $top wm deiconify $top BindModeNormal if {[Devlpt]} { foreach a [array names Defauts] { set lg [string length $a] set aff "$a [string repeat "." [expr {30-$lg}]] :" AuLog "$aff [set Defauts($a)]" } AuLog "\n" } focus $::NomTextSeq $::NomTextSeq see 1.0 update idletasks return $NomFenetreOrdali } proc InitialisePET91 {} { # Taken from the AAIndex database # set data " # H JOND920103 # D The 250 PAM PET91 matrix (Jones et al., 1992) # R LIT:1814076 PMID:1633570 # A Jones, D.T., Taylor, W.R. and Thornton, J.M. # T The rapid generation of mutation data matrices from protein sequences # J CABIOS 8, 275-282 (1992) # M rows = ARNDCQEGHILKMFPSTWYV, cols = ARNDCQEGHILKMFPSTWYV 2. -1. 5. 0. 0. 3. 0. -1. 2. 5. -1. -1. -1. -3. 11. -1. 2. 0. 1. -3. 5. -1. 0. 1. 4. -4. 2. 5. 1. 0. 0. 1. -1. -1. 0. 5. -2. 2. 1. 0. 0. 2. 0. -2. 6. 0. -3. -2. -3. -2. -3. -3. -3. -3. 4. -1. -3. -3. -4. -3. -2. -4. -4. -2. 2. 5. -1. 4. 1. 0. -3. 2. 1. -1. 1. -3. -3. 5. -1. -2. -2. -3. -2. -2. -3. -3. -2. 3. 3. -2. 6. -3. -4. -3. -5. 0. -4. -5. -5. 0. 0. 2. -5. 0. 8. 1. -1. -1. -2. -2. 0. -2. -1. 0. -2. 0. -2. -2. -3. 6. 1. -1. 1. 0. 1. -1. -1. 1. -1. -1. -2. -1. -1. -2. 1. 2. 2. -1. 1. -1. -1. -1. -1. -1. -1. 1. -1. -1. 0. -2. 1. 1. 2. -4. 0. -5. -5. 1. -3. -5. -2. -3. -4. -2. -3. -3. -1. -4. -3. -4. 15. -3. -2. -1. -2. 2. -2. -4. -4. 4. -2. -1. -3. -2. 5. -3. -1. -3. 0. 9. 1. -3. -2. -2. -2. -3. -2. -2. -3. 4. 2. -3. 2. 0. -1. -1. 0. -3. -3. 4. # // " set Laa ARNDCQEGHILKMFPSTWYV set Lm [split $data \n] set i 0 foreach l $Lm { regsub -all { +} [string trim $l] " " l if {$l ne "" && [string index $l 0] ne "#"} { set Lv [split $l " "] set a [string index $Laa $i] for {set j 0} {$j <= $i} {incr j} { set b [string index $Laa $j] set v [lindex $Lv $j] set M($a,$b) $v set M($b,$a) $v } incr i } } return [array get M] } proc InitialiseRPCA {} { global TRPCA set Lv [split [InitRPCA] \n] lassign $Lv lx ly lz set Laa [split "ARNDCQEGHILKMFPSTWYV" ""] foreach a $Laa x [split $lx] y [split $ly] z [split $lz] { set x [expr {10.*$x}] set y [expr {10.*$y}] set z [expr {10.*$z}] set TRPCA($a) [list $x $y $z] set TRPCA(Norm$a) [S_nV [set TRPCA($a)]] } return } proc InitialiseRasMol {Canal} { global RecuperationEffectuee global tcl_platform global LiaisonCoupee set LiaisonCoupee 0 set Patientons 30 set IlEstLa 0 if {$tcl_platform(platform) != "windows"} { while {[incr Patientons -1]} { set LesInterps [winfo interps] if {[regexp "rasmol" [join $LesInterps "\n"]]} { set IlEstLa 1 break } after 2000 } if { ! $IlEstLa} { FaireLire "Can't connect to RasMol\nCanceled" return } } after 1000 update return } proc InitialiseRosace {} { global OrdEtcDir Rosace set LRos [IniRosace] set i 1 foreach l $LRos { lassign [split $l ","] v a if {$i <= 20} { set RosX($a) $v } else { set RosY($a) $v } incr i } foreach a [array names RosX] { set x [set RosX($a)] set y [set RosY($a)] set Rosace($a) [list $x $y] set Rosace(Norm$a) [S_nV [set Rosace($a)]] } return } proc InitialiseUnArbre {tree} { global Abr LNOrdali subangleMax Xmin Xmax Ymin Ymax Defauts set AId [DecortiqueUnArbre $tree] set Abr($AId,TypeTree) [set Defauts(TypeTree)] set Abr($AId,TAff) "Accession" set A [set Abr(Arbre,$AId)] # Init fonte et parametres par defauts if {"TreeFont$AId" ni [font names]} { font create "TreeFontBoot$AId" -family Helvetica -size [set Defauts(FontSizeTreeBoot)] -weight [set Defauts(FontWghtTree)] font create "TreeFont$AId" -family Helvetica -size [set Defauts(FontSizeTree)] -weight [set Defauts(FontWghtTree)] } set Abr($AId,PADWdt) [set Defauts(CanvasWTree)] set Abr($AId,PADHgt) [set Defauts(CanvasHTree)] set Abr($AId,FWidth) [set Defauts(FWidthTree)] set Abr($AId,FHeight) [set Defauts(FHeightTree)] set Abr($AId,FontSize) [set Defauts(FontSizeTree)] set Abr($AId,FontWght) [set Defauts(FontWghtTree)] set Abr($AId,NfoisX) 1. set Abr($AId,NfoisY) 1.2 set Abr($AId,ScaleR) 1. set Abr($AId,Rotate) 0. set Abr($AId,OffsetX) 5 set Abr($AId,OffsetY) [expr {int([set Abr($AId,NfoisY)]*[lindex [font metrics "TreeFont$AId"] 5])}] set Increment 50. set Abr($AId,Increment) $Increment if {[TypeAli] in [list "XML" "ORD"]} { set Abr(TypeAff) [list "Seq Name" "Accession" "BankId" "Organism" "Description" "Acc + BankId" "Acc + Orga" "Acc + Desc" "Orga + Desc"] } else { set Abr(TypeAff) "Accession" } set Abr($AId,Tag) 0 set Abr($AId,BootShow) 0 set Abr($AId,LSeq) [$A leaves] set Abr($AId,LSeqOri) [$A leaves] if {[llength [SequencesSelectionnees]] == 1} { set Abr($AId,LeafSel) [SequencesSelectionnees] } else { set Abr($AId,LeafSel) [lindex [set Abr($AId,LSeq)] 0] } # Initialisation Dessin Tree2Coordonnees $AId DataDeLArbre $AId AjusteCoordonneesInit $AId return $AId } proc InitialiseVMD {} { global ListeTypesDeFeatures global OrdLibDir VMDsend "CliVMDInit $OrdLibDir" if {[info exists ListeTypesDeFeatures]} { VMDsend "NouvelleFeatures $ListeTypesDeFeatures" } LookupCouleursVMD trace add variable ListeTypeDeFeatures write UpdateVMDFeatures return } proc InitialiseVolPol {} { global VolPol set lvp [split [IniVolPol] \n] foreach l $lvp { lassign $l n v p set VolPol($n) [list $v $p] set VolPol(Norm$n) [S_nV [set VolPol($n)]] } return } proc InitialiseVrp {} { global OrdEtcDir lastX lastY env Vrp set lastX 0 set lastY 0 set Vrp(gap) "-" set Vrp(CmX) 0 set Vrp(CmY) 0 set Vrp(MinX) 0 set Vrp(MaxX) 0 set Vrp(MinY) 0 set Vrp(MaxY) 0 set Vrp(SzX) 0 set Vrp(SzY) 0 set Vrp(ScaleOrig) 10.0 set Vrp(Nb) {} set Vrp(AA1) {} set Vrp(X) {} set Vrp(Y) {} set Vrp(SS) {} set Vrp(Sz) 0 #Graphic settings #set Vrp(font) {Helvetica 12 normal} set Vrp(fontFamily) Helvetica set Vrp(fontSize) 10 set Vrp(fontStyle) normal set Vrp(font) "$Vrp(fontFamily) $Vrp(fontSize) $Vrp(fontStyle)" set Vrp(style1) normal set Vrp(styleItalic) 0 set Vrp(styleRoman) 0 set Vrp(styleUnderline) 0 set Vrp(Scale) 1.0 set Vrp(CX) 0.0 set Vrp(CY) 0.0 set Vrp(TrX) 0.0 set Vrp(TrY) 0.0 set Vrp(Border) 10.0 set Vrp(File) "test.fle" set Vrp(fileType) fle set Vrp(Height) 400 set Vrp(Width) 700 set Vrp(DotSz) [expr {$Vrp(ScaleOrig)/4.0}] set Vrp(oldTag) "" set Vrp(oldTag1) "" set Vrp(oldTag2) "" set Vrp(showChar) red set Vrp(oldChar) lightblue set Vrp(BegRes) 0 set Vrp(EndRes) 0 set Vrp(colLabel) red set Vrp(colDot) SkyBlue2 set Vrp(cursor) [. cget -cursor] set Vrp(busyCursor) watch set VrpC(NbAA) 0 set VrpC(HydX,A) 0.0 set VrpC(HydY,A) 0.0 # landscape orientation set Vrp(printOrient) true set Vrp(seqSel) 0 set Vrp(DataAA) [file join $OrdEtcDir "rosace.txt"] set Vrp(Overwrite) 0 return } proc InsCommun {} { set FichierSqlCommun "[RepertoireDuGenome]/InsCommuns.sql" foreach Nom [ListeDesPABs] { set FichierSql [GscopeFile $Nom "macsimSql"] if {[FileAbsent $FichierSql]} { continue } lappend LeCommun [ContenuDuFichier $FichierSql] } return [SauveLesLignes $LeCommun dans $FichierSqlCommun] } proc InsereGenomicsLink {{Login ""} {OverWrite ""}} { #rR si Login finit par .tcl c'est un fichier if {[string equal -nocase $Login "OverWrite"]} { set Login ""; set OverWrite "OverWrite" } set OverWrite [string equal -nocase $OverWrite "OverWrite"] if { ! $OverWrite } { FaireLire "Now you'll change nothing. \n To OverWrite use InsereGenomicsLink Login OverWrite" } else { if { ! [OuiOuNon "I'll overwrite what I'm allowed to do. OK?"] } { exit } } set PourUnFichierPrecis 0 set LesSources [LesSourcesDeGscope] if {[regexp "\.tcl$" $Login]} { set LesSources [list $Login] set Login "" set PourUnFichierPrecis 1 } set LesMAJ {} foreach F $LesSources { if { ! [regexp ".tcl$" $F]} { continue } if {$Login!="" && ! [regexp "/$Login/" $F]} { continue } if { ! $PourUnFichierPrecis } { set F "[HomeRipp]/gscope/$F" } set LeNew {} set OK 1 foreach Ligne [LesLignesDuFichier $F] { if { ! [regexp {/genomics/g[0-9]+/} $Ligne]} { lappend LeNew $Ligne; continue } set OK 0 regsub -all {/genomics/g[0-9]+/} $Ligne "/genomics/link/" New lappend LeNew $New Espionne $Ligne Espionne $New lappend LesLignesG $Ligne $New } if {$OK} { continue } Espionne $F if { ! [file writable $F]} { FaireLire "Je ne peux pas modifier $F" continue } if {$OverWrite} { lappend LesMAJ [SauveLesLignes $LeNew dans $F] } } AfficheListe $LesMAJ set LesMAJ2 {} foreach F $LesSources { if { ! [regexp ".tcl$" $F]} { continue } if {$Login!="" && ! [regexp "/$Login/" $F]} { continue } if { ! $PourUnFichierPrecis } { set F "[HomeRipp]/gscope/$F" } set LeNew {} set OK 1 foreach Ligne [LesLignesDuFichier $F] { if { ! [regexp {/genomics/} $Ligne]} { lappend LeNew $Ligne; continue } if { [regexp {/genomics/link/} $Ligne]} { lappend LeNew $Ligne; continue } if { [regexp {/genomics/g[^/]+/} $Ligne]} { lappend LeNew $Ligne; continue } set OK 0 regsub -all {/genomics/} $Ligne "/genomics/link/" New lappend LeNew $New Espionne $Ligne Espionne $New lappend LesLignesG $Ligne $New } if {$OK} { continue } Espionne $F if { ! [file writable $F]} { FaireLire "Je ne peux pas modifier $F" continue } if {$OverWrite} { lappend LesMAJ2 [SauveLesLignes $LeNew dans $F] } } AfficheListe $LesMAJ2 } proc InsereHrefAccessDans {Ligne BanqueId {Access ""}} { set ET "EtCoMeRcIaL" set Ref "[WscopeScience] $ET AfficheMoi $ET SequenceDesBanques $ET $BanqueId $ET $Access" set HRef [H_Href $Access $Ref] regsub -all {\:} $Access "\\:" AA regsub $AA $Ligne $HRef LigneAvecRef regsub -all " $ET " $LigneAvecRef {\&} LigneAvecRef return $LigneAvecRef } proc InsereHrefSeqcheckOligoDans {Ligne S P {PGS ""}} { set LigneAvecRef $Ligne set ET "EtCoMeRcIaL" if {$P!=""} { set Ref "[WscopeScience] $ET ShowOli $ET P1456" set HRef [H_Href $P $Ref] regsub " $P " $LigneAvecRef " $HRef " LigneAvecRef } set LesFicSeq [LocaliseLesTfasDuSeqCheck $S] set LesNouvellesLignesAvecRef {} foreach FicSeq $LesFicSeq { set DirSeq [file dirname $FicSeq] set Qui [file tail $FicSeq] regsub "[RepertoireDuGenome]/" $DirSeq "" Quoi set Ref "[WscopeScience] $ET FileMoi $ET $Quoi $ET $Qui" set HRef [H_Href $S $Ref] regsub " $S " $LigneAvecRef " $HRef " NouvelleLigneAvecRef lappend LesNouvellesLignesAvecRef $NouvelleLigneAvecRef } if {$LesNouvellesLignesAvecRef!={}} { set LigneAvecRef [join $LesNouvellesLignesAvecRef "\n"] } regsub -all " $ET " $LigneAvecRef {\&} LigneAvecRef return $LigneAvecRef } proc InsereNouvelleSequence {n s} { global {*}[info globals "TD*"] db TabSF set ins "NULL" foreach t {TDesSeqnames TDesAccess TDesBId TDesDescriptifs TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesPhylum TDesGO TDuLineage TDesHydro TDespI TDesMolW} { set v [set ${t}($n)] if {! [string is integer -strict $v] && ! [string is double -strict $v]} { if {$v eq ""} { lappend ins "NULL" } else { set v [string map [list "'" "''"] $v] lappend ins "'$v'" } } else { lappend ins $v } } set sdegap [string map {" " "" "." ""} $s] lappend ins "'$sdegap'" $db eval "insert into seqinfo values ([join $ins ,])" set pki [$db last_insert_rowid] set sqn [set TDesSeqnames($n)] $db eval {insert into seqali values (NULL, $pki, $sqn, $s)} return } proc Inseredata {Table FichierCsv LesTetes} { set Commande "copy $Table ($LesTetes) FROM '$FichierCsv' DELIMITER AS ';' CSV;" Espionne "$Commande" return [GxDbSqlExec $Commande] } proc InseredataOld {Table FichierCsv LesTetes} { set Commande "copy $Table ($LesTetes) FROM '$FichierCsv' DELIMITER AS ';' CSV;" CanalSqlGxDb SqlExec $Commande CanalSqlDisconnect } proc InsertionSequencesAPosition {Lnoms Lseqs Lnadd Lsadd iInsert} { # insertion after a given seq if {$iInsert eq "end"} { # find index of last non-empty element set i [expr {[llength $Lnoms] - 1}] set nom [string trim [lindex $Lnoms $i]] while {$nom eq ""} { incr i -1 set nom [string trim [lindex $Lnoms $i]] } } incr i foreach n $Lnadd s $Lsadd { set Lnoms [linsert $Lnoms $i $n] set Lseqs [linsert $Lseqs $i $s] incr i } return [list $Lnoms $Lseqs] } proc InsertionSequencesDansGroupes {LNAli LSAli LNAdd LSAdd} { global SDG LNDG # no groups, return if {[llength $LNDG] == 1} { foreach seq $Lseq { set GroupeDeLaSequence($seq) "GroupeToutLeMonde" lappend SDG(GroupeToutLeMonde) $seq } return } foreach n $LNAli s $LSAli { if {$n ne ""} { lappend Lns $n $s } } foreach n $LNAdd s $LSAdd { lappend Lns $n $s } puts [join $Lns \n] array set TPCI [CalculeLesPCIGenerique $Lns] DefineGroupForNewSeq $LNAdd TPCI # rebuild seq list if {[llength [lsearch -regexp -all $LNDG {^Group}]] > 1} { set Lg [lrange $LNDG 1 end] } else { set Lg $LNDG } set Ln [list] ; set Ls [list] foreach g $Lg { if {! [regexp {^Group} $g]} {continue} lappend Ln {} lappend Ls {} foreach nm [set SDG($g)] { set i [lsearch -exact $Lns $nm] set sq [lindex $Lns $i+1] lappend Ls $sq lappend Ln $nm } lappend Ln {} lappend Ls {} } return [list $Ln $Ls] } proc InsideCSTB {} { global InsideCSTB global OutsideCSTB if {[info exists InsideCSTB]} { return $InsideCSTB } set HostEna "" catch {set HostEna [exec host ena]} set InsideCSTB [regexp "192.168.10.130" $HostEna] set OutsideCSTB [expr ! $InsideCSTB] return $InsideCSTB } proc InspecteListe {l {indent 0}} { if {$indent == 5 || ! [string is list -strict $l] || ! [regexp " " $l]} { puts "[string repeat $indent $indent] $l" return } incr indent foreach elt $l { InspecteListe $elt $indent } } proc InstallEnv {{p ""}} { global OrdaliDir tcl_platform env if {$p eq ""} { package require platform set p [::platform::generic] } if {$tcl_platform(platform) eq "windows"} { set odir [file join o:/ ordali] } else { set odir $env(ORDALIDIR) } switch $p { "Linux-x86" - "linux-ix86" { set rep "Linux-x86" set pre lib set suf ".so" } "Linux-x86_64" - "linux-x86_64" { set rep "Linux-x86_64" set pre lib set suf ".so" } "Windows" - "win32-ix86" { set rep Windows set pre "" set suf ".dll" } "Mac" - "macosx-ix86" { set rep MacOSX set pre "lib" set suf ".dylib" } } # first make it clean puts "cleaning ..." set home [pwd] cd [file join $OrdaliDir lib] foreach d [glob -nocomplain -type d *] { file delete -force -- $d } cd $home file delete -force [file join $OrdaliDir lib] puts "copying pure-tcl packages ..." file copy -force [file join $OrdaliDir Extensions AllPlatform] [file join $OrdaliDir lib] puts "copying platform specific packages ..." foreach pkg {"tclcluspack0.1" "tclfastme0.1" "tsurf0.1" "biotext0.1" "tclordalie0.1"} { set libin [file join $odir Extensions $pkg $rep "${pre}${pkg}$suf"] set pkgin [file join $odir Extensions $pkg $rep pkgIndex.tcl] set libout [file join $odir lib $pkg "${pre}${pkg}$suf"] set pkgout [file join $odir lib $pkg pkgIndex.tcl] # create dir file mkdir [file join $OrdaliDir lib $pkg] file copy -force $libin $libout file copy -force $pkgin $pkgout if {$pkg eq "biotext0.1"} { file copy -force [file join $odir Extensions $pkg biotext.tcl] [file join $odir lib $pkg] } } # Tcl/Tk platform specific extensions # tcl3d file copy -force [file join $odir Extensions $rep tcl3d-0.4.1 tcl3d0.4.1] [file join $odir lib] file copy -force [file join $odir Extensions $rep tcl3d-0.4.1 extlibs] [file join $odir lib] # sqlite3 file copy -force [file join $odir Extensions $rep sqlite3] [file join $odir lib] # tdom file copy -force [file join $odir Extensions $rep tdom-0.8.3] [file join $odir lib] puts "\ndone !\n" exit } proc InteRosace {Type {K ""}} { global RosaceCourante global LesInteRosacesPossibles global LesInteRosaces if {$K==""} { if { ! [info exists RosaceCourante]} { RscopeBoard $CurrentGenome } set K $RosaceCourante } if {$Type=="Which"} { if { ! [info exists $LesInteRosaces($K)] || [llength $LesInteRosaces($K)]==0} { FaireLire "No Interior Wheel" } else { FaireLire "[join $LesInteRosaces($K) "\n"]" } return "" } if {$Type=="New"} { AiguilleLaListe {} $K "UneListe" } if { ! [info exists LesInteRosacesPossibles]} { foreach Procedure [info procs] { if {[regexp "^RosaceDe" $Procedure]} { lappend LesInteRosacesPossibles $Procedure } } } set InteRo [ChoixParmi [concat $LesInteRosacesPossibles "Erase_all"]] if {$InteRo==""} { return "" } if {$InteRo=="Erase_all"} { AiguilleLaListe {} $K "UneListe" ; return "" } lappend LesInteRosaces($K) $InteRo $InteRo $K } proc IntegerApres {Champ dans Texte} { return [ValeurApres $Champ dans $Texte "%d"] } proc IntegerEnFin {de Texte} { return [ValeurEnFin de $Texte "%d"] } proc IntegerToAscii {I} { set Ascii [format "%c" $I] return $Ascii } proc IntegerToRGB {Couleur} { binary scan [binary format "i*" $Couleur] "c1c1c1c1" b g r v set r [expr ( $r + 0x100 ) % 0x100] set g [expr ( $g + 0x100 ) % 0x100] set b [expr ( $b + 0x100 ) % 0x100] return "$r $g $b" } proc IntegralToMb {FichierGO} { foreach Nom [ListeDesPABs] { set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO] if {$LesGO!=""} { foreach GO $LesGO { #Espionne "$Nom $GO" if {$GO=="GO:0016021"} {Espionne $Nom} } } } } proc InterGene {} { # Détermine le nombre de SBS dans les intergènes # Déclaration des fichiers set FichierDesProximites [open "/tmp/Conservation/MappingTotal.txt" "r"] set FichierLog "/tmp/Conservation/Intergenes.txt" # Suppressions des éventuelles versions précédentes des fichiers if { [file exists $FichierLog] } { file delete $FichierLog } # Compteurs : set CompteurIntergenes 0 set CompteurAval 0 set CompteurAmont 0 set CompteurAvalValide 0 set CompteurAmontValide 0 while { [gets $FichierDesProximites LigneMapping] >=0 } { set ExonOuIntron "" ScanLaListe $LigneMapping ID ChromosomeH StartH EndH Acc DebSBS FinSBS OrientationSBS DistanceAuTSS ExonOuIntron CdsOuPas UtrOuPas OccupationExonOuIntron if { $ExonOuIntron == "" } { incr CompteurIntergenes if { $DistanceAuTSS < 0 } { incr CompteurAmont if { $DistanceAuTSS > -20000 } { incr CompteurAmontValide } } else { incr CompteurAval if { $DistanceAuTSS < 20000 } { incr CompteurAvalValide } } } } AppendAuFichier $FichierLog "=====================================" AppendAuFichier $FichierLog " Statistiques du traitement InterStaf " AppendAuFichier $FichierLog "=====================================" AppendAuFichier $FichierLog " " AppendAuFichier $FichierLog "* Dans un Intergenes: $CompteurIntergenes" AppendAuFichier $FichierLog "* En 'amont' d'un gène : $CompteurAmont ($CompteurAmontValide à moins de 20kb)" AppendAuFichier $FichierLog "* En 'aval' d'un gène : $CompteurAval ($CompteurAvalValide à moins de 20kb)" } proc InteractantDes90 {} { set LesTar {}; set premierefois 1 set Fichier "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/9606.string" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^PID" $Ligne]} { continue } set LesMots [split $Ligne "\t"] set Sou [lindex $LesMots 1] set Tar [lindex $LesMots 3] if {$premierefois} { lappend LesTar $Tar set SouPrecedent $Sou set premierefois 0 continue } if {$SouPrecedent == $Sou} { lappend LesTar $Tar } else { set Targets [join $LesTar " | "] set LigneResult "$SouPrecedent;$Targets" lappend LesLignesResult $LigneResult set LesTar {} lappend LesTar $Tar } set SouPrecedent $Sou } set Targets [join $LesTar " | "] set LigneResult "$SouPrecedent;$Targets" lappend LesLignesResult $LigneResult SauveLesLignes $LesLignesResult dans "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/TousInteractantDes90" } proc InteractantDes90PourCytoscape {} { #attention voir interet de ce fichier set Fichier1 "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/9606-QueInitial.string" set Fichier2 "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/9606.string" foreach Ligne [LesLignesDuFichier $Fichier1] { if {[regexp "^PID" $Ligne]} { continue } set LesMots [split $Ligne "\t"] set GnInitial1 [lindex $LesMots 1] lappend LesGnInitial1 $GnInitial1 } set LesGnInitial1 [ListeSansDoublon $LesGnInitial1] foreach Ligne [LesLignesDuFichier $Fichier2] { set trouve 0 if {[regexp "^PID" $Ligne]} { continue } set LesMots [split $Ligne "\t"] set GnInitial2 [lindex $LesMots 1] foreach Gn1 $LesGnInitial1 { if {$GnInitial2==$Gn1} { set trouve 1 lappend LesLignesResult $Ligne break } } if {!$trouve} {Espionne "$GnInitial2 trouve pas"} } #SauveLesLignes $LesLignesResult dans "/genomics/link/Tau/GSTRdCVF/BlastpSurStringHomme/9606-AcTousInteractants.string" } proc InteractionPfamComplet {{repertoire ""}} { #il me faut la liste des pfams tous court.... pour faire la requete... CanalSqlDomine set listeDesPfams [ListePfamComplex] set Domain2 {} foreach pfam $listeDesPfams { if {$pfam != ""} { set idpfam [split $pfam "-"] if {[info exists PfamProt([lindex $idpfam 0])]} { #Espionne "PfamProt([lindex $idpfam 0]) existe ---> $PfamProt([lindex $idpfam 0])" set listeProt [split $PfamProt([lindex $idpfam 0]) "|"] set Vue 0; foreach prot $listeProt { #Espionne "$prot == [lindex $idpfam 1]" if {$prot==[lindex $idpfam 1]} { set Vue 1; } } if {$Vue==0} { #Espionne "dans vue 0" set pfamC $PfamProt([lindex $idpfam 0]) #Espionne "Avant: $pfamC" append pfamC "|[lindex $idpfam 1]" #Espionne "Apres: $pfamC" #Espionne "ajouter: [lindex $idpfam 0] -----> $PfamProt([lindex $idpfam 0])" set PfamProt([lindex $idpfam 0]) $pfamC #Espionne "ajouter: [lindex $idpfam 0] -----> $PfamProt([lindex $idpfam 0])" } } else { set PfamProt([lindex $idpfam 0]) "[lindex $idpfam 1]" #Espionne "[lindex $idpfam 0] ###### $PfamProt([lindex $idpfam 0])" } #Espionne "###### $PfamProt([lindex $idpfam 0])" #Espionne "[lindex $idpfam 0] ------- $PfamProt([lindex $idpfam 0])" if {$Domain2==""} { append Domain2 "'[lindex $idpfam 0]'" } else { append Domain2 ",'[lindex $idpfam 0]'" } } } #Espionne "Domaine2:" #Espionne "$Domain2" #faire la liste des pabs... set Resultat [array size 24] set Liste [ListeDesPABs] foreach pab $Liste { set protCible [ValiGN $pab] #Espionne "\t $pab : $protCible" set ListePfam [getMacsimsInf $pab ConcatPfam] #faire la requete dans la base DOMINE foreach pfam $ListePfam { set pfam [lindex [split $pfam ";"] 3] if {[regexp {(.*)from.*} $pfam a p]} { set pfam $p; } if {[regexp {^PROP_(.*).*} $pfam a p]} { set pfam $p; } set pfam [lindex [split $pfam " "] 0] #Espionne "pfam:$pfam" set requete "SELECT distinct domain2 FROM INTERACTION where Domain1='$pfam' and Domain2 in ($Domain2)" #Espionne "$requete" foreach {domaine} [SqlExec $requete ""] { #Espionne "domaine:$domaine" #recuperer la prote du domaine set protein $PfamProt($domaine) #Espionne $protein #ici faire test si existe deja... set protCle $protCible append protCle "_$protein" set value $pfam append value "-$domaine" append protCle $value #set Result($protCle) $value lappend Result $protCle #array set tabpseudo(1 , 1) {$domaine} } #valeur cle->valeur..; PF-->P1256 } } return $Result # foreach nom [lsort [array names Result]] { # puts "Valeur associée à $nom: $Result($nom)" # } # foreach {nom valeur} [array get tableau] { # puts "Valeur associée à \"$nom\": $valeur" # } # set PfamComplexL [ListePfamComplex] # foreach pfam $PfamComplexL { # set pfam # } } proc InteractiveMode {{Mode ""}} { global InteractiveMode if { ! [info exists InteractiveMode]} { set InteractiveMode 1 } if {$Mode==""} { return $InteractiveMode } set InteractiveMode 1 if {[regexp -nocase {(Batch|Off|0)} $Mode]} { set InteractiveMode 0 } set Chut [expr ! $InteractiveMode] global OuiOuNonToujoursParDefaut ; set OuiOuNonToujoursParDefaut $Chut global EspionneNon ; set EspionneNon $Chut global FaireLireNon ; set FaireLireNon $Chut global EntreToujoursDefaut ; set EntreToujoursDefaut $Chut return $InteractiveMode } proc InterpreteLaLigneDeCommande {Ligne} { global env AExecuter APutser if {[info exists env(ORDALIEONWEB)]} { set ::EspionneNon 1 } Espionne "---------------------------------------------------" Espionne "[DonneDateEtHeure]" Espionne "Program : $::argv0" Espionne "options : $::argv" Espionne "---------------------------------------------------" Espionne "" # Pour Julie, enleve les = au cas ou ... set Ligne [string map {= " "} $Ligne] regsub -all { +} $Ligne " " Ligne set Ligne [string trim $Ligne] # Pas d'arguments if {$Ligne eq ""} { puts "\ntype 'ordalie help' to access on-line arguments\n" LoadTclPackages return } set Arg1 [lindex [split $Ligne " "] 0] set Val1 [lindex [split $Ligne " "] 1] ##################### # ADMIN Ordali : # # On ne load ni packages tcl ou tk. # On execute et puis exit if {$Arg1 eq "admin"} { puts [eval {*}[lrange [split $Ligne " "] 1 end]] exit } ########################### #LoadTclPackages namespace path {::tcl::mathop ::tcl::mathfunc} # from GSCOPE : puts et exe if {$Arg1 eq "puts"} { set reponse [eval {*}[lrange [split $Ligne " "] 1 end]] TaisToi 0 puts $reponse exit #return } if {$Arg1 eq "exe"} { LesDefauts Mode batch eval {*}[lrange [split $Ligne " "] 1 end] return "dansexe" } LoadTclPackages # manage project, if {$Arg1 eq "project"} { if {$Val1 eq ""} { FaireLire "Please supply a project name !" exit } LoadTkAndPackages CheckForProject $Val1 return "stop" } # traite help if {[string tolower $Arg1] eq "help"} { set Ligne "-ordalihelp 1" } elseif {[file exists $Arg1]} { set ftype [file extension $Arg1] switch $ftype { ".macsim" - ".xml" {set type "xml"} ".tfa" - ".tfasta" - ".fasta" {set type "tfa"} ".msf" {set type "msf"} ".aln" {set type "aln"} ".rsf" {set type "rsf"} ".ord" {set type "ord"} default {set type [FormatDuFichierSequence $Arg1]} } if {$type ne ""} { set Ligne "-$type $Ligne" } } # bad argument # at this point, all arguments should start with # a '-' character if {[string index $Ligne 0] ne "-"} { FaireLire "\"$Ligne\" is not recognized or does not exists !" return } # Traite les arguments. Sont maintenant tous sous # forme de paire cle-valeur set Liste [DonneListeCleValeur $Ligne] set AExecuter "" foreach {e v} $Liste { set e [string tolower $e] switch $e { "-puts" { #puts [eval $v] set APutser $v } "-exe" { #eval $v if {[string length $AExecuter]} { append AExecuter " ; " } append AExecuter $v } "-selnom" { LesDefauts SelectionNom $v } "-time" { LeTempsDesProcs } "-showss" { LesDefauts AffSS $v } "-downloadpdb" { switch $v { "0" {set what "dont"} default {set what "internet"} } LesDefauts DownloadPDB $what } "-balibase" { LesDefauts Balibase $v LesDefauts CheckSeq 0 LesDefauts AffSS 1 } "-precompute" { LesDefauts PreCompute $v } "-msf" { set FichierMSF $v LesDefauts FichierMSF $FichierMSF LesDefauts TypeAli MSF } "-rsf" { set FichierRSF $v LesDefauts FichierRSF $FichierRSF LesDefauts TypeAli RSF } "-tfa" { set FichierTFA $v LesDefauts FichierTFA $FichierTFA LesDefauts TypeAli TFA } "-xml" { set FichierXML $v LesDefauts FichierXML $FichierXML LesDefauts TypeAli XML } "-ord" { set FichierORD $v LesDefauts FichierORD $FichierORD LesDefauts TypeAli ORD } "-aln" { set FichierALN $v LesDefauts FichierALN $FichierALN LesDefauts TypeAli ALN } "-group" { set TypeDeGroupesACreer $v LesDefauts TypeDeGroupesACreer $TypeDeGroupesACreer if {$TypeDeGroupesACreer == "fichierclu"} { set fichierclu [lindex $Liste [expr {$Idx + 2}]] LesDefauts FichierClu $fichierclu } } "-batch" { LesDefauts Mode Batch LesDefauts Exit 1 LesDefauts LogAtStartup 0 } "-mode" { LesDefauts Mode [string tolower $v] LesDefauts LogAtStartup 0 } "-convert" { set fmt [string toupper $v] LesDefauts DownloadPDB dont LesDefauts Mode Batch LesDefauts Exit 1 LesDefauts DownloadPDB none set AExecuter "SauveLAlignement $fmt JLeSauveAs" } "-project" { LesDefauts InProject 1 LesDefauts Project $v } "-devlpt" { LesDefauts Devlpt 1 } "-run" { LesDefauts Run 1 } "-dump" { if {$v ne ""} { set FichierDump $v } else { set FichierDump 1 } LesDefauts Dump $FichierDump } "-exit" { LesDefauts Exit 1 } "-checkseq" { LesDefauts CheckSeq $v } "-debug" { if {$v eq ""} {set v 1} LesDefauts Debug $v } "-clusdeb" { LesDefauts clusdeb $v } "-weight1" { LesDefauts Poids $v } "-record" { bind Button <1> {+Record %W %x %y} bind Menu <1> {+Record %W %x %y} bind Menubutton <1> {+Record %W %x %y} bind Radiobutton <1> {+Record %W %x %y} bind Checkbutton <1> {+Record %W %x %y} } "-weight2" { LesDefauts Poids2 $v } "-weight3" { LesDefauts Poids3 $v } "-savelog" { LesDefauts SaveLog $v } "-threshold" { set Threshold $v if {$v >= 51 && $v <= 100} { LesDefauts Threshold $v } } "-pdb" { set Idx [lsearch $Liste "-pdb"] set FichierPDB [lindex $Liste [expr {$Idx+1}]] LesDefauts FichierPDB $FichierPDB set SeqAssocie [lindex $Liste [expr {$Idx+2}]] LesDefauts SeqAssocie $SeqAssocie LesDefauts PDB 1 } "-view" { LesDefauts Visualize $v set FichierOMAC $v LesDefauts FichierOMAC $v } "-script" { if {[file exists $v]} { LesDefauts RunScript 1 LesDefauts Script $v } } "-ordalihelp" { OrdalieHelpOnLine exit } } } return } proc InterproScanWebService {args} { set Lquery [list] set YaEmail 0 foreach {k v} $args { switch $k { "-sequence" { lappend Lquery sequence $v } "-appl" { } "-goterms" { if {! [string is boolean $v]} { puts "Bad value for -goterms !\nShould be a boolean." continue } lappend Lquery goterms $v } "-pathways" { if {! [string is boolean $v]} { puts "Bad value for -pathways !\nShould be a boolean !" continue } lappend Lquery pathways $v } "-title" { lappend Lquery title $v } "-email" { lappend Lquery email $v set YaEmail 1 } } } if {! $YaEmail} { lappend Lquery email luc.moulinier@laposte.net } set query [::http::formatQuery {*}$Lquery] set baseUrl "http://www.ebi.ac.uk/Tools/services/rest/iprscan5" return [EBIWebService $baseUrl $query] } proc Interproscan {args} { global Interproscan if {$args=={}} { set Qui "" set Quoi "" } else { set Qui [lindex $args 0] set Quoi [join [lrange $args 1 end] ","] } if {$Qui==""} { set Qui "ListOf" ; set Quoi "Filename" } if {[info exists Interproscan($Qui,$Quoi)]} {return $Interproscan($Qui,$Quoi)} if {[info exists Interproscan("EstCharge")]} {return ""} set Interproscan("EstCharge") 1 set SpliRet 0 if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set SpliRet 1 set LesRepertoires [LesRepertoires "Mouse" "Mod"] } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set SpliRet 1 set LesRepertoires [LesRepertoires "Rat" "Mod"] } else { set RepertoireTf "[RepertoireDuGenome]/tfasdescopains" set LesRepertoires [list $RepertoireTf] } set RepertoireInterproscan "[RepertoireDuGenome]/Interproscan" set Interproscan(DirOut,) $RepertoireInterproscan set LesFichierInterproscan [glob -nocomplain "$RepertoireInterproscan/*.is"] if {$LesFichierInterproscan=={}} { file mkdir $RepertoireInterproscan foreach Repertoire $LesRepertoires { foreach FileIn [glob -nocomplain "$Repertoire/*"] { if {$SpliRet} { set Queue [file tail $FileIn] regsub {\.[^\.]+$} $Queue "" Cluster set Box [InterrogeBox $Cluster Box] } else { set Box [file tail $FileIn] } set FileOut "$Box.is" set Commande "/bips/bin/iprscan -cli -i $FileIn -o $RepertoireInterproscan/$FileOut -appl hmmpfam -format raw -goterms -iprlookup" #dans le cas ou on lance d'une lame on est redirige vers starv2 car marche pas sur lame if {![regexp "star" [info hostname]]} {set Commande "rsh starv2 $Commande"} catch {eval exec $Commande} #dans le cas ou on lance sur une machine ou iprscan n existe pas, on arrete tout pour eviter de tourner a l'infini if {[glob -nocomplain "$RepertoireInterproscan/*.is"]=={}} {return ""} } } unset Interproscan return [Interproscan $Qui $Quoi] } set Interproscan(ListOf,Filename) $LesFichierInterproscan foreach FichierInterproscan $LesFichierInterproscan { set Queue [file tail $FichierInterproscan] regsub {\.[^\.]+$} $Queue "" Box lappend Interproscan(ListOf,Box) $Box set Interproscan($Box,ListOf,IdDomain) {} foreach LigneInterproscan [LesLignesDuFichier $FichierInterproscan] { set LesMotsInterproscan [split $LigneInterproscan "\t"] set Technique [lindex $LesMotsInterproscan 3] if {$Technique!="HMMPfam"} {continue} set Name [lindex $LesMotsInterproscan 0] #enleve les extensions .CONTIG en fin de nom des clones (je ne sais plus pourquoi) #regsub {\.[^\.]+$} $Name "" Name lappend Interproscan(ListOf,Name) $Name set Interproscan(ListOf,Name) [ListeSansDoublon $Interproscan(ListOf,Name)] lappend Interproscan($Name,ListOf,Box) $Box set Interproscan($Name,ListOf,Box) [ListeSansDoublon $Interproscan($Name,ListOf,Box)] lappend Interproscan($Box,Name) $Name set Interproscan($Box,Name) [ListeSansDoublon $Interproscan($Box,Name)] set IdDomain [lindex $LesMotsInterproscan 4] set DesDomain [lindex $LesMotsInterproscan 5] set Start [lindex $LesMotsInterproscan 6] set Stop [lindex $LesMotsInterproscan 7] set Score [lindex $LesMotsInterproscan 8] lappend Interproscan($Box,$Name,IdDomain) $IdDomain set Interproscan($Box,$Name,IdDomain) [ListeSansDoublon $Interproscan($Box,$Name,IdDomain)] set Interproscan($Box,$Name,$IdDomain,DesDomain) $DesDomain #lappend car un domaine PFAM peut se trouver a deux endroits differents sur le meme Name lappend Interproscan($Box,$Name,$IdDomain,Start-Stop) $Start-$Stop set Interproscan($Box,$Name,$IdDomain,$Start-$Stop,Score) $Score lappend Interproscan($Box,ListOf,IdDomain) $IdDomain lappend Interproscan($Box,$IdDomain,ListOf,Name) $Name } set Interproscan($Box,ListOf,IdDomain) [lsort -unique $Interproscan($Box,ListOf,IdDomain)] } return [Interproscan $Qui $Quoi] } proc InterproscanFromOneFile {args} { #set FichierInterproscan "/home/brochetx/Documents/bilan_presence|absence/TAF9/RecherchePDB/test/resultInter2" #set FichierInterproscan "/genomics/link/TTL/ttl_08062009_radwen.ipr" #set FichierInterproscan "" global InterproscanFromOneFile if {$args=={}} { set Qui "" set Quoi "" } else { set Qui [lindex $args 0] set Quoi [join [lrange $args 1 end] ","] } #attention doit toujours preciser le fichier Interproscan avant de commencer ac [InterproscanFromOneFile File TonFile] if {$Qui=="File"} { if {[info exists InterproscanFromOneFile]} { unset -nocomplain InterproscanFromOneFile } set InterproscanFromOneFile(File) $Quoi return "" } if {$Qui==""} { set Qui "ListOf" ; set Quoi "Name" } if {[info exists InterproscanFromOneFile($Qui,$Quoi)]} {return $InterproscanFromOneFile($Qui,$Quoi)} if {[info exists InterproscanFromOneFile("EstCharge")]} {return ""} set InterproscanFromOneFile("EstCharge") 1 foreach LigneInterproscan [LesLignesDuFichier $InterproscanFromOneFile(File)] { set LesMotsInterproscan [split $LigneInterproscan "\t"] set Technique [lindex $LesMotsInterproscan 3] if {$Technique!="HMMPfam"} {continue} set Name [lindex $LesMotsInterproscan 0] lappend InterproscanFromOneFile(ListOf,Name) $Name set InterproscanFromOneFile(ListOf,Name) [ListeSansDoublon $InterproscanFromOneFile(ListOf,Name)] set IdDomain [lindex $LesMotsInterproscan 4] set DesDomain [lindex $LesMotsInterproscan 5] set Start [lindex $LesMotsInterproscan 6] set Stop [lindex $LesMotsInterproscan 7] set Score [lindex $LesMotsInterproscan 8] lappend InterproscanFromOneFile($Name,IdDomain) $IdDomain set InterproscanFromOneFile($Name,IdDomain) [ListeSansDoublon $InterproscanFromOneFile($Name,IdDomain)] set InterproscanFromOneFile($Name,$IdDomain,DesDomain) $DesDomain lappend InterproscanFromOneFile($Name,$IdDomain,Start-Stop) $Start-$Stop set InterproscanFromOneFile($Name,$IdDomain,$Start-$Stop,Score) $Score lappend InterproscanFromOneFile($IdDomain,ListOf,Name) $Name } return [InterproscanFromOneFile $Qui $Quoi] } proc InterproscanRattrapage {} { #NB: changer ListBox selon le cas set SpliRet 0 if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set SpliRet 1 set LesRepertoires [LesRepertoires "Mouse" "Mod"] set ListBox [list SPM0036 SPM0515 SPM1349 SPM2091 SPM2909 SPM3531 SPM4510 SPM5327 SPM5773 SPM6592] } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set SpliRet 1 set LesRepertoires [LesRepertoires "Rat" "Mod"] set ListBox [list SPR2839 SPR4847 SPR4952 SPR5284] } else { set RepertoireTf "[RepertoireDuGenome]/tfasdescopains" set LesRepertoires [list $RepertoireTf] } set RepertoireInterproscan "[RepertoireDuGenome]/Interproscan" foreach Box $ListBox { set LesElus($Box) 1 } foreach Repertoire $LesRepertoires { foreach FileIn [glob -nocomplain "$Repertoire/*"] { if {$SpliRet} { set Queue [file tail $FileIn] regsub {\.[^\.]+$} $Queue "" Cluster set Box [InterrogeBox $Cluster Box] } else { set Box [file tail $FileIn] } if {[info exists LesElus($Box)] && $LesElus($Box) == 1} { set FileOut "$Box.is" Espionne $FileOut set Commande "/bips/bin/iprscan -cli -i $FileIn -o $RepertoireInterproscan/$FileOut -appl hmmpfam -format raw -goterms -iprlookup" catch {eval exec $Commande} } } } } proc Interroge2GO {args} { global TableauInterrogation2GO if {0} { global OntoEstAuCafe if {[PreFixe]!="Onto"} { set OntoEstAuCafe 1 } if {[info exists OntoEstAuCafe] && $OntoEstAuCafe} { return [QuestionDeScience Ontology "ret Interroge2GO [join $args " "]"] } } if {$args == "unset"} { if {[info exists TableauInterrogation2GO]} {unset TableauInterrogation2GO} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogation2GO($Quoi)]} { return [lsort -unique [set TableauInterrogation2GO($Quoi)]] } ###################CHARGE Fichier2GO################### if {![info exists TableauInterrogation2GO(EstCharge)]} { set TableauInterrogation2GO(EstCharge) 1 Charge2GO TableauInterrogation2GO } if {![info exists TableauInterrogation2GO($Quoi)]} {return} return [lsort -unique [set TableauInterrogation2GO($Quoi)]] } proc InterrogeActiChip2Affy {args} { Wup "Permet de questionner les Probe_Set commun entre ActiChip et Affymetrix UG133A 2.0" Wup "Voir aussi decharge et charge" global TabActiChip_Affy #Arguments: ########### #Index est le numero unique attribue en fonction de la ligne dans le fichier affymetrix #Pour faire la correspondance entre les deux #$AccGscope Probe_Set - Nom des Probe Set (11 references) peut etre une liste # AccGscope AccessRefSeq - Access RefSeq correspondant au gscope #$AccRefSeq Probe_Set - Nom des Probe Set (11 references) peut etre une liste # AccRefSeq AccessGscope - Access gscope correspondant au RefSeq #$ProbeSetID AccessRefSeq - Access RefSeq correspondant au Probe Set (11 references) # ProbeSetID AccessGscope - Access gscope correspondant au Probe Set (11 references) #LesAccessGscope - Liste des Access Gscope disponible if {$args == "unset"} { if {[info exists TabActiChip_Affy]} {array unset TabActiChip_Affy} return "" } set Quoi [join $args ","] if { [info exists TabActiChip_Affy($Quoi)]} {return [set TabActiChip_Affy($Quoi)]} if {! [info exists TabActiChip_Affy(EstCharge)]} {set TabActiChip_Affy(EstCharge) 0} if {$Quoi=="Decharge"} { DechargeActiChip2Affy return "" } if { [info exists TabActiChip_Affy(EstVide)]} {return ""} if { [info exists TabActiChip_Affy($Quoi)]} {return [set TabActiChip_Affy($Quoi)]} ###################CHARGE le Fichier avec les ActiChip2Affy######################### if {! [info exists TabActiChip_Affy(EstCharge)] || [set TabActiChip_Affy(EstCharge)]=="0"} { set TabActiChip_Affy(EstCharge) 1 set ResultatCharge [ChargeActiChip2Affy TabActiChip_Affy] if {$ResultatCharge != ""} { set TabActiChip_Affy(EstVide) 1 return "" } } if {! [info exists TabActiChip_Affy($Quoi)]} {return ""} return [set TabActiChip_Affy($Quoi)] } proc InterrogeActiChip2Ontario {args} { Wup "Permet de questionner les sondes communes aux puces ActiChip et Ontario " Wup "Voir aussi decharge et charge" global TabOntario #Arguments: ########### # FichierACharger peut etre vide "" #$FichierACharger $GscopeAccess ProteinAccess - Access de protein correspondant au gscope access #$FichierACharger $GscopeAccess DesignAccess - Access de genbank correspondant au gscope access pour le design #$FichierACharger $GscopeAccess Definition - Definition du gscope access #$FichierACharger $GscopeAccess Chip_EST - nombre de fois que le gene est trouve sur la puce Ontario #$FichierACharger $GscopeAccess LesOriginal_Image_ID - liste des OriginalId de Ontarion #$FichierACharger $GscopeAccess LesVerified_Image_ID - liste des VerifiedId de Ontarion #$FichierACharger $GscopeAccess clusterID - Unigene cluster #$FichierACharger $Block $Row $Col - valeur a 1 si existe #$FichierACharger $Block $Row $Col GscopeAccess - Liste des Access Gscope trouve pour ce gene if {$args == "unset"} { if {[info exists TabOntario]} {array unset TabOntario} return "" } set FichierACharger [lindex $args 0] if {! [file exists "$FichierACharger"]} { set RepOntario "[RepertoireDuGenome]/Autres_Puces/Ontario" set FichierACharger "$RepOntario/Chip_EST_Gene_Present.txt" } if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" return "" } set Quoi [join [concat $FichierACharger [lrange $args 1 end]] ","] #Espionne "$Quoi" #set Quoi [join $args ","] if { [info exists TabOntario($Quoi)]} {return [set TabOntario($Quoi)]} if {! [info exists TabOntario($FichierACharger,EstCharge)]} {set TabOntario($FichierACharger,EstCharge) 0} if {$Quoi=="Decharge"} { DechargeActiChip2Ontario $FichierACharger return "" } if { [info exists TabOntario($FichierACharger,EstVide)]} {return ""} if { [info exists TabOntario($Quoi)]} {return [set TabOntario($Quoi)]} ###################CHARGE le Fichier avec les InfosOntario######################### if {! [info exists TabOntario($FichierACharger,EstCharge)] || [set TabOntario($FichierACharger,EstCharge)]=="0"} { set TabOntario($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeActiChip2Ontario TabOntario $FichierACharger] if {$ResultatCharge != ""} { set TabOntario($FichierACharger,EstVide) 1 return "" } } if {! [info exists TabOntario($Quoi)]} {return ""} return [set TabOntario($Quoi)] } proc InterrogeActiChip2UMCU {args} { Wup "Permet de questionner les Oligos communs entre ActiChip et UMCU" Wup "Utilise le fichier Chip_UMCU_Gene_Present.txt" Wup "Voir aussi decharge et charge" global TabActiChip_UMCU #Arguments: ########### #$AccGscope UMCU_ID - ID de la puce UMCU correspondant au gscope Access de ActiChip2.0 #$UMCU_ID AccessGscope - gscope Access de ActiChip2.0 correspondant a UMCU_ID de la puce UMCU #LesAccessGscope - Liste des Access Gscope disponible if {$args == "unset"} { if {[info exists TabActiChip_UMCU]} {array unset TabActiChip_UMCU} return "" } set Quoi [join $args ","] if { [info exists TabActiChip_UMCU($Quoi)]} {return [set TabActiChip_UMCU($Quoi)]} if {! [info exists TabActiChip_UMCU(EstCharge)]} {set TabActiChip_UMCU(EstCharge) 0} if {$Quoi=="Decharge"} { DechargeActiChip2UMCU return "" } if { [info exists TabActiChip_UMCU(EstVide)]} {return ""} if { [info exists TabActiChip_UMCU($Quoi)]} {return [set TabActiChip_UMCU($Quoi)]} ###################CHARGE le Fichier avec les ActiChip2UMCU######################### if {! [info exists TabActiChip_UMCU(EstCharge)] || [set TabActiChip_UMCU(EstCharge)]=="0"} { set TabActiChip_UMCU(EstCharge) 1 set ResultatCharge [ChargeActiChip2UMCU TabActiChip_UMCU] if {$ResultatCharge != ""} { set TabActiChip_UMCU(EstVide) 1 return "" } } if {![info exists TabActiChip_UMCU($Quoi)]} {return ""} return [set TabActiChip_UMCU($Quoi)] } proc InterrogeAffy_UCSC {args} { Wup "Permet de questionner les Probe_Set Affymetrix U133A 2.0 dans UCSC" Wup "Voir aussi decharge et charge" global TabAffy_UCSC #Arguments: ########### #FichierAffyUCSC, fourni par UCSC, il contient la liste des infos des localisations sur les genomes UCSC #pour chaque sequence consensus associee a un ProbeSet #Genome est le nom du genome UCSC utilise par ex: human ou mouse #$FichierAffyUCSC $Genome LesProbeSets - Liste des ProbeSets disponibles #$FichierAffyUCSC $Genome LesChromo - Liste des noms de chromosomes disponibles #$FichierAffyUCSC $Genome $Chromo LesProbeSets - Liste des ProbeSets disponibles par chromosome #$FichierAffyUCSC $Genome $ProbeSetID Chromosome - Liste des localisations chromosomique de $ProbeSetID #$FichierAffyUCSC $Genome $ProbeSetID $Chromo Debut - Liste des Debuts sur le ou les chromo de $ProbeSetID #$FichierAffyUCSC $Genome $ProbeSetID $Chromo Fin - Liste des Fins sur le ou les chromo de $ProbeSetID #$FichierAffyUCSC $Genome $ProbeSetID $Chromo Strand - Liste des Strands sur le ou les chromo de $ProbeSetID if {$args == "unset"} { if {[info exists TabAffy_UCSC]} {array unset TabAffy_UCSC} return "" } set Quoi [join $args ","] set Genome [lindex $args 1] set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { set FichierACharger "[UCSCGenomeDir $Genome]/database/affyU133Plus2.txt" if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" return "" } } set Quoi [join [concat [list $FichierACharger] [lrange $args 2 end]] ","] if { [info exists TabAffy_UCSC($Quoi)]} {return [set TabAffy_UCSC($Quoi)]} if {! [info exists TabAffy_UCSC($FichierACharger,EstCharge)]} {set TabAffy_UCSC($FichierACharger,EstCharge) 0} if {$Quoi=="Decharge"} { DechargeAffy_UCSC $FichierACharger return "" } if { [info exists TabAffy_UCSC($FichierACharger,EstVide)]} {return ""} if { [info exists TabAffy_UCSC($Quoi)]} {return [set TabAffy_UCSC($Quoi)]} ###################CHARGE le Fichier avec les Affy_UCSC######################### if {! [info exists TabAffy_UCSC($FichierACharger,EstCharge)] || [set TabAffy_UCSC($FichierACharger,EstCharge)]=="0"} { set TabAffy_UCSC($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeAffy_UCSC TabAffy_UCSC $FichierACharger] if {$ResultatCharge != ""} { set TabAffy_UCSC($FichierACharger,EstVide) 1 return "" } } if {! [info exists TabAffy_UCSC($Quoi)]} {return ""} return [set TabAffy_UCSC($Quoi)] } proc InterrogeBED {{Qui ""} {Quoi ""} {File ""}} { global InterrogeBED if {$Qui==""} { set Qui "ListOf" ; set Quoi "name" } if {$Quoi==""} { set Quoi "name" } if {[info exists InterrogeBED($Qui,$Quoi,$File)]} {return $InterrogeBED($Qui,$Quoi,$File)} if {[info exists InterrogeBED("EstCharge",$File)]} {return ""} set InterrogeBED("EstCharge",$File) 1 set LesTetes [list "chrom" "chromStart" "chromEnd" "name" "score" "strand" "thickStart" "thickEnd" "itemRgb" "blockCount" "blockSizes" "blockStarts"] foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^track" $Ligne]} {continue} set MotsDeLaLigne [split $Ligne "\t"] set Name [lindex $MotsDeLaLigne 3] set InterrogeBED($Name,line,$File) $Ligne lappend InterrogeBED(ListOf,name,$File) $Name foreach Mot $MotsDeLaLigne Tete $LesTetes { set InterrogeBED($Name,$Tete,$File) $Mot } } return [InterrogeBED $Qui $Quoi $File] } proc InterrogeBandesCytologiques {args} { global TableauBandesCytologiques #$Chromosome LesBandesP #$Chromosome LesBandesQ #$Chromosome Centromere #$Chromosome $Bande #$Chromosome TailleP #$Chromosome TailleQ #TaillePMax #TailleQMax #NbChromosomes #LesChromosomes if {$args == "unset"} { if {[info exists TableauBandesCytologiques]} {unset TableauBandesCytologiques} return } set Quoi [join $args ","] if {[info exists TableauBandesCytologiques($Quoi)]} {return [set TableauBandesCytologiques($Quoi)]} set File "[HumanGenomeDir]/Localisation/CytologicMap" if {![file exists $File]} {return} ###################CHARGE BandesCytologiques######################### if {[info exists TableauBandesCytologiques($File,EstCharge)]} {return} set TableauBandesCytologiques($File,EstCharge) 1 ChargeBandesCytologiques TableauBandesCytologiques $File if {[info exists TableauBandesCytologiques($Quoi)]} {return [set TableauBandesCytologiques($Quoi)]} return } proc InterrogeBestHitInDatabase {args} { Wup "Permet de questionner les infos de BestHitInDataBase" Wup "Voir aussi decharge et charge" global InfoDatabase #Arguments: ########### #$FichierBlast AccessDeRef - Meilleur access du blast selon les criteres appliques # FichierBlast BId - Access en reserve si n a pas passe les tests (vide si trop limite) # FichierBlast IdGlobal - Pourcentage d identite global: Aligne sur Total dans les alignements # FichierBlast PCoverQuery - Recouvrement de Query par rapport au Subject # FichierBlast PCoverSubject - Recouvrement de Subject par rapport au Query # FichierBlast InitialBId - Premier BId trouve pour pas le perdre # FichierBlast $InitialBId Aligned - Bases Alignees du premier BId trouve if {$args == "unset"} { if {[info exists InfoDatabase]} {array unset InfoDatabase} return "" } set Quoi [join $args ","] if {[info exists InfoDatabase($Quoi)]} {return [set InfoDatabase($Quoi)]} set FichierACharger [lindex $args 0] if {! [info exists InfoDatabase($FichierACharger,EstCharge)]} {set InfoDatabase($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeBestHitInDatabase $FichierACharger return "" } if { [info exists InfoDatabase($FichierACharger,EstVide)]} {return ""} if { [info exists InfoDatabase($Quoi)]} {return [set InfoDatabase($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists InfoDatabase($FichierACharger,EstCharge)] || [set InfoDatabase($FichierACharger,EstCharge)]=="0"} { set InfoDatabase($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLesBestHitInDatabase InfoDatabase $FichierACharger] if {$ResultatCharge != ""} { set InfoDatabase($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoDatabase($Quoi)]} {return ""} return [set InfoDatabase($Quoi)] } proc InterrogeBestProteinAndmRNAForeachOrga {args} { global TableauBestProteinAndmRNAForeachOrga ### $Quoi peut etre egale a Protein ou mRNA#### #LesNoms #$Nom LesOrganismes #$Nom $Quoi LesAccess #$Nom Organisme $Orga $Quoi Access #$Nom Access $Access Identity #LesOrganismes #Access $Access LesNoms #Access $Access LesOrganismes #Access $Access Definition #Access $Access Taille #Access $Access ProteinOumRNA if {$args == "unset"} { if {[info exists TableauBestProteinAndmRNAForeachOrga]} {unset TableauBestProteinAndmRNAForeachOrga} return "" } set Quoi [join $args ","] if {[info exists TableauBestProteinAndmRNAForeachOrga($Quoi)]} { return [set TableauBestProteinAndmRNAForeachOrga($Quoi)] } set FichierBestProtAndmRNA "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" ###################CHARGE BestProtAndmRNA######################### if { [file exists $FichierBestProtAndmRNA] && ![info exists TableauBestProteinAndmRNAForeachOrga($FichierBestProtAndmRNA,EstCharge)]} { set TableauBestProteinAndmRNAForeachOrga($FichierBestProtAndmRNA,EstCharge) 1 ChargeBestProteinAndmRNAForeachOrga TableauBestProteinAndmRNAForeachOrga $FichierBestProtAndmRNA } if {![info exists TableauBestProteinAndmRNAForeachOrga($Quoi)]} {return} return [set TableauBestProteinAndmRNAForeachOrga($Quoi)] } proc InterrogeBilanMasking {args} { #LesEtats #LesNoms #$Nom LesEtats #$Nom LesRepeats #$Nom Etat $InfoMasking PMasked #$Nom Etat $InfoMasking LesRepeats #$Nom Etat $InfoMasking Repeat $Repeat n #$Nom Repeat $Repeat n #$Nom Etat $InfoMasking NbRepeat #LesRepeats #Repeat $Repeat LesNoms #Repeat $Repeat n set File "[RepertoireDuGenome]/fiches/BilanMasking" if {![file exists $File]} {return} global TableauBilanMasking if {$args == "unset"} { if {[info exists TableauBilanMasking]} {unset TableauBilanMasking} return } set Quoi [join $args ","] if {[info exists TableauBilanMasking($Quoi)]} { return [set TableauBilanMasking($Quoi)] } if {[info exists TableauBilanMasking($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauBilanMasking($File,EstCharge) 1 ChargeBilanMasking TableauBilanMasking $File if {[info exists TableauBilanMasking($Quoi)]} { return [set TableauBilanMasking($Quoi)] } return } proc InterrogeBindingPfamDesFromGo {{Qui ""} {Quoi ""}} { global InterrogeBindingPfamDesFromGo if {$Qui==""} { set Qui "ListOf"; set Quoi "Pfam" } if {[info exists InterrogeBindingPfamDesFromGo($Qui,$Quoi)]} {return $InterrogeBindingPfamDesFromGo($Qui,$Quoi)} if {[info exists InterrogeBindingPfamDesFromGo("EstCharge")]} {return ""} set InterrogeBindingPfamDesFromGo("EstCharge") 1 #set File "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/BindingPfamDesFromGo.txt" set File "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromGo/NucleicAcidBindingPfamDesFromGo.txt" foreach Ligne [LesLignesDuFichier $File] { set elmts [split $Ligne "\t"] set Pfam [lindex $elmts 0] if {$Pfam == ""} {continue} set Des [lindex $elmts 2] set Des [string trim $Des] lappend InterrogeBindingPfamDesFromGo(ListOf,Pfam) $Pfam set InterrogeBindingPfamDesFromGo($Pfam,Des) $Des set InterrogeBindingPfamDesFromGo($Des,Pfam) $Pfam } return [InterrogeBindingPfamDesFromGo $Qui $Quoi] } proc InterrogeBox {{Qui ""} {Quoi ""}} { global InterrogeBox if {$Qui==""} { set Qui "ListOf"; set Quoi "Box" } if {[info exists InterrogeBox($Qui,$Quoi)]} {return $InterrogeBox($Qui,$Quoi)} if {[info exists InterrogeBox("EstCharge")]} {return ""} set InterrogeBox("EstCharge") 1 set RepertoireProttfa "[RepertoireDuGenome]/prottfa" foreach File [glob -nocomplain "$RepertoireProttfa/*"] { set Box [file tail $File] lappend InterrogeBox(ListOf,Box) $Box set LigneDes [lindex [LesLignesDuFichier $File] 0] set LesMotsDes [split $LigneDes " "] set Ref [lindex $LesMotsDes 4] set Cluster [lindex $LesMotsDes 1] set InterrogeBox($Box,Ref) $Ref set InterrogeBox($Box,Cluster) $Cluster set InterrogeBox($Cluster,Box) $Box } return [InterrogeBox $Qui $Quoi] } proc InterrogeCalcMeanID_Pos {args} { Wup "Permet de questionner les infos des MeanIDs obtenus par CalcMeanID_Pos" Wup "Voir aussi decharge et charge" global TabMeanIDInAln #Arguments: ########### #$Fichier LesIndices - Les indices du nombre de couples de positions #$Fichier LesPos - Les positions par couples demandees #$Fichier $Indice Pos - Les Position a cet indice #$Fichier $Indice MeanId - Le MeanId a cet indice #$Fichier $Pos Ref MeanId - Rend la valeur pour une position dans la reference (P02568) #$Fichier $Pos PDB MeanId - Rend la valeur pour une position dans la PDB (1yag) if {$args == "unset"} { if {[info exists TabMeanIDInAln]} {array unset TabMeanIDInAln} return "" } set Quoi [join $args ","] if {[info exists TabMeanIDInAln($Quoi)]} {return [set TabMeanIDInAln($Quoi)]} set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabMeanIDInAln($FichierACharger,EstCharge)]} {set TabMeanIDInAln($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeCalcMeanID_Pos $FichierACharger return "" } if { [info exists TabMeanIDInAln($FichierACharger,EstVide)]} {return ""} if { [info exists TabMeanIDInAln($Quoi)]} {return [set TabMeanIDInAln($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabMeanIDInAln($FichierACharger,EstCharge)] || [set TabMeanIDInAln($FichierACharger,EstCharge)]=="0"} { set TabMeanIDInAln($FichierACharger,EstCharge) 1 Espionne "On charge $FichierACharger" set ResultatCharge [ChargeCalcMeanID_Pos TabMeanIDInAln $FichierACharger] if {$ResultatCharge != ""} { set TabMeanIDInAln($FichierACharger,EstVide) 1 return "" } } if {![info exists TabMeanIDInAln($Quoi)]} {return ""} return [set TabMeanIDInAln($Quoi)] } proc InterrogeChoosenGeneOntology {args} { global TableauChoosenGeneOntology #$FichierChoosenGO LesGOChoisis #$FichierChoosenGO GOChoisi $GO Type if {$args == "unset"} { if {[info exists TableauChoosenGeneOntology]} { unset TableauChoosenGeneOntology } return "" } set Quoi [join $args ","] if {[info exists TableauChoosenGeneOntology($Quoi)]} { return [set TableauChoosenGeneOntology($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauChoosenGeneOntology($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauChoosenGeneOntology($File,EstCharge) 1 ChargeChoosenGeneOntology TableauChoosenGeneOntology $File if {[info exists TableauChoosenGeneOntology($Quoi)]} { return [set TableauChoosenGeneOntology($Quoi)] } return } proc InterrogeCiblesSafeAcne {{Qui ""} {Quoi ""}} { global InterrogeCiblesSafeAcne if {[info exists InterrogeCiblesSafeAcne($Qui,$Quoi)]} { return $InterrogeCiblesSafeAcne($Qui,$Quoi) } if {[info exists InterrogeCiblesSafeAcne("EstCharge")]} { return "" } set InterrogeCiblesSafeAcne("EstCharge") 1 set m -1 set FileCibles "/genomics/link/SafeAcne/FichiersInitiaux/KRZYZOSIAK_SummarizedList.csv" set LesLignesDuFichier [LesLignesDuFichier $FileCibles] #Titre foreach Ligne [lrange $LesLignesDuFichier 0 1] { incr m set n -1 foreach ElmtTitre [split $Ligne ";"] { incr n regsub -all " " $ElmtTitre "_" ElmtTitre set LesTetes($m,$n) $ElmtTitre } } for {set p 0} {$p <= $n} {incr p} { set NvTitre "$LesTetes(0,$p) $LesTetes(1,$p)" set NvTitre [string trim $NvTitre] regsub -all " " $NvTitre "_" NvTitre set LesTitres($p) $NvTitre } #Data foreach Ligne [lrange $LesLignesDuFichier 2 end] { set n -1 foreach Elmt [split $Ligne ";"] { incr n if {$n==1} { set Gn $Elmt if {[regexp "/" $Gn]} { set Gn [lindex [split $Gn "/"] 0] } set Gn [string trim $Gn] lappend InterrogeCiblesSafeAcne(ListOf,Gn) $Gn continue } if {$n>1} { set Value $Elmt if {$Value>=1.2 || $Value<=-1.2} { set Cond $LesTitres($n) lappend InterrogeCiblesSafeAcne(ListOf,Cond) $Cond lappend InterrogeCiblesSafeAcne($Gn,LesCond) $Cond lappend InterrogeCiblesSafeAcne($Cond,LesGn) $Gn } } } } set InterrogeCiblesSafeAcne(ListOf,Gn) [lsort -unique $InterrogeCiblesSafeAcne(ListOf,Gn)] set InterrogeCiblesSafeAcne(ListOf,Cond) [lsort -unique $InterrogeCiblesSafeAcne(ListOf,Cond)] foreach Gn $InterrogeCiblesSafeAcne(ListOf,Gn) { set InterrogeCiblesSafeAcne($Gn,LesCond) [ListeSansDoublon $InterrogeCiblesSafeAcne($Gn,LesCond)] } foreach Cond $InterrogeCiblesSafeAcne(ListOf,Cond) { set InterrogeCiblesSafeAcne($Cond,LesGn) [ListeSansDoublon $InterrogeCiblesSafeAcne($Cond,LesGn)] } return [InterrogeCiblesSafeAcne $Qui $Quoi] } proc InterrogeClassificationTaxonomique {args} { global TableauClassificationTaxonomique if {$args == "unset"} { if {[info exists TableauClassificationTaxonomique]} { unset TableauClassificationTaxonomique } return "" } set Quoi [join $args ","] if {[info exists TableauClassificationTaxonomique($Quoi)]} { return [ElimineLesRedondancesDansUneListe [set TableauClassificationTaxonomique($Quoi)]] } set File "[RepTaxonomie]/ClassificationTaxonomique" if {![file exists $File]} {return} if {[info exists TableauClassificationTaxonomique($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauClassificationTaxonomique($File,EstCharge) 1 ChargeLaClassificationTaxonomique TableauClassificationTaxonomique if {[info exists TableauClassificationTaxonomique($Quoi)]} { return [ElimineLesRedondancesDansUneListe [set TableauClassificationTaxonomique($Quoi)]] } return } proc InterrogeClu {FileClu Qui Quoi} { global InterrogeClu if {[info exists InterrogeClu(FileClu)] && $InterrogeClu(FileClu)!=$FileClu} { unset InterrogeClu } if {[info exists InterrogeClu($Qui,$Quoi)]} { return $InterrogeClu($Qui,$Quoi) } if {[info exists InterrogeClu("EstCharge")]} { return "" } set InterrogeClu("EstCharge") 1 set InterrogeClu(FileClu) $FileClu foreach Ligne [LesLignesDuFichier $FileClu] { if {$Ligne==""} {continue} if {[regexp "^Number of clusters" $Ligne]} { set InterrogeClu(Nb,Clu) [StringApres "clusters : " dans $Ligne] } elseif {[regexp "^Cluster" $Ligne]} { set NumClu [StringApres "Cluster" dans $Ligne] set TailleClu [StringApres "size=" dans $Ligne] set InterrogeClu($NumClu,Taille) $TailleClu lappend InterrogeClu(ListOf,Clu) $NumClu } else { set Gn $Ligne lappend InterrogeClu($NumClu,ListOfGn) $Gn lappend InterrogeClu(AllClu,ListOfGn) $Gn lappend InterrogeClu($Gn,Clu) $NumClu } } return [InterrogeClu $FileClu $Qui $Quoi] } proc InterrogeClusters {{Qui ""} {Quoi ""} {Org ""}} { global InterrogeClusters if {[info exists InterrogeClusters($Qui,$Quoi,$Org)]} {return $InterrogeClusters($Qui,$Quoi,$Org)} if {[info exists InterrogeClusters("EstCharge",$Org)]} {return ""} set InterrogeClusters("EstCharge",$Org) 1 foreach File [glob -nocomplain "/genomics/link/SpliRetMouse/201404/clusters/*${Org}.fa" ] { set FileCourt [file tail $File] set LesMots [split $FileCourt "_"] set nbMot [llength $LesMots] if {$nbMot!=4} {return "$File a pas bon nombre de mot"} set Gn [lindex $LesMots 0] set Clu [lindex $LesMots 2] set Org [lindex $LesMots 3] regsub {\.fa} $Org "" Org lappend InterrogeClusters(ListOf,Clu,$Org) $Clu set InterrogeClusters($Clu,Gn,$Org) $Gn lappend InterrogeClusters($Gn,Clu,$Org) $Clu foreach Ligne [LesLignesDuFichier $File] { if {![regexp "^>" $Ligne]} {continue} set Var [string range [lindex [split $Ligne " "] 0] 1 end] lappend InterrogeClusters($Clu,Var,$Org) $Var lappend InterrogeClusters($Var,Clu,$Org) $Clu } } return [InterrogeClusters $Qui $Quoi $Org] } proc InterrogeClustersFusionnes {args} { global TableauClustersFusionnes if {$args == "unset"} { if {[info exists TableauClustersFusionnes]} { unset TableauClustersFusionnes } return "" } set Quoi [join $args ","] if {[info exists TableauClustersFusionnes($Quoi)]} { return [set TableauClustersFusionnes($Quoi)] } if {[info exists TableauClustersFusionnes(EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauClustersFusionnes(EstCharge) 1 ChargeClustersFusionnes TableauClustersFusionnes if {[info exists TableauClustersFusionnes($Quoi)]} { return [set TableauClustersFusionnes($Quoi)] } return } proc InterrogeContigAndProt {args} { global TableauInterrogationContigAndProt #unset #$Nom Contig BanqueId #$Nom Contig Access #$Nom Contig Taille #$Nom Contig Organisme #$Nom Contig Expect #$Nom Contig Identity #$Nom Contig NbAli #$Nom Protein BanqueId #$Nom Protein Access #$Nom Protein Taille #$Nom Protein Organisme #$Nom Protein Expect #$Nom Protein Score #$Nom Protein Identity #$Nom Protein NbAli #$Nom Protein Distance if {$args == "unset"} { if {[info exists TableauInterrogationContigAndProt]} {unset TableauInterrogationContigAndProt} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationContigAndProt($Quoi)]} { return [set TableauInterrogationContigAndProt($Quoi)] } set FichierContigAndProt "[RepertoireDuGenome]/fiches/ContigAndProt" ###################CHARGE ContigAndProt######################### if { [file exists $FichierContigAndProt] && ![info exists TableauInterrogationContigAndProt($FichierContigAndProt,EstCharge)]} { set TableauInterrogationContigAndProt($FichierContigAndProt,EstCharge) 1 ChargeContigAndProt TableauInterrogationContigAndProt $FichierContigAndProt } if {![info exists TableauInterrogationContigAndProt($Quoi)]} {return} return [set TableauInterrogationContigAndProt($Quoi)] } proc InterrogeContigsDesChromosomes {args} { global TableauContigsDesChromosomes #LesChromosomes #LesContigs #$Chromo LesContigs #$Chromo Taille #$Contig if {$args == "unset"} { if {[info exists TableauContigsDesChromosomes]} {unset TableauContigsDesChromosomes} return } set Quoi [join $args ","] if {[info exists TableauContigsDesChromosomes($Quoi)]} {return [set TableauContigsDesChromosomes($Quoi)]} set File "[HumanGenomeDir]/Localisation/seq_contig.md" if {![file exists $File]} {return} ###################CHARGE ContigsDesChromosomes######################### if {[info exists TableauContigsDesChromosomes($File,EstCharge)]} {return} set TableauContigsDesChromosomes($File,EstCharge) 1 ChargeContigsDesChromosomes TableauContigsDesChromosomes $File if {[info exists TableauContigsDesChromosomes($Quoi)]} {return [set TableauContigsDesChromosomes($Quoi)]} return } proc InterrogeCopainsDesCompulsory {{Qui ""} {Quoi ""}} { global InterrogeCopainsDesCompulsory if {$Quoi==""} {set Quoi "Nom"} if {[info exists InterrogeCopainsDesCompulsory($Qui,$Quoi)]} { #if {[PourWscope]} {return "

[join $InterrogeCopainsDesCompulsory($Qui,$Quoi) "\n"]

"} return $InterrogeCopainsDesCompulsory($Qui,$Quoi) } if {[info exists InterrogeCopainsDesCompulsory("EstCharge")]} { return "" } set InterrogeCopainsDesCompulsory("EstCharge") 1 #attention certains n'ont pas gn set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterSsBigClu" set Seuil 8 set I 0 foreach Nom [ListOfCompulsoryGenes] { set LesGnsDuNom {} #Espionne "$Nom" set InterrogeCopainsDesCompulsory($Nom,Boite) {} foreach File [glob -nocomplain "$Repertoire/${Nom}-*-lesbestcops"] { #Espionne "File $File" if {[regexp "AFFX" $File]} {Espionne "Attention AFFX"} set premiereligne 1 foreach Ligne [LesLignesDuFichier $File] { if {$premiereligne} { set premiereligne 0 scan $Ligne "%s %s" nbdecombinaisoncompul bidon set TabCompul($Nom) $nbdecombinaisoncompul } set LesMots [split $Ligne " "] set nb [lindex $LesMots 0] if {$nb < $Seuil} {continue} #Espionne "nb $nb" set EviPs [lindex $LesMots 1] if {[regexp "AFFX" EviPs]} {Espionne "Attention2"} set LesEviPs [split $EviPs "-"] set Boite [lindex $LesEviPs 0] set Gn [lindex $LesMots 2] lappend InterrogeCopainsDesCompulsory($Nom,Boite) $Boite lappend InterrogeCopainsDesCompulsory($Boite,Nom) $Nom set InterrogeCopainsDesCompulsory($Boite,Nom) [lsort -unique $InterrogeCopainsDesCompulsory($Boite,Nom)] #Espionne "$Boite $Gn" } } set InterrogeCopainsDesCompulsory($Nom,Boite) [lsort -unique $InterrogeCopainsDesCompulsory($Nom,Boite)] } return [InterrogeCopainsDesCompulsory $Qui $Quoi] } proc InterrogeCorresEnsEtOS {{Qui ""} {Quoi ""}} { global InterrogeCorresEnsEtOS if {[info exists InterrogeCorresEnsEtOS($Qui,$Quoi)]} {return $InterrogeCorresEnsEtOS($Qui,$Quoi)} if {[info exists InterrogeCorresEnsEtOS("EstCharge")]} {return ""} set InterrogeCorresEnsEtOS("EstCharge") 1 foreach Ligne [LesLignesDuFichier "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/CorresEnsEtOS"] { foreach {Ens Genre Espece} [split $Ligne " "] { set OS "$Genre $Espece" set InterrogeCorresEnsEtOS($OS,Ens) $Ens set InterrogeCorresEnsEtOS($Ens,OS) $OS } } return [InterrogeCorresEnsEtOS $Qui $Quoi] } proc InterrogeCorresJuncVar {{Qui ""} {Quoi ""} {File ""}} { global InterrogeCorresJuncVar if {$Qui==""} { set Qui "ListOf" ; set Quoi "Junction" } if {[info exists InterrogeCorresJuncVar($Qui,$Quoi,$File)]} {return $InterrogeCorresJuncVar($Qui,$Quoi,$File)} if {[info exists InterrogeCorresJuncVar("EstCharge",$File)]} {return ""} set InterrogeCorresJuncVar("EstCharge",$File) 1 foreach Ligne [LesLignesDuFichier $File] { set MotsDeLaLigne [split $Ligne "\t"] set Junction [lindex $MotsDeLaLigne 0] set LesVarJunc [lindex $MotsDeLaLigne 1] lappend InterrogeCorresJuncVar(ListOf,Junction,$File) $Junction set InterrogeCorresJuncVar($Junction,VarJunc,$File) $LesVarJunc foreach VarJunc [split $LesVarJunc " "] { set InterrogeCorresJuncVar($VarJunc,Junction,$File) $Junction } } return [InterrogeCorresJuncVar $Qui $Quoi $File] } proc InterrogeDefinitionsConsensus {args} { global TableauDefinitionConsensus #unset #$Nom Definition #LesNoms Espionne coucou1 if {$args == "unset"} { if {[info exists TableauDefinitionConsensus]} {unset TableauDefinitionConsensus} return "" } set Fichier "[RepertoireDuGenome]/fiches/DefinitionsConsensus" if {![file exists $Fichier]} {Espionne coucou ; return} set Quoi [join $args ","] if {[info exists TableauDefinitionConsensus($Quoi)]} {return [set TableauDefinitionConsensus($Quoi)]} if {[info exists TableauDefinitionConsensus(EstCharge)]} {return} ###################CHARGE Definiton consensus######################### set TableauDefinitionConsensus(EstCharge) 1 ChargeDefinitionsConsensus TableauDefinitionConsensus $Fichier if {[info exists TableauDefinitionConsensus($Quoi)]} {return [set TableauDefinitionConsensus($Quoi)]} return } proc InterrogeDevStage {args} { global TableauInterrogationDevStage #unset #LesDevStages #LesNoms #$Nom LesDevStages #$Nom LesEST #EST $Access LesDevStages #EST $Access LesNoms #EST $Access DevStage $DevStage n #DevStage $DevStage LesNoms #DevStage $DevStage LesEST #DevStage $DevStage n #$Nom DevStage $DevStage n #$Nom DevStage $DevStage LesEST #$Nom DevStage $DevStage EST $Access n if {$args == "unset"} { if {[info exists TableauInterrogationDevStage]} { unset TableauInterrogationDevStage } return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationDevStage($Quoi)]} { return [set TableauInterrogationDevStage($Quoi)] } set File1 "[RepertoireDuGenome]/fiches/DevStage" ###################CHARGE FichierExonicMap######################### if {[file exists $File1] && ![info exists TableauInterrogationDevStage($File1,EstCharge)]} { set TableauInterrogationDevStage($File1,EstCharge) 1 ChargeDevStage TableauInterrogationDevStage $File1 } set File2 "[RepertoireDuGenome]/fiches/EffectifsDesDevStage" if {[file exists $File2] && ![info exists TableauInterrogationDevStage($File2,EstCharge)]} { set TableauInterrogationDevStage($File2,EstCharge) 1 ChargeEffectifDesDevStage TableauInterrogationDevStage $File2 } if {[info exists TableauInterrogationDevStage($Quoi)]} { return [set TableauInterrogationDevStage($Quoi)] } return } proc InterrogeDisEMBL {args} { #Permet de questionner les infos de DisEMBL #Voir aussi decharge et charge global InfoDisEMBL #Utilisation: #On demande set ListeLOOPS [InterrogeDisEMBL $File LOOPS] #on boucle sur #foreach Indice $ListeLOOPS { # et on recupere la valeur par # set Valeur [InterrogeDisEMBL $File LOOPS $Indice] #} #Arguments: ########### #$Fichier LOOPS - Les valeurs de i #$Fichier LOOPS $i - Valeur de LOOPS pour $i #$Fichier HOTLOOPS - Les valeurs de i #$Fichier HOTLOOPS $i - Valeur de HOTLOOPS pour $i #$Fichier REM465 - Les valeurs de i #$Fichier REM465 $i - Valeur de REM465 pour $i if {$args == "unset"} { if {[info exists InfoDisEMBL]} {array unset InfoDisEMBL} return "" } #1 On test si c deja en memoire et si oui on retourne la valeur demandee set Quoi [join $args ","] if {[info exists InfoDisEMBL($Quoi)]} {return [set InfoDisEMBL($Quoi)]} #2 On recupere le fichier (1er argument) set FichierACharger [lindex $args 0] if {! [info exists InfoDisEMBL($FichierACharger,EstCharge)]} { set InfoDisEMBL($FichierACharger,EstCharge) 0 } #3 On decharge le cas echeant if {$Quoi=="$FichierACharger,Decharge"} { DechargeDisEMBL $FichierACharger return "" } if { [info exists InfoDisEMBL($FichierACharger,EstVide)]} {return ""} if { [info exists InfoDisEMBL($Quoi)]} {return [set InfoDisEMBL($Quoi)]} #4 On charge les resultats if {! [info exists InfoDisEMBL($FichierACharger,EstCharge)] || [set InfoDisEMBL($FichierACharger,EstCharge)]=="0"} { set InfoDisEMBL($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeDisEMBL InfoDisEMBL $FichierACharger] if {$ResultatCharge != ""} { set InfoDisEMBL($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoDisEMBL($Quoi)]} {return ""} return [set InfoDisEMBL($Quoi)] } proc InterrogeDomaines {args} { global TableauDomaines #LesNoms #$Nom LesDomaines if {$args == "unset"} { if {[info exists TableauDomaines]} {unset TableauDomaines} return "" } set Quoi [join $args ","] if {[info exists TableauDomaines($Quoi)]} {return [set TableauDomaines($Quoi)]} if {[info exists TableauDomaines(EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauDomaines(EstCharge) 1 ChargeDomaines TableauDomaines if {[info exists TableauDomaines($Quoi)]} {return [set TableauDomaines($Quoi)]} return } proc InterrogeECCpdRn {args} { #LesElements #Element $Element LesPathway global TableauInterrogationECCpdRn if {$args == "unset"} { if {[info exists TableauInterrogationECCpdRn]} {unset TableauInterrogationECCpdRn} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationECCpdRn($Quoi)]} {return [set TableauInterrogationECCpdRn($Quoi)]} if {[info exists TableauInterrogationECCpdRn(EstCharge)]} {return} ###################CHARGE Pathway######################### ChargeECCpdRn TableauInterrogationECCpdRn set TableauInterrogationECCpdRn(EstCharge) 1 if {![info exists TableauInterrogationECCpdRn($Quoi)]} {return} return [set TableauInterrogationECCpdRn($Quoi)] } proc InterrogeECDuPathway {args} { #Pathway $Pathway LesEC #Pathway $Pathway EC $EC LesDefinitions #Pathway $Pathway Definition $Definition EC global TableauInterrogationECDuPathway if {$args == "unset"} { if {[info exists TableauInterrogationECDuPathway]} {unset TableauInterrogationECDuPathway} return "" } set Pathway [lindex $args 1] set Quoi [join $args ","] if {[info exists TableauInterrogationECDuPathway($Quoi)]} {return [set TableauInterrogationECDuPathway($Quoi)]} if {[info exists TableauInterrogationECDuPathway($Pathway,EstCharge)]} {return} ###################CHARGE Pathway######################### ChargeECDuPathway TableauInterrogationECDuPathway $Pathway set TableauInterrogationECDuPathway($Pathway,EstCharge) 1 if {![info exists TableauInterrogationECDuPathway($Quoi)]} {return} return [set TableauInterrogationECDuPathway($Quoi)] } proc InterrogeEvidenceTable {{Qui ""} {Quoi ""}} { #Interroge la table score_types global InterrogeEvidenceTable if {[info exists InterrogeEvidenceTable($Qui,$Quoi)]} { return $InterrogeEvidenceTable($Qui,$Quoi) } if {[info exists InterrogeEvidenceTable("EstCharge")]} { return "" } set InterrogeEvidenceTable("EstCharge") 1 CanalSqlString foreach {ScoId ScoTy} [SqlExec "select * from network.score_types" "GetList"] { set InterrogeEvidenceTable($ScoId,ScoTy) $ScoTy set InterrogeEvidenceTable($ScoTy,ScoId) $ScoId lappend InterrogeEvidenceTable(ListOf,ScoId) $ScoId lappend InterrogeEvidenceTable(ListOf,ScoTy) $ScoTy } CanalSqlDisconnect return [InterrogeEvidenceTable $Qui $Quoi] } proc InterrogeExAs {{Qui ""} {Quoi ""}} { global InterrogeExAs if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "AnalSoft" } if {[info exists InterrogeExAs($Qui,$Quoi)]} { return $InterrogeExAs($Qui,$Quoi) } if {[info exists InterrogeExAs("EstCharge")]} { return "" } set InterrogeExAs("EstCharge") 1 set FichierNormal "[RepertoireDuGenome]/transcriptomique/MetaCluster/ExAs" #set FichierNormal "[RepertoireDuGenome]/transcriptomique/ConeSpe/Hierarchisation/ExAs" set LesTetes "Experience AnalysisSoftware" set InterrogeExAs(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierNormal] { if {$Ligne==""} {continue} set LesElmts [split $Ligne "\t"] set Exp [lindex $LesElmts 0] set AnalSoft [lindex $LesElmts 1] lappend InterrogeExAs(ListOf,Exp) $Exp lappend InterrogeExAs(ListOf,AnalSoft) $AnalSoft lappend InterrogeExAs($Exp,AnalSoft) $AnalSoft foreach Tete $LesTetes Elmt $LesElmts { set InterrogeExAs($Exp,$Tete) $Elmt } } return [InterrogeExAs $Qui $Quoi] } proc InterrogeExCs {{Qui ""} {Quoi ""}} { global InterrogeExCs if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "ClusSoft" } if {[info exists InterrogeExCs($Qui,$Quoi)]} { return $InterrogeExCs($Qui,$Quoi) } if {[info exists InterrogeExCs("EstCharge")]} { return "" } set InterrogeExCs("EstCharge") 1 set FichierClust "[RepertoireDuGenome]/transcriptomique/MetaCluster/ExCs" #set FichierClust "[RepertoireDuGenome]/transcriptomique/ConeSpe/Hierarchisation/ExCs" set LesTetes "Experience ClusterSoftware" set InterrogeExCs(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierClust] { if {$Ligne==""} {continue} set LesElmts [split $Ligne "\t"] set Exp [lindex $LesElmts 0] set ClusSoft [lindex $LesElmts 1] lappend InterrogeExCs(ListOf,Exp) $Exp lappend InterrogeExCs(ListOf,ClusSoft) $ClusSoft lappend InterrogeExCs($Exp,ClusSoft) $ClusSoft foreach Tete $LesTetes Elmt $LesElmts { set InterrogeExCs($Exp,$Tete) $Elmt } } return [InterrogeExCs $Qui $Quoi] } proc InterrogeFichierAffyAnnot {File Qui Quoi} { global InterrogeFichierAffyAnnot if {[info exists InterrogeFichierAffyAnnot(File)] && $InterrogeFichierAffyAnnot(File)!=$File} { unset InterrogeFichierAffyAnnot } if {[info exists InterrogeFichierAffyAnnot($Qui,$Quoi)]} { return $InterrogeFichierAffyAnnot($Qui,$Quoi) } if {[info exists InterrogeFichierAffyAnnot("EstCharge")]} { return "" } set InterrogeFichierAffyAnnot("EstCharge") 1 set InterrogeFichierAffyAnnot(File) $File foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^#%" $Ligne]} { set LesMots [split $Ligne "="] set Tete [lindex $LesMots 0] regsub "#%" $Tete "" Tete set Version [lindex $LesMots 1] set InterrogeFichierAffyAnnot($Tete,version) $Version } } set LesHeaders [TabulonsSansQuote $File "," ";" " " "GetListOfHeaders"] set LesLignesValues [TabulonsSansQuote $File "," ";" " " "GetListOfValues"] foreach LigneValues $LesLignesValues { set LesMots [split $LigneValues ";"] set i -1 foreach Mot $LesMots { incr i if {$i==0} { set Id $Mot lappend InterrogeFichierAffyAnnot(ListOf,Id) $Id continue } set InterrogeFichierAffyAnnot($Id,[lindex $LesHeaders $i]) $Mot } } return [InterrogeFichierAffyAnnot $File $Qui $Quoi] } proc InterrogeFichierAffyAnnotRapide {File Qui Quoi} { #N'interroge que l'entete (les lignes commençant par #%) #Evite d'appeler InterrogeFichierAffyAnnot, qui est long, quand on veut seulement interroger l'entete global InterrogeFichierAffyAnnotRapide if {[info exists InterrogeFichierAffyAnnotRapide(File)] && $InterrogeFichierAffyAnnotRapide(File)!=$File} { unset InterrogeFichierAffyAnnotRapide } if {[info exists InterrogeFichierAffyAnnotRapide($Qui,$Quoi)]} { return $InterrogeFichierAffyAnnotRapide($Qui,$Quoi) } if {[info exists InterrogeFichierAffyAnnotRapide("EstCharge")]} { return "" } set InterrogeFichierAffyAnnotRapide("EstCharge") 1 set InterrogeFichierAffyAnnotRapide(File) $File foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^#%" $Ligne]} { set LesMots [split $Ligne "="] set Tete [lindex $LesMots 0] regsub "#%" $Tete "" Tete set Version [lindex $LesMots 1] set InterrogeFichierAffyAnnotRapide($Tete,version) $Version } } return [InterrogeFichierAffyAnnotRapide $File $Qui $Quoi] } proc InterrogeFichierAffyRMA {args} { global TabRMA #$Fichier $Nom Val #$Fichier ValMax #$Fichier ValMin if {$args == "unset"} { if {[info exists TabRMA]} {unset TabRMA} return "" } set File [lindex $args 0] set Quoi [join $args ","] if {[info exists TabRMA($Quoi)]} {return [set TabRMA($Quoi)]} if {[info exists TabRMA($File,EstCharge)]} {Espionne "estcharge !";return} set FichierACharger [lindex $args 0] ################### CHARGE #################### set TabRMA(EstCharge) 1 ChargeFichierAffyRMA TabRMA $FichierACharger if {[info exists TabRMA($Quoi)]} {return [set TabRMA($Quoi)]} return } proc InterrogeFichierBestNMavecDef {args} { global TabNMDef #$Fichier $DD NM #$Fichier $DD Def if {$args == "unset"} { if {[info exists TabNMDef]} {unset TabNMDef} return "" } set Quoi [join $args ","] if {[info exists TabNMDef($Quoi)]} {return [set TabNMDef($Quoi)]} if {[info exists TabNMDef(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE FichierDDTARScores #################### set TabNMDef(EstCharge) 1 ChargeFichierBestNMavecDef TabNMDef $FichierACharger if {[info exists TabNMDef($Quoi)]} {return [set TabNMDef($Quoi)]} return } proc InterrogeFichierCentromere {args} { global TabCentro #$Fichier $Chro DebutCentro #$Fichier $Chro FinCentro if {$args == "unset"} { if {[info exists TabCentro]} {unset TabCentro} return "" } set Quoi [join $args ","] if {[info exists TabCentro($Quoi)]} {return [set TabCentro($Quoi)]} set File [lindex $args 0] if {![file exists $File]} {Espionne "$File does not exist";return} if {[info exists TabCentro($File,EstCharge)]} {Espionne "coucou TabCentro est charge";return} ################### CHARGE #################### set TabCentro($File,EstCharge) 1 ChargeFichierCentromeres TabCentro $File if {[info exists TabCentro($Quoi)]} {return [set TabCentro($Quoi)]} return } proc InterrogeFichierCompletDesPFAMUniques {args} { global TabPFAMComplet #$PFAM Definition #$PFAM Nombre #$PFAM Liste if {$args == "unset"} { if {[info exists TabPFAMComplet]} {unset TabPFAMComplet} return "" } set Quoi [join $args ","] if {[info exists TabPFAMComplet($Quoi)]} {return [set TabPFAMComplet($Quoi)]} if {[info exists TabPFAMComplet(EstCharge)]} {return} ################### CHARGE FichierCompletDesPFAMUniques #################### set TabPFAMComplet(EstCharge) 1 ChargeFichierCompletDesPFAMUniques TabPFAMComplet if {[info exists TabPFAMComplet($Quoi)]} {return [set TabPFAMComplet($Quoi)]} return } proc InterrogeFichierCourbeCGH {args} { global TabPlot #unset #$File Chromosome $Chrom LesPos #$File Chromosome $Chrom $PosMid #$File VMax #$File VMin if {[regexp "unset" $args]} { if {[info exists TabPlot]} {unset TabPlot} return "" } set Quoi [join $args ","] if {[info exists TabPlot($Quoi)]} {return [set TabPlot($Quoi)]} set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TabPlot($File,EstCharge)]} {Espionne coucou;return} set FichierACharger [lindex $args 0] ################### CHARGE #################### set TabPlot($File,EstCharge) 1 #ChargeFichierCourbeCGH TabPlot $FichierACharger ChargeFichierCourbeCGH TabPlot $File if {[info exists TabPlot($Quoi)]} {return [set TabPlot($Quoi)]} return } proc InterrogeFichierDDTARScores {args} { global TabDDComplet #$Fichier $DD $TAR IdGlob #$Fichier $DD $TAR CoverS #$Fichier $DD $TAR CoverQ if {$args == "unset"} { if {[info exists TabDDComplet]} {unset TabDDComplet} return "" } set Quoi [join $args ","] if {[info exists TabDDComplet($Quoi)]} {return [set TabDDComplet($Quoi)]} if {[info exists TabDDComplet(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE FichierDDTARScores #################### set TabDDComplet(EstCharge) 1 ChargeFichierDDTARScores TabDDComplet $FichierACharger if {[info exists TabDDComplet($Quoi)]} {return [set TabDDComplet($Quoi)]} return } proc InterrogeFichierDDUniques3T {args} { global TabDDUniquesComplet #$Fichier $N AccProt #$Fichier $N DefProt #$Fichier $N AccRNA #$Fichier $N DefRNA #$Fichier $N Warning #$Fichier $N DifE #$Fichier $N ProfE #$Fichier $N DifS #$Fichier $N ProfS #$Fichier $N DifU #$Fichier $N ProfU #$Fichier $N $DifMoy #$Fichier $N Pmoy if {$args == "unset"} { if {[info exists TabDDUniquesComplet]} {unset TabDDUniquesComplet} return "" } set Quoi [join $args ","] if {[info exists TabDDUniquesComplet($Quoi)]} {return [set TabDDUniquesComplet($Quoi)]} if {[info exists TabDDUniquesComplet(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE FichierCompletDesDDUniques #################### set TabDDUniquesComplet(EstCharge) 1 ChargeFichierDDUniques3T TabDDUniquesComplet $FichierACharger if {[info exists TabDDUniquesComplet($Quoi)]} {return [set TabDDUniquesComplet($Quoi)]} return } proc InterrogeFichierDataAffyPourTous3T {args} { global TabAffyComplet #$Fichier $PAB Code #$Fichier $PAB Def #$Fichier $PAB DetN #$Fichier $PAB DetE #$Fichier $PAB DetS #$Fichier $PAB DetU #$Fichier $PAB IntN #$Fichier $PAB IntE #$Fichier $PAB IntS #$Fichier $PAB IntU #$Fichier $PAB FE #$Fichier $PAB PE #$Fichier $PAB FS #$Fichier $PAB PS #$Fichier $PAB FU #$Fichier $PAB PU #$Fichier $PAB FoldMoy #$Fichier $PAB ProfMoy if {$args == "unset"} { if {[info exists TabAffyComplet]} {unset TabAffyComplet} return "" } set Quoi [join $args ","] if {[info exists TabAffyComplet($Quoi)]} {return [set TabAffyComplet($Quoi)]} if {[info exists TabAffyComplet(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE FichierCompletDesAffyUniques #################### set TabAffyComplet(EstCharge) 1 ChargeFichierDataAffyPourTous3T TabAffyComplet $FichierACharger if {[info exists TabAffyComplet($Quoi)]} {return [set TabAffyComplet($Quoi)]} return } proc InterrogeFichierExonicMap {args} { global TableauFichierExonicMap if {$args == "unset"} { if {[info exists TableauFichierExonicMap]} {unset TableauFichierExonicMap} return "" } #unset #$FichierEM LesWarning #$FichierEM NbCycles #$FichierEM Nom #$FichierEM Query FichierTFA #$FichierEM Query SeqTFA #$FichierEM Query Type #$FichierEM Query Taille #$FichierEM Query Warning #$FichierEM LesRangs #$FichierEM Rang $Rang LesWarning #$FichierEM Rang $Rang NbAliTot #$FichierEM Rang $Rang NbAreas #$FichierEM Rang $Rang NbExonicAreas #$FichierEM Rang $Rang NbAbsentAreas #$FichierEM Rang $Rang NbPolyLocAreas #$FichierEM Rang $Rang Chromosome #$FichierEM Rang $Rang Contig #$FichierEM Rang $Rang ContigFragments #$FichierEM Rang $Rang ContigLocalisation Debut #$FichierEM Rang $Rang ContigLocalisation Fin #$FichierEM Rang $Rang Sens #$FichierEM Rang $Rang LesOrientations #$FichierEM Rang $Rang Area $nArea Type #$FichierEM Rang $Rang Area $nArea $Type n #$FichierEM Rang $Rang $Type $nType DQ #$FichierEM Rang $Rang $Type $nType FQ #$FichierEM Rang $Rang $Type $nType Taille #$FichierEM Rang $Rang $Type $nType DS #$FichierEM Rang $Rang $Type $nType FS #$FichierEM Rang $Rang $Type $nType Orientation #$FichierEM Rang $Rang $Type $nType Sens #$FichierEM Rang $Rang $Type $nType nAli #$FichierEM Rang $Rang $Type $nType nAliTot #$FichierEM Rang $Rang $Type $nType Identity #$FichierEM Rang $Rang $Type $nType nContigu set Quoi [join $args ","] if {[info exists TableauFichierExonicMap($Quoi)]} { return [set TableauFichierExonicMap($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauFichierExonicMap($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauFichierExonicMap($File,EstCharge) 1 ChargeExonicMap TableauFichierExonicMap $File if {[info exists TableauFichierExonicMap($Quoi)]} {return [set TableauFichierExonicMap($Quoi)]} return } proc InterrogeFichierFinal {args} { global TabFinal #--- #$DD PMoy #$DD IMoy #--- #$DD AccProt #$DD DefProt #$DD GO #$DD Pathway #$DD PFAM #$DD Papier #$DD All if {$args == "unset"} { if {[info exists TabFinal]} {unset TabFinal} return "" } set Quoi [join $args ","] if {[info exists TabFinal($Quoi)]} {return [set TabFinal($Quoi)]} if {[info exists TabFinal(EstCharge)]} {return} ################### CHARGE FichierCompletDesPFAMUniques #################### set TabFinal(EstCharge) 1 ChargeFichierFinal TabFinal if {[info exists TabFinal($Quoi)]} {return [set TabFinal($Quoi)]} return } proc InterrogeFichierHumanChromos {args} { global TabChro #$Fichier $Chro Taille if {$args == "unset"} { if {[info exists TabChro]} {unset TabChro} return "" } set Quoi [join $args ","] if {[info exists TabChro($Quoi)]} {return [set TabChro($Quoi)]} set File [lindex $args 0] if {![file exists $File]} {Espionne "$File does not exist";return} if {[info exists TabChro($File,EstCharge)]} {Espionne "est charge";return} ################### CHARGE #################### set TabChro($File,EstCharge) 1 ChargeFichierHumanChromos TabChro $File if {[info exists TabChro($Quoi)]} {return [set TabChro($Quoi)]} return } proc InterrogeFichierLoc {args} { global TableauLocalisationDesPAB #unset #$File Chromosome $Chrom LesNoms #$File Chromosome $Chrom $Nom #$File LesNoms #$File Nom $Nom ##Out Detail d'une localisation => Liste avec comme elements : #0:Chro #1:Deb #2:Fin #3:Nom #4:Id #5:Other if {$args == "unset"} { if {[info exists TableauLocalisationDesPAB]} {unset TableauLocalisationDesPAB} return } set Quoi [join $args ","] if {[info exists TableauLocalisationDesPAB($Quoi)]} { return [set TableauLocalisationDesPAB($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauLocalisationDesPAB($File,EstCharge)]} {return} ###################CHARGE Localisation des boites sur genome######################### set TableauLocalisationDesPAB($File,EstCharge) 1 ChargeFichierLoc TableauLocalisationDesPAB $File if {[info exists TableauLocalisationDesPAB($Quoi)]} { return [set TableauLocalisationDesPAB($Quoi)] } return } proc InterrogeFichierMapViewer {args} { global TableauFichierMapViewer #$FichierMV LesChromosomes #$FichierMV Chromosome $Chromosome LesElements #$FichierMV Chromosome $Chromosome Element $Element LesLocalisations #Details : #0 : Id etc.. #1 : LesInfos #2 : Chromosome #3 : Debut #4 : Fin #5 : Taille #6 : Sens if {$args == "unset"} { if {[info exists TableauFichierMapViewer]} {unset TableauFichierMapViewer} return } set Quoi [join $args ","] if {[info exists TableauFichierMapViewer($Quoi)]} { return [ElimineLesRedondancesDansUneListe [set TableauFichierMapViewer($Quoi)]] } set File [lindex $args 0] if {![file exists $File]} {set File "[HumanGenomeDir]/Localisation/$File"} if {![file exists $File]} {return} set NameFile [file tail $File] set nChromo [NumeroDuChromosome [lindex $args 2]] if {[info exists TableauFichierMapViewer($NameFile,$nChromo,EstCharge)]} {return} ###################CHARGE FichierMapViewer######################### set TableauFichierMapViewer($NameFile,$nChromo,EstCharge) 1 ChargeFichierMapViewer TableauFichierMapViewer $File $nChromo if {[info exists TableauFichierMapViewer($Quoi)]} { return [set TableauFichierMapViewer($Quoi)] } return } proc InterrogeFichierOutRepeatMasker {args} { #FichierOUT LesRepeats #FichierOUT LesRegionsMasquees #FichierOUT Repeat $Repeat LesRegions #FichierOUT Debut $Debut Fin $Fin Repeat global TableauFichierOutRepeatMasker if {$args == "unset"} { if {[info exists TableauFichierOutRepeatMasker]} {unset TableauFichierOutRepeatMasker} return } set Quoi [join $args ","] if {[info exists TableauFichierOutRepeatMasker($Quoi)]} {return [set TableauFichierOutRepeatMasker($Quoi)]} set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauFichierOutRepeatMasker($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauFichierOutRepeatMasker($File,EstCharge) 1 ChargeFichierOutRepeatMasker TableauFichierOutRepeatMasker $File if {[info exists TableauFichierOutRepeatMasker($Quoi)]} {return [set TableauFichierOutRepeatMasker($Quoi)]} return } proc InterrogeFichierRefLink {args} { global TabCentro #$Fichier $NM NP #$Fichier $NM GN #$Fichier $NP NM #$Fichier $NP GN if {$args == "unset"} { if {[info exists TabRefLink]} {unset TabRefLink} return "" } set Quoi [join $args ","] if {[info exists TabRefLink($Quoi)]} {return [set TabRefLink($Quoi)]} if {[info exists TabRefLink(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE #################### set TabRefLink(EstCharge) 1 ChargeFichierRefLink TabRefLink $FichierACharger if {[info exists TabRefLink($Quoi)]} {return [set TabRefLink($Quoi)]} return } proc InterrogeFichierSEG {args} { global TabPlot #unset #$File Chromosome $Chrom LesPos #$file $Chromosome $PosMid Val #$File VMax #$File VMin #$File Chromosome $Chrom LesDebFin if {[regexp "unset" $args]} { if {[info exists TabPlot]} {unset TabPlot} return "" } set Quoi [join $args ","] if {[info exists TabPlot($Quoi)]} {return [set TabPlot($Quoi)]} set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TabPlot($File,EstCharge)]} {Espionne coucou;return} ################### CHARGE #################### set TabPlot($File,EstCharge) 1 ChargeFichierSEG TabPlot $File if {[info exists TabPlot($Quoi)]} {return [set TabPlot($Quoi)]} return } proc InterrogeFichierTotalDataDD {args} { global TabDDComplet #$Fichier $PAB N #$Fichier $PAB JR #$Fichier $PAB Code #$Fichier $PAB User #$Fichier $PAB Bande #$Fichier $PAB AccProt #$Fichier $PAB DefProt #$Fichier $PAB AccRNA #$Fichier $PAB DefRNA #$Fichier $PAB Profil #$Fichier $PAB ProfCons if {$args == "unset"} { if {[info exists TabDDComplet]} {unset TabDDComplet} return "" } set Quoi [join $args ","] if {[info exists TabDDComplet($Quoi)]} {return [set TabDDComplet($Quoi)]} if {[info exists TabDDComplet(EstCharge)]} {return} set FichierACharger [lindex $args 0] ################### CHARGE FichierCompletDesDDUniques #################### set TabDDComplet(EstCharge) 1 ChargeFichierTotalDataDD TabDDComplet $FichierACharger if {[info exists TabDDComplet($Quoi)]} {return [set TabDDComplet($Quoi)]} return } proc InterrogeFoldIndex {args} { #Permet de questionner les infos de FoldIndex #Voir aussi decharge et charge global InfoFoldIndex #Utilisation: #On demande set ListeLOOPS [InterrogeDisEMBL $File LOOPS] #on boucle sur #foreach Indice $ListeLOOPS { # et on recupere la valeur par # set Valeur [InterrogeDisEMBL $File LOOPS $Indice] #} #Arguments: ########### #$Fichier pds - Les valeurs de i #$Fichier pds $i - Valeur de LOOPS pour $i if {$args == "unset"} { if {[info exists InfoFoldIndex]} {array unset InfoFoldIndex} return "" } #1 On test si c deja en memoire et si oui on retourne la valeur demandee set Quoi [join $args ","] if {[info exists InfoFoldIndex($Quoi)]} {return [set InfoFoldIndex($Quoi)]} #2 On recupere le fichier (1er argument) set FichierACharger [lindex $args 0] if {! [info exists InfoFoldIndex($FichierACharger,EstCharge)]} {set InfoFoldIndex($FichierACharger,EstCharge) 0} #3 On decharge le cas echeant if {$Quoi=="$FichierACharger,Decharge"} { DechargeFoldIndex $FichierACharger return "" } if { [info exists InfoFoldIndex($FichierACharger,EstVide)]} {return ""} if { [info exists InfoFoldIndex($Quoi)]} {return [set InfoFoldIndex($Quoi)]} #4 On charge les resultats if {! [info exists InfoFoldIndex($FichierACharger,EstCharge)] || [set InfoFoldIndex($FichierACharger,EstCharge)]=="0"} { set InfoFoldIndex($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeFoldIndex InfoFoldIndex $FichierACharger] if {$ResultatCharge != ""} { set InfoFoldIndex($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoFoldIndex($Quoi)]} { return ""} return [set InfoFoldIndex($Quoi)] } proc InterrogeGSEAGeneSets {Qui Quoi} { set File "/biolo/GSEA/GeneSets/msigdb.v3.0.symbols.gmt" global InterrogeGSEAGeneSets if {[info exists InterrogeGSEAGeneSets($Qui,$Quoi)]} { return $InterrogeGSEAGeneSets($Qui,$Quoi) } if {[info exists InterrogeGSEAGeneSets("EstCharge")]} { return "" } set InterrogeGSEAGeneSets("EstCharge") 1 foreach Ligne [LesLignesDuFichier $File] { set LesMots [split $Ligne "\t"] set Id [lindex $LesMots 0] set Link [lindex $LesMots 1] set LesGns [lrange $LesMots 2 end] set InterrogeGSEAGeneSets($Id,link) $Link set InterrogeGSEAGeneSets($Id,LesGns) $LesGns set InterrogeGSEAGeneSets($Id,NbGn) [llength $LesGns] } return [InterrogeGSEAGeneSets $Qui $Quoi] } proc InterrogeGeneName {args} { global TableauInterrogationGeneName #unset #LesNoms #$Nom LesGeneNames #$Nom LesProteines #Protein $Access LesGeneNames #Protein $Access LesGeneNames #Protein $Access LesNoms #GeneName $GeneName LesNoms #GeneName $GeneName LesProteines #GeneName $GeneName n #LesGeneNames #$Nom GeneName $GeneName n #$Nom GeneName $GeneName LesProteines #$Nom GeneName $GeneName Protein $Access n #Protein $Access GeneName $GeneName n if {$args == "unset"} { if {[info exists TableauInterrogationGeneName]} { unset TableauInterrogationGeneName } return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationGeneName($Quoi)]} { return [set TableauInterrogationGeneName($Quoi)] } set File1 "[RepertoireDuGenome]/fiches/GeneName" ###################CHARGE FichierExonicMap######################### if {[file exists $File1] && ![info exists TableauInterrogationGeneName($File1,EstCharge)]} { set TableauInterrogationGeneName($File1,EstCharge) 1 ChargeGeneName TableauInterrogationGeneName $File1 } if {[info exists TableauInterrogationGeneName($Quoi)]} { return [set TableauInterrogationGeneName($Quoi)] } return } proc InterrogeGeneOntology {args} { global TableauGeneOntology #unset #$FichierGeneOntology LesGroupes #$FichierGeneOntology Groupe $Groupe LesGO #$FichierGeneOntology Groupe $Groupe GO $GO n #$FichierGeneOntology Groupe $Groupe LesTypes #$FichierGeneOntology Groupe $Groupe LesNoms #$FichierGeneOntology Groupe $Groupe LesAccess #$FichierGeneOntology LesNoms #$FichierGeneOntology $Nom LesGroupes #$FichierGeneOntology $Nom LesAccess #$FichierGeneOntology $Nom LesGO #$FichierGeneOntology $Nom LesTypes #$FichierGeneOntology $Nom Access $Access LesGO #$FichierGeneOntology $Nom Access $Access LesTypes #$FichierGeneOntology $Nom Access $Access Groupe #$FichierGeneOntology $Nom Access $Access Type $Type LesGO #$FichierGeneOntology $Nom Groupe $Groupe LesAccess #$FichierGeneOntology $Nom Groupe $Groupe LesGO #$FichierGeneOntology $Nom Groupe $Groupe GO $GO n #$FichierGeneOntology $Nom Groupe $Groupe LesTypes #$FichierGeneOntology $Nom GO $GO LesAccess #$FichierGeneOntology $Nom GO $GO n #$FichierGeneOntology $Nom GO $GO LesGroupes #$FichierGeneOntology LesAccess #$FichierGeneOntology Access $Access LesGO #$FichierGeneOntology Access $Access LesNoms #$FichierGeneOntology Access $Access LesTypes #$FichierGeneOntology Access $Access LesGroupes #$FichierGeneOntology LesTypes #$FichierGeneOntology LesGO #$FichierGeneOntology GO $GO LaDefinition #$FichierGeneOntology LaDefinition $Def GO #$FichierGeneOntology GO $GO n #$FichierGeneOntology GO $GO LesAncetres #$FichierGeneOntology GO $GO Type #$FichierGeneOntology GO $GO LesAccess #$FichierGeneOntology GO $GO LesNoms #$FichierGeneOntology GO $GO LesGroupes if {$args == "unset"} { if {[info exists TableauGeneOntology]} { unset TableauGeneOntology } return "" } set Quoi [join $args ","] if {[info exists TableauGeneOntology($Quoi)]} { return [set TableauGeneOntology($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauGeneOntology($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauGeneOntology($File,EstCharge) 1 ChargeGeneOntology TableauGeneOntology $File if {[info exists TableauGeneOntology($Quoi)]} { return [set TableauGeneOntology($Quoi)] } return } proc InterrogeGenomeKEGG {args} { #LesOrgaCourts #LesOrganismes #LesTaxonId #OrgaCourt $OrgaCourt Organisme #Organisme $Organisme OrgaCourt #OrgaCourt $OrgaCourt TaxonId #Organisme $Organisme TaxonId #TaxonId $TaxId Organisme #TaxonId $TaxId OrgaCourt global TableauInterrogationGenomeKEGG if {$args == "unset"} { if {[info exists TableauInterrogationGenomeKEGG]} {unset TableauInterrogationGenomeKEGG} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationGenomeKEGG($Quoi)]} { return [set TableauInterrogationGenomeKEGG($Quoi)] } set FichierGenomeKEGG "[KEGGDir]/genome" if {![file exists $FichierGenomeKEGG ]} {return} if { [info exists TableauInterrogationGenomeKEGG($FichierGenomeKEGG,EstCharge)]} {return} ###################CHARGE GenomeKEGG######################### ChargeGenomeKEGG TableauInterrogationGenomeKEGG $FichierGenomeKEGG set TableauInterrogationGenomeKEGG($FichierGenomeKEGG,EstCharge) 1 if {[info exists TableauInterrogationGenomeKEGG($Quoi)]} {return [set TableauInterrogationGenomeKEGG($Quoi)]} return } proc InterrogeGlobPlot {args} { #Permet de questionner les infos de GlobPlot #Voir aussi decharge et charge global InfoGlobPlot #Utilisation: #On demande set ListeDisorder [InterrogeGlobPlot $File Disorder] #on boucle sur #foreach Indice $ListeDisorder { # et on recupere la valeur par # set Valeur [InterrogeGlobPlot $File Disorder $Indice] #} #Arguments: ########### #$Fichier Disorder - Les valeurs de i #$Fichier Disorder $i - Valeur de Disorder pour $i #$Fichier GlobDoms - Les valeurs de i #$Fichier GlobDoms $i - Valeur de GlobDoms pour $i if {$args == "unset"} { if {[info exists InfoGlobPlot]} { Espionne "unset InfoGlobPlot" array unset InfoGlobPlot } return "" } #1 On test si c deja en memoire et si oui on retourne la valeur demandee set Quoi [join $args ","] if {[info exists InfoGlobPlot($Quoi)]} {return [set InfoGlobPlot($Quoi)]} #2 On recupere le fichier (1er argument) set FichierACharger [lindex $args 0] if {! [info exists InfoGlobPlot($FichierACharger,EstCharge)]} {set InfoGlobPlot($FichierACharger,EstCharge) 0} #3 On decharge le cas echeant if {$Quoi=="$FichierACharger,Decharge"} { DechargeGlobPlot $FichierACharger return "" } if { [info exists InfoGlobPlot($FichierACharger,EstVide)]} {return ""} if { [info exists InfoGlobPlot($Quoi)]} {return [set InfoGlobPlot($Quoi)]} #4 On charge les resultats if {! [info exists InfoDisEMBL($FichierACharger,EstCharge)] || [set InfoDisEMBL($FichierACharger,EstCharge)]=="0"} { set InfoGlobPlot($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeGlobPlot InfoGlobPlot $FichierACharger] if {$ResultatCharge != ""} { set InfoGlobPlot($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoGlobPlot($Quoi)]} {return ""} return [set InfoGlobPlot($Quoi)] } proc InterrogeHgmdParGdb {idGdb} { # cette procedure n'est plus fonctionnelle car l'IP du lbgi est reconnue et interdite d'acces par la HGMD # au lieu d'utiliser cette proc, on verifie à present la présence d'un lien vers la HGMD dans la fiche GDB (attention, pas parfait, car le lien n'est pas tjs present, meme si une entree existe)! set url1 "[LbgiUrl]/~friedric/hgmdParGDB.php" set Query [::http::formatQuery gdb $idGdb] set url "${url1}?$Query" set LesLignes {} set x [HttpCopy $url LesLignes] if {[lsearch -regexp $LesLignes "We are sorry,"] == -1} { return 1 } else { return 0 } } proc InterrogeInfoDeLOligo {args} { Wup "Permet de questionner les infos des oligos" Wup "Voir aussi decharge et charge" global InfoOligo #Arguments: ########### #$FichierOligo $NomOligo Taille - la Taille de l oligo # FichierOligo NomOligo Tm - le Tm # FichierOligo NomOligo ExpTm - le Tm avec une autre methode # FichierOligo NomOligo GC - le GC content # FichierOligo NomOligo Debut - le debut sur la query # FichierOligo NomOligo Fin - la fin sur la query # FichierOligo NomOligo NbCandidats - le nombre de candidats pouvant hybrider l oligo # FichierOligo NomOligo NbContigues - le nombre de fois ou on a eu 15 nt successifs # FichierOligo NomOligo LesCandidats - la liste des access des candidats # FichierOligo NomOligo Sequence - la sequence # FichierOligo $Debut $Fin NomOligo - le nom de l oligo # FichierOligo LesNoms - la liste des noms des oligos # FichierOligo LesDebutFin - la liste de listes des coordonnees des oligos if {$args == "unset"} { if {[info exists InfoOligo]} {array unset InfoOligo} return "" } set Quoi [join $args ","] if {[info exists InfoOligo($Quoi)]} {return [set InfoOligo($Quoi)]} set FichierACharger [lindex $args 0] if {! [info exists InfoOligo($FichierACharger,EstCharge)]} {set InfoOligo($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeInfoDeOligo $FichierACharger return "" } if { [info exists InfoOligo($FichierACharger,EstVide)]} {return ""} if { [info exists InfoOligo($Quoi)]} {return [set InfoOligo($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists InfoOligo($FichierACharger,EstCharge)] || [set InfoOligo($FichierACharger,EstCharge)]=="0"} { set InfoOligo($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLesInfoDeLOligo InfoOligo $FichierACharger] if {$ResultatCharge != ""} { set InfoOligo($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoOligo($Quoi)]} {return ""} return [set InfoOligo($Quoi)] } proc InterrogeInfoDePSORTII {args} { Wup "Permet de questionner les infos des localisation cellulaires de POSRTII" Wup "Voir aussi decharge et charge" global PsortInfo #Arguments: ########### #$FichierPsort $Localisation - rend le pourcentage associe # FichierPsort LesLocalisation - rend les noms de toutes les localisation # FichierPsort BestLocalisation - rend la meilleure localisation if {$args == "unset"} { if {[info exists PsortInfo]} {array unset PsortInfo} return "" } set Quoi [join $args ","] if {[info exists PsortInfo($Quoi)]} {return [set PsortInfo($Quoi)]} set FichierACharger [lindex $args 0] if {[info exists PsortInfo($FichierACharger,EstVide)]} {return ""} if {$Quoi=="$FichierACharger,Decharge"} { DechargeInfoDePSORTII $FichierACharger return "" } ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists PsortInfo($FichierACharger,EstCharge)]} { set PsortInfo($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeLesInfosDePSORTII PsortInfo $FichierACharger] if {$ResultatCharge != ""} { set PsortInfo($FichierACharger,EstVide) 1 return "" } } if {![info exists PsortInfo($Quoi)]} {return ""} return [set PsortInfo($Quoi)] } proc InterrogeInfoDePrimer {args} { Wup "Permet de questionner les infos des Primers" Wup "Voir aussi charge" global InfoPrimer #Arguments: ########### #$PAB - liste Frag Primer1 Primer2 if {$args == "unset"} { if {[info exists InfoPrimer]} {array unset InfoPrimer} return "" } set Quoi [join $args ","] if {[info exists InfoPrimer($Quoi)]} {return [set InfoPrimer($Quoi)]} set PAB [lindex $args 0] if {[info exists InfoPrimer($PAB,EstVide)]} {return ""} ###################CHARGE le Fichier avec les Primers######################### if {! [info exists InfoPrimer($PAB,EstCharge)]} { set InfoPrimer($PAB,EstCharge) 1 set ResultatCharge [ChargeLesInfoDePrimer InfoPrimer $PAB] if {$ResultatCharge != ""} { set InfoPrimer($PAB,EstVide) 1 return "" } } if {![info exists InfoPrimer($Quoi)]} {return ""} return [set InfoPrimer($Quoi)] } proc InterrogeInfoDuLogDeLOligo {args} { Wup "Permet de questionner les infos contenues dans le log des oligos" Wup "Voir aussi decharge et charge" global InfoDuLogDeLOligo #Indexation sur le nom du fichier mais egalement sur les positions debut fin pour ne pas tout charger #Arguments: ########### #$Fichierlog $Debut $Fin LesCandidats - Les candidats detectes par l oligo # Fichierlog Debut Fin $Candidat IDG - Les pourcentages d idendite du candidat # Fichierlog Debut Fin $Candidat NbContigue - Le nombre de bases contigues identique # Fichierlog Debut Fin NbContigue - if {$args == "unset"} { if {[info exists InfoDuLogDeLOligo]} {array unset InfoDuLogDeLOligo} return "" } set Quoi [join $args ","] if {[info exists InfoDuLogDeLOligo($Quoi)]} {return [set InfoDuLogDeLOligo($Quoi)]} set FichierACharger [lindex $args 0] set Debut [lindex $args 1] set Fin [lindex $args 2] if {! [info exists InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstCharge)]} {set InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeLesInfosDuFichierLog $FichierACharger return "" } if { [info exists InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstVide)]} {return ""} if { [info exists InfoDuLogDeLOligo($Quoi)]} {return [set InfoDuLogDeLOligo($Quoi)]} ###################CHARGE le Fichier log avec les infos complementaires des Oligos################### if {! [info exists InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstCharge)] || [set InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstCharge)]=="0"} { set InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstCharge) 1 set ResultatCharge [ChargeLesInfosDuFichierLog InfoDuLogDeLOligo $FichierACharger $Debut $Fin] if {$ResultatCharge != ""} { set InfoDuLogDeLOligo($FichierACharger,$Debut,$Fin,EstVide) 1 return "" } } if {![info exists InfoDuLogDeLOligo($Quoi)]} {return ""} return [set InfoDuLogDeLOligo($Quoi)] } proc InterrogeIngenuityGbEtEvi {{Qui ""} {Quoi ""}} { global InterrogeIngenuityGbEtEvi if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityGbEtEvi($Qui,$Quoi)]} { return $InterrogeIngenuityGbEtEvi($Qui,$Quoi) } if {[info exists InterrogeIngenuityGbEtEvi("EstCharge")]} { return "" } set InterrogeIngenuityGbEtEvi("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/ListeIngenuityGbAcEvi" set LesTetes "Acc Evi" set InterrogeIngenuityGbEtEvi(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set LesElmts [split $Ligne " "] set Acc [lindex $LesElmts 0] set Evi [lindex $LesElmts 1] lappend InterrogeIngenuityGbEtEvi(ListOf,Evi) $Evi lappend InterrogeIngenuityGbEtEvi(ListOf,Acc) $Acc lappend InterrogeIngenuityGbEtEvi($Acc,Evi) $Evi set InterrogeIngenuityGbEtEvi($Evi,Acc) $Acc } return [InterrogeIngenuityGbEtEvi $Qui $Quoi] } proc InterrogeIngenuityGbetGn {{Qui ""} {Quoi ""}} { global InterrogeIngenuityGbetGn if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityGbetGn($Qui,$Quoi)]} { return $InterrogeIngenuityGbetGn($Qui,$Quoi) } if {[info exists InterrogeIngenuityGbetGn("EstCharge")]} { return "" } set InterrogeIngenuityGbetGn("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/Analysis_Rechip_Gb_20061002-all.ini" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2006 Ingenuity Systems,} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Refseq} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuityGbetGn(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Gb [lindex $LesElmts 0] set Gn [lindex $LesElmts 1] lappend InterrogeIngenuityGbetGn(ListOf,Gb) $Gb lappend InterrogeIngenuityGbetGn(ListOf,Gn) $Gn lappend InterrogeIngenuityGbetGn($Gn,Gb) $Gb set InterrogeIngenuityGbetGn($Gb,Gn) $Gn } return [InterrogeIngenuityGbetGn $Qui $Quoi] } proc InterrogeIngenuityGnGbetPathway {{Qui ""} {Quoi ""}} { global InterrogeIngenuityGnGbetPathway if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityGnGbetPathway($Qui,$Quoi)]} { return $InterrogeIngenuityGnGbetPathway($Qui,$Quoi) } if {[info exists InterrogeIngenuityGnGbetPathway("EstCharge")]} { return "" } set InterrogeIngenuityGnGbetPathway("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/LesPathwaysGb.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2006 Ingenuity Systems} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Pathway} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuityGnGbetPathway(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Pathway [lindex $LesElmts 0] set Gns [lindex $LesElmts 2] lappend InterrogeIngenuityGnGbetPathway(ListOf,Pathway) $Pathway set LesGenesNames [split $Gns ","] foreach Gn $LesGenesNames { lappend InterrogeIngenuityGnGbetPathway(ListOf,Gns) $Gn lappend InterrogeIngenuityGnGbetPathway($Pathway,Gns) $Gn lappend InterrogeIngenuityGnGbetPathway($Gn,Pathway) $Pathway } } return [InterrogeIngenuityGnGbetPathway $Qui $Quoi] } proc InterrogeIngenuityGnNmetPathway {{Qui ""} {Quoi ""}} { global InterrogeIngenuityGnNmetPathway if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityGnNmetPathway($Qui,$Quoi)]} { return $InterrogeIngenuityGnNmetPathway($Qui,$Quoi) } if {[info exists InterrogeIngenuityGnNmetPathway("EstCharge")]} { return "" } set InterrogeIngenuityGnNmetPathway("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/LesPathwaysNm.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2006 Ingenuity Systems} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Pathway} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuityGnNmetPathway(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Pathway [lindex $LesElmts 0] set Gns [lindex $LesElmts 2] lappend InterrogeIngenuityGnNmetPathway(ListOf,Pathway) $Pathway set LesGenesNames [split $Gns ","] foreach Gn $LesGenesNames { lappend InterrogeIngenuityGnNmetPathway(ListOf,Gns) $Gn lappend InterrogeIngenuityGnNmetPathway($Pathway,Gns) $Gn lappend InterrogeIngenuityGnNmetPathway($Gn,Pathway) $Pathway } } return [InterrogeIngenuityGnNmetPathway $Qui $Quoi] } proc InterrogeIngenuityGnetPathway {{Qui ""} {Quoi ""}} { global InterrogeIngenuityGnetPathway if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityGnetPathway($Qui,$Quoi)]} { return $InterrogeIngenuityGnetPathway($Qui,$Quoi) } if {[info exists InterrogeIngenuityGnetPathway("EstCharge")]} { return "" } set InterrogeIngenuityGnetPathway("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/pathway.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2007 Ingenuity Systems} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Pathway} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuityGnetPathway(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Pathway [lindex $LesElmts 0] set Gns [lindex $LesElmts 4] lappend InterrogeIngenuityGnetPathway(ListOf,Pathway) $Pathway set LesGenesNames [split $Gns ","] foreach Gn $LesGenesNames { lappend InterrogeIngenuityGnetPathway(ListOf,Gns) $Gn lappend InterrogeIngenuityGnetPathway($Pathway,Gns) $Gn lappend InterrogeIngenuityGnetPathway($Gn,Pathway) $Pathway } } return [InterrogeIngenuityGnetPathway $Qui $Quoi] } proc InterrogeIngenuityNmEtEvi {{Qui ""} {Quoi ""}} { global InterrogeIngenuityNmEtEvi if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityNmEtEvi($Qui,$Quoi)]} { return $InterrogeIngenuityNmEtEvi($Qui,$Quoi) } if {[info exists InterrogeIngenuityNmEtEvi("EstCharge")]} { return "" } set InterrogeIngenuityNmEtEvi("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/ListeIngenuityNmAcEvi" set LesTetes "Acc Evi" set InterrogeIngenuityNmEtEvi(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set LesElmts [split $Ligne " "] set Acc [lindex $LesElmts 0] set Evi [lindex $LesElmts 1] lappend InterrogeIngenuityNmEtEvi(ListOf,Evi) $Evi lappend InterrogeIngenuityNmEtEvi(ListOf,Acc) $Acc lappend InterrogeIngenuityNmEtEvi($Acc,Evi) $Evi set InterrogeIngenuityNmEtEvi($Evi,Acc) $Acc } return [InterrogeIngenuityNmEtEvi $Qui $Quoi] } proc InterrogeIngenuityNmetGn {{Qui ""} {Quoi ""}} { global InterrogeIngenuityNmetGn if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "Evi" } if {[info exists InterrogeIngenuityNmetGn($Qui,$Quoi)]} { return $InterrogeIngenuityNmetGn($Qui,$Quoi) } if {[info exists InterrogeIngenuityNmetGn("EstCharge")]} { return "" } set InterrogeIngenuityNmetGn("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/Analysis_Retchip_Nm_20061002-all.ini" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2006 Ingenuity Systems,} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Refseq} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuityNmetGn(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Nm [lindex $LesElmts 0] set Gn [lindex $LesElmts 1] lappend InterrogeIngenuityNmetGn(ListOf,Nm) $Nm lappend InterrogeIngenuityNmetGn(ListOf,Gn) $Gn lappend InterrogeIngenuityNmetGn($Gn,Nm) $Nm set InterrogeIngenuityNmetGn($Nm,Gn) $Gn } return [InterrogeIngenuityNmetGn $Qui $Quoi] } proc InterrogeIngenuitySwetGn {{Qui ""} {Quoi ""}} { global InterrogeIngenuitySwetGn if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {[info exists InterrogeIngenuitySwetGn($Qui,$Quoi)]} { return $InterrogeIngenuitySwetGn($Qui,$Quoi) } if {[info exists InterrogeIngenuitySwetGn("EstCharge")]} { return "" } set InterrogeIngenuitySwetGn("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Ingenuity/FileAnnot.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {2000-2007 Ingenuity Systems,} $Ligne]} {continue} if {$Ligne==""} {continue} if {[regexp {^Rank} $Ligne]} { set LesTetes [split $Ligne "\t"] set InterrogeIngenuitySwetGn(ListOf,Header) $LesTetes set OnAttendEntete 0 continue } set LesElmts [split $Ligne "\t"] set Sw [lindex $LesElmts 3] set Gn [lindex $LesElmts 5] lappend InterrogeIngenuitySwetGn(ListOf,Sw) $Sw lappend InterrogeIngenuitySwetGn(ListOf,Gn) $Gn lappend InterrogeIngenuitySwetGn($Gn,Sw) $Sw set InterrogeIngenuitySwetGn($Sw,Gn) $Gn } return [InterrogeIngenuitySwetGn $Qui $Quoi] } proc InterrogeKEGG {args} { #LesPathway #LesLiens #LesKegg #LesOrganismes #Kegg $KeggNumber LesPathway #Kegg $KeggNumber Definition #Kegg $KeggNumber LesLiens #Kegg $KeggNumber LesOrganismes #Kegg $KeggNumber Organisme $Organisme LesEnzymes #Pathway $Pathway LesKegg #Pathway $Pathway Definition #Pathway $Pathway LesOrganismes #Organisme $Organisme LesKegg #Organisme $Organisme LesPathway #Lien $Elet LesKegg #Organisme $Organisme Enzyme $Enzyme LesKegg global TableauInterrogationKEGG if {$args == "unset"} { if {[info exists TableauInterrogationKEGG]} {unset TableauInterrogationKEGG} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationKEGG($Quoi)]} {return [set TableauInterrogationKEGG($Quoi)]} set FichierKEGG "[KEGGDir]/ko" if {![file exists $FichierKEGG ]} {return} if { [info exists TableauInterrogationKEGG($FichierKEGG,EstCharge)]} {return} ###################CHARGE KEGG######################### Espionne "KEGG loading..." ChargeKEGG TableauInterrogationKEGG $FichierKEGG Espionne "KEGG OK" set TableauInterrogationKEGG($FichierKEGG,EstCharge) 1 if {![info exists TableauInterrogationKEGG($Quoi)]} {return} return [set TableauInterrogationKEGG($Quoi)] } proc InterrogeLeGPRFile {args} { Wup "Permet de questionner les infos contenus dans un fichier GPR (resultat de GenePix)" Wup "Base sur le fichier .gal qui contient la position sur la plaque des sondes" global InfoLeGPRFile ############################## #GPR FILE is BLOCK ROW COLUMN# ############################## #Arguments: ########### #Quelques exemples toujours dispo #Quoi - Liste de tout ce qui interrogeable #ATF - Version du Axon Text File format #LesDataFields - Nom des colonnes de donnees #NDataFields - Nb de colonne de donnee #NbBlock - Nombre de block #NbColumn - Nombre de colonne #NbRow - Nombre de ligne #NMaxOptionalHeader - Nombre maximum de ligne dans le header if {$args == "unset"} { if {[info exists InfoLeGPRFile]} {array unset InfoLeGPRFile} return "" } set Quoi [join $args ","] if {[info exists InfoLeGPRFile($Quoi)]} {return [set InfoLeGPRFile($Quoi)]} set FichierACharger [lindex $args 0] if {[info exists InfoLeGPRFile($FichierACharger,EstVide)]} {return ""} if {$Quoi=="$FichierACharger,Decharge"} { DeChargeLeGPRFile $FichierACharger return "" } ###################CHARGE le Fichier avec les GPRFile######################### if {! [info exists InfoLeGPRFile($FichierACharger,EstCharge)]} { set InfoLeGPRFile($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeLeGPRFile InfoLeGPRFile $FichierACharger] if {$ResultatCharge != ""} { set InfoLeGPRFile($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoLeGPRFile($Quoi)]} {return ""} return [set InfoLeGPRFile($Quoi)] } proc InterrogeLeGalFile_ActiChip {args} { Wup "Permet de questionner les infos de ActiChip" Wup "Base sur le fichier .gal qui contient la position sur la plaque des sondes" global InfoGalFileActiChip ############################## #GAL FILE is BLOCK ROW COLUMN# ############################## #Arguments: ########### #$Id Block - Block #$Id Col - Column #$Id Row - Row #$Block $Row $Column Id - Id #$Block $Row $Column Name - Name #LesIDs - Liste des Ids # #Quelques exemples toujours dispo ################################# #Quoi - Liste de tout ce qui interrogeable #ATF - Version du Axon Text File format #LesDataFields - Nom des colonnes de donnees #NDataFields - Nb de colonne de donnee #NbBlock - Nombre de block #NMaxOptionalHeader - Nombre maximum de ligne dans le header #Block[0-9] - Position du block if {$args == "unset"} { if {[info exists InfoGalFileActiChip]} {array unset InfoGalFileActiChip} return "" } set Quoi [join $args ","] if {[info exists InfoGalFileActiChip($Quoi)]} {return [set InfoGalFileActiChip($Quoi)]} ###################CHARGE le Fichier avec le GalFileActiChip######################### if {! [info exists InfoGalFileActiChip(EstCharge)]} { set InfoGalFileActiChip(EstCharge) 1 set ResultatCharge [ChargeLeGalFile_ActiChip InfoGalFileActiChip] if {$ResultatCharge != ""} { set InfoGalFileActiChip(EstVide) 1 return "" } } if {![info exists InfoGalFileActiChip($Quoi)]} {return ""} return [set InfoGalFileActiChip($Quoi)] } proc InterrogeLeGalFile_Ontario {args} { Wup "Permet de questionner les infos des puces EST Ontario" Wup "Base sur le fichier .gal qui contient la position sur la plaque des sondes" global InfoGalFile ############################## #GAL FILE is BLOCK ROW COLUMN# ############################## #Arguments: ########### #ATTENTION Verified puis Original #$VerifiedId $OriginalId Block - Block #$VerifiedId $Id Col - Column #$VerifiedId $Id Row - Row #Double reference pour eviter les problemes lies au N/A #$Block $Row $Column VerifiedId - VerifiedId #$Block $Row $Column OriginalId - OriginalId #$Block $Row $Column Name - Name #LesIDs - Liste des couples de Verified_ID et Original_ID #Quelques exemples toujours dispo #Quoi - Liste de tout ce qui interrogeable #ATF - Version du Axon Text File format #LesDataFields - Nom des colonnes de donnees #NDataFields - Nb de colonne de donnee #NbBlock - Nombre de block #NMaxOptionalHeader - Nombre maximum de ligne dans le header #Block[0-9] - Position du block if {$args == "unset"} { if {[info exists InfoGalFile]} {array unset InfoGalFile} return "" } set Quoi [join $args ","] if {[info exists InfoGalFile($Quoi)]} {return [set InfoGalFile($Quoi)]} ###################CHARGE le Fichier avec le GalFileEST######################### if {! [info exists InfoGalFile(EstCharge)]} { set InfoGalFile(EstCharge) 1 set ResultatCharge [ChargeInfoGalFile InfoGalFile] if {$ResultatCharge != ""} { set InfoGalFile(EstVide) 1 return "" } } if {![info exists InfoGalFile($Quoi)]} {return ""} return [set InfoGalFile($Quoi)] } proc InterrogeLeIOBFile_Ontario {args} { Wup "Permet de questionner les infos des puces EST Ontario" Wup "Base sur le fichier .iob qui contient toute l info seq definition ..." global InfoIOBFile ############################# #IOB FILE is GRID COLUMN ROW# ############################# #Arguments: ########### #$sample Grid - Grid #$sample Col - Column #$sample Row - Row #$sample Statut - Statut #$sample Definition - Definition #$sample Abreviation - Gene abreviation #$sample Chromosome - chromosomal location #$sample CytoBand - cytoband location #$sample UnigeneID - UnigeneID #$sample AccessionID - AccessionID #$grid $col $row Sample - Sample ou id du spot #$grid $col $row Statut - Statut #$grid $col $row Definition - Definition du spot #$grid $col $row Abreviation - Gene abreviation #$grid $col $row Chromosome - chromosomal location #$grid $col $row CytoBand - cytoband location #$grid $col $row UnigeneID - UnigeneID #$grid $col $row AccessionID - AccessionID #LesSamples - Liste des sample ou id du fichier iob if {$args == "unset"} { if {[info exists InfoIOBFile]} {array unset InfoIOBFile} return "" } set Quoi [join $args ","] if {[info exists InfoIOBFile($Quoi)]} {return [set InfoIOBFile($Quoi)]} ###################CHARGE le Fichier avec les LeIOBFile_Ontario######################### if {! [info exists InfoIOBFile(EstCharge)]} { set InfoIOBFile(EstCharge) 1 set ResultatCharge [ChargeLeIOBFile_Ontario InfoIOBFile] if {$ResultatCharge != ""} { set InfoIOBFile(EstVide) 1 return "" } } if {![info exists InfoIOBFile($Quoi)]} {return ""} return [set InfoIOBFile($Quoi)] } proc InterrogeLesAccRSEtUG_Affymetrix {args} { Wup "Permet d interroger les infos de LesAccDefRefSeqUnigene de la puce Affymetrix" Wup "Pour le projet Gscope Affy3Marker donnera les ref RefSeq et Unigene du PAB" global InfoAccAffy #Arguments: ########### #Mieux vaut utiliser les references de la puce (Block Row Column) #Gscope Access\tAffymetrixAccess\tAccRefSeq\tIdGRefSeq\tCoverRefSeq\tDefRefSeq\tAccUnigene\tUGId\tIdGUnigene\tCoverUnigene\tDefUnigene #$AffyAccess PAB - PAB #$AffyAccess BestDefinition - BestDefinition #$PABOuAffyAccess AccRefSeq - Acc equivalent dans RefSeq #$PABOuAffyAccess IdGRefSeq - Pourcentage Identite du blastn dans RefSeq #$PABOuAffyAccess CoverRefSeq - Pourcent Id de recouvrement de la Q par rapport S du blastn dans RefSeq #$PABOuAffyAccess DefRefSeq - Definition equivalent dans RefSeq #$PABOuAffyAccess AccUniseq - Acc equivalent dans Uniseq #$PABOuAffyAccess AccUnigene - Acc equivalent dans Unigene #$PABOuAffyAccess IdGUniseq - Pourcentage Identite du blastn dans Uniseq #$PABOuAffyAccess CoverUniseq - Pourcent Id de recouvrement de la Q par rapport a S du blastn dans Uniseq #$PABOuAffyAccess DefUniseq - Definition equivalent dans Uniseq #LesAccRefSeq - Liste des Access RefSeq presents sur la puce #$AccRefSeq - Renvoi 1 si existe #$AccRefSeq AccGscope - Liste des Acc Gscope du projet PuceEST #LesAccAffymetrix - Liste des ProbetSetId presents sur la puce #$AccRefSeq ProbeSetId - Renvoi la liste des ProbeSetId attaches if {$args == "unset"} { if {[info exists InfoAccAffy]} {array unset InfoAccAffy} return "" } set Quoi [join $args ","] if {[info exists InfoAccAffy($Quoi)]} {return [set InfoAccAffy($Quoi)]} ###################CHARGE le Fichier avec les AccRSEtUGDeAffymetrix######################### if {! [info exists InfoAccAffy(EstCharge)]} { set InfoAccAffy(EstCharge) 1 set ResultatCharge [ChargeLesAccRSEtUG_Affymetrix InfoAccAffy] if {$ResultatCharge != ""} { set InfoAccAffy(EstVide) 1 return "" } } if {![info exists InfoAccAffy($Quoi)]} {return ""} return [set InfoAccAffy($Quoi)] } proc InterrogeLesAccRSEtUG_Ontario {args} { Wup "Permet d interroger les infos de LesAccDefRefSeqUnigene de la puce EST" Wup "Pour le projet Gscope PuceEST donnera les ref RefSeq et Unigene du PAB" global InfoAccOntario #Arguments: ########### #Mieux vaut utiliser les references de la puce (Block Row Column) #$PAB OriginalID - le Original_Image_ID de la puce #$PAB VerifiedID - le Verified_Image_ID de la puce #$PAB BestDefinition - La meilleure definition entre RefSeq et Uniseq #$OriginalID PAB - le PAB de Original_Image_ID de la puce #$VerifiedID PAB - le PAB de Verified_Image_ID de la puce # #$Block $Row $Column PAB - PAB #$Block $Row $Column BestDefinition - BestDefinition #$Block $Row $Column AccRefSeq - Acc equivalent dans RefSeq #$Block $Row $Column IdGRefSeq - Pourcentage Identite du blastn dans RefSeq #$Block $Row $Column CoverRefSeq - Pourcent Id de recouvrement de la Q par rapport S du blastn dans RefSeq #$Block $Row $Column DefRefSeq - Definition equivalent dans RefSeq #$Block $Row $Column AccUniseq - Acc equivalent dans Uniseq #$Block $Row $Column AccUnigene - Acc equivalent dans Unigene #$Block $Row $Column IdGUniseq - Pourcentage Identite du blastn dans Uniseq #$Block $Row $Column CoverUniseq - Pourcent Id de recouvrement de la Q par rapport a S du blastn dans Uniseq #$Block $Row $Column DefUniseq - Definition equivalent dans Uniseq # #$OriginalIDOuVerifiedIDOuPAB BestDefinition - BestDefinition #$OriginalIDOuVerifiedIDOuPAB AccRefSeq - Acc equivalent dans RefSeq #$OriginalIDOuVerifiedIDOuPAB IdGRefSeq - Pourcentage Identite du blastn dans RefSeq #$OriginalIDOuVerifiedIDOuPAB CoverRefSeq - Pourcent Id de recouvrement de la Q par rapport S du blastn dans RefSeq #$OriginalIDOuVerifiedIDOuPAB DefRefSeq - Definition equivalent dans RefSeq #$OriginalIDOuVerifiedIDOuPAB AccUniseq - Acc equivalent dans Uniseq #$OriginalIDOuVerifiedIDOuPAB AccUnigene - Acc equivalent dans Unigene #$OriginalIDOuVerifiedIDOuPAB IdGUniseq - Pourcentage Identite du blastn dans Uniseq #$OriginalIDOuVerifiedIDOuPAB CoverUniseq - Pourcent Id de recouvrement de la Q par rapport a S du blastn dans Uniseq #$OriginalIDOuVerifiedIDOuPAB DefUniseq - Definition equivalent dans Uniseq # #LesAccRefSeq - Liste des Access RefSeq presents sur la puce #$AccRefSeq - Renvoi 1 si existe #$AccRefSeq AccGscope - Liste des Acc Gscope du projet PuceEST if {$args == "unset"} { if {[info exists InfoAccOntario]} {array unset InfoAccOntario} return "" } set Quoi [join $args ","] if {[info exists InfoAccOntario($Quoi)]} {return [set InfoAccOntario($Quoi)]} ###################CHARGE le Fichier avec les AccRSEtUGDeLaPuceEST######################### if {! [info exists InfoAccOntario(EstCharge)]} { set InfoAccOntario(EstCharge) 1 set ResultatCharge [ChargeLesAccRSEtUG_Ontario InfoAccOntario] if {$ResultatCharge != ""} { set InfoAccOntario(EstVide) 1 return "" } } if {![info exists InfoAccOntario($Quoi)]} {return ""} return [set InfoAccOntario($Quoi)] } proc InterrogeLesAccessRefSeqDesPABs {args} { Wup "Permet de questionner les infos de LesAccessUnigeneDesPABs" Wup "Base sur le fichier LesAccessUgUnDesPABs qui contient les resultats des blastn vs unigene" global InfoRefSeqID #Arguments: ########### #$PAB RefSeqId - Access RefSeq # PAB LesPABs - Les PAB if {$args == "unset"} { if {[info exists InfoRefSeqID]} {array unset InfoRefSeqID} return "" } set Quoi [join $args ","] if {[info exists InfoRefSeqID($Quoi)]} {return [set InfoRefSeqID($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists InfoRefSeqID(EstCharge)]} { set InfoRefSeqID(EstCharge) 1 set ResultatCharge [ChargeInfoRefSeqID InfoRefSeqID] if {$ResultatCharge != ""} { set InfoRefSeqID(EstVide) 1 return "" } } if {![info exists InfoRefSeqID($Quoi)]} {return ""} return [set InfoRefSeqID($Quoi)] } proc InterrogeLesAccessUnigeneDesPABs {args} { Wup "Permet de questionner les infos de LesAccessUnigeneDesPABs" Wup "Base sur le fichier LesAccessUgUnDesPABs qui contient les resultats des blastn vs unigene" global InfoUnigeneID #Arguments: ########### #$PAB UnigeneId - Access Unigene # PAB UniseqId - Access Uniseq # PAB LesPABs - Les PAB if {$args == "unset"} { if {[info exists InfoUnigeneID]} {array unset InfoUnigeneID} return "" } set Quoi [join $args ","] if {[info exists InfoUnigeneID($Quoi)]} {return [set InfoUnigeneID($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists InfoUnigeneID(EstCharge)]} { set InfoUnigeneID(EstCharge) 1 set ResultatCharge [ChargeInfoUnigeneID InfoUnigeneID] if {$ResultatCharge != ""} { set InfoUnigeneID(EstVide) 1 return "" } } if {![info exists InfoUnigeneID($Quoi)]} {return ""} return [set InfoUnigeneID($Quoi)] } proc InterrogeLesAnnotAffymetrix {args} { Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0" Wup "Voir aussi decharge et charge" global TabAnnotAffy #Arguments: ########### #Index est le numero unique attribue en fonction de la ligne dans le fichier affymetrix #Pour faire la correspondance entre les deux #ListOfProbeSet - Liste des ProbeSet disponibles #$Index RefSeq - Access RefSeq si il existe #$AccRefSeq Index - Index du RefSeq #$IndexOuAccRefSeq Probe_Set_Name - Nom du Probe Set (11 references) peut etre une liste # IndexOuAccRefSeq Description - Description # IndexOuAccRefSeq Sequence_Type - # IndexOuAccRefSeq repAccession - Access de la sequence utilisee # IndexOuAccRefSeq GeneName - Nom du gene # IndexOuAccRefSeq Product - # IndexOuAccRefSeq subcluster - Cluster Unigene # IndexOuAccRefSeq fullLengths - Les access des sequences completes if {$args == "unset"} { if {[info exists TabAnnotAffy]} {array unset TabAnnotAffy} return "" } set FichierACharger [lindex $args 0] if {! [file exists "$FichierACharger"]} { #Mouse430_2_annot.txt #HG-U133_Plus_2_annot.txt #CE FICHIER EST TELECHARGER DU SITE AFFYMETRIX .csv ET TRANSFORME EN Tab Delimited File set RepAffy "[Affymetrix_Dir]" set FichierACharger "$RepAffy/${FichierACharger}/Annotation/${FichierACharger}_annot.txt" if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" return "" } } set Quoi [join [concat $FichierACharger [lrange $args 1 end]] ","] #set Quoi [join $args ","] if { [info exists TabAnnotAffy($Quoi)]} {return [set TabAnnotAffy($Quoi)]} if {! [info exists TabAnnotAffy($FichierACharger,EstCharge)]} {set TabAnnotAffy($FichierACharger,EstCharge) 0} if {$Quoi=="Decharge"} { DechargeLesAnnotAffymetrix $FichierACharger return "" } if { [info exists TabAnnotAffy($FichierACharger,EstVide)]} {return ""} if { [info exists TabAnnotAffy($Quoi)]} {return [set TabAnnotAffy($Quoi)]} ###################CHARGE le Fichier avec les InfosAffymetrix######################### if {! [info exists TabAnnotAffy($FichierACharger,EstCharge)] || [set TabAnnotAffy($FichierACharger,EstCharge)]=="0"} { set TabAnnotAffy($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeLesAnnotAffymetrix TabAnnotAffy $FichierACharger] if {$ResultatCharge != ""} { set TabAnnotAffy($FichierACharger,EstVide) 1 return "" } } if {! [info exists TabAnnotAffy($Quoi)]} {return ""} return [set TabAnnotAffy($Quoi)] } proc InterrogeLesBornesMsmegmatis {args} { Wup "Permet de questionner les bornes des sequences de M.smegmatis" Wup "Voir aussi decharge et charge" global TabBMsmegatis #Arguments: ########### #Access est la combinaison du nom de 2 boites Gscope ex: MS00756(Acc1) et MS00758(Acc2) MS00756MS00758 #$Access Acc1 -- 1er access du couple #$Access Acc2 -- 2em access du couple #$Access D1 -- Debut de la premiere zone de PCR #$Access F1 -- Fin de la premiere zone de PCR #$Access D2 -- Debut de la deuxieme zone de PCR #$Access F2 -- Fin de la deuxieme zone de PCR if {$args == "unset"} { if {[info exists TabBMsmegatis]} {array unset TabBMsmegatis} return "" } set Quoi [join $args ","] if { [info exists TabBMsmegatis($Quoi)]} {return [set TabBMsmegatis($Quoi)]} if {! [info exists TabBMsmegatis(EstCharge)]} {set TabBMsmegatis(EstCharge) 0} if {$Quoi=="Decharge"} { DechargeLesBornesMsmegmatis return "" } if { [info exists TabBMsmegatis(EstVide)]} {return ""} if { [info exists TabBMsmegatis($Quoi)]} {return [set TabBMsmegatis($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists TabBMsmegatis(EstCharge)] || [set TabBMsmegatis(EstCharge)]=="0"} { set TabBMsmegatis(EstCharge) 1 set ResultatCharge [ChargeLesBornesMsmegmatis TabBMsmegatis] if {$ResultatCharge != ""} { set TabBMsmegatis(EstVide) 1 return "" } } if {! [info exists TabBMsmegatis($Quoi)]} {return ""} return [set TabBMsmegatis($Quoi)] } proc InterrogeLesClustersDesMSF {args} { #unset #$Fichier LesClusters #$Fichier LesAccess #$Fichier NbClusters #$Fichier Cluster $Cluster Size #$Fichier Cluster $Cluster LesAccess #$Fichier Access $Access Cluster global TableauInterrogationDesClustersDesMSF if {$args == "unset"} { if {[info exists TableauInterrogationDesClustersDesMSF]} { unset TableauInterrogationDesClustersDesMSF } return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationDesClustersDesMSF($Quoi)]} { return [set TableauInterrogationDesClustersDesMSF($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauInterrogationDesClustersDesMSF($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauInterrogationDesClustersDesMSF($File,EstCharge) 1 ChargeFichierClusteringDesMSF TableauInterrogationDesClustersDesMSF $File if {[info exists TableauInterrogationDesClustersDesMSF($Quoi)]} { return [set TableauInterrogationDesClustersDesMSF($Quoi)] } return } proc InterrogeLesDomainesDesARPs {args} { Wup "Permet de questionner les domaines caracteristiques des differentes sous familles d ARP" Wup "Voir aussi decharge et charge" global LesDomainesDesARPs #Arguments: ########### #Les residus sont indexes en fonction de la famille d ARP a laquelle il appartient. #Pour acceder a la position equivalente il faut connaitre sa position (ieme residu) #dans la liste des positions de cette famille, on peut alors avoir access a la position #LesFamilles - Liste des familles presentes (ARP1, ARP2 ...) #$Famille LesAccess - Les Access d une famille #$Famille Lesi - Les numeros (rangs) des domaines #$Famille $i Type $Type - La type de domaine (IN ou DEL) pour un rang #$Famille $i Taille $Taille - La taille du domaine (IN ou DEL) pour un rang #$Famille $Access LesPositions - LesPositions contenant des domaines #$Famille $Access IN LesPositions - LesPositions des INsertions #$Famille $Access DEL LesPositions - LesPositions des DELetions #$Famille $Access $PosDomaines Type - Le type de domaine pour un access a une position #$Famille $Access $PosDomaines Taille - Le taille du domaine pour un access a une position if {$args == "unset"} { if {[info exists LesDomainesDesARPs]} {array unset LesDomainesDesARPs} return "" } set Quoi [join $args ","] if { [info exists LesDomainesDesARPs($Quoi)]} {return [set LesDomainesDesARPs($Quoi)]} if {! [info exists LesDomainesDesARPs(EstCharge)]} { set LesDomainesDesARPs(EstCharge) 0} if {$Quoi=="Decharge"} { #Espionne "Decharge $FichierACharger" DechargeLesDomainesDesARPs $FichierACharger return "" } if { [info exists LesDomainesDesARPs(EstVide)]} {return ""} if { [info exists LesDomainesDesARPs($Quoi)]} {return [set LesDomainesDesARPs($Quoi)]} ###################CHARGE le Fichier avec les residus des ARPs######################### if {! [info exists LesDomainesDesARPs(EstCharge)] || [set LesDomainesDesARPs(EstCharge)]=="0"} { set LesDomainesDesARPs(EstCharge) 1 set ResultatCharge [ChargeLesDomainesDesARPs LesDomainesDesARPs] if {$ResultatCharge != ""} { set LesDomainesDesARPs(EstVide) 1 return "" } } if {![info exists LesDomainesDesARPs($Quoi)]} {return ""} return [set LesDomainesDesARPs($Quoi)] } proc InterrogeLesEffectifsDesMots {args} { global TableauEffectifsDesMots if {[string equal -nocase $args "unset"]} { if {[info exists TableauEffectifsDesMots]} {unset TableauEffectifsDesMots} return } set Quoi [join $args ","] if {[info exists TableauEffectifsDesMots($Quoi)]} {return [set TableauEffectifsDesMots($Quoi)]} if {![info exists TableauEffectifsDesMots(EstCharge)]} { set TableauEffectifsDesMots(EstCharge) 1 set LesPhrases [LesPhrasesMemorisees] if {$LesPhrases == ""} {return} foreach LeCouple [LesEffectifsDesCouplesDeMots $LesPhrases] { set Mot1 [lindex $LeCouple 0] if {![info exists TableauEffectifsDesMots(Mot,$Mot1,LesSuivants)]} { set TableauEffectifsDesMots(Mot,$Mot1,LesSuivants) {} } set Mot2 [lindex $LeCouple 1] set n [lindex $LeCouple 2] for {set i 1} {$i <= $n} {incr i} {lappend TableauEffectifsDesMots(Mot,$Mot1,LesSuivants) $Mot2} set TableauEffectifsDesMots(Couple,$Mot1,$Mot2,n) $n set TableauEffectifsDesMots(Couple,$Mot1,$Mot2,nMax) [lindex $LeCouple 3] } set TableauEffectifsDesMots(LesMots) {} foreach LeMot [LesEffectifsDesMots $LesPhrases] { set Mot [lindex $LeMot 0] if {![info exists TableauEffectifsDesMots(Mot,$Mot,n)]} {lappend TableauEffectifsDesMots(LesMots) $Mot} set TableauEffectifsDesMots(Mot,$Mot,n) [lindex $LeMot 1] set TableauEffectifsDesMots(Mot,$Mot,nMax) [lindex $LeMot 2] } set TableauEffectifsDesMots(TousLesMots) {} foreach Mot [set TableauEffectifsDesMots(LesMots)] { set n [set TableauEffectifsDesMots(Mot,$Mot,n)] for {set i 1} {$i <= $n} {incr i} { lappend TableauEffectifsDesMots(TousLesMots) $Mot } if {![info exists TableauEffectifsDesMots(Mot,$Mot,nPremier)]} {set TableauEffectifsDesMots(Mot,$Mot,nPremier) 0} if {![info exists TableauEffectifsDesMots(Mot,$Mot,nDernier)]} {set TableauEffectifsDesMots(Mot,$Mot,nDernier) 0} } foreach LaPhrase $LesPhrases { set Premier [lindex $LaPhrase 0 ] set Dernier [lindex $LaPhrase end] incr TableauEffectifsDesMots(Mot,$Premier,nPremier) incr TableauEffectifsDesMots(Mot,$Dernier,nDernier) } set nMots [llength TousLesMots] } else { return } if {[info exists TableauEffectifsDesMots($Quoi)]} {return [set TableauEffectifsDesMots($Quoi)]} return } proc InterrogeLesInfosAffymetrix {args} { Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0" Wup "Voir aussi decharge et charge" global TabAffy #Arguments: ########### #Index est le numero unique attribue en fonction de la ligne dans le fichier affymetrix #Pour faire la correspondance entre les deux #ListOfProbeSet - Liste des ProbeSet disponibles #$Index RefSeq - Access RefSeq si il existe #$AccRefSeq Index - Index du RefSeq #$IndexOuAccRefSeq Probe_Set_Name - Nom du Probe Set (11 references) peut etre une liste # IndexOuAccRefSeq Description - Description # IndexOuAccRefSeq Sequence_Type - # IndexOuAccRefSeq repAccession - Access de la sequence utilisee # IndexOuAccRefSeq GeneName - Nom du gene # IndexOuAccRefSeq Product - # IndexOuAccRefSeq subcluster - Cluster Unigene # IndexOuAccRefSeq fullLengths - Les access des sequences completes if {$args == "unset"} { if {[info exists TabAffy]} {array unset TabAffy} return "" } set FichierACharger [lindex $args 0] if {! [file exists "$FichierACharger"]} { set RepAffy "[Affymetrix_Dir]" set FichierACharger "$RepAffy/${FichierACharger}/LibFiles/${FichierACharger}" if {[file exists "${FichierACharger}.gin"]} { set FichierACharger "${FichierACharger}.gin" } else { set FichierACharger "${FichierACharger}.GIN" } } if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" return "" } set Quoi [join [concat $FichierACharger [lrange $args 1 end]] ","] #set Quoi [join $args ","] if { [info exists TabAffy($Quoi)]} {return [set TabAffy($Quoi)]} if {! [info exists TabAffy($FichierACharger,EstCharge)]} {set TabAffy($FichierACharger,EstCharge) 0} if {$Quoi=="Decharge"} { DechargeLesInfosAffymetrix $FichierACharger return "" } if { [info exists TabAffy($FichierACharger,EstVide)]} {return ""} if { [info exists TabAffy($Quoi)]} {return [set TabAffy($Quoi)]} ###################CHARGE le Fichier avec les InfosAffymetrix######################### if {! [info exists TabAffy($FichierACharger,EstCharge)] || [set TabAffy($FichierACharger,EstCharge)]=="0"} { set TabAffy($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeLesInfosAffymetrix TabAffy $FichierACharger] if {$ResultatCharge != ""} { set TabAffy($FichierACharger,EstVide) 1 return "" } } if {! [info exists TabAffy($Quoi)]} {return ""} return [set TabAffy($Quoi)] } proc InterrogeLesInfosDesARPs {args} { Wup "Permet de questionner les infos des oligos contenues dans le fichier pour excel" Wup "Voir aussi decharge et charge" global LesInfosDesARPs #Arguments: ########### #$Access - Rend 1 si on le possede # Access Definition - Rend la definition de la proteine # Access Organisme - Rend le ou les organismes de la proteine # Access Taxon - Rend le ou les taxons de la proteine # Access Categorie - Rend la categorie theorique de la sequence (basee sur l alignement) #$Categorie LesAccess - Rend les access presents de la categorie #$Categorie LesTaxons - Rend les Taxons presents de la categorie #LesIDs - Rend les IDs references #LesAccess - Rend les access references #LesCategories - Rend les categories if {$args == "unset"} { if {[info exists LesInfosDesARPs]} {array unset LesInfosDesARPs} return "" } set Quoi [join $args ","] if {[info exists LesInfosDesARPs($Quoi)]} {return [set LesInfosDesARPs($Quoi)]} #set FichierACharger [lindex $args 0] set RepARP "[RepARPAnno]" set FichierACharger "$RepARP/ListeAccessDesARPs" set FichierACharger "$RepARP/ListeAccessDesARPs_Def_Org" set FichierACharger "$RepARP/ListeAccessDesARPs_Id_Def_Org" if {! [info exists LesInfosDesARPs($FichierACharger,EstCharge)]} {set LesInfosDesARPs($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeLesInfosDesARPs $FichierACharger return "" } if { [info exists LesInfosDesARPs($FichierACharger,EstVide)]} {return ""} if { [info exists LesInfosDesARPs($Quoi)]} {return [set LesInfosDesARPs($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists LesInfosDesARPs($FichierACharger,EstCharge)] || [set LesInfosDesARPs($FichierACharger,EstCharge)]=="0"} { set LesInfosDesARPs($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLesInfosDesARPs LesInfosDesARPs $FichierACharger] if {$ResultatCharge != ""} { set LesInfosDesARPs($FichierACharger,EstVide) 1 return "" } } if {![info exists LesInfosDesARPs($Quoi)]} {return ""} return [set LesInfosDesARPs($Quoi)] } proc InterrogeLesInfosDesProtsDonnees {args} { Wup "Permet de questionner les infos des oligos contenues dans le fichier pour excel" Wup "Voir aussi decharge et charge" global LesInfosDesProtsDonnees #Arguments: ########### #$Access - Rend 1 si on le possede # Access Definition - Rend la definition de la proteine # Access Organisme - Rend le ou les organismes de la proteine # Access Taxon - Rend le ou les taxons de la proteine # Access Categorie - Rend la categorie theorique de la sequence (basee sur l alignement) #$Categorie LesAccess - Rend les access presents de la categorie #$Categorie LesTaxons - Rend les Taxons presents de la categorie #LesAccess - Rend les access references #LesCategories - Rend les categories if {$args == "unset"} { if {[info exists LesInfosDesProtsDonnees]} {array unset LesInfosDesProtsDonnees} return "" } set Quoi [join $args ","] if {[info exists LesInfosDesProtsDonnees($Quoi)]} {return [set LesInfosDesProtsDonnees($Quoi)]} set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { set FichierACharger "[RepertoireDuGenome]/LesAccess_Def_Org" #Espionne "Pas de fichier par defaut ChargeLesInfosDesProtsDonnees" set args [linsert $args 0 $FichierACharger] set Quoi [join $args ","] } if {! [info exists LesInfosDesProtsDonnees($FichierACharger,EstCharge)]} {set LesInfosDesProtsDonnees($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DehargeLesInfosDesProtsDonnees $FichierACharger return "" } if { [info exists LesInfosDesProtsDonnees($FichierACharger,EstVide)]} {return ""} if { [info exists LesInfosDesProtsDonnees($Quoi)]} {return [set LesInfosDesProtsDonnees($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists LesInfosDesProtsDonnees($FichierACharger,EstCharge)] || [set LesInfosDesProtsDonnees($FichierACharger,EstCharge)]=="0"} { set LesInfosDesProtsDonnees($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLesInfosDesProtsDonnees LesInfosDesProtsDonnees $FichierACharger] if {$ResultatCharge != ""} { set LesInfosDesProtsDonnees($FichierACharger,EstVide) 1 return "" } } if {![info exists LesInfosDesProtsDonnees($Quoi)]} {return ""} return [set LesInfosDesProtsDonnees($Quoi)] } proc InterrogeLesInfosICDS {args} { Wup "Permet de questionner les Infos des sequences de M.smegmatis" Wup "Voir aussi decharge et charge" global TabICDS #Arguments: ########### #Access est la combinaison du nom de 2 boites Gscope ex: MS00756(Acc1) et MS00758(Acc2) MS00756MS00758 #$Access Acc1 -- 1er access du couple #$Access Acc2 -- 2em access du couple #$Access D1 -- Debut de la premiere zone de PCR #$Access F1 -- Fin de la premiere zone de PCR #$Access D2 -- Debut de la deuxieme zone de PCR #$Access F2 -- Fin de la deuxieme zone de PCR if {$args == "unset"} { if {[info exists TabICDS]} {array unset TabICDS} return "" } set Quoi [join $args ","] if { [info exists TabICDS($Quoi)]} {return [set TabICDS($Quoi)]} if {! [info exists TabICDS(EstCharge)]} {set TabICDS(EstCharge) 0} if {$Quoi=="Decharge"} { DechargeLesInfosICDS return "" } if { [info exists TabICDS(EstVide)]} {return ""} if { [info exists TabICDS($Quoi)]} {return [set TabICDS($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists TabICDS(EstCharge)] || [set TabICDS(EstCharge)]=="0"} { set TabICDS(EstCharge) 1 set ResultatCharge [ChargeLesInfosICDS TabICDS] if {$ResultatCharge != ""} { set TabICDS(EstVide) 1 return "" } } if {! [info exists TabICDS($Quoi)]} {return ""} return [set TabICDS($Quoi)] } proc InterrogeLesInfosUMCU {args} { Wup "Permet de questionner les infos des puces UMCU" Wup "Base sur le fichier .txt qui contient les infos" global InfoUMCU #Arguments: ########### #$Fichier $MetaRow $MetaColumn $Row $Column DATAFIELD - Rend l info du DATAFIELD pour la position demandee # Fichier LesAccess - Liste de tous les access de sequences sur la puce UMCU # Fichier LesAccRefSeq - Liste des access RefSeq sur la puce UMCU # Fichier LesAccGenbank - Liste des access Genbank sur la puce UMCU if {$args == "unset"} { if {[info exists InfoUMCU]} {array unset InfoUMCU} return "" } set Quoi [join $args ","] if {[info exists InfoUMCU($Quoi)]} {return [set InfoUMCU($Quoi)]} set FichierACharger [lindex $args 0] if {[info exists InfoUMCU($FichierACharger,EstVide)]} {return ""} if {$Quoi=="$FichierACharger,Decharge"} { DechargeInfoUMCU $FichierACharger return "" } ###################CHARGE le Fichier avec les UMCU######################### if {! [info exists InfoUMCU($FichierACharger,EstCharge)]} { set InfoUMCU($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeInfoUMCU InfoUMCU $FichierACharger] if {$ResultatCharge != ""} { set InfoUMCU($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoUMCU($Quoi)]} {return ""} return [set InfoUMCU($Quoi)] } proc InterrogeLesOligosPourExcel {args} { Wup "Permet de questionner les infos des oligos contenues dans le fichier pour excel" Wup "Voir aussi decharge et charge" global InfoPourExcel #Arguments: ########### #$FichierOligosPourExcel LesAccess - LesAccess de references # FichierOligosPourExcel LesAccessGScope - LesAccess de gscope if {$args == "unset"} { if {[info exists InfoPourExcel]} {array unset InfoPourExcel} return "" } set Quoi [join $args ","] if {[info exists InfoPourExcel($Quoi)]} {return [set InfoPourExcel($Quoi)]} set FichierACharger [lindex $args 0] if {! [info exists InfoPourExcel($FichierACharger,EstCharge)]} {set InfoPourExcel($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeInfoDeOligo $FichierACharger return "" } if { [info exists InfoPourExcel($FichierACharger,EstVide)]} {return ""} if { [info exists InfoPourExcel($Quoi)]} {return [set InfoPourExcel($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### if {! [info exists InfoPourExcel($FichierACharger,EstCharge)] || [set InfoPourExcel($FichierACharger,EstCharge)]=="0"} { set InfoPourExcel($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLesOligosPourExcel InfoPourExcel $FichierACharger] if {$ResultatCharge != ""} { set InfoPourExcel($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoPourExcel($Quoi)]} {return ""} return [set InfoPourExcel($Quoi)] } proc InterrogeLesRedondants {{Qui ""} {Quoi ""}} { global InterrogeLesRedondants if {[info exists InterrogeLesRedondants($Qui,$Quoi)]} {return $InterrogeLesRedondants($Qui,$Quoi)} if {[info exists InterrogeLesRedondants("EstCharge")]} {return ""} set InterrogeLesRedondants("EstCharge") 1 set File "/genomics/link/SpliRetMouse/database/LaRefEtLesAccessRedondants" foreach Ligne [LesLignesDuFichier $File] { set LesAccess [split $Ligne " "] set nbacc [llength $LesAccess] set Ref [lindex $LesAccess 0] for {set i 1} {$i < $nbacc} {incr i} { lappend InterrogeLesRedondants($Ref,LesRedond) [lindex $LesAccess $i] set InterrogeLesRedondants([lindex $LesAccess $i],LaRef) $Ref } } return [InterrogeLesRedondants $Qui $Quoi] } proc InterrogeLesResidusDesARPs {args} { Wup "Permet de questionner les residus caracteristiques des differentes sous familles d ARP" Wup "Voir aussi decharge et charge" global LesResidusDesARPs #Arguments: ########### #Les residus sont indexes en fonction de la famille d ARP a laquelle il appartient. #Pour acceder au residus il faut connaitre sa position (ieme residu) dans ls liste des residus de cette famille. #on peut alors avoir access au residu et a sa position #LesFamilles - Liste des familles presentes (ARP1, ARP2 ...) #$Famille LesGroupes - Rend pour la famille les groupes existants #$Famille Groupe $Groupe LesResidus - Rend pour LeGroupe voulu les Numeros de residus groupes #$Famille Lesi - Les numeros (rang) de residus #$Famille $i Residu - La valeur du residu pour un rang #$Famille $i Pos - La position du residu pour un rang #$Famille $AccessDeRef LesPositions - Rend les position des residus a chercher if {$args == "unset"} { if {[info exists LesResidusDesARPs]} {array unset LesResidusDesARPs} return "" } set Quoi [join $args ","] if {[info exists LesResidusDesARPs($Quoi)]} {return [set LesResidusDesARPs($Quoi)]} if {! [info exists LesResidusDesARPs(EstCharge)]} {set LesResidusDesARPs(EstCharge) 0} if {$Quoi=="Decharge"} { #Espionne "Decharge $FichierACharger" DechargeLesResidusDesARPs $FichierACharger return "" } if { [info exists LesResidusDesARPs(EstVide)]} {return ""} if { [info exists LesResidusDesARPs($Quoi)]} {return [set LesResidusDesARPs($Quoi)]} ###################CHARGE le Fichier avec les residus des ARPs######################### if {! [info exists LesResidusDesARPs(EstCharge)] || [set LesResidusDesARPs(EstCharge)]=="0"} { set LesResidusDesARPs(EstCharge) 1 set ResultatCharge [ChargeLesResidusDesARPs LesResidusDesARPs] if {$ResultatCharge != ""} { set LesResidusDesARPs(EstVide) 1 return "" } } if {![info exists LesResidusDesARPs($Quoi)]} {return ""} return [set LesResidusDesARPs($Quoi)] } proc InterrogeLibrariesRepeatMasker {args} { global TableauLibrariesRepeatMasker #LesOrganismes #LesLibraries #Librarie $Librarie LesOrganismes #Organisme $Organisme LesLibraries if {$args == "unset"} { if {[info exists TableauLibrariesRepeatMasker]} {unset TableauLibrariesRepeatMasker} return } set Quoi [join $args ","] if {[info exists TableauLibrariesRepeatMasker($Quoi) ]} {return [set TableauLibrariesRepeatMasker($Quoi)]} if {[info exists TableauLibrariesRepeatMasker(EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauLibrariesRepeatMasker(EstCharge) 1 ChargeLibrariesRepeatMasker TableauLibrariesRepeatMasker if {[info exists TableauLibrariesRepeatMasker($Quoi)]} {return [set TableauLibrariesRepeatMasker($Quoi)]} return } proc InterrogeListTau {{Qui ""} {Quoi ""}} { global InterrogeListTau if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists InterrogeListTau($Qui,$Quoi)]} {return $InterrogeListTau($Qui,$Quoi)} if {[info exists InterrogeListTau("EstCharge")]} {return ""} set InterrogeListTau("EstCharge") 1 set Fichier "/genomics/link/Tau/Dec2008/GSTRdCVF/versionfinaletableau031208_GST-RdCVFL.csv" #set Fichier "/genomics/link/Tau/Publi/Tableau010408Csv.csv" set LesLignes [LesLignesDuFichier $Fichier] foreach Ligne $LesLignes { set LesMots [split $Ligne ";"] if {[regexp "^function" $Ligne] || [regexp "^Protein" $Ligne]} { set LesHeaders $LesMots set InterrogeListTau(ListOf,headers) $LesHeaders continue } #set function [lindex $LesMots 0] #set Name [lindex $LesMots 1] #set GI [lindex [split [lindex $LesMots 2] "|"] 1] set Name [lindex $LesMots 1] set function [lindex $LesMots 2] set GI [lindex $LesMots 3] lappend InterrogeListTau(ListOf,GI) $GI set InterrogeListTau($GI,function) $function set InterrogeListTau($GI,Name) $Name } return [InterrogeListTau $Qui $Quoi] } proc InterrogeListTauControl {{Qui ""} {Quoi ""}} { global InterrogeListTauControl if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists InterrogeListTauControl($Qui,$Quoi)]} {return $InterrogeListTauControl($Qui,$Quoi)} if {[info exists InterrogeListTauControl("EstCharge")]} {return ""} set InterrogeListTauControl("EstCharge") 1 set Fichier "/genomics/link/Tau/Dec2008/GSTControl/versionfinaletableau031208_GST.csv" #set Fichier "/genomics/link/Tau/GSTControl/GST_interacting_proteins_laetitia.csv" set LesLignes [LesLignesDuFichier $Fichier] foreach Ligne $LesLignes { set LesMots [split $Ligne ";"] if {[regexp "^Protein" $Ligne]} { set LesHeaders $LesMots set InterrogeListTauControl(ListOf,headers) $LesHeaders continue } #set ProteinName [lindex $LesMots 0] #set GI [lindex [split [lindex $LesMots 1] "|"] 1] set ProteinName [lindex $LesMots 1] set GI [lindex [split [lindex $LesMots 2] "|"] 1] lappend InterrogeListTauControl(ListOf,GI) $GI set InterrogeListTauControl($GI,ProteinName) $ProteinName } return [InterrogeListTauControl $Qui $Quoi] } proc InterrogeLocalisation {args} { global TableauLocalisationDesPAB #unset #$File Chromosome $Chrom LesNoms #$File Contig $Cont LesNoms #$File Chromosome $Chrom $Nom #$File LesNoms #$File Nom $Nom ##Out Detail d'une localisation => Liste avec comme elements : #0:Nom #1:InfoLocalisation #2:ExpectDeRef #3:Expect #4:ScoreDeRef #5:Score #6:PId #7:DQ #8:FQ #9:Chrom #10:DSurChr #11:FSurChr #12:SensSurChr #13:Contig #14:Fragment #15:DSurCont #16:FSurCont #17:OrientationSurCont #18:SensSurCont #19:BandesCyto #20:Info (BestPolyLoc BestLoc) #21:source ( "" = sequence initiale ; prottfa = proteine de reference ; mrnatfa_Homo_sapiens = meilleur mRNA humain trouve if {$args == "unset"} { if {[info exists TableauLocalisationDesPAB]} {unset TableauLocalisationDesPAB} return } set Quoi [join $args ","] if {[info exists TableauLocalisationDesPAB($Quoi)]} { return [set TableauLocalisationDesPAB($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauLocalisationDesPAB($File,EstCharge)]} {return} ###################CHARGE Localisation des boites sur genome######################### set TableauLocalisationDesPAB($File,EstCharge) 1 ChargeFichierLocalisation TableauLocalisationDesPAB $File if {[info exists TableauLocalisationDesPAB($Quoi)]} { return [set TableauLocalisationDesPAB($Quoi)] } return } proc InterrogeMAIA {args} { Wup "Permet de questionner les infos MAIA" Wup "Base sur le fichier .gal qui contient la position sur la plaque des sondes" global InfoMAIA ############################## #GPR FILE is BLOCK ROW COLUMN# ############################## #Arguments: ########### #Quelques exemples toujours dispo #Quoi - Liste de tout ce qui interrogeable #ATF - Version du Axon Text File format #LesDataFields - Nom des colonnes de donnees #NDataFields - Nb de colonne de donnee #NbBlock - Nombre de block #NbColumn - Nombre de colonne #NbRow - Nombre de ligne #NMaxOptionalHeader - Nombre maximum de ligne dans le header if {$args == "unset"} { if {[info exists InfoMAIA]} {array unset InfoMAIA} return "" } set Quoi [join $args ","] if {[info exists InfoMAIA($Quoi)]} {return [set InfoMAIA($Quoi)]} set FichierACharger [lindex $args 0] if {[info exists InfoMAIA($FichierACharger,EstVide)]} {return ""} if {$Quoi=="$FichierACharger,Decharge"} { DechargeInfoMAIA $FichierACharger return "" } ###################CHARGE le Fichier avec les MAIA######################### if {! [info exists InfoMAIA($FichierACharger,EstCharge)]} { set InfoMAIA($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeInfoMAIA InfoMAIA $FichierACharger] if {$ResultatCharge != ""} { set InfoMAIA($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoMAIA($Quoi)]} {return ""} return [set InfoMAIA($Quoi)] } proc InterrogeMesKEGG {args} { #unset #Type = EC ou Pathway ou Kegg #Id == access from EC ou Pathway ou Kegg #LesNoms #LesPathway #LesEC #LesKegg #LesPathwayEtKeggEtEC #$Nom LesPathwayEtKeggEtEC #$Nom LesPathway #$Nom LesEC #$Nom LesKegg #$Type $Id LesNoms #$Type $Id Definition global TableauInterrogationDeMesKEGG if {$args == "unset"} { if {[info exists TableauInterrogationDeMesKEGG]} {unset TableauInterrogationDeMesKEGG} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationDeMesKEGG($Quoi) ]} {return [set TableauInterrogationDeMesKEGG($Quoi)]} if {[info exists TableauInterrogationDeMesKEGG(EstCharge)]} {return} ###################CHARGE Pathway######################### ChargeMesKEGG TableauInterrogationDeMesKEGG set TableauInterrogationDeMesKEGG(EstCharge) 1 if {![info exists TableauInterrogationDeMesKEGG($Quoi)]} {return} return [set TableauInterrogationDeMesKEGG($Quoi)] } proc InterrogeMesOMIM {args} { global TableauFichierMesOMIM #LesOMIM #LesNoms #OMIM $OMIM LesNoms #OMIM $OMIM Definition #$Nom LesOMIM if {$args == "unset"} { if {[info exists TableauFichierMesOMIM]} {unset TableauFichierMesOMIM} return "" } set Quoi [join $args ","] if {[info exists TableauFichierMesOMIM($Quoi)]} {return [set TableauFichierMesOMIM($Quoi)]} if {[info exists TableauFichierMesOMIM(EstCharge)]} {return} ###################CHARGE Mes OMIM######################### set TableauFichierMesOMIM(EstCharge) 1 Espionne "MesOMIM is loading ..." ChargeMesOMIM TableauFichierMesOMIM Espionne "MesOMIM is loaded" if {[info exists TableauFichierMesOMIM($Quoi)]} {return [set TableauFichierMesOMIM($Quoi)]} return } proc InterrogeMesRetNet {args} { global TableauFichierMesRetNet #LesRetNet #LesNoms #RetNet $RetNet LesNoms #RetNet $RetNet Definition #$Nom LesRetNet if {$args == "unset"} { if {[info exists TableauFichierMesRetNet]} {unset TableauFichierMesRetNet} return "" } set Quoi [join $args ","] if {[info exists TableauFichierMesRetNet($Quoi)]} {return [set TableauFichierMesRetNet($Quoi)]} if {[info exists TableauFichierMesRetNet(EstCharge)]} {return} ###################CHARGE Mes RetNet######################### set TableauFichierMesRetNet(EstCharge) 1 Espionne "MesRetNet is loading ..." ChargeMesRetNet TableauFichierMesRetNet Espionne "MesRetNet is loaded" if {[info exists TableauFichierMesRetNet($Quoi)]} {return [set TableauFichierMesRetNet($Quoi)]} return } proc InterrogeMouseUbiquitin {Qui Quoi} { global InterrogeMouseUbiquitin if {$Quoi==""} { set Quoi Ubi} if {[info exists InterrogeMouseUbiquitin($Qui,$Quoi)]} { return $InterrogeMouseUbiquitin($Qui,$Quoi) } if {[info exists InterrogeMouseUbiquitin("EstCharge")]} { return "" } set InterrogeMouseUbiquitin("EstCharge") 1 set File "/genomics/link/FLD/Input/UbiquitinMouseStringId" foreach Ligne [LesLignesDuFichier $File] { set IdString [string trim $Ligne] set InterrogeMouseUbiquitin($IdString,Ubi) "YES" } return [InterrogeMouseUbiquitin $Qui $Quoi] } proc InterrogeNames {{Qui ""} {Quoi ""} {Org ""}} { #Name contient la ref global InterrogeNames if {$Qui == "Reset"} { if {[info exists InterrogeNames]} { unset InterrogeNames } return "" } if {[info exists InterrogeNames($Qui,$Quoi,$Org)]} {return $InterrogeNames($Qui,$Quoi,$Org)} if {[info exists InterrogeNames("EstCharge",$Org)]} {return ""} set InterrogeNames("EstCharge",$Org) 1 if {$Org=="Mouse"} { set LesRepertoires [LesRepertoires "Mouse" "Mod"] } if {$Org=="Rat"} { set LesRepertoires [LesRepertoires "Rat" "Mod"] } if {$Org=="SpliRet"} { set RepertoireSourisTfactor "[RepertoireDuGenome]/FichiersInitial/SOURIS_Tfactor" set LesRepertoires [list $RepertoireSourisTfactor] } foreach Repertoire $LesRepertoires { foreach File [glob -nocomplain "$Repertoire/*"] { set Cluster [file tail $File] regsub {\.[^\.]+$} $Cluster "" Cluster lappend InterrogeNames(ListOf,Cluster,$Org) $Cluster set LesAccess [LaSequenceDuTFAs $File "LaListeDesAccess" ] foreach Name $LesAccess { lappend InterrogeNames($Cluster,Name,$Org) $Name lappend InterrogeNames($Name,Cluster,$Org) $Cluster } } } return [InterrogeNames $Qui $Quoi $Org] } proc InterrogeOMIM {args} { global TableauFichierOMIM #LesOMIM #OMIM $OMIM LesInfos ###Details### ##LesInfos est une liste de liste dont chaque element est une des localisations#### ###Chaque Localisation est une liste dont les elements sont : #index 0 : OMIM number #index 1 : Chromosome #index 2 : Liste contennant la borne min et max sur le chromosome #index 3 : la localisation non-traitee donnee par OMIM #index 4 : MapEntry number #index 5 : Liste contennant les GeneName #index 6 : le status de ces Gene #index 7 : liste contennant Les methodes utilisees pour le mapping #index 8 : Commentaires #index 9 : Titre du OMIM #index 10: liste contennant Les desordres occasionnees (maladies) #index 11: liste contennant les equivalents murins #index 12: Reference #index 13: Liste contennant la date jour mois puis annee if {$args == "unset"} { if {[info exists TableauFichierOMIM]} {unset TableauFichierOMIM} return "" } set Quoi [join $args ","] if {[info exists TableauFichierOMIM($Quoi)]} {return [set TableauFichierOMIM($Quoi)]} if {[info exists TableauFichierOMIM(EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauFichierOMIM(EstCharge) 1 Espionne "OMIM is loading ..." ChargeOMIM TableauFichierOMIM Espionne "OMIM is loaded" if {[info exists TableauFichierOMIM($Quoi)]} {return [set TableauFichierOMIM($Quoi)]} return } proc InterrogeOrf2Cluster2Access2Def2Expression {args} { global TableauOrf2Cluster2Access2Def2Expression if {$args == "unset"} { if {[info exists TableauOrf2Cluster2Access2Def2Expression]} { unset TableauOrf2Cluster2Access2Def2Expression } return "" } set Quoi [join $args ","] if {[info exists TableauOrf2Cluster2Access2Def2Expression($Quoi)]} { if {![regexp "LesExpressions" $Quoi]} { return [ElimineLesRedondancesDansUneListe [set TableauOrf2Cluster2Access2Def2Expression($Quoi)]] } else { return [set TableauOrf2Cluster2Access2Def2Expression($Quoi)] } } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauOrf2Cluster2Access2Def2Expression($File,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauOrf2Cluster2Access2Def2Expression($File,EstCharge) 1 ChargeOrf2Cluster2Access2Def2Expression TableauOrf2Cluster2Access2Def2Expression $File if {[info exists TableauOrf2Cluster2Access2Def2Expression($Quoi)]} { if {![regexp "LesExpressions" $Quoi]} { return [ElimineLesRedondancesDansUneListe [set TableauOrf2Cluster2Access2Def2Expression($Quoi)]] } else { return [set TableauOrf2Cluster2Access2Def2Expression($Quoi)] } } return } proc InterrogeOriginalAnnotAffymetrix {args} { Wup "Permet de questionner les infos de la puce Affymetrix UG133A 2.0" Wup "Voir aussi decharge et charge" global OriAnnotAffy #Arguments: ########### #Index est le numero unique attribue en fonction de la ligne dans le fichier affymetrix #Pour faire la correspondance entre les deux #ListOfProbeSet - Liste des ProbeSet disponibles #$Index RefSeq - Access RefSeq si il existe #$AccRefSeq Index - Index du RefSeq #$IndexOuAccRefSeq Probe_Set_Name - Nom du Probe Set (11 references) peut etre une liste # IndexOuAccRefSeq Description - Description # IndexOuAccRefSeq Sequence_Type - # IndexOuAccRefSeq repAccession - Access de la sequence utilisee # IndexOuAccRefSeq GeneName - Nom du gene # IndexOuAccRefSeq Product - # IndexOuAccRefSeq subcluster - Cluster Unigene # IndexOuAccRefSeq fullLengths - Les access des sequences completes if {$args == "unset"} { if {[info exists OriAnnotAffy]} {array unset OriAnnotAffy} return "" } set FichierACharger [lindex $args 0] if {! [file exists "$FichierACharger"]} { #Mouse430_2_annot.txt #HG-U133_Plus_2_annot.txt #CE FICHIER EST TELECHARGER DU SITE AFFYMETRIX .csv ET TRANSFORME EN Tab Delimited File set RepAffy "[Affymetrix_Dir]" #Mouse430_2_original_annot.txt set FichierACharger "$RepAffy/${FichierACharger}/Annotation/${FichierACharger}_original_annot.txt" if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" return "" } } set Quoi [join [concat $FichierACharger [lrange $args 1 end]] ","] #set Quoi [join $args ","] if { [info exists OriAnnotAffy($Quoi)]} {return [set OriAnnotAffy($Quoi)]} if {! [info exists OriAnnotAffy($FichierACharger,EstCharge)]} {set OriAnnotAffy($FichierACharger,EstCharge) 0} if {$Quoi=="Decharge"} { DechargeOriginalAnnotAffymetrix $FichierACharger return "" } if { [info exists OriAnnotAffy($FichierACharger,EstVide)]} {return ""} if { [info exists OriAnnotAffy($Quoi)]} {return [set OriAnnotAffy($Quoi)]} ###################CHARGE le Fichier avec les InfosAffymetrix######################### if {! [info exists OriAnnotAffy($FichierACharger,EstCharge)] || [set OriAnnotAffy($FichierACharger,EstCharge)]=="0"} { set OriAnnotAffy($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeOriginalAnnotAffymetrix OriAnnotAffy $FichierACharger] if {$ResultatCharge != ""} { set OriAnnotAffy($FichierACharger,EstVide) 1 return "" } } if {! [info exists OriAnnotAffy($Quoi)]} {return ""} return [set OriAnnotAffy($Quoi)] } proc InterrogeOrtholHGU133Plus2 {{Qui ""} {Quoi ""}} { global InterrogeOrtholHGU133Plus2 if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists InterrogeOrtholHGU133Plus2($Qui,$Quoi)]} {return $InterrogeOrtholHGU133Plus2($Qui,$Quoi)} if {[info exists InterrogeOrtholHGU133Plus2("EstCharge")]} {return ""} set InterrogeOrtholHGU133Plus2("EstCharge") 1 set Fichier "/genomics/link/Tau/GSTRdCVF/BlastpSurStringPoulet/Chicken.na25.orthologHuman.csv" foreach Ligne [LesLignesDuFichier $Fichier] { set LesMots [split $Ligne ","] if {[regexp "^\"Probe" $Ligne]} { set LesHeaders $LesMots set InterrogeOrtholHGU133Plus2(ListOf,headers) $LesHeaders continue } set PsPoulet [lindex $LesMots 0] regsub -all "\"" $PsPoulet "" PsPoulet set PucePoulet [lindex $LesMots 1] regsub -all "\"" $PucePoulet "" PucePoulet set PsOrthol [lindex $LesMots 2] regsub -all "\"" $PsOrthol "" PsOrthol set PuceOrthol [lindex $LesMots 3] regsub -all "\"" $PuceOrthol "" PuceOrthol lappend InterrogeOrtholHGU133Plus2($PsPoulet,PsOrthol) $PsOrthol } return [InterrogeOrtholHGU133Plus2 $Qui $Quoi] } proc InterrogePathway {args} { #$Fichier Pathway #$Fichier Organisme #$Fichier LesDefinitions #$Fichier LesCoordonnees #$Fichier LesCompound #$Fichier LesKegg #$Fichier Forme $Forme XMin $XMin YMin $YMin XMax $XMax YMax $YMax LesConcernes global TableauInterrogationPathway if {$args == "unset"} { if {[info exists TableauInterrogationPathway]} {unset TableauInterrogationPathway} return "" } set FichierPathway [lindex $args 0] if {![file exists $FichierPathway]} {return} set Quoi [join $args ","] if {[info exists TableauInterrogationPathway($Quoi)]} {return [set TableauInterrogationPathway($Quoi)]} if {[info exists TableauInterrogationPathway($FichierPathway,EstCharge)]} {return} ###################CHARGE Pathway######################### ChargePathway TableauInterrogationPathway $FichierPathway set TableauInterrogationPathway($FichierPathway,EstCharge) 1 if {![info exists TableauInterrogationPathway($Quoi)]} {return} return [set TableauInterrogationPathway($Quoi)] } proc InterrogePathways {args} { global TabPathways #$Fichier $Nom LesPathways if {$args == "unset"} { if {[info exists TabPathways]} {unset TabPathways} return "" } set File [lindex $args 0] set Quoi [join $args ","] if {[info exists TabPathways($Quoi)]} {return [set TabPathways($Quoi)]} if {[info exists TabPathways($File,EstCharge)]} {Espionne "estcharge !";return} set FichierACharger [lindex $args 0] ################### CHARGE #################### set TabPathways(EstCharge) 1 ChargeFichierPathways TabPathways $FichierACharger if {[info exists TabPathways($Quoi)]} {return [set TabPathways($Quoi)]} return } proc InterrogePfamDesFrom1500 {{Qui ""} {Quoi ""}} { global InterrogePfamDesFrom1500 if {$Qui==""} { set Qui "ListOf"; set Quoi "Pfam" } if {[info exists InterrogePfamDesFrom1500($Qui,$Quoi)]} {return $InterrogePfamDesFrom1500($Qui,$Quoi)} if {[info exists InterrogePfamDesFrom1500("EstCharge")]} {return ""} set InterrogePfamDesFrom1500("EstCharge") 1 set File "/genomics/link/SpliRetMouse/BindingPfam/BindingPfamFromDes/PfamDesFrom1500.txt" foreach Ligne [LesLignesDuFichier $File] { set elmts [split $Ligne "\t"] set Pfam [lindex $elmts 0] set Des [lindex $elmts 2] set Des [string trim $Des] lappend InterrogePfamDesFrom1500(ListOf,Pfam) $Pfam set InterrogePfamDesFrom1500($Pfam,Des) $Des set InterrogePfamDesFrom1500($Des,Pfam) $Pfam } return [InterrogePfamDesFrom1500 $Qui $Quoi] } proc InterrogePopulationDesClustersCorresAuProfilParticulier {Cluster ASoft CSoft} { #pour linstant ne marche qu'avec lexp 2 #AnalysisSoftware: RMA or dChip #ClusteringSoftware: ClustKMTMEV ClustKMFASABI ClustMMFASABI global InterrogePopulationDesClustersCorresAuProfilParticulier if {$CSoft=="K-Means cluster method from TMEV (TIGR MultiExperiment Viewer(MeV))"} {set CSoft "ClustKMTMEV"} if {$CSoft=="K-Means cluster method from FASABI"} {set CSoft "ClustKMFASABI"} if {$CSoft=="MixtureModel clustering method from FASABI"} {set CSoft "ClustMMFASABI"} if {$Cluster=="reset"} { catch {unset InterrogePopulationDesClustersCorresAuProfilParticulier} return "" } if {[info exists InterrogePopulationDesClustersCorresAuProfilParticulier($Cluster,$ASoft,$CSoft)]} { return $InterrogePopulationDesClustersCorresAuProfilParticulier($Cluster,$ASoft,$CSoft) } set FichierExp2RMA "[RepertoireDuGenome]/transcriptomique/ConeSpe/PopulationClustAcProfilParticulierExp2RMA" set FichierExp2dChip "[RepertoireDuGenome]/transcriptomique/ConeSpe/PopulationClustAcProfilParticulierExp2dChip" foreach LigneRMA [LesLignesDuFichier $FichierExp2RMA] { set LesElmtsRMA [split $LigneRMA " "] set CS [lindex $LesElmtsRMA 0] set Cl [lindex $LesElmtsRMA 1] set Nb [lindex $LesElmtsRMA 2] regsub {\(} $Nb "" Nb regsub {\)} $Nb "" Nb set InterrogePopulationDesClustersCorresAuProfilParticulier($Cl,RMA,$CS) $Nb } foreach LignedChip [LesLignesDuFichier $FichierExp2dChip] { set LesElmtsdChip [split $LignedChip " "] set CS [lindex $LesElmtsdChip 0] set Cl [lindex $LesElmtsdChip 1] set Nb [lindex $LesElmtsdChip 2] regsub {\(} $Nb "" Nb regsub {\)} $Nb "" Nb set InterrogePopulationDesClustersCorresAuProfilParticulier($Cl,dChip,$CS) $Nb } return [InterrogePopulationDesClustersCorresAuProfilParticulier $Cluster $ASoft $CSoft] } proc InterrogeProtAndContigChoisis {args} { global TableauInterrogationProtAndContigChoisis #$Nom ProteineChoisie Access #$Nom ContigChoisi Access #$Nom SeqChoisie #$Nom InfoSeqChoisie #$Nom OrganismeChoisi if {$args == "unset"} { if {[info exists TableauInterrogationProtAndContigChoisis]} {unset TableauInterrogationProtAndContigChoisis} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationProtAndContigChoisis($Quoi)]} { return [set TableauInterrogationProtAndContigChoisis($Quoi)] } set FichierProtEtDesContigsChoisis "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesContigsChoisis" ###################CHARGE ProtAndContig######################### if { [file exists $FichierProtEtDesContigsChoisis] && ![info exists TableauInterrogationProtAndContigChoisis($FichierProtEtDesContigsChoisis,EstCharge)]} { set TableauInterrogationProtAndContigChoisis($FichierProtEtDesContigsChoisis,EstCharge) 1 ChargeProtEtContigChoisis TableauInterrogationProtAndContigChoisis $FichierProtEtDesContigsChoisis } if {![info exists TableauInterrogationProtAndContigChoisis($Quoi)]} {return} return [set TableauInterrogationProtAndContigChoisis($Quoi)] } proc InterrogeProtAndmRNA {args} { global TableauInterrogationProtAndmRNA #$Nom Taille #$Nom Masking #$Nom ReMasking #$Nom MRM #$Nom Rang $Rang Type #$Nom Rang $Rang LesmRNAs #$Nom Rang $Rang LesProteines #$Nom Rang $Rang LesAccessEquivalents #$Nom Rang $Rang LesAccessAbsentsDuBlast #$Nom Rang $Rang LesProteinesAbsentesDuBlast #$Nom Rang $Rang LesmRNAsAbsentesDuBlast #$Nom Rang $Rang BanqueId #$Nom Rang $Rang Access #$Nom Access $Access LesRangs #$Nom Rang $Rang Definition #$Nom Rang $Rang Organism #$Nom Rang $Rang Taille #$Nom Rang $Rang NbElementsDeLaQuery DansLAlignement #$Nom Rang $Rang NbElementsDeLaQuery DansLAlignement #$Nom Rang $Rang NbElementsDeLaQuery DansLe5UTR #$Nom Rang $Rang NbElementsDeLaQuery DansLeCDS #$Nom Rang $Rang NbElementsDeLaQuery DansLe3UTR #$Nom Rang $Rang Expect #$Nom Rang $Rang Score #$Nom Rang $Rang Id #$Nom Rang $Rang LesWarning #$Nom LesRangs if {$args == "unset"} { if {[info exists TableauInterrogationProtAndmRNA]} {unset TableauInterrogationProtAndmRNA} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationProtAndmRNA($Quoi)]} { return [set TableauInterrogationProtAndmRNA($Quoi)] } set Nom [lindex $args 0] set File "[RepertoireDuGenome]/ProtAndmRNA/$Nom" ###################CHARGE ProtAndmRNA######################### if { [file exists $File] && ![info exists TableauInterrogationProtAndmRNA($File,EstCharge)]} { set TableauInterrogationProtAndmRNA($File,EstCharge) 1 ChargeProtAndmRNA TableauInterrogationProtAndmRNA $File } if {![info exists TableauInterrogationProtAndmRNA($Quoi)]} {return} return [set TableauInterrogationProtAndmRNA($Quoi)] } proc InterrogeProtAndmRNAChoisis {args} { global TableauInterrogationProtAndmRNAChoisis #$Nom ProteineChoisie Access #$Nom mRNAChoisi Access #$Nom SeqChoisie #$Nom InfoSeqChoisie #$Nom OrganismeChoisi if {$args == "unset"} { if {[info exists TableauInterrogationProtAndmRNAChoisis]} {unset TableauInterrogationProtAndmRNAChoisis} return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationProtAndmRNAChoisis($Quoi)]} { return [set TableauInterrogationProtAndmRNAChoisis($Quoi)] } set FichierProtEtDesmRNAsChoisis "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis" ###################CHARGE ProtAndmRNA######################### if { [file exists $FichierProtEtDesmRNAsChoisis] && ![info exists TableauInterrogationProtAndmRNAChoisis($FichierProtEtDesmRNAsChoisis,EstCharge)]} { set TableauInterrogationProtAndmRNAChoisis($FichierProtEtDesmRNAsChoisis,EstCharge) 1 ChargeProtEtmRNAChoisis TableauInterrogationProtAndmRNAChoisis $FichierProtEtDesmRNAsChoisis } if {![info exists TableauInterrogationProtAndmRNAChoisis($Quoi)]} {return} return [set TableauInterrogationProtAndmRNAChoisis($Quoi)] } proc InterrogeProteinesJumelles {args} { #$Fichier $Nom LesProteinesJumelles #$Fichier LesNoms global TableauProteinesJumelles if {$args == "unset"} { if {[info exists TableauProteinesJumelles]} {unset TableauProteinesJumelles} return "" } set Fichier [lindex $args 0] if {![file exists $Fichier]} {return} set Quoi [join $args ","] if {[info exists TableauProteinesJumelles($Quoi)]} {return [set TableauProteinesJumelles($Quoi)]} if {[info exists TableauProteinesJumelles($Fichier,EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauProteinesJumelles($Fichier,EstCharge) 1 ChargeProteinesJumelles $Fichier TableauProteinesJumelles if {[info exists TableauProteinesJumelles($Quoi)]} {return [set TableauProteinesJumelles($Quoi)]} return } proc InterrogeProteinsNamesTable {Qui Quoi} { #interroge la table proteins_names de STRING global InterrogeProteinsNamesTable if {[info exists InterrogeProteinsNamesTable($Qui,$Quoi)]} { return $InterrogeProteinsNamesTable($Qui,$Quoi) } if {[info exists InterrogeProteinsNamesTable("EstCharge")]} { return "" } set InterrogeProteinsNamesTable("EstCharge") 1 CanalSqlString set Sql "select protein_id,species_id from items.proteins_names limit 10000" foreach {ProtId SpeId} [SqlExec $Sql "GetList"] { set InterrogeProteinsNamesTable($ProtId,SpeId) $SpeId } CanalSqlDisconnect return [InterrogeProteinsNamesTable $Qui $Quoi] } proc InterrogeRefPfam {{Qui ""} {Quoi ""}} { #mouse ou rat (selon le cas) de la liste des ProchesQuery85 avec le plus de pfam et la plus longue sequence #NB:essaye de choisir un non initial mais peut être le cas #pour la prochaine fois, prendre celui qui a le plus de pfam et les pfam les plus long global InterrogeRefPfam if {[info exists InterrogeRefPfam($Qui,$Quoi)]} {return $InterrogeRefPfam($Qui,$Quoi)} if {[info exists InterrogeRefPfam("EstCharge")]} {return ""} set InterrogeRefPfam("EstCharge") 1 foreach FileProche [glob -nocomplain "[RepertoireDuGenome]/ProchesQuery85/*"] { array unset Tableau1; array unset Tableau2 set RefPfam "" if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set Org Mouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set Org Rat } else { set Org SpliRet } if {$Org=="SpliRet"} { set Cluster [file tail $FileProche] regsub {\.[^\.]+$} $Cluster "" Cluster set Box [InterrogeBox $Cluster Box] set Ref [ExtraitInfo $Box "Ref"] } else { set Box [file tail $FileProche] regsub {\.[^\.]+$} $Box "" Box set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] } if {$Org=="SpliRet"} { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new"} } else { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} } foreach Name [LesLignesDuFichier $FileProche] { set LesPFAMMacsims {}; set LesPFAMMacsimsClean {} set LesPFAMMacsims [FromMacsims $FileMacsims $Name JustPfam] foreach PFAMMacsims $LesPFAMMacsims { if {[regexp "ERROR" $PFAMMacsims] || [regexp "WARN" $PFAMMacsims]} {continue} lappend LesPFAMMacsimsClean $PFAMMacsims } set nombrePFAMMacsims [llength $LesPFAMMacsimsClean] set LongSeq [string length [FromMacsims $FileMacsims $Name SeqDataSansGap]] lappend Tableau1($LongSeq) $Name lappend Tableau2($nombrePFAMMacsims) $Name set InterrogeRefPfam($Box-$Name,nombrePFAMMacsims) $nombrePFAMMacsims } set LesNombresPfam [array names Tableau2] set LesNombresPfam [lsort -integer -decreasing $LesNombresPfam] set LesLongSeq [array names Tableau1] set LesLongSeq [lsort -integer -decreasing $LesLongSeq] set LesNamesInitial [InterrogeNames $Cluster Name $Org] foreach maxpfam $LesNombresPfam { Espionne "maxpfam $maxpfam" Espionne "$Tableau2($maxpfam)" foreach maxlong $LesLongSeq { Espionne "maxlong $maxlong" Espionne "$Tableau1($maxlong)" set premierefois 1; set NameInitialSelec "" set ListInter [ListsIntersection $Tableau2($maxpfam) $Tableau1($maxlong)] Espionne "ListInter $ListInter" foreach NameSelec $ListInter { set cestuninitial 0 foreach NameInitial $LesNamesInitial { if {$NameInitial==$Ref} {set NameInitial $Box} if {$NameSelec==$NameInitial} { if {$premierefois} { set premierefois 0 set NameInitialSelec $NameSelec } set cestuninitial 1 ; break } } if {$cestuninitial} { continue } set Organism [lindex [split $NameSelec "_"] end] if {$Org=="Mouse"} { if {![regexp -nocase "mouse" $Organism] && ![regexp -nocase "mus" $Organism]} {continue} set RefPfam $NameSelec break } if {$Org=="Rat"} { if {![regexp -nocase "rat" $Organism] && ![regexp -nocase "rattus" $Organism]} {continue} set RefPfam $NameSelec break } } if {$RefPfam=="" && $NameInitialSelec!=""} {set RefPfam $NameInitialSelec} if {$RefPfam!=""} { break } } if {$RefPfam!=""} { break } } if {$RefPfam!=""} { set InterrogeRefPfam($Cluster,RefPfam) $RefPfam set InterrogeRefPfam($Box,RefPfam) $RefPfam } } return [InterrogeRefPfam $Qui $Quoi] } proc InterrogeRefs {{Qui ""} {Quoi ""} {Ou ""}} { #pour une ref, te donne le cluster #pour un cluster, te donne la ref #Ou: "/genomics/link/SpliRetMouse/FichiersModifUnique/RefsDesClusters" global InterrogeRefs if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {$Qui == "Reset"} { if {[info exists InterrogeRefs]} { unset InterrogeRefs } return "" } if {$Ou!=""} { if {[info exists InterrogeRefs(File,Name)] && $Ou!=$InterrogeRefs(File,Name)} { unset InterrogeRefs } set Fichier $Ou } else { if {[info exists InterrogeRefs(File,Name)]} { set Ou $InterrogeRefs(File,Name) set Fichier $Ou } else { FaireLire "Il faut donner un nom de fichier la 1ere fois" return "" } } if {[info exists InterrogeRefs($Qui,$Quoi)]} {return $InterrogeRefs($Qui,$Quoi)} if {[info exists InterrogeRefs("EstCharge")]} {return ""} set InterrogeRefs("EstCharge") 1 set InterrogeRefs(File,Name) $Fichier set LesLignes [LesLignesDuFichier $Fichier] set LesHeaders [list Cluster Ref] set InterrogeRefs(ListOf,headers) $LesHeaders foreach Ligne $LesLignes { set LesMots [split $Ligne " "] set Cluster [lindex $LesMots 0] set Ref [lindex $LesMots 1] set Ref [regsub ">" $Ref ""] set InterrogeRefs($Cluster,Ref) $Ref lappend InterrogeRefs($Ref,Cluster) $Cluster lappend InterrogeRefs(ListOf,Cluster) $Cluster } return [InterrogeRefs $Qui $Quoi] } proc InterrogeRepartitionSurGenome {args} { global TableauFichierRepartitionSurGenome #$Fichier LesChromosomes #$Fichier LesTypesDeRegion #$Fichier LesElements #$Fichier TypeDeRegion $TypeDeRegion LesRegions #$Fichier TypeDeRegion $TypeDeRegion LesChromosomes #$Fichier Element $Element LesRegions #$Fichier LesElements #$Fichier Chromosome $Chromosome LesElements #$Fichier Chromosome $Chromosome LesTypesDeRegion #$Fichier Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Qui Debut #$Fichier Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Qui Fin #$Fichier Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Qui LesElements #$Fichier Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Qui NbElements #$Fichier Chromosome $Chromosome TypeDeRegion $TypeDeRegion Region $Qui Taille #$Fichier TypeDeRegion $TypeDeRegion LesRegions if {$args == "unset"} { if {[info exists TableauFichierRepartitionSurGenome]} {unset TableauFichierRepartitionSurGenome} return "" } set Quoi [join $args ","] if {[info exists TableauFichierRepartitionSurGenome($Quoi)]} { return [set TableauFichierRepartitionSurGenome($Quoi)] } set File [lindex $args 0] if {![file exists $File]} {return} if {[info exists TableauFichierRepartitionSurGenome($File,EstCharge)]} {return} ###################CHARGE FichierRepartitionSurGenome######################### set TableauFichierRepartitionSurGenome($File,EstCharge) 1 Espionne "$File is loading ..." ChargeRepartitionSurGenome TableauFichierRepartitionSurGenome $File Espionne "$File loaded ..." if {[info exists TableauFichierRepartitionSurGenome($Quoi)]} {return [set TableauFichierRepartitionSurGenome($Quoi)]} return } proc InterrogeRetNet {args} { global TableauFichierRetNet #LesRetNet #RetNet $RetNet LesInfos ###Details### ##LesInfos est une liste de liste dont chaque element est une des localisations#### ###Chaque Localisation est une liste dont les elements sont : #index 0 : RetNet ref #index 1 : Chromosome #index 2 : Liste contennant la borne min et max sur le chromosome #index 3 : la localisation non-traitee donnee par RetNet #index 4 : Les autres noms de ce gene #index 5 : Definition if {$args == "unset"} { if {[info exists TableauFichierRetNet]} {unset TableauFichierRetNet} return "" } set Quoi [join $args ","] if {[info exists TableauFichierRetNet($Quoi)]} {return [set TableauFichierRetNet($Quoi)]} if {[info exists TableauFichierRetNet(EstCharge)]} {return} ###################CHARGE FichierExonicMap######################### set TableauFichierRetNet(EstCharge) 1 Espionne "RetNet is loading ..." ChargeRetNet TableauFichierRetNet Espionne "RetNet is loaded" if {[info exists TableauFichierRetNet($Quoi)]} {return [set TableauFichierRetNet($Quoi)]} return } proc InterrogeRetrievePIDBetweenPosInMACS {args} { Wup "Permet de questionner les infos des PIDs des domaines obtenus par RetrievePIDBetweenPosInMACSs" Wup "Voir aussi decharge et charge" global TabPIDInAln #Arguments: ########### #$Fichier Debut - Rend la position du debut du domaine (insertion) #$Fichier Fin - Rend la position de fin du domaine (insertion) #$Fichier $Access $Debut $Fin PID - Rend le pourcentage d identite de la zone par rapport a une ref #$Fichier $Access $Debut $Fin Taille - Rend la taille du domaine (insertion) if {$args == "unset"} { if {[info exists TabPIDInAln]} {array unset TabPIDInAln} return "" } set Quoi [join $args ","] if {[info exists TabPIDInAln($Quoi)]} {return [set TabPIDInAln($Quoi)]} set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabPIDInAln($FichierACharger,EstCharge)]} {set TabPIDInAln($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeRetrievePIDBetweenPosInMACS $FichierACharger return "" } if { [info exists TabPIDInAln($FichierACharger,EstVide)]} {return ""} if { [info exists TabPIDInAln($Quoi)]} {return [set TabPIDInAln($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabPIDInAln($FichierACharger,EstCharge)] || [set TabPIDInAln($FichierACharger,EstCharge)]=="0"} { set TabPIDInAln($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeRetrievePIDBetweenPosInMACS TabPIDInAln $FichierACharger] if {$ResultatCharge != ""} { set TabPIDInAln($FichierACharger,EstVide) 1 return "" } } if {![info exists TabPIDInAln($Quoi)]} {return ""} return [set TabPIDInAln($Quoi)] } proc InterrogeRetrievePositionsInMACS {args} { Wup "Permet de questionner les infos des positions des domaines obtenus par RetrievePositionsInMACSs" Wup "Voir aussi decharge et charge" global TabPosInAln #Arguments: ########### #$Fichier LesPositions - Rend toutes les positions demandees #$Fichier $Acc $Pos Position - Rend la position equivalente a la position de $Access a la$Position dans la reference #$Fichier $Acc LesPositions - Rend la position equivalente a la position de $Access a la$Position dans la reference #$Fichier $Groupe Pos - Rend la position du groupe if {$args == "unset"} { if {[info exists TabPosInAln]} {array unset TabPosInAln} return "" } set Quoi [join $args ","] if {[info exists TabPosInAln($Quoi)]} {return [set TabPosInAln($Quoi)]} set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabPosInAln($FichierACharger,EstCharge)]} {set TabPosInAln($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeRetrievePositionsInMACS $FichierACharger return "" } if { [info exists TabPosInAln($FichierACharger,EstVide)]} {return ""} if { [info exists TabPosInAln($Quoi)]} {return [set TabPosInAln($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabPosInAln($FichierACharger,EstCharge)] || [set TabPosInAln($FichierACharger,EstCharge)]=="0"} { set TabPosInAln($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeRetrievePositionsInMACS TabPosInAln $FichierACharger] if {$ResultatCharge != ""} { set TabPosInAln($FichierACharger,EstVide) 1 return "" } } if {![info exists TabPosInAln($Quoi)]} {return ""} return [set TabPosInAln($Quoi)] } proc InterrogeRetrieveResidueInMACS {args} { Wup "Permet de questionner les infos des residus obtenus par RetrieveResidueInMACSs" Wup "Voir aussi decharge et charge" global TabResInAln #Arguments: ########### #$Fichier $Access $Position Residu - Rend le residu a la position $Position #$Fichier $Groupe Pos - Rend la position du groupe if {$args == "unset"} { if {[info exists TabResInAln]} {array unset TabResInAln} return "" } set Quoi [join $args ","] if {[info exists TabResInAln($Quoi)]} {return [set TabResInAln($Quoi)]} set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabResInAln($FichierACharger,EstCharge)]} {set TabResInAln($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeRetrieveResidueInMACS $FichierACharger return "" } if { [info exists TabResInAln($FichierACharger,EstVide)]} {return ""} if { [info exists TabResInAln($Quoi)]} {return [set TabResInAln($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabResInAln($FichierACharger,EstCharge)] || [set TabResInAln($FichierACharger,EstCharge)]=="0"} { set TabResInAln($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeRetrieveResidueInMACS TabResInAln $FichierACharger] if {$ResultatCharge != ""} { set TabResInAln($FichierACharger,EstVide) 1 return "" } } if {![info exists TabResInAln($Quoi)]} {return ""} return [set TabResInAln($Quoi)] } proc InterrogeRonn {args} { #Permet de questionner les infos de Ronn #Voir aussi decharge et charge global InfoRonn if {$args == "unset"} { if {[info exists InfoRonn]} {array unset InfoRonn} return "" } #1 On test si c deja en memoire et si oui on retourne la valeur demandee set Quoi [join $args ","] if {[info exists InfoRonn($Quoi)]} {return [set InfoRonn($Quoi)]} #2 On recupere le fichier (1er argument) set FichierACharger [lindex $args 0] if {! [info exists InfoRonn($FichierACharger,EstCharge)]} {set InfoRonn($FichierACharger,EstCharge) 0} #3 On decharge le cas echeant if {$Quoi=="$FichierACharger,Decharge"} { DechargeRonn $FichierACharger return "" } if { [info exists InfoRonn($FichierACharger,EstVide)]} {return ""} if { [info exists InfoRonn($Quoi)]} {return [set InfoRonn($Quoi)]} #4 On charge les resultats if {! [info exists InfoRonn($FichierACharger,EstCharge)] || [set InfoRonn($FichierACharger,EstCharge)]=="0"} { set InfoRonn($FichierACharger,EstCharge) 1 set ResultatCharge [ChargeRonn InfoRonn $FichierACharger] if {$ResultatCharge != ""} { set InfoRonn($FichierACharger,EstVide) 1 return "" } } if {![info exists InfoRonn($Quoi)]} { return "" } return [set InfoRonn($Quoi)] } proc InterrogeSelectedEST {args} { global TabSelectedEST #unset #$File LesNoms #$File LesAccess #$File LesTissueType #$File LesDevStage #$File LesOrganism #$File Nom $Nom LesAccess #$File Nom $Nom LesTissueType #$File Nom $Nom LesDevStage #$File Nom $Nom LesOrganism #$File Access $Access LesNoms #$File Access $Access LesTissueType #$File Access $Access LesDevStage #$File Access $Access LesOrganism #$File TissueType $TissueType LesAccess #$File TissueType $TissueType LesNoms #$File DevStage $DevStage LesAccess #$File DevStage $DevStage LesNoms #$File Organism $Organism LesAccess #$File Organism $Organism LesNoms set FirstArg [lindex $args 0] if {$FirstArg == "unset"} { if {[info exists TabSelectedEST]} {unset TabSelectedEST}; return } set Quoi [join $args ","] if {[info exists TabSelectedEST($Quoi)]} {return [set TabSelectedEST($Quoi)]} if {[info exists TabSelectedEST($FirstArg,EstCharge)]} {return} if {![file exists $FirstArg]} {return} set TabSelectedEST($FirstArg,EstCharge) 1 LoadSelectedEST TabSelectedEST $FirstArg if {[info exists TabSelectedEST($Quoi)]} {return [set TabSelectedEST($Quoi)]} return } proc InterrogeSeq {{Qui ""} {Quoi ""}} { global InterrogeSeq if {[info exists InterrogeSeq($Qui,$Quoi)]} {return $InterrogeSeq($Qui,$Quoi)} if {[info exists InterrogeSeq("EstCharge")]} {return ""} set InterrogeSeq("EstCharge") 1 set FichierSw "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Sw_Vertebrata" set FichierTr "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Uniprot/Tr_Vertebrata" set FichierVa "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Varsplic/varsplic_Vertebrata" set FichierRn "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-new-proteic_Vertebrata" set FichierRr "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/Refseq/refseq-rel-proteic_Vertebrata" set FichierEn "/genomics/link/SpliRetMouse/database/TousLesTfasAcRedond/ENSEMBL61/Ensembl_Vertebrata" set ListeFichier [list $FichierSw $FichierTr $FichierVa $FichierRn $FichierRr $FichierEn] foreach Fichier $ListeFichier { foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess" "" "" ForceAccessFirst] { set TFA [LaSequenceDuTFAs $Fichier $Access] set Seq [string toupper [QueLaSequenceDuTexteTFA $TFA]] set InterrogeSeq($Access,Tfa) $TFA set InterrogeSeq($Access,Seq) $Seq lappend InterrogeSeq($Seq,Access) $Access } } return [InterrogeSeq $Qui $Quoi] } proc InterrogeSortieNcbi {{Qui ""} {Quoi ""}} { global InterrogeSortieNcbi if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists InterrogeSortieNcbi($Qui,$Quoi)]} {return $InterrogeSortieNcbi($Qui,$Quoi)} if {[info exists InterrogeSortieNcbi("EstCharge")]} {return ""} set InterrogeSortieNcbi("EstCharge") 1 #set Fichier "/genomics/link/Tau/sortie_ncbi.txt" set Fichier "/genomics/link/Tau/Dec2008/GSTRdCVF/sortie_ncbi.txt" set InterrogeSortieNcbi(ListOf,headers) [list Acc Gi] set LesLignes [LesLignesDuFichier $Fichier] foreach Ligne $LesLignes { if {$Ligne==""} { continue } elseif {[regexp {^[0-9]{1,2}:} $Ligne ]} { set Access [StringApres ":" dans $Ligne] set Access [string trim $Access] } elseif {[regexp {^gi\|} $Ligne ]} { set GI [lindex [split $Ligne "|"] 1] set DB [lindex [split $Ligne "|"] 2] set InterrogeSortieNcbi($GI,Access) $Access set InterrogeSortieNcbi($Access,GI) $GI set InterrogeSortieNcbi($GI,DB) $DB set InterrogeSortieNcbi($GI,Orga) $Orga } else { set index1 [expr [string first "\[" $Ligne] + 1] set index2 [expr [string first "\]" $Ligne] - 1] set Orga [string range $Ligne $index1 $index2] } } return [InterrogeSortieNcbi $Qui $Quoi] } proc InterrogeSortieNcbiControl {{Qui ""} {Quoi ""}} { global InterrogeSortieNcbiControl if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists InterrogeSortieNcbiControl($Qui,$Quoi)]} {return $InterrogeSortieNcbiControl($Qui,$Quoi)} if {[info exists InterrogeSortieNcbiControl("EstCharge")]} {return ""} set InterrogeSortieNcbiControl("EstCharge") 1 set Fichier "/genomics/link/Tau/Dec2008/GSTControl/sortie_ncbi_control.txt" set InterrogeSortieNcbiControl(ListOf,headers) [list Acc Gi] set LesLignes [LesLignesDuFichier $Fichier] foreach Ligne $LesLignes { if {$Ligne==""} { continue } elseif {[regexp {^[0-9]{1,2}:} $Ligne ]} { set Access [StringApres ":" dans $Ligne] set Access [string trim $Access] } elseif {[regexp {^gi\|} $Ligne ]} { set GI [lindex [split $Ligne "|"] 1] set DB [lindex [split $Ligne "|"] 2] set InterrogeSortieNcbiControl($GI,Access) $Access set InterrogeSortieNcbiControl($Access,GI) $GI set InterrogeSortieNcbiControl($GI,DB) $DB set InterrogeSortieNcbiControl($GI,Orga) $Orga } else { set index1 [expr [string first "\[" $Ligne] + 1] set index2 [expr [string first "\]" $Ligne] - 1] set Orga [string range $Ligne $index1 $index2] } } return [InterrogeSortieNcbiControl $Qui $Quoi] } proc InterrogeSpeciesTable {Qui Quoi} { #interroge la table species de STRING global InterrogeSpeciesTable if {[info exists InterrogeSpeciesTable($Qui,$Quoi)]} { return $InterrogeSpeciesTable($Qui,$Quoi) } if {[info exists InterrogeSpeciesTable("EstCharge")]} { return "" } set InterrogeSpeciesTable("EstCharge") 1 CanalSqlString set Sql "select species_id,official_name from items.species" foreach {SpeId SpeName} [SqlExec $Sql "GetList"] { set InterrogeSpeciesTable($SpeId,SpeName) $SpeName set InterrogeSpeciesTable($SpeName,SpeId) $SpeId } CanalSqlDisconnect return [InterrogeSpeciesTable $Qui $Quoi] } proc InterrogeTissueType {args} { global TableauInterrogationTissueType #unset #LesTissues #LesNoms #$Nom LesTissues #$Nom LesEST #EST $Access LesTissues #EST $Access LesNoms #EST $Access Tissue $Tissue n #Tissue $Tissue LesNoms #Tissue $Tissue LesEST #Tissue $Tissue n #$Nom Tissue $Tissue n #$Nom Tissue $Tissue LesEST #$Nom Tissue $Tissue EST $Access n if {$args == "unset"} { if {[info exists TableauInterrogationTissueType]} { unset TableauInterrogationTissueType } return "" } set Quoi [join $args ","] if {[info exists TableauInterrogationTissueType($Quoi)]} { return [set TableauInterrogationTissueType($Quoi)] } set File1 "[RepertoireDuGenome]/fiches/TissueType" ###################CHARGE FichierExonicMap######################### if {[file exists $File1] && ![info exists TableauInterrogationTissueType($File1,EstCharge)]} { set TableauInterrogationTissueType($File1,EstCharge) 1 ChargeTissueType TableauInterrogationTissueType $File1 } set File2 "[RepertoireDuGenome]/fiches/EffectifsDesTissueType" if {[file exists $File2] && ![info exists TableauInterrogationTissueType($File2,EstCharge)]} { set TableauInterrogationTissueType($File2,EstCharge) 1 ChargeEffectifDesTissueType TableauInterrogationTissueType $File2 } if {[info exists TableauInterrogationTissueType($Quoi)]} { return [set TableauInterrogationTissueType($Quoi)] } return } proc InterrogeTousLesCodesAvecUneListe {FichierSelection FichierTous} { foreach Ligne [LesLignesDuFichier $FichierTous] { scan $Ligne "%s %s" gscope codeaffy set Gscope($codeaffy) $gscope } foreach Ligne [LesLignesDuFichier $FichierSelection] { scan $Ligne "%s" codeaffy if {[info exists Gscope($codeaffy)]} { lappend LesGscope "$Gscope($codeaffy)" } else { lappend LesManquants $codeaffy } } Espionne [llength $LesGscope] return $LesManquants } proc InventOi {{Qui ""} {Quoi ""} {Defaut ""}} { LogWscope [Environ] set RG $Qui if { ! [file exists "$RG/beton"]} { return $Defaut } scan [PremiereLigneDuFichier "$RG/fiches/bornesdespabs"] "%s" Premier if {[file exists "$RG/blastp/$Premier"] && [file exists "$RG/taxobla/$Premier"]} { return "lightgreen" } if {[file exists "$RG/taxobla/$Premier"]} { return "yellow" } return "orange" } proc Inventaire {{GetWhat ""}} { if {$GetWhat==""} { set GetWhat "Show" } set Total [format "%5d" [llength [ListeDesPABs]]] set Sortie [list "$Total [PreFixe] are available\n"] foreach Toire [lsort [glob -type d "[RepertoireDuGenome]/*"]] { set Queue [file tail $Toire] set BeauQ [format "%16s" $Queue] set Rep $Toire set BeauToire [format "%-15s" $Toire] if { ! [file exists $Rep] } { lappend Sortie "$BeauToire doesn't exists." continue } set LesPABs [lsort [glob -nocomplain "$Rep/[PreFixe]*"]] set LesTous [lsort [glob -nocomplain "$Rep/*"]] set N [llength $LesPABs] set A [expr [llength $LesTous] - [llength $LesPABs]] set BeauN [format "%5d" $N] set BeauA [format "%5d" $A] if {[info exists SesPABs]} { unset SesPABs } set LesExt {} foreach PAB $LesPABs { if {[regexp "[PreFixe]\[0-9\]+(\[^0-9\]*)" $PAB Match Ext]} { lappend LesExt $Ext lappend SesPABs($Ext) $PAB } } set LesExt [lsort -unique $LesExt] if {[llength $LesExt]>1} { foreach Ext $LesExt { set LesPs $SesPABs($Ext) set N [llength $LesPs] set A [expr [llength $LesTous] - [llength $LesPs]] set BeauN [format "%5d" $N] set BeauA [format "%5d" $A] lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire" } } else { set Ext "" lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire" } } set LesFiches [lsort [glob -nocomplain "[RepertoireDuGenome]/fiches/*"]] set LesPastouche [lsort [glob -nocomplain "[RepertoireDuGenome]/pastouche/*"]] set Sortie [concat $Sortie [list "\n\n"] $LesFiches] set Sortie [concat $Sortie [list "\n\n"] $LesPastouche] if {[OnTraite OI]} { lappend Sortie "\n\n" [BlastLocalInventaire] } set LeContenuPasTouche {} foreach P [lsort [GlobRecursif "" "[RepertoireDuGenome]/pastouche"]] { if {[info exists DejaVu($P)]} { FaireLire "$P deja vu en \n$DejaVu($P)" } set DejaVu($P) $P if {[file type $P]=="directory"} { continue } lappend LeContenuPasTouche [ContenuDuFichier $P] } set ContenuPasTouche [join $LeContenuPasTouche "\n"] lappend Sortie "\nContenu des pastouche" lappend Sortie $ContenuPasTouche set Sortie [join $Sortie "\n"] #rR ............................................... on peut faire Affiche meme avec Wscope mais faut faire postpone des boutons if {[PourWscope]} { return "

$Sortie

" } if {$GetWhat=="GetText"} { return $Sortie } set F [Affiche $Sortie "AvecShow" "Inventory at [Date Nice]"] set B [BoutonneLaFenetre $F "NewInventory\nNew Check"] $B configure -background "yellow" bind $B <1> Inventaire bind $B CheckInventaire return $F } proc InventaireDeLaDatabaseClonage {} { set Choix [ChoixParmi [list "Show_OligosTogether" "Show_Oligos" "Show_VirtualPPCR" "Show_AllRec1" "Show_AllRec2" "Show_VEDidier" "Show_Localisation" "" "Show_Matrices" "Show_pDONR_pDEST" "Show_pDONR" "Show_pDEST" "Show_Signals" "Show_BrocOli" "Show_GluOli" "Show_pEntr" "Show_CoOl" "Show_Spine" "" "Show_RestEnzymes" "Show_RestEnzymesHits" "Show_RareCodon" "" "Browse_Oligos" "Browse_PPCR" ]] switch $Choix { "Show_OligosTogether" {AffichePof "AllPs"} "Show_Oligos" {AffichePof} "Show_VirtualPPCR" {AfficheVirtualPPCR} "Show_AllRec1" {AfficheLesRec1} "Show_AllRec2" {AfficheLesRec2} "Show_VEDidier" {ShowVEDidier} "Show_Localisation" {LocalisationDesVirtualPPCRs} "Show_Matrices" {InventaireDesMatrices} "Show_pDONR_pDEST" {InventaireDesVecteurs "pDONR_pDEST"} "Show_pDONR" {InventaireDesVecteurs "pDONR"} "Show_pDEST" {InventaireDesVecteurs "pDEST"} "Show_Signals" {InventaireDesSignaux "Show"} "Show_BrocOli" {InventaireDesBrocOli "Show"} "Show_GluOli" {InventaireDesGluOli "Show"} "Show_pEntr" {InventaireDesPEntr "Show"} "Show_Signals" {RestrictionEnzymes} "Show_CoOl" {CoOlPourTous} "Show_Spine" {SpineSummary "Show"} "Show_RareCodon" {AfficheSlidingCodonRarePour} "Show_RestEnzymes" {ShowRestrictionEnzyme} "Show_RestEnzymesHits" {RestrictionEnzymesStatistics "ShowHits"} "Browse_Oligos" {InventaireDesOligos} "Browse_PPCR" {InventaireDesPPCR} default {} } return $Choix } proc InventaireDesAccessDesMSF {Repertoire} { set LocalDir [pwd] cd $Repertoire set LesMSFs [glob -nocomplain "*.msf"] foreach Fichier $LesMSFs { if { ! [DecortiqueUnMSF $Fichier LesAccess Sequences]} { continue } set Fichier [file tail $Fichier] foreach Access $LesAccess { set ACCESS [string toupper $Access] lappend SesMSFs($ACCESS) $Fichier if { ! [info exists DejaVu($ACCESS)]} { lappend TousLesAccess $Access lappend TousLesACCESS $ACCESS } set DejaVu($ACCESS) 1 } } foreach Access $TousLesAccess ACCESS $TousLesACCESS { set LesMSFs [set SesMSFs($ACCESS)] if {[set N [llength $LesMSFs]] > 1} { set Texte [format "Vu %2d fois %-20s" $N $Access] foreach FicMSF $LesMSFs { append Texte [format "%-18s" $FicMSF] } Espionne $Texte } } exit } proc InventaireDesBrocOli {{Action ""}} { if {$Action==""} { set Action "Show" } return [AfficheFichier [BrocOli "FileName"]] } proc InventaireDesFichiersClonage {{Rep ""} {OnVeut AfficherTout}} { #rR depuis 2007/07/27 if {$Rep==""} { set Rep "PAY" } if {$Rep==""} { set Rep "ProGS" } if { ! [ClonInventoryExists Listes]} { ClonInventorySet Listes [Debroussaille $Rep] } set Listes [ClonInventory Listes] set LesFichiersOligos [lindex $Listes 0] set LesFichiersOligos_NA [lindex $Listes 1] set LesFichiersPPCR [lindex $Listes 2] set LesFichiersPPCR_NA [lindex $Listes 3] set LesDecomposOligos [lindex $Listes 4] set LesDecomposOligos_NA [lindex $Listes 5] set LesDecomposPPCR [lindex $Listes 6] set LesDecomposPPCR_NA [lindex $Listes 7] set LesFichiersSignaux [lindex $Listes 8] set LesCommandesDOligos [lindex $Listes 9] set TousLesAvantsGroupes {} set TousLesApresGroupes {} ClonInventorySet Oligos Sujets {} foreach Fichier $LesFichiersOligos Decompo $LesDecomposOligos { foreach Sujet [lindex $Decompo 0] LesAv [lindex $Decompo 1] LesAp [lindex $Decompo 2] { lappend TousLesAvantsGroupes [join $LesAv "_"] lappend TousLesApresGroupes [join $LesAp "_"] ClonInventoryAppend $Sujet Oligos [list $Fichier [list $Sujet $LesAv $LesAp]] ClonInventoryAppend Oligos Sujets $Sujet set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]] set TexCoAvAp [join $CoAvAp " === "] ClonInventoryAppend $TexCoAvAp $Fichier } } ClonInventorySet Oligos Sujets [lsort -unique [ClonInventory Oligos Sujets]] if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos"} { set Fen [AfficheVariable [join [ClonInventory Oligos Sujets] "\n"] "AvecShowItsOligos" "ConstructionsWithOligos"] if {$OnVeut=="AfficherOligos"} { return $Fen } } if {$OnVeut=="RetournerOligos"} { return [ClonInventory Oligos Sujets] } ClonInventorySet Oligos_NA Sujets {} foreach Fichier $LesFichiersOligos_NA Decompo $LesDecomposOligos_NA { set Sujet [lindex $Decompo 0] set LesAv [lindex $Decompo 1] lappend TousLesAvantsGroupes [join $LesAv "_"] set LesAp [lindex $Decompo 2] lappend TousLesApresGroupes [join $LesAp "_"] ClonInventoryAppend $Sujet Oligos_NA [list $Fichier $Decompo] ClonInventoryAppend Oligos_NA Sujets $Sujet set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]] set TexCoAvAp [join $CoAvAp " === "] ClonInventoryAppend $TexCoAvAp $Fichier } ClonInventorySet Oligos_NA Sujets [lsort -unique [ClonInventory Oligos_NA Sujets]] if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos_NA"} { set Fen [AfficheVariable [join [ClonInventory Oligos_NA Sujets] "\n"] "AvecShowItsOligos_NA" "ConstructionsWithOligos_NA"] if {$OnVeut=="AfficherOligos_NA"} { return $Fen } } if {$OnVeut=="RetournerOligos_NA"} { return [ClonInventory Oligos_NA Sujets] } ClonInventorySet PPCR_NA Sujets {} foreach Fichier $LesFichiersPPCR_NA Decompo $LesDecomposPPCR_NA { set Sujet [lindex $Decompo 0] set LesAv [lindex $Decompo 1] set LesAp [lindex $Decompo 2] ClonInventoryAppend $Sujet PPCR_NA [list $Fichier $Decompo] ClonInventoryAppend PPCR_NA Sujets $Sujet set CoAvAp [list $Sujet $LesAv $LesAp] set TexCoAvAp [join $CoAvAp " +++ "] ClonInventoryAppend $TexCoAvAp $Fichier } ClonInventorySet PPCR_NA Sujets [lsort -unique [ClonInventory PPCR_NA Sujets]] if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} { set Fen [AfficheVariable [join [ClonInventory PPCR_NA Sujets] "\n"] "AvecShowItsPPCR_NA" "ConstructionsWithPPCR_NA"] if {$OnVeut=="AfficherPPCR_NA"} { return $Fen } } if {$OnVeut=="RetournerPPCR_NA"} { return [ClonInventory PPCR_NA Sujets] } ClonInventorySet PPCR Sujets {} foreach Fichier $LesFichiersPPCR Decompo $LesDecomposPPCR { set LesSu [lindex $Decompo 0] set LesAv [lindex $Decompo 1] set LesAp [lindex $Decompo 2] foreach Sujet $LesSu Avs $LesAv Aps $LesAp { ClonInventoryAppend $Sujet PPCR [list $Fichier [list $Sujet $Avs $Aps]] ClonInventoryAppend PPCR Sujets $Sujet set CoAvAp [list $Sujet $Avs $Aps] set TexCoAvAp [join $CoAvAp " +++ "] ClonInventoryAppend $TexCoAvAp $Fichier } } ClonInventorySet PPCR Sujets [lsort -unique [ClonInventory PPCR Sujets]] if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} { set Fen [AfficheVariable [join [ClonInventory PPCR Sujets] "\n"] "AvecShowItsPPCR" "ConstructionsWithPPCR"] if {$OnVeut=="AfficherPPCR"} { return $Fen } } if {$OnVeut=="RetournerPPCR"} { return [ClonInventory PPCR Sujets] } if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherSignaux"} { set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux] if {$LesFichiersSignaux!={}} { BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]" } } if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesAvantsGroupes"} { set TousLesAvantsGroupes [lsort -unique $TousLesAvantsGroupes] set Fen [AfficheVariable [join $TousLesAvantsGroupes "\n"] "SansFetch" AvantsGroupes] if {$TousLesAvantsGroupes!={}} { BoutonneLaFenetre $Fen "Groups of 5' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]" } } if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesApresGroupes"} { set TousLesApresGroupes [lsort -unique $TousLesApresGroupes] set Fen [AfficheVariable [join $TousLesApresGroupes "\n"] "SansFetch" ApresGroupes] if {$TousLesApresGroupes!={}} { BoutonneLaFenetre $Fen "Groups of 3' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]" } } if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesCommandesDOligos"} { set Fen [AfficheVariable [join $LesCommandesDOligos "\n"] "AvecOli" CommandesDOligos] } } proc InventaireDesGluOli {{Action ""}} { if {$Action==""} { set Action "Show" } return [AfficheFichier "[RepertoireDuGenome]/fiches/GluOli.txt"] } proc InventaireDesMatrices {} { return [AfficheFichier "[RepertoireDuGenome]/fiches/matrices_of_oligos" "AvecOli"] } proc InventaireDesNMsEtGBs {} { set LesNMs {} set LesGBs {} foreach I [RetChip ListOf Index] { foreach C [list "refseq_PIQOR" "DNA_acc"] { set NM [RetChip $I $C] if { ! [regexp {^NM_[0-9]+$} $NM]} { if {[regexp "," $NM]} { set SesNMs [split $NM ","] foreach NM $SesNMs { if {[regexp {^NM_[0-9]+$} $NM]} { lappend LesNMs $NM ; lappend LesNMsDu($I) $NM; continue } } continue } } if {$NM==""} { continue } if {[regexp {^NM_[0-9]+$} $NM]} { lappend LesNMs $NM ; lappend LesNMsDu($I) $NM; continue } Espionne "GB $NM" if {[regexp {^[A-Z]+[0-9]+$} $NM]} { lappend LesGBs $NM ; lappend LesGBsDu($I) $NM; continue } } } set LesNMs [lsort -unique $LesNMs] set LesGBs [lsort -unique $LesGBs] if {[OuiOuNon "Do I look for missing NM and GB at NCBI ?"]} { set LesVides {} set Fichier "[Fiches]/GbNmFromNcbiEnStock" if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier } foreach X [concat $LesNMs $LesGBs] { if {[NmEnStock $X]!=""} { continue } if {[GbEnStock $X]!=""} { continue } set NCBI [FromNCBI $X] if {$NCBI==""} { lappend LesVides $X } AppendAuFichier $Fichier $NCBI } return } SauveLesLignes [array get LesNMsDu] dans "[Fiches]/NmsParLigne" SauveLesLignes [array get LesGBsDu] dans "[Fiches]/GbsParLigne" set KeepEnStock [OuiOuNon "Do I keep existing NmEnStock (and GbEnStock) ?"] set LesRestants $LesNMs if {$KeepEnStock} { set LesRestants {} foreach NM $LesNMs { if {[NmEnStock $NM]!=""} { continue } lappend LesRestants $NM } } Espionne $LesRestants set Fichier "[Fiches]/NmEnStock" if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier } while 1 { if {$LesRestants=={}} { break } set LesCourants [lrange $LesRestants 0 99] set LesRestants [lrange $LesRestants 100 end] set NMs [join $LesCourants "|"] set GetzCourant [Getz $NMs refseq] set T [regexp -all {\|} $NMs] ; incr T set N [regexp -all "//" $GetzCourant] Espionne "Recu $N sur $T" AppendAuFichier $Fichier $GetzCourant } set LesRestants $LesGBs if {$KeepEnStock} { set LesRestants {} foreach GB $LesGBs { if {[GbEnStock $GB]!=""} { continue } lappend LesRestants $GB } } Espionne $LesRestants set Fichier "[Fiches]/GbEnStock" if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier } while 1 { if {$LesRestants=={}} { break } set LesCourants [lrange $LesRestants 0 99] set LesRestants [lrange $LesRestants 100 end] set GBs [join $LesCourants "|"] set GetzCourant [Getz $GBs genbank genbanknew] set T [regexp -all {\|} $GBs] ; incr T set N [regexp -all "//" $GetzCourant] Espionne "Recu $N sur $T" AppendAuFichier $Fichier $GetzCourant } exit } proc InventaireDesOligos {{Source ""}} { if {$Source==""} { set Source "Oli" } set LesPSuj {} switch $Source { "Oli" { foreach P [Oli "LaListeMerci"] { set DesP [Oli $P "Description"] regsub "^>" $DesP "" DesP lappend LesPSuj $DesP } } } AfficheVariable [join $LesPSuj "\n"] "AvecOli" "InventaireDesOligos" return } proc InventaireDesPEntr {{Action ""}} { foreach E [PEntr "ListeDesEs"] { set PE [PEntr $E] set iChamp 0 foreach Champ [split $PE ","] { incr iChamp if { ! [info exists LargeurDuChamp($iChamp)]} { set LargeurDuChamp($iChamp) 1 } set LargeurDuChamp($iChamp) [Maxi $LargeurDuChamp($iChamp) [string length $Champ]] } } set LeShow {} foreach E [PEntr "ListeDesEs"] { set PE [PEntr $E] set LaLigne "$E " set iChamp 0 foreach Champ [split $PE ","] { incr iChamp lappend LaLigne [format "%-[set LargeurDuChamp($iChamp)]s" $Champ] } lappend LeShow [join $LaLigne " "] } set Show [join $LeShow "\n"] return [AfficheVariable $Show "" "Inventory_of_PEntr"] } proc InventaireDesSignaux {{Selection ""}} { global RepertoireDuGenome set Action "" if {$Selection=="Show"} { set Action "Show" ; set Selection "" } if {$Selection==""} { set Selection "[RepertoireDuGenome]/signaux/signaux.tfa" } set LeShow {} foreach Fichier [split $Selection "\n"] { if {[info exists SeqSign]} { unset SeqSign ; unset SeqPPCR } set LesSignaux [LesSignauxDuFichier $Fichier SeqSign SeqPPCR] foreach Signal $LesSignaux { set Actuel [set SeqPPCR($Signal)] set SIGNAL [string toupper $Signal] lappend LesFichiersDuSignal($Signal) $Fichier if {[info exists Sequence($SIGNAL)]} { set Autre [set Sequence($SIGNAL)] set Actuel [set SeqPPCR($Signal)] if {$Autre!=$Actuel} { FaireLire "$Autre\n$Actuel\n\ndon't correspond for signal $Signal in\n [join [set LesFichiersDuSignal($Signal)] \n]]" } } set Sequence($SIGNAL) $Actuel set Ligne "[format "%-20s" $Signal] $Actuel" lappend LeShow $Ligne } if {$Action=="Show"} { return [AfficheVariable [join $LeShow "\n"] "" Signals_Inventory ] } while {[OuiOuNon "I would like to save these signals in a file. Can I do it ?"]} { set BonFichierDeSignaux "$RepertoireDuGenome/signaux/bons_signaux.tfa" set BonFichierDeSignaux [FichierPourSaveAs $BonFichierDeSignaux] if {$BonFichierDeSignaux==""} { continue } foreach Signal $LesSignaux { set SignalAGarder($Signal) 1 } set LeMeilleurOrdrePourLesSignaux [MorceauxChoisis [LeBonOrdrePourLesSignaux] "Please transfer all signals to the right and reorder them if necessary"] foreach Signal $LeMeilleurOrdrePourLesSignaux { if { ! [info exists SignalAGarder($Signal)]} { continue } lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"] set DejaVu($Signal) 1 } foreach Signal [array names SignalAGarder] { if {[info exists DejaVu($Signal)]} { continue } lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"] set DejaVu($Signal) 1 } return [Sauve [join $LesSeqs "\n\n"] dans $BonFichierDeSignaux] } return [lsort -unique $LesSignaux] } } proc InventaireDesSignauxGroupes {TousLesSignauxGroupes} { if {[regexp "\n" $TousLesSignauxGroupes]} { set TousLesSignauxGroupes [split $TousLesSignauxGroupes "\n"] } foreach Signaux $TousLesSignauxGroupes { set LesSignaux [split $Signaux "_"] set i 0 foreach Prems $LesSignaux { lappend LesPrems $Prems foreach Deuss [lrange $LesSignaux [incr i] end] { set Ordre($Prems,$Deuss) $Signaux if {[info exists Ordre($Deuss,$Prems)]} { if {[OuiOuNon "wrong signal order $Prems $Deuss in $Signaux \nPrevious was [set Ordre($Deuss,$Prems)] \nDo I keep the old one ?"]} { unset Ordre($Prems,$Deuss) } else { unset Ordre($Deuss,$Prems) } } } } } EspionneL [array get Ordre] set Encore 1 while {$Encore} { if {[info exists EstDeuxieme]} { unset EstDeuxieme } set Encore 0 foreach {PD Signaux} [array names Ordre] { ScanLaListe [split PD ","] Prems Deuss if {[info exists DejaVu($Prems)]} { continue } set EstDeuxieme($Deuss) $Prems } foreach {PD Signaux} [array names Ordre] { ScanLaListe [split $PD ","] Prems Deuss if {[info exists EstDeuxieme($Prems)]} { continue } if {[info exists DejaVu($Prems)]} { continue } lappend LeBonOrdre $Prems set DejaVu($Prems) 1 set Encore 1 } } foreach P [lsort -unique $LesPrems] { if {[info exists DejaVu($P)]} { continue } lappend LeBonOrdre $P } if {[OuiOuNon "Do I append this order to the signals-order-file ?"]} { set AncienOrdre [LeBonOrdrePourLesSignaux] set NouvelOrdre [concat $AncienOrdre $LeBonOrdre] set LeBonOrdre {} foreach Signal $NouvelOrdre { if {[info exists Vu($Signal)]} { continue } set Vu($Signal) 1 lappend LeBonOrdre $Signal } LeBonOrdrePourLesSignaux $LeBonOrdre "ASauver" } EspionneL $LeBonOrdre return $LeBonOrdre } proc InventaireDesVecteurs {{VecType ""}} { set LesPossibles [LesVecteurs $VecType "GetFilenames"] return [AfficheVariable [join $LesPossibles "\n"] "AvecShow" "${VecType}_Vectors"] } proc InverseTagNom {pos} { global NomSeqSel NomNomSeq set Lt {} lassign [split $pos .] y x set Lt [$NomNomSeq tag names $pos] if {"InvNm" ni $Lt} { $NomNomSeq tag add InvNm $y.0 $y.end } else { $NomNomSeq tag remove InvNm $y.0 $y.end set idx [lsearch $NomSeqSel $pos] set NomSeqSel [lreplace $NomSeqSel $idx $idx] } return } proc InverseTagNomSB {pos} { global NomNomSeq global NomSeqSel if {[$NomNomSeq tag includes InvNm $pos]} { $NomNomSeq tag cell {} $pos set idx [lsearch $NomSeqSel $pos] set NomSeqSel [lreplace $NomSeqSel $idx $idx] } else { $NomNomSeq tag cell InvNm $pos } return } proc IpSiLocalhost {Ip} { set Hostname [info hostname] regsub {\..*} $Hostname "" HostnameCourt if {$Ip=="localhost" || [regexp {^127} $Ip]} { set Ip $HostnameCourt } return $Ip } proc IsColsConsFreeSurf {Word} { set LesIsColsConsFreeSurf [list "column-score" "consensus" "freetext" "surface-accessibility" "colscor" "consensus" "freetext" "surfacc"] set i [lsearch $LesIsColsConsFreeSurf $Word] return [expr $i >= 0] } proc IsEmptyStack {{OtherStack ""}} { global OurCurrentStack OurStacks if {$OtherStack!=""} { set OurCurrentStack $OtherStack } if {! [info exists OurCurrentStack] || $OurCurrentStack==""} { return 1 } if { ! [info exists OurStacks($OurCurrentStack,StackHeight)]} { return 1 } set h [set OurStacks($OurCurrentStack,StackHeight)] return [expr $h==0] } proc IsItDNA {Sequence} { Wup "Verifie si une sequence est nucleique ou pas" if {[regexp -nocase {[^ACTGURYKMSWBDHVN]} $Sequence]} {return "-1"} else {return "1"} } proc IsLeaf {Tree} { return [DataSet isLeaf $Tree] } proc IsNuc {Sequence {ForceNucProt ""}} { if {$ForceNucProt!=""} { return ! [regexp -nocase "P" $ForceNucProt] } return ! [IsProt $Sequence] } proc IsPk {Text} { return [regexp {^[0-9]+$} $Text] } proc IsProt {Sequence {ForceNucProt ""}} { if {$ForceNucProt!=""} { set IsProt [regexp -nocase "P" $ForceNucProt] } else { set Nucs [join [PossibleNucleotides] ""] set RX "\[^$Nucs\]" set IsProt [regexp $RX $Sequence] } return $IsProt } proc IsRealAgent {a1 n1 a2 n2} { global Sequences TAg Sref LSOrdali lassign [Seq2AbsRef $n1 $a1] d1 f1 lassign [Seq2AbsRef $n2 $a2] d2 f2 if {$d1 == $d2 && $f1 == $f2} { return "*" } else { return " " } set sf1 [string range $Sref($n1) $d1 $f1] set sf2 [string range $Sref($n2) $d2 $f2] if {$sf1 eq $sf2} { return 1 } else { return 0 } } proc IsRetchip {Nom} { set Retchip [ExtraitInfo $Nom "Retchip:"] return [string equal -nocase $Retchip "Yes"] } proc IsScalar_M {M} { return [expr {![IsVector_M $M] && [IsScalar_V [V_fromM $M]]}] } proc IsScalar_V {V} { return [expr {[llength $V]==1}] } proc IsSqlNull {Valeur} { if {$Valeur==""} { return 1 } return 0 } proc IsVector_M {M} { return [expr [llength $M]!=1] } proc IsoleEtAfficheUnDomaineNucleique {{NomOuTexte ""} {DP ""} {FP ""}} { set SeqNuc [IsoleUnDomaine $NomOuTexte $DP $FP "RetournerSeqNuc"] return [AfficheVariable $SeqNuc "AvecFormate"] } proc IsoleLesLignesDuFichier {Fichier} { if {![file exists $Fichier]} {return ""} set NouveauContenu "" foreach Ligne [LesLignesDuFichier $Fichier] { if { [regexp -nocase "^AFFX" $Ligne] || [regexp -nocase "^Msa" $Ligne] || [regexp -nocase "^YEL" $Ligne]} { append NouveauContenu "$Ligne\n" } } Espionne $NouveauContenu if {[OuiOuNon "Voulez vous sauvez ces lignes\?"]} { set NewFile [SauveLeFichierSous] Sauve $NouveauContenu dans $NewFile } return "$NouveauContenu" } proc IsoleLesLignesDuFichierContenant {Fichier Query} { if {![file exists $Fichier]} {return ""} set NouveauContenu "" foreach Ligne [LesLignesDuFichier $Fichier] { if {![regexp -nocase $Query $Ligne]} {continue} append NouveauContenu "$Ligne\n" } Espionne $NouveauContenu if {[OuiOuNon "Voulez vous sauvez ces lignes\?"]} { SauveLeFichierSous } return "$NouveauContenu" } proc IsoleUnDomaine {{NomOuTexte ""} {DP ""} {FP ""} {QuoiRetourner ""}} { JeMeSignale Wup "QuoiRetourner can be RetournerSeqNuc RetournerSeqPro RetournerSeqNucAndSeqPro" Wup "QuoiRetourner can be RetournerSeqNucIfOK ..." Wup "otherwize QuoiRetourner is the list of the 2 filenames" if {[EstUnPAB $NomOuTexte]} { set Nom $NomOuTexte set FicPro "[RepertoireDuGenome]/prottfa/$Nom" set FicNuc "[RepertoireDuGenome]/nuctfa/$Nom" set SeqPro [QueLaSequenceDuFichierTFA $FicPro] set SeqNuc [QueLaSequenceDuFichierTFA $FicNuc] set Alias [AliasPourClonage $Nom] } elseif {[regexp "\n" $NomOuTexte] && [regexp {^>} $NomOuTexte]} { set FicNuc "" set FicPro "" set TFA $NomOuTexte set SeqNuc [QueLaSequenceDuTexteTFA $TFA] set LongNuc [string length $SeqNuc] set SeqPro [SeqNucToSeqPro $SeqNuc] set Entete [EnteteDuTexteTFA $TFA] scan $Entete "%s" Access regsub ">" $Access "" Access set Nom $Access set Alias $Access } set LongProt [string length $SeqPro] while {$FP==""} { FaireLire "Please enter start and stop position for the protein\n \(or 'bases nnn nnn' if nuc)" if {$DP==""} { set DP 1 } set FPpropose $LongProt set DN [expr ($DP-1)*3+1] set FN [expr ($FPpropose-1)*3+3] set SS [Entre "$DP $LongProt bases $DN $FN"] if {$SS==""} { if {[OuiOuNon "Do I cancel ?"]} { return "" } else { continue } } if {[regexp -nocase {^ *b} $SS]} { catch {unset SeqPro} scan $SS "%s %d %d" bidon DNlu FNlu if {$DNlu<$FNlu} { if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") && [expr ($FNlu-$DNlu+1)%3]!=0} { FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again." continue } set SeqN [string range $SeqNuc [expr $DNlu-1] [expr $FNlu-1]] set DPlu [expr ($DNlu-3)/3+1] set FPlu [expr ($FNlu-1)/3+1] } else { if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") && [expr ($DNlu-$FNlu+1)%3]} { FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again." continue } set SeqN [string range $SeqNuc [expr $FNlu-1] [expr $DNlu-1]] set SeqN [NucToReverseAndComplementNuc $SeqN] set LongSeqN [string length $SeqNuc] set DNlu [expr $LongSeqN-$DNlu+1] set FNlu [expr $LongSeqN-$FNlu+1] set DPlu [expr ($DNlu-3)/3+1] set FPlu [expr ($FNlu-1)/3+1] } } else { set DPlu 99999 set FPlu -9999 scan $SS "%d %d" DPlu FPlu if {$FPlu<$DPlu && [OuiOuNon "Do I reverse and complement the sequence $FPlu $DPlu ?"]} { catch {unset SeqPro} set BonneFin [strign length $SeqNuc] while {[expr $BonneeFin%3]} { incr BonneFin -1 } set SeqNuc [string range $SeqNuc 0 [expr $BonneFin-1]] set SeqNuc [NucToReverseAndComplementNuc $SeqNuc] set SeqPro [SeqNucToSeqPro $SeqNuc] set NowLongPro [string length $SeqPro] set DPlu [expr $NowLongProt-$DPlu+1] set FPlu [expr $NowLongProt-$FPlu+1] Espionne "$DNlu $FNlu $DPlu $FPlu" } } if {[regexp "RetournerSeqNuc" $QuoiRetourner] && 1<=$DNlu && $DNlu<$FNlu && $FNlu<=$LongNuc} { set DN $DNlu ; set FN $FNlu ; break } if {1<=$DPlu && $DPlu<$FPlu && $FPlu<=$LongProt} { set DP $DPlu ; set FP $FPlu ; break } FaireLire "Please choose correct limits between 1 and $LongProt" } if {[info exists SeqN]} { set SeqP [SeqNucToSeqPro $SeqN] } else { set NucOnly 1 if {[regexp "b" $DP]} { regsub "b" $DP "" DN set NucOnly 1 } else { set DN [expr ($DP-1)*3+1] } if {[regexp "b" $FP]} { regsub "b" $FP "" FN set NucOnly 1 } else { set FN [expr ($FP-1)*3+3] } set SeqN [string range $SeqNuc [expr $DN-1] [expr $FN-1]] if { $NucOnly } { set SeqP "" set FicP "" } else { if {[info exists SeqPro]} { set SeqP [string range $SeqPro [expr $DP-1] [expr $FP-1]] set SeqPVerif [SeqNucToSeqPro $SeqN] if { ! [string equal -nocase $SeqP $SeqPVerif]} { if {[OuiOuNon "$DN $FN\n$SeqP\n$SeqPVerif\n Your protein sequence is not the exact translation of the nucleic.\n Do I cancel ?"]} { return "" } } } else { set SeqP [SeqNucToSeqPro $SeqN] } } } if {$QuoiRetourner=="RetournerSeqNuc"} { return $SeqN } if {$QuoiRetourner=="RetournerSeqPro"} { return $SeqP } if {$QuoiRetourner=="RetournerSeqNucAndSeqPro"} { return [list $SeqN $SeqP] } regsub -all {.} $SeqP "& " SeqP3 set Retour [AfficheVariable "$SeqP3\n$SeqN" "AvecRetour" ""] if {$Retour==""} { return "" } if {$QuoiRetourner=="RetournerSeqNucIfOK"} { return $SeqN } if {$QuoiRetourner=="RetournerSeqProIfOK"} { return $SeqP } if {$QuoiRetourner=="RetournerSeqnucAndSeqProIfOK"} { return "$SeqN $SeqP" } while { ! [OuiOuNon "Do I save the prot and nuc in .tfa files ?"]} { if {[OuiOuNon "Do I cancel ?"]} { return "" } } set FicN "$Alias-$DP-$FP.nuctfa" set FicN [FichierPourSaveAs $FicN] if { ! $NucOnly } { set FicP "$Alias-$DP-$FP.prottfa" set FicP [FichierPourSaveAs $FicP] set TfaP [SequenceFormatTFA $SeqP "$Alias-$DP-$FP extracted from prot $Nom" "protbrut"] if {$TfaP==""} { return "" } Sauve $TfaP dans $FicP } set TfaN [SequenceFormatTFA $SeqN "$Alias-$DP-$FP extracted from nuc $Nom bases $DN to $FN" "protbrut"] if {$TfaN==""} { return "" } Sauve $TfaN dans $FicN return [list $FicP $FicN] } proc Italic_WordML {} { return "" } proc ItemHTMLFermant {Item} { global ItemHTMLFermant if {[info exists ItemHTMLFermant($Item)]} { return $ItemHTMLFermant($Item) } set Item [string tolower $Item] set LesSimples {area img ox os oc ac de gn id pn rect polyline path} if {[lsearch -exact $LesSimples $Item]>=0} { return ">" } # if {[string equal -nocase $Item "LI"]} { return "

" } return "" } proc Iterator {Name Action args} { global Iterator #rR Il arrive qu'on veuille imbriquer des boucles ... c'est fastidieux ... #rR Iterator permet de la faire en deux lignes #rR Il faut d'abord le créer : #rR set Name [Iterator New Init $L0 $L1 $L2] #rR Puis l'utiliser : #rR while {[Iterator $Name Next v0 v1 v2]} { ... } #rR attention les v sont sans $ #rR Le dernier indice (v2) va le plus vite !!!!!!!!!!!!!!!!!!!! #rR Attention les listes sont numerotees de 0 a 2 a l'exterieur (pour le user) #rR mais elles sont indexees de 2 a 0 dans la proc (en interne) #rR Iterator $Name Reset #rR Iterator $Name Destroy #rR set Info [Iterator Iterator Get ListOf Name] #rR set Info [Iterator $Name Get Current 2] #rR current index de L2 #rR set Info [Iterator $Name Get Current All] #rR tous les current L0 L1 L2 #rR set Info [Iterator $Name Get Max 0] #rR set Info [Iterator $Name Get Max All] #rR set Info [Iterator $Name Get Total Iter] #rR Pour les puristes on pourrait le faire en une ligne ... : #rR while {[Iterator [Iterator New Init $L0 $L1 $L2] Next v0 v1 v2]} { ... } if {$Action=="Get"} { set Qui [lindex $args 0] set Quoi [lindex $args 1] if {[regexp {^[0-9]+$} $Quoi]} { set Quoi [expr [llength $Iterator($Name,ListOf,Index)] - $Quoi -1] } if {[info exists Iterator($Name,$Qui,$Quoi)]} { return $Iterator($Name,$Qui,$Quoi) } if {$Quoi=="All"} { set LeAll {} foreach iL [RetourneLaListe $Iterator($Name,ListOf,Index)] { lappend LeAll $Iterator($Name,$Qui,$iL) } return $LeAll } return "" } if {$Action=="Next"} { set LesP $args set LesP [RetourneLaListe $LesP] set iP 0 if {$Iterator($Name,WaitsFor,Start)} { set incrNext 0 } else { set incrNext 1 } set Iterator($Name,WaitsFor,Start) 0 foreach aP $LesP { upvar $aP P set k $Iterator($Name,Current,$iP) incr k $incrNext set incrNext 0 if {$k>$Iterator($Name,Max,$iP)} { set k 0 ; set incrNext 1 } set P [lindex $Iterator($Name,List,$iP) $k] set Iterator($Name,Current,$iP) $k incr iP } if { $incrNext==0 } { return 1 } foreach iP Iterator($Name,ListOf,Index) { set Iterator($Name,Current,$iP) 0 } return 0 } if {$Name=="New"} { set Name [NomDe "iterator"] set Action "Init" } if { $Action=="Init"} { set LesL $args set LesL [RetourneLaListe $LesL] if {[info exists Iterator($Name,ListOf,Index)]} { foreach L $Iterator($Name,ListOf,Index) { unset Iterator($Name,List,$iL) unset Iterator($Name,Max,$iL) unset Iterator($Name,Current,$iL) } unset Iterator($Name,ListOf,Index) } set iL 0 set Total 1 foreach L $LesL { lappend Iterator($Name,ListOf,Index) $iL set Iterator($Name,List,$iL) $L set Iterator($Name,Max,$iL) [expr [llength $L] - 1] set Iterator($Name,Current,$iL) 0 set Total [expr $Total * [llength $L]] incr iL } set Iterator($Name,Total,Iter) $Total lappend Iterator(Iterator,ListOf,Name) $Name set Iterator($Name,WaitsFor,Start) 1 return $Name } if { $Action=="Reset"} { foreach iP $Iterator($Name,ListOf,Index) { set Iterator($Name,Current,$iP) 0 } set Iterator($Name,WaitsFor,Start) 1 return $Name } if { $Action=="Destroy"} { if {[info exists Iterator($Name,ListOf,Index)]} { foreach iL $Iterator($Name,ListOf,Index) { unset Iterator($Name,List,$iL) unset Iterator($Name,Max,$iL) unset Iterator($Name,Current,$iL) } unset Iterator($Name,ListOf,Index) unset Iterator($Name,WaitsFor,Start) return "" } set i [lsearch $Iterator(Iterator,ListOf,Name) $Name] set Iterator(Iterator,ListOf,Name) [lreplace $Iterator(Iterator,ListOf,Name) $i $i] return 1 } return "" } proc ItsAGene {Nom} { set Valeur [ExtraitInfo $Nom "CNS-Glimmer-says"] if { $Valeur == "" } { return -1 } if {[regexp "it's a gene" $Valeur]} { return 1 } if {[regexp "it's not a gene" $Valeur]} { return 0 } return 2 } proc ItsOligos {Selection {NA ""}} { return [ShowItsOligos $Selection $NA "GetThem"] } proc ItsPPCR {Selection {NA ""}} { return [ShowItsPPCR $Selection $NA "GetThem"] } proc JArreteDeBosser {Moi} { global Bosseurs if { ! [file exists $Moi]} { return 0 } file delete -force $Moi set Texte [set Bosseurs($Moi)] unset Bosseurs($Moi) unset Bosseurs($Texte) return 1 } proc JaiCommandeAuMagos {f template maxSeq filter gapped maxE db} { global PipeCollection global Defauts global OuiOuNonToujoursParDefaut ; set OuiOuNonToujoursParDefaut 1 global EspionneNon ; set EspionneNon 1 global FaireLireNon ; set FaireLireNon 1 global EntreToujoursDefaut ; set EntreToujoursDefaut 1 global JavaDisponible ; set JavaDisponible 0 NousAllonsAuBoulot "[MagosDir]/Depot" set PipeCollection 0 LesDefautsDuPipe LesDefauts LesDefautsDuPipe "File,file" $f #LesDefautsDuPipe "File,log" "verbose" LesDefautsDuPipe "Blast,d" $db LesDefautsDuPipe "Blast,v" 500 LesDefautsDuPipe "Blast,b" 500 LesDefautsDuPipe "Blast,b" 500 LesDefautsDuPipe "Filter,maxseq" $maxSeq LesDefautsDuPipe "Filter,expect" $maxE #LesDefautsDuPipe "Filter,method" strips LesDefautsDuPipe "Filter,varsplic" 1 LesDefautsDuPipe "Etapes,cluspack" 0 LesDefautsDuPipe "Etapes,macsims" 0 if {$filter == 0} { LesDefautsDuPipe "Blast,F" F } else { LesDefautsDuPipe "Blast,F" T } if {$gapped == 0} { LesDefautsDuPipe "Blast,g" F } else { LesDefautsDuPipe "Blast,g" T } # remaniement du fichier d'entree si le nom contient des caracteres speciaux set NQuery [VerifieInputTfa $f] puts "nquery est $NQuery" set log "$f-magos.log" set BestPdb 0 if {$template != "none"} { # si un template est precise if {[regexp {[a-z]} [string index $template end]]} { # si le dernier caractere est en minuscule, on le met en majuscule set template [string toupper $template end] } set BestPdb "PDB:$template" } else { # si pas de template catch {set BestPdb [PSSMpour3D $f]} } if {$BestPdb != 0} { LesDefautsDuPipe "Filter,addpdb" $BestPdb } #Espionne "best est $BestPdb" catch {[PipeGrid]} Message if { $NQuery == ""} { set NQuery "query" } set fl [open $log w] set FATarer {} # Remplissage du fichier log et creation du tar if {[file exists $f.blastp] && [file exists $f.copains]} { puts $fl "blastp = ok" lappend FATarer "$f.blastp" } else { set Lf [glob -nocomplain $f*] foreach e $Lf { file delete -force $e } OnRevientDuBoulot set url "http://pig-pbil.ibcp.fr/cgi-bin/magos/run_geno3d.py?id=XXXX&status=false" set tmp [WgetzSurWeb $f $url] exit } # Selection du meilleur msf catch {set bmsf [VerifieBestMsf $f]} # si on a 1 best MSF if {$bmsf != "no file"} { if {$bmsf == ".leon"} { # Verifie la presence du BestPDB si le meilleur msf est leon set test [VerifiePresencePDB ${f}.leon.msf $BestPdb] if {$test == 0} { catch {set bmsf [MeilleurMsfClRas $f]} } } file copy -force "${f}${bmsf}.msf" "$f.best.msf" set bmsf "$f.best.msf" puts $fl "macs = ok" lappend FATarer $bmsf # Mise en evidence des proteines impliquees dans les maladies genetiques humaines LitLeTFAMagos "$f.copains" LAcc Seqs FiltreMaladies $f $LAcc if {[file exists "$f.disease"]} { puts $fl "disease = ok" lappend FATarer "$f.disease" } # creation de l alignement de la query avec le template if {$BestPdb != 0} { catch {CreeEmpreinte $f $NQuery $BestPdb} if {[file exists "$f.empreinte"]} { puts $fl "empreinte = ok" lappend FATarer "$f.empreinte" } } # Calcul du MACSIM #catch {exec /biolo/macsim/query2first $f.tmp.xml $NQuery $f.xml} Message catch {eval exec [MacsimsExe] $bmsf "$f.tmp"} Message catch {eval exec /biolo/macsim/query2first $f.tmp.xml $NQuery $f.xml} Message # ajout des conservations dans le fichier macsims if {[file exists "$f.xml"]} { catch {[AjoutConservationMacsims $f.xml Cluster]} puts $fl "macsim = ok" lappend FATarer "$f.xml" } } close $fl if {[file exists $log]} { lappend FATarer $log } eval exec tar -cf "results-${f}.tar" $FATarer set Frayon [file join "/genomics" g6 Magos EnRayon "results-${f}.tar"] file rename -force results-${f}.tar $Frayon set Lf [glob -nocomplain $f*] foreach e $Lf { file delete -force $e } OnRevientDuBoulot set url "http://pig-pbil.ibcp.fr/cgi-bin/magos/run_geno3d.py?id=XXXX" set tmp [WgetzSurWeb $f $url] exit } proc JalviewHtml {FichierMacsim {JalviewJunkdir ""} {JalviewJunkdirUrl ""}} { set CreateWebFile 0 if {0 && [EstUnPAB $FichierMacsim] && $JalviewJunkdir=="" && $JalviewJunkdirUrl=="" } { set CreateWebFile 1 set Nom $FichierMacsim set FichierJalviewHtml "[RepertoireDuGenome]/web/$Nom.jalview.html" if {[UseExistingJalviewHtml] && [FileExists $FichierJalviewHtml]} { return [ContenuDuFichier $FichierJalviewHtml] } } if {[EstUnPAB $FichierMacsim]} { set FichierMacsim "[RepertoireDuGenome]/macsimXml/$FichierMacsim" } if {$JalviewJunkdir ==""} { set JalviewJunkdir "[HomeRipp]/www/JalviewJunkdir" } if {$JalviewJunkdirUrl==""} { set JalviewJunkdirUrl "/JalviewJunkdir" } if {[FileAbsent $FichierMacsim]} { # if {[regexp "^/" $FichierMacsim]} { return "" } if {[FileExists "$FichierMacsim.xml"]} { set FichierMacsim "$FichierMacsim.xml" } else { if {[FileExists "[RepertoireDuGenome]/$FichierMacsim"] } { set FichierMacsim "[RepertoireDuGenome]/$FichierMacsim" } } } if {[FileAbsent $FichierMacsim] && [FileExists "$FichierMacsim.gz"]} { set FichierMacsim "$FichierMacsim.gz" } if {[FileAbsent $FichierMacsim]} { return "Sorry, there is no file $FichierMacsim" } set Macsim [ContenuDuFichier $FichierMacsim] NousAllonsAuBoulot $JalviewJunkdir set Racine [TmpFile "macsim2jal" "./"] regsub {\./} $Racine "" Racine Sauve $Macsim dans $Racine.xml if {[catch {exec /biolo/macsim/macsim2jal "$Racine.xml" $Racine > [HomeRipp]/lolo.log} Message]} { OnRevientDuBoulot return "Error during macsim2jal with message=$Message=" } file delete -force $Racine.xml if {[FileAbsent $Racine.html]} { file delete -force $Racine.txt file delete -force $Racine.tfa } if {[FileAbsent $Racine.html]} { return "I didn't find $Racine.html" } if {$CreateWebFile} { set WebDir [file dirname $FichierJalviewHtml] file mkdir $WebDir regsub {.html$} $FichierJalviewHtml ".tfa" FichierJalviewTfa regsub {.html$} $FichierJalviewHtml ".txt" FichierJalviewTxt set Html [ContenuDuFichier $Racine.html] regsub -all "value=\"$Racine" $Html "value=\"$Nom.jalview" Html Sauve $Html dans $FichierJalviewHtml file copy -force $Racine.tfa $FichierJalviewTfa file copy -force $Racine.txt $FichierJalviewTxt if {[UseExistingJalviewHtml]} { return [JalviewHtml $Nom] } } set Html [ContenuDuFichier $Racine.html] OnRevientDuBoulot regsub -all "value=\"$Racine" $Html "valuetype=\"ref\" value=\"$JalviewJunkdirUrl/$Racine" Html regsub -all {archive=[^>]+\">} $Html "archive=\"[LbgiUrl]/Jalview/jalviewApplet.jar\">" Html return $Html } proc JavOO {{What ""} {Query ""} {Resource ""} {IP ""} {Port ""} {User ""} {Password ""}} { if {$What==""} { set What "Data" } # if {$Query==""} { set Query "select \"Nom des participants\" from LiLaboDef order by \"Nom des participants\";" } # if {$Resource==""} { set Resource "ListeLabo" } if {$Query==""} { set Query "select * from GUCY2D;" } if {$Resource==""} { set Resource "LCA_GUCY2D" } if {$IP==""} { set IP "olo" } if {$Port==""} { set Port 18000 } set CanalJavOO [socket $IP $Port] puts $CanalJavOO "" puts $CanalJavOO "123" puts $CanalJavOO "$Resource" puts $CanalJavOO "$Query" puts $CanalJavOO "" puts $CanalJavOO "" flush $CanalJavOO Espionne $Query set LaReponse {} while {[gets $CanalJavOO Ligne]>=0} { if {[regexp "" $Ligne]} { break } lappend LaReponse $Ligne } set Reponse [join $LaReponse "\n"] if {$What=="Data" || $What=="DataHtml"} { set Reponse [ValeurDeLaBalise "data" Reponse "NePasRogner"] } if {$What=="DataHtml"} { set Reponse "

$Reponse

" } return $Reponse } proc JeCommenceABosser {} { set LesBoulots [list "FantomisePourTous {} AskWhereToBegin" "EtudeCodonStart AskWhereToBegin" "CoupeAuBonMetPourTous AskWhereToBegin" ] set Boulot [ChoixParmi $LesBoulots] if {$Boulot==""} { return "" } JeVaisBosser $Boulot eval $Boulot } proc JeMeSignale {{Etat ""}} { global FenetreDePatience NiveauFenetreDePatience global JeMeSignaleInactif set Commande "\[[info level -1]\]" if { $Etat == "Get" } { return $Commande } set CommandeComplete "$Commande $Etat" if { $Etat == "GetAll" } { return $CommandeComplete } if { [info exists JeMeSignaleInactif] && $JeMeSignaleInactif } { return } if { ! [info exists NiveauFenetreDePatience] } { set NiveauFenetreDePatience 0 } Warne $CommandeComplete set Commande [lindex [split $CommandeComplete " "] 0] if { $Etat == "Patience" } { incr NiveauFenetreDePatience set FenetreDePatience($NiveauFenetreDePatience) [Patience $Commande] return [set FenetreDePatience($NiveauFenetreDePatience)] } if { $Etat == "FinPatience" } { Warne [set FenetreDePatience($NiveauFenetreDePatience)] destroy [set FenetreDePatience($NiveauFenetreDePatience)] incr NiveauFenetreDePatience -1 update return "" } return "" } proc JeSuisDescendantDe {As B} { regsub -all {[ \,;\n\t]+} $As "," As set As [split [string trim $As ","] ","] set iB [Tax $B TaxId] foreach A $As { set iA [Tax $A TaxId] set iC [AncetreCommun $iA $iB] Espionne "$iA $iB $iC" if {$iC==$iA} { return 1 } } return 0 } proc JeSuisTonAncetre {Parent Enfant} { #rR petite magouille car les clades excavata et archaeplastida n'existent pas set FichierComposition "[RepertoireDuGenome]/bilan/CompositionDuClade$Parent.txt" if {[file exists $FichierComposition]} { foreach Mot [LesMotsDuTexte [ContenuDuFichier $FichierComposition]] { if {[JeSuisTonAncetre $Mot $Enfant]} { return 1 } } return 0 } set ParId [Tax $Parent "TaxId"] set EnfId [Tax $Enfant "TaxId"] set Classe [TaxClass $EnfId "All" "Forward" "TaxId"] # regsub -all {[ ;]+} $Classe " " Classe set LesAncetres [split $Classe " ;"] if {[lsearch $LesAncetres $ParId]<0} { return 0 } return 1 } proc JeTesteLeNouveauPipeGrid {} { global PipeCollection global OrdBinDir global DefautsPipe set PipeCollection 0 LesDefautsDuPipex PipeGrid return 1 } proc JeVaisBosser {Texte} { global Bosseurs set Moi [TmpFile Bosse] set Bosseurs($Texte) $Moi set Bosseurs($Moi) $Texte return $Moi } proc JeuDeTestARPAnno {} { Wup "Lance ARPAnno sur toutes les ARPs de l article" set RepARP "[RepARPAnno]" set RepARP "/genomics/g1/ARP/alignement_ARP/ARPAnno" set RepTFA "$RepARP/ARP_TFA" set RepTFA "$RepARP/ARP_TFA_lesarps" #set RepTFA "$RepARP/ARP_TFA_validation" set LesFichiersTFA [glob -nocomplain -directory $RepTFA "*.tfa"] #set LesFichiersTFA [lrange $LesFichiersTFA 0 5] Espionne "$LesFichiersTFA [llength $LesFichiersTFA]" set i 0 foreach TFA $LesFichiersTFA { set VraiAccess "[file tail $TFA]" regsub -nocase ".tfa$" $VraiAccess "" VraiAccess set Categorie [InterrogeLesInfosDesARPs [string toupper $VraiAccess] Categorie] if { $Categorie == ""} { set Categorie "Unknown" } else { regsub -all {\-\-\-\-} $Categorie "" Categorie regsub "Les" $Categorie "" Categorie } if {![regexp -nocase {ARP[0-9]+} $Categorie]} {continue} if {![info exists TabARP($Categorie,LesAccess)]} { set TabARP($Categorie,LesAccess) "" lappend TabARP($Categorie,LesAccess) $VraiAccess } else { lappend TabARP($Categorie,LesAccess) $VraiAccess } set VraiFamille "$Categorie" set Texte [list $VraiAccess $VraiFamille] incr i #ARPAnno $TFA $VraiFamille ARPAnno $TFA set LesVraisFamilles [LesResultatsARPAnalyses "LesFamilles" "LaValeurMerci"] foreach Famille $LesVraisFamilles { if {[regexp -nocase {Actin|Orphan} $Famille]} {continue} set Score_PId [LesResultatsARPAnalyses "$Famille,Score_PId_ini" "LaValeurMerci"] set Score_Cover [LesResultatsARPAnalyses "$Famille,Score_Cover_ini" "LaValeurMerci"] set Score_Residue [LesResultatsARPAnalyses "$Famille,Score_Residue_ini" "LaValeurMerci"] set Score_Domain [LesResultatsARPAnalyses "$Famille,Score_Domain_ini" "LaValeurMerci"] foreach V [list Score_PId Score_Cover Score_Residue Score_Domain] { if { [set $V] == "No"} { continue } elseif {[set $V] == ""} { set [set V] "No" } else { set [set V] [format "%5.1f" [set $V]] } } if {$VraiFamille=="$Famille"} { set FamilleOk "1" } else { set FamilleOk "0" } foreach V [list $Famille $Score_PId $Score_Cover $Score_Residue $Score_Domain] { lappend Texte $V } if {![info exists TabARP($Famille)]} { set TabARP($Famille) "" lappend TabARP($Famille) $Texte } else { lappend TabARP($Famille) $Texte } } set Texte [join $Texte "\t"] set TabARP($VraiAccess) $Texte #Espionne "$Texte" #On vide la memoire LesResultatsARPAnalyses UnsetAll DechargeLesResidusDesARPs DechargeLesDomainesDesARPs } foreach Famille $LesVraisFamilles { if {[info exists TabARP($Famille,LesAccess)]} { Espionne "$Famille\t[llength [set TabARP($Famille,LesAccess)]]" foreach Acc [set TabARP($Famille,LesAccess)] { if {[info exists TabARP($Acc)]} { Espionne "[set TabARP($Acc)]" } } } } Espionne "$i" return "" } proc JeuDeVerifARPAnno {} { Wup "Lance ARPAnno sur toutes les ARPs trouvees par DbW" set RepARP "[RepARPAnno]" set RepARP "/genomics/g1/ARP/alignement_ARP/ARPAnno" set RepTFA "$RepARP/ARP_TFA" set RepTFA "$RepARP/ARP_TFA_lesarps" set RepTFA "$RepARP/ARP_TFA_validation" set LesFichiersTFA [glob -nocomplain -directory $RepTFA "*.tfa"] #set LesFichiersTFA [lrange $LesFichiersTFA 0 5] Espionne "$LesFichiersTFA [llength $LesFichiersTFA]" set i 0 foreach TFA $LesFichiersTFA { set VraiAccess "[file tail $TFA]" regsub -nocase ".tfa$" $VraiAccess "" VraiAccess set Categorie [InterrogeLesInfosDesARPs [string toupper $VraiAccess] Categorie] if { $Categorie == ""} { set Categorie "Unknown" } else { regsub -all {\-\-\-\-} $Categorie "" Categorie regsub "Les" $Categorie "" Categorie } #if {![regexp -nocase {ARP[0-9]+} $Categorie]} {continue} if {![info exists TabARP($Categorie,LesAccess)]} { set TabARP($Categorie,LesAccess) "" lappend TabARP($Categorie,LesAccess) $VraiAccess } else { lappend TabARP($Categorie,LesAccess) $VraiAccess } set VraiFamille "$Categorie" set Texte [list $VraiAccess $VraiFamille] incr i #ARPAnno $TFA $VraiFamille ARPAnno $TFA "" 1 set LesVraisFamilles [LesResultatsARPAnalyses "LesFamilles" "LaValeurMerci"] foreach Famille $LesVraisFamilles { if {[regexp -nocase {Actin|Orphan} $Famille]} {continue} set Impact_Score_PId "0.2" set Impact_Score_Cover "0.1" set Impact_Score_Residue "0.4" set Impact_Score_Domain "0.3" set Score_PId [LesResultatsARPAnalyses "$Famille,Score_PId_ini" "LaValeurMerci"] set Score_Cover [LesResultatsARPAnalyses "$Famille,Score_Cover_ini" "LaValeurMerci"] set Score_Residue [LesResultatsARPAnalyses "$Famille,Score_Residue_ini" "LaValeurMerci"] set Score_Domain [LesResultatsARPAnalyses "$Famille,Score_Domain_ini" "LaValeurMerci"] set Score [LesResultatsARPAnalyses "$Famille,Score" "LaValeurMerci"] foreach V [list Score_PId Score_Cover Score_Residue Score_Domain Score] { if { [set $V] == "No"} { set [set V] [format "%5.1f" "0.0"] continue } elseif {[set $V] == ""} { set [set V] [format "%5.1f" "0.0"] } else { set [set V] [format "%5.1f" [set $V]] } } set ScoreNoRedirect [expr {(($Score_PId * $Impact_Score_PId) + ($Score_Cover * $Impact_Score_Cover)+ ($Score_Residue * $Impact_Score_Residue) + ($Score_Domain * $Impact_Score_Domain)) * 1.0}] foreach V [list Score_PId Score_Cover Score_Residue Score_Domain Score ScoreNoRedirect] { if { [set $V] == "No"} { continue } elseif {[set $V] == ""} { set [set V] "No" } else { set [set V] [format "%5.1f" [set $V]] } } if {$VraiFamille=="$Famille"} { set FamilleOk "1" } else { set FamilleOk "0" } foreach V [list $Famille $Score $ScoreNoRedirect $Score_PId $Score_Cover $Score_Residue $Score_Domain] { lappend Texte $V } if {![info exists TabARP($Famille)]} { set TabARP($Famille) "" lappend TabARP($Famille) $Texte } else { lappend TabARP($Famille) $Texte } } set Texte [join $Texte "\t"] Espionne "$Texte" set TabARP($VraiAccess) $Texte #Espionne "$Texte" #On vide la memoire LesResultatsARPAnalyses UnsetAll DechargeLesResidusDesARPs DechargeLesDomainesDesARPs } foreach Famille $LesVraisFamilles { if {[info exists TabARP($Famille,LesAccess)]} { Espionne "$Famille\t[llength [set TabARP($Famille,LesAccess)]]" foreach Acc [set TabARP($Famille,LesAccess)] { if {[info exists TabARP($Acc)]} { Espionne "[set TabARP($Acc)]" } } } } Espionne "$i" return "" } proc Json {} { source "[HomeRipp]/Desktop/exp_json.tcl" Espionne [info procs ::json::*] # set TJ [ContenuDuFichier "[HomeRipp]/json.txt"] set TJ [ContenuDuFichier "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=24026985&retmode=json"] set TJ [encoding convertfrom "utf-8" $TJ] set D [::json::json2dict $TJ] return $D Espionne $TJ set D [json::json2prettydict $TJ] Espionne $D return $D exit set Pretty [PrettyDict $D] Espionne $Pretty exit set d [string first "Stoetzel" $TJ] set f [expr $d +220] Espionne [string range $TJ $d $f] exit # regsub -all {u'([^']*)'} $TJ {"\1"} TJ # Espionne [string range $TJ 0 end] set D [::json::json2dict $TJ] return $D Espionne $D exit dict for {k v} D { Espionne "k=$k" Espionne "v=$v" } # Espionne $D exit } proc JulieDefinition {Nom LesDEJ} { set Fen [SeeAby Show $Nom] set DEJ [ChoixParmiJoli $LesDEJ] if {$DEJ==""} { if {[OuiOuNon "Do we stop ?"]} { return -1 } } set Info [Informe $Nom "DEJ: $DEJ"] after 1000 destroy $Fen return $Info } proc JulieDefinitionPourTous {} { set LesDEJ [LesLignesDuFichier "[GscopeDir]/julies-definitions.txt"] set LesBeauxDEJ {} foreach DEJ $LesDEJ { regsub -all "\t" $DEJ " " DEJ while {[regexp " " $$DEJ]} { regsub -all " " $DEJ " " DEJ } lappend LesBeauxDEJ $DEJ } foreach DEJ $LesBeauxDEJ { scan $DEJ "%s" A set DEJdeA "" regsub "$A " $DEJ "" DEJdeA lappend LesDEJde($A) $DEJdeA } foreach Nom [ListeDesPABs] { set DEJ [ExtraitInfo $Nom "DEJ:"] if {$DEJ!=""} { continue } set Alias [Alias $Nom] set AliasCourt $Alias regsub "_.*" $Alias "" AliasCourt if {[info exists LesDEJde($AliasCourt)]} { set LesPossibles [lsort -unique $LesDEJde($AliasCourt)] set FenSeeAby "Bidon" if {[llength $LesPossibles]>1} { set FenSeeAby [SeeAby Show $Nom] } set DEJok [ChoixParmi $LesPossibles] set RV [ExtraitInfo $Nom "RV:"] ScanLaListe [split $RV ""] R V set RefVar "Ref$R" if {$V!=0} { set RefVar "$RefVar V$V" } set Info [Informe $Nom "DEJ: $RefVar $DEJok"] if {[winfo exists $FenSeeAby]} { after 1000 destroy $FenSeeAby } if {$Info!=""} { continue } if {[OuiOuNon "Do we stop ."]} { break } } set Retour [JulieDefinition $Nom $LesBeauxDEJ] if {$Retour==-1} { break } } } proc JumeauLesAccRSEtUG_Affymetrix {PABOuRefSeq {Quoi RefSeq}} { Wup "Permet de faire savoir qui est Jumeau de qui a paetir des infos de LesAccDefRefSeqUnigene de la puce Affymetrix" Wup "Pour le projet Gscope Affy3Marker donnera les ref RefSeq et Unigene du PAB" #$PAB RefSeq - Rend les RefSeq associes pour le PAB #$PAB Unigene - Rend les Unigene associes pour le PAB #$PAB LesPAB - Rend les PABs associes pour le PAB global JumeauLesAccRSEtUG if {$Quoi != "PAB" && $Quoi != "RefSeq" && $Quoi != "Unigene" && $Quoi != "LesPAB"} {return ""} if {[info exists JumeauLesAccRSEtUG($PABOuRefSeq)]} { if {[info exists JumeauLesAccRSEtUG($PABOuRefSeq,$Quoi)]} { return [set JumeauLesAccRSEtUG($PABOuRefSeq,$Quoi)] } else { return "" } } foreach PAB [ListeDesPABs] { set LesAccRefSeq "" set LesAccUnigene "" set JumeauLesAccRSEtUG($PAB) 1 set JumeauLesAccRSEtUG($PAB,LesPAB) "" set LesAccRefSeq [InterrogeLesAccRSEtUG_Affymetrix $PAB AccRefSeq] if {$LesAccRefSeq != "None"} { foreach RefSeq $LesAccRefSeq { if {! [info exists JumeauLesAccRSEtUG($PAB,RefSeq)]} { set JumeauLesAccRSEtUG($PAB,RefSeq) "" } lappend JumeauLesAccRSEtUG($PAB,RefSeq) $RefSeq if {! [info exists JumeauLesAccRSEtUG($RefSeq,PAB)]} { set JumeauLesAccRSEtUG($RefSeq,PAB) "" lappend JumeauLesAccRSEtUG($RefSeq,PAB) $PAB } else { Espionne "$PAB $RefSeq -- [set JumeauLesAccRSEtUG($RefSeq,PAB)]" lappend JumeauLesAccRSEtUG($RefSeq,PAB) $PAB set JumeauLesAccRSEtUG($RefSeq,PAB) [lsort -unique [set JumeauLesAccRSEtUG($RefSeq,PAB)]] set LesPABs [set JumeauLesAccRSEtUG($RefSeq,PAB)] foreach PABs $LesPABs { set JumeauLesAccRSEtUG($PABs,LesPAB) $LesPABs } } } } set LesAccUnigene [InterrogeLesAccRSEtUG_Affymetrix $PAB AccUniseq] if {$LesAccUnigene != "None"} { foreach Unigene $LesAccUnigene { if {! [info exists JumeauLesAccRSEtUG($PAB,Unigene)]} { set JumeauLesAccRSEtUG($PAB,Unigene) "" } lappend JumeauLesAccRSEtUG($PAB,Unigene) $Unigene if {! [info exists JumeauLesAccRSEtUG($Unigene,PAB)]} { set JumeauLesAccRSEtUG($Unigene,PAB) "" lappend JumeauLesAccRSEtUG($Unigene,PAB) $PAB } else { Espionne "$PAB $Unigene -- [set JumeauLesAccRSEtUG($Unigene,PAB)]" lappend JumeauLesAccRSEtUG($Unigene,PAB) $PAB set JumeauLesAccRSEtUG($Unigene,PAB) [lsort -unique [set JumeauLesAccRSEtUG($Unigene,PAB)]] set LesPABs [set JumeauLesAccRSEtUG($Unigene,PAB)] foreach PABs $LesPABs { set JumeauLesAccRSEtUG($PABs,LesPAB) $LesPABs } } } } } return "[JumeauLesAccRSEtUG_Affymetrix $PABOuRefSeq $Quoi]" } proc JumeauRepresentatif {Nom} { global JumeauRepresentatif if {[info exists JumeauRepresentatif($Nom)]} { return [set JumeauRepresentatif($Nom)] } if {[info exists JumeauRepresentatif("EstCharge")]} { return "" } set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux" if { ! [file exists $FichierDesJumeaux]} { set LesFichiersJumeaux [glob -nocomplain "[RepertoireDuGenome]/fiches/jumeaux*"] if {[llength $LesFichiersJumeaux]>0} { set LesPossibles $LesFichiersJumeaux lappend LesPossibles "Run a new Jumeaux" set FichierDesJumeaux [ChoixParmi $LesPossibles] if {$FichierDesJumeaux=="Run a new Jumeaux"} { set FichierDesJumeaux "" } } } if { $FichierDesJumeaux=={} || ! [file exists $FichierDesJumeaux]} { if {[OuiOuNon "Do You want to run Jumeaux ?"]} { set FichierDesJumeaux [Jumeaux "Ask"] } } foreach Ligne [LesLignesDuFichier $FichierDesJumeaux] { set LesJumeaux [split $Ligne " "] set JR [lindex $LesJumeaux 0] lappend JumeauRepresentatif(LaListeMerci) $JR foreach J [lrange $LesJumeaux 0 end] { set JumeauRepresentatif($J) $JR } } set JumeauRepresentatif("EstCharge") 1 return [JumeauRepresentatif $Nom] } proc Jumeaux {{Source ""} {Rep ""}} { while {$Source=="" || $Source =="Ask"} { set Source [ChoixParmi [list "NoTwinsAtAll" "SeqNuc" "LocChroContig" "Overlap"]] if {$Source!=""} { break } } set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux_$Source" while {[file exists $FichierDesJumeaux]} { if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I replace it ?"]} { File delete -force $FichierDesJumeaux break } if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I keep it ?"]} { return $FichierDesJumeaux } } set LesSeqNom {} if {$Source=="Overlap"} { return [ClustersDeClonesAuxLocsChevauchantes] } if {$Source=="SeqNuc"} { if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" } foreach Nom [ListeDesPABs] { set Fichier "$Rep/$Nom" if { ! [file exists $Fichier]} { continue } set Seq [string toupper [QueLaSequenceDuTFA $Fichier]] lappend LesSeqNom "$Seq $Nom" } } if {$Source=="LocChroContig"} { foreach Nom [ListeDesPABs] { set LesLocCC [LesLocalisationsSurChroContig $Nom] if {$LesLocCC=={}} { continue } set LocCC [lindex $LesLocCC 0] regsub { [+\-]} $LocCC "" LocCC regsub -all { } $LocCC "_" LocCC lappend LesSeqNom "$LocCC $Nom" } } set LesSeqNom [lsort $LesSeqNom] lappend LesSeqNom "bidon bidon" set OldSeq "zzzzzz" set LaSortie {} foreach SeqNom $LesSeqNom { scan $SeqNom "%s %s" Seq Nom if {$OldSeq==$Seq} { if { ! [info exists LesMemes]} { set LesMemes $OldNom } lappend LesMemes $Nom } else { if {[info exists LesMemes]} { lappend LaSortie [join $LesMemes " "] unset LesMemes } } set OldSeq $Seq set OldNom $Nom } if {$LaSortie=={}} { Sauve "No twins were found" dans $FichierDesJumeaux } else { SauveLesLignes $LaSortie dans $FichierDesJumeaux } return $FichierDesJumeaux } proc JumeauxAccessBestProteine {Fichier1200} { foreach Ligne [LesLignesDuFichier $Fichier1200] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set JR [lindex $LesJumeaux 0] lappend ListeDesJR $JR } Espionne [llength $ListeDesJR] Espionne [llength [lsort -unique $ListeDesJR]] #SauveLesLignes $ListeDesJR dans "[RepertoireDuGenome]/fiches/1195" foreach Nom $ListeDesJR { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] lappend L "$AccBestProtHuman $Nom" #set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] #lappend L "$AccBestmRNAHuman $Nom" } Espionne [llength $L] set Ltriee [lsort $L] #Espionne $Ltriee SauveLesLignes $Ltriee dans "[RepertoireDuGenome]/fiches/AccBestProtHuman_JR" #SauveLesLignes $Ltriee dans "[RepertoireDuGenome]/fiches/AccBestmRNAHuman_JR" set n 0; set AccPrec aaa foreach ProtDD $Ltriee { set LesElts [split $ProtDD " "] set Acc [lindex $LesElts 0]; set DD [lindex $LesElts 1] #FaireLire $Acc if {$Acc!="" && $Acc==$AccPrec} {incr n;Espionne $Acc} set AccPrec $Acc } return $n } proc JumeauxRefSeq {FichierBestNMDef FichierSortie} { foreach Nom [ListeDesPABs] { set NM [InterrogeFichierBestNMavecDef $FichierBestNMDef $Nom NM] if {$NM!=""} { lappend Liste "$Nom\t$NM" } } Espionne [llength $Liste] set L [lsort -index 1 $Liste] Espionne [llength $L] set PrevAccess "zzzzz" foreach Elt $L { set LesData [split $Elt "\t"] set DD [lindex $LesData 0] set Access [lindex $LesData 1] if {$Access==$PrevAccess} { if {![info exists LesMemes]} {lappend LesMemes $PrevDD} lappend LesMemes $DD } else { if {[info exists LesMemes]} { lappend LaSortie [join $LesMemes " "] unset LesMemes } } set PrevAccess $Access set PrevDD $DD } Espionne [llength $LaSortie] SauveLesLignes $LaSortie dans $FichierSortie foreach J $LaSortie { set LesJumeaux [split $J " "] set JR [lindex $LesJumeaux 0] if {[file exists "[RepertoireDuGenome]/prottfa/$JR"]} {lappend AvecProt $JR} } Espionne [llength $AvecProt] set l [lsort -unique $AvecProt] Espionne [llength $l] } proc JunkDir {{JunkDir ""}} { return [RepertoireDeTravail $JunkDir] } proc KEGG {Nom FileMSF FileClust {IdDesProtId 0.98} {NormMDMin 0.5}} { ####Recherche des EC appartennant aux proteines du cluster du msf si celui-ci a un bon NormMD#### if {![file exists $FileMSF]} {return [list "$Nom\tNothing"]} AskMSF unset if {[AskMSF $FileMSF $Nom] != ""} { set Query $Nom } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" } else { return [list "$Nom\tNothing"] } set Cluster [InterrogeLesClustersDesMSF $FileClust Access $Query Cluster] if {$Cluster == "" } { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust LesAccess] } else { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust Cluster $Cluster LesAccess] } set LesAccessDesId {} foreach Access $LesAccessDuMSF { if {$Query == $Access} {continue} if {[EstUnAccessPDB $Access]} {continue} if {[IDdansMSF $FileMSF $Query $Access SelonA] < $IdDesProtId} {continue} if {[IDdansMSF $FileMSF $Query $Access SelonB] < $IdDesProtId} {continue} lappend LesAccessDesId $Access } set NormMD [MDScoreAvecSelectionDuFichier $FileMSF $LesAccessDuMSF] Espionne "$Nom -> NormMD $NormMD" if {$NormMDMin <= $NormMD} { set LesAccess [lsort -unique [concat $LesAccessDuMSF $LesAccessDesId]] } else { set LesAccess [lsort -unique $LesAccessDesId] } AskLesPagesInfos load $LesAccess protein set LesEC {} set LesKegg {} set LesPathway {} foreach Access $LesAccess { if {$Query == $Access} {continue} if {[regexp {^[0-9]} $Access]} {continue} set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} {continue} Espionne $Access foreach LaReq [PageInfo2Kegg $PageInfo] { set Quoi [lindex $LaReq 0] set Qui [lindex $LaReq 1] if {$Quoi == "Pathway"} {lappend LesPathway $Qui} if {$Quoi == "Kegg" } {lappend LesKegg $Qui} if {$Quoi == "EC" } {lappend LesEC $Qui} } } AskLesPagesInfos unset if {$LesEC == {} && $LesKegg == {} && $LesPathway == {}} {return [list "$Nom\tNothing"]} set LeTexte {} ###Il ne reste plus qu'a ecrire dans le fichier########### foreach EC [lsort -unique $LesEC ] {lappend LeTexte "$Nom\tEC\t$EC\t" } foreach Kegg [lsort -unique $LesKegg ] {lappend LeTexte "$Nom\tKegg\t$Kegg\t[InterrogeKEGG Kegg $Kegg Definition]" } foreach Pathway [lsort -unique $LesPathway] {lappend LeTexte "$Nom\tPathway\t$Pathway\t[InterrogeKEGG Pathway $Pathway Definition]"} if {$LeTexte == {}} {return [list "$Nom\tNothing"]} return $LeTexte } proc KEGGDir {{OrgaC ""}} { if {$OrgaC != ""} {return "[GscopeDatabaseDir KEGG]/pathway/$OrgaC"} return "[GscopeDatabaseDir KEGG]/pathway" } proc KPduKG {KG Organisme} { # set NP [BirdGet $NM "accession"] # regsub {\..*} $NP "" NP # return $NP set Query "select kgID, displayID, alias from ucsc$Organisme.kgprotalias Where kgID=$KG" set KP [BirdSendQueryAndGetFromUrl $Query "" "flat"] return $KP } proc KanvaCourant {} { global KanvaCourant global CurrentGenome if {[info exists KanvaCourant]} { return $KanvaCourant } set KanvaCourant [GscopeBoard $CurrentGenome] return $KanvaCourant } proc Keep1ByCluster {clusterList minIdentity} { #initialisation var + fichier set FIC [open "deletedByRedundancy.log" "w"] global RepertoireDuGenome set repTfa "/prottfa" set compteurGroupe 0 set compteurRedundant 0 #la liste final des proteines a supprimer #toutes celles a supprimer (le PAB n'apparait qu'une seule fois dans la liste) set aSupprimer [list ] puts " --> determination de la sequence à garder par cluster (sp > (tr | ref)" ################################################################################" #on cree le fichier log foreach cluster $clusterList { set currentMax 0 set currentMaxSp 0 set maxName "" set maxNameSp "" foreach proteine $cluster { #puts "$proteine" set l [BenSeqLength $proteine] if {$l==-1} {puts "probs avec la longueur de '$proteine' : $repTfa"} set origin [lindex [split [ExtraitInfo $proteine Narcisse] : ] 0] #verif si "sp" (swissprot), si oui, on garde la plus grande if {$origin=="sp" && $l > $currentMaxSp} { set currentMaxSp $l set maxNameSp "$proteine" #puts "if1 $currentMaxSp : $maxNameSp" } #recherche de la plus longue toute origine confondue if {$l > $currentMax} { set currentMax $l set maxName "$proteine" } } #si on a du swissprot, on le garde en priorité if {$currentMaxSp!=0 && $maxNameSp!=""} { set currentMax $currentMaxSp set maxName $maxNameSp #puts "if2 $currentMax : $maxName" } #max detecte, on va remplir le log ##info des groupes puts $FIC ">groupe $maxName (l=[BenSeqLength $maxName] o=[lindex [split [ExtraitInfo $maxName Narcisse] : ] 0]): [string trim [BenEnteteTFA $maxName]]" incr compteurGroupe ##info des membre foreach proteine $cluster { if {$proteine!=$maxName} { puts $FIC " $proteine (l=[BenSeqLength $proteine] o=[lindex [split [ExtraitInfo $proteine Narcisse] : ] 0]): [string trim [BenEnteteTFA $proteine]]" #si le PAB est deja dans la liste "aSupprimer", on ne le rajoute pas une 2nd fois if {[lsearch -exact $aSupprimer $proteine]==-1} { lappend aSupprimer $proteine incr compteurRedundant } } } set currentMax 0 set currentMaxSp 0 set maxName "" set maxNameSp "" } puts $FIC "### [Maintenant]" puts $FIC "### minIdentity = $minIdentity %" puts $FIC "### nbre de groupes : $compteurGroupe" puts $FIC "### nbre de redondants uniques: $compteurRedundant" close $FIC ############################################################################ #on va supprimmer les redondants de la listedesPABs #et en faire une sauvegarde puts " -->sauvegarde de bornedespabs en bornesdespabs.backup" file copy -force "$RepertoireDuGenome/fiches/bornesdespabs" "$RepertoireDuGenome/fiches/bornesdespabs.backup" file delete "$RepertoireDuGenome/fiches/bornesdespabs" set FICOUT [open "$RepertoireDuGenome/fiches/bornesdespabs" "w"] set FICIN [open "$RepertoireDuGenome/fiches/bornesdespabs.backup" "r"] #suppression des redondants dans bornedespabs.backup #et ecriture dans bornedespabscorrectes puts " -->suppression des redondants dans /infos/bornesdespabs" while {[gets $FICIN line]!=-1} { if {[lsearch -exact $aSupprimer [lindex [split $line] 0]]!=-1} { continue } puts $FICOUT $line } close $FICIN close $FICOUT puts " --> Pour infos, un fichier \"deletedByRedundancy.log\" a été créé." puts " Il contient les infos concernant ce qui a été supprimé." ############################################################################ # on garde les anciens fichiers au cas ou #si les rep de sauvegarde sont absents, on les cree if {![file exists "$RepertoireDuGenome/prottfa/backup/"]} { file mkdir $RepertoireDuGenome/prottfa/backup puts " -->creation du repertoire de sauvegarde : $RepertoireDuGenome/prottfa/backup/" } puts " -->transfert des sequences a supprimer dans $RepertoireDuGenome/prottfa/backup/" foreach PAB $aSupprimer { if {[file exists "$RepertoireDuGenome/prottfa/$PAB"]} { file rename "$RepertoireDuGenome/prottfa/$PAB" "$RepertoireDuGenome/prottfa/backup/$PAB" } } ############################################################################ # creation d'un fasta du proteome corrigé puts " -->creation du fichier du protéome corrigé : final_correctedProteome.fasta" set pref [PreFixe] set filename "final_[PreFixe]_correctedProteome.fasta" set FICOUT [open $filename "w"] RechargeListeDesPABs puts $FICOUT "### [Maintenant]" puts $FICOUT "### minIdentity = $minIdentity %" foreach PAB [ListeDesPABs] { set FICIN [open "$RepertoireDuGenome/prottfa/$PAB"] while {[gets $FICIN line]!=-1} { puts $FICOUT $line } close $FICIN } close $FICOUT } proc KeepOnlyHeader {fasta} { set FICIN [open $fasta "r"] set FICOUT [open "listeEntetesFasta" "w"] while {[gets $FICIN line]!=-1} { if {$line==""} { continue } if {[string index $line 0]==">"} { puts $FICOUT $line } } close $FICIN close $FICOUT } proc KeepOnlyInteractantUbi {Repertoire} { #set Repertoire "/genomics/link/FLD/STRING/StringCombinedFASTED_10090_201302141718" set WithAny "$Repertoire/WithAny.string" set Sandwich "$Repertoire/Sandwich.string" set QueryOnly "$Repertoire/QueryOnly.string" set LesFiles [list $WithAny $Sandwich $QueryOnly] foreach File $LesFiles { set FileShort [file tail $File] set LesParts [split $FileShort "."] set Name [lindex $LesParts 0] set Ext [lindex $LesParts 1] set NvFile "${Name}OnlyUbi.$Ext" set LesNvLignes {} foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^PIDInitial" $Ligne]} { lappend LesNvLignes $Ligne continue } set IdInteractant [lindex [split $Ligne "\t"] 2] if {[InterrogeIdentifiersString $IdInteractant Ini "$Repertoire/Identifiers"] == "YES"} { lappend LesNvLignes $Ligne continue } if {[InterrogeMouseUbiquitin $IdInteractant Ubi] == "YES"} { lappend LesNvLignes $Ligne } } SauveLesLignes $LesNvLignes dans "$Repertoire/$NvFile" } } proc KeepOnlyInteractionWithExperimentEvidence {Repertoire} { #set Repertoire "/genomics/link/FLD/STRING/StringCombinedFASTED_10090_201302141718" set WithAny "$Repertoire/WithAny.string" set Sandwich "$Repertoire/Sandwich.string" set QueryOnly "$Repertoire/QueryOnly.string" set LesFiles [list $WithAny $Sandwich $QueryOnly] foreach File $LesFiles { set FileShort [file tail $File] set LesParts [split $FileShort "."] set Name [lindex $LesParts 0] set Ext [lindex $LesParts 1] set NvFile "${Name}OnlyExp.$Ext" set LesNvLignes {} foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^PIDInitial" $Ligne]} { lappend LesNvLignes $Ligne } if {[regexp "experimental" $Ligne]} { lappend LesNvLignes $Ligne } } SauveLesLignes $LesNvLignes dans "$Repertoire/$NvFile" } } proc KeepOnlyInteractionWithExperimentEvidenceAndOnlyInteractantUbi {Repertoire} { #set Repertoire "/genomics/link/FLD/STRING/StringCombinedFASTED_10090_201302141718" set WithAny "$Repertoire/WithAny.string" set Sandwich "$Repertoire/Sandwich.string" set QueryOnly "$Repertoire/QueryOnly.string" set LesFiles [list $WithAny $Sandwich $QueryOnly] foreach File $LesFiles { set FileShort [file tail $File] set LesParts [split $FileShort "."] set Name [lindex $LesParts 0] set Ext [lindex $LesParts 1] set NvFile "${Name}OnlyExpOnlyUbi.$Ext" set LesNvLignes {} foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^PIDInitial" $Ligne]} { lappend LesNvLignes $Ligne continue } if {![regexp "experimental" $Ligne]} { continue } set IdInteractant [lindex [split $Ligne "\t"] 2] if {[InterrogeIdentifiersString $IdInteractant Ini "$Repertoire/Identifiers"] == "YES"} { lappend LesNvLignes $Ligne continue } if {[InterrogeMouseUbiquitin $IdInteractant Ubi] == "YES"} { lappend LesNvLignes $Ligne } } SauveLesLignes $LesNvLignes dans "$Repertoire/$NvFile" } } proc KeyList {K} { global KeyList if {$K=="PleaseReset"} { if {[info exists KeyList]} { unset KeyList } return "" } if {$K=="PleaseGetKeys"} { if {[info exists KeyList]} { return $KeyList } return {} } lappend KeyList $K return $K } proc KgAlias {{Qui ""} {Quoi ""}} { global KgAlias Wup "Il y 2 colonnes Id et Gn" if {[info exists KgAlias($Qui,$Quoi)]} {return $KgAlias($Qui,$Quoi)} if {[info exists KgAlias("EstCharge")]} {return ""} set KgAlias("EstCharge") 1 if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {$Quoi==""} {set Quoi "Gn"} set Fichier "/genomics/link/UCSCGenomes/Mus_musculus/database/kgAlias.txt" set LesLignes [LesLignesDuFichier $Fichier] set KgAlias(ListOf,headers) [list "Id" "Gn"] foreach Ligne $LesLignes { set LesMots [split $Ligne "\t"] set Id [lindex $LesMots 0] set Gn [lindex $LesMots 1] lappend KgAlias(ListOf,Id) $Id lappend KgAlias(ListOf,Gn) $Gn #liste des Gns correspondant a un Id lappend KgAlias($Id,Gn) $Gn #liste des Ids correspondant a un Gn lappend KgAlias($Gn,Id) $Id } set KgAlias(ListOf,Id) [lsort -unique $KgAlias(ListOf,Id)] set KgAlias(ListOf,Gn) [lsort -unique $KgAlias(ListOf,Gn)] return [KgAlias $Qui $Quoi] } proc KickOutThatName {prefix oldWord newWord} { set compteur 1 puts "'$oldWord'" #regexp -indices $oldWord "vbcy_dgy_ brucei. udgf edg" var #puts $var #unset var file mkdir "modifiedNames" for {set i 1} {$i<30000} {incr i} { set base "" if {$i<10} { append base $prefix "0000$i" if {![file exists $base]} {continue} puts ">>> modif $base $i" set input [open "./$base" "r"] set output [open "./modifiedNames/$base" "w"] } elseif {$i<100} { append base $prefix "000$i" if {![file exists $base]} {continue} puts ">>> modif $base $i" set input [open "./$base" "r"] set output [open "./modifiedNames/$base" "w"] } elseif {$i<1000} { append base $prefix "00$i" if {![file exists $base]} {continue} puts ">>> modif $base $i" set input [open "./$base" "r"] set output [open "./modifiedNames/$base" "w"] } elseif {$i<10000} { append base $prefix "0$i" if {![file exists $base]} {continue} puts ">>> modif $base $i" set input [open "./$base" "r"] set output [open "./modifiedNames/$base" "w"] } elseif {$i<100000} { append base $prefix "$i" if {![file exists $base]} {continue} puts ">>> modif $base $i" set input [open "./$base" "r"] set output [open "./modifiedNames/$base" "w"] } while {[gets $input line]!=-1} { regexp -indices $oldWord $line var if {[info exists var]} { puts "[lindex $var 0] [lindex $var 1]" puts $output [string replace $line [lindex $var 0] [lindex $var 1] "$newWord"] unset var continue } puts $output $line } close $input close $output } } proc KillParLaCroix {} { return } proc KillPython {} { set Qds [exec ps -ef | grep "python"] set LesQds [split $Qds "\n"] foreach Ligne $LesQds { Espionne $Ligne if { ! [regexp "python sv" $Ligne]} { continue } scan $Ligne "%s %d" moi Pid Espionne $Pid catch {exec kill -9 $Pid} } } proc KillQds {} { set Qds [exec ps -ef | grep "/cafedessciences/bin/qds"] set LesQds [split $Qds "\n"] foreach Ligne $LesQds { Espionne $Ligne if { ! [regexp "/usr/local/bin/tclsh .*/cafedessciences/bin/qds " $Ligne]} { continue } scan $Ligne "%s %d" moi Pid Espionne $Pid catch {exec kill -9 $Pid} } } proc KinaseBarcode {} { cd [EvolHHuProDir] foreach Ligne [LesLignesDuFichier "kinase_bilan.lst"] { set X "" set Y "unk" scan $Ligne "%s %s %s %s %s %s" K A E B X Y if {$X==""} { continue } set Xde($K) $X set Yde($K) $Y } foreach Ligne [LesLignesDuFichier "barcode.txt"] { set K "" scan $Ligne "%s" K if {$K==""} { continue } if {[info exists Xde($K)]} { set N [join [list $Xde($K) $Yde($K) $K] "_"] regsub $K $Ligne $N New lappend LeNew $New } else { lappend LeNew $Ligne } } return [SauveLesLignes $LeNew dans "KinaseBarcode.txt"] } proc KoAnno {{Access ""} {ExistingAccess ""} {NomMsf ""} {ExistingNomMsf ""}} { if {$ExistingNomMsf!=""} { return [ExistingKoAnnoMsf $ExistingNomMsf] } if { $NomMsf!=""} { return [KoAnnoMsf $NomMsf] } if {$ExistingAccess!=""} { return [ExistingKoAnnoAccess $ExistingAccess] } if { $Access!=""} { return [KoAnnoAccess $Access] } return "Please fill in One field and press Send" } proc KoAnnoAccess {Access} { if { ! [regexp -nocase {^[A-Z][A-Z0-9]+$} $Access]} { return "Sorry, it seems that $Access is not a valid protein accession number" } set RepParent [OnGoingDir] set Rep "$RepParent/$Access" if {0 && [file exists $Rep]} { return "I saw already $Access, please run it as Existing KoAnno result" } if {[FileAbsent $RepParent]} { file mkdir $RepParent } set LesFichiersCrees [FouinePourLesAccess [list $Access] $RepParent] if {[regexp "^Show " $LesFichiersCrees]} { return $LesFichiersCrees } if {$LesFichiersCrees==""} { return "Sorry something went wrong" } return [ExistingKoAnnoAccess $Access] } proc KoAnnoInfo {Access} { set Info [SequenceDesBanques $Access] return "

$Info

" set Url "http://bips.u-strasbg.fr/srsbin/cgi-bin/wgetz?-e+\[{swissprot_SP_sptrembl}-acc:$Access\]|\[swissprot-id:$Access\]+-vn+2" return [HttpCopy $Url] } proc KoAnnoMsf {{NomMsf ""}} { if {$NomMsf==""} { return "" } set RepParent "[OnGoingDir]/$NomMsf" set FichierMsf "$RepParent/$NomMsf.msf" if {[FileAbsent $FichierMsf]} { set Trouve "" set LesPossibles [glob -nocomplain "/tools/wwwbio3d/Receptacle/UpLoad.*_of_KoAnnoMsf_$NomMsf*"] foreach Possible $LesPossibles { set Dirna [file dirname $Possible] set Queue [file tail $Possible] set BelleQueue [StringApres "_of_KoAnnoMsf_" dans $Queue] regsub -nocase "\.msf$" $BelleQueue "" BelleQueue append BelleQueue ".msf" if {$NomMsf==$BelleQueue} { set Trouve $Possible } } if {$Possible==""} { return "Sorry, $FichierMsf doesn't exist. Please upload it." } if { ! [file exists $RepParent]} { file mkdir $RepParent } file copy $Possible $FichierMsf } set LesFichiersCrees [FouinePourUnMsf $FichierMsf $RepParent] if {$LesFichiersCrees==""} { return "Sorry something went wrong" } return [ExistingKoAnnoMsf $NomMsf] } proc KoAnnoPourTous {{Repertoire ""}} { if {$Repertoire==""} { set Repertoire [RepertoireDuGenome]/msf } set r [glob -directory $Repertoire *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } KoAnnoX $fichier FinPasTouche $f } } proc KoAnnoUpdateXmlWithMacsim {NomMsf} { set RepParent "[OnGoingDir]/$NomMsf" set FichierXml "$RepParent/$NomMsf.xml" if {[FileAbsent $FichierXml]} { return "Please create first the xml file from the multiple alignement with KoAnno" } set Status [UpdateXmlWithMacsim $FichierXml] if {[regexp -nocase "^Error|^Return" $Status]} { return $Status } return [ExistingKoAnnoMsf $NomMsf] } proc KoAnnoX {fichier} { set Repertoire [RepertoireDuGenome] set RepertoireKoAnno $Repertoire/KoAnno/ if { ! [file exists "$RepertoireKoAnno"]} { File mkdir $RepertoireKoAnno } #Espionne "msf: $fichier" set list [split $fichier "/"] set newRep $RepertoireKoAnno[lindex $list [llength $list]-1] set FichierXml $Repertoire/macsimXml/[lindex $list [llength $list]-1] if { ! [file exists "$newRep"]} { File mkdir $newRep } FouinePourUnMsfX "$fichier" "$newRep" CreeXmlAnnotePourUnMsfX "$fichier" "$newRep" } proc LAacMetOuNon {} { set RepertoireSourisOthers "/genomics/link/SpliRetMouse/FichiersInitial/SOURIS_others" set RepertoireSourisTfactor "/genomics/link/SpliRetMouse/FichiersInitial/SOURIS_Tfactor" set RepertoireRatOthers "/genomics/link/SpliRetRat/FichiersInitial/RAT_others" set RepertoireRatTfactor "/genomics/link/SpliRetRat/FichiersInitial/RAT_Tfactor" set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireRatTfactor $RepertoireRatOthers] foreach Repertoire $LesRepertoires { foreach File [glob -nocomplain "$Repertoire/*"] { set cluster [lindex [split [file tail $File] "."] 0] foreach Ligne [LesLignesDuFichier $File] { if {[regexp "^>" $Ligne] } { set trouve 0 if {[regexp "^>LA" $Ligne] || [regexp "^>30" $Ligne]} { set trouve 1 set nbligne 0 } } else { if {$trouve} { set Premier [lindex [split $Ligne ""] 0] set trouve 0 if {$Premier!="M"} {Espionne "attention $cluster"} } } } } } } proc LAccessEtLaBanque {Id {FichierAvecAccess ""}} { set LesInfos {} if { [regexp "^Msa." $Id ] || [regexp "^AFFX" $Id ] } { if {![file exists $FichierAvecAccess]} { lappend LesInfos "Not found" lappend LesInfos "Not found" } else { set NewId [CorrigeId $Id] foreach Ligne [LesLignesDuFichier $FichierAvecAccess] { if {[regexp $NewId $Ligne]} { set LaLigne [split $Ligne "\t"] regsub -all " " [lindex $LaLigne 1] "" Access lappend LesInfos $Access lappend LesInfos "GB" return $LesInfos } else {continue} } if {$LesInfos == ""} { lappend LesInfos "Not Found" lappend LesInfos "Not Found" } } } elseif {[regexp "^YEL" $Id ] } { lappend LesInfos "Not Found" lappend LesInfos "Not Found" } elseif {[regexp "^TC" $Id ] } { lappend LesInfos [CorrigeId $Id] lappend LesInfos "TIGR" } elseif {[regexp "^ET" $Id ] } { lappend LesInfos [CorrigeId $Id] lappend LesInfos "EGAD" } else { lappend LesInfos [CorrigeId $Id] lappend LesInfos "GB" } return $LesInfos } proc LApercuDesGenesDuProjet {FichierClusters} { set Liste [ListeDesJR $FichierClusters] set LApercu {} set Entete "Name\tTwins\tAC Prot\tAC mRNA\tDefinition mRNA" lappend LApercu $Entete foreach Nom $Liste { set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccessProt=="" && $AccessmRNA==""} {continue} if {$AccessProt!=""} { set Definition [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Definition] } else { set Definition [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Definition] } if {$Definition==""} {continue} set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] lappend LApercu "$Nom\t$LesJumeaux\t$AccessProt\t$AccessmRNA\t$Definition" } return $LApercu } 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] } proc LCnk {Ln k} { set n [llength $Ln] set x 0 set Lr [list] while {$x < $k} { set Ltmp $Lr foreach e $Ltmp { set f [lindex $e end] for {set i [expr {$f+1}]} {$i < $n} {incr i} { lappend Ltmp [list {*}$e $i] } } for {set i 0} {$i < $n} {incr i} { lappend Ltmp $i } set Lr $Ltmp incr x } set Lr [lsort -unique $Lr] set Ltot [list] foreach e $Lr { if {[llength $e] == $k} { lappend Ltot $e } } set Lres [list] foreach e $Ltot { set tmp [list] foreach i $e { lappend tmp [lindex $Ln $i] } lappend Lres $tmp } return $Lres } proc LCnk_choose {Lv Ln k} { set n [llength $Ln] foreach e $Lv { set x [lindex $e end] for {set i [expr {$x + 1}]} {$i < $n} {incr i} { lappend Lr [list {*}$e $i] } } } proc LConcat {aListe ListeB} { upvar $aListe Liste if { ! [info exists Liste]} { set Liste {} } set Liste [concat $Liste $ListeB] return $Liste } proc LConcatTest {} { set L {a b c} return [LConcat L {d e f}] } proc LElectionDeMissBlast {FichierBlast LesBanquesIdEtLesAccess {Pourcentage ""} {ExpectMax ""} {NbSubject ""}} { Wup "retourne les Access classes en fonction du score, de l'expect et de leur apparition dans le blast" Wup "Liste contenant plusieurs autres listes contenant les elements suivants : BanqueId Access Expect Score Subject Classement" if {$LesBanquesIdEtLesAccess == {}} {return ""} if {![file exists $FichierBlast]} { Espionne "$FichierBlast does not exist" return "" } if {$ExpectMax == "" } {set ExpectMax "1e-3"} if {$NbSubject == "" } {set NbSubject "250" } if {$Pourcentage == ""} {set Pourcentage "0.05"} set LesListes {} set LesLaiderons {} foreach BanqueIdEtAccess $LesBanquesIdEtLesAccess { scan $BanqueIdEtAccess "%s %s" BanqueId Access set Subject [UnSubjectDuBlast $FichierBlast $BanqueId $Access] if {$Subject == ""} { set LesInfos [list "$BanqueId" "$Access" "" "" "" "0"] lappend LesLaiderons $LesInfos continue } if {[regexp {Expect\([0-9]\) = } $Subject]} { regsub {Expect\([0-9]\) = } $Subject "Expect = " Subject } regexp -nocase "Expect = (\[a-z0-9\.\-]*) " $Subject tmp Expect if {[regexp "^e" $Expect]} { set Expect "1$Expect"} regexp -nocase "Score = (\[e0-9\.\+]*) bits " $Subject tmp Score if {$Expect > $ExpectMax} { set LesInfos [list "$BanqueId" "$Access" "$Expect" "$Score" "$Subject" "0"] lappend LesLaiderons $LesInfos continue } set LesInfos [list "$BanqueId" "$Access" "$Expect" "$Score" "$Subject"] lappend LesListes $LesInfos } set LesListes [lsort -decreasing -real -index 3 [lsort -real -index 2 $LesListes]] if {$LesListes != {}} { set ExpectDeRef [lindex [lindex $LesListes 0] 2] set ScoreDeRef [lindex [lindex $LesListes 0] 3] set LeScoreMinEtMax [DePartEtDAutreDeLaValeur $ScoreDeRef $Pourcentage] set ScoreMin [lindex $LeScoreMinEtMax 0] set ScoreMax [lindex $LeScoreMinEtMax 1] set Classement 1 set LePodium {} set i "-1" foreach LesInfos $LesListes { set Expect [lindex $LesInfos 2] set Score [lindex $LesInfos 3] if {$ScoreMin <= $Score && $Score <= $ScoreMax && $ExpectDeRef == $Expect} { lappend LesInfos $Classement incr i } else { incr Classement set Classement [expr $Classement + $i] lappend LesInfos $Classement set ExpectDeRef $Expect set ScoreDeRef $Score set LeScoreMinEtMax [DePartEtDAutreDeLaValeur $ScoreDeRef $Pourcentage] set ScoreMin [lindex $LeScoreMinEtMax 0] set ScoreMax [lindex $LeScoreMinEtMax 1] set i 0 } lappend LePodium $LesInfos } } foreach LesInfos $LesLaiderons { lappend LePodium $LesInfos } return $LePodium } proc LEnteteDuGalFile {{Fichier ""}} { Wup "Permet de recuperer l entete d un GalFile pour mieux l utiliser" set RepPuceOntario "[RepertoireDuGenome]/Autres_Puces/Ontario/GalFile" if {$Fichier == ""} {set Fichier "$RepPuceOntario/SS-H19k7.gal"} set Entete "" set SurLeHeader 0 set SurLesDonnees 0 set NDeLigne 0 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { #block col row name id if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} if {$SurLeHeader !="1" && [regexp -nocase "^ATF" $Ligne]} { set SurLeHeader 1 set NDeLigne 0 lappend Entete "$Ligne" continue } if {$SurLeHeader=="1" && $NDeLigne=="0"} { set LigneSplitee [split $Ligne "\t"] #On ajoute 1 colonne de donnee supplementaire set NMaxOptionalHeader [lindex $LigneSplitee 0] set NewLigne [join [list $NMaxOptionalHeader [expr [lindex $LigneSplitee 1]+1]] "\t"] set NDeLigne 1 lappend Entete "$NewLigne" continue } if {$SurLeHeader=="1" && [expr $NDeLigne <= $NMaxOptionalHeader]} { incr NDeLigne lappend Entete "$Ligne" continue } else {set SurLeHeader 0} break } close $F return "$Entete" } proc LIndexes {Liste args} { set L {} foreach I $args { lappend L [lindex $Liste $I] } return $L } proc LInsertionDesRegionsAbsentes {LesRegions TailleQuery} { set LesRegions [lsort -integer -index 0 $LesRegions] set LesAccessEtLeurSens {} set ToutesLesRegions {} foreach UneRegion [lsort -integer -index 0 $LesRegions] { set Access [lindex [lindex $UneRegion 4] 1] set Sens [lindex $UneRegion 6] lappend ToutesLesRegions $UneRegion if {![info exists TabTmp($Access,$Sens,LesR)]} { set TabTmp($Access,$Sens,LesR) {} lappend LesAccessEtLeurSens [list $Access $Sens] } lappend TabTmp($Access,$Sens,LesR) $UneRegion } foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] set LesRegionsDuContig [set TabTmp($Access,$Sens,LesR)] if {$Sens == "+"} { set LesRegionsDuContig [lsort -index 7 -integer $LesRegionsDuContig] } else { set LesRegionsDuContig [lsort -decreasing -index 7 -integer $LesRegionsDuContig] } set LesRegionsDuContig [lsort -integer -index 0 $LesRegionsDuContig] set nRegionsDuContig [llength $LesRegionsDuContig] foreach UneRA [LesRegionsAbsentesDesPetitesRegions $LesRegionsDuContig 1 $TailleQuery] { set DA [Mini [lindex $UneRA 0] [lindex $UneRA 1]] set FA [Maxi [lindex $UneRA 0] [lindex $UneRA 1]] for {set i 0} {$i < $nRegionsDuContig} {incr i} { set nR [expr $i + 1] set LaRPrec [lindex $LesRegionsDuContig $i] set LeContig [lindex $LaRPrec 4] set DPrec [Mini [lindex $LaRPrec 0] [lindex $LaRPrec 1]] set FPrec [Maxi [lindex $LaRPrec 0] [lindex $LaRPrec 1]] if {$Sens == "+"} { set DSPrec [Mini [lindex $LaRPrec 7] [lindex $LaRPrec 8]] set FSPrec [Maxi [lindex $LaRPrec 7] [lindex $LaRPrec 8]] } else { set DSPrec [Maxi [lindex $LaRPrec 7] [lindex $LaRPrec 8]] set FSPrec [Mini [lindex $LaRPrec 7] [lindex $LaRPrec 8]] } if {$nR == 1} { if {$FA < $DPrec} { if {$Sens == "+" && $DSPrec != 1} { set DSA 1 set FSA [expr $DSPrec - 1] lappend ToutesLesRegions [list $DA $FA 0 0 $LeContig "" $Sens $DSA $FSA 0 0 0] break } if {$Sens == "-"} { set DSA 1e+200 set FSA [expr $DSPrec + 1] lappend ToutesLesRegions [list $DA $FA 0 0 $LeContig "" $Sens $DSA $FSA 0 0 0] break } } } if {$nR == $nRegionsDuContig} { if {$FPrec < $DA} { if {$Sens == "+"} { set DSA [expr $FSPrec + 1] set FSA 1e+200 } else { if {$FSPrec == 1} {continue} set DSA [expr $FSPrec - 1] set FSA 1 } lappend ToutesLesRegions [list $DA $FA 0 0 $LeContig "" $Sens $DSA $FSA 0 0 0] break } continue } set LaRSuiv [lindex $LesRegionsDuContig $nR] set DSuiv [Mini [lindex $LaRSuiv 0] [lindex $LaRSuiv 1]] if {$Sens == "+"} { set DSSuiv [Mini [lindex $LaRSuiv 7] [lindex $LaRSuiv 8]] } else { set DSSuiv [Maxi [lindex $LaRSuiv 7] [lindex $LaRSuiv 8]] } if {[expr abs($FPrec - $DSuiv)] <= 1 || [expr abs($FSPrec-$DSSuiv)] <= 1} {continue} if {$DA <= $FPrec} {continue} if {$DSuiv <= $FA } {continue} if {$Sens == "+"} { set DSA [expr $FSPrec + 1] set FSA [expr $DSSuiv - 1] } else { set DSA [expr $FSPrec - 1] set FSA [expr $DSSuiv + 1] } lappend ToutesLesRegions [list $DA $FA 0 0 $LeContig "" $Sens $DSA $FSA 0 0 0] break } } } return [lsort -integer -index 0 $ToutesLesRegions] } proc LInsertionDesRegionsRepetees {LesRegionsRepetees LesRegionsUniques TailleQuery} { set LesRegionsRepetees [lsort -integer -index 0 $LesRegionsRepetees] set LesAccessEtLeurSens {} set LesRegions {} foreach UneRegionUnique [lsort -integer -index 0 $LesRegionsUniques] { set Access [lindex [lindex $UneRegionUnique 4] 1] set Sens [lindex $UneRegionUnique 6] if {![info exists TabTmp($Access,$Sens,LesRU)]} { set TabTmp($Access,$Sens,LesRU) {} lappend LesAccessEtLeurSens [list $Access $Sens] } lappend LesRegions $UneRegionUnique lappend TabTmp($Access,$Sens,LesRU) $UneRegionUnique } foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] foreach UneRegion $LesRegionsRepetees { set Access2 [lindex [lindex $UneRegion 4] 1] set Sens2 [lindex $UneRegion 6] if {$Access2 != $Access || $Sens2 != $Sens} {continue} set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } set LesRUDuContig [set TabTmp($Access,$Sens,LesRU)] set nRUDuContig [llength $LesRUDuContig] for {set i 0} {$i < $nRUDuContig} {incr i} { set nRU [expr $i +1] set LaRUPrec [lindex $LesRUDuContig $i] set DPrec [Mini [lindex $LaRUPrec 0] [lindex $LaRUPrec 1]] set FPrec [Maxi [lindex $LaRUPrec 0] [lindex $LaRUPrec 1]] if {$Sens == "+"} { set DSPrec [Mini [lindex $LaRUPrec 7] [lindex $LaRUPrec 8]] set FSPrec [Maxi [lindex $LaRUPrec 7] [lindex $LaRUPrec 8]] } else { set DSPrec [Maxi [lindex $LaRUPrec 7] [lindex $LaRUPrec 8]] set FSPrec [Mini [lindex $LaRUPrec 7] [lindex $LaRUPrec 8]] } if {$nRU == 1} { if {$DPrec != 1 && $F < $DPrec} { if {$Sens == "+" && $DSPrec != 1} { if {$FS < $DSPrec} { lappend LesRegions $UneRegion break } } if {$Sens == "-"} { if {$DSPrec < $FS} { lappend LesRegions $UneRegion break } } } } if {$nRU != $nRUDuContig} { set LaRUSuiv [lindex $LesRUDuContig $nRU] set DSuiv [Mini [lindex $LaRUSuiv 0] [lindex $LaRUSuiv 1]] if {$Sens == "+"} { set DSSuiv [Mini [lindex $LaRUSuiv 7] [lindex $LaRUSuiv 8]] } else { set DSSuiv [Maxi [lindex $LaRUSuiv 7] [lindex $LaRUSuiv 8]] } } else { set DSuiv $TailleQuery if {$Sens == "+"} {set DSSuiv 1e200} else {set DSSuiv 1} } if {[expr abs($FPrec - $DSuiv)] <= 1 || [expr abs($FSPrec-$DSSuiv)] <= 1} {continue} if {$D <= $FPrec} {continue} if {$DSuiv <= $F } {continue} if {$Sens == "+"} { if {$DS <= $FSPrec} {continue} if {$DSSuiv <= $FS } {continue} } else { if {$FSPrec <= $DS } {continue} if {$FS <= $DSSuiv} {continue} } lappend LesRegions $UneRegion break } } } if {[info exists TabTmp]} {unset TabTmp} foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] foreach UneRegion $LesRegions { set Access2 [lindex [lindex $UneRegion 4] 1] set Sens2 [lindex $UneRegion 6] if {$Access2 != $Access || $Sens2 != $Sens} {continue} set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {![info exists TabTmp($D,$F,n) ]} {set TabTmp($D,$F,n) 0} if {![info exists TabTmp($Access,$Sens,$D,$F,n)]} {set TabTmp($Access,$Sens,$D,$F,n) 0} incr TabTmp($D,$F,n) incr TabTmp($Access,$Sens,$D,$F,n) } } set ToutesLesRegions {} foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] foreach UneRegion $LesRegions { set Access2 [lindex [lindex $UneRegion 4] 1] set Sens2 [lindex $UneRegion 6] if {$Access2 != $Access || $Sens2 != $Sens} {continue} set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] set nTot [set TabTmp($D,$F,n)] set n [set TabTmp($Access,$Sens,$D,$F,n)] set UneRegion [lreplace $UneRegion 2 2 $nTot] set UneRegion [lreplace $UneRegion 3 3 $n ] lappend ToutesLesRegions $UneRegion } } return [lsort -integer -index 0 $ToutesLesRegions] } proc LNduFNgcg {N} { return [SNvsLNgcg $N ln] } proc LNduSNgcg {N} { return [SNvsLNgcg $N ln] } proc LOFtoTFAs {ListOfFiles {UseFilename ""}} { if {$UseFilename==""} { set UseFilename "UseFileName" } set UseFilename [string equal -nocase $UseFilename "UseFilename"] set LesTFAs {} foreach Fichier $ListOfFiles { if {[FileAbsent $Fichier]} { FaireLire "$Fichier\ndoesn't exist ... I'll skip it." continue } set Nom "" if {$UseFilename} { set Nom [file tail $Fichier] } set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] $Nom] lappend LesTFAs $TFA } return [join $LesTFAs "\n"] } proc LOPPI {pf} { set L [LongueurDeLaSequence $pf "prottfa"] set O [nombreCaracteristiqueAnalyse $pf "orthologie"] set P [nombreCaracteristiqueAnalyse $pf "pdb"] set F [nombreCaracteristiqueAnalyse $pf "pfam"] set I [nombreCaracteristiqueAnalyse $pf "interaction"] return "$L $O $P $F $I" } proc LPABLuc {} { return [LesLignesDuFichier [file join [RepGenLuc] prottfa ListeDesPABs]] set Ll [LesLignesDuFichier [file join [RepGenLuc] fiches bornesdespabs]] foreach l $Ll { if { ! [YaPABdans $Ligne] } { continue } ExtraireDe $Ligne Nom Debut Fin Orient set Boite $Nom lappend ListeDesPABs $Nom } return $ListeDesPABs } proc LaCategorieDeCuttOffDe {CutOff} { Wup "Permet de retourner la categorie du CutOff voulu" global CategorieDeCuttOff if {[info exists CategorieDeCuttOff($CutOff)]} { return [set CategorieDeCuttOff($CutOff)] } else { if {[info exists CategorieDeCuttOff(EstCharge)]} { return [LaCategorieDeCuttOffDe Default] } } if {! [info exists CategorieDeCuttOff($CutOff)]} { #On charge les infos set LesBoths [list GC Tm ExpTm XDebutDeOligoNt XFinDeOligoNt NbCandidats NbContigues NbUnrelated] set LesEquals [list NomOligo] set LesRegexps [list LesCandidats] set Default [list Default] #Both recherche les 2 criteres #Equal recherche exactement ce critere #Regxep recherche la presence de tous en meme temps foreach Cat [list LesBoths LesEquals LesRegexps Default] { switch -exact -- $Cat { "LesBoths" {set TypeDeCat "Both"} "LesEquals" {set TypeDeCat "Equal"} "LesRegexps" {set TypeDeCat "Regexp"} "Default" {set TypeDeCat "Regexp"} } foreach Element [set $Cat] { set CategorieDeCuttOff($Element) $TypeDeCat } } set CategorieDeCuttOff(EstCharge) 1 } return "[LaCategorieDeCuttOffDe $CutOff]" } proc LaConservationDesMeilleuresRegionsRepetees {LesRegions {var 0.05} {TailleMin 10}} { set LesRegionsRestantes {} set LesAccessEtLeurSens {} foreach UneRegion [lsort -integer -index 0 $LesRegions] { set Access [lindex [lindex $UneRegion 4] 1] set Sens [lindex $UneRegion 6] if {![info exists TabTmp($Access,$Sens,LesRR)]} { set TabTmp($Access,$Sens,LesRR) {} lappend LesAccessEtLeurSens [list $Access $Sens] } set n [lindex $UneRegion 3] if {$n <= 1} {lappend LesRegionsRestantes $UneRegion;continue} set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {[expr $F - $D + 1] < $TailleMin} {lappend LesRegionsRestantes $UneRegion;continue} lappend TabTmp($Access,$Sens,LesRR) $UneRegion if {![info exists TabTmp($Access,$Sens,$D,$F,nAliMax)]} { set TabTmp($Access,$Sens,$D,$F,nAliMax) 0 } set nAli [lindex $UneRegion 9 ] if {[set TabTmp($Access,$Sens,$D,$F,nAliMax)] < $nAli} { set TabTmp($Access,$Sens,$D,$F,nAliMax) $nAli } } foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] foreach UneRR [set TabTmp($Access,$Sens,LesRR)] { set D [Mini [lindex $UneRR 0] [lindex $UneRR 1]] set F [Maxi [lindex $UneRR 0] [lindex $UneRR 1]] set nAliMax [expr [set TabTmp($Access,$Sens,$D,$F,nAliMax)] * (1-$var)] set nAli [lindex $UneRR 9 ] if {$nAli < $nAliMax} {continue} if {![info exists TabTmp($Access,$Sens,$D,$F,n)]} { set TabTmp($Access,$Sens,$D,$F,n) 0 } if {![info exists TabTmp($D,$F,n)]} { set TabTmp($D,$F,n) 0 } incr TabTmp($Access,$Sens,$D,$F,n) incr TabTmp($D,$F,n) lappend LesRegionsRestantes $UneRR } } set ToutesLesRegions {} foreach UnAccessEtUnSens $LesAccessEtLeurSens { set Access [lindex $UnAccessEtUnSens 0] set Sens [lindex $UnAccessEtUnSens 1] foreach UneRegion $LesRegionsRestantes { set Access2 [lindex [lindex $UneRegion 4] 1] set Sens2 [lindex $UneRegion 6] if {$Access2 != $Access || $Sens2 != $Sens} {continue} set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {![info exists TabTmp($D,$F,n) ]} {lappend ToutesLesRegions $UneRegion;continue} set nTot [set TabTmp($D,$F,n) ] set UneRegion [lreplace $UneRegion 2 2 $nTot] if {![info exists TabTmp($Access,$Sens,$D,$F,n)]} {lappend ToutesLesRegions $UneRegion;continue} set n [set TabTmp($Access,$Sens,$D,$F,n)] set UneRegion [lreplace $UneRegion 3 3 $n ] lappend ToutesLesRegions $UneRegion } } return [lsort -integer -index 0 $ToutesLesRegions] } proc LaDefMACSIMSDe {FichierMacsims access} { package require tdom if {![file isfile $FichierMacsims]} {return ""} set fh [open $FichierMacsims "r"] set domDoc [dom parse -channel $fh] close $fh set root [$domDoc documentElement] set def [$root selectNodes "string(//sequence\[seq-name=\"$access\"\]/seq-info/definition)"] $domDoc delete return $def } proc LaDefinitionDeLAcNuc_PageInfo {PageInfo} { set Champs "DEFINITION" set LaDefinition {} set SuisJeSurLaDef 0 foreach Ligne [split $PageInfo "\n"] { if {[regexp "^$Champs" $Ligne]} { regsub "^$Champs" $Ligne "" Ligne set SuisJeSurLaDef 1 lappend LaDefinition [string trim $Ligne] continue } if {!$SuisJeSurLaDef} {continue} if {![regexp {^ } $Ligne]} {set SuisJeSurLaDef 0;break} lappend LaDefinition [string trim $Ligne] } return $LaDefinition } proc LaDefinitionDeLaProt_PageInfo {PageInfo} { set Champs "DE" set LaDefinition {} foreach DE [LeChampsDeLaPageProteine $PageInfo "DE"] { regsub "^DE" $DE "" DE set DE [string trim $DE] lappend LaDefinition $DE } return $LaDefinition } proc LaDefinition_PageInfo {PageInfo} { set LaDef [LaDefinitionDeLAcNuc_PageInfo $PageInfo] if {$LaDef == ""} {set LaDef [LaDefinitionDeLaProt_PageInfo $PageInfo]} return $LaDef } proc LaDescription2_0 {IdOuAccess} { global MemoDE set IdOuAccess [string toupper $IdOuAccess] if {[info exists MemoDE($IdOuAccess)]} {return $MemoDE($IdOuAccess)} set DE [exec getz "\[UNIPROT-id:$IdOuAccess\] | \[UNIPROT-acc:$IdOuAccess\]" -f des] if {$DE eq ""} { set MemoDE($IdOuAccess) "" } else { foreach el [split $DE "\n"] { append MemoDE($IdOuAccess) "[string trim [string range $el 2 end]] " } set MemoDE($IdOuAccess) [RecupereDescriptionRecommandeUniprot [string trim $MemoDE($IdOuAccess)]] } return $MemoDE($IdOuAccess) } proc LaDifferenceDeL1AvecL2 {Liste1 moins Liste2} { ###Rend une liste contenant les elements presents dans L1 mais pas dans L2 ###Si L2 seulement a des elements supplementaires, cette procedure ne rend rien foreach Element $Liste2 {set TabDejaVu($Element) 1} set LaDifference {} foreach Element $Liste1 { if {[info exists TabDejaVu($Element)]} {continue} lappend LaDifference $Element } return $LaDifference } proc LaFamilleElargie {ListeCandidat {Famille famille}} { Wup "Rend la liste complete FamillePoissonPecheurs PAB GDBName pour une liste access-orga" set ListeDesPABs {} foreach Candidat $ListeCandidat { set CandidatAccess [lindex $Candidat 0] set CandidatOrga [lrange $Candidat 1 end] Espionne "\nCandidat $CandidatOrga" Espionne "Access $CandidatAccess" set NomGscope [LesNomsGscopeDeLOrganisme $CandidatOrga] Espionne "Nom Gscope: $NomGscope" foreach nomG $NomGscope { Espionne $nomG if {$nomG == "BsuX"} { continue } if {$nomG == "BiZar"} { continue } if {$nomG == "VchoDemo"} { continue } set BoiteDuGenome [QuestionDeScience $nomG "ret Narcisse $CandidatAccess"] if {$BoiteDuGenome == "" && [regexp -nocase {[a-z]{3}} $CandidatAccess]} { set LeEmbl [LaSequenceDesBanques $CandidatAccess $CandidatAccess accessOk "OnVeutEMBL"] if {$LeEmbl == ""} {continue} scan [lindex $LeEmbl 1] "%s %s" bidon AC set BoiteDuGenome [QuestionDeScience $nomG "ret Narcisse $AC"] } if {$BoiteDuGenome == ""} {continue} Espionne "BoiteDuGenome $BoiteDuGenome" set ListeAccessEnPlus [QuestionDeScience $nomG "ret LesAccessDesOrganismesSample $BoiteDuGenome"] set ListeOrgaEnPlus [QuestionDeScience $nomG "ret LesAccessDesOrganismesSample $BoiteDuGenome LesOrganismesMerci"] Espionne "coucou1 $ListeAccessEnPlus" Espionne "coucou2 $ListeOrgaEnPlus" foreach AC $ListeAccessEnPlus OG $ListeOrgaEnPlus { #Espionne "$AC $OG" set PAB [NarcissePourLOrganisme $AC $OG] if {$PAB == ""} { continue } lappend ListeDesPABs $PAB lappend AdePAB($PAB) $AC set Poisson [Glossaire $OG Court] set FPP "$Famille $Poisson $nomG" if { ! [info exists FPPdePAB($PAB)] || [lsearch [set FPPdePAB($PAB)] $FPP] < 0} { lappend FPPdePAB($PAB) $FPP } } } } set LesFpPPP {} foreach PAB [lsort -unique $ListeDesPABs] { set LesPecs {} foreach FPP [set FPPdePAB($PAB)] { scan $FPP "%s %s %s" Fam Poi Pec lappend LesPecs $Pec } set Liste [concat [list $Fam $Poi] $LesPecs] set FpPPP [join $Liste "_"] lappend LesFpPPP $FpPPP set PABdeFpPPP($FpPPP) $PAB } set Sortie {} foreach FpPPP [lsort $LesFpPPP] { set PAB [set PABdeFpPPP($FpPPP)] set GDBName [file tail [GenomeDu $PAB]] lappend Sortie "$FpPPP $PAB $GDBName" } EspionneL $Sortie return $Sortie } proc LaFigureAutomatique {} { global RepertoireDuGenome global NePasDessinerLesZonesDansLaRosace global ParametresDuBoard Wup "Draws a rosace with org1 and org2 ... the dotplots have to be made before." NousAllonsAuBoulot "$RepertoireDuGenome/figure" set K [DotPlot genomes phor Proches] # RestaureUneDemarcation $K "org1.dp" # set NePasDessinerLesZonesDansLaRosace 1 set R [DemarqueLaRosace $K] # catch {unset NePasDessinerLesZonesDansLaRosace} #perdu set ParametresDuBoard($R,IemeCouche) 1 # set R [RosaceDuDotPlot $K] set K [DotPlot genomes pfur Proches] # RestaureUneDemarcation $K "org2.dp" set ParametresDuBoard($R,IemeCouche) 0 #perdu set R [DemarqueLaRosace $K] set ParametresDuBoard($R,IemeCouche) 2 # set R [RosaceDuDotPlot $K] RosaceDesPIOs "EnPlus" "" {phor pfur tmar bsub} RosaceDesTwoGenesCluster "EnPlus" "" {phor pfur tmar bsub} OnRevientDuBoulot } proc LaFigureAutomatique2002 {} { global RepertoireDuGenome global NePasDessinerLesZonesDansLaRosace global ParametresDuBoard set R [RosaceDesPIOs "EnPlus" "" {phor pfur tmar bsub}] set R [RosaceDesTwoGenesCluster "EnPlus" "" {phor pfur tmar bsub}] RecoloreLesBoites ClassesFonctionnelles $R } proc LaFigureAutomatiqueMsFinal {} { global RepertoireDuGenome global NePasDessinerLesZonesDansLaRosace global ParametresDuBoard DecalageAngulaireRosace # set R [RosaceDesPIOs "EnPlus" "" {mtub mlep}] set R [RosaceDesTwoGenesCluster "EnPlus" "" {mtub mlep}] set R [RosaceDesGCSkew "EnPlus" "" 0.75 0.80] RecoloreLesBoites "NombreDeCopainsDansBlast" $R } proc LaFrequenceDesPetitesRegions {aTabBlast {LesBanquesIdOuLesContigs All} {SeuilId None}} { upvar $aTabBlast TabBlast set TailleFragment 100000 set NbSubjectDansBlast [set TabBlast(NbSubject)] set TailleQuery [set TabBlast(Taille)] set LesBornes {} set LesGrandesRegions {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] if {[regexp {_[0-9]*} $BId]} { regexp -nocase {(HS[0-9XYUN]*):([0-9a-z]*)_([0-9]*)} $BId tmp Chromosome Contig NbFragment } else { regexp -nocase {(HS[0-9XYUN]*):([0-9a-z]*)} $BId tmp Chromosome Contig set NbFragment 0 } if {$LesBanquesIdOuLesContigs != "All"} { set EstCeUnDesId 0 foreach BIdOuContigDeRef $LesBanquesIdOuLesContigs { if {$BId == $BIdOuContigDeRef || $Contig == $BIdOuContigDeRef} { set EstCeUnDesId 1 break } } if {!$EstCeUnDesId} {continue} } if {![info exists NbFragment]} {set NbFragment 0} set NbFragment [Base10 $NbFragment] set NbSegment [set TabBlast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { set Identities [set TabBlast($BId,$j,Identities)] scan $Identities "%d/%d" nmRNA nmRNATot set Id [expr $nmRNA*1.0/$nmRNATot] if {$SeuilId != "None" && $Id < $SeuilId} {continue} set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set DS [expr [set TabBlast($BId,$j,DS)] + $TailleFragment*$NbFragment] set FS [expr [set TabBlast($BId,$j,FS)] + $TailleFragment*$NbFragment] set Sens [SensDeLaRegion [set TabBlast($BId,$j,Orientation)]] set LAlignement [split [set TabBlast($BId,$j,AlignLineaire)] "\n"] set AlignQuery [lindex $LAlignement 0] regsub {^Query:[0-9 ]*} $AlignQuery "" AlignQuery regsub {[0-9 ]*$} $AlignQuery "" AlignQuery set AlignQuery [string trim $AlignQuery] set AlignSubject [lindex $LAlignement 2] regsub {^Sbjct:[0-9 ]*} $AlignSubject "" AlignSubject regsub {[0-9 ]*$} $AlignSubject "" AlignSubject set AlignSubject [string trim $AlignSubject] if {[info exists Region($DQ,$FQ,$DS,$FS)]} {continue} set Region($DQ,$FQ,$DS,$FS) 1 lappend LesGrandesRegions [list "$DQ" "$FQ" "$Chromosome" "$Contig" "$DS" "$FS" "$Sens" "$AlignQuery" "$AlignSubject"] lappend LesBornes [list "$DQ"] set TabBornesDebut($DQ) "OK" lappend LesBornes [list "$FQ"] set TabBornesFin($FQ) "OK" } unset Contig unset NbFragment unset Chromosome } set LesBornes [lsort -integer -increasing -index 0 [ElimineLesRedondancesDansUneListe $LesBornes]] set LesGrandesRegions [lsort -integer -increasing -index 0 [lsort -integer -increasing -index 1 $LesGrandesRegions]] set LesPetitesRegions {} set NbRegions 0 foreach Borne $LesBornes { if {![info exists DebutDeRef]} {set DebutDeRef $Borne} if {$Borne == $DebutDeRef} { if {[info exists TabBornesFin($Borne)]} { set FinDeRef $Borne lappend LesPetitesRegions [list "$DebutDeRef" "$FinDeRef"] set DebutDeRef [expr $Borne + 1] } continue } if {[info exists TabBornesDebut($Borne)] && [info exists TabBornesFin($Borne)]} { set FinDeRef [expr $Borne - 1] incr NbRegions lappend LesPetitesRegions [list "$DebutDeRef" "$FinDeRef"] set DebutDeRef $Borne set FinDeRef $Borne incr NbRegions lappend LesPetitesRegions [list "$DebutDeRef" "$FinDeRef"] set DebutDeRef [expr $Borne +1] } elseif {[info exists TabBornesDebut($Borne)] && ![info exists TabBornesFin($Borne)]} { set FinDeRef [expr $Borne - 1] incr NbRegions lappend LesPetitesRegions [list "$DebutDeRef" "$FinDeRef"] set DebutDeRef $Borne } elseif {![info exists TabBornesDebut($Borne)] && [info exists TabBornesFin($Borne)]} { set FinDeRef $Borne incr NbRegions lappend LesPetitesRegions [list "$DebutDeRef" "$FinDeRef"] set DebutDeRef [expr $Borne + 1] } } set LesRegions $LesPetitesRegions set LesPetitesRegions {} foreach UnePetiteRegion $LesRegions { set DPR [lindex $UnePetiteRegion 0] set FPR [lindex $UnePetiteRegion 1] if {1 < $DPR && ![info exists Frequence]} { set Frequence 0 lappend LesPetitesRegions [list "1" [expr $DPR - 1] "$Frequence" {}] } set Frequence 0 set LesCoordonneesDesSubjects {} foreach UneGrandeRegion $LesGrandesRegions { set DGR [lindex $UneGrandeRegion 0] set FGR [lindex $UneGrandeRegion 1] if {$DGR <= $DPR && $FPR <= $FGR } { incr Frequence set Chromo [lindex $UneGrandeRegion 2] set Contig [lindex $UneGrandeRegion 3] set DS [lindex $UneGrandeRegion 4] set FS [lindex $UneGrandeRegion 5] set Sens [lindex $UneGrandeRegion 6] set AlignQ [lindex $UneGrandeRegion 7] set AlignS [lindex $UneGrandeRegion 8] if {$Sens == "-"} {set i -1} else {set i 1} set PosQ [expr $DGR - 1] set PosS [expr $DS - $i] foreach BaseQ [split $AlignQ ""] BaseS [split $AlignS ""] { if {$BaseQ != "-" && $BaseS != "-"} { incr PosQ incr PosS "$i" } elseif {$BaseQ == "-"} { incr PosS "$i" } elseif {$BaseS == "-"} { incr PosQ } if {$PosQ == $DPR} {set DSSurPR $PosS} if {$PosQ == $FPR} {set FSSurPR $PosS;break} } if {[info exists Subjects($DPR,$FPR,$Chromo,$Contig,$DSSurPR,$FSSurPR,$Sens)]} {continue} set Subjects($DPR,$FPR,$Chromo,$Contig,$DSSurPR,$FSSurPR,$Sens) 1 lappend LesCoordonneesDesSubjects [list "$Chromo" "$Contig" "$DSSurPR" "$FSSurPR" "$Sens"] } } lappend UnePetiteRegion $Frequence lappend UnePetiteRegion $LesCoordonneesDesSubjects lappend LesPetitesRegions $UnePetiteRegion } set FinDeLaDerniereRegion [lindex [lindex $LesPetitesRegions end] 1] if {$FinDeLaDerniereRegion != $TailleQuery} { set Frequence 0 lappend LesPetitesRegions [list [expr $FinDeLaDerniereRegion + 1] "$TailleQuery" "$Frequence" {}] } if {[info exists TabBornesDebut]} {unset TabBornesDebut} if {[info exists TabBornesFin ]} {unset TabBornesFin } return $LesPetitesRegions } proc LaFrequenceDesPetitesRegionsDeLaQueryDuBlast {FichierBlast {ExpectMax 1e200} {NbSubjectMax 1e200} {IdMin 0.0} {SplitWithGap Yes} {LesBanqueId ""}} { set TailleQ [AskBlast $FichierBlast Taille] set LesGrandesRegions [LesGrandesRegionsDeLaQueryDuBlast $FichierBlast $ExpectMax $NbSubjectMax $IdMin $SplitWithGap $LesBanqueId] set LesPetitesRegions [LesPetitesRegionsDesGrandesRegions $LesGrandesRegions ] foreach LaRegion [LesRegionsAbsentesDesPetitesRegions $LesPetitesRegions 1 $TailleQ ] { lappend LesPetitesRegions $LaRegion } set LesFrequencesDesPetitesRegions {} foreach LaPetiteRegion [lsort -index 0 -real $LesPetitesRegions] { set DPR [lindex $LaPetiteRegion 0] set FPR [lindex $LaPetiteRegion 1] set i 0 foreach LaGrandeRegion $LesGrandesRegions { set DGR [lindex $LaGrandeRegion 0] set FGR [lindex $LaGrandeRegion 1] if {[CesRegionsSontEllesOverlappantes $DPR $FPR $DGR $FGR]} {incr i} } lappend LesFrequencesDesPetitesRegions [list $DPR $FPR $i] } return $LesFrequencesDesPetitesRegions } proc LaFtableDansLOrdre {NoeudFtable {Quoi ""}} { if {$Quoi==""} {set Quoi "AllTypes"} set LesFtype {} set LesFitem {} foreach NoeudFitem [$NoeudFtable selectNodes "fitem"] { set Ftype [$NoeudFitem selectNodes "string(ftype)"] lappend LesFtype $Ftype if {$Quoi=="TypeList"} { continue } set Fstart [$NoeudFitem selectNodes "string(fstart)"] set Fstop [$NoeudFitem selectNodes "string(fstop)"] set Fcolor [$NoeudFitem selectNodes "string(fcolor)"] set Fscore [$NoeudFitem selectNodes "string(fscore)"] set Fnote [$NoeudFitem selectNodes "string(fnote)"] if {$Quoi=="$Ftype" || $Quoi=="AllTypes"} { set Fitem [list $Ftype $Fstart $Fstop $Fcolor $Fscore $Fnote] lappend LesFitem $Fitem } } if {$Quoi=="TypeList"} { set LesFtype [lsort -unique $LesFtype] return $LesFtype } set LesFitem [lsort -index 1 -integer $LesFitem] return $LesFitem } proc LaFusionDesRegionsOverlappantes {LesRegions} { set LesRegionsFusionnees {} set FinDeRef "" set DebutDeRef "" foreach LaRegion [lsort -index 0 -real [lsort -index 1 -real $LesRegions]] { set Debut [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set Fin [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] if {$DebutDeRef == ""} { set DebutDeRef $Debut set FinDeRef $Fin continue } #Espionne "$Debut $Fin $DebutDeRef $FinDeRef" if {[CesRegionsSontEllesOverlappantes $Debut $Fin $DebutDeRef $FinDeRef]} {set FinDeRef [Maxi $Fin $FinDeRef];continue} lappend LesRegionsFusionnees [list $DebutDeRef $FinDeRef] set DebutDeRef $Debut set FinDeRef $Fin } if {$DebutDeRef == "" || $FinDeRef == ""} {return $LesRegionsFusionnees} lappend LesRegionsFusionnees [list $DebutDeRef $FinDeRef] return $LesRegionsFusionnees } proc LaLigneAPnOsOc {Nom Candidat} { global RepertoireDuGenome global LesLignesAPnOsOc NomDuAPnOsOcCourant scan $Candidat "%s %s %f" BanqueId Access PN if { ! [info exists NomDuAPnOsOcCourant] || $NomDuAPnOsOcCourant != $Nom } { set FichierAPnOsOc "$RepertoireDuGenome/apnosoc/$Nom" if { ! [file exists $FichierAPnOsOc]} { set LesLignesAPnOsOc {} } set LesLignesAPnOsOc [LesLignesDuFichier $FichierAPnOsOc] set NomDuAPnOsOcCourant $Nom } set Ieme [lsearch -regexp $LesLignesAPnOsOc "$BanqueId $Access"] if { $Ieme < 0 } { return "" } return [lindex $LesLignesAPnOsOc $Ieme] } proc LaListeDesAccessEnPlusObtenusParGO {} { global MesAccessInterressants MesAccessInterressants #Charge la liste des Access du premier projet set Liste [ListeDesPABs] #set Liste [ListeTest] set MesAcc "" foreach PAB $Liste { set AccProt "" set Id "" set AccProt [AccessDeLaBoite $PAB protein] if {$AccProt == $PAB} {continue} lappend MesAcc $AccProt #Espionne "$PAB $AccProt" if {![info exists DejaVu($AccProt)]} {set DejaVu($AccProt) 1} else {continue} set Id [lindex [DefDeAcc $AccProt "protein" "Id"] 1] if {![info exists DejaVu($Id)]} {set DejaVu($Id) 1} else {continue} #Espionne "$PAB $AccProt $Id" if {$AccProt==""} {Espionne "No prot for $PAB $AccProt"} } set NbNew 0 set NbCommune 0 if {1} { set LesAccess [array names MesAccessInterressants] foreach Access $LesAccess { if {![info exists DejaVu($Access)]} { #EnrichiAccessToKeepOrNotToKeep $AccProt Espionne "$Access\t\t[join [lrange [DefDeAcc $Access protein Def] 1 end] " "]" incr NbNew } else { incr NbCommune } } } Espionne "Nombre de PAB [llength $Liste]" Espionne "Nombre de Proteine [llength $MesAcc]" Espionne "Sans les doubles [llength [lsort -unique $MesAcc]]" Espionne "Nombre de genes en commun $NbCommune" Espionne "Nombre de genes en plus $NbNew" #set LesAccess [array names MesAccessInterressants] #EspionneL [lsort $LesAccess] return "" } proc LaListeDesTasks {{Ordre ""}} { set LaListe [list ? 0 "Selected" Sele 1234 "Selected" PCR 123 "PCR" Clon 123 "Cloned" Expr 123 "Expressed" Solu 123 "Soluble" Puri 123 "Purified" ScUp 123 "Scale-up" InCr 2 "In crystallization" Crys 2 "Crystallized" CrDi 2 "Diffraction-quality Crystals" NaDi 2 "Native diffraction-data" PhDi 2 "Phasing diffraction-data" NMRa 3 "NMR Assigned" HSQC 3 "HSQC" 3d 2 "Crystal Structure" NMR 3 "NMR Structure" PDB 2 "In PDB" MoFu 0 "Molecular Function" Biol 0 "Biological Process" Cell 0 "Cellular Component" STOP 4 "Work Stopped" Othe 0 "Other"] if {[regexp "Reverse" $Ordre]} { return [RetourneLaListe $LaListe] } return $LaListe } proc LaListeNomAlias {} { set LaListe {} foreach Nom [ListeDesPABs] { set Alias [Alias $Nom] if {$Alias==""} { set Alias "unknown" } lappend LaListe "$Nom $Alias" } return [join $LaListe "\n"] } proc LaListeRetournee {Liste} { set n [llength $Liste] if {$n == 0} {return {}} set LaListeRetournee {} for {set i [expr $n - 1]} {$i >=0} {incr i -1} { lappend LaListeRetournee [lindex $Liste $i] } return $LaListeRetournee } proc LaListeSplittee {ListeIni NbElementsParListe} { set LesListes {} set Liste $ListeIni while {0 < [llength $Liste]} { set LengthListe [llength $Liste] if {$NbElementsParListe < $LengthListe} { lappend LesListes [lrange $Liste 0 [expr $NbElementsParListe - 1]] set Liste [lrange $Liste $NbElementsParListe end ] } else { lappend LesListes [lrange $Liste 0 [expr $LengthListe - 1]] set Liste {} } } return $LesListes } proc LaListeToBeOrthologue {{PlusMinusOrgas ""}} { global ToBeOrthologue if {$PlusMinusOrgas==""} { FaireLire "Please give a list of organisms with + and - (ie. +paby -mjan -phor +hsp)" set PlusMinusOrgas [Entre] if {$PlusMinusOrgas==""} { return {} } } set Texte $PlusMinusOrgas regsub -all " " $Texte "" Texte if { ! [regexp {^(\+|\-)} $Texte]} { set Texte "+$Texte" } regsub -all {\+|\-} $Texte " &" Texte regsub "^ " $Texte "" Texte set LesVoulus {} set LesExclus {} foreach PMOrga [split $Texte " "] { regsub {^(\+|\-)} $PMOrga "" Orga if {[regexp {\+} $PMOrga]} { lappend LesVoulus $Orga } if {[regexp {\-} $PMOrga]} { lappend LesExclus $Orga } } set LesCommeIlFaut {} foreach Nom [ListeDesPABs] { set ToBeOrthologue($Nom) 0 set Presents [ORGAorgaDesMSFs $Nom "Presents"] set IlEnManqueUn 0 foreach Orga $LesVoulus { if { ! [regexp -nocase $Orga $Presents]} { set IlEnManqueUn 1 ; break } } if {$IlEnManqueUn} { continue } set YAUnExclu 0 foreach Orga $LesExclus { if {[regexp -nocase $Orga $Presents]} { set YAUnExclu 1 ; break } } if {$YAUnExclu} { continue } set ToBeOrthologue($Nom) 1 lappend LesCommeIlFaut $Nom } set ToBeOrthologue($PlusMinusOrgas) 1 return $LesCommeIlFaut } proc LaManierePourAffiche {TypeDeFichier} { set PourNotes 0 set PourNuc 0 set PourProt 0 set PourBlast 0 set PourMSF 0 set Rep [file tail [file dirname $TypeDeFichier]] if {[regexp -nocase {^notes} $Rep]} { set PourNotes 1 } if {[regexp -nocase {^(copain|tfa)} $Rep]} { set PourNuc 1 } if {[regexp -nocase {nuctfa|nucembl} $Rep]} { set PourNuc 1 } if {[regexp -nocase {prottfa|protembl} $Rep]} { set PourProt 1 } if {[regexp -nocase {(TBlast|Blast|Ballast)} $Rep]} { set PourBlast 1 } if {[regexp -nocase {(MSF|Clustal|DbClustal)} $Rep]} { set PourMSF 1 } set LesAvecs {} if {$PourNuc} { lappend LesAvecs "AvecBlaste" "AvecFormate"} if {$PourProt} { lappend LesAvecs "AvecBlaste" "AvecFormate"} if {$PourBlast} { lappend LesAvecs "AvecAligneurs" "AvecSegAlignements" } if {$PourMSF} { lappend LesAvecs "AvecEtudeMSF" "GrandeLargeur"} if {[OnTraiteDesClones]} { if {$PourNotes} { lappend LesAvecs "AvecOli" lappend LesAvecs "AvecShowItsOligos" } } set LesAvecs [lsort -unique $LesAvecs] return [join $LesAvecs ""] } proc LaMeilleureProteineDuMeilleurContig {Nom {ExpectMax 0.001} {var 0.05} {Extension 10000} {IdMin 0.8}} { set IdDeRef [expr (1 - $var)] set FBlast "[RepertoireDuGenome]/blastngenembl/$Nom" if {![file exists $FBlast]} {return [list $Nom "NoBlastFound"]} set Rep "[RepertoireDuGenome]/contig" if {![file exists $Rep]} {file mkdir $Rep} set FichierTFA "$Rep/$Nom" set FichierTFAMasked "$Rep/$Nom.m" set FichierTFATmp "[TmpFile $Nom].tfa" set FichierBlastX "$Rep/$Nom.blastx" set OrgaDeRef [OrganismeDuPAB $Nom] Espionne "$Nom -> Contig extraction" set NbSubject [AskBlast $FBlast NbSubject] if {$NbSubject == ""} {return [list $Nom "NoContigFound"]} set LesContigsBruts [lsort -decreasing -index 8 -integer [LesContigsDuBlast $FBlast $ExpectMax]] if {$LesContigsBruts == {}} {return [list $Nom "NoContigFound"]} foreach LeContig $LesContigsBruts { set BId [lindex $LeContig 0] set Orga [lindex $LeContig 12] if {$Orga != $OrgaDeRef} {continue} set PIdContig [lindex $LeContig 7] if {$PIdContig < $IdDeRef } {continue} set Access [lindex $LeContig 1] set Taille [lindex $LeContig 2] set Expect [lindex $LeContig 5] set Score [lindex $LeContig 6] set NbContig [lindex $LeContig 8] Espionne "$Nom -> Best Contig $BId $Access $Orga $PIdContig $NbContig" set D [Mini [AskBlast $FBlast BanqueId $BId Segment 1 DS] [AskBlast $FBlast BanqueId $BId Segment 1 FS]] set F [Maxi [AskBlast $FBlast BanqueId $BId Segment 1 DS] [AskBlast $FBlast BanqueId $BId Segment 1 FS]] set ExtensionMin $Extension set ExtensionMax $Extension set BorneMin [expr $D - $ExtensionMin] set BorneMax [expr $F + $ExtensionMax] if {$Taille < $BorneMax} {set BorneMax $Taille;set ExtensionMax [expr $BorneMax - $F ]} if {$BorneMin < 1 } {set BorneMin 1 ;set ExtensionMin [expr $D - $BorneMin]} set D [expr $BorneMin + $ExtensionMin] set F [expr $BorneMax - $ExtensionMax] set DNew $ExtensionMin set FNew [expr $BorneMax - $BorneMin + 1 - $ExtensionMax] set Seq [SequenceDeLAccess $BId htg] set TailleSeq [string length $Seq] if {$Taille != $TailleSeq} { Espionne "$BId length change $Taille -> $TailleSeq" continue } set Seq [string range $Seq [expr $BorneMin - 1] [expr $BorneMax - 1]] if {$Seq == ""} {continue} set Entete "$Nom contig $BId $Taille from $BorneMin to $BorneMax Query from $D to $F" set SeqTFA [SequenceFormatTFA $Seq $Entete "brut"] Sauve $SeqTFA dans $FichierTFA Sauve $SeqTFA dans $FichierTFATmp set OptionSpecies [OptionsSpeciesAutomatique $Orga] if {$OptionSpecies != "None"} { Espionne "$Nom -> contig $BId is masking with Repeatmasker with the option $OptionSpecies" set SeqTFA [MasqueLesRepeatsDuFichier $FichierTFA $OptionSpecies] Sauve $SeqTFA dans $FichierTFAMasked set FichierTFA $FichierTFAMasked } Espionne "$Nom -> $FichierTFA against protein database" PipeBlast $FichierTFA protein $FichierBlastX X 500 $ExpectMax T 4 Espionne "$Nom -> Blast OK" set LesProteines [LesProteinesLesPlusProchesDeLaRegionDuContig $FichierTFAMasked $FichierBlastX $DNew $FNew $IdMin $ExpectMax] if {$LesProteines == {}} { return [list $Nom "Contig" $BId $Access $Taille $Orga $Expect $PIdContig $NbContig "NoProteinFound"] } set LesBIdProt {} foreach LaProteine [lsort -real -increasing -index 3 $LesProteines] {lappend LesBIdProt [lindex $LaProteine 0]} AskLesPagesInfos load $LesBIdProt protein if {[info exists LaProteineDeRef]} {unset LaProteineDeRef} if {[info exists DistanceMin] } {unset DistanceMin} set NbDeRef 0 foreach LaProteine [lsort -real -increasing -index 3 $LesProteines] { set BIdProt [lindex $LaProteine 0] if {[AskLesPagesInfos ask $BIdProt] == ""} {continue} set Def [PageInfo $BIdProt protein des] if {[regexp -nocase "Fragment" $Def]} {continue} set Distance [lindex $LaProteine 3] if {![info exists DistanceMin]} {set DistanceMin [expr $Distance * (1 + $var)]} if {$DistanceMin < $Distance} {break} set Nb [lindex $LaProteine 7] if {$NbDeRef < $Nb} { set LaProteineDeRef $LaProteine set NbDeRef $Nb } } if {![info exists LaProteineDeRef]} {break} set BIdProt [lindex $LaProteineDeRef 0] set AccessProt [lindex $LaProteineDeRef 1] set TailleProt [lindex $LaProteineDeRef 2] set Distance [lindex $LaProteineDeRef 3] set ExpectProt [lindex $LaProteineDeRef 4] set ScoreProt [lindex $LaProteineDeRef 5] set PIdProt [lindex $LaProteineDeRef 6] set NbProt [lindex $LaProteineDeRef 7] set PageInfo [AskLesPagesInfos ask $BIdProt] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set OrgaDeProt [lindex $LesOrgas 0] set EstCeUnDesOrga 0 foreach O $LesOrgas {if {[string equal -nocase $O $Orga]} {set EstCeUnDesOrga 1}} if {$EstCeUnDesOrga} {set OrgaDeProt $Orga} Espionne "$Nom -> Best Protein found $BIdProt $AccessProt $OrgaDeProt $PIdProt $NbProt" AskLesPagesInfos unset return [list $Nom "Contig" $BId $Access $Taille $Orga $Expect $PIdContig $NbContig "Protein" $BIdProt $AccessProt $TailleProt $OrgaDeProt $Distance $ExpectProt $ScoreProt $PIdProt $NbProt] } return [list $Nom "NoContigFound"] } proc LaNouvellesListeDesPABsDuDD {} { #fiches/ListeDesSansProtSansJumeaux set Fichier623 "/genomics/link/HeadNecknonrnr/fiches/ListeDesSansProtSansJumeaux" foreach Ligne [LesLignesDuFichier $Fichier623] { set Nom [lindex $Ligne 0] set Vu($Nom) 1 lappend ListeDesPABs $Nom } set Fichier555 "/genomics/link/HeadNecknonrnr/Jumeaux/Les555DDAvecProtSansDb" foreach Ligne [LesLignesDuFichier $Fichier555] { set DD [lindex $Ligne 0] if {[info exists Vu($DD)]} {Espionne "$DD doublon";continue} lappend ListeDesPABs $DD } Espionne [llength $ListeDesPABs] SauveLesLignes $ListeDesPABs dans "/genomics/link/HeadNecknonrnr/fiches/ListeDesPABs" } proc LaProteineADesVariants {Access {Quoi Etat}} { Wup "Permet de savoir si Access a des variants et le nombre" Wup "Attention il faut compter plus 1 car lui n esr pas avec dans varsplic" global TabVariant if {[info exists TabVariant($Access,$Quoi)]} { return "[set TabVariant($Access,$Quoi)]" } else { if {[info exists TabVariant]} {unset TabVariant} } set Banques "protein" set Link "varsplic" set Type [list "acc" "id"] set OnARien 0 foreach Typ $Type { set Commande "getz -vf des \"\\\[$Banques-$Typ: $Access\\\] > $Link \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$OnARien==0 && $GetzOut == ""} { set OnARien 0 continue } else { set OnARien 1 set NbVariant "[llength [split $GetzOut "\n"]]" set TabVariant($Access,NbVariant) $NbVariant break } } if {$OnARien =="1"} { set TabVariant($Access,Etat) 1 return 1 } else { set TabVariant($Access,Etat) 0 return 0 } } proc LaSelectionDeChunhuaPourProcure {Rep Fichier} { #les 19 clones selectionnes par C[GscopeDatabase hunhua sont dans le gscope Strasbg. #FichierFoldExpression "[GscopeDatabaseDir HeadNeck3]/fiches/FoldExpression" #FichierBilanMasking "[GscopeDatabaseDir HeadNeck3]/fiches/BilanMasking" #FichierKegg "[GscopeDatabaseDir HeadNeck3]/fiches/Kegg" #FichierGeneName "[GscopeDatabaseDir HeadNeck3]/fiches/GeneName" #FichierDomaines "[GscopeDatabaseDir HeadNeck3]/fiches/Domaines" #FichierBestProt "[GscopeDatabaseDir HeadNeck3]/fiches/BestProteinAndmRNAForeachOrga" #FichierHydrophobicity "[GscopeDatabaseDir /HeadNeck3/fiches/hydrophobicity" foreach JR [split [ContenuDuFichier "[GscopeDatabaseDir HeadNeck3]/procure/les19jrdechunhua"] " "] { Espionne $JR set FichierACreer "[RepertoireDuGenome]/fiches/$Fichier" if {![file exists $FichierACreer]} { foreach Ligne [LesLignesDuFichier "$Rep/fiches/$Fichier"] { set PAB [lindex $Ligne 0] if {$PAB!=$JR} {continue} if {$PAB==$JR} {lappend LeContenu $Ligne} } } } SauveLesLignes $LeContenu dans $FichierACreer return $LeContenu } proc LaSelectionDeNoe {{ReInit 0} {Save Save}} { global RepertoireDuGenome set FichierSelectionDeNoe "$RepertoireDuGenome/fiches/SelectionDeNoe" set ReInitialise [expr [string equal $ReInit "1"] || [string equal -nocase $ReInit "ReInitialise"]] if {$ReInitialise || ![file exists $FichierSelectionDeNoe]} { FaireLire "Please, choose the organisms you are specially interested in." set LaListeDesOrganismes [list "Homo sapiens" "Mus musculus" "Rattus norvegicus" "Drosophila melanogaster"] set LesOrganismes [ChoixDesPresents $LaListeDesOrganismes "" "Select organisms"] while {[OuiOuNon "Would you want to add an other organism to that list ?"]} { set NouvelOrganisme [Entre] set BonOrg [Glossaire $NouvelOrganisme Complet] if {$BonOrg==""} { if {![OuiOuNon "The organism $NouvelOrganisme doesn't exist\nDo you want to select it?"]} { continue } } elseif {$BonOrg!=$NouvelOrganisme} { if {[OuiOuNon "Your organism $NouvelOrganisme \n seems to be \n $BonOrg \n Do I keep $BonOrg ?"]} { set NouvelOrganisme $BonOrg } else { if {![OuiOuNon "Do I keep $NouvelOrganisme?"]} { continue } } } if {$NouvelOrganisme != "" } { lappend LesOrganismes $NouvelOrganisme } } if {$Save == "Save"} { Sauve [join $LesOrganismes "\n"] dans $FichierSelectionDeNoe } return $LesOrganismes } else { return [LesLignesDuFichier $FichierSelectionDeNoe] } } proc LaSelectionDesBestGO {LesGO {PMin 0.80} {FMin 0.5} {NbGOParType ""}} { set LesGO [LesGODeRefDesGO $LesGO] #Determine les effectifs de chaque GO dans un tableau indexe par le nom du GO foreach GO $LesGO { if {![info exists TabGO($GO)]} {set TabGO($GO) 0} incr TabGO($GO) } #Distingue chaque embranchement de l'arbre ontologique et calcul les effectifs de chacun des noeuds de ces embranchements set LesEmbranchementsEtLeurEffectif {} foreach GO [ElimineLesRedondancesDansUneListe $LesGO] { foreach Type [GODB GO $GO LesTypes] { #Espionne "$GO\t$Type\t[set TabGO($GO)]" if {$Type == ""} {continue} if {![info exists TabGO($Type,Lesn)]} {set TabGO($Type,Lesn) {}} foreach LEmbranchement [LesEmbranchementsGO $Type $GO] { set n 0 set LEmbranchementEtLeursEffectifs {} foreach GODeLEmbranchement $LEmbranchement { if {[info exists TabGO($GODeLEmbranchement)]} {incr n [set TabGO($GODeLEmbranchement)]} lappend LEmbranchementEtLeursEffectifs [list $Type $GODeLEmbranchement $n] } lappend TabGO($Type,Lesn) $n lappend LesEmbranchementsEtLeurEffectif $LEmbranchementEtLeursEffectifs } } } #Elimination des embranchements avec effectif trop faible (Seuil FMin * EffectifDeTousLesEmbranchements Max) et des noeuds rares (Seuil PMin * EffectifMaxDeLEmbranchement) set LesGO {} foreach LEmbranchementEtLeursEffectifs $LesEmbranchementsEtLeurEffectif { set Type [lindex [lindex $LEmbranchementEtLeursEffectifs 0 ] 0] set nMax [lindex [lindex $LEmbranchementEtLeursEffectifs end] 2] set Max [lindex [lsort -integer [set TabGO($Type,Lesn)]] end] set nMin1 [expr $Max * $FMin ] set nMin2 [expr $nMax * $PMin ] foreach LeGOEtSonEffectif $LEmbranchementEtLeursEffectifs { set Type [lindex $LeGOEtSonEffectif 0] set GO [lindex $LeGOEtSonEffectif 1] set n [lindex $LeGOEtSonEffectif 2] if {$n < $nMin1 || $n < $nMin2} {continue} set Tab($GO) $n lappend LesGO $GO break } } set LesGO [EnterrerLesAncetresGO [ElimineLesRedondancesDansUneListe $LesGO]] if {$NbGOParType == ""} { if {[info exists TabGO]} {unset TabGO} return $LesGO } set LesGO2 {} foreach GO $LesGO {set n [set TabGO($GO)];lappend LesGO2 [list $GO $n]} set LesGO {} foreach LeGO [lsort -decreasing -index 1 -integer $LesGO2] { set GO [lindex $LeGO 0] foreach Type [GODB GO $GO LesTypes] { if {![info exists TabGO($Type,n)]} {set TabGO($Type,n) 0} incr TabGO($Type,n) if {$NbGOParType < [set TabGO($Type,n)]} {continue} lappend LesGO $GO } } if {[info exists TabGO]} {unset TabGO} return $LesGO } proc LaSelectionDesEST {Nom FichierTFA FichierBlastEST {AllOrgaouJustMyOrga AllOrga} {ID 0.98} {TailleAliMin 50}} { if {![file exists $FichierTFA] || ![file exists $FichierBlastEST]} {return} AskBlast unset set FichierBlastEST [BlastDesMeilleursESTDuBlast $FichierBlastEST $FichierTFA "" $ID $TailleAliMin] set LesId [LesBanqueIdDuBlast $FichierBlastEST 1e200 1e200] set OrgaDeRef [OrganismeDuPAB $Nom] AskLesPagesInfos load $LesId est set LeTexte {} foreach Id $LesId { set Page [AskLesPagesInfos ask $Id] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] if {$AllOrgaouJustMyOrga != "AllOrga"} { set EstCeUnDesOrga 0 foreach Orga $LesOrgas { if {[string equal -nocase $Orga $OrgaDeRef]} {set EstCeUnDesOrga 1;break} } if {!$EstCeUnDesOrga} {continue} } foreach Orga $LesOrgas {lappend LeTexte "$Nom\t$Id\tOrganism\t$Orga" } foreach Tissue [LesTissuesDeLAcNuc_PageInfo $Page] {lappend LeTexte "$Nom\t$Id\tTissueType\t$Tissue"} foreach DevStage [LesDevStageDeLAcNuc_PageInfo $Page] {lappend LeTexte "$Nom\t$Id\tDevStage\t$DevStage"} } AskBlast unset AskLesPagesInfos unset return $LeTexte } proc LaSelectionDesESTPourTous {RepTFA RepBlast FichierPop FichierOut} { set L [CreeListePourFichierAUneColonne $FichierPop] foreach Nom $L { Espionne $Nom set FichierTFA "$RepTFA/$Nom" set FichierBlastEST "$RepBlast/$Nom" if {![file exists $FichierTFA]} {continue} if {![file exists $FichierBlastEST]} {continue} lappend LaSelection [LaSelectionDesEST $Nom $FichierTFA $FichierBlastEST] } set LaSelection [join $LaSelection " "] SauveLesLignes $LaSelection dans $FichierOut } proc LaSelectionDesMeilleursGO {LesGO {P 0.80} {FractionDuMax 0.33} {NbGOParType ""}} { foreach GO $LesGO { if {![info exists TabGO($GO)]} {set TabGO($GO) 0} incr TabGO($GO) } set LesEmbranchementsEtLeurEffectif {} foreach GO [ElimineLesRedondancesDansUneListe $LesGO] { set GO [string toupper $GO] set Type [Onto $GO Type] if {$Type == ""} {continue} if {![info exists TabGO($Type,Lesn)]} {set TabGO($Type,Lesn) {}} foreach LEmbranchement [LesEmbranchementsOntologiques $Type $GO] { set n 0 set LEmbranchementEtLeursEffectifs {} foreach GODeLEmbranchement $LEmbranchement { if {[info exists TabGO($GODeLEmbranchement)]} {incr n [set TabGO($GODeLEmbranchement)]} lappend LEmbranchementEtLeursEffectifs [list $Type $GODeLEmbranchement $n] } lappend TabGO($Type,Lesn) $n lappend LesEmbranchementsEtLeurEffectif $LEmbranchementEtLeursEffectifs } } set LesGO {} foreach LEmbranchementEtLeursEffectifs $LesEmbranchementsEtLeurEffectif { set Type [lindex [lindex $LEmbranchementEtLeursEffectifs 0 ] 0] set nMax [lindex [lindex $LEmbranchementEtLeursEffectifs end] 2] set Max [lindex [lsort -integer [set TabGO($Type,Lesn)]] end] set nMin1 [expr $Max * $FractionDuMax ] set nMin2 [expr $nMax * $P ] #Espionne "$Type $Max $nMin1 $nMin2" #Espionne $LEmbranchementEtLeursEffectifs foreach LeGOEtSonEffectif $LEmbranchementEtLeursEffectifs { set Type [lindex $LeGOEtSonEffectif 0] set GO [lindex $LeGOEtSonEffectif 1] set n [lindex $LeGOEtSonEffectif 2] if {$n < $nMin1 || $n < $nMin2} {continue} set Tab($GO) $n lappend LesGO $GO break } } set LesGO [EnterrerLesAncetresOntologiques [ElimineLesRedondancesDansUneListe $LesGO]] if {$NbGOParType == ""} { if {[info exists TabGO]} {unset TabGO} return $LesGO } set LesGO2 {} foreach GO $LesGO {set n [set TabGO($GO)];lappend LesGO2 [list $GO $n]} set LesGO {} foreach LeGO [lsort -decreasing -index 1 -integer $LesGO2] { set GO [lindex $LeGO 0] set Type [Onto $GO Type] if {![info exists TabGO($Type,n)]} {set TabGO($Type,n) 0} incr TabGO($Type,n) if {$NbGOParType < [set TabGO($Type,n)]} {continue} lappend LesGO $GO } if {[info exists TabGO]} {unset TabGO} return $LesGO } proc LaSelectionDesSegmentsDuBlast {FichierBlast {EnFonctionDe Expect} {SeuilOuValeurs 0.001}} { Wup "EnFonctionDe -> LesBIdToKeep , LesBIdToEliminate , LesSegmentsDesBIdToKeep, LesAccessToKeep , LesAccessToEliminate , LesOrgaToKeep , LesOrgaToEliminate , LesmRNAsToKeep, LesmRNAsToEliminate, Expect , Score , SensToKeep, SensToEliminate , Identity, IdentityWithoutFilter, Positives, PositivesWithoutFilter, NbPositivesSurTailleQuery, NbPositivesSurTailleQueryWithoutFilter, TailleAlignementMin, TailleAlignementMax , LesRegionsToEliminate (Elimination des segments possedant ces regions), LesRegionsToKeep (Segments possedant les regions a conserver), NbSubjectMax, NbAliMax, JusteLePremierAlignementDesSubjects,RegionsAligneesSurRegionsAlignables, RegionsAligneesSurRegionsDansAlignement, RegionsAligneesSurRegionsDansAlignementSubject, RegionsAligneesSurTailleQuery, RegionsAligneesSurTailleSubject, RegionsAligneesSurTailleQueryDansLeMeilleurDesSens, RegionsAligneesSurTailleSubjectDansLeMeilleurDesSens" set LesSegmentsAConserver {} set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Mask "X" if {[string equal -nocase "BLASTN" $TypeDeBlast]} {set Mask "N"} set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject] if {$NbSubjectDansBlast == "" || $NbSubjectDansBlast < 1} {return} set TailleQuery [AskBlast $FichierBlast Taille ] if {$EnFonctionDe == "LesSegmentsDesBIdToKeep"} { foreach LeBId $SeuilOuValeurs { set BId [lindex $LeBId 0] set LesSegments [lrange $LeBId 1 end] lappend LesSegmentsAConserver [list $BId $LesSegments] } return $LesSegmentsAConserver } if {$EnFonctionDe == "LesmRNAsToKeep"} { set LesBId {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {lappend LesBId [AskBlast $FichierBlast Subject $i]} foreach BId [LesmRNAsDesAcNucs $LesBId] { set LesSegments {} set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} {lappend LesSegments $j} Espionne $BId lappend LesSegmentsAConserver [list $BId $LesSegments] } return $LesSegmentsAConserver } if {$EnFonctionDe == "LesmRNAsToEliminate"} { set LesBId {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {lappend LesBId [AskBlast $FichierBlast Subject $i]} foreach BId [LesNonmRNAsDesAcNucs $LesBId] { set LesSegments {} set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} {lappend LesSegments $j} Espionne $BId lappend LesSegmentsAConserver [list $BId $LesSegments] } return $LesSegmentsAConserver } set k 0 set l 0 for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { incr k if {$EnFonctionDe == "NbSubjectMax" && $SeuilOuValeurs < $k} {break} set BId [AskBlast $FichierBlast Subject $i] set LesSegments {} set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} {lappend LesSegments $j} if {$EnFonctionDe == "LesBIdToEliminate"} { set LAiJeVu 0 set BIdCourt $BId regsub -nocase {^[^\:]+\:} $BId "" BIdCourt foreach BIdDeRef $SeuilOuValeurs { regsub {^[^\:]+\:} $BIdDeRef "" BIdDeRef if {[string equal -nocase $BIdDeRef $BIdCourt]} {set LAiJeVu 1;break} } if {!$LAiJeVu} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } if {$EnFonctionDe == "LesBIdToKeep"} { set LAiJeVu 0 set BIdCourt $BId regsub -nocase {^[^\:]+\:} $BId "" BIdCourt foreach BIdDeRef $SeuilOuValeurs { regsub {^[^\:]+\:} $BIdDeRef "" BIdDeRef if {[string equal -nocase $BIdDeRef $BIdCourt]} {set LAiJeVu 1;break} } if {$LAiJeVu} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } set Access [AskBlast $FichierBlast BanqueId $BId Access] if {$EnFonctionDe == "LesAccessToEliminate"} { set LAiJeVu 0 foreach AccDeRef $SeuilOuValeurs { if {[string equal -nocase $AccDeRef $Access]} {set LAiJeVu 1;break} } if {!$LAiJeVu} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } if {$EnFonctionDe == "LesAccessToKeep"} { set LAiJeVu 0 foreach AccDeRef $SeuilOuValeurs { #Espionne $Access if {[string equal -nocase $AccDeRef $Access]} {set LAiJeVu 1;break} } if {$LAiJeVu} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } if {$EnFonctionDe == "LesOrgaToEliminate"} { set EnAiJeVuUn 0 foreach Orga [LesOrgasDeLAccess $BId] { if {[regexp -nocase $Orga [join $SeuilOuValeurs "\t"]]} {set EnAiJeVuUn 1;break} } if {!$EnAiJeVuUn} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } if {$EnFonctionDe == "LesOrgaToKeep"} { set EnAiJeVuUn 0 foreach Orga [LesOrgasDeLAccess $BId] { #Espionne "$BId\t$Orga\t[join $SeuilOuValeurs "\t"]" if {[regexp -nocase $Orga [join $SeuilOuValeurs "\t"]]} {set EnAiJeVuUn 1;break} } if {$EnAiJeVuUn} {lappend LesSegmentsAConserver [list $BId $LesSegments]} continue } if {0 && $EnFonctionDe == "LesmRNAsToKeep"} { set PageInfo [PageInfo $BId genbank] if {[EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} { #Espionne $BId lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {0 && $EnFonctionDe == "LesmRNAsToEliminate"} { set PageInfo [PageInfo $BId genbank] if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} { #Espionne $BId lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurRegionsAlignables"} { set P [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables $FichierBlast $BId] if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurRegionsAlignables $SeuilOuValeurs $P" lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurRegionsDansAlignement"} { set P [PourcentageDIdentiteGlobal $FichierBlast $BId "Query"] if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurRegionsDansAlignement $SeuilOuValeurs $P" lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurRegionsDansAlignement_Subject"} { set P [PourcentageDIdentiteGlobal $FichierBlast $BId "Subject"] if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurRegionsDansAlignement_Subject $SeuilOuValeurs $P" lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurTailleQuery"} { set P [PourcentageDeRecouvrement $FichierBlast $BId "Query"] if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurTailleQuery $SeuilOuValeurs $P" lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurTailleSubject"} { set P [PourcentageDeRecouvrement $FichierBlast $BId "Subject"] if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurTailleSubject $SeuilOuValeurs $P" lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurTailleQueryDansLeMeilleurDesSens"} { set nSPlus [NombreDeBasesEnCommun $FichierBlast $BId "Query" "+"] set nSMoins [NombreDeBasesEnCommun $FichierBlast $BId "Query" "-"] if {$nSPlus < $nSMoins} { set P [expr $nSMoins * 1.0 / $TailleQuery] set SensSelect "-" } else { set SensSelect "+" set P [expr $nSPlus * 1.0 / $TailleQuery] } if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurTailleQuery $SeuilOuValeurs $P" set LesSegments {} for {set j 1} {$j <= $NbSegment} {incr j} { set Orient [AskBlast $FichierBlast BanqueId $BId Segment $j Orientation] if {[SensDeLaRegion $Orient] == $SensSelect} {lappend LesSegments $j} } lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } if {$EnFonctionDe == "RegionsAligneesSurTailleSubjectDansLeMeilleurDesSens"} { set nSPlus [NombreDeBasesEnCommun $FichierBlast $BId "Subject" "+"] set nSMoins [NombreDeBasesEnCommun $FichierBlast $BId "Subject" "-"] if {$nSPlus < $nSMoins} { set P [expr $nSMoins * 1.0 / [AskBlast $FichierBlast BanqueId $BId Taille]] set SensSelect "-" } else { set SensSelect "+" set P [expr $nSPlus * 1.0 / [AskBlast $FichierBlast BanqueId $BId Taille]] } if {$SeuilOuValeurs < $P} { #Espionne "$BId RegionsAligneesSurTailleSubjectDansLeMeilleurDesSens $SeuilOuValeurs $P" set LesSegments {} for {set j 1} {$j <= $NbSegment} {incr j} { set Orient [AskBlast $FichierBlast BanqueId $BId Segment $j Orientation] if {[SensDeLaRegion $Orient] == $SensSelect} {lappend LesSegments $j} } lappend LesSegmentsAConserver [list $BId $LesSegments] } continue } set LesSegments {} for {set j 1} {$j <= $NbSegment} {incr j} { if {$EnFonctionDe == "JusteLePremierAlignementDesSubjects"} { if {$j == 1} { #Espionne "$BId JusteLePremierAlignementDesSubjects segment $j" lappend LesSegments $j break } continue } incr l if {$EnFonctionDe == "NbAliMax" && $SeuilOuValeurs < $l} {break} if {$EnFonctionDe == "Expect"} { if {[AskBlast $FichierBlast BanqueId $BId Segment $j Expect] <= $SeuilOuValeurs} {lappend LesSegments $j} continue } if {$EnFonctionDe == "Score"} { if {[AskBlast $FichierBlast BanqueId $BId Segment $j Score] <= $SeuilOuValeurs} {lappend LesSegments $j} continue } if {$EnFonctionDe == "SensToKeep"} { if {[AskBlast $FichierBlast BanqueId $BId Segment $j Orientation] == $SeuilOuValeurs} {lappend LesSegments $j} continue } if {$EnFonctionDe == "SensToEliminate"} { if {[AskBlast $FichierBlast BanqueId $BId Segment $j Orientation] != $SeuilOuValeurs} {lappend LesSegments $j} continue } if {$EnFonctionDe == "Identity"} { set Identities [AskBlast $FichierBlast BanqueId $BId Segment $j Identities] scan $Identities "%d/%d" n nTot set Id [expr $n*1.0/$nTot] #Espionne "$BId\t$Id\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Id} {lappend LesSegments $j} continue } if {$EnFonctionDe == "IdentityWithoutFilter"} { set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BId Segment $j] set Identities [AskBlast $FichierBlast BanqueId $BId Segment $j Identities] scan $Identities "%d/%d" n nTot set Id [expr $n*1.0/($nTot- $NbBasesFiltrees)] #Espionne "$BId\t$Id\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Id} {lappend LesSegments $j} continue } if {$EnFonctionDe == "Positives"} { set Positives [AskBlast $FichierBlast BanqueId $BId Segment $j Positives] scan $Positives "%d/%d" n nTot set Pos [expr $n*1.0/$nTot] #Espionne "$BId\t$Pos\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Pos} {lappend LesSegments $j} continue } if {$EnFonctionDe == "PositivesWithoutFilter"} { set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BId Segment $j] set Positives [AskBlast $FichierBlast BanqueId $BId Segment $j Positives] scan $Positives "%d/%d" n nTot set Pos [expr $n*1.0/($nTot- $NbBasesFiltrees)] #Espionne "$BId\t$Pos\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Pos} {lappend LesSegments $j} continue } if {$EnFonctionDe == "NbPositivesSurTailleQueryWithoutFilter"} { set Positives [AskBlast $FichierBlast BanqueId $BId Segment $j Positives] set NbBasesFiltrees [NombreDeBasesFiltrees $FichierBlast $BId Segment $j] scan $Positives "%d" n set Pos [expr $n * 1.0 / ($TailleQuery - $NbBasesFiltrees)] #Espionne "$BId\t$Pos\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Pos} {lappend LesSegments $j} continue } if {$EnFonctionDe == "NbPositivesSurTailleQuery"} { set Positives [AskBlast $FichierBlast BanqueId $BId Segment $j Positives] scan $Positives "%d" n set Pos [expr $n * 1.0 / $TailleQuery] #Espionne "$BId\t$Pos\t$SeuilOuValeurs" if {$SeuilOuValeurs <= $Pos} {lappend LesSegments $j} continue } set DQ [Mini [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] set FQ [Maxi [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] if {$EnFonctionDe == "TailleAlignementMin"} { set TailleAli [expr $FQ-$DQ+1] if {$SeuilOuValeurs <= $TailleAli } { #Espionne "$BId segment $j TailleAli $TailleAli $SeuilOuValeurs" lappend LesSegments $j } continue } if {$EnFonctionDe == "TailleAlignementMax"} { set TailleAli [expr $FQ-$DQ+1] if {$TailleAli <= $SeuilOuValeurs} {lappend LesSegments $j} continue } if {$EnFonctionDe == "LesRegionsToKeep"} { set EnAiJeUne 0 foreach LaRegion $SeuilOuValeurs { set Debut [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set Fin [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] #Espionne "$DQ $FQ $Debut $Fin" if {[CesRegionsSontEllesOverlappantes $DQ $FQ $Debut $Fin]} { set EnAiJeUne 1 break } } if {$EnAiJeUne} {lappend LesSegments $j} continue } if {$EnFonctionDe == "LesRegionsToEliminate"} { set EnAiJeUne 0 foreach LaRegion $SeuilOuValeurs { set Debut [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set Fin [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] #Espionne "$DQ $FQ $Debut $Fin" if {[CesRegionsSontEllesOverlappantes $DQ $FQ $Debut $Fin]} { set EnAiJeUne 1 break } } if {!$EnAiJeUne} {lappend LesSegments $j} continue } lappend LesSegments $j } if {$LesSegments != {}} {lappend LesSegmentsAConserver [list $BId $LesSegments]} } return $LesSegmentsAConserver } proc LaSequenceColoree {Texte {Maniere ""} {Ftable ""} {AvecZones ""}} { set LesLettres {} set LesClasses {} if {$AvecZones==""} { set AvecZones 0 } if {$Maniere==""} { set Maniere "Seqlab" } if {$Maniere=="Normal"} { return $Texte } if {$Maniere=="Seqlab"} { foreach AA [split $Texte ""] { lappend LesLettres $AA if {$AA==" "} { set AA "Space" } if {$AA=="."} { set AA "Dot" } if {$AA=="-"} { set AA "Hyphen" } if {$AA=="~"} { set AA "Tilde" } lappend LesClasses $AA } } if {$Maniere=="Ftype"} { set ItemVide "-1 -1 -1 -1 -1 -1" PositionAutreDe Absolue 1 $Texte set Fin 0 foreach Item $Ftable { incr Fin ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote set AbsPos [regexp "^AbsolutePosition " $Fnote] if {$AbsPos} { set AvantProchain [expr $Fstart-1] set Alpha $Fstart set Omega $Fstop } else { set AvantProchain [expr [PositionAutreDe Relative $Fstart]-1] set Alpha [PositionAutreDe Relative $Fstart] set Omega [PositionAutreDe Relative $Fstop] } foreach I [NombresEntre $Fin $AvantProchain] { set ItemEnPosition($I) $ItemVide } foreach I [NombresEntre $Alpha $Omega] { set ItemEnPosition($I) $Item } set Fin $Omega } incr Fin set Max [string length $Texte] if {$Fin<=$Max} { foreach I [NombresEntre $Fin $Max] { set ItemEnPosition($I) $ItemVide } } set IGap 0 set Mot "" if {[info exists OldClasse]} { unset OldClasse } if {[info exists OldColScoNot]} { unset OldColScoNot } regsub -all -nocase {[^A-Z]} $Texte "" VraieSeq foreach AA [split $Texte ""] { incr IGap set Item $ItemEnPosition($IGap) ScanLaListe $Item Ftype Fstart Fstop Fcolor Fscore Fnote set ColScoNot "$Fcolor $Fscore $Fnote" set SS "$Fstart-$Fstop" if {$Fstart==$Fstop} { set SS $Fstart } if {[regexp "^AbsolutePosition" $Fnote]} { append SS " (absolute position)" } if {$Fscore!=""} { append SS " $Fscore" } regsub "^AbsolutePosition " $Fnote "" BelleFnote set TexteBulle "$Ftype $SS $BelleFnote" if {$Fcolor=="-1"} { set Classe "C999" } else { set Classe "C$Fcolor" } if {[info exists OldColScoNot] && $ColScoNot!=$OldColScoNot} { if {$OldItem==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle } if {$AvecZones} { set L [string length $Mot] set Mot "" lappend LesLettres $Mot } else { lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"] } lappend LesClasses $OldClasse set Mot $AA set OldColScoNot $ColScoNot set OldClasse $Classe set OldItem $Item set OldTexteBulle $TexteBulle set OldFnote $Fnote continue } set OldColScoNot $ColScoNot set OldClasse $Classe set OldItem $Item set OldTexteBulle $TexteBulle set OldFnote $Fnote append Mot $AA } if {$Mot!=""} { if {$Item==$ItemVide} { set Bulle "No feature" } else { set Bulle $OldTexteBulle } if {$AvecZones} { set L [string length $Mot] set Mot "" lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"] } else { lappend LesLettres [H_Href $Mot "" "title='$Bulle' alt='$Bulle' name='$Bulle'"] } lappend LesClasses $Classe } } return [H_ColoredLetters $LesLettres $LesClasses] } proc LaSequenceConvertieSiOnVeut {LaSequence OnVeutEMBL Access} { if { ! $OnVeutEMBL } { return $LaSequence } set Format [FormatDeLaSequence_l $LaSequence] if {$Format == "embl"} { return $LaSequence } else { return [split [SequenceFormatEMBL_l $LaSequence $Access $Format] "\n"] } } proc LaSequenceDesBanques {BanqueId {Access ""} {aAccessOK ""} {OnVeutEMBL ""} {NouveauPABCourant ""}} { LogWscope "dans LaSequenceDesBanques $BanqueId" if {$OnVeutEMBL=="" && [regexp "^OnVeut" $Access]} { set OnVeutEMBL $Access set Access "" } if {$aAccessOK!=""} { upvar $aAccessOK AccessOK } global RepertoireDuGenome global LesLignesEMBLEnMemoire global AccessOKEnMemoire global ConfigChargee global QuidSeqEstDisponible global PABCourant global EviteSPTNEW set BanqueIdOriginal $BanqueId if {[regexp "\|" $BanqueId]} { regsub -nocase {^(sp|sw|lcl)\|} $BanqueId "" BanqueId } if {[regexp "\|" $BanqueId]} { lassign [split $BanqueId "|"] B A set BanqueId $B if {$Access=="" || $Access==$BanqueIdOriginal} { set Access $A } } if {[regexp "Sc306" [RepertoireDuGenome]]} { if {[regexp {^(Sc|Eh|At|Hs)[0-9]+$} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir YEAH]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } if {[regexp {^(PF)[^ ]*} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir Pfalciparum]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } if {[regexp {^(TB)[^ ]*} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir Tbrucei]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } } if {[regexp "YEAH|Tparva" [RepertoireDuGenome]]} { if {[regexp {^(Sc|Eh|At|Hs)[0-9]+$} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir YEAH]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } if {[regexp {^(PF)[^ ]*} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir Pfalciparum]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } if {[regexp {^(TB)[^ ]*} $BanqueId Match]} { set RepProt "[GscopeDatabaseDir Tbrucei]/prottfa" set FichierTFA "$RepProt/$Match" if {[file exists $FichierTFA]} { set AccessOK $Match return [LesLignesDuFichier $FichierTFA] } } } if {[regexp {^ref\|([^\|]+)} $BanqueId Match X]} { regsub {\.[0-9]*} $X "" X set BanqueId "refseq:$X" set Access "" } if {$BanqueId==""} { set BanqueId $Access} if {$Access==""} { set Access $BanqueId } if {$BanqueId=="" && $Access==""} { set AccessOK "" ; return {} } if {[regexp "^OnVeut" $Access]} { set OnVeutEMBL $Access set Access $BanqueId } set OnVeutGenBank [string equal -nocase $OnVeutEMBL "OnVeutGenBank"] set Force 1 set Previens 0 set OnExigeNature 0 if {[string equal -nocase $OnVeutEMBL "OnVeutNature"]} { set OnExigeNature 1 set OnVeutEMBL "" } if {[regexp -nocase "^EST" $BanqueId] && [string equal -nocase $OnVeutEMBL "OnVeutEMBL"]} { set OnVeutEMBL "OnVeutNucEMBL" } set OnExigeNuc 0 if {[string equal -nocase $OnVeutEMBL "OnVeutNucEMBL"]} { set OnVeutEMBL "OnVeutEMBL" set OnExigeNuc 1 } if {[string equal -nocase $OnVeutEMBL "OnVeutEMBL"]} { set OnVeutEMBL 1 } else { set OnVeutEMBL 0 } while {[regexp {^SCB\:} $BanqueId]} { set FichierTFAsSCB "/genomics/link/Riboalvi/banques/SCB" if {[FileAbsent $FichierTFAsSCB]} { break } set TFA [LaSequenceDuTFAs $FichierTFAsSCB $BanqueId] set AccessOK $BanqueId if { ! $OnVeutEMBL} { return [split $TFA "\n"] } set EMBL [SequenceFormatEMBL $TFA "" "tfa"] return [split $EMBL "\n"] } while {[regexp {^BSDProtAll\:} $BanqueId]} { set FichierTFAsBSD "/genomics/link/BSD/prottfa/$Access" if {[FileAbsent $FichierTFAsBSD]} { break } set TFA [LaSequenceDuTFAs $FichierTFAsBSD $Access] set AccessOK $BanqueId if { ! $OnVeutEMBL} { return [split $TFA "\n"] } set EMBL [SequenceFormatEMBL $TFA "" "tfa"] return [split $EMBL "\n"] } while {[regexp {^(ALVE|ALBO|ALGI)[0-9]+$} $BanqueId]} { set FichierTFAsAlvinella "/genomics/link/Riboalvi/banques/protAlvinella.tfa" if {[FileAbsent $FichierTFAsAlvinella]} { break } set TFA [LaSequenceDuTFAs $FichierTFAsAlvinella $BanqueId] set AccessOK $BanqueId if { ! $OnVeutEMBL} { return [split $TFA "\n"] } set LesOSOCOX {} lappend LesOSOCOX "OS Alvinella pompejana." lappend LesOSOCOX "OC Eukaryota; Metazoa; Annelida; Polychaeta; Palpata; Canalipalpata;" lappend LesOSOCOX "OC Terebellida; Alvinellidae; Alvinella." lappend LesOSOCOX "OX NCBI_TaxID=6376;" set OSOCOX [join $LesOSOCOX "\n"] set EMBL [SequenceFormatEMBL $TFA "" "tfa"] regsub "\nDE " $EMBL "\n$OSOCOX\nDE Hypothetical protein " EMBL return [split $EMBL "\n"] } #rR On devrait traiter tout REFSEQ avec ceci (y a pas NZ voir lbgiki) if {0 && [EstUnRefseq $Access]} { regsub -nocase {^REFSEQ.?\:} $Access "" Acc set R [BirdWeb "REFSEQ" $Acc] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"] } return [split [GenBankToEMBL $R] "\n"] } } #rR sinon on fait comme dans le temps if {0 && [regexp -nocase {^REFSEQ.*\:} $BanqueId]} { regsub -nocase {^REFSEQ.*\:} $BanqueId "" A set R [BirdWeb REFSEQ $A] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"] } return [split [GenBankToEMBL $R] "\n"] } } if {0 && [regexp -nocase {^(REFSEQ\:)?(NP|XP)_[0-9]+$} $Access]} { regsub -nocase {^REFSEQ\:} $Access "" Acc set R [BirdWeb "REFSEQP" $Acc] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"] } return [split [GenBankToEMBL $R] "\n"] } set R [Getz $Acc "refseqP" -view FastaSeqs] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"] } set iSecondChevron [string first ">" $R 2] if {$iSecondChevron>-1} { set R [string range $R 0 [incr iSecondChevron -1]] } set R [SequenceFormatEMBL $R "" "tfa" "No" "No"] return [split $R "\n"] } } if {0 && [regexp -nocase {^(REFSEQ\:)?(NM|XM)_[0-9]+$} $Access]} { regsub -nocase {^REFSEQ\:} $Access "" Acc set R [BirdWeb "REFSEQ" $Acc] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"]} return [split [GenBankToEMBL $R] "\n"] } set R [Getz $Acc "refseq" -view FastaSeqs] if {$R!=""} { set AccessOk $Acc if {$OnVeutGenBank} { return [split $R "\n"] } set iSecondChevron [string first ">" $R 2] if {$iSecondChevron>-1} { set R [string range $R 0 [incr iSecondChevron -1]] } set R [SequenceFormatEMBL $R "" "tfa" "No" "No"] return [split $R "\n"] } } if {[regexp -nocase {^HS[0-9unxy]+\:} $BanqueId BanqueHS]} { regsub {\:} $BanqueHS "" BanqueHS set BanqueHS [string tolower $BanqueHS] if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d $BanqueHS -s $BanqueId 2> /dev/null]} Message]} { return "" } if {$OnVeutEMBL} { return [split [SequenceFormatEMBL $TfaDeLaBanqueBlast "" "tfa"] "\n"] } return [split $TfaDeLaBanqueBlast "\n"] } if {[regexp -nocase {^UniRef[0-9]+} $BanqueId Match]} { if {[regexp -nocase {^UniRef[0-9]+_([A-Z][A-Z0-9]+)} $BanqueId M Acc]} { set AOk $BanqueId set R [LaSequenceDesBanques "protein:$Acc" $Acc AOkBidon $OnVeutEMBL $NouveauPABCourant] if {$R!=""} { set AccessOK $AOk return $R } } set Banque [string tolower $Match] if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s $BanqueId 2> /dev/null]} Message]} { set AccessOK "" return "" } if {[regexp {^>lcl\|} $TfaDeLaBanqueBlast]} { regsub {^>lcl\|} $TfaDeLaBanqueBlast ">" TfaDeLaBanqueBlast } set AccessOK $BanqueId if { ! $OnVeutEMBL} { return [split $TfaDeLaBanqueBlast "\n"]} set SeqDesBanques [SequenceFormatEMBL $TfaDeLaBanqueBlast $Access "tfa"] return [split $SeqDesBanques "\n"] } if {[regexp -nocase {Msmegmatis\:|MsAllProt\:} $BanqueId]} { set NomMs [StringApres ":" dans $BanqueId] set FicMs "[GscopeDatabaseDir Ms]/protembl/$NomMs" if {[file exists $FicMs]} { set AccessOK $BanqueId return [LesLignesDuFichier $FicMs] } set FicMs "[GscopeDatabaseDir Ms]/prottfa/$NomMs" if {[file exists $FicMs]} { set AccessOK $BanqueId set NomLu [StringApres ":" dans $$BanqueId] return [SequenceFormatEMBL [ContenuDuFichier $FicMs] $NomLu "tfa"] } } if {[regexp -nocase "VARSPLIC\:" $BanqueId]} { regsub -nocase "VARSPLIC" $BanqueId "PROT" ProtId regsub -nocase "VARSPLIC\:" $BanqueId "" AccessOK if {[regexp {_[0-9]+$} $ProtId]} { regsub {_[0-9]+$} $ProtId "" ProtId } if {[regexp {\-[0-9]+$} $ProtId]} { regsub {\-[0-9]+$} $ProtId "" ProtId } set LesLignesEMBL [LaSequenceDesBanques $ProtId] if {$LesLignesEMBL==""} { set AccessOK "" ; return "" } set SeqTFA [TfaDeLaBanqueBlast "/catalog/blast/varsplic" $BanqueId] if {$SeqTFA==""} { if {[regexp {_[0-9]+$} $BanqueId]} { regsub "_" $BanqueId "-" BanqueId } set SeqTFA [TfaDeLaBanqueBlast "/catalog/blast/varsplic" $BanqueId] if {$SeqTFA==""} { set AccessOK "" ; return "" } } set Seq [QueLaSequenceDuTexteTFA $SeqTFA] regsub "VARSPLIC\:" $BanqueId "" Id set LeNouveau {} foreach Ligne $LesLignesEMBL { if {[regexp "^ID " $Ligne]} { set Ligne "ID $Id VARSPLIC created by Gscope-varsplic.tcl from $ProtId" append Ligne "\nAC $Id;" } if {[regexp "SQ " $Ligne ]} { break } lappend LeNouveau $Ligne } lappend LeNouveau [QueSequenceFormatEMBL $Seq AvecSQ] set AccessOK $BanqueId return $LeNouveau } regsub -nocase "^RSHUM\:" $BanqueId "RSHUMAN:" BanqueId if {[regexp "RSHUMAN\:" $BanqueId]} { set Access "" } if { ! [info exists EviteSPTNEW]} { set EviteSPTNEW 1 } if {[EstUnAccessPDB $BanqueId] || $Access=="mol:protein"} { set Access $BanqueId } if { ! [regexp {\:} $BanqueId] && [regexp -nocase {(SPT|SW)[_\|]} $BanqueId]} { regsub {[_\|]} $BanqueId ":" NewBanqueId if {$BanqueId==$Access} { set Access $NewBanqueId } set BanqueId $NewBanqueId } if {$BanqueId==$Access && [regexp ":" $Access] && ! [regexp -nocase "RSHUMAN\:" $Access]} { regsub -nocase {[a-z0-9_]+\:} $Access "" Access } if {$NouveauPABCourant!=""} { set PABCourant $NouveauPABCourant } Wup "Fetch the sequence. In EMBL format if OnVeutEMBL." Wup "BanqueId or Access ? First I try Access then BanqueId" Wup "Maybe I stored before in memory ..." if {[info exists LesLignesEMBLEnMemoire($BanqueId,$Access)]} { set LesLignesEMBL [set LesLignesEMBLEnMemoire($BanqueId,$Access)] set AccessOK [set AccessOKEnMemoire($BanqueId,$Access)] return $LesLignesEMBL } if {[regexp {^ci[0-9]{10}$} $Access]} { return [LesLignesDuFichier "/genomics/link/Ciona/protembl/[CioNarcisse $Access]"] } if {[regexp {^(ensembl|gp|pironly|remtrembl|worm)\:[a-zA-Z_0-9]+$} $BanqueId]} { set TFA [LaSequenceDuTFAs "/genomics/link/petitPDBscope/banques/nrdb_specific.tfa" $BanqueId] if {$TFA==""} { return {} } if {$OnVeutEMBL} { return [split [SequenceFormatEMBL $TFA "" "tfa"] "\n"] } return $TFA } set LaSequence {} Wup "It's a file" if {[regexp "/" $BanqueId]} { if {[file exists $BanqueId]} { if {[file isdirectory $BanqueId]} { set AccessOK "" return [lsort [glob -nocomplain "$BanqueId/*"]] } set LaSequence [LesLignesDuFichier $BanqueId] # Warne "fichier $BanqueId" set AccessOK [file tail $BanqueId] set NomDuFichier [file tail $BanqueId] set GCG [join $LaSequence "\n"] if {[regexp "^LOCUS" $GCG]} { if { ! [regexp {[^\n]* [0-9]+ aa } $GCG]} { set AccessOK $Access if {$OnExigeNature} { return [split $GCG "\n"] } set FichierGB "[RepertoireDeTravail]/$NomDuFichier.gbtags" Sauve $GCG dans $FichierGB set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"] File delete -force $FichierGB return $LesLignesEMBL } else { set AccessOK $Access if {$OnExigeNature} { return [split $GCG "\n"] } set FichierGB "[RepertoireDeTravail]/$NomDuFichier.gbk" Sauve $GCG dans $FichierGB set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqProt $FichierGB] "prot"] "\n"] File delete -force $FichierGB return $LesLignesEMBL } } return [LaSequenceConvertieSiOnVeut $LaSequence $OnVeutEMBL $NomDuFichier] } if { $Previens } { FaireLire "$BanqueId not found in databases." } return {} } if {[OnTraiteUneCollection] && [info exists PABCourant]} { set Copain "$RepertoireDuGenome/coembl/$PABCourant/$Access" if {[file exists $Copain]} { set AccessOK $Access set LesLignesEMBL [LesLignesDuFichier $Copain] return $LesLignesEMBL } if {[file exists "$RepertoireDuGenome/genscanpredictions/$PABCourant"]} { set Texte [ContenuDuFichier "$RepertoireDuGenome/genscanpredictions/$PABCourant"] if {[regexp "^>$Access " $Texte]} { return [split [SequenceFormatEMBL $Texte "" "tfa"] "\n"] } } } foreach SousRep {"Spine/Sequences"} { if {[file exists "$RepertoireDuGenome/$SousRep/$Access"]} { set AccessOK $Access set Texte [ContenuDuFichier "$RepertoireDuGenome/$SousRep/$Access"] set LesLignesEMBL [split [SequenceFormatEMBL $Texte] "\n"] return $LesLignesEMBL } } if {[EstUnPAB $BanqueId]} { if {[file exists "$RepertoireDuGenome/protembl/$BanqueId"]} { set AccessOK $BanqueId set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/protembl/$BanqueId"] return $LesLignesEMBL } if {[file exists "$RepertoireDuGenome/nucembl/$BanqueId"]} { set AccessOK $BanqueId set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/nucembl/$BanqueId"] return $LesLignesEMBL } } if {[EstUnPAB $Access]} { if {[file exists "$RepertoireDuGenome/protembl/$Access"]} { set AccessOK $Access set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/protembl/$Access"] return $LesLignesEMBL } if {[file exists "$RepertoireDuGenome/nucembl/$Access"]} { set AccessOK $Access set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/nucembl/$Access"] return $LesLignesEMBL } } if {[EstUnPAB $BanqueId]} { if {[file exists "$RepertoireDuGenome/prottfa/$BanqueId"]} { set AccessOK $BanqueId set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/prottfa/$BanqueId"] "\n"] return $LesLignesEMBL } if {[file exists "$RepertoireDuGenome/nuctfa/$BanqueId"]} { set AccessOK $BanqueId set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/nuctfa/$BanqueId"] "\n"] return $LesLignesEMBL } } if {[EstUnPAB $Access]} { if {[file exists "$RepertoireDuGenome/prottfa/$Access"]} { set AccessOK $Access set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/prottfa/$Access"] "\n"] return $LesLignesEMBL } if {[file exists "$RepertoireDuGenome/nuctfa/$Access"]} { set AccessOK $Access set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/nuctfa/$Access"] "\n"] return $LesLignesEMBL } } Wup "I search in seqpath" if {[file exists "$RepertoireDuGenome/seqpath"]} { foreach Ext {".pep" ".embl" ".tfa" ""} { set Liste [glob -nocomplain "$RepertoireDuGenome/seqpath/*/$Access$Ext"] foreach Fichier $Liste { set LaSequence [LesLignesDuFichier $Fichier] if {[llength $LaSequence] == 0} { continue } set AccessOK $Access return [LaSequenceConvertieSiOnVeut $LaSequence $OnVeutEMBL $Access] } } } if {[regexp "^EVImmProt\:" $BanqueId]} { set NomDuEVI [lindex [split $BanqueId ":"] 1] set FichierEVI "[GscopeDatabaseDir EVImm]/protembl/$NomDuEVI" if { ! [file exists $FichierEVI]} { if {$Force} { return {} } FaireLire "$FichierEVI not found." return {} } set LesLignesEMBL [LesLignesDuFichier $FichierEVI] set AccessOK $NomDuEVI return $LesLignesEMBL } if {[regexp "^AffyHS\:" $BanqueId]} { set NomDuAffy [lindex [split $BanqueId ":"] 1] set FichierAffy "/genomics/link/AffyHS/nucembl/$NomDuAffy" if { ! [file exists $FichierAffy]} { if {$Force} { return {} } FaireLire "$FichierAffy not found." return {} } set LesLignesEMBL [LesLignesDuFichier $FichierAffy] set AccessOK $NomDuAffy return $LesLignesEMBL } if {0 && [regexp "^PABY\:" $BanqueId]} { set NomDuPABY [lindex [split $BanqueId ":"] 1] set FichierPABY "[GscopeDatabaseDir Pabyssi]/protembl/$NomDuPABY" if { ! [file exists $FichierPABY]} { if {$Force} { return {} } FaireLire "$FichierPABY not found." return {} } set LesLignesEMBL [LesLignesDuFichier $FichierPABY] set AccessOK $NomDuPABY return $LesLignesEMBL } if {[regexp -nocase "^ClonV:" $BanqueId]} { set NomDuVec [lindex [split $BanqueId ":"] 1] set FichierVec "$RepertoireDuGenome/vecteurs/$NomDuVec" if { ! [file exists $FichierVec]} { if {$Force} { return {} } FaireLire "$FichierVec not found" return {} } set LesLignesEMBL [LesLignesDuFichier $FichierVec] set AccessOK $NomDuVec return $LesLignesEMBL } if {0 && [regexp -nocase "^PFUR:" $BanqueId]} { set NomDuPFUR [lindex [split $BanqueId ":"] 1] set FichierPFUR "[GscopeDatabaseDir Pfuriosus]/protembl/$NomDuPFUR" if { ! [file exists $FichierPFUR]} { if {$Force} { return {} } FaireLire "$FichierPFUR not found" return {} } set LesLignesEMBL [LesLignesDuFichier $FichierPFUR] set AccessOK $NomDuPFUR return $LesLignesEMBL } if {[regexp -nocase {^AFF[0-9]{5}$} $Access]} { set NomDuAffymetrix $Access set FichierAffymetrix "[GscopeDatabaseDir AffyHS]/nucembl/$NomDuAffymetrix" if { ! [file exists $FichierAffymetrix]} { if {$Force} { return {} } FaireLire "$FichierAffymetrix not found" return {} } set LesLignesEMBL [LesLignesDuFichier $FichierAffymetrix] set AccessOK $NomDuAffymetrix return $LesLignesEMBL } if {[EstUnAccessPDB $BanqueId]} { set AccessOK $BanqueId if {$OnExigeNature} { set LeNature [split [TextePDB $BanqueId] "\n"] ; #rR attention il faudrait mettre All pour avoir aussi les COORD return $LeNature } set LesLignesEMBL [split [EMBLduPDB $BanqueId] "\n"] return $LesLignesEMBL } if {[QuidSeqEstDisponible]} { set EMBL [QuestionDeScience QuidSeq "QuidRefSeqOfAC $Access"] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access # Warne "QuidSeq $Access" return $LesLignesEMBL } } if {[OutsideCSTB]} { set LaReponse [WgetzSurWeb $BanqueId] if {$LaReponse!={} && ! [regexp -nocase "^ERREUR" $LaReponse]} { return $LaReponse } if {[SembleEtreUnAccessVarsplic $BanqueId]} { return [LaSequenceDesBanques "VARSPLIC:$BanqueId"] } return {} } LogWscope "Avant GeneQuid UniprotData $Access" #rR GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid set EMBL [GeneQuid UniprotData $Access] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access # Warne "GeneQuid UniprotData $Access" return $LesLignesEMBL } set EMBL [GeneQuid UniprotData $BanqueId] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $BanqueId # Warne "GeneQuid UniprotData $BanqueId" return $LesLignesEMBL } #rR GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid #rR rajouté le 2014/07/09 if {[UseBirdForUniprot]} { #Espionne "I use UseBirdForUniprot to search $Access" if {[regexp {\|} $Access]} { foreach Mot [split $Access "|"] { set EMBL [BirdWeb "uniprot" $Mot] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access Espionne "Bird uniprot $Access" return $LesLignesEMBL } } } set EMBL [BirdWeb "uniprot" $Access] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access Espionne "I got the info using BirdWeb uniprot $Access" return $LesLignesEMBL } } else { #rR on prendra FromOrthoInspector ou FromYannis voir ci-dessous } set EMBL [Getz $Access] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access Warne "getz $Access" return $LesLignesEMBL } set EMBL [Getz $BanqueId] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access # Warne "getz $Access" return $LesLignesEMBL } if {[set Alternatif [AccessAlternatif $Access]]!=""} { set EMBL [Getz $Alternatif] if {[regexp "^ID " $EMBL]} { set LesLignesEMBL [split $EMBL "\n"] set AccessOK $Access # Warne "getz $Access alternatif $Alternatif" return $LesLignesEMBL } } if {[SembleEtreUnAccessVarsplic $BanqueId]} { set LesLignesEMBL [LaSequenceDesBanques "VARSPLIC:$BanqueId"] if {$LesLignesEMBL!={}} { return $LesLignesEMBL } } set GB "" if {0 && $GB==""} { set GB [BirdWeb "gbrl" $Access] } if {0 && $GB==""} { set GB [Getz $Access "GenbankFull"] } if {$GB!="" && [regexp "\nACCESSION" $GB]} { set AccessOK $Access if {$OnExigeNature} { return [split $GB "\n"] } set FichierGB "[RepertoireDeTravail]/$Access.genbank" Sauve $GB dans $FichierGB if {$OnExigeNuc} { set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"] } else { set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierGB]] "\n"] } # File delete -force $FichierGB return $LesLignesEMBL } if {0 && $GB==""} { set GB [Getz $Access "est sts gss htg htc"] } if {$GB!="" && [regexp "\nACCESSION " $GB]} { set OnExigeNuc 1 set AccessOK $Access if {$OnExigeNature} { return [split $GB "\n"] } set FichierGB "[RepertoireDeTravail]/$Access.gbtags" Sauve $GB dans $FichierGB if {$OnExigeNuc} { set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"] } else { set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierGB]] "\n"] } File delete -force $FichierGB return $LesLignesEMBL } if {[info exists EviteSPTNEW] && $EviteSPTNEW && [regexp -nocase "^SPTNEW" $BanqueId]} { Warne "$BanqueId $Access not found. I don't search in SPTNEW with GCG" if { 0 && $Previens } { FaireLire "$BanqueId $Access not found. I don't search in SPTNEW with GCG. I ignore it." } return {} } Wup "On ne l'a donc jamais vu ... On essaye GCG." global TryGCG if { ! [info exists TryGCG]} { set TryGCG 0 } if {$OnExigeNature || $TryGCG} { set AccessGCG $BanqueId set GCG [FetchCat $AccessGCG] if {$GCG == ""} { set AccessGCG $Access set GCG [FetchCat $AccessGCG] } if {$GCG != ""} { set GCG [QueLePremierGCG $GCG] if {[regexp "^!!NA_SEQUENCE" $GCG] && [regexp "\nACCESSION " $GCG]} { set AccessOK $Access if {$OnExigeNature} { return [split $GCG "\n"] } set FichierGB "[RepertoireDeTravail]/$Access.gbtags" Sauve $GCG dans $FichierGB set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"] File delete -force $FichierGB return $LesLignesEMBL } if {[regexp "^!!AA_SEQUENCE" $GCG] && [regexp "\nACCESSION " $GCG]} { set AccessOK $Access if {$OnExigeNature} { return [split $GCG "\n"] } set FichierGB "[RepertoireDeTravail]/$Access.gbk" Sauve $GCG dans $FichierGB set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqProt $FichierGB] "prot"] "\n"] File delete -force $FichierGB return $LesLignesEMBL } set AccessOK $AccessGCG set LesLignesGCG [split $GCG "\n"] if { $OnExigeNature} { return $LesLignesGCG } if { ! $OnVeutEMBL } { return $LesLignesGCG } set iSQ [lsearch -regexp $LesLignesGCG "^SQ"] set Entete [lrange $LesLignesGCG 0 $iSQ] set Suite [lrange $LesLignesGCG $iSQ end] set iPP [lsearch -regexp $Suite {\.\.}] set iFin [lsearch -regexp $Suite "^ID"] if {[incr iFin -1] < 0} { set iFin "end" } set Sequence [join [lrange $Suite [incr iPP] $iFin] ""] regsub -all {[ 0-9]} $Sequence "" Sequence set LaSeqEMBL [split [QueSequenceFormatEMBL $Sequence "SansSQ"] "\n"] set LesLignesEMBL [concat $Entete $LaSeqEMBL "\n//"] return $LesLignesEMBL } } if {[OnTraite "CilioCarta"]} { set TFA [QuestionDeScience EVImm "ret FromYannis $BanqueId TFA"] if {$TFA!=""} { set AccessOK $BanqueId if {$OnVeutEMBL} { return [split [SequenceFormatEMBL $TFA $Access tfa] "\n"] } return [split $TFA "\n"] } } Warne "$BanqueId $Access not found." if { $Previens } { FaireLire "$BanqueId introuvable. Je l'ignore." } return {} } proc LaSequenceDesLignesEMBL {LesEMBL} { Wup "Return the sequence of the EMBL text" set OK 0 set Sequence "" foreach Ligne $LesEMBL { if {[regexp "^SQ" $Ligne]} { set OK 1 continue } if {$OK} { regsub -all -nocase {[^A-Z]} $Ligne "" BoutDeSeq append Sequence $BoutDeSeq } } return $Sequence } proc LaSequenceDuFichierEMBL {Fichier} { return [LaSequenceDesLignesEMBL [LesLignesDuFichier $Fichier]] } proc LaSequenceDuTFAs {FichierTFAs AccessDemande {DontMemorize ""} {CarRedon ""} {ForceAccessFirst ""} {AllowDigitOnly ""}} { global LesSequencesDuTFAs if {$DontMemorize=="DontMemorize"} { set DontMemorize 1 } else { set DontMemorize 0 } if {$CarRedon==""} { set CarRedon "_" } if {[string equal -nocase $AllowDigitOnly "AllowDigitOnly"]} { set AllowDigitOnly 1 } else { set PrefixIfDigitOnly $AllowDigitOnly if {$PrefixIfDigitOnly==""} { set PrefixIfDigitOnly "n" } set AllowDigitOnly 0 } set ForceAccessFirst [string equal -nocase $ForceAccessFirst "ForceAccessFirst"] regsub "\:" $AccessDemande "_" AccessDemande Wup "Loads the sequence corresponding to Access from a multiple tfa file (can be a blast database)" Wup "Not sure that it works well if wrong '>b:id access'" if {[info exists LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]} { return [set LesSequencesDuTFAs($FichierTFAs,$AccessDemande)] } if {[info exists LesSequencesDuTFAs($FichierTFAs)]} { return "" } set nIeme 1 set Trouve 0 set I 0 #rR attention dans le temps je considerais le BanqueId comme etant du style SPT:ABCDEF #rR Maintenant c'est plutot du style SYNT_HUMAN ... #rR Du coup dans ce qui suit, ou on s'attend soit a trouver >SYNTH_HUMAN Q12345 soit >Q12345 #rR dans le premier cas on vuet avoir les deux ... #rR et pour les PDB c'est on a en general >PDB:1y18_F et pas d'access #rR pour je ne sais plus quelle raison j'ai remplace les : par _ foreach Ligne [LesLignesDuFichier $FichierTFAs] { if { ! [regexp -nocase {[\-\.\*a-z0-9_>]} $Ligne]} { continue } if { [regexp {^#} $Ligne]} { continue } if {[regexp "^>" $Ligne]} { incr I if {$DontMemorize && $Trouve} { break } regsub {^> *} $Ligne "" Ligne set AccessLu "" scan $Ligne "%s %s" BanqueId AccessLu set Meme 0 if {$ForceAccessFirst || [regexp -nocase {^PDB\:} $BanqueId] || [regexp "|" $BanqueId]} { set AccessLu $BanqueId set Meme 1 } else { # if { ! [regexp -nocase {[a-z0-9_]+\:[a-z0-9_]+} $BanqueId] } { Espionne coucou; set AccessLu $BanqueId } } regsub {\:} $BanqueId "_" Banque_Id regsub {\:} $AccessLu "_" Access_Lu if { ! [regexp -nocase {[a-z0-9]} $AccessLu]} { set Access_Lu $Banque_Id } ;#rR 2014/01/07 car il n'y a plus de Access set Access $Access_Lu #rR ATTENTION on rajoute PrefixIfDigitOnly si y a que des chiffres car y avait clustal (?) qui se plante ! if { ! $AllowDigitOnly && ! [regexp -nocase {[a-z_]} $Access_Lu]} { set Access "$PrefixIfDigitOnly$Access_Lu" } set AccessTmp $Access set nIeme 1 while {[info exists DejaVu($Access)]} { set Access "$AccessTmp$CarRedon[incr nIeme]" } if {$Meme} { set BanqueId $Access } set DejaVu($Access) 1 if {$DontMemorize && $Access!=$Access_Lu} { continue } if {$Access!=$Access_Lu && ! [regexp -nocase {[^a-z\:_0-9]} $Access_Lu]} { regsub "$Access_Lu" $Ligne $Access Ligne } set LesSequencesDuTFAs($FichierTFAs,$Access) ">$Ligne" if {$Banque_Id!=$Access && ! [info exists LesSequencesDuTFAs($FichierTFAs,$Banque_Id)]} { set LesSequencesDuTFAs($FichierTFAs,$Banque_Id) ">$Ligne" } lappend LesSequencesDuTFAs($FichierTFAs,LaListeDesAccess) $Access continue } if {$DontMemorize && $Access!=$Access_Lu} { continue } set Trouve 1 append LesSequencesDuTFAs($FichierTFAs,$Access) "\n$Ligne" if {$Banque_Id!=$Access && ! [info exists LesSequencesDuTFAs($FichierTFAs,$Banque_Id)]} { append LesSequencesDuTFAs($FichierTFAs,$Banque_Id) "\n$Ligne" } } if {$DontMemorize} { if {[info exists LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]} { return [set LesSequencesDuTFAs($FichierTFAs,$AccessDemande)] } else { return "" } } set LesSequencesDuTFAs($FichierTFAs) "SontChargees" return [LaSequenceDuTFAs $FichierTFAs $AccessDemande] } proc LaSequenceDuTFAsMultiEntete {FichierTFAs Access} { global LesSequencesDuTFAs Wup "Same as LaSequenceDuTFAs execept that it accepts several access on a header line" Wup "Loads the sequence corresponding to Access from a multiple tfa file (can be a blast database)" Wup "Not sure that it works well if wrong '>b:id access'" if {[info exists LesSequencesDuTFAs($FichierTFAs,$Access)]} { return [set LesSequencesDuTFAs($FichierTFAs,$Access)] } if {[info exists LesSequencesDuTFAs($FichierTFAs)]} { return "" } foreach Ligne [LesLignesDuFichier $FichierTFAs] { if { ! [regexp -nocase {[a-z0-9_>]} $Ligne]} { continue } if {[regexp "^>" $Ligne]} { regsub "^>" $Ligne "" Ligne set LesAcessLus {} foreach Champ [split $Ligne "+"] { set AccessLu "" scan $Champ "%s" AccessLu lappend LesAccessLus $AccessLu set LesSequencesDuTFAs($FichierTFAs,$AccessLu) ">$AccessLu" lappend LesSequencesDuTFAs($FichierTFAs,LaListeDesAccess) $AccessLu } continue } foreach AccessLu $LesAccessLus { append LesSequencesDuTFAs($FichierTFAs,$AccessLu) "\n$Ligne" } } set LesSequencesDuTFAs($FichierTFAs) "SontChargees" return [LaSequenceDuTFAsMultiEntete $FichierTFAs $Access] } proc LaSequenceDuTexteEMBL {Texte} { return [LaSequenceDesLignesEMBL [split $Texte "\n"]] } proc LaSequenceGenomiquePourPromAn {FileTFA DebutTSS {Access ""} {Organism ""}} { set Seq [QueLaSequenceDuFichierTFA $FileTFA] set Taille [string length $Seq] return [list [list "GenomicSequence" "GenomicSequence" "1" $Taille "+" $DebutTSS "" "" $Access $Organism]] } proc LaTkColDe {c} { if {! [info exists ::ListeTkCol]} {InitTkCol} if {[regexp {_} $c]} { set c [string map {_ ""} $c] } set n [lsearch -inline -nocase $::ListeTkCol $c] if {$n ne ""} { return $n } else { return blue } } proc LaTotale {} { set lf [ListeDesPABs] foreach f $lf { MounirDuBlast $f } exit } proc LaTotalePourLesCDNAs {} { global RepertoireDuGenome if {! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} { if {[OnTraiteDesAffymetrix]} { CreeBornesDesCDNAs "Affymetrix" } else { CreeBornesDesCDNAs } } ProtocoleEukaryotePourDNA } proc LaTrace {{cmd ""} {ignoredArg ""}} { global ListeProc if {! [info exists ListeProc]} { inittrace set ListeProc {} return } set cmd [lindex $cmd 0] if {[lsearch $ListeProc $cmd] == -1} { lappend ListeProc $cmd } return } proc LaTraduction {Liste {Sortie ""} {SansBlanc ""}} { global GscopeDico if {$Sortie==""} { set Sortie [GscopeLangue] } set SansBlanc [string equal -nocase $SansBlanc "SansBlanc"] if { ! [info exists GscopeDico]} { foreach FichierDico [glob -nocomplain "[GscopeEtc]/gscope_*.dic"] { if {[file exists $FichierDico]} { if {[info exists LesLangues]} { unset LesLangues } foreach Ligne [LesLignesDuFichier $FichierDico] { if {[regexp {^[ \t]*\#} $Ligne]} { continue } set LesTermes {} foreach Terme [split $Ligne ":"] { regsub -all {^[ \t]+} $Terme "" Terme regsub -all {[ \t]+$} $Terme "" Terme lappend LesTermes $Terme } if { ! [info exists LesLangues]} { set LesLangues $LesTermes set NombreDeLangues [llength $LesLangues] continue } while {[llength $LesTermes] < $NombreDeLangues} { lappend LesTermes "" } set LesTermes [EtendAuxPremiersTermes $LesTermes] set LesTermes [lrange $LesTermes 0 [expr $NombreDeLangues-1]] set LesTermes [EtendAuxDerniersTermes $LesTermes] foreach Terme $LesTermes { foreach Langue $LesLangues TermeTraduit $LesTermes { if {$Terme==""} { continue } if {$SansBlanc} { regsub -all " " $TermeTraduit "_" TermeTraduit } set GscopeDico($Terme:$Langue) $TermeTraduit } } } } } } foreach Terme $Liste { if {[info exists GscopeDico($Terme:$Sortie)]} { lappend LaTraduction [set GscopeDico($Terme:$Sortie)] } else { lappend LaTraduction $Terme } } return $LaTraduction } proc LaValeurMaxCGHBAC {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMax 0 ChargeFichierCourbeCGH TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Value [lindex $LInfo 2] if {$Value>$ValMax} {set ValMax $Value} } } } return $ValMax } proc LaValeurMaxCGHOligo {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMax 0 ChargeFichierCourbeCGH TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Val [lindex $LInfo 3] set Value [format "%.2f" [expr ($Val*log(10)/log(2))*1.0]] if {$Value>$ValMax} {set ValMax $Value} } } } return $ValMax } proc LaValeurMaxCGHSeg {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMax 0 ChargeFichierSEG TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Value [lindex $LInfo 6] set Value [format "%.2f" [expr $Value*1.0]] if {$Value>$ValMax} {set ValMax $Value} } } } return $ValMax } proc LaValeurMinCGHBAC {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMin 100 ChargeFichierCourbeCGH TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Value [lindex $LInfo 2] if {$Value<$ValMin} {set ValMin $Value} } } } return $ValMin } proc LaValeurMinCGHOligo {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMin 100 ChargeFichierCourbeCGH TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Val [lindex $LInfo 3] set Value [format "%.2f" [expr ($Val*log(10)/log(2))*1.0]] if {$Value<$ValMin} {set ValMin $Value} } } } return $ValMin } proc LaValeurMinCGHSeg {FichierCourbe Chromosome {LesPos ""}} { #NB: fichiercourbe= pour 1 patient set ValMin 100 ChargeFichierSEG TabC $FichierCourbe $Chromosome $LesPos if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { set Value [lindex $LInfo 6] set Value [format "%.2f" [expr $Value*1.0]] if {$Value<$ValMin} {set ValMin $Value} } } } return $ValMin } proc LabelText {base {args ""}} { #set default values set frargs "" set txtargs "" set labargs "" set txtpack "" set labpack "" #parse arguments, assign to label/text components foreach {arg val} $args { switch -- $arg { -relief {append frargs " $arg $val " } -borderwidth {append frargs " $arg $val " } -labelfont {append labargs "-font \{$val\} " } -labelwidth {append labargs " -width $val "} -labelheight {append labargs " -height $val "} -labeltext {append labargs " -text \{$val\} "} -labeljustify {append labargs " -justify $val "} -labeltextanchor {append labargs " -anchor $val "} -labelbg - -labelbackground {append labargs " -background $val "} -labelfg - -labelforeground {append labargs " -foreground $val "} -labeltextvariable {append labargs " -textvariable $val" } -labelside { append labpack " -side $val " append txtpack " -side $val " } -labelanchor { append labpack " -anchor $val " append txtpack " -anchor $val " } -width - -height - -background - -foregroung - -bg - -fg - -font {append txtargs " $arg \{$val\} "} -textvariable { #todo: Create variable if one does not exist set variable $val set a $variable puts $a trace var ::$a wu _$a set ::${a}_ $base.$variable ################################################### #create bespoke trace handler ################################################### proc _$a {name i op} { # args passed to the fucntion # name variable name # i array index # op operation #upvar 1 $name var if {$::DEBUG} { puts ">> name: $name i: $i op: $op" #puts "[set ::${name}(${i})_]" } #deal with unset variables if { $op == "u" } { if { $i != {} } { rename _$name {} } else { rename _${name}(${i}) {} } return } #assuming variable to be an array, ie $i != NULL if {$i != {} } { #variable is and array [set ::${name}(${i})_] delete 1.0 end [set ::${name}(${i})_] insert end [set ::${name}(${i})] } else { #simple variable [set ::${name}_] delete 1.0 end [set ::${name}_] insert end [set ::${name}] } } #end proc } # end textvariable block } #end switch } #end foreach # build megawidget frame $base {*}$frargs label $base.lab {*}$labargs pack $base.lab {*}$labpack text $base.$variable {*}$txtargs pack $base.$variable {*}$txtpack -in $base if {$::DEBUG} { bind "$base.$variable" { # get variable name set tmp %W puts "%W -- [winfo parent %W]" puts "%W -- [winfo pathname [winfo id %W]]" puts [lindex [split %W .] end] } } #update variable when focus is lost bind "$base.$variable" { set a [%W get 1.0 end] set b [lindex [split %W .] end] #if {$::DEBUG} { puts "a = $a b = $b \n[set $b]" } #remove any blank lines set $b [string trimright [string trimleft $a]] } #return location return $base } proc LacheLeBouton {w} { global QuelBouton global LeBoutonQuiEstMontre catch {after cancel $QuelBouton} catch {destroy $LeBoutonQuiEstMontre} } proc Laetst {} { set RepertoireParent "/home/luudao/tmp/" set Racine String_9606_201108051443 set NomZip String_9606_201108051443.tgz exec csh -c "cd $RepertoireParent; tar -cf - $Racine | gzip -9 > $NomZip" puts "all done !" exit } proc Lana {{Qui ""} {Quoi ""}} { global Lana set IouM "Merck" if {[regexp "^s" $Qui]} { set IouM "Igbmc" } set FichierTFA "[LanaRep]/nuctfa$IouM/$Qui" set Entete [EnteteDuFichierTFA $FichierTFA] if {$IouM=="Igbmc"} { ScanLaListe [split $Entete " "] SpotID ProductID OligoName GenbankID UGCluster Symbol LLID set Def [StringSuivant "Def: " dans $Entete] set Aliases [StringSuivant "Aliases: " dans $Def] regsub { Aliases: .*} $Def "" Def } else { ScanLaListe [split $Entete " "] Reporter_ID gene_id gene locuslink accession } set Seq [QueLaSequenceDuFichierTFA $FichierTFA] if {[info exists $Quoi]} { return [set $Quoi] } return "" } proc LanaBestHits {IouM {Qui ""}} { set OldBId "" set OldQuery "" set Bidon "na -1 na na -1 -1 -1/-1 Plus/Plus -1 -1 -1 -1" foreach Ligne [LesLignesDuFichier "[LanaRep]/Hits$IouM"] { if {$Ligne==""} { continue } ScanLaListe [split $Bidon " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct if {$Qui!="" && $Qui!=$Query} { continue } set QBS [StringSuivant " /" dans $Ligne] ScanLaListe [split $QBS "/"] SeqQuery Barres SeqSbjct set DHQ [Mini $DebQuery $FinQuery] set FHQ [Maxi $DebQuery $FinQuery] set LHQ [expr $FHQ-$DHQ+1] if {$FHQ==$LongQuery && ($DHQ==1 || $DHQ==2) && $Identities=="$LHQ/$LHQ"} { lappend BonsHits($Query) $Ligne Espionne $Ligne AppendAuFichier "[LanaRep]/BestHits$IouM" $Ligne } else { if { ! [info exists BonsHits($Query)]} { AppendAuFichier "[LanaRep]/BadHits$IouM" $Ligne } } set OldQuery $Query continue #rR le reste est obsolete ScanLaListe [split $Identities "/"] A B if {$A<$B} { continue } if {0 && $Identities!="$LongQuery/$LongQuery"} { continue } if {[expr $A<$LongQuery-2]} { continue } if {$OldQuery!=$Query} { Espionne "\n\n[Lana $Query Def]" } if {0 && $OldBId!=$BId} { Espionne } set OldBId $BId Espionne "$Query [format %-5s $BId] $LongQuery $Identities $DebQuery $FinQuery $DebSbjct $FinSbjct $Barres" } } proc LanaCommonTargets {{Ext ""}} { foreach Ligne [LesLignesDuFichier "[LanaRep]/TargetsIgbmc$Ext"] { scan $Ligne "%s %s" Access ProbeIgbmc lappend Igbmc($Access) $ProbeIgbmc lappend LesAccessIgbmc $Access } set LesAccessIgbmc [lsort -unique $LesAccessIgbmc] foreach Ligne [LesLignesDuFichier "[LanaRep]/TargetsMerck$Ext"] { scan $Ligne "%s %s" Access ProbeMerck lappend Merck($Access) $ProbeMerck lappend LesAccessMerck $Access } set LesAccessMerck [lsort -unique $LesAccessMerck] foreach Access $LesAccessMerck { if {[info exists Igbmc($Access)]} { AppendAuFichier "[LanaRep]/CommonTargets$Ext" "$Access [join $Igbmc($Access) /] [join $Merck($Access) /]" } } } proc LanaCreateBadNuctfa {IouM FromFile ToRep} { if {[FileAbsent $ToRep ]} { file mkdir $ToRep } foreach Ligne [LesLignesDuFichier $FromFile] { scan $Ligne "%s" Query file copy -force "[LanaRep]/nuctfa$IouM/$Query" "$ToRep/$Query" } return $ToRep } proc LanaHits {IouM} { set RepDesBla "[LanaRep]/blatblast$IouM" if {[regexp -nocase "blastn" $IouM]} { set RepDesBla "[LanaRep]/$IouM" } set FichierDesCopains "[LanaRep]/Hits$IouM" if {[file exists $FichierDesCopains] && [OuiOuNon "Do I replace $FichierDesCopains"]} { file delete $FichierDesCopains } foreach Fichier [lsort [glob "$RepDesBla/*"]] { set LesHits [DecortiqueBlat $Fichier] set LaSortie {} foreach LeHit $LesHits { ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct set Texte "$Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand $DebQuery $FinQuery $DebSbjct $FinSbjct" append Texte " /$SeqQuery/$Barres/$SeqSbjct" lappend LaSortie $Texte } if {$LaSortie=={}} { continue } AppendAuFichier $FichierDesCopains [join $LaSortie "\n"] } return $FichierDesCopains } proc LanaIgbmc {} { # SpotID ProductID OligoName GenbankID Position Sequence Length Tm_C UGCluster Name Symbol Aliases LLID set FichierIgbmc "[LanaRep]/DeLana/puceOligoSourisIGBMC.csv" set Queue [file tail $FichierIgbmc] regsub -nocase {\.[^\.]+$} $Queue "" Queue LoadTxl $FichierIgbmc T -1 ";" set RepNuc "[LanaRep]/nuctfaIgbmc" if {[FileAbsent $RepNuc]} { file mkdir $RepNuc } set LesHeaders $T(ListHeaderPlease,$Queue) Espionne $LesHeaders foreach I $T(ListAllPlease,$Queue) { foreach Header $LesHeaders { set $Header [string trim $T($I,$Header)] if {$Header!="Name" && $Header!="Aliases"} { regsub -all " " [set $Header] "_" $Header } if {[set $Header]==""} { set $Header "na" } } regsub -all " " $LLID "" LLID regsub {s0*} $SpotID "" SpotNum regsub -all {\|+} $Aliases "|" Aliases set Entete "$SpotID $ProductID $OligoName $GenbankID $UGCluster $Symbol $LLID Def: $Name Aliases: $Aliases" #rR attention on enleve le 1er a set Sequence [string range $Sequence 1 end] set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"] set FichierTFA "$RepNuc/$SpotID" Sauve $TFA dans $FichierTFA if {$I%100==0} { Espionne $Entete } } } proc LanaLaTotale {{Etape ""}} { Wup "Il y a deux fichier Excel Igbmc et Merck sauves en .csv" Wup "On cree les nuctfa, on fait les blat, on decortique les blat pour creer les copains, on cree les .csv resultat" if {$Etape==""} { set Etape [ChoixParmi [LanaLesEtapesPossibles]] } if {$Etape=="Lana"} { LanaIgbmc LanaMerck # set Etape "BLAT_server" } if {$Etape=="BLAT_server"} { BLAT_server start mouse star6 # set Etape "BLAT_clientPourTousRR" } if {$Etape=="BLAT_clientPourTousRR"} { BLAT_clientPourTousRR "[LanaRep]/nuctfaIgbmc" "[LanaRep]/blatblastIgbmc" mouse BLAT_clientPourTousRR "[LanaRep]/nuctfaMerck" "[LanaRep]/blatblastMerck" mouse # set Etape "LanaHits" } if {$Etape=="LanaHits"} { LanaHits "Igbmc" LanaHits "Merck" # set Etape "LanaBestHits" } if {$Etape=="LanaBestHits"} { LanaBestHits "Igbmc" LanaBestHits "Merck" # set set Etape "LanaLocaliseBestHits" } if {$Etape=="LanaLocaliseBestHits"} { LanaLocaliseBestHits Igbmc LanaLocaliseBestHits Merck LanaCommonTargets # set Etape "LanaCreateNuctfaBad" } if {$Etape=="LanaCreateNuctfaBad"} { LanaCreateBadNuctfa "Igbmc" "[LanaRep]/BadHitsIgbmc" "[LanaRep]/nuctfaIgbmcBad" LanaCreateBadNuctfa "Merck" "[LanaRep]/BadHitsMerck" "[LanaRep]/nuctfaMerckBad" # set Etape "BLAT_clientPourTousRR-desBadsurHuman" } if {$Etape=="BLAT_clientPourTousRR_desBadsurHuman"} { set RepIgbmcHuman "[LanaRep]/blatblastIgbmcHuman" ; if {[FileAbsent $RepIgbmcHuman]} { file mkdir $RepIgbmcHuman } BLAT_clientPourTousRR "[LanaRep]/nuctfaIgbmcBad" $RepIgbmcHuman human # il faut faire find . -size 0 -exec rm {} \; set RepMerckHuman "[LanaRep]/blatblastMerckHuman" ; if {[FileAbsent $RepMerckHuman]} { file mkdir $RepMerckHuman } BLAT_clientPourTousRR "[LanaRep]/nuctfaMerckBad" "[LanaRep]/blatblastMerckHuman" human # il faut faire find . -size 0 -exec rm {} \; set Etape "LanaHitsHuman" } if {$Etape=="LanaHitsHuman"} { LanaHits "IgbmcHuman" LanaHits "MerckHuman" # set Etape "LanaBestHitsHuman" } if {$Etape=="LanaBestHitsHuman"} { LanaBestHits "IgbmcHuman" LanaBestHits "MerckHuman" # set Etape "LanaLocaliseBestHitsHuman" } if {$Etape=="LanaLocaliseBestHitsHuman"} { LanaLocaliseBestHits IgbmcHuman LanaLocaliseBestHits MerckHuman LanaCommonTargets Human } if {$Etape=="LanaBlastN"} { set RepQuery "[LanaRep]/nuctfaIgbmcBad" set LesQuery {} foreach Query [glob -nocomplain "[LanaRep]/nuctfaIgbmcBad/*"] { set Query [file tail $Query] lappend LesQuery $Query } BlastNPourTous Mus_musculus $LesQuery $RepQuery F 1 set RepBlastNIgbmc "[LanaRep]/blastnIgbmc" if {[FileAbsent $RepBlastNIgbmc]} {file mkdir $RepBlastNIgbmc} foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/blastnMus_musculus/*"] { set Queue [file tail $Fichier] if { ! [regexp {^s[0-9]+$} $Queue]} { continue } file copy $Fichier "$RepBlastNIgbmc/$Queue" } set RepQuery "[LanaRep]/nuctfaMerckBad" set LesQuery {} foreach Query [glob -nocomplain "[LanaRep]/nuctfaMerckBad/*"] { set Query [file tail $Query] lappend LesQuery $Query } BlastNPourTous Mus_musculus $LesQuery $RepQuery F 1 set RepBlastNMerck "[LanaRep]/blastnMerck" if {[FileAbsent $RepBlastNMerck]} {file mkdir $RepBlastNMerck} foreach Fichier [glob -nocomplain "[RepertoireDugenome]/blastnMus_musculus/*"] { set Queue [file tail $Fichier] if { ! [regexp {^[0-9]+$} $Queue]} { continue } file copy $Fichier "$RepBlastNMerck/$Queue" } # set Etape "LanaHitsBlastN" } if {$Etape=="LanaHitsBlastN"} { LanaHits "blastnIgbmc" LanaHits "blastnMerck" # set Etape "LanaBestHitsBlastN" } if {$Etape=="LanaBestHitsBlastN"} { LanaBestHits "blastnIgbmc" LanaBestHits "blastnMerck" } } proc LanaLesEtapesPossibles {} { set LesEtapesPossibles {} foreach Ligne [split [info body LanaLaTotale] "\n"] { if { ! [regexp -nocase {\$Etape==\"([a-z_0-9]+)\"} $Ligne Match Etape]} { continue } lappend LesEtapesPossibles $Etape } return $LesEtapesPossibles } proc LanaLocaliseBestHits {IouM {Qui ""}} { set FichierTargets "[LanaRep]/Targets$IouM" while {[file exists $FichierTargets]} { if {[OuiOuNon "Do I replace $FichierTargets"]} { file delete $FichierTargets ; break } if {[OuiOuNon "Do I cancel LanaLocaliseBestHits"] } { return "" } } set Org "Mouse" if {[regexp "Human" $IouM]} { set Org "Human" } set Bidon "na -1 na na -1 -1 -1/-1 Plus/Plus -1 -1 -1 -1" foreach Ligne [LesLignesDuFichier "[LanaRep]/BestHits$IouM"] { if {$Ligne==""} { continue } ScanLaListe [split $Bidon " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct if {$Qui!="" && $Qui!=$Query} { continue } set Chro $BId set Milieu [expr ($DebSbjct + $FinSbjct)/2] set Locs "" if {$Locs==""} { set Locs [LocIn $Milieu $Org $Chro] } if {$Locs==""} { set Locs [LocIn $DebSbjct $Org $Chro] } if {$Locs==""} { set Locs [LocIn $FinSbjct $Org $Chro] } if {$Locs!=""} { foreach Loc [split $Locs "\n"] { ScanLaListe [LesMotsDeLaLigne $Loc] Access Deb Fin Orient AppendAuFichier $FichierTargets "$Access $Ligne === $Loc" } } } } proc LanaMerck {} { # Reporter_ID Sequence reporter_id gene_id gene locuslink accession set RepNuc "[LanaRep]/nuctfaMerck" if {[FileAbsent $RepNuc]} { file mkdir $RepNuc } set FichierMerck "[LanaRep]/DeLana/puceOligoSourisMerck.csv" set Queue [file tail $FichierMerck] regsub -nocase {\.[^\.]+$} $Queue "" Queue LoadTxl $FichierMerck T -1 ";" set LesHeaders $T(ListHeaderPlease,$Queue) Espionne $LesHeaders foreach I $T(ListAllPlease,$Queue) { foreach Header $LesHeaders { set $Header [string trim $T($I,$Header)] if {[set $Header]==""} { set $Header "na" } } if {$Sequence=="na"} { continue } regsub -all {\|+} "|$accession|" "|" accession set Entete "$Reporter_ID $gene_id $gene $locuslink $accession" set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"] set FichierTFA "$RepNuc/$Reporter_ID" Sauve $TFA dans $FichierTFA if {$I%100==0} { Espionne $Entete } } } proc LanaRep {} { return "/genomics/link/Lana" } proc LanaShow {} { global BestHit foreach IouM [list "Igbmc" "Merck"] { foreach Ligne [LesLignesDuFichier "[LanaRep]/BestHits$IouM"] { ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct lappend BestHit($Query) $Ligne } } set F [AfficheFichier "[LanaRep]/CommonTargets" "AvecLana"] set B [BoutonneLaFenetre $F "ShowTarget" "LanaShowTarget \[selection get\]"] $B configure -background "black" -foreground "white" } proc LanaShowTarget {Selection} { global BestHit scan $Selection "%s %s %s" Access Igbmc Merck lappend LaPage $Selection lappend LaPage [LocUcsc $Access "line"] lappend LaPage "" foreach AI [split $Igbmc "/"] { lappend LaPage " [join $BestHit($AI) " \n"]" } foreach AM [split $Merck "/"] { lappend LaPage [join $BestHit($AM) "\n"] } AfficheVariable [join $LaPage "\n"] "GrandeLargeur" } proc Lance {Aligneur Selection} { global LaFenetreDesMSF set Num [NomDe ""] switch -regexp $Aligneur { "All" { foreach a [Aligneurs] { if {[Aligneurs $a]} { set MSF [AlignePar $a $Selection "Batch" $Num] lappend ListeDesMSF $MSF } } set Fenetre [AfficheVariable [join $ListeDesMSF "\n"] "AvecShowAvecEtudeMSF" "Wait all be Highlighted ...\nThen reselect and press a function. "] BoutonneLaFenetre $Fenetre "Log" "AfficheLogDesMSF \[selection get\]" foreach Fichier $ListeDesMSF { set LaFenetreDesMSF($Fichier) $Fenetre } } "clustalw|dialign|pileup|prrp" { AlignePar $Aligneur $Selection "Batch" $Num } default { } } } proc LanceAreaimol {f1 f2} { set o [open cmd.csh w] puts $o "setccp4" puts $o "areaimol xyzin $f1 xyzin2 $f2 xyzout out.pdb < outfile" puts $o "diffmode compare" puts $o "pntden 100" puts $o "output" puts $o "end" puts $o "eof" puts $o "exit" close $o catch {exec tcsh cmd.csh} Msg if {$Msg ne ""} { #puts "Msg : $Msg" } if {! [file exists outfile]} { return 0 } else { return [LesLignesDuFichier outfile] } } proc LanceCalculConservation {} { global Cons ScoreMeth set ft [PrepareRunOrdali] if {$Cons(Entry) ne ""} { set Cons(Title) [$Cons(Entry) get] } lappend Cons(ListeCons) [list $ft $Cons(Title)] if {$Cons(ComboSel) ne ""} { $Cons(ComboSel) configure -values $Cons(ListeCons) $Cons(ComboSel) current [expr {[llength $Cons(ListeCons)]-1}] } set Cons(ConsCou) $ft set ScoreMeth($ft,Title) $Cons(Title) set ScoreMeth($ft,Methode) $Cons(Method) ChangeConservation return } proc LanceDoc {} { global OrdHlpDir package require Tkhtml set file [file join $OrdHlpDir help.html] Hv_Run -readfile $file return } proc LanceElm {} { foreach Box [ListeDesPABs] { Espionne "$Box" if {[regexp -nocase "Mouse" [RepertoireDuGenome]] || [regexp -nocase "Rat" [RepertoireDuGenome]]} { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"} } else { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne.reduit"} } set FileElm "[RepertoireDuGenome]/fiches/regexp_all_elms_exp_manual_SsCLV" set Commande "/biolo/macsim/elm2relacs $FileMacsims $FileElm $FileMacsims.elm /tmp" catch {eval exec $Commande} } } proc LanceIdentityProfile {} { global LNDG SDG LNOrdali ListeDesPiliersDuGroupe ScoreMeth ListeTypesDeFeatures TabSF LongueurTotale Sequences PrI FaireAttendre "Please wait ...\nComputing Identity Profiles ..." if {! [info exists ListeDesPiliersDuGroupe]} { CreeLesPiliers } # groups to compute switch $PrI(grp) { "All" {set Lgrp $LNDG} "Global" {set Lgrp [lindex $LNDG 0]} default {set Lgrp $PrI(grp)} } set NPiliers [llength [set ListeDesPiliersDuGroupe([lindex $Lgrp 0])]] set wlg $PrI(win) set jmp $PrI(jump) set f "Score-Iden" lappend ListeTypesDeFeatures $f set ScoreMeth($f,ListeGrps) $Lgrp foreach g $Lgrp { set mmax -99999999.0 set mmin 99999999.0 set LPil [set ListeDesPiliersDuGroupe($g)] set id 0 set if [expr {$wlg-1}] set Nsq 0 foreach p [lrange $LPil $id $if] { set p [string map [list "." ""] $p] if {[string length $p] >= 2} { incr Nsq } } while {$if <= ($NPiliers-$wlg)} { if {$id != 0} { set pOte [lindex $LPil $id] set pAdd [lindex $LPil $if] set pOte [string map {"." ""} $pOte] set pAdd [string map {"." ""} $pAdd] if {[string length $pOte] >= 2} { incr Nsq -1 } if {[string length $pAdd] >= 2} { incr Nsq } } if {$Nsq == 0} { set istk [expr {$id+($wlg/2)-1}] set ScoreMeth($f,$g,$istk) -999. incr id $jmp incr if $jmp continue } # Create "window" alignment for PCI set SAli [list] foreach n [set SDG($g)] { lappend SAli $n [string range [set Sequences($n)] $id $if] } CalculeLesPCIGenerique $SAli TPCI set in 1 ; set nm 0 set m 0.0 foreach n1 [lrange $SDG($g) 0 end-1] { foreach n2 [lrange $SDG($g) $in end] { set m [expr {$m + [lindex $TPCI($n1,$n2) 0]}] incr nm } incr in } set m [expr {100.*$m/double($nm)}] if {$m > $mmax} {set mmax $m} if {$m < $mmin} {set mmin $m} set istk [expr {$id+($wlg/2)-1}] set ScoreMeth($f,$g,$istk) $m incr id $jmp ; incr if $jmp unset -nocomplain TPCI } set Sc($g,min) $mmin set Sc($g,max) $mmax set ScoreMeth($f,${g}-min) $mmin set ScoreMeth($f,${g}-max) $mmax } set ScoreMeth($f,Edit) 0 set ScoreMeth(ScaleGlobal) 1 FaireLaSuite if {$PrI(CSV)} { set file [DemandeEtSauveFichier csv] if {$file ne ""} { set o [open $file w] set g [lindex $Lgrp 0] set Li [list] foreach e [array names ScoreMeth "$f,$g,*"] { lappend Li [lindex [split $e ,] 2] } set Li [lsort -unique -integer $Li] foreach i $Li { set Ls [list] foreach g $Lgrp { set x [set ScoreMeth($f,$g,$i)] if {$x == -999. || $x < 0.1} { set x 0.0 } lappend Ls $x } puts $o [join $Ls ";"] } close $o } } if {1} { set file [open "vals.txt" w] foreach g $Lgrp { puts $file "$g" puts $file "[string repeat - [string length $g]]" foreach n [lsort -dictionary [array names ScoreMeth "$f,${g},*"]] { lassign [split $n ,] nf ng ni puts $file "$ni [set ScoreMeth($n)]" } puts $file "" } close $file } unset -nocomplain PrI TPCI return } proc LanceInterproScan {FileIn FileOut} { set Commande "/titan/data/iprscan/V4.8/iprscan/bin/iprscan -cli -i tmpfa -o tmpo -appl patternscan -format raw" #set Commande "/titan/data/iprscan/V4.8/iprscan/bin/iprscan -cli -i $FileIn -o $FileOut -appl patternscan -format raw -goterms -iprlookup" catch {eval exec $Commande >& iprlog} return } proc LanceInterproscanOld {Repertoire} { #repetition avec proc Interproscan #dans 2eme relance, donne nom des box au lieu nom des clusters dans repertoire Interproscan #set RepertoireSourisTfactor "/genomics/link/SpliRetMouse/FichiersModifUnique/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai" #set RepertoireSourisOthers "/genomics/link/SpliRetMouse/FichiersModifUnique/PROT_VARIANTES_61_mai/SOURIS_others_61_mai" #set RepertoireSourisNOALT "/genomics/link/SpliRetMouse/FichiersModifUnique/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai" #set RepertoireRatTfactor "/genomics/link/SpliRetRat/FichiersModifUnique/PROT_VARIANTES_61_mai/RAT_Tfactor_61_mai" #set RepertoireRatOthers "/genomics/link/SpliRetRat/FichiersModifUnique/PROT_VARIANTES_61_mai/RAT_others_61_mai" set RepertoireRatNOALT "/genomics/link/SpliRetRat/FichiersModifUnique/PROT_VARIANTES_61_mai/RAT_NO_ALT_61_mai" set RepertoireOut "[RepertoireDuGenome]/Interproscan" if {! [file exists $RepertoireOut]} {file mkdir $RepertoireOut} set LesFileOut {} foreach FileIn [glob -nocomplain "$Repertoire/*"] { Espionne "" Espionne "$FileIn" set Queue [file tail $FileIn] regsub {\.[^\.]+$} $Queue "" Cluster set Box [InterrogeBox $Cluster Box] set FileOut "$Box.is" Espionne "$FileOut" set Commande "/bips/bin/iprscan -cli -i $FileIn -o $RepertoireOut/$FileOut -appl hmmpfam -format raw -goterms -iprlookup" Espionne "$Commande" catch {eval exec $Commande} if {[FileExists $FileOut]} { lappend LesFileOut $FileOut } } return $LesFileOut } proc LanceLeServeurWscope {} { global GscopeDir global RepertoireDuGenome global CurrentGenome global ForumWscope global FichierAFaire global FichierDejaFait set Sonnette "$ForumWscope/wscope_${CurrentGenome}_est_pret" lappend LesCommandes "Sauve $Sonnette dans $Sonnette" SauveLesLignes $LesCommandes dans $FichierAFaire after 2000 if {! [file exists $Sonnette]} { after 2000 } if { ! [file exists $Sonnette]} { after 5000 eval exec $GscopeDir/bin/gscope ToujoursFaire $CurrentGenome & after 3000 } File delete $Sonnette } proc LanceLeonMS2PH {type} { set leon "/biolo/leon/leon.tcsh" puts "On est dans Leon : pour $type" foreach pab [ListeDesPABs] { puts "traite $pab" set logFile [file join [RepertoireDuGenome] "msf_$type" "Rascal" "Leon" "${pab}.log"] set alnFile [file join [RepertoireDuGenome] "msf_$type" "Rascal" "Leon" $pab] set inFile [file join [RepertoireDuGenome] "msf_$type" "Rascal" $pab] if {![file exists $alnFile]} { if {[file exists $inFile]} { catch {exec $leon $inFile $pab $alnFile $logFile} } } } puts "fin calcul leon" CalculNorMDMS2PH $type leon puts "fin calcul NorMD suite a Leon" return 1 } proc LanceLesBlastPString {TaxID RepertoireTfa RepertoireSortie} { #RepertoireTfa genomics/link/Tau/GSTControl/BlastpSurStringPoulet/fastaquery #RepertoireSortie genomics/link/Tau/GSTControl/BlastpSurStringPoulet set non 0 foreach FichierTFA [glob -nocomplain "$RepertoireTfa/*"] { if {[regexp ".blastp" $FichierTFA]} {continue} Espionne "" Espionne "FichierTFA $FichierTFA" set Access [file tail $FichierTFA] set PID [BlastPStringMoi $FichierTFA $TaxID] Espionne "$Access $PID" if {[info exists DejaVu($PID)]} { incr DejaVu($PID) Espionne "$PID pls" } else { set DejaVu($PID) 1 } if {$PID=="vide"} { incr non } else { set Ligne "$PID" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "$RepertoireSortie/$TaxID" Espionne "" Espionne "non $non" } proc LanceLesCalculs {lc ngrp relatif {what pfam}} { CreeListeScore $ngrp NormalisationColonnes # AIC/BIC - MixtureModel #puts "$lc" #puts "$::ListeScore" #set Lgr [Tclcluspack $::ListeScore -dt coordinates -cm mm -nbc aic -wc] set Lgr [Tclcluspack $::ListeScore -dt coordinates -cm kmeans -nbc dpc -wc] set order decreasing switch $what { "pfam" { set rep [LanceTestsPfam $Lgr -order $order -nomgrr $ngrp -method $lc] } "bali" { set rep [LanceTestsBali $Lgr -order $order -nomgrr $ngrp -method $lc] } default { set rep [LanceTestsPDB $Lgr -order $order -relatif $relatif -nomgrr $ngrp] } } # pour shunter Al2Co ! if {"7" in $lc} {set rep 1} return $rep } proc LanceLoc {} { foreach Box [ListeDesPABs] { Espionne "$Box" set FileTfa "[RepertoireDuGenome]/FastaMacsims/$Box" set RepertoireSortie "[RepertoireDuGenome]/Loc" if {! [file exists $RepertoireSortie]} {file mkdir $RepertoireSortie} set Commande "/biolo/WolfPsort/bin/runWolfPsortHtmlTables animal $RepertoireSortie $Box < $FileTfa" catch {eval exec $Commande} } } proc LanceMonMacsim {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set RepertoireMsf "msf" foreach Nom $Liste { Espionne $Nom set FichierMacsim "[RepertoireDuGenome]/macsim/$Nom.xml" set FichierMacsimXml "[RepertoireDuGenome]/macsimXml/$Nom" set FichierMsf "[RepertoireDuGenome]/$RepertoireMsf/$Nom" if {[file exists $FichierMacsimXml]} {continue} if {[file exists $FichierMacsim]} {continue} if {! [file exists $FichierMsf]} {continue} MacsimManu $Nom $RepertoireMsf } } proc LanceOrdali {{behave slave} {aNomFenetreOrdali ""}} { global LongueurTotale NomSeqSel BufferSeq ListeTypesDeFeatures VariablesAuDepart Threshold AExecuter APutser NomFenetreOrdali VersionDeOrdali Defauts Toggle TabSF ListeTypesDeFeatures BufNTimes upvar $aNomFenetreOrdali NomFenetreOrdali set Threshold [set Defauts(Threshold)] set ListeTypesDeFeatures {} set NomSeqSel {} set BufferSeq {} set LongueurTotale 0 array set TabSF {} set BufNTimes "" InitComparaison InitChemicals InitHydroAA InitCode3l1l DemarrageOrdali DefinitionPreferences InitialiseCouleurs PrintSetup "defauts" #::profiler::reset set fileIn [LoadingAlignement] if {[set Defauts(PreCompute)]} { PreCalculs } FinDemarrage #AfficheProfileResults # Lancement fenetre principale if {! [info exists NomFenetreOrdali] || $NomFenetreOrdali eq ""} { set w ".ordali" set NomFenetreOrdali $w } else { set w $NomFenetreOrdali } if {[ModeI]} { ChangeTkOptions InitialiseFenetreOrdali $behave $NomFenetreOrdali InitAffichage update idletasks if {[TypeAli] in {"XML" "RSF" "ORD"}} { ChangeMode "feature" } #AfficheProfileResults # Toggle if necessary ToggleScores if {! $Toggle(ToolBar)} { ToggleToolbar } if {! $Toggle(Feature)} { ToggleFeature } BindingsOrdali BindMenuItems BindModeNormal } set VariablesAuDepart [info globals] if {[set Defauts(TypeDeGroupesACreer)] != "User" && [TypeAli] != "XML"} { DefinitionGroupes [set Defauts(TypeDeGroupesACreer)] } if {[set Defauts(Run)]} {RunOrdali} if {[set Defauts(Dump)]} {DumpOrdali} if {[set Defauts(RunScript)]} { source [set Defauts(Script)] } if {$behave eq "slave"} {return $w} if {[info exists AExecuter] && $AExecuter ne ""} { eval "$AExecuter" } if {[info exists APutser] && $APutser ne ""} { puts [eval $APutser] } if {[set Defauts(Exit)]} { AdieuOrdali } return } proc LancePSScan {f} { exec perl /home/moumou/tmp/ps_scan/ps_scan.pl -r -s -d /home/moumou/tmp/ps_scan/prosite.dat $f > ${f}.out if {! [file exists ${f}.out]} { puts "==> Erreur dans psscan !!" return {} } set Ll [LesLignesDuFichier ${f}.out] file delete -force ${f}.out return $Ll } proc LancePhrap {FichierEstTFA FichierSortie {Options ""}} { set Commande "exec /gcg/extensions/bin/phrap $FichierEstTFA $Options >& FichierSortie" eval $Commande } proc LancePipe {w} { global CurrentPipe global DefautsPipe LesDefauts Mode batch set CurrentPipe(Filter,bank) [set CurrentPipe(Blast,d)] foreach e [lsort [array names CurrentPipe]] { set DefautsPipe($e) [set CurrentPipe($e)] } if {[VerifieParametres]} { PipeGrid } else { return } exit } proc LancePourLaetitiaEnSortieDeGrid {} { RenommeLesRepertoiresDeLaGrid NormdEnSortieDeGrid file copy -force "[RepertoireDuGenome]/fiches/normdensortiedegrid" "[RepertoireDuGenome]/fiches/normdensortiedegrid.grid" CluspackDeLaGrid CreeLeFichierGroupedpcDeLaGrid #NormdDesCluspackDeLaGridPourTous #CreeLeFichierNormdEnSortieDeGrid } proc LancePourLaetitiaEnSortieDePipeLocal {Nom} { RangePipeLocal $Nom NormdEnSortieDePipeLocal $Nom file copy -force "[RepertoireDuGenome]/fiches/normdensortiedegrid" "[RepertoireDuGenome]/fiches/normdensortiedegrid.grid" CreeLeFichierGroupedpcDuPipeLocal $Nom #file rename -force "[RepertoireDuGenome]/fiches/groupedpc" "[RepertoireDuGenome]/fiches/groupedpc.grid" } proc LanceProtDeProjet {f} { global OPjt set file [file join ord ${f}.ord] set log [file join Logs $f] set cmd [list ordali $file -project $OPjt(Dir) -savelog $log] exec {*}$cmd & return } proc LanceRascalMS2PH {type} { puts "pour $type" foreach pab [ListeDesPABs] { puts "traite $pab" set outFile [file join [RepertoireDuGenome] "msf_$type" "Rascal" $pab] if {![file exists $outFile]} { set inFile [file join [RepertoireDuGenome] "msf_$type" $pab] if {[file exists $inFile]} { catch {exec rascal $inFile $outFile} } } } CalculNorMDMS2PH $type rascal LanceLeonMS2PH $type return 1 } proc LanceRecupInFoMS2PH {} { set fic "/genomics/link/MS2PH-db/list/listAcc" puts "id@@EntryName@@ListSynAccNum@@ProteinName@@ListSynProtName@@GeneName@@ListSynGeneName@@Function@@ListGO@@ListGeneOmim@@ListPhenoOmim@@" set listEntry [LesLignesDuFichier $fic] foreach e $listEntry {} #foreach e {P35520} { if { ![regexp {^[1-9]} $e]} { parseFicUniprot $e } } return 1 } proc LanceStringDesSelectionnesSur180 {TaxId} { set nbbox 0; set nbvide 0 set FichierDesSelectionnes "[RepertoireDuGenome]/string/YesScNoTb.tfa" foreach Ligne [LesLignesDuFichier $FichierDesSelectionnes] { if {[regexp "^TP" $Ligne]} { set Box [lindex [split $Ligne " "] 0] Espionne "" Espionne "$Box" incr nbbox if {$TaxId=="9606"} { set FileTfa "[RepertoireDuGenome]/prottfa/$Box" set FileOut "[RepertoireDuGenome]/string/BlastpSurStringHomme/resultblast/$Box.blastp" set RepertoireSortie "[RepertoireDuGenome]/string/BlastpSurStringHomme" } if {$TaxId=="4932"} { set FileTfa [InfHomolog $Box filename] set FileOut "[RepertoireDuGenome]/string/BlastpSurStringLevure/resultblast/$Box.blastp" set RepertoireSortie "[RepertoireDuGenome]/string/BlastpSurStringLevure" } set Result [BlastPStringGeneral $FileTfa $FileOut $TaxId] Espionne "$Result" if {$Result=="vide"} { incr nbvide } else { set Ligne "$Result" lappend LesLignes $Ligne } } } SauveLesLignes $LesLignes dans "$RepertoireSortie/$TaxId" Espionne "" Espionne "nbbox $nbbox" Espionne "nbvide $nbvide" } proc LanceStringDesSelectionnesSur80 {TaxId} { set nbbox 0; set nbvide 0 set FichierDesSelectionnes "[RepertoireDuGenome]/string/80/bilanP62.csv" foreach Ligne [LesLignesDuFichier $FichierDesSelectionnes] { #Espionne "$Ligne" set LesMotsDeLaLigne [split $Ligne ";"] set Box [lindex $LesMotsDeLaLigne 2] if {![regexp "^TP" $Box]} {continue} Espionne "++$Box" incr nbbox if {$TaxId=="9606"} { set RepertoireSortie "[RepertoireDuGenome]/string/80/BlastpSurStringHomme" set FileTfa "[RepertoireDuGenome]/prottfa/$Box" set FileOut "$RepertoireSortie/resultblast/$Box.blastp" } if {$TaxId=="4932"} { set FileTfa [InfHomolog $Box filename] set RepertoireSortie "[RepertoireDuGenome]/string/80/BlastpSurStringLevure" set FileOut "$RepertoireSortie/resultblast/$Box.blastp" } set Result [BlastPStringGeneral $FileTfa $FileOut $TaxId] Espionne "$Result" if {$Result=="vide"} { incr nbvide } else { set Ligne "$Result" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "$RepertoireSortie/$TaxId" Espionne "" Espionne "nbbox $nbbox" Espionne "nbvide $nbvide" } proc LanceTestLuc {} { foreach f [ListeDesPABs] { puts "traitement $f" TestSelLuc $f } return 1 } proc LanceTests {fres ident {nomgrp ""}} { global ConsRef global LNDG set IdG 0 if {$nomgrp != ""} { set IdG [lsearch $LNDG $nomgrp] incr IdG 2 } # lecture clusters. # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set Lf [LesLignesDuFichier $fres] set nc [string trim [lindex [split [lindex $Lf 0] ":"] 1]] puts "NClusters : $nc" if {$nc < 2} { set g "OneCluster" set fmt "%15s :: %4d | %5d %6d %5s | %5d %6d %5s | %5d" puts "[format $fmt $ident-$g -1 -1 -1 -1 -1 -1 -1 -1]" return } set d 2 for {set i 0} {$i < $nc} {incr i} { set ngr "gr$i" set ne [lindex [split [lindex $Lf $d] "="] 1] if {! $ne} {continue} set id [expr {$d + 1}] set if [expr {$d + $ne}] set Lv {} set SVec 0. set mv 0. set nval 0 for {set j $id} {$j <= $if} {incr j} { set vals [lindex $Lf $j] set listev [split $vals "\t"] set v [lindex $listev 0] lappend Lv $v set Gres($v) $ngr set Vec [lrange $listev 1 end] foreach e $Vec { set mv [expr {$mv + $e}] incr nval } } set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr set d [expr {$if + 2}] } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster set lv [lsort -decreasing -real [array names TNormV]] if {$lv == {}} { puts "\t===> 1 cluster vide !!!" return } set top [set TNormV([lindex $lv 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] set dos [set TNormV([lindex $lv 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] if {! [llength $lv]} { set dos -1 set ne2 0 set le2 {} } if {[ModeI]} {CreeFeaturesScore $ident $nomgrp $lel $le2} # cree tableau t(type de conservation, no de cluster) = nbr residue foreach g [array names ConsRef] { set l [set ConsRef($g)] foreach v $l { if {! [info exists Gres($v)]} {continue} set ng [set Gres($v)] if {[info exists tmp($g,$ng)]} { incr tmp($g,$ng) } else { set tmp($g,$ng) 1 } } } # Pour un type de conservation donne, # - on cherche dans combien de groupes sont contenus les residues consideres # - on prend le nbr total de residus contenus dans ces groupes set Lar [array names tmp] foreach g [array names ConsRef] { set Li [lsearch -all -inline -regexp $Lar $g] set resli {} set cmptr 0 foreach n $Li { set ln [split $n ","] set ng [lindex $ln 1] set nbr [llength [set Tres($ng)]] lappend resli [list $ng $nbr] incr cmptr $nbr } set resli [lsort -index 1 -decreasing -integer $resli] set Comp($g) $resli set LeCmptr($g) $cmptr } # Affiche resultats set fmt "%15s :: %4d | %5d %6d %5s | %5d %6d %5s | %5d" set Ltype [ReordonneTypeCons] if {$nomgrp != ""} {set nomgrp [lindex $Ltype $IdG]} # fait par type # IdenGlob # ======== set gafaire $nomgrp if {$nomgrp == ""} { set gafaire "IdenGlob" set g "IdenGlob" set g2 "ConsGlob" # if {! [llength [set ConsRef($gafaire)]]} {break} set ngrp [llength [set Comp($g)]] set nori [llength [set ConsRef($g)]] set ecar [expr {$nori - [set LeCmptr($g)]}] set pgr [lindex [lindex [set Comp($g)] 0] 0] set emg $nel set dmg [expr {$nori - $nel}] set ncons 0 if {$dmg < 0 && [info exists ConsRef($g2)]} { set lori [set ConsRef($g2)] foreach e $lel { if {[lsearch $lori $e] != -1} {incr ncons} } } puts "[format $fmt $ident-$g $nori $ngrp $ecar $pgr $emg $dmg $top $ncons]" } # EnleveCluster [set Tres($top)] # ConsGlob # ======== set g $nomgrp if {$nomgrp == ""} {set g "ConsGlob"} set ngrp [llength [set Comp($g)]] set nori [llength [set ConsRef($g)]] set ecar [expr {$nori - [set LeCmptr($g)]}] set pgr [lindex [lindex [set Comp($g)] 0] 0] set emg $ne2 set dmg [expr {$nori - $ne2}] set ncons 0 puts "[format $fmt $ident-$g $nori $ngrp $ecar $pgr $emg $dmg $top $ncons]" return } proc LanceTestsBali {Lres args} { global NId NCo NTt NConsDansId NConsDansCo NConsDansTt PABCourant LNDG LConsSA set NId 0 ; set NCo 0 ; set NTt 0 set NConsDansId 0 set NConsDansCo 0 set NConsDansTt 0 set method "dpc" set order "decreasing" set nomgrp "" set relatif 1 foreach {k v} $args { switch $k { "-nomgrp" { if {$v eq {}} {set $v ""} set nomgrp $v } "-method" {set method $v} "-order" {set order $v} "-relatif" {set relatif $v} } } # lecture clusters. # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set i 1 set vtot 0 foreach c $Lres { set ngr "gr$i" set Lv {} set mv 0. set nval 0 foreach ind $c { set listev [lrange $ind 1 end] set v [lindex $ind 0] lappend Lv $v set Gres($v) $ngr foreach e $listev { set mv [expr {$mv + $e}] incr nval incr vtot } } if {! $nval} {continue} set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr incr i } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster set Lclus [lsort -$order -real [array names TNormV]] puts "[join $method +] : $vtot [llength $Lclus]" if {$Lclus == {}} { puts "\t===> 1 cluster vide !!" return 0 } if {[llength $Lclus] == 1} { puts "\t==> Only ONE cluster !" return 0 } set top [set TNormV([lindex $Lclus 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] if {[llength $Lclus] <= 1} { set dos -1 set ne2 0 set le2 {} } else { set dos [set TNormV([lindex $Lclus 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] } set NId $nel set NCo $ne2 set NTt [expr {$nel + $ne2}] set NConsDansId 0 set NConsDansCo 0 set NConsDansTt 0 foreach e $lel { if {$e in $LConsSA} { incr NConsDansId incr NConsDansTt } } foreach e $le2 { if {$e in $LConsSA} { incr NConsDansCo incr NConsDansTt } } return 1 } proc LanceTestsPDB {Lres args} { global NId NCo NConsDansId NConsDansCo PABCourant LNDG ConsRef set method "dpc" set order "decreasing" set nomgrp "" set relatif 1 foreach {k v} $args { switch $k { "-nomgrp" { if {$v eq {}} {set $v ""} set nomgrp $v } "-method" {set method $v} "-order" {set order $v} "-relatif" {set relatif $v} } } set IdG 0 if {$nomgrp ne ""} { set IdG [lsearch $LNDG $nomgrp] incr IdG 2 } # lecture clusters. # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set i 1 foreach c $Lres { set ngr "gr$i" set Lv {} set mv 0. set nval 0 foreach ind $c { set listev [lrange $ind 1 end] set v [lindex $ind 0] lappend Lv $v set Gres($v) $ngr foreach e $listev { set mv [expr {$mv + $e}] incr nval } } if {! $nval} {continue} set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr incr i } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster set Lclus [lsort -$order -real [array names TNormV]] if {$Lclus == {}} { puts "\t===> 1 cluster vide !!" return 0 } if {[llength $Lclus] == 1} { puts "\t==> Only ONE cluster !" return 0 } set top [set TNormV([lindex $Lclus 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] if {[llength $Lclus] <= 1} { set dos -1 set ne2 0 set le2 {} } else { set dos [set TNormV([lindex $Lclus 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] } set LConsSA {} if {[info exists ConsRef($PABCourant,sa)]} { set LConsSA [set ConsRef($PABCourant,sa)] } set LConsNA {} if {[info exists ConsRef($PABCourant,nsa)]} { set LConsNA [set ConsRef($PABCourant,nsa)] } incr NId $nel incr NCo $ne2 if {[land $lel $le2] != {}} { puts "PROBLEME !" puts "Residues in both indetity and Conservation !" return 0 } foreach {a n1 n2} $LConsSA { if {$relatif} { set x1 [CorrespondanceSeqGen $PABCourant $n1] set x2 [CorrespondanceSeqGen $PABCourant $n2] } else { set x1 $n1 set x2 $n2 } if {$x1 eq "" || $x2 eq ""} { puts "$PABCourant $n1 $n2 $x1 $x2" } for {set i $x1} {$i <= $x2} {incr i} { if {$i in $lel} {incr NConsDansId} if {$i in $le2} {incr NConsDansCo} } } return 1 } proc LanceTestsPfam {Lres args} { global NId NCo NTt NConsDansId NConsDansCo NConsDansTt PABCourant LNDG set NId 0 ; set NCo 0 ; set NTt 0 set NConsDansId 0 set NConsDansCo 0 set NConsDansTt 0 set method "dpc" set order "decreasing" set nomgrp "" set relatif 1 foreach {k v} $args { switch $k { "-nomgrp" { if {$v eq {}} {set $v ""} set nomgrp $v } "-method" {set method $v} "-order" {set order $v} "-relatif" {set relatif $v} } } # lecture clusters. # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set i 1 set vtot 0 foreach c $Lres { set ngr "gr$i" set Lv {} set mv 0. set nval 0 foreach ind $c { set listev [lrange $ind 1 end] set v [lindex $ind 0] lappend Lv $v set Gres($v) $ngr foreach e $listev { set mv [expr {$mv + $e}] incr nval incr vtot } } if {! $nval} {continue} set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr incr i } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster set Lclus [lsort -$order -real [array names TNormV]] puts "[join $method +] : $vtot [llength $Lclus]" if {$Lclus == {}} { puts "\t===> 1 cluster vide !!" return 0 } if {[llength $Lclus] == 1} { puts "\t==> Only ONE cluster !" return 0 } set top [set TNormV([lindex $Lclus 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] if {[llength $Lclus] <= 1} { set dos -1 set ne2 0 set le2 {} } else { set dos [set TNormV([lindex $Lclus 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] } set LConsSA {} foreach {a x1 x2} [set ConsRef(${PABCourant},sa)] { for {set i $x1} {$i <= $x2} {incr i} { lappend LConsSA $i } } if {0 && $method eq "Norm"} { set lv [lsort -real -decreasing -index 1 $::ListeScore] puts "[join [lrange $lv 0 20] \n]" puts "LConsSA $LConsSA" puts "lel $lel" } set LConsNA {} foreach {a x1 x2} [set ConsRef(${PABCourant},nsa)] { for {set i $x1} {$i <= $x2} {incr i} { lappend LConsNA $i } } if {[land $lel $le2] != {}} { puts "PROBLEME !" puts "Residues in both indetity and Conservation !" return 0 } set NId $nel set NCo $ne2 #set NTt [expr {$nel + $ne2}] set NTt $nel set NConsDansId 0 set NConsDansCo 0 set NConsDansTt 0 #puts "lel $lel" #puts "lcsa $LConsSA" foreach e $lel { if {$e in $LConsSA} { incr NConsDansId incr NConsDansTt } if {$e in $LConsNA} { incr NConsDansCo incr NConsDansTt } } if {0} { foreach e $le2 { if {$e in $LConsNA} {incr NConsDansCo} } } return 1 } proc LanceToutPourUn {Nom {Type ""}} { set Fichier "[RepertoireDuGenome]/SortieProg" AppendAuFichier $Fichier "$Nom $Type" if {[regexp -nocase "nuc" $Type]} { CreateRetinalTargetsPourUnNuc $Nom InformePourUnNuc $Nom } if {[regexp -nocase "prot" $Type]} { CreateRetinalTargetsPourUneProt $Nom InformePourUneProt $Nom } RetrievePourUn $Nom } proc LanceVerifLongSqMSF {} { foreach pab [ListeDesPABs] { puts "traite $pab" set file [file join [RepertoireDuGenome] "msf_nature" "$pab"] VerifLongSqMSF $file } return 1 } proc LanceurCluspack {File {Type coordinates} {Model dpc} {Method kmeans} {Dist 0.001} {NbGr -1} args} { # OBLIGATOIRE : # ------------- # -dt=coordinates|alignment|distances|similarities # -nbc=secator|dpc|aic|bic|number number=3 pour ordali # -cm=ward|kmeans|bionj|mm # OPTIONS : # --------- # -fd=x : filtering_distance # -wc : write coordinates" # -dt1 ou dt2 : density1 ou -density2 # NOTE : mixturemodel+aic -> pas de dist ! if {$Dist ne ""} {set filter "-fd=$Dist"} {set filter ""} if {$Model eq "secator" && $Method eq "kmeans"} {set Method "ward"} if {$Model eq "dpc" && $NbGr > -1} {set Model $NbGr} set Commande "[CluspackExe] $File -dt=$Type -nbc=$Model -cm=$Method $filter $args" catch {eval exec $Commande} return } proc LanceurGOAnno {Nom} { set RepertoireGOAnno "[RepertoireDuGenome]/GeneOntology" if {! [file exists $RepertoireGOAnno]} {file mkdir $RepertoireGOAnno} GOAnalyse "" "[RepertoireDuGenome]/annotation/$Nom.msf" "[RepertoireDuGenome]/annotation/$Nom.clust" "[RepertoireDuGenome]/GeneOntology/$Nom.xml" $Nom set Fichier1 "[RepertoireDuGenome]/annotation/$Nom.msf" set Fichier2 "[RepertoireDuGenome]/annotation/$Nom.clust" file delete -force $Fichier1 file delete -force $Fichier2 } proc LanceurMacsim {Fichier} { set pab [file rootname $Fichier] set Fichier2 "$pab.blocks" set Fichier3 "tmp_macsim" set Commande "/home/julie/macsim_clustering/macsim_new.tcsh $Fichier $Fichier2 > $Fichier3" eval exec $Commande if {[file exists $Fichier3]} { set LLignes [LesLignesDuFichier $Fichier3] foreach l $LLignes { if {! [regexp "GCG" $l]} {continue} set nb [string range [lindex $l 3] 1 7] foreach file [glob -nocomplain $nb*] { file delete -force $file } file delete -force $Fichier.tfa file delete -force $Fichier3 } } return 1 } proc LargeurDe {w} { global Memo return [set Memo(LargeurDe$w)] } proc LastColorPfamInMacsims {FileMacsimsXml} { package require tdom set FileMacsimsXml [TheTrueMacsimsFile $FileMacsimsXml] set LesColor {} set fh [open $FileMacsimsXml "r"] dom parse -channel $fh doc close $fh $doc documentElement root foreach seq [$root selectNodes "//sequence"] { foreach noeud_PFAM [$seq selectNodes ".//fitem\[ftype=\"PFAM-A\"\]"] { lappend LesColor [$noeud_PFAM selectNodes "string(./fcolor)"] } } if {$LesColor == {} } { $doc delete return "" } set LesColor [lsort -unique -integer $LesColor] set LastColor [lindex $LesColor end] $doc delete return $LastColor } proc LastVersionAffy {} { return "na34" } proc LaunchOrApplyDrawBlast {w} { set FichierBlast [AskOptionsDeDrawBlast ask $w FichierBlast ] set BanqueId [AskOptionsDeDrawBlast ask $w BanqueId ] set NbSubjectMax [AskOptionsDeDrawBlast ask $w NbSubjectMax ] set ExpectMax [AskOptionsDeDrawBlast ask $w ExpectMax ] set IdMin [AskOptionsDeDrawBlast ask $w IdMin ] set LargeurFenetre [AskOptionsDeDrawBlast ask $w LargeurFenetre ] set FrameCanvaMosaic [AskOptionsDeDrawBlast ask $w FrameCanvaMosaic ] set HauteurFenetreMosaic [AskOptionsDeDrawBlast ask $w HauteurFenetreMosaic ] set FrameCanvaMapping [AskOptionsDeDrawBlast ask $w FrameCanvaMapping ] set HauteurFenetreMapping [AskOptionsDeDrawBlast ask $w HauteurFenetreMapping ] set TailleMaxDUneRegionNonAlignee [AskOptionsDeDrawBlast ask $w TailleMaxDUneRegionNonAlignee] if {![file exists $FichierBlast]} {return} if {![AskBlast $FichierBlast Exists]} {AskBlast unset} DrawMosaic $FichierBlast $ExpectMax $NbSubjectMax $IdMin "" $LargeurFenetre $HauteurFenetreMosaic $FrameCanvaMosaic $w DrawMapping $FichierBlast $BanqueId $ExpectMax $IdMin $TailleMaxDUneRegionNonAlignee $LargeurFenetre $HauteurFenetreMapping $FrameCanvaMapping $w return } proc LaunchPfamScan {n s} { global Rpfm set seq ">$n $s " set Rpfm($n) [PfamScanWebService -seq $seq] return } proc LaunchPipesForGroups {putInParaT putOrthoT {debut ""} {fin ""}} { global RepertoireDuGenome upvar $putInParaT putInPara upvar $putOrthoT putOrtho set listePAB [ListeDesPABs2] if {$debut==""} {set debut 0} if {$fin==""} {set fin [llength $listePAB]} #melange ortho/para pour un meme alignement (version pour AnalyseBlast) array set PABPourPipe {} foreach PAB $listePAB { set infosPara {} set infosOrtho {} #if {[info exists putInPara($PAB)]} {set infosPara $putInPara($PAB)} if {[info exists putOrtho($PAB)]} {set infosOrtho $putOrtho($PAB)} if {$infosPara=="" && $infosOrtho==""} {continue} set PABPourPipe($PAB) [concat $infosPara $infosOrtho] } #preparatifs pour les alignements via pipealign ################################################ #creation du repertoiretfasdescopainsAdd if {![file exists "$RepertoireDuGenome/tfasdescopainsAdd/"]} { file mkdir "$RepertoireDuGenome/tfasdescopainsAdd/" } #creation de fastas avec toutes les sequences associées au maitre du groupe #dans le repertoire $RepertoireDuGenome/tfasdescopainsAdd foreach {PABs val} [array get PABPourPipe] { set filename "$RepertoireDuGenome/tfasdescopainsAdd/$PABs" set FICOUT [open $filename "w"] foreach PAB $val { set FICIN [open "$RepertoireDuGenome/prottfa/$PAB" "r"] while {[gets $FICIN line]!=-1} { puts $FICOUT $line } close $FICIN } close $FICOUT puts "create $RepertoireDuGenome/tfasdescopainsAdd/$PABs" } #cree le repertoire pour feinter le pipe #(il se fera sur les seqs absentes du pas touche seulement) if {![file exists "$RepertoireDuGenome/pastouche/"]} { file mkdir "$RepertoireDuGenome/pastouche/" } #creation des fichiers pas touche for {set i $debut} {$i<$fin} {incr i} { set PAB [lindex $listePAB $i] if {![info exists PABPourPipe($PAB)] && ![file exists "$RepertoireDuGenome/pastouche/$PAB"]} { set FICOUT [open "$RepertoireDuGenome/pastouche/$PAB" "w"] close $FICOUT puts "create $PAB" } if {[info exists PABPourPipe($PAB)] && [file exists "$RepertoireDuGenome/pastouche/$PAB"]} { file delete "$RepertoireDuGenome/pastouche/$PAB" puts "delete $PAB" } } #lancement des alignements ############################# ############### ## rq : formatdb pour la banque avec option -o T ## sinon marche pas # Charge les options par defaut LesDefautsDuPipe # Parametre les options #LesDefautsDuPipe "File,file" $filename LesDefautsDuPipe "Etapes,blast" 0 LesDefautsDuPipe "Blast,d" "banques/ORTHObis" LesDefautsDuPipe "Filter,maxseq" 200 LesDefautsDuPipe "Filter,expect" 0.001 #LesDefautsDuPipe "Project,project" "addSeq" # Lance le pipe silencieusement global EspionneNon if {[info exists EspionneNon]} { set ancienEspionneNon $EspionneNon } else {set ancienEspionneNon 0} set EspionneNon 1 if {[catch {PipeGrid} Message]} { set EspionneNon $ancienEspionneNon Espionne "Error from pipealign. Message follows \n$Message" } set EspionneNon $ancienEspionneNon } proc LaunchPipesForInParas {tableT {debut ""} {fin ""}} { global RepertoireDuGenome upvar $tableT table set listePAB [ListeDesPABs2] if {$debut==""} {set debut 0} if {$fin==""} {set fin [llength $listePAB]} #melange ortho/para pour un meme alignement (version pour AnalyseBlast) array set PABPourPipe {} foreach {key val} [array get table] { set lists [split $key ","] set laListe [split [lindex $lists 0] " "] foreach PAB $laListe { if {[info exists PABPourPipe($PAB)]} {continue} set PABPourPipe($PAB) $laListe } } #preparatifs pour les alignements via pipealign ################################################ #cree le repertoire pour feinter le pipe #(il se fera sur les seqs absentes du pas touche seulement) if {![file exists "$RepertoireDuGenome/pastouche/"]} { file mkdir "$RepertoireDuGenome/pastouche/" } #creation des fichiers pas touche for {set i $debut} {$i<$fin} {incr i} { set PAB [lindex $listePAB $i] if {![info exists PABPourPipe($PAB)] && ![file exists "$RepertoireDuGenome/pastouche/$PAB"]} { set FICOUT [open "$RepertoireDuGenome/pastouche/$PAB" "w"] close $FICOUT puts "create $PAB" } if {[info exists PABPourPipe($PAB)] && [file exists "$RepertoireDuGenome/pastouche/$PAB"]} { file delete "$RepertoireDuGenome/pastouche/$PAB" puts "delete $PAB" } } #lancement des alignements ############################# ############### ## rq : formatdb pour la banque avec option -o T ## sinon marche pas # Charge les options par defaut LesDefautsDuPipe # Parametre les options #LesDefautsDuPipe "File,file" $filename LesDefautsDuPipe "Etapes,blast" 0 LesDefautsDuPipe "Blast,d" "banques/ORTHObis" LesDefautsDuPipe "Filter,maxseq" 200 LesDefautsDuPipe "Filter,expect" 1 #LesDefautsDuPipe "Project,project" "addSeq" # Lance le pipe silencieusement global EspionneNon if {[info exists EspionneNon]} { set ancienEspionneNon $EspionneNon } else {set ancienEspionneNon 0} set EspionneNon 1 if {[catch {PipeGrid} Message]} { set EspionneNon $ancienEspionneNon Espionne "Error from pipealign. Message follows \n$Message" } set EspionneNon $ancienEspionneNon } proc LaunchPipesForSpecificList {{laListe ""} {debut ""} {fin ""}} { global RepertoireDuGenome set listePAB [ListeDesPABs2] if {$debut==""} {set debut 0} if {$fin==""} {set fin [llength $listePAB]} array set PABPourPipe {} if {$laListe==""} { set PABPourPipe(XTRO01770) [list "XTRO05067" ] } #preparatifs pour les alignements via pipealign ################################################ #creation du repertoiretfasdescopainsAdd if {![file exists "$RepertoireDuGenome/tfasdescopainsAdd/"]} { file mkdir "$RepertoireDuGenome/tfasdescopainsAdd/" } #creation de fastas avec toutes les sequences associées au maitre du groupe #dans le repertoire $RepertoireDuGenome/tfasdescopainsAdd foreach {PABs val} [array get PABPourPipe] { set filename "$RepertoireDuGenome/tfasdescopainsAdd/$PABs" set FICOUT [open $filename "w"] foreach PAB $val { set FICIN [open "$RepertoireDuGenome/prottfa/$PAB" "r"] while {[gets $FICIN line]!=-1} { puts $FICOUT $line } close $FICIN } close $FICOUT puts "create $RepertoireDuGenome/tfasdescopainsAdd/$PABs" } #cree le repertoire pour feinter le pipe #(il se fera sur les seqs absentes du pas touche seulement) if {![file exists "$RepertoireDuGenome/pastouche/"]} { file mkdir "$RepertoireDuGenome/pastouche/" } #creation des fichiers pas touche for {set i $debut} {$i<$fin} {incr i} { set PAB [lindex $listePAB $i] if {![info exists PABPourPipe($PAB)] && ![file exists "$RepertoireDuGenome/pastouche/$PAB"]} { set FICOUT [open "$RepertoireDuGenome/pastouche/$PAB" "w"] close $FICOUT puts "create $PAB" } if {[info exists PABPourPipe($PAB)] && [file exists "$RepertoireDuGenome/pastouche/$PAB"]} { file delete "$RepertoireDuGenome/pastouche/$PAB" puts "delete $PAB" } } #lancement des alignements ############################# ############### ## rq : formatdb pour la banque avec option -o T ## sinon marche pas # Charge les options par defaut LesDefautsDuPipe # Parametre les options #LesDefautsDuPipe "File,file" $filename LesDefautsDuPipe "Etapes,blast" 0 LesDefautsDuPipe "Blast,d" "banques/ORTHObis" LesDefautsDuPipe "Filter,maxseq" 200 LesDefautsDuPipe "Filter,expect" 0.001 #LesDefautsDuPipe "Project,project" "addSeq" # Lance le pipe silencieusement global EspionneNon if {[info exists EspionneNon]} { set ancienEspionneNon $EspionneNon } else {set ancienEspionneNon 0} set EspionneNon 1 if {[catch {PipeGrid} Message]} { set EspionneNon $ancienEspionneNon Espionne "Error from pipealign. Message follows \n$Message" } set EspionneNon $ancienEspionneNon } proc Lav2Maf {BlastZFile TFAFile1 TFAFile2 MafFile} { ### Execution du programme lav2maf ### # lav2maf transforme un fichier blastz en un fichier maf # # TFAFile1 et TFAFile2 sont les fichier de seq qui ont ete utilises pour lancer blastz # if {![file exists $BlastZFile] || ![file exists $TFAFile1] || ![file exists $TFAFile2]} { Espionne "At least one lav2maf input file does not exists" return } #set Commande "exec [PATH lav2maf] $BlastZFile $TFAFile1 $TFAFile2 > $MafFile" set Commande "exec lav2maf $BlastZFile $TFAFile1 $TFAFile2 > $MafFile" if {[catch {eval $Commande} Message]} {Espionne $Message;return} return $MafFile } proc LbgiUrl {} { set LbgiUrl "http://www.lbgi.fr" return $LbgiUrl } proc LeBilanTriePourJean {{Fichier ""}} { global RepertoireDuGenome set RepBilan "$RepertoireDuGenome/bilan_xhda" if {! [regexp "/" $Fichier]} { set Fichier "$RepBilan/$Fichier" } set Fichier [LectureBilanHDACroises LesFamilles LesOrgCibles Bilan $Fichier] if {$Fichier=={}} { return "" } set LesXs $LesFamilles set LesYs $LesOrgCibles set Ordre "SampledBAE" set LesGenoTries [LesGenomesDansLeBonOrdre $Ordre] foreach Y $LesYs { set JExiste($Y) 1 } foreach G $LesGenoTries { set Y [string toupper [Glossaire $G Court]] if { ! [info exists JExiste($Y)]} { continue } lappend LesYsTries $Y } set Titre "X-HDA sorted by Organisms ($Ordre)" set Fichier [File tail $Fichier] return [DessineBilanHDACroises $LesXs $LesYsTries Bilan $Fichier] } proc LeBonOrdrePourLesSignaux {{NouvelOrdre ""} {ASauver ""}} { global LeBonOrdrePourLesSignaux global RepertoireDuGenome set FichierOrdreDesSignaux "$RepertoireDuGenome/signaux/ordredessignaux" if {$NouvelOrdre!=""} { set LeBonOrdrePourLesSignaux $NouvelOrdre } if {$ASauver=="ASauver"} { SauveLesLignes $LeBonOrdrePourLesSignaux dans $FichierOrdreDesSignaux } if {[info exists LeBonOrdrePourLesSignaux]} { return $LeBonOrdrePourLesSignaux } if { ! [file exists $FichierOrdreDesSignaux]} { return {} } set LeBonOrdrePourLesSignaux [LesLignesDuFichier $FichierOrdreDesSignaux] return $LeBonOrdrePourLesSignaux } proc LeChampDesLignesEMBL {LesLignes Champ} { set Sortie {} foreach Ligne $LesLignes { if {[regexp "^$Champ" $Ligne]} { lappend Sortie $Ligne } } return $Sortie } proc LeChampsDeLaPageGenBank {PageGenBank NOMDUCHAMPS} { global RepertoireDuGenome set LaPageGenBank [split $PageGenBank "\n"] set SuisJeSurLeBonChamps 0 set LAiJeVu 0 set LesInfosDuChamps {} foreach Ligne $LaPageGenBank { if {!$SuisJeSurLeBonChamps && $LAiJeVu} {break} if { $SuisJeSurLeBonChamps == 1 && [regexp " " $Ligne]} { lappend LesInfosDuChamps " $Ligne" } else { set SuisJeSurLeBonChamps 0 } if { [regexp "$NOMDUCHAMPS " $Ligne] && $LAiJeVu == 0} { lappend LesInfosDuChamps $Ligne set LAiJeVu 1 set SuisJeSurLeBonChamps 1 } } return "$LesInfosDuChamps" } proc LeChampsDeLaPageProteine {PageProteine NOMDUCHAMPS} { global RepertoireDuGenome set LaPageProteine [split $PageProteine "\n"] set SuisJeSurLeBonChamps 0 set LesInfosDuChamps {} foreach Ligne $LaPageProteine { if {![regexp "^$NOMDUCHAMPS " $Ligne] } {continue} lappend LesInfosDuChamps $Ligne } return $LesInfosDuChamps } proc LeClusterXHda {Query {Quoi ""} {FichierCluster ""}} { global RepertoireDuGenome global LeClusterXHda if {$Quoi==""} { set Quoi "LesMembres" } if {[info exists LeClusterXHda(Query)] && [set LeClusterXHda(Query)]==$Query} { if {[info exists LeClusterXHda($Quoi)]} { return [set LeClusterXHda($Quoi)] } } if {$FichierCluster==""} { set LesFDPC [glob -nocomplain "$RepertoireDuGenome/xhda/*.dpc"] set FichierCluster [ChoixParmi $LesFDPC] if {$FichierCluster==""} { return {} } } set OnVeutToutLeMonde 0 set OnVeutToutLeMondeAvecGroupe 0 set OutQuery 0 if {$Query=="OnVeutToutLeMonde"} { set OnVeutToutLeMonde 1 } if {$Query=="OnVeutToutLeMondeAvecGroupe"} { set OnVeutToutLeMondeAvecGroupe 1 } set LeGroupe {} set OnLeTient 0 set Numero "" foreach Ligne [LesLignesDuFichier $FichierCluster] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster [0-9]+|^unclustered seq} $Ligne]} { if {$OnLeTient} { break } set Numero "" scan $Ligne "%s %s" Groupe Numero set Taille [IntegerApres "size=" dans $Ligne] if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 } set LeGroupe {} if {$Query==$Numero} { set OnLeTient 1 } continue } scan $Ligne "%s" Access if {[string toupper $Access]==[string toupper $Query]} { set OnLeTient 1 if {$OutQuery} { continue } } lappend ToutLeMondeAvecGroupe "$Access $Numero" lappend ToutLeMonde $Access lappend LeGroupe $Access } if { ! $OnLeTient } { set LeGroupe {} } set LeClusterXHda(Numero) $Numero set LeClusterXHda(LesMembres) $LeGroupe set LeClusterXHda(Taille) $Taille set LeClusterXHda(Query) $Query if {$Quoi=="Numero" } { return $Numero } if {$Quoi=="Taille" } { return $Taille } if {$OnVeutToutLeMonde} { return $ToutLeMonde } if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe } if {$Groupe=="unclustered"} { return $ToutLeMonde } else { return $LeGroupe } } proc LeContig {IdDuContig} { if {[regexp {_[0-9]*} $IdDuContig]} { regexp -nocase {([a-z0-9]*):([0-9a-z]*)_([0-9]*)} $IdDuContig tmp Chromosome Access Fragment } else { regexp -nocase {([a-z0-9]*):([0-9a-z]*)} $IdDuContig tmp Chromosome Access set Fragment "" } set NbFragment 0 if {$Fragment != ""} {set NbFragment [Base10 $Fragment]} return [list $Chromosome $Access $Fragment $NbFragment] } proc LeDecompte {{Quoi ""}} { set LeDecompte {} set CumulMutants 0 set CumulVPPCRs 0 foreach Nom [ListeDesPABs] { set Alias [Alias $Nom] set LesMutants [LesMutantsDe $Nom] set NbMutants [llength $LesMutants] set LesVPPCRs [LesVirtualPPCRsDuPGS $Nom] foreach VPPCR $LesVPPCRs { if {[info exists DejaVu($VPPCR)]} { continue } incr CumulVPPCRs } set NbVPPCRs [llength $LesVPPCRs] set SpineTask [SpineTask $Nom] set Owner [ExtraitInfo $Nom "Owner"] incr CumulMutants $NbMutants set Def [DefinitionRapide $Nom] lappend LeDecompte "" set Ligne [format "%8s %-15s %-4s %2d %2d %-30s %s" $Nom [string range $Alias 0 15] $SpineTask $NbMutants $NbVPPCRs $Owner $Def] lappend LeDecompte $Ligne lappend LeDecompteDuOwner($Owner) $Ligne } lappend LeDecompte "" lappend LeDecompte " $CumulMutants Sauvages et mutants" lappend LeDecompte " $CumulVPPCRs produits PCR" if {[regexp "ParOwner" $Quoi]} { regsub "ParOwner" $Quoi "" Quoi set LaPageOwner {} foreach Owner [lsort [array names LeDecompteDuOwner]] { LConcat LaPageOwner $LeDecompteDuOwner($Owner) } set Decompte [join $LaPageOwner "\n"] } else { set Decompte [join $LeDecompte "\n"] } if {$Quoi=="GetText"} { return $Decompte } if {$Quoi=="Show"} { return [AfficheVariable $Decompte "" "XbgsSummary"] } return $LeDecompte } proc LeDescriptif {Access {Nom ""} {Texte ""}} { global LesDescriptifs global NomDesDescriptifsEnMemoire Wup "if Texte isn't empty it returns the old value and sets the new one" if {$Texte!=""} { if {[info exists LesDescriptifs($Access)]} { set Old [set LesDescriptifs($Access)] set LesDescriptifs($Access) $Texte set LesDescriptifs([string toupper $Access]) $Texte return $Old } } if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] } set FichierDescriptif "[RepertoireDuGenome]/descriptifs/$Nom" if {$Nom!="" && [file exists $FichierDescriptif]} { if {[info exists NomDesDescriptifsEnMemoire] && $NomDesDescriptifsEnMemoire==$Nom} { return "$Access (no description available in descriptifs/$Nom)" } set LesDescriptifs(${Nom}_isloaded) $Nom if {[info exists LesDescriptifs]} { unset LesDescriptifs } set LeDescDuPAB [LeDescriptifDuPAB $Nom] set LesDescriptifs($Nom) $LeDescDuPAB foreach Ligne [LesLignesDuFichier $FichierDescriptif] { set iEgal [string first "=" $Ligne] set AccessLu [string range $Ligne 0 [expr $iEgal -1]] set Descript [string range $Ligne [expr $iEgal +1] end] set LesDescriptifs($AccessLu) $Descript set LesDescriptifs([string toupper $AccessLu]) $Descript set Id [StringApres "ID:" dans $Ligne] set ID [string toupper $Id] regsub $AccessLu $Descript $Id Descript if { ! [info exists LesDescriptifs($Id)] } { set LesDescriptifs($Id) $Descript } if { ! [info exists LesDescriptifs($ID)] } { set LesDescriptifs($ID) $Descript } } set NomDesDescriptifsEnMemoire $Nom if {$Texte!=""} { #rR attention le descriptif du Id n'est pas mis à jour !!!!!!!!!!! if {[info exists LesDescriptifs($Access)]} { set Old [set LesDescriptifs($Access)] set LesDescriptifs($Access) $Texte set LesDescriptifs([string toupper $Access]) $Texte return $Old } } if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] } if {$Nom==$Access} { return [LeDescriptifDuPAB $Nom] } return "$Access (no description)" } } proc LeDescriptifDuPAB {Nom} { set OS [NotreOS] set OC [NotreOC] set OX [NotreOX] set DE [Definition $Nom] set GN [NomDeGene $Nom] set ID $Nom set AC $Nom set Descriptif "$Nom OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX" return $Descriptif } proc LeFichierDesSignaux {{Choix ""}} { set Choix [regexp -nocase {^Cho} $Choix] if {$Choix} { return [lindex [LesFichiersDeType "Signaux"] 0] } set Fichier "[RepertoireDuGenome]/signaux/signaux.tfa" if {[file exists $Fichier]} { return $Fichier } set Fichier "/genomics/link/ProGS/signaux/signaux.tfa" if {[file exists $Fichier]} { return $Fichier } FaireLire "I cna't find the signel file ... Please browse for it." return [ButineArborescence "All" "./"] } proc LeFichierSDT_ActiChip {{FichierSDT ""}} { Wup "Permet de faire un fichier d annotation lisible pour le programme Acuity Axon" Wup "Ce type de fichier a pour extension .sdt et est majoritairement separe par des tabulations" Wup "Le .sdt est un fichier qui permet d ajouter des annotations" #Attention il faut une reference unique qui sera toujours utilise (ex: id) #On peut prendre l AccessGscope #L ID unique doit etre en premiere position if { $FichierSDT==""} { set FichierSDT "[RepertoireDuGenome]/GalFile/ActiChip2.1/ActiChip2.1_juillet05.sdt" } #1- On recupere la liste des ID d oligos (ex: ACT0001_Oligo12_BC000445) set LesPABs [InterrogeLeGalFile_ActiChip LesIDs] #Espionne "$LesPABs" #Espionne "Taille [llength $LesPABs]" set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set RepNuctfa "[RepertoireDuGenome]/nuctfa" #2- Les donnees ou nom des champs utilises set Header [list "ID" "Gscope_Access" "Protein_Access" "Protein_Definition" "Protein_size" "Genbank_Access" "Genbank_size" "Chromosome" "CytoBand" "RefSeq_Id" "RefSeq_Definition" "Uniseq_Access" "Unigene_Id" "Unigene_Definition" "Tm" "GC" "Begin" "End" "RefSeq_NbDetected" "RefSeq_AccDetected" "Unigene_NbDetected" "Unigene_AccDetected" "GO_Function" "GO_Process" "GO_Component"] AppendAuFichier $FichierSDT [join "$Header" "\t"] #3- Recuperation des informations foreach NomOligo $LesPABs { if {$NomOligo==""} {continue} #3-1 Les repertoires de design set DirOligo1 "[RepertoireDuGenome]/Probes/RefSeqBLAST3" set DirOligo2 "[RepertoireDuGenome]/Probes/UnigeneBLAST3" set OtherDirOligo1 "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" set OtherDirOligo2 "[RepertoireDuGenome]/Probes/NewUnigeneBLAST3" set PAB "" #3-2 On disseque le NomOligo = PAB_NumeroOligo_AccessDuDesign if {[regexp {(ACT[0-9]{4})_Oligo[0-9]+} $NomOligo tmp PAB]} { if {$PAB=="" || ! [regexp "^ACT" $PAB]} { set PAB "" continue } } elseif {[regexp {(NM[0-9]+)_Oligo[0-9]+} $NomOligo tmp PAB]} { if {$PAB=="" || ! [regexp "^NM" $PAB]} { set PAB "" continue } } #3-3 On test le repertoire du design # On psotionne les fichier du design if {! [file exists "$DirOligo1/${PAB}.masked"]} { set DirOligo1 $OtherDirOligo1 set DirOligo2 $OtherDirOligo2 } if {! [file exists "$DirOligo1/${PAB}.masked"]} { continue } #3-3-1 Fichier pour RefSeq set FichierOligo1 "$DirOligo1/${PAB}.oligo" set FichierOligo1 "$DirOligo1/${PAB}.selection" set FichierOligo1 "$DirOligo1/${PAB}.croisee" if { [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo Taille]==""} { set FichierOligo1 "$DirOligo1/${PAB}.selection" if {[InterrogeInfoDeLOligo $FichierOligo1 $NomOligo Taille]==""} { set FichierOligo1 "$DirOligo1/${PAB}.oligo" } } #3-3-2 Fichier pour Unigene set FichierOligo2 "$DirOligo2/${PAB}.oligo" #set FichierOligo2 "$DirOligo2/${PAB}.selection" set Gscope_Access "" set ID "" set Protein_Access "" set Definition "" set Protein_size "" set Genbank_Access "" set Genbank_size "" set Chromosome "" set CytoBand "" set RefSeq_Access "" set RefSeq_Definition "" set Uniseq_Access "" set Unigene_Id "" set Unigene_Definition "" set Tm "" set GC "" set Begin "" set End "" set RefSeq_NbDetected "" set RefSeq_AccDetected "" set Unigene_NbDetected "" set Unigene_AccDetected "" set LesInfos "" set GO_Function "" set GO_Process "" set GO_Component "" set Gscope_Access $PAB #3-4 Les donnnees des oligos #3-4-1 Access utilise lors du design # un mRNA ou sequence originale (nuctfa) set Query "$RepmRNA/$PAB" if {[file exists $Query]} { set Genbank_Access [AccessDeLaBoite $PAB mRNA] } else { set Query "$RepNuctfa/$PAB" if {[file exists $Query]} { set Genbank_Access [AccessDuTFADumRNA $Query] } else {set Genbank_Access "$PAB"} } #3-4-2 Taille de la sequence query du deisgn set Genbank_size [string length [join [QueLaSequenceDuFichierTFA $Query] ""]] #set Genbank_Definition [AccessDeLaBoite $PAB mRNA Definition] #3-4-3 Access et definition et taille de la proteine correspondante set Protein_Access [AccessDeLaBoite $PAB protein] set Protein_Definition [AccessDeLaBoite $PAB protein Definition] set Protein_size [InterrogeBestProteinAndmRNAForeachOrga Access $Protein_Access Taille] #3-4-4 Definition de secours (mRNA ou access) if { $Protein_Definition == "" && $Genbank_Access != ""} { set Protein_Definition [AccessDeLaBoite $PAB mRNA Definition] if { $Protein_Definition == ""} { set Protein_Definition [lrange [DefDeAcc $Genbank_Access genbankfull Def] 1 end] } } #3-4-5 Les Infos de l oligo set ID $NomOligo set OligoEquivalent [NomOligoEquivalent $PAB $NomOligo $DirOligo1 $DirOligo2] #set LaSequence [InterrogeInfoDeLOligo $FichierOligo $NomOligo Sequence] #set TailleOligo [InterrogeInfoDeLOligo $FichierOligo $NomOligo Taille] #set ExpTm [InterrogeInfoDeLOligo $FichierOligo $NomOligo ExpTm] # Generales set GC [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo GC] set Tm [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo Tm] set Begin [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo Debut] set End [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo Fin] # Specifique a RefSeq set RefSeq_NbDetected [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo NbCandidats] set RefSeq_AccDetected [join [InterrogeInfoDeLOligo $FichierOligo1 $NomOligo LesCandidats] " "] regsub -all "RSHUM:NM" $RefSeq_AccDetected "NM_" RefSeq_AccDetected regsub -all "RSHUM:NG" $RefSeq_AccDetected "NG_" RefSeq_AccDetected # Specifique a Unigene set Unigene_NbDetected [InterrogeInfoDeLOligo $FichierOligo2 $OligoEquivalent NbCandidats] set Unigene_AccDetected [join [InterrogeInfoDeLOligo $FichierOligo2 $OligoEquivalent LesCandidats] " "] regsub -all "UG:" $Unigene_AccDetected "" Unigene_AccDetected #3-4-6 Access RefSeq set RefSeq_Id [ReturnBestHitFromLogFile $PAB $DirOligo1] set RefSeq_Definition [ReturnDefinitionFromBestHitFromLogFile $RefSeq_Id] regsub -all "RSHUM:NM" $RefSeq_Id "NM_" RefSeq_Id regsub -all "RSHUM:NG" $RefSeq_Id "NG_" RefSeq_Id #3-4-7 Access Unigene set Uniseq_Access [ReturnBestHitFromLogFile $PAB $DirOligo2] set Unigene_Definition [ReturnDefinitionFromBestHitFromLogFile $Uniseq_Access] set BestBanqueUg [LeUnigeneDeUniseq $Uniseq_Access] if {$BestBanqueUg==""} { #On essaie avec les nouveaux blastn Unigene set Unigene_Id [InterrogeLesAccessUnigeneDesPABs $PAB UnigeneId] if {$Unigene_Id == ""} { set Unigene_Id "No Unigene Id associated" } else { set Unigene_Definition [ReturnDefinitionFromBestHitFromLogFile $Unigene_Id] } } regsub -all "UG:" $Uniseq_Access "" Uniseq_Access #3-4-8 L ontology (GPO) set FileGOXML "[RepertoireDuGenome]/GeneOntology/${PAB}.xml" set LesTypes [AskGOAnalyse $FileGOXML Methode GPO LesTypes] if {$LesTypes != {}} { foreach Type $LesTypes { set LesGOs [AskGOAnalyse $FileGOXML Methode GPO Type $Type LesGO] switch -regexp -- $Type { "function" {set GO_Function $LesGOs} "process" {set GO_Process $LesGOs} "component" {set GO_Component $LesGOs} } #set Def [AskGOAnalyse $FileGOXML Type $Type GO $GO Definition] #set TexteType [format "%-9s" $Type] #Espionne "$TexteType $GO $Def" #lappend LeTexte "$TexteType $GO $Def" #lappend LesGOAvecLiens $GO } } #Espionne "F $GO_Function -- P $GO_Process -- C $GO_Component" #3-4-8 Localisation genomique (Homo sapiens) set FichiermRNALoc "[RepertoireDuGenome]/Localisation/mRNAHsapLocalisation_Human" if {[InterrogeLocalisation $FichiermRNALoc Nom $PAB] != ""} { set InfoLoc "" set LesLocalisations "" set Localisation "" set IdDeRef 0.95 set PIdDeRef [format "%.1f" [expr $IdDeRef * 100]] set LesLocalisations [InterrogeLocalisation $FichiermRNALoc Nom $PAB] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] set Warning "" if {$InfoLoc != "MonoLoc"} {set Warning $InfoLoc} foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation 20] != "BestLoc" && [lindex $LaLocalisation 20] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9] set CytoBand [lindex $LaLocalisation 19] #set D [lindex $LaLocalisation 10] #set F [lindex $LaLocalisation 11] #set Sens [lindex $LaLocalisation 12] #set Contig [lindex $LaLocalisation 13] set Id [lindex $LaLocalisation 6] set PId [format "%.1f" [expr $Id * 100]] if {$Id < $IdDeRef} { if {$Warning != ""} {set Warning "$Warning ;"} set Warning "$Warning Id < $PIdDeRef%" } lappend Localisation "$Chromosome" } set Localisation [join $Localisation " ; "] if {$Warning != ""} {append Localisation $Warning} } #3-5 Stockage des donnees recuperees foreach Info $Header { lappend LesInfos [set $Info] } AppendAuFichier $FichierSDT [join "$LesInfos" "\t"] } return "" } proc LeFichierSDT_Ontario {{Fichier ""} {FichierSDT ""}} { Wup "Permet de faire un fichier d annotation lisible pour le programme Acuity de Axon" Wup "Ce type de fichier a pour extension .sdt et est majoritairement separe par des tabulations" Wup "Le .sdt est un fichier qui permet d ajouter des annotations" ############################## #GAL FILE is BLOCK ROW COLUMN# ############################## set RepPuceOntario "[RepertoireDuGenome]/Autres_Puces/Ontario" set RepGalFile "$RepPuceOntario/GalFile" if {$Fichier ==""} {set Fichier "$RepGalFile/SS-H19k7_ActiChip2_0.gal"} if {$FichierSDT==""} {set FichierSDT "$RepGalFile/SS-H19k7_ActiChip2_0.sdt"} if {! [file exists $Fichier]} { Espionne "Usage is Input from Ontario informations and the Output file" Espionne "Usage is LeFichierSDT_Ontario Input Output" } if {[file exists $FichierSDT]} { while {1} { if {[OuiOuNon "$FichierSDT already exists.\nPlease choose a file name for new SDT File"]} { set FichierSDT [tk_getOpenFile -title "Choose a file" -initialdir "$RepGalFile"] if {$FichierSDT==""} {continue} else {break} } } } #2- Les donnees ou nom des champs utilises set Header [list "ID" "Genbank_Id" "Definition" "Gene" "Chromosome" "CytoBand" "RefSeq_Id" "Unigene_Id" "NewUnigene_Id" "NewDefinition" "Gscope_Access2" "Gscope_Access"] AppendAuFichier $FichierSDT [join "$Header" "\t"] #3- Recuperation des informations set SurLeHeader 0 set SurLesDonnees 0 set NDeLigne 0 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { #block col row name id if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} if {$SurLeHeader !="1" && [regexp -nocase "^ATF" $Ligne]} { set SurLeHeader 1 set NDeLigne 0 continue } if {$SurLeHeader=="1" && $NDeLigne=="0"} { set LigneSplitee [split $Ligne "\t"] #On ajoute 1 colonne de donnee supplementaire set NMaxOptionalHeader [lindex $LigneSplitee 0] set NDeLigne 1 continue } if {$SurLeHeader=="1" && [expr $NDeLigne <= $NMaxOptionalHeader]} { incr NDeLigne continue } else {set SurLeHeader 0} if {$SurLeHeader=="0" && [regexp -nocase "^Block\t" $Ligne]} { set SurLesDonnees 1 continue } set NewLigne "" set LigneSplitee "" set LesInfos "" set grid "" set row "" set col "" set Definition "" set NewDefinition "" set Gscope_Access2 "" set LigneSplitee [split $Ligne "\t"] set grid [lindex $LigneSplitee 0] set row [lindex $LigneSplitee 1] set col [lindex $LigneSplitee 2] #Recuperation de l info calculee pour Gene_Present et les access gscope de Actin set Gscope_Access2 [InterrogeActiChip2Ontario "" $grid $row $col GscopeAccess] #set Protein_Id [InterrogeActiChip2Ontario "" $grid $row $col ProteinAccess] #set Design_Access [InterrogeActiChip2Ontario "" $grid $row $col DesignAccess] #set Definition [InterrogeActiChip2Ontario "" $grid $row $col Definition] #Recuperation de l info calculee pour Gene_Present et les access gscope de PuceEST set Gscope_Access [InterrogeLesAccRSEtUG_Ontario $grid $row $col PAB] #grid col row sample gene desc flag #1 3 1 5548382 5548382 Seq_Ver:Hs.159410:BM549033:molybdenum cofactor synthesis 3:MOCS3:20:20q13.13:3:33800 #desc c quoi: #? UnigeneId Access Definition Name Ch Cyto Flag OriginalID #Seq_Ver :Hs.159410 :BM549033 :molybdenum cofactor synthesis 3 :MOCS3 :20 :20q13.13 :3 :33800 set Statut [InterrogeLeIOBFile_Ontario $grid $col $row Statut] set ID [InterrogeLeIOBFile_Ontario $grid $col $row Sample] set Definition [InterrogeLeIOBFile_Ontario $grid $col $row Definition] set Gene [InterrogeLeIOBFile_Ontario $grid $col $row Abreviation] set Chromosome [InterrogeLeIOBFile_Ontario $grid $col $row Chromosome] set CytoBand [InterrogeLeIOBFile_Ontario $grid $col $row CytoBand] set Unigene_Id [InterrogeLeIOBFile_Ontario $grid $col $row UnigeneID] set Genbank_Id [InterrogeLeIOBFile_Ontario $grid $col $row AccessionID] set RefSeq_Id "None" if {$Statut == "No_Seq"} { set RefSeq_Id "" set NewUnigene_Id "" set NewDefinition "" } else { #On utilise ce qui a ete fait pour la premiere version du gal file (SS-H19k6.gal, .iob) set RefSeq_Id [InterrogeLesAccRSEtUG_Ontario $grid $row $col AccRefSeq] if {[regexp -nocase "RSHUM:" $RefSeq_Id]} { regsub "RSHUM:NM" $RefSeq_Id "NM_" RefSeq_Id } set NewUnigene_Id [InterrogeLesAccRSEtUG_Ontario $grid $row $col AccUnigene] if {$Definition==""} { set NewDefinition [InterrogeLesAccRSEtUG_Ontario $grid $row $col BestDefinition] } } #3-5 Stockage des donnees recuperees foreach Element $Header { if {[set $Element]==""} {set $Element "None"} lappend LesInfos [set $Element] } AppendAuFichier $FichierSDT [join "$LesInfos" "\t"] continue } close $F return "" } proc LeFichierSDT_UMCU {{FichierSDT ""}} { Wup "Permet de faire un fichier d annotation lisible pour le programme Acuity Axon" Wup "Ce type de fichier a pour extension .sdt et est majoritairement separe par des tabulations" Wup "Le .sdt est un fichier qui permet d ajouter des annotations" #Attention il faut une reference unique qui sera toujours utilise (ex: id) #On peut prendre l AccessGscope #L ID unique doit etre en premiere position if { $FichierSDT==""} { set FichierSDT "[RepertoireDuGenome]/Autres_Puces/UMCU/UMCU-H25k11.sdt" } #1- On recupere la liste des ID d oligos (ex: ACT0001_Oligo12_BC000445) set FichierUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU/UMCU-H25k11.txt" set LesIDs [InterrogeLesInfosUMCU $FichierUMCU LesAccess] #Espionne "$LesIDs" Espionne "Taille [llength $LesIDs]" #2- Les donnees ou nom des champs utilises set Header [list "ID" "ID_ActiChip" "Name" "GB_Access" "Gene_Symbol" "UniGene_ID"] AppendAuFichier $FichierSDT [join "$Header" "\t"] #3- Recuperation des informations foreach ID $LesIDs { if {$ID==""} {continue} set GB_Access "" set ID_ActiChip "" set Name "" set Gene_Symbol "" set UniGene_ID "" set Infos "" set LesInfos "" set GB_Access $ID set Name [InterrogeLesInfosUMCU $FichierUMCU $ID Name] set Gene_Symbol [InterrogeLesInfosUMCU $FichierUMCU $ID Gene_Symbol] set UniGene_ID [InterrogeLesInfosUMCU $FichierUMCU $ID UniGene_ID] set ID [InterrogeLesInfosUMCU $FichierUMCU $ID Oligo_ID] #Attention le ID ici doit etre le Oligo_ID de UMCU set ID_ActiChip [InterrogeActiChip2UMCU $ID AccessGscope] #3-5 Stockage des donnees recuperees foreach Info $Header { lappend LesInfos [set $Info] } AppendAuFichier $FichierSDT [join "$LesInfos" "\t"] #papaEspionne [join "$LesInfos" "\t"] } return "" } proc LeGetzUniseq {Access {Banques uniseq} {Link genbank} {Option AccessDef}} { Wup "Recupere grace a getz les liens dans Link pour les Access dans Banques" Wup "Option EntreeComplete == sortie getz de toute l entree" Wup "Option AccessDef == sortie getz avec juste Id et Def" set LesAccess "" set UnAccess "" set bidon "" set Access [split $Access "\n"] if {$Banques == "uniseq"} { foreach AC [lsort -unique $Access] { set UnAccess [lindex $AC 0] if {[regexp -nocase "UG:" $AC]} {regsub -all "UG:" $UnAccess "" UnAccess} if {[regexp -nocase "Hs#" $AC]} {regsub -all "Hs#" $UnAccess "Hs_" UnAccess} lappend LesAccess $UnAccess } set Access [join $LesAccess "|"] } elseif {$Banques == "genbank"} { foreach AC [lsort -unique $Access] { if {! [regexp -nocase {[a-z]+ || [0-9]+} $AC]} {continue} if { [regexp {^ACT[0-9]{4}$} $AC]} {continue} if {! [regexp "^ACCESSION" $AC] && ! [regexp -nocase "^LOCUS" $AC]} {continue} scan $AC "%s %s" bidon UnAccess lappend LesAccess $UnAccess } set Access [join [lsort -unique $LesAccess] "|"] } if {$Access == ""} {return ""} if {$Option == "EntreeComplete"|| $Option=="All"} {set option "-e"} elseif {$Option == "AccessDef"} {set option "-f \"id des\""} set Typ1 id set Typ2 acc if {$Link == "NoLink"} { #set Commande "getz $option \"\\\[$Banques-id: $Access\\\]\"" set Commande "getz $option \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\])\"" } else { #set Commande "getz $option \"\\\[$Banques-id: $Access\\\] \\\> $Link \"" set Commande "getz $option \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\]) \\\> $Link \"" } #http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?[uniseq-all:$Access]>protein+-vn+2+-f+id%20des #http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?[uniseq-all:$Access]>protein+-vn+2+-e catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {return ""} if {$GetzOut=={}} {return ""} return $GetzOut } proc LeGrandResume {} { foreach Ligne [LesVEDidierCompatiblesGscope "GetList"] { set R1 "" scan $Ligne "%s %s %s %s" VE R1 pDEST PGS if {$R1==""} { continue } set R2 "${R1}_$pDEST" lappend LesVEDidierDuPGS($PGS) $VE set Rec2DuVEDidier($VE) $R2 } SauveLesLignes [array get LesVEDidierDuPGS] dans "[Fiches]/VEDidierDuPGS.txt" set LesRapports {} set LesClefs [VEDidier ListeDes Clefs] foreach VE [VEDidier ListeDes VE] { set LaLigne {} set ProtName [VEDidier $VE "ProtName"] set Scientist [VEDidier $VE "Scientist"] set VectorName [VEDidier $VE "Vectorname"] set Organism [VEDidier $VE "Organism"] set Alias $ProtName set PGS [VEDidier $VE "CodeRipp"] if {$PGS==""} { set PGS "------" } else { set Alias [Alias $PGS] } lappend LaLigne $VE lappend LaLigne $PGS lappend LaLigne [format "%-10s" $ProtName] lappend LaLigne [format "%-10s" $Alias] lappend LaLigne [format "%-30s" $Scientist] lappend LaLigne [format "%-15s" $VectorName] lappend LaLigne [format "%-15s" $Organism] if {[info exists Rec2DuVEDidier($VE)]} { set R2 $Rec2DuVEDidier($VE) set N [Rec1 $R2 N] set Sujet [VirtualPPCREnStock $N Sujet] set LesMots [split $Sujet "-"] set F [lindex $LesMots end] set D [lindex $LesMots end-1] set pDONR [Rec1 $R2 Vecteur] set pDEST [Rec2 $R2 Vecteur] set P5 [VirtualPPCREnStock $N P5] set P3 [VirtualPPCREnStock $N P3] lappend LaLigne [format "%-25s" $R2] lappend LaLigne "$P5 [Oli $P5 Signals]" lappend LaLigne "$P3 [Oli $P3 Signals]" set FichierRec2 [Rec2 $R2 Fichier] set SeqRec2 [QueLaSequenceDuFichierTFA $FichierRec2] set FichierFusionProt $FichierRec2 regsub "/rec2/" $FichierFusionProt "/fusion/" FichierFusionProt regsub "/fusion/" $FichierFusionProt "/fusion/Fus_" FichierFusionProt append FichierFusionProt ".prottfa" if {[FileExists $FichierFusionProt]} { set SeqFusion [QueLaSequenceDuFichierTFA $FichierFusionProt] } else { set SeqFusion "" } set LeTR {} lappend LeTR VE $VE lappend LeTR ProteinName $Alias lappend LeTR Organism $Organism lappend LeTR Boundaries "$D-$F" lappend LeTR PGS $PGS lappend LeTR Rec2 $R2 # lappend LeTR OldProtname $ProtName # lappend LeTR Oligo5P $P5 lappend LeTR Signals5 [Oli $P5 Signals] lappend LeTR Signals3 [Oli $P3 Signals] foreach Clef [LesEtatsDesVEs] { lappend LeTR $Clef [VEDidier $VE $Clef] } lappend LeTR NucSeqRec2 $SeqRec2 lappend LeTR ProtSequence $SeqFusion set SeqProtCoupure "" set Protease "" foreach Signal [split [Oli $P5 Signals] "_"] { if {[EstUneProtease $Signal]} { set Protease $Signal ; break } } if {$Protease!=""} { set FichierCoupureProt $FichierRec2 regsub "/rec2/" $FichierCoupureProt "/coupure/" FichierCoupureProt regsub "/coupure/" $FichierCoupureProt "/coupure/cut_" FichierCoupureProt append FichierCoupureProt "_$Protease.prottfa" if {[FileExists $FichierCoupureProt]} { set SeqProtCoupure [QueLaSequenceDuFichierTFA $FichierCoupureProt] } else { set SeqProtCoupure "" } } lappend LeTR ProtCutted $SeqProtCoupure set LesTitres {} set LeRapport {} foreach {T R} $LeTR { lappend LesTitres $T lappend LeRapport $R } if {$LesRapports=={}} { lappend LesRapports [join $LesTitres ";"] } set Rapport [join $LeRapport ";"] lappend LesRapports $Rapport } set Ligne [join $LaLigne "\t"] lappend LeGrandResume $Ligne } SauveLesLignes $LesRapports dans "[Fiches]/ReportForJaime.txt" set Resume [join $LeGrandResume "\n"] return [AfficheVariable $Resume] } proc LeManquant {} { set FichierAccess "[RepertoireDuGenome]/LesAccessDesmRNAsChoisis" set L [CreeListePourFichierAUneColonne $FichierAccess] Espionne [llength $L] foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_choisis/*"] { set NomFichier [file tail $Fichier] set Vu($NomFichier) 1 } foreach Access $L { if {$Access==""} {continue} if {![info exists Vu($Access)]} {Espionne $Access} } } proc LeMeilleurDuLot {ls} { set o [open tocmd w] foreach e $ls { lassign $e idc rf rs puts $o "PDB:$idc" } close $o if {[catch {set Lg [exec fastacmd -i tocmd -d pdb]} Msg]} { return "" } if {[string index $Lg 0] ne ">"} { return "" } DecortiqueUnTFA $Lg Ln Sq set smax -1 set lm "" foreach n $Ln l $ls { set s [string length [set Sq($n)]] if {$s > $smax} { set smax $s set lm $l } } return $lm } proc LeMeilleurTblastn {OrgCible LesGenORFs} { set BestExpect 1 foreach {Gen ORF} $LesGenORFs { set Fichier "/genomics/link/$Gen/tblastngenomes/$ORF" set LO [OuATapeTBlastN $Fichier "genomes" "ListeDesOrganismes"] set LE [OuATapeTBlastN $Fichier "genomes" "ListeDesExpects"] set LD [OuATapeTBlastN $Fichier "genomes" "ListeDesDebuts"] set LF [OuATapeTBlastN $Fichier "genomes" "ListeDesFins"] set LB [OuATapeTBlastN $Fichier "genomes" "ListeDesBanqueId"] foreach Org $LO Expect $LE Deb $LD Fin $LF BankId $LB { if {[string equal -nocase $Org $OrgCible]} { if {$Expect < $BestExpect} { set BestExpect $Expect set BestGen $Gen set BestORF $ORF set BestDeb $Deb set BestFin $Fin set BestBankId $BankId } break } } } return "$BestGen $BestORF $BestBankId $BestDeb $BestFin $BestExpect" } proc LeMeilleurmRNACandidat {LesmRNACandidats TailleProt} { set DbtCDSMax 0 set ScoreMax -1e200 set DiffTailleMin 1e200 AskLesPagesInfos unset AskLesPagesInfos load $LesmRNACandidats genbankfull set LesmRNAs {} foreach Access $LesmRNACandidats { if {[info exists DbtCDS ]} {unset DbtCDS} if {[info exists FinCDS ]} {unset FinCDS} set PageInfo [AskLesPagesInfos ask $Access] Espionne $PageInfo regexp { CDS [^0-9]+([0-9]+)\.[ ]*\.([0-9]+)} $PageInfo tmp DbtCDS FinCDS if {![info exists DbtCDS ] || ![info exists FinCDS ]} {continue} #IMPORTANT TGA (STOP) a la fin du CDS" set TailleProtTheo [expr ($FinCDS - $DbtCDS + 1) * 1.0 /3 - 1 ] set DiffTaille [expr abs($TailleProt-$TailleProtTheo)] if {$DiffTaille > $DiffTailleMin} {continue} if {$DiffTaille < $DiffTailleMin} { set LesmRNAs {} set DbtCDSMax 0 set ScoreMax -1e200 set DiffTailleMin $DiffTaille } set Info [PageInfo $Access genbank "id des key org"] set NbBonus 0 while {[regexp -nocase "mRNA|complete cds|cDNA to mRNA" $Info]} { incr NbBonus regsub -nocase "mRNA|complete cds|cDNA to mRNA" $Info "" Info } set NbMalus 0 while {[regexp -nocase "promoter|gene|exon" $Info]} { incr NbMalus regsub -nocase "promoter|gene|exon" $Info "" Info } set Score [expr $NbBonus - $NbMalus] if {$Score < $ScoreMax } {continue} if {$Score > $ScoreMax } {set LesmRNAs {};set DbtCDSMax 0;set ScoreMax $Score} if {$DbtCDS < $DbtCDSMax } {continue} if {$DbtCDS > $DbtCDSMax } {set LesmRNAs {};set DbtCDSMax $DbtCDS} lappend LesmRNAs $Access } AskLesPagesInfos unset return [lindex $LesmRNAs 0] } proc LeMetDuPoch {Nom} { global QueLesMetOK set CS [CodonStart $Nom] if {[regexp -nocase "ok" $CS]} { regsub {GroupeSize [0-9]+ [0-9]+ } $CS "" CS scan $CS "%s %d %s" MVL Position OK if { ! [regexp -nocase {[MVL]} $MVL]} { FaireLire "$Nom $CS Ca merde ... pas de MVL" if {[OuiOuNon "On corrige Info ?"]} { Informe $Nom return "On recommence" } else { return "Abandon" } } if { ! [regexp -nocase "ok" $OK]} { FaireLire "$Nom $CS Ca merde ... pas de OK" if {[OuiOuNon "On corrige Info ?"]} { Informe $Nom return "On recommence" } else { return "Abandon" } } if {$Position == 1} { return "M 1 OK ... on ne change rien" } set Debut [Box $Nom debut] set Fin [Box $Nom fin] set Orient [Box $Nom orient] if { $Orient == "F" } { set DebutEntamme [expr $Debut+($Position-1)*3] set FinEntamme [expr $DebutEntamme+29] set Position $DebutEntamme } else { set FinEntamme [expr $Fin-($Position-1)*3] set DebutEntamme [expr $FinEntamme-29] set Position $FinEntamme } set Entamme [BoutADN $DebutEntamme $FinEntamme $Orient] if { ! [CodonStartPossible [string range $Entamme 0 2]]} { FaireLire "$Nom $Entamme ca merde a l'entamme" if {[OuiOuNon "On corrige Info ?"]} { Informe $Nom return "On recommence" } else { return "Abandon malgre OK" } } return "Coupe a $Entamme en $Position" } else { if {[Decede $Nom]} { return "Abandon car decede" } if {$QueLesMetOK || [Informe $Nom] == "" } { return "Abandon car non OK" } else { return "On recommence" } } } proc LeNombreDeResidusDansLeDomaine {FichierMSF {D -1} {F end}} { set TFAs [CreeLeTFAsDuMSF $FichierMSF] set TmpTFAs [Sauve $TFAs dans [TmpFile]] set Sortie {} if { ! [regexp "end" $D]} { incr D -1} if { ! [regexp "end" $F]} { incr F -1} foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] { set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]] set Zone [string range $Seq $D $F] regsub -all {\.|\-} $Zone "" ZoneSansPoint set nRes [string length $ZoneSansPoint] lappend Sortie [format "%-10s %5d %s---%s" $Access $nRes [string range $ZoneSansPoint 0 4] [string range $ZoneSansPoint end-4 end]] } # file delete -force $TmpTFAs return $Sortie } proc LeNombreDuResidu {r} { if {[regexp {^[0-9]} $r]} { set ler $r } else { set ler [string range $r 1 end] } return $ler } proc LeNucProfileDeLaSeq {Seq Nuc} { ######################################################################################## ### Rend une liste dont chaque element correspond a 1 ou 0 selon si nuc voulu ou pas ### ### (ex: $Nuc == GC, pour le calcul du profil en GC) ### ### a chacune des positions de la sequence ### ######################################################################################## if {![EstCeDeLADN_Seq $Seq]} {Espionne "Problem: your sequence is not a DNA sequence";return} #Nucleotides recherches set LesNuc [split $Nuc ""] set LeNucProfile {} #Parcours de chacune des positions de la sequence set LesRes [split $Seq ""] foreach Res $LesRes { foreach Nuc $LesNuc { if {[string equal -nocase $Res $Nuc]} {set Nuc 1 ; break} else {set Nuc 0} } #Espionne "Res:$Res Nuc: $Nuc" lappend LeNucProfile $Nuc } return $LeNucProfile } proc LeNucProfileDeLaSeq_OLD {Seq Nuc {WindowSize 10}} { ############OKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOK############### ######################################################################################## ### Rend une liste dont chaque element correspond au pourcentage en nucleotide voulu ### ### Pourcentage calcule sur la fenetre WindowSize ### ### (ex: $Nuc == GC, pour le calcul du profil en GC) ### ### a chacune des positions de la sequence ### ######################################################################################## if {![EstCeDeLADN_Seq $Seq]} {Espionne "Problem: your sequence is not a DNA sequence";return} set LesNuc [split $Nuc ""] set Volet [expr int($WindowSize / 2)] set LeNucProfile {} #Parcours de chacune des positions de la sequence set LesRes [split $Seq ""] set SeqLength [llength $LesRes] set IndexMax $SeqLength set Pos 0 foreach Res $LesRes { incr Pos set NbNuc 0 #Espionne "Position$Pos Res:$Res" #Determination des extr de la fenetre set iMin [expr $Pos - $Volet] if {$iMin < 1 } {set iMin 1} set iMax [expr $Pos + $Volet] if {$IndexMax < $iMax} {set iMax $IndexMax} #Espionne "iMin: $iMin ; iMax: $iMax" set LocalWindowSize [expr $iMax - $iMin +1] #Espionne "LocalWindowSize: $LocalWindowSize" #Calcul du poucentage des Nuc sur cette fenetre for {set j $iMin} {$j <= $iMax} {incr j} { set Res [lindex $LesRes [expr $j -1]] #Espionne "Nuc$j: $Res" foreach Nuc $LesNuc { if {[string equal -nocase $Res $Nuc]} {incr NbNuc} } } set NucPercent [expr $NbNuc * 1.0 / $LocalWindowSize] #set NucPercent [expr $NbNuc *100.0 / $LocalWindowSize] #Espionne "NucPercent: $NbNuc *100.0 / $LocalWindowSize ; $NucPercent" lappend LeNucProfile $NucPercent } return $LeNucProfile } proc LeNucProfileDesQueryPosDuMAF {FileTFA {Nuc GC}} { set TFASeq [string toupper [TFA2SEQ $FileTFA]] #le regsub qui suit enleve tout sauf A-Z en majuscule (cad caracteres autres que lettres, minuscules, chiffres ...) regsub -all {[^A-Z]+} $Seq "" Seq return [LeNucProfileDeLaSeq $Seq $Nuc] } proc LePCIDuResidu {args} { Wup "Permet de questionner le fichier des pourcentages d identite calcules par Luc" Wup "Les PID sont faits par rapport a la PDB 1yag_a et les structures IIaires sont issues de la PDB" Wup "On relit puis trie les Access en fonction de leur famille et les moyennes sont ainsi calculees" Wup "Voir aussi decharge et interroge" global TabPCIRes #Arguments: ########### #LesCategorie -- Rend les Familles d ARP disponible #$Pos -- Rend PAR DEFAUT le pourcentage d ID moyen du residu pour toutes les ARPs #$Pos $Categorie -- Rend le pourcentage d ID du residu pour cette famille d ARP #$Pos Total -- Rend le pourcentage d ID moyen du residu pour toutes les ARPs #HelixOuSheet Number -- Rend le nombre de Sheet ou de Helix #HelixOuSheet $i PDB Debut -- Rend le debut de HouS numero $i dans la PDB #HelixOuSheet $i PDB Fin -- Rend le Fin de HouS numero $i dans la PDB #HelixOuSheet $i Reference Debut -- Rend le debut de HouS numero $i dans la Reference #HelixOuSheet $i Reference Fin -- Rend le Fin de HouS numero $i dans la Reference if {$args == "unset"} { if {[info exists TabPCIRes]} {array unset TabPCIRes} return "" } set Quoi [join $args ","] if {[info exists TabPCIRes($Quoi)]} {return [set TabPCIRes($Quoi)]} #set FichierACharger "[RepertoireDuGenome]/alignement_ARP/test/PIDSecStruct_all_Ordered" #set FichierACharger "[RepertoireDuGenome]/PIDSecStruct_all_Ordered" set FichierACharger "[RepertoireDuGenome]/Projet_ARP/Resultat/3D/PIDSecStruct_all_Ordered" #set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabPCIRes($FichierACharger,EstCharge)]} {set TabPCIRes($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeRetrieveResidueInMACS $FichierACharger return "" } if { [info exists TabPCIRes($FichierACharger,EstVide)]} {return ""} if { [info exists TabPCIRes($Quoi)]} {return [set TabPCIRes($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabPCIRes($FichierACharger,EstCharge)] || [set TabPCIRes($FichierACharger,EstCharge)]=="0"} { set TabPCIRes($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLePCIDuResidu TabPCIRes $FichierACharger] if {$ResultatCharge != ""} { set TabPCIRes($FichierACharger,EstVide) 1 return "" } } if {![info exists TabPCIRes($Quoi)]} {return ""} return [set TabPCIRes($Quoi)] } proc LePCIDuResiduDUnAccess {args} { Wup "Permet de questionner le fichier des pourcentages d identite calcules par Luc" Wup "Les PID sont faits par rapport a la PDB 1yag_a et les structures IIaires sont issues de la PDB" Wup "On relit puis trie les Access en fonction de leur famille et les moyennes sont ainsi calculees" Wup "Ici on le fait uniquement pour un access en particulier" Wup "Voir aussi decharge et interroge" global TabPCIRes1Acc #Arguments: ########### #$Pos -- Rend PAR DEFAUT le pourcentage d ID moyen du residu pour toutes les ARPs #HelixOuSheet Number -- Rend le nombre de Sheet ou de Helix #HelixOuSheet $i PDB Debut -- Rend le debut de HouS numero $i dans la PDB #HelixOuSheet $i PDB Fin -- Rend le Fin de HouS numero $i dans la PDB #HelixOuSheet $i Reference Debut -- Rend le debut de HouS numero $i dans la Reference #HelixOuSheet $i Reference Fin -- Rend le Fin de HouS numero $i dans la Reference if {$args == "unset"} { if {[info exists TabPCIRes1Acc]} {array unset TabPCIRes1Acc} return "" } set Quoi [join $args ","] if {[info exists TabPCIRes1Acc($Quoi)]} {return [set TabPCIRes1Acc($Quoi)]} #set FichierACharger "[RepertoireDuGenome]/alignement_ARP/test/PIDSecStruct_all_Ordered" #set FichierACharger "[RepertoireDuGenome]/PIDSecStruct_all_Ordered" set FichierACharger "[RepertoireDuGenome]/alignement_ARP/Resultat/3D/PIDSecStruct_all" #set FichierACharger [lindex $args 0] if {! [file exists $FichierACharger]} { Espionne "Pb $FichierACharger" } if {! [info exists TabPCIRes1Acc($FichierACharger,EstCharge)]} {set TabPCIRes1Acc($FichierACharger,EstCharge) 0} if {$Quoi=="$FichierACharger,Decharge"} { #Espionne "Decharge $FichierACharger" DechargeRetrieveResidueInMACS $FichierACharger return "" } if { [info exists TabPCIRes1Acc($FichierACharger,EstVide)]} {return ""} if { [info exists TabPCIRes1Acc($Quoi)]} {return [set TabPCIRes1Acc($Quoi)]} ###################CHARGE le Fichier avec les residus demandees######################### if {! [info exists TabPCIRes1Acc($FichierACharger,EstCharge)] || [set TabPCIRes1Acc($FichierACharger,EstCharge)]=="0"} { set TabPCIRes1Acc($FichierACharger,EstCharge) 1 #Espionne "On charge $FichierACharger" set ResultatCharge [ChargeLePCIDuResiduDUnAccess TabPCIRes1Acc $FichierACharger] if {$ResultatCharge != ""} { set TabPCIRes1Acc($FichierACharger,EstVide) 1 return "" } } if {![info exists TabPCIRes1Acc($Quoi)]} {return ""} return [set TabPCIRes1Acc($Quoi)] } proc LePanneauDeCouleursDuGraph {target LeCanvasPere tagorid} { Wup "Petit panneau de couleur pour changer la couleur des graphes Tm GC Nbseq Id" set w ".choixcouleur" set GraphPanel "[winfo toplevel $target]" if {[winfo exists $w]} {destroy $w} toplevel $w wm overrideredirect $w 1 wm resizable $w false false set FInfo "$w.frame" frame $FInfo -borderwidth "1" -relief "ridge" -background "gray" pack $FInfo -fill "both" -expand "true" bind $FInfo "destroy $w" bind $GraphPanel "destroy $w" #bind $target {wm geometry $w +[winfo rootx $target]+[winfo rooty $target]} #Palette pour le panneau special de choix de couleur set LesCouleurs "" set LesCouleurs [list black red green3 orange deeppink deepskyblue2 darkviolet firebrick4 palette] set NbCouleur [llength $LesCouleurs] set MaxRow 2 set MaxCol [expr $NbCouleur/$MaxRow] set Row 0 set Column 0 foreach Couleur $LesCouleurs { if {$Row>=$MaxRow} {incr Column;set Row 0} if {$Couleur=="palette"} { set LCoul "${FInfo}.${Couleur}" label $LCoul -background "yellow" -relief "ridge" -width "2" -text "P" grid $LCoul -column "$Column" -row "$Row" -padx "2" -pady "2" bind $LCoul "ChangeLaCouleurDuGraph $LeCanvasPere $tagorid \[tk_chooseColor\]" bind $LCoul "destroy $w" continue } set LCoul "${FInfo}.${Couleur}" label $LCoul -background "$Couleur" -relief "sunken" -width "2" grid $LCoul -column "$Column" -row "$Row" -padx "2" -pady "2" bind $LCoul "ChangeLaCouleurDuGraph $LeCanvasPere $tagorid $Couleur" bind $LCoul "destroy $w" incr Row } set x [expr [winfo rootx $target]] set y [expr [winfo rooty $target]] wm geometry $w +${x}+${y} return "" } proc LePilierDeReference {aa Pilier} { return [string map [list . $aa] $Pilier] } proc LePlusPetit {ListeLabels aDissim aValpp} { upvar $aDissim Dissim upvar $aValpp Valpp set Valpp 100000 set Sortir 0 set Autres $ListeLabels set Nompp "" foreach Nom1 $ListeLabels { set Autres [lrange $Autres 1 end] foreach Nom2 $Autres { if {![set Dissim($Nom1,$Nom2)]} { set Valpp 0 set Nompp [list $Nom1 $Nom2] set Sortir 1 break } elseif {[set Dissim($Nom1,$Nom2)]<$Valpp} { set Valpp [set Dissim($Nom1,$Nom2)] set Nompp [list $Nom1 $Nom2] } } if {$Sortir} {break} } return $Nompp } proc LePremierExonDumRNAPourPromAn {Debut Fin Sens {Access ""} {Organism ""}} { return [list [list "FirstExon" "ProtocolGeneStructure" $Debut $Fin $Sens $Debut 0 "" $Access $Organism]] } proc LeProfilDeLAlignementDeLaQuery {FichierBlast BanqueId {WhatSens BothSens}} { if {![file exists $FichierBlast]} {return ""} set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [AskBlast $FichierBlast Taille] #^[0-9]+_[0-9]+$ pour les access de jean #regsub {_[0-9]+$} $BanqueId "" BanqueId if {[regexp "_" $BanqueId] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BanqueId]} { regsub {_[0-9]+$} $BanqueId "" BanqueId } for {set i 1} {$i <= $TailleQuery} {incr i} {set TabProfil($i) 0} set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [AskBlast $FichierBlast Subject $j] if {[info exists BId_Court]} {unset BId_Court} #^[0-9]+_[0-9]+$ pour les access de jean #regsub {_[0-9]+$} $BId "" BId_Court if {[regexp "_" $BId] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BId]} { regsub {_[0-9]+$} $BId "" BId_Court } else { set BId_Court $BId } if {![string equal -nocase $BId_Court $BanqueId]} {continue} set NbSegments [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { set AlignLineaire [AskBlast $FichierBlast BanqueId $BId Segment $Segment AlignLineaire] if {$AlignLineaire == ""} {return} set Sens [SensDeLaRegion [AskBlast $FichierBlast BanqueId $BId Segment $Segment Orientation]] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set DQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment DQ] set FQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment FQ] if {[info exists AliQuery]} {unset AliQuery} if {[info exists AliSbjct]} {unset AliSbjct} set Query [lindex [split $AlignLineaire "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split $AlignLineaire "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] if {![info exists AliQuery]} {continue} if {![info exists AliSbjct]} {continue} set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ == "-"} {continue} if {$AQ == $AS} { for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} { set Pos [expr $PosIni - $i] } else { set Pos [expr $PosIni + $i] } if {![info exists TabProfil($Pos)]} {continue} incr TabProfil($Pos) } } if {$Sens == "-"} { set PosIni [expr $PosIni - $Indice] } else { set PosIni [expr $PosIni + $Indice] } } } } set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} {lappend LeProfil [set TabProfil($i)]} return $LeProfil } proc LeProfilDeLAlignementDeLaQuery_TabBlast {aTabBlast BanqueId {WhatSens BothSens}} { upvar $aTabBlast TabBlast if {![info exists TabBlast]} {return} set TypeDeBlast [set TabBlast(TypeDeBlast)] set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [set TabBlast(Taille)] regsub {_[0-9]+$} $BanqueId "" BanqueId for {set i 1} {$i <= $TailleQuery} {incr i} {set TabProfil($i) 0} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [set TabBlast($j)] if {[info exists BId_Court]} {unset BId_Court} regsub {_[0-9]+$} $BId "" BId_Court if {$BId_Court != $BanqueId} {continue} set NbSegments [set TabBlast($BId,NbSegment)] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { if {![info exists TabBlast($BId,$Segment,AlignLineaire)]} {return ""} set DQ [set TabBlast($BId,$Segment,DQ) ] set FQ [set TabBlast($BId,$Segment,FQ) ] set Sens [SensDeLaRegion [set TabBlast($BId,$Segment,Orientation)]] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set Query [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ == "-"} {continue} if {$AQ == $AS} { for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} { set Pos [expr $PosIni - $i] } else { set Pos [expr $PosIni + $i] } if {![info exists TabProfil($Pos)]} {continue} incr TabProfil($Pos) } } if {$Sens == "-"} { set PosIni [expr $PosIni - $Indice] } else { set PosIni [expr $PosIni + $Indice] } } } } set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} {lappend LeProfil [set TabProfil($i)]} return $LeProfil } proc LeProfilDeLAlignementDuSubject {FichierBlast BanqueId {WhatSens BothSens}} { if {![file exists $FichierBlast]} {return ""} set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Indice 1 if {$TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleSbjct [AskBlast $FichierBlast BanqueId $BanqueId Taille] for {set i 1} {$i <= $TailleSbjct} {incr i} {set TabProfil($i) 0} set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [AskBlast $FichierBlast Subject $j] if {0} { if {[info exists BId_Court]} {unset BId_Court} regsub {_[0-9]+$} $BId "" BId_Court if {$BId_Court != $BanqueId} {continue} } else { if {![string equal -nocase $BId $BanqueId]} {continue} } set NbSegments [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { set AlignLineaire [AskBlast $FichierBlast BanqueId $BId Segment $Segment AlignLineaire] if {$AlignLineaire == ""} {return} set Orientation [AskBlast $FichierBlast BanqueId $BId Segment $Segment Orientation] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set DS [AskBlast $FichierBlast BanqueId $BId Segment $Segment DS ] set FS [AskBlast $FichierBlast BanqueId $BId Segment $Segment FS ] set Query [lindex [split $AlignLineaire "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split $AlignLineaire "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FS < $DS} {set Sens "-"} set PosIni $DS foreach AQ $LAliQuery AS $LAliSbjct { if {[regexp -nocase "\\\-" $AS]} {continue} if {$AQ == $AS} { for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} { set Pos [expr $PosIni - $i] } else { set Pos [expr $PosIni + $i] } if {![info exists TabProfil($Pos)]} {continue} incr TabProfil($Pos) } } if {$Sens == "-"} { set PosIni [expr $PosIni - $Indice] } else { set PosIni [expr $PosIni + $Indice] } } } } set LeProfil {} for {set i 1} {$i <= $TailleSbjct} {incr i} {lappend LeProfil [set TabProfil($i)]} return $LeProfil } proc LeProfilDeLAlignementDuSubject_TabBlast {aTabBlast BanqueId {WhatSens BothSens}} { upvar $aTabBlast TabBlast if {![info exists TabBlast]} {return} set TypeDeBlast [set TabBlast(TypeDeBlast)] set Indice 1 if {$TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleSbjct [set TabBlast($BanqueId,Taille)] for {set i 1} {$i <= $TailleSbjct} {incr i} {set TabProfil($i) 0} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [set TabBlast($j)] if {$BId != $BanqueId} {continue} if {0} { if {[info exists BId_Court]} {unset BId_Court} regsub {_[0-9]+$} $BId "" BId_Court if {$BId_Court != $BanqueId} {continue} } set NbSegments [set TabBlast($BId,NbSegment)] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { if {![info exists TabBlast($BId,$Segment,AlignLineaire)]} {return ""} set DS [set TabBlast($BId,$Segment,DS) ] set FS [set TabBlast($BId,$Segment,FS) ] set Orientation [set TabBlast($BId,$Segment,Orientation)] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set Query [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FS < $DS} {set Sens "-"} set PosIni $DS foreach AQ $LAliQuery AS $LAliSbjct { if {[regexp -nocase "\\\-" $AS]} {continue} if {$AQ == $AS} { for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} { set Pos [expr $PosIni - $i] } else { set Pos [expr $PosIni + $i] } if {![info exists TabProfil($Pos)]} {continue} incr TabProfil($Pos) } } if {$Sens == "-"} { set PosIni [expr $PosIni - $Indice] } else { set PosIni [expr $PosIni + $Indice] } } } } set LeProfil {} for {set i 1} {$i <= $TailleSbjct} {incr i} {lappend LeProfil [set TabProfil($i)]} return $LeProfil } proc LeProfilDeLaQuerySurToutLeBlast {FichierBlast {BaseAligneOuBaseDansAlignementOuLesDeux BaseAligne} {WhatSens BothSens} {LesBanqueId ""} {Expect 1e200}} { if {![file exists $FichierBlast]} {return ""} foreach BId $LesBanqueId { #jM regsub {_[0-9]+$} $BId "" BId if {[regexp "_" $BId] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BId]} { regsub {_[0-9]+$} $BId "" BId } set TabBIdOk($BId) 1 } set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [AskBlast $FichierBlast Taille] for {set i 1} {$i <= $TailleQuery} {incr i} { set TabProfil(BaseAligne,$i) 0 set TabProfil(BaseDansAlignement,$i) 0 } set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [AskBlast $FichierBlast Subject $j] if {[info exists BId_Court]} {unset BId_Court} #jM regsub {_[0-9]+$} $BId "" BId_Court if {[regexp "_" $BId_Court] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BId_Court]} { regsub {_[0-9]+$} $BId "" BId_Court } if {$LesBanqueId != "" && ![info exists TabBIdOk($BId_Court)]} {continue} set NbSegments [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { set AlignLineaire [AskBlast $FichierBlast BanqueId $BId Segment $Segment AlignLineaire] if {$AlignLineaire == ""} {return} set DQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment DQ ] set FQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment FQ ] set Orientation [AskBlast $FichierBlast BanqueId $BId Segment $Segment Orientation] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set Query [lindex [split $AlignLineaire "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split $AlignLineaire "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ == "-"} {continue} for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} {set Pos [expr $PosIni-$i]} else {set Pos [expr $PosIni+$i]} incr TabProfil(BaseDansAlignement,$Pos) if {$AQ == $AS} { if {![info exists TabProfil(BaseAligne,$Pos)]} {continue} incr TabProfil(BaseAligne,$Pos) } } if {$Sens == "-"} {set PosIni [expr $PosIni-$Indice]} else {set PosIni [expr $PosIni+$Indice]} } } } set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} { if {[string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "BaseAligne" ]} { lappend LeProfil [set TabProfil(BaseAligne,$i)] continue } if {[string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "BaseDansAlignement"]} { lappend LeProfil [set TabProfil(BaseDansAlignement,$i)] continue } if { [string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "LesDeux" ]} { lappend LeProfil [list [set TabProfil(BaseAligne,$i)] [set TabProfil(BaseDansAlignement,$i)]] continue } } return $LeProfil } proc LeProfilDeLaQuerySurToutLeBlast_TabBlast {aTabBlast {BaseAligneOuBaseDansAlignementOuLesDeux BaseAligne} {WhatSens BothSens} {LesBanqueId ""}} { upvar $aTabBlast TabBlast foreach BId $LesBanqueId { regsub {_[0-9]+$} $BId "" BId set TabBIdOk($BId) 1 } if {![info exists TabBlast]} {return} set TypeDeBlast [set TabBlast(TypeDeBlast)] set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [set TabBlast(Taille)] for {set i 1} {$i <= $TailleQuery} {incr i} { set TabProfil(BaseAligne,$i) 0 set TabProfil(BaseDansAlignement,$i) 0 } set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [set TabBlast($j)] if {[info exists BId_Court]} {unset BId_Court} regsub {_[0-9]+$} $BId "" BId_Court if {$LesBanqueId != "" && ![info exists TabBIdOk($BId_Court)]} {continue} set NbSegments [set TabBlast($BId,NbSegment)] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { if {![info exists TabBlast($BId,$Segment,AlignLineaire)]} {return ""} set DQ [set TabBlast($BId,$Segment,DQ) ] set FQ [set TabBlast($BId,$Segment,FQ) ] set Orientation [set TabBlast($BId,$Segment,Orientation)] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set Query [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ = "-"} {continue} for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} {set Pos [expr $PosIni-$i]} else {set Pos [expr $PosIni+$i]} incr TabProfil(BaseDansAlignement,$Pos) if {$AQ == $AS} { if {![info exists TabProfil(BaseAligne,$Pos)]} {continue} incr TabProfil(BaseAligne,$Pos) } } if {$Sens == "-"} {set PosIni [expr $PosIni-$Indice]} else {set PosIni [expr $PosIni+$Indice]} } } } set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} { if {$BaseAligneOuBaseDansAlignementOuLesDeux == "BaseAligne"} { lappend LeProfil [set TabProfil(BaseAligne,$i)] continue } if {$BaseAligneOuBaseDansAlignementOuLesDeux == "BaseDansAlignement"} { lappend LeProfil [set TabProfil(BaseDansAlignement,$i)] continue } if {$BaseAligneOuBaseDansAlignementOuLesDeux == "LesDeux"} { lappend LeProfil [list [set TabProfil(BaseAligne,$i)] [set TabProfil(BaseDansAlignement,$i)]] continue } } return $LeProfil } proc LeProfilDesQueryPos_TSS {TSSPos TFAFile} { ### Determine le profil des QueryPos_TSS (ex: -10001, -10000 ... 0 ... +10000 +10001) set LesQueryPos_TSS {} set QueryLength [TailleDeLaSequenceDuFichierTFA $TFAFile] if {$TSSPos != "1"} { set i 1 } else {set i 2} ### QueryPos_TSS = - $TSSPos +i for {set Pos 1} {$Pos <= $QueryLength} {incr Pos} { set QueryPos_TSS [expr $i - $TSSPos] lappend LesQueryPos_TSS $QueryPos_TSS incr i } return $LesQueryPos_TSS } proc LeProfilDuMAF {MAFFile} { if {![file exists $MAFFile]} {Espionne "MAFFile: $MAFFile does not exists" ; return} #upvar $aTab Tab set LeProfilDuMultiZ {} set i 0 set SuisJeSurUnAli 0 set F [open $MAFFile] while {[gets $F Line] >= 0} { set Line [string trim $Line] regsub -all {[ ]+} $Line " " Line set lLine [split $Line " "] set What [lindex $lLine 0] #Espionne $Line if {$What == "a"} { incr i set Score 0.0 regexp {score=(-*[0-9]+\.[0-9]+)} $Line tmp Score set SuisJeSurUnAli 1 continue } if {!$SuisJeSurUnAli} {continue} if {$What == "s"} { set ID [lindex $lLine 1] # "From +1" car dans un fichier maf le premier residu de la seq a pour position "0" set From [expr [lindex $lLine 2] + 1] set Size [lindex $lLine 3] set Sens [lindex $lLine 4] set Seq [lindex $lLine 6] set To [expr $From + $Size - 1] #Espionne "$i\t$ID\t$From\tto\t$To\t$Sens\t$Size\t$Score" lappend LeProfilDuMultiZ [list $i $ID $From $To $Sens $Size $Score $Seq] } } close $F return $LeProfilDuMultiZ } proc LeProfilNDesQueryPosDuMAF {TFAFile MAFFile} { ### Determine le profil N cad le nb de seq presentes dans un block d'alignement pour chaque position de la query ### N est initialise ici a 0, mais il est incremente qq soit la seq cad que la query est comprise dans N ### RefSeq = Sequence of Reference set LesN {} set LesNOUT {} set LesIDDuMAF {} set QueryLength [TailleDeLaSequenceDuFichierTFA $TFAFile] set RefSeq [lindex [TFA2Header $TFAFile] 0] ### 1- Initialisation de N a 0 pour chaque position de la query for {set i 1} {$i <= $QueryLength} {incr i} { set Tab(QueryPos,$i,N) 0 set Tab(QueryPos,$i,NbBlockAli) 0 } ### 2- Calcul de N pour chaque position de la query ### ne compte pas la seq si le res dans le block d'alignement a cette position est un gap "-", "N" ou "X" foreach lProfilDuMAF [LeProfilDuMAF $MAFFile] { set BlockAli [lindex $lProfilDuMAF 0] set ID [lindex $lProfilDuMAF 1] set From [lindex $lProfilDuMAF 2] set To [lindex $lProfilDuMAF 3] set Score [lindex $lProfilDuMAF 6] set lSeq [split [string toupper [lindex $lProfilDuMAF 7]] ""] if {![info exists Tab($MAFFile,ID,$ID)]} { set Tab($MAFFile,ID,$ID) 1 lappend LesIDDuMAF $ID } ### 2.1- Premier parcours du block d'alignement if {![info exists Tab(BlockAli,$BlockAli)]} { # i parcoure les BlockPos, j les BlockPos ayant un Query Res set IDRefSeq $ID set i 0 set j 0 set Tab(BlockAli,$BlockAli,LesBlockPos) {} set Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery) {} set BlockQueryPosBegin $From set BlockQueryPosEnd $To foreach Res $lSeq { lappend Tab(BlockAli,$BlockAli,LesBlockPos) $i if {$Res == "N" || $Res == "X" ||![regexp {[A-Z]} $Res]} {incr i ; continue} set QueryPos [expr $From + $j] #Espionne "Res: $Res ; BlockPos: $i ; QueryPos: $QueryPos" lappend Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery) $i set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$i,QueryPos) $QueryPos #Espionne "Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$i,QueryPos): $QueryPos" incr i incr j } # Compte dans combien de BlockAli sont presentes chaque QueryPos for {set QueryPos $From} {$QueryPos <= $To} {incr QueryPos} { incr Tab(QueryPos,$QueryPos,NbBlockAli) } set Tab(BlockAli,$BlockAli) 1 } ### 2.2- Parcours suivants du block d'alignement, incrementation de N ### N n'est donc pas incremente si la pos de la query n'est pas presente dans un block d'alignement, d'ou "4-" foreach BlockPosDeLaQuery [set Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery)] { set Res [lindex $lSeq $BlockPosDeLaQuery] set QueryPos [set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$BlockPosDeLaQuery,QueryPos)] ### si cette QueryPos a deja ete rencontree avec ces deux meme organismes, on continue ### cad que l'on incremente qu'une fois N par couple d'organismes pour chaque QueryPos if {[info exists Tab(IDRefSeq,$IDRefSeq,ID,$ID,QueryPos,$QueryPos)]} { Espionne "!!!Overlapping: IDRefSeq $IDRefSeq,ID $ID,QueryPos $QueryPos!!!" continue } if {$Res == "N" || $Res == "X" ||![regexp {[A-Z]} $Res]} {continue} # on cree cette info seulement si le res n'est pas "N", "X" ou "-" set Tab(IDRefSeq,$IDRefSeq,ID,$ID,QueryPos,$QueryPos) 1 incr Tab(QueryPos,$QueryPos,N) ###test, a enlever!!! if {1} { if {[set Tab(QueryPos,$QueryPos,N)] > $LesIDDuMAF} { set N [set Tab(QueryPos,$QueryPos,N)] Espionne "N: $N, BlockAli: $BlockAli,BlockPosDeLaQuery: $BlockPosDeLaQuery,QueryPos: $QueryPos,Res: $Res" } } } } ### 3- Creation de la liste LeProfilN ### i parcoure toutes les positions de la query for {set i 1} {$i <= $QueryLength} {incr i} { lappend LesN [set Tab(QueryPos,$i,N)] } ###test, a enlever!!! if {0} { set i 0 foreach N $LesN { if {$N > $LesIDDuMAF} {Espionne "N: $N ; QueryPos: $i ; NbBlockAli: [set Tab(QueryPos,$QueryPos,NbBlockAli)]"} incr i } } ### 4-Pour les positions pas presentes dans un BlockAli, met n a 1 car il y a au moins la seq query #set toto 0 foreach N $LesN { #incr toto if {$N == "0"} { set N 1 #Espionne "Pos: $toto / N: $N" } lappend LesNOUT $N } return $LesNOUT } proc LeProfilnDesQueryPosDuMAF {TFAFile MAFFile} { ### Determine le profil n cad le nb de seq presentes dans un block d'alignement pour chaque position de la query ### n est, pour chaque position de la query, ### le nb de seq dont le res aligne a cette position est identique au residu de la query ### n est ici initialise a 0, mais il est incremente pour chaque access du maf, ### si position pas presente dans un alignement (QueryRes=gapouNouX), alors n est incremente a 1 (== query seq) ### RefSeq = Sequence of Reference set Lesn {} set LesnOUT {} set QueryLength [TailleDeLaSequenceDuFichierTFA $TFAFile] set RefSeq [lindex [TFA2Header $TFAFile] 0] ### 1- Initialisation de n a 0 pour chaque position de la query for {set i 1} {$i <= $QueryLength} {incr i} { set Tab(QueryPos,$i,n) 0 set Tab(QueryPos,$i,NbBlockAli) 0 } ### 2- Calcul de n pour chaque position de la query ### ne compte pas la seq si le res dans le block d'alignement a cette position est un gap "-", "N" ou "X" foreach lProfilDuMAF [LeProfilDuMAF $MAFFile] { set BlockAli [lindex $lProfilDuMAF 0] set ID [lindex $lProfilDuMAF 1] set From [lindex $lProfilDuMAF 2] set To [lindex $lProfilDuMAF 3] set Score [lindex $lProfilDuMAF 6] set lSeq [split [string toupper [lindex $lProfilDuMAF 7]] ""] ### 2.1- Premier parcours du block d'alignement if {![info exists Tab(BlockAli,$BlockAli)]} { # i parcoure les BlockPos, j les BlockPos ayant un Query Res set IDRefSeq $ID set i 0 set j 0 set Tab(BlockAli,$BlockAli,LesBlockPos) {} set Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery) {} set BlockQueryPosBegin $From set BlockQueryPosEnd $To foreach Res $lSeq { lappend Tab(BlockAli,$BlockAli,LesBlockPos) $i if {$Res == "N" || $Res == "X" ||![regexp {[A-Z]} $Res]} {incr i ; continue} set QueryPos [expr $From + $j] lappend Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery) $i set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$i,QueryPos) $QueryPos set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$i,QueryRes) $Res incr i incr j } # Compte dans combien de BlockAli sont presentes chaque QueryPos for {set QueryPos $From} {$QueryPos <= $To} {incr QueryPos} { incr Tab(QueryPos,$QueryPos,NbBlockAli) } set Tab(BlockAli,$BlockAli) 1 } ### 2.2- Parcours suivants du block d'alignement, incrementation de n foreach BlockPosDeLaQuery [set Tab(BlockAli,$BlockAli,LesBlockPosDeLaQuery)] { set Res [lindex $lSeq $BlockPosDeLaQuery] set QueryPos [set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$BlockPosDeLaQuery,QueryPos)] set QueryRes [set Tab(BlockAli,$BlockAli,BlockPosDeLaQuery,$BlockPosDeLaQuery,QueryRes)] #Espionne "BlockAli,$BlockAli,BlockPosDeLaQuery,$BlockPosDeLaQuery,ID,$ID,Res,$Res,QueryRes,$QueryRes" if {$Res != $QueryRes} {continue} ### si cette QueryPos a deja ete rencontree avec ces deux meme organismes, on continue ### cad que l'on incremente qu'une fois n par couple d'organismes pour chaque QueryPos if {[info exists Tab(IDRefSeq,$IDRefSeq,ID,$ID,QueryPos,$QueryPos)]} {continue} if {$Res == "N" || $Res == "X" ||![regexp {[A-Z]} $Res]} {continue} # on cree cette info seulement si le res n'est pas "N", "X" ou "-" set Tab(IDRefSeq,$IDRefSeq,ID,$ID,QueryPos,$QueryPos) 1 incr Tab(QueryPos,$QueryPos,n) #Espionne "[set Tab(QueryPos,$QueryPos,n)]" } } ### 3- Creation de la liste LeProfiln ### i parcoure toutes les positions de la query for {set i 1} {$i <= $QueryLength} {incr i} { lappend Lesn [set Tab(QueryPos,$i,n)] } ### 4-Pour les positions pas presentes dans un BlockAli, met n a 1 car il y a au moins la seq query foreach n $Lesn { if {$n == "0"} {set n 1} lappend LesnOUT $n } return $LesnOUT } proc LeProfilnSurNDesQueryPosDuMAF {Lesn LesN} { set LeProfilnSurN {} foreach n $Lesn N $LesN { ### met nSurN a 0 si n=0 ou si seule la query a un residu a cette position, sinon calcul de nSurN ### n=0 signifie que cette QueryPos n'est pas dans les blocks d'alignement if {$n == 1 || ($n == 1 && $N == 1)} {set nSurN 0} else {set nSurN [expr $n * 1.0 / $N]} ### lappend LeProfilnSurN $nSurN } return $LeProfilnSurN } proc LeRepertoireDeRefSeq {Acc} { Wup "Design de RefSeq complet, environ 19000" Wup "Les fichiers de la banque RefSeq ont ete separes dans des sous repertoires" Wup "19700 entrees NM reparties dans 371 repertoires" Wup "Une entree refseq NMXXXXXX, nous avons donc pris les 4 premies chiffres" Wup "ex: NM012349 sera stockee dans le repertoire NM0123" set Rep "" if {! [regexp {NM[0-9]{4}} $Acc Rep]} { return "" } else { return "$Rep" } } proc LeTamis {Tam {Commande ""}} { global RepertoireDuGenome global LeTamis global LeTamisDeLaCommande Wup "Manages the file and array containing the Tamis" set FichierDesTamis "$RepertoireDuGenome/fiches/nomcommande-tamis" if {$Tam=="RelireEtReecrireLeFichierDesTamis"} { if {[info exists LeTamis]} {unset LeTamis} set ReecrireLeFichierDesTamis 1 } else { set ReecrireLeFichierDesTamis 0 } if {$Tam=="NeConnaitPasEncore" || $Tam=="LeNomDuTamisAssocieA"} { if { ! [info exists LeTamis(EstCharge)]} { LeTamis Turlututu } if {[info exists LeTamisDeLaCommande($Commande)]} { return 0 } else { if {$Tam=="NeConnaitPasEncore"} { return 1 } if {$Tam=="LeNomDuTamisAssocieA"} { return [set LeTamisDeLaCommande($Commande)] } } } if {$Commande!=""} { set CommandeExistante [LeTamis $Tam] if {$CommandeExistante=="TamisInconnu"} { AppendAuFichier $FichierDesTamis "$Tam $Commande" if {[info exists LeTamis]} { unset LeTamis } return [LeTamis $Tam] } if {$CommandeExistante==$Commande} { return $Commande } if {[OuiOuNon " The new\n$Tam $Commande\n wants to replace the old\n$Tam $CommandeExistante\n Do you want to replace it ?"]} { AppendAuFichier $FichierDesTamis "$Tam $Commande" if {[info exists LeTamis]} { unset LeTamis } LeTamis "RelireEtReecrireLeFichierDesTamis" return [LeTamis $Tam] } return "" } if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]} if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"} if {[file exists $FichierDesTamis]} { set LesLignesTamis [LesLignesDuFichier $FichierDesTamis] } else { set LesLignesTamis {} } if {[info exists LeTamis]} { unset LeTamis } foreach Ligne $LesLignesTamis { scan $Ligne "%s" TamisLu regsub "$TamisLu " $Ligne "" CommandeLue set LeTamis($TamisLu) $CommandeLue set LeTamisDeLaCommande($CommandeLue) $TamisLu } set LesLignesTamis {} set LaListe {} foreach TamExistant [lsort [array names LeTamis]] { lappend LeTamis(LaListeMerci) $TamExistant lappend LesLignesTamis "$TamExistant [set LeTamis($TamExistant)]" } if {$ReecrireLeFichierDesTamis} { SauveLesLignes $LesLignesTamis dans $FichierDesTamis } set LeTamis(EstCharge) "TamisCharge" if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]} if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"} } proc LeUGIdUN_Fastacmd {LesAccess {UGIdOnly ""}} { Wup "Recupere grace a fastacmd le numero unigene" #####lcl|UG:Hs#S1730160 #Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), /cds=(104,1237) /gb=NM_001100 /gi=5016087 /ug=Hs.1288 /len=1374 set LesResultats "" foreach Acc $LesAccess { set EnteteFCmd [FastaCmd "$Acc" "" 0] set tmp "" set tmp2 "" set Res [regexp -nocase {/ug=([a-z][a-z].[0-9]+)} $EnteteFCmd tmp tmp2] if {$UGIdOnly==""} { lappend LesResultats "$Acc $tmp2" } else { lappend LesResultats "$tmp2" } } return $LesResultats } proc LeUGIdUN_Getz {Access {Banques ""} {Link ""} {FullOut 0}} { Wup "Permet de recuperer l acc unigene (Hs.524782) a partir de l acc uniseq (Hs_S1000253 ou Hs#S1000253)" if {$Banques==""} {set Banques "uniseq"} if {$Link ==""} {set Link "unigene"} set LesAccess "" set UnAccess "" if {$Banques == "uniseq"} { foreach AC [lsort -unique $Access] { set UnAccess [lindex $AC 0] if {[regexp -nocase "UG:" $AC]} {regsub -all "UG:" $UnAccess "" UnAccess} if {[regexp -nocase "Hs#" $AC]} {regsub -all "Hs#" $UnAccess "Hs_" UnAccess} if {[regexp -nocase "Mm#" $AC]} {regsub -all "Mm#" $UnAccess "Mm_" UnAccess} lappend LesAccess $UnAccess } set Access [join $LesAccess "|"] } if {$Access == ""} {return ""} set option "-vf \"ugi\" -cs \";\"" #On utilise le champs ugi dans Uniseq pour obtenir l Id Unigene set Commande "getz $option \"\\\[$Banques-all: $Access\\\]\"" #UNISEQ:Hs_S1000253;Hs.524782 #On utilise le champs ugi dans Uniseq pour obtenir l Id Unigene #set Commande "getz $option \"\\\[$Banques-all: $Access\\\] \\\> $Link \"" #UNIGENE:Hs_S1000253;Hs.524782 catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message set UGId "" if {![info exists GetzOut]} {return ""} if { $GetzOut == ""} {return ""} foreach ID $GetzOut { if {$FullOut} {lappend UGId [split $ID ";"]} else {lappend UGId [lindex [split $ID ";"] 1]} } #set UGId [lindex [split $GetzOut ";"] 1] return "$UGId" } proc LeUnigeneDeUniseq {LesAcc} { Wup "Permet de recuperer l acc unigene (Hs.524782) a partir de l acc uniseq (Hs_S1000253 ou Hs#S1000253)" if {$LesAcc==""} {return ""} set Resultat "" set Resultat [LeUGIdUN_Getz $LesAcc uniseq unigene 0] if { $Resultat==""} { set Resultat [LeUGIdUN_Fastacmd $LesAcc UGIdOnly] } set Resultat [join $Resultat ""] return $Resultat } proc LeUnigeneDeUniseq_GUI {LesAcc} { Wup "Permet de recuperer l acc unigene (Hs.524782) a partir de l acc uniseq (Hs_S1000253 ou Hs#S1000253)" if {$LesAcc==""} {return ""} set Resultat "" set Resultat [LeUGIdUN_Getz $LesAcc uniseq unigene 1] if { $Resultat==""} { set Resultat [LeUGIdUN_Fastacmd $LesAcc] } if { $Resultat==""} { set Resultat "No Unigene Id or link available for [join $LesAcc " "]" } else { set Resultat [join $Resultat "\n"] } set Fen [AfficheVariable $Resultat "AvecFormateAvecBlaste" "Unigene Id search"] return $Fen } proc LeaveBox {K X Y} { global CouleurEnEntree oldText if { ! [info exists CouleurEnEntree]} { return } set Id [$K find withtag current] $K itemconfigure $Id -fill $CouleurEnEntree # ShowBox $K $X $Y "Leave" } proc LectureBilanHDACroises {aLesFamilles aLesOrgCibles aBilan {Fichier ""}} { global RepertoireDuGenome upvar $aLesFamilles LesFamilles upvar $aLesOrgCibles LesOrgCibles upvar $aBilan Bilan set LesFamilles [list] set LesOrgCibles [list] set FichierDefaut "$RepertoireDuGenome/fiches/bilan_hda_croises" if {$Fichier=="AskForFile"} { set Fichier [ButineArborescence "All" $FichierDefaut] if {$Fichier==""} { return "" } } if {$Fichier==""} { set Fichier $FichierDefaut } if {![file exists $Fichier]} {return ""} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s %s %s %s" Fam Org TblastN BlastP Jaune set Bilan($Fam,$Org) [list $TblastN $BlastP $Jaune] if {![info exists DejaVuF($Fam)]} { lappend LesFamilles $Fam set DejaVuF($Fam) 1 } if {![info exists DejaVuO($Org)]} { lappend LesOrgCibles $Org set DejaVuO($Org) 1 } } return $Fichier } proc LectureClusters {File atab aNG {NmG Group}} { upvar $atab tab upvar $aNG NomsGroupe set NmG "Group" # Lit les fichiers issus de CLUSPACK mais # SANS LES COORDONNEES !!! set LLignes [LesLignesDuFichier $File] # set Ln [split [lindex $LLignes 0] ":"] # set NbrGrp [string trim [lindex $Ln 1]] set LLignes [lrange $LLignes 2 end] set i 1 foreach l $LLignes { if {[regexp {^Cluster|^Unclustered} $l]} { set NmGrp "$NmG$i" lappend NomsGroupe $NmGrp } elseif {$l != ""} { lappend tab($NmGrp) [string trim $l] } else { incr i } } return 1 } proc LectureDeChainePDB {LesLignes MolId {Polymer 1}} { global PDB_[set MolId]_TypAtm global PDB_[set MolId]_NomAtm global PDB_[set MolId]_NomRes1l global PDB_[set MolId]_NomRes3l global PDB_[set MolId]_NmrRes global PDB_[set MolId]_ChnIdn global PDB_[set MolId]_AtmXYZ global PDB_[set MolId]_AtmBQ global PDB_[set MolId]_Sequence global PDB_[set MolId]_Header global PDB_[set MolId]_Site set Vraia 0 set ChaineCourant -1 set ResiduCourant -999 set AlterLocRes "" set CC "" set PremRes 1 set Latmn {} set Latmx {} set Latmb {} set Latmz {} foreach ligne $LesLignes { set ee " $ligne" set AtomName [string range $ee 13 16] # set AlterLocRes [string index $ee 17] set NomRes3L [string range $ee 18 20] set NomRes1L [AutreCodeLuc $NomRes3L] scan [string range $ee 23 27] "%s" ResidueNumber scan [string range $ee 31 54] "%8f%8f%8f" x y z set AtomXYZ [list $x $y $z] scan [string range $ee 55 66] "%6f%6f" q b set AtomBQ [list $b $q] set AtomNA [NoAtomicDe [string trim [string range $ee 77 78]]] ## ATTENTION !! # Cette version ne lit pas les hydrogenes ! if {$AtomNA==1} {continue} # if {[regexp {^[0-9H]} [string trim $AtomName]]} {continue} set ChainIdent [string index $ee 22] # if {$AlterLocRes ne ""} {continue} if {$ResiduCourant == -999} { set ResiduCourant $ResidueNumber set CC $ChainIdent } if {$ResidueNumber != $ResiduCourant} { lappend PDB_[set MolId]_TypRes($CC) $Polymer lappend PDB_[set MolId]_NomRes1l($CC) $N1LCou lappend PDB_[set MolId]_NomRes3l($CC) $N3LCou lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb lappend PDB_[set MolId]_AtmNA($CC) $Latmz set Latmn {} set Latmx {} set Latmb {} set Latmz {} if {$ChainIdent ne $ChaineCourant} { lappend PDB_[set MolId]_ChnIdn $ChainIdent set ChaineCourant $ChainIdent set CC $ChainIdent } } lappend Latmn $AtomName lappend Latmx $AtomXYZ lappend Latmb $AtomBQ lappend Latmz $AtomNA set ResiduCourant $ResidueNumber set N3LCou $NomRes3L set N1LCou $NomRes1L } if { ! [info exists N1LCou]} { return 0 } # lappend ChnIdn $CC lappend PDB_[set MolId]_TypRes($CC) $Polymer lappend PDB_[set MolId]_NomRes1l($CC) $N1LCou lappend PDB_[set MolId]_NomRes3l($CC) $N3LCou lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb lappend PDB_[set MolId]_AtmNA($CC) $Latmz return $Vraia set PremiereChaine "" if {! [info exists PDB_[set MolId]_ChnIdn]} { set LdesC {} } else { set LdesC [set PDB_[set MolId]_ChnIdn] } set ChaineCourant -1 set AtmTypCourant "" set NomResCourant "" set ResiduCourant -999 set AlterLocRes "" set CC "" set PremRes 1 set Latmn {} set Latmx {} set Latmb {} foreach ligne $LesLignes { set ee " $ligne" set AtmTyp [string range $ee 1 4] set AtomName [string range $ee 13 16] # set AlterLocRes [string index $ee 17] set ResidueName [string range $ee 18 20] set ChainIdent [string range $ee 22 22] if {$PremiereChaine eq ""} {set PremiereChaine $ChainIdent} scan [string range $ee 23 27] "%s" ResidueNumber scan [string range $ee 31 54] "%8f%8f%8f" x y z set AtomXYZ [list $x $y $z] scan [string range $ee 55 66] "%6f%6f" q b set AtomBQ [list $b $q] # ATTENTION ! On ne prend pas les hydrogenes ! if {[string index [string trim $AtomName] 0] eq "H"} {continue} if {[lsearch $LdesC $ChainIdent] != -1} {continue} # if {$AlterLocRes ne ""} {continue} if {$ResiduCourant == -999} { set ResiduCourant $ResidueNumber set NomRes1L [AutreCodeLuc $ResidueName] set CC $ChainIdent set AtmTyp $AtmTyp } if {$ResidueNumber != $ResiduCourant} { set NomRes1L [AutreCodeLuc $ResidueName] lappend PDB_[set MolId]_NomRes($CC) $NomResCourant lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_TypAtm($CC) $AtmTypCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb set Latmn {} set Latmx {} set Latmb {} if {$ChainIdent ne $ChaineCourant} { lappend PDB_[set MolId]_ChnIdn $ChainIdent set ChaineCourant $ChainIdent set CC $ChainIdent } } lappend Latmx $AtomXYZ lappend Latmb $AtomBQ lappend Latmn $AtomName set AtmTypCourant $AtmTyp set ResiduCourant $ResidueNumber set NomResCourant $NomRes1L } # lappend PDB_[set MolId]_ChnIdn $ChainIdent if {$NomResCourant ne "XXX"} { lappend PDB_[set MolId]_NomRes($CC) $NomResCourant lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_TypAtm($CC) $AtmTypCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb } return $Vraia } proc LectureEtIntegrationDesRefsRho {{FichierOut ""}} { Wup "Permet de lire le fichier contenant les nouvelles references pour les sequences Rho" Wup "Permet de verifier si possede deja la ref et sinon de la stocker au format TFA" set Fichier "[RepertoireDuGenome]/LV_Rho_RefAdd_sept04.txt" if {$FichierOut==""} { set FichierOut "[RepertoireDuGenome]/NewRhoTFA.tfas" } set LesAccess "" #Official gene symbol and Name (HGNC) Reference NCBI Fonction Synonyme Observations #PAK5 AB_040812 Rho-effector p21-activated kinase 5 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if { [regexp -nocase "^Official" $Ligne]} {continue} set LigneSplitee [split $Ligne "\t"] set Name [lindex $LigneSplitee 0] set Access [lindex $LigneSplitee 1] set Definition [lindex $LigneSplitee 2] if {$Access==""} {continue} lappend LesAccess $Access } close $F #Espionne "NbAccess [llength $LesAccess]" set LesAccess [lsort -unique $LesAccess] #Espionne "NbAccess [llength $LesAccess]" set nbendouble 0 set NewAccess "" foreach Acc $LesAccess { if {![regexp "^RSHUM:NM" $Acc]} { regsub "^NM_" $Acc "RSHUM:NM" Acc } if {[InterrogeLesAccessRefSeqDesPABs $Acc] == "1"} { #Espionne "$Acc en double" incr nbendouble continue } lappend NewAccess $Acc } set NewAccess [lsort -unique $NewAccess] #Espionne "NbAccess [llength $NewAccess]" #Espionne "NbEnDouble $nbendouble" foreach NAcc $NewAccess { if {[regexp "^RSHUM:NM" $NAcc]} { regsub "^RSHUM:NM" $NAcc "NM_" NAcc } set Entete ">$NAcc from NCBI" #Espionne "$Entete" set Sequence [SequenceDuNCBI $NAcc nucleotide] if {$Sequence == ""} { Espionne "Pb $NAcc" } #Espionne "$Sequence" set Tfa [join [list $Entete $Sequence] "\n"] AppendAuFichier $FichierOut $Tfa } return "" } proc LectureOrdaliDB {file} { global LNOrdali LSOrdali {*}[info globals "TD*"] global Sequences TabSF ListeDesFragments global LNDG SDG db CompteurDeMac Defauts set db root sqlite3 $db $file -nomutex 1 if {0 && [VersionOrdalieDB]} { UpgradeOrdalieDB } # fichier backup de db file tempfile Defauts(FichierOBK) $db backup $Defauts(FichierOBK) $db eval {begin transaction} # Paramtres Ordalie set Lkv [$db eval {select * from ordalie}] set Lt [$db eval {select distinct(var) from ordalie}] global {*}$Lt foreach {t k v} $Lkv { set ${t}($k) $v } InitInfoArrays global {*}[info globals "TD*"] set Li [$db eval {select * from seqinfo}] set Ln [$db eval {select seqname from seqinfo}] set i 0 ; set k 0 while {$i < [llength $Li]} { set Lval [lrange $Li $i [expr {$i+17}]] set n [lindex $Ln $k] foreach t {tmp TDesSeqnames TDesAccess TDesBId TDesDescriptifs TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesPhylum TDesGO TDuLineage TDesHydro TDespI TDesMolW tmp} v $Lval { if {$t eq "tmp"} {continue} set ${t}($n) $v } incr i 18 incr k } set ListeDesFragments [list] foreach k [array names TDesFragment] { if {[set TDesFragment($k)]} { lappend ListeDesFragments $k } } set pkm [$db eval {select max(pk_mac) from mac}] set nom [$db eval {select name from mac where pk_mac=$pkm}] $db eval {commit} LesDefauts IxMacCourant $pkm LesDefauts NmMacCourant $nom set CompteurDeMac $pkm CreatePDBFromDB CreeVue InitPosSeqGenGenSeq InfosDesPDB TraiteAABizarres CalculeComposition CalculeMolecularWeight LogSeqInfoGlobales LogLesCompositions return } proc LecturePolyr {} { global Ltrig Lvert Lnorm set Ll [LesLignesDuFichier toto.nff] lassign [split [lindex $Ll 3] " "] nvec tom tom] puts "nvert $nvec" set i 4 set k 0 while {$k < $nvec} { set l [lindex $Ll $i] regsub -all { +} $l " " l lassign [split $l " "] x y z tmp lappend Lvert [list $x $y $z] incr i incr k } puts "line : [lindex $Ll $i]" puts "nvert [llength $Lvert]" set ntrig [lindex $Ll $i] incr i set k 0 puts "face $ntrig" while {$k < $ntrig} { set l [lindex $Ll $i] regsub -all { +} $l " " l lassign [split [string trim $l]] n a b c tmp lappend face [list $a $b $c] incr i incr k } puts "faces [llength $face]" puts "line : [lindex $Ll $i]" set nnorm [lindex $Ll $i] set k 0 incr i puts "norm $nnorm" while {$k < $nnorm} { set l [lindex $Ll $i] regsub -all { +} $l " " l lassign [split [string trim $l]] x y z lappend Lnorm [list $x $y $z] incr i incr k } puts "nnorms [llength $Lnorm]" puts [join [lrange $face end-10 end] \n] foreach f $face { lassign $f a b c lappend Ltrig [list [lindex $Lvert $a] [lindex $Lvert $b] [lindex $Lvert $c]] } return } proc LectureQHull {} { global Ltrig Lnorm Lvert set Ll [LesLignesDuFichier coord.vec] set i -1 set lec 0 while {$i < [llength $Ll]} { incr i set l [lindex $Ll $i] if {[regexp {OFF} $l]} { set lec 1 set k 0 continue } if {$lec} { regsub -all { +} [string trim $l] " " l if {$k < 3} { lassign [split $l " "] x y z lappend Lvert [list $x $y $z] incr k } else { lassign [split $l " "] n a b c nx ny nz t p lappend Lnorm [list $nx $ny $nz] set lec 0 } } } foreach {v1 v2 v3} $Lvert { lappend Ltrig [list $v1 $v2 $v3] } return } proc Lego {FiPdb FiMod FiFa {FragSize ""} {FragNumber ""} {StackSize ""}} { if {$FragSize ==""} { set FragSize 5 } if {$FragNumber==""} { set FragNumber 20 } if {$StackSize !=""} { set Options "-g $StackSize" } exec /home/koehl/program/lego/Lego -i $FiPdb -o $FiMod -f $FiFa -s $FragSize -n $FragNumber $Options return $FiMod } proc LemRNADeLAccessProt {Access} { set TailleProt [TailleDeLaProt_PageInfo [PageInfo $Access protein ID]] if {$TailleProt == ""} { set SeqProt [SequenceDeLAccess $Access protein] regsub -nocase {[^a-z]*} $SeqProt "" SeqProt set TailleProt [string length $SeqProt] } set LesAcNucs [ElimineLesRedondancesDansUneListe [LesAcNucsDeLAccess $Access]] set LesmRNACandidats [LesmRNAsDesAcNucs $LesAcNucs] return [LeMeilleurmRNACandidat $LesmRNACandidats $TailleProt] } proc LemRNADeLAccessProt_PageInfo {PageInfo} { set TailleProt [TailleDeLaProt_PageInfo $PageInfo] set LesAcNucs [ElimineLesRedondancesDansUneListe [LesAcNucsDeLAccess_PageInfo $PageInfo]] set LesmRNACandidats [LesmRNAsDesAcNucs $LesAcNucs] return [LeMeilleurmRNACandidat $LesmRNACandidats $TailleProt] } proc LeonEtMacsimPourTous {{Liste ""} {Keep ""} {SqueezeLeon ""}} { set SqueezeLeon [string equal -nocase $SqueezeLeon "SqueezeLeon"] set RepLeo "[RepertoireDuGenome]/msfLeon" set RepLog "[RepertoireDuGenome]/leonLog" set RepRsf "[RepertoireDuGenome]/macsimRsf" set RepXml "[RepertoireDuGenome]/macsimXml" if {$SqueezeLeon} { set RepLeo "[RepertoireDuGenome]/msf" } if { ! [file exists $RepLeo]} {file mkdir $RepLeo} if { ! [file exists $RepLog]} {file mkdir $RepLog} if { ! [file exists $RepRsf]} {file mkdir $RepRsf} if { ! [file exists $RepXml]} {file mkdir $RepXml} if {$Keep==""} { set Keep "Keep" } if {$Keep=="Keep"} { set Keep 1 } else { set Keep 0 } if {[regexp "^StartWith" $Liste]} { set Premier [StringApres "StartWith" dans $Liste] set Liste [ListeDesPABs] set I [lsearch $Liste $Premier] set Liste [lrange $Liste $I end] } else { if {$Liste==""} { set Liste [ListeDesPABs] } if {[EstUnPAB $Liste]} { set Liste [list $Liste] } } foreach Nom $Liste { Espionne "LeonEtMacsim s'occupent de $Nom" set FichierMSF "[RepertoireDuGenome]/msf/$Nom" if { ! [file exists $FichierMSF]} { continue } if {[file size $FichierMSF] < 50} { continue } set FichierLeo "$RepLeo/$Nom" set FichierLog "$RepLog/$Nom" set FichierRsf "$RepRsf/$Nom" set FichierXml "$RepXml/$Nom" set Query $Nom if {[regexp "QUERY_PROTEIN" [ContenuDuFichier $FichierMSF]]} { set Query "QUERY_PROTEIN" } regsub ".rsf$" $FichierRsf "" FichierRsfSansExtension if { $Keep && [file exists $FichierRsfSansExtension]} { continue } if { $Keep && [file exists $FichierRsf]} { continue } if {[PasTouche $Nom]} { continue } set OnTeste [OnTraite "TestUniref"] set CommandeLeon "leon" if {$OnTeste} { set CommandeLeon "/home/julie/LEON2/leon2.tcsh" } if { ! [file exists $FichierLeo]} { if {[file exists $FichierLog]} { file delete $FichierLog } set FichierLeoXml $FichierLeo.xml if {[file exists $FichierLeoXml]} { file delete $FichierLeoXml } Espionne "$CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog" exec $CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog } if {[file exists $FichierXml]} { file delete $FichierXml } if {[file exists $FichierRsf]} { file delete $FichierRsf } if { ! [file exists $FichierLeo]} { set MonMessage "$FichierLeo was not created by Leon ... Bouhhh !" AppendAuFichier $FichierLog $MonMessage Warne $MonMessage FinPasTouche $Nom continue } ConvertToOneHundred $FichierLeo $FichierLeo if { ! $OnTeste } { NousAllonsAuBoulot set FichierRsfLog "$FichierRsf.log" if {[file exists $FichierRsfLog]} {file delete $FichierRsfLog} Espionne "ExecuteMacsim $FichierLeo $FichierRsf" set Message [ExecuteMacsim $FichierLeo $FichierRsf] OnRevientDuBoulot set FichierRsfRsf "$FichierRsf.rsf" set FichierRsfXml "$FichierRsf.xml" if {[file exists $FichierRsfXml]} { file rename $FichierRsfXml $FichierXml } if { ! [file exists $FichierRsfRsf]} { set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message" Warne $MonMessage AppendAuFichier $FichierRsfLog $MonMessage } else { file rename $FichierRsfRsf $FichierRsf if {[file exists $FichierRsfLog]} { file delete $FichierRsfLog } Espionne "$FichierRsf is OK !" } } FinPasTouche $Nom } } proc LeonEtMacsimPourTousX {{Liste ""} {Keep ""}} { set RepLeo "[RepertoireDuGenome]/msfLeon" set RepLog "[RepertoireDuGenome]/leonLog" set RepRsf "[RepertoireDuGenome]/macsimRsf" set RepXml "[RepertoireDuGenome]/macsimXml" if { ! [file exists $RepLeo]} {file mkdir $RepLeo} if { ! [file exists $RepLog]} {file mkdir $RepLog} if { ! [file exists $RepRsf]} {file mkdir $RepRsf} if { ! [file exists $RepXml]} {file mkdir $RepXml} if {$Keep==""} { set Keep "Keep" } if {$Keep=="Keep"} { set Keep 1 } else { set Keep 0 } if {[regexp "^StartWith" $Liste]} { set Premier [StringApres "StartWith" dans $Liste] set Liste [ListeDesPABs] set I [lsearch $Liste $Premier] set Liste [lrange $Liste $I end] } else { if {$Liste==""} { set Liste [ListeDesPABs] } if {[EstUnPAB $Liste]} { set Liste [list $Liste] } } #Peut-etre rajouter ici un pastouche!!! Pou ne pas modifie ce qui a deja ete fait!!!??? foreach Nom $Liste { Espionne "LeonEtMacsim s'occupent de $Nom" set FichierMSF "[RepertoireDuGenome]/alignFasta/$Nom" if { ! [file exists $FichierMSF]} { continue } if {[file size $FichierMSF] < 50} { continue } set FichierLeo "$RepLeo/$Nom" set FichierLog "$RepLog/$Nom" set FichierRsf "$RepRsf/$Nom" set FichierXml "$RepXml/$Nom" set Query $Nom if {[regexp "QUERY_PROTEIN" [ContenuDuFichier $FichierMSF]]} { set Query "QUERY_PROTEIN" } regsub ".rsf$" $FichierRsf "" FichierRsfSansExtension if { $Keep && [file exists $FichierRsfSansExtension]} { continue } if { $Keep && [file exists $FichierRsf]} { continue } if {[PasTouche $Nom]} { continue } if { ! [file exists $FichierLeo]} { if {[file exists $FichierLog]} { file delete $FichierLog } exec leon $FichierMSF $Query $FichierLeo $FichierLog } if {[file exists $FichierXml]} { file delete $FichierXml } if {[file exists $FichierRsf]} { file delete $FichierRsf } if { ! [file exists $FichierLeo]} { set MonMessage "$FichierLeo was not created by Leon ... Bouhhh !" AppendAuFichier $FichierLog $MonMessage Warne $MonMessage FinPasTouche $Nom continue } ConvertToOneHundred $FichierLeo $FichierLeo NousAllonsAuBoulot set FichierRsfLog "$FichierRsf.log" if {[file exists $FichierRsfLog]} {file delete $FichierRsfLog} set Message "" Espionne "execute [HomeRipp]/gscope/bin/macsim $FichierLeo $FichierRsf" #erreur la commande existe pas catch {exec /biolo/macsim/macsim $FichierLeo $FichierRsf} Message #catch {exec [HomeRipp]/gscope/bin/macsim $FichierLeo $FichierRsf} Message OnRevientDuBoulot set FichierRsfRsf "$FichierRsf.rsf" set FichierRsfXml "$FichierRsf.xml" if {[file exists $FichierRsfXml]} { file rename $FichierRsfXml $FichierXml } if { ! [file exists $FichierRsfRsf]} { set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message" Warne $MonMessage AppendAuFichier $FichierRsfLog $MonMessage } else { file rename $FichierRsfRsf $FichierRsf if {[file exists $FichierRsfLog]} { file delete $FichierRsfLog } Espionne "$FichierRsf is OK !" } FinPasTouche $Nom } } proc LeonExe {} { global tcl_platform global OrdBinDir global env if {[info exists env(GRILLE)] && $env(GRILLE)} { return "./leon" } if {[set tcl_platform(platform)] != "windows"} { if {[info exists OrdBinDir]} { return [file join $OrdBinDir "leon"] } else { return "/biolo/leon/leon" } } else { set lexe [file join $OrdBinDir "leon.exe"] regsub "Program Files" $lexe "PROGRA~1" lexe return $lexe } } proc LeonGrid {NomATraiter} { global PipeCollection global PipeQuery set Vd "" set Vr "" if {$PipeCollection} { set InMsf [file join [RepertoireDuGenome] msf $NomATraiter] set InRascal [file join [RepertoireDuGenome] rascal $NomATraiter] set OutMsf [file join [RepertoireDuGenome] leon $NomATraiter] set OutLog [file join [RepertoireDuGenome] leon "${NomATraiter}.log"] set fnormd [file join [RepertoireDuGenome] normd $NomATraiter] if {[file exists $OutMsf]} {return 1} } else { set NomATraiter [file rootname $NomATraiter] set InMsf "${NomATraiter}.msf" set InRascal "${NomATraiter}.rascal.msf" set OutMsf "${NomATraiter}.leon.msf" set OutLog "${NomATraiter}.leon.log" set fnormd "${NomATraiter}.normd" } if {! [file exists $fnormd]} {return 0} if {! [file exists $InMsf]} {return 0} set Ll [LesLignesDuFichier $fnormd] foreach l $Ll { if {[regexp "dbclustal" $l]} { set Vd [string range $l [expr [string first ":" $l] +2] end] } if {[regexp "rascal" $l]} { set Vr [string range $l [expr [string first ":" $l] +2] end] } } if {$Vd == "undetermined"} {return 0} if {$Vr == "undetermined"} { set In $InMsf AjouteAuLogPipe "leon sur dbclustal" } elseif {$Vd > $Vr} { set In $InMsf AjouteAuLogPipe "leon sur dbclustal" } else { set In $InRascal AjouteAuLogPipe "leon sur rascal" } #puts "lesentreesdeleon" #puts "$In $PipeQuery $OutMsf $OutLog" catch {eval exec [LeonExe] $In $PipeQuery $OutMsf $OutLog} Message if {[file exists $OutMsf]} { AjouteAuLogPipe "leon = ok" return 1 } else { AjouteAuLogPipe "leon failed" return 0 } } proc LesAAFrequents {FichierCod} { set LesFreq [CreeListeCodonFrequency $FichierCod] set LesFreqTrie [lsort -index 2 -decreasing $LesFreq] set LesFirst [lrange $LesFreqTrie 0 2] foreach AA $LesFirst { set f [lindex $AA 2] set fa [format "%.2f" $f] set AA [lreplace $AA 2 2 $fa] lappend LesFirstArr $AA } return $LesFirstArr } proc LesAALesPlusDifferents {FichierCodMusRef FichierCodSeq} { set LesDifferences [CompareDeuxTablesCodonFrequency $FichierCodMusRef $FichierCodSeq] set LesPlus [lrange $LesDifferences 0 2] return $LesPlus } proc LesAALesPlusDifferentsPourTous {} { set FichierCodMusRef "[RepertoireDuGenome]/codonfrequency/mus.cod" foreach Nom [ListeDesPABs] { set FichierCodSeq "[RepertoireDuGenome]/codonfrequency/tables_codonfrequency/$Nom.cod" set LesPlus [LesAALesPlusDifferents $FichierCodMusRef $FichierCodSeq] append Tous "$LesPlus\n" } return $Tous } proc LesAcNucsDeLAccess {Access} { #set PageInfo [join [LaSequenceDesBanques $Access $Access AccessOk "OnVeutNature"] "\n"] set PageInfo [PageInfo $Access protein DR] return [LesAcNucsDeLAccess_PageInfo $PageInfo] } proc LesAcNucsDeLAccess_PageInfo {PageInfo} { #set PageInfo [join [LaSequenceDesBanques $Access $Access AccessOk "OnVeutNature"] "\n"] set LesAcNucs [LesAcNucsDeLaProt_PageInfo $PageInfo] return $LesAcNucs } proc LesAcNucsDeLaProt_PageInfo {PageInfo} { set LesAcNucs {} foreach EMBL [LeChampsDeLaPageProteine $PageInfo DR] { if {![regexp -nocase "EMBL" $EMBL]} {continue} regsub "DR" $EMBL "" EMBL regsub "EMBL;" $EMBL "" EMBL set EMBL [string trim $EMBL] lappend LesAcNucs [string toupper [lindex [split $EMBL ";"] 0]] } return $LesAcNucs } proc LesAccDuneLigne {NumeroLigne} { set nbdefois 0; set trop 0; set onaligne 0 foreach Ligne [LesLignesDuFichier "/genomics/link/EVI3/parser/AttriToutVf2"] { if {![regexp "^ligne $NumeroLigne" $Ligne] && [regexp "^ligne" $Ligne]} { set onaligne 0 } if {[regexp "^ligne $NumeroLigne " $Ligne]} { set onaligne 1; set nbdefois 0 } if {$onaligne && [regexp "^>" $Ligne]} { incr nbdefois } } Espionne "Pour La Ligne $NumeroLigne, on a $nbdefois access mrna" } proc LesAccRSEtUG_Affymetrix {{LesPABs ""}} { Wup "Permet de sauver les resultats des recherches dans RefSeq et Unigene des sequence de la puce EST" set FichierSave "[RepertoireDuGenome]/LesAccDefRefSeqUnigene2" if {[file exists $FichierSave]} { set F [open "$FichierSave"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} set DejaFait([lindex $Ligne 0]) 1 continue } close $F } set Texte "Gscope Access\tAffymetrixAccess\tAccRefSeq\tIdGRefSeq\tCoverRefSeq\tDefRefSeq\tAccUnigene\tUGId\tIdGUnigene\tCoverUnigene\tDefUnigene" AppendAuFichier $FichierSave $Texte set Texte "" if { $LesPABs == "LaTotale"} {set LesPABs [ListeDesPABs]} foreach PAB $LesPABs { if {[info exists DejaFait($PAB)]} {continue} #Espionne $PAB set AccRefSeq "" set AccUnigene "" #AffymetrixAccess set AffymetrixAccess [AffymetrixAccess $PAB] if {$AffymetrixAccess==""} {set AffymetrixAccess None} #Espionne "$AffymetrixAccess" set LesAccRefSeq [MeilleurAccDuBlast_Affymetrix $PAB "[RepertoireDuGenome]/blastnrsmouse_r18"] #Espionne "$LesAccRefSeq" if {$LesAccRefSeq==""} { set DefRefSeq "None" set IdGRefSeq "None" set CoverRefSeq "None" set AccRefSeq "None" } else { set LesAccDefRefSeq "" foreach AccRefSeq $LesAccRefSeq { set IdGRefSeq [format "%.2f" [lindex $AccRefSeq 1]] set CoverRefSeq [format "%.2f" [lindex $AccRefSeq 2]] set AccRefSeq [lindex $AccRefSeq 0] #Espionne "$AccRefSeq $IdGRefSeq $CoverRefSeq" set DefRefSeq [FastaCmd $AccRefSeq "" 0 "/genomics/g1/AffyProbes/banque/rsmouse_r18"] set DefRefSeq [lrange $DefRefSeq 2 end] #Espionne "$DefRefSeq" lappend LesAccDefRefSeq [list $AccRefSeq "$DefRefSeq"] } set Variant [DetectionDesVariants $LesAccDefRefSeq] if {$Variant != ""} { set LesAcc "" set LesDef "" foreach LAccDef $Variant { lappend LesAcc [lindex $LAccDef 0] lappend LesDef [lindex $LAccDef 1] } set AccRefSeq [join $LesAcc ";"] set DefRefSeq [join $LesDef ";"] } } #>lcl|RSHUM:NM001100 NM001100 Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), mRNA. 4/2003 set LesAccUnigene [MeilleurAccDuBlast_Affymetrix $PAB "[RepertoireDuGenome]/blastnunigenemm"] if {$LesAccUnigene==""} { set DefUnigene "None" set IdGUnigene "None" set CoverUnigene "None" set AccUnigene "None" } else { set LesDefsUnigene "" set LesAccsUnigene "" foreach AccUnigene $LesAccUnigene { set IdGUnigene [format "%.2f" [lindex $AccUnigene 1]] set CoverUnigene [format "%.2f" [lindex $AccUnigene 2]] set AccUnigene [lindex $AccUnigene 0] set DefUnigene [FastaCmd $AccUnigene "" 0 unigenemm] regsub -all {[\{\}]} $DefUnigene " " DefUnigene set DefUnigene [lrange $DefUnigene 1 end] lappend LesAccsUnigene "$AccUnigene" lappend LesDefsUnigene "$DefUnigene" } set AccUnigene [join $LesAccsUnigene ";"] set DefUnigene [join $LesDefsUnigene ";"] } #>lcl|UG#S345348 Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), mRNA. 4/2003 set UGId [LeUGIdUN_Getz [split $AccUnigene ";"]] if {$UGId==""} {set UGId "None"} else { set UGId [join $UGId ";"]} set Texte [join [list $PAB $AffymetrixAccess $AccRefSeq $IdGRefSeq $CoverRefSeq $DefRefSeq $AccUnigene $UGId $IdGUnigene $CoverUnigene $DefUnigene] "\t"] AppendAuFichier $FichierSave $Texte } return "" } proc LesAccRSEtUG_Ontario {{LesPABs ""}} { Wup "Permet de sauver les resultats des recherches dans RefSeq et Unigene des sequence de la puce EST" set FichierSave "[RepertoireDuGenome]/LesAccDefRefSeqUnigene" set FichierSave "[RepertoireDuGenome]/LesAccDefRefSeqUnigene3" if {[file exists $FichierSave]} { set F [open "$FichierSave"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} set DejaFait([lindex $Ligne 0]) 1 continue } close $F } set Texte "Gscope Access\tCodeClone\tAccRefSeq\tIdGRefSeq\tCoverRefSeq\tDefRefSeq\tAccUnigene\tUGId\tIdGUnigene\tCoverUnigene\tDefUnigene\tBlock\tRow\tColumn" AppendAuFichier $FichierSave $Texte set Texte "" if {$LesPABs == "LaTotale" || $LesPABs == ""} {set LesPABs [ListeDesPABs]} foreach PAB $LesPABs { if {[info exists DejaFait($PAB)]} {continue} Espionne $PAB set AccRefSeq "" set AccUnigene "" set CodeClone [CodeClone $PAB] if {$CodeClone==""} {set CodeClone NoneCC} set Access [split $CodeClone "_"] set OriginalId [lindex $Access 0] set VerifiedId [lindex $Access 1] set Block [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Block] set Column [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Col] set Row [InterrogeLeGalFile_Ontario $VerifiedId $OriginalId Row] #set AccRefSeq [MeilleurAccDuBlast_Ontario $PAB "[RepertoireDuGenome]/blastnrshuman"] set AccRefSeq [MeilleurAccDuBlast_Ontario $PAB "[RepertoireDuGenome]/blastnrefseq-rel-rna-human"] if {$AccRefSeq==""} { set DefRefSeq "None" set IdGRefSeq "None" set CoverRefSeq "None" set AccRefSeq "None" } else { set IdGRefSeq [format "%.2f" [lindex $AccRefSeq 1]] set CoverRefSeq [format "%.2f" [lindex $AccRefSeq 2]] set AccRefSeq [lindex $AccRefSeq 0] set DefRefSeq [FastaCmd $AccRefSeq "" 0 "refseq-rel-rna-human"] if {! [regexp "No Result " $DefRefSeq]} { set DefRefSeq [lrange $DefRefSeq 1 end] } #set DefRefSeq [join [FastaCmd $AccRefSeq "" 0 "refseq-rel-rna-human"] ""] #set DefRefSeq [join [FastaCmd $AccRefSeq "" 0] ""] #set DefRefSeq [lrange $DefRefSeq 2 end] } #>lcl|RSHUM:NM001100 NM001100 Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), mRNA. 4/2003 set AccUnigene [MeilleurAccDuBlast_Ontario $PAB "[RepertoireDuGenome]/blastnunigenehs"] if {$AccUnigene==""} { set DefUnigene "None" set IdGUnigene "None" set CoverUnigene "None" set AccUnigene "None" } else { set IdGUnigene [format "%.2f" [lindex $AccUnigene 1]] set CoverUnigene [format "%.2f" [lindex $AccUnigene 2]] set AccUnigene [lindex $AccUnigene 0] set DefUnigene [FastaCmd $AccUnigene "" 0 "unigenehs"] if {! [regexp "No Result " $DefUnigene]} { set DefUnigene [lrange $DefUnigene 1 end] } #set DefUnigene [join [FastaCmd $AccUnigene "" 0 unigenehs] ""] #set DefUnigene [join [FastaCmd $AccUnigene "" 0] ""] #set DefUnigene [lrange $DefUnigene 1 end] } #>lcl|UG#S345348 Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), mRNA. 4/2003 set UGId [LeUGIdUN_Getz $AccUnigene] #set UGId [LeUnigeneDeUniseq $AccUnigene unigenehs] if {$UGId==""} {set UGId "None"} #set Texte [join [list $PAB $CodeClone $AccRefSeq $IdGRefSeq $CoverRefSeq $DefRefSeq $AccUnigene $UGId $IdGUnigene $CoverUnigene $DefUnigene] "\t"] set Texte [join [list $PAB $CodeClone $AccRefSeq $IdGRefSeq $CoverRefSeq $DefRefSeq $AccUnigene $UGId $IdGUnigene $CoverUnigene $DefUnigene $Block $Row $Column] "\t"] AppendAuFichier $FichierSave $Texte } return "" } proc LesAccessDeLOrgaDesAPNS {Fichier MonOrga} { Wup "Renvoi la liste des Id Access de l'orga voulu des apns " set RepAPNS "[RepertoireDuGenome]/apns" if {$Fichier == "LaTotale"} { set LesFichiers [glob -nocomplain "$RepAPNS/*"] } else { set LesFichiers $Fichier } #Espionne $LesFichiers foreach Fichier $LesFichiers { set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set Organisme "" set LesOrgas {} scan $Ligne "%s %s %s" Id Access Expect #Espionne "$Id $Access $Expect $Organisme" set LesOrgas [split [lrange $Ligne 3 end] ":"] foreach ORGA $LesOrgas { #Espionne "$Fichier $ORGA ------ $MonOrga" if {$ORGA==""} {continue} if {[string equal -nocase $ORGA $MonOrga]} { lappend lesAccess "$Id $Access" continue } } } close $F } set lesAccess [lsort -unique $lesAccess] return $lesAccess } proc LesAccessDeLaPageInfo {PageInfo} { set LesAccess {} foreach Ligne [split $PageInfo "\n"] { if {[regexp -nocase {^ACCESSION } $Ligne tmp]} { regsub $tmp $Ligne "" Ligne set Ligne [string trim $Ligne] foreach Acc [split $Ligne " "] { if {$Acc == ""} {continue} lappend LesAccess [string trim $Acc] } break } if {[regexp -nocase {^AC } $Ligne tmp]} { regsub $tmp $Ligne "" Ligne set Ligne [string trim $Ligne] regsub -all ";" $Ligne "" Ligne foreach Acc [split $Ligne " "] { if {$Acc == ""} {continue} lappend LesAccess [string trim $Acc] } } } return $LesAccess } proc LesAccessDefDeLOligo {PAB NomOligo Dir} { Wup "Rend les Access et les Def des autres candidats de l oligo" Wup "Mise a jour Meilleure lecture d une sortie OligoArray, ajout de ChangeDebutAccessDeDir" Wup "Mise a jour Integration de InterrogeInfoDeOligo" global DebutAccessDeDir if {! [info exists DebutAccessDeDir]} {set DebutAccessDeDir ""} if {$PAB == "" || $NomOligo == "" || $Dir == ""} {return ""} set Fichier "$Dir/${PAB}.oligo" if {! [file exists $Fichier]} { set Fichier "$Dir/$PAB" if {! [file exists $Fichier]} {return ""} } set LesCandidats [InterrogeInfoDeLOligo $Fichier $NomOligo LesCandidats] if {$LesCandidats == ""} {return [list "No Hit found during Database searches"]} if { [regexp -nocase "No Hit found" $LesCandidats]} {return [list "$LesCandidats"]} if {! [info exists DebutAccessDeDir]} { ChangeDebutAccessDeDir $LesCandidats} if { $DebutAccessDeDir == ""} { ChangeDebutAccessDeDir $LesCandidats} if {! [regexp $DebutAccessDeDir $LesCandidats]} {set DebutAccessDeDir "";ChangeDebutAccessDeDir $LesCandidats} if {$DebutAccessDeDir==""} {return ""} set LesAccessDef "" set MaLigne "" foreach Candidat [split $LesCandidats " "] { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Candidat]} {continue} if {! [info exists DebutAccessDeDir]} {ChangeDebutAccessDeDir $Ligne} if { [regexp -nocase "$DebutAccessDeDir" $Candidat] || [regexp -nocase "$PAB" $Candidat]} { if {$MaLigne!=""} {lappend LesAccessDef $MaLigne;set MaLigne ""} set MaLigne $Candidat continue } append MaLigne " $Candidat" } #Pour le dernier de la liste sinon pas ajouter a LesAccessDef lappend LesAccessDef $MaLigne return [lsort -unique $LesAccessDef] } proc LesAccessDefDeLOligoArray {PAB NomOligo Dir} { Wup "Rend les access et les def des autres candidats de l'oligo" Wup "Version amelioree pour meilleure lecture d'une sortie OligoArray" if {$PAB == "" || $NomOligo == "" || $Dir == ""} {return ""} set Fichier "[RepertoireDuGenome]/Probes/$Dir/$PAB" if {! [file exists $Fichier]} {return ""} set Pattern "" #Attention pour differencier DbActin, Unigene, RefSeq et Human_genome if {[regexp -nocase "Unigene" $Dir]} {set DebutAccessDeDir "UG:"} if {[regexp -nocase "HsGenome" $Dir]} {set DebutAccessDeDir "HS"} if {[regexp -nocase "DbActin" $Dir]} {set DebutAccessDeDir "ACT"} if {[regexp -nocase "RefSeq" $Dir]} {set DebutAccessDeDir "RSHUM:"} set LigneSplitee {} set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {! [regexp -nocase "$NomOligo\[^0-9\]" $Ligne]} {continue} set LigneSplitee [split "$Ligne" "\t"] set LesCandidats [lrange $LigneSplitee 4 end] set LesCandidats [join $LesCandidats " "] set LesAccessDef {} #set LesAccess {} set MaLigne "" foreach element [split $LesCandidats " "] { if {! [regexp -nocase {[a-z]+ || [0-9]+} $element]} { continue } if { [regexp -nocase "$DebutAccessDeDir" $element] || [regexp -nocase "$PAB" $element]} { if {$MaLigne!=""} {lappend LesAccessDef $MaLigne;set MaLigne ""} set Access $element set MaLigne $Access continue } append MaLigne " $element" } #Pour le dernier de la liste sinon pas ajouter a LesAccessDef lappend LesAccessDef $MaLigne } close $F return [lsort -unique $LesAccessDef] } proc LesAccessDesOrganismesSample {Nom {Quoi ""}} { global MemoLesAccessTarget MemoLesOrganismesTarget MemoNomTarget if {$Quoi==""} { set Quoi "LesAccessMerci" } if {$Quoi=="LesOrganismesMerci" && [info exists MemoNomTarget] && $MemoNomTarget==$Nom} { return $MemoLesOrganismesTarget } if {$Quoi=="LesAccessMerci" && [info exists MemoNomTarget] && $MemoNomTarget==$Nom} { return $MemoLesAccessTarget } set LesAccess {} set LesOrganismes {} foreach Organisme [SampledOrganism LaListeMerci] { set Bid "" set Acc "" scan [BidAccessDeLOrganisme $Organisme $Nom] "%s %s" Bid Acc if {$Acc==""} { continue } lappend LesOrganismes $Organisme lappend LesAccess $Acc } set MemoNomTarget $Nom set MemoLesAccessTarget $LesAccess set MemoLesOrganismesTarget $LesOrganismes if {$Quoi=="LesAccessMerci"} { return $LesAccess } if {$Quoi=="LesOrganismesMerci"} { return $LesOrganismes } return $LesAccess } proc LesAccessDesProteinesIdentiquesDansMSF {FichierMSF QuelleProteine {Id 0.98}} { if {![file exists $FichierMSF]} {return} set LesAccess [AskMSF $FichierMSF LesAccess] if {$LesAccess == ""} {return} set LesAccessId {} foreach Access $LesAccess { if {[string equal -nocase $QuelleProteine $Access]} {set QuelleProteine $Access;break} } foreach Access $LesAccess { if {[string equal -nocase $Access $QuelleProteine]} {continue} if {[EstUnAccessPDB $Access ]} {continue} if {[catch {set PI [IDdansMSF $FichierMSF $QuelleProteine $Access SelonA]}]} {continue} if {$PI < $Id } {continue} lappend LesAccessId $Access } return $LesAccessId } proc LesAccessDesSeqali {l} { return [$::db eval "select si.access from seqinfo as si, seqali as sa where si.pk_seqinfo=sa.pk_seqinfo and sa.pk_seqali in ([join $l ,])"] } proc LesAccessDuAPN {NomOuFichier} { global RepertoireDuGenome set Nom [file tail $NomOuFichier] set FichierAPN $NomOuFichier if { ! [file exists $FichierAPN]} { set FichierAPN "$RepertoireDuGenome/apns/$Nom" } if { ! [file exists $FichierAPN]} { return {} } set LesAccess {} foreach Ligne [LesLignesDuFichier $FichierAPN] { set Access "" scan $Ligne "%s %s %s" BanqueId Access PN if {$Access==""} { continue } lappend LesAccess $Access } return $LesAccess } proc LesAccessDuAliInOut {NomOuFichier {InOut All}} { global RepertoireDuGenome set Nom [file tail $NomOuFichier] set Fichier "$RepertoireDuGenome/aliinout/$Nom" if { ! [file exists Fichier]} { set Fichier $NomOuFichier } if { ! [file exists Fichier]} { return {} } set All [regexp -nocase "All" $InOut] set In [regexp -nocase "In" $InOut] set Out [regexp -nocase "Out" $InOut] set LesAccess {} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s" BID Access if {[EstUnAccessPDB $BID]} { set Access $BID } if {$All} { lappend LesAccess $Access } if {$In && [regexp "accepted" $Ligne]} { lappend LesAccess $Access } if {$Out && [regexp "rejected" $Ligne]} { lappend LesAccess $Access } } return $LesAccess } proc LesAccessDuBlast {FichierBlast} { DepouilleLeBlast TabBlast $FichierBlast "1e-3" set NbSbjct [set TabBlast(NbSubject)] set TailleQuery [set TabBlast(Taille)] set NomQuery [set TabBlast(Query)] set LesProches {} Espionne "NbSbjct $NbSbjct" for {set i 1} {$i <=$NbSbjct} {incr i} { set OnADejaCeBidAvecGO 0 set LesGOsDeBId "" set BId [set TabBlast($i)] set Access [set TabBlast($BId,Access)] Espionne "$BId $Access" if {! [AccessToKeepOrNotToKeep $BId]} {continue} set LesGOsDeBId [Access2GO $BId] foreach GO $LesGOsDeBId { #Espionne "$GO" if {! [GOToKeepOrNotToKeep $GO]} { #Espionne "Celui on a ce GO" set OnADejaCeBidAvecGO 1;break} } if {$OnADejaCeBidAvecGO} {continue} if {0&&[regexp {^SW:}]} {} EnrichiAccessToKeepOrNotToKeep $Access } return "" } proc LesAccessDuCluster {c} { return [$::db eval {select si.access from seqinfo as si, seqali as sa, ln_seqali_cluster as lsc where lsc.pk_cluster=$c and lsc.pk_seqali=sa.pk_seqali and si.pk_seqinfo=sa.pk_seqinfo order by lsc.pos}] } proc LesAccessDuFichier {Fichier} { if {![file exists $Fichier]} {return ""} set F [open $Fichier] set LesAccess {} set i 0 while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9]} $Ligne]} {continue} if {[info exists Access]} {unset Access} if {[regexp -nocase {gi\|[0-9]*\|[a-z]*\|} $Ligne]} { set Ligne [string trim $Ligne] regsub {gi\|[0-9]*\|[a-z]*\|} $Ligne "" Ligne if { [regexp -nocase {^[a-z]*_[0-9]*} $Ligne Access]} { incr i lappend LesAccess [list "$Access" "ncbi"] } elseif {[regexp -nocase {^[0-9a-z]*} $Ligne Access]} { incr i lappend LesAccess [list "$Access" "genembl"] } } if {[regexp -nocase {^ID } $Ligne]} { if {[regexp -nocase { ([0-9a-z_]+)} $Ligne tmp Access]} { lappend LesAccess [list "$Access" "protein"] } } } close $F return $LesAccess } proc LesAccessDuGroupe {NomOuMSF Query {Liste Tous} {Calculate ""}} { if {$Liste=="Tous"} { return [GroupeSecator $NomOuMSF $Query "In" $Calculate] } foreach Access [GroupeSecator $NomOuMSF $Query "In" $Calculate] { set MoiAussi([string toupper $Access]) 1 } set LesBons {} foreach Access $Liste { if { ! [info exists MoiAussi([string toupper $Access])] } { continue } lappend LesBons $Access } Espionne $LesBons return $LesBons } proc LesAccessDuMSF {TexteOuFichierMSF} { DecortiqueUnMSF $TexteOuFichierMSF LesAccess return $LesAccess } proc LesAccessDuMac {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select si.access from seqinfo as si, seqali as sa, ln_mac_seqali as lms where lms.pk_mac=$m and lms.pk_seqali=sa.pk_seqali and sa.pk_seqinfo=si.pk_seqinfo}] } proc LesAccessDuMac_VOIR_PLUS_LOIN_1 {{m 0}} { #rR attention il y en a un autre plus bas # ATTENTION # Ici on retourne les access de tous les clusters if {! $m} {set m [MacCourant]} return [$::db eval {select si.access from seqinfo as si, seqali as sa, ln_seqali_cluster as lsc, cluster as c where c.pk_clustering=$m and lsc.pk_cluster=c.pk_cluster and sa.pk_seqali=lsc.pk_seqali and si.pk_seqinfo=sa.pk_seqinfo}] } proc LesAccessDuMsf {FichierMSF} { set debutEnTete 0 set lesAccess {} foreach ligne [LesLignesDuFichier $FichierMSF] { if {[regexp {\s*MSF:[\s\d]+Type:[\sPN]+Check:[\s\d]+\.\.} $ligne]} { set debutEnTete 1 continue } elseif {$debutEnTete && [regexp {\s*Name:\s*(\S+)} $ligne regMatch access]} { lappend lesAccess $access } elseif {[regexp {\s*//} $ligne]} { break } } return $lesAccess } proc LesAccessEMBLDesLignesEMBL {LesLignes} { set LesMots {} foreach Ligne [LeChampDesLignesEMBL $LesLignes "DR"] { if { ! [regexp "DR EMBL" $Ligne]} { continue } regsub "DR EMBL" $Ligne "" Ligne regsub -nocase -all {[^a-z_0-9\.]} $Ligne " " Ligne set LesMots [concat $LesMots [split $Ligne " "]] } set LesBons {} foreach Mot $LesMots { if { ! [regexp -nocase {[a-z]} $Mot]} { continue } if {[regexp "NOT_ANNOTATED_CDS" $Mot]} { continue } lappend LesBons $Mot } return $LesBons } proc LesAccessEn1997 {{Date ""}} { Wup "Permet de regarder combien de sequences sont presentes dans les banques a une date donnee" if {$Date == ""} { set Date "19970301" } set LesCategories [lsort [InterrogeLesInfosDesARPs LesCategories]] Espionne "$LesCategories" foreach Cat $LesCategories { #Espionne "$Cat" if {[regexp -nocase "actin" $Cat]} {continue} set LesAccessGetz [join [InterrogeLesInfosDesARPs $Cat LesAccess] "|"] set Banques "protein" set option "" set option "-vf \"acc crd org\" -cs \"\\\\t\"" #set option "-vf \"acc crd org Authors Title Year\" -cs \"\\\\t\"" #set option "-vf \"acc crd org Title Year\" -cs \"\\\\t\"" #set option "-c" #set option "-vf snm" set Typ1 "acc" set Typ2 "id" #getz '[protein-id:ACTS_*] & [protein-crd#:19890601]' -vf crd #set Commande "getz $option \"((\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\]) & \\\[$Banques-crd#:19971231\\\])\"" set Commande "getz $option \"((\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\]) & \\\[$Banques-crd#:$Date\\\])\"" #set Commande "getz $option \"((\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\]) & \\\[$Banques-crd#:$Date\\\]) \\\> taxonomy\"" #Espionne "$Commande" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {continue} if {$GetzOut==""} {continue} Espionne "$Cat\n$GetzOut" } return "" } proc LesAccessEtDefDesActins {aTabActin Fichier} { Wup "Creer un tableau avec les access et def a partir de la liste originelle de sequence DeLBMAGM/TousLesGenes.txt" upvar $aTabActin TabActin set OnEnTientUn 0 set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {$OnEnTientUn} { if {$Ligne ==""} {continue} set TabActin($Access) $Ligne set OnEnTientUn 0 continue } if {![regexp -nocase {^[0-9]+: } $Ligne ]} {continue} regsub {^[0-9]+: } $Ligne "" Ligne set Access [lindex $Ligne 0] set OnEnTientUn 1 continue } close $F } proc LesAccessFreresDansDecrypthon {X} { set LesAccessFreres {} foreach GM [AutreAccessDansXref $X] { lappend LesAccessFreres [AutreAccessDansGM $GM] } return $LesAccessFreres } proc LesAccessProchesDeLaProteineDeRef {Nom {IdDesProtId 0.98} {AvecOuSansCluster AvecCluster} {NormMDMin 0.5}} { set FileMSF "[RepertoireDuGenome]/msf/$Nom" set FileClust "${FileMSF}.clust" ####Recherche des EC appartennant aux proteines du cluster du msf si celui-ci a un bon NormMD#### if {![file exists $FileMSF]} {return} set Cluster [InterrogeLesClustersDesMSF $FileClust Access $Nom Cluster] if {$Cluster == "" } { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust LesAccess] } else { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust Cluster $Cluster LesAccess] } set LesAccessDesId {} foreach Access $LesAccessDuMSF { if {$Nom == $Access} {continue} Espionne $Access if {[IDdansMSF $FileMSF $Nom $Access SelonA] < $IdDesProtId} {continue} if {[IDdansMSF $FileMSF $Nom $Access SelonB] < $IdDesProtId} {continue} lappend LesAccessDesId $Access } if {[string equal -nocase $AvecOuSansCluster "AvecCluster"]} { set LesAccess [lsort -unique [concat $LesAccessDuMSF $LesAccessDesId]] } else { set LesAccess [lsort -unique $LesAccessDesId] } return $LesAccess } proc LesAccessRefSeqDesPABs {{LesPABs ""}} { Wup "Base sur les recherches blastn contre refseq" Wup "Identifie le meilleur hit dans le blastn (%Id > 0.95 ou %PCoverQuery > 0.70 ou %PCoverSubject" Wup "Sauve le tout dans un fichier LesAccessRefSeqDesPABs" #Format: Gscope Access RefSeq Id set DirOligo "[RepertoireDuGenome]/Probes/RefSeqBLAST3" set OtherDirOligo "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" set FichierRefSeqID "[RepertoireDuGenome]/LesAccessRefSeqDesPABs" set Entete "" set LesAccessRefSeq "" lappend Entete "Gscope Access\tRefSeq Id" AppendAuFichier $FichierRefSeqID $Entete if {$LesPABs==""} {set LesPABs [ListeDesPABs]} foreach PAB $LesPABs { set AccRefSeq "" set DirOligo "[RepertoireDuGenome]/Probes/RefSeqBLAST3" set OtherDirOligo "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" if {![file exists "$DirOligo/${PAB}.masked"]} { set DirOligo $OtherDirOligo } #Pour recupere l access RefSeq set AccRefSeq [ReturnBestHitFromLogFile $PAB $DirOligo] if {[regexp "Warning" $AccRefSeq]} { set AccRefSeq [lindex $AccRefSeq 1] continue } #regsub "RSHUM:NM" $AccRefSeq "NM_" AccRefSeq if {$AccRefSeq==""} { Espionne "Pb avec $PAB RefSeq est vide" continue } set Ligne "$PAB\t$AccRefSeq" Espionne "$Ligne" AppendAuFichier $FichierRefSeqID $Ligne lappend LesAccessRefSeq $AccRefSeq } Espionne "NbRefSeq [llength $LesAccessRefSeq]" set LesAccessRefSeq [lsort -unique $LesAccessRefSeq] Espionne "NbRefSeq [llength $LesAccessRefSeq]" return "" } proc LesAccessStatCompletes {LogFile Debut Fin} { Wup "Permet de recuperer les candidats de l oligo avec leur pourcentages d identite et leur nb bases contigues" if {![file exists $LogFile]} {return ""} set LesCandidats "" set LesAccessDef "" set LesCandidats [InterrogeInfoDuLogDeLOligo "$LogFile" $Debut $Fin LesCandidats] if { $LesCandidats == ""} { set LesCandidats "No Hit found in database or in log file" lappend LesAccessDef $LesCandidats } else { foreach C $LesCandidats { lappend LesAccessDef "[format "%-16s %6.2f" $C [InterrogeInfoDuLogDeLOligo "$LogFile" $Debut $Fin $C IDG]] [InterrogeInfoDuLogDeLOligo "$LogFile" $Debut $Fin $C NbContigue]" } } return $LesAccessDef } proc LesAccessUnigeneDesPABs {{LesPABs ""}} { Wup "Base sur les recherches blastn contre unigene" Wup "Identifie le meilleur hit dans le blastn (%Id > 0.95 ou %PCoverQuery > 0.70 ou %PCoverSubject" Wup "Sauve le tout dans un fichier LesAccessUgUnDesPABs" #Format: Gscope Access Uniseq Id Unigene Id set FichierUnigeneID "[RepertoireDuGenome]/LesAccessUgUnDesPABs" set Entete "Gscope Access\tUniseq Id\tUnigene Id" AppendAuFichier $FichierUnigeneID $Entete if {$LesPABs==""} {set LesPABs [ListeDesPABs]} foreach PAB $LesPABs { set Resultat "" set AccUnigene "" set UGId "" set FichierBlast "[RepertoireDuGenome]/blastn-unigene/${PAB}" #Test du meilleur hit dans la banque #askblast set TailleQuery [AskBlast $FichierBlast Taille] set NbSubject [AskBlast $FichierBlast NbSubject] #set TailleQuery [InterrogeBestHitInDatabase $FichierBlast TailleQuery] #set NbSubject [InterrogeBestHitInDatabase $FichierBlast NbSubject] if {$NbSubject>0} { set PIdentity 0.95 set PRecouvrement 0.70 set LesBIdsBases "" set IdGlobal 0.0 set PCoverQuery 0.0 set PCoverSubject 0.0 set BId [InterrogeBestHitInDatabase $FichierBlast InitialBId] set LesBIdsBases [InterrogeBestHitInDatabase $FichierBlast LesBIdsBases] if {$LesBIdsBases==""} { set Raison "Query has no equivalent sequence in DataBase: No fitting sequence in Blast searches" } else { #Pourcentage d identite global: Aligne sur Total dans les alignements set IdGlobal [InterrogeBestHitInDatabase $FichierBlast IdGlobal] #Recouvrement de Q sur S ou inversement #PCoverQuery Query par rapport au Subject #PCoverSubject Subject par rapport au Query set PCoverQuery [InterrogeBestHitInDatabase $FichierBlast PCoverQuery] set PCoverSubject [InterrogeBestHitInDatabase $FichierBlast PCoverSubject] set AccUnigene $BId if {$IdGlobal<$PIdentity || $PCoverQuery<$PRecouvrement || $PCoverSubject<$PRecouvrement} { set Raison "Query has no equivalent sequence in DataBase: $BId (\%Id [format "%.2f" $IdGlobal], Cover S/Q [format "%.2f" $PCoverQuery], Cover Q/S [format "%.2f" $PCoverSubject])." #On ne met pas a zero pour preserver les cas limites de nos cutoffs #set AccUnigene "" if {($PCoverQuery <= 0.2 || $PCoverSubject <= 0.2) || $IdGlobal <= 0.90} { #On met tout de meme a zero car trop limite set AccUnigene "" } } else { set Raison "Query has an equivalent sequence in DataBase: $BId (\%Id [format "%.2f" $IdGlobal], Cover S/Q [format "%.2f" $PCoverQuery], Cover Q/S [format "%.2f" $PCoverSubject])." } } } else { set Raison "Query has no equivalent sequence in DataBase: No Hit found in Blast searches" set AccUnigene "" } #>lcl|UG#S345348 Homo sapiens actin, alpha 1, skeletal muscle (ACTA1), mRNA. 4/2003 if {$AccUnigene==""} { set AccUnigene "$Raison" set UGId "" } else { set UGId [LeUnigeneDeUniseq $AccUnigene] } if {$UGId==""} {set UGId "No Unigene Id associated"} set Resultat "$PAB\t$AccUnigene\t$UGId" AppendAuFichier $FichierUnigeneID $Resultat InterrogeBestHitInDatabase $FichierBlast Decharge } } proc LesAcsDuId {ID} { set LesLignesEMBL [LaSequenceDesBanques $ID "" "OnVeutEMBL"] if {$LesLignesEMBL==""} { return {} } set LesACs {} foreach Ligne $LesLignesEMBL { if { ! [regexp "^AC " $Ligne]} { if {$LesACs=={}} { continue } else { return $LesACs } } regsub "^AC " $Ligne "" Ligne regsub ";" $Ligne " " Ligne LConcat LesACs [LesMotsDeLaLigne $Ligne] } return $LesACs } proc LesAffyAnnot {{version ""}} { set LesAffyAnnot [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/*/*.annot.csv"]] return $LesAffyAnnot } proc LesAffyAnnotDansLeBonOrdre {{version ""}} { LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U133/HG-U133B.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95Av2.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95A.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95B.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95C.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95D.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/HG-U95/HG_U95E.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/Chicken/Chicken.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/Xenopuslaevis/Xenopus_laevis.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.*.annot.csv"]] LConcat LesEntrees [lsort [glob -nocomplain "[RepertoireAffyAnnot $version]/Celegans/Celegans.*.annot.csv"]] return $LesEntrees } proc LesAffymetrixDuOwner {Owner} { foreach Nom [ListeDesPABs] { if {[OwnerOfCDNA $Nom]!=$Owner} { continue } Espionne "$Nom [LesAffymetrixEnOverlap $Nom]" } exit } proc LesAffymetrixEnOverlap {Nom} { global LesAffymetrixEnOverlap global RepertoireDuGenome set AA [AffymetrixAssocie] if {$AA==""} { return {} } if {[info exists LesAffymetrixEnOverlap($Nom)]} { return [set LesAffymetrixEnOverlap($Nom)] } if {[info exists LesAffymetrixEnOverlap("EstCharge")]} { return [set LesAffymetrixEnOverlap("EstCharge")] } set FichierOverlap "$RepertoireDuGenome/fiches/overlap_affymetrix" if {[file exists $FichierOverlap]} { foreach Ligne [LesLignesDuFichier $FichierOverlap] { scan $Ligne "%s" NomLu set LesAffymetrixEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end] } set LesAffymetrixEnOverlap("EstCharge") {} return [LesAffymetrixEnOverlap $Nom] } if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} { set LesAffymetrixEnOverlap("EstCharge") [list "NoValues"] return [set LesAffymetrixEnOverlap("EstCharge")] } set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif"] set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid"] set iAf -1 set iCd 0 set PrecedentiCd $iCd set MaxiCd [llength $LesCd] foreach Af $LesAf { incr iAf scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf Espionne "[string repeat " " 40] $Af" set iCd $PrecedentiCd while {$iCd<$MaxiCd} { set Cd [lindex $LesCd $iCd] scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd # Espionne "\n $Af\n$Cd" if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break } if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} { # Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd" incr iCd continue } if {$FinCd<$DebutAf} { # Espionne "[string repeat " " 40] $FinCd<$DebutAf" incr iCd continue } # Espionne "je me lance dans\n $Af\n$Cd" break } if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue } for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } { set Cd [lindex $LesCd $iCd] scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd if {[CetOrdre $Af $Cd]} { break } if {$FinCd < $DebutAf} { continue } # Espionne " $Af\n$Cd overlap" lappend LesAffymetrix($NomCd) $NomAf } } foreach NomCd [array names LesAffymetrix] { set LesAffys [lsort -unique [set LesAffymetrix($NomCd)]] AppendAuFichier $FichierOverlap "$NomCd [join $LesAffys " "]" } return [LesAffymetrixEnOverlap $Nom] } proc LesAiresCliquablesDuHTML {{FichierHTML ""}} { global RepertoireDuGenome if {$FichierHTML==""} { set FichierHTML [ButineArborescence "All"] if {$FichierHTML==""} { return {} } } set Texte [ContenuDuFichier $FichierHTML] set Map [ValeurDeLaBalise "map" Texte] while {$Map!=""} { set Area [ValeurDeLaBalise "area" Map] if {$Area==""} { break } set Reference [StringApres "href=" dans $Area] regsub -all {\"} $Reference "" Reference set Nom [file tail $Reference] regsub -nocase {(.htm|.html)$} $Nom "" Nom set Shape [StringApres "shape=" dans $Area] set TexteCoords [StringSuivant "coords=" dans $Area] regsub -all {[\"\,]} $TexteCoords " " TexteCoords if {[regexp "circle" $Shape]} { scan $TexteCoords "%d %d %d" xC yC rC set xMin [expr $xC-$rC] set xMax [expr $xC+$rC] set yMin [expr $yC-$rC] set yMax [expr $yC+$rC] } else { scan $TexteCoords "%d %d %d %d" xMin yMin xMax yMax } lappend LesAires "$Nom $xMin $yMin $xMax $yMax $Reference" } return $LesAires } proc LesAliasExistants {} { return [NomDuAlias "LesAlias"] } proc LesAliasLesPlusProches {A} { set Orga "" regexp {_([^_]+_[^_]+)$} $A Match Orga regsub -all "_" $Orga " " Orga regsub {_[^_]+_[^_]+$} $A "" A foreach Alias [LesAliasExistants] { set Existe($Alias) 1 } set Genre "XXXXXXXXX" set Espece "XXXXXXXXX" scan $Orga "%s %s" Genre Espece set G [string index $Genre 0] set E [string index $Espece 0] set Ge "$G$E" set ge [string tolower $Ge] set LesPossibles {} foreach Alias [LesAliasExistants] { if {[string equal $A $Alias]} { set PGS [NomDuAlias $Alias] set Organisme [OrganismeDuPAB $PGS] set O "" regexp {<<(.+)>>} $Organisme Match O Espionne "$PGS $Organisme $O $Orga" if {$O!=$Orga} { break } lappend LesPossibles $Alias } } set X $A regsub -all {[\-\_]} $X "" X regsub -nocase "alpha" $X "a" X regsub -nocase "beta" $X "b" X regsub -nocase "gamma" $X "g" X foreach Alias [LesAliasExistants] { set Y $Alias regsub -all {[\-\_]} $Y "" Y if {[string equal -nocase $X $Y]} { set PGS [NomDuAlias $Alias] set Organisme [OrganismeDuPAB $PGS] regexp {<<(.+)>>} $Organisme Match O if {$O!=$Orga} { continue } lappend LesPossibles $Alias } } foreach Possible [list "$Ge$A" "$ge$A" "$A$Ge" "$A$ge"] { if {[info exists Existe($Possible)]} { lappend LesPossibles $Possible } } return $LesPossibles } proc LesBandelettesDuBlast {FichierOuNom {Source ""} {AvecSize ""} {OnGraphe ""}} { global OnGrapheLesBandelettes if { ! [info exists OnGrapheLesBandelettes]} { set OnGrapheLesBandelettes 0 } if {$OnGraphe==""} { set OnGraphe "DontGraphe" } if {$OnGraphe=="OnGraphe"} { set OnGraphe 1 } else { set OnGraphe 0 } set NombreDeBandelettes 40 if {[OnTraiteMS2PH]} { set NombreDeBandelettes 100 } if {[PreFixe]=="RO"} { set NombreDeBandelettes 100 } set Nom [file tail $FichierOuNom] set MaxADecortiquer "SansLimiteDeNombre" set SeuilExpect "SansSeuilExpect" if {$AvecSize=="AvecSize"} { set AvecSize 1 } else { set AvecSize 0 } if {$AvecSize} { scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect set MaxADecortiquer [expr $MaxVoulus+$MaxPDB] global SeuilExpectPourJulie if {[info exists SeuilExpectPourJulie]} { set SeuilExpect $SeuilExpectPourJulie } } if {[regexp "/" $FichierOuNom]} { set Fichier $FichierOuNom } else { if {$Source==""} { set Source "blastp" } set Fichier "[RepertoireDuGenome]/$Source/$Nom" } if {$Source==""} { if {[regexp "daedalus" $Fichier]} { set Source "daedalushits" } else { set Source "blast" } } if { ! [file exists $Fichier]} { FaireLire "$Fichier doesn't exist. I'll cancel LaSelectionDuBlast" return "" } set LesCandidats {} if {[regexp "daedalushits" $Source]} { set Texte [ContenuDuFichier $Fichier] set PN 0.0009876 while 1 { set BlastHit [ValeurDeLaBalise "BlastHit" Texte "Rogner" BH] if {$BlastHit==""} { break } set BanqueId $BH set Access $BH set AccessOK $BH set OldPN $PN set ID [ValeurDeLaBalise "ID" BlastHit "NePasRogner"] if {[regexp VARSPLIC $ID]} { continue } set AC [ValeurDeLaBalise "AC" BlastHit "NePasRogner"] set PN [ValeurDeLaBalise "PN" BlastHit "NePasRogner"] if {$PN=="0.000999"} { set PN $OldPN } set OX [ValeurDeLaBalise "OX" BlastHit "NePasRogner"] set GN [ValeurDeLaBalise "GN" BlastHit "NePasRogner"] set DE [ValeurDeLaBalise "DE" BlastHit "NePasRogner"] set OS [ValeurDeLaBalise "OS" BlastHit "NePasRogner"] set OC [ValeurDeLaBalise "OC" BlastHit "NePasRogner"] set CandId [lindex [split $ID " "] 0] set CandAc [lindex [split $AC " "] 0] if {$CandId==""} { set CandId $BanqueId } if {$CandAc==""} { set CandAc $Access } if {$OS=="" && $OX!=""} { set OS [Tax $OX "Name"] } regsub -all " " $DE "_" BeauDE set Candidat "$CandId $CandAc $PN $BeauDE $OX $OS $OC" lappend LesCandidats $Candidat } } if {[regexp "blast" $Source]} { set n [DecortiqueBlast $Fichier $SeuilExpect $MaxADecortiquer Query lBanqueId lAccess lDE lProfil lPN] foreach CandId $lBanqueId CandAc $lAccess PN $lPN DE $lDE { regsub -all " " $DE "_" BeauDE set Candidat "$CandId $CandAc $PN $BeauDE" lappend LesCandidats $Candidat } } if {$LesCandidats=={}} { return "" } set LesPNs {} set LesLogPNs {} foreach Candidat $LesCandidats { set DE "" set OX "" scan $Candidat "%s %s %s %s %s" CandId CandAc PN DE OX set BonPN $PN if {$PN< 1.e-200} { set BonPN 1.e-200 } set LogPN [expr log10($BonPN)] lappend LesPNs $PN lappend LesLogPNs $LogPN } if {$OnGraphe || $OnGrapheLesBandelettes} { set K [Graphe $LesLogPNs] global KduGraphe ; set KduGraphe $K } if {$LesPNs=={}} {return {}} if {[llength $LesPNs]==1} {return [list [lindex $LesPNs 0] $LesCandidats]} set Prems [lindex $LesLogPNs 0] set Derns [lindex $LesLogPNs end] set Ecart [expr (1.*($Derns-$Prems))/$NombreDeBandelettes] set L $Prems while {$L<$Derns} { lappend LesLimites $L set L [expr $L + $Ecart] } lappend LesLimites 999999 set LesLimitesHautes [lrange $LesLimites 1 end] set LB [lindex $LesLimites 0] set LH [lindex $LesLimitesHautes 0] set Compte -4 set i 0 foreach LogPN $LesLogPNs Candidat $LesCandidats { incr Compte while 1 { if {$LB<=$LogPN && $LogPN<$LH} { break } if {[incr i] >= [llength $LesLimites]} { break } set LB [lindex $LesLimites $i] set LH [lindex $LesLimitesHautes $i] } if { ! [info exists LesCandidatsPour($LB)]} { lappend LesLBs $LB lappend LesChoixX $LogPN $LogPN $LogPN lappend LesChoixY $Compte [expr $Compte +1] [expr $Compte +2] } lappend LesCandidatsPour($LB) "$LogPN $Candidat" } if {$OnGraphe || $OnGrapheLesBandelettes} { Graphe $LesChoixY $LesChoixX $K "red" Graphe [lrange $LesLimites 0 end-1] "" $K "green" } foreach LB $LesLBs { if { ! [info exists LesCandidatsPour($LB)]} { continue } set SesCandidats {} foreach Candidat [set LesCandidatsPour($LB)] { lappend SesCandidats $Candidat } lappend LesLBsEtLeursCandidats $LB $SesCandidats } return $LesLBsEtLeursCandidats } proc LesBandelettesDuBlastGrid {lAccess lBanqueId lPN lDE} { set NombreDeBandelettes 100 set LesCandidats {} foreach CandId $lBanqueId CandAc $lAccess PN $lPN DE $lDE { regsub -all " " $DE "_" BeauDE set Candidat "$CandId $CandAc $PN $BeauDE" lappend LesCandidats $Candidat } Espionne "il y a [llength $LesCandidats] candidats pour les band" if {$LesCandidats=={}} { return "" } set LesPNs {} set LesLogPNs {} foreach Candidat $LesCandidats { set DE "" set OX "" scan $Candidat "%s %s %s %s %s" CandId CandAc PN DE OX set BonPN $PN if {$PN< 1.e-200} { set BonPN 1.e-200 } set LogPN [expr log10($BonPN)] lappend LesPNs $PN lappend LesLogPNs $LogPN } if {$LesPNs=={}} {return {}} if {[llength $LesPNs]==1} {return [list [lindex $LesPNs 0] $LesCandidats]} set Prems [lindex $LesLogPNs 0] Espionne "prems vaut $Prems" set Derns [lindex $LesLogPNs end] Espionne "derns vaut $Derns" set Ecart [expr (1.*($Derns-$Prems))/$NombreDeBandelettes] set L $Prems while {$L<$Derns} { lappend LesLimites $L set L [expr $L + $Ecart] } lappend LesLimites 999999 set LesLimitesHautes [lrange $LesLimites 1 end] set LB [lindex $LesLimites 0] set LH [lindex $LesLimitesHautes 0] set Compte -4 set i 0 foreach LogPN $LesLogPNs Candidat $LesCandidats { incr Compte while 1 { if {$LB<=$LogPN && $LogPN<$LH} { break } if {[incr i] >= [llength $LesLimites]} { break } set LB [lindex $LesLimites $i] set LH [lindex $LesLimitesHautes $i] } if { ! [info exists LesCandidatsPour($LB)]} { lappend LesLBs $LB lappend LesChoixX $LogPN $LogPN $LogPN lappend LesChoixY $Compte [expr $Compte +1] [expr $Compte +2] } lappend LesCandidatsPour($LB) "$LogPN $Candidat" } foreach LB $LesLBs { if { ! [info exists LesCandidatsPour($LB)]} { continue } set SesCandidats {} foreach Candidat [set LesCandidatsPour($LB)] { lappend SesCandidats $Candidat } lappend LesLBsEtLeursCandidats $LB $SesCandidats } return $LesLBsEtLeursCandidats } proc LesBandesCytologiques {} { set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierCyto "$RepLocalisation/CytologicMap" if {![file exists $FichierCyto]} { Espionne "$FichierCyto does not exist" return "" } set LesBandes {} set DebutDeRef 1 set ChromosomeDeRef "" set LesChromosomes {} foreach Ligne [LesLignesDuFichier $FichierCyto] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Chromosome [NumeroDuChromosome [lindex $LaLigne 0]] if {$ChromosomeDeRef != $Chromosome} { lappend LesChromosomes $Chromosome set ChromosomeDeRef $Chromosome set DebutDeRef 1 } set Bande [lindex $LaLigne 1] set Quoi [lindex $LaLigne 3] set Fin [lindex $LaLigne 2] if {[string equal -nocase "centromere" $Quoi]} { if {![info exists Tab($Chromosome,Centromere,D)]} { set Tab($Chromosome,Centromere,D) $DebutDeRef set Tab($Chromosome,Centromere,F) $Fin } if {$DebutDeRef < [set Tab($Chromosome,Centromere,D)]} {set Tab($Chromosome,Centromere,D) $DebutDeRef} if {[set Tab($Chromosome,Centromere,F)] < $Fin } {set Tab($Chromosome,Centromere,F) $Fin } } if {![info exists Tab($Chromosome,pter,D)]} { set Tab($Chromosome,pter,D) 1e200 set Tab($Chromosome,pter,F) -1e200 } if {$DebutDeRef < [set Tab($Chromosome,pter,D)]} { set Tab($Chromosome,pter,D) $DebutDeRef set Tab($Chromosome,pter,F) $Fin } if {![info exists Tab($Chromosome,qter,D)]} { set Tab($Chromosome,qter,D) 1e200 set Tab($Chromosome,qter,F) -1e200 } if {[set Tab($Chromosome,qter,F)] < $Fin} { set Tab($Chromosome,qter,D) $DebutDeRef set Tab($Chromosome,qter,F) $Fin } lappend LesBandes [list $Chromosome $Bande $DebutDeRef $Fin] set DebutDeRef [expr $Fin + 1] } foreach Chromosome $LesChromosomes { if {[info exists Tab($Chromosome,Centromere,D)]} { set Bande "${Chromosome}cent" set D [set Tab($Chromosome,Centromere,D)] set F [set Tab($Chromosome,Centromere,F)] lappend LesBandes [list $Chromosome $Bande $D $F] } if {[info exists Tab($Chromosome,pter,D)]} { set Bande "${Chromosome}pter" set D [set Tab($Chromosome,pter,D)] set F [set Tab($Chromosome,pter,F)] lappend LesBandes [list $Chromosome $Bande $D $F] } if {[info exists Tab($Chromosome,qter,D)]} { set Bande "${Chromosome}qter" set D [set Tab($Chromosome,qter,D)] set F [set Tab($Chromosome,qter,F)] lappend LesBandes [list $Chromosome $Bande $D $F] } } return [lsort -index 0 [lsort -index 2 -integer $LesBandes]] } proc LesBandesCytologiquesDeLaLocalisation {Contig Debut Fin} { set Sens "+" if {$Fin < $Debut} {set tmp $Fin; set Fin $Debut; set Debut $tmp} set LesCoordonnees [CoordonneesSurChromosome $Contig $Debut $Fin $Sens] set Chromosome [lindex $LesCoordonnees 0] set D [lindex $LesCoordonnees 1] set F [lindex $LesCoordonnees 2] set LesBandesCytos {} foreach LaBCyto [LesBandesCytologiquesDeLaRegion $Chromosome $D $F] { lappend LesBandesCytos [lindex $LaBCyto 0] } return $LesBandesCytos } proc LesBandesCytologiquesDeLaRegion {ChromDeRef Debut Fin} { set RepLocalisation "[HumanGenomeDir]/Localisation" set FichierCyto "$RepLocalisation/CytologicMap" if {![file exists $FichierCyto]} { Espionne "$FichierCyto does not exist" return "" } set Max 0 set LesBandes {} foreach Ligne [LesLignesDuFichier $FichierCyto] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Chromosome [NumeroDuChromosome [lindex $LaLigne 0]] if {$Chromosome != $ChromDeRef} {continue} set Borne [lindex $LaLigne 2] lappend LesBandes $LaLigne if {$Max < $Borne} {set Max $Borne} } if {1e+5 < $Max} {set Facteur 1} else {set Facteur 1e+6} set FinBCytoPrecedent 0 set LesBandesOccupees {} foreach LaBande $LesBandes { set Bande [lindex $LaBande 1] set Borne [lindex $LaBande 2] set FinBCyto [expr round($Borne*$Facteur)] set TailleBCyto [expr $FinBCyto - $FinBCytoPrecedent] if {[CesRegionsSontEllesOverlappantes $Debut $Fin $FinBCytoPrecedent $FinBCyto]} { lappend LesBandesOccupees [list "$Bande" "$TailleBCyto" ] } set FinBCytoPrecedent $FinBCyto } return $LesBandesOccupees } proc LesBandesCytologiquesDeLorganisme {Access {Description ""} {Orga Hs}} { set LesBandes [LesBandesCytologiques $Access $Description] foreach Liste $LesBandes { if {[lindex $Liste 0]==$Orga} { set NouvelleListe [lreplace $Liste 0 0] return $NouvelleListe } } return {} } proc LesBandesPourTousLesClustersDunChromo {Chromo {NbVoisins 6} {SeuilTolerance 2}} { #Chromo doit etre de la forme HS.... if {![regexp "^HS" $Chromo]} {return "Please, give a chromosome beginning by HS"} set ScoreMaxGlobal [ScoreMaxGlobal $NbVoisins] #Espionne $ScoreMaxGlobal set ScoreMaxChromo [ScoreMaxChro $Chromo $NbVoisins] #Espionne $ScoreMaxChromo set ValeurSeuil [expr $ScoreMaxGlobal/$SeuilTolerance] if {$ScoreMaxChromo<=$ValeurSeuil} {return {}} set NbNoms 0 set LesClusters {} set Liste [LesNNScores $Chromo $NbVoisins] foreach Element $Liste { scan $Element "%s %d %s %d %d" nom score chro debut fin if {$score > $ValeurSeuil} { incr NbNoms if {$NbNoms==1} {set BorneInf $debut} if {$NbNoms>=2} {set BorneSup $fin} } else { if {$NbNoms>=2} { lappend LesClusters "$Chromo $BorneInf $BorneSup" } set NbNoms 0 } } #EspionneL $LesClusters if {$LesClusters=={}} {return ""} set FichierBandesCyto "[HumanGenomeDir]/Localisation/CytologicMap" set LesBandesDuCluster {} foreach Cluster $LesClusters { set DebutCluster [lindex $Cluster 1] set FinCluster [lindex $Cluster 2] set FinBandePrec 0 set n 0 foreach Ligne [LesLignesDuFichier $FichierBandesCyto] { scan $Ligne "%s %s %s" chr band fin if {$chr!=$Chromo} { continue } else { #set fin [expr round ($fin*1000000)] if {$fin>=$FinCluster} { incr n if {$n==1} {lappend LesBandesDuCluster $band} else {continue} } if {$DebutCluster<=$fin && $DebutCluster>=$FinBandePrec && $FinCluster>$fin} { lappend LesBandesDuCluster $band } else {set FinBandePrec $fin} } } lappend LesBandesDeTousLesClusters $LesBandesDuCluster set LesBandesDuCluster {} } return $LesBandesDeTousLesClusters } proc LesBanqueIdDuBlast {FichierBlast {Expect 1e200} {NbSubject 1e200}} { if {![file exists $FichierBlast]} {return} ###Extraction des id dans le blast reduit### set LesBId {} foreach LeHit [LesHitsDuBlast $FichierBlast $Expect $NbSubject] { regsub -all -nocase {[^0-9a-z\.\-\:_\,\/]} $LeHit " " LeHit set BId [lindex $LeHit 0] regsub {^[^\:]*\:} $BId "" BId lappend LesBId $BId } return [ElimineLesRedondancesDansUneListe $LesBId] } proc LesBanquesBLASTDesARPs {{LesFichiersTFA ""}} { Wup "ATTENTION version utilisant les sequences dans les RSF" Wup "Permet de creer une banque blast a partir du fichier TFA" Wup "On creer a partir des access presents dans chaque categorie d ARP un banque BLAST" Wup "voir proc LesTFAsDesRSFsDesARPs" set RepARP "[RepARPAnno]" set RepTFA "$RepARP/ARP_TFA" set RepBanque "$RepARP/ARP_BLAST" set RepMACS "$RepARP/ARP_MACS" set RepSignature "$RepARP/ARP_Signature" set RepARP_Results "[RepARPAnnoWeb]" set RepTFAResults "$RepARP_Results" set RepBlastResults "$RepARP_Results" set RepMACSResults "$RepARP_Results" if {![file exists "$RepBanque"]} { file mkdir "$RepBanque" } if {$LesFichiersTFA == ""} { set LesFichiersTFA [glob -nocomplain -directory "$RepMACS/" "*.tfa"] #set LesFichiersTFA "/genomics/g1/ARP/alignement_ARP/ARPAnno/ARP_MACS/Orphans.tfa" } else { foreach F $LesFichiersTFA { if {! [file exists $F]} { return "" } } } foreach FichierTFA $LesFichiersTFA { if {[regexp "Modele" $FichierTFA]} {continue} set Banque [file tail $FichierTFA] regsub {.[a-z]{2,3}$} $Banque "" Banque Espionne "Banque $Banque" set Title $Banque set Cmdformadb "formatdb -i $FichierTFA -o T -t $Title -p T -n \"$RepBanque/$Banque\"" if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"} } return "" } proc LesBanquesBLASTDesARPs_InMemory {} { Wup "ATTENTION version utilisant les infos stockees en memoire (interroge ... donc les access inconnus n y sont pas)" Wup "Permet de creer une banque blast a partir du fichier TFA" Wup "On creer a partir des access presents dans chaque categorie d ARP un banque BLAST" set RepARP "[RepARPAnno]" set RepBanque "$RepARP/ARP_BLAST" if {![file exists "$RepBanque"]} { file mkdir "$RepBanque" } set LesCategories [lsort [InterrogeLesInfosDesARPs LesCategories]] #Espionne "$LesCategories" foreach Cat $LesCategories { #Espionne "$Cat" if {! [regexp -nocase "LesARP" $Cat]} {continue} set Famille $Cat regsub -all {\-\-\-\-} $Famille "" Famille regsub "Les" $Famille "" Famille set FichierTFA "$RepBanque/${Famille}.tfa" if {[file exists $FichierTFA]} { file delete -force $FichierTFA } set LesAccessGetz [join [InterrogeLesInfosDesARPs $Cat LesAccess] "|"] set Banques "protein" set option "-view FastaSeqs" set Typ1 "acc" set Typ2 "id" set Commande "getz $option \"\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\]\"" #Espionne "$Commande" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {continue} if {$GetzOut==""} {continue} regsub -all {protein\|} $GetzOut "" GetzOut regsub -all {\|} $GetzOut " " GetzOut #Espionne "$Cat\n$GetzOut" AppendAuFichier $FichierTFA $GetzOut lappend LesFichiersTFA $FichierTFA } foreach FichierTFA $LesFichiersTFA { set Banque [file tail $FichierTFA] regsub {.[a-z]{2,3}$} $Banque "" Banque Espionne "Banque $Banque" set Title $Banque set Cmdformadb "formatdb -i $FichierTFA -o T -t $Title -p T -n \"$RepBanque/$Banque\"" if {[catch {eval exec $Cmdformadb} Message]} {Warne "Error in Formatdb command:\n>>>>$Message"} } return "" } proc LesBanquesDeLaFerme {Ferme} { set OnAttendPP 1 set LesBanques {} foreach Ligne [LesLignesDuFichier $Ferme] { if {$OnAttendPP} { if {[regexp {\.\.} $Ligne]} { set OnAttendPP 0 } continue } scan $Ligne "%s" B lappend LesBanques $B } return $LesBanques } proc LesBanquesDuNal {Fichier {Rep ""}} { if {$Rep==""} { set Rep "SameDir" } if {$Rep=="SameDir"} { set Rep "[file dirname $Fichier]/" } set LesBanques {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp "^DBLIST " $Ligne]} { continue } while {[regsub -all " " $Ligne " " Ligne]} {} set LesBanques [lrange [split $Ligne " "] 1 end] } set LesBonnesBanques {} foreach Banque $LesBanques { set Banque [file tail $Banque] lappend LesBonnesBanques "$Rep$Banque" } return $LesBonnesBanques } proc LesBanquesIdEnStock {K {LBID Interrogation}} { global LesBanquesIdEnStock if {$LBID=="UnSet" && [info exists LesBanquesIdEnStock($K)]} { unset LesBanquesIdEnStock($K) return } if {$LBID=="Interrogation"} { return [set LesBanquesIdEnStock($K)] } set LesBanquesIdEnStock($K) $LBID return $LBID } proc LesBestProteinAndmRNAForeachOrganism {Nom FichierMSF {IdDesProtId 0.99} {IdMinStrict 0.3}} { if {![file exists $FichierMSF ]} {return} if {[AskMSF $FichierMSF LesAccess] == ""} {return} if {[AskMSF $FichierMSF $Nom] != ""} { set Query $Nom } elseif {[AskMSF $FichierMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" } else { return } set LeTexte {} set LesAccess [AskMSF $FichierMSF LesAccess] AskLesPagesInfos load $LesAccess protein set LesAcNucs {} set Tab($Nom,LesOrgas) {} foreach Access $LesAccess { if {[string equal -nocase $Access $Query]} {continue} if {[EstUnAccessPDB $Access ]} {continue} set Id1 [IDdansMSF $FichierMSF $Query $Access SelonB] if {$Id1 < $IdMinStrict} {continue} set Id2 [IDdansMSF $FichierMSF $Query $Access SelonA] if {$Id2 < $IdMinStrict} {continue} if {$Id1 < $Id2} {set Id $Id1} else {set Id $Id2} set Page [AskLesPagesInfos ask $Access] if {$Page == ""} {continue} Espionne $Access foreach Orga [lsort -unique [LesOrgasDeLaPage_PageInfo $Page]] { if {[info exists Tab($Nom,$Orga,$Access)]} {continue} set Tab($Nom,$Orga,$Access) [list $Access $Id] if {![info exists Tab($Nom,$Orga,LesProteines)]} { set Tab($Nom,$Orga,LesProteines) {} lappend Tab($Nom,LesOrgas) $Orga } lappend Tab($Nom,$Orga,LesProteines) [list $Access $Id] } foreach AcNuc [LesAcNucsDeLaProt_PageInfo $Page] { lappend LesAcNucs $AcNuc } } AskLesPagesInfos load [lsort -unique $LesAcNucs] genbankfull foreach Orga [lsort -unique [set Tab($Nom,LesOrgas)]] { set LesProteines [lsort -index end -real -decreasing [set Tab($Nom,$Orga,LesProteines)]] set LaProteine [lindex $LesProteines 0] set AccessDeRef [lindex $LaProteine 0] set LesProteinesSelect {} set LesmRNAsSelect {} Espionne $Orga foreach LaProteine $LesProteines { set AccessProt [lindex $LaProteine 0] set IdAvecAccessDeRef [IDdansMSF $FichierMSF $AccessDeRef $AccessProt SelonB] if {$IdAvecAccessDeRef < $IdDesProtId} {continue} set IdAvecAccessDeRef [IDdansMSF $FichierMSF $AccessDeRef $AccessProt SelonA] if {$IdAvecAccessDeRef < $IdDesProtId} {continue} set PageInfoProt [AskLesPagesInfos ask $AccessProt] if {$PageInfoProt == ""} {continue} set SeqProtDeRef [string toupper [string trim [LaSequenceDuTexteEMBL $PageInfoProt]]] regsub -nocase {^[M]*} $SeqProtDeRef "" SeqProtDeRef set TailleProt [TailleDeLaProt_PageInfo $PageInfoProt] lappend LesProteinesSelect [list $AccessProt $Id $TailleProt $PageInfoProt] foreach AccessGB [LesAcNucsDeLaProt_PageInfo $PageInfoProt] { set PageInfoGB [AskLesPagesInfos ask $AccessGB] if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfoGB]} {continue} set EstCeLeMemeOrga 0 foreach OrgaDumRNA [LesOrgasDeLaPage_PageInfo $PageInfoGB] { if {[string equal -nocase $OrgaDumRNA $Orga]} {set EstCeLeMemeOrga 1;break} } if {!$EstCeLeMemeOrga} {continue} set SeqProtDumRNA [string toupper [string trim [SeqProtDumRNA_PageInfo $PageInfoGB]]] regsub -nocase {^[M]*} $SeqProtDumRNA "" SeqProtDumRNA set EstCeLaMemeProt 0 if {$SeqProtDumRNA == $SeqProtDeRef} {set EstCeLaMemeProt 1} set Taille [TailleDeLAcNuc_PageInfo $PageInfoGB ] lappend LesmRNAsSelect [list $AccessGB $Taille $PageInfoGB $AccessProt $Id $TailleProt $PageInfoProt $EstCeLaMemeProt] } } if {$LesProteinesSelect == {}} {continue} if {$LesmRNAsSelect == {}} { set LaProteine [lindex [lsort -index 2 -real -decreasing $LesProteinesSelect] 0] set AccessProt [lindex $LaProteine 0] set Id [IDdansMSF $FichierMSF $Query $AccessProt SelonA] set TailleDeLaProt [lindex $LaProteine 2] set PageInfoProt [lindex $LaProteine 3] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " "] lappend LeTexte "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" continue } else { set LemRNA [lindex [lsort -index 7 -real -decreasing [lsort -index 1 -real -decreasing $LesmRNAsSelect] ] 0] set AccessGB [lindex $LemRNA 0] set TailleGB [lindex $LemRNA 1] set PageInfoGB [lindex $LemRNA 2] set DefGB [join [LaDefinitionDeLAcNuc_PageInfo $PageInfoGB] " "] set AccessProt [lindex $LemRNA 3] set Id [IDdansMSF $FichierMSF $Query $AccessProt SelonA] set TailleProt [lindex $LemRNA 5] set PageInfoProt [lindex $LemRNA 6] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " "] set EstCeLaMemeProt [lindex $LemRNA 7] if {!$EstCeLaMemeProt} {set QuEstCe "Variant"} else {set QuEstCe ""} lappend LeTexte "$Nom\t$Orga\tProtein\t$AccessProt\t$TailleProt\t$Id\t$DefProt" lappend LeTexte "$Nom\t$Orga\tmRNA\t$AccessGB\t$TailleGB\t$Id\t$DefGB\t$QuEstCe" } } AskLesPagesInfos unset if {[info exists Tab ]} {unset Tab} return $LeTexte } proc LesBestProteinesHumanAvecLoc {FichierClusters} { set Liste [ListeDesJR $FichierClusters] set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" if {![file exists $FichierBest]} {return} set FichierBestLocNuctfa "[RepertoireDuGenome]/Localisation/BestLocalisation_Human_Box" set FichierBestLocProttfa "[RepertoireDuGenome]/Localisation/BestProttfaLocalisation_Human" set FichierBestLocmRNA "[RepertoireDuGenome]/Localisation/BestmRNAHsapLocalisation_Human" if {![file exists $FichierBestLocNuctfa] || ![file exists $FichierBestLocProttfa] || ![file exists $FichierBestLocmRNA]} {return} set Entete "Name\tTwins\tClone\tCytoBand\tSource Loc.\tAcc. Protein\tId. Prot\tDefinition Prot.\tOrganism P.\tLength Prot\tAcc. mRNA\tId. mRNA\tDefinition mRNA\tOrganism mRNA\tLength mRNA" lappend LApercu $Entete foreach Nom $Liste { #pb dans les infos de exonhit set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] set Loc [InterrogeLocalisation $FichierBestLocNuctfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocProttfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocmRNA Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } } } set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProt Identity] set LesOrgasP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt LesOrganismes] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Definition] set TailleP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Taille] set LesOrgasR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA LesOrganismes] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Definition] set TailleR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Taille] if {$AccessmRNA!="" || $AccessProt!=""} { lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR" } } return $LApercu } proc LesBestProteinesHumanAvecLocEtGO {FichierClusters} { if {![file exists $FichierClusters]} { set Liste [ListeDesPABs] } else { set Liste [ListeDesJR $FichierClusters] } set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" if {![file exists $FichierBest]} {return} set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" if {![file exists $FichierGO]} {return} set FichierBestLocNuctfa "[RepertoireDuGenome]/Localisation/BestLocalisation_Human_Box" set FichierBestLocProttfa "[RepertoireDuGenome]/Localisation/BestProttfaLocalisation_Human" set FichierBestLocmRNA "[RepertoireDuGenome]/Localisation/BestmRNAHsapLocalisation_Human" if {![file exists $FichierBestLocNuctfa] || ![file exists $FichierBestLocProttfa] || ![file exists $FichierBestLocmRNA]} {return} set Entete "Name\tTwins\tClone\tCytoBand\tSource Loc.\tAcc. Protein\tId. Prot\tDefinition Prot.\tOrganism P.\tLength Prot\tAcc. mRNA\tId. mRNA\tDefinition mRNA\tOrganism mRNA\tLength mRNA\tGO" lappend LApercu $Entete foreach Nom $Liste { #pb dans les infos de exonhit et de SSH2 set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] if {[file exists $FichierClusters]} { set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] } set LesDefinitionsGO {} set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO] if {$LesGO!={}} { foreach GO $LesGO { set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] lappend LesDefinitionsGO $LaDefinitionGO } } set Loc [InterrogeLocalisation $FichierBestLocNuctfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocProttfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocmRNA Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } } } set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProt Identity] set LesOrgasP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt LesOrganismes] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Definition] set TailleP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Taille] set LesOrgasR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA LesOrganismes] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Definition] set TailleR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Taille] if {$AccessmRNA!="" || $AccessProt!=""} { #lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" lappend LApercu "$Nom\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" } } return $LApercu } proc LesBestProteineshuman2 {FichierClusters} { set Liste [ListeDesJR $FichierClusters] set NbBons 0 set NbVides 0 foreach Nom $Liste { #set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] if {$AccessmRNA=="" && $AccessProt==""} {incr NbVides} set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProt Identity] if {$IdmRNA>0.94 && $IdProt>0.94} {incr NbBons} } Espionne "nb vides: $NbVides" return "nb bons sup 0.94: $NbBons" } proc LesBidir {Path {Organism zebrafish} {Database refGene} {LongueurMoyennePromoteurBidir 1000} {BirdVersion bird} {MinOuMax Max}} { # Recupere les gènes bidirectionnels comme suit : # - tous les genes + # - les genes - a distance maxi de $LongueurMoyennePromoteurBidir (1000) # L'option MinOuMax permet de selectionner l'intergene de taille maximum ou minimum si plusieurs candidats if { $MinOuMax == "Max"} { set OrderBy1 "DESC" set OrderBy2 "ASC" } if { $MinOuMax == "Min"} { set OrderBy1 "ASC" set OrderBy2 "DESC" } Espionne " " set Promoteurs 0 set Pseudo 0 set BrinPlus 0 set BrinMoins 0 set BiDir 0 Espionne "LesBidir: Recuperation des genes sur les brins +" set FichierDesRequetes [open "/tmp/LesBidir$Organism.bql" "w"] puts $FichierDesRequetes "ID * DB UCSC" #puts $FichierDesRequetes "WH SQLNATIVE SELECT bin, access, chrom, strand, txStart, txEnd, cdsStart, cdsEnd, exonCount, exonStarts, exonEnds, id, name2, cdsStartStat, cdsEndStat, exonFrames, name, mRNA, spID, spDisplayID, geneSymbol, refseq, protAcc, typegene, description FROM ucschuman.$Database WHERE strand='+' ORDER BY chrom, txStart $OrderBy1" puts $FichierDesRequetes "WH SQLNATIVE SELECT chrom, strand, txStart, txEnd, cdsStart, cdsEnd, exonCount, exonStarts, exonEnds, id, name2, cdsStartStat, cdsEndStat, exonFrames, name FROM ucsc$Organism.$Database WHERE strand='+' ORDER BY chrom, txStart $OrderBy1" puts $FichierDesRequetes "LM 100000" puts $FichierDesRequetes "#" close $FichierDesRequetes exec /biolo/bird/bin/birdql_client.sh "/tmp/LesBidir$Organism.bql" "bird" "/tmp/LesBidir$Organism.res" Espionne "LesBidir: Constitution des requetes sur le brin -" set FichierDesRequetesExecutees [open "/tmp/LesBidir$Organism.res" "r"] set FichierDesRequetes2 [open "/tmp/LesBidir$Organism.bql2" "w"] gets $FichierDesRequetesExecutees Ligne while { [gets $FichierDesRequetesExecutees Ligne] >=0 } { set Liste [split $Ligne "|"] #ScanLaListe $Liste bin access chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name cdsStartStat cdsEndStat exonFrames name mRNA spID spDisplayID geneSymbol refseq protAcc typegene description ScanLaListe $Liste chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name cdsStartStat cdsEndStat exonFrames name if { [string range $chrom 0 0] != "c"} { set chrom "chr$chrom" } set Limite [expr $txStart - $LongueurMoyennePromoteurBidir] puts $FichierDesRequetes2 "ID * DB UCSC" #puts $FichierDesRequetes2 "WH SQLNATIVE SELECT bin, access, chrom, strand, txStart, txEnd, cdsStart, cdsEnd, exonCount, exonStarts, exonEnds, id, name2, cdsStartStat, cdsEndStat, exonFrames, name, mRNA, spID, spDisplayID, geneSymbol, refseq, protAcc, typegene, description FROM ucschuman.GeCo WHERE strand='-' AND chrom='$chrom' AND txEnd >= $Limite AND txEnd < $txStart ORDER BY txEnd $OrderBy2 fetch first 1 rows only" puts $FichierDesRequetes2 "WH SQLNATIVE SELECT chrom, strand, txStart, txEnd, cdsStart, cdsEnd, exonCount, exonStarts, exonEnds, id, name2, cdsStartStat, cdsEndStat, exonFrames, name FROM ucsc$Organism.$Database WHERE strand='-' AND chrom='$chrom' AND txEnd >= $Limite AND txEnd < $txStart ORDER BY txEnd $OrderBy2 fetch first 1 rows only" puts $FichierDesRequetes2 "#" } close $FichierDesRequetes2 BirdFetch "/tmp/LesBidir$Organism.bql2" "/tmp/LesBidir$Organism.res2" set FichierDesRequetesExecutees1 [open "/tmp/LesBidir$Organism.res" "r"] set FichierDesRequetesExecutees2 [open "/tmp/LesBidir$Organism.res2" "r"] set FichierDesBidir [open "$Path.$Organism.bidir" "w"] set FichierDesAccess [open "$Path.$Organism.acc" "w"] set FichierDesCoord [open "$Path.$Organism.coord" "w"] Espionne "LesBidir: Ecriture des bidir" gets $FichierDesRequetesExecutees1 Ligne1 while { [gets $FichierDesRequetesExecutees1 Ligne1] >=0 } { incr BrinPlus set Liste1 [split $Ligne1 "|"] #ScanLaListe $Liste1 bin1 access1 chrom1 strand1 txStart1 txEnd1 cdsStart1 cdsEnd1 exonCount1 exonStarts1 exonEnds1 id1 name21 cdsStartStat1 cdsEndStat1 exonFrames1 name1 mRNA1 spID1 spDisplayID1 geneSymbol1 refseq1 protAcc1 typegene1 description1 ScanLaListe $Liste1 chrom1 strand1 txStart1 txEnd1 cdsStart1 cdsEnd1 exonCount1 exonStarts1 exonEnds1 id1 name21 cdsStartStat1 cdsEndStat1 exonFrames1 name1 gets $FichierDesRequetesExecutees2 Ligne2 gets $FichierDesRequetesExecutees2 Ligne2 if { $Ligne2 != "EMPTY" && [string range $Ligne2 0 4] != "Query"} { incr BrinMoins set Liste2 [split $Ligne2 "|"] #ScanLaListe $Liste2 bin2 access2 chrom2 strand2 txStart2 txEnd2 cdsStart2 cdsEnd2 exonCount2 exonStarts2 exonEnds2 id2 name22 cdsStartStat2 cdsEndStat2 exonFrames2 name2 mRNA2 spID2 spDisplayID2 geneSymbol2 refseq2 protAcc2 typegene2 description2 ScanLaListe $Liste2 chrom2 strand2 txStart2 txEnd2 cdsStart2 cdsEnd2 exonCount2 exonStarts2 exonEnds2 id2 name22 cdsStartStat2 cdsEndStat2 exonFrames2 name2 set TaillePromoteurCommun [expr $txStart1 - $txEnd2] if { $name1 != "Pseudogene" && $name2 != "Pseudogene" } { set chromZ $chrom2 if { $chrom2 == "chr1" } { set chromZ "chr01"} if { $chrom2 == "chr2" } { set chromZ "chr02"} if { $chrom2 == "chr2_random" } { set chromZ "chr02_random"} #regsub -all {\s} $description1 "." description1 #regsub -all {\s} $description2 "." description2 #puts $FichierDesBidir "$chromZ $txEnd2 $txStart1 $TaillePromoteurCommun $access1 $typegene1 $description1 $access2 $typegene2 $description2" puts $FichierDesBidir "$chromZ $txEnd2 $txStart1 $TaillePromoteurCommun $name1 $name2" puts $FichierDesAccess "$name1" puts $FichierDesAccess "$name2" puts $FichierDesCoord "$chromZ|$txEnd2|$txStart1" incr BiDir } else { incr Pseudo } } } close $FichierDesBidir exec sort -u "$Path.$Organism.bidir" ">$Path.$Organism.sort" set FichierDesBidir [open "$Path.$Organism.sort" "r"] set FichierDesPromoteurs [open "$Path.$Organism.promobi" "w"] gets $FichierDesBidir LigneBiDirB #ScanLaListe $LigneBiDirB Bchrom BtxEnd2 BtxStart1 BTaillePromoteurCommun Baccess1 Btypegene1 Bdescription1 Baccess2 Btypegene2 Bdescription2 ScanLaListe $LigneBiDirB Bchrom BtxEnd2 BtxStart1 BTaillePromoteurCommun Baccess1 Baccess2 set Dedoublonnes 1 puts $FichierDesPromoteurs "$Dedoublonnes $LigneBiDirB" Espionne "Selection des promoteurs uniques" while { [gets $FichierDesBidir LigneBiDirA] >=0 } { #ScanLaListe $LigneBiDirA Achrom AtxEnd2 AtxStart1 ATaillePromoteurCommun Aaccess1 Atypegene1 Adescription1 Aaccess2 Atypegene2 Adescription2 ScanLaListe $LigneBiDirA Achrom AtxEnd2 AtxStart1 ATaillePromoteurCommun Aaccess1 Aaccess2 if { $Achrom != $Bchrom } { puts $FichierDesPromoteurs "$Dedoublonnes $LigneBiDirA $Chevauchant" incr Promoteurs incr Dedoublonnes } else { if { $BtxEnd2 != $AtxEnd2 && $BtxStart1 != $AtxStart1 } { # Dedoublonnage incr Dedoublonnes if { $BtxEnd2 < $AtxStart1 } { set Chevauchant "Non" puts $FichierDesPromoteurs "$Dedoublonnes $LigneBiDirA" incr Promoteurs } else { set Chevauchant [expr $Dedoublonnes - 1] puts $FichierDesPromoteurs "$Dedoublonnes $LigneBiDirA" } } } set Bchrom $Achrom set BtxEnd2 $AtxEnd2 set BtxStart1 $AtxStart1 set Baccess1 $Aaccess1 set Baccess2 $Aaccess2 #set Btypegene1 $Atypegene1 #set Btypegene2 $Atypegene2 #set Bdescription1 $Adescription1 #set Bdescription2 $Adescription2 set BTaillePromoteurCommun $ATaillePromoteurCommun } close $FichierDesPromoteurs close $FichierDesBidir Espionne "LesBidir: Fin" Espionne "- Genes sur le Brin+ : $BrinPlus" Espionne "- Genes sur le Brin- A bonne distance : $BrinMoins" Espionne "- Dont..." Espionne " * Contenant au moins un pseudogene : $Pseudo" Espionne " * Bidir : $BiDir" Espionne "- Promoteurs bidir dedoublonnes : $Dedoublonnes" Espionne "- Promoteurs bidir uniques : $Promoteurs" } proc LesBlastManquants_Gretta {} { set LesNoms {} foreach Nom [ListeDesPABs] { if {[file exists "[RepertoireDuGenome]/blastp/$Nom"] || ![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} lappend LesNoms $Nom } EspionneL [LaListeSplittee $LesNoms 100] } proc LesBlastXDesHitsMultiples {Nom} { global LesBlastXDesHitsMultiples if {[info exists LesBlastXDesHitsMultiples($Nom)]} { return [set LesBlastXDesHitsMultiples($Nom)] } if {[info exists LesBlastXDesHitsMultiples("EstCharge")]} { return {} } set LesBlastXDesHitsMultiples("EstCharge") 1 foreach Fichier [glob "[RepertoireDuGenome]/blastxmultiples/*"] { if { ! [regexp {MS[]0-9]+} $Fichier NomLu]} { continue } lappend LesBlastXDesHitsMultiples($NomLu) $Fichier } return [LesBlastXDesHitsMultiples $Nom] } proc LesBlastsDuCongelo {} { set OiCode [PreFixe] set Domain [OiDomainFromOiCode $OiCode] set OX [NotreOX] set Science [ScienceOiDeMonDomaine] set LesOP [QuestionDeScience $Science "ret WIW $OX ListOfOP"] return $LesOP } proc LesBlastsDuPsiBlast {Fichier {Nieme ""} {Trie ""}} { if {$Trie==""} { set Trie 0 } else { set Trie 1 } if {$Nieme==""} { set Nieme "All" } set DansEntete 1 set DansFin 0 set LaFin {} set LesBlasts {} foreach Ligne [LesLignesDuFichier $Fichier] { if {$DansFin || [regexp " Database" $Ligne]} { set DansFin 1 set DansEntete 0 lappend LaFin $Ligne continue } if {[regexp "Results from round" $Ligne]} { set DansEntete 0 if {[info exists LeCourant]} { lappend LesBlasts $LeCourant } set LeCourant $LEntete continue } if {$DansEntete} { lappend LEntete $Ligne continue } lappend LeCourant $Ligne } if {[info exists LeCourant]} { lappend LesBlasts $LeCourant } set LesBonBlasts {} foreach LeBlast $LesBlasts { LConcat LeBlast $LaFin lappend LesBonBlasts [join $LeBlast "\n"] } if {$Nieme=="All"} { return $LesBonBlasts } if {[regexp {^[0-9]+$} $Nieme]} { incr Nieme -1 } set BlastNonTrie [lindex $LesBonBlasts $Nieme] if {$Trie} { set BlastTrie [DecortiqueBlast $BlastNonTrie "SansSeuilExpect" "SansLimiteDeNombre" RetourneBlastTrie] return $BlastTrie } return $BlastNonTrie } proc LesBlocks {grp window} { global LNOrdali CpB set nseqs [llength [set CpB($grp)]] # matrice comparaison array set Matrix [InitClustalMatrix gon250] # taken from comp_blocks.c from rascal if {$grp ne "GroupeToutLeMonde"} { if {$nseqs < 10} { set block_cutoff 15 } else { set block_cutoff 10 } set minlength 6 set conserved 0.0 } else { if {$nseqs < 100} { set block_cutoff 10 } elseif {$nseqs < 250} { set block_cutoff 6 } else { set block_cutoff 5 } set minlength 4 set conserved 0.8 } get_blocks $grp $block_cutoff $window $conserved $minlength if {$grp eq "GroupeToutLeMonde"} { foreach b $CpB(Blocks,$grp) { lassign $b d f puts "GLOBALCOREBLOCK $d $f" } return } set Lprf1 [list] set Lprf2 [list] set Lcode [list] set Laa $Matrix(laa) puts "Laa $Laa" if {[llength [set CpB($grp)]] > 1} { set fst 0 foreach b [set CpB(Blocks,$grp)] { lappend Lprf1 [Profile1DuBlock $grp $b Matrix 1.0] lappend Lprf2 [Profile2DuBlock $grp $b $Laa] lappend Lcode 0 if {$grp eq "Group1" && $fst == 1} { set fst 0 puts "\ndata Group 1 $b" puts "profile 1" puts [join [lindex $Lprf1 1] \n] puts "profile 2" puts [join [lindex $Lprf2 1] \n] } incr fst } } set CpB($grp,Lprf1) $Lprf1 set CpB($grp,Lprf2) $Lprf2 set CpB($grp,Lcode) $Lcode return } proc LesBoiteRepresentativeLitigieuse {} { #pas un prog juste pour garder traces de ce que jai fait a la main if {$Ligne=="22" || $Ligne=="102" || $Ligne=="729" || $Ligne=="1074" || $Ligne=="405" || $Ligne=="1251" || $Ligne=="1286" || $Ligne=="1355" || $Ligne=="1417" || $Ligne=="1578" || $Ligne=="1680" || $Ligne=="1737" || $Ligne=="1760" || $Ligne=="962" || $Ligne=="1880" || $Ligne =="2058" || $Ligne=="1379" || $Ligne=="1380" || $Ligne=="1381" || $Ligne=="1626" || $Ligne=="1708" || $Ligne =="2056" || $Ligne =="2169" || $Ligne =="2173"} { set premiereloc 1 foreach Nom $ListeDesNoms { set Loc [ExtraitInfo $Nom "LocUcscFrom200602"] set LesMotsLoc [split $Loc ":- "] set Nvstart "" set Nvstop "" set longgn "" Espionne "$Nom $Loc" if {$premiereloc} { set premiereloc 0 set chr [lindex $LesMotsLoc 0] set start [lindex $LesMotsLoc 1] set stop [lindex $LesMotsLoc 2] if {$start=="" || $stop==""} { continue } set longgn [expr $stop - $start] set LongMax $longgn continue } set Nvchr [lindex $LesMotsLoc 0] set Nvstart [lindex $LesMotsLoc 1] set Nvstop [lindex $LesMotsLoc 2] Espionne "$start $Nvstop $stop" if {$Nvstart=="" || $Nvstop==""} { continue } if {$chr!= $Nvchr} { Espionne "pas meme chr" set different 1 continue } if {$Nvstart == $start && $Nvstop == $stop} { Espionne "meme loc" set different 0 } elseif {$start > $Nvstart && $Nvstart < $stop && $start < $Nvstop && $Nvstop > $stop} { Espionne "ca chevauche 1" set different 0 } elseif {$start < $Nvstart && $Nvstart < $stop} { Espionne "ca chevauche 2" set different 0 } elseif {$start < $Nvstop && $Nvstop < $stop} { Espionne "$start $Nvstop $stop" Espionne "ca chevauche 3" set different 0 } elseif {$start > $Nvstart && $stop < $Nvstop} { Espionne "ca chevauche 4" set different 0 } else { Espionne "chevauche pas" set different 1 } set start $Nvstart set stop $Nvstop } } if {$Ligne=="22" || $Ligne=="102" || $Ligne=="729" || $Ligne=="1074" || $Ligne=="1417" || $Ligne=="1578" || $Ligne=="1680" || $Ligne=="1880"} { set BonneBoite $ListeDesNoms } if {$Ligne=="405"} { set BonneBoite [list "EVI04050"] } if {$Ligne=="962"} { set BonneBoite [list "EVI09620"] } if {$Ligne=="1251"} { set BonneBoite [list "EVI12511" "EVI12512"] } if {$Ligne=="1286"} { set BonneBoite [list "EVI12860" "EVI12861" "EVI12862" "EVI12863" "EVI12864"] } if {$Ligne=="1355"} { set BonneBoite [list "EVI13550"] } if {$Ligne=="1379"} { set BonneBoite [list "EVI13793"] } if {$Ligne=="1380"} { set BonneBoite [list "EVI13801"] } if {$Ligne=="1381"} { set BonneBoite [list "EVI13810"] } if {$Ligne=="1626"} { set BonneBoite [list "EVI16264"] } if {$Ligne=="1708"} { set BonneBoite [list "EVI17080"] } if {$Ligne=="1737"} { set BonneBoite [list "EVI17372"] } if {$Ligne=="1760"} { set BonneBoite [list "EVI17602"] } if {$Ligne =="2056"} { set BonneBoite [list "EVI20560"] } if {$Ligne =="2058"} { set BonneBoite [list "EVI20580"] } if {$Ligne =="2169"} { set BonneBoite [list "EVI21695"] } if {$Ligne =="2173"} { set BonneBoite [list "EVI21730" "EVI21731" "EVI21732" "EVI21733"] } if {$Ligne =="2458"} { set BonneBoite [list "EVI24581" "EVI24583" "EVI24584" "EVI24585" "EVI24586" "EVI24587"] } if {$BonneBoite!={}} { Espionne "$BonneBoite Main" RangeMoi set EviOf $Ligne $BonneBoite "LaetitiaChoose" continue } } proc LesBornesAvecLesNucEMBL {} { global RepertoireDuGenome global ListeDesPABs if {[file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} { if {[OuiOuNon "$RepertoireDuGenome/fiches/bornesdespabs \n exists. Do I cancel ?"]} { return "" } } foreach Fichier [glob "$RepertoireDuGenome/nucembl/*"] { foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^AC" $Ligne]} { scan $Ligne "%s %s" AC Nom continue } if {[regexp "CC \-\!\- from" $Ligne]} { scan $Ligne "%s %s %s %d %s %d%s %s %s" CC XXX FROM Debut TO Fin POINT ORIENTATION Orient lappend LesBornes "$Nom $Debut $Fin $Orient" break } } Espionne "$Nom $Debut $Fin $Orient" } return [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"] } proc LesBornesDeChroContig {Chro Contig} { global RepertoireDuGenome set AA [AffymetrixAssocie] if {$AA==""} { set LesAd {} set LesAf {} } else { set LesAd [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trid.best"] set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif.best"] } set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"] set LesCf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif.best"] lappend $LesAf "Fin HZ" lappend $LesCd "Fin HZ" set iAd 0 set iAf 0 set iCd 0 set iCf 0 set LesBornes {} foreach LesAouC [list $LesAf $LesCd] { set iAf 0 set longAf [llength $LesAouC] while {$iAf<$longAf} { set Af [lindex $LesAouC $iAf] scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf if {$SensAf=="+"} { set SensAf "F" } else { set SensAf "R" } if {"$Chro $Contig" > "$ChroAf $ContigAf"} { incr iAf ; continue } if {"$Chro $Contig" < "$ChroAf $ContigAf"} { break } if { ! [regexp $Contig $ContigAf]} { incr iAf ; continue } lappend LesBornes "$NomAf $DebutAf $FinAf $SensAf" incr iAf } } return $LesBornes } proc LesBornesDeGlimmer {{NomNumeroDuDernierExistant ""} {FichierGlimmer ""}} { global RepertoireDuGenome FaireLire "Attention, Glimmer 1.04 lit result.out\nGlimmer 2.0 lit result.coord" set NePasPrendreLesDouteux 0 if {$NomNumeroDuDernierExistant==""} { set Prefixe [PreFixe] set DernierNumero "0000" } else { regsub -all {[0-9]} $NomNumeroDuDernierExistant "" Prefixe regsub -all -nocase {[a-z_]} $NomNumeroDuDernierExistant "" ChaineDernierNumero if {$ChaineDernierNumero==""} { set ChaineDernierNumero 0 } scan $ChaineDernierNumero "%d" DernierNumero } if {$FichierGlimmer==""} { set FichierGlimmer "$RepertoireDuGenome/glimmer/result.coord" } while { ! [file exists $FichierGlimmer]} { if {[OuiOuNon "I can't find the Glimmer output\n$FichierGlimmer\n\Do I run Glimmer ?"]} { Glimmer } else { return {} } } set OnAttendQueCaVienne [regexp "Putative Genes" [ContenuDuFichier $FichierGlimmer]] set LesBornesDeGlimmer {} foreach Ligne [LesLignesDuFichier $FichierGlimmer] { Espionne $Ligne if {[regexp "Putative Genes" $Ligne]} { set OnAttendQueCaVienne 0 continue } else { if {$OnAttendQueCaVienne} { continue } } if {$NePasPrendreLesDouteux && [regexp {\[} $Ligne]} { continue } scan $Ligne "%d %d %d" Numero Debut Fin incr Numero $DernierNumero set Nom [format "%s%[FormatDesNumerosPourCollection]" $Prefixe $Numero] if {$Debut < $Fin} { set Orient "F" } else { set Orient "R" set Toto $Debut set Debut $Fin set Fin $Toto } set Long [expr $Fin-$Debut+1] if {$Long>100000} { continue } set Frame [string toupper [NomDeLaFrame [expr $Debut%3] $Orient]] lappend LesBornesDeGlimmer "$Nom $Debut $Fin $Orient" } return $LesBornesDeGlimmer } proc LesBornesDesGenesEtendus {{Fichier ""}} { set LesDifferentes {} foreach Nom [ListeDesPABs] { set Debut [Box $Nom debut] set Fin [Box $Nom fin] set Orient [Box $Nom orient] set OldBornes "$Nom $Debut $Fin $Orient" set Nouvelles [BornesDuGeneEtendu $Nom] if {$Nouvelles!=$OldBornes} { lappend LesDifferentes $OldBornes $Nouvelles } lappend LesBornes $Nouvelles } if {$Fichier==""} { return $LesBornes } if {$Fichier=="AskForFile"} { set Fichier [FichierPourSaveAs] } if {$Fichier==""} { return "" } set FichierDiff "$Fichier.diff" SauveLesLignes $LesDifferentes dans $FichierDiff return [SauveLesLignes $LesBornes dans $Fichier] } proc LesBornesDuCDS {Texte} { regsub -all "(" $Texte "" regsub -all "join" $Texte "[JoinCDS " Texte regsub -all "complement" $Texte "[ComplementCDS " Texte } proc LesBornesParLambdaIntegrase {SeqPPCR SeqSiteP SeqAttB1 SeqAttB2} { set SeqPPCR [string toupper $SeqPPCR] set SeqSiteP [string toupper $SeqSiteP] set SeqAttB1 [string toupper $SeqAttB1] set SeqAttB2 [string toupper $SeqAttB2] set LesPositions {} foreach Seq [list $SeqPPCR $SeqSiteP] { foreach S [list $SeqAttB1 $SeqAttB2] { set LongueurAttB [string length $S] set Offset 0 while {[set Pos [string first $S $Seq]]<0 } { incr Offset set S [string range $S 1 end-1] if {[string length $S]<5} {return ""} Espionne $S } set AutrePos [string last $S $Seq] if {$Pos!=$AutrePos} { FaireLire "I found two AttB at $Pos and $AutrePos" } set PosMilieuAttB [expr $Pos - $Offset + $LongueurAttB/2] Espionne "$Pos $Offset $PosMilieuAttB $S" lappend LesPositions $PosMilieuAttB } } return $LesPositions } proc LesBornesParSeqCheck {PGS} { set LesSeqCheck [split [ExtraitInfo $PGS "SeqCheck"] "/"] set LesPossibles {} set LesIllumines {} foreach Ligne $LesSeqCheck { set Ligne [string trim $Ligne] if { ! [regexp { *(P[0-9]+) } $Ligne Match Oli]} { lappend LesPossibles $Ligne continue } set Sens [Oli $Oli "Sens"] if {$Sens=="3'"} { regsub "$Oli " $Ligne "$Oli " Ligne } lappend LesPossibles $Ligne lappend LesIllumines $Ligne } set LesBons [MorceauxChoisis $LesPossibles $LesIllumines "Please select lines in the left window and press '--->'\n Reorder with 'Up' and 'Down' if necessary."] set MinD 9999 set MaxF -9999 foreach Ligne $LesBons { set D "" set F "" while {1} { scan $Ligne "%s %s %s" NomSequenceur Oli Bornes set Sens [Oli $Oli "Sens"] if { ! [regexp {[0-9]+\-[0-9]+} $Bornes]} { if {[OuiOuNon "$Ligne\is not as SeqName Pxxxx 123-987\n Do I skipp ?"]} { set D "Skip" ; break } if {[OuiOuNon "Do You want to correct it ?"]} { set Ligne [Entre $Ligne] continue } if {[OuiOuNon "Do I cancel ?"]} { return "" } continue } regsub {\-} $Bornes " " Bornes scan $Bornes "%d %d" D F break } if {$D=="Skip"} { continue } if {$Sens=="5'"} { set MinD [Mini $F $MinD] } if {$Sens=="3'"} { set MaxF [Maxi $D $MaxF] } } set Propose "$PGS $MinD $MaxF" while 1 { if {[OuiOuNon "Do I create sequencing oligos for\n$Propose ?\n\n(I'll extend it on each side)"]} { return $Propose } if {[OuiOuNon "Do You want to correct it ?"]} { set Propose [Entre $Propose] continue } if {[OuiOuNon "Do I cancel ?"]} { return "" } } } proc LesBoutonsDeLaFrame {F} { set LesBoutons {} foreach Bouton [winfo children $F] { if {[winfo class $Bouton]!="Button"} { continue } lappend LesBoutons $Bouton } return $LesBoutons } proc LesBoutonsEnfonces {{quoi features}} { global FrmBtnFea set Lb {} foreach c [winfo children $FrmBtnFea] { if {[EtatDuBouton $c]} { if {$quoi eq "features"} { lappend Lb [$c cget -text] } else { lappend Lb $c } } } return $Lb } proc LesBoutsDeLaLigneAvecTexteSeparateur {Ligne {Sep ""} {Trim ""}} { set LesBouts {} set LongSep [string length $Sep] while 1 { if {$Ligne=="" } { break } set i [string first $Sep $Ligne] if {$i<0} { set Bout $Ligne } else { set Bout [string range $Ligne 0 [expr $i - 1]] } if {$Trim!=""} { set Bout [string $Trim $Bout] } lappend LesBouts $Bout if {$i<0} { break } set Ligne [string range $Ligne [expr $i + $LongSep] end] } return $LesBouts } proc LesCDNAsEnOverlap {Nom {BestOnly ""}} { global LesCDNAsEnOverlap global RepertoireDuGenome Wup "Attention si on commence en BestOnly il le reste durant tout le run et vice versa" set BestOnly [regexp -nocase "BestOnly" $BestOnly] if {$BestOnly} { set Best ".best" } else { set Best "" } if {[info exists LesCDNAsEnOverlap($Nom)]} { return [set LesCDNAsEnOverlap($Nom)] } if {[info exists LesCDNAsEnOverlap("EstCharge")]} { return [set LesCDNAsEnOverlap("EstCharge")] } set FichierOverlap "$RepertoireDuGenome/fiches/overlap_cdnas$Best" if {[file exists $FichierOverlap]} { foreach Ligne [LesLignesDuFichier $FichierOverlap] { scan $Ligne "%s" NomLu set LesCDNAsEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end] } set LesCDNAsEnOverlap("EstCharge") {} return [LesCDNAsEnOverlap $Nom] } if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} { set LesCDNAsEnOverlap("EstCharge") [list "NoValues"] return [set LesCDNAsEnOverlap("EstCharge")] } set LesAf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best"] set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best"] set iAf -1 set iCd 0 set PrecedentiCd $iCd foreach Af $LesAf { incr iAf scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf Espionne "[string repeat " " 40] $Af" set iCd $PrecedentiCd while {1} { set Cd [lindex $LesCd $iCd] scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd Espionne "\n $Af\n$Cd" if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break } if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} { Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd" incr iCd continue } if {$FinCd<$DebutAf} { Espionne "[string repeat " " 40] $FinCd<$DebutAf" incr iCd continue } Espionne "je me lance dans\n $Af\n$Cd" break } if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue } for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } { set Cd [lindex $LesCd $iCd] scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd if {[CetOrdre $Af $Cd]} { break } if {$FinCd < $DebutAf} { continue } if {$NomCd==$NomAf} { continue } Espionne " $Af\n$Cd overlap" lappend LesCDNAs($NomCd) $NomAf } } foreach Nom [array names LesCDNAs] { set LesAffys [lsort -unique [set LesCDNAs($Nom)]] AppendAuFichier $FichierOverlap "$Nom [join $LesAffys " "]" } return [LesCDNAsEnOverlap $Nom] } proc LesCalculsSurLesDistances_PourRapport {} { ### Moyenne Ecart type Min Max### set LesDistances {} set LesClusters [O2C2O LesClusters foreach Cluster1 $LesClusters { foreach Cluster2 $LesClusters { if {$Cluster1 == $Cluster2} {continue} if {[info exists TabTmp($Cluster2,$Cluster1)]} {continue} set TabTmp($Cluster1,$Cluster2) 1 set Distance [expr round([O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance])] lappend LesDistances $Distance } } return [MoyenneEcartMinMaxCumulLong $LesDistances] } proc LesCandidatsPourClustalW {FichierOuNom {Source ""}} { global RepertoireDuGenome global SeuilExpectPourJulie if {$Source==""} { set Source "blastp" } set Nom [file tail $FichierOuNom] scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect if {[info exists SeuilExpectPourJulie]} { set SeuilExpect $SeuilExpectPourJulie } Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... " set LesIndesirables {} if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} { lappend LesIndesirables $Indesirables } if { $Source=="apnosoc"} { set FichierApnOsOc "$RepertoireDuGenome/apnosoc/$Nom" if {[file exists $FichierApnOsOc]} { set LesCandidats [LesLignesDuFichier "$RepertoireDuGenome/apnosoc/$Nom"] } else { return {} } } elseif { $Source=="blastp" || $Source=="ballast"} { set LesCandidats {} if {[file exists $FichierOuNom]} { set FichierBallast $FichierOuNom } else { set FichierBallast "$RepertoireDuGenome/$Source/$Nom" } if { ! [file exists $FichierBallast]} { return {} } DecortiqueBlast $FichierBallast $SeuilExpect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN PrepareLesSequencesDesBanques $lBanqueId $lAccess foreach BanqueId $lBanqueId Access $lAccess Profil $lProfil PN $lPN { set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"] DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue } Wup "Si ballast, on ne prend que ceux qui ont contribue au profil" if {0 && $Source=="ballast" && ! $Profil} { continue } lappend LesCandidats "$BanqueId $Access $PN $OS $OC" regsub -all {\:} $DE "_" DE set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX" StockeLeDescriptif $AccessOK $Descriptif $Nom } } return $LesCandidats } proc LesCaracteresAscii {} { foreach n [NombresEntre 32 256] { lappend LesCars "[IntegerToAscii $n] $n" } return $LesCars } proc LesCaracteristquesDesControlesActiChip {} { set DirControle "[RepertoireDuGenome]/Probes/Controles_ActiChip" set LesControlesActiChip [ListeControlesActiChip] foreach Seq $LesControlesActiChip { set EnteteDeLOligo "" set File "$DirControle/$Seq" set Sequence [QueLaSequenceDuFichierTFA $File] lappend EnteteDeLOligo $Seq lappend EnteteDeLOligo [string length $Sequence] lappend EnteteDeLOligo "[format "%.1f" [CalculTmDeLaSeq $Sequence "" "" NearestNeighbor]]" Espionne "[join $EnteteDeLOligo " "]" } return "" } proc LesCartesExonicDesARPs {} { Wup "Permet de recuperer les cartes exoniques des ARPs" Wup "ainsi que de les transformer en sequence exonique ou l exon 1 est code par la lettre A" ChargeLesCartesExonicDesARPsHumaines "" "" ChargeLesCartesExonicDesAutresARPs "" "" return "" } proc LesCategoriesInteressantes {{ReInitialise 0}} { global RepertoireDuGenome set FichierCat "$RepertoireDuGenome/fiches/categories_interessantes" if {$ReInitialise || ![file exists $FichierCat]} { set LesCategories [MorceauxChoisis [lsort [O2C2O LesCategories]]] if {$LesCategories == {}} {return} Sauve [join $LesCategories "\n"] dans $FichierCat } return [LesLignesDuFichier $FichierCat] } proc LesCercles {args} { global LAA global lcol global MaxX MaxY MinX MinY Max set lfile $args set AA "ACDEFGHIKLMNPQRSTVWY" set LAA [lsort [split $AA ""]] set ncol [expr [llength $lfile] - 1] set lcol [list yellow DeepSkyBlue3 magenta green lightgray] set MaxX -999. set MaxY -999. set MinX 999. set MinY 999. set Max 0. foreach f $lfile { global lx$f global ly$f LitVecLC $f lx$f ly$f } MetALEchelle $lfile InitWLC $lfile set Ref [lindex $lfile 0] set lfile [lrange $lfile 1 end] TraceVecLC $Ref [lindex $lcol 0] set nf 1 foreach f $lfile col [lrange $lcol 1 $ncol] { set i 1 if {[info exists XX]} {unset XX} if {[info exists W]} {unset W} foreach x1 [set lx$Ref] y1 [set ly$Ref] x2 [set lx$f] y2 [set ly$f] { set W($i) 1. set XX(1,$i,1) $x1 set XX(2,$i,1) $y1 set XX(3,$i,1) 0. set XX(1,$i,2) $x2 set XX(2,$i,2) $y2 set XX(3,$i,2) 0. incr i } set Ni [expr $i - 1] set resup [COMPARORTHO XX W Rot Trans] set rms [lindex $resup 0] set mxd [lindex $resup 1] lappend Log "$Ref --- $f :: rms = $rms ; max dev = $mxd" set MRot [M_T Rot] set VTrans [V_T Trans] set nx$f {} set ny$f {} foreach x [set lx$f] y [set ly$f] { set v [list $x $y 0.] set Ln [AppliqueRotation $v $MRot $VTrans] lappend nx$f [lindex $Ln 0] lappend ny$f [lindex $Ln 1] } puts "CoefCor entre x ref et x $f [CoefficientCorrelation [set lx$Ref] [set nx$f]]" puts "CoefCor entre y ref et y $f [CoefficientCorrelation [set ly$Ref] [set ny$f]]" set lx$f [set nx$f] set ly$f [set ny$f] update TraceVecLC $f [lindex $lcol $nf] incr nf } puts "\n\n" EspionneL $Log return } proc LesChampsIndividuels {Texte {Separateur ,}} { if { ! [regexp $Separateur $Texte] } { regsub {[\.\;]$} $Texte "" Texte ; return [list $Texte] } set P 0 set Bon "" set LesBons {} foreach C [split $Texte ""] { if {$C=="("} { incr P 1 } if {$C==")"} { incr P -1 } if {$C==$Separateur && $P==0 } { lappend LesBons $Bon ; continue } append Bon $C } regsub {^ +and *} $Bon "" Bon regsub {[\.\;]$} $Bon "" Bon regsub " sp$" $Bon " sp." Bon lappend LesBons $Bon return $LesBons } proc LesChampsInteressantsDeNarcisse {} { return {ID AC DE GN} } proc LesChampsInteressantsDuAccess {BanqueId Access args} { set SeparateurDuChamp(AC) " " set SeparateurDuChamp(ID) " " set SeparateurDuChamp(OS) " " set SeparateurDuChamp(OC) " " set SeparateurDuChamp(OX) " " set LesChamps $args if {[regexp {^[A-Z][A-Z]$} $Access]} { set LesChamps [concat [list $Access] $args] set Access $BanqueId } foreach Champ $LesChamps { set ChampInteressant($Champ) 1 } set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"] if {$LesLignesEMBL==""} { return {} } foreach Ligne $LesLignesEMBL { scan $Ligne "%s" ChampLu if {[string equal $ChampLu "SQ"]} { break } if { ! [info exists ChampInteressant($ChampLu)]} { continue } regsub "$ChampLu " $Ligne "" Ligne lappend LesValeurs($ChampLu) [string trim $Ligne] } set LeResultat {} foreach Champ $LesChamps { set Valeur "" set Sep "\n" if {[info exist SeparateurDuChamp($Champ)]} { set Sep $SeparateurDuChamp($Champ) } if {[info exists LesValeurs($Champ)]} { set Valeur [join $LesValeurs($Champ) $Sep] } lappend LeResultat $Valeur } return $LeResultat } proc LesChrDansBed {} { set File "/genomics/link/SpliRetMouse/201404/PubliFarkas/GSE40524_junctions_high-quality.bed" # set File "/genomics/link/SpliRetMouse/201404/cdsSOURIS-06092011.bed" # set File "/genomics/link/SpliRetMouse/201404/cdsRAT-06092011.bed" foreach Ligne [LesLignesDuFichier $File] { if {[regexp "track" $Ligne]} {continue} set LesMots [split $Ligne "\t"] set Chr [string trim [lindex $LesMots 0]] lappend LesChr $Chr } set LesChr [ListeSansDoublon $LesChr] EspionneL $LesChr } proc LesClassesDuDescriptif {Nom {Expect ""}} { set FD [GscopeFile $Nom "descriptifs"] if {[FileAbsent $FD]} { return {} } set LesClasses {} foreach Ligne [LesLignesDuFichier $FD] { set Classe [StringSuivant "OC:" dans $Ligne] regsub {OX: .*} $Classe "" Classe if {$Classe==""} { continue } lappend LesClasses $Classe } return $LesClasses } proc LesClassesDuGlossaire {} { global RepertoireDuGenome foreach Complet [Glossaire "Coucou" "EntierComplet"] { set Classe [OCduOS $Complet] if {$Classe=="" || $Classe=="ClassUnknown"} { scan $Complet "%s" Genre if {[regexp -nocase "^Virus " $Complet]} { set Classe "Virus." } elseif {[info exists Classes($Genre)]} { set Classe [set Classes($Genre)] } else { Espionne "$Complet:$Classe" lappend LesUnknowns $Complet continue } } scan $Complet "%s" Genre set Classes($Genre) $Classe lappend CompletClasse "$Complet:$Classe" } Espionne [SauveLesLignes $LesUnknowns dans "$RepertoireDuGenome/fiches/completssansclasse"] Espionne [SauveLesLignes $CompletClasse dans "$RepertoireDuGenome/fiches/organisme_classe"] } proc LesClefsDeDidier {} { set LesClefs [list VE Cloned Expression_tested Soluble Insoluble Purified Crystallization Crystal Structure Stopped Coexpr_vector1 Coexpr_vector2 Coexpr_vector3 Scientist Vectorname Baculo Eukaryote DomainLimit Mutant ProtName CodeRipp Organism Comments] } proc LesClustersDeCluspack {TexteOuFichier {GetIt ""}} { if {$GetIt==""} { set GetIt "GetGroupsAndMembers" } if {[regexp "\n" TexteOuFichier]} { set Texte $TexteOuFichier } else { set Texte [ContenuDuFichier $TexteOuFichier] } Espionne $Texte set ToutLeMondeAvecGroupe {} set LesGroupesEtLeursMembres {} set LesGroupes {} set LesMembres {} set OnLeTient 0 append Texte "\nThatsAllFolks" foreach Ligne [split $Texte "\n"] { if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue } if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne] | $Ligne=="ThatsAllFolks"} { set Numero "" scan $Ligne "%s %s" Groupe Numero if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 } if {[info exists NumeroCourant]} { lappend LesGroupesEtLeursMembres [list $NumeroCourant $LesMembres] if {$Ligne=="ThatsAllFolks"} { break } set LesMembres {} } set NumeroCourant $Numero continue } scan $Ligne "%s" Access lappend ToutLeMondeAvecGroupe "$Access $Numero" lappend LesMembres $Access } if {$GetIt=="GetGroupsAndMembers"} { return $LesGroupesEtLeursMembres } if {$GetIt=="GetAllWithGroup"} { return $ToutLeMondeAvecGroupe } return [list $ToutLeMondeAvecGroupe $LesGroupesEtLeursMembres] } proc LesClustersDeLaListe {Fichier} { foreach PAB [LesLignesDuFichier $Fichier] { set PAB [File tail $PAB] set NCluster [InfoDuCluster $PAB Numero] lappend PABDuCluster($NCluster) $PAB lappend LesNClusters $NCluster #Espionne "$PAB Cluster [InfoDuCluster $PAB Numero]" } foreach Cluster [lsort -unique $LesNClusters] { Espionne "$Cluster [set PABDuCluster($Cluster)]" } } proc LesClustersDesOperons {} { set FileOperons "[RepertoireDuGenome]/fiches/operons" if {![file exists $FileOperons]} {return ""} set i 0 set LesClusters {} foreach LOperon [LesLignesDuFichier $FileOperons] { incr i set Orf [lindex $LOperon 0] lappend LesClusters [Operon $Orf Clusters] } return $LesClusters } proc LesClustersDuMac {{quoi index} {m 0}} { if {! $m} {set m [MacCourant]} if {$quoi eq "name"} { set r [$::db eval {select c.name from cluster as c, clustering as g where c.pk_clustering=g.pk_clustering and g.pk_mac=$m order by c.pk_cluster}] } else { set r [$::db eval {select c.pk_cluster from cluster as c, clustering as g where c.pk_clustering=g.pk_clustering and g.pk_mac=$m order by c.pk_cluster}] } return $r } proc LesClustersProchesDuCluster {Cluster {DistanceMax 230} {NbOperonsCommunsMin 1} {ZscoreMinDuCluster 5} {DiffZscoreMinClusterEtClusterFusionne 0} {NiveauGOMin_process ""} {NiveauGOMin_function ""} {NiveauGOMin_component ""} {LesClustersProches ""}} { ### procedure recursive ### global TabZScoreDesGeneOntologyDesClustersXHDA set FichierBestGOProttfa "[RepertoireDuGenome]/fiches/GeneOntology" ### seuils p80f50 ### set FichierBestGOClusterXHDA "[RepertoireDuGenome]/fiches/GeneOntology_ClustersXHDA" ### seuils p70f70 ### foreach Clust $LesClustersProches {set TabDejaClusterProche($Clust) 1} if {[info exists TabDejaClusterProche($Cluster)]} {return $LesClustersProches} lappend LesClustersProches $Cluster set LesClusters [O2C2O LesClusters] if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA]} { foreach Clust $LesClusters { ### Selection des GO en fonction de leur niveau dans l'arbre ### ### Premier niveau interessant est 3 en process et 2 en function ### foreach GO [InterrogeGeneOntology $FichierBestGOClusterXHDA Groupe $Clust LesGO] { set Type [Onto $GO Type] ### on n'etudie que les types pour lesquels on a determine un seuil minimal ### if {$Type == "" || ![info exists NiveauGOMin_$Type]} {continue} set NiveauGOMin [set NiveauGOMin_$Type ] set NiveauDuGO [NiveauMinDuGO $GO $Type] if {$NiveauDuGO == "" || $NiveauGOMin == "" || $NiveauDuGO < $NiveauGOMin} {continue} set TabTmp(Cluster,$Clust,$GO) 1 foreach Ancetre [InterrogeGeneOntology $FichierBestGOClusterXHDA GO $GO LesAncetres] { set NiveauDuGO [NiveauMinDuGO $Ancetre $Type] if {$NiveauDuGO == "" || $NiveauGOMin == "" || $NiveauDuGO < $NiveauGOMin} {continue} set TabTmp(Cluster,$Clust,$Ancetre) 1 } } ### Liste de tous les GO interessants d'un cluster, chaque GO est mis autant de fois ### qu'il est present dans le cluster ### set TabZScoreDesGeneOntologyDesClustersXHDA($Clust,LesGO) {} foreach Nom [O2C2O Cluster $Clust LesOrfs] { foreach GO [InterrogeGeneOntology $FichierBestGOProttfa $Nom LesGO] { if {[info exists TabTmp($Nom,$GO)]} {continue} set TabTmp($Nom,$GO) 1 if {[info exists TabTmp(Cluster,$Clust,$GO)]} { lappend TabZScoreDesGeneOntologyDesClustersXHDA($Clust,LesGO) $GO } foreach Ancetre [InterrogeGeneOntology $FichierBestGOProttfa GO $GO LesAncetres] { if {[info exists TabTmp($Nom,$Ancetre)]} {continue} set TabTmp($Nom,$Ancetre) 1 if {[info exists TabTmp(Cluster,$Clust,$Ancetre)]} { lappend TabZScoreDesGeneOntologyDesClustersXHDA($Clust,LesGO) $Ancetre } } } } ### Determine les differents effectifs de GO necessaires pour le calcul du Zscore ### foreach GO [set TabZScoreDesGeneOntologyDesClustersXHDA($Clust,LesGO)] { set Type [Onto $GO Type] if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($Type,NbGO) ]} { set TabZScoreDesGeneOntologyDesClustersXHDA($Type,NbGO) 0 } ### N ### incr TabZScoreDesGeneOntologyDesClustersXHDA($Type,NbGO) if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Clust,NbGO)]} { set TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Clust,NbGO) 0 } ### R ### incr TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Clust,NbGO) if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($GO,n) ]} { set TabZScoreDesGeneOntologyDesClustersXHDA($GO,n) 0 } ### n ### incr TabZScoreDesGeneOntologyDesClustersXHDA($GO,n) if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($Clust,$GO,n) ]} { set TabZScoreDesGeneOntologyDesClustersXHDA($Clust,$GO,n) 0 } ### r ### incr TabZScoreDesGeneOntologyDesClustersXHDA($Clust,$GO,n) } } if {[info exists TabTmp]} {unset TabTmp} } ### GO du cluster d'interet conserve si zscore >= seuil ### foreach GO [lsort -unique [set TabZScoreDesGeneOntologyDesClustersXHDA($Cluster,LesGO)]] { set Type [Onto $GO Type] set r1 [set TabZScoreDesGeneOntologyDesClustersXHDA($Cluster,$GO,n) ] set R1 [set TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Cluster,NbGO) ] set n [set TabZScoreDesGeneOntologyDesClustersXHDA($GO,n) ] set N [set TabZScoreDesGeneOntologyDesClustersXHDA($Type,NbGO) ] set ZScore1 [ZScore $r1 $R1 $n $N ] if {$ZScore1 < $ZscoreMinDuCluster} {continue} set Def [lindex [Onto $Type $GO LesDefinitions] 0] ### Recherche de cluster proche selon la distance, leur presence ensemble en operon### ### et la difference de zscore### ### entre chacun des clusters seuls et le cluster issu de la fusion ### foreach Cluster2 $LesClusters { if {$Cluster == $Cluster2 } {continue} if { [info exists TabDejaClusterProche($Cluster2)] } {continue} if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($Cluster2,$GO,n)] } {continue} if {![info exists TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Cluster2,NbGO)]} {continue} if {$DistanceMax < [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 Distance] } {continue} if {$NbOperonsCommunsMin > [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 NbOperonsCommuns]} {continue} set r2 [set TabZScoreDesGeneOntologyDesClustersXHDA($Cluster2,$GO,n) ] set R2 [set TabZScoreDesGeneOntologyDesClustersXHDA($Type,$Cluster2,NbGO)] set ZScore2 [ZScore $r2 $R2 $n $N ] if {$ZScore2 < $ZscoreMinDuCluster } {continue} set r [expr $r1 + $r2 ] set R [expr $R1 + $R2 ] set ZScore12 [ZScore $r $R $n $N ] set DiffZScore1 [expr $ZScore12 - $ZScore1] set DiffZScore2 [expr $ZScore12 - $ZScore2] if { $DiffZScore1 < $DiffZscoreMinClusterEtClusterFusionne || $DiffZScore2 < $DiffZscoreMinClusterEtClusterFusionne } { continue } Espionne "Cluster $Cluster -> $Cluster2 [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 Distance] [O2C2O Cluster1 $Cluster Cluster2 $Cluster2 NbOperonsCommuns] $ZScore1 $ZScore2 $DiffZScore1 $DiffZScore2 $GO $Def" set LesClustersProches [LesClustersProchesDuCluster $Cluster2 $DistanceMax $NbOperonsCommunsMin $ZscoreMinDuCluster $DiffZscoreMinClusterEtClusterFusionne $NiveauGOMin_process $NiveauGOMin_function $NiveauGOMin_component $LesClustersProches] } } return $LesClustersProches } proc LesClustersSpecifiquesDesCategories {{LesCategoriesSpecifiques ""} {LesCategories ""} {Var 0.05}} { if {$LesCategoriesSpecifiques == {}} { set LesCategoriesSpecifiques [MorceauxChoisis [lsort [O2C2O LesCategories]]] } if {$LesCategories == {}} {set LesCategories [MorceauxChoisis [lsort [O2C2O LesCategories]]]} if {$LesCategories == "CategoriesInteressantes"} {set LesCategories [LesCategoriesInteressantes]} set LesClustersSelected {} set LesClusters [O2C2O LesClusters] Espionne [llength $LesClusters] foreach Cluster $LesClusters { Espionne "\n\nCluster $Cluster\n" if {[EstCeQueLeClusterEstSpecifiqueDesCategories $Cluster $LesCategoriesSpecifiques $LesCategories $Var]} { lappend LesClustersSelected $Cluster } } set Total [llength $LesClustersSelected] lappend LesClustersSelected $Total Sauve [join $LesClustersSelected "\n"] dans "[RepertoireDuGenome]/fiches/lesclustersselected" return } proc LesCodeCloneDesAffymetrixEnOverlap {Nom} { set LesAffys [LesAffymetrixEnOverlap $Nom] set LesCC {} foreach Affy $LesAffys { set CC [CodeCloneDuAffymetrix $Affy] if {$CC==""} { continue } lappend LesCC $CC } return $LesCC } proc LesCodesAffy {Fichier} { set Liste [CreeListePourFichierAUneColonne $Fichier] CodeClonePourTous $Liste } proc LesCodesGenetiques {P} { global LesCodesGenetiques Wup "We replace O (the coding of STOP in MutaSequence) by * (O is not used as aa code)" if {$P=="O"} { set P "*" } set P [string toupper $P] if {$P=="STOP"} { set P "*" } if {[string length $P]==3} { set P [UT $P] } if {[info exists LesCodesGenetiques($P)]} { return [set LesCodesGenetiques($P)] } if {[info exists LesCodesGenetiques("EstCharge")]} { return "NNN" } set LesCodesGenetiques("EstCharge") 1 foreach A {A T G C} { foreach B {A T G C} { foreach C {A T G C} { set Codon "$A$B$C" set AA [AAduCodon $Codon] lappend LesCodesGenetiques($AA) $Codon lappend LesCodesGenetiques(LALISTEMERCI) "$Codon $AA" } } } return [LesCodesGenetiques $P] } proc LesCodonStartStop {Nom} { set FichierTfa "[RepertoireDuGenome]/mrnatfa_cds_Mus_musculus/$Nom" if {![file exists $FichierTfa]} {return} set LongueurSeq [string length [QueLaSequenceDuTFA $FichierTfa]] set Start [ExtraitPartieDuTfa $FichierTfa 1 5] #Espionne $Start set Stop [ExtraitPartieDuTfa $FichierTfa [expr $LongueurSeq -4] $LongueurSeq] #Espionne $Stop set LesStartStop [list $Nom $Start $Stop] return $LesStartStop } proc LesCodonStartStopPourTous {} { foreach Nom [ListeDesPABs] { lappend LesStartStopPourTous [LesCodonStartStop $Nom] } return $LesStartStopPourTous } proc LesContigsDuBlast {FichierBlast {ExpectMax 0.001} {NbSubject 500}} { set LesContigs {} set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject] set LesBId {} for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} {lappend LesBId [AskBlast $FichierBlast Subject $i]} AskLesPagesInfos load $LesBId htg foreach BId $LesBId { set Access [string toupper [AskBlast $FichierBlast BanqueId $BId Access]] if {[info exists Tab($Access,LesOrganismes)]} {continue} set PageInfo [AskLesPagesInfos ask $BId] if {$PageInfo == ""} {continue} set TailleDansDB [TailleDeLAcNuc_PageInfo $PageInfo] set Taille [AskBlast $FichierBlast BanqueId $BId Taille ] if {$TailleDansDB != $Taille} {continue} if {![regexp -nocase "HTG" [InfoDuChampsDeLaPageGenBank $PageInfo KEYWORDS]]} {continue} set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Tab($Access,LesOrganismes) $LesOrgas set Def [join [LaDefinitionDeLAcNuc_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Expect [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect ] set Score [AskBlast $FichierBlast BanqueId $BId Segment 1 Score ] scan $Score "%f" Score set Orientation [AskBlast $FichierBlast BanqueId $BId Segment 1 Orientation] set PIdGlob [PourcentageDIdentiteGlobal $FichierBlast $BId] set NbBasesEnCommun [NombreDeBasesEnCommun $FichierBlast $BId] set LeProfil [LeProfilDeLAlignementDuSubject $FichierBlast $BId] set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { lappend LesContigs [list $BId $Access $Taille 0 $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun 0 0 0 $Orga $Def {} "CONTIG"] } } AskLesPagesInfos unset set LesContigs [lsort -real -decreasing -index 2 $LesContigs] set LesContigs [lsort -real -decreasing -index 7 $LesContigs] set LesContigs [lsort -integer -decreasing -index 8 $LesContigs] return $LesContigs } proc LesContigsDuBlast_TabBlast {aTabBlast} { upvar $aTabBlast TabBlast set LesContigs {} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] set Access [string toupper [set TabBlast($BId,Access)]] if {[info exists Tab($Access,LesOrganismes)]} {continue} set PageInfo [PageInfo $BId genbank "id acc key des org"] if {$PageInfo == ""} {continue} if {![regexp -nocase "HTG" [InfoDuChampsDeLaPageGenBank $PageInfo KEYWORDS]]} {continue} set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Tab($Access,LesOrganismes) $LesOrgas set Def [join [LaDefinitionDeLAcNuc_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Expect [set TabBlast($BId,1,Expect) ] set Score [set TabBlast($BId,1,Score) ] set Taille [set TabBlast($BId,Taille) ] scan $Score "%f" Score set Orientation [set TabBlast($BId,1,Orientation)] set PIdGlob [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] set NbBasesEnCommun [NombreDeBasesEnCommun_TabBlast TabBlast $BId] set LeProfil [LeProfilDeLAlignementDuSubject_TabBlast TabBlast $BId] Espionne $BId set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { lappend LesContigs [list $BId $Access $Taille 0 $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun 0 0 0 $Orga $Def {} "CONTIG"] } } set LesContigs [lsort -real -decreasing -index 2 $LesContigs] set LesContigs [lsort -real -decreasing -index 7 $LesContigs] set LesContigs [lsort -integer -decreasing -index 8 $LesContigs] return $LesContigs } proc LesControlesActiChipPourExcel {} { Wup "Permet de creer le fichier excel des Controles" set ListeControles [ListeControlesActiChip] set Wdir1 "[RepertoireDuGenome]/Probes/Controles_ActiChip/RefSeq_Controles" set Wdir2 "[RepertoireDuGenome]/Probes/Controles_ActiChip/Unigene_Controles" LesOligosPourExcel "$ListeControles" "$Wdir1" "$Wdir2" "" "" return "" } proc LesCoordonneesDeLaPart {Rayon AngleMin AngleMax {XCentre 0} {YCentre 0} {InverseAxeY Yes}} { set pi 3.141592 if {$InverseAxeY == "Yes"} {set Facteur -1} else {set Facteur 1} set EcartAngleMin [expr 2*$pi/360] set AngleDOuverture [expr abs($AngleMax - $AngleMin)] if {$AngleDOuverture < $EcartAngleMin} { set XMin [expr $Rayon * cos($AngleMin) + $XCentre] set YMin [expr $Rayon * sin($AngleMin) * $Facteur + $YCentre] set XMax [expr $Rayon * cos($AngleMax) + $XCentre] set YMax [expr $Rayon * sin($AngleMax) * $Facteur + $YCentre] return [list "$XCentre" "$YCentre" "$XMin" "$YMin" "$XMax" "$YMax"] } set LesCoords [list "$XCentre" "$YCentre"] set nEcart [expr int($AngleDOuverture/$EcartAngleMin)] for {set i 0} {$i <= $nEcart} {incr i} { set Angle [expr $AngleMin + $i * $EcartAngleMin] set X [expr $Rayon * cos($Angle) + $XCentre] set Y [expr $Rayon * sin($Angle) * $Facteur + $YCentre] lappend LesCoords $X lappend LesCoords $Y } set DernierAngle [expr $AngleDOuverture - $nEcart*$EcartAngleMin] if {$DernierAngle != 0} { set X [expr $Rayon * cos($AngleMax) + $XCentre] set Y [expr $Rayon * sin($AngleMax) * $Facteur + $YCentre] lappend LesCoords $X lappend LesCoords $Y } return $LesCoords } proc LesCoordonneesDuCDSDumRNA {Access} { return [LesCoordonneesDuCDSDumRNA_PageInfo [PageInfo $Access genbankfull]] } proc LesCoordonneesDuCDSDumRNA_PageInfo {PageInfo} { if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {return} regexp { CDS [^0-9]+([0-9]+)\.[ ]*\.([0-9]+)} $PageInfo tmp DbtCDS FinCDS if {![info exists DbtCDS] || ![info exists FinCDS]} {return} return [list $DbtCDS $FinCDS] } proc LesCoordonneesExonicMap {Query} { Wup "Permet de donner les coordonnees des sequences alignees sur le genome" set ListeDFExon "" set LesRangs [lindex [InterrogeFichierExonicMap $Query LesRangs] 0] foreach Rang $LesRangs { set NbExon [InterrogeFichierExonicMap $Query Rang $Rang NbExonicAreas] for {set i 1} {$i <= $NbExon} {incr i} { set Debut [InterrogeFichierExonicMap $Query Rang $Rang ExonArea $i DQ] set Fin [InterrogeFichierExonicMap $Query Rang $Rang ExonArea $i FQ] lappend ListeDFExon [list $Debut $Fin] } } return "$ListeDFExon" } proc LesCopains {FichierBlastP FichierSortie} { Espionne [SauveLesLignes [LesCandidatsPourClustalW $FichierBlastP "blastp"] dans $FichierSortie] } proc LesCopainsDeCluster {Exp {Anal ""} {Clus ""} {Num ""}} { global LesCopainsDeCluster set RepertoireTranscriptomique "[RepertoireDuGenome]/transcriptomique/cluster" if {[info exists LesCopainsDeCluster($Exp,$Anal,$Clus,$Num)]} { return $LesCopainsDeCluster($Exp,$Anal,$Clus,$Num) } if {[info exists LesCopainsDeCluster("EstCharge")]} { return {} } set LesCopainsDeCluster("EstCharge") 1 foreach File [glob -nocomplain "$RepertoireTranscriptomique/*"] { set Queue [file tail $File] foreach Ligne [LesLignesDuFichier $File] { set LesMots [split $Ligne "\t"] ScanLaListe $LesMots Bidon ExpPs AnalPs ClusPs NumPs if {$NumPs=="NA"} {continue} lappend LesCopainsDeCluster($ExpPs,$AnalPs,$ClusPs,$NumPs) $Queue } } foreach {C V} [array get LesCopainsDeCluster] { if {[regexp "EstCharge" $C]} {continue} lappend LesCopainsDeCluster(ListOfCombi,,,) $C set VSD [ListeSansDoublon $V] set LesCopainsDeCluster($C) $VSD set LesCopainsDeCluster(SizeOf$C) [llength $VSD] } return [LesCopainsDeCluster $Exp $Anal $Clus $Num] } proc LesCopainsDePathway {Pathway} { global LesCopainsDePathway set FichierPathway "[RepertoireDuGenome]/Ingenuity/LesPathwaysDesBoites" if {[info exists LesCopainsDePathway($Pathway)]} { return $LesCopainsDePathway($Pathway) } if {[info exists LesCopainsDePathway("EstCharge")]} { return {} } set LesCopainsDePathway("EstCharge") 1 foreach Ligne [LesLignesDuFichier $FichierPathway] { set LesMots {}; set Boite ""; set PathwaysLus ""; set LesPathwaysLu {} set LesMots [split $Ligne "\t"] ScanLaListe $LesMots Boite PathwaysLus set LesPathwaysLu [split $PathwaysLus ","] foreach PathwayLu $LesPathwaysLu { lappend LesCopainsDePathway($PathwayLu) $Boite } } foreach {C V} [array get LesCopainsDePathway] { set LesCopainsDePathway($C) [ListeSansDoublon $V] } return [LesCopainsDePathway $Pathway] } proc LesCops {{Liste ""}} { set RepertoireEntree "[RepertoireDuGenome]/transcriptomique/cluster" set RepertoireSortie "[RepertoireDuGenome]/transcriptomique/LesCopainsCluster" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set LesVisuals {GO:0050908 GO:0007632 GO:0008542 GO:0007601 GO:0051356} if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { Espionne "$Nom" #if {[PasTouche $Nom]} {continue} set LesFichiers [split [TranscriptomicClusters $Nom FileNames] "\n"] foreach File $LesFichiers { Espionne "File $File" set nbdecombinaison 0 set LesCopsTotal {} set LesCombinaisons {} set LesLignes {} set Queue [file tail $File] Espionne "$Queue" regsub {\-.*} $Queue "" Nom if {[file exists "$RepertoireSortie/$Queue-lescops"]} {continue} foreach Ligne [LesLignesDuFichier $File] { set LesMots [split $Ligne "\t"] ScanLaListe $LesMots Bidon ExpPs AnalPs ClusPs NumPs if {$NumPs=="NA"} {continue} #attention plus de NA set S [LesCopainsDeCluster SizeOf$ExpPs $AnalPs $ClusPs $NumPs] if {$S>2500} {continue} incr nbdecombinaison set LesMots [LesMotsDeLaLigne $ClusPs] set un [lindex $LesMots 0] set deux [lindex $LesMots 3] set trois [lindex $LesMots 4] set ClusPs2 "$un$deux$trois" regsub -- "-" $ClusPs2 "" ClusPs2 set Combi "$ExpPs,$AnalPs,$ClusPs2,$NumPs" set LesCops($Combi) [LesCopainsDeCluster $ExpPs $AnalPs $ClusPs $NumPs] LConcat LesCopsTotal $LesCops($Combi) lappend LesCombinaisons $Combi } set LesCopsTotal [lsort $LesCopsTotal] foreach Combi $LesCombinaisons { set Ligne "$Combi: $LesCops($Combi)" lappend LesLignes $Ligne } set premierefois 1 foreach elmt $LesCopsTotal { #Espionne "elmt $elmt" if {$premierefois} { set Cumul($elmt) 1 set AncienElmt "" set premierefois 0 } if {$AncienElmt==$elmt} { incr Cumul($elmt) } if {$AncienElmt!=$elmt} { set Cumul($elmt) 1 } set AncienElmt $elmt } set LesResultsSansMoi {} foreach {cle val} [array get Cumul] { Espionne "cle $cle" Espionne "val $val" set LesIdGos {}; set LesDefs {} set LesElmtCle [split $cle "-"] set Nom [lindex $LesElmtCle 0] set Gn [ExtraitInfo $Nom "ValiGN"] set LesIdGos [InterrogeGeneOntology $FichierGO $Nom LesGO] foreach IdGo $LesIdGos { foreach Visual $LesVisuals { if {$IdGo==$Visual} { lappend LesDefs [join [InterrogeGeneOntology $FichierGO GO $IdGo LaDefinition] ""] } } } set DefinitionGo [join $LesDefs ","] if {$cle==$Queue} { set MoiMeme "$val $cle $Gn $DefinitionGo" } else { lappend LesResultsSansMoi "$val $cle $Gn $DefinitionGo" } } set LesResultsSansMoi [lsort -integer -index 0 -decreasing $LesResultsSansMoi] #set LesResultsSansMoi [lsort -real -index 0 -decreasing $LesResultsSansMoi] #lappend LesLignesResult "nbdecombinaison $nbdecombinaison" set LesLignesResult [list $MoiMeme] foreach x $LesResultsSansMoi { lappend LesLignesResult "$x" } #SauveLesLignes $LesLignes dans "$RepertoireSortie/$Queue-lescops" #SauveLesLignes $LesLignesResult dans "$RepertoireSortie/$Queue-lesbestcops" array unset LesCops; array unset Cumul } #FinPasTouche $Nom } } proc LesCopsPath {} { set FichierEntree "[RepertoireDuGenome]/Ingenuity/LesPathwaysDesBoites" set RepertoireSortie "[RepertoireDuGenome]/Ingenuity/LesCopainsPathway" foreach Ligne [LesLignesDuFichier $FichierEntree] { set LesMots {}; set Boite ""; set PathwaysLus ""; set LesPathwaysLu {} set LigneFinale ""; set LesLignes {}; set LesPath {} regexp {^(\S+)\s+(.+)$} $Ligne tmp Boite PathwaysLus #si pas de pathway exp reguliere ne match pas puts "$Boite" set LesPathwaysLu [split $PathwaysLus ","] foreach PathwayLu $LesPathwaysLu { set LesCopsPath($PathwayLu) [LesCopainsDePathway $PathwayLu] lappend LesPath $PathwayLu } foreach Path $LesPath { set LigneFinale "$Path: $LesCopsPath($Path)" lappend LesLignes $LigneFinale } SauveLesLignes $LesLignes dans "$RepertoireSortie/$Boite-lescops" array unset LesCopsPath } } proc LesCouleursSeqlabDesAAs {AA} { global LesCouleursSeqlabDesAAs if {[regexp "fg_and_bg_of_bg" $AA]} { set AA [string tolower $AA] } if {[string length $AA]==1} { set AA [string toupper $AA] } if {$AA==" "} { set AA "Space" } if {$AA=="."} { set AA "Dot" } if {$AA=="-"} { set AA "Hyphen" } if {$AA=="~"} { set AA "Tilde" } if {[info exists LesCouleursSeqlabDesAAs($AA)]} {return $LesCouleursSeqlabDesAAs($AA)} if {[info exists LesCouleursSeqlabDesAAs("EstCharge")]} { if {[regexp "fg_and_bg_of_bg" $AA]} { return "black unknown" } return $LesCouleursSeqlabDesAAs("EstCharge") } lappend AFB I white magenta lappend AFB L white magenta lappend AFB M white magenta lappend AFB V white magenta lappend AFB R white blue lappend AFB K white blue lappend AFB F white red lappend AFB Y white red lappend AFB W white red lappend AFB D white forestgreen lappend AFB E white forestgreen lappend AFB Q white green lappend AFB P white black lappend AFB G black orange lappend AFB H black cyan lappend AFB N black cyan lappend AFB S white darkviolet lappend AFB T white darkviolet lappend AFB A white darkviolet lappend AFB C white darkviolet lappend AFB "Space" white darkslategrey lappend AFB "Dot" white darkslategrey lappend AFB "Hyphen" white darkslategrey lappend AFB "Tilde" white darkslategrey lappend AFB "NoValue" white darkslategrey set LesCouleursSeqlabDesAAs(LaListeMerci) $AFB foreach {A F B} $AFB { lappend LesCouleursSeqlabDesAAs(ListeDesAAs) $A lappend LesCouleursSeqlabDesAAs(ListeDesFGs) $F lappend LesCouleursSeqlabDesAAs(ListeDesBGS) $B set LesCouleursSeqlabDesAAs($A) "$F $B" set LesCouleursSeqlabDesAAs(fg_and_bg_of_bg_$B) "$F $B" } set LesCouleursSeqlabDesAAs("EstCharge") $LesCouleursSeqlabDesAAs(NoValue) return [LesCouleursSeqlabDesAAs $AA] } proc LesCoupuresPossibles {} { set LesCoupuresPossibles [list "Thrombin 12 P" "TEV2 18 P" "TEVS 18 P" "Protease3C 18 P" "NdeI 3 N" "BamHI 3 N" "SpeI 3 N"] return $LesCoupuresPossibles } proc LesCrossLinkedDeLAccess_Recursif {Access {LesCrossLinked ""}} { set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} { set PageInfo [PageInfo $Access "\{protein genbankfull\}"] AskLesPagesInfos set $Access $PageInfo } if {$PageInfo == ""} {return $LesCrossLinked} if {[regexp "^LOCUS " $PageInfo]} { if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {return $LesCrossLinked} set CEstUneProteine 0 set CEstUnmRNA 1 } else { set CEstUneProteine 1 set CEstUnmRNA 0 } foreach LIndividu $LesCrossLinked { set Individu [lindex $LIndividu 0] set DejaVu($Individu) 1 } if {[info exists DejaVu($Access)]} {return $LesCrossLinked} set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] if {$CEstUneProteine} { set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] set Taille [TailleDeLaProt_PageInfo $PageInfo] foreach Orga $LesOrgas {lappend LesCrossLinked [list $Access "Protein" $Taille $Orga $Def]} set LesNouveauxAcNuc {} foreach AcNuc [LesAcNucsDeLaProt_PageInfo $PageInfo] { if {[info exists DejaVu($AcNuc)]} {continue} lappend LesNouveauxAcNuc $AcNuc } AskLesPagesInfos load $LesNouveauxAcNuc genbankfull foreach AcNuc $LesNouveauxAcNuc { set PageInfo [AskLesPagesInfos ask $AcNuc] if {$PageInfo == ""} {continue} if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {continue} set LesCrossLinked [LesCrossLinkedDeLAccess_Recursif $AcNuc $LesCrossLinked] } } if {$CEstUnmRNA} { set Def [join [LaDefinitionDeLAcNuc_PageInfo $PageInfo] " "] set Taille [TailleDeLAcNuc_PageInfo $PageInfo] foreach Orga $LesOrgas { lappend LesCrossLinked [list $Access "mRNA" $Taille $Orga $Def] } set LesNouveauxAcProt {} foreach AcProt [LesProteinesDeLAcNuc_PageInfo $PageInfo] { if {[info exists DejaVu($AcProt)]} {continue} lappend LesNouveauxAcProt $AcProt } AskLesPagesInfos load $LesNouveauxAcProt protein foreach AcProt $LesNouveauxAcProt { set PageInfo [AskLesPagesInfos ask $AcProt] if {$PageInfo == ""} {continue} set LesCrossLinked [LesCrossLinkedDeLAccess_Recursif $AcProt $LesCrossLinked] } } return $LesCrossLinked } proc LesCrossLinkedDesAccess {LesAccess} { if {$LesAccess == {}} {return} AskLesPagesInfos load $LesAccess "\{protein genbankfull\}" set LesCrossLinked {} foreach Access $LesAccess { set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} {continue} foreach LeCrossLinked [LesCrossLinkedDeLAccess_Recursif $Access $LesCrossLinked] { lappend LesCrossLinked $LeCrossLinked } } AskLesPagesInfos unset return $LesCrossLinked } proc LesCsDeManu {} { foreach Nom [ListeDesPABs] { set CS [CodonStart $Nom] if {$CS=="" || [regexp "^GroupSize" $CS]} { continue } InformeSansDemander $Nom "CSP: $CS" InformeSansDemander $Nom "=CodonStart: ARefaire" Espionne "$Nom $CS" } exit } proc LesDDConsideresPourLesResultatsFinaux {} { set FichierDes925 "[RepertoireDuGenome]/fiches/les925pabs" foreach JR [ListeDesJR $FichierDes925] { set Vu($JR) 1 } #1854 et jum = 2334 set Fichier1854EtJumeaux "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $Fichier1854EtJumeaux] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set Trouve 0 foreach DD $LesJumeaux { if {[info exists Vu($DD)]} {lappend LesOldJR $DD; set Trouve 1;break} } #aucun DD de cette ligne n'etait ds les 925 if {$Trouve==0} {lappend ListeSansJR $Ligne} } Espionne [llength $LesOldJR] Espionne [llength $ListeSansJR] #return $ListeSansJR } proc LesDDConsideresPourLesResultatsFinaux1 {} { set FichierDes925 "[RepertoireDuGenome]/fiches/925" foreach Ligne [LesLignesDuFichier $FichierDes925] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { set Vu($DD) 1 } } #1854 et jum = 2334 set Fichier1854EtJumeaux "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $Fichier1854EtJumeaux] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set Trouve 0 foreach DD $LesJumeaux { if {[info exists Vu($DD)]} {lappend LesOldJR $DD; set Trouve 1;break} } #aucun DD de cette ligne n'etait ds les 925 if {$Trouve==0} {lappend ListeSansJR $Ligne} } Espionne [llength $LesOldJR] Espionne [llength $ListeSansJR] #return $ListeSansJR } proc LesDDConsideresPourLesResultatsFinaux2 {} { set FichierDes925 "[RepertoireDuGenome]/fiches/925" foreach Ligne [LesLignesDuFichier $FichierDes925] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { set Vu($DD) 1 } } set Fichier1854EtJumeaux "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $Fichier1854EtJumeaux] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { if {![info exists Vu($DD)]} {lappend LesNonVus $DD} } } Espionne [llength $LesNonVus] } proc LesDDConsideresPourLesResultatsFinaux3 {} { set FichierDes925 "[RepertoireDuGenome]/fiches/les925pabs" foreach Ligne [LesLignesDuFichier $FichierDes925] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { set Vu($DD) 1 } } Espionne $n set Fichier1854EtJumeaux "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $Fichier1854EtJumeaux] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { if {![info exists Vu($DD)]} {lappend LesNonVus $DD} } } Espionne [llength $LesNonVus] } proc LesDDManquants {Fichier} { set n 0 set L [CreeListePourFichierAUneColonne $Fichier] foreach DD $L { incr n if {[regexp {^DD0+} $DD]} {regsub {^DD0+} $DD "" DD} else {regsub "DD" $DD "" DD} if {$DD!=$n} {FaireLire "$n $DD";set n $DD} } } proc LesDefDesClustersDPC {Fichier} { Wup "Ajoute la def a partir du fichier TribeMcl pour les clusters DPC du pipe" set NbGroupe "" set LesGroupes {} set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if { [regexp -nocase "^Number" $Ligne]} {continue} if { [regexp -nocase "^query" $Ligne]} {continue} if { [regexp -nocase "^Group" $Ligne]} { set NbGroupe [lindex $Ligne 1] lappend LesGroupes $NbGroupe continue } set Access [lindex $Ligne 0] set TabCluster($Access,groupe) $NbGroupe lappend TabCluster($NbGroupe,lesAccess) $Access } close $F set FichierSave "ClusterDpcPipeComplet" set FichierCluster "[RepertoireDuGenome]/actinlist2" set F [open "$FichierCluster"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set Def "" set MonAccess [lindex $Ligne 0] set Def [lrange $Ligne 1 end] set TabCluster($MonAccess,def) $Def } close $F foreach UnGroupe $LesGroupes { foreach LesAccDuGroupe [set TabCluster($UnGroupe,lesAccess)] { set DefDeAc [set TabCluster($LesAccDuGroupe,def)] set Entete [format "%3s %10s %-30s" $UnGroupe $LesAccDuGroupe $DefDeAc] AppendAuFichier $FichierSave $Entete } } return "" } proc LesDefauts {args} { global env OrdEtcDir Defauts VersionDeOrdali set VersionDeOrdali 3.5 if {[llength $args] == 2} { lassign $args Type Valeur set Defauts($Type) $Valeur if {$Type == "Mode" && [string equal -nocase $Valeur "batch"]} { global FaireLireNon set FaireLireNon 1 } return } set ::VueEditee 0 ValsDesDefauts if {[UtiliseCCode]} { set Defauts(UseSpeedCode) "C" } else { set Defauts(UseSpeedCode) "tcl" } if {$args ne "OldDef"} { package require platform set plat [::platform::generic] if {[regexp -nocase {^window} $plat]} { set fdef [file join $env(APPDATA) ordalierc.def] } else { if {[info exists env(HOME)]} { set fdef [file join $env(HOME) .ordalierc] } else { # env(HOME) does not exits... # Ordalie is launched from a httpd server set fdef "DontSaveIt" } } if {[file exists $fdef]} { array set Defauts [ContenuDuFichier $fdef] #source $fdef } elseif {$fdef ne "DontSaveIt"} { SauveOrdalieDefauts } } if {"Structure" ni [info commands]} { SetupPDBObject } ToggleAuLog $Defauts(LogAtStartup) return } proc LesDefautsDuPipe {args} { global DefautsPipe global VersionDuPipe set VersionDuPipe 1.0 if {[llength $args] != 0} { set Type [lindex $args 0] set Valeur [lindex $args 1] set DefautsPipe($Type) $Valeur if {$Type == "Blast,d"} {set DefautsPipe(Filter,bank) $Valeur} } else { set DefautsPipe(File,file) "" set DefautsPipe(File,pjt) 0 set DefautsPipe(File,log) "verbose" #AF set DefautsPipe(Project,project) "" set DefautsPipe(Url,birdHoan) "http://bird.u-strasbg.fr:8080/bird/" #set DefautsPipe(Url,birdHoan) "http://d1.crihan.fr:8080/bird/" ## set DefautsPipe(Blast,d) "protall" set DefautsPipe(Blast,e) "5000" #set DefautsPipe(Blast,v) "5000" set DefautsPipe(Blast,b) "5000" set DefautsPipe(Blast,K) "0" set DefautsPipe(Blast,f) "9" set DefautsPipe(Blast,F) "T" set DefautsPipe(Blast,g) "T" set DefautsPipe(Blast,m) "0" #set DefautsPipe(Blast,a) "4" set DefautsPipe(Blast,p) "blastp" set DefautsPipe(Filter,bank) [set DefautsPipe(Blast,d)] set DefautsPipe(Filter,method) "none" set DefautsPipe(Filter,length) "3000" set DefautsPipe(Filter,fragment) "1" set DefautsPipe(Filter,maxseq) "500" set DefautsPipe(Filter,expect) "0.001" set DefautsPipe(Filter,add) "0" set DefautsPipe(Filter,varsplic) "0" set DefautsPipe(Filter,addpdb) "" set DefautsPipe(DbClustal,propagate) "1" set DefautsPipe(DbClustal,output) "gcg" set DefautsPipe(DbClustal,motifs) "1" set DefautsPipe(DbClustal,clustalw) "/biolo/clustal/bin/clustalw" set DefautsPipe(Conservation,method) "Cluster" set DefautsPipe(Cluspack,bestmsf) "auto" set DefautsPipe(Macsims,bestmsf) "auto" set DefautsPipe(Etapes,blast) "1" set DefautsPipe(Etapes,ballast) "1" set DefautsPipe(Etapes,filter) "1" set DefautsPipe(Etapes,clustal) "1" set DefautsPipe(Etapes,normd1) "1" set DefautsPipe(Etapes,rascal) "1" set DefautsPipe(Etapes,normd2) "1" set DefautsPipe(Etapes,leon) "1" set DefautsPipe(Etapes,normd3) "1" set DefautsPipe(Etapes,cluspack) "1" set DefautsPipe(Etapes,macsims) "1" set DefautsPipe(Etapes,conservation) "0" set DefautsPipe(Etapes,modelisation) "0" } if {[set DefautsPipe(Blast,m)] != 0} { set DefautsPipe(Etapes,ballast) "0" set DefautsPipe(Etapes,filter) "0" set DefautsPipe(Etapes,clustal) "0" set DefautsPipe(Etapes,normd1) "0" set DefautsPipe(Etapes,rascal) "0" set DefautsPipe(Etapes,normd2) "0" set DefautsPipe(Etapes,leon) "0" set DefautsPipe(Etapes,normd3) "0" set DefautsPipe(Etapes,cluspack) "0" set DefautsPipe(Etapes,macsims) "0" set DefautsPipe(Etapes,conservation) "0" set DefautsPipe(Etapes,modelisation) "0" } if {[set DefautsPipe(Filter,method)] eq "meta" || [set DefautsPipe(Filter,method)] eq "euca" || [set DefautsPipe(Filter,method)] eq "vert"} { if {[set DefautsPipe(Blast,d)] ne "protein" || [set DefautsPipe(Blast,d)] ne "swsplice"} { set DefautsPipe(Blast,d) "protall" set DefautsPipe(Filter,bank) "protall" } } # si on souhaite calculer un modele, une empreinte doit etre cree au prealable # il faut dc que le projet soit de type ms2phdb if {[set DefautsPipe(Etapes,modelisation)] == 1} { set DefautsPipe(Project,project) "ms2phdb" } if {[QuelProjet] eq "ms2phdb"} { # la banque interrogee doit contenir des pdb # afin de beneficier des ancres pour les templates if {[set DefautsPipe(Blast,d)] ne "protall" && [regexp "uni90pdb" [set DefautsPipe(Blast,d)]] != 1} { set DefautsPipe(Blast,d) "protall" set DefautsPipe(Filter,bank) "protall" } set DefautsPipe(Etapes,conservation) "1" } set DefautsPipe(Blast,v) [set DefautsPipe(Blast,b)] return 1 } proc LesDefautsDuPipex {args} { global DefautsPipe global VersionDuPipe set VersionDuPipe 1.0 if {[llength $args] != 0} { set Type [lindex $args 0] set Valeur [lindex $args 1] set DefautsPipe($Type) $Valeur if {$Type == "Blast,d"} {set DefautsPipe(Filter,bank) $Valeur} } else { #set DefautsPipe(File,file) "/genomics/link/SpliRetMouse/prottfa/SPM0001" set DefautsPipe(File,file) "/genomics/link/SpliRetMouse/tmp/SPM0229" set DefautsPipe(File,pjt) 0 set DefautsPipe(File,log) "" #AF #set DefautsPipe(Project,project) "ms2phdb" #set DefautsPipe(Url,birdHoan) "http://bird.u-strasbg.fr:8080/bird/" ## #set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/FichiersInitial/TousLesAddMouseSsO" #set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/database/refseq-prot" set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/database/VERT_UniProt_RefSeq_Ensembl_Varsplic" set DefautsPipe(Blast,e) "1" set DefautsPipe(Blast,v) "5000" set DefautsPipe(Blast,b) "5000" set DefautsPipe(Blast,K) "0" set DefautsPipe(Blast,f) "9" set DefautsPipe(Blast,F) "T" set DefautsPipe(Blast,g) "T" set DefautsPipe(Blast,m) "0" #set DefautsPipe(Blast,a) "4" set DefautsPipe(Blast,p) "blastp" set DefautsPipe(Filter,bank) [set DefautsPipe(Blast,d)] set DefautsPipe(Filter,method) "splice" set DefautsPipe(Filter,length) "3000" set DefautsPipe(Filter,fragment) "1" set DefautsPipe(Filter,maxseq) "33" set DefautsPipe(Filter,expect) "0.01" set DefautsPipe(Filter,add) "0" set DefautsPipe(Filter,varsplic) "0" set DefautsPipe(Filter,addpdb) "" set DefautsPipe(Project,project) "addSeq" set DefautsPipe(DbClustal,propagate) "1" set DefautsPipe(DbClustal,output) "gcg" set DefautsPipe(DbClustal,motifs) "1" set DefautsPipe(DbClustal,clustalw) "/biolo/clustal/bin/clustalw" set DefautsPipe(Cluspack,bestmsf) "auto" set DefautsPipe(Macsims,bestmsf) "auto" set DefautsPipe(Conservation,method) "none" set DefautsPipe(Etapes,conservation) "0" set DefautsPipe(Etapes,blast) "1" set DefautsPipe(Etapes,ballast) "1" set DefautsPipe(Etapes,filter) "1" set DefautsPipe(Etapes,clustal) "1" set DefautsPipe(Etapes,normd1) "1" set DefautsPipe(Etapes,rascal) "1" set DefautsPipe(Etapes,normd2) "1" set DefautsPipe(Etapes,leon) "1" set DefautsPipe(Etapes,normd3) "1" set DefautsPipe(Etapes,cluspack) "0" set DefautsPipe(Etapes,macsims) "1" set DefautsPipe(Etapes,modelisation) "0" } if {[set DefautsPipe(Filter,method)] eq "meta" || [set DefautsPipe(Filter,method)] eq "euca"} { if {[set DefautsPipe(Blast,d)] ne "protein"} { set DefautsPipe(Blast,d) "protall" set DefautsPipe(Filter,bank) "protall" } } return } proc LesDefautsDuPipey {args} { global DefautsPipe global VersionDuPipe set VersionDuPipe 1.0 if {[llength $args] != 0} { set Type [lindex $args 0] set Valeur [lindex $args 1] set DefautsPipe($Type) $Valeur if {$Type == "Blast,d"} {set DefautsPipe(Filter,bank) $Valeur} } else { #set DefautsPipe(File,file) "/genomics/link/SpliRetMouse/prottfa/SPM0001" set DefautsPipe(File,file) "/genomics/link/SpliRetMouse/tmp/SPM0229" set DefautsPipe(File,pjt) 0 set DefautsPipe(File,log) "" #AF #set DefautsPipe(Project,project) "ms2phdb" #set DefautsPipe(Url,birdHoan) "http://bird.u-strasbg.fr:8080/bird/" ## #set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/FichiersInitial/TousLesAddMouseSsO" #set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/database/refseq-prot" set DefautsPipe(Blast,d) "/genomics/link/SpliRetMouse/database/VERT_UniProt_RefSeq_Ensembl_Varsplic" set DefautsPipe(Blast,e) "1" set DefautsPipe(Blast,v) "5000" set DefautsPipe(Blast,b) "5000" set DefautsPipe(Blast,K) "0" set DefautsPipe(Blast,f) "9" set DefautsPipe(Blast,F) "T" set DefautsPipe(Blast,g) "T" set DefautsPipe(Blast,m) "0" #set DefautsPipe(Blast,a) "4" set DefautsPipe(Blast,p) "blastp" set DefautsPipe(Filter,bank) [set DefautsPipe(Blast,d)] set DefautsPipe(Filter,method) "splice" set DefautsPipe(Filter,length) "3000" set DefautsPipe(Filter,fragment) "1" set DefautsPipe(Filter,maxseq) "33" set DefautsPipe(Filter,expect) "0.01" set DefautsPipe(Filter,add) "0" set DefautsPipe(Filter,varsplic) "0" set DefautsPipe(Filter,addpdb) "" set DefautsPipe(Project,project) "addSeq" set DefautsPipe(DbClustal,propagate) "1" set DefautsPipe(DbClustal,output) "gcg" set DefautsPipe(DbClustal,motifs) "1" set DefautsPipe(DbClustal,clustalw) "/biolo/clustal/bin/clustalw" set DefautsPipe(Cluspack,bestmsf) "auto" set DefautsPipe(Macsims,bestmsf) "auto" set DefautsPipe(Conservation,method) "none" set DefautsPipe(Etapes,conservation) "0" set DefautsPipe(Etapes,blast) "1" set DefautsPipe(Etapes,ballast) "1" set DefautsPipe(Etapes,filter) "1" set DefautsPipe(Etapes,clustal) "1" set DefautsPipe(Etapes,normd1) "1" set DefautsPipe(Etapes,rascal) "1" set DefautsPipe(Etapes,normd2) "1" set DefautsPipe(Etapes,leon) "1" set DefautsPipe(Etapes,normd3) "1" set DefautsPipe(Etapes,cluspack) "0" set DefautsPipe(Etapes,macsims) "1" set DefautsPipe(Etapes,modelisation) "0" } return } proc LesDefinitionsBienParenthesees {Texte} { set Niveau 0 set LesDefs {} set Lu "" set LesCars [split $Texte ""] lappend LesCars "." set DernierMis "turlututu" foreach C $LesCars { if {$C=="("} { if {$Niveau==0} { set AMettre [string trim $Lu " .;"] if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } } incr Niveau append Lu $C continue } if {$C==")"} { incr Niveau -1 append Lu $C continue } append Lu $C if {$C==" " || $C=="." || $C==";"} { set AMettre [string trim $Lu " .;"] if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } } } set AMettre [string trim $Lu " .;"] if {$AMettre!=$DernierMis} { lappend LesDefs $AMettre ; set DernierMis $AMettre } return $LesDefs } proc LesDefinitionsDesProteinesDuMSF {Nom {IdDesProtId 0.98} {NormMDMin 0.5}} { set FileMSF "[RepertoireDuGenome]/msf/$Nom" set FileClust "${FileMSF}.clust" ####Recherche des EC appartennant aux proteines du cluster du msf si celui-ci a un bon NormMD#### if {![file exists $FileMSF]} {return} if {[AskMSF $FileMSF $Nom] != ""} { set Query $Nom } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" } else { return } set LesMotsDeRef {} set LesDefinitionsDeRef {} foreach Access [LesProteinesProchesDeLaProteineDeRef $Query $FileMSF $FileClust $IdDesProtId AvecCluster $NormMDMin] { if {[regexp {^[0-9]} $Access]} {continue} LesPhrasesMemorisees UNSET InterrogeLesEffectifsDesMots UNSET set PageInfo [PageInfo $Access protein des] if {$PageInfo == ""} {continue} set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] if {$Def == ""} {continue} lappend LesDefinitionsDeRef "$Access\t$Def" } return [LesPhrasesNettoyees $LesDefinitionsDeRef] } proc LesDefinitionsDuMsf {FichierMsf} { set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre] foreach NomSeq $LesSequencesDansLOrdre { regsub "spt_" $NomSeq "" Access set DE [BirdWeb UNIPROT $Access] Espionne "$Access $DE" } return } proc LesDefinitionsRevisitees {} { foreach Nom [ListeDesPABs] { set NotreDE [string trim [Definition $Nom] "."] set NarciDE [string trim [ExtraitInfo $Nom "DE_Narcisse"] "."] if {[string toupper $NotreDE]==[string toupper $NarciDE]} { continue } if {[regexp "Hypothetical protein" $NotreDE] && [regexp {HYPOTHETICAL [0-9\.]* KDA PROTEIN} $NarciDE] } { continue } Espionne $Nom Espionne "$NotreDE\n$NarciDE" lappend LesNouveaux $Nom } return $LesNouveaux } proc LesDefsAlA {args} { global AlATables set ::WithGUI 0 set ::debug 1 set ::debsq "s01" set ::debag "" set ::WeightCols 1 set ::WeightMotif 0 set ::MotifLen 5 set ::DoStep 0 set ::StepMode 0 set ::Start 0 set ::AlATables " - file { . pk_file P . nom V32 . dataset V32 . nbSeqs I . length I } - block { . pk_block P . start I . stop I . length I } - ln_file_block { . pk_file I . pk_block I } - analyse { . pk_analyse P . score V16 . matrix V16 . weight I . motiflen I } - ln_block_analyse { . pk_block I . pk_analyse I } - segment { . pk_segment P . rank R . min I . max I . nzero I . nsup I } - ln_analyse_segment { . pk_analyse I . pk_segment I }" return } proc LesDescriptifsDuBlast {FichierOuNom {Source ""}} { #rR Petite remarque : LesDescriptifs c'est assez compliqué #rR ça a l'air de tourner en rond ... car ici on crée les descritptifs même s'ils existent déjà #rR en fait il ne le rajoute que s'il n'existe pas #rR (StockeLeDescriptif est assez intelligent ) global RepertoireDuGenome global SeuilExpectPourJulie if {$Source==""} { set Source "blastp" } set Nom [file tail $FichierOuNom] scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect set MaxADecortiquer [expr $MaxVoulus+$MaxPDB] if {[info exists SeuilExpectPourJulie]} { set SeuilExpect $SeuilExpectPourJulie } Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... " set LesIndesirables {} if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} { lappend LesIndesirables $Indesirables } set LesCandidats {} if {$Source=="daedalus" || ($Source=="" && [OuiOuNonMemo "Do I use Daedalushits to collect the candidates for DbClustal ?" 0])} { set Source "daedalushits" set Fichier "$RepertoireDuGenome/$Source/$Nom" while { ! [file exists $Fichier]} { if {[OuiOuNon "May be you forgot to run DaedalusHitsDuBlastPPourTous.\n Do I run it now ... (it could take a while) ? "]} { DaedalusHitsDuBlastPPourTous "EnProcessExterne" } else { if {[OuiOuNon "Do I return an empty list of orthologs for $Nom ?" 0]} { return {} } if {[OuiOuNon "Do I use the blastp file ?"]} { return [LesDescriptifsDuBlast $FichierOuNom "blastp"] } } } set Texte [ContenuDuFichier $Fichier] set PN 0.0009876 while 1 { set BlastHit [ValeurDeLaBalise "BlastHit" Texte "Rogner" BH] if {$BlastHit==""} { break } set BanqueId $BH set Access $BH set AccessOK $BH set OldPN $PN set ID [ValeurDeLaBalise "ID" BlastHit "NePasRogner"] set AC [ValeurDeLaBalise "AC" BlastHit "NePasRogner"] set PN [ValeurDeLaBalise "PN" BlastHit "NePasRogner"] if {$PN=="0.000999"} { set PN $OldPN } set OX [ValeurDeLaBalise "OX" BlastHit "NePasRogner"] set GN [ValeurDeLaBalise "GN" BlastHit "NePasRogner"] set DE [ValeurDeLaBalise "DE" BlastHit "NePasRogner"] set OS [ValeurDeLaBalise "OS" BlastHit "NePasRogner"] set OC [ValeurDeLaBalise "OC" BlastHit "NePasRogner"] set CandId [lindex [split $ID " "] 0] set CandAc [lindex [split $AC " "] 0] if {$CandId==""} { set CandId $BanqueId } if {$CandAc==""} { set CandAc $Access } if {$OS=="" && $OX!=""} { set OS [Tax $OX "Name"] } regsub -all " " $DE "_" BeauDE set Candidat "$CandId $CandAc $PN $OS $BeauDE $OC" lappend LesCandidats $Candidat regsub -all {\:} $DE "_" DE set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX" StockeLeDescriptif $AccessOK $Descriptif $Nom } Espionne "$Nom accepts [llength $LesCandidats] candidats" return $LesCandidats } if {[file exists $FichierOuNom] && $Nom!=$FichierOuNom} { set Fichier $FichierOuNom } else { set Fichier "$RepertoireDuGenome/$Source/$Nom" } if { ! [file exists $Fichier]} { return {} } DecortiqueBlast $Fichier $SeuilExpect $MaxADecortiquer Query lBanqueId lAccess lDE lProfil lPN #rR rajout 2014/11/25 set LesBonBid {} set LesBonAcc {} foreach BID $lBanqueId ACC $lAccess { if {[regexp {\|} $BID]} { lassign [split $BID "|"] Ban BonAcc BonBid lappend LesBonAcc $BonAcc lappend LesBonBid $BonBid continue } lappend LesBonAcc $ACC lappend LesBonBid $BID } set lAccess $LesBonAcc set lBanqueId $LesBonBid set NbEnMemoire [PrepareLesSequencesDesBanques $lBanqueId $lAccess] Espionne "$NbEnMemoire EMBL mis en memoire par PrepareLesSequencesDesBanques" foreach BanqueId $lBanqueId Access $lAccess PetitDE $lDE Profil $lProfil PN $lPN { if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue } # if {$FromDescriptifs} { # } set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"] if {$LesLignesEMBL=={}} { continue } DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX Espionne $DE if {$DE==""} { set DE $PetitDE } LeDescriptif $AC $Nom $DE ;#rR rajout 2013/10/17 : Mise en memoire pour ConcatLeTFAs regsub -all " " $DE "_" BeauDE lappend LesCandidats "$BanqueId $Access $PN $OS $BeauDE $OC" regsub -all {\:} $DE "_" DE set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX" StockeLeDescriptif $AccessOK $Descriptif $Nom } return $LesCandidats } proc LesDescriptifsDuMSF {FileMSF} { if {![file exists $FileMSF]} {return} AskMSF unset AskLesPagesInfos unset set LesAccess [AskMSF $FileMSF LesAccess] if {$LesAccess == ""} {return} AskLesPagesInfos load $LesAccess protein set LesDescriptifs {} foreach Access $LesAccess { if {$Access == "QUERY_PROTEIN"} {continue} Espionne "$FileMSF -> $Access" set AccessOK "$Access=$Access" if {[EstUnAccessVARSPLIC $Access] || [EstUnAccessPDB $Access]} { set LaPageInfo [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"] } else { set LaPageInfo [split [AskLesPagesInfos ask $Access] "\n"] } if {$LaPageInfo == ""} {continue} DecortiqueLesLignesEMBL $LaPageInfo ID AC DE GN OS OC OX regsub -all {\:} $DE "_" DE lappend LesDescriptifs "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX" } AskLesPagesInfos unset AskMSF unset return $LesDescriptifs } proc LesDevStage {Nom FichierBlastEST {AllOrgaouJustMyOrga AllOrga} {IdDeRef 0.95}} { if {![file exists $FichierBlastEST]} {return [list "$Nom\tNoESTFound"]} set NbSubject [AskBlast $FichierBlastEST NbSubject] if {$NbSubject == ""} {return [list "$Nom\tNoESTFound"]} set OrgaDeRef [OrganismeDuPAB $Nom] set LeTexte {} set LesBId {} for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlastEST Subject $i] set PAlignees [PourcentageDesBasesAligneesSurToutesLesBasesAlignables $FichierBlastEST $BId] if {$PAlignees < $IdDeRef} {continue} set PAlignables [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables $FichierBlastEST $BId] if {$PAlignables < $IdDeRef} {continue} Espionne $BId lappend LesBId $BId } AskLesPagesInfos load $LesBId est set LeTexte {} foreach BId $LesBId { set Page [AskLesPagesInfos ask $BId] if {$Page == ""} {continue} set Access [AskBlast $FichierBlastEST BanqueId $BId Access] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] if {$AllOrgaouJustMyOrga != "AllOrga"} { set EstCeUnDesOrga 0 foreach Orga $LesOrgas { if {[string equal -nocase $Orga $OrgaDeRef]} {set EstCeUnDesOrga 1;break} } if {!$EstCeUnDesOrga} {continue} } set LesDevStages [LesDevStageDeLAcNuc_PageInfo $Page] if {$LesDevStages == {}} {continue} foreach DevStage $LesDevStages { foreach Orga $LesOrgas { Espionne "$Nom\t$Access\t$Orga\t$DevStage" lappend LeTexte "$Nom\t$Access\t$Orga\t$DevStage" } } } AskBlast unset AskLesPagesInfos unset if {$LeTexte == {}} {return [list "$Nom\tNoESTFound"]} return $LeTexte } proc LesDevStageDeLAcNuc {Access {Banque genbankfull}} { return [LesDevStageDeLAcNuc_PageInfo [PageInfo $Access $Banque]] } proc LesDevStageDeLAcNuc_PageInfo {PageInfo} { set LAiJeVu 0 set Infos "" foreach Ligne [split $PageInfo "\n"] { if {!$LAiJeVu && [regexp -nocase "dev_stage=" $Ligne]} { regsub -nocase " source " $Ligne "" Ligne append Infos " $Ligne" set LAiJeVu 1 continue } if {$LAiJeVu && [regexp -nocase "BASE COUNT" $Ligne]} {break} if {!$LAiJeVu} {continue} append Infos " $Ligne" } if {!$LAiJeVu} {return ""} regsub -all " /" $Infos "," Infos regsub -all "\"" $Infos " " Infos regsub -all " and " $Infos "," Infos regsub -all {\. } $Infos "," Infos regsub -all ", " $Infos "," Infos regsub -all " ," $Infos "," Infos regsub -all "\=" $Infos "\=," Infos regsub -all "\\(" $Infos " " Infos regsub -all "\\)" $Infos " " Infos while {[regexp " " $Infos]} {regsub -all " " $Infos " " Infos} set LesTissues "" set SuisJeSurUnTissue 0 foreach Element [split [string trim $Infos] ","] { set Element [string trim $Element] if {$Element == ""} {continue} if {[string equal -nocase "dev_stage=" $Element]} { set SuisJeSurUnTissue 1 continue } if {$SuisJeSurUnTissue && [regexp "=" $Element]} { set SuisJeSurUnTissue 0 continue } if {!$SuisJeSurUnTissue} {continue} if {[info exists Tab($Element)]} {continue} set Tab($Element) 1 lappend LesTissues $Element } return [lsort -unique $LesTissues] } proc LesDiftesBandesParCluster {LeCluster} { foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] { ## (rq: pas de user R dans ce fichier) if {[regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set U [lindex $LesChamps 0] ### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ###### set CodeClone [string trim [lindex $LesChamps 1]] if {$U=="F"} { set CodeClone [string toupper $CodeClone] } set B [lindex $LesChamps 2] set Band($U,$CodeClone) $B } set LesJumeaux [split $LeCluster " "] foreach DD $LesJumeaux { Espionne $DD set CC [ExtraitInfo $DD "CodeClone"] set Ow [ExtraitInfo $DD "OwnerOfCDNA"] if {$Ow=="R"} {set Ow "I"} if {$Ow=="F"} {set CC [string toupper $CC]} set Bande $Band($Ow,$CC) #Bandes de Fred du type H16B sans profil alors que H16 avec profil et meme bande if {$Ow=="F" && [regexp -nocase {[A-Z]+[0-9]+[A-Z]} $Bande]} { regexp -nocase -indices {[A-Z]+[0-9]+} $Bande tmp set NewBande [string range $Bande 0 [lindex $tmp 1]] set Bande $NewBande } if {![info exists Vu($Bande,$Ow)]} {set Vu($Bande,$Ow) 1; lappend LesDiftesBandes $Bande} } return $LesDiftesBandes } proc LesDomaines {Nom FileMSF FileClust {IdDesProtId 0.98} {NorMDMin 0.5} {ProportionMinDuDomaineDeLaQuery 0.75}} { if {![file exists $FileMSF]} {return} if {[AskMSF $FileMSF $Nom] != ""} { set Query $Nom set LaSeqProtDeRef [split [string toupper [AskMSF $FileMSF $Query]] ""] } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" set LaSeqProtDeRef [split [string toupper [AskMSF $FileMSF $Query]] ""] } else { return } ###Recensement de tous les domaines Interpro Pfam et features de cet Access#### set TousLesDomainesDeRef {} foreach Access [LesProteinesProchesDeLaProteineDeRef $Query $FileMSF $FileClust $IdDesProtId "AvecCluster" $NorMDMin] { if {[EstUnAccessPDB $Access]} {continue} if {[EstUnAccessVARSPLIC $Access]} {continue} set Seq [AskMSF $FileMSF $Access] if {$Seq == ""} {continue} set LaSeqProt [split [string toupper $Seq] ""] ###Determination des domaines INTERPRO, PFAM et fetatures de la proteine set LesDomaines [LesDomainesDeLAccess $Access AvecInterpro AvecPFAM AvecFeature] set Tab(Access,$Access,LesDomaines) $LesDomaines set Tab(Access,$Access,LaSeqProt) $LaSeqProt if {$LesDomaines == {}} {continue} ###Correspondance des domaines de l'access avec la sequence de la query foreach LeDomaine [lsort -unique -index 3 -real $LesDomaines] { set Type [lindex $LeDomaine 0] set Dom [lindex $LeDomaine 1] set Def [lindex $LeDomaine 2] set Debut [lindex $LeDomaine 3] set Fin [lindex $LeDomaine 4] set NAATot [expr $Fin - $Debut + 1] set NAAEnCommun 0 ################################################# ###IMPORTANT car dans feature un domaine peut avoir plusieurs domaines#### if {$Type == "FEATURE"} { set OldDom $Dom set Dom "$Dom $Def" regsub -all -nocase {[^a-z0-9 ]} $Dom "" Dom set Tab(Domaine,$Dom,VraiNomDeDomaine) $OldDom } set DebutDeRef "" set PosSurProt 0 set PosSurProtDeRef 0 set AiJeLeDebut 0 set AiJeLaFin 0 foreach AADeRef $LaSeqProtDeRef AA $LaSeqProt { if {$AADeRef != "."} {incr PosSurProtDeRef} if {$AA != "."} {incr PosSurProt} else {continue} if {$PosSurProt < $Debut } {continue} if {$Fin < $PosSurProt} {break } if {!$AiJeLeDebut} { if {$AADeRef != $AA} {continue} set DebutDeRef $PosSurProtDeRef set FinDeRef $PosSurProtDeRef set AiJeLeDebut 1 } if {$AiJeLeDebut && $AADeRef == $AA} { incr NAAEnCommun set FinDeRef $PosSurProtDeRef } } if {$DebutDeRef == "" || $FinDeRef == ""} {continue} if {[expr ($FinDeRef-$DebutDeRef+1) * 1.0 / ($Fin-$Debut+1)] < $ProportionMinDuDomaineDeLaQuery} {continue} if {![info exists Tab(Domaine,$Dom,LesCoordonnees)]} { lappend TousLesDomainesDeRef $Dom set Tab(Domaine,$Dom,Type) $Type set Tab(Domaine,$Dom,Def) $Def set Tab(Domaine,$Dom,LesCoordonnees) {} } if {![info exists Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess)]} { set Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess) {} } lappend Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess) $Access lappend Tab(Domaine,$Dom,LesCoordonnees) [list $DebutDeRef $FinDeRef] } } set LesDomainesDeRef {} foreach DomDeRef $TousLesDomainesDeRef { set Def [set Tab(Domaine,$DomDeRef,Def)] set Type [set Tab(Domaine,$DomDeRef,Type)] ##Fusion de toutes les regions identiques et overlappantes determinees ci-dessus foreach LaRegionDeRef [LaFusionDesRegionsOverlappantes [set Tab(Domaine,$DomDeRef,LesCoordonnees)]] { set DebutDeRef [lindex $LaRegionDeRef 0] set FinDeRef [lindex $LaRegionDeRef 1] set LesAccess {} foreach UneR [set Tab(Domaine,$DomDeRef,LesCoordonnees)] { set D [lindex $UneR 0] set F [lindex $UneR 1] if {![CesRegionsSontEllesOverlappantes $DebutDeRef $FinDeRef $D $F]} {continue} foreach Access [set Tab(Domaine,$DomDeRef,$D,$F,LesAccess)] {lappend LesAccess $Access} } set NAATotDeRef [expr $FinDeRef - $DebutDeRef + 1] set NAAEnCommunMax 0 ##Calcul et determination du Pourcentage d'homologie le plus eleve avec ##les autres access possedant egalement ce domaine foreach Access $LesAccess { set LaSeqProt [set Tab(Access,$Access,LaSeqProt)] set NAAEnCommun 0 set PosSurProtDeRef 0 foreach AADeRef $LaSeqProtDeRef AA $LaSeqProt { if {$AADeRef != "."} {incr PosSurProtDeRef} else {continue} if {$PosSurProtDeRef < $DebutDeRef } {continue} if {$FinDeRef < $PosSurProtDeRef} {break } if {$AADeRef != $AA} {continue} incr NAAEnCommun } if {$NAAEnCommunMax < $NAAEnCommun} {set NAAEnCommunMax $NAAEnCommun} } if {$NAAEnCommunMax == 0} {continue} set Dom $DomDeRef ###Important on redonne le vrai nom du domaine aux features#### if {$Type == "FEATURE" && [info exists Tab(Domaine,$Dom,VraiNomDeDomaine)]} { set Dom [set Tab(Domaine,$Dom,VraiNomDeDomaine)] } set P [expr $NAAEnCommunMax * 1.0 / $NAATotDeRef] lappend LesDomainesDeRef [list $Nom $Type $Dom $Def $DebutDeRef $FinDeRef $P] } } if {$LesDomainesDeRef == {}} {return} return [lsort -index 4 -real [lsort -index 5 -real $LesDomainesDeRef]] } proc LesDomainesDeLAccess {Access {AvecOuSansInterpro AvecInterpro} {AvecOuSansPFAM AvecPFAM} {AvecOuSansFeature AvecFeature}} { ##Les domaines interpro de l'access par Interpromatch set LesDomaines {} if {$AvecOuSansInterpro == "AvecInterpro"} { foreach LInterpro [LesInterproDeLAccess $Access] { set IPR [lindex $LInterpro 1] set Def [lindex $LInterpro 2] set Debut [lindex $LInterpro 3] set Fin [lindex $LInterpro 4] if {$Debut == "" || $Fin == ""} {continue} if {[info exists Tab($IPR,$Debut,$Fin)]} {continue} set Tab($IPR,$Debut,$Fin) 1 lappend LesDomaines [list INTERPRO $IPR $Def $Debut $Fin] } } if {$AvecOuSansPFAM == "AvecPFAM"} { ##Les domaines pfam de l'access par SwissPfam dans SRS foreach LePfam [LesDomainesPfamDeLaProteine $Access] { set Pfam [lindex $LePfam 1] set Def [lindex $LePfam 2] set Debut [lindex $LePfam 4] set Fin [lindex $LePfam 5] lappend LesDomaines [list PFAM $Pfam $Def $Debut $Fin] } } if {$AvecOuSansFeature == "AvecFeature"} { ###Les features de l'access par extraction des infos de SRS foreach LaFeature [LesFeaturesDeLAccess $Access] { set Feature [lindex $LaFeature 1] ###Elimination de certains Feature ininteressant if {[regexp -nocase {VARSPLIC|PROPEP|CONFLICT|VARIANT|MUTAGEN} $Feature]} {continue} lappend LesDomaines $LaFeature } } return $LesDomaines } proc LesDomainesDeLaBoite {Nom {IdDesProtId 0.98} {NormMDMin 0.5} {ProportionMinDuDomaineDeLaQuery 0.75}} { set RepMSF "[RepertoireDuGenome]/msf" set File "$RepMSF/$Nom" if {![file exists $File]} {return} AskMSF $File unset if {[AskMSF $File $Nom] != ""} { set Query $Nom set LaSeqProtDeRef [split [string toupper [AskMSF $File $Query]] ""] } elseif {[AskMSF $File "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" set LaSeqProtDeRef [split [string toupper [AskMSF $File $Query]] ""] } else { return } ###Recensement de tous les domaines Interpro Pfam et features de cet Access#### set TousLesDomainesDeRef {} ####Uniquement les Access avec IdDesProtId % d'identite avec la query ou les proteines ####du cluster de msf si normmd est superieur a NormMDMin ou si il n'y a pas de clusters ####de MSF toutes les proteines du msf si le NormMD est superieur a NormMDMin foreach Access [LesAccessProchesDeLaProteineDeRef $Nom $IdDesProtId AvecCluster $NormMDMin] { if {[EstUnAccessPDB $Access]} {continue} set Seq [AskMSF $File $Access] if {$Seq == ""} {continue} set LaSeqProt [split [string toupper $Seq] ""] ###Determination des domaines INTERPRO, PFAM et fetatures de la proteine set LesDomaines [LesDomainesDeLAccess $Access AvecInterpro AvecPFAM AvecFeature] set Tab(Access,$Access,LesDomaines) $LesDomaines set Tab(Access,$Access,LaSeqProt) $LaSeqProt if {$LesDomaines == {}} {continue} ###Correspondance des domaines de l'access avec la sequence de la query foreach LeDomaine [lsort -unique -index 3 -real $LesDomaines] { set Type [lindex $LeDomaine 0] set Dom [lindex $LeDomaine 1] set Def [lindex $LeDomaine 2] set Debut [lindex $LeDomaine 3] set Fin [lindex $LeDomaine 4] set NAATot [expr $Fin - $Debut + 1] set NAAEnCommun 0 ################################################# ###IMPORTANT car dans feature un domaine peut avoir plusieurs domaines#### if {$Type == "FEATURE"} { set OldDom $Dom set Dom "$Dom $Def" regsub -all -nocase {[^a-z0-9 ]} $Dom "" Dom set Tab(Domaine,$Dom,VraiNomDeDomaine) $OldDom } set DebutDeRef "" set PosSurProt 0 set PosSurProtDeRef 0 set AiJeLeDebut 0 set AiJeLaFin 0 foreach AADeRef $LaSeqProtDeRef AA $LaSeqProt { if {$AADeRef != "."} {incr PosSurProtDeRef} if {$AA != "."} {incr PosSurProt} else {continue} if {$PosSurProt < $Debut } {continue} if {$Fin < $PosSurProt} {break } if {!$AiJeLeDebut} { if {$AADeRef != $AA} {continue} set DebutDeRef $PosSurProtDeRef set FinDeRef $PosSurProtDeRef set AiJeLeDebut 1 } if {$AiJeLeDebut && $AADeRef == $AA} { incr NAAEnCommun set FinDeRef $PosSurProtDeRef } } if {$DebutDeRef == "" || $FinDeRef == ""} {continue} if {[expr ($FinDeRef-$DebutDeRef+1) * 1.0 / ($Fin-$Debut+1)] < $ProportionMinDuDomaineDeLaQuery} {continue} if {![info exists Tab(Domaine,$Dom,LesCoordonnees)]} { lappend TousLesDomainesDeRef $Dom set Tab(Domaine,$Dom,Type) $Type set Tab(Domaine,$Dom,Def) $Def set Tab(Domaine,$Dom,LesCoordonnees) {} } if {![info exists Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess)]} { set Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess) {} } lappend Tab(Domaine,$Dom,$DebutDeRef,$FinDeRef,LesAccess) $Access lappend Tab(Domaine,$Dom,LesCoordonnees) [list $DebutDeRef $FinDeRef] } } set LesDomainesDeRef {} foreach DomDeRef $TousLesDomainesDeRef { set Def [set Tab(Domaine,$DomDeRef,Def)] set Type [set Tab(Domaine,$DomDeRef,Type)] ##Fusion de toutes les regions identiques et overlappantes determinees ci-dessus foreach LaRegionDeRef [LaFusionDesRegionsOverlappantes [set Tab(Domaine,$DomDeRef,LesCoordonnees)]] { set DebutDeRef [lindex $LaRegionDeRef 0] set FinDeRef [lindex $LaRegionDeRef 1] set LesAccess {} foreach UneR [set Tab(Domaine,$DomDeRef,LesCoordonnees)] { set D [lindex $UneR 0] set F [lindex $UneR 1] if {![CesRegionsSontEllesOverlappantes $DebutDeRef $FinDeRef $D $F]} {continue} foreach Access [set Tab(Domaine,$DomDeRef,$D,$F,LesAccess)] {lappend LesAccess $Access} } set NAATotDeRef [expr $FinDeRef - $DebutDeRef + 1] set NAAEnCommunMax 0 ##Calcul et determination du Pourcentage d'homologie le plus eleve avec ##les autres access possedant egalement ce domaine foreach Access $LesAccess { set LaSeqProt [set Tab(Access,$Access,LaSeqProt)] set NAAEnCommun 0 set PosSurProtDeRef 0 foreach AADeRef $LaSeqProtDeRef AA $LaSeqProt { if {$AADeRef != "."} {incr PosSurProtDeRef} else {continue} if {$PosSurProtDeRef < $DebutDeRef } {continue} if {$FinDeRef < $PosSurProtDeRef} {break } if {$AADeRef != $AA} {continue} incr NAAEnCommun } if {$NAAEnCommunMax < $NAAEnCommun} {set NAAEnCommunMax $NAAEnCommun} } if {$NAAEnCommunMax == 0} {continue} set Dom $DomDeRef ###Important on redonne le vrai nom du domaine aux features#### if {$Type == "FEATURE" && [info exists Tab(Domaine,$Dom,VraiNomDeDomaine)]} { set Dom [set Tab(Domaine,$Dom,VraiNomDeDomaine)] } set P [expr $NAAEnCommunMax * 1.0 / $NAATotDeRef] lappend LesDomainesDeRef [list $Nom $Type $Dom $Def $DebutDeRef $FinDeRef $P] } } if {$LesDomainesDeRef == {}} {return} return [lsort -index 4 -real [lsort -index 5 -real $LesDomainesDeRef]] } proc LesDomainesDiscriminantsDesARPs {{FichierMSF ""} {LesFichiersPos ""} {FichierOut ""}} { Wup "Permet de rendre les domaines discriminants et les positions relatives" #Utilisation du programme de Julie qui permet de transcrire les positions, dans un alignement par rapport a une #sequence de reference, en position equivalentes dans plusieurs autres sequences #Format d entree du fichier #1ere ligne Seq de ref (P02568) #2eme ligne les positions separees par des blancs (1 34 546 21 ...) #ligne suivante un nom de sequence par ligne #/home/julie/bin/aln_pos Actin_Complet3_1_Propre.rsf ARP8_signature set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/" set Aln_Pos "/home/julie/bin/aln_pos" if {$FichierMSF==""} { set FichierMSF "$ARPHomeDir/Actin_Complet3_8.rsf" } #Fichier contenant les positions importantes pour le binding au nucleotide (ATP/ATP) if {$FichierOut==""} { set FichierOut "$ARPHomeDir/Residue/LesARPs_signature.dom" } #Lecture du fichier contenant les positions a recherchees #set LesFichiersPos [glob -nocomplain -directory "$ARPHomeDir/Residue" "ARP*_signature"] if {$LesFichiersPos=="" || ! [file exists $LesFichiersPos]} { set LesFichiersPos [glob -nocomplain -directory "$ARPHomeDir/Residue" "ARP*_signature.dom"] } Espionne "$LesFichiersPos" foreach FichierPos $LesFichiersPos { if {[file size $FichierPos]=="0"} {continue} AppendAuFichier $FichierOut [file tail $FichierPos] set Reference "" set LesPos "" set i 0 set F [open "$FichierPos"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} incr i if {$i=="1"} { set Reference [lindex $Ligne 0] continue } if {$i=="2"} { set LesPos [split [string trim $Ligne] " "] break } } close $F set LaReference [join [linsert $LesPos 0 $Reference] "\t"] #Espionne "$LaReference" AppendAuFichier $FichierOut $LaReference set LesResidus "" set Result "" if {[catch {set LesResidus [exec $Aln_Pos $FichierMSF $FichierPos]} Message]} { Espionne "pb $Message" } else { foreach Result [split $LesResidus "\n"] { set Result [join [string trim $Result] "\t"] AppendAuFichier $FichierOut $Result } } } return "" } proc LesDomainesPfamDeLaProteine {AccessProt} { set LesDomaines {} foreach Ligne [split [PageInfo $AccessProt swisspfam] "\n"] { set Ligne [string trim $Ligne] if {$Ligne == "" || [regexp "^>" $Ligne]} {continue} regsub -all "\t" $Ligne " " Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] set Id [lindex $LaLigne 0 ] set LesCoords {} set LesElements [lrange $LaLigne 2 end] while {[regexp {([0-9]+)\-([0-9]+)} [lindex $LesElements end] tmp Debut Fin]} { lappend LesCoords [list $Debut $Fin] set LesElements [lrange $LesElements 0 end-1] } set LesElements2 {} foreach Element $LesElements { if {[regexp {^[-]+$} $Element]} {continue} lappend LesElements2 $Element } set Score [lindex $LesElements2 0] regexp {\(([0-9]+)\)} $Score tmp Score set Access [lindex $LesElements2 1 ] set Def [lrange $LesElements2 2 end] foreach LaCoord $LesCoords { set D [lindex $LaCoord 0] set F [lindex $LaCoord 1] lappend LesDomaines [list $Id $Access $Def $Score $D $F] } } return [lsort -index 4 -increasing -integer [lsort -index 5 -decreasing -integer $LesDomaines]] } proc LesDonneesPourNicolas {{FichierSave ""} {Dir ""}} { #B C R if {$FichierSave == ""} { #Choix du fichier de sauvegarde while {1} { set Texte "Choose a file name to save your selection" FaireLire "$Texte" set FichierSave [tk_getSaveFile -title "Choose a file name to save" -initialdir "[RepertoireDuGenome]"] if {$FichierSave == ""} { if {! [OuiOuNon "Would you like to continue ?"]} {return ""} } else { break } } } if {[file exists $FichierSave]} { if {! [OuiOuNon "$FichierSave already exists, would you like append to it ?"]} { file delete -force $FichierSave } } while {1} { if {$Dir==""} { FaireLire "Choose a directory containing all .gpr files" set Dir [tk_chooseDirectory -title "Choose a directory" -initialdir "[RepertoireDuGenome]"] } else {break} } set LesFichiers [glob -nocomplain "$Dir/*.gpr"] Espionne "$LesFichiers" set Fichier1 [lindex $LesFichiers 0] Espionne "$Fichier1" set NbBlock [InterrogeLeGPRFile $Fichier1 NbBlock] set NbColonne [InterrogeLeGPRFile $Fichier1 NbColumn] set NbRow [InterrogeLeGPRFile $Fichier1 NbRow] #Espionne "$NbBlock $NbColonne $NbRow" AppendAuFichier $FichierSave "[join [concat [list Block Column Row Name] $LesFichiers] "\t"]" set Ligne "" for {set b 1} {$b<=$NbBlock} {incr b} { for {set r 1} {$r<=$NbRow} {incr r} { for {set c 1} {$c<=$NbColonne} {incr c} { set Name [InterrogeLeGPRFile $Fichier1 $b $c $r Name] lappend Ligne $b lappend Ligne $c lappend Ligne $r lappend Ligne $Name foreach File $LesFichiers { #set Name [InterrogeLeGPRFile $File $b $c $r Name] set xF635Median "F635 Median" set F635Median [InterrogeLeGPRFile $File $b $c $r "$xF635Median"] if {$F635Median==""} {Espionne "Pb avec $File pour $xF635Median"} lappend Ligne $F635Median } #Espionne "B $b C $c R $r" #Espionne ">>> [join $Ligne "\t"]" AppendAuFichier $FichierSave "[join $Ligne "\t"]" set Ligne "" } } } return "" } proc LesECDeLAccess {Access} { set PageInfo [PageInfo $Access protein des] return [LesECDeLAccess_PageInfo $PageInfo] } proc LesECDeLAccess_PageInfo {PageInfo} { set LesEC {} foreach Ligne [split $PageInfo "\n"] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {![regexp "^DE " $Ligne]} {continue} while {[regexp -nocase {(EC [0-9\.]+)|(EC:[0-9\.]+)} $Ligne tmp EC]} { regsub "\.$" $EC "" EC lappend LesEC [string tolower $EC] regsub -nocase {EC [0-9\.\-]+|EC:[0-9\.\-]+} $Ligne "" Ligne } } return $LesEC } proc LesEPDouDBTSSSelectedPourPromAn {FileTFA {EPDouDBTSS EPD} {IdMin 0.3} {Expect 0.1} {NbSubject 100} {Filter F} {TSSPosition 10001} {nVar 0.05}} { #Attention DistProm est la distance prise pour construction des seq dans mrnatfa_$Orga_promoter = TSSPosition -1 #Selection == "Yes" si on veut selectionner les hits set LesSegmentsDesBIdToKeep {} set ResultType "PromoterAndTSS" if {![file exists $FileTFA]} {Espionne "$FileTFA does not exists" ; return } set FileBlast "$FileTFA.blastn$EPDouDBTSS" set FileBlastReduit "$FileBlast.red" AskBlast unset AskDBTSS unset AskEPDIdOrga unset ### 1-Recherche d'homologie entre la sequence TFA query et la DB EPD ou DBTSS par Blastn ### Espionne "$FileTFA -> blast against $EPDouDBTSS blast database" if {$EPDouDBTSS == "EPD"} { BlastEPD $FileTFA $FileBlast $Expect $NbSubject $Filter } else { BlastDBTSS $FileTFA $FileBlast $Expect $NbSubject $Filter } if {![file exists $FileBlast]} {Espionne "File blast $EPDouDBTSS does not exists" ; return } ### 2-Selection des segments des subjects selon un seuil d'identite min ### set NbSubject [AskBlast $FileBlast NbSubject] if {$NbSubject == ""} {Espionne "File blast $EPDouDBTSS is not valid" ; return } #Determination du nb max de bases des subjects alignees avec la query set nMax 0 set LesRegions {} #On parcoure chaque subject du blast for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FileBlast Subject $i ] set NbSegment [AskBlast $FileBlast BanqueId $BId NbSegment] set Taille [AskBlast $FileBlast BanqueId $BId Taille ] set TabSegmentToKeep($BId,LesSegments) {} #On parcoure chaque segment du subject for {set j 1} {$j <= $NbSegment} {incr j} { set Identities [AskBlast $FileBlast BanqueId $BId Segment $j Identities] if {$Identities == ""} {continue} set n 0 scan $Identities "%d/%d" n nTot set TailleS [AskBlast $FileBlast BanqueId $BId Taille] #Nb de bases du subject alignees avec la query sur la taille du subject set Identity [expr $n * 1.0 / $TailleS] if {$Identity < $IdMin} {continue} ### 3- Determination du sens ### set Sens [SensDeLaRegion [AskBlast $FileBlast BanqueId $BId Segment $j Orientation]] set Identity [format "%.2f" [expr $Identity * 100]] set DQ [Mini [AskBlast $FileBlast BanqueId $BId Segment $j DQ] [AskBlast $FileBlast BanqueId $BId Segment $j FQ]] set DS [Mini [AskBlast $FileBlast BanqueId $BId Segment $j DS] [AskBlast $FileBlast BanqueId $BId Segment $j FS]] set FS [Maxi [AskBlast $FileBlast BanqueId $BId Segment $j DS] [AskBlast $FileBlast BanqueId $BId Segment $j FS]] ### 4- Selection des TSS de EPD les plus proches des TSS potentiels initiaux ### # -10000__________________exon1(x)_________________+10000 Seq promotrice potentielle (<-protocole Freddy) # | | | # | * | *= TSS potentiel # | | # 0___________________________________________20000+x Seq promotrice potentielle # | | # | | # | | # -499_______________+100 EPD sequence # | | | # | ** | **= EPD TSS # | | # 0___________________________________________20000+x Seq promotrice potentielle # | | # 9501 10100 # # ==> Localisation EPD seq sur seq promotrice potentielle proche de [9501-10100] #Les seq EPD ou DBTSS sont -499/+100 par rapport au TSS, leur taille est de 600 pb #Dc la position du TSS sur la query d'apres le EPD hit est de:[expr $DQ + 499 - $DS +1] if {$Sens == "+"} { set F 1 set SubjectBorne $DS } else { set F -1 set SubjectBorne $FS } if {$EPDouDBTSS == "EPD"} { set AmontTSS 499 } else {set AmontTSS 1000} set TSSQ [expr $DQ + $F * ($AmontTSS -$SubjectBorne +1)] #Calcul distance entre TSS ini potentiel et TSS suggere par DBTSS #Si DistProm est de 10000, la position du TSS est de 10000+1 set TSSDist [expr -1 * ($TSSPosition - $TSSQ)] lappend LesRegions [list $BId $j $Identity $Sens $TSSQ $TSSDist $n ] lappend TabSegmentToKeep(BId,$BId,LesSegments) $j if {$n > $nMax} {set nMax $n} } } ### Classe EPD ou DBTSS hits par identite decroissantes puis par valeur absolue des dist entre TSS pot ini et TSS EPD ou DBTSS croissantes ### 4- Selection des subjects ayant le max de bases alignees avec la query (n) +/- 5%(nVar) ### #Determination des IdEPD ou DBTSS ayant le max de bases alignees avec la query set Tab(LesBId) {} set LesInfos {} set LesRegions [lsort -index 5 -real -increasing -command CompareLaVADesNombres [lsort -index 2 -real -decreasing $LesRegions]] foreach LaRegion $LesRegions { set BId [lindex $LaRegion 0 ] set j [lindex $LaRegion 1 ] set n [lindex $LaRegion 6 ] if {![info exists Tab($BId,LesSegments)]} { set Tab($BId,LesSegments) {} lappend Tab(LesBId) $BId } lappend Tab($BId,LesSegments) $j set Sens [SensDeLaRegion [AskBlast $FileBlast BanqueId $BId Segment $j Orientation]] set DQ [Mini [AskBlast $FileBlast BanqueId $BId Segment $j DQ] [AskBlast $FileBlast BanqueId $BId Segment $j FQ]] set FQ [Maxi [AskBlast $FileBlast BanqueId $BId Segment $j DQ] [AskBlast $FileBlast BanqueId $BId Segment $j FQ]] set Id [lindex $LaRegion 2] set Sens [lindex $LaRegion 3] set TSSQ [lindex $LaRegion 4] set TSSDist [lindex $LaRegion 5] if {$EPDouDBTSS == "EPD"} { set Orga [AskEPDIdOrga EPDId $BId EPDOrganism] } else { set Orga [AskDBTSS $BId Organism] } lappend LesInfos [list $EPDouDBTSS $ResultType $DQ $FQ $Sens $TSSQ $TSSDist $Id $BId $Orga] } foreach BId [set Tab(LesBId)] { lappend LesSegmentsDesBIdToKeep [concat [list $BId] [set TabSegmentToKeep($BId,LesSegments)]] } ### 5-Reduit le blast initial aux segments des subjects ayant une identite superieure au seuil ### FichierBlastReduit $FileBlast $FileBlastReduit LesSegmentsDesBIdToKeep $LesSegmentsDesBIdToKeep AskBlast unset AskDBTSS unset AskEPDIdOrga unset return $LesInfos } proc LesEVIsDuGN {GN} { #voir aussi ds gscope_retchip de RR GscopeIdsOfGeneName {Gn} global LesEVIsDuGN set GN [string toupper $GN] if {[info exists LesEVIsDuGN($GN)]} { return $LesEVIsDuGN($GN) } if {[info exists LesEVIsDuGN("EstCharge")]} { return {} } set LesEVIsDuGN("EstCharge") 1 foreach Nom [ListeDesPABs] { set g [ExtraitInfo $Nom "ValiGN"] if {$g==""} { continue } set G [string toupper $g] lappend LesEVIsDuGN($G) $Nom lappend LesEVIsDuGN(LISTEDESGNS) $g lappend LesEVIsDuGN(LISTEDESGNS) $G } set LesEVIsDuGN(LISTEDESGNS) [lsort -unique $LesEVIsDuGN(LISTEDESGNS)] return [LesEVIsDuGN $GN] } proc LesEffectifsDesCouplesDeMots {LesPhrases} { set LesCouples {} set i 0 foreach Phrase $LesPhrases { incr i set MotPrecedent "" set LesCouplesDeLaPhrases {} foreach Mot [split $Phrase " "] { if {$MotPrecedent == ""} {set MotPrecedent $Mot;continue} if {![info exists TabTmp($MotPrecedent,$Mot,n)]} { lappend LesCouples [list $MotPrecedent $Mot] set TabTmp($MotPrecedent,$Mot,n) 0 set TabTmp($MotPrecedent,$Mot,nMax) 0 } if {![info exists TabTmp($i,$MotPrecedent,$Mot,n)]} { set TabTmp($i,$MotPrecedent,$Mot,n) 0 lappend LesCouplesDeLaPhrases [list $MotPrecedent $Mot] } incr TabTmp($MotPrecedent,$Mot,nMax) incr TabTmp($i,$MotPrecedent,$Mot,n) set MotPrecedent $Mot } foreach LeCouple $LesCouplesDeLaPhrases { set Mot1 [lindex $LeCouple 0] set Mot2 [lindex $LeCouple 1] set n [set TabTmp($i,$Mot1,$Mot2,n)] set nMax [set TabTmp($Mot1,$Mot2,n)] if {$nMax < $n} {set TabTmp($Mot1,$Mot2,n) $n} } } set LesCouplesEtLeurEffectif {} foreach LeCouple $LesCouples { set Mot1 [lindex $LeCouple 0] set Mot2 [lindex $LeCouple 1] lappend LesCouplesEtLeurEffectif [list $Mot1 $Mot2 [set TabTmp($Mot1,$Mot2,n)] [set TabTmp($Mot1,$Mot2,nMax)]] } return [lsort -integer -index 3 -decreasing $LesCouplesEtLeurEffectif] } proc LesEffectifsDesDistances {{TailleDesPalliers 10}} { global RepertoireDuGenome set FileDistances "$RepertoireDuGenome/xhda/TousLesBilans_PourNuca.dst" if {![file exists $FileDistances]} {return ""} set LesDistances {} foreach Ligne [LesLignesDuFichier $FileDistances] { foreach Distance [split $Ligne " "] { if {$Distance == 0 || $Distance == ""} {continue} set DistanceArrondie [expr round($Distance/$TailleDesPalliers) * $TailleDesPalliers] if {![info exists TabDist($DistanceArrondie)]} { set TabDist($DistanceArrondie) 1 lappend LesDistances $DistanceArrondie } else { incr TabDist($DistanceArrondie) } } } set LesEffectifs {} foreach Distance [lsort -integer $LesDistances] { set Effectif "$Distance\t[set TabDist($Distance)]" lappend LesEffectifs $Effectif } unset TabDist set LesEffectifs [join $LesEffectifs "\n"] return $LesEffectifs } proc LesEffectifsDesMots {LesPhrases} { set LesMots {} set i 0 foreach Phrase $LesPhrases { incr i set LesMotsDeLaPhrase {} foreach Mot [split $Phrase " "] { if {![info exists TabTmp($Mot,n)]} { lappend LesMots $Mot set TabTmp($Mot,n) 0 set TabTmp($Mot,nMax) 0 } if {![info exists TabTmp($i,$Mot,n)]} { set TabTmp($i,$Mot,n) 0 lappend LesMotsDeLaPhrase $Mot } incr TabTmp($Mot,nMax) incr TabTmp($i,$Mot,n) } foreach Mot $LesMotsDeLaPhrase { set n [set TabTmp($i,$Mot,n)] set nMax [set TabTmp($Mot,n)] if {$nMax < $n} {set TabTmp($Mot,n) $n} } } set LesMotsEtLeurEffectif {} foreach Mot $LesMots { lappend LesMotsEtLeurEffectif [list $Mot [set TabTmp($Mot,n)] [set TabTmp($Mot,nMax)]] } return [lsort -integer -index 2 -decreasing $LesMotsEtLeurEffectif] } proc LesElementsSousLaLocalisationDuGenome {FichierMapViewer {ChromosomeOuContig Chromosome} ChromOuCont Debut Fin} { if {[string equal -nocase $ChromosomeOuContig "Contig"]} { set LesInfos [CoordonneesSurChromosome $ChromOuCont [Mini $Debut $Fin] [Maxi $Debut $Fin] "+"] if {$LesInfos == ""} {return} set ChromOuCont [lindex $LesInfos 0] set Debut [lindex $LesInfos 1] set Fin [lindex $LesInfos 2] } set nChromo [NumeroDuChromosome $ChromOuCont] set LesElements {} foreach Element [InterrogeFichierMapViewer $FichierMapViewer Chromosome $nChromo LesElements] { foreach LaLocalisation [InterrogeFichierMapViewer $FichierMapViewer Chromosome $nChromo Element $Element LesLocalisations] { set DebElt [lindex $LaLocalisation 3] set FinElt [lindex $LaLocalisation 4] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $DebElt $FinElt]} {continue} lappend LesElements $LaLocalisation } } return $LesElements } proc LesElusDuBlastPAuChoixPourTous {{Source ""}} { foreach Nom [ListeDesPABs] { set LesElus [LesElusDuBlastPAuChoix $Nom $Source] Espionne $LesElus } } proc LesElusDuBlastPParAuChoix {Nom {Source ""} {Show ""}} { JeMeSignale set Nom [file tail $Nom] set MaxNbElus 200 if {$Show==""} { set Show "DontShow" } if {$Show=="Show"} { set Show 1 } else { set Show 0 } set LesElus [AuChoixDuBlast $Nom "GetList"] if {$Show} { set Fen [AfficheUneSortieBlast $Nom] set LesBIds {} foreach Elu $LesElus { scan $Elu "%s" BId lappend LesBIds $BId } IllumineLaListe $LesBIds $Fen # FaireSavoir "On passe au suivant de $Nom" # destroy $Fen # global KduGraphe ; destroy [winfo parent $KduGraphe] # set Show [OuiOuNon "Do I continue to show the selected accesses ?"] } return $LesElus } proc LesElusDuBlastPParBandelettes {Nom {Source ""} {Show ""} {SeuilExpect ""} {LoinToujours ""}} { #rR On peut forcer a prendre les eloignes. (je ne sais plus pourquoi ...) if {$LoinToujours!=""} { if {[regexp -nocase "NotUsed" $LoinToujours]} { LoinToujours "NotUsed" } else { LoinToujours $LoinToujours "Set" } } if {$SeuilExpect==""} { set SeuilExpect 0.001 } set NomOrigine $Nom set Nom [file tail $Nom] set NombreMiniDeProches 20 set MaxNbElus 200 if {[OnTraiteMS2PH]} { set MaxNbElus 9999 set NombreMiniDeProches 1 } if {$Show==""} { set Show "DontShow" } if {$Show=="Show"} { set Show 1 } else { set Show 0 } set NomOuFichier $Nom if { ! [EstUnPAB $Nom]} { set NomOuFichier $NomOrigine } set LesLBsEtLeursCandidats [LesBandelettesDuBlast $NomOuFichier $Source] set LesElus {} set TousLesProches {} # set DejaBascule 1 set NbElus 0 foreach {LB SesCandidats} $LesLBsEtLeursCandidats { catch {unset PremierSW} catch {unset PremierTout} catch {unset PremierPDB} foreach Candidat $SesCandidats { scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX if {[EstUnAccessPDB $BId]} { if { ! [info exists PremierPDB]} { set PremierPDB $BId } continue } if {[EstUnAccessSwissprot $BId]} { if { ! [info exists PremierSW]} { set PremierSW $BId } } if { ! [info exists PremierTout]} { set PremierTout $BId } } set Capital "" if { [info exists PremierSW]} { set Capital $PremierSW } elseif { [info exists PremierTout]} { set Capital $PremierTout } elseif { [info exists PremierPDB]} { set Capital $PremierPDB } set NProchesPrisPourCetteBandelette 0 foreach Candidat $SesCandidats { set OX "" scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX lappend LesProches "$BId $Access $PN $OX" # Espionne "$BId $PN" set BonAPrendre [expr [LoinToujours $PN] || [EstUnAccessPDB $BId] || $PN<=$SeuilExpect && [string equal $BId $Capital]] # Espionne "$BId $PN $BonAPrendre [EstUnAccessPDB $BId] " if {$BonAPrendre} { lappend LesElus "$BId $Access $PN $OX" set NbElus [llength $LesElus] if {$NbElus > $MaxNbElus} { break } } if {$PN<=$SeuilExpect} { lappend TousLesProches "$BId $Access $PN $OX" } else { if { ! [info exists DejaBascule] && [llength $LesElus]<$NombreMiniDeProches} { set DejaBascule 1 lappend TousLesProches "$BId $Access $PN $OX" set LesElus $TousLesProches } } } if {$NbElus > $MaxNbElus} { break } } if {$Show} { set Fen [AfficheUneSortieBlast $Nom] set LesBIds {} foreach Elu $LesElus { scan $Elu "%s" BId lappend LesBIds $BId } IllumineLaListe $LesBIds $Fen # FaireSavoir "On passe au suivant de $Nom" # destroy $Fen # global KduGraphe ; destroy [winfo parent $KduGraphe] # set Show [OuiOuNon "Do I continue to show the selected accesses ?"] } return $LesElus } proc LesElusDuBlastPParBandelettesPourTous {{Source ""}} { foreach Nom [ListeDesPABs] { set LesElus [LesElusDuBlastPParBandelettes $Nom $Source] Espionne $LesElus } } proc LesElusDuBlastPParMounir {Nom {Source ""} {Show ""}} { JeMeSignale set Nom [file tail $Nom] set MaxNbElus 200 if {$Show==""} { set Show "DontShow" } if {$Show=="Show"} { set Show 1 } else { set Show 0 } set LesElus [MounirDuBlast $Nom "GetList"] if {$Show} { set Fen [AfficheUneSortieBlast $Nom] set LesBIds {} foreach Elu $LesElus { scan $Elu "%s" BId lappend LesBIds $BId } IllumineLaListe $LesBIds $Fen # FaireSavoir "On passe au suivant de $Nom" # destroy $Fen # global KduGraphe ; destroy [winfo parent $KduGraphe] # set Show [OuiOuNon "Do I continue to show the selected accesses ?"] } return $LesElus } proc LesElusDuBlastPParMounirPourTous {{Source ""}} { foreach Nom [ListeDesPABs] { set LesElus [LesElusDuBlastPParMounir $Nom $Source] Espionne $LesElus } } proc LesEmbranchementsGO {Type GO} { global nEmbranchements TabLesEmbranchementsGO Tab $Type $GO if {![info exists nEmbranchements]} {return {}} set LesEmbranchementsOntologiques {} for {set i 1} {$i <= $nEmbranchements} {incr i} {lappend LesEmbranchementsOntologiques [set Tab($i,LEmbranchement)]} if {[info exists Tab ]} {unset Tab } if {[info exists nEmbranchements]} {unset nEmbranchements} return $LesEmbranchementsOntologiques } proc LesEmbranchementsOntologiques {Type GO} { global nEmbranchements TabLesEmbranchementsOntologiques Tab $Type $GO if {![info exists nEmbranchements]} {return {}} set LesEmbranchementsOntologiques {} for {set i 1} {$i <= $nEmbranchements} {incr i} {lappend LesEmbranchementsOntologiques [set Tab($i,LEmbranchement)]} if {[info exists Tab ]} {unset Tab } if {[info exists nEmbranchements]} {unset nEmbranchements} return $LesEmbranchementsOntologiques } proc LesEndroitsDesDiff {la lb} { if {[llength $la] > [llength $lb]} { set a $la ; set b $lb } else { set a $lb ; set b $la } set lr {} set i 0 ; set j 0 ; set n 0 set decal 0 while {$i < [llength $a]} { set e [lindex $a $i] set f [lindex $b $j] if {$e == $f} { incr i ; incr j if {$decal} { lappend lr [list $r $n] } set n 0 set decal 0 } else { if {! $decal} { if {$i == 0} { set r "" } else { set r [lindex $a [expr {$i-1}]] } } set decal 1 incr i incr n } } if {$decal} { lappend lr [list $r $n] } return $lr } proc LesEntetesChevronneesDuBlast {Page {GetWhat ""} {Titre ""}} { if { ! [regexp "\n" $Page]} { set Fichier $Page if {[EstUnPAB $Fichier]} { if {[FileAbsent $Fichier]} { set Fichier [GscopeFile $Fichier "blastp"] } if {[FileAbsent $Fichier]} { set Fichier [GscopeFile $Fichier "blastn"] } } if {[FileAbsent $Fichier]} { return "" } set Page [ContenuDuFichier $Fichier] } if {$GetWhat==""} { set GetWhat "GetHeaders" } set OnAttendChevron 1 set OnAttendFinEntete 0 set OnAFiniLePremier 0 foreach Ligne [split $Page "\n"] { if {$OnAttendChevron && [regexp {^>} $Ligne]} { set Entete $Ligne set OnAttendChevron 0 set OnAttendFinEntete 1 continue } if {$OnAttendFinEntete} { if {[regexp {^ {10}Length =} $Ligne]} { set OnAttendFinEntete 0 set OnAttendChevron 1 regsub -all { +} $Entete " " Entete set OnAFiniLePremier 0 } else { append Entete " $Ligne" } continue } if { ! $OnAFiniLePremier && [regexp {^ Score = } $Ligne]} { set Expect [PNApres "Expect = " dans $Ligne] lappend LesScoreExpect $Ligne } if { ! $OnAFiniLePremier && [regexp {^ Identities = } $Ligne]} { lappend LesIdentities $Ligne lappend LesEntetes "[string trim $Entete] Expect=$Expect" set OnAFiniLePremier 1 } } if {$GetWhat=="GetHeaders"} { return $LesEntetes } if {$GetWhat=="GetScoreExpect"} { return $LesScoreExpect } if {$GetWhat=="GetIdentities"} { return $LesIdentities } if {$GetWhat=="GetAll"} { return [list $LesEntetes $LesScoreExpect $LesIdentities]} if {$Titre==""} { set Titre "Headers" } return [AfficheVariable [join $LesEntetes "\n"] "AvecFetch" $Titre] } proc LesEponineSelectedPourPromAn {FileContigTFA {TSSPosition 10001}} { AskEponine unset set LesInfos {} set ResultType "PromoterAndTSS" set FileOUT "$FileContigTFA.Eponine" Eponine $FileContigTFA $FileOUT foreach Eponine [AskEponine $FileOUT LesEponines] { set Debut [AskEponine $FileOUT n $Eponine D] set Fin [AskEponine $FileOUT n $Eponine F] set Sens [AskEponine $FileOUT n $Eponine Sens] set TSSLoc $Debut set TSSDist [expr -1 * ($TSSPosition - $Debut) ] set Identity [AskEponine $FileOUT n $Eponine Score] lappend LesInfos [list "Eponine" $ResultType $Debut $Fin $Sens $TSSLoc $TSSDist $Identity "Eponine" ""] } AskEponine unset return [lsort -index 6 -real -command CompareLaVADesNombres $LesInfos] } proc LesEtatsDesVEs {} { return [list Cloned Expression_tested Soluble Insoluble Purified Crystallization Crystal Structure Stopped] } proc LesExpsRetinobase {} { CanalSqlBioArrayBase set Ligne "pk_experiment;description;publication;authors;abstract;pubmedid;shortdescription;name;sample_preparation" lappend LesLignes $Ligne foreach {PkEx Des Pub Au Ab Pu SDes Name SaPre} [SqlExec "select pk_experiment,description,publication,authors,abstract,pubmedid,shortdescription,name,sample_preparation from retinobase3.experiment order by pk_experiment;" "GetList"] { set Ligne "$PkEx;$Des;$Pub;$Au;$Ab;$Pu;$SDes;$Name;$SaPre" lappend LesLignes $Ligne } CanalSqlDisconnect Espionne $LesLignes SauveLesLignes $LesLignes dans "/home/poidevin/ordi/Transcriptomique/LesExpsRetinobase.csv" } proc LesFamillesDARPs {} { Wup "Permet de retourner les noms des familles d ARPs" Wup "On aurai pu utiliser InterrogeLesInfosDesARPs" set RepARP "[RepARPAnno]" set RepBanque "$RepARP/ARP_BLAST" #On recupere les differentes banques BLAST des ARPs set LesB "" set LesBanques_tmp [glob -nocomplain -directory "$RepBanque/" "*.tfa"] foreach Banque $LesBanques_tmp { set Banque [file tail $Banque] regsub -all {.[a-z]{2,3}$} $Banque "" Banque lappend LesB $Banque } #On les ordonne correctement ARP1 a ARP10 set Last "" set LesBanques "" set OnActin 0 foreach B $LesB { if { [regexp -nocase "ARP10" $B]} { set Last $B continue } elseif {[regexp -nocase "ARP11" $B]} { set RealLast $B continue } elseif {[regexp -nocase "actin" $B]} { set OnActin 1 set LesBanques [linsert $LesBanques 0 $B] } elseif {[regexp -nocase "orphans" $B]} { if {$OnActin} { set LesBanques [linsert $LesBanques 1 $B] } else { set LesBanques [linsert $LesBanques 0 $B] } } else { lappend LesBanques $B } } if {$Last != ""} {lappend LesBanques $Last} if {$RealLast != ""} {lappend LesBanques $RealLast} return $LesBanques } proc LesFantomes {} { foreach Nom [ListeDesPABs] { if { ! [Fantome $Nom]} { continue } Espionne "$Nom [ExtraitInfo $Nom Fantome]" lappend LesFantomes $Nom } return $LesFantomes } proc LesFantomesEnFrameshift {} { foreach Nom [ListeDesPABs] { if { ! [Fantome $Nom]} { continue } if { ! [regexp "FS ok" [ExtraitInfo $Nom "EP:"]]} { continue } Informe $Nom } exit } proc LesFastas {{User ""}} { set MesProjets [LesProjetsDe "$User"] foreach Projet $MesProjets { set Existe($Projet) 1 } foreach Rep [glob /genomics/g*/*] { if { ! [file readable $Rep]} {continue} set MesFastas [glob -nocomplain $Rep/*.fasta] if {$MesFastas=={}} { continue } if {[llength $MesFastas] < 1 } { Espionne $MesFastas } set Fasta [lindex $MesFastas 0] set RepDuG [file tail [file dirname $Fasta]] if {![info exists Existe($RepDuG)]} { continue } lappend LesFastas $Fasta } return $LesFastas } proc LesFeaturesDeLAccess {Access} { return [LesFeaturesDeLAccess_PageInfo [PageInfo $Access protein]] } proc LesFeaturesDeLAccess_PageInfo {PageInfo} { if {$PageInfo == ""} {return} set Feature "" set LesFeatures {} foreach Ligne [split $PageInfo "\n"] { if {$Ligne == ""} {continue} if {![regexp {^FT } $Ligne]} {continue} set LigneNew $Ligne while {[regexp " " $LigneNew]} {regsub -all " " $LigneNew " " LigneNew} regsub {\.$} $LigneNew "" LigneNew set LaLigne [split $LigneNew " "] if {[regexp {^FT } $Ligne]} { append Feature "[join [lrange $LaLigne 1 end] " "]" continue } if {$Feature != "" && [info exists Debut] && [info exists Fin]} { if {![regexp {[^0-9<>]} $Debut] && ![regexp {[^0-9<>]} $Fin]} { regsub -all "<|>" $Debut "" Debut regsub -all "<|>" $Fin "" Fin lappend LesFeatures [list FEATURE $Type [string trim $Feature] $Debut $Fin] } } set Type [lindex $LaLigne 1] set Debut [lindex $LaLigne 2] set Fin [lindex $LaLigne 3] set Feature [string trim [join [lrange $LaLigne 4 end] " "]] if {$Feature == ""} {set Feature " "} } if {$Feature != "" && [info exists Debut] && [info exists Fin]} { if {![regexp {[^0-9]} $Debut] && ![regexp {[^0-9]} $Fin]} { lappend LesFeatures [list FEATURE $Type [string trim $Feature] $Debut $Fin] } } return $LesFeatures } proc LesFeaturesUtilisees {f e} { global LFeatCourantes if {! [info exists LFeatCourantes]} { set LFeatCourantes [LesBoutonsEnfonces] } if {$e} { set LFeatCourantes [linsert $LFeatCourantes 0 $f] } else { set i [lsearch $LFeatCourantes $f] set LFeatCourantes [lreplace $LFeatCourantes $i $i] } set LFeatCourantes [lunique $LFeatCourantes] return $LFeatCourantes } proc LesFeuillesDuSousArbre {t n} { set nf 0 foreach c [$t children -all $n] { incr nf [$t isleaf $c] } return $nf } proc LesFichiers2GO {} { return [glob -nocomplain "[GODBDir]/*2go"] } proc LesFichiersBlastNsDeRefSeq_Design {} { Wup "Design de RefSeq complet, environ 19200" Wup "Pour faire les blastn et les masked tous d un seul coup" set DataBase "/blast/rshuman.nsq" set Dir "[RepertoireDuGenome]/Probes/RefSeq_TFA" set LesQuerys [glob -nocomplain -directory $Dir "NM*"] foreach Query $LesQuerys { set Dir "[RepertoireDuGenome]/Probes/RefSeq_Design" set NMDIR [LeRepertoireDeRefSeq [file tail $Query]] set Dir "${Dir}/${NMDIR}" if {[file exists "${Dir}/[file tail $Query].blastn"]} { Espionne "${Dir}/${NMDIR}/[file tail $Query].blastn existe deja" continue } LesParametresDuDesign Query $Query "Positionne" LesParametresDuDesign DataBase $DataBase "Positionne" LesParametresDuDesign WorkingDir $Dir "Positionne" LesParametresParDefaut Oligo_BlastN_PourTous } return "" } proc LesFichiersDe {Rep {RegExp ""}} { if {$RegExp==""} { set RegExp "*" } regsub -all "@" $RegExp "*" RegExp if { ! [regexp "^/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" } return [glob -nocomplain "$Rep/$RegExp"] } proc LesFichiersDeBalibase {} { set baldir /maison/moumou/Balibase3-luc/bb3_release set Ldir [glob -type d $baldir/RV*] set Lout [list] foreach dir $Ldir { set Lf [glob $dir/*.xml] foreach f $Lf { if {! [regexp {\_luc|BBS[0-9]} $f]} { lappend Lout $f } } } return $Lout } proc LesFichiersDeType {{Type ""} {Rep ""} {GetAll ""}} { if {$GetAll=="GetAll"} { set GetAll 1 } else { set GetAll 0 } # set TypeBeton(Oligo) 1 set TypeBeton(Signaux) 1 set TypeBeton(pDONR) 1 set TypeBeton(pDEST) 1 set SpecifDesTypes(All) "" set SpecifDesTypes(Fusion) "" set SpecifDesTypes(Rec2) "" set SpecifDesTypes(Rec1) "" set SpecifDesTypes(Ppcr) "" set SpecifDesTypes(Oligo) ".tfa" set SpecifDesTypes(Header) "header*" set SpecifDesTypes(Signaux) "signaux" set SpecifDesTypes(Matrice) "" set SpecifDesTypes(Construction) "*.tfa" set SpecifDesTypes(pDONR) "p*.tfa" set SpecifDesTypes(pDEST) "p*.tfa" set RepertoireDesTypes(All) "./" set RepertoireDesTypes(Fusion) "[RepertoireDuGenome]/fusion" set RepertoireDesTypes(Rec2) "[RepertoireDuGenome]/rec2" set RepertoireDesTypes(Rec1) "[RepertoireDuGenome]/rec1" set RepertoireDesTypes(Ppcr) "[RepertoireDuGenome]/ppcr_virtuels" set RepertoireDesTypes(Oligo) "[RepertoireDuGenome]/oligos" set RepertoireDesTypes(Header) "[GscopeEtc]" set RepertoireDesTypes(Signaux) "[RepertoireDuGenome]/signaux" set RepertoireDesTypes(Matrice) "[RepertoireDuGenome]/matrices" set RepertoireDesTypes(Construction) "[RepertoireDuGenome]/constructions" set RepertoireDesTypes(pDONR) "[RepertoireDuGenome]/vecteurs/pDONR" set RepertoireDesTypes(pDEST) "[RepertoireDuGenome]/vecteurs/pDEST" if {[info exists SpecifDesTypes($Type)]} { set Specif [set SpecifDesTypes($Type)] } else { set Specif $Type } if {$Rep==""} { if {[info exists RepertoireDesTypes($Type)]} { set Rep [set RepertoireDesTypes($Type)] } else { set Rep $Type } } set LesPossibles {} if { ! [info exists TypeBeton($Type)] && $SpecifDesTypes($Type)!=""} { set Ici [pwd] set LesLocaux [glob -nocomplain -type {f l} "$Ici/*$Specif*"] set LesLocaux2 [glob -nocomplain -type {f l} "$Ici/*/*$Specif*"] LConcat LesPossibles $LesLocaux LConcat LesPossibles $LesLocaux2 } set LesCommuns [glob -nocomplain -type {f l} "$Rep/*$Specif*"] set LesCommuns2 [glob -nocomplain -type {f l} "$Rep/*/*$Specif*"] LConcat LesPossibles $LesCommuns LConcat LesPossibles $LesCommuns2 set LesPossiblesTmp [lsort -unique $LesPossibles] set LesPossibles {} foreach Possi $LesPossiblesTmp { if {[regexp "~$" $Possi]} { continue } lappend LesPossibles $Possi } if {$GetAll} { return $LesPossibles } set LesBons {} while {1} { set TexteType $Type if {$Type=="All"} { set TexteType "file" } set LesBons [MorceauxChoisisAndMore $LesPossibles $LesBons "Please select a $TexteType in the left window and press '--->'\n Reorder with 'Up' and 'Down' if necessary.\n Press 'More' if you want to add your own file."] if {$LesBons=={} && [OuiOuNon "Do You want an empty list ?"]} { return {} } if {$LesBons=={} && [OuiOuNon "Do You want to select your own files ?"] || [lindex $LesBons end]=="MorePlease"} { set Perso [ButineArborescence "All" "."] if {$Perso!=""} { lappend LesPossibles $Perso } continue } elseif {[lindex $LesBons end]=="Selection"} { FaireLire "Enter a regular expression to select some of these files" set ExpReg [Entre "YOURTEXT"] set LesNouveauxPossibles {} foreach Possi $LesPossibles { if { ! [regexp $ExpReg $Possi]} { continue } lappend LesNouveauxPossibles $Possi } set LesPossibles $LesNouveauxPossibles continue } else { break } } set LesBonsBons {} foreach Bon $LesBons { set Mot "" scan $Bon "%s" Mot if {$Mot==""} { continue } lappend LesBonsBons $Mot } return $LesBonsBons } proc LesFichiersGO {} { set LesFichiersGO {} foreach Type [LesTypesGO] {lappend LesFichiersGO "[GODBDir]/$Type.ontology"} return $LesFichiersGO } proc LesFichiersMasquesDeRefSeq_Design {} { Wup "Design de RefSeq complet, environ 19200" Wup "Pour faire les masked tous d un seul coup" set DataBase "/blast/rshuman.nsq" set Dir "[RepertoireDuGenome]/Probes/RefSeq_TFA" set Query [glob -nocomplain -directory $Dir "NM*"] foreach Query $LesQuerys { set Dir "[RepertoireDuGenome]/Probes/RefSeq_Design" set NMDIR [LeRepertoireDeRefSeq [file tail $Query]] set Dir "${Dir}/${NMDIR}" LesParametresDuDesign Query $Query "Positionne" LesParametresDuDesign WorkingDir $Dir "Positionne" LesParametresParDefaut LesFichiersMasques_PourTous } return "" } proc LesFichiersMasques_Launcher {{args ""}} { Wup "Pour faire les masked tous d un seul coup" if {$args==""} { AjouteAuLog "CADO4MI usage is query, database, length, range, nboligo and optional parameters" AjouteAuLog [format "%-21s %-12s" " -q (Query)" "Your query sequence in fasta format."] AjouteAuLog [format "%-21s %-12s" " -w (WorkingDir)" "Choose the directory where to save your files"] AjouteAuLog "\nYou need to define at least Query, and WorkingDir" return "" } foreach {Option Valeur} $args { #AjouteAuLog "O $Option V $Valeur" switch -regexp -- $Option { "-q$" {LesParametresDuDesign Query $Valeur "Positionne"} "-w$" {LesParametresDuDesign WorkingDir $Valeur "Positionne"} } } LesFichiersMasques_PourTous return "" } proc LesFichiersMasques_PourTous {} { Wup "Procedure qui lance le Masking pour tous" set Repnuctfa "[RepertoireDuGenome]/nuctfa" set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set OK 1 foreach Parametre [list Query WorkingDir] { set $Parametre [LesParametresDuDesign $Parametre "LaValeurMerci"] if {[set $Parametre]==""} {set OK 0;break} } if {$OK!="1"} { AjouteAuLog "Missing parameters.\nMasking all sequences, require 2 parameters query and working directory." return "" } if {$Query=="LaTotale"} {set Query [ListeDesPABs]} if {[llength $Query]=="1"} { set Return [CheckTFAFile $Query] if {$Return!=""} { LesParametresDuDesign Query "Reset" LesParametresDuDesign Query "$Return" "Positionne" } set Query [LesParametresDuDesign Query "LaValeurMerci"] } set Query [split $Query " "] foreach PAB $Query { if {$PAB!="" && [file exists "$PAB"]} { set FichierQuery "$PAB" } elseif {[file exists "$RepmRNA/$PAB"]} { set FichierQuery "$RepmRNA/$PAB" } elseif {[file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } else { AjouteAuLog "No File for the Query ($PAB)" continue } if {[regexp {/} "$PAB"]} {set PAB [file tail $PAB]} #Rq: On a plus le vrai chemin du fichier original set FichierEnCours "$WorkingDir/${PAB}.encours" set FichierMasque "$WorkingDir/${PAB}.masked" set FichierBlast "$WorkingDir/${PAB}.blastn" set FichierLog "$WorkingDir/${PAB}.log" set FichierOligo "$WorkingDir/${PAB}.oligo" set FichierSelection "$WorkingDir/${PAB}.selection" if {[file exists $FichierEnCours]} { AjouteAuLog "$PAB in work" continue } elseif {[file exists $FichierLog] || [file exists $FichierOligo]} { continue } else {Sauve "" dans $FichierEnCours} AjouteAuLog ">>>In charge of $PAB<<<" #On filtre la sequence pour le poly A ##################################### if {![file exists $FichierMasque]} { AjouteAuLog "Masking $PAB" set FichierMasque [PrepareMaSequenceALaRechercheDHomologie $FichierQuery $WorkingDir] } else { AjouteAuLog "Masking already done" } file delete -force $FichierEnCours AjouteAuLog "<><>\n" } return "" } proc LesFichiersQuiCommencentPar {Texte {Rep ""} {Extension ""}} { if {$Rep!="" && [regexp "/$" $Rep]} { append Rep "/" } set LesBons {} foreach Fichier [glob -nocomplain "${Rep}*$Extension"] { if {[regexp -nocase -- "^$Texte" [file tail $Fichier]]} { lappend LesBons $Fichier } } return "$LesBons" } proc LesFichiersUnAUnDuTFAs {Fichier {Rep ""} {Systeme ""}} { if {$Rep==""} { set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]/.."] } if {$Systeme=="" && [OuiOuNon "Do You want to use one of my specific naming system ?"]} { set Systeme [ChoixParmi [list "TmpFile" "Use_access" "Use_access_but_remove_signals" "Ask_for_each"]] } foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] { set TFA [LaSequenceDuTFAs $Fichier $Access] set FicTFA [NommageAuto $Access $Systeme $Rep] set FicTFACree [Sauve $TFA dans $FicTFA] lappend LesFicTFACrees $FicTFACree } return $LesFicTFACrees } proc LesFilsDe {n} { foreach f $::T($n,child) { lappend ::Lfils [LesFilsDe $f] } return $::Lfils } proc LesFirstEFSelectedPourPromAn {FileContigTFA {TSSPosition 10001}} { AskFirstEF unset set LesInfos {} set ResultType "GeneStructure" set FileOUT "$FileContigTFA.FirstEF" FirstEF $FileContigTFA $FileOUT foreach Sens [AskFirstEF $FileOUT LesSens] { foreach Prediction [AskFirstEF $FileOUT Sens $Sens LesPredictions] { foreach Rang [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction LesRangs] { set DProm [Mini [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DPromoter] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FPromoter]] set FProm [Maxi [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DPromoter] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FPromoter]] set DExon [Mini [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DExon] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FExon]] set FExon [Maxi [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DExon] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FExon]] if {$Sens == "+"} { set D $DProm set F $FExon set TSSLoc $DExon } else { set D $DExon set F $FProm set TSSLoc $FExon } set TSSDist [expr -1 * ($TSSPosition -$TSSLoc)] lappend LesInfos [list "FirstEF" $ResultType $D $F $Sens $TSSLoc $TSSDist "" "FirstEF" ""] set DCpG [Mini [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DCpG] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FCpG]] set FCpG [Maxi [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang DCpG] [AskFirstEF $FileOUT Sens $Sens Prediction $Prediction Rang $Rang FCpG]] if {$DCpG == "" || $FCpG == ""} {continue} lappend LesInfos [list "FirstEFCpG" $ResultType $DCpG $FCpG $Sens $TSSLoc $TSSDist "" "CpG" ""] } } } AskFirstEF unset return [lsort -index 6 -real -command CompareLaVADesNombres $LesInfos] } proc LesFrames {} { return [ChoixDesPresents [LesProceduresExistantes]] } proc LesFullBidir {{Organism human} {Database GeCo} {LongueurMoyennePromoteurBidir 2000} {BirdVersion bird}} { # Recupere les gènes bidirectionnels comme suit : # - tous les genes #Et verifie ceux séparés de 1000pb CanalSqlUcscHuman set nbPureGene 0 #---------------------------------------------------------------# set timestamp [clock format [clock seconds] -format "%H:%M:%S"] puts -nonewline "$timestamp|LesFullBidir : Loading GeCo " #---------------------------------------------------------------# flush stdout set nbFullBidir 0 set nbTrueBidir 0 foreach {access chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames name mRNA spID spDisplayID geneSymbol refseq protAcc description typegene pseudogene span spanloc confidence reference} [SqlExec "SELECT access, chrom, strand, txStart, txEnd, cdsStart, cdsEnd, exonCount, exonStarts, exonEnds, id, name2, cdsStartStat, cdsEndStat, exonFrames, name, mRNA, spID, spDisplayID, geneSymbol, refseq, protAcc, description, typegene, pseudogene, span, spanloc, confidence, reference FROM ucsc$Organism.$Database WHERE pseudogene='no' ORDER BY chrom, txStart, txEnd" -flatlist] { incr numGene incr nbPureGene lappend listeDesBin $nbPureGene lappend listeDesStarts $txStart lappend listeDesEnds $txEnd #Espionne "$nbPureGene $txStart" set TableauGene($nbPureGene,access) $access set TableauGene($nbPureGene,chrom) $chrom set TableauGene($nbPureGene,txStart) $txStart set TableauGene($nbPureGene,txEnd) $txEnd set TableauGene($nbPureGene,strand) $strand set TableauGene($nbPureGene,cdsStart) $cdsStart set TableauGene($nbPureGene,cdsEnd) $cdsEnd set TableauGene($nbPureGene,exonCount) $exonCount set TableauGene($nbPureGene,exonStarts) $exonStarts set TableauGene($nbPureGene,exonEnds) $exonEnds set TableauGene($nbPureGene,id) $id set TableauGene($nbPureGene,name2) $name2 set TableauGene($nbPureGene,cdsStartStat $cdsStartStat set TableauGene($nbPureGene,cdsEndStat) $cdsEndStat set TableauGene($nbPureGene,exonFrames) $exonFrames set TableauGene($nbPureGene,name) $name set TableauGene($nbPureGene,mRNA) $mRNA set TableauGene($nbPureGene,spID) $spID set TableauGene($nbPureGene,spDisplayID) $spDisplayID set TableauGene($nbPureGene,geneSymbol) $geneSymbol set TableauGene($nbPureGene,refseq) $refseq set TableauGene($nbPureGene,protAcc) $protAcc set TableauGene($nbPureGene,description) $description set TableauGene($nbPureGene,typegene) $typegene set TableauGene($nbPureGene,pseudogene) $pseudogene set TableauGene($nbPureGene,span) $span set TableauGene($nbPureGene,spanloc) $spanloc set TableauGene($nbPureGene,confidence) $confidence set TableauGene($nbPureGene,reference) $reference } #---------------------------------------------------------------# set timestamp [clock format [clock seconds] -format "%H:%M:%S"] puts "( $nbPureGene genes loaded ) " #---------------------------------------------------------------# set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|LesFullBidir : Selecting on distance criterion ($LongueurMoyennePromoteurBidir bp) " #---------------------------------------------------------------# flush stdout for {set I 1} {$I < $nbPureGene} {incr I} { set currentEnd $TableauGene($I,txEnd) set next [expr $I + 1] set nextStart $TableauGene($next,txStart) set distance [expr $nextStart - $currentEnd] Espionne "$I $distance $currentEnd $nextStart" if {[expr abs($distance)] <= $LongueurMoyennePromoteurBidir} { incr nbFullBidir Espionne "Total: $nbFullBidir" if { $TableauGene($I,strand) == "-" && $TableauGene($next,strand) == "+" } { incr nbTrueBidir Espionne "Vrais : $nbTrueBidir" } } } Espionne "Il y a $nbFullBidir dont $nbTrueBidir vrais" } proc LesGN {FichierAccess FichierSortie} { foreach Ligne [LesLignesDuFichier $FichierAccess] { if {$Ligne==""} {continue} set Access $Ligne lappend LesAccess $Access } set LesAccess [split $LesAccess " "] set LesAccess [join $LesAccess "\|"] set Commande "getz \"\\\[protein-acc:$LesAccess\\\]\" \-vf gen" set GetzOut [eval exec $Commande] AppendAuFichier $FichierSortie $GetzOut } proc LesGNsDeLaFicheEMBL {AcOuId} { package require textutil set fiche [BirdEntry $AcOuId] if {$fiche eq ""} {error "$AcOuId: Fiche non trouvée."} if {[llength $fiche] > 1} {error "$AcOuId: Plusieurs fiches trouvées."} set fiche [lindex $fiche 0] set ligneGN "" foreach ligne [split $fiche "\n"] { if {[string range $ligne 0 1] eq "GN"} { append ligneGN " [string trim [string range $ligne 2 end]]" } } set lesGNs {} foreach {regMatch GN} [regexp -all -inline {Name=([^;]+);} $ligneGN] {lappend lesGNs $GN} foreach {regMatch Synonyms} [regexp -all -inline {Synonyms=([^;]+);} $ligneGN] { set lesGNs [concat $lesGNs [::textutil::splitx $Synonyms {,\s*}]] } return $lesGNs } proc LesGOAvecCeKeyword {Keyword {ExactlyOrContained Exactly}} { if {[string equal -nocase $ExactlyOrContained "Exactly"]} {set Exact 1} else {set Exact 0} set LesGO {} foreach Type [GODB LesTypes] { foreach GO [GODB Type $Type LesGO] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] foreach Definition [GODB Type $Type GO $GO LesDefinitions] { if {[info exists TabTmp($GO)]} {continue} if {$Exact && [string equal -nocase $Keyword $Definition]} { lappend LesGO $GO set TabTmp($GO) 1 } if {!$Exact && [regexp -nocase $Keyword $Definition]} { lappend LesGO $GO set TabTmp($GO) 1 } } } } foreach Requete [2GO LesRequetes] { if {($Exact && [string equal -nocase $Keyword $Requete]) || (!$Exact && [regexp -nocase $Keyword $Requete])} { foreach GO [2GO $Requete LesLiens] { foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {[info exists TabTmp($GO)]} {continue} lappend LesGO $GO set TabTmp($GO) 1 } } } } return [lsort -unique $LesGO] } proc LesGODeRefDesGO {LesGO} { set LesGODeRef {} foreach GO $LesGO { set GO [string toupper $GO] if {[info exists TabTmp]} {unset TabTmp} foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {[info exists TabTmp($GO)]} {continue} set TabTmp($GO) 1 lappend LesGODeRef $GO } } return $LesGODeRef } proc LesGOsDuFichierXML {Fichier} { set T [ContenuDuFichier $Fichier] while 1 { set SL [ValeurDeLaBalise "start_list" T] while 1 { set GO [ValeurDeLaBalise "text" SL] if {$GO==""} { break } if {[info exists DejaVu($GO)]} { continue } set DejaVu($GO) 1 lappend LesGOs $GO } if {$SL==""} { break } } return $LesGOs } proc LesGbManquants {} { foreach I [RetChip ListOf Index] { set GB [RetChip $I "DNA_acc"] if {$GB == ""} { continue } if { [regexp -nocase {^[A-Z]+[0-9]+$} $GB] } { set GBSt [GbEnStock $GB] if {$GBSt != ""} {continue} else { puts "la ligne $I a un GB=$GB qu'on ne trouve pas" } } } } proc LesGenScanSelectedPourPromAn {FileContigTFA {TSSPosition 10001}} { set LesInfos {} set FileOUT "$FileContigTFA.GenScan" GenScanExec $FileContigTFA $FileOUT set ResultType "GeneStructure" foreach Protein [lsort [DecortiqueGenScan All All Numbers [ContenuDuFichier $FileOUT]]] { foreach Exon [lsort [DecortiqueGenScan $Protein All Numbers]] { set Debut [DecortiqueGenScan $Protein $Exon Begin ] set Fin [DecortiqueGenScan $Protein $Exon End ] set Sens [DecortiqueGenScan $Protein $Exon Sens ] if {$Sens == "+"} { set TSSLoc [DecortiqueGenScan $Protein All Gauche] } else {set TSSLoc [DecortiqueGenScan $Protein All Droite]} set TSSDist [expr -1 * ($TSSPosition - $TSSLoc) ] set Identity [DecortiqueGenScan $Protein $Exon Proba ] set Id $Protein.$Exon set Organism "" set Nature [DecortiqueGenScan $Protein $Exon Nature] lappend LesInfos [list "GenScan" $ResultType $Debut $Fin $Sens $TSSLoc $TSSDist $Identity $Id $Organism $Nature] } } return [lsort -index 6 -real -command CompareLaVADesNombres $LesInfos] } proc LesGeneName {Nom FileMSF FileClust {IdDesProtId 0.98} {NorMDMin 0.5}} { if {![file exists $FileMSF]} {return} if {[AskMSF $FileMSF $Nom] != ""} { set Query $Nom } elseif {[AskMSF $FileMSF "QUERY_PROTEIN"] != ""} { set Query "QUERY_PROTEIN" } else { return [list [list $Nom Nothing]] } set LesAccess [LesProteinesProchesDeLaProteineDeRef $Query $FileMSF $FileClust $IdDesProtId "AvecCluster" $NorMDMin] AskLesPagesInfos load $LesAccess protein set LeTexte {} foreach Access $LesAccess { if {[EstUnAccessPDB $Access]} {continue} set Page [AskLesPagesInfos ask $Access] if {$Page == "" } {continue} if {$Access == $Query } {continue} set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] foreach GeneName [LesGeneNameDeLAccess_PageInfo $Page] { foreach Orga $LesOrgas { lappend LeTexte [list $Nom $Access $Orga $GeneName] } } } AskLesPagesInfos unset if {$LeTexte == {}} {return [list [list $Nom Nothing]]} return $LeTexte } proc LesGeneNameDeLAccess {Access} { return [LesGeneNameDeLAccess_PageInfo [PageInfo $Access protein gen]] } proc LesGeneNameDeLAccess_PageInfo {PageInfo} { set LesGeneName {} set GdeLigne "" foreach Ligne [split $PageInfo "\n"] { if {![regexp -nocase {^GN } $Ligne tmp]} {continue} regsub {^GN[ ]+} $Ligne "" Ligne append GdeLigne [string trim $Ligne] } regsub -all {[ ]*;[ ]*} $GdeLigne ";" GdeLigne regsub -all {[ ]*,[ ]*} $GdeLigne "," GdeLigne regsub -all {/|\\} $GdeLigne "," GdeLigne foreach Type [split $GdeLigne ";"] { if {![regexp {^Name=|^Synonyms=} $Type tmp]} {continue} regsub $tmp $Type "" Type foreach GN [split $Type ","] { set GN [string toupper [string trim $GN]] if {$GN == "" || [regexp {[0-9]+RIK$|^[A-Z]+:|^KIAA|^DKFZ} $GN]} {continue} lappend LesGeneName $GN } } return $LesGeneName } proc LesGenomesComplets {} { global RepertoireDuGenome global LesGenomesComplets global Glossaire if {[info exists LesGenomesComplets]} { return $LesGenomesComplets } set FichierLesGenomesComplets "[RepertoireDuGenome]/fiches/lesgenomescomplets" if {[file exists $FichierLesGenomesComplets]} { set LesGenomesComplets {} foreach Ligne [LesLignesDuFichier $FichierLesGenomesComplets] { set Genre "" set Espece "" scan $Ligne "%s %s" Genre Espece if {$Espece==""} { continue } lappend LesGenomesComplets "$Genre $Espece" } return $LesGenomesComplets } if { ! [file exists "[RepertoireDuGenome]/fiches"]} { file mkdir "[RepertoireDuGenome]/fiches" } catch { if {[file type $FichierLesGenomesComplets]=="link"} { file delete -force $FichierLesGenomesComplets } } set FichierLesGenomesCompletsDefaut "[GscopeEtc]/gscope_lesgenomescomplets" if {[file exists $FichierLesGenomesCompletsDefaut]} { if { 1 || [OuiOuNon "I need the file with all complete genomes.\n Can I copy $FichierLesGenomesCompletsDefaut ?"]} { if { [catch {file copy $FichierLesGenomesCompletsDefaut $FichierLesGenomesComplets}]} { return {} } return [LesGenomesComplets] } } FaireLire "I need the file of all complete genomes\n I will ask You to select a file\n OR\n You can copy or link it from an other directory to\n $FichierLesGenomesComplets\n (You can do it before Acknowledge)" if { ! [file exists $FichierLesGenomesComplets]} { set Ailleurs [ButineArborescence "All" "$RepertoireDuGenome/../lesgenomescomplets"] if {$Ailleurs!=""} { if {[OuiOuNon "Ok to copy\n $Ailleurs\nto\n $FichierLesGenomesComplets\n?"]} { File copy $Ailleurs $FichierLesGenomesComplets } else { if {[OuiOuNon "Do I exit ?"]} { exit } } } } return [LesGenomesComplets] } proc LesGenomesCompletsAuFormat {{Format Court}} { foreach Organisme [LesGenomesComplets] { lappend LesGCF [Glossaire $Organisme $Format] } return $LesGCF } proc LesGenomesCompletsBizarres {{Quoi ""}} { if {$Quoi==""} { set Quoi [ChoixParmi [list "Bizarres" "Nouveaux" "Inconnus"]] if {$Quoi==""} { return {} } } set LesBizarres {} set LesNouveaux {} set LesInconnus {} foreach O [LesGenomesComplets] { set G [Glossaire $O Complet] if {$G==$O} { continue } set T [Tax $O "Name"] if {$T==$O} { lappend LesBizarres "New organism : $O" lappend LesNouveaux $O } if {$T=="" || [regexp -nocase "Error" $T] } { lappend LesBizarres "Wrong organism : $O" lappend LesInconnus $O } } if {$Quoi=="Bizarres"} { return $LesBizarres } if {$Quoi=="Nouveaux"} { return $LesNouveaux } if {$Quoi=="Inconnus"} { return $LesInconnus } return $LesBizarres } proc LesGenomesCompletsPossibles {{Format Court}} { Wup "Is obsolete" return [LesGenomesCompletsAuFormat $Format] } proc LesGenomesCompletsPourGlossaire {} { global Glossaire Wup "To run faster for the most used orgs" foreach G [LesGenomesComplets] { regsub " " $G "_" G set Court [Glossaire $G Court] set Glossaire($Court,Court) $Court set Glossaire($Court,Complet) [Glossaire $G Complet] set Glossaire($Court,COMPLET) [Glossaire $G COMPLET] set Glossaire($Court,Demi) [Glossaire $G Demi] set Glossaire($Court,Tout) [Glossaire $G Tout] } } proc LesGenomesDansLeBonOrdre {{Ordre BAE} {QueVeutOn ""}} { global LesGenomesDansLeBonOrdre if {$Ordre=="OC"} { set QueVeutOn $Ordre ; set Ordre "BAE" } Wup "If QueVeutOn is OC it returns the OCs list. (Works only for BAE, not for Original)" if {$QueVeutOn=="" && [info exists LesGenomesDansLeBonOrdre($Ordre)]} { return [set LesGenomesDansLeBonOrdre($Ordre)] } if { $QueVeutOn!=""} { if { ! [info exists LesGenomesDansLeBonOrdre($Ordre,$QueVeutOn)]} { LesGenomesDansLeBonOrdre $Ordre } return [set LesGenomesDansLeBonOrdre($Ordre,$QueVeutOn)] } set LesGenomes [LesGenomesComplets] if {$Ordre=="Original"} { set LesGenomesDansLeBonOrdre($Ordre) $LesGenomes return $LesGenomes } if {$Ordre=="Alpha"} { return [lsort $LesGenomes] } foreach Genome $LesGenomes { set OS [Glossaire $Genome Complet] if {[info exists DejaVu($OS)]} { FaireLire "$OS\n is the organism of the genome $Genome\n but\n is also the organism of the genome [set GenomeDuOS($OS)] It can be a source of problems ..." } set DejaVu($OS) 1 set OC [PhylumDuGenome $OS OC] set OSduGenome($Genome) $OS set OCduGenome($Genome) $OC set GenomeDuOS($OS) $Genome set OCaTrier $OC if {$Ordre=="BAE"} { regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier } if {$Ordre=="FamiliarBAE"} { regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier if {[FamiliarOrganism $OS]} { set OCaTrier "0_$OCaTrier" } } if {$Ordre=="SampledBAE"} { regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier if {[SampledOrganism $OS]} { set OCaTrier "0_$OCaTrier" } } lappend LesOSOCs [list $OCaTrier $OS] } set LesOSOCsTries [lsort -index 0 $LesOSOCs] foreach LeOCOS $LesOSOCsTries { ScanLaListe $LeOCOS OCaTrier OS set Genome [set GenomeDuOS($OS)] lappend LesGenomesTries $Genome lappend LesOCDesGenomesTries [set OCduGenome($Genome)] } set LesGenomesDansLeBonOrdre($Ordre) $LesGenomesTries set LesGenomesDansLeBonOrdre($Ordre,OC) $LesOCDesGenomesTries return $LesGenomesTries } proc LesGenomesEukaryotes {} { global RepertoireDuGenome set File "$RepertoireDuGenome/fiches/lesgenomeseukaryotes" if {![file exists $File]} {FichierGenomesEukaryotes} return [LesLignesDuFichier $File] } proc LesGenomesParListe {} { global NotreOS set LGComplets [LesGenomesComplets] set LGCourts [LesGenomesCompletsAuFormat Court] set LesNoms {} foreach UnGLong $LGComplets UnGCourt $LGCourts { if { $UnGLong != $NotreOS } { lappend LesNoms "$UnGCourt $UnGLong" } } return $LesNoms } proc LesGiSsProt {} { set FichierSortieNcbi "/genomics/link/Tau/Dec2008/GSTRdCVF/sortie_ncbi.txt" foreach Ligne [LesLignesDuFichier $FichierSortieNcbi] { if {[regexp {^gi\|} $Ligne ]} { lappend LesGINcbi [lindex [split $Ligne "|"] 1] } } foreach GIInitial [InterrogeListTau ListOf GI] { set trouve 0 foreach GINcbi $LesGINcbi { if {$GIInitial==$GINcbi} { set trouve 1 break } } if {!$trouve} {Espionne "$GIInitial"} } } proc LesGrandesRegionsDeLaQueryDuBlast {FichierBlast {ExpectMax 1e200} {NbSubjectMax 1e200} {IdMin 0.0} {SplitWithGap Yes} {LesBanqueId ""}} { foreach BId $LesBanqueId {set TabSelect($BId) 1} set NbSubject [AskBlast $FichierBlast NbSubject ] set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == "" || $NbSubject == ""} {return} set k 0 set LesGrandesRegions {} for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlast Subject $i] if {$LesBanqueId != "" && ![info exists TabSelect($BId)]} {continue} set Expect [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect] if {$Expect == ""} {continue} incr k if {$NbSubjectMax < $k } {break} if {$ExpectMax < $Expect} {continue} set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} { set Expect [AskBlast $FichierBlast BanqueId $BId Segment $j Expect] if {$ExpectMax < $Expect} {continue} if {0 < $IdMin} { set Identities [AskBlast $FichierBlast BanqueId $BId Segment $j Identities] scan $Identities "%d/%d" nmRNA nmRNATot set Id [expr $nmRNA*1.0/$nmRNATot] if {$Id < $IdMin} {continue} } set DQ [Mini [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] set FQ [Maxi [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] if {$SplitWithGap == "Yes"} { if {$FQ < $DQ} {set FactSensQ -1 } else {set FactSensQ 1 } set AlignLineaire [AskBlast $FichierBlast BanqueId $BId Segment $j AlignLineaire] set LAlignLineaire [split $AlignLineaire "\n"] set Query [lindex $LAlignLineaire 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex $LAlignLineaire 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] if {[info exists Debut]} {unset Debut} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {0 && $AQ == "$BaseFiltree"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } set PosIni [expr $PosIni + 1 * $FactSensQ] continue } if {$AS == "-" || $AS == "*" || $AQ == "*"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } set PosIni [expr $PosIni + 1 * $FactSensQ] continue } if {$AQ == "-"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } continue } if {![info exist Debut]} {set Debut $PosIni} set Fin [expr $PosIni ] set PosIni [expr $PosIni + 1 * $FactSensQ] } if {[info exists Debut]} {lappend LesGrandesRegions [list $Debut $Fin];unset Debut} } else { lappend LesGrandesRegions [list $DQ $FQ] } } } return $LesGrandesRegions } proc LesGrandesRegionsDuBlast {aTabBlast {LesBanqueId All} {SeuilId None} {SplitWithGap Yes}} { upvar $aTabBlast TabBlast if {![info exists TabBlast(NbSubject)]} {return {}} set TypeDeBlast [set TabBlast(TypeDeBlast)] if {$TypeDeBlast == "BLASTN"} {set BaseFiltree "N"} else {set BaseFiltree "X"} set LesGrandesRegions {} if {![info exists TabBlast(NbSubject)]} {return {}} set NbSubject [set TabBlast(NbSubject)] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set TabBlast($i)] if {$LesBanqueId != "All"} { set EnEstCeUn 0 foreach BIdDeRef $LesBanqueId {if {$BIdDeRef == $BId} {set EnEstCeUn 1;break}} if {!$EnEstCeUn} {continue} } set NbSegment [set TabBlast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { if {$SeuilId != "None"} { set Identities [set TabBlast($BId,$j,Identities)] scan $Identities "%d/%d" nmRNA nmRNATot set Id [expr $nmRNA*1.0/$nmRNATot] if {$Id < $SeuilId} {continue} } set DQ [Mini [set TabBlast($BId,$j,DQ)] [set TabBlast($BId,$j,FQ)]] set FQ [Maxi [set TabBlast($BId,$j,DQ)] [set TabBlast($BId,$j,FQ)]] if {$SplitWithGap == "Yes"} { if {$FQ < $DQ} {set FactSensQ -1 } else {set FactSensQ 1 } set Query [lindex [split [set TabBlast($BId,$j,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$j,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] if {[info exists Debut]} {unset Debut} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {0 && $AQ == "$BaseFiltree"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } set PosIni [expr $PosIni + 1 * $FactSensQ] continue } if {$AS == "-" || $AS == "*" || $AQ == "*"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } set PosIni [expr $PosIni + 1 * $FactSensQ] continue } if {$AQ == "-"} { if {[info exists Debut]} { lappend LesGrandesRegions [list $Debut $Fin] unset Debut } continue } if {![info exist Debut]} {set Debut $PosIni} set Fin [expr $PosIni ] set PosIni [expr $PosIni + 1 * $FactSensQ] } if {[info exists Debut]} {lappend LesGrandesRegions [list $Debut $Fin];unset Debut} } else { lappend LesGrandesRegions [list $DQ $FQ] } } } return $LesGrandesRegions } proc LesGraphesDeLOligo {K} { Wup "Retourn les tag des graphes disponibles Tm, GC ..." set LesGraphes "" set LesId [$K find withtag "OligoGraph"] foreach Id $LesId { set MesTags "" set index "" set MesTags [$K gettags $Id] set index [lsearch $MesTags "OligoGraph"] lappend LesGraphes [lindex $MesTags [expr $index+1]] } set LesGraphes [lsort -unique $LesGraphes] return $LesGraphes } proc LesGrosManquants {} { foreach Nom [ListeDesPABs] { set FichierMsf "[RepertoireDuGenome]/msf/$Nom" set FichierLeo "[RepertoireDuGenome]/msfLeon/$Nom" set FichierRsf "[RepertoireDuGenome]/macsimRsf/$Nom" set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom" if {[file exists $FichierRsf]} { continue } if { ! [file exists $FichierMsf]} { continue } Espionne "$Nom [file exists $FichierLeo] [file exists $FichierRsf] [file size $FichierMsf]" } exit } proc LesGroup {FileMacsims} { set FileMacsims [TheTrueMacsimsFile $FileMacsims] set fh [open $FileMacsims "r"] dom parse -channel $fh doc close $fh $doc documentElement root foreach seq [$root selectNodes "//sequence"] { set Name [$seq selectNodes "string(./seq-name)"] set Group [$seq selectNodes "string(./seq-info/group)"] Espionne "$Name $Group" } } proc LesGscopecodesAffymetrix {Fichier} { set n 0 set LesGscopeCodes "" foreach Ligne [LesLignesDuFichier $Fichier] { #Espionne $Ligne scan $Ligne "%s" c foreach PAB [ListeDesPABs] { set CodeClone [CodeClone $PAB] if {$c != $CodeClone} { continue } else { #Espionne $PAB incr n lappend LesGscopeCodes "$PAB\n" } } } Espionne "n=$n" return $LesGscopeCodes } proc LesGscopecodesAffymetrixFoldExpr {Fichier} { set n 0 set LesGscopeCodes "" foreach Ligne [LesLignesDuFichier $Fichier] { #Espionne $Ligne scan $Ligne "%s %s" c e foreach PAB [ListeDesPABs] { set CodeClone [CodeClone $PAB] if {$c != $CodeClone} { continue } else { #Espionne $PAB incr n lappend LesGscopeCodes "$PAB\t$e" } } } Espionne "n=$n" return $LesGscopeCodes } proc LesHeadersDeLaBanqueBlast {B {Hr nhr}} { global RepertoireDuGenome Wup "Searches for the correct bank and returns the list of header from the .nhr file" set Loc "$RepertoireDuGenome/banques" set Glo "/catalog/blast" foreach BHr [list "$B.$Hr" "$Loc/$B.$Hr" "$Glo/$B.$Hr" "NotFound"] { if {[file exists $BHr]} { break } } if {$BHr=="NotFound"} { return {} } set Headers [ContenuDuFichier $BHr] regsub -all {(gnl\|BL_ORD_ID\|[0-9]+ +|lcl\|)} $Headers "\n" Headers return [split [string trim $Headers "\n"] "\n"] } proc LesHitsAvecDelta {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} { if {$UseExpect==""} { set UseExpect "UseExpect" } set UseExp [string equal -nocase "UseExpect" $UseExpect] if {$SelectMethod==""} { set SelectMethod "FirstOnly" } if {$GetWhat==""} { set GetWhat "Show" } if {$Seuil==""} { set Seuil 99999 } if {[regexp -nocase "Best" $SelectMethod]} { set SelectMethode "BestOnly" } if {[regexp -nocase "First" $SelectMethod]} { set SelectMethode "FirstOnly" } if {[regexp -nocase "Ave" $SelectMethod]} { set SelectMethode "AboveAverage" } if {$LesOrganismesInteressants=={}} { return {} } set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]] if {$LesOrgaTrie=={}} { return {} } set LesChoisis {} set PremierTaxId "" foreach Ligne $LesOrgaTrie { #rR je rappelle que taxobla ne contient qu'une fois chaque organisme lassign [split $Ligne "\t"] Expect Score TaxId OS Reste if {$Expect==0.0} { set Expect 1.0e-250 } # if {$Expect >1.0} { set Expect 1.0 } set TaxId [string trim $TaxId] set OS [string trim $OS] set Reste [string trim $Reste] if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue } if {$PremierTaxId==""} { set PremierTaxId $TaxId } set Expect [string trim $Expect] set Score [string trim $Score] if {$Expect > $Seuil} { break } lappend LesExpects $Expect lappend LesScores $Score lappend LesChoisis "$Expect\t$Score\t$TaxId\t$OS\t$Reste" } if {$LesChoisis=={}} { return "" } if {$UseExp} { set LesValeurs $LesExpects set LesValeurs [FromList $LesValeurs Iterate log10] ;#rR passage en log } else { set LesValeurs $LesScores } lassign [FromList $LesValeurs] MoyenneBidon EcartType Min Max Somme NbValeurs set Moyenne [expr $Somme/[llength $LesOrganismesInteressants]] set LaSortie {} foreach Choisi $LesChoisis { lassign [split $Choisi "\t"] Expect Score TaxId if {$UseExp} { set Valeur $Expect set Valeur [expr log10($Valeur)] ;#rR passage en log } else { set Valeur $Score } set Delta [expr $Valeur-$Moyenne] set HitAvecDelta "$Delta\t$Choisi" if {$SelectMethod=="FirstOnly" && $TaxId!=$PremierTaxId} { continue } ;#rR la on choisit de ne garder que le meilleur dans l'ordre du blast if {$UseExp} { if {$SelectMethod=="BestOnly" && $Delta > -10} { continue } if {$SelectMethod=="AboveAverage" && $Delta > 0} { continue } } else { if {$SelectMethod=="BestOnly" && $Delta > 100} { continue } if {$SelectMethod=="AboveAverage" && $Delta > 0} { continue } } lappend LaSortie $HitAvecDelta } if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} { set FichierDeltas $GetWhat if {[string equal -nocase "Save" $GetWhat]} { set FichierDeltas [GscopeFile $Nom delta] } return [SauveLesLignes $LaSortie dans $FichierDeltas] } if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie } if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] } return [AfficheListe $LaSortie] } proc LesHitsDe {Nom} { set SeuilExpect 10. set MaxListe 10 set FichierBlast "[RepertoireDuGenome]/blastp/$Nom" if { ! [file exists $FichierBlast]} { return {} } set lAccess {} DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN return $lAccess } proc LesHitsDuBallast {FichierBallast} { if {![file exists $FichierBallast]} { Espionne "$FichierBallast does not exist" return "" } set F [open $FichierBallast] set SuisJeSurLesHits 0 set LesHits {} while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} if {[regexp -nocase "^Sequences producing High-scoring Segment Pairs" $Ligne]} { set SuisJeSurLesHits 1 continue } if {[regexp "^>" $Ligne]} {set SuisJeSurLesHits 0;break} if {!$SuisJeSurLesHits || [regexp "^\-" $Ligne]} {continue} set SuisJeUneReference 0 if {![regexp "^ " $Ligne]} {set SuisJeUneReference 1} set Ligne [string trim $Ligne] regsub -all "\t" $Ligne " " Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] set Id [string toupper [lindex $LaLigne 0]] set IdCourt $Id regsub {^[^\:]+\:} $Id "" IdCourt if {[EstUnAccessPDB $Id]} {set Access $IdCourt} else {set Access [string toupper [lindex $LaLigne 1]]} if {$SuisJeUneReference} {set Expect [lindex $LaLigne end]} set LesLMS [AskLMS $FichierBallast Access $IdCourt LesLMS] if {$LesLMS != ""} { lappend LesHits [concat [list $IdCourt $Access $Expect] $LesLMS] continue } set LesLMS [AskLMS $FichierBallast Access $Access LesLMS] if {$LesLMS != ""} { lappend LesHits [concat [list $Access $Access $Expect] $LesLMS] continue } lappend LesHits [list $Access $Access $Expect] } close $F return $LesHits } proc LesHitsDuBlast {Fichier {SeuilExpect 0.001} {MaxListe 99999} {Quoi ""}} { DecortiqueBlast $Fichier $SeuilExpect $MaxListe Query lBId lA lDE lProfil lPN set Retour {} set LesBId {} set LesA {} foreach BId $lBId A $lA DE $lDE PN $lPN { lappend LesBId $BId lappend LesA $A lappend Retour [format "%-75s %s" "$BId $A $DE" $PN] } if {[regexp "I" $Quoi]} { return $LesBId } if {[regexp "A" $Quoi]} { return $LesA } return $Retour exit } proc LesHitsDuBlast_FC {FichierBlast {ExpectDeRef 1e200} {NbSubject 1e200}} { set nHits 0 set SuisSurLesHit 0 set i 0 set LignesDesHits {} set F [open $FichierBlast] while {[gets $F Ligne]>=0} { if {[regexp -nocase "Sequences producing significant alignments" $Ligne]} { set SuisSurLesHit 1 continue } if {$SuisSurLesHit} { if {[string equal -nocase "\\\\End of List" $Ligne] } {set SuisSurLesHit 0;break} if {[string first ">" $Ligne] == 0} {set SuisSurLesHit 0;break} } if {!$SuisSurLesHit || ![regexp -nocase {[0-9a-z]} $Ligne]} {continue} lappend LignesDesHits $Ligne } close $F set LignesDesHits [join $LignesDesHits "\n"] regsub -all "\n!" $LignesDesHits "" LignesDesHits set LesHits {} foreach Ligne [split $LignesDesHits "\n"] { set Ligne [string trim $Ligne] while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] #Je traite les BId et les access### set BId [lindex $LaLigne 0] set Access [lindex $LaLigne 1] regsub -all {\(|\)} $Access "" Access if {[info exists TabDejaVu($BId)]} {continue} else {set TabDejaVu($BId) 1} if {[EstUnAccessPDB $Access] && [EstUnAccessPDB $BId]} {continue} if {[string equal -nocase $Access "Begin:"]} {set Access $BId} ################## set Expect [lindex $LaLigne end] if {[regexp "^e" $Expect]} {set Expect "1$Expect"} if {$ExpectDeRef < $Expect} {break} incr i if {$NbSubject < $i} {break} #Espionne $LaLigne set Score [lindex $LaLigne end-1] lappend LesHits [list "$BId" "$Access" "$Expect" "$Score"] } return $LesHits } proc LesHitsMultiples {} { set FichierDesHits "[RepertoireDuGenome]/fiches/LesHitsMultiples" set LesPABs [LesPABsDansLOrdre] set i 1 set LesCourants [lrange $LesPABs 0 4] foreach Nom $LesCourants { set LesHitsDe($Nom) [LesHitsDe $Nom] } foreach Suivant [lrange $LesPABs 5 end] { set Nom [lindex $LesCourants 2] foreach Autre $LesCourants { if {$Autre==$Nom} { continue } foreach MonHit [set LesHitsDe($Nom)] { foreach SonHit [set LesHitsDe($Autre)] { if { ! [string equal -nocase $MonHit $SonHit]} { continue } Espionne "$Nom $Autre $MonHit" lappend LesHitsMultiples($Nom) "$Autre $MonHit" AppendAuFichier $FichierDesHits "$Nom $Autre $MonHit" } } } set Premier [lindex $LesCourants 0] unset LesHitsDe($Premier) set LesCourants [lreplace $LesCourants 0 0] lappend LesCourants $Suivant set LesHitsDe($Suivant) [LesHitsDe $Suivant] } } proc LesHomologiesDuBlastN {Fichier {AvecLaSeq ""} {BanqueBlast ""} {Maniere ""} {Qui ""}} { if {$Maniere==""} { set Maniere "AvecTestOrgaAvecOffset" } set AvecTestOrga [string equal -nocase $Maniere "AvecTestOrga"] set AvecOffset [string equal -nocase $Maniere "AvecOffset"] if {$AvecLaSeq==""} { set AvecLaSeq "SansLaSeq" } set AvecLaSeq [string equal -nocase $AvecLaSeq "AvecLaSeq"] set Nom [file tail $Fichier] set SeuilDuBlastN 0.001 set nSequencesTrouves [DecortiqueBlast $Fichier $SeuilDuBlastN "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli] if { $nSequencesTrouves == 0 } { set nCops 0 return {} } if {$Qui=="FirstOnly"} { set Qui [lindex $lBanqueId 0] } set ListeDesHomologues {} set nCops 0 set AttendreFinEntete 0 set FinEntete 0 foreach BanqueId $lBanqueId PN $lPN PartieSegAli $lPartieSegAli { if {$Qui!="" && ! [string equal -nocase $Qui $BanqueId]} { continue } if {$AvecTestOrga} { set Genre "" set Espece "" scan [OffsetEtOrganismeDuFragment $BanqueId $BanqueBlast] "%s %s %s" O Genre Espece set OrgaComplet "$Genre $Espece" set Orga [Glossaire $OrgaComplet Court] } else { set Orga "iinc" } set nCopsDansCetteSequence 0 foreach Ligne $PartieSegAli { if { $AttendreFinEntete } { if { ! [regexp {[0-9a-zA-Z_]} $Ligne] } { set AttendreFinEntete 0 set FinEntete 1 } else { append Entete $Ligne continue } } if {[regexp {^>} $Ligne]} { set Entete $Ligne set AttendreFinEntete 1 } if { $FinEntete } { set FinEntete 0 if {$AvecOffset} { set Offset [OffsetDansEnteteSegAli $Entete $BanqueBlast] } else { set Offset 0 } } if { [regexp "^ Identities =" $Ligne] } { set Identities [StringApres "Identities =" dans $Ligne] set Positives [StringApres "Positives =" dans $Ligne] scan $Identities "%d/%d" nId nTotal scan $Positives "%d/%d" nPo nTotal } if { [regexp "^ Score =" $Ligne] } { if {[info exists Score]} { incr nCops incr nCopsDansCetteSequence if { $AvecLaSeq } { set EtLaSeq "\t$SeqQuery\t$SeqSbjct" } else { set EtLaSeq "" } Wup "Je triche en cachant dans Score le PourcentageIdentite" set PourcentageIdentiteCacheDansScore [format "%5.2f" [expr (100.*$nId)/$nTotal]] set BeauIdentities [format "%14.14s" $Identities] lappend ListeDesHomologues "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$BeauIdentities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq" unset Score unset Expect unset DebutQuery unset DebutSbjct } set Score [FloatApres "Score =" dans $Ligne] catch {unset Expect} if {[regexp "Expect =" $Ligne]} { set Expect [PNApres "Expect =" dans $Ligne] } if {[regexp {Expect\([0-9]\) =} $Ligne Match]} { set Expect [PNApres $Match dans $Ligne] } if { ! [info exists Expect]} { Warne "$Ligne\nwithout Expect ... I break" catch {unset Score} catch {unset Expect} catch {unset DebutQuery} catch {unset DebutSbjct} break } catch {unset DebutQuery} catch {unset DebutSbjct} if { [expr $Expect > $SeuilDuBlastN]} { catch {unset Score} catch {unset Expect} catch {unset DebutQuery} catch {unset DebutSbjct} break } } if {[regexp "^ Database:" $Ligne] } { break } if {[regexp "^Query:" $Ligne] } { if { ! [info exists DebutQuery]} { set SeqQuery "" set DebutQuery [IntegerApres "Query:" dans $Ligne] } regexp -indices {[0-9]+} $Ligne D set D [lindex $D 1] regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F set F [expr [lindex $F 0]+$D-1] append SeqQuery [string trim [string range $Ligne $D $F]] set FinQuery [IntegerEnFin de $Ligne] } if {[regexp "^Sbjct:" $Ligne] } { if { ! [info exists DebutSbjct]} { set SeqSbjct "" set DebutSbjct [expr [IntegerApres "Sbjct:" dans $Ligne] + $Offset] } regexp -indices {[0-9]+} $Ligne D set D [lindex $D 1] regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F set F [expr [lindex $F 0]+$D-1] append SeqSbjct [string trim [string range $Ligne $D $F]] set FinSbjct [expr [IntegerEnFin de $Ligne] + $Offset] } } if {[info exists Score] && [expr $Expect <= $SeuilDuBlastN] } { incr nCops incr nCopsDansCetteSequence if { $AvecLaSeq } { set EtLaSeq "\t$SeqQuery\t$SeqSbjct" } else { set EtLaSeq "" } Wup "Je triche en cachant dans Score le PourcentageIdentite" set PourcentageIdentiteCacheDansScore [expr (100.*$nId)/$nTotal] lappend ListeDesHomologues "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq" } catch {unset Score} catch {unset Expect} catch {unset DebutQuery} catch {unset DebutSbjct} if {$Qui!=""} { break } } return $ListeDesHomologues } proc LesIdDeLaBanqueRelieALAccess {Access de Banque1 dans Banque2} { set Commande "[ProgPathway getz] \"\\\[${Banque1}-acc:$Access\\\] > $Banque2 \"" catch {set Out [eval exec $Commande]} Message set Out [string trim $Out] if {$Out == ""} { set Commande "[ProgPathway getz] \"\\\[${Banque1}-id:$Access\\\] > $Banque2 \"" catch {set Out [eval exec $Commande]} Message if {$Out == ""} {return} } set LesId {} foreach Ligne [split $Out "\n"] { if {$Ligne == ""} {continue} if {[info exists Id]} {unset Id} regsub {^[^:]+:} $Ligne "" Id if {![info exists Id]} {continue} lappend LesId $Id } return $LesId } proc LesIdMappingUniprot {Liste {GetWhat ""} {Field ""}} { if {[llength $Liste]==1 && [file exists $Liste]} { set Liste [LesLignesDuFichier $Liste] } if {$GetWhat==""} { set GetWhat "GetQR" } if {[regexp {[ \,\;\n\r\t]} $Liste]} { set Liste [split $Liste " ,;\n\r\t"] } if {$Field==""} { set Field "ACC" } set LesRecus [IDMapping "ACC+ID" $Field $Liste] foreach Q $Liste R $LesRecus { if {$R==""} { lappend LesR $R } lappend LesQR "$Q:$R" } if {[regexp -nocase "GetR" $GetWhat]} { set Result $LesR } if {[regexp -nocase "GetQR" $GetWhat]} { set Result $LesQR } if {[regexp -nocase "AsTextWithSpace" $GetWhat]} { set Result [join $Result " "] } if {[regexp -nocase "AsTextWithComma" $GetWhat]} { set Result [join $Result ","] } if {[regexp -nocase "AsTextWithNewLine" $GetWhat]} { set Result [join $Result "\n"] } return $Result } proc LesIdSelectParGretta {File} { set LesId {} set F [open $File] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Id [lindex $LaLigne 0] if {$Id == "Accession"} {continue} lappend LesId $Id } close $F return $LesId } proc LesIlotsSansPointDans {Texte} { set Start -1 set LesBornes {} while {[regexp -indices -start $Start {[^\.]+} $Texte Indices]} { scan $Indices "%d %d" D F lappend LesBornes "$D $F" set Start [expr $F+1] } return $LesBornes } proc LesIndexsDesAccess {Ls} { # Rajoute les simples quotes ... # boucle pour avoir les pk dans l'ordre set pkm [MacCourant] foreach acc $Ls { set acc [string map [list "'" "''"] $acc] lappend tmp "'$acc'" } set Na [list] set Na [$::db eval "select sa.pk_seqali from seqali as sa, seqinfo as si, ln_mac_seqali as lms where lms.pk_mac=$pkm and lms.pk_seqali=sa.pk_seqali and sa.pk_seqinfo=si.pk_seqinfo and si.access in ([join $tmp ,]) order by sa.pk_seqali"] return $Na } proc LesIndexsDesSeqnames {Ls} { foreach s $Ls {lappend Ns '[set ::TDesSeqnames($s)]'} return [$::db eval "select pk_seqali from seqali where seqname in ([join $Ns ,])"] } proc LesIndividusClasses {LesIndividus} { return [lsort -integer -decreasing -index 0 $LesIndividus] } proc LesInfosDe {K Quoi} { Wup "Retourne les informations liees au canvas qu on a besoin" global TabCanvas #Espionne "Demande $K $Quoi" if {[info exists TabCanvas($K,$Quoi)]} {return [set TabCanvas($K,$Quoi)]} else {return ""} } proc LesInfosDeBaseDeMaSequence {SeqQuery {Quoi ""}} { Wup "Retourne les informations de bases de la sequence composition en ATGC, les Tms ..." set Fiche "" set AvecSeq 0 set AvecSeqFormate 0 set AvecStatNuc 0 set AvecTm 0 set AvecTaille 0 set LaTotale 0 if {$Quoi==""|| $Quoi=="LaTotale"} {set LaTotale 1} foreach Choix $Quoi { switch $Choix { "AvecSeq" {set AvecSeq 1;set AvecSeqFormate 0} "AvecSeqFormate" {set AvecSeqFormate 1;set AvecSeq 0} "AvecTaille" {set AvecTaille 1} "AvecStatNuc" {set AvecStatNuc 1} "AvecTm" {set AvecTm 1} "default" {set LaTotale 1} } } set TailleQueryNt [string length $SeqQuery] if {$AvecSeq || $LaTotale} { set SeqRes "" lappend SeqRes ">Sequence:" lappend SeqRes "----------" lappend SeqRes "$SeqQuery" lappend Fiche [join $SeqRes "\n"] } if {$AvecSeqFormate} { set SeqRes "" lappend SeqRes ">Sequence:" lappend SeqRes "----------" set MaSeq $SeqQuery while {1} { if {$MaSeq==""} {break} lappend SeqRes [string range $MaSeq 0 79] set MaSeq [string range $MaSeq 80 end] } lappend Fiche [join $SeqRes "\n"] } if {$AvecTaille || $LaTotale} { set TailleRes "" lappend TailleRes ">Length:" lappend TailleRes "--------" lappend TailleRes "$TailleQueryNt nt(s)" lappend Fiche [join $TailleRes "\n"] } if {$AvecStatNuc || $LaTotale} { set nA [NombreDeBaseDe $SeqQuery "A"] set nT [NombreDeBaseDe $SeqQuery "T"] set nG [NombreDeBaseDe $SeqQuery "G"] set nC [NombreDeBaseDe $SeqQuery "C"] set nN [NombreDeBaseDe $SeqQuery "N"] set nAT [expr $nT + $nA] set nGC [expr $nG + $nC] set nPu [expr $nG + $nA] set nPy [expr $nT + $nC] set PercentA [expr ($nA*1.0/$TailleQueryNt)*100.0] set PercentT [expr ($nT*1.0/$TailleQueryNt)*100.0] set PercentG [expr ($nG*1.0/$TailleQueryNt)*100.0] set PercentC [expr ($nC*1.0/$TailleQueryNt)*100.0] set PercentN [expr ($nN*1.0/$TailleQueryNt)*100.0] set PercentAT [expr $PercentA + $PercentT] set PercentGC [expr $PercentC + $PercentG] set PercentPu [expr ($nPu*1.0/$TailleQueryNt)*100.0] set PercentPy [expr ($nPy*1.0/$TailleQueryNt)*100.0] set StatNucRes "" lappend StatNucRes ">Nucleic Acid Composition:" lappend StatNucRes "--------------------------" lappend StatNucRes [format " %5s %8s %4s" "Bases" "Number" "%"] lappend StatNucRes [format " %3s %6d %5.1f" " A " $nA $PercentA] lappend StatNucRes [format " %3s %6d %5.1f" " T " $nT $PercentT] lappend StatNucRes [format " %3s %6d %5.1f" " G " $nG $PercentG] lappend StatNucRes [format " %3s %6d %5.1f" " C " $nC $PercentC] lappend StatNucRes [format " %3s %6d %5.1f" " N " $nN $PercentN] lappend StatNucRes [format " %3s %6d %5.1f" "A+T" $nAT $PercentAT] lappend StatNucRes [format " %3s %6d %5.1f" "G+C" $nGC $PercentGC] lappend StatNucRes [format " %3s %6d %5.1f" "Pur" $nPu $PercentPu] lappend StatNucRes [format " %3s %6d %5.1f" "Pyr" $nPy $PercentPy] lappend Fiche [join $StatNucRes "\n"] } if {$AvecTm || $LaTotale} { set TmWallace [CalculTmDeLaSeq $SeqQuery "" 0.0 Wallace] set TmDNADNA [CalculTmDeLaSeq $SeqQuery "" 0.0 DNADNA] set TmDNARNA [CalculTmDeLaSeq $SeqQuery "" 0.0 DNARNA] set TmRNARNA [CalculTmDeLaSeq $SeqQuery "" 0.0 RNARNA] set TmNN [CalculTmDeLaSeq $SeqQuery "" 0.0 NearestNeighbor] if {$TmNN=="-1"} {set TmNN "0.0"} set TmRes "" lappend TmRes ">Melting Temperature:" lappend TmRes "---------------------" lappend TmRes [format "%8s %9s %5s\n" "Method" "" "Result"] lappend TmRes [format "%-16s %-5.0f \°C %-s" "Wallace" $TmWallace "Tm = 4*(G+C)+2*(A+T)"] lappend TmRes [format "%-16s %-5.1f \°C %-s" "DNA-DNA" $TmDNADNA "Tm = 81.5+16.6*log M+0.41(%GC)-500/L-0.62F"] lappend TmRes [format "%-16s %-5.1f \°C %-s" "DNA-RNA" $TmDNARNA "Tm = 79.8+18.5*log M+0.584(%GC)+0.11(%GC)^2-820/L-0.35F"] lappend TmRes [format "%-16s %-5.1f \°C %-s" "RNA-RNA" $TmRNARNA "Tm = 79.8+18.5*log M+0.584(%GC)+0.11(%GC)^2-820/L-0.50F"] lappend TmRes [format "%-16s %-5.1f \°C %-s" "Nearest Neighbor" $TmNN "Tm = 1000*DH/(DS+R*ln(\[ADN\]/4)-273.15)"] lappend Fiche [join $TmRes "\n"] } return [join $Fiche "\n\n"] } proc LesInfosDeMesPABDuPoster {} { set FichierOut "[RepertoireDuGenome]/Info_DuPoster" set LesPABs [list ACT0004 ACT0010 ACT1162 ACT0017 ACT0016 ACT0883 ACT0204 ACT0396 ACT0938 ACT1164 ACT0916] #set LesPABs [list ACT0004] foreach PAB $LesPABs { set Access [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] set Texte "$PAB $Access" AppendAuFichier $FichierOut "" AppendAuFichier $FichierOut $Texte AppendAuFichier $FichierOut "[string repeat "-" [string length $Texte]]" set option "-f \"id des CC\"" set Banques "protein" set Typ1 id set Typ2 acc set Commande "getz $option \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\])\"" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]||$GetzOut==""} { set Commande "getz $option \"\\\[$Banques-all: $Access\\\]\"" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message } if {![info exists GetzOut]||$GetzOut==""} { Espionne "$PAB Rien" } else { #Espionne "$GetzOut" AppendAuFichier $FichierOut $GetzOut } } return "" } proc LesInfosDesARPs {{FichierARP ""} {FichierSave ""}} { Wup "Permet de recuperer les infos des access de l alignement multiple des ARPs" Wup "ListeAccessDesARPs est un fichier creer a partir d 1 copier/coller de la liste des access dans seqlab" if {$FichierARP==""} { set FichierARP "[RepertoireDuGenome]/ListeAccessDesARPs" } if {! [file exists $FichierARP]} {return ""} if {$FichierSave==""} { set FichierSave "${FichierARP}_Id_Def_Org" } #Lecture du fichier et recuperation des access et des groupes de sequences set F [open "$FichierARP"] set NewCategorie "" set LesCategorie "" while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if { [regexp "^----" $Ligne]} { set NewCategorie $Ligne lappend LesCategorie $NewCategorie continue } if {$NewCategorie==""} {continue} set Access [string toupper [lindex $Ligne 0]] if {$Access==""} {continue} lappend TabARP($NewCategorie,LesAccess) $Access } close $F #Pour chaque sequence de chaque categorie on recherche les infos interessantes #Description #Organisme foreach Cat $LesCategorie { Espionne "$Cat" set LesAccessGetz [join [set TabARP($Cat,LesAccess)] "|"] set Banques "protein" set option "-vf \"acc des org txi id\" -cs \"COLSEPARATOR\" -rs \"ROWSEPARATOR\"" set Typ1 "acc" set Commande "getz $option \"\\\[$Banques-$Typ1: $LesAccessGetz\\\]\"" Espionne "$Commande" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {continue} if {$GetzOut==""} {continue} #Espionne "$GetzOut" set GetzOut [split $GetzOut "\n"] set GetzOut [join $GetzOut " "] regsub -all "ROWSEPARATOR" $GetzOut "\n" GetzOut set GetzOut [split $GetzOut "\n"] foreach E $GetzOut { if {! [regexp -nocase {[a-z]+ || [0-9]+} $E] || $E==""} {continue} #Espionne ">>>$E" regsub -all "COLSEPARATOR" $E "\n" E set Acc "" set Def "" set Org "" set Tax "" set Id "" set E [split $E "\n"] set Acc [lindex $E 1] set Def [lindex $E 2] set Org [lindex $E 3] set Tax [split [lindex $E 4] " "] set Id [split [lindex $E 5] " "] #Espionne "$Tax" #Cas ou on a plusieurs access pour une meme entrees dans la banque #Attention on peut avoir plusieurs entree avec le meme accession number (ex ARP2_HUMAN et ARP2_MOUSE) #mais avec des organismes differents #Espionne ">>>NewAcc" #Espionne "<<<$Acc" foreach A [split $Acc " "] { if {[regexp $A [set TabARP($Cat,LesAccess)]]} { set OnLa $A #Espionne ">>>$OnLa" set TabARP($OnLa,Def) $Def if {! [info exists TabARP($OnLa,Id)]} { set TabARP($OnLa,Id) "" lappend TabARP($OnLa,Id) [string trim $Id] } else { lappend TabARP($OnLa,Id) [string trim $Id] } if {! [info exists TabARP($OnLa,Org)]} { set TabARP($OnLa,Org) "" lappend TabARP($OnLa,Org) [string trim $Org] } else { lappend TabARP($OnLa,Org) [string trim $Org] } if {! [info exists TabARP($OnLa,Tax)]} { set TabARP($OnLa,Tax) "" foreach T $Tax { lappend TabARP($OnLa,Tax) [string trim $T] } } else { foreach T $Tax { lappend TabARP($OnLa,Tax) [string trim $T] } } #Espionne "$OnLa $Org" } } } } set Cat "" set Acc "" set MonAcc "" foreach Cat $LesCategorie { AppendAuFichier $FichierSave "$Cat" #Espionne "$Cat" foreach MonAcc [set TabARP($Cat,LesAccess)] { set Def "" set Id "" set Acc $MonAcc if {[regexp {ARP[0-9]+} $Acc]} { #Equivalence entre ARP01 et son acc set Acc [AccessCorrespondantAuxARPs $MonAcc] } if {[info exists TabARP($Acc,Id)]} { set Id [join [string trim [set TabARP($Acc,Id)]] " "] } if {[info exists TabARP($Acc,Def)]} { set Def [string trim [set TabARP($Acc,Def)]] } set Org "" if {[info exists TabARP($Acc,Org)]} { set Org [join [string trim [set TabARP($Acc,Org)]] " "] } set Tax "" if {[info exists TabARP($Acc,Tax)]} { set Tax [join [string trim [set TabARP($Acc,Tax)]] " "] } Espionne "$MonAcc -- $Id -- $Def -- $Org -- $Tax" AppendAuFichier $FichierSave "[join [list $MonAcc $Id $Def $Org $Tax] "\t"]" } } return "" } proc LesInfosDesGOSurLArborescence {GO X Color {LesInfos ""} {aTabGOSelectionnes ""}} { if {$aTabGOSelectionnes != ""} { upvar $aTabGOSelectionnes TabGOSelectionnes if {[set TabGOSelectionnes(LesGO)] != {} && ![info exists TabGOSelectionnes($GO)]} {return $LesInfos} } if {![info exists TabGOSelectionnes(LesGO) ]} {set TabGOSelectionnes(LesGO) {}} if {![info exists TabGOSelectionnes(LesTypes)]} {set TabGOSelectionnes(LesTypes) {}} global PosYSurArbreGO set EcartX 30 set EcartY 15 lappend LesInfos [list $GO $X $PosYSurArbreGO $Color] set X [expr $X + $EcartX] foreach Type [Onto LesTypes] { if {[set TabGOSelectionnes(LesTypes)] != {} && ![info exists TabGOSelectionnes($Type)]} {continue} foreach GOFils [Onto $Type $GO LesContributions] { if {[set TabGOSelectionnes(LesGO)] != {}} {if {![info exists TabGOSelectionnes($GOFils)]} {continue}} set PosYSurArbreGO [expr $PosYSurArbreGO + $EcartY] set LesInfos [LesInfosDesGOSurLArborescence $GOFils $X "red" $LesInfos TabGOSelectionnes] } foreach GOFils [Onto $Type $GO LesEnfants ] { if {[set TabGOSelectionnes(LesGO)] != {}} {if {![info exists TabGOSelectionnes($GOFils)]} {continue}} set PosYSurArbreGO [expr $PosYSurArbreGO + $EcartY] set LesInfos [LesInfosDesGOSurLArborescence $GOFils $X "blue" $LesInfos TabGOSelectionnes] } } return $LesInfos } proc LesInfosDesProtsDonnees {FichierProtDonnees FichierSave} { Wup "Permet de recuperer les infos des access de l alignement multiple des ARPs" Wup "ListeAccessDesARPs est un fichier creer a partir d 1 copier/coller de la liste des access dans seqlab" if {! [file exists $FichierProtDonnees] || $FichierSave==""} {Espionne "Nofile for LesInfosDesProtsDonnees";return ""} #Lecture du fichier et recuperation des access et des groupes de sequences set F [open "$FichierProtDonnees"] set NewCategorie "" set LesCategorie "" while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if { [regexp "^----" $Ligne]} { set NewCategorie $Ligne lappend LesCategorie $NewCategorie continue } if {$NewCategorie==""} {continue} set Access [string toupper [lindex $Ligne 0]] if {$Access==""} {continue} lappend TabProtDonnees($NewCategorie,LesAccess) $Access } close $F #Pour chaque sequence de chaque categorie on recherche les infos interessantes #Description #Organisme foreach Cat $LesCategorie { #Espionne "$Cat" set LesAccessGetz [join [set TabProtDonnees($Cat,LesAccess)] "|"] set Banques "protein" set option "-vf \"acc des org txi\" -cs \"COLSEPARATOR\" -rs \"ROWSEPARATOR\"" set Typ1 "acc" set Typ2 "id" set Commande "getz $option \"(\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\])\"" #Espionne "$Commande" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {continue} if {$GetzOut==""} {continue} #Espionne "$GetzOut" set GetzOut [split $GetzOut "\n"] set GetzOut [join $GetzOut " "] regsub -all "ROWSEPARATOR" $GetzOut "\n" GetzOut set GetzOut [split $GetzOut "\n"] foreach E $GetzOut { if {! [regexp -nocase {[a-z]+ || [0-9]+} $E] || $E==""} {continue} #Espionne ">>>$E" regsub -all "COLSEPARATOR" $E "\n" E set E [split $E "\n"] set Acc [lindex $E 1] set Def [lindex $E 2] set Org [lindex $E 3] set Tax [split [lindex $E 4] " "] #Espionne "$Tax" #Cas ou on a plusieurs access pour une meme entrees dans la banque #Attention on peut avoir plusieurs entree avec le meme accession number (ex ARP2_HUMAN et ARP2_MOUSE) #mais avec des organismes differents #Espionne ">>>NewAcc" #Espionne "<<<$Acc" set OnLa "" foreach A [split $Acc " "] { if {[regexp $A [set TabProtDonnees($Cat,LesAccess)]]} { set OnLa $A #Espionne ">>>$OnLa" set TabProtDonnees($OnLa,Def) $Def if {! [info exists TabProtDonnees($OnLa,Org)]} { set TabProtDonnees($OnLa,Org) "" lappend TabProtDonnees($OnLa,Org) [string trim $Org] } else { lappend TabProtDonnees($OnLa,Org) [string trim $Org] } if {! [info exists TabProtDonnees($OnLa,Tax)]} { set TabProtDonnees($OnLa,Tax) "" foreach T $Tax { lappend TabProtDonnees($OnLa,Tax) [string trim $T] } } else { foreach T $Tax { lappend TabProtDonnees($OnLa,Tax) [string trim $T] } } #Espionne "$OnLa $Org" } } if {$OnLa==""} { #Cas particulier avec des IDs #PROTEIN:UBC1_MOUSE #set OnLa [lindex [split $Acc " "] 0] set Acc [lindex $E 0] regsub -all -nocase "PROTEIN:" $Acc "" Acc #Espionne "cas des IDS -- $Acc" set OnLa $Acc set TabProtDonnees($OnLa,Def) $Def if {! [info exists TabProtDonnees($OnLa,Org)]} { set TabProtDonnees($OnLa,Org) "" lappend TabProtDonnees($OnLa,Org) [string trim $Org] } else { lappend TabProtDonnees($OnLa,Org) [string trim $Org] } if {! [info exists TabProtDonnees($OnLa,Tax)]} { set TabProtDonnees($OnLa,Tax) "" foreach T $Tax { lappend TabProtDonnees($OnLa,Tax) [string trim $T] } } else { foreach T $Tax { lappend TabProtDonnees($OnLa,Tax) [string trim $T] } } } } } set Cat "" set Acc "" set MonAcc "" foreach Cat $LesCategorie { AppendAuFichier $FichierSave "$Cat" #Espionne "$Cat" foreach MonAcc [set TabProtDonnees($Cat,LesAccess)] { set Def "" set Acc $MonAcc if {[info exists TabProtDonnees($Acc,Def)]} { set Def [string trim [set TabProtDonnees($Acc,Def)]] } set Org "" if {[info exists TabProtDonnees($Acc,Org)]} { set Org [join [string trim [set TabProtDonnees($Acc,Org)]] " "] } set Tax "" if {[info exists TabProtDonnees($Acc,Tax)]} { set Tax [join [string trim [set TabProtDonnees($Acc,Tax)]] " "] } AppendAuFichier $FichierSave "[join [list $MonAcc $Def $Org $Tax] "\t"]" } } return "" } proc LesInfosDesRegionsDansLeBlast {FileBlast LesRegions {LesBanqueId All} {SeuilId None} {QuEstCeQueCest ""}} { if {$LesBanqueId != "All"} { foreach BId $LesBanqueId {set TabBIdOK($BId) 1} } set NbSubject [AskBlast $FileBlast NbSubject] if {$NbSubject == "" || $NbSubject == 0} {return} set TypeDeBlast [AskBlast $FileBlast TypeDeBlast] set IndiceQ 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set IndiceQ 3} set IndiceS 1 if {$TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} {set IndiceS 3} if { $TypeDeBlast == "BLASTX" || $TypeDeBlast == "BLASTP" || $TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} { set BaseFiltree "X" } elseif {$TypeDeBlast == "BLASTN"} { set BaseFiltree "N" } set LesRegions [lsort -integer -index 0 $LesRegions] set NbSubject [AskBlast $FileBlast NbSubject] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FileBlast Subject $i] if {$LesBanqueId != "All" && ![info exists TabBIdOK($BId)]} {continue} if {[info exist TabTmp($BId)]} {continue} set TabTmp($BId) 1 set NbSegment [AskBlast $FileBlast BanqueId $BId NbSegment] for {set j 1} {$j <= $NbSegment} {incr j} { if {$SeuilId != "None"} { set Identities [AskBlast $FileBlast BanqueId $BId Segment $j Identities] scan $Identities "%d/%d" nmRNA nmRNATot set Id [expr $nmRNA*1.0/$nmRNATot] if {$Id < $SeuilId} {continue} } set DQ [AskBlast $FileBlast BanqueId $BId Segment $j DQ] set FQ [AskBlast $FileBlast BanqueId $BId Segment $j FQ] set DS [AskBlast $FileBlast BanqueId $BId Segment $j DS] set FS [AskBlast $FileBlast BanqueId $BId Segment $j FS] if {$FQ < $DQ} {set SensQ "-"} else {set SensQ "+"} if {$FQ < $DQ} {set FactSensQ -1 } else {set FactSensQ 1 } if {$FS < $DS} {set SensS "-"} else {set SensS "+"} if {$FS < $DS} {set FactSensS -1 } else {set FactSensS 1 } set Orientation [AskBlast $FileBlast BanqueId $BId Segment $j Orientation] set Sens [SensDeLaRegion $Orientation] set Query [lindex [split [AskBlast $FileBlast BanqueId $BId Segment $j AlignLineaire] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [AskBlast $FileBlast BanqueId $BId Segment $j AlignLineaire] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] foreach UneRegion $LesRegions { set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] if {![info exists TabTmp($D,$F,LesBId)]} { set TabTmp($D,$F,LesBId) {} } if {![CesRegionsSontEllesOverlappantes $D $F [Mini $DQ $FQ] [Maxi $DQ $FQ]]} {continue} if {![info exists TabTmp($D,$F,$BId,LesSegments)]} { set TabTmp($D,$F,$BId,LesSegments) {} } if {![info exists TabTmp($D,$F,$BId,$Sens,NbArea)]} { set TabTmp($D,$F,$BId,$Sens,NbArea) 0 } if {![info exists TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli)]} { set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) 0 set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot) 0 } lappend TabTmp($D,$F,$BId,LesSegments) [list $DQ $FQ $DS $FS $Orientation $Sens] set NContMax 0 set NCont 0 set PosIniQ $DQ set PosIniS $DS set LesBornesSurSubject {} foreach AQ $LAliQuery AS $LAliSbjct { if {[string equal -nocase "-" $AQ]} { set PosIniS [expr $PosIniS + $IndiceS * $FactSensS] if { [Maxi $D [Mini $DQ $FQ]] <= $PosIniQ && $PosIniQ <= [Mini $F [Maxi $DQ $FQ]]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } continue } if {[string equal -nocase "-" $AS]} { set PosIniQ [expr $PosIniQ + $IndiceQ * $FactSensQ] if { [Maxi $D [Mini $DQ $FQ]] <= $PosIniQ && $PosIniQ <= [Mini $F [Maxi $DQ $FQ]]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } continue } for {set k 0} {$k < $IndiceQ} {incr k} { set PosQ [expr $PosIniQ + $k * $FactSensQ] for {set l 0} {$l < $IndiceS} {incr l} { set PosS [expr $PosIniS + $l * $FactSensS] if { [Maxi $D [Mini $DQ $FQ]] <= $PosQ && $PosQ <= [Mini $F [Maxi $DQ $FQ]]} { lappend LesBornesSurSubject $PosS } } if { [Maxi $D [Mini $DQ $FQ]] <= $PosQ && $PosQ <= [Mini $F [Maxi $DQ $FQ]]} { if {[string equal -nocase $BaseFiltree $AQ]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 continue } if {$AQ == $AS} { incr NCont incr TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) } else { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } incr TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot) } } set PosIniQ [expr $PosIniQ + $IndiceQ * $FactSensQ] set PosIniS [expr $PosIniS + $IndiceS * $FactSensS] } if {$LesBornesSurSubject == {}} {continue} set LesBornesSurSubject [lsort -integer $LesBornesSurSubject] lappend TabTmp($D,$F,LesBId) $BId incr TabTmp($D,$F,$BId,$Sens,NbArea) lappend TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,D) [lindex $LesBornesSurSubject 0 ] lappend TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,F) [lindex $LesBornesSurSubject end] if {$NContMax < $NCont} {set NContMax $NCont} set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NCont) $NContMax } } } set LesRegionsEtLeurFrequence {} foreach UneRegion $LesRegions { set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set LesBId [set TabTmp($D,$F,LesBId)] set NTot [llength $LesBId] set LesBIdDeLaRegion {} foreach BId [lsort -unique $LesBId] { foreach UnSegment [set TabTmp($D,$F,$BId,LesSegments)] { set DQ [lindex $UnSegment 0] set FQ [lindex $UnSegment 1] set DS [lindex $UnSegment 2] set FS [lindex $UnSegment 3] set Sens [lindex $UnSegment 5] if {![info exists TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli)]} {continue} set NAli [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) ] if {$NAli == 0} {continue} set Orient [lindex $UnSegment 4] set NAliTot [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot)] set NCont [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NCont)] set DsurS [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,D)] set FsurS [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,F)] set N [set TabTmp($D,$F,$BId,$Sens,NbArea)] lappend LesRegionsEtLeurFrequence [list $D $F $NTot $N $BId $Orient $Sens $DsurS $FsurS $NAli $NAliTot $NCont] } } } if {[info exists TabTmp]} {unset TabTmp} if {$QuEstCeQueCest == "Contig"} { set TailleContig 100000 set LesRegionsEtLeurFrequenceTmp {} foreach UneRegion $LesRegionsEtLeurFrequence { set BId [lindex $UneRegion 4] if {[regexp {_[0-9]*} $BId]} { regexp -nocase {([a-z0-9]+):([0-9a-z]+)_([0-9]+)} $BId tmp Chromosome Contig Fragment } else { regexp -nocase {([a-z0-9]+):([0-9a-z]+)} $BId tmp Chromosome Contig set Fragment "" } if {$Fragment != ""} {set NbFragment [Base10 $Fragment]} else {set NbFragment 0} set DS [expr [lindex $UneRegion 7] + $TailleContig * $NbFragment] set FS [expr [lindex $UneRegion 8] + $TailleContig * $NbFragment] set BId [list $Chromosome $Contig [string length $Fragment]] set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set Sens [lindex $UneRegion 6] if {[info exists TabTmp($D,$F,$Contig,$DS,$FS,$Sens)]} {continue} set TabTmp($D,$F,$Contig,$DS,$FS,$Sens) 1 if {![info exists TabTmp($D,$F,$Contig,$Sens,NbArea)]} {set TabTmp($D,$F,$Contig,$Sens,NbArea) 0} incr TabTmp($D,$F,$Contig,$Sens,NbArea) set UneRegion [lreplace $UneRegion 4 4 $BId] set UneRegion [lreplace $UneRegion 7 7 $DS ] set UneRegion [lreplace $UneRegion 8 8 $FS ] lappend LesRegionsEtLeurFrequenceTmp $UneRegion } set LesRegionsEtLeurFrequence {} foreach UneRegion $LesRegionsEtLeurFrequenceTmp { set Contig [lindex [lindex $UneRegion 4] 1] set Sens [lindex $UneRegion 6] set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set UneRegion [lreplace $UneRegion 3 3 [set TabTmp($D,$F,$Contig,$Sens,NbArea)]] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } set UneRegion [lreplace $UneRegion 0 0 [Mini $D $F]] set UneRegion [lreplace $UneRegion 1 1 [Maxi $D $F]] set UneRegion [lreplace $UneRegion 7 7 $DS] set UneRegion [lreplace $UneRegion 8 8 $FS] lappend LesRegionsEtLeurFrequence $UneRegion } } if {[info exists TabTmp)]} {unset TabTmp} return [lsort -index 0 -integer $LesRegionsEtLeurFrequence] } proc LesInfosDesRegionsDansLeBlast_TabBlast {aTabBlast LesRegions {LesBanqueId All} {SeuilId None} {QuEstCeQueCest ""}} { upvar $aTabBlast TabBlast if {$LesBanqueId != "All"} { foreach BId $LesBanqueId {set TabBIdOK($BId) 1} } if {![info exists TabBlast(NbSubject)]} {return {}} set TypeDeBlast [set TabBlast(TypeDeBlast)] set IndiceQ 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set IndiceQ 3} set IndiceS 1 if {$TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} {set IndiceS 3} if { $TypeDeBlast == "BLASTX" || $TypeDeBlast == "BLASTP" || $TypeDeBlast == "TBLASTN" || $TypeDeBlast == "TBLASTX"} { set BaseFiltree "X" } elseif {$TypeDeBlast == "BLASTN"} { set BaseFiltree "N" } set LesRegions [lsort -integer -index 0 $LesRegions] set NbSubject [set TabBlast(NbSubject)] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set TabBlast($i)] if {$LesBanqueId != "All" && ![info exists TabBIdOK($BId)]} {continue} if {[info exist TabTmp($BId)]} {continue} set TabTmp($BId) 1 set NbSegment [set TabBlast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { if {$SeuilId != "None"} { set Identities [set TabBlast($BId,$j,Identities)] scan $Identities "%d/%d" nmRNA nmRNATot set Id [expr $nmRNA*1.0/$nmRNATot] if {$Id < $SeuilId} {continue} } set DQ [set TabBlast($BId,$j,DQ)] set FQ [set TabBlast($BId,$j,FQ)] set DS [set TabBlast($BId,$j,DS)] set FS [set TabBlast($BId,$j,FS)] if {$FQ < $DQ} {set SensQ "-"} else {set SensQ "+"} if {$FQ < $DQ} {set FactSensQ -1 } else {set FactSensQ 1 } if {$FS < $DS} {set SensS "-"} else {set SensS "+"} if {$FS < $DS} {set FactSensS -1 } else {set FactSensS 1 } set Orientation [set TabBlast($BId,$j,Orientation)] set Sens [SensDeLaRegion $Orientation] set Query [lindex [split [set TabBlast($BId,$j,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$j,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] foreach UneRegion $LesRegions { set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] if {![info exists TabTmp($D,$F,LesBId)]} { set TabTmp($D,$F,LesBId) {} } if {![CesRegionsSontEllesOverlappantes $D $F [Mini $DQ $FQ] [Maxi $DQ $FQ]]} {continue} if {![info exists TabTmp($D,$F,$BId,LesSegments)]} { set TabTmp($D,$F,$BId,LesSegments) {} } if {![info exists TabTmp($D,$F,$BId,$Sens,NbArea)]} { set TabTmp($D,$F,$BId,$Sens,NbArea) 0 } if {![info exists TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli)]} { set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) 0 set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot) 0 } lappend TabTmp($D,$F,$BId,LesSegments) [list $DQ $FQ $DS $FS $Orientation $Sens] set NContMax 0 set NCont 0 set PosIniQ $DQ set PosIniS $DS set LesBornesSurSubject {} foreach AQ $LAliQuery AS $LAliSbjct { if {[string equal -nocase "-" $AQ]} { set PosIniS [expr $PosIniS + $IndiceS * $FactSensS] if { [Maxi $D [Mini $DQ $FQ]] <= $PosIniQ && $PosIniQ <= [Mini $F [Maxi $DQ $FQ]]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } continue } if {[string equal -nocase "-" $AS]} { set PosIniQ [expr $PosIniQ + $IndiceQ * $FactSensQ] if { [Maxi $D [Mini $DQ $FQ]] <= $PosIniQ && $PosIniQ <= [Mini $F [Maxi $DQ $FQ]]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } continue } for {set k 0} {$k < $IndiceQ} {incr k} { set PosQ [expr $PosIniQ + $k * $FactSensQ] for {set l 0} {$l < $IndiceS} {incr l} { set PosS [expr $PosIniS + $l * $FactSensS] if { [Maxi $D [Mini $DQ $FQ]] <= $PosQ && $PosQ <= [Mini $F [Maxi $DQ $FQ]]} { lappend LesBornesSurSubject $PosS } } if { [Maxi $D [Mini $DQ $FQ]] <= $PosQ && $PosQ <= [Mini $F [Maxi $DQ $FQ]]} { if {[string equal -nocase $BaseFiltree $AQ]} { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 continue } if {$AQ == $AS} { incr NCont incr TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) } else { if {$NContMax < $NCont} {set NContMax $NCont} set NCont 0 } incr TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot) } } set PosIniQ [expr $PosIniQ + $IndiceQ * $FactSensQ] set PosIniS [expr $PosIniS + $IndiceS * $FactSensS] } if {$LesBornesSurSubject == {}} {continue} set LesBornesSurSubject [lsort -integer $LesBornesSurSubject] lappend TabTmp($D,$F,LesBId) $BId incr TabTmp($D,$F,$BId,$Sens,NbArea) lappend TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,D) [lindex $LesBornesSurSubject 0 ] lappend TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,F) [lindex $LesBornesSurSubject end] if {$NContMax < $NCont} {set NContMax $NCont} set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NCont) $NContMax } } } set LesRegionsEtLeurFrequence {} foreach UneRegion $LesRegions { set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set LesBId [set TabTmp($D,$F,LesBId)] set NTot [llength $LesBId] set LesBIdDeLaRegion {} foreach BId [lsort -unique $LesBId] { foreach UnSegment [set TabTmp($D,$F,$BId,LesSegments)] { set DQ [lindex $UnSegment 0] set FQ [lindex $UnSegment 1] set DS [lindex $UnSegment 2] set FS [lindex $UnSegment 3] set Sens [lindex $UnSegment 5] if {![info exists TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli)]} {continue} set NAli [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAli) ] if {$NAli == 0} {continue} set Orient [lindex $UnSegment 4] set NAliTot [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NAliTot)] set NCont [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,NCont)] set DsurS [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,D)] set FsurS [set TabTmp($D,$F,$BId,$DQ,$FQ,$DS,$FS,$Sens,F)] set N [set TabTmp($D,$F,$BId,$Sens,NbArea)] lappend LesRegionsEtLeurFrequence [list $D $F $NTot $N $BId $Orient $Sens $DsurS $FsurS $NAli $NAliTot $NCont] } } } if {[info exists TabTmp]} {unset TabTmp} if {$QuEstCeQueCest == "Contig"} { set TailleContig 100000 set LesRegionsEtLeurFrequenceTmp {} foreach UneRegion $LesRegionsEtLeurFrequence { set BId [lindex $UneRegion 4] if {[regexp {_[0-9]*} $BId]} { regexp -nocase {([a-z0-9]+):([0-9a-z]+)_([0-9]+)} $BId tmp Chromosome Contig Fragment } else { regexp -nocase {([a-z0-9]+):([0-9a-z]+)} $BId tmp Chromosome Contig set Fragment "" } if {$Fragment != ""} {set NbFragment [Base10 $Fragment]} else {set NbFragment 0} set DS [expr [lindex $UneRegion 7] + $TailleContig * $NbFragment] set FS [expr [lindex $UneRegion 8] + $TailleContig * $NbFragment] set BId [list $Chromosome $Contig [string length $Fragment]] set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set Sens [lindex $UneRegion 6] if {[info exists TabTmp($D,$F,$Contig,$DS,$FS,$Sens)]} {continue} set TabTmp($D,$F,$Contig,$DS,$FS,$Sens) 1 if {![info exists TabTmp($D,$F,$Contig,$Sens,NbArea)]} {set TabTmp($D,$F,$Contig,$Sens,NbArea) 0} incr TabTmp($D,$F,$Contig,$Sens,NbArea) set UneRegion [lreplace $UneRegion 4 4 $BId] set UneRegion [lreplace $UneRegion 7 7 $DS ] set UneRegion [lreplace $UneRegion 8 8 $FS ] lappend LesRegionsEtLeurFrequenceTmp $UneRegion } set LesRegionsEtLeurFrequence {} foreach UneRegion $LesRegionsEtLeurFrequenceTmp { set Contig [lindex [lindex $UneRegion 4] 1] set Sens [lindex $UneRegion 6] set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] set UneRegion [lreplace $UneRegion 3 3 [set TabTmp($D,$F,$Contig,$Sens,NbArea)]] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } set UneRegion [lreplace $UneRegion 0 0 [Mini $D $F]] set UneRegion [lreplace $UneRegion 1 1 [Maxi $D $F]] set UneRegion [lreplace $UneRegion 7 7 $DS] set UneRegion [lreplace $UneRegion 8 8 $FS] lappend LesRegionsEtLeurFrequence $UneRegion } } if {[info exists TabTmp)]} {unset TabTmp} return [lsort -index 0 -integer $LesRegionsEtLeurFrequence] } proc LesInfosDuCluster {{NomDuCluster ""}} { Wup "Rend la taille et les membres du cluster Numero X ou du PAB X" if {! [regexp -nocase {[a-z]+ || [0-9]+} $NomDuCluster]} {return "No Query"} set LesMembres [InfoDuCluster $NomDuCluster] set Taille [InfoDuCluster $NomDuCluster Taille] set Numero [InfoDuCluster $NomDuCluster Numero] set TexteMembres [join $LesMembres " "] regsub -all "[PreFixe]" $TexteMembres "" TexteMembres return "Cluster $Numero\nTaille: $Taille\nMembres: $TexteMembres" } proc LesInfosDuPoch {} { set LesCles [list Acreuser Construct Construct1 Constructt2 INfo1 Info1 Info2 StructHyp Target ] foreach Nom [ListeDesPABs] { set FI "[HomeRipp]/vrac/infos/$Nom" if {[FileAbsent $FI]} { continue } foreach Ligne [LesLignesDuFichier $FI] { foreach Cle $LesCles { if {[regexp "^$Cle\:" $Ligne]} { Espionne "$Nom $Ligne" InformeSansDemander $Nom $Ligne } } } } } proc LesInfosDuVRGMasking {File} { # VRG == vector, repeat and genome masking, c'est la masking pour les sequences de differential display # ### Pour chaque file ".tfa.Masking.infos, permet de savoir si la seq est masquee par V, R ou G ### set V 0 set R 0 set G 0 set F [open $File] while {[gets $F Ligne]>=0} { if {$V && $R && $G} {break} set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Info [lindex $LaLigne 5] if {$Info == "Vector masked" && !$V} {incr V} if {$Info == "Repeat masked" && !$R} {incr R} if {$Info == "Genome masked" && !$G} {incr G} } close $F return [list $V $R $G] } proc LesInfosSupplementairesPourATV {Acc Dist Quoi {DeQui ""}} { Wup "Permet de rechercher les informations supplementaires a ajouter a l arbre pour le format," Wup "compatible NHX (New Hampshire eXtented) et lisible par ATV (viewer d arbre phylo)" #String1 - A priori reserve aux organismes #String2 - Laissee a plusieurs choix: Definition - EC - Categories (dediees a ARP) #Integer1 - A priori reserve aux TaxID #NHX (New Hampshire eXtented) TAG LIST ###################################### #no tag String sequence name of this node (MUST BE FIRST, IF ASSIGNED) #: double branch length to parent node (MUST BE SECOND, IF ASSIGNED) #:B= integer bootstrap value at this node (does not apply to external nodes) #:S= String species name of the species/phylum at this node #:T= integer NCBI taxonomy ID of the species/phylum at this node #:E= String EC number at this node #:O= integer orthologous to this external node #:SO= integer "super orthologous" (no duplications on paths) to this external node #:L= float log likelihood value on parent branch #:D= 'Y'or'N' 'Y' if this node represents a duplication event - # 'N' if this node represents a speciation event (does not apply to ext nodes) #:Sw= 'Y'or'N' placing a subtree on the parent branch of this node makes the tree significantly worse # according to Kishino/Hasegawa test (or similar) #:Co= 'Y'or'N' collapse this node when drawing the tree (default is not to collapse) #ex: [&&NHX:S=human:E=1.1.1.1:] if {$DeQui=="Default"} {set DeQui 0} else {set DeQui 1} if {$Acc=="" || $Dist == ""} {return ""} set String1 "" set String2 "" set Integer1 "" #3-0 On va chercher les informations supplementaires de nos access ################################################################## set OnVeutOrga 0 set OnVeutDef 0 set OnVeutCat 0 set OnVeutEC 0 set OnVeutTax 0 foreach Q [split $Quoi " "] { switch -regexp -- $Q { "Species" {set OnVeutOrga 1} "Definition" {set OnVeutDef 1;set OnVeutCat 0;set OnVeutEC 0} "Categories" {set OnVeutDef 0;set OnVeutCat 1;set OnVeutEC 0} "EC" {set OnVeutDef 0;set OnVeutCat 0;set OnVeutEC 1} "TaxID" {set OnVeutTax 1} } } #3-1 L organisme ################ if {$OnVeutOrga} { set Org "" set LesOrgas "" if {$DeQui} { #Jean pour ARP set Org [InterrogeLesInfosDesARPs $Acc Taxon] foreach O $Org { set MyOrg [LesOrgasDeMesTaxID $O Name] if {$MyOrg==""} {continue} lappend LesOrgas [join $MyOrg "_"] } } else { set Org [InterrogeLesInfosDesProtsDonnees $Acc Taxon] foreach O $Org { set MyOrg [LesOrgasDeMesTaxID $O Name] if {$MyOrg==""} {continue} lappend LesOrgas [join $MyOrg "_"] } #Raymond: liste des orgas } set LesOrgas [string trim [join $LesOrgas "_"]] regsub -all {\[|\]|\(|\)|\,|\:} $LesOrgas "_" LesOrgas regsub -all {_{2,}} $LesOrgas "_" LesOrgas regsub -all {^_|_$} $LesOrgas "" LesOrgas set String1 $LesOrgas } #3-2 La definition ################## if {$OnVeutDef} { set Def "" if {$DeQui} { #Jean pour ARP set Def [string trim [InterrogeLesInfosDesARPs $Acc Definition]] regsub -all {\.} $Def " " Def } else { set Def [string trim [InterrogeLesInfosDesProtsDonnees $Acc Definition]] regsub -all {\.} $Def " " Def #Raymond: chaine de caracteres } set Def [string trim [join $Def "_"]] regsub -all {\[|\]|\(|\)|\,|\:|\-} $Def "_" Def regsub -all {_{2,}} $Def "_" Def regsub -all {^_|_$} $Def "" Def set String2 $Def } #3-2 La Categorie des ARPs ########################## if {$OnVeutCat} { set Cat "" if {$DeQui} { #Jean pour ARP set Cat [string trim [InterrogeLesInfosDesARPs $Acc Categorie]] regsub -all {\.} $Cat " " Cat } set Cat [string trim [join $Cat "_"]] regsub -all {\[|\]|\(|\)|\,|\:|\-} $Cat "_" Cat regsub -all {_{2,}} $Cat "_" Cat regsub -all {^_|_$} $Cat "" Cat regsub -all {Les} $Cat "" Cat set String2 $Cat } #3-3 Les EC (enzyme commission) ############################### if {$OnVeutEC} { set EC "" if {$DeQui} { #Jean pour ARP set EC "" } else { #Raymond: chaine de caractere } set EC [string trim [join $EC "_"]] regsub -all {\[|\]|\(|\)|\,|\:|\-} $EC "_" EC regsub -all {_{2,}} $EC "_" EC regsub -all {^_|_$} $EC "" EC set String2 $EC } #3-4 Les TaxID du NCBI ###################### if {$OnVeutTax} { set Tax "" if {$DeQui} { set Tax "" } else { #Raymond: Integer } set Tax [string trim [join $Tax "_"]] regsub -all {\[|\]|\(|\)|\,|\:|\-} $Tax "_" Tax regsub -all {_{2,}} $Tax "_" Tax regsub -all {^_|_$} $Tax "" Tax set Integer1 $Tax } set InsideInfo "" if {$String1!=""} { append InsideInfo ":S=$String1" } if {$String2!=""} { append InsideInfo ":E=$String2" } if {$Integer1!=""} { append InsideInfo ":T=$Integer1" } if {$InsideInfo==""} { set AddedInfo "${Acc}:${Dist}" } else { set AddedInfo "${Acc}:${Dist}\[\\&\\&NHX${InsideInfo}\]" } return $AddedInfo } proc LesInteractionsString8.3 {protId {seuil ""} Org {WithoutTextMiningOnly ""} {GetWhat ""}} { #Attention pour les versions anterieures a 9.0 CanalSqlString #a verif que notre protId ne soit pas que dans protein_id_b (voir where) set LocalWithoutTextMiningOnly [string equal -nocase $WithoutTextMiningOnly "WithoutTextMiningOnly"] if {$seuil==""} { set seuil [SeuilStringInteractomeDefaut] } set idx 0 set LesInteractions {} set Sql "select protein_id_a, protein_id_b, combined_score, equiv_nscore, equiv_nscore_transferred, equiv_fscore, equiv_pscore, equiv_hscore, array_score, array_score_transferred, experimental_score, experimental_score_transferred, database_score, database_score_transferred, textmining_score, textmining_score_transferred from network.protein_protein_links where protein_id_a = '$protId' and combined_score >= '$seuil' order by combined_score DESC;" foreach {Pi1 Pi2 Cs Ns Nst Fs Ps Hs As Ast Es Est Ds Dst Ts Tst} [SqlExec $Sql "GetList"] { set idx 1 set evidence "" if { $LocalWithoutTextMiningOnly && [expr $Ts+$Tst > 0] && [expr $Ns+$Nst+$Fs+$Ps+$Hs+$As+$Ast+$Es+$Est+$Ds+$Dst==0]} { continue } if {$Ns != 0} { append evidence "neighborhood $Ns " } if {$Nst != 0} { append evidence "neighborhoodT $Nst " } if {$Fs != 0} { append evidence "fusion $Fs " } if {$Ps != 0} { append evidence "co-occ $Ps " } if {$Hs != 0} { append evidence "homology $Hs " } if {$As != 0} { append evidence "array $As " } if {$Ast != 0} { append evidence "arrayT $Ast " } if {$Es != 0} { append evidence "experimental $Es " } if {$Est != 0} { append evidence "experimentalT $Est " } if {$Ds != 0} { append evidence "database $Ds " } if {$Dst != 0} { append evidence "databaseT $Dst " } if {$Ts != 0} { append evidence "textmining $Ts " } if {$Tst != 0} { append evidence "textminingT $Tst " } if {$GetWhat=="GetGn"} { set Pn1 [PreferredName $Pi1 $Org] set Pn2 [PreferredName $Pi2 $Org] #PourWscope lappend LesInteractions "$Pn1\tpp\t$Pn2" lappend LesInteractions "$Pi1\t$Pn1\t$Pi2\t$Pn2\t$Cs\t$evidence" } if {$GetWhat=="GetSw"} { regsub "_" $Org " " OrgProv set TaxId [TaxIdOrg $OrgProv] set Sw1 [SwFromProtIDString9 $Pi1 $TaxId] set Sw2 [SwFromProtIDString9 $Pi2 $TaxId] lappend LesInteractions "$Pi1\t$Sw1\t$Pi2\t$Sw2\t$Cs\t$evidence" } } Espionne "I found [llength $LesInteractions] interactions for $protId" return $LesInteractions } proc LesInteractionsString9.0 {protId {seuil ""} Org {WithoutTextMiningOnly ""} {GetWhat ""}} { if {$GetWhat==""} { set GetWhat "GetGn" } CanalSqlString set LocalWithoutTextMiningOnly [string equal -nocase $WithoutTextMiningOnly "WithoutTextMiningOnly"] if {$seuil==""} { set seuil [SeuilStringInteractomeDefaut] } set LesInteractions {} set Sql "select node_id_a, node_type_b, node_id_b, combined_score, evidence_scores from network.node_node_links where node_id_a = '$protId' and combined_score >= '$seuil' order by combined_score DESC;" foreach {Pi1 Bidon Pi2 Cs LesEs} [SqlExec $Sql "GetList"] { set evidence "" ; set trouveTextMining 0; set trouveAutreChose 0 foreach Es [split $LesEs "{}"] { if {$Es=="" || $Es==","} {continue} set EsDetails [split $Es ","] set ScoId [lindex $EsDetails 0] if {$ScoId==12 || $ScoId==13} {set trouveTextMining 1} if {$ScoId!=12 && $ScoId!=13} {set trouveAutreChose 1} set Sco [lindex $EsDetails 1] append evidence "[InterrogeEvidenceTable $ScoId ScoTy] $Sco " } if {$LocalWithoutTextMiningOnly && $trouveTextMining==1 && $trouveAutreChose==0} {continue} if {[regexp -nocase "Gn" $GetWhat]} { set Pn1 [PreferredName $Pi1 $Org] set Pn2 [PreferredName $Pi2 $Org] #PourWscope lappend LesInteractions "$Pn1\tpp\t$Pn2" } if {[regexp -nocase "Sw" $GetWhat]} { regsub "_" $Org " " OrgProv set TaxId [TaxIdOrg $OrgProv] set Sw1 [SwFromProtIDString10 $Pi1 $TaxId] set Sw2 [SwFromProtIDString10 $Pi2 $TaxId] } if { [regexp -nocase "Gn" $GetWhat] && ! [regexp -nocase "Sw" $GetWhat] } { lappend LesInteractions "$Pi1\t$Pn1\t$Pi2\t$Pn2\t$Cs\t$evidence" } if { [regexp -nocase "Sw" $GetWhat] && ! [regexp -nocase "Gn" $GetWhat] } { lappend LesInteractions "$Pi1\t$Sw1\t$Pi2\t$Sw2\t$Cs\t$evidence" } if { [regexp -nocase "Gn" $GetWhat] && [regexp -nocase "Sw" $GetWhat] } { lappend LesInteractions "$Pi1\t$Pn1\t$Sw1\t$Pi2\t$Pn2\t$Sw2\t$Cs\t$evidence" } } Espionne "I found [llength $LesInteractions] interactions for $protId" CanalSqlDisconnect return $LesInteractions } proc LesInterproDeLAccess {Access} { set Commande "[ProgPathway getz] \"\(\\\[protein\-acc:$Access\\\]\|\\\[protein\-id:$Access\\\]\)>iprmatches\" \-view IprMatchesView" catch {set Out [eval exec $Commande]} Message if {![info exists Out]} {return} set LesInterpro {} foreach Ligne [split [string trim $Out] "\n"] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set Pos [string first ":" $Ligne] if {$Pos < 0 && [regexp {^([0-9]+)\-([0-9]+)} $Ligne tmp Debut Fin]} { lappend LesInterpro [list $Access $IPR $DefIPR $Debut $Fin $Domaine $DefDom] } set MotAvant [string trim [string range $Ligne 0 [expr $Pos-1]]] set Apres [string trim [string range $Ligne [expr $Pos+1] end ]] if {[string equal -nocase $MotAvant "IPRMATCHES"]} { set Pos [string first " " $Apres] set Access [string trim [string range $Apres 0 [expr $Pos-1]]] continue } if {[string equal -nocase $MotAvant "Interpro"]} { set Pos [string first " " $Apres] if {$Pos < 0} { set IPR [string trim [string range $Apres 0 end ]] set DefIPR "" } else { set IPR [string trim [string range $Apres 0 [expr $Pos-1]]] set DefIPR [string trim [string range $Apres [expr $Pos+1] end ]] } continue } if {$MotAvant != ""} { set Banque $MotAvant set Pos [string first " " $Apres] if {$Pos < 0} { set Domaine [string trim [string range $Apres 0 end ]] set DefDom "" } else { set Domaine [string trim [string range $Apres 0 [expr $Pos-1]]] set DefDom [string trim [string range $Apres [expr $Pos+1] end ]] } continue } } return $LesInterpro } proc LesJRTouchantUnChromo {Chromo FichierClusters} { set LesClonesDuChromo [QuiToucheChroContig $Chromo] set LesNoms [split $LesClonesDuChromo " "] set LesJR {} foreach JR [ListeMinimumDesJR $FichierClusters] { #Espionne $JR set Vu($JR) 1 } foreach Nom $LesNoms { if {![info exists Vu($Nom)]} {continue} lappend LesJR $Nom } set NbJR [llength $LesJR] #Espionne "JR:$NbJR" return $LesJR } proc LesJRsAvecMemesAccessDeProtOuDemRNAPourUnPAB {PAB FichierClusters} { #avec le fichier clusters obtenus par les overlaps set LesAccessProtAChercher [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] if {$LesAccessProtAChercher!=""} { set LesAccessAChercher $LesAccessProtAChercher } else { set LesAccessAChercher [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" mRNA Access] } foreach Nom [ListeDesJR $FichierClusters] { set LesAccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$LesAccessProt !=""} { foreach AccessProt $LesAccessProt { lappend LesAccessNom "$AccessProt $Nom" } } else { set LesAccessRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$LesAccessRNA!=""} { foreach AccessRNA $LesAccessRNA { lappend LesAccessNom "$AccessRNA $Nom" } } } } set LesAccessNomTries [lsort -dictionary $LesAccessNom] set ListeDesJumeaux {} foreach AccessNom $LesAccessNomTries { set Nom [lindex $AccessNom end] set Access [lindex $AccessNom 0] foreach AccessPAB $LesAccessAChercher { if {$Access==$AccessPAB && $Nom!=$PAB} { lappend ListeDesJumeaux $Nom } } } #si par exemple 2 access pour le pab #et s il existe d autres pabs avec ses 2 access #alors il y aura des doublons dans la liste #### elimination des doublons: correction de la liste a retourner ###### set ListeDesJumeauxCorrigee {} foreach Jumeau $ListeDesJumeaux { if {![info exists Vu($Jumeau)]} { set Vu($Jumeau) 1 lappend ListeDesJumeauxCorrigee $Jumeau } else {continue} } return $ListeDesJumeauxCorrigee } proc LesJumeauxDeSequencesDuPremier {Nom} { set FichierJumSeqNuc "[RepertoireDuGenome]/fiches/jumeaux_SeqNuc" foreach Ligne [LesLignesDuFichier $FichierJumSeqNuc] { set LesJumeaux [split $Ligne " "] set Premier [lindex $LesJumeaux 0] if {$Premier==$Nom} {set LsansPremier [lreplace $LesJumeaux 0 0]; return $LsansPremier} } return "" } proc LesJumeauxDuPAB {PAB FichierClusters} { foreach Ligne [LesLignesDuFichier $FichierClusters] { if {$Ligne==""} {continue} set Ligne [split $Ligne " "] set n 0 foreach Nom $Ligne { if {$Nom==$PAB} { set Noms [join $Ligne " "] #FaireLire $Noms regsub "$PAB" $Noms "" Noms regsub " " $Noms " " Noms set Noms [string trim $Noms] set LesNoms [split $Noms " "] return $LesNoms } } } return } proc LesKeywordsInteressantsDuGenbank {TexteOuFichier aTab args} { if {[regexp "\n" $TexteOuFichier]} { set Texte $TexteOuFichier } else { set Texte [ContenuDuFichier $TexteOuFichier] } upvar $aTab Tab set LesKW $args foreach KW $LesKW { set Tab($KW) "" } foreach Ligne [split $Texte "\n"] { if {[regexp {^[^ ]} $Ligne]} { scan $Ligne "%s" KW set Interessant [expr [lsearch $LesKW $KW] > -1] if {$Interessant} {set Tab($KW) "" ; set Sep ""} } if {$Interessant} { append Tab($KW) "$Sep$Ligne" set Sep "\n" } } if {[llength $LesKW]==1} { return $Tab([lindex $LesKW 0]) } return $LesKW } proc LesLca {Nom} { set L [ExtraitInfo $Nom "LCA:"] regsub -all " / " $L "/" L return [split $L "/"] } proc LesLibrariesOuOptionsSpeciesAutomatiques {Organisme {NbPhylumEnCommunMin 5}} { if {$Organisme == ""} {return [InterrogeLibrariesRepeatMasker Organisme "Homo sapiens" LesLibraries]} if {[InterrogeLibrariesRepeatMasker Organisme $Organisme LesLibraries] != ""} { return [InterrogeLibrariesRepeatMasker Organisme $Organisme LesLibraries] } if {[regexp -nocase {human|^homo } $Organisme]} { return [InterrogeLibrariesRepeatMasker Organisme "Homo sapiens" LesLibraries] } if {[regexp -nocase {mouse|^mus |^rattus } $Organisme]} { return [InterrogeLibrariesRepeatMasker Organisme "Mus musculus" LesLibraries] } if {[regexp -nocase "arabidopsis" $Organisme]} { return [InterrogeLibrariesRepeatMasker Organisme "Arabidopsis thaliana" LesLibraries] } if {[string equal -nocase $Organisme "elegans" ]} { return [InterrogeLibrariesRepeatMasker Organisme "Caenorhabditis elegans" LesLibraries] } if {[string equal -nocase $Organisme "drosophila"] || [regexp -nocase "Drosophila|fly" $Organisme]} { return [InterrogeLibrariesRepeatMasker Organisme "Drosophila melanogaster" LesLibraries] } if {[string equal -nocase $Organisme "rat"]} { return [InterrogeLibrariesRepeatMasker Organisme "Rattus norvegicus" LesLibraries] } if {[string equal -nocase $Organisme "danio.lib"] || [regexp -nocase "Danio" $Organisme]} { return "danio.lib" } if {[string equal -nocase $Organisme "Bos taurus"] || [regexp -nocase "cow" $Organisme]} { return "cow" } set LesOrganismes [InterrogeLibrariesRepeatMasker LesOrganismes] lappend LesOrganismes "Vertebrata" "Mammalia" "Bos taurus" set LesPhylums [lindex [InterrogeClassificationTaxonomique $Organisme LesPhylums] 0] set LesLibrariesSelect {} set NbPhylumEnCommunMax 0 foreach Specie $LesOrganismes { set LesPhylumsDesSpecies [lindex [InterrogeClassificationTaxonomique $Specie LesPhylums] 0] set NbPhylumEnCommun 0 foreach Phylum $LesPhylums Phylum2 $LesPhylumsDesSpecies { if {$Phylum != $Phylum2} {break} incr NbPhylumEnCommun } Espionne "$Specie $NbPhylumEnCommun" if {$NbPhylumEnCommun < $NbPhylumEnCommunMax} {continue} set LesLibraries [InterrogeLibrariesRepeatMasker Organisme $Specie LesLibraries] if {$Specie == "Vertebrata"} {set LesLibraries [InterrogeLibrariesRepeatMasker Organisme "Other vertebrates" LesLibraries]} if {$Specie == "Mammalia" } {set LesLibraries [InterrogeLibrariesRepeatMasker Organisme "Other mammalians" LesLibraries ]} if {$Specie == "Bos taurus"} {set LesLibraries [list "cow"]} if {$NbPhylumEnCommunMax < $NbPhylumEnCommun} { set LesLibrariesSelect $LesLibraries set NbPhylumEnCommunMax $NbPhylumEnCommun continue } foreach Library $LesLibraries {lappend LesLibrariesSelect $Library} } if {$NbPhylumEnCommunMax < $NbPhylumEnCommunMin} {return} return [lsort -unique $LesLibrariesSelect] } proc LesLigneesUsageUnique {} { foreach AppeleeAppelante [LesProceduresUsageUnique] { scan $AppeleeAppelante "%s %s" Appelee Appelante set AppelanteDe($Appelee) $Appelante lappend AppeleePar($Appelante) $Appelee # Espionne "set AppelanteDe($Appelee) $Appelante" # Espionne "lappend AppeleePar($Appelante) $Appelee > [set AppeleePar($Appelante)]" lappend LesUsageUnique $Appelee } foreach Procedure $LesUsageUnique { if {[info exists AppeleePar($Procedure)]} { # Espionne "j'abandonne $Procedure car appelante de [set AppeleePar($Procedure)]" continue } set LaLignee {} lappend LaLignee $Procedure while 1 { if {[info exists AppelanteDe($Procedure)]} { set Procedure [set AppelanteDe($Procedure)] lappend LaLignee $Procedure } else { break } } Espionne "[llength $LaLignee] [join $LaLignee " "]" } } proc LesLignesDesJumeauxAccessProt {ListeNoms FichierRedondance} { set JR [TrouveLeOldJR $ListeNoms] if {$JR==""} { set LesJumeaux [split $ListeNoms " "] set JR [lindex $LesJumeaux 0] } set AccessProtAChercher [InterrogeProtAndmRNAChoisis $JR ProteineChoisie Access] if {$AccessProtAChercher!="" && $AccessProtAChercher!="NOPROTEIN"} { set LesLignesDeJumeaux {} #set NewLigne "" foreach Ligne [LesLignesDuFichier $FichierRedondance] { set Nom [TrouveLeOldJR $Ligne] if {$Nom==""} { set LesJumeaux [split $Ligne " "] set Nom [lindex $LesJumeaux 0] } set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {$AccessProt!="" && $AccessProt!="NOPROTEIN" && $AccessProt==$AccessProtAChercher && $Nom!=$JR} { lappend LesLignesDeJumeaux $Ligne #set NewLigne [concat $NewLigne $Ligne] } } #return [concat $ListeNoms $NewLigne] return $LesLignesDeJumeaux } return "" } proc LesLignesDuFichier {{Fichier ""}} { if { $Fichier == "" } {return {}} if {[regexp -nocase {https?\://|ftp\://} $Fichier]} { return [split [HttpCopy $Fichier] "\n"] } ;#rR 2014/07/02 if {[regexp {\.gz$} $Fichier]} { return [split [exec zcat $Fichier] "\n"] } set LesLignes {} set f [open $Fichier r] while {[gets $f Ligne]>=0} { lappend LesLignes $Ligne } close $f return $LesLignes } proc LesLignesDuGz {Fichier} { set f [open $Fichier] zlib push gunzip $f set LesLignes {} while {[gets $f Ligne]>=0} { lappend LesLignes $Ligne } close $f return $LesLignes } proc LesLignesDuTexte {Texte} { return [split $Texte "\n"] } proc LesLignesEntreExpressionsDuFichier {Fichier A B {BExclu SecondExcluded}} { if {$BExclu=="SecondIncluded"} { set BExclu 1 } else { set BExclu 0 } set OnYEst 0 set LesBonnes {} foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp $A $Ligne]} { set OnYEst 1 } if {[regexp $B $Ligne] && $BExclu} { break } if {$OnYEst} { lappend LesBonnes $Ligne } if {[regexp $B $Ligne]} { break } } return $LesBonnes } proc LesLignesIaJDuFichier {Fichier i j} { return [lrange [LesLignesDuFichier $Fichier] $i $j] # return [lrange [LesPremieresLignesDuFichier $Fichier $j] [incr i -1] end] } proc LesLignesTrieesSurUneClefEntete {LesLignes LesIndices} { if {$LesIndices=={}} { return $LesLignes } set Indice [lindex $LesIndices 0] set Car "_" set LesLignesTriees {} set LesClefs {} foreach Ligne $LesLignes { set Entete "" scan $Ligne "%s" Entete if {$Entete==""} { continue } set LesMots [split $Entete $Car] set Clef [lindex $LesMots $Indice] lappend LesLignesPour($Clef) $Ligne lappend LesClefs $Clef } foreach Clef [lsort -unique $LesClefs] { set LesLignes [set LesLignesPour($Clef)] foreach Ligne $LesLignes { lappend LesLignesTriees $Ligne } } return [LesLignesTrieesSurUneClefEntete $LesLignesTriees [lrange $LesIndices 1 end]] } proc LesLignesVitales {Fichier {SansVide ""} {SansBlanc ""}} { set SansVide [string equal -nocase $SansVide "SansVide"] set SansBlanc [string equal -nocase $SansBlanc "SansBlanc"] Wup "Returns the lists of the lines from Fichier, accepts continuation and ignores # or empty lines" set LesVitales {} set Lu "" foreach Ligne [LesLignesDuFichier $Fichier] { if {$SansBlanc} { regsub -all " " $Ligne "" Ligne } if {[regexp {\#} $Ligne]} { regsub {\#.*$} $Ligne "" Ligne } if {$SansVide && [string trim $Ligne]==""} { continue } if { ! [regexp -nocase {[^ ]} $Ligne]} { continue } if {[regexp {\\$} $Ligne]} { regsub {\\$} $Ligne "" Ligne append Lu $Ligne } else { append Lu $Ligne lappend LesVitales $Lu set Lu "" } } return $LesVitales } proc LesLocalisationDesPSORTII {} { Wup "Les localisations cellulaires possibles donnees par PSORTII" set lesLocsPossibles [list "extracellular" "cytoplasmic" "nuclear" "mitochondrial" "peroxisomal" "Golgi" "endoplasmic reticulum" "vacuolar" "vesicles of secretory system" "plasma" "cytoskeletal"] return "$lesLocsPossibles" } proc LesLocalisationsSurChroContig {NomVoulu} { global LesLocalisationsSurChroContig global RepertoireDuGenome JeMeSignale if {[info exists LesLocalisationsSurChroContig($NomVoulu)]} { return [set LesLocalisationsSurChroContig($NomVoulu)] } if {[info exists LesLocalisationsSurChroContig("EstCharge")]} { return [set LesLocalisationsSurChroContig("EstCharge")] } set Fichier "$RepertoireDuGenome/fiches/localisationchrocontig" if {[file exists $Fichier]} { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" Nom regsub "$Nom " $Ligne "" Ligne lappend LesLocalisationsSurChroContig($Nom) $Ligne } set LesLocalisationsSurChroContig("EstCharge") [list "No value"] return [LesLocalisationsSurChroContig $NomVoulu] } if {$NomVoulu=="Create"} { set Liste [ListeDesPABs] set CreeFichier 1 } else { set Liste [list $NomVoulu] set CreeFichier 0 } foreach Nom $Liste { set LesHomologues [ChaqueSegmentDuBlastN $Nom] set LesChroContig($Nom) {} set OldChroContig "" foreach Homologue $LesHomologues { scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin if {[expr $E > 1.e-3] } { continue } regsub {\:} $ChroContigTroncon " " ChroContigTroncon regsub {_} $ChroContigTroncon " " ChroContigTroncon set Troncon 0 scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon set Troncon [Base10 $Troncon] regsub {^0} $Chro "" Chro if {![info exists DejaVu($Nom,$Chro,$Contig)]} { set DejaVu($Nom,$Chro,$Contig) 1 if {$Deb<$Fin} { set MeilleureGauche($Nom,$Chro,$Contig) $Deb set MeilleureDroite($Nom,$Chro,$Contig) $Fin } else { set MeilleureGauche($Nom,$Chro,$Contig) $Fin set MeilleureDroite($Nom,$Chro,$Contig) $Deb } lappend LesNomChroContigDansLOrdre($Nom) "$Nom,$Chro,$Contig" } lappend LesHomologuesDe($Nom,$Chro,$Contig) $Homologue } if {[info exists DejaVu]} { unset DejaVu } if { ! [info exists LesNomChroContigDansLOrdre($Nom)]} { continue } foreach NCC [set LesNomChroContigDansLOrdre($Nom)] { foreach Homologue [set LesHomologuesDe($NCC)] { scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin regsub {\:} $ChroContigTroncon " " ChroContigTroncon regsub {_} $ChroContigTroncon " " ChroContigTroncon set Troncon 0 scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon set Troncon [Base10 $Troncon] regsub {^0} $Chro "" Chro if {![info exists DejaVu($Nom,$Chro,$Contig)]} { lappend LesChroContig($Nom) "$Chro $Contig" set DejaVu($Nom,$Chro,$Contig) 1 } lappend LesPositions($Nom,$Chro,$Contig) $Deb $Fin if {[expr $Deb < $Fin]} { set Sens($Nom,$Chro,$Contig) "+" } else { set Sens($Nom,$Chro,$Contig) "-" } } set LesLocas {} foreach Loc [set LesChroContig($Nom)] { scan $Loc "%s %s" Chro Contig set LesPosTriees [lsort -integer [set LesPositions($Nom,$Chro,$Contig)]] set MG [set MeilleureGauche($Nom,$Chro,$Contig)] set iMG [lsearch $LesPosTriees $MG] while 1 { if {$iMG<=0} { break } set NewMG [lindex $LesPosTriees [incr iMG -1]] if {[expr $NewMG + 100000 < $MG]} { break } set MG $NewMG } set MD [set MeilleureDroite($Nom,$Chro,$Contig)] set iMD [lsearch $LesPosTriees $MD] set L [expr [llength $LesPosTriees] -1] while 1 { if {$iMD>=$L} { break } set NewMD [lindex $LesPosTriees [incr iMD 1]] if {[expr $MD + 100000 < $NewMD]} { break } set MD $NewMD } set Gauche $MG set Droite $MD set Orient [set Sens($Nom,$Chro,$Contig)] Espionne "LesLocalisation sur $Nom $Chro $Contig $Gauche $Droite $Orient" lappend LesLocas "$Chro $Contig $Gauche $Droite $Orient" } } if {$CreeFichier} { set LesLocalisationsSurChroContig($Nom) $LesLocas foreach Lo $LesLocas { AppendAuFichier $Fichier "$Nom $Lo" } } else { return $LesLocas } set LesLocalisationsSurChroContig("EstCharge") [list "No value"] } if {$CreeFichier} { return $Fichier } return [LesLocalisationsSurChroContig $NomVoulu] } proc LesLocalisesAvecProteine {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] set n 0 set NbContig 0 set RepProttfa "[RepertoireDuGenome]/prottfa" foreach Nom $Liste { if {[PolyLocalise $Nom]!="NoLocalization"} { set Fichier "$RepProttfa/$Nom" if {[file exists $Fichier]} { set Contenu [ContenuDuFichier $Fichier] if {[regexp "CONTIG" $Contenu]} {incr NbContig} incr n } } } Espionne $NbContig return $n } proc LesLocalisesSansRien {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] set n 0 set RepProttfa "[RepertoireDuGenome]/prottfa" foreach Nom $Liste { if {[PolyLocalise $Nom]!="NoLocalization"} { set Fichier "$RepProttfa/$Nom" if {![file exists $Fichier]} { set LesCopsEST [LesMeilleursCopainsDuBlast $Nom "blastnest"] if {$LesCopsEST=={} ||[lindex $LesCopsEST 0]=="File not yet available" ||[lindex $LesCopsEST 0]=="No value" ||[lindex $LesCopsEST 0]=="No hit"} { set LesCopsGenembl [LesMeilleursCopainsDuBlast $Nom "blastngenembl"] if {$LesCopsGenembl=={} ||[lindex $LesCopsGenembl 0]=="File not yet available" ||[lindex $LesCopsGenembl 0]=="No value" ||[lindex $LesCopsGenembl 0]=="No hit"} {incr n} } } } } return $n } proc LesLocsDesProbesAffy {FichierRMA FichierProbesets FichierSortie FichierSortieAbsents} { if {![file exists $FichierProbesets]} { foreach Ligne [LesLignesDuFichier $FichierRMA] { set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp "probeset" $Ligne]} {continue} set LesElts [split $Ligne "\t"] set probeset [lindex $LesElts 0] lappend LesProbesets $probeset } SauveLesLignes $LesProbesets dans $FichierProbesets } else { foreach Ligne [LesLignesDuFichier $FichierProbesets] { lappend LesProbesets $Ligne } } #FaireLire "nb probesets: [llength $LesProbesets]" set LesProbeSets [lsort -unique $LesProbesets] #FaireLire "nb probesets UNIQ: [llength $LesProbesets]" set probeset "" foreach probeset $LesProbeSets { Espionne $probeset set LesChros "" set LesChros [InterrogeAffy_UCSC "" human $probeset Chromosome] if {$LesChros==""} { AppendAuFichier $FichierSortieAbsents "$probeset" } foreach chro $LesChros { set LesDebuts "" set LesDebuts [InterrogeAffy_UCSC "" human $probeset $chro Debut] set LesFins [InterrogeAffy_UCSC "" human $probeset $chro Fin] foreach Debut $LesDebuts Fin $LesFins { AppendAuFichier $FichierSortie "$probeset\t$chro\t$Debut\t$Fin" } } } } proc LesLongueurs {FichierTFAs} { foreach Sale [LesLignesDuFichier $FichierTFAs] { if {[regexp "^>" $Sale]} { scan $Sale "%s" Access if {[info exists LongSale]} { puts "$LongSale $LongPropre $Access" } set LongSale 0 set LongPropre 0 } regsub -all -nocase {[^a-z]} $Sale "" Propre incr LongSale [string length $Sale] incr LongPropre [string length $Propre] } puts "$LongSale $LongPropre $Access" exit } proc LesLongueursDesProteines {{GetWhat ""}} { set LaSortie {} foreach Nom [ListeDesPABs] { set SeqPro [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"] set L [string length $SeqPro] lappend LaSortie "$Nom [Alias $Nom] $L" } if {[string equal -nocase "GetList"]} { return $LaSortie } if {[string equal -nocase "GetText"]} { return [join $LaSortie "\n"] } return [AfficheListe $LaSortie "" "Proteins Length"] } proc LesLongueursDesSequences {{Rep ""} {Quoi ""}} { if {$Rep==""} { set Rep "nuctfa" } if {$Quoi==""} { set Quoi "Histo" } foreach Nom [ListeDesPABs] { set Fic "[RepertoireDuGenome]/$Rep/$Nom" if {[FileAbsent $Fic]} {continue} set Seq [QueLaSequenceDuFichierTFA $Fic] set L [string length $Seq] lappend NomLong "$Nom $L" if { ! [info exists Histo($L)]} { set Histo($L) 0 } incr Histo($L) } if {$Quoi=="NomLongueur"} { return $NomLong } foreach L [lsort -integer [array names Histo]] { lappend LHisto "$L [set Histo($L)]" } return $LHisto } proc LesLoupes {{OrgaOuPAB ""} {SampledOnly ""} {FichierBilan ""}} { Wup "Determine dans un fichier bilanXHDA les loupes,rend des orgas pour un PAB, et vice versa" Wup "Ceci pour les Sampled uniquement ou Tous leurs PABs (si orga) leurs orgas (si PAB)" Wup "Rend aussi laListecomplete des Orgas ou PABs loupes" global RepertoireDuGenome global LesLoupes if {[info exists LesLoupes($OrgaOuPAB)]} { return [set LesLoupes($OrgaOuPAB)] } if {[info exists LesLoupes]} { return ""} if {$SampledOnly=="Tous"} {set SampledOnly 0} else {set SampledOnly 1} set RepXHda "$RepertoireDuGenome/xhda" set RepBilan "$RepertoireDuGenome/bilan_xhda" if {$FichierBilan==""} { set LesFichiersBilan [glob -nocomplain "$RepBilan/*"] } if { $FichierBilan!="" && ! [regexp "/" $FichierBilan]} { set LesFichiersBilan "$RepBilan/$FichierBilan" } #EspionneL $LesFichiersBilan set LesPABsLoupes {} foreach file $LesFichiersBilan { if { ! [file exists $file]} { continue } foreach ligne [LesLignesDuFichier $file] { scan $ligne "%s %s %d %d %d" PAB Orga T B J if { $ligne == "" } { continue } if {[CouleurHDACroises [list $T $B $J]]=="J"} { set Organisme [Glossaire $Orga Complet] if {$SampledOnly && ! [SampledOrganism $Organisme]} { continue } lappend LesLoupes($PAB) $Organisme lappend LesLoupes($Organisme) $PAB if { ! [info exists DejaVu($PAB)]} { lappend LesPABsLoupes $PAB set DejaVu($PAB) 1 } if { ! [info exists DejaVu($Organisme)]} { lappend LesOrganismesLoupes $Organisme set DejaVu($Organisme) 1 } } } } if {! [info exists LesOrganismesLoupes]} { set LesLoupes(LesOrganismesMerci) "Aucun" } else { set LesLoupes(LesOrganismesMerci) $LesOrganismesLoupes } if {! [info exists LesOrganismesLoupes]} { set LesLoupes(LesPABsMerci) "Aucun" } else { set LesLoupes(LesPABsMerci) $LesPABsLoupes } return [LesLoupes $OrgaOuPAB] } proc LesLoupesDe {Quoi} { global RepertoireDuGenome set RepXHda "$RepertoireDuGenome/xhda" if {[EstUnPAB $Quoi]} { set Fichier "$RepXHda/LoupeDeTous.parpab" if {[File exists $Fichier]} { return [LitLoupesParPAB $Fichier $Quoi] } else { return "$Fichier do not exists" } } else { set Fichier "$RepXHda/LoupeDeTous.parorga" if {[File exists $Fichier]} { return [LitLoupesParORGA $Fichier $Quoi] } else { return "$Fichier do not exists" } } } proc LesLoupesDeTous {{Fichier ""}} { Wup "Rend les Loupes ou jaunes de tous les organismes et PABs classes par PAB ou par Orga dans LoupeDeTous.parpab et LoupeDeTous.parorga" global RepertoireDuGenome set RepXHda "$RepertoireDuGenome/xhda" set RepBilan "$RepertoireDuGenome/bilan_xhda" if { $Fichier!="" && ! [regexp "/" $Fichier]} { set FichierBilan "$RepBilan/$Fichier" } if { $Fichier=="" } { set FichierBilan "" } set LesOrgas [LesLoupes "LesOrganismesMerci" "Tous" $FichierBilan] set LesPABs [LesLoupes "LesPABsMerci" "Tous" $FichierBilan] set Resultat {} foreach element $LesOrgas { lappend Resultat "[lrange $element 0 end] [LesLoupes $element "Tous" $FichierBilan]" } set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDeTous.parorga"] set Resultat {} foreach element $LesPABs { lappend Resultat "$element [join [LesLoupes $element "Tous" $FichierBilan] " "]" } set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDeTous.parpab"] return "" } proc LesLoupesDiaBac {{Fichier ""}} { Wup "Rend les Loupes ou jaunes uniquement des DiaBacs classes par PAB ou par Orga dans LoupeDiaBac.parpab et LoupeDiaBac.parorga" global RepertoireDuGenome set RepXHda "$RepertoireDuGenome/xhda" set RepBilan "$RepertoireDuGenome/bilan_xhda" if { $Fichier!="" && ! [regexp "/" $Fichier]} { set FichierBilan "$RepBilan/$Fichier" } if { $Fichier=="" } { set FichierBilan "" } set LesOrgas [LesLoupes "LesOrganismesMerci" "SampledOnly" $FichierBilan] set LesPABs [LesLoupes "LesPABsMerci" "SampledOnly" $FichierBilan] set Resultat {} foreach element $LesOrgas { lappend Resultat "[lrange $element 0 end] [LesLoupes $element "SampledOnly" $FichierBilan]" } set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDiaBac.parorga"] set Resultat {} foreach element $LesPABs { lappend Resultat "$element [join [LesLoupes $element "SampledOnly" $FichierBilan] " "]" } set Ok [SauveLesLignes $Resultat dans "$RepXHda/LoupeDiaBac.parpab"] return "" } proc LesMacs {{quoi name}} { if {! [info exists ::db]} { return "" } elseif {$quoi eq "name"} { return [$::db eval {select name from mac}] } else { return [$::db eval {select pk_mac from mac}] } } proc LesManquants {} { foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/bilancompl/*"] { set Old [file tail $Fichier] set New [NouveauNom $Old] if {$New==""} { File delete -force $Fichier } else { if {![file exists "[RepertoireDuGenome]/bilan/$New"]} { File rename -force "[RepertoireDuGenome]/bilancompl/$Old" "[RepertoireDuGenome]/bilancompl/$New" } else { File delete -force $Fichier } } } } proc LesMatchTFBSSelectedPourPromAn {FileTFA Profile {TSSPosition 10001}} { set LesInfos {} set ResultType "TFBSResearch" set FileOUT "$FileTFA.Match_$Profile" #Execution du programme Match sur FileTFAMatchMasked Match $FileTFA $FileOUT $Profile AskMatch unset AskMatchMatrixAccess2Id2Name unset foreach Motif [AskMatch $FileOUT LesMotifs] { Espionne $Motif #Un motif par core de matrice puis x presence par matrice complete ayant ce core set NbPresence [AskMatch $FileOUT Motif $Motif NbPresence] for {set Presence 1} {$Presence <= $NbPresence} {incr Presence} { #Espionne "$Motif $Presence" ###Selection selon le sens, elimination des "-" set Sens [AskMatch $FileOUT Motif $Motif n $Presence Sens] set Debut [AskMatch $FileOUT Motif $Motif n $Presence Debut] set Fin [AskMatch $FileOUT Motif $Motif n $Presence Fin] #Attention, la TSSDist est la dist entre le tss et la fin si en 5' et le debut si en 3' #Attention, pour l'instant la tss dist est calculee par rapport a la 1ere base du 1er exon et non par rapport au tss de ref!!! set TSSDist1 [expr -1 * ($TSSPosition - $Debut)] set TSSDist2 [expr -1 * ($TSSPosition - $Fin) ] if {[expr abs($TSSDist1)] < [expr abs($TSSDist2)]} {set TSSDist $TSSDist1} else {set TSSDist $TSSDist2} set ScoreCore [AskMatch $FileOUT Motif $Motif n $Presence ScoreCore] set Access [AskMatchMatrixAccess2Id2Name Id $Motif Access] set Name [AskMatchMatrixAccess2Id2Name Id $Motif Name] lappend LesInfos [list "Match_$Profile" $ResultType $Debut $Fin $Sens "" $TSSDist $ScoreCore $Name $Access $Presence] } } AskMatch unset AskMatchMatrixAccess2Id2Name unset return [lsort -index 6 -real -command CompareLaVADesNombres $LesInfos] } proc LesMauvaisInfos {} { foreach Nom [ListeDesFusions] { if { ! [EstUneFusion $Nom]} { continue } set Fusion [Fusion $Nom] if {[regexp "/" $Fusion]} {Informe $Nom} continue Espionne "\n\n\nFusion $Fusion" foreach Fus [split $Fusion "/"] { set NomA [StringApres "obtained by fusion of " dans $Fus] set PartA [ExtraitInfo $NomA "PartAofFusion"] Espionne "$NomA est PartA \n$PartA" set Double [StringSuivant "obtained by fusion of " dans $Fus] set BonneA [StringSuivant "obtained by fusion of " dans $PartA] if {$BonneA==$Double} { continue } Espionne "Je sucre $Fus" continue if {[regexp "because frameshift between" $Fus]} { set NomB [StringApres "obtained by fusion of $NomA and " dans $Fus] set PartB [ExtraitInfo $NomB "PartBofFusion"] Espionne "$NomB est PartB \n$PartB" } } } } proc LesMeilleursCopainsDuBlast {Nom {Rep blastngenembl}} { global LesMeilleursCopainsDuBlast global RepertoireDuGenome if {[info exists LesMeilleursCopainsDuBlast($Nom,$Rep)]} { return [set LesMeilleursCopainsDuBlast($Nom,$Rep)] } if {[info exists LesMeilleursCopainsDuBlast("EstCharge",$Rep)]} { return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)] } set Fichier "$RepertoireDuGenome/fiches/cops_$Rep" if { ! [file exists $Fichier]} { set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "File not yet available"] return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)] } foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } scan $Ligne "%s" NomLu regsub "$NomLu " $Ligne "" Cop lappend LesMeilleursCopainsDuBlast($NomLu,$Rep) $Cop } set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "No value"] return [LesMeilleursCopainsDuBlast $Nom $Rep] } proc LesMeilleursOntarioDeNosSequencesParBlast {{LesPABs ""}} { Wup "Permet de determiner les access equivalents de nos sequences dans la puce Ontario" Wup "Recherche faite au moyen de blast" set RepOntario "[RepertoireDuGenome]/Autres_Puces/Ontario/" set RepBanque "$RepOntario/blastn" if {$LesPABs==""} {set LesPABs [ListeOligos]} foreach PAB $LesPABs { set FichierBlast "$RepBanque/$PAB" set Identity 0.95 set PCoverQuery 0.90 set PCoverSubject 0.90 set TailleQuery [AskBlast $FichierBlast Taille] set NomQuery [AskBlast $FichierBlast Query] set NbSbjct [AskBlast $FichierBlast NbSubject] if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} set LesProches "" for {set i 1} {$i <=$NbSbjct} {incr i} { set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [AskBlast $FichierBlast Subject $i] #Pourcentage d'identite global: Aligne sur Total dans les alignements #Discremine les plus proches identiques sur les alignements des autres set IdGlobal [PourcentageDIdentiteGlobal $FichierBlast $BId] if {$IdGlobal<=$Identity} {continue} #Pourcentage d'identite etendu : Aligne sur Alignable #Discremine les identiques locaux (ex: poly A) de ceux bien alignes #PCoverQuery Query par rapport au Subject #set PRecouvrementQuery [PourcentageDeRecouvrement $FichierBlast $BId "Query"] #PCoverSubject Subject par rapport au Query set PRecouvrementSubject [PourcentageDeRecouvrement $FichierBlast $BId "Subject"] #Espionne ">>$BId IdGlobal $IdGlobal Cover S/Q $PRecouvrementQuery Cover Q/S $PRecouvrementSubject" #Espionne ">>$BId IdGlobal $IdGlobal Cover Q/S $PRecouvrementSubject" if {$PRecouvrementSubject <= $PCoverSubject} {continue} lappend LesProches $BId } AskBlast unsetfile $FichierBlast } return $LesProches } proc LesMeilleursOntarioDeNosSequencesParReference {{LesPABs ""}} { Wup "Permet de determiner les access equivalents de nos sequences dans la puce Ontario" Wup "Recherche faite au moyen du texte (InterrogeAccRefSeq)" set RepOntario "[RepertoireDuGenome]/Autres_Puces/Ontario/" set RepBanque "$RepOntario/blastn" set DirOligo "[RepertoireDuGenome]/Probes/RefSeqBLAST3" if {! [file exists $DirOligo]} { set DirOligo "/genomics/Actin/Probes/RefSeqBLAST3" } if {$LesPABs==""} {set LesPABs [ListeOligos]} foreach PAB $LesPABs { set AccRefSeq "" #Pour recupere l access RefSeq set AccRefSeq [ReturnBestHitFromLogFile $PAB $DirOligo] if {[regexp "Warning" $AccRefSeq]} {set AccRefSeq [lindex $AccRefSeq 1]} #regsub "RSHUM:NM" $AccRefSeq "NM_" AccRefSeq if {$AccRefSeq==""} { Espionne "Pb avec $PAB RefSeq est vide" continue } #A partir du RefSeq on cherche l access gscope du projet PuceEST set LesAccGscope [InterrogeLesAccRSEtUG_Ontario $AccRefSeq AccGscope] #Pour chaque access gscope du projet PuceEST on extrait les OriginalID et VerifiedID set LesOriginalID "" set LesVerifiedID "" set LesProches "" foreach Gscope $LesAccGscope { set OriginalID "" set VerifiedID "" set OriginalID [InterrogeLesAccRSEtUG_Ontario $Gscope OriginalID] set VerifiedID [InterrogeLesAccRSEtUG_Ontario $Gscope VerifiedID] if {$OriginalID!=""} { lappend LesProches "${OriginalID}_${VerifiedID}" } if {$OriginalID == "" || $VerifiedID == ""} { Espionne ">>pb $PAB $Gscope" } } } return "$LesProches" } proc LesMeilleursUMCUDeNosSequencesParBlast {{LesPABs ""}} { Wup "Permet de determiner les access equivalents de nos sequences dans la puce UMCU" Wup "Recherche faite au moyen de blast" set RepUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU/" set RepBanque "$RepUMCU/blastn" switch -regexp -- $LesPABs { "ActiChip1" {set LesPABs [ActiChip1_0]} "ActiChip2" {set LesPABs [ActiChip2_0]} "default" {set LesPABs [ActiChip2_0]} } #Espionne "$LesPABs" foreach PAB $LesPABs { set FichierBlast "$RepBanque/$PAB" set Identity 0.95 set PCoverQuery 0.90 set PCoverSubject 0.90 set TailleQuery [AskBlast $FichierBlast Taille] set NomQuery [AskBlast $FichierBlast Query] set NbSbjct [AskBlast $FichierBlast NbSubject] if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} set LesProches "" for {set i 1} {$i <=$NbSbjct} {incr i} { #Le recouvrement doit etre maximal de notre Query (seq ActiChip) vers Subject (seq UMCU) #A l inverse on peut etre plus souple dans le sens S vers Q set Identity 0.95 set PCoverQuery 0.90 set PCoverSubject 0.50 set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [AskBlast $FichierBlast Subject $i] #Pourcentage d'identite global: Aligne sur Total dans les alignements #Discremine les plus proches identiques sur les alignements des autres set IdGlobal [PourcentageDIdentiteGlobal $FichierBlast $BId] if {$IdGlobal <= $Identity} {continue} #Pourcentage d'identite etendu : Aligne sur Alignable #Discremine les identiques locaux (ex: poly A) de ceux bien alignes #PCoverQuery Query par rapport au Subject set PRecouvrementQuery [PourcentageDeRecouvrement $FichierBlast $BId "Query"] Espionne ">>$PAB - $BId IdGlobal $IdGlobal Cover Q/S $PRecouvrementQuery" if {$PRecouvrementQuery <= $PCoverQuery} {continue} #PCoverSubject Subject par rapport au Query set PRecouvrementSubject [PourcentageDeRecouvrement $FichierBlast $BId "Subject"] Espionne ">>$PAB - $BId IdGlobal $IdGlobal Cover Q/S $PRecouvrementQuery Cover S/Q $PRecouvrementSubject" #Espionne ">>$PAB - $BId IdGlobal $IdGlobal Cover Q/S $PRecouvrementSubject" if {$PRecouvrementSubject <= $PCoverSubject} {continue} lappend LesProches $BId } AskBlast unsetfile $FichierBlast } return $LesProches } proc LesMeilleursUMCUDeNosSequencesParReference {{LesPABs ""}} { Wup "Permet de determiner les access equivalents de nos sequences dans la puce UMCU" Wup "Recherche faite au moyen du texte (InterrogeAccRefSeq)" set FichierUMCU "/genomics/g2/PuceUMCU/UMCU-H25k11.txt" set FichierUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU/UMCU-H25k11.txt" set RepUMCU "[RepertoireDuGenome]/Autres_Puces/UMCU/" set RepBanque "$RepUMCU/blastn" switch -regexp -- $LesPABs { "ActiChip1" {set LesPABs [ActiChip1_0]} "ActiChip2" {set LesPABs [ActiChip2_0]} "default" {set LesPABs [ActiChip2_0]} } #Espionne "$LesPABs" foreach PAB $LesPABs { set LesProches "" set AccRefSeq "" set DirOligo "[RepertoireDuGenome]/Probes/RefSeqBLAST3" if {! [file exists $DirOligo]} { set DirOligo "/genomics/Actin/Probes/RefSeqBLAST3" } if {! [file exists "$DirOligo/${PAB}.log"]} { set DirOligo "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" if {! [file exists $DirOligo]} { set DirOligo "/genomics/Actin/Probes/NewRefSeqBLAST3" } if {! [file exists "$DirOligo/${PAB}.log"]} { continue } } #Pour recuperer l access RefSeq de notre seq ActiChip set AccRefSeq [ReturnBestHitFromLogFile $PAB $DirOligo] if {[regexp "Warning" $AccRefSeq]} {set AccRefSeq [lindex $AccRefSeq 1]} if {[regexp "RSHUM:NM" $AccRefSeq]} { regsub -all "RSHUM:NM" $AccRefSeq "NM_" AccRefSeq } set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set RepNuctfa "[RepertoireDuGenome]/nuctfa" set Query "$RepmRNA/$PAB" if {[file exists $Query]} { set DesignAccess [AccessDeLaBoite $PAB mRNA] } else { set Query "$RepNuctfa/$PAB" if {[file exists $Query]} { set DesignAccess [AccessDuTFADumRNA $Query] } else {set DesignAccess ""} } if {$AccRefSeq=="" && $DesignAccess==""} { Espionne "Pb avec $PAB RefSeq et Acc du design sont vide" continue } #Pour recuperer l access sur la puce UMCU #On teste d abord l access RefSeq et apres on teste l access Genbank set Oligo_ID [InterrogeLesInfoUMCU $FichierUMCU $AccRefSeq Oligo_ID] if { $Oligo_ID == ""} { set Oligo_ID [InterrogeLesInfosUMCU $FichierUMCU $DesignAccess Oligo_ID] if {$Oligo_ID == ""} {continue} #Si l access Genbank de notre ActiChip existe sur UMCU on le garde lappend LesProches "$DesignAccess" #Espionne "$PAB -- $DesignAccess -- $Oligo_ID" continue } #Si l access RefSeq de notre ActiChip existe sur UMCU on le garde lappend LesProches "$AccRefSeq" #Espionne "$PAB -- $AccRefSeq -- $Oligo_ID" } return "$LesProches" } proc LesMembresDeLaFamille {Nom} { global RepertoireDuGenome set RepFamille "$RepertoireDuGenome/xhda/famille" if {[file exists "$RepFamille/${Nom}.fam"] && [file size "$RepFamille/${Nom}.fam"]!=0} { set FichierFamille "$RepFamille/${Nom}.fam" } else { return "" } foreach ligne [LesLignesDuFichier $FichierFamille] { scan $ligne "%s %s %s" FPP PAB orga set Famille [lindex [split $FPP "_"] 0] lappend LesORGAsPABs $orga lappend LesORGAsPABs $PAB } return $LesORGAsPABs } proc LesMemesDansPGSetXGS {} { Wup "Recherche les target identiques dans XGS et PGS ..." Wup "Il faut, apres, supprimer la ligne du XGS dans XGS.txt" set Page [SpineSummary "RetourneTexte"] foreach Ligne [split $Page "\n"] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } ScanLaLigneSpine $Ligne X Al Ac SpOk SpTsk Owner Or if {[EstUnPAB $X]} { lappend DejaVuAl($Al) $Ligne lappend DejaVuAc($Ac) $Ligne continue } if {[regexp "XGS" $X]} { set Vu "" if {[info exists DejaVuAl($Al)]} { append Vu [join $DejaVuAl($Al) "\n"] } if {[info exists DejaVuAc($Ac)]} { append Vu [join $DejaVuAc($Ac) "\n"] } if {$Vu==""} { continue } set Memes "$Ligne\n\n$Vu" set R [AfficheVariable $Memes "AvecRetourGrandeLargeur"] } } } proc LesMetsTropLoin {{Quoi faux}} { foreach Nom [ListeDesPABs] { set Valeur [CodonStart $Nom] if {$Valeur==""} { continue } foreach {M P As} [split $Valeur " "] { set Poch [ExtraitInfo $Nom "met"] if {[regexp "faux" $Poch]} { lappend Lesfaux "$P faux $Nom" } if {[regexp "ok" $Poch]} { if {[info exists DejaVu($Nom)]} { continue } lappend Lesok "$P ok $Nom" } if {[regexp "plau" $Poch]} { if {[info exists DejaVu($Nom)]} { continue } lappend Lesplau "$P plau $Nom" } set DejaVu($Nom) 1 } } return [join [set Les$Quoi] "\n"] } proc LesMillionsEtLesScoresPourTousLesClustersDunChromo {Chromo {NbVoisins 6} {SeuilTolerance 2}} { #Chromo doit etre de la forme HS.... if {![regexp "^HS" $Chromo]} {return "Please, give a chromosome beginning by HS"} set ScoreMaxGlobal [ScoreMaxGlobal $NbVoisins] set ScoreMaxChromo [ScoreMaxChro $Chromo $NbVoisins] set ValeurSeuil [expr $ScoreMaxGlobal/$SeuilTolerance] if {$ScoreMaxChromo<=$ValeurSeuil} {return {}} set NbNoms 0 set LesClusters {} set Liste [LesNNScores $Chromo $NbVoisins] set ScoreMaxCluster 0 foreach Element $Liste { scan $Element "%s %d %s %d %d" nom score chro debut fin if {$score>$ValeurSeuil} { #Espionne $Element incr NbNoms if {$NbNoms==1} { set ScoreMaxCluster $score set BorneInf $debut } if {$NbNoms>=2} { if {$score>$ScoreMaxCluster} {set ScoreMaxCluster $score} set BorneSup $fin } } else { if {$NbNoms>=2} { set MillionDebut [expr round ($BorneInf/1000000) +1] set MillionFin [expr round ($BorneSup/1000000) +1] if {$MillionDebut!=$MillionFin} { set NbMillions [expr ($MillionFin-$MillionDebut)] if {$NbMillions==1} { lappend LesClusters "$Chromo $MillionDebut $ScoreMaxCluster" lappend LesClusters "$Chromo $MillionFin $ScoreMaxCluster" } else { for {set i 0} {$i<=$NbMillions} {incr i} { lappend LesClusters "$Chromo [expr $MillionDebut+$i] $ScoreMaxCluster" #Espionne "$Chromo [expr $MillionDebut+$i] $ScoreMaxCluster" } } } else { lappend LesClusters "$Chromo $MillionDebut $ScoreMaxCluster" } #EspionneL $LesClusters #Espionne "fin cluster" } set ScoreCluster 0 set ScoreMaxCluster 0 set NbNoms 0 } } #si bon nn score dans le dernier element : if {$score>$ValeurSeuil && $NbNoms>=2} { set MillionDebut [expr round ($BorneInf/1000000) +1] set MillionFin [expr round ($BorneSup/1000000) +1] if {$MillionDebut!=$MillionFin} { set NbMillions [expr ($MillionFin-$MillionDebut)] if {$NbMillions==1} { lappend LesClusters "$Chromo $MillionDebut $ScoreMaxCluster" lappend LesClusters "$Chromo $MillionFin $ScoreMaxCluster" } else { for {set i 0} {$i<=$NbMillions} {incr i} { lappend LesClusters "$Chromo [expr $MillionDebut+$i] $ScoreMaxCluster" } } } else { lappend LesClusters "$Chromo $MillionDebut $ScoreMaxCluster" } set ScoreCluster 0 set ScoreMaxCluster 0 set NbNoms 0 #Espionne "fin cluster" } if {$LesClusters=={}} {return ""} return $LesClusters } proc LesMinEtMax {Liste {CBS 0}} { set LesMinMax "" foreach Elt $Liste { Espionne $Elt if {$CBS==0} { set FichierCourbe "[RepertoireDuGenome]/PRIMA_CGH/$Elt" Espionne $FichierCourbe set x [InterrogeFichierCourbeCGH $FichierCourbe "unset"] set VMin [InterrogeFichierCourbeCGH $FichierCourbe VMin] set VMax [InterrogeFichierCourbeCGH $FichierCourbe VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] lappend LesMinMax "$Elt\t$VMinf\t$VMaxf" } else { set FichierCourbe "[RepertoireDuGenome]/PRIMA_CGH_SEG/$Elt.seg" Espionne $FichierCourbe set x [InterrogeFichierSEG $FichierCourbe "unset"] set VMin [InterrogeFichierSEG $FichierCourbe VMin] set VMax [InterrogeFichierSEG $FichierCourbe VMax] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] lappend LesMinMax "$Elt\t$VMinf\t$VMaxf" } } EspionneL $LesMinMax return } proc LesMinMaxParChromo {Chromosome Liste {CBS 0}} { set LesMinMax "" foreach Elt $Liste { Espionne $Elt if {$CBS==0} { set FichierCourbe "[RepertoireDuGenome]/PRIMA_CGH/$Elt" Espionne $FichierCourbe if {[regexp -nocase "BAC" $Elt]} { set VMin [LaValeurMinCGHBAC $FichierCourbe $Chromosome] set VMax [LaValeurMaxCGHBAC $FichierCourbe $Chromosome] } else { set VMin [LaValeurMinCGHOligo $FichierCourbe $Chromosome] set VMax [LaValeurMaxCGHOligo $FichierCourbe $Chromosome] } set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] lappend LesMinMax "$Elt\t$Chromosome\t$VMinf\t$VMaxf" } else { set FichierCourbe "[RepertoireDuGenome]/PRIMA_CGH_SEG/$Elt.seg" Espionne $FichierCourbe set x [InterrogeFichierSEG $FichierCourbe "unset"] set VMin [LaValeurMinCGHSeg $FichierCourbe $Chromosome] set VMax [LaValeurMaxCGHSeg $FichierCourbe $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] lappend LesMinMax "$Elt\t$Chromosome\t$VMinf\t$VMaxf" } } EspionneL $LesMinMax return } proc LesMonoLocsDesProbesAffy {FichierRMA FichierProbesets FichierSortie} { if {![file exists $FichierProbesets]} { foreach Ligne [LesLignesDuFichier $FichierRMA] { set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp "probeset" $Ligne]} {continue} set LesElts [split $Ligne "\t"] set probeset [lindex $LesElts 0] lappend LesProbesets $probeset } SauveLesLignes $LesProbesets dans $FichierProbesets } else { foreach Ligne [LesLignesDuFichier $FichierProbesets] { lappend LesProbesets $Ligne } } Espionne "nb probesets: [llength $LesProbesets]" foreach probeset $LesProbesets { Espionne $probeset set LesChros [InterrogeAffy_UCSC "" human $probeset Chromosome] if {[llength $LesChros]>1} {continue} set LesDebuts [InterrogeAffy_UCSC "" human $probeset $LesChros Debut] if {[llength $LesDebuts]>1} {continue} set LesFins [InterrogeAffy_UCSC "" human $probeset $LesChros Fin] #lappend LesMonoLocsProbesets "$probeset\t$LesChros\t$LesDebuts\t$LesFins" AppendAuFichier $FichierSortie "$probeset\t$LesChros\t$LesDebuts\t$LesFins" } #SauveLesLignes $LesMonoLocsProbesets dans $FichierSortie } proc LesMotsDeLaLigne {Ligne {REX ""}} { return [split [LigneDesMots $Ligne $REX] " "] } proc LesMotsDeLaLigneTabulee {Ligne {Tab ""}} { if {$Tab==""} { set Tab "," } set LesC [split $Ligne ""] set LesP [concat [list " "] [lrange $LesC 0 end-1]] set InQuote 0 set Mot "" lappend LesP " " lappend LesC $Tab set LesMots {} foreach P $LesP C $LesC { if {$C=="\"" && $P!="\\"} { if {$InQuote} { set InQuote 0 } else { set InQuote 1 } continue } if {$C==$Tab && ! $InQuote} { lappend LesMots $Mot ; set Mot "" ; continue } append Mot $C } return $LesMots } proc LesMotsDuTexte {Texte} { regsub -all {[ \t\,\;\n\r]+} $Texte " " Texte set Texte [string trim $Texte] set LesMots [split $Texte " "] return $LesMots } proc LesMotsImportants {Ligne} { regsub -all "EC " $Ligne "EC_" Ligne regsub -all -nocase {[^a-z0-9\-_\+\.]} $Ligne " " Ligne set LesImportants {} foreach Mot [LesMotsDeLaLigne $Ligne] { if { ! [regexp -nocase {[a-z]} $Mot]} { continue } regsub -all {^\.|\.$} $Mot "" Mot regsub -all {\.} $Mot "_" Mot lappend LesImportants $Mot } return $LesImportants } proc LesMultiLocsDesProbesAffy {FichierRMA FichierProbesets FichierSortie} { if {![file exists $FichierProbesets]} { foreach Ligne [LesLignesDuFichier $FichierRMA] { set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp "probeset" $Ligne]} {continue} set LesElts [split $Ligne "\t"] set probeset [lindex $LesElts 0] lappend LesProbesets $probeset } SauveLesLignes $LesProbesets dans $FichierProbesets } else { foreach Ligne [LesLignesDuFichier $FichierProbesets] { lappend LesProbesets $Ligne } } FaireLire "nb probesets: [llength $LesProbesets]" foreach probeset $LesProbesets { Espionne $probeset set LesChros [InterrogeAffy_UCSC "" human $probeset Chromosome] if {[llength $LesChros]==1} { set LesDebuts [InterrogeAffy_UCSC "" human $probeset $LesChros Debut] if {[llength $LesDebuts]==1} {Espionne "$probeset monoloc";continue} } Espionne "$probeset leschros: $LesChros" foreach chro $LesChros { set LesDebuts [InterrogeAffy_UCSC "" human $probeset $chro Debut] set LesFins [InterrogeAffy_UCSC "" human $probeset $chro Fin] Espionne "$probeset chro: $chro lesdebuts:$LesDebuts lesfins:$LesFins" # Double boucle!!! foreach Debut $LesDebuts Fin $LesFins { Espionne "coucou $probeset $chro $Debut $Fin" #set PosMid [expr ($Fin-$Debut)/2 + $Debut] #lappend LesMultiLocsProbesets "$probeset\t$chro\t$Debut\t$Fin" AppendAuFichier $FichierSortie "$probeset\t$chro\t$Debut\t$Fin" } } } #SauveLesLignes $LesMultiLocsProbesets dans $FichierSortie } proc LesMut {Nom} { set L [ExtraitInfo $Nom "Mut:"] regsub -all " / " $L "/" L return [split $L "/"] } proc LesMutantsDe {PGS {Quoi ""}} { global LesMutantsDe Wup "Quoi can be Sites or Names" if {$Quoi==""} { set Quoi "Sites" } if {[info exists LesMutantsDe($PGS,$Quoi)]} { return [set LesMutantsDe($PGS,$Quoi)] } if {[info exists LesMutantsDe("EstCharge")]} { return {} } set LesMutantsDe("EstCharge") 1 set LesGrandsFreres {} foreach Nom [ListeDesPABs] { set Texte [ExtraitInfo $Nom "Muted"] if {$Texte==""} { continue } if { ! [regexp "mutation of" $Texte]} { continue } set GrandFrere [StringApres "mutation of" dans $Texte] lappend LesMutantsDe($GrandFrere,Names) $Nom set LesMutantsDe($Nom,SonGrandFrere) $GrandFrere regsub { *mutation +of +[^ ]+ +[^ ]+ } $Texte "" TexteCodes set LesCodes [split $TexteCodes] set LesCoOrdonnes {} foreach Code $LesCodes { if { ! [regexp -nocase {[a-z]} $Code]} { continue } regsub {[0-9]+} [string toupper $Code] " & " Coco scan $Coco "%s %d %s" AncienP PosAncienP NouveauP set LongAncienP [string length $AncienP] lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP" lappend LesMutantsDe($GrandFrere,Sites) $PosAncienP lappend LesGrandsFreres $GrandFrere } } set LesGrandsFreres [lsort -u $LesGrandsFreres] set LesMutantsDe(LaListeDes,GrandsFreres) $LesGrandsFreres foreach GrandFrere $LesGrandsFreres { set LesMutantsDe($GrandFrere,Sites) [lsort -integer -unique [set LesMutantsDe($GrandFrere,Sites)]] } return [LesMutantsDe $PGS $Quoi] } 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 LesNNScores {Chromo {Nvoisins 6}} { if {![regexp "^HS" $Chromo]} {return "Please, give a chromosome beginning by HS"} if {[RepertoireDuGenome]=="[GscopeDatabaseDir AffyTarget]" || [RepertoireDuGenome]=="[GscopeDatabaseDir Affy]"} { set Affy "target" } else { set Affy "" } foreach CodeGscope [ListeDesDifferentiellementExprimesSansJumeaux $Affy] { if {$CodeGscope!=""} { set Vu($CodeGscope) 1 } } set ListeDeListes {} foreach Nom [ListeDesPABs] { if {[ListeLesInfosDeLaLocalisationSurChromosome $Nom]!={}} { set Chro [lindex [ListeLesInfosDeLaLocalisationSurChromosome $Nom] 1] if {$Chro!=$Chromo} {continue} lappend ListeDeListes [ListeLesInfosDeLaLocalisationSurChromosome $Nom] } } set ListeFinale {} #tri de la liste de liste selon borne inferieure set ListeDeListesTriee [lsort -integer -index 2 $ListeDeListes] set IndicePetiteListe 0 foreach PetiteListe $ListeDeListesTriee { set Nom [lindex $PetiteListe 0] #Espionne $Nom if {![info exists Vu($Nom)]} { #Espionne "nom jete" incr IndicePetiteListe continue } set Debut [lindex $PetiteListe 2] set Fin [lindex $PetiteListe 3] set Score 0 set PetiteListeTemp {} #determination du score pour ce nom set IndiceDuVoisinExtremeVersP [expr $IndicePetiteListe - $Nvoisins] set IndiceDuVoisinExtremeVersQ [expr $IndicePetiteListe + $Nvoisins] for {set i $IndiceDuVoisinExtremeVersP} {$i <= $IndiceDuVoisinExtremeVersQ} {incr i} { if {$i==$IndicePetiteListe} {continue} set lVoisin [lindex $ListeDeListesTriee $i] if {$lVoisin != ""} { set NomDuVoisin [lindex $lVoisin 0] if {[info exists Vu($NomDuVoisin)]} { incr Score } } } if {$Score!=0} { set PetiteListeTemp [list $Nom $Score $Chromo $Debut $Fin] lappend ListeFinale $PetiteListeTemp } incr IndicePetiteListe } if {$ListeFinale!= {}} {set ListeFinale [lsort -integer -increasing -index 3 $ListeFinale]} return $ListeFinale } proc LesNmManquants {} { foreach I [RetChip ListOf Index] { set NM [RetChip $I "refseq_PIQOR"] #Espionne "$I=>$NM existe" if {$NM == ""} { continue } if { [regexp {^NM_[0-9]+$} $NM] } { set NMSt [NmEnStock $NM] if {$NMSt != ""} {continue} else { puts "la ligne $I a un NM=$NM qu'on ne trouve pas" } } if { [regexp "," $NM] } { set sesNM [split $NM ","] foreach X $sesNM { set NMSt [NmEnStock $X] if {$NMSt != ""} {continue} else { puts "la ligne $I a un de ses NM qu'on ne trouve pas" } } } } } proc LesNoms {{PABouNomsInteressantsouListeouFichier PAB} {Quoi ""}} { if {$PABouNomsInteressantsouListeouFichier == "PAB"} {return [ListeDesPABs]} if {$PABouNomsInteressantsouListeouFichier == "NomsInteressants"} { set Fichier "[RepertoireDuGenome]/fiches/LesNomsInteressants" if {![file exists $Fichier]} {return [ListeDesPABs]} return [lsort -unique [ContenuDuFichier $Fichier]] } if {$PABouNomsInteressantsouListeouFichier == "Liste"} { return $Quoi } if {$PABouNomsInteressantsouListeouFichier == "Fichier"} { return [lsort -unique [ContenuDuFichier $Quoi]] } return [ListeDesPABs] } proc LesNomsDesSeqsSel {} { set Ln {} if {[QuelMode] eq "seqlab"} { set LNoms $::LNSeqlab } else { set LNoms $::LNOrdali } foreach e $::NomSeqSel { lassign [split $e .] y x incr y -1 set nom [lindex $LNoms $y] if {$nom ne ""} { lappend Ln $nom } } return $Ln } proc LesNomsEnStock {K {Quoi Interrogation}} { global LesNomsEnStock if {$Quoi=="UnSet" && [info exists LesNomsEnStock($K)]} { unset LesNomsEnStock($K) return } if {$Quoi=="Interrogation"} { return [set LesNomsEnStock($K)] } set LesNomsEnStock($K) $Quoi return $Quoi } proc LesNomsGscopeDeLOrganisme {Organisme} { global RepertoireDuGenome global LesNomsGscopeDeLOrganisme set Organisme [Glossaire $Organisme Complet] if {[info exists LesNomsGscopeDeLOrganisme($Organisme)]} { return [set LesNomsGscopeDeLOrganisme($Organisme)] } if {[info exists LesNomsGscopeDeLOrganisme("EstCharge")]} { return {} } foreach FichierMiniConfig [glob "$RepertoireDuGenome/../*/beton/miniconfig"] { set NomGscope [file tail [file dirname [file dirname $FichierMiniConfig]]] if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue } foreach Ligne [LesLignesDuFichier $FichierMiniConfig] { if {[regexp "^NotreOS " $Ligne]} { scan $Ligne "%s %s %s" Bidon Genre Espece regsub {\.$} $Espece "" Espece set OrganismeLu "$Genre $Espece" lappend LesNomsGscopeDeLOrganisme($OrganismeLu) $NomGscope break } } } set LesNomsGscopeDeLOrganisme("EstCharge") "EstCharge" return [LesNomsGscopeDeLOrganisme $Organisme] } proc LesNomsPiques {} { global Piques if { ! [info exists Piques]} { return "" } set ListeDesPiques {} foreach Nom [array names Piques] { lappend ListeDesPiques $Nom } return [join $ListeDesPiques "\n"] } proc LesNomsPourOlymClade {} { set LesNoms [ListeDesPABs] # set LesNoms [lrange $LesNoms 0 999] return $LesNoms } proc LesNonBidir {Path FileName NbGenesVoulus {Database GeCo} {NombreDeGenesDansDatabase 33700} {LongueurMoyennePromoteurBidir 1000} {BirdVersion bird} {MinOuMax Max}} { set TempPath "/tmp/$FileName" set Path "$Path/$FileName" if { $MinOuMax == "Max"} { set OrderBy1 "DESC" set OrderBy2 "ASC" } if { $MinOuMax == "Min"} { set OrderBy1 "ASC" set OrderBy2 "DESC" } set FichierDesRequetes [open "$TempPath.bql" "w"] set FichierDesNonBidir [open "$Path.nb" "w"] set FichierDesPromoteursNonBidir [open "$Path.pnb" "w"] Espionne "LesNonBidir : Start " set Promoteurs 0 set Pseudo 0 set BrinPlus 0 set BrinMoins 0 set BiDir 0 set NonBidir 0 set Doublons 0 set K 0 set accessOld "" set Limite 0 set RandomEtHap 0 set ListeDesEntetes {} Espionne "LesNonBidir : Generation des requetes aleatoires " set I 1 for {set I 1} {$I <= $NbGenesVoulus} {incr I} { set RandomStart [expr int(floor(80000000 * rand()))] incr K puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE SELECT access, chrom, txStart, txEnd, strand, exonCount, name, mRNA, spID, spDisplayID, geneSymbol, protAcc, typegene, description FROM ucschuman.GeCo WHERE txStart>=$RandomStart AND pseudogene='no' ORDER BY txStart" puts $FichierDesRequetes "LM 1" puts $FichierDesRequetes "#" } close $FichierDesRequetes Espionne "LesNonBidir : Execution des requetes aleatoires " BirdFetch "$TempPath.bql" "$TempPath.res" set FichierDesRequetesExecutees1 [open "$TempPath.res" "r"] set FichierDesRequetes2 [open "$TempPath.bql2" "w"] gets $FichierDesRequetesExecutees1 Ligne1 Espionne "LesNonBidir : Generation des requetes de verification non-bidir " while { [gets $FichierDesRequetesExecutees1 Ligne1] >=0 } { ScanLaPipe $Ligne1 access chrom txStart txEnd strand exonCount name mRNA spID spDisplayID geneSymbol protAcc typegene description set random "" set hap "" regexp {random} $chrom random regexp {hap} $chrom hap if { $random == "" && $hap == ""} { if { [string range $chrom 0 0] != "c"} { set chrom "chr$chrom" } if { $strand == "+" } { set Limite [expr $txStart - $LongueurMoyennePromoteurBidir] puts $FichierDesRequetes2 "ID * DB UCSC" puts $FichierDesRequetes2 "WH SQLNATIVE SELECT access FROM ucschuman.GeCo WHERE strand='-' AND chrom='$chrom' AND txEnd < [expr $txStart - $LongueurMoyennePromoteurBidir] AND name<>'Pseudogene' AND strand = '-'" puts $FichierDesRequetes2 "LM 1" puts $FichierDesRequetes2 "#" } else { set Limite [expr $txEnd + $LongueurMoyennePromoteurBidir] puts $FichierDesRequetes2 "ID * DB UCSC" puts $FichierDesRequetes2 "WH SQLNATIVE SELECT access FROM ucschuman.GeCo WHERE strand='+' AND chrom='$chrom' AND txStart > [expr $txEnd + $LongueurMoyennePromoteurBidir] AND name<>'Pseudogene' AND strand = '+'" puts $FichierDesRequetes2 "LM 1" puts $FichierDesRequetes2 "#" } } gets $FichierDesRequetesExecutees1 Ligne1 } close $FichierDesRequetes2 close $FichierDesRequetesExecutees1 Espionne "LesNonBidir : Execution des requetes de verification non-bidir " BirdFetch "$TempPath.bql2" "$TempPath.res2" set FichierDesRequetesExecutees2 [open "$TempPath.res2" "r"] set FichierDesRequetesExecutees1 [open "$TempPath.res" "r"] Espionne "LesNonBidir : Verification non-bidir" gets $FichierDesRequetesExecutees2 Ligne2 gets $FichierDesRequetesExecutees1 Ligne1 set Alerte 0 while { [gets $FichierDesRequetesExecutees2 Ligne2] >=0 } { gets $FichierDesRequetesExecutees1 Ligne1 if { $Ligne2 == "EMPTY" } { incr Alerte } else { set description1 "NoDescription" ScanLaPipe $Ligne1 access1 chrom1 txStart1 txEnd1 strand1 exonCount1 name1 mRNA1 spID1 spDisplayID1 geneSymbol1 protAcc1 typegene1 description1 if {$access1 != $accessOld} { regsub -all {\s} $description1 "." description1 if { $strand1 == "+" } { set PromoteurStart [expr $txStart1 - 1400] set PromoteurEnd [expr $txStart1 + 400] } else { set PromoteurStart [expr $txEnd1 - 400] set PromoteurEnd [expr $txEnd1 + 1400] } set numerochrom [string range $chrom1 3 4] regsub -all {\.} $numerochrom "" numerochrom regsub -all {\_} $numerochrom "" numerochrom set SequencePromoteur "" set random "" set hap "" regexp {random} $chrom1 random regexp {hap} $chrom1 hap if { $random == "" && $hap == ""} { set Index "$access1.$PromoteurStart.$PromoteurEnd" puts $FichierDesNonBidir "$access1 $chrom1 $txStart1 $txEnd1 $strand1" lappend ListeDesEntetes $Index } else { incr RandomEtHap } } } gets $FichierDesRequetesExecutees2 Ligne2 gets $FichierDesRequetesExecutees1 Ligne1 } close $FichierDesRequetesExecutees2 close $FichierDesRequetesExecutees1 close $FichierDesNonBidir Espionne "LesNonBidir : Tri par chromosome" set ListeDesEntetes [lsort -increasing $ListeDesEntetes] Espionne "LesNonBidir : Recuperation des sequences" foreach Entete $ListeDesEntetes { regsub -all {\.} $Entete " " Entete ScanLaListe $Entete access PromoteurStart PromoteurEnd if { $access != $accessOld } { regsub -all {chrchr} $chrom "chr" chrom regsub -all {chr} $chrom "" numerochrom set SequencePromoteur "" #set SequencePromoteur [BoutAdnDeUcscBoost $PromoteurStart $PromoteurEnd $strand "Homo_sapiens" $numerochrom] #set SequencePromoteur [string toupper $SequencePromoteur] #puts $FichierDesPromoteursNonBidir "$access $chrom $PromoteurStart $PromoteurEnd" #puts $FichierDesPromoteursNonBidir $SequencePromoteur incr NonBidir set accessOld $access } else { incr Doublons } } close $FichierDesPromoteursNonBidir Espionne "LesNonBidir: Fin" Espionne "Nombre genes : $K" Espionne " * Contenant au moins un pseudogene : $Pseudo" Espionne " * Random/Hap : $RandomEtHap" Espionne " * Bidir : $Alerte" Espionne " * Doublons : $Doublons" Espionne " * NonBidir : $NonBidir" } proc LesNonLocalisesAvecProteine {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] set n 0 set NbContig 0 set RepProttfa "[RepertoireDuGenome]/prottfa" foreach Nom $Liste { if {[PolyLocalise $Nom]=="NoLocalization"} { set Fichier "$RepProttfa/$Nom" if {[file exists $Fichier]} { set Contenu [ContenuDuFichier $Fichier] if {[regexp "CONTIG" $Contenu]} {incr NbContig} incr n } } } Espionne $NbContig return $n } proc LesNonmRNAsDesAcNucs {LesAccess} { AskLesPagesInfos load $LesAccess genbankfull set LesNonmRNAs {} foreach Access $LesAccess { set PageInfo [AskLesPagesInfos ask $Access] if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} { lappend LesNonmRNAs $Access } } AskLesPagesInfos unset return $LesNonmRNAs } proc LesOMIMDeLaRegion {Chrom Debut Fin} { ##pour sortie voir InterrogeOMIM set Chrom [NumeroDuChromosome $Chrom] set LesOMIM {} foreach OMIM [lsort -unique [InterrogeOMIM LesOMIM]] { foreach LInfo [InterrogeOMIM OMIM $OMIM LesInfos ] { set Chromosome [lindex $LInfo 1] if {$Chromosome != $Chrom} {continue} set LesBornes [lindex $LInfo 2] set D [lindex $LesBornes 0] set F [lindex $LesBornes 1] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $D $F]} {continue} lappend LesOMIM $LInfo } } return $LesOMIM } proc LesOffsetsDePfur {} { global RepertoireDuGenome Wup "Il y a une sequence non utilisee, je la saute." set Offset 0 foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/db/pfur"] { if {[regexp ">" $Ligne]} { scan $Ligne ">%s" Courant if {[regexp "MM4to38\-10429" $Courant]} { puts $Ligne; continue } puts "$Courant $Offset" } else { if {[regexp "MM4to38\-10429" $Courant]} { puts $Ligne; continue } incr Offset [string length $Ligne] } } } proc LesOligoExcel_RefSeq_Design {} { Wup "Design de RefSeq complet, environ 19200" Wup "Pour les resultats de refseq dans un seul fichier" set Dir "[RepertoireDuGenome]/Probes/RefSeq_TFA" set LesQuerys [glob -nocomplain -directory $Dir "NM*"] set WDir "[RepertoireDuGenome]/Probes/RefSeq_Design" set FichierSave "[RepertoireDuGenome]/Probes/Resultat_Design_RefSeq" set firsttime 1 foreach Q $LesQuerys { if {$firsttime==1} {set AvecEntete ""} else {set AvecEntete "PasDEntete"} incr firsttime set Q [file tail $Q] set DirOligo "[RepertoireDuGenome]/Probes/RefSeq_Design/[LeRepertoireDeRefSeq $Q]" #Espionne "LesOligosPourExcel $Q $DirOligo $FichierSave" LesOligosPourExcel $Q $DirOligo "" "" $FichierSave $AvecEntete } return "" } proc LesOligosCommandes {} { FaireLire "Mise a jour de oligosMIEUX" foreach P [Oli "LaListeMerci"] { set Descr [Oli $P "Description"] if {[regexp "ignore" $Descr]} { continue } if {[regexp "without" $Descr]} { continue } if {[regexp "mutant" $Descr]} { continue } if {[regexp "MutOli" $Descr]} { continue } if {[regexp "SeqOli" $Descr]} { continue } set SEQ [string toupper [Oli $P "Seq"]] lappend OliDeLaSeq($SEQ) $P } foreach FOli [glob "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] { foreach Access [LaSequenceDuTFAs $FOli "LaListeDesAccess"] { if {[regexp "^SeqOli" $Access]} {continue} set LesLis [DecomposeLaLigne $Access] set LesSujets [lindex $LesLis 0] set LesAvs [lindex $LesLis 1] set LesAps [lindex $LesLis 2] if {$LesAvs==$LesAps} { FaireLire "$FOli\n$Access" } if {$LesAps==""} { set Sens "5'" set Signaux [join $LesAvs "_"] } else { set Sens "3'" set Signaux [join $LesAps "_"] } if {[llength $LesSujets]>1} { FaireLire "$FOli\ntrop de sujets" } set Sujet [lindex $LesSujets 0] set TFA [LaSequenceDuTFAs $FOli $Access] set Seq [QueLaSequenceDuTexteTFA $TFA] set SEQ [string toupper $Seq] set LesPs [list "PInconnu"] if {[info exists OliDeLaSeq($SEQ)]} { set LesPs $OliDeLaSeq($SEQ) } else { continue if {[OuiOuNon "$FOli\n$Access\n\nOn le traque ?"]} { AfficheFichier $FOli "AvecRetour" } break } foreach P $LesPs { set Descr [Oli $P "Description"] set Cibles [StringSuivant " for " dans $Descr] set LesCibles [split $Cibles " "] set i [lsearch -exact $LesCibles $Sujet] if {[llength [lsort -unique $LesCibles]]<[llength $LesCibles]} { FaireLire $Descr } if {$i<0} { lappend LesCibles $Sujet append Descr " $Sujet" set NEW [SequenceFormatTFA [Oli $P "Seq"] $Descr] Sauve $NEW dans "[RepertoireDuGenome]/oligosMIEUX/$P.tfa" Espionne [format "%-17s %-20s %s %s=%s" $Sujet $Signaux $Sens $P $Descr] } } } } exit } proc LesOligosDuPGS {PGS} { global LesOligosDuPGS if {[info exists LesOligosDuPGS($PGS)]} { return [set LesOligosDuPGS($PGS)] } if {[info exists LesOligosDuPGS("EstCharge")]} { return {} } foreach P [Oli "LaListeMerci"] { set TypeOli [Oli $P Type] if {$TypeOli!="SynOli"} { continue } set PSujets [Oli $P Subjects] set PSignals [Oli $P Signals] regsub -all "_" $PSignals " " PSigs set PSens [Oli $P Sens] if {$PSens=="5'"} { set POliSignals " === $PSigs === " } else { set POliSignals " === === $PSigs" } foreach Ma [MatOl $P Matrice] AA [MatOl $P AA] NA [MatOl $P NA] Or [MatOl $P Orient] Su [MatOl $P Subjects] { set PGSlu [file tail $Ma] lappend LesOligosDuPGS($PGSlu) $P } } set LesOligosDuPGS("EstCharge") 1 return [LesOligosDuPGS $PGS] } proc LesOligosIdentiques {PAB DirOligo1 DirOligo2} { Wup "Permet de rendre la liste de oligos en commun entre deux recherche differentes" set LesOligosEnCommun "" #Stock les oligos du premier set FichierOligo1 "$DirOligo1/$PAB.oligo" set LesOligo1s [InterrogeInfoDeLOligo $FichierOligo1 LesNoms] foreach Oligo1 $LesOligo1s { set Debut [InterrogeInfoDeLOligo $FichierOligo1 $Oligo1 Debut] set Fin [InterrogeInfoDeLOligo $FichierOligo1 $Oligo1 Fin] set TabOligo(Oligo,$Debut,$Fin) 1 set TabOligo(NomOligo,$Debut,$Fin) $Oligo1 } #Compare les oligos du deuxieme au premier #Stock les oligos communs aux deux banques avec le nom de la 1ere banque et Debut Fin set FichierOligo2 "$DirOligo2/$PAB.oligo" set LesOligo2s [InterrogeInfoDeLOligo $FichierOligo2 LesNoms] foreach Oligo2 $LesOligo2s { set Debut [InterrogeInfoDeLOligo $FichierOligo2 $Oligo2 Debut] set Fin [InterrogeInfoDeLOligo $FichierOligo2 $Oligo2 Fin] if {[info exists TabOligo(Oligo,$Debut,$Fin)]} { set VraiNom [set TabOligo(NomOligo,$Debut,$Fin)] set NbCandidatsTotal [expr [InterrogeInfoDeLOligo $FichierOligo1 $VraiNom NbCandidats] + [InterrogeInfoDeLOligo $FichierOligo2 $Oligo2 NbCandidats]] lappend LesOligosEnCommun [list $VraiNom $Debut $Fin $NbCandidatsTotal [InterrogeInfoDeLOligo $FichierOligo1 $VraiNom NbCandidats] [InterrogeInfoDeLOligo $FichierOligo2 $Oligo2 NbCandidats]] } } set LesOligosEnCommun [lsort -increasing -index 3 $LesOligosEnCommun] return $LesOligosEnCommun } proc LesOligosPourExcel {LesQuery DirOligo {DirOligo2 ""} {Quoi ""} {FichierSave ""} {AvecEntete ""}} { Wup "Sauve les oligos dans un format utilisable par Excel" Wup "Rq si DirOligo2 est renseigne on utilise le fichier .croisee si ce dernier existe aussi" Wup "03/09/03 Mise a jour pour definition" Wup "10/09/03 Mise a jour pour tenir compte des oligos croisee" Wup "18/03/04 Mise a jour pour tenir compte des access unigene" Wup "10/04/04 Mise a jour pour integrer des liens vers SRS et NCBI" #Quoi peut etre ref de oligo ou coordonnees #Choix du fichier de sauvegarde if {$FichierSave == ""} { while {1} { set Texte "Choose a file name to save your selection" FaireLire "$Texte" set FichierSave [tk_getSaveFile -title "Choose a file name to save" -initialdir "[RepertoireDuGenome]"] if {$FichierSave == ""} { if {! [OuiOuNon "Would you like to continue ?"]} {return ""} } else { break } } } if {[file exists $FichierSave]} { if {! [OuiOuNonMemo "$FichierSave already exists, would you like to append to it ?"]} { file delete -force $FichierSave } } if {$AvecEntete == "" || $AvecEntete == "AvecEntete" || $AvecEntete == "1"} {set AvecEntete 1} else {set AvecEntete 0} #Pour utilier des references comme Debut Fin ou la ref de l oligo if {$Quoi==""} {set PasDeQuoi 1} else {set PasDeQuoi 0} set OnAUnigeneDir1 0 set OnAUnigeneDir2 0 #On va marquer les PAB faisant partis de la liste Test (60 refs) set ListeTest [ListeTest] set Entete "GScope Access \tProtein Access \tDesign Access \tDefinition \tTaille \tReference \tBanque \tBest_Banque" if {[regexp -nocase "unigene" $DirOligo]} { set OnAUnigeneDir1 1 append Entete "\tBest_Banque_Ug" } append Entete "\tDefinition \tDebut \tFin \tTm \tTaille \tSequence \tNombreDeCandidat \tCandidat \tUnrelatedAcc" if {$DirOligo2!=""} { append Entete "\tOligoEquivalent \tBanque2 \tBest_Banque2" if {[regexp -nocase "unigene" $DirOligo2]} { set OnAUnigeneDir2 1 append Entete "\tBest_Banque_Ug" } append Entete "\tDefinition \tNombreDeCandidat2 \tCandidat" } append Entete "\tCommentaire\tCategorie" if {$AvecEntete} {AppendAuFichier $FichierSave $Entete} if {$LesQuery=="LaTotale"} {set LesQuery [ListeDesPABs]} if {$LesQuery=="LaVraieTotale"} {set LesQuery [concat [ListeTest] [ListeDesPABs]]} if {$LesQuery=="LesTests"} {set LesQuery [ListeTest]} set Banque [file tail $DirOligo] set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set RepNuctfa "[RepertoireDuGenome]/nuctfa" foreach PAB $LesQuery { set OnTraiteDeCroisee 0 set ProteinAccess "" set NucleicAccess "" set OligoEquivalent "" set BestBanque1 "" set BestBanqueUg "" set Definition1 "" set Banque2 "" set NombreDeCandidat2 "" set Candidat2 "" set BestBanque2 "" set Definition2 "" set BestBanqueUg2 "" set UnrelatedAcc "" set Commentaire "" set Categorie "" #On va marquer les PAB faisant partis de la liste Test (60 refs) if {[regexp -nocase "$PAB" $ListeTest]} { set Categorie "test" } else { if {[regexp "^ACT" $PAB]} { set JumeauRepresentatif [JumeauRepresentatif $PAB] if {$JumeauRepresentatif!="" && $PAB!=$JumeauRepresentatif} {Espionne "$PAB pas jumeau best";continue} } } set FichierMasque "$DirOligo/${PAB}.masked" set FichierOligo "$DirOligo/${PAB}.oligo" set FichierBlastn "$DirOligo/${PAB}.blastn" set FichierLog "$DirOligo/${PAB}.log" set FichierSelection "$DirOligo/${PAB}.selection" set FichierCroisee "$DirOligo/${PAB}.croisee" if {$PasDeQuoi} { set FichierACharger $FichierSelection } else { set FichierACharger $FichierOligo } if {![file exists $FichierMasque]} { #Creation du fichier oligo pour excel $PAB oligo non calcules set LesInfos "$PAB\tNo Oligo yet calculated" AppendAuFichier $FichierSave $LesInfos continue } if {![file exists $FichierSelection] && ![file exists $FichierCroisee]} { #Creation du fichier oligo pour excel $PAB oligo non trouves set BestBanque1 "" if {[file exists $FichierBlastn] && [file exists $FichierLog]} { set BestBanque1 [ReturnBestHitFromLogFile $PAB $DirOligo] } set LesInfos "$PAB\tNo Oligo found due to not enough identity\t$BestBanque1" AppendAuFichier $FichierSave $LesInfos continue } set TailleQuery [string length [QueLaSequenceDuFichierTFA $FichierMasque]] #On peut prendre le fichier croisee if {$DirOligo2!=""} { set FichierOligo2 "$DirOligo2/$PAB.oligo" set EstCharge2 "" set EstCharge2 [InterrogeInfoDeLOligo $FichierOligo2 EstCharge] if {$EstCharge2==""} {set EstCharge2 0} if {[file exists $FichierCroisee] && [file exists "$FichierOligo2"]} { set OnTraiteDeCroisee 1 if {$PasDeQuoi} { set FichierACharger $FichierCroisee } else { set FichierACharger $FichierOligo } set Banque2 [file tail $DirOligo2] } } #Test si on avait deja charge le fichier auparavant set EstCharge1 "" set EstCharge1 [InterrogeInfoDeLOligo $FichierACharger EstCharge] if {$EstCharge1==""} {set EstCharge1 0} #Access utilise lors du design #un mRNA ou sequence originale (nuctfa) ####################################### set Query "$RepmRNA/$PAB" if {[file exists $Query]} { set NucleicAccess [AccessDeLaBoite $PAB mRNA] } else { set Query "$RepNuctfa/$PAB" if {[file exists $Query]} { set NucleicAccess [AccessDuTFADumRNA $Query] } else {set NucleicAccess "$PAB"} } #Access et definition de la proteine correspondante ################################################### set ProteinAccess [AccessDeLaBoite $PAB protein] set Definition [AccessDeLaBoite $PAB protein Definition] #Definition de secours (mRNA ou access) ####################################### if { $Definition == "" && $NucleicAccess != ""} { set Definition [AccessDeLaBoite $PAB mRNA Definition] if { $Definition == ""} { set Definition [lrange [DefDeAcc $NucleicAccess genbankfull Def] 1 end] } } if {![info exists Tab($NucleicAccess)]} {set Tab($NucleicAccess) 1} else {Espionne "$PAB $NucleicAccess deja vu";continue} set BestBanque1 [ReturnBestHitFromLogFile $PAB $DirOligo] set Definition1 [ReturnDefinitionFromBestHitFromLogFile $BestBanque1] set ProteinAccess "=LIEN_HYPERTEXTE(\"http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?-newId+-e+(\[protein-id:'$ProteinAccess'\]|\[protein-acc:'$ProteinAccess'\])\"; \"$ProteinAccess\")" set NucleicAccess "=LIEN_HYPERTEXTE(\"http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?-newId+-e+(\[genbank:'$NucleicAccess'\]|\[genbank-acc:'$NucleicAccess'\])\"; \"$NucleicAccess\")" #Les donnees des Oligos ####################### set LesOligos [InterrogeInfoDeLOligo $FichierACharger LesNoms] if {$LesOligos == ""} { if { [InterrogeInfoDeLOligo $FichierACharger NotDone]=="1"} { #Espionne "Excel File creation for $PAB : no oligo yet designed" set LesInfos "$PAB\tNo Oligo yet calculated" AppendAuFichier $FichierSave $LesInfos } elseif { [InterrogeInfoDeLOligo $FichierACharger NoOligo]=="1"} { #Espionne "Excel File creation for $PAB : no oligo found" set LesInfos "$PAB\tNo Oligo found" set BestBanque1 "" if {[file exists $FichierBlastn] && [file exists $FichierLog]} { set BestBanque1 [ReturnBestHitFromLogFile $PAB $DirOligo] if {[regexp -nocase "warning" $BestBanque1]} { set LesInfos "$PAB\tNo Oligo found due to not enough identity\t$BestBanque1" } } AppendAuFichier $FichierSave $LesInfos continue } else {Espionne "$PAB\tPetit probleme";continue} } #Pour utilier des references comme Debut Fin ou la ref de l oligo if {$PasDeQuoi=="0"} { set MonOligo "" if {[llength $Quoi]>1} { #On a pas un access mais des debut fin set MonOligo [InterrogeInfoDeLOligo $FichierACharger [lindex $Quoi 0] [lindex $Quoi 1] NomOligo] } else { set MonOligo $Quoi } if { $MonOligo==""} {continue} if {![regexp "$MonOligo" $LesOligos]} {Espionne "No $MonOligo dans $FichierACharger";continue} } foreach NomOligo $LesOligos { #Pour utilier des references comme Debut Fin ou la ref de l oligo if {$PasDeQuoi=="0" && ![regexp $MonOligo $NomOligo]} {continue} set TailleOligo [InterrogeInfoDeLOligo $FichierACharger $NomOligo Taille] set OligoTm [InterrogeInfoDeLOligo $FichierACharger $NomOligo Tm] set ExpTm [InterrogeInfoDeLOligo $FichierACharger $NomOligo ExpTm] set Debut [InterrogeInfoDeLOligo $FichierACharger $NomOligo Debut] set Fin [InterrogeInfoDeLOligo $FichierACharger $NomOligo Fin] set NbCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbCandidats] set NbContigues [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbContigues] set LesCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo LesCandidats] set LaSequence [InterrogeInfoDeLOligo $FichierACharger $NomOligo Sequence] set UnrelatedAcc [regexp -all {NG[0-9]+} $LesCandidats] if {[regexp "^RSHUM:" $BestBanque1]} { regsub -nocase {RSHUM:NM} $BestBanque1 "NM_" BestBanque1 set BestBanque1 "=LIEN_HYPERTEXTE(\"http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=Nucleotide&cmd=search&term=$BestBanque1\"; \"$BestBanque1\")" } set LesInfosDeLOligo "$PAB \t$ProteinAccess \t$NucleicAccess \t\"$Definition\" \t$TailleQuery \t$NomOligo \t$Banque \t$BestBanque1" if {$OnAUnigeneDir1} { #set BestBanqueUg [LeUGIdUN_Getz $BestBanque1] set BestBanqueUg [LeUnigeneDeUniseq $BestBanque1] if {$BestBanqueUg!=""} { set BestBanqueUg "=LIEN_HYPERTEXTE(\"http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?-newId+-e+\[unigene:'$BestBanqueUg'\]\"; \"$BestBanqueUg\")" } else {set BestBanqueUg "No Unigene Id associated"} append LesInfosDeLOligo "\t$BestBanqueUg" } append LesInfosDeLOligo "\t$Definition1 \t$Debut \t$Fin \t$OligoTm \t$TailleOligo \t$LaSequence \t$NbCandidats \t$LesCandidats \t$UnrelatedAcc" if {$OnTraiteDeCroisee} { set OligoEquivalent [NomOligoEquivalent $PAB $NomOligo $DirOligo $DirOligo2] set NombreDeCandidat2 [InterrogeInfoDeLOligo $FichierOligo2 $OligoEquivalent NbCandidats] set Candidat2 [InterrogeInfoDeLOligo $FichierOligo2 $OligoEquivalent LesCandidats] set BestBanque2 [ReturnBestHitFromLogFile $PAB $DirOligo2] set Definition2 [ReturnDefinitionFromBestHitFromLogFile $BestBanque2] if {[regexp "^RSHUM:" $BestBanque2]} { regsub -nocase {RSHUM:NM} $BestBanque2 "NM_" BestBanque2 set BestBanque2 "=LIEN_HYPERTEXTE(\"http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=Nucleotide&cmd=search&term=$BestBanque2\"; \"$BestBanque2\")" } append LesInfosDeLOligo "\t$OligoEquivalent \t$Banque2 \t$BestBanque2" if {$OnAUnigeneDir2} { #set BestBanqueUg2 [LeUGIdUN_Getz $BestBanque2] set BestBanqueUg2 [LeUnigeneDeUniseq $BestBanque2] if {$BestBanqueUg2!=""} { set BestBanqueUg2 "=LIEN_HYPERTEXTE(\"http://igbmc.u-strasbg.fr/srs71bin/cgi-bin/wgetz?-newId+-e+\[unigene:'$BestBanqueUg2'\]\"; \"$BestBanqueUg2\")" } else {set BestBanqueUg2 "No Unigene Id associated"} append LesInfosDeLOligo "\t$BestBanqueUg2" } append LesInfosDeLOligo "\t$Definition2 \t$NombreDeCandidat2 \t$Candidat2" } append LesInfosDeLOligo "\t$Commentaire" #On va marquer les PAB faisant partis de la liste Test (60 refs) if {[regexp -nocase "$PAB" $ListeTest]} { set Categorie "test" append LesInfosDeLOligo "\t$Categorie" } AppendAuFichier $FichierSave $LesInfosDeLOligo continue } if { $EstCharge1=="0"} {InterrogeInfoDeLOligo $FichierACharger Decharge} if {$OnTraiteDeCroisee} { if {$EstCharge2=="0"} {InterrogeInfoDeLOligo $FichierOligo2 Decharge} } } return "" } proc LesOligosPourExcel_GUI {{DirOligo1 ""}} { Wup "Permet de sauver les oligos selectionnes dans le format excel" Wup "Utiliser dans GUI" Wup "Rq les oligos sont ceux choisis automatiquement (.selection et .croisee) ou modifies par l utilisateur" if {$DirOligo1 == ""} { while {1} { set Texte "Please select the directory containing the design results." FaireLire "$Texte" set DirOligo1 [tk_chooseDirectory -title "Choose directory" -initialdir "[RepertoireDuGenome]"] if {$DirOligo1 == ""} { if {! [OuiOuNon "Would you like to reselect ?"]} {return ""} } break } } while {1} { set DirOligo2 "" set Texte "Your database is $DirOligo1 \nIf cross results exists, can you choose the second directory ?" if {[OuiOuNon "$Texte"]} { while {1} { set T "Choose the other directory" set DirOligo2 [tk_chooseDirectory -title $T -initialdir "[RepertoireDuGenome]"] if {$DirOligo2 == ""} { if {! [OuiOuNon "Would you like to reselect second directory ?"]} {continue} } break } break } else {break} } #Choix du fichier de sauvegarde while {1} { set Texte "Choose a file name to save your selection" FaireLire "$Texte" set FichierSave [tk_getSaveFile -title "Choose a file name to save" -initialdir "[RepertoireDuGenome]"] if {$FichierSave == ""} { if {! [OuiOuNon "Would you like to continue ?"]} {return ""} } else { break } } set ListePossible "" foreach Acc [glob -nocomplain -directory $DirOligo1 "*.masked"] { regsub ".masked$" $Acc "" Acc lappend ListePossible [file tail $Acc] } if {$ListePossible==""} {set AvecListeDesPABs 1} else {set AvecListeDesPABs 0} set LesQuery "" while {1} { set Texte "Save the oligo informations for all sequence designed ?\nIf no, choose a sample." if {! [OuiOuNon "$Texte"]} { while {1} { if {$AvecListeDesPABs} { set LesQuery [MorceauxChoisis [ListeDesPABs]] } else { set LesQuery [MorceauxChoisis $ListePossible] } if {$LesQuery == ""} { if {! [OuiOuNon "Would you like to choose again ?"]} {return ""} } break } break } else { if {$AvecListeDesPABs} { set LesQuery [ListeDesPABs] } else { set LesQuery $ListePossible } break } } LesOligosPourExcel $LesQuery $DirOligo1 $DirOligo2 "" $FichierSave OuiOuNonMemo UnsetAllPlease return "" } proc LesOligosSelectionnes {K {Option ""}} { Wup "Retourne la liste des Noms des oligos Selectionnes par proc SelectionneOligo" set LesIds "" set LesIds [$K find withtag "Selected"] if {$Option=="LesIds"} {return $LesIds} set LesNomsDesOligos "" foreach Id $LesIds { set MesTags [$K gettags $Id] set Nom [lindex $MesTags 4] lappend LesNomsDesOligos $Nom } return $LesNomsDesOligos } proc LesOnListDeSeeAbyPossibles {} { set LesOnListPossibles {} foreach Ligne [split [info body SeeAby] "\n"] { if { ! [regexp {\# OnList} $Ligne]} { continue } scan $Ligne "%s" Possible regsub -all {\"} $Possible "" Possible Espionne $Possible lappend LesOnListPossibles $Possible } return $LesOnListPossibles } proc LesOntologyDuCluster {{ClusterOuPab ""} {Type ""}} { Wup "Affiche les Gene Ontology du cluster ou des PAB" Wup "Type function component process" if {$ClusterOuPab==""} {return ""} if {![regexp -nocase {[0-9]+} $ClusterOuPab]} {return "Numero de Cluster ou PAB"} if {$Type==""} {set Type "function"} if {$Type!="function" && $Type!="component" && $Type!="process"} {return "Type must be function, process or component"} set LesPABs [InfoDuCluster $ClusterOuPab Membres] if {[regexp -nocase "^No info" $LesPABs]} {return ""} foreach PAB $LesPABs { set AC [Narcisse $PAB] lappend LesAccess $AC #Espionne "$PAB $AC" } IllustreOntologyDesAccess $LesAccess $Type } proc LesOperonsCommunsEntreClusters {Cluster1 Cluster2} { set LesOperonsCommuns {} foreach Operon1 [O2C2O Cluster $Cluster1 LesOperons] { foreach Operon2 [O2C2O Cluster $Cluster2 LesOperons] { if {$Operon1 == $Operon2} {lappend LesOperonsCommuns $Operon1} } } set LesOperonsCommuns [lsort -unique $LesOperonsCommuns] return $LesOperonsCommuns } proc LesOrdresEntreIndexes {Couleur Deb Fin} { global LesOrdresTries global IndexesDesOrdres set LesOrdresAvecPeutEtreCanvas [lrange [set LesOrdresTries($Couleur)] $Deb $Fin] if { [lsearch -regexp $LesOrdresAvecPeutEtreCanvas {^create canvas}] == -1} { set DebutCanvas [lsearch -regexp $LesOrdresTries($Couleur) {^create canvas}] set FinCanvas [lsearch -regexp $LesOrdresTries($Couleur) {^fin create canvas}] set LesOrdresAvecPeutEtreCanvas [concat [lrange $LesOrdresTries($Couleur) $DebutCanvas $FinCanvas] $LesOrdresAvecPeutEtreCanvas] } # SauveLesLignes $LesOrdresAvecPeutEtreCanvas dans /home/wscope/wscope/forum/Espionne${Deb}${Fin}.txt return $LesOrdresAvecPeutEtreCanvas } proc LesOrdresEntrePositions {Couleur xMin xMax} { global IndexesDesOrdres if {[info exists IndexesDesOrdres($xMin)] && [info exists IndexesDesOrdres($xMax)]} { scan [set IndexesDesOrdres($xMin)] "%s %s" Bidon VraiMin scan [set IndexesDesOrdres($xMax)] "%s %s" VraiMax Bidon return [LesOrdresEntreIndexes $Couleur $VraiMin $VraiMax] } set LesBornesMin [lsort -integer [array names IndexesDesOrdres]] set LesBornesMax [lrange $LesBornesMin 1 end] set BonxMin [lindex $LesBornesMin 0] set BonxMax [lindex $LesBornesMax end] set XMaxAncien -999999 foreach m $LesBornesMin M $LesBornesMax { if { $m <= $xMin } { set BonxMin $m } if { $XMaxAncien <= $xMax && $xMax < $M } { set BonxMax $M break } set XMaxAncien $M } Espionne "$xMin $xMax $BonxMin $BonxMax" if { ! [info exists BonxMin]} { return {} } scan [set IndexesDesOrdres($BonxMin)] "%s %s" Bidon VraiMin scan [set IndexesDesOrdres($BonxMax)] "%s %s" VraiMax Bidon return [LesOrdresEntreIndexes $Couleur $VraiMin $VraiMax] } proc LesOrdresPourGif {LesOrdresBruts} { global FillPourGif OutlinePourGif Wup "GscopeBoard, first creates the boxes," Wup " and second, color them, storing the colors in the arrays FillPourGif and OutlinePourGif" foreach Ligne $LesOrdresBruts { if { ! [regexp "Box|TEXTE|Cadre|arc|Web|Seq|Lettre" $Ligne]} { continue } if {[regexp "Cadre" $Ligne]} { regsub "rectangle|rect" $Ligne canvas Ligne regsub "outline" $Ligne background Ligne } if {[regexp "Box" $Ligne]} { set Nom [StringApres "Box" dans $Ligne] regsub -all {\}} $Nom "" Nom if {[info exists FillPourGif($Nom)]} { if {[regexp {\-fill} $Ligne]} { append Ligne " -" regsub {\-fill [^\-]+\-} $Ligne "-fill [set FillPourGif($Nom)] -" Ligne regsub " \-$" $Ligne "" Ligne } else { append Ligne " -fill [set FillPourGif($Nom)]" } } if {[info exists OutlinePourGif($Nom)]} { if {[regexp {\-outline} $Ligne]} { append Ligne " -" regsub {\-outline [^\-]+\-} $Ligne "-outline [set OutlinePourGif($Nom)] -" Ligne regsub " \-$" $Ligne "" Ligne } else { append Ligne " -fill [set OutlinePourGif($Nom)]" } } } lappend LesOrdresOK $Ligne } set LesOrdresTries [lsort -command CompareLeTroisiemeChamp $LesOrdresOK] foreach Ligne $LesOrdresTries { Espionne $Ligne foreach SousOrdre [DecoupeEnSousOrdresPourGif $Ligne] { lappend LesOrdres $SousOrdre } } return $LesOrdres } proc LesOrgaDistAccessDesOrthologues {Nom} { global RepertoireDuGenome global LesOrgaDistAccessDesOrthologues global NotreOrga if {[info exists LesOrgaDistAccessDesOrthologues($Nom)]} { return [set LesOrgaDistAccessDesOrthologues($Nom)] } if {[info exists LesOrgaDistAccessDesOrthologues]} { return {} } set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo.$NotreOrga" if { ! [file exists $FichierDistancesPhylo]} { return {} } foreach Ligne [LesLignesDuFichier $FichierDistancesPhylo] { set Liste [split $Ligne " "] set NomLu [lindex $Liste 0] set LesOrgaDistAccessDesOrthologues($NomLu) [lrange $Liste 1 end] } if {[info exists LesOrgaDistAccessDesOrthologues($Nom)]} { return [set LesOrgaDistAccessDesOrthologues($Nom)] } return {} } proc LesOrganismesDeLaCrossValidation {} { global RepertoireDuGenome set RepFiches "$RepertoireDuGenome/fiches" set FichierCV "$RepFiches/CrossValidation" if {![file exists "$FichierCV"]} { FaireLire "$FichierCV does not exist\.\nI am going to create it\." CrossValidationPourTous "" Save } set LesOrganismes {} foreach Ligne [LesLignesDuFichier $FichierCV] { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} set LaLigne [split $Ligne "\t"] if {[lindex $LaLigne 2] == {}} {continue} lappend LesOrganismes [lindex $LaLigne 2] } return [ElimineLesRedondancesDansUneListe $LesOrganismes] } proc LesOrganismesDuBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""} {GetWhat ""} {AvecMemoTaxo ""}} { #Pour raison de compatibilité je le garde pour le moment pour Arnaud return [TaxonomyDuBlast $TexteOuListeOuFichier $CutPN $MaxListe $GetWhat $AvecMemoTaxo] } proc LesOrganismesDuHTML {Fichier} { set Texte [ContenuDuFichier $Fichier] set OL [ValeurDeLaBalise "ol" Texte] set LesOrganismes {} while 1 { set B [ValeurDeLaBalise "li" OL] if {$B==""} { break } set iPV [string last ";" $B] set Champ [string range $B [incr iPV] end] set iP [string last "

" $Champ] if {$iP>=0} { set Champ [string range $Champ 0 [incr iP -1]] } regsub { *\(.*} $Champ "" Organisme if {[info exists DejaVu($Organisme)]} { continue } set DejaVu($Organisme) 1 lappend LesOrganismes $Organisme } return $LesOrganismes exit } proc LesOrganismesEnStock {BanqueId Access} { global TabOrga if {[info exists TabOrga($BanqueId,$Access)]} { set LesOrganismes [set TabOrga($BanqueId,$Access)] } else { set LesOrganismes [LesOrgasDeLAccess $BanqueId] set TabOrga($BanqueId,$Access) $LesOrganismes } return $LesOrganismes } proc LesOrganismesImportants {} { global RepertoireDuGenome set File "$RepertoireDuGenome/fiches/orgimportant" if {![file exists $File]} {FichierGenomesEukaryotes} return [LesLignesDuFichier $File] } proc LesOrganismesImportantsPourDBClustal {{Ask ""}} { global RepertoireDuGenome global GscopeDir global LesOrganismesImportantsPourDBClustal set Ask [regexp -nocase "^Ask$" $Ask] if {! $Ask && [info exists LesOrganismesImportantsPourDBClustal]} { return $LesOrganismesImportantsPourDBClustal } set FichierOrgImportant "$RepertoireDuGenome/fiches/orgimportant" if {$Ask || ! [file exists $FichierOrgImportant]} { set FichierOrgImportantDefaut "$GscopeDir/gscope_orgimportant" if {[file exists $FichierOrgImportantDefaut] && [OuiOuNon "Do I copy the file \n $FichierOrgImportantDefaut\n to $FichierOrgImportant\n ?"]} { File copy $FichierOrgImportantDefaut $FichierOrgImportant } else { while {[OuiOuNon "Do You want to load an existing file with Important Organisms ?"]} { set F [ButineArborescence "All" $RepertoireDuGenome] if {$F==""} { continue } if {[OuiOuNon "Do I copy it to $FichierOrgImportant ?"]} { File copy -force $F $FichierOrgImportant } else { set FichierOrgImportant $F } break } } } if {[file exists $FichierOrgImportant]} { set LesOIs [LesLignesDuFichier $FichierOrgImportant] } else { lappend LesOIs "### Important organisms for DBClustal" lappend LesOIs "# You can modify these lines." lappend LesOIs "# please respect Upper-lower case ( Homo sapiens )" lappend LesOIs "# use 'remove' to remove an organism." lappend LesOIs "# nothing to add a new organism." lappend LesOIs "# use 'addall' to tell to Gscope to add all these returned by the function" lappend LesOIs "# use 'remall' to tell to Gscope to remove these" lappend LesOIs "#" lappend LesOIs "# If one organism appears two times, the first command has priority" lappend LesOIs "###" lappend LesOIs "Pyrococcus furiosus" lappend LesOIs "remove Pyrococcus furiosus" lappend LesOIs "remove Homo sapiens" lappend LesOIs "Homo sapiens" lappend LesOIs "addall LesGenomesComplets" set Ask 1 } while {$Ask && [OuiOuNon "Do You want to edit the Important Organisms List ?" 0]} { set OIs [EntreTexte [join $LesOIs "\n"]] if {$OIs==""} { continue } set LesOIs [split $OIs "\n"] if {[OuiOuNon "Do I save these organisms in \n $FichierOrgImportant ?"]} { SauveLesLignes $LesOIs dans $FichierOrgImportant } break } set LesOrganismesImportants {} foreach Ligne $LesOIs { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } if {[regexp " *#+" $Ligne]} { continue } if {[regexp "^(addall |remall )" $Ligne Match]} { set Commande [StringSuivant "$Match" dans $Ligne] foreach O [eval $Commande] { if {[info exists DejaVu($O)]} { continue } set DejaVu($O) 1 if {$Match=="addall "} { lappend LesOrganismesImportants $O } } continue } set RemoveMoi [regexp "^remove " $Ligne] regsub "^remove +" $Ligne "" O if {[info exists DejaVu($O)]} { continue } set DejaVu($O) 1 if {$RemoveMoi} { continue } lappend LesOrganismesImportants $O } set LesOrganismesImportantsPourDBClustal $LesOrganismesImportants return $LesOrganismesImportants } proc LesOrganismesOrthologues {Nom {Prog DbClustal} {PA Presents} {Format Complet}} { set Oo "" if {$Prog=="TBlastN"} { set Oo [ORGAorgaDesTBlastNs $Nom $PA] } if {$Prog=="BlastP"} { set Oo [ORGAorgaDesBlastPs $Nom $PA] } if {$Prog=="DbClustal"} { set Oo [ORGAorgaDesMSFs $Nom $PA] } regsub -all { {2,}} $Oo " " Oo set Inconnu [Glossaire "" $Format] set LesOrganismesOrthologues {} foreach Orga [split $Oo " "] { if {$Format=="Court"} { set Organisme $Orga } else { set Organisme [Glossaire $Orga $Format] } if {$Organisme=="" || $Organisme==$Inconnu || $Organisme=="iinc" } { continue } lappend LesOrganismesOrthologues $Organisme } return $LesOrganismesOrthologues } proc LesOrganismesQuiSontEtQuiNeSontPas {{iLsSont ""} {iLsNeSontPas ""} {LesOrganismes ""}} { if {$LesOrganismes == {} } {set LesOrganismes [O2C2O LesOrganismesLongs]} set LesBonsOrganismes {} foreach Organisme $LesOrganismes { set LesCategories [O2C2O OrganismeLong $Organisme LesCategories] set EstUnBon 1 foreach Cat $iLsSont { set EnAiJeVuUn 0 foreach Categorie $LesCategories { if {[string equal -nocase $Categorie $Cat]} { set EnAiJeVuUn 1 break } } if {!$EnAiJeVuUn} {set EstUnBon 0;break} } if {!$EstUnBon} {continue} set EstUnBon 1 foreach Cat $iLsNeSontPas { set EnAiJeVuUn 0 foreach Categorie $LesCategories { if {[string equal -nocase $Categorie $Cat]} { set EnAiJeVuUn 1 break } } if {$EnAiJeVuUn} {set EstUnBon 0;break} } if {!$EstUnBon} {continue} lappend LesBonsOrganismes $Organisme } return $LesBonsOrganismes } proc LesOrganismesTresProches {{Organisms ""}} { global RepertoireDuGenome global LesOrganismesTresProches global DemandeDejaFaite global Org1 Org2 #rR a rajoute Organisms pour pouvoir le faire taire (pour SM2PH surtout) if {$Organisms!=""} { set LesOrganismesTresProches $Organisms } if {[info exists LesOrganismesTresProches]} { return $LesOrganismesTresProches } if {[PourWscope]} { return {} } if {[info exists Org1] && [info exists Org2]} { if { ! [info exists LesOrganismesTresProches]} { set LesOrganismesTresProches [list $Org1 $Org2] } return $LesOrganismesTresProches } set Org1 " " set Org2 " " if {[OnTraiteUneCollection]} { return {}} set RepertoireFiches "$RepertoireDuGenome/fiches" if { ! [file exists $RepertoireFiches]} { File mkdir $RepertoireFiches } if { ! [info exists LesOrganismesTresProches]} { set Fichier "$RepertoireDuGenome/fiches/lesorganismestresproches" if { [info exists DemandeDejaFaite] && ! [file exists $Fichier]} { return {} } while { ! [file exists $Fichier]} { if { ! [OuiOuNon "Do You want to give the two nearest organisms ?" 0]} { set DemandeDejaFaite 1 if {[OuiOuNon "Do I ask later ?"]} { return {} } Sauve "Aaaa\nBbbb" dans $Fichier } else { FaireLire "You have to select 2 organisms.\nThe first one ..." scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece set Orga [Glossaire "$Genre $Espece" Court] lappend LesOrganismesTresProches $Orga FaireLire "The second one ..." scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece set Orga [Glossaire "$Genre $Espece" Court] lappend LesOrganismesTresProches $Orga SauveLesLignes $LesOrganismesTresProches dans $Fichier } } set LesOrganismesTresProches [LesLignesDuFichier $Fichier] } set Org1 [lindex $LesOrganismesTresProches 0] set Org2 [lindex $LesOrganismesTresProches 1] return $LesOrganismesTresProches } proc LesOrgasDeLAccess {Access} { set PageInfo [PageInfo $Access protein "id org"] if {$PageInfo == ""} {set PageInfo [PageInfo $Access genbankfull "id org"]} if {$PageInfo == ""} {return ""} return [LesOrgasDeLaPage_PageInfo $PageInfo] } proc LesOrgasDeLaPage_PageInfo {PageInfo} { set PremierMotDeLaPremiereLigne [lindex [split [lindex [split $PageInfo "\n"] 0] " "] 0] if {$PremierMotDeLaPremiereLigne == "LOCUS"} { set Champs "SOURCE" set LesChamps [LeChampsDeLaPageGenBank $PageInfo $Champs] } else { set Champs "OS" set LesChamps [LeChampsDeLaPageProteine $PageInfo $Champs] } set LesOrga {} foreach OS $LesChamps { if {[regexp ";" $OS]} {continue} set OS [string trim $OS] regsub "^OS|^SOURCE" $OS "" OS regsub -all {\(|\)} $OS "" OS regsub -all " and" $OS " " OS regsub -all " and " $OS " " OS regsub -all ", " $OS "," OS regsub "\\.$" $OS "" OS set OS [string trim $OS] foreach Orga [split $OS ","] { if {[info exists Genre ]} {unset Genre } if {[info exists Espece]} {unset Espece} set Orga [string trim $Orga] scan $Orga "%s %s" Genre Espece if {![info exists Genre ]} {continue} if {![info exists Espece]} {continue} if {[regexp -nocase {[^0-9a-z_\'\-\.]} $Espece]} {continue} set Orga "$Genre $Espece" lappend LesOrga $Orga } } return [lsort -unique [ElimineLesRedondancesDansUneListe $LesOrga]] } proc LesOrgasDeMesTaxID {args} { Wup "Permet de charger et de recuperer les Nom scientifique des TaxId et inversement si ils ont ete charges" global InfoOrgaTaxID #Arguments: ########### #$Acc Name -- Rend le nom scientifique du TaxID #$Name TaxID -- Rend le TaxID du nom scientifique if {$args == "unset"} { if {[info exists InfoOrgaTaxID]} {array unset InfoOrgaTaxID} return "" } #Mode charge les access seulement if {[lindex $args 0]=="Charge"} { set LesTaxID [lindex $args 1] set LesTaxID [string trim [join [lindex $args 1] " "]] } else { #Mode un seul access set LesTaxID [lindex $args 0] } set Quoi [join $args ","] if {[info exists InfoOrgaTaxID($Quoi)]} {return [set InfoOrgaTaxID($Quoi)]} ###################CHARGE le Fichier avec les Oligos######################### set ResultatCharge [ChargeLesOrgasDeMesTaxID InfoOrgaTaxID $LesTaxID] if {![info exists InfoOrgaTaxID($Quoi)]} {return ""} return [set InfoOrgaTaxID($Quoi)] } proc LesOrgasDesAccess {LesAccess {Champ Complet} {Nom ""}} { global RepertoireDuGenome global QuidSeqEstDisponible set LesAccessRestants $LesAccess set LesAccessRestantsEncore $LesAccessRestants set LesBonsAccessOrga {} if {$LesAccessRestants=={}} { return $LesBonsAccessOrga } Wup "With Descriptif ... not yet finish (because multiple OSs)" if {$Nom!=""} { set LesAccessRestantsEncore {} set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom" if {[info exists $FichierDescriptif]} { foreach Access $LesAccessRestants { set O [OrgaDuDescriptif $Access $Nom] if {$O==""} { lappend LesBonsAccessOrga "$Access [Glossaire [set OrgaDe($Access)] $Champ]" } else { lappend LesAccessRestantsEncore $Access } } } } if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga } set LesAccessRestants $LesAccessRestantsEncore Wup "With distancephylo" if {$Champ=="Court" && $Nom!=""} { set LesAccessRestantsEncore {} set LesODAs [LesOrgaDistAccessDesOrthologues $Nom] foreach {O D A} $LesODAs { set OrgaDe($A) $O } set LesAccessRestantsRestants {} foreach Access $LesAccessRestants { if {[info exists OrgaDe($Access)]} { lappend LesBonsAccessOrga "$Access [Glossaire [set OrgaDe($Access)] $Champ]" } else { lappend LesAccessRestantsEncore $Access } } } if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga } set LesAccessRestants $LesAccessRestantsEncore Wup "For PDB or Ciona" set LesAccessRestantsEncore {} foreach Access $LesAccessRestants { if {[regexp {^ci[0-9]{10}$} $Access]} { set Organisme "Ciona intestinalis" lappend LesBonsAccessOrga "$Access [Glossaire $Organisme $Champ]" } elseif {[EstUnAccessPDB $Access]} { set Organisme [OrganismeDuPDB $Access] lappend LesBonsAccessOrga "$Access [Glossaire $Organisme $Champ]" } else { lappend LesAccessRestantsEncore $Access } } if {$LesAccessRestantsEncore=={}} { return $LesBonsAccessOrga } set LesAccessRestants $LesAccessRestantsEncore Wup "For Ciona" Wup "With QuidSeq" if {[info exists QuidSeqEstDisponible] && $QuidSeqEstDisponible} { set TexteAccessOrga [QuestionDeScience QuidSeq "QuidOSsOfACs [join $LesAccessRestants "|"]"] regsub {[ \n]+$} $TexteAccessOrga "" TexteAccessOrga set LesAccessOrga [split $TexteAccessOrga "\n"] foreach AccessOrga $LesAccessOrga { scan $AccessOrga "%s" Access regsub "^$Access +" $AccessOrga "" Organismes lappend LesBonsAccessOrga "$Access [Glossaire $Organismes $Champ]" } return $LesBonsAccessOrga } Wup "Without QuidSeq" foreach Access $LesAccessRestantsEncore { set Orga [OrgaDuAccess $Access $Champ] lappend LesBonsAccessOrga "$Access $Orga" } return $LesBonsAccessOrga } proc LesOrgasInteressants {} { global RepertoireDuGenome return [split [ContenuDuFichier "$RepertoireDuGenome/fiches/familiar_organism"] "\n"] } proc LesOrthologuesFamiliersDuBlastP {{Nom CreateIt} {Quoi All}} { global RepertoireDuGenome global NotreOS global NotreOrga set FichierOrthologuesFamiliers "$RepertoireDuGenome/fiches/orthologues.familiar" if {$Nom!="CreateIt"} { if { ! [file exists $FichierOrthologuesFamiliers]} { return "" } set DejaPasse 0 set LesOrthos {} foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] { scan $Ligne "%s" NomLu if {$NomLu!=$Nom && ! $DejaPasse } { continue } if {$NomLu!=$Nom && $DejaPasse } { break } scan $Ligne "%s %s %s %s %s %s" NomLu BanqueId Access Expect Genre Espece switch -regexp $Quoi { "All" { set Texte "$BanqueId $Access $Expect $Genre $Espece" } "BanqueId" { set Texte "$BanqueId" } "Access" { set Texte "$Access" } "Expect" { set Texte "$Expect" } "Orga" { set Texte "$Genre $Espece" } default { set Texte "$BanqueId $Access $Expect $Genre $Espece" } } set DejaPasse 1 lappend LesOrthos $Texte } return $LesOrthos } while {[file exists $FichierOrthologuesFamiliers]} { if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n Do I cancel LesOrthologuesFamiliersDuBlastP ?"]} { return $FichierOrthologuesFamiliers } if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n Do I replace it ?"]} { File delete -force $FichierOrthologuesFamiliers break } if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n Do I append to it ?"]} { set LesAnciennes {} foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] { scan $Ligne "%s" NomLu set DejaVu($NomLu) 1 } break } } set LesNomOrthologues {} set LesNomAPNs {} foreach NomLu [ListeDesPABs] { if {[info exists DejaVu($NomLu)]} { continue } set SesAPNs {} set FichierAPNs "$RepertoireDuGenome/apns/$NomLu" if {[file exists $FichierAPNs]} { foreach Ligne [LesLignesDuFichier $FichierAPNs] { set Genre "" set Espece "" set Organisme "" scan $Ligne "%s %s %f %s %s" BanqueId Access PN Genre Espece if { $PN > 0.001 } { break } if {$Espece!=""} { set Organisme "$Genre $Espece" } if {$Organisme==""} { continue set Organisme [OrgaDuAccess $Access Complet $BanqueId] } if {$Organisme==""} { continue } if { ! [FamiliarOrganism $Organisme] && $Organisme!=$NotreOS} { continue } lappend SesAPNs "$NomLu $Ligne" } } foreach APN $SesAPNs { AppendAuFichier $FichierOrthologuesFamiliers [join $SesAPNs "\n"] } } return $FichierOrthologuesFamiliers } proc LesOubliesParGscope {} { foreach Nom [ListeDesPABs] { set Fic "[RepertoireDuGenome]/msf/$Nom" if { ! [file exists $Fic]} { set MSF 0 } elseif {[regexp "NoSequence" [ContenuDuFichier $Fic]]} { set MSF -1 } else { set MSF 1 } set Fic "[RepertoireDuGenome]/daedalushits/$Nom" if { ! [file exists $Fic]} { set DAE 0 } else { set DAE 1 } set Fic "[RepertoireDuGenome]/blastp/$Nom" if { ! [file exists $Fic]} { set BLA 0 } elseif {[regexp "No hits" [ContenuDuFichier $Fic]]} { set BLA -1 } else { set BLA 1 } if {$MSF==1 && $DAE==1 && $BLA==1} { continue } if {$BLA==0 && ($MSF!=0 || $DAE!=0)} { lappend LesOublies "$Nom sans blast mais avec autre" continue PourVoir $Nom } if {$DAE==0 && $BLA==1} { lappend LesOublies "$Nom sans daedalus mais avec blast" continue PourVoir $Nom } lappend LesOublies "$Nom $MSF $DAE $BLA" } return $LesOublies } proc LesOverlapsCommunsEntreBlastEtLoc {} { foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapEtProfils"] { set DD [lindex $Ligne 0] set Vu($DD) 1 } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapDDAffy_Loc_sansDDclusters_New"] { set L [split $Ligne " "] foreach Nom $L { if {[regexp "DD" $Nom] && [info exists Vu($Nom)]} { lappend LesCommuns $Ligne break } } } Espionne [llength $LesCommuns] #SauveLesLignes $LesCommuns dans "[RepertoireDuGenome]/communs_overlaps_blast_loc" SauveLesLignes $LesCommuns dans "[RepertoireDuGenome]/communs_overlaps_blast_loc_new" } proc LesOverlapsSupplementairesObtenusParLoc {} { foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapEtProfils"] { set DD [lindex $Ligne 0] set Vu($DD) 1 } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OverlapDDAffy_Loc_sansDDclusters"] { set L [split $Ligne " "] set Signal 0 foreach Nom $L { if {[regexp "DD" $Nom] && [info exists Vu($Nom)]} { set Signal 1 } } if {$Signal==0} {lappend LesSupp $Ligne} } #FaireLire [llength $LesSupp] #SauveLesLignes $LesCommuns dans "[RepertoireDuGenome]/communs_overlaps_blast_loc" SauveLesLignes $LesSupp dans "[RepertoireDuGenome]/supp_overlaps_blast_loc" } proc LesPABDefUG {} { set Liste [ListeTest] set Rep "[RepertoireDuGenome]/Probes/UnigeneBLAST3" foreach PAB $Liste { set LeUniseqDePAB "" set LeUGDePAB "" set DefUnigene "" set DefUnigene1 "" set Def2 "" set LeUniseqDePAB [ReturnBestHitInDatabase $PAB $Rep] if {$LeUniseqDePAB==""} { set LeUGDePAB "" set DefUnigene "" } else { set LeUGDePAB [LeUGIdUN_Getz $LeUniseqDePAB "uniseq" "unigene"] if {[regexp "No Result for" $LeUGDePAB]} { set DefUnigene "" set DefUnigene1 "" } else { set DefUnigene [join [FastaCmd $LeUniseqDePAB "" 0] ""] if {[regexp "No Result for" $DefUnigene]} { set DefUnigene1 "" } else { set DefUnigene1 [lrange $DefUnigene 1 end] } } if {[regexp {/} $DefUnigene]} { regexp -indices { } $DefUnigene index set DefUnigene [string range $DefUnigene [lindex $index 0] end] regexp -indices {/} $DefUnigene index set Def2 [string range $DefUnigene 0 [expr [lindex $index 0] -1]] } else { set Def2 "" } } Espionne "$PAB\t$LeUGDePAB\t$DefUnigene1\t$Def2\t$LeUniseqDePAB" } return "" } proc LesPABsAvecInfo {Texte} { return [RepereBox $Texte "AllPlease"] } proc LesPABsAvecMemesAccessDeProtOuDemRNA {PAB FichierClusters} { #avec le fichier clusters obtenus par les overlaps set ListeDesJumeauxCorrigee [LesJRsAvecMemesAccessDeProtOuDemRNAPourUnPAB $PAB $FichierClusters] foreach Boite $ListeDesJumeauxCorrigee { lappend ListeFinale $Boite set LesAutresJumeaux [LesJumeauxDuPAB $Boite $FichierClusters] foreach AutreJumeau $LesAutresJumeaux { lappend ListeFinale $AutreJumeau } } return $ListeFinale } proc LesPABsDansLOrdre {{Replace ""}} { global RepertoireDuGenome global ListeDesPABs global ListeDeBoites set ReplaceList [regexp -nocase "ReplaceList" $Replace] set ReplaceFile [regexp -nocase "ReplaceFile" $Replace] foreach Boite [ListeDesPABs] { set Nom [Box $Boite nom] set Debut [Box $Boite debut] lappend AQuiEstCeDebut($Debut) $Nom set AQuiEstCeDebut($Debut) [lsort -unique [set AQuiEstCeDebut($Debut)]] lappend LesDebuts $Debut } set LesDebutsTries [lsort -unique -integer $LesDebuts] set NouvelleListeDesPABs {} foreach Debut $LesDebutsTries { foreach Nom [set AQuiEstCeDebut($Debut)] { set Ligne "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient]" lappend NouveauBornesDesPABs $Ligne lappend NouvelleListeDesPABs $Nom } } if {$ReplaceFile} { SauveLesLignes $NouveauBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs" } if {$ReplaceList} { set ListeDesPABs $NouvelleListeDesPABs set NouvelleListeDeBoites $NouvelleListeDesPABs foreach Boite [ListeDeBoites] { if {[info exists DejaVu($Boite)]} { continue } set DejaVu($Boite) 1 lappend NouvelleListeDeBoites $Boite } set ListeDeBoites $NouvelleListeDeBoites } return $NouvelleListeDesPABs } proc LesPABsDeLaFamille {Fam} { global LesPABsDeLaFamille global RepertoireDuGenome if {[info exists LesPABsDeLaFamille($Fam)]} { return [set LesPABsDeLaFamille($Fam)] } if {[info exists LesPABsDeLaFamille("EstCharge")]} { return [List] } foreach Nom [ListeDesPABs] { set FamLu [NomDeFamille $Nom] lappend LesPABsDeLaFamille($FamLu) $Nom } set LesPABsDeLaFamille("EstCharge") 1 return [LesPABsDeLaFamille $Fam] } proc LesPABsDuTFAs {Fichier {Rep ""}} { if { ! [OuiOuNon "Ok to create all nuctfa files and to replace fiches/bornesdespabs" 0]} { return "" } if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" } if { ! [file exists $Rep]} { file mkdir $Rep } set PF [PreFixe] set Numero 0 set Debut 101 set Frame [expr $Debut%3] foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] { incr Numero set BeauNumero [format "%5.5d" $Numero] set Nom "$PF$BeauNumero" set TFA [LaSequenceDuTFAs $Fichier $Access] set FicTFA "$Rep/$Nom" set Ent [EnteteDuTexteTFA $TFA] set Seq [QueLaSequenceDuTexteTFA $TFA] set Long [string length $Seq] set NouveauTFA [SequenceFormatTFA $Seq "$Nom $Ent" nucbrut] Sauve $NouveauTFA dans $FicTFA set Fin [expr $Debut+$Long-1] set Bornes "$Nom $Debut $Fin F" lappend LesBornes $Bornes set Debut [expr (($Fin + 1000)/3)*3 + $Frame] } return [SauveLesLignes $LesBornes dans "[RepertoireDuGenome]/fiches/bornesdespabs"] } proc LesPDBPourBali3 {} { foreach Ligne [LesLignesDuFichier "/genomics/link/Bali3/PDB.liste"] { Espionne $Ligne scan $Ligne "%s" Access set TFA [TFADuPDB $Access "ForceSEQRES" ] Espionne $TFA set Nom "Pdb_$Access" regsub ">$Access " $TFA ">$Nom " TFA set FichierTFA [Sauve $TFA dans "/genomics/link/Bali3/proteome/$Nom"] lappend LaListe "$Nom $FichierTFA" } Espionne [SauveLesLignes $LaListe dans "/genomics/link/Bali3/Bali3.fof"] exit } proc LesPDBsDesARPs {} { Wup "Transforme le factor B du pdb avec le pourcentage d'identite sur les structures pour toutes les ARPs" set LesCategories [InterrogeLesInfosDesARPs LesCategories] regsub -all {\-\-\-\-} $LesCategories "" LesCategories regsub -all "Les" $LesCategories "" LesCategories set Type "Famille" foreach Famille $LesCategories { set FichierOut "[RepertoireDuGenome]/1yag_${Famille}.pdb" ChangeLeFactorBParIDDansLaPDB 1yag $FichierOut $Famille $Type } set FichierOut "[RepertoireDuGenome]/1yag_LesARPs.pdb" ChangeLeFactorBParIDDansLaPDB 1yag $FichierOut Total return "" } proc LesPEtA {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} { Wup "Permet une selection entre plusieurs choix" global ChoixMultipleRadio global validOk if { $ListeDeTextes == {}} {set ListeDeTextes $Liste} if {[llength $Liste] == 0 } {return [list {} {}]} set MaxScreenX [expr [winfo screenwidth .]/2] set MaxScreenY [expr [winfo screenheight .]/2] set n 0 set LesLooks {} foreach Element $Liste { incr n set Look "a$n" lappend LesLooks $Look } set w [NomDe fenetre] catch {destroy $w} catch {unset validOk} toplevel $w wm geometry $w +300+100 wm title $w "$Invite" #wm resizable $w false false #Creation des boutons ##################### set Boutons $w.termine frame $Boutons button $Boutons.dismiss -text "Dismiss" -background "red" -relief "ridge" -padx "2" -command {set validOk 0} button $Boutons.toutpresent -text "All +" -background "yellow" -relief "ridge" -padx "2" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) p } } button $Boutons.toutabsent -text "All -" -background "orange" -relief "ridge" -padx "2" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) a } } button $Boutons.validate -text "Validate" -background "green" -relief "ridge" -padx "2" -command {set validOk 1} pack $Boutons -side bottom -pady 2 -fill x pack $Boutons.dismiss $Boutons.toutpresent $Boutons.toutabsent $Boutons.validate -side left -expand yes #Creation de la frame contenant # les radio boutons # les scrollbars ############################### frame $w.frame set BouRad "$w.frame.radios" set ScroHor "$w.frame.xscroll" set ScroVer "$w.frame.yscroll" scrollbar $ScroVer -command "$BouRad yview" scrollbar $ScroHor -command "$BouRad xview" -orient horizontal set CanvaScreenX 200 set CanvaScreenY 25 set HauteurUneLigne 25 canvas $BouRad -width $CanvaScreenX -height $CanvaScreenY -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" set HauteurTotale 5 set LargeurTotale 0 set TailleLabel 0 set LongestLabel 0 foreach Look $LesLooks Element $Liste Texte $ListeDeTextes { set FLook "$BouRad.$Look" frame $FLook radiobutton $FLook.radioP -relief flat -variable ChoixMultipleRadio($Look) -value p -width 0 radiobutton $FLook.radioA -relief flat -variable ChoixMultipleRadio($Look) -value a -width 0 label $FLook.text -text $Texte -anchor "w" pack $FLook.radioP $FLook.radioA $FLook.text -side left $BouRad create window 0 $HauteurTotale -anchor "nw" -window $FLook incr HauteurTotale $HauteurUneLigne set TailleLabel [winfo reqwidth $FLook.text] if {$TailleLabel > $LongestLabel} { set LaPlusLongueFrame "$FLook" set LongestLabel $TailleLabel } } update grid $w.frame.radios -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $w.frame 0 -weight 1 -minsize 0 grid columnconfig $w.frame 0 -weight 1 -minsize 0 pack $w.frame -expand yes -fill both #Mise a jour de la scroll region et de la taille du canvas #update set Taille1 [winfo reqwidth $LaPlusLongueFrame] set Taille2 [winfo width $LaPlusLongueFrame] if {$Taille1 > $Taille2} {set Taille $Taille1} else {set Taille $Taille2} $BouRad configure -width [Mini $Taille $MaxScreenX] $BouRad configure -height [Mini [expr $HauteurTotale+10] $MaxScreenY] $BouRad configure -scrollregion [list 0 0 $Taille $HauteurTotale] tkwait variable validOk destroy $w if {! $validOk} {return [list {} {}]} foreach Look $LesLooks { lappend LesPAIs [set ChoixMultipleRadio($Look)] } set LesPresents {} set LesAbsents {} foreach Look $LesLooks Element $Liste PAI $LesPAIs { if {$PAI == "p"} {lappend LesPresents $Element} if {$PAI == "a"} {lappend LesAbsents $Element} } return [list $LesPresents $LesAbsents] } proc LesPanneauxPossibles {{Panneau LaListeMerci}} { global RepertoireDuGenome global LesPanneauxPossibles if { ! [info exists LesPanneauxPossibles]} { # set LesPanneauxPossibles(PresenceAbsence) "Listbox:LesGenomesParListe" set LesPanneauxPossibles(ShowOrganisms) "Texte:MontreOrganismes" set LesPanneauxPossibles(LinearGenome) "GscopeBoard $RepertoireDuGenome PourGif" set LesPanneauxPossibles(CircularGenome) "RscopeBoard $RepertoireDuGenome PourGif" set LesPanneauxPossibles(PhyloRank) "DessineOrgaEtSesPlaces $RepertoireDuGenome/fiches/orgaetsesplaces.tout_le_monde PourGif" set LesPanneauxPossibles(PhyloRanks) "DessineOrgaEtSesPlaces $RepertoireDuGenome/fiches/orgaetsesplaces.> PourGif" set LesPanneauxPossibles(ProteomeDotplot) "DotPlot genomes > Proches PourGif" } if {$Panneau=="LaListeMerci"} { return [array names LesPanneauxPossibles] } if {[info exists LesPanneauxPossibles($Panneau)]} { return [set LesPanneauxPossibles($Panneau)] } return "Sorry no such panneau" } proc LesParaloguesDuBlastP {} { global RepertoireDuGenome global NotreOS global NotreOrga set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp" set LesNomParalogues {} set LesNomAPNs {} foreach Nom [ListeDesPABs] { set SesParalogues {} set SesAPNs {} set FichierAPNs "$RepertoireDuGenome/apns/$Nom" if {[file exists $FichierAPNs]} { foreach Ligne [LesLignesDuFichier $FichierAPNs] { scan $Ligne "%s %s %f" BanqueId Access PN if { $PN > 0.001 } { break } set Para [Narcisse $Access] if {$Para==$Nom} { continue } if { ! [regexp "[ExpressionReguliereDesPABs]" $Para]} { continue } lappend SesParalogues $Para lappend SesAPNs "$BanqueId $Access $PN" } } lappend LesNomParalogues "$Nom [join $SesParalogues " "]" foreach APN $SesAPNs { lappend LesNomAPNs "$Nom $APN" } } Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"] Espionne [SauveLesLignes $LesNomAPNs dans "$FichierParalogues.apn"] return $FichierParalogues } proc LesParaloguesDuBlastPPourMs {{Source ""} {SeuilExpect ""}} { if {$SeuilExpect==""} { set SeuilExpect 0.001 } set MaxListe 999 set FichierParalogues "[RepertoireDuGenome]/fiches/paraloguesMs" if {[FileExists $FichierParalogues]} { foreach Ligne [LesLignesDuFichier $FichierParalogues] { scan $Ligne "%s" Nom set DejaVu($Nom) 1 } } if {$Source==""} { set Source "blastp" } if {$Source=="blastp"} { foreach Nom [ListeDesPABs] { Espionne "je cherche les paralogues pour $Nom" if {[info exists DejaVu($Nom)]} { continue } set FichierBlast [GscopeFile $Nom "blastp"] if {[FileAbsent $FichierBlast]} {continue} set n [DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN] if {$n==0} { continue } set MesParalogues {} foreach BanqueId $lBanqueId Access $lAccess { if {[regexp -nocase {\:} $BanqueId]} { set NomLu [StringApres ":" dans $BanqueId] if {$NomLu==$Nom} { continue } if {[EstUnPAB $NomLu]} { lappend MesParalogues $NomLu continue } } } if {$MesParalogues=={}} { continue } set BonneLigne "$Nom [join $MesParalogues " "]" Espionne $BonneLigne AppendAuFichier $FichierParalogues $BonneLigne } } return $FichierParalogues } proc LesParaloguesDuMSF {} { global RepertoireDuGenome global NotreOS global NotreOrga set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.msf" set FichierDistanceMSF "$RepertoireDuGenome/fiches/distancesphylo.$NotreOrga" while { ! [file exists $FichierDistanceMSF]} { if { ! [OuiOuNon "$FichierDistanceMSF\n doesn't exist. Do I calculate it ? "]} { return "" } set FichierDistanceMSF [CreeDistancesPhyloAvecLesMSFs $NotreOrga ".$NotreOrga"] } foreach Ligne [LesLignesDuFichier $FichierDistanceMSF] { scan $Ligne "%s" Nom set SesParalogues {} set SesDistances {} set Premier 1 foreach {Orga Dist Access} [lrange [split $Ligne " "] 1 end] { if {$Orga!=$NotreOrga} { continue } if {$Premier} { set Premier 0 } set Para [Narcisse $Access] if {$Para==$Nom} { continue } lappend SesParalogues $Para lappend SesDistances $Dist } lappend LesNomParalogues "$Nom [join $SesParalogues " "]" lappend LesNomDistances "$Nom [join $SesDistances " "]" } Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"] Espionne [SauveLesLignes $LesNomDistances dans "$FichierParalogues.dist"] } proc LesParametresDuDesign {args} { Wup "Permet de gerer et stocker les parametres du design et de les donner a toutes les procedures qui en ont besoin" #Utilisation Qui ValeurOuNon Quoi #Valeur pour Qui (ex): #LesZones #NbOligo ... #Valeur pour Quoi: #Positionne Positionne le parametre a la valeur #Ajoute Ajoute ou positionne le parametre si il n existe pas #Existe Retourne 1 si la valeur existe ou 0 sinon #LaValeurMerci Retourne la valeur du parametre ou vide sinon #Reset Positionne la valeur a vide #UnsetAll Efface tout #Particulier: #Qui=all Retourne toutes les valeurs du tableau #Qui=UnsetAll Vide le tableau en entier #Quoi=Reset et Valeur=all Supprime toutes les entrees de Qui (Ex:LesZones*) #Qui=LesZones peut etre seul ou associe avec LaSequence (voir les join args par ",") global ParametresDuDesign set Qui [lindex $args 0] if { $Qui==""} { return "" } elseif {$Qui=="all"} { if {[info exists ParametresDuDesign]} {return [array get ParametresDuDesign]} } elseif {$Qui=="UnsetAll"} { array unset ParametresDuDesign "*" return "" } set NbArgs [llength $args] #Valeur si il y en a une ok sinon c est aussi $Qui set Valeur [lindex $args end-1] set Quoi [lindex $args end] if {$Quoi==""} {set Quoi "LaValeurMerci"} if {$Quoi=="Positionne"} { if {$Qui=="LesZones" && [expr $NbArgs > 3]} { set Qui [join [lrange $args 0 end-2] ","] } set ParametresDuDesign($Qui) $Valeur return "" } elseif {$Quoi=="Reset"} { if {$Valeur=="all"} { array unset ParametresDuDesign "$Qui*" } else { if {$Qui=="LesZones" && [expr $NbArgs > 2]} { set Qui [join [lrange $args 0 end-1] ","] } if {[info exists ParametresDuDesign($Qui)]} {unset ParametresDuDesign($Qui)} } } elseif {$Quoi=="LaValeurMerci"} { if {$Qui=="LesZones" && [expr $NbArgs > 2]} { set Qui [join [lrange $args 0 end-1] ","] } if {[info exists ParametresDuDesign($Qui)]} {return [set ParametresDuDesign($Qui)]} else {return ""} } elseif {$Quoi=="Ajoute"} { if {$Qui=="LesZones" && [expr $NbArgs > 3]} { set Qui [join [lrange $args 0 end-2] ","] } lappend ParametresDuDesign($Qui) $Valeur } elseif {$Quoi=="Existe"} { if {$Qui=="LesZones" && [expr $NbArgs > 2]} { set Qui [join [lrange $args 0 end-1] ","] } if {[info exists ParametresDuDesign($Qui)]} {return 1} else {return 0} } return "" } proc LesParametresDuDesign_OLD {Qui {Valeur ""} {Quoi ""}} { Wup "Permet de gerer et stocker les parametres du design et de les donner a toutes les procedures qui en ont besoin" #Positionne Positionne le parametre a la valeur #Ajoute Ajoute ou positionne le parametre si il n existe pas #Existe Retourne 1 si la valeur existe ou 0 sinon #LaValeurMerci Retourne la valeur du parametre ou vide sinon #Reset Positionne la valeur a vide #UnsetAll Efface tout global ParametresDuDesign #Espionne "Param $Qui $Valeur $Quoi" if {$Qui==""} { return "" } elseif {$Qui=="all"} { if {[info exists ParametresDuDesign]} {return [array get ParametresDuDesign]} } elseif {$Qui=="UnsetAll"} { array unset ParametresDuDesign "*" return "" } if {$Quoi==""} {set Quoi "LaValeurMerci"} if {$Quoi=="Positionne"} { set ParametresDuDesign($Qui) $Valeur return "" } elseif {$Quoi=="Reset"} { if {[info exists ParametresDuDesign($Qui)]} {unset ParametresDuDesign($Qui)} } elseif {$Quoi=="LaValeurMerci"} { if {[info exists ParametresDuDesign($Qui)]} {return [set ParametresDuDesign($Qui)]} else {return ""} } elseif {$Quoi=="Ajoute"} { lappend ParametresDuDesign($Qui) $Valeur } elseif {$Quoi=="Existe"} { if {[info exists ParametresDuDesign($Qui)]} {return 1} else {return 0} } return "" } proc LesParametresDuSetUp {Qui {Valeur ""} {Quoi ""}} { Wup "Permet de gerer et stocker les parametres du design et de les donner a toutes les procedures qui en ont besoin" #Positionne Positionne le parametre a la valeur #Ajoute Ajoute ou positionne le parametre si il n existe pas #Existe Retourne 1 si la valeur existe ou 0 sinon #LaValeurMerci Retourne la valeur du parametre ou vide sinon #Reset Positionne la valeur a vide #UnsetAll Efface tout global ParametresDuSetUp Espionne "Param $Qui $Valeur $Quoi" if {$Qui==""} { return "" } elseif {$Qui=="all"} { if {[info exists ParametresDuSetUp]} {return [array get ParametresDuSetUp]} } elseif {$Qui=="UnsetAll"} {array unset ParametresDuSetUp;return ""} if {$Quoi==""} {set Quoi "LaValeurMerci"} if {$Quoi=="Positionne"} { set ParametresDuSetUp($Qui) $Valeur return "" } elseif {$Quoi=="Reset"} { if {[info exists ParametresDuSetUp($Qui)]} {unset ParametresDuSetUp($Qui)} } elseif {$Quoi=="LaValeurMerci"} { if {[info exists ParametresDuSetUp($Qui)]} {return [set ParametresDuSetUp($Qui)]} else {return ""} } elseif {$Quoi=="Ajoute"} { lappend ParametresDuSetUp($Qui) $Valeur } elseif {$Quoi=="Existe"} { if {[info exists ParametresDuSetUp($Qui)]} {return 1} else {return 0} } return "" } proc LesParametresParDefaut {} { Wup "Positione les parametres du design par defaut" #Les parametres par defauts #Pour la methode de calcul du Tm NearestNeighbor #Pour la Specificite 70 percent et 15 bases contigues #Pour le Pas on positionne a 10 #Pour le Blast expect limite 100 #Pour le Blast taille des mots 15 #Pour le Blast max a aligne 2000 #Pour le nombre d oligo 100 #QueryCheck 1 set LesParamsParDefaut [list NbOligo "100" TmMethod "NearestNeighbor" IdLimit "70.0" NbContiguous "15" Step "10" BlastExpect "100" BlastWord "15" BlastNbAligned "2000" BlastStrand "1" QueryCheck "1"] foreach {Param Valeur} $LesParamsParDefaut { if {! [LesParametresDuDesign $Param "Existe"]} { LesParametresDuDesign $Param $Valeur "Positionne" } else {continue} } return "" } proc LesParticuliersPourRegine {FichierSortie} { set FichierCorres "[RepertoireDuGenome]/lacorrespondance" foreach Ligne [LesLignesDuFichier $FichierCorres] { if {$Ligne==""} {continue} set Ligne [split $Ligne "\t"] set New [lindex $Ligne 0]; set Old [lindex $Ligne 1] set O($New) $Old } set FichierParticRegine "[RepertoireDuGenome]/Regine/pbs_out" foreach Ligne [LesLignesDuFichier $FichierParticRegine] { if {$Ligne==""} {continue} set Vu($Ligne) 1 } set FichierPartic "[RepertoireDuGenome]/fiches/436profil" foreach Ligne [LesLignesDuFichier $FichierPartic] { if {$Ligne==""} {continue} set LesChamps [split $Ligne "\t"] set Code [lindex $LesChamps 0] if {[info exists Vu($Code)]} { Espionne $Code set HNK $O($Code) set User [lindex $LesChamps 1] set CodeClone [lindex $LesChamps 2] set Bande [lindex $LesChamps 3] set Ite [lindex $LesChamps 4] set Ine [lindex $LesChamps 5] set Its [lindex $LesChamps 6] set Ins [lindex $LesChamps 7] set Itu [lindex $LesChamps 8] set Inu [lindex $LesChamps 9] set DifMoy [lindex $LesChamps 10] set Pmoy [lindex $LesChamps 11] set PDD [lindex $LesChamps 12] set PDD2 [lindex $LesChamps 13] if {$PDD=="" && $PDD2!=""} {set PDD $PDD2} set ProfCons [lindex $LesChamps 14] set ProfVN [lindex $LesChamps 15] set ProfNorthern [lindex $LesChamps 16] set ProfMb [lindex $LesChamps 17] lappend Liste "$HNK\t$Code\t$CodeClone\t$Bande\t$User\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu\t$DifMoy\t$Pmoy\t$PDD\t$ProfCons\t$ProfVN\t$ProfNorthern\t$ProfMb" } } Espionne [llength $Liste] SauveLesLignes $Liste dans $FichierSortie } proc LesPatternSelectedPourPromAn {FileTFA Pattern TSSPosition} { if {$Pattern == ""} { return } set LesInfos {} set LesInfosAntisense {} set ResultType "PatternResearch" set LesPatternsSelected [PatternResearchInSeqFileTFA $Pattern $FileTFA] foreach PatternSelected $LesPatternsSelected { set Debut [lindex $PatternSelected 0] set Fin [lindex $PatternSelected 1] set TSSDist1 [expr -1 * ($TSSPosition - $Debut)] set TSSDist2 [expr -1 * ($TSSPosition - $Fin) ] if {[expr abs($TSSDist1)] < [expr abs($TSSDist2)]} {set TSSDist $TSSDist1} else {set TSSDist $TSSDist2} lappend LesInfos [list $Pattern $ResultType $Debut $Fin "+" "" $TSSDist "100.00" $Pattern ""] } set LesInfos [lsort -index 6 -real -command CompareLaVADesNombres $LesInfos] set PatternRAndC [NucToReverseAndComplementNuc $Pattern] set LesPatternsSelected [PatternResearchInSeqFileTFA $PatternRAndC $FileTFA] foreach PatternSelected $LesPatternsSelected { set Debut [lindex $PatternSelected 0] set Fin [lindex $PatternSelected 1] set TSSDist1 [expr -1 * ($TSSPosition - $Debut)] set TSSDist2 [expr -1 * ($TSSPosition - $Fin) ] if {[expr abs($TSSDist1)] < [expr abs($TSSDist2)]} {set TSSDist $TSSDist1} else {set TSSDist $TSSDist2} lappend LesInfosAntisense [list "$Pattern antisense" $ResultType $Debut $Fin "-" "" $TSSDist "100.00" "$Pattern antisense" ""] } set LesInfosAntisense [lsort -index 6 -real -command CompareLaVADesNombres $LesInfosAntisense] foreach InfoAntisense $LesInfosAntisense {lappend LesInfos $InfoAntisense} return $LesInfos } proc LesPbBLASTsRefSeq_Design {} { Wup "Design de RefSeq complet, environ 19200" Wup "Pour faire les masked tous d un seul coup" set DataBase "/blast/rshuman.nsq" set Dir "[RepertoireDuGenome]/Probes/RefSeq_TFA" set LesQuerys [glob -nocomplain -directory $Dir "NM*"] #set Index [lsearch $LesQuerys "[RepertoireDuGenome]/Probes/RefSeq_TFA/NM145199"] #set LesQuerys [lrange $LesQuerys $Index end]] set NbPb 0 foreach Query $LesQuerys { set Dir "[RepertoireDuGenome]/Probes/RefSeq_Design" set NMDIR [LeRepertoireDeRefSeq [file tail $Query]] set Dir "${Dir}/${NMDIR}" set Q [file tail $Query] if {[file exists "$Dir/${Q}.blastn"]} { #file delete -force "$Dir/${Q}.blastn" #file delete -force "$Dir/${Q}.log" #file delete -force "$Dir/${Q}.oligo" #file delete -force "$Dir/${Q}.encours" #file delete -force "$Dir/${Q}.selection" incr NbPb } else { Espionne "NoBlast for $Dir/$Q" } } Espionne "NbPb $NbPb" } proc LesPdbDesRecepteursNucleaires {} { NousAllonsAuBoulot "/genomics/link/ProGS/NuclearReceptor" set LesAccessPDB [LesLignesDuFichier "nuclearbinding_list.txt"] foreach Access $LesAccessPDB { set Access [string trim $Access] if {$Access==""} { continue } set a [string tolower $Access] set T [TextePDB $a "all"] if {$T==""} { lappend LesAbsents $Access; continue } Espionne [Sauve $T dans "$a.pdb"] lappend LesPresents $a } set P [AfficheListe $LesPresents "AvecFetche"] AfficheListe $LesAbsents OnRevientDuBoulot return $P } proc LesPetitesRegionsDesGrandesRegions {LesGrandesRegions} { set LesBornes {} set NbRegions [llength $LesGrandesRegions] foreach UneGrandeRegion $LesGrandesRegions { set D [Mini [lindex $UneGrandeRegion 0] [lindex $UneGrandeRegion 1]] set F [Maxi [lindex $UneGrandeRegion 0] [lindex $UneGrandeRegion 1]] if {![info exists TabDebut($D)]} {set TabDebut($D) 1} if {![info exists TabFin($F) ]} {set TabFin($F) 1} for {set i $D} {$i <= $F} {incr i} {lappend LesBornes $i} } set i 0 set LesPetitesRegions {} set LesBornes [lsort -unique -integer $LesBornes] set DebutDeRef [lindex $LesBornes 0] foreach Borne $LesBornes { incr i set EstUnDebut 0 set EstUneFin 0 set EstDebutDeRef 0 set ProchainEstUnDebut 0 set ProchainEstUneFin 0 if {[info exists TabDebut($Borne) ]} {set EstUnDebut 1} if {[info exists TabFin($Borne) ]} {set EstUneFin 1} if {[info exists TabDebut([expr $Borne+1])]} {set ProchainEstUnDebut 1} if {[info exists TabFin([expr $Borne+1])]} {set ProchainEstUneFin 1} if {$Borne == $DebutDeRef } {set EstDebutDeRef 1} if {$EstUnDebut && $EstUneFin} { if {!$EstDebutDeRef} { lappend LesPetitesRegions [list $DebutDeRef [lindex $LesBornes [expr $i-2]]] } lappend LesPetitesRegions [list $Borne $Borne] set DebutDeRef [lindex $LesBornes $i] continue } if {$EstUneFin} { if {!$EstDebutDeRef} { lappend LesPetitesRegions [list $DebutDeRef $Borne] } else { lappend LesPetitesRegions [list $Borne $Borne] } set DebutDeRef [lindex $LesBornes $i] continue } if {$EstUnDebut} { if {!$EstDebutDeRef} { lappend LesPetitesRegions [list $DebutDeRef [lindex $LesBornes [expr $i-2]]] } if {$ProchainEstUnDebut} { lappend LesPetitesRegions [list $Borne $Borne] set DebutDeRef [lindex $LesBornes $i] } else { set DebutDeRef $Borne } continue } } return [lsort -integer -index 0 $LesPetitesRegions] } proc LesPetitesRegionsDuBlast {aTabBlast FichierTFA {LesBanquesIdOuLesContigs All} {TailleMin None} {SeuilId None} {JeBlastLesRegionsAbsentes 1}} { upvar $aTabBlast TabBlast #Parametres du second blast des regions absentes du premier blast set Filtre F set NbSubject 250 set ExpectDeRef 1 set EditCommand 0 set RepertoireDeW [RepertoireDeTravail] set NomFichier [file tail $FichierTFA] set BIdDeRef [set TabBlast(1)] regexp -nocase {(HS[0-9XYUn]*):([0-9a-z]*)} $BIdDeRef tmp Chromosome ContigDeRef set LesPetitesRegions [LaFrequenceDesPetitesRegions TabBlast $LesBanquesIdOuLesContigs $SeuilId] set LesPetitesRegions_tmp $LesPetitesRegions set LesPetitesRegions {} foreach UneRegion $LesPetitesRegions_tmp { set Deb [lindex $UneRegion 0] set Fin [lindex $UneRegion 1] set Freq [lindex $UneRegion 2] if {$Freq != "0"} {lappend LesPetitesRegions $UneRegion;continue} if {$JeBlastLesRegionsAbsentes != 1} {lappend LesPetitesRegions $UneRegion;continue} set FichierTFA_tmp "$RepertoireDeW/${NomFichier}_${Deb}_${Fin}" set FichierBlast_tmp "$RepertoireDeW/${NomFichier}_${Deb}_${Fin}.blastnhuman" set Seq [string range [QueLaSequenceDuTFA $FichierTFA] [expr $Deb-1] [expr $Fin-1]] if {$TailleMin != "None" && [string length $Seq] < $TailleMin} { lappend LesPetitesRegions $UneRegion continue } set Entete "[PremiereLigneDuFichier $FichierTFA] AREA $Deb to $Fin" set SeqTFA [SequenceFormatTFA $Seq $Entete] Sauve $SeqTFA dans $FichierTFA_tmp if {![ValidationDeLaSequenceMasquee $FichierTFA_tmp]} { lappend LesPetitesRegions $UneRegion continue } Espionne "BlastN $Deb -> $Fin" BlastNDuFichier $FichierTFA_tmp human $FichierBlast_tmp $Filtre $NbSubject $ExpectDeRef $EditCommand DepouilleLeBlast TabBlastTmp $FichierBlast_tmp $ExpectDeRef $NbSubject if {![file exists $FichierBlast_tmp] || ![info exists TabBlastTmp(1)]} { lappend LesPetitesRegions $UneRegion continue } set LesPetitesRegionsAbsentes [LaFrequenceDesPetitesRegions TabBlastTmp $ContigDeRef $SeuilId] if {$LesPetitesRegionsAbsentes != {}} { foreach UnePetiteRegionAbsente $LesPetitesRegionsAbsentes { set DebTmp [expr $Deb + [lindex $UnePetiteRegionAbsente 0] - 1] set FinTmp [expr $Deb + [lindex $UnePetiteRegionAbsente 1] - 1] set UnePetiteRegionAbsente [lreplace $UnePetiteRegionAbsente 0 1 $DebTmp $FinTmp] lappend LesPetitesRegions $UnePetiteRegionAbsente } } else { lappend LesPetitesRegions $UneRegion } unset TabBlastTmp File delete -force $FichierBlast_tmp File delete -force $FichierTFA_tmp } return $LesPetitesRegions } proc LesPfamStartStop {FileMacsims ListeNames Box Ref} { set LesPfamStartStop {} InitPosRel2Abs $FileMacsims $ListeNames foreach Chacun $ListeNames { if {$Chacun==$Ref} {set Chacun $Box} set LesPfamsChacun [FromMacsims $FileMacsims $Chacun "ConcatPfam"] foreach PfamChacun $LesPfamsChacun { set MotsPfamChacun [split $PfamChacun "/"] set Pfam [lindex $MotsPfamChacun 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id regsub "ERROR_" $Id "" Id FstartFstop $PfamChacun RFstart RFstop set Start [DonnePosRA $Chacun $RFstart Absolue] set Stop [DonnePosRA $Chacun $RFstop Absolue] set PfSS "$Id $Start $Stop" lappend LesPfamStartStop $PfSS } } set LesPfamStartStop [lsort -unique $LesPfamStartStop] set LesPfamStartStop [lsort -command TriePfSS $LesPfamStartStop] return $LesPfamStartStop } proc LesPfamStartStopNonRedondant {LaCourante} { set collapse 1 while {$collapse} { if {[llength $LaCourante]<2} {break} set lA [lrange $LaCourante 0 end-1] set lB [lrange $LaCourante 1 end] set i -1 foreach A $lA B $lB { DecortiquePfSS $A PfA StartA StopA DecortiquePfSS $B PfB StartB StopB if {$PfA!=$PfB || ! [Recouvrement $StartA $StopA $StartB $StopB]} { set collapse 0 incr i continue } set StartN [Mini $StartA $StartB] set StopN [Maxi $StopA $StopB] set N "$PfA $StartN $StopN" lappend LesAnciens($N) $A $B if {[info exists LesAnciens($A)]} { set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($A)]] } if {[info exists LesAnciens($B)]} { set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($B)]] } set collapse 1 break } if { ! $collapse } { break } set LaCourante [lreplace $LaCourante [expr $i+1] [expr $i+2] $N] } return $LaCourante } proc LesPhrasesMemorisees {{LesPhrasesAMemoriser ""}} { global LesPhrasesMemorisees if {[string equal -nocase $LesPhrasesAMemoriser "unset"]} { if {[info exists LesPhrasesMemorisees]} {unset LesPhrasesMemorisees} return } if {$LesPhrasesAMemoriser != ""} { set LesPhrasesMemorisees [LesPhrasesNettoyees $LesPhrasesAMemoriser] return $LesPhrasesMemorisees } if {[info exists LesPhrasesMemorisees]} {return $LesPhrasesMemorisees} return } proc LesPhrasesNettoyees {LesPhrases} { set LesPhrasesNettoyees {} foreach Phrase $LesPhrases { set Phrase [string toupper $Phrase] regsub -all {[^0-9A-Z_\-\+\.]|\. |\.$} $Phrase " " Phrase regsub -all -nocase "hypothetical protein" $Phrase " " Phrase regsub -all -nocase "full insert sequence" $Phrase " " Phrase regsub -all -nocase "full length" $Phrase " " Phrase regsub -all -nocase "similar to" $Phrase " " Phrase regsub -all -nocase "supported by" $Phrase " " Phrase while {[regexp " " $Phrase]} {regsub -all " " $Phrase " " Phrase} set Phrase [string trim $Phrase] set LaPhrase {} foreach Mot [split [string trim $Phrase] " "] { if {[EstCeQueCeMotEstInterdit $Mot]} {continue} lappend LaPhrase $Mot } if {$LaPhrase == {}} {continue} lappend LesPhrasesNettoyees [join $LaPhrase " "] } return $LesPhrasesNettoyees } proc LesPlusProchesPABs {Sequence {BestOnlyOrExpectOrMaxList ""} {ForceNucProt ""} {BanqueBlast ""} {Programme ""}} { set SequencePropre "" foreach Ligne [split $Sequence "\n"] { if {[regexp ">" $Ligne]} { continue } regsub -nocase -all {[^a-z]} $Ligne "" S append SequencePropre $S } set Sequence $SequencePropre set IsProt [IsProt $Sequence $ForceNucProt] set BanqueProt "[RepertoireDuGenome]/banques/AllProttfa" set BanqueNuc "[RepertoireDuGenome]/banques/AllNuctfa" if {$BanqueBlast==""} { if {$IsProt} { if {$Programme==""} { set Programme "P" } set BanqueBlast $BanqueProt } else { if {$Programme==""} { set Programme "N" } set BanqueBlast $BanqueNuc } } set PremiereFois 1 while {[FileAbsent $BanqueBlast]} { FaireLire "I can not find the BlastDatabase $BanqueBlast\nPlease help me" set BanqueBlast [Entre $BanqueBlast] if {[FileExists $BanqueBlast]} { break } if {$PremiereFois && [OuiOuNon "Do I try tblastN or blastX"]} { set PremiereFois 0 if {$IsProt} { if {[file exists $BanqueNuc]} { set Programme "tblastn" ; set BanqueBlast $BanqueNuc ; break} } else { if {[file exists $BanqueProt]} { set Programme "blastx" ; set BanqueBlast $BanqueProt ; break} } } if {[OuiOuNon "Do we continue later"]} { return "" } } set BlastOut [Blast $Programme $Sequence "retourne" $BanqueBlast "NoGenericCommand"] if {[regexp -nocase "Best" $BestOnlyOrExpectOrMaxList]} { set CutPN 0.001 set MaxListe 1 } elseif {[regexp {^[0-9]+$} $BestOnlyOrExpectOrMaxList]} { set CutPN 0.001 set MaxListe $BestOnlyOrExpectOrMaxList } elseif {[regexp {^[\.\-\+-eE0-9]+$} $BestOnlyOrExpectOrMaxList]} { set CutPN $BestOnlyOrExpectOrMaxList set MaxListe "" } else { set CutPN "" set MaxListe "" } set N [DecortiqueBlast $BlastOut $CutPN $MaxListe Query lBanqueId lAccess lDE lProfil lPN] if {$N==0} { return "" } set Retour {} foreach ID $lBanqueId AC $lAccess DE $lDE PN $lPN { lappend Retour "$ID\t$AC\t$DE\tExpect=$PN" } return [join $Retour "\n"] } proc LesPositionsDeNosAccessSurLaPuce_Ontario {{Fichier ""}} { Wup "ATTENTION DESUET VOIR InterrogeActiChip2Ontario" Wup "Permet de relire le fichier de nos sequences propres avec les Ids presents sur la puce" Wup "Permet d associer a chaque Id la position sur la plaque grace au galfile et un PAB" Wup "Permet de relire le fichier de nos sequences propres avec les Ids" ############################## #GAL FILE is BLOCK ROW COLUMN# ############################## global TabDesPositions if {$Fichier==""} {set Fichier "[RepertoireDuGenome]/Autres_Puces/Ontario/Chip_EST_Gene_Present.txt"} set F [open "$Fichier"] while {[gets $F Ligne]>=0} { #GScopeAccess ProteinAccess DesignAccess Definition Chip_EST Original_Image_ID Verified_Image_ID clusterID if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} if { [regexp -nocase "^GScopeAccess" $Ligne] || [regexp -nocase "^GScope Access" $Ligne]} {continue} set LigneSplitee [split $Ligne "\t"] set GScopeAccess [lindex $LigneSplitee 0] set ProteinAccess [lindex $LigneSplitee 1] set DesignAccess [lindex $LigneSplitee 2] set Definition [lindex $LigneSplitee 3] set Chip_EST [lindex $LigneSplitee 4] set LesOriginal_Image_ID [lindex $LigneSplitee 5] set LesVerified_Image_ID [lindex $LigneSplitee 6] set clusterID [lindex $LigneSplitee 7] if {! [expr $Chip_EST >=1]} { continue } else { if {[expr $Chip_EST > 1]} { regsub -all {\"} $LesOriginal_Image_ID "" LesOriginal_Image_ID regsub -all {\"} $LesVerified_Image_ID "" LesVerified_Image_ID set LesOriginal_Image_ID [split $LesOriginal_Image_ID ";"] set LesVerified_Image_ID [split $LesVerified_Image_ID ";"] } foreach Original_Image_ID $LesOriginal_Image_ID Verified_Image_ID $LesVerified_Image_ID { if { [InterrogeLeGalFile_Ontario $Verified_Image_ID $Original_Image_ID Block] != ""} { set Block [InterrogeLeGalFile_Ontario $Verified_Image_ID $Original_Image_ID Block] set Col [InterrogeLeGalFile_Ontario $Verified_Image_ID $Original_Image_ID Col] set Row [InterrogeLeGalFile_Ontario $Verified_Image_ID $Original_Image_ID Row] } elseif { [InterrogeLeGalFile_Ontario $Original_Image_ID $Verified_Image_ID Block] != ""} { set Block [InterrogeLeGalFile_Ontario $Original_Image_ID $Verified_Image_ID Block] set Col [InterrogeLeGalFile_Ontario $Original_Image_ID $Verified_Image_ID Col] set Row [InterrogeLeGalFile_Ontario $Original_Image_ID $Verified_Image_ID Row] } else {Espionne "$GScopeAccess pb de positionnement $LesOriginal_Image_ID $LesVerified_Image_ID";continue} set TabDesPositions($Block,$Row,$Col) 1 lappend TabDesPositions($Block,$Row,$Col,PAB) [string trim $GScopeAccess] #Espionne "B $Block R $Row C $Col PAB [string trim $GScopeAccess]" } } continue } close $F return "" } proc LesPpcrDesPs {} { foreach P [P5ofPPCR "LaListeDesPs"] { Espionne "$P" } exit } proc LesPremieresLignes {Numero {NombreDeLignes 847}} { #Reecrit dans un nouveau fichier les N premieres lignes d'un autre Espionne "LesPremieresLignes $Numero: Start" set Compteur 0 set FichierComplet [open "[Fiches]/NonBiDir/NonBidir$Numero.nb" "r"] set FichierCoupe [open "[Fiches]/NonBiDir/NonBidir.847.$Numero.nb" "w"] while { [gets $FichierComplet Ligne] >=0 && $Compteur < 847} { incr Compteur puts $FichierCoupe $Ligne } Espionne "LesPremieresLignes $Numero: End" } proc LesPremieresLignesDuFichier {Fichier n} { if { $Fichier == "" } {return {}} if {$n<1} { return {}} set f [open $Fichier r] set LesLignes {} while {[gets $f Ligne]>=0} { lappend LesLignes $Ligne if { ! [incr n -1]} { break } } close $f return $LesLignes } proc LesPresencesDesOrganismesDansCluster {Cluster LesOrganismes} { global RepertoireDuGenome set RepXHDA "$RepertoireDuGenome/bilan_xhda" set SeuilBlastPTBlastN 50 set TailleCluster [O2C2O Cluster $Cluster TailleCluster] foreach Orf [O2C2O Cluster $Cluster LesOrfs] { set FichierInfo "$RepXHDA/$Orf" if {![file exists $FichierInfo]} {continue} set F [open $FichierInfo] while {[gets $F Info] >=0} { scan $Info "%s %s %s %s" Box Orga TBlastN BlastP if {$TBlastN < $SeuilBlastPTBlastN || $BlastP < $SeuilBlastPTBlastN } {continue} set Organisme [O2C2O OrganismeCourt [string tolower $Orga] OrganismeLong] set EnEstCeUn 0 foreach OrgaDeRef $LesOrganismes { if {$Organisme == $OrgaDeRef} {set EnEstCeUn 1;break} } if {!$EnEstCeUn} {continue} if {![info exists TabTmp($Organisme)]} {set TabTmp($Organisme) 0} incr TabTmp($Organisme) } close $F } set LesPresences {} foreach Organisme $LesOrganismes { set n 0 if {[info exists TabTmp($Organisme)]} {set n [set TabTmp($Organisme)]} lappend LesPresences [expr $n * 100.0 / $TailleCluster] } return $LesPresences } proc LesPresentsAbsentsIndifferents {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} { global retourChoixMultiple global ChoixMultipleRadio global validOk Wup "returns 3 lists" if {$ListeDeTextes=={}} { set ListeDeTextes $Liste } if {[llength $Liste] == 0 } { return {} } set n 0 set LesLooks {} foreach Element $Liste { incr n set Look "a$n" lappend LesLooks $Look } if { [PourWscope] } { LesPAIs [ChoixMultiple $Look $ListeDeTextes] } else { set w [NomDe fenetre] catch {destroy $w} catch {unset validOk} toplevel $w wm geometry $w +300+100 wm title $w "$Invite" set MaxWidth 0 foreach Texte $ListeDeTextes { if { [string length $Texte] > $MaxWidth } { set MaxWidth [string length $Texte] } } frame $w.frame pack $w.frame -expand yes -fill both set BouRad "$w.frame.radios" set ScroHor "$w.frame.xscroll" set ScroVer "$w.frame.yscroll" scrollbar $ScroVer -command "$BouRad yview" scrollbar $ScroHor -command "$BouRad xview" -orient horizontal set CanvaScreenX 300 set CanvaScreenY 25 set HauteurUneLigne 25 canvas $BouRad -width $CanvaScreenX -height $CanvaScreenY -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" set HauteurTotale 5 foreach Look $LesLooks Element $Liste Texte $ListeDeTextes { set FLook "$BouRad.$Look" frame $FLook radiobutton $FLook.radioP -relief flat -variable ChoixMultipleRadio($Look) -value p radiobutton $FLook.radioA -relief flat -variable ChoixMultipleRadio($Look) -value a radiobutton $FLook.radioI -relief flat -variable ChoixMultipleRadio($Look) -value i label $FLook.text -width $MaxWidth -text $Texte -anchor "w" pack $FLook.radioP $FLook.radioA $FLook.radioI $FLook.text -side left $BouRad create window 0 $HauteurTotale -anchor "nw" -window $FLook incr HauteurTotale $HauteurUneLigne } $BouRad configure -scrollregion [list 0 0 $CanvaScreenX $HauteurTotale] grid $w.frame.radios -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $w.frame 0 -weight 1 -minsize 0 grid columnconfig $w.frame 0 -weight 1 -minsize 0 $BouRad configure -height [Mini [expr $HauteurTotale+60] 600] set Boutons $w.termine frame $Boutons button $Boutons.dismiss -text "Dismiss" -background "red" -command { set validOk 0 } button $Boutons.toutpresent -text "All +" -background "yellow" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) p } } button $Boutons.toutabsent -text "All -" -background "orange" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) a } } button $Boutons.toutindif -text "All X" -background "lightblue" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) i } } button $Boutons.validate -text "Validate" -background "green" -command { set validOk 1 } pack $Boutons -side top pack $Boutons.dismiss $Boutons.toutpresent $Boutons.toutabsent $Boutons.toutindif $Boutons.validate -side left tkwait variable validOk destroy $w if { ! $validOk} { return [list {} {} {}] } foreach Look $LesLooks { lappend LesPAIs [set ChoixMultipleRadio($Look)] } } set retourChoixMultiple {} set LesPresents {} set LesAbsents {} set LesIndifferents {} foreach Look $LesLooks Element $Liste PAI $LesPAIs { if { $PAI == "p" } { lappend LesPresents $Element } if { $PAI == "a" } { lappend LesAbsents $Element } if { $PAI == "i" } { lappend LesIndifferents $Element } } return [list $LesPresents $LesAbsents $LesIndifferents] } proc LesPresentsEtAbsents {Liste {ListeDeTextes ""} {Invite "Select ... and validate."}} { ###################################################### ###MODIFICATION DE LA PROC DE J. MULLER LesPEtA ### ###MODIFICATION DE LA COULEUR ET DU NOM DES BOUTONS### ###################################################### Wup "Permet une selection entre plusieurs choix" global ChoixMultipleRadio global validOk if { $ListeDeTextes == {}} {set ListeDeTextes $Liste} if {[llength $Liste] == 0 } {return [list {} {}]} set MaxScreenX [expr [winfo screenwidth .]/2] set MaxScreenY [expr [winfo screenheight .]/2] set n 0 set LesLooks {} foreach Element $Liste { incr n set Look "a$n" lappend LesLooks $Look } set w [NomDe fenetre] catch {destroy $w} catch {unset validOk} toplevel $w wm geometry $w +300+100 wm title $w "$Invite" #wm resizable $w false false #Creation des boutons ##################### set Boutons $w.termine frame $Boutons button $Boutons.dismiss -text "Dismiss" -command {set validOk 0} button $Boutons.toutpresent -text "Select All" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) p } } button $Boutons.toutabsent -text "Unselect All" -command { foreach Look [array names ChoixMultipleRadio] { set ChoixMultipleRadio($Look) a } } button $Boutons.validate -text "Validate" -command {set validOk 1} pack $Boutons -side bottom -pady 2 -fill x pack $Boutons.dismiss $Boutons.toutpresent $Boutons.toutabsent $Boutons.validate -side left -expand yes #Creation de la frame contenant # les radio boutons # les scrollbars ############################### frame $w.frame set BouRad "$w.frame.radios" set ScroHor "$w.frame.xscroll" set ScroVer "$w.frame.yscroll" scrollbar $ScroVer -command "$BouRad yview" scrollbar $ScroHor -command "$BouRad xview" -orient horizontal set CanvaScreenX 200 set CanvaScreenY 25 set HauteurUneLigne 25 canvas $BouRad -width $CanvaScreenX -height $CanvaScreenY -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" set HauteurTotale 5 set LargeurTotale 0 set TailleLabel 0 set LongestLabel 0 foreach Look $LesLooks Element $Liste Texte $ListeDeTextes { set FLook "$BouRad.$Look" frame $FLook radiobutton $FLook.radioP -relief flat -variable ChoixMultipleRadio($Look) -value p -width 0 radiobutton $FLook.radioA -relief flat -variable ChoixMultipleRadio($Look) -value a -width 0 label $FLook.text -text $Texte -anchor "w" -font {Courier 10} pack $FLook.radioP $FLook.radioA $FLook.text -side left $BouRad create window 0 $HauteurTotale -anchor "nw" -window $FLook incr HauteurTotale $HauteurUneLigne set TailleLabel [winfo reqwidth $FLook.text] if {$TailleLabel > $LongestLabel} { set LaPlusLongueFrame "$FLook" set LongestLabel $TailleLabel } } grid $w.frame.radios -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $w.frame 0 -weight 1 -minsize 0 grid columnconfig $w.frame 0 -weight 1 -minsize 0 pack $w.frame -expand yes -fill both #Mise a jour de la scroll region et de la taille du canvas update set Taille1 [winfo reqwidth $LaPlusLongueFrame] set Taille2 [winfo width $LaPlusLongueFrame] if {$Taille1 > $Taille2} {set Taille $Taille1} else {set Taille $Taille2} #set VraiCanvaX [expr $CanvaScreenX + [winfo width $BouRad]] #$BouRad configure -width [Mini $VraiCanvaX $MaxScreenX] $BouRad configure -width [Mini $Taille $MaxScreenX] $BouRad configure -height [Mini [expr $HauteurTotale+10] $MaxScreenY] $BouRad configure -scrollregion [list 0 0 $Taille $HauteurTotale] tkwait variable validOk destroy $w if {! $validOk} {return [list {} {}]} foreach Look $LesLooks { lappend LesPAIs [set ChoixMultipleRadio($Look)] } set LesPresents {} set LesAbsents {} foreach Look $LesLooks Element $Liste PAI $LesPAIs { if {$PAI == "p"} {lappend LesPresents $Element} if {$PAI == "a"} {lappend LesAbsents $Element} } return [list $LesPresents $LesAbsents] } proc LesProbesSetDeNosSequencesParBlast {{LesPABs ""}} { Wup "Permet de rechercher les access equivalents de nos sequences dans la puce affymetrix" Wup "Recherche faite au moyen du blastn" Wup "On se permet un cutoff pour GID de 95% et un recouvrement S/G de 95% aussi" set RepAffy "[RepertoireDuGenome]/Autres_Puces/Affy/U133A_2_0/" set RepBanque "$RepAffy/blastn" if {$LesPABs == ""} {set LesPABs [ActiChip2_0]} if {$LesPABs == "ActiChip1_0"} {set LesPABs [ActiChip1_0]} if {$LesPABs == "ActiChip2_0"} {set LesPABs [ActiChip2_0]} foreach PAB $LesPABs { set Identity 0.95 set PCoverQuery 0.95 set PCoverSubject 0.95 set FichierBlast "$RepBanque/$PAB" set NbSbjct [AskBlast $FichierBlast NbSubject] set TailleQuery [AskBlast $FichierBlast Taille] set NomQuery [AskBlast $FichierBlast Query] set LesProches "" if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} for {set i 1} {$i <=$NbSbjct} {incr i} { set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [AskBlast $FichierBlast Subject $i] #Pourcentage d'identite global: Aligne sur Total dans les alignements #Discremine les plus proches identiques sur les alignements des autres set IdGlobal [PourcentageDIdentiteGlobal $FichierBlast $BId] if {$IdGlobal<=$Identity} {continue} #Pourcentage d'identite etendu : Aligne sur Alignable #Discremine les identiques locaux (ex: poly A) de ceux bien alignes #PCoverQuery Query par rapport au Subject #set PRecouvrementQuery [PourcentageDeRecouvrement $FichierBlast $BId "Query"] #PCoverSubject Subject par rapport au Query set PRecouvrementSubject [PourcentageDeRecouvrement $FichierBlast $BId "Subject"] #Espionne ">>$BId IdGlobal $IdGlobal Cover S/Q $PRecouvrementQuery Cover Q/S $PRecouvrementSubject" #Espionne ">>$BId IdGlobal $IdGlobal Cover Q/S $PRecouvrementSubject" if {$PRecouvrementSubject <= $PCoverSubject} {continue} lappend LesProches $BId } #Espionne ">>>>>Choix: [join $LesProches " "]" AskBlast unsetfile $FichierBlast } return $LesProches } proc LesProceduresDuFichier {Fichier {aFichierContenant ""}} { if {$aFichierContenant!=""} { upvar $aFichierContenant FichierContenant } global GscopeDir if { ! [regexp "/" $Fichier] } { set Fichier "$GscopeDir/$Fichier" } if { ! [file exists $Fichier]} { return {} } set LesNomProc {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {^proc +([A-Z][a-zA-Z0-9_]+) +[\{[a-zA-Z)]} $Ligne Match NomProc]} { continue } lappend FichierContenant($NomProc) $Fichier lappend LesNomProc $NomProc } return $LesNomProc } proc LesProceduresExistantes {} { Wup "Returns the list of existing procs ... begining with Uppercase" global LesProceduresExistantes if { ! [info exists LesProceduresExistantes]} { set LesProceduresExistantes [lsort [info procs {[A-Z]*}]] } return $LesProceduresExistantes } proc LesProceduresNonAppelantes {} { foreach Procedure [LesProceduresExistantes] { set LesAppelees [QuiJAppel $Procedure "LaListeMerci"] if {$LesAppelees != {}} { continue } lappend LesProceduresNonAppelantes $Procedure } return $LesProceduresNonAppelantes } proc LesProceduresUsageUnique {} { global GscopeDir set FichierLesProceduresUsageUnique "$GscopeDir/lesproceduresusageunique" if {[file exists $FichierLesProceduresUsageUnique]} { return [LesLignesDuFichier $FichierLesProceduresUsageUnique] } foreach Procedure [LesProceduresExistantes] { set LesAppelantes [QuiMAppel $Procedure "LaListeMerci"] if {[llength $LesAppelantes] > 1} { continue } if {[llength $LesAppelantes] == 0} { set Appelante "PERSONNE" } else { set Appelante [lindex $LesAppelantes 0] } lappend LesProceduresUsageUnique "$Procedure $Appelante" } SauveLesLignes $LesProceduresUsageUnique dans $FichierLesProceduresUsageUnique return $LesProceduresUsageUnique } proc LesProchesDansLeBlast {FichierBlast {Identity ""} {PCoverQuery ""} {PCoverSubject ""} {FichierLog ""}} { Wup "Determine dans un fichier blast les BIds tres proches en fonction du IdGlobal puis du IdEtendu" set DirDesJumeaux "[RepertoireDuGenome]/Jumeaux" if {$Identity == ""} {set Identity 0.95} if {$PCoverQuery == ""} {set PCoverQuery 0.95} if {$PCoverSubject== ""} {set PCoverSubject 0.95} if {$FichierLog == ""} {set FichierLog "$DirDesJumeaux/TousLesJumeaux_${Identity}_${PCoverQuery}_${PCoverSubject}.log"} set NbSbjct [AskBlast $FichierBlast NbSubject] set TailleQuery [AskBlast $FichierBlast Taille] set NomQuery [AskBlast $FichierBlast Query] set LesProches "" if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} AppendAuFichier $FichierLog "\nQuery: $NomQuery" for {set i 1} {$i <=$NbSbjct} {incr i} { set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [AskBlast $FichierBlast Subject $i] #Pourcentage d'identite global: Aligne sur Total dans les alignements #Discremine les plus proches identiques sur les alignements des autres set IdGlobal [PourcentageDIdentiteGlobal $FichierBlast $BId] if {$IdGlobal<=$Identity} {continue} #PCoverQuery Query par rapport au Subject set PRecouvrementQuery [PourcentageDeRecouvrement $FichierBlast $BId "Query"] #PCoverSubject Subject par rapport au Query set PRecouvrementSubject [PourcentageDeRecouvrement $FichierBlast $BId "Subject"] #AppendAuFichier $FichierLog ">>$BId IdGlobal $IdGlobal Cover S/Q $PRecouvrementQuery Cover Q/S $PRecouvrementSubject" if {$PRecouvrementQuery <= $PCoverQuery || $PRecouvrementSubject <= $PCoverSubject} {continue} #Pourcentage d'identite etendu : Aligne sur Alignable #Discremine les identiques locaux (ex: poly A) de ceux bien alignes #set IdEtendu [PourcentageDesBasesAligneesSurToutesLesBasesAlignables_TabBlast TabBlast $BId] #set P2 [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables_TabBlast TabBlast $BId] lappend LesProches $BId AppendAuFichier $FichierLog ">>$BId IdGlobal $IdGlobal Cover S/Q $PRecouvrementQuery Cover Q/S $PRecouvrementSubject" } AskBlast unsetfile $FichierBlast return $LesProches } proc LesProcsEnDouble {{Meld ""}} { set Meld [string equal -nocase $Meld "Meld"] foreach F [LesSourcesDeGscope] { if { ! [regexp ".tcl$" $F]} { continue } if {[regexp "chalmel|jmuller" $F]} { continue } Espionne $F set F "[HomeRipp]/gscope/$F" foreach Ligne [LesLignesDuFichier $F] { if { ! [regexp {^proc ([^ ]+) } $Ligne Match P]} { continue } lappend LesSourcesDe($P) $F } } foreach {P Fs} [array get LesSourcesDe] { if {[llength $Fs]==1} { continue } set Egal "" if {[llength $Fs]==2} { set F1 [lindex $Fs 0] source $F1 set A1 [info args $P] set S1 [info body $P] set S1 "$A1\n$S1" set F2 [lindex $Fs 1] source $F2 set A2 [info args $P] set S2 [info body $P] set S2 "$A2\n$S2" Espionne "=$P=\n[join $Fs \n]\n" if {$P=="AttriDesAcDna"} { break Espionne "\n\n\n$S1\n\n\n" Espionne "\n\n\n$S2\n\n\n" } if {$S1==$S2} { set Egal "Ce sont les memes" } else { if {$Meld} { set T1 "[TmpFile][file tail $F1]" set T2 "[TmpFile][file tail $F2]" Sauve $S1 dans $T1 Sauve $S2 dans $T2 exec meld $T1 $T2 # FaireLire "Clique ici quand tu auras comparer les deux" file delete $T1 file delete $T2 } } } lappend LesDoubles "\n$P\n[join $Fs \n]\n$P $Egal\n" } return [AfficheListe $LesDoubles] } proc LesProfilsDeConsDesQueryPosDuMAF {TFAFile MAFFile {Arrondi 3}} { set QuerySeq [string toupper [TFA2SEQ $TFAFile]] regsub -all {[^A-Z]+} $QuerySeq "" QuerySeq set QueryLength [TailleDeLaSequenceDuFichierTFA $TFAFile] #set GCSmoothWindow [expr int($QueryLength / 10)] set QueryPos 0 ### Met chaque Res de QuerySeq dans un tableau indexe par $QueryPos foreach Res [split $QuerySeq ""] { incr QueryPos set TabRes($QueryPos) $Res } ################################ RAPPEL ######################################## ### n=1 si que la query a cette MAFPos ### ### n=1 si cette QueryPos n'est dans aucun block d'alignement du maf ### ### N=1 au minimum, jamais 0 car incremente pour chaque seq du maf ### ### nSurN=0 si QueryRes a cette MAFPos est un gap ### ### nSurN=0 si n=1 et N=1 cad si seule la query a un residu a cette position ### ### dans les autres cas, calcul de [expr $n * 1.0 / $N] ### ################################################################################ ############################################################################## #Espionne "LeGCProf" #set LeGCProf [LeNucProfileDeLaSeq $QuerySeq "GC" ] #Espionne "LeGCProf_s" #set LeGCProf_s [LeProfilLisse $LeGCProf $GCSmoothWindow] Espionne "LeProfn" set LeProfn [LeProfilnDesQueryPosDuMAF $TFAFile $MAFFile ] #set LeProfn_s [LeProfilLisse $LeProfn $SmoothWindow ] Espionne "LeProfN" set LeProfN [LeProfilNDesQueryPosDuMAF $TFAFile $MAFFile ] #set LeProfN_s [LeProfilLisse $LeProfN $SmoothWindow ] #Espionne "LeProfnSurN" #set LeProfnSurN [LeProfilnSurNDesQueryPosDuMAF $LeProfn $LeProfN ] #Espionne "LeProfnSurN: $LeProfnSurN" #set LeProfnSurN_s [LeProfilLisse $LeProfnSurN $SmoothWindow ] ############################################################################## set QueryPos 0 set LesProfilsDeConservation {} foreach n $LeProfn N $LeProfN { incr QueryPos set Res [set TabRes($QueryPos) ] #set n_s [format "%.${Arrondi}f" $n_s ] #set N_s [format "%.${Arrondi}f" $N_s ] #set nSurN [format "%.${Arrondi}f" $nSurN ] #set nSurN_s [format "%.${Arrondi}f" $nSurN_s] #set GC_s [format "%.${Arrondi}f" $GC_s ] #lappend LesProfilsDeConservation [list $QueryPos $QueryPos $Res $n $n_s $N $N_s $nSurN $nSurN_s $GC_s] lappend LesProfilsDeConservation [list $QueryPos $QueryPos $Res $n $N] } return $LesProfilsDeConservation } proc LesProfilsDeLaQuerySurToutLeBlast {FichierBlast {BaseAligneOuBaseDansAlignementOuLesDeux BaseAligne} {WhatSens BothSens} {LesBanqueId ""} {Expect 1e200}} { if {![file exists $FichierBlast]} {return ""} foreach BId $LesBanqueId { #Modif Jean #regsub {_[0-9]+$} $BId "" BId if {[regexp "_" $BId] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BId]} { regsub {_[0-9]+$} $BId "" BId } set TabBIdOk($BId) 1 } set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [AskBlast $FichierBlast Taille] set LesBId {} set NbSubjectDansBlast [AskBlast $FichierBlast NbSubject ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [AskBlast $FichierBlast Subject $j] if {[info exists BId_Court]} {unset BId_Court} #Modif Jean #regsub {_[0-9]+$} $BId "" BId_Court if {[regexp "_" $BId] && [regexp {^[a-zA-Z]{,2}[0-9]+_[0-9]+$} $BId]} { regsub {_[0-9]+$} $BId "" BId_Court } else { set BId_Court $BId } if {$LesBanqueId != "" && ![info exists TabBIdOk($BId_Court)]} {continue} if {![info exists TabProfil($BId_Court,1)]} { lappend LesBId $BId_Court for {set i 1} {$i <= $TailleQuery} {incr i} { set TabProfil($BId_Court,BaseAligne,$i) 0 set TabProfil($BId_Court,BaseDansAlignement,$i) 0 } } set NbSegments [AskBlast $FichierBlast BanqueId $BId NbSegment] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { set AlignLineaire [AskBlast $FichierBlast BanqueId $BId Segment $Segment AlignLineaire] if {$AlignLineaire == ""} {return ""} set Orientation [AskBlast $FichierBlast BanqueId $BId Segment $Segment Orientation] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set DQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment DQ ] set FQ [AskBlast $FichierBlast BanqueId $BId Segment $Segment FQ ] set Query [lindex [split $AlignLineaire "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split $AlignLineaire "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ == "-"} {continue} for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} {set Pos [expr $PosIni-$i]} else {set Pos [expr $PosIni+$i]} incr TabProfil($BId_Court,BaseDansAlignement,$Pos) if {$AQ == $AS} { if {![info exists TabProfil($BId_Court,BaseAligne,$Pos)]} {continue} incr TabProfil($BId_Court,BaseAligne,$Pos) } } if {$Sens == "-"} {set PosIni [expr $PosIni-$Indice]} else {set PosIni [expr $PosIni+$Indice]} } } } set LesProfils {} foreach BId $LesBId { set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} { if {[string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "BaseAligne"]} { lappend LeProfil [set TabProfil($BId,BaseAligne,$i)] continue } if {[string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "BaseDansAlignement"]} { lappend LeProfil [set TabProfil($BId,BaseDansAlignement,$i)] continue } if {[string equal -nocase $BaseAligneOuBaseDansAlignementOuLesDeux "LesDeux"]} { lappend LeProfil [list [set TabProfil($BId,BaseAligne,$i)] [set TabProfil($BId,BaseDansAlignement,$i)]] continue } } lappend LesProfils [list $BId $LeProfil] } return $LesProfils } proc LesProfilsDeLaQuerySurToutLeBlast_TabBlast {aTabBlast {BaseAligneOuBaseDansAlignementOuLesDeux BaseAligne} {WhatSens BothSens} {LesBanqueId ""}} { upvar $aTabBlast TabBlast foreach BId $LesBanqueId { regsub {_[0-9]+$} $BId "" BId set TabBIdOk($BId) 1 } if {![info exists TabBlast]} {return} set TypeDeBlast [set TabBlast(TypeDeBlast)] set Indice 1 if {$TypeDeBlast == "BLASTX" || $TypeDeBlast == "TBLASTX"} {set Indice 3} set TailleQuery [set TabBlast(Taille)] set LesBId {} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set j 1} {$j <= $NbSubjectDansBlast} {incr j} { set BId [set TabBlast($j)] if {[info exists BId_Court]} {unset BId_Court} regsub {_[0-9]+$} $BId "" BId_Court if {$LesBanqueId != "" && ![info exists TabBIdOk($BId_Court)]} {continue} if {![info exists TabProfil($BId_Court,1)]} { lappend LesBId $BId_Court for {set i 1} {$i <= $TailleQuery} {incr i} { set TabProfil($BId_Court,BaseAligne,$i) 0 set TabProfil($BId_Court,BaseDansAlignement,$i) 0 } } set NbSegments [set TabBlast($BId,NbSegment)] for {set Segment 1} {$Segment <= $NbSegments} {incr Segment} { if {![info exists TabBlast($BId,$Segment,AlignLineaire)]} {return ""} set DQ [set TabBlast($BId,$Segment,DQ) ] set FQ [set TabBlast($BId,$Segment,FQ) ] set Orientation [set TabBlast($BId,$Segment,Orientation)] set Sens [SensDeLaRegion $Orientation] if {$WhatSens != "BothSens" && $Sens != $WhatSens} {continue} set Query [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 0] scan $Query "%s %d %s %d" Entete D AliQuery F set LAliQuery [split $AliQuery ""] set Sbjct [lindex [split [set TabBlast($BId,$Segment,AlignLineaire)] "\n"] 2] scan $Sbjct "%s %d %s %d" Entete D AliSbjct F set LAliSbjct [split $AliSbjct ""] set Sens "+" if {$FQ < $DQ} {set Sens "-"} set PosIni $DQ foreach AQ $LAliQuery AS $LAliSbjct { if {$AQ == "-"} {continue} for {set i 0} {$i < $Indice} {incr i} { if {$Sens == "-"} {set Pos [expr $PosIni-$i]} else {set Pos [expr $PosIni+$i]} incr TabProfil($BId_Court,BaseDansAlignement,$Pos) if {$AQ == $AS} { if {![info exists TabProfil($BId_Court,BaseAligne,$Pos)]} {continue} incr TabProfil($BId_Court,BaseAligne,$Pos) } } if {$Sens == "-"} {set PosIni [expr $PosIni-$Indice]} else {set PosIni [expr $PosIni+$Indice]} } } } set LesProfils {} foreach BId $LesBId { set LeProfil {} for {set i 1} {$i <= $TailleQuery} {incr i} { if {$BaseAligneOuBaseDansAlignementOuLesDeux == "BaseAligne"} { lappend LeProfil [set TabProfil($BId,BaseAligne,$i)] continue } if {$BaseAligneOuBaseDansAlignementOuLesDeux == "BaseDansAlignement"} { lappend LeProfil [set TabProfil($BId,BaseDansAlignement,$i)] continue } if {$BaseAligneOuBaseDansAlignementOuLesDeux == "LesDeux"} { lappend LeProfil [list [set TabProfil($BId,BaseAligne,$i)] [set TabProfil($BId,BaseDansAlignement,$i)]] continue } } lappend LesProfils [list $BId $LeProfil] } return $LesProfils } proc LesProjetsDe {{User ""} {QuoiEncore ""} {Action ""} {SansDoublon ""}} { if {$Action==""} { set Action "Show" } set SansDoublon [string equal -nocase $SansDoublon "SansDoublon"] if {$QuoiEncore==""} { set QuoiEncore "Rien" } set NbSeqTotal 0 set NbProjects 0 set OldNbSeq -1 set LesBornes [glob -nocomplain "/genomics/g*/*/fiches/bornesdespabs"] LConcat LesBornes [glob -nocomplain "/gstock/*/fiches/bornesdespabs"] foreach Fichier $LesBornes { set Owner [file attributes $Fichier -owner] if {$User!=""} { set Ligne [exec ls -l $Fichier] if { ! [regexp $User $Ligne]} { if {$User!="Inconnu"} { continue } if {$User=="Inconnu" && ! [regexp {^[0-9]+$} $Owner]} { continue } else { set Owner "Inconnu" } } } set Rep [file tail [file dirname [file dirname $Fichier]]] set NbSeq [llength [LesLignesDuFichier $Fichier]] # Espionne "$Owner $Rep $NbSeq $Fichier" if {$NbSeq==0} { set OldNbSeq $NbSeq ; continue } # Espionne "$SansDoublon && $OldNbSeq==$NbSeq" if {$SansDoublon && $OldNbSeq==$NbSeq} { continue } set OldNbSeq $NbSeq incr NbSeqTotal $NbSeq incr NbProjects set Retour [format "%-10s %-20s %s" $Owner $Rep $Fichier] if {$QuoiEncore=="NbSeq"} { set Retour [format "%-28s %10d %s" $Rep $NbSeq sequences] } else { if {$QuoiEncore!="Rien"} { append Retour [set $QuoiEncore] } } lappend LesProjets $Retour } lappend LesProjets [format "%15d %-12s %10d %s" $NbProjects projects $NbSeqTotal sequences] if {$Action=="GetList"} { return $LesProjets } set Clavier "Postpone" TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "Magenta" TouchePour $Clavier "RangeGstock" "RangeGstock \[set PagePropre(@F@)\]" TouchePour <2> "/ sel." "RangeGstock \[selection get\]" TouchePour <3> "/DoIt" "RangeGstock \[selection get\] - Force" set F [AfficheListe $LesProjets "" "$User Gscope_Projects"] return $F } proc LesPrositesDuTFA {f} { set Ll [LancePSScan $f] array set R [list] set Lpos [list] foreach l $Ll { if {[string index $l 0] eq ">"} { if {$Lpos != {}} { lappend R($n) $ps $Lpos set Lpos [list] } lassign [split [string range $l 1 end] " "] n tmp ps tmp } else { regsub -all { +} [string trim $l] " " l lassign [split $l " "] p1 tmp p2 tmp lappend Lpos $p1 $p2 } } if {$Lpos != {}} { lappend R($n) $ps $Lpos } return [array get R] } proc LesProtSsSeq {} { set FichierPoub "/genomics/link/Tau/Dec2008/GSTRdCVF/BlastpSurStringHomme/poub" } proc LesProteinesAvecCesGO {LesGO {LesOrgas ""} {Field ""} {Banque protein}} { set LesRequetes [LesRequetesDesGOEtDesDescendants $LesGO] set nRequetes [llength $LesRequetes] if {$nRequetes == 0} {return} set i 0 set LesKW {} set LesDR {} set LesDES {} foreach LaRequete $LesRequetes { set What [lindex $LaRequete 0] set Requete [string trim [lindex $LaRequete 1]] while {[regexp " " $Requete]} {regsub -all " " $Requete " " Requete} if {$Requete == ""} {continue} if {[string equal -nocase $What "spkw2go"]} { lappend LesKW $Requete continue } if {[string equal -nocase $What "ec2go"]} { regsub ":" $Requete " " Requete lappend LesDES $Requete continue } lappend LesDR $Requete } set Commande "[ProgPathway getz] \"\(" set PresenceCommandeAvant 0 if {$LesDR != {}} { set DR [join $LesDR "|"] regsub "\\\|" $DR "\|" DR append Commande "\\\[$Banque-DR:$DR\\\]" set PresenceCommandeAvant 1 } if {$LesKW != {}} { if {$PresenceCommandeAvant} {append Commande " \| "} set KW [join $LesKW "|"] regsub "\\\|" $KW "\|" KW append Commande "\\\[$Banque-KEY:$KW\\\]" set PresenceCommandeAvant 1 } if {$LesDES != {}} { if {$PresenceCommandeAvant} {append Commande " \| "} set DES [join $LesDES "|"] regsub "\\\|" $DES "\|" DES append Commande "\\\[$Banque-DES:$DES\\\]" set PresenceCommandeAvant 1 } append Commande "\)" if {$LesOrgas != ""} { set Orgas [join $LesOrgas "|"] regsub "\\\|" $Orgas "\|" Orgas append Commande " \& \\\[$Banque-ORG:$Orgas\\\]" } if {$Field != ""} { append Commande "\" -f \{$Field\} " } else { append Commande "\"" } Espionne $Commande set LesInfos [split [eval exec $Commande] "\n"] return $LesInfos } proc LesProteinesAvecCesOntologies {LesGO {LesOrgas ""} {Field ""} {Banque protein}} { set Commande "[ProgPathway getz] \"\(" set LesRequetes [LesRequetesDuGOEtDesDescendants $LesGO] Espionne $LesRequetes set nRequetes [llength $LesRequetes] if {$nRequetes == 0} {return} set i 0 foreach LaRequete $LesRequetes { incr i set What [lindex $LaRequete 0] set Requete [string trim [lindex $LaRequete 1]] while {[regexp " " $Requete]} {regsub -all " " $Requete " " Requete} set Champs "DR" if {[string equal -nocase $What "spkw2go"]} {set Champs "key"} if {[string equal -nocase $What "ec2go" ]} { set Champs "Des" regsub ":" $Requete " " $Requete } append Commande " \\\[$Banque-$Champs:$Requete\\\] " if {$i < $nRequetes} {append Commande " \| "} else {append Commande " \) "} } if {$LesOrgas != ""} { append Commande " \& \( " set nOrga [llength $LesOrgas] set i 0 foreach Orga $LesOrgas { incr i append Commande " \\\[$Banque-org:$Orga\\\] " if {$i < $nOrga} {append Commande " | "} } append Commande " \)" } if {$Field != ""} { append Commande "\" -f \{$Field\} " } else { append Commande "\"" } set LesInfos [split [eval exec $Commande] "\n"] return $LesInfos } proc LesProteinesDansLeMemeClusterDuMSF {FichierClust {ProteinQuery QUERY_PROTEIN}} { if {![file exists $FichierClust]} {return} set Cluster [InterrogeLesClustersDesMSF $FichierClust Access $ProteinQuery Cluster] if {$Cluster == ""} {return} return [InterrogeLesClustersDesMSF $FichierClust Cluster $Cluster LesAccess] } proc LesProteinesDeLAcNuc {AccessOuBanqueId} { return [LesProteinesDeLAcNuc_PageInfo [PageInfo $AccessOuBanqueId genbankfull]] } proc LesProteinesDeLAcNuc_PageInfo {PageInfo {EtDeLOrga ""}} { set LesProteines {} foreach Ligne [split $PageInfo "\n"] { set Ligne [string trim $Ligne] if {[info exists Prot]} {unset Prot} if {[regexp -nocase "protein_id" $Ligne]} { regsub -all {\"} $Ligne "" Ligne set d [string first "=" $Ligne] set f [string first "." $Ligne] if {$f < $d} {set f [string length $Ligne]} set Prot [string range $Ligne [expr $d + 1] [expr $f - 1]] } if { [regexp -nocase "db_xref" $Ligne] && [regexp -nocase {SWISS\-PROT|SPTREMBL} $Ligne]} { regsub -all {\"} $Ligne "" Ligne set d [string last ":" $Ligne] set Prot [string range $Ligne [expr $d + 1] end] } if {![info exists Prot]} {continue} set Acc [PageInfo $Prot protein acc] if {$Acc == "" } {continue} regsub -all ";" $Acc "" Acc scan $Acc "%s %s" AC Acc lappend LesProteines [string toupper $Acc] } if {$EtDeLOrga != ""} { set LesProteinesTmp {} foreach Proteine $LesProteines { set EstCeUnDesOrgas 0 foreach Orga [LesOrgasDeLaPage_PageInfo $PageInfo] { if {[string equal -nocase $Orga $EtDeLOrga]} {set EstCeUnDesOrgas 1;break} } if {!$EstCeUnDesOrgas} {continue} lappend LesProteinesTmp $Proteine } set LesProteinesTmp $LesProteines } return [lsort -unique $LesProteines] } proc LesProteinesDeLaPageGenBank {FicheGenBank} { set LesProteines {} foreach Ligne [split $FicheGenBank "\n"] { if { [regexp -nocase "db_xref=" $Ligne] && [regexp -nocase "SWISS-PROT" $Ligne]} { regexp -nocase "(SWISS-PROT:\[0-9a-z\_]*)" $Ligne tmp Proteine if {[info exists Proteine]} { regsub "SWISS-PROT:" $Proteine "" Proteine lappend LesProteines $Proteine } } } return $LesProteines } proc LesProteinesDesPABs {Fichier} { set L [CreeListePourFichierAUneLigne $Fichier] foreach Nom $L { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set DefinitionProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition] lappend Lsortie "$Nom\t$AccBestProtHuman\t$DefinitionProtHuman" } return $Lsortie } proc LesProteinesDuBlast {FileBlast {ExpectMax 0.001} {NbSubjectMax 500}} { set LesBId {} set n 0 set NbSubjectDansBlast [AskBlast $FileBlast NbSubject] for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [AskBlast $FileBlast Subject $i] if {[EstUnAccessPDB $BId]} {continue} set Expect [AskBlast $FileBlast BanqueId $BId Segment 1 Expect] set Score [AskBlast $FileBlast BanqueId $BId Segment 1 Score ] if {$ExpectMax < $Expect} {continue} incr n if {$NbSubjectMax < $n } {break} lappend LesBId $BId } AskLesPagesInfos load $LesBId protein set LesProteines {} foreach BId $LesBId { if {[info exists Tab($BId,LesOrganismes)]} {continue} set PageInfo [AskLesPagesInfos ask $BId] if {$PageInfo == ""} {continue} set Expect [AskBlast $FileBlast BanqueId $BId Segment 1 Expect] set Score [AskBlast $FileBlast BanqueId $BId Segment 1 Score ] set Access [string toupper [AskBlast $FileBlast BanqueId $BId Access]] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Taille [AskBlast $FileBlast BanqueId $BId Taille ] scan $Score "%f" Score set Orientation [AskBlast $FileBlast BanqueId $BId Segment 1 Orientation] set NbBasesEnCommun [NombreDeBasesEnCommun $FileBlast $BId] set NbInCDS $NbBasesEnCommun set NbIn5UTR 0 set NbIn3UTR 0 set PIdGlob [PourcentageDIdentiteGlobal $FileBlast $BId] set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { set LesmRNAs [LesmRNAsDeLaProt_PageInfo $PageInfo $Orga] lappend LesProteines [list $BId $Access $Taille $Taille $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun $NbIn5UTR $NbInCDS $NbIn3UTR $Orga $Def $LesmRNAs "PROTEIN"] } } set LesProteines [lsort -real -decreasing -index 2 $LesProteines] set LesProteines [lsort -real -decreasing -index 10 $LesProteines] set LesProteines [lsort -real -decreasing -index 7 $LesProteines] set LesProteines [lsort -integer -decreasing -index 8 $LesProteines] AskBlast unset AskLesPagesInfos unset return $LesProteines } proc LesProteinesDuBlast_TabBlast {aTabBlast} { upvar $aTabBlast TabBlast set LesProteines {} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] if {[info exists Tab($BId,LesOrganismes)]} {continue} Espionne $BId if {[EstUnAccessPDB $BId]} {continue} set Access [string toupper [set TabBlast($BId,Access)]] set PageInfo [PageInfo $BId protein "id acc des org dr"] if {$PageInfo == ""} {continue} set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Expect [set TabBlast($BId,1,Expect) ] set Score [set TabBlast($BId,1,Score) ] set Taille [set TabBlast($BId,Taille) ] scan $Score "%f" Score set Orientation [set TabBlast($BId,1,Orientation)] set NbBasesEnCommun [NombreDeBasesEnCommun_TabBlast TabBlast $BId] set NbInCDS $NbBasesEnCommun set NbIn5UTR 0 set NbIn3UTR 0 set PIdGlob [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { set LesmRNAs [LesmRNAsDeLaProt_PageInfo $PageInfo $Orga] lappend LesProteines [list $BId $Access $Taille $Taille $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun $NbIn5UTR $NbInCDS $NbIn3UTR $Orga $Def $LesmRNAs "PROTEIN"] } } set LesProteines [lsort -real -decreasing -index 2 $LesProteines] set LesProteines [lsort -real -decreasing -index 10 $LesProteines] set LesProteines [lsort -real -decreasing -index 7 $LesProteines] set LesProteines [lsort -integer -decreasing -index 8 $LesProteines] return $LesProteines } proc LesProteinesIdentiquesDuMSF {FichierMSF {ProteinQuery QUERY_PROTEIN} {IdMin 0.98}} { if {![file exists $FichierMSF]} {return} set LesAccess [AskMSF $FichierMSF LesAccess] set LesProteines {} foreach Access $LesAccess { set LesId [IDdansMSF $FichierMSF $ProteinQuery $Access SelonAEtB] set Id1 [lindex $LesId 0] set Id2 [lindex $LesId 1] if {$Id1 == "" || $Id1 < $IdMin} {continue} if {$Id2 == "" || $Id2 < $IdMin} {continue} lappend LesProteines $Access } return [lsort -unique $LesProteines] } proc LesProteinesIdentiquesOuQuasi {FichierClusters} { set Liste [ListeDesJR $FichierClusters] set Entete "Name\tTwins\tAccess\tLength\tOrganism\tDefinition" lappend LApercu $Entete foreach Nom $Liste { set FichierMSF "[RepertoireDuGenome]/msf/$Nom" if {![file exists $FichierMSF]} {continue} set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] foreach Access [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $Nom 0.98] { set Access [string toupper $Access] if {[info exists DejaVu($Access)]} {continue} set DejaVu($Access) 1 lappend LesAccessDesChoisi $Access set PageInfo [PageInfo $Access protein "id acc des org"] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] set Taille [TailleDeLaProt_PageInfo $PageInfo] foreach Org $LesOrgas { lappend LApercu "$Nom\t$LesJumeaux\t$Access\t$Taille\t$Org\t$Def" } } } return $LApercu } proc LesProteinesLesPlusProchesDeLaRegionDuContig {FichierTFAContig FichierBlast BorneMin BorneMax {IdMin 0.8} {ExpectMax 0.001}} { set LesBIdProt [LesBanqueIdDuBlast $FichierBlast] set LesTFAsDesProt [LesSeqTFAsDesBanqueId $LesBIdProt protein] if {$LesTFAsDesProt == {}} {return} set FileBlastDB [TmpFile [file tail $FichierBlast]] Sauve [join $LesTFAsDesProt "\n"] dans $FileBlastDB TFAs2DB $FileBlastDB set NewFileBlast "$FichierBlast.new" PipeBlast $FichierTFAContig $FileBlastDB $NewFileBlast X 500 $ExpectMax F 4 if {[file exists $NewFileBlast]} { file copy -force $FichierBlast "$FichierBlast.old" file rename -force $NewFileBlast $FichierBlast } set LesProteines {} set NbSubject [AskBlast $FichierBlast NbSubject] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlast Subject $i] if {[info exist TabTmp($BId)]} {continue} set TabTmp($BId) 1 #Je ne garde que les Proteines ayant au moins x% d'identite avec le contig# set PIdGlob [PourcentageDIdentiteGlobal $FichierBlast $BId Subject] if {$PIdGlob < $IdMin} {continue} set NbSegment [AskBlast $FichierBlast BanqueId $BId NbSegment] set DMin 1e200 for {set j 1} {$j <= $NbSegment} {incr j} { set D [Mini [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] set F [Maxi [AskBlast $FichierBlast BanqueId $BId Segment $j DQ] [AskBlast $FichierBlast BanqueId $BId Segment $j FQ]] if {$F < $BorneMin} { set Distance [expr $BorneMin - $F] if {$Distance < $DMin} {set DMin $Distance} continue } if {$BorneMax < $D} { set Distance [expr $D - $BorneMax] if {$Distance < $DMin} {set DMin $Distance} continue } ##Sinon je suis overlappant donc DMin est egale a 0## set DMin 0 } set Nb [NombreDeBasesEnCommun $FichierBlast $BId Subject] ############################################## #set Access [AskBlast $FichierBlast BanqueId $BId Access] set Access $BId ############################################## set Taille [AskBlast $FichierBlast BanqueId $BId Taille] set Expect [AskBlast $FichierBlast BanqueId $BId Segment 1 Expect] set Score [AskBlast $FichierBlast BanqueId $BId Segment 1 Score] scan $Score "%f" Score lappend LesProteines [list $BId $Access $Taille $DMin $Expect $Score $PIdGlob $Nb] } return [lsort -integer -index 3 [lsort -integer -index 7 -decreasing $LesProteines]] } proc LesProteinesMito {} { foreach Nom [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {![file exists $FichierProttfa]} {continue} set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] if {[regexp "from mitochondrion Homo" $EnteteProttfa]} {lappend Liste $Nom} } Espionne [llength $Liste] SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/mitoch_prot_931" } proc LesProteinesPreditesDuGenscan {AccessOuFichierGSC {Quoi TFA} {Offset 0}} { global RepertoireDuGenome Wup "return the list of localisation (if Quoi=Loc) or the tfas file (if =TFA)" if {[regexp "/" $AccessOuFichierGSC]} { set TexteGS [ContenuDuFichier $AccessOuFichierGSC] } else { set TexteGS [GenScanEnStock $AccessOuFichierGSC] } if {$TexteGS==""} { return {} } foreach Prot [DecortiqueGenScan All All Numbers $TexteGS] { set G [expr [DecortiqueGenScan $Prot All Gauche] + $Offset] set D [expr [DecortiqueGenScan $Prot All Droite] + $Offset] set S [DecortiqueGenScan $Prot All Sens] if {$Quoi=="Loc"} { lappend Sortie "$G $D $S $Prot" } if {$Quoi=="TFA"} { lappend Sortie [DecortiqueGenScan $Prot All TFAo] } } return $Sortie } proc LesProteinesProchesDeLaProteineDeRef {Query FileMSF FileClust {IdDesProtId 0.98} {AvecOuSansCluster AvecCluster} {NorMDMin 0.5}} { ####Uniquement les Access avec IdDesProtId % d'identite avec la query ou les proteines ####du cluster de msf si NorMD est superieur a NorMDMin ou si il n'y a pas de clusters ####de MSF toutes les proteines du msf si le NormMD est superieur a NormMDMin if {![file exists $FileMSF]} {return} set Cluster [InterrogeLesClustersDesMSF $FileClust Access $Query Cluster] if {$Cluster == "" } { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust LesAccess] } else { set LesAccessDuMSF [InterrogeLesClustersDesMSF $FileClust Cluster $Cluster LesAccess] } if {[MDScoreAvecSelectionDuFichier $FileMSF $LesAccessDuMSF] < $NorMDMin} {set LesAccessDuMSF {}} set LesAccessDesId [LesProteinesIdentiquesDuMSF $FileMSF $Query $IdDesProtId] if {[string equal -nocase $AvecOuSansCluster "AvecCluster"]} { set LesAccess [lsort -unique [concat $LesAccessDuMSF $LesAccessDesId]] } else { set LesAccess [lsort -unique $LesAccessDesId] } return $LesAccess } proc LesProteinesUniques {} { ### Calcul de la liste de proteines uniques d'un projet cad sans compter la redondance des proteines jumelles ### set FichierProtJum "[RepertoireDuGenome]/fiches/ProteinesJumelles_old" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" InterrogeProteinesJumelles unset InterrogeOrf2Cluster2Access2Def2Expression unset foreach Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesClusters] { Espionne "Cluster -> $Cluster" # Traitement des proteines jumelles, ne garde que les proteines uniques pour chaque cluster set LesNoms {} foreach Nom [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE Cluster $Cluster LesNoms] { if {[info exists TabDeJaVu($Cluster,$Nom)]} {continue} set TabDeJaVu($Cluster,$Nom) 1 foreach Jum [lsort -unique [InterrogeProteinesJumelles $FichierProtJum $Nom LesProteinesJumelles]] { set TabDeJaVu($Cluster,$Jum) 1 } lappend LesNoms $Nom } set LesNoms [lsort -unique $LesNoms] } InterrogeProteinesJumelles unset InterrogeOrf2Cluster2Access2Def2Expression unset return $LesNoms } proc LesRNsDeYann {} { foreach Nom [ListeDesPABs] { set TexteNR [ExtraitInfo $Nom NR] if { ! [regexp "oui" $TexteNR]} { continue } regsub "oui " $TexteNR "" GN scan $GN "%s" GN InformeSansDemander $Nom "=ValiGN: $GN" lappend LesNRsDeYann "$Nom $GN" } SauveLesLignes $LesNRsDeYann dans "[RepertoireDuGenome]/fiches/les_nr_de_yann" exit } proc LesRapportsPourAccess {{LesNoms ""} {Keep ""}} { set RepRapports "[RepertoireDuGenome]/rapportsaccess" if { ! [file exists $RepRapports]} { File mkdir $RepRapports } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set LesNoms [ListeDesPABs]} else {set LesNoms $LesNoms} set Fichierjumeaux "[RepertoireDuGenome]/fiches/jumeaux" if {![file exists $Fichierjumeaux]} { set Clusters 0 } else { set Clusters 1 } set FichierLocalisation "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human" if {![file exists $FichierLocalisation]} {return ""} ChargeFichierLocalisation Tab $FichierLocalisation "" $LesNoms if {![info exists Tab(LesNoms)]} { Espionne coucou return "" } set FichierFonction "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis" set FichierContig "[RepertoireDuGenome]/fiches/ContigAndProt" if {![file exists $FichierFonction] || ![file exists $FichierContig]} { set Fonction 0 } else { set Fonction 1 } set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" set RepBlastAffy "[RepertoireDuGenome]/blastntargetaffy" if {![file exists $RepBlastAffy]} {set Affy 0} else {set Affy 1} foreach Nom $LesNoms { if {$Keep==1 && [file exists "$RepRapports/$Nom"]} { continue } Espionne $Nom set Rapport {} #Generalites: Espionne "$Nom -> Generalites" set CodeClone [CodeClone $Nom] set Longueur [SeqLength $Nom] lappend Rapport "GscopeCode: $Nom" lappend Rapport "CodeClone: $CodeClone" lappend Rapport "Length: $Longueur" if {$Affy==1} { set User [OwnerOfCDNA $Nom] lappend Rapport "User: $User" #user indispensable dans le rapport car cle primaire dans la table clone de la DB } #Clusters: Espionne "$Nom -> clusters" if {$Clusters==1} { #pour que la proc jumeaurepresentatif marche : #le fichier jumeaux est une copie de clusters set JR [JumeauRepresentatif $Nom] lappend Rapport "JR: $JR" } #RepeatMasker Espionne "$Nom -> Masking ; ReMasking ; Masking and ReMasking" if {[InterrogeBilanMasking $Nom LesEtats] != ""} { set PMasked [InterrogeBilanMasking $Nom Etat MRM PMasked ] set LesRepeats [InterrogeBilanMasking $Nom Etat MRM LesRepeats] if {$PMasked!=""} { lappend Rapport "MRM Pourcent: $PMasked" } if {$LesRepeats!=""} { lappend Rapport "MRM LesRepeats: $LesRepeats" } } #Localisation genomique Espionne "$Nom -> localisation genomique" set PolyLoc [PolyLocalise $Nom] #lappend Rapport "LocType: $PolyLoc" if {$PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} { foreach LInfo [set Tab(Nom,$Nom)] { set Info [lindex $LInfo 20] if {[regexp "Best" $Info]} { set Chro [lindex $LInfo 9] set Debut [lindex $LInfo 10] set Fin [lindex $LInfo 11] set Sens [lindex $LInfo 12] set BandeCyto [lindex $LInfo 19] lappend Rapport "Chromosome: $Chro" lappend Rapport "Begin: $Debut" lappend Rapport "End: $Fin" lappend Rapport "Orientation: $Sens" lappend Rapport "CytologicBand: $BandeCyto" } } } #Proteines et mRNA Espionne "$Nom -> Proteines et mRNA" if {$Fonction==1} { set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {[regexp -nocase "noprotein" $AccessProt] && [regexp -nocase "nomrna" $AccessRNA]} { set AccessProt [InterrogeContigAndProt $Nom Protein Access] if {$AccessProt!=""} { set Organisme [InterrogeContigAndProt $Nom Protein Organisme] set BanqueID [InterrogeContigAndProt $Nom Protein BanqueId] set Definition [InfoDeLaPageProteine $BanqueID $AccessProt DE] lappend Rapport "BanqueID: $BanqueID" lappend Rapport "AccessProteine: $AccessProt" lappend Rapport "DefProt: $Definition" lappend Rapport "Organisme: $Organisme" lappend Rapport "Warning: Contig" } } else { set Organisme [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] set Warning [InterrogeProtAndmRNAChoisis $Nom InfoSeqChoisie] set Definition [InfoDeLaPageProteine "" $AccessProt DE] if {$AccessRNA!="NOMRNA" && $AccessRNA!=""} { lappend Rapport "AccessRNA: $AccessRNA" set Definition [InfoDeLaPage "" $AccessRNA DEFINITION] if {$Definition!=""} { lappend Rapport "DefRNA: $Definition" } } if {$AccessProt!="NOPROTEIN" && $AccessProt!=""} { lappend Rapport "AccessProteine: $AccessProt" set Definition [InfoDeLaPageProteine "" $AccessProt DE] if {$Definition!=""} { lappend Rapport "DefProt: $Definition" } } if {$Organisme!=""} { lappend Rapport "Organisme: $Organisme" } if {$Warning!=""} { lappend Rapport "Warning: $Warning" } } } #Gene Name Espionne "$Nom -> gene name" if {[info exists AccessProt]} { set LesNomsDesGenes [InterrogeGeneName Protein $AccessProt LesGeneNames] if {$LesNomsDesGenes!=""} { lappend Rapport "GeneName: $LesNomsDesGenes" } } #Kegg #####info pathway redondante avec GO #####interet de kagg: les dessins #Gene Ontology if {[file exists $FichierGO]} { Espionne "$Nom -> ontology" if {[InterrogeGeneOntology $FichierGO $Nom LesGO] != ""} { set LesGOFunction {} set LesGOProcess {} set LesGOComponent {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {$GO == ""} {continue} set Type [InterrogeGeneOntology $FichierGO GO $GO Type] if {$Type == "function" } {lappend LesGOFunction $GO} if {$Type == "process" } {lappend LesGOProcess $GO} if {$Type == "component"} {lappend LesGOComponent $GO} } set LesDefGOFunction {} set LesDefGOProcess {} set LesDefGOComponent {} foreach GO $LesGOFunction { lappend LesDefGOFunction "$GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } set DefGOFunction [join $LesDefGOFunction " "] lappend Rapport "GOfunction: $DefGOFunction" foreach GO $LesGOProcess { lappend LesDefGOProcess "$GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } set DefGOProcess [join $LesDefGOProcess " "] lappend Rapport "GOprocess: $DefGOProcess" foreach GO $LesGOComponent { lappend LesDefGOComponent "$GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } set DefGOComponent [join $LesDefGOComponent " "] lappend Rapport "GOcomponent: $DefGOComponent" } } #Copains du blast N Affymetrix (target) if {$Affy==1} { Espionne "$Nom -> Copains du blast N Affymetrix (target)" set Banque "blastntargetaffy" set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque] set LesCodes {} if {$LesCops!={} && [lindex $LesCops 0]!="File not yet available" && [lindex $LesCops 0]!="No value" && [lindex $LesCops 0]!="No hit" && [lindex $LesCops 0]!="No hits found" } { set PremiereFois 1 foreach Cop $LesCops { scan $Cop "%s %s" t g if {$PremiereFois} { lappend LesCodes $g set PremiereFois 0 continue } else { lappend LesCodes $g } } } if {$LesCodes!={}} { lappend Rapport "Affymetrix: $LesCodes" } } Espionne "fin" SauveLesLignes $Rapport dans "$RepRapports/$Nom" } return "" } proc LesRapportsPourAccessAvecKeggEtEST {{LesNoms ""} {Keep ""}} { set RepRapports "[RepertoireDuGenome]/rapportsaccess" if { ! [file exists $RepRapports]} { File mkdir $RepRapports } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set LesNoms [ListeDesPABs]} else {set LesNoms $LesNoms} foreach Nom $LesNoms { if {$Keep==1 && [file exists "$RepRapports/$Nom"]} { continue } Espionne $Nom set Rapport {} #Generalites: Espionne "$Nom -> Generalites" set CodeClone [CodeClone $Nom] set Longueur [SeqLength $Nom] lappend Rapport "GscopeCode: $Nom" lappend Rapport "CodeClone: $CodeClone" lappend Rapport "Length: $Longueur" set User [OwnerOfCDNA $Nom] lappend Rapport "User: $User" #Kegg #####info pathway redondante avec GO #####interet de kegg: les dessins ##Pathways KEGG## Espionne "$Nom -> KEGG" if {[InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC]!=""} { if {[InterrogeMesKEGG $Nom LesPathway]!=""} { set LesNumerosDesPathways [InterrogeMesKEGG $Nom LesPathway] lappend Rapport "Pathway: [join $LesNumerosDesPathways " ; "]" foreach Pathway $LesNumerosDesPathways { set DefPathway [InterrogeMesKEGG Pathway $Pathway Definition] lappend LesDefPathway $DefPathway } lappend Rapport "DefPathway: [join $LesDefPathway " ; "]" } if {[InterrogeMesKEGG $Nom LesEC]!=""} { set LesEC [InterrogeMesKEGG $Nom LesEC] lappend Rapport "EC: [join $LesEC " ; "]" } if {[InterrogeMesKEGG $Nom LesKegg]!=""} { set LesKegg [InterrogeMesKEGG $Nom LesKegg] lappend Rapport "NumKegg: [join $LesKegg " ; "] " foreach Kegg $LesKegg { set DefKegg [InterrogeMesKEGG Kegg $Kegg Definition] lappend LesDefKegg $DefKegg } lappend Rapport "DefKegg: [join $DefKegg " ; "]" } } else { lappend Rapport "Pathway: " lappend Rapport "DefPathway: " lappend Rapport "EC: " lappend Rapport "NumKegg: " lappend Rapport "DefKegg: " } ### Tissue Type ### Espionne "$Nom -> Tissue Type" if {[InterrogeTissueType $Nom LesTissues] != ""} { set LesTissues {} foreach Tissue [InterrogeTissueType $Nom LesTissues] { if {$Tissue == ""} {continue} lappend LesTissues [list $Tissue [InterrogeTissueType $Nom Tissue $Tissue n]] } if {$LesTissues != {}} { set LesTissuesEtLeurEffectif {} foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { lappend LesTissuesEtLeurEffectif "[lindex $LeTissue 0] ([lindex $LeTissue 1])" } lappend Rapport "TissueType: [join $LesTissuesEtLeurEffectif " ; "]" } } else { lappend Rapport "TissueType: " } ### Development Stage ### Espionne "$Nom -> Development stage" if {[InterrogeDevStage $Nom LesDevStages] != ""} { set LesDevStage {} foreach DevStage [InterrogeDevStage $Nom LesDevStages] { if {$DevStage == ""} {continue} lappend LesDevStage [list $DevStage [InterrogeDevStage $Nom DevStage $DevStage n]] } if {$LesDevStage != {}} { set LesDevStageEtLeurEffectif {} foreach LeDevStage [lsort -index 1 -decreasing -integer $LesDevStage] { lappend LesDevStageEtLeurEffectif "[lindex $LeDevStage 0] ([lindex $LeDevStage 1])" } lappend Rapport "DevelopmentStage: [join $LesDevStageEtLeurEffectif " ; "]" } } else { lappend Rapport "DevelopmentStage: " } Espionne "fin" SauveLesLignes $Rapport dans "$RepRapports/$Nom" } return "" } proc LesRapportsPourAccessPourESTseuls {{LesNoms ""} {Keep ""}} { set RepRapports "[RepertoireDuGenome]/rapportsaccess" if { ! [file exists $RepRapports]} { File mkdir $RepRapports } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set LesNoms [ListeDesPABs]} else {set LesNoms $LesNoms} foreach Nom $LesNoms { if {$Keep==1 && [file exists "$RepRapports/$Nom"]} { continue } Espionne $Nom set Rapport {} #Generalites Espionne "$Nom -> Generalites" set CodeClone [CodeClone $Nom] set Longueur [SeqLength $Nom] lappend Rapport "GscopeCode: $Nom" lappend Rapport "CodeClone: $CodeClone" lappend Rapport "Length: $Longueur" set User [OwnerOfCDNA $Nom] lappend Rapport "User: $User" #EST set LesCops [LesMeilleursCopainsDuBlast $Nom blastnest-human] set Tmax 1 foreach Cop $LesCops { scan $Cop "%s %s" bid acc set AccessEST $acc set PageInfoEST [PageInfo $AccessEST genbankfull "id acc des org"] set TailleEST [TailleDeLAcNuc_PageInfo $PageInfoEST] if {$TailleEST>$Tmax} { set Tmax $TailleEST set CopMax $Cop } } lappend Rapport "EST: $CopMax" Espionne "fin" SauveLesLignes $Rapport dans "$RepRapports/$Nom" } return "" } proc LesRapportsPourAccessSpecialAffy {{LesNoms ""} {Keep ""}} { #affy set RepRapports "[RepertoireDuGenome]/rapportsaccessspecial" if { ! [file exists $RepRapports]} { File mkdir $RepRapports } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set LesNoms [ListeDesPABs]} else {set LesNoms $LesNoms} foreach Nom $LesNoms { if {$Keep && [file exists "$RepRapports/$Nom"]} { continue } Espionne $Nom set Rapport {} #Generalites: set CodeClone [CodeClone $Nom] set AC [ExtraitInfo $Nom "AffymetrixAccess"] set Definition [ExtraitInfo $Nom "GBtagsDefinition"] lappend Rapport "GscopeCode: $Nom" lappend Rapport "CodeClone: $CodeClone" lappend Rapport "Access: $AC" lappend Rapport "Definition: $Definition" Espionne "fin" SauveLesLignes $Rapport dans "$RepRapports/$Nom" } return "" } proc LesRecepteursNucleairesDe {{Qui ""}} { if {$Qui==""} { set LesPossibles [glob -nocomplain "[RepertoireDuGenome]/blastp*"] set Qui [ChoixParmi $LesPossibles] if {$Qui==""} { return {} } set Qui [file tail $Qui] regsub "blastp" $Qui "" Qui } foreach Nom [ListeDesPABs] { set Fichier "[RepertoireDuGenome]/blastp$Qui/$Nom" DecortiqueBlast $Fichier 0.001 9999 Query lBanqueId lAccess lDE lProfil lPN if {$Qui=="briggsae"} { set lAccess $lBanqueId } foreach Access $lAccess PN $lPN { lappend VerExpect($Access) "$PN $Nom" } } set LesRNs {} foreach Access [lsort [array names VerExpect]] { set VerExpect($Access) [lsort -command CompareLesFloatsEnDebut [set VerExpect($Access)]] if {$Qui=="Ciona"} { set CIONA [CioNarcisse $Access] lappend LesRNs "$CIONA $Access [join [set VerExpect($Access)] { }]" } else { lappend LesRNs "xxxxxx $Access [join [set VerExpect($Access)] { }]" } } return $LesRNs } proc LesRegionsAbsentesDesPetitesRegions {LesPetitesRegions {TailleMin ""} {TailleMax ""}} { if {$TailleMax == ""} { set Max1 [lindex [lindex [lsort -integer -index 1 $LesPetitesRegions] end] 1] set Max2 [lindex [lindex [lsort -integer -index 0 $LesPetitesRegions] end] 0] set TailleMax [Maxi $Max1 $Max2] } if {$TailleMin == ""} { set Min1 [lindex [lindex [lsort -integer -index 1 $LesPetitesRegions] 0] 1] set Min2 [lindex [lindex [lsort -integer -index 0 $LesPetitesRegions] 0] 0] set TailleMin [Mini $Max1 $Max2] } set Debut 1 set LesRegionsAbsentes {} foreach UneRegion [lsort -integer -index 0 [lsort -integer -index 1 $LesPetitesRegions]] { set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {$TailleMax < $F} {set TailleMax $F} if {$Debut < $D} {lappend LesRegionsAbsentes [list $Debut [expr $D - 1]]} set Debut [expr $F + 1] } if {$F < $TailleMax} {lappend LesRegionsAbsentes [list [expr $F + 1] $TailleMax ]} return $LesRegionsAbsentes } proc LesRegionsAvecLesRegionsAbsentesBlastees {FichierTFAQuery LesRegions TailleQuery {TailleMinQ 10} {TailleMaxQ 20000} {TailleMax 1e5} {Expect 0.001} {ElimineLesRegionsRichesEnA 1}} { if {![file exists $FichierTFAQuery]} {return} set TailleFragment 100000 set NameFile [file tail $FichierTFAQuery] set ToutesLesRegions {} foreach UneRegion $LesRegions { set N [lindex $UneRegion 3] set LeBId [lindex $UneRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $UneRegion 6] if {$N == 1} { if {![info exists TabTmp($Access,$Sens,Score)]} {set TabTmp($Access,$Sens,Score) 0} incr TabTmp($Access,$Sens,Score) [lindex $UneRegion 9] } if {$N != 0} {lappend ToutesLesRegions $UneRegion;continue} set Chrom [lindex $LeBId 0] set NbNDuContig [lindex $LeBId end] set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] set Taille [expr $F - $D + 1] if {$Taille < $TailleMinQ || $TailleMaxQ <= $Taille } {continue} set BorneMin [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set BorneMax [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set TailleContig [TailleDuContig $Chrom $Access $NbNDuContig] if {$TailleContig < $BorneMin} {continue} if {$TailleContig < $BorneMax} {set BorneMax $TailleContig} if {$Sens == "+"} { set DS [Mini $BorneMin $BorneMax] set FS [Maxi $BorneMin $BorneMax] } else { set DS [Maxi $BorneMin $BorneMax] set FS [Mini $BorneMin $BorneMax] } set File [TmpFile $NameFile] set Seq [string range [QueLaSequenceDuFichierTFA $FichierTFAQuery] [expr $D-1] [expr $F-1]] set FichierTFAQ "${File}_Query_${D}_${F}.tfa" set SeqTFA [SequenceFormatTFA $Seq "Query $D $F"] if {$SeqTFA == ""} {continue} Sauve $SeqTFA dans $FichierTFAQ set TailleRegion [expr abs($FS - $DS) + 1] if {$TailleMax < $TailleRegion} { if {$D !=1 && $F != $TailleQuery} {continue} if {$Sens == "+"} { if {$D == 1 } {set DS [expr int($FS - $TailleMax)]} if {$F == $TailleQuery} {set FS [expr int($DS + $TailleMax)]} } if {$Sens == "-"} { if {$D == 1 } {set DS [expr int($FS + $TailleMax)]} if {$F == $TailleQuery} {set FS [expr int($DS - $TailleMax)]} } } set BorneMin [Mini $DS $FS] set BorneMax [Maxi $DS $FS] set FichierTFAS "${File}_Subject_${Chrom}_${Access}_${BorneMin}_${BorneMax}.tfa" set SeqTFA [SequenceTFADuContig $Chrom $Access $BorneMin $BorneMax $NbNDuContig $TailleContig] if {$SeqTFA == ""} {continue} Sauve $SeqTFA dans $FichierTFAS set FichierBlast "${File}_${D}_${F}_${Chrom}_${Access}_${DS}_${FS}.blast" set FichierFasta "${File}_${D}_${F}_${Chrom}_${Access}_${DS}_${FS}.fasta" BlastNAvecFastaN $FichierTFAQ $FichierTFAS $FichierBlast $FichierFasta if {$Sens == "+"} { FichierBlastReduit $FichierBlast $FichierBlast SensToKeep "Plus / Plus" } else { FichierBlastReduit $FichierBlast $FichierBlast SensToKeep "Plus / Minus" } set NbSubject [AskBlast $FichierBlast NbSubject] if {$NbSubject == "" || $NbSubject == 0} {continue} set LesGrandesRegions [LesGrandesRegionsDeLaQueryDuBlast $FichierBlast $Expect 1e200 0.0 Yes ""] set LesPetitesRegions [LesPetitesRegionsDesGrandesRegions $LesGrandesRegions] set LesInfos [LesInfosDesRegionsDansLeBlast $FichierBlast $LesPetitesRegions "All" "None"] if {$LesInfos == {}} {continue} foreach LInfo $LesInfos { set N [lindex $LInfo 3] set DQ [expr $D + [Mini [lindex $LInfo 0] [lindex $LInfo 1]] - 1] set FQ [expr $D + [Maxi [lindex $LInfo 0] [lindex $LInfo 1]] - 1] set DS2 [expr $BorneMin + [Mini [lindex $LInfo 7] [lindex $LInfo 8]] - 1] set FS2 [expr $BorneMin + [Maxi [lindex $LInfo 7] [lindex $LInfo 8]] - 1] if {$Sens == "-"} {set tmp $DS2;set DS2 $FS2;set FS2 $tmp} if {$NbNDuContig == 0} { set BId [list $Chrom $Access ""] } else { set BId [list $Chrom $Access $NbNDuContig] } if {$N == 1} { if {![info exists TabTmp($Access,$Sens,Score)]} {set TabTmp($Access,$Sens,Score) 0} incr TabTmp($Access,$Sens,Score) [lindex $LInfo 9] } set LInfo [lreplace $LInfo 4 4 $BId] set LInfo [lreplace $LInfo 0 0 $DQ ] set LInfo [lreplace $LInfo 1 1 $FQ ] set LInfo [lreplace $LInfo 7 7 $DS2] set LInfo [lreplace $LInfo 8 8 $FS2] lappend LInfo 0 lappend ToutesLesRegions $LInfo } } set LesRegions {} foreach UneRegion $ToutesLesRegions { set N [lindex $UneRegion 3] if {$N != 1} {lappend LesRegions $UneRegion;continue} set LeBId [lindex $UneRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $UneRegion 6] lappend LesRegions [lreplace $UneRegion end end [set TabTmp($Access,$Sens,Score)]] } return $LesRegions } proc LesRegionsAvecLesRegionsAbsentesBlastees_Old {FichierTFAQuery LesRegions TailleQuery {TailleMinQ 10} {TailleMaxQ 20000} {TailleMax 1e5} {Expect 0.001} {ElimineLesRegionsRichesEnA 1}} { if {![file exists $FichierTFAQuery]} {return} set TailleFragment 100000 set NameFile [file tail $FichierTFAQuery] set ToutesLesRegions {} foreach UneRegion $LesRegions { set N [lindex $UneRegion 3] set LeBId [lindex $UneRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $UneRegion 6] if {$N == 1} { if {![info exists TabTmp($Access,$Sens,Score)]} {set TabTmp($Access,$Sens,Score) 0} incr TabTmp($Access,$Sens,Score) [lindex $UneRegion 9] } if {$N != 0} {lappend ToutesLesRegions $UneRegion;continue} set Chrom [lindex $LeBId 0] set NbNDuContig [lindex $LeBId end] set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] set Taille [expr $F - $D + 1] if {$Taille < $TailleMinQ || $TailleMaxQ <= $Taille } {continue} set BorneMin [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set BorneMax [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set TailleContig [TailleDuContig $Chrom $Access $NbNDuContig] if {$TailleContig < $BorneMin} {continue} if {$TailleContig < $BorneMax} {set BorneMax $TailleContig} if {$Sens == "+"} { set DS [Mini $BorneMin $BorneMax] set FS [Maxi $BorneMin $BorneMax] } else { set DS [Maxi $BorneMin $BorneMax] set FS [Mini $BorneMin $BorneMax] } set File [TmpFile $NameFile] set Seq [string range [QueLaSequenceDuFichierTFA $FichierTFAQuery] [expr $D-1] [expr $F-1]] set FichierTFAQ "${File}_Query_${D}_${F}.tfa" set SeqTFA [SequenceFormatTFA $Seq "Query $D $F"] if {$SeqTFA == ""} {continue} Sauve $SeqTFA dans $FichierTFAQ set TailleRegion [expr abs($FS - $DS) + 1] if {$TailleMax < $TailleRegion} { if {$D !=1 && $F != $TailleQuery} {continue} if {$Sens == "+"} { if {$D == 1 } {set DS [expr int($FS - $TailleMax)]} if {$F == $TailleQuery} {set FS [expr int($DS + $TailleMax)]} } if {$Sens == "-"} { if {$D == 1 } {set DS [expr int($FS + $TailleMax)]} if {$F == $TailleQuery} {set FS [expr int($DS - $TailleMax)]} } } set BorneMin [Mini $DS $FS] set BorneMax [Maxi $DS $FS] set FichierTFAS "${File}_Subject_${Chrom}_${Access}_${BorneMin}_${BorneMax}.tfa" set SeqTFA [SequenceTFADuContig $Chrom $Access $BorneMin $BorneMax $NbNDuContig $TailleContig] if {$SeqTFA == ""} {continue} Sauve $SeqTFA dans $FichierTFAS set FichierBlast "${File}_${D}_${F}_${Chrom}_${Access}_${DS}_${FS}.blast" set FichierFasta "${File}_${D}_${F}_${Chrom}_${Access}_${DS}_${FS}.fasta" BlastNAvecFastaN $FichierTFAQ $FichierTFAS $FichierBlast $FichierFasta if {$Sens == "+"} { FichierBlastReduit $FichierBlast $FichierBlast SensToKeep "Plus / Plus" } else { FichierBlastReduit $FichierBlast $FichierBlast SensToKeep "Plus / Minus" } DepouilleLeBlast TabBlast $FichierBlast if { ![info exists TabBlast(NbSubject)] || [set TabBlast(NbSubject)] == 0} {continue} set LesGrandesRegions [LesGrandesRegionsDuBlast TabBlast "All" "None"] set LesPetitesRegions [LesPetitesRegionsDesGrandesRegions $LesGrandesRegions] set LesInfos [LesInfosDesRegionsDansLeBlast_TabBlast TabBlast $LesPetitesRegions "All" "None"] if {$LesInfos == {}} {continue} foreach LInfo $LesInfos { set N [lindex $LInfo 3] set DQ [expr $D + [Mini [lindex $LInfo 0] [lindex $LInfo 1]] - 1] set FQ [expr $D + [Maxi [lindex $LInfo 0] [lindex $LInfo 1]] - 1] set DS2 [expr $BorneMin + [Mini [lindex $LInfo 7] [lindex $LInfo 8]] - 1] set FS2 [expr $BorneMin + [Maxi [lindex $LInfo 7] [lindex $LInfo 8]] - 1] if {$Sens == "-"} {set tmp $DS2;set DS2 $FS2;set FS2 $tmp} if {$NbNDuContig == 0} { set BId [list $Chrom $Access ""] } else { set BId [list $Chrom $Access $NbNDuContig] } if {$N == 1} { if {![info exists TabTmp($Access,$Sens,Score)]} {set TabTmp($Access,$Sens,Score) 0} incr TabTmp($Access,$Sens,Score) [lindex $LInfo 9] } set LInfo [lreplace $LInfo 4 4 $BId] set LInfo [lreplace $LInfo 0 0 $DQ ] set LInfo [lreplace $LInfo 1 1 $FQ ] set LInfo [lreplace $LInfo 7 7 $DS2] set LInfo [lreplace $LInfo 8 8 $FS2] lappend LInfo 0 lappend ToutesLesRegions $LInfo } } set LesRegions {} foreach UneRegion $ToutesLesRegions { set N [lindex $UneRegion 3] if {$N != 1} {lappend LesRegions $UneRegion;continue} set LeBId [lindex $UneRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $UneRegion 6] lappend LesRegions [lreplace $UneRegion end end [set TabTmp($Access,$Sens,Score)]] } return $LesRegions } proc LesRegionsAvecScoreModifieEnFonctionDesRegionsRepetees {LesRegions} { #Etant donne que les regions exoniques sont separees par des regions repetees et qu'il existe des retropseudogenes #avec plus de 99% d'id sur le genome ; il ne faut donc pas considerer les regions repetees #dans le calcul du score => le score des retropseudogenes devraient diminuer et non pas celui des vrais genes set LesRegionsRepetees {} set LesAccessEtLeurSensDesRegions {} foreach LaRegion $LesRegions { set n [lindex $LaRegion 3] if {1 < $n} {lappend LesRegionsRepetees $LaRegion} set LeBId [lindex $LaRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $LaRegion 6] set Score [lindex $LaRegion 12] if {![info exists Tab($Access,$Sens,Score)] && $Score != ""} {set Tab($Access,$Sens,Score) $Score} if {![info exists Tab($Access,$Sens,LesRegions)]} { set Tab($Access,$Sens,LesRegions) {} lappend LesAccessEtLeurSensDesRegions [list $Access $Sens] } lappend Tab($Access,$Sens,LesRegions) $LaRegion } foreach LaRegion $LesRegionsRepetees { set D [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set F [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] for {set i $D} {$i <= $F} {incr i} {set Tab(Seq,$i) 1} } set LesRegionsModifiees {} foreach LAccessEtLeSens $LesAccessEtLeurSensDesRegions { set Access [lindex $LAccessEtLeSens 0] set Sens [lindex $LAccessEtLeSens 1] set LesRegionsAModifier [set Tab($Access,$Sens,LesRegions)] set Score [set Tab($Access,$Sens,Score)] foreach LaRegion $LesRegionsAModifier { set n [lindex $LaRegion 3] if {$n != 1} {continue} set D [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set F [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] for {set i $D} {$i <= $F} {incr i} { if {[info exists Tab(Seq,$i)]} {incr Score -1} } } foreach LaRegion $LesRegionsAModifier { set n [lindex $LaRegion 3] if {$n != 1} {lappend LesRegionsModifiees $LaRegion;continue} set LaRegion [lreplace $LaRegion 12 12 $Score] lappend LesRegionsModifiees $LaRegion } } return $LesRegionsModifiees } proc LesRegionsDeLaQuerySurLeSubject {aTabBlast BId} { upvar $aTabBlast Blast set LesRegions {} if {![info exists Blast($BId,NbSegment)]} {return $LesRegions} set NbSegment [set Blast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set Blast($BId,$j,DQ)] set FQ [set Blast($BId,$j,FQ)] set DS [set Blast($BId,$j,DS)] set FS [set Blast($BId,$j,FS)] set Orientation [set Blast($BId,$j,Orientation)] set TailleS [set Blast($BId,Taille)] if {$FQ < $DQ && $Orientation < 0} { set tmpQ $FQ set FQ $DQ set DQ $tmpQ set tmpS $FS set FS $DS set DS $tmpS } if {$Orientation == "" && [set Blast(TypeDeBlast)] == "BLASTP"} { set Orientation "Prot / Prot" } lappend LesRegions [list "$DQ" "$FQ" "$DS" "$FS" "$TailleS" "$Orientation"] } return [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $LesRegions]] } proc LesRegionsDetecteesPolyN {Seq N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { ################################################################## ### Detection de region polyN a partir d'une sequence lineaire ### ################################################################## #Seq : Sequence lineaire #N : la base d'interet ex N=A pour detecter un PolyA #nMin : Taille du PolyN minimum = taille "sliding window" #PMin : Pourcentage de A minimum dans le PolyN #NbMaxDeBasesDiffDeNContigues : Nb maximum de bases differentes de N contigues dans le polyN #Retourne : une liste contenant l'index du debut et de la fin du ou des PolyN detectes #je mets la seq dans une liste et je calcule la taille de la sequence set LaSeq [split $Seq ""] set TailleSeq [llength $LaSeq ] ### Met chaque base de la seq dans un tableau indexe avec la position de la base ### Plus rapide que lindex set PosSeq 0 foreach Base $LaSeq {set TabSeq($PosSeq) $Base;incr PosSeq} set LesDebuts {} #Je parcours la seq du debut jusqu'au debut de la derniere "sliding window" (TailleSeq - TailleSlidingWindow) for {set i 0} {$i <= [expr $TailleSeq - $nMin]} {incr i} { #grace au tableau d'indexation des bases de la seq je demande la base correspondant à la position i set Base [set TabSeq($i)] #je ne commence à compter qu'à partir d'une base N if {![string equal -nocase $Base $N]} {continue} #cette base peut donc etre mon debut de polyN set Debut $i #je vais comptabiliser le nb de bases N,le nb total de bases à travers toutes les "sliding window", #le nombre de bases N à la fin et au debut du polyN #ainsi que le nombre de bases differentes de N contigues set NbN 1 set NbNAuDebut 1 set NbNALaFin 1 set NbBases 1 set NbDeBasesDiffDeNContigues 0 #Je parcours la seq de la base suivante (debut + 1) jusqu'à la derniere base ( je quitte if {$LesDebuts == {}} {return} #sinon je reforme la description (Debut Fin) de chaque region polyN trouvee set LesRegions {} foreach Debut $LesDebuts {lappend LesRegions [list $Debut [set Tab($Debut,Fin)]]} #determination des regions polyN finalement selectionnees set TailleMaxPolyN 0 set LesRegionsSelectionnees {} #fusion des regions polyN chevauchantes foreach LaRegion [LaFusionDesRegionsOverlappantes $LesRegions] { #+1 pour D et F car la premiere base de la seq est en position 1 #alors que l'indexation dans cette procedure commence à 0 set D [expr [lindex $LaRegion 0] + 1] set F [expr [lindex $LaRegion 1] + 1] set TaillePolyN [expr $F - $D +1] #determination et selection de la region polyN de plus grande taille if {$TailleMaxPolyN < $TaillePolyN} { set TailleMaxPolyN $TaillePolyN set LesRegionsSelectionnees {} lappend LesRegionsSelectionnees [list $D $F $TaillePolyN $N] continue } #selection finale de la ou des regions polyN de plus grande taille if {$TailleMaxPolyN == $TaillePolyN} { lappend LesRegionsSelectionnees [list $D $F $TaillePolyN $N] continue } continue } Espionne "TailleSeq : $TailleSeq" Espionne "Les debuts : $LesDebuts" Espionne "Toutes Les Regions : $LesRegions" Espionne "Les Regions select : $LesRegionsSelectionnees" Espionne $Seq Espionne [MasqueLesRegions $Seq $LesRegionsSelectionnees N] #je retourne le debut et la fin des regions polyN selectionnees return $LesRegionsSelectionnees } proc LesRegionsDetecteesPolyNDesTFAs {FichierTFAs N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { set LesTFAs [split [ContenuDuFichier $FichierTFAs] ">"] foreach TFA $LesTFAs { if {$TFA == ""} {continue} set TFA ">$TFA" Espionne $TFA LesRegionsDetecteesPolyNDuTFA $TFA A } return } proc LesRegionsDetecteesPolyNDesTFAs_EXISTEAILLEURS {FichierTFAs N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { set LesTFAs [split [File2Text $FichierTFAs] ">"] set LesRegionsDesTFAs {} foreach TFA $LesTFAs { if {$TFA == ""} {continue} set TFA ">$TFA" Espionne $TFA lappend LesRegionsDesTFAs [LesRegionsDetecteesPolyNDuTFA $TFA A] } return $LesRegionsDesTFAs } proc LesRegionsDetecteesPolyNDuTFA {TFA N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { ### Detection de region polyN a partir d'un fichier TFA ou d'un texte TFA if {[file exists $TFA]} {set TFA [string toupper [string trim [ContenuDuFichier $TFA]]]} set Seq [QueLaSequenceDuTexteTFA $TFA] return [LesRegionsDetecteesPolyN $Seq $N $nMin $PMin $NbMaxDeBasesDiffDeNContigues $NbMinDeNAuxExtremites] } proc LesRegionsDetecteesPolyNDuTFA_EXISTEAILLEURS {TFA N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { ### Detection de region polyN a partir d'un fichier TFA ou d'un texte TFA set Seq [TFA2SEQ $TFA] return [LesRegionsDetecteesPolyN $Seq $N $nMin $PMin $NbMaxDeBasesDiffDeNContigues $NbMinDeNAuxExtremites] } proc LesRegionsDetecteesPolyN_EXISTEAILLEURS {Seq N {nMin 10} {PMin 0.95} {NbMaxDeBasesDiffDeNContigues 2} {NbMinDeNAuxExtremites 5}} { ################################################################## ### Detection de region polyN a partir d'une sequence lineaire ### ################################################################## #Seq : Sequence lineaire #N : la base d'interet ex N=A pour detecter un PolyA #nMin : Taille du PolyN minimum = taille "sliding window" #PMin : Pourcentage de A minimum dans le PolyN #NbMaxDeBasesDiffDeNContigues : Nb maximum de bases differentes de N contigues dans le polyN #Retourne : une liste contenant l'index du debut et de la fin du ou des PolyN detectes #je mets la seq dans une liste et je calcule la taille de la sequence set LaSeq [split $Seq ""] set TailleSeq [llength $LaSeq ] ### Met chaque base de la seq dans un tableau indexe avec la position de la base ### Plus rapide que lindex set PosSeq 0 foreach Base $LaSeq {set TabSeq($PosSeq) $Base;incr PosSeq} set LesDebuts {} #Je parcours la seq du debut jusqu'au debut de la derniere "sliding window" (TailleSeq - TailleSlidingWindow) for {set i 0} {$i <= [expr $TailleSeq - $nMin]} {incr i} { #grace au tableau d'indexation des bases de la seq je demande la base correspondant à la position i set Base [set TabSeq($i)] #je ne commence à compter qu'à partir d'une base N if {![string equal -nocase $Base $N]} {continue} #cette base peut donc etre mon debut de polyN set Debut $i #je vais comptabiliser le nb de bases N,le nb total de bases à travers toutes les "sliding window", #le nombre de bases N à la fin et au debut du polyN #ainsi que le nombre de bases differentes de N contigues set NbN 1 set NbNAuDebut 1 set NbNALaFin 1 set NbBases 1 set NbDeBasesDiffDeNContigues 0 #Je parcours la seq de la base suivante (debut + 1) jusqu'à la derniere base ( je quitte if {$LesDebuts == {}} {return} #sinon je reforme la description (Debut Fin) de chaque region polyN trouvee set LesRegions {} foreach Debut $LesDebuts {lappend LesRegions [list $Debut [set Tab($Debut,Fin)]]} ###Attention, a faire!!!### ###Fusionner les regions polyN selectionnees et mettre la suite de la selection directement dans la procedure qui en a besoin### ### cad fichierTFA2EST au moment de la selection des EST qui ont une queue polyA ou polyT ### #determination des regions polyN finalement selectionnees set LesRegionsSelectionnees {} #fusion des regions polyN chevauchantes foreach LaRegion [LaFusionDesRegionsOverlappantes $LesRegions] { #+1 pour D et F car la premiere base de la seq est en position 1 #alors que l'indexation dans cette procedure commence à 0 set D [expr [lindex $LaRegion 0] + 1] set F [expr [lindex $LaRegion 1] + 1] set TaillePolyN [expr $F - $D +1] lappend LesRegionsSelectionnees [list $D $F $TaillePolyN $N] } return $LesRegionsSelectionnees } proc LesRegionsDuBlast {FichierBlast {ExpectDeRef ""} {Nb ""}} { if {![file exists $FichierBlast]} {return ""} if {$ExpectDeRef == ""} {set ExpectDeRef "1e-3"} DepouilleLeBlast Blast $FichierBlast $ExpectDeRef $Nb return [LesRegionsDuTabBlast Blast] } proc LesRegionsDuTabBlast {aTabBlast} { upvar $aTabBlast Blast if {![info exists Blast(NbSubject)]} {return ""} set NbSubject [set Blast(NbSubject)] set LesRegions {} set LesBornes {} for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set Blast($i)] set NbSegment [set Blast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set Blast($BId,$j,DQ)] set FQ [set Blast($BId,$j,FQ)] lappend LesBornes $DQ lappend LesBornes $FQ if {$FQ < $DQ} { set tmp $FQ set FQ $DQ set DQ $tmp } set LaRegion [list "$DQ" "$FQ"] lappend LesRegions $LaRegion } } set LesBornes [lsort -increasing -integer [ElimineLesRedondancesDansUneListe $LesBornes]] foreach Borne $LesBornes { set Limites($Borne,Left) "-" set Limites($Borne,Right) "-" foreach LaRegion $LesRegions { set DQ [lindex $LaRegion 0] set FQ [lindex $LaRegion 1] if {$FQ < $DQ} { set tmp $FQ set FQ $DQ set DQ $tmp } if {$Borne < $DQ || $Borne > $FQ} { continue } elseif {$Borne < $FQ && $Borne > $DQ} { set Limites($Borne,Left) "+" set Limites($Borne,Right) "+" } elseif {$Borne == $DQ || $Borne < $FQ } { set Limites($Borne,Right) "+" } elseif {$Borne == $FQ} { set Limites($Borne,Left) "+" } } set Left [set Limites($Borne,Left)] set Right [set Limites($Borne,Right)] } set LesRegions2 {} for {set i 0} {$i < [llength $LesBornes]} {incr i} { set Borne [lindex $LesBornes $i] set Right [set Limites($Borne,Right)] if {$Right == "+"} { set LaRegion2 [list "$Borne" [lindex $LesBornes [expr $i + 1]]] lappend LesRegions2 $LaRegion2 } } set LesRegions {} set NRegions 0 set LesGdesRegions {} set DebutGdeRegion [lindex [lindex $LesRegions2 0] 0] set FinGdeRegion [lindex [lindex $LesRegions2 0] 1] foreach LaRegion2 $LesRegions2 { incr NRegions set LaRegion [linsert $LaRegion2 0 $NRegions] set DQR [lindex $LaRegion2 0] set FQR [lindex $LaRegion2 1] if {$FQR < $DQR} { set tmp $FQR set FQR $DQR set DQR $tmp } if {$FinGdeRegion == $DQR} { set FinGdeRegion $FQR } elseif {$FinGdeRegion <= $DQR} { set UneGdeRegion [list "$DebutGdeRegion" "$FinGdeRegion"] lappend LesGdesRegions $UneGdeRegion set DebutGdeRegion $DQR set FinGdeRegion $FQR } set Frequence 0 for {set i 1} {$i <= $NbSubject} {incr i} { set BId [set Blast($i)] set NbSegment [set Blast($BId,NbSegment)] for {set j 1} {$j <= $NbSegment} {incr j} { set DQ [set Blast($BId,$j,DQ)] set FQ [set Blast($BId,$j,FQ)] if {$FQ < $DQ} { set tmp $FQ set FQ $DQ set DQ $tmp } if {$DQR < $DQ || $FQ < $FQR} { continue } else { incr Frequence } } } set LaRegion [linsert $LaRegion 1 $Frequence] lappend LesRegions $LaRegion } set UneGdeRegion [list "$DebutGdeRegion" "$FinGdeRegion"] lappend LesGdesRegions $UneGdeRegion set LesPetitesRegions $LesRegions set LesRegions {} foreach UnePetiteRegion $LesPetitesRegions { set DebutPetiteRegion [lindex $UnePetiteRegion 2] set FinPetiteRegion [lindex $UnePetiteRegion 3] foreach UneGdeRegion $LesGdesRegions { set DebutGdeRegion [lindex $UneGdeRegion 0] set FinGdeRegion [lindex $UneGdeRegion 1] if {$DebutPetiteRegion < $DebutGdeRegion} { continue } elseif {$DebutGdeRegion <= $DebutPetiteRegion && $FinPetiteRegion <=$FinGdeRegion} { set LaRegion [linsert $UnePetiteRegion 4 $DebutGdeRegion] set LaRegion [linsert $LaRegion 5 $FinGdeRegion] lappend LesRegions $LaRegion } else { continue } } } set LesRegions [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 [lsort -increasing -integer -index 2 [lsort -increasing -integer -index 3 $LesRegions]]]] return "$LesRegions" } proc LesRegionsLesPlusGrandes {LesRegions} { # LesRegions sont decrites par leurs coordonnees set TailleMax 0 set LesRegionsSelectionnees {} foreach LaRegion $LesRegions { set D [Mini [lindex $LaRegion 0] [lindex $LaRegion 1]] set F [Maxi [lindex $LaRegion 0] [lindex $LaRegion 1]] set Taille [expr $F - $D +1] #determination et selection de la region polyN de plus grande taille if {$TailleMax < $Taille} { set TailleMax $Taille set LesRegionsSelectionnees {} lappend LesRegionsSelectionnees $LaRegion continue } #selection finale de la ou des regions polyN de plus grande taille if {$TailleMax == $Taille} { lappend LesRegionsSelectionnees $LaRegion continue } } return $LesRegionsSelectionnees } proc LesRegionsMasqueesDeLaQuery {FichierTFAMasked} { if {![file exists $FichierTFAMasked]} {return ""} if {[EstCeDeLADN $FichierTFAMasked] == 0} {return {}} set Seq [QueLaSequenceDuFichierTFA $FichierTFAMasked] set Seq [string toupper [string trim $Seq]] if {![regexp "N" $Seq]} {return {}} set Taille [string length $Seq] set Position 0 set SuisJeSurUneRegionMasquee 0 set LesRegions {} foreach Element [split $Seq ""] { incr Position if {$SuisJeSurUneRegionMasquee == 1 && $Element == "N" && $Taille == $Position} { set PosSup $Position set UneRegion [list "$PosInf" "$PosSup" "$Taille"] lappend LesRegions $UneRegion break } elseif {$SuisJeSurUneRegionMasquee == 0 && $Element == "N"} { set PosInf $Position set PosSup $Position set SuisJeSurUneRegionMasquee 1 } elseif {$SuisJeSurUneRegionMasquee == 1 && $Element == "N"} { set PosSup $Position } elseif {$SuisJeSurUneRegionMasquee == 1 && $Element != "N"} { set UneRegion [list "$PosInf" "$PosSup" "$Taille"] lappend LesRegions $UneRegion set SuisJeSurUneRegionMasquee 0 } } set LesRegions [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $LesRegions]] return $LesRegions } proc LesRegionsNouvellementMasquees {FileTFAMasked FileTFAini} { ### Calcul des regions nouvellement masquees apres une etape de reapeat ou vector ... masking ### #RM = Region Masquee #RNM = Region Nouvellement Masquee set SeqTFAini [TFA2SEQ $FileTFAini ] set SeqTFAMasked [TFA2SEQ $FileTFAMasked] set LesRMTFAini [LesRegionsMasqueesDeLaQuery $FileTFAini ] #Espionne "LesRMTFAini: $LesRMTFAini" set LesRMTFAMasked [LesRegionsMasqueesDeLaQuery $FileTFAMasked] #Espionne "LesRMTFAMasked: $LesRMTFAMasked" set LesRM {} set LesRNM {} #Faire une liste avec toutes les regions pour utiliser la proc LesPetitesRegionsDesGrandesRegions foreach RMTFAini $LesRMTFAini { lappend LesRM $RMTFAini } foreach RMTFAMasked $LesRMTFAMasked { lappend LesRM $RMTFAMasked } #Espionne "LesRM: $LesRM" set LesPRGR [LesPetitesRegionsDesGrandesRegions $LesRM] #Espionne "LesPRGR: $LesPRGR" foreach LaPRGR $LesPRGR { set DPRGR [lindex $LaPRGR 0] set FPRGR [lindex $LaPRGR 1] if {$LesRMTFAini == ""} {set LAiJeRencontre 0} foreach LaRMTFAini $LesRMTFAini { set LAiJeRencontre 0 set DRMTFAini [lindex $LaRMTFAini 0] set FRMTFAini [lindex $LaRMTFAini 1] if {![CesRegionsSontEllesOverlappantes $DPRGR $FPRGR $DRMTFAini $FRMTFAini]} {continue} set LAiJeRencontre 1 break } if {!$LAiJeRencontre} {lappend LesRNM $LaPRGR} } #Espionne "LesRNM: $LesRNM" return $LesRNM } proc LesRegionsProchesFusionnees {LesRegions DistanceMax} { foreach LaRegion [lsort -index 0 -real [LesPetitesRegionsDesGrandesRegions $LesRegions]] { } } proc LesRegionsUniquesDesContigsDansLeBonOrdre {LesRegions {var 0.05}} { set LesAccessEtLeurSens {} foreach UneRegion $LesRegions { set Access [lindex [lindex $UneRegion 4] 1] set Sens [lindex $UneRegion 6] if {[lindex $UneRegion 3] != 1} {continue} if {![info exists Tab($Access,$Sens)]} { set Tab($Access,$Sens) {} lappend LesAccessEtLeurSens [list $Access $Sens] } set D [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] if {$Sens == "-"} { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } set UneRegion [lreplace $UneRegion 0 0 $D ] set UneRegion [lreplace $UneRegion 1 1 $F ] set UneRegion [lreplace $UneRegion 7 7 $DS] set UneRegion [lreplace $UneRegion 8 8 $FS] lappend Tab($Access,$Sens,LesRegions) $UneRegion } set ScoreMaxTot 0 set LesRegionsDesContigsDansLOrdre {} foreach LAccess $LesAccessEtLeurSens { set Access [lindex $LAccess 0] set Sens [lindex $LAccess 1] set LesRegionsDeLAccess {} foreach UneRegion [lsort -index 0 -integer [set Tab($Access,$Sens,LesRegions)]] { set Access2 [lindex [lindex $UneRegion 4] 1] set Sens2 [lindex $UneRegion 6] if {$Access2 != $Access || $Sens2 != $Sens} {continue} lappend LesRegionsDeLAccess $UneRegion } set LesRegionsDeLAccAvecLesRangsDeLaQ {} set LesRegionsDeLAccAvecLesRangsDeLaQEtDuS {} set LesRangs {} set i 0 foreach UneRegion [lsort -integer -index 0 $LesRegionsDeLAccess] { incr i lappend UneRegion $i lappend LesRegionsDeLAccAvecLesRangsDeLaQ $UneRegion } if {$Sens == "+"} { set LesRegions [lsort -integer -index 8 $LesRegionsDeLAccAvecLesRangsDeLaQ] } else { set LesRegions [lsort -decreasing -integer -index 8 $LesRegionsDeLAccAvecLesRangsDeLaQ] } set i 0 foreach UneRegion $LesRegions { incr i lappend UneRegion $i lappend LesRegionsDeLAccAvecLesRangsDeLaQEtDuS $UneRegion } foreach UneRegion $LesRegionsDeLAccAvecLesRangsDeLaQEtDuS { lappend LesRangs [list [lindex $UneRegion end-1] [lindex $UneRegion end] [lindex $UneRegion 9]] } set LesRegions [lsort -integer -index 0 $LesRegionsDeLAccAvecLesRangsDeLaQEtDuS] set LesRangsOrdonnes [AlignementDynamique [lsort -integer -index 0 $LesRangs]] set ScoreMax 0 set LesRegionsDansLOrdre {} foreach LeRang $LesRangsOrdonnes { set ScoreMax [expr $ScoreMax + [lindex $LeRang end]] set RangQuery [lindex $LeRang 0] set UneDesRegionsOrdonnees [lindex $LesRegions [expr $RangQuery - 1]] lappend LesRegionsDansLOrdre [lrange $UneDesRegionsOrdonnees 0 11] } foreach UneRegion $LesRegionsDansLOrdre { lappend UneRegion $ScoreMax lappend LesRegionsDesContigsDansLOrdre $UneRegion } if {$ScoreMaxTot < $ScoreMax} {set ScoreMaxTot $ScoreMax} } set ScoreMaxTot [expr $ScoreMaxTot * (1 - $var)] set LesRegions {} foreach UneRegion $LesRegionsDesContigsDansLOrdre { if {[lindex $UneRegion end] < $ScoreMaxTot} {continue} lappend LesRegions $UneRegion } return $LesRegions } proc LesRegionsUniquesFusionneesDesContigs {LesRegions {TailleMinIntron 10}} { set LesAccessEtLeurSens {} set LesRegions [lsort -integer -index 0 $LesRegions] foreach UneRegion $LesRegions { set LeBId [lindex $UneRegion 4] set Access [lindex $LeBId 1] set Sens [lindex $UneRegion 6] if {[info exists TabTmp($Access,$Sens)]} {continue} set TabTmp($Access,$Sens) 1 lappend LesAccessEtLeurSens [list $Access $Sens] } set LesRegionsDuContig {} foreach LAccessEtLeSens $LesAccessEtLeurSens { if {[info exists UneRegionDeRef]} {unset UneRegionDeRef} set Access [lindex $LAccessEtLeSens 0] set Sens [lindex $LAccessEtLeSens 1] foreach UneRegion $LesRegions { set LeBId [lindex $UneRegion 4] set Access2 [lindex $LeBId 1] set Sens2 [lindex $UneRegion 6] set N [lindex $UneRegion 3] if {$Access2 != $Access || $Sens2 != $Sens} {continue} if {![info exists UneRegionDeRef]} {set UneRegionDeRef $UneRegion;continue} if {$N != 0 && $N != 1} { if {[info exists UneRegionDeRef]} { lappend LesRegionsDuContig $UneRegionDeRef unset UneRegionDeRef } lappend LesRegionsDuContig $UneRegion continue } set D [Mini [lindex $UneRegion 0 ] [lindex $UneRegion 1]] set F [Maxi [lindex $UneRegion 0 ] [lindex $UneRegion 1]] set nAli [lindex $UneRegion 9 ] set nAliTot [lindex $UneRegion 10] set nCont [lindex $UneRegion 11] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } set NDeRef [lindex $UneRegionDeRef 3] if {$NDeRef != $N} { lappend LesRegionsDuContig $UneRegionDeRef set UneRegionDeRef $UneRegion continue } set FDeRef [Maxi [lindex $UneRegionDeRef 0] [lindex $UneRegionDeRef 1]] if {[expr $FDeRef + $TailleMinIntron] < $D} { lappend LesRegionsDuContig $UneRegionDeRef set UneRegionDeRef $UneRegion continue } if {$Sens == "+"} { set FSDeRef [Maxi [lindex $UneRegionDeRef 7] [lindex $UneRegionDeRef 8]] } else { set FSDeRef [Mini [lindex $UneRegionDeRef 7] [lindex $UneRegionDeRef 8]] } if {$Sens == "+" && [expr $FSDeRef + $TailleMinIntron] < $DS} { lappend LesRegionsDuContig $UneRegionDeRef set UneRegionDeRef $UneRegion continue } if {$Sens == "-" && $DS < [expr $FSDeRef - $TailleMinIntron]} { lappend LesRegionsDuContig $UneRegionDeRef set UneRegionDeRef $UneRegion continue } set nAliDeRef [expr [lindex $UneRegionDeRef 9] + $nAli] set nAliTotDeRef [expr [lindex $UneRegionDeRef 10] + $nAliTot] set nContDeRef [lindex $UneRegionDeRef 11] if {$nContDeRef < $nCont} {set nContDeRef $nCont} set UneRegionDeRef [lreplace $UneRegionDeRef 1 1 $F ] set UneRegionDeRef [lreplace $UneRegionDeRef 8 8 $FS ] set UneRegionDeRef [lreplace $UneRegionDeRef 9 9 $nAliDeRef ] set UneRegionDeRef [lreplace $UneRegionDeRef 10 10 $nAliTotDeRef ] set UneRegionDeRef [lreplace $UneRegionDeRef 11 11 $nContDeRef ] } if {[info exists UneRegionDeRef]} {lappend LesRegionsDuContig $UneRegionDeRef} } return $LesRegionsDuContig } proc LesRegionsVidesDeLaListe {LesRegionsOccupees Taille} { set LesBornesMax {} set LesRegionsOccupees [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $LesRegionsOccupees]] foreach UneRegion $LesRegionsOccupees { if {[lindex $UneRegion 0] != ""} { lappend LesBornesMax [lindex $UneRegion 0] lappend LesBornesMax [lindex $UneRegion 1] } } if {$LesBornesMax != {}} { set FinDesRegions [MaxiDeLaListe $LesBornesMax] } set LesRegionsVides {} if {$LesRegionsOccupees == {}} { set UneRegionVide [list "1" "$Taille" "$Taille"] lappend LesRegionsVides $UneRegionVide } else { set SuisJeSurUneRegionVide 0 for {set i 1} {$i <= $Taille} {incr i} { foreach UneRegion $LesRegionsOccupees { if {[lindex $UneRegion 0] == "" || [lindex $UneRegion 1] == ""} {continue} set D [lindex $UneRegion 0] set F [lindex $UneRegion 1] if {$F < $D} { set tmp $F set F $D set D $tmp } if {$SuisJeSurUneRegionVide == 1 && $i == $Taille} { set PosSup $Taille set UneRegionVide {} set UneRegionVide [list "$PosInf" "$PosSup" "$Taille"] lappend LesRegionsVides $UneRegionVide break } elseif {$SuisJeSurUneRegionVide == 0 && $i == $Taille} { break } elseif {$FinDesRegions < $i && $SuisJeSurUneRegionVide == 0} { set SuisJeSurUneRegionVide 1 set PosInf $i set PosSup $i break } elseif {$FinDesRegions < $i && $SuisJeSurUneRegionVide == 1} { set PosSup $i break } elseif {$F < $i} { continue } elseif {$D <= $i && $i <= $F && $SuisJeSurUneRegionVide == 0} { break } elseif {$D <= $i && $i <= $F && $SuisJeSurUneRegionVide == 1} { set UneRegionVide {} set SuisJeSurUneRegionVide 0 set UneRegionVide [list "$PosInf" "$PosSup" "$Taille"] lappend LesRegionsVides $UneRegionVide break } elseif {$SuisJeSurUneRegionVide == 0 && $i < $D} { set PosInf $i set PosSup $i set SuisJeSurUneRegionVide 1 break } elseif {$SuisJeSurUneRegionVide == 1 && $i < $D} { set PosSup $i break } } } } set LesRegionsVides [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $LesRegionsVides]] return $LesRegionsVides } proc LesRepeatsDeLEnteteDuTFA {FichierTFA} { if {![file exists $FichierTFA]} {return} return [LesRepeatsDuTFA [ContenuDuFichier $FichierTFA]] } proc LesRepeatsDeRepeatMaskerOut {FichierRMOut} { set LesRepeats {} set F [open $FichierRMOut] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set Ligne [string trim $Ligne] if {![regexp {^[0-9]} $Ligne]} {continue} regsub -all {[ ]+} $Ligne " " Ligne set LaLigne [split $Ligne " "] set Debut [lindex $LaLigne 5] set Fin [lindex $LaLigne 6] set Repeat [lindex $LaLigne 9] lappend LesRepeats [list $Debut $Fin $Repeat] } close $F return $LesRepeats } proc LesRepeatsDuTFA {TexteTFA} { set LesRepeats {} set SuisJeSurLePourcentage 0 set LesMots [split [EnteteDuTexteTFA $TexteTFA] " "] set NbMots [llength $LesMots] set LesRepeatsTmp {} set SuisJeSurLesRepeats 0 for {set i $NbMots} {$i > 0} {incr i -1} { set Mot [lindex $LesMots [expr $i - 1]] if {$Mot == ""} {continue} if {[string equal -nocase "endmask" $Mot] || [string equal -nocase "endremask" $Mot] || [string equal -nocase "endmrm" $Mot]} { set SuisJeSurLesRepeats 1 continue } if {[regexp -nocase "partially|totally" $Mot] && [regexp -nocase "masked" $Mot]} {break} if {[regexp -nocase "norepeat|nosequence" $Mot]} {break} if {$SuisJeSurLesRepeats} {lappend LesRepeatsTmp $Mot} } set LesRepeats {} set LesRepeatsTmp [lrange $LesRepeatsTmp 0 end-1] for {set i [llength $LesRepeatsTmp]} {$i > 0} {incr i -1} { lappend LesRepeats [lindex $LesRepeatsTmp [expr $i - 1]] } return $LesRepeats } proc LesRepertoires {Org IniOrMod} { #les fichiers Mod sont faits avec la procedure RenommeLARedondant if {[regexp -nocase "Mouse" $Org]} { if {$IniOrMod=="Ini"} {set Chemin "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai"} if {$IniOrMod=="Mod"} {set Chemin "/genomics/link/SpliRetMouse/FichiersModifUnique/PROT_VARIANTES_61_mai"} set RepertoireSourisTfactor "$Chemin/SOURIS_Tfactor_61_mai" set RepertoireSourisOthers "$Chemin/SOURIS_others_61_mai" set RepertoireSourisNOALT "$Chemin/SOURIS_NO_ALT_61_mai" set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNOALT] } if {[regexp -nocase "Rat" $Org]} { if {$IniOrMod=="Ini"} {set Chemin "/genomics/link/SpliRetRat/FichiersInitial/PROT_VARIANTES_61_mai"} if {$IniOrMod=="Mod"} {set Chemin "/genomics/link/SpliRetRat/FichiersModifUnique/PROT_VARIANTES_61_mai"} set RepertoireRatTfactor "$Chemin/RAT_Tfactor_61_mai" set RepertoireRatOthers "$Chemin/RAT_others_61_mai" set RepertoireRatNOALT "$Chemin/RAT_NO_ALT_61_mai" set LesRepertoires [list $RepertoireRatTfactor $RepertoireRatOthers $RepertoireRatNOALT] } return $LesRepertoires } proc LesRepertoiresInteressantsPour {Nom {HtmlAussi ""} {Vite ""}} { } proc LesRepertoiresPossiblesPour {Nom {HtmlAussi ""} {Vite ""}} { global RepertoireDuGenome if {$Nom=="All"} { set Vite "TesteRepertoire" if {$HtmlAussi==""} { set HtmlAussi "HtmlAussi" } } if {$Vite==""} { set Vite "Vite" } if {$Vite=="TestePresence" || $Vite=="TesteRepertoire"} { set Vite 0 } else { set Vite 1 } if {$HtmlAussi=="HtmlAussi"} {set HtmlAussi 1 } else {set HtmlAussi 0 } if {$Vite} { set LesRepNom [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] if {$HtmlAussi} { set LesRepNomHtml [glob -nocomplain "[RepertoireDuGenome]/*/$Nom.html"] LConcat LesRepNom $LesRepNomHtml } set LesPossibles {} foreach RepNom $LesRepNom { lappend LesPossibles [file tail [file dirname $RepNom]] } return $LesPossibles } set LesPossibles {} set LesRepertoires [glob -nocomplain -type d $RepertoireDuGenome/*] set LesLiens [glob -nocomplain -type l $RepertoireDuGenome/*] foreach Lien $LesLiens { set But [file readlink $Lien] if {[file isdirectory $But]} { lappend LesRepertoires $But } } if {$Nom=="All"} { foreach Rep $LesRepertoires { set LesRepNom [glob -nocomplain "$Rep/[PreFixe]*"] if {$LesRepNom=={}} {continue} lappend LesPossibles [file tail $Rep] } return $LesPossibles } foreach Rep $LesRepertoires { if {$Vite} { lappend LesPossibles [file tail $Rep] ; continue } if {[file exists "$Rep/$Nom"]} { lappend LesPossibles [file tail $Rep] continue } if {$HtmlAussi && [file exists "$Rep/$Nom.html"]} { lappend LesPossibles [file tail $Rep] continue } if {[OnTraiteDesCDNAs]} { continue } foreach SousRep [lsort [glob -nocomplain -type d $Rep/*]] { if {[file exists $Rep/$Nom]} { lappend LesPossibles "[file tail $Rep]/[file tail $SousRep]" continue } } } return $LesPossibles } proc LesRepertoiresPourSeeAbyShow {{Action ""} {Reps ""}} { global LesRepertoiresPourSeeAbyShow if {$Action==""} { set Action "Get" } set FichierShowDirs "[RepertoireDuGenome]/fiches/showdirs" if {$Action=="Get"} { if {[info exists LesRepertoiresPourSeeAbyShow]} { return $LesRepertoiresPourSeeAbyShow } if {[file exists $FichierShowDirs]} { set LesRepertoiresPourSeeAbyShow [LesLignesDuFichier $FichierShowDirs] } else { set LesRepertoiresPourSeeAbyShow [list bilan notes msf infos blastp prottfa nuctfa ver ] } return $LesRepertoiresPourSeeAbyShow } if {$Action=="PutInFront"} { set LesRepertoiresPourSeeAbyShow [linsert $LesRepertoiresPourSeeAbyShow 0 {*}$Reps] set LesRepertoiresPourSeeAbyShow [ListeSansDoublon $LesRepertoiresPourSeeAbyShow] return $LesRepertoiresPourSeeAbyShow } set LesAnciens [LesRepertoiresPourSeeAbyShow] if {$Action=="Ask"} { set LesFichiersPossibles [glob -nocomplain "$FichierShowDirs*"] if {$LesFichiersPossibles!={}} { while {[OuiOuNon "Do you want to load a file ?"]} { set FichierPossible [ButineArborescence "All" "[RepertoireDuGenome]/fiches/"] if {$FichierPossible==""} { continue } set LesAnciens [LesLignesDuFichier $FichierPossible] break } } set LesReps [MorceauxChoisisAndMore $LesAnciens] if {$LesReps=={}} { set LesReps $LesAnciens } foreach Rep $LesReps { lappend LesNouveaux [file tail $Rep] } set LesRepertoiresPourSeeAbyShow $LesNouveaux while {[OuiOuNon "Do You want to save this list in a file ?"]} { set NewFichierShowDirs [FichierPourSaveAs $FichierShowDirs] if {$NewFichierShowDirs==""} { continue } SauveLesLignes $LesRepertoiresPourSeeAbyShow dans $NewFichierShowDirs break } return $LesRepertoiresPourSeeAbyShow } } proc LesRequetesDesGOEtDesAncetres {LesGO} { set TousLesGO {} foreach GO [lsort -unique [concat $LesGO [TousLesAncetresGODesGO $LesGO]]] { lappend TousLesGO $GO foreach Type [GODB GO $GO LesTypes] { set GODeRef [GODB Type $Type GOSynonyme $GO GODeRef] lappend TousLesGO $GODeRef foreach GOSynonyme [GODB Type $Type GO $GO LesSynonymes] { lappend TousLesGO $GOSynonyme } } } set LesInfos {} foreach GO [lsort -unique $TousLesGO] { set GO [string toupper $GO] lappend LesInfos [list GO $GO] foreach Requete [2GO $GO LesLiens] { if {[info exists TabTmp($Requete)]} {continue} set TabTmp($Requete) 1 set What [2GO $Requete WhatIsIt] lappend LesInfos [list $What $Requete] } } return [lsort -index 0 $LesInfos] } proc LesRequetesDesGOEtDesDescendants {LesGO} { set TousLesGO {} set LesDescendants [TousLesDescendantsGODesGO $LesGO] foreach GO [lsort -unique [concat $LesGO $LesDescendants]] { lappend TousLesGO $GO foreach Type [GODB GO $GO LesTypes] { set GODeRef [GODB Type $Type GOSynonyme $GO GODeRef] lappend TousLesGO $GODeRef foreach GOSynonyme [GODB Type $Type GO $GO LesSynonymes] { lappend TousLesGO $GOSynonyme } } } set LesInfos {} foreach GO [lsort -unique $TousLesGO] { set GO [string toupper $GO] lappend LesInfos [list GO $GO] foreach Requete [2GO $GO LesLiens] { if {[info exists TabTmp($Requete)]} {continue} set TabTmp($Requete) 1 set What [2GO $Requete WhatIsIt] lappend LesInfos [list $What $Requete] } } return [lsort -index 0 $LesInfos] } proc LesRequetesDuGOEtDesAncetres {LesGO} { set LesInfos {} foreach GO [lsort -unique $LesGO] { set TousLesGODuGO [list $GO] set TousLesGODuGO [concat $TousLesGODuGO [TousLesAncetresOntologiques "JeNeConnaisPasLeType" $GO]] foreach GO $TousLesGODuGO { set TousLesGODuGOEtPlus [list $GO] set Jumeau [Onto $GO MonJumeau] if {$Jumeau != ""} {lappend TousLesGODuGOEtPlus $Jumeau} foreach Jumeau [Onto $GO LesJumeaux] {lappend TousLesGODuGOEtPlus $Jumeau} foreach GO [lsort -unique $TousLesGODuGOEtPlus] { if {[info exists TabTmp($GO)]} {continue} set TabTmp($GO) 1 lappend LesInfos [list GO $GO] foreach Req [Interroge2GO $GO] { if {[info exists TabTmp($Req)]} {continue} set TabTmp($Req) 1 set What [Interroge2GO $Req WhatIsIt] lappend LesInfos [list $What $Req] } } } } return [lsort -index 0 $LesInfos] } proc LesRequetesDuGOEtDesDescendants {LesGO} { set LesInfos {} foreach GO [lsort -unique $LesGO] { set TousLesGODuGO [list $GO] set TousLesGODuGO [concat $TousLesGODuGO [TousLesDescendantsOntologiques "JeNeConnaisPasLeType" $GO]] foreach GO $TousLesGODuGO { set TousLesGODuGOEtPlus [list $GO] set Jumeau [Onto $GO MonJumeau] if {$Jumeau != ""} {lappend TousLesGODuGOEtPlus $Jumeau} foreach Jumeau [Onto $GO LesJumeaux] {lappend TousLesGODuGOEtPlus $Jumeau} foreach GO [lsort -unique $TousLesGODuGOEtPlus] { if {[info exists TabTmp($GO)]} {continue} set TabTmp($GO) 1 lappend LesInfos [list GO $GO] foreach Req [Interroge2GO $GO] { if {[info exists TabTmp($Req)]} {continue} set TabTmp($Req) 1 set What [Interroge2GO $Req WhatIsIt] lappend LesInfos [list $What $Req] } } } } return [lsort -index 0 $LesInfos] } proc LesResidusDesARPs {{FichierMSF ""} {FichierPosNtB ""} {FichierOut ""}} { Wup "Permet de rendre les residus equivalents a certaines positions importantes pour une fonction en particulier" Wup "Permet egalement de calculer les moyennes de % d identite et de similarite" Wup "Tout depend du fichier de positions qui est donne" #Utilisation du programme de Julie qui permet de transcrire les positions, dans un alignement par rapport a une #sequence de reference, aux residus equivalents dans plusieurs autres sequences #Format d entree du fichier #1ere ligne Seq de ref (P02568) #2eme ligne les positions separees par des blancs (1 34 546 21 ...) #ligne suivante un nom de sequence par ligne #/home/julie/bin/aln_res Actin_Complet3_1_Propre.rsf ARP_ntbinding set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/" set Aln_Res "/home/julie/bin/aln_res" if {$FichierMSF==""} { set FichierMSF "$ARPHomeDir/Actin_Complet3_1_Propre.rsf" } #Lecture du fichier contenant les positions a recherchees if {$FichierPosNtB==""} { set FichierPosNtB "$ARPHomeDir/Residue/ARP_ntbinding" } #Fichier contenant les positions importantes pour le binding au nucleotide (ATP/ATP) if {$FichierOut==""} { set FichierOut "$ARPHomeDir/Residue/LesARPs_ntbinding" } foreach FichierPos $FichierPosNtB { set Reference "" set LesPos "" set i 0 set F [open "$FichierPos"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} incr i if {$i=="1"} { set Reference [lindex $Ligne 0] continue } if {$i=="2"} { set LesPos [split [string trim $Ligne] " "] break } } close $F AppendAuFichier $FichierOut [join [join [list Positions $LesPos] " "] "\t"] } #Recherche des residus aux positions demandees set LesResidus "" set Result "" if {[catch {set LesResidus [exec $Aln_Res $FichierMSF $FichierPosNtB]} Message]} { Espionne "pb $Message" } else { foreach Result [split $LesResidus "\n"] { set Result [join [string trim $Result] "\t"] AppendAuFichier $FichierOut $Result } } #Recuperation des categories de sequences dans ARP set LesCategories [InterrogeLesInfosDesARPs LesCategories] set LesCategories [linsert $LesCategories end "Autres"] foreach Cate $LesCategories { set TabResidue($Cate) "" } #Recuperation des resultats et classement en fonction des categories set FileToRead "$FichierOut" set Ligne "" set F [open "$FileToRead"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set Cat "" set Results "" set Acc "" set Residues "" set Results [split $Ligne "\t"] set Acc [string toupper [lindex $Results 0]] set Residues [lrange $Results 1 end] if {[regexp -nocase {exonic|\-{3,}} $Acc]} {continue} set TabResidue($Acc,Residues) [join $Residues "\t"] if {$Acc=="P02568"} { set SeqDeRef [join $Residues ""] } if {$Acc=="POSITIONS" || $Acc=="P02568"} { set Cat "----Reference----" } else { set Cat [InterrogeLesInfosDesARPs $Acc Categorie] } if {! [info exists TabResidue($Cat)] || $Cat ==""} { lappend TabResidue(Autres) $Acc } else { lappend TabResidue($Cat) $Acc } } close $F file delete -force $FichierOut #Enregistrement dans le meme fichier apres l avoir deleter des resultats formates set TailleSeqDeRef [string length $SeqDeRef] set Ligne "Access\t[string repeat "\t" $TailleSeqDeRef]\t\tSimilarity\t\t\tIdentity" AppendAuFichier $FichierOut $Ligne foreach Categorie $LesCategories { if {[info exists TabResidue($Categorie)] && [set TabResidue($Categorie)]==""} {continue} set MoyenneSimilarite 0 set MoyenneIdentite 0 set TotalSimilarite 0 set TotalIdentite 0 set NbValeurs 0 set LesValeursSimilarites "" set LesValeursIdentites "" AppendAuFichier $FichierOut $Categorie foreach Access [set TabResidue($Categorie)] { set Ligne "" set Seq2Compare "" set Similarite 0 set Identite 0 incr NbValeurs if {$Access!="POSITIONS"} { set Seq2Compare [join [split [set TabResidue($Access,Residues)] "\t"] ""] set Similarite [join [LesResidusSimilaires $SeqDeRef $Seq2Compare] "\t"] set Identite [join [LesResidusIdentiques $SeqDeRef $Seq2Compare] "\t"] } set Seq2Compare [set TabResidue($Access,Residues)] append Ligne "$Access\t$Seq2Compare\t$Similarite\t$Identite" set TotalSimilarite [expr $TotalSimilarite + [lindex $Similarite end]] set TotalIdentite [expr $TotalIdentite + [lindex $Identite end]] lappend LesValeursSimilarites [lindex $Similarite end] lappend LesValeursIdentites [lindex $Identite end] AppendAuFichier $FichierOut $Ligne } set MoyenneSimilarite [expr (1.0 * $TotalSimilarite) / $NbValeurs] set MoyenneIdentite [expr (1.0 * $TotalIdentite) / $NbValeurs] if {$LesValeursSimilarites ==""} { set TabResidue($Categorie,EcartFredSim) "" set TabResidue($Categorie,EcartFredIde) "" } else { set EcartFredSim [EcartTypeDeLaListe $LesValeursSimilarites] set EcartFredIde [EcartTypeDeLaListe $LesValeursIdentites] set TabResidue($Categorie,EcartFredSim) $EcartFredSim set TabResidue($Categorie,EcartFredIde) $EcartFredIde } set TabResidue($Categorie,MoyenneSimilarite) $MoyenneSimilarite set TabResidue($Categorie,MoyenneIdentite) $MoyenneIdentite set Ligne "Moyennes\t[string repeat "\t" $TailleSeqDeRef]\t\t$MoyenneSimilarite\t\t\t$MoyenneIdentite" AppendAuFichier $FichierOut "$Ligne" } AppendAuFichier $FichierOut "" AppendAuFichier $FichierOut "[join [list Famille MoyenneSimilarite EcartTypeSimilarite MoyenneIdentite EcartTypeIdentite] "\t"]" foreach Categorie $LesCategories { if {[info exists TabResidue($Categorie)] && [set TabResidue($Categorie)]==""} {continue} set MoyenneSimilarite [set TabResidue($Categorie,MoyenneSimilarite)] set MoyenneIdentite [set TabResidue($Categorie,MoyenneIdentite)] set EcartFredSim [set TabResidue($Categorie,EcartFredSim)] set EcartFredIde [set TabResidue($Categorie,EcartFredIde)] AppendAuFichier $FichierOut "[join [list $Categorie $MoyenneSimilarite $EcartFredSim $MoyenneIdentite $EcartFredIde] "\t"]" } return "" } proc LesResidusDesARPsPourABP {} { set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP" set ABPDir "$ARPHomeDir/Resultat/signature/ABP_residues" set MSF "$ARPHomeDir/Resultat/alignement/Actin_Complet5_0.rsf" set LesFichierABP [glob -nocomplain -directory "$ABPDir" "*.res"] foreach F $LesFichierABP { Espionne "$F" set FOut "Les[file tail $F]" regsub ".res$" $FOut "Fout" #Espionne "LesResidusDesARPs $MSF $F $FOut" LesResidusDesARPs $MSF $F $FOut } return "" } proc LesResidusDiscriminantsDesARPs {{FichierMSF ""} {LesFichiersPos ""} {FichierOut ""}} { Wup "Permet de rendre les residus discriminants et les positions relatives" #Utilisation du programme de Julie qui permet de transcrire les positions, dans un alignement par rapport a une #sequence de reference, en position equivalentes dans plusieurs autres sequences #Format d entree du fichier #1ere ligne Seq de ref (P02568) #2eme ligne les positions separees par des blancs (1 34 546 21 ...) #ligne suivante un nom de sequence par ligne #/home/julie/bin/aln_pos Actin_Complet3_1_Propre.rsf ARP8_signature set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/" set Aln_Pos "/home/julie/bin/aln_pos" if {$FichierMSF==""} { set FichierMSF "$ARPHomeDir/Actin_Complet3_8.rsf" } #Fichier contenant les positions importantes pour le binding au nucleotide (ATP/ATP) if {$FichierOut==""} { set FichierOut "$ARPHomeDir/Residue/LesARPs_signature.res" } #Lecture du fichier contenant les positions a recherchees #set LesFichiersPos [glob -nocomplain -directory "$ARPHomeDir/Residue" "ARP*_signature"] if {$LesFichiersPos==""} { set LesFichiersPos [glob -nocomplain -directory "$ARPHomeDir/Residue" "ARP*_signature.res"] } Espionne "$LesFichiersPos" foreach FichierPos $LesFichiersPos { if {[file size $FichierPos]=="0"} {continue} AppendAuFichier $FichierOut [file tail $FichierPos] set Reference "" set LesPos "" set i 0 set F [open "$FichierPos"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} incr i if {$i=="1"} { set Reference [lindex $Ligne 0] continue } if {$i=="2"} { set LesPos [split [string trim $Ligne] " "] break } } close $F set LaReference [join [linsert $LesPos 0 $Reference] "\t"] #Espionne "$LaReference" AppendAuFichier $FichierOut $LaReference set LesResidus "" set Result "" if {[catch {set LesResidus [exec $Aln_Pos $FichierMSF $FichierPos]} Message]} { Espionne "pb $Message" } else { foreach Result [split $LesResidus "\n"] { set Result [join [string trim $Result] "\t"] AppendAuFichier $FichierOut $Result } } } return "" } proc LesResidusIdentiques {SeqA SeqB} { Wup "Retourne le nombre de residus identiques entre 2 sequence par rapport a la premiere" Wup "Output liste: NbIdentique NbResidus Pourcent" set i -1 set NbId 0 set Total [string length $SeqA] foreach C [split $SeqA ""] { incr i set NbId [expr $NbId + [string equal $C [string index $SeqB $i]]] } set Pourcent [format "%.2f" [expr (($NbId*1.0)/$Total)*100.0]] return [list $NbId $Total $Pourcent] } proc LesResidusNtBindingsDesARPs {{FichierMSF ""} {FichierPosNtB ""} {FichierOut ""}} { set ARPHomeDir "[RepertoireDuGenome]/alignement_ARP/" if {$FichierMSF==""} { set FichierMSF "$ARPHomeDir/Actin_Complet3_1_Propre.rsf" } #Lecture du fichier contenant les positions a recherchees if {$FichierPosNtB==""} { set FichierPosNtB "$ARPHomeDir/Residue/ARP_ntbinding_all" } set FichierOut "$ARPHomeDir/Residue/LesARPs_ntbinding_all" LesResidusDesARPs $FichierMSF $FichierPosNtB $FichierOut return "" } proc LesResidusSimilaires {SeqA SeqB} { Wup "Retourne le nombre de residus similaires entre 2 sequence par rapport a la premiere" Wup "Output liste: NbSimilaire NbResidus Pourcent" set i -1 set NbS 0 set Total [string length $SeqA] foreach C [split $SeqA ""] { incr i set NbS [expr $NbS + [EstSimilaire $C [string index $SeqB $i]]] } set Pourcent [format "%.2f" [expr (($NbS*1.0)/$Total)*100.0]] return [list $NbS $Total $Pourcent] } proc LesResultatsARPAnalyses {args} { Wup "Permet de gerer et stocker les parametres et les resultats de la recherche des familles d ARPs" #Utilisation Qui ValeurOuNon Quoi #Valeur pour Quoi: #Positionne Positionne le parametre a la valeur #Ajoute Ajoute ou positionne le parametre si il n existe pas #Existe Retourne 1 si la valeur existe ou 0 sinon #LaValeurMerci Retourne la valeur du parametre ou vide sinon #Reset Positionne la valeur a vide #UnsetAll Efface tout #Particulier: #Qui=all Retourne toutes les valeurs du tableau #Qui=UnsetAll Vide le tableau en entier #Quoi=Reset et Valeur=all Supprime toutes les entrees de Qui (Ex:LesZones*) global ResultsARPAnalyses set Qui [lindex $args 0] if { $Qui==""} { return "" } elseif {$Qui=="all"} { if {[info exists ResultsARPAnalyses]} {return [array get ResultsARPAnalyses]} } elseif {$Qui=="UnsetAll"} { array unset ResultsARPAnalyses "*" return "" } set NbArgs [llength $args] #Valeur si il y en a une ok sinon c est aussi $Qui set Valeur [lindex $args end-1] set Quoi [lindex $args end] if {$Quoi==""} {set Quoi "LaValeurMerci"} if {$Quoi=="Positionne"} { set ResultsARPAnalyses($Qui) $Valeur return "" } elseif {$Quoi=="Reset"} { if {$Valeur=="all"} { array unset ResultsARPAnalyses "$Qui*" } else { if {[info exists ResultsARPAnalyses($Qui)]} {unset ResultsARPAnalyses($Qui)} } } elseif {$Quoi=="LaValeurMerci"} { if {[info exists ResultsARPAnalyses($Qui)]} {return [set ResultsARPAnalyses($Qui)]} else {return ""} } elseif {$Quoi=="Ajoute"} { lappend ResultsARPAnalyses($Qui) $Valeur } elseif {$Quoi=="Existe"} { if {[info exists ResultsARPAnalyses($Qui)]} {return 1} else {return 0} } return "" } proc LesResultatsGCCount {} { Wup "Permet de rendre les resultats du best GC sous forme de liste" global TabDesGCs if {! [info exists TabDesGCs]} {return ""} set LesResultats [array get TabDesGCs] return $LesResultats } proc LesResultatsTmCount {} { Wup "Permet de rendre les resultats du best Tm sous forme de liste" global TabDesTms if {! [info exists TabDesTms]} {return ""} set LesResultats [array get TabDesTms] return $LesResultats } proc LesRetChip {{LesChamps ""} {JoinCar ""}} { if {$JoinCar==""} { set JoinCar " " } if {$JoinCar=="WithoutJoinCar"} { set JoinCar "" } if {$LesChamps==""} { set LesChamps [list "Nom"] } set LesRetChip {} foreach Nom [ListeDesPABs] { set RetChip [ExtraitInfo $Nom "RetChip"] if { ! [regexp -nocase "^y" $RetChip]} { continue } set LesInfos {} foreach Champ $LesChamps { lappend LesInfos [ExtraitInfo $Nom $Champ] } set Infos [join $LesInfos $JoinCar] lappend LesRetChip $Infos } return $LesRetChip } proc LesRetChipAcCoordHumaines {} { set nb 0; set vide 0 foreach PAB [ListeDesPABs] { set Rc [ExtraitInfo $PAB "RetChip"] if {$Rc=="yes"} { incr nb; set LesLoc {}; set LesLignes {} set GnM1 [ExtraitInfo $PAB "ValiGN"] #set GnM2 [ExtraitInfo $PAB "ValiGNProt"] set GnH1 [HumanFromMouse $GnM1 Approved_Symbol] #set GnH2 [HumanFromMouse $GnM2 Approved_Symbol] Espionne "" Espionne "$PAB $Rc" #if {$GnM1!="" && $GnM2!="" && $GnM1!=$GnM2} {Espionne "attention mouse different"} #if {$GnH1!="" && $GnH2!="" && $GnH1!=$GnH2} {Espionne "attention human different"} Espionne "Mouse $GnM1" Espionne "Human $GnH1" if {$GnH1==""} { incr vide Espionne "vide" set LigneDef "$GnM1;vide;vide" lappend LesLignesDef $LigneDef } else { lappend LesLignes "ID * DB UCSC" lappend LesLignes "WH SQLNATIVE SELECT chrom, strand, txStart, txEnd from ucschuman.pureGene WHERE name2='$GnH1'" lappend LesLignes "FM FLAT" set FileBql "/tmp/toto.bql" set FileRes "/tmp/toto.res" SauveLesLignes $LesLignes dans $FileBql BirdForceHoan $FileBql $FileRes foreach Ligne [LesLignesDuFichier $FileRes] { if {[regexp {^Query} $Ligne]} {continue} if {[regexp {^EMPTY} $Ligne]} { set Loc "vide" lappend LesLoc $Loc } else { set LesMots [split $Ligne "|"] set Chr [lindex $LesMots 0] set Strand [lindex $LesMots 1] set Start [lindex $LesMots 2] set Stop [lindex $LesMots 3] set Loc "${Chr}:${Start}:${Stop}:${Strand}" lappend LesLoc $Loc } } set LesLoc [ListeSansDoublon $LesLoc] foreach LaLoc $LesLoc { set LesMorceaux [split $LaLoc ":"] set Chr [lindex $LesMorceaux 0] set Deb [lindex $LesMorceaux 1] set Fin [lindex $LesMorceaux 2] set Sen [lindex $LesMorceaux 3] set LigneDef "$GnM1;$GnH1;$Chr;$Deb;$Fin;$Sen" lappend LesLignesDef $LigneDef } EspionneL "$LesLoc" file delete $FileBql file delete $FileRes } } } Espionne "$nb" Espionne "$vide" SauveLesLignes $LesLignesDef dans "/genomics/link/EVImm/Les1500AcHumanLoc" } proc LesRetChipAcCoordHumaines2 {} { set nb 0; set vide 0 foreach PAB [ListeDesPABs] { set Rc [ExtraitInfo $PAB "RetChip"] if {$Rc=="yes"} { incr nb set GnM1 [ExtraitInfo $PAB "ValiGN"] set GnH1 [HumanFromMouse $GnM1 Approved_Symbol] Espionne "" Espionne "$PAB $Rc" Espionne "Mouse $GnM1" Espionne "Human $GnH1" if {$GnH1!=""} { } } } } proc LesRetNetDeLaRegion {Chrom Debut Fin} { ##pour sortie voir InterrogeRetNet set Chrom [NumeroDuChromosome $Chrom] set LesRetNet {} foreach RetNet [lsort -unique [InterrogeRetNet LesRetNet]] { foreach LInfo [InterrogeRetNet RetNet $RetNet LesInfos ] { set Chromosome [lindex $LInfo 1] if {$Chromosome != $Chrom} {continue} set LesBornes [lindex $LInfo 2] set D [lindex $LesBornes 0] set F [lindex $LesBornes 1] if {![CesRegionsSontEllesOverlappantes $Debut $Fin $D $F]} {continue} lappend LesRetNet $LInfo } } return $LesRetNet } proc LesRetinalFate {} { set retinalfate 0; set LesGns {} set LesLignesExl [NomLigne ListeDes Lignes] set nblignesExl 0 foreach LigneExl $LesLignesExl { incr nblignesExl set ListeDesNoms {}; set BonneListeDesNoms {} set TousLesNoms [NomLigne $LigneExl Noms] set ListeDesNoms [split $TousLesNoms " "] set NbDeNomPrUneLigne [llength $ListeDesNoms] if {[llength $ListeDesNoms]==1} { set BonneListeDesNoms $ListeDesNoms } if {[llength $ListeDesNoms]>1} { set BonneListeDesNoms [split [RangeMoi get EviOf $LigneExl] " "] } foreach Nom $BonneListeDesNoms { set trouve 0 set Status [ExtraitInfo $Nom "Status"] set StatusCompOpt [string range $Status 0 [expr [string first "\(" $Status] - 1]] if {$StatusCompOpt=="optional"} {continue} set LesElmt [split $Status "\(\),"] foreach elmt $LesElmt { if {$elmt=="retinal_fate"} {set trouve 1} } if {!$trouve} {continue} set IdAccProt [ExtraitInfo $Nom "IdAccProt"] set LesProt [split $IdAccProt " "] set AccProt [lindex $LesProt 1] #Espionne "$LigneExl $BonneListeDesNoms" Espionne "$Nom $AccProt" } } } proc LesSamplesRetinobase {} { CanalSqlBioArrayBase set Ligne "e.pk_experiment,e.description,s.pk_sample,s.samplename,s.description_sample,s.noofreplicates" lappend LesLignes $Ligne foreach {PkEx DesEx PkSa NaSa DesSa ReplSa} [SqlExec "select distinct e.pk_experiment,e.description,s.pk_sample,s.samplename,s.description_sample,s.noofreplicates from retinobase3.experiment e,retinobase3.realexp r,retinobase3.sample s where e.pk_experiment=r.pk_experiment and r.pk_sample=s.pk_sample order by e.pk_experiment,s.pk_sample;" "GetList"] { set Ligne "$PkEx;$DesEx;$PkSa;$NaSa;$DesSa;$ReplSa" lappend LesLignes $Ligne } CanalSqlDisconnect EspionneL $LesLignes SauveLesLignes $LesLignes dans "/home/poidevin/ordi/Transcriptomique/LesSamplesRetinobase.csv" } proc LesScientistsDeDidier {} { foreach VE [VEDidier ListeDes VE] { set S [VEDidier $VE Scientist] if { ! [info exists NbVE($S)]} {set NbVE($S) 0 } incr NbVE($S) } set LesScientists [lsort [array names NbVE]] return $LesScientists } proc LesScoreImproved {} { global RepertoireDuGenome set RascalDir "$RepertoireDuGenome/msfrascal" set Destination "$RepertoireDuGenome/msfrascal/results.test" set LesRascal [glob -nocomplain "$RascalDir/*"] set ListeASauver "" set NbRascal 0 set NbRascalImproved 0 foreach msf $LesRascal { incr NbRascal foreach ligne [LesLignesDuFichier $msf] { #if {![regexp -nocase {[0-9]+} $ligne] && ![regexp -nocase {[a-z]+} $ligne]} {continue} if {[regexp "improved NorMD from" $ligne]} { set LigneMD [StringSuivant "improved NorMD from" dans $ligne] Espionne $LigneMD scan $LigneMD "%s %s %s" MDold to MDnew if {[expr $MDold<$MDnew]} { set LaLigne "[file tail $msf] $MDold $MDnew" lappend ListeASauver $LaLigne incr NbRascalImproved } } } } set PercentRascal [expr $NbRascalImproved/$NbRascal*100] lappend ListeASauver "NbRascal $NbRascal \nNbRascal improved $NbRascalImproved $PercentRascal %" return "[SauveLesLignes $ListeASauver dans $Destination]" } proc LesScoresMaxPourTousLesChromosomes {{NbVoisins 6}} { foreach Chro [ListeDesChromosomesHS] { set ScoreMax [ScoreMaxChro $Chro $NbVoisins] lappend Liste "$Chro $ScoreMax" } set ListeTriee [lsort -increasing -integer -index 1 $Liste] return $ListeTriee } proc LesSeqTFADesVariants {Access {AvecOuSansSeqIni Sans}} { #Entree : Access = Access ou Id d'une proteine # AvecOuSansSeqIni = "Avec" ou "Sans" la sequence initiale de l'id avec les variants #Sortie : Les seq TFA de tous les variants d'un access #La banque s'appellera VARSPLIC set NomBanque "VARSPLIC" #J'extrait la sequence TFA de l'access avec getz set SeqTFA [PageInfo $Access protein seq] #Si je ne trouve pas la seq, l'id n'existe donc pas (c'est quand meme bien fait getz) if {$SeqTFA == ""} {return} #Je transforme la sequence TFA en sequence lineaire (c'est plus fstoche a travailler) set SeqIni [QueLaSequenceDuTexteTFA $SeqTFA] set Length [string length $SeqIni] set LesSeqTFA {} #Appelle "LesSpliceVariants" qui retourne les infos de tous les variants sous la forme d'une liste de liste #Pour chacun de ces variants foreach UnVariant [LesSpliceVariantsDeLAccess $Access] { Espionne $UnVariant set IdDuVariant [lindex $UnVariant 0] set AccessDuVariant [lindex $UnVariant 1] set Definition [lindex $UnVariant 2] set Quoi [lindex $UnVariant 3] #Selon "AvecOuSansSeqIni" je garde ou j'elimine la sequence initiale if {$Quoi == "INITIAL"} { if {[string equal -nocase $AvecOuSansSeqIni "Sans"]} {continue} set Seq $SeqIni } else { #Si je suis sur un variant jessaie de reconstruire sa sequence a partir des informations extraites de la PageInfo ("LesSpliceVariantsDeLAccess") #Je decompose toutes les regions de la seq ini (c'est a dire les regions ou il ne se passe rien ; ou il y a un remplacement de sequence ; ou il y a une suppression de cette region set ToutesLesRegions {} foreach LeVSP [lrange $UnVariant 3 end] { set VSP [lindex $LeVSP 0] set D [lindex $LeVSP 1] set F [lindex $LeVSP 2] lappend ToutesLesRegions [list $D $F $Length] set Tab($D,$F) $LeVSP } foreach LaRegion [LesRegionsVidesDeLaListe $ToutesLesRegions $Length] {lappend ToutesLesRegions $LaRegion} set Seq "" #Je reconstruis ma sequence en traitant chaque region individuellement dans l'ordre ##WARNING ca ne peut pas marcher si les regions des variants sont overlappants (ce qui ne doit pas arriver) foreach LaRegion [lsort -index 0 -real $ToutesLesRegions] { set D [lindex $LaRegion 0] set F [lindex $LaRegion 1] if {![info exists Tab($D,$F)]} { append Seq [string range $SeqIni [expr $D-1] [expr $F-1]] continue } set LeVSP [set Tab($D,$F)] append Seq [lindex $LeVSP end] } } #Je rajoute la sequence au format TFA dans la liste a retourner avec comme entete : ">Banque:ID Access Description" lappend LesSeqTFA [SequenceFormatTFA $Seq "${NomBanque}:${IdDuVariant} ${AccessDuVariant} ${Definition}"] } #Je retourne toutes les seq TFA return $LesSeqTFA } proc LesSeqTFAsDesBanqueId {LesBanqueId Banque {Organism ""} {AvecFragment 1}} { ###Extraction des sequences tfa a partir des Id du blast### set Commande "[ProgPathway getz] \"" set i 0 set LesBID {} foreach BID [ElimineLesRedondancesDansUneListe $LesBanqueId] { regsub {^[^:]+:} $BID "" BID lappend LesBID [string toupper $BID] } if {$LesBID == {}} {return} set BID [join $LesBID "|"] regsub "\\\|" $BID "\|" BID append Commande "\\\[$Banque-id:$BID\\\]" if {!$AvecFragment} { append Commande " ! \\\[$Banque-des:\(fragment\)\\\]" } if {$Organism != ""} { append Commande " \& \\\[$Banque-org:$Organism\\\] \" -f seq -sf fasta" } else { append Commande "\" -f seq -sf fasta" } set SeqTFAs "" catch {set GetzOut [eval exec $Commande]} Message if {[info exists GetzOut] && $GetzOut != ""} {set SeqTFAs $GetzOut} set LesSeqTFAs {} set LaSeqTFAEnCours {} foreach Ligne [split $SeqTFAs "\n"] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {[regexp "^>" $Ligne]} { if {$LaSeqTFAEnCours != {}} {lappend LesSeqTFAs [join $LaSeqTFAEnCours "\n"]} set LaSeqTFAEnCours {} } lappend LaSeqTFAEnCours $Ligne } if {$LaSeqTFAEnCours != {}} {lappend LesSeqTFAs [join $LaSeqTFAEnCours "\n"]} foreach TFA $LesSeqTFAs { scan $TFA ">%s" BID set BID [string toupper $BID] set TabSeq($BID,SeqTFA) $TFA } set LesSeqTFAs {} foreach BID $LesBID { if {![info exists TabSeq($BID,SeqTFA)]} {continue} lappend LesSeqTFAs [set TabSeq($BID,SeqTFA)] } return $LesSeqTFAs } proc LesSeqTFAsDesBanqueId_old {LesBanqueId Banque {Organism ""} {AvecFragment 1}} { ###Extraction des sequences tfa a partir des Id du blast### set Commande "[ProgPathway getz] \"" set i 0 set LesBID [ElimineLesRedondancesDansUneListe $LesBanqueId] if {$LesBID == {}} {return} set BID [join $LesBID "|"] regsub "\\\|" $BID "\|" BID append Commande "\\\[$Banque-id:$BID\\\]" if {!$AvecFragment} { append Commande " ! \\\[$Banque-des:\(fragment\)\\\]" } if {$Organism != ""} { append Commande " \& \\\[$Banque-org:$Organism\\\] \" -f seq -sf fasta" } else { append Commande "\" -f seq -sf fasta" } set SeqTFAs "" catch {set GetzOut [eval exec $Commande]} Message if {[info exists GetzOut] && $GetzOut != ""} {set SeqTFAs $GetzOut} set LesSeqTFAs {} set LaSeqTFAEnCours {} foreach Ligne [split $SeqTFAs "\n"] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {[regexp "^>" $Ligne]} { if {$LaSeqTFAEnCours != {}} {lappend LesSeqTFAs [join $LaSeqTFAEnCours "\n"]} set LaSeqTFAEnCours {} } lappend LaSeqTFAEnCours $Ligne } if {$LaSeqTFAEnCours != {}} {lappend LesSeqTFAs [join $LaSeqTFAEnCours "\n"]} foreach TFA $LesSeqTFAs { scan $TFA ">%s" BId set TabSeq($BId,SeqTFA) $TFA } set LesSeqTFAs {} foreach BId $LesBanqueId { if {![info exists TabSeq($BId,SeqTFA)]} {continue} lappend LesSeqTFAs [set TabSeq($BId,SeqTFA)] } return $LesSeqTFAs } proc LesSeqTFAsDuBlast {FichierBlast Banque {Expect 1e200} {NbSubject 1e200} {Organism ""}} { set LesBId [LesBanqueIdDuBlast $FichierBlast $Expect $NbSubject] return [LesSeqTFAsDesBanqueId $LesBId $Banque $Organism] } proc LesSeqnamesDuCluster {c} { return [$::db eval {select sa.seqname from seqali as sa, ln_seqali_cluster as lsc where lsc.pk_cluster=$c and lsc.pk_seqali=sa.pk_seqali order by lsc.pos}] } proc LesSeqnamesDuMac {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select sa.seqname from seqali as sa, ln_mac_seqali as lms where lms.pk_mac=$m and lms.pk_seqali=sa.pk_seqali order by lms.pos}] } proc LesSeqsDesSeqsSel {} { set Ls {} if {[QuelMode] eq "seqlab"} { set LSeqs [$::NomTextSeq output all] } else { set LSeqs $::LSOrdali } foreach e $::NomSeqSel { lassign [split $e .] y x incr y -1 set seq [lindex $LSeqs $y] set tmp [string map [list "." "" " " ""] $seq] if {$tmp eq ""} {continue} lappend Ls $seq } return $Ls } proc LesSequencesDeLeveillard {Fichier FichierOut} { set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set UnGI "" scan $Ligne "%s" UnGI if {$UnGI==""} {continue} lappend LesGI $UnGI } close $F foreach GI $LesGI { set Sequence "" Espionne "$GI" set Sequence [string trim [NCBI $GI protein]] AppendAuFichier $FichierOut $Sequence } return "" } proc LesSequencesDesARPsManquantes {} { Wup "Permet de recuperer les sequences non presentes dans les alignements originaux" Wup "Cherche dans les blastPs" global AccessARP ChargeLesAccessDesARPsDejaPresents set RepBlastARP "[RepertoireDuGenome]/blastp" foreach PAB [ListeDesPABs] { set FichierBlastP "$RepBlastARP/$PAB" set NbEnPlus 0 set NbSubject [AskBlast $FichierBlastP NbSubject] for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlastP Subject $i] set Access [string toupper [AskBlast $FichierBlastP BanqueId $BId Access]] #Espionne "$BId $Access" if {[info exists AccessARP($Access)]} { continue } else { incr NbEnPlus lappend LesNouveauxAccess $Access set AccessARP($Access) 1 } } Espionne "$PAB en ajoute $NbEnPlus" #set Access [AskBlast $FichierBlastP BanqueId $BId Access] AskBlast unset } Espionne "Nombre d access [llength $LesNouveauxAccess]" Espionne "$LesNouveauxAccess" set LesAccessGetz [join $LesNouveauxAccess "|"] set Banques "protein" set option "-view FastaSeqs" set Typ1 "id" set Typ2 "acc" set Commande "getz $option \" (\\\[$Banques-$Typ1: $LesAccessGetz\\\] | \\\[$Banques-$Typ2: $LesAccessGetz\\\]) ! \\\[$Banques-des:fragment|fragments\\\]\"" catch {unset GetzOut} catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut]} {return ""} if {$GetzOut=={}} {return ""} set LesAccess "" regsub -all {\>protein\|} $GetzOut ">" GetzOut foreach Ligne [split $GetzOut "\n"] { if {[regexp ">" $Ligne]} { regsub {\|[A-Z0-9_]+ } $Ligne " " Ligne } lappend LesAccess $Ligne } #Espionne "[join $LesAccess "\n"]" AppendAuFichier $FichierSave "[join $LesAccess "\n"]" return "" } proc LesSequencesDesClassificationsEtOrganismesDuMacsims {Nom ListeDeSequences A} { set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml" set Liste {} ParseMACSIMS $Fichier macsims foreach Sequence $ListeDeSequences { if {$Sequence == "$Nom"} {continue} set Classification $macsims($Sequence,Classification) set Organisme $macsims($Sequence,Organisme) set TaxonomyComplete "$Classification $Organisme" if {[regexp -nocase $A $TaxonomyComplete]} { lappend Liste "$Sequence $Classification $Organisme" } } Espionne $Liste return $Liste } proc LesSequencesDesDomainesDeLaVieDuMacsims {Nom} { set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml" set Liste {} ParseMACSIMS $Fichier macsims set LesNomsSequences $macsims(Noms) foreach Sequence $LesNomsSequences { Espionne $Sequence set DomaineDeLaVie $macsims($Sequence,DomaineDeLaVie) lappend Liste "$Sequence $DomaineDeLaVie" } return $Liste } proc LesSequencesDesVariantsDeLaProteine {Access {Quoi Sequence}} { Wup "Permet de recuperer une liste de sequence au format fasta de tous les variants de splicing de Access" global TabVariant if {[info exists TabVariant($Access,$Quoi)]} { return "[set TabVariant($Access,$Quoi)]" } else { if {[info exists TabVariant]} {unset TabVariant} } set Banques "protein" set Link "varsplic" set Type [list "acc" "id"] set OnARien 0 foreach Typ $Type { set Commande "getz -e \"\\\[$Banques-$Typ: $Access\\\] > $Link \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$OnARien==0 && $GetzOut == ""} { set OnARien 0 continue } else { set OnARien 0 set OnEnAUn 0 set UneSeq "" set LesSequences [split $GetzOut "\n"] foreach Ligne $LesSequences { if {$Ligne==""} {continue} if {[string range $Ligne 0 0] != ">" && $OnEnAUn==1} {lappend UneSeq $Ligne} if {[string range $Ligne 0 0] == ">"} { if {$OnEnAUn=="1"} { set OnEnAUn 0 lappend TabVariant($Access,Sequence) [join $UneSeq "\n"] set UneSeq "" } lappend UneSeq $Ligne set OnEnAUn 1 continue } } break } } return "[LesVariantsDeLaProteine $Access $Quoi]" } proc LesSequencesDuFichier {Fichier Rep} { if {![file exists $Fichier]} {return ""} set Keep 0 if {[OuiOuNon "Would you want to keep the sequence in this directory?"]} {set Keep 1} set LesAccess [ElimineLesRedondancesDansUneListe [LesAccessDuFichier $Fichier]] set LesSequences {} foreach LAccess $LesAccess { set Access [lindex $LAccess 0] if {$Keep && [file exists "$Rep/${Access}.tfa"]} {continue} set Type [lindex $LAccess 1] Espionne "$Access\t$Type" set Sequence "" set Entete "$Access" if {$Type == "genembl"} { set Entete "$Access" set Sequence [SequenceAcNuc $Access] if {$Sequence == ""} { set Entete "$Access from NCBI" set Sequence [SequenceDuNCBI $Access nucleotide] } } if {$Type == "ncbi"} { set Entete "$Access from NCBI" set Sequence [SequenceDuNCBI $Access nucleotide] } if {$Type == "protein"} { set AccessmRNA [LemRNADeLAccessProt $Access] if {$AccessmRNA == ""} { Espionne "$Access does not have an Access of mRNA referenced" set LesAcNucs [LesAcNucsDeLaAccess $Access] if {$LesAcNucs != {}} {set AccessmRNA [lindex $LesAcNucs 0]} } set Entete "$AccessmRNA from $Access" set Sequence [SequenceAcNuc $AccessmRNA] if {$Sequence == ""} { set Entete "$AccessmRNA from NCBI from $Access" set Sequence [SequenceDuNCBI $AccessmRNA nucleotide] } } if {$Sequence == ""} {append Entete " not found"} set SeqTFA [SequenceFormatTFA $Sequence $Entete] Espionne "$SeqTFA" Sauve $SeqTFA dans "$Rep/${Access}.tfa" lappend LesSequences $SeqTFA } #Espionne "Nb Access theorique [llength $LesAccess]" return $LesSequences } proc LesSequencesDuGroupeMacsims {Nom {AvecOuSansOrganismeEtudie ""}} { set Fichier "[RepertoireDuGenome]/macsims/$Nom.xml" if {! [file exists $Fichier]} {return} ParseMACSIMS $Fichier macsims set SequencesDuGroupe $macsims(Groupe,$macsims($Nom,Groupe)) regsub "$Nom " $SequencesDuGroupe "" SequencesDuGroupe regsub "$Nom" $SequencesDuGroupe "" SequencesDuGroupe set SequencesDuGroupe "$Nom $SequencesDuGroupe" if {$AvecOuSansOrganismeEtudie == "Sans"} { set SequencesDuGroupeSansMonOrganisme [EnleveLaSequenceDeMonOrganisme $Nom $SequencesDuGroupe] return $SequencesDuGroupeSansMonOrganisme } return $SequencesDuGroupe } proc LesSequencesDuMac {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select sa.seq from seqali as sa, ln_mac_seqali as lms where lms.pk_mac=$m and lms.pk_seqali=sa.pk_seqali}] } proc LesSequencesDuMac_VOIR_PLUS_LOIN_1 {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select sa.seq from seqali as sa, cluster as c, ln_seqali_cluster as lsc, clustering as g where g.pk_mac=$m and g.pk_clustering=c.pk_clustering and c.pk_cluster=lsc.pk_cluster and lsc.pk_seqali=sa.pk_seqali}] } proc LesSequencesDuMac_VOIR_PLUS_LOIN_2 {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select sa.seq from seqali as sa, ln_mac_seqali as lms where lms.pk_mac=$m AND lms.pk_seqali=sa.pk_seqali order by lms.pos}] } proc LesSequencesInactives {} { set Lv [$::db eval {select pk_seqali from ln_vis_seqali where pk_vis=$pk_vis}] set La [$::db eval {select las.pk_seqali from ln_active_seqali as las, active as ac where ac.pk_vis=$pk_vis and ac.pk_active=las.pk_active order by las.pos}] set Li [lor $Lv $La] return [LesAccessDesSeqali $Li] } proc LesSequencesIssuesDeLaSequenceSplitee {FichierTFA {Liste ""}} { if {![file exists $FichierTFA]} { Espionne "No File for $Fichier" return "$Liste" } set RepTFA [file dirname $FichierTFA] set NomFichierTFA [file tail $FichierTFA] regsub ".tfa" $NomFichierTFA "" Id set EnteteTFA [PremiereLigneDuFichier $FichierTFA] if {[regexp "split into" $EnteteTFA]} { regsub ">$Id " $EnteteTFA "" EnteteTFA regsub "split into" $EnteteTFA "" EnteteTFA regsub "$Id" $EnteteTFA "" EnteteTFA while {[regexp "(TC\[0-9]*)" $EnteteTFA]} { regexp "(TC\[0-9]*)" $EnteteTFA tmp NewId regsub "$NewId" $EnteteTFA "" EnteteTFA set NewFichierTFA "$RepTFA/$NewId.tfa" set Liste [LesSequencesIssuesDeLaSequenceSplitee $NewFichierTFA $Liste] } } elseif {[regexp "found" $EnteteTFA] } { return $Liste } else { lappend Liste $Id } set Liste [ElimineLesRedondancesDansUneListe $Liste] return $Liste } proc LesSequencesSansProteineIdentifiee {} { #fichier=/fiches/ListeDesCourtsEtDesSansTriee #fichier regroupe les pabs qui sont courts (...) #et qui n'ont ni loc ni mrna ni prot ni est (voir plus bas) set Fichier "/genomics/link/HeadNecknonrnr/fiches/ListeDesCourtsEtDesSansTriee" set n 0 foreach Ligne [LesLignesDuFichier $Fichier] { set DD [lindex $Ligne 0] set Vu($DD) 1 incr n } #la liste des pabs contient 2469 pabs foreach PAB [ListeDesPABs] { if {![info exists Vu($PAB)]} { set FichierProttfa "/genomics/link/HeadNecknonrnr/prottfa/$PAB" if {![file exists $FichierProttfa] || ([file exists $FichierProttfa] && [regexp -nocase "from contig" [EnteteDuFichierTFA $FichierProttfa]])} { lappend Liste $PAB } } } #supprimer les jumeaux seq (au moins!) foreach Nom $Liste { if {[JumeauRepresentatif $Nom]==$Nom || [JumeauRepresentatif $Nom]==""} { lappend ListeSansJumeaux $Nom } } Espionne [llength $ListeSansJumeaux] SauveLesLignes $ListeSansJumeaux dans "/genomics/link/HeadNecknonrnr/fiches/ListeDesSansProtSansJumeaux" } proc LesSequences_UMCU {} { Wup "Permet de rechercher les sequences disponibles sur la puce UMCU a partir des access fournis par UMCU et SRS" Wup "Creation de 2 fichiers, un pour les Genbank et un pour les RefSeq" Wup "Il faut encore verifier la redondance des RefSeq (proc EnleveRedondanceRefSeq_UMCU)" #1 On recupere la liste des access de sequences disponibles sur la puce UMCU ############################################################################ #set LesAccess [InterrogeLesInfosUMCU "[RepertoireDuGenome]/UMCU-H25k11.txt" LesAccess] set LesRefSeq [InterrogeLesInfosUMCU "[RepertoireDuGenome]/UMCU-H25k11.txt" LesAccRefSeq] set LesGenbank [InterrogeLesInfosUMCU "[RepertoireDuGenome]/UMCU-H25k11.txt" LesAccGenbank] #2 On cherche les Genbank ######################### Espionne "Searching Genbank ... need to find [llength $LesGenbank] sequences." set FileGenbank "[RepertoireDuGenome]/UMCU_Genbank.tfa" if {[file exists $FileGenbank]} { Espionne "Genbank already done." } else { set NbFound 0 set size [expr [llength $LesGenbank] + 101] for {set i 0} {$i<$size} {incr i 100} { set LesAccessTmp "" set LesAcc "" set LesAccessTmp [lrange $LesGenbank $i [expr $i+99]] set LesAcc [join $LesAccessTmp "|"] #Espionne "$LesAcc" set Banques "genbank" set option "-view FastaSeqs" set Typ1 "acc" set Typ2 "id" set Commande "getz $option \"\\\[$Banques-$Typ1: $LesAcc\\\] | \\\[$Banques-$Typ2: $LesAcc\\\]\"" #Espionne "$Commande" catch {unset GetzOut} set GetzOut "" catch {set GetzOut [eval exec $Commande]} Message set NbFound_Tmp 0 set NbFound_Tmp [regexp -all ">" $GetzOut] set NbFound [expr $NbFound + $NbFound_Tmp] AppendAuFichier $FileGenbank "$GetzOut" #Espionne "$GetzOut" } Espionne "found $NbFound ... Genbank done." } #3 On cherche les RefSeq ######################## Espionne "Searching RefSeq ... need to find [llength $LesRefSeq] sequences." set FileRefSeq "[RepertoireDuGenome]/UMCU_RefSeq.tfa" if {[file exists $FileRefSeq]} { Espionne "RefSeq already done." } else { set NbFound 0 set size [expr [llength $LesRefSeq] + 101] for {set i 0} {$i<$size} {incr i 100} { set LesAccessTmp "" set LesAcc "" set LesAccessTmp [lrange $LesRefSeq $i [expr $i+99]] set LesAcc [join $LesAccessTmp "|"] set Banques "refseq" set option "-view FastaSeqs" set Typ1 "acc" set Typ2 "id" set Commande "getz $option \"\\\[$Banques-$Typ1: $LesAcc\\\] | \\\[$Banques-$Typ2: $LesAcc\\\]\"" #Espionne "$Commande" catch {unset GetzOut} set GetzOut "" if {[catch {set GetzOut [eval exec $Commande]} Message]} {Espionne "$Message"} set NbFound_Tmp 0 set NbFound_Tmp [regexp -all ">" $GetzOut] set NbFound [expr $NbFound + $NbFound_Tmp] AppendAuFichier $FileRefSeq "$GetzOut" #Espionne "$GetzOut" } Espionne "found $NbFound ... RefSeq done." } return "" } proc LesSeriesDeNResidues {NombreTotal NombreParSeries} { set NbSeries [expr int($NombreTotal * 1.0 / $NombreParSeries)] set Mod [expr $NombreTotal % $NombreParSeries] set LesSeries {} for {set i 0} {$i < $NbSeries} {incr i} { set D [expr $NombreParSeries * $i + 1] set F [expr $D + $NombreParSeries - 1 ] lappend LesSeries [list $D $F] } if {$Mod != 0} { set D [expr $NombreParSeries * $NbSeries + 1] set F [expr $D + $Mod - 1] lappend LesSeries [list $D $F] } return $LesSeries } proc LesServeursWscopeQuiTournent {{Genome ""}} { set PS [eval exec ps -ef] set Sortie {} foreach Ligne [split $PS "\n"] { if {[regexp "gscope ToujoursFaire $Genome" $Ligne]} { lappend Sortie $Ligne } } return $Sortie } proc LesSeuilsAC {{QueVeutOn ""}} { global LesSeuilsAC LesSeuilsACCoul LesSeuilsACSign if { ! [info exists LesSeuilsAC]} { set ACLaListe [AnchorsCount "LaListeMerci"] scan [MoyenneEcartMinMaxCumulLong $ACLaListe] "%f %f %d %d" Mo Ec Mi Ma lappend LesSeuilsAC [format "%4.1f" [Maxi 1.0 [expr $Mo-2*$Ec]]] lappend LesSeuilsAC [format "%4.1f" [Maxi 2.0 [expr $Mo-1*$Ec]]] lappend LesSeuilsAC [format "%4.1f" [expr $Mo+1*$Ec]] lappend LesSeuilsAC [format "%4.1f" [expr $Mo+2*$Ec]] lappend LesSeuilsACCoul "red" lappend LesSeuilsACCoul "orange" lappend LesSeuilsACCoul "yellow" lappend LesSeuilsACCoul "green" set i -1 lappend LesSeuilsACSign "AC verylow ( %AC < [lindex $LesSeuilsAC [incr i]])" lappend LesSeuilsACSign "AC low ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])" lappend LesSeuilsACSign "AC normal ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])" lappend LesSeuilsACSign "AC high ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])" lappend LesSeuilsACSign "AC veryhigh ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])" } if {$QueVeutOn=="CouleurMerci"} { return $LesSeuilsACCoul } if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsACSign } return $LesSeuilsAC } proc LesSeuilsCAI {{QueVeutOn ""}} { global LesSeuilsCAI LesSeuilsCAISign if { ! [info exists LesSeuilsCAI]} { set CAILaListe [CAI "LaListeMerci"] scan [MoyenneEcartMinMaxCumulLong $CAILaListe] "%f %f %d %d" Mo Ec Mi Ma lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-2*$Ec]] lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-1*$Ec]] lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+1*$Ec]] lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+2*$Ec]] set i -1 lappend LesSeuilsCAISign "CAI verylow ( CAI < [lindex $LesSeuilsCAI [incr i]])" lappend LesSeuilsCAISign "CAI low ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])" lappend LesSeuilsCAISign "CAI normal ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])" lappend LesSeuilsCAISign "CAI high ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])" lappend LesSeuilsCAISign "CAI veryhigh ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])" } if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsCAISign } return $LesSeuilsCAI } proc LesSeuilsGC {{QueVeutOn ""}} { global LesSeuilsGC LesSeuilsGCSign if { ! [info exists LesSeuilsGC]} { set GCLaListe [CompositionEn GC "LaListeMerci"] scan [MoyenneEcartMinMaxCumulLong $GCLaListe] "%f %f %d %d" Mo Ec Mi Ma lappend LesSeuilsGC [format "%4.1f" [expr $Mo-2*$Ec]] lappend LesSeuilsGC [format "%4.1f" [expr $Mo-1*$Ec]] lappend LesSeuilsGC [format "%4.1f" [expr $Mo+1*$Ec]] lappend LesSeuilsGC [format "%4.1f" [expr $Mo+2*$Ec]] set i -1 lappend LesSeuilsGCSign "GC skew verylow ( %GC < [lindex $LesSeuilsGC [incr i]])" lappend LesSeuilsGCSign "GC skew low ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])" lappend LesSeuilsGCSign "GC skew normal ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])" lappend LesSeuilsGCSign "GC skew high ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])" lappend LesSeuilsGCSign "GC skew veryhigh ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])" } if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsGCSign } return $LesSeuilsGC } proc LesSeuilsMDScore {{QueVeutOn SeuilMerci}} { global LesSeuilsMDScore LesSeuilsMDScoreSign LesSeuilsMDScoreCoul if { ! [info exists LesSeuilsMDScore]} { set LesSeuilsMDScore { -999.0 0.0 0.5 0.7 0.9 } set LesSeuilsMDScoreSign {"No value" "Problem" "Twilight zone" "Good" "Sure"} set LesSeuilsMDScoreCoul {"grey" "red" "orange" "yellow" "green"} } if {$QueVeutOn=="SeuilMerci"} { return $LesSeuilsMDScore } if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsMDScoreSign } if {$QueVeutOn=="CouleurMerci"} { return $LesSeuilsMDScoreCoul } } proc LesSeuilsOperonsHomologues {{QueVeutOn ""}} { global LesSeuilsOperonsHomologues LesSeuilsOperonsHomologuesSign if { ! [info exists LesSeuilsOperonsHomologues]} { # set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"] # scan [MoyenneEcartMinMaxCumulLong $OHLaListe] "%f %f %d %d" Mo Ec Mi Ma lappend LesSeuilsOH [format "%4.1f" 0.1] lappend LesSeuilsOH [format "%4.1f" 1.1] lappend LesSeuilsOH [format "%4.1f" 2.1] lappend LesSeuilsOH [format "%4.1f" 10.1] lappend LesSeuilsOH [format "%4.1f" 20.1] lappend LesSeuilsOHSign "ClusterMaintenance 0 == n" lappend LesSeuilsOHSign "ClusterMaintenance 1 == n" lappend LesSeuilsOHSign "ClusterMaintenance 2 <= n < 10" lappend LesSeuilsOHSign "ClusterMaintenance 10 < n <= 20" lappend LesSeuilsOHSign "ClusterMaintenance 20 < n" } if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsOHSign } return $LesSeuilsOH } proc LesSignaux {} { set FichierDesSignaux "[RepertoireDuGenome]/signaux/signaux.tfa" set LesSignaux [LesSignauxDuFichier $FichierDesSignaux] return $LesSignaux } proc LesSignauxDuFichier {FichierSignaux {aSequenceDuSignal ""} {aSequenceDuSignalPourPPCR ""}} { if {$aSequenceDuSignal !=""} { upvar $aSequenceDuSignal SequenceDuSignal } if {$aSequenceDuSignalPourPPCR!=""} { upvar $aSequenceDuSignalPourPPCR SequenceDuSignalPourPPCR } if {[info exists SequenceDuSignal]} { unset SequenceDuSignal } if {[info exists SequenceDuSignalPourPCR]} { unset SequenceDuSignalPourPCR } if {$FichierSignaux==""} { return {} } set LesSignaux {} foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $FichierSignaux] $FichierSignaux NF] { if {[regexp "^ *>" $Ligne]} { regsub -all ">" $Ligne " " Ligne scan $Ligne "%s" Signal regsub "_" $Signal "" Signal if {[info exists SequenceDuSignal($Signal)]} { if {[string equal -nocase [set SequenceDuSignal($Signal)] [Thrombin]]} { set Signal "ThrombinOld" } FaireLire "I found two times the same signal $Signal \n in $FichierSignaux" } lappend LesSignaux $Signal set SequenceDuSignal($Signal) "" set SequenceDuSignalPourPPCR($Signal) "" continue } regsub -nocase -all {[^a-z]} $Ligne "" Seq append SequenceDuSignal($Signal) $Seq append SequenceDuSignalPourPPCR($Signal) $Seq if {[string equal $Signal "ThrombinOld"] && ! [string equal [set SequenceDuSignalPourPPCR($Signal)] [ThrombinOld]]} { FaireLire "Problem with signal Thrombin in $FichierSignaux" } } if {[set i [lsearch -exact $LesSignaux "Thrombin"]] > -1 } { if {[string equal [set SequenceDuSignalPourPPCR(Thrombin)] [ThrombinOld]]} { set LesSignaux [lreplace $LesSignaux $i $i "ThrombinOld"] set SequenceDuSignal(ThrombinOld) [ThrombinOld] set SequenceDuSignalPourPPCR(ThrombinOld) [ThrombinOld] unset SequenceDuSignal(Thrombin) unset SequenceDuSignalPourPPCR(Thrombin) } } return $LesSignaux } proc LesSignificationsAssocieesAuxORFs {K} { global TypeCouleur set TypeDeCouleur [set TypeCouleur($K)] foreach Nom [ListeDesPABs] { set Couleur [CouleurParTypeEtNom $TypeDeCouleur $Nom $K] lappend LesNomSignif "$Nom [GetSignification $Couleur $K]" } set LesNomSignif [lsort -command CompareSansPremierChamp $LesNomSignif] return $LesNomSignif } proc LesSourcesDeGscope {{PathType ""} {AvecMain ""}} { if {$PathType=="" } { set PathType "Relatif" } if {$AvecMain=="" } { set AvecMain "AvecMain" } if {$AvecMain=="AvecMain" || $AvecMain=="WithMain"} { set AvecMain 1 } else { AvecMain 0 } set LesSourcesDeGscope {} set LesGscopeTcl {} if {$AvecMain} { lappend LesGscopeTcl "[GscopeDir]/gscope.tcl" } LConcat LesGscopeTcl [glob "[GscopeDir]/gscope_*.tcl"] foreach Fichier $LesGscopeTcl { if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Source "$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } foreach Fichier [glob "[GscopeContrib]/*/*.tcl"] { if {[regexp -nocase "ARanger" $Fichier]} { continue } if {[regexp -nocase "Poubelle/" $Fichier]} { continue } if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set ReperUsername [file dirname $Fichier] set Username [file tail $ReperUsername] set Reper [file dirname $ReperUsername] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Username/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Contrib [file tail $Reper] set Source "$Contrib/$Username/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } foreach Fichier [glob "[GscopeContrib]/*/*/*.tcl"] { if {[regexp -nocase "ARanger" $Fichier]} { continue } if {[regexp -nocase "Poubelle/" $Fichier]} { continue } if {[regexp "AllProcs_CGHviewer.tcl" $Fichier]} { continue } if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set ReperUsernameSub [file dirname $Fichier] set Sub [file tail $ReperUsernameSub] set ReperUsername [file dirname $ReperUsernameSub] set Username [file tail $ReperUsername] set Reper [file dirname $ReperUsername] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Username/$Sub/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Contrib [file tail $Reper] set Source "$Contrib/$Username/$Sub/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } foreach Fichier [glob "[GscopeEtc]/*"] { if {[regexp -nocase "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } if {[regexp "~$" $Fichier]} { continue } if {[regexp {.[0-9]{4,}$} $Fichier]} { continue } set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Etc [file tail $Reper] set Source "$Etc/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } #rR et Ordali set LesOrdaliTcl [glob "[GscopeDir]/ordali/src/ordali_*.tcl"] foreach Fichier $LesOrdaliTcl { if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Source "ordali/src/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } set LesOrdaliEtc [glob -nocomplain "[GscopeDir]/ordali/etc/*"] foreach Fichier $LesOrdaliEtc { if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Source "ordali/etc/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } set LesOrdaliDoc [glob -nocomplain "[GscopeDir]/ordali/doc/*"] foreach Fichier $LesOrdaliDoc { if {[regexp "obsolete" $Fichier]} { continue } if {[file isdirectory $Fichier]} { continue } set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Source "ordali/doc/$Queue" } else { set Source $Fichier } lappend LesSourcesDeGscope $Source } #rR Attention On a rajoute le / en fin de lib ... car il nous faut toute l'arborescence. set Fichier "[GscopeDir]/ordali/lib" set Queue [file tail $Fichier] set Reper [file dirname $Fichier] if {[regexp -nocase "Exact" $PathType]} { set Source $Fichier } elseif {[regexp -nocase "Absol" $PathType]} { set Source "$Reper/$Queue" } elseif {[regexp -nocase "Relat" $PathType]} { set Source "ordali/lib" } else { set Source $Fichier } lappend LesSourcesDeGscope "$Source/" ;#rR avec / return $LesSourcesDeGscope } proc LesSourcesDuProgramme {{PathType ""} {AvecMain ""}} { #rR Attention ici specifique Gscope return [LesSourcesDeGscope $PathType $AvecMain] } proc LesSousChamps {T {Champ ""}} { set Balise [ProchaineBalise T] if {$Champ!="" && ! [string equal -nocase $Balise $Champ]} { return {}} Espionne $Balise set LesValeurs {} set i 5 while 1 { if {[incr i -1]==0} { break } set Valeur [ValeurDeLaBalise $Balise T] if {$Valeur==""} { break } lappend LesValeurs $Valeur # Espionne [string range $Valeur 0 300] } return $LesValeurs } proc LesSpikePourExcel {} { Wup "Permet de creer le fichier excel des Spikes" set ListeSpike "CAB LTP4 LTP6 NAC1 PRKase RCP1 RCA TIM XCP2 rbcL" set Wdir1 "[RepertoireDuGenome]/Probes/Spike_Athaliana/Spike_RefSeq" set Wdir2 "[RepertoireDuGenome]/Probes/Spike_Athaliana/Spike_Unigene" LesOligosPourExcel "$ListeSpike" "$Wdir1" "$Wdir2" "" "" return "" } proc LesSpliceVariantsDeLAccess {Access} { #Entree : Access = Access ou Id d'une proteine #Sortie : Description de tous les variants dans une liste de liste #Appelle de la procedure LesSpliceVariantsDeLAccess_PageInfo dont l'Entree est une Page d'info de sptrembl ou swiss-prot return [LesSpliceVariantsDeLAccess_PageInfo [PageInfo $Access protein]] } proc LesSpliceVariantsDeLAccess_PageInfo {PageInfo} { #Entree : PageInfo = Page d'info de sptrembl ou swiss-prot #Sortie : Description de tous les variants dans une liste de liste if {$PageInfo == ""} {return} #Extraction de l'Id de la PageInfo set Id [BanqueIdDeLaProt_PageInfo $PageInfo] #Initiliasation des indicateurs de presence pour me reperer dans la PageInfo set SuisJeSurLesAlternativeProducts 0 set SuisJeSurLeComment 0 set AiJeRencontreUnVariant 0 #Les infos de chaque variant seront stockees dans une liste (LaDefinitionDUnVariant) elle-même stockée dans une liste (LesDefinitionsDesVariants) set LesDefinitionsDesVariants {} set LaDefinitionDUnVariant {} #Je parcours toutes les lignes de la PageInfo foreach Ligne [split $PageInfo "\n"] { #Tant que je ne trouve pas les Comment (CC) je passe (continue), à moins de l'avoir déjà rencontre alors je sors de la boucle if {![string equal -nocase [string range $Ligne 0 1] "CC"]} { if {$SuisJeSurLeComment} {break} continue } #J'enleve le champs de la ligne (CC) et les espaces aux extremites set Ligne [string trim [string range $Ligne 2 end]] #Je cherche la ligne contennant "-!- ALTERNATIVE PRODUCTS:" correspondant au debut de la description des variants if {[string range $Ligne 0 0] == "-"} { if {[string equal -nocase "-!- ALTERNATIVE PRODUCTS:" $Ligne]} { set SuisJeSurLesAlternativeProducts 1 continue } else { #Si j'ai deja vu "ALTERNATIVE PRODUCT:" je stoppe la boucle if {$SuisJeSurLesAlternativeProducts} {break} continue } } #je ne continue que si je suis sur les lignes de "ALTERNATIVE PRODUCTS" if {!$SuisJeSurLesAlternativeProducts} {continue} #Si "ALTERNATIVE PRODUCTS" possede un champs "Event=" et pas de champs "Name=" -> il n'est donc pas au bon format if {[string equal -nocase [string range $Ligne 0 5] "Event="]} { if {$AiJeRencontreUnVariant} {break} continue } #"ALTERNATIVE PRODUCTS" doit avoir une description complete avec le nom du variant "Name=" etc.. if {[string equal -nocase [string range $Ligne 0 4] "Name="]} { set AiJeRencontreUnVariant 1 if {$LaDefinitionDUnVariant != {}} { lappend LesDefinitionsDesVariants [join $LaDefinitionDUnVariant " "] set LaDefinitionDUnVariant {} } lappend LaDefinitionDUnVariant $Ligne continue } #Si je suis dans ALTERNATIVE PRODUCTS" mais que je n'ai toujours pas rencontre le nom des variants "Name=", cette ligne ne correspond donc pas a la definition d'un variant -> je continue sinon je rajoute l'info if {!$AiJeRencontreUnVariant} {continue} lappend LaDefinitionDUnVariant $Ligne } if {$LaDefinitionDUnVariant != {}} {lappend LesDefinitionsDesVariants [join $LaDefinitionDUnVariant " "]} set LesAccessDesVariants {} #Pour chaque definition de variant foreach DefinitionDUnVariant $LesDefinitionsDesVariants { #J'extraits l'Id de ce variant, si je ne le trouve pas je passe if {![regexp -nocase {IsoId\=([^\;]+)\;} $DefinitionDUnVariant tmp AccessDuVariant]} {continue} #J'extraits la description des sequences (VSP) a modifier pour ce variant, si je ne les trouve pas je passe if {![regexp -nocase {Sequence\=([^\;]+)\;} $DefinitionDUnVariant tmp VSPs]} {continue} #Je remplace le "-" de l'extension par un "_" regsub -all -nocase {[^0-9a-z]} $AccessDuVariant "_" AccessDuVariant set LesVSPs {} #Je forme la liste de tous les VSP (sequence a modifier) foreach VSP [split $VSPs ","] {lappend LesVSPs [string toupper [string trim $VSP]]} #Je stocke toutes ces infos dans un tableau afin de l'interroger apres lappend LesAccessDesVariants $AccessDuVariant set Tab($AccessDuVariant,Def) $DefinitionDUnVariant set Tab($AccessDuVariant,LesVSP) $LesVSPs } #Appelle de la procedure LesFeaturesDeLAccess_PageInfo qui retourne une liste de liste avec la description de toutes les features d'une PageInfo de protein dans un format "facilement" lisible foreach LaFeature [LesFeaturesDeLAccess_PageInfo $PageInfo] { #Je ne garde que les features des "VARSPLIC" set Type [lindex $LaFeature 1] if {$Type != "VARSPLIC"} {continue} #J'extraits le VSP de la description du VARSPLIC set Description [lindex $LaFeature 2] if {![regexp -nocase {FTId=([0-9a-z_]+)} $Description tmp UnVSP]} {continue} #J'extraits le ddebut et la fin set D [lindex $LaFeature 3] set F [lindex $LaFeature 4] if {$D == "" || $F == ""} {continue} #je stocke le tout dans un tableau set Tab(VSP,$UnVSP,D) $D set Tab(VSP,$UnVSP,F) $F #Si c'est une region a enlever "Missing" if {[regexp -nocase {^Missing} $Description]} { set Tab(VSP,$UnVSP,Info) "MISSING" continue } #Si c'est une region a remplacer "REPLACE" set Tab(VSP,$UnVSP,Info) "REPLACE" if {![regexp -nocase {[ a-z]+\->([ a-z]+)} $Description tmp NewArea]} {continue} regsub -all " " $NewArea "" NewArea set Tab(VSP,$UnVSP,NewArea) $NewArea } #Je vais maintenant pouvoir remplir la liste de liste qui sera retournee par le programme "LesVariants" set LesVariants {} #Pour chaque access de variants foreach AccessDuVariant $LesAccessDesVariants { #Je l'affiche Espionne $AccessDuVariant #J'extraits son extension ex P25513_10 -> 10 set Extension "" regexp {_([0-9]+)$} $AccessDuVariant tmp Extension if {$Extension == ""} {continue} #Je cree un Id unique pour chaque variant avec l'extension de l'access du variant set IdDuVariant "${Id}_${Extension}" #j'interroge le tableau pour qu'il me retourne la definition du variant set Definition [set Tab($AccessDuVariant,Def)] #Chaque element de "LesVariants" est une liste contennant les infos de chaque variant au format : #Index 0 : Id du variant #Index 1 : Acc du variant #Index 2 : Def du variant #Index 3 -> end : description de chaque variant (liste) avec les sequences a supprimer "MISSING" et a remplacer "REPLACE" au format : # Index 0 : le nom du VSP # Index 1 : le debut # Index 2 : la fin # Index 4 : Replace ou Missing # Index 5 : la sequence de remplacement set LeVariant [list $IdDuVariant $AccessDuVariant $Definition] foreach VSP [set Tab($AccessDuVariant,LesVSP)] { #si le VSP est une sequence exterieure (autre access) ou "Not described" je passe if {[string equal -nocase $VSP "External"] || [string equal -nocase $VSP "Not described"]} {break} #si le VSP est la sequence initiale je l'indique et je sors de la boucle car il ne dois pas contenir de VSP if {[string equal -nocase $VSP "DISPLAYED"]} { lappend LeVariant "INITIAL" break } set D [set Tab(VSP,$VSP,D)] set F [set Tab(VSP,$VSP,F)] set Info [set Tab(VSP,$VSP,Info)] set NewArea "" if {$Info != "MISSING"} {set NewArea [set Tab(VSP,$VSP,NewArea)]} #Je remplis les infos de chaque VSP lappend LeVariant [list $VSP $D $F $Info $NewArea] } lappend LesVariants $LeVariant } #Je retourne la liste de liste de tous mes variants return $LesVariants } proc LesStatsDesVariantsDansLesBanques {} { Wup "Comptabilise le nombre de proteines, le nombre de proteines avec des variants et le nombre de variants" set Access "*" set LesBanques [list "swissprot" "sptrembl" "protein"] set Link "varsplic" foreach Banques $LesBanques { set Typ1 "acc" set Typ1 "id" #Pour chaque banque on cherche le nombre total d entrees set Commande "getz -wc \"\\\[$Banques-$Typ1: $Access\\\] \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$GetzOut == ""} { set NbProt "No getz" Espionne "Nombre de prot dans $Banques $NbProt" } else { set NbProt "$GetzOut" Espionne "Nombre de prot dans $Banques $NbProt" } #Calcul du nombre de proteines avec au moins un variant set Commande "getz -wc \"\\\[$Banques-$Typ1: $Access\\\] > $Link > $Banques\"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {Espionne "$Message"} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le Nb de prot avec variant $NbVariant" } else { set NbVariant "$GetzOut" Espionne "Le Nb de prot avec variant $NbVariant" } #Calcul du nombre de variant pour les proteines set Commande "getz -vf des \"\\\[$Banques-$Typ1: $Access\\\] > $Link \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {Espionne "$Message"} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le nb de variant au total $NbVariant" } else { set NbVariant "[llength [split $GetzOut "\n"]]" Espionne "Le nb de variant au total $NbVariant" } #La meme chose pour seulement les proteines humaines Espionne "\nHuman" #Calcul du nombre de proteines avec au moins un variant set Commande "getz -wc \"\\\[$Banques-$Typ1: $Access\\\] & \\\[$Banques-org: Homo sapiens\\\] \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {Espionne "$Message"} if {$GetzOut == ""} { set NbProt "No getz" Espionne "Nombre de prot dans $Banques $NbProt" } else { set NbProt "$GetzOut" Espionne "Nombre de prot dans $Banques $NbProt" } #Calcul du nombre de proteines avec au moins un variant set Commande "getz -wc \"(\\\[$Banques-$Typ1: $Access\\\] & \\\[$Banques-org: Homo sapiens\\\]) > $Link > $Banques\"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {Espionne "$Message"} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le Nb de prot avec variant $NbVariant" } else { set NbVariant "$GetzOut" Espionne "Le Nb de prot avec variant $NbVariant" } #Calcul du nombre de variant pour les proteines set Commande "getz -vf des \"(\\\[$Banques-$Typ1: $Access\\\] & \\\[$Banques-org: Homo sapiens\\\])> $Link \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le nb de variant au total $NbVariant" } else { set NbVariant "[llength [split $GetzOut "\n"]]" Espionne "Le nb de variant au total $NbVariant" } } return "" } proc LesStatsDesVariantsDeTous {} { Wup "Permet de savoir pour tous les Access le nombre de variant" Wup "Attention il faut compter plus 1 car lui n est pas avec dans varsplic" global MesAccessInterressants set Liste [ListeDesPABs] set MesAcc "" foreach PAB $Liste { set AccProt "" set Id "" set AccProt [AccessDeLaBoite $PAB protein] if {$AccProt == $PAB} {continue} lappend MesAcc $AccProt continue } set MesAcc [lsort -unique $MesAcc] #Espionne $MesAcc Espionne "Les PABs [llength $MesAcc]" MesAccessInterressants set LesAcc [array names MesAccessInterressants] foreach Acc $LesAcc {lappend MesAcc $Acc} #Espionne $MesAcc Espionne "Les acc en + [llength $MesAcc]" set NbProtAvecV 0 set NbVariantTot 0 set Access [join $MesAcc "|"] set Link "varsplic" set Type [list "acc" "id"] set LesBanques [list "swissprot" "sptrembl" "protein"] foreach Banques $LesBanques { set Typ1 "acc" set Typ2 "id" set Commande "getz -wc \"\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\] \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$GetzOut == ""} { set NbProt "No getz" Espionne "Nombre de prot dans $Banques $NbProt" } else { set NbProt "$GetzOut" Espionne "Nombre de prot dans $Banques $NbProt" } set Commande "getz -wc \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\]) > $Link > $Banques\"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le Nb de prot avec variant $NbVariant" } else { set NbVariant "$GetzOut" Espionne "Le Nb de prot avec variant $NbVariant" set Commande "getz -vf des \"(\\\[$Banques-$Typ1: $Access\\\] | \\\[$Banques-$Typ2: $Access\\\]) > $Link \"" catch {set GetzOut [eval exec $Commande]} Message if {! [info exists GetzOut]} {continue} if {$GetzOut == ""} { set NbVariant "No Getz" Espionne "Le nb de variant au total $NbVariant" continue } else { set OnARien 1 set NbVariant "[llength [split $GetzOut "\n"]]" Espionne "Le nb de variant au total $NbVariant" } } } return "" } proc LesStructuresDeActin {Position} { global ActinStruct if {! [info exists ActinStruct]} { set Struct "---------BBBBB---BBBBBB-------BBBB--BBB---HHHHHH------BB-HHHHH-B--BBBB----------HHHHHHHHHHHHH------HHH--BBBBB-----HHHHHHHHHHHHH-----BBBBBBHHHHHHHH-----BBBBBB----BBBBBBB--BB-HHH-BBB---HHHHHHHHHHHHH--------HHHHHHHHHHHHHH------HHHHHHHH-------BBBB-----BBBB--HHHHHHH----HHHH------HHHHHHHHH----HHHHHHHH--BBBB-HHH----HHHHHHHHHHHH--------BB----HHHHHHHHHHHHH--HHHHHH-BBHHHHHHH-HHHH-----" set i 1 foreach AA [split $Struct ""] { set ActinStruct($i,Struct) $AA incr i } } if {! [info exists ActinStruct($Position,Struct)]} {return ""} return "[set ActinStruct($Position,Struct)]" } proc LesSubKeywordsInteressantsDuGenbank {TexteOuFichier aTab KW args} { if {[regexp "\n" $TexteOuFichier]} { set Texte $TexteOuFichier } else { set Texte [ContenuDuFichier $TexteOuFichier] } set Texte [LesKeywordsInteressantsDuGenbank $Texte Bidon $KW] upvar $aTab Tab set LesSKW $args foreach SKW $LesSKW { set Tab($SKW) "" } foreach Ligne [split $Texte "\n"] { if { ! [regexp {^ } $Ligne]} { scan $Ligne "%s" SKW set Interessant [expr [lsearch $LesSKW $SKW] > -1] if {$Interessant} {set Tab($SKW) "" ; set Sep ""} } if {$Interessant} { append Tab($SKW) "$Sep$Ligne" set Sep "\n" } } if {[llength $LesSKW]==1} { return $Tab([lindex $LesSKW 0]) } return $LesSKW } proc LesSubjectsDuBlast {FichierBlast {LesBanquesId All}} { if {![file exists $FichierBlast]} { Espionne "$FichierBlast does not exist" return "" } set F [open $FichierBlast] set LesSubjects {} set UnSubject "" set SuisJeSurUnSubject 0 while {[gets $F Ligne]>=0} { if {!$SuisJeSurUnSubject && [string first ">" $Ligne] != 0} {continue} if { $SuisJeSurUnSubject && [regexp " Database:" $Ligne]} { set SuisJeSurUnSubject 0 break } if { $SuisJeSurUnSubject && [string first ">" $Ligne] != 0} { append UnSubject "\n$Ligne" continue } if {[string first ">" $Ligne] == 0} { if {$SuisJeSurUnSubject} { if {$LesBanquesId == "All"} { lappend LesSubjects $UnSubject } else { set TabTmp($BanqueId) $UnSubject } set UnSubject "" set SuisJeSurUnSubject 0 } if {[info exists BanqueId]} {unset BanqueId} scan $Ligne "%s" BanqueId regsub ">" $BanqueId "" BanqueId if {$LesBanquesId == "All"} { set SuisJeSurUnSubject 1 } else { foreach BId $LesBanquesId { if {[string equal -nocase $BanqueId $BId]} {set SuisJeSurUnSubject 1;break} } } if {$SuisJeSurUnSubject} {set UnSubject $Ligne} } } close $F if {$UnSubject != ""} { if {$LesBanquesId == "All"} { lappend LesSubjects $UnSubject } else { set TabTmp($BanqueId) $UnSubject } } if {$LesBanquesId != "All"} { foreach BId $LesBanquesId { if {![info exists TabTmp($BId)]} {lappend LesSubjects "";continue} lappend LesSubjects [set TabTmp($BId)] } } if {[info exists TabTmp]} {unset TabTmp} return $LesSubjects } proc LesSujetsAvecOligos {} { set LesSujetsAvecOligos {} foreach P [Oli "LaListeMerci"] { foreach Sujet [Oli $P Subjects] { lappend LesSujetsAvecOligos [format "%-20s %s" $Sujet $P] } } return $LesSujetsAvecOligos } proc LesSujetsDansLeBonOrdre {LesSujets} { set LesBeauxSujets {} foreach Sujet $LesSujets { set LesMots [split $Sujet "-"] set F [lindex $LesMots end] set D [lindex $LesMots end-1] set BeauSujet $Sujet if {[regexp {^[0-9]+$} $D] && [regexp {^[0-9]+$} $F]} { set Reste [join [lrange $LesMots 0 end-2] "-"] set BeauSujet [format "%s\-%5.5d\-%5.5d" $Reste $D $F] } lappend LesBeauxSujets $BeauSujet set MonSujet($BeauSujet) $Sujet } set LesBeauxTries [lsort $LesBeauxSujets] set LesTries {} foreach BeauSujet $LesBeauxTries { lappend LesTries [set MonSujet($BeauSujet)] } return $LesTries } proc LesSujetsDeLOligo_NOT_YET_USED {P {Action ""} {Valeur ""}} { if {$Action==""} { set Action "get" } set FiSujOl [FiSujOl $P] if {$Action=="get"} { if {$Valeur=="filename"} { return $FiSujOl } if {[file exists $FiSujOl]} { return [LesLignesDuFichier $FiSujOl] } else { return {} } } if {$Action=="set"} { return [SauveLesLignes $Valeur dans $FiSujOl] } if {$Action=="append"} { set LesSujets [LesSujetsDeLOligo $P] if {[lsearch $LesSujets -exact $Valeur]<0} { lappend LesSujets $Valeur } SauveLesLignes $Valeur dans $FiSujOl return $LesSujets } } proc LesTAFs {} { foreach F [glob "*.nuctfa"] { regsub ".nuctfa" $F "-protein.blastx" B set Sequence [QueLaSequenceDuFichierTFA $F] Blaste "X" $Sequence $B "/catalog/blast/protein" } exit foreach D [glob "*.dna"] { regsub ".dna" $D "" T if {[regexp "ec" $T]} { set Entete "$T $T Encephalitozoon cuniculi Tbp Associated Factor" } if {[regexp "y" $T]} { set Entete "$T $T Saccharomyces cerevisiae Tbp Associated Factor" } if {[regexp "h" $T]} { set Entete "$T $T Homo sapiens Tbp Associated Factor" } set TFA [SequenceFormatTFA [ContenuDuFichier $D] $Entete "gcg"] Sauve $TFA dans "$T.nuctfa" } exit } proc LesTFADeLaProteine {{LesNoms ""}} { if {$LesNoms==""} {set LesNoms [ListeDesPABs]} set RepProtTFA "[RepertoireDuGenome]/prottfa" if {![file exists $RepProtTFA]} {File mkdir $RepProtTFA} foreach Nom $LesNoms { set FichierProtTFA "$RepProtTFA/$Nom" if {[file exists $FichierProtTFA]} {continue} set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set Organism [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] set Entete "$Nom PROTEIN $AccessProt from $Organism" #Espionne $Entete set SeqProt [QueLaSequenceDuTexteTFA [PageInfo $AccessProt protein seq]] #Espionne $SeqProt if {$SeqProt==""} {Espionne "$Nom no seq";continue} set SeqTFA [SequenceFormatTFA $SeqProt $Entete] Sauve $SeqTFA dans $FichierProtTFA } } proc LesTFADuFileTFAs {FichierTFAs} { return [LesTFADuTFAs [File2Text $FichierTFAs]] } proc LesTFADuTFAs {TFAs} { set LesTFA {} foreach TFA [split $TFAs ">"] { set TFA [string trim $TFA] if {$TFA == ""} {continue} set TFA ">$TFA" lappend LesTFA $TFA } return $LesTFA } proc LesTFAsDesHitsDuBallast {FichierAnchors {NbHitsMax 200} {NbPDBMax 30} {AvecFragment 0}} { if {![file exists $FichierAnchors]} {return} AskAnchors unset set IdDeRef [AskAnchors $FichierAnchors IdDeRef] set LesHits [list [list $IdDeRef 1e200]] foreach Id [AskAnchors $FichierAnchors LesId ] { set n [AskAnchors $FichierAnchors Id $Id NbLMS] lappend LesHits [list $Id $n] } set NbRequestInDBMax [expr ($NbHitsMax + $NbPDBMax) * 2] set NbRequestInDB 0 set LesBanqueId {} foreach LeHit [lsort -index 1 -decreasing -real $LesHits] { if {$NbRequestInDBMax <= $NbRequestInDB} {break} set BanqueId [lindex $LeHit 0 ] if {[info exists TabDejaVu($BanqueId)]} {continue} set TabDejaVu($BanqueId) 1 if {[regexp -nocase "UniRef" $BanqueId]} { Espionne $BanqueId regexp -nocase {UniRef[0-9]*} $BanqueId BanqueUniref set BanqueUniref [string tolower $BanqueUniref] set TFA [TFADeLaBanqueBlast "/blast/$BanqueUniref" $BanqueId] if {$TFA == ""} {continue} regsub -nocase {>[^ ]+} $TFA ">$BanqueId" TFA set TabTmp($BanqueId) $TFA incr NbRequestInDB continue } if {[EstUnAccessPDB $BanqueId]} { set TFA [TFADeLaBanqueBlast "/blast/pdb" $BanqueId] if {$TFA == ""} {continue} regsub -nocase {>[^ ]+} $TFA ">$BanqueId" TFA set TabTmp($BanqueId) $TFA incr NbRequestInDB continue } if {[EstUnAccessVARSPLIC $BanqueId]} { set TFA [TFADeLaBanqueBlast "/blast/varsplic" "VARSPLIC:$BanqueId"] if {$TFA == ""} {continue} regsub -nocase {>[^ ]+} $TFA ">$BanqueId" TFA set TabTmp($BanqueId) $TFA incr NbRequestInDB continue } incr NbRequestInDB lappend LesBanqueId $BanqueId } foreach TFA [LesSeqTFAsDesBanqueId $LesBanqueId "protein" "" $AvecFragment] { set TFA [string toupper $TFA] scan [EnteteDuTexteTFA $TFA] ">%s" BId if {$BId == ""} {continue} set BId [string toupper $BId] set TabTmp($BId) $TFA } set NbPDB 0 set NbHits 0 set LesTFAs {} foreach LeHit $LesHits { set BanqueId [string toupper [lindex $LeHit 0 ]] if {![info exists TabTmp($BanqueId)]} {continue} if {[EstUnAccessPDB $BanqueId]} { incr NbPDB if {$NbPDBMax < $NbPDB } {continue} } else { incr NbHits if {$NbHitsMax < $NbHits} {continue} } lappend LesTFAs [set TabTmp($BanqueId)] } AskAnchors unset return $LesTFAs } proc LesTFAsDesHitsDuBlastP {FichierBlast {NbHitsMax 200} {NbPDBMax 30} {AvecFragment 0}} { set NbRequestInDBMax [expr ($NbHitsMax + $NbPDBMax) * 2] set NbRequestInDB 0 set LesHits [LesBanqueIdDuBlast $FichierBlast 1e200 1e200] set LesBanqueId {} foreach BanqueId $LesHits { set BanqueId [string toupper $BanqueId] if {$NbRequestInDBMax <= $NbRequestInDB} {break} if {[EstUnAccessPDB $BanqueId]} { set TFA [TFADeLaBanqueBlast "/blast/pdb" $BanqueId] if {$TFA == ""} {continue} regsub -nocase {>[^ ]+} $TFA ">$BanqueId" TFA set TabTmp($BanqueId) $TFA incr NbRequestInDB continue } if {[regexp {\-[0-9]+$} $BanqueId]} { set TFA [TFADeLaBanqueBlast "/blast/varsplic" "VARSPLIC:$BanqueId"] if {$TFA == ""} {continue} regsub -nocase {>[^ ]+} $TFA ">$BanqueId" TFA set TabTmp($BanqueId) $TFA incr NbRequestInDB continue } incr NbRequestInDB lappend LesBanqueId $BanqueId } foreach TFA [LesSeqTFAsDesBanqueId $LesBanqueId "protein" "" $AvecFragment] { set TFA [string toupper $TFA] scan [EnteteDuTexteTFA $TFA] ">%s" BId if {$BId == ""} {continue} set BId [string toupper $BId] set TabTmp($BId) $TFA } set NbPDB 0 set NbHits 0 set LesTFAs {} foreach BanqueId $LesHits { set BanqueId [string toupper $BanqueId] if {![info exists TabTmp($BanqueId)]} {continue} if {[EstUnAccessPDB $BanqueId]} { incr NbPDB if {$NbPDBMax < $NbPDB } {continue} } else { incr NbHits if {$NbHitsMax < $NbHits} {continue} } lappend LesTFAs [set TabTmp($BanqueId)] } return $LesTFAs } proc LesTFAsDesRSFsDesARPs {{LesFichierRSF ""}} { Wup "Permet d extraire au format TFAs les sequences presentes dans les alignement au format .RSF" Wup "Utilisation pour generer les fichiers tfa pour ensuite creer les banques blasts" Wup "voir proc LesBanquesBLASTDesARPs" set RepARP "[RepARPAnno]" set RepTFA "$RepARP/ARP_TFA" set RepBanque "$RepARP/ARP_BLAST" set RepMACS "$RepARP/ARP_MACS" set RepSignature "$RepARP/ARP_Signature" set RepARP_Results "[RepARPAnnoWeb]" set RepTFAResults "$RepARP_Results" set RepBlastResults "$RepARP_Results" set RepMACSResults "$RepARP_Results" set ClustalW "clustalw" set ClustalOut "" if {$LesFichierRSF == ""} { set LesFichierRSF [glob -nocomplain -directory "$RepMACS/" "*.rsf"] #set LesFichierRSF "/genomics/g1/ARP/alignement_ARP/ARPAnno/ARP_MACS/Actin.rsf" #set LesFichierRSF "/genomics/g1/ARP/alignement_ARP/ARPAnno/ARP_MACS/Orphans.rsf" } else { foreach F $LesFichierRSF { if {! [file exists $F]} { return "" } } } foreach RSF $LesFichierRSF { if {[regexp "Modele" $RSF]} {continue} Espionne "$RSF" set FichierTFA "" set FichierDND "" regsub {.rsf$} $RSF ".tfa" FichierTFA #regsub {.rsf$} $RSF ".fasta" FichierTFA regsub {.rsf$} $RSF ".dnd" FichierDND if {[file exists $FichierTFA]} {file delete -force $FichierTFA} set Commande "$ClustalW $RSF -convert -output=FASTA" catch { unset ClustalOut} if {[catch {set ClustalOut [eval exec $Commande]} Message]} { Espionne ">>>>Pb with clustal converting [file tail $RSF] to FASTA:\n$Message" if {[file exists $FichierDND]} {file delete -force $FichierDND} } if {![info exists ClustalOut]} {continue} if {$ClustalOut == ""} {continue} if {[file exists $FichierDND]} {file delete -force $FichierDND} lappend LesFichiersTFA $FichierTFA } foreach TFA $LesFichiersTFA { set Tmp "${TFA}_tmp" set Sequence "" Espionne "$Tmp" set OnAEntete "0" set F [open "$TFA"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {[regexp "^>" $Ligne]} { set OnAEntete 1 if {$Sequence!=""} { regsub -all {\-} $Sequence "" Sequence #Espionne "Saving: $Sequence" AppendAuFichier $Tmp $Sequence } if {! [regexp -nocase actin "$TFA"] && [regexp -nocase "p02568" $Ligne]} {set OnAEntete 0;continue} AppendAuFichier $Tmp $Ligne set Sequence "" continue } else { if {$OnAEntete=="0"} {continue} #Espionne "$Sequence" append Sequence [join $Ligne ""] } } close $F if {$Sequence!=""} { regsub -all {\-} $Sequence "" Sequence AppendAuFichier $Tmp $Sequence } file copy -force $Tmp $TFA if {[regexp {.fasta$} $TFA]} { set NewFile "" regsub {.fasta$} $TFA ".tfa" NewFile file rename -force $TFA $NewFile file delete -force $TFA Espionne "$NewFile" } file delete -force $Tmp } return "" } proc LesTailleDesInsertions_article {Dir FichierMACS} { set LesFamilleARPs [LesFamillesDARPs] foreach Famille $LesFamilleARPs { if {! [regexp "^ARP" $Famille]} {continue} TailleDesInsertions_article $Dir $Famille $FichierMACS } return "" } proc LesTaxIdDeOdile {} { foreach Ligne [LesLignesDuFichier "[BlomeDir]/TTLL.csv"] { if { ! [regexp {[0-9]+} $Ligne OX]} { continue } if {[OiCode $OX OI]==""} { lappend LesPerdus "perdu $OX [Tax $OX Name]" } Espionne "$OX [Tax $OX Name]" } return $LesPerdus } proc LesTaxIdDesGenomesComplets {} { set LesRepAvecFichier {} set LesRepAvecTaxId {} foreach FiGBK [concat [glob -nocomplain "/genome/*/*.ref"] [glob -nocomplain "/genome/*/*.gbk"]] { Espionne $FiGBK set Rep [file tail [file dirname $FiGBK]] if {$Rep=="Archaea" || $Rep=="Bacteria" || $Rep=="H.sapiens" || $Rep=="YeastGenome"} { continue } lappend LesRepAvecFichier $Rep set TaxId "" if { ! [info exists LesTaxIdDuRep($Rep)]} { set LesTaxIdDuRep($Rep) {} } foreach Ligne [LesLignesIaJDuFichier $FiGBK 1 1000] { if { ! [regexp {/db_xref=\"taxon\:} $Ligne]} { continue } set TaxId [IntegerApres "taxon\:" dans $Ligne] if {$TaxId==""} { continue } set TaxId [BetterTaxId $TaxId] set Organisme [Tax $TaxId] lappend LesTaxIdDuFichierRef($FiGBK) $TaxId if {[info exists FichierDuRep($Rep,$TaxId)]} { lappend FichierDuRep($Rep,$TaxId) $FiGBK ; continue } lappend LesRepAvecTaxId $Rep lappend FichierDuRep($Rep,$TaxId) $FiGBK lappend LesTaxIdDuRep($Rep) $TaxId break } } foreach FiGBK [array names LesTaxIdDuFichierRef] { set LesT [set LesTaxIdDuFichierRef($FiGBK)] if {[llength LesT]>1} { FaireLire "I found more than 1 TaxId for $FiGBK\n[join $LesT " "]" } set LesTaxIdDuFichierRef($FiGBK) [lsort -u [set LesTaxIdDuFichierRef($FiGBK)]] Espionne [SauveLesLignes [array get LesTaxIdDuFichierRef] dans "/genomics/link/Common/fiches/taxid_du_fichierref"] } foreach Rep [lsort -unique $LesRepAvecFichier] { if {[set LesTaxIdDuRep($Rep)]=={}} { lappend LesPauvres "Rep sans TaxId $Rep" Espionne "Rep sans TaxId $Rep" } } foreach Rep [lsort -unique $LesRepAvecTaxId] { if {[llength [set LesTaxIdDuRep($Rep)]]==1} { set TaxId [lindex [set LesTaxIdDuRep($Rep)] 0] lappend LesBons "\n$Rep $TaxId [Tax $TaxId]" continue } lappend LesMultis "\n$Rep [join [set LesTaxIdDuRep($Rep)] " "]" foreach TaxId [set LesTaxIdDuRep($Rep)] { lappend LesMultis " $TaxId [Tax $TaxId]" lappend LesMultis [join [set FichierDuRep($Rep,$TaxId)] "\n"] } } Espionne [SauveLesLignes $LesBons dans "/genomics/link/Common/fiches/les_genomes_un_taxid"] Espionne [SauveLesLignes $LesPauvres dans "/genomics/link/Common/fiches/les_genomes_sans_taxid"] Espionne [SauveLesLignes $LesMultis dans "/genomics/link/Common/fiches/les_genomes_multi_taxid"] exit } proc LesTissueOuStrainDeLaProt {Access {Quoi TISSUE}} { return [LesTissueOuStrainDeLaProt_PageInfo [PageInfo $Access protein] $Quoi] } proc LesTissueOuStrainDeLaProt_PageInfo {PageInfo {Quoi TISSUE}} { set Champs "RC" set LesTissues {} foreach RC [LeChampsDeLaPageProteine $PageInfo "$Champs"] { if {![regexp -nocase "$Quoi=" $RC]} {continue} set i [string first "$Quoi=" $RC] set RC [string range $RC [expr $i+7] end] set j [string first ";" $RC] set RC [string range $RC 0 [expr $j-1]] regsub -all " and " $RC " " RC regsub -all ", " $RC "," RC set LeRC [split $RC ","] foreach Tissue $LeRC { if {$Tissue == ""} {continue} lappend LesTissues $Tissue } } return [ElimineLesRedondancesDansUneListe $LesTissues] } proc LesTissueType {Nom FichierBlastEST {AllOrgaouJustMyOrga AllOrga} {IdDeRef 0.95}} { if {![file exists $FichierBlastEST]} {return [list "$Nom\tNoESTFound"]} set NbSubject [AskBlast $FichierBlastEST NbSubject] if {$NbSubject == ""} {return [list "$Nom\tNoESTFound"]} set OrgaDeRef [OrganismeDuPAB $Nom] set LesBId {} for {set i 1} {$i <= $NbSubject} {incr i} { set BId [AskBlast $FichierBlastEST Subject $i] set PAlignees [PourcentageDesBasesAligneesSurToutesLesBasesAlignables $FichierBlastEST $BId] if {$PAlignees < $IdDeRef} {continue} set PAlignables [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables $FichierBlastEST $BId] if {$PAlignables < $IdDeRef} {continue} Espionne $BId lappend LesBId $BId } AskLesPagesInfos load $LesBId est set LeTexte {} foreach BId $LesBId { set Page [AskLesPagesInfos ask $BId] if {$Page == ""} {continue} set Access [AskBlast $FichierBlastEST BanqueId $BId Access] set LesOrgas [LesOrgasDeLaPage_PageInfo $Page] if {$AllOrgaouJustMyOrga != "AllOrga"} { set EstCeUnDesOrga 0 foreach Orga $LesOrgas { if {[string equal -nocase $Orga $OrgaDeRef]} {set EstCeUnDesOrga 1;break} } if {!$EstCeUnDesOrga} {continue} } set LesTissues [LesTissuesDeLAcNuc_PageInfo $Page] if {$LesTissues == {}} {continue} foreach Tissue $LesTissues { foreach Orga $LesOrgas { set Info "$Nom\t$Access\t$Orga\t$Tissue" lappend LeTexte $Info } } } AskBlast unset AskLesPagesInfos unset if {$LeTexte == {}} {return [list "$Nom\tNoESTFound"]} return $LeTexte } proc LesTissueTypeDesTests {} { set FichierEST "[RepertoireDuGenome]/fiches/SelectedEST" foreach PAB [ListeTest] { set LesTissues [lsort -unique [InterrogeSelectedEST $FichierEST Nom $PAB LesTissueType]] foreach T $LesTissues { if {[regexp {skeletal|muscle|epithelial|mcf7} $T]} { Espionne "$PAB $T" } } } return "" } proc LesTissuesDeLAcNuc {Access {Banque genbankfull}} { return [LesTissuesDeLAcNuc_PageInfo [PageInfo $Access $Banque]] } proc LesTissuesDeLAcNuc_PageInfo {PageInfo} { set LAiJeVu 0 set Infos "" foreach Ligne [split $PageInfo "\n"] { if {!$LAiJeVu && [regexp -nocase "tissue_type=" $Ligne]} { regsub -nocase " source " $Ligne "" Ligne append Infos " $Ligne" set LAiJeVu 1 continue } if {$LAiJeVu && [regexp -nocase "BASE COUNT" $Ligne]} {break} if {!$LAiJeVu} {continue} append Infos " $Ligne" } if {!$LAiJeVu} {return ""} regsub -all " /" $Infos "," Infos regsub -all "\"" $Infos " " Infos regsub -all " and " $Infos "," Infos regsub -all {\. } $Infos "," Infos regsub -all ", " $Infos "," Infos regsub -all " ," $Infos "," Infos regsub -all "\=" $Infos "\=," Infos regsub -all "\\(" $Infos " " Infos regsub -all "\\)" $Infos " " Infos while {[regexp " " $Infos]} {regsub -all " " $Infos " " Infos} set LesTissues "" set SuisJeSurUnTissue 0 foreach Element [split [string trim $Infos] ","] { set Element [string trim $Element] if {$Element == ""} {continue} if {[string equal -nocase "tissue_type=" $Element]} { set SuisJeSurUnTissue 1 continue } if {$SuisJeSurUnTissue && [regexp "=" $Element]} { set SuisJeSurUnTissue 0 continue } if {!$SuisJeSurUnTissue} {continue} if {[info exists Tab($Element)]} {continue} set Tab($Element) 1 lappend LesTissues $Element } return [lsort -unique $LesTissues] } proc LesTypesDesGO {LesGO} { set LesTypes {} foreach GO $LesGO { if {$GO == "GO:0003673"} {continue} foreach Type [GODB GO $GO LesTypes] { if {[info exists TabTmp($Type)]} {continue} set TabTmp($Type) 1 lappend LesTypes $Type } if {[llength $LesTypes] >= [llength [GODB LesTypes]]} {break} } return $LesTypes } proc LesTypesGO {} { set Liste {} foreach File [glob -nocomplain "[GODBDir]/*.ontology"] { set NameFile [file tail $File] if {[string equal -nocase $NameFile "defintions_terms.ontology"]} {continue} lappend Liste [FichierGO2Type $NameFile] } return $Liste } proc LesTypesOntologiques {} { set Liste {} foreach File [glob -nocomplain "[OntologyDir]/*.ontology"] { set NameFile [file tail $File] if {[string equal -nocase $NameFile "defintions_terms.ontology"]} {continue} regsub {\.ontology} $NameFile "" Type lappend Liste $Type } return $Liste } proc LesUniquesParSerie {FichierClusters {Selec "EXH-PPRB PP00"}} { set Liste [ListeDesJR $FichierClusters] set LesDatas1 {} set LesSelec [split $Selec " "] foreach Nom $Liste { set CodeClone [ExtraitInfo $Nom OwnerOfCDNA] foreach Sel $LesSelec { if {[regexp "^$Sel" $CodeClone]} {lappend LesDatas1 $Nom} } } #Espionne "nb uniques: [llength $LesDatas1]" return $LesDatas1 } proc LesUtilesDeHumanGenome {} { set LesUtiles {} foreach Ligne [LesLignesDuFichier "[GscopeDir]/lesrepsdehumangenome.liste"] { set Quota "" scan $Ligne "%d %s" Quota Fichier if {$Quota==""} { continue } set Xoue [Oue "/$Fichier"] if {$Xoue==""} { continue } lappend LesUtiles $Fichier } return $LesUtiles } proc LesVEDidierCompatiblesGscope {{Action ""}} { if {$Action==""} { set Action "ShowOnly" } set FichierVEDidierCompatiblesGscope "[Fiches]/VEDidierCompatiblesGscope.txt" if {$Action=="GetList" && [FileExists $FichierVEDidierCompatiblesGscope]} { return [LesLignesDuFichier $FichierVEDidierCompatiblesGscope] } set LesNonPGS {} set LesNonCodeRipp {} set LesNonGateway {} set LesVecteursManquants {} set LesMauvaisesLimites {} set LesMauvaisProtName {} foreach VE [VEDidier ListeDes VE] { set ProtName [VEDidier $VE "ProtName"] set Scientist [VEDidier $VE "Scientist"] set Vectorname [VEDidier $VE "Vectorname"] set DomainLimit [string trim [VEDidier $VE "DomainLimit"]] set CodeRipp [VEDidier $VE "CodeRipp"] if {$CodeRipp==""} { lappend LesNonCodeRipp "$VE [VEDidier $VE Ligne]" continue } set NomDuProtName [NomDuAlias $ProtName] if {$NomDuProtName=="" && $CodeRipp!=""} { set BetterProtName [Alias $CodeRipp] if {0 && [OuiOuNon "the ProtName from Didier '$ProtName' doesn't correspond to the Gscope ProtName '$BetterProtName' \n Do I use $BetterProtName"]} { set ProtName $BetterProtName } lappend LesMauvaisProtName "'$ProtName' '$BetterProtName' $CodeRipp $Scientist" } set Organism [VEDidier $VE "Organism"] set ProtOrga "${ProtName}_$Organism" regsub -all " " $ProtOrga "_" ProtOrga if {[NomDuAlias $ProtName]!=""} { set AliasGscope $ProtName } else { set AliasGscope [AliasAlias $ProtOrga "Gscope"] } set Comments [VEDidier $VE "Comments"] set PGS "" set DE "" if {$AliasGscope!=""} { set PGS [NomDuAlias $AliasGscope] if {[regexp " " $PGS]} { scan $PGS "%s %s" PGS PGS2 if {$CodeRipp==$PGS2} { set PGS $PGS2 } } set DE [DefinitionRapide $PGS] } if {$PGS==""} { lappend LesNonPGS "$VE [VEDidier $VE Ligne]" continue } if {$CodeRipp!="" && $CodeRipp!=$PGS} { FaireLire "CodeRipp is not PGS\n[VEDidier $VE Ligne]\n $AliasGscope $PGS" } regsub "/" $DomainLimit " " Limites scan $Limites "%d %d" D F if {! [info exists Missing($Vectorname)]} { set Trouve [FindVector $Vectorname] if {$Trouve==""} { Espionne "missing vector $Vectorname for $VE $PGS $AliasGscope $D $F $Scientist" lappend LesVecteursManquants $Vectorname set Missing($Vectorname) 1 continue } } set LesVPs [LesVirtualPPCRsDuPGS $PGS] set Ok 0 set LesMauvaisSujets {} foreach N $LesVPs { set Sujet [VirtualPPCREnStock $N "Sujet"] if { ! [regexp {[0-9]+\-[0-9]+$} $Sujet] } { lappend LesMauvaisSujets "$N $Sujet" continue } Espionne [VirtualPPCREnStock $N "Resume"] regsub -all -- {\-} $Sujet " " Mots set LesMots [split $Mots " "] set Ds [lindex $LesMots end-1] set Fs [lindex $LesMots end] regsub -- "\-$D\-$F$" $Sujet "" PName set Dp $D set Fp $F if {$Ds==2 && $Dp==1} { set Dp 2 } if {$Ds==2 && $Dp==3} { set Dp 2 } if {[expr abs($Fs-$Fp)<=1]} { set Fp $Fs } if {$Dp==$Ds && $Fp==$Fs} { set Ok 1 ; break } lappend LesMauvaisSujets "$N $Sujet" } if {$Ok} { if {$Dp!=$D || $Fp!=$F} { lappend LesMauvaisesLimites "$VE $ProtName $D>$Dp $F>$Fp [VirtualPPCREnStock $N]" } set Vecteur [FindVector NameOf_$Vectorname] set R1 "${N}_pDONR207" set NduR [Rec1 $R1 N] if {$NduR!=$N} { lappend LesNonGateway "$N n'a pas de Rec1 $VE [VEDidier $VE Ligne]" continue } set Type [TypeDeVecteurGateway $Vecteur] if {$Type!=2} { lappend LesNonGateway "$N son $Vectorname n'est pas Gateway $VE [VEDidier $VE Ligne]" continue } lappend LaSortie "$VE $R1 $Vecteur $PGS $AliasGscope $D $F $Vectorname $Scientist [VirtualPPCREnStock $N]" } else { lappend LesMauvais "nothing for $VE $PGS $AliasGscope $D $F $Vectorname $Scientist" lappend LesMauvais [join $LesMauvaisSujets "\n"] lappend LesMauvais "" } } set LaSortie [lsort $LaSortie] if {$LesNonCodeRipp!={}} { Espionne [SauveLesLignes $LesNonCodeRipp dans "[Fiches]/NonCodeRipp.txt"] } if {$LesNonPGS!={}} { Espionne [SauveLesLignes $LesNonPGS dans "[Fiches]/NonPGS.txt"] } if {$Action!="ShowOnly"} { if {$LesNonPGS!={}} { Espionne [SauveLesLignes $LesNonPGS dans "[Fiches]/NonPGS.txt"] } if {$LesMauvaisProtName!={}} { Espionne [SauveLesLignes $LesMauvaisProtName dans "[Fiches]/MauvaisProtName.txt"] } if {$LesMauvaisesLimites!={}} { Espionne [SauveLesLignes $LesMauvaisesLimites dans "[Fiches]/MauvaisesLimites.txt"] } if {$LesNonGateway!={}} { Espionne [SauveLesLignes $LesNonGateway dans "[Fiches]/NonGateway.txt"] } if {$LesVecteursManquants!={}} { set LesVecteursManquants [lsort -unique $LesVecteursManquants] Espionne [SauveLesLignes $LesVecteursManquants dans "[Fiches]/VecteursManquants.txt"] } SauveLesLignes $LaSortie dans $FichierVEDidierCompatiblesGscope } if {$Action=="GetList"} { return $LaSortie } AfficheVariable [join $LesMauvais "\n"] return [AfficheVariable [join $LaSortie "\n"]] } proc LesValeursNormalisees {LesValeurs} { set LesValeursNormalisees {} set LaMoyEtLET [MoyenneEcartMinMaxCumulLong $LesValeurs] set Moy [lindex $LaMoyEtLET 0] set ET [lindex $LaMoyEtLET 1] foreach Valeur $LesValeurs { if {$ET != 0} { lappend LesValeursNormalisees [expr ($Valeur - $Moy) * 1.0 / $ET] } else { lappend LesValeursNormalisees [expr ($Valeur - $Moy)] } } return $LesValeursNormalisees } proc LesValueursExtremes {FichierDepart} { set premierefois 1 foreach Ligne [LesLignesDuFichier $FichierDepart] { if {[regexp "Probe" $Ligne]} {continue} set Valeur [lindex [split $Ligne "\t"] 1] if {$premierefois} { set petit $Valeur set grand $Valeur set premierefois 0 } else { if {$Valeur>$grand} {set grand $Valeur} if {$Valeur<$petit} {set petit $Valeur} } } Espionne "le plus grand $grand" Espionne "le plus petit $petit" } proc LesVecteurs {{VecType ""} {GetThem ""}} { if {$VecType==""} { set VecType "pDONR_pDEST" } if {$GetThem==""} { set GetThem "GetFilenames" } set GetFilenames [string equal -nocase $GetThem "GetFilenames"] set GetNames [string equal -nocase $GetThem "GetNames"] set LesPossible {} if {[regexp "pDONR" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDONR" "" "GetAll"] } if {[regexp "pDEST" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDEST" "" "GetAll"] } if {$GetNames} { set LesNames {} foreach F $LesPossibles { set Name [file tail $F] regsub {\.tfa} $Name "" Name lappend LesNames $Name } return $LesNames } if {$GetFilenames} { return $LesPossibles } } proc LesVieuxLiens {} { foreach RF [glob "/genomics/*/*/banques"] { foreach Lien [glob -nocomplain "$RF/*"] { if {[file type $Lien]!="link"} { continue } set Cible [file readlink $Lien] set QueueCible [file tail $Cible] set RepCible [file dirname $Cible] if {[file tail $RepCible]=="banques"} { set Autre [file tail [file dirname $RepCible]] set BonAutre "[GscopeDatabaseDir $Autre]/banques/$QueueCible" Espionne "\n" Espionne $Lien exec rm $Lien exec ln -s $BonAutre $Lien } } } } proc LesVirtualPPCRsDuPGS {PGS} { global LesVirtualPPCRsDuPGS if {[info exists LesVirtualPPCRsDuPGS($PGS)]} { return [set LesVirtualPPCRsDuPGS($PGS)] } if {[info exists LesVirtualPPCRsDuPGS("EstCharge")]} { return {} } set LesVirtualPPCRsDuPGS("EstCharge") 1 foreach Loc [LocalisationDesVirtualPPCRs "GetAllLocs"] { scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo lappend LesVirtualPPCRsDuPGS($PGSLu) $NLu } return [LesVirtualPPCRsDuPGS $PGS] } proc LesZonesDuBlastNEnOverlap {Fichier} { global RepertoireDuGenome global LesORFsEnOverlap global ListeDeBoites set FichierTesBornes "$Fichier.tesbornes" set FichierMesBornes "$Fichier.mesbornes" set FichierMesOverlaps "$Fichier.mesoverlaps" set FichierMesSolitaires "$Fichier.messolitaires" set FichierMesConviviaux "$Fichier.mesconviviaux" set FichierMesInteressants "$Fichier.mesinteressants" foreach Ligne [LesLignesDuFichier $FichierTesBornes] { ExtraireDe $Ligne Nom Debut Fin Orient regsub "TaZone" $Nom "MaZone" MonNom set TaZone($MonNom) $Ligne } foreach Ligne [LesLignesDuFichier $FichierMesBornes] { ExtraireDe $Ligne Nom Debut Fin Orient if {[info exists DejaVu($Debut,$Fin,$Orient)]} { Espionne "DejaVu [set DejaVu($Debut,$Fin,$Orient)] $Nom" continue } set Long [expr $Fin-$Debut+1] if {$Long<1000} { continue } set Frame [NomDeLaFrame [expr $Debut%3] $Orient] set Boite $Nom Box $Boite nom $Nom Box $Boite orient $Orient Box $Boite frame $Frame Box $Boite debut $Debut Box $Boite fin $Fin Box $Boite long $Long set DejaVu($Debut,$Fin,$Orient) $Nom lappend ListeDeBoites $Boite } CalculeLesORFsEnOverlap foreach Boite $ListeDeBoites { set Nom [Box $Boite nom] set Over [CalculeLesOverlapsDe $Nom] if {$Over == ""} { continue } if {[regexp "I am in" $Over]} { set EstIn($Nom) 1 } } foreach Boite $ListeDeBoites { set Nom [Box $Boite nom] if {[info exists EstIn($Nom)]} { continue } set Over [CalculeLesOverlapsDe $Nom] lappend Interessants $Nom if {$Over == ""} { lappend Solitaires $Nom continue } lappend Conviviaux $Nom foreach Ligne [split $Over "\n"] { if {[regexp "I contain" $Ligne]} { continue } set Toi [StringApres " in " dans $Ligne] if {[info exists EstIn($Toi)]} { continue } set Longueur [IntegerApres "Overlap\:" dans $Ligne] if {$Longueur<100} { continue } if {[Box $Nom orient]!=[Box $Toi orient]} { continue } if {[info exists DejaVu($Nom,$Toi)]} { continue } set DejaVu($Toi,$Nom) 1 lappend MoiToi $Nom lappend MoiToi $Toi lappend MoiToi $Longueur } } set OldMoi "" foreach {Moi Toi Longueur} $MoiToi { if {$OldMoi != $Moi } { lappend SortieOverlaps "$Moi [Box $Moi debut] [Box $Moi fin] [Box $Moi orient]" set LongMoi [expr [Box $Moi fin]-[Box $Moi debut]+1] } set OldMoi $Moi set LongToi [expr [Box $Toi fin]-[Box $Toi debut]+1] lappend SortieOverlaps "[string repeat " " [string length $Moi]] [Box $Toi debut] [Box $Toi fin] [Box $Toi orient] $Toi $LongMoi $LongToi $Longueur" } foreach Nom $Solitaires { lappend SortieSolitaires "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]" } foreach Nom $Conviviaux { lappend SortieConviviaux "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]" } foreach Nom $Interessants { lappend SortieInteressants "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]" } Espionne [SauveLesLignes $SortieSolitaires dans $FichierMesSolitaires] Espionne [SauveLesLignes $SortieConviviaux dans $FichierMesConviviaux] Espionne [SauveLesLignes $SortieOverlaps dans $FichierMesOverlaps] Espionne [SauveLesLignes $SortieInteressants dans $FichierMesInteressants] exit } proc LesZonesEnOverlap {Nom {Quoi ""}} { if {$Quoi==""} { set Quoi "LesZonesTriees" } set Debut [Box $Nom debut] set Fin [Box $Nom fin] set Orient [Box $Nom orient] set Long [expr $Fin-$Debut+1] if {$Long<1} { return "" } set LesOverlaps [split [Overlap $Nom] "/"] set LesZones {} foreach Ovl $LesOverlaps { regexp "I am in|I contain|I begin in|I end in" $Ovl Type set Voisin [StringApres $Type dans $Ovl] if {[Fantome $Voisin]} { continue } set D [IntegerApres "from" dans $Ovl] set F [IntegerApres "to" dans $Ovl] set L [expr $F-$D+1] set P [expr (100*$L)/$Long] lappend LesZones "$P $D $F $Voisin" } if {$Quoi=="LesZones"} { return $LesZones } set LesZonesTriees [lsort -decreasing -integer -index 0 $LesZones] if {$Quoi=="LesZonesTriees"} { return $LesZonesTriees } FaireLire "ZonesEnOverlap wrong argument" return } proc LesZonesEnOverlapMultiple {Nom} { set Debut [Box $Nom debut] set Fin [Box $Nom fin] set Orient [Box $Nom orient] set Long [expr $Fin-$Debut+1] set NombreMinimumDeCopainsNecessaires 5 set LesZones [LesZonesEnOverlap $Nom] set LesZonesEtendues {} foreach Zone $LesZones { scan $Zone "%d %d %d %s" P D F Voisin if {[Fantome $Voisin]} { continue } if {[NombreDeCopainsDansBlast $Voisin]<$NombreMinimumDeCopainsNecessaires} { continue } incr D -15 incr F 15 lappend LesZonesEtendues "$P $D $F $Voisin" } set LesZonesEtendues [lsort -integer -index 1 $LesZonesEtendues] if {$LesZonesEtendues=={}} { return {} } set LesRecouvrements {} set LesZonesRestantes $LesZonesEtendues foreach ZonePremiere $LesZonesEtendues { set LesZonesRestantes [lrange $LesZonesRestantes 1 end] if {[info exists DejaVu($ZonePremiere)]} { continue } scan $ZonePremiere "%d %d %d %s" P D F Voisin set DMin $D set FMax $F foreach Zone $LesZonesRestantes { scan $Zone "%d %d %d %s" P D F Voisin if {$D>$FMax} { break } set DejaVu($Zone) 1 set FMax [Maxi $F $FMax] } set DMin [Maxi $DMin $Debut] set FMax [Mini $FMax $Fin] set PCent [expr (100*($FMax-$DMin+1))/$Long] lappend LesRecouvrements "$PCent $DMin $FMax" } return $LesRecouvrements } proc LesZscoreDesRequetesDuGroupe {LesRequetesDesIndividusDuGroupe LesRequetesDesTouteLaPopulation} { #Liste dont chaque element est la liste des requetes d'un individu set R [llength $LesRequetesDesIndividusDuGroupe] set N [llength $LesRequetesDesTouteLaPopulation] set ToutesLesRequetes {} foreach LesRequetes $LesRequetesDesIndividusDuGroupe { foreach Requete [lsort -unique $LesRequetes] { if {![info exists Tab(Requete,$Requete,r)]} { set Tab(Requete,$Requete,r) 0 set Tab(Requete,$Requete,n) 0 lappend ToutesLesRequetes $Requete } incr Tab(Requete,$Requete,r) } } foreach LesRequetes $LesRequetesDesTouteLaPopulation { foreach Requete [lsort -unique $LesRequetes] { if {![info exists Tab(Requete,$Requete,r)]} { set Tab(Requete,$Requete,r) 0 set Tab(Requete,$Requete,n) 0 lappend ToutesLesRequetes $Requete } incr Tab(Requete,$Requete,n) } } set LesZscoreDesRequetes {} foreach Requete [lsort -unique $ToutesLesRequetes] { set r [set Tab(Requete,$Requete,r)] set n [set Tab(Requete,$Requete,n)] if {$n == 0 || $N == 0 || $R == 0 || $N == $R || ($n == $r && $N == $R) || ($r == $R && $n == $N)} {continue} set zscore [ZScore $r $R $n $N] if {$zscore == ""} {continue} lappend LesZscoreDesRequetes [list $Requete $zscore $r $R $n $N] } return [lsort -index 1 -decreasing -real $LesZscoreDesRequetes] } proc LesmRNAsChoisisHuman {FichierClusters FichierSortie} { foreach PAB [ListeDesJR $FichierClusters] { set AccessmRNA [InterrogeProtAndmRNAChoisis $PAB mRNAChoisi Access] set Orga [InterrogeProtAndmRNAChoisis $PAB OrganismeChoisi] if {$AccessmRNA=="" || $AccessmRNA=="NOMRNA"} { continue } elseif {[regexp -nocase "HOMO SAPIENS" $Orga]} { #Espionne $AccessmRNA lappend LesAccessDesmRNAsChoisis "$AccessmRNA" } } #Espionne [llength $LesAccessDesmRNAsChoisis] set L [lsort -unique $LesAccessDesmRNAsChoisis] Espionne [llength $L] #SauveLesLignes $L dans "[RepertoireDuGenome]/LesAccessDesmRNAsChoisis" #FaireLire $L set LesAccessChoisis [split $L " "] set LesAccessPourGetz [join $LesAccessChoisis "\|"] #FaireLire $LesAccessPourGetz set Commande "getz \"\\\[genbankfull-acc:$LesAccessPourGetz\\\]\" \-view FastaSeqs" set GetzOut [eval exec $Commande] AppendAuFichier $FichierSortie $GetzOut set i 0 set n 0 foreach Ligne [LesLignesDuFichier $FichierSortie] { #Espionne $Ligne if {[regexp "^>" $Ligne]} { incr n set LesInfos [split $Ligne "\|"] set Access [lindex $LesInfos 1] set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_choisis/$Access" if {![info exists Vu($Access)]} { set Vu($Access) 1 incr i AppendAuFichier $FichiermRNA $Ligne #AppendAuFichier $Fichiersortie2 $Ligne Espionne $Access lappend Liste $Access } } if {[info exists Vu($Access)] && ([regexp "^A" $Ligne] || [regexp "^T" $Ligne] || [regexp "^G" $Ligne] || [regexp "^C" $Ligne])} { AppendAuFichier $FichiermRNA $Ligne #AppendAuFichier $Fichiersortie2 $Ligne } } Espionne "$n tfas" Espionne "nb access: [llength $Liste]" Espionne "nb tfas apres: $i" } proc LesmRNAsDeLaProt {BIdOuAccess} { return [LesmRNAsDeLaProt_PageInfo [PageInfo $BIdOuAccess protein]] } proc LesmRNAsDeLaProt_PageInfo {PageInfo {EtDeLOrga ""}} { set LesmRNAs {} set LesAccess [LesAcNucsDeLaProt_PageInfo $PageInfo] AskLesPagesInfos load $LesAccess genbankfull foreach AcNuc $LesAccess { set PageInfo [AskLesPagesInfos ask $AcNuc] if {$PageInfo == ""} {continue} if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {continue} if {$EtDeLOrga != ""} { set EstCeUnDesOrgas 0 foreach Orga [LesOrgasDeLaPage_PageInfo $PageInfo] { if {[string equal -nocase $Orga $EtDeLOrga]} {set EstCeUnDesOrgas 1;break} } if {!$EstCeUnDesOrgas} {continue} } lappend LesmRNAs $AcNuc } AskLesPagesInfos unset return $LesmRNAs } proc LesmRNAsDesAcNucs {LesAccess} { AskLesPagesInfos unset AskLesPagesInfos load $LesAccess genbankfull set LesmRNAs {} foreach Access $LesAccess { set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} {continue} if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {continue} lappend LesmRNAs $Access } AskLesPagesInfos unset return $LesmRNAs } proc LesmRNAsDuBlast {FileBlast {ExpectMax 0.001} {NbSubjectMax 500}} { set NbSubjectDansBlast [AskBlast $FileBlast NbSubject] set LesBId {} set n 0 for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [AskBlast $FileBlast Subject $i] if {[info exists Tab($BId,LesOrganismes)]} {continue} set Expect [AskBlast $FileBlast BanqueId $BId Segment 1 Expect ] set Score [AskBlast $FileBlast BanqueId $BId Segment 1 Score ] if {$ExpectMax < $Expect} {continue} incr n if {$NbSubjectMax < $n } {break} lappend LesBId $BId } set LesmRNAs {} AskLesPagesInfos load $LesBId genbankfull foreach BId $LesBId { if {[info exists Tab($BId,LesOrganismes)]} {continue} set PageInfo [AskLesPagesInfos ask $BId] if {$PageInfo == ""} {continue} if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {continue} set Access [string toupper [AskBlast $FileBlast BanqueId $BId Access]] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLAcNuc_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Taille [AskBlast $FileBlast BanqueId $BId Taille ] scan $Score "%f" Score set Orientation [AskBlast $FileBlast BanqueId $BId Segment 1 Orientation] set PIdGlob [PourcentageDIdentiteGlobal $FileBlast $BId] set NbBasesEnCommun [NombreDeBasesEnCommun $FileBlast $BId] set LeProfil [LeProfilDeLAlignementDuSubject $FileBlast $BId] set NbInCDS 0 set NbIn5UTR 0 set NbIn3UTR 0 set n 0 if {[info exists DbtCDS]} {unset DbtCDS} if {[info exists FinCDS]} {unset FinCDS} regexp { CDS [^0-9]+([0-9]+)\.[ ]*\.([0-9]+)} $PageInfo tmp DbtCDS FinCDS if {![info exists DbtCDS] || ![info exists FinCDS]} {continue} foreach Base $LeProfil { incr n if {$Base == 0} {continue} if {[info exists DbtCDS] && [info exists FinCDS]} { if {$DbtCDS <= $n && $n <= $FinCDS} {incr NbInCDS} if {$n < $DbtCDS } {incr NbIn5UTR} if {$FinCDS < $n } {incr NbIn3UTR} } } set TailleCDS [expr $FinCDS - $DbtCDS + 1] set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { set LesProteines {} foreach Prot [LesProteinesDeLAcNuc_PageInfo $PageInfo] {lappend LesProteines [string toupper $Prot]} lappend LesmRNAs [list $BId $Access $Taille $TailleCDS $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun $NbIn5UTR $NbInCDS $NbIn3UTR $Orga $Def $LesProteines "mRNA"] } } set LesmRNAs [lsort -real -decreasing -index 2 $LesmRNAs] set LesmRNAs [lsort -real -decreasing -index 10 $LesmRNAs] set LesmRNAs [lsort -real -decreasing -index 7 $LesmRNAs] set LesmRNAs [lsort -integer -decreasing -index 8 $LesmRNAs] AskBlast unset AskLesPagesInfos unset return $LesmRNAs } proc LesmRNAsDuBlast_TabBlast {aTabBlast} { upvar $aTabBlast TabBlast set LesmRNAs {} set NbSubjectDansBlast [set TabBlast(NbSubject) ] for {set i 1} {$i <= $NbSubjectDansBlast} {incr i} { set BId [set TabBlast($i)] if {[info exists Tab($BId,LesOrganismes)]} {continue} set Access [string toupper [set TabBlast($BId,Access)]] set PageInfo [PageInfo $BId genbank] if {$PageInfo == ""} {continue} if {![EstCeUnmRNACompleteCDS_PageInfo $PageInfo]} {continue} set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLAcNuc_PageInfo $PageInfo] " "] if {$Def == ""} {set Def "Not found"} set Expect [set TabBlast($BId,1,Expect) ] set Score [set TabBlast($BId,1,Score) ] set Taille [set TabBlast($BId,Taille) ] scan $Score "%f" Score set Orientation [set TabBlast($BId,1,Orientation)] set PIdGlob [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] set NbBasesEnCommun [NombreDeBasesEnCommun_TabBlast TabBlast $BId] set LeProfil [LeProfilDeLAlignementDuSubject_TabBlast TabBlast $BId] set NbInCDS 0 set NbIn5UTR 0 set NbIn3UTR 0 set n 0 if {[info exists DbtCDS]} {unset DbtCDS} if {[info exists FinCDS]} {unset FinCDS} Espionne $BId regexp { CDS [^0-9]+([0-9]+)\.[ ]*\.([0-9]+)} $PageInfo tmp DbtCDS FinCDS if {![info exists DbtCDS] || ![info exists FinCDS]} {continue} foreach Base $LeProfil { incr n if {$Base == 0} {continue} if {[info exists DbtCDS] && [info exists FinCDS]} { if {$DbtCDS <= $n && $n <= $FinCDS} {incr NbInCDS} if {$n < $DbtCDS } {incr NbIn5UTR} if {$FinCDS < $n } {incr NbIn3UTR} } } set TailleCDS [expr $FinCDS - $DbtCDS + 1] set Tab($BId,LesOrganismes) $LesOrgas foreach Orga $LesOrgas { set LesProteines {} foreach Prot [LesProteinesDeLAcNuc_PageInfo $PageInfo] {lappend LesProteines [string toupper $Prot]} lappend LesmRNAs [list $BId $Access $Taille $TailleCDS $Orientation $Expect $Score $PIdGlob $NbBasesEnCommun $NbIn5UTR $NbInCDS $NbIn3UTR $Orga $Def $LesProteines "mRNA"] } } set LesmRNAs [lsort -real -decreasing -index 2 $LesmRNAs] set LesmRNAs [lsort -real -decreasing -index 10 $LesmRNAs] set LesmRNAs [lsort -real -decreasing -index 7 $LesmRNAs] set LesmRNAs [lsort -integer -decreasing -index 8 $LesmRNAs] return $LesmRNAs } proc LgtDescriptif {} { global TDesDescriptifs set max -1 foreach e [array names TDesDescriptifs] { set l [string length [set TDesDescriptifs($e)]] if {$l > $max} {set max $l} } return $max } proc LibraryEditorGui {} { NSLibraryEditorGui::initNS NSLibraryEditorGui::showGui } proc LienEntreExpEtPuce {ExpCourt} { global LienEntreExpEtPuce if {[info exists LienEntreExpEtPuce($ExpCourt)]} { return $LienEntreExpEtPuce($ExpCourt) } if {[info exists LienEntreExpEtPuce("EstCharge")]} { return {} } set LienEntreExpEtPuce("EstCharge") 1 set LesLignes {} CanalSqlBioArrayBase foreach {Ex Ch} [SqlExec "select distinct e.description, at.type from retinobase3.realexp re, retinobase3.experiment e, retinobase3.arraytype at where re.pk_experiment = e.pk_experiment and re.pk_arraytype = at.pk_arraytype;" "GetList"] { lappend LesLignes "$Ex\t$Ch" } CanalSqlDisconnect foreach Ligne $LesLignes { set LesElmts {}; set LesElmtsChip {}; set LesElmtsChipPris {} #Espionne "$Ligne" set LesElmts [split $Ligne "\t"] set ExpLu [lindex $LesElmts 0] set ExpRaccourci [string range $ExpLu 0 24] #Espionne "1 $ExpLu" regsub -all " " $ExpRaccourci "_" ExpRaccourci #Espionne "2 $ExpRaccourci" set ChipLu [lindex $LesElmts 1] #Espionne "4 $ChipLu" set LesElmtsChip [split $ChipLu " "] set nbelmtchip [llength $LesElmtsChip] if {$nbelmtchip==1} { set ChipLu [lindex $LesElmtsChip 0] } else { for {set j 0} {$j<[expr $nbelmtchip-1]} {incr j} { lappend LesElmtsChipPris [lindex $LesElmtsChip $j] } set ChipLu [join $LesElmtsChipPris " "] } #Espionne "5 $ChipLu" set LienEntreExpEtPuce($ExpRaccourci) $ChipLu } return [LienEntreExpEtPuce $ExpCourt] } proc LiensAgents {n agn ns} { global TAg LNOrdali set Link {} foreach ki [array names T "$n,*"] { lassign [split $ki ,] ni ai set Li [lsearch -index 0 -exact $T($ki) $nt] foreach ipair $Li { lassign [lindex $T($ki) $ipair] tmp agt lappend Link $ni $ai $nt $agt } } return $Link } proc LigneAcPlsAccess {} { set A 0 foreach I [RetChip2 ListOf Index] { set Des1 [RetChip2 $I "description_customer"] set Des2 [RetChip2 $I "description_memorec"] set Ac1 [RetChip2 $I "DNA_acc"] set Ac2 [RetChip2 $I "refseq_PIQOR"] set Ac3 [RetChip2 $I "prot_acc"] set Ac4 [RetChip2 $I "prot_acc_PIQOR"] set deuxvides 0 set jaitrouve 0 if {!$deuxvides && $Ac2!=""} { if {[regexp {\,} $Ac2]} { incr A #puts "ligne $I a pls access ds refseq_piqor=> $Ac2" #ok il y a les 57 } } if {!$deuxvides && $Ac1!=""} { if {[regexp {\,} $Ac1]} { set B 0 #Ac1 a tjs un seul access #puts "ligne $I a pls access ds dna_acc" } } if {$Ac1!="" && $Ac2!=""} { set deuxpleins 1 if {[regexp {\,} $Ac2]} { set Genre [OrgDuNmOuGb $Ac1] if {[regexp {^Mus} $Genre]} { puts "ligne $I a un access ds dna_acc et pls access ds refseq_piqor" if { $Ac1==$Ac2 } { set jaitrouve 1 puts "la ligne $I a le meme access ds dna_acc et refseq_piqor" } if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } { set LesNMs [split $Ac2 ","] foreach LeNM $LesNMs { if { $LeNM==$Ac1 } { set jaitrouve 1 puts "la ligne $I a un access ds dna_acc qui se retrouve ds refseq_piqor" } } } if { !$jaitrouve } { puts "la ligne $I a un access ds dna_acc qui ne se retrouve pas dans refseq_piqor" } } } } } puts "A=$A" } proc LigneAcPlsAccess_AEffacer {} { set A 0 foreach I [RetChip2 ListOf Index] { set Des1 [RetChip2 $I "description_customer"] set Des2 [RetChip2 $I "description_memorec"] set Ac1 [RetChip2 $I "DNA_acc"] set Ac2 [RetChip2 $I "refseq_PIQOR"] set Ac3 [RetChip2 $I "prot_acc"] set Ac4 [RetChip2 $I "prot_acc_PIQOR"] set deuxvides 0 set jaitrouve 0 if {!$deuxvides && $Ac2!=""} { if {[regexp {\,} $Ac2]} { incr A #puts "ligne $I a pls access ds refseq_piqor=> $Ac2" #ok il y a les 57 } } if {!$deuxvides && $Ac1!=""} { if {[regexp {\,} $Ac1]} { set B 0 #Ac1 a tjs un seul access #puts "ligne $I a pls access ds dna_acc" } } if {$Ac1!="" && $Ac2!=""} { set deuxpleins 1 if {[regexp {\,} $Ac2]} { set Genre [OrgDuNmOuGb $Ac1] if {[regexp {^Mus} $Genre]} { puts "ligne $I a un access ds dna_acc et pls access ds refseq_piqor" if { $Ac1==$Ac2 } { set jaitrouve 1 puts "la ligne $I a le meme access ds dna_acc et refseq_piqor" } if { $jaitrouve == 0 && [regexp {.\,.} $Ac2] } { set LesNMs [split $Ac2 ","] foreach LeNM $LesNMs { if { $LeNM==$Ac1 } { set jaitrouve 1 puts "la ligne $I a un access ds dna_acc qui se retrouve ds refseq_piqor" } } } if { !$jaitrouve } { puts "la ligne $I a un access ds dna_acc qui ne se retrouve pas dans refseq_piqor" } } } } } puts "A=$A" } proc LigneAccessPourLOligo {P} { set LesSujets [Oli $P Subjects] set Sens [Oli $P Sens] set Signals [Oli $P Signals] set Seq [Oli $P Seq] set SeqSujet [Oli $P SeqSubject] set Type [Oli $P Type] set TypeUtilisation $Type if {$Type=="SynOli"} { set TypeUtilisation "PCR" } set Fournis [Fournisseur $P] set OlIgbmc [OlIgbmc $P] set Tm [TMDeLaSequence $SeqSujet] set LesPoMa [PositionSurMatrices $P] if {0 && [llength $LesPoMa]>1 && $Type!="MutOli"} { FaireLire "I found more than 1 matrix for $P. Please select one of them." set PoMa [ChoixParmi $LesPoMa] } else { set PoMa [lindex $LesPoMa 0] } set AA -1 set NA -1 set Orient "F" set PAB "" scan $PoMa "%s %d %d %s %s" P AA NA Orient PAB if {$AA<0} { set Matrice "" } else { set Matrice [Alias $PAB] } set Sens "" if {$Orient=="F"} { set Sens "sens" set Tm5p "tm5p_$Tm" set LesSST {} foreach Suj $LesSujets { set SST "${Signals}_$Suj $Tm5p" lappend LesSST $SST } set signal [join $LesSST "+"] } if {$Orient=="R"} { set Sens "antisens" set Tm3p "tm3p_$Tm" set LesSST {} foreach Suj $LesSujets { set SST "${Suj}_${Signals} $Tm3p" lappend LesSST $SST } set signal [join $LesSST "+"] } set code_IGBMC $OlIgbmc regsub "OLIGO\:" $code_IGBMC "" code_IGBMC set sequence $Seq set brin $Sens set proteine $Matrice if {$Type=="MutOli"} { set mutation [Oli $P CodeMutation] } else { set mutation "" } set utilisation $TypeUtilisation set longueur [string length $Seq] set signal $signal if {$Fournis!=""} { set demandeur $Fournis } else { set demandeur "" } set date_commande "" set date_reception "" set codon_de_l_oligo1 "" set boite "" set LaLigne {} lappend LaLigne $P lappend LaLigne $code_IGBMC lappend LaLigne $sequence lappend LaLigne $brin lappend LaLigne $proteine lappend LaLigne $mutation lappend LaLigne $utilisation lappend LaLigne $longueur lappend LaLigne $signal lappend LaLigne $demandeur lappend LaLigne $date_commande lappend LaLigne $date_reception lappend LaLigne $codon_de_l_oligo1 lappend LaLigne $boite set Ligne [join $LaLigne "\"\t\""] set Ligne "\"$Ligne\"" return $Ligne } proc LigneDesMots {Ligne {REX ""}} { if {$REX==""} { set REX "\;" } regsub -all "$REX|\t" $Ligne " " Ligne if {$REX!=" "} { while {[regexp " " $Ligne]} { regsub -all " " $Ligne " " Ligne } } set Ligne [string trim $Ligne] return $Ligne } proc LigneDuFichierJumeauxSeqNuc {Nom} { global RepertoireDuGenome set FichierJumeauxSeqNuc "$RepertoireDuGenome/fiches/jumeaux_SeqNuc" if {![file exists $FichierJumeauxSeqNuc]} { if {[OuiOuNon "Do You want to run Jumeaux ?"]} { set FichierDesJumeaux [Jumeaux "Ask"] } else {return ""} } foreach Ligne [LesLignesDuFichier $FichierJumeauxSeqNuc] { if {[regexp "$Nom" $Ligne]} { return $Ligne } } } proc LignesEMBLtoTFA {LesLignesEMBL Entete} { set iSQ [lsearch -regexp $LesLignesEMBL "^SQ"] set Sequence "" if {$iSQ!="end"} { regsub -all {[ 0-9/\n\t]} [join [lrange $LesLignesEMBL [incr iSQ] end] ""] "" Sequence } set TFA ">$Entete\n[SequenceFormatBrut $Sequence]" return $TFA } proc LignesParGb {GB} { return [GbsParLigne $GB] } proc LignesParNm {NM} { return [NmsParLigne $NM] } proc LineageFromGI {LId} { array set T [eSummaryREST protein $LId] set Ltxid [list] foreach id $LId { lappend Ltxid [set T($id,TaxId)] } set Llin [list] array set Tx [eFetchREST taxonomy $Ltxid] foreach t $Ltxid { if {[info exists Tx($t,Lineage)]} { lappend Llin $Tx($t,Lineage) } else { lappend Llin "" } } return $Llin } proc Link2HTML {aT} { upvar $aT tbl Html_Href $tbl(textLink) $tbl(targetLink) return } proc LireHori {Fichier {FichierSuivant ""}} { global RepertoireDuGenome foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp "^PH" $Ligne]} { continue } set LesMots [split $Ligne ","] scan $LesMots "%s %s %d %d" NomLu PM Debut Fin if {$PM=="+"} { set Orient "F" } if {$PM=="-"} { set Orient "R" } regsub -all -nocase {[a-z]} $NomLu "" Numero scan $Numero "%d" N set Nom [PreFixe][format "%4.4d" $N] lappend LesBornes "$Nom $Debut $Fin $Orient" } if {$FichierSuivant!=""} { set N [Maxi $Numero 3000] foreach Ligne [LesLignesDuFichier $FichierSuivant] { if { ! [regexp "^PH" $Ligne]} { continue } set LesMots [split $Ligne ","] scan $LesMots "%s %s %d %d" NomLu PM Debut Fin if {$PM=="+"} { set Orient "F" } if {$PM=="-"} { set Orient "R" } set Nom [PreFixe][format "%4.4d" [incr N]] lappend LesBornes "$Nom $Debut $Fin $Orient" } } Espionne [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs.nouveaux"] } proc LireMSF {ListeMSF LesNoms aProteines BorneSup} { upvar $aProteines Proteines set FinNoms [expr [lsearch $ListeMSF "//"]] set ListeMSF [lrange $ListeMSF $FinNoms end] #determination de la colonne ou commence les sequences set PremierNom [lindex $LesNoms 0] set DebutProt [lsearch -regexp $ListeMSF $PremierNom] regexp -indices $PremierNom [lindex $ListeMSF $DebutProt] Rang set ColDebutSeq [expr [lindex $Rang 1]+1] while {[string index [lindex $ListeMSF $DebutProt] $ColDebutSeq]== " "} { incr ColDebutSeq } foreach ligne $ListeMSF { if {$ligne==""} continue scan $ligne "%s" Nom if {[lsearch $LesNoms $Nom]==-1} continue set Sequence [string range $ligne $ColDebutSeq end] regsub -all " " $Sequence "" Sequence lappend Proteines($Nom) $Sequence } foreach Nom $LesNoms { set Intermed [join [set Proteines($Nom)] ""] set Proteines($Nom) [split $Intermed ""] } set Longueur [llength [set Proteines([lindex $LesNoms 0])]] set j 1 for {set i 1} {$i<=$Longueur} {incr i} { set Compteur 0 foreach Nom $LesNoms { set aa [lindex [set Proteines($Nom)] [expr $i-1]] set AA($Nom,$j) $aa if {$aa!="." & $aa!="~"} { incr Compteur } } if {$Compteur} { incr j } if {$j==$BorneSup} break } set Longueur [expr $j-1] foreach Nom $LesNoms { set Proteines($Nom) [list] for {set i 1} {$i<=$Longueur} {incr i} { lappend Proteines($Nom) [set AA($Nom,$i)] } } return $Longueur } proc LireUnMsf {listeMSF anoms_sequences alespositions alesproteines} { upvar $anoms_sequences noms_sequences upvar $alesproteines lesproteines upvar $alespositions lespositions #lit une liste contenant un msf, donne la liste des noms de sequences et retourne les proteines dans un tableau de listes set noms_sequences [list] set lespositions [list] #creation de noms_sequences set indice [lsearch -regexp $listeMSF "Name:"] set fin_liste_noms [lsearch $listeMSF "//"] while {$indice<$fin_liste_noms} { set fin_access [expr [string wordend [lindex $listeMSF $indice] 7]-1] set [string range [lindex $listeMSF $indice] 7 $fin_access] [list] lappend noms_sequences [string range [lindex $listeMSF $indice] 7 $fin_access] incr indice } #initialisation du tableau des sequences proteiques foreach ns $noms_sequences { set lesproteines($ns) {} } set listeMSF [lrange $listeMSF [expr $fin_liste_noms+2] end] set debut_des_prot [lsearch -regexp $listeMSF [lindex $noms_sequences 0]] regexp -indices [lindex $noms_sequences 0] [lindex $listeMSF $debut_des_prot] rang set col_debut_seq [expr [lindex $rang 1]+1] while {[string index [lindex $listeMSF $debut_des_prot] $col_debut_seq]== " "} { incr col_debut_seq } #remplissage du tableau de sequences proteiques, chaque element du tableau est une liste d'aa while {!($debut_des_prot==-1)} { foreach ns $noms_sequences { set chaine_intermed [string range [lindex $listeMSF $debut_des_prot] $col_debut_seq end] regsub -all " " $chaine_intermed "" chaine_intermed for {set i 0} {$i<[string length $chaine_intermed]} {incr i} { lappend lesproteines($ns) [string index $chaine_intermed $i] } incr debut_des_prot } set listeMSF [lrange $listeMSF [expr $debut_des_prot+1] end] set debut_des_prot [lsearch -regexp $listeMSF [lindex $noms_sequences 0]] } #initialisation des positions for {set i 0} {$i<[llength [set lesproteines([lindex $noms_sequences 0])]]} {incr i} { lappend lespositions $i } return [llength $noms_sequences] } proc LisBox {Conteneur {Liste ""} {LesIllumines ""}} { frame $Conteneur -borderwidth 10 pack $Conteneur -side left -expand yes -fill both set LixBox "$Conteneur.list" scrollbar $Conteneur.yscroll -command "$LixBox yview" scrollbar $Conteneur.xscroll -command "$LixBox xview" -orient horizontal set Largeur 30 set Hauteur 35 listbox $LixBox -width $Largeur -height $Hauteur -setgrid 1 -yscroll "$Conteneur.yscroll set" -xscroll "$Conteneur.xscroll set" -selectmode extended -background "LightGrey" -foreground "Black" -selectbackground "LightYellow" -selectforeground "Black" -font [list Courier [PolicePourListBox]] grid $LixBox -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $Conteneur.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $Conteneur.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $Conteneur 0 -weight 1 -minsize 0 grid columnconfig $Conteneur 0 -weight 1 -minsize 0 bind $LixBox <3> "DecrisLaLigne %W %x %y" bind $LixBox "DecrisLaLigne %W %x %y Efface" foreach Element $Liste { $LixBox insert end $Element } foreach Nom $LesIllumines { Illumine $Nom $LixBox } return $LixBox } proc Lissage {TailleFenetre LesNoms aBin aBinLisses} { upvar $aBinLisses BinLisses upvar $aBin Bin global TailleSeq set Seuil [expr $TailleFenetre/2] foreach Nom $LesNoms { set Compteur 1 for {set i 1} {$i<=$TailleSeq} {incr i $TailleFenetre} { set Somme 0 for {set j 0} {$j<$TailleFenetre && [expr $i+$j]<=$TailleSeq} {incr j} { incr Somme [set Bin($Nom,[expr $i+$j])] } if {$Somme<=$Seuil} { set BinLisses($Nom,$Compteur) 0 } else { set BinLisses($Nom,$Compteur) 1 } incr Compteur } } return [expr $Compteur-1] } proc Lissage3D {l} { # lissage par polynomes de Lagrange de ordre 5 set n [llength $l] if {$n < 5} {return} set km [expr {4*($n-1)+1}] set cof [list 0.1 0.125 0.25 0.375 0.50 0.625 0.75 0.875 1.0 0.875 0.75 0.625 0.50 0.375 0.25 0.125] for {set k 0} {$k < $km} {incr k} { set xout($k) [list 0.0 0.0 0.0] set norms($k) 0.0 } set xout([expr {$km-1}]) [lindex $l end] set C0 6144.0 set C1 -1536.0 set C2 1024.0 set i 0 set lx1 [lrange $l 0 end-4] set lx2 [lrange $l 1 end-3] set lx3 [lrange $l 2 end-2] set lx4 [lrange $l 3 end-1] set lx5 [lrange $l 4 end] foreach v1 $lx1 v2 $lx2 v3 $lx3 v4 $lx4 v5 $lx5 { for {set k 0} {$k < 16} {incr k} { set kk0 "$k." set kk4 [expr {$k - 4.0}] set kk8 [expr {$k - 8.0}] set kk12 [expr {$k - 12.0}] set kk16 [expr {$k - 16.0}] set c0 [expr {$kk4 * $kk8 * $kk12 * $kk16 / $C0}] set c1 [expr {$kk0 * $kk8 * $kk12 * $kk16 / $C1}] set c2 [expr {$kk0 * $kk4 * $kk12 * $kk16 / $C2}] set c3 [expr {$kk0 * $kk4 * $kk8 * $kk16 / $C1}] set c4 [expr {$kk0 * $kk4 * $kk8 * $kk12 / $C0}] lassign $v1 x1 y1 z1 lassign $v2 x2 y2 z2 lassign $v3 x3 y3 z3 lassign $v4 x4 y4 z4 lassign $v5 x5 y5 z5 set qipk [expr {4*$i+$k}] lassign [set xout($qipk)] xo yo zo set lecof [lindex $cof $k] set xo [expr {$xo + $lecof*($x1*$c0 + $x2*$c1 + $x3*$c2 + $x4*$c3 + $x5*$c4)}] set yo [expr {$yo + $lecof*($y1*$c0 + $y2*$c1 + $y3*$c2 + $y4*$c3 + $y5*$c4)}] set zo [expr {$zo + $lecof*($z1*$c0 + $z2*$c1 + $z3*$c2 + $z4*$c3 + $z5*$c4)}] set xout($qipk) [list $xo $yo $zo] set norms($qipk) [expr {[set norms($qipk)] + $lecof}] } incr i } for {set k 0} {$k < $km-1} {incr k} { set xout($k) [V_VS [set xout($k)] / [set norms($k)]] } foreach k [lsort -integer [array names xout]] { lappend Lo [set xout($k)] } return $Lo } proc LissageParFenetre {Lx wdt} { if {! ($wdt % 2)} { FaireLire "Smoothing coefficient should be odd !" return } set w [expr {($wdt-1)/2}] set l [llength $Lx] for {set i 0} {$i < $l} {incr i} { set d [expr {$i - $w}] set f [expr {$i + $w}] set ax 0.0 set n 0 foreach x [lrange $Lx $d $f] { set ax [expr {$ax + $x}] incr n } set nx [expr {$ax/$n}] lappend newx $nx } return $newx } proc LisseCourbe {l {w 3}} { if {[llength $l] < $w} {return 0} set rst [expr $w/2. - $w/2] if {! $rst} {incr w} set rst [expr $w/2] for {set i 0} {$i < $rst} {incr i} { lappend res [lindex $l $i] } # -1 dans test while car commence a 0 !! set n 1 while {$n <= [expr [llength $l]-$rst-1]} { set p 0. for {set i -$rst} {$i <= $rst} {incr i} { set ix [expr $n + $i] set v [lindex $l $ix] set p [expr $p + $v] } set p [expr $p/$w.] lappend res $p incr n } incr rst -1 for {set i $rst} {$i >= 0} {incr i -1} { lappend res [lindex $l end-$i] } return $res } proc ListBlastong {} { } proc ListEqual {A B} { if {[llength $A]!=[llength $B]} { return 0 } foreach a $A b $B { if {[set L [llength $a]]!=[llength $b]} { return 0 } if {$L>1} { if { ! [ListEqual $a $b]} { return 0 } } else { if {$a != $b} { return 0 } } } return 1 } proc ListFromSerial {Texte} { return [ListFromSeriallist [SeriallistFromSerial $Texte]] } proc ListFromSeriallist {Liste} { set L {} foreach {K V} [lindex $Liste 1] { lappend L [ValueFromSeriallist $V] } return $L } proc ListMix {MainList args} { if {[lindex $args 0]=="WithLists"} { set args [lindex $args 1] } set Nu 0 foreach {Op Li} $args { incr Nu foreach E $Li { set IsIn($Nu,$E) 1 } } set LesBons $MainList set Nu 0 foreach {Op Li} $args { incr Nu set LesNouveaux {} foreach E $LesBons { if {$Op=="In" && [info exists IsIn($Nu,$E)]} { lappend LesNouveaux $E } if {$Op=="No" && ! [info exists IsIn($Nu,$E)]} { lappend LesNouveaux $E } } set LesBons [lsort -unique $LesNouveaux] } return $LesBons } proc ListOfChr {{Premier ""} {Dernier ""}} { if {$Premier==""} { set Premier 1 } if {$Dernier==""} { set Dernier 25 } set LesChr {} foreach N [NombresEntre $Premier $Dernier] { set NN [format "%2.2d" $N] set Chr "Chr$NN" lappend LesChr $Chr } return $LesChr } proc ListOfCompulsoryGenes {} { foreach Nom [ListeDesPABs] { set Status [ExtraitInfo $Nom "Status"] set Status [string range $Status 0 [expr [string first "(" $Status] - 1]] if {$Status!="compulsory"} {continue} lappend ListOfCompulsoryGenes $Nom } return $ListOfCompulsoryGenes } proc ListOfEBIDatabases {} { # databanses list : # http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/database # set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/database" set Lxml [HttpCopy $url] set RId [dom parse $Lxml] set doc [$RId documentElement] puts "\nDatabase Name <-> keyword" foreach nd [$doc selectNodes //values/value] { set db [$nd selectNode string(./label)] set vl [$nd selectNode string(./value)] puts "$db <-> $vl" } exit } proc ListOfGenesWith {Key Value args} { set LesR {} foreach Nom [ListeDesPABs] { set K "$Key:" set V [ExtraitInfo $Nom $K] if {[regexp {^RX_(.*)} $Value Match VV]} { if { ! [regexp $VV $V]} { continue } } else { if {$V!=$Value} { continue } } set R $Nom if {$args=={}} { lappend LesR $Nom ; continue } set LesInfos {} foreach I $args { lappend LesInfos [ExtraitInfo $Nom $I] } lappend LesR [join $LesInfos "\t"] } set LesR [lsort -unique $LesR] return $LesR } proc ListSeria {Texte} { return [eval list $Texte] } proc ListTranspose {LL} { #rR LL peut avoir des lignes de longueurs différentes #rR On est obligé de passer par un tableau à 2 dimensions set MaxICol -1 set iLig 0 foreach Ligne $LL { set iCol 0 set LesCol {} foreach e $Ligne { lappend LesCol $iCol lappend T($iLig,$iCol) $e incr iCol } set MaxICol [expr max($MaxICol,[llength $LesCol]-1)] incr iLig } set MaxILig [expr $iLig-1] set N {} set Vide "NA" foreach iCol [NombresEntre 0 $MaxICol] { set Colonne {} foreach iLig [NombresEntre 0 $MaxILig] { if {[info exists T($iLig,$iCol)]} { lappend Colonne $T($iLig,$iCol) } else { lappend Colonne $Vide } } Espionne $Colonne lappend N $Colonne } return $N } proc Liste {FichierOui FichierNon} { #FichierOui: ListeDesGenesAuxProfilsCorreles #FichierNon: ListeDesGenesAuxProfilsOpposes foreach Ligne [LesLignesDuFichier $FichierOui] { if {$Ligne==""} {continue} set LesChamps [split $Ligne "\t"] set FoldAffy [lindex $LesChamps 36] set FoldDD [lindex $LesChamps 16] if {($FoldAffy>0 && $FoldDD<0) || ($FoldAffy<0 && $FoldDD>0)} { continue } lappend Liste $Ligne } Espionne [llength $Liste] foreach Ligne [LesLignesDuFichier $FichierNon] { if {$Ligne==""} {continue} lappend Liste $Ligne } Espionne [llength $Liste] #SauveLesLignes $Liste dans "[RepertoireDuGenome]/OVERLAP931NEW/ListePourFig3A" } proc Liste489 {} { set Fichier "[RepertoireDuGenome]/essaipoub2" set LesEVIs {} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" Nom lappend LesEVIs $Nom Espionne $Nom } foreach x $LesEvis { puts $x } } proc ListeChroDebutFinNom {} { #a lancer dans /AffyTarget par exemple pour proc ci-dessus #car le RepertoireDuGenome est different if { ! [file exists "[RepertoireDuGenome]/fiches"]} { File mkdir "[RepertoireDuGenome]/fiches" } #set FichierDesClonesEnOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap" set FichierBestLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" if {![file exists $FichierBestLoc]} {return "I need $FichierBestLoc"} set LesLocsNom {} foreach Nom [ListeDesPABs] { set Loc [InterrogeLocalisation $FichierBestLoc Nom $Nom] if {$Loc==""} {continue} #polyloc: if {[llength $Loc]>=2} {continue} set Loc [join $Loc ""] set Chro [lindex $Loc 9] set DSurChro [lindex $Loc 10] set FSurChro [lindex $Loc 11] if {$Chro==""} {Espionne $Nom} lappend LesLocsNom "$Chro $DSurChro $FSurChro $Nom" } Espionne [llength $LesLocsNom] SauveLesLignes $LesLocsNom dans "[RepertoireDuGenome]/Localisation/listepouroverlapavecdd" } proc ListeChroDebutFinNom_New {} { #en utilisant cette fois le fichier NuctfaLocalisation_Human_Best #cree a partir des cartes exoniques #comme si la seq ncutfa etait un mRNA... #a lancer dans /AffyTarget par exemple pour proc ci-dessus #car le RepertoireDuGenome est different if { ! [file exists "[RepertoireDuGenome]/fiches"]} { File mkdir "[RepertoireDuGenome]/fiches" } #set FichierDesClonesEnOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap" set FichierBestLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" set FichierNew "[RepertoireDuGenome]/Localisation/NuctfaLocalisation_Human_Best" if {![file exists $FichierBestLoc]} {return "I need $FichierBestLoc"} set LesLocsNom {} foreach Nom [ListeDesPABs] { set Loc [InterrogeLocalisation $FichierNew Nom $Nom] if {$Loc==""} { set Loc [InterrogeLocalisation $FichierBestLoc Nom $Nom] } if {$Loc==""} {continue} #polyloc: if {[llength $Loc]>=2} {continue} set Loc [join $Loc ""] set Chro [lindex $Loc 9] set DSurChro [lindex $Loc 10] set FSurChro [lindex $Loc 11] if {$Chro==""} {Espionne $Nom} lappend LesLocsNom "$Chro $DSurChro $FSurChro $Nom" } Espionne [llength $LesLocsNom] #SauveLesLignes $LesLocsNom dans "[RepertoireDuGenome]/Localisation/listepouroverlapavecdd" SauveLesLignes $LesLocsNom dans "[RepertoireDuGenome]/Localisation/listepouroverlapavecdd_new" } proc ListeCompressee {liste} { set olde "HolaTriouPoilAuGenou" foreach e [lsort $liste] { if { $e != $olde } { lappend Compresse $e set olde $e } } return $Compresse } proc ListeCompulsoryEVImm {} { set i 0 set Liste [ListeDesPABs] foreach Nom $Liste { set Status [ExtraitInfo $Nom "Status"] if {[regexp "^compulsory" $Status]} { incr i set GnP [ExtraitInfo $Nom "ValiGNProt"] set Prot [ExtraitInfo $Nom "IdAccProt"] if {$GnP=="" || $GnP=="no value"} {set GnP [ExtraitInfo $Nom "ValiGN"]} lappend LesLignes "$GnP $Prot" } } set LesLignes [EnleveLignesVides $LesLignes] set LesLignes [ListeSansDoublon $LesLignes] SauveLesLignes $LesLignes dans "/home/poidevin/ordi/MS2PHProt/LesRetinalForSm2PH" } proc ListeCompulsoryPourRavi {} { set LesLignesExl [NomLigne ListeDes Lignes] foreach LigneExl $LesLignesExl { set TousLesNoms [NomLigne $LigneExl Noms] set ListeDesNoms [split $TousLesNoms " "] set NbDeNomPrUneLigne [llength $ListeDesNoms] if {$NbDeNomPrUneLigne==1} { set BonneListeDesNoms $ListeDesNoms } if {$NbDeNomPrUneLigne>1} { set BonneListeDesNoms [split [RangeMoi get EviOf $LigneExl] " "] } foreach Nom $BonneListeDesNoms { set Status [ExtraitInfo $Nom "Status"] set Status [string range $Status 0 [expr [string first "(" $Status] - 1]] if {[regexp "optional" $Status]} {continue} set Gn [ExtraitInfo $Nom "ValiGN"] set AccessmRNA [AccessEvi $Nom] set LesProbeSetId {} foreach ProbeSetId [lsort -unique [AffyAnno $AccessmRNA "Probe_Set_ID"]] { lappend LesProbeSetId $ProbeSetId } set Ps [join $LesProbeSetId ","] #set Ps [ExtraitInfo $Nom "ProbeSetId"] set Ligne "$Nom $Gn $Ps" lappend LesLignes $Ligne } } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/ListePourRavi/ListeCompulsory" } proc ListeControles {} { Wup "Rend la liste des controles choisis pour le premier design" set MaListe [list BC008848 ECOL0658 HUMTUBAK NM_006013 X53416 BC013310 ECOL3535 L05092 NM_018955] return $MaListe } proc ListeControlesActiChip {} { Wup "Liste des controles pour la puce ActiChip" global ListeControlesActiChip if {[info exists ListeControlesActiChip]} { return $ListeControlesActiChip } else { set ListeControlesActiChip "" set Dir "[RepertoireDuGenome]/Probes/Controles_ActiChip/RefSeq_Controles" set LesFichiers [glob -nocomplain -directory $Dir "*.masked"] regsub -all ".masked" $LesFichiers "" LesFichiers foreach F $LesFichiers { lappend ListeControlesActiChip [file tail $F] } } return $ListeControlesActiChip } proc ListeDeBoites {} { global ListeDeBoites if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites } return $ListeDeBoites } proc ListeDes1500AffyPs {} { set LesLignes {} foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/Arnaud/nuctfa1500Final/*"] { set Nom [file tail $Fichier] set Ligne "" set AccessmRNA [AccessEvi $Nom] set Gn [ExtraitInfo $Nom "ValiGN"] set LesProbeSetId {} foreach ProbeSetId [lsort -unique [AffyAnnoMG430 $AccessmRNA "Probe_Set_ID"]] { lappend LesProbeSetId $ProbeSetId } if {$LesProbeSetId=={}} { set PSI "novalue" } else { set PSI [join $LesProbeSetId ","] } set Ligne "$Nom $AccessmRNA $Gn $PSI" Espionne "$Ligne" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/NomPsMG430" } proc ListeDes945PABsPourBlastAffy {FichierSortie} { #247 set Fichier247 "[RepertoireDuGenome]/fiches/Les247SansProtNiLoc" foreach Ligne [LesLignesDuFichier $Fichier247] { if {$Ligne==""} {continue} set Vu($Ligne) 1 } #25 set Fichier25 "[RepertoireDuGenome]/fiches/Les25ProtNotHumanNotLocated" foreach Ligne [LesLignesDuFichier $Fichier25] { if {$Ligne==""} {continue} set Vu($Ligne) 1 } foreach Nom [ListeDesPABs] { if {![info exists Vu($Nom)]} {lappend L $Nom} } Espionne [llength $L] set Ltriee [lsort -unique $L] Espionne [llength $Ltriee] SauveLesLignes $Ltriee dans $FichierSortie } proc ListeDesARNs {} { global ListeDesARNs if { ! [info exists ListeDesARNs]} { ChargeLesARNs } return $ListeDesARNs } proc ListeDesAccessPresentsDansLeMACSDeLaFamille {Famille} { Wup "Permet de rendre la liste des sequences presentes dans les MACS de references" Wup "ATTENTION on ne se base pas sur les .rsf mais sur les fichiers TFA" global TabMACS set RepARP "[RepARPAnno]" set RepMACS "$RepARP/ARP_MACS" set MACSDeRef "$RepMACS/${Famille}.rsf" set TFAMACSDeRef "$RepMACS/${Famille}.tfa" if {[info exists TabMACS] && [info exists TabMACS($Famille)]} { return "[set TabMACS($Famille)]" } if {! [file exists $TFAMACSDeRef]} {return ""} set LesAccess "" set F [open "$TFAMACSDeRef"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {[string first ">" $Ligne]=="0"} { set Entete "" set EnteteSplitee "" set Access "" set Entete $Ligne regsub -all "^>" $Entete "" Entete set EnteteSplitee [split $Entete " "] set Access [lindex $EnteteSplitee 0] lappend LesAccess $Access continue } continue } close $F set TabMACS($Famille) [lsort -unique $LesAccess] if {[info exists TabMACS] && [info exists TabMACS($Famille)]} { return "[set TabMACS($Famille)]" } return "" } proc ListeDesBlastnesthumanTODO {} { foreach Nom [ListeDesPABs] { Espionne $Nom set FichierBlastESThum "[RepertoireDuGenome]/blastnest/$Nom" if {![file exists $FichierBlastESThum]} { if {[file exists "[RepertoireDuGenome]/nucmask_SansBoutPlasmide/$Nom"]} { exec gscope yes BlastNPourTous est-human $Nom "[RepertoireDuGenome]/nucmask_SansBoutPlasmide" } else {exec gscope yes BlastNPourTous est-human $Nom "[RepertoireDuGenome]/nucmask"} } } } proc ListeDesBoxCibles {} { set File "/genomics/link/SpliRetMouse/CibleNaomi17092010/CibleFromNaomi_17092010.csv" foreach Ligne [LesLignesDuFichier $File] { foreach {IdOrg ClusterId} [split $Ligne ";"] { set ClusterId "cluster_$ClusterId" if {$IdOrg == "SPR"} { set Box [QuestionDeScience SpliRetRat "ret InterrogeBox $ClusterId Box"] if {$Box==""} {continue} lappend LesBoxSPR $Box } if {$IdOrg == "SPM"} { set Box [QuestionDeScience SpliRetMouse "ret InterrogeBox $ClusterId Box"] if {$Box==""} {continue} lappend LesBoxSPM $Box } } } SauveLesLignes "$LesBoxSPR" dans "/genomics/link/SpliRetMouse/CibleNaomi17092010/ListeBoxSPRCible" SauveLesLignes "$LesBoxSPM" dans "/genomics/link/SpliRetMouse/CibleNaomi17092010/ListeBoxSPMCible" } proc ListeDesChromosomesHS {} { set Liste [list HS01 HS02 HS03 HS04 HS05 HS06 HS07 HS08 HS09 HS10 HS11 HS12 HS13 HS14 HS15 HS16 HS17 HS18 HS19 HS20 HS21 HS22 HSX HSY HSUN] return $Liste } proc ListeDesCourtsEtDesSans {} { set LesCourts [ListeLesTropCourts 25] set LesSans [ListeLesSansRien] set ListeTotale [concat $LesCourts $LesSans] #Espionne "total: [llength $ListeTotale]" set ListeTotaleTriee [lsort -increasing -index 0 $ListeTotale ] SauveLesLignes $ListeTotaleTriee dans "[RepertoireDuGenome]/fiches/ListeDesCourtsEtDesSansTriee" } proc ListeDesDDAExclure {FichierDesAExclure} { #FichierDesAExclure = "[RepertoireDuGenome]/fiches/18nolocavecgb" #ou bien : FichierDesAExclure = "[RepertoireDuGenome]/fiches/Les247SansProtNiLoc" foreach DD [ListeDesJR $FichierDesAExclure] { set Vu($DD) 1 } set FichierRedondance1SansCourts "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $FichierRedondance1SansCourts] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { if {[info exists Vu($DD)]} {lappend LesLignesAExclure $Ligne} } } return $LesLignesAExclure } proc ListeDesDDSansLes247SansHomology {Fichier247 Fichier1195AChanger} { foreach Ligne [LesLignesDuFichier $Fichier247] { if {$Ligne==""} {continue} set Ligne [string trim $Ligne] #Espionne $Ligne set Vu($Ligne) 1 } set n 0 foreach Ligne [LesLignesDuFichier $Fichier1195AChanger] { if {$Ligne==""} {continue} set Ligne [string trim $Ligne] if {![info exists Vu($Ligne)]} {lappend L $Ligne} else {incr n} } Espionne $n Espionne [llength $L] SauveLesLignes $L dans "[RepertoireDuGenome]/fiches/948" } proc ListeDesDatasets {} { return [$::db eval {select distinct dataset from file}] } proc ListeDesDifferentiellementExprimesSansJumeaux {Affy} { if {$Affy=="target"} { set Fichier "[GscopeDatabaseDir AffyTarget]/ListeDesTargetsDifferentiellementExprimeesSansJumeaux" if {![file exists $Fichier]} {return ""} set Contenu [ContenuDuFichier $Fichier] set LesCodes [split $Contenu "\n"] } else { set Fichier "[GscopeDatabaseDir AffyHS]/ListeDesDifferentiellementExprimesSansJumeaux" if {![file exists $Fichier]} {return ""} set Contenu [ContenuDuFichier $Fichier] set LesCodes [split $Contenu " "] } set NbCodes [llength $LesCodes] #FaireLire $NbCodes return $LesCodes } proc ListeDesEntreesDuBlast {FichierBlast} { set Query [AskBlast $FichierBlast Query] set LesMots [split $Query "|"] set AccessQuery [lindex [split $Query "|"] 1] #gscope putl LaSequenceDesBanques /genomics/link/EVImm/nuctfa/EVI14790 #gscope putl LaSequenceDesBanques NM_027328 #set BIdQuery "REFSEQ:$AccessQuery" #lappend LesBId $BIdQuery set TFAQuery [LaSequenceDesBanques $AccessQuery] set TFAQuery [join $TFAQuery "\n"] set NbSujet [AskBlast $FichierBlast NbSubject] for {set i 1} {$i <= $NbSujet} {incr i} {lappend LesBId [AskBlast $FichierBlast Subject $i]} set Selection [join $LesBId "\n"] set FastaDuBlast2 "/genomics/link/EVImm/prpf31/gene/FastaDuBlast2" Espionne $Selection set TFAs [ConcatLesTFAs $Selection] Espionne $TFAs Sauve $TFAs dans $FastaDuBlast2 AppendAuFichier $FastaDuBlast2 $TFAQuery } proc ListeDesFamilles {} { set LesFamilles {} foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/xhda/famille/*.fam"] { set Queue [file tail $Fichier] regsub ".fam$" $Queue "" Famille lappend LesFamilles $Famille } return $LesFamilles } proc ListeDesFeaturesUtilisees {} { if {! [info exists ::LFeatCourantes]} { set ::LFeatCourantes {} } return $::LFeatCourantes } proc ListeDesFusions {} { global ListeDesFusions global ListeDeBoites if {[info exists ListeDesFusions]} { return $ListeDesFusions } set FichierBornesDesFusions "[RepertoireDuGenome]/fiches/bornesdesfusions" if { ! [file exists $FichierBornesDesFusions]} { set ListeDesFusions {} return $ListeDesFusions } foreach Ligne [LesLignesDuFichier $FichierBornesDesFusions] { if { ! [regexp -nocase {[a-z]} $Ligne]} {continue} ExtraireDe $Ligne Nom Debut Fin Orient Box $Nom nom $Nom Box $Nom debut $Debut Box $Nom fin $Fin Box $Nom orient $Orient if {$Orient=="F"} { Box $Nom frame "T" } else { Box $Nom frame "t" } lappend ListeDesFusions $Nom lappend ListeDeBoites $Nom } return $ListeDesFusions } proc ListeDesGLIMMERs {} { global ListeDesGLIMMERs if { ! [info exists ListeDesGLIMMERs]} { ChargeLesGLIMMERs } return $ListeDesGLIMMERs } proc ListeDesJR {FichierClusters} { set LesJR {} foreach Ligne [LesLignesDuFichier $FichierClusters] { if {$Ligne!=""} { scan $Ligne "%s" JR lappend LesJR "$JR" } } set NbJR [llength $LesJR] #Espionne "nb JR = $NbJR" return $LesJR } proc ListeDesJumeauxQuiRestentSelonLeurLocalisation {} { #attention je change jumeaux pour que proc jumeaurepresentatif marche #desormais jumeaux=jumeaux_Overlap set FichierDes623 "/genomics/link/HeadNecknonrnr/fiches/ListeDesSansProtSansJumeaux" foreach Ligne [LesLignesDuFichier $FichierDes623] { set Nom [lindex $Ligne 0] if {[JumeauRepresentatif $Nom]==$Nom || [JumeauRepresentatif $Nom]==""} { lappend ListeSansJumeaux $Nom } } return [llength $ListeSansJumeaux] } proc ListeDesJumeauxRepresentatifs {} { return [JumeauRepresentatif "LaListeMerci"] } proc ListeDesMatrices {} { return [$::db eval {select distinct matrix from analyse}] } proc ListeDesMotiflen {} { return [$::db eval {select distinct motiflen from analyse}] } proc ListeDesNews {} { Wup "Rend la liste des nouvelles sequences a designee" set Liste [ListeDesPABs] #set Liste [lrange $Liste 1164 2437] set LesPABs "" foreach PAB $Liste { set Numero "" regsub {^ACT[0]{0,3}} $PAB "" Numero if {$Numero > 1164 && $Numero < 2439} { lappend LesPABs $PAB #Espionne "$PAB -- $Numero" } } return "$LesPABs" } proc ListeDesNumerosDesChromosomes {} { set Liste [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y UN] return $Liste } proc ListeDesOligosRestreints {args} { Wup "Permet de retourner une liste d oligo contenant des criteres bien definis" set ListeOligos "" #CutOff pour limiter l affichage si besoin est ############################################## #set LesCutOffs [list GC Tm ExpTm XDebutDeOligoNt XFinDeOligoNt NbCandidats NbContigues NbUnrelated LesCandidats] set LesCutOffs [lindex $args 1] set FichierACharger [lindex $args 0] set LesOligos [InterrogeInfoDeLOligo $FichierACharger LesNoms] foreach NomOligo $LesOligos { #set NomOligo [InterrogeInfoDeLOligo $FichierACharger [lindex $UnDebutFinDeOligo 0] [lindex $UnDebutFinDeOligo 1] NomOligo] #set LaSequence [InterrogeInfoDeLOligo $FichierACharger $NomOligo Sequence] #set TailleOligo [InterrogeInfoDeLOligo $FichierACharger $NomOligo Taille] #set GC [InterrogeInfoDeLOligo $FichierACharger $NomOligo GC] set Tm [InterrogeInfoDeLOligo $FichierACharger $NomOligo Tm] #set ExpTm [InterrogeInfoDeLOligo $FichierACharger $NomOligo ExpTm] set XDebutDeOligoNt [InterrogeInfoDeLOligo $FichierACharger $NomOligo Debut] set XFinDeOligoNt [InterrogeInfoDeLOligo $FichierACharger $NomOligo Fin] set NbCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbCandidats] set NbContigues [InterrogeInfoDeLOligo $FichierACharger $NomOligo NbContigues] #set LesCandidats [InterrogeInfoDeLOligo $FichierACharger $NomOligo LesCandidats] #Comparaison des criteres de l oligo avec les cutoffs demandes set KO 0 set Result 1 foreach CutOff $LesCutOffs { if {$KO == "1"} {continue} set Result [CheckForRestrictedParameter [set $CutOff] $CutOff] if {$Result=="0"} { set KO 1 } } if {$KO == "1"} { continue } else { lappend ListeOligos [list $NomOligo $Tm $XDebutDeOligoNt $NbCandidats] } } return "$ListeOligos" } proc ListeDesOrganismesAyantMemeOperon {Nom} { global LesOrganismesAyantMemeOperon if { ! [info exists LesOrganismesAyantMemeOperon] } { ChargeLesOrganismesAyantMemeOperon } if { [info exists LesOrganismesAyantMemeOperon($Nom)] } { return [set LesOrganismesAyantMemeOperon($Nom)] } else { return {} } } proc ListeDesPABs {{NouveauPAB ""}} { global ListeDesPABs if { ! [info exists ListeDesPABs]} { ChargeLesPABs } if {$NouveauPAB!="" && [lsearch -exact $ListeDesPABs $NouveauPAB]<0} { lappend ListeDesPABs $NouveauPAB } return $ListeDesPABs } proc ListeDesPABs2 {{NouveauPAB ""}} { global ListeDesPABs if { ! [info exists ListeDesPABs]} { ChargeLesPABs2 } if {$NouveauPAB!="" && [lsearch -exact $ListeDesPABs $NouveauPAB]<0} { lappend ListeDesPABs $NouveauPAB } return $ListeDesPABs } proc ListeDesPABsAffy {} { set L [] } proc ListeDesPABsSansLesSequencesCourtes {FichierPABsSansJumeauxSeq FichierSortie} { #sequence courte = sequence de moins de 25 bases (A/T/G/C) #necessaire car il y a une sequence vide #et les sequences de moins de 9 nucleotides ne sont pas blastees set n 0 set L [CreeListePourFichierAUneColonne $FichierPABsSansJumeauxSeq] foreach DD $L { set FichierMRM "[RepertoireDuGenome]/nucmask/$DD" if {[file exists $FichierMRM]} { set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM] #set L [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN set LSansN [string length $SeqMRMSansN] if {$LSansN>=25} { AppendAuFichier $FichierSortie "$DD" } else {incr n} } else { Espionne "$FichierMRM doesn't exist" } } return $n } proc ListeDesPABsSansLesSequencesEnDouble {FichierPABs2467 FichierSortie} { #proc JumeauRepresentatif de RR appelle le fichier /fiches/jumeaux #ici, le fichier jumeaux est une copie du fichier fiches/jumeaux_SeqNuc set n 0 set L [CreeListePourFichierAUneColonne $FichierPABs2469] foreach Nom $L { if {[JumeauRepresentatif $Nom]!="" && [JumeauRepresentatif $Nom]!=$Nom} {incr n; continue} AppendAuFichier $FichierSortie "$Nom" } return $n } proc ListeDesPDBDB {} { return [lsort -unique [$::db eval {select nom from pdb}]] } proc ListeDesPipeAlignARefaire {} { foreach Nom [ListeDesPABs] { set FichierProtffa "[RepertoireDuGenome]/prottfa/$Nom" set FichierMSF "[RepertoireDuGenome]/msf/$Nom" if {[file exists $FichierProtffa] && ![file exists $FichierMSF]} { lappend Liste $Nom } } Espionne [llength $Liste] set Liste [lsort -unique $Liste] Espionne [llength $Liste] Espionne $Liste #SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/LesMSFaFaire" } proc ListeDesRhos {} { Wup "Rend la liste des nouvelles sequences de la categorie des Rho a designee" set Liste [ListeDesPABs] #set Liste [lrange $Liste 2438 end] set LesPABs "" foreach PAB $Liste { set Numero "" regsub {^ACT[0]{0,3}} $PAB "" Numero if {$Numero > 2438} { lappend LesPABs $PAB #Espionne "$PAB -- $Numero" } } return "$LesPABs" } proc ListeDesScores {} { return [$::db eval {select distinct score from analyse}] } proc ListeDesTRNAs {} { global ListeDesTRNAs if { ! [info exists ListeDesTRNAs]} { ChargeLesTRNAs } return $ListeDesTRNAs } proc ListeDesTROUs {} { global ListeDesTROUs if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs } return $ListeDesTROUs } proc ListeLes1220 {FichierJumeauxFinal FichierSortie} { foreach Ligne [LesLignesDuFichier $FichierJumeauxFinal] { if {$Ligne==""} {continue} set LesDD [split $Ligne " "] set JR [lindex $LesDD 0] lappend Liste $JR foreach DD $LesDD { set Vu($DD) 1 } } Espionne [llength $Liste] set n 0 foreach Nom [ListeDesPABs] { if {![info exists Vu($Nom)]} {lappend Liste $Nom; incr n} } Espionne $n Espionne [llength $Liste] #verif no doublons set L [lsort -unique $Liste] Espionne [llength $L] SauveLesLignes $L dans $FichierSortie } proc ListeLesCodesClones {} { set Fichier "/home/carles/genomes/DD2/S1codesJ.txt" set MauvaisCodes "" foreach Ligne [LesLignesDuFichier $Fichier] { regsub -all -nocase {\s} $Ligne " " Ligne set LesCodes [split $Ligne " "] foreach Code $LesCodes { append MauvaisCodes "$Code\n" } } return $MauvaisCodes } proc ListeLesDDAvecProteineHuman {FichierSortie} { set n 0 foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {continue} incr n #Espionne $DD set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] if {[regexp "from CONTIG" $EnteteProttfa]} { if {[regexp "from Homo sapiens from CONTIG" $EnteteProttfa]} {lappend Liste $DD} } elseif {[regexp "from Homo sapiens" $EnteteProttfa] || [regexp "from mitochondrion Homo" $EnteteProttfa]} {lappend Liste $DD} } Espionne "nb pabs avec pro: $n" Espionne "nb prot human: [llength $Liste]" set L [lsort -unique $Liste] Espionne "nb prot human u:[llength $L]" foreach Nom $L { set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNAHs]} {lappend LesNotHuman $Nom} else {lappend LesHumanHomolog $Nom} } Espionne "nb no mrnatfahuman: [llength $LesNotHuman] - nb avec mrnatfahuman: [llength $LesHumanHomolog]" exit #SauveLesLignes $ListeTriee dans $FichierSortie foreach Nom $LesNotHuman { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} else {lappend LesNoLoc $Nom} } Espionne "[llength $LesNoLoc] noloc" set L [lsort -unique $LesNoLoc] Espionne [llength $L] SauveLesLignes $L dans $FichierSortie #exit #Espionne "[llength $LesLocalises] localises " #return $LesLocalises Espionne [llength [lsort -unique $LesNotHuman]] foreach Nom $LesNoLoc { set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess] if {$EST!=""} {lappend LesEST $Nom} } Espionne $LesEST Espionne [llength $LesEST] set Ltriee [lsort -unique $LesEST] Espionne [llength $Ltriee] foreach Nom $LesNoLoc { set NM [InterrogeFichierBestNMavecDef $FichierBestOverlapAvecDef $Nom NM] if {$NM=="" || $NM==" "} {lappend LesSansRefSeq $Nom} else {Espionne "avec nm: $Nom $NM"} } Espionne [llength $LesSansRefSeq] set L [lsort -unique $LesSansRefSeq] Espionne [llength $L] } proc ListeLesDDAvecProteineHuman_avecbest {} { set n 0 foreach DD [ListeDesPABs] { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} { incr n lappend Liste $DD set FichierProtHs "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProtHs]} {Espionne "$FichierProtHs doesn t exist"} set IdProt [InterrogeBestProteinAndmRNAForeachOrga $DD Access $AccBestProtHuman Identity] if {$IdProt>=0.8} {lappend LesHumanHomolog $DD} else {lappend LesHumanhomologIdFaible $DD} } else {lappend LesSans $DD} } Espionne "nb prot human: $n" Espionne "nb avec bestprothuman: [llength $Liste]" Espionne "nb sans bestprothuman: [llength $LesSans]" Espionne "nb prot human >0.8:[llength $LesHumanHomolog]" set Ls [lsort -unique $LesHumanHomolog] Espionne "nb prot human u >0.8:[llength $Ls]" Espionne "nb prot human <0.8:[llength $LesHumanhomologIdFaible]" set Li [lsort -unique $LesHumanhomologIdFaible] Espionne "nb prot human u:[llength $Li]" exit foreach Nom $Liste { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccBestmRNAHuman!=""} { set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNAHs]} {Espionne "$FichiermRNAHs doesn t exist"} set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccBestmRNAHuman Identity] if {$IdmRNA>=0.8} {lappend LesHuman $Nom} else {lappend LesHumanIdFaible $Nom} } else {lappend LesNotHuman $Nom} } Espionne "nb no mrnatfahuman: [llength $LesNotHuman] - nb avec mrnatfahuman >80: [llength $LesHuman] - nb best mrna<.8: [llength $LesHumanIdFaible]" } proc ListeLesDDAvecProteineNotHuman {FichierLoc FichierEST FichierBestOverlapAvecDef FichierSortie} { set n 0 foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {continue} incr n set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] if {[regexp "from CONTIG" $EnteteProttfa]} { if {![regexp "from Homo sapiens from CONTIG" $EnteteProttfa]} {lappend Liste $DD} } elseif {![regexp "from Homo sapiens" $EnteteProttfa] && ![regexp "from mitochondrion Homo" $EnteteProttfa]} {lappend Liste $DD} } Espionne "n avec prot: $n" Espionne "n prot no human: [llength $Liste]" set L [lsort -unique $Liste] Espionne "n prot no human: [llength $L]" foreach Nom $L { set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNAHs]} {lappend LesNotHuman $Nom} else {lappend LesHumanHomolog $Nom} } Espionne "nb no mrnatfahuman: [llength $LesNotHuman] - nb avec mrnatfahuman: [llength $LesHumanHomolog]" Espionne $LesHumanHomolog exit set LesNoLoc "" foreach Nom $LesNotHuman { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} else {lappend LesNoLoc $Nom} } Espionne "[llength $LesNoLoc] noloc" set L [lsort -unique $LesNoLoc] Espionne [llength $L] SauveLesLignes $L dans $FichierSortie #exit #Espionne "[llength $LesLocalises] localises " #return $LesLocalises #Espionne [llength [lsort -unique $LesNotHuman]] foreach Nom $L { set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess] if {$EST!=""} {lappend LesEST $Nom} } Espionne $LesEST Espionne [llength $LesEST] set Ltriee [lsort -unique $LesEST] Espionne [llength $Ltriee] #exit foreach Nom $L { set NM [InterrogeFichierBestNMavecDef $FichierBestOverlapAvecDef $Nom NM] if {$NM=="" || $NM==" "} {lappend LesSansRefSeq $Nom} else {Espionne "avec nm: $Nom $NM"} } Espionne [llength $LesSansRefSeq] set L [lsort -unique $LesSansRefSeq] Espionne [llength $L] } proc ListeLesDDAvecProteineNotHuman_avecbest {} { set n 0 foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {continue} incr n set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] if {[regexp "from CONTIG" $EnteteProttfa]} { if {![regexp "from Homo sapiens from CONTIG" $EnteteProttfa]} {lappend Liste $DD} } elseif {![regexp "from Homo sapiens" $EnteteProttfa] && ![regexp "from mitochondrion Homo" $EnteteProttfa]} {lappend Liste $DD} } Espionne "n avec prot: $n" Espionne "n prot no human: [llength $Liste]" set L [lsort -unique $Liste] Espionne "n prot no human: [llength $L]" foreach Nom $L { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccBestmRNAHuman!=""} { set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNAHs]} {Espionne "$FichiermRNAHs doesn t exist"} set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccBestmRNAHuman Identity] if {$IdmRNA>=0.8} {lappend LesHumanHomolog $Nom} else {lappend LesHumanhomologIdFaible $Nom} } else {lappend LesNotHuman $Nom} } Espionne "n avec best human mrna>0.8: [llength $LesHumanHomolog] -<0.8: [llength $LesHumanhomologIdFaible] - sans bestmrna: [llength $LesNotHuman]" } proc ListeLesDDAvecmRNAHuman_avecbest {} { set n 0 foreach DD [ListeDesPABs] { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" mRNA Access] if {$AccBestmRNAHuman!=""} { incr n lappend Liste $DD set FichiermRNAHs "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$DD" if {![file exists $FichiermRNAHs]} {Espionne "$FichiermRNAHs doesn t exist"} set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $DD Access $AccBestmRNAHuman Identity] if {$IdmRNA>=0.8} {lappend LesHumanHomolog $DD} else {lappend LesHumanhomologIdFaible $DD} } } Espionne "nb mrna human: $n"; Espionne "n besthumanmrna: [llength $Liste]" Espionne "nb mrna human >0.8:[llength $LesHumanHomolog]" set Ls [lsort -unique $LesHumanHomolog] Espionne "nb mrna human u >0.8:[llength $Ls]" Espionne "nb mrna human <0.8:[llength $LesHumanhomologIdFaible]" set Li [lsort -unique $LesHumanhomologIdFaible] Espionne "nb mrna human u:[llength $Li]" foreach Nom $Liste { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} { set FichierProtHs "[RepertoireDuGenome]/prottfa/$Nom" if {![file exists $FichierProtHs]} {Espionne "$FichierProtHs doesn t exist"} set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccBestProtHuman Identity] if {$IdProt>=0.8} {lappend LesHumanHom $DD} else {lappend LesHumanIdFaible $DD} } else {lappend LesNotHuman $Nom; Espionne $Nom} } Espionne "nb no besthumanprot: [llength $LesNotHuman] - nb avec besthumanprot >80: [llength $LesHumanHom] - nb best prot<.8: [llength $LesHumanIdFaible]" } proc ListeLesDDSansProteine {Fichiersortie} { foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {lappend Liste $DD} } Espionne [llength $Liste] set L [lsort -unique $Liste] Espionne [llength $L] SauveLesLignes $L dans $Fichiersortie } proc ListeLesDDSansProteineAvecLocSansGb {FichierLoc FichierSortie} { foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {lappend Liste $DD} } Espionne [llength $Liste] set L [lsort -unique $Liste] Espionne [llength $L] foreach Nom $L { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} } Espionne [llength $LesLocalises] set Ltriee [lsort -unique $LesLocalises] Espionne [llength $Ltriee] exit set LesNoHit "" foreach Nom $Ltriee { set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$Nom" if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue} set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0 0] if {$LesProchesGb==0} {lappend LesNoHit $Nom} #set LesCopainsGb [LesMeilleursCopainsDuBlast $Nom] #if {[regexp "No hits found" $LesCopainsGb]} {lappend LesNoHit $Nom} } Espionne [llength $LesNoHit] set L [lsort -unique $LesNoHit] Espionne [llength $L] return $L #SauveLesLignes $L dans $FichierSortie } proc ListeLesDDSansProteineNiLocNiEST {FichierLoc FichierEST FichierSortie} { #no prot. foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {lappend Liste $DD} } Espionne [llength $Liste] set L [lsort -unique $Liste] Espionne [llength $L] #no loc foreach Nom $L { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs=="" || $LesLocs==" "} {lappend LesNoLoc $Nom} } Espionne [llength $LesNoLoc] set Ltriee [lsort -unique $LesNoLoc] Espionne [llength $Ltriee] set LesNoHit "" foreach Nom $Ltriee { set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$Nom" if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue} set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0 0] if {$LesProchesGb==0} {lappend LesNoHit $Nom} else {Espionne "$Nom $LesProchesGb"} #set LesCopainsGb [LesMeilleursCopainsDuBlast $Nom] #if {[regexp "No hits found" $LesCopainsGb]} {lappend LesNoHit $Nom} } Espionne [llength $LesNoHit] set L [lsort -unique $LesNoHit] Espionne [llength $L] #no est foreach Nom $L { set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess] if {$EST==""} {lappend LesNoEST $Nom} else {Espionne "$Nom: $EST"} } Espionne [llength $LesNoEST] set Ltriee [lsort -unique $LesNoEST] Espionne [llength $Ltriee] #SauveLesLignes $L dans $FichierSortie } proc ListeLesDDSansProteineNiLocNiGb {FichierLoc FichierSortie} { foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {lappend Liste $DD} } Espionne [llength $Liste] set L [lsort -unique $Liste] Espionne [llength $L] foreach Nom $L { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs=="" || $LesLocs==" "} {lappend LesNoLoc $Nom} } Espionne [llength $LesNoLoc] set Ltriee [lsort -unique $LesNoLoc] Espionne [llength $Ltriee] set LesNoHit "" foreach Nom $Ltriee { set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$Nom" if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue} set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0 0] if {$LesProchesGb==0} {lappend LesNoHit $Nom} else {Espionne "$Nom $LesProchesGb"} #set LesCopainsGb [LesMeilleursCopainsDuBlast $Nom] #if {[regexp "No hits found" $LesCopainsGb]} {lappend LesNoHit $Nom} } Espionne [llength $LesNoHit] set L [lsort -unique $LesNoHit] Espionne [llength $L] #SauveLesLignes $L dans $FichierSortie } proc ListeLesDDSansProteinePlus {FichierBestOverlapAvecDef FichierLoc FichierEST FichierSortie} { #no prot. foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {![file exists $FichierProttfa]} {lappend Liste $DD} } Espionne [llength $Liste] set L [lsort -unique $Liste] Espionne [llength $L] exit #no loc foreach Nom $L { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] #if {$LesLocs=="" || $LesLocs==" "} {lappend LesNonLocalises $Nom} if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} } Espionne [llength $LesLocalises] set Ltriee [lsort -unique $LesLocalises] Espionne [llength $Ltriee] #SauveLesLignes $Ltriee dans $FichierSortie #exit set S 0; set n 0; set Lmini 10000; set Lmaxi 0 foreach DD $Ltriee { set FichierMRM "[RepertoireDuGenome]/nucmask/$DD" set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM] #set L [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN set LSansN [string length $SeqMRMSansN] #if {$LSansN==869} {Espionne $DD} incr n set S [expr $LSansN+ $S] if {$LSansN<$Lmini} {set Lmini $LSansN} if {$LSansN>$Lmaxi} {set Lmaxi $LSansN} } Espionne "lmin: $Lmini - lmax: $Lmaxi" #FaireLire "$S / $n" Espionne "longueur moy: [expr $S/$n]" set LesNoHit "" foreach Nom $Ltriee { #set FichierBlastGb "[RepertoireDuGenome]/blastngenembl/$Nom" #if {![file exists $FichierBlastGb]} {Espionne "$FichierBlastGb doesn't exist";continue} #set LesProchesGb [ac_LesProchesDansLeBlastBis $FichierBlastGb 0.95 0 0] #if {$LesProchesGb!=0} {lappend LesHit $Nom} set NM [InterrogeFichierBestNMavecDef $FichierBestOverlapAvecDef $Nom NM] if {$NM=="" || $NM==" "} {lappend LesSansRefSeq $Nom} else {lappend LesRS $Nom} #set LesCopainsGb [LesMeilleursCopainsDuBlast $Nom] #if {[regexp "No hits found" $LesCopainsGb]} {lappend LesNoHit $Nom} } #Espionne [llength $LesSansRefSeq] #set L [lsort -unique $LesSansRefSeq] #Espionne [llength $LesHit] #set L [lsort -unique $LesHit] Espionne "avec nm: [llength $LesRS]" set L [lsort -unique $LesRS] Espionne "avec nm: [llength $L]" Espionne $L exit #est foreach Nom $L { set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess] if {$EST==""} {lappend LesSansEST $Nom} } Espionne [llength $LesSansEST] set Ltriee [lsort -unique $LesSansEST] Espionne [llength $Ltriee] #exit #SauveLesLignes $L dans $FichierSortie } proc ListeLesDDavecProtMaisSansEST {FichierEST} { foreach Nom [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set EST [InterrogeSelectedEST $FichierEST Nom $Nom LesAccess] if {[file exists $FichierProttfa] && $EST==""} { lappend Liste $Nom } } Espionne [llength $Liste] return $Liste } proc ListeLesGenesSelectionnesEtEtudiesAvecGO {Fichier45 Fichier36 Fichier59} { # Fichier45: les 45 DD presents sur MA et selectionnes par stat # Fichier36: les 36 DD presents sur Affy avec FCDD>1 et FCAffy>3 # Fichier59: les 59 DD presents sur Affy avec FCDD>1 et FCAffy>2 # enlever les doublons (=communs) (lsort -unique) et les jumeaux (meme numgene) # -> liste totale non redondante # extraire de final ou touscomplete les lignes relatives a ces genes (go, def, hyp proteins...) foreach Ligne [LesLignesDuFichier $Fichier45] { if {$Ligne==""} {continue} lappend L $Ligne } #foreach Ligne [LesLignesDuFichier $Fichier36] { #if {$Ligne==""} {continue} #lappend L $Ligne #} foreach Ligne [LesLignesDuFichier $Fichier59] { if {$Ligne==""} {continue} lappend L $Ligne } #Espionne "l avt unique : [llength $L]" set Lu [lsort -unique $L] #Espionne "l unique : [llength $Lu]" set FichierTot "[RepertoireDuGenome]/ANALYSE/Tous_6july05" foreach DD $Lu { set n [InterrogeFichierTotalDataDD $FichierTot $DD N] if {![info exists Vu($n)]} {set Vu($n) 1; lappend Lfinale $DD} else {continue} } #Espionne "l finale sans jumeau: [llength $Lfinale]" foreach DD $Lfinale { set V($DD) 1 } set FichierFinal "[RepertoireDuGenome]/ANALYSE/finaaal_6jul05_avecMAetSel_mitoch" foreach Ligne [LesLignesDuFichier $FichierFinal] { if {$Ligne==""} {continue} set LesElts [split $Ligne "\t"] set DD [lindex $LesElts 1] if {[info exists V($DD)]} { lappend Ltout $Ligne } else { set LesJum [split [lindex $LesElts 5] " "] foreach D $LesJum { if {[info exists V($D)]} { lappend Ltout $Ligne } } } } return $Ltout } proc ListeLesInfosDeLaLocalisationSurChromosome {Nom} { global LILC if {[info exists LILC($Nom)]} { return [set LILC($Nom)] } if {[info exists LILC("EstCharge")]} { return {} } set LILC("EstCharge") 1 set Fichier "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" if {![file exists $Fichier]} {return {}} set Liste {a b c d} set Rang 0 foreach Ligne [LesLignesDuFichier $Fichier] { set ChroVu 0 set LesElementsDeLaLigne [split $Ligne "\t"] set Code [lindex $LesElementsDeLaLigne 0] foreach Element $LesElementsDeLaLigne { incr Rang if {$Rang==1} {set Code $Element} if {[regexp "HS" $Element]} { set Chro $Element set RangChro $Rang set ChroVu 1 } elseif {$ChroVu==1 && $Rang==[expr $RangChro+1]} { set Inf $Element } elseif {$ChroVu==1 && $Rang==[expr $RangChro+2]} { set Sup $Element break } } set LILC($Code) [list $Code $Chro $Inf $Sup] } return [ListeLesInfosDeLaLocalisationSurChromosome $Nom] } proc ListeLesPABsSansRien {FichierDesPABs FichierDesSansRien FichierDesInconnus FichierDesNoHuman} { #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] #localisation# set FichierLocOuPas "[RepertoireDuGenome]/fiches/LocaliseOuPas" foreach Ligne [LesLignesDuFichier $FichierLocOuPas] { if {$Ligne==""} {continue} set LesDonnees [split $Ligne "\t"] set DD [lindex $Ligne 0] set LocOuPas [lindex $Ligne 1] set Loc($DD) $LocOuPas } #est-human# set FichierEstOuPas "[RepertoireDuGenome]/fiches/ESTsOuPas" foreach Ligne [LesLignesDuFichier $FichierEstOuPas] { if {$Ligne==""} {continue} set LesDonnees [split $Ligne "\t"] set DD [lindex $Ligne 0] set ESTOuPas [lindex $Ligne 1] set Est($DD) $ESTOuPas } #proteine: set FichierProteinOuPas "[RepertoireDuGenome]/fiches/" foreach Nom $L { Espionne $Nom #Localisation# if {[info exists Loc($Nom)]} {set Loca $Loc($Nom)} else {Espionne "$Nom no_tab_loc"; set Loca 0} #Est-human# if {[info exists Est($Nom)]} {set ests $Est($Nom)} else {Espionne "$Nom no_tab_est"; set ests 0} #protein# set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] #(peut ne rien rendre: pour DD1222 par exemple qui n'existe pas) set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] if {$AccessProt=="NOPROTEIN" || $AccessProt==""} { set Prot 0 } elseif {$Orga=="Homo sapiens"} {set Prot 1} #mRNA - Genembl# set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] set Org [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] if {$AccessmRNA=="" || $AccessmRNA=="NOMRNA"} { set mRNA 0 set LesCopains [LesMeilleursCopainsDuBlast $Nom] if {$LesCopains=="" || $LesCopains=="No value" || $LesCopains=="No hits found"} { set Gb 0 } else {set Gb 1} } else {set mRNA 1; set gb 1} #bilan loc et homologie# if {$Prot==1} {} if {$Loca==0 && $Prot==0 && $mRNA==0 && $Gb==0 && $ests==0} {AppendAuFichier $FichierDesSansRien $Nom} if {$Loca==0 && $Prot==0 && $mRNA==0 && $Gb==1 && $ests==0} {AppendAuFichier $FichierDesNoHuman $Nom} if {$Loca==1 && $Prot==0 && $mRNA==0 && $Gb==0 && $ests==0} {AppendAuFichier $FichierDesInconnus $Nom} } Espionne "FIN" } proc ListeLesSansESTbisavecProt {} { #est-human# set FichierEstOuPas "[RepertoireDuGenome]/fiches/ESTsOuPas" foreach Ligne [LesLignesDuFichier $FichierEstOuPas] { if {$Ligne==""} {continue} set LesDonnees [split $Ligne "\t"] set DD [lindex $Ligne 0] set ESTOuPas [lindex $Ligne 1] set Est($DD) $ESTOuPas } foreach Nom [ListeDesPABs] { if {![info exists Est($Nom)]} {Espionne $Nom;continue} if {$Est($Nom)==0} { set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {[file exists $FichierProttfa]} {lappend Liste $Nom} } } Espionne [llength $Liste] return $Liste } proc ListeLesSansProfilsDuTout {FichierOverlapFinal} { foreach Ligne [LesLignesDuFichier $FichierOverlapFinal] { set Ligne [string trim $Ligne] if {$Ligne ==""} {continue} set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 1] #1: Exclure les affy non detectes set TAR [lindex $LesChamps 2] set Detn [lindex $LesChamps 22] set Dete [lindex $LesChamps 23] set Dets [lindex $LesChamps 24] set Detu [lindex $LesChamps 25] if {($Detn=="A" || $Detn=="M") && ($Dete=="A" || $Dete=="M") && ($Dets=="A" || $Dets=="M") && ($Detu=="A" || $Detu=="M")} { lappend LesAbsents $TAR continue } set ProfilDD [lindex $LesChamps 17] set ProfilCalcDD [lindex $LesChamps 18] set ProfilConsDD [lindex $LesChamps 19] if {($ProfilDD=="" || $ProfilDD==0) && $ProfilCalcDD=="" && ($ProfilConsDD=="" || $ProfilConsDD=="?")} {lappend Liste "$DD $ProfilDD $ProfilConsDD $ProfilCalcDD"} } Espionne [llength $Liste] return $Liste } proc ListeLesSansRien {} { set ListeNo0 {} set ListeNo1 {} set FichierLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" if {![file exists $FichierLoc]} {return "$FichierLoc doesn t exist"} foreach Nom [ListeDesPABs] { set FMRM "[RepertoireDuGenome]/nucmask/$Nom" if {![file exists $FMRM]} {return "$Nom -> pas de nucmask!"} set SeqMRM [QueLaSequenceDuFichierTFA $FMRM] regsub -all -nocase "N" $SeqMRM "" SeqSansNMRM set LApresMRM [string length $SeqSansNMRM] if {$LApresMRM>=10} { Espionne $Nom #la loc des seq DD est tellement difficile qu'il ne faut pas en tenir compte! #(polyloc) sauf si elle est nulle. Voir proc CompteLesSequencesDDBizarres set Loc [InterrogeLocalisation $FichierLoc Nom $Nom] set AccessmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "mRNA" Access] set AccessProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access] set FichierBlastnest "[RepertoireDuGenome]/blastnest-human/$Nom" if {$Loc==""} {set L 0} else {set L 1} if {$AccessmRNAHuman==""} {set R 0} else {set R 1} if {$AccessProtHuman==""} {set P 0} else {set P 1} if {$R==0 && $P==0} { if {[file exists $FichierBlastnest]} { set Test [MatchWithESTsOuiOuNon $Nom $FichierBlastnest] if {$Test==0 && $L==1} { lappend ListeNo1 $Nom AppendAuFichier "[RepertoireDuGenome]/locmaisrien75bis" $Nom } if {$Test==0 && $L==0} { lappend ListeNo0 $Nom AppendAuFichier "[RepertoireDuGenome]/seqsansrien75bis" $Nom } #if {$Test==1} {lappend ListeNoAvecEST $Nom} } else { if {$L==1} { lappend ListeNo1 $Nom AppendAuFichier "[RepertoireDuGenome]/locmaisrien75bis" $Nom } if {$L==0} { lappend ListeNo0 $Nom AppendAuFichier "[RepertoireDuGenome]/seqsansrien75bis" $Nom } } } } } #Espionne "avec est: [llength $ListeNoAvecEST]" Espionne "sans rien:[llength $ListeNo0]" Espionne "loc mais rien:[llength $ListeNo1]" return "" } proc ListeLesTropCourts {{FichierListeDesPABs ""} {SeuilLongueur 9}} { set Liste {} if {$FichierListeDesPABs==""} { foreach Nom [ListeDesPABs] { #proc JumeauRepresentatif de RR appelle le fichier jumeaux #ici, vaut mieux que le fichier jumeaux soit une copie du fichier #jumeaux_SeqNuc if {[JumeauRepresentatif $Nom]!=$Nom} {continue} set FMRM "[RepertoireDuGenome]/nucmask/$Nom" if {[file exists $FMRM]} { set SeqMRM [QueLaSequenceDuFichierTFA $FMRM] set LAvtMRM [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqSansNMRM set LApresMRM [string length $SeqSansNMRM] if {$LApresMRM<$SeuilLongueur} { lappend Liste "$Nom\t$LApresMRM" } } else { Espionne "$FMRM doesn t exist" } } } else { set L [CreeListePourFichierAUneColonne $FichierListeDesPABs] foreach Nom $L { if {[JumeauRepresentatif $Nom]!="" && [JumeauRepresentatif $Nom]!=$Nom} {continue} set FMRM "[RepertoireDuGenome]/nucmask/$Nom" if {[file exists $FMRM]} { set SeqMRM [QueLaSequenceDuFichierTFA $FMRM] set LAvtMRM [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqSansNMRM set LApresMRM [string length $SeqSansNMRM] if {$LApresMRM<$SeuilLongueur} { lappend Liste "$Nom\t$LApresMRM" } } else { Espionne "$FMRM doesn t exist" } } } set ListeTriee [lsort -integer -index 1 $Liste] Espionne [llength $ListeTriee] return $ListeTriee } proc ListeMinimumDesJR {FichierClusters} { #soustrait les autresjumeaux a la liste des JR #40 autres jumeaux pour DD (51 pour AffyHS); base sur la proc oldLesAutresJumeaux #91 autres jumeaux pour Exonhit ; proc ElimineLesJRAyantLesMemesAccessDeProtOuDemRNA #1414 JR DD (8848 JR AffyHS) #1418 JR Exonhit #DD : 1374 (1414 - 40) #Affy:8797 (8848 - 51) return [ElimineLesJRAyantLesMemesAccessDeProtOuDemRNA $FichierClusters] } proc ListeMontpelier {} { foreach Nom [ListeDesPABs] { regsub "EVI" $Nom "" NomSsEvi set ligne [string range $NomSsEvi 0 end-1] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] if {[string index $ligne 0] == 0} { set ligne [string range $ligne 1 end] } } } if {[regexp "x" [RetChip2 $ligne "retinal_fate"]]} { set jaitrouve 1 set Prot [ExtraitInfo $Nom "Id et Access prot"] set mRNA [AccessEvi $Nom] set DesCust [RetChip2 $ligne "description_customer"] set LigneFinal "$ligne;$Nom;$DesCust;$mRNA;$Prot" lappend LesLignesFinales $LigneFinal } } SauveLesLignes $LesLignesFinales dans [Fiches]/LesGenesMontpelier2.csv } proc ListeMorphineExtADown_QPCR {} { Wup "Rend la liste des sequence morphines ExtA choisies pour validation sur QPCR" set MaListe [list MORPH0022 MORPH0011 MORPH0005 MORPH0037 MORPH0070 MORPH0054 MORPH0059] return $MaListe } proc ListeMorphineExtAUp_QPCR {} { Wup "Rend la liste des sequence morphines ExtA choisies pour validation sur QPCR" set MaListe [list MORPH0147 MORPH0080 MORPH0081 MORPH0122 MORPH0084 MORPH0138 MORPH0090 MORPH0145 MORPH0139 MORPH0089 MORPH0096 MORPH0074] return $MaListe } proc ListeOligos {} { Wup "Permet de rendre la liste des PAB des oligos commandes" set Fichier "[RepertoireDuGenome]/ListeDesPABsDesOligosCommandes.txt" global ListeOligo if {! [info exists ListeOligo]} { #Espionne "Liste existe pas encore on continue" } else { #Espionne "Liste existe" return $ListeOligo } if {! [file exists $Fichier]} {Espionne "$Fichier does not exists";return ""} set ListeOligo "" set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z0-9]+} $Ligne]} {continue} set PAB "" scan $Ligne "%s" PAB lappend ListeOligo $PAB } close $F set ListeOligo [lsort -unique $ListeOligo] return $ListeOligo } proc ListeParCategorie {Fichier FichierFinal GO} { #Fichier: /fiches/GeneOntology_GPO #GO:... foreach Nom [ListeDesPABs] { set Vu($Nom) 1 } foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set DD [lindex [split $Ligne "\t"] 0 ] if {[regexp -nocase $GO $Ligne] && [info exists Vu($DD)]} { lappend Liste $DD } } Espionne [llength $Liste ] set L [lsort -unique $Liste] Espionne [llength $L] foreach Elt $L { set InfosDD [InterrogeFichierFinal $Elt All] set InfosDD [join $InfosDD "\t"] lappend ListeFinale "$Elt\t$InfosDD" } return $ListeFinale #SauveLesLignes $ListeFinale dans $FichierFinal } proc ListePfamComplex {{repertoire ""}} { #ajouter des couleurs ici pour etre sure d'en avaoir assez pour l'instant probleme avec creation des region!!!!!!!! bon courage!! #recupere l'ensemble des domaines pour toutes les proteins!! set ListeDesDomaines {} set PfamListe {} set Liste [ListeDesPABs] foreach pab $Liste { set ValiGN [ExtraitInfo $pab "ValiGN"] Espionne "ValiGN:$ValiGN" if { [file exists "[RepertoireDuGenome]/macsimXml/$pab.aj"]} { set fileMacsim "[RepertoireDuGenome]/macsimXml/$pab.aj" } else { set fileMacsim "[RepertoireDuGenome]/macsimXml/$pab" } set annotation [FromMacsims "$fileMacsim" "$pab" "ConcatPfam"] foreach an $annotation { set idpfam $an; if {[regexp {(.*)from.*} $idpfam a p]} { set idpfam $p; } if {[regexp {^PROP_(.*).*} $idpfam a p]} { set idpfam $p; } set idpfam [lindex [split $idpfam " "] 0] lappend PfamListe "$idpfam-$ValiGN" } } return $PfamListe # #elimine les doublons # set ListeDesDomaines [lsort -unique $ListeDesDomaines] } proc ListeSansDoublon {Liste {NoCase ""} {NoEmpty ""}} { set NoEmpty [string equal -nocase $NoEmpty "NoEmpty"] set NoCase [string equal -nocase $NoCase "NoCase"] set SansDoublon {} set I -1 foreach Element $Liste { if {$NoEmpty && [string trim $Element]==""} { continue } set ELEMENT $Element if {$NoCase} { set ELEMENT [string toupper $Element] } if { [info exists DejaVu($ELEMENT)] } { set Ancien $DejaVu($ELEMENT) if {[regexp {[a-z]} $Element]} { set SansDoublon [lreplace $SansDoublon $Ancien $Ancien $Element] } continue } set DejaVu($ELEMENT) [incr I] lappend SansDoublon $Element } return $SansDoublon } proc ListeSsElmtVide {Liste} { set ListeFinal {} if {$Liste == {}} {return $ListeFinal} foreach elmt $Liste { if {[regexp {^Neo} $elmt]} {continue} if {$elmt!=""} {lappend ListeFinal $elmt} } return $ListeFinal } proc ListeTest {} { Wup "Rend la liste des ACT choisis pour le premier design" set MaListe [list ACT0004 ACT0005 ACT0010 ACT0016 ACT0017 ACT0030 ACT0034 ACT0045 ACT0050 ACT0053 ACT0059 ACT0062 ACT0123 ACT0155 ACT0176 ACT0198 ACT0202 ACT0204 ACT0269 ACT0283 ACT0285 ACT0297 ACT0298 ACT0301 ACT0345 ACT0355 ACT0374 ACT0393 ACT0396 ACT0397 ACT0582 ACT0585 ACT0592 ACT0594 ACT0595 ACT0604 ACT0609 ACT0611 ACT0883 ACT0892 ACT0899 ACT0911 ACT0915 ACT0916 ACT0938 ACT0997 ACT1013 ACT1017 ACT1037 ACT1043 ACT1047 ACT1133 ACT1140 ACT1150 ACT1162 ACT1164] return $MaListe } proc ListeTotalEVIProbeset {{Liste ""}} { if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set totalps 0 foreach Nom $Liste { puts "Nom $Nom" set Ligne "" set ProbesSet [ExtraitInfo $Nom "ProbeSetId"] if {$ProbesSet=="no value" || $ProbesSet==""} { set Ligne "$Nom" lappend LesLignes $Ligne continue } set LesProbesSet [split $ProbesSet ","] foreach Ps $LesProbesSet { puts "Ps $Ps" incr totalps set Ligne "$Nom $Ps" lappend LesLignes $Ligne } } puts "totalps $totalps" SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/ListeTotalEviPs" } proc ListeTrieeDesDistancesPhylos {Nom Reference {Arbre ""}} { global RepertoireDuGenome global ListeDistanceDeChaqueFeuille global NotreOS set FichierPhylo "$RepertoireDuGenome/phylos/$Nom" Wup "On peut ne pas avoir cree les fichiers phylos" if { ! [file exists $FichierPhylo]} { Wup "J'en cree qu'un, pas plusieurs ..." CreeLesFichiersPhylos $Nom } if { ! [file exists $FichierPhylo]} { Warne "$FichierPhylo couldn't be created" return {} } set ListeDistanceDeChaqueFeuille {} catch {unset SortieSeqDist} catch {set SortieSeqDist [split [exec seqdist $FichierPhylo $Reference] "\n"]} if { ! [info exists SortieSeqDist]} { Warne "seqdist did'nt success with $FichierPhylo $Reference" return {} } if {[llength $SortieSeqDist] == 0} { return {} } foreach Ligne $SortieSeqDist { if {[scan $Ligne "%s %s %s %f" Cible to Feuille Distance]!=4 } { continue } lappend ListeSeqDistDeChaqueFeuille "$Feuille $Distance" } set ListeTrieeSD [lsort -command "CompareLesFloats" $ListeSeqDistDeChaqueFeuille] Wup "On demande tous les Orgas en une seule fois" set LesAccess {} foreach FeuilleDistance $ListeTrieeSD { scan $FeuilleDistance "%s %f" Feuille DistanceFloat lappend LesAccess $Feuille } foreach AccessOrga [LesOrgasDesAccess $LesAccess Court] { Espionne $AccessOrga set Orga "iinc" scan $AccessOrga "%s %s" Access Orga set OrgaDuAccess($Access) $Orga } set ListeOrgaDistance {} foreach FeuilleDistance $ListeTrieeSD { Wup "Je stocke les distances en INTEGER de 0 a 100" scan $FeuilleDistance "%s %f" Feuille DistanceFloat set Access $Feuille if {[llength $ListeTrieeSD] == 1} { set DistanceFloat [expr $DistanceFloat/2] } set Distance [expr round(100*$DistanceFloat)] if {[info exists OrgaDuAccess($Access)]} { set Orga [set OrgaDuAccess($Access)] } else { set Orga [Glossaire "Inconnu inconnu" Court] } foreach O [SplitOrgas $Orga] { lappend ListeOrgaDistance "$O $Distance $Access" } } return $ListeOrgaDistance } proc ListeWolfgang2 {} { foreach Nom [ListeDesPABs] { set mRNAAcc [AccessEvi $Nom] set ProtAcc [ExtraitInfo $Nom "Id et Access prot"] set Ps [ExtraitInfo $Nom "ProbeSetId"] set Ligne "$Nom;$mRNAAcc;$ProtAcc;$Ps" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans [RepertoireDuGenome]/Wolfgang2 } proc Listedes2467PABs {Rep FichierSortie} { foreach Fichier [glob -nocomplain -directory $Rep "DD*"] { set NomFichier [file tail $Fichier] lappend ListeDesPABs $NomFichier } Espionne [llength $ListeDesPABs] set L [lsort -unique $ListeDesPABs] Espionne [llength $L] SauveLesLignes $L dans $FichierSortie } proc ListonsLesTrous {LongMotif Offset} { global RepertoireDuGenome global ListeDesTROUs if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs } foreach Boite $ListeDesTROUs { set Nom [Box $Boite nom] set Debut [Box $Boite debut] set Fin [Box $Boite fin] set Orient [Box $Boite orient] set Long [expr $Fin-$Debut+1] if {[info exists Histo($Long)]} { incr Histo($Long) } else { set Histo($Long) 1 } set DF [Maxi $Debut [expr $Fin-$Offset-$LongMotif]] set FF [Mini $Fin [expr $Fin-$Offset+$LongMotif]] set SeqF [BoutADN $DF $FF "F"] set DR [Maxi $Debut [expr $Debut+$Offset-$LongMotif]] set FR [Mini $Fin [expr $Debut+$Offset+$LongMotif]] set SeqR [BoutADN $DR $FR "R"] set Entamme "f${SeqF}r${SeqR}" set Termine "f${SeqF}r${SeqR}" append Entammes $Entamme append Termines $Termine # lappend LesTrousDeLongueur($Long) "[BoutADN $Debut $Fin "F"] f $Nom" # lappend LesTrousDeLongueur($Long) "[BoutADN $Debut $Fin "R"] r $Nom" } regsub -all "A|T" $Entammes "-" Entammes regsub -all "C|G" $Entammes "O" Entammes regsub -all "A|T" $Termines "-" Termines regsub -all "C|G" $Termines "O" Termines for {set i 0} {$i<[string length $Entammes]-$LongMotif} {incr i} { set MotifE [string range $Entammes $i [expr $i+$LongMotif-1]] set MotifT [string range $Termines $i [expr $i+$LongMotif-1]] if { ! [regexp "f|r" $MotifE]} { if {[info exists HistoE($MotifE)]} { incr HistoE($MotifE) } else { set HistoE($MotifE) 1 } } if { ! [regexp "f|r" $MotifT]} { if {[info exists HistoT($MotifT)]} { incr HistoT($MotifT) } else { set HistoT($MotifT) 1 } } } foreach MotifE [array names HistoE] { lappend HME "[set HistoE($MotifE)] $MotifE" } foreach MotifT [array names HistoT] { lappend HMT "[set HistoT($MotifT)] $MotifT" } set E [lsort -command CompareLesIntegersEnDebut $HME] set T [lsort -command CompareLesIntegersEnDebut $HMT] foreach t $T { puts "$t" } return set Sortie {} foreach Long [lsort -decreasing -integer [array names Histo]] { puts "$Long [set Histo($Long)]" if {$D<=$Long && $Long<=$F} { set Sortie [concat $Sortie [set LesTrousDeLongueur($Long)]] } } puts [join [lsort $Sortie] "\n"] } proc ListsComplement {LesA LesB} { Wup "A butnot B" foreach B $LesB { set Existe($B) 1 } set ComplementAB {} foreach A $LesA { if {! [info exists Existe($A)]} { lappend ComplementAB $A } } return $ComplementAB } proc ListsIntersection {LesA LesB {NoCase ""}} { #rR si NoCase on garde quand meme les A avec leur casse set NoCase [string equal -nocase $NoCase "NoCase"] foreach B $LesB { if {$NoCase} { set B [string tolower $B] } set Existe($B) 1 } set InterAB {} foreach A $LesA { set a $A if {$NoCase} { set a [string tolower $A] } if {[info exists Existe($a)]} { lappend InterAB $A } } return $InterAB } proc ListsUnion {LesA LesB} { set LesAB [ListeSansDoublon [concat $LesA $LesB]] return $LesAB } proc LitBlastJunctions {RepertoireBl SeuilLong} { #proc LitBlastJunctions {RepertoireBl SeuilLong SeuilIdent SeuilPosition} #RepertoireBl /genomics/link/SpliRetMouse/201404/RepDeTravail/Pax2 #RepertoireBl /genomics/link/SpliRetMouse/201404/RepDeTravail/All6 #RepertoireBl /genomics/link/SpliRetMouse/201404/RepDeTravail/Allmouse #RepertoireBl /genomics/link/SpliRetMouse/201404/RepDeTravail/All6rat #Org mouse ou rat set a 0; set b 0 set nb 0 set RepertoireBlCourt [lindex [split [Realpath $RepertoireBl] "/"] end] if {[regexp "mouse" $RepertoireBlCourt]} {set Org "mouse"} if {[regexp "rat" $RepertoireBlCourt]} {set Org "rat"} foreach FileBlast [lsort [glob -nocomplain "$RepertoireBl/*dustno.bl2.2.29"]] { if {[expr $nb %100]==0} {Espionne "$nb $a $b"} incr nb AskBlast unset set Query [AskBlast $FileBlast Query] set NbSub [AskBlast $FileBlast NbSubject] #Espionne "NbSub $NbSub" set connu 0 for {set i 1} {$i <= $NbSub} {incr i} { set Access [AskBlast $FileBlast Subject $i] # Espionne "++$Access" set NbSeg [AskBlast $FileBlast BanqueId $Access NbSegment] # Espionne "NbSeg $NbSeg" for {set j 1} {$j <= $NbSeg} {incr j} { set Gaps [AskBlast $FileBlast BanqueId $Access Segment $j Gaps] set BoutGaps [split $Gaps "/ "] set NbGap [lindex $BoutGaps 0] set Identities [AskBlast $FileBlast BanqueId $Access Segment $j Identities] set BoutIdentites [split $Identities "/ "] set NbIdent [lindex $BoutIdentites 0] set NbTotal [lindex $BoutIdentites 1] set PourcIdent [lindex $BoutIdentites 2] regsub {\(} $PourcIdent "" PourcIdent regsub {\)} $PourcIdent "" PourcIdent regsub "%" $PourcIdent "" PourcIdent set DQ [AskBlast $FileBlast BanqueId $Access Segment $j DQ] set FQ [AskBlast $FileBlast BanqueId $Access Segment $j FQ] set DS [AskBlast $FileBlast BanqueId $Access Segment $j DS] set FS [AskBlast $FileBlast BanqueId $Access Segment $j FS] if {0 && $SeuilLong<=$NbTotal} { if {$DS>$FS} { set w $DS set DS $FS set FS $w } } # if {$SeuilLong<=$NbTotal && $SeuilIdent<=$NbIdent && [expr $DQ-$SeuilPosition]<=$DS && $DS<=[expr $DQ+$SeuilPosition] && [expr $FQ-$SeuilPosition]<=$FS && $FS<=[expr $FQ+$SeuilPosition]} # if {$SeuilLong<=$NbTotal && $SeuilIdent<=$NbIdent && $DQ-$SeuilPosition<=$DS && $DS<=$DQ+$SeuilPosition && $FQ-$SeuilPosition<=$FS && $FS<=$FQ+$SeuilPosition} if {$SeuilLong<=$NbTotal} { set connu 1 if {![info exists DejaVu($PourcIdent)]} { lappend LesPourcIdent $PourcIdent set DejaVu($PourcIdent) 0 } incr DejaVu($PourcIdent) break } } if {$connu} {break} } if {$connu} { incr a } else { incr b set VarJunc [InterrogeCorresJuncVar $Query VarJunc "/genomics/link/SpliRetMouse/201404/RepDeTravail/CorresJuncVar_$Org"] lappend LesQueriesNew "$Query\t$VarJunc" } } foreach PourcIdent [lsort -unique -integer $LesPourcIdent] { lappend FrequPourcIdent "$PourcIdent\t$DejaVu($PourcIdent)" } Espionne "$a connu" Espionne "$b new" SauveLesLignes $LesQueriesNew dans "$RepertoireBl/LesJunctionsNew" SauveLesLignes $FrequPourcIdent dans "$RepertoireBl/FrequPourcIdent" # GrapheDesFrequences "$RepertoireBl/FrequPourcIdent" # return $b } proc LitCiliaGEO {} { foreach Ligne [LesLignesDuFichier "/home/poidevin/ordi/Cilia/GEO/CiliaCeInGEO.txt"] { if {[regexp "Accession:" $Ligne]} { set GSE [StringApres "Accession:" dans $Ligne] Espionne "$GSE" } } } proc LitEtCompleteOneFile {FichierInterproscan FichierMacsim} { package require tdom set nbnvcoulpfam 0 set File "" InterproscanFromOneFile File $FichierInterproscan set LesNamesInterproscan [InterproscanFromOneFile ListOf Name] set LesNamesMacsims [FromMacsims $FichierMacsim ListOf Names] Espionne "LesNamesInterproscan $LesNamesInterproscan" set fh [open $FichierMacsim "r"] dom parse -channel $fh doc close $fh $doc documentElement root dom createNodeCmd "elementNode" com::ftable dom createNodeCmd "elementNode" com::fitem dom createNodeCmd "elementNode" com::ftype dom createNodeCmd "elementNode" com::fstart dom createNodeCmd "elementNode" com::fstop dom createNodeCmd "elementNode" com::fcolor dom createNodeCmd "elementNode" com::fscore dom createNodeCmd "elementNode" com::fnote dom createNodeCmd "textNode" com::text foreach NameInterproscan $LesNamesInterproscan { Espionne "\t Name $NameInterproscan" set LesConcatInterproscan {}; set LesConcatMacsims {} set LesPFAMInterproscan [InterproscanFromOneFile $NameInterproscan IdDomain] foreach PFAMInterproscan $LesPFAMInterproscan { set StartStopInterproscan [InterproscanFromOneFile $NameInterproscan $PFAMInterproscan Start-Stop] if {[regexp {\-.*\-} $StartStopInterproscan]} { foreach coord [split $StartStopInterproscan " "] { set ScoreInterproscan [InterproscanFromOneFile $NameInterproscan $PFAMInterproscan $coord Score] lappend LesConcatInterproscan "$PFAMInterproscan/$coord/$ScoreInterproscan" } } else { set ScoreInterproscan [InterproscanFromOneFile $NameInterproscan $PFAMInterproscan $StartStopInterproscan Score] lappend LesConcatInterproscan "$PFAMInterproscan/$StartStopInterproscan/$ScoreInterproscan" } } foreach NameMacsim $LesNamesMacsims { if {[regexp -nocase "$NameInterproscan" $NameMacsim]} { set LesConcatMacsims [FromMacsims $FichierMacsim $NameMacsim ConcatPfam] break } } Espionne "interproscan" EspionneL "$LesConcatInterproscan" Espionne "macsims" EspionneL "$LesConcatMacsims" foreach ConcatInterproscan $LesConcatInterproscan { set trouve 0 #Espionne "ConcatInterproscan $ConcatInterproscan" set LesMotsInterproscan [split $ConcatInterproscan "/"] set PFAMInterproscan [lindex $LesMotsInterproscan 0] set StartStopInterproscan [lindex $LesMotsInterproscan 1] set ScoreInterproscan [lindex $LesMotsInterproscan 2] set CoordInterproscan [split $StartStopInterproscan "-"] set StartInterproscan [lindex $CoordInterproscan 0] set StopInterproscan [lindex $CoordInterproscan 1] foreach ConcatMacsims $LesConcatMacsims { #Espionne "ConcatMacsims $ConcatMacsims" set LesMotsMacsim [split $ConcatMacsims "/"] set PFAMMacsims [lindex $LesMotsMacsim 0] set StartStopMacsims [lindex $LesMotsMacsim 1] set CoordMacsims [split $StartStopMacsims "-"] set StartMacsims [lindex $CoordMacsims 0] set StopMacsims [lindex $CoordMacsims 1] if {[regexp $PFAMInterproscan $PFAMMacsims] && $StartStopInterproscan==$StartStopMacsims} { Espionne "1erechance" set trouve 1 break } if {[regexp $PFAMInterproscan $PFAMMacsims] && (([expr $StartMacsims-10] < $StartInterproscan && $StartInterproscan < [expr $StartMacsims+10]) || ([expr $StopMacsims-10] < $StopInterproscan && $StopInterproscan < [expr $StopMacsims+10]))} { Espionne "2emechance" set trouve 1 break } #cas ou le Pfam interproscan est contenu entierement dans le pfam macsims if {[regexp $PFAMInterproscan $PFAMMacsims] && (($StartMacsims < $StartInterproscan && $StartInterproscan < $StopMacsims) && ($StartMacsims < $StopInterproscan && $StopInterproscan < $StopMacsims))} { set trouve 1 break } } if {$trouve} { Espionne "onatrouve $PFAMInterproscan" } else { Espionne "attention on n a PAS trouve $PFAMInterproscan" set ColorPFAM [ColorOfPfam $FichierMacsim $PFAMInterproscan] #Espionne "ColorPFAM $ColorPFAM" if {$ColorPFAM==""} { #ArrayNvColorPFAM: quand un pfam n a pas de couleur dans macsims, on cree une nouvelle couleur et on la stocke dans ArrayNvColorPFAM pour que quand on rencontre de nouveau ce PFAM, on puisse recuperer cette couleur if {[info exists ArrayNvColorPFAM($PFAMInterproscan)]} { set ColorPFAM $ArrayNvColorPFAM($PFAMInterproscan) } else { incr nbnvcoulpfam set ColorPFAM [expr [LastColorPfamInMacsims $FichierMacsim] + $nbnvcoulpfam] set ArrayNvColorPFAM($PFAMInterproscan) $ColorPFAM } } #Espionne "ColorPFAM $ColorPFAM" foreach seq [$root selectNodes "//sequence"] { set NameMacsim [$seq selectNodes "string(./seq-name)"] if {[regexp -nocase "$NameInterproscan" $NameMacsim]} { set noeud_ftable [$seq selectNodes ".//ftable"] if {$noeud_ftable==""} { set noeud_seqinfo [$seq selectNodes "./seq-info"] $noeud_seqinfo appendFromScript { com::ftable { com::fitem { com::ftype {com::text "PFAM-A"} com::fstart {com::text "$StartInterproscan"} com::fstop {com::text "$StopInterproscan"} com::fcolor {com::text "$ColorPFAM"} com::fscore {com::text "$ScoreInterproscan"} com::fnote {com::text "$PFAMInterproscan from Interproscan"} } } } } else { $noeud_ftable appendFromScript { com::fitem { com::ftype {com::text "PFAM-A"} com::fstart {com::text "$StartInterproscan"} com::fstop {com::text "$StopInterproscan"} com::fcolor {com::text "$ColorPFAM"} com::fscore {com::text "$ScoreInterproscan"} com::fnote {com::text "$PFAMInterproscan from Interproscan"} } } } } } set fh [open $FichierMacsim.aj "w"] puts $fh "" $doc asXML -channel $fh -doctypeDeclaration 0 close $fh } } } $doc delete } proc LitEtCompleteXML {} { #attention pour un projet general (pas SpliRetMouse ni SpliRetRat), ReecritTousLesMacsimsAcOrga doit etre lance apres LitEtCompleteXML (sinon LitEtCompleteXML ne marche pas correctement) package require tdom set LesBoxPb {} set LesFichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsimXml/*.orgord"] if {$LesFichierMacsim=={}} {set LesFichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsimXml/*.org"]} if {$LesFichierMacsim=={}} {set LesFichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsimXml/*"]} if {$LesFichierMacsim=={}} {return "NoMacsimsFiles"} foreach FichierMacsim $LesFichierMacsim { set nbnvcoulpfam 0 if {[info exists ArrayNvColorPFAM]} {unset ArrayNvColorPFAM} set Box [file tail $FichierMacsim] regsub {\.[^\.]+$} $Box "" Box set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set FichierInterproscan "[RepertoireDuGenome]/Interproscan/$Box.is" #Espionne "" #Espionne "$FichierMacsim" #Espionne "$FichierInterproscan" set LesNamesInterproscan [Interproscan $Box Name] if {$LesNamesInterproscan=={}} { #Espionne "pas trouve interproscan" continue } #Espionne "LesNamesInterproscan $LesNamesInterproscan" set fh [open $FichierMacsim "r"] dom parse -channel $fh doc close $fh $doc documentElement root dom createNodeCmd "elementNode" com::ftable dom createNodeCmd "elementNode" com::fitem dom createNodeCmd "elementNode" com::ftype dom createNodeCmd "elementNode" com::fstart dom createNodeCmd "elementNode" com::fstop dom createNodeCmd "elementNode" com::fcolor dom createNodeCmd "elementNode" com::fscore dom createNodeCmd "elementNode" com::fnote dom createNodeCmd "textNode" com::text foreach NameInterproscan $LesNamesInterproscan { if {[NameInMacsimsYesorNo $FichierMacsim $NameInterproscan YesOrNo]!="Yes"} {continue} #Espionne "\t Name $NameInterproscan" set LesConcatInterproscan {}; set LesConcatMacsims {} set LesPFAMInterproscan [Interproscan $Box $NameInterproscan IdDomain] foreach PFAMInterproscan $LesPFAMInterproscan { set StartStopInterproscan [Interproscan $Box $NameInterproscan $PFAMInterproscan Start-Stop] if {[regexp {\-.*\-} $StartStopInterproscan]} { foreach coord [split $StartStopInterproscan " "] { set ScoreInterproscan [Interproscan $Box $NameInterproscan $PFAMInterproscan $coord Score] lappend LesConcatInterproscan "$PFAMInterproscan/$coord/$ScoreInterproscan" } } else { set ScoreInterproscan [Interproscan $Box $NameInterproscan $PFAMInterproscan $StartStopInterproscan Score] lappend LesConcatInterproscan "$PFAMInterproscan/$StartStopInterproscan/$ScoreInterproscan" } } if {$NameInterproscan==$Ref} { #ds le cas de la query(la ref)du macsims,c'est le nom de la box qui est reference ds macsims (pas le name) set NameInterproscan $Box #Espionne "\t Name devient $NameInterproscan" } set LesConcatMacsims [FromMacsims $FichierMacsim $NameInterproscan ConcatPfam] #Espionne "NameInterproscan $NameInterproscan" #Espionne "interproscan" #EspionneL "$LesConcatInterproscan" #Espionne "macsims" #EspionneL "$LesConcatMacsims" foreach ConcatInterproscan $LesConcatInterproscan { set trouve 0 #Espionne "ConcatInterproscan $ConcatInterproscan" set LesMotsInterproscan [split $ConcatInterproscan "/"] set PFAMInterproscan [lindex $LesMotsInterproscan 0] set StartStopInterproscan [lindex $LesMotsInterproscan 1] set ScoreInterproscan [lindex $LesMotsInterproscan 2] set CoordInterproscan [split $StartStopInterproscan "-"] set StartInterproscan [lindex $CoordInterproscan 0] set StopInterproscan [lindex $CoordInterproscan 1] foreach ConcatMacsims $LesConcatMacsims { #Espionne "ConcatMacsims $ConcatMacsims" set LesMotsMacsim [split $ConcatMacsims "/"] set PFAMMacsims [lindex $LesMotsMacsim 0] set StartStopMacsims [lindex $LesMotsMacsim 1] set CoordMacsims [split $StartStopMacsims "-"] set StartMacsims [lindex $CoordMacsims 0] set StopMacsims [lindex $CoordMacsims 1] if {[regexp $PFAMInterproscan $PFAMMacsims] && $StartStopInterproscan==$StartStopMacsims} { set trouve 1 break } if {[regexp $PFAMInterproscan $PFAMMacsims] && (([expr $StartMacsims-20] < $StartInterproscan && $StartInterproscan < [expr $StartMacsims+20]) || ([expr $StopMacsims-20] < $StopInterproscan && $StopInterproscan < [expr $StopMacsims+20]))} { set trouve 1 break } #cas ou le Pfam interproscan est contenu entierement dans le pfam macsims if {[regexp $PFAMInterproscan $PFAMMacsims] && (($StartMacsims < $StartInterproscan && $StartInterproscan < $StopMacsims) && ($StartMacsims < $StopInterproscan && $StopInterproscan < $StopMacsims))} { set trouve 1 break } } if {$trouve} { #Espionne "onatrouve $PFAMInterproscan" } else { lappend LesBoxPb $Box #Espionne "" #Espionne "$Box" #Espionne "$NameInterproscan" #Espionne "interproscan:" #EspionneL "$LesConcatInterproscan" #Espionne "macsims:" #EspionneL "$LesConcatMacsims" #Espionne "on n a PAS trouve $PFAMInterproscan" set ColorPFAM [ColorOfPfam $FichierMacsim $PFAMInterproscan] if {$ColorPFAM==""} { #ArrayNvColorPFAM: quand un pfam n a pas de couleur dans macsims, on cree une nouvelle couleur et on la stocke dans ArrayNvColorPFAM pour que quand on rencontre de nouveau ce PFAM, on puisse recuperer cette couleur if {[info exists ArrayNvColorPFAM($PFAMInterproscan)]} { set ColorPFAM $ArrayNvColorPFAM($PFAMInterproscan) } else { incr nbnvcoulpfam set ColorPFAM [expr [LastColorPfamInMacsims $FichierMacsim] + $nbnvcoulpfam] set ArrayNvColorPFAM($PFAMInterproscan) $ColorPFAM } } foreach seq [$root selectNodes "//sequence"] { set NameMacsim [$seq selectNodes "string(./seq-name)"] if {[regexp "$NameInterproscan" $NameMacsim]} { set noeud_ftable [$seq selectNodes ".//ftable"] if {$noeud_ftable==""} { set noeud_seqinfo [$seq selectNodes "./seq-info"] $noeud_seqinfo appendFromScript { com::ftable { com::fitem { com::ftype {com::text "PFAM-A"} com::fstart {com::text "$StartInterproscan"} com::fstop {com::text "$StopInterproscan"} com::fcolor {com::text "$ColorPFAM"} com::fscore {com::text "$ScoreInterproscan"} com::fnote {com::text "$PFAMInterproscan from Interproscan"} } } } } else { $noeud_ftable appendFromScript { com::fitem { com::ftype {com::text "PFAM-A"} com::fstart {com::text "$StartInterproscan"} com::fstop {com::text "$StopInterproscan"} com::fcolor {com::text "$ColorPFAM"} com::fscore {com::text "$ScoreInterproscan"} com::fnote {com::text "$PFAMInterproscan from Interproscan"} } } } } } set fh [open $FichierMacsim.aj "w"] puts $fh "" $doc asXML -channel $fh -doctypeDeclaration 0 close $fh } } } $doc delete } set LesBoxPb [ListeSansDoublon $LesBoxPb] set longDesBoxPb [llength $LesBoxPb] #Espionne "" #EspionneL "$LesBoxPb" #Espionne "LesBoxAj $longDesBoxPb" } proc LitEtCompleteXMLAideParenthese {} { foreach FichierMacsim $LesFichierMacsim { foreach NameInterproscan $LesNamesInterproscan { foreach ConcatInterproscan $LesConcatInterproscan { foreach ConcatMacsims $LesConcatMacsims { } if {$trouve} { Espionne "onatrouve $PFAMInterproscan" } else { foreach seq [$root selectNodes "//sequence"] { set NameMacsim [$seq selectNodes "string(./seq-name)"] } Espionne "oncreeaj" #set fh [open $FichierMacsim.aj "w"] #puts $fh "" #$doc asXML -channel $fh -doctypeDeclaration 0 #close $fh } } } $doc delete } set LesBoxPb [ListeSansDoublon $LesBoxPb] set longDesBoxPb [llength $LesBoxPb] } proc LitFichier {NomFichier} { #lit un fichier et renvoie son contenu dans une liste set f [open $NomFichier r] set liste [list] while {![eof $f]} {gets $f ligne ; lappend liste $ligne} close $f return $liste } proc LitFichierCompare {aTabCompare {FichierCompare ""}} { upvar $aTabCompare TabCompare global RepertoireDuGenome if {![file exists $FichierCompare]} {return ""} set ContenuCompare [ContenuDuFichier $FichierCompare] set SuisJeSurLesCoordonnees 0 set LesPosDeQuery1 {} set LesPosDeQuery2 {} set LesPoints {} foreach Ligne [LesLignesDuFichier $FichierCompare] { set Ligne [string trim $Ligne] regsub "\n" $Ligne "" Ligne if {$Ligne == "" } {continue} if {[regexp "COMPARE of" $Ligne]} { regsub "COMPARE of" $Ligne "" Input1 set Input1 [string trim $Input1] regsub "^: " $Input1 "" Input1 regexp "from: (\[0-9]*)" $Input1 tmp DQ1 regexp "to: (\[0-9]*)" $Input1 tmp FQ1 continue } elseif {[regexp "Description:" $Ligne] && ![info exists Description1]} { regsub "Description:" $Ligne "" Description1 continue } elseif {[regexp "\\*\\*\\* To" $Ligne ]} { regsub "\\*\\*\\* To" $Ligne "" Input2 regsub "^: " $Input2 "" Input2 regexp "from: (\[0-9]*)" $Input2 tmp DQ2 regexp "to: (\[0-9]*)" $Input2 tmp FQ2 continue } elseif {[regexp "Description:" $Ligne] && ![info exists Description2]} { regsub "Description:" $Ligne "" Description2 continue } elseif {[regexp "Word-size|Window" $Ligne]} { regexp "Window:(\[ 0-9]*)" $Ligne tmp Window if {[info exists Window]} {set Window [string trim $Window]} regexp "Stringency:(\[ 0-9]*)" $Ligne tmp Stringency if {[info exists Stringency]} {set Stringency [string trim $Stringency]} regexp "Points:(\[ 0-9]*)" $Ligne tmp Points if {[info exists Points]} {set Points [string trim $Points]} regexp "Word-size:(\[ 0-9]*)" $Ligne tmp WordSize if {[info exists WordSize]} {set WordSize [string trim $WordSize]} regexp "Alphabet:(\[ 0-9]*)" $Ligne tmp Alphabet if {[info exists Alphabet]} {set Alphabet [string trim $Alphabet]} set SuisJeSurLesCoordonnees 1 continue } elseif {$SuisJeSurLesCoordonnees && [regexp -nocase "\[a-z]" $Ligne tmp]} { break } elseif {$SuisJeSurLesCoordonnees} { while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LesPositions [split $Ligne " "] for {set i 0} {$i < [llength $LesPositions]} {incr i} { set X [lindex $LesPositions $i] if {$X == 0} {break} set Y [lindex $LesPositions [expr $i + 1]] set LePoint [list "$X" "$Y"] lappend LesPoints $LePoint set TabCompare($X,$Y) 1 incr i } } } set TabCompare(Input1) $Input1 set TabCompare(Input2) $Input2 set TabCompare(DebutQuery1) $DQ1 set TabCompare(FinQuery1) $FQ1 set TabCompare(DebutQuery2) $DQ2 set TabCompare(FinQuery2) $FQ2 set TabCompare(Points) $Points if {[info exists Description1]} {set TabCompare(Description1) $Description1} if {[info exists Description2]} {set TabCompare(Description2) $Description2} if {[info exists Window ]} {set TabCompare(Window) $Window} if {[info exists Stringency]} {set TabCompare(Stringency) $Stringency} if {[info exists WordSize ]} {set TabCompare(WordSize) $WordSize} if {[info exists Alphabet ]} {set TabCompare(Alphabet) $Alphabet} set TabCompare(LesPoints) $LesPoints return $aTabCompare } proc LitFichierSansBlancs {NomFichier} { #lit un fichier et renvoie son contenu dans une liste sauf les lignes vides set f [open $NomFichier r] set liste [list] while {![eof $f]} { gets $f ligne if {$ligne==""} continue lappend liste $ligne } close $f return $liste } proc LitGPL {{Qui ""} {Quoi ""}} { global LitGPL set QUI [string toupper $Qui] set QUOI [string toupper $Quoi] if {[info exists LitGPL($QUI,$QUOI)]} { return $LitGPL($QUI,$QUOI) } if {[info exists LitGPL("EstCharge")]} { return "" } set LitGPL("EstCharge") 1 set F "[HomeRipp]/GxHome/AgilentAnnot/GPL14550_family.soft" set LitGPL(FILENAME,) $F set PremiereFois 1 set LetsGo 0 set f [open $F r] while {[gets $f Ligne] >= 0} { set LesLinc {}; set LesRef {}; set LesEns {}; set LesGb {}; set LesTc {} if {[regexp "^!platform_table_begin" $Ligne]} {set LetsGo 1; continue} if {[regexp "^!platform_table_end" $Ligne]} {break} if {!$LetsGo} {continue} regsub -all ";" $Ligne "," Ligne set LesMots [split $Ligne "\t"] if {$PremiereFois} { set LesTetes $LesMots foreach Tete $LesTetes { set TETE [string toupper $Tete] lappend LesTETES $TETE } set LitGPL(LISTOF,HEADER) $LesTetes set PremiereFois 0 continue } set Id [lindex $LesMots 1] set ID [string toupper $Id] foreach Mot $LesMots H $LesTETES { set MOT [string toupper $Mot] set LitGPL($ID,$H) $Mot if {$H=="CYTOBAND"} { lassign [split $Mot "|"] SS Loc set LitGPL($ID,SPECIESSYMBOL) $SS set LitGPL($ID,CYTOBAND) $Loc lappend LitGPL(LISTOF,SPECIESSYMBOL) $SS lappend LitGPL(LISTOF,CYTOBAND) $Loc lappend LitGPL(IDSOFCYTOBAND,$Loc) $Id lappend LitGPL(IDSOFSPECIESSYMBOL,$SS) $Id } else { lappend LitGPL(LISTOF,$H) $Mot lappend LitGPL(IDSOF$H,$MOT) $Id } } } lappend LitGPL(LISTOF,HEADER) "SPECIESSYMBOL" lappend LesTetes "SpeciesSymbol" lappend LesTETES "SPECIESSYMBOL" foreach h $LesTetes H $LesTETES { set LitGPL(LISTOF,$H) [lsort -unique $LitGPL(LISTOF,$H)] set LitGPL(COUNTOF,$H) [llength $LitGPL(LISTOF,$H)] lappend LitGPL(ALL,COUNTS) "[format %5d $LitGPL(COUNTOF,$H)] $h" } close $f return [LitGPL $Qui $Quoi] } proc LitHelixDansPDB {laligne {chaine ""}} { # Numerotation format PDB commence a 1 et tcl # commence a 0. # Rajoute un blanc a laligne pour avoir la meme # coherence de format set laligne " $laligne" set HelNm [string range $laligne 8 10] set HelID [string range $laligne 12 14] set TypResDep [string range $laligne 16 18] set NomChnDep [string range $laligne 20 20] set NomResDep [string range $laligne 22 25] set TypResFin [string range $laligne 28 30] set NomChnFin [string range $laligne 32 32] set NomResFin [string range $laligne 34 37] set ClassHel [string range $laligne 39 40] set LongHel [string range $laligne 72 76] switch $ClassHel { 1 {set Type "Alpha"} 3 {set Type "Pi"} 5 {set Type "3_10"} 10 {set Type "polyP"} default {set Type "Alpha"} } if {$NomChnDep eq $chaine || $chaine eq ""} { return "Helix $Type $HelNm $NomChnDep $NomResDep $TypResDep $NomResFin $TypResFin $LongHel" } else { return "PasBon" } } proc LitLeTFA {FileOrText aNom aSeq} { upvar $aNom Nom $aSeq Seq if {[file exists $FileOrText]} { set Lignes [LesLignesDuFichier $FileOrText] } else { set Lignes [split $FileOrText "\n"] } lappend Lignes ">" set n 0 set laseq "" foreach l $Lignes { set l [string trim $l] if {$l eq ""} {continue} if {[string index $l 0] eq ">"} { if {$laseq ne ""} { set laseq [string map [list " " "" "-" "." "\n" "" "~" "."] $laseq] set laseq [string toupper $laseq] lappend Nom $lenom set Seq($lenom) $laseq set laseq "" incr n } set l [string trim [string range $l 1 end]] set ib [string first " " $l] if {$ib == -1} { set ib end } else { incr ib -1 } set lenom [string range $l 0 $ib] } else { append laseq $l } } return $n } proc LitLeTFAMagos {file aNom aSeq} { upvar $aNom Nom upvar $aSeq Seq set Lignes [LesLignesDuFichier $file] lappend Lignes ">" set n 0 set laseq "" foreach l $Lignes { set l [string trim $l] if {$l == ""} {continue} if {[string index $l 0] == ">"} { if {$laseq != ""} { regsub -all " " $laseq "" laseq regsub -all {\-} $laseq "." laseq regsub -all {\n} $laseq "" laseq lappend Nom $lenom set Seq($lenom) $laseq set laseq "" incr n } set l [string trim [string range $l 1 end]] set ib [string first " " $l] if {$ib == -1} { set ib end } else { incr ib -1 } set lenom [string range $l 0 $ib] } else { append laseq $l } } return $n } proc LitLesPoidsDuMSF {FichierMSF {ng ""}} { global SDG LNOrdali LesPoidsDesSequences if {$ng == ""} { set LesNomsDesSeqs $LNOrdali } else { set LesNomsDesSeqs [set SDG($ng)] } set LesLignes [LesLignesDuFichier $FichierMSF] if {[llength $LesLignes] < 2} { return 0 } set iSlashSlash [expr {[lsearch -regexp $LesLignes "//"]+1}] set iLeWeight [lsearch -regexp $LesLignes "Weight"] # lecture du champ Weight: du MSF set i 0 foreach Ligne [lrange $LesLignes $iLeWeight $iSlashSlash] { if {![regexp "Weight" $Ligne]} {continue} set iw [expr {[string last "Weight" $Ligne]+7}] set pd [string trim [string range $Ligne $iw end]] set nom [lindex $LesNomsDesSeqs $i] set LesPoidsDesSequences($nom) $pd incr i } return } proc LitLoupesParORGA {Fichier Qui} { set LesPABs {} set ORGA [Glossaire $Qui Complet] foreach Ligne [LesLignesDuFichier $Fichier] { if {! [regexp -nocase {[a-z]+} $Ligne]} {continue} scan $Ligne "%s %s" Genre Espece set Organisme "$Genre $Espece" if {$Organisme!=$Qui && $Organisme!=$ORGA} {continue} set LesPABs [StringSuivant "$Espece" dans $Ligne] } return [lsort $LesPABs] } proc LitLoupesParPAB {Fichier Qui} { set LesVraisOrgas {} foreach Ligne [LesLignesDuFichier $Fichier] { if {! [regexp -nocase {[a-z]+} $Ligne]} {continue} scan $Ligne "%s" PAB if {$PAB!=$Qui} {continue} set LesOrgas [StringSuivant "$PAB" dans $Ligne] foreach {Genre Espece} $LesOrgas { lappend LesVraisOrgas "$Genre $Espece" } } return [lsort $LesVraisOrgas] } proc LitMatrixFileGSE60458 {} { set F "/home/poidevin/ordi/Collaboration/Pheochromocytoma/GSE60458_series_matrix.txt" foreach Ligne [LesLignesDuFichier $F] { if {[regexp "^3180\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^12645\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^18548\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^24905\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^25447\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^26560\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^37443\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^39820\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^41227\t" $Ligne]} {Espionne "$Ligne"} if {[regexp "^45657\t" $Ligne]} {Espionne "$Ligne"} } } proc LitMatrixIL13 {} { set F "[GxData]/GxUpload/IL13/cel_files/GSE37693_series_matrix.txt" foreach Ligne [LesLignesDuFichier $F] { if {[regexp "^\"ILMN_1715901\"" $Ligne]} {Espionne "$Ligne"} } } proc LitMesClusters {{Fichier ""} {Destination ""}} { Wup "Lit le fichier LesCLusters et le formate correctement dans le fichier Destination" if {$Fichier==""} { set Fichier "/home/jmuller/Developpement/LesClusters" } if {! [File exists $Fichier]} {return "$Fichiers does not exists"} if {$Destination==""} { set Destination "/home/jmuller/Developpement/LesClustersFormates" } set AvecTest 0 set ProtDesClusters 0 set NbrCluster 0 set NbrProtTotal 0 foreach Ligne [LesLignesDuFichier $Fichier] { if {! [regexp -nocase {[a-z]+} $Ligne]} {continue} if { [regexp -nocase "^#" $Ligne]} {continue} scan $Ligne "%s %s %s %s" Cluster Numero NbProteine Definition set PABsInteressants [StringSuivant "$Definition " dans $Ligne] if {[regexp "^Cluster" $Ligne]} {incr NbrCluster} set ProtDesClusters [expr $ProtDesClusters+$NbProteine] set NbrProt [llength $PABsInteressants] set NbrProtTotal [expr $NbrProtTotal+$NbrProt] #Espionne "$PABsInteressants $NbrProt -- $NbrProtTotal" if {$AvecTest} { foreach PAB $PABsInteressants { set AutreNumero [MembresDuClusterN $PAB "Numero"] if {$AutreNumero!=$Numero} { Espionne "Vrai $AutreNumero de $PAB ancien $Numero" } } } lappend ListeASauver [format "%-7s %3d %4d %-25s %s" $Cluster $Numero $NbProteine $Definition $PABsInteressants] foreach Element $PABsInteressants { lappend ListeCompleteDesPABs $Element #Espionne "[Narcisse $Element]" } } lappend ListeASauver "Nombre de Clusters: $NbrCluster pour $ProtDesClusters" lappend ListeASauver "Proteines surlignees: $NbrProtTotal" #EspionneL "$ListeASauver" #Espionne "$ProtDesClusters" set ListeCompleteDesPABs [lsort $ListeCompleteDesPABs] #EspionneL "$ListeCompleteDesPABs [llength $ListeCompleteDesPABs]" return [SauveLesLignes $ListeASauver dans $Destination] } proc LitPG94 {} { set I 0 foreach Fichier [lsort [glob "[RepertoireDuGenome]/DeWolfgang/*"]] { set Definition [IemeLigneDuFichier $Fichier 2] set Nom "Seq[incr I] " set NomFic $Nom if {[regexp {^affy ([0-9]+(_[fr])?_at)} $Definition Match Access]} { set Nom "$Access " ; set NomFic $Access} if {[regexp {^A[^ ]+} $Definition Match]} { set Nom "" ; set NomFic $Match } set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] "$Nom$Definition" "gcg"] Espionne $TFA Sauve $TFA dans "[RepertoireDuGenome]/DeWolfgang/$NomFic.tfa" } exit } proc LitRef {} { global Ref RefS if {[info exists Ref]} {unset Ref} if {[info exists RefS]} {unset RefS} set Ll [LesLignesDuFichier "/home/moumou/dbmarie/ListeOG.txt"] foreach l $Ll { regsub -all {\t+} $l "\t" l set Ls [split $l "\t"] set ab [string range [lindex $Ls 0] 1 end-1] set nm [lindex $Ls 1] set tx [lindex $Ls 2] set dm [lindex $Ls 3] set Ref($tx) [list $ab $nm $dm] set RefS($ab) [list $tx $nm $dm] } return } proc LitSheetDansPDB {laligne {chaine ""}} { # Numerotation format PDB commence a 1 et tcl # commence a 0. # Rajoute un blanc a laligne pour avoir la meme # coherence de format set laligne " $laligne" set StrandID [string range $laligne 8 10] set SheetID [string range $laligne 12 14] set NbStrd [string range $laligne 15 16] set TypResDep [string range $laligne 18 20] set NomChnDep [string range $laligne 22 22] set NomResDep [string range $laligne 23 26] set TypResFin [string range $laligne 29 31] set NomChnFin [string range $laligne 33 33] set NomResFin [string range $laligne 34 37] set SensStrd [string range $laligne 39 40] if {$NomChnDep ne $NomChnFin} {set NomChnDep "cesttroplebordel"} if {$NomChnDep == $chaine || $chaine == ""} { return "Sheet $SheetID $StrandID $NomChnDep $NomResDep $TypResDep $NomResFin $TypResFin $SensStrd" } else { return "PasBon" } } proc LitSortieOligoArray {{PAB ""} {Dir ""}} { Wup "Recherche dans une sortie OligoArray 1.0 les oligos, leurs positions, tailles ..." Wup "Version sans prise en compte des AccessDef voir proc LesAccessDefDeLOligoArray" Wup "Version amelioree pour meilleure lecture d'une sortie OligoArray" if {$PAB=="" || $Dir==""} { return "" } set RepProbes "[RepertoireDuGenome]/Probes" if {[regexp -all {/} $Dir]} { set FichierProbes "$RepProbes/[file tail $Dir]/$PAB" } else { set FichierProbes "$RepProbes/$Dir/$PAB" } if {! [file exists $FichierProbes]} { return "-2" } set LigneSplitee {} set LesOligos {} set TailleOligo 0 set OnLeTient 0 set F [open "$FichierProbes"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} { continue } if {[regexp -nocase -all "NoOligo" $Ligne]} {return "-1"} if {[string range $Ligne 0 0] != ">"} { if {! $OnLeTient} {continue} set TailleOligo [string length $Ligne] set ExpTm [CalculTmDeLaSeq $Ligne "" 0.0 DNADNA] #set ExpTm [NearestNeighborTm $Ligne] lappend LesOligos [list $NomOligo $TailleOligo $OligoTm $SecondaryTm $DistanceDu3End $ExpTm] set OnLeTient 0 continue } set OnLeTient 1 set DistanceDu3End 0 set OligoTm 0 set SecondaryTm 0 set LigneSplitee [split "$Ligne" "\t"] set Entete [lindex $LigneSplitee 0] set PAB [lindex $Entete 0] regsub ">" $PAB "" PAB set NomOligo [lindex $Entete 1] set DistanceDu3End [lindex $LigneSplitee 1] set OligoTm [lindex $LigneSplitee 2] set SecondaryTm [lindex $LigneSplitee 3] } close $F return $LesOligos } proc LitString {{Qui ""} {Quoi ""} {Ou ""}} { #meme programme que Tau #Ou = le fichier .string global LitString if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Qui == "Reset"} { if {[info exists LitString]} { unset LitString } return "" } if {$Ou!=""} { if {[info exists LitString(File,Name)] && $Ou!=$LitString(File,Name)} { unset LitString } set Fichier $Ou } else { if {[info exists LitString(File,Name)]} { set Ou $LitString(File,Name) set Fichier $Ou } else { FaireLire "Il faut donner un nom de fichier la 1ere fois" return "" } } if {[info exists LitString($Qui,$Quoi)]} { return $LitString($Qui,$Quoi) } if {[info exists LitString("EstCharge")]} { return "" } set LitString("EstCharge") 1 set Q [file tail $Fichier] regsub -nocase {\.[^\.]+$} $Q "" Q LoadTxlWithRowsOfCells $Fichier Txl -1 "\t" set LitString(File,Name) $Fichier set LitString(File,Queue) $Q set LitString(ListOf,Header) $Txl(ListHeaderPlease,$Q) set LitString(ListOf,Index) $Txl(ListAllPlease,$Q) foreach I $LitString(ListOf,Index) { foreach H $LitString(ListOf,Header) { set LitString($I,$H) $Txl($I,$H) } set LitString($LitString($I,PIDInitial),PN) $LitString($I,PNInitial) set LitString($LitString($I,PNInitial),PID) $LitString($I,PIDInitial) set LitString($LitString($I,PIDCop),PN) $LitString($I,PNCop) set LitString($LitString($I,PNCop),PID) $LitString($I,PIDCop) set PI $Txl($I,PIDInitial) set PC $Txl($I,PIDCop) lappend LitString($PI,ListOfCop) $PC lappend LitString($PC,ListOfRef) $PI lappend LitString(ListOf,Ref) $PI lappend LitString(ListOf,Cop) $PC set LitString($PI,IsRef) 1 if { ! [info exists LitString($PC,IsRef)]} { set LitString($PC,IsRef) 0 } } set LitString(ListOf,Ref) [lsort -unique $LitString(ListOf,Ref)] set LitString(ListOf,Cop) [lsort -unique $LitString(ListOf,Cop)] return [LitString $Qui $Quoi] } proc LitTfa {f} { global Tfa RefS set root [file tail $f] if {[info exists Tfa]} {unset Tfa} set Ll [LesLignesDuFichier $f] foreach l $Ll { if {! [regexp {^>} $l]} {continue} set tx "" set nt "" set Ls [split $l "|"] if {[regexp {^>SM} $l]} { set nm $root set tx 9606 } elseif {[llength $Ls] == 1} { if {[regexp {^>PDB} $l]} {continue} set ib [string first " " $l] if {$ib == -1} {set ib end} set nm [string trim [string range $l 1 $ib]] set ab [lindex [split $nm "_"] 0] if {[info exists RefS($ab)]} {set tx [lindex [set RefS($ab)] 0]} } else { set nm [string trim [string range [lindex $Ls 0] 1 end]] set tx [string trim [lindex $Ls 1]] if {[llength $Ls] == 3} {set nt [string trim [lindex $Ls 2]]} } set Tfa($nm) [list $tx $nt] } return } proc LitTurnDansPDB {laligne {chaine ""}} { # Numerotation format PDB commence a 1 et tcl # commence a 0. # Rajoute un blanc a laligne pour avoir la meme # coherence de format set laligne " $laligne" set TurnNm [string range $laligne 8 10] set TypResDep [string range $laligne 16 18] set NomChnDep [string range $laligne 20 20] set NomResDep [string range $laligne 21 24] set TypResFin [string range $laligne 27 29] set NomChnFin [string range $laligne 31 31] set NomResFin [string range $laligne 32 35] if {$NomChnDep eq $chaine || $chaine eq ""} { return "Turn XXX $TurnNm $NomChnDep $NomResDep $TypResDep $NomResFin $TypResFin" } else { return "PasBon" } } proc LitVecLC {file alx aly} { upvar $alx lx upvar $aly ly global Lnom MaxX MaxY MinX MinY Max set lignes [LesLignesDuFichier $file] set mx 0. ; set my 0. foreach l $lignes { set sline [split $l " "] lassign $l nm x y lappend lxyn [list $x $y $nm] set mx [expr {$mx + $x}] set my [expr {$my + $y}] } set mx [expr {$mx / [llength $lignes]}] set my [expr {$my / [llength $lignes]}] set lxyn [lsort -index 2 $lxyn] set Lnom {} foreach e $lxyn { lassign $e x y n lappend Lnom $n lappend lx [expr {$x - $mx}] lappend ly [expr {$y - $my}] } puts "\nfile : $file" puts "Moy X : $mx" puts "Moy Y : $my" return puts "\n$file [llength $lnom]" puts [format "acide %s norm max %7.2f" $NAA $Nmax] puts "" set fmt "%s | %7.3f %7.3f %7.3f| %6.3f %6.3f %7.2f" foreach x $lx y $ly n $lnom { set xn [expr {$x/$Nmax}] set yn [expr {$y/$Nmax}] lappend nxn $xn lappend nyn $yn if {$xn > $MaxX} {set MaxX $xn} if {$xn < $MinX} {set MinX $xn} if {$yn > $MaxY} {set MaxY $yn} if {$yn < $MinY} {set MinY $yn} set OldN [expr {sqrt($x*$x+$y*$y)}] set Norm [expr {sqrt($xn*$xn+$yn*$yn)}] puts [format $fmt $n $x $y $OldN $xn $yn $Norm] } set Max [Maxi [Maxi $MaxX $MaxY] [expr -1.*[Mini $MinX $MinY]]] set lx $nxn set ly $nyn update return } proc LnFn {n} { if {$n == 0} { return 1. } else { return [expr {log(sqrt(2.*3.1415926))+($n+0.5)*log($n)-$n}] } } proc Load2GO {aTab} { upvar $aTab Tab set Tab(LesTypesDeRequetes) {} set Tab(LesRequetes) {} set Tab(LesGO) {} foreach Fichier [LesFichiers2GO] { Espionne "2GO -> [file tail $Fichier] loading ..." set F [open $Fichier] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == "" || [regexp "^!" $Ligne]} {continue} set Debut [expr [string first ":" $Ligne] + 1] set GO [lindex [split [string trim $Ligne] " "] end] set go [string tolower $GO] set Entete [string trim [string range $Ligne 0 [expr $Debut - 2]]] if {![string equal -nocase $Entete "SP_KW"]} { if {[info exists RequeteTot]} {unset RequeteTot} scan $Ligne "%s" RequeteTot set RequeteTotLower [string tolower $RequeteTot] set Requete [string trim [string range $RequeteTot $Debut end]] set RequeteLower [string tolower $Requete] } else { set Fin [expr [string first ">" $Ligne] - 1] #debutLP set Debut [string first " " $Ligne] #finLP set RequeteTot [string trim [string range $Ligne 0 $Fin]] set RequeteTotLower [string tolower [string trim [string range $Ligne 0 $Fin]]] set Requete [string trim [string range $Ligne $Debut $Fin]] set RequeteLower [string tolower [string trim [string range $Ligne $Debut $Fin]]] } if {[string equal -nocase $Entete "ec"]} { set RequeteLower $Requete set Requete "ec $Requete" } if {![info exists Tab($Requete,LesLiens)]} { set Tab($Requete,LesLiens) {} set Tab($RequeteLower,LesLiens) {} set Tab($RequeteTot,LesLiens) {} set Tab($RequeteTotLower,LesLiens) {} set WhatIsIt [file tail $Fichier] if {![info exists TabTmp($WhatIsIt)]} { set TabTmp($WhatIsIt) 1 lappend Tab(LesTypesDeRequetes) $WhatIsIt } set Tab($Requete,WhatIsIt) $WhatIsIt set Tab($RequeteLower,WhatIsIt) $WhatIsIt set Tab($RequeteTot,WhatIsIt) $WhatIsIt set Tab($RequeteTotLower,WhatIsIt) $WhatIsIt lappend Tab(LesRequetes) $Requete } if {![info exists Tab($GO,LesLiens) ]} { lappend Tab(LesGO) $GO set WhatIsIt GO if {![info exists TabTmp($WhatIsIt)]} { set TabTmp($WhatIsIt) 1 lappend Tab(LesTypesDeRequetes) $WhatIsIt } set Tab($GO,WhatIsIt) $WhatIsIt set Tab($go,WhatIsIt) $WhatIsIt set Tab($GO,LesLiens) {} set Tab($go,LesLiens) {} } if {![info exists TabTmp($Requete,$GO)]} { lappend Tab($Requete,LesLiens) $GO lappend Tab($RequeteLower,LesLiens) $GO lappend Tab($RequeteTot,LesLiens) $GO lappend Tab($RequeteTotLower,LesLiens) $GO lappend Tab($GO,LesLiens) $Requete lappend Tab($go,LesLiens) $Requete set TabTmp($Requete,$GO) 1 } if {![info exists TabTmp($Requete)]} { set TabTmp($Requete) 1 lappend Tab(LesRequetes) $Requete } } Espionne "2GO -> [file tail $Fichier] loaded" close $F } if {[info exists TabTmp]} {unset TabTmp} return $aTab } proc LoadAnchors {aTab FichierAnchors} { upvar $aTab Tab if {![file exists $FichierAnchors]} {return} set Tab($FichierAnchors,LesId) {} set F [open $FichierAnchors] while {[gets $F Ligne]>=0} { if {![regexp {^seq\:} $Ligne]} {continue} set LaLigne [split $Ligne "\t"] regsub -all "\t" $Ligne " " Ligne while {[regexp " " $Ligne]} {regsub -all {[ ]{2,}} $Ligne " " Ligne} set LaLigne [split $Ligne " "] if {![info exists Tab($FichierAnchors,IdDeRef)]} {set Tab($FichierAnchors,IdDeRef) [lindex $LaLigne 1]} set Id [lindex $LaLigne 2] if {![info exists Tab($FichierAnchors,Id,$Id,NbLMS)]} { set Tab($FichierAnchors,Id,$Id,NbLMS) 0 lappend Tab($FichierAnchors,LesId) $Id } incr Tab($FichierAnchors,Id,$Id,NbLMS) set nLMS [set Tab($FichierAnchors,Id,$Id,NbLMS)] set Tab($FichierAnchors,Id,$Id,LMS,$nLMS,Pos) [lindex $LaLigne 4] set Tab($FichierAnchors,Id,$Id,LMS,$nLMS,Beg) [lindex $LaLigne 6] set Tab($FichierAnchors,Id,$Id,LMS,$nLMS,End) [lindex $LaLigne 7] set Tab($FichierAnchors,Id,$Id,LMS,$nLMS,Len) [lindex $LaLigne 9] } close $F return $aTab } proc LoadBLT {version dir} { set prefix "lib" set suffix [info sharedlibextension] regsub {\.} $version {} version_no_dots # Determine whether to load the full BLT library or # the "lite" tcl-only version. if { [info commands tk] == "tk" } { set name ${prefix}BLT${version_no_dots}${suffix} } else { set name ${prefix}BLTlite${version_no_dots}${suffix} } global tcl_platform if { $tcl_platform(platform) == "unix" } { set library [file join $dir $name] if { ![file exists $library] } { # Try the parent directory. set library [file join [file dirname $dir] $name] } if { ![file exists $library] } { # Default to the path generated at compilation. set library [file join "/linux/local/ActiveTcl/lib" $name] } } else { set library $name } load $library BLT } proc LoadBlast {aTabBlast FichierBlast} { upvar $aTabBlast TabBlast set Compteur 0 set ExpectDeRef 1e200 set NbSubjectTot 1e200 if {![file exists $FichierBlast]} {return} set SuisJeSurLesAlignements 0 set SuisJeSurUnAlignement 0 set ToutLeSubject "" set TousLesSubjects {} set j 0 set SuisJeSurLeNomDeLaQuery 0 set TailleMaxDUnFichier [expr 25*1e6] if {$TailleMaxDUnFichier < [file size $FichierBlast]} { set NbHitsMax 10000 Espionne "$FichierBlast is too long, we are going to study only the $NbHitsMax first hits" } else { set NbHitsMax "NoLimit" } set NomQuery {} set F [open $FichierBlast] set nHits 0 while {[gets $F Ligne]>=0} { if {[string range $Ligne 0 6] == "Query= "} { set SuisJeSurLeNomDeLaQuery 1 set Ligne [string range $Ligne 7 end] } if {!$SuisJeSurLesAlignements && [regexp "\[0-9\.]* letters" $Ligne]} { set SuisJeSurLeNomDeLaQuery 0 } if {$SuisJeSurLeNomDeLaQuery} { regsub "\n" $Ligne " " Ligne lappend NomQuery [string trim $Ligne] } incr j if {$j == 1 || $j == 2} { if {[string range $Ligne 0 4] == "BLAST" || [string range $Ligne 0 5] == "TBLAST"} { set LigneTrim [string trim $Ligne] set TypeDeBlast [string range $LigneTrim 0 [expr [string first " " $LigneTrim]-1]] set TabBlast($FichierBlast,TypeDeBlast) $TypeDeBlast } } if {[string range $Ligne 0 11] == " Database: " || [string range $Ligne 0 7] == "Matrix: "} { if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject} regsub "\n" $Ligne "" Ligne regsub " Database: " $Ligne "" Ligne set TabBlast($FichierBlast,Database) [string trim $Ligne] set SuisJeSurLesAlignements 0 break } if {[string range $Ligne 0 0] != ">" && $SuisJeSurLesAlignements == 0} {continue} if {[string range $Ligne 0 8] == " Score = "} {incr nHits} if {$NbHitsMax != "NoLimit" && $NbHitsMax < $nHits} { if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject} break } if {[string range $Ligne 0 0] == ">"} { if {$ToutLeSubject != ""} {lappend TousLesSubjects $ToutLeSubject} set ToutLeSubject "" set SuisJeSurLesAlignements 1 set SuisJeSurUnAlignement 1 append ToutLeSubject "$Ligne" } elseif {$SuisJeSurUnAlignement && $SuisJeSurLesAlignements} { append ToutLeSubject "\n$Ligne" } } close $F set NbSubject 0 foreach Subject $TousLesSubjects { regsub -all {Expect[ 0-9\(\)]* =} $Subject "Expect =" Subject set AiJeAuMoinsUnExpectCorrect 0 set Tmp $Subject while {[regexp { Expect =([ e0-9\.\-]*)} $Tmp ToutLExpect Expect]} { set Expect [string trim $Expect] if {[string range $Expect 0 0] == "e"} {set Expect "1$Expect"} if {$Expect <= $ExpectDeRef} {set AiJeAuMoinsUnExpectCorrect 1;break} regsub { Expect =[ e0-9\.\-]*} $Tmp "" Tmp } unset Tmp if {!$AiJeAuMoinsUnExpectCorrect} {continue} set SubjectBrut $Subject ####BanqueId et Access et definition et Taille###### regexp -indices " Length = " $Subject DebFin set EnteteSubject [string trim [string range $Subject 1 [lindex $DebFin 0]]] set Subject [string range $Subject [lindex $DebFin 0] end ] regsub -all "\n" $EnteteSubject " " EnteteSubject regsub -all {\(|\)} $EnteteSubject "_" EnteteSubject while {[regexp " " $EnteteSubject]} {regsub -all " " $EnteteSubject " " EnteteSubject} set LEnteteSubject [split $EnteteSubject " "] set BanqueId [lindex $LEnteteSubject 0] #set BANQUEID [string toupper $BanqueId] set Access [lindex $LEnteteSubject 1] regsub "^_" $Access "" Access regsub "_$" $Access "" Access #set ACCESS [string toupper $Access ] set Definition [join [lrange $LEnteteSubject 2 end] " "] if {$Access == ""} { set Access $BanqueId set Definition "" } elseif {![regexp -nocase {^[a-z]} $Access] || [EstUnAccessPDB $BanqueId]} { set Access $BanqueId set Definition [join [lrange $LEnteteSubject 1 end] " "] } #########Elimination en fonction de l'access ou du banqueid################## incr NbSubject if {$NbSubjectTot < $NbSubject} {incr NbSubject -1;break} ############################################################################# regexp -nocase { Length = ([0-9]+)[ ]*\n} $Subject tmp Taille regsub { Length = [0-9]+[ ]*\n} $Subject "" Subject set TabBlast($FichierBlast,Subject,$NbSubject) $BanqueId set TabBlast($FichierBlast,BanqueId,$BanqueId,Access) $Access set TabBlast($FichierBlast,BanqueId,$BanqueId,Definition) $Definition set TabBlast($FichierBlast,BanqueId,$BanqueId,Taille) $Taille set TabBlast($FichierBlast,BanqueId,$BanqueId,SubjectBrut) $SubjectBrut ##############Split les alignements du subject############## set SuisJeSurUnAlignement 0 set LesAlignements {} set LAlignement {} foreach Ligne [split $Subject "\n"] { if {[regexp -nocase "Score = " $Ligne]} { if {$LAlignement != {}} { lappend LesAlignements [join $LAlignement "\n"] set LAlignement {} } lappend LAlignement $Ligne set SuisJeSurUnAlignement 1 } elseif {$SuisJeSurUnAlignement} { lappend LAlignement $Ligne } } lappend LesAlignements [join $LAlignement "\n"] ##############Decomposition des alignements########### set NbSegment 0 foreach Alignement $LesAlignements { set AlignementBrut $Alignement incr NbSegment set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,AlignBrut) $Alignement set Score "" set Expect "" set Identities "" set Gaps "" set Orientation "" set Positives "" set Query "" set Sbjct "" set Inter "" set AlignementLineaire "" set DebutQuery "" set FinQuery "" set DebutSbjct "" set FinSbjct "" regexp { Score = ([e0-9a-z\.\+\(\) ]+)} $Alignement tmp Score regsub { Score = [e0-9a-z\.\+\(\) ]+} $Alignement "" Alignement set Score [string trim $Score] regexp { Expect =([ e0-9\.\-]+)} $Alignement tmp Expect regsub { Expect =[ e0-9\.\-]+} $Alignement "" Alignement set Expect [string trim $Expect] if {[regexp "^e" $Expect]} { set Expect "1$Expect"} regexp { Identities = ([0-9a-z\/\%\(\) ]+)} $Alignement tmp Identities regsub { Identities = [0-9a-z\/\%\(\) ]+} $Alignement "" Alignement set Identities [string trim $Identities] if {[regexp { Positives = ([0-9\/\%\(\) ]+)} $Alignement tmp Positives]} { regsub { Positives = [0-9\/\%\(\) ]+} $Alignement "" Alignement } set Positives [string trim $Positives] if {[regexp { Gaps = ([0-9\/\%\(\) ]+)} $Alignement tmp Gaps]} { regsub { Gaps = [0-9\/\%\(\) ]+} $Alignement "" Alignement } set Gaps [string trim $Gaps] regexp -nocase { [a-z]+ = ([0-9a-z\/\-\+ ]+)} $Alignement tmp Orientation regsub -nocase { [a-z]+ = [0-9a-z\/\-\+ ]+} $Alignement "" Alignement set Orientation [string trim $Orientation] regsub -all "," $Alignement "" Alignement set Alignement [string trim $Alignement] foreach Ligne [split $Alignement "\n"] { if {$Query != "" && [regexp {^Query: [0-9 ]+} $Ligne]} { regsub {[0-9 ]+$} $Query "" Query append Query [string range $Ligne $n end] } if {$Sbjct != "" && [regexp {^Sbjct: [0-9 ]+} $Ligne]} { regsub {[0-9 ]+$} $Sbjct "" Sbjct append Sbjct [string range $Ligne $n end] } if { $Inter != "" && [regexp -nocase {^ } $Ligne] && [regexp -nocase {[a-z\|\-\+]} $Ligne]} { append Inter [string range $Ligne $n end] } if { $Query == "" && [regexp {^Query: ([0-9 ]+)} $Ligne tmp DebutQuery]} { set n [string length $tmp] append Query $Ligne } if { $Sbjct == "" && [regexp {^Sbjct: ([0-9 ]+)} $Ligne tmp DebutSbjct]} { append Sbjct $Ligne } if { $Inter == "" && [regexp {^ } $Ligne] && [regexp {[a-z\|\-\+]} $Ligne] } { append Inter $Ligne } } regexp {([0-9]+)[ ]*$} $Query tmp FinQuery regexp {([0-9]+)[ ]*$} $Sbjct tmp FinSbjct if {$AlignementLineaire != ""} {set AlignementLineaire "\n"} append AlignementLineaire "$Query\n$Inter\n$Sbjct" set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Score) $Score set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Expect) $Expect set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Identities) $Identities set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Positives) $Positives set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Gaps) $Gaps set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Orientation) $Orientation set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,Align) $Alignement set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,AlignLineaire) $AlignementLineaire set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,AlignBrut) $AlignementBrut set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,DQ) [string trim $DebutQuery] set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,FQ) [string trim $FinQuery ] set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,DS) [string trim $DebutSbjct] set TabBlast($FichierBlast,BanqueId,$BanqueId,Segment,$NbSegment,FS) [string trim $FinSbjct ] } set TabBlast($FichierBlast,BanqueId,$BanqueId,NbSegment) $NbSegment } set NomQuery [join $NomQuery " "] while {[regexp " " $NomQuery]} {regsub -all " " $NomQuery " " NomQuery} set TabBlast($FichierBlast,Query) $NomQuery set TabBlast($FichierBlast,Taille) [TailleDeLaQueryDuBlast $FichierBlast] set TabBlast($FichierBlast,NbSubject) $NbSubject return $aTabBlast } proc LoadCorrespondances {aTab FileCorrespondances} { ### Chargement des correspondances entre BoiteGscope BoiteProjet et DDseqini ### if {![file exists $FileCorrespondances]} { return } upvar $aTab Tab set Tab($FileCorrespondances,NbGscopeBox) 0 set Tab($FileCorrespondances,LesGscopeBox) {} set Tab($FileCorrespondances,LesProjetBox) {} set Tab($FileCorrespondances,LesIniSeqBox) {} set Tab($FileCorrespondances,LesClusters) {} set Tab($FileCorrespondances,LesDates) {} set F [open $FileCorrespondances] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {[regexp {^\#} $Ligne]} {continue} set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set GscopeBox [lindex $LaLigne 0] set ProjetBox [lindex $LaLigne 1] set IniSeqBox [lindex $LaLigne 2] set Orga [lindex $LaLigne 3] set Date [lindex $LaLigne 4] set Cluster [lindex $LaLigne 5] set Def [lindex $LaLigne 6] set VMasked [lindex $LaLigne 7] set RMasked [lindex $LaLigne 8] set GMasked [lindex $LaLigne 9] set LesExpr [lrange $LaLigne 10 end] incr Tab($FileCorrespondances,NbGscopeBox) lappend Tab($FileCorrespondances,LesGscopeBox) $GscopeBox lappend Tab($FileCorrespondances,LesProjetBox) $ProjetBox set Tab($FileCorrespondances,GscopeBox,$GscopeBox,IniSeqBox) $IniSeqBox set Tab($FileCorrespondances,GscopeBox,$GscopeBox,ProjetBox) $ProjetBox set Tab($FileCorrespondances,GscopeBox,$GscopeBox,Orga) $Orga set Tab($FileCorrespondances,GscopeBox,$GscopeBox,Date) $Date set Tab($FileCorrespondances,GscopeBox,$GscopeBox,Cluster) $Cluster set Tab($FileCorrespondances,GscopeBox,$GscopeBox,Def) $Def set Tab($FileCorrespondances,GscopeBox,$GscopeBox,VMasked) $VMasked set Tab($FileCorrespondances,GscopeBox,$GscopeBox,RMasked) $RMasked set Tab($FileCorrespondances,GscopeBox,$GscopeBox,GMasked) $GMasked set Tab($FileCorrespondances,GscopeBox,$GscopeBox,LesExpressions) $LesExpr set Tab($FileCorrespondances,ProjetBox,$ProjetBox,GscopeBox) $GscopeBox if {![info exists Tab($FileCorrespondances,IniSeqBox,$IniSeqBox,LesGscopeBox)]} { lappend Tab($FileCorrespondances,LesIniSeqBox) $IniSeqBox set Tab($FileCorrespondances,IniSeqBox,$IniSeqBox,LesGscopeBox) {} } lappend Tab($FileCorrespondances,IniSeqBox,$IniSeqBox,LesGscopeBox) $GscopeBox if {![info exists Tab($FileCorrespondances,Cluster,$Cluster,LesGscopeBox)]} { lappend Tab($FileCorrespondances,LesClusters) $Cluster set Tab($FileCorrespondances,Cluster,$Cluster,LesGscopeBox) {} set Tab($FileCorrespondances,Cluster,$Cluster,NbGscopeBox) 0 } incr Tab($FileCorrespondances,Cluster,$Cluster,NbGscopeBox) lappend Tab($FileCorrespondances,Cluster,$Cluster,LesGscopeBox) $GscopeBox if {![info exists Tab($FileCorrespondances,Date,$Date,LesGscopeBox)]} { lappend Tab($FileCorrespondances,LesDates) $Date set Tab($FileCorrespondances,Date,$Date,LesGscopeBox) {} } lappend Tab($FileCorrespondances,Date,$Date,LesGscopeBox) $GscopeBox } close $F return $aTab } proc LoadDB {} { global db set db "root" sqlite3 $db clientmail.sql set Lvar [$db eval {select distinct var from clientvar}] global {*}$Lvar update foreach {var key val} [$db eval {select var,key,val from clientvar}] { puts ">>$var<< >>$key<< >>$val<<" if {$key ne ""} { set ${var}($key) $val } else { set $var $val } } update return } proc LoadDBTSS {aTab} { ### Charge la banque DBTSS ### set FileDBTSS [DBTSSDir "TFAs"] if {![file exists $FileDBTSS]} { return } upvar $aTab Tab set Tab(LesId) {} Espionne "DBTSS TFA sequence loading ..." set Tab($FileDBTSS,LesDBTSS) {} foreach TFA [split [ContenuDuFichier $FileDBTSS] ">"] { set TFA [string trim $TFA] if {$TFA == ""} {continue} set TFA ">$TFA" if {![regexp -nocase {^>([0-9a-z]+)\:([0-9a-z_]+)} $TFA tmp ORG IdCourt]} { Espionne "Problem with : \n$TFA" continue } set Id "$ORG:$IdCourt" set Organism "Unknown unknown" if {$ORG == "MMU"} {set Organism "Mus musculus"} if {$ORG == "HSA"} {set Organism "Homo sapiens"} lappend Tab(LesId) $IdCourt set Tab($Id,Organism) $Organism set Tab($IdCourt,Organism) $Organism set Tab($Id,SeqTFA) $TFA set Tab($IdCourt,SeqTFA) $TFA } Espionne "DBTSS TFA sequence loaded." return $aTab } proc LoadEPDIdOrga {aTab} { ### Charge le fichier EPDIdOrga ### set FileEPDIdOrga [EPDDir "EPDIdOrga"] if {![file exists $FileEPDIdOrga]} {Espionne "File $FileEPDIdOrga does not exists" ; return } upvar $aTab Tab set Tab(LesEPDIds) {} set Tab(LesEPDOrgas) {} set Tab(LesEPDOrganisms) {} set Tab(LesEPDOrganismsLongs) {} Espionne "EPD Ids and EPD Organism loading ..." set Tab($FileEPDIdOrga,LesEPDIdsOrgas) {} set F [open $FileEPDIdOrga] while {[gets $F Ligne]>=0} { set LaLigne [split $Ligne "\t"] set EPDId [lindex $LaLigne 0] set EPDOrga [lindex $LaLigne 1] set EPDOrganism [lindex $LaLigne 2] set EPDOrganismLong [lindex $LaLigne 3] lappend Tab(LesEPDIds) $EPDId lappend Tab(LesEPDOrgas) $EPDOrga lappend Tab(LesEPDOrganisms) $EPDOrganism lappend Tab(LesEPDOrganismsLongs) $EPDOrganismLong lappend Tab(EPDOrga,$EPDOrga,LesEPDIds) $EPDId set Tab(EPDId,$EPDId,EPDOrga) $EPDOrga set Tab(EPDId,$EPDId,EPDOrganism) $EPDOrganism set Tab(EPDId,$EPDId,EPDOrganismLong) $EPDOrganismLong } close $F Espionne "EPD Ids and EPD Organism loaded." return $aTab } proc LoadEPDOrgas {aTab} { ### Charge le fichier EPDOrgas ### set FileEPDOrgas [EPDDir "EPDOrgas"] if {![file exists $FileEPDOrgas]} {Espionne "File $EPDOrgas does not exists"; return } upvar $aTab Tab set Tab(LesEPDOrgas) {} set Tab(LesEPDOrganisms) {} set Tab(LesEPDOrganismsLongs) {} Espionne "EPD Organism loading ..." set Tab($FileEPDOrgas,LesEPDOrgas) {} foreach Ligne [LesLignesDuFichier $FileEPDOrgas] { set LaLigne [split $Ligne "\t"] set EPDOrga [lindex $LaLigne 0] set EPDOrganism [lindex $LaLigne 1] set EPDOrganismLong [lindex $LaLigne 2] lappend Tab(LesEPDOrgas) $EPDOrga lappend Tab(LesEPDOrganisms) $EPDOrganism lappend Tab(LesEPDOrganismsLongs) $EPDOrganismLong set Tab(EPDOrga,$EPDOrga,EPDOrganism) $EPDOrganism set Tab(EPDOrga,$EPDOrga,EPDOrganismLong) $EPDOrganismLong set Tab(EPDOrganism,$EPDOrganism,EPDOrganismLong) $EPDOrganismLong } Espionne "EPD Organism loaded." return $aTab } proc LoadEponine {aTab FileEponine} { ### Chargement des resultats de Eponine ### if {![file exists $FileEponine]} { return } upvar $aTab Tab set Tab($FileEponine,LesEponines) {} set F [open $FileEponine] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {[regexp {^\#} $Ligne]} {continue} set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Debut [lindex $LaLigne 3] set Fin [lindex $LaLigne 4] set Score [format "%.6f" [lindex $LaLigne 5]] set Sens [lindex $LaLigne 6] if {![info exists Tab($FileEponine,NbEponines)]} { set Tab($FileEponine,NbEponines) 0 } incr Tab($FileEponine,NbEponines) set n [set Tab($FileEponine,NbEponines)] lappend Tab($FileEponine,LesEponines) $n set Tab($FileEponine,n,$n,D) $Debut set Tab($FileEponine,n,$n,F) $Fin set Tab($FileEponine,n,$n,Sens) $Sens set Tab($FileEponine,n,$n,Score) $Score } close $F return $aTab } proc LoadFileFichiers {w} { global CurrentPipe set Fichier [DemandeEtOuvreFichier ".tfa"] if {! [file exists $Fichier]} {return} $w selection clear $w insert end $Fichier set CurrentPipe(File,pjt) 0 update return } proc LoadFileInfosDuFileTFAs {aTab FileInfosDuFileTFAs} { ### Charge les informations du fichier TFAs### if {![file exists $FileInfosDuFileTFAs]} { Espionne "FileInfosDuFileTFAs: $FileInfosDuFileTFAs does not exists" return } upvar $aTab Tab set i 0 set F [open $FileInfosDuFileTFAs] while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set SeqName [lindex $LaLigne 0] set Id [lindex $LaLigne 1] set TailleSeq [lindex $LaLigne 2] set Entete [lindex $LaLigne 3] if {![info exists Tab($FileInfosDuFileTFAs,LesSeqNames)]} { set Tab($FileInfosDuFileTFAs,LesSeqNames) {} } lappend Tab($FileInfosDuFileTFAs,LesSeqNames) $SeqName set Tab($FileInfosDuFileTFAs,SeqName,$SeqName,Id) $Id set Tab($FileInfosDuFileTFAs,SeqName,$SeqName,SeqLength) $TailleSeq set Tab($FileInfosDuFileTFAs,SeqName,$SeqName,Entete) $Entete } close $F return $aTab } proc LoadFirstEF {aTab FileFirstEF} { ### Chargement des resultats de FirstEF ### if {![file exists $FileFirstEF]} { return } upvar $aTab Tab set Tab($FileFirstEF,LesSens) {} set F [open $FileFirstEF] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {![regexp {^[0-9]+} $Ligne]} {continue} regsub -all "\t" $Ligne " " Ligne regsub -all {\.\.} $Ligne " " Ligne regsub -all { [0]+} $Ligne " " Ligne regsub -all {\.} $Ligne "0." Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] set n [lindex $LaLigne 0] set DProm [lindex $LaLigne 1] set FProm [lindex $LaLigne 2] if {$DProm < $FProm} {set Sens "+"} else {set Sens "-"} set DProm [Mini [lindex $LaLigne 1] [lindex $LaLigne 2]] set FProm [Maxi [lindex $LaLigne 1] [lindex $LaLigne 2]] set PProm [lindex $LaLigne 3] set DExon [Mini [lindex $LaLigne 4] [lindex $LaLigne 5]] set FExon [Maxi [lindex $LaLigne 4] [lindex $LaLigne 5]] set PExon [lindex $LaLigne 6] set PDonor [lindex $LaLigne 7] set InfoCpG [lindex $LaLigne 8] if {$InfoCpG == "Non-CpG-related"} { set DCpG "" set FCpG "" } else { set InfoCpG "CpG-related" set DCpG [Mini [lindex $LaLigne 8] [lindex $LaLigne 9]] set FCpG [Maxi [lindex $LaLigne 8] [lindex $LaLigne 9]] } set Rank [lindex $LaLigne end] if {![info exists Tab($FileFirstEF,Sens,$Sens,LesPredictions)]} { lappend Tab($FileFirstEF,LesSens) $Sens set Tab($FileFirstEF,Sens,$Sens,LesPredictions) {} } if {![info exists Tab($FileFirstEF,Sens,$Sens,Prediction,$n,LesRangs)]} { lappend Tab($FileFirstEF,Sens,$Sens,LesPredictions) $n set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,LesRangs) {} } if {[info exists Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,PPromoter)]} {continue} lappend Tab($FileFirstEF,Sens,$Sens,Prediction,$n,LesRangs) $Rank set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,PPromoter) $PProm set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,DPromoter) $DProm set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,FPromoter) $FProm set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,DExon) $DExon set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,FExon) $FExon set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,PExon) $PExon set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,PDonor) $PDonor set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,InfoCpG) $InfoCpG if {$InfoCpG == "Non-CpG-related"} {continue} set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,DCpG) $DCpG set Tab($FileFirstEF,Sens,$Sens,Prediction,$n,Rang,$Rank,FCpG) $FCpG } close $F return $aTab } proc LoadFontesAscii {} { global FontAsc OrdEtcDir set f [file join $OrdEtcDir FontesGif.asc] array set FontAsc [ContenuDuFichier $f] return } proc LoadGOAnalyse {aTab FichierXML} { upvar $aTab Tab if {![file exists $FichierXML]} {return} set SuisJeSur_GO_ANALYSE 0 set QuelMethode "" set QuelGO "" set QuelType "" set F [open $FichierXML] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {![regexp -nocase {<([^ |^>]+)} $Ligne tmp Balise]} {continue} if {$Balise == "GO_ANALYSE"} { if {![regexp -nocase {PID_MIN\=\"([0-9\.e\-\+]+)\"} $Ligne tmp Tab($FichierXML,IdMin) ]} {return} if {![regexp -nocase {NORMD_MIN\=\"([0-9\.e\-\+]+)\"} $Ligne tmp Tab($FichierXML,NorMDMin)]} {return} if {![regexp -nocase {P_MIN\=\"([0-9\.e\-\+]+)\"} $Ligne tmp Tab($FichierXML,PMin) ]} {return} if {![regexp -nocase {F_MIN\=\"([0-9\.e\-\+]+)\"} $Ligne tmp Tab($FichierXML,FMin) ]} {return} set Tab($FichierXML,LesMethodes) {} set Tab($FichierXML,LesAccess) {} set SuisJeSur_GO_ANALYSE 1 continue } if {$Balise == "/GO_ANALYSE"} {break} #Espionne "$Ligne $SuisJeSur_GO_ANALYSE" if {!$SuisJeSur_GO_ANALYSE} {continue} if {$Balise == "INPUT"} { if {![regexp -nocase {QUERY_ID\=\"([^\"]*)\"} $Ligne tmp Tab($FichierXML,Query,Id) ]} {return} if {![regexp -nocase {QUERY_NAME\=\"([^\"]+)\"} $Ligne tmp Tab($FichierXML,Query,Name)]} {return} continue } if {$Balise == "/INPUT"} {continue} if {$Balise == "MSF_FILE"} { if {![regexp -nocase {>([^<]*)<} $Ligne tmp Tab($FichierXML,Fichier,MSF)]} {return} continue } if {$Balise == "CLUST_FILE"} { if {![regexp -nocase {>([^<]*)<} $Ligne tmp Tab($FichierXML,Fichier,CLUST)]} {return} continue } if {$Balise == "OUTPUT" || $Balise == "/OUTPUT"} {continue} if {$Balise == "IPO" } {set QuelMethode "IPO";continue} if {$Balise == "/IPO"} {set QuelMethode "" ;continue} if {$Balise == "PPO" } {set QuelMethode "PPO";continue} if {$Balise == "/PPO"} {set QuelMethode "" ;continue} if {$Balise == "MSO" } {set QuelMethode "MSO";continue} if {$Balise == "/MSO"} {set QuelMethode "" ;continue} if {$Balise == "GPO" } {set QuelMethode "GPO";continue} if {$Balise == "/GPO"} {set QuelMethode "" ;continue} if {$QuelMethode == ""} {continue} if {![info exists Tab($FichierXML,Methode,$QuelMethode,LesTypes)]} { lappend Tab($FichierXML,LesMethodes) $QuelMethode set Tab($FichierXML,Methode,$QuelMethode,LesAccess) {} set Tab($FichierXML,Methode,$QuelMethode,LesTypes) {} } if {$Balise == "GO"} { if {![regexp -nocase {GO_ID\=\"([^\"]+)\"} $Ligne tmp QuelGO ]} {set QuelGO "";set QuelType "";continue} if {![regexp -nocase {GO_TYPE\=\"([^\"]+)\"} $Ligne tmp QuelType ]} {set QuelGO "";set QuelType "";continue} if {![regexp -nocase {GO_DEFINITION\=\"([^\"]*)\"} $Ligne tmp Def ]} {set QuelGO "";set QuelType "";continue} if {![regexp -nocase {NB_SUBJECT\=\"([0-9\.e\+]+)\"} $Ligne tmp NbSubject]} {set QuelGO "";set QuelType "";continue} if {![info exists Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,LesGO)]} { set Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,LesGO) {} lappend Tab($FichierXML,Methode,$QuelMethode,LesTypes) $QuelType } if {![info exists Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,GO,$QuelGO,LesAccess)]} { set Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,GO,$QuelGO,LesAccess) {} } lappend Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,LesGO) $QuelGO set Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,GO,$QuelGO,NbAccess) $NbSubject set Tab($FichierXML,Type,$QuelType,GO,$QuelGO,Definition) $Def continue } if {$Balise == "/GO"} {set QuelGO "";set QuelType "";continue} if {$QuelGO == "" || $QuelType == ""} {continue} if {$Balise == "SUBJECT"} { if {![regexp -nocase {>([^<]+)<} $Ligne tmp Access]} {continue} if {![info exists Tab($FichierXML,Methode,$QuelMethode,Access,$Access,LesTypes)]} { set Tab($FichierXML,Methode,$QuelMethode,Access,$Access,LesTypes) {} lappend Tab($FichierXML,Methode,$QuelMethode,LesAccess) $Access } if {![info exists Tab($FichierXML,Methode,$QuelMethode,Access,$Access,Types,$QuelType,LesGO)]} { lappend Tab($FichierXML,Methode,$QuelMethode,Access,$Access,LesTypes) $QuelType set Tab($FichierXML,Methode,$QuelMethode,Access,$Access,Types,$QuelType,LesGO) {} } lappend Tab($FichierXML,Methode,$QuelMethode,Type,$QuelType,GO,$QuelGO,LesAccess) $Access lappend Tab($FichierXML,Methode,$QuelMethode,Access,$Access,Type,$QuelType,LesGO) $QuelGO continue } } close $F return $aTab } proc LoadGODB {aTab} { upvar $aTab Tab set Tab(LesTypes) {} set Tab(LesGO) {} foreach Fichier [LesFichiersGO] { if {![file exists $Fichier]} {continue} set Type [FichierGO2Type $Fichier] lappend Tab(LesTypes) $Type set Tab(Type,$Type,LesGO) {} Espionne "GODB -> $Type ontology loading ..." set F [open $Fichier] while {[gets $F Ligne]>=0} { if {$Ligne == "" || [regexp "^!" $Ligne]} {continue} set Espace "" regexp {^([ ]*)} $Ligne tmp Espace set Niveau 0 set Niveau [string length $Espace] set PosTmp [string first "GO:" $Ligne] set GOTmp [string range $Ligne [expr $PosTmp] end] set GOTmp [lindex [split $GOTmp {;|%|<}] 0] regsub -all " " $GOTmp "" GOTmp set LesGO [split $GOTmp ","] set GO [lindex $LesGO 0 ] if {![info exists Tab(GO,$GO,LesTypes)]} { set Tab(GO,$GO,LesTypes) {} set Tab(Type,$Type,GO,$GO,LesSynonymes) {} lappend Tab(Type,$Type,LesGO) $GO lappend Tab(LesGO) $GO } foreach Synonyme [lrange $LesGO 1 end] { if {![info exists Tab(GO,$Synonyme,LesTypes)]} {set Tab(GO,$Synonyme,LesTypes) {}} if { [info exists Tab(Type,$Type,GOSynonyme,$Synonyme,GODeRef)]} {continue} lappend Tab(GO,$Synonyme,LesTypes) $Type set Tab(Type,$Type,GOSynonyme,$Synonyme,GODeRef) $GO lappend Tab(Type,$Type,GO,$GO,LesSynonymes) $Synonyme } set Tab(Type,$Type,GOSynonyme,$GO,GODeRef) $GO if {0 < [string first "<" $GO]} { set GO [string range $GO 0 [expr [string first "<" $GO ] - 1]] } if {0 < [string first "%" $GO]} { set GO [string range $GO 0 [expr [string first "%" $GO ] - 1]] } set Ligne [string trim $Ligne] set TabTmp($Niveau) $GO if {![info exists Tab(Type,$Type,GO,$GO,LesNiveaux) ]} { set Tab(Type,$Type,GO,$GO,LesNiveaux) {} lappend Tab(GO,$GO,LesTypes) $Type } if {![info exists Tab(Type,$Type,LesNiveaux) ]} {set Tab(Type,$Type,LesNiveaux) {}} if {![info exists Tab(Type,$Type,Niveau,$Niveau,LesGO) ]} { set Tab(Type,$Type,Niveau,$Niveau,LesGO) {} lappend Tab(Type,$Type,LesNiveaux) $Niveau } if {![info exists Tab(Type,$Type,GO,$GO,LesEC) ]} {set Tab(Type,$Type,GO,$GO,LesEC) {}} if {![info exists Tab(Type,$Type,GO,$GO,LesParents) ]} {set Tab(Type,$Type,GO,$GO,LesParents) {}} if {![info exists Tab(Type,$Type,GO,$GO,LesConstituants) ]} {set Tab(Type,$Type,GO,$GO,LesConstituants) {}} if {![info exists Tab(Type,$Type,GO,$GO,LesContributions)]} {set Tab(Type,$Type,GO,$GO,LesContributions) {}} if {![info exists Tab(Type,$Type,GO,$GO,LesEnfants) ]} {set Tab(Type,$Type,GO,$GO,LesEnfants) {}} lappend Tab(Type,$Type,GO,$GO,LesNiveaux) $Niveau lappend Tab(Type,$Type,Niveau,$Niveau,LesGO) $GO if {[regexp "^\\$" $Ligne]} { set Definition [string trim [string range [lindex [split $Ligne ";"] 0] 1 end]] regsub -all {\\} $Definition "" Definition lappend Tab(Type,$Type,GO,$GO,LesDefinitions) $Definition continue } if {[regexp -nocase "^%" $Ligne]} { set LOrigineDesEnfants "LesEnfants"; set LOrigineDesParents "LesParents" regsub "^%" $Ligne "" Ligne } if {[regexp -nocase "^<" $Ligne]} { set LOrigineDesEnfants "LesContributions";set LOrigineDesParents "LesConstituants" regsub "^<" $Ligne "" Ligne } set NiveauInf [expr $Niveau - 1] set GOInf [set TabTmp($NiveauInf)] if {![info exists Tab(Type,$Type,GO,$GOInf,LesEnfants) ]} {set Tab(Type,$Type,GO,$GOInf,LesEnfants) {}} if {![info exists Tab(Type,$Type,GO,$GOInf,LesContributions)]} {set Tab(Type,$Type,GO,$GOInf,LesContributions) {}} if {![info exists TabTmp($GO,$GOInf)] && ![info exists TabTmp($GOInf,$GO)]} { lappend Tab(Type,$Type,GO,$GO,$LOrigineDesParents) $GOInf lappend Tab(Type,$Type,GO,$GOInf,$LOrigineDesEnfants) $GO set TabTmp($GO,$GOInf) 1 set TabTmp($GOInf,$GO) 1 } set Pos1 [string first "%" $Ligne] set Pos2 [string first "<" $Ligne ] #######Le GO principal de la ligne################## if { $Pos1 != -1 && $Pos2 != -1 && $Pos1 < $Pos2} { set ElementsDuGO [string range $Ligne 0 [expr $Pos1-1]] set Ligne [string range $Ligne $Pos1 end] } elseif {$Pos1 != -1 && $Pos2 != -1 && $Pos2 < $Pos1} { set ElementsDuGO [string range $Ligne 0 [expr $Pos2-1]] set Ligne [string range $Ligne $Pos2 end] } elseif {$Pos1 == -1 && $Pos2 != -1} { set ElementsDuGO [string range $Ligne 0 [expr $Pos2-1]] set Ligne [string range $Ligne $Pos2 end] } elseif {$Pos1 != -1 && $Pos2 == -1} { set ElementsDuGO [string range $Ligne 0 [expr $Pos1-1]] set Ligne [string range $Ligne $Pos1 end] } else { set ElementsDuGO $Ligne set Ligne "" } set LesElementsTmp [split [string trim $ElementsDuGO] "\;"] set LesElementsDuGO {} foreach Element $LesElementsTmp {lappend LesElementsDuGO [string trim $Element]} if {![info exists Tab(Type,$Type,GO,$GO,LesDefinitions)]} { set Tab(Type,$Type,GO,$GO,LesDefinitions) {} set Definition [lindex $LesElementsDuGO 0] regsub -all {\\} $Definition "" Definition lappend Tab(Type,$Type,GO,$GO,LesDefinitions) $Definition foreach Element $LesElementsDuGO { if {[regexp "synonym:" $Element]} { regsub "synonym:" $Element "" Element regsub -all {\\} $Element "" Element lappend Tab(Type,$Type,GO,$GO,LesDefinitions) [string trim $Element] } elseif {[regexp "EC:" $Element]} { lappend Tab(Type,$Type,GO,$GO,LesEC) [string trim $Element] } } } } Espionne "GODB -> $Type ontology loaded" if {[info exists TabTmp]} {unset TabTmp} close $F if {0} { #######GO Nothing########################################## set GONothing "GO:nothing" set Niveau 1 set Definition "No $Type ontology" set GOPere [set Tab(Type,$Type,Niveau,[expr $Niveau - 1],LesGO)] set Tab(Type,$Type,Nothing) $GONothing set Tab(Type,$Type,GO,$GONothing,LesSynonymes) {} set Tab(Type,$Type,GO,$GONothing,LesNiveaux) {} set Tab(Type,$Type,GO,$GONothing,LesEC) {} set Tab(Type,$Type,GO,$GONothing,LesParents) {} set Tab(Type,$Type,GO,$GONothing,LesConstituants) {} set Tab(Type,$Type,GO,$GONothing,LesContributions) {} set Tab(Type,$Type,GO,$GONothing,LesEnfants) {} lappend Tab(Type,$Type,GO,$GOPere,LesEnfants) $GONothing lappend Tab(Type,$Type,GO,$GONothing,LesNiveaux) $Niveau lappend Tab(Type,$Type,GO,$GONothing,LesDefinitions) $Definition lappend Tab(Type,$Type,Niveau,$Niveau,LesGO) $GONothing lappend Tab(Type,$Type,GO,$GONothing,LesParents) $GOPere lappend Tab(LesGO) $GONothing lappend Tab(Type,$Type,LesGO) $GONothing } } return $aTab } proc LoadGOGraph {} { package require struct::graph if {[lsearch -exact [info commands] "GOGraph"] != -1} {return} ::struct::graph GOGraph set ontologyOboFile "[GenomicsSubDir "Ontology"]/Ontology/gene_ontology.obo" Espionne "Reading $ontologyOboFile..." set inHeader 1 foreach line [LesLignesDuFichier $ontologyOboFile] { if {$line eq ""} {continue} if {[regexp {^\[(.+)\]$} $line regMatch stanza]} { set inHeader 0 } elseif {!$inHeader} { if {[string index $line 0] eq "!"} {continue} # BUG regexp : une subexpr non-greedy rends les suivantes non-greedy # regexp {^((?:\\:|[^:])+?): ((?:\\!|[^!])*)} $line regMatch tag tagValue # Workaround en 2 temps 3 regexp... Trop la loose regexp {^((?:\\:|[^:])+?): } $line regMatch tag regexp {^((?:\\!|[^!])*)} [regsub {^((?:\\:|[^:])+?): } $line ""] regMatch tagValue set tagValue [string trim $tagValue] if {[regexp { \{((?:\\\}|[^\}])+)\}$} $tagValue regMatch modifiers]} { regsub { \{((?:\\\}|[^\}])+)\}$} $tagValue "" tagValue } else { set modifiers "" } switch -exact $stanza { "Term" { switch -exact $tag { "id" { set id $tagValue if {![GOGraph node exists $id]} {GOGraph node insert $id} } "name" { GOGraph node set $id "name" $tagValue } "namespace" { GOGraph node set $id "namespace" $tagValue } "alt_id" { GOGraph node lappend $id "alternateIDs" $tagValue } "def" { regexp {^\"((?:\\\"|[^\"])+)\"} $tagValue regMatch def GOGraph node set $id "definition" $def } "synonym" { regexp {^\"((?:\\\"|[^\"])+)\"} $tagValue regMatch synonym GOGraph node lappend $id "synonyms" $synonym } "xref" { GOGraph node lappend $id "xrefs" $tagValue } "is_a" { if {$tagValue eq ""} { puts "OUPS ($line) $tag = $tagValue" } if {![GOGraph node exists $tagValue]} {GOGraph node insert $tagValue} GOGraph arc insert $id $tagValue } } } } } } Espionne "Finished." } proc LoadLMS {aTabLMS FichierBallast} { upvar $aTabLMS TabLMS set FichierMotifs "$FichierBallast.motifs" if {![file exists $FichierMotifs]} {return} set NbLMS 0 set TabLMS($FichierBallast,LesLMS) {} set TabLMS($FichierBallast,LesAccess) {} set LesDebutsEtFins {} set F [open $FichierMotifs] while {[gets $F Ligne]>=0} { regsub -all { |\t} $Ligne "" Ligne if {![regexp {^[0-9]+\-[0-9]+} $Ligne]} {continue} set LesElements [split $Ligne ":"] set LesBornes [split [lindex $LesElements 0] "-"] set Debut [Mini [lindex $LesBornes 0] [lindex $LesBornes 1]] set Fin [Maxi [lindex $LesBornes 0] [lindex $LesBornes 1]] incr NbLMS lappend TabLMS($FichierBallast,LesLMS) $NbLMS set TabLMS($FichierBallast,LMS,$NbLMS,Debut) $Debut set TabLMS($FichierBallast,LMS,$NbLMS,Fin) $Fin set TabLMS($FichierBallast,LMS,$NbLMS,Motif) [lindex $LesElements 1] set TabLMS($FichierBallast,LMS,$NbLMS,Score) [lindex $LesElements 2] set TabLMS($FichierBallast,LMS,$NbLMS,LesAccess) {} if {![info exists TabLMS($FichierBallast,Debut,$Debut,Fin,$Fin,LesLMS)]} {set TabLMS($FichierBallast,Debut,$Debut,Fin,$Fin,LesLMS) {}} lappend TabLMS($FichierBallast,Debut,$Debut,Fin,$Fin,LesLMS) $NbLMS lappend LesDebutsEtFins [list $Debut $Fin] } close $F set TabLMS($FichierBallast,NbLMS) $NbLMS set FichierAnchors "$FichierBallast.anchors" if {![file exists $FichierAnchors]} {return} set F [open $FichierAnchors] while {[gets $F Ligne]>=0} { while {[regexp { |\t} $Ligne]} {regsub -all { |\t} $Ligne " " Ligne} if {$Ligne == ""} {continue} set LaLigne [split $Ligne " "] if {![string equal -nocase [lindex $LaLigne 0] "seq:"]} {continue} set Access1 [string toupper [lindex $LaLigne 1 ]] regsub {^[^\|]+\|} $Access1 "" Access1 set Access2 [string toupper [lindex $LaLigne 2 ]] regsub {^[^\|]+\|} $Access2 "" Access2 if {![info exists TabLMS($FichierBallast,Access,$Access1,LesLMS)]} { lappend TabLMS($FichierBallast,LesAccess) $Access1 set TabLMS($FichierBallast,Access,$Access1,LesLMS) {} } if {![info exists TabLMS($FichierBallast,Access,$Access2,LesLMS)]} { lappend TabLMS($FichierBallast,LesAccess) $Access2 set TabLMS($FichierBallast,Access,$Access2,LesLMS) {} } set Deb [Mini [lindex $LaLigne 4 ] [lindex $LaLigne 6 ]] set Fin [Maxi [lindex $LaLigne 4 ] [lindex $LaLigne 6 ]] set Score [lindex $LaLigne 11] foreach LeDebutEtLaFin $LesDebutsEtFins { set DLMS [lindex $LeDebutEtLaFin 0] set FLMS [lindex $LeDebutEtLaFin 1] if {![CesRegionsSontEllesOverlappantes $Deb $Fin $DLMS $FLMS]} {continue} foreach nLMS [set TabLMS($FichierBallast,Debut,$DLMS,Fin,$FLMS,LesLMS)] { if {![info exists TabTmp($nLMS,$Access1)]} { lappend TabLMS($FichierBallast,LMS,$nLMS,LesAccess) $Access1 set TabTmp($nLMS,$Access1) 1 lappend TabLMS($FichierBallast,Access,$Access1,LesLMS) $nLMS set TabLMS($FichierBallast,Access,$Access1,LMS,$nLMS,Debut) $Deb set TabLMS($FichierBallast,Access,$Access1,LMS,$nLMS,Fin) $Fin set TabLMS($FichierBallast,Access,$Access1,LMS,$nLMS,Score) $Score } if {![info exists TabTmp($nLMS,$Access2)]} { lappend TabLMS($FichierBallast,LMS,$nLMS,LesAccess) $Access2 set TabTmp($nLMS,$Access2) 1 lappend TabLMS($FichierBallast,Access,$Access2,LesLMS) $nLMS set TabLMS($FichierBallast,Access,$Access2,LMS,$nLMS,Debut) $Deb set TabLMS($FichierBallast,Access,$Access2,LMS,$nLMS,Fin) $Fin set TabLMS($FichierBallast,Access,$Access2,LMS,$nLMS,Score) $Score } } } } close $F return $aTabLMS } proc LoadMatch {aTab FileMatch} { ### Charge la sortie du programme match ### if {![file exists $FileMatch]} { return } upvar $aTab Tab set Tab($FileMatch,LesMotifs) {} set SuisJeSurLesInfos 0 set F [open $FileMatch] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} ### Remplace tous les "$" par un "_" dans les Id ### set Ligne [regsub -all {\$} $Ligne "_"] if {[regexp "^Inspecting sequence" $Ligne]} { set SuisJeSurLesInfos 1 continue } if {[regexp "^Total" $Ligne]} { set SuisJeSurLesInfos 0 break } if {!$SuisJeSurLesInfos} {continue} if {[regexp {\(([\+\-]+)\)} $Ligne tmp Sens]} { regsub {\([\+\-]+\)} $Ligne $Sens Ligne } regsub -all {\|} $Ligne " " Ligne while {[regexp " " $Ligne]} {regsub -all " " $Ligne " " Ligne} set LaLigne [split $Ligne " "] set MotifId [lindex $LaLigne 0] set DebutMotif [lindex $LaLigne 1] set Sens [lindex $LaLigne 2] set ScoreCoreMatch [lindex $LaLigne 3] set ScoreMotifMatch [lindex $LaLigne 4] set MatchingSequence [lindex $LaLigne 5] set FinMotif [expr $DebutMotif + [string length $MatchingSequence] -1] if {![info exists Tab($FileMatch,Motif,$MotifId,NbPresence)]} { set Tab($FileMatch,Motif,$MotifId,NbPresence) 0 lappend Tab($FileMatch,LesMotifs) $MotifId } incr Tab($FileMatch,Motif,$MotifId,NbPresence) #i est le numero donne a chacun des motifs set i [set Tab($FileMatch,Motif,$MotifId,NbPresence)] set Tab($FileMatch,Motif,$MotifId,n,$i,Debut) $DebutMotif set Tab($FileMatch,Motif,$MotifId,n,$i,Fin) $FinMotif set Tab($FileMatch,Motif,$MotifId,n,$i,Sens) $Sens set Tab($FileMatch,Motif,$MotifId,n,$i,Sequence) $MatchingSequence set Tab($FileMatch,Motif,$MotifId,n,$i,ScoreCore) $ScoreCoreMatch set Tab($FileMatch,Motif,$MotifId,n,$i,ScoreMotif) $ScoreMotifMatch } close $F return $aTab } proc LoadMatchMatrixAccess2Id2Name {aTab FileMatchMatrixLibrary} { ### Chargement du fichier d'informations sur la librairie de matrices de Match ### if {![file exists $FileMatchMatrixLibrary]} { return } upvar $aTab Tab set F [open $FileMatchMatrixLibrary] # Creation d'une PageInfo par matrice # ### Attention, la derniere page info est "NUMBER_OF_MATRIXES 172" ### set LesPagesInfos {} set LaPageInfo {} while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} ### Remplace tous les "$" par un "_" dans les Id ### set Ligne [regsub -all {\$} $Ligne "_"] lappend LaPageInfo $Ligne if {[regexp "//" $Ligne]} { if {$LaPageInfo != {}} {lappend LesPagesInfos [join $LaPageInfo "\n"]} set LaPageInfo {} } } close $F if {$LaPageInfo != ""} {lappend LesPagesInfos [join $LaPageInfo "\n"]} set LaPageInfo {} #Espionne "NbPagesInfos: [llength $LesPagesInfos]" set Tab($FileMatchMatrixLibrary,LesAccess) {} set Tab($FileMatchMatrixLibrary,LesId) {} foreach PageInfo $LesPagesInfos { if {![regexp -nocase {AC[ \t]+([0-9a-z]+)\n} $PageInfo tmp Access]} {continue} if {![regexp -nocase {ID[ \t]+([0-9a-z_\$]+)\n} $PageInfo tmp Id ]} {continue} set Def "" regexp -nocase {NA[ \t]+([^\n]+)\n} $PageInfo tmp Def if {![info exists Tab($FileMatchMatrixLibrary,Access,$Access,Id)]} { lappend Tab($FileMatchMatrixLibrary,LesAccess) $Access set Tab($FileMatchMatrixLibrary,Access,$Access,Id) $Id set Tab($FileMatchMatrixLibrary,Access,$Access,Name) $Def set Tab($FileMatchMatrixLibrary,Access,$Access,Info) $PageInfo } if {![info exists Tab($FileMatchMatrixLibrary,Id,$Id,Access)]} { lappend Tab($FileMatchMatrixLibrary,LesId) $Id set Tab($FileMatchMatrixLibrary,Id,$Id,Access) $Access set Tab($FileMatchMatrixLibrary,Id,$Id,Name) $Def set Tab($FileMatchMatrixLibrary,Id,$Id,Info) $PageInfo } } if {0} { foreach PageInfo $LesPagesInfos { foreach Info $LaPageInfo { set Info [string trim $Info] if {$Info == ""} {continue} if {[lindex $Info 0] == "AC"} {set Access [lindex $Info 1]} if {[lindex $Info 0] == "ID"} {set Id [lindex $Info 1]} if {[lindex $Info 0] == "NA"} {set Name [lindex $Info 1]} } set Tab($FileMatchMatrixLibrary,Access,$Access,Id) $Id set Tab($FileMatchMatrixLibrary,Access,$Access,Name) $Name set Tab($FileMatchMatrixLibrary,Id,$Id,Access) $Access set Tab($FileMatchMatrixLibrary,Id,$Id,Name) $Name #Espionne "Access,Id: $Access [set Tab($FileMatchMatrixLibrary,Access,$Access,Id)]" #Espionne "Access,Name: $Access [set Tab($FileMatchMatrixLibrary,Access,$Access,Name)]" #Espionne "Id,Access: $Id [set Tab($FileMatchMatrixLibrary,Id,$Id,Access)]" #Espionne "Id,Name: $Id [set Tab($FileMatchMatrixLibrary,Id,$Id,Name)]" lappend LesAccess $Access lappend LesId $Id } set Tab($FileMatchMatrixLibrary,LesAccess) $LesAccess set LesSingleAccess [lsort -unique $LesAccess] set LesSingleId [lsort -unique $LesId] #Espionne "LesSingleAccess: [llength $LesSingleAccess]" #Espionne "LesSingleId: [llength $LesSingleId]" } return $aTab } proc LoadMySql {} { foreach couple { { "platypus" "OrnAna1"} { "stickleback" "GasAcu1"} { "tetraodon" "TetNig1"} {"horse" "EquCab2"} {"rhesus" "RheMac2"} {"cow BosTau4"} {"guineapig" "CavPor3"}} { set org [lindex $couple 0] set genome [lindex $couple 1] Espionne "$org $genome" WgetAndLoadIntoDOPAmySql $org $genome } } proc LoadNorMD {} { global LNorMD #set rep [file join [RepGenLuc] msf_nature Rascal Leon] #aF travaille sur les msf de rascal set rep [file join [RepGenLuc] msf_nature Rascal] set Ll [LesLignesDuFichier [file join $rep "NorMD.out"]] set Tot 0. set Inf 0 set Tsp 0. foreach l $Ll { set f [lindex $l 0] set n [lindex $l 1] set LNorMD($f) $n set Tot [expr {$Tot + $n}] if {$n < 0.3} { incr Inf } else { set Tsp [expr {$Tsp + $n}] } } puts "" puts "Nombre alignt ........: [llength $Ll]" puts "Nombre alignt > 0.3 ..: [expr {[llength $Ll] - $Inf}]" puts "NorMD moyen ..........: [expr {$Tot / [llength $Ll]}]" puts "NorMD > 0.4 moyen ....: [expr {$Tsp /([llength $Ll] - $Inf)}]" puts "" return } proc LoadNouveauPDB {IdOrFile {pdbid ""} {init 0} {indb 1}} { global HashPDB ListePDB Warn if {$pdbid eq ""} { set pdbid $IdOrFile set file $IdOrFile } else { set file $IdOrFile } Structure create $pdbid set cok [$pdbid new $file "" $init $indb] if {$cok == 0} { # Problem : bad pdb ? lappend Warn(BadPdb) $pdbid set Warn($pdbid) 1 $pdbid destroy return 0 } # Obsolete or superseeded if {$cok != 1} { lassign $cok what newid if {$what eq "superseeded"} { set cmdId $newid set newid "::$newid" if {$cmdId ni [info commands]} { $pdbid CopiePDB $newid $pdbid destroy set pdbid $newid } } else { # obsolete, reload $pdbid destroy set pdbid $newid Structure create $pdbid set cok [$pdbid new $pdbid] if {$cok == 0} { lappend Warn(BadPdb) $pdbid set Warn($pdbid) 1 $pdbid destroy return 0 } } set cok $pdbid } # record the new pdbid if {! [info exists HashPDB]} { set HashPDB(iHmax) 0 } set iH $HashPDB(iHmax) if {[string range $pdbid 0 1] eq "::"} { set pdbid [string range $pdbid 2 end] } set HashPDB(${pdbid}) $iH set HashPDB($iH) ${pdbid} incr iH set HashPDB(iHmax) $iH return $cok } proc LoadObjFromDB {} { global db if {! [info exists db] || $db eq ""} { return 0 } set nobj 0 foreach t [GetTables] { if {! [regexp {^obj\_} $t]} {continue} set pdb [lsort -unique [$db eval "select p.name from pdb as p, $t as o where o.pk_pdb=p.pk_pdb"]] set obj $t $pdb newObj $obj 1 $pdb updateObjFlags $obj $pdb render $obj incr nobj } return $nobj } proc LoadProject {p} { global OPjt db set db "root" sqlite3 $db $OPjt(Dir).opjt set Lfroot [$db eval {select fileroot from files where ord=1}] set w $OPjt(Window) destroy {*}[winfo children $w] label $w.ldef -text "Ordalie project : $p" -font "Helvetica 14 bold" -anchor w -justify left label $w.ltitle -text "Click on an alignment to launch Ordalie" -anchor w -justify left # create frame with all files to display set wf $w.ffiles frame $wf grid columnconfig $w.ffiles all -weight 1 set lg [PlusLongEltDe $Lfroot] set sz [SizeOfFont FntPrjt] set NbrPerLine [expr {floor(750./($lg * $sz))}] set i 0 ; set j 0 foreach f $Lfroot { button $wf.bf${i}_${j} -text "$f" -background green1 -command [list LanceProtDeProjet $f] grid $wf.bf${i}_${j} -row $j -column $i -ipady 2 -ipadx 2 incr i if {$i == $NbrPerLine} { set i 0 incr j } } # buttons button $w.bsum -text "Create Summary" -background green1 -command CreateSummaryProject button $w.bclose -text "Close" -background red -command {destroy [winfo toplevel %W]} grid $w.ldef -row 0 -column 0 -columnspan 2 -sticky w -padx 5 -pady 10 grid $w.ltitle -row 1 -column 0 -columnspan 2 -sticky w -padx 5 -pady 5 grid $wf -row 2 -column 0 -columnspan 2 -sticky news -padx 5 -pady 5 grid $w.bclose -row 3 -column 0 -sticky w -pady {20 10} -padx 5 grid $w.bsum -row 3 -column 1 -sticky e -pady {20 10} -padx 5 FenetreAuCentre $w return } proc LoadPromAn {aTab File} { ### Charge les donnees de l'analyse de promoteurs ### if {![file exists $File]} { return } upvar $aTab Tab set Tab($File,LesPromoterInfos) {} set Tab($File,LesResultTypes) {} set i 0 set F [open $File] set Tab(LesEntetes) {} while {[gets $F Ligne]>=0} { if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set ResultType [lindex $LaLigne 1] set Method [lindex $LaLigne 0] set Debut [lindex $LaLigne 2] set Fin [lindex $LaLigne 3] set Sens [lindex $LaLigne 4] set TSSLoc [lindex $LaLigne 5] set TSSDist [lindex $LaLigne 6] set Identity [lindex $LaLigne 7] set Name [lindex $LaLigne 8] set Orga [lindex $LaLigne 9] set LesInfosSup [lrange $LaLigne 10 end] if {![info exists Tab($File,ResultType,$ResultType,LesMethods)]} { set Tab($File,ResultType,$ResultType,LesMethods) {} lappend Tab($File,LesResultTypes) $ResultType } if {![info exists Tab($File,ResultType,$ResultType,Method,$Method,n)]} { lappend Tab($File,ResultType,$ResultType,LesMethods) $Method set Tab($File,ResultType,$ResultType,Method,$Method,n) 0 } incr Tab($File,ResultType,$ResultType,Method,$Method,n) set n [set Tab($File,ResultType,$ResultType,Method,$Method,n)] set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,D) $Debut set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,F) $Fin set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,Sens) $Sens if {$Name != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,Name) $Name } if {$TSSLoc != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,TSSLoc) $TSSLoc } if {$TSSDist != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,TSSDist) $TSSDist } if {$Identity != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,Identity) $Identity } if {$Orga != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,Organism) $Orga } if {$LesInfosSup != ""} {set Tab($File,ResultType,$ResultType,Method,$Method,n,$n,LesInfosSup) $LesInfosSup} } close $F return $aTab } proc LoadReference {} { global ConsRef unset ConsRef set Lf [LesLignesDuFichier "logasp.all"] foreach l $Lf { set Ll [split $l ":"] set ng [lindex $Ll 0] set lr [lindex $Ll 1] regsub -all {\.} $ng "" ng regsub -all {\(} $lr "" lr regsub -all {\)} $lr "" lr regsub -all " " $lr "" lr set Res [split $lr ","] set ConsRef($ng) $Res } return } proc LoadReferencePDB {} { global TNResConsNSA TNResConsSA ConsRef set rep [file join [RepGenLuc] AnalyseSelection] set Ll [LesLignesDuFichier [file join $rep "resSitePDB.txt"]] set sa 0 set sna 0 set NResConsSA 0 set NResConsNSA 0 set Prems 1 foreach l $Ll { if {[regexp {^gPDB} $l]} { if {$Prems} { set Prems 0 } else { set TNResConsSA($f) $NResConsSA set TNResConsNSA($f) $NResConsNSA set NResConsSA 0 set NResConsNSA 0 } set f [lindex $l 0] continue } if {[regexp "site actif" $l]} { set sa 1 set sna 0 continue } if {[regexp "site non actif" $l]} { set sna 1 set sa 0 continue } if {[regexp {^[A-Z]} $l]} { set aa [lindex $l 0] set n [lindex $l 1] if {$sa} { lappend ConsRef($f,sa) $aa $n incr NResConsSA } else { lappend ConsRef($f,sna) $aa $n incr NResConsNSA } continue } } set TNResConsSA($f) $NResConsSA set TNResConsNSA($f) $NResConsNSA return } proc LoadSelectedEST {aTab File} { upvar $aTab Tab set Tab($File,LesNoms) {} set Tab($File,LesAccess) {} set F [open $File] while {[gets $F Ligne]>=0} { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} set LaLigne [split $Ligne "\t"] set Nom [lindex $LaLigne 0] set Id [lindex $LaLigne 1] if {$Id == "NoESTFound"} {continue} set Quoi [lindex $LaLigne 2] #rR a mis le tolower sur conseil de Laetitia set Qui [string tolower [lindex $LaLigne 3]] set Cat "Les$Quoi" if {![info exists Tab($File,Nom,$Nom,$Cat) ]} {set Tab($File,Nom,$Nom,$Cat) {}} if {![info exists Tab($File,Access,$Id,$Cat)]} {set Tab($File,Access,$Id,$Cat) {}} if {![info exists Tab($File,$Cat) ]} {set Tab($File,$Cat) {}} if {![info exists Tab($File,Nom,$Nom,LesAccess)]} { set Tab($File,Nom,$Nom,LesAccess) {} lappend Tab($File,LesNoms) $Nom } if {![info exists Tab($File,Access,$Id,LesNoms)]} { set Tab($File,Access,$Id,LesNoms) {} lappend Tab($File,LesAccess) $Id } if {![info exists Tab($File,$Quoi,$Qui,LesNoms)]} { set Tab($File,$Quoi,$Qui,LesNoms) {} set Tab($File,$Quoi,$Qui,LesAccess) {} lappend Tab($File,$Cat) $Qui } if {![info exists Tab($File,Nom,$Nom,$Quoi,$Qui,n)]} { set Tab($File,Nom,$Nom,$Quoi,$Qui,n) 0 set Tab($File,Nom,$Nom,$Quoi,$Qui,LesAccess) {} lappend Tab($File,Nom,$Nom,$Cat) $Qui lappend Tab($File,$Quoi,$Qui,LesNoms) $Nom } if {![info exists TabTmp($Nom,$Id)]} { set TabTmp($Nom,$Id) 1 lappend Tab($File,Nom,$Nom,LesAccess) $Id } incr Tab($File,Nom,$Nom,$Quoi,$Qui,n) lappend Tab($File,Nom,$Nom,$Quoi,$Qui,LesAccess) $Id lappend Tab($File,Access,$Id,$Cat) $Qui lappend Tab($File,$Quoi,$Qui,LesAccess) $Id } close $F return $aTab } proc LoadSqlonage {{Action ""}} { global LoadSqlonage package require sqlite3 set FichierSqlonage "[RepertoireDuGenome]/sqlite/Sqlonage.db" if {$Action=="GetFileName"} { return $FichierSqlonage } if {[info exists LoadSqlonage(DbName)]} { if {$Action=="Reset"} { FaireLire "Please rerun gscope to reset the Sqlonage database" ; return "" } return $LoadSqlonage(DbName) } if {[string equal -nocase $Action "Reset"] && [FileExists $FichierSqlonage]} { Garde $FichierSqlonage file delete $FichierSqlonage } set LoadSqlonage(DbName) [sqlite3 Sqlonage $FichierSqlonage] return $LoadSqlonage(DbName) } proc LoadTaxNCBI {} { #rR on lit le fichier et on stocke tout en utilisant TaxNCBI Qui Quoi =Valeur #rR j'ai rajoute le = obligatoire pour modifier la valeur 2012/04/10 set TaxDir [TaxDir "NCBI"] set Fichier "$TaxDir/delnodes.dmp" set f [open $Fichier "r"] while {[gets $f Ligne]>=0} { set LesChamps [split $Ligne "\t"] ScanLaListe $LesChamps TaxId TaxNCBI $TaxId Deleted "=1" } close $f set Fichier "$TaxDir/merged.dmp" set f [open $Fichier "r"] while {[gets $f Ligne]>=0} { regsub -all "\t" $Ligne "" Ligne set LesChamps [split $Ligne "|"] ScanLaListe $LesChamps TaxId Nouveau TaxNCBI $TaxId Merged "=$Nouveau" } close $f set Fichier "$TaxDir/nodes.dmp" set f [open $Fichier "r"] while {[gets $f Ligne]>=0} { regsub -all "\t" $Ligne "" Ligne set LesChamps [split $Ligne "|"] ScanLaListe $LesChamps TaxId Parent Rank Embl Division TaxNCBI $Parent Children "=$TaxId" TaxNCBI $TaxId Parent "=$Parent" TaxNCBI $TaxId Rank "=$Rank" # TaxNCBI $TaxId Embl "=$Embl" # TaxNCBI $TaxId Division "=$Division" } close $f Espionne "Chargement $TaxDir/names.dmp" set Fichier "$TaxDir/names.dmp" set f [open $Fichier "r"] set nTaxId 0 # set iMaxPourTest 999 set iMaxPourTest -1 while {[gets $f Ligne]>=0} { if {[incr iMaxPourTest -1]%10000==0} { Espionne $Ligne } if {[incr iMaxPourTest -1] == 0} { break } regsub -all "\t" $Ligne "" Ligne set LesChamps [split $Ligne "|"] ScanLaListe $LesChamps TaxId Name UniqueName NameClass if {$TaxId=="1890940"} { Espionne $Ligne } if {[info exists DejaVu($Name)]} { lappend LesDoublons $Name } set DejaVu($Name) 1 TaxNCBI $TaxId TaxId "=$TaxId" TaxNCBI $TaxId ItsNames "=$Name" if {$UniqueName!=""} { TaxNCBI $TaxId UniqueName "=$UniqueName" TaxNCBI $Name ItsTaxIds "=$TaxId" } TaxNCBI $Name TaxId "=$TaxId" TaxNCBI $Name NameClass "=$NameClass" if {[string equal -nocase $NameClass "scientific name"]} { incr nTaxId TaxNCBI $TaxId Name "=$Name" } TaxNCBI "ListOf" "Names" "=$Name" } TaxNCBI "SortUnique" "ListOf" "=Names" ;#rR attention il faut aussi le = close $f set LesDoublons [lsort $LesDoublons] # SauveLesLignes $LesDoublons dans "$TaxDir/DoublonsNames.txt" return $nTaxId } proc LoadTaxUniProt {} { #rR on lit le fichier et on stocke tout en utilisant TaxUniprot Qui Quoi =Valeur #rR j'ai rajoute le = obligatoire pour modicier la valeur 2012/04/10 #lM adapte pour UniProt 2013/11/08 set UrlPourLaMiseAJour "http://www.uniprot.org/taxonomy/?query=&force=yes&format=tab" TaxUniProt 1 TaxId "=1" TaxUniProt 1 Name "=root" TaxUniProt "root" TaxId "=1" TaxUniProt "root" Name "=root" TaxUniProt 1 ItsTaxIds "=1" TaxUniProt 1 ItsNames "=root" TaxUniProt "root" ItsTaxIds "=1" TaxUniProt "root" ItsNames "=root" TaxUniProt 1 Rank "=no rank" TaxUniProt 1 Children "=10239" TaxUniProt 1 Children "=12884" TaxUniProt 1 Children "=12908" TaxUniProt 1 Children "=28384" TaxUniProt 1 Children "=131567" TaxUniProt 10239 Parent "=1" TaxUniProt 12884 Parent "=1" TaxUniProt 12908 Parent "=1" TaxUniProt 28384 Parent "=1" TaxUniProt 131567 Parent "=1" set TaxDir [TaxDir "UniProt"] set Fichier "$TaxDir/taxonomy-all.tab" set f [open $Fichier "r"] set PrendPremiereLigne 0 while {[gets $f Ligne]>=0} { if {! $PrendPremiereLigne} { #lM premiere ligne contient les noms des champs # Taxon | Mnemonic | Scientific name | Common name | Synonym | Other Names | Reviewed | Rank | Lineage | Parent set PrendPremiereLigne 1 continue } set LesChamps [split $Ligne "\t"] lassign $LesChamps TaxId Mnemonic Name CommonName Synonym OtherNames Reviewed Rank Lineage Parent if {[string trim $Rank] eq ""} { set Rank "no rank" } TaxUniProt $TaxId TaxId "=$TaxId" TaxUniProt $TaxId Name "=$Name" TaxUniProt $Name TaxId "=$TaxId" TaxUniProt $TaxId ItsNames "=$Name" TaxUniProt $Name ItsTaxIds "=$TaxId" TaxUniProt $TaxId Rank "=$Rank" TaxUniProt $TaxId Lineage "=$Lineage" TaxUniProt $TaxId Parent "=$Parent" TaxUniProt $Parent Children "=$TaxId" TaxUniProt "ListOf" "Names" "=$Name" } TaxUniProt "SortUnique" "ListOf" "=Names" ;#rR attention il faut aussi le = close $f return } proc LoadTclPackages {} { package require tclcluspack package require tclordalie package require tclfastme package require http package require sqlite3 package require La catch { namespace import La::*} package require struct package require tdom if {$::tcl_version ne "8.6"} { package require TclOO } return } proc LoadTkAndPackages {} { package require Tk $::tcl_patchLevel #catch {console show} Espionne "Tk : $::tk_patchLevel" Espionne "tcl3d : [package require tcl3d]" if {$::Defauts(Devlpt)} { Espionne "biotext-dev: [package require biotext-dev]" } else { Espionne "biotext : [package require biotext]" } Espionne "combobox : [package require combobox 2.3]" Espionne "LRIPhoto : [package require LRIPhoto]" Espionne "" namespace import ::LRI::* if {[tk windowingsystem] eq "aqua"} { catch {set ::origUseCustomMDEF $::tk::mac::useCustomMDEF; set ::tk::mac::useCustomMDEF 1} } return } proc LoadTxl {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""} {WholeLine ""}} { set WholeLine [string equal -nocase "WholeLine" $WholeLine] if {$CoLi==""} { set CoLi "LiCo" } Wup "Normally the values are stored in Txl(Line,Column)" Wup " with CoLi==CoLi we have Txl(Column,Line)" if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl } if {$Sep==""} { set Sep "\t" } set Queue [file tail $Fichier] regsub -nocase {\.[^\.]+$} $Queue "" Queue global LoadTxlForGenoret if {[info exists LoadTxlForGenoret] && $LoadTxlForGenoret} {set Queue [NormaliseTxlFieldName $Queue] } if { ! [file exists $Fichier]} { Warne "$Fichier does not exist" set Txl(ListHeaderPlease,$Queue) {} set Txl(ListAllPlease,$Queue) {} return $aTxl } set LesLignes [LesLignesDuFichier $Fichier] set Entete [lindex $LesLignes 0] set LesLignes [lrange $LesLignes 1 end] set LesTetes {} foreach Tete [split $Entete $Sep] { regsub -all {\#} $Tete "" Tete regsub -all {\'} $Tete "" Tete regsub -all {\?} $Tete "" Tete regsub -all {\(} $Tete "" Tete regsub -all {\)} $Tete "" Tete regsub -all {\"} $Tete "" Tete while {[regexp " " $Tete]} { regsub -all { {2,}} $Tete " " Tete } set Tete [string trim $Tete] regsub -all { } $Tete "_" Tete # regsub -all -nocase {[\0260\$]} $Tete "_" Tete regsub -all -nocase {[\176\$]} $Tete "_" Tete set Original $Tete if {$Tete==""} { set Tete "_" } while {[info exists DejaVu($Tete)]} { append Tete "_2" } set DejaVu($Tete) $Original lappend LesTetes $Tete } set Txl(ListHeaderPlease,$Queue) $LesTetes set Txl(ListOf,Header) $LesTetes set I 1 foreach Ligne $LesLignes { if { ! [regexp -nocase {\S} $Ligne]} { continue } incr I set LesMots [split $Ligne $Sep] if {$MainIndex<0} { set Nom $I } else { set Nom [lindex $LesMots $MainIndex] regsub -all {\"} $Nom "" Nom } lappend Txl(ListAllPlease,$Queue) $Nom lappend Txl(ListOf,Index) $Nom foreach Mot $LesMots Tete $LesTetes { regsub -all {\"} $Mot "" Mot if {$CoLi=="CoLi"} { set Txl($Tete,$Nom) $Mot } else { set Txl($Nom,$Tete) $Mot } } if {$WholeLine} { if {$CoLi=="CoLi"} { set Txl(WholeLine,$Nom) $Ligne } else { set Txl($Nom,WholeLine) $Ligne } } } return $aTxl } proc LoadTxlAffy {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""}} { Wup "Attention BonSep n'est pas utilise, ca ne marche que pour \",\"" set BonSep $Sep if {[regexp {[\,\-\;]} $BonSep]} { set BonSep "\\$Sep" } if {$CoLi==""} { set CoLi "LiCo" } Wup "Normally the values are stored in Txl(Line,Column)" Wup " with CoLi==CoLi we have Txl(Column,Line)" if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl } if {$Sep==""} { set Sep "\t" } set Queue [file tail $Fichier] regsub -nocase {\.[^\.]+$} $Queue "" Queue if { ! [file exists $Fichier]} { set Txl(ListHeaderPlease,$Queue) {} set Txl(ListAllPlease,$Queue) {} return $aTxl } #LP #set LesLignes [LesLignesDuFichier $Fichier] foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^#" $Ligne]} {continue} lappend LesLignes $Ligne } #LP set Entete [lindex $LesLignes 0] set LesLignes [lrange $LesLignes 1 end] set LesTetes {} foreach Tete [split $Entete $Sep] { regsub -all {\(} $Tete "" Tete regsub -all {\)} $Tete "" Tete regsub -all {\"} $Tete "" Tete regsub -all { } $Tete "_" Tete lappend LesTetes $Tete } set Txl(ListHeaderPlease,$Queue) $LesTetes set I 1 foreach Ligne $LesLignes { incr I regsub -all "@" $Ligne "A=r=O=b=A" set BelleLigne [string trim $Ligne {\"}] regsub -all {\"\,\"} $BelleLigne "@" BelleLigne set LesMots [split $BelleLigne "@"] if {$MainIndex<0} { set Nom $I } else { set Nom [lindex $LesMots $MainIndex] regsub -all {\"} $Nom "" Nom } lappend Txl(ListAllPlease,$Queue) $Nom if {[info exists DejaVu]} {unset DejaVu} foreach Mot $LesMots Tete $LesTetes { #LP if {$Tete=="RefSeq_Protein_ID"} { if {[regexp "." $Mot]} { set Mot [lindex [split $Mot "."] 0] } } #LP set MemoValeur($Tete) $Mot if {$Tete==""} { continue } if { ! [BonneTete $Tete]} { continue } regsub -all {"A=r=O=b=A"} $Mot "@" Mot regsub -all {\"} $Mot "" Mot set LesPetitsMots [LesBoutsDeLaLigneAvecTexteSeparateur $Mot "///" "trim"] if {$CoLi=="CoLi"} { if {[info exists Txl($Tete,$Nom)]} { if {$Txl($Tete,$Nom)!=$Mot} { append Txl($Tete,$Nom) " -or- $Mot" } } else { set Txl($Tete,$Nom) $Mot } if {[BonneTete "$Tete-IsChef"]} { foreach PetitMot $LesPetitsMots { if {[set iSS [string first {//} $PetitMot]]>0} { set PetitMot [string range $PetitMot 0 [incr iSS -1]] set PetitMot [string trim $PetitMot] } lappend Txl([BonneTete "GrandChef"],$PetitMot) $Nom } } } else { if {[info exists Txl($Nom,$Tete)]} { if {$Txl($Nom,$Tete)!=$Mot} { append Txl($Nom,$Tete) " -or- $Mot" } } else { set Txl($Nom,$Tete) $Mot } if {[BonneTete "$Tete-IsChef"]} { foreach PetitMot $LesPetitsMots { if {[set iSS [string first {//} $PetitMot]]>=0} { set PetitMot [string range $PetitMot 0 [incr iSS -1]] set PetitMot [string trim $PetitMot] } lappend Txl($PetitMot,[BonneTete "GrandChef"]) $Nom } } } } foreach Referent [BonneTete ListOfReferents] { foreach Chef [BonneTete ListChefFor$Referent] { if {$CoLi=="CoLi"} { lappend Txl($Referent,$MemoValeur($Chef)) $MemoValeur($Referent) } else { lappend Txl($MemoValeur($Chef),$Referent) $MemoValeur($Referent) } } } } return $aTxl } proc LoadTxlForMonika {} { set RepDeMonika "/genomics/link/Monika/DeMonika" set Fichier "$RepDeMonika/FINAL_LIST.txt" set Queue [file tail $Fichier] regsub {\.[a-z]+$} $Queue "" Queue LoadTxl $Fichier T "" "" "CoLi" set LesTetes $T(ListHeaderPlease,$Queue) foreach I $T(ListAllPlease,$Queue) { set A $T(Product_Id,$I) Espionne "$I $A" set LignesEMBL [LaSequenceDesBanques $A] EspionneL $LignesEMBL SauveLesLignes $LignesEMBL dans "$RepDeMonika/$I.embl" } exit } proc LoadTxlWithRowsOfCells {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""} {WholeLine ""}} { set WholeLine [string equal -nocase "WholeLine" $WholeLine] if {$CoLi==""} { set CoLi "LiCo" } Wup "Normally the values are stored in Txl(Line,Column)" Wup " with CoLi==CoLi we have Txl(Column,Line)" if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl } if {$Sep==""} { set Sep "\t" } set Queue [file tail $Fichier] regsub -nocase {\.[^\.]+$} $Queue "" Queue global LoadTxlForGenoret if {[info exists LoadTxlForGenoret] && $LoadTxlForGenoret} {set Queue [NormaliseTxlFieldName $Queue] } set Txl(Queue) $Queue if { ! [file exists $Fichier]} { set Txl(ListHeaderPlease,$Queue) {} set Txl(ListAllPlease,$Queue) {} return $aTxl } set Texte [ContenuDuFichier $Fichier] set NewSep "" set NewQQ "" set NewRet "" set LesRowsOfCells [RowsOfCells $Texte $Sep $NewSep $NewQQ $NewRet] set LesHLus [lindex $LesRowsOfCells 0] set LesRowsOfCells [lrange $LesRowsOfCells 1 end] set LesTetes {} foreach Tete $LesHLus { regsub -all {\'} $Tete "" Tete regsub -all {\?} $Tete "" Tete regsub -all {\(} $Tete "" Tete regsub -all {\)} $Tete "" Tete regsub -all {\"} $Tete "" Tete regsub -all {\,} $Tete "_" Tete while {[regexp " " $Tete]} { regsub -all { {2,}} $Tete " " Tete } set Tete [string trim $Tete] regsub -all { } $Tete "_" Tete #rR ca devrait enlever le degre regsub -all -nocase {\0260} $Tete "_" Tete set Original $Tete if {$Tete==""} { set Tete "_" } while {[info exists DejaVu($Tete)]} { append Tete "_2" } set DejaVu($Tete) $Original lappend LesTetes $Tete } set Txl(ListHeaderPlease,$Queue) $LesTetes set I 1 foreach LesMots $LesRowsOfCells { incr I if {$MainIndex<0} { set Nom $I } else { set Nom [lindex $LesMots $MainIndex] regsub -all {\"} $Nom "" Nom } set Nom [string trim $Nom] if {$Nom==""} { continue } if {[info exists DejaVu($Nom,$Queue)]} { FaireLire "I already saw $Nom , I'll skip it now" ; continue } set DejaVu($Nom,$Queue) 1 lappend Txl(ListAllPlease,$Queue) $Nom foreach Mot $LesMots Tete $LesTetes { regsub -all {\"} $Mot "" Mot if {$CoLi=="CoLi"} { set Txl($Tete,$Nom) $Mot } else { set Txl($Nom,$Tete) $Mot } } if {$WholeLine} { if {$CoLi=="CoLi"} { set Txl(WholeLine,$Nom) $LesMots } else { set Txl($Nom,WholeLine) $LesMots } } } set Txl(ListHeaderPlease,) $Txl(ListHeaderPlease,$Queue) set Txl(ListAllPlease,) $Txl(ListAllPlease,$Queue) return $aTxl } proc LoadUCSC {aTab File} { ### Frederic Chalmel, Biozentrum Basel, 2005 ### ### load du fichier refSeqAli.txt ### upvar $aTab Tab if {![file exists $File]} {Espionne "File UCSC: $File does not exists" ; return} Espionne "$File is loading ..." set Tab($File,Loaded) 1 set Tab($File,ListOfID) {} set F [open $File] while {[gets $F Line]>=0} { set Line [string trim $Line] if {$Line == ""} {continue} set Line [split $Line "\t" ] ### Access du mRNA RefSeq set ID [lindex $Line 10] regsub {^[^\:]+\:} $ID "" ID if {![info exists Tab($File,ID,$ID,ListOfPosition)]} { set Tab($File,ID,$ID,ListOfPosition) {} lappend Tab($File,ListOfID) $ID } ### Brin, debut et fin du mRNA localise sur le genome set Strand [lindex $Line 9 ] set SeqFrom [lindex $Line 12] set SeqTo [lindex $Line 13] ### Chromosome, localisation du mRNA sur le chr set Chr [lindex $Line 14] regsub {^chr} $Chr "" Chr set ChrFrom [lindex $Line 16] set ChrTo [lindex $Line 17] ### Localisation du mRNA sur le chr lappend Tab($File,ID,$ID,ListOfPosition) [list $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand] ### Carte exonique (liste des exons, de leur start sur le mRNA et sur le chr) set lExSize [split [lindex $Line 19] ","] set lSeqStart [split [lindex $Line 20] ","] set lChrStart [split [lindex $Line 21] ","] ### Liste de localisation des exons sut le mRNA et sur le chr set Tab($File,ID,$ID,Chrom,$Chr,From,$ChrFrom,To,$ChrTo,Strand,$Strand,ListOfPosition) {} foreach Size $lExSize Start1 $lSeqStart Start2 $lChrStart { if {$Size == "" || $Start1 == "" || $Start2 == ""} {continue} set End2 [expr $Start2 + $Size] set End1 [expr $Start1 + $Size] lappend Tab($File,ID,$ID,Chrom,$Chr,From,$ChrFrom,To,$ChrTo,Strand,$Strand,ListOfPosition) [list $ID $Start1 $End1 $Chr $Start2 $End2 $Strand] } } close $F Espionne "$File loaded" return $aTab } proc LoadUnArbre {} { global Abr set f [DemandeEtOuvreFichier ph 1] if {$f eq ""} {return} set LeTree [ContenuDuFichier $f] set LeTree [NettoieArbre $LeTree] if {$LeTree == 0 || [catch {set AId [InitialiseUnArbre $LeTree]} Msg]} { puts "Msg\n$Msg\n$::errorInfo" FaireLire "Error while reading the tree file !\nVerify the file is in Newick format" return } # some spec set Abr($AId,Mode) normal set Abr($AId,TypeGapTree) "Unknown" set Abr($AId,NbrSites) "Unknown" set Abr($AId,TreeNBoot) "Unknown" set Abr($AId,BootDone) 0 AfficheUnArbre $AId return } proc LoadingAlignement {} { global LongueurTotale ListeTypesDeFeatures global Defauts TabSF db OrdTmpDir global LNOrdali Sequences AlnName AlnScore AlnNote #::profiler::reset if {[TypeAli] eq "pasdali"} {return 0} set fic [set Defauts(Fichier[TypeAli])] if {! [VerifieFormatAlignement $fic [TypeAli]]} { return 0 } set AlnName [file rootname [file tail $fic]] regsub -all " " $AlnName "_" AlnName InitInfoArrays if {[TypeAli] ne "ORD"} { #set fdb [file join $OrdTmpDir "[pid].odb"] #set db [FabriqueDeTables [set Defauts(TablesDB)] root $fdb] set db [FabriqueDeTables [set Defauts(TablesDB1.1)] root] } switch [TypeAli] { "XML" { set AlnScore 0.0 set AlnNote "" DecortiqueUnXml2 $fic } "TFA" { DecortiqueUnTFA $fic LNOrdali Sequences } "ALN" { DecortiqueUnALN $fic LNOrdali Sequences } "MSF" { DecortiqueUnMSF $fic Ln Sq set LNOrdali {} foreach v $Ln { set n [BonAccess $v] set s [BonneSequencePourAlignement [set Sq($v)]] lappend LNOrdali $n set Sequences($n) $s } } "RSF" { DecortiqueUnRSF $fic LNOrdali Sequences TabSF set ListeTypesDeFeatures [set TabSF(LesTypesDeFeatures)] } "ORD" { #::profiler::reset LectureOrdaliDB $fic #AfficheProfileResults } } set LongueurTotale [LongueurDeLAlignement] if {[TypeAli] ne "ORD"} { if {! [InitSequences]} { return 0 } InitPremierGroupe if {[TypeAli] eq "XML"} { DonneTabFeature TabSF } elseif {[TypeAli] eq "RSF"} { DonneTabFeatureDuRsf TabSF } } AssignSeqToGroup InitInfoSeqs InitConsensus if {[TypeAli] ne "ORD"} { RemplitOrdaliDB } #AfficheProfileResults return $fic } proc LoadingFontImages {} { global OrdEtcDir set size [font configure FntPrt -size] set Lf [glob [file join $OrdEtcDir CN $size *.png]] foreach f $Lf { set img [file rootname [file tail $f]] if {$img eq "CN_${size}_Space"} { set img "CN_${size}_" } image create photo $img -file $f } return } proc Loc {} { set Fichier "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach PAB [ListeDesJR $Fichier] { #Espionne $PAB set FichierBlastGenome "[RepertoireDuGenome]/blastnhuman/$PAB" set L [BoxLocalisation $PAB $FichierBlastGenome] #EspionneL $L foreach Elt $L { lappend LBoxLoc $Elt } } return $LBoxLoc } proc LocAffy {{Qui ""} {Quoi ""}} { global LocAffy if {$Qui==""} { set Qui "ListOf" ; set Quoi "Arguments" } if {[info exists LocAffy($Qui,$Quoi)]} { return $LocAffy($Qui,$Quoi) } if {[info exists LocAffy("EstCharge")]} { return "" } set LocAffy("EstCharge") 1 set Org "Mouse" foreach P [AffyAnno ListOf Index] { set Ali [AffyAnno $P "Alignments"] regsub -all { */// *} $Ali "@" Ali foreach Lo [split $Ali "@"] { regsub -all { */+ *} $Lo "@" Lo set LesChamps [split $Lo "@"] set CSES [lindex $LesChamps 0] regsub -all {[\:\-\(\)]} $CSES " " CSES scan $CSES "%s %s %s %s" Chr Start End Strand lappend LocAffy(ListOf$Org$Chr,StartEndName) "$Start $End $P" set Cytoband [lindex $LesChamps 2] lappend LocAffy(ListOf$Org$Chr,CytobandName) "$Cytoband $P" } } set LocAffy(ListOf,Arguments) [array names LocAffy] foreach V $LocAffy(ListOf,Arguments) { if {[regexp "StartEndName$" $V]} { set LocAffy($V) [lsort -integer -index 0 $LocAffy($V)] } if {[regexp "CytobandName$" $V]} { set LocAffy($V) [lsort $LocAffy($V)] } } return [LocAffy $Qui $Quoi] } proc LocAfter {Position Org Chr {Strand ""} {FromWhere ""}} { Wup "Attention UCSC compte a partir de 0" if {$FromWhere==""} { set FromWhere "refGene" } set org [string tolower $Org] set fromwhere [string tolower $FromWhere] set Where "chrom='$Chr' and $Position<=txStart" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select TXSTART from ucsc$org.$fromwhere where $Where order by TXSTART fetch first 1 rows only" # set Premier [Bird $Query "flat"] set Premier [BirdSendQueryUrlAndGetFromUrl $Query "" "format=flat"] if {$Premier==""} { return "" } set Where "chrom='$Chr' and $Premier=txStart" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select NAME, TXSTART, TXEND, STRAND from ucsc$org.$fromwhere where $Where order by TXEND" # set Retour [Bird $Query "flat"] set Retour [BirdSendQueryUrlAndGetFromUrl $Query "" "format=plat"] set Retour [string trim $Retour " \n"] return $Retour } proc LocAfterBoost {Position Org Chr {Strand ""} {FromWhere ""}} { set Retour "" if {$FromWhere==""} { set FromWhere "refGene" } # set Chr "chr$Chr" set Where "chrom='$Chr' and txStart>=$Position" set ListeDesExonsStarts {} set ListeDesExonsEnds {} foreach {access txStart txEnd strand} [SqlExec "select name, txStart, txEnd, strand FROM ucsc$Org.$FromWhere WHERE $Where order by txStart ASC LIMIT 1"] { set Retour "$access $txStart $txEnd $strand" set Retour [string trim $Retour "\n"] set Retour [string trim $Retour] } return $Retour } proc LocBefore {Position Org Chr {Strand ""} {FromWhere ""}} { Wup "Attention UCSC compte a partir de 0" if {$FromWhere==""} { set FromWhere "refGene" } set org [string tolower $Org] set fromwhere [string tolower $FromWhere] set Where "chrom='$Chr' and txEnd<=$Position" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select TXEND from ucsc$org.$fromwhere where $Where order by TXEND desc fetch first 1 rows only" # set Premier [Bird $Query "flat"] set Premier [BirdSendQueryUrlAndGetFromUrl $Query "" "format=flat"] if {$Premier==""} { return "" } set Where "chrom='$Chr' and $Premier=txEnd" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select NAME, TXSTART, TXEND, STRAND from ucsc$org.$fromwhere where $Where order by TXSTART" # set Retour [Bird $Query "flat"] set Retour [BirdSendQueryUrlAndGetFromUrl $Query "" "format=plat"] set Retour [string trim $Retour " \n"] return $Retour } proc LocBeforeBoost {Position Org Chr {Strand ""} {FromWhere ""}} { set Retour "" if {$FromWhere==""} { set FromWhere "refGene" } # set Chr "chr$Chr" set Where "chrom='$Chr' and txEnd<=$Position" set ListeDesExonsStarts {} set ListeDesExonsEnds {} foreach {access txStart txEnd strand} [SqlExec "select name, txStart, txEnd, strand FROM ucsc$Org.$FromWhere WHERE $Where order by txEnd DESC LIMIT 1" ] { set Retour "$access $txStart $txEnd $strand" set Retour [string trim $Retour "\n"] set Retour [string trim $Retour] } return $Retour } proc LocCategorie {FichierLoc} { foreach Nom [ListeDesPABs] { set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs!="" && $LesLocs!=" "} {lappend LesLocalises $Nom} else {lappend LesNoLoc $Nom} } Espionne "loc: [llength $LesLocalises]";Espionne "no loc: [llength $LesNoLoc]" foreach DD $LesLocalises { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} {lappend AvecProt $DD;continue} lappend Liste $DD if {[file exists "[RepertoireDuGenome]/prottfa/$DD"]} {Espionne $DD} } Espionne "loc avec prot: [llength $AvecProt]" Espionne "loc sans prot: [llength $Liste]" foreach DD $LesNoLoc { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} {lappend nolocAvecProt $DD;continue} lappend nolocnoprot $DD } Espionne "noloc avec prot: [llength $nolocAvecProt]" Espionne "noloc sans prot: [llength $nolocnoprot]" Espionne $nolocAvecProt } proc LocIn {Position Org Chr {Strand ""} {FromWhere ""}} { Wup "Attention UCSC compte a partir de 0" if {$FromWhere==""} { set FromWhere "refGene" } set org [string tolower $Org] set fromwhere [string tolower $FromWhere] set Where "chrom='$Chr' and txStart<=$Position and $Position<=txEnd" if {$Strand!=""} { if {$Strand=="F"} { set Strand "+" } if {$Strand=="R"} { set Strand "-" } append Where " and strand='$Strand'" } set Query "select NAME, TXSTART, TXEND, STRAND from ucsc$org.$fromwhere where $Where order by TXSTART" # set Retour [Bird $Query "" "flat"] set Retour [BirdSendQueryUrlAndGetFromUrl $Query "" "format=plat"] set Retour [string trim $Retour " \n"] return $Retour } proc LocInBQL {Position ResultatBQL Separator} { if { $ResultatBQL == "" } { set Retour "Vide" } else { set ExonOuIntron "?" set CdsOuPas "?" set Retour "" set ListeDesExonsStarts {} set ListeDesExonsEnds {} set Liste [split $ResultatBQL "$Separator"] ScanLaListe $Liste Name chrom TxStart TxEnd Strand ExonStarts ExonEnds ExonCount CdsStart CdsEnd set ListeDesExonsStarts [split $ExonStarts ","] set ListeDesExonsEnds [split $ExonEnds ","] set LongueurDesStarts [llength $ListeDesExonsStarts] set LongueurDesEnds [llength $ListeDesExonsEnds] if { $LongueurDesStarts == $LongueurDesEnds && $LongueurDesStarts == [expr $ExonCount +1] } { if { $Position >= $CdsStart && $Position <= $CdsEnd } { set UtrOuCDS "CDS" } else { if { $Strand == "+" } { if { $CdsStart > $Position } { set UtrOuCDS "5-UTR" } if { $CdsEnd < $Position } { set UtrOuCDS "3-UTR" } } if { $Strand == "-" } { if { $CdsEnd < $Position } { set UtrOuCDS "5-UTR" } if { $CdsStart > $Position } { set UtrOuCDS "3-UTR" } } } set ExonOuIntron "Erreur" set OccupationExonOuIntron -1 set RechercheDansExon "KO" for {set I 0} {$I < $ExonCount } {incr I } { set DebExon [lindex $ListeDesExonsStarts $I] set FinExon [lindex $ListeDesExonsEnds $I] if { $DebExon <= $Position && $FinExon >= $Position } { set DebutExonOuIntron $DebExon set FinExonOuIntron $FinExon set RechercheDansExon "OK" if { $Strand == "+" } { set DistanceAuDebutDeExonOuIntron [expr $Position - $DebutExonOuIntron] set DistanceAlaFinDeExonOuIntron [expr $FinExonOuIntron - $Position] set ExonOuIntronNumber [expr $I + 1] set ExonOuIntron "Exon$Separator$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($Position-$DebExon) / ($FinExon-$DebExon)] } else { set DistanceAuDebutDeExonOuIntron [expr $FinExonOuIntron - $Position] set DistanceAlaFinDeExonOuIntron [expr $Position - $DebutExonOuIntron] set ExonOuIntronNumber [expr $ExonCount - $I] set ExonOuIntron "Exon$Separator$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($FinExon-$Position) / ($FinExon-$DebExon)] } if { $ExonOuIntronNumber == $ExonCount } { set ExonOuIntron "ExonLast$Separator$ExonOuIntronNumber" } } } #Espionne "Intron" if { $RechercheDansExon == "KO" } { if { $ExonCount > 1 } { for {set J 0} {$J < [expr $ExonCount-1] } {incr J } { set FinExonCourant [lindex $ListeDesExonsEnds $J] set DebExonSuivant [lindex $ListeDesExonsStarts [expr $J+1]] #Espionne "$Position $FinExonCourant $DebExonSuivant" if { $Position >= $FinExonCourant && $Position < $DebExonSuivant } { set DebutExonOuIntron $FinExonCourant set FinExonOuIntron $DebExonSuivant set DebutIntron $FinExonCourant set FinIntron $DebExonSuivant if { $Strand == "+" } { set DistanceAuDebutDeExonOuIntron [expr $Position - $DebutIntron] set DistanceAlaFinDeExonOuIntron [expr $FinIntron - $Position] set ExonOuIntronNumber [expr $J + 1] set ExonOuIntron "Intron$Separator$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($Position - $FinExonCourant)/($DebExonSuivant - $FinExonCourant) ] } else { set DistanceAuDebutDeExonOuIntron [expr $FinIntron - $Position] set DistanceAlaFinDeExonOuIntron [expr $Position - $DebutIntron] set ExonOuIntronNumber [expr $ExonCount - $J - 1] set ExonOuIntron "Intron$Separator$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($DebExonSuivant-$Position)/($DebExonSuivant-$FinExonCourant)] } if { $ExonOuIntronNumber == [expr $ExonCount -1] } { set ExonOuIntron "IntronLast$Separator$ExonOuIntronNumber" } } } } else { set ExonOuIntron "Probleme Intron" } } #On cherche si le SBS est plus proche du début ou de la fin de l'exon/intron oé il se trouve if { ![info exists DistanceAuDebutDeExonOuIntron] } { error "$Position <> $ResultatBQL" } if {$DistanceAuDebutDeExonOuIntron < $DistanceAlaFinDeExonOuIntron} { set DistanceAlaBorneDeExonOuIntron $DistanceAuDebutDeExonOuIntron set DebutOuFinExonOuIntron "Debut" } else { set DistanceAlaBorneDeExonOuIntron $DistanceAlaFinDeExonOuIntron set DebutOuFinExonOuIntron "Fin" } set Retour "$Name$Separator$TxStart$Separator$TxEnd$Separator$Strand$Separator$ExonOuIntron$Separator$UtrOuCDS$Separator$DebutExonOuIntron$Separator$FinExonOuIntron$Separator$DebutOuFinExonOuIntron$Separator$DistanceAlaBorneDeExonOuIntron" } else { #Espionne "Erreur: Starts=$LongueurDesStarts Ends=$LongueurDesEnds Count=$ExonCount" set Retour "$Name$Separator$TxStart$Separator$TxEnd$Separator$Strand$SeparatorErreur$SeparatorErreur$SeparatorErreur$SeparatorErreur$SeparatorErreur$SeparatorErreur" } set Retour [string trim $Retour "\n"] set Retour [string trim $Retour] } return $Retour } proc LocInBetween {Position Org Chr {FromWhere ""} {FinPosition ""}} { #Quand on utilise LocUcsc Org=Mouse #Quand on utilise LocUcscRefSeq Org=mm9 #NB: Pour Between, dans le cas ou pls NM chevauchants, n'en choisit qu'un dans le resultat (au hasard). Pour plus tard, considere tous les NM ou le plus long ? Wup "Attention UCSC compte a partir de 0" global LocInBetween set NDeChaqueCote 20 if {$FinPosition==""} { set FinPosition $Position } if {$FromWhere==""} { set FromWhere "Ucsc" } set Foc "$FromWhere$Org$Chr" if { ! [info exists LocInBetween($Foc)]} { if {$FromWhere=="Ucsc"} { #set LocInBetween($Foc) [LocUcsc ListOf$Org$Chr "StartEndName"] set LocInBetween($Foc) [LocUcscRefSeq $Org ListOf$Chr "StartEndName"] } if {$FromWhere=="Affy"} { set LocInBetween($Foc) [LocAffy ListOf$Org$Chr "StartEndName"] } } set D 0 set F [expr [llength $LocInBetween($Foc)] - 1] if {$F<$D} { return "Error NoStartEndNameAvailable" } set SENDeb [lindex $LocInBetween($Foc) 0] set SENFin [lindex $LocInBetween($Foc) end] if {$SENDeb==""||$SENFin==""} { return "Error NoGenome" } if {$Position<[lindex $SENDeb 0] || $Position>[lindex $SENFin 1]} { return "Outside $SENDeb $SENFin" } set OldAvant $SENDeb set OldApres $SENFin while 1 { #Espionne "$OldAvant $OldApres" #Espionne "$D $F" if {$F<$D} { #Espionne "$F $D" set StatusPremier "Between $OldAvant $OldApres" break } set M [expr ($D+$F)/2] set SEN [lindex $LocInBetween($Foc) $M] #Espionne "$M $SEN" set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$Start<=$Position && $Position<=$End} { set LesIns [list "In $SEN"] #Espionne "$M $SEN" for {set I [expr -$NDeChaqueCote]} { $I<=$NDeChaqueCote} { incr I } { set MM [expr $M + $I] set SEN [lindex $LocInBetween($Foc) $MM] if {$SEN==""} { continue } set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$FinPosition<$Start || $End<$Position} { continue } #Espionne "$MM $SEN" lappend LesIns "In $SEN" } set LesIns [lsort -unique $LesIns] return $LesIns } if {$D==$F} { if {$Position<$Start} {set OldApres $SEN} if {$End<$Position} {set OldAvant $SEN} set StatusPremier "Between $OldAvant $OldApres" break } if {$Position<$Start} {set OldApres $SEN; set F [expr $M -1]} if {$End<$Position} {set OldAvant $SEN; set D [expr $M +1]} } #quand trouve Between dans la boucle du dessus, cherche si il y a pas tout de meme des In set LesIns {} for {set I [expr -$NDeChaqueCote]} { $I<=$NDeChaqueCote} { incr I } { set MM [expr $M + $I] set SEN [lindex $LocInBetween($Foc) $MM] if {$SEN==""} { continue } set Start [lindex $SEN 0] set End [lindex $SEN 1] if {$FinPosition<$Start || $End<$Position} { continue } #Espionne "$MM $SEN" lappend LesIns "In $SEN" } set LesIns [lsort -unique $LesIns] if {$LesIns!={}} { return $LesIns } return $StatusPremier } proc LocInBoost {Position Org Chr {FromWhere refGene}} { set ExonOuIntron "Intron" set CdsOuPas "NonRenseigneCDS" set Retour "" Wup "Attention UCSC compte a partir de 0" set Where "chrom='$Chr' and txStart<=$Position and $Position<=txEnd" set org $Org if {$FromWhere == "refGene"} { set typegene "protein" set nameOuAccess "name" } else { set typegene "protein" set nameOuAccess "access" set Where "$Where AND typegene='protein' } set ListeDesExonsStarts {} set ListeDesExonsEnds {} foreach { Name TxStart TxEnd Strand ExonStarts ExonEnds ExonCount CdsStart CdsEnd } [SqlExec "select $nameOuAccess, txStart, txEnd, strand, exonStarts, exonEnds, exonCount, cdsStart, cdsEnd from ucsc$org.$FromWhere where $Where order by TxStart LIMIT 1" -flatlist] { if {$typegene == "protein"} { set UtrOuCDS "PasUtr" if { $Position >= $CdsStart && $Position <= $CdsEnd } { set CdsOuPas "DansCds" } else { set CdsOuPas "HorsCds" if { $Strand == "+" } { if { $CdsStart > $Position } { set UtrOuCDS "5-UTR" } if { $CdsEnd < $Position } { set UtrOuCDS "3-UTR" } } if { $Strand == "-" } { if { $CdsEnd < $Position } { set UtrOuCDS "5-UTR" } if { $CdsStart > $Position } { set UtrOuCDS "3-UTR" } } } set ListeDesExonsStarts [split $ExonStarts ","] set ListeDesExonsEnds [split $ExonEnds ","] set ExonOuIntron "Erreur" set OccupationExonOuIntron -1 set RechercheDansExon "KO" for {set I 0} {$I < $ExonCount } {incr I } { set DebExon [lindex $ListeDesExonsStarts $I] set FinExon [lindex $ListeDesExonsEnds $I] if { $DebExon <= $Position && $FinExon >= $Position } { set DebutExonOuIntron $DebExon set FinExonOuIntron $FinExon set RechercheDansExon "OK" if { $Strand == "+" } { set DistanceAuDebutDeExonOuIntron [expr $Position - $DebutExonOuIntron] set DistanceAlaFinDeExonOuIntron [expr $FinExonOuIntron - $Position] set ExonOuIntronNumber [expr $I + 1] set ExonOuIntron "Exon$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($Position-$DebExon) / ($FinExon-$DebExon)] } else { set DistanceAuDebutDeExonOuIntron [expr $FinExonOuIntron - $Position] set DistanceAlaFinDeExonOuIntron [expr $Position - $DebutExonOuIntron] set ExonOuIntronNumber [expr $ExonCount - $I] set ExonOuIntron "Exon$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($FinExon-$Position) / ($FinExon-$DebExon)] } if { $ExonOuIntronNumber == $ExonCount } { set ExonOuIntron "ExonLast$ExonOuIntronNumber" } } } if { $RechercheDansExon == "KO" } { if { $ExonCount > 1 } { for {set J 0} {$J < [expr $ExonCount-1] } {incr J } { set FinExonCourant [lindex $ListeDesExonsEnds $J] set DebExonSuivant [lindex $ListeDesExonsStarts [expr $J+1]] if { $Position >= $FinExonCourant && $Position < $DebExonSuivant } { set DebutExonOuIntron $FinExonCourant set FinExonOuIntron $DebExonSuivant set DebutIntron $FinExonCourant set FinIntron $DebExonSuivant if { $Strand == "+" } { set DistanceAuDebutDeExonOuIntron [expr $Position - $DebutIntron] set DistanceAlaFinDeExonOuIntron [expr $FinIntron - $Position] set ExonOuIntronNumber [expr $J + 1] set ExonOuIntron "Intron$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($Position - $FinExonCourant)/($DebExonSuivant - $FinExonCourant) ] } else { set DistanceAuDebutDeExonOuIntron [expr $FinIntron - $Position] set DistanceAlaFinDeExonOuIntron [expr $Position - $DebutIntron] set ExonOuIntronNumber [expr $ExonCount - $J - 1] set ExonOuIntron "Intron$ExonOuIntronNumber" set OccupationExonOuIntron [expr 100*($DebExonSuivant-$Position)/($DebExonSuivant-$FinExonCourant)] } if { $ExonOuIntronNumber == [expr $ExonCount -1] } { set ExonOuIntron "IntronLast" } } } } else { set ExonOuIntron "Probleme Intron" } } #On cherche si le SBS est plus proche du début ou de la fin de l'exon/intron oé il se trouve if {$DistanceAuDebutDeExonOuIntron < $DistanceAlaFinDeExonOuIntron} { set DistanceAlaBorneDeExonOuIntron $DistanceAuDebutDeExonOuIntron set DebutOuFinExonOuIntron "Debut" } else { set DistanceAlaBorneDeExonOuIntron $DistanceAlaFinDeExonOuIntron set DebutOuFinExonOuIntron "Fin" } set Retour "$Name $TxStart $TxEnd $Strand $ExonOuIntron $CdsOuPas $UtrOuCDS $DebutExonOuIntron $FinExonOuIntron $DebutOuFinExonOuIntron $DistanceAlaBorneDeExonOuIntron $OccupationExonOuIntron" set Retour [string trim $Retour "\n"] set Retour [string trim $Retour] } else { set Retour "$Name $TxStart $TxEnd $Strand X X X X X X X X" set Retour [string trim $Retour "\n"] set Retour [string trim $Retour] } } return $Retour } proc LocToSequenceUcsc {Chromosome Debut Fin Orientation Organisme VersionGenome} { #Version plus flexible de BoutADNDeUcsc set FichierTFA "" if {[regexp -nocase "homo|human|Human|Homo" $Organisme]} { set Organisme "Homo_Sapiens" set FichierTFA2 "/genomics/link/UCSCGenomes/$Organisme/bigZips$VersionBigZips/$Chromosome.fa" } else { if {[regexp -nocase "Mus|Mouse" $Organisme]} { set Organisme "Mus_Musculus" } set FichierTFA "/genomics/link/UCSCGenomes/$Organisme/bigZips$VersionGenome/$Chromosome.fa" } return [BoutADNDuTFA $Debut $Fin $Orientation $FichierTFA] } proc LocUcStaf {{Qui ""} {Quoi ""}} { global LocUcStaf #set WithoutQDS [expr [info exists LocUcStaf(FichierLocUcStafHuman)] || [info exists LocUcStaf(FichierLocUcStafMouse)]] #if { ! [OnTraiteUCSCGenomes] && ! $WithoutQDS} { return [QuestionDeScience "UCSCGenomes" "ret LocUcStaf $Qui $Quoi"] } #if {[OnTraiteUCSCGenomes]} { #set RepertoireUcsc [RepertoireDuGenome]239RefSq.affyID_xenoAnnot.txt #} else { #set RepertoireUcsc "/genomics/link/UCSCAlignements/g3/UCSCGenomes" # } set RepertoireUcsc "/genomics/link/UCSCAlignements/g3/UCSCGenomes" if {$Qui==""} { set Qui "ListOf" set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcStaf($Qui,$Quoi)]} { return $LocUcStaf($Qui,$Quoi) } if {[info exists LocUcStaf("EstCharge")]} { return "" } set LocUcStaf("EstCharge") 1 set FichierLocUcStafHuman "$RepertoireUcsc/Homo_sapiens/database/all_mrna.txt" if {[info exists LocUcStaf(FichierLocUcStafMouse)]} { set FichierLocUcStafMouse $LocUcStaf(FichierLocUcStafMouse) } else { #rR set FichierLocUcStafMouse "$RepertoireUcsc/Mus_musculus/database/MouseAllGenes200602" #rR set FichierLocUcStafMouse "$RepertoireUcsc/Mus_musculus/database/knowngene.txt" set FichierLocUcStafMouse "$RepertoireUcsc/Mus_musculus/database/all_mrna.txt" } #================================================================================== set OnTraitemRNA [regexp "all_mrna" [file tail $FichierLocUcStafHuman]] set OnTraiteknowngene [regexp "knowngene" [file tail $FichierLocUcStafHuman]] #================================================================================== if {$OnTraiteknowngene} { set EnteteCommuneknowngene "bin name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneknowngene " "] } #================================================================================== if {$OnTraitemRNA} { set EnteteCommunemRNA "bin matches misMatches repMatches nCount qNumInsert qBaseInsert tNumInsert tBaseInsert strand qName qSize qStart qEnd tName tSize tStart tEnd blockCount blockSizes qStarts tStarts" set LesTetes [split $EnteteCommunemRNA " "] } #================================================================================== if {!$OnTraitemRNA && !$OnTraiteknowngene} { set EnteteCommuneknowngene "name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds NAME2 alignID" set LesTetes [split $EnteteCommuneknowngene " "] } set LocUcStaf(ListOf,Header) $LesTetes foreach Ligne [concat [list "Human"] [LesLignesDuFichier $FichierLocUcStafHuman] [list "Mouse"] [LesLignesDuFichier $FichierLocUcStafMouse]] { if {[regexp {^(Human|Mouse)$} $Ligne]} { set HumMou $Ligne continue } set LesMots [LesMotsDeLaLigne $Ligne] if {$OnTraiteknowngene} { set Name [lindex $LesMots 1] } else { #=========================================================== foreach Tete $LesTetes { set $Tete [lindex $LesMots [lsearch $LesTetes $Tete]] } set Name $qName set chrom $tName set Space " " # Espionne $Name$Space$qName$Space$qStart$Space$qEnd #=========================================================== } if {[info exists LocUcStaf($Name,name)]} { set ReferenceName $Name set Ieme 1 set NewName "$Name-[incr Ieme]" while {[info exists LocUcStaf($NewName,name)]} { set NewName "$Name-[incr Ieme]" } set LocUcStaf($NewName,ReferenceName) $ReferenceName set Name $NewName lappend LocUcStaf(PolyLocalisationOf,$ReferenceName) $NewName lappend LocUcStaf(ListOf,PolyLocalisation) $NewName } set txStart $tStart set txEnd $tEnd lappend LocUcStaf(ListOf$HumMou,Access) $qName lappend LocUcStaf(ListOf,Access) $qName foreach Tete $LesTetes Mot $LesMots { set $Tete $Mot set LocUcStaf($Name,$Tete) $Mot } if {$OnTraitemRNA} { lappend LocUcStaf(ListOf,qName) $qName lappend LocUcStaf($qName,line) $Name } if {$OnTraiteknowngene} { lappend LocUcStaf(ListOf,name2) $name2 lappend LocUcStaf($name2,line) $Name } if { ! $OnTraiteknowngene && ! $OnTraitemRNA } { lappend LocUcStaf(ListOf,NAME2) $NAME2 lappend LocUcStaf($NAME2,line) $Name } set LocUcStaf($Name,line) $Ligne lappend LocUcStaf(ListOf$HumMou,chrom) $chrom set StartEndName [list $txStart $txEnd $strand $Name] lappend LocUcStaf(ListOf$HumMou$chrom,StartEndName) $StartEndName } foreach Org [list "Human" "Mouse"] { set LocUcStaf(ListOf$Org,chrom) [lsort -unique $LocUcStaf(ListOf$Org,chrom)] foreach Chr $LocUcStaf(ListOf$Org,chrom} { set LocUcStaf(ListOf$Org$Chr,StartEndName) [lsort -integer -index 0 $LocUcStaf(ListOf$Org$Chr,StartEndName)] } return [LocUcStaf $Qui $Quoi] } proc LocUcsc {{Qui ""} {Quoi ""}} { global LocUcsc Wup "Attention UCSC compte a partir de 0 pour les start MAIS a partir de 1 pour les end !!!!!!!!!!!!!!!!!!!!!!!!" set RepertoireUcsc "/genomics/link/UCSCGenomes" set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/mm9/last/knownGene.txt" if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcsc($Qui,$Quoi)]} { return $LocUcsc($Qui,$Quoi) } if {[info exists LocUcsc("EstCharge")]} { return "" } set LocUcsc("EstCharge") 1 set LesTetes [list KgId chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds proteinAcc alignID] set LocUcsc(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierLocUcscMouse] { #rR c est un peu maladroit de indiquer que le blanc ne doit pas etre reduit de 2 a 1 set LesMots [LesMotsDeLaLigne $Ligne " "] set KgId [lindex $LesMots 0] lappend LocUcsc(ListOf,KgId) $KgId foreach Tete $LesTetes Mot $LesMots { set $Tete $Mot set LocUcsc($KgId,$Tete) $Mot } lappend LocUcsc(ListOf,proteinAcc) $proteinAcc lappend LocUcsc($proteinAcc,KgId) $KgId set LocUcsc($KgId,line) $Ligne lappend LocUcsc(ListOf,chrom) $chrom #LocUcsc ListOfchr1 StartEndName set StartEndName [list $txStart $txEnd $strand $KgId] lappend LocUcsc(ListOfMouse$chrom,StartEndName) $StartEndName } return [LocUcsc $Qui $Quoi] } proc LocUcscEssai {{Qui ""} {Quoi ""}} { Wup "Attention UCSC compte a partir de 0" set RepertoireUcsc "/genomics/link/UCSCGenomes" set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/knownGene.txt" if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcscEssai($Qui,$Quoi)]} { return $LocUcscEssai($Qui,$Quoi) } if {[info exists LocUcscEssai("EstCharge")]} { return "" } set LocUcscEssai("EstCharge") 1 set LesTetes [list KgId chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds proteinAcc alignID] set LocUcscEssai(ListOf,Header) $LesTetes return [LocUcscEssai $Qui $Quoi] } proc LocUcscEvi {Nom {FromWhere ""} {AllLoc ""}} { set LesLignesLocUcsc {} set AllLoc [string equal -nocase "AllLoc" $AllLoc] set Acc [AccessEvi $Nom] if {$FromWhere==""} { set FromWhere "From200602" } if {$FromWhere=="From200602"} { set LigneLocUcsc [LocUcsc $Acc "line"] set LigneNewAcc [LocUcsc PolyLocalisationOf $Acc] set LesNewsAcc [split $LigneNewAcc " "] lappend LesLignesLocUcsc $LigneLocUcsc foreach New $LesNewsAcc { lappend LesLignesLocUcsc [LocUcsc $New "line"] } } set Name ""; set Chrom ""; set Strand ""; set TxStart ""; set TxEnd "" scan $LigneLocUcsc "%s %s %s %s %s" Name Chrom Strand TxStart TxEnd set LocUcscEvi "$Chrom:$TxStart-$TxEnd ($Strand)" if { ! $AllLoc} { return $LocUcscEvi } if {$AllLoc && $LocUcscEvi==":- ()"} { return $LocUcscEvi } foreach LigneLocUcsc $LesLignesLocUcsc { set Name ""; set Chrom ""; set Strand ""; set TxStart ""; set TxEnd "" scan $LigneLocUcsc "%s %s %s %s %s" Name Chrom Strand TxStart TxEnd set LocUcscEvi "$Chrom:$TxStart-$TxEnd ($Strand)" lappend LesLUE $LocUcscEvi } return $LesLUE } proc LocUcscOld {{Qui ""} {Quoi ""}} { Wup "Attention UCSC compte a partir de 0" global LocUcsc #set WithoutQDS [expr [info exists LocUcsc(FichierLocUcscHuman)] || [info exists LocUcsc(FichierLocUcscMouse)]] #if { ! [OnTraiteUCSCGenomes] && ! $WithoutQDS} { return [QuestionDeScience "UCSCGenomes" "ret LocUcsc $Qui $Quoi"] } #if {[OnTraiteUCSCGenomes]} { #set RepertoireUcsc [RepertoireDuGenome]239RefSq.affyID_xenoAnnot.txt #} else { #set RepertoireUcsc "/genomics/link/UCSCGenomes" # } set RepertoireUcsc "/genomics/link/UCSCGenomes" if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcsc($Qui,$Quoi)]} { return $LocUcsc($Qui,$Quoi) } if {[info exists LocUcsc("EstCharge")]} { return "" } set LocUcsc("EstCharge") 1 if {[info exists LocUcsc(FichierLocUcscHuman)]} { set FichierLocUcscHuman $LocUcsc(FichierLocUcscHuman) } else { set FichierLocUcscHuman "$RepertoireUcsc/Homo_sapiens/database/knownGene.txt" } if {[info exists LocUcsc(FichierLocUcscMouse)]} { set FichierLocUcscMouse $LocUcsc(FichierLocUcscMouse) } else { set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/knownGene.txt" } set OnTraiteRefGene [regexp "refGene" [file tail $FichierLocUcscMouse]] if {$OnTraiteRefGene} { set EnteteCommuneRefGene "bin name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneRefGene " "] } else { set EnteteCommuneKnownGene "KgId chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds proteinAcc alignID" set LesTetes [split $EnteteCommuneKnownGene " "] } set LocUcsc(ListOf,Header) $LesTetes foreach Ligne [concat [list "Human"] [LesLignesDuFichier $FichierLocUcscHuman] [list "Mouse"] [LesLignesDuFichier $FichierLocUcscMouse]] { if {[regexp {^(Human|Mouse)$} $Ligne]} { set HumMou $Ligne ; continue } set LesMots [LesMotsDeLaLigne $Ligne] if {$OnTraiteRefGene} { set Name [lindex $LesMots 1] } else { set Name [lindex $LesMots 0] } if {[info exists LocUcsc($Name,name)]} { set ReferenceName $Name set Ieme 1 set NewName "$Name-[incr Ieme]" while {[info exists LocUcsc($NewName,name)]} { set NewName "$Name-[incr Ieme]" } set LocUcsc($NewName,ReferenceName) $ReferenceName set Name $NewName lappend LocUcsc(PolyLocalisationOf,$ReferenceName) $NewName lappend LocUcsc(ListOf,PolyLocalisation) $NewName } lappend LocUcsc(ListOf$HumMou,Access) $Name lappend LocUcsc(ListOf,Access) $Name foreach Tete $LesTetes Mot $LesMots { set $Tete $Mot set LocUcsc($Name,$Tete) $Mot } if {$OnTraiteRefGene} { lappend LocUcsc(ListOf,name2) $name2 lappend LocUcsc($name2,line) $Name } else { lappend LocUcsc(ListOf,proteinID) $proteinID lappend LocUcsc($proteinID,line) $Name } set LocUcsc($Name,line) $Ligne lappend LocUcsc(ListOf$HumMou,chrom) $chrom set StartEndName [list $txStart $txEnd $strand $Name] lappend LocUcsc(ListOf$HumMou$chrom,StartEndName) $StartEndName } foreach Org [list "Human" "Mouse"] { set LocUcsc(ListOf$Org,chrom) [lsort -unique $LocUcsc(ListOf$Org,chrom)] foreach Chr $LocUcsc(ListOf$Org,chrom) { set LocUcsc(ListOf$Org$Chr,StartEndName) [lsort -integer -index 0 $LocUcsc(ListOf$Org$Chr,StartEndName)] } } return [LocUcsc $Qui $Quoi] } proc LocUcscRat {{Qui ""} {Quoi ""}} { Wup "Attention UCSC compte a partir de 0" global LocUcscRat set RepertoireUcsc "/genomics/link/UCSCGenomes" if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcscRat($Qui,$Quoi)]} { return $LocUcscRat($Qui,$Quoi) } if {[info exists LocUcscRat("EstCharge")]} { return "" } set LocUcscRat("EstCharge") 1 if {[info exists LocUcscRat(FichierLocUcscRat)]} { set FichierLocUcscRat $LocUcscRat(FichierLocUcscRat) } else { set FichierLocUcscRat "$RepertoireUcsc/Mus_musculus/database/knownGene.txt" } set OnTraiteRefGene [regexp "refGene" [file tail $FichierLocUcscRat]] if {$OnTraiteRefGene} { set EnteteCommuneRefGene "bin name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneRefGene " "] } else { set EnteteCommuneKnownGene "name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds proteinID alignID" set LesTetes [split $EnteteCommuneKnownGene " "] } set LocUcscRat(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierLocUcscRat] { set LesMots [LesMotsDeLaLigne $Ligne] if {$OnTraiteRefGene} { set Name [lindex $LesMots 1] } else { set Name [lindex $LesMots 0] } if {[info exists LocUcscRat($Name,name)]} { set ReferenceName $Name set Ieme 1 set NewName "$Name-[incr Ieme]" while {[info exists LocUcscRat($NewName,name)]} { set NewName "$Name-[incr Ieme]" } set LocUcscRat($NewName,ReferenceName) $ReferenceName set Name $NewName lappend LocUcscRat(PolyLocalisationOf,$ReferenceName) $NewName lappend LocUcscRat(ListOf,PolyLocalisation) $NewName } lappend LocUcscRat(ListOf$HumMou,Access) $Name lappend LocUcscRat(ListOf,Access) $Name foreach Tete $LesTetes Mot $LesMots { set $Tete $Mot set LocUcscRat($Name,$Tete) $Mot } if {$OnTraiteRefGene} { lappend LocUcscRat(ListOf,name2) $name2 lappend LocUcscRat($name2,line) $Name } else { lappend LocUcscRat(ListOf,proteinID) $proteinID lappend LocUcscRat($proteinID,line) $Name } set LocUcscRat($Name,line) $Ligne lappend LocUcscRat(ListOf$HumMou,chrom) $chrom set StartEndName [list $txStart $txEnd $strand $Name] lappend LocUcscRat(ListOf$HumMou$chrom,StartEndName) $StartEndName } foreach Org [list "Human" "Mouse"] { set LocUcscRat(ListOf$Org,chrom) [lsort -unique $LocUcscRat(ListOf$Org,chrom)] foreach Chr $LocUcscRat(ListOf$Org,chrom) { set LocUcscRat(ListOf$Org$Chr,StartEndName) [lsort -integer -index 0 $LocUcscRat(ListOf$Org$Chr,StartEndName)] } } return [LocUcscRat $Qui $Quoi] } proc LocUcscRefSeq {Org {Qui ""} {Quoi ""}} { #Org sera mm9, hg19, danRer6, galGal3 ... global LocUcscRefSeq if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcscRefSeq(Org)] && $LocUcscRefSeq(Org)!=$Org} { unset LocUcscRefSeq } if {[info exists LocUcscRefSeq($Qui,$Quoi)]} { return $LocUcscRefSeq($Qui,$Quoi) } if {[info exists LocUcscRefSeq("EstCharge")]} { return "" } set LocUcscRefSeq("EstCharge") 1 set LocUcscRefSeq(Org) $Org set File [CorresVersionGenomeEtFichierRefGene $Org] set EnteteCommuneRefGene "bin name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds score name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneRefGene " "] set LocUcscRefSeq(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $File] { if {$Ligne==""} {continue} set LesMots [LesMotsDeLaLigne $Ligne] set AccNm [lindex $LesMots 1] set exonCount [lindex $LesMots 8] lappend LocUcscRefSeq(ListOf,Access) $AccNm set LocUcscRefSeq($AccNm,line) $Ligne lappend LocUcscRefSeq($AccNm,lines) $Ligne lappend LocUcscRefSeq($AccNm,exonCounts) $exonCount foreach Tete $LesTetes Mot $LesMots { set LocUcscRefSeq($AccNm,$Tete) $Mot } set Chr $LocUcscRefSeq($AccNm,chrom) lappend LesChr $Chr set StartEndName [list $LocUcscRefSeq($AccNm,txStart) $LocUcscRefSeq($AccNm,txEnd) $LocUcscRefSeq($AccNm,strand) $AccNm $LocUcscRefSeq($AccNm,name2)] lappend LocUcscRefSeq(ListOf$Chr,StartEndName) $StartEndName } foreach Chr [lsort -unique $LesChr] { #set LocUcscRefSeq(ListOf$Chr,StartEndName) [lsort -integer -index 1 $LocUcscRefSeq(ListOf$Chr,StartEndName)] set LocUcscRefSeq(ListOf$Chr,StartEndName) [lsort -integer -index 0 $LocUcscRefSeq(ListOf$Chr,StartEndName)] } return [LocUcscRefSeq $Org $Qui $Quoi] } proc LocUcscRefSeqEvi {Nom {FromWhere ""} {AllLoc ""}} { set AllLoc [string equal -nocase "AllLoc" $AllLoc] if {$FromWhere==""} {set FromWhere "From200602"} if {$FromWhere=="From200602"} { set LigneLocUcsc [LocUcscRefSeq $Nom "line"] set LignesLocUcsc [LocUcscRefSeq $Nom "lines"] } if {$FromWhere=="From200503"} { set RepertoireUcsc "/genomics/link/UCSCGenomes" set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/refGene.txt" global LocUcscRefSeq ; set LocUcscRefSeq(FichierLocUcscMouse) $FichierLocUcscMouse set LigneLocUcsc [LocUcscRefSeq $Nom "line"] set LignesLocUcsc [LocUcscRefSeq $Nom "lines"] } set Name "" set Chrom "" set Strand "" set TxStart "" set TxEnd "" scan $LigneLocUcsc "%s %s %s %s %s %s" bidon Name Chrom Strand TxStart TxEnd set LocUcscRefSeqEvi "$Chrom:$TxStart-$TxEnd ($Strand)" if { ! $AllLoc} { return $LocUcscRefSeqEvi } if {$AllLoc && $LocUcscRefSeqEvi==":- ()"} {return $LocUcscRefSeqEvi} foreach LigneLocUcsc $LignesLocUcsc { set Name "" set Chrom "" set Strand "" set TxStart "" set TxEnd "" scan $LigneLocUcsc "%s %s %s %s %s %s" bidon Name Chrom Strand TxStart TxEnd set LocUcscRefSeqEvi "$Chrom:$TxStart-$TxEnd ($Strand)" lappend LesLUE $LocUcscRefSeqEvi } return $LesLUE } proc LocUcscRefSeqOld {{Qui ""} {Quoi ""}} { #name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds global LocUcscRefSeq if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcscRefSeq($Qui,$Quoi)]} { return $LocUcscRefSeq($Qui,$Quoi) } if {[info exists LocUcscRefSeq("EstCharge")]} { return "" } set LocUcscRefSeq("EstCharge") 1 set RepertoireUcsc "/genomics/link/UCSCGenomes" if {[info exists LocUcscRefSeq(FichierLocUcscMouse)]} { set FichierLocUcscMouse $LocUcscRefSeq(FichierLocUcscMouse) } else { set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/refGene.txt" } set EnteteCommuneRefGene "bin name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneRefGene " "] set LocUcscRefSeq(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierLocUcscMouse] { if {$Ligne==""} {continue} set LesMots [LesMotsDeLaLigne $Ligne] set AccNm [lindex $LesMots 1] set exonCount [lindex $LesMots 8] lappend LocUcscRefSeq(ListOf,Access) $AccNm set LocUcscRefSeq($AccNm,line) $Ligne lappend LocUcscRefSeq($AccNm,lines) $Ligne lappend LocUcscRefSeq($AccNm,exonCounts) $exonCount foreach Tete $LesTetes Mot $LesMots { set LocUcscRefSeq($AccNm,$Tete) $Mot } set Chr $LocUcscRefSeq($AccNm,chrom) set StartEndName [list $LocUcscRefSeq($AccNm,txStart) $LocUcscRefSeq($AccNm,txEnd) $AccNm] } return [LocUcscRefSeq $Qui $Quoi] } proc LocUcscRefSeqRat {{Qui ""} {Quoi ""}} { #name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds global LocUcscRefSeqRat if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "line" } if {[info exists LocUcscRefSeqRat($Qui,$Quoi)]} { return $LocUcscRefSeqRat($Qui,$Quoi) } if {[info exists LocUcscRefSeqRat("EstCharge")]} { return "" } set LocUcscRefSeqRat("EstCharge") 1 set RepertoireUcsc "/genomics/link/UCSCGenomes" if {[info exists LocUcscRefSeqRat(FichierLocUcscRat)]} { set FichierLocUcscRat $LocUcscRefSeqRat(FichierLocUcscRat) } else { set FichierLocUcscRat "$RepertoireUcsc/Rattus_norvegicus/database/refGene.txt" } set EnteteCommuneRefGene "name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds id name2 cdsStartStat cdsEndStat exonFrames" set LesTetes [split $EnteteCommuneRefGene " "] set LocUcscRefSeqRat(ListOf,Header) $LesTetes foreach Ligne [LesLignesDuFichier $FichierLocUcscRat] { if {$Ligne==""} {continue} set LesMots [LesMotsDeLaLigne $Ligne] set AccNm [lindex $LesMots 0] set exonCount [lindex $LesMots 7] lappend LocUcscRefSeqRat(ListOf,Access) $AccNm lappend LocUcscRefSeqRat($AccNm,line) $Ligne lappend LocUcscRefSeqRat($AccNm,lines) $Ligne lappend LocUcscRefSeqRat($AccNm,exonCounts) $exonCount foreach Tete $LesTetes Mot $LesMots { set LocUcscRefSeqRat($AccNm,$Tete) $Mot } set Chr $LocUcscRefSeqRat($AccNm,chrom) set StartEndName [list $LocUcscRefSeqRat($AccNm,txStart) $LocUcscRefSeqRat($AccNm,txEnd) $AccNm] } return [LocUcscRefSeqRat $Qui $Quoi] } proc LocaText {t {Action ""}} { global LocaText if {$Action==""} { set Action "Next" } if {$Action=="Top"} { if { ! [info exists LocaText($t,Start)]} { unset LocaText($t,Start) } set Action "Next" } if {$Action=="New"} { if {[info exists LocaText($t,Text)]} { unset LocaText($t,Text) } if { ! [info exists LocaText($t,Start)]} { unset LocaText($t,Start) } } if { ! [info exists LocaText($t,Text)]} { set Texte [Entre] set LocaText($t,Text) $Texte } if { ! [info exists LocaText($t,Start)]} { set LocaText($t,Start) 1.0 } set Index [$t search $LocaText($t,Text) $LocaText($t,Start)] if {$Index == ""} { return "" } set Fin [expr $Index + 0.[string length $LocaText($t,Text)]] $t tag configure Spot -background red $t tag remove Spot 1.0 end $t tag add Spot $Index $Fin set LocaText($t,Start) [expr $Index + 0.1] return $Index } proc LocalisationChromosomiqueAffyProbes {Input} { Wup "Identifie a partir d un blast ou d un blat les localisation chromosomiques des ProbeSet sur le genome UCSC" Wup "Utilise 3 cutoff, PId du HSP, Cover du HSP avec un gene, Cover des HSP pour un gene" Wup "voir projet AffyProbesTest" #0- Recuperation des infos diverses #0-1 Nom de la puce set GoodChip "" foreach AffyChip [Affymetrix_Chips] { if {[regexp -nocase $AffyChip $Input]} {set GoodChip $AffyChip} } #0-2 Nom du genome set Genome "" if { [regexp "^HG" $GoodChip]} { set Genome "human" } elseif {[regexp "^MG" $GoodChip]} { set Genome "mouse" } if {$Genome==""} {return ""} #1- Chargement des infos du Blast ou du Blat set TailleQuery [AskBlast $Input Taille] set NomQuery [AskBlast $Input Query] set NbSbjct [AskBlast $Input NbSubject] if {$NbSbjct=="0" || $NbSbjct==""} {Espionne ">>>[file tail $Input]\tNo blat hit\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery RefSeq]\t[InterrogeLesInfosAffymetrix $GoodChip $NomQuery Description]";return ""} set Profile_Base "[string repeat "0" $TailleQuery]" Espionne [join [list Query Chromosome "Query Begins" "Query Ends" "Chr Begins" "Chr Ends" QueryLength NbBaseFound QueryCover NbBaseMultiFound QueryMultiCover] "\t"] #Espionne ">>Q: $NomQuery -- $TailleQuery -- NbSbjct $NbSbjct" #2- Boucle sur les differents subjects set LesChromos "" set LesMultiLoc "" set PId_Cutoff "95.0" set Cover_Cutoff "70.0" for {set i 1} {$i <=$NbSbjct} {incr i} { #Le recouvrement doit etre maximal de notre Query vers Subject #A l inverse on peut etre plus souple dans le sens S vers Q set BId [AskBlast $Input Subject $i] set NbSegment [AskBlast $Input BanqueId $BId NbSegment] set Chromosome [string trim $BId] regsub "chr" $Chromosome "" Chromosome #Espionne ">> $BId -- $NbSegment -- $Chromosome" #2-1 Boucle sur les differents HSPs for {set j 1} {$j <=$NbSegment} {incr j} { set DS "" set FS "" set DS_Tmp "" set FS_Tmp "" set Aln "" set AlnQ "" set nbN "0" set PId "0.0" set PId_Tmp "" set PCover "0.0" set nbId "" set nbTot "" set DQ "" set FQ "" set DQ_Tmp "" set FQ_Tmp "" set TailleHSP "0" set Sens "" set SensQ "" set SensS "" #2-1-1 Recuperation des debut et fin, PId set DS_Tmp [AskBlast $Input BanqueId $BId Segment $j DS] set FS_Tmp [AskBlast $Input BanqueId $BId Segment $j FS] set PId_Tmp [AskBlast $Input BanqueId $BId Segment $j Identities] set Aln [AskBlast $Input BanqueId $BId Segment $j AlignLineaire] set Aln [lindex [split $Aln "\n"] 0] #Espionne "$Aln" regexp {^Query:[ ]+[0-9]+ ([a-z\-]+) [0-9]+} $Aln tmp AlnQ set nbN [regexp -all -indices {[n]} $AlnQ] #166/201 (83%) regexp {([0-9]+)/([0-9]+) \([0-9]+%\)} $PId_Tmp Tmp nbId nbTot if {$nbId == "" || $nbTot == ""} { Espionne "Pb avec le PId de $BId" continue } else { #On ajoute aux bases identiques le nombre de bases N pour palier aux pertes d identite set nbId [expr $nbId + $nbN] #PId du HSP set PId [expr ($nbId*100.0)/$nbTot] #PCover du HSP par rapport a la query complete set PCover [expr ($nbId*100.0)/$TailleQuery] } if {$PId < $PId_Cutoff} {continue} #Espionne "HSP $j: $DS_Tmp / $FS_Tmp" #Espionne "\tPId: $PId -- $nbId + $nbN / $nbTot" #Espionne "\tCover: $PCover -- $nbId + $nbN / $TailleQuery" set Sens [AskBlast $Input BanqueId $BId Segment $j Orientation] scan $Sens "%s / %s" SensQ SensS set DQ_Tmp [AskBlast $Input BanqueId $BId Segment $j DQ] set FQ_Tmp [AskBlast $Input BanqueId $BId Segment $j FQ] if {$DQ_Tmp>$FQ_Tmp} { set DQ $FQ_Tmp set FQ $DQ_Tmp set TailleHSP [expr $DQ_Tmp - $FQ_Tmp + 1] } else { set DQ $DQ_Tmp set FQ $FQ_Tmp set TailleHSP [expr $FQ_Tmp - $DQ_Tmp + 1] } #Espionne "$BId - $PId - $DS - $FS" #Profil de chaque HSP set ProfileHSP "" set ProfileHSP "[string repeat "0" [expr $DQ-1]]" append ProfileHSP "[string repeat "1" $TailleHSP]" if {$TailleQuery == $FQ} { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ-1]]" } else { append ProfileHSP "[string repeat "0" [expr $TailleQuery-$FQ]]" } #Espionne "$ProfileHSP" #Espionne "$TailleQuery [string length $ProfileHSP]" #lappend Tab($ID_Tmp,CoverQ) $HSPCover #lappend Tab($ID_Tmp,CoverQ) [list $DQ $FQ] set Tab($i,$j,CoverQ) $ProfileHSP set Tab($i,$j,Debut) $DS_Tmp set Tab($i,$j,Fin) $FS_Tmp set Tab($i,$j,DebutQ) $DQ set Tab($i,$j,FinQ) $FQ if {! [info exists Tab($i,Lesj)]} { set Tab($i,Lesj) "" } lappend Tab($i,Lesj) $j } #Espionne "Lesj de $i :[set Tab($i,Lesj)]" #2-1-6 Creation d 1 profil cumulatif des alignements pour un subject (chromosome) # calcul du recouvrement de la query set Profile_Tmp "$Profile_Base" if {! [info exists Tab($i,Lesj)]} {continue} set LesDebutsFins "" set LesDebuts "" set LesFins "" set LesDebutsQ "" set LesFinsQ "" foreach HSP [set Tab($i,Lesj)] { set NbTrouve "" #Espionne "HSP -- $HSP" if {! [info exists Tab($i,$HSP,CoverQ)]} {continue} set Profile [set Tab($i,$HSP,CoverQ)] lappend LesDebutsFins [list [set Tab($i,$HSP,DebutQ)] [set Tab($i,$HSP,FinQ)] [set Tab($i,$HSP,Debut)] [set Tab($i,$HSP,Fin)]] set Profile_Tmp2 "" #Espionne "<< -- $Profile_Tmp" #Espionne "< -- $Profile" foreach a [split $Profile_Tmp ""] b [split $Profile ""] { if {$a >= 0 && $b=="1"} { if {$a == 9} { append Profile_Tmp2 $a } else { append Profile_Tmp2 [expr $a + $b] continue } } else { append Profile_Tmp2 $a } } set Profile_Tmp $Profile_Tmp2 } set NbTrouve1 "" set NbTrouve2 "" set QueryCover "" set QueryCover_Cutoff "70.0" set MultiLocCover "" set MultiLocCover_Cutoff "50.0" #Pourcentage de residus trouves a 1 seule localisation pour le meme hit (meme chromosome) set NbTrouve1 [regexp -all -indices {[1-9]} $Profile_Tmp] set QueryCover [expr ($NbTrouve1*100.0)/$TailleQuery] if {$QueryCover >= $QueryCover_Cutoff} { #On considere le hit comme valide et donc on lui attribue la localisation lappend LesChromos $Chromosome } #Pourcentage de residus trouves a plus d 1 localisation pour le meme hit (meme chromosome) set NbTrouve2 [regexp -all -indices {[2-9]} $Profile_Tmp] set MultiLocCover [expr ($NbTrouve2*100.0)/$TailleQuery] if {$MultiLocCover >= $MultiLocCover_Cutoff} { #On considere le hit comme valide pour une multiloc sur le meme hit set TabMulti($Chromosome) 1 #lappend LesMultiLoc 1 } set LesDebuts "" set LesFins "" set LesDebutsQ "" set LesFinsQ "" set LesDebutsFins [lsort -integer -increasing -index 0 $LesDebutsFins] foreach DF $LesDebutsFins { lappend LesDebutsQ [lindex $DF 0] lappend LesFinsQ [lindex $DF 1] lappend LesDebuts [lindex $DF 2] lappend LesFins [lindex $DF 3] } Espionne [join [list $NomQuery $Chromosome [join $LesDebutsQ ";"] [join $LesFinsQ ";"] [join $LesDebuts ";"] [join $LesFins ";"] $TailleQuery $NbTrouve1 $QueryCover $NbTrouve2 $MultiLocCover] "\t"] #Espionne "$Profile_Tmp" #Espionne "$Chromosome -- Query Cover: $NbTrouve1 / $TailleQuery = $QueryCover" #Espionne "$Chromosome -- Multi Loc : $NbTrouve2 / $TailleQuery = $MultiLocCover" #Espionne "$Chromosome -- Debuts $LesDebuts // Fins $LesFins" } AskBlast unsetfile $Input set Texte "" if {[llength $LesChromos] > 1} { append Texte "MultiChromo ($LesChromos) " set FirstTime 1 foreach Chr $LesChromos { if {[info exists TabMulti($Chr)]} { if {$FirstTime} { set FirstTime 0 append Texte "MultiLoc pour " } append Texte "$Chr " } } } elseif {[llength $LesChromos] == 1} { append Texte "MonoChromo ($LesChromos) " set FirstTime 1 foreach Chr $LesChromos { if {[info exists TabMulti($Chr)]} { if {$FirstTime} { set FirstTime 0 append Texte "MultiLoc pour " } append Texte "$Chr " } } } else { append Texte "NoChromo" } #Espionne ">>>$NomQuery\t$Texte" return "" } proc LocalisationChromosomiqueAffyProbesPourTous {Dir} { set LesFichiers [glob -nocomplain -directory "$Dir" "*"] foreach File $LesFichiers { #Espionne "$File" LocalisationChromosomiqueAffyProbes $File } return "" } proc LocalisationDesVirtualPPCRs {{Action ""} {NVoulu ""}} { global LocalisationDesVirtualPPCRs if {$Action==""} { set Action "Show" } if {$Action=="GetLocOf" && [info exists LocalisationDesVirtualPPCRs($NVoulu)]} { return [set LocalisationDesVirtualPPCRs($NVoulu)] } if {$Action=="GetLocOf" && [info exists LocalisationDesVirtualPPCRs("EstCharge")]} { return "" } set LesLocs {} set LesBads {} set LocalisationDesVirtualPPCRs("EstCharge") 1 set FichierLocalisationDesVirtualPPCRs "[RepertoireDuGenome]/fiches/LocalisationDesVirtualPPCRs" if {[file exists $FichierLocalisationDesVirtualPPCRs]} { array set LocalisationDesVirtualPPCRs [LesLignesDuFichier $FichierLocalisationDesVirtualPPCRs] } foreach N [VirtualPPCREnStock "LaListeDesNs"] { set PGS [VirtualPPCREnStock $N "PGS"] set SeqSujet [VirtualPPCREnStock $N "SeqSubject"] set FullName [VirtualPPCREnStock $N "FullName"] if { ! [info exists LocalisationDesVirtualPPCRs($N)]} { set FicTFA "[RepertoireDuGenome]/nuctfa/$PGS" if {[file exists $FicTFA]} { set SeqNuc [QueLaSequenceDuFichierTFA $FicTFA] if {[regexp -nocase -indices $SeqSujet $SeqNuc Indices]} { scan $Indices "%d %d" d f set DN [expr $d+1] set FN [expr $f+1] set DP [expr $d/3 + 1] set FP [expr $f/3 + 1] } else { set DN -1 set FN -1 set DP -1 set FP -1 } } else { set DN -2 set FN -2 set DP -2 set FP -2 } set Ligne [format "%s %s %4d - %4d %4d - %4d %s" $N $PGS $DP $FP $DN $FN $FullName] set LocalisationDesVirtualPPCRs($N) $Ligne } else { set Ligne [set LocalisationDesVirtualPPCRs($N)] scan $Ligne "%s %s %d %s %d %d %s %d %s" NMemo PGSMemo DP Tiret1 FP DN Tiret2 FN FullNameMemo if {$N!=$NMemo || $PGS!=$PGSMemo} { FaireLire "Something is wrong with \n$Ligne\nI expected $N $PGS $FullName" } } scan $FullName "%s %s" PgsLu SujetLu set PpcrName [StringSuivant "ppcr: " dans $FullName] scan $PpcrName "%s" SujetPpcr if {$SujetLu!=$SujetPpcr} { FaireLire "Different subjects in $Ligne" } if {[regexp {\-[0-9]+\-[0-9]+$} $SujetLu Match]} { regsub -all {\-} $Match " " Bornes scan $Bornes "%d %d" DLu FLu if {$DP==$DLu && $FP==$FLu} { } else { lappend LesBads $Ligne } } lappend LesLocs $Ligne } if { ! [file exists $FichierLocalisationDesVirtualPPCRs]} { SauveLesLignes [array get LocalisationDesVirtualPPCRs] dans $FichierLocalisationDesVirtualPPCRs } if {$Action=="ShowBad"} { return [AfficheVariable [join $LesBads "\n"] "AvecVirtualPPCR" "BadLocalisationDesVirtualPPCRsSurLesPGS"] } if {$Action=="Show"} { return [AfficheVariable [join $LesLocs "\n"] "AvecVirtualPPCR" "LocalisationDesVirtualPPCRsSurLesPGS"] } if {$Action=="GetAllLocs"} { return $LesLocs } if {$Action=="GetLocOf"} { return [LocalisationDesVirtualPPCRs "GetLocOf" $NVoulu] } return $LesLocs } proc LocalisationGenomique {} { #Creation du fichier /Localisation/BoxLocalisation_Human set Fichier [FichierBoxLocalisation "BoxLocalisation_Human"] #Creation du fichier polylocalise /Localisation/polylocalise FichierPolyLocalise $Fichier #Creation des fichiers de distribution /Localisation/*_Distribution QuelquesChiffresSurLesSequences Save 1 #Procedures de raymond LesLocalisationsSurChroContig "Create" TriLesLocalisations TriLesLocalisations "BestOnly" } proc LocalisationOligoWolfgang {{Liste ""}} { set Repertoirelur "/genomics/link/lur" if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set total 0; set pasprot 0; set passouris 0; set souris 0; set dejaid 0; set cas1 0; set cas2 0; set cas3 0; set cas4 0; set pasmRNA 0 foreach Nom $Liste { incr total puts "" set LigneFinal ""; set AccmRNA ""; set AccmRNA2 "" set AccProt ""; set IdProt ""; set AccmRNA ""; set AccmRNA2 ""; set LocRs ""; set LocGbRs ""; set LocGbRs2 "" set AccProt [RecupereAccProtWolfgang $Nom] set Espece [RecupereOrganisme $Nom] puts "Espece $Espece" if {[regexp "NoProtein" $AccProt]} { incr pasprot puts "Nom $Nom" puts "pas prot" set LigneFinal "$Nom; " lappend LesLignesFinals $LigneFinal continue } if {![regexp -nocase {^Mus} $Espece]} { incr passouris puts "Nom $Nom" puts "pas souris" set LigneFinal "$Nom; " lappend LesLignesFinals $LigneFinal continue } if {[regexp "MOUSE" $AccProt]} { incr souris incr dejaid set IdProt $AccProt puts "IdProt $IdProt" } else { incr souris set IdProt [IdDuProt $AccProt] puts "IdProt $IdProt" } set AccsmRNAs [LocUcsc $IdProt] if {$AccsmRNAs==""} { incr pasmRNA puts "Nom $Nom" puts "pas mRNA" set LigneFinal "$Nom; " lappend LesLignesFinals $LigneFinal continue } puts "AccsmRNAs $AccsmRNAs" set LesAccmRNA [split $AccsmRNAs " "] set LesAccmRNA [ListeSansDoublon $LesAccmRNA] if {[llength $LesAccmRNA]==1} { incr cas1; puts "un acc" set AccmRNA [lindex $LesAccmRNA 0] puts "AccmRNA $AccmRNA" } elseif {[llength $LesAccmRNA]>1} { set onanm 0 foreach elmt $LesAccmRNA { if {[regexp {^NM_} $elmt]} { set onanm 1 incr cas2; puts "pls acc ac nm" set AccmRNA $elmt puts "AccmRNA $AccmRNA" break } } if {!$onanm} { incr cas3; puts "pls acc ss nm" set AccmRNA [lindex $LesAccmRNA 0] set AccmRNA2 [lindex $LesAccmRNA 1] puts "AccmRNA $AccmRNA" puts "AccmRNA2 $AccmRNA2" } } else { incr cas4; puts "cas4" } if { [regexp {^NM_} $AccmRNA] || [regexp {^XM_} $AccmRNA] || [regexp {^NR_} $AccmRNA]} { set LocRs [LocUcscRefSeqEvi $AccmRNA From200602 AllLoc] set LocRs [ListeSansDoublon $LocRs] } set LocGbRs [LocUcscEvi $AccmRNA From200602 AllLoc] set LocGbRs [ListeSansDoublon $LocGbRs] if {$AccmRNA2!=""} { set LocGbRs2 [LocUcscEvi $AccmRNA2 From200602 AllLoc] set LocGbRs2 [ListeSansDoublon $LocGbRs2] } if {$LocRs!=""} { puts "LocRs $LocRs" puts "LocGbRs $LocGbRs" set LocFinal [DetermineLocUcsc $LocGbRs $LocRs] puts "$LocFinal" set LigneFinal "$Nom;$LocFinal" lappend LesLignesFinals $LigneFinal } if {$LocGbRs2!=""} { puts "LocGbRs $LocGbRs" puts "LocGbRs2 $LocGbRs2" set LocFinal [DetermineLocUcsc $LocGbRs $LocGbRs2] puts "$LocFinal" set LigneFinal "$Nom;$LocFinal" lappend LesLignesFinals $LigneFinal } } puts "" puts "total $total" puts "pasprot $pasprot" puts "passouris $passouris" puts "souris $souris" puts "pasmRNA $pasmRNA" puts "un acc $cas1" puts "pls acc ac nm $cas2" puts "pls acc ss nm $cas3" puts "cas4 $cas4" SauveLesLignes $LesLignesFinals dans $Repertoirelur/LocalisationOligoWolfgang } proc LocaliseBlastNDataBase {{NomDeLaBanque ""} {T ""}} { global RepertoireDuGenome Wup "Creates the correct link or database in ./banques" Wup "ATTENTION : If NomDeLaBanque is not empty returns it immediately ... a ameliorer" if {$NomDeLaBanque!=""} { return $NomDeLaBanque } set RepDesBanques "$RepertoireDuGenome/banques" if { ! [file exists $RepDesBanques]} { File mkdir $RepDesBanques } set BlastNDataBaseDefaut "/catalog/blast/human.nal" if {$T=="T"} { set BlastNDataBase "$RepDesBanques/tblastndatabase" } else { set BlastNDataBase "$RepDesBanques/blastndatabase" } if {[file exists $BlastNDataBase] && [file type $BlastNDataBase]=="link"} { set BlastNDataBase [ReadLink $BlastNDataBase $RepDesBanques] } while { ! [file exists "$BlastNDataBase"]} { if {[OuiOuNon "You didn't define the (T)BlastN database.\n Do You want to use $BlastNDataBaseDefaut ?"]} { eval exec "ln -sf $BlastNDataBaseDefaut $BlastNDataBase" set BlastNDataBase [ReadLink $BlastNDataBase $RepDesBanques] continue } if {[OuiOuNon "You didn't define the BlastN database.\n You can create your own database in $RepDesBanques\n Do You want to do it now ?"]} { FaireLire "Do it before answering" return [LocaliseBlastNDataBase] } if {[OuiOuNon "Do I exit ?"]} { exit } if {[OuiOuNon "Do I cancel BlastN ?"]} { return "" } } regsub {\.(nal|nhr)$} $BlastNDataBase "" BlastNDataBase return $BlastNDataBase } proc LocaliseBlastPDataBase {{Banque ""}} { global RepertoireDuGenome Wup "Creates the correct link or database in ./banques" if {[regexp {_dedicated_(.+)$} $Banque Match Rep]} { regsub {_dedicated_(.+)$} $Banque "" B set Loc [LocaliseBlastPDataBase $B] DedicatedBlastDatabase $Rep Espionne $Loc return $Loc } if {[regexp "/" $Banque]} { return $Banque } if {$Banque!=""} { set Possible "[RepertoireDuGenome]/banques/$Banque" if {[file exists $Possible] || [file exists $Possible.phr] || [file exists $Possible.pal] } { return $Possible } set Possible "/catalog/blast/$Banque" if {[file exists $Possible] || [file exists $Possible.phr] || [file exists $Possible.pal] } { return $Possible } FaireLire "Attention la banque ne peut etre que dans [RepertoireDuGenome]/banques/" } set RepDesBanques "$RepertoireDuGenome/banques" if { ! [file exists $RepDesBanques]} { File mkdir $RepDesBanques } set BlastPDataBaseDefaut "/catalog/blast/protall.pal" set BlastPDataBase "$RepDesBanques/blastpdatabase" if {[file exists $BlastPDataBase] && [file type $BlastPDataBase]=="link"} { set BlastPDataBase [ReadLink $BlastPDataBase $RepDesBanques] } Espionne $BlastPDataBase while { ! [file exists "$BlastPDataBase"]} { if {[OuiOuNon "You didn't define the BlastP database.\n Do You want to use $BlastPDataBaseDefaut ?"]} { eval exec "ln -sf $BlastPDataBaseDefaut $BlastPDataBase" set BlastPDataBase [ReadLink $BlastPDataBase $RepDesBanques] continue } if {[OuiOuNon "You didn't define the BlastP database.\n You can create your own database in $RepDesBanques\n Do You want to do it now ?"]} { FaireLire "Do it before answering" return [LocaliseBlastPDataBase] } if {[OuiOuNon "Do I exit ?"]} { exit } if {[OuiOuNon "Do I cancel BlastP ?"]} { return "" } } regsub {\.(pal|phr)$} $BlastPDataBase "" BlastPDataBase return $BlastPDataBase } proc LocaliseDansLaListe {Liste Pos} { if {$Pos<0} { return "-1 -1" } set D [lindex $Liste 0] set OldD $D foreach F [lrange $Liste 1 end] { if {$Pos>=$F} { set OldD $D ; set D $F ; continue } return "$D $F" } if {$Pos==$F} {return "$OldD $F"} return "-2 -2" } proc LocaliseLaProteineSurLeGenome {FichierTFA} { global RepertoireDuGenome global FichierSequenceADN set NomDeLaBanque "$RepertoireDuGenome/banques/[PreFixe]" if { ! [file exists "$NomDeLaBanque.nhr"]} { CreeUneBanqueBlast $FichierSequenceADN $NomDeLaBanque } if { ! [regexp "/" $FichierTFA] && [YaPABouTROUouTRNAouARNenDebutDe [file tail $FichierTFA]]} { set FichierTFA "$RepertoireDuGenome/prottfa/$FichierTFA" } set NomDeLaProteine [file tail $FichierTFA] set FichierBlast "[RepertoireDeTravail]/$NomDeLaProteine.tblastn" if { ! [file exists $FichierBlast]} { set CommandeTBlastN "exec blastall -p tblastn -i $FichierTFA -o $FichierBlast -d $NomDeLaBanque -v 500 -K 0 -b 500 -e 10.0 -F F" eval $CommandeTBlastN } set MonReflet [lindex [ChaqueProteineDuTBlastN $FichierBlast "AvecLaSeq"] 0] set MesTraits [split $MonReflet "\t"] set Debut [lindex $MesTraits 9] set Fin [lindex $MesTraits 10] set Subject [lindex $MesTraits 11] set Query [QueLaSequence [ContenuDuFichier $FichierTFA]] if {[string range $Query 1 end] != [string range $Subject 1 end]} { Espionne $NomDeLaProteine Espionne $Query Espionne $Subject return "$Debut $Fin :Erreur:$Query:$Subject" } return "$Debut $Fin" } proc LocaliseLeFrameshiftDuBlastX {Fichier} { global SeuilExpectPourBlastX ; set SeuilExpectPourBlastX 10.1234 set A -1 ; set B -1 foreach Ligne [ChaqueProteineDuBlastX $Fichier] { scan $Ligne "%s %d %d %s %s %f %f %d %d %d %d" NomLu N I Access Orga S E DQ FQ DS FS if {$I==1} { set LesPos {} } lappend LesPos $DQ lappend LesPos $FQ if {$I==1} { continue } set LesPos [lsort -integer $LesPos] set A [lindex $LesPos 1] set B [lindex $LesPos 2] break } return "[Mini $A $B] [Maxi $A $B]" } proc LocaliseLeProteome {FichierTFAsDuProteome {DernierBon ""}} { global RepertoireDuGenome set FichierBornes "$RepertoireDuGenome/fiches/bornesduproteome" set FichierTmp "[RepertoireDeTravail]/tmp.localise.[PreFixe]" while {[file exists $FichierBornes]} { if {[OuiOuNon "$FichierBornes already exists.\nDo I append to it ?"]} { break } if {[OuiOuNon "Do I accept it ?"]} { return $FichierBornes } if {[OuiOuNon "Do I delete $FichierBornes ?"]} { break } if {[OuiOuNon "Do I cancel Proteome localisation ?"]} { return "" } if {[OuiOuNon "Do I stop ?"]} { exit } } if {$DernierBon == ""} { set AttendLeDernierBon 0 } else { set AttendLeDernierBon 1 } foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"] { if {$AttendLeDernierBon} { set AttendLeDernierBon [regexp $DernierBon $Access] continue } File delete -force "$FichierTmp" File delete -force "$FichierTmp.tblastn" set Query [LaSequenceDuTFAs $FichierTFAsDuProteome $Access] regsub "^>" $Query ">$FichierTmp $FichierTmp " Query set FichierTFA [Sauve $Query dans "$FichierTmp"] set Bornes [LocaliseLaProteineSurLeGenome $FichierTFA] scan $Bornes "%d %d" Debut Fin set Orient "F" if {$Debut>$Fin} { set Orient "R" set W $Debut set Debut $Fin set Fin $W } AppendAuFichier $FichierBornes "$Access $Debut $Fin $Orient" } return $FichierBornes } proc LocaliseLesBornesPourRefSeq {Debut Fin Chromosome Sens PId Genome {Quoi RefSeq}} { Wup "Permet de rendre les Access present pour un debut et une fin sur un chromosome" Wup "Utilisation du chevauchement des Debuts et des Fins de la query et des access sur les chromosomes" Wup "On utilise plusieurs cutoff PId et Pcover qui caracterise chaque HSP" global PosUCSC if {$Quoi=="RefSeq"} { #set File "/genomics/g3/UCSCGenomes/Mus_musculus/database/refSeqAli.txt" #set File "/genomics/g3/UCSCGenomes/Homo_sapiens/database/refSeqAli.txt" set File "[UCSCGenomeDir $Genome]/database/refSeqAli.txt" } elseif {$Quoi=="All"} { set File "[UCSCGenomeDir $Genome]/database/all_mrna.txt" } else { Espionne "Problem with LocaliseLesBornesPourRefSeq no Quoi (RefSeq ou All)" return "" } set LesDFsRetenus "" set LesIDsRetenus "" #Espionne "Test for $Debut $Fin in $Chromosome $Sens $PId" #Partie qui peut etre inclue dans un Interroge ou AskUCSC if {! [info exists PosUCSC] || ! [info exists PosUCSC(EstCharge)]} { set PosUCSC(EstCharge) 1 #1- Recuperation de la liste des access disponibles set ListOfID [AskUCSC $File ListOfID] #Espionne "$ListOfID" foreach ID $ListOfID { set ListOfPosition "" set IdBis "" set Chr "" set D "" set F "" #2- Pour chaque Access on recupere la liste des positions # liste: $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand #Rq: les positions des annotations en minus strand (-) sont des plus petites au plus grandes # ce sont donc les positions absolues qui sont donnees par UCSC set ListOfPosition [AskUCSC $File ID $ID ListOfPosition] foreach LofP $ListOfPosition { set IdBis "" set Chr "" set D "" set F "" set Strand "" ###$File ID $ID ListOfPosition --> liste $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand set IdBis [lindex $LofP 0] set Chr [lindex $LofP 3] set D [lindex $LofP 4] set F [lindex $LofP 5] set Strand [lindex $LofP 6] #Espionne "$LofP" #Espionne "$ID | $IdBis - $Strand | $Chr -- $D - $F" #2-1 Pour un chr, debut et fin -- son ID if {! [info exists PosUCSC($Chr,$Strand,$D,$F,ID)]} { set PosUCSC($Chr,$Strand,$D,$F,ID) "" } set PosUCSC($Chr,$Strand,$D,$F,ID) $ID #2-2 Pour un chr et un ID -- ses fins if {! [info exists PosUCSC($Chr,$Strand,$IdBis,LesF)]} { set PosUCSC($Chr,$Strand,$IdBis,LesF) "" } lappend PosUCSC($Chr,$Strand,$IdBis,LesF) $F #2-3 Pour un chr et un debut -- ses IDs if {! [info exists PosUCSC($Chr,$Strand,$D,LesIDs)]} { set PosUCSC($Chr,$Strand,$D,LesIDs) "" } lappend PosUCSC($Chr,$Strand,$D,LesIDs) $IdBis #2-4 Pour un chr et un debut -- ses Fins if {! [info exists PosUCSC($Chr,$Strand,$D,LesF)]} { set PosUCSC($Chr,$Strand,$D,LesF) "" } lappend PosUCSC($Chr,$Strand,$D,LesF) $F #2-5 Pour un chr et une fin -- ses Debuts if {! [info exists PosUCSC($Chr,$Strand,$F,LesD)]} { set PosUCSC($Chr,$Strand,$F,LesD) "" } lappend PosUCSC($Chr,$Strand,$F,LesD) $D #2-6 Pour un chr -- ses Debuts if {! [info exists PosUCSC($Chr,$Strand,LesD)]} { set PosUCSC($Chr,$Strand,LesD) "" } lappend PosUCSC($Chr,$Strand,LesD) $D #2-7 Pour un chr -- ses Fins if {! [info exists PosUCSC($Chr,$Strand,LesF)]} { set PosUCSC($Chr,$Strand,LesF) "" } lappend PosUCSC($Chr,$Strand,LesF) $F #2-8 La liste des chromosomes if {! [info exists PosUCSC(LesChr)]} { set PosUCSC(LesChr) "" } lappend PosUCSC(LesChr) $Chr } } if {! [info exists PosUCSC(LesChr)]} {return ""} set PosUCSC(LesChr) [lsort -unique [set PosUCSC(LesChr)]] #On enleve la redondance dans les debuts et fin identiques #cette information est de toute facon presente dans les autres resultats #set NbGenes "" foreach Chro [set PosUCSC(LesChr)] { if {[info exists PosUCSC($Chro,+,LesD)]} { set PosUCSC($Chro,+,LesD) [lsort -unique [set PosUCSC($Chro,+,LesD)]] #Espionne "Nb Debut: chromo $Chro + = [llength [set PosUCSC($Chro,+,LesD)]]" #lappend NbGenes [llength [set PosUCSC($Chro,+,LesD)]] } if {[info exists PosUCSC($Chro,-,LesD)]} { set PosUCSC($Chro,-,LesD) [lsort -unique [set PosUCSC($Chro,-,LesD)]] #Espionne "Nb Debut: chromo $Chro - = [llength [set PosUCSC($Chro,-,LesD)]]" #lappend NbGenes [llength [set PosUCSC($Chro,-,LesD)]] } if {[info exists PosUCSC($Chro,+,LesF)]} { set PosUCSC($Chro,+,LesF) [lsort -unique [set PosUCSC($Chro,+,LesF)]] #Espionne "Nb Fin: chromo $Chro + = [llength [set PosUCSC($Chro,+,LesF)]]" #lappend NbGenes [llength [set PosUCSC($Chro,+,LesF)]] } if {[info exists PosUCSC($Chro,-,LesF)]} { set PosUCSC($Chro,-,LesF) [lsort -unique [set PosUCSC($Chro,-,LesF)]] #Espionne "Nb Fin: chromo $Chro - = [llength [set PosUCSC($Chro,-,LesF)]]" #lappend NbGenes [llength [set PosUCSC($Chro,-,LesF)]] } } #Espionne "NbGenes: [expr [join $NbGenes "+"]]" } #d et f (debut fin trouves), D et F coordonnees du/des mRNAs dispos # # D d f F #Ok | | | | # ------------------------------------ # d D f F #Ok | | | | # ------------------------------------ # D d F f #Ok | | | | # ------------------------------------ # D F d f #No | | | | # ------------------------------------ set TailleSequence [expr $Fin - $Debut + 1] #4-1 Recuperation des indices de positions avec notre Debut et Fin #################################################################### #4-1-1 On cherche $Fin dans la liste des debuts. On garde tout les debuts positionnes avant $Fin ################################################################################################ set Indice "" set NewIndice "" set ListeDesDebuts "" set OnLeGarde 0 if {! [info exists PosUCSC($Chromosome,$Sens,LesD)]} {return ""} set ListeDesDebuts [set PosUCSC($Chromosome,$Sens,LesD)] #Espionne "$ListeDesDebuts" #Pour tenir compte du fait que l on peut tomber pile sur une position existante set Indice [lsearch -all -exact -integer $ListeDesDebuts $Fin] if {$Indice != "" && [expr $Indice >= 0]} { Espionne "$Fin existe deja ($Indice) dans la liste des debuts" set OnLeGarde 1 } lappend ListeDesDebuts $Fin #Espionne "Avant Liste des debuts [llength $ListeDesDebuts]" set ListeDesDebuts [lsort -integer -increasing -unique $ListeDesDebuts] #Espionne "Apres Liste des debuts [llength $ListeDesDebuts]" #4-1-2 Recherche de l indice de notre $Fin ########################################## set Indice [lsearch -all -exact -integer $ListeDesDebuts $Fin] #Espionne "Indices: $Indice" if {! [expr $Indice >= 0]} {return ""} #Espionne "$ListeDesDebuts" #Pour tenir compte du fait que l on peut tomber pile sur une position existante if {$OnLeGarde} { set NewIndice $Indice } else { #Si Indice = 0 on a -1 mais c ok car on ne le prend pas set NewIndice [expr $Indice - 1] } if {! [expr $NewIndice >= 0]} { #Espionne "Pb $NewIndice calcule < 0" return "" } #4-1-3 On parcourt toutes les positions des debuts (D) et on garde ceux dont la fin est superieur a $Debut ########################################################################################################## set LesDebutsATester [lrange $ListeDesDebuts 0 $NewIndice] set LesDebutsATester [lsort -integer -decreasing $LesDebutsATester] foreach D $LesDebutsATester { set LesFs "" set F "" #Mettre une condition d arret #if {$D > $LimiteInf} {break} set LesFs [set PosUCSC($Chromosome,$Sens,$D,LesF)] foreach F $LesFs { #Espionne "$D $F -- $Debut" if {$F < $Debut} {continue} lappend LesDFsRetenus [list $D $F] } } #Espionne "Liste debuts: $LesDFsRetenus" #4-2-1 On cherche $Debut dans la liste des Fins. On garde toutes les fins positionnees apres $Debut #4-2-1 A partir de la Fin(F) on va garder toutes les fins existantes (f) dont le debut est superieure au D recherche ################################################################################################################ set Indice "" set NewIndice "" set ListeDesFins "" set OnLeGarde 0 set ListeDesFins [set PosUCSC($Chromosome,$Sens,LesF)] #Pour tenir compte du fait que l on peut tomber pile sur une position existante set Indice [lsearch -all -exact -integer $ListeDesFins $Debut] if {$Indice != "" && [expr $Indice >= 0]} { Espionne "$Debut existe deja ($Indice) dans la liste des fins" set OnLeGarde 1 } lappend ListeDesFins $Debut #Espionne "Avant Liste des fins [llength $ListeDesFins]" set ListeDesFins [lsort -integer -increasing -unique $ListeDesFins] #Espionne "Apres Liste des fins [llength $ListeDesFins]" #4-2-2 Recherche de l indice de notre $Debut ############################################ set Indice [lsearch -all -exact -integer $ListeDesFins $Debut] #Espionne "Indices: $Indice" if {! [expr $Indice >= 0]} {return ""} #Espionne "$ListeDesFins" #Pour tenir compte du fait que l on peut tomber pile sur une position existante set TailleListeDesFins [llength $ListeDesFins] if {$OnLeGarde} { set NewIndice $Indice } else { #Si Indice = $TailleListeDesFins on a $TailleListeDesFins+1 mais c ok car on ne le prend pas set NewIndice [expr $Indice + 1] } if {! [expr $NewIndice < $TailleListeDesFins]} { #Espionne "Pb $NewIndice calcule > fin ($TailleListeDesFins)" return "" } #4-2-3 On parcourt toutes les positions des fins (F) et on garde ceux dont le debut est inferieur a $Fin ######################################################################################################## set LesFinsATester [lrange $ListeDesFins $NewIndice end] set LesFinsATester [lsort -integer -increasing $LesFinsATester] foreach F $LesFinsATester { set LesDs "" set D "" #Mettre une condition d arret #if {$F < $LimiteSup} {break} set LesDs [set PosUCSC($Chromosome,$Sens,$F,LesD)] foreach D $LesDs { if {$D > $Fin} {continue} lappend LesDFsRetenus [list $D $F] } } if {$LesDFsRetenus == ""} {return ""} set LesDFsRetenus [lsort -unique $LesDFsRetenus] #Espionne "Liste debuts+fins: $LesDFsRetenus" #5- Selection des ID suscpetibles de contenir notre sequence #5-1 On parcourt toutes les positions et on conserve les bonnes ############################################################### set PCoverCutOff "90.0" set PCoverCutOff "80.0" set PIdCutOff "95.0" foreach DF $LesDFsRetenus { set UnD "" set UnF "" set ID "" set BorneInf "" set BorneSup "" set Cover "" set PCover "" set UnD [lindex $DF 0] set UnF [lindex $DF 1] set ID [set PosUCSC($Chromosome,$Sens,$UnD,$UnF,ID)] #5-2 CutOff1 - Calcul du recouvrement Query / Subject # Ou encore combien de la query est contenue dans le subject if {$Debut < $UnD} {set BorneInf $UnD} else {set BorneInf $Debut} if {$Fin < $UnF} {set BorneSup $Fin} else {set BorneSup $UnF} if {$BorneSup>$BorneInf} { set Cover [expr $BorneSup - $BorneInf + 1] } else { set Cover [expr $BorneInf - $BorneSup + 1] Espionne "Prob inversion" } set Cover [expr abs($Cover)] set PCover [expr 100.0*(($Cover*1.0) / $TailleSequence)] Espionne "Cover $ID: ($BorneSup - $BorneInf) $Cover / $TailleSequence = $PCover % cover | $PId % Id." if {$PCover < $PCoverCutOff} {continue} #5-3 CutOff2 - Utilisation du pourcentage d identite # Ou encore le PId du HSP if {$PId < $PIdCutOff} {continue} lappend LesIDsRetenus $ID } return "$LesIDsRetenus" } proc LocaliseLesBornesPourRefSeqMoi {Debut Fin Chromosome Sens PId Genome {Quoi RefSeq}} { Wup "Permet de rendre les Access present pour un debut et une fin sur un chromosome" Wup "Utilisation du chevauchement des Debuts et des Fins de la query et des access sur les chromosomes" Wup "On utilise plusieurs cutoff PId et Pcover qui caracterise chaque HSP" global PosUCSC if {$Quoi=="RefSeq"} { #set File "/genomics/link/UCSCGenomes/Mus_musculus/database/refSeqAli.txt" #set File "/genomics/link/UCSCGenomes/Homo_sapiens/database/refSeqAli.txt" set File "[UCSCGenomeDir $Genome]/database/refSeqAli.txt" } elseif {$Quoi=="All"} { set File "[UCSCGenomeDir $Genome]/database/all_mrna.txt" } else { Espionne "Problem with LocaliseLesBornesPourRefSeq no Quoi (RefSeq ou All)" return "" } set LesDFsRetenus "" set LesIDsRetenus "" #Espionne "Test for $Debut $Fin in $Chromosome $Sens $PId" #Partie qui peut etre inclue dans un Interroge ou AskUCSC if {! [info exists PosUCSC] || ! [info exists PosUCSC(EstCharge)]} { set PosUCSC(EstCharge) 1 #1- Recuperation de la liste des access disponibles set ListOfID [AskUCSC $File ListOfID] #Espionne "$ListOfID" foreach ID $ListOfID { set ListOfPosition "" set IdBis "" set Chr "" set D "" set F "" #2- Pour chaque Access on recupere la liste des positions # liste: $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand #Rq: les positions des annotations en minus strand (-) sont des plus petites au plus grandes # ce sont donc les positions absolues qui sont donnees par UCSC set ListOfPosition [AskUCSC $File ID $ID ListOfPosition] foreach LofP $ListOfPosition { set IdBis "" set Chr "" set D "" set F "" set Strand "" ###$File ID $ID ListOfPosition --> liste $ID $SeqFrom $SeqTo $Chr $ChrFrom $ChrTo $Strand set IdBis [lindex $LofP 0] set Chr [lindex $LofP 3] set D [lindex $LofP 4] set F [lindex $LofP 5] set Strand [lindex $LofP 6] #Espionne "$LofP" #Espionne "$ID | $IdBis - $Strand | $Chr -- $D - $F" #2-1 Pour un chr, debut et fin -- son ID if {! [info exists PosUCSC($Chr,$Strand,$D,$F,ID)]} { set PosUCSC($Chr,$Strand,$D,$F,ID) "" } set PosUCSC($Chr,$Strand,$D,$F,ID) $ID #2-2 Pour un chr et un ID -- ses fins if {! [info exists PosUCSC($Chr,$Strand,$IdBis,LesF)]} { set PosUCSC($Chr,$Strand,$IdBis,LesF) "" } lappend PosUCSC($Chr,$Strand,$IdBis,LesF) $F #2-3 Pour un chr et un debut -- ses IDs if {! [info exists PosUCSC($Chr,$Strand,$D,LesIDs)]} { set PosUCSC($Chr,$Strand,$D,LesIDs) "" } lappend PosUCSC($Chr,$Strand,$D,LesIDs) $IdBis #2-4 Pour un chr et un debut -- ses Fins if {! [info exists PosUCSC($Chr,$Strand,$D,LesF)]} { set PosUCSC($Chr,$Strand,$D,LesF) "" } lappend PosUCSC($Chr,$Strand,$D,LesF) $F #2-5 Pour un chr et une fin -- ses Debuts if {! [info exists PosUCSC($Chr,$Strand,$F,LesD)]} { set PosUCSC($Chr,$Strand,$F,LesD) "" } lappend PosUCSC($Chr,$Strand,$F,LesD) $D #2-6 Pour un chr -- ses Debuts if {! [info exists PosUCSC($Chr,$Strand,LesD)]} { set PosUCSC($Chr,$Strand,LesD) "" } lappend PosUCSC($Chr,$Strand,LesD) $D #2-7 Pour un chr -- ses Fins if {! [info exists PosUCSC($Chr,$Strand,LesF)]} { set PosUCSC($Chr,$Strand,LesF) "" } lappend PosUCSC($Chr,$Strand,LesF) $F #2-8 La liste des chromosomes if {! [info exists PosUCSC(LesChr)]} { set PosUCSC(LesChr) "" } lappend PosUCSC(LesChr) $Chr } } if {! [info exists PosUCSC(LesChr)]} {return ""} set PosUCSC(LesChr) [lsort -unique [set PosUCSC(LesChr)]] #On enleve la redondance dans les debuts et fin identiques #cette information est de toute facon presente dans les autres resultats #set NbGenes "" foreach Chro [set PosUCSC(LesChr)] { if {[info exists PosUCSC($Chro,+,LesD)]} { set PosUCSC($Chro,+,LesD) [lsort -unique [set PosUCSC($Chro,+,LesD)]] #Espionne "Nb Debut: chromo $Chro + = [llength [set PosUCSC($Chro,+,LesD)]]" #lappend NbGenes [llength [set PosUCSC($Chro,+,LesD)]] } if {[info exists PosUCSC($Chro,-,LesD)]} { set PosUCSC($Chro,-,LesD) [lsort -unique [set PosUCSC($Chro,-,LesD)]] #Espionne "Nb Debut: chromo $Chro - = [llength [set PosUCSC($Chro,-,LesD)]]" #lappend NbGenes [llength [set PosUCSC($Chro,-,LesD)]] } if {[info exists PosUCSC($Chro,+,LesF)]} { set PosUCSC($Chro,+,LesF) [lsort -unique [set PosUCSC($Chro,+,LesF)]] #Espionne "Nb Fin: chromo $Chro + = [llength [set PosUCSC($Chro,+,LesF)]]" #lappend NbGenes [llength [set PosUCSC($Chro,+,LesF)]] } if {[info exists PosUCSC($Chro,-,LesF)]} { set PosUCSC($Chro,-,LesF) [lsort -unique [set PosUCSC($Chro,-,LesF)]] #Espionne "Nb Fin: chromo $Chro - = [llength [set PosUCSC($Chro,-,LesF)]]" #lappend NbGenes [llength [set PosUCSC($Chro,-,LesF)]] } } #Espionne "NbGenes: [expr [join $NbGenes "+"]]" } #d et f (debut fin trouves), D et F coordonnees du/des mRNAs dispos # # D d f F #Ok | | | | # ------------------------------------ # d D f F #Ok | | | | # ------------------------------------ # D d F f #Ok | | | | # ------------------------------------ # D F d f #No | | | | # ------------------------------------ set TailleSequence [expr $Fin - $Debut + 1] #4-1 Recuperation des indices de positions avec notre Debut et Fin #################################################################### #4-1-1 On cherche $Fin dans la liste des debuts. On garde tout les debuts positionnes avant $Fin ################################################################################################ set Indice "" set NewIndice "" set ListeDesDebuts "" set OnLeGarde 0 if {! [info exists PosUCSC($Chromosome,$Sens,LesD)]} {return ""} set ListeDesDebuts [set PosUCSC($Chromosome,$Sens,LesD)] #Espionne "$ListeDesDebuts" #Pour tenir compte du fait que l on peut tomber pile sur une position existante set Indice [lsearch -all -exact -integer $ListeDesDebuts $Fin] if {$Indice != "" && [expr $Indice >= 0]} { Espionne "$Fin existe deja ($Indice) dans la liste des debuts" set OnLeGarde 1 } lappend ListeDesDebuts $Fin #Espionne "Avant Liste des debuts [llength $ListeDesDebuts]" set ListeDesDebuts [lsort -integer -increasing -unique $ListeDesDebuts] #Espionne "Apres Liste des debuts [llength $ListeDesDebuts]" #4-1-2 Recherche de l indice de notre $Fin ########################################## set Indice [lsearch -all -exact -integer $ListeDesDebuts $Fin] #Espionne "Indices: $Indice" if {! [expr $Indice >= 0]} {return ""} #Espionne "$ListeDesDebuts" #Pour tenir compte du fait que l on peut tomber pile sur une position existante if {$OnLeGarde} { set NewIndice $Indice } else { #Si Indice = 0 on a -1 mais c ok car on ne le prend pas set NewIndice [expr $Indice - 1] } if {! [expr $NewIndice >= 0]} { #Espionne "Pb $NewIndice calcule < 0" return "" } #4-1-3 On parcourt toutes les positions des debuts (D) et on garde ceux dont la fin est superieur a $Debut ########################################################################################################## set LesDebutsATester [lrange $ListeDesDebuts 0 $NewIndice] set LesDebutsATester [lsort -integer -decreasing $LesDebutsATester] foreach D $LesDebutsATester { set LesFs "" set F "" #Mettre une condition d arret #if {$D > $LimiteInf} {break} set LesFs [set PosUCSC($Chromosome,$Sens,$D,LesF)] foreach F $LesFs { #Espionne "$D $F -- $Debut" if {$F < $Debut} {continue} lappend LesDFsRetenus [list $D $F] } } #Espionne "Liste debuts: $LesDFsRetenus" #4-2-1 On cherche $Debut dans la liste des Fins. On garde toutes les fins positionnees apres $Debut #4-2-1 A partir de la Fin(F) on va garder toutes les fins existantes (f) dont le debut est superieure au D recherche ################################################################################################################ set Indice "" set NewIndice "" set ListeDesFins "" set OnLeGarde 0 set ListeDesFins [set PosUCSC($Chromosome,$Sens,LesF)] #Pour tenir compte du fait que l on peut tomber pile sur une position existante set Indice [lsearch -all -exact -integer $ListeDesFins $Debut] if {$Indice != "" && [expr $Indice >= 0]} { Espionne "$Debut existe deja ($Indice) dans la liste des fins" set OnLeGarde 1 } lappend ListeDesFins $Debut #Espionne "Avant Liste des fins [llength $ListeDesFins]" set ListeDesFins [lsort -integer -increasing -unique $ListeDesFins] #Espionne "Apres Liste des fins [llength $ListeDesFins]" #4-2-2 Recherche de l indice de notre $Debut ############################################ set Indice [lsearch -all -exact -integer $ListeDesFins $Debut] #Espionne "Indices: $Indice" if {! [expr $Indice >= 0]} {return ""} #Espionne "$ListeDesFins" #Pour tenir compte du fait que l on peut tomber pile sur une position existante set TailleListeDesFins [llength $ListeDesFins] if {$OnLeGarde} { set NewIndice $Indice } else { #Si Indice = $TailleListeDesFins on a $TailleListeDesFins+1 mais c ok car on ne le prend pas set NewIndice [expr $Indice + 1] } if {! [expr $NewIndice < $TailleListeDesFins]} { #Espionne "Pb $NewIndice calcule > fin ($TailleListeDesFins)" return "" } #4-2-3 On parcourt toutes les positions des fins (F) et on garde ceux dont le debut est inferieur a $Fin ######################################################################################################## set LesFinsATester [lrange $ListeDesFins $NewIndice end] set LesFinsATester [lsort -integer -increasing $LesFinsATester] foreach F $LesFinsATester { set LesDs "" set D "" #Mettre une condition d arret #if {$F < $LimiteSup} {break} set LesDs [set PosUCSC($Chromosome,$Sens,$F,LesD)] foreach D $LesDs { if {$D > $Fin} {continue} lappend LesDFsRetenus [list $D $F] } } if {$LesDFsRetenus == ""} {return ""} set LesDFsRetenus [lsort -unique $LesDFsRetenus] #Espionne "Liste debuts+fins: $LesDFsRetenus" #5- Selection des ID suscpetibles de contenir notre sequence #5-1 On parcourt toutes les positions et on conserve les bonnes ############################################################### set PCoverCutOff "90.0" set PCoverCutOff "80.0" set PIdCutOff "95.0" foreach DF $LesDFsRetenus { set UnD "" set UnF "" set ID "" set BorneInf "" set BorneSup "" set Cover "" set PCover "" set UnD [lindex $DF 0] set UnF [lindex $DF 1] set ID [set PosUCSC($Chromosome,$Sens,$UnD,$UnF,ID)] #Espionne "$DF $ID" #5-2 CutOff1 - Calcul du recouvrement Query / Subject # Ou encore combien de la query est contenue dans le subject if {$Debut < $UnD} {set BorneInf $UnD} else {set BorneInf $Debut} if {$Fin < $UnF} {set BorneSup $Fin} else {set BorneSup $UnF} if {$BorneSup>$BorneInf} { set Cover [expr $BorneSup - $BorneInf + 1] } else { set Cover [expr $BorneInf - $BorneSup + 1] Espionne "Prob inversion" } set Cover [expr abs($Cover)] set PCover [expr 100.0*(($Cover*1.0) / $TailleSequence)] #Espionne "Cover $ID: ($BorneSup - $BorneInf) $Cover / $TailleSequence = $PCover % cover | $PId % Id." if {$PCover < $PCoverCutOff} {continue} #5-3 CutOff2 - Utilisation du pourcentage d identite # Ou encore le PId du HSP if {$PId < $PIdCutOff} {continue} lappend LesIDsRetenus $ID } return "$LesIDsRetenus" } proc LocaliseLesFrameshifts {{FichierFrameshifts ""}} { if {$FichierFrameshifts==""} { set FichierFrameshifts "[RepertoireDuGenome]/fiches/Frameshifts" } if {[regexp "All$" $FichierFrameshifts]} { set OnlyFS 0 } else {set OnlyFS 1} foreach Nom [ListeDesPABs] { if { $OnlyFS && ! [regexp -nocase "FS ok|FS Nt|FS Ct|Gap" [ExtraitInfo $Nom "EP"]]} { continue } set Raison [ExtraitInfo $Nom "EP"] regsub -all " " $Raison "_" Raison foreach Fichier [LesBlastXDesHitsMultiples $Nom] { if {[info exists DejaVu($Fichier)]} { continue } set DejaVu($Fichier) $Nom set NN [file tail $Fichier] set Offset [Box $Nom debut] foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp "nucleic sequence from" $Ligne]} { continue } set Moi [StringApres "nucleic sequence from " dans $Ligne] set Lui [StringApres "$Moi to " dans $Ligne] set Offset [Mini [Box $Moi debut] [Box $Lui debut]] break } set Loc "[LocaliseLeFrameshiftDuBlastX $Fichier] $NN" scan $Loc "%d %d" D F set Localisation "[expr $D+$Offset-1] [expr $F+$Offset-1]" set Resultat "$Localisation $NN $Raison" Espionne $Resultat lappend LesLocs $Resultat } } set Localisations {} set OldLoc "" set Noms "" lappend LesLocs "-1 -1 xxx" foreach Ligne $LesLocs { scan $Ligne "%d %d %s %s" D F Nom Raison if {$Nom=="xxx" || ($OldLoc!="" && "$D $F"!=$OldLoc)} { lappend Localisations "$OldLoc [join $LesNoms " "] = [join $LesRaisons "+"]" set LesNoms {} set LesRaisons {} } lappend LesNoms $Nom lappend LesRaisons $Raison set OldLoc "$D $F" } return [SauveLesLignes $Localisations dans $FichierFrameshifts] } proc LocaliseLesTfasDuSeqCheck {{Qui ""}} { global LocaliseLesTfasDuSeqCheck if {[info exists LocaliseLesTfasDuSeqCheck($Qui)]} { return $LocaliseLesTfasDuSeqCheck($Qui) } if {[info exists LocaliseLesTfasDuSeqCheck("EstCharge")]} { return "" } set LocaliseLesTfasDuSeqCheck("EstCharge") 1 set RepPossibles "[RepertoireDuGenome]/atelier/*" set LesFichiers [glob -nocomplain "$RepPossibles/*.tfa"] foreach Fichier $LesFichiers { lappend LocaliseLesTfasDuSeqCheck(ListOfFilepathes) $Fichier set Queue [file tail $Fichier] lappend LocaliseLesTfasDuSeqCheck($Queue) $Fichier lappend LocaliseLesTfasDuSeqCheck(ListOfFilenames) $Queue regsub -nocase ".tfa$" $Queue "" Name lappend LocaliseLesTfasDuSeqCheck($Name) $Fichier lappend LocaliseLesTfasDuSeqCheck(ListOfNames) $Name } return [LocaliseLesTfasDuSeqCheck $Qui] } proc LocaliseOuPas {FichierDesPABs FichierSortie} { #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] set Liste ""; set Un 0; set Zero 0 foreach Nom $L { #Espionne $Nom if {![info exists Vu($Nom)]} {set Vu($Nom) 1} else {Espionne $Nom} set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] set Loc 0; set SourceLoc ""; set SourceLoca "" if {$LesLocs!="" && [regexp "HS" $LesLocs]} { set Loc 1 foreach Loca $LesLocs { if {[regexp -nocase "best" [lindex $Loca 20]]} { set SourceLoca [lindex $Loca 21] break } } set SourceLoc $SourceLoca } else { set FichierLoc "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" set LesLocs [InterrogeLocalisation $FichierLoc Nom $Nom] if {$LesLocs!=""} { set Loc 1 set SourceLoc "DD_sequence" } } if {$Loc==1} {incr Un} ; if {$Loc==0} {incr Zero} if {$Loc==1} {lappend Liste "$Nom\t$Loc\t$FichierLoc\t$SourceLoc"} if {$Loc==0} {lappend Liste "$Nom\t$Loc"} } Espionne [llength $Liste] set LTriee [lsort -unique $Liste] #set LTriee [lsort -index 0 $Liste] Espionne [llength $LTriee] Espionne "Nb1: $Un -Nb0: $Zero" SauveLesLignes $LTriee dans $FichierSortie } proc LocalisePsiBlastPDataBase {{Banque ""}} { return [LocaliseBlastPDataBase $Banque] } proc LocaliseSurADN {{Sequence ""} {Quoi ""}} { while {$Sequence==""} { FaireLire "Please enter the dna sequence to search" set Sequence [Entre] if {$Sequence=="" && [OuiOuNon "Do I cancel ?"]} { return "" } } if {$Quoi==""} { set Quoi "FR" } set OLS [expr [string length $Sequence] -1] global ADN TDN RAC if { ! [info exists ADN]} { ChargeADNetTDNetRAC } set I 0 set LesHitsF {} while {[set Indices [string first $Sequence $ADN $I]]>-1} { append Indices " [expr $Indices+$OLS]" scan $Indices "%d %d" D F set I [expr $D+1] lappend LesHitsF "$Indices F" if {$Quoi=="First" || $Quoi=="FFirst"} { break } } if {$Quoi=="F" || $Quoi=="First" || $Quoi=="FFirst"} { return $LesHitsF } set L [string length $RAC] set I 0 set Reverse [NucToReverseAndComplementNuc $Sequence] set LesHitsR {} while {[set Indices [string first $Sequence $RAC $I]]>-1} { append Indices " [expr $Indices+$OLS]" scan $Indices "%d %d" D F set I $F lappend LesHitsR "[expr $L-$F+1] [expr $L-$D+1] R" if {$Quoi=="First" || $Quoi=="RFirst"} { break } } if {$Quoi=="R" || $Quoi=="First" || $Quoi=="RFirst"} { return $LesHitsR } return [concat $LesHitsF $LesHitsR] } proc LocaliseTBlastNDataBase {{NomDeLaBanque ""}} { return [LocaliseBlastNDataBase $NomDeLaBanque "T"] } proc LockMode {l} { global ModeLocke if {! [info exists ModeLocke]} {set ModeLocke 0} set res $ModeLocke set ModeLocke $l return $res } proc LockSequencesOut {} { global SDG SeqsOut if {! [info exists SDG(GrSeqOut)]} {return} foreach s [set SDG(GrSeqOut)] { set SeqsOut($s) 1 } return } proc LoctypeDansRapport {Rapport} { foreach Ligne [LesLignesDuFichier $Rapport] { scan $Ligne "%s %s" type def if {$type=="LocType:"} {return $def} } } proc Locus {Texte FichierTFA} { set Seq "x[QueLaSequenceDuTFA $FichierTFA]" set iStart 1 while {[regexp -indices -start $iStart -nocase -- $Texte $Seq LesIndices]} { Espionne $LesIndices set iStart [lindex $LesIndices 1] } exit } proc Log {{Texte ""} {FichierLog ""} {DoNotMemo ""}} { global FichierLogMemo if {$FichierLog==""} { if {[info exists FichierLogMemo]} { set FichierLog $FichierLogMemo } else { set FichierLog "gscope.log" } } if { ! [regexp {^/} $FichierLog]} { if {[info proc LogDir]==""} { #rR pour pouvoir être indépendatn de gscope_topographe.tcl set FichierLog "~/$FichierLog" } else { set FichierLog "[LogDir]/$FichierLog" } } if { ! [string equal -nocase $DoNotMemo "DoNotMemo"]} { set FichierLogMemo $FichierLog } return [AppendAuFichier $FichierLog $Texte] } proc LogChangesDuringInfoUpdate {aT} { array set Chg $aT if {[llength [array names Chg]] == 0} { return } # ckeck changes for all sequences foreach n $::LNOrdali { if {$n eq ""} {continue} foreach k [lsort [array names Chg "$n,*"]] { lassign [set Chg($k)] old new puts "$k | $old ==> $new " } puts "" } return } proc LogClustering {} { global SDG LNDG AuLog @begin blob AuLog @title New Clustering AuLog @text Alignment : [MacCourant name] set GrMeth [ClusteringDuMac method] AuLog @text Grouping method .........: $GrMeth AuLog @text Number of groups ........: [expr {[llength $LNDG] -1}] foreach g [lrange $LNDG 1 end] { AuLog @text $g : [llength [set SDG($g)]] sequences AuLog @text {*}[set SDG($g)] } AuLog @end return } proc LogDir {} { return "[HomeRipp]/log" } proc LogExpe {Texte} { set FiLogExpe "[HomeRipp]/loghtml/logexpe.log" AppendAuFichier $FiLogExpe $Texte } proc LogInfosClusters {} { global LNDG SDG # log clustering if {[llength $LNDG] > 1} { AuLog @begin blob AuLog @title Alignment Clusterng AuLog @begin teletype foreach g $LNDG { if {$g eq "GroupeToutLeMonde" || $g eq "all" || $g eq "All"} {continue} AuLog @tele $g : [llength [set SDG($g)]] sequences AuLog @tele {*}[set SDG($g)] AuLog "" } AuLog @end AuLog @end } return } proc LogInfosSoTOL {} { global Tx TaxRoot LCompleteId LSelectableId LUserId set Log [list] # input parameters lappend Log "

SoTOL input parameters :

" lappend Log "" lappend Log "" lappend Log "" if {$Tx(-addmodel)} { lappend Log "" } elseif {$Tx(-modelsin)} { lappend Log "" } else { lappend Log "" } if {$Tx(-useorgs) eq "all"} { lappend Log "" } else { lappend Log "" } if {[llength $LUserId]} { lappend Log "" } lappend Log "

Number of taxa IDs	:	$Tx(-ntaxa)
Tree root	:	$TaxRoot $Tx(Name,$TaxRoot)
Model organisms	:	Add after selection
Model organisms	:	Include into selection
Model organisms	:	Treated as normal organisms
Organisms to use	:	ALL complete genomes
Organisms to use	:	'representative' organism per Species
Number of user taxa IDs	:	[llength $LUserId]

" # database infos lappend Log "

SoTOL database information :

" lappend Log "" lappend Log "" lappend Log "" lappend Log "

Total number of complete genomes	:	[llength $LCompleteId]
Number of selectable taxa	:	[llength $LSelectableId]

" return [join $Log \n] } proc LogInsUpDelPourExec {Query {Fichier ""}} { global FichierInsUpDelPourExec global LogInsUpDelPourExec set LogInsUpDelPourExec 0 if { ! [info exists LogInsUpDelPourExec] || ! $LogInsUpDelPourExec} { return "" } if {$Query=="CloseFile"} { if {[info exists $FichierInsUpDelPourExec]} { set F $FichierInsUpDelPourExec unset FichierInsUpDelPourExec return $F } return "" } if {$Query=="InFile"} { if {$Fichier==""} { set FichierInsUpDelPourExec "[LogSqlReceptacleDir]/InsUpDelPourExec_[pid]_[Date].sql" } else { set FichierInsUpDelPourExec $Fichier } return $FichierInsUpDelPourExec } if { ! [info exists FichierInsUpDelPourExec]} { set FichierInsUpDelPourExec "[LogSqlReceptacleDir]/InsUpDelPourExec_[pid]_[Date].sql" } if {$Query=="DeleteFile"} { if { ! [info exists FichierInsUpDelPourExec]} { return "" } if {[file exists $FichierInsUpDelPourExec]} { file delete $FichierInsUpDelPourExec } set F $FichierInsUpDelPourExec unset FichierInsUpDelPourExec return $F } if {0 && [regexp -nocase "^ *select" $Query]} { return "" } return [AppendAuFichier $FichierInsUpDelPourExec "$Query ;"] } proc LogL {{Liste ""} {FichierLog ""}} { return [Log [join $Liste "\n"] $FichierLog] } proc LogLesCompositions {} { global LNOrdali LSOrdali TDesCompos AuLog @begin table AuLog @title AminoAcid Composition : set Ln [PlusLongEltDe $LNOrdali] AuLog @begin tabular AuLog @titlecols Protein A C D E F G H I K L M N P Q R S T V W Y AuLog @typecols T R R R R R R R R R R R R R R R R R R R R foreach s $LNOrdali { if {[string trim $s] eq ""} {continue} set ligne "$s" foreach v [set TDesCompos($s,aa)] { #append ligne " [format "%5.2f" $v]" lappend ligne [format %5.2f $v] } AuLog @row {*}$ligne } AuLog @end AuLog @title Physico-chemical Composition : AuLog @begin tabular AuLog @titlecols Protein AILMV PGST FYW KRH DEQN AuLog @typecols T R R R R R foreach s $LNOrdali { if {[string trim $s] eq ""} {continue} set ligne $s foreach v [set TDesCompos($s,pc)] { #append ligne " [format "%5.2f" $v]" lappend ligne [format %5.2f $v] } AuLog @row {*}$ligne } AuLog @end AuLog @end return } proc LogPCI {{what ""}} { global LTPCI ListePDB LNDG SDG if {$what eq "global"} { set LdesG "GroupeToutLeMonde" } else { set LdesG [lrange $LNDG 1 end] } set t [list] foreach {k v} $LTPCI { lappend t $k } set lg [PlusLongEltDe $t] incr lg array set tmp $LTPCI AuLog @begin blob AuLog @title Summary of Pairwise Sequences Identites set txt [list] foreach g $LdesG { set Ln [set SDG($g)] if {$g eq "GroupeToutLeMonde"} { AuLog @subtitle All sequences } else { AuLog @subtitle $g } AuLog @begin teletype # Moyenne generale, std dev. # min et max set min 999. ; set max -999. set pmn "" ; set pmx "" set m 0.0 ; set m2 0.0 set i 1 ; set npairs 0 foreach n1 [lrange $Ln 0 end-1] { foreach n2 [lrange $Ln $i end] { lassign [set tmp($n1,$n2)] pc l1 l2 l1sl2 set pc [expr {100.*$pc}] lappend txt [format %${lg}s " $n1-$n2"] [format %6.1f $pc] set m [expr {$m + $pc}] set m2 [expr {$m2 + $pc*$pc}] incr npairs if {$pc > $max} { set max $pc set pmx "[format %${lg}s $n1-$n2] [format %6.1f $max]" } if {$pc < $min} { set min $pc set pmn "[format %${lg}s $n1-$n2] [format %6.1f $min]" } } incr i } if {$npairs != 0} { set m [expr {$m/$npairs}] set s [expr {sqrt($m2/$npairs - $m*$m)}] } else { set m 0.0 set s 0.0 } AuLog @tele Mean Identity ............: [format %6.1f $m] AuLog @tele Standard deviation .......: [format %6.1f $s] AuLog @tele minimum pair identity ....: $pmn AuLog @tele maximum pair identity ....: $pmx AuLog @tele "" for {set i 0} {$i < [llength $txt]} {incr i 10} { AuLog @tele {*}[lrange $txt $i $i+9] } AuLog @end } AuLog @end return } proc LogSeqInfoGlobales {} { global LNOrdali LSOrdali LongueurTotale NombreDeSequences ListePDB ListeDesFragments AlnScore TDesAccess TDespI TDesMolW AuLog @begin blob AuLog @title General Information : AuLog @begin teletype if {! [info exists AlnScore]} { set AlnScore 0.0 } AuLog @tele Alignment score .........: $AlnScore AuLog @tele Alignment length ........: $LongueurTotale AuLog @tele Number of sequences .....: $NombreDeSequences AuLog @tele Number of PDB sequences .: [llength $ListePDB] AuLog @tele Number of fragments .....: [llength $ListeDesFragments] AuLog @end AuLog @end set pl [PlusLongEltDe $LNOrdali] AuLog @begin table AuLog @title Global information on proteins set lmin 9999999. ; set lmax -99999. foreach n $LNOrdali s $LSOrdali { if {[string trim $n] eq ""} {continue} set s [string map [list "." "" "Z" ""] $s] set l [string length $s] if {$l > $lmax} { set lmax $l set nmax $n set amax [set TDesAccess($n)] } if {$l < $lmin} { set lmin $l set nmin $n set amin [set TDesAccess($n)] } } AuLog @subtitle Length min : $lmin $nmin $amin AuLog @subtitle Lenght max : $lmax $nmax $amax AuLog @begin tabular AuLog @titlecols {Seq. Name} Accession Length MOlW pI AuLog @typecols T T I R R set fmt "|%${pl}s|%${pl}s|%6d|%10.2f|%6.3f|" foreach n $LNOrdali s $LSOrdali { if {[string trim $n] eq ""} {continue} set ac [set TDesAccess($n)] set s [string map [list "." "" "Z" ""] $s] set l [string length $s] AuLog @row $n $ac $l [format %.3f [set TDesMolW($n)]] [format %6.3f [set TDespI($n)]] } AuLog @end if {[llength $ListeDesFragments]} { AuLog @begin blob AuLog @title List of Fragments : AuLog @list $ListeDesFragments AuLog @end } AuLog @end return } proc LogSeqlab {clu seq aas} { if {! $clu && ! $seq && ! $aas} { return } AuLog @begin blob AuLog @title Editor Log if {$clu} { AuLog @text clustering has changed } if {$seq} { AuLog @text insertions/deletions have been edited } if {$aas} { AuLog @text aa sequences have been changed } AuLog @end return } proc LogSqlReceptacleDir {} { return "/usr/local/apache/logs/LogSqlReceptacle" } proc LogSup {chan} { global Log if {[gets $chan line] >= 0} { lappend Log $line } return } proc LogWget {} { #garde que les lignes interressantes du fichier .log #AVANT set Fichier "/titan/data/string/9.05/mirroritems.log" set Fichier "/tempor/string/mirrorevidence.log" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^ *0K} $Ligne]} {Espionne "$Ligne"; continue} if {[regexp {^ *[0-9]+K} $Ligne]} {continue} Espionne "$Ligne" } } proc LogWscope {Texte} { return [Log $Texte "gscopehtmlserver.log" "DoNotMemo"] } proc LogWscopeL {Liste} { return [LogWscope [join $Liste "\n"]] } proc Logg {args} { return #rR ne pas utiliser car les droits sont pas bons !!!!!!!!!!!!!!!!!!!!!!!!! set l [open "/home/ripp/log/logg.log" "a"] puts $l [join $args " "] close $l return $args } proc Login {} { global env set Login $env(LOGNAME) return $Login } proc LoginConnexion {login password} { set fileUsers "/groupes/poch/ripp/wwwLinux/puzz/password" #set fileProjectD "/groupes/poch/ripp/wwwLinux/puzz/DroitProjetUsers" foreach Ligne [LesLignesDuFichier $fileUsers] { set LP [split $Ligne ":"] set LoginPass([lindex $LP 0]) [lindex $LP 1] } if {[info exists LoginPass($login)]} { if {$LoginPass($login)==$password} { Espionne "OK" return 0 } else { Espionne "password pas bon" return 1 } } else { Espionne "login pas bon" } } proc LoginServer {imapID username password} { # Beware ! ::imap4::login return 0 if successfull !! if {[::imap4::login $imapID $username $password]} { puts "Beware !\nI can't connect to the server using the following username and password :\n$username\n$password" FaireLire return 0 } else { return 1 } } proc LogoCADO4MI {} { Wup "Un petit logo pour faire joli ..." global LogoAffiche if {[info exists LogoAffiche] && $LogoAffiche=="1"} {return ""} #AjouteAuLog "\n" #AjouteAuLog "\t __ _ _____ " #AjouteAuLog "\t ____ / /(_)/ ___/____ " #AjouteAuLog "\t / __ \\/ // // / __/ __ \\ " #AjouteAuLog "\t / /_/ / // // /_/ / /_/ / " #AjouteAuLog "\t \\____/_//_/ \\____/\\____/ " #AjouteAuLog "\t ___________________ " #AjouteAuLog "\t _____ ___ __ ___/_______ _(_)____/ ____ " #AjouteAuLog "\t / __// _ \\/ / / _ \\/ ___// // // __ \\/ __ \\ " #AjouteAuLog "\t (__ )/ __/ /__/ __/ /__ / // // /_/ / / / / " #AjouteAuLog "\t /____/ \\___/____/\\___/\\___//__//_/ \\____/_/ /_/ " #AjouteAuLog "\t _____ ____ " #AjouteAuLog "\t /__ / / _ \\ " #AjouteAuLog "\t / / / / / / " #AjouteAuLog "\t __/ /_ / /_/ / " #AjouteAuLog "\t /____(_)\\____/ " #AjouteAuLog "\t " #AjouteAuLog "\n" AjouteAuLog "\n" AjouteAuLog "\t ___ ___ ____ ___ " AjouteAuLog "\t / __| / \\ | _\\ / _\\ " AjouteAuLog "\t | / | ^ || |\\ | /\\ | " AjouteAuLog "\t |\\__ | _ || |_/ | \_/ | " AjouteAuLog "\t \\___||_| |_||____/\\___/ " AjouteAuLog "\t _ " AjouteAuLog "\t | | _ " AjouteAuLog "\t | |_| |_ " AjouteAuLog "\t |___ _| " AjouteAuLog "\t | | " AjouteAuLog "\t |_| _ " AjouteAuLog "\t _ _ |_| " AjouteAuLog "\t |\\ / | _ " AjouteAuLog "\t | \\_/ | | | " AjouteAuLog "\t | ___ | | | " AjouteAuLog "\t | | | | | | " AjouteAuLog "\t |_| |_| |_/ " AjouteAuLog "\t " AjouteAuLog "\t " AjouteAuLog "\t _____ ____ " AjouteAuLog "\t /__ / / _ \\ " AjouteAuLog "\t / / / / / / " AjouteAuLog "\t __/ /_ / /_/ / " AjouteAuLog "\t /____(_)\\____/ " AjouteAuLog "\t " AjouteAuLog "\n" Espionne "\n" Espionne "\t ___ ___ ____ ___ " Espionne "\t / __| / \\ | _\\ / _\\ " Espionne "\t | / | ^ || |\\ | /\\ | " Espionne "\t |\\__ | _ || |_/ | \_/ | " Espionne "\t \\___||_| |_||____/\\___/ " Espionne "\t _ " Espionne "\t | | _ " Espionne "\t | |_| |_ " Espionne "\t |___ _| " Espionne "\t | | " Espionne "\t |_| _ " Espionne "\t _ _ |_| " Espionne "\t | \\ / | _ " Espionne "\t | \\_/ | | | " Espionne "\t | \\_/| | | | " Espionne "\t | | | | | | " Espionne "\t |_| |_| |_/ " Espionne "\t " Espionne "\t " Espionne "\t _____ ____ " Espionne "\t /__ / / _ \\ " Espionne "\t / / / / / / " Espionne "\t __/ /_ / /_/ / " Espionne "\t /____(_)\\____/ " Espionne "\t " Espionne "\n" set LogoAffiche 1 return "" } proc LoinToujours {PN {Action ""}} { Wup "On peut vouloir prendre toutes les sequences lointaines" Wup "LoinToujours 0.001 Set en fixe le seuil" Wup "LoinToujours bidon NotUsed on repondra systematique non" Wup "LoinToujours bidon Reset on annule tout pour le prochain usage" Wup "LoinTours PN repond PN>SeuilExpect" if {[OnTraiteMS2PH]} { return 0 } global LoinToujours if {$PN=="Reset" || $PN=="NotUsed"} { set Action $PN } if {$Action=="Reset"} { if {[info exists LoinToujours]} { unset LoinToujours } return 0 } if {$Action=="NotUsed"} { set LoinToujours(UseIt) 0 return 0 } if {$Action=="Set"} { if {[info exists LoinToujours]} { unset LoinToujours } set LoinToujours(UseIt) 1 set LoinToujours(SeuilExpect) $PN return 1 } if { ! [info exists LoinToujours(SeuilExpect)]} { set LoinToujours(SeuilExpect) 0.001 } if { ! [info exists LoinToujours(UseIt)]} { set LoinToujours(UseIt) [OuiOuNon "Do I take all sequences, even with expect > $LoinToujours(SeuilExpect)" 0] } if {$LoinToujours(UseIt)} { return [expr $PN>$LoinToujours(SeuilExpect)] } return 0 } proc LoinToujoursTest {} { puts [LoinToujours 0.1] puts [LoinToujours 0.0001] puts [LoinToujours 0.01 Set] puts [LoinToujours 0.1] puts [LoinToujours 0.00001] puts [LoinToujours Reset] puts [LoinToujours 0.1] puts [LoinToujours NotUsed] puts [LoinToujours 0.0001] puts [LoinToujours 0.01 Set] puts [LoinToujours 0.1] puts [LoinToujours 0.00001] puts [LoinToujours Reset] puts [LoinToujours 0.1] puts [LoinToujours 0.00001] } proc Long {A B I J} { if {$I==0 ||$J==0} { return 0 } set X [string index $A $I] set Y [string index $B $J] if {$X==$Y} { set R 1 } else { set R 0 } set M [Maxi [expr [Long $A $B [expr $I-1] [expr $J-1]]+$R] [Maxi [Long $A $B [expr $I-1] $J] [Long $A $B $I [expr $J-1]]] ] return $M } proc LongInfoSeq {n} { global Sequences TDesOrganismes TDesDescriptifs TDesBId set Org "Unknown" set Des "None" set Bid [set TDesBId($n)] if {[info exists TDesOrganismes($n)]} { set Org [set TDesOrganismes($n)] } if {[info exists TDesDescriptifs($n)]} { set Des [set TDesDescriptifs($n)] } set Len [set Sequences($n)] regsub -all {\.} $Len "" Len set Len [string length $Len] set D 0 set nl -1 while {$D < [string length $Des]} { incr nl set F [expr {$D+29}] set ib [string wordstart [string range $Des $D $F] $F] if {$ib <= 0} { set Ic 30 } else { set Ic $ib set F [expr {$D+$ib-1}] } set L [string range $Des $D $F] incr D $Ic set TDes($nl) $L } set rep "Acc ...: $n\n" append rep "BId ...: $Bid\n" append rep "Org ...: $Org\n" foreach l [lsort -integer [array names TDes]] { if {$l == 0} { set pref "Des ...:" } else { set pref " :" } append rep "$pref [set TDes($l)]\n" } append rep "Len ...: $Len\n" return $rep } proc LongueurADN {{Orga ""}} { Wup "Returns the length in bases of orga's genome" global LongueurADNDesOrganismes global ADN TDN RAC if {$Orga==""} { if {[info exists LongueurADNDesOrganismes("NotreOS")]} { return [set LongueurADNDesOrganismes("NotreOS")] } if { ! [info exists ADN]} { ChargeADNetTDNetRAC } set LongueurADNDesOrganismes("NotreOS") [expr [string length $ADN]-1] return [set LongueurADNDesOrganismes("NotreOS")] } if {[info exists LongueurADNDesOrganismes($Orga)]} { return [set LongueurADNDesOrganismes($Orga)] } if {[info exists LongueurADNDesOrganismes("SontCharges")]} { return -1 } ChargeLesPositionsDesOrthologues return [LongueurADN $Orga] } proc LongueurAlignement {{quoi ""}} { if {$quoi eq "seqlab"} { set l [string length [$::NomTextSeq output 0]] } else { set Lseq [split [$::NomTextSeq get 1.0 end] \n] set lmax 1 foreach s $Lseq { set l [string length $s] if {$l > $lmax} {break} } } return $l } proc LongueurDeLAlignement {{quoi ""}} { global Sequences LongueurTotale if {$quoi eq "seqlab"} { set lg [string length [$::NomTextSeq output 0]] } else { set Ll [list] foreach n [array names Sequences] { lappend Ll [string length [set Sequences($n)]] } set Ll [lsort -unique -integer $Ll] if {[lindex $Ll 0] == 0} {set Ll [lreplace $Ll 0 0]} if {[llength $Ll] == 1} { set lg [lindex $Ll 0] } else { set lg [DonneMemeLongueur Sequences] } } set LongueurTotale $lg return $lg } proc LongueurDeLaSequence {Nom {Rep ""}} { if {$Rep==""} { set Rep "nuctfa" } set Fic "[RepertoireDuGenome]/$Rep/$Nom" if {[FileAbsent $Fic]} {return -1} set Seq [QueLaSequenceDuFichierTFA $Fic] set L [string length $Seq] return $L } proc LongueurDeMaSequenceDuTfasdescopains {File sequence} { set testProt "Q9XUL9" set maseq "no" #tfasdescopains set mes_lignes [LesLignesDuFichier [RepertoireDuGenome]/NewTfasDesCopains/$File] foreach ligne $mes_lignes { if {[regexp {^>} $ligne]} { set name [lindex [split $ligne " "] 1] if {$sequence==$name} {set maseq "OK"} } else { if {$maseq=="OK"} { #Espionne "taille de $maseq: [string length $ligne]" return [string length $ligne] #set longueur [string length $ligne] #break } } } } proc LongueurDesSeq {Box} { set i -1 set Cluster [ExtraitInfo $Box "Cluster"] set FileTfa "[RepertoireDuGenome]/FichiersInitial/SOURIS_Tfactor/$Cluster.fa" if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/SOURIS_others/$Cluster.fa"} if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/RAT_Tfactor/$Cluster.fa"} if {![file exists $FileTfa]} {set FileTfa "[RepertoireDuGenome]/FichiersInitial/RAT_others/$Cluster.fa"} if {![file exists $FileTfa]} {Espionne "$Box warning"} set LesSeq [QueLaSequenceDuFichierTFA $FileTfa ListOfTxt] foreach Ligne [LesLignesDuFichier $FileTfa] { if {[regexp "^\>" $Ligne]} { incr i scan $Ligne "%s" name regsub "\>" $name "" name set Seq [lindex $LesSeq $i] set nb [CompteLesLettres Seq $Seq] lappend LesLignes "$name $nb" } } return $LesLignes } proc LongueurMac {{m 0}} { if {! $m} {set m [MacCourant]} return [$::db eval {select max(length(sa.seq)) from seqali as sa, ln_mac_seqali as lms where lms.pk_mac=$m and lms.pk_seqali=sa.pk_seqali}] } proc LongueurMoyDescDNAsDD {} { set S 0; set n 0; set Lmini 10000; set Lmaxi 0 foreach DD [ListeDesPABs] { set FichierTFA "[RepertoireDuGenome]/nuctfa/$DD" set SeqTFA [QueLaSequenceDuFichierTFA $FichierTFA] set L [string length $SeqTFA] incr n set S [expr $L+ $S] if {$L<$Lmini} {set Lmini $L} if {$L>$Lmaxi} {set Lmaxi $L} } Espionne "lmin: $Lmini - lmax: $Lmaxi" return "longueur moy: [expr $S/$n]" } proc LongueurMoyenne {} { Wup "Average length of the orfs." global ListeDeBoites if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites } set Mi 9999999 set Ma -999999 set CumulLong 0 set n 0 foreach Boite $ListeDeBoites { set Nom [Box $Boite nom] if { ! [EstUnPAB $Nom] } { continue } set Debut [Box $Boite debut] set Fin [Box $Boite fin] set Orient [Box $Boite orient] set Long [expr $Fin-$Debut+1] set Mi [Mini $Long $Mi] set Ma [Maxi $Long $Ma] incr CumulLong $Long incr n } set PourcentageCodant [format "%5.2f" [expr 100.*$CumulLong/[LongueurADN]]] puts "$n ORFs mini [expr $Mi/3] maxi [expr $Ma/3] moyenne [expr $CumulLong/(3*$n)] $PourcentageCodant" } proc LongueurPourTous {Rep} { if {![file exists "[RepertoireDuGenome]/$Rep"]} {return} foreach Fichier [glob "[RepertoireDuGenome]/$Rep/*"] { set Nom [file tail $Fichier] set L [string length [QueLaSequenceDuTFA $Fichier]] append Longueurs "$Nom\t$L\n" } return $Longueurs } proc LongueurSeqTfa {FichierTfa} { return [string length [QueLaSequenceDuTFA $FichierTfa]] } proc LookupCouleursVMD {} { global Couleurs global Lookup_Couleurs global Lookup_ColVMD global CanalV global Defauts set Lc "[CouleurOrdali2O [set Defauts(CoulVariable)]]" foreach c [array names Couleurs] { if {$c eq "Stock"} {continue} if {[regexp {^CoulG} $c]} {continue} set le [set Couleurs($c)] foreach e $le { set e [CouleurOrdali2O $e] lappend Lc "$e" } } set le [split [set Couleurs(Stock)]] foreach e $le { lappend Lc "$e" } set Lc [lunique $Lc] set i 0 if {[llength $Lc] > 32} {set fin 32} {set fin end} foreach c [lrange $Lc 0 $fin] { lassign [set Lookup_Couleurs($c)] r g b set r [expr {$r/255.}] set g [expr {$g/255.}] set b [expr {$b/255.}] VMDsend "NouvelleCouleur $i $c $r $g $b" set Lookup_ColVMD($c) $i set Lookup_ColVMD($i) $c incr i } VMDsend "color Display Background [set Lookup_ColVMD(black)]" return } proc LookupCouleursVMDbon {} { global Couleurs global Lookup_Couleurs global Lookup_ColVMD global CanalV set i 100 foreach c [array names Lookup_Couleurs] { puts "$c" lassign [set Lookup_Couleurs($c)] r g b set r [expr {$r/255.}] set g [expr {$g/255.}] set b [expr {$b/255.}] VMDsend "NouvelleCouleur $i $c $r $g $b" set Lookup_ColVMD($c) $i set Lookup_ColVMD($i) $c incr i } return } proc Looping {n} { global iter set nf [Next $n] if {$iter < 1000} { Looping $nf } exit } proc Lower {K tagorid} { Wup "Met en arriere plan le widget marque par tagorid" $K lower $tagorid return "" } proc LowerLesAverageDeLOligo {K} { Wup "Met en arriere plan les averages des graphes" set LesGraphes [LesGraphesDeLOligo $K] foreach Graph $LesGraphes { Lower $K "Average${Graph}" } return "" } proc LucIMAPToTcl {items} { set quote 0 set str "" foreach c [split $items ""] { if {$c eq "\""} { if {$quote} { set quote 0 } else { set quote 1 } append str $c continue } if {$quote} { append str $c } else { set x $c switch -- $c { "\{" {set x "\\\{"} "\}" {set x "\\\}"} {(} {set x "\{"} {)} {set x "\}"} } append str $x } } set str [string map {"\[" "\\\[" "\]" "\\\]"} $str] return $str } proc Luc_bgerror {err} { global errorInfo set old_errorInfo $errorInfo #package require smtp #package require mime if {[info exists ::env(USER)]} { set user $::env(USER) } else { set user "unknown" } set msg "[DonneDateEtHeure] File : $::Defauts(Fichier[TypeAli]) $::errorInfo " catch {send_simple_message luc.moulinier@unistra.fr localhost "\[Bug-Ordalie\] $user: $err" $msg} set errorInfo $old_errorInfo Old_bgerror $err return } proc MAFFT {FichierTFAs {FichierMAFFT ""}} { if {$FichierMAFFT==""} { regsub {\.tfa(|s)$} $FichierTFAs "" FichierMAFFT append FichierMAFFT ".mafft" } set VraiFichierTFAs $FichierTFAs if { ! [regexp "^/" $FichierTFAs]} { set VraiFichierTFAs "[pwd]/$FichierTFAs" } set VraiFichierMAFFT $FichierMAFFT if { ! [regexp "^/" $FichierMAFFT]} { set VraiFichierMAFFT "[pwd]/$FichierMAFFT" } NousAllonsAuBoulot set RepDessus [pwd] set RepMAFFT "[TmpFile MAFFT .]" file mkdir $RepMAFFT cd $RepMAFFT set Racine [file tail $VraiFichierTFAs] file copy $VraiFichierTFAs $Racine.in set OK 1 while 1 { if {[catch { exec /biolo/mafft/bin/sextet5 < $Racine.in >& /dev/null } Message]} { FaireLire "MAFFT failed running 'sextet5' with message \n$Message" set OK 0 break } if {[catch { exec /biolo/mafft/bin/tbfast -FAx < $Racine.in >& /dev/null } Message]} { FaireLire "MAFFT failed running 'tbfast -FAx ...' with message \n$Message" set OK 0 break } if {[catch { exec /biolo/mafft/bin/tbfast -JFAx < pre > $Racine.out 2> $Racine.log } Message]} { FaireLire "MAFFT failed running 'tbfast -JFAx ...' with message \n$Message" set OK 0 break } break } if { $OK } { if {[file exists $Racine.out]} { file rename -force $Racine.out $VraiFichierMAFFT } cd $RepDessus foreach F [glob -nocomplain $RepMAFFT/*] { file delete -force $F } file delete $RepMAFFT } OnRevientDuBoulot if { ! $OK } { return "" } return [ConvertToMsf $FichierMAFFT $FichierMAFFT] } proc MAFFTLaetiStar {FichierTfa} { # ATTENTION : Avant faire "setenv MAFFT_BINARIES /home/perrodou/mafft_star/binaries/" set FichierMAFFT "/genomics/link/EVImm/prpf31/riken/prpMafft" set FichierMsf "/genomics/link/EVImm/prpf31/riken/prpMsf" set Commande "/home/perrodou/mafft_star/scripts/mafft" catch {eval exec $Commande $FichierTfa > $FichierMAFFT} CreeLeMSFduTFAs $FichierMAFFT $FichierMsf } proc MAFFTManuStar {Nom RepertoireDesTFAs RepertoireDeSortie} { # ATTENTION : Avant faire "setenv MAFFT_BINARIES /home/perrodou/mafft_star/binaries/" if {$RepertoireDeSortie == ""} { set RepertoireDeSortie "[RepertoireDuGenome]/msfmafft" } set FichierEntree "[RepertoireDuGenome]/$RepertoireDesTFAs/$Nom" set RepertoireSortie "[RepertoireDuGenome]/$RepertoireDeSortie" set FichierSortie "[RepertoireDuGenome]/$RepertoireDeSortie/$Nom.mafft" if {! [file exists $FichierSortie]} {file mkdir $RepertoireSortie} Espionne "$FichierEntree $FichierSortie" set Commande "/home/perrodou/mafft_star/scripts/mafft --maxiterate 3" catch {eval exec $Commande $FichierEntree > $FichierSortie} set FichierSortieMsf "[RepertoireDuGenome]/$RepertoireDeSortie/$Nom" set FichierMAFFT "[RepertoireDuGenome]/$RepertoireDeSortie/$Nom.mafft" CreeLeMSFduTFAs $FichierMAFFT $FichierSortieMsf file delete -force $FichierMAFFT } proc MAFFTPourTous {{RepTFAs ""} {RepMAFFT ""} {Keep ""}} { if {$Keep=="OverWrite"} { set Keep 0 } if {$Keep=="Keep"} { set Keep 1 } if {$Keep==""} { set Keep [OuiOuNon "Do I keep existing files ?"] } if {$RepTFAs==""} { set RepTFAs "[RepertoireDuGenome]/tfaspourmafft" } if {$RepMAFFT==""} { set RepMAFFT "[RepertoireDuGenome]/mafft" } if { ! [file exists $RepMAFFT]} { file mkdir $RepMAFFT } foreach Nom [ListeDesPABs] { set FichierTFAs "$RepTFAs/$Nom" if { ! [file exists $FichierTFAs]} { continue } set FichierMAFFT "$RepMAFFT/$Nom" if {$Keep && [file exists $FichierMAFFT]} { continue } set Retour [MAFFT $FichierTFAs $FichierMAFFT] Espionne "I run MAFFT on $Nom and got >$Retour<" } } proc MAJProtMS2PH {} { # Procedure de mise a jour des proteines de MS2PH-db # Utilisation GeneCards (GC), Human Gene Mutation Database (HGMD) et Human Genome Database (GDB) # on croise d abord GC et HGMD # les donnees sont completees en croisant GDB et HGMD # les anciennes donnees sont deplacees dans un repertoire contenant la date # De sorte que le repertoire AJour contient toujours les dernieres donnees # MS2PH.tfa contient ces sequences dans l'ordre, au format fasta global RepAJour set chemin "/home/friedric/MS2PH/MS2PH-db/ListeProt/" set date [eval exec date -u +%d%m%y] set RepOld [file join $chemin "Old$date"] set RepAJour [file join $chemin "AJour"] set ficTFA [file join $RepAJour "MS2PH.tfa"] catch {eval exec mkdir $RepOld} catch {eval exec cp $ficTFA $RepOld} # lancement des MAJ des listes issues de GC et GDB de maniere independante # MAJ des donnes issues de GC set listeGC [MAJProtMS2PHGC] # MAJ des donnees issues de GDB set listeGDB [MAJProtMS2PHGDB] # creation de la liste qui va contenir toutes ces donnees (concatenation des 2 listes) set listeGlobale [concat $listeGC $listeGDB] puts "lg listeGlobale [llength $listeGlobale]" # on recupere la liste des access deja presents dans MS2PH-db set lAccess "" # on cree la liste des access et synonymes deja presents dans MS2PH-db set listAccessSyn "" set LesLignes [LesLignesDuFichier $ficTFA] if {$LesLignes != ""} { foreach l $LesLignes { if {[string first ">" $l] == 0} { lappend lAccess [string range $l 1 6] } } puts "long liste Acc : [llength $lAccess]" # on recupere tous les Access synonyme par BIRD # requete simple : on donne 1 access, on recupere tous les access associes set test [RecupAccSeqParBird $lAccess 0] # si la requete dans BIRD s est bien deroulee if {$test == 1} { set ficOutTar "bird.tar.gz" set ficOut "listeResu" if {[file exists $ficOutTar]} { # le fichier de resultat est dezippe - detare eval exec tar -xzf $ficOutTar if {[file exists ${ficOut}.sw]} { # on recupere les ligne du fichier qui nous interesse set lignes [LesLignesDuFichier ${ficOut}.sw] foreach l $lignes { # on recupere tous les Access presents dans le fichier de resultats # Attention : les Access peuvent se situer sur plus d une ligne # on complete la liste des synonymes listAccessSyn if {[string first "AC" $l] == 0} { set l [string range $l 5 end] foreach e $l { # nettoyage des Access set e [string trim $e "\["] set e [string trim $e "\]"] set e [string trim $e ";"] lappend listAccessSyn [string range $e 0 5] } } } } } } } puts "long liste Acc syn : [llength $listAccessSyn]" # mise en evidence des sequences proteiques supplementaires # a partir des listes generees en se basant sur GC et la GDB # chaque element de chacune des listes est comparee a la liste des access et synonymes # si l access n est pas present dans cette liste # il est d une part ajoute a la liste des sequences a ajouter lseqToAdd # et la liste des synonyme est completee par son access et ses synonymes set lseqToAdd "" foreach e $listeGlobale { if {[lsearch -regexp $listAccessSyn $e] == -1} { lappend lseqToAdd $e # interrogation de BIRD pour recuperer les synonymes set test [RecupAccSeqParBird $e 0] if {$test == 1} { set ficOutTar "bird.tar.gz" set ficOut "listeResu" if {[file exists $ficOutTar]} { eval exec tar -xzf $ficOutTar if {[file exists ${ficOut}.sw]} { set lignes [LesLignesDuFichier ${ficOut}.sw] set i 0 # il peut y avoir plusieurs lignes contenant des Access # dc "tant que la ligne commence par AC" on recupere des synonymes while {[string first "AC" [lindex $lignes $i]] == 0} { # recuperation de la partie de la ligne qui contient la liste des Access set l [string range [lindex $lignes 0] 5 end] foreach syn $l { # ajout de l Access et ses synonymes (nettoyes) a la liste set syn [string trim $syn "\["] set syn [string trim $syn "\]"] set syn [string trim $syn ";"] lappend listAccessSyn $syn } incr i } } } } } } puts "lg listeSeqToAdd [llength $lseqToAdd]" EspionneL $lseqToAdd # Mise a jour du fichier des sequences au format tfa set LesTFAs [CreeTFASelonAccess $lseqToAdd] if {$LesTFAs != ""} { # le fichier MS2PH.tfa est complete avec les nouvelles sequences set f1 [open $ficTFA a+] foreach li $LesTFAs { puts $f1 $li } close $f1 } return 1 } proc MAJProtMS2PHGC {} { # MAJ des donnees issues de GC, croisees avec les donnees de HGMD # DiseaseGenesFromGC contient la liste des genes "that cause, predispose or protect from diseases" selon GC # recapGene contient les listes des genes GC associes aux ID Uniprot et aux genes HGMD # listeProtGC contient la liste des access Uniprot OK pour integrer MS2PH-db # retourne la liste des access Uniprot OK pour integrer MS2PH-db global RepAJourGC set chemin "/home/friedric/MS2PH/MS2PH-db/ListeProt/GeneCards/" set date [eval exec date -u +%d%m%y] set RepOld [file join $chemin "Old$date"] set RepAJourGC [file join $chemin "AJour"] set ficDisGene [file join $RepAJourGC "DiseaseGenesFromGC"] set ficLProtGC [file join $RepAJourGC "listeProtGC"] set ficRecapGene [file join $RepAJourGC "recapGene"] # cree RepOld et y copie les anciennes donnees catch {eval exec mkdir $RepOld} catch {eval exec cp $ficDisGene $ficLProtGC $ficRecapGene $RepOld} # site web GeneCards - page de la liste des "Disease Genes" set url1 "http://www.genecards.org/cgi-bin/listdiseasecards.pl?type=full" set Leslignes {} # copie des lignes de l url set x [HttpCopy $url1 LesLignes] # si la copie s'est bien deroulee if {$x == 1 } { # les lignes sont parsees - creation du fichier DiseaseGenesFromGC set Lgenes [RecupDiseaseGenesGC $LesLignes] } # filtrage de la liste des Disease Genes selon la HGMD set NewList [FiltrageListeGC $Lgenes] return $NewList } proc MAJProtMS2PHGDB {} { # MAJ des donnees issues de la GDB : recuperation des Genetic Disorders by Chromosome pour lesquels on a 1 seq proteique # Les dernieres maj sont deplacees dans un rep dont le nom contient la date # Le repertoire AJour contiendra les nouvelles donnees # ChromoWithProtSeq contient la liste des GDB-Access dans les banques # listeGDBidProt contient la liste des access Uniprot OK pour integrer MS2PH-db global RepAJourGDB global listeARetranscrire set chemin "/home/friedric/MS2PH/MS2PH-db/ListeProt/GDB/" set date [eval exec date -u +%d%m%y] set RepOld [file join $chemin "Old$date"] set RepAJourGDB [file join $chemin "AJour"] set ficOut [file join $RepAJourGDB "listeGDBidProt"] # cree RepOld # copie des anciennes donnees dans RepOld catch {eval exec mkdir $RepOld} catch {eval exec cp $ficOut $RepOld} set url1 "http://www.gdb.org/gdbreports/Chr.XXXX.omim.html" set Lchr [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y Unknown_or_Multiple_Locations] set listeARetranscrire "" # parcours de chaque chromosome foreach i $Lchr { # creation de l url qui va bien, fonction du chromosome traite regsub "XXXX" $url1 $i newurl set Leslignes {} # copie des lignes de l url set x [HttpCopy $newurl Leslignes] # si la copie s'est bien deroulee if {$x == 1 } { # les lignes sont parsees ParseFicheChromoGDB $i $Leslignes } } set f [open $ficOut w] foreach e $listeARetranscrire { puts $f $e } close $f return $listeARetranscrire } proc MATMATMAT {aA aB aC aPROD} { upvar $aA A upvar $aB B upvar $aC C upvar $aPROD PROD # Calcule PROD= A * B * C # A,B,C etant des matrices 3x3 foreach i {1 2 3} { foreach j {1 2 3} { set dd 0. foreach k {1 2 3} { foreach l {1 2 3} { set dd [expr {$dd+[set A($i,$k)]*[set B($k,$l)]*[set C($l,$j)]}] } } set D($i,$j) $dd } } foreach i {1 2 3} { foreach j {1 2 3} { set PROD($i,$j) [set D($i,$j)] } } return } proc MDScore {MSFouNom {Force ""}} { global MDScore global RepertoireDuGenome Wup "Force can be CalculeMoi or IsText if MSFouNom is the text of the MSF itself" if {$Force=="IsText"} { set MSF $MSFouNom set FichierMSF [TmpFile] Sauve $MSF dans $FichierMSF set Nom "" set Force "CalculeMoi" } else { set Nom $MSFouNom if {$Nom=="LaListeMerci" && [info exists MDScore("LaListeMerci")]} { return [set MDScore("LaListeMerci")] } set FichierMSF $Nom set Nom [file tail $FichierMSF] } set CalculeMoi [string equal -nocase "CalculeMoi" $Force] if { ! $CalculeMoi && $Nom!="" && [info exists MDScore($Nom)]} { return [set MDScore($Nom)] } if { ! [file exists $FichierMSF]} { set FichierMSF "$RepertoireDuGenome/msf/$Nom" } if { $Nom!="LaListeMerci" && ($CalculeMoi || ! [YaPABouTROUouTRNAouARNenDebutDe $Nom])} { set CommandeMDScore "normd $FichierMSF" set MD "" if { ! [catch {set MD [eval exec $CommandeMDScore]} Message]} { if { ! [regexp {[0-9]} $MD]} { Warne "MDScore ne rend pas de nombre mais $Message" return -9999.4 } set Score "" scan $MD "%s %f" NomDuFich Score if {[regexp {^[0-9\-\+\.eE]+$} $Score]} { set MD $Score } elseif {[regexp {^[0-9\-\+\.eE]+$} $NomDuFich]} { set MD $NomDuFich } else { set MD $MD } return $MD } else { Warne "MDScore se plante par $Message" return -9999.0 } } set FichierMDs "$RepertoireDuGenome/fiches/md_scores" if {[file exists $FichierMDs] && [ContenuDuFichier $FichierMDs]!=""} { foreach Ligne [LesLignesDuFichier $FichierMDs] { set MD "" scan $Ligne "%s %s %s" NomLu MDouFichier MD if {$MD==""} { set MD $MDouFichier } if {$MD==""} { set MD -9999.5 } set MDScore($NomLu) $MD lappend MDScore(LaListeMerci) "$NomLu $MD" } if {[info exists MDScore($Nom)]} { return [set MDScore($Nom)] } else { if {$Force=="CalculeMoiSiManquant"} { set MD [MDScore $Nom "CalculeMoi"] lappend MDScore(LaListeMerci) "$Nom $MD" set LesNomMD [lsort [set MDScore(LaListeMerci)]] SauveLesLignes $LesNomMD dans $FichierMDs return $MD } return -9999.8 } } if { ! [OuiOuNonMemo "Do I calculate now all MDscores (NorMD) ... ?"]} { return -9999.3 } foreach NomLu [ListeDesPABs] { if {[info exists MDScore($NomLu)]} { continue } set FichierMSF "$RepertoireDuGenome/msf/$NomLu" if { ! [file exists $FichierMSF]} { set MD -9999.7 } else { set MD [MDScore $FichierMSF "CalculeMoi"] } set MDScore($NomLu) $MD Espionne "$NomLu $MD" AppendAuFichier $FichierMDs "$NomLu $MD" } if {[info exists MDScore($Nom)]} { return [set MDScore($Nom)] } else { return -9999.6 } } proc MDScoreAvecSelection {TexteMSF LesAccess {InOut In}} { if {[llength $LesAccess]<2} { return -9999.0 } set MSFSelection [MSFSelection $TexteMSF $LesAccess $InOut] if {$MSFSelection==""} { return -9999.0 } return [MDScore $MSFSelection "IsText"] } proc MDScoreAvecSelectionDuFichier {FichierMSF LesAccess {InOut In}} { return [MDScoreAvecSelection [ContenuDuFichier $FichierMSF] $LesAccess $InOut] } proc MF_Reduce {} { DecortiqueUnTFA PF01588_full.tfa Ln Sq foreach n $Ln { lassign [split $n "/"] a tmp lappend La $a } # traite ID set Lr [IDMapping "ID" NF50 $La] set na 0 ; set Lum [list] foreach n $Ln a $La r $Lr { if {$a eq $r || $r eq ""} { puts ">$a< >$r<" lappend Lum $a continue } lappend R($r) $n incr na } # traite ACC set Lc [IDMapping "ACC+ID" NF50 $Lum] set na2 0 ; set Lum2 [list] foreach a $La c $Lc { if {$a eq $c || $c eq ""} { lappend Lum2 $a continue } set i [lsearch $La $a] set n [lindex $Ln $i] lappend R($c) $n incr na2 } puts "nbr of seqs .............. [llength $Ln]" puts "nbr of seqs ID mapped .... $na" puts "nbr of seqs ACC mapped ... $na2" puts " Total mapped ... [expr {$na+$na2}]" puts "nbr of UniRef50 .......... [llength [array names R]]" puts "" set Lseq [list] ; set Lk [list] foreach k [array names R] { lappend Lk $k set n [lindex [set R($k)] 0] lappend Lseq [set Sq($n)] } EcritLeTfa U50.tfa $Lk $Lseq parray R puts "" puts "[join $Lum2 \n]" exit } proc MGI {{Qui ""} {Quoi ""}} { #LP 2013/01/31 avant on lisait MRK_Synonym.sql.rpt. Maintenant on lit MRK_List2.rpt global MGI if {$Qui==""} { set Qui "ListOf" } if {$Quoi=="" && [string equal -nocase $Qui "ListOf"]} { set Quoi "Header" } if {$Quoi==""} { set Quoi "AllTxt" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {[info exists MGI($Qui,$Quoi)]} { return $MGI($Qui,$Quoi) } if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} { set LesTouts [MGI $Qui All] set LeRetour {} set N [llength $LesTouts] set Saut "" if {$N>1} { set Saut "\n" } set I 0 foreach LeTout $LesTouts { incr I if {$LeTout==""} { continue } if {$N>1} { lappend LeRetour [format "\n%45s : %s" "I_found_${N}_hits" $I] } foreach T [MGI ListOf Header] V $LeTout { lappend LeRetour [format "%45s : %s" $T $V] } } if {$Quoi=="ALLLIST"} { return $LeRetour } set Retour [join $LeRetour "\n"] if {$Quoi=="ALLHTML" || [PourWscope]} { return "

\n$Retour\n

" } if {$Quoi=="ALLTXT"} { return $Retour } return $Retour } if {[info exists MGI("EstCharge")]} { if {[info exists MGI($Qui,ONE_MGIID)]} { return [MGI $MGI($Qui,ONE_MGIID) $Quoi] } return "" } set MGI("EstCharge") 1 set FichierMGI "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_List2.rpt" set Q [file tail $FichierMGI] regsub -nocase {\.[^\.]+$} $Q "" Q set MGI(FILE,NAME) $FichierMGI set MGI(FILE,QUEUE) $Q LoadTxl $FichierMGI Txl -1 "\t" set MGI(LISTOF,HEADER) $Txl(ListHeaderPlease,$Q) set MGI(LISTOF,INDEX) $Txl(ListAllPlease,$Q) foreach I $Txl(ListAllPlease,$Q) { set MgiId $Txl($I,MGI_Accession_ID) set Gn $Txl($I,Marker_Symbol) if {[info exists Txl($I,Marker_Synonyms_pipe-separated)]} { set SynIni $Txl($I,Marker_Synonyms_pipe-separated) } set MGIID [string toupper $MgiId] set GN [string toupper $Gn] lappend MGI(LISTOF,MGIID) $MgiId lappend MGI(LISTOF,GENENAME) $Gn set MGI($GN,MGIID) [lsort -unique [lappend MGI($GN,MGIID) $MgiId]] set MGI($MGIID,GENENAME) [lsort -unique [lappend MGI($MGIID,GENENAME) $Gn]] if {[info exists SynIni]} { set LesSyn [split $SynIni "|"] set MGI($MGIID,LISTOFSYN) $LesSyn set MGI($GN,LISTOFSYN) $LesSyn foreach Syn $LesSyn { set SYN [string toupper $Syn] lappend MGI($SYN,REFERENCE_MGIID) $MGIID lappend MGI($SYN,REFERENCE_GENENAME) $Gn } } set LeTout {} foreach T $Txl(ListHeaderPlease,$Q) { lappend LeTout $Txl($I,$T) set MGI($MGIID,[string toupper $T]) $Txl($I,$T) set MGI($GN,[string toupper $T]) $Txl($I,$T) } lappend MGI($MGIID,ALL) $LeTout lappend MGI($GN,ALL) $LeTout } set MGI(LISTOF,MGIID) [lsort -unique $MGI(LISTOF,MGIID)] set MGI(LISTOF,GENENAME) [lsort -unique $MGI(LISTOF,GENENAME)] return [MGI $Qui $Quoi] } proc MGIHGNC {{Qui ""} {Quoi ""}} { global MGIHGNC if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "AllTxt" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {[info exists MGIHGNC($Qui,$Quoi)]} { return $MGIHGNC($Qui,$Quoi) } if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} { set LeTout [MGIHGNC $Qui "All"] if {$LeTout==""} { return "" } foreach T [MGIHGNC ListOf Header] V $LeTout { lappend LeRetour [format "%45s : %s" $T $V] } if {$Quoi=="ALLLIST"} { return $LeRetour } set Retour [join $LeRetour "\n"] if {$Quoi=="ALLHTML" || [PourWscope]} { return "

\n$Retour\n

" } if {$Quoi=="ALLTXT"} { return $Retour } return $Retour } if {[info exists MGIHGNC("EstCharge")]} { if {[info exists MGIHGNC($Qui,MGIID)]} { set FirstRef [lindex $MGIHGNC($Qui,MGIID) 0] if {[string equal -nocase $Qui $FirstRef]} { return "" } return [MGIHGNC $FirstRef $Quoi] } return "" } set MGIHGNC("EstCharge") 1 set FichierMGIHGNC "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/HMD_HGNC_Accession.rpt" set Q [file tail $FichierMGIHGNC] set MGIHGNC(FILE,NAME) $FichierMGIHGNC set MGIHGNC(FILE,QUEUE) $Q set MGIHGNC(LISTOF,HEADER) [list "MgiId" "MgiGeneName" "MgiMarkerName" "MgiEntrezGeneId" "HgncId" "HgncGeneName" "HgncEntrezGeneId"] foreach Ligne [LesLignesDuFichier $FichierMGIHGNC] { set LesMots [split $Ligne "\t"] ScanLaListe $LesMots MgiId MgiGeneName MgiMarkerName MgiEntrezGeneId HgncId HgncGeneName HgncEntrezGeneId set MGIID [string toupper $MgiId] set HGNCID [string toupper $HgncId] set MGIGENENAME [string toupper $MgiGeneName] set HGNCGENENAME [string toupper $HgncGeneName] #if {$HGNCID!="" && [info exists DejaVu($HGNCID)]} { FaireLire "DejaVu $HGNCID\n$DejaVu($HGNCID)\n$Ligne" } #set DejaVu($HGNCID) $Ligne #if {$MGIID!="" && [info exists DejaVu($MGIID)]} { FaireLire "DejaVu $MGIID\n$DejaVu($MGIID)\n$Ligne" } #set DejaVu($MGIID) $Ligne foreach T $MGIHGNC(LISTOF,HEADER) V $LesMots { set T [string toupper $T] set MGIHGNC($MGIID,$T) $V set MGIHGNC($HGNCID,$T) $V } set MGIHGNC($MGIID,HGNCID) $HGNCID set MGIHGNC($HGNCID,MGIID) $MGIID lappend MGIHGNC($MGIGENENAME,MGIID) $MGIID lappend MGIHGNC($HGNCGENENAME,HGNCID) $HGNCID lappend MGIHGNC($MgiEntrezGeneId,HGNCGENEID) $HgncEntrezGeneId lappend MGIHGNC($HgncEntrezGeneId,MGIGENEID) $MgiEntrezGeneId lappend MGIHGNC($HgncEntrezGeneId,MGIID) $MGIID lappend MGIHGNC(LISTOF,MGIID) $MGIID lappend MGIHGNC(LISTOF,HGNCID) $HGNCID lappend MGIHGNC(LISTOF,MGIGENENAME) $MGIGENENAME lappend MGIHGNC(LISTOF,HGNCGENENAME) $HGNCGENENAME set MGIHGNC($MGIID,ALL) $LesMots set MGIHGNC($HGNCID,ALL) $LesMots } set MGIHGNC(LISTOF,MGIID) [lsort -unique $MGIHGNC(LISTOF,MGIID)] set MGIHGNC(LISTOF,HGNCID) [lsort -unique $MGIHGNC(LISTOF,HGNCID)] set MGIHGNC(LISTOF,MGIGENENAME) [lsort -unique $MGIHGNC(LISTOF,MGIGENENAME)] set MGIHGNC(LISTOF,HGNCGENENAME) [lsort -unique $MGIHGNC(LISTOF,HGNCGENENAME)] return [MGIHGNC $Qui $Quoi] } proc MGILP {{Qui ""} {Quoi ""}} { #From LP: En 2008, tous les MGI n etaient pas present dans [GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_Synonym.sql.rpt ??? exemple:ccng2 #FromLP: En 2013, le fichier MRK_Synonym.sql.rpt n existe plus : ne se sert plus de MGILP global MGILP set Qui [string toupper $Qui] if {[info exists MGILP($Qui,$Quoi)]} {return $MGILP($Qui,$Quoi)} if {[info exists MGILP("EstCharge")]} {return ""} set MGILP("EstCharge") 1 #set MGILP(LISTOF,HEADER) [list "MgiId" "GeneName"] set Fichier "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_Dump1.rpt" foreach Ligne [LesLignesDuFichier $Fichier] { set LesMotsDeLaLigne [split $Ligne "\t"] set Mgi [lindex $LesMotsDeLaLigne 0] set Gn [lindex $LesMotsDeLaLigne 1] set Gn [string toupper $Gn] set MGILP($Mgi,Gn) $Gn set MGILP($Gn,Mgi) $Mgi } return [MGILP $Qui $Quoi] } proc MGISW {{Qui ""} {Quoi ""} {Ou ""}} { JeMeSignale #Utilise l'un ou l'autre #set FichierMGISW "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt.rpt" #set FichierMGISW "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt_TrEMBL.rpt" global MGISW if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {$Quoi==""} { set Quoi "AllTxt" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] Espionne $Ou if {[string equal -nocase $Ou "SW"]} { set Ou "MRK_SwissProt.rpt" } if {[string equal -nocase $Ou "SWTrEmbl"]} { set Ou "MRK_SwissProt_TrEMBL.rpt" } if {$Ou!="" && ! [regexp "/" $Ou]} { set Ou "/genomics/link/UCSCGenomes/GeneNaming/$Ou" } Espionne $Ou if {$Ou!=""} { if {[info exists MGISW(FILE,NAME)] && $Ou!=$MGISW(FILE,NAME)} { unset MGISW } set FichierMGISW $Ou set MGISW(FILE,NAME) $Ou } else { if {[info exists MGISW(FILE,NAME)]} { set Ou $MGISW(FILE,NAME) set FichierMGISW $Ou } else { FaireLire "Il faut donner un nom de fichier ou SW ou SWTrEmbl la premiere fois" return "" } } if {[info exists MGISW($Qui,$Quoi)]} { return $MGISW($Qui,$Quoi) } if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} { set LeTout [MGISW $Qui "All"] if {$LeTout==""} { return "" } foreach T [MGISW ListOf Header] V $LeTout { lappend LeRetour [format "%45s : %s" $T $V] } if {$Quoi=="ALLLIST"} { return $LeRetour } set Retour [join $LeRetour "\n"] if {$Quoi=="ALLHTML" || [PourWscope]} { return "

\n$Retour\n

" } if {$Quoi=="ALLTXT"} { return $Retour } return $Retour } if {[info exists MGISW("EstCharge")]} { if {[info exists MGISW($Qui,MGIID)]} { set FirstRef [lindex $MGISW($Qui,MGIID) 0] if {[string equal -nocase $Qui $FirstRef]} { return "" } return [MGISW $FirstRef $Quoi] } return "" } set MGISW("EstCharge") 1 set Q [file tail $FichierMGISW] set MGISW(FILE,NAME) $FichierMGISW set MGISW(FILE,QUEUE) $Q set MGISW(LISTOF,HEADER) [list "MgiId" "GeneName" "Status" "Name" "cMPosition" "Chr" "Sw"] foreach Ligne [LesLignesDuFichier $FichierMGISW] { set LesMots [split $Ligne "\t"] ScanLaListe $LesMots MgiId GeneName Status Name cMPosition Chr Sw set MGIID [string toupper $MgiId] set GENENAME [string toupper $GeneName] lappend MGISW(LISTOF,MGIID) $MGIID lappend MGISW(LISTOF,GENENAME) $GENENAME if {$MGIID!="" && [info exists DejaVu($MGIID)]} { FaireLire "DejaVu $MGIID\n$DejaVu($MGIID)\n$Ligne" } set DejaVu($MGIID) $Ligne if {$GENENAME!="" && [info exists DejaVu($GENENAME)]} { FaireLire "DejaVu $GENENAME\n$DejaVu($GENENAME)\n$Ligne" } set DejaVu($GENENAME) $Ligne foreach T $MGISW(LISTOF,HEADER) V $LesMots { set T [string toupper $T] set MGISW($MGIID,$T) $V set MGISW($GENENAME,$T) $V } set MGISW($MGIID,SW) $Sw set MGISW($MGIID,ALL) $LesMots } set MGISW(LISTOF,MGIID) [lsort -unique $MGISW(LISTOF,MGIID)] set MGISW(LISTOF,GENENAME) [lsort -unique $MGISW(LISTOF,GENENAME)] return [MGISW $Qui $Quoi] } proc MMMInit {} { global CMDef db package require Tk package require sqlite3 package require imap4 package require tls package require mime package require tablelist package require base64 source /home/moumou/imap4.tcl source /home/moumou/mime.tcl source /home/moumou/rfc2822.tcl ClientMailDef # init styles set cbg $CMDef(Background) foreach wdg {TCheckbutton TRadiobutton} { ttk::style map MMM.$wdg -background [list active $cbg disabled $cbg readonly $cbg] ttk::style map MMM.$wdg -foreground [list active white disabled white readonly white] } ttk::style configure MMM.TFrame -background $cbg ttk::style configure MMM.TLabel -background $cbg -foreground white -anchor e -justify right -font CMFont ttk::style configure MMM.TEntry -font CMFont ttk::style configure MMM.TEntry -fieldbackground black ttk::style configure MMM.TEntry -fieldforeground white ttk::style configure MMM.TEntry -foreground white ttk::style configure MMM.TCheckbutton -background $cbg -foreground white -font CMFont ttk::style configure MMM.TRadiobutton -background $cbg -foreground white -font CMFont # database present if {! [file exists clientmail.sql]} { set db [FabriqueDeTables $CMDef(Tables) "" clientmail.sql] NewMailServer } else { LoadDB MailServerChooser ConnectMailbox } MMMInterface return set Lfold [::imap4::folders $imapID -inline] set mb(Lfolders) $Lfold ::imap4::select $imapID $FOLDER InitFolder $FOLDER return } proc MMMInterface {} { global CMDef db TMail wm withdraw . grid columnconfig . all -weight 1 grid rowconfig . all -weight 1 . configure -background $::CMDef(Background) # global frame ttk::frame .f -style MMM.TFrame grid .f -row 0 -column 0 -sticky news -padx 10 grid columnconfig .f all -weight 1 grid rowconfig .f all -weight 1 set w .f # menu frame ttk::frame $w.fmenu -style MMM.TFrame grid $w.fmenu -row 0 -column 0 -sticky ew grid columnconfig $w.fmenu all -weight 1 # mail frame ttk::frame $w.fmail -style MMM.TFrame grid rowconfig $w.fmail all -weight 1 grid columnconfig $w.fmail all -weight 1 grid $w.fmail -row 1 -column 0 -sticky news set TMail(List) [list] set TMail(Read) [list] set TMail(Answ) [list] set TMail(Atta) [list] set TMail(UID) [list] set CMDef(TbL) $w.fmail.tbl tablelist::tablelist $w.fmail.tbl -background black -foreground white -columns { 1 "A" center 15 "Sender" left 20 "Subject" left 10 Date left} -font CMFont -labelfont CMFontBold -labelcommand tablelist::sortByColumn -labelforeground white -labelbackground "#444444" -labelactivebackground green -labelactiveforeground white -height 5 -selecttype row -selectmode extended -selectforeground white -selectbackground "#555555" -listvariable TMail(List) set CMDef(WText) $w.fmail.txt text $w.fmail.txt -background black -foreground white -wrap word -font CMFont -height 10 -yscrollcommand "$w.fmail.vsc set" scrollbar $w.fmail.vsc -width 8 -command "$w.fmail.txt yview " grid $w.fmail.tbl -row 0 -column 0 -columnspan 2 -sticky news grid $w.fmail.vsc -row 1 -column 1 -sticky ns grid $w.fmail.txt -row 1 -column 0 -sticky news ttk::frame $w.fbut -style MMM.TFrame grid $w.fbut -row 2 -column 0 -sticky ew button $w.fbut.bok -text " Close " -bg green1 -font CMFontBold -command {QuitMMM} grid $w.fbut.bok -row 0 -column 0 -sticky e grid columnconfig $w.fbut all -weight 1 # special configurations $w.fmail.tbl columnconfigure 0 -font CMFontBold -labelfont CMFont $w.fmail.tbl columnconfigure 1 -sortmode asciinocase # -sortcommand SortColumn $w.fmail.tbl columnconfigure 2 -sortmode asciinocase # -sortcommand SortColumn $w.fmail.tbl columnconfigure 3 -sortmode dictionary # -sortcommand SortColumn update idletasks RetrieveMails # bindings bind Text {focus %W} bind Text {focus .} bind $w.fmail.txt {%W yview scroll [expr {%D/120}] units} bind [$w.fmail.tbl bodytag] {DisplayMessage %W %w %y} bind [winfo toplevel $w] {NewMailServer} wm attributes . -fullscreen 1 wm deiconify . #FenetreAuCentre $w update idletasks #tkwait variable Retour return 1 } proc MMm {} { global Coucou T _1T set Coucou "bonjour\nsalut" set T(1) "Je suis sur \n deux lignes" set _1T(a) "1ta" foreach Variable [info globals] { global $Variable if {[regexp "Glossaire" $Variable]} { continue } if { ! [info exists $Variable]} { continue } if {[array exists $Variable]} { lappend LesGlobal [PaqArray [set Variable]] } else { lappend LesGlobal [PaqListe $Variable [set $Variable]] } } set Coucou perdu unset _1T EspionneL $LesGlobal Espionne "Fin de LesGlobal" set LesV [AffecteLesVariablesDeLaListe $LesGlobal] foreach V $LesV { if {[array exists $V]} { Espionne "$V [array get $V]" } else { Espionne "$V [set $V]" } } Espionne $Coucou Espionne $T(1) Espionne $_1T(a) exit } proc MOD3 {I aJ aK} { upvar $aJ J upvar $aK K set J [expr {$I+1}] set K [expr {$I+2}] if {$J > 3} {set J [expr {$J-3}]} if {$K > 3} {set K [expr {$K-3}]} return } proc MSF2TFAs {FileMSF FileTFAs {JusteLesSequences 1}} { if {![file exists $FileMSF]} {return} set LeTexte {} foreach Access [AskMSF $FileMSF LesAccess] { set Seq [string toupper [AskMSF $FileMSF $Access]] if {$JusteLesSequences} {regsub -all {[^A-Z]} $Seq "" Seq} set SeqTFA [SEQ2TFA $Seq $Access] Espionne $Access lappend LeTexte $SeqTFA } AskMSF unset if {$LeTexte == {}} {return} Sauve [join $LeTexte "\n"] dans $FileTFAs } proc MSF2WordML {FileMSF {FileOut ""} {PMin 0.85} {NbProtMinToConsiderACol 10} {SizeFont 6} {NbResiduesParLigne 100}} { if {![file exists $FileMSF]} {return} if {$FileOut == ""} { set FileOut [FichierPourSaveAs "$FileMSF.xml"] if {$FileOut == ""} {return} } set LesAA [list A R N D C Q E G H I L K M F P S T W Y V] foreach AA [list A C F I L M V W Y T S G] {set TabHydrophobic($AA) 1} foreach AA [list A C S T D V G P ] {set TabSmall($AA) 1} foreach AA [list D E H K R ] {set TabCharged($AA) 1} foreach AA [list D E H K N Q R S T ] {set TabPolar($AA) 1} set LesAccess [AskMSF $FileMSF LesAccess] set NbAcc [llength $LesAccess] set Acc1 [lindex $LesAccess 0] set Seq1 [AskMSF $FileMSF $Acc1] set TailleAli [string length $Seq1] set NbCarMax 11 foreach Acc $LesAccess { set NbCar [string length $Acc] if {$NbCarMax < $NbCar} {set NbCarMax $NbCar} set TabSeq($Acc,Length) 0 set Seq [string toupper [AskMSF $FileMSF $Acc]] set i 0 set j 0 foreach AA [split $Seq ""] { if {$AA == "~"} {set AA "."} incr i if {$AA != "."} {incr j} set TabSeq($Acc,$i,PosSeq) $j set TabSeq($Acc,$i) $AA } } incr NbCarMax for {set i 1} {$i <= $TailleAli} {incr i} { set NbAccInColumn 0 set TabSeq(Res,H,$i) 0 set TabSeq(Res,S,$i) 0 set TabSeq(Res,C,$i) 0 set TabSeq(Res,P,$i) 0 set TabSeq(Res,Cons,$i) 0 set NbH 0 set NbS 0 set NbC 0 set NbP 0 set TabNMax(N) 0 set TabNMax(AA) "" foreach AA $LesAA {set TabN($AA) 0} set LaLigne {} foreach Acc $LesAccess { set AA [set TabSeq($Acc,$i)] lappend LaLigne $AA if {[info exists TabHydrophobic($AA)]} {incr NbH} if {[info exists TabSmall($AA) ]} {incr NbS} if {[info exists TabCharged($AA) ]} {incr NbC} if {[info exists TabPolar($AA) ]} {incr NbP} if {[info exists TabN($AA)]} { incr TabSeq($Acc,Length) incr TabN($AA) incr NbAccInColumn if {[set TabNMax(N)] < [set TabN($AA)]} { set TabNMax(N) [set TabN($AA)] set TabNMax(AA) $AA } } } if {$NbAccInColumn < $NbProtMinToConsiderACol} {continue} set PH [expr $NbH * 1.0 / $NbAccInColumn] if {$PMin <= $PH } {set TabSeq(Res,H,$i) h} set PS [expr $NbS * 1.0 / $NbAccInColumn] if {$PMin <= $PS } {set TabSeq(Res,S,$i) s} set PC [expr $NbC * 1.0 / $NbAccInColumn] if {$PMin <= $PC } {set TabSeq(Res,C,$i) c} set PP [expr $NbP * 1.0 / $NbAccInColumn] if {$PMin <= $PP } {set TabSeq(Res,P,$i) p} set AA [set TabNMax(AA)] set PI [expr [set TabNMax(N)] * 1.0 / $NbAccInColumn] if {$PMin <= $PI} {set TabSeq(Res,Cons,$i) $AA} } set LeTexte {} lappend LeTexte [DebutDoc_WordML "Courier"] foreach LaSerie [LesSeriesDeNResidues $TailleAli $NbResiduesParLigne] { set D [lindex $LaSerie 0] set F [lindex $LaSerie 1] set LaTextDePos {} set nAcc 0 foreach Acc $LesAccess { incr nAcc set LeTextDeLaSeq {} for {set i $D} {$i <= $F} {incr i} { set Color "black" set BackGround "white" set AA [set TabSeq($Acc,$i)] if { [set TabSeq(Res,Cons,$i)] != 0} { if {[set TabSeq(Res,Cons,$i)] == $AA} { set Color "white" set BackGround "black" } else { set Color "black" set BackGround "white" } } elseif {[set TabSeq(Res,H,$i)] != 0} { if {[info exists TabHydrophobic($AA)]} { set Color "black" set BackGround "yellow" } else { set Color "black" set BackGround "white" } } elseif {[set TabSeq(Res,S,$i)] != 0} { if {[info exists TabSmall($AA)]} { set Color "white" set BackGround "green" } else { set Color "black" set BackGround "white" } } elseif {[set TabSeq(Res,C,$i)] != 0} { if {[info exists TabCharged($AA)]} { set Color "white" set BackGround "red" } else { set Color "black" set BackGround "white" } } elseif {[set TabSeq(Res,P,$i)] != 0} { if {[info exists TabPolar($AA)]} { set Color "blue" set BackGround "white" } else { set Color "black" set BackGround "white" } } else { set Color "black" set BackGround "white" } lappend LeTextDeLaSeq [EncadrementDeTexte_WordML $AA 0 0 0 $SizeFont $Color $BackGround ] set Color "black" set BackGround "white" if {[expr $i % 10] == 0} { if {$nAcc == 1} { lappend LaTextDePos [EncadrementDeTexte_WordML [format "%10s" "|"] 0 0 0 $SizeFont $Color $BackGround] lappend LaTextDePos [EncadrementDeTexte_WordML " " 0 0 0 $SizeFont $Color $BackGround] } lappend LeTextDeLaSeq [EncadrementDeTexte_WordML " " 0 0 0 $SizeFont $Color $BackGround] } } if {$nAcc == 1} { set LaLigne {} lappend LaLigne [EncadrementDeTexte_WordML [format "%-${NbCarMax}s %6s " "" ""] 1 0 0 $SizeFont $Color $BackGround] lappend LaLigne [join $LaTextDePos "\n"] lappend LaLigne [EncadrementDeTexte_WordML [format " %-6s %-8s" "" ""] 1 0 0 $SizeFont $Color $BackGround] lappend LeTexte [Paragraphe_WordML [join $LaLigne "\n"]] } set Length [set TabSeq($Acc,Length)] set DSurProt [set TabSeq($Acc,$D,PosSeq)] set FSurProt [set TabSeq($Acc,$F,PosSeq)] if {$DSurProt == 0 && $FSurProt != 0} {set DSurProt 1} set TextLength "($Length)" set LaLigne {} lappend LaLigne [EncadrementDeTexte_WordML [format "%-${NbCarMax}s %6s " $Acc $DSurProt ] 1 0 0 $SizeFont black white] lappend LaLigne [join $LeTextDeLaSeq "\n"] lappend LaLigne [EncadrementDeTexte_WordML [format " %-6s %-8s" $FSurProt $TextLength] 1 0 0 $SizeFont black white] lappend LeTexte [Paragraphe_WordML [join $LaLigne "\n"]] lappend LeTexte "" } foreach Res [list H S C P Cons] Cat [list Hydrophobic Small Charged Polar Conserved] { set LeTextDeLaSeq {} for {set i $D} {$i <= $F} {incr i} { set Color "black" set BackGround "white" if {[set TabSeq(Res,$Res,$i)] == 0} {set AA " "} else {set AA [set TabSeq(Res,$Res,$i)]} lappend LeTextDeLaSeq [EncadrementDeTexte_WordML $AA 0 0 0 $SizeFont $Color $BackGround] if {[expr $i % 10] == 0} { lappend LeTextDeLaSeq [EncadrementDeTexte_WordML " " 0 0 0 $SizeFont $Color $BackGround] } } set LaLigne {} lappend LaLigne [EncadrementDeTexte_WordML [format "%-${NbCarMax}s %6s " $Cat ""] 1 0 0 $SizeFont $Color $BackGround] lappend LaLigne [join $LeTextDeLaSeq "\n"] lappend LaLigne [EncadrementDeTexte_WordML [format " %-6s %-8s" "" ""] 1 0 0 $SizeFont $Color $BackGround] lappend LeTexte [Paragraphe_WordML [join $LaLigne "\n"]] lappend LeTexte "" } lappend LeTexte [Paragraphe_WordML [EncadrementDeTexte_WordML "" 0 0 0 $SizeFont black white]] lappend LeTexte "" } lappend LeTexte [FinDoc_WordML "Landscape"] Sauve [join $LeTexte "\n"] dans $FileOut return } proc MSF2binaire {LesNoms aProteines aBin TailleSeq} { upvar $aProteines Proteines upvar $aBin Bin foreach Nom $LesNoms { set i 1 set LaProteine [set Proteines($Nom)] foreach el $LaProteine { if {$el =="." || $el=="~"} { set Bin($Nom,$i) 0 } else { set Bin($Nom,$i) 1 } incr i } } } proc MSFPourCollection {Nom} { Wup "Attention we call the DbClustalPourTous for only one !!" DbClustalPourTous $Nom } proc MSFSelection {FichierOuTexteMSF LesAccess {InOut In}} { if {[EstUnPAB $FichierOuTexteMSF]} { set FichierOuTexteMSF [GscopeFile $FichierOuTexteMSF "msf"] } set TexteMSF $FichierOuTexteMSF if { ! [regexp "\n" $FichierOuTexteMSF] && [file exists $FichierOuTexteMSF]} { set TexteMSF [ContenuDuFichier $FichierOuTexteMSF] } if {$InOut=="In"} { set In 1 } else { set In 0 } foreach Access $LesAccess { set ACCESS [string toupper $Access] set InterestingAccess($ACCESS) 1 } set LesNouveaux {} foreach Ligne [split $TexteMSF "\n"] { if {[regexp "^PileUp" $Ligne] || [regexp {^ANCHORS [0-9]+} $Ligne] || [regexp {^ +MSF\:} $Ligne] || ! [regexp -nocase {[a-z0-9]} $Ligne] } { lappend LesNouveaux $Ligne ; continue } set Tope 0 if {[regexp -nocase {Name: [a-z0-9_\:\-]} $Ligne]} { scan $Ligne "%s %s" Name Access } else { scan $Ligne "%s" Access } set ACCESS [string toupper $Access] set Tope [info exists InterestingAccess($ACCESS)] if { $Tope && ! $In } { continue } if { ! $Tope && $In } { continue } lappend LesNouveaux $Ligne } return [join $LesNouveaux "\n"] } proc MSO {FichierClust FichierMSF {NomQuery QUERY_PROTEIN} {NorMDMin 0.3} {PMin 0.8} {FMin 0.5}} { if {![file exists $FichierClust] || ![file exists $FichierMSF]} {return} #OUT = [list [list GOTerm1 Type Def nAccess [list Access1 Access2 ...]] [list GOTerm2 Type Def nAccess [list Access1 Access2 ...]]] #MSO Mean Subfamily Ontology set LesAccessDuCluster [LesProteinesDansLeMemeClusterDuMSF $FichierClust $NomQuery] Espionne "$LesAccessDuCluster" set LesAccessSelected {} if {1 < [llength $LesAccessDuCluster]} { set MSFTotal [ContenuDuFichier $FichierMSF] set MSFDuCluster [MSFSelection $MSFTotal $LesAccessDuCluster "In"] if {$MSFDuCluster != ""} { set FMSF "[TmpFile [file tail $FichierMSF]].msfducluster" Sauve $MSFDuCluster dans $FMSF } if {$NorMDMin <= [PipeNorMD $FMSF ]} {set LesAccessSelected $LesAccessDuCluster } } else { if {$NorMDMin <= [PipeNorMD $FichierMSF]} {set LesAccessSelected [InterrogeLesClustersDesMSF $FichierClust LesAccess]} } #nG AskLesPagesInfos load $LesAccessSelected protein AskLesPagesInfos load $LesAccessSelected uniprot set LesGO {} foreach Access $LesAccessSelected { if {[EstUnAccessPDB $Access]} {continue} Espionne "Access $Access -> 2GO" set PageInfo [AskLesPagesInfos ask $Access] if {$PageInfo == ""} {continue} set LesGODeLAccess [PageInfo2GO $PageInfo] foreach GO $LesGODeLAccess { if {![info exists TabTmp(GO,$GO,LesAccess)]} {set TabTmp(GO,$GO,LesAccess) {}} lappend LesGO $GO lappend TabTmp(GO,$GO,LesAccess) $Access } set LesGOAncestraux [TousLesAncetresGODesGO $LesGODeLAccess] foreach GO $LesGOAncestraux { if {![info exists TabTmp(GO,$GO,LesAccess)]} {set TabTmp(GO,$GO,LesAccess) {}} lappend TabTmp(GO,$GO,LesAccess) $Access } } AskLesPagesInfos unset set LesGOSelected {} foreach GO [LaSelectionDesBestGO $LesGO $PMin $FMin] { if {![info exists TabTmp(GO,$GO,LesAccess)]} {continue} set LesAccess [lsort -unique [set TabTmp(GO,$GO,LesAccess)]] set nAccess [llength $LesAccess] foreach Type [GODB GO $GO LesTypes] { set Def [lindex [GODB Type $Type GO $GO LesDefinitions] 0] lappend LesGOSelected [list $GO $Type $Def $nAccess $LesAccess] } } return [lsort -index 1 [lsort -index 3 -real -decreasing $LesGOSelected]] } 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 if {[info exists MSP($Qui,$Quoi,$Quid)]} { return $MSP($Qui,$Quoi,$Quid) } if {[info exists MSP("EstCharge")]} { return "" } set MSP("EstCharge") 1 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 from synthetase" "GetList"] foreach {PkS SName} $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,$PkS,A) $A set MSP(Syn,$System,A) $A set MSP(Syn,$System,System) $System lappend MSP(Syn,ListOf,A) $A lappend MSP(Syn,ListOf,pk) $PkS lappend MSP(Syn,ListOf,System) $System } 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,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" "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,ListOfCo) $Comment set MSP(Mut,$PkM,pkd) $PkD foreach V [list $V1 $V2] { if { ! [info exists DejaVu($V)] && ! [regexp "X" $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] foreach Cons [list IdenGlob ConsGlob SimiGlob AllGlob IdenLocal ConsLocal SimiLocal AllLocal] { set MSP(Con,$A,$Cons) {} } set MonAccess "${A}mito_Homo.sapi" 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 L 0 set G 0 foreach C [split $Seq ""] { incr G if {$C!="-" && $C!="."} { incr 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 return [MSP $Qui $Quoi $Quid] } proc MSPFroMac {args} { if {[PourWscope]} { return [FromMacsim {*}$args] } set Commande "ret FromMacsim [join $args { }]" set Res [QuestionDeScience MSP $Commande] return $Res } 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 MULTMAT {MA aTRANS IMOL} { upvar $aTRANS TRANS T_M A $MA 1 # MULTIPLICATION MATRICIELLE (3X3). # LA NOUVELLE MATRICE EST MISE E foreach K {1 2 3} { foreach L {1 2 3} { set TRANSO($K,$L) [set TRANS($K,$L,$IMOL)] } } foreach K {1 2 3} { foreach L {1 2 3} { set TRANS($K,$L,$IMOL) [expr { [set A($K,1)]*[set TRANSO(1,$L)]+ [set A($K,2)]*[set TRANSO(2,$L)]+ [set A($K,3)]*[set TRANSO(3,$L)]}] } } return } proc M_MM {A op B} { if {$op=="*"} { return [M_xMM $A $B] } else { return [M_lMM 1 $A $op 1 $B] } } proc M_Mwithout {M l c} { set F {} foreach V [lreplace $M $l $l] { lappend F [V_Vwithout $V $c] } return $F } proc M_R {R} { set T [Angle_R $R] set A [Axe_R $R] set c [expr cos($T)] set s [expr sin($T)] set u [expr 1.-$c] set norm [S_nV $A] if {[expr $norm < 1.e-10]} { set norm 1.0 } set AN [V_nV $A] set x [S_fromV $A 0] set y [S_fromV $A 1] set z [S_fromV $A 2] set xx [expr $x*$x*$u] set yy [expr $y*$y*$u] set zz [expr $z*$z*$u] set xy [expr $x*$y*$u] set yz [expr $y*$z*$u] set xz [expr $z*$x*$u] set xs [expr $x*$s] set ys [expr $y*$s] set zs [expr $z*$s] set M [M_create [V_create [expr $xx+$c ] [expr $xy+$zs] [expr $xz-$ys]] [V_create [expr $xy-$zs] [expr $yy+$c ] [expr $yz+$xs]] [V_create [expr $xz+$ys] [expr $yz-$xs] [expr $zz+$c ]] ] return $M } proc M_SM {s op A} { #rR tout faux ! set C {} foreach VA $A { set VR {} foreach x $VA { lappend VR [expr ($s*$x)] } lappend C $VC } return $C } proc M_T {aT} { upvar $aT T set Zero 0 foreach Bornes [array names T] { set I "undefined" set J "undefined" scan $Bornes "%d,%d" I J if {$I=="undefined" || $J=="undefined"} { continue } set Valeur [set T($Bornes)] if {[regexp "\." $Valeur]} { set Zero 0.0 } set BonT($I,$J) $Valeur lappend LesIs $I lappend LesJs $J } set LesIs [lsort $LesIs] set DebI [lindex $LesIs 0] set FinI [lindex $LesIs end] set LesJs [lsort $LesJs] set DebJ [lindex $LesJs 0] set FinJ [lindex $LesJs end] set M {} for {set I $DebI} {$I<=$FinI} {incr I} { set V {} for {set J $DebJ} {$J<=$FinJ} {incr J} { if {[info exists BonT($I,$J)]} { lappend V [set BonT($I,$J)] } else { lappend V $Zero } } lappend M $V } return $M } proc M_create {args} { set M {} foreach V $args { lappend M $V } return $M } proc M_fromM {M dx dy {fx end} {fy end}} { set F {} foreach V [lrange $M $dx $fx] { lappend F [V_fromV $V $dy $fy] } return $F } proc M_invM {M} { return [oldM_invM $M] #rR if {[IsScalar_M $M]} { set X [lindex [lindex $M 0] 0] return [Mcreate 1 [expr {1/$X}]] } set Minv {} set D [S_deterM $M] set pm 1 set i 0 foreach V $M { set W {} set j 0 foreach X $V { set P [M_Mwithout $M $i $j] lappend W [expr {$pm*[S_deterM $P]/$D}] set PM [expr {-$pm}] incr j } lappend Minv $W incr i } return $Minv } proc M_lMM {a A op b B} { #rR attention ceci ne permet pas le produit de matrice #rR ... c'est une combinaison linéaire set C {} foreach VA $A VB $B { set VC {} foreach x $VA y $VB { lappend VC [expr ($a*$x) $op ($b*$y)] } lappend C $VC } return $C } proc M_tM {A} { foreach V $A { set I -1 set LesI {} foreach x $V { incr I lappend Tempo($I) $x lappend LesI $I } } set T {} foreach I $LesI { lappend T [set Tempo($I)] } return $T } proc M_unit {{n 3} {Valeur 1.0}} { set M {} for {set j 0} {$j<$n} {incr j} { lappend M [V_unit $j $n $Valeur] } return $M } proc M_xMM {A B} { set TB [M_tM $B] set C {} foreach W $TB { lappend C [V_MV $A * $W] } #rR a rajoute la transposition 2014/01/06 ... c'etait faux depuis toujours !!! set R [M_tM $C] return $R } proc MaMarie {} { set RepertoireDuGenome [RepertoireDuGenome] puts "Mafft on LastSynMito\n" puts "repG $RepertoireDuGenome" puts "routine MaMarie dans ordali_misc.tcl" set rtfa [file join $RepertoireDuGenome tfasdescopains] set rmft [file join $RepertoireDuGenome mafft] set rnmd [file join $RepertoireDuGenome normd] set rout [file join $RepertoireDuGenome MsfFinaux] set rxml [file join $RepertoireDuGenome XmlFinaux] set rodb [file join $RepertoireDuGenome msf] set rora [file join $RepertoireDuGenome rascal] set rkal [file join $RepertoireDuGenome kalign] for {set i 1} {$i <= 29} {incr i} { catch {unset TNor} set e [format "SM%02d" $i] set ftfa [file join $rtfa $e] set fmft [file join $rmft $e] set fkal [file join $rkal $e] set fras [file join $rmft "${e}.ras"] set fkra [file join $rkal "${e}.ras"] set fodb [file join $rodb $e] set fora [file join $rora $e] set fout [file join $rout $e] set fxml [file join $rxml $e] set fnmd [file join $rnmd $e] set Ln [LesLignesDuFichier $fnmd] set Nc [lindex [split [string trim [lindex $Ln 0]] " "] end] set Nr [lindex [split [string trim [lindex $Ln 1]] " "] end] set TNor(DBCLUSTAL) $Nc set TNor(RASCAL) $Nr if {$Nc > $Nr} { set fori $fodb } else { set fori $fora } set MafftExe "/biolo/mafft/bin/mafft-linsi" set KalignExe "/biolo/kalign/kalign" # catch {exec $MafftExe --auto $ftfa > $fmft} Msg # MAFFT catch {exec $MafftExe $ftfa > $fmft} Msg exec [NorMDExe] $fmft > fmanor set manor [LesLignesDuFichier fmanor] set Nm [lindex $manor 0] set TNor(MAFFT) $Nm file delete -force fmanor catch {eval exec [ClustalwExe] -infile=$fmft -outfile=$fmft -output=gcg -convert} Msg3 catch {exec [RascalExe] $fmft $fras} Msg catch {exec [NorMDExe] $fras > fmanor} Msg2 set manor [LesLignesDuFichier fmanor] set Nrm [lindex $manor 0] set TNor(RASMAFFT) ${Nrm} file delete -force fmanor catch {exec $KalignExe $ftfa $fkal} Msg exec [NorMDExe] $fkal > fkanor set kanor [LesLignesDuFichier fkanor] set Nk [lindex $kanor 0] set TNor(KALIGN) $Nk file delete -force fkanor catch {eval exec [ClustalwExe] -infile=$fkal -outfile=$fkal -output=gcg -convert} Msg3 catch {exec [RascalExe] $fkal $fkra} Msg catch {exec [NorMDExe] $fkra > fmanor} Msg2 set manor [LesLignesDuFichier fmanor] set Nrk [lindex $manor 0] set TNor(RASKALIGN) ${Nrk} file delete -force fmanor # # Results : # puts "$e" set imx "" set nmax -999. foreach j [lsort [array names TNor]] { puts [format "\t%5.3f from %s" [set TNor($j)] $j] if {[set TNor($j)] >= $nmax} { set nmax [set TNor($j)] set imx $j } } puts "\t===> Take $imx" switch $imx { "DBCLUSTAL" - "RASCAL" {file copy -force $fori $fout} "MAFFT" {file copy -force $fmft $fout} "RASMAFFT" {file copy -force $fras $fout} "KALIGN" {file copy -force $fkal $fout} "RASKALIGN" {file copy -force $fkra $fout} } puts "" catch {exec [MacsimsExe] $fout $fxml} } exit } proc MacCourant {{quoi index}} { if {$quoi eq "index"} { return [set ::Defauts(IxMacCourant)] } else { return [set ::Defauts(NmMacCourant)] } } proc MacEdite {{v ""}} { set pkm [MacCourant] if {$v eq ""} { return [$::db eval {select edition from mac where pk_mac=$pkm}] } else { $::db eval {update mac set edition=$v where pk_mac=$pkm} } } proc MacSimToRsf {{XmlMacSimDirectory XmlContigs} {RSFdirectory RsfContigs}} { if { ! [file isdirectory [RepertoireDuGenome]/$XmlMacSimDirectory] } { exit 1 } if { ! [file isdirectory [RepertoireDuGenome]/$RSFdirectory] } { puts "Creating [RepertoireDuGenome]/$RSFdirectory" file mkdir [RepertoireDuGenome]/$RSFdirectory } # set files [glob -directory [RepertoireDuGenome]/$XmlMacSimDirectory *.xml] set files [glob -directory [RepertoireDuGenome]/$XmlMacSimDirectory *] foreach xml $files { # set outfile [RepertoireDuGenome]/$RSFdirectory/[regsub -nocase {.xml$} [regsub -nocase {^.*/} $xml {}] {.rsf}] set outfile [RepertoireDuGenome]/$RSFdirectory/[regsub -nocase {^.*/} $xml {}] puts "$xml -> $outfile" exec clustalw $xml -convert -output=RSF -outfile=$outfile } } proc Macsim {FileIn FileOut} { if {![file exists $FileIn]} {return} set Commande "eval exec /biolo/macsim/macsim $FileIn $FileOut" catch {eval $Commande} Message return $FileOut } proc Macsim2Jalview {FichierMacsimXml {QueryAccess ""}} { package require tdom if {$QueryAccess eq ""} {regexp {^[^.]+} [file tail $FichierMacsimXml] QueryAccess} set tfa [open "[file dirname $FichierMacsimXml]/$QueryAccess.jalview.tfa" "w"] set feat [open "[file dirname $FichierMacsimXml]/$QueryAccess.jalview.features" "w"] set fh [open $FichierMacsimXml "r"] set domDoc [dom parse -channel $fh] set root [$domDoc documentElement] close $fh foreach n [$root selectNodes "//sequence"] { set group [string trim [$n selectNodes "string(.//group\[1\])"]] lappend groups($group) $n } set lColors {} lappend lColors 0 "0,0,225" lappend lColors 1 "192,192,0" lappend lColors 2 "128,0,0" lappend lColors 3 "0,225,225" lappend lColors 4 "0,128,128" lappend lColors 5 "64,128,0" lappend lColors 6 "192,128,0" lappend lColors 7 "192,128,192" lappend lColors 8 "0,150,192" lappend lColors 9 "64,64,225" lappend lColors 10 "192,225,0" lappend lColors 11 "255,192,0" lappend lColors 12 "225,0,128" lappend lColors 13 "0,225,192" lappend lColors 14 "150,0,225" lappend lColors 15 "0,192,225" lappend lColors 16 "164,225,64" lappend lColors 17 "225,192,64" lappend lColors 18 "225,64,192" lappend lColors 19 "64,64,225" lappend lColors 20 "192,64,225" lappend lColors 21 "192,225,64" lappend lColors 22 "128,0,128" lappend lColors 23 "192,0,192" array set colors $lColors array set labelColors {} array set labelFeatures {} foreach g [lsort -integer [array names groups]] { foreach n $groups($g) { set access [string trim [$n selectNodes "string(.//accession)"]] set sequence [string trim [$n selectNodes "string(seq-data)"]] puts $tfa [formatFasta $access $sequence] array unset index array set index [seqPos2AlnPosIndex $sequence] foreach ft [$n selectNodes ".//fitem"] { set type [string trim [$ft selectNodes "string(ftype)"]] set start [string trim [$ft selectNodes "string(fstart)"]] set stop [string trim [$ft selectNodes "string(fstop)"]] set color [string trim [$ft selectNodes "string(fcolor)"]] set score [string trim [$ft selectNodes "string(fscore)"]] set note [string trim [$ft selectNodes "string(fnote)"]] if {$start > $stop} { set tmp $start set start $stop set stop $tmp } if {$start < 1} {continue} set color [expr $color % 24] set label "$type$color" if {![info exists labelColors($label)]} {set labelColors($label) $colors($color)} lappend labelFeatures($label) "$note\t$access\t-1\t$start\t$stop\t$label" } } puts $tfa [formatFasta "SPACER" ""] } foreach label [lsort [array names labelColors]] { puts $feat "$label\t$labelColors($label)" } foreach label [lsort [array names labelFeatures]] { puts $feat [join $labelFeatures($label) "\n"] } close $tfa close $feat exit 0 } proc MacsimDeOrdalie {} { computeBlocks SeqErrors PropagateFeatures return } proc MacsimExiste {} { return [file exists "[RepertoireDuGenome]/macsimXml"] } proc MacsimManu {Nom RepertoireDuMsf} { set FichierSource "[RepertoireDuGenome]/$RepertoireDuMsf/$Nom" set RepertoireDestination "[RepertoireDuGenome]/macsim" if {! [file exists $RepertoireDestination]} {file mkdir $RepertoireDestination} set FichierDestination "$RepertoireDestination/$Nom" set Commande "/biolo/macsim/macsim" #Espionne "$Commande $FichierSource $FichierDestination" catch {exec $Commande $FichierSource $FichierDestination >& /dev/null} } proc MacsimPourTous {RepMsf {PAB ""} {RepMacsim ""}} { # Attention, penser a lancer le macsim sur le meilleur alignement # Normalement c'est le msf leon # mais pas toujours: voir le fichier normd if {$PAB==""} {return} if {![file exists $RepMacsim]} {file mkdir $RepMacsim} foreach Fichier [glob -nocomplain "$RepMsf/$PAB*"] { set Nom [file tail $Fichier] Espionne $Nom set FichierMacsim "$RepMacsim/$Nom" if {[file exists "$RepMacsim/$Nom.rsf"]} {continue} if {[PasTouche $Nom]} {continue} PasTouche $Nom Macsim $Fichier $FichierMacsim if {[file exists "$RepMacsim/$Nom.rsf"]} {FinPasTouche $Nom} #Sauve $MacsimOut dans $FichierMacsim #set Commande "eval exec /biolo/macsim/macsim $Fichier $FichierMacsim" #catch {eval $Commande} Message #Sauve $FichierMacsim dans $FichierMacsim #set MacsimOut [eval exec $Commande] #Espionne "$Nom done" } } proc MacsimXmlComplet {} { set i 0 foreach FichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsims/*.xml"] { set Box [file tail $FichierMacsim] regsub {\.[^\.]+$} $Box "" Box if {![file exists "[RepertoireDuGenome]/macsimXml/$Box"]} { incr i; Espionne "manque dans macsimXml $Box" } } Espionne "i $i" } proc Macsims {FichierMsf {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} { LogWscope "Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog $Delete" #rR y a encore un probleme ... 2011/04/20 if {$FichierXml==""} { set FichierXml "GetXmlText" } if {$FichierRsf==""} { set FichierRsf "DeleteRsfFile" } set GetRsf "GetRsfFile" if {$FichierRsf=="GetRsfText" || $FichierRsf=="DeleteRsfFile"} { set GetRsf $FichierRsf set FichiersRsf "[TmpFile].rsf" } set GetXml "GetXmlFile" if {$FichierXml=="GetXmlText" || $FichierXml=="DeleteXmlFile"} { set GetXml $FichierXml set FichierXml "[TmpFile].xml" } set Message [ExecuteMacsim $FichierMsf $FichierRsf] if {$Message!=""} { Warne $Message if {$FichierLog!=""} { AppendAuFichier $FichierLog $Message } } set FichierRsfRsf "$FichierRsf.rsf" set FichierRsfXml "$FichierRsf.xml" if {[file exists $FichierRsfXml]} { file rename $FichierRsfXml $FichierXml } if { ! [file exists $FichierRsfRsf]} { set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message" Warne $MonMessage if {$FichierLog!=""} { AppendAuFichier $FichierLog $MonMessage } } else { file rename $FichierRsfRsf $FichierRsf } foreach Mot [split $Delete "_"] { set F "Fichier$Mot" if {[regexp {\.$} $F]} { set FSansPoint [string trimright $F "."] if { ! [info exists $FSansPoint]} { continue } foreach FF [glob -nocomplain "[set $FSansPoint].*"] { file delete $FF } } else { if { ! [info exists $F]} { continue } foreach FF [glob -nocomplain "[set $F]*"] { file delete $FF } } } if {$GetRsf=="DeleteRsfFile"} { file delete $FichierRsf } if {$GetXml=="DeleteXmlFile"} { file delete $FichierXml } if {$GetRsf=="GetRsfText"} { set Rsf [ContenuDuFichier $FichierRsf] file delete $FichierRsf return $Rsf } if {$GetXml=="GetXmlText"} { set Xml [ContenuDuFichier $FichierXml] file delete $FichierXml return $Xml } return $FichierXml } proc MacsimsCodification {SX El} { global MacsimsCodification set El [string tolower $El] if {[info exists MacsimsCodification($SX,$El)]} { return $MacsimsCodification($SX,$El) } if {[info exists MacsimsCodification("EstCharge")]} { return $Ele } set MacsimsCodification("EstCharge") 1 set MacsimsCodification(Sql,macsim) "MACSIMS" set MacsimsCodification(Sql,alignment) "MACSIMS" set MacsimsCodification(Sql,sequence) "SEQ" set MacsimsCodification(Sql,column-score) "COLSCORE" set MacsimsCodification(Sql,freetext) "FREETEXT" set MacsimsCodification(Sql,consensus) "CONSENSUS" set MacsimsCodification(Sql,surface-accessibility) "SURFACC" set MacsimsCodification(Xml,macsims) "macsim" set MacsimsCodification(Xml,alignment) "aln" set MacsimsCodification(Xml,sequence) "seq" set MacsimsCodification(Xml,column-score) "colsco" set MacsimsCodification(Xml,freetext) "freetext" set MacsimsCodification(Xml,consensus) "cons" set MacsimsCodification(Xml,surface-accessibility) "suracc" set MacsimsCodification(ListOf,keys) [lsort -unique [array names MacsimsCodification]] return [MacsimsCodification $SX $El] } proc MacsimsExe {} { global tcl_platform global OrdBinDir global env if {[info exists env(GRILLE)] && $env(GRILLE)} { return "./macsim" } if {[set tcl_platform(platform)] != "windows"} { if {[info exists OrdBinDir]} { return [file join $OrdBinDir "macsim"] } else { return "/biolo/macsim/macsim" } } else { set lexe [file join $OrdBinDir "macsim.exe"] regsub "Program Files" $lexe "PROGRA~1" lexe return $lexe } } proc MacsimsFromText {TexteMsf} { if { ! [regexp "\n" $TexteMsf] && [file exists $TexteMsf]} { set TexteMsf [ContenuDuFichier $TexteMsf] } if { ! [regexp "\n" $TexteMsf]} { set TexteMsf [Base64Decode $TexteMsf] } set FichierMsf "[TmpFile].msf" Sauve $TexteMsf dans $FichierMsf set Xml [Macsims $FichierMsf "GetXmlText"] file delete $FichierMsf return $Xml } proc MacsimsGrid {pab} { global DefautsPipe global PipeCollection global BestPdb global NQuery global laddSeq set bchx [set DefautsPipe(Macsims,bestmsf)] if {$PipeCollection} { if {[QuelProjet] eq "ms2phdb"} { set fileBestMsf [file join [RepertoireDuGenome] "empreinte" $pab.msf] if {![file exists $fileBestMsf]} {return 0} } else { set fileNormd [file join [RepertoireDuGenome] "normd" $pab] if {![file exists $fileNormd]} {return 0} set rbest [string tolower [DefineBestMsfPipe $fileNormd $bchx]] if {$rbest eq "no file"} {return 0} puts "rbest est $rbest" AjouteAuLogPipe "rbest est $rbest" #AF #verif presence addSeq si necessaire if {[QuelProjet] eq "addSeq" && $rbest eq "leon" } { set rbest [VerifPresenceAddSeq $pab] if {$rbest ne "leon"} { puts "\[addSeq\] bestAli est $rbest" AjouteAuLogPipe "\[addSeq\] bestAli est $rbest" } } ## set fileBestMsf [file join [RepertoireDuGenome] $rbest $pab] } set fileMacsimsTmp [file join [RepertoireDuGenome] "macsims" $pab.tmp] set fileMacsims [file join [RepertoireDuGenome] "macsims" $pab.xml] if {[file exists $fileMacsims]} {return 1} } else { set fileNormd "[file rootname $pab].normd" if { [file exists $fileNormd]} { set rbest [string tolower [DefineBestMsfPipe $fileNormd $bchx]] if {$rbest eq "no file"} {return 0} puts "rbest est $rbest" AjouteAuLogPipe "rbest est $rbest" if {[QuelProjet] eq "addSeq" && $rbest eq "leon" } { set rbest [VerifPresenceAddSeq $pab] if {$rbest ne "leon"} { puts "\[addSeq\] bestAli est $rbest" AjouteAuLogPipe "\[addSeq\] bestAli est $rbest" } } if {[QuelProjet] eq "addSeq" && $rbest eq ".leon" } { set rbest [VerifPresenceAddSeq $pab] if {$rbest ne ".leon"} { puts "[addSeq] bestAli est $rbest" AjouteAuLogPipe "\[addSeq\] bestAli est $rbest" } } if {$rbest eq "msf"} { set rbest "" } else { set rbest ".$rbest" } set fileBestMsf "[file rootname $pab]$rbest.msf" set fileMacsimsTmp "[file rootname $pab].macsims.tmp" set fileMacsims "[file rootname $pab].macsims.xml" } else { set fileBestMsf $pab set fileMacsimsTmp "[file rootname $pab].macsims.tmp" set fileMacsims "[file rootname $pab].macsims.xml" } } # Calcul du MACSIM set CommandeMacsims "[MacsimsExe] $fileBestMsf $fileMacsimsTmp" if {[catch {eval exec $CommandeMacsims} Message]} {puts "$Message"} if {[QuelProjet] eq "ms2phdb"} { set CommandeQuery2First "[Query2FirstExe] $fileMacsimsTmp.xml $NQuery $fileMacsims" if {[catch {eval exec $CommandeQuery2First} Message]} {puts "$Message"} } else { catch {file rename -force $fileMacsimsTmp.xml $fileMacsims} } if {[file exists $fileMacsims]} { AjouteAuLogPipe "macsims = ok" return 1 } else { AjouteAuLogPipe "macsims failed" return 0 } } proc MacsimsInfo {args} { global MacsimsInfo #rR calls ParseMACSIMS from Nicolas Gagniere set Qui [lindex $args 0] set Quoi [lindex $args 1] if {[regexp -nocase "LoadXml" $Qui]} { set Fichier $Quoi if {[info exists MacsimsInfo(File)]} { if {[string equal -nocase "ReLoadXml" $Qui] || $MacsimsInfo(File)!=$Fichier} { unset MacsimsInfo } } if { ! [info exists MacsimsInfo(File)]} { if {[FileAbsent $Fichier]} { FaireLire "$Fichier\ndoesn't exist" return "" } ParseMACSIMS $Fichier MacsimsInfo # parray MacsimsInfo; exit; set MacsimsInfo(File) $Fichier set LesKey1 {} set LesFeaturesKeys {} foreach X [array names MacsimsInfo] { set LesKey [split $X ","] set Key1 [lindex $LesKey 1] lappend LesKey1 $Key1 if {$Key1=="Features"} {lappend LesFeaturesKeys [lindex $LesKey 3]} } set LesKey1 [ListeSansDoublon $LesKey1] set MacsimsInfo(ListOf,Key1) $LesKey1 set LesFeaturesKeys [ListeSansDoublon $LesFeaturesKeys] set MacsimsInfo(ListOf,FeaturesKeys) $LesFeaturesKeys set args [lrange $args 2 end] # parray MacsimsInfo if {$args=={}} { return $MacsimsInfo(File) } } } set Tout [join $args ","] if {[info exists MacsimsInfo($Tout)]} { return $MacsimsInfo($Tout) } return "" } proc MacsimsOlida {FichierMSF FichierOut} { if {![file isfile $FichierMSF]} {return} if {[catch {exec [ExecPath macsim] $FichierMSF $FichierOut >& /dev/null} Message] == 1} { Espionne "Error from macsims. Message follows \n$Message" } return $FichierOut } proc MacsimsOnWeb {Msf {FichierXml ""}} { if {$FichierXml==""} { set FichierXml "GetXml" } if { ! [regexp "\n" $Msf] && [file exists $Msf]} { set Msf [ContenuDuFichier $Msf] } set Msf64 [Base64Encode $Msf] set Query [::http::formatQuery "TexteMsf" $Msf64] ] set Xml [HttpGetUrl "[LbgiUrl]/~ripp/cgi-bin/WscopeServer.tcl?science=Zero&commande=MacsimsFromText" $Query] if {$FichierXml=="GetXml"} { return $Xml } if {[regexp {^//} $FichierXml]} { regsub {^//} $FichierXml "[RepertoireDuGenome]/" FichierXml } return [Sauve $Xml dans $FichierXml] } proc MacsimsPourAnnotation {Nom {AvecOuSansOrganismeEtudie ""}} { set FichierSource "[RepertoireDuGenome]/prottfa/$Nom.leon.msf" if {![file isfile $FichierSource]} { set FichierSource "[RepertoireDuGenome]/msfleon/$Nom" if {![file isfile $FichierSource]} {return} } set FichierSortie "[RepertoireDuGenome]/prottfa/$Nom.macsims" if {[OptionsProtocoleAnnotation "OptionsGlobales,AvecGarde"] && [file isfile $FichierSortie]} {return} set Commande "/biolo/macsim/macsim" catch {exec $Commande $FichierSource $FichierSortie} } proc MacsimsReduit {} { # macsims reduit n'enleve pas les gaps inutiles package require tdom set RepertoireProches "[RepertoireDuGenome]/ProchesQuery85" foreach Box [ListeDesPABs] { if {[regexp -nocase "Mouse" [RepertoireDuGenome]] || [regexp -nocase "Rat" [RepertoireDuGenome]]} { set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} } else { set Cluster [ExtraitInfo $Box "Cluster"] set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ajout.ordonne" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.new.ordonne"} } set fh [open $FileMacsims "r"] dom parse -channel $fh doc close $fh $doc documentElement root dom createDocument macsim doc2 $doc2 documentElement root2 $doc2 createElement alignment ali $root2 appendChild $ali set ListeDesGroup [GroupDeMaSelection $Box] foreach seq [$root selectNodes "//sequence"] { set Name [$seq selectNodes "string(./seq-name)"] set Group [$seq selectNodes "string(./seq-info/group)"] foreach GroupVoulu $ListeDesGroup { if {$Group==$GroupVoulu} { $ali appendChild $seq break } } } set fh2 [open $FileMacsims.reduit "w"] puts $fh2 "" $doc2 asXML -channel $fh2 -doctypeDeclaration 0 close $fh2 $doc delete $doc2 delete } } proc MacsimsSpliRetPourNaomi {{Compress ""}} { set Compress [regexp -nocase "^Comp" $Compress] set SourceDir "[RepertoireDuGenome]/macsimXml" if {$Compress} { set DestinDir "[RepertoireDuGenome]/macsimXmlPourNaomiGZ" } else { set DestinDir "[RepertoireDuGenome]/macsimXmlPourNaomi" } file mkdir $DestinDir set I 1 foreach Nom [ListeDesPABs] { if {[incr I -1]==0} { Espionne $Nom; set I 100 } set Clus [ExtraitInfo $Nom "Cluster"] set Fic "$SourceDir/$Nom.orgord.aj" if {[FileAbsent $Fic]} { set Fic "$SourceDir/$Nom.orgord" } if {[FileAbsent $Fic]} { continue } if {$Compress} { set Out "$DestinDir/$Nom-$Clus.xml.gz" exec gzip -c $Fic > $Out } else { set Out "$DestinDir/$Nom-$Clus.xml" file copy $Fic $Out } } } proc MacsimsVariables {{Init ""}} { #rR Si Init n initialise toutes les listes a vide et les tableau au tableau vide #rR On rend [list $LesL $LesT] #rR les strings (AlnScore, etc.) sont traités comme des listes set Init [regexp -nocase {^(Y|1|Init)} $Init] set LesL [list AlnName AlnScore AlnNote LNDG LNOrdali] foreach L $LesL { global $L if {$Init} { set $L {} } } set LesT [list Sequences TabSF TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW TDesStatus TDesWeight TDesSense TDesScore TDesScore TDesLength TColScore LesSeqsDuGroupe SDG LesSequencesAssocieesClassesCanon] foreach T $LesT { global $T if {$Init} { array set $T [list] } } return [list $LesL $LesT] # foreach t {TDesHydro TDesSeqnames TDespI TDesAccess TDesPhylum TDesGO TDuLineage TDesOrganismes TDesTaxId TDesFragment TDuGroupeDesSeqs TDesEC TDesComplex TDesBId TDesDescriptifs TDesMolW} { # array set $t [list] # } # return } proc Maf2fasta {RefSeq Ordered_ProjectedMafFile FileOUT {OutputFormat ""} {Beg ""} {End ""}} { ### Reformats a projected MAF file (multiple alignment) in MultiPipMaker or MultiFastaFormat # Beg and End = begin and end of the projected multiple alignment to reformat # OutputFormat: default ("") --> MultiPipMaker # fasta --> fasta # fasta2 --> fasta with 50 residues long lines #Espionne "Maf2fasta ..." #set Commande "exec [PATH maf2fasta] $RefSeq $Ordered_ProjectedMafFile $Beg $End $OutputFormat > $FileOUT" set Commande "exec maf2fasta $RefSeq $Ordered_ProjectedMafFile $Beg $End $OutputFormat > $FileOUT" ##################################################################################################### #puts "$Commande" if {[catch {eval $Commande} Message]} {Espionne $Message ; return} return $FileOUT } proc Maf_order {MafFile LesSpecies MafOrderedFile} { ### Execution du programme maf_order ### # LesSpecies = species that need to be included in the ordered file # the ordering of the components in a maf block follows the ordering of the species names in the arguments. # Species not in the arguments are excluded #Espionne "Maf_order ..." if {![file exists $MafFile]} {puts "MafFile: $MafFile does not exists" ; return} #set Commande "exec [PATH maf_order] $MafFile " set Commande "exec maf_order $MafFile " foreach Specie $LesSpecies { append Commande " $Specie" } append Commande " > $MafOrderedFile" #puts "Commande: $Commande" if {[catch {eval $Commande} Message]} {Espionne $Message;return} return $MafOrderedFile } proc Maf_project {MafFile ReferenceSequence Maf_projectMafFile} { ### Execution du programme maf_project ### # Reference seq in the top row of each block # # Maf blocks ordered by the starting position of thetop row # Espionne "Maf_project ..." if {![file exists $MafFile]} {Espionne "MafFile: $MafFile does not exists" ; return} #set Commande "exec [PATH maf_project] $MafFile $ReferenceSequence > $Maf_projectMafFile" set Commande "exec maf_project $MafFile $ReferenceSequence > $Maf_projectMafFile" if {[catch {eval $Commande} Message]} {Espionne $Message;return} return $Maf_projectMafFile } proc Mafft_AddSequences {fali fseqs} { if {[file exists $fali]} { set ali [ContenuDuFichier $fali] } elseif {[string first "\n" $fali] > -1} { set ali $fali } elseif {[llength $fali] > 1} { set ali [join $fali "\n"] } if {[file exists $fseqs]} { set seqs [ContenuDuFichier $fseqs] } elseif {[string first "\n" $fseqs] > -1} { set seqs $fseqs } elseif {[llength $fseqs] > 1} { set seqs [join $fseqs "\n"] } set url "http://ddbj.nig.ac.jp/wabi/mafft/" set query [::http::formatQuery "format" "text" "querySequence" "$ali" "addSequence" "$seqs" "parameters" "--globalpair --maxiterate 1000" "result" "www"] set ok [HttpCopy $url res $query] puts "ok submit $ok" puts "res submit $res" if {! $ok} { puts "ERROR in Mafft_AddSequences !\nCannot send request to server\n" return "" } set id [lindex $res 0] regsub -all { +} $id " " id set id [lindex [split $id " "] 1] puts "id= $id" # check job status set urlStatus "$url${id}" while {1} { set ok [HttpCopy $urlStatus res] puts "ok status $ok" puts "res= \n$res" if {! $ok} { puts "ERROR in Mafft_AddSequences !\nCannot retrieve job status !\n" return "" } set istatus [lsearch -regexp $res {^status:}] set statusLine [lindex $res $istatus] regsub -all { +} $statusLine " " statusLine set status [lindex [split $statusLine " "] 1] puts "status $status" if {$status in {"waiting" "running"}} { after 5000 } elseif {$status eq "finished"} { break } else { puts "ERROR in Mafft_AddSequences !\nUnknown status : $status" return "" } } # Now get results set urlResult "$url${id}?info=result" puts $urlResult set resR "" set ok [HttpCopy $urlResult resR] set tmp [HttpCopy $urlResult] puts "tmp\n$tmp" puts "ok result $ok" puts "res=\n$resR" if {! $ok} { puts "ERROR in Mafft_AddSequences !\nCannot get results\n" return "" } return $resR } proc Mafft_AddSequences_local {fali fseqs} { if {! [file exists $fali]} { if {[llength $fali] > 1} { set fali [join $fali \n] } set nali "/tmp/ali_[pid]_[clock scan now].tfa" set o [open $nali w] puts $o $fali close $o } else { set nali $fali } if {! [file exists $fseqs]} { if {[llength $fseqs] > 1} { set fseqs [join $fseqs \n] } set nseqs "/tmp/seqs_[pid]_[clock scan now].tfa" set o [open $nseqs w] puts $o $fseqs close $o } else { set nseqs $fseqs } set nout "/tmp/out_[pid]_[clock scan now].tfa" #set pb [catch {exec csh -c "setmafft ; mafft --add $nseqs $nali > $nout 2> /tmp/error.log"} out] set pb [catch {exec csh -c "setmafft ; mafft --add $nseqs $nali > $nout"} out] set res [ContenuDuFichier $nout] if {[string index $res 0] eq ">"} { set res [split $res \n] set pb 0 } if {$pb} { puts "Error in MAFFT !" set res "" puts "\nMsg:\n$out" #set pb [catch {exec /biolo/mafft/mafft --add $nseqs $nali > $nout 2> /tmp/error.log"} out] } file delete $nali $nseqs $nout return $res } proc MagosDir {} { return "/genomics/link/Magos" } proc Maigrir {{Quoi blastp} {Combien ""} {NomVoulu ""} {NewRep ""}} { if {$Combien==""} { set Combien 13 } set Rep "[RepertoireDuGenome]/$Quoi" if {$NewRep==""} { set NewRep $Quoi } if { ! [regexp "/" $NewRep]} { set NewRep "[RepertoireDuGenome]/$NewRep" } if { ! [OuiOuNon "I will reduce the blast segment alignments to $Combien\n from $Rep \nto $NewRep\n OK ?" 0]} { return 0 } if {$NomVoulu==""} { set Liste [ListeDesPABs] } else { set Liste [list $NomVoulu] } foreach Nom $Liste { set FichierAvant "$Rep/$Nom" if { ! [file exists $FichierAvant]} { continue } set FichierApres "$NewRep/$Nom" if {[file exists $FichierApres]} { continue } set ListeDesLignes [LesLignesDuFichier $FichierAvant] set LongAvant [llength $ListeDesLignes] scan [join [lrange $ListeDesLignes 0 3] " "] "%s" PremierMot set PremierMot [string toupper $PremierMot] # set PourBlastP [string equal -nocase $PremierMot "BLASTP"] # set PourBallast [string equal -nocase $PremierMot "Ballast"] # set PourTBlastX [string equal -nocase $PremierMot "TBLASTX"] # set PourBlastN [string equal -nocase $PremierMot "BLASTN"] # set PourTBlastN [string equal -nocase $PremierMot "TBLASTN"] set PourBlastP [expr ! [string compare $PremierMot "BLASTP"]] set PourBlastX [expr ! [string compare $PremierMot "BLASTX"]] set PourTBlastX [expr ! [string compare $PremierMot "TBLASTX"]] set PourBlastN [expr ! [string compare $PremierMot "BLASTN"]] set PourTBlastN [expr ! [string compare $PremierMot "TBLASTN"]] set PourBallast [expr ! [string compare $PremierMot "BALLAST"]] if { ! [expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} { Warne "$Fichier is not a blast file. I skipp it." continue } set Encore $Combien set LeNouveau {} set LongApres 0 foreach Ligne $ListeDesLignes { if {[regexp "^>" $Ligne]} { if { ! [incr Encore -1]} { break } } incr LongApres lappend LeNouveau $Ligne } SauveLesLignes $LeNouveau dans $FichierApres Espionne "$Nom a maigri de $LongAvant a $LongApres" } return 1 } proc MailAuxDestinataires {FichierTXTCommandeOligos {LesDestinataires ""} {Sujet ""}} { if {$LesDestinataires=={}} { set LesDestinataires {} lappend LesDestinataires "Peggy.Mathon@igbmc.u-strasbg.fr" lappend LesDestinataires "Marie.Herledan@igbmc.u-strasbg.fr" lappend LesDestinataires "Marie-France.Tinland@igbmc.u-strasbg.fr" lappend LesDestinataires "Didier.Busso@igbmc.u-strasbg.fr" lappend LesDestinataires "Sylvia.Eiler@igbmc.u-strasbg.fr" lappend LesDestinataires "Arnaud.Poterszman@igbmc.u-strasbg.fr" lappend LesDestinataires "Raymond.Ripp@igbmc.u-strasbg.fr" lappend LesDestinataires "europrim@invitrogen.com" set LesDestinataires [ChoixDesPresents $LesDestinataires] } if {$Sujet==""} { set Sujet [Entre "[file tail $FichierTXTCommandeOligos]"] } if {$LesDestinataires=={}} { return {} } foreach Destinataire $LesDestinataires { Espionne [MailFichier $FichierTXTCommandeOligos $Destinataire $Sujet] } return $LesDestinataires } proc MailFichier {Fichier {Destinataire ""} {Sujet ""}} { global env if {$Destinataire==""} { set MySelf [set env(USER)] set Destinataire "$MySelf@lbgi.fr" } if { ! [file exists $Fichier]} { FaireLire "$Fichier doesn't exist. Sorry" return "" } if {$Sujet==""} { set Sujet [file tail $Fichier] regsub ".txt$" $Sujet "" Sujet set Subject "Commande oligos $Sujet" } else { set Subject $Sujet } set Message "" set CommandeMail "mail" if {[info exists env(HOSTTYPE)] && $env(HOSTTYPE)=="alpha"} { set CommandeMail "mailx" } if {[catch {exec $CommandeMail -s $Subject $Destinataire < $Fichier} Message]} { FaireLire "Error during mail. \nI got following error message :\n$Message" return $Message } return $Fichier } proc MailLbgi {{Qui ""} {Quoi ""}} { global MailLbgi if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "nmpnlb" } set Qui [string toupper $Qui] set Quoi [string toupper $Quoi] if {$Qui=="LIST"} { set Qui "LISTOF" } if {$Qui=="RELOAD" && [info exists MailLbgi]} { unset MailLbgi set Qui "" set Quoi "" return [MailLbgi] } regsub -all "LOGIN" $Quoi "L" Quoi regsub -all "PRENOM" $Quoi "P" Quoi regsub -all "NOM" $Quoi "N" Quoi regsub -all "MAIL" $Quoi "M" Quoi if {[info exists MailLbgi($Qui,$Quoi)]} { if {[PourWscope] && $Qui=="LISTOF"} { return "

\n[join $MailLbgi($Qui,$Quoi) \n]\n

" } return $MailLbgi($Qui,$Quoi) } if {[info exists MailLbgi("EstCharge")]} { if {[regexp {^[LNPMB]+$} $Quoi]} { set LesL $MailLbgi(LISTOF,L) set LesN $MailLbgi(LISTOF,N) set LesP $MailLbgi(LISTOF,P) set LesM $MailLbgi(LISTOF,M) set LeToutBeau {} foreach X [split $Qui ","] { set PourQui($X) 1 } EspionneL [array get PourQui] foreach L $LesL N $LesN P $LesP M $LesM { set B "$P.$N" if {$Qui!="LISTOF" && ! [info exists PourQui([string toupper $L])] && ! [info exists PourQui([string toupper $N])] && ! [info exists PourQui([string toupper $M])] && ! [info exists PourQui([string toupper $B])]} { continue } set LaLigne {} foreach X [split $Quoi ""] { set F "%-18s" if {$X=="M"} { set F "%40s" } if {$X=="B"} { set F "%-30s" } lappend LaLigne [format $F [set $X]] } lappend LeToutBeau [join $LaLigne " "] } set LeToutBeau [lsort $LeToutBeau] if {[PourWscope]} { return "

\n[join $LeToutBeau \n]\n

" } return $LeToutBeau } return "" } set MailLbgi("EstCharge") 1 set MailLbgi(FILENAME,) "[HomeRipp]/rh/maillbgi.txt" set LesLNPM [LesLignesDuFichier $MailLbgi(FILENAME,)] set LeToutBeau {} foreach LNPM $LesLNPM { regsub -all {[ ]+} $LNPM " " LNPM lassign [split $LNPM " "] l n p m set b "$p.$n" lappend LeToutBeau [format "%-18s %-18s %-18s %40s %-30s" $l $n $p $m $b] set L [string toupper $l] set N [string toupper $n] set P [string toupper $p] set B [string toupper $b] set M [string toupper $m] set MailLbgi($L,L) $l set MailLbgi($L,N) $n set MailLbgi($L,P) $p set MailLbgi($L,M) $m set MailLbgi($L,B) $b set MailLbgi($N,L) $l set MailLbgi($N,N) $n set MailLbgi($N,P) $p set MailLbgi($N,M) $m set MailLbgi($N,B) $b set MailLbgi($B,L) $l set MailLbgi($B,N) $n set MailLbgi($B,P) $p set MailLbgi($B,M) $m set MailLbgi($B,B) $b set MailLbgi($M,L) $l set MailLbgi($M,N) $n set MailLbgi($M,P) $p set MailLbgi($M,M) $m set MailLbgi($M,B) $b lappend MailLbgi($P,L) $l lappend MailLbgi($P,N) $n lappend MailLbgi($P,P) $p lappend MailLbgi($P,B) $b lappend MailLbgi($P,M) $m lappend MailLbgi(LISTOF,L) $l lappend MailLbgi(LISTOF,N) $n lappend MailLbgi(LISTOF,P) $p lappend MailLbgi(LISTOF,B) $b lappend MailLbgi(LISTOF,M) $m } set MailLbgi(LISTOF,ALL) $LeToutBeau return [MailLbgi $Qui $Quoi] } proc MailServerChooser {} { global db CMDef set Lname [$db eval {select distinct name, username from mailbox}] if {[llength $Lname] == 2} { return } # Are we coming from MMMInterface ? if {[llength [winfo children .]] > 0} { set w .chooser toplevel $w } else { set w . } grid columnconfig $w all -weight 1 grid rowconfig $w all -weight 1 $w configure -background $::CMDef(Background) set w "$w.ftop" ttk::frame $w -style MMM.TFrame grid $w -row 0 -column 0 -sticky news -padx 20 -pady 20 grid rowconfig $w all -weight 1 grid columnconfig $w all -weight 1 ttk::label $w.lab -text "Choose a mailbox :" -style MMM.TLabel grid $w.lab -row 0 -column 0 -sticky ew # frame for mailboxxes ttk::frame $w.fb -style MMM.TFrame grid $w.fb -row 1 -column 0 -sticky news set r 0 ; set c 0 foreach {name user} $Lname { set nameNS [string map {" " "" "\"" "" ' ""} $name] button $w.fb.b$nameNS -text "\n $name \n" -font CMFontBold -background green -foreground white -command [list ChangeMailbox $name $user $w] grid $w.fb.b$nameNS -row $r -column $c -padx 5 -pady 5 incr c if {$c == 3} { set c 0 incr r } } FenetreAuCentre $w tkwait variable ::CMDef(imapID) update idletasks return } proc MainJumeaux {{Qui LaTotale} {NOuP ""} {Banque ""} {PIdentity 0.95} {PCoverQuery 0.95} {PCoverSubject 0.95}} { Wup "Marche a suivre pour se debarasser des Jumeaux" Wup "Calcul les blast pour toutes les sequences contre une banques constituee de toutes nos sequences" Wup "Calcul des plus proches: Identite globale classique + Recouvrement Q/S et S/Q" Wup "Creation de 4 types de fichier:" Wup " Jumeaux.log : fichier contenant les infos de l'etape de calcul des plus proches" Wup " TousLesJumeaux : fichier contenant chaque PAB et ces Jumeaux" Wup " TousLesJumeaux.trie : fichier debarasse des redondances et avec les jumeaux" Wup " TousLesJumeaux.final : fichier ordonnee en fonction de la banque et de la taille" global RepDesSequences set DirDesJumeaux "[RepertoireDuGenome]/Jumeaux" set FichierJumeaux "$DirDesJumeaux/TousLesJumeaux" set FichierJumeauxTrie "${FichierJumeaux}.trie" set FichierJumeauxFinal "${FichierJumeaux}.final" if {! [file exists $DirDesJumeaux]} {file mkdir $DirDesJumeaux} if {! [OuiOuNon "Would you like to determine first Twins ?"]} {return ""} set Texte "You will need a few step to begin:\n" append Texte "Step 0-1 : Blast database creation and selection\n" append Texte "Step 0-2 : Query selection\n" append Texte "Step 0-3 : Parameters setting\n" append Texte " Global ID percent\n" append Texte " Alignement Cover percent (Query over Subject)\n" append Texte " Alignement Cover percent (Subject over Query)\n\n" append Texte "Then it will go with 4 processing steps:\n" append Texte "Step 1 : Blast searches all against all\n" append Texte "Step 2 : Twins determination for each sequence\n" append Texte "Step 3 : Removing each duplicated cluster of twins\n" append Texte "Step 4 : Ranking within each cluster the best sequence (Database, Length)" FaireLire "$Texte" #1-BLAST DATABASE CREATION AND SELECTION if {! [OuiOuNon "Have you already define the blast database ?"]} { while {1} { if {[OuiOuNon "Have you a file with all your sequences in fasta format (tfa)"]} { set NomDuFichierTFA [tk_getOpenFile -title "Choose a file" -initialdir "[RepertoireDuGenome]"] if {$NomDuFichierTFA==""} {continue} else {break} } else { if {[OuiOuNon "Choose a directory containing all your fasta files\nThen enter the name of the file which will contain all of them and at the end the name of the blast database"]} { while {1} { set RepDeTravail [tk_chooseDirectory -title "Choose a directory" -initialdir "[RepertoireDuGenome]"] if {$RepDeTravail ==""} {continue} else {break} } while {1} { set NomDuFichierTFA [Entre "NomDuFichierTFA" ] if {$NomDuFichierTFA==""} {continue} else {break} } set NomDuFichierTFA "$DirDesJumeaux/$NomDuFichierTFA" ReunitMesTFAs $RepDeTravail $NomDuFichierTFA break } } } set NOuP "" while {$NOuP==""} { if {[OuiOuNon "Are they proteins ?"]} { set NOuP "P" } elseif {[OuiOuNon "So DNA ?"]} { set NOuP "N" } else {set NOuP ""} } while {1} { set NomDeLaBanque [Entre "NomDeLaBanqueBlast"] if {$NomDeLaBanque==""} {continue} else {break} } set NomDeLaBanque "$DirDesJumeaux/$NomDeLaBanque" CreeBanqueBlastDuProjet $NomDuFichierTFA $NomDeLaBanque $NOuP } else { while {1} { FaireLire "Please select blast database.\nYou can choose any .xxx file from your database" set NomDeLaBanque [tk_getOpenFile -title "Choose blast database" -initialdir "$DirDesJumeaux"] if {$NomDeLaBanque==""} {continue} set NOuP "" while {$NOuP==""} { if {[OuiOuNon "Are they proteins ?"]} { set NOuP "P" } elseif {[OuiOuNon "So DNA ?"]} { set NOuP "N" } else {set NOuP ""} } break } } if {[regexp {\.[a-z]{3}$} $NomDeLaBanque]} {regsub {\.[a-z]{3}$} $NomDeLaBanque "" NomDeLaBanque} if {$NOuP == "N"} { set RepDesSequences "[RepertoireDuGenome]/nuctfa" } elseif {$NOuP == "P"} { set RepDesSequences "[RepertoireDuGenome]/prottfa" } else { set RepDesSequences "[RepertoireDuGenome]/nuctfa" } #2-QUERY SELECTION if {[OuiOuNon "I will use $RepDesSequences to search your Query Sequences.\nWould you like to change it?"]} { while {1} { set RepDesSequences [tk_chooseDirectory -title "Choose a directory" -initialdir "[RepertoireDuGenome]"] if {$RepDesSequences==""} {continue} else {break} } } if {[OuiOuNon "Would you like to use only a subset of all Querys ?"]} { set Qui "" set LesQui "" set LesQuerys [glob -nocomplain -directory "$RepDesSequences" "*"] regsub -all "$RepDesSequences/" $LesQuerys "" LesQuerys set Qui [MorceauxChoisis $LesQuerys] #set Qui [MorceauxChoisis [ListeDesPABs]] if {$Qui == ""} {return ""} } #3-PARAMETERS SELECTION if {[OuiOuNon "Would you like to change Twins selections parameters ?\n1-ID 0.95\n2-Cover Q/S 0.95\n3-Cover S/Q 0.95"]} { FaireLire "First: Global Identity Percent." while {1} { set PIdentity [Entre "0.95"] if {$PIdentity ==""} {continue} else {break} } FaireLire "Second: Cover Percent Q/S." while {1} { set PCoverQuery [Entre "0.95"] if {$PCoverQuery ==""} {continue} else {break} } FaireLire "Third: Cover Percent S/Q." while {1} { set PCoverSubject [Entre "0.95"] if {$PCoverSubject==""} {continue} else {break} } } if {[OuiOuNon "Would you like to change Output file names ?"]} { while {1} { set FileName "[Entre "TousLesJumeaux"]" if {$FileName==""} {continue} set FichierJumeaux "$DirDesJumeaux/$FileName" set FichierJumeauxTrie "${FichierJumeaux}.trie" set FichierJumeauxFinal "${FichierJumeaux}.final" break } } else { set FichierJumeaux "$DirDesJumeaux/TousLesJumeaux_${PIdentity}_${PCoverQuery}_${PCoverSubject}" set FichierJumeauxTrie "${FichierJumeaux}.trie" set FichierJumeauxFinal "${FichierJumeaux}.final" } Espionne "\nFirst Twins Creation" Espionne "Step 1 : Blast searches all against all" #Calcul tous les fastas et blasts MesBlastsPourLesJumeaux $Qui $NomDeLaBanque $NOuP Espionne "Step 2 : Twins determination for each sequence" #Calcul les Jumeaux avec les proches dans le blast MesJumeaux $Qui $PIdentity $PCoverQuery $PCoverSubject $FichierJumeaux Espionne "Step 3 : Removing each duplicated cluster of twins" #Calcul les Jumeaux avec les proches dans le blast RegroupeLesVraisJumeaux $FichierJumeaux $FichierJumeauxTrie Espionne "Step 4 : Ranking within each cluster the best sequence (Database, Length)" #Calcul les Jumeaux avec les proches dans le blast CalculLeFichierOrdonneDesJumeaux $FichierJumeauxTrie $FichierJumeauxFinal $NOuP #Espionne "Step 5 : On calcule les nouvelle bornes" #CreeLesNouvellesBornesDesPABsLocChevauchantes $FichierJumeauxFinal #CreeLesNouvellesBornesDesPABs $FichierJumeauxFinal return "" } proc MainLevee {K x y Action} { global IdScrollRectangle global LesCouleursPourMainLevee global LesTaillesPourMainLevee global DernierXDuTouche DernierYDuTouche global BufferMainLevee set X [$K canvasx $x] set Y [$K canvasy $y] set Touche [$K find withtag current] if {[info exists IdScrollRectangle($K)] && $Touche==[set IdScrollRectangle($K)]} { if {[regexp "Point|Motion" $Action]} { return } } set ItemType [$K type $Touche] if {$Action == "Motion"} { $K move $Touche [expr $x-$DernierXDuTouche] [expr $y-$DernierYDuTouche] set DernierXDuTouche $x set DernierYDuTouche $y return } if {$Action == "Point"} { set DernierXDuTouche $x set DernierYDuTouche $y return } if {$Action=="Modif"} { set LesActions {"Erase" "Size" "Color" "Raise" "Lower" "Copy" "Paste" "EditWidget" "New"} if {$ItemType=="text"} { lappend $LesActions "Text" } set Action [ChoixParmi $LesActions] if {$Action == "" } { return } } if {$Action == "Erase"} { if { ! [OuiOuNon "Do you really want to erase this $ItemType"]} { return 0 } $K delete $Touche return 1 } if {$Action == "Raise"} { $K raise $Touche return "Raise" } if {$Action == "Lower"} { $K lower $Touche if {[info exists IdScrollRectangle($K)]} { $K lower [set IdScrollRectangle($K)]} return "Lower" } if {$Action == "Color"} { set OldCouleurFill [$K itemcget $Touche -fill] if {[set CouleurFill [UneCouleurPourMainLevee $OldCouleurFill]]=="Cancel"} { return "" } $K itemconfigure $Touche -fill $CouleurFill if { ! [regexp "arc|polygon|rectangle" $ItemType] || ! [OuiOuNon "Do You want to change the Outline Color ?"]} { return $CouleurFill } set OldCouleurOutline [$K itemcget $Touche -outline] if {[set CouleurOutline [UneCouleurPourMainLevee $OldCouleurOutline]]=="Cancel"} { return "" } $K itemconfigure $Touche -outline $CouleurOutline return $CouleurFill } if {$Action == "Size"} { if {[set Taille [UneTaillePourMainLevee]]==""} { return } ScanLaListe [Barycentre [$K coords $Touche]] CX CY $K scale $Touche $CX $CY $Taille $Taille if {$ItemType == "arc" && $Taille == "Copy"} { set Extent [$K itemcget $Touche -extent] $K itemconfigure $Touche -extent [expr $Extent*[Entre 0.9]] return } if {$ItemType == "arc" && $Taille == "Extent"} { set Extent [$K itemcget $Touche -extent] $K itemconfigure $Touche -extent [expr $Extent*[Entre 0.9]] return } if {$ItemType == "line" && $Taille == "Arrow"} { set AvAr [$K itemcget $Touche -arrow] if {$AvAr=="first"} { set AvAr "last" } else { set AvAr "first" } $K itemconfigure $Touche -arrow $AvAr return } if {$Taille == "Other"} { set Taille [Entre 21] if {$Taille == ""} { return "" } lappend LesTaillesPourMainLevee $Taille } if { $ItemType=="arc" || $ItemType=="line" } { $K itemconfigure $Touche -width $Taille return $Taille } if { $ItemType=="text"} { $K itemconfigure $Touche -font [list Courier $Taille] return $Taille } } if {$Action == "Text"} { set Texte [Entre [$K itemcget $Touche -text]] if {$Texte == ""} { return "" } if { $ItemType=="text"} { $K itemconfigure $Touche -text $Texte return $Texte } } if {$Action == "Copy"} { set Nouveau [RenaissanceDuWidget $K $Touche "Copy"] return $Nouveau } if {$Action == "Paste"} { if { ! [info exists BufferMainLevee]} { FaireLire "You never made a Copy" return "" } regsub {^[^ ]+ } $BufferMainLevee "$K " Nouveau catch {set NouveauId [eval $Nouveau]} Message if {[regexp {[^0-9]} $Message]} { FaireLire "I got this message : \n$Message" return "" } return $NouveauId } if {$Action == "EditWidget"} { set Nouveau [RenaissanceDuWidget $K $Touche] return $Nouveau } if {$Action == "New"} { set Nouveau [CreerUnWidget $K] return $Nouveau } } proc MainLeveeSurUnCanva {K} { global IdScrollRectangle $K bind "all" <1> "MainLevee $K %x %y Point" $K bind "all" "MainLevee $K %x %y Motion" $K bind "all" "MainLevee $K %x %y Relache" $K bind "all" "MainLevee $K %x %y Modif" regsub {\.[a-z_0-9]+$} $K "" w set Bouton [BoutonneLaFenetre $w "Save/Restore/Erase"] $Bouton configure -background "green" bind $Bouton <1> "SauveLeCanva $K all" bind $Bouton <2> "RestaureLeCanva $K" bind $Bouton <3> "EraseLeCanva $K" set Bouton [BoutonneLaFenetre $w "Paste"] $Bouton configure -background "orange" bind $Bouton <1> "MainLevee $K 0 0 Paste" } proc Maintenance {} { set lesBanques [split [BlastDatabaseInventory ListOf ProBestFirst]] foreach banque $lesBanques { Espionne $banque set queue [file tail $banque] Espionne $queue set fichierTest "/home/joly/BlastTest/$queue.test.blast" set fichierQuery "/home/joly/BlastTest/queryBidon.tfa" if {[file exists $fichierTest]} { continue } else { Espionne [monBlast $fichierQuery $fichierTest $banque "ecrase" "wait"] } } return "Finished !" } proc Maintenant {} { return [clock format [clock seconds] -format { %d %b. %Y %I:%M:%S %p}] } proc MajOiProteomes {{TaxId ""}} { set LesIDs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"] set LesACs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"] foreach ID $LesIDs AC $LesACs { if { ! [regexp "_" $ID]} { continue } ;#rR on verra plus tard !!!!!!!!!!!!!!!!!! set AJour 1 set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"] if {$LesLignesEMBL=={}} { set IdAcRef [UniprotHistory $AC] if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue } scan $IdAcRef "%s %s" IdRef AcRef set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"] if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue } set AJour 0 } if {$AJour} { continue } Espionne "$ID $AC $IdAcRef" } } proc MajYaProteomes {{TaxId ""}} { set LesIDs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"] set LesACs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"] foreach ID $LesIDs AC $LesACs { if { ! [regexp "_" $ID]} { continue } ;#rR on verra plus tard !!!!!!!!!!!!!!!!!! set AJour 1 set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"] if {$LesLignesEMBL=={}} { set IdAcRef [UniprotHistory $AC] if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue } scan $IdAcRef "%s %s" IdRef AcRef set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"] if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue } set AJour 0 } if {$AJour} { continue } Espionne "$ID $AC $IdAcRef" } } proc MakeAll {} { package require platform set p [::platform::generic] switch [string tolower $p] { "linux-x86" - "linux-ix86" { set rep "Linux-x86" } "linux-x86_64" - "linux-x86_64" { set rep "Linux-x86_64" } "windows" - "win32-ix86" { set rep Windows } "mac" - "macosx-ix86" { set rep MacOSX-x86 } } puts "\nCompilation :\n" foreach p {tclordalie0.1 tclcluspack0.1 tclfastme0.1 biotext0.1 tsurf0.1} { cd [file join $::OrdaliDir Extensions $p $rep] puts "$p" # nettoyage set Ldel [glob -nocomplain *.o] if {$Ldel != {}} {file delete -force {*}$Ldel} set Ldel [glob -nocomplain *.so] if {$Ldel != {}} {file delete -force {*}$Ldel} # copie des sources set Lfc [glob -nocomplain [file join .. src *.c]] file copy -force {*}$Lfc "[pwd]" set Lfh [glob -nocomplain [file join .. src *.h]] file copy -force {*}$Lfh "[pwd]" # compilation catch {exec make} Msg if {[regexp -nocase {erreur|error} $Msg]} { puts "#########################" puts $Msg puts "#########################" } } exit } 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 MakeOpenglSelection {} { if {$::pgl(SelectionList) ne ""} { glCallList $::pgl(SelectionList) return } set list [glGenLists 1] set ::pgl(SelectionList) $list glNewList $list GL_COMPILE_AND_EXECUTE dont_use_light glInitNames set imol -1 foreach mol $::StrucAVoir { incr imol set nom [DonneIdDeAccessPDB $mol] set LObj [$nom _ListeObjets] set MolOn 0 foreach obj $LObj { if {! [$nom _EtatDeObjet $obj]} {continue} set MolOn 1 } if {! $MolOn} {continue} glPushName $imol set iobj -1 foreach obj $LObj { incr iobj if {! [$nom _EtatDeObjet $obj]} {continue} glPushName $iobj set La [$nom _SetupPicking $obj] foreach {x y z i} $La { glPushName $i glBegin GL_POINTS glVertex3f $x $y $z glEnd glPopName } glPopName } glPopName } glEndList return } proc MakePDBQuery {args} { set query " " set i 0 foreach {what val} $args { set xml " $i" if {$i} { append xml " and" } switch $what { "-cellcomp" { append xml " head org.pdb.query.simple.TreeEntityQuery CellComponentTree Search for mitochondrion (GO ID:5739) mitochondrion (GO ID:5739) " } "-orga" { append xml " head org.pdb.query.simple.OrganismQuery Organism Search : Organism Name=$val $val " } "-ec" { append xml " head org.pdb.query.simple.EnzymeClassificationQuery Enzyme Classification Search : EC=$val $val " } } append xml " " # add query block append query $xml incr i } append query " " return $query } proc MakeRedundancyClusters {redundantSequencesL {upClustering ""}} { upvar $redundantSequencesL redundantSequences # ex : clustered(AGAM00004) 45 # la sequence 4 est regroupee dans le groupe 45 # les groupes vont de 1 à n (n° du groupe donné par llength) array set clustered {} set newList [list ] set AgrpNumber 0 set BgrpNumber 0 set Adetected 0 set Bdetected 0 if {$upClustering==""} {set upClustering "no"} puts " --> création des clusters de redondants (opération longue)" foreach {cle val} [array get redundantSequences] { set couple [split $cle ","] #recherche si l'element A puis B du couple est deja dans un nouveau groupe if {[info exists clustered([lindex $couple 0])]} { set Adetected 1 set AgrpNumber $clustered([lindex $couple 0]) } elseif {$upClustering=="yes" && [info exists clustered([lindex $couple 1])]} { set Bdetected 1 set BgrpNumber $clustered([lindex $couple 1]) } #si A trouve, on vérifie que B existe et se trouve aussi dans le meme groupe if {$Adetected} { if {[info exists clustered([lindex $couple 1])] && ($clustered([lindex $couple 0])==$clustered([lindex $couple 1]))} { set Bdetected 1 } } #cas ou les 2 ne sont pas detectes if {$Adetected==0 && $Bdetected==0} { lappend newList $couple set clustered([lindex $couple 0]) [llength $newList] set clustered([lindex $couple 1]) [llength $newList] } #cas ou A detecte et pas B if {$Adetected==1 && $Bdetected==0} { set temp [lindex $newList [expr $AgrpNumber-1]] #on ajoute B et on reinjecte lappend temp [lindex $couple 1] lset newList [expr $AgrpNumber-1] $temp } #cas ou les 2 detectes, on fait rien # ########################## # ## option d'upClustering # if {$upClustering=="yes"} { # #si B trouve, on vérifie que A est aussi dans le groupe # if {$Bdetected==1} { # if {[lsearch -exact [lindex $newList $BgrpNumber] # [lindex $couple 0]]!=-1} { # set Adetected 1 # } # } # #cas ou B detecte et pas A # if {$Bdetected==1 && $Adetected==0} { # set temp [lindex $newList $BgrpNumber] # #on ajoute A et on reinjecte # lappend temp [lindex $couple 0] # lset newList $BgrpNumber $temp # } # } set AgrpNumber 0 set BgrpNumber 0 set Adetected 0 set Bdetected 0 } return $newList } proc Maladies {} { package require tdom set file "/home/moumou/listdiseasecards.html" set Lfile [LesLignesDuFichier $file] set Id [dom parse -simple -html $Lfile] set RId [$Id documentElement] set Lnds [$RId selectNodes //tr/td/a] set Lfnt [$RId selectNodes //tr/td/font] foreach e $Lnds { set nom [$e selectNodes string(.)] if {! [regexp {\|} $nom]} {continue} set Ln [split $nom "|"] lappend Lid [string trim [lindex $Ln 0]] lappend Ldef [string trim [lindex $Ln 1]] } foreach e $Lfnt { set n [$e selectNodes string(.)] lappend Ltmp [string trim $n] } foreach {a b c} $Ltmp { lappend Lloc $b lappend Lrmk [list "{$a}" "{$c}"] } set f [open "ms2ph.fof" w] foreach i $Lid d $Ldef l $Lloc r $Lrmk { set j 0 regsub -all {\{} $d "" d regsub -all {\}} $d "" d set d [split $d ","] while {[lindex $d $j] != "" || [lindex $r $j] != ""} { set df [lindex $d $j] set rk [lindex $r $j] regsub -all {\{} $rk "" rk regsub -all {\}} $rk "" rk set rk [string trim $rk] if {!$j} { set lc $l set id $i set Lsrs [ReqSrs [list $id $df]] set ac [lindex $Lsrs 0] set an [lindex $Lsrs 1] set sd [lindex $Lsrs 2] puts $f "$ac $an" } else { set lc "" set id "" set ac "" set an "" set sd "" } puts "$id\t$df\t$lc\t$rk\t$ac\t$an\t$sd" incr j } } close $f exit return } proc ManageFiles {} { Wup "Manageur des fichiers a partir du CADO4MI_Panel" Wup "Permet de supprimer des fichiers crees" Wup "Permet de sauver les resultats dans un fichier delimite par des tabulations" set w ".filemanagement" if {[winfo exists $w]} {wm deiconify $w;raise $w;return ""} else {toplevel $w} wm geometry $w +300+100 wm title $w "File Management" wm resizable $w false false wm protocol $w WM_DELETE_WINDOW "destroy $w" #Frame Generale contenant les autres frame et le bouton dismiss set FirstFrame "$w.framehome" set ButtonDismiss "$FirstFrame.bdismiss" frame $FirstFrame -borderwidth "3" -relief "groove" button $ButtonDismiss -background "red" -relief "ridge" -text "Dismiss" -padx "2" -command "eval \[wm protocol $w WM_DELETE_WINDOW\]" #Frame pour supprimer les types de fichier set FInfo "$FirstFrame.finfo" set ButtonErase "$FInfo.berase" frame $FInfo -borderwidth "3" -relief "groove" button $ButtonErase -background "OliveDrab1" -relief "ridge" -text "Erase File" -padx "2" -command { set LesExtensions [EntreDeux [list ".masked" ".blastn" ".oligo" ".log" ".selection" ".croisee"]] if {$LesExtensions == ""} {return ""} set BrowsedDir [tk_chooseDirectory -title "Choose one directory." -initialdir "[RepertoireDuGenome]"] if {$BrowsedDir == ""} {return ""} set ListeAcc "" foreach Acc [glob -nocomplain -directory $BrowsedDir "*.masked"] { regsub ".masked" $Acc "" Acc lappend ListeAcc [file tail $Acc] } set LesQuels [EntreDeux $ListeAcc] if {$LesQuels == ""} {return ""} if {[OuiOuNon "You want to erase $LesExtensions in $BrowsedDir"]} { foreach PAB $LesQuels { foreach Extension $LesExtensions { set Fichier "${BrowsedDir}/${PAB}${Extension}" if {[file exists $Fichier]} {file delete -force $Fichier} } } } } set Texte [format "%-10s" "Allow to erase the different types of files generated."] set_balloon $ButtonErase "$Texte" #Frame pour sauver les resultats dans un fichier separes par des tabulations set FExcel "$FirstFrame.frameexcel" set ButtonToExcel "$FExcel.bsave" frame $FExcel -borderwidth "3" -relief "groove" button $ButtonToExcel -background "OliveDrab1" -relief "ridge" -text "Save Results" -padx "2" -command "LesOligosPourExcel_GUI" set Texte [format "%-10s" "Allow to save the results in a tab-delimited file."] set_balloon $ButtonToExcel "$Texte" pack $FirstFrame -fill both -expand true pack $FInfo -side top -fill both -expand true pack $ButtonErase -side top -fill both -expand true pack $FExcel -side top -fill both -expand true pack $ButtonToExcel -side top -fill both -expand true pack $ButtonDismiss -side top -fill both -expand true return "" } proc ManipuleLaRosace {Action R Tag x y} { Wup "Manages the point-and-motion for rotating the arcs" global ParametresDuBoard global AnglePoint JeMeSignale set CentreX [set ParametresDuBoard($R,CentreX)] set CentreY [set ParametresDuBoard($R,CentreY)] set X [$R canvasx $x] set Y [$R canvasx $y] if {$Action == "Point"} { set AnglePoint [AngleDansRosace "CoordonneesVraies" $X $Y $CentreX $CentreY] return } if {$Action == "Release"} { if { ! [info exists AnglePoint]} { return } set AngleRelease [AngleDansRosace "CoordonneesVraies" $X $Y $CentreX $CentreY] set AngleDelta [Entre0Et2PI [expr $AngleRelease-$AnglePoint]] } foreach Id [$R find withtag $Tag] { set Coordonnees [$R coords $Id] if {$Action == "Switch"} { set NouvellesCoordonnees [SwitchEnX $Coordonnees $CentreX] } if {$Action == "Release"} { set NouvellesCoordonnees [TourneLaListeAutour $Coordonnees $CentreX $CentreY $AngleDelta] } eval $R coords $Id [split $NouvellesCoordonnees " "] } } proc MapAreaFromCanva {TexteOuFichierTcl FichierImage FichierHtml} { if {[regexp "\n" $TexteOuFichierTcl]} { set TexteTcl $TexteOuFichierTcl } else { set TexteTcl [ContenuDuFichier $TexteOuFichierTcl] } set Map "map" lappend LeHtml [ContenuDuFichier "[GscopeEtc]/EnteteHtmlPourIllustreLesChromosomes.html"] lappend LeHtml "" lappend LeHtml "

" Html_Append "

Table Of Contents

" Html_Append "

" foreach elt $TbLog(LElt) { if {[set Lix [lsearch -all -regexp [set TbLog($elt,LElt)] "title_"]] == -1} { continue } set InSub 0 foreach ix $Lix { set ittl [lindex [set TbLog($elt,LElt)] $ix] if {[regexp {^subt} $ittl]} { if {! $InSub} { set InSub 1 Html_Append "
" } Html_Append "
• " set subtitle [set TbLog($elt,$ittl,Subtitle)] Html_Href $subtitle "#$ittl" "style='fontsize:big;'" Html_Append "
" } else { if {$InSub} { set InSub 0 Html_Append "
" } Html_Append "
• " set title [set TbLog($elt,$ittl,Title)] Html_Href $title "#$ittl" "style='fontsize:big;'" Html_Append "
" } } if {$InSub} { Html_Append "

" } } Html_Append "" Html_Append "

" Html_Append "

---

" Html_BR return } proc TOCEnText {} { global TbLog TextOut lappend TextOut "" lappend TextOut "Table Of Contents" lappend TextOut "-----------------" foreach elt $TbLog(LElt) { if {[set Lix [lsearch -all -regexp [set TbLog($elt,LElt)] "title_"]] == -1} { continue } set InSub 0 foreach ix $Lix { set ittl [lindex [set TbLog($elt,LElt)] $ix] if {[regexp {^subt} $ittl]} { if {! $InSub} { set InSub 1 set pre " " } set subtitle [set TbLog($elt,$ittl,Subtitle)] lappend TextOut "$pre$subtitle" } else { if {$InSub} { set InSub 0 set pre "" } set title [set TbLog($elt,$ittl,Title)] lappend TextOut $title } } } lappend TextOut "" return } proc TOT {} { global StrucAVoir LoadTkAndPackages rename EnvoieLesObjets Envoie_wait rename Cubes EnvoieLesObjets catch {glDeleteLists 513 1} glFlush glFinish set StrucAVoir [list] Initialisation AfficheFenetreOpengl #Update3DMatrices $::pgl(wogl) postredisplay return } proc TPIO {} { foreach Nom [ListeDesPABs] { Espionne [time {set PIO [PourcentageIdentiteOrga $Nom taci]}] Espionne $PIO } exit } proc TRANSFORME {VX MC VXP} { set PROV [V_VV $VX "-" $VXP] set VXMOL [V_MV $MC * $PROV] return $VXMOL } proc TRCOOR {NA,X,TRANS,IAT,IMOL} { foreach K {1 2 3} { set XO($K) [set X($K,$IAT,$IMOL)] } foreach K {1 2 3} { set X($K,$IAT,$IMOL) [expr {[set TRANS($K,1,$IMOL)]*$XO(1)+[set TRANS($K,2,$IMOL)]*$XO(2)+[set TRANS($K,3,$IMOL)]*$XO(3)}] } return } proc TRNAscanSE {} { global RepertoireDuGenome global FichierSequenceADN File mkdir "$RepertoireDuGenome/trnadir" set FichierTRNAscanSE "$RepertoireDuGenome/trnadir/tRNAscan-SE.out" set Ordre "-G" set OC [NotreOC] if {[regexp -nocase "Archaea" $OC]} { set Ordre "-A" } if {[regexp -nocase "Bacteria" $OC]} { set Ordre "-P" } if {[regexp -nocase "Eukaryota" $OC]} { set Ordre "" } set CommandeTRNAscanSE "" while {$CommandeTRNAscanSE==""} { set CommandeTRNAscanSE "tRNAscan-SE $Ordre -o $FichierTRNAscanSE $FichierSequenceADN" set CommandeTRNAscanSE [Entre $CommandeTRNAscanSE] if {$CommandeTRNAscanSE=="" && [OuiOuNon "Do I cancel TRNAscanSE ?"]} { return "" } } catch {eval exec $CommandeTRNAscanSE} Message if { ! [file exists $FichierTRNAscanSE]} { FaireLire "TRNAscanSE didn't run properly.\nMay be You forget to set the environment." return 0 } set FichierBornesDesTRNAs "$RepertoireDuGenome/fiches/bornesdestrnas" while {[file exists $FichierBornesDesTRNAs]} { if {[OuiOuNon "I have to calculate $FichierBornesDesTRNAs.\n Do I delete the old one ? (You can copy it before answer)"]} { File delete -force $FichierBornesDesTRNAs } else { if {[OuiOuNon "Do I keep the old version ?"]} { break } } } ChargeLesTRNAs return 1 } proc TSB {} { CreeLesPiliers set Lp [set ::ListeDesPiliersDuGroupe(GroupeToutLeMonde)] set sc [ScoreDeBILD $Lp] foreach p $Lp s $sc { puts "$p [format %6.2f $s]" } exit } proc TSE {args} { set pf [lindex $args 0] set Lm [lrange $args 1 end] TestScoreExe $pf $Lm } proc TSOH {} { set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"] Espionne [lsort -integer $OHLaListe] Espionne [MoyenneEcartMinMaxCumulLong $OHLaListe] } proc TSeq {} { DecortiqueUnTFA ./tmp/D_all.tfa Ln Sq foreach {k tax} {Dcy_Cyan.mero 45157 Dmi_Cyan.mero 45157 Dcy_Homo.sapi 9606 Dmi_Homo.sapi 9606} { set s $Sq($k) set s [string map {"." "" "-" ""} $s] #set Lblast [BlastService -p blastp -d nr -orga $tax -expect 0.00001 -query ">toto\n$s" -nlist 10 -f 1 -qdef yes] puts "$k $tax" #puts [join $Lblast \n] #SauveLesLignes $Lblast dans tmp/bl${k}_$tax.blast set Lblast [LesLignesDuFichier tmp/bl${k}_$tax.blast] DecortiqueBlast $Lblast "" "" "" Lbid Lacc Lde "" LPN set i 1 foreach a $Lacc b $Lbid p $LPN d $Lde { puts "$i hit $a $b $p $d" incr i } puts "" unset -nocomplain Lbid Lacc Lde LPN } exit } proc TT {} { puts [string repeat "*" 600] package require BLT set T [blt::tree create] set I1 [CreateNode $T] Spy $T puts "insert de $I1 dans $T en root" $T root $I1 puts "$I1 devient root" Spy $T set I2 [CreateNode $T] puts "insert de $I2 dans $T en root" Spy $T set I3 [CreateNode $T] puts "insert de $I3 dans $T en root" Spy $T set I4 [CreateNode $T $I3] puts "insert de $I4 dans $T en $I3" Spy $T set I5 [CreateNode $T $I4] puts "insert de $I5 dans $T en $I4" Spy $T set TV ".tv" blt::treeview $TV -tree $T $TV open all pack $TV puts "ai trouve [$T path "IAm4"]" set R [NewRoot $T "IAm4"] set RV ".rv" blt::treeview $RV -tree $R $RV open all pack $RV } proc TTLL {{Qui ""} {Quoi ""}} { #rR Les Clades pour les TTLL de Sarah Djeddi global TTLL regsub -all "_" $Qui " " Qui if {[regexp -nocase "Help" $Qui]} { lappend LeHelp "TTLL stands for Tubulin Tyrosine Ligase Like (from Sarah)" lappend LeHelp "TTLL ListOf Clade" lappend LeHelp "TTLL ListOf OX" lappend LeHelp "TTLL ListOf OS" lappend LeHelp "TTLL 9606 Clade" lappend LeHelp "TTLL Homo_sapiens Clade -> Sarcopterygii (eh oui !!! on est comme ça !!) " lappend LeHelp "TTLL 9606 Clade -> Sarcopterygii" lappend LeHelp "TTLL Sarcopterygii OX -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377" lappend LeHelp "TTLL Sarcopterygii OS -> lists the organism names" lappend LeHelp "TTLL 9606 OX -> 9606" lappend LeHelp "TTLL 9606 OS -> Homo sapiens" lappend LeHelp "TTLL Homo_sapiens OX -> 9606 (nb : with underscore _ you don't need quotes) " lappend LeHelp "TTLL Homo_sapiens OS -> Homo sapiens" lappend LeHelp "Attention some Organims can belong to several Clades" lappend LeHelp "TTLL 12345 Clade may return several hits" lappend LeHelp "" lappend LeHelp " Raymond" return [join $LeHelp "\n"] } set FichierCsv "[BlomeDir]/TTLL.csv" set Fichier "/genomics/link/OI/fiches/TTLL.txt" if {[regexp -nocase "^ReDo_" $Qui]} { if {[file exists $Fichier]} { file delete $Fichier } regsub -nocase "^ReDo_" $Qui "" Qui return [TTLL $Qui $Quoi] } if {[info exists TTLL($Qui,$Quoi)]} { return $TTLL($Qui,$Quoi) } if {[info exists TTLL("EstCharge")]} { return "" } set TTLL("EstCharge") 1 set OnMemorise 0 ; #rR Attention si on mémorise il faut faire redo quand il faut if { $OnMemorise && [file exists $Fichier]} { array set TTLL [ContenuDuFichier $Fichier] set TTLL(csv,file) $FichierCsv return [TTLL $Qui $Quoi] } set TTLL(ListOf,Clade) {} foreach Ligne [LesLignesDuFichier $FichierCsv] { set A "" set B "" lassign [split $Ligne ";"] A B set A [string trim $A] set B [string trim $B] if {[regexp -nocase {[A-Z]} $A]} { regsub -all " " $A "" A set Clade $A set TTLL($Clade,OX) {} set TTLL($Clade,OS) {} lappend TTLL(ListOf,Clade) $Clade continue } if {[regexp {^[0-9]+$} $A]} { set B [Tax $A Name] lappend TTLL($Clade,OX) $A lappend TTLL($Clade,OS) $B lappend TTLL($A,Clade) $Clade lappend TTLL($B,Clade) $Clade lappend TTLL(ListOf,OX) $A lappend TTLL(ListOf,OS) $B set TTLL($A,OX) $A set TTLL($A,OS) $B set TTLL($B,OX) $A set TTLL($B,OS) $B continue } } set TTLL(ListOf,Clade) [lsort -unique $TTLL(ListOf,Clade)] set TTLL(ListOf,JoinedClade) [join $TTLL(ListOf,Clade) " "] set TTLL(ListOf,OX) [lsort -unique $TTLL(ListOf,OX)] set TTLL(ListOf,OS) [lsort -unique $TTLL(ListOf,OS)] if {$OnMemorise} { Sauve [array get TTLL] dans $Fichier } return [TTLL $Qui $Quoi] } proc TTLLrenomme {} { set Fic "/genomics/link/TTLL/DeYann/ttll_seq_fasta.txt" foreach Access } proc TTT {} { set A "Q92947-2" if {[catch {set Sortie [exec getz -e -cs "\\\|" \[VARSPLIC:$A\]>protein]} Message]} { FaireLire "error from getz \n$Message" exit } Espionne $Sortie exit } proc TW1 {} { package require http set url "http://bips.u-strasbg.fr/PipeAlign/get_pdb_file.cgi?1ile" if {[catch {::http::geturl $url} token]} { puts "Error $url : bad url or no network" return 0 } upvar #0 $token toto set lignes [split [set toto(body)] "\n"] unset toto return $lignes } proc T_DoBootstrap {Ln Lpil} { set lgs [llength $Lpil] set nbs [llength $Ln] set NewA [list] set Lr [list] for {set col 0} {$col < $lgs} {incr col} { # Attention !! int(9.99) = 9 !! donc lgs et pas lgs-1 ! set H [expr {int(rand()*$lgs)}] set pil [lindex $Lpil $H] for {set i 0} {$i < $nbs} {incr i} { lappend l$i [lindex $pil $i] } } for {set i 0} {$i < $nbs} {incr i} { lappend NewA [set l$i] lappend Lr [string length [string map {"." ""} [join [set l$i] ""]]] set l$i [list] } set i 1 foreach n1 $Ln s1 $NewA l1 $Lr { set TPCI($n1,$n1) 0.0 foreach n2 [lrange $Ln $i end] s2 [lrange $NewA $i end] l2 [lrange $Lr $i end] { set dist [expr {1.0-[NRIdentite $s1 $l1 $s2 $l2]}] set TPCI($n1,$n2) $dist set TPCI($n2,$n1) $dist } incr i } set Ldst [list] foreach n1 $Ln { foreach n2 $Ln { lappend Ldst [set TPCI($n1,$n2)] } } return $Ldst } proc T_DoBootstrap2 {Ln Lpil Lrd} { set lgs [llength $Lpil] set nbs [llength $Ln] set NewA [list] set Lr [list] for {set col 0} {$col < $lgs} {incr col} { # Attention !! int(9.99) = 9 !! donc lgs et pas lgs-1 ! # set H [expr {int(rand()*$lgs)}] set H [lindex $Lrd $col] set pil [lindex $Lpil $H] for {set i 0} {$i < $nbs} {incr i} { lappend l$i [lindex $pil $i] } } for {set i 0} {$i < $nbs} {incr i} { lappend NewA [set l$i] lappend Lr [string length [string map [list "." ""] [join [set l$i] ""]]] set l$i [list] } set i 1 foreach n1 $Ln s1 $NewA l1 $Lr { set TPCI($n1,$n1) 0.0 foreach n2 [lrange $Ln $i end] s2 [lrange $NewA $i end] l2 [lrange $Lr $i end] { set dist [expr {1.0-[NRIdentite $s1 $l1 $s2 $l2]}] set TPCI($n1,$n2) $dist set TPCI($n2,$n1) $dist } incr i } set Ldst [list] foreach n1 $Ln { foreach n2 $Ln { lappend Ldst [set TPCI($n1,$n2)] } } return $Ldst } proc T_M {aT M {StartIndex 0}} { upvar $aT T set I $StartIndex foreach V $M { set J $StartIndex foreach X $V { set T($I,$J) $X incr J } incr I } } proc T_T {aD aS} { # Attention D est reinitialise upvar $aD D upvar $aS S array set T [array get S] if {[info exists D]} { unset D } array set D [array get T] } proc T_V {aT V {StartIndex 0}} { upvar $aT T set I $StartIndex foreach X $V { set T($I) $X incr I } } proc TabFeaturesDesSeqs {id aTab} { upvar $aTab tb global LNOrdali set RId [$id documentElement] ExtraitListeItemFeatures $id LItemFeat set tb(Items) $LItemFeat foreach n $LNOrdali { set query "//*\[string(seq-name)='$n'\]/descendant::*\[name()='fitem'\]" set lneitem [$RId selectNodes "$query"] set tb($n) {} foreach f $lneitem { set ValI {} foreach i $LItemFeat { set nfi [$f selectNodes "./$i"] set val [$nfi selectNodes string(.)] regsub -all " " $val {_} val lappend ValI $val } lappend tb($n) $ValI } } return } proc TabGlobaux {pab data conv} { # conv permet de determiner s il faut convertir ou non les positions ds l ali en position dans la sequence foreach n {"IdenGlob" "ConsGlob" "SimiGlob"} { set l$n {} set l${n}R {} # ce qui se situe apres $n et commence ou non par "{" jusqu a "}" regexp "$n {{0,1}(\[^\}\{\]+)}" [set data] match l$n foreach e [set l$n] { # si conv est vide, on convertit if { $conv == "" } { set pos [CorrespondanceGenSeqOrd $pab $e] # sinon on garde les positions dans l alignement } else { set pos $e } if { $pos != -1 } { lappend l${n}R $pos } } lappend lTotal [set l${n}R] } return $lTotal } proc TabGroupe {id numGrp liste} { set lResu {} set li {} set n "CoulG$numGrp" # ce qui se situe apres $n et commence ou non par "{" jusqu a "}" regexp "$n {{0,1}(\[^\}\{\]+)}" $liste match li #puts "les $n sont [set l$n]" if {$li != ""} { foreach e $li { set pos [CorrespondanceGenSeqOrd $id $e] lappend lResu $pos } } return $lResu } proc TabLMSDesAccessDuBallast {aTabAccess FichierBallastMotifs FichierBallastAnchors} { upvar $aTabAccess TabAccess if {![file exists $FichierBallastMotifs]} { Espionne "$FichierBallastMotifs does not exist." return "" } if {![file exists $FichierBallastAnchors]} { Espionne "$FichierBallastAnchors does not exist." return "" } set LesLMS {} set nLMS 0 set F [open $FichierBallastMotifs] while {[gets $F Ligne]>=0} { if {![regexp -nocase {[0-9a-z]} $Ligne]} {continue} if {[regexp "Suggested Words" $Ligne]} {continue} set Ligne [string trim $Ligne] scan $Ligne "%d %s %d" DebutLMS Separateur FinLMS incr nLMS lappend LesLMS [list "$DebutLMS" "$FinLMS" "$nLMS"] } close $F set LesAccess {} set F [open $FichierBallastAnchors] while {[gets $F Ligne]>=0} { if {![regexp -nocase "seq:" $Ligne]} {continue} if {[info exists LMS]} {unset LMS} if {[info exists Access] } {unset Access } if {[info exists Position]} {unset Position} scan $Ligne "%s %s %s %s %d %s %d" Seq Query Access Pos Pos1 Beg Position if {![info exists TabAccess($Access)]} { lappend LesAccess $Access set TabAccess($Access) {} } set TrouveLeLMS 0 foreach LeLMS $LesLMS { set Debut [lindex $LeLMS 0] set Fin [lindex $LeLMS 1] if { $Debut <= $Position && $Position <= $Fin} { set nLMS [lindex $LeLMS 2] lappend TabAccess($Access) $nLMS set TrouveLeLMS 1 break } } if {$TrouveLeLMS == 0} { Espionne "$Nom -> ERROR $Access $Position ERROR" } } close $F return $aTabAccess } proc TabLesEmbranchementsGO {aTab Type Individu} { upvar $aTab Tab global nEmbranchements if {![info exists nEmbranchements]} {set nEmbranchements 1 } set Individu [string toupper $Individu] set Individu [GODB Type $Type GOSynonyme $Individu GODeRef] if {![info exists Tab($nEmbranchements,LEmbranchement)]} {set Tab($nEmbranchements,LEmbranchement) {}} lappend Tab($nEmbranchements,LEmbranchement) $Individu set LesParents [concat [GODB Type $Type GO $Individu LesParents] [GODB Type $Type GO $Individu LesConstituants]] set nParents [llength $LesParents] if {1 < $nParents} {set LEmbranchemenAvantLeNoeud [set Tab($nEmbranchements,LEmbranchement)]} for {set i 0} {$i < $nParents} {incr i} { if {1 < $nParents && 0 < $i} { incr nEmbranchements set Tab($nEmbranchements,LEmbranchement) $LEmbranchemenAvantLeNoeud } set Parent [string toupper [lindex $LesParents $i]] set Parent [GODB Type $Type GOSynonyme $Parent GODeRef] TabLesEmbranchementsGO Tab $Type $Parent } return $aTab } proc TabLesEmbranchementsOntologiques {aTab Type Individu} { upvar $aTab Tab global nEmbranchements if {![info exists nEmbranchements]} {set nEmbranchements 1 } set Individu [string toupper $Individu] if {[OntoExists $Individu MonJumeau]} {set Individu [string toupper [Onto $Individu MonJumeau]]} if {![info exists Tab($nEmbranchements,LEmbranchement)]} {set Tab($nEmbranchements,LEmbranchement) {}} lappend Tab($nEmbranchements,LEmbranchement) $Individu set LesParents [concat [Onto $Type $Individu LesParents] [Onto $Type $Individu LesConstituants]] set nParents [llength $LesParents] if {1 < $nParents} {set LEmbranchemenAvantLeNoeud [set Tab($nEmbranchements,LEmbranchement)]} for {set i 0} {$i < $nParents} {incr i} { if {1 < $nParents && 0 < $i} { incr nEmbranchements set Tab($nEmbranchements,LEmbranchement) $LEmbranchemenAvantLeNoeud } set Parent [string toupper [lindex $LesParents $i]] if {[OntoExists $Parent MonJumeau]} {set Parent [string toupper [Onto $Parent MonJumeau]]} TabLesEmbranchementsOntologiques Tab $Type $Parent } return $aTab } proc TabLesPageInfos {aTab {LesId ""} {Banque ""}} { upvar $aTab Tab if {$LesId == {}} {return} set LesIdModif {} foreach Id $LesId { set IdModif $Id regsub -nocase {^[^\:]+\:} $Id "" IdModif regsub -nocase {\-[0-9]+$} $IdModif "" IdModif set IdModif [string toupper $IdModif] set TabTmp($Id,modif) $IdModif set TabTmp($IdModif,ini) $Id lappend LesIdModif $IdModif } if {$Banque == ""} {set Banque "\{genbankfull protein est\}"} set Ids [join $LesIdModif "|"] set Ids "\($Ids\)" set Commande "[ProgPathway getz] \" \( \\\[$Banque-acc:$Ids\\\] \| \\\[$Banque-id:$Ids\\\] \) \" -e" catch {set GetzOut [eval exec $Commande]} Message if {![info exists GetzOut] || $GetzOut == ""} {return} set LaPageInfo {} foreach Ligne [split $GetzOut "\n"] { lappend LaPageInfo $Ligne if {[string trim $Ligne] != "//"} {continue} set PageInfo [join $LaPageInfo "\n"] set LesAccess [LesAccessDeLaPageInfo $PageInfo] lappend LesAccess [BanqueIdDeLaPageInfo $PageInfo] foreach Access $LesAccess { set Access [string toupper $Access] set TabTmp($Access,PageInfo) $PageInfo } set LaPageInfo {} } foreach Id $LesId { set IdModif [set TabTmp($Id,modif)] if {![info exists TabTmp($IdModif,PageInfo)]} {continue} set Tab($Id) [set TabTmp($IdModif,PageInfo)] } return $aTab } proc Table2HTML {aT} { upvar $aT tbl if {[set id $tbl(Id)] ne ""} { Html_Append "

" } else { Html_Append "

" } foreach elt $tbl(LElt) { switch -regexp -- $elt { {^title\_} { Html_Append "

$tbl($elt,Title)

" } {^Subtitle\_} { Html_Append "

$tbl($elt,Subtitle)

" } {^text} { Html_Teletype "[join $tbl($elt,Text) \n]" } {^tabular} { set lt [array get tbl "$elt,*"] #puts "[join $lt \n]" array set tt $lt Tabular2HTML tt } } } Html_Append "

" Html_BR return } proc Table2Text {aT} { upvar $aT tbl global TextOut foreach elt $tbl(LElt) { switch -regexp -- $elt { {^title\_} { lappend TextOut $tbl($elt,Title) lappend TextOut [string repeat - [string length $tbl($elt,Title)]] } {^Subtitle\_} { lappend TextOut $tbl($elt,Subtitle) } {^text} { lappend TextOut [join $tbl($elt,Text) \n] } {^tabular} { set lt [array get tbl "$elt,*"] array set tt $lt Tabular2Text tt } } } lappend TextOut "" return } proc TableCorrespondanceAncienNouveau {} { foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/prottfa/*"] { #premier mot de l entete sans ">" set Nouveau [EnteteDuFichierTFA $Fichier ""] #entete entiere avec ">" set Entete [EnteteDuFichierTFA $Fichier] scan $Entete "%s %s %s %s" new old prot acc lappend LaCorrespondance "$old\t$Nouveau\t$acc" } return $LaCorrespondance } proc TableauActinome {} { #327 ACT set LesLignes {} set FichierActinome "[RepertoireDuGenome]/TableauActiChip" set LigneDeTete "RetscopeId;GeneName;Description;NucAccessionNumber;ProtAccessionNumber;CytoBand;ProbeSet;processGO;functionGO;componentGO" lappend LesLignes $LigneDeTete foreach Nom [ActiChip2_0] { set Gn [ExtraitInfo $Nom "ValiGN"] set Des [ExtraitInfo $Nom "ValiDE"] regsub -all ";" $Des "," Des set AccARNm [AccessEvi $Nom] set ProbesSet [ExtraitInfo $Nom "ProbeSetId"] set CytoBand [ExtraitInfo $Nom "CytoBand"] set AccProt [ExtraitInfo $Nom "IdAccProt"] set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set LesComponent {}; set LesFunction {}; set LesProcess {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { set Type [InterrogeGeneOntology $FichierGO GO $GO Type] #set DefGO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""] if {[regexp {component} $Type]} {lappend LesComponent $GO} if {[regexp {function} $Type]} {lappend LesFunction $GO} if {[regexp {process} $Type]} {lappend LesProcess $GO} } set LesComponent [ListeSansDoublon $LesComponent] set LesFunction [ListeSansDoublon $LesFunction] set LesProcess [ListeSansDoublon $LesProcess] set comp [join $LesComponent ","] set func [join $LesFunction ","] set proce [join $LesProcess ","] set Ligne "$Nom;$Gn;$Des;$AccARNm;$AccProt;$CytoBand;$ProbesSet;$proce;$func;$comp" lappend LesLignes $Ligne } SauveLesLignes $LesLignes dans $FichierActinome } proc TableauRecapDesSelectionnes {Fichier} { #Fichier est soit [RepertoireDuGenome]/transcriptomique/ConeSpe/ListeRMAExp2J15Cond soit [RepertoireDuGenome]/transcriptomique/ConeSpe/ListedChipExp2J15Cond if {[regexp "RMA" $Fichier]} {set AnalysisSoftware RMA} if {[regexp "dChip" $Fichier]} {set AnalysisSoftware dChip} set PkExperiment 2 #attention faire autrement amettreenarg set RepertoireSi "[RepertoireDuGenome]/transcriptomique/ConeSpe/SignalIntensityExp2J15" set FichierSortie "[RepertoireDuGenome]/transcriptomique/ConeSpe/TableauRecapExp2J15$AnalysisSoftware" CanalSqlBioArrayBase set i 0 foreach Ps [LesLignesDuFichier $Fichier] { incr i Espionne "Ps $Ps $i" set Fichier "$RepertoireSi/$Ps" set LesSiTrb {}; set LesSiRd7 {}; set LesSiWt {} foreach Ligne [LesLignesDuFichier $Fichier] { set elmts [split $Ligne "\t"] if {[regexp "Trbeta" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} { lappend LesSiTrb [lindex $elmts 4] } if {[regexp "rd7" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} { lappend LesSiRd7 [lindex $elmts 4] } if {[regexp "wt" $Ligne] && [regexp -nocase "$AnalysisSoftware" $Ligne]} { lappend LesSiWt [lindex $elmts 4] } } set MoyTrb [MoyenneDeLaListe $LesSiTrb] set MoyRd7 [MoyenneDeLaListe $LesSiRd7] set MoyWt [MoyenneDeLaListe $LesSiWt] set Rapport [expr $MoyRd7 / $MoyTrb] regsub -all {\-OU\-} $Ps "/" Ps set TexteCluster [TrouveClusterParticulier $Ps $PkExperiment] foreach Ligne [split $TexteCluster "\n"] { if {[regexp -nocase "$AnalysisSoftware" $Ligne]} { set ElmtLigne [split $Ligne "\t"] if {[regexp "K-Means cluster method from TMEV" $Ligne]} { set KMTMEV [lindex $ElmtLigne 4] set PopulationTotaleDeKMTMEV [PopulationDuCluster $KMTMEV $PkExperiment $AnalysisSoftware "K-Means cluster method from TMEV (TIGR MultiExperiment Viewer(MeV))"] set PopulationParticuliereDeKMTMEV [InterrogePopulationDesClustersCorresAuProfilParticulier $KMTMEV $AnalysisSoftware "K-Means cluster method from TMEV (TIGR MultiExperiment Viewer(MeV))"] } elseif {[regexp "K-Means cluster method from FASABI" $Ligne]} { set KMFASABI [lindex $ElmtLigne 4] set PopulationTotaleDeKMFASABI [PopulationDuCluster $KMFASABI $PkExperiment $AnalysisSoftware "K-Means cluster method from FASABI"] set PopulationParticuliereDeKMFASABI [InterrogePopulationDesClustersCorresAuProfilParticulier $KMFASABI $AnalysisSoftware "K-Means cluster method from FASABI"] } elseif {[regexp "MixtureModel clustering method from FASABI" $Ligne]} { set MMFASABI [lindex $ElmtLigne 4] set PopulationTotaleDeMMFASABI [PopulationDuCluster $MMFASABI $PkExperiment $AnalysisSoftware "MixtureModel clustering method from FASABI"] set PopulationParticuliereDeMMFASABI [InterrogePopulationDesClustersCorresAuProfilParticulier $MMFASABI $AnalysisSoftware "MixtureModel clustering method from FASABI"] } } } set AccessGb [AffyAnnoMG430 $Ps "Representative_Public_ID"] set GeneName [AffyAnnoMG430 $Ps "Gene_Symbol"] set AccessNm [AffyAnnoMG430 $Ps "RefSeq_Transcript_ID"] set Go [AffyAnnoMG430 $Ps "Gene_Ontology_Cellular_Component"] set transmb [AffyAnnoMG430 $Ps "Trans_Membrane"] #attention aux /// set LesMorceaux {}; set LesComp {} if {$Go=="---"} { set CompFin "no" } else { regsub -all {/{3}} $Go "@" Go set LesMorceaux [split $Go "@"] foreach Morceau $LesMorceaux { #Espionne "Morceau $Morceau" regsub -all {/{2}} $Morceau "@" Morceau set Comp [lindex [split $Morceau "@"] 1] set Comp [string trim $Comp] lappend LesComp $Comp } set LesComp [ListeSansDoublon $LesComp] set CompFin [join $LesComp "/"] } if {$transmb=="---"} { set transmb "no" } else { set transmb "yes" } set LigneFin "$Ps;$GeneName;$AccessGb;$AccessNm;$CompFin;$transmb;$MoyRd7;$MoyWt;$MoyTrb;$Rapport;$KMTMEV;$PopulationTotaleDeKMTMEV;$PopulationParticuliereDeKMTMEV;$KMFASABI;$PopulationTotaleDeKMFASABI;$PopulationParticuliereDeKMFASABI;$MMFASABI;$PopulationTotaleDeMMFASABI;$PopulationParticuliereDeMMFASABI" lappend LesLignesFin $LigneFin } CanalSqlDisconnect set LesLignesFin [lsort -real -command CompareFlottant -decreasing $LesLignesFin] SauveLesLignes $LesLignesFin dans $FichierSortie } proc TableauRecapLoc {} { foreach Box [ListeDesPABs] { set LesLignesResult {} set File "[RepertoireDuGenome]/Loc/htdocs/results/$Box.html" set LesLocPossiblesGen [QuellesSontLocPossibles $Box] set formatstring "%-28s" foreach LocPossibleGen $LesLocPossiblesGen { set longloc [llength [split $LocPossibleGen ""]] if {$longloc<5} {set longloc 5} append formatstring " %${longloc}s" } set finalTete [format "$formatstring" Name {*}$LesLocPossiblesGen] lappend LesLignesResult $finalTete foreach Ligne [LesLignesDuFichier $File] { if {![regexp "^\<" $Ligne]} { set LesValues {} set LesLocPossibles $LesLocPossiblesGen set Name [lindex [split $Ligne " "] 0] set index1 [expr [string first "/" $Ligne] +4] set index2 [expr [string first "\<" $Ligne $index1] - 1 ] set LocDeName [string range $Ligne $index1 $index2] set LesLocDeName [split $LocDeName ","] foreach LocPossible $LesLocPossibles { set trouve 0; set indexelmt -1 foreach elmt $LesLocDeName { incr indexelmt set elmt [string trim $elmt] set LesMots [split $elmt ":"] set tete [lindex $LesMots 0] set valeur [lindex $LesMots 1] if {$LocPossible == $tete} { set trouve 1 lappend LesValues $valeur set LesLocPossibles [lreplace $LesLocPossibles 0 0] set LesLocDeName [lreplace $LesLocDeName $indexelmt $indexelmt] break } } if {!$trouve} {lappend LesValues " -"} } set final [format $formatstring $Name {*}$LesValues] lappend LesLignesResult $final } } SauveLesLignes $LesLignesResult dans "[RepertoireDuGenome]/Loc/$Box" } } proc Tabular2HTML {aT} { upvar $aT tbl if {[set id $tbl(Id)] ne ""} { Html_Append "

" } else { Html_Append "

" } Html_Append "" Html_Append "" if {$tbl(TitleCols) != {}} { Html_Append "" foreach c $tbl(TitleCols) { if {$c eq "NULL"} {set c ""} Html_Append "" } Html_Append "" } #puts "nbr cols [llength [lindex [set tbl(Rows)] 0]]" #puts "nbr rows [llength [set tbl(Rows)]]" #puts "typecols $tbl(TypeCols)" if {! [info exists tbl(Rows)]} { set tbl(Rows) [list] } for {set i 0} {$i < [llength [lindex $tbl(Rows) 0]]} {incr i} { set classe($i) "" if {[info exists tbl(TypeCols)]} { set type [lindex $tbl(TypeCols) $i] if {$type eq "R" || $type eq "I"} { set classe($i) "class='rightalign'" } } } foreach lrow $tbl(Rows) { Html_Append "" set i 0 foreach c $lrow { if {$c eq "NULL"} {set c ""} Html_Append "" incr i } Html_Append "" } Html_Append "" Html_Append "

$c
$c

" Html_Append "

" return } proc Tabular2Text {aT} { upvar $aT tbl global TextOut # determine columns widths set TotLg 0 for {set i 0} {$i < [llength [lindex [set tbl(Rows)] 0]]} {incr i} { set lgt [PlusLongEltDe [ExtraitListeDeListe $tbl(Rows) $i]] if {$tbl(TitleCols) != {}} { set c [lindex $tbl(TitleCols) $i] if {$c eq "NULL"} {set c ""} set l [string length $c] if {$l > $lgt} {set lgt $l} } set TFmt($i) [list " %${lgt}s |" $lgt] incr TotLg $lgt incr TotLg 3 ; # white space + | } incr TotLg ; # leading | # fill the table set sep [string repeat - $TotLg] lappend TextOut "" lappend TextOut $sep if {$tbl(TitleCols) != {}} { set i 0 set textcol "|" foreach c $tbl(TitleCols) { if {$c eq "NULL"} {set c ""} lassign [set TFmt($i)] fmt tmp append textcol [format $fmt $c] incr i } lappend TextOut $textcol lappend TextOut $sep } foreach lrow $tbl(Rows) { set tcol "|" set i 0 foreach c $lrow { if {$c eq "NULL"} {set c ""} lassign [set TFmt($i)] fmt tmp append tcol [format $fmt $c] incr i } lappend TextOut $tcol } lappend TextOut $sep lappend TextOut "" return } proc TabulonsSansQuote {Fichier {TabIn ""} {TabOut ""} {ReplaceTabOut ""} {GetWhat ""}} { if {$GetWhat==""} { set Getwhat "GetFilename" } if {[regexp -nocase "Tab" $TabIn]} { set TabIn "\t" } if {$TabOut==""} { set TabOut ";" } if {$ReplaceTabOut==""} { set ReplaceTabOut " " } set Nouveau "$Fichier.NEW" set Export "$Fichier.EXPORT" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^#" $Ligne]} {continue} set LesMots [LesMotsDeLaLigneTabulee $Ligne $TabIn] set LesBons {} foreach Mot $LesMots { if {0 && [regexp $TabOut $Mot]} { FaireLire $Mot } regsub -all $TabOut $Mot $ReplaceTabOut Bon lappend LesBons $Bon } set Bons [join $LesBons $TabOut] lappend LeNouveau $Bons } if {$GetWhat=="GetListOfHeaderValues"} { return $LeNouveau } set Headers [lindex $LeNouveau 0] if {$GetWhat=="GetHeaders"} { return $Headers } if {$GetWhat=="GetListOfHeaders"} { return [split $Headers $TabOut] } set LesNouvellesValeurs [lrange $LeNouveau 1 end] if {$GetWhat=="GetListOfValues"} { return $LesNouvellesValeurs } SauveLesLignes $LesNouvellesValeurs dans $Export return [SauveLesLignes $LeNouveau dans $Nouveau] } proc Tag2MolObjAtm {i} { set x [expr {[string length $i]-4}] scan $i "%${x}d%02d%02d" atm iobj imol set mol [lindex $::StrucAVoir $imol] set mol "::[DonneIdDeAccessPDB $mol]" set obj [lindex [$mol _ListeObjets] $iobj] return [list $mol $obj $atm] } proc TagLaFenetre {args} { global NomTextSeq LSOrdali if {$::TypeSeq eq "DNA"} { set Lgaa [list A G C T U] set Lfreg [list A G C T U] } else { # set Lgaa [list STAC DE IJLMV FYW P RK Q G HN] # take one representative per group set Lgaa [list S D I F P R Q G H] set Lfreg [list "S|T|A|C" "D|E" "I|J|L|M|V" "F|Y|W" "P" "R|K" "Q" "G" "H|N"] } $NomTextSeq configure -state normal lassign [$::TScrollX get] fx1 fx2 lassign [$::TScrollY get] fy1 fy2 set w [LongueurDeLAlignement] set h [llength $LSOrdali] set xm [expr {int($fx1*$w)-1}] set xx [expr {int($fx2*$w)+1}] set ym [expr {int($fy1*$h)-1}] set yx [expr {int($fy2*$h)+1}] foreach a $Lgaa freg $Lfreg { $NomTextSeq tag remove Tag$a 1.0 end set lt {} for {set y $ym ; set yt [expr {$ym-1}]} {$y <= $yx} {incr y ; incr yt} { # set yt [expr {$y-1}] set t [string range [lindex $LSOrdali $yt] $xm $xx] set lv [regexp -all -inline -indices -- $freg $t] foreach e $lv { lassign $e d f lappend lt $y.[expr {$d+$xm+1}] $y.[expr {$f+$xm+2}] } } if {$lt != {}} { $NomTextSeq tag add Tag$a {*}$lt } } $NomTextSeq configure -state disabled return } proc TagNode {AId} { global Abr set t [set Abr(Arbre,$AId)] set PAD [set Abr($AId,PAD)] set Li [$PAD gettags [$PAD find withtag current]] if {[set ix [lsearch -regexp $Li "rota-"]] ==-1} { return } set i [lindex $Li $ix] set n [$t attr $i] set Abr($AId,NodeSel) $n set Lbox [$PAD bbox $i] set Id [$PAD create oval $Lbox -fill black -outline black -tags IdNodeSel] set Li [$PAD find withtag rotation] foreach i $Li { $PAD itemconfig $i -fill white -outline white } $PAD lower rotation $PAD bind rotation "" $PAD bind IdNodeSel [list $PAD delete IdNodeSel ; set Abr($AId,NodeSel) ""] return } proc TagNomsSelectionnes {} { foreach e $::NomSeqSel { $::NomNomSeq tag add InvNm $e "$e wordend" } return } proc TagSeqsGroupees {} { global ListeSeqsGroupees global LNSeqlab global NomNomSeq foreach t [array names ListeSeqsGroupees] { set Tcol "TC$t" set Ls [set ListeSeqsGroupees($t)] foreach s $Ls { set i [lsearch $LNSeqlab $s] $NomNomSeq tag cell $Tcol $i,0 } } return } proc Tagoff {Value Index K} { global CouleurTag set CouleurTag "CouleurTagParDefaut" } proc Tagon {Value Index K} { global CouleurTag set CouleurTag $Value } proc TagsDuDump {d} { set Ltags {} set YaFnd 0 set TOn 0 set TOff 0 set ld [split $d " "] foreach {k v i} $ld { if {$v eq "InvS"} {continue} if {$v eq "Fnd" && !$YaFnd} { lappend Ltags $v 0 "end-1c" set YaFnd 1 } if {$k eq "tagon"} { lassign [split $i "."] y1 x1 set TOn 1 } if {$k eq "tagoff"} { lassign [split $i "."] y2 x2 if {! $TOn} {set x1 -1} lappend Ltags $v $x1 $x2 set TOn 0 } } if {$TOn} {lappend Ltags $v $x1 "Fin"} return $Ltags } proc TagsGenerauxFenetre {} { $::NomNomSeq tag configure InvNm -background black -foreground white $::NomNomSeq tag configure NrmNm -background white -foreground black return } proc TailleDeLAcNuc_PageInfo {PageInfo} { set Taille "" foreach Ligne [split $PageInfo "\n"] { if {![string equal -nocase [string range $Ligne 0 5] "LOCUS "]} {continue} regexp -nocase {([0-9]+) bp} $Ligne tmp Taille break } return $Taille } proc TailleDeLAccess {Access {Banque ""}} { set PageInfo [PageInfo $Access protein id] if {$PageInfo != ""} { return [TailleDeLaProt_PageInfo $PageInfo] } else { set PageInfo [PageInfo $Access genbankfull id] return [TailleDeLAcNuc_PageInfo $PageInfo] } return } proc TailleDeLaBanque {Banque} { set Taille 0 foreach F [glob -nocomplain $Banque.*] { set Size [file size $F] incr Taille $Size } return "$Taille [expr $Taille/1000 + 1]KO [expr $Taille/1000000 + 1]MO [expr $Taille/1000000000 + 1]GO" } proc TailleDeLaProt_PageInfo {PageInfo} { set Taille "" foreach Ligne [split $PageInfo "\n"] { if {![string equal -nocase [string range $Ligne 0 2] "ID "]} {continue} regexp -nocase {([0-9]+) AA} $Ligne tmp Taille break } return $Taille } proc TailleDeLaQueryDuBlast {FichierBlast} { if {[file exists $FichierBlast]} { set F [open $FichierBlast] set nHits 0 set Taille "" while {[gets $F Ligne]>=0} { if {[regexp "\[0-9\,]* letters" $Ligne tmp]} { regsub " letters" $tmp "" Taille regsub "\," $Taille "" Taille break } } close $F return "$Taille" } else { return "" } } proc TailleDeLaSequenceDuFichierTFA {FichierTFA} { if {![file exists $FichierTFA]} {return ""} return [string length [string trim [QueLaSequenceDuFichierTFA $FichierTFA]]] } proc TailleDesAffymetrix {} { #cette proc fait des tas #ici de 1000 #pour les sequences <10000 foreach Nom [ListeDesPABs] { set L [SeqLength $Nom] if {$L>10000} { continue } set L [expr $L/1000] lappend LesLongueurs $L } Histogramme $LesLongueurs Graphe } proc TailleDesInsertions_article {RepMACSResults Famille FichierMACS} { Wup "Permet de calculer la taille moyenne, le min et le max des insertions des ARPs" Wup "Besoin un alignement au format msf sans features" set AccessDeRef "P02568" set LesFichiersASupprimer "" #1 Liste des Access a traiter a priori ###################################### set LesQuery_tmp [InterrogeLesInfosDesARPs $Famille LesAccess] # Recuperation des Access effectivement dans l alignement DecortiqueUnMSF $FichierMACS LesNoms Sequences set LesQuery "" foreach Q $LesQuery_tmp { if {! [regexp $Q $LesNoms]} {continue} lappend LesQuery $Q } set Query [join $LesQuery "\n"] #2 Recherche des positions equivalentes pour ces insertions dans la query ######################################################################### # Les positions des insertions dans la sequence de reference set LesPositionsDesDomaines [InterrogeLesDomainesDesARPs $Famille $AccessDeRef IN LesPositions] if {$LesPositionsDesDomaines==""} {return "-2"} # Creation du fichier pour aller questionner l alignement avec aln_pos set LesDFPositionsDesDomaines "" foreach Position $LesPositionsDesDomaines { lappend LesDFPositionsDesDomaines $Position lappend LesDFPositionsDesDomaines [expr $Position + 1] } set LesDFPositionsDesDomaines [join $LesDFPositionsDesDomaines " "] if {$LesDFPositionsDesDomaines == ""} {return "-2"} set FichierPosDomTmpDeRef "$RepMACSResults/PosDomTmpDeRef_${Famille}" if {[file exists $FichierPosDomTmpDeRef]} {file delete -force $FichierPosDomTmpDeRef} set LesLignes [list $AccessDeRef $LesDFPositionsDesDomaines $Query] AppendAuFichier $FichierPosDomTmpDeRef [join $LesLignes "\n"] set LesLignes "" lappend LesFichiersASupprimer $FichierPosDomTmpDeRef # On questionne l alignement avec aln_pos # On recherche les positions des insertions de la ref dans notre query pour toutes les insertions # Creation d un fichier contenant les positions equivalentes qui ont ete recherchees pour la query set FichierResTmp "$RepMACSResults/PosDomEquiTmpDeRef_${Famille}" if {[file exists $FichierResTmp]} {file delete -force $FichierResTmp} set Result [RetrievePositionsInMACS "$FichierMACS" $FichierPosDomTmpDeRef "$FichierResTmp"] if {$Result=="-1"} {Espionne "Pb RetrieveResidueInMACS";return ""} lappend LesFichiersASupprimer $FichierResTmp # Boucle sur les couples de positions (debut et fin) de la query pour tous les domaines set LesDFPositionsDesDomaines [split $LesDFPositionsDesDomaines " "] foreach Acc $LesQuery { set LesPositions [InterrogeRetrievePositionsInMACS $FichierResTmp $Acc LesPositions] foreach {DomainD DomainF} $LesPositions {RefD RefF} $LesDFPositionsDesDomaines { #Verification des positions initiales pour les extremites N-Ter et C-Ter #si N-Ter on remet la position de debut a 1 #si C-Ter on ne touche pas car le prog de Julie va prendre la fin automatiquement (bug ??) if {$RefD=="1"} { #On a une extension en N-Terminal set DomainD 1 } #3 Calcul de la taille de l insertion pour la query ################################################### set TailleInsertQuery [expr $DomainF - $DomainD] if {! [info exists TabDomain($RefD)]} { set TabDomain($RefD) "" } if {! [info exists TabDomain($RefD,Min)]} { set TabDomain($RefD,Min) 100000000000 } if {! [info exists TabDomain($RefD,Max)]} { set TabDomain($RefD,Max) 1 } lappend TabDomain($RefD) $TailleInsertQuery if {$TailleInsertQuery > [set TabDomain($RefD,Max)]} { set TabDomain($RefD,Max) $TailleInsertQuery } if {$TailleInsertQuery < [set TabDomain($RefD,Min)]} { set TabDomain($RefD,Min) $TailleInsertQuery } #Espionne "$Acc -- $RefD - $DomainF / $DomainD - $TailleInsertQuery" } } #4 Affichage des resultats ########################## Espionne "$Famille" Espionne "PosRef\tMeanLength\tMinLength\tMaxLength" foreach {D F} $LesDFPositionsDesDomaines { set LesDebutTaille [set TabDomain($D)] set Nb [llength $LesDebutTaille] set Mean [expr 1.0*(([join $LesDebutTaille "+"])/$Nb)] Espionne "$D\t$Mean\t[set TabDomain($D,Min)]\t[set TabDomain($D,Max)]" } #5 Suppression des fichiers ########################### foreach F $LesFichiersASupprimer { if {[file exists $F]} {file delete -force $F} } return "" } proc TailleDesJunkdirs {{Quoi ""}} { Wup "Donne la taille des junkdirs des personnes appartenant au groupe Poch" set CoefDiv 1 if {$Quoi==""} {set Quoi enmega } if {$Quoi=="enkilo"} {set CoefDiv 1e3} if {$Quoi=="enmega"} {set CoefDiv 1e6} set Listing [lsort [glob -nocomplain "/groupes/poch/*"]] foreach element $Listing { if {! [file isdirectory $element]} {continue} lappend ListePoch $element } foreach Repertoire $ListePoch { set NomAAfficher "Junkdir de " if {[File exists "$Repertoire/junkdir"]} { regsub "/groupes/poch/" $Repertoire "" QuiCest append NomAAfficher $QuiCest set TailleRepJunkdir [TailleDuRepertoire "$Repertoire/junkdir"] Espionne [format "%-25s%13d" $NomAAfficher [expr round($TailleRepJunkdir*1.0/$CoefDiv)]] } continue } } proc TailleDesSeq {LesQuery} { set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set Repnuctfa "[RepertoireDuGenome]/nuctfa" if {$LesQuery=="LaTotale"} {set LesQuery [ListeDesPABs]} foreach PAB $LesQuery { if {[file exists "$RepmRNA/$PAB"]} { set FichierQuery "$RepmRNA/$PAB" } elseif {[file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } else {Espionne "No File for the Query ($PAB)";continue} Espionne "$PAB [string length [QueLaSequenceDuFichierTFA $FichierQuery]]" } } proc TailleDesSequencesAAligner {{Liste ""}} { set EnDetails 0 if {$Liste==""} { set Liste [ListeDesPABs] } if {[EstUnPAB $Liste]} { set EnDetails 1 set Liste [list $Liste] set LesLongueursAccess {} } foreach Nom $Liste { set Fichier "[RepertoireDuGenome]/tfasdescopains/$Nom" if { ! [file exists $Fichier]} { continue } set MinLong 999999 set MaxLong 0 set LesLongueurs {} foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] { set TFA [LaSequenceDuTFAs $Fichier $Access] set Long [string length [QueLaSequenceDuTexteTFA $TFA]] lappend LesLongueurs $Long if {$EnDetails} { set Entete [EnteteDuTexteTFA $TFA] lappend LesLongueursAccess "$Long $Entete" } set MinLong [Mini $MinLong $Long] set MaxLong [Maxi $MaxLong $Long] } set LesLongueurs [lsort -integer $LesLongueurs] if {$EnDetails} { set LesLongueursAccess [lsort -index 0 -integer $LesLongueursAccess] return [AfficheVariable [join $LesLongueursAccess "\n"] "AvecFetch" "SequenceLengthesOf/$Fichier"] } if {$MaxLong<1000} { continue } lappend ToutesLesLongueurs "$Nom $MaxLong" } if {$EnDetails} { exit } set ToutesLesLongueurs [lsort -index 1 -integer $ToutesLesLongueurs] SauveLesLignes $ToutesLesLongueurs dans "[RepertoireDuGenome]/fiches/toutesleslongueurs" exit } proc TailleDesTFAsDesCopains {} { foreach Nom [ListeDesPABs] { set FiTFAs [GscopeFile $Nom "tfasdescopains"] if {[FileAbsent $FiTFAs]} { incr C(-1) ; lappend T(-1) $Nom; continue } set TFAs [ContenuDuFichier $FiTFAs] set N [regexp -all ">" $TFAs] if { 0 <= $N && $N < 1 } { incr C(0) ; lappend T(0) $Nom; continue } if { 1 <= $N && $N < 2 } { incr C(1) ; lappend T(1) $Nom; continue } if { 2 <= $N && $N < 3 } { incr C(2) ; lappend T(2) $Nom; continue } if { 3 <= $N && $N < 10 } { incr C(7) ; lappend T(7) $Nom; continue } set D 0 set I 10 while {$D < 500} { incr D $I ; set F $D ; incr F $I ; set M [expr ($D+$F)/2] if { $D <= $N && $N < $F } { incr C($M) ; lappend T($M) $Nom; break } } } foreach N [lsort -integer [array names C]] { if {$C($N) > 10 } { lappend LeResultat "$N $C($N)" } else { lappend LeResultat "$N $C($N) $T($N)" } } AfficheListe $LeResultat } proc TailleDuChromosomeEnMb {Chromo} { set LesTailles [list 0 245 243 199 191 180 170 158 145 134 135 134 133 114 105 100 90 81 77 63 63 46 49 152 50 1] if {$Chromo=="LaListeMerci"} { return [lrange $LesTailles 1 end] } if { ! [regexp -nocase {^HS[0-9]{2}$|^HS[XY]{1}$|^HSun$} $Chromo]} { return -1 } regsub -nocase "X" $Chromo 23 Chromo regsub -nocase "Y" $Chromo 24 Chromo regsub -nocase "un" $Chromo 25 Chromo regsub -all {[^0-9]} $Chromo "" Numero regsub "^0" $Numero "" Numero if {0<$Numero && $Numero <26} { return [lindex $LesTailles $Numero] } return -2 } proc TailleDuContig {Chromosome Contig {nChiffres ""}} { if {$nChiffres == ""} {set nChiffres [NbDeChiffresPourLeFragmentDuContig $Chromosome $Contig]} set Fragment [string repeat 0 $nChiffres] if {$nChiffres != 0} { set BId "$Chromosome:${Contig}_$Fragment" } else { set BId "$Chromosome:$Contig" } set LaFiche [LaSequenceDesBanques $BId $BId AccessOk "OnVeutNature"] if {$LaFiche == {} } {return ""} foreach Ligne $LaFiche { if {![regexp "^LOCUS" $Ligne]} {continue} scan $Ligne "%s %s %d" LOCUS Contig Taille break } return $Taille } proc TailleDuDescriptifDuBlastP {{Ask ""}} { global RepertoireDuGenome global GscopeDir global TailleDuDescriptifDuBlastP set Ask [regexp -nocase "^Ask$" $Ask] if {! $Ask && [info exists TailleDuDescriptifDuBlastP]} { return $TailleDuDescriptifDuBlastP } set FichierTaille "$RepertoireDuGenome/fiches/sizedescriptif" if { $Ask || ! [file exists $FichierTaille]} { set FichierTailleDefaut "$GscopeDir/gscope_sizedescriptif" if {[file exists $FichierTailleDefaut] && [OuiOuNon "Do I copy the file \n $FichierTailleDefaut\n to $FichierTaille\n ?"]} { File copy $FichierTailleDefaut $FichierSortie } else { while {[OuiOuNon "Do You want to load an existing file with sizes for description ?"]} { set F [ButineArborescence "All" $RepertoireDuGenome] if {$F==""} { continue } if {[OuiOuNon "Do I copy it to $FichierTaille ?"]} { File copy -force $F $FichierTaille } else { set FichierTaille $F } break } } } if {[file exists $FichierTaille]} { set VT [ContenuDuFichier $FichierTaille] } else { set VT "90 120 30 10. respectively : at_least max_with_complete_genomes max_pdb expect" set Ask 1 } while {$Ask && [OuiOuNon "Do You want to modify the sizes ?"]} { set NewVT [Entre $VT] if {$NewVT==""} { continue } set VT $NewVT if {[OuiOuNon "Do I save these values in $FichierTaille ?"]} { Sauve $VT dans $FichierTaille } } set TailleDuDescriptifDuBlastP $VT return $VT } proc TailleDuRepertoire {{Repertoire ""}} { Wup "Rend la taille d'un repertoire" if {$Repertoire==""} {return 0} set Taille 0 foreach file [glob -nocomplain "$Repertoire/*"] { set Taillefile 0 if {![File readable $file]} {continue} set Taillefile [File size $file] #Espionne "$file $Taillefile" if {[File isdirectory $file]} { set Taille [expr [TailleDuRepertoire $file] + $Taille] } else { set Taille [expr $Taillefile + $Taille] } } return $Taille } proc TailleEchantillon {FichierCod} { set TailleEchantillon 0 foreach Ligne [LesLignesDuFichier $FichierCod] { set Ligne [string trim $Ligne] if {$Ligne==""} {continue} if {[regexp {^Gly} $Ligne]} { set VuDebut 1 scan $Ligne "%s %s %s" aa cod n set TailleEchantillon [expr $TailleEchantillon +$n] } else { if {![info exists VuDebut]} {continue} if {[info exists VuDebut]} { scan $Ligne "%s %s %s" aa cod n set TailleEchantillon [expr $TailleEchantillon +$n] } } } return $TailleEchantillon } proc TailleFonte {incr} { set size [font configure SeqFont -size] incr size $incr # keep font sizes sane... if {$size >= 6 && $size <= 32} { font configure SeqFont -size $size } else { return } if {[QuelMode] eq "seqlab"} { #puts "change fonte $incr" set wgt [font configure SeqFont -weight] set fam [font configure SeqFont -family] set fam [string map [list " " ""] $fam] $::NomTextSeq font family $fam size $size weight $wgt if {$incr > 0} { #$::NomTextSeq font bigger } else { #$::NomTextSeq font smaller } } update ReDessineLesScores FenetreAuCentre $::NomFenetreOrdali return } proc TailleMoyenne {ExonOuIntron NumeroExonOuIntron {org human_hg18} {fromwhere refGene}} { CanalSqlUcsc $org # Donne la taille moyenne d'un exon ou d'un intron donné sur un ensemble de génes if { [regexp -nocase "Last" $ExonOuIntron]} { regsub -all -nocase "Last" $ExonOuIntron "" ExonOuIntron set NumeroExonOuIntron "Last" } # Initialisation : set Liste {} set StartsDuCount {} set EndsDuCount {} set I 0 set J 0 set LongueurTotale 0 # Déclaration des fichiers if {$fromwhere==""} { set fromwhere "refGene" } set Numero $NumeroExonOuIntron if {$NumeroExonOuIntron == "Last"} { set NumeroExonOuIntron 1} if { $ExonOuIntron == "Intron" || $ExonOuIntron == "IntronLast"} { set Where "exonCount > $NumeroExonOuIntron" } if { $ExonOuIntron == "Exon" || $ExonOuIntron == "ExonLast"} { set Where "exonCount >= $NumeroExonOuIntron" } set ListeDesExonsStarts {} set ListeDesExonsEnds {} set timestamp [clock format [clock seconds] -format "%H:%M:%S"] set Query "select name from ucsc$org.$fromwhere where $Where order by txStart" foreach name [SqlExec $Query] { lappend ListeName $name } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] #Espionne "TailleMoyenne|$timestamp : Stockage des exonCount" set Query "select exonCount from ucsc$org.$fromwhere where $Where order by txStart" foreach exonCount [SqlExec $Query] { lappend ListeCount $exonCount } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] #Espionne "TailleMoyenne|$timestamp : Stockage des Start" set Query "select exonStarts from ucsc$org.$fromwhere where $Where order by txStart" foreach start [SqlExec $Query] { lappend ListeStart $start } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] #Espionne "TailleMoyenne|$timestamp : Stockage des End" set Query "select exonEnds from ucsc$org.$fromwhere where $Where order by txStart" foreach end [SqlExec $Query] { lappend ListeEnd $end } #Espionne "TailleMoyenne|$timestamp : Stockage des Strand" set Query "select strand from ucsc$org.$fromwhere where $Where order by txStart" foreach strand [SqlExec $Query] { lappend ListeStrand $strand } set NumeroExonOuIntron $Numero foreach Count $ListeCount { set Strand [lindex $ListeStrand $I] set Acc [lindex $ListeName $I] set StartsDuCount [split [lindex $ListeStart $I] ","] set EndsDuCount [split [lindex $ListeEnd $I] ","] set Numero $NumeroExonOuIntron if {$NumeroExonOuIntron == "Last" && $ExonOuIntron == "Intron"} { set NumeroExonOuIntron [expr $Count - 1] } if {$NumeroExonOuIntron == "Last" && $ExonOuIntron == "Exon"} { set NumeroExonOuIntron $Count } incr I if { $Strand == "+"} { if {$ExonOuIntron == "Exon" } { set Start [lindex $StartsDuCount [expr $NumeroExonOuIntron - 1]] set End [lindex $EndsDuCount [expr $NumeroExonOuIntron - 1]] } else { set Start [lindex $EndsDuCount [expr $NumeroExonOuIntron - 1]] set End [lindex $StartsDuCount $NumeroExonOuIntron] } } else { # Attention : la liste des exons se terminant aussi par une virgule, les listes contiennet un élément vide é la fin if {$ExonOuIntron == "Exon" } { set Start [lindex $StartsDuCount [expr $Count - $NumeroExonOuIntron ]] set End [lindex $EndsDuCount [expr $Count - $NumeroExonOuIntron]] } else { set Start [lindex $EndsDuCount [expr $Count - 1 - $NumeroExonOuIntron]] set End [lindex $StartsDuCount [expr $Count - $NumeroExonOuIntron]] #Espionne "$Acc $Strand $Start $End" } } if { $Start != "" && $End != ""} { incr J set LongueurExonOuIntron [expr $End - $Start + 1] set LongueurTotale [expr $LongueurTotale + $LongueurExonOuIntron] } set NumeroExonOuIntron $Numero } set LongueurMoyenne [expr round($LongueurTotale/$J)] #Espionne "===========================================" #Espionne " Statistiques du traitement TailleMoyenne =" #Espionne "===========================================" #Espionne " " #Espionne "* Organisme considere: $org" #Espionne "* Entite consideree: $ExonOuIntron $NumeroExonOuIntron" #Espionne "* Nombre de genes possedant cette entite : $I" #Espionne "* Nombre de genes corrects possédant cette entite : $J" #Espionne "* Somme des longueurs de cette entite : $LongueurTotale pb" #Espionne "* Longueur moyenne de cette entite: $LongueurMoyenne pb" #Espionne " " return $LongueurMoyenne } proc TailleProteome {Qui} { global TailleProteome if {[OnTraite "OI2017" "Like"]} { return [OiProteomeSize $Qui] } if {[info exists TailleProteome($Qui)]} { return $TailleProteome($Qui) } if {[info exists TailleProteome("EstCharge")]} { return -1 } set TailleProteome("EstCharge") 1 set Fichier "[RepertoireDuGenome]/banques/Proteome201501_TaillesDesOs.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {^([0-9]+)[ \t].+_([0-9]+)} $Ligne Match Taille TaxId]} { continue } set TailleProteome($TaxId) $Taille } set TailleProteome(9606) 20193 ; #rR dans la banque il y en a 66922 #rR on n'a gardé que les swissprot return [TailleProteome $Qui] } proc TailleSequenceEPDOuDBTSS {EPDOuDBTSS} { if {$EPDOuDBTSS == "EPD"} {set TailleSequenceEPDOuDBTSS 600} if {$EPDOuDBTSS == "DBTSS"} {set TailleSequenceEPDOuDBTSS 1200} return $TailleSequenceEPDOuDBTSS } proc TailleSortiePourDBClustal {{Ask ""}} { global RepertoireDuGenome global GscopeDir global TailleSortiePourDBClustal set Ask [regexp -nocase "^Ask$" $Ask] if {! $Ask && [info exists TailleSortiePourDBClustal]} { return $TailleSortiePourDBClustal } set FichierTailleSortie "$RepertoireDuGenome/fiches/sizemsf" if { $Ask || ! [file exists $FichierTailleSortie]} { set FichierTailleSortieDefaut "$GscopeDir/gscope_sizemsf" if {[file exists $FichierTailleSortieDefaut] && [OuiOuNon "Do I copy the file \n $FichierTailleSortieDefaut\n to $FichierTailleSortie\n ?"]} { File copy $FichierTailleSortieDefaut $FichierTailleSortie } else { while {[OuiOuNon "Do You want to load an existing file with output sizes for dbclustal ?"]} { set F [ButineArborescence "All" $RepertoireDuGenome] if {$F==""} { continue } if {[OuiOuNon "Do I copy it to $FichierTailleSortie ?"]} { File copy -force $F $FichierTailleSortie } else { set FichierTailleSortie $F } break } } } if {[file exists $FichierTailleSortie]} { set VT [ContenuDuFichier $FichierTailleSortie] } else { set VT "40 70 30 0.001 respectively : at_least max_with_complete_genomes max_pdb expect" set Ask 1 } while {$Ask && [OuiOuNon "Do You want to modify the output sizes ?"]} { set NewVT [Entre $VT] if {$NewVT==""} { continue } set VT $NewVT if {[OuiOuNon "Do I save these values in $FichierTailleSortie ?"]} { Sauve $VT dans $FichierTailleSortie } } set TailleSortiePourDBClustal $VT return $VT } proc TaisToi {{Silence ""}} { if {$Silence eq ""} {set Silence 1} if {$Silence} { if {"putsCmdOriginale" ni [info commands]} { rename ::puts ::putsCmdOriginale rename ::PutsDuTaisToi ::puts } } else { if {"putsCmdOriginale" in [info commands]} { rename ::puts PutsDuTaisToi rename ::putsCmdOriginale ::puts } } return } proc Tamis {{TamisOuListe ListeDesPABs} {Action ForAll} {TamisOuListe2OuGrilleOuCritere X} {Operateur ""} {Valeur ""}} { if {[regexp "^NewTamis" $TamisOuListe]} { regsub "NewTamis" $TamisOuListe "" Action set TamisOuListe "X" set TamisOuListe2OuGrilleOuCritere "X" } if {$TamisOuListe=="X"} { set NomTamisEntrant [ChoisisUnTamis "ChampNom"] if {$NomTamisEntrant==""} { return {} } set ComTamisEntrant [LeTamis $NomTamisEntrant] } elseif {[LeTamis $TamisOuListe]!="TamisInconnu"} { set NomTamisEntrant $TamisOuListe set ComTamisEntrant [LeTamis $NomTamisEntrant] } else { set NomTamisEntrant $TamisOuListe set ComTamisEntrant $TamisOuListe } if {[regexp -nocase "ForAll" $Action]} { if {$ComTamisEntrant=="TamisInconnu"} { return {} } return [eval $ComTamisEntrant] } if {[regexp -nocase "And|Or|ButNot" $Action]} { set TamisOuListe2 $TamisOuListe2OuGrilleOuCritere if {$TamisOuListe2=="X"} { set NomTamisEntrant2 [ChoisisUnTamis "ChampNom"] if {$NomTamisEntrant2==""} { return {} } set ComTamisEntrant2 [LeTamis $NomTamisEntrant2] } elseif {[LeTamis $TamisOuListe2]!="TamisInconnu"} { set NomTamisEntrant2 $TamisOuListe2 set ComTamisEntrant2 [LeTamis $NomTamisEntrant2] } else { set NomTamisEntrant2 $TamisOuListe2 set ComTamisEntrant2 $TamisOuListe2 } set Commande "Tamis $NomTamisEntrant $Action $NomTamisEntrant2" NommeEtStockeLeTamis $Commande if {$ComTamisEntrant=="TamisInconnu"} { set ListeDeNoms1 {} } else { set ListeDeNoms1 [eval $ComTamisEntrant] } if {$ComTamisEntrant2=="TamisInconnu"} { set ListeDeNoms2 {} } else { set ListeDeNoms2 [eval $ComTamisEntrant2] } switch [string toupper $Action] { "AND" { return [ListsIntersection $ListeDeNoms1 $ListeDeNoms2] } "OR" { return [ListsUnion $ListeDeNoms1 $ListeDeNoms2] } "BUTNOT" { return [ListsComplement $ListeDeNoms1 $ListeDeNoms2] } } FaireLire "Y a un probleme dans Tamis" return {} } if {[regexp -nocase "Where" $Action]} { set NoMayBe "NoMayBe" set GrilleOuCritere $TamisOuListe2OuGrilleOuCritere if {$Operateur==""} { set Grille $GrilleOuCritere if {$Grille=="X"} { set Grille [ChoisisUneGrille] } set NoMayBe $Grille set COV [NoCo "Commande" $Grille] ScanCOV $COV Critere Operateur Valeur } else { set Critere $GrilleOuCritere } if {$Critere=="X"} { set Critere [ChoisisLeCritere] if {$Critere==""} { set Critere "AlwaysTrue" set Operateur "==" set Valeur "1" } } if {$Operateur=="X"} { set Operateur [ChoixDansLaListe {"<" "<=" "==" ">=" ">" "!=" "Contains" "NotContains"} ] } if {$Valeur=="X"} { set Valeur [Entre] } if {$Valeur=="?"} { set QuestionnerToujours 1 set Valeur [Entre] } else { set QuestionnerToujours 0 } if {$QuestionnerToujours} { set COV "$Critere $Operateur ?" } else { set COV "$Critere $Operateur $Valeur" } set Grille [NoCo "MieuxNommer" $NoMayBe $COV] set Commande "Tamis $NomTamisEntrant $Action $Grille" NommeEtStockeLeTamis $Commande set LesBons {} set CasFavorables {} switch $Operateur { "<" { set CasFavorable {"-1"} } "<=" { set CasFavorable {"-1" "0"} } "==" { set CasFavorable {"0"} } ">=" { set CasFavorable {"0" "1"} } ">" { set CasFavorable {"1"} } "!=" { set CasFavorable {"-1" "1"} } default { set CasFavorable "1" } } regsub {\?$} $Valeur "" Valeur if {$ComTamisEntrant=="TamisInconnu"} { return {} } set ListeDeNoms [eval $ComTamisEntrant] set AutresArgs "" set SesArgs [info args $Critere] set nArgs [llength $SesArgs] if {$nArgs>1} { FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them." set AutresArgs [Entre] } foreach Nom $ListeDeNoms { if {$AutresArgs==""} { set ValeurCalculee [eval $Critere $Nom] } else { set ValeurCalculee [eval $Critere $Nom $AutresArgs] } if {$Operateur=="Contains"} { set T [regexp -nocase "$Valeur" "$ValeurCalculee"] } elseif {$Operateur=="NotContains"} { set T [expr ! [regexp -nocase "$Valeur" "$ValeurCalculee"]] } else { if { ! [catch {if {[expr $ValeurCalculee $Operateur $Valeur]} { lappend LesBons $Nom }}]} { continue } set T [string compare $ValeurCalculee $Valeur] } foreach Cas $CasFavorable { if {$T==$Cas} { lappend LesBons $Nom break } } } return $LesBons } if {[regexp -nocase "Keep" $Action]} { set NoMayBe "NoMayBe" set Critere $TamisOuListe2OuGrilleOuCritere if {$Critere=="X"} { set Critere [ChoisisLeCritere] if {$Critere==""} { set Critere "AlwaysTrue" } } set COV [NoCo "Commande" $Critere] if {$COV!=""} { set NoNomme $Critere set Critere $COV } else { # on pourrait y rajouter des args supplementaires pris dans operateur et valeur set COV $Critere set NoNomme [NoCo "MieuxNommer" $NoMayBe $COV] } set Commande "Tamis $NomTamisEntrant $Action $NoNomme" NommeEtStockeLeTamis $Commande set LesBons {} if {$ComTamisEntrant=="TamisInconnu"} { return {} } set ListeDeNoms [eval $ComTamisEntrant] set AutresArgs "" set SesArgs [info args $Critere] set nArgs [llength $SesArgs] if {$nArgs>1} { FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them." set AutresArgs [Entre] } foreach Nom $ListeDeNoms { if {$AutresArgs==""} { set ValeurCalculee [eval $Critere $Nom] } else { set ValeurCalculee [eval $Critere $Nom $AutresArgs] } lappend LesBons "$Nom $ValeurCalculee" } return $LesBons } FaireLire "Action $Action unknown in Tamis" return {} } proc TamponNFois {quoi {n ""}} { global Tampon set res 1 switch $quoi { "init" {set Tampon ""} "ajoute" { if {! [string is integer $n]} {return} append Tampon $n } "vide" { if {$Tampon ne ""} { set res $Tampon set Tampon "" } } } return $res } proc TarDeGscope {{TarDestin ""}} { if {$TarDestin==""} { set TarDestin "[GscopeDir]/gscope.tar" } if { ! [regexp "^/" $TarDestin]} { set TarDestin "[pwd]/$TarDestin" } if { ! [OuiOuNon "Ok to create $TarDestin ?"]} { return ""} set LesSourcesDeGscope [LesSourcesDeGscope "Relatif" "AvecMain"] set RepDessus "[GscopeDir]/.." NousAllonsAuBoulot $RepDessus if {[file exists $TarDestin]} { file delete $TarDestin } foreach S $LesSourcesDeGscope { set BonS "gscope/$S" Espionne $BonS set UC "u" if { ! [file exists $TarDestin]} { set UC "c" } exec tar -${UC}hf $TarDestin $BonS } OnRevientDuBoulot return $TarDestin } proc TasTamis {{Tam ""} {Fichier ""}} { global TasTamis Wup "Create a file Fichier (or returns a list) with 'Nom Value' foreach Nom verifying Tam" if {[info exists TasTamis]} { unset TasTamis } CreeLeTasTamis $Tam set Liste {} foreach Nom [array names TasTamis] { lappend Liste "$Nom [set TasTamis($Nom)]" } if {$Fichier==""} { return $Liste } else { return [SauveLesLignes $Liste dans $Fichier] } } proc Tau {{Qui ""} {Quoi ""}} { global Tau if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" } if {[info exists Tau($Qui,$Quoi)]} { return $Tau($Qui,$Quoi) } if {[info exists Tau("EstCharge")]} { return "" } set Tau("EstCharge") 1 #set Fichier "/genomics/link/Tau/GSTControl/BlastpSurStringHomme/9606.string" #set Fichier "/genomics/link/Tau/GSTControl/BlastpSurStringHomme/9606_SsTm.string" set Fichier "/genomics/link/Tau/Dec2008/GSTControl/BlastpSurStringHomme/9606.string" set Q [file tail $Fichier] regsub -nocase {\.[^\.]+$} $Q "" Q LoadTxlWithRowsOfCells $Fichier Txl -1 "\t" set Tau(File,Name) $Fichier set Tau(File,Queue) $Q set Tau(ListOf,Header) $Txl(ListHeaderPlease,$Q) set Tau(ListOf,Index) $Txl(ListAllPlease,$Q) foreach I $Tau(ListOf,Index) { foreach H $Tau(ListOf,Header) { set Tau($I,$H) $Txl($I,$H) } set PI $Txl($I,PIDInitial) set PC $Txl($I,PIDCop) lappend Tau($PI,ListOfCop) $PC lappend Tau($PC,ListOfRef) $PI lappend Tau(ListOf,Ref) $PI lappend Tau(ListOf,Cop) $PC set Tau($PI,IsRef) 1 if { ! [info exists Tau($PC,IsRef)]} { set Tau($PC,IsRef) 0 } } set Tau(ListOf,Ref) [lsort -unique $Tau(ListOf,Ref)] set Tau(ListOf,Cop) [lsort -unique $Tau(ListOf,Cop)] return [Tau $Qui $Quoi] } proc TauNew {} { set Fichier [Tau File Name] regsub "\.string$" $Fichier "-QueInitial.string" NewFichier set LesHeader [Tau ListOf Header] set LesLignes {} lappend LesLignes [join $LesHeader "\t"] foreach I [Tau ListOf Index] { set PC [Tau $I PIDCop] if { ! [Tau $PC IsRef] } { continue } set LaLigne {} foreach H $LesHeader { lappend LaLigne [Tau $I $H] } lappend LesLignes [join $LaLigne "\t"] } EspionneL $LesLignes return [SauveLesLignes $LesLignes dans $NewFichier] } proc TauxAccessTrouves {Rep Database} { #Compte les access trouvés dans bird a apartir d'une liste d'access set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TauxAccessTrouves : Start" set FichierIn [open "$Rep/EpouvanBlast.XPacc" "r"] set FichierDesRequetes [open "/tmp/EpouvanBlastTAV.bql" "w"] gets $FichierIn Ligne set IDligne "ID $Ligne" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TauxAccessTrouves : Building queries" while { [gets $FichierIn Ligne] >=0 } { set IDligne "$IDligne,$Ligne" } puts $FichierDesRequetes "$IDligne DB $Database" puts $FichierDesRequetes "FD GET_COUNT" puts $FichierDesRequetes "//" close $FichierDesRequetes close $FichierIn set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TauxAccessTrouves : Executing queries" exec /biolo/bird/bin/birdql_client.sh /tmp/EpouvanBlastTAV.bql bird /tmp/EpouvanBlastTAV.res set FichierDesRequetesExecutees [open "/tmp/EpouvanBlastTAV.res" "r"] while { [gets $FichierDesRequetesExecutees Ligne2] >=0 } { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TauxAccessTrouves : $Ligne2" } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TauxAccessTrouves : End" } proc Tavernier {} { set R "hopla ! On est au Magos , gell !" return $R } proc TavernierDuMagos {f template maxSeq filter gapped maxE db} { NousAllonsAuBoulot "[MagosDir]/Depot" set LaCentrale "[MagosDir]/Centrale" Ragot Tavernier # set url "http://www-bio3d-igbmc.u-strasbg.fr/~friedric/XXXX" # pour lancer la procedure, Lyon nous envoie # http://www-bio3d-igbmc.u-strasbg.fr/~ripp/cgi-bin/gscope_html_server.tcsh?Magos&TavernierDuMagos&XXXX&none&100&1&1&1E-3&protall set url "http://pig-pbil.ibcp.fr/tmp/MODELING/XXXX/XXXX.tfa" set Lf [WgetzSurWeb $f $url] set foo [open $f w] puts $foo [join $Lf "\n"] close $foo #exec [file join $LaCentrale TraiteCommande.tcsh] $f $template $maxSeq $filter $gapped $maxE $db & Ragot "avant TraiteCommande" if {[catch {eval exec [file join $LaCentrale TraiteCommande.tcsh] $f $template $maxSeq $filter $gapped $maxE $db &} Message]} { Ragot $Message return "TraiteCommande se plante avec le message $Message" } Ragot "apres TraiteCommande" return "Commande passee \n" } proc Tax {Query {Quoi ""} {Valeur ""}} { regsub -all " +" [string trim $Query] "_" Query #f {[OnTraite "CilioCarta" "Like"] || [OnTraite MSP]} { return [QuestionDeScience EVImm "ret Tax $Query $Quoi $Valeur"] } if { ! [OnTraite EVImm] } { return [QuestionDeScience EVImm "ret Tax $Query $Quoi $Valeur"] } set TaxSystem [TaxSystem] return [Tax$TaxSystem $Query $Quoi $Valeur] } proc TaxC {TaxIdOuTaxName {E ""}} { global TaxI global TaxJ global TaxN global TaxC if {[info exists TaxC($TaxIdOuTaxName)]} { return [set TaxC($TaxIdOuTaxName)] } if {[regexp -nocase {[a-z]} $TaxIdOuTaxName]} { set TaxId [TaxI $TaxIdOuTaxName $E] } else { set TaxId $TaxIdOuTaxName } if {[info exists TaxC($TaxId)]} { return [set TaxC($TaxId)] } if {[info exists TaxC("EstCharge")]} { return "" } ChargeTaxIJNC return [TaxC $TaxId] } proc TaxClass {Query {AllOrRankOnly ""} {Reverse ""} {Quoi ""}} { global TaxClass #rR on parcourt recursivement les classes ... mais on stocke en memoire ce qui a deja ete vu if {$Query=="IsAlreadyLoaded"} { return [info exists TaxClass] } regsub -all "_" $Query " " Query if {$Query==""} { return "" } if {[regexp "^ERROR" $Query]} { return $Query } if {[regexp -nocase "Name" $AllOrRankOnly]} { set Quoi "Name"; set AllOrRankOnly "" } if {[regexp -nocase "Name" $Reverse]} { set Quoi "Name"; set Reverse "" } if {$Quoi==""} { set Quoi "TaxId" } if {[regexp -nocase "Name" $Quoi]} { set Quoi "Name" } if {[string equal -nocase $Reverse "Reverse"]} { set Reverse "Reverse" } else { set Reverse "Forward" } if {[regexp -nocase "RankOnly|Ranked" $AllOrRankOnly]} { set AllOrRankOnly "RankOnly" } else { set AllOrRankOnly "All" } if {$AllOrRankOnly==""} { set AllOrRankOnly "All" } if {[regexp -nocase {[a-z]} $Query]} { set Query [Tax $Query TaxId] } if {[info exists TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi)]} { return [set TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi)] } set Moi $Query if {$Moi==1} { return [Tax $Moi $Quoi]} set Moi [Tax $Moi $Quoi] set Parent [Tax $Query "Parent"] set Ancetres [TaxClass [Tax $Query "Parent"] $AllOrRankOnly $Reverse $Quoi] if {[regexp -nocase "Rank" $AllOrRankOnly] && [Tax $Query "Rank"]=="no rank"} { return $Ancetres } if {[string equal -nocase $Reverse "Reverse"]} { set Class "$Moi; $Ancetres" } else { set Class "$Ancetres; $Moi" } set TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi) $Class return $Class } proc TaxDB2Memory {} { global db TaxRoot Tx Lfeuilles LSelectableId LAllIds LCompleteId InitTaxDB $db eval {PRAGMA synchronous = OFF} #$db eval {PRAGMA journal_mode = MEMORY} $db eval {PRAGMA journal_mode = OFF} # depending on the database requested if {$Tx(-txdb) eq "uniprot"} { set dbtaxo "/genomics/link/taxonomy/uniprot_taxonomy/uniprot_taxonomy.sql" $db eval {attach database $dbtaxo as tax} $db eval {begin transaction} set Lfpar1 [$db eval {select taxid, Rank, Parent, Name from tax.taxonomy}] } else { set dbtaxo /genomics/link/taxonomy/ncbi_taxonomy/ncbi_taxonomy.sql $db eval {attach database $dbtaxo as taxonomy} $db eval {begin transaction} set Lfpar1 [$db eval {select n.taxid, n.Rank, n.Parent, m.name from nodes as n, names as m where n.taxid=m.taxid and m.name_class = 'scientific name'}] } set key "'$Tx(-cgdb),LComp'" set LCompleteId [split $::VSotol($Tx(-cgdb),LComp) " "] $db eval {commit} puts "load taxonomy into memory done ..." array unset Tx "*,*" set Lallf [list] ; set Lallp [list] set Lenv [list] foreach {f r p n} $Lfpar1 { if {$f eq $p || $p eq ""} { puts "gros cons $f" } lappend Lallf $f lappend Lallp $p if {0 && ! [regexp -nocase "environmental samples" $n]} { lappend Lallf $f lappend Lallp $p } else { lappend Lenv $f #continue } set Tx(Name,$f) $n set Tx(Rank,$f) $r set Tx(Parent,$f) $p lappend Tx(Child,$p) $f incr Tx(NbChild,$p) set Tx(NbChildCum,$f) 0 set Tx(hasSel,$f) 0 set Tx(Etat,$f) 0 set Tx(isComp,$f) 0 set Tx(NbComp,$f) 0 set Tx(isGold,$f) 0 set Tx(isInt,$f) 0 set Tx(NbInt,$f) 0 set Tx(ShowInt,$f) 0 set Tx(NbKeep,$f) 0 } puts "memorize done ..." # set Ln [list] set Lnor [list] foreach g $LCompleteId { set Lv [DonneGenealogieMem $g] puts "[llength $Lv] | $g" if {131567 ni $Lv} { lappend Lnor $g } lappend Ln [llength $Lv] foreach v $Lv { if {$Tx(Name,$v) eq "environmental samples"} { #puts "$g $Tx(Name,$g) $v" } } } puts "[join [DenombreLaListe $Ln] \n]" puts "lnor $Lnor" #exit set LAllIds $Lallf set Lfeuilles [lsort -unique -integer [lor $Lallf $Lallp from1]] puts "Lall : [llength [lsort -unique $Lallf]]" puts "Lfeuilles : [llength $Lfeuilles]" # add info for leaves foreach f $Lfeuilles { set Tx(Child,$f) [list] set Tx(NbChild,$f) 0 set Tx(Etat,$f) -1 } # flag complete genomes foreach g $LCompleteId { set Tx(isComp,$g) 1 } return } proc TaxDir {{system ""}} { if {$system==""} { set system "NCBI" } #lM rajoute system pour avoir TaxUniProt set TaxDir "[GscopeDatabaseDir Common]/fiches/Tax$system" return $TaxDir } proc TaxFontMode {quoi val} { eval font configure TaxFont -${quoi} $val DrawTaxo return } proc TaxGetz {Query {Quoi ""}} { regsub -all "_" $Query "" Query set RankOnly 0 if {$Quoi=="RankedParent"} { set Quoi "Parent" ; set RankOnly 1 } if {$Quoi==""} { set Quoi "TaxId" if {[regexp -nocase {^[0-9]+$} $Query]} { set Quoi "Name" } } if {[string equal -nocase $Quoi "ID"]} { set Quoi "TaxId" } if {[string equal -nocase $Quoi "Name"]} { set Quoi "Name" } set ChampQuery "Taxon" if {[regexp -nocase {^[0-9]+$} $Query]} { set ChampQuery "ID" } Espionne "getz -e \[TAXONOMY-$ChampQuery:$Query\]" if {[catch {set Reponse [exec getz -e \[TAXONOMY-$ChampQuery:$Query\]]} Message]} { regsub -all "\n" $Message " " Message # return "error from getz : $Message" } foreach Ligne [split $Reponse "\n"] { set Var "" if {[regexp -nocase {^ID *\: *} $Ligne Match]} { set Var "TaxId" } if {[regexp -nocase {^PARENT ID *\: *} $Ligne Match]} { set Var "Parent" } if {[regexp -nocase {^RANK *\: *} $Ligne Match]} { set Var "Rank" } if {[regexp -nocase {^GC ID *\: *} $Ligne Match]} { set Var "GCID" } if {[regexp -nocase {^MGC ID *\: *} $Ligne Match]} { set Var "MGCID" } if {[regexp -nocase {^SCIENTIFIC NAME *\: *} $Ligne Match]} { set Var "Name" } if {[regexp -nocase {^SYNONYM *\: *} $Ligne Match]} { set Var "Synonym" } if {[regexp -nocase {^EQUIVALENT NAME *\: *} $Ligne Match]} { set Var "Equiv" } if {$Var==""} { continue } set Info [StringSuivant ":" dans $Ligne] set $Var [string trim $Info] # regsub $Match $Ligne "" $Var # set $Var [string trim [set $Var]] } if {[info exists $Quoi]} { if {$RankOnly && $Parent>1 && [TaxGetz $Parent Rank]=="no rank"} { return [TaxGetz $Parent "RankedParent"] } return [set $Quoi] } return "ERROR in TaxGetz $Query $Quoi I got $Reponse" } proc TaxI {TaxName {E ""}} { global TaxI global TaxJ global TaxN global TaxC if {$E!=""} { set TaxName "$TaxName $E" } if {[info exists TaxI($TaxName)]} { return [set TaxI($TaxName)] } if {[info exists TaxI("EstCharge")]} { set TN $TaxName while {$TN!=""} { if {[info exists TaxJ($TN)]} { return [set TaxJ($TN)] } set TN [CondenseTaxName $TN] } return "" } ChargeTaxIJNC return [TaxI $TaxName] } proc TaxIdDuAccess {Access {Nom ""}} { if {$Nom!=""} { set TaxId [TaxIdDuMacsim $Access $Nom] if {$TaxId!=""} { return $TaxId } set TaxId [ChampDaedalus "OX" $Access $Nom ] if {$TaxId!=""} { return $TaxId } set Descriptif [LeDescriptif $Access $Nom] set TaxId [ChampDuDescriptif $Descriptif "OX"] if {$TaxId!=""} { return $TaxId } return "" } set Embl [join [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"] "\n"] if {$Embl!=""} { return [TaxIdDuTexteEmbl $Embl] } Espionne "Je n'ai pas trouve LaSequenceDesBanques $Access" return "" } proc TaxIdDuFichierRef {Fichier} { global TaxIdDuFichierRef if {[info exists TaxIdDuFichierRef($Fichier)]} { return [set TaxIdDuFichierRef($Fichier)] } if {[info exists TaxIdDuFichierRef("EstCharge")]} { return "" } set FichierTaxIdDuFichierRef "/genomics/link/Common/fiches/taxid_du_fichierref" array set TaxIdDuFichierRef [LesLignesDuFichier $FichierTaxIdDuFichierRef] set TaxIdDuFichierRef("EstCharge") 1 return [TaxIdDuFichierRef $Fichier] } proc TaxIdDuGenomeComplet {Banque} { global TaxIdDuGenomeComplet set Banque [string toupper $Banque] if {[info exists TaxIdDuGenomeComplet($Banque)]} { return [set TaxIdDuGenomeComplet($Banque)] } if {[info exists TaxIdDuGenomeComplet("EstCharge")]} { return "" } set FichierTaxIdDuGenomeComplet "[RepertoireDuGenome]/fiches/taxid_des_genomes_complets" if { ! [file exists $FichierTaxIdDuGenomeComplet]} { set FichierTaxIdDuGenomeComplet "[GscopeDatabaseDir Common]/fiches/taxid_des_genomes_complets" } if {[file exists $FichierTaxIdDuGenomeComplet]} { array set TaxIdDuGenomeComplet [LesLignesDuFichier $FichierTaxIdDuGenomeComplet] } set FichierTaxIdDuGenomeCompletRR "[RepertoireDuGenome]/fiches/taxid_des_genomes_complets_RR" if { ! [file exists $FichierTaxIdDuGenomeCompletRR]} { set FichierTaxIdDuGenomeCompletRR "[GscopeDatabaseDir Common]/fiches/taxid_des_genomes_complets_RR" } if {[file exists $FichierTaxIdDuGenomeCompletRR]} { array set TaxIdDuGenomeComplet [LesLignesDuFichier $FichierTaxIdDuGenomeCompletRR] } foreach {C V} [array get TaxIdDuGenomeComplet] { lappend TaxIdDuGenomeComplet(LESNOMS) $C lappend TaxIdDuGenomeComplet(LESTAXIDS) $V } set TaxIdDuGenomeComplet("EstCharge") 1 return [TaxIdDuGenomeComplet $Banque] } proc TaxIdDuPAB {Nom} { global TaxIdDuPAB if {[info exists TaxIdDuPAB($Nom)]} { return [set TaxIdDuPAB($Nom)] } if {[info exists TaxIdDuPAB("EstCharge")]} { return "" } set FichierTaxIdDuPAB "[RepertoireDuGenome]/fiches/taxiddespabs" if {[file exists $FichierTaxIdDuPAB]} { array set TaxIdDuPAB [LesLignesDuFichier $FichierTaxIdDuPAB] set TaxIdDuPAB("EstCharge") 1 return [TaxIdDuPAB $Nom] } while { ! [OuiOuNon "Do I create TaxIdDesPABs ?"]} { if {[OuiOuNon "Do I create an empty file ?\n(You can delete it later and run this prog again)"]} { SauveLesLignes {} dans FichierTaxIdDuPAB return "" } if {[OuiOuNon "Do I cancel TaxIdDuPAB ?"]} { return "" } } set TaxIdDuPAB("EstCharge") 1 set Sql "insert (pk_into taxonomy values ($TaxId, DEFAULT, $Name)" lappend LesSql $Sql if {[OuiOuNon "Do I search in OX field from protembl ?"]} { foreach PAB [ListeDesPABs] { set Embl [ContenuDuFichier "[RepertoireDuGenome]/protembl/$PAB"] set TaxIdDuPAB($PAB) [TaxIdDuTexteEmbl $Embl] } } SauveLesLignes [array get TaxIdDuPAB] dans $FichierTaxIdDuPAB return [TaxIdDuPAB $Nom] } proc TaxIdDuTexteEmbl {Embl} { foreach Ligne [split $Embl "\n"] { if { ! [regexp {^OX } $Ligne]} { continue } set TaxId [StringSuivant "NCBI_TaxID=" dans $Ligne] regsub -all {[\.\;\,]} $TaxId " " TaxId set TaxId [string trim $TaxId] if { ! [regexp {^[0-9 ]+$} $TaxId]} { FaireLire "The Embl file contains following OX line\n$Ligne\n\nPlease help me ..." set TaxId [Entre $TaxId] } while {[regexp -all " " $TaxId]} { regsub -all " " $TaxId " " TaxId } return $TaxId } return "" } proc TaxIdOfFamiliarOrganisms {} { set LesOrgaTaxId {} foreach Orga [FamiliarOrganism LaListeMerci] { set TaxId [Tax $Orga TaxId] if {$TaxId=="" || [regexp "ERROR" $TaxId]} { FaireLire "I can't find TaxId for $Orga. I'll skip" continue } lappend LesOrgaTaxId "$Orga $TaxId" } SauveLesLignes $LesOrgaTaxId dans "[RepertoireDuGenome]/fiches/familiar_organism_with_taxid" return $LesOrgaTaxId } proc TaxIdOrg {OrgOuTaxId} { #exemple format org: Mus musculus, Rattus norvegicus, Gallus gallus CanalSqlString if {[regexp {^[0-9]+$} $OrgOuTaxId]} { set out [SqlExec "select official_name from items.species where species_id = '$OrgOuTaxId';"] } else { set out [SqlExec "select species_id from items.species where official_name = '$OrgOuTaxId';" "GetList"] } return $out CanalSqlDisconnect } proc TaxMemo {{Qui ""} {Quoi ""}} { if {[info exists TaxMemo($Qui,$Quoi)]} { return $TaxMemo($Qui,$Quoi) } set R [Tax $Qui $Quoi] set TaxMemo($Qui,$Quoi) $R return $R } proc TaxN {TaxId} { global TaxI global TaxJ global TaxN global TaxC if {[info exists TaxN($TaxId)]} { return [set TaxN($TaxId)] } if {[info exists TaxN("EstCharge")]} { return "" } ChargeTaxIJNC return [TaxN $TaxId] } proc TaxNCBI {TaxId {Quoi ""} {Value ""}} { global TaxNCBI #rR je ne sais pas pourquoi il n'y a pas de ranked comme dans Getz if {$Quoi=="RankedParent"} { set Quoi "Parent" } set TaxId [string map [list "_" " "] $TaxId] if {$Quoi==""} { set Quoi "TaxId" if {[regexp -nocase {^[0-9]+$} $TaxId]} { set Quoi "Name" } } if {$Value==""} { set Value "GetValue" } if {[string equal -nocase $Value "GetValue"]} { if {[info exists TaxNCBI($TaxId,$Quoi)]} { return [set TaxNCBI($TaxId,$Quoi)] } if { ! [info exists TaxNCBI("EstCharge")]} { LoadTaxNCBI return [TaxNCBI $TaxId $Quoi $Value] } if {$Quoi=="Deleted"} { return 0 } if {($Quoi=="Name" || $Quoi=="Parent" || $Quoi=="Children" || $Quoi=="ItsNames") && ! [regexp {^[0-9]+$} $TaxId]} { set TNCBI [TaxNCBI $TaxId TaxId] if {$TNCBI==""} { return "" } return [TaxNCBI $TNCBI $Quoi] } set MAJUSCULE [string toupper $TaxId] if {[info exists TaxNCBI($MAJUSCULE,OriginalCase)] && [info exists TaxNCBI($TaxNCBI($MAJUSCULE,OriginalCase),$Quoi)]} { return $TaxNCBI($TaxNCBI($MAJUSCULE,OriginalCase),$Quoi) } return "" } set TaxNCBI("EstCharge") 1 #rR ***************************************** il faut =value ************** if { ! [regexp "^=" $Value]} { return "" } set Value [string map [list "=" ""] $Value] if { ! [info exists TaxNCBI(Query,$Quoi)]} { set TaxNCBI(Query,$Quoi) 1 lappend TaxNCBI(List,Queries) $Quoi } if {[string equal -nocase $Value "ResetValue"]} { if {[info exists TaxNCBI($TaxId,$Quoi)]} { set V [set TaxNCBI($TaxId,$Quoi)] unset TaxNCBI($TaxId,$Quoi) } return $V } if {$TaxId=="SortUnique" && $Quoi=="ListOf" && $Value=="Names"} { set TaxNCBI(ListOf,Names) [lsort -unique $TaxNCBI(ListOf,Names)] return 1 } set MAJUSCULE [string toupper $TaxId] set TaxNCBI($MAJUSCULE,OriginalCase) $TaxId if {$TaxId=="ListOf" && $Quoi=="Names"} { lappend TaxNCBI(ListOf,Names) $Value return $Value } if {$Quoi=="ItsNames" || $Quoi=="ItsTaxIds" || $Quoi=="Children"} { lappend TaxNCBI($TaxId,$Quoi) $Value return [set TaxNCBI($TaxId,$Quoi)] } set TaxNCBI($TaxId,$Quoi) $Value if {$Quoi=="Name"} { if { ! [info exists TaxNCBI($TaxId,exists)]} { set TaxNCBI($TaxId,exists) 1 lappend TaxNCBI(List,TaxId) $TaxId } } return $Value } proc TaxParQdsMemo {{Qui ""}} { #rR on appelle QuestionDeScience et on mémorise pour le coup d'après. global TaxParQdsMemo regsub -all "_" $Qui " " Qui if {[info exists TaxParQdsMemo($Qui)]} { return $TaxParQdsMemo($Qui)} set Q $Qui regsub -all {\[} $Q "\\\[" Q regsub -all {\]} $Q "\\\]" Q set R [QuestionDeScience EVImm "ret Tax \"$Q\""] set TaxParQdsMemo($Qui) $R if {$R!=""} { set TaxParQdsMemo($R) $Qui } return $R } proc TaxSystem {{Value ""}} { global TaxSystem # set DefaultValue "NCBI" set DefaultValue "UniProt" if {$Value!=""} { set VALUE [string toupper $Value] set TaxSys(GETZ) "Getz" set TaxSys(NCBI) "NCBI" set TaxSys(UNIPROT) "UniProt" if {[info exists TaxSys($VALUE)]} { set Value $TaxSys($VALUE) } else { set DEFAULT [string toupper $DefaultValue] set Better $TaxSys($DEFAULT) Warne "Attention $Value is not a valid TaxSystem I'll use $Better" set Value $Better } set TaxSystem $Value } if { ! [info exists TaxSystem]} { set TaxSystem $DefaultValue } return $TaxSystem } proc TaxUniProt {TaxId {Quoi ""} {Value ""}} { global TaxUniProt #lM a repris TaxNCBI et l'a change pour faire UniProt taxonomy #rR je ne sais pas pourquoi il n'y a pas de ranked comme dans Getz if {$Quoi=="RankedParent"} { set Quoi "Parent" } set TaxId [string map [list "_" " "] $TaxId] if {$Quoi==""} { set Quoi "TaxId" if {[regexp -nocase {^[0-9]+$} $TaxId]} { set Quoi "Name" } } if {$Value==""} { set Value "GetValue" } if {[string equal -nocase $Value "GetValue"]} { if {[info exists TaxUniProt($TaxId,$Quoi)]} { return [set TaxUniProt($TaxId,$Quoi)] } if { ! [info exists TaxUniProt("EstCharge")]} { LoadTaxUniProt return [TaxUniProt $TaxId $Quoi $Value] } if {($Quoi=="Name" || $Quoi=="Parent" || $Quoi=="Children" || $Quoi=="ItsNames") && ! [regexp {^[0-9]+$} $TaxId]} { return [TaxUniProt [TaxUniProt $TaxId TaxId] $Quoi] } set MAJUSCULE [string toupper $TaxId] if {[info exists TaxUniProt($MAJUSCULE,OriginalCase)] && [info exists TaxUniProt($TaxUniProt($MAJUSCULE,OriginalCase),$Quoi)]} { return $TaxUniProt($TaxUniProt($MAJUSCULE,OriginalCase),$Quoi) } return "" } set TaxUniProt("EstCharge") 1 #rR ***************************************** il faut =value ************** if { ! [regexp "^=" $Value]} { return "" } set Value [string map [list "=" ""] $Value] if { ! [info exists TaxUniProt(Query,$Quoi)]} { set TaxUniProt(Query,$Quoi) 1 lappend TaxUniProt(List,Queries) $Quoi } if {[string equal -nocase $Value "ResetValue"]} { if {[info exists TaxUniProt($TaxId,$Quoi)]} { set V [set TaxUniProt($TaxId,$Quoi)] unset TaxUniProt($TaxId,$Quoi) } return $V } if {$TaxId=="SortUnique" && $Quoi=="ListOf" && $Value=="Names"} { set TaxUniProt(ListOf,Names) [lsort -unique $TaxUniProt(ListOf,Names)] return 1 } set MAJUSCULE [string toupper $TaxId] set TaxUniProt($MAJUSCULE,OriginalCase) $TaxId if {$TaxId=="ListOf" && $Quoi=="Names"} { lappend TaxUniProt(ListOf,Names) $Value return $Value } if {$Quoi=="ItsNames" || $Quoi=="ItsTaxIds" || $Quoi=="Children"} { lappend TaxUniProt($TaxId,$Quoi) $Value return [set TaxUniProt($TaxId,$Quoi)] } set TaxUniProt($TaxId,$Quoi) $Value if {$Quoi=="Name"} { if { ! [info exists TaxUniProt($TaxId,exists)]} { set TaxUniProt($TaxId,exists) 1 lappend TaxUniProt(List,TaxId) $TaxId } } return $Value } proc TaxoBla {{Cadre ""} {Qui ""} {Quoi ""}} { #rR TaxoBla stocke tout ce qu'il peut pour tous les CladeDistrbution ci-dessus #rR En fait Cadre est censé être du style Clade_0.001_FirstOnly_UseExpect #rR On peut donc faire l'étude d'un clade dans plusieurs cadres ;) #rR attention Expect est le vrai expect ... LogExp = log10($Expect) #rR attention Expect est le vrai expect ... LogExp = log10($Expect) #rR attention Expect est le vrai expect ... LogExp = log10($Expect) #rR attention Expect est le vrai expect ... LogExp = log10($Expect) #rR TaxoBla lit les fichiers taxobla où ne figure qu'une fois chaque organisme... #rR FirstOnly concerne le First d'un Clade ... #rR Petite remarque : les Rank et LogExpect sont croissants, les Score sont décroissants #rR DeltaE va de -250 à +250 #rR DeltaS de 3000 à -3000 #rR DeltaR de -100 à +100 global TaxoBla if {[info exists TaxoBla($Cadre,$Qui,$Quoi)]} { return $TaxoBla($Cadre,$Qui,$Quoi) } if {[info exists TaxoBla($Cadre,"EstCharge")]} { return "" } if {[regexp {^New_(.+)} $Cadre Match CadreLu]} { foreach Name [array names TaxoBla -glob "$CadreLu,*"] { unset TaxoBla($Name) } set Cadre $CadreLu set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"] if {[file exists $FichierTaxoBla]} { file delete $FichierTaxoBla } } set TaxoBla($Cadre,"EstCharge") 1 set Clade "" set Seuil "" set SelectMethod "" set UseExpect "" lassign [split $Cadre "_"] Clade Seuil SelectMethod UseExpect if {[OnTraite CilioCarta Like]} { set LesTaxId [CladeContent $Clade "UseQds" "Without,[NotreOX]"] } elseif {[OnTraite OI2017 Like]} { set LesTaxId [CladeContentWithinOi2017 $Clade] } else { FaireLire "Désolé. Il faut être CilioCarta Like ou OI2017 Like ..." } set LesOS {} foreach TaxId $LesTaxId { set OS [join [Tax $TaxId Name] "_"] lappend LesOS $OS } if {$Seuil==""} { set Seuil 0.001 } if {$SelectMethod==""} { set SelectMethod "FirstOnly" } if {$UseExpect==""} { set USeExpect "UseExpect" } set TaxoBla($Cadre,Cadre,) $Cadre set TaxoBla($Cadre,ListOf,TaxId) $LesTaxId set TaxoBla($Cadre,ListOf,OS) $LesOS set TaxoBla($Cadre,Seuil,) $Seuil set TaxoBla($Cadre,SelectMethod,) $SelectMethod set TaxoBla($Cadre,UseExpect,) $UseExpect set TaxoBla($Cadre,ListOf,DeltaE) {} set TaxoBla($Cadre,ListOf,DeltaS) {} set TaxoBla($Cadre,ListOf,DeltaR) {} set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"] set TaxoBla($Cadre,file,) $FichierTaxoBla #rR Attention ici on lit le fichier memorisé ... à effacer s'il faut le refaire if {[file exists $FichierTaxoBla]} { array set TaxoBla [LesLignesDuFichier $FichierTaxoBla] return [TaxoBla $Cadre $Qui $Quoi] } if {$LesTaxId=={}} { return [TaxoBla $Cadre $Qui $Quoi] } foreach TaxId $LesTaxId { set TaxoBla($Cadre,$TaxId-Sum,LogExp) 0 set TaxoBla($Cadre,$TaxId-Sum,Score) 0 set TaxoBla($Cadre,$TaxId-Sum,Rank) 0 set TaxoBla($Cadre,$TaxId-Sum,DeltaE) 0 set TaxoBla($Cadre,$TaxId-Sum,DeltaS) 0 set TaxoBla($Cadre,$TaxId-Sum,DeltaR) 0 } set SumAllLogExp 0 set SumAllScore 0 set SumAllRank 0 set SumAllFirstLogExp 0 set SumAllFirstScore 0 set SumAllFirstRank 0 set SumAllDeltaE 0 set SumAllDeltaS 0 set SumAllDeltaR 0 set NbNom 0 foreach Nom [ListeDesPABs] { set TaxoBla($Cadre,$Nom,ListOfTaxId) {} set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]] if {$LesOrgaTrie=={}} { continue } set LesChoisis {} set FirstTaxId "" set Ieme 0 set NbHits 0 foreach Ligne $LesOrgaTrie { incr Ieme #rR je rappelle que taxobla ne contient qu'une fois chaque organisme lassign [split $Ligne "\t"] Expect Score TaxId OS Reste set TaxId [string trim $TaxId] if {[lsearch $LesTaxId $TaxId]<0} { continue } if {$Expect==0.0} { set Expect 1.0e-250 } #if {$Expect >1.0} { set Expect 1.0 } set OS [string trim $OS] set Reste [string trim $Reste] set Expect [string trim $Expect] set Score [expr round([string trim $Score])] set BonSeuil $Seuil if {[regexp -nocase "^e" $Seuil]} { set BonSeuil "1.0$Seuil" } if {$Expect > $BonSeuil} { break } incr NbHits if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 1 ; lappend TaxoBla($Cadre,ListOf,Nom) $Nom } set LogExp [expr round(log10($Expect))] ;#rR on passe en log !!!!!!!!!!!!!!!!! set AbsRank $Ieme lappend LesLogExps $LogExp lappend LesScores $Score lappend TaxoBla($Cadre,$Nom,ListOfTaxId) $TaxId set TaxoBla($Cadre,$Nom-$TaxId,Expect) $Expect set TaxoBla($Cadre,$Nom-$TaxId,LogExp) $LogExp set TaxoBla($Cadre,$Nom-$TaxId,Score) $Score set TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $AbsRank if {$FirstTaxId==""} { set FirstTaxId $TaxId set FirstLogExp $LogExp set FirstScore $Score set FirstAbsRank $AbsRank set TaxoBla($Cadre,$Nom-First,TaxId) $TaxId set TaxoBla($Cadre,$Nom-First,LogExp) $LogExp set TaxoBla($Cadre,$Nom-First,Score) $Score set TaxoBla($Cadre,$Nom-First,AbsRank) $AbsRank lappend TaxoBla($Cadre,FirstTaxId-$TaxId,ListOfNom) $Nom set TaxoBla($Cadre,$TaxId-First,LogExp) $LogExp set TaxoBla($Cadre,$TaxId-First,Score) $Score } set TaxoBla($Cadre,$TaxId-Sum,LogExp) [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp) + $LogExp] set TaxoBla($Cadre,$TaxId-Sum,Score) [expr $TaxoBla($Cadre,$TaxId-Sum,Score) + $Score] lappend TaxoBla($Cadre,$TaxId,ListOfNom) $Nom } set NbHitsInBlast $Ieme set TaxoBla($Cadre,$Nom,NbHits) $NbHits if {$NbHits==0} { continue} incr NbNom set SumLogExp 0 set SumScore 0 set SumRank 0 foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) { #set Rank [expr $TaxoBla($Cadre,$Nom-$TaxId,AbsRank)*100/$NbHitsInBlast] set Rank [NiceRank $TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $NbHitsInBlast] set TaxoBla($Cadre,$Nom-$TaxId,Rank) $Rank if {$TaxId==$FirstTaxId} { set TaxoBla($Cadre,$Nom-First,Rank) $Rank set TaxoBla($Cadre,$TaxId-First,Rank) $Rank set FirstRank $Rank } set SumLogExp [expr $SumLogExp + $TaxoBla($Cadre,$Nom-$TaxId,LogExp)] set SumScore [expr $SumScore + $TaxoBla($Cadre,$Nom-$TaxId,Score)] set SumRank [expr $SumRank + $TaxoBla($Cadre,$Nom-$TaxId,Rank)] } set AverageLogExp [expr round($SumLogExp / $NbHits)] set AverageScore [expr round($SumScore / $NbHits)] set AverageRank [expr max(1,round($SumRank / $NbHits))] ;#rR j'ai mis 1 minimum #set AverageRank [expr max(1,[NiceRank $SumRank $NbHits])] ;#rR j'ai mis 1 minimum set TaxoBla($Cadre,$Nom-Average,LogExp) $AverageLogExp set TaxoBla($Cadre,$Nom-Average,Score) $AverageScore set TaxoBla($Cadre,$Nom-Average,Rank) $AverageRank lappend TaxoBla($Cadre,AverageLogExp-$AverageLogExp,ListOfNom) $Nom lappend TaxoBla($Cadre,AverageScore-$AverageScore,ListOfNom) $Nom lappend TaxoBla($Cadre,AverageRank-$AverageRank,ListOfNom) $Nom lappend TaxoBla($Cadre,FirstLogExp-$FirstLogExp,ListOfNom) $Nom lappend TaxoBla($Cadre,FirstScore-$FirstScore,ListOfNom) $Nom lappend TaxoBla($Cadre,FirstRank-$FirstRank,ListOfNom) $Nom set SumDeltaE 0 set SumDeltaS 0 set SumDeltaR 0 foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) { set DeltaE [expr round($TaxoBla($Cadre,$Nom-$TaxId,LogExp) - $TaxoBla($Cadre,$Nom-Average,LogExp))] set DeltaS [expr round($TaxoBla($Cadre,$Nom-$TaxId,Score) - $TaxoBla($Cadre,$Nom-Average,Score))] set DeltaR [expr round($TaxoBla($Cadre,$Nom-$TaxId,Rank) - $TaxoBla($Cadre,$Nom-Average,Rank))] set TaxoBla($Cadre,$TaxId-First,DeltaE) $DeltaE set TaxoBla($Cadre,$TaxId-First,DeltaS) $DeltaS set TaxoBla($Cadre,$TaxId-First,DeltaR) $DeltaR incr SumDeltaE $DeltaE incr SumDeltaS $DeltaS incr SumDeltaR $DeltaR set TaxoBla($Cadre,$Nom-$TaxId,DeltaE) $DeltaE set TaxoBla($Cadre,$Nom-$TaxId,DeltaS) $DeltaS set TaxoBla($Cadre,$Nom-$TaxId,DeltaR) $DeltaR lappend TaxoBla($Cadre,DeltaE-$DeltaE,ListOfNom) $Nom lappend TaxoBla($Cadre,DeltaS-$DeltaS,ListOfNom) $Nom lappend TaxoBla($Cadre,DeltaR-$DeltaR,ListOfNom) $Nom lappend TaxoBla($Cadre,ListOf,DeltaE) $DeltaE lappend TaxoBla($Cadre,ListOf,DeltaS) $DeltaS lappend TaxoBla($Cadre,ListOf,DeltaR) $DeltaR set LogExp $TaxoBla($Cadre,$Nom-$TaxId,LogExp) set Score $TaxoBla($Cadre,$Nom-$TaxId,Score) set Rank $TaxoBla($Cadre,$Nom-$TaxId,Rank) lappend TaxoBla($Cadre,ListOf,LogExp) $LogExp lappend TaxoBla($Cadre,ListOf,Score) $Score lappend TaxoBla($Cadre,ListOf,Rank) $Rank lappend TaxoBla($Cadre,$TaxId-LogExp-$LogExp,ListOfNom) $Nom lappend TaxoBla($Cadre,$TaxId-Score-$Score,ListOfNom) $Nom lappend TaxoBla($Cadre,$TaxId-Rank-$Rank,ListOfNom) $Nom lappend TaxoBla($Cadre,$TaxId-DeltaE-$DeltaE,ListOfNom) $Nom lappend TaxoBla($Cadre,$TaxId-DeltaS-$DeltaS,ListOfNom) $Nom lappend TaxoBla($Cadre,$TaxId-DeltaR-$DeltaR,ListOfNom) $Nom set TaxoBla($Cadre,$TaxId-Sum,Rank) [expr $TaxoBla($Cadre,$TaxId-Sum,Rank) + $Rank] set TaxoBla($Cadre,$TaxId-Sum,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE) + $DeltaE] set TaxoBla($Cadre,$TaxId-Sum,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS) + $DeltaS] set TaxoBla($Cadre,$TaxId-Sum,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR) + $DeltaR] } set TaxoBla($Cadre,$Nom-Average,DeltaE) [expr round($SumDeltaE / $NbHits)] set TaxoBla($Cadre,$Nom-Average,DeltaS) [expr round($SumDeltaS / $NbHits)] set TaxoBla($Cadre,$Nom-Average,DeltaR) [expr round($SumDeltaR / $NbHits)] set SumAllLogExp [expr $SumAllLogExp + $TaxoBla($Cadre,$Nom-Average,LogExp)] set SumAllScore [expr $SumAllScore + $TaxoBla($Cadre,$Nom-Average,Score)] set SumAllRank [expr $SumAllRank + $TaxoBla($Cadre,$Nom-Average,Rank)] set SumAllDeltaE [expr $SumAllDeltaE + $TaxoBla($Cadre,$Nom-Average,DeltaE)] set SumAllDeltaS [expr $SumAllDeltaS + $TaxoBla($Cadre,$Nom-Average,DeltaS)] set SumAllDeltaR [expr $SumAllDeltaR + $TaxoBla($Cadre,$Nom-Average,DeltaR)] set SumAllFirstLogExp [expr $SumAllFirstLogExp + $TaxoBla($Cadre,$Nom-First,LogExp)] set SumAllFirstScore [expr $SumAllFirstScore + $TaxoBla($Cadre,$Nom-First,Score)] set SumAllFirstRank [expr $SumAllFirstRank + $TaxoBla($Cadre,$Nom-First,Rank)] } ;#rR fin de la boucle sur Nom set TaxoBla($Cadre,ListOf,LogExp) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,LogExp)] set TaxoBla($Cadre,ListOf,Score) [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,Score)] set TaxoBla($Cadre,ListOf,Rank) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,Rank)] set TaxoBla($Cadre,ListOf,DeltaE) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaE)] set TaxoBla($Cadre,ListOf,DeltaS) [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,DeltaS)] set TaxoBla($Cadre,ListOf,DeltaR) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaR)] set TaxoBla($Cadre,Average,LogExp) [expr $SumAllLogExp/$NbNom] set TaxoBla($Cadre,Average,Score) [expr $SumAllScore/$NbNom] set TaxoBla($Cadre,Average,Rank) [expr $SumAllRank/$NbNom] set TaxoBla($Cadre,Average,DeltaE) [expr $SumAllDeltaE/$NbNom] set TaxoBla($Cadre,Average,DeltaS) [expr $SumAllDeltaS/$NbNom] set TaxoBla($Cadre,Average,DeltaR) [expr $SumAllDeltaR/$NbNom] set TaxoBla($Cadre,First,LogExp) [expr $SumAllFirstLogExp/$NbNom] set TaxoBla($Cadre,First,Score) [expr $SumAllFirstScore/$NbNom] set TaxoBla($Cadre,First,Rank) [expr $SumAllFirstRank/$NbNom] foreach TaxId $LesTaxId { if { ! [info exists TaxoBla($Cadre,$TaxId,ListOfNom)]} { continue } set N [llength $TaxoBla($Cadre,$TaxId,ListOfNom)] set TaxoBla($Cadre,$TaxId-Average,LogExp) [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp)/$N] set TaxoBla($Cadre,$TaxId-Average,Score) [expr $TaxoBla($Cadre,$TaxId-Sum,Score)/$N] set TaxoBla($Cadre,$TaxId-Average,Rank) [expr $TaxoBla($Cadre,$TaxId-Sum,Rank)/$N] ; set TaxoBla($Cadre,$TaxId-Average,Rank) [expr max(1,$TaxoBla($Cadre,$TaxId-Average,Rank))] set TaxoBla($Cadre,$TaxId-Average,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE)/$N] set TaxoBla($Cadre,$TaxId-Average,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS)/$N] set TaxoBla($Cadre,$TaxId-Average,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR)/$N] } SauveLesLignes [array get TaxoBla "$Cadre,*"] dans $FichierTaxoBla return [TaxoBla $Cadre $Qui $Quoi] } proc TaxoBlaAvecScore {Nom} { FaireLire "Attention TaxoBlaAvecScore ne devrait plus servir." exit # on apprend par coeur set FiBla [GscopeFile $Nom "blastp"] set OnAttendSQ 1 set OnEstDansLaPartie 0 foreach Ligne [LesLignesDuFichier $FiBla] { if {$OnAttendSQ} { if { ! [regexp {^Sequences producing} $Ligne]} { continue } set OnAttendSQ 0 continue } if {[regexp "^>" $Ligne]} { break } regsub -all {[ \t]+} [string trim $Ligne] " " Ligne set LesMots [split $Ligne " "] if {$LesMots=={}} { continue } set Access [lindex $LesMots 0] set Score [lindex $LesMots end-1] set Score [expr round($Score)] set Expect [lindex $LesMots end] set ScoreDe($Access) $Score } # on a bien appris par coeur !!! set FiTax [GscopeFile $Nom "taxobla"] set FiTaxOLD [GscopeFile $Nom "taxoblaOLD"] set LesNouvellesLignes {} foreach Ligne [LesLignesDuFichier $FiTaxOLD] { set LesChamps [split $Ligne "\t"] set Info [lindex $LesChamps 3] scan $Info "%s" Access set Score $ScoreDe($Access) set BeauScore [format %5d $Score] regsub "\t" $Ligne \t$BeauScore\t Ligne lappend LesNouvellesLignes $Ligne } return [SauveLesLignes $LesNouvellesLignes dans $FiTax] } proc TaxoBlaAvecScorePourTous {} { FaireLire "Attention TaxoBlaAvecScorePourTous ne devrait plus servir." exit foreach Nom [ListeDesPABs] { set FiTax [GscopeFile $Nom "taxobla"] if {[File exists $FiTax]} { continue } if {[PasTouche $Nom]} { continue } set Fichier [TaxoBlaAvecScore $Nom] FinPasTouche $Nom Espionne $Fichier } } proc TaxoValide {Liste {Quoi ""}} { if {$Quoi == ""} { set Quoi "GetValid" } set LesValides {} set LesInconnus {} foreach A $Liste { if {[Tax $A "TaxId"]==""} { lappend LesInconnus $A } else { lappend LesValides $A } } if {[regexp -nocase "Valid" $Quoi]} { return $LesValides } return $LesInconnus } proc TaxoblaDuCongelo {LesOP} { if {[regexp {[ ,\n\t]} $LesOP]} { regsub -all {[ ,\n\t]+} $LesOP "," LesOP set LesOP [split [string trim $LesOP ","] ","] } set PreviousId "" set LeTaxobla {} set Ieme 0 set Keme 0 set LesFicTax {} foreach OP $LesOP { if {[file exists "[RepertoireDuGenome]/$OP"]} { set g [open "[RepertoireDuGenome]/$OP" "r"] Espionne "j'utilise le dezipé" } else { set Gz [DernierGz $OP] set g [open $Gz "r"] zlib push gunzip $g } while {[gets $g Ligne]>=0} { if {[incr Keme]%10000==1} { Espionne $Keme } if {[string index $Ligne 0]=="#"} { continue } scan $Ligne "%s %s" BAI Subject set Id [lindex [split $BAI "|"] end] if {$PreviousId!="" && $Id!=$PreviousId} { if {[info exists DejaVu]} { unset DejaVu } if {[incr Ieme]%100==1} { LogWscope $Ieme } if { $Ieme % 10==1} { Espionne $Ieme } set FicTax [RangeTaxobla $PreviousId $LeTaxobla] if {$FicTax!=""} { lappend LesFicTax $FicTax } set LeTaxobla {} } set PreviousId $Id set IdSubject [lindex [split $Subject "|"] end] #set OX [QuestionDeScience OI "ret WiwOxFrom $IdSubject"] set OX [WiwOxFrom $IdSubject] if {[info exists DejaVu($OX)]} { continue } set DejaVu($OX) $IdSubject lappend LeTaxobla "$OX\t$Ligne" } close $g } if {$LeTaxobla!={}} { RangeTaxobla $PreviousId $LeTaxobla } return $LesFicTax } proc TaxoblaFromOi {} { set OX [NotreOX] set Science [ScienceOiDeMonDomaine] Espionne "QuestionDeScience $Science ret WIW $OX ListOfOP" set LesOP [QuestionDeScience $Science "ret WIW $OX ListOfOP"] Espionne $LesOP LogWscope $LesOP return [TaxoblaDuCongelo $LesOP] } proc TaxoblaKeepOnly {{KeepWhat ""} {Extension ""} {TaxoblaOrigin ""}} { if {$KeepWhat ==""} { set KeepWhat "AEB_ListOf_OX" } if {$Extension ==""} { set Extension $KeepWhat } if {$TaxoblaOrigin==""} { set TaxoblaOrigin "taxobla" } set LesKeepedOX {} if {[regexp {^([A-Z]+)_([^_]+)_([^_]+)$} $KeepWhat Match Domaines Lo W]} { foreach D [split $Domaines ""] { Espionne "OiCodeForDomain $D $Lo $W" set LesOX [OiCodeForDomain $D $Lo $W] LConcat LesKeepedOX $LesOX } } Espionne $LesKeepedOX foreach OX $LesKeepedOX { set Keep($OX) 1 } NousAllonsAuBoulot [RepertoireDuGenome] set DestDir "taxobla$Extension" foreach Nom [ListeDesPABs] { if {[PasTouche $Nom]} { continue } set Orig "$TaxoblaOrigin/$Nom" set Dest "$DestDir/$Nom" file mkdir $DestDir if {[FileExists $Orig] && [FileAbsent $Dest]} { set LeNew {} foreach Ligne [LesLignesDuFichier $Orig] { scan $Ligne "%s %s %s" Pn Score OX if { ! [info exists Keep($OX)]} { continue } lappend LeNew $Ligne } SauveLesLignes $LeNew dans $Dest Espionne $Dest lappend LesNouveaux $Dest } FinPasTouche $Nom } OnRevientDuBoulot return $LesNouveaux } proc TaxoblaProject {{Qui ""} {Quoi ""}} { global TaxoblaProject set FichierMemo "/genomics/link/OI/fiches/TaxoblaProject.txt" if {[regexp -nocase "^ReDo_" $Qui]} { if {[file exists $FichierMemo]} { file delete $FichierMemo } regsub -nocase "^ReDo_" $Qui "" Qui if {[info exists TaxoblaProject]} { unset TaxoblaProject } return [TaxoblaProject $Qui $Quoi] } if {[info exists TaxoblaProject($Qui,$Quoi)]} { return $TaxoblaProject($Qui,$Quoi) } if {[info exists TaxoblaProject("EstCharge")]} { return "" } set TaxoblaProject("EstCharge") 1 if {[file exists $FichierMemo]} { array set TaxoblaProject [ContenuDuFichier $FichierMemo] return [TaxoblaProject $Qui $Quoi] } set LesRepExistants [glob -nocomplain "/genomics/link/*/taxobla"] foreach RepT $LesRepExistants { set Rep [file dirname $RepT] set LesProttfa [lsort [glob -nocomplain "$Rep/prottfa/*"]] if { [set NbProttfa [llength $LesProttfa]] < 10} { continue } set LesTaxobla [lsort [glob -nocomplain "$Rep/taxobla/*"]] set Projet [file tail $Rep] if { [set NbTaxobla [llength $LesTaxobla]] < $NbProttfa } { Espionne "$Projet $NbTaxobla/$NbProttfa" ; continue } lappend LesProjets [file tail $Rep] set OX [IntegerApres "NotreOX" dans [ContenuDuFichier "$Rep/beton/miniconfig"]] set TaxoblaProject($Projet,NS) $NbProttfa set TaxoblaProject($Projet,NT) $NbTaxobla set TaxoblaProject($Projet,OX) $OX } set TaxoblaProject(ListOf,Project) [lsort -unique $LesProjets] Sauve [array get TaxoblaProject] dans $FichierMemo return [TaxoblaProject $Qui $Quoi] } proc Taxonomy {Nom} { return [ExtraitInfo $Nom "Taxonomy"] } proc TaxonomyDuBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""} {GetWhat ""} {AvecMemoTaxo ""}} { #rR Toute cette histoire de taxonomy présente dans le blast date de CilioCarta (2015) #rR Ca marche si la banque blast a été créée avec les OX que je rajoute pour tout Uniprot #rR on lit les chevrons du blast qui contiennent l'expect et le TaxId (pour CilioCarta en tout cas) #rR on rend la liste du premier hit de chaque orga rencontré sauf si CutPN contient KeepAll set KeepAll [regexp -nocase "KeepAll" $CutPN] if {$KeepAll} { regsub -nocase "KeepAll" $CutPN "" CutPN } if {$CutPN=="" || $CutPN =="-" } { set CutPN "9999999" } if {$MaxListe==""|| $MaxListe=="-" } { set MaxListe "9999999" } if {$GetWhat==""} { set GetWhat "Show" } if {[regexp -nocase "Memo" $AvecMemoTaxo]} { global MemoTaxoPourTaxobla } set LesRetenus {} set Nom "" if {[EstUnPAB $TexteOuListeOuFichier]} { set Nom $TexteOuListeOuFichier set TexteOuListeOuFichier [GscopeFile $Nom "blastp"] if {[FileAbsent TexteOuListeOuFichier]} { set ListeDesLignes {} } else { set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier] } #rR ici on prend le fichier set FichierTaxobla [GscopeFile $Nom "taxobla"] if {[file exists $FichierTaxobla]} { set LesRetenus [LesLignesDuFichier $FichierTaxobla] } } elseif {[regexp "^/FromOi/(.+)$" $TexteOuListeOuFichier Match Nom]} { set ListeDesLignes [BlastFromOi $Nom] } elseif {[regexp "\n" $TexteOuListeOuFichier]} { set ListeDesLignes [split $TexteOuListeOuFichier "\n"] } elseif {[regexp " " $TexteOuListeOuFichier]} { set ListeDesLignes $TexteOuListeOuFichier } elseif {[file exists $TexteOuListeOuFichier]} { set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier] set Nom [file tail $TexteOuListeOuFichier] } elseif {[string length $TexteOuListeOuFichier] > 100} { set ListeDesLignes [split [Base64Decode $TexteOuListeOuFichier] "\n"] } else { FaireLire "I don't know how to analyse the blast\n$TexteOuListeOuFichier\n It's not a text, not a list, not a file" return "" } if {$LesRetenus=={}} { set DansChevron 0 set NbLus 0 foreach Ligne $ListeDesLignes { set Chev [regexp "^>" $Ligne] if { ! $DansChevron && ! $Chev} { continue } if { ! $DansChevron && $Chev} { regsub ">" $Ligne "" Ligne scan $Ligne "%s" Access if {[info exists DejaVu($Access)]} { set DansChevron 0 ; continue } set DejaVu($Access) $Ligne set Info $Ligne set Expect "" set DansChevron 1 continue } if {[regexp "^ *Identities" $Ligne]} { set DansChevron 0 ; continue } if {[regexp {Expect *= *([^\,]+)} $Ligne Match sPN]} { set Score [expr round([StringApres "Score =" dans $Ligne])] ;#rR rajoute le 2015/06/08 regsub {^[eE]} $sPN "1e" sPN # scan $sPN "%f" PN set PN $sPN if {[catch { expr $PN > $CutPN } ]} { Warne "Oh le vilain $PN" set PN 1E-200 } if {[expr $PN <= $CutPN]} { regsub -all " +" $Info " " Info set Info [string trim $Info] set TaxId "" if {[regexp -nocase {(TAXID|OX)(=|:)([0-9]+)( |$)} $Info Match K S T]} { set TaxId $T } else { if {[regexp {OS=(.*)$} $Info Match OS]} { regsub { [A-Z]+=.*$} $OS "" OS regsub -all {\[} $OS "\\\[" OS regsub -all {\]} $OS "\\\]" OS regsub {\.$} $OS "" OS if {[info exists MemoTaxoPourTaxobla($OS)]} { set TaxId $MemoTaxoPourTaxobla($OS) } else { regsub -all " " $OS "_" O_S set TaxId [QuestionDeScience EVImm "ret Tax $O_S"] if {$TaxId==""} { lassign [split $O_S "_"] Genre Espece set G_E "${Genre}_$Espece" set TaxId [QuestionDeScience EVImm "ret Tax $G_E"] } set MemoTaxoPourTaxobla($OS) $TaxId } } } if {[info exists MemoTaxoPourTaxobla($TaxId)]} { set Orga $MemoTaxoPourTaxobla($TaxId) } else { if {$TaxId!=""} { set Orga [QuestionDeScience EVImm "ret Tax $TaxId"] set MemoTaxoPourTaxobla($TaxId) $Orga } else { set Orga "Unknown unknown" } } if { $KeepAll || ! [info exists DejaVu($TaxId)] } { if {[string length $Orga]>36} { set Orga "[string range $Orga 0 36]..." } lappend LesRetenus [format "%7s\t%6s\t%8s\t%-40s\t%s" $PN $Score $TaxId $Orga $Info] ;#rR rajout de score 2015/06/08 if {[incr NbLus]>$MaxListe} { break } set DejaVu($TaxId) 1 } } set Info "" set Access "" set DansChevron 0 continue } append Info " $Ligne" } } if {$GetWhat=="GetList"} { return $LesRetenus } if {$GetWhat=="GetText"} { return [join $LesRetenus "\n"] } if {$GetWhat=="Show"} { #rR On peut postponé les TouchePour ... ils sont mis en mémoire et rajoutés en queue des boutons :) set Clavier "Postpone" TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "Orange" TouchePour $Clavier "See Taxo" "AfficheTaxoFromTaxoLine \[selection get\] $Nom" TouchePour "<2>" "/ Fetch" "AfficheFetchFromTaxoLine \[selection get\] $Nom" TouchePour $Clavier NouvelleCouleur "Magenta" TouchePour $Clavier "OutlierOrganism" "OutlierOrganismInBlast $Nom" TouchePour $Clavier "Set Current Clade" "HighlightClade @F@ New" ;#rR les @F@ seront remplacés par la fenêtre car Postpone TouchePour "<2>" "/ See" "HighlightClade @F@ See" TouchePour $Clavier "Highlight Clade" "HighlightClade @F@ Current" if {[PourWscope]} { return [AfficheListe $LesRetenus "GrandeLargeur" $Nom] } set F [AfficheListe $LesRetenus "GrandeLargeur" $Nom] } set Fichier "" if {[regexp "/" $GetWhat]} { set Fichier $GetWhat } if {$GetWhat=="Save" && [EstUnPAB $Nom]} { mkdir "[RepertoireDuGenome]/taxobla"; set Fichier [GscopeFile $Nom "taxobla"] } if {$Fichier!=""} { return [SauveLesLignes $LesRetenus dans $Fichier] } if {$GetWhat=="GetText"} { return [join $LesRetenus "\n"] } return $LesRetenus } proc TaxonomyDuBlastPourTous {{RepBlast ""} {RepTaxobla ""} {CutPN ""} {MaxListe ""}} { if {$RepBlast==""} { set RepBlast "[RepertoireDuGenome]/blastp" } if {$RepTaxobla==""} { set RepTaxobla "[RepertoireDuGenome]/taxobla" } if { ! [regexp "/" $RepBlast]} { set RepBlast "[RepertoireDuGenome]/$RepBlast" } if { ! [regexp "/" $RepTaxobla]} { set RepTaxobla "[RepertoireDuGenome]/$RepTaxobla" } if {[FileAbsent $RepTaxobla]} { file mkdir $RepTaxobla } set I 0 set LesFichierTaxoblaCrees {} foreach Nom [ListeDesPABs] { if {$I%100==0} { Espionne "TaxonomyDuBlast $Nom" } incr I set FichierTaxobla $RepTaxobla/$Nom if {[file exists $FichierTaxobla] && [file size $FichierTaxobla]>0} { continue } set FichierBlast "$RepBlast/$Nom" if {[PasTouche "Taxobla$Nom"]} { continue } set F [TaxonomyDuBlast $FichierBlast $CutPN $MaxListe $FichierTaxobla "AvecMemoTaxo"] lappend LesFichierTaxoblaCrees $F set L [llength [LesLignesDuFichier $F]] Espionne "$FichierTaxobla [format %6d $L] different organisms" FinPasTouche "Taxobla$Nom" } return $LesFichierTaxoblaCrees } proc TaxonomyProcessXML {Lxml Lid} { set RId [dom parse $Lxml] set doc [$RId documentElement] array set T [list] foreach nT [$doc selectNodes //TaxaSet/Taxon] { set Tax [$nT selectNode string(./TaxId)] set isReplaced [expr {$Tax ni $Lid}] set sn [$nT selectNode ./ScientificName] set ScName [$sn selectNode string(.)] set Rank [$nT selectNode string(./Rank)] set Lin [$nT selectNode string(./Lineage)] set Lon [list] foreach no [$nT selectNode ./OtherNames/Synonym] { lappend Lon [$no selectNode string(.)] } set T($Tax,isReplaced) $isReplaced set T($Tax,ScientificName) "$ScName" set T($Tax,Rank) $Rank set T($Tax,Lineage) "$Lin" set T($Tax,Synonyms) $Lon # check for taxid changes set Lrep [list] foreach no [$nT selectNode ./AkaTaxIds/TaxId] { lappend Lrep [$no selectNode string(.)] } set T($Tax,Replaces) $Lrep } $RId delete update return [array get T] } proc Tba {PhyloTree TbaFile TbaLogFile} { ### tba program execution from the TBA suite ### # generates the multiple alignment from get_covered, multiz, pair2tb and maf_project programs # Espionne "Tba ..." set Rep [file dirname $TbaFile] ##################################################################################################### ### Attention, pb avec le "*.maf" !!!!!!!!!!!!!!!!!!!!!!! a voir !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ### ### dans proman par web, possibilite de x fichier maf de differents projets dans le meme repertoire ... #set Commande "exec [PATH tba] + \"$PhyloTree\" [glob -nocomplain "*.maf"] $TbaFile >& $TbaLogFile" set Commande "exec tba + \"$PhyloTree\" [glob -nocomplain "*.maf"] $TbaFile >& $TbaLogFile" ##################################################################################################### puts "$Commande" if {[catch {eval $Commande} Message]} {Espionne $Message;return} return $TbaFile } proc Tbrucei {} { set Dir "/genomics/link/Tbrucei" file mkdir "$Dir/beton" file mkdir "$Dir/fiches" file mkdir "$Dir/prottfa" set Pep "$Dir/DuTigr/TBA1.pep" set Prefixe "TB" set LesBornes {} set LeTFA {} if {[FileAbsent "$Dir/prottfa"]} { file mkdir "$Dir/prottfa" } if {[FileAbsent "$Dir/fiches"]} { file mkdir "$Dir/fiches" } set Deb 100 set Fin [expr $Deb+300] set Sens "F" foreach Ligne [LesLignesDuFichier $Pep] { if {[regexp ">" $Ligne]} { if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" } set Ligne [string trim $Ligne "> "] set LesMots [split $Ligne "/ "] ScanLaListe $LesMots A set O "Trypanosoma brucei" set Nom $A regsub "Tb" $Nom "TB" Nom regsub {[^TB0-9\.]} $Nom "" Nom set Entete ">$Nom $O $Ligne" Espionne $Entete set LeTFA [list $Entete] lappend LesBornes ">$Nom $Deb $Fin $Sens" incr Deb 390 set Fin [expr $Deb+300] continue } lappend LeTFA $Ligne } if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" } return [SauveLesLignes $LesBornes dans "$Dir/fiches/bornesdespabs"] } proc TbruceiChromosomes {} { foreach Fichier [lsort [glob "[RepertoireDuGenome]/DuTigr/Tbrucei_chr*.tfa"]] { regsub -all {\.tfa+$} $Fichier "" NewFichier set Racine [file tail $NewFichier] append NewFichier ".new" set LesLignes [LesLignesDuFichier $Fichier] set OnAttendLeDebut 1 foreach Ligne $LesLignes { if {$OnAttendLeDebut && ! [regexp {^>} $Ligne]} { continue } if {$OnAttendLeDebut} { set Entete $Ligne scan $Entete "%s" Access regsub ">" $Access "" Access set Entete [StringSuivant " " dans $Entete] set Entete ">$Racine $Entete $Access" Espionne $Entete set OnAttendLeDebut 0 set LeNew [list $Entete] continue } if {[regexp -nocase {[^ATGCNMYWRK]} $Ligne] && [OuiOuNon "Est-ce la fin en \n$Ligne"]} { break } lappend LeNew $Ligne } lappend LesNews [SauveLesLignes $LeNew dans $NewFichier] } return $LesNews } proc TbruceiNuc {} { set Dir "/genomics/link/Tbrucei" file mkdir "$Dir/nuctfa" set LeTFA {} foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/DuTigr/TBA1.cds"] { if {[regexp ">" $Ligne]} { if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/nuctfa/$Nom" } set Ligne [string trim $Ligne "> "] set LesMots [split $Ligne "/ "] ScanLaListe $LesMots A set O "Trypanosoma brucei" set Nom $A regsub "Tb" $Nom "TB" Nom regsub {[^TB0-9\.]} $Nom "" Nom set Entete ">$Nom $O $Ligne" Espionne $Entete set LeTFA [list $Entete] continue } lappend LeTFA $Ligne } if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/nuctfa/$Nom" } return } proc Tche2 {} { global T LNOrdali array set T [ContenuDuFichier filsde.dat] set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08] set Lch [Che2] puts [join $Lch \n] exit } proc Tcomp {} { global db package require sqlite3 set db root sqlite3 $db bench.sql set pfdir /genomics/link/Pfam set Lpfam [$db eval {select distinct job from results}] set Lj2d [list] foreach pf $Lpfam { set pfile [lindex [glob -nocomplain [file join $pfdir "${pf}*"]] end] lappend Lj2d [list $pf $pfile] } Thr_Submit -joblist $Lj2d -proccreate Tcree -procexe TcompExe -procresults TcompResults -nthreads 20 $db close exit } proc TcompExe {Largs} { global LNDG SDG ListeDesPiliersDuGroupe LNOrdali Sequences LongueurTotale lassign $Largs pfile unset -nocomplain ListeDesPiliersDuGroupe SDG Sequences LNOrdali set LNDG GroupeToutLeMonde DecortiqueUnTFA $pfile LNOrdali Sequences set LongueurTotale [string length [set Sequences([lindex $LNOrdali 0])]] set SDG(GroupeToutLeMonde) $LNOrdali CreeLesPiliers set Lpil [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)] set nseq [string length [lindex $Lpil 0]] set Lthrgap [list 0.005 0.1 0.25 0.5 0.7] set Lres [list] foreach pcgap $Lthrgap { LesDefauts PCThrGap $pcgap set ThrGap [DefineGapThreshold $nseq] set lgt 0 foreach pori $Lpil { set p [string map [list X "" Z "" " " "" "." ""] $pori] if {[string length $p] >= $ThrGap} { incr lgt } } lappend Lres [list $pcgap $lgt] } puts "[join $Lres \n]" return $Lres } proc TcompResults {pktest pfamid Lval} { global db set LErr [list] foreach e $Lval { lassign $e gp lgt set Lpk [$db eval {select pk_results from results where gapthr=$gp and job=$pfamid}] $db eval "update results set lgt=$lgt where pk_results in ([join $Lpk ,])" puts "nVal [llength $Lval] npkr [llength $Lpk]" } return $LErr } proc TcpDump {Commande} { set Fichier "TcpDump" set PidTcpDump [exec tcpdump -s 0 -i any -w $Fichier &] afte 100 eval exec $Commande exec kill -9 PidTcpDump return $Fichier } proc Tcree {} { set GscopeDir $env(GSCOPEDIR) set OrdaliDejaSource 1 source [file join $GscopeDir gscope_source.tcl] set OrdaliDir $env(ORDALIDIR) set OrdaliDejaSource 0 source [file join $OrdaliDir src ordali_source.tcl] package require Thread package require http #LoadTclPackages package require tclcluspack package require tclordalie #package require sqlite3 set VariablesAuDepart [info globals] source /home/moumou/gscopublic/bcm.tcl source /home/moumou/gscopublic/bcm_setup.tcl source /home/moumou/gscopublic/bcm_run.tcl InitLesDefauts LesDefauts OnlyTLog 1 LesDefauts Mode batch BCM_setup } proc Td {} { puts [join [DecoupeEnSousOrdresPourGif "create rectangle 1 2 3 4 -a \{A AA\} -b \\\{ -c -9"] "\n"] exit } proc Tdbc {} { global RepertoireDuGenome set LesAccess [LesLignesDuFichier "$RepertoireDuGenome/descriptifs/VCHO10004"] set Texte [join $LesAccess "\n"] DbClustal toto oscar.msf $Texte "AvecSelection" exit } proc Tele2HTML {aT} { upvar $aT tbl if {$tbl(Text) eq ""} { Html_BR } else { Html_Append "$tbl(Text)" } return } proc Tele2Text {aT} { upvar $aT tbl lappend ::TextOut "$tbl(Text)" return } proc TempsExecutionDesBlast {{GetWhat ""} {Qui ""} {Mi ""} {Ma ""}} { #rR Je prends la date de création du fasta et du blast dans oif/OI1234/fasta et oif/OI1234/blast if {$Mi==""} { set Mi -1 } if {$Ma==""} { set Ma 9999999 } if {$Qui==""} { set Qui [lsort [glob -nocomplain "[RepertoireDuGenome]/oif/OI*"]] } set N 0 set Total 0 set LesTemps {} set Min 999999 set Max -1 set NbNom 0 foreach Nom $Qui { set Nom [file tail $Nom] incr NbNom Espionne $Nom NousAllonsAuBoulot "[RepertoireDuGenome]/oif/$Nom" foreach B [lsort [glob -nocomplain "blast/*"]] { set S [file size $B] if {$S==0} { continue } set Q [file tail $B] set F "fasta/$Q" set Deb [file mtime $F] set Fin [file mtime $B] set Duree [expr $Fin-$Deb] if {$Duree<$Mi} { continue } if {$Ma<$Duree} { continue } incr N incr Total $Duree lappend LesTemps $Duree set Min [Mini $Min $Duree] set Max [Maxi $Max $Duree] } OnRevientDuBoulot } set M [expr $Total/$N] set JoursTotalLbgi [expr $Total/(60*60*24)] set JoursTotal [expr 10000000*$JoursTotalLbgi/$N] set AnsTotal [expr $JoursTotal/365] set Message "Sur $N blast faits Min $Min Moyenne $M Max $Max Temps total $JoursTotalLbgi jours au lbgi ... et en extraolant $JoursTotal jours pour les 10 000 000 soit $AnsTotal ans !" Espionne $Message set LesTemps [lsort -integer $LesTemps] if {[regexp -nocase "Histo" $GetWhat]} { lassign [Histogramme $LesTemps "GetLists"] LesN LesY Graphe $LesN $LesY "" "" 1200 1200 } if {[regexp -nocase "Graphe" $GetWhat]} { Graphe $LesTemps "" "" "" 1200 1200 } return $Message } proc TermineChangePreferences {w} { global LNDG global NomFenetreOrdali global Defauts global NomTextSeq global NomNomSeq global WTexteRegle global LesPoidsDesSequences if {[winfo exists $NomFenetreOrdali.lessequences.tognoms] && ![set Defauts(CheckSeq)]} { destroy $NomFenetreOrdali.lessequences.tognoms } if {![winfo exists $NomFenetreOrdali.lessequences.tognoms] && [set Defauts(CheckSeq)]} { button $NomFenetreOrdali.lessequences.tognoms -text "Access/Name" -command "ChangeTypeNom \[$NomFenetreOrdali.lessequences.scrolly get \]" -background green1 grid $NomFenetreOrdali.lessequences.tognoms -in $NomFenetreOrdali.lessequences -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky news } font configure SeqFont -size [set Defauts(SeqFontSize)] -family [set Defauts(SeqFontFaml)] -weight [set Defauts(SeqFontWght)] if {[set Defauts(Poids)]} { global LesPoidsDesSequences global LesPoidsLus set LesPoidsDesSequences $LesPoidsLus } destroy $w update return } proc TermineSelection {} { global Defauts global Sequences global LNOrdali global LNDG global SDG global ListeNomAssocieALAccess global ListeDesNomsDeGenes global ListeDesDefinitions global ListeDesPiliersDuGroupe global LongueurTotale global BonSeq AuLog "Termine : Nbr Seq [llength $LNOrdali]" set Encore 1 while {$Encore} { set Idx [lsearch $BonSeq "0"] if {$Idx != -1} { set Seq [lindex $LNOrdali $Idx] unset Sequences($Seq) set LNOrdali [lreplace $LNOrdali $Idx $Idx] if {[set Defauts(CheckSeq)]} { set ListeNomAssocieALAccess [lreplace $ListeNomAssocieALAccess $Idx $Idx] set ListeDesNomsDeGenes [lreplace $ListeDesNomsDeGenes $Idx $Idx] set ListeDesDefinitions [lreplace $ListeDesDefinitions $Idx $Idx] } if {[info exists SDG]} { foreach ng [array names SDG] { set IdG [lsearch [set SDG($ng)] $Seq] if {$IdG != -1} { set SDG($ng) [lreplace [set SDG($ng)] $IdG $IdG] } } } set BonSeq [lreplace $BonSeq $Idx $Idx] } else { set Encore 0 } } if {! [info exists LNDG]} { InitPremierGroupe } set LeGrpDesPiliersAcreer 0 CreeLesPiliers $LeGrpDesPiliersAcreer set PilPoint [string repeat "." [llength $LNOrdali]] set Encore 1 while {$Encore} { set Idx [lsearch -exact $ListeDesPiliersDuGroupe(GroupeToutLeMonde) $PilPoint] if {$Idx != -1} { set ListeDesPiliersDuGroupe(GroupeToutLeMonde) [lreplace $ListeDesPiliersDuGroupe(GroupeToutLeMonde) $Idx $Idx] } else { set Encore 0 } } set k 0 foreach Seq $LNOrdali { set NewSeq "" set i 0 foreach Pilier $ListeDesPiliersDuGroupe(GroupeToutLeMonde) { append NewSeq [string index $Pilier $k] incr i } set Sequences($Seq) $NewSeq incr k } set LongueurTotale [string length [set Sequences([lindex $LNOrdali 0])]] unset ListeDesPiliersDuGroupe(GroupeToutLeMonde) AuLog "Termine : Nbr Seq [llength $LNOrdali]" InitWRegle if {![info exists LNDG]} { InitWTexte } else { MetAJourWNomsWSeqs } AfficheTexteSeq AfficheRegle return } proc TermineZoneAnnotation {w x y} { PositionAnnotation $w $x $y "fin" set Lt [$w tag ranges selZone] if {$Lt != {} } { set Ntag "Anno_[incr ::Anno(NoTag)]" set ::Anno(NtagCou) $Ntag $w tag configure $Ntag -background $::Anno(fgcol) $w tag add $Ntag {*}$Lt $w tag remove selZone 1.0 end } $w configure -state disabled return } proc TestAAduCodon {} { Espionne [AAduCodon Tga] Espionne [AAduCodon TGA W] Espionne [AAduCodon tGA] Espionne [AAduCodon ATG] Espionne [AAduCodon ATG S] Espionne [AAduCodon ATG] Espionne [AAduCodon Reset] Espionne [AAduCodon ATG] Espionne [AAduCodon tGA] exit } proc TestAccessEnCommun {} { global MesAccessInterressants foreach PAB [ListeDesPABs] { set AccProt [AccessDeLaBoite $PAB protein] if {![info exists DejaVu($AccProt)]} {set DejaVu($AccProt) 1} else {continue} if {$AccProt==""} {Espionne "No prot for $PAB $AccProt"} #Si existe rend 0 if {[AccessToKeepOrNotToKeep $AccProt]==1} { set Id [lindex [DefDeAcc $AccProt "protein" "Id"] 1] if {$Id =="" || [regexp "ACT" $Id]} {continue} #Espionne "$PAB Acc $Acc" if {[AccessToKeepOrNotToKeep $Id]==1} { #EnrichiAccessToKeepOrNotToKeep $AccProt Espionne "$AccProt\t[lindex [DefDeAcc $AccProt "protein" "Id"] 1]\t[AccessDeLaBoite $PAB protein Definition]" continue } continue } } #set LesAccess [array names MesAccessInterressants] #EspionneL [lsort $LesAccess] } proc TestAff {} { AfficheFichier "[RepertoireDuGenome]/nuctfa/EVI0001" "AvecFormate" set Texte [ContenuDuFichier "[RepertoireDuGenome]/nuctfa/EVI0001"] AfficheVariable $Texte "AvecFormate" } proc TestAffiche {} { AfficheFichier "[RepertoireDuGenome]/nuctfa/EVI00020" "AvecFormate" set Texte [ContenuDuFichier "[RepertoireDuGenome]/nuctfa/EVI00020"] AfficheVariable $Texte "AvecFormate" } proc TestAffyAnno {} { foreach Index [AffyAnno ListOf Index] { foreach Header [AffyAnno ListOf Header] { Espionne "$Index $Header [AffyAnno $Index $Header]" } } } proc TestAllEleGen {} { set SizeFMin 99999999999 set SizeFMax -1 foreach Gn [AllEleGen ListOf Gn] { if {$Gn=="" || $Gn=="NA"} { continue } set Size [AllEleGen $Gn Size] if {$Size>1000000} { continue; Espionne $Gn } if {$Size==""} { continue } if { ! [info exists SizeMin(F)]} { set SizeMin(F) $Size ; set SizeMax(F) $Size } set SizeMin(F) [Mini $SizeMin(F) $Size] set SizeMax(F) [Maxi $SizeMax(F) $Size] foreach T [AnnotType ListOf T] { set Size [AllEleGen $Gn Size $T] if {$Size==""} { continue } if { ! [info exists SizeMin($T)]} { set SizeMin($T) $Size ; set SizeMax($T) $Size } set SizeMin($T) [Mini $SizeMin($T) $Size] set SizeMax($T) [Maxi $SizeMax($T) $Size] } } lappend LaSortie [format "%9s %9d %9d" Final $SizeMin(F) $SizeMax(F)] foreach T [lreverse [AnnotType ListOf T]] { set Code [AnnotType $T Code] if { ! [info exists SizeMin($T)]} { continue } lappend LaSortie [format "%9s %9s %9s" $Code $SizeMin($T) $SizeMax($T)] } return $LaSortie } proc TestAnalyseBlastP {} { Wup "Test AnalyseDesBlastPs nombredecopainsdansblast orthoblastp ooblastp" global RepertoireDuGenome global CheckResultat if { ![file exists "$RepertoireDuGenome/apns"] || [glob -nocomplain "$RepertoireDuGenome/apns/*"]=={} || ![file exists "$RepertoireDuGenome/fiches/nombredecopainsdansblast" ]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/nombredecopainsdansblast, run CreeLesFichiersApns" lappend CheckResultat " and run CreeLeFichierNombreDeCopainsDansBlast" } else { lappend CheckResultat " Count les BlastPs done" } if {![file exists "$RepertoireDuGenome/fiches/orthoblastp"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/orthoblastp, run CreeOrthoBlastP" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/orthoblastp exists, CreeOrthoBlastP done" } if {![file exists "$RepertoireDuGenome/fiches/ooblastp"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/ooblastp, run ORGAorgaDesBlastPs" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/ooblastp exists, ORGAorgaDesBlastPs done" } } proc TestAnalyseDbClustal {} { Wup "Test AnalyseDbClustaL oomsf startcodon_summary phylumsorthologues paralogues.blastp" Wup "et startcodon_report startcodon_cluster" global RepertoireDuGenome global CheckResultat if {[file exists "$RepertoireDuGenome/fiches/oomsf"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/oomsf\t exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/oomsf" } if {[file exists "$RepertoireDuGenome/fiches/phylumsorthologues"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/phylumsorthologues exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/phylumsorthologues" } if {[file exists "$RepertoireDuGenome/fiches/paralogues.blastp"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/paralogues.blastp exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/paralogues.blastp" } if {[file exists "$RepertoireDuGenome/fiches/startcodon_summary"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/startcodon_summary exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/startcodon_summary" } if {[file exists "$RepertoireDuGenome/fiches/startcodon_cluster"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/startcodon_cluster exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/startcodon_cluster" } #start_codon_report_essai ou start_codon_report if {[file exists "$RepertoireDuGenome/fiches/startcodon_report_essai"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/startcodon_report_essai exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/startcodon_report_essai" } #start_codon_report_essai ou start_codon_report if {![file exists "$RepertoireDuGenome/fiches/oomsf"] || ![file exists "$RepertoireDuGenome/fiches/phylumsorthologues"] || ![file exists "$RepertoireDuGenome/fiches/startcodon_summary"] || ![file exists "$RepertoireDuGenome/fiches/startcodon_cluster"] || ![file exists "$RepertoireDuGenome/fiches/startcodon_report_essai"] || ![file exists "$RepertoireDuGenome/fiches/paralogues.blastp"] } { lappend CheckResultat "Analysis on DbClustal incomplete, run AnalyseLesDbClustal" } else { lappend CheckResultat "AnalyseLesDbClustal done" } } proc TestAnalyseTBlastN {} { Wup "Test AnalyseDesTBlastNs ouatapetbn orthotblastn ootblastn" global RepertoireDuGenome global CheckResultat if {![file exists "$RepertoireDuGenome/fiches/ouatapetbn.genomes"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/ouatapetbn.genomes, run CreeOuATapeTBlastN" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/ouatapetbn.genomes exists" } if {![file exists "$RepertoireDuGenome/fiches/orthotblastn"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/orthotblastn, run CreeOrthoTBlastN" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/orthotblastn exists, CreeOrthoTBlastN done" } if {![file exists "$RepertoireDuGenome/fiches/ootblastn"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/ootblastn, run ORGAorgaDesTBlastNs" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/ootblastn exists, ORGAorgaDesTBlastNs done" } if {![file exists "$RepertoireDuGenome/fiches/organismesayantmemeoperon"]} { lappend CheckResultat "No $RepertoireDuGenome/fiches/organismesayantmemeoperon, run CreeLeFichierOrganismesAyantMemeOperon" } else { lappend CheckResultat " $RepertoireDuGenome/fiches/organismesayantmemeoperon exists" } } proc TestAnchorsCoherents {} { global RepertoireDuGenome set FichierTFA "$RepertoireDuGenome/tfasdescopains/PDB66" set FichierAnchors "$RepertoireDuGenome/ballast/PDB66.anchors" set FichierBlast "$RepertoireDuGenome/blastp/PDB66" Espionne [AnchorsCoherents $FichierTFA $FichierAnchors $FichierBlast] exit } proc TestAnnotationXml {} { ParseAnnotationXml "[RepertoireDuGenome]/annotation/BA0003.xml" AX parray AX exit } proc TestArClade {} { foreach Ligne [LesLignesDuFichier [GscopeFile AHalma04100 taxobla]] { scan $Ligne "%s %s %s" E S OX Espionne [format "%-30s %s OX = %s" [ArCladeOf $OX Name] [Tax $OX Name] $OX] } } proc TestArbreEnListe {{args ""}} { global AfficheArbreIndent set AfficheArbreIndent 0 if {$args != ""} {set Fic $args} {set Fic "/genomics/link/ARP/phylos/ARP47"} set Arbre [ArbreEnListe [ContenuDuFichier $Fic]] AfficheArbre $Arbre exit } proc TestArchaeaGenomesDeClaudine {} { foreach OS [ClaudineArchaea ListOf OS] { regsub -all " +" [string trim $OS] "_" OS Espionne [format "%-30s %s" [ArCladeOf $OS Name] $OS] } } proc TestBali {} { global LNOrdali LSOrdali Sequences PABCourant OrdTmpDir FichierTFA Defauts SDG NomSeqSel global NId NCo NTt NConsDansId NConsDansCo NConsDansTt TableScore LNorMD NAli LongTot Sequences global VariablesAuDepart TNResConsNSA TNResConsSA LongueurTotale global ConsRef TNResConsSA ListePDB ConsSA global NomSeqSel NBench global TResSeeAsId TResSeeAsCo TResSeeAsTt TResId TResCo TResTt set FichierMSF "" LesDefauts set NomSeqSel {} set Ntypes [list Norm Thompson Ranganatan VolPol Liu Liu2 RPCA Entrop1 Entrop2] set BDir /home/moumou/tmp/Balibase3/bb3_release set Ldir [lsort [glob -types d [file join $BDir RV*]]] foreach d $Ldir { puts "\n====================" puts "= [file tail $d]" puts "====================\n" # Init Variables sens/spec set LongTot 0 set NAli 0 set NBench 0 foreach type $Ntypes { set TResSeeAsId($type) 0 set TResSeeAsCo($type) 0 set TResSeeAsTt($type) 0 set TResId($type) 0 set TResCo($type) 0 set TResTt($type) 0 } LesDefauts TypeAli MSF LesDefauts Mode "Batch" set VariablesAuDepart [info globals] set Lf [glob [file join $d *.msf]] foreach f $Lf { if {[regexp {^BBS} [file tail $f]]} { continue } set FichierMSF $f LesDefauts FichierMSF $FichierMSF puts "\n => [file tail $f]" LoadingAlignement InitInfoSeqs LongueurDeLAlignement set NSqs [llength $SDG(GroupeToutLeMonde)] set PABCourant $f puts "NSeqs : $NSqs Lgt $LongueurTotale" if {$NSqs < 10} { puts "Less than 10 Sequences !!" FermeFichier continue } AnyBal $f FermeFichier } # Calcul Specificite et Sensibilite puts "" puts "" puts "=========================" puts "= R E S U L T A T S =" puts "=========================" puts "" puts "Nombre alignements ..............: $NAli" puts "Longueur totale .................: $LongTot" puts "Nombre residus du benchmark .....: $NBench" puts "" foreach tnom $Ntypes { # Sens = VraiPos/(VraiPos + FauxNeg) # Spec = VraiNeg/(VraiNeg + FauxPos) # VraiPos : Identi ET SA # FauxPos : SA non vu (non identifie) # VraiNeg : lg - sa - colo cons qui sont pas sites # FauxNeg : Sa qui ne sont pas dans une col de cons set ResSeeAsId "[set TResSeeAsId($tnom)]." set ResId "[set TResId($tnom)]." set ResSeeAsCo "[set TResSeeAsCo($tnom)]." set ResCo "[set TResCo($tnom)]." set ResSeeAsTt "[set TResSeeAsTt($tnom)]." set ResTt "[set TResTt($tnom)]." # Pour Identite # -------- set sensId [expr {1.*$ResSeeAsId/$NBench}] set specId [expr {1.*($LongTot - $ResId - ($NBench - $ResSeeAsId))/(($LongTot - $ResId - ($NBench - $ResSeeAsId))+($ResId - $ResSeeAsId))}] set SumSensSpecId [expr {($sensId + $specId) - 1.0}] # Pour Conserve # -------- set sensCo [expr {1.*$ResSeeAsCo/$NBench}] set specCo [expr {1.*($LongTot - $ResCo - ($NBench - $ResSeeAsCo))/(($LongTot - $ResCo - ($NBench - $ResSeeAsCo))+($ResCo - $ResSeeAsCo))}] set SumSensSpecCo [expr {($sensCo + $specCo) - 1.0}] # Pour Global (Identite+Cons) #set NConsTt [expr {$NConsId + $NConsCo}] set sensTt [expr {$ResSeeAsTt/$NBench}] set specTt [expr {1.*($LongTot - $ResTt - ($NBench - $ResSeeAsTt))/(($LongTot - $ResTt - ($NBench - $ResSeeAsTt))+($ResTt - $ResSeeAsTt))}] set SumSensSpecTt [expr {($sensTt + $specTt) - 1.0}] puts "" puts "type [join $tnom +] :" puts "--------------" puts "Nombre residus vus Identite........... : $ResId" puts "Nombre residus vus Conserves ......... : $ResCo" puts "Nombre residus vus Iden+Cons ......... : $ResTt" puts "Nombre residus typifies Ident ........ : $ResSeeAsId" puts "Nombre residus typifies Cons ......... : $ResSeeAsCo" puts "Nombre residus typifies Iden+Cons .... : $ResSeeAsTt" set fmt "%s %5.3f" puts "" puts [format $fmt "\tsensibilite Identite ......:" $sensId] puts [format $fmt "\tspecificite Identite ......:" $specId] puts [format $fmt "\tSomme sens+spec Identite...:" $SumSensSpecId] puts [format $fmt "\tsensibilite Conserve ......:" $sensCo] puts [format $fmt "\tspecificite Conserve ......:" $specCo] puts [format $fmt "\tSomme sens+spec Conserve ..:" $SumSensSpecCo] puts [format $fmt "\tsensibilite totale ........:" $sensTt] puts [format $fmt "\tspecificite totale ........:" $specTt] puts [format $fmt "\tSomme sens+spec totale ....:" $SumSensSpecTt] puts "" puts "" set ResPF($tnom,sensId) $sensId set ResPF($tnom,specId) $specId set ResPF($tnom,sumId) $SumSensSpecId set ResPF($tnom,sensCo) $sensCo set ResPF($tnom,specCo) $specCo set ResPF($tnom,sumCo) $SumSensSpecCo set ResPF($tnom,sensTt) $sensTt set ResPF($tnom,specTt) $specTt set ResPF($tnom,sumTt) $SumSensSpecTt } puts "\n\n" foreach titre {"Sensibilite Identite" "Specificite Identite" "Sum Identite" "Sensibilite Conserve" "Specificite Conserve" "Sum Conserve" "Sensibilite Totale" "Specificite Totale" "Sum Totale"} cle {sensId specId sumId sensCo specCo sumCo sensTt specTt sumTt} { puts "$titre" set Lv [array names ResPF "*,$cle"] set Lr [list] foreach v $Lv { lassign [split $v ,] nom tmp set x [set ResPF($v)] lappend Lr [list $nom $x] } set Lr [lsort -real -index 1 $Lr] foreach v $Lr { lassign $v nom x puts [format "%15s %7.2f" [join $nom +] [expr {$x*100.}]] } puts "" } puts "\nTermine\n" } return } proc TestBird {} { set Query "select * from ucschuman.refgene where txend < 990000 and txstart >= 924207 and chrom='chr1'" Espionne [Bird $Query xml] } proc TestBirdFromQueryText {} { set Query {} # foreach Access [list NP_000035 NP_001009012 NP_001028083 XP_001504915 NP_001003053 NP_038504 NP_036634 NP_999479 XP_001376683] {} foreach Access [list P12345999 PAX2_HUMAN] { lappend Query "ID $Access DB uniprot" lappend Query "FM FLAT" } set Query [join $Query "\n"] Espionne $Query set R [BirdFromQueryText $Query] return $R } proc TestBirdFromTheBlast {} { BirdFromTheBlast EF001 return [BirdWeb "uniprot" "UniRef50_Q057N6"] } proc TestBirdQL {} { set LaQuery {} lappend LaQuery "ID CO8B_HUMAN DB Uniprot" lappend LaQuery "FD AC,ID,DR,GN" lappend LaQuery "FM FLAT" lappend LaQuery "AC P12345 DB Uniprot" lappend LaQuery "FD AC,ID,DR,GN" lappend LaQuery "FM FLAT" set Query [join $LaQuery "\n"] return [BirdFromQueryText $Query] return [BirdQL $Query] } proc TestBlastP {} { Wup "Test BlastP et AnalyseBlastP " global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test BlastP------" if {[file exists "$RepertoireDuGenome/blastp"]} { set Reponse " $RepertoireDuGenome/blastp exists" if {[glob -nocomplain "$RepertoireDuGenome/blastp/*"]=={}} { append Reponse " but you should run BlastPPourTous" lappend CheckResultat $Reponse } else { append Reponse " and BlastPPourTous done" lappend CheckResultat $Reponse TestAnalyseBlastP } } else { set Reponse "Create $RepertoireDuGenome/blastp, run BlastPPourTous" lappend CheckResultat $Reponse } } proc TestBlastReduit {} { BlastReduit PGS542 [LesLignesDuFichier liste.txt] AEnlever exit } proc TestBlastnOnHumanJunctions {} { #Comparaison entre les versions de blast 2.2.10 (blastall) et 2.2.29 avec et sans filtre set BankJuncHuman "/genomics/link/SpliRetMouse/201404/PubliFarkas/JunctionsHumanFromFarkas" foreach FileNuc [glob -nocomplain "/genomics/link/SpliRetMouse/201404/RepDeTravail/VersionBlastn/*.tfa"] { regsub {\.tfa} $FileNuc "" FileNucOut set CommandeBlastOld "blastall -p blastn -i $FileNuc -o ${FileNucOut}_.bl2.2.10 -d $BankJuncHuman -e 50.0 -W 8" Espionne "$CommandeBlastOld" lappend LesCommandes $CommandeBlastOld if {[catch {eval exec $CommandeBlastOld} Message]} { Espionne "Problem with $CommandeBlastOld" Espionne $Message } set CommandeBlastOldFT "blastall -p blastn -i $FileNuc -o ${FileNucOut}_FT.bl2.2.10 -d $BankJuncHuman -e 50.0 -F T -W 8" Espionne "$CommandeBlastOldFT" lappend LesCommandes $CommandeBlastOldFT if {[catch {eval exec $CommandeBlastOldFT} Message]} { Espionne "Problem with $CommandeBlastOldFT" Espionne $Message } set CommandeBlastOldFF "blastall -p blastn -i $FileNuc -o ${FileNucOut}_FF.bl2.2.10 -d $BankJuncHuman -e 50.0 -F F -W 8" Espionne "$CommandeBlastOldFF" lappend LesCommandes $CommandeBlastOldFF if {[catch {eval exec $CommandeBlastOldFF} Message]} { Espionne "Problem with $CommandeBlastOldFF" Espionne $Message } set CommandeBlastNew "/biolo/blast/bin/blastn -task blastn -query $FileNuc -out ${FileNucOut}_.bl2.2.29 -db $BankJuncHuman -evalue 50.0 -word_size 8" Espionne "$CommandeBlastNew" lappend LesCommandes $CommandeBlastNew if {[catch {eval exec $CommandeBlastNew} Message]} { Espionne "Problem with $CommandeBlastNew" Espionne $Message } set CommandeBlastNewDustYes "/biolo/blast/bin/blastn -task blastn -query $FileNuc -out ${FileNucOut}_dustyes.bl2.2.29 -db $BankJuncHuman -evalue 50.0 -dust yes -word_size 8" Espionne "$CommandeBlastNewDustYes" lappend LesCommandes $CommandeBlastNewDustYes if {[catch {eval exec $CommandeBlastNewDustYes} Message]} { Espionne "Problem with $CommandeBlastNewDustYes" Espionne $Message } set CommandeBlastNewDustNo "/biolo/blast/bin/blastn -task blastn -query $FileNuc -out ${FileNucOut}_dustno.bl2.2.29 -db $BankJuncHuman -evalue 50.0 -dust no -word_size 8" Espionne "$CommandeBlastNewDustNo" lappend LesCommandes $CommandeBlastNewDustNo if {[catch {eval exec $CommandeBlastNewDustNo} Message]} { Espionne "Problem with $CommandeBlastNewDustNo" Espionne $Message } } #SauveLesLignes $LesCommandes dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/VersionBlastn/Commandes" } proc TestBlastpOnProtall {} { #Comparaison entre les versions de blast 2.2.10 (blastall) et 2.2.29 avec et sans filtre foreach FileProt [glob -nocomplain "/genomics/link/SpliRetMouse/201404/RepDeTravail/VersionBlastp/*.tfa"] { regsub {\.tfa} $FileProt "" FileProtOut set CommandeBlastOld "blastall -p blastp -i $FileProt -o ${FileProtOut}_.bl2.2.10 -d /blast/protall -v 5000 -b 5000" Espionne "$CommandeBlastOld" lappend LesCommandes $CommandeBlastOld if {[catch {eval exec $CommandeBlastOld} Message]} { Espionne "Problem with $CommandeBlastOld" Espionne $Message } set CommandeBlastOldFT "blastall -p blastp -i $FileProt -o ${FileProtOut}_FT.bl2.2.10 -d /blast/protall -F T -v 5000 -b 5000" Espionne "$CommandeBlastOldFT" lappend LesCommandes $CommandeBlastOldFT if {[catch {eval exec $CommandeBlastOldFT} Message]} { Espionne "Problem with $CommandeBlastOldFT" Espionne $Message } set CommandeBlastOldFF "blastall -p blastp -i $FileProt -o ${FileProtOut}_FF.bl2.2.10 -d /blast/protall -F F -v 5000 -b 5000" Espionne "$CommandeBlastOldFF" lappend LesCommandes $CommandeBlastOldFF if {[catch {eval exec $CommandeBlastOldFF} Message]} { Espionne "Problem with $CommandeBlastOldFF" Espionne $Message } set CommandeBlastNew "/biolo/blast/bin/blastp -query $FileProt -out ${FileProtOut}_.bl2.2.29 -db /blast/protall -num_descriptions 5000 -num_alignments 5000" Espionne "$CommandeBlastNew" lappend LesCommandes $CommandeBlastNew if {[catch {eval exec $CommandeBlastNew} Message]} { Espionne "Problem with $CommandeBlastNew" Espionne $Message } set CommandeBlastNewSegYes "/biolo/blast/bin/blastp -query $FileProt -out ${FileProtOut}_segyes.bl2.2.29 -db /blast/protall -seg yes -num_descriptions 5000 -num_alignments 5000" Espionne "$CommandeBlastNewSegYes" lappend LesCommandes $CommandeBlastNewSegYes if {[catch {eval exec $CommandeBlastNewSegYes} Message]} { Espionne "Problem with $CommandeBlastNewSegYes" Espionne $Message } set CommandeBlastNewSegNo "/biolo/blast/bin/blastp -query $FileProt -out ${FileProtOut}_segno.bl2.2.29 -db /blast/protall -seg no -num_descriptions 5000 -num_alignments 5000" Espionne "$CommandeBlastNewSegNo" lappend LesCommandes $CommandeBlastNewSegNo if {[catch {eval exec $CommandeBlastNewSegNo} Message]} { Espionne "Problem with $CommandeBlastNewSegNo" Espionne $Message } } SauveLesLignes $LesCommandes dans "/genomics/link/SpliRetMouse/201404/RepDeTravail/VersionBlastp/Commandes" } proc TestBlomeSql {Projet Phylum} { set LeSql [list] lappend LeSql "SELECT COUNT(ln_organism_taxobla.pk_taxobla), specie, taxid, ln_organism_taxobla.pk_organism, clade.nom " lappend LeSql "FROM ln_organism_taxobla join taxobla ON taxobla.pk_taxobla =ln_organism_taxobla.pk_taxobla " lappend LeSql "JOIN organism ON organism.pk_organism= ln_organism_taxobla.pk_organism " lappend LeSql "JOIN ln_clade_organism ON ln_clade_organism.pk_organism = organism.pk_organism " lappend LeSql "JOIN clade ON clade.pk_clade=ln_clade_organism.pk_clade " lappend LeSql "GROUP BY organism.pk_organism ORDER BY clade.pk_clade" set Sql [join $LeSql " "] set R [SqlExecForDatabase "[BlomeDbDir]/${Projet}_${Phylum}.db" $Sql GetList] EspionneL $R exit } proc TestBrocOli {} { set FicOligos "[RepertoireDuGenome]/atelier/rr/oligos_rr.tfa" set FicOligos "[RepertoireDuGenome]/atelier/AnneCath2/oligos_HsCyclinT1-2-533-674-726.tfa" # set FicOligos "[RepertoireDuGenome]/atelier/Levy/Ordre2/oligos_AttB1_NdeI-ToDo20080710hsVBP1-BamHI_TEV2_STREP_STOP_AttB2.tfa" foreach Access [LaSequenceDuTFAs $FicOligos "LaListeDesAccess"] { set TFA [LaSequenceDuTFAs $FicOligos $Access] set B [BrocOli $TFA] Espionne $B } } proc TestCA {} { return [CompareADNDesFichiersTFA "/genomics/link/ProGS/nuctfa/PGS002" "/genomics/link/ProGS/nuctfa/PGS502" SansAffichage] } proc TestCanalSqlCurrent {} { CanalSql Espionne [CanalSqlCurrent] CanalSqlDisconnect Espionne [CanalSqlCurrent] CanalSql Espionne [CanalSqlCurrent] } proc TestCanvasToSvgFile {} { # set K [GscopeBoard] package require Tk LogWscope coucoucoucoucouc set K [IllustreLeBlast "/genomics/link/CilioCarta2014/blastp/CIL006"] LogWscope $K return [CanvasToSvgFile $K "GetSvg"] } proc TestCanvasToSvgFileSvg {} { package require Tk set K [IllustreLeBlastSvg] return [CanvasToSvgFile $K "GetSvg"] } proc TestCdsFromNM {} { set Fasta [eFetchREST nucleotide "NM_019955 AI852232 NM_019778" cds] Espionne $Fasta } proc TestCenar {} { set G [QueLaSequenceDuFichierTFA "/genomics/link/Cenar/beton/cenarchaeum_symbiosum.tfa"] regsub -all -nocase {[ATGC]} $G "" g Espionne $g set O [QueLaSequenceDuFichierTFA "/home/sage2014/odile/NC_014820.tfa"] if {$G==$O} { FaireLire "C bon" } exit } proc TestChaqueProteineDuTBlastN {Nom} { global RepertoireDuGenome set Fichier "$RepertoireDuGenome/tblastngenomes/$Nom" if { ! [file exists $Fichier]} { return "" } Espionne [join [ChaqueProteineDuTBlastN $Fichier] "\n"] exit } proc TestChemin {} { global T LNOrdali set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08] array set T [ContenuDuFichier filsde.dat] set n1 s01 foreach k [array names T "$n1,*"] { lassign [split $k ,] n1 ag1 set Lchemin [CheminsAgent $n1 $ag1 $n1 $ag1] puts "\n$n1 $ag1 :" puts [join $Lchemin \n] } exit } proc TestCheminRR {} { global T LNOrdali set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08] array set T [ContenuDuFichier "/home/moumou/Agents/filsde.dat"] # foreach {K V} [array get T] { # lassign [split $k ,] n1 ag1 # Espionne "$K" # } set n1 s01 foreach k [array names T "$n1,*"] { lassign [split $k ,] n1 ag1 set A "$n1,$ag1" set B "$n1,$ag1" set Lchemin [CheminsAgentRR $A $B] puts "\n$A :" puts [join $Lchemin \n] } exit } proc TestChoixParmi {} { set LCP [ColorationsPossibles] set LCPT [LaTraduction $LCP] Espionne [ChoixParmiJoli $LCP {} $LCPT] exit } proc TestCineticCongRD1 {} { foreach GN [CineticCongRD1 ListOf GN] { foreach Mot [split $GN ","] { set GscopeId [QuestionDeScience "EVImm" "ret GscopeIdsOfGeneName $Mot WithSynonyms"] Espionne "$Mot $GscopeId" } } } proc TestCladeCourant {} { Espionne [CladeCourant] Espionne [CladeCourant Insecta] Espionne [CladeCourant See] Espionne [CladeCourant New] } proc TestCleaning {} { Chronometre Depart #Rapide CleanFeaturesInMACS "[RepertoireDuGenome]/alignement_ARP/Actin_Complet6_7.rsf" toto Chronometre Arrivee Chronometre Depart #Lent CleanFeaturesInMACS2 "[RepertoireDuGenome]/alignement_ARP/Actin_Complet6_7.rsf" tutu Chronometre Arrivee } proc TestClonage {} { set LesOli [ClonInventory LesOligos] set LesOli [ClonInventory LesOligos] Espionne [OligosFiles [ChoixParmi [ItsOligos [ChoixParmi $LesOli]]]] } proc TestClusterPos {{file ""}} { global LNOrdali PABCourant OrdTmpDir FichierMSF Defauts SDG NomSeqSel global NId NCo NConsDansId NConsDansCo TableScore LNorMD ConsRef Sequences global VariablesAuDepart TNResConsNSA TNResConsSA LongueurTotale LongTot set FichierMSF "" NousAllonsAuBoulot $OrdTmpDir LoadReferencePDB LoadNorMD LesDefauts NettoieLeTmp set rep "[RepGenLuc]/msf" #set repLeon [file join [RepGenLuc] "msf_nature" "Rascal" "Leon"] #aF on prend les fichiers issus de Rascal et non pas de leon! set repRascal [file join [RepGenLuc] "msf_nature" "Rascal"] if {$file ne ""} { set LesFiles $file if {[string index [string trim $file] end] == "+"} { set tmp [LPABLuc] set file [string range $file 0 end-1] set i [lsearch $tmp $file] set LesFiles [lrange $tmp $i end] } } else { set LesFiles [LPABLuc] #aF je ne veux pas traiter l ensemble de la liste, mais simplement certains PAB, contenu dans le fichier fichierPAB #set fichierPAB [file join [RepGenLuc] "Typification" "ResuThese" "listeComQualSansrm"] #set LesFiles [LesLignesDuFichier $fichierPAB] } set NomSeqSel {} # Types de conservations a tester # Originaux : # set Ltypes [list 0 1 2 4 5 04 05 45 045 6 7 8 9] # set Ntypes [list Norm Surf Angle Dist Delta Norm+Dist Norm+Delta Dist+Delta Norm+Dist+Delta VolPol Al2Co Liu RPCA] # # to work set Ltypes [list 0 1 2 3 4 5 6 8 9] set Ntypes [list Norm Surf Angle Surf2 Dist Delta VolPol Liu RPCA] set LongTot 0 foreach type $Ltypes { set TNConsId($type) 0 set TNConsCo($type) 0 set TNId($type) 0 set TNCo($type) 0 } set VariablesAuDepart [info globals] LesDefauts TypeAli MSF LesDefauts Mode "Batch" set NAli 0 set NResConsSA 0 set NResConsNSA 0 foreach n $LesFiles { # set fic [file join $repLeon $n] #aF a modifie repLeon en repRascal set fic [file join $repRascal $n] if {! [file exists $fic]} { puts " >>$fic<< doesn t exists !" puts " -----------------------\n\n" continue } file copy -force $fic [file join $OrdTmpDir $n] set FichierMSF [file join $OrdTmpDir $n] LesDefauts FichierMSF $FichierMSF puts "===========" puts "| $n |" puts "===========" set PABCourant $n if {[set LNorMD($n)] < 0.3} { puts "" puts " >>> NorMD est < a 0.3 <<<" puts "" FermeFichier continue } LoadingAlignement # ::profiler::reset MetAJourGroupes set NSqs [llength $SDG(GroupeToutLeMonde)] puts "NSeqs : $NSqs" if {$NSqs < 10} { puts "Les than 10 Sequences !!" FermeFichier continue } if {[info exists TableScore]} {unset TableScore} set grp "" ScoreDeNorm $grp ; # 0 1 2 3 ScoreDeSurf $grp ; # 0 1 2 3 ScoreDeThompson $grp ; # 4 ScoreDeRanganatan $grp ; # 5 ScoreDeVolPol $grp ; # 6 ScoreAl2Co $grp ; # 7 ScoreDeLiu $grp ; # 8 ScoreDeLiu2 $grp ; # 8 ScoreDeRPCA $grp ; # 9 set rep1 [VerificationAvantCalculs] if {! $rep1} { puts "Une des methode foireuse !!" puts "skip alignement\n" } else { set BonTousTypes 1 foreach type $Ltypes tnom $Ntypes { set NConsDansId 0 set NConsDansCo 0 set NId 0 set NCo 0 set rep2 [LanceLesCalculs $type $grp] update if {$rep2} { set tmp_TNConsId($type) $NConsDansId set tmp_TNConsCo($type) $NConsDansCo set tmp_TNId($type) $NId set tmp_TNCo($type) $NCo } else { set BonTousTypes 0 break } } if {$BonTousTypes} { incr LongTot $LongueurTotale incr NAli incr NResConsSA [set TNResConsSA($n)] incr NResConsNSA [set TNResConsNSA($n)] foreach type $Ltypes tnom $Ntypes { incr TNConsId($type) [set tmp_TNConsId($type)] incr TNConsCo($type) [set tmp_TNConsCo($type)] incr TNId($type) [set tmp_TNId($type)] incr TNCo($type) [set tmp_TNCo($type)] } } } file delete -force [file join $OrdTmpDir $n] FermeFichier puts "" puts "" #AfficheProfileResults } # Calcul Specificite et Sensibilite puts "" puts "" puts "=========================" puts "= R E S U L T A T S =" puts "=========================" puts "" puts "Nombre alignements ..............: $NAli" puts "Longueur totale .................: $LongTot" puts "Nombre residus site actif .......: $NResConsSA" puts "Nombre residus NON site actif ...: $NResConsNSA" puts "" set NResCons ${NResConsSA} foreach t $Ltypes tnom $Ntypes { # Sens = VraiPos/(VraiPos + FauxNeg) # Spec = VraiNeg/(VraiNeg + FauxPos) # VraiPos : Identi ET SA # FauxNeg : SA non vu (non identifie) # VraiNeg : lg - sa - colo cons qui sont pas sites # FauxNeg : Sa qui ne sont pas dans une col de cons if {$t == 7} {continue} set NConsId "[set TNConsId($t)]." set NId "[set TNId($t)]." # Pour Identite set sensId [expr {1.*$NConsId/$NResCons}] set specId [expr {1.*($LongTot - $NId - ($NResCons - $NConsId))/(($LongTot - $NId - ($NResCons - $NConsId))+($NId - $NConsId))}] set SumSensSpecId [expr {($sensId + $specId) - 1.0}] # Pour Global (Identite+Cons) set NTt [expr {$NId + [set TNCo($t)]}] set NConsTt [expr {$NConsId + [set TNConsCo($t)]}] set sensTt [expr {$NConsTt/$NResCons}] set specTt [expr {1.*($LongTot - $NTt - ($NResCons - $NConsTt))/(($LongTot - $NTt - ($NResCons - $NConsTt))+($NTt - $NConsTt))}] set SumSensSpecTt [expr {($sensTt + $specTt) - 1.0}] # CalculSensibiliteSpecificite $NConsId [expr {$NId-$NConsId}] [expr {$LongTot - $NId}] puts "" puts "type $tnom :" puts "--------------" puts "Nombre residus Identite........... : $NId" puts "Nombre residus Ident+Cons .........: $NTt" puts "Nombre residus SA typifie Iden ....: $NConsId" puts "Nbr resi SA typifie Iden+Cons .....: $NConsTt" set fmt "%s %5.3f" puts "" puts [format $fmt "\tsensibilite Identite ......:" $sensId] puts [format $fmt "\tspecificite Identite ......:" $specId] puts [format $fmt "\tSomme sens+spec Identite...:" $SumSensSpecId] puts [format $fmt "\tsensibilite totale ........:" $sensTt] puts [format $fmt "\tspecificite totale ........:" $specTt] puts [format $fmt "\tSomme sens+spec totale ....:" $SumSensSpecTt] puts "" puts "" } exit } proc TestCodeOrga {} { foreach OX [WIW ListOf OX] { } } proc TestCodonStartEtDeletionDuMSF {FichierMSF {QueFaire AfficheToujours} {Nom ""} {ADN ""}} { global RepertoireDuGenome global PositionUltimeDuCodonStart Wup "It works for stand alone FichierMSF ... then it needs Nom (name of Query) and ADN (its ADN sequence)" if { ! [info exists PositionUltimeDuCodonStart]} { set PositionUltimeDuCodonStart 400 } if {[YaPABenDebutDe $FichierMSF]} { set FichierMSF "$RepertoireDuGenome/msf/$FichierMSF" } if {[regexp {^TROU[0-9]+[A-F]$} $FichierMSF]} { set FichierMSF "$RepertoireDuGenome/trousclustalw/$FichierMSF" } if { ! [file exists $FichierMSF]} { return "Clustalw inexistant" } set PL [PremiereLigneDuFichier $FichierMSF] if {[regexp "Clustalw inutile" $PL] || [regexp "NoSequence" $PL]} { return "Clustalw inutile" } if {$ADN==""} { set Nom [file tail $FichierMSF] set NomOuADN $Nom set Calculate "" } else { set Nom $Nom set NomOuADN [string toupper $ADN] set Calculate "ToCalculate" } set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences] Espionne "$FichierMSF $NombreDeSequences" if {$NombreDeSequences < 2} { return "No other sequence available" } if {[regexp "/Ms" [RepertoireDuGenome]] && [OuiOuNonMemo "Do I take all sequences in one cluster"]} { set LesSequencesDuGroupe $LesSequencesDansLOrdre } else { set LesSequencesDuGroupe [LesAccessDuGroupe $FichierMSF $Nom $LesSequencesDansLOrdre $Calculate] Espionne $LesSequencesDuGroupe } if {[llength $LesSequencesDuGroupe] > 1} { set LesSequencesDansLOrdre $LesSequencesDuGroupe } set LesRetenues {} foreach NomSeq $LesSequencesDansLOrdre { if {[EstUnAccessPDB $NomSeq]} { continue } lappend LesRetenues $NomSeq } if {[llength $LesRetenues] < 2} { return "Not enough sequence available" } set LesSequencesDansLOrdre $LesRetenues foreach NomSeq $LesSequencesDansLOrdre { Espionne "NS $NomSeq" set Seq [string toupper [set Sequences($NomSeq)]] if {[regexp "TROU" $Seq]} { set cDebut [string range [string trim $Seq "."] 0 0] set Debut($NomSeq) [string first $cDebut $Seq] } else { set iM [string first "M" "$Seq M"] set iL [string first "L" "$Seq L"] set iV [string first "V" "$Seq V"] set Debut($NomSeq) [Mini $iM [Mini $iL $iV]] } set cFin [string range [string trim $Seq "."] end end] set Fin($NomSeq) [string last $cFin $Seq] } foreach NomSeq $LesSequencesDansLOrdre { set BeauAccess [format "%-12s" $NomSeq] lappend LaPage "$BeauAccess [set Sequences($NomSeq)]" } set Page [join $LaPage "\n"] set Remarque "" set YaMieux 0 set LesCandidats {} if { ! [info exists Sequences($Nom)]} { return "" } set dPAB [set Debut($Nom)] set sPAB [string toupper [set Sequences($Nom)]] set TailleDuGroupe 0 foreach NomSeq $LesSequencesDansLOrdre { if {$NomSeq==$Nom} { continue } Espionne $NomSeq incr TailleDuGroupe set dAutre [set Debut($NomSeq)] if { $dPAB > $dAutre } { continue } set LesTouches {} foreach Ecart {-1 0 1} { if { $dPAB > [expr $dAutre+$Ecart] } { continue } if {[regexp -nocase {[MLV]} [string index $sPAB [expr $dAutre+$Ecart]] Start] } { lappend LesTouches [expr $dAutre+$Ecart] $Ecart } } if {$LesTouches=={}} { continue } foreach {Touche Ecart} $LesTouches { if { ! [YaCodonStartEnPosition $Touche $sPAB $NomOuADN]} { continue } if { $Ecart != 0 && [YaCodonStartEnPosition [expr $Touche-$Ecart]]} { continue } set Zone [string range $sPAB $dPAB $Touche] regsub -all -nocase {[^A-Z]} $Zone "" Zone set Position [expr [string length $Zone]] set Start [string index $Zone end] if {$Position>$PositionUltimeDuCodonStart} { break } lappend LesCandidats "$Position $Start $NomSeq" incr YaMieux 1 } } if { $LesCandidats != {} } { set LesCandidats [lsort -command CompareLesIntegersEnDebut $LesCandidats] set OldPosition -1 set Remarque "\n=CodonStart: GroupSize $TailleDuGroupe $NombreDeSequences" foreach PMS $LesCandidats { scan $PMS "%d %s %s" Position Start Nomseq if {$Position != $OldPosition} { append Remarque " $Start $Position $Nomseq" } else { append Remarque "/$Nomseq" } set OldPosition $Position } } set StartNom [string range $sPAB $dPAB $dPAB] set iNom [lsearch -exact $LesSequencesDansLOrdre $Nom] foreach NomSeq [lrange $LesSequencesDansLOrdre [expr $iNom-4] [expr $iNom+4]] { if {[string equal -nocase $NomSeq [Narcisse $Nom]]} { continue } lappend ListeDesDebuts [set Debut($NomSeq)] lappend ListeDesFins [set Fin($NomSeq)] } set ListeDesDebutsTries [lsort -decreasing -integer $ListeDesDebuts] set Prems [lindex $ListeDesDebutsTries 0] if {[llength $ListeDesDebutsTries]>1} { set Deuss [lindex $ListeDesDebutsTries 1] } else { set Deuss $Prems } set Derns [lindex $ListeDesDebutsTries end] set Manque [expr ($Prems-$Deuss)] set MaxManque [expr ($Prems-$Derns)] if { [expr $Manque > 10] && [set Debut($Nom)] == $Prems } { set DebutADN [Box $Nom debut] set FinADN [Box $Nom fin] set Orient [Box $Nom orient] if { $Orient == "F" } { set DebutBlastX [expr $DebutADN-($MaxManque*3)] set FinBlastX [expr $DebutADN-1] set EstLance [BlastXdeADN $Nom $DebutBlastX $FinBlastX] set EstLanceAligne3P [Aligne3PdeADN $Nom "Changer" $DebutBlastX $FinBlastX "Laisser" $DebutADN $FinADN $Orient] } else { set DebutBlastX [expr $FinADN+1] set FinBlastX [expr $FinADN+($MaxManque*3)] set EstLance [BlastXdeADN $Nom $DebutBlastX $FinBlastX] set EstLanceAligne3P [Aligne3PdeADN $Nom "Changer" $DebutBlastX $FinBlastX "Laisser" $DebutADN $FinADN $Orient] } incr YaMieux 10 append Remarque "\n=DeletedStart: je crois deviner une erreur de sequence, il manque au moins $Manque AA. BlastX $EstLance." } set ListeDesFinsTries [lsort -increasing -integer $ListeDesFins] set Prems [lindex $ListeDesFinsTries 0] if {[llength $ListeDesDebutsTries]>1} { set Deuss [lindex $ListeDesDebutsTries 1] } else { set Deuss $Prems } set Derns [lindex $ListeDesFinsTries end] set Manque [expr ($Deuss-$Prems)] set MaxManque [expr ($Derns-$Prems)] Warne "$Nom [set Fin($Nom)] $Prems $Deuss $Manque" if { [expr $Manque > 10] && [set Fin($Nom)] == $Prems } { set DebutADN [Box $Nom debut] set FinADN [Box $Nom fin] set Orient [Box $Nom orient] if { $Orient == "R" } { set DebutBlastX [expr $DebutADN-($MaxManque*3)] set FinBlastX [expr $DebutADN-1] set EstLance [BlastXdeADN $Nom $DebutBlastX $FinBlastX] set EstLanceAligne3P [Aligne3PdeADN $Nom "Laisser" $DebutADN $FinADN "Changer" $DebutBlastX $FinBlastX $Orient] } else { set DebutBlastX [expr $FinADN+1] set FinBlastX [expr $FinADN+($MaxManque*3)] set EstLance [BlastXdeADN $Nom $DebutBlastX $FinBlastX] set EstLanceAligne3P [Aligne3PdeADN $Nom "Laisser" $DebutADN $FinADN "Changer" $DebutBlastX $FinBlastX $Orient] } incr YaMieux 100 append Remarque "\n=DeletedStop: je crois deviner une erreur de sequence, il manque au moins $Manque AA. BlastX $EstLance." } if { $QueFaire == "RetourneRemarque"} { return $Remarque } Espionne "Remarque $YaMieux\n$Remarque" if { $QueFaire == "TestPourTous" && $YaMieux > 0 } { Informe $Nom $Remarque return } if { $QueFaire == "AfficheToujours" || $QueFaire == "AfficheSilFaut" && $YaMieux > 0 } { if { ! $YaMieux } { set Remarque "\n=CodonStart: GroupSize $TailleDuGroupe $NombreDeSequences $StartNom 1" } set Fenetre [AfficheVariable "$Page$Remarque" "AvecCorrInfoGrandeLargeur" $Nom ] if {[info exists LesCandidats]} { Illumine $Nom $Fenetre foreach Candidat $LesCandidats { scan $Candidat "%d %s %s" Position Start NomSeq Illumine $NomSeq $Fenetre } } return $Fenetre } } proc TestCodonStartEtDeletionDuMSFPourTous {{CommenceAvec ""}} { global NePlusFaireBlastX global NePlusFaireAligne3P global InformeSansDemander global RepertoireDuGenome set NePlusFaireBlastX 1 set NePlusFaireAligne3P 1 set InformeSansDemander 1 set EtudieMSFPourTous 1 set OnAttend 0 if {$CommenceAvec!=""} { set OnAttend 1 } foreach Nom [ListeDesPABs] { if {$OnAttend && $Nom!=$CommenceAvec} { continue } set OnAttend 0 TestCodonStartEtDeletionDuMSF $Nom "TestPourTous" } set InformeSansDemander 0 CreeStartCodonSummary "Replace" } proc TestConcatLesTFAs {} { # set Selection "EST:[StringSuivant "EST:" dans [ContenuDuFichier ~/sele]]" set Selection [ContenuDuFichier "[HomeRipp]/SelectionBOX006.txt"] return [ConcatLesTFAs $Selection] } proc TestCorrectionPourThrombin {Fi} { return [CorrectionPourThrombin [LesLignesDuFichier $Fi] $Fi zz] } proc TestCoupeMainChain {type Lca {Lcol ""} {Lc ""} {Lo ""}} { if {$type eq "Protein"} { # CA - CA : en gros 4.3 A -> Thr 6. set dst 36. } else { # P - P : en gros 5.5 A -> Thr 8 set dst 64. } set Li 0 set i 0 set p0 [lindex $Lca 0] foreach p [lrange $Lca 1 end] { lassign $p0 a b c d lassign $p x y z w if {($a-$x)**2 + ($b-$y)**2 + ($c-$z)**2 > $dst} { lappend li $i } set p0 $p incr i } lappend Li [expr {[llength $Lca]-1}] set i0 0 set Lres [list] foreach i [lrange $Li 1 end] { set rca [lrange $Lca $i0 $i] if {$Lcol != {}} { set rcol [lrange $Lcol $i0 $i] } else { lappend Lres $rca continue } if {$Lc != {}} { set rc [lrange $Lc $i0 $i] set ro [lrange $Lo $i0 $i] lappend Lres [list $rca $rcol $rc $ro] } else { lappend Lres [list $rca $rcol] } set i0 [expr {$i+1}] } return $Lres if {[llength $Li] == 2} { return [list $Lres] } else { return $Lres } } proc TestCreeLaListeLesCopains {} { } proc TestCrmMapper {} { # set A [BirdSendQueryUrlAndGetFromUrl {select TXSTART from ucscmouse.refgene where chrom='chr11' and 77696429<=txStart and strand='+' order by TXSTART fetch first 1 rows only} {} format=flat] # Espionne "$A" set B [BirdSendQueryUrlAndGetFromUrl {select NAME, TXSTART, TXEND, STRAND from ucscmouse.refgene where chrom='chr11' and 77747137=txStart and strand='+' order by TXEND} {} format=plat] Espionne "$B" } proc TestDataSet {} { global DataSet set A [DataSet create AAA] set B [DataSet create BBB] set C [DataSet create CCC] DataSet father $B $A DataSet linksappend $A $C DataSet spyAll $A set Z [DataSet clone $A] DataSet updateFather $Z foreach X [concat [list $A $B $C $Z] [DataSet links $Z]] { DataSet spyAll $X } exit Grave DataSet exit } proc TestDecortiqueBlast {{Nom ""}} { global RepertoireDuGenome global ListeDesPABs if { $Nom == "" } { ChargeListeDeBoites set Liste $ListeDesPABs } else { set Liste [list $Nom] } foreach Nom $Liste { set FichierBlastP "$RepertoireDuGenome/blastp/$Nom" set lPartieSegAli {} # DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN SegAli $lPartieSegAli { # puts "$BanqueId $Access $DE $Profil $PN \n$SegAli" puts "$BanqueId $Access $DE" } continue set FichierBlast "$RepertoireDuGenome/blastngenembl/$Nom" if { ! [file exists $FichierBlast]} { continue } DecortiqueBlast $FichierBlast 0.001 5 Query lBanqueId lAccess lDE lProfil lPN foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN { Espionne "$Nom $BanqueId $Access $DE $Profil $PN" set LeEMBL [LaSequenceDesBanques $BanqueId $Access a "OnVeutNucEMBL"] if {$LeEMBL=={}} { } else { EspionneL $LeEMBL break } } Espionne "" continue set FichierBallast "$RepertoireDuGenome/ballast/$Nom" if { ! [file exists $FichierBallast]} { continue } set FichierBlastP "$RepertoireDuGenome/blastp/$Nom" DecortiqueBlast $FichierBallast "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN { puts "$BanqueId $Access $DE $Profil $PN" } DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN { puts "$BanqueId $Access $DE $Profil $PN" } } exit } proc TestDecortiqueBlat {Fichier} { set LesHits [DecortiqueBlat $Fichier] foreach LeHit $LesHits { ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct] Espionne "$Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand" } } proc TestDecortiqueEMBL {{Fichier ""}} { if {$Fichier==""} { set Fichier "./essai.embl" } set LL [LaSequenceDesBanques $Fichier] DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX SequenceBrute LaDETotal EspionneL [list $ID $AC $DE $GN $OS $OC $OX $LaDETotal] Espionne $SequenceBrute exit } proc TestDecortiqueGenScan {} { set X [DecortiqueGenScan All All Numbers [ContenuDuFichier "IT0002.gsc"]] Espionne $X Espionne [DecortiqueGenScan 1 All Gauche] Espionne [DecortiqueGenScan 1 All Droite] foreach N [DecortiqueGenScan 1 All Numbers] { Espionne [DecortiqueGenScan 1 $N Begin] Espionne [DecortiqueGenScan 1 $N End] } exit } proc TestDecortiqueUnMSF {FichierMSF} { DecortiqueUnMSF $FichierMSF LesNoms Sequences foreach NomSeq $LesNoms { set Seq $Sequences($NomSeq) regsub -all {\.} $Seq "" Lettres Espionne "$NomSeq [string length $Seq] [string length $Lettres]" Espionne $Seq } exit } proc TestDecortiqueUnMacsimXml {{Quoi ""}} { global Voir_dans_MacsimsVariables LesDefauts set FichierOuTexteXML "/genomics/link/CilioCarta2014/macsimXml/CIL006" set MacsimsVariables [DecortiqueUnMacsimXml $FichierOuTexteXML] lassign $MacsimsVariables LesL LesT if {[array exists ::$Quoi]} { parray ::$Quoi } else { EspionneL [set ::$Quoi] } foreach T $LesT { # parray ::$T } return $MacsimsVariables } proc TestDecortiqueUnRSF {} { set n [DecortiqueUnRSF "/genomics/link/CilioCarta2014/macsimRsf/CIL006" LesName Sequences TabRSF "" "AvecBornesLocales"] foreach Name $LesName { Espionne "name $Name [set TabRSF($Name,group)]" set LesTypes [set TabRSF($Name,LesTypesDeFeatures)] foreach Type $LesTypes { Espionne "\nPour $Name : Type $Type" EspionneL [set TabRSF($Name,Type,$Type)] } } Espionne $TabRSF($Name,LesClefs) exit } proc TestDefDesDomaine {CodeGscope} { set compt 1 set ListeDesDomaines {} set LdomaineName {} set fichierMSF [RepertoireDuGenome]/msf/$CodeGscope set fichierMacsim [RepertoireDuGenome]/macsimXml/$CodeGscope set annotation [FromMacsims "$fichierMacsim" "$CodeGscope" "ConcatPfam"] foreach pfam $annotation { Espionne "---> pafm: $pfam" scan $pfam "%s %s %s %s" pfamName complement from position if {[regexp {^PROP_(.*)} $pfamName a p]} { set pfamName $p } set pos [split [lindex [split $position "/"] 1] "-"] set start [lindex $pos 0] set end [lindex $pos 1] #Espionne "Pfam: $pfamName; start: $start; END: $end" #Espionne "Pfam: $pfamName" #definir la position absolue set start [DansAlignementPositionAbsolue $start $CodeGscope $fichierMSF] set end [DansAlignementPositionAbsolue $end $CodeGscope $fichierMSF] if {$LdomaineName==""} { lappend LdomaineName $pfamName lappend ListeDesDomaines "$pfamName $start $end" } else { set value [lsearch -exact $LdomaineName $pfamName] Espionne "value: $value" if {$value==-1} { #Espionne "$pfamName" lappend LdomaineName $pfamName lappend ListeDesDomaines "$pfamName $start $end" } else { append pfamName "_$compt" #Espionne "pfamName: $pfamName" lappend LdomaineName $pfamName lappend ListeDesDomaines "$pfamName $start $end" incr compt } } } return $ListeDesDomaines } proc TestDefinitionPartagee {} { foreach Nom [ListeDesPABs] { if {[EstUnPABMute $Nom]} { continue } set Fichier "[RepertoireDuGenome]/blastp/$Nom" DecortiqueBlast $Fichier 0.001 80 Query lBId lA lDE lProfil lPN DefinitionPartagee $lDE $Fichier } } proc TestDesdomaine {CodeGscope} { set ListeDesDomaines [TestDefDesDomaine $CodeGscope] foreach domaine $ListeDesDomaines { #Espionne "domaine: $domaine" scan $domaine "%s %s %s" pfam start end #Espionne "pfam: $pfam; start: $start; end: $end" set PosDebAbsolueSeqRef 0 set PosFinAbsolueSeqRef 0 PositionRelativeSeqCibleParRapportSeqRef $pfam $CodeGscope $start $end } } proc TestDialogPort {} { Espionne [DialogPort] Espionne [DialogPort] Espionne [DialogPort GetFirst] Espionne [DialogPort New] Espionne [DialogPort GetAll] Espionne [DialogPort 21109] Espionne [DialogPort New] Espionne [DialogPort GetAll] Espionne [DialogPort] } proc TestDict2Json {} { set D [Json] source "[HomeRipp]/Desktop/exp_json.tcl" return [::json::dict2json $D] } proc TestEE {} { set Meilleur [lindex [LesAccessEMBLDesLignesEMBL [LaSequenceDesBanques syd_ecoli syd_ecoli AccessOK "OnVeutEMBL"]] 2] set LeGenBank [LaSequenceDesBanques $Meilleur $Meilleur AccessOK "OnVeutNature"] EspionneL [DecortiqueGenBank OS OC SeqADN $LeGenBank] exit } proc TestEstCeVraimentUneNouvelleSequence {{NP ""}} { set TFA [ContenuDuFichier [GscopeFile PGS001 $NP]] # append TFA "ATGATGATAG" regsub {>[^ ]+} $TFA ">AR" TFA Espionne [EstCeVraimentUneNouvelleSequence $TFA $NP] } proc TestExec {} { # CanalSqlString # CanalSqlDisconnect return [exec which tcsh] exec tcsh -c "cd /home/luudao/tmp/ ; tar -cf - String_9606_201109201940 | gzip -9 > String_9606_201109201940.tgz " } proc TestExtractPartsFromEMBL {} { Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 0 2] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 3 3] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 2 3] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26224 26224] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26225 26225] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26224] Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26225] exit } proc TestFiches {} { Wup "Test le repertoire /fiches similarite sizedescriptif sizemsf codonstartpossible codonstoppossible" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test /fiches------" if {[file exists "$RepertoireDuGenome/fiches"] &&[file isdirectory "$RepertoireDuGenome/fiches"]} { set Reponse " $RepertoireDuGenome/fiches\t\t\t exists" lappend CheckResultat $Reponse if {[file exists "$RepertoireDuGenome/fiches/similarite"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/similarite\t exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/similarite\t copy it" } if {[file exists "$RepertoireDuGenome/fiches/sizedescriptif"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/sizedescriptif \t exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/sizedescriptif \tcopy it" } if {[file exists "$RepertoireDuGenome/fiches/sizemsf"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/sizemsf\t\t exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/sizemsf\t\tcopy it" } if {[file exists "$RepertoireDuGenome/fiches/codonstartpossible"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/codonstartpossible exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/codonstartpossible copy it" } if {[file exists "$RepertoireDuGenome/fiches/codonstoppossible/"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/codonstoppossible exists" } else { lappend CheckResultat "No $RepertoireDuGenome/fiches/codonstoppossible copy it" } } else { set Reponse "Create $RepertoireDuGenome/fiches \(mkdir fiches\)" lappend CheckResultat $Reponse } } proc TestFormatQuery {} { set Query [::http::formatQuery A B "Donnees" "Bonjour Madame il fait beau et 2+2=4"] Espionne $Query Espionne [TexteAscii $Query] exit } proc TestFrappeQuUnCoup {} { Espionne [set Moi [FrappeQuUnCoup "AskWhereToBegin" "set"]] Espionne [FrappeQuUnCoup PGS015 $Moi] Espionne [FrappeQuUnCoup PGS111 $Moi] Espionne [FrappeQuUnCoup PGS018 $Moi] } proc TestFromMacsim {} { Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU] FromMacsim UnsetAll Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU] FromMacsim CIL007 unset Espionne [FromMacsim CIL007 Sequences G1PUE7_MYOLU] } proc TestFusionneLesGenscan {A B TailleTroncon} { set LeGscA [LesLignesDuFichier $A] set LeGscB [LesLignesDuFichier $B] EspionneL [FusionneLesGenscan $LeGscA $LeGscB $TailleTroncon] exit } proc TestGenoretProteomicsLinks {} { set Nom EVI00520 foreach Ref [GenoretProteomicsLinks $Nom "Ref"] { Espionne $Ref EspionneL [GenoretProteomicsLinks "$Nom$Ref" "Columns"] } exit } proc TestGlossaire {} { Glossaire Reset Glossaire exit } proc TestGraphe {{Fichier ""}} { set LaListeDesTags [list [list a] [list b] [list c] [list d] [list e] [list f] [list g] [list h]] set K [Graphe {1 3 4 5 6 3 4 2} {3 4 2 1 3 4 4 5} "" "blue" 800 600 {} "" "Beau titre" $LaListeDesTags] set G {1 3 2 5 2 3 2 2} # Graphe $G "Regulier" $K "red" "" "" {400 400 500 550} # Graphe [list 0 [llength $G]] [list [MiniDeLaListe $G] [MiniDeLaListe $G]] $K "red" "" "" {400 400 500 550} $K create text 400 400 -text Coucou MainLeveeSurUnCanva $K set K2 [Graphe {1 3 4 5 6 3 4 2} {3 4 2 1 3 4 4 5} "" "blue" 800 600 {} "" "K2" $LaListeDesTags] Espionne [GraphesEnStock] } proc TestGscopeCroises {} { EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP {} Court"] EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY1969 BlastP {} Court"] EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353333 BlastP {} Court"] EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2354 BlastP"] EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"] EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"] } proc TestHdac {} { set LesEnzymes [list BamHI BglII EcoRI NcoI NdeI NruI] foreach Fichier [lsort -dictionary [glob "[RepertoireDuGenome]/atelier/hdac/hdac*.tfa"]] { set ProtTfa [NucToProtTFA [ContenuDuFichier $Fichier]] set L [string length [QueLaSequenceDuTexteTFA $ProtTfa]] regsub ".tfa$" $Fichier .prottfa FichierProt Sauve $ProtTfa dans $FichierProt set Hits [CheckRestrictionEnzymes $Fichier $LesEnzymes "" "GetHits"] lappend LaSortie $Hits lappend LaSortie "[expr 3*$L] bases $L AA" lappend LaSortie " " } set Sortie [join $LaSortie "\n"] return [AfficheVariable $Sortie] } proc TestHttpCopy {} { HttpCopy "http://hgdownload.cse.ucsc.edu/goldenPath/currentGenomes" LesLignes EspionneL $LesLignes exit } proc TestInfoEmbl {} { set Access "P12345" Espionne [InfoEmbl $Access SQ] Espionne [InfoEmbl $Access Delete] exit } proc TestInterrogeAffy_UCSC {} { set Chr [InterrogeAffy_UCSC "" human 1552481_s_at Chromosome] set LesDebuts [InterrogeAffy_UCSC "" human 1552481_s_at $Chr Debut] Espionne "--------------------------------------------" Espionne "Chr $Chr -- LesDebuts $LesDebuts" } proc TestInterrogeSeq {} { Espionne "1 [InterrogeSeq REFSEQPREL:NP_001116571 Tfa]" Espionne "2 [InterrogeSeq REFSEQPREL:NP_001116571 Seq]" Espionne "3 [InterrogeSeq ENSECAP00000014430 Seq]" } proc TestIt {} { set Name [Iterator New "Init" {a b c} {1 2 3}] Espionne "name=$Name" Espionne [Iterator $Name Get Total Iter] while {[Iterator $Name "Next" A N]} { Espionne "$A $N" } Iterator $Name Reset while {[Iterator $Name "Next" A N]} { Espionne "$A $N" } set Name [Iterator New "Init" {A B C D} {1 2 3}] Espionne "Iterator New Init {A B C D} {1 2 3} = $Name" Espionne "while {\[Iterator $Name Next A N\]} { Espionne \$A \$N }" while {[Iterator $Name "Next" A N]} { Espionne "$A $N" } Espionne "Iterator $Name Reset" Iterator $Name Reset while {[Iterator $Name "Next" A N]} { Espionne "$A $N" if {$A=="C" && $N==2} { Espionne "break pour C et 2"; break } } Espionne "Iterator $Name Get Current All = [Iterator $Name Get Current All]" Espionne "Iterator $Name Get Current 2 = [Iterator $Name Get Current 2]" Espionne "Iterator $Name Get Current 0 = [Iterator $Name Get Current 0]" Espionne "Iterator Iterator Get ListOf Name = [Iterator Iterator Get ListOf Name]" exit } proc TestLKI {} { set Texte [ContenuDuFichier "[RepertoireDuGenome]/protemblRecupere/EVI03681"] LesKeywordsInteressantsDuGenbank $Texte T LOCUS DEFINITION SOURCE FEATURES Espionne $T(DEFINITION) Espionne $T(SOURCE) Espionne $T(FEATURES) } proc TestLODB {fileBlast} { set fileBlast "/genomics/link/CilioCarta/blastp/HSAP00001" set fileBlast "/home/kress/elephas.blastp" set blast [ContenuDuFichier $fileBlast] set B64 [Base64Encode $blast] # set orgas [QuestionDeScience EVImm "ret TaxonomyDuBlast $B64 - - GetText"] set orgas [TaxonomyDuBlast $B64 KeepAll - GetText] Espionne $orgas } proc TestLSDT {} { foreach Access [LaSequenceDuTFAs toto.tfa "LaListeDesAccess"] { set Seq [LaSequenceDuTFAs toto.tfa $Access] Espionne " .................$Access\n[SequenceFormatTFA $Seq]" } exit } proc TestLaProteineADesVariants {} { global MesAccessInterressants set Liste [ListeDesPABs] set MesAcc "" foreach PAB $Liste { set AccProt "" set Id "" set AccProt [AccessDeLaBoite $PAB protein] if {$AccProt == $PAB} {continue} lappend MesAcc $AccProt continue } set MesAcc [lsort -unique $MesAcc] #Espionne $MesAcc Espionne "Les PABs [llength $MesAcc]" MesAccessInterressants set LesAcc [array names MesAccessInterressants] foreach Acc $LesAcc {lappend MesAcc $Acc} #Espionne $MesAcc set NbProt [llength $MesAcc] Espionne "Les acc en + $NbProt" set NbProtAvecV 0 set NbVariantTot 0 set NbSWAvecV 0 set SW 0 set NbSW 0 set NbSWVariantTot 0 foreach Acc $MesAcc { if {[EstUnAccessDeQuelleBanque $Acc swissprot]} { incr NbSW set SW 1 Espionne "SW $Acc" } set AdesV [LaProteineADesVariants $Acc Etat] if {$AdesV=="1"} { set NbVariant [LaProteineADesVariants $Acc NbVariant] if {$SW} {incr NbSWAvecV;incr NbSWVariantTot} incr NbProtAvecV incr NbVariantTot $NbVariant } else {set NbVariant 0} Espionne "$Acc\t$AdesV\t$NbVariant" #Espionne "[LesVariantsDeLaProteine $Acc Sequence]" set SW 0 } Espionne "NbProt $NbProt Avec Variant $NbProtAvecV" Espionne "Nb Variant total $NbVariantTot" Espionne "NbSw $NbSW avec variant $NbSWAvecV pour $NbSWVariantTot variants au total" } proc TestLaSequenceDesBanques {BanqueId {Access ""} {aAccessOK ""} {OnVeutEMBL ""} {NouveauPABCourant ""}} { set LaSeq [LaSequenceDesBanques $BanqueId $Access AccessOK $OnVeutEMBL $NouveauPABCourant] set R [concat $LaSeq [list "\n" $AccessOK]] return $R } proc TestLambdaIntegrase {} { set SeqPPCR [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/ppcr_virtuels/N1733"] set SeqSiteP [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/vecteurs/pDONR/pDONR207.tfa"] set LesBornes [LesBornesParLambdaIntegrase $SeqPPCR $SeqSiteP [SEQAttB1] [SEQAttB2]] Espionne $LesBornes exit } proc TestLambdaIntegrase2 {} { set SeqRec1 [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/rec1/N1733_pDONR207"] set SeqPDest [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/vecteurs/pDEST/pDEST17.tfa"] set LesBornes [LesBornesParLambdaIntegrase $SeqRec1 $SeqPDest [SEQAttL1] [SEQAttL2]] Espionne $LesBornes exit } proc TestLeDesignREFSEQ {} { Wup "Tester les design qui sont pourris" set Dir "[RepertoireDuGenome]/Probes/RefSeq_TFA" set LesQuerys [glob -nocomplain -directory $Dir "NM*"] set WDir "[RepertoireDuGenome]/Probes/RefSeq_Design" #set LesQuerys "[RepertoireDuGenome]/Probes/RefSeq_TFA/NM002026" set LesRepPourris "" foreach Q $LesQuerys { set L "" set Q [file tail $Q] set LeRep [LeRepertoireDeRefSeq $Q] #set File "$WDir/$LeRep/$Q.oligo" set File "$WDir/$LeRep/$Q.log" #Espionne "$Q $File" if {! [file exists $File]} {continue} #set L [EnteteDuFichierTFA $File] set L [LesLignesDuFichier $File] set toto "No Hit found during DataBase searches" if {[regexp "NoHitFound" $L]} { set Nb [regexp -all "NoHitFound" $L] if {$Nb > 10} { lappend LesRepPourris $LeRep lappend LesFilePourris $Q #file delete -force "$WDir/$LeRep/$Q.log" #file delete -force "$WDir/$LeRep/$Q.oligo" #file delete -force "$WDir/$LeRep/$Q.selection" } else { continue } } } set LesRepPourris [lsort -unique $LesRepPourris] set LesFilePourris [lsort -unique $LesFilePourris] Espionne "[llength $LesRepPourris] $LesRepPourris" Espionne "[llength $LesFilePourris] $LesFilePourris" } proc TestLego {} { ScanLaListe [Seq3dAndA5From 1oxa_20.mod] Seq3d LesA5 Espionne "$Seq3d \n$LesA5" set GappedSeq3d [Entre $Seq3d] set GappedSeqAA [GappedSeqAAFromGappedSeq3d $GappedSeq3d $LesA5 $Seq3d] Espionne $GappedSeq3d Espionne $GappedSeqAA exit } proc TestLesAbsentsBestProtAndmRNA {} { set Liste [lrange [ListeDesPABs] 1164 end] set Nbfrag 0 set Nbfragetnomrna 0 set Nomrna 0 foreach PAB $Liste { set AccProt [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] #set TailleProt [InterrogeBestProteinAndmRNAForeachOrga Access $AccProt Taille] set DefProt [InterrogeBestProteinAndmRNAForeachOrga Access $AccProt Definition] set AccmRNA [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" mRNA Access] #set TaillemRNA [InterrogeBestProteinAndmRNAForeachOrga Access $AccmRNA Taille] set DefmRNA [InterrogeBestProteinAndmRNAForeachOrga Access $AccmRNA Definition] if {[regexp -nocase "fragment" $DefProt]} { incr Nbfrag if {$AccmRNA!=""} { Espionne "$PAB AccProt $AccProt $DefProt AccmRNA $AccmRNA $DefmRNA" } } if {$AccmRNA==""} { incr Nomrna if {[regexp -nocase "fragment" $DefProt]} { incr Nbfragetnomrna #Espionne "$PAB AccProt $AccProt $DefProt AccmRNA $AccmRNA $DefmRNA" } #Espionne "$PAB no mrna" } } Espionne "Norna $Nomrna -- NoRNAAndFrag $Nbfragetnomrna -- Nbfrag $Nbfrag" } proc TestLesBestProtAndmRNA {} { set Liste [ListeDesPABs] foreach PAB $Liste { set AccmRNA [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" mRNA Access] set TaillemRNA [InterrogeBestProteinAndmRNAForeachOrga Access $AccmRNA Taille] set AccProt [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] set TailleProt [InterrogeBestProteinAndmRNAForeachOrga Access $AccProt Taille] if {$TaillemRNA=="" || $TailleProt==""} {continue} if {$TaillemRNA>$TailleProt} {continue} else { Espionne "$PAB AccmRNA $AccmRNA $TaillemRNA AccProt $AccProt $TailleProt" } } } proc TestLesDescriptifs {} { global RepertoireDuGenome foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/lesdescriptifs"] { ScanLaListe [split $Ligne "="] AC Reste # Espionne "[ChampDuDescriptif [LeDescriptif $AC] OS] # [ChampDuDescriptif [LeDescriptif $AC] OX]" # continue ScanLaListe [split $Ligne " "] Bidon OSGenre Espece regsub "OS\:" $OSGenre "" Genre set Organisme "$Genre $Espece" Espionne [time {Getz $AC}] Espionne [time {set OS [QuestionDeScience QuidSeq "QuidOSOfAC $AC"]}] regsub {^[ \n]|[ \n]$} $OS "" OS if {$OS==$Organisme} { Espionne "$Organisme $AC" } else { Espionne "$Organisme $AC >$OS< +++++++++++++++++" } } } proc TestLesJumeauxProts {} { set LesPABs [lrange [ListeDesPABs] 0 1165] set LesPABs "" set Fichier "[RepertoireDuGenome]/ListeDesPABsDesOligosCommandes.txt" set F [open "$Fichier"] while {[gets $F Ligne]>=0} { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} set PAB "" scan $Ligne "%s" PAB if {$PAB==""} {continue} lappend LesPABs $PAB } close $F foreach PAB $LesPABs { set Acc [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] if {$Acc==""} {continue} #Espionne "$PAB $Acc" lappend LesAccessProt $Acc } set LesPAB2s [lrange [ListeDesPABs] 0 1165] foreach PAB $LesPAB2s { set Acc [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" Protein Access] if {$Acc==""} {continue} if {[regexp -nocase $Acc $LesAccessProt]} {continue} set JR [JumeauRepresentatif $PAB] if {$JR != $PAB} { if {[regexp -nocase $JR $LesPABs]} {continue} if {[regexp -nocase $JR $LesPAB2s]} {continue} } Espionne "$PAB $Acc" lappend LesAccessProt2 $Acc } Espionne "[llength $LesAccessProt]" Espionne "[llength [lsort -unique $LesAccessProt]]" Espionne "[llength $LesAccessProt2]" Espionne "[llength [lsort -unique $LesAccessProt2]]" return "" } proc TestLesNotes {} { Wup "Test les notes" global RepertoireDuGenome global CheckResultat if {[file exists "$RepertoireDuGenome/notes"] &&[file isdirectory "$RepertoireDuGenome/notes"]} { set Reponse " $RepertoireDuGenome/notes exists" if {[glob -nocomplain "$RepertoireDuGenome/notes/*"]=={}} { append Reponse " but you should run CreeToutesLesNotes" lappend CheckResultat $Reponse } else { append Reponse " and CreeToutesLesNotes done" lappend CheckResultat $Reponse } } else { set Reponse "Create $RepertoireDuGenome/notes, run CreeToutesLesNotes" lappend CheckResultat $Reponse } } proc TestLesOligoExcel {} { #set Liste [lrange [ListeDesPABs] 0 1164] #set Liste [lrange [ListeDesPABs] 1164 end] #set Liste [list ACT0022 ACT0004] #set Liste [list ACT0073 ACT0200 ACT0213 ACT0235 ACT0274 ACT0309 ACT0377 ACT0390 ACT0408 ACT0445 ACT0453 ACT0456 ACT0467 ACT0537 ACT0618 ACT0662 ACT0669 ACT0670 ACT0698 ACT0744 ACT0746 ACT0746 ACT0780 ACT0783 ACT0830 ACT0846 ACT0849 ACT0850 ACT0852 ACT0855 ACT0985 ACT1059 ACT1086] set Liste [ListeDesRhos] LesOligosPourExcel "$Liste" "[RepertoireDuGenome]/Probes/RefSeq_Rho" "[RepertoireDuGenome]/Probes/Unigene_Rho" "" "[RepertoireDuGenome]/Essai_OligoPourExcel_Rho" #LesOligosPourExcel "$Liste" "[RepertoireDuGenome]/Probes/RefSeqBLAST3" "[RepertoireDuGenome]/Probes/UnigeneBLAST3" "" "" #LesOligosPourExcel "$Liste" "[RepertoireDuGenome]/Probes/RefSeqBLAST3" "[RepertoireDuGenome]/Probes/UnigeneBLAST3" "" "[RepertoireDuGenome]/Essai_AvecNewListeACT1164" #LesOligosPourExcel "ACT0001 ACT2291 ACT1618 ACT1247 ACT1524 ACT1323" "[RepertoireDuGenome]/Probes/TEST_RefSeq" "[RepertoireDuGenome]/Probes/TEST_Unigene" "" "" #LesOligosPourExcel "LaVraieTotale" "[RepertoireDuGenome]/Probes/RefSeqBLAST3" "[RepertoireDuGenome]/Probes/UnigeneBLAST3" "" "" #set Liste [lrange [ListeDesPABs] 0 1164] #set Liste [lrange [ListeDesPABs] 1164 end] #LesOligosPourExcel "$Liste" "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" "[RepertoireDuGenome]/Probes/NewUnigeneBLAST3" "" "" #LesOligosPourExcel "$Liste" "[RepertoireDuGenome]/Probes/NewRefSeqBLAST3" "[RepertoireDuGenome]/Probes/NewUnigeneBLAST3" "" "[RepertoireDuGenome]/Essai_AvecNewListeACT2436" return "" } proc TestLesTrous {} { Wup "Test les trous" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test Trous et Notes------" if {[file exists "$RepertoireDuGenome/fiches/bornesdestrous"]} { lappend CheckResultat " TrousLaTotale done" } else { lappend CheckResultat "Create les trous, run TrousLaTotale" } } proc TestLienDbclustalw {} { Wup "Test LiensdeDbclustalW" global RepertoireDuGenome global CheckResultat if {[file exists "$RepertoireDuGenome/dbclustalw"]} { set Reponse " $RepertoireDuGenome/dbclustalw exists" if {[file type "$RepertoireDuGenome/dbclustalw" ]=="link" && [file readlink "$RepertoireDuGenome/dbclustalw"]=="msf"} { append Reponse " and linked to msf" lappend CheckResultat $Reponse } else { append Reponse " but not linked to msf" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/dbclustalw create dbclustalw linked to $RepertoireDuGenome/msf" lappend CheckResultat $Reponse } } proc TestLiens {} { Wup "Test les liens pouvant exister" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test des Important Links------" if {[file exists "$RepertoireDuGenome/banques"]} { set Reponse " $RepertoireDuGenome/banques exists" if {[file type "$RepertoireDuGenome/banques" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/banques"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/banques create it if necessary" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/fiches/familiar_organism"]} { set Reponse " $RepertoireDuGenome/fiches/familiar_organism exists" if {[file type "$RepertoireDuGenome/fiches/familiar_organism" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/fiches/familiar_organism"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/fiches/familiar_organism create it if necessary" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/fiches/lesgenomescomplets"]} { set Reponse " $RepertoireDuGenome/fiches/lesgenomescomplets exists" if {[file type "$RepertoireDuGenome/fiches/lesgenomescomplets" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/fiches/lesgenomescomplets"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/fiches/lesgenomescomplets create it if necessary" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/stockgenscan"]} { set Reponse " $RepertoireDuGenome/stockgenscan exists" if {[file type "$RepertoireDuGenome/stockgenscan" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/stockgenscan"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/stockgenscan create link to /genomics/common/stockgenscan (for ex.)" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/stockcontigs"]} { set Reponse " $RepertoireDuGenome/stockcontigs exists" if {[file type "$RepertoireDuGenome/stockcontigs" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/stockcontigs"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/stockcontigs create link to /genomics/common/stockcontigs (for ex.)" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/blastn"]} { set Reponse " $RepertoireDuGenome/blastn exists" if {[file type "$RepertoireDuGenome/blastn" ]=="link"} { set Link [file readlink "$RepertoireDuGenome/blastn"] append Reponse " and linked to $Link" lappend CheckResultat $Reponse } else { append Reponse " and is not a Link" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/blastn create link to $RepertoireDuGenome/blastnhuman (for ex.)" lappend CheckResultat $Reponse } } proc TestLiensDiabac {} { Wup "Test les Liens specifiques a Diabac" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test des Important Links in DiaBac------" if {[file exists "$RepertoireDuGenome/banques"]} { set Reponse " $RepertoireDuGenome/banques exists" if {[file type "$RepertoireDuGenome/banques" ]=="link" && [file readlink "$RepertoireDuGenome/banques"]=="../DiaBac/banques"} { append Reponse " and linked to /genomics/DiaBac/banques" lappend CheckResultat $Reponse } else { append Reponse " and not linked to /genomics/DiaBac/banques" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/banques create link to ../../DiaBac/banques" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/fiches/familiar_organism"]} { set Reponse " $RepertoireDuGenome/fiches/familiar_organism exists" if {[file type "$RepertoireDuGenome/fiches/familiar_organism" ]=="link" && [file readlink "$RepertoireDuGenome/fiches/familiar_organism"]=="../../DiaBac/fiches/familiar_organism"} { append Reponse " and linked to familiar_organism" lappend CheckResultat $Reponse } else { append Reponse " and not linked to familiar_organism" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/fiches/familiar_organism create link to ../../DiaBac/fiches/familiar_organism" lappend CheckResultat $Reponse } if {[file exists "$RepertoireDuGenome/fiches/lesgenomescomplets"]} { set Reponse " $RepertoireDuGenome/fiches/lesgenomescomplets exists" if {[file type "$RepertoireDuGenome/fiches/lesgenomescomplets" ]=="link" && [file readlink "$RepertoireDuGenome/fiches/lesgenomescomplets"]=="../../DiaBac/fiches/lesgenomescomplets"} { append Reponse " and linked to lesgenomescomplets " lappend CheckResultat $Reponse } else { append Reponse " and not linked to lesgenomescomplets" lappend CheckResultat $Reponse } } else { set Reponse "No $RepertoireDuGenome/fiches/lesgenomescomplets create link to ../../DiaBac/fiches/lesgenomescomplets" lappend CheckResultat $Reponse } } proc TestLiensGenomesOuCollection {} { if {[OnTraiteUnGenome]} { TestLiensDiabac } else { TestLiens } } proc TestListMix {} { set A [list 1 2 3 4 5 6 7 8 9] set B [list 2 4 6 8] set C [list 3 6] Espionne [MixLists $A No $C In $B] } proc TestListTranspose {} { set LL {{a b c} {d e} {g h i k}} EspionneL $LL EspionneL [ListTranspose $LL] return [ListTranspose $LL] } proc TestLocAfter {} { set Var [LocAfter 77696429 Mouse chr11 +] Espionne $Var } proc TestLocalisationDesVirtualPPCRs {} { set Loc [LocalisationDesVirtualPPCRs GetLocOf N1733] scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo Espionne "$NLu $DPLu $FPLu $DNLu $FNLu" set Loc [LocalisationDesVirtualPPCRs GetLocOf N1732] scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo Espionne "$NLu $DPLu $FPLu $DNLu $FNLu" exit } proc TestLong {} { set A "abcefdyeyf" set B "abcdxcef" puts [expr [Long $A $B [expr [string length $A]-1] [expr [string length $B]-1]]+1] exit } proc TestLsortMultipleIndex {} { set lt [list "9003 90041 John_Doe HSeL" "9003 90040 Vernor_Vinge DJu" "0009 98000 Gerard_Majax HSeE" "9999 00001 Man_SuperMan HseE"] foreach elmt $lt { Espionne $elmt } set lt [lsort -index 1 $lt] Espionne "1ere" Espionne $lt set lt [lsort -index 0 $lt] Espionne "2eme" EspionneL $lt } proc TestMDScore {} { foreach Nom [ListeDesPABs] { set MD [MDScore $Nom] set Couleur [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "CouleurMerci"]] set Signif [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "SignificationMerci"]] Espionne "$Nom $MD $Couleur $Signif" } } proc TestMSFDeDomaine {CodeGscope} { set RepertoireDeDomaines "[RepertoireDuGenome]/PDBParDomaine/$CodeGscope" Espionne $RepertoireDeDomaines set r [glob -directory $RepertoireDeDomaines *] foreach fichier $r { set fichierTmpMsf [RunDbClustal $r "" "GetMsfFilename"] Espionne "file rename -force $fichierTmpMsf $r.msf" file rename -force $fichierTmpMsf $r.msf } } proc TestMSP {} { set YaCons 0 set LesStart {} foreach Ligne [LesLignesDuFichier "[HomeRipp]/msp/data/alignments/dcethal1.txt"] { if {$YaCons && [regexp {([0-9]+)} $Ligne Match Start]} { lappend LesStart $Start set YaCons 0 continue } if {[regexp {Cons\-T80} $Ligne]} { set YaCons 1 ; continue } } set LesStart [lsort -integer $LesStart] Espionne $LesStart exit } proc TestM_lMM {} { set A [M_unit] set B [M_unit] puts [Nice_M $A] set C [M_lMM 2 $A * 3 $B] return [Nice_M $C] } proc TestMacsimsAcOrga {} { # test si tous les .org ont bien ete cres foreach FichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsimXml/*"] { if {[regexp ".org" $FichierMacsim]} { continue } if {[file exists $FichierMacsim.org]} { continue } Espionne "doitcreer le .org de $FichierMacsim" } } proc TestMacsimsInfo {} { global MacsimsInfo MacsimsInfo LoadXml "/genomics/link/SpliRet/macsimXml/SP0001" parray MacsimsInfo exit EspionneL [MacsimsInfo ListOf Key1] Espionne "=================================" EspionneL [MacsimsInfo ListOf FeaturesKeys] foreach Access [MacsimsInfo Noms] { Espionne "$Access [MacsimsInfo $Access Features]" } } proc TestMacsimsOnWeb {} { set Msf [ContenuDuFichier [GscopeFile PGS779 "msf"]] set Xml [MacsimsOnWeb $Msf] return $Xml } proc TestMafft {{file ""}} { global OrdTmpDir NousAllonsAuBoulot puts "[OuSuisJe]" set repmsf [file join [RepertoireDuGenome] "msf_mounir"] set reptfa [file join [RepertoireDuGenome] "tfasdescopains_mounir"] set LesFiles $file if {$file == ""} {set LesFiles [ListeDesPABs]} foreach f $LesFiles { if {! [file exists [file join $reptfa $f]]} {continue} if {! [file exists [file join $repmsf $f]]} {continue} file copy -force [file join $reptfa $f] $f set nseq [LitLeTFA $f nom seq] catch {exec mafft --quiet $f > maout.tfa} {Message} exec clustalw -infile=maout.tfa -outfile=maout.msf -convert -output=gscope set normMafft [exec normd maout.msf pam250.bla 0.0 0.1] exec rascal maout.msf maras.msf set normRas 0.0001 if {[file exists maras.msf]} { set normRas [exec normd maras.msf pam250.bla 0.0 0.1] } file copy -force [file join $repmsf $f] $f set normClustal [exec normd $f pam250.bla 0.0 0.1] puts "$f\t$nseq\t$normMafft\t$normRas\t$normClustal" file delete -force $f maout.msf maout.tfa maras.msf unset nom seq } exit return } proc TestMath3D {} { set V [V_unit 1 3 4.8] set Angle [AngleRad 30 degres] set R [R_create $Angle $V] puts R puts [Nice_R $R] set M [M_R $R] puts [Nice_M $M "m"] set R [R_M $M] puts [Nice_R $R] set M [M_R $R] puts [Nice_M $M "mr de R"] set IM [M_invM $M] puts [Nice_M $IM "inv de mr"] set I [M_MM $M * $IM] puts [Nice_M $I "mr*inv"] set R [R_M $IM] puts [Nice_R $R] set A [list [list 2 3 4] [list 5 6 7]] set B [list [list 2 3 4 5] [list 5 6 7 8] [list 2 2 2 2]] set C [M_MM $A * $B] puts [Nice_M $A A] puts [Nice_M $B B] puts [Nice_M $C AB] exit } proc TestMeilleuresDefinitions2_0 {{LesPABs ""} {MotsOuExprCreux ""} {MotsOuExprInterdits ""} {ratioScores 0.80}} { set fichierOut "[RepertoireDuGenome]/fiches/TestMeilleuresDefs2" #if {$LesPABs eq ""} {set LesPABs [ListeDesPABs]} if {$LesPABs eq ""} {set LesPABs [MorceauxChoisis [ListeDesPABs]]} foreach pab $LesPABs { set fichierMacsims "[RepertoireDuGenome]/macsims/$pab.xml" if {[file isfile $fichierMacsims]} { Espionne $pab ParseMACSIMS $fichierMacsims macsims set groupe $macsims(Groupe,$macsims($pab,Groupe)) set posQuery [lsearch -exact $groupe $pab] set groupeSansQuery [lreplace $groupe $posQuery $posQuery] AppendAuFichier $fichierOut "$pab [MeilleuresDefinitions2_0 $groupeSansQuery $MotsOuExprCreux $MotsOuExprInterdits $ratioScores]" } } } proc TestMemoDelta {} { MemoDelta a b x MemoDelta a b y MemoDelta a b z Espionne [MemoDelta a b] Espionne [MemoDelta a r] MemoDelta Reset MemoDelta a b y MemoDelta a b z Espionne [MemoDelta a b] Espionne [MemoDelta a r] } proc TestMonCopain {} { foreach IndexA [RetChip2 ListOf Index] { if {[set IndexB [MonCopain Nouveau $IndexA]]==""} { Espionne "$IndexA [RetChip2 $IndexA description_customer]" continue } set VA [RetChip2 $IndexA WholeLine] set VB [RetChip3 $IndexB WholeLine] set LesMots [split $VB ";"] set LesMots [concat [lrange $LesMots 0 6] [list ""] [lrange $LesMots 8 end]] set VB [join $LesMots ";"] if {[string first $VA $VB]==0} { continue } Espionne "$IndexA $IndexB\n$VA\n$VB\n" } exit } proc TestMoyenneRank {} { set LesClades [OlymStock ListOf Clade] # set LesClades [list Deuterostomia Fungi] foreach Nom [ListeDesPABs] { foreach Clade $LesClades { set M [OlymStock $Nom $Clade-MoyenneRank] Espionne "$Nom $M $Clade" } } } proc TestMsf {} { Wup "Test du repertoire msf et TestAnalyseDbClustal TestLienDbclustalw" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test Msf------" if {[file exists "$RepertoireDuGenome/msf"] &&[file isdirectory "$RepertoireDuGenome/msf"]} { set Reponse " $RepertoireDuGenome/msf exists" if {[glob -nocomplain "$RepertoireDuGenome/msf/*"]=={}} { append Reponse ", you should run DbClustalPourTous" lappend CheckResultat $Reponse } else { append Reponse " and DbClustalPourTous done" lappend CheckResultat $Reponse TestAnalyseDbClustal } TestLienDbclustalw } else { set Reponse "Create $RepertoireDuGenome/msf \(mkdir msf\)" lappend CheckResultat $Reponse } } 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 TestNCBINames {} { set Fichier "./names.dmp" set f [open $Fichier "r"] set nTaxId 0 # set iMaxPourTest 999 set iMaxPourTest -1 while {[gets $f Ligne]>=0} { if {[incr iMaxPourTest -1]%1000==0} { Espionne $Ligne } if {[incr iMaxPourTest -1] == 0} { break } regsub -all "\t" $Ligne "" Ligne set LesChamps [split $Ligne "|"] ScanLaListe $LesChamps TaxId Name UniqueName NameClass if {$TaxId=="1890940"} { Espionne $Ligne } if {[info exists DejaVu($Name)]} { lappend LesDoublons $Name } set DejaVu($Name) 1 TaxNCBI $TaxId TaxId "=$TaxId" TaxNCBI $TaxId ItsNames "=$Name" if {$UniqueName!=""} { TaxNCBI $TaxId UniqueName "=$UniqueName" TaxNCBI $Name ItsTaxIds "=$TaxId" } TaxNCBI $Name TaxId "=$TaxId" TaxNCBI $Name NameClass "=$NameClass" if {[string equal -nocase $NameClass "scientific name"]} { incr nTaxId TaxNCBI $TaxId Name "=$Name" } TaxNCBI "ListOf" "Names" "=$Name" } } proc TestNW {sr su} { lassign [NW $sr $su] sra sua ShowProtDiff sra sua exit } proc TestNewAndOldUnigene {} { set LesPABs [ListeDesPABs] set FichierOut "[RepertoireDuGenome]/Essai_Compare_NewAndOld_Unigene" set Result "Gscope_Access\tOLD_Uniseq\tOLD_Unigene\tNEW_Uniseq\tNEW_Unigene\tOLD_Definition\tNEW_Definition" AppendAuFichier $FichierOut "$Result" foreach PAB $LesPABs { if {$PAB==""} {continue} set Result "" set DirOligo2 "[RepertoireDuGenome]/Probes/UnigeneBLAST3" set OtherDirOligo2 "[RepertoireDuGenome]/Probes/NewUnigeneBLAST3" if {![file exists "$DirOligo2/${PAB}.masked"]} { set DirOligo2 $OtherDirOligo2 } #Access Unigene ############### set BestBanque [ReturnBestHitFromLogFile $PAB $DirOligo2] set Definition [ReturnDefinitionFromBestHitFromLogFile $BestBanque] set BestBanqueUg [LeUnigeneDeUniseq $BestBanque] set Definition1 [ReturnDefinitionFromBestHitFromLogFile $BestBanque] set NewBestBanque [InterrogeLesAccessUnigeneDesPABs $PAB UniseqId] set NewBestBanqueUg [InterrogeLesAccessUnigeneDesPABs $PAB UnigeneId] set Definition2 [ReturnDefinitionFromBestHitFromLogFile $NewBestBanque] #On essaie avec les nouveaux blastn Unigene if {$BestBanqueUg==""} { set BestBanqueUg "No Unigene Id associated" } if {$NewBestBanqueUg==""} { set NewBestBanqueUg "No Unigene Id associated" } set Result "$PAB\t$BestBanque\t$BestBanqueUg\t$NewBestBanque\t$NewBestBanqueUg\t$Definition1\t$Definition2" AppendAuFichier $FichierOut "$Result" } } proc TestNewVirtualPPCR {} { set PPCR "GFP-1-239 +++ AttB1 XhoI +++ XhoI AttB2" AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFaire Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"] Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"] exit } proc TestNucExtension5PrimeDeRec2 {FiRec2} { set TFA [SequenceFormatTFA [NucExtension5PrimeDeRec2 $FiRec2] "fusion" "nucbrut"] Espionne [Sauve $TFA dans "testfusion.tfa"] } proc TestNucProtTFAEMBL {} { Wup "Test le presence de NucTFA NucEMBL ProtTFA ProtEMBL" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test TFA et EMBL------" if { ![file exists "$RepertoireDuGenome/nuctfa"] || [glob -nocomplain "$RepertoireDuGenome/nuctfa/*"]=={}} { lappend CheckResultat "No $RepertoireDuGenome/nuctfa, run CompleteLaDataBase" } else { lappend CheckResultat " $RepertoireDuGenome/nuctfa exists" } if { ![file exists "$RepertoireDuGenome/prottfa"] || [glob -nocomplain "$RepertoireDuGenome/prottfa/*"]=={}} { lappend CheckResultat "No $RepertoireDuGenome/prottfa, run CompleteLaDataBase" } else { lappend CheckResultat " $RepertoireDuGenome/prottfa exists" } if { ![file exists "$RepertoireDuGenome/nucembl"] || [glob -nocomplain "$RepertoireDuGenome/nucembl/*"]=={}} { lappend CheckResultat "No $RepertoireDuGenome/nucembl, run CompleteLaDataBase" } else { lappend CheckResultat " $RepertoireDuGenome/nucembl exists" } if { ![file exists "$RepertoireDuGenome/protembl"] || [glob -nocomplain "$RepertoireDuGenome/protembl/*"]=={}} { lappend CheckResultat "No $RepertoireDuGenome/protembl, run CompleteLaDataBase" } else { lappend CheckResultat " $RepertoireDuGenome/protembl exists" } } proc TestOO {args} { source "[GscopeDir]/gscope_oo.tcl" return [eval $args] } proc TestOXOC {} { foreach Nom [ListeDesPABs] { set X [ExtraitInfo $Nom "Organism"] set C [ExtraitInfo $Nom "Taxonomy"] Espionne "$Nom $X $C" if {[regexp "sapiens" $X] && ! [regexp "sapiens" $C]} { FaireLire $Nom } if {! [regexp "sapiens" $X] && [regexp "sapiens" $C]} { FaireLire $Nom } } exit } proc TestOnto {} { Espionne [QuestionDeScience Ontology "ret Onto GO:0003674 Type"] Espionne [QuestionDeScience Ontology "ret Onto GO:0003674 Type"] exit Espionne [QuestionDeScience Ontology "ret ListeDesPABs"] Espionne [QuestionDeScience Ontology "ret ListeDesPABs"] exit } proc TestOr {} { LesDefauts Espionne $::Defauts(PrefixesBank) exit } proc TestOrgaDuDescriptif {Nom1 Nom2} { global RepertoireDuGenome foreach Nom [list $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2] { Espionne $Nom set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom" set LesAccess {} foreach Ligne [LesLignesDuFichier $FichierDescriptif] { ScanLaListe [split $Ligne "="] Access lappend LesAccess $Access Espionne $Access } set O [LesOrgasDesAccess $LesAccess Court $Nom] } exit } proc TestPCRAlvi {} { foreach Ligne [LesLignesDuFichier "[Fiches]/OligosF.csv"] LigneR [LesLignesDuFichier "[Fiches]/OligosR.csv"] { ScanLaListe [split $Ligne ";"] OligoNameF OligoF Bidon1 Bidon2 Bidon3 NotesF regexp {BOX[0-9]+} $NotesF Nom ScanLaListe [split $LigneR ";"] OligoNameR OligoR Bidon1 Bidon2 Bidon3 NotesR set OligoRSens [NucToReverseAndComplementNuc $OligoR] Espionne $Ligne Espionne $LigneR if {[regexp "RunOff" $OligoNameR]} { set OligoR "" } set MF [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]] PCR $MF $OligoF $OligoR $Nom } exit } proc TestPDB {} { set Lpdbid [list 1c0a 1il2 1asy] source [HomeRipp]/oso.tcl SetupPDBObject foreach pdbid $Lpdbid { set file "/db/catalog/pdb/compressed_files/[string range $pdbid 1 2]/pdb${pdbid}.ent.gz" Structure create $pdbid set cok [$pdbid new $file "" 0 0] foreach c [$pdbid _chains] { puts "$pdbid" puts "$c [$pdbid _chainIs $c]" # set s [join [$pdbid _resname -chain A] ""] } } exit foreach pdbid $Lpdbid { Structure create $pdbid set Rep [string range $pdbid 1 2] set file "/db/catalog/pdb/compressed_files/[string range $pdbid 1 2]/pdb${pdbid}.ent.gz" set cok [$pdbid new $file "" 0 0] foreach c [$pdbid _chains] { Espionne "$pdbid chain $c is [$pdbid _chainIs $c]" Espionne "$pdbid chain $c is [$pdbid _chainIs $c]" # Espionne [$pdbid _resname -chain $c] } $pdbid destroy } exit } proc TestParseGOAnno {nomFichier} { ParseGOAnno $nomFichier goanno parray goanno } proc TestParseMACSIMS {nomFichier} { ParseMACSIMS $nomFichier macsims parray macsims } proc TestPasTouche {} { return [PasTouche Bidon12345] } proc TestPckFastme {aT} { upvar $aT T global auto_path lappend auto_path [file join home moumou fastme1.1] package require fastme set Ln [array names T] foreach e $Ln { set Le [join [split $e ,]] lappend Lnom {*}$Le } set Lnom [lsort -unique $Lnom] foreach n1 $Lnom { foreach n2 $Lnom { lassign [set T($n1,$n2)] pc l1 l2 lsl lappend Ldst [expr {1.-$pc}] } } set rep [fastme $Lnom $Ldst] puts $rep return } proc TestPcrProduct {} { set Oli5 [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/oligos/P2081.tfa"] set Oli3 [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/oligos/P2193.tfa"] set Seq [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/nuctfa/PGS990"] set R [QuestionDeScience "EVImm" "ret PcrProduct $Oli5 $Seq $Oli3 getfasta"] return $R return [PcrProduct $Oli5 $Seq $Oli3 "getfasta"] } proc TestPosPfam {{file ""}} { global LNOrdali LSOrdali Sequences PABCourant OrdTmpDir FichierTFA Defauts SDG NomSeqSel global NId NCo NTt NConsDansId NConsDansCo NConsDansTt TableScore LNorMD ConsRef Sequences global VariablesAuDepart TNResConsNSA TNResConsSA LongueurTotale LongTot set FichierTFA "" # LoadReferencePDB global ConsRef TNResConsSA TNResConsNSA source ConsPfam.txt LesDefauts set rep [file join /home moumou work moumou BenchPfam] if {$file ne ""} { set LesFiles [split $file ,] } else { set LesFiles [glob [file join $rep *]] } set NomSeqSel {} # Types de conservations a tester # Originaux : # set Ntypes [list Norm Surf Angle Thompson Delta Norm+Thompson Norm+Delta Thompson+Delta Norm+Thompson+Delta VolPol Al2Co Liu RPCA] # # to work #set iNtypes [list Norm Surf] #set iNtypes [list Norm Thompson VolPol Liu Liu2 RPCA Entrop1 Entrop2] set iNtypes [list Norm Thompson Ranganatan VolPol Liu Liu2 RPCA Entrop1 Entrop2] #set Ntypes [list Norm Surf Angle Surf2 Thompson Delta VolPol Liu RPCA Liu2 Liu+RPCA Norm+Liu Norm+Thompson+Liu] set iNtypes [list Entrop1 Entrop2 Entrop3 Entrop4 Entrop5 Entrop6] # # brute force: # Cree tous les couples set Ntypes $iNtypes if {0} { set i 1 foreach n1 [lrange $iNtypes 0 end-1] { foreach n2 [lrange $iNtypes $i end] { lappend Ntypes [list ${n1} $n2] } incr i } } set LongTot 0 foreach type $Ntypes { set TResSeeAsId($type) 0 set TResSeeAsCo($type) 0 set TResSeeAsTt($type) 0 set TResId($type) 0 set TResCo($type) 0 set TResTt($type) 0 } set VariablesAuDepart [info globals] LesDefauts TypeAli TFA LesDefauts Mode "Batch" set NAli 0 set NBenchId 0 set NBenchCo 0 set NBenchTt 0 # BOUCLE PRINCIPZLE foreach f [lsort $LesFiles] { set fic [file tail $f] if {$fic in {"PF00836"}} {continue} set FichierTFA $f LesDefauts FichierTFA $FichierTFA puts "===========" puts "| $fic |" puts "===========" DecortiqueUnTFA $f LNOrdali Sequences LongueurDeLAlignement foreach n $LNOrdali { lappend LSOrdali [set Sequences($n)] } # ::profiler::reset MetAJourGroupes set NSqs [llength $SDG(GroupeToutLeMonde)] set PABCourant $fic puts "NSeqs : $NSqs Lgt $LongueurTotale" if {$NSqs < 10} { puts "Less than 10 Sequences !!" FermeFichier continue } set grp "" foreach tnom $Ntypes { unset -nocomplain TableScore foreach t $tnom { ScoreDe$t $grp } set rep1 [VerificationAvantCalculs] if {! $rep1} { puts "Une des methode foireuse !!" puts "skip alignement\n" file delete -force [file join $OrdTmpDir $fic] set BonTousTypes 0 FermeFichier puts "" puts "" break } set BonTousTypes 1 set rep2 [LanceLesCalculs $tnom $grp 0 pfam] #puts "Score [join $tnom +] done ..." if {$rep2} { set tmp_TResSeeAsId($tnom) $NConsDansId set tmp_TResSeeAsCo($tnom) $NConsDansCo set tmp_TResSeeAsTt($tnom) $NConsDansTt set tmp_TResId($tnom) $NId set tmp_TResCo($tnom) $NCo set tmp_TResTt($tnom) $NTt } else { puts "fail for method $tnom" set BonTousTypes 0 break } } if {$BonTousTypes} { incr LongTot $LongueurTotale incr NAli incr NBenchId [set TNResConsSA($fic)] incr NBenchCo [set TNResConsNSA($fic)] foreach tnom $Ntypes { incr TResSeeAsId($tnom) [set tmp_TResSeeAsId($tnom)] incr TResSeeAsCo($tnom) [set tmp_TResSeeAsCo($tnom)] incr TResSeeAsTt($tnom) [set tmp_TResSeeAsTt($tnom)] incr TResId($tnom) [set tmp_TResId($tnom)] incr TResCo($tnom) [set tmp_TResCo($tnom)] incr TResTt($tnom) [set tmp_TResTt($tnom)] } } file delete -force [file join $OrdTmpDir $fic] FermeFichier puts "" puts "" #AfficheProfileResults } set NBenchTt [expr {$NBenchId + $NBenchCo}] # Calcul Specificite et Sensibilite puts "" puts "" puts "=========================" puts "= R E S U L T A T S =" puts "=========================" puts "" puts "Nombre alignements ..............: $NAli" puts "Longueur totale .................: $LongTot" puts "Nombre residus identites ........: $NBenchId" puts "Nombre residus conserves ........: $NBenchCo" puts "Nombre residus à identifier .....: $NBenchTt" puts "" foreach tnom $Ntypes { # Sens = VraiPos/(VraiPos + FauxNeg) # Spec = VraiNeg/(VraiNeg + FauxPos) # VraiPos : Identi ET SA # FauxPos : SA non vu (non identifie) # VraiNeg : lg - sa - colo cons qui sont pas sites # FauxNeg : Sa qui ne sont pas dans une col de cons set ResSeeAsId "[set TResSeeAsId($tnom)]." set ResId "[set TResId($tnom)]." set ResSeeAsCo "[set TResSeeAsCo($tnom)]." set ResCo "[set TResCo($tnom)]." set ResSeeAsTt "[set TResSeeAsTt($tnom)]." set ResTt "[set TResTt($tnom)]." # Pour Identite # -------- set sensId [expr {1.*$ResSeeAsId/$NBenchId}] set specId [expr {1.*($LongTot - $ResId - ($NBenchId - $ResSeeAsId))/(($LongTot - $ResId - ($NBenchId - $ResSeeAsId))+($ResId - $ResSeeAsId))}] set SumSensSpecId [expr {($sensId + $specId) - 1.0}] # Pour Conserve # -------- set sensCo [expr {1.*$ResSeeAsCo/$NBenchCo}] set specCo [expr {1.*($LongTot - $ResCo - ($NBenchCo - $ResSeeAsCo))/(($LongTot - $ResCo - ($NBenchCo - $ResSeeAsCo))+($ResCo - $ResSeeAsCo))}] set SumSensSpecCo [expr {($sensCo + $specCo) - 1.0}] # Pour Global (Identite+Cons) #set NConsTt [expr {$NConsId + $NConsCo}] set sensTt [expr {$ResSeeAsTt/$NBenchTt}] set specTt [expr {1.*($LongTot - $ResTt - ($NBenchTt - $ResSeeAsTt))/(($LongTot - $ResTt - ($NBenchTt - $ResSeeAsTt))+($ResTt - $ResSeeAsTt))}] set SumSensSpecTt [expr {($sensTt + $specTt) - 1.0}] puts "" puts "type [join $tnom +] :" puts "--------------" puts "Nombre residus vus Identite........... : $ResId" puts "Nombre residus vus Conserves ......... : $ResCo" puts "Nombre residus vus Iden+Cons ......... : $ResTt" puts "Nombre residus typifies Ident ........ : $ResSeeAsId" puts "Nombre residus typifies Cons ......... : $ResSeeAsCo" puts "Nombre residus typifies Iden+Cons .... : $ResSeeAsTt" set fmt "%s %5.3f" puts "" puts [format $fmt "\tsensibilite Identite ......:" $sensId] puts [format $fmt "\tspecificite Identite ......:" $specId] puts [format $fmt "\tSomme sens+spec Identite...:" $SumSensSpecId] puts [format $fmt "\tsensibilite Conserve ......:" $sensCo] puts [format $fmt "\tspecificite Conserve ......:" $specCo] puts [format $fmt "\tSomme sens+spec Conserve ..:" $SumSensSpecCo] puts [format $fmt "\tsensibilite totale ........:" $sensTt] puts [format $fmt "\tspecificite totale ........:" $specTt] puts [format $fmt "\tSomme sens+spec totale ....:" $SumSensSpecTt] puts "" puts "" set ResPF($tnom,sensId) $sensId set ResPF($tnom,specId) $specId set ResPF($tnom,sumId) $SumSensSpecId set ResPF($tnom,sensCo) $sensCo set ResPF($tnom,specCo) $specCo set ResPF($tnom,sumCo) $SumSensSpecCo set ResPF($tnom,sensTt) $sensTt set ResPF($tnom,specTt) $specTt set ResPF($tnom,sumTt) $SumSensSpecTt } puts "\n\n" foreach titre {"Sensibilite Identite" "Specificite Identite" "Sum Identite" "Sensibilite Conserve" "Specificite Conserve" "Sum Conserve" "Sensibilite Totale" "Specificite Totale" "Sum Totale"} cle {sensId specId sumId sensCo specCo sumCo sensTt specTt sumTt} { puts "$titre" set Lv [array names ResPF "*,$cle"] set Lr [list] foreach v $Lv { lassign [split $v ,] nom tmp set x [set ResPF($v)] lappend Lr [list $nom $x] } set Lr [lsort -real -index 1 $Lr] foreach v $Lr { lassign $v nom x puts [format "%15s %7.2f" [join $nom +] [expr {$x*100.}]] } puts "" } puts "\nTermine\n" #exit return } proc TestPost {} { set query [::http::formatQuery "ka" "va" "kb" "vb\navecNL" "kc" "vc"] set token [::http::geturl "http://ena/wscoperr?Zero&CaVa" -query $query] upvar #0 $token state set body $state(body) ::http::cleanup $token return $body } proc TestPostgreSQL {} { puts [package require Pgtcl] } proc TestQdsHitCounts {} { set RepertoireParent /genomics/link/GxData/GxUpload/HumanGeneAtlas/Study/Distances/String_9606_201212101651 set HitCounts [QuestionDeScience EVImm "ret HitCounts $RepertoireParent"] return $HitCounts } proc TestQsub {{GetWhat ""}} { set S "-b y pwd" set S "tcsh -c 'pwd; hostname; pwd; ls'" return [Qsub $S $GetWhat "" "" "" ""] } proc TestQueLePremierGCG {} { set GCG [ContenuDuFichier p12345.swissprot] Espionne [QueLePremierGCG "$GCG\n$GCG"] exit } proc TestQueSequenceFormatEMBL {} { Espionne [QueSequenceFormatEMBL " METKGYHSLPEGLDMERRWGQVSQAVERSSLGPTERTDENNYMEIVNVSC VSGAIPNNSTQGSSKEKQELLPCLQQDNNRPGILTSDIKTELESKELSAT VAESMGLYMDSVRDADYSYEQQNQQGSMSPAKIYQNVEQLVKFYKGNGHR PSTLSCVNTPLRSFMSDSGSSVNGGVMRAIVKSPIMCHEKSPSVCSPLNM TSSVCSPAGINSVSSTTASFGSFPVHSPITQGTPLTCSPNAENRGSRSHS PAHASNVGSPLSSPLSSMKSSISSPPSHCSVKSPVSSPNNVTLRSSVSSP ANINNSRCSVSSPSNTNNRSTLSSPAASTVGSICSPVNNAFSYTASGTSA GSSTLRDVVPSPDTQEKGAQEVPFPKTEEVESAISNGVTGQLNIVQYIKP EPDGAFSSSCLGGNSKINSDSSFSVPIKQESTKHSCSGTSFKGNPTVNPF" "" AvecReperes] } proc TestQuidSeq {} { set LesACOS [QuestionDeScience QuidSeq "QuidOSsOfACs P12345|P12345 "] regsub {[ \n]+$} $LesACOS "" LesACOS Espionne $LesACOS exit } proc TestRGS {Nom} { set LeGroupe [GroupeSecator $Nom $Nom "Out"] Espionne $LeGroupe Espionne [llength $LeGroupe] Espionne [RapportGroupeSecator $Nom] exit } proc TestRand {l} { set dl [expr {10*$l}] Init_C_Random for {set i 0} {$i < 10} {incr i} { lappend lc {*}[C_Random $l] # after 1000 } for {set i 0} {$i < $dl} {incr i} { lappend lt [expr {int(rand()*$l)}] } set lc [lsort -unique -integer $lc] set lt [lsort -unique -integer $lt] #puts "lc [llength $lc]" #puts "lt [llength $lt]" if {$lc != $lt} { #puts "diff dans lc et lt" #puts "[lor $lc $lt]" } #flush stdout #update idletasks exit return } proc TestRavi {} { package require tdom set MacsimXml [ContenuDuFichier "ra.xml"] set NoeudMacsim [[dom parse $MacsimXml] documentElement] Espionne $NoeudMacsim } proc TestReassembleLesTronconsGenscan {Contig TailleTroncon} { set LesTroncons [lsort [glob -nocomplain "toto*.gsc"]] Espionne [ReassembleLesTronconsGenscan $LesTroncons $TailleTroncon "fusion.gsc"] exit } proc TestRecombinaisonEtFusion {} { set LespD [list "[RepertoireDuGenome]/vecteurs/pet15b-FLAG-gcassette-frameA.tfa" "[RepertoireDuGenome]/vecteurs/pETG60A.tfa" "[RepertoireDuGenome]/vecteurs/pETG28c2.tfa" "[RepertoireDuGenome]/vecteurs/pDEST10.tfa" ] set LespD [ChoixDesPresents $LespD] set LesR1 [ChoixDesPresents [glob -nocomplain "[RepertoireDuGenome]/rec1/*.tfa"]] set LesFiFuN {} foreach R1 $LesR1 { set QR1 [file tail $R1] regsub ".tfa$" $QR1 "" QR1 foreach pD $LespD { Espionne "[file tail $R1] [file tail $pD]" set QpD [file tail $pD] regsub ".tfa$" $QpD "" QpD set D "[RepertoireDuGenome]/rec2/${QR1}_$QpD.tfa" if { ! [file exists $D]} { Espionne [Recombinaison $R1 $pD $D "" "Seconde"] } if { ! [file exists $D]} { Warne "$D\nwas not created. I'll skipp." ; continue } set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $D] if {$FiFuNP==""} { continue } scan $FiFuNP "%s" $FiFuN lappend LesFiFuN $FiFuN } } return $LesFiFuN } proc TestRepOrga {} { Wup "Test le repertoire du genome" global RepertoireDuGenome global CheckResultat if {[file exists "$RepertoireDuGenome"]} { lappend CheckResultat "The project exists" return 1 } else { lappend CheckResultat "No project \"$RepertoireDuGenome\" available" return 0 } } proc TestRetourne {} { set L {a b c d e f g} puts [join $L " "] puts [join [RetourneLaListe $L] " "] } proc TestRewriteXmlToXml {FichierSource {FichierDestin ""} {Doctype ""}} { package require tdom if {$Doctype==""} { set Doctype [DoctypeForMacsim] } if {$Doctype=="NoDoctype"} { set Doctype "" } if {$FichierDestin==""} { set FichierDestin $FichierSource } set AncienXML [ContenuDuFichier $FichierSource] set Doc [dom parse $AncienXML] set Root [$Doc documentElement] foreach Noeud [$Root selectNodes "//subgroup"] { set Valeur [$Noeud selectNodes "string(.)"] set Papa [$Noeud parentNode] set Nouveau [$Doc createElement "group"] $Nouveau appendChild [$Doc createTextNode $Valeur] $Papa replaceChild $Nouveau $Noeud } foreach Noeud [$Root selectNodes "//column-score"] { set Nouveau [$Doc createElement "colsco-type"] $Nouveau appendChild [$Doc createTextNode "int"] set Suivant [$Noeud selectNodes "colsco-data"] Espionne $Suivant $Noeud insertBefore $Nouveau $Suivant } set NouveauXml $Doctype append NouveauXml [$Root asXML -indent 1] regsub "" $NouveauXml "" NouveauXml regsub "" $NouveauXml "" NouveauXml if {$FichierDestin=="GetIt"} { return $NouveauXml } return [Sauve $NouveauXml dans $FichierDestin] } proc TestRowsOfCells {} { set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/AmdConsortium/FamLevel2OK.csv"] EspionneL [RowsOfCells $Texte] exit } proc TestSampleTOL {} { InitTaxDB LoadTkAndPackages ChangeTkOptions GUITaxInitialise #SampleTOL -ntaxa 200 -UserFile marie.id set Lt [LesLignesDuFichier marie.tax] #set Lt [LesLignesDuFichier tax.txt] set sLt [join $Lt ,] if {0} { exec ordali exe SampleTOL -fileOut tutu.html -ntaxa 212 -root 131567 -output terminal -addmodel 0 -modelsin 1 -userids $sLt >& logcmd exit } set addm 0 ; set modelsin 1 set ntaxa 212 set taxroot "131567" set useall "representative" set file "tol_exec.html" set others "-userids $sLt" #set others "" #set Cmd "setenv ORDALIEONWEB 1 ; setenv ORDALIDIR /home/moumou/ordali ; setenv PATH /home/moumou/ordali/bin ; setenv HOME /home/moumou/ ; ordali puts SampleTOL -ntaxa $ntaxa -root $taxroot -modelsin $modelsin -addmodel $addm -useorgs $useall -output terminal -fileOut $file $others" #exec tcsh -c $Cmd >& logSotol & #::profiler::reset eval SampleTOL -ntaxa $ntaxa -root $taxroot -modelsin $modelsin -addmodel $addm -useorgs $useall -fileOut $file $others #AfficheProfileResults #SampleTOL -fileOut tutu.html -ntaxa 20 -root 561 -output terminal -addmodel 0 -modelsin 1 -userids $sLt #SampleTOL -fileOut tutu.html -ntaxa 20 -root 561 -output terminal -addmodel 0 -modelsin 1 GUIViewSampleTOL return } proc TestScoreExe {fpfam Lmscore} { global Sequences LNOrdali LSOrdali ListeDesPiliersDuGroupe LNDG SDG TbScores ListeScore LongueurTotale ConsMeth # use executable -> exe or library -> lib set how "exe" #set how "lib" # lit le fichier DecortiqueUnTFA $fpfam LNOrdali Sequences set LongueurTotale [string length [set Sequences([lindex [array names Sequences] 0])]] if {"SanderSP" in $Lmscore || "Valdar" in $Lmscore} { set Lns [list] foreach n $LNOrdali { lappend Lns $n [set Sequences($n)] } set LPCI [CalculeLesPCIGenerique $Lns] } # calcule score set LNDG GroupeToutLeMonde set SDG(GroupeToutLeMonde) $LNOrdali CreeLesPiliers # prepare pour scores set TbScores(Lcols) $Lmscore if {[llength $Lmscore] > 1} { set Scale 1 } else { set Scale 0 } set Lthrgap [list 0.005 0.1 0.25 0.5 0.7] foreach pcgap $Lthrgap { LesDefauts PCThrGap $pcgap unset -nocomplain ListeScore array unset TbScores "Score,*" update foreach mscore $Lmscore { if {$mscore eq "SanderSP" || $mscore eq "Valdar"} { set sco [ScoreDe$mscore [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)] $LNOrdali $LPCI] } else { set sco [ScoreDe$mscore [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] } if {$Scale} { set sco [CentreData $sco -999.0] } set TbScores(Score,$mscore) $sco } CreeListeScore set Lori $ListeScore set LgS [llength $ListeScore] puts "\ngap ${pcgap}% $LgS" if {$LgS < 2} { # Probleme : nb cols < 2 puts "\nListeScore=0\n$Lmscore $pcgap $pfamid" continue } if {$how eq "exe"} { set o [file tempfile fdat] foreach l $Lori { puts $o [join $l \t] } close $o update idletasks catch {file copy $fdat [file tail $fdat]} } # pour chaque meth clustering foreach cm [list dpc mixturemodel secator] { set Lval $Lori # Fait clusters switch $cm { "dpc" { if {$how eq "lib"} { set Lgr [Tclcluspack $Lval -dt coordinates -cm kmeans -nbc dpc -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=kmeans -nbc=dpc -wc] } set lab dpc } "secator" { if {$how eq "lib"} { if {0} { set fout [open "fout_[thread::id]" w] foreach xval $Lval { puts $fout "{*}$xval" } close $fout } set Lgr [Tclcluspack $Lval -dt coordinates -cm hierar -nbc secator -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=hierar -nbc=secator -wc] } set lab secator } "mixturemodel" { if {$how eq "lib"} { set Lgr [Tclcluspack $Lval -dt coordinates -cm mm -nbc aic -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=mm -nbc=aic -wc] } set lab mm } } if {$how eq "exe"} { if {[catch {exec {*}$cmd >& cout.log} Msg]} { file copy $fdat plantage.dat puts "Pb Cluspack\n$Msg" puts "$cmd" puts "[ContenuDuFichier cout.log]" } # lit clusters if {[file exists "${fdat}.clu"]} { set Lres [TraiteResultatClustering "${fdat}.clu" ""] } else { puts "log cluspack :\n[ContenuDuFichier cout.log]" continue } file delete -force cout.log ${fdat}.clu } else { set Lres [TraiteResultatClusteringTcl $Lgr ""] } set Ltrouve [lindex $Lres 1] set res [list "'$lab'" $pcgap $Ltrouve $LgS] puts "-> $res" } if {$how eq "exe"} { file delete -force [file tail $fdat] $fdat } } exit } proc TestSelLuc {id} { set fileBlast [file join [RepertoireDuGenome] "blastp" $id] set fileCopain [file join [RepertoireDuGenome] "tfasdescopains_luc" $id] set fOut "/home/friedric/gscoperso/Final$id" set listeId {} if {[file exists $fileCopain]} { set li [LesLignesDuFichier $fileBlast] set line [LesLignesDuFichier $fileCopain] set f [open $fOut w] foreach l $line { if {[regexp ">" $l]} { set n [string range $l 9 15] lappend listeId $n } } foreach n $listeId { foreach ll $li { if {[regexp $n $ll]} { puts $f "$id $ll" break } } #eval exec "grep \"$n\" $file" } close $f } return 1 } proc TestSeriallistFromSerial {{F ""}} { if {$F!=""} { set Texte [ContenuDuFichier $F] } else { set Texte "a:4:{i:0;s:10:\"1415670_at\";i:1;s:6:\"270637\";i:2;s:10:\"1415672_at\";i:3;s:6:\"270639\";}" } # ArrayFromSerial $Texte A #parray A # exit set R [SeriallistFromSerial $Texte] return $R set A(coucou) 1 ArrayFromSerial $Texte A parray A exit } proc TestSetOptions {A B C D args} { set LesOptions [SetOptions $args] foreach Option $LesOptions { Espionne "$Option [set $Option]" } exit } proc TestSiProteine {Fichier} { Wup "Verifie si une sequence est proteique ou pas" set Sequence [QueLaSequenceDuFichierTFA $Fichier] if {[regexp -nocase {[^ATGCNXMKRSYWVHDB]} $Sequence]} {return "1"} else {return "-1"} } proc TestSignalsInside {LesPGS {LesSignaux ""}} { if {$LesSignaux==""} { set LesSignaux [list "NdeI" "BamHI"] } set LesHits {} foreach PGS $LesPGS { set FiNuc [GscopeFile $PGS "nuctfa"] foreach Signal $LesSignaux { set Pattern [Signal $Signal] set PosNPosA [PositionDuPatternDansFichierTFA $Pattern $FiNuc] if {$PosNPosA!="-1 -1"} { lappend LesHits "$PGS [Alias $PGS] $Signal $PosNPosA" } } } return $LesHits } proc TestSock {} { LogWscope "dans TestSock" return "Bonjour" } proc TestSocket {} { # set Reponse [QuestionDeScience] set SocketLBGS [socket lbgs.u-strasbg.fr 80] puts $SocketLBGS "GET /people/peoplealpha.php\n" gets $SocketLBGS Reponse puts $Reponse exit while {1} { Espionne [socket ouragan 20000] } exit Espionne [socket ouragan 20000] Espionne [catch {set Soso [socket ouragan 20001]} Message] Espionne $Soso Espionne $Message Espionne [socket ouragan 25000] Espionne [socket ouragan 25001] exit } proc TestSqlCilioCarta {{Quoi ""}} { CanalSqlCilioCarta # set R [SqlExec "select name from sqlite_master" $Quoi] set R [SqlExec "select * from prot where genename is not null limit 3" $Quoi] return $R } proc TestSqlInsert {} { CanalSqlMacsims set R [SqlInsertOnceRecordIntoTable macsims name salut ] Espionne $R } proc TestStack {} { puts [PushOnStack Bonjour] puts [PushOnStack Ca] puts [PushOnStack va] puts [IsEmptyStack] puts [PullFromStack] puts [ValFromStack] puts [ValFromStack] puts [ValFromStack] puts [PullFromStack] puts [PullFromStack] puts [PullFromStack] puts [PullFromStack] DestroyStack exit } proc TestStatNuc {} { Wup "Test Statistiques sur Nuc" global RepertoireDuGenome global CheckResultat if {[file exists "$RepertoireDuGenome"]&&[file isdirectory "$RepertoireDuGenome"]} { lappend CheckResultat "\n------Test des Statistiques------" if {![file exists "$RepertoireDuGenome/fiches/compositionenatgc"]} { lappend CheckResultat "No composition en ATGC, run CreeLeFichierCompositionEnATGC" } else { lappend CheckResultat "Ok for Composition en ATGC" } if {![file exists "$RepertoireDuGenome/fiches/spectregc"] || ![file exists "$RepertoireDuGenome/fiches/spectregcxy"] } { lappend CheckResultat "No SpectreGC, run CreeLesFichiersSpectreDesGC" } else { lappend CheckResultat "Ok for SpectreGC" } if {![file exists "$RepertoireDuGenome/fiches/sd_bons"] || ![file exists "$RepertoireDuGenome/fiches/sd_loin"] || ![file exists "$RepertoireDuGenome/fiches/sd_mets"] || ![file exists "$RepertoireDuGenome/fiches/sd_sans"] } { lappend CheckResultat "No ShineDalgarno, run CreeLesFichiersDesShineDalgarnoDesPABs" } else { lappend CheckResultat "Ok for ShineDalgarno" } if {[file exists "$RepertoireDuGenome/codonw"] &&[file isdirectory "$RepertoireDuGenome/codonw"]} { set Reponse " $RepertoireDuGenome/codonw exists" if {[glob -nocomplain "$RepertoireDuGenome/codonw/*"]=={}} { append Reponse " but codonw was not launched \(do setcodonw before\)" lappend CheckResultat $Reponse } else { append Reponse " and codonw done" lappend CheckResultat $Reponse } } else { lappend CheckResultat "Codonw was not launched \(do setcodonw before\)" } if {[file exists "$RepertoireDuGenome/trnadir"] &&[file isdirectory "$RepertoireDuGenome/trnadir"] } { set Reponse " $RepertoireDuGenome/trnadir exists" if {[glob -nocomplain "$RepertoireDuGenome/trnadir/*"]=={}} { append Reponse " but tRNAscan-SE was not launched \(do settrnascan before\)" lappend CheckResultat $Reponse } else { append Reponse " and tRNAscan done" lappend CheckResultat $Reponse } } else { lappend CheckResultat "tRNAscan-SE was not launched \(do settrnascan before\)" } if {[file exists "$RepertoireDuGenome/fiches/coglimmer"]} { lappend CheckResultat " $RepertoireDuGenome/fiches/coglimmer exists so Glimmer done" } else { lappend CheckResultat "Glimmer \(compare to existing\) was not launched \(do setglimmer before\)" } } } proc TestStudent {} { Student "a b c d e" "x y z" } proc TestTBlastN {} { Wup "Test TblastN et TestAnalyseTBlastN" global RepertoireDuGenome global CheckResultat lappend CheckResultat "\n------Test tBlastN genome------" if {[file exists "$RepertoireDuGenome/tblastngenomes"]} { set Reponse " $RepertoireDuGenome/tblastngenomes exists" if {[glob -nocomplain "$RepertoireDuGenome/tblastngenomes/*"]=={}} { append Reponse " but you should run TBlastNPourTous" lappend CheckResultat $Reponse } else { append Reponse " and TBlastNPourTous done" lappend CheckResultat $Reponse TestAnalyseTBlastN } } else { set Reponse "Create $RepertoireDuGenome/tblastngenomes, run TBlastNPourTous" lappend CheckResultat $Reponse } } proc TestTDomSurSpineAnnotation {} { package require tdom # package require tnc set FichierXml "[HomeRipp]/spine/public/xml/macsim.xml" set XML [ContenuDuFichier $FichierXml] set Id [dom parse $XML] set Root [$Id documentElement] set NoeudAli [$Root selectNodes "alignment"] set AlnName [$NoeudAli selectNodes "string(aln-name)"] Espionne $AlnName foreach Noeud [$NoeudAli selectNodes "sequence"] { set SeqName [$Noeud selectNodes "string(seq-name)"] Espionne "$SeqName" } exit } proc TestTDomSurSpineTarget {} { package require tdom set FichierXml "[HomeRipp]/spine/public/xml/Tpetit.xml" set XML [ContenuDuFichier $FichierXml] set Id [dom parse $XML] set Root [$Id documentElement] set LesNoeudsTarget [$Root selectNodes {//target[//target/status/@access='PUBLIC']}] foreach NoeudTarget $LesNoeudsTarget { set ID [$NoeudTarget selectNodes "string(ID)"] set NoeudStatus [$NoeudTarget selectNodes "status"] set Task [$NoeudStatus selectNodes "string(task)"] set Lab [$NoeudStatus selectNodes "string(lab)"] Espionne "$ID $Task $Lab" } exit } proc TestTailleEtTmPourLeDesignDesOligos {LesPABs {LesTailles ""} {LesTemperatures ""} {Ecart ""} {FichierSortie ""}} { Wup "Affiche le choix des oligo par leur tm et leur longueur" global TabSeqTm #LesParametres a comparer if {$LesPABs == "LaTotale"} {set LesPABs [lsort -increasing [ListeDesPABs]]} #if {$LesTailles == ""} {set LesTailles [list 50 55 60 65 70]} if {$LesTailles == ""} {set LesTailles [list 60]} if {$LesTemperatures == ""} {set LesTemperatures [list 86 88 90 92 94 96 98]} if {$Ecart == ""} {set Ecart 5} if {$FichierSortie == ""} {set FichierSortie "[RepertoireDuGenome]/StatOligoPossible_60.new"} #set LesPABs [lrange $LesPABs 874 end] #AppendAuFichier $FichierSortie [join [list "Sequence" "Length" "Tm" "Range" "Total" "Accepted" "\%" "Rejected" "\%" "GCAccepted \%" "GCRejected \%"] "\t"] foreach PAB $LesPABs { if {$PAB=="ACT1165"} {continue} foreach Taille $LesTailles { foreach Temperature $LesTemperatures { set Res [ChoixDesOligosParLeTm $PAB $Taille $Temperature $Ecart] set Total [lindex $Res 0] set Accepted [lindex $Res 1] set Rejected [lindex $Res 2] set GCAccepted [lindex $Res 3] set GCRejected [lindex $Res 4] if {$Total==0} {set Total 1} #Espionne "$PAB $Taille $Temperature $Ecart $Total $Accepted [format "%.1f" [expr ($Accepted/($Total*1.0))*100.0]] $Rejected [format "%.1f" [expr ($Rejected/($Total*1.0))*100.0]]" AppendAuFichier $FichierSortie [join [list $PAB $Taille $Temperature $Ecart $Total $Accepted [format "%.1f" [expr ($Accepted/($Total*1.0))*100.0]] $Rejected [format "%.1f" [expr ($Rejected/($Total*1.0))*100.0]] $GCAccepted $GCRejected] "\t"] } } if {[info exists TabSeqTm]} {unset TabSeqTm} } return "" } proc TestTaxClass {} { Espionne [TaxClass 9606] Espionne [TaxClass 9606] Espionne [TaxClass 9605] Espionne [TaxClass 9606 "" "" Name] Espionne [TaxClass 9606 "" "" Rank] Espionne [TaxClass 9606 "" "" Name] exit } proc TestTaxParQdsMemo {} { Espionne [TaxParQdsMemo "Frog virus 3 (isolate Goorha)"] Espionne [TaxParQdsMemo "Frog virus 3 (isolate Goorha)"] Espionne [TaxParQdsMemo 9606] Espionne [TaxParQdsMemo "Homo sapiens"] Espionne [TaxParQdsMemo "Homo_sapiens"] } proc TestTmpFile {} { set F1 "[TmpFile RRR ~ "" WithDateAndUniqueRoot]_F1" Sauve xxx dans $F1 set F2 "[TmpFile RRR ~ "" WithDateAndUniqueRoot]_F2" Sauve xxx dans $F2 exit } proc TestTransfert {} { #test si le transfert entre macsims et macsimXml est complet set i 0; set j 0 foreach FichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsims/*xml"] { set Box [file tail $FichierMacsim] regsub {\.[^\.]+$} $Box "" Box incr i if {[file exists "[RepertoireDuGenome]/macsimXml/$Box"]} { incr j } else { Espionne "Manque $FichierMacsim dans macsimXml" } } Espionne "$i doit etre egale a $j" } proc TestTree {Nom {Type Access}} { global RepertoireDuGenome set A [ArbreEnListe [ContenuDuFichier "$RepertoireDuGenome/phylos/$Nom"]] puts $A set T [TreeFromArbre "Racine" $A $Type] NicePrintOfTree $T set P [PathToNode N_00006 $T "value"] set N [lindex $P end] puts $P set S [SwapRoot $T $N $P] puts " et le meme en N_00006" NicePrintOfTree $S exit } proc TestUnCanva {} { set K [UnCanva 600 400 300 200] $K configure -background red $K create rectangle 100 100 200 250 -fill green set G [Graphe {10 20}] $G configure -background red return $K } proc TestUnixFileName {} { foreach Ligne [LesLignesDuFichier "[HomeRipp]/lesbanquestblastn"] { scan $Ligne "%s" Banque Espionne "$Banque [UnixFileName $Banque]" } exit } proc TestUpload {{Fichier ""}} { if {$Fichier==""} { set Fichier "[HomeRipp]/images/TintinEtBD/pirogue.gif" } set Queue [file tail $Fichier] # format a gif file upload according to the following form: #

# # # #
# #

# get contents of the gif set fd [open $Fichier] fconfigure $fd -translation binary set image [read $fd] close $fd # set up other fields array set fields { MAX_FILE_SIZE " " action 1 img_resize "100%" } # format the image and form puts [form-data::format file1 $Queue $image image/gif] } proc TestW {} { load wrapwave/tcl_wavelib.so set vp [split [IniVolPol] \n] foreach l $vp { regsub -all { +} [string trim $l] " " l lassign [split $l " "] aa v p puts ">$aa< >$v< >$p<" set VP($aa,Vol) $v set VP($aa,Pol) $p } set VP(-,Vol) -1 set VP(-,Pol) -1 set s1 "ACDHGMSPKMSKSANWRGAL" set s2 "MTSHKMSKSPILSEHT" set Ls1V {} ; set Ls1P {} set Ls2V {} ; set Ls2P {} foreach x1 [split $s1 ""] x2 [split $s2 ""] { if {$x1 ne ""} { lappend Ls1V $VP($x1,Vol) lappend Ls1P $VP($x1,Pol) } if {$x2 ne ""} { lappend Ls2V $VP($x2,Vol) lappend Ls2P $VP($x2,Pol) } } # standise : -moy et / par ecarttype set Ls1P [Standardise $Ls1P] set Ls2P [Standardise $Ls2P] lappend Ls2P 0.0 0.0 0.0 0.0 set ws1P [::wavelets::forwardDWT haar 1 $Ls1P] puts "ws1P [llength $ws1P]" set ws2P [::wavelets::forwardDWT bior3.3 2 $Ls2P] } proc TestWali {{Quoi ""}} { #rR Attention ici on redéfinit certaines choses .. donc à ne pas exécuter dans Wali global WaliSourceDir ; set WaliSourceDir "[HomeRipp]/wwwLinux/wali" ; source $WaliSourceDir/wali_source.tcl if {[info proc SESSION]==""} { proc SESSION args { return "" } } if {$Quoi=="TaxonomyToHTML"} { return [TaxonomyToHTML CIL007] } return [UlAli "[WaliRootDir]/example.rsf"] } proc TestWarne {} { global WarneEnPuts set WarneEnPuts 0 set WarneEnPuts 0 Warne salut Warne "Comment ca va ?" } proc TestWebService {} { set R [WebService "Gx" Execute querytext "GxFun::SignalIntensity&&0&1&301&&T&&&GeneAsText&limit 10"] return $R set R [WebService "Gx" GxDbSqlExec querytext "select name,pk_tissue from tissue" getwhatfromserial "GetList"] return $R set R [WebService "Gx" GxDbSqlExec querytext "select probeset_id,pk_probeset from probeset where probeset_id in ('1415670_at','1415672_at');" getwhatfromserial "GetList"] return $R } proc TestWebServiceOLD {} { ;#rR ???????? package require http return [WebService "http://www.uniprot.org/mapping/?" toto [list from ACC to P_REFSEQ_AC format tab query P13368]] } proc TestXav {} { DecortiqueUnMSF msf/QR002 LesAccess Sequences foreach access $LesAccess { Espionne "$access" } } proc TestYaOrthologue {} { global RepertoireDuGenome set Somme 0 set n 0 foreach Nom [ListeDesPABs] { incr n # set Somme [expr $Somme + [PourcentageIdentiteOrga $Nom phor "$RepertoireDuGenome/fiches/piclustalw"]] incr Somme [YaOrthologue $Nom phor $RepertoireDuGenome] # set Somme [expr $Somme + [PourcentageIdentiteOrga $Nom phor "$RepertoireDuGenome/fiches/piclustalw"]] } puts [expr $Somme/$n] puts $n exit } proc Test_DbClustal {} { #! /bin/tcsh while (1) sleep 5 ps au |grep lardenoi >> Test_DbClustal.txt end } proc Test_H_Open_Close {} { lappend LT [H_Open [H_BalAtt [H_Pivot] Coucou "a b c d"]] lappend LT [H_Open [H_Color [H_Pivot]]] lappend LT "These lines will" lappend LT "be enclosed" lappend LT "between Opens and Closes" lappend LT [H_Close] lappend LT [H_Close] EspionneL $LT } 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 } proc TesteDoublon {} { foreach Ligne [LesLignesDuFichier LesDoublons.fof] { scan $Ligne "%s %s" Ps Fic regsub "/rng313.forAnnot/" $Fic "/xenoAovFDR.35/" Fix Espionne $Fic if {[ContenuDuFichier $Fic]!=[ContenuDuFichier $Fix]} { Espionne "$Fic\n$Fix" } } } proc TesteGrave {} { global NomDuFichierPierre set NomDuFichierPierre "pierre.testegrave" File delete -force $NomDuFichierPierre set L {6 8 9 7 } Grave L set A(toto) [list 4 5 "bonjour madame" [list comment va votre mari "Jules Dupont"]] set A(tutu) 5 set A(lili) $L Grave A EspionneL [array get A] unset A Degrave A unset L Degrave L Espionne $L EspionneL [array get A] exit } proc TesteIndexation {} { scan [BoundingBox [ListeDeBoites]] "%d %d" xDebut xFin set xDebut [Maxi 1 [expr $xDebut-3000]] incr xFin 1000 set ScalX [ expr 1024.0 / ( $xFin - $xDebut ) ] set Pas [expr round ( ( 10240.0 / round ( 1.0 / $ScalX ) ) * ( $xFin - $xDebut ) / 1024.0 ) ] set DebutCourant $xDebut set FinCourant [expr $xDebut + $Pas] Espionne "$ScalX $xDebut $xFin $Pas" ChargeOrdres "NombreDeCopainsDansBlast" ordrescomplets.txt indexes.txt signif.txt LesOrdresEntrePositions "NombreDeCopainsDansBlast" [expr 1+5*$Pas] [expr 1+7*$Pas] exit } 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 TesteRepereBox {K} { LesOrdresPourGif [GscopeBoard titi PourGif] exit Espionne [RepereBox "serrs" OrdrePourGif] } proc TesteSavantEnBatch {} { set Question "batch set x 3\nbatch set y \$x" puts [QuestionDeScience Paby $Question] exit } proc TesteTamis {} { set Commande [ChoisisUnTamis "ChampCommande"] if {$Commande==""} { exit } Espionne [eval $Commande] exit } proc TesteTouteLaBalise {} { Espionne [TouteLaBalise protein match.xml] Espionne [TouteLaBalise protein] Espionne [TouteLaBalise protein match.xml "CloseFileAfterRead"] Espionne [TouteLaBalise protein match.xml] Espionne [TouteLaBalise protein "" "CloseFileAfterRead"] Espionne [TouteLaBalise protein match.xml] } proc TesteUnCanva {} { set K [UnCanva 600 600 600 600 EtY] set K2 [UnCanva 600 800 6000 8000 EtY] $K create rectangle 200 200 300 500 -fill red set I [image create photo ima -file [HomeRipp]/images/hammer.gif] $K create image 0 0 -anchor nw -image ima MainLeveeSurUnCanva $K } proc TesteValeurDeLaBalise {} { set Texte " " set V [ValeurDeLaBalise BlastHit Texte "NePasRogner" A] Espionne "Valeur >$V<" Espionne "Attrib >$A<" Espionne "/$Texte/" set V [ValeurDeLaBalise DE Texte "NePasRogner" A] Espionne "Valeur >$V<" Espionne "Attrib >$A<" Espionne "/$Texte/" set V [ValeurDeLaBalise AC Texte "NePasRogner" A] Espionne "Valeur >$V<" Espionne "Attrib >$A<" Espionne "/$Texte/" Espionne [AttributsDeLaBalise DE Texte] exit } proc Teste_Fleche {} { set K [UnCanva 600 600] Fleche $K 200 100 430 100 -width 50 -outlinewidth 1 -fill "red" -outline "blue" -arrowdirection "both" -flatside "left" Fleche $K 200 300 230 300 -width 50 -outlinewidth 1 -outline "green" -arrowdirection "both" Fleche $K 200 400 230 400 -width 50 -outlinewidth 1 -fill "" -outline "orange" -arrowdirection "start" Fleche $K 200 500 230 500 -width 50 -outlinewidth 1 -fill "red" -outline "grey" -arrowdirection "none" $K create oval 10 10 100 200 MainLeveeSurUnCanva $K regsub ".canvas" $K "" w Gonfle $w all 1. 1. set K [UnCanva 600 600] Fleche $K 200 100 230 100 -width 50 -outlinewidth 1 -fill "red" -outline "blue" -arrowdirection "end" Fleche $K 200 300 230 300 -width 50 -outlinewidth 1 -fill "red" -outline "blue" -arrowdirection "both" Fleche $K 200 400 230 400 -width 50 -outlinewidth 1 -fill "red" -outline "blue" -arrowdirection "start" Fleche $K 200 500 230 500 -width 50 -outlinewidth 1 -fill "red" -outline "blue" -arrowdirection "none" $K create oval 10 10 100 200 MainLeveeSurUnCanva $K regsub ".canvas" $K "" w Gonfle $w all 1. 1. } proc Teste_LaTraduction {} { set Liste [ColorationsPossibles] foreach X $Liste T [LaTraduction $Liste "english" "SansBlanc"] { Espionne "$X $T" } exit } proc Teste_ScanLaListe {} { set L {1 2 3 4 5 6 7 } puts [ScanLaListe $L a b c] puts $a puts $b puts $c exit } proc Testlib {} { global OrdEtcDir TBlosum ListeDesAcidesAmines # set f [file join $OrdEtcDir pam250.bla] set f [file join $OrdEtcDir blosum62.dat] InitTBlosum $f # sans parametres --> gonnet250 # InitTBlosum array set TPam [array get TBlosum] #set laa [lrange $ListeDesAcidesAmines 0 end-1] set laa [split "ARNDCQEGHILKMFPSTWYV" ""] package require math::linearalgebra namespace import -force math::linearalgebra::* set M [mkMatrix 20 20] set i 0 foreach a $laa { set r [list] foreach b $laa { lappend r [set TPam($a,$b)] } setrow M $i $r incr i } # set M [CentreReduitMatrice $M] set M [CentreMatrice $M] set Lv [eigenvectorsSVD $M] lassign $Lv Vecs Vals AnalyseValeursPropres $Vals package require sqlite set Ev1 [lindex $Vecs 0] set Ev2 [lindex $Vecs 1] set Ev3 [lindex $Vecs 2] for {set i 1} {$i < 4} {incr i} { lassign [AnalyseVecteursPropres [set Ev$i]] k$i cp if {$i != 1} { set En$i [V_SV -1.0 * [set Ev$i]] lassign [AnalyseVecteursPropres [set En$i]] kn$i cn if {$cn > $cp} { set Ev$i [set En$i] set k$i [set kn$i] } } set Av$i [VecteurDeAAIndex [set k$i]] } FittingParRotation $Ev1 $Ev2 $Ev3 $Av1 $Av2 $Av3 puts "\nApres centrage et mise a l'echelle" FittingParRotation $Ev1 $Ev2 $Ev3 $Av1 $Av2 $Av3 1 1 exit } proc TestonsExec {} { #rR voir dans [HomeRipp]/Werig/bugPgtclExec puts "First exec" puts [exec pwd] puts [package require Pgtcl] puts "Second exec" puts [exec pwd] return "return from TestonExec" # load /usr/local/ActiveTcl/lib/pgtcl2.0.0/libpgtcl2.0.0.so } proc TestonsOligo {} { set FichierPourExcel1 "[RepertoireDuGenome]/Probes/OligoPourExcel4_6.txt" set FichierPourExcel2 "[RepertoireDuGenome]/Probes/New_OligoPourExcel_2_1.txt" #set LesAccessDeRef [InterrogeLesOligosPourExcel "$FichierPourExcel1" LesAccess] set LesAccessDeRef [InterrogeLesOligosPourExcel "$FichierPourExcel2" LesAccess] set ListeDeja [list ACT1168 ACT1200 ACT1375 ACT1384 ACT1396 ACT1457 ACT1476 ACT1671 ACT2437 ACT2438] set LesAcc "" foreach Acc $LesAccessDeRef { set ExisteAcc [InterrogeLesOligosPourExcel "$FichierPourExcel1" $Acc] if {$ExisteAcc=="1"} { set LesPABAssocie [InterrogeLesOligosPourExcel "$FichierPourExcel2" $Acc PAB] foreach PABAssocie $LesPABAssocie { if {! [regexp "$PABAssocie" $ListeDeja]} { lappend LesAcc "$PABAssocie On a deja $Acc [InterrogeLesOligosPourExcel "$FichierPourExcel2" $Acc Definition]" #Espionne "$PABAssocie On a deja $Acc [InterrogeLesOligosPourExcel "$FichierPourExcel2" $Acc Definition]" } } } } set LesAcc [lsort -index 0 $LesAcc] Espionne "[join $LesAcc "\n"]" return "" } proc TestonsSql {{Action ""}} { global TestonsSql if {[regexp -nocase "^(Y|O|1)" $Action]} { set TestonsSql 1 } if {[regexp -nocase "^(N|0)" $Action]} { set TestonsSql 0 } if { ! [info exists TestonsSql]} { set TestonsSql [catch {package require Pgtcl} Message] } if {$TestonsSql} { Espionne "Attention TestonsSql est a 1. I got the message \n$Message" } return $TestonsSql } proc Testsipathsontlesmemepourunememeligne {} { set LesLignes [NomLigne ListeDes Lignes] foreach Ligne $LesLignes { Espionne "" Espionne "ligne $Ligne" set Lesnombrepathway {} set TousLesNoms [NomLigne $Ligne Noms] set ListeDesNoms [split $TousLesNoms " "] foreach Nom $ListeDesNoms { set nombrepathway 0 set ListePathPourUnNom {} set Lesnombrepathway {} Espionne "$Nom" set LesPathway [ExtraitInfo $Nom "Pathways"] if {$LesPathway==""} { lappend Lesnombrepathway "" Espionne "nopathway" continue } Espionne "$LesPathway" set ListePathPourUnNom [split $LesPathway ","] foreach Pathway $ListePathPourUnNom { incr nombrepathway } } lappend Lesnombrepathway $nombrepathway Espionne "nombrepathway $nombrepathway" set Lesnombrepathway [ListeSansDoublon $Lesnombrepathway] set longLesnombrepathway [llength $Lesnombrepathway] Espionne "longLesnombrepathway $longLesnombrepathway" if {$longLesnombrepathway>1} { Espionne "Attention" #FaireLire "$Ligne pas meme pathway" } } } proc Testtoupper {{CC XJ4.1_i1}} { set CC [string toupper $CC] return $CC } proc TetesIdentiquesOuNon {} { set version "na32" set FichierMG430A "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.$version.annot.csv" set FichierMG430 "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.$version.annot.csv" set FichierMGU74A "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.$version.annot.csv" set FichierMGU74B "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.$version.annot.csv" set FichierMGU74C "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.$version.annot.csv" set FichierRGU34A "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.$version.annot.csv" set FichierHGU1332 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.$version.annot.csv" set FichierHGU133A "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.$version.annot.csv" set FichierHGU133B "[RepertoireAffyAnnot $version]/HG-U133/HG-U133B.$version.annot.csv" set FichierZebra "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.$version.annot.csv" set FichierDroso "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.$version.annot.csv" set FichierChick "[RepertoireAffyAnnot $version]/Chicken/Chicken.$version.annot.csv" set FichierXenop "[RepertoireAffyAnnot $version]/Xenopuslaevis/Xenopus_laevis.$version.annot.csv" set LesFichiers [list $FichierMG430A $FichierMG430 $FichierMGU74A $FichierMGU74B $FichierMGU74C $FichierRGU34A $FichierHGU1332 $FichierHGU133A $FichierHGU133B $FichierZebra $FichierDroso $FichierChick $FichierXenop] foreach File $LesFichiers { Espionne "File $File" set Tete [TabulonsSansQuote $File "," ";" " " "GetHeaders"] #set LesLignes [TabulonsSansQuote $File "," ";" " " "GetListOfHeaders"] Espionne "Tete $Tete" lappend LesTetes $Tete } set LesTetes [ListeSansDoublon $LesTetes] set long [llength $LesTetes] if {$long==1} { Espionne "tous les fichiers ont les memes tetes" } else { Espionne "tous les fichiers n ont pas les memes tetes" } } proc Texe {Largs} { global LNOrdali LSOrdali Sequences lassign $Largs pkpfam fpfam Lpdb2id unset -nocomplain Sequences LNOrdali LSOrdali set pfamid [lindex [split [file tail $fpfam] .] 0] puts "$pfamid" # lit le fichier DecortiqueUnTFA $fpfam LNOrdali Sequences set Lout [BCM_Pdb2Pfam $pfamid $Lpdb2id] update # finish EcritLeTfa "${fpfam}_smp" $LNOrdali $LSOrdali puts "" return $Lout } proc Text2HTML {aT} { upvar $aT tbl set txt $tbl(Text) if {[string index $txt 0] eq "\{"} { set txt [string range $txt 1 end] } if {[string index $txt end] eq "\}"} { set txt [string range $txt 0 end-1] } set txt [string map {"\n" "
"} $txt] if {$txt ne "" || $txt ne "{}"} { Html_Append $txt } Html_BR return } proc Text2Text {aT} { upvar $aT tbl lappend ::TextOut "$tbl(Text)" return } proc TextFilesFusion {args} { puts ">>> Fusion des fichiers : output=fusionnedFile" set compteur 0 set tout 0 set output [open "fusionnedFile" "w"] foreach fileName $args { set input [open "$fileName" "r"] while {[gets $input line]!=-1} { if {$line=="" || $line=="\n" || ([string index $line 0]=="#")} {continue} incr compteur incr tout set infos [split $line ";"] puts $output "$tout;[lindex $infos 1];[lindex $infos 2];[lindex $infos 3];[lindex $infos 4]" } close $input set nombre($fileName) $compteur set compteur 0 } close $output puts " -->OK" puts " -->Pour info : " set total 0 foreach {cle val} [array get nombre] { puts " - $cle : contient $val lignes" set total [expr $total+$val] } puts "Total : $total" } proc TextOnCanva {Value Index K DecalX DecalY} { global CouleurTag regsub -all {\{|\}} $Value "" Value if {$Value == ""} { return "0 0"} Wup "Voir PrintOrdali ... pour compatibilite" set TailleFonte 10 set OffsetLettre [font measure [list CourierNew $TailleFonte] Z] set HauteurLettre 14 regsub {\.} $Index " " XY scan $XY "%d %d" Y X set x [expr ( $X + 2 + $DecalX)*$OffsetLettre ] set y [expr ( $Y + 1 + $DecalY)*$HauteurLettre] set FG [CouleurOrdali fg] set BG [CouleurOrdali bg] set fx [expr $x+[font measure [list CourierNew $TailleFonte] $Value]] set fy [expr $y+$HauteurLettre] if {$FG=="NoColor"} { set FG "black" } if {$BG!="NoColor"} { $K create rectangle $x $y $fx $fy -fill $BG -outline $BG } $K create text $x $y -text "$Value" -anchor nw -fill $FG -font [list CourierNew $TailleFonte] set PosX [expr round($fx/$OffsetLettre)] set PosY [expr round($fy/$HauteurLettre)] return "$PosX $PosY" } proc TextOnHTML {Value Index aTextOnHTML} { upvar $aTextOnHTML TextOnHTML global CouleurTag global CodeSpanOrdali global OldY global GaucheOrdali regsub -all {\{|\}} $Value "" Value regsub {\.} $Index " " XY scan $XY "%d %d" Y X if { ! [info exists OldY] || $Y!=$OldY} { append TextOnHTML "\n" set Gauche "" if {[info exists GaucheOrdali($Y)]} { set Gauche [set GaucheOrdali($Y)] } append TextOnHTML [BelleGauche $Gauche] } set OldY $Y set CodeSpan [set CodeSpanOrdali($CouleurTag)] append TextOnHTML "$Value" set PosY $Y set PosX [expr $X+[string length $Value]] return "$PosX $PosY" } proc TextToHTML {FichierText FichierHtml} { if {![file exists $FichierText]} {return ""} set NomFichier [file tail $FichierText] set TexteHtml [Html_DuTexteTelQuel $FichierText $NomFichier] Sauve $TexteHtml dans $FichierHtml } proc TextToHTMLPourTous {RepFichiersText RepFichiersHtml} { if {![file exists $RepFichiersText]} {return ""} if {![file exists $RepFichiersHtml]} {file mkdir "[RepertoireDuGenome]/$RepFichiersHtml"} foreach Fichier [glob -nocomplain "$RepFichiersText/*"] { set NomFichier [file tail $Fichier] if {[file exists "[RepertoireDuGenome]/$RepFichiersHtml/$NomFichier.html"]} {Espionne "$NomFichier already exists";continue} Espionne "$NomFichier en cours" set TexteHtml [Html_DuTexteTelQuel $Fichier $NomFichier] set Fichier_html "[RepertoireDuGenome]/$RepFichiersHtml/$NomFichier.html" Sauve $TexteHtml dans $Fichier_html } } proc TexteAscii {Texte} { regsub -all {\+} $Texte " " Texte regsub -all "%0D" $Texte "%0A" Texte while {[regexp -nocase {%[0-9a-h]{2}} $Texte Hexa]} { set Car [HexaToAscii $Hexa] if {$Car=="&"} { set Car "\\&" } regsub -all $Hexa $Texte $Car Texte } regsub -all "\<" $Texte "<" Texte regsub -all "\>" $Texte ">" Texte return $Texte } proc TexteEntreChevrons {Texte} { set i [string first "<" $Texte] if {$i<0} { return "" } set Bon "" set N 1 foreach C [split [string range $Texte [incr i] end] ""] { if {$C==">" && $N==1} { return $Bon } append Bon $C if {$C=="<"} { incr N } if {$C==">"} { incr N -1} } return $Bon } proc TexteExonicMap {FichierBlast FichierTFA LesRegions {AlertId 0.95} {NbIteration No}} { set TailleFragment 100000 set RepTFA [file dirname $FichierTFA] set NameRepTFA [file tail $RepTFA] set RepBlast [file dirname $FichierBlast] set NameFileTFA [file tail $FichierTFA] set NameFileTFA "$NameRepTFA/$NameFileTFA" set TypeDeBlast [AskBlast $FichierBlast TypeDeBlast] if {$TypeDeBlast == ""} {return} set Entete [EnteteDuFichierTFA $FichierTFA] set LeTexte {} lappend LeTexte "Box: $Entete" lappend LeTexte "File: $NameFileTFA" if {$TypeDeBlast == "BLASTN"} { lappend LeTexte "Type: DNA" } else { lappend LeTexte "Type: PROTEIN" } lappend LeTexte "LengthBox: [AskBlast $FichierBlast Taille]" if {$NbIteration != "No"} { lappend LeTexte "NbCycles: $NbIteration" } set LesAccessEtLeurSens {} foreach UneRegion [lsort -integer -index end -decreasing $LesRegions] { set LeBId [lindex $UneRegion 4] set Chrom [lindex $LeBId 0] set Access [lindex $LeBId 1] set NdeN [lindex $LeBId 2] set Sens [lindex $UneRegion 6] set Orient [lindex $UneRegion 5] set Score [lindex $UneRegion end] if {![info exists TabTmp($Access,$Sens,LesRegions)]} { lappend LesAccessEtLeurSens [list $Chrom $Access $Sens $NdeN] set TabTmp($Access,$Sens,LesRegions) {} set TabTmp($Access,$Sens,BorneMin) 1e200 set TabTmp($Access,$Sens,BorneMax) 0 set TabTmp($Access,$Sens,LesOrient) {} set TabTmp($Access,$Sens,Score) 0 set TabTmp($Access,$Sens,NbAli) 0 set TabTmp($Access,$Sens,NbAliTot) 0 set TabTmp($Access,$Sens,NbExon) 0 set TabTmp($Access,$Sens,NbAbsent) 0 set TabTmp($Access,$Sens,NbPolyLoc) 0 } lappend TabTmp($Access,$Sens,LesRegions) $UneRegion if {$Orient != ""} {lappend TabTmp($Access,$Sens,LesOrient) $Orient} if {[set TabTmp($Access,$Sens,Score)] < $Score} {set TabTmp($Access,$Sens,Score) $Score} set N [lindex $UneRegion 3] if {$N == 1 } {incr TabTmp($Access,$Sens,NbExon)} if {$N == 0 } {incr TabTmp($Access,$Sens,NbAbsent)} if {1 < $N} {incr TabTmp($Access,$Sens,NbPolyLoc)} if {$N != 1} {continue} incr TabTmp($Access,$Sens,NbAliTot) [lindex $UneRegion 10] incr TabTmp($Access,$Sens,NbAli) [lindex $UneRegion 9] set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] if {$DS < [set TabTmp($Access,$Sens,BorneMin)]} {set TabTmp($Access,$Sens,BorneMin) $DS} if {[set TabTmp($Access,$Sens,BorneMax)] < $FS} {set TabTmp($Access,$Sens,BorneMax) $FS} } if {1 < [llength $LesAccessEtLeurSens]} { lappend LeTexte "WARNING: polylocalised" } set i 0 foreach LAccessEtLeSens $LesAccessEtLeurSens { set Chrom [lindex $LAccessEtLeSens 0] set Access [lindex $LAccessEtLeSens 1] set Sens [lindex $LAccessEtLeSens 2] set NdeN [lindex $LAccessEtLeSens 3] set Score [set TabTmp($Access,$Sens,Score) ] set NbAli [set TabTmp($Access,$Sens,NbAli)] set NbAliTot [set TabTmp($Access,$Sens,NbAliTot)] set IdTot [expr $NbAli * 1.0 / $NbAliTot] set NbExon [set TabTmp($Access,$Sens,NbExon)] set NbAbsent [set TabTmp($Access,$Sens,NbAbsent)] set NbPolyLoc [set TabTmp($Access,$Sens,NbPolyLoc)] set BorneMin [set TabTmp($Access,$Sens,BorneMin)] set BorneMax [set TabTmp($Access,$Sens,BorneMax)] set LesOrient [lsort -unique [set TabTmp($Access,$Sens,LesOrient)]] if {$Sens == "+"} { set LesRegions [lsort -real -index 7 [set TabTmp($Access,$Sens,LesRegions)]] } else { set LesRegions [lsort -real -index 7 -decreasing [set TabTmp($Access,$Sens,LesRegions)]] } set LesRegions [lsort -integer -index 0 $LesRegions] set Fragments "" if {$NdeN != 0} { set FragmentMin [format "%${NdeN}.${NdeN}d" [expr round($BorneMin / $TailleFragment)]] set FragmentMax [format "%${NdeN}.${NdeN}d" [expr round($BorneMax / $TailleFragment)]] if {$Sens == "+"} { set Fragments "From $FragmentMin to $FragmentMax" } else { set Fragments "From $FragmentMax to $FragmentMin" } } if {$Sens == "+"} { set Bornes "From $BorneMin to $BorneMax" } else { set Bornes "From $BorneMax to $BorneMin" } incr i lappend LeTexte "" lappend LeTexte "RANK_SCORE: $i $Score" lappend LeTexte "Chromosome: $Chrom" lappend LeTexte "Contig: $Access" if {$Fragments != ""} { lappend LeTexte "ContigFragments: $Fragments" } lappend LeTexte "ContigLocalisation: $Bornes" lappend LeTexte "Orientation: [join $LesOrient " "]" lappend LeTexte "Sense: $Sens" lappend LeTexte "NbExonicAreas: $NbExon" lappend LeTexte "NbAbsentAreas: $NbAbsent" lappend LeTexte "NbPolyLocAreas: $NbPolyLoc" if {$IdTot < $AlertId} { lappend LeTexte "WARNING: MayBeWrongLoc ([expr round($IdTot * 100)] %)" } set nRepeat 0 set nExon 0 set nAbsent 0 foreach UneRegion $LesRegions { set N [lindex $UneRegion 3] if {$N == 1} {incr nExon ;set QuEstCeQueCEst "ExonArea" ;set n $nExon} if {$N < 1} {incr nAbsent;set QuEstCeQueCEst "AbsentArea" ;set n $nAbsent} if {1 < $N} {incr nRepeat;set QuEstCeQueCEst "PolyLocArea";set n $nRepeat} set DQ [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set FQ [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] set TailleArea [expr $FQ - $DQ + 1] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } if {$N != 0} { set Orient [lindex $UneRegion 5] set Sens [lindex $UneRegion 6] set nAli [lindex $UneRegion 9] set nAliTot [lindex $UneRegion 10] set nCont [lindex $UneRegion 11] set Id [expr $nAli * 100.0 / $nAliTot] lappend LeTexte [format "%-5d %-5d %-5d %12s %-3s %-9d %-9d %-11s %s %-5d %-5d %-5.1f %-5d" $DQ $FQ $TailleArea $QuEstCeQueCEst $n $DS $FS $Orient $Sens $nAli $nAliTot $Id $nCont] } else { lappend LeTexte [format "%-5d %-5d %-5d %12s %-3s" $DQ $FQ $TailleArea $QuEstCeQueCEst $n] } } } return [join $LeTexte "\n"] } proc TexteExonicMap_TabBlast {aTabBlast Nom FichierTFA FichierBlast LesRegions {AlertId 0.95} {NbIteration No}} { upvar $aTabBlast TabBlast set TailleFragment 100000 set RepTFA [file dirname $FichierTFA] set NameRepTFA [file tail $RepTFA] set RepBlast [file dirname $FichierBlast] set NameFileTFA [file tail $FichierTFA] set NameFileTFA "$NameRepTFA/$NameFileTFA" set TypeDeBlast [set TabBlast(TypeDeBlast)] if {![info exists TabBlast(TypeDeBlast)]} {return ""} set LeTexte {} lappend LeTexte "Box: $Nom" lappend LeTexte "File: $NameFileTFA" if {$TypeDeBlast == "BLASTN"} { lappend LeTexte "Type: DNA" } else { lappend LeTexte "Type: PROTEIN" } lappend LeTexte "LengthBox: [set TabBlast(Taille)]" PourcentagesDeMasking Repeat $Nom $RepTFA $RepBlast if {[info exists Repeat(Masking)] } { lappend LeTexte "Masking: [set Repeat(Masking)]" } if {$NbIteration != "No"} { lappend LeTexte "NbCycles: $NbIteration" } set LesAccessEtLeurSens {} foreach UneRegion [lsort -integer -index end -decreasing $LesRegions] { set LeBId [lindex $UneRegion 4] set Chrom [lindex $LeBId 0] set Access [lindex $LeBId 1] set NdeN [lindex $LeBId 2] set Sens [lindex $UneRegion 6] set Orient [lindex $UneRegion 5] set Score [lindex $UneRegion end] if {![info exists TabTmp($Access,$Sens,LesRegions)]} { lappend LesAccessEtLeurSens [list $Chrom $Access $Sens $NdeN] set TabTmp($Access,$Sens,LesRegions) {} set TabTmp($Access,$Sens,BorneMin) 1e200 set TabTmp($Access,$Sens,BorneMax) 0 set TabTmp($Access,$Sens,LesOrient) {} set TabTmp($Access,$Sens,Score) 0 set TabTmp($Access,$Sens,NbAli) 0 set TabTmp($Access,$Sens,NbAliTot) 0 set TabTmp($Access,$Sens,NbExon) 0 set TabTmp($Access,$Sens,NbAbsent) 0 set TabTmp($Access,$Sens,NbPolyLoc) 0 } lappend TabTmp($Access,$Sens,LesRegions) $UneRegion if {$Orient != ""} {lappend TabTmp($Access,$Sens,LesOrient) $Orient} if {[set TabTmp($Access,$Sens,Score)] < $Score} {set TabTmp($Access,$Sens,Score) $Score} set N [lindex $UneRegion 3] if {$N == 1 } {incr TabTmp($Access,$Sens,NbExon)} if {$N == 0 } {incr TabTmp($Access,$Sens,NbAbsent)} if {1 < $N} {incr TabTmp($Access,$Sens,NbPolyLoc)} if {$N != 1} {continue} incr TabTmp($Access,$Sens,NbAliTot) [lindex $UneRegion 10] incr TabTmp($Access,$Sens,NbAli) [lindex $UneRegion 9] set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] if {$DS < [set TabTmp($Access,$Sens,BorneMin)]} {set TabTmp($Access,$Sens,BorneMin) $DS} if {[set TabTmp($Access,$Sens,BorneMax)] < $FS} {set TabTmp($Access,$Sens,BorneMax) $FS} } if {1 < [llength $LesAccessEtLeurSens]} { lappend LeTexte "WARNING: polylocalised" } set i 0 foreach LAccessEtLeSens $LesAccessEtLeurSens { set Chrom [lindex $LAccessEtLeSens 0] set Access [lindex $LAccessEtLeSens 1] set Sens [lindex $LAccessEtLeSens 2] set NdeN [lindex $LAccessEtLeSens 3] set Score [set TabTmp($Access,$Sens,Score) ] set NbAli [set TabTmp($Access,$Sens,NbAli)] set NbAliTot [set TabTmp($Access,$Sens,NbAliTot)] set IdTot [expr $NbAli * 1.0 / $NbAliTot] set NbExon [set TabTmp($Access,$Sens,NbExon)] set NbAbsent [set TabTmp($Access,$Sens,NbAbsent)] set NbPolyLoc [set TabTmp($Access,$Sens,NbPolyLoc)] set BorneMin [set TabTmp($Access,$Sens,BorneMin)] set BorneMax [set TabTmp($Access,$Sens,BorneMax)] set LesOrient [lsort -unique [set TabTmp($Access,$Sens,LesOrient)]] if {$Sens == "+"} { set LesRegions [lsort -real -index 7 [set TabTmp($Access,$Sens,LesRegions)]] } else { set LesRegions [lsort -real -index 7 -decreasing [set TabTmp($Access,$Sens,LesRegions)]] } set LesRegions [lsort -integer -index 0 $LesRegions] set Fragments "" if {$NdeN != 0} { set FragmentMin [format "%${NdeN}.${NdeN}d" [expr round($BorneMin / $TailleFragment)]] set FragmentMax [format "%${NdeN}.${NdeN}d" [expr round($BorneMax / $TailleFragment)]] if {$Sens == "+"} { set Fragments "From $FragmentMin to $FragmentMax" } else { set Fragments "From $FragmentMax to $FragmentMin" } } if {$Sens == "+"} { set Bornes "From $BorneMin to $BorneMax" } else { set Bornes "From $BorneMax to $BorneMin" } incr i lappend LeTexte "" lappend LeTexte "RANK_SCORE: $i $Score" lappend LeTexte "Chromosome: $Chrom" lappend LeTexte "Contig: $Access" if {$Fragments != ""} { lappend LeTexte "ContigFragments: $Fragments" } lappend LeTexte "ContigLocalisation: $Bornes" lappend LeTexte "Orientation: [join $LesOrient " "]" lappend LeTexte "Sense: $Sens" lappend LeTexte "NbExonicAreas: $NbExon" lappend LeTexte "NbAbsentAreas: $NbAbsent" lappend LeTexte "NbPolyLocAreas: $NbPolyLoc" if {$IdTot < $AlertId} { lappend LeTexte "WARNING: MayBeWrongLoc ([expr round($IdTot * 100)] %)" } set nRepeat 0 set nExon 0 set nAbsent 0 foreach UneRegion $LesRegions { set N [lindex $UneRegion 3] if {$N == 1} {incr nExon ;set QuEstCeQueCEst "ExonArea" ;set n $nExon} if {$N < 1} {incr nAbsent;set QuEstCeQueCEst "AbsentArea" ;set n $nAbsent} if {1 < $N} {incr nRepeat;set QuEstCeQueCEst "PolyLocArea";set n $nRepeat} set DQ [Mini [lindex $UneRegion 0] [lindex $UneRegion 1]] set FQ [Maxi [lindex $UneRegion 0] [lindex $UneRegion 1]] set TailleArea [expr $FQ - $DQ + 1] if {$Sens == "+"} { set DS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] } else { set DS [Maxi [lindex $UneRegion 7] [lindex $UneRegion 8]] set FS [Mini [lindex $UneRegion 7] [lindex $UneRegion 8]] } if {$N != 0} { set Orient [lindex $UneRegion 5] set Sens [lindex $UneRegion 6] set nAli [lindex $UneRegion 9] set nAliTot [lindex $UneRegion 10] set nCont [lindex $UneRegion 11] set Id [expr $nAli * 100.0 / $nAliTot] lappend LeTexte [format "%-5d %-5d %-5d %12s %-3s %-9d %-9d %-11s %s %-5d %-5d %-5.1f %-5d" $DQ $FQ $TailleArea $QuEstCeQueCEst $n $DS $FS $Orient $Sens $nAli $nAliTot $Id $nCont] } else { lappend LeTexte [format "%-5d %-5d %-5d %12s %-3s" $DQ $FQ $TailleArea $QuEstCeQueCEst $n] } } } return [join $LeTexte "\n"] } proc TexteHDACroises {V Fam Orga {Quoi ""}} { if {$Quoi=="Devoile"} { return "$Fam $Orga [join $V " "]" } set T [lindex $V 0] set P [lindex $V 1] set J [lindex $V 2] if {1 || [CouleurHDACroises $V]=="O"} { return "$P" } return " " } proc TexteOMO {NomVoulu {Format Court}} { global RepertoireDuGenome global TexteOMO if { ! [YaPABdans $NomVoulu]} { return "" } if { ! [info exists TexteOMO]} { set FichierOMO "$RepertoireDuGenome/fiches/organismesayantmemeoperon" if { ! [ file exists $FichierOMO]} { set TexteOMO Bidon return } foreach Ligne [LesLignesDuFichier $FichierOMO] { set LesMots [split $Ligne " "] set Nom [lindex $LesMots 0] set Voisin [lindex $LesMots 1] set iOMO [string length "$Nom $Voisin xxxx"] set sOMO [string trim [string range $Ligne $iOMO end]] set Texte "" for {set i 0} {$i < [string length $sOMO]} {incr i 5} { set C [string index $sOMO $i] if { $C != " " } { append Texte $C } else { append Texte "." } } set TexteOMO($Nom,Court) $Texte set TexteOMO($Nom,Long) $Ligne set TexteOMO($Nom,Avant) $Voisin set TexteOMO($Voisin,Apres) $Nom } } if { ! [info exists TexteOMO($NomVoulu,$Format)]} { return ""} return [set TexteOMO($NomVoulu,$Format)] } proc TextePDB {aPDB {Quoi ""} {JoinCar " "} {OnTheWeb ""}} { if {$Quoi==""} { set Quoi "Ref" } set OnTheWeb [string equal -nocase $OnTheWeb "OnTheWeb"] regsub -nocase "^PDB:" $aPDB "" aPDB #rR pour avoir la sequence de SEQRES il faut donner la chaine SEQRES_B. #rR par defaut on prend la chaine A set Chain "A" if {[regexp "SEQRES" $Quoi]} { if {[regexp {SEQRES_([A-Za-z]+)} $Quoi Match ChaineVoulue]} { set Chain $ChaineVoulue } set Quoi "SEQRES" } if { ! [regexp "/" $aPDB]} { regsub -nocase {_[a-z]*} $aPDB "" aPDB set RepLocalPDB "[RepertoireDuGenome]/localpdb" set FichierLocalPDB "$RepLocalPDB/pdb[string tolower $aPDB].ent" if {[file exists $FichierLocalPDB]} { set TextePDB [ContenuDuFichier $FichierLocalPDB] } else { set SousRep [string range $aPDB 1 2] set FichierPDB "/catalog/pdb/compressed_files/$SousRep/pdb$aPDB.ent.gz" if {[file exists $FichierPDB]} { set TextePDB [exec zcat $FichierPDB] } else { if {! $OnTheWeb} { return "" } #lm ne passe plus par RecupereUnFichierSurWeb... #lm prend cas general #set LTextePDB [RecupereUnFichierSurWeb [string toupper $aPDB]] set pdbid [string toupper $aPDB] set url "http://www.rcsb.org/pdb/cgi/export.cgi/XXXX.pdb?format=PDB&pdbId=XXXX&compression=None" regsub -all "XXXX" $url $aPDB url set TextePDB [HttpCopy $url] } } } else { set TextePDB [ContenuDuFichier $aPDB] } if {[string equal -nocase "All" $Quoi]} { return $TextePDB } if {$TextePDB==""} { return "" } #lm ultime test pour savoir si on a bien un PDB #rR ................... supprime par rR 2016/09/14 if {0 && [string range $TextePDB 0 5] ne "HEADER"} { return "" } set JusquASeqres 0 set JusquAAtom 1 if {$Quoi=="Ref" && $JusquASeqres} { set iSEQRES [string first "\nSEQRES " $TextePDB] if {$iSEQRES<0} { set iSEQRES end } return [string range $TextePDB 0 $iSEQRES] } if {$Quoi=="Ref" && $JusquAAtom} { set iATOM [string first "\nATOM " $TextePDB] if {$iATOM<0} { set iATOM end } return [string range $TextePDB 0 $iATOM] } if {$Quoi!=""} { set Sortie {} foreach Ligne [split $TextePDB "\n"] { if { ! [regexp "^$Quoi" $Ligne]} { continue } if {$Quoi=="SEQRES"} { scan $Ligne "%s %s %s %s" K I C N if {$K!="SEQRES"} { break } if {$Chain!=$C} { continue } regsub "$K *$I *$C *$N" $Ligne "" CodesTroisLettres lappend Sortie $CodesTroisLettres continue } set Ligne [string range $Ligne 0 69] regsub "$Quoi" $Ligne "" Ligne set Ligne [string trim $Ligne] lappend Sortie $Ligne if {$Quoi!="ATOM" && [regexp "^ATOM" $Ligne]} { break } } if {$Quoi=="SEQRES"} { set Sortie [join $Sortie " "] regsub -all { +} $Sortie " " Sortie return [string trim $Sortie] } return [join $Sortie $JoinCar] } return $TextePDB } proc TextePourRosace {Action K {ListeOuFichier ""}} { global ParametresDuBoard set CentreX [set ParametresDuBoard($K,CentreX)] set CentreY [set ParametresDuBoard($K,CentreY)] if {$Action == "Add"} { set Liste $ListeOuFichier if {$Liste == {}} { set Texte [Entre] if {$Texte == ""} { return } $K create text $CentreX $CentreY -text "$Texte" -font {Courier 10} -tags [list "Etiquette" $Texte] return $Texte } if {$Liste != {}} { set DefautX $CentreX set DefautY $CentreY foreach Ligne $Liste { set X [incr DefautX 10] set Y [incr DefautY 10] scan $Ligne "%s %s %s" Texte X Y $K create text $X $Y -text "$Texte" -font {Courier 10} -tags [list "Etiquette" $Texte] } } } if {$Action == "AddFromList"} { if {$ListeOuFichier == ""} { set Fichier [ButineArborescence] if {$Fichier == ""} { return "" } foreach Ligne [LesLignesDuFichier $Fichier] { set Texte "Bidon" scan $Ligne "%s" Texte lappend Liste $Texte } } else { set Liste $ListeOuFichier } return [TextePourRosace "Add" $K $Liste] } } proc TexteTFAsDesMeilleursCopainsDuBlast {Nom RepBlast GrosFichierTFAs {Expect 0.001}} { global RepertoireDuGenome if { ! [regexp "/" $RepBlast]} { set RepBlast "$RepertoireDuGenome/$RepBlast" } set FichierBlast "$RepBlast/$Nom" if {$FichierBlast==""} { return "" } set n [DecortiqueBlast $FichierBlast $Expect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN] if {$n==0} { set n [DecortiqueBlast $FichierBlast 0.001 5 Query lBanqueId lAccess lDE lProfil lPN] if {$n==0} { return "" } } Espionne $lBanqueId set Texte [ExtraitLesSequencesDuTFAs $GrosFichierTFAs $lBanqueId] return $Texte } proc TexteTfaFromTexteTfaWithoutNumbers {TexteTFA} { set Seq [QueLaSequenceDuTexteTFA $TexteTFA] set Ent [EnteteDuTexteTFA $TexteTFA] set NouveauTexteTFA [SequenceFormatTFA $Seq $Ent] return $NouveauTexteTFA } proc TexteUT {TexteOuFichier} { set Texte $TexteOuFichier if {[regexp "/" $TexteOuFichier]} { set Texte [ContenuDuFichier $TexteOuFichier] } set New "" foreach Mot [LesMotsDuTexte $Texte] { set X [UT $Mot] append New $X } return $New } proc Texte_WordML {Texte} { return "$Texte" } proc TfaATCGbackground {} { set FichierTfa [open "/genomics/link/STAF/fiches/Bidir/1000/SequencesTotales.bidir" "r"] set A 0 set T 0 set C 0 set G 0 set I 0 set Chars 0 Espionne "TfaATCGbackground : Start" while { [gets $FichierTfa Sequence] > 0 } { if { [string index $Sequence 0] != ">" } { set CharArray [split $Sequence ""] foreach Char $CharArray { if { $Char == "A" } { incr A incr Chars } if { $Char == "T" } { incr T incr Chars } if { $Char == "C" } { incr C incr Chars } if { $Char == "G" } { incr G incr Chars } } } } set FA [expr double($A)/$Chars] set FT [expr double($T)/$Chars] set FC [expr double($C)/$Chars] set FG [expr double($G)/$Chars] Espionne "TfaATCGbackground : A=$FA ($A)" Espionne "TfaATCGbackground : T=$FT ($T)" Espionne "TfaATCGbackground : C=$FC ($C)" Espionne "TfaATCGbackground : G=$FG ($G)" Espionne "TfaATCGbackground : $Chars chars in $I sequences" Espionne "TfaATCGbackground : End" } proc TfaAvecOrgaEnAccess {Fichier {Out ""}} { foreach Ligne [LesLignesDuFichier $Fichier] { if { [regexp {>.*\[(.*)\]} $Ligne Match Orga] } { regsub -all " " $Orga "_" Orga lappend LeNew ">$Orga" continue } lappend LeNew $Ligne } if {$Out==""} { return [join $LeNew "\n"] } return [SauveLesLignes $LeNew dans $Out] } proc TfaDeLaBanqueBlast {Banque Access} { set Banque [string tolower $Banque] set TfaDeLaBanqueBlast "" catch { set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s $Access 2> /dev/null] } Message #rR Rajout du 2014/11/10 car il y a PDB: if {$TfaDeLaBanqueBlast!=""} { return $TfaDeLaBanqueBlast } #Warne $Message if { ! [regexp {^[0-9]} $Access]} { return "" } catch { set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s "PDB:$Access" 2> /dev/null] } Message return $TfaDeLaBanqueBlast } proc TfaPourPipe {} { set FichierTfaPourPipe [RepertoireDuGenome]/PourPipe.tfa foreach Nom [ListeDesPABs] { set FichierTfa "[GscopeFile $Nom prottfa]" if {[FileAbsent $FichierTfa]} {continue} Espionne $FichierTfa AppendAuFichier $FichierTfaPourPipe [ContenuDuFichier $FichierTfa] } } proc TfaPourPipeVideRetrouve {} { set FichierTfaPourPipe [RepertoireDuGenome]/PourPipeVideRetrouve.tfa foreach F [glob -nocomplain "[RepertoireDuGenome]/protemblVide/*"] { set Queue [file tail $F] lappend LesVidesRetrouves $Queue } EspionneL $LesVidesRetrouves foreach VideRetrouve $LesVidesRetrouves { set FichierTfa [GscopeFile $VideRetrouve "prottfa"] if {[FileAbsent $FichierTfa]} {continue} Espionne $FichierTfa AppendAuFichier $FichierTfaPourPipe [ContenuDuFichier $FichierTfa] } } proc TfaTmpFromGCG {FiOl} { set LesLignes [LesLignesDuFichier $FiOl] set Entete [lindex $LesLignes 1] set TFA [SequenceFormatTFA_l [lrange $LesLignes 2 end] $Entete "gcg"] return [Sauve $TFA dans "[TmpFile].tfa"] } proc Tgbk {FichierGBK} { set LesInfosGenBank [DecortiqueGenBank OS OC SeqADN $FichierGBK] Espionne [FromInfoOfGenBankToEMBL $LesInfosGenBank ] } proc Tgbt {} { set LesInfosGBTags [DecortiqueGBTags OS OC AC gb] Espionne [FromInfoOfGenBankToEMBL $LesInfosGBTags nuc] exit } proc TheTrueMacsimsFile {Nom {Preference ""}} { if {[regexp "/" $Nom]} { if {[file exists $Nom]} { return $Nom } if {[file exists $Nom.xml]} { return $Nom.xml } if {[file exists $Nom.xml.gz]} { return $Nom.xml.gz } if {[file exists $Nom.gz]} { return $Nom.gz } } if { ! [EstUnPAB $Nom]} { return $Nom } foreach Dir [list "[RepertoireDuGenome]/macsimXml" "[RepertoireDuGenome]/macsims"] { if {[file exists $Dir/$Nom]} { return $Dir/$Nom } if {[file exists $Dir/$Nom.xml]} { return $Dir/$Nom.xml } if {[file exists $Dir/$Nom.xml.gz]} { return $Dir/$Nom.xml.gz } if {[file exists $Dir/$Nom.gz]} { return $Dir/$Nom.gz } } return $Nom } proc ThrBal {} { global dbR AlATables LesDefsAlA package require sqlite3 file delete res.sql set dbR [FabriqueDeTables $AlATables "" res.sql] LesDefauts #set Lf [LesFichiersDeBalibase] set Lf /home/moumou/Agents/BB11001.xml set Ljobs {} set iJob 0 foreach f $Lf { foreach len {5 7 11 13 15 17} { lappend Ljobs [list $iJob [list $f $len]] incr iJob } } puts "\nNbr of jobs : [llength $Ljobs]\n" #set args [lindex $Ljobs 0] #AnalyseFichierBalibase {*}$args #exit Thr_Submit -joblist $Ljobs -proccreate SetupAnaBali -procexe AnalyseFichierBalibase -procresults ResAnaBalAgents -nthreads 40 #tpoolagents $Ljobs $dbR close exit } proc ThrPfam {} { global db # clean #file delete -force {*}[glob /genomics/link/Pfam/PF*_smp] set db root sqlite3 $db bench.sql # Nettoyage Pfam si besoin est set Lf [glob -nocomplain "/genomics/link/Pfam/*_smp"] if {$Lf != {} } { file delete -force {*}$Lf } puts "inits and cleaning done ..." # define jobs 2 do $db eval {begin transaction} set Lpfamid [lsort -unique -dictionary [$db eval {select pfamid from pdbmap}]] set Ljobs [list] foreach pf $Lpfamid { set pk_pfam [$db eval {select pk_pfam from pfam where pfamid=$pf}] set Lpdb2id [$db eval {select pk_pdbmap,id from pdbmap where pfamid=$pf}] set fpfam [glob [file join /genomics/link/Pfam "${pf}*"]] set Largs [list $pk_pfam $fpfam $Lpdb2id] lappend Ljobs [list $pf $Largs] } $db eval {commit} Thr_Submit -joblist $Ljobs -proccreate Tcree -procexe Texe -procresults Tresults -nthreads 100 $db close exit } proc ThrSco {} { global db package require Thread set db root sqlite3 $db bench.sql #set Ljobs [BCM_CreateJobs2Do_Tests PF01239] set Ljobs [BCM_CreateJobs2Do_Tests] Thr_Submit -joblist $Ljobs -proccreate Tcree -procexe ScoreExe -procresults ScoreResults -nthreads 22 $db close exit } proc Thr_CreateJobs2Do {} { global DThr dres # - liste jobs2do set Lval [set DThr(JobList)] if {$DThr(Limit) == -1} { set DThr(Limit) [llength $Lval] } set Lval [lrange $Lval 0 $DThr(Limit)-1] puts "Nbr of jobs to do : [llength $Lval]" $dres eval {begin transaction} foreach e $Lval { lassign $e job par $dres eval {insert into tests values (NULL,$job,$par,'-1',0)} } $dres eval {create index idx_tests on tests (job,thread)} $dres eval {commit} return $Lval } proc Thr_CreeThread {} { global TDT DThr set scr [info body $DThr(ProcCreate)] set body [info body MyPuts] set CreateIt " global MyLog VueEditee set MyLog {} set VueEditee 0 proc MyPuts {args} {$body} #package require profiler #::profiler::init $scr Thr_Setup set cmdIn \[info commands\] set VariablesAuDepart \[info globals\] rename puts oldputs rename MyPuts puts after 1000 " set Id [thread::create] set retour $Id set TDT($Id) $Id trace add variable TDT($Id) write Thr_RecupResults thread::preserve $Id thread::configure $Id -unwindonerror 1 -eventmark 1 set done "" set ret [thread::send $Id $CreateIt] #vwait done puts "done $done $ret" puts "thread $Id created ([llength [thread::names]]) ...\n" return $retour } proc Thr_DonneUnJob {lId} { global CestFini TDT dres db DThr set pkmin [$dres eval {select min(pk_tests) from tests where thread='-1'}] if {! [string is integer -strict $pkmin]} { puts "\nAll done !\nReleasing threads ...\n" flush stdout #thread::send $lId {thread::release} thread::release $lId if {[llength [thread::names]] == 1} { set CestFini 1 } return } set params [$dres eval {select job,args from tests where pk_tests=$pkmin}] lassign $params job Largs set TDT($lId,Data) [list $job $Largs] $dres eval {update tests set thread=$lId where pk_tests=$pkmin} update idletasks #parray TDT #puts "after info [after info]" #flush stdout update idletasks after 1000 thread::send -async $lId [list ::Thr_ThreadExe $DThr(ProcExe) $job $Largs] TDT($lId) return } proc Thr_DonneUnJobNoThr {} { global CestFini TDT dres db DThr set pkmin [$dres eval {select min(pk_tests) from tests where thread='-1'}] if {! [string is integer -strict $pkmin]} { puts "\nAll done !\nReleasing threads ...\n" flush stdout return 0 } set params [$dres eval {select pk_tests,job,args from tests where pk_tests=$pkmin}] lassign $params pktest job Largs $dres eval {update tests set thread='1' where pk_tests=$pkmin} set TDT(job,Data) [list $job $Largs] return [list $job $Largs] } proc Thr_RecupResults {a b op} { global TDT dres DThr update idletasks after 1000 set tid $b set pkt [$dres eval {select pk_tests from tests where thread=$tid}] set Lres [set TDT($b)] #set Larg [set TDT($tid,Data)] # if thread is in error if {[string range $Lres 0 4] ne "tid0x" || ! [string is list -strict $Lres]} { # on est en train de traiter une erreur !! puts "==> $b : $Lres\n$::errorInfo" flush stdout after 1000 trace remove variable TDT($tid) write Thr_RecupResults update idletasks if {[thread::exists $tid]} { set scr " global MyLog rename ::puts ::MyPuts rename ::oldputs ::puts puts \[join \$MyLog \n\] flush stdout " thread::send $tid $scr catch {thread::release $tid} } array unset TDT "${tid}*" # met le job du thread à -1 $dres eval {update tests set res=-1,thread=0 where pk_tests=$pkt} set Larg "prout" puts "Leave on error\n$pkt $Larg [llength [thread::names]]" set b [Thr_CreeThread] Thr_DonneUnJob $b return } lassign $Lres Id job Lval if {$b ne $Id} { puts "\nProblem\n$b ne $Id !" flush stdout set b $Id } # Treat result set LErr [$DThr(ProcResults) $pkt $job $Lval] set ires 1 if {$LErr != {} } { puts "\nProblem $b !\npkt $pkt\nLval\n[join $Lval \n]Error : [join $LErr \n]\n" set ires -1 } $dres eval {update tests set res=$ires,thread='0' where pk_tests=$pkt} incr DThr(nDone) if {! ($DThr(nDone) % 1000)} { puts "... $DThr(nDone) done ([llength [thread::names]]) [DonneDateEtHeure]" flush stdout } set scr { global MyLog #rename ::puts ::MyPuts #rename ::oldputs ::puts set out "\nLog [thread::id]\n" foreach l $::MyLog { append out "$l\n" } puts "$out" flush stdout set MyLog {} rename ::puts ::oldputs rename ::MyPuts ::puts } #thread::send $b $scr Thr_DonneUnJob $b return } proc Thr_Setup {} { global DThr set DThr(Threaded) 1 set DThr(nThreads) 20 set DThr(Limit) -1 set DThr(nDone) 0 set DThr(TableTests) " - tests : tests a faire { . pk_tests P . job V32 . args T methodes scoring . thread V32 . res I -1 error, 0 pas fait, 1 ok } " return } proc Thr_Submit {args} { global DThr dres package require Thread Thr_Setup Thr_VerifArgs {*}$args puts "[DonneDateEtHeure]" set DThr(TMaster) [thread::id] puts "\nThread Master : $DThr(TMaster)\n" set CestFini 0 file delete -force dres.sql #set dres [FabriqueDeTables $DThr(TableTests) memory] set dres [FabriqueDeTables $DThr(TableTests) dres.sql] # creation des jobs Thr_CreateJobs2Do #CorrectifDres # Creation des threads et preserved set listeID [list] thread::errorproc Thr_ThreadError for {set i 1} {$i<$DThr(nThreads)} {incr i} { set Id [Thr_CreeThread] lappend ListeThreadID $Id } update idletasks puts "" puts "[DonneDateEtHeure]" puts "Start working ...\n" foreach Id $ListeThreadID { Thr_DonneUnJob $Id } # lance l'event loop du master vwait CestFini foreach a [array names TDT "tid*"] { if {[regexp {,} $a]} {continue} puts "trace $a [join [trace info variable $a] \n]" } # Stat glob on jobs puts "\n" puts "====================================" puts "Jobs ...... : [$dres eval {select count(pk_tests) from tests}]" puts "Successfull : [$dres eval {select count(pk_tests) from tests where res = 1}]" puts "Failed .... : [$dres eval {select count(pk_tests) from tests where res = -1}]" puts "" $dres backup dres_bak.sql $dres close puts "[DonneDateEtHeure]" return } proc Thr_SubmitNoThr {args} { global DThr dres Thr_Setup Thr_VerifArgs {*}$args set DThr(Threaded) 0 puts "[DonneDateEtHeure]" file delete -force dres.sql set dres [FabriqueDeTables $DThr(TableTests) dres memory] # creation des jobs Thr_CreateJobs2Do #CorrectifDres set ::DebVerif 1 while {[set Ljar [Thr_DonneUnJobNoThr]] != 0} { lassign $Ljar job Largs set pkt [$dres eval {select pk_tests from tests where thread='1'}] puts "\n$job - $pkt - $Largs" set Lval [$DThr(ProcExe) $Largs] set LErr [$DThr(ProcResults) $pkt $job $Lval] set ires 1 if {$LErr != {} } { puts "\nProblem !\npkt $pkt job $job\nLval\n[join $Lval \n]\nErreur : [join $LErr \n]\n" set ires -1 } $dres eval {update tests set res=$ires,thread='0' where pk_tests=$pkt} incr DThr(nDone) if {! ($DThr(nDone) % 1000)} { puts "... $DThr(nDone) done ([llength [thread::names]]) [DonneDateEtHeure]" flush stdout } } # Stat glob on jobs puts "\n" puts "====================================" puts "Jobs ...... : [$dres eval {select count(pk_tests) from tests}]" puts "Successfull : [$dres eval {select count(pk_tests) from tests where res = 1}]" puts "Failed .... : [$dres eval {select count(pk_tests) from tests where res = -1}]" puts "" $dres backup dres.sql $dres close puts "[DonneDateEtHeure]" return } proc Thr_ThreadError {tid stack} { global TDT dres DThr if {$tid eq $DThr(TMaster)} { puts "\nMASTER Error $tid\n$stack\n" if {[info exists ::errorInfo]} { puts "$::errorInfo" } flush stdout return } set pkt [$dres eval {select pk_tests from tests where thread=$tid}] set Larg [set TDT($tid,Data)] puts "\nError in thread $tid\npktest $pkt, args $Larg\n$stack" trace remove variable TDT($tid) write Thr_RecupResults after 100 if {[thread::exists $tid]} { puts "... deleting thread $tid" set scr " global MyLog rename ::puts ::toto rename ::oldputs ::puts puts \[join \$::MyLog \n\] flush stdout thread::release $tid " thread::send $tid $scr } array unset TDT "${tid}*" # met le job du thread à -1 $dres eval {update tests set res=-1,thread=0 where pk_tests=$pkt} if {[llength [thread::names]] < $DThr(nThreads)} { set Id [Thr_CreeThread] after 1000 update idletasks Thr_DonneUnJob $Id } return } proc Thr_ThreadExe {scr job Largs} { if {$::DThr(Threaded)} { set tid [thread::id] } else { set tid "tid0xturlulu" } #::profiler::reset set Lout [$scr $Largs] #AfficheProfileResults set LRT [list $tid $job $Lout] return $LRT } proc Thr_Usage {} { puts "Arguments :" puts " -joblist " puts " -proccreate " puts " -procexe " puts " -procresults " puts "\nOpetional :" puts " -nthreads " puts " -limit " puts "" return } proc Thr_VerifArgs {args} { global DThr if {[llength $args] < 8} { Thr_Usage exit } foreach {k v} $args { switch $k { "-joblist" { if {! [string is list -strict $v]} { puts "Error ! jobList is not a proper list !\n" exit } set DThr(JobList) $v } "-proccreate" { set DThr(ProcCreate) $v } "-procexe" { set DThr(ProcExe) $v } "-procresults" { set DThr(ProcResults) $v } "-nthreads" { if {! [string is integer -strict $v] || $v <= 0} { puts "Error ! Invalid number of threads !" exit } set DThr(nThreads) $v } "-limit" { if {! [string is integer -strict $v] || $v <= 0} { puts "Error ! Invalid limit !" exit } set DThr(Limit) $v } default { puts "unknown keyword $k\nIgnored" } } } if {$DThr(nThreads) > [llength $DThr(JobList)]} { set DThr(nThreads [llength $DThr(JobList)] } return } proc ThreadedBlastService {Ljobs} { package require Thread set program { set OrdaliDejaSource 1 set GscopeDir $env(GSCOPEDIR) source [file join $GscopeDir gscope_source.tcl] set OrdaliDir $env(ORDALIDIR) set OrdaliDejaSource 0 source [file join $OrdaliDir src ordali_source.tcl] package require Thread set VariablesAuDepart [info globals] InitLesDefauts LesDefauts OnlyTLog 1 LesDefauts Mode batch } # Create a pool of threads and initialize them with our code set poolid [tpool::create -maxworkers 20 -initcmd $program] # Create a number of job requests and # submit the jobs to the pool. # We keep an id for each job so we can # track when they complete set jids {} foreach Largs $Ljobs { set id [tpool::post -nowait $poolid [list BlastService {*}$Largs]] lappend jids $id set iq [lsearch $Largs "-query"] set query [lindex $Largs $iq+1] # is query a fasta ? if {[string first "\n" $query] != -1} { set query [lindex [split $query \n] 0] } set io [lsearch $Largs "-orga"] if {$io == -1} { set orga "none" } else { set orga [lindex $Largs $io+1] } lappend Tj(Lid) $id set Tj($id,Largs) $Largs set Tj($id,Input) [list $query $orga] set Tj($id,query) $query set Tj($id,Res) "" set Tj($id,nTimes) 0 } # Wait for the jobs we submitted to complete. # Collect the results and remove completed jobs # from the set of job ids so that we can # wait on the running jobs each time around the outer loop. set limit 0 set maxlim [expr {5*[llength $jids]}] set nDone 0 set nInit [llength $jids] while {[llength $jids] > 0 && $limit < $maxlim} { if {! ($nDone % 10)} { puts [format "%d done ..." $nDone] flush stdout } set done [tpool::wait $poolid $jids] # check finished jobs foreach id $done { set Tj($id,Res) [tpool::get $poolid $id] if {$Tj($id,Res) eq "ServerError" && $Tj($id,nTimes) < 5} { puts "----------------------" puts "Server Error !" puts "Args : $Tj($id,Largs)" puts "----------------------" flush stdout update idletasks incr Tj($id,nTimes) set newid [tpool::post -nowait $poolid [list BlastService {*}$Tj($id,Largs)]] lappend jids $newid foreach k [array names Tj "$id,*"] { lassign [split $k ,] tmp key set Tj($newid,$key) $Tj($k) } array unset Tj "$id,*" } set ndx [lsearch -exact $jids $id] if {$ndx != -1} { set jids [lreplace $jids $ndx $ndx] update } } incr limit set nDone [expr {$nInit - [llength $jids]}] } if {$limit >= $maxlim} { puts "hit limit"} # Clean up and report tpool::release $poolid return [array get Tj] } proc Thrombin {} { return "CTGGTGCCACGCGGTTCT" } proc ThrombinOld {} { return "CTGGTGCCGCGCGGCAGC" } proc TiltArbre {AId ref n ang} { global Abr set t [set Abr(Arbre,$AId)] set x [$t get $ref xcoord] set y [$t get $ref ycoord] set Ld [concat $ref $n [$t descendants $n]] foreach d $Ld { set xd [$t get $d xcoord] set yd [$t get $d ycoord] set Lxy [TourneBoite $x $y $xd $yd $ang] lassign $Lxy xE yE if {0 && $ref eq "root"} { puts [format "xi %6.3f xf %6.3f | yi %6.3f yf %6.3f | %s" $xd $xE $yd $yE $d] } $t set $d xcoord $xE $t set $d ycoord $yE foreach a {oldtheta theta LeftL LeftR RightR RightL LeftA RightA} { if {[$t keyexists $d $a]} { set Adep [$t get $d $a] set Afin [expr {$Adep+$ang}] set Afin [expr {$Afin >= [2Pi]?$Afin-[2Pi]:$Afin}] set Afin [expr {$Afin <= [2Pi]?$Afin+[2Pi]:$Afin}] set Afin [expr {$Afin < 0.?$Afin+[2Pi]:$Afin}] $t set $d $a $Afin } } } return } proc Timer {Programme {Tic 1000}} { if {[info exists $TicCounter] } { incr TicCounter } else { set TicCounter 1 } if { $Tic = $TicCounter } { Espionne "$Programme : $Tic traites" set Tic 0 } } proc TissueTypesGeneraux {TissueType {LesTissuesImportants ""}} { foreach TissueImportant $LesTissuesImportants { set TissueImportant [string toupper $TissueImportant] set TabTmp($TissueImportant) 1 } if {[regexp -nocase {leptotene|spermat|epididymis|gonad|mullerian|genital|mesonephros|ovary|oviduct|sertoli|testis|uterus|vagin|zygoten|vesicular gland} $TissueType]} { set TissueType "REPRODUCTION" } elseif {[regexp -nocase {pituitary} $TissueType]} { set TissueType "PITUARY GLAND" } elseif {[regexp -nocase {adrenal|hypothalam|langerhans|pancrea} $TissueType]} { set TissueType "ENDOCRINE SYSTEM" } elseif {[regexp -nocase {gland|rathke|saliv} $TissueType]} { set TissueType "GLAND" } elseif {[regexp -nocase {retin|eye|optic|lens} $TissueType]} { set TissueType "EYE" } elseif {[regexp -nocase {hippocamp|cortex|brain|cerebel|neural|cerebral|corpora quadrigemina|corpus striatum|medulla oblongata|postrema|subfornical} $TissueType]} { set TissueType "BRAIN" } elseif {[regexp -nocase {bone marrow|hematopoiet|aorta|vein} $TissueType]} { set TissueType "BLOOD" } elseif {[regexp -nocase {bone|maxilla|osteoblast|cartilage|cranio|mandibl|joints} $TissueType]} { set TissueType "BONE" } elseif {[regexp -nocase {amnion|blastocy|branchial arches|endoderm|embryo|gastrula|blastul|placent|egg|fetus|mesenchym|notochord|primitive|trophoblast|es cell|diencephal} $TissueType]} { set TissueType "EMBRYO" } elseif {[regexp -nocase {spinal|cord} $TissueType]} { set TissueType "CNS" } elseif {[regexp -nocase {adipose} $TissueType]} { set TissueType "FAT TISSUE" } elseif {[regexp -nocase {bowel|cecum|colon|intestin|isthmal|stomach|tongue|jejunal} $TissueType]} { set TissueType "GASTROINTESTINAL TRACK" } elseif {[regexp -nocase {lymph|spleen|b cell|macrophage|nk cell|sympathetic ganglion|tcell|thymus} $TissueType]} { set TissueType "IMMUNE SYSTEM" } elseif {[regexp -nocase {carcino|cancer|tumor|melanom|metastat} $TissueType]} { set TissueType "TUMOR" } elseif {[regexp -nocase {wolffian|bladder|kidney} $TissueType]} { set TissueType "URINARY TRACK" } elseif {[regexp -nocase {olfactory} $TissueType]} { set TissueType "NEUROSENSORY SYSTEM" } elseif {[regexp -nocase {inner ear} $TissueType]} { set TissueType "INNER EAR" } elseif {[regexp -nocase {lung} $TissueType]} { set TissueType "LUNG" } elseif {[regexp -nocase {liver} $TissueType]} { set TissueType "LIVER" } elseif {[regexp -nocase {cardiac|heart} $TissueType]} { set TissueType "HEART" } elseif {[regexp -nocase {diaphragm|muscle} $TissueType]} { set TissueType "MUSCLE" } elseif {[regexp -nocase {skin} $TissueType]} { set TissueType "SKIN" } else { set TissueType "OTHER" } if {$LesTissuesImportants != {} && ![info exists TabTmp($TissueType)]} {return "OTHER"} return $TissueType } proc Title2HTML {aT} { upvar $aT tbl Html_Append "

" Html_Append "

$tbl(Title)

" Html_Append "

" return } proc Title2Text {aT} { upvar $aT tbl global TextOut lappend TextOut "$tbl(Title)" lappend TextOut [string repeat = [string length $tbl(Title)]] return } proc TkH {} { global GscopeDir # NouveauPack set w [AfficheFichier "$GscopeDir/gscope.tcl"] QueFontLesBoutonsDe $w EspionneL [$w.frame.list get 0 end] } proc Tlts {} { set L [list [list 60. 40. 0.] [list 60. 35. 5.] [list 60. 30. 10.] [list 55. 5. 40.] [list 60. 20. 20.] [list 60. 25. 15.] [list 55. 10. 35.] [list 65. 0. 35.] [list 65. 5. 30.] [list 65. 10. 25.] [list 65. 15. 20.]] set Ls [list] foreach e $L { lassign $e g n p set m2 [expr {($g*$g + $n*$n + $p*$p)/3.}] set s [expr {sqrt($m2 - (100./3.)**2)}] set gn [expr {abs($g - $n)}] set gp [expr {abs($g - $p)}] set np [expr {abs($n - $p)}] set ss [expr {($gn + $gp + $np)/3.}] lappend Ls [list $s $ss $g $n $p $gn $gp $np] } set fmt "%5.2f %5.2f %5.2f %5.2f %5.2f" set Ls [lsort -real -index 0 $Ls] foreach e $Ls { lassign $e std sgnp g n p gn gp np puts [format $fmt $std $sgnp $g $n $p] } puts "" set Ls [lsort -real -index 1 $Ls] foreach e $Ls { lassign $e std sgnp g n p gn gp np puts [format $fmt $std $sgnp $g $n $p] } puts "" set Ls [lsort -command TrieDoubles -increasing $Ls] foreach e $Ls { lassign $e std sgnp g n p gn gp np puts [format $fmt $std $sgnp $g $n $p] } puts "" exit } proc TmMoyenDesSequences {{Liste ""}} { Wup "Permet de calculer la moyenne des Tm de plusieurs sequences" if {$Liste==""} { #set Liste [ListeTest] #set Liste [list ACT0001 ACT0010] set Liste [ListeDesPABs] } set RepmRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" set Repnuctfa "[RepertoireDuGenome]/nuctfa" set TmMoyenne 0.0 set nbTm 0 set TmTotal 0.0 foreach PAB $Liste { set Tm "" set LaSeq "" set FichierQuery $PAB if {[file exists $FichierQuery]} { set FichierQuery $FichierQuery } elseif { [file exists "$RepmRNA/$PAB"]} { set FichierQuery "$RepmRNA/$PAB" } elseif {[file exists "$Repnuctfa/$PAB"]} { set FichierQuery "$Repnuctfa/$PAB" } else { continue } set LaSeq [QueLaSequenceDuFichierTFA $FichierQuery] if {$LaSeq==""} {Espionne "$FichierQuery no sequence available";continue} set Tm [CalculTmDeLaSeq $LaSeq "" "" "NearestNeighbor"] if {$Tm=="-1"} {continue} elseif {$Tm==""} {continue} set TmTotal [expr $TmTotal+$Tm] incr nbTm } set TmMoyenne [expr $TmTotal/$nbTm] return "$TmMoyenne" } proc TmPanel {LeCanvasPere} { Wup "Panel de choix d affichage et de couleur du graphes du meilleur Tm" set LesGraphes [LesGraphesDeLOligo $LeCanvasPere] if {$LesGraphes==""} {return ""} set GrapheTopLevel "$LeCanvasPere.besttmgraphe" if {[winfo exists $GrapheTopLevel]} { wm deiconify $GrapheTopLevel raise $GrapheTopLevel return "" } else {toplevel $GrapheTopLevel} wm geometry $GrapheTopLevel +300+100 wm title $GrapheTopLevel "Best Tm Selection" wm resizable $GrapheTopLevel false false set FrameGraphe "$GrapheTopLevel.besttmframe" frame $FrameGraphe -borderwidth "3" -relief "groove" pack $FrameGraphe -expand "true" -side "top" -fill "both" set NbGraph [llength $LesGraphes] set NbRow 0 set IndGraph 0 foreach Graphe $LesGraphes { incr IndGraph incr NbRow set TagOrId $Graphe set Graphe [string tolower $Graphe] set PetiteFrameGraphe "$FrameGraphe.f$Graphe" set LGraph "$PetiteFrameGraphe.l$Graphe" set BGrOn "$PetiteFrameGraphe.bgon$Graphe" set BGrOff "$PetiteFrameGraphe.bgoff$Graphe" set BMoyOn "$PetiteFrameGraphe.bmoyon$Graphe" set BMoyOff "$PetiteFrameGraphe.bmoyoff$Graphe" set BColor1 "$PetiteFrameGraphe.bcolor1$Graphe" set BColor2 "$PetiteFrameGraphe.bcolor2$Graphe" frame $PetiteFrameGraphe -borderwidth "0" -relief "groove" label $LGraph -text "$TagOrId" -padx "2" -borderwidth "3" -relief "groove" -background "orange" button $BGrOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere ${TagOrId}Lines" button $BGrOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere ${TagOrId}Lines" button $BMoyOn -text "On" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Raiser $LeCanvasPere ${TagOrId}Plot" button $BMoyOff -text "Off" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -command "Lower $LeCanvasPere ${TagOrId}Plot" button $BColor1 -text "Color" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -background deepskyblue2 -command "LePanneauDeCouleursDuGraph $BColor1 $LeCanvasPere ${TagOrId}Lines" button $BColor2 -text "Color" -anchor "center" -padx "3" -borderwidth "2" -relief "groove" -background deepskyblue2 -command "LePanneauDeCouleursDuGraph $BColor1 $LeCanvasPere ${TagOrId}Plot" grid $PetiteFrameGraphe -sticky ewns grid $LGraph -row $NbRow -column 0 -sticky ewns -rowspan 2 grid $BGrOn -row $NbRow -column 1 -sticky ewns grid $BGrOff -row $NbRow -column 2 -sticky ewns grid $BMoyOn -row $NbRow -column 3 -sticky ewns grid $BMoyOff -row $NbRow -column 4 -sticky ewns incr NbRow grid $BColor1 -row $NbRow -column 1 -sticky ewns -columnspan 2 grid $BColor2 -row $NbRow -column 3 -sticky ewns -columnspan 2 if {$IndGraph==1} { set DismissB "$PetiteFrameGraphe.destroybutton" set LDuGraph "$PetiteFrameGraphe.ldugraph" set LDuMoyenne "$PetiteFrameGraphe.ldumoyenne" button $DismissB -text "Exit" -anchor "center" -padx "3" -background "red" -borderwidth "2" -relief groove -activebackground "red" -overrelief "sunken" -command "destroy $GrapheTopLevel" label $LDuGraph -text "Lines" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief groove label $LDuMoyenne -text "Plot" -anchor "center" -padx "2" -background "#808FFF" -borderwidth "3" -relief groove grid $DismissB -row 0 -column 0 -sticky ewns grid $LDuGraph -row 0 -column 1 -sticky ewns -columnspan 2 grid $LDuMoyenne -row 0 -column 3 -sticky ewns -columnspan 2 } if {$IndGraph==$NbGraph} { set LAllDuGr "$PetiteFrameGraphe.lalldugraph" set BAllGrOn "$PetiteFrameGraphe.ballgon" set BAllGrOff "$PetiteFrameGraphe.ballgoff" label $LAllDuGr -text "Both" -anchor "center" -padx "2" -relief "groove" -background "green3" -borderwidth "3" button $BAllGrOn -text "On" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Raiser $LeCanvasPere OligoGraph" button $BAllGrOff -text "Off" -anchor "center" -padx "3" -relief "groove" -background "yellow" -borderwidth "2" -command "Lower $LeCanvasPere OligoGraph" incr NbRow grid $LAllDuGr -row $NbRow -column 0 -sticky ewns grid $BAllGrOn -row $NbRow -column 1 -sticky ewns -columnspan 2 grid $BAllGrOff -row $NbRow -column 3 -sticky ewns -columnspan 2 } grid columnconfigure $PetiteFrameGraphe 0 -weight 1 grid columnconfigure $PetiteFrameGraphe 1 -weight 0 grid columnconfigure $PetiteFrameGraphe 2 -weight 0 grid columnconfigure $PetiteFrameGraphe 3 -weight 0 grid columnconfigure $PetiteFrameGraphe 4 -weight 0 } return "" } proc TmpDecortiqueUnPDB {Fichier toto {LaMolId ""}} { if {[llength $Fichier] == 1} { if {! [regsub {\.} $Fichier "" tmp]} { set lignes [RecupereUnFichierSurWeb $Fichier] } else { set lignes [LesLignesDuFichier $Fichier] } } else { set lignes $Fichier } set MolId [string range $LaMolId 0 3] set lignesPDB [ExtraitLignesAtomesDuPDB $lignes] if {$MolId == ""} {set MolId [file rootname [file tail $Fichier]]} # set Header [ExtraitHeadDuPDB $lignes] # set PDB_[set MolId]_Header $Header if {$lignesPDB == -1} {return 0} set ChaineCourant -1 set NomResCourant "" set ResiduCourant -999 set CC "" set PremRes 1 set Latmn {} set Latmx {} set Latmb {} set fmt "%*13s%4s%*1s%3s%*1s%1s%4d%24s%12s" foreach ligne $lignesPDB { set ee " $ligne" if {$toto} { set AtomName [string range $ee 13 16] set ResidueName [string range $ee 18 20] set ChainIdent [string range $ee 22 22] if {$ChainIdent == " "} {set ChainIdent "a"} scan [string range $ee 23 26] "%d" ResidueNumber set AtomXYZ [string range $ee 31 54] set AtomBQ [string range $ee 55 66] } else { scan $ee $fmt AtomName ResidueName ChainIdent ResidueNumber AtomXYZ AtomBQ if {$ChainIdent == " "} {set ChainIdent "a"} } if {$ResiduCourant == -999} { set ResiduCourant $ResidueNumber set NomRes1L [AutreCodeLuc $ResidueName] set CC $ChainIdent } if {$ResidueNumber != $ResiduCourant} { set NomRes1L [AutreCodeLuc $ResidueName] if {! [string equal $NomResCourant "XXX"]} { lappend PDB_[set MolId]_NomRes($CC) $NomResCourant lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb set Latmn {} set Latmx {} set Latmb {} lappend Latmx $AtomXYZ lappend Latmb $AtomBQ lappend Latmn $AtomName } if { ! [string equal $ChainIdent $ChaineCourant]} { lappend PDB_[set MolId]_ChnIdn $ChainIdent set ChaineCourant $ChainIdent set CC $ChainIdent } } lappend Latmx $AtomXYZ lappend Latmb $AtomBQ lappend Latmn $AtomName set ResiduCourant $ResidueNumber set NomResCourant $NomRes1L } # lappend PDB_[set MolId]_ChnIdn $ChainIdent if {$NomResCourant != "XXX"} { lappend PDB_[set MolId]_NomRes($CC) $NomResCourant lappend PDB_[set MolId]_NmrRes($CC) $ResiduCourant lappend PDB_[set MolId]_NomAtm($CC) $Latmn lappend PDB_[set MolId]_AtmXYZ($CC) $Latmx lappend PDB_[set MolId]_AtmBQ($CC) $Latmb } # set lsite [ExtraitSiteActifDuPDB $Header] # if {$lsite != {}} {array set PDB_[set MolId]_Site $lsite} return 1 } proc TmpFile {{Racine ""} {Rep ""} {Sep ""} {WithDate ""}} { global TmpFileNumber if {[regexp -nocase "Date" $Sep]} { set WithDate $Sep ; set Sep "" } set TestUniqueRoot [regexp -nocase "UniqueRoot" $WithDate] set WithDate [regexp -nocase "WithDate" $WithDate] if {$Rep=="envTEMP"} { global env if {[info exists env(TEMP)]} { set Rep [set env(TEMP)] } else { set Rep "" } } set MemoSep $Sep if {$Sep==""} { set Sep "." } if {[regexp "NoSep" $Sep]} { set Sep "" } if {$Rep==""} { set Rep [RepertoireDeTravail] } regsub -all {/*$} $Rep "" Rep if { ! [info exists TmpFileNumber]} { set TmpFileNumber 0 } if {$Racine==""} { set Racine "tmp" } if {$WithDate} { set Date [Date "Seconds"] set TmpFileName "$Rep/$Racine$Sep$Date" if {$TestUniqueRoot && [glob -nocomplain "$TmpFileName*"]!={}} { after 1000 return [TmpFile $Racine $Rep $MemoSep "WithDateAndUniqueRoot"] } return $TmpFileName } set Pid [pid] incr TmpFileNumber set TmpFileName "$Rep/$Racine$Sep$Pid$Sep$TmpFileNumber" return $TmpFileName } proc ToBeOrthologue {Nom {PlusMinusOrgas ""}} { global ToBeOrthologue if {[info exists ToBeOrthologue($PlusMinusOrgas)]} { if {[info exists ToBeOrthologue($Nom)] } { return [set ToBeOrthologue($Nom)] } else { return 0 } } if {[info exists ToBeOrthologue]} { unset ToBeOrthologue } LaListeToBeOrthologue $PlusMinusOrgas if {[info exists ToBeOrthologue($Nom)] } { return [set ToBeOrthologue($Nom)] } else { return 0 } } proc Today {} { return [clock format [clock seconds] -format "%A %d %B %Y"] } proc Toggle {SaVariable} { upvar $SaVariable MaVariable set MaVariable [expr ! $MaVariable] return $MaVariable } proc ToggleAllOff {} { global StrucAVoir pgl set fobj $pgl(frObjc) foreach e $StrucAVoir { lassign $e nc f set nom [DonneIdDeAccessPDB $nc] set t [$fobj.f${nom}.b0 cget -text] if {[string index $t 0] eq "-"} { $fobj.f${nom}.b0 invoke } } return } proc ToggleAuLog {{Init ""}} { global wtlog Toggle if {$Init ne ""} { set Toggle(AuLog) $Init if {! $Init} { if {[info commands AuLogText] ne ""} { rename AuLogText AuLog } } else { if {[info commands AuLogWindow] ne ""} { rename AuLogWindow AuLog } } return } set Toggle(AuLog) [expr {! $Toggle(AuLog)}] if {$Toggle(AuLog)} { rename AuLog AuLogText rename AuLogWindow AuLog AuLog } else { rename AuLog AuLogWindow rename AuLogText AuLog DetruitLogConsole destroy } return } proc ToggleCanva {K Tag} { global Action global CouleurDuFond if { ! [info exists Action]} { set Action "raise" } if { $Action == "raise" } { set Action "lower" set Couleur $CouleurDuFond } else { set Action "raise" set Couleur "black" } $K itemconfigure $Tag -fill $Couleur $K $Action $Tag } proc ToggleCouleursResidues {args} { global Toggle NomTextSeq if {[TypeAli] eq "pasdali"} {return} if {[QuelMode] eq "seqlab"} {return} set Ldtags [EditorMappingData] $NomTextSeq configure -state normal if {! $Toggle(ColRes)} { set Toggle(ColRes) 1 $NomTextSeq configure -background DimGray set lt [$NomTextSeq tag names] if {"TagA" ni $lt} { foreach def $Ldtags { lassign $def n f b $NomTextSeq tag configure Tag$n -background $b -foreground $f } } FaireAttendre "Please wait ...\nColoring according to residues types ..." BindModeColors TagLaFenetre FaireLaSuite } else { set Toggle(ColRes) 0 $NomTextSeq configure -background white set Ltodel [list] foreach c $Ldtags { lassign $c n f b lappend Ltodel "Tag$n" } $NomTextSeq tag delete {*}$Ltodel BindModeNormal } $NomTextSeq configure -state disabled return } proc ToggleFeature {} { global FrmBouton NomFenetreOrdali Toggle if {[QuelMode] ni [list "feature" "ordali"] && [TypeAli] eq "pasdali"} { set Toggle(Feature) [expr {! $Toggle(Feature)}] return } if {$Toggle(Feature)} { grid $FrmBouton -row 5 -column 0 -padx 10 -pady 10 -sticky news } else { grid forget $FrmBouton } FenetreAuCentre [winfo toplevel $NomFenetreOrdali] update idletasks return } proc ToggleFullScreen {} { global GeomNormal Defauts NomFenetreOrdali #puts "TogglefullScreen" set top [winfo toplevel $NomFenetreOrdali] wm withdraw $top set Etat [wm attributes $top -fullscreen] puts "toplevel $top Etat $Etat Def [set Defauts(FullScreen)]" #set Defauts(FullScreen) [expr {! [set Defauts(FullScreen)]}] set Etat [expr {! $Etat}] if {$Etat} { puts "Full Screen" set GeomNormal [wm geometry $top] puts " GeomNormal $GeomNormal" set xw [winfo screenwidth $top] set xh [winfo screenheight $top] puts " $xw $xh" #wm maxsize $top $xw $xh #wm minsize $top $xw $xh #wm overrideredirect $top 1 #wm attributes $top -fullscreen 1 wm attributes $top -fullscreen 1 puts " New [wm geometry $top]" } else { puts "Normal" set geom [string map [list + " " - " " x " "] $GeomNormal] lassign [split $geom " "] w h x y #wm overrideredirect $top 0 #wm attributes $top -fullscreen 0 if {$x eq ""} {set x 0} if {$y eq ""} {set y 0} if {$w eq ""} {set w 0} if {$h eq ""} {set h 0} wm geometry $top +${x}+$y wm attributes $top -fullscreen 0 } wm deiconify $top update idletasks set Defauts(FullScreen) $Etat return } proc ToggleScores {{args ""}} { global Toggle LFeatCourantes NomFenetreOrdali FrmSequence Cons ListeTypesDeFeatures puts "toggleScores [info level 0]" catch {puts " -1 [info level -1]"} update switch [QuelMode] { "feature" { set Lft [lsearch -regexp -all -inline $ListeTypesDeFeatures {^Cons\-|^Score\-}] if {! [llength $Lft]} { set Toggle(Scores) 0 return } } "conservation" { set Toggle(Scores) [set Cons(Show)] set Lft [lindex [set Cons(ConsCou)] 0] if {$Lft eq "None"} { #return set Lft "" } } default return } #puts "Lft $Lft" if {[set Toggle(Scores)]} { if {[QuelMode] eq "feature"} { DessineLesScores foreach e $Lft { set w [BtnDeLaFeature $e] if {[EtatDuBouton $w]} { #puts "e= $e" DessineLesScores $e } } } elseif {[QuelMode] eq "conservation"} { DessineLesScores $Lft } } else { if {[winfo exists $FrmSequence.csc]} { grid forget $FrmSequence.csc destroy $FrmSequence.csc } } update idletasks FenetreAuCentre [winfo toplevel $NomFenetreOrdali] return } proc ToggleSecStr {} { if {! $::Defauts(AffSS)} { set ::Defauts(AffSS) 1 CacheStrSecDansAlignement } else { set ::Defauts(AffSS) 0 MontreStrSecDansAlignement } return } proc ToggleShowFrame {} { global pgl if {$pgl(showframe)} { grid forget $pgl(frInfo) grid forget $pgl(frCtrl) grid forget $pgl(frObjc) grid forget $pgl(frFonc) set pgl(showframe) 0 } else { grid $pgl(frInfo) -row 0 -column 0 -columnspan 3 -sticky ew grid $pgl(frCtrl) -row 1 -column 0 -columnspan 3 -sticky ew grid $pgl(frObjc) -row 2 -column 0 -sticky ns -pady 15 grid $pgl(frFonc) -row 2 -column 2 -sticky ns -pady 15 set pgl(showframe) 1 } FenetreAuCentre [winfo toplevel $pgl(wogl)] raise $pgl(wogl) update idletasks return } proc ToggleShowSeqFrame {} { global Defauts FrmMenu FrmToolBar FrmVues FrmScores FrmBouton FrmDebug if {! [set Defauts(ShowFrame)]} { grid forget $FrmMenu grid forget $FrmToolBar grid forget $FrmVues grid forget $FrmScores grid forget $FrmBouton grid forget $FrmDebug set Defauts(ShowFrame) 1 } else { grid $FrmMenu -row 0 -column 0 -padx 5 -sticky ew grid $FrmToolBar -row 1 -column 0 -sticky ew -padx 5 grid $FrmVues -row 2 -column 0 -sticky ew -padx 5 -pady {1 3} grid $FrmScores -row 4 -column 0 -sticky ew grid $FrmBouton -row 5 -column 0 -padx 10 -pady 10 -sticky news grid $FrmDebug -row 6 -column 0 -padx 10 -pady 5 set Defauts(ShowFrame) 0 } return } proc ToggleStepMode {} { set ::StepMode [expr {! $::StepMode}] puts "\n-> Step Mode : $::StepMode" return } proc ToggleTabBouton {w} { set Lw [split $w .] set mol [string range [lindex $Lw end-1] 1 4] set sea [join [lrange $Lw 0 end-1] .] set Lwo [lsearch -regexp -all -inline [winfo children $sea] "\.bto"] set Lwd [lsearch -regexp -all -inline [winfo children $sea] "\.btd"] set Lwe [lsearch -regexp -all -inline [winfo children $sea] "\.bte"] if {[string index [$w cget -text] 0] eq "-"} { $w configure -text "+ $mol" -foreground green1 if {$Lwo != {} } { grid forget {*}$Lwo grid forget {*}$Lwe grid forget {*}$Lwd } } else { $w configure -text "- $mol" -foreground yellow set c 1 foreach o $Lwo e $Lwe d $Lwd { # re-grid obj name button grid $o -row $c -column 0 -sticky w -pady 0 -ipady 0 -padx {10 0} grid $e -row $c -column 1 -sticky e -pady 0 -ipady 0 grid $d -row $c -column 2 -sticky e -pady 0 -ipady 0 incr c } } update idletasks $::pgl(wogl) postredisplay return } proc ToggleTaxArrow {w} { set Lt [$w gettags current] set n "" foreach t $Lt { if {[regexp {A[0-9]+} $t]} { set n [string range $t 1 end] set toSee $t break } } if {$n eq ""} { puts "pb n=>< . Lt >$Lt<" return } set ::Tx(Etat,$n) [expr {! $::Tx(Etat,$n)}] DrawTaxo $toSee return } proc ToggleTaxInternal {w} { set Lt [$w gettags current] set n "" foreach t $Lt { if {[regexp {(NI|RI)[0-9]+} $t]} { set n [string range $t 2 end] set toSee $t break } } # Etat = 0 means closed if {! $::Tx(Etat,$n)} { return } set NbI $::Tx(NbInt,$n) # Open/Close internal nodes if {! $::Tx(ShowInt,$n)} { # open it set do 1 } else { # close it set do 0 } set ::Tx(ShowInt,$n) $do for {set i 0} {$i <= $NbI} {incr i} { set c $::Tx(ChildD,$n) set ::Tx(ShowInt,$c) $do set n $c } update DrawTaxo $toSee return } proc ToggleTextePhylo {K {Qui Both}} { global ToggleTextePhylo if { ! [info exists ToggleTextePhylo($K)]} { set ToggleTextePhylo($K) "raise" } set Etat [set ToggleTextePhylo($K)] if {$Etat=="raise"} { set Etat "lower" } else { set Etat "raise" } if {$Qui=="Both" || $Qui=="Orga"} { $K $Etat "TexteOrga" } if {$Qui=="Both" || $Qui=="Rank"} { $K $Etat "TexteRang" } set ToggleTextePhylo($K) $Etat return $Etat } proc ToggleToolbar {} { global FrmToolBar if {! [winfo exists $FrmToolBar]} { AfficheBarreBoutons } else { set Le [winfo children $FrmToolBar] destroy {*}$Le grid forget $FrmToolBar destroy $FrmToolBar } return } proc ToggleWindowMode {{from ""}} { global pgl if {! $pgl(fscreen) } { SetFullScreenMode set pgl(fscreen) 1 } else { SetWindowMode set pgl(fscreen) 0 } FenetreAuCentre [winfo toplevel $pgl(wogl)] return } proc ToggleWindowMode_paul {} { if { $::gDemo(fullScreen) } { SetFullScreenMode .top set ::gDemo(fullScreen) false } else { SetWindowMode .top $::gDemo(winWidth) $::gDemo(winHeight) set ::gDemo(fullScreen) true } } proc Togl_CreateFonct {w} { global BUFSIZE selectBuffer pgl Rad set BUFSIZE 512 set selectBuffer [tcl3dVector GLuint $BUFSIZE] set pgl(FontBase) [$w loadbitmapfont] set pgl(FontBase) [$w loadbitmapfont] set ambient { 0.4 0.4 0.4 1.0 } set diffuse { 0.8 0.8 0.8 1.0 } set specular { 1.0 1.0 1.0 1.0 } # x,y,z,w if w=0 lumier a l'infini , 1 set position { 0.0 50.0 100.0 0.0 } set lmodel_ambient { 0.2 0.2 0.2 1.0 } set local_view { 0.0 } glClearColor 0.0 0.0 0.0 0.0 glDepthFunc GL_LEQUAL glEnable GL_DEPTH_TEST glLightfv GL_LIGHT0 GL_AMBIENT $ambient glLightfv GL_LIGHT0 GL_DIFFUSE $diffuse glLightfv GL_LIGHT0 GL_SPECULAR $specular glLightf GL_LIGHT0 GL_SHININESS 85. glLightfv GL_LIGHT0 GL_POSITION $position glLightModelfv GL_LIGHT_MODEL_AMBIENT $lmodel_ambient glLightModelfv GL_LIGHT_MODEL_TWO_SIDE 1.0 glLightModeli GL_LIGHT_MODEL_COLOR_CONTROL $::GL_SEPARATE_SPECULAR_COLOR #glLightModelfv GL_LIGHT_MODEL_LOCAL_VIEWER $local_view glEnable GL_LIGHTING glEnable GL_LIGHT0 glColorMaterial GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE glEnable GL_COLOR_MATERIAL glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR {1.0 1.0 1.0 1.0} glMaterialf GL_FRONT_AND_BACK GL_SHININESS 100. # Fog section glEnable GL_FOG set fogColor {0.0 0.0 0.0 0.0} glFogfv GL_FOG_COLOR $fogColor glFogi GL_FOG_MODE $::GL_EXP2 glFogf GL_FOG_DENSITY 0.02 glFogf GL_FOG_START 0.0 glFogf GL_FOG_END 10.0 glFogi GL_FOG_COORD_SRC $::GL_FOG_COORD glHint GL_FOG_HINT $::GL_NICEST glEnable GL_LINE_SMOOTH glHint GL_LINE_SMOOTH_HINT $::GL_NICEST glEnable GL_POLYGON_SMOOTH glHint GL_POLYGON_SMOOTH_HINT $::GL_NICEST glShadeModel $pgl(shadeModel) glEnable GL_RESCALE_NORMAL return } proc Togl_DisplayFonct {w} { glViewport 0 0 [$w width] [$w height] glClear [expr $::GL_COLOR_BUFFER_BIT | $::GL_DEPTH_BUFFER_BIT] glMatrixMode GL_MODELVIEW glLoadIdentity glTranslatef 0.0 0.0 [expr {-1. * $::Rad}] set mat [build_rotmatrix $::cQuat] glMultMatrixf $mat glTranslatef [expr {-1.0*$::pgl(xCen)}] [expr {-1.0*$::pgl(yCen)}] [expr {-1.0*$::pgl(zCen)}] EnvoieLesObjets AfficheDistances AfficheLabels glFlush $w swapbuffers return } proc Togl_ReshapeFonct {toglwin {w -1} {h -1}} { global pgl Rad # for tcl3d 0.5.0 set h [$toglwin height] set w [$toglwin width] if { $h == 0 } {set h 1} if { $w == 0 } {set w 1} set pgl(width) $w set pgl(height) $h if {$w > $h} { set pgl(ratioX) [expr {double($w)/$h}] set pgl(ratioY) 1.0 } else { set pgl(ratioY) 1.0 set pgl(ratioY) [expr {double($h)/$w}] } glViewport 0 0 $w $h set ratX $pgl(ratioX) set ratY $pgl(ratioY) set zoom $pgl(Zoom) set frontclip $pgl(frontclip) set backclip $pgl(backclip) glMatrixMode GL_PROJECTION glLoadIdentity glOrtho [expr {-$ratX*$zoom*($Rad+$pgl(xTra))}] [expr { $ratX*$zoom*($Rad-$pgl(xTra))}] [expr {-$ratY*$zoom*($Rad+$pgl(yTra))}] [expr { $ratY*$zoom*($Rad-$pgl(yTra))}] [expr {$pgl(backclip) +$pgl(zTra)}] [expr {$pgl(frontclip)+$pgl(zTra)}] glMatrixMode GL_MODELVIEW glLoadIdentity puts "reshape done ..." flush stdout $toglwin swapbuffers return } proc Tok {{TexteInitial ""}} { global ChaineTok global TokCourant if {$TexteInitial!=""} { set ChaineTok $TexteInitial } if { $ChaineTok=="" } { set TokCourant "" ; return "" } set Tok [string index $ChaineTok 0] set ChaineTok [string range $ChaineTok 1 end] if {[regexp {[ \n\t]} $Tok]} { return [Tok] } set TokCourant $Tok return $Tok } proc TooCloseOrganism {Genre {Espece ""}} { global TooCloseOrganism global RepertoireDuGenome if {$Espece==""} { set O $Genre } else { set O "$Genre $Espece" } if {[info exists TooCloseOrganism($O)]} { return [set TooCloseOrganism($O)] } set Orga [Glossaire $O Complet] if {$Orga==""} { set Orga $O } if {[info exists TooCloseOrganism($Orga)]} { return [set TooCloseOrganism($Orga)] } if {[info exists TooCloseOrganism ]} { return [set TooCloseOrganism("NotFound")] } set Fichier "$RepertoireDuGenome/fiches/tooclose_organism" if {[file exists $Fichier]} { Wup "We do it first for the most common used" foreach G [LesGenomesComplets] { set C [Glossaire $G Court] set TooCloseOrganism($G) 0 set TooCloseOrganism($C) 0 } set TooCloseOrganism(LaListeMerci) {} foreach Ligne [LesLignesDuFichier $Fichier] { set OrgaLu [string trim $Ligne] lappend TooCloseOrganism(LaListeMerci) $OrgaLu set TooCloseOrganism($OrgaLu) 1 set TooCloseOrganism([Glossaire $OrgaLu "Court"]) 1 Espionne [Glossaire $OrgaLu "Court"] } set TooCloseOrganism("NotFound") 0 return [TooCloseOrganism $O] } set LaFamille {} while {[OuiOuNon "Do You want to define 'Too close organisms' ?"]} { if {[OuiOuNon "Do You want to copy or link an other 'TooCloseOrganism' file ?"]} { set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."] if {$Autre==""} { continue } if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} { exec ln -s $Autre $Fichier } elseif {[OuiOuNon "Do I copy it ?"]} { File copy $Autre $Fichier } return [TooCloseOrganism $O] } set LaFamille [ChoixDesPresents [LesGenomesComplets]] set Other "" while {[OuiOuNon "Do You want to add other organisms to the too close organisms list ?" 0]} { set Other [Entre $Other] set BonOther [Glossaire $Other Complet] if {$BonOther==""} { FaireLire "I don't know the organism $Other" } else { lappend LaFamille $BonOther } } if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break } } if {$LaFamille=={}} { if { ! [OuiOuNon "Do You want to save 'Too Close Organisms' as an empty list ?"]} { set TooCloseOrganism("NotFound") 0 set TooCloseOrganism(LaListeMerci) {} return [TooCloseOrganism $O] } } SauveLesLignes $LaFamille dans $Fichier return [TooCloseOrganism $O] } proc TopoDuBlastN {} { global RepertoireDuGenome global PlottePourBlastN global DotPlotDesProches ; set DotPlotDesProches 0 global yDuContig set OnVeutLeDotPlot 0 set OnVeutLesQuery 1 foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdescontigs"] { scan $Ligne "%s %d %d" Contig d f set Debut($Contig) $d set Fin($Contig) $f set Long($Contig) [expr $f-$d+1] lappend LesFins $f set ContigDeLaFin($f) $Contig } set OldContig "" foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ouonttapelescontigs.mini"] { if { ! [regexp {[a-z0-9]} $Ligne]} { continue } scan $Ligne "%s %d %d %s %s %s %s %d %d %d %d" Contig a b OrgaComplet Orga Fraction PN dQ fQ dC fC regsub {TTH\-} $Contig "" Contig set Sens "F" if {$dC>$fC} { set W $dC set dC $fC set fC $W set Sens "R" } foreach FinDeContig $LesFins { if {$FinDeContig < $fC} { continue } set ContigCible [set ContigDeLaFin($FinDeContig)] if {$dC < [set Debut($ContigCible)]} { FaireLire "A cheval sur $ContigCible\n$Ligne" } break } ScanLaListe [split $Fraction "/"] IdenHSP LongHSP if {$LongHSP < 1} { continue } set Limite -0 if {[incr dQ $Limite]<0} { continue } if {[incr fQ $Limite]<0} { continue } if {[incr dC $Limite]<0} { continue } if {[incr fC $Limite]<0} { continue } lappend Nous "$Contig $dQ $fQ" lappend Nous "$Contig $dQ $fQ" lappend Vous "$ContigCible $dC $fC" lappend Vous "$ContigCible $dC $fC" lappend NosPos $dQ lappend NosPos $fQ lappend VosPos $dC lappend VosPos $fC set dQr [format "%3d" [expr round(100.*($dQ-[set Debut($Contig)])/[set Long($Contig)])] ] set fQr [format "%3d" [expr round(100.*($fQ-[set Debut($Contig)])/[set Long($Contig)])] ] set dCr [format "%3d" [expr round(100.*($dC-[set Debut($ContigCible)])/[set Long($ContigCible)])] ] set fCr [format "%3d" [expr round(100.*($fC-[set Debut($ContigCible)])/[set Long($ContigCible)])] ] set BelleFraction [format "%15s" $Fraction] set OldContig $Contig set Resume "$Sens $Contig $dQr $fQr $ContigCible $dCr $fCr $BelleFraction $dQ $fQ [set Debut($Contig)] [set Long($Contig)] $dC $fC [set Debut($ContigCible)] [set Long($ContigCible)]" lappend LesCommunsDeCible($ContigCible) $Resume lappend LesCommunsDeQuery($Contig) $Resume } set xMax 12000 set yMax 250000 set K [UnCanva $xMax $yMax 1000 1000] MainLeveeSurUnCanva $K set dy 50 set y [expr 10*$dy] set lQueryMax 0 foreach Contig [lsort -decreasing [array names LesCommunsDeCible]] { set lQuery 0 set MettreEntete 1 foreach Ligne [set LesCommunsDeQuery($Contig)] { scan $Ligne "%s %s %d %d %s %d %d %s %d %d %d %d %d %d %d %d" Sens Query dQr fQr Cible dCr fCr Fraction dQ fQ aQ lQ dC fC aC lC if { ! $lQuery } { set lQuery $lQ } if { ! $lQueryMax } { set lQueryMax $lQ } set oC [expr $lQueryMax+$dQ-$aQ-$dC+$aC] incr y $dy if {$Sens=="F"} { set CouleurAuSens "red" } else { set CouleurAuSens "blue" } set X1 $oC set X2 [expr $oC+$lC] set X1 [expr $X1/24.] set X2 [expr $X2/24.] if {$MettreEntete} { set MettreEntete 0 $K create text [expr $X1] [expr $y-2*$dy] -text $Contig -fill black -anchor w set yDuContig($Query) [expr 1.*$y/$yMax] set X2Query $X2 set n 0 lappend LesTextesAssocies "" } $K create line $X1 $y $X2 $y -fill black set bdQ [format "%7d" $dQ] set bfQ [format "%7d" $fQ] set bdC [format "%7d" $dC] set bfC [format "%7d" $fC] set blQ [format "%7d" [set Long($Query)]] set blC [format "%7d" [set Long($Cible)]] set baQ [format "%7d" [set Debut($Query)]] set bzQ [format "%7d" [set Fin($Query)]] set baC [format "%7d" [set Debut($Cible)]] set bzC [format "%7d" [set Fin($Cible)]] set bFraction [format "%11s" $Fraction] set BeauTexteQuery "$Query $bFraction $blQ $bdQ-$bfQ $baQ $bzQ" set TexteQuery "$Query $Fraction [set Long($Query)] $dQ-$fQ [set Debut($Query)] [set Fin($Query)]" set TexteCible "$Cible [string repeat " " [string length $Fraction]] [set Long($Cible)] $dC-$fC [set Debut($Cible)] [set Fin($Cible)]" set BeauTexteCible "$Cible $blC $bdC-$bfC $baC $bzC" set LesTags [list "$TexteQuery" "\n$TexteCible" "Coeur"] set Texte [format "%2.2d %s" [incr n] $Cible] $K create text [expr $X2Query+100] $y -text $Texte -anchor w -font {Courier 4} lappend LesTextesAssocies "[format %2d $n] $BeauTexteQuery $BeauTexteCible" set X1 [expr $oC+$dC-$aC] set X2 [expr $oC+$fC-$aC] set X1 [expr $X1/24.] set X2 [expr $X2/24.] $K create line $X1 $y $X2 $y -fill $CouleurAuSens -width 3 -tag $LesTags } incr y [expr 5*$dy] $K create line 0 $y 24000 $y -fill grey incr y [expr 5*$dy] } SauveLesLignes $LesTextesAssocies dans "$RepertoireDuGenome/textesassocies" regsub {\.canvas} $K "" FK Gonfle $FK all 0.2 0.2 BoutonneLaFenetre $FK "Coucou" "puts coucou" $K bind "Coeur" <1> "AfficheLeBlastNDuContig $K %x %y" $K bind "Coeur" <2> "SauteSurCible $K %x %y" $K bind "Coeur" "EntreDansCoeur $K %x %y" $K bind "Coeur" "SortDeCoeur $K %x %y" if {$OnVeutLeDotPlot} { set PlottePourBlastN 0 Plotte $Nous $Vous $NosPos $VosPos unset PlottePourBlastN } } proc TotalWSize {win} { set top [winfo toplevel $win] wm geometry $top +10+10 update idletasks # Recuperation geometrie (avec decoration) # Scan de la geometrie pour extraire les champs set g [wm geometry $top] scan $g "%dx%d%d%d" w h x y set w [winfo width $top] set h [winfo height $top] # Position absolue de la fenetre set tx [winfo rootx $top] set ty [winfo rooty $top] # Epaisseur de la bordure set borderw [expr {$tx-$x}] # Hauteur de la barre de titre set titleh [expr {$ty-$y}] #On peut alors, en supposant que la bordure est la #meme a gauche a droite et en bas, et que la barre # de titre est en haut, "deviner" les dimensions # totales du toplevel set totalwidth [expr {$w + 2*$borderw}] set totalheight [expr {$h + $titleh + $borderw}] update return [list $totalwidth $totalheight] } proc TouchePour {Clavier {Texte ""} {Commande ""} {Action ""} {Couleur ""}} { global TouchePour if {[regexp -nocase "GetPostpone" $Clavier]} { if { ! [info exists TouchePour(Postpone)]} { set TouchePour(Postpone) {} } set Memo $TouchePour(Postpone) if {[regexp -nocase "Reset" $Clavier]} { set TouchePour(Postpone) {} set TouchePour(ClavierCourant) "" } return $Memo } if { ! [info exists TouchePour(ClavierCourant)]} { set TouchePour(ClavierCourant) "" } set CC $Clavier if {[regexp "^<" $CC]} { set CC $TouchePour(ClavierCourant) } else { set TouchePour(ClavierCourant) $CC } if {$CC=="Postpone"} { if {[regexp "^<" $Clavier]} { lappend TouchePour(Postpone) [list $Clavier $Texte $Commande $Action $Couleur] } else { lappend TouchePour(Postpone) [list $Texte $Commande $Action $Couleur] } return $TouchePour(Postpone) } if {$Texte=="ReAcceptAll" && [info exists TouchePour($CC,RefuseAll)]} { unset TouchePour($CC,RefuseAll) return "" } if {$Texte=="RefuseAll"} { set TouchePour($CC,RefuseAll) 1 } if {[info exists TouchePour($CC,RefuseAll)]} { return "" } #rR if {[PourWscope]} { return [TouchePourWscope $Clavier $Texte $Commande $Action $Couleur] } #rR #????? if {[regexp "NoWeb" $Action]} { return "" } if {[regexp "^<" $Clavier]} { set Bouton [set TouchePour(BoutonCourant)] set NewTexte [lindex [$Bouton configure -text] 4] append NewTexte $Texte $Bouton configure -text $NewTexte bind $Bouton $Clavier $Commande return $Bouton } if {$Texte=="NouvelleCouleur"} { set TouchePour($Clavier,Couleur) $Commande return [set TouchePour($Clavier,Couleur)] } if {$Texte=="NouvelleGamme"} { if {[PourWscope]} { return } if { ! [info exists TouchePour($Clavier,Gamme)]} { set TouchePour($Clavier,Gamme) -1 } set Gamme [incr TouchePour($Clavier,Gamme)] set DestFrame "$Clavier.gamme$Gamme" frame $DestFrame pack $DestFrame -side "left" -fill x -pady 0 -anchor "n" set TouchePour($Clavier,DestFrame) $DestFrame return $DestFrame } if {$Action=="NoWeb"} { set NoWeb 1 } else { set NoWeb 0 } if {$NoWeb && [PourWscope]} { return "" } if { ! [info exists TouchePour($Clavier,nTouches)]} { set TouchePour($Clavier,nTouches) -1 } if { ! [info exists TouchePour($Clavier,Couleur)]} { set TouchePour($Clavier,Couleur) "grey" } set B [incr TouchePour($Clavier,nTouches)] if {$Couleur==""} { set Couleur [set TouchePour($Clavier,Couleur)] } set Bouton "$Clavier.touche$B" set WidthButton 15 if {[regexp "\.board\." $Bouton]} { set WidthButton 25 } button $Bouton -text $Texte -background $Couleur -foreground black -relief raise -width $WidthButton -height 1 -pady 0 bind $Bouton <1> $Commande if { ! [PourWscope]} { pack $Bouton -in [set TouchePour($Clavier,DestFrame)] -side "top" -expand 1 } set TouchePour(BoutonCourant) $Bouton return $Bouton } proc TouchePourWscope {QuoiOuClavier {QuiOuTexte ""} {Commande ""} {Maniere ""} {Couleur ""}} { global TouchePourWscope #rR TouchePourWscope est appele au fur et a mesure de la contruction des boutons par AfficheVariable #rR il sera interroge ensuite pour creer la WebForm #rR et puis pour traiter l'appel utilisateur #rR Finalement detruit par Dismiss si tout est fait dans les regles de l'art #rR cas ou il faut rendre qq chose ************************************************************************* set Quoi $QuoiOuClavier set Qui $QuiOuTexte set Retour "OnNeDemandeRien" if {[regexp "LesInfosDuBouton" $Quoi]} { set Bouton $Qui set Fenetre "" regexp {_[^_]+} $Bouton Fenetre set Retour "" if {[info exists TouchePourWscope($Fenetre,$Bouton)]} { set Retour $TouchePourWscope($Fenetre,$Bouton) } return $Retour } if {[regexp "LesBoutonsDeLaFenetre" $Quoi]} { set Fenetre $Qui if {[info exists TouchePourWscope($Fenetre,Boutons)]} { set Retour $TouchePourWscope($Fenetre,Boutons) } } if {[regexp "RemiseAZero" $Quoi]} { set Fenetre $Qui if {[info exists TouchePourWscope($Fenetre)]} { foreach k $TouchePourWscope($Fenetre) { if {[info exists TouchePourWscope($Fenetre,$k)]} { unset $TouchePourWscope($Fenetre,$k) } } unset TouchePourWscope($Fenetre) } return $Retour } if {$Retour!="OnNeDemandeRien"} { return $Retour } #rr fin cas rendre qq chose ******************************************************************************** set Clavier $QuoiOuClavier regsub -all {[\.\-]} $Clavier "_" Clavier if { ! [info exists TouchePourWscope(IndexTouche)]} { set TouchePourWscope(IndexTouche) 0 } incr TouchePourWscope(IndexTouche) set Texte $QuiOuTexte if {[regexp "NoWeb" $Maniere]} { return "" } set Fenetre "" if {[info exists TouchePourWscope(FenetreCourante)]} { set Fenetre $TouchePourWscope(FenetreCourante) } if {[regexp {_[^_]+} $Clavier FenetreDuClavier]} { set Fenetre $FenetreDuClavier } set TouchePourWscope(FenetreCourante) $Fenetre if {[regexp {^<([^>]+)>} $Clavier Match NumTouche]} { set Clavier $TouchePourWscope(ClavierCourant) append Clavier $NumTouche } else { set TouchePourWscope(ClavierCourant) $Clavier append Clavier "1" } append Clavier "_$TouchePourWscope(IndexTouche)" if {$Texte=="NouvelleGamme"} { lappend TouchePourWscope($Fenetre,Boutons) "NouvelleGamme" return "" } if {$Texte=="NouvelleCouleur"} { set TouchePourWscope(Couleur) $Commande return $TouchePourWscope(Couleur) } if {$Couleur==""} { if { ! [regexp {^ */} $Texte] && [info exists TouchePourWscope(PropreCouleur)]} {unset TouchePourWscope(PropreCouleur) } if { ! [info exists TouchePourWscope(Couleur)]} { set TouchePourWscope(Couleur) "red" } set Couleur $TouchePourWscope(Couleur) } else { if { ! [regexp {^ */} $Texte]} { set TouchePourWscope(PropreCouleur) $Couleur } } if {[info exists TouchePourWscope(PropreCouleur)]} { set Couleur $TouchePourWscope(PropreCouleur) } set LesInfosDuBouton [list $Clavier $Texte $Commande $Maniere $Couleur] set TouchePourWscope($Fenetre,$Clavier) $LesInfosDuBouton lappend TouchePourWscope($Fenetre,Boutons) $LesInfosDuBouton return $Clavier } proc TouchePressee {w t} { global LSSeqlab LNSeqlab set idx [$w index] lassign [split $idx ,] il ic set s [string trim [lindex $LNSeqlab $il]] if {$s eq ""} {return} set sq [lindex $LSSeqlab $il] set sq [lreplace $sq $ic $ic [string toupper $t]] lset LSSeqlab $il $sq $w chars $il,[expr {$ic+1}] $t return } proc ToujoursFaire {CurGeno} { global FichierAFaire global FichierDejaFait global CurrentGenome set Pointeuse 0 set Attente 2000 set MaxIdle [expr 1000*60*15] while { 1 } { incr Pointeuse $Attente if {[file exists $FichierAFaire]} { set Pointeuse 0 FaireAFaire continue } if {$Pointeuse > $MaxIdle} { exit } after $Attente } } proc TourneArbreEntier {AId rot} { global Abr set t [set Abr(Arbre,$AId)] foreach e [$t nodes] { if {[$t keyexists $e theta]} { set th [$t get $e theta] $t set $e theta [expr {$th+$rot}] } if {[$t keyexists $e oldtheta]} { set th [$t get $e oldtheta] $t set $e oldtheta [expr {$th+$rot}] } } # TransformationCartesienne $AId root # AjusteCoordonneesInit $AId # ReAjusteCoordonnees $AId return } proc TourneBoite {x1 y1 x2 y2 deltaA} { # ramene a l'origine, tourne et revient # Angle en RADIANS !! set cd [expr {cos($deltaA)}] set sd [expr {sin($deltaA)}] set xp [expr {$x2-$x1}] set yp [expr {$y2-$y1}] set x [expr {$xp*$cd-$yp*$sd}] set y [expr {$xp*$sd+$yp*$cd}] set xf [expr {$x+$x1}] set yf [expr {$y+$y1}] return [list $xf $yf] } proc TourneBoiteD {x1 y1 x2 y2 deltaA} { # ramene a l'origine, tourne et revient # Angle en DEGRES !! # -------- set cd [expr {cos($deltaA*[Pi]/180.)}] set sd [expr {sin($deltaA*[Pi]/180.)}] set xp [expr {$x2-$x1}] set yp [expr {$y2-$y1}] set x [expr {$xp*$cd-$yp*$sd}] set y [expr {$xp*$sd+$yp*$cd}] set xf [expr {$x+$x1}] set yf [expr {$y+$y1}] return [list $xf $yf] } proc TourneFourmi {tag} { global PAD TFB lassign [CentreFourmi $tag] xm ym set ov "" foreach elt [$PAD find withtag $tag] { if {[$PAD type $elt] == "oval"} { set ov $elt continue } set Lc [$PAD coords $elt] set angTot [BonAngle [expr {$TFB($tag,angle) - $TFB($tag,oldAng)}]] set Lc [TourneListe $xm $ym $angTot $Lc] #set Lc [TourneListe $xm $ym [expr {-1.*$TFB($tag,oldAng)}] $Lc] #set Lc [TourneListe $xm $ym $TFB($tag,angle) $Lc] $PAD coords $elt {*}$Lc } if {$ov != ""} { BouleSurCorps $tag $ov } set TFB($tag,oldAng) $TFB($tag,angle) return } proc TourneLaListeAutour {Liste CentreX CentreY AngleDelta} { Wup "Returns the rotated list" set PI 3.14159 foreach {X Y} $Liste { set Angle [AngleDansRosace "CoordonneesVraies" $X $Y $CentreX $CentreY] set Rayon [RayonDansRosace "CoordonneesVraies" $X $Y $CentreX $CentreY] set NouvelAngle [Entre0Et2PI [expr $Angle+$AngleDelta]] lappend Sortie [expr $CentreX+$Rayon*cos($NouvelAngle)] lappend Sortie [expr $CentreY+$Rayon*sin($NouvelAngle)] } return $Sortie } proc TourneListe {xr yr ang Lc} { set cd [expr {cos($ang*[Pi]/180.)}] set sd [expr {sin($ang*[Pi]/180.)}] set Lout [list] foreach {x2 y2} $Lc { set xp [expr {$x2 - $xr}] set yp [expr {$y2 - $yr}] set x [expr {$xp*$cd-$yp*$sd}] set y [expr {$xp*$sd+$yp*$cd}] set xf [expr {round($x + $xr)}] set yf [expr {round($y + $yr)}] lappend Lout $xf $yf } return $Lout } proc TousAMemeTaille {Path tailleLimite {Organism Homo_sapiens} {bigzips bigZips200603}} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TousA$tailleLimite: Start" set FichierIn [open "$Path.coord" "r"] set FichierOut [open "$Path.tfa" "w"] set FichierOutMasked [open "$Path.masked.tfa" "w"] set FichierOutMaskedPure [open "$Path.pure.tfa" "w"] set FichierOutMaskedPureSeq [open "$Path.pure.seq" "w"] set reads 0 set written1 0 set written2 0 set pure 0 while { [gets $FichierIn LigneIn] >=0 } { incr reads ScanLaListe $LigneIn chrom start end summit tags peak fold set length [expr $end - $start + 1] Espionne "Sequence $reads" if { $length < $tailleLimite} { incr written1 set extend [expr int(($tailleLimite - $length)/2)] set extendStart [expr $start - $extend] set extendEnd [expr $end + $extend] set extendLength [expr $length + 2 * $extend] regsub -all -nocase "chr" $chrom "" chrom set header ">Seq$reads.chr$chrom:$extendStart-$extendEnd.$summit.$tags.$peak.$fold" set sequence [BoutAdnDeUcscBoost $extendStart $extendEnd "F" $Organism $chrom $bigzips] } else { incr written2 regsub -all -nocase "chr" $chrom "" chrom set header ">Seq$reads.chr$chrom:$start-$end.$summit.$tags.$peak.$fold" set sequence [BoutAdnDeUcscBoost $start $end "F" $Organism $chrom $bigzips] set extendStart $start set extendEnd $end } regsub -all {[a t c g]} $sequence "N" sequenceMasked if {[regexp {[A T C G]} $sequenceMasked]} { puts $FichierOutMaskedPure [formatFasta $header $sequenceMasked] set header ">chr$chrom:$extendStart-$extendEnd" puts $FichierOutMaskedPureSeq $header puts $FichierOutMaskedPureSeq $sequenceMasked incr pure } puts $FichierOut [formatFasta $header $sequence] puts $FichierOutMasked [formatFasta $header $sequenceMasked] } close $FichierIn close $FichierOut close $FichierOutMasked close $FichierOutMaskedPure set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TousA$tailleLimite: Lus = $reads" Espionne "$timestamp|TousA$tailleLimite: Ecrit<$tailleLimite = $written1" Espionne "$timestamp|TousA$tailleLimite: Ecrit>=$tailleLimite = $written2" Espionne "$timestamp|TousA$tailleLimite: Pure = $pure" Espionne "$timestamp|TousA$tailleLimite: End" } proc TousFreres {} { global db InitTaxDB $db eval {begin transaction} set Lpere [$db eval {select distinct(Parent) from taxonomy where Rank="Species"}] foreach id $Lpere { set Lrk [$db eval {select distinct(Rank) from taxonomy where Parent=$id}] if {[llength $Lrk] > 1} { puts "$id $Lrk" } } $db eval {commit} exit } proc TousLesAncetresEtLesDescendantsGODesGO {LesGO} { return [concat [TousLesAncetresGODesGO $LesGO] [TousLesDescendantsGODesGO $LesGO]] } proc TousLesAncetresGO {Type Individu {TousLesAncetres ""}} { set Individu [string toupper $Individu] set Individu [GODB Type $Type GOSynonyme $Individu GODeRef] set LesParents [GODB Type $Type GO $Individu LesParents] set LesConstituants [GODB Type $Type GO $Individu LesConstituants] set TousLesParents [concat [GODB Type $Type GO $Individu LesParents] [GODB Type $Type GO $Individu LesConstituants]] if {![info exists TousLesAncetres]} {set TousLesAncetres {}} foreach Parent $TousLesParents { if {[GODB Exists Type $Type GOSynonyme $Parent GODeRef]} { set Parent [GODB Type $Type GOSynonyme $Parent GODeRef] } lappend TousLesAncetres $Parent set TousLesAncetres [TousLesAncetresGO $Type $Parent $TousLesAncetres] } return [ElimineLesRedondancesDansUneListe $TousLesAncetres] } proc TousLesAncetresGODesGO {LesGO} { set LesAncetres {} foreach GO $LesGO { if {[info exists TabTmp($GO)]} {continue} foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {[info exists TabTmp($GO)]} {continue} foreach GOPere [TousLesAncetresGO $Type $GO] { if {[info exists TabTmp($GOPere)]} {continue} set TabTmp($GOPere) 1 lappend LesAncetres $GOPere } } } if {[info exists TabTmp]} {unset TabTmp} return [ElimineLesRedondancesDansUneListe $LesAncetres] } proc TousLesAncetresOntologiques {Type Individu {TousLesAncetres ""}} { set Individu [string toupper $Individu] if {[OntoExists $Individu MonJumeau]} {set Individu [Onto $Individu MonJumeau]} if {![TypeOntologieExiste $Type]} { set Type [Onto $Individu Type] } set TousLesParents [concat [Onto $Type $Individu LesParents] [Onto $Type $Individu LesConstituants]] if {![info exists TousLesAncetres]} {set TousLesAncetres {}} foreach Parent $TousLesParents { if {[OntoExists $Parent MonJumeau]} {set Parent [Onto $Parent MonJumeau]} lappend TousLesAncetres $Parent set TousLesAncetres [TousLesAncetresOntologiques $Type $Parent $TousLesAncetres] } return [ElimineLesRedondancesDansUneListe $TousLesAncetres] } proc TousLesAscendantsGO {GO} { set ascendants {} set monType [Onto $GO "Type"] set mesParents [Onto $monType $GO "LesParents"] foreach parent $mesParents { set type [Onto $parent "Type"] set niv [lsort -unique [Onto $type $parent "LesNiveaux"]] # garde seulement la premiere def set def [lindex [Onto $type $parent "LesDefinitions"] 0] set parents [Onto $type $parent "LesParents"] if {$niv != 0} { set ascendants [concat $ascendants [TousLesAscendantsGO $parent]] lappend ascendants [list $parent $type $niv $def $parents] } } return [lsort -dictionary -index 2 [lsort -unique $ascendants]] } proc TousLesBlastsContreAffy {Rep1 Rep2} { foreach PAB [ListeDesPABs] { set AccessmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $PAB Organisme "Homo sapiens" "mRNA" Access] if {$AccessmRNAHuman==""} { #blastn nuctfa contre affytarget if {![file exists "$Rep1/$PAB"]} { BlastNNuctfaContreBanqueAffy $PAB $Rep1 } } else { #blastn mrna contre affytarget if {![file exists "$Rep2/$PAB"]} { BlastNmRNAHumanContreBanqueAffy $PAB $Rep2 } } } } proc TousLesBlastsContreAffy945 {Rep1 Rep2 Rep3} { foreach Nom [ListeDesPABs] { set Banque "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget" set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {[file exists $FichiermRNA]} { #blastn mrna contre affytarget BlastNmRNAHumanContreBanqueAffy $Nom $Rep1 continue } elseif {[file exists $FichierProttfa]} { set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] set H 0 if {[regexp "from CONTIG" $EnteteProttfa]} { if {[regexp "from Homo sapiens from CONTIG" $EnteteProttfa]} {set H 1} } elseif {[regexp "from Homo sapiens" $EnteteProttfa] || [regexp "from mitochondrion Homo" $EnteteProttfa]} {set H 1} if {$H==1} { set FichierBlast "$Rep2/$Nom" if {![file exists $Rep2]} {file mkdir $Rep2} if {[file exists $FichierBlast]} {continue} Espionne "Je lance $FichierProttfa en TblastN contre $Banque" set FichierBlastTmp [TmpFile] set FichierBlastTmp [TBlastNDuFichier $FichierProttfa $Banque 1 $FichierBlastTmp] if {[file exists $FichierBlastTmp]} { File rename -force $FichierBlastTmp $FichierBlast } continue } } BlastNNuctfaContreBanqueAffy $Nom $Rep3 } } proc TousLesBlastsContreAffy951 {Rep1 Rep2 Rep3} { foreach Nom [ListeDesPABs] { set Banque "[GscopeDatabaseDir AffyTarget]/banques/AffyTarget" set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$AccBestmRNAHuman!="" && [file exists $FichiermRNA]} { #blastn mrna contre affytarget BlastNmRNAHumanContreBanqueAffy $Nom $Rep1 continue } elseif {$AccBestProtHuman!="" && [file exists $FichierProttfa]} { set FichierBlast "$Rep2/$Nom" if {![file exists $Rep2]} {file mkdir $Rep2} if {[file exists $FichierBlast]} {continue} Espionne "Je lance $FichierProttfa en TblastN contre $Banque" set FichierBlastTmp [TmpFile] set FichierBlastTmp [TBlastNDuFichier $FichierProttfa $Banque 1 $FichierBlastTmp] if {[file exists $FichierBlastTmp]} { File rename -force $FichierBlastTmp $FichierBlast } continue } BlastNNuctfaContreBanqueAffy $Nom $Rep3 } } proc TousLesCodesAffy {} { set LesCodes {} foreach PAB [ListeDesPABs] { set CodeClone [CodeClone $PAB] #Espionne $CodeClone lappend LesCodes "$PAB\t$CodeClone" } return $LesCodes } proc TousLesCopainsDesCompulsory {} { #attention certain ont pas gn set compulsory 0 set LesGns {} set Tot 0 #set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterAll" set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterSsBigClu" foreach Nom [ListOfCompulsoryGenes] { set LesGnsDuNom {} #Espionne "$Nom" incr compulsory foreach File [glob -nocomplain "$Repertoire/${Nom}-*-lesbestcops"] { #Espionne "File $File" if {[regexp "AFFX" $File]} {Espionne "Attention1"} set premiereligne 1 foreach Ligne [LesLignesDuFichier $File] { if {$premiereligne} { set premiereligne 0 scan $Ligne "%s %s" nbdecombinaisoncompul bidon set TabCompul($Nom) $nbdecombinaisoncompul } set LesMots [split $Ligne " "] set nb [lindex $LesMots 0] if {$nb < 4} {continue} #Espionne "nb $nb" set EviPs [lindex $LesMots 1] if {[regexp "AFFX" EviPs]} {Espionne "Attention2"} set LesEviPs [split $EviPs "-"] set Boite [lindex $LesEviPs 0] set Gn [lindex $LesMots 2] lappend LesGnsDuNom $Gn #Espionne "$Boite $Gn" lappend LesGns $Gn } } set LesGnsDuNom [ListeSsElmtVide $LesGnsDuNom] set LesGnsDuNom [lsort -unique $LesGnsDuNom] set longLesGnsDuNom [llength $LesGnsDuNom] incr Tot $longLesGnsDuNom set TabLongLesGnsDuNom($Nom) $longLesGnsDuNom } set Max 0 set Min 20 foreach {cle val} [array get TabCompul] { if {$val>$Max} {set Max $val} if {$val<$Min} {set Min $val} #Espionne "$cle $val" } Espionne "MaxCombinaison $Max" Espionne "MinCombinaison $Min" set LesResults {} foreach {clef valeur} [array get TabLongLesGnsDuNom] { lappend LesResults "$valeur $clef" } set LesResults [lsort -integer -index 0 -decreasing $LesResults] foreach x $LesResults { #Espionne "$x" } set LesGns [ListeSsElmtVide $LesGns] set LesGns [lsort -unique $LesGns] set longLesGns [llength $LesGns] Espionne $LesGns Espionne "compulsory $compulsory" Espionne "longLesGns $longLesGns" } proc TousLesCopainsDesCompulsoryDifferentSeuil {} { #le seuil etablie pour chaque compulsory est dependant du nbdecombinaison set compulsory 0 set LesGns {} set Tot 0 set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterSsBigClu" foreach Nom [ListOfCompulsoryGenes] { set LesGnsDuNom {} Espionne "$Nom" incr compulsory foreach File [glob -nocomplain "$Repertoire/${Nom}-*-lesbestcops"] { Espionne "File $File" if {[regexp "AFFX" $File]} {Espionne "Attention1"} set premiereligne 1 foreach Ligne [LesLignesDuFichier $File] { if {$premiereligne} { set premiereligne 0 scan $Ligne "%s %s" nbdecombinaisoncompul bidon set TabCompul($Nom) $nbdecombinaisoncompul } set LesMots [split $Ligne " "] set nb [lindex $LesMots 0] if {$nbdecombinaisoncompul<=5} { #prend que ceux dont le nb=nbdecombinaisoncompul if {$nb != $nbdecombinaisoncompul} {continue} } else { if {$nb < expr $nbdecombinaisoncompul} {continue} } Espionne "nb $nb" set EviPs [lindex $LesMots 1] if {[regexp "AFFX" EviPs]} {Espionne "Attention2"} set LesEviPs [split $EviPs "-"] set Boite [lindex $LesEviPs 0] set Gn [lindex $LesMots 2] lappend LesGnsDuNom $Gn Espionne "$Boite $Gn" lappend LesGns $Gn } } set LesGnsDuNom [ListeSsElmtVide $LesGnsDuNom] set LesGnsDuNom [lsort -unique $LesGnsDuNom] set longLesGnsDuNom [llength $LesGnsDuNom] incr Tot $longLesGnsDuNom set TabLongLesGnsDuNom($Nom) $longLesGnsDuNom } set Max 0 set Min 20 foreach {cle val} [array get TabCompul] { if {$val>$Max} {set Max $val} if {$val<$Min} {set Min $val} #Espionne "$cle $val" } puts "MaxCombinaison $Max" puts "MinCombinaison $Min" set LesResults {} foreach {clef valeur} [array get TabLongLesGnsDuNom] { lappend LesResults "$valeur $clef" } set LesResults [lsort -integer -index 0 -decreasing $LesResults] foreach x $LesResults { Espionne "$x" } set LesGns [ListeSsElmtVide $LesGns] set LesGns [lsort -unique $LesGns] set longLesGns [llength $LesGns] Espionne $LesGns Espionne "compulsory $compulsory" Espionne "longLesGns $longLesGns" } proc TousLesCopainsDesRetinalFate {{Liste ""}} { set retinalfate 0; set LesGns {} if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterSsBigClu" foreach Nom $Liste { set trouve 0 set LesGnsDuNom {} set Status [ExtraitInfo $Nom "Status"] set StatusCompOpt [string range $Status 0 [expr [string first "\(" $Status] - 1]] if {$StatusCompOpt=="optional"} {continue} set LesElmt [split $Status "\(\),"] foreach elmt $LesElmt { if {$elmt=="retinal_fate"} {set trouve 1} } if {!$trouve} {continue} incr retinalfate foreach File [glob -nocomplain "$Repertoire/$Nom*-lesbestcops"] { set premiereligne 1 foreach Ligne [LesLignesDuFichier $File] { if {$premiereligne} { set premiereligne 0 scan $Ligne "%s %s" nbdecombinaisoncompul bidon set TabCompul($Nom) $nbdecombinaisoncompul continue } set LesMots [split $Ligne " "] set nb [lindex $LesMots 0] if {$nb<8} {continue} #Espionne "nb $nb" set EviPs [lindex $LesMots 1] set LesEviPs [split $EviPs "-"] set Boite [lindex $LesEviPs 0] set Gn [lindex $LesMots 2] lappend LesGnsDuNom $Gn #Espionne "$Boite $Gn" lappend LesGns $Gn } } set LesGnsDuNom [ListeSsElmtVide $LesGnsDuNom] set LesGnsDuNom [lsort -unique $LesGnsDuNom] set longLesGnsDuNom [llength $LesGnsDuNom] #Espionne "LesGnsDuNom $LesGnsDuNom" #Espionne "longLesGnsDuNom $longLesGnsDuNom" set TabLongLesGnsDuNom($Nom) $longLesGnsDuNom } set Max 0 set Min 20 foreach {cle val} [array get TabCompul] { if {$val>$Max} {set Max $val} if {$val<$Min} {set Min $val} #Espionne "$cle $val" } Espionne "MaxCombinaison $Max" Espionne "MinCombinaison $Min" set LesResults {} foreach {clef valeur} [array get TabLongLesGnsDuNom] { lappend LesResults "$valeur $clef" } set LesResults [lsort -integer -index 0 -decreasing $LesResults] foreach x $LesResults { Espionne "$x" } set LesGns [ListeSsElmtVide $LesGns] set LesGns [lsort -unique $LesGns] Espionne $LesGns set longLesGns [llength $LesGns] Espionne "retinalfate $retinalfate" Espionne "longLesGns $longLesGns" } proc TousLesDescendantsGO {Type Individu {TousLesDescendants ""}} { set Individu [string toupper $Individu] set Individu [GODB Type $Type GOSynonyme $Individu GODeRef] set TousLesEnfants [concat [GODB Type $Type GO $Individu LesEnfants] [GODB Type $Type GO $Individu LesContributions]] if {![info exists TousLesDescendants]} {set TousLesDescendants {}} foreach Enfant $TousLesEnfants { set Enfant [string toupper $Enfant] if {[GODB Exists Type $Type GOSynonyme $Enfant GODeRef]} {set Enfant [GODB Type $Type GOSynonyme $Enfant GODeRef]} lappend TousLesDescendants $Enfant set TousLesDescendants [TousLesDescendantsGO $Type $Enfant $TousLesDescendants] } return [ElimineLesRedondancesDansUneListe $TousLesDescendants] } proc TousLesDescendantsGODesGO {LesGO} { set LesDescendants {} foreach GO $LesGO { if {[info exists TabTmp($GO)]} {continue} foreach Type [GODB GO $GO LesTypes] { set GO [GODB Type $Type GOSynonyme $GO GODeRef] if {[info exists TabTmp($GO)]} {continue} foreach GOFils [TousLesDescendantsGO $Type $GO] { if {[info exists TabTmp($GOFils)]} {continue} set TabTmp($GOFils) 1 lappend LesDescendants $GOFils } } } if {[info exists TabTmp]} {unset TabTmp} return [ElimineLesRedondancesDansUneListe $LesDescendants] } proc TousLesDescendantsOntologiques {Type Individu {TousLesDescendants ""}} { set Individu [string toupper $Individu] if {[OntoExists $Individu MonJumeau]} {set Individu [Onto $Individu MonJumeau]} if {![TypeOntologieExiste $Type]} { set Type [Onto $Individu Type] } set TousLesEnfants [concat [Onto $Type $Individu LesEnfants] [Onto $Type $Individu LesContributions]] if {![info exists TousLesDescendants]} {set TousLesDescendants {}} foreach Enfant $TousLesEnfants { set Enfant [string toupper $Enfant] if {[OntoExists $Enfant MonJumeau]} {set Enfant [Onto $Enfant MonJumeau]} lappend TousLesDescendants $Enfant set TousLesDescendants [TousLesDescendantsOntologiques $Type $Enfant $TousLesDescendants] } return [ElimineLesRedondancesDansUneListe $TousLesDescendants] } proc TousLesEMBLtoGCG {{Rep ""} {Dest ""}} { global RepertoireDuGenome if {$Rep==""} { set Rep "$RepertoireDuGenome/nucembl" } if {$Dest==""} { regsub "embl" $Rep "" BaseRep set Dest "${BaseRep}gcg" } if { ! [OuiOuNon "Do I create the files in $Dest ?"]} { return } if {[file exists $Dest]} { File mkdir $Dest } foreach Fichier [glob -nocomplain "$Rep/*"] { set Nom [file tail $Fichier] set Sortie {} foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^SQ " $Ligne]} { append Ligne " .." } lappend Sortie $Ligne } SauveLesLignes $Sortie dans "$Dest/$Nom" } FaireLire "Please do following : \ncd $Dest\nand run the gcg command reformat with *" } proc TousLesJumeauxDuPAB {PAB FichierClusters} { foreach Ligne [LesLignesDuFichier $FichierClusters] { if {$Ligne==""} {continue} set Ligne [split $Ligne " "] foreach Nom $Ligne { if {$Nom==$PAB} { return $Ligne } } } } proc TousLesMetDuPoch {{Nom ""}} { global ListeDeBoites if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites } if { $Nom != ""} { set ListeATester [lrange $ListeDeBoites [lsearch $ListeDeBoites $Nom] end] } else { set ListeATester $ListeDeBoites } foreach Boite $ListeATester { set Nom [Box $Boite nom] if { ! [YaPABdans $Nom]} { continue } set Entamme [LeMetDuPoch $Nom] while {$Entamme == "On recommence"} { set Entamme [LeMetDuPoch $Nom] } puts "$Nom $Entamme" } } proc TousLesMiniBootstrap {} { global RepertoireDuGenome foreach FichierPhylo [glob "$RepertoireDuGenome/bootstrap/*"] { MiniBootstrap $FichierPhylo } } proc TousLesPremiersDuClade {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""}} { if {$GetWhat==""} { set GetWhat "Show" } if {$Seuil==""} { set Seuil 0.001 } set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]] if {$LesOrgaTrie=={}} { return "The file taxobla/$Nom does not exist" } set LaSortie {} foreach Ligne $LesOrgaTrie { lassign [split $Ligne "\t"] Expect Score TaxId OS Reste set TaxId [string trim $TaxId] set OS [string trim $OS] set Reste [string trim $Reste] if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue } set Expect [string trim $Expect] if {$Expect > $Seuil} { break } lappend LaSortie $Ligne } if {$LaSortie=={}} { return "" } if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} { set FichierPremiers $GetWhat if {[string equal -nocase "Save" $GetWhat]} { set FichierPremiers [GscopeFile $Nom premier] } return [SauveLesLignes $LaSortie dans $FichierPremiers] } if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie } if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] } return [AfficheListe $LaSortie] } proc TousLesSegmentsConsecutifs {Liste {JoinCar }} { set LL [llength $Liste] set LesSegments {} foreach N [NombresEntre 1 $LL] { foreach D [NombresEntre 0 [expr $LL-$N]] { set F [expr $D+$N-1] set W [lrange $Liste $D $F] lappend LesSegments [join $W $JoinCar] } } return $LesSegments } proc TousObjetsOff {} { global pgl StrucAVoir set fobj $pgl(frObjc) set Lf [winfo children $fobj] foreach w $Lf { set c [lindex [split $w .] end] if {[string index $c 0] ne "f"} {continue} set nom [string range $c 1 end] foreach e [winfo children $w] { set b [lindex [split $e .] end] if {[string range $b 0 2] ne "bto"} {continue} set o [string trim [$e cget -text]] if {! [$nom _EtatDeObjet $o]} { continue } $nom ObjetOff $o $e configure -foreground red } } update idletasks $pgl(wogl) postredisplay return } proc TousObjetsOn {} { global pgl StrucAVoir set fobj $pgl(frObjc) set Lf [winfo children $fobj] foreach w $Lf { set c [lindex [split $w .] end] if {[string index $c 0] ne "f"} {continue} set nom [string range $c 1 end] foreach e [winfo children $w] { set b [lindex [split $e .] end] if {[string range $b 0 2] ne "bto"} {continue} set o [string trim [$e cget -text]] if {[$nom _EtatDeObjet $o]} {continue} $nom ObjetOn $o $e configure -foreground green1 } } update idletasks $pgl(wogl) postredisplay return } proc TousSens {} { foreach P [Oli "LaListeMerci"] { Espionne $P Espionne [Oli $P "Sens"] } } proc TousToTFA {} { foreach F [glob "*.nuc"] { regsub ".nuc$" $F ".tfa" T regsub ".nuc$" $F "" T if {[file exists "$T.tfa"]} { continue } set TFA [SequenceFormatTFA [ContenuDuFichier $F] ">$T" "gcg"] Espionne [Sauve $TFA dans "$T.tfa"] } exit } proc ToutPourYann {} { # set Sequence [QueLaSequenceDuFichierTFA "/genomics/link/ProGS/prottfa/PGS001"] set Access "P10827" set Site "http://globplot.embl.de/cgiDict.py" set Url $Site append Url "?key=" append Url "process" append Url "&SP_entry=" append Url $Access append Url "&sequence_string=" append Url "" append Url "¶ms=" append Url "RL" append Url "&peak_frame_dis=" append Url 5 append Url "&join_frame_dis=" append Url 4 append Url "&do_smart=" append Url "true" append Url "&peak_frame_dom=" append Url 74 append Url "&join_frame_dom=" append Url 15 append Url "&plot_title=" append Url "titreduplot" append Url "&smooth_frame_1=" append Url 5 append Url "&smooth_frame_2=" append Url 5 set LesLignes {} HttpCopy $Url LesLignes EspionneL $LesLignes SauveLesLignes $LesLignes dans GlobPlotResultat.html # set Sequence [QueLaSequenceDuFic set Site "http://dis.embl.de/cgiDict.py" set LesCVs {} lappend LesCVs "key=process" lappend LesCVs "SP_entry=$Access" lappend LesCVs "sequence_string=" lappend LesCVs "smooth_frame=8" lappend LesCVs "peak_frame=8" lappend LesCVs "join_frame=4" lappend LesCVs "fold_coils=1.20" lappend LesCVs "fold_rem465=1.20" lappend LesCVs "fold_hotloops=1.40" lappend LesCVs "plot_title=" lappend LesCVs "doApplet=true" lappend LesCVs "tango_PH=7.40" lappend LesCVs "tango_T=278.15" lappend LesCVs "tango_I=0.05" lappend LesCVs "tango_TFE=0.00" lappend LesCVs "fold_tango=1.00" set CVs [join $LesCVs "&"] set Url "$Site?$CVs" set LesLignes {} HttpCopy $Url LesLignes EspionneL $LesLignes SauveLesLignes $LesLignes dans DisEmblResultat.html exit } proc ToutSurLesEntetesDeFrag {FichierFrag {Rep ""}} { if {$Rep==""} { set Rep "SameDir" } if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" } set LesBanques {} foreach Ligne [LesLignesDuFichier $FichierFrag] { regsub {\:} $Ligne " " Ligne scan $Ligne "%s" Banque set LesMots [split $Ligne " "] set Genre [lindex $LesMots 9] set Espece [lindex $LesMots 10] if {[info exists DejaVu($Banque)]} { continue } set DejaVu($Banque) 1 lappend LesBanques $Banque lappend LesOrganismes "$Genre $Espece" } set LesBonnesBanques {} foreach SN $LesBanques O $LesOrganismes { set FN [FNduSNgcg $SN] set LN [LNduSNgcg $SN] if {$FN==""} { FaireLire "$SN inconnu" ; continue } ScanLaListe [split $FN ":"] Dir Fic if {$LN!=$Fic} { FaireLire "FN $FN <> LN $LN" } if {[catch {set VraieDir [exec name $Dir]} Message]} { FaireLire "Problem with 'exec name $Dir'\ I got message \n$Message" continue } set BonRef "" foreach FiRef [glob -nocomplain "$VraieDir/*.ref"] { set Queue [file tail $FiRef] if {[string equal -nocase $Queue "$Fic.ref"]} { set BonRef $FiRef ; break } } if {$BonRef==""} { Warne "$VraieDir/$Fic.ref doen't exist" } set TaxId [TaxIdDuFichierRef $BonRef] set TaxIdDuO [Tax $O] Espionne "$O<$TaxIdDuO>" if {$TaxId==""} { if {$TaxIdDuO==""} { FaireLire "I didn't found a TaxId for\n$BonRef" } set TaxId $TaxIdDuO } set N 7 set TaxIdAuBonNiveau $TaxId while { [incr N -1] } { Espionne "$N $TaxIdAuBonNiveau $TaxIdDuO" if {$TaxIdAuBonNiveau==$TaxIdDuO} { break } set TaxIdAuBonNiveau [Tax $TaxIdAuBonNiveau Parent] } if {0 && $TaxIdAuBonNiveau!=$TaxIdDuO} { FaireLire "$TaxIdDuO is not a parent of $TaxId for \n$BonRef" } lappend LesBonnesBanques "$SN $BonRef $TaxId" set TaxIdDuGenomeComplet($SN) $TaxId set RefDuGenomeComplet($SN) $BonRef } if {[OuiOuNon "Do I save TaxIdDuGenomeComplet ?"]} { set FichierTaxIdDuGenomeComplet "/genomics/link/Common/fiches/taxid_des_genomes_complets" SauveLesLignes [array get TaxIdDuGenomeComplet] dans $FichierTaxIdDuGenomeComplet } if {[OuiOuNon "Do I save RefDuGenomeComplet ?"]} { set FichierRefDuGenomeComplet "/genomics/link/Common/fiches/ref_des_genomes_complets" SauveLesLignes [array get RefDuGenomeComplet] dans $FichierRefDuGenomeComplet } return $LesBonnesBanques } proc TouteLaBalise {Bal {Fichier ""} {Close ""}} { global CanalPourTouteLaBalise FichierPourTouteLaBalise if {$Bal=="CloseFilePlease"} { if {[info exists CanalPourTouteLaBalise]} { close $CanalPourTouteLaBalise unset CanalPourTouteLaBalise unset FichierPourTouteLaBalise } } set CloseFileIfEmpty [string equal $Close "CloseFileIfEmpty"] set CloseFileAfterRead [string equal $Close "CloseFileAfterRead"] if {[info exists FichierPourTouteLaBalise]} { if {$Fichier!="" && $FichierPourTouteLaBalise != $Fichier} { close $CanalPourTouteLaBalise unset CanalPourTouteLaBalise } } if { ! [info exists CanalPourTouteLaBalise] } { set FichierPourTouteLaBalise $Fichier set CanalPourTouteLaBalise [open $FichierPourTouteLaBalise "r"] } if {$Bal=="OpenFilePlease"} { return $CanalPourTouteLaBalise } set LesLignes {} while {[gets $CanalPourTouteLaBalise Ligne] >= 0} { if {[regexp "\<$Bal " $Ligne] || [regexp "\<$Bal *\>" $Ligne]} { set LesLignes [list $Ligne] ; break } } if {$LesLignes=={}} { if {$CloseFileIfEmpty} { if {[info exists CanalPourTouteLaBalise]} { close $CanalPourTouteLaBalise unset CanalPourTouteLaBalise unset FichierPourTouteLaBalise } } return "" } while {[gets $CanalPourTouteLaBalise Ligne] >= 0} { lappend LesLignes $Ligne if {[regexp "" $Ligne]} { break } } if {$CloseFileAfterRead} { if {[info exists CanalPourTouteLaBalise]} { close $CanalPourTouteLaBalise unset CanalPourTouteLaBalise unset FichierPourTouteLaBalise } } return [join $LesLignes "\n"] } proc ToutesLesCombinaisons {LesMots aTabPaires} { upvar $aTabPaires TabPaires if {0} { Wup "Exemple de TabPaires" #Nb maximum de mots A dans une phrase# set TabPaires(A,nMaxParPhrase) 1 set TabPaires(B,nMaxParPhrase) 1 set TabPaires(C,nMaxParPhrase) 1 #Nb maximum de couples des mots A et B dans une phrase# set TabPaires(A,B,n) 3 set TabPaires(B,C,n) 3 } set LesCombinaisons {} foreach Mot [lsort -unique $LesMots] { set LesCombinaisons [ToutesLesCombinaisons_recursifs $Mot $LesMots TabPaires $LesCombinaisons] } return $LesCombinaisons } proc ToutesLesCombinaisons_recursifs {Mot LesMots aTabPaires {LesCombinaisons ""}} { upvar $aTabPaires TabPaires set nCombi [llength $LesCombinaisons] foreach LaCombi $LesCombinaisons { set Combi [join $LaCombi " "] set TabPaires($Combi) 1 } set LesCombinaisonsTmp $LesCombinaisons set LesCombinaisons {} if {![info exists TabPaires($Mot)]} {lappend LesCombinaisons [list $Mot]} foreach LaCombi $LesCombinaisonsTmp { lappend LesCombinaisons $LaCombi set CombiAvecLeNouveauMot "[join $LaCombi " "] $Mot" if {[info exists TabPaires($CombiAvecLeNouveauMot)]} {continue} set nDeCeMot 1 foreach MotPrec $LaCombi {if {$Mot == $MotPrec} {incr nDeCeMot}} if {[info exists TabPaires($Mot,nMaxParPhrase)] && [set TabPaires($Mot,nMaxParPhrase)] < $nDeCeMot} {continue} set MotPrec [lindex $LaCombi end] if {![info exists TabPaires($MotPrec,$Mot,n)]} {continue} lappend LaCombi $Mot lappend LesCombinaisons $LaCombi } if {[ListEqual $LesCombinaisonsTmp $LesCombinaisons]} {return $LesCombinaisons} foreach MotSuiv [lsort -unique $LesMots] { if {$Mot != "" && ![info exists TabPaires($Mot,$MotSuiv,n)]} {continue} set LesCombinaisons [ToutesLesCombinaisons_recursifs $MotSuiv $LesMots TabPaires $LesCombinaisons] } return $LesCombinaisons } proc ToutesLesProcsDeGscope {{file ""}} { global ProcsAuDepart LoadTkAndPackages set PAll [list] set ListeProc [lsort [info procs]] foreach e $ListeProc { if {$e in $ProcsAuDepart} {continue} set a [info args $e] set b [info body $e] set sar "" foreach g $a { if {[info default $e $g Def]} { if {$Def == ""} {set Def "\"\""} if {[regexp " " $Def]} {set Def "\"$Def\""} append sar "{$g $Def} " } else { append sar "$g " } } set sar [string trim $sar] lappend PAll "proc $e {$sar} {" lappend PAll $b lappend PAll "}" lappend PAll "" } if {$file ne ""} { set f [open "LesProcsDeGscope.tcl" w] puts $f [join $PAll \n] close $f } return $PAll } proc ToutesLesRegionsDeLaQuery {aTabBlast FichierBlast BanqueId FichierTFA} { upvar $aTabBlast TabBlast set TailleQ [TailleDeLaQueryDuBlast $FichierBlast] set LesRegionsMasquees {} if { ([file exists $FichierTFA] || $FichierTFA != "") && [EstCeDeLADN $FichierTFA] == 1 } { set LesRegionsMasquees [LesRegionsMasqueesDeLaQuery $FichierTFA] } set LesRegionsDuBlast [LesRegionsDeLaQuerySurLeSubject TabBlast $BanqueId] set TailleS [lindex [lindex $LesRegionsDuBlast 0] 4] set ToutesLesRegions {} foreach UneRegionMasquee $LesRegionsMasquees { lappend UneRegionMasquee "" lappend UneRegionMasquee "" lappend UneRegionMasquee "$TailleS" lappend UneRegionMasquee "N" lappend ToutesLesRegions $UneRegionMasquee } foreach UneRegionDuBlast $LesRegionsDuBlast { set UneRegionDuBlast [linsert $UneRegionDuBlast 2 $TailleQ] lappend ToutesLesRegions $UneRegionDuBlast } set ToutesLesRegions [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $ToutesLesRegions]] set LesRegionsVidesDeLaQuery [LesRegionsVidesDeLaListe $ToutesLesRegions $TailleQ] foreach UneRegionVide $LesRegionsVidesDeLaQuery { lappend UneRegionVide "" lappend UneRegionVide "" lappend UneRegionVide "$TailleS" lappend UneRegionVide "RAS" lappend ToutesLesRegions $UneRegionVide } set ToutesLesRegions [lsort -increasing -integer -index 0 [lsort -decreasing -integer -index 1 $ToutesLesRegions]] if {$LesRegionsDuBlast != {}} { set LesRegionsOccupeesSurLeSubject {} foreach UneRegion $ToutesLesRegions { if {[lindex $UneRegion 3] == "" || [lindex $UneRegion 4] == ""} {continue} set DS [lindex $UneRegion 3] set FS [lindex $UneRegion 4] set UneRegion [list "$DS" "$FS"] lappend LesRegionsOccupeesSurLeSubject $UneRegion } set LesRegionsVidesDuSubject [LesRegionsVidesDeLaListe $LesRegionsOccupeesSurLeSubject $TailleS] set LesAutresRegions $ToutesLesRegions set ToutesLesRegions {} foreach UneRegionVide $LesRegionsVidesDuSubject { set LaRegion [list "" "" "$TailleQ"] lappend LaRegion [lindex $UneRegionVide 0] lappend LaRegion [lindex $UneRegionVide 1] lappend LaRegion [lindex $UneRegionVide 2] lappend LaRegion "RAS" lappend ToutesLesRegions $LaRegion } foreach UneRegion $LesAutresRegions { lappend ToutesLesRegions $UneRegion } } return $ToutesLesRegions } proc ToutesLesSequencesTFA {Fichier Rep FileSave} { if {![file exists $Fichier]} {return ""} set LesSequences {} foreach LAccess [LesAccessDuFichier $Fichier] { set Access [lindex $LAccess 0] set File "$Rep/${Access}.tfa" if {![file exists $File]} {Espionne "$File does not exist";continue} lappend LesSequences [ContenuDuFichier $File] } Sauve [join $LesSequences "\n"] dans $FileSave return $LesSequences } proc Toutou {X} { Espionne $X } proc Tparva {} { set Dir "/genomics/link/Tparva" set Pep "$Dir/DuTigr/TPA1.pep" set Prefixe "TP" set LesBornes {} set LeTFA {} if {[FileAbsent "$Dir/prottfa"]} { file mkdir "$Dir/prottfa" } if {[FileAbsent "$Dir/fiches"]} { file mkdir "$Dir/fiches" } set Deb 100 set Fin [expr $Deb+300] set Sens "F" foreach Ligne [LesLignesDuFichier $Pep] { if {[regexp ">" $Ligne]} { if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" } set LesMots [split $Ligne "|"] ScanLaListe $LesMots A T TT D O C X Y set A [string trim $A "> "] regsub "_" $T "" N regsub "TP0" $N "" N set Nom "$Prefixe$N" set LeTFA [list ">$Nom $O $D $C $X $A"] lappend LesBornes ">$Nom $Deb $Fin $Sens" incr Deb 390 set Fin [expr $Deb+300] continue } lappend LeTFA $Ligne } if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" } return [SauveLesLignes $LesBornes dans "$Dir/fiches/bornesdespabs"] } proc TracageFeatureSummary {} { global EFeat LNOrdali Sequences set PAD $EFeat(PAD) $PAD delete all # Liste seq a tracer set Lnoms [list] ; set Lseqs [list] foreach n $LNOrdali { if {$n eq "" || ! $EFeat(LMSeq,$n)} {continue} lappend Lnoms $n lappend Lseqs [set Sequences($n)] lappend Lnaff $EFeat(NSeq,$n) } # nothing to draw if {$Lnoms == {} } {return} set lgnoms [PlusLongEltDe $Lnaff val] set EFeat(WdtNoms) [font measure FontFeat $lgnoms] set EFeat(WdtL) [font measure FontFeat "Z"] set EFeat(HgtL) [lindex [font metrics FontFeat] 5] set OffX 10 ; set OffY 10 # calcule place pour compteur pos set EFeat(WdtCmpt) [expr {[string length [LongueurDeLAlignement]] * $EFeat(WdtL)}] # calcule place pour le texte de seq set nChar [expr {($EFeat(FWidth) - 2*$OffX - $EFeat(WdtNoms) - 2*$EFeat(WdtCmpt) - 3*2)/$EFeat(WdtL)}] set WdtSeq [expr {$nChar * $EFeat(WdtL)}] set d 0 ; set f [expr {$nChar-1}] set slgt [LongueurDeLAlignement] set xPos [expr {$OffX + $EFeat(WdtNoms)}] set yPos $OffY while {$d < $slgt} { if {$f >= $slgt} { set f [expr {$slgt-1}] } # on aligne a droite, on se positionne # a la fin du nom foreach n $Lnoms s $Lseqs naf $Lnaff { $PAD create text $xPos $yPos -anchor ne -justify right -text "$naf" -font FontFeat # DonnePosGS gives ix strting at 1 ! set deb [DonnePosGS $n $d] set fin [DonnePosGS $n $f] incr xPos [expr {2 + $EFeat(WdtCmpt)}] $PAD create text $xPos $yPos -anchor ne -justify right -text "$deb" -font FontFeat incr xPos 2 $PAD create text $xPos $yPos -anchor nw -justify left -text "[string range $s $d $f]" -font FontFeat incr xPos $WdtSeq incr xPos 2 $PAD create text $xPos $yPos -anchor nw -justify left -text "$fin" -font FontFeat incr yPos $EFeat(HgtL) set xPos [expr {$OffX + $EFeat(WdtNoms)}] set yPos [DrawFeatSum $n $xPos $yPos $d $f] } incr d $nChar ; incr f $nChar incr yPos [expr {$EFeat(HgtL)+1}] } lassign [$PAD bbox all] xm ym xx yx set wd [expr {$xx - $xm + 2*$OffX}] set hg [expr {$yx - $ym + 2*$OffY}] $PAD configure -scrollregion [list 0 0 $wd $hg] ShowFeatNote return } proc TraceColBox {x y n col} { set c $::NwOj(Can) set x1 [expr {$x+7}] set y1 [expr {$y-3}] if {$col eq "couldefond"} {set col black} $c create rectangle $x $y1 $x1 $y -fill $col -outline $col -tags [list ColRes Nbr$n] return } proc TraceCylindre {liste QObj la lb col1 col2 {Rd1 0.1} {Rd2 0.1}} { lassign $la x1 y1 z1 lassign $lb x2 y2 z2 set vx [expr {$x2-$x1}] set vy [expr {$y2-$y1}] set vz [expr {$z2-$z1}] set lg [expr {sqrt($vx*$vx+$vy*$vy+$vz*$vz)}] if {$lg == 0.0} { puts "===> lg=0. la = $la lb = $lb" set lg 1. } set al [expr {acos($vz/$lg)*180./acos(-1.)}] if {$vz < 0.0} {set al [expr {-1.*$al}]} set rx [expr {-$vy*$vz}] set ry [expr {$vx*$vz}] set rz 0. glPushMatrix glTranslatef $x1 $y1 $z1 glRotatef $al $rx $ry 0.0 gluCylinder $QObj $Rd1 $Rd2 $lg 32 1 glPopMatrix return } proc TraceHistogramme {LesX LesY {MinX ""} {MaxX ""} {MinY ""} {MaxY ""}} { set LesXTries [lsort -real $LesX] set LesYTries [lsort -real $LesX] if {$MinX eq ""} { set MinX [lindex $LesXTries 0] } if {$MaxX eq ""} { set MaxX [lindex $LesXTries end] } if {$MinY eq ""} { set MinY [lindex $LesYTries 0] } if {$MaxY eq ""} { set MaxY [lindex $LesYTries end] } return } proc TraceLesAxesDePositionPourPromAn {KCanva X Y} { global TabApparitionOuDisparitionDeCetteSelection set Id [$KCanva find withtag current] set MesTags [$KCanva gettags $Id] set ColorIni [lindex $MesTags 2 ] set ColorSel [lindex $MesTags 3 ] set IdDeRef [$KCanva find withtag "GenomicSequence"] set IdCadre [$KCanva find withtag "Cadre" ] if {![info exists TabApparitionOuDisparitionDeCetteSelection($KCanva,$Id)] || [set TabApparitionOuDisparitionDeCetteSelection($KCanva,$Id)] == {}} { set LesCoordsDeRef [$KCanva coords $IdDeRef] set YMinDeRef [lindex $LesCoordsDeRef 1] set YMaxDeRef [lindex $LesCoordsDeRef 3] set LesCoordsDuCadre [$KCanva coords $IdCadre] set XMaxDeRef [lindex $LesCoordsDuCadre 2] set LesCoords [$KCanva coords $Id] set XMin [lindex $LesCoords 0] set YMin [lindex $LesCoords 1] set XMax [lindex $LesCoords 2] set YMax [lindex $LesCoords 3] set LesId {} lappend LesId [$KCanva create line $XMax $YMin $XMaxDeRef $YMin -dash {4 2} -width 2 -fill $ColorSel] lappend LesId [$KCanva create line $XMax $YMax $XMaxDeRef $YMax -dash {4 2} -width 2 -fill $ColorSel] lappend LesId [$KCanva create line $XMin $YMin $XMin $YMaxDeRef -dash {4 2} -width 2 -fill $ColorSel] lappend LesId [$KCanva create line $XMax $YMin $XMax $YMaxDeRef -dash {4 2} -width 2 -fill $ColorSel] $KCanva itemconfigure $Id -fill $ColorSel set TabApparitionOuDisparitionDeCetteSelection($KCanva,$Id) $LesId } else { $KCanva itemconfigure $Id -fill $ColorIni foreach IdLine [set TabApparitionOuDisparitionDeCetteSelection($KCanva,$Id)] {$KCanva delete $IdLine} set TabApparitionOuDisparitionDeCetteSelection($KCanva,$Id) {} } return } proc TraceLiaison {qobj la lb col1 col2 stick} { if {$stick} { #use_light TraceCylindre "" $qobj $la $lb $col1 $col2 } else { #dont_use_light TraceLigne "" $la $lb $col1 $col2 } return } proc TraceLigne {liste la lb col1 col2} { lassign $la x1 y1 z1 lassign $lb x2 y2 z2 set vx [expr {($x2-$x1)/2.+$x1}] set vy [expr {($y2-$y1)/2.+$y1}] set vz [expr {($z2-$z1)/2.+$z1}] if {0} { puts "col1 $col1" puts "col2 $col2" puts " $x1 $y1 $z1" puts " $vx $vy $vz" puts " $x2 $y2 $z2\n" } # glColor3f {*}$col1 nolight_color3fv $col1 glLineWidth 1.0 glBegin GL_LINES glNormal3f 0.0 0.0 0.0 glVertex3f $x1 $y1 $z1 glNormal3f 0.0 0.0 0.0 glVertex3f $vx $vy $vz glEnd # glColor3f {*}$col2 nolight_color3fv $col2 glBegin GL_LINES glNormal3f 0.0 0.0 0.0 glVertex3f $x2 $y2 $z2 glNormal3f 0.0 0.0 0.0 glVertex3f $vx $vy $vz glEnd return } proc TraceObjetDansO {{LaMolId ""}} { global NomEtSeqAssPDB global StrucAVoir global Defauts set LesStruc $LaMolId if {$LaMolId == ""} {set LesStruc $StrucAVoir} foreach mol $LesStruc { set elt [lindex $NomEtSeqAssPDB [lsearch -regexp $NomEtSeqAssPDB $mol]] scan $elt "%s %s %s" pdb NomSeqAss MolId set chn [string index $MolId 5] set MolId [string range $MolId 0 3] IlFautVoir "mol $MolId" IlFautVoir "pai_zo ; ; [CouleurOrdali2O [set Defauts(CoulVariable)]]" set LesOrdres [CouleursPourO [CouleursOrdali ${MolId}_$chn]] foreach ord $LesOrdres { IlFautVoir $ord } IlFautVoir "mol $MolId obj ca$MolId ca ; end" IlFautVoir "mol $MolId obj sp$MolId z ; end" } return } proc TraceObjetDansRasMol {mol} { IlFautVoir "wireframe off" IlFautVoir "structure" IlFautVoir "cartoon" return } proc TraceObjetsDeLaMolDansPyMOL {mol} { VersPyMOL "cartoon loop" set LCmds [CouleursOrdali $mol] foreach c $LCmds { VersPyMOL "$c" } VersPyMOL "show cartoon" VersPyMOL "hide lines" return } proc TraceResBox {x y n type} { set c $::NwOj(Can) set ::NwOj(TypeMax) 7 if {$type > $::NwOj(TypeMax)} {set type 0} incr y -5 switch $type { 0 { # "None" - nothing set x1 [expr {$x+3}] set y2 [expr {$y-4}] $c create line $x1 $y $x1 $y2 -fill cyan -tags [list NBox Type0 Nbr$n NBox$n] } 1 { # "Atoms" - wireframe or stick set y1 $y set x1 [expr {$x+3}] set y2 [expr {$y-3}] $c create line $x1 $y1 $x1 $y2 -fill cyan -tags [list NBox Type1 Nbr$n NBox$n] set x2 $x set y3 [expr {$y2-3}] $c create line $x1 $y2 $x2 $y3 -fill cyan -tags [list NBox Type1 Nbr$n] set x3 [expr {$x1+3}] $c create line $x1 $y2 $x3 $y3 -fill cyan -tags [list NBox Type1 Nbr$n] set y4 [expr {$y3-2}] $c create line $x3 $y3 $x3 $y4 -fill cyan -tags [list NBox Type1 Nbr$n] } 2 { # "Ca/P Trace" - simple ca/p trace set x1 $x ; set x2 [expr {$x+7}] set y1 [expr {$y-2}] $c create line $x1 $y1 $x2 $y1 -fill cyan -tags [list NBox Type2 Nbr$n] } 3 { # "Ribbon" - lit Ribbon on CA or P trace set x1 [expr {$x+7}] set y1 [expr {$y-3}] $c create rectangle $x $y $x1 $y1 -fill black -outline cyan -tags [list NBox Type3 Nbr$n] } 4 { # "Ribbon + Atoms" - Ribbon + sticks set x1 [expr {$x+7}] set y1 [expr {$y-3}] $c create rectangle $x $y $x1 $y1 -fill black -outline cyan -tags [list NBox Type4 Nbr$n] set x2 [expr {$x+3}] set y2 [expr {$y1-3}] $c create line $x2 $y1 $x2 $y2 -fill cyan -tags [list NBox Type4 Nbr$n] set y3 [expr {$y2-3}] $c create line $x2 $y2 $x $y3 -fill cyan -tags [list NBox Type4 Nbr$n] $c create line $x2 $y2 $x1 $y3 -fill cyan -tags [list NBox Type4 Nbr$n] } 5 { # "Ribbon + CPK" - ribbon + CPK sidechains set x1 [expr {$x+7}] set y1 [expr {$y-3}] $c create rectangle $x $y $x1 $y1 -fill black -outline cyan -tags [list NBox Type5 Nbr$n] # 2eme ball , just on top set y2 [expr {$y1-3}] set x1 [expr {$x+3}] ; set x2 [expr {$x+5}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type5 Nbr$n] set x1 $x ; set x2 [expr {$x+3}] set y1 $y2 ; set y2 [expr {$y1-3}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type5 Nbr$n] set x1 [expr {$x+4}] ; set x2 [expr {$x+7}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type5 Nbr$n] } 6 { # "Pearls" - Big ball at residue position set x1 [expr {$x+7}] set y1 [expr {$y-7}] $c create oval $x $y $x1 $y1 -fill black -outline cyan -tags [list NBox Type6 Nbr$n] } 7 { # "CPK" - whole residue as CPK # premiere boule set x1 [expr {$x+2}] ; set x2 [expr {$x+5}] set y1 $y ; set y2 [expr {$y-3}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type7 Nbr$n NBox$n] # 2eme ball , just on top set y1 $y2 ; set y2 [expr {$y1-3}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type7 Nbr$n] set x1 $x ; set x2 [expr {$x+3}] set y1 $y2 ; set y2 [expr {$y1-3}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type7 Nbr$n] set x1 [expr {$x+4}] ; set x2 [expr {$x+7}] $c create oval $x1 $y1 $x2 $y2 -fill black -outline cyan -tags [list NBox Type7 Nbr$n] } } $c raise NBox return } proc TraceStrSec {widget x1 x2 y1 Type} { set HautFont [font metrics SeqFont -displayof $widget -linespace ] set LargFont [font measure SeqFont -displayof $widget A] set y2 [expr {$y1+$HautFont}] set ymil [expr {$y1+$HautFont/2}] set y1t [expr {$y1+$HautFont/3}] set y12t [expr {$y1+2*$HautFont/3+1}] set Id "" if {$Type == "Alpha"} { set Id [$widget create rectangle $x1 $y1 $x2 $y2 -fill red] } if {$Type == "Pi"} { set Id [$widget create rectangle $x1 $y1 $x2 $y2 -fill pink] } if {$Type == "3_10"} { set Id [$widget create rectangle $x1 $y1 $x2 $y2 -fill magenta] } if {$Type == "Sheet"} { set x1f [expr {$x2-$LargFont}] set Id [$widget create polygon $x1 $y1t $x1f $y1t $x1f $y1 $x2 $ymil $x1f $y2 $x1f $y12t $x1 $y12t -fill green -outline black] } if {$Type == "Turn"} { set Id [$widget create oval $x1 $y1 $x2 $y2 -fill blue] } if {$Type == "Coil"} { set xp [expr {$x2+$LargFont-1}] $widget create line $x1 $ymil $x2 $ymil } if {$Id != ""} {$widget raise $Id} return } proc TraceVecLC {f col} { global CanvasLC global MaxX MaxY MinX MinY Max global Delta WinX WinY CentX CentY Radius WinScale global malx maly malnom macol global lx$f global ly$f global LAA set c $CanvasLC if {[$c find withtag $col] != {}} { $c delete $col return } set lx [set lx$f] set ly [set ly$f] puts "\nTrace $f col $col" foreach x $lx y $ly n $LAA { set xv [expr {$x * $WinScale + $CentX}] set yv [expr {$y * $WinScale + $CentY}] $c create line $CentX $CentY $xv $yv -arrow last -fill $col -tags "$col" if {$xv >= $CentX} { set anchorv [expr "{$yv} >= $CentY ? {nw} : {sw} "] } else { set anchorv [expr "{$yv} >= $CentY ? {ne} : {se}" ] } $c create text $xv $yv -text $n -anchor $anchorv -fill $col -tags "$col" } return } proc Tracelaproc {args} { puts "info var [info level -1]" catch {puts "info var [info level -2]"} catch {puts "info var [info level -3]"} return } proc Tracelavar {n1 n2 o} { puts "\n ############" catch {puts "info var -3 : [info level -3]"} catch {puts "info var -2 : [info level -2]"} puts "info var -1 : [info level -1]" global $n1 puts "$n1 [set $n1]" ; flush stdout puts " ############\n" return set i 0 while {$i <= [llength $::LNOrdali]} { puts "\t[join [lrange $::LNOrdali $i [expr {$i+4}]]]" incr i 5 } puts "" return } proc Traduction {Terme {Sortie ""}} { return [lindex [LaTraduction [list $Terme] $Sortie] 0] } proc TraiteAABizarres {{force 0}} { global Sequences Warn foreach n [array names Sequences] { set s [set Sequences($n)] if {! [info exists Warn($n)] || $force} { set val 0 switch -regexp $s { {B} { set val 1 lappend Warn(B) $n } {Z} { set val 1 lappend Warn(Z) $n } {U} { set val 1 lappend Warn(U) $n } {X} { set val 1 lappend Warn(X) $n } {J} { set val 1 lappend Warn(J) $n } {O} { set val 1 lappend Warn(O) $n } {[0-9]} { set val 1 lappend Warn(Numbers) $n } } set Warn($n) $val } } return } proc TraiteComponent {} { set Ll [LesLignesDuFichier components.cif] foreach l $Ll { switch -regexp $l { {^data_} { set cmp [string range $l 5 7] } {^_chem_comp\.type } { regsub -all { +} $l " " l set type [string toupper [join [lrange [split $l " "] 1 end]]] } {^_chem_comp\.pdbx_type } { regsub -all { +} $l " " l set ptyp [lindex [split $l " "] 1] } {^_chem_comp\.one_letter_code } { regsub -all { +} $l " " l set 1ltc [lindex [split $l " "] 1] lappend res [list $cmp $type $ptyp $1ltc] } } } set res [lsort -index 2 $res] set f [open comp.txt w] foreach e $res { puts $f [join $e \t] } close $f exit } proc TraiteGenBankId {pdbid} { global TInf puts "Genbank treatment :" set okseq 0 foreach c [set TInf($pdbid,LChains)] { if {[info exists TInf($pdbid,$c,ok)] && ! $TInf($pdbid,$c,ok)} { continue } puts "\tChain $c" # sequnp peut avoir change avec SEQADV # prend l'original pour comparer set sequnpal $TInf($pdbid,$c,sequnpal) set sequnpori $TInf($pdbid,$c,sequnpori) set SeqAdn "" set Lacc [list] # utilise d abord refseq set Lacc [set TInf($pdbid,$c,rs_acc)] puts "\tAccess: [join $Lacc]" set Lres [DbFetchGET refseq $Lacc] if {$Lres == 0 || $Lres eq ""} { set Lres [eFetchREST nucleotide $Lacc] } if {$Lres == 0 || $Lres eq ""} { puts "PROBLEM loading RefSeq $Lacc !" set Lres "" } set Lres [SplitLesEMBL $Lres] foreach res $Lres { set Lorfs [DecortiqueGenBank OS OC SeqAdn $res] # cherche seq ADN correspondant à la sequence Sws set SeqAdn [ChercheQuelOrf $Lorfs $sequnpori] if {$SeqAdn ne ""} { break } } # not found, try genbank ids set Lacc [set TInf($pdbid,$c,gb_acc)] if {$SeqAdn eq "" && $Lacc != {}} { set Lres [DbFetchGET ena_coding $Lacc] set Lres [SplitLesEMBL $Lres] set fasta [DbFetchGET ena_coding $Lacc fasta] set Lsf [list] DecortiqueUnTFA $fasta Lsf TSf foreach seq $Lsf { set sadn $TSf($seq) if {[SeqNucToSeqPro [string range $sadn end-2 end]] eq "*"} { set sadn [string range $sadn 0 end-3] } set seqtra [SeqNucToSeqPro $sadn] set off [string first $sequnpori $seqtra] if {$off > -1} { set SeqAdn $sadn break } } } set SeqAdn [string toupper $SeqAdn] set TInf($pdbid,$c,seqadn) $SeqAdn if {$SeqAdn eq ""} { # pas bon pour cette chaine set TInf($pdbid,$c,ok) 0 continue } # find an ORF that mathc sequnproi incr okseq set seqpdn [SeqNucToSeqPro $SeqAdn] set TInf($pdbid,$c,seqpdn) $seqpdn set TInf($pdbid,$c,seqpdnal) $seqpdn # met les X dans seqpdn set sequnp $TInf($pdbid,$c,sequnp) if {[string first "X" $sequnp] > -1} { # align seqpdn sur sequnproi # ca s'aligne car c'est le bon orf lassign [NW $seqpdn $sequnpori] seqpdnal tmp set Lsunp [split $sequnp ""] set Lix [lsearch -all $Lsunp "X"] set Lspdn [split $seqpdnal ""] foreach i $Lix { set g 0 ; set s 0 while {$s < $i} { if {[lindex $Lsunp $s] ne "-"} { incr s } incr g } lset Lspdn $g "X" } set seqpdn [join $Lspdn ""] } if {$sequnpori ne $sequnpal} { # sequnp et sequnpori diff sont les X # align sur uniprot deja aligne lassign [NW $seqpdn $sequnpal] seqpdnal sequnpal2 set TInf($pdbid,$c,seqpdnal) $seqpdnal # seqpdb a change, corige ADN if {$seqpdn ne $seqpdnal} { # aligne ADN set a 0 set ns "" for {set i 0} {$i < [string length $seqpdnal]} {incr i} { if {[string index $seqpdnal $i] eq "-"} { append ns "XXX" } else { append ns [string range $SeqAdn [expr {3*$a}] [expr {3*$a+2}]] incr a } } set TInf($pdbid,$c,seqadn) $ns } } # recale si decale set offset [string first $sequnpori $seqpdn] if {$offset > 0} { set seqpdbal $TInf($pdbid,$c,seqpdbal) set seqresal $TInf($pdbid,$c,seqresal) set rep [string repeat "-" $offset] set seqpdbal "$rep$seqpdbal" set sequnpal "$rep$sequnpal" set seqresal "$rep$seqresal" set TInf($pdbid,$c,seqpdbal) $seqpdbal set TInf($pdbid,$c,sequnpal) $sequnpal set TInf($pdbid,$c,seqresal) $seqresal } } if {$okseq > 0} { return 1 } else { return 0 } } proc TraiteGenBankId_test {pdbid} { global TInf puts "Genbank treatment :" set okseq 0 foreach c [set TInf($pdbid,LChains)] { if {[info exists TInf($pdbid,$c,ok)] && ! $TInf($pdbid,$c,ok)} { continue } puts "\tChain $c" set sequnp $TInf($pdbid,$c,sequnpori) set SeqAdn "" set Lacc [list] # utilise d abord refseq set Lacc [set TInf($pdbid,$c,rs_acc)] set Lres [DbFetchGET refseq $Lacc] if {$Lres == 0 || $Lres eq ""} { set Lres [eFetchREST nucleotide $Lacc] } if {$Lres == 0 || $Lres eq ""} { puts "PROBLEM loading RefSeq $Lacc !" set Lres "" } set Lres [SplitLesEMBL $Lres] foreach res $Lres { set Lorfs [DecortiqueGenBank OS OC SeqAdn $res] # cherche seq ADN correspondant à la sequence Sws set SeqAdn [ChercheQuelOrf $Lorfs $sequnp] if {$SeqAdn ne ""} { break } } # not found, try genbank ids if {$SeqAdn eq ""} { set Lacc [set TInf($pdbid,$c,gb_acc)] } set SeqAdn [string toupper $SeqAdn] set TInf($pdbid,$c,seqadn) $SeqAdn if {$SeqAdn ne ""} { incr okseq } else { # pas bon pour cette chaine set TInf($pdbid,$c,ok) 0 } } if {$okseq > 0} { return 1 } else { return 0 } } proc TraiteLesRefSeqP {AccessRefseq} { set Entry [BirdEntryMoi $AccessRefseq entrez_protein] if {$Entry==""} {return ""} foreach Ligne [split $Entry "\n"] { if {[regexp "/gene=" $Ligne]} { set index1 [expr [string first "\"" $Ligne] + 1] set index2 [expr [string last "\"" $Ligne ] - 1] set gn [string range $Ligne $index1 $index2] } if {[regexp "/coded_by=" $Ligne]} { set index1 [expr [string first "\"" $Ligne] + 1] set index2 [expr [string last ":" $Ligne ] - 1] set NM [string range $Ligne $index1 $index2] } if {[regexp "/db_xref=\"GeneID:" $Ligne]} { set index1 [expr [string first ":" $Ligne] + 1] set GeneId [string range $Ligne $index1 end-1] } if {[regexp "/db_xref=\"taxon:" $Ligne]} { set index1 [expr [string first ":" $Ligne] + 1] set taxId [string range $Ligne $index1 end-1] } } return "$gn|$NM|$GeneId|$taxId" } proc TraiteLogTampon {line} { global inBeginLog LogTampon switch -regexp -- $line { {^\@begin} {incr inBeginLog} {^\@end} {incr inBeginLog -1} } append LogTampon $line set res "" if {! $inBeginLog} { set res [OutputTLog Text $LogTampon] set LogTampon "" } return $res } proc TraitePDBDeLAlignement {} { global ListePDB BadPDB HashPDB Sequences LNOrdali PBV PBW PipeCollection Warn LSOrdali SDG Defauts set ListePDB {} set BadPDB {} set HashPDB(iHmax) 0 set ix -1 set PBW "Treating PDB sequences ...." set PBV 0. set Nseq [llength $LNOrdali] set LNtmp $LNOrdali set ToChange [list] foreach seq $LNtmp { set PBV [expr {$PBV + 100. / $Nseq}] incr ix if {! [EstUnAccessPDB $seq]} { continue } set pdbid [DonneIdDeAccessPDB $seq] set chn [DonneChainDeAccessPDB $seq] set ChgN 0 ; set ChgC 0 # try DownloadPDB dont if {$pdbid ni [info commands] && $Defauts(DownloadPDB) ne "dont"} { set cok [LoadNouveauPDB $pdbid] if {$cok == 0} { lappend BadPDB $ix continue } # obsolete or superseeded if {$cok != 1} { set pdbid $cok set ChgN 1 } if {$chn ni [set Lc [$pdbid _chains]]} { set chn [lindex $Lc 0] set ChgC 1 } if {$ChgN || $ChgC} { lappend ToChange [list $ix $pdbid $chn] } } else { # PDB existe deja. # On ne traite pas le PDB mais on # enregistre la nouvelle chaine } # Carefull !! # ListePDB contains the RIGHT name set newname [BonNomPDB ${pdbid}_$chn] lappend ListePDB $newname # update names in group array if {[info exists SDG]} { foreach grp [array names SDG] { if {[set isdg [lsearch [set SDG($grp)] $seq]] != -1} { set SDG($grp) [lreplace [set SDG($grp)] $isdg $isdg $newname] } } } } # Superseeded/obsolete/chain changed if {$ToChange != {} } { foreach k [lsort -integer -decreasing -index 0 $ToChange] { lassign $k i n c set old [lindex $LNtmp $i] set oldid [DonneIdDeAccessPDB $old] set chn [DonneChainDeAccessPDB $old] set newn [BonNomPDB ${n}_$c] puts "old $old newn $newn" set LNtmp [lreplace $LNtmp $i $i $newn] set seq [lindex $LSOrdali $i] unset Sequences($old) set Sequences($newn) $seq # logs ... set log "Warning : entry $old changed to $newn" AuLog @begin warning AuLog @text $log AuLog @end puts "" puts [string repeat "=" [string length $log]] puts $log puts [string repeat "=" [string length $log]] puts "" } } set LNOrdali $LNtmp return } proc TraitePdbId {pdbid} { global TInf SA InitSolventArea puts "PDB treatment :" set pdbText [TextePDB $pdbid ALL "" OnTheWeb] if {$pdbText eq ""} { puts "PDB does not exists !" return 0 } Structure create $pdbid set cok [$pdbid new $pdbText "" 0 1] if {$cok != 1} { puts "\tBad PDB, obsolete or superseeded" if {[info exists ::db]} { #$::db close #unset -nocomplain ::db update } return 0 } unset -nocomplain TInf Str NAcc update # proteins chains set Lc [$pdbid _chains] if {[llength $Lc] == 0 || [llength $Lc] > 20} { puts "\tTOO many chains !" if {[info exists ::db]} { #$::db close #unset -nocomplain ::db } $pdbid destroy update return 0 } set TInf($pdbid,LChains) [list] foreach c $Lc { puts "\tChain $c" set TInf($pdbid,$c,ok) 0 if {[$pdbid _chainIs $c] ne "Protein"} { puts "\tNot a protein" continue } # si residue numerotes avec ABC..., on passe ... set Lnmr [$pdbid _resnumber -chain $c -polymer] set nmr [join $Lnmr ""] if {[regexp {[A-Z]} $nmr]} { puts "\tNumerotation de merde ... passe !" continue } # protein de fusion, on passe if {[EstProteineDeFusion [$pdbid GiveVar Header]]} { puts "\tThis is a fusion protein" continue } # cross reference set Laccid [$pdbid dbref $c] lassign $Laccid acc bid if {$acc eq "" && $bid eq ""} { puts "\tError : no DBREF !" continue } puts "\tDBREF $acc $bid" # sequence set seqpdb [join [$pdbid _resname -chain $c] ""] if {$seqpdb eq ""} { puts "PROBLEM : seqpdb vide !" continue } # sequence seqres ... set seqres [$pdbid _seqres $c] if {$seqres eq ""} { puts "\tPROBLEM ! seqres vide !" continue } # 1: test inclusion simple set seqpdbal $seqpdb set seqresal $seqres set ix [string first $seqpdb $seqres] if {$ix == -1} { lassign [NW $seqpdb $seqres] seqpdbal seqresal if {[string first "-" $seqresal] != -1} { set ok 0 puts "\tERROR : gaps in seqresal !" } else { set ok [RRPSMemeSequences $seqpdbal $seqresal] } if {! $ok} { ShowProtDiff seqpdbal seqresal puts "\tError : SeqRes != SeqPDB !" if {0 && $c eq "A"} { set f1 [open str1.fa w] puts $f1 ">seqpdb" puts $f1 $seqpdb close $f1 set f1 [open str2.fa w] puts $f1 ">seqres" puts $f1 $seqres close $f1 exit } set TInf($pdbid,$c,ok) 0 continue } } else { # offset > -1 # seqpdb included in seqres set seqpdbal "[string repeat - $ix]$seqpdb" } # il y a deja des X dans seqpdb ? (res mod) # si oui, met dans sequnp if {0 && [string first "X" $seqpdbal] != -1} { puts "\t-> Modified residues in PDB !" continue } # chain ok # collect infos # longueur chaine set slgt [string map {- "" X "" 0 ""} $seqpdb] set lgt [string length $slgt] # Recup infos sec struc $pdbid PDBInfos $c # struc. sec. set secstr [$pdbid SecStr -chain $c] set binhe [$pdbid SSBin "helix" $c] set binsh [$pdbid SSBin "sheet" $c] set bintu [$pdbid SSBin "turn" $c] lappend TInf($pdbid,LChains) $c set TInf($pdbid,$c,ok) 1 set TInf($pdbid,$c,length) $lgt set TInf($pdbid,$c,seqpdb) $seqpdb set TInf($pdbid,$c,seqpdbal) $seqpdbal set TInf($pdbid,$c,seqres) $seqres set TInf($pdbid,$c,seqresori) $seqres set TInf($pdbid,$c,up_acc) $acc set TInf($pdbid,$c,up_bid) $bid set TInf($pdbid,$c,secstr) $secstr set TInf($pdbid,$c,bin_he) $binhe set TInf($pdbid,$c,bin_sh) $binsh set TInf($pdbid,$c,bin_tu) $bintu # sauve pdb de la chain $pdbid save $c all all 0 "${pdbid}_${c}.pdb" } # Nettoyage #$::db close #unset -nocomplain ::db update if {$TInf($pdbid,LChains) == {} } { puts "Error : no good chains" return 0 } # sauve le fichier pour exec stride # stride secondary structures # si une chaine non traitee , flag ok=0 set strRSA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwx" foreach c $TInf($pdbid,LChains) { # init set TInf($pdbid,$c,seqrsa) "" # calcul STRIDE catch {exec /home/moumou/bin/stride ${pdbid}_$c.pdb} Msg update set aStride [ReadStrideOutput $Msg] if {$aStride == {} } { puts "STRIDE ERROR ${pdbid}_${c}.pdb\n$Msg" set TInf($pdbid,$c,ok) 0 file delete ${pdbid}_${c}.pdb continue } #set Str(SS,$c) "" #set Str(iS,$c) "" array set Str $aStride set TInf($pdbid,$c,SSi) [set Str(SS,$c)] set TInf($pdbid,$c,sSS) [set Str(iS,$c)] # NAccess # init set TInf($pdbid,$c,seqnac) "" catch {exec naccess ${pdbid}_${c}.pdb} Msg #update if {! [file exists ${pdbid}_${c}.rsa]} { puts "Error in NAccess !" file delete ${pdbid}_${c}.pdb continue } set seqrsa "" if {1} { set Crsa [ContenuDuFichier ${pdbid}_$c.rsa] #puts "$Crsa" set aNAccess [ReadNAccessOutput $Crsa] file delete ${pdbid}_${c}.asa file delete ${pdbid}_${c}.log file delete ${pdbid}_${c}.rsa file delete ${pdbid}_${c}.pdb #puts "aNAccess $aNAccess" array set NAcc $aNAccess set Lseq [split [set TInf($pdbid,$c,seqpdb)] ""] # stride surface area # transforme accessibilite en 'sequence set seqrsa "" if {[info exists Str(SA,$c)]} { set Lsa [set Str(SA,$c)] if {[llength $Lseq] != [llength $Lsa]} { puts "\tSTRIDE : length PDB != length Stride !" } else { foreach sa $Lsa aa $Lseq { if {$aa eq "X" || $sa eq ""} { append seqrsa "0" continue } if {! [info exists SA($aa)]} { append seqrsa "0" continue } set rsa [expr {$sa/$SA($aa)*100.}] if {$rsa >= 100.} { set rsa 99.9 } set rsa [expr {int($rsa/2)}] set arsa [string index $strRSA $rsa] append seqrsa $arsa } } } } set TInf($pdbid,$c,seqrsa) $seqrsa # NAccess accessibility set seqnac "" if {[info exists NAcc(rsa,$c)]} { set Lseq [split [set TInf($pdbid,$c,seqpdb)] ""] if {[llength $Lseq] != [llength [set NAcc(rsa,$c)]]} { puts "\tPROBLEM : length PDB != length NACCESS !" } else { foreach na [set NAcc(rsa,$c)] aa $Lseq sq [set NAcc(seq,$c)] { if {$aa eq "X" || $na eq ""} { append seqnac "0" continue } if {$na >= 100.} { set na 99.9 } set nac [expr {int($na /2)}] set anac [string index $strRSA $nac] append seqnac $anac } } } set TInf($pdbid,$c,seqnac) $seqnac } return 1 } proc TraitePdbId_test {pdbid} { global TInf SA InitSolventArea puts "PDB treatment :" Structure create $pdbid set pdbText [TextePDB $pdbid ALL "" OnTheWeb] set cok [$pdbid new $pdbText "" 0 1] if {$cok != 1} { puts "\tBad PDB, obsolete or superseeded" if {[info exists ::db]} { $::db close unset -nocomplain ::db update } return 0 } unset -nocomplain TInf # proteins chains set Lc [$pdbid _chains] if {[llength $Lc] == 0 || [llength $Lc] > 20} { puts "\tTOO many chains !" if {[info exists ::db]} { $::db close unset -nocomplain ::db } $pdbid destroy update return 0 } set TInf($pdbid,LChains) [list] foreach c $Lc { puts "\tChain $c" if {[$pdbid _chainIs $c] ne "Protein"} { puts "\tNot a protein" set TInf($pdbid,$c,ok) 0 continue } # si residue numerotes avec ABC...etc, on passe ... set Lnmr [$pdbid _resnumber -chain $c -polymer] set nmr [join $Lnmr ""] if {[regexp {[A-Z]} $nmr]} { puts "\tNumerotation de merde ... passe !" set TInf($pdbid,$c,ok) 0 continue } # protein de fusion, on passe if {[EstProteineDeFusion [$pdbid GiveVar Header]]} { puts "\tThis is a fusion protein" set TInf($pdbid,$c,ok) 0 continue } # cross reference set Laccid [$pdbid dbref $c] lassign $Laccid acc bid if {$acc eq "" && $bid eq ""} { puts "\tError : no DBREF !" set TInf($pdbid,$c,ok) 0 continue } puts "\tDBREF $acc $bid" # sequence set seqpdb [join [$pdbid _resname -chain $c] ""] # sequence seqres ... set seqres [$pdbid _seqres $c] # 1: test inclusion simple set seqpdbal $seqpdb set seqresal $seqres set ix [string first $seqpdb $seqres] # chain ok # collect infos # longueur chaine set lgt [string length $seqpdb] # Recup infos sec struc $pdbid PDBInfos $c # struc. sec. set secstr [$pdbid SecStr -chain $c] set binhe [$pdbid SSBin "helix" $c] set binsh [$pdbid SSBin "sheet" $c] set bintu [$pdbid SSBin "turn" $c] lappend TInf($pdbid,LChains) $c set TInf($pdbid,$c,ok) 1 set TInf($pdbid,$c,length) $lgt set TInf($pdbid,$c,seqpdb) $seqpdb set TInf($pdbid,$c,seqpdbal) $seqpdbal set TInf($pdbid,$c,seqres) $seqres set TInf($pdbid,$c,seqresori) $seqres set TInf($pdbid,$c,up_acc) $acc set TInf($pdbid,$c,up_bid) $bid set TInf($pdbid,$c,secstr) $secstr set TInf($pdbid,$c,bin_he) $binhe set TInf($pdbid,$c,bin_sh) $binsh set TInf($pdbid,$c,bin_tu) $bintu # sauve pdb de la chain $pdbid save $c all all 0 "${pdbid}_${c}.pdb" } # Nettoyage $::db close unset -nocomplain ::db update if {$TInf($pdbid,LChains) == {} } { puts "Error : no good chains" return 0 } # sauve le fichier pour exec stride # stride secondary structures # si une chaine non traitee , flag ok=0 set strRSA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwx" foreach c $TInf($pdbid,LChains) { # init set TInf($pdbid,$c,seqrsa) "" # calcul STRIDE catch {exec /home/moumou/bin/stride ${pdbid}_$c.pdb} Msg set aStride [ReadStrideOutput $Msg] file delete ${pdbid}_${c}.pdb set TInf($pdbid,$c,SSi) "ssi" set TInf($pdbid,$c,sSS) "sss" # NAccess # init set TInf($pdbid,$c,seqnac) "" #catch {exec naccess ${pdbid}_${c}.pdb} Msg set seqrsa "" set TInf($pdbid,$c,seqrsa) $seqrsa # NAccess accessibility set seqnac "" set TInf($pdbid,$c,seqnac) $seqnac } return 1 } proc TraitePfamScanResult {a b op} { set res $::Rpfm($b) if {$res eq ""} { set ::Rpfm($b,feat) "" return } package require json set Ldict [::json::json2dict $res] foreach dict $Ldict { set name [dict get $dict name] set desc [dict get $dict desc] set desc [string map {" " "_"} $desc] set acc [dict get $dict acc] if {! [info exists ::Rpfm($acc)]} { incr ::Rpfam(num) set ::Rpfm($acc) $::Rpfm(num) } set color $::Rpfm($acc) set seq [dict get $dict seq] lassign $seq tmp to tmp from lappend ::Rpfm($b,feat) [list $from $to $color "${acc}_$desc"] } exit return } proc TraitePhenoLink {lseq} { foreach ligne $lseq { set disease [DeterminationDisease $ligne] lappend ldisease $disease } return $ldisease } proc TraiteProtSeqLink {lseq} { set acnum "" # on prend en priorite le num swiss-prot set j [lsearch -regexp $lseq "SWISS-PROT"] if {$j != -1} { set acnum [DeterminationAcNum [lindex $lseq $j]] } else { set j [lsearch -regexp $lseq "PIR"] if {$j != -1} { set acnum [DeterminationAcNum [lindex $lseq $j]] } else { set acnum [DeterminationAcNum [lindex $lseq 1]] } } return $acnum } proc TraiteResultatClustering {fres ident {nomgrp ""} {method dpc}} { global ConsMeth LNDG # Lit fichier .clu de CLUSPACK , mais # AVEC LES COORDONNEES !! set IdG 0 if {$nomgrp ne ""} { set IdG [lsearch $LNDG $nomgrp] incr IdG 2 } else { set ConsMeth(IdenGlob) {} set ConsMeth(ConsGlob) {} } # lecture clusters. # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set Lf [LesLignesDuFichier $fres] lappend Lf "" set i 1 foreach l [lrange $Lf 2 end] { if {[regexp -nocase {^Cluster|^Unclustered} $l]} { set ngr "gr$i" set Lv {} set mv 0. set nval 0 } elseif {$l ne ""} { if {! [info exists ngr]} {puts "[join $Lf \n]"} set listev [split $l "\t"] set v [lindex $listev 0] lappend Lv $v set Gres($v) $ngr foreach e [lrange $listev 1 end] { set mv [expr {$mv + $e}] incr nval } } else { if {! $nval} {continue} set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr incr i } } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster # ne2 : nbr elemes cluster No 2 set lv [lsort -decreasing -real [array names TNormV]] if {[llength $lv] > 1} { set top [set TNormV([lindex $lv 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] if {[llength $lv] > 2} { set dos [set TNormV([lindex $lv 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] } else { set dos -1 set ne2 0 set le2 {} } } else { set nel 0 set lel {} set ne2 0 set le2 {} } # remplit tableau des conservations set Lout [list] if {$nomgrp eq ""} { set ConsMeth(IdenGlob) $lel set ConsMeth(ConsGlob) $le2 set Lout [list IdenGlob $lel ConsGlob $le2] } else { set ConsMeth($nomgrp) $lel } return $Lout } proc TraiteResultatClusteringTcl {Lres ident {nomgrp ""} {method dpc}} { global ConsMeth LNDG set IdG 0 if {$nomgrp ne ""} { set IdG [lsearch $LNDG $nomgrp] incr IdG 2 } else { set ConsMeth(IdenGlob) {} set ConsMeth(ConsGlob) {} } # Calcule norme moyenne de chaque cluster # Gres : Tab indexe par le residu, donne le groupe # Tres : Tab indexe par le groupe, donne les resius set i 1 foreach c $Lres { set ngr "gr$i" set Lv [list] set mv 0.0 set nval 0 foreach ind $c { set listev [lrange $ind 1 end] set v [lindex $ind 0] lappend Lv $v set Gres($v) $ngr foreach e $listev { set mv [expr {$mv + $e}] incr nval } } if {! $nval} {continue} set Tres($ngr) $Lv set Mnorm [expr {$mv/$nval}] set TNormI($ngr) $Mnorm set TNormV($Mnorm) $ngr incr i } # cherche cluster avec + grde norme # nel : nbr d'element de ce cluster # ne2 : nbr elemes cluster No 2 set lv [lsort -decreasing -real [array names TNormV]] if {[llength $lv] > 1} { set top [set TNormV([lindex $lv 0])] set nel [llength [set Tres($top)]] set lel [set Tres($top)] if {[llength $lv] > 2} { set dos [set TNormV([lindex $lv 1])] set ne2 [llength [set Tres($dos)]] set le2 [set Tres($dos)] } else { set dos -1 set ne2 0 set le2 {} } } else { set nel 0 set lel {} set ne2 0 set le2 {} } # remplit tableau des conservations set Lret [list] if {$nomgrp eq ""} { set ConsMeth(IdenGlob) $lel set ConsMeth(ConsGlob) $le2 lappend Lret IdenGlob $lel ConsGlob $le2 } else { set ConsMeth($nomgrp) $lel lappend Lret $nomgrp $lel } return $Lret } proc TraiteSequencesAInserer {pkvo l pkvue} { global db foreach e $l { lassign $e new nf old if {! $nf} { lappend Li [$db eval {select lvs.pk_seqali from ln_vue_seqali as lvs, seqinfo as si, seqali as sa where si.access=$new and sa.pk_seqinfo=si.pk_seqinfo and lvs.pk_vue=$pkvue and lvs.pk_seqali=sa.pk_seqali}] } else { set L [$db eval {select * from seqinfo where access=$old}] set ins '$new' set pkref [lindex $L 0] foreach e [lrange $L 2 end] { if {[string trim $e] eq ""} { lappend ins "NULL" } elseif {[string is integer $e] || [string is double $e]} { lappend ins $e } else { lappend ins '$e' } } $db eval "insert into seqinfo values (NULL,[join $ins ,])" set seq [$db eval {select s.seq from seqali as s, ln_vis_seqali as l where s.pk_seqinfo=$pkref and l.pk_vis=$pkvo and l.pk_seqali=s.pk_seqali}] set Npki [$db eval {select max(pk_seqinfo) from seqinfo}] $db eval {insert into seqali values (NULL,$Npki,$seq)} set Npks [$db eval {select max(pk_seqali) from seqali}] lappend Li $Npks } } return $Li } proc TraiteTag {Lt} { set res [list] foreach {k v i} $Lt { if {[regexp {^FX\_} $v]} { set bg [$::NomTextSeq tag cget $v -background] set fg [$::NomTextSeq tag cget $v -foreground] lappend res [list $k $fg $bg $i] } } return $res } proc TraiteUnGDB {id} { global file1 global file2 package require tdom # puts $id set url "http://www.gdb.org/gdb-bin/genera/genera/hgd/Gene?" append url $id set Lignes {} HttpCopy $url Lignes # les lignes sont mises les 1 a la suite des autres # --> introduction de retour chariot pour que le fichier soit analysable set Lnew {} foreach l $Lignes { regsub -all ">" $l ">\n" l set Lnew [concat $Lnew [split $l "\n"]] } # certaines balises sont mal fermees # --> decoupage de la 1ere partie du fichier qui ne contient pas d'info interessantes set i [lsearch -regexp $Lnew "

"] set nl [lrange $Lnew [expr $i+1] end] set Id [dom parse -simple -html $nl] set RId [$Id documentElement] set Lnds [$RId selectNodes //dt/b/a/i] # si le modele de noeud a ete trouve sur la page web if {$Lnds == ""} {return} set test [[lindex $Lnds 0] selectNodes string(.)] # si le premier noeud contient le mot Symbol if {! [regexp "Symbol" $test]} {return} set acnum [RecupereItemDuGDB $Lnds "Protein Sequence Links" $id] if {$acnum != ""} { if {! [regexp "Show" $acnum]} { puts $file2 $acnum } if {![regexp "shortDetail" $id]} { puts $file1 $id } } # set disease [RecupereItemDuGDB $Lnds "Phenotype Links" $id] return } proc TraiteUnGDB_AEffacer {id} { #rR la derniere version est dans dans ~moumou/ordali/src/ordali_ms2ph.Tcl # procedure qui va recuperer les infos de seq proteique pour chaque identifiant gdb global RepAJourGDB global listeARetranscrire set url "http://www.gdb.org/gdb-bin/genera/genera/hgd/Gene?" append url $id set Lignes {} HttpCopy $url Lignes if {$Lignes != ""} { #verification de l'existence d'un lien vers la HGMD if {[lsearch -regexp $Lignes "Human Gene Mutation Database"] != -1} { # si ce lien existe, on recupère la séquences prot du GDB DetermineProtSeqGDB $Lignes $id } else { puts "pas de lien hgmd pour $id" } } return 1 } proc TraiteUnGDB_bis {id} { global file1 global file2 package require tdom # puts $id set url "http://www.gdb.org/gdb-bin/genera/genera/hgd/Gene?" append url $id set Lignes {} HttpCopy $url Lignes # les lignes sont mises les 1 a la suite des autres # --> introduction de retour chariot pour que le fichier soit analysable set Lnew {} foreach l $Lignes { regsub -all ">" $l ">\n" l set Lnew [concat $Lnew [split $l "\n"]] } # certaines balises sont mal fermees # --> decoupage de la 1ere partie du fichier qui ne contient pas d'info interessantes set i [lsearch -regexp $Lnew "

"] set nl [lrange $Lnew [expr $i+1] end] set Id [dom parse -simple -html $nl] set RId [$Id documentElement] # puts "RId = $RId" set Lnds [$RId selectNodes //dt/b/a/i] # si le modele de noeud a ete trouve sur la page web if {$Lnds == ""} {return} set test [[lindex $Lnds 0] selectNodes string(.)] # si le premier noeud contient le mot Symbol if {! [regexp "Symbol" $test]} {return} set Ldisease [RecupereItemDuGDB $Lnds "Phenotype Links" $id] foreach dis $Ldisease { if {[regexp {^[0-9]} $dis]} { puts $file2 "$id\t$dis" } } return } proc TraiteUniProtId {pdbid} { global TInf OrgaScientific puts "UniProt treatment :" foreach c [set TInf($pdbid,LChains)] { if {[info exists TInf($pdbid,$c,ok)] && ! [set TInf($pdbid,$c,ok)]} { continue } puts "\tChain $c" set acc [set TInf($pdbid,$c,up_acc)] puts "\tUniProt $acc" set Lres [split [DbFetchGET uniprot $acc] \n] if {$Lres == 0 || $Lres eq ""} { puts "PROBLEM ! can't retrieve $acc" set TInf($pdbid,$c,ok) 0 continue } set Lgb [ExtraitDRDeUniProt $Lres] set Lrs [ExtraitDRDeUniProt $Lres RefSeq] if {$Lgb == {} && $Lrs == {}} { puts "PROBLEM : no cross db with genbank/refseq in uniprot $acc" set TInf($pdbid,$c,ok) 0 continue } set TInf($pdbid,$c,gb_acc) $Lgb set TInf($pdbid,$c,rs_acc) $Lrs # test organisme et recupere sequence DecortiqueLesLignesEMBL $Lres ID AC DE GN OS OC OX SeqUnp if {! [regexp -nocase "$OrgaScientific" $OS]} { puts "\tError : Bad organism : $OS" set TInf($pdbid,$c,ok) 0 continue } set TInf($pdbid,$c,sequnpori) $SeqUnp set seqres $TInf($pdbid,$c,seqres) set seqresal $seqres set TInf($pdbid,$c,seqresal) $seqresal set seqpdbal $TInf($pdbid,$c,seqpdbal) set TInf($pdbid,$c,sequnp) $SeqUnp # check if seqadv ... set seqadvChange 0 set Ladv [$pdbid _seqadv $c] if {$Ladv != {} } { set chg [CheckSeqAdv $c $Ladv] if {$chg} { set seqadvChange 1 puts "\tseqres, sequnp changed by SEQADV" set seqres $TInf($pdbid,$c,seqres) set SeqUnp $TInf($pdbid,$c,sequnp) set seqpdbal $TInf($pdbid,$c,seqpdbal) } } if {0} { set f1 [open f1.fa w] puts $f1 ">seqres" puts $f1 $seqres close $f1 set f1 [open f2.fa w] puts $f1 ">sequnp" puts $f1 $SeqUnp close $f1 exit } set offset [string first $seqres $SeqUnp] if {$offset == -1} { lassign [NW $seqres $SeqUnp] seqresal sequnpal set ok [RRPSMemeSequences $seqresal $sequnpal] if {! $ok} { puts "Error : seqres pdb pas dans seq uniprot" ShowProtDiff seqresal sequnpal set TInf($pdbid,$c,ok) 0 continue } set seqpdbal [RealignSeqContreSeq $seqpdbal $seqresal 0 0] set TInf($pdbid,$c,seqpdbal) $seqpdbal #ShowProtDiff seqpdbal seqresal } else { # offset != -1 set dec [string repeat - $offset] set seqresal "$dec$seqres" set sequnpal $SeqUnp # et ausi pdbal set seqpdbal $TInf($pdbid,$c,seqpdbal) set seqpdbal "$dec$seqpdbal" set TInf($pdbid,$c,seqpdbal) $seqpdbal } set TInf($pdbid,$c,seqres) $seqres set TInf($pdbid,$c,seqresal) $seqresal set TInf($pdbid,$c,sequnp) $SeqUnp set TInf($pdbid,$c,sequnpal) $sequnpal set TInf($pdbid,$c,offset) $offset #ShowProtDiff seqresal seqpdbal # si seqres a bouge, re-ealigner seqpdbal if {0 && $seqadvChange} { set seqpdbal [set TInf($pdbid,$c,seqpdbal)] # record 0 <-insertions set Lres [split $seqresal ""] set Li0 [lsearch -all $Lres "0"] foreach i $Li0 { lset Lres $i "-" } set seqg [join $Lres ""] #lassign [NW $seqpdbal $seqg] seqpdbal seqg set seqpdbal [RealignSeqContreSeq $seqpdbal $seqg] set TInf($pdbid,$c,seqpdbal) $seqpdbal } } return 1 } proc TraiteUniProtId_old {pdbid} { global TInf OrgaScientific puts "UniProt treatment :" foreach c [set TInf($pdbid,LChains)] { if {[info exists TInf($pdbid,$c,ok)] && ! [set TInf($pdbid,$c,ok)]} { continue } puts "\tChain $c" set acc [set TInf($pdbid,$c,up_acc)] puts "\tUniProt $acc" set Lres [split [DbFetchGET uniprot $acc] \n] if {$Lres == 0 || $Lres eq ""} { puts "PROBLEM ! can't retrieve $acc" set TInf($pdbid,$c,ok) 0 continue } #set Lgb [ExtraitDRDeUniProt $Lres] set Lrs [IDMapping "ACC+ID" REFSEQ_NT_ID $acc] set Lgb [IDMapping "ACC+ID" EMBL_ID $acc] #set Lrs [ExtraitDRDeUniProt $Lres RefSeq] if {$Lgb == {} && $Lrs == {}} { puts "Error : no cross db with genbank/refseq in uniprot $acc" set TInf($pdbid,$c,ok) 0 continue } set TInf($pdbid,$c,gb_acc) $Lgb set TInf($pdbid,$c,rs_acc) $Lrs # test organisme et recupere sequence DecortiqueLesLignesEMBL $Lres ID AC DE GN OS OC OX SeqUnp if {! [regexp -nocase "$OrgaScientific" $OS]} { puts "\tError : Bad organism : $OS" set TInf($pdbid,$c,ok) 0 continue } set TInf($pdbid,$c,sequnp) $SeqUnp set TInf($pdbid,$c,sequnpori) $SeqUnp # test seqres pdb contre uniprot set seqres $TInf($pdbid,$c,seqres) set offset [string first $seqres $SeqUnp] set TInf($pdbid,$c,offset) $offset } return 1 } proc TraitementDesPFAMs {Sequence Type Note LongueurFeature} { scan $Note "%s" NumeroPFAM set DefinitionPFAM [StringSuivant $NumeroPFAM dans $Note] set OriginePropagation [StringSuivant "from" dans $Note] set OriginePropagation [string trim $OriginePropagation] regsub -all " from $OriginePropagation" $DefinitionPFAM "" DefinitionPFAM set DefinitionPFAM [string trim $DefinitionPFAM] set ListePFAMs [list $Sequence $Type $NumeroPFAM $DefinitionPFAM $OriginePropagation $LongueurFeature] return $ListePFAMs } proc TraitementDesRegionsEtBlocks {Sequence Type Note LongueurFeature} { regsub -all "REGION_|SBLOCK_" $Note "" NumeroRegion set ListeRegions [list $Sequence $Type $NumeroRegion $LongueurFeature] return $ListeRegions } proc Transcript {Bornes aSeqADN} { upvar $aSeqADN SeqADN Wup "create the mRAN from the DNA ... I will soon use join and complement etc." scan $Bornes "%d %d %s" Debut Fin Orient incr Debut -1 incr Fin -1 set Seq [string range $SeqADN $Debut $Fin] if {$Orient=="F"} { return $Seq } else { return [NucToReverseAndComplementNuc $Seq] } } proc TranscriptVariants {} { set Titre "Trancript Variants" set Old [PourWscope] PourWscope 1 Html_ZeroToBody $Titre PourWscope $Old Html_Append "

$Titre

" Html_Append "
" foreach Box [ListeDesPABs] { Espionne [Html_TranscriptVariants $Box] } Html_BodyToEnd set Texte [Html_Get "ZeroIt"] return $Texte } proc TranscriptVariantsEnDur {} { if {[regexp -nocase "Mouse" [RepertoireDuGenome]]} { set FileHtml TranscriptVariantsMouse } elseif {[regexp -nocase "Rat" [RepertoireDuGenome]]} { set FileHtml TranscriptVariantsRat } else { set FileHtml TranscriptVariants } set LeHtml [TranscriptVariants] Garde "[GenoretDir]/Collaboration/Splicing/${FileHtml}.html" set ficOut "[GenoretDir]/Collaboration/Splicing/${FileHtml}.html" set f [open $ficOut w] puts $f $LeHtml } proc TranscriptomicBestFriendsInCluster {Nom {Quoi ""} {Comment ""}} { set Extension "-lesbestcops" if {$Comment==""} { set Comment "FileContent" } if {$Quoi==""} { set Quoi "All"} set Fichier "[TranscriptomicBestFriendsInClusterDir]/${Nom}-$Quoi$Extension" if {[FileExists $Fichier]} { if {$Comment=="FileContent"} { return [ContenuDuFichier $Fichier] } if {$Comment=="NiceWeb"} { return [NiceWebOfCluster [ContenuDuFichier $Fichier]] } } if {$Quoi!="Filenames" || $Quoi!="All"} { return "" } set Probesets [ExtraitInfo $Nom "ProbeSetId:"] regsub -all "/" $Probesets "-OU-" Probesets regsub -all "," $Probesets " " Probesets set LesPS [LesMotsDeLaLigne $Probesets] set LaSortie {} foreach PS $LesPS { set Fichier "[TranscriptomicBestFriendsInClusterDir]/$Nom-$PS$Extension" if {[FileAbsent $Fichier]} {continue} if {$Quoi=="FileNames"} { lappend LaSortie $Fichier } if {$Quoi=="All"} { lappend LaSortie [ContenuDuFichier $Fichier] } } return [join $LaSortie "\n"] } proc TranscriptomicBestFriendsInClusterDir {} { return "[RepertoireDuGenome]/transcriptomique/LesCopainsCluster" } proc TranscriptomicClusters {Nom {Quoi ""}} { if {$Quoi==""} { set Quoi "All"} set Fichier "[TranscriptomicClustersDir]/${Nom}_$Quoi" if {[FileExists $Fichier]} { return [ContenuDuFichier $Fichier] } set Probesets [ExtraitInfo $Nom "ProbeSetId:"] regsub -all "/" $Probesets "-OU-" Probesets regsub -all "," $Probesets " " Probesets set LesPS [LesMotsDeLaLigne $Probesets] set LaSortie {} foreach PS $LesPS { set Fichier "[TranscriptomicClustersDir]/$Nom-$PS" if {[FileAbsent $Fichier]} {continue} if {$Quoi=="FileNames"} { lappend LaSortie $Fichier } if {$Quoi=="All"} { lappend LaSortie [ContenuDuFichier $Fichier] } } return [join $LaSortie "\n"] } proc TranscriptomicClustersDir {} { return "[RepertoireDuGenome]/transcriptomique/cluster" } proc TranscriptomicSignalIntensity {Nom} { set Rep "[RepertoireDuGenome]/transcriptomique/SignalIntensity" set LesFichiers [glob -nocomplain "$Rep/$Nom-*"] set LaSortie {} foreach Fichier $LesFichiers { set Queue [file tail $Fichier] set Probeset [StringSuivant "-" dans $Queue] lappend LaSortie "" lappend LaSortie "$Nom $Probeset" foreach Ligne [LesLignesDuFichier $Fichier] { ScanLaListe [split $Ligne "\t"] Ps Ch Ex Sa Si Ca Re So lappend LaSortie "$Ps [format "%6.2f" $Si] [format "%1s" $Ca] $Re [format "%-8s" $So] $Ch $Ex $Sa" } } set Texte [join $LaSortie "\n"] if {[PourWscope]} { return [Html_DuTexteTelQuel $Texte] } return $Texte } proc TranscritRetina {} { return [TranscriptVariants] } proc TransformationCartesienne {AId n} { global Abr global Xmin Xmax Ymin Ymax set t [set Abr(Arbre,$AId)] set Le [$t children $n] if {$n ne "root" && [$t get $n ordre]} {set Le [lreverse $Le]} foreach e $Le { TransformationCartesienne $AId $e } set theta [$t get $n theta] set r [$t get $n r] set x [expr {$r*cos($theta)}] set y [expr {$r*sin($theta)}] $t set $n xcoord $x $t set $n ycoord $y set Xmin [expr {$Xmin<$x?$Xmin:$x}] set Ymin [expr {$Ymin<$y?$Ymin:$y}] set Xmax [expr {$Xmax>$x?$Xmax:$x}] set Ymax [expr {$Ymax>$y?$Ymax:$y}] return } proc TransformationPolaire {AId n theta lower upper} { global Abr subangleMax set t [set Abr(Arbre,$AId)] if {[$t isleaf $n]} {return} set epsilon 0.0001 set w [$t get $n width] set pr [$t get $n r] set ptheta [$t get $n theta] set subangle [expr {($upper-$lower)/$w}] if {$subangle < $subangleMax} {set subangleMax $subangle} set angle $upper set Le [$t children $n] if {$n ne "root" && [$t get $n ordre]} {set Le [lreverse $Le]} foreach e $Le { set we [$t get $e width] set len [$t get $e length] set angle [expr {$angle - $we / 2.0 * $subangle}] set len [expr {$len<0.?0.:$len}] set nr [expr {sqrt($len*$len + $pr*$pr + 2.*$len*$pr*cos($angle - $ptheta))}] $t set $e r $nr if {abs( $pr*cos($ptheta) + $len*cos($angle)) > $epsilon} { set ntheta [expr {atan( ($pr*sin($ptheta) + $len*sin($angle)) / ($pr*cos($ptheta) + $len*cos($angle)))}] } elseif {$pr*sin($ptheta) + $len*sin($angle) >= 0.0} { set ntheta [expr {[Pi] / 2.}] } else { set ntheta [expr {1.5 * [Pi]}] } if {$pr*cos($ptheta) + $len*cos($angle) < -$epsilon} { set ntheta [expr {$ntheta + [Pi]}] } $t set $e theta $ntheta if {! [$t isleaf $e]} { TransformationPolaire $AId $e $ntheta [expr {$angle - $we*$subangle/2.}] [expr {$angle + $we*$subangle/2.}] } else { $t set $e oldtheta $angle } set angle [expr {$angle - $we / 2.0 * $subangle}] } return } proc TransformeColonneEnLigne {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" nom append Fichier "$nom " } return $Fichier } proc TransformeExonsEnIntrons {Path Limit} { #Parser de GetExons permettant de recuperer le plus proche intron d'un Exon pour Dave set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TransformeExonsEnIntrons : Start" set FichierExon [open "$Path.coord" "r"] set FichierIntron [open "$Path.csv" "w"] set Davisque 0 set nbIntrons 0 set moyenne 0 set distanceCumulee 0 set distanceCumuleeIntron1 0 set oldAccess "" set oldStartE 0 set oldEndE 0 set exonPargeneDuGene 1 set sommeExon 0 set introns1 0 set nbIntronsConsideres 0 set listeDesRatios {} while { [gets $FichierExon Ligne] >= 0} { ScanLaListe $Ligne ID Access Exon Chromosome StartE EndE strand exonCount if { $oldEndE != $EndE && $oldStartE != $StartE } { if { $Exon != "Exon1"} { set IntronStart $oldEndE set IntronEnd $StartE set Distance [expr $IntronEnd - $IntronStart + 1] set distanceCumulee [expr $distanceCumulee + $Distance] if {$Exon == "Exon2" && $strand == "+"} { set distanceCumuleeIntron1 [expr $distanceCumuleeIntron1 + $Distance] incr introns1 } regsub -all -nocase {Exon|Intron} $Exon "" Num if {$Distance <= $Limit} { incr Davisque set rat [expr (100 * $Num) / $exonCount] lappend listeDesRatios $rat Espionne $rat } puts $FichierIntron "$Distance $Access $Exon $Chromosome:$IntronStart-$IntronEnd" incr exonPargeneDuGene incr nbIntronsConsideres } else { if { $exonPargeneDuGene != 0} { lappend ListeDesNombreDIntron $exonPargeneDuGene } else { lappend ListeDesNombreDIntron 1 } set exonPargeneDuGene 1 } } set oldEndE $EndE set oldStartE $StartE incr nbIntrons } set MoyenneIntron1 [expr $distanceCumuleeIntron1 / $introns1] Espionne "Consideres $nbIntronsConsideres / Totaux $nbIntrons (Intron 1 : $MoyenneIntron1" set len [llength $ListeDesNombreDIntron] foreach nbExon $ListeDesNombreDIntron { set sommeExon [expr $sommeExon + $nbExon] #-Espionne $sommeExon } set sommeRatio 0 set nbRatios [llength $listeDesRatios] foreach ratio $listeDesRatios { set sommeRatio [expr $sommeRatio + $ratio] } set ratioMoyen [expr $sommeRatio / $nbRatios] Espionne "$sommeExon / $len" set moyenneNbExon [expr $sommeExon / $len ] set ProportionDavisque [expr (100 * $Davisque) / $nbIntrons] set moyenne [expr $distanceCumulee / $nbIntrons] Espionne "$nbIntrons avec en moyenne une longeur de $moyenne pb dont $Davisque ($ProportionDavisque %) a moins de $Limit avec un ratio de $ratioMoyen" Espionne "De plus les genes ont en moyenne moyenne $nbExon exons" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|TransformeExonsEnIntrons : End" close $FichierExon close $FichierIntron } proc TransformeFC {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set LesElts [split $Ligne "\t"] set NumGene [lindex $LesElts 0] set FC [lindex $LesElts 1] if {$FC>0 && $FC<1} {set FC [expr -(1/$FC)]} if {$FC==1} {set FC 0} lappend L "$NumGene\t$FC" } return $L } proc TransformeFichierBACPourCBS {LesFichiers} { foreach nom $LesFichiers { puts $nom set FIC [open $nom "r"] gets $FIC ligne set compteur 0 while {[gets $FIC ligne]>10} { set chrom($compteur) [lindex $ligne 0] set position($compteur) [expr round([lindex $ligne 1])] set log_ratios($compteur) [lindex $ligne 2] set compteur [expr $compteur + 1] } close $FIC set FIC [open "$nom.txt" "w"] puts $FIC "log_ratios chrom position" for {set i 0} {$i<$compteur} {incr i} { set mot $chrom($i) if {![regexp {_random} $chrom($i)]} { puts $FIC "$log_ratios($i) $chrom($i) $position($i)"; } } close $FIC } } proc TransformeFichierOligoPourCBS {LesFichiers} { foreach nom $LesFichiers { puts $nom set FIC [open $nom "r"] gets $FIC ligne set compteur 0 while {[gets $FIC ligne]>10} { if {[regexp -nocase "random" $ligne]} {continue} set chrom($compteur) [lindex $ligne 0] set debut($compteur) [lindex $ligne 1] regsub {^0+} $debut($compteur) {} debut($compteur) set fin($compteur) [lindex $ligne 2] regsub {^0+} $fin($compteur) {} fin($compteur) set position($compteur) [expr round(($debut($compteur)+$fin($compteur))/2.0)] set log_ratios($compteur) [expr [lindex $ligne 3]*log(10.0)/log(2.0)] set compteur [expr $compteur + 1] } close $FIC set FIC [open "$nom.txt" "w"] puts $FIC "log_ratios chrom position" for {set i 0} {$i<$compteur} {incr i} { set mot $chrom($i) if {![regexp {_random} $chrom($i)]} { puts $FIC "$log_ratios($i) $chrom($i) $position($i)"; } } close $FIC } } proc TransformeLesClonesDeCW {} { set Fichier "/home/carles/genomes/DD2/CW.txt" set CodesBonsPourDataBase "" foreach Ligne [LesLignesDuFichier $Fichier] { regsub -all -nocase {\s} $Ligne " " Ligne set LesCodes [split $Ligne " "] foreach Code $LesCodes { regsub -all {[ab]} $Code "-" Code append CodesBonsPourDataBase "$Code\n" } } return $CodesBonsPourDataBase } proc TransformeLigneEnColonne {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { set LesNoms [split $Ligne " "] foreach Nom $LesNoms { #Espionne $Nom append Fichier "$Nom\n" } } return $Fichier } proc Tree2Coordonnees {AId} { global Abr subangleMax Xmin Xmax Ymin Ymax set subangleMax 999. TransformationPolaire $AId root [expr {[Pi]/2.}] [expr {-[Pi]/2.}] [expr {3.*[Pi]/2.}] set Abr($AId,subangleMax) $subangleMax set Xmin 999999. set Ymin 999999. set Xmax -999999. set Ymax -999999. TransformationCartesienne $AId root return } proc Tree2PH {t n} { if {[$t isleaf $n]} {return $n} set x "(" set Lnd [list] foreach fils [$t children $n] { set l ":[$t get $fils length]" lappend Lnd "[Tree2PH $t $fils]$l" } append x [join $Lnd ,] ")" if {$n eq "root"} {append x ";"} return $x } proc Tree:closeallchildren {w v} { global Tree if {![info exists Tree($w:$v:open)]} return Tree:close $w $v foreach c $Tree($w:$v:children) { Tree:closeallchildren $w "$v/$c" } } proc Tree:createallchildren {KTree LeCheminComplet} { global Tree set Chemin "" foreach LeNewChild $LeCheminComplet { set NewChild [lindex $LeNewChild 0] set OpenOuClose [lindex $LeNewChild 1] set image [lindex $LeNewChild 2] set Chemin "$Chemin/$NewChild" if {[info exists Tree($KTree:$Chemin:open)]} {continue} Tree:newitem $KTree $Chemin -image $image TreeOpenOuClose $KTree $Chemin $OpenOuClose } } proc Tree:delitem {w v} { global Tree if {![info exists Tree($w:$v:open)]} return if {[string compare $v /]==0} { # delete the whole widget catch {destroy $w} foreach t [array names Tree $w:*] { unset Tree($t) } } if {[info exists Tree($w:$v:children)]} { foreach c $Tree($w:$v:children) { catch {Tree:delitem $w $v/$c} } unset Tree($w:$v:children) } if {[info exists Tree($w:$v:open)]} {unset Tree($w:$v:open)} if {[info exists Tree($w:$v:icon)]} {unset Tree($w:$v:icon)} set dir [file dirname $v] if {[info exists Tree($w:$dir:children)]} { set n [file tail $v] set i [lsearch -exact $Tree($w:$dir:children) $n] if {$i>=0} { set Tree($w:$dir:children) [lreplace $Tree($w:$dir:children) $i $i] } } Tree:buildwhenidle $w } proc Tree:openallchildren {w v} { global Tree if {![info exists Tree($w:$v:open)]} return Tree:open $w $v foreach c $Tree($w:$v:children) { Tree:openallchildren $w "$v/$c" } } proc TreeDeLeaf {name} { foreach t $::Ltrees { set Lt [$t serialize] if {[lsearch -exact [lindex $Lt 2] $name] != -1} { return $t } } return "" } proc TreeFromArbre {Valeur Arbre {Type Classe}} { global NumeroPourTreeFromArbre if { ! [info exists NumeroPourTreeFromArbre]} { set NumeroPourTreeFromArbre 0 } incr NumeroPourTreeFromArbre set Beau [format "N_%5.5d" $NumeroPourTreeFromArbre] set Valeur $Beau if {[EstUneFeuille $Arbre]} { set Access [NomDeLaFeuille $Arbre] if {$Type=="Access"} { set Info $Access } if {$Type=="Organisme"} { set Info [OrgaDuAccess $Access] } if {$Type=="Classe"} { set Info [OCduOS [OrgaDuAccess $Access]] } # set L [NewLeaf [list $Valeur $Info]] set L [NewLeaf $Info] return $L } Dedouble $Arbre G x D y # set T [NewTreeFromTrees [list $Valeur ""] [TreeFromArbre $x $G $Type] [TreeFromArbre $y $D $Type]] set T [NewTreeFromTrees $Valeur [TreeFromArbre $x $G $Type] [TreeFromArbre $y $D $Type]] return $T } proc TreeOpenOuClose {K Chemin {OpenOuClose Open}} { global Tree if {![info exists Tree]} {return} if {[string equal -nocase $OpenOuClose "Open"]} { set Tree($K:$Chemin:open) 1 return } if {[string equal -nocase $OpenOuClose "Close"]} { set Tree($K:$Chemin:open) 0 return } return } proc TresseVRP {{FichierMSF ""} {FichierTresse ""} {Derive 0}} { while { ! [file exists $FichierMSF]} { if {$FichierMSF==""} { FaireLire "Please, browse for a MSF file." set FichierMSF [ButineArborescence "All" "[RepertoireDuGenome]/"] } elseif {[regexp [ExpressionReguliereDesPABs] $FichierMSF]} { set FichierMSF "[RepertoireDuGenome]/msf/$FichierMSF" } if {$FichierMSF==""} { return "" } if { ! [file exists $FichierMSF]} { if {[OuiOuNon "$FichierMSF\n doesn't exist. Do I skipp ?"]} { return "" } set FichierMSF "" } } if {$FichierTresse==""} { FaireLire "Please, give a filename for output." set FichierTresse [FichierPourSaveAs] } if {$FichierTresse==""} { return "" } set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesNomsDeSequences Sequences] set Sortie {} lappend Sortie "begin_object [string range [file tail $FichierMSF] end-5 end ]" set Ieme 0 foreach Nom $LesNomsDeSequences { incr Ieme set Sequence [set Sequences($Nom)] set Objet [format "%s%3.3d" "Seq" $Ieme] set Couleur [Nuance3x8 [expr 1.0*$Ieme/$NombreDeSequences]] scan $Couleur "%d %d %d" r g b set CouleurPourO [expr ($r*256 + $g)*256 + $b] lappend Sortie " colour $CouleurPourO" set Trace "move" set X 0.0 set Y 0.0 set Z 0.0 set dZ 1.0 foreach A [split $Sequence ""] { set Z [expr $Z+$dZ] scan [VecteurVRP $A] "%f %f" dX dY set X [expr $X+$dX] set Y [expr $Y+$dY] if {$Derive} { lappend Sortie "$Trace $X $Y $Z" } else { lappend Sortie "move 0.0 0.0 $Z" lappend Sortie "line $dX $dY $Z" } set Trace "line" } # lappend Sortie "end" # Espionne [set FichierCree [SauveLesLignes $Sortie dans ${FichierTresse}$Objet]] # regsub "/groupes/poch" $FichierCree "/home" FichierCree # lappend LesFichiersCrees "draw $FichierCree" } Espionne [SauveLesLignes $Sortie dans $FichierTresse] # Espionne [SauveLesLignes $LesFichiersCrees dans $FichierTresse] exit } proc Tresults {pktest pfamid Lval} { global db lassign $Lval Nseq Lgt m sd Lpro $db eval {update pfam set nseqs=$Nseq,lgt=$Lgt,idm=$m,idsd=$sd where pfamid=$pfamid} foreach p $Lpro { $db eval {insert into propfam values(NULL,$p,$pfamid)} } update return [list] } proc TriAlea {SeuilExpect MaxListe lAccess lPN} { if {[llength $lAccess] < 3} {return $lAccess} set i 0 foreach e $lPN { if {$e <= $SeuilExpect} { incr i } else { break } } set Ntot $i # on a au max 500 sequences dans init, donc on peut garder au max # 0.6 * 500 sequences if {$Ntot > 500} { set Garde [expr 500 * 0.4] } else { set Garde [expr $Ntot * 0.4] } # set NOte [expr $Ntot * 0.6] # set Garde [expr $Ntot - $NOte] if {$Garde > $MaxListe} {set Garde $MaxListe} #Espionne "NOte vaut $NOte" Espionne "garde vaut $Garde" #set Garde [expr round($Garde)] #Espionne "garde vaut $Garde" set n 1 set Lidx {} while {$n < $Garde} { set idx [expr round(rand() * [expr $Ntot - 1])] if {[lsearch $Lidx $idx] == -1} { lappend Lidx $idx incr n } } set Lidx [lsort -integer -decreasing $Lidx] #Espionne $Lidx set LesElus {} foreach e $Lidx { lappend LesElus [lindex $lAccess $e] } #Espionne "les elus sont $LesElus" return $LesElus } proc TriBilanHDACroises {K Index SurQui} { global MemoBilanHDACroises set LesXs [set MemoBilanHDACroises($K,LesXs)] set LesYs [set MemoBilanHDACroises($K,LesYs)] foreach {C V} [array get MemoBilanHDACroises] { regsub "$K," $C "" C set T($C) $V } if {$SurQui=="SurOrganisme"} { set Ordres {"bidon" "BAE" "SampledBAE" "Alpha"} set Ordre [lindex $Ordres $Index] set LesGenoTries [LesGenomesDansLeBonOrdre $Ordre] foreach Y $LesYs { set JExiste($Y) 1 } set LesVYs {} foreach G $LesGenoTries { set Y [string toupper [Glossaire $G Court]] if { ! [info exists JExiste($Y)]} { continue } lappend LesYsTries $Y } set Titre "X-HDA sorted by Organisms ($Ordre)" return [DessineBilanHDACroises $LesXs $LesYsTries T $Titre] } if {$SurQui=="SurFamille"} { set Id [$K find withtag current] set MesTags [$K gettags $Id] set Famille [lindex $MesTags 1] set LesVYs {} foreach Y $LesYs { set V [set T($Famille,$Y)] set VY [split $V " "] lappend VY $Y lappend LesVYs $VY set YduVY($VY) $Y } set LesVYsTries [lsort -decreasing -index [expr $Index-1] -integer $LesVYs] set LesYsTries {} foreach VY $LesVYsTries { set Y [set YduVY($VY)] lappend LesYsTries $Y } set Titre "X-HDA sorted by $Famille ($Index)" return [DessineBilanHDACroises $LesXs $LesYsTries T $Titre] } if {$SurQui=="SurLaMoyenne"} { Wup "il faut trier LesXs en fonction de la valeur du Bilan" set Id [$K find withtag current] set MesTags [$K gettags $Id] set Complet [lindex $MesTags 0] set Orga [lindex $MesTags 1] set LesVXs {} foreach X $LesXs { set Famille $X set V [set T($Famille,$Orga)] set VX [split $V " "] lappend VX $X lappend LesVXs $VX set XduVX($VX) $X } set LesVXsTries [lsort -decreasing -index [expr $Index-1] -integer $LesVXs] set LesXsTries {} foreach VX $LesVXsTries { set X [set XduVX($VX)] lappend LesXsTries $X } set Titre "X-HDA sorted with $Complet ($Index)" return [DessineBilanHDACroises $LesXsTries $LesYs T $Titre] } } proc TriCami {e m la lp} { global DefautsPipe set lbon "" set maxPQS [expr $m - 50] set i 0 set j 0 foreach a $la { if {![regexp -nocase {^PQS} $a] && ![regexp -nocase {^PDB} $a]} { if {$i < 50} { lappend lbon $a incr i } } else { if {$j < $maxPQS} { lappend lbon $a incr j } } } return $lbon } proc TriDeFichiers {A B} { set DA [file dirname $A] set DB [file dirname $B] if {$DA<$DB} { return -1 } if {$DA>$DB} { return 1 } return [string compare [file tail $A] [file tail $B]] } proc TriDeJean {fichier} { set NombreDeY 0 set NombreDeN 0 set NombreTotal 0 foreach ligne [LesLignesDuFichier $fichier] { scan $ligne "%s %s" PAB Type if {$Type=="y"} {incr NombreDeY} if {$Type=="n"} {incr NombreDeN} incr NombreTotal lappend LesPabs $ligne } EspionneL $LesPabs Espionne "Nbr Total $NombreTotal WrongStartCodon" Espionne "In O-Island $NombreDeY [format "%4.2f" [expr $NombreDeY./$NombreTotal.*100]]%" Espionne "In Both strain $NombreDeN [format "%4.2f" [expr $NombreDeN./$NombreTotal.*100]]%" exit return [list $LesPabs $NombreDeY [format "%4.2f" [expr $NombreDeY./$NombreTotal.]] $NombreDeN [format "%4.2f" [expr $NombreDeN./$NombreTotal]] $NombreTotal] } proc TriEuca {e m la lp} { global DefautsPipe if {$m > 100} { set maxPDB 25 } else { set maxPDB [expr $m/4] } # m est MaxHitListe set ficTmp "./listeAccForBird.txt" set ficOutTar "bird.tar.gz" set ficOutTarDec "bird.tar" set ficOut "listeEuca" set lbon "" set nbPDB 0 if {$la != ""} { # creation du fichier necessaire pour interroger BIRD set f [open $ficTmp w] foreach a $la { puts $f "ID [EnlevePrefixeBank $a] DB Prot" puts $f "WH OC contains Eukaryota" puts $f "FD ID,AC" puts $f "//" } close $f set urlBird [set DefautsPipe(Url,birdHoan)] set CommandeBird "[CurlExe] -F upload=@$ficTmp ${urlBird}bsearch?service=querycomplexe&out_file=${ficOut}&interpro=yes -o ${ficOutTar}" if {[catch {eval exec $CommandeBird} Message]} {puts "$Message"} if {[file exists $ficOutTar]} { catch {eval exec gunzip -f $ficOutTar} Message catch {eval exec tar -xf $ficOutTarDec} Message if {[file exists ${ficOut}.sw]} { set lignes [LesLignesDuFichier ${ficOut}.sw] foreach a $la { if {[EstUnAccessPDB $a]} { if {[llength $lbon] < $m && $nbPDB < $maxPDB} { lappend lbon $a incr nbPDB } } elseif {[lsearch -regexp $lignes [EnlevePrefixeBank $a]] != -1 && [llength $lbon] < $m} { lappend lbon $a } } } } file delete -force $ficTmp $ficOutTar ${ficOut}.* } return $lbon } proc TriFDD {exp mxs la lp} { set lBanqueId $la set lPN $lp set LDPN {} set LD2PN {} set LD3PN {} if {[llength $lPN] < 5} { set LesElus $lBanqueId return $LesElus } # Transformation E-values # set lPN [LisseCourbe $lPN] foreach e $lPN { if {$e == 0.0} {set e "1.0e-300"} set e [expr log($e)] lappend llogPN $e } set Eder [lindex $lPN end] # Calcul des derivee premiere, seconde et tierce set LDPN [Derivee $llogPN] # set LDPN [LisseCourbe $LDPN] set LDPN [linsert $LDPN 0 -300.] set LD2PN [Derivee $LDPN] set LD2PN [linsert $LD2PN 0 300.] # set LD2PN [linsert $LD2PN end 300.] set LD3PN [Derivee $LD2PN] set LD3PN [linsert $LD3PN 0 300.] # set LD3PN [linsert $LD3PN end 300. 300.] # fait tri # Met toujours le Premier lappend LesElus [lindex $lBanqueId 0] set nelus 0 set i 0 set LDt [lrange $LD3PN 0 end] set LBt [lrange $lBanqueId 0 end] foreach e $LDt { if {$i == 0 || $i == 1} { incr i continue } set icou [expr $i-1] set Flag 0 if {$e < 0.0} { set prev [lindex $LDt ${icou}] if {$prev > 0.0} { lappend LesElus [lindex $LBt $icou] lappend Lid $icou set Flag 1 incr nelus } } if {$nelus >= $mxs} {break} incr i } foreach i $LesElus { if {$i == ""} {continue} lappend res $i } set LesElus $res return $LesElus } proc TriFragments {Page {Maniere ""} {Action ""}} { if {$Action==""} { set Action "Affiche" } if {$Maniere==""} { set Maniere "Ask" } if {$Maniere=="Ask"} { set Maniere [ChoixParmi [list "FillLimitsWith_000" "FullLeftRightOnSameLine" "1_3_0" "0_3_1" "0_" "1_" "2_" "3_" "Other"]] } if {$Maniere=="Other"} { set Maniere [Entre "0_1_2_3_"] } set LesLignes [split $Page "\n"] if {$Maniere=="FillLimitsWith_000"} { foreach Ligne $LesLignes { if {[regexp -- {^[^_]+_([^ \-_]+\-[0-9]+\-[0-9]+)_} $Ligne Match Sujet]} { set LesMots [split $Sujet "-"] ScanLaListe $LesMots N D F set BeauSujet [format "%s-%4.4d-%4.4d" $N $D $F] regsub -- "\-" $Sujet "\\\-" SujetRX regsub $SujetRX $Ligne $BeauSujet Ligne set DiffLong [expr [string length $BeauSujet]-[string length $Sujet]] set iB [string first " " $Ligne] regsub [string repeat " " $DiffLong] $Ligne "" Ligne } lappend LesLignesTriees $Ligne } } elseif {[regexp {^[0-9]+_[0-9]*} $Maniere]} { set Maniere [string trim $Maniere "_"] set LOrdre [split $Maniere "_"] set LesLignesTriees [LesLignesTrieesSurUneClefEntete $LesLignes $LOrdre] } elseif {$Maniere=="FullLeftRightOnSameLine"} { foreach Ligne $LesLignes { set Entete "" scan $Ligne "%s %d %d %f %f" Entete Residues Charged Molecularweight Isoelectricpoint if {$Entete==""} { continue } regsub "_" $Entete " " ZoNom scan $ZoNom "%s %s" Zone Nom if { ! [info exists DejaVu($Nom)]} { lappend LesNoms $Nom } set DejaVu($Nom) 1 foreach Var [list Entete Residues Charged Molecularweight Isoelectricpoint] { set P($Nom,$Zone,$Var) [set $Var] } } foreach Nom $LesNoms { set ZoNom [string range "All_$Nom" 0 36] set ChargedF [set P($Nom,Full,Charged)] set ChargedL [set P($Nom,Left,Charged)] set ChargedR [set P($Nom,Righ,Charged)] set MolecularweightF [set P($Nom,Full,Molecularweight)] set MolecularweightL [set P($Nom,Left,Molecularweight)] set MolecularweightR [set P($Nom,Righ,Molecularweight)] set IsoelectricpointF [set P($Nom,Full,Isoelectricpoint)] set IsoelectricpointL [set P($Nom,Left,Isoelectricpoint)] set IsoelectricpointR [set P($Nom,Righ,Isoelectricpoint)] lappend LesLignesTriees [format "%-40.40s %3d %3d %3d %10.2f %10.2f %10.2f %5.2f %5.2f %5.2f" $ZoNom $ChargedF $ChargedL $ChargedR $MolecularweightF $MolecularweightL $MolecularweightR $IsoelectricpointF $IsoelectricpointL $IsoelectricpointR ] } } else { return $Page } set BellePage [join $LesLignesTriees "\n"] if {$Action=="Retour"} { return $BellePage } return [AfficheVariable $BellePage "AvecTriFragments"] } proc TriHKL {Fichier} { set Sortie {} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%5d %5d %5d %f %f %f %f %f %f %f %f" h k l Fp SFp Fm SFm F SF DF SDF puts "$h $k $l" if {$SDF<0} { continue } if {$SFm<0} { set SFm 0 } lappend Sortie [format "%5d%5d%5d%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e" $h $k $l $Fp $SFp $Fm $SFm $F $SF $DF $SDF] } puts [SauveLesLignes $Sortie dans "$Fichier.nouveau"] } proc TriLesLocalisations {{BestOnly ""}} { global RepertoireDuGenome set BestOnly [regexp -nocase "BestOnly" $BestOnly] if {$BestOnly} { set Best ".best" } else { set Best "" } set FichLoc "$RepertoireDuGenome/fiches/localisationchrocontig" set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best" set FichTrF "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best" if { ! [file exists $FichLoc]} { return [list {} {}] } while {[file exists $FichTrD]} { if {[OuiOuNon "$FichTrD already exists. Do I use it ?"]} { return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]] } if {[OuiOuNon "$FichTrD already exists. Do I overwrite it ?"]} { File delete -force $FichTrD File delete -force $FichTrF } else { if {[OuiOuNon "Do I stop ?"]} { exit } } } foreach Ligne [LesLignesDuFichier $FichLoc] { scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens if {$BestOnly && [info exists Dejavu($Nom)]} { continue } set Dejavu($Nom) 1 set CC "$Chro $Contig" lappend LesLocsDesCC($CC) $Ligne if { ! [info exists DejaVu($CC)]} { lappend LesCC $CC } set DejaVu($CC) 1 } set LesCCT [lsort $LesCC] foreach CC $LesCCT { set LesDebuts {} set LesFins {} if {[info exists DejaDebut]} { unset DejaDebut ; unset LesLocsDesDebuts} if {[info exists DejaFin]} { unset DejaFin ; unset LesLocsDesFins} foreach Ligne [set LesLocsDesCC($CC)] { scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens lappend LesLocsDesDebuts($Debut) $Ligne if { ! [info exists DejaDebut($Debut)]} { lappend LesDebuts $Debut } set DejaDebut($Debut) 1 lappend LesLocsDesFins($Fin) $Ligne if { ! [info exists DejaFin($Fin)]} { lappend LesFins $Fin } set DejaFin($Fin) 1 } set LesDebuts [lsort -integer $LesDebuts] set LesFins [lsort -integer $LesFins] foreach Debut $LesDebuts { AppendAuFichier $FichTrD [join [set LesLocsDesDebuts($Debut)] "\n"] } foreach Fin $LesFins { AppendAuFichier $FichTrF [join [set LesLocsDesFins($Fin)] "\n"] } } return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]] } proc TriListeCorrespondance {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { lappend LaCorrespondance $Ligne } set ListeTriee [lsort -dictionary -index 2 $LaCorrespondance] return $ListeTriee } proc TriMeta {e m la lp} { global DefautsPipe if {$m > 100} { set maxPDB 25 } else { set maxPDB [expr $m/4] } # m est MaxHitListe set ficTmp "./listeAccForBird.txt" set ficOutTar "bird.tar.gz" set ficOutTarDec "bird.tar" set ficOut "listeMeta" set lbon "" set nbPDB 0 if {$la != ""} { # creation du fichier necessaire pour interroger BIRD set f [open $ficTmp w] foreach a $la { puts $f "ID [EnlevePrefixeBank $a] DB Prot" puts $f "WH OC contains Metazoa" puts $f "FD ID,AC" puts $f "//" } close $f set urlBird [set DefautsPipe(Url,birdHoan)] set CommandeBird "[CurlExe] -F upload=@$ficTmp ${urlBird}bsearch?service=querycomplexe&out_file=${ficOut}&interpro=yes -o ${ficOutTar}" if {[catch {eval exec $CommandeBird} Message]} {puts "$Message"} if {[file exists $ficOutTar]} { catch {eval exec gunzip -f $ficOutTar} Message catch {eval exec tar -xf $ficOutTarDec} Message if {[file exists ${ficOut}.sw]} { set lignes [LesLignesDuFichier ${ficOut}.sw] foreach a $la { if {[EstUnAccessPDB $a]} { if {[llength $lbon] < $m && $nbPDB < $maxPDB} { lappend lbon $a incr nbPDB } } elseif {[lsearch -regexp $lignes [EnlevePrefixeBank $a]] != -1 && [llength $lbon] < $m} { lappend lbon $a } } } } file delete -force $ficTmp $ficOutTar ${ficOut}.* } return $lbon } proc TriMounir {e m la lp} { if {[llength $la] < 2} {return $la} set i 0 set n 0 set palier 0. foreach p $lp { set pal($i) $p if {$p == "1e-200"} {set pal($i) 0.} set j [expr $i - 1] if {$i > 0 && [expr [set pal($i)] * [set pal($j)] ]} { set palier [expr $palier + log([set pal($i)]) - log([set pal($j)]) ] } incr i incr n } set palier [expr $palier / ($n - 1)] # prends toujours le premier set i 0 set nok 0 set liste {} while {($i < $n) && ($nok < $m)} { if {$i == 0} { lappend liste [lindex $la 0] set exprev [set pal(0)] incr nok } else { if {[set pal($i)] != 0.} { if {$exprev == 0.} { lappend liste [lindex $la $i] set exprev [set pal($i)] set difference 0. incr nok } else { set difference [expr log([set pal($i)])-log($exprev)] } # Si la difference est sup. au palier on prend la sequence if {$difference > $palier} { lappend liste [lindex $la $i] set exprev [set pal($i)] incr nok } } } incr i } return $liste } proc TriNature {e m la lp} { # m est MaxHitListe set lbon [lrange $la 0 $m] return $lbon } 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 TriParScoreMinEtLongueurMin {ratioScores a b} { set scoreA [lindex $a 0] set defA [lindex $a 1] set scoreB [lindex $b 0] set defB [lindex $b 1] # Attention : scores tous négatifs (<= -13) if {[expr ($scoreA < $scoreB) ? double($scoreB) / $scoreA : double($scoreA) / $scoreB] >= $ratioScores} { if {[string length $defA] < [string length $defB]} { return -1 } elseif {[string length $defA] > [string length $defB]} { return 1 } } else { if {$scoreA < $scoreB} { return -1 } elseif {$scoreA > $scoreB} { return 1 } } return 0 } proc TriSplice {e m la lac lp ld} { global DefautsPipe set lbon {} # defini le nombre max de sequences de chaque orga set max [expr $m / 11] set i 0; set j 0; set k 0; set l 0; set o 0; set p 0 set q 0; set r 0; set s 0; set t 0; set u 0 set n 0 foreach a $la ac $lac de $ld { set Orga "" if {![regexp {^ENS} $a]} { if {[regexp "OS=" $de]} { set Orga [string trim [StringSuivant "OS=" dans $de]] if {[regexp "GN=" $Orga]} { set index [string first "GN=" $Orga] set Orga [string trim [string range $Orga 0 [expr $index-1]]] } elseif {[regexp "Length =" $Orga]} { set index [string first "Length =" $Orga] set Orga [string trim [string range $Orga 0 [expr $index-1]]] } else { Espionne "==========$a n'a pas d'OS============" } } } if { ([regexp "[InterrogeCorresEnsEtOS "Homo sapiens" Ens]P\[0-9\]" $ac] || ($Orga == "Homo sapiens" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $i < $max } { lappend lbon $a incr i incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Mus musculus" Ens]P\[0-9\]" $ac] || ($Orga == "Mus musculus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $j < $max } { lappend lbon $a incr j incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Rattus norvegicus" Ens]P\[0-9\]" $ac] || ($Orga == "Rattus norvegicus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $k < $max } { lappend lbon $a incr k incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Canis familiaris" Ens]P\[0-9\]" $ac] || (($Orga == "Canis familiaris" || $Orga == "Canis lupus familiaris") && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $l < $max } { lappend lbon $a incr l incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Danio rerio" Ens]P\[0-9\]" $ac] || ($Orga == "Danio rerio" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $o < $max } { lappend lbon $a incr o incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Xenopus tropicalis" Ens]P\[0-9\]" $ac] || ($Orga == "Xenopus tropicalis" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $p < $max } { lappend lbon $a incr p incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Bos taurus" Ens]P\[0-9\]" $ac] || ($Orga == "Bos taurus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $q < $max } { lappend lbon $a incr q incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Gallus gallus" Ens]P\[0-9\]" $ac] || ($Orga == "Gallus gallus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $r < $max } { lappend lbon $a incr r incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Tetraodon nigroviridis" Ens]P\[0-9\]" $ac] || ($Orga == "Tetraodon nigroviridis" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $s < $max } { lappend lbon $a incr s incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Ornithorhynchus anatinus" Ens]P\[0-9\]" $ac] || ($Orga == "Ornithorhynchus anatinus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $t < $max } { lappend lbon $a incr t incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Monodelphis domestica" Ens]P\[0-9\]" $ac] || ($Orga == "Monodelphis domestica" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $u < $max } { lappend lbon $a incr u incr n } } return $lbon } proc TriSpliceAnne {e m la lac lp ld} { global DefautsPipe set lbon "" # defini le nombre max de sequences de chaque orga set max [expr $m / 4] set i 0 set j 0 set k 0 set l 0 set n 0 foreach a $la ac $lac de $ld { if {([regexp {ENSP[0-9]} $a] || [regexp {_HUMAN} $a] || ([regexp {[NXYZA]P_[0-9]} $ac] && [regexp {\[Homo sapiens\]} $de])) && $i < $max} { lappend lbon $a incr i incr n } elseif {([regexp {ENSMUSP[0-9]} $a] || [regexp {_MOUSE} $a] || ([regexp {[NXYZA]P_[0-9]} $ac] && [regexp {\[Mus musculus\]} $de])) && $j < $max} { lappend lbon $a incr j incr n } elseif {([regexp {ENSRNOP[0-9]} $a] || [regexp {_RAT} $a] || ([regexp {[NXYZA]P_[0-9]} $ac] && [regexp {\[Rattus norvegicus\]} $de])) && $k < $max} { lappend lbon $a incr k incr n } elseif {([regexp {ENSTNIP[0-9]} $a] || [regexp {_TETNG} $a] || ([regexp {[NXYZA]P_[0-9]} $ac] && [regexp {\[Tetraodon nigroviridis\]} $de])) && $l < $max} { lappend lbon $a incr l incr n } elseif {[EstUnAccessVarSplic $a]} { if {([regexp {_HUMAN} $ac] || [regexp {_MOUSE} $ac] || [regexp {_RAT} $ac] || [regexp {_TETNG} $ac]) && $n < $m} { lappend lbon $a incr n } } } return $lbon } proc TriSpliceMoi {e m la lac lp ld} { global DefautsPipe set lbon {} # defini le nombre max de sequences de chaque orga set max [expr $m / 11] set i 0; set j 0; set k 0; set l 0; set o 0; set p 0 set q 0; set r 0; set s 0; set t 0; set u 0 set n 0 foreach a $la ac $lac de $ld { Espionne "a $a ac $ac de $de" set Orga "" if {![regexp {^ENS} $a]} { Espionne "onentre" if {[regexp "OS=" $de]} { set Orga [string trim [StringSuivant "OS=" dans $de]] if {[regexp "GN=" $Orga]} { set index [string first "GN=" $Orga] set Orga [string trim [string range $Orga 0 [expr $index-1]]] } elseif {[regexp "Length =" $Orga]} { set index [string first "Length =" $Orga] set Orga [string trim [string range $Orga 0 [expr $index-1]]] } else { Espionne "==========$a n'a pas d'OS============" } } } Espionne "onestla" Espionne "Orga $Orga ++" if { ([regexp "[InterrogeCorresEnsEtOS "Homo sapiens" Ens]P\[0-9\]" $ac] || ($Orga == "Homo sapiens" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $i < $max } { Espionne "entre Homo" lappend lbon $a incr i incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Mus musculus" Ens]P\[0-9\]" $ac] || ($Orga == "Mus musculus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $j < $max } { Espionne "entre Mus" lappend lbon $a incr j incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Rattus norvegicus" Ens]P\[0-9\]" $ac] || ($Orga == "Rattus norvegicus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $k < $max } { Espionne "entre Rattus" lappend lbon $a incr k incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Canis familiaris" Ens]P\[0-9\]" $ac] || (($Orga == "Canis familiaris" || $Orga == "Canis lupus familiaris") && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $l < $max } { Espionne "entre Canis" lappend lbon $a incr l incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Danio rerio" Ens]P\[0-9\]" $ac] || ($Orga == "Danio rerio" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $o < $max } { Espionne "entre Danio" lappend lbon $a incr o incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Xenopus tropicalis" Ens]P\[0-9\]" $ac] || ($Orga == "Xenopus tropicalis" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $p < $max } { Espionne "entre Xenopus" lappend lbon $a incr p incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Bos taurus" Ens]P\[0-9\]" $ac] || ($Orga == "Bos taurus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $q < $max } { Espionne "entre Bos" lappend lbon $a incr q incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Gallus gallus" Ens]P\[0-9\]" $ac] || ($Orga == "Gallus gallus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $r < $max } { Espionne "entre Gallus" lappend lbon $a incr r incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Tetraodon nigroviridis" Ens]P\[0-9\]" $ac] || ($Orga == "Tetraodon nigroviridis" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $s < $max } { Espionne "entre Tetraodon" lappend lbon $a incr s incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Ornithorhynchus anatinus" Ens]P\[0-9\]" $ac] || ($Orga == "Ornithorhynchus anatinus" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $t < $max } { Espionne "entre Ornithorhynchus" lappend lbon $a incr t incr n } elseif { ([regexp "[InterrogeCorresEnsEtOS "Monodelphis domestica" Ens]P\[0-9\]" $ac] || ($Orga == "Monodelphis domestica" && ([regexp {[NXYZA]P_[0-9]} $ac] || [regexp {^SW:} $a] || [regexp {^TR:} $a] || [EstUnAccessVarSplic $a]))) && $u < $max } { Espionne "entre Monodelphis" lappend lbon $a incr u incr n } } return $lbon } proc TriStrips {SeuilExpect MaxListe lAccess lBanqueId lPN lDE} { if {[llength $lAccess] < 2} {return $lAccess} set MaxNbElus $MaxListe set NombreMiniDeProches 1 set LesLBsEtLeursCandidats [LesBandelettesDuBlastGrid $lAccess $lBanqueId $lPN $lDE] set LesElus {} set TousLesProches {} set NbElus 0 foreach {LB SesCandidats} $LesLBsEtLeursCandidats { catch {unset PremierSW} catch {unset PremierTout} catch {unset PremierPDB} foreach Candidat $SesCandidats { scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX if {[EstUnAccessPDB $BId]} { if {! [info exists PremierPDB]} {set PremierPDB $BId } continue } if {[EstUnAccessSwissprot $BId]} { if {! [info exists PremierSW]} { set PremierSW $BId } } if {! [info exists PremierTout]} { set PremierTout $BId } } set Capital "" if { [info exists PremierSW]} { set Capital $PremierSW } elseif { [info exists PremierTout]} { set Capital $PremierTout } elseif { [info exists PremierPDB]} { set Capital $PremierPDB } set NProchesPrisPourCetteBandelette 0 foreach Candidat $SesCandidats { set OX "" scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX # on ne prend pas les PDB par defaut... if {![EstUnAccessPDB $BId]} { lappend LesProches "$BId $Access $PN $OX" set BonAPrendre [expr $PN<=0.001 && [string equal $BId $Capital]] } #lappend LesProches "$BId $Access $PN $OX" #set BonAPrendre [expr [EstUnAccessPDB $BId] || $PN<=0.001 && [string equal $BId $Capital]] if {$BonAPrendre} { lappend LesElus "$BId $Access $PN $OX" set NbElus [llength $LesElus] if {$NbElus > $MaxNbElus} { break } } if {$PN<=0.001} { lappend TousLesProches "$BId $Access $PN $OX" } else { if { ! [info exists DejaBascule] && [llength $LesElus]<$NombreMiniDeProches} { set DejaBascule 1 lappend TousLesProches "$BId $Access $PN $OX" set LesElus $TousLesProches } } } if {$NbElus > $MaxNbElus} { break } } Espionne "il y a $NbElus elus" set res [ExtraitListeDeListe $LesElus 0] return $res } proc TriVert {e m la lp} { global DefautsPipe if {$m > 100} { set maxPDB 25 } else { set maxPDB [expr $m/4] } # m est MaxHitListe set ficTmp "./listeAccForBird.txt" set ficOutTar "bird.tar.gz" set ficOutTarDec "bird.tar" set ficOut "listeVert" set lbon "" set nbPDB 0 if {$la != ""} { # creation du fichier necessaire pour interroger BIRD set f [open $ficTmp w] foreach a $la { puts $f "ID [EnlevePrefixeBank $a] DB Prot" puts $f "WH OC contains Vertebrata" puts $f "FD ID,AC" puts $f "//" } close $f set urlBird [set DefautsPipe(Url,birdHoan)] set CommandeBird "[CurlExe] -F upload=@$ficTmp ${urlBird}bsearch?service=querycomplexe&out_file=${ficOut}&interpro=yes -o ${ficOutTar}" if {[catch {eval exec $CommandeBird} Message]} {puts "$Message"} if {[file exists $ficOutTar]} { catch {eval exec gunzip -f $ficOutTar} Message catch {eval exec tar -xf $ficOutTarDec} Message if {[file exists ${ficOut}.sw]} { set lignes [LesLignesDuFichier ${ficOut}.sw] foreach a $la { if {[EstUnAccessPDB $a]} { if {[llength $lbon] < $m && $nbPDB < $maxPDB} { lappend lbon $a incr nbPDB } } elseif {[EstUnAccessVarSplic $a] && [llength $lbon] < $m} { lappend lbon $a } elseif {[lsearch -regexp $lignes [EnlevePrefixeBank $a]] != -1 && [llength $lbon] < $m} { lappend lbon $a } } } } file delete -force $ficTmp $ficOutTar ${ficOut}.* } return $lbon } proc TrieAleatoirement {TexteA TexteB} { set n [expr round(rand())] if {[string equal $TexteA $TexteB]} { return 0 } elseif {$n == 0} { return -1 } else { return 1 } } proc TrieBCMRes {what} { global GR Lrm if {$what eq "cree"} { lassign [split $GR(lim) " "] slimmin slimmax if {$GR(gap) eq "All"} { set sgap "*" } else { set sgap $GR(gap) } if {$GR(cm) eq "All"} { set scm "*" } else { set scm $GR(cm) } set Ltmp [array names Lrm "$slimmin,$slimmax,$sgap,$scm"] set GR(vis) [list] foreach k $Ltmp { lassign [split $k ,] lmin lmax gap cm foreach l [set Lrm($k)] { lassign $l meth sens spec power nTot nLSA nFind npkr lappend GR(vis) [list $sens $spec $power $meth $gap $cm $nTot $nLSA $nFind] } } set GR(LabelInfo) "Sens Spec Power " } elseif {$GR(vis) == {} } { return } elseif {$what eq "sens"} { set GR(vis) [lsort -real -index 0 -decreasing $GR(vis)] } elseif {$what eq "spec"} { set GR(vis) [lsort -real -index 1 -decreasing $GR(vis)] } else { set GR(vis) [lsort -real -index 2 -decreasing $GR(vis)] } $GR(text) configure -state normal $GR(text) delete 1.0 end set lgt [PlusLongEltDe $GR(Lmeth)] puts "lgt $lgt" set Elvis [list] set fmt "%6.4f %6.4f %6.4f | %- ${lgt}s %4.2f %s | %6d %6d %6d" foreach l $GR(vis) { lappend Elvis [format $fmt {*}$l] } $GR(text) insert end "[join $Elvis \n]" $GR(text) configure -state disabled return } proc TrieDoubles {a b} { lassign $a sa ssa ga na pa gna gpa npa lassign $b sb ssb gb nb pb gnb gpb npb set mxa [expr {max($ga,$pa,$na)}] set mxb [expr {max($gb,$pb,$nb)}] if {abs($mxa-$mxb) >= 5.} { if {$mxa < $mxb} {return 1} if {$mxa > $mxb} {return -1} } else { if {min($ga,$pa,$na) != 0. && min($gb,$nb,$pb) != 0.} { set ma [expr {$ga*$pa*$na}] set mb [expr {$gb*$pb*$nb}] if {$ma < $mb} {return 1} if {$ma > $mb} {return -1} } else { if {$mxa > $mxb} {return 1} if {$mxa < $mxb} {return -1} } } return 0 return 0 } proc TrieEtAffiche {Texte {CommandeDeTri ""} {Maniere ""} {NomDuFichierOrigine ""}} { set LesLignes [split $Texte "\n"] if {$CommandeDeTri==""} { set CommandeDeTri "Alpha" } if {[regexp -nocase "^Alpha" $CommandeDeTri]} { set LesTriees [lsort $LesLignes] } elseif {[regexp {^[0-9]+$} $CommandeDeTri]} { set Colonne $CommandeDeTri set LesTriees [lsort -index $Colonne $LesLignes] } else { set Commande [Entre "lsort -index 1 "] if {$Commande==""} { return "" } set LesTriees [eval $Commande \$LesLignes] } return [AfficheListe $LesTriees $Maniere $NomDuFichierOrigine] } proc TrieFileGrid {a b} { set x [NumeroDuWU $a] set y [NumeroDuWU $b] if {$x > $y} {return 1} if {$x == $y} {return 0} if {$x < $y} {return -1} } proc TrieGroupesSeqlab {a b} { if {[string range $a 1 end] >= [string range $b 1 end]} { return 1 } elseif {[string range $a 1 end] == [string range $b 1 end]} { return 0 } else { return -1 } } proc TrieIntPfam {a b} { lassign $a d1 f1 lassign $b d2 f2 if {$d1 < $d2} {return -1} if {$d1 > $d2} {return 1} if {$f1 < $f2} {return 1} if {$f1 > $f2} {return -1} return 0 } proc TrieKey {a b} { set ia -1 set ib -1 set i 0 foreach c {name type manufacturer composition description url} { if {[regexp "^$c" $a]} {set ia $i} if {[regexp "^$c" $b]} {set ib $i} incr i } if {$ia > $ib} {return 1} if {$ia < $ib} {return -1} if {$ia == $ib && $ia != -1} {return 0} return 0 } proc TrieLaSortie {LaSortie} { #refait le contenu du fichier #met le clone dont la sequence est la plus longue devant foreach Ligne $LaSortie { set LesJumeaux [split $Ligne " "] set LaNouvelleLigne [TrieLesJumeauxParLongueurDecroissante $LesJumeaux] append TexteDuNouveauFichier "$LaNouvelleLigne\n" } set LeTexteDuNouveauFichier [split $TexteDuNouveauFichier "\n"] set LeTexteTrieDuNouveauFichier [lsort -dictionary $LeTexteDuNouveauFichier] set TexteTrieDuNouveauFichier [join $LeTexteTrieDuNouveauFichier "\n"] return $TexteTrieDuNouveauFichier } proc TrieLesExons {ListeDesExons} { foreach Homologie $ListeDesExons { ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga PourcentageIdentiteCacheDansScore Expect DebutQuery FinQuery DebutSbjct FinSbjct lappend LesDebuts "$DebutSbjct" set MonHomo($DebutSbjct) $Homologie if {[expr ($DebutQuery-$FinQuery)*($DebutSbjct-$FinSbjct)>0]} { set Sens increasing } else { set Sens decreasing } } foreach DebutSbjct [lsort -$Sens -integer $LesDebuts] { lappend LesTries [set MonHomo($DebutSbjct)] } return $LesTries } proc TrieLesExonsEtPurgeLesOverlaps {ListeDesHomologues} { set LesTries {} set ListeDesExons {} set OldChroContigTroncon "Bidon" foreach Homologie $ListeDesHomologues { ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga PourcentageIdentiteCacheDansScore Expect DebutQuery FinQuery DebutSbjct FinSbjct if {$OldChroContigTroncon!="Bidon" && $ChroContigTroncon!=$OldChroContigTroncon} { set LesTries [concat $LesTries [TrieLesExons $ListeDesExons]] set ListeDesExons {} } set OldChroContigTroncon $ChroContigTroncon lappend ListeDesExons $Homologie } set LesTries [concat $LesTries [TrieLesExons $ListeDesExons]] set ListeDesExons {} foreach Homologie $LesTries { ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga PourcentageIdentiteCacheDansScore Expect DebutQuery FinQuery DebutSbjct FinSbjct set S "$DebutSbjct,$FinSbjct" if { ! [info exists nHits($ChroContigTroncon)]} { set nHits($ChroContigTroncon) 0 } incr nHits($ChroContigTroncon) if {[info exists DejaVu($S)]} { lappend LesPurgeables [set DejaVu($S)] lappend LesPurgeables $Homologie set DejaDejaVu($S) [set DejaVu($S)] } set DejaVu($S) $Homologie } foreach Homologie $LesTries { ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga PourcentageIdentiteCacheDansScore Expect DebutQuery FinQuery DebutSbjct FinSbjct set S "$DebutSbjct,$FinSbjct" if {[info exists DejaPurge($S)]} { continue } if {[info exists DejaDejaVu($S)]} { set DejaPurge($S) 1 scan [set DejaDejaVu($S)] "%s" CCT1 scan [set DejaVu($S)] "%s" CCT2 if {[set nHits($CCT1)] > [set nHits($CCT2)]} { lappend LesPurges [set DejaDejaVu($S)] } else { lappend LesPurges [set DejaVu($S)] } continue } lappend LesPurges $Homologie } return $LesPurges } proc TrieLesJumeauxParLongueurDecroissante {LesJumeaux} { global RepertoireDuGenome set LesListes {} foreach Nom $LesJumeaux { set Longueur [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]] set Liste [list $Nom $Longueur] lappend LesListes $Liste } set LesListesTriees [lsort -integer -decreasing -index 1 $LesListes] set LaNouvelleLigne {} foreach PetiteListe $LesListesTriees { set Boite [lindex $PetiteListe 0] lappend LaNouvelleLigne $Boite } return $LaNouvelleLigne } proc TrieLesListesDeDemarcation {K VouH} { global LesDemarcationsVerticales global LesDemarcationsHorizontales global LesAbscissesVerticales global LesAbscissesHorizontales global LesEtiquettesVerticales global LesEtiquettesHorizontales if {$VouH=="v"} { set ListeA [set LesAbscissesVerticales($K)] set ListeB [set LesDemarcationsVerticales($K)] set ListeC [set LesEtiquettesVerticales($K)] } if {$VouH=="h"} { set ListeA [set LesAbscissesHorizontales($K)] set ListeB [set LesDemarcationsHorizontales($K)] set ListeC [set LesEtiquettesHorizontales($K)] } foreach A $ListeA B $ListeB C $ListeC { set Bdu($A) $B set Cdu($A) $C } set ListeATriee [lsort -integer $ListeA] foreach A $ListeATriee { lappend ListeBTriee [set Bdu($A)] lappend ListeCTriee [set Cdu($A)] } if {$VouH=="v"} { set LesAbscissesVerticales($K) $ListeATriee set LesDemarcationsVerticales($K) $ListeBTriee set LesEtiquettesVerticales($K) $ListeCTriee return } if {$VouH=="h"} { set LesAbscissesHorizontales($K) $ListeATriee set LesDemarcationsHorizontales($K) $ListeBTriee set LesEtiquettesHorizontales($K) $ListeCTriee return } } proc TrieLesReductions {} { set Fichier "[RepertoireDuGenome]/TableauPourReductionSsRedondanceFiltrer" set LesLignes {} foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^GscopeId} $Ligne]} { set LigneDeTete $Ligne continue } lappend LesLignes $Ligne } set LesLignesFinales [list $LigneDeTete] set LesLignesTriees [lsort -command CompareReduction $LesLignes] LConcat LesLignesFinales $LesLignesTriees SauveLesLignes $LesLignesFinales dans "[RepertoireDuGenome]/TableauPourReductionSsRedondanceFiltrerTrie" #EspionneL $LesLignesTriees #return $LesLignesTriees } proc TrieLesTimesDesDevStage {{Fichier ""}} { if {$Fichier==""} { set Fichier "[Fiches]/SelectedEST" } foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase "DevStage" $Ligne]} { continue } set T [StringSuivant "DevStage" dans $Ligne] set T [string trim $T " \t"] lappend LesTs $T } set LesTs [lsort -unique $LesTs] set LesBonsT {} foreach T $LesTs { set OldT $T set T [string tolower $T] if {$T=="adult"} { set T "7 week" } regsub "adult" $T "" T regsub -all {approx\.|age|old|\~} $T "" T regsub {e18\-p} $T {p0-p} T regsub "whole embryo including extraembryonic tissues at " $T "" T regsub {days? *pc} $T "day post coitum" T regsub " pc embryo" $T "day post coitum" T regsub "postcoitum" $T "post coitum" T regsub "d\.p\.c" $T "dpc" T regsub "p\.c" $T "dpc" T regsub "embryonic" $T "embryo" T regsub "cells" $T "cell" T regsub "one\-cell" $T "1 cell" T regsub "two\-cell" $T "2 cell" T regsub "four\-cell" $T "4 cell" T regsub "eight\-cell" $T "8 cell" T regsub "eigth\-cell" $T "8 cell" T regsub "sixteen\-cell" $T "16 cell" T regsub "cell\-.*" $T "cell" T regsub -all "days" $T "day" T if {[regexp "cell" $T]} { regsub {embryo[a-z]*} $T "" T } if {[regexp {embryo[a-z]*[0-9\.\- ]+dpc} $T]} { regsub {embryo[a-z]*} $T "" T } regsub "dpc" $T "day post coitum" T regsub {embryos?} $T "day post coitum" T set T [join [LesMotsDeLaLigne $T] " "] regsub -all "day day" $T "day" T regsub -all "day day" $T "day" T set T [join [LesMotsDeLaLigne $T] " "] regsub -all {day post coitum +day post coitum} $T "day post coitum" T regsub {day post coitum[^0-9]+} $T "day post coitum " T regsub {([0-9])\-([a-z])} $T {\1 \2} T regsub -all {([0-9])([a-z])} $T {\1 \2} T set T [join [LesMotsDeLaLigne $T] " "] if {[regexp "day post coitum" $T]} { regsub "day post coitum" $T "" T set T "daypostcoitum $T" } elseif {[regexp {weeks?|months?|years?|days?} $T Match]} { regsub $Match $T "" T set T [string trim $T " -"] regsub "s$" $Match "" Match set T "postnatal$Match $T" } elseif {[regexp {cell} $T]} { regsub "cell" $T "" T set T [string trim $T " -"] set T "cell $T" } elseif {[regexp {^[0-9\. ]+$} $T]} { set T [string trim $T " -"] set T "daypostcoitum $T" } elseif {[regexp {^e[0-9\. ]+$} $T]} { set T [string trim $T " -"] regsub "e" $T "" T set T "daypostcoitum $T" } elseif {[regexp {^p[0-9]+[ \-]p[0-9]+$} $T]} { regsub -all "p" $T "" T set T "postnatalday $T" } elseif {[regexp {^p[0-9]+$} $T]} { regsub -all "p" $T "" T set T "postnatalday $T" } # regsub -all {[0-9][0-9\.\- ]*[0-9]} $T "XXX" T lappend LesBonsT "$T = $OldT" } set LesBonsT [lsort -unique $LesBonsT] return [AfficheVariable [join $LesBonsT "\n"]] } proc TrieLesTissuesDesSelectedEST {{Fichier ""} {Quoi ""}} { if {$Quoi==""} { set Quoi "Choose" } if {$Fichier==""} { set Fichier "[Fiches]/SelectedEST" } foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase "TissueType" $Ligne]} { continue } set T [StringSuivant "TissueType" dans $Ligne] set T [string trim $T " \t"] lappend LesTs $T } set LesTs [lsort -unique $LesTs] set LesBonsT {} foreach T $LesTs { lappend LesBonsT $T } # set LesBonsT [lsort -unique $LesBonsT] if {$Quoi=="GetList"} { return $LesBonsT } return [MorceauxChoisis $LesBonsT] } proc TrieList {a b} { #utilise dans un lsort avec l'argument command, voir proc du dessus FaitTrieListe #on veut trier dabord a partir de la 1ère colonne puis de la 2ème colonne lassign $a a0 a1 lassign $b b0 b1 if {$a0 > $b0} {return 1} if {$a0 < $b0} {return -1} if {$a1 > $b1} {return 1} if {$a1 < $b1} {return -1} } proc TrieNomGroupe {a b} { set ea [ExtraitNoDuGroupe $a] set eb [ExtraitNoDuGroupe $b] if {$ea > $eb} {return 1} if {$ea == $eb} {return 0} if {$ea < $eb} {return -1} } proc TriePfSS {a b} { scan $a "%s %d %d" Pa Da Fa scan $b "%s %d %d" Pb Db Fb if {$Da==$Db} { if {$Fa==$Fb} { return [string compare "$Pa" "$Pb"] } if {$Fa<$Fb} { return -1 } if {$Fa>$Fb} { return 1 } } if {$Da<$Db} { return -1 } if {$Da>$Db} { return 1 } } proc TriePre {a b} { lassign $a ia da lassign $b ib db if {$da eq $db} {return 0} if {$da eq "bac"} {return 1} if {$da eq "arc"} {return -1} if {$da ne "euk" && $db eq "bac"} {return -1} if {$da eq "euk" && $db eq "arc"} {return 1} } proc TrieResPos {} { #g d n dg ndg set Li [LesLignesDuFichier "res_pos"] foreach l $Li { if {! [regexp "IdenGlob" $l]} {continue} foreach id {" g" " d" " n" " dg" "ndg"} { if {[regexp "$id-IdenG" $l]} {break} } set txt [OteLesBlancsEnTrop $l] set le [split $txt " "] set ni [lindex $le 2] if {! $ni} {continue} set df [lindex $le 9] if {[expr abs($df)] > 100} {continue} lappend R[string trim $id] $df } set file [open "respos.dat" w] foreach a $Rg b $Rd c $Rn d $Rdg e $Rndg { puts $file "$a\t$b\t$c\t$d\t$e" } close $file foreach id {"g" "d" "n" "dg" "ndg"} { set sm 0 set sm2 0 foreach e [set R$id] { incr sm $e incr sm2 [expr $e*$e] } set n [llength [set R$id]] set sm [expr $sm/$n.] set sm2 [expr $sm2/$n.] set ec [expr sqrt($sm2 - $sm*$sm)] puts "pour $id : m= $sm, std= $ec" } exit } proc TrieZonesPfam {aI} { upvar $aI I set out [list] foreach id [array names I] { set res [list] foreach e [set I($id)] { lassign $e d f col txt lappend Ldf($id) [list $d $f] } set Ldf($id) [lsort -integer -command TrieIntPfam [set Ldf($id)]] set i 0 set t$i [list [lindex [set Ldf($id)] 0]] foreach e [lrange [set Ldf($id)] 1 end] { lassign $e d f set bon 0 for {set c 0} {$c <= $i} {incr c} { foreach v [set t$c] { lassign $v dv fv if {$d < $fv} { set bon 1 lappend t$c $e break } } if {$bon} {break} } if {! $bon} { incr i set t$i [list $e] } } set dm -999. for {set c 0} {$c <= $i} {incr c} { lassign [lindex [set t$c] 0] d1 f1 lassign [lindex [set t$c] end] d2 f2 set dst [expr {$f2-$d1+1}] if {$dst > $dm} { set dm $dst set cm $c } lappend res "${id}@$c" $d1 $f2 } set res [lsort -stride 3 -integer -index 1 $res] foreach {n d f} $res { lassign [split $n @] id c set t "" if {$c == $cm} { set t $txt } lappend out "${id}@$c)" $d $f $col $t } } set out [lsort -stride 5 -integer -index 1 $out] set Lr [list] foreach {a b c d e} $out { lassign [split $a @] id tmp lappend Lr [list $id $b $c $d $e] } return $Lr } proc TrieZonesPfam_AEffacer {aI} { upvar $aI I set out [list] foreach id [array names I] { set res [list] foreach e [set I($id)] { lassign $e d f col txt lappend Ldf($id) [list $d $f] } set Ldf($id) [lsort -integer -command TrieIntPfam [set Ldf($id)]] set i 0 set t$i [list [lindex [set Ldf($id)] 0]] foreach e [lrange [set Ldf($id)] 1 end] { lassign $e d f set bon 0 for {set c 0} {$c <= $i} {incr c} { foreach v [set t$c] { lassign $v dv fv if {$d < $fv} { set bon 1 lappend t$c $e break } } if {$bon} {break} } if {! $bon} { incr i set t$i [list $e] } } set dm -999. for {set c 0} {$c <= $i} {incr c} { lassign [lindex [set t$c] 0] d1 f1 lassign [lindex [set t$c] end] d2 f2 set dst [expr {$f2-$d1+1}] if {$dst > $dm} { set dm $dst set cm $c } lappend res "${id}@$c" $d1 $f2 } set res [lsort -stride 3 -integer -index 1 $res] foreach {n d f} $res { lassign [split $n @] id c set t "" if {$c == $cm} { set t $txt } lappend out "${id}@$c)" $d $f $col $t } } set out [lsort -stride 5 -integer -index 1 $out] set Lr [list] foreach {a b c d e} $out { lassign [split $a @] id tmp lappend Lr [list $id $b $c $d $e] } return $Lr } proc TrienomMouse {a b} { set ia -1 set ib -1 set i 0 foreach c {LA0AAA ENSMUST NM_ XM_ SP} { if {[regexp "^$c" $a]} {set ia $i} if {[regexp "^$c" $b]} {set ib $i} incr i } if {$ia > $ib} {return 1} if {$ia < $ib} {return -1} if {$ia == $ib && $ia != -1} {return 0} set fa [lindex [split $a _] end] set fb [lindex [split $b _] end] set ea [string toupper $fa] set eb [string toupper $fb] set ia -1 set ib -1 set i 0 foreach c {"^(HUMAN|HOMO)" "^(RAT|RATTUS)" "^(MOUSE|MUS)"} { if {[regexp $c $ea]} {set ia $i} if {[regexp $c $eb]} {set ib $i} incr i } if {$ia > $ib} {return 1} if {$ia < $ib} {return -1} if {$ia == $ib && $ia != -1} {return 0} return 0 } proc TrienomRat {a b} { set ia -1 set ib -1 set i 0 foreach c {LA0ACA ENSRNOT NM_ XM_ SP} { if {[regexp "^$c" $a]} {set ia $i} if {[regexp "^$c" $b]} {set ib $i} incr i } if {$ia > $ib} {return 1} if {$ia < $ib} {return -1} if {$ia == $ib && $ia != -1} {return 0} set fa [lindex [split $a _] end] set fb [lindex [split $b _] end] set ea [string toupper $fa] set eb [string toupper $fb] set ia -1 set ib -1 set i 0 foreach c {"^(HUMAN|HOMO)" "^(MOUSE|MUS)" "^(RAT|RATTUS)"} { if {[regexp $c $ea]} {set ia $i} if {[regexp $c $eb]} {set ib $i} incr i } if {$ia > $ib} {return 1} if {$ia < $ib} {return -1} if {$ia == $ib && $ia != -1} {return 0} return 0 } proc Triplet {x y z} { return [list $x $y $z] } proc TrogStatus {Nom} { global RepertoireDuGenome global TrogStatus if {[info exists TrogStatus($Nom)]} { return [set TrogStatus($Nom)] } if {[info exists TrogStatus("EstCharge")]} { return "" } set FichierTrogStatus "$RepertoireDuGenome/fiches/trogstatus" set TrogStatus("EstCharge") "EstCharge" if { ! [file exists $FichierTrogStatus]} { return "" } foreach Ligne [LesLignesDuFichier $FichierTrogStatus] { scan $Ligne "%s %s" NomLu Valeur set TrogStatus($NomLu) $Valeur } return [TrogStatus $Nom] } proc TroisBoots {{Texte ""}} { global TokCourant if {$Texte!=""} { Tok $Texte } if { ! [regexp {^\(} $TokCourant]} { return "TroisBootsNonValideCarSansOuvrante" } Tok set Gauche [Arboot] if {[regexp "NonValide" $Gauche]} { return "TroisBootsNonValideCar$Gauche" } if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" } Tok set Milieu [Arboot] if {[regexp "NonValide" $Milieu]} { return "TroisBootsNonValideCar$Milieu" } if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" } Tok set Droite [Arboot] if {[regexp "NonValide" $Droite]} { return "TroisBootsNonValideCar$Droite" } if { ! [regexp {\)} $TokCourant]} { return "TroisBootsNonValideCarSansFermante" } Tok if { ! [regexp {\;} $TokCourant]} { return "TroisBootsNonValideCarSansPointVirgule" } return [list $Gauche $Milieu $Droite] } proc TronconneLeFichierTFA {FichierTFA {TailleTroncon 100000} {TailleOverlap 10000} {Working UseSameNameOnTmp}} { Wup "Cuts the tfa file into fragments" if {$Working=="UseSameNameOnTmp"} { set Queue [file tail $FichierTFA] regsub ".tfa$" $Queue "" Queue set WD "[RepertoireDeTravail]" } if {$Working=="UseSameName"} { set Queue [file tail $FichierTFA] regsub ".tfa$" $Queue "" Queue set WD [file dirname $FichierTFA] } if {$Working=="UseTmpFile"} { set Tmp [TmpFile] set Queue [file tail $Tmp] set WD [file dirname $Tmp] } set LesTroncons {} set iFinTroncon [expr $TailleTroncon + $TailleOverlap -1] set TFA [ContenuDuFichier $FichierTFA] set Entete [PremiereLigneDuFichier $FichierTFA] scan $Entete "%s" ChevronAccess set Seq [QueLaSequenceDuTFA $FichierTFA] set PasLaPeine [expr [string length $Seq] < $TailleTroncon] set N 1 set D 1 while {$Seq!=""} { set Troncon [string range $Seq 0 $iFinTroncon] set F [expr $D+[string length $Troncon]-1] if {$PasLaPeine} { set BeauN "" set FromBase "" } else { set BeauN "_[format "%2.2d" $N]" set FromBase "from base $D to $F " } set FichierSortie "$WD/${Queue}${BeauN}.tfa" regsub "$ChevronAccess " $Entete "$ChevronAccess $FromBase" NouvelleEntete regsub "^>" $NouvelleEntete "" NouvelleEntete Sauve [SequenceFormatTFA $Troncon $NouvelleEntete "brut"] dans $FichierSortie lappend LesTroncons $FichierSortie if {[string length $Seq] <= $iFinTroncon} { break } set Seq [string range $Seq $TailleTroncon end] incr D $TailleTroncon incr N } return $LesTroncons } proc TronquerSequence {Path Acouper BoutACouper} { # Procédure rognant en 5' ou en 3' un ensemble de séquences. Le nombre de pb é rogner est é préciser. La sortie est faite aux formats # SLX, TFA, IG, SEQ # Au passage, il filtre les Acta et les mets dans un fichier (é commenter si nécessaire) # Déclaration des fichiers # ------------------------ set FichierDesSequencesATronquer [open "$Path.bidir" "r"] set FichierDesSLX [open "$Path.slx" "w"] set FichierDesTFA [open "$Path.tfa" "w"] set FichierDesIG [open "$Path.ig" "w"] set FichierDesSEQ [open "$Path.seq" "w"] # Suppression des versions précédentes des fichiers # -------------------------------------------------- if { [file exists $FichierDesSLX] } { file delete $FichierDesSLX } if { [file exists $FichierDesTFA] } { file delete $FichierDesTFA } if { [file exists $FichierDesSEQ] } { file delete $FichierDesSEQ } if { [file exists $FichierDesIG] } { file delete $FichierDesIG } set I 0 # Do the loop, baby yeah ! # ------------------------ while { [gets $FichierDesSequencesATronquer Ligne] >=0 } { puts $FichierDesTFA "$Ligne" gets $FichierDesSequencesATronquer Ligne if { $Ligne != "" } { incr I 1 ScanLaListe $Ligne Sequence if { $BoutACouper == 3 || $BoutACouper == "both" } { set Fin [expr 24 - $Acouper] set Sequence [string range $Sequence 0 $Fin ] } if { $BoutACouper == 5 || $BoutACouper == "both" } { set Sequence [string range $Sequence $Acouper 24] } set Un 1 puts $FichierDesSLX "Sp$I $Sequence" #puts $FichierDesTFA ">Sp$I" puts $FichierDesTFA "$Sequence" puts $FichierDesSEQ "$Sequence" puts $FichierDesIG "; comment" puts $FichierDesIG "; comment" puts $FichierDesIG "Sp$I" puts $FichierDesIG "$Sequence$Un" } } close $FichierDesSequencesATronquer close $FichierDesSLX close $FichierDesTFA close $FichierDesSEQ close $FichierDesIG } proc TrousLaTotale {} { global RepertoireDuGenome set OldIntergenes "$RepertoireDuGenome/fiches/bornesdesintergenes" set Concorde [expr [file exists $OldIntergenes] && [OuiOuNon "Do I correct numbering according to existing intergenes ?"]] if {$Concorde} { # Espionne "Concorde" set KeepOldIntergenes "OldIntergenes.[pid]" File rename $OldIntergenes $KeepOldIntergenes } set FichierIntergenes [CreeLeFichierBornesDesIntergenes "Replace"] if {$Concorde} { set LesTous [ConcordanceNumerotationDesIntergenes $KeepOldIntergenes $FichierIntergenes] if { ! [OuiOuNon "OK to delete bad files in \nnuctfa nucembl trousblastx trouxsapns ?"]} { FaireLire "Please recover the correct names. I'll exit." exit } foreach Rep {nuctfa nucembl trousblastx trouxsapns} { foreach Fichier [glob -nocomplain "$RepertoireDuGenome/$Rep/TROU*"] { File delete -force $Fichier } } SauveLesLignes $LesTous dans $FichierIntergenes } CreeLesFichiersSequencesDesTrous "Replace" BlastXDesTROUsPourTous CreeLesFichiersApns "trouxs" CreeLeFichierNombreDeCopainsDansBlast NombreDeCopainsDansBlast "Reload" return [ListeDesTROUs] } proc Trouve {FichierAccess} { foreach Ligne [LesLignesDuFichier $FichierAccess] { if {$Ligne==""} {continue} set Access $Ligne set Commande "getz \"\\\[protein-acc:$Access\\\]\" \-view FastaSeqs" set GetzOut [eval exec $Commande] if {$GetzOut==""} {Espionne $Access} } } proc TrouveAccAcPlsEvi {} { #set Fichier "[RepertoireDuGenome]/ListeIngenuityNmAcEvi" set Fichier "[RepertoireDuGenome]/ListeIngenuityGbAcEvi" foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set LesElmts [split $Ligne " "] set Acc [lindex $LesElmts 0] if {[info exists DejaVu($Acc)]} { incr DejaVu($Acc) continue } set DejaVu($Acc) 1 } foreach Clef [array names DejaVu] { set nbdefois $DejaVu($Clef) if {$nbdefois>1} { puts "$Clef $DejaVu($Clef)" } } } proc TrouveBestPDB {pab} { global LesNomsDesSequencesDansLOrdre global Sequences global TDesPCI global PipeCollection global DefautsPipe global Defauts LesDefauts catch {array unset LesNomsDesSequencesDansLOrdre} catch {array unset Sequences} catch {array unset TDesPCI} if {$PipeCollection} { set fileIn [file join [RepertoireDuGenome] prottfa $pab] set fileOut [file join [RepertoireDuGenome] blastp3D $pab] set destBallast [file join [RepertoireDuGenome] blastp3D $pab-bal] set anchors [file join [RepertoireDuGenome] blastp3D $pab-bal.anchors] set fileDnd [file join [RepertoireDuGenome] blastp3D $pab-3d.dnd] set fileTmp [file join [RepertoireDuGenome] blastp3D $pab-3d.tmp] set fileCl [file join [RepertoireDuGenome] blastp3D $pab-3d.cl] set fileOutCl [file join [RepertoireDuGenome] blastp3D $pab-3dAli.tfa] } else { set fileIn "$pab" set fileOut "[file rootname $pab].blastp3D" set destBallast "[file rootname $pab]-bal" set anchors "[file rootname $pab]-bal.anchors" set fileDnd "[file rootname $pab]-3d.dnd" set fileTmp "[file rootname $pab]-3d.tmp" set fileCl "[file rootname $pab]-3d.cl" set fileOutCl "[file rootname $pab]-3dAli.tfa" } set lesPDB "" set NQuery [QueryDuTFA $fileIn] # recherche des template potentiels : blastp dans la PDB set CommandeBlast "[BlastallExe] -i $fileIn -o $fileOut -p blastp -d pdb -e 0.01 -b 100 -v 100 -F F" if {[catch {eval exec $CommandeBlast} Message]} {puts "$Message"} # verif output blastp set Ll [LesLignesDuFichier $fileOut] if {[llength $Ll] < 10} { Espionne "Something wrong with BlastP file" return 0 } # ballast sur blastp PDB set CommandeBallast "[BallastExe] -p $fileOut -o $destBallast -anchors -noext -queryname $NQuery" catch {eval exec $CommandeBallast} Message # modification du fichier d ancres de maniere a pouvoir en tenir compte if {[file exists $anchors]} { if {[llength [LesLignesDuFichier $anchors]] > 1} { DecortiqueAncresBallast $anchors Qu Ob Ps B1 B2 Ln Wg set fout [open $anchors w] puts $fout "Ballast 0.000000" foreach q $Qu o $Ob p $Ps d $B1 f $B2 l $Ln w $Wg { set o [EnlevePrefixeBank $o] set fmt [format "seq: %15s %15s\tpos: %10d\tbeg: %10d %10d\tlen: %6d\tweight: %6.2f\n" $q $o $p $d $f $l $w] puts $fout $fmt } close $fout } } set LBlast [LesLignesDuFichier $fileOut] DecortiqueBlastGrid $LBlast 100 100 Query lBanqueId lAccess lDE lScoreDansProfil lPN if {[llength $lBanqueId] == 0} { return "" } if { ![file exists $fileOutCl] } { set o [open "$fileTmp" w] puts $o [join $lBanqueId "\n"] close $o catch {exec [FastacmdExe] -i $fileTmp -d pdb} Msg if {[string first "\[fastacmd\]" $Msg] != -1} { Espionne "Error in Fastacmd ! Aborting \n$Msg" return 0 } set Lq [LesLignesDuFichier $fileIn] set Ls [split $Msg "\n"] set Lr "" foreach l $Ls { if {[string index $l 0] ne ">"} { lappend Lr $l continue } set ib [PremierBlanc $l] if {$ib ne "end"} {incr ib -1} set bid [string range $l 0 $ib] set bid [EnlevePrefixeFastacmd $bid] set bid [EnlevePrefixeBank $bid] lappend Lr ">$bid" } set lf [concat $Lq $Lr] set f [open $fileCl w] puts $f [join $lf "\n"] close $f if {[file exists $anchors]} { set opt "-propagate -motifs=$anchors" } else { set opt "" } set CommandeClustal "[ClustalwExe] $opt -infile=$fileCl -outfile=$fileOutCl -output=fasta" if {[catch {eval exec $CommandeClustal} Message]} {puts "$Message"} } LesDefauts Mode "Batch" if {[file exists $fileOutCl]} { LitLeTFA $fileOutCl LesNomsDesSequencesDansLOrdre Sequences set LPCI [CalculeLesPCI "" "" $NQuery "" 1] foreach e [array names TDesPCI] { set le [split $e ","] #cree 1 liste qui contient "deb, fin, %id, idPDB" pour chaque template potentiel if { [lindex $le 0] != $NQuery } { set id [lindex [set TDesPCI($e)] 0] #on recupere uniquement les PDB qui ont + de 25% d'identite avec la query #if {$id > 0.25} {} if {$id > 0.3} { set name [lindex $le 0] set l$name "" set seq [set Sequences($name)] set lseq [split $seq {}] set pos1 [lsearch -regexp $lseq {[A-Z]}] set posEnd [expr $pos1 + [lindex [set TDesPCI($e)] 1]] #set id [lindex [set TDesPCI($e)] 0] set pdbId [lindex $le 0] set long [expr $posEnd - $pos1] # on ne tient compte que des template de plus de 45 residus de long if {$long > 45} { lappend l$name $pos1 lappend l$name $posEnd lappend l$name $id lappend l$name $pdbId lappend l$name $long lappend lesPDB [set l$name] } unset l$name } } } } #EspionneL $lesPDB # on classe les PDB par longueur decroissante set lesPDBSort [lsort -integer -decreasing -index 4 $lesPDB] set ltemplate "" foreach pdb $lesPDBSort { set ltemplate [comparePDB $pdb $ltemplate] } puts "les templates sont:" EspionneL $ltemplate set lBest "" foreach template $ltemplate { set toAdd "[lindex $lAccess [lsearch -regexp $lBanqueId [lindex $template 3]]]" if {[regexp "^PDB:" $toAdd]} { regsub "PDB:" $toAdd "" toAdd } lappend lBest $toAdd } if {[info exists LesNomsDesSequencesDansLOrdre]} { array unset LesNomsDesSequencesDansLOrdre } if {[info exists Sequences]} { array unset Sequences } if {[info exists TDesPCI]} { array unset TDesPCI } if {[info exists LPCI]} { unset LPCI } #set lf [glob -nocomplain "[RepertoireDuGenome]/blastp3D/$file-3d*"] #eval file delete -force $lf set lf [glob -nocomplain "{$destBallast}*"] catch {eval file delete -force $lf} Message if {[file exists $fileTmp]} { File delete -force $fileTmp } if {[file exists $fileDnd]} { File delete -force $fileDnd } if {[file exists $fileCl]} { File delete -force $fileCl } if {[file exists $fileOutCl]} { File delete -force $fileOutCl } return $lBest } proc TrouveCdna {} { set total 0; set vide 0; set vraiplein 0; set fauxplein 0 set RepertoireSortieBlast "[RepertoireDuGenome]/blastnRetMouse" #set File "$RepertoireSortieBlast/EVI00020" #set File "$RepertoireSortieBlast/EVI32380" foreach File [glob -nocomplain "$RepertoireSortieBlast/*"] { incr total set Queue [file tail $File] set Query {}; set lBanqueId {}; set lAccess {}; set lDE {}; set lProfil {}; set lPN {} DecortiqueBlast $File "0.001" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN #DecortiqueBlast $File "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN #foreach BanqueId $lBanqueId PN $lPN if {$lPN=={}} { incr vide set LaLigneVide "$Queue => pas de touche" lappend LesLignesVides $LaLigneVide } else { if {[lindex $lPN 0] == 0.0} { incr vraiplein lappend LesLignesVraiPleines "$Queue" foreach BanqueId $lBanqueId Access $lAccess PN $lPN { set LaLigneVraiPleine "$BanqueId $Access $PN" lappend LesLignesVraiPleines $LaLigneVraiPleine } } else { incr fauxplein lappend LesLignesFauxPleines "$Queue" foreach BanqueId $lBanqueId Access $lAccess PN $lPN { set LaLigneFauxPleine "$BanqueId $Access $PN" lappend LesLignesFauxPleines $LaLigneFauxPleine } } } } lappend LesLignesVides "nb $vide" lappend LesLignesVraiPleines "nb $vraiplein" lappend LesLignesFauxPleines "nb $fauxplein" SauveLesLignes $LesLignesVides dans "[RepertoireDuGenome]/ResultcDNA/CDNAVide" SauveLesLignes $LesLignesVraiPleines dans "[RepertoireDuGenome]/ResultcDNA/CDNAVraiPlein" SauveLesLignes $LesLignesFauxPleines dans "[RepertoireDuGenome]/ResultcDNA/CDNAFauxPlein" Espionne "total $total" Espionne "vide $vide" Espionne "vraiplein $vraiplein" Espionne "fauxplein $fauxplein" } proc TrouveCluster {ProbeSet} { set LesLignes {} CanalSqlBioArrayBase foreach {Ps Ex SoAn SoCl Cl} [SqlExec "select p.probeset_id, e.description, a.name, c.clu_description, lncep.clusternumber from retinobase3.ln_clu_exp_pro lncep, retinobase3.cluster c, retinobase3.analysissoftware a, retinobase3.experiment e, retinobase3.probeset p where lncep.pk_experiment = e.pk_experiment and lncep.pk_probeset = p.pk_probeset and lncep.pk_cluster = c.pk_cluster and lncep.pk_software = a.pk_software and p.probeset_id= '$ProbeSet' order by e.pk_experiment;" "GetList"] { lappend LesLignes "$Ps\t$Ex\t$SoAn\t$SoCl\t$Cl" } CanalSqlDisconnect return [join $LesLignes "\n"] } proc TrouveClusterParticulier {ProbeSet PkExperiment} { set LesLignes {} foreach {Ps Ex SoAn SoCl Cl} [SqlExec "select p.probeset_id, e.pk_experiment, a.name, c.clu_description, lncep.clusternumber from retinobase3.ln_clu_exp_pro lncep, retinobase3.cluster c, retinobase3.analysissoftware a, retinobase3.experiment e, retinobase3.probeset p where lncep.pk_experiment = e.pk_experiment and lncep.pk_probeset = p.pk_probeset and lncep.pk_cluster = c.pk_cluster and lncep.pk_software = a.pk_software and p.probeset_id= '$ProbeSet' and e.pk_experiment = '$PkExperiment' order by e.pk_experiment;" "GetList"] { lappend LesLignes "$Ps\t$Ex\t$SoAn\t$SoCl\t$Cl" } return [join $LesLignes "\n"] } proc TrouveCommuns {l} { set luni [lsort -unique $l] set com {} foreach e $luni { set n [llength [lsearch -all $l $e]] if {$n != 1} { if {$e != ""} { lappend com $e } } } return $com } proc TrouveDansLesInfos {K} { Wup "Trouve des oligos en fonction de vos criteres" set Quoi [Entre "Ex: Id: Oligo1_ACT1013"] if {$Quoi==""} {return ""} #Pour tenir compte des multiples blancs if {[regexp {: } $Quoi]} {regsub {: } $Quoi ": +" Quoi} DeselectionneLesTrouves $K set LesIdsRetenus "" set LesIds [$K find withtag "Boite"] foreach Id $LesIds { set Info [lindex [$K gettags $Id] 1] if {[regexp -nocase "$Quoi" $Info]} {lappend LesIdsRetenus $Id} else {continue} } foreach Id $LesIdsRetenus { $K itemconfigure $Id -outline "darkviolet" $K itemconfigure $Id -width "3" $K itemconfigure $Id -dash {6 4 2 4} $K addtag "Finded" withtag $Id } return "" } proc TrouveDesCas {} { foreach Box [ListeDesPABs] { Espionne "$Box" set Org Mouse set refpfaminitial 0 set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj.reduit" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.reduit"} set LesPfamNettoyeDeLaRef {}; set LesPfamStartStop {}; array unset DejaVu set LesNamesTotal {}; array unset LesAnciens set Cluster [ExtraitInfo $Box "Cluster"] set Ref [ExtraitInfo $Box "Ref"] set LesNames [InterrogeNames $Cluster Name $Org] set RefPfam [ExtraitInfo $Box "RefPfam"] set NbPFAMRef [InterrogeRefPfam $Box-$RefPfam nombrePFAMMacsims] Espionne "Ref $Ref" Espionne "RefPfam $RefPfam" LConcat LesNamesTotal $LesNames LConcat LesNamesTotal $RefPfam LConcat LesNamesTotal $Box set LesNamesTotal [ListeSansDoublon $LesNamesTotal] Espionne "LesNamesTotal $LesNamesTotal" InitPosRel2Abs $FileMacsims $LesNamesTotal set Gn [ExtraitInfo $Box "ValiGN"] set Des [ExtraitInfo $Box "ValiDE"] set LesPfamInfoRef [FromMacsims $FileMacsims $RefPfam "Concat"] foreach PfamInfoRef $LesPfamInfoRef { Espionne "PfamInfoRef $PfamInfoRef" set MotsPfamInfoRef [split $PfamInfoRef "/"] set Pfam [lindex $MotsPfamInfoRef 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id $PfamName" Espionne "PfamNettoye $PfamNettoye" lappend LesPfamNettoyeDeLaRef $PfamNettoye FstartFstop $PfamInfoRef RFstart RFstop Espionne "RFstart $RFstart RFstop $RFstop" set Start [DonnePosRA $RefPfam $RFstart Absolue] set Stop [DonnePosRA $RefPfam $RFstop Absolue] set PfSS "$Id $Start $Stop" Espionne "PfSS $PfSS" Espionne "" lappend LesPfamStartStop $PfSS set PossedePfSS($RefPfam,$PfSS) 1 } foreach Name $LesNames { Espionne "" Espionne "Name $Name" if {$Name==$Ref} {set Name $Box} if {$Name==$RefPfam} {set refpfaminitial 1} Espionne "refpfaminitial $refpfaminitial" set LesPfamInfoName [FromMacsims $FileMacsims $Name "Concat"] foreach PfamInfoName $LesPfamInfoName { set MotsPfamInfoName [split $PfamInfoName "/"] set Pfam [lindex $MotsPfamInfoName 0] set MotsPfam [split $Pfam " "] set Id [lindex $MotsPfam 0] set PfamName [lindex $MotsPfam 1] regsub "PROP_" $Id "" Id set PfamNettoye "$Id $PfamName" Espionne "PfamNettoye $PfamNettoye" lappend LesPfamNettoyeDeLaName $PfamNettoye FstartFstop $PfamInfoName RFstart RFstop Espionne "RFstart $RFstart RFstop $RFstop" set Start [DonnePosRA $Name $RFstart Absolue] set Stop [DonnePosRA $Name $RFstop Absolue] set PfSS "$Id $Start $Stop" Espionne "PfSS $PfSS" lappend LesPfamStartStop $PfSS set PossedePfSS($Name,$PfSS) 1 } } set LesPfamStartStop [lsort -unique $LesPfamStartStop] set LesPfamStartStop [lsort -command TriePfSS $LesPfamStartStop] Espionne "" Espionne "LesPfamStartStop $LesPfamStartStop" set LaCourante $LesPfamStartStop set collapse 1 while {$collapse} { if {[llength $LaCourante]<2} {break} set lA [lrange $LaCourante 0 end-1] set lB [lrange $LaCourante 1 end] Espionne "lA $lA" Espionne "lB $lB" set i -1 foreach A $lA B $lB { DecortiquePfSS $A PfA StartA StopA DecortiquePfSS $B PfB StartB StopB Espionne "PfA $PfA StartA $StartA StopA $StopA" Espionne "PfB $PfB StartB $StartB StopB $StopB" if {$PfA!=$PfB || ! [Recouvrement $StartA $StopA $StartB $StopB]} { set collapse 0 Espionne "onentre" incr i continue } set StartN [Mini $StartA $StartB] set StopN [Maxi $StopA $StopB] set N "$PfA $StartN $StopN" Espionne "N $N" lappend LesAnciens($N) $A $B Espionne "3 toto" foreach Ancien [array names LesAnciens] { Espionne "$Ancien=$LesAnciens($Ancien)" } if {[info exists LesAnciens($A)]} { Espionne "A existe: $A values= $LesAnciens($A)" set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($A)]] } if {[info exists LesAnciens($B)]} { Espionne "B existe: $B values= $LesAnciens($B)" set LesAnciens($N) [lsort -unique [concat $LesAnciens($N) $LesAnciens($B)]] } Espionne "4 titi" foreach Ancien [array names LesAnciens] { Espionne "$Ancien=$LesAnciens($Ancien)" } set collapse 1 break } if { ! $collapse } { break } set LaCourante [lreplace $LaCourante [expr $i+1] [expr $i+2] $N] Espionne "LaCourante $LaCourante" } set LesPfamStartStopCollapse $LaCourante Espionne "LesPfamStartStopCollapse $LesPfamStartStopCollapse" set longancien [llength [array names LesAnciens]] Espionne "longancien $longancien" Espionne "LesAnciens [array names LesAnciens]" foreach Ancien [array names LesAnciens] { Espionne "$Ancien=$LesAnciens($Ancien)" } Espionne "result" foreach Ancien [array names LesAnciens] { Espionne "$Ancien=$LesAnciens($Ancien)" if {[llength $LesAnciens($Ancien)]>3} {Espionne "okkkkkkkkkkkkkkkkkkkkkkkkkk"} } Espionne "" } } proc TrouveDescription {NomComplet} { global RepertoireDuGenome set FichierNotes $RepertoireDuGenome/notes/$NomComplet if {! [file exists $FichierNotes]} { return [list "Infos for $NomComplet not found."] } return [LesLignesDuFichier $FichierNotes] } proc TrouveIncoherenceChezRetinobase2 {} { set NbDePs 0; set PasFromPs 0; set PasFromEv 0; set CestOk 0; set Non 0; set LesSsPs {}; set LesAcPsSsEv {}; set LesEgaux {}; set LesDifferents {} foreach Ps [AffyAnno ListOf Index] { CanalSqlBioArrayBase set trouve 1 set pastrouveps 1 puts "++$Ps" incr NbDePs set RequestPs [SqlExec "select ps.pk_probeset, ps.pk_arraytype, ps.probeset_id, ps.accno, ps.genesymbol, ps.refseqtranscript_id from retinobase2.probeset ps where ps.probeset_id = '$Ps';" "GetList"] if {$RequestPs=={}} { set trouve 0 set pastrouveps 0 puts "pas ds ps" incr PasFromPs lappend LesSsPs $Ps } set RequestEv [SqlExec "select ev.pk_expressionvalue, ev.pk_probeset, ev.pk_sample, ev.probsetid, ev.ratio, ev.ratiodescription from retinobase2.expressionvalue ev where ev.probsetid = '$Ps';" "GetList"] if {$pastrouveps && $RequestEv=={}} { set trouve 0 puts "pas ds ev" incr PasFromEv lappend LesAcPsSsEv $Ps } if {$trouve} { set Request [SqlExec "select ps.pk_probeset, ps.pk_arraytype, ps.probeset_id, ps.accno, ps.genesymbol, ps.refseqtranscript_id, ev.pk_expressionvalue, ev.pk_probeset, ev.pk_sample, ev.probsetid, ev.ratio, ev.ratiodescription from retinobase2.expressionvalue ev, retinobase2.probeset ps where ev.pk_probeset=ps.pk_probeset and ps.probeset_id = '$Ps';" "GetList"] # EspionneL $Request set PsIdFromPs [lindex $Request 2] set PsIdFromEv [lindex $Request 9] if {[string equal $PsIdFromPs $PsIdFromEv]} { incr CestOk Espionne "$PsIdFromPs = $PsIdFromEv" lappend LesEgaux "$PsIdFromPs = $PsIdFromEv" } else { incr Non Espionne "$PsIdFromPs != $PsIdFromEv" lappend LesDifferents "$PsIdFromPs != $PsIdFromEv" } } Espionne "" Espionne "" CanalSqlDisconnect } SauveLesLignes $LesSsPs dans /genomics/link/EVI/RaviSsPs.txt SauveLesLignes $LesAcPsSsEv dans /genomics/link/EVI/RaviAcPsSsEv.txt SauveLesLignes $LesEgaux dans /genomics/link/EVI/RaviEgaux.txt SauveLesLignes $LesDifferents dans /genomics/link/EVI/RaviDifferents.txt puts "nombre total= $NbDePs" puts "nombre ou ok= $CestOk" puts "nombre ou non= $Non" } proc TrouveIncoherenceChezRetinobase3 {} { set NbDePs 0; set PasFromPs 0; set PasFromEv 0; set corres 0; set CestOk 0; set Non 0; set LesSsPs {}; set LesAcPsSsEv {}; set LesEgaux {}; set LesDifferents {} foreach Ps [AffyAnno ListOf Index] { CanalSqlBioArrayBase set trouve 1 set pastrouveps 1 puts "++$Ps" incr NbDePs set RequestPs [SqlExec "select ps.pk_probeset, ps.probeset_id, ps.accno, ps.genesymbol, ps.refseqtranscript_id from retinobase2.probeset ps where ps.probeset_id = '$Ps';" "GetList"] if {$RequestPs=={}} { set trouve 0 set pastrouveps 0 puts "pas ds ps" incr PasFromPs lappend LesSsPs $Ps } set RequestEv [SqlExec "select ev.pk_expressionvalue, ev.pk_ln, ev.probsetid, ev.ratio, ev.ratiodescription from retinobase2.expressionvalue ev where ev.probsetid = '$Ps';" "GetList"] if {$pastrouveps && $RequestEv=={}} { set trouve 0 puts "pas ds ev" incr PasFromEv lappend LesAcPsSsEv $Ps } if {$trouve} { incr corres set Request [SqlExec "select ps.pk_probeset, ps.probeset_id, ps.accno, ps.genesymbol, ps.refseqtranscript_id, ev.pk_expressionvalue, ev.pk_ln, ev.probsetid, ev.ratio, ev.ratiodescription from retinobase2.expressionvalue ev, retinobase2.probeset ps where ev.pk_probeset=ps.pk_probeset and ps.probeset_id = '$Ps';" "GetList"] # EspionneL $Request set PsIdFromPs [lindex $Request 1] puts $PsIdFromPs set PsIdFromEv [lindex $Request 7] puts $PsIdFromEv if {[string equal $PsIdFromPs $PsIdFromEv]} { incr CestOk Espionne "$PsIdFromPs = $PsIdFromEv" lappend LesEgaux "$PsIdFromPs = $PsIdFromEv" } else { incr Non Espionne "$PsIdFromPs != $PsIdFromEv" lappend LesDifferents "$PsIdFromPs != $PsIdFromEv" } } Espionne "" Espionne "" CanalSqlDisconnect } SauveLesLignes $LesSsPs dans /genomics/link/EVI/Retinobase3SsPs.txt SauveLesLignes $LesAcPsSsEv dans /genomics/link/EVI/Retinobase3AcPsSsEv.txt SauveLesLignes $LesEgaux dans /genomics/link/EVI/Retinobase3Egaux.txt SauveLesLignes $LesDifferents dans /genomics/link/EVI/Retinobase3Differents.txt puts "nombre total= $NbDePs" puts "nombre de ps a comparer= $corres" puts "nombre ou ok= $CestOk" puts "nombre ou non= $Non" } proc TrouveIntensitySignal {ProbeSet} { set LesLignes {} CanalSqlBioArrayBase foreach {Ps Ch Ex Sa SaC Si Ca Re So} [SqlExec "select p.probeset_id, at.type, e.description, s.description_sample, s.short_description, rd.signalintensity, rd.call, rd.noofreplicate, a.name from retinobase3.realexp re, retinobase3.experiment e, retinobase3.sample s, retinobase3.arraytype at, retinobase3.rawdata rd, retinobase3.analysissoftware a, retinobase3.probeset p where p.pk_probeset = rd.pk_probeset and rd.pk_software = a.pk_software and rd.pk_realexp = re.pk_realexp and re.pk_experiment = e.pk_experiment and re.pk_sample = s.pk_sample and re.pk_arraytype = at.pk_arraytype and p.probeset_id = '$ProbeSet' order by re.pk_experiment, re.pk_sample;" "GetList"] { lappend LesLignes "$Ps\t$Ch\t$Ex\t$Sa\t$SaC\t$Si\t$Ca\t$Re\t$So" } CanalSqlDisconnect return [join $LesLignes "\n"] } proc TrouveIntensitySignalParticulier {ProbeSet PkExperiment Age} { set LesLignes {} CanalSqlBioArrayBase foreach {Ps Ex Sa Ag Si Re So} [SqlExec "select p.probeset_id, e.pk_experiment, s.short_description, i.age, rd.signalintensity, rd.noofreplicate, a.name from retinobase3.realexp re, retinobase3.experiment e, retinobase3.sample s, retinobase3.individual i, retinobase3.rawdata rd, retinobase3.analysissoftware a, retinobase3.probeset p where p.pk_probeset = rd.pk_probeset and rd.pk_software = a.pk_software and rd.pk_realexp = re.pk_realexp and re.pk_experiment = e.pk_experiment and re.pk_sample = s.pk_sample and s.pk_individual = i.pk_individual and p.probeset_id = '$ProbeSet' and e.pk_experiment = '$PkExperiment' and i.age = '$Age' order by re.pk_sample;" "GetList"] { lappend LesLignes "$Ps\t$Ex\t$Sa\t$Ag\t$Si\t$Re\t$So" } CanalSqlDisconnect return [join $LesLignes "\n"] } proc TrouveIntensitySignalParticulierChicken {ProbeSet PkExperiment} { set LesLignes {} CanalSqlBioArrayBase foreach {Ps Ex Sa Ag Si Re So} [SqlExec "select p.probeset_id, e.pk_experiment, s.short_description, i.age, rd.signalintensity, rd.noofreplicate, a.name from retinobase3.realexp re, retinobase3.experiment e, retinobase3.sample s, retinobase3.individual i, retinobase3.rawdata rd, retinobase3.analysissoftware a, retinobase3.probeset p where p.pk_probeset = rd.pk_probeset and rd.pk_software = a.pk_software and rd.pk_realexp = re.pk_realexp and re.pk_experiment = e.pk_experiment and re.pk_sample = s.pk_sample and s.pk_individual = i.pk_individual and p.probeset_id = '$ProbeSet' and e.pk_experiment = '$PkExperiment' and (s.short_description = 'Chicken_fibroblasts_adult' OR s.short_description = 'Chicken_cone_adult') order by re.pk_sample;" "GetList"] { lappend LesLignes "$Ps\t$Ex\t$Sa\t$Si\t$Re\t$So" } CanalSqlDisconnect return $LesLignes #return [join $LesLignes "\n"] } proc TrouveLAParticulier {} { set j 0 set RepertoireSourisTfactor "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/SOURIS_Tfactor_61_avr" set RepertoireSourisOthers "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/SOURIS_others_61_avr" set RepertoireSourisNOALT "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/SOURIS_NO_ALT_61_avr" set RepertoireRatTfactor "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/RAT_Tfactor_61_avr" set RepertoireRatOthers "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/RAT_others_61_avr" set RepertoireRatNOALT "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_avr/RAT_NO_ALT_61_avr" set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNOALT $RepertoireRatTfactor $RepertoireRatOthers $RepertoireRatNOALT] foreach Repertoire $LesRepertoires { set i 0 foreach FileST [glob -nocomplain "$Repertoire/*"] { set cluster [lindex [split [file tail $FileST] "."] 0] set taille [file size $FileST] if {$taille == 0} {incr i; incr j} foreach Ligne [LesLignesDuFichier $FileST] { if {[regexp "^>LA" $Ligne]} { scan $Ligne "%s" Name regsub ">" $Name "" Name if {[regexp "LA0ACA45YB14CM1" $Name]} {Espionne "$Name $cluster"} if {[regexp "LA0ACA90YD21.CONTIG" $Name]} {Espionne "$Name $cluster"} if {[regexp "LA0ACA99YB24CM1" $Name]} {Espionne "$Name $cluster"} } } } #Espionne "$Repertoire $i" } Espionne "$j" } proc TrouveLARedondant {} { #set RepertoireSourisTfactor "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai" #set RepertoireSourisOthers "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai" #set RepertoireSourisNOALT "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai" #set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNOALT] set RepertoireRatTfactor "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/RAT_Tfactor_61_mai" set RepertoireRatOthers "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/RAT_others_61_mai" set RepertoireRatNOALT "/genomics/link/SpliRetMouse/FichiersInitial/PROT_VARIANTES_61_mai/RAT_NO_ALT_61_mai" set LesRepertoires [list $RepertoireRatTfactor $RepertoireRatOthers $RepertoireRatNOALT] foreach Repertoire $LesRepertoires { foreach FileST [glob -nocomplain "$Repertoire/*"] { set FileCourt [string range $FileST 66 end] set cluster [lindex [split [file tail $FileST] "."] 0] set taille [file size $FileST] if {$taille == 0} {continue} foreach Ligne [LesLignesDuFichier $FileST] { if {[regexp "^>LA" $Ligne]||[regexp "^>303" $Ligne]} { scan $Ligne "%s" Name regsub ">" $Name "" Name lappend DejaVu($Name) $FileCourt } } } } #Espionne "LA0AAA85YB23CM1:" #EspionneL "$DejaVu(LA0AAA85YB23CM1)" foreach Clef [array names DejaVu] { if {[llength $DejaVu($Clef)]>1} { Espionne "\t $Clef" EspionneL "$DejaVu($Clef)" } } } proc TrouveLaBoiteRepresentative {} { set LesLignes [NomLigne ListeDes Lignes] set nblignes 0 set unnom 0; set plsnom 0 set cas3a 0; set cas3b 0; set cas3c 0; set cas3d 0; set cas3e 0 set unseulgn 0; set plsgn 0 foreach Ligne $LesLignes { #if {$Ligne!="2067"} {continue} if {[RangeMoi get EviOf $Ligne]!={}} { continue } incr nblignes set ListeDesNoms {} set LesGns {}; set LesGnsNM {}; set LesDes {}; set LesLoc {} set BonneBoite {} set TV 0 set TousLesNoms [NomLigne $Ligne Noms] set ListeDesNoms [split $TousLesNoms " "] set NbDeNomPrUneLigne [llength $ListeDesNoms] if {[llength $ListeDesNoms]==1} { incr unnom continue } if {[llength $ListeDesNoms]>1} {incr plsnom} Espionne "" Espionne "Ligne $Ligne" foreach Nom $ListeDesNoms { set Gn [ExtraitInfo $Nom "ValiGN"] set Acc [AccessEvi $Nom] set Des [ExtraitInfo $Nom "ValiDE"] Espionne "$Nom $Gn $Acc $Des" if {[regexp "NM" $Acc]} {lappend LesGnsNM $Gn} lappend LesGns $Gn lappend LesDes $Des } set LesGns [ListeSansDoublon $LesGns] set LesGnsNM [ListeSansDoublon $LesGnsNM] set LongLesGns [llength $LesGns] set LongLesGnsNM [llength $LesGnsNM] set LongLesDes [llength $LesDes] if { $Ligne=="729" || $Ligne=="1417" || $Ligne=="413"} { set BonneBoite $ListeDesNoms } if {$Ligne=="413"} { set BonneBoite [list "EVI04130"] } if {$BonneBoite!={}} { Espionne "$BonneBoite Main" RangeMoi set EviOf $Ligne $BonneBoite "LaetitiaChoose" continue } ScanLaListe [CompteDans $ListeDesNoms "NM" "XM"] nbNM nbXM if {$nbNM==1} { incr cas3a; Espionne "cas3a" foreach Nom $ListeDesNoms { set Acc [AccessEvi $Nom] if {[regexp {NM_} $Acc]} { lappend BonneBoite $Nom break } } if {$BonneBoite!={}} { Espionne "$BonneBoite NmAlone" RangeMoi set EviOf $Ligne $BonneBoite "NmAlone" #ok continue } FaireLire "Probleme NmUnSeul" } if {$nbNM>1} { incr cas3b; Espionne "cas3b" set LongMax 0 if {$LongLesGnsNM==1} { set BonneBoitetv "" incr unseulgn; Espionne "unseulgn" foreach Nom $ListeDesNoms { set Acc [AccessEvi $Nom] if {![regexp {NM_} $Acc]} {continue} set Loc [ExtraitInfo $Nom "LocUcscFrom200602"] lappend LesLoc $Loc set LesMotsLoc [split $Loc ":- "] set start "" set stop "" Espionne "$Nom $Loc" set start [lindex $LesMotsLoc 1] set stop [lindex $LesMotsLoc 2] if {$start=="" || $stop==""} { continue } set longgn [expr $stop - $start] Espionne "$longgn" if {$longgn > $LongMax} { set BonneBoitetv $Nom set LongMax $longgn } } lappend BonneBoite $BonneBoitetv } if {$BonneBoite!={}} { Espionne "$BonneBoite NmBestLoc" RangeMoi set EviOf $Ligne $BonneBoite "NmBestLoc" continue } if {$LongLesGnsNM!=1} { set onapls 0 incr plsgn; Espionne "plsgn" set LaDesClient [RetChip5 $Ligne description_customer] regsub -nocase -all "\\+" $LaDesClient "" LaDesClient regsub -all {\-} $LaDesClient "" LaDesClientCompact regsub -all " " $LaDesClientCompact "" LaDesClientCompact regsub -all "beta" $LaDesClientCompact "b" LaDesClientCompact regsub -all "alpha" $LaDesClientCompact "a" LaDesClientCompact set premiereloc 1; set client 0; Espionne "LaDesClient $LaDesClient" Espionne "LaDesClientCompact $LaDesClientCompact" foreach Nom $ListeDesNoms { set Acc [AccessEvi $Nom] set Gn [ExtraitInfo $Nom "ValiGN"] set Des [ExtraitInfo $Nom "ValiDE"] regsub -nocase -all "\\+" $Des "" Des regsub -all {\-} $Des "" DesCompact regsub -all " " $DesCompact "" DesCompact regsub -all "beta" $DesCompact "b" DesCompact regsub -all "alpha" $DesCompact "a" DesCompact if {![regexp {NM_} $Acc]} {continue} if {$Gn!="" && [regexp -nocase $Gn $LaDesClientCompact]} { Espionne "rentreici" set client 1 Espionne "Des $Des" Espionne "DesCompact $DesCompact" Espionne "$Nom $Gn ce que veut client" lappend BonneBoite $Nom if {![regexp {transcript variant} $Des]} { break } } if {$Des!="" && $LaDesClient!="" && ([regexp -nocase $LaDesClient $Des]|| [regexp -nocase $DesCompact $LaDesClientCompact] || [regexp -nocase $LaDesClientCompact $DesCompact])} { Espionne "rentrela" if {[regexp {similar} $Des]} {continue} set client 1 Espionne "Des $Des" Espionne "DesCompact $DesCompact" Espionne "$Nom [string range $Des 0 10] ce que veut client" lappend BonneBoite $Nom if {![regexp {transcript variant} $Des]} { break } } } if {[llength $BonneBoite]>1} { Espionne "attention" set LongMax 0; set BonneBoiteFinal {} foreach Boite $BonneBoite { set Loc [ExtraitInfo $Boite "LocUcscFrom200602"] lappend LesLoc $Loc set LesMotsLoc [split $Loc ":- "] set start "" set stop "" Espionne "$Boite $Loc" set start [lindex $LesMotsLoc 1] set stop [lindex $LesMotsLoc 2] if {$start=="" || $stop==""} { continue } set longgn [expr $stop - $start] Espionne "$longgn" if {$longgn > $LongMax} { lappend BonneBoiteFinal $Boite set LongMax $longgn } } set BonneBoite $BonneBoiteFinal } if {$BonneBoite!={}} { Espionne "$BonneBoite NmBestClient" RangeMoi set EviOf $Ligne $BonneBoite "NmBestClient" continue } if {$BonneBoite=={}} { set BonneBoite [ChoisisBonneBoite $Ligne] if {$BonneBoite!={}} { RangeMoi set EviOf $Ligne $BonneBoite "LaetitiaChoose" continue } } } } if {$nbNM==0} { incr cas3c; Espionne "cas3c" if {$NbDeNomPrUneLigne==$nbXM} { incr cas3d; Espionne "cas3d" Espionne "que des xm" foreach Nom $ListeDesNoms { lappend BonneBoite $Nom break } Espionne "$BonneBoite XmFirstNoNm" RangeMoi set EviOf $Ligne $BonneBoite "XmFirstNoNm" continue } incr cas3e; Espionne "cas3e" set LongMax 0 Espionne "pas que des xm" set nbpartial 0; set nbxml 0 ScanLaListe [CompteDans $ListeDesNoms "NM" "XM"] nbNM nbXM set PremierGb "" set PremierXm "" foreach Nom $ListeDesNoms { if { $PremierGb=="" && ! [regexp "XM" [AccessEvi $Nom]]} { set PremierGb $Nom } if { $PremierXm=="" && [regexp "XM" [AccessEvi $Nom]]} { set PremierXm $Nom } set Des [ExtraitInfo $Nom "ValiDE"] if {[regexp {partial} $Des] || [regexp {fragment} $Des]} { continue } if {[regexp "XM" [AccessEvi $Nom]]} { continue } if {[regexp "NR" [AccessEvi $Nom]]} { continue } lappend BonneBoite $Nom Espionne "$BonneBoite GbFirstNotPartial" RangeMoi set EviOf $Ligne $BonneBoite "GbFirstNotPartial" break } if {$BonneBoite!={}} { continue } foreach Nom $ListeDesNoms { set Des [ExtraitInfo $Nom "ValiDE"] if {[regexp {partial} $Des] || [regexp {fragment} $Des]} { continue } lappend BonneBoite $Nom Espionne "$BonneBoite XmFirstNonPartial" RangeMoi set EviOf $Ligne $BonneBoite "XmFirstNotPartial" #ok break } if {$BonneBoite!={}} { continue } if {$PremierGb!=""} { lappend BonneBoite $PremierGb Espionne "$BonneBoite GbFirst" RangeMoi set EviOf $Ligne $BonneBoite "GbFirst" #ok continue } if {$PremierXm!=""} { lappend BonneBoite $PremierXm Espionne "$BonneBoite XmFirst" RangeMoi set EviOf $Ligne $BonneBoite "XmFirst" #ok continue } lappend BonneBoite [lindex $ListeDesNoms 0] Espionne "$BonneBoite First" RangeMoi set EviOf $Ligne $BonneBoite "First " #ok continue } FaireLire "Horreur $Ligne" } RangeMoi save #AfficheVariable [join [RangeMoi get ListOf Status] "\n"] Espionne "nblignes $nblignes" Espionne "nblignesacunseulnom $unnom" Espionne "nblignesacplsnom $plsnom" Espionne "unnm cas3a $cas3a" Espionne "plsnm cas3b $cas3b" Espionne "unseulgn $unseulgn" Espionne "plsgn $plsgn" Espionne "aucunnm cas3c $cas3c" Espionne "quedesxm cas3d $cas3d" Espionne "pasquedesxm cas3e $cas3e" } proc TrouveLaReferenceVoulue {ReferenceVoulue FichierPhylo} { Wup "Texte est un arbre phylo" Wup "Recherche l'Access qui correspond a l'organisme ReferenceVoulue" Wup " Ne marche bien que pour les synthetases... et encore ... j'ai tout change." set Texte [ContenuDuFichier $FichierPhylo] regsub -all {\(|\)|\:|\n} $Texte " " Texte foreach Mot [split $Texte " "] { if { ! [regexp -nocase {[A-Z]} $Mot]} { continue } if {0 && [regexp -indices {[0-9]} $Mot sChiffre]} { scan $sChiffre "%d" iChiffre puts "$sChiffre $iChiffre" puts $Mot set Mot "[string range $Mot 0 [incr iChiffre -1]]_[string range $Mot [incr iChiffre] end]" puts $Mot } lappend LesMots $Mot } puts [join $LesMots " "] foreach Access $LesMots { if {[regexp $ReferenceVoulue [OrgaDuAccess $Access Court]]} { return $Access } } exit set LesReferencesPossibles {} if { [lsearch -regexp $LesMots $ReferenceVoulue] < 0 } { FaireLire "You have to tell me which organism I take as reference for [AutreCode $Nom]" set Reference [ChoixParmi $LesMots] } else { while {[set iReference [lsearch -regexp $LesMots $ReferenceVoulue]] > -1} { lappend LesReferencesPossibles [lindex $LesMots $iReference] set LesMots [lrange $LesMots [expr $iReference+1] end] } if {[llength $LesReferencesPossibles] == 2 && [AutreCode $Nom]=="glu"} { set iReference [lsearch -regexp $LesReferencesPossibles "sye"] if {$iReference > -1} { set Reference [lindex $LesReferencesPossibles $iReference] } else { FaireLire "You have to tell me which organism I take as reference for [AutreCode $Nom]" set Reference [ChoixParmi $LesReferencesPossibles] } } elseif {[llength $LesReferencesPossibles] == 2 && [AutreCode $Nom]=="gln"} { set iReference [lsearch -regexp $LesReferencesPossibles "syq"] if {$iReference > -1} { set Reference [lindex $LesReferencesPossibles $iReference] } else { FaireLire "You have to tell me which organism I take as reference for [AutreCode $Nom]" set Reference [ChoixParmi $LesReferencesPossibles] } } elseif {[llength $LesReferencesPossibles] > 1} { FaireLire "You have to tell me which organism I take as reference for [AutreCode $Nom]" set Reference [ChoixParmi $LesReferencesPossibles] } else { set Reference [lindex $LesReferencesPossibles 0] } } } proc TrouveLeOldJR {Ligne} { #oldjr= jr de la liste des 926 (pour lequel tout est calcule) set LesJumeaux [split $Ligne " "] set Trouve 0 foreach DD $LesJumeaux { if {[info exists Vu($DD)]} {set Trouve 1;return $DD} } if {$Trouve==0} {return ""} } proc TrouveLesInsuffisants {} { set LesExonhitNonJR {} foreach PAB [ListeDesPABs] { set VuJR 0 set Old [AncienNom $PAB] if {[regexp "^EX" $Old]} { foreach Ligne [LesLignesDuFichier "[GscopeDatabaseDir Exonhit]/fiches/clusters"] { scan $Ligne "%s" jr if {$Old!=$jr} { continue } else { set VuJR 1 } } if {$VuJR==0} {lappend LesExonhitNonJR $PAB} } } return $LesExonhitNonJR } proc TrouveLesJamaisExprimes {{Qui ""} {Quoi ""}} { global TrouveLesJamaisExprimes if {$Qui==""} {set Qui "ListeDes" ; set Quoi "ProbeSet"} if {$Quoi==""} {set Quoi "OuiNon"} if {[info exists TrouveLesJamaisExprimes($Qui,$Quoi)]} { return $TrouveLesJamaisExprimes($Qui,$Quoi) } if {[info exists TrouveLesJamaisExprimes("EstCharge")]} { return "" } set TrouveLesJamaisExprimes("EstCharge") "" set Fichier "/genomics/link/WP14/Wolfgang/congRD1/gcrma/which.2ndHi.ps.neverAbove4.7gcrma.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^affyID" $Ligne]} {continue} set LesMots [split $Ligne "\t"] set Ps [lindex $LesMots 0] set OuiNon [lindex $LesMots 1] lappend TrouveLesJamaisExprimes(ListeDes,ProbeSet) $Ps set TrouveLesJamaisExprimes($Ps,OuiNon) $OuiNon } return [TrouveLesJamaisExprimes $Qui $Quoi] } proc TrouveLesRefs {Org} { set nbVide 0; set nbSsRef 0 #ici la ref est le plus grand NM ou ENS #ds le cas ou le cluster n'a ni NM ni ENS, on prend le plus grand LA #Oldversion: #1ereversion: la ref est le plus grand ensembl #2emeversion: la ref est le plus grand NM ou ENS if {[regexp -nocase "Test" $Org]} { set RepertoireSourisOthers "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_others_61_mai" set RepertoireSourisTfactor "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_Tfactor_61_mai" set RepertoireSourisNoAlt "/genomics/link/SpliRetTest/FichiersInitial/PROT_VARIANTES_61_mai/SOURIS_NO_ALT_61_mai" set LesRepertoires [list $RepertoireSourisTfactor $RepertoireSourisOthers $RepertoireSourisNoAlt] set FichierOut "/genomics/link/SpliRetTest/FichiersInitial/RefsDesClusters" } if {[regexp -nocase "Mouse" $Org]} { set LesRepertoires [LesRepertoires "Mouse" "Mod"] set FichierOut "/genomics/link/SpliRetMouse/FichiersModifUnique/RefsDesClusters" } if {[regexp -nocase "Rat" $Org]} { set LesRepertoires [LesRepertoires "Rat" "Mod"] set FichierOut "/genomics/link/SpliRetRat/FichiersModifUnique/RefsDesClusters" } foreach Repertoire $LesRepertoires { foreach FileST [glob -nocomplain "$Repertoire/*"] { set cluster [lindex [split [file tail $FileST] "."] 0] set taille [file size $FileST] if {$taille == 0} {incr nbVide; continue} set YaRef [ClusterAvOuSsRef $cluster ref $Org] if {!$YaRef} {incr nbSsRef} set NameDuPlusGrandRef "" set LongDuPlusGrandRef -999 foreach Access [LaSequenceDuTFAs $FileST "LaListeDesAccess" "" "" "ForceAccessFirst" "AllowDigitOnly"] { regsub "Nbr" $Access "" Access set TFA [LaSequenceDuTFAs $FileST $Access] set Seq [QueLaSequenceDuTexteTFA $TFA] set LongCourant [string length $Seq] #Espionne "$Access $LongCourant" if {$YaRef && ! [regexp {^(ENS|NM|XM)} $Access] } { continue } if {$LongCourant>$LongDuPlusGrandRef} { set LongDuPlusGrandRef $LongCourant set NameDuPlusGrandRef $Access } } set LigneResult "$cluster $NameDuPlusGrandRef" #Espionne $LigneResult lappend LesLigneResult $LigneResult } } Espionne "nbvide= $nbVide nbssref= $nbSsRef" SauveLesLignes $LesLigneResult dans $FichierOut } proc TrouveLesSsProt {{Liste ""}} { set lesmanquants 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set NvNom "$Nom _1" regsub " " $NvNom "" NvNom set Fichier "[GscopeFile $NvNom protembl]" if {![file exists $Fichier]} { incr lesmanquants Espionne "$lesmanquants $NvNom manque" } } Espionne "nombre= $lesmanquants" } proc TrouveLesSsProt2 {{Liste ""}} { set lesmanquants 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set Fichier "[GscopeFile $Nom prottfa]" if {![file exists $Fichier]} { incr lesmanquants Espionne "$Fichier" Espionne "$lesmanquants $Nom manque" } } Espionne "nombre= $lesmanquants" } proc TrouveMacsimFaux {{Liste ""}} { set total 0; set A 0; set B 0; set C 0; set D 0; set Dbis 0; set E 0; set Ebis 0; set F 0; set G 0 set LesARefaire {} if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { puts "" puts "$Nom" incr total set FichierMsf "[RepertoireDuGenome]/msf/$Nom" set FichierMacsimRsf "[RepertoireDuGenome]/macsim/$Nom.rsf" set FichierMacsimXml "[RepertoireDuGenome]/macsim/$Nom.xml" if {![file exists $FichierMsf] && ![file exists $FichierMacsimRsf] && ![file exists $FichierMacsimXml]} { incr A puts "normal pas msf" } if {[file exists $FichierMsf] && (![file exists $FichierMacsimRsf] || ![file exists $FichierMacsimXml])} { incr B puts "pas normal ac msf" lappend LesARefaire $Nom #arelancer } if {[file exists $FichierMsf] && [file exists $FichierMacsimRsf] && [file exists $FichierMacsimXml]} { incr C set LesLignesRsf [LesLignesDuFichier $FichierMacsimRsf] set longrsf [llength $LesLignesRsf] set premLigneRsf [lindex $LesLignesRsf 0] set derniereligneRsf [lindex $LesLignesRsf [expr $longrsf -1]] if {![regexp {^!!RICH_SEQUENCE} $premLigneRsf]} { incr D puts "pb ac rsf" lappend LesARefaire $Nom } if {![regexp {^\}} $derniereligneRsf]} { incr Dbis puts "pbbis ac rsf" lappend LesARefaire $Nom } set LesLignesXml [LesLignesDuFichier $FichierMacsimXml] set longxml [llength $LesLignesXml] set premLigneXml [lindex $LesLignesXml 0] set derniereligne [lindex $LesLignesXml [expr $longxml -1]] if {![regexp {^<\?xml version="1.0"\?>} $premLigneXml]} { incr E puts "pb ac xml" lappend LesARefaire $Nom } if {![regexp {^} $derniereligne]} { incr Ebis puts "pbbis ac xml" lappend LesARefaire $Nom } set taillersf [file size $FichierMacsimRsf] set taillexml [file size $FichierMacsimXml] puts "taillersf $taillersf" puts "taillexml $taillexml" if {$taillersf <=1} { incr F puts "rsf trop petit" lappend LesARefaire $Nom } if {$taillexml <=1} { incr G puts "xml trop petit" lappend LesARefaire $Nom } } } set LesARefaire [ListeSansDoublon $LesARefaire] set longdesarefaire [llength $LesARefaire] puts "longdesarefaire $longdesarefaire" SauveLesLignes $LesARefaire dans "[RepertoireDuGenome]/MacsimARelancer4" puts "total $total" #5543 puts "A $A" #410 puts "B $B" #146 puts "C $C" #4987 puts "D $D" #2 puts "Dbis $Dbis" #2 puts "E $E" #0 puts "Ebis $Ebis" #2 puts "F $F" #2 puts "G $G" #0 } proc TrouveRatio {ProbeSet} { set LesLignes {} CanalSqlBioArrayBase foreach {Ps Ch Ex Ra De So} [SqlExec "select p.probeset_id, at.type, e.description, ra.ratio, ra.ratiodescription, a.name from retinobase3.realexp re, retinobase3.experiment e, retinobase3.ratio ra, retinobase3.arraytype at, retinobase3.analysissoftware a, retinobase3.probeset p where p.pk_probeset = ra.pk_probeset and ra.pk_software = a.pk_software and ra.pk_realexp = re.pk_realexp and re.pk_experiment = e.pk_experiment and re.pk_arraytype = at.pk_arraytype and p.probeset_id = '$ProbeSet' order by re.pk_realexp;" "GetList"] { lappend LesLignes "$Ps\t$Ch\t$Ex\t$Ra\t$De\t$So" } CanalSqlDisconnect return [join $LesLignes "\n"] } proc TrouveRedondantDsRefGene {} { set premier 1 set RepertoireUcsc "/genomics/link/UCSCGenomes" set FichierLocUcscMouse "$RepertoireUcsc/Mus_musculus/database/refGene.txt" foreach Ligne [LesLignesDuFichier $FichierLocUcscMouse] { set trouve 0 if {$Ligne==""} {continue} set LesMots [LesMotsDeLaLigne $Ligne] set AccNm [lindex $LesMots 1] #Espionne "AccNm $AccNm" if {$premier} { set premier 0 lappend LesAcc $AccNm } else { foreach Acc $LesAcc { if {$Acc==$AccNm} { Espionne "$AccNm en pls exemplaires" set trouve 1 } } if {!$trouve} { lappend LesAcc $AccNm } } } } proc TrouveRedondants {} { set File "/genomics/link/SpliRetMouse/database/TousLesAccess" foreach Ligne [LesLignesDuFichier $File] { set Access [StringSuivant "Access:" dans $Ligne] set index [string first "Access" $Ligne] set Morceau [string range $Ligne 0 [expr $index -1]] lappend Redond($Morceau) $Access } foreach Clef [array names Redond] { Espionne "" Espionne "$Clef" EspionneL "$Redond($Clef)" set nbPotentiel [llength $Redond($Clef)] if {$nbPotentiel>1} { array unset Redond2; set LesLignesRedond {} set i -1 foreach Value $Redond($Clef) { incr i # Espionne "$i: $Value" set Seq$i [string trim [InterrogeSeq $Value Seq]] # Espionne "[set Seq$i]" set Redond2($i) $Value } for {set j 0} {$j <$nbPotentiel} {incr j} { for {set k 1} {$k <$nbPotentiel} {incr k} { if {$k<=$j} {continue} if {[string equal [set Seq$j] [set Seq$k]]} { set LigneRedond "$Redond2($j) egale $Redond2($k)" # Espionne "$LigneRedond" lappend LesLignesRedond $LigneRedond } } } if {$LesLignesRedond=={}} {continue} set premierefois 1; set m 0 foreach cas $LesLignesRedond { #Espionne "cas $cas" set LesMots [split $cas " "] set Un [lindex $LesMots 0] set Deux [lindex $LesMots 2] if {$premierefois} { lappend Liste$m $Un lappend Liste$m $Deux set premierefois 0 #Espionne "1er m=$m" #EspionneL "[set Liste$m]" } else { #Espionne "2eme m=$m" set trouve 0 for {set n 0} {$n <= $m} {incr n} { #Espionne "n=$n (m=${m})" foreach Ac [set Liste$n] { #Espionne "Ac $Ac" #Espionne "Un $Un Deux $Deux" if {$Ac==$Un || $Ac==$Deux} { set trouve 1 #Espionne "onatrouve" lappend Liste$n $Un lappend Liste$n $Deux break } } } if {!$trouve} { incr m #Espionne "pastrouve m=$m" lappend Liste$m $Un lappend Liste$m $Deux } } } for {set p 0} {$p <= $m} {incr p} { set LesNonRefs {} # Espionne "Liste $p :" set Liste$p [ListeSansDoublon [set Liste$p]] # EspionneL "[set Liste$p]" set Accesss [join [set Liste$p] " "] if {[regexp "SW:" $Accesss]} { set ref "SW:" } elseif {[regexp "TR:" $Accesss]} { set ref "TR:" } elseif {[regexp "VARSPLIC:" $Accesss]} { set ref "VARSPLIC:" } elseif {[regexp "REFSEQPNEW:" $Accesss]} { set ref "REFSEQPNEW:" } elseif {[regexp "REFSEQPREL:" $Accesss]} { set ref "REFSEQPREL:" } elseif {[regexp "ENS" $Accesss]} { set ref "ENS" } else { return "aucune ref trouve pour $Clef" } Espionne "quelle ref? $ref" set trouveref 0 foreach elmt [set Liste$p] { if {[regexp $ref $elmt] && !$trouveref} { set trouveref 1 set LaRef $elmt } else { lappend LesNonRefs $elmt lappend TousLesNonsRefs $elmt } } Espionne "LaRef $LaRef" set LesNonRefs [join $LesNonRefs " "] Espionne "LesNonRefs $LesNonRefs" set LigneASauver "$LaRef $LesNonRefs" lappend LesLignesASauver $LigneASauver set Liste$p {} } } } SauveLesLignes $LesLignesASauver dans "/genomics/link/SpliRetMouse/database/LaRefEtLesAccessRedondants" SauveLesLignes $TousLesNonsRefs dans "/genomics/link/SpliRetMouse/database/LesAccessRedondants" } proc TssForESRARE {} { set Fichier "/home/gioalt/WORK-IN-PROGRESS/data/HSDRs_coordinates_input.txt" foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp {^ESRAR} $Ligne] } { continue } scan $Ligne "%s %s %s %s %s %s %s" N Name Chr Strand Seq D F set M [expr ($D +$F)/2] set B [LocBefore $M "Mouse" $Chr]; scan $B "%s %s %s %s" RB DB FB SB set A [LocAfter $M "Mouse" $Chr]; scan $A "%s %s %s %s" RA DA FA SA set I [LocIn $M "Mouse" $Chr]; scan $I "%s %s %s %s" RI DI FI SI set DeltaI "NotFound" if {$I!=""} { set DeltaI 0 set LeTfaI [LaSequenceDesBanques $RI]; set EI [lindex $LeTfaB 0] } set DeltaB [expr $M-$FB] set DeltaA [expr $DA-$M] set LeTfaB [LaSequenceDesBanques $RB]; set EB [lindex $LeTfaB 0] set LeTfaA [LaSequenceDesBanques $RA]; set EA [lindex $LeTfaA 0] set Ok "" if {$DeltaI==0} { if {[regexp -nocase $Name $EI]} { set Ok "Hourrahhhh" Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Inside $RI $Ok" lappend LesInside "$N $Name $M $Strand $SI $DI $FI $DeltaI $RI $EI" continue } } if {$DeltaB < $DeltaA} { if {[regexp -nocase $Name $EB]} { set Ok "Hourrahhhh" Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Before $RB $Ok" lappend LesBefore "$N $Name $M $Strand $SB $DB $FB $DeltaB $RB $EB" continue } } if {$DeltaA < $DeltaB} { if {[regexp -nocase $Name $EA]} { set Ok "Hourrahhhh" Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA After $RA $Ok" lappend LesAfter "$N $Name $M $Strand $SA $DA $FA $DeltaA $RA $EA" continue } } if {$DeltaA == $DeltaB} { FaireLire "$N $Name $FB $M $DA $DeltaB $DeltaA Equality !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" } if {$Ok==""} { Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Before $RB Perduuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu" Espionne "$EB\n$EA" lappend LesPerdus "$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA \n$EB\n$EA\n" } } AfficheVariable [join $LesBefore "\n"] "" "Before" AfficheVariable [join $LesAfter "\n"] "" "After" AfficheVariable [join $LesPerdus "\n"] "" "Perdus" } proc TuArretesDeBosser {} { global Bosseurs set LesTextes [list "Select the process you want to stop"] foreach Texte [array names Bosseurs] { if {[regexp "/" $Texte]} { continue } lappend LesTextes $Texte } set Texte [ChoixParmi $LesTextes] if {$Texte=="" || ! [info exists Bosseurs($Texte)]} { return "" } set Toi [set Bosseurs($Texte)] if {$Toi==""} { return "" } Sauve $Texte dans $Toi return $Toi } proc TuMontrerasCeQueFaitLeBouton {Bouton} { global QuelBouton return [set QuelBouton [after 1000 MontreCeQueFaitLeBouton $Bouton]] } proc TwoPi {} { return [expr 2*3.1415926] } proc Tx {{D ""} {F ""}} { global Tx TxD TxF if {$D==""} { set D $TxD } if {$F==""} { set F $TxF } return [string range $Tx $D $F] } proc TypeAc {} { set K 0 set list {} foreach I [RetChip5 ListOf Index] { set Ac [RetChip5 $I "DNA_acc"] if {$Ac!=""} { set LesAC [split $Ac ","] foreach AC $LesAC { set pref [string range $AC 0 1] if {[regexp {[0-9]+} $pref]} { set pref [string range $pref 0 0] } Espionne "le prefixe est $pref a la ligne $I" lappend list $pref } } } set L [lsort -unique $list] set NB [llength $L] foreach x $L { puts $x } Espionne "nb de type d'access different=$NB" } proc TypeAc_AEffacer {} { set K 0 set list {} foreach I [RetChip2 ListOf Index] { set AC [RetChip2 $I "DNA_acc"] if {$AC!=""} { if { [regexp {.\,.} $AC] } { incr K Espionne "attention il y a pls access pour ligne $I=>$K" continue } # set pref [string range $AC 0 2] # if {[regexp -nocase {^[a-z]3} $pref]} {Espionne "attention $pref a 3 lettres=>$I"} set pref [string range $AC 0 1] if {[regexp {[0-9]+} $pref]} { set pref [string range $pref 0 0] } Espionne "le prefixe est $pref a la ligne $I" lappend list $pref } } set L [lsort -unique $list] set NB [llength $L] foreach x $L { puts $x } Espionne "nb de type d'access different=$NB" } proc TypeAli {} { return [set ::Defauts(TypeAli)] } proc TypeDeVecteurGateway {Vecteur} { if {$Vecteur==""} { return 0 } if {[regexp "/" $Vecteur]} { set Fichier $Vecteur } else { set Fichier [FindVector $Vecteur] if {[FileAbsent $Fichier]} { return 0 } } set Seq [QueLaSequenceDuFichierTFA $Fichier] if {[regexp -nocase [SEQAttL1] $Seq] && [regexp -nocase [SEQAttL2] $Seq]} { return 1 } if {[regexp -nocase [SEQAttR1] $Seq] && [regexp -nocase [SEQAttR2] $Seq]} { return 2 } return 0 } proc TypeDeVecteurGatewayPourTous {} { foreach Vecteur [LesVecteurs] { Espionne "[TypeDeVecteurGateway $Vecteur] $Vecteur" } } proc TypeOntologieExiste {Type} { if {![File exists "[OntologyDir]/$Type.ontology"]} {return 0} return 1 } proc TypeProsite {IdProsite} { #un prosite est soit MATRIX soit PATTERN set link "http://prosite.expasy.org/$IdProsite" set LesLignes [LesLignesDuFichier $link] foreach Ligne $LesLignes { if {![regexp "Entry type" $Ligne]} {continue} ValeurDeLaBalise "td" Ligne set type [ValeurDeLaBalise "td" Ligne] return $type } } proc TypeSeq {} { return $::TypeSeq } proc UCSCGenomeDir {Genome} { Wup "Genome directory" global UCSCGenomeDir if {[info exists UCSCGenomeDir($Genome)] && [file exists [set UCSCGenomeDir($Genome)]]} {return [set UCSCGenomeDir($Genome)]} switch -exact -- $Genome { "human" {set UCSCGenomeDir($Genome) "/genomics/g3/UCSCGenomes/Homo_sapiens"} "mouse" {set UCSCGenomeDir($Genome) "/genomics/g3/UCSCGenomes/Mus_musculus"} "mstigr" {set UCSCGenomeDir($Genome) "/genomics/g5/MsTigr/DuTigr"} "default" {return ""} } if {[info exists UCSCGenomeDir($Genome)] && [file exists [set UCSCGenomeDir($Genome)]]} {return [set UCSCGenomeDir($Genome)]} return "" } proc UNRREAL {fileIn fileOut hs1 type hs2 nbmistakes1 nbmistakes2 chr {includeRepeats no}} { # Recherche un motif en générant un mismatch (adapté récepteurs nucléaires) set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Start" if {$includeRepeats == "no"} { set casse "" } else { set casse "-nocase" } set ChromoSize [ChromoSize "human" "hg18" "chr$chr"] set FichierOut [open "$fileOut" "w"] set FichierRepeats [open "$fileOut.rep" "w"] set FichierDesDR "RGKTSA-$type.txt" regsub -all -nocase {[A-z]} $type "" type set hs1length [string length $hs1] set hs2length [string length $hs2] set reverseHs1 [IUPACtoReverseAndComplementIUPAC $hs1] set reverseHs2 [IUPACtoReverseAndComplementIUPAC $hs2] set pseudoRegExp1 [IUPACtoRegExp $hs1] set pseudoRegExp2 [IUPACtoRegExp $hs2] set pseudoRegExp1R [IUPACtoRegExp $reverseHs1] set pseudoRegExp2R [IUPACtoRegExp $reverseHs2] set matchArray {} set AllMatchesArray {} set oneMatch {} set regExpMistakeParam1 {} set regExpMistakeParam2 {} regsub -all {\_} $pseudoRegExp1 "" regExp1 regsub -all {\_} $pseudoRegExp2R "" regExp2R if {$nbmistakes1 == 1} { for {set i 0} {$i < $hs1length} {incr i} { unset regExpMistakeParam1 set regExpMistakeParam1 $i set regExp1Add [regExpMistake $pseudoRegExp1 $regExpMistakeParam1] set regExp2AddR [regExpMistake $pseudoRegExp2R $regExpMistakeParam1] set regExp1 "$regExp1|$regExp1Add" set regExp2R "$regExp2R|$regExp2AddR" } } if {$nbmistakes1 == 2} { for {set i 0} {$i < $hs1length} {incr i} { for {set l 0} {$l < $hs1length} {incr l} { if { $l <= $i } { unset regExpMistakeParam1 set regExpMistakeParam1 "$i $l" set regExp1Add [regExpMistake $pseudoRegExp1 $regExpMistakeParam1] set regExp2AddR [regExpMistake $pseudoRegExp2R $regExpMistakeParam1] set regExp1 "$regExp1|$regExp1Add" set regExp2R "$regExp2R|$regExp2AddR" } } } } regsub -all {\_} $pseudoRegExp2 "" regExp2 regsub -all {\_} $pseudoRegExp1R "" regExp1R if {$nbmistakes2 == 1} { for {set j 0} {$j < $hs2length} {incr j} { unset regExpMistakeParam2 set regExpMistakeParam2 $j set regExp2Add [regExpMistake $pseudoRegExp2 $regExpMistakeParam2] set regExp1AddR [regExpMistake $pseudoRegExp1R $regExpMistakeParam2] set regExp2 "$regExp2|$regExp2Add" set regExp1R "$regExp1R|$regExp1AddR" } } if {$nbmistakes2 == 2} { for {set j 0} {$j < $hs2length} {incr j} { for {set k 0} {$k < $hs2length} {incr k} { unset regExpMistakeParam2 set regExpMistakeParam2 "$j $k" set regExp2Add [regExpMistake $pseudoRegExp2 $regExpMistakeParam2] set regExp1AddR [regExpMistake $pseudoRegExp1R $regExpMistakeParam2] set regExp2 "$regExp2|$regExp2Add" set regExp1R "$regExp1R|$regExp1AddR" } } } set regExp "($regExp1)" append regExp {[ATCGatcgN]} append regExp "{$type}" append regExp "($regExp2)" set regExpR "($regExp2R)" append regExpR {[ATCGatcgN]} append regExpR "{$type}" append regExpR "($regExp1R)" set len [expr $hs1length + $hs2length + $type] set sequenceNumber 0 set totalHits 0 set totalMatches {} set nbMatchs 0 array unset SeqTFA set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Loading sequences" array set SeqTFA [readFasta $fileIn 0] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] foreach Acc $SeqTFA(index) { set sequence $SeqTFA($Acc,sequence); set listeDesStarts {} set indo -1 set sequenceHitNumber 0 incr sequenceNumber set AllMatchesArray {} set matches {} set sequenceLength [string length $sequence] set oneMatch {} puts -nonewline "$timestamp|UNRREAL chr$chr/DR$type : Scanning Plus strand " set startOffset 0 set Hit 0 while { [eval regexp $casse -indices -start {$startOffset} {$regExp} {$sequence} Position] } { incr Hit incr HitPlus set PositionStart [lindex $Position 0] set PositionEnd [lindex $Position 1] set matchSequence [string range $sequence $PositionStart $PositionEnd] lappend AllMatchesArray [list $matchSequence $PositionStart $PositionEnd "F"] set startOffset [expr $PositionStart +1] } puts "(Hits : $HitPlus)" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] puts -nonewline "$timestamp|UNRREAL chr$chr/DR$type : Scanning Minus strand " set startOffset 0 flush stdout while { [eval regexp $casse -indices -start {$startOffset} {$regExpR} {$sequence} Position] } { incr Hit incr HitMoins set PositionStart [lindex $Position 0] set PositionEnd [lindex $Position 1] set matchSequence [string range $sequence $PositionStart $PositionEnd] lappend AllMatchesArray [list $matchSequence $PositionStart $PositionEnd "R"] set startOffset [expr $PositionStart + 1] } puts "(Hits : $HitMoins)" set numou 0 set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Parsing $Hit merged results" foreach Match $AllMatchesArray { incr nbMatchs set sequenceHitNumber [llength $AllMatchesArray] set hs1MistakeArray {} set hs2MistakeArray {} set hs1Mistake 0 set hs2Mistake 0 set matchSequence [lindex $Match 0] set matchStart [lindex $Match 1] set matchEnd [lindex $Match 2] set matchType [lindex $Match 3] if {$matchType == "F"} { set hs1Sequence [string range $matchSequence 0 [expr $hs1length - 1] ] set hs2Sequence [string range $matchSequence [expr $hs1length + $type] [expr $hs1length + $type + $hs2length]] set linkerStart $hs1length set linkerStop [expr $hs1length + $type - 1] set linker [string range $matchSequence $linkerStart $linkerStop ] set hs1MistakeArray [IUPACcheck $hs1 $hs1Sequence] set hs2MistakeArray [IUPACcheck $hs2 $hs2Sequence] } else { set hs1Sequence [string range $matchSequence [expr $hs2length + $type] [expr $hs2length + $type + $hs1length]] set hs2Sequence [string range $matchSequence 0 [expr $hs1length - 1]] set linkerStart $hs2length set linkerStop [expr $hs2length + $type - 1] set linker [string range $matchSequence $linkerStart $linkerStop] set hs1MistakeArray [IUPACcheck $reverseHs1 $hs1Sequence] set hs2MistakeArray [IUPACcheck $reverseHs2 $hs2Sequence] #Espionne "$matchSequence $hs2Sequence $linker $hs1Sequence $reverseHs1" } set matchStart [expr $matchStart + 1] set matchEnd [expr $matchEnd + 1] set hs1Mistake [llength $hs1MistakeArray] set hs2Mistake [llength $hs2MistakeArray] set hs1SequenceArray [split $hs1Sequence ""] set hs2SequenceArray [split $hs2Sequence ""] set mm1 "" set mm2 "" set mm1Array {} set mm2Array {} if {$matchType == "R"} { foreach mm1 $hs1MistakeArray { set mm1 [expr 7 - $mm1] lappend mm1Array $mm1 } foreach mm2 $hs2MistakeArray { set mm2 [expr 7 - $mm2] lappend mm2Array $mm2 } } else { foreach mm1 $hs1MistakeArray { lappend mm1Array $mm1 } foreach mm2 $hs2MistakeArray { lappend mm2Array $mm2 } } lsort $mm1Array lsort $mm2Array set themistakes1 "" foreach mis1 $mm1Array { append themistakes1 "/$mis1" } set themistakes2 "" foreach mis2 $mm2Array { append themistakes2 "/$mis2" } set start 0 set acc "" incr indice; set matchEnd [expr $matchStart + $hs1length + $hs2length + $type - 1] if {[regexp {a|t|c|g} $matchSequence]} { if {$includeRepeats == "yes"} { puts $FichierRepeats "$nbMatchs $sequenceNumber $chr $matchStart $matchEnd $matchType $hs1Mistake@$themistakes1 $hs2Mistake@$themistakes2 $matchSequence" incr totalHits } } else { puts $FichierOut "$nbMatchs $sequenceNumber $chr $matchStart $matchEnd $matchType $hs1Mistake@$themistakes1 $hs2Mistake@$themistakes2 $matchSequence" incr totalHits } set verif "true" incr numou } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : End ($totalHits hits)" close $FichierOut } proc UNRREALc {chrom type} { set fileIn "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200603/chr$chrom.fa" set fileOut "/genomics/link/RGKTSA/Coordonnees/chr$chrom-$type.coord" set hs1 "RGKTSA" set hs2 "RGKTSA" set nbmistakes1 2 set nbmistakes2 2 UNRREAL $fileIn $fileOut $hs1 $type $hs2 $nbmistakes1 $nbmistakes2 $chrom } proc UNRREALold {chr DR} { # Recherche un motif en générant un mismatch (adapté récepteurs nucléaires) set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Start" set Chromosome "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200603/chr$chr.fa" set FichierDesDR1 "RGKTSA-Chr$chr-DR1.txt" if { [file exists $FichierDesDR1] } { file delete $FichierDesDR1 } if { [file exists $FichierDesDR2] } { file delete $FichierDesDR2 } if { [file exists $FichierDesDR3] } { file delete $FichierDesDR3 } if { [file exists $FichierDesDR4] } { file delete $FichierDesDR4 } if { [file exists $FichierDesDR5] } { file delete $FichierDesDR5 } if { [file exists $FichierDesDR6] } { file delete $FichierDesDR6 } set DR1 0 set DR2 0 set DR3 0 set DR4 0 set DR5 0 set DR6 0 array unset SeqTFA array set SeqTFA [readFasta $Chromosome 0] set Acc [lindex $SeqTFA(index) 0] set RegExp {[AG]G[TG]T[CG]A} append RegExp {|[CT]G[TG]T[CG]A} append RegExp {|[AG][ATC][TG]T[CG]A} append RegExp {|[AG]G[AC]T[CG]A} append RegExp {|[AG]G[TG][ACG][CG]A} append RegExp {|[AG]G[TG]T[AT]A} append RegExp {|[AG]G[TG]T[CG][TCG]} set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Scanning plus strand" set ListeDesPositionsPlus [regexp -indices -all -inline -nocase "$RegExp" $SeqTFA($Acc,sequence)] set RegExp {T[GC]A[CA]C[TC]} append RegExp {|[ACG][GC]A[CA]C[TC]} append RegExp {|T[AT]A[CA]C[TC]} append RegExp {|T[GC][CGT][CA]C[TC]} append RegExp {|T[GC]A[GC]C[TC]} append RegExp {|T[GC]A[CA][GAT][TC]} append RegExp {|T[GC]A[CA]C[AG]} set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Scanning minus strand" set ListeDesPositionsMoins [regexp -indices -all -inline -nocase "$RegExp" $SeqTFA($Acc,sequence)] set Start 0 set End 0 set DR1f [open $FichierDesDR1 "w"] set DR2f [open $FichierDesDR2 "w"] set DR3f [open $FichierDesDR3 "w"] set DR4f [open $FichierDesDR4 "w"] set DR5f [open $FichierDesDR5 "w"] set DR6f [open $FichierDesDR6 "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Parsing plus strand" foreach PaireDeBornes $ListeDesPositionsPlus { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 2 } { incr DR1 puts $DR1f " DR1 $DR1 chr$chr $Start $NewEnd +" } if { [expr $NewStart - $End] == 3 } { incr DR2 puts $DR2f "DR2 $DR2 chr$chr $Start $NewEnd +" } if { [expr $NewStart - $End] == 4 } { incr DR3 puts $DR3f "DR3 $DR3 chr$chr $Start $NewEnd +" } if { [expr $NewStart - $End] == 5 } { incr DR4 puts $DR4f "DR4 $DR4 chr$chr $Start $NewEnd +" } if { [expr $NewStart - $End] == 6 } { incr DR5 puts $DR5f "DR5 $DR5 chr$chr $Start $NewEnd +" } if { [expr $NewStart - $End] == 7 } { incr DR6 puts $DR6f "DR6 $DR6 chr$chr $Start $NewEnd +" } set Start $NewStart set End $NewEnd } set Start 0 set End 0 set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : Parsing minus strand" foreach PaireDeBornes $ListeDesPositionsMoins { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 2 } { incr DR1 puts $DR1f "DR1 $DR1 chr$chr $Start $NewEnd -" } if { [expr $NewStart - $End] == 3 } { incr DR2 puts $DR2f "DR2 $DR2 chr$chr $Start $NewEnd -" } if { [expr $NewStart - $End] == 4 } { incr DR3 puts $DR3f "DR3 $DR3 chr$chr $Start $NewEnd -" } if { [expr $NewStart - $End] == 5 } { incr DR4 puts $DR4f "DR4 $DR4 chr$chr $Start $NewEnd -" } if { [expr $NewStart - $End] == 6 } { incr DR5 puts $DR5f "DR5 $DR5 chr$chr $Start $NewEnd -" } if { [expr $NewStart - $End] == 7 } { incr DR6 puts $DR6f "DR6 $DR6 chr$chr $Start $NewEnd -" } set Start $NewStart set End $NewEnd } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UNRREAL chr$chr/DR$type : End" close $DR1f close $DR2f close $DR3f close $DR4f close $DR5f close $DR6f } proc UT {X} { global UT if {[string length $X]==1} { set X [string toupper $X] } else { set X [string tolower $X] } if {$X=="ace"} { return "" } if { ! [info exists UT]} { set UT(ala) A set UT(glu) E set UT(gln) Q set UT(trp) W set UT(phe) F set UT(pha) F set UT(phb) f set UT(tyr) Y set UT(cys) C set UT(met) M set UT(ser) S set UT(lys) K set UT(ly1) k set UT(leu) L set UT(val) V set UT(ile) I set UT(asp) D set UT(thr) T set UT(his) H set UT(arg) R set UT(pro) P set UT(gly) G set UT(gla) J set UT(glb) j set UT(asn) N foreach {Y ValUT} [array get UT] { set UT($ValUT) $Y } set UT(csy) C set UT(asi) [set UT(asn)] set UT(aya) [set UT(ala)] set UT(cea) [set UT(cys)] set UT(cme) [set UT(cys)] set UT(cro) [set UT(ser)] set UT(csd) [set UT(cys)] set UT(css) [set UT(cys)] set UT(csw) [set UT(cys)] set UT(cxm) [set UT(met)] set UT(glh) [set UT(glu)] set UT(hic) [set UT(his)] set UT(hph) [set UT(phe)] set UT(kcx) [set UT(lys)] set UT(mho) [set UT(met)] set UT(mse) [set UT(met)] set UT(mso) [set UT(met)] set UT(nep) [set UT(his)] set UT(oas) [set UT(ser)] set UT(omt) [set UT(met)] set UT(pca) [set UT(gln)] set UT(sac) [set UT(ser)] set UT(tpo) [set UT(thr)] } if {[info exists UT($X)]} { return [set UT($X)] } if {[string length $X]==1} { return XXX } if {[string length $X]==3} { return x } return $X } proc UTRsansCDS {Organisme database} { set FichierDesRequetes [open "/genomics/link/STAF/fiches/Requetes-MNCEKiller.sql" "w"] set FichierDesResultats "/genomics/link/STAF/fiches/Resultats-MNCEKiller.result" puts $FichierDesRequetes "ID * DB UCSC" puts $FichierDesRequetes "WH SQLNATIVE select ExonCount, ExonStarts, ExonEnds, CdsStart, CdsEnd, Strand from ucsc$Organisme.$database where ExonCount >=1" puts $FichierDesRequetes "FM FLAT" puts $FichierDesRequetes "//" close $FichierDesRequetes set Tada [BirdFetch "/genomics/link/STAF/fiches/Requetes-MNCEKiller.sql" "$FichierDesResultats"] set FichierDesResultats [open "/genomics/link/STAF/fiches/Resultats-MNCEKiller.result" "r"] set I 0 set J 0 while { [gets $FichierDesResultats LigneResultat] >=0 } { if { [string range $LigneResultat 0 4] !="Query" } { ScanLaListe $LigneResultat ExonCount ExonStarts ExonEnds CdsStart CdsEnd Strand if { $Strand == "+" } { if { $ExonCount == 1 } { set DernierExonEnd [lindex [split $ExonEnds ","] [expr $ExonCount - 1]] } else { set DernierExonEnd [lindex [split $ExonEnds ","] [expr $ExonCount - 1]] } if { $CdsStart > $DernierExonEnd } { incr I } } if { $Strand == "-" } { set DernierExonEnd [lindex [split $ExonStarts ","] 0] if { $CdsEnd < $DernierExonEnd } { incr J } } } } Espionne "Resultat $I et $J" } proc UbiquitinProtHumanToMouse {} { set File "/genomics/link/FLD/Input/Ubiquitin-related_proteins.csv" set OnAttend 1 set total 0; set SsMgiId 0; set ParSwAcString 0; set ParSwSsString 0; set ParSwTrAcString 0; set ParSwTrSsString 0; set SsSw 0; set ParTrAcString 0; set ParTrSsString 0; set SsSwEtTr 0 set TousLesIdString {} foreach Line [LesLignesDuFichier $File] { Espionne "" if {$OnAttend} { set OnAttend 0; continue } incr total set HumanGeneId [lindex [split $Line ";"] 0] set HumanGeneId [string trim $HumanGeneId] set MgiId [MGIHGNC $HumanGeneId MgiId] Espionne "$HumanGeneId $MgiId" if {$MgiId==""} { incr SsMgiId Espionne "SsMgiId $SsMgiId" set NewLine "$Line" lappend LesNewLines $NewLine continue } set onaSw 0; set onaTrEMBL 0 set LesSw [MGISW $MgiId Sw "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt.rpt"] set LesSwTrEMBL [MGISW $MgiId Sw "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt_TrEMBL.rpt"] if {$LesSw!=""} { set onaSw 1 } if {$LesSwTrEMBL!=""} { set onaTrEMBL 1 } set LesSwFin {}; set LesIdString {} if {$onaSw} { Espionne "AcSw: $LesSw" foreach Sw [split $LesSw " "] { set IdString [ProtIDStringFromGn $Sw "10090"] Espionne "$Sw $IdString" if {$IdString!=""} {lappend LesIdString $IdString} } if {$LesIdString!={}} { incr ParSwAcString set LesIdString [lsort -unique $LesIdString] LConcat LesSwFin $LesSw # if {[llength $LesIdString]>1} { FaireLire "contradiction" } } else { incr ParSwSsString if {$onaTrEMBL} { Espionne "LesSwTrEMBL: $LesSwTrEMBL" foreach Tr [split $LesSwTrEMBL " "] { set IdString [ProtIDStringFromGn $Tr "10090"] Espionne "$Tr $IdString" if {$IdString!=""} {lappend LesIdString $IdString} } LConcat LesSwFin $LesSw LConcat LesSwFin $LesSwTrEMBL if {$LesIdString!={}} { incr ParSwTrAcString set LesIdString [lsort -unique $LesIdString] # if {[llength $LesIdString]>1} { FaireLire "contradiction" } } else { incr ParSwTrSsString } } } } else { incr SsSw Espionne "SsSw $SsSw" if {$onaTrEMBL} { Espionne "LesSwTrEMBL: $LesSwTrEMBL" foreach Tr [split $LesSwTrEMBL " "] { set IdString [ProtIDStringFromGn $Tr "10090"] Espionne "$Tr $IdString" if {$IdString!=""} {lappend LesIdString $IdString} } LConcat LesSwFin $LesSwTrEMBL if {$LesIdString!={}} { incr ParTrAcString set LesIdString [lsort -unique $LesIdString] # if {[llength $LesIdString]>1} { FaireLire "contradiction" } } else { incr ParTrSsString } } else { incr SsSwEtTr } } Espionne "Final $LesIdString" Espionne "LesSwFin $LesSwFin" set SwFin [join $LesSwFin "|"] if {$LesIdString!={}} { LConcat TousLesIdString $LesIdString set IdString [join $LesIdString "|"] } else { set IdString "" } set NewLine "$Line;$MgiId;$SwFin;$IdString" Espionne "NewLine $NewLine" lappend LesNewLines $NewLine } SauveLesLignes $LesNewLines dans "/genomics/link/FLD/Input/Ubiquitin-related_proteinsWithMouseId.csv" SauveLesLignes $TousLesIdString dans "/genomics/link/FLD/Input/UbiquitinMouseStringId" Espionne "total $total" Espionne "SsMgiId $SsMgiId" Espionne "SsSw $SsSw" Espionne "SsSwEtTr $SsSwEtTr" Espionne "ParSwAcString $ParSwAcString " Espionne "ParSwSsString $ParSwSsString" Espionne "ParSwTrAcString $ParSwTrAcString" Espionne "ParSwTrSsString $ParSwTrSsString" Espionne "ParTrAcString $ParTrAcString" Espionne "ParTrSsString $ParTrSsString" set SsIdString [expr $SsMgiId + $SsSwEtTr + $ParSwTrSsString + $ParTrSsString] Espionne "SsIdString $SsIdString" } proc UcscAssemblyNameOf {Espece} { set ValueofCol "Uu" if {[regexp -nocase "^Mus" $Espece]} {set ValueofCol "mm"} if {[regexp -nocase "^Rattus" $Espece]} {set ValueofCol "rn"} if {[regexp -nocase "^Homo" $Espece]} {set ValueofCol "hg"} if {[regexp -nocase "^Brachidanio" $Espece]} {set ValueofCol "danRer"} if {[regexp -nocase "^Danio" $Espece]} {set ValueofCol "danRer"} if {[regexp -nocase "^Drosophila" $Espece]} {set ValueofCol "dm"} if {[regexp -nocase "^Gallus" $Espece]} {set ValueofCol "galGal"} if {[regexp -nocase "^Caenorhabditis" $Espece]} {set ValueofCol "ce"} if {[regexp -nocase "^Xenopus" $Espece]} {set ValueofCol "xl"} if {$Espece=="mm"} {set ValueofCol "Mus musculus"} if {$Espece=="rn"} {set ValueofCol "Rattus norvegicus"} if {$Espece=="hg"} {set ValueofCol "Homo sapiens"} if {$Espece=="hs"} {set ValueofCol "Homo sapiens"} if {$Espece=="dr"} {set ValueofCol "Danio rerio"} if {$Espece=="dm"} {set ValueofCol "Drosophila melanogaster"} if {$Espece=="gg"} {set ValueofCol "Gallus gallus"} if {$Espece=="ce"} {set ValueofCol "Caenorhabditis elegans"} if {$Espece=="xl"} {set ValueofCol "Xenopus laevis"} return $ValueofCol } proc UltraMiner {LongueurDesMots {ASortir ""} {monofasta yes} {combinations no} {MaxSpacer 0} {framed no} {masked yes} {typeSequence genome}} { #Lance XignalMiner en mode genome sur tous les chromosomes , parse les resultats et upload dans mysql foreach I { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 "X" "Y"} { Espionne "" set FichierFasta "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200603/chr$I.fa" set indiceFichier "$I" XignalMiner $FichierFasta $indiceFichier $LongueurDesMots $ASortir $monofasta $combinations $MaxSpacer $framed $masked $typeSequence } XignalParser $LongueurDesMots "yes" } proc UnCanva {{LargeurMaxi ""} {HauteurMaxi ""} {LargeurVoulue ""} {HauteurVoulue ""} {GonfleAussiY ""} {Titre ""} {AvecMainLevee ""}} { if {$LargeurVoulue==""} { set LargeurVoulue 512 } if {$HauteurVoulue==""} { set HauteurVoulue [expr ($LargeurVoulue*3)/4] } if {$LargeurMaxi==""} { set LargeurMaxi 512 } if {$HauteurMaxi==""} { set HauteurMaxi [expr ($LargeurMaxi*3)/4] } if {$GonfleAussiY==""} { set GonfleAussiY "GonfleAussiY" } global ScrollRectangleOriginal IdScrollRectangle global CouleurDuFondDeUnCanva if { ! [info exists CouleurDuFondDeUnCanva]} { set CouleurDuFondDeUnCanva "white" } if {[regexp "MainLevee" $AvecMainLevee]} { set AvecMainLevee 1 } else { set AvecMainLevee 0 } if {$GonfleAussiY=="NoY"} { set GonfleY 1.0 set DegonfleY 1.0 } else { set GonfleY "gonfle" set DegonfleY "degonfle" } set w [NomDe canva] if {$Titre==""} { set Titre $w } catch {destroy $w} toplevel $w wm title $w $Titre wm iconname $w $Titre set CanvaScroMinX 0 set CanvaScroMinY 0 set CanvaScroMaxX $LargeurMaxi set CanvaScroMaxY $HauteurMaxi set K $w.canvas set ScroHor $w.hscroll set ScroVer $w.vscroll set KShSv $w.grid set Boutons $w.buttons frame $Boutons pack $Boutons -side bottom -fill x -pady 2m button $Boutons.dismiss -text "Dismiss" -background "red" -command "destroy $w" bind $Boutons.dismiss "MainLeveeSurUnCanva $K" bind $Boutons.dismiss "FaireLire \[$KShSv configure\]" pack $Boutons.dismiss -side left -expand 1 button $Boutons.postscript -text "Zoom/UnZoom/Reset\nPNG/Postscript/Print\nFull PNG/Postscript/Print" -background "yellow" if { ! [string equal -nocase "NoZoom" $GonfleAussiY]} { bind $Boutons.postscript <1> "Gonfle $w all gonfle $GonfleY" bind $Boutons.postscript <2> "Gonfle $w all degonfle $DegonfleY" bind $Boutons.postscript <3> "Gonfle $w all reset reset" } bind $Boutons.postscript "CanvaEnPNG $K Visible" bind $Boutons.postscript "CanvaEnPostscript $K Visible AskForFile" bind $Boutons.postscript "CanvaEnImpression $K Visible" bind $Boutons.postscript "CanvaEnPNG $K OnVeutTout" bind $Boutons.postscript "CanvaEnPostscript $K OnVeutTout AskForFile" bind $Boutons.postscript "CanvaEnImpression $K OnVeutTout" pack $Boutons.postscript -side left -expand 1 button $Boutons.jpg -text "Create Jpg file" -background "yellow" bind $Boutons.jpg <1> "CanvaEnJpg $K \[FichierPourSaveAs\]" pack $Boutons.jpg -side left -expand 1 frame $KShSv scrollbar $ScroHor -orient horiz -command "$K xview" scrollbar $ScroVer -command "$K yview" canvas $K -width $LargeurVoulue -height $HauteurVoulue $K configure -scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY] -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" -background $CouleurDuFondDeUnCanva set IdScrollRectangle($K) [$K create rect $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY -tags [list "Cadre"] -outline $CouleurDuFondDeUnCanva] set ScrollRectangleOriginal($K) "[$K coords [set IdScrollRectangle($K)]]" grid rowconfig $KShSv 0 -weight 1 -minsize 0 grid columnconfig $KShSv 0 -weight 1 -minsize 0 grid $K -in $KShSv -padx 1 -pady 1 -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $ScroVer -in $KShSv -padx 1 -pady 1 -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $ScroHor -in $KShSv -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew pack $KShSv -expand yes -fill both -padx 1 -pady 1 if {$AvecMainLevee} { MainLeveeSurUnCanva $K } return $K } proc UnCanvaDe {LargeurMaxi HauteurMaxi {LargeurVoulue 768} {HauteurVoulue 512} {Titre ""} {AvecMainLevee ""}} { Wup "Permet de cree une fenetre composee de 1 canvas, de une frame avec des boutons ..." set CouleurDuFondDeUnCanva "white" if {[regexp "MainLevee" $AvecMainLevee]} {set AvecMainLevee 1} else {set AvecMainLevee 0} set w [NomDe canva] if {$Titre==""} {set Titre $w} catch {destroy $w} toplevel $w wm title $w $Titre wm iconname $w $Titre set CanvaScroMinX 0 set CanvaScroMinY 0 set CanvaScroMaxX $LargeurMaxi set CanvaScroMaxY $HauteurMaxi set K $w.canvas set ScroHor $w.hscroll set ScroVer $w.vscroll set KShSv $w.grid set Boutons $w.buttons frame $Boutons pack $Boutons -side bottom -fill x -pady 2m button $Boutons.dismiss -text "Dismiss" -background "red" -command "eval \[wm protocol $w WM_DELETE_WINDOW\]" -padx 3 bind $Boutons.dismiss "MainLeveeSurUnCanva $K" pack $Boutons.dismiss -side left -expand 1 button $Boutons.zoom -text "Zoom In / Out\nZoom x In / Out\nZoom Reset all" -background "yellow" -padx 3 bind $Boutons.zoom <1> "zoom $K 1.25 1.25" bind $Boutons.zoom <2> "zoom $K 0.8 0.8" bind $Boutons.zoom "zoom $K 1.25 1.0" bind $Boutons.zoom "zoom $K 0.8 1.0" bind $Boutons.zoom "ResetZoom $K" #bind $Boutons.zoom "zoom $K 1.0 1.25" #bind $Boutons.zoom "zoom $K 1.0 0.8" pack $Boutons.zoom -side left -expand 1 frame $KShSv scrollbar $ScroHor -orient horiz -command "$K xview" scrollbar $ScroVer -command "$K yview" canvas $K -width $LargeurVoulue -height $HauteurVoulue $K configure -scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY] -xscrollcommand "$ScroHor set" -yscrollcommand "$ScroVer set" grid rowconfig $KShSv 0 -weight 1 -minsize 0 grid columnconfig $KShSv 0 -weight 1 -minsize 0 grid $K -in $KShSv -padx 1 -pady 1 -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $ScroVer -in $KShSv -padx 1 -pady 1 -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $ScroHor -in $KShSv -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew pack $KShSv -expand yes -fill both -padx 1 -pady 1 if {$AvecMainLevee} {MainLeveeSurUnCanva $K} wm protocol $w WM_DELETE_WINDOW "after 10 destroy $w" return $K } proc UnOligoDePlusPour {P TFA} { set FiSeqOl [FiSeqOl $P] set Rep [file dirname $FiSeqOl] if { ! [file exists $Rep]} { file mkdir $Rep } if { ! [file exists $FiSeqOl]} { return [Sauve $TFA dans $FiSeqOl] } set LL [LesLignesDuFichier $FiSeqOl] set OldEntete [lindex $LL 0] set OldSeq [join [lrange $LL 1 end] ""] set OldPSig [join [lrange [split $OldEntete " "] 0 6] " "] set AA [split $TFA "\n"] set NewEntete [lindex $AA 0] set NewSeq [join [lrange $AA 1 end] ""] set NewPSig [join [lrange [split $NewEntete " "] 0 6] " "] if { ! [string equal -nocase $OldSeq $NewSeq]} { FaireLire "Different oligo sequences for $P\n$OldSeq\n$NewSeq\n I'll keep the first one." } if { ! [string equal -nocase $OldPSig $NewPSig]} { FaireLire "Different oligo signal header for $P\n$OldPSig\n$NewPSig\n I'll keep the first one." } set NouvelleEntete "$OldEntete [lindex [split $NewEntete " "] end]" set NewLL [lreplace $LL 0 0 $NouvelleEntete] return [SauveLesLignes $NewLL dans $FiSeqOl] } proc UnOligoPourExcel_GUI {K PAB} { Wup "Permet de sauver les oligos selectionnes dans le format excel" Wup "Rq les oligos sont ceux choisis dans l interface et pour le seul PAB affiche" #Choix du fichier de sauvegarde while {1} { set Texte "Choose a file name to save your selection" FaireLire "$Texte" set FichierSave [tk_getSaveFile -title "Choose a file name to save" -initialdir "[RepertoireDuGenome]"] if {$FichierSave == ""} { if {! [OuiOuNon "Would you like to continue ?"]} {return ""} } else { break } } #Choix des Oligos a sauver set Answer "" set LesNomsOligos "" while {1} { set Texte "Please choose with Control+1 the oligo(s) to save under file:" set Answer [FaireSavoir $Texte "Saving File - Waiting your selection."] set LesNomsOligos [LesOligosSelectionnes $K LesIds] if {$LesNomsOligos==""} { if {! [OuiOuNon "No Oligo selected !\nWould you like to retry ?"]} {break} else {continue} } else {break} } if {[OuiOuNon "Would you like to save the header one time in your file ?"]} { set AvecEntete "AvecEntete" } else {set AvecEntete "SansEntete"} set Dir "" set Dir2 "" set FirstTime 0 foreach Id $LesNomsOligos { set MesTags [$K gettags $Id] set NomOligo [lindex $MesTags 4] set Dir [lindex $MesTags 5] set Dir2 "" set Fichier "$Dir/${PAB}.oligo" if { ! [file exists $Fichier]} { set Fichier "$Dir/$PAB" if {! [file exists $Fichier]} {return ""} } #Deuxieme resultat de design si il y a eu une selection croisee if {[file exists "$Dir/$PAB.croisee"]} { if {[info exists TabDirCroiseeDe($Dir)]} { set Question "You previously defined a crossed directory for $Dir\n Should I always use it ?" if {[OuiOuNonMemo $Question]} { set Dir2 [set TabDirCroiseeDe($Dir)] } else { set Dir2 "" unset TabDirCroiseeDe($Dir) } } set Essai "[lindex [LesInfosDe $K MesDirs] end]" if {$Dir2==""} { while {1} { set Texte "Some crossed results exists for your sequence between \nthis design ($Dir) and another ! \nCould you give me the other directory containing these results ?" if {[OuiOuNon "$Texte"]} { while {1} { if {$Essai!="" && [OuiOuNon "Shall we use $Essai ?"]} { set Dir2 "$Essai" } else { set T "Choose the other directory" set Dir2 [tk_chooseDirectory -title $T -initialdir "[RepertoireDuGenome]"] } if {$Dir2 == ""} { if {! [OuiOuNon "Would you like to reselect ?"]} {continue} } break } break } else {break} } } } if {! [info exists TabDirCroiseeDe($Dir)] && $Dir2!=""} {set TabDirCroiseeDe($Dir) $Dir2} set D [InterrogeInfoDeLOligo $Fichier $NomOligo Debut] set F [InterrogeInfoDeLOligo $Fichier $NomOligo Fin] incr FirstTime if {$FirstTime!="1"} {set AvecEntete "SansEntete"} LesOligosPourExcel $PAB $Dir $Dir2 "$D $F" $FichierSave $AvecEntete } if {[info exists TabDirCroiseeDe]} {unset TabDirCroiseeDe} OuiOuNonMemo UnsetAllPlease return "" } proc UnPetitNomPourNosPdbs {} { set Fichier "[RepXbgs]/PdbOfNuclearReceptorsIGBMC.list" set OldAlias "" foreach Ligne [LesLignesDuFichier $Fichier] { set Alias "" scan $Ligne "%s %s" aPDB Alias if {$Alias==""} { set Alias $OldAlias } set TextePDB [TextePDB $aPDB] if {$TextePDB==""} { continue } set Id [AfficheVariable $TextePDB] update idletask set NewAlias [Entre $Alias] set OldAlias $NewAlias lappend LesBons "$aPDB $NewAlias" destroy $Id } SauveLesLignes $LesBons dans $Fichier return $LesBons } proc UnSeulGetz {Texte} { set Prem [string first "\n//" $Texte] set Dern [string last "\n//" $Texte] if {$Prem==$Dern} { return $Texte } set AvDe [string last "\n//" $Texte [incr Dern -3]] return "[string range $Texte [incr AvDe 3] end]" } proc UnSubjectDuBlast {FichierBlast BanqueId Access} { if {![file exists $FichierBlast]} { Espionne "$FichierBlast does not exist" return "" } set Query "$BanqueId | $Access" set Subject "" set SuisJeSurMonSubject 0 set F [open $FichierBlast] while {[gets $F Ligne]>=0} { if {$Subject != "" && !$SuisJeSurMonSubject} {break} if {[regexp "^>\[0-9]" $Ligne]} {continue} if {![regexp -nocase {[a-z]} $Ligne ]} {continue} while {[regexp " " $Ligne]} {regsub " " $Ligne " " Ligne} while {[regexp "^ " $Ligne]} {regsub "^ " $Ligne "" Ligne} if {[regexp "^>" $Ligne] && [regexp -nocase "$Query" $Ligne]} { set SuisJeSurMonSubject 1 regsub "\n" $Ligne "" Ligne append Subject $Ligne } if {[regexp -nocase "Query: " $Ligne]} { set SuisJeSurMonSubject 0 } if {![regexp "^>" $Ligne] && $SuisJeSurMonSubject } { regsub "\n" $Ligne "" Ligne append Subject " $Ligne" } } close $F set Subject [string trim $Subject] while {[regexp " " $Subject]} {regsub -all " " $Subject " " Subject} return $Subject } proc UnderLine_WordML {} { return "" } proc UneCouleurPourMainLevee {{CouleurParDefaut ""}} { global CouleurDuFond global LesCouleursPourMainLevee set CouleurParDefautParDefaut "grey" if { ! [info exists LesCouleursPourMainLevee]} { if {[info exists CouleurDuFond]} { set CdF $CouleurDuFond } else { set CdF "white" } set LesCouleursPourMainLevee [list "black" "grey" "white" "blue" "lightblue" "yellow" "green" "orange" "red" "purple" $CdF "-Transparent-" "-NewColor-" "-Default-"] } if {$CouleurParDefaut=="LaListe"} { return $LesCouleursPourMainLevee } if {$CouleurParDefaut==""} { set CouleurParDefaut $CouleurParDefautParDefaut } foreach C $LesCouleursPourMainLevee { if {$C=="-Default-"} { set C $CouleurParDefaut } if {[regexp {^\-} $C]} { set C "grey" } lappend LesCouleursColorees $C } set Couleur [ChoixParmi $LesCouleursPourMainLevee $LesCouleursColorees] if {$Couleur == ""} { return "Cancel" } if {$Couleur == "-Transparent-"} { return "" } if {$Couleur == "-Default-"} { return $CouleurParDefaut } if {$Couleur == "-NewColor-"} { set Couleur [PaletteDeCouleurs] if {$Couleur == ""} { return "" } lappend LesCouleursPourMainLevee $Couleur return $Couleur } return $Couleur } proc UneNouvelleSequencePourGscope {{Nouveau ""} {Maniere ""}} { if {$Maniere==""} { set Maniere "Ask" } if {$Nouveau==""} { # if { ! [OuiOuNon "Do You want to add a new sequence to the GscopeDatabase ?"]} { return "" } FaireLire "Please enter the sequence or its access or its file name ..." } set Seq [SeqIn $Nouveau] set Format [FormatDeLaSequence $Seq] set EMBL "" if {[regexp "embl" $Format]} { set EMBL $Seq if {$Maniere!="Auto"} { AfficheVariable $EMBL "AvecChangeFormat" "Your sequence in EMBL format" } } set TFA [SequenceFormatTFA $Seq "" $Format] if {$Maniere!="Auto"} { while 1 { FaireLire "Please verify (and/or edit) the TFA sequence" set BonTFA [EntreTexte $TFA] if {$BonTFA!=""} { set TFA $BonTFA ; break } if {[OuiOuNon "Do you want to edit it again ?"]} { continue } if { ! [OuiOuNon "Do we cancel ?"]} { return "" } return [UneNouvelleSequencePourGscope $Nouveau] } while {$EMBL!=""} { set SeqTFA [QueLaSequenceDuTexteTFA $TFA] set SeqEMBL [QueLaSequenceDuTexteEMBL $EMBL] if {[string equal -nocase $SeqTFA $SeqEMBL]} { break } if {[OuiOuNon "The original EMBL sequence doesn't correspond to the TFA sequence.\n Do I forget the original EMBL sequence ?"]} { set EMBL "" ; break } if {[OuiOuNon "The original EMBL sequence doesn't correspond to the TFA sequence.\n Do we cancel UneNouvelleSequencePourGscope ?"]} { return "" } } } if {[regexp -nocase "P" [NucOuProt $TFA]]} { set NucOuProt "prot" } else { set NucOuProt "nuc" } set ExisteDeja [EstCeVraimentUneNouvelleSequence $TFA $NucOuProt] set LongS [string length [QueLaSequenceDuTexteTFA $TFA]] if {[regexp -nocase "P" $NucOuProt]} { set LongN [expr $LongS*3] } else { set LongN $LongS } set Dernier [DernierPAB "EnNumero"] regsub -all -nocase {[A-Z_]} $Dernier "" Numero set N [Base10 $Numero] incr N set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $N] if {$Maniere!="Auto"} { while 1 { set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $N] if {[OuiOuNon "Do I use $NouveauNom ?"]} { break } set NouveauNom [Entre $NouveauNom] if {$NouveauNom!=""} { break } } } set AncienNom [Box $NouveauNom nom] set AncienDeb [Box $NouveauNom debut] set AncienFin [Box $NouveauNom fin] set AncienOri [Box $NouveauNom orient] if {$AncienNom!=""} { set Nom $AncienNom set Debut $AncienDeb set Fin $AncienFin set Orient $AncienOri } else { set DernierPosition [DernierPAB "EnPosition"] set FinActuelle [Box $DernierPosition fin] set Nom $NouveauNom set Debut [expr $FinActuelle +100] set Fin [expr $Debut + $LongN] set Orient "F" } set Borne "$Nom $Debut $Fin $Orient" if {$Maniere!="Auto"} { while { ! [OuiOuNon "Ok to use $Borne ?"]} { set NouvelleBorne [Entre $Borne] if {$NouvelleBorne==""} { continue } set Borne $NouvellesBorne } } scan $Borne "%s %d %d %s" Nom Debut Fin Orient MiseAJourBornesDesPABs $Borne set LesExistants [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] if {$Maniere!="Auto"} { if {$LesExistants!={}} { FaireLire "Please select the OLD files I have to delete" set LesEffacables [MorceauxChoisis $LesExistants] foreach Effacables $LesEffacables { file delete $Effacables } } } set FichierTFA "[RepertoireDuGenome]/${NucOuProt}tfa/$Nom" if { $Maniere=="Auto" || ! [file exists $FichierTFA] || [OuiOuNon "Ok to overwrite $FichierTFA ?"]} { set Rep "[RepertoireDuGenome]/${NucOuProt}tfa" if { ! [file exists $Rep]} { file mkdir $Rep } Sauve $TFA dans $FichierTFA } if {$EMBL!=""} { set Rep "[RepertoireDuGenome]/${NucOuProt}embl" if { ! [file exists $Rep]} { file mkdir $Rep } set FichierEMBL "$Rep/$Nom" if { $Maniere=="Auto" || ! [file exists $FichierEMBL] || [OuiOuNon "Ok to overwrite $FichierEMBL ?"]} { Sauve $EMBL dans $FichierEMBL } } return "$Nom $Debut $Fin $Orient" } proc UneSequenceDuMSF {FichierMSF NomDeLaSequence {NoGap ""}} { if {[DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]==0} { return "" } if { ! [info exists Sequences($NomDeLaSequence)]} { return "" } set Seq $Sequences($NomDeLaSequence) if {[regexp -nocase "NoGap" $NoGap]} { regsub -all {[\.\-]} $Seq "" Seq } return $Seq } proc UneTaillePourMainLevee {{TailleParDefaut ""}} { global LesTaillesPourMainLevee JeMeSignale set TailleParDefautParDefaut 1.1 if { ! [info exists LesTaillesPourMainLevee] } { set LesTaillesPourMainLevee [list 0.1 0.5 0.9 1.0 1.1 2.0 10. -1 "Other" "Default"] } if {$TailleParDefaut=="LaListe"} { return $LesTaillesPourMainLevee } if {$TailleParDefaut==""} { set TailleParDefaut $TailleParDefautParDefaut } set Taille [ChoixParmi $LesTaillesPourMainLevee] if {$Taille == ""} { return "" } if {$Taille == "Default"} { return $TailleParDefaut } if {$Taille == "Other"} { set Taille [Entre $TailleParDefaut] if {$Taille == ""} { return "" } lappend LesTaillesPourMainLevee $Taille return $Taille } return $Taille } proc UniProtProteome {{pref 0}} { # Taxonomy identifier of top node for query, e.g. 2 for Bacteria, 2157 for Archea, etc. # (see http://www.uniprot.org/taxonomy) set top_node 131567 # Toggle this to 1 if you want reference instead of complete proteomes. set reference $pref set proteome [expr {$reference ? "reference:yes" : "complete:yes"}] set keyword [expr {$reference ? "keyword:1185" : "keyword:181"}] # Get a list of all taxons below the top node with a complete/reference proteome. set url "http://www.uniprot.org/taxonomy/?query=ancestor:$top_node+$proteome&format=list" set response_list [split [HttpCopy $url] \n] set Lout [list] foreach id $response_list { if {[string trim $id] ne ""} { lappend Lout $id } } return $Lout } proc UniprotHistory {{Qui ""} {Quoi ""}} { #rR on rend la référence ou l'historique de Id ou Ac #rR uniprot ne rend que le premier si on lui fournit l'id, mais il rend l'historique avec ac if {$Quoi==""} { set Quoi "History" } set Access [string toupper $Qui] set Url "http://www.uniprot.org/uniprot/$Access.txt?version=*" set LesTFAs [LesLignesDuFichier $Url] set IdReference "" set IdHistory {} set AcReference "" set AcHistory {} set IdAcReference "" set HistoryOfId {} set HistoryOfAc {} foreach Ligne $LesTFAs { if {[regexp {ID ([^ ]+)} $Ligne Match IDLu]} { if {$IDLu!=""} { if {$IdReference==""} { set IdReference $IDLu } lappend IdHistory $IDLu lappend HistoryOfId $IDLu } } if {[regexp {AC (.+)} $Ligne Match ACsLus]} { set ACs $ACsLus regsub -all {[ ;]+} $ACs " " ACs set LesACs [split [string trim $ACs] " "] if {$LesACs!={}} { lappend HistoryOfAc $ACsLus if {$AcReference==""} { set AcReference [lindex $LesACs 0] if {$AcReference!=$Qui} { return [UniprotHistory $AcReference $Quoi] } } foreach AC $LesACs { lappend AcHistory $AC } } } } set IdHistory [ListeSansDoublon $IdHistory] set AcHistory [ListeSansDoublon $AcHistory] set IdAcReference "$IdReference $AcReference" if {[regexp -nocase "^IdAcR" $Quoi]} { set Quoi "IdAcReference" } if {[regexp -nocase "^IdR" $Quoi]} { set Quoi "IdReference" } if {[regexp -nocase "^IdH" $Quoi]} { set Quoi "IdHistory" } if {[regexp -nocase "^AcR" $Quoi]} { set Quoi "AcReference" } if {[regexp -nocase "^AcH" $Quoi]} { set Quoi "AcHistory" } if {[info exists $Quoi]} { return [set $Quoi] } if {[regexp -nocase "^H" $Quoi]} { set LeHis {} foreach A $HistoryOfAc I $HistoryOfId { lappend LeHis "$I\t$A" } set LeHis [ListeSansDoublon $LeHis] return $LeHis } return "" } proc UniprotToCoord {Rep} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Start" set FichierIn [open "$Rep/EpouvanBlastEnriched.csv" "r"] set FichierOut [open "$Rep/ProtaccToCoord.csv" "w"] set FichierDesRequetes [open "/tmp/ProtaccToCoord.bql" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Building SP queries" set CompteurLus 0 while { [gets $FichierIn Ligne] >=0 } { ScanLaListe $Ligne numero NP XP Acc Organism Expect incr CompteurLus puts $FichierDesRequetes "ID $Acc DB UNIPROT" puts $FichierDesRequetes "FD DR" puts $FichierDesRequetes "LM 1" puts $FichierDesRequetes "//" } close $FichierDesRequetes close $FichierIn set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Executing SP queries" exec /biolo/bird/bin/birdql_client.sh /tmp/ProtaccToCoord.bql bird /tmp/ProtaccToCoord.res set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Parsing SP queries" set FichierDesRequetesExecutees [open "/tmp/ProtaccToCoord.res" "r"] set FichierDesRequetes2 [open "/tmp/ProtaccToCoord.bql2" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Building RS queries" set Written "no" set CompteurRsEcrits 0 set CompteurRsVidesEcrits 0 set Uniprot 0 while { [gets $FichierDesRequetesExecutees Ligne] >=0 } { if { [regexp -nocase $Ligne]} { incr Uniprot } if { [regexp -nocase {RefSeq} $Ligne] && [regexp {DR} $Ligne] && $Written == "no"} { incr CompteurRsEcrits set RefSeq [string trim [lindex [split [lindex [split $Ligne ";"] 1] "."] 0]] puts $FichierDesRequetes2 "AC $RefSeq DB REFSEQ" #puts $FichierDesRequetes2 "FD DBSOURCE" puts $FichierDesRequetes2 "LM 1" puts $FichierDesRequetes2 "//" set Written "yes" } if { [string range $Ligne 0 1] == "//" } { if {$Written == "no"} { incr CompteurRsVidesEcrits puts $FichierDesRequetes2 "ID IMPOSSIBLE DB REFSEQP" #puts $FichierDesRequetes2 "FD DBSOURCE" puts $FichierDesRequetes2 "LM 1" puts $FichierDesRequetes2 "//" } set Written "no" } } Espionne "$CompteurRsEcrits refseq ($Uniprot fiches)" close $FichierDesRequetes2 close $FichierDesRequetesExecutees Espionne "$timestamp|ProtaccToCoord : Executing RS queries" exec /biolo/bird/bin/birdql_client.sh /tmp/ProtaccToCoord.bql2 bird /tmp/ProtaccToCoord.res2 set FichierDesRequetesExecutees2 [open "/tmp/ProtaccToCoord.res2" "r"] set FichierDesRequetes3 [open "/tmp/ProtaccToCoord.bql3" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Building RG queries" set CompteurRgEcrits 0 while { [gets $FichierDesRequetesExecutees2 Ligne2] >=0 } { if { [regexp -nocase {DBSOURCE} $Ligne2] && [regexp -nocase {REFSEQ} $Ligne2]} { incr CompteurRgEcrits set NM [string trim [lindex [split $Ligne2 ":"] 1]] set NM [string trim [lindex [split $NM " "] 1]] set NM [string trim [lindex [split $NM "."] 0]] puts $FichierDesRequetes3 "ID * DB UCSC" puts $FichierDesRequetes3 "WH SQLNATIVE SELECT chrom, txStart, txEnd FROM ucschuman.refGene WHERE name='$NM'" puts $FichierDesRequetes3 "LM 1" puts $FichierDesRequetes3 "//" } } close $FichierDesRequetes3 close $FichierDesRequetesExecutees2 set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Executing RG queries" exec /biolo/bird/bin/birdql_client.sh /tmp/ProtaccToCoord.bql3 bird /tmp/ProtaccToCoord.res3 set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : Parsing RG queries" set CompteurTotalEcrit 0 set FichierDesRequetesExecutees3 [open "/tmp/ProtaccToCoord.res3" "r"] set FichierIn [open "$Rep/EpouvanBlast.csv" "r"] while { [gets $FichierDesRequetesExecutees3 Ligne3] >=0 } { incr CompteurTotalEcrit gets $FichierDesRequetesExecutees3 Ligne3 gets $FichierIn Ligne4 puts $FichierOut "$Ligne4 $Ligne3" } close $FichierDesRequetesExecutees3 close $FichierOut close $FichierIn set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ProtaccToCoord : End" Espionne "$timestamp|ProtaccToCoord : Read = $CompteurLus" Espionne "$timestamp|ProtaccToCoord : Uniprot found = $CompteurRsEcrits ($CompteurRsVidesEcrits unfound)" Espionne "$timestamp|ProtaccToCoord : Refseq Xref found = $CompteurRgEcrits" Espionne "$timestamp|ProtaccToCoord : Written = $CompteurTotalEcrit" } proc UnixFileName {Banque} { global DirectoryNames DirLogNames CompleteFileNames if {[info exists DirectoryNames]} { if {[info exists CompleteFileNames([string toupper $Banque])]} { return [set CompleteFileNames([string toupper $Banque])] } else { return $Banque } } set OnAttendPP 1 foreach Ligne [LesLignesDuFichier "/gcg/gcg/gcgdbconfigure/dblogicals"] { if {$OnAttendPP && ! [regexp {\.\. *$} $Ligne]} { continue } if {$OnAttendPP && [regexp {\.\. *$} $Ligne]} { set OnAttendPP 0 ; continue } if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } scan $Ligne "%s %s" DirLogName Directory set DirectoryNames([string toupper $DirLogName]) $Directory set DirLogNames([string toupper $Directory]) $DirLogName } set OnAttendPP 1 foreach Ligne [LesLignesDuFichier "/gcg/gcg/gcgdbconfigure/dbnames.map"] { if {$OnAttendPP && ! [regexp {\.\. *$} $Ligne]} { continue } if {$OnAttendPP && [regexp {\.\. *$} $Ligne]} { set OnAttendPP 0 ; continue } if { [regexp -nocase { *\!} $Ligne]} { continue } if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } scan $Ligne "%s %s %s %s" FlatFileName DirLogName LibLogName ShortLogName set Directory [set DirectoryNames([string toupper $DirLogName])] foreach Ext [list gbk dat seq ""] { set CompleteFileName "$Directory/$FlatFileName.$Ext" if {[file exists $CompleteFileName]} { break } } set CompleteFileNames([string toupper $ShortLogName]) $CompleteFileName } return [UnixFileName $Banque] } proc Unknown {} { foreach Nom [ListeDesPABs] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set GO [InterrogeFichierFinal $Nom GO] set Pathway [InterrogeFichierFinal $Nom Pathway] set PFAM [InterrogeFichierFinal $Nom PFAM] if {$GO=="" && $Pathway=="" && $PFAM==""} {lappend Liste $Nom} } Espionne [llength $Liste] Espionne $Liste } proc Unknown2 {} { foreach Nom [ListeDesPABs] { if {![file exists "[RepertoireDuGenome]/prottfa/$Nom"]} {continue} set GO [InterrogeFichierFinal $Nom GO] set Pathway [InterrogeFichierFinal $Nom Pathway] set PFAM [InterrogeFichierFinal $Nom PFAM] if {$GO=="" && $Pathway=="" && $PFAM==""} { #lappend Liste $Nom set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} { set DefinitionProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition] if {[regexp -nocase "HYPOTHETICAL" $DefinitionProtHuman] || [regexp -nocase "PREDICTED" $DefinitionProtHuman] || [regexp -nocase "SIMILAR TO" $DefinitionProtHuman] || [regexp -nocase "KIAA" $DefinitionProtHuman] || [regexp -nocase "DKFZp" $DefinitionProtHuman] || [regexp -nocase "FLJ" $DefinitionProtHuman] || [regexp -nocase "PUTATIVE" $DefinitionProtHuman]} { #Espionne $DefinitionProtHuman #lappend LpourAffy $AccBestProtHuman lappend Liste $Nom } } } } Espionne [llength $Liste] } proc UnsetLesTableauxDesGraphAvecBlast {} { Wup "Permet de supprimer les tableaux en memoire des profils du blast pour faire Id et NbSeq" global ProfilBlast if {[array exists ProfilBlast]} {array unset ProfilBlast} return "" } proc UpDownCommeIlFaut {aUpDown aJoinCar aRecordsJoinCar {aListJoinCar ""}} { upvar $aUpDown UpDown upvar $aJoinCar JoinCar upvar $aRecordsJoinCar RecordsJoinCar if {$aListJoinCar!=""} { upvar $aListJoinCar ListJoinCar } else { set ListJoinCar "" } set L [list $JoinCar $RecordsJoinCar $ListJoinCar $UpDown] set I 0 foreach E $L { if {[EstUpDown $E]} { break } incr I } if {$I >= [expr [llength $L]-1]} { foreach Car [list JoinCar RecordsJoinCar ListJoinCar] { if {[set $Car]=="nl"} { set $Car "\n" } if {[set $Car]=="tab"} { set $Car "\t" } } return } set N [lreplace $L $I $I] lappend N [lindex $L $I] lassign $N JoinCar RecordsJoinCar ListJoinCar UpDown foreach Car [list JoinCar RecordsJoinCar ListJoinCar] { if {[set $Car]=="nl"} { set $Car "\n" } if {[set $Car]=="tab"} { set $Car "\t" } } return } proc Update3DMatrices {} { global pgl Rad set ratX $pgl(ratioX) set ratY $pgl(ratioY) set zoom $pgl(Zoom) set frontclip $pgl(frontclip) set backclip $pgl(backclip) glMatrixMode GL_PROJECTION glLoadIdentity glOrtho [expr {-$ratX*$zoom*($Rad+$pgl(xTra))}] [expr { $ratX*$zoom*($Rad-$pgl(xTra))}] [expr {-$ratY*$zoom*($Rad+$pgl(yTra))}] [expr { $ratY*$zoom*($Rad-$pgl(yTra))}] [expr {$pgl(backclip) }] [expr {$pgl(frontclip)}] glMatrixMode GL_MODELVIEW glLoadIdentity $pgl(wogl) postredisplay return } proc UpdateAgentsOfSeq {n} { global TAg Sequences MotifLen set s $Sequences($n) set lgt [string length $s] set Lag [list] set nchar 0 set iDep 0 ; set iFin -1 set iAg 0 set step [expr {$MotifLen - 1}] if {0} { for {set i 0} {$i < ($lgt-$step)} {incr i} { set mot [string range $s $i $i+$step] set dgmot [string map {. ""} $mot] if {$dgmot eq $mot} { lappend Lag [list $n $iAg 1 $i [expr {$i+$step}]] incr iAg } } } if {1} { for {set i 0} {$i < $lgt} {incr i} { set ai [string index $s $i] set isChar [expr {$ai ne "."}] incr nchar $isChar if {$isChar} { if {$nchar == 1} { set iDep $i } if {$i != ($lgt-1)} { continue } } # gap suit un gap if {$nchar == 0} { continue } # on peut etre au dernier aa de seq # (i= lgt-1) # ou bien # on a un gap qui sequence if {$isChar} { incr i } if {0 && $n eq "S03"} { puts "iDep $iDep" puts "i= $i" puts "lgt $lgt" } if {($i-$iDep) < $MotifLen} { set nchar 0 set iDep $i continue } set AgActif 1 # cree agents for {set j $iDep} {$j <= ($i-$MotifLen)} {incr j} { # cree agent lappend Lag [list $n $iAg 1 $j [expr {$j+$MotifLen-1}]] incr iAg } set iDep $i set nchar 0 } } CreateAgents $Lag return [llength $Lag] } proc UpdateDBSeqInfo {} { global db TDesAccess TDesSeqnames TDesBId global LNOrdali foreach n $LNOrdali { set pk [$db eval {select pk_seqinfo from seqinfo where seqname=$n}] $db eval "update seqinfo set seqmane='$n', access='[set TDesAccess($n)]', bid='[set TDesBId($n)]' where pk_seqinfo=$pk" } return } proc UpdateDessinRasmol {{n1 ""} {n2 ""} {op ""}} { global LFCO global LFeatCourantes global RasM set Fc [lor $LFCO $LFeatCourantes] foreach e [set RasM(LMols)] { lassign $e m i DessineFeatureDansRasmol $m $i "" $Fc } return } proc UpdateGUI {} { if {! $::WithGUI} {return} .t delete 1.0 end .t tag remove Col 1.0 end .t tag remove Spy 1.0 end set Ltxt [list] foreach n $::LNOrdali { lappend Ltxt $::Sequences($n) } .t insert end [join $Ltxt \n] #.t tag configure Spy -foreground white -background "#DD0000" .t tag configure Spy -foreground black -background "#aaaaaa" .t tag configure Col -foreground white -background "#0000DD" FenetreAuCentre [winfo toplevel .t] update idletasks return } proc UpdateInfosDesSeqs {} { global {*}[info globals "TD*"] LNOrdali Sequences LSOrdali ListePDB if {[QuelMode] ne "ordali" && [QuelMode] ne "feature"} { return } # create co-list seqname-access set Luni [list] ; set Lnun [list] set Lref [list] ; set Lnrf [list] set Lgi [list] ; set Lngi [list] foreach n $LNOrdali { if {$n eq "" || $n in $ListePDB} { continue } set bid [set TDesBId($n)] if {[EstUnUniProt $bid]} { lappaend Lnun $n # In Uniprot, Access is not moving lappend Luni [set TDesAccess($n)] } elseif {[EstUnRefseq $bid]} { lappend Lnrf $n lappend Lref $bid } elseif {[EstUnGI $bid]} { lappend Lngi $n lappend Lgi $bid } } # first : Check UniProt ID haven't change set Lnew [ConvertUniProt2UniProtAcc $Luni] foreach u $Luni n $Lnew { if {$u ne $n} { puts "old $u new $n" } } array set T {} # infos from uniprot if {$Luni != {}} { array set T [InfosFromUniProt $Luni] } # change GI to refseq ID if {$Lgi != {}} { set Lchn [ConvertGI2RefSeq $Lgi] foreach g $Lgi c $Lchn n $Lngi { # not found if {$g eq $c} {continue} # add as refseq ID lappend Lref $c lappend Lnrf $n } } # get refseq infos if {$Lref != {}} { array set T [InfosFromRefSeq $Lref] } if {[llength [array names T]] == 0} { puts "\nNothing updated ..." puts "array names T 0" puts "\nLuniprot [join $Luni \n]" puts "\nLrefseq [join $Lref \n]" return } # make summary of changes set Lsqn [concat $Lnun $Lnrf] set Lid [concat $Luni $Lref] array set Chg [list] if {[TypeAli] eq "XML" || [TypeAli] eq "ORD"} { foreach sqn $Lsqn id $Lid { if {! [info exists T($id,Desc)]} { continue } # check AC if {$TDesAccess($sqn) ne $sqn && $TDesAccess($sqn) ne $T($id,currAC)} { set Chg($sqn,AC) [list $TDesAccess($sqn) $T($id,currAC)] } # check ID if {$TDesBId($sqn) ne $sqn && $TDesBId($sqn) ne $id} { set Chg($sqn,BId) [list $TDesBId($sqn) $id] } # check all other data foreach t {TDesDescriptifs TDesTaxId TDuLineage TDesOrganismes TDesPhylum TDesAccess} k {Desc TaxId Lineage Organism Phylum currAC} { if {[set ${t}($sqn)] ne "" && [set ${t}($sqn)] ne [set T($id,$k)]} { set Chg($sqn,$k) [list [set ${t}($sqn)] [set T($id,$k)]] } } } } # Now update the different tables foreach sqn $Lsqn id $Lid { if {! [info exists T($id,Desc)]} { continue } foreach t {TDesDescriptifs TDesTaxId TDuLineage TDesOrganismes TDesPhylum TDesAccess} k {Desc TaxId Lineage Organism Phylum currAC} { set ${t}($sqn) [set T($id,$k)] } } LogChangesDuringInfoUpdate [array get Chg] return } proc UpdateKoAnnoMsf {NomMsf} { set RepParent "[OnGoingDir]/$NomMsf" set FichierMsf "$RepParent/$NomMsf.msf" set FichierXml "$RepParent/$NomMsf.xml" set FichierXml [CreeXmlAnnotePourUnMsf $FichierMsf $RepParent] if {$FichierXml==""} { return "Sorry,but something went wrong. I didn't get a result." } set Query "HtmlFromXmlMacsim&$FichierXml" set Url "[WscopeScience]&$Query" return [HttpCopy $Url] } proc UpdateLeFichierLog {Log1 {Log2 ""}} { Wup "Mise a jour des fichiers log de la veille version a la nouvelle version" set Fichier1 $Log1 if {$Log2==""} { set FichierNew "$Log1.tmp" } else { set FichierNew "$Log2" } if {![file exists $Fichier1]||[file exists $FichierNew]} {Espionne "Dejafait $FichierNew";return ""} set LesLignes [LesLignesDuFichier $Fichier1] if {[regexp "Moving on:" $LesLignes]} { Espionne "[file tail $Log1] celui la est deja au format" return "" } set LesTrucsARemplacer [list "Length Query" "Query Length :" "Requested" "Oligo Requested:" "On se balade :" "Moving on:" "Ongarde" "Spec: We keep TOOMUCHIDENTICAL" "On garde" "Spec: We keep" "On vire" "Spec: We left" "\tOn en garde" ">>>\tWe keep" "On en vire" "We left" "On a vu des PROHIBES" "Prohibited: PROHIBES"] foreach {Replace Quoi} $LesTrucsARemplacer { regsub -all $Replace $LesLignes $Quoi LesLignes } set Sequence 0 set Prohib 0 set GC 0 set Tm 0 set Spec 0 set Spec2 0 set OnAPasCommence 0 foreach Ligne $LesLignes { if {! [regexp -nocase {[a-z]+ || [0-9]+} $Ligne]} {continue} if {$OnAPasCommence=="0" && ![regexp -nocase {Moving on:} $Ligne]} { if {[regexp "^Oligo Requested:" $Ligne ]} { set Ligne [split $Ligne " "] set IDP [lindex $Ligne 14] set IDP2 [format "%.1f" [expr $IDP *100.0]] set tmlo [format "%.1f" [lindex $Ligne 5]] set tmup [format "%.1f" [lindex $Ligne 7]] set Ligne [lreplace $Ligne 14 14 $IDP2] set Ligne [lreplace $Ligne 5 5 $tmlo] set Ligne [lreplace $Ligne 7 7 $tmup] } if {[regexp "^Query has" $Ligne ]} { if {! [regexp "Cover S/Q" $Ligne]} { set Ligne [split $Ligne " "] set Id1 [format "%.2f" [lindex $Ligne end-2]] set Id2 [format "%.2f" [lindex $Ligne end-1]] set Id3 [format "%.2f" [lindex $Ligne end]] set Ligne [lreplace $Ligne end-2 end-2 "(%Id $Id1,"] set Ligne [lreplace $Ligne end-1 end-1 "Cover S/Q $Id2,"] set Ligne [lreplace $Ligne end end "Cover Q/S $Id3)"] set Ligne [join $Ligne " "] } } lappend NewLines $Ligne continue } if {[regexp "^Moving on:" $Ligne]} { #Espionne "$Ligne" set OnAPasCommence 1 set Sequence 1 set Prohib 0 set GC 0 set Tm 0 set Spec 0 set Spec2 0 lappend NewLines $Ligne continue } if {$Sequence} { scan $Ligne "%s" Seq if {[string length $Seq] == "60"} { #Espionne "On a la sequence $Seq" lappend NewLines "Sequence: $Seq" set Sequence 0 set Prohib 1 lappend NewLines "Length: OK" continue } set Sequence 0 set Prohib 1 lappend NewLines $Ligne } if {$Prohib} { if {[regexp "^Prohibited" $Ligne]} { set Prohib 0 set GC 1 lappend NewLines "$Ligne" continue } if {[regexp "^GC\:" $Ligne]} { set Prohib 0 set GC 1 lappend NewLines "Prohibited: OK" } set Prohib 0 set GC 1 } if {$GC} { if {[regexp "^GC\:" $Ligne]} { set GCV "" scan $Ligne "%s %f" E GCV if {$Seq!=""} { set xGC [NombreDeBaseDe $Seq "G|C"] set GCV2 [expr ($xGC)/(60*1.0)] } else {Espionne "Pas desequence $Ligne"} if {$GCV==""} {Espionne "Probleme $GCV $Ligne"} lappend NewLines "GC: [format "%.1f" [expr $GCV2 * 100.0]] [join [lrange $Ligne 2 end] " "]" set GC 0 set Tm 1 continue } set GC 0 set Tm 1 } if {$Tm} { if {[regexp "^Tm\:" $Ligne]} { if {[regexp "calculation" $Ligne ]} { set Tm 0 set Spec 1 lappend NewLines $Ligne continue } set Word "" set ETM "" set TM1 "" set TM2 "" scan $Ligne "%s %f %s" ETM TM1 Word set TM1 [format "%.1f" $TM1] if {$Word == ">" || $Word == "<"} { set TM2 [format "%.1f" [lindex $Ligne end]] set Ligne "$ETM $TM1 $Word $TM2" } else { set Ligne "$ETM $TM1 OK" } set Tm 0 set Spec 1 lappend NewLines $Ligne continue } set Tm 0 set Spec 1 } if {$Spec} { if {[regexp "^Spec: We keep" $Ligne]} { lappend NewLines "$Ligne" set Spec 0 set Spec2 1 continue } if {[regexp ">>>\tWe keep" $Ligne]} { lappend NewLines "$Ligne" set Spec 0 continue } } if {$Spec2} { if {[regexp "ID G" $Ligne]} { scan $Ligne "%s %s %f" id g v lappend NewLines "\tID G [format "%.2f" [expr $v * 100.0]]" set Spec 1 set Spec2 0 continue } set Spec2 0 } #Espionne "$Ligne pb" lappend NewLines $Ligne } AppendAuFichier $FichierNew [join $NewLines "\n"] file rename -force $Fichier1 "${Fichier1}.old" file rename -force $FichierNew $Fichier1 return "" } proc UpdateLesFichiersLog {Rep {Rep2 ""}} { Wup "Mise a jour des fichiers log de la veille version a la nouvelle version" set Liste [lrange [ListeDesPABs] 0 1164] foreach PAB $Liste { set LogFile "$Rep/${PAB}.log" if {$Rep==""} { set Log2 "" } else { set Log2 "$Rep2/${PAB}.log" } #UpdateLeFichierLog $LogFile $Log2 UpdateLeFichierLog $LogFile } } proc UpdateListboxSeqFeat {} { global EFeat TDesSeqnames TDesAccess TDesBId LNOrdali foreach n $LNOrdali { if {$n ne ""} { switch $EFeat(NomsAff) { "Accession" {set naf $n} "Seq. Name" {set naf [set TDesSeqnames($n)]} "Bank Id" {set naf [set TDesBId($n)]} } set EFeat(NSeq,$n) $naf } else { set naf $n } lappend Lnaff $naf } set EFeat(ListboxListe) $Lnaff TracageFeatureSummary return } proc UpdateMol3dObjets {n1 n2 op} { global ListeMol3dObjets Obj3dCou Mol3dCou Feat3dCou set lob [[set $n1] _ListeObjets] set ListeMol3dObjets [list] foreach o $lob { lappend ListeMol3dObjets [string range $o 4 end] } set Obj3dCou "" set Feat3dCou "None" return } proc UpdateMolObjFeat {args} { global pgl Mol3dCou Obj3dCou Feat3dCou Feat3dCou2 update if {$Obj3dCou eq ""} {return} if {$Feat3dCou eq ""} {return} $Mol3dCou _mapfeat $Obj3dCou $Feat3dCou 0 $Mol3dCou _mapfeat $Obj3dCou $Feat3dCou2 1 $Mol3dCou _dellist $Obj3dCou $Mol3dCou render $Obj3dCou $pgl(wogl) postredisplay return } proc UpdateNoms {} { ChangeNomsAff $::Defauts(NomsAffiches) $::NomNomSeq configure -state normal $::NomNomSeq delete 1.0 end $::NomNomSeq insert end $::NomsAffiches $::NomNomSeq configure -state disabled return } proc UpdatePosFeatures {} { global LNOrdali LSOrdali TabSF LNSTemp LSSTemp ListePDB foreach n $LNOrdali s $LSOrdali { if {$n eq ""} {continue} # si la seq n'est pas dans nouvel alignemtn if {[set ix [lsearch $LNSTemp $n]] == -1} {continue} # Features pdb traitees a part if {$n in $ListePDB} { UpdatePosPDBFeatures $n $s continue } # cas general set Le [array names TabSF "${n},*"] foreach e $Le { set newft [list] foreach ft [set TabSF($e)] { lassign [split $e ,] tmp ftype DecortiqueUneFeature $ft d f color score note csys set gsd [expr {[string index $s $d] eq "."}] set dg [NewFeatPosDe $n $d $gsd] if {$dg < 0} { set dg [expr {-1*$dg}] } set gsf [expr {[string index $s $f] eq "."}] set fg [NewFeatPosDe $n $f $gsf] if {$fg < 0} { set fg [expr {-1*$fg}] } set nl [list fstart $dg fstop $fg fcolor $color fscore $score fnote $note fcsys $csys] lappend newft $nl } set TabSF($e) $newft } } return } proc UpdatePosPDBFeatures {n s} { global TabSF set mol [DonneIdDeAccessPDB $n] set chn [DonneChainDeAccessPDB $n] foreach e [array names TabSF "${n},*"] { lassign [split $e ,] tmp ftype set newft [list] foreach ft [set TabSF($e)] { DecortiqueUneFeature $ft d f color score note csys set gd [expr {[string index $s $d] eq "."}] set gf [expr {[string index $s $f] eq "."}] if {! $gd} { # d : position globale, start 0 set ds [DonnePosGS $n $d] # ds : position dans PDB set ids [$mol CoordsPDB2Seq $chn $ds] # ids : position seq : start 0 set dg [NewFeatPosDe $n $d $gd $ids] } else { set dg [NewFeatPosDe $n $d $gd] } if {! $gf} { #incr f set fs [DonnePosGS $n $f] set ifs [$mol CoordsPDB2Seq $chn $fs] #incr ifs -1 set fg [NewFeatPosDe $n $f $gf $ifs] } else { set fg [NewFeatPosDe $n $f $gf] } if {$dg < 0} {set dg [expr {-1*$dg}]} if {$fg < 0} {set fg [expr {-1*$fg}]} set nl [list fstart $dg fstop $fg fcolor $color fscore $score fnote $note fcsys $csys] lappend newft $nl } set TabSF($e) $newft } return } proc UpdateTableConversionNCBI {} { # A lancer sur le temp du serveur set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UpdateTableConversionNCBI : Start" # exec wget "ftp://ftp.ncbi.nlm.nih.gov/gene/DATA/gene2accession.gz" 2>@1 # exec gunzip "/tmp/gene2accession.gz" set FichierIn [open "/tmp/gene2accessionReference" "r"] set FichierOut [open "/tmp/gene2accession.csv" "w"] set FichierDesRequetes [open "/tmp/gene2accession.bql" "w"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UpdateTableConversionNCBI : Building queries" while { [gets $FichierIn Ligne] >= 0} { ScanLaListe $Ligne bin tax_id GeneID status RNA_nucleotide_accession_version RNA_nucleotide_gi protein_accession_version protein_gi genomic_nucleotide_accession_version genomic_nucleotide_gi start_position_on_the_genomic_accession end_position_on_the_genomic_accession orientation assembly set chromoFiche [lindex [split $genomic_nucleotide_accession_version "."] 0] if {[string range $chromoFiche 0 1] == "NC" } { set database "REFSEQG" } else { set database "GBFULL" } puts $FichierDesRequetes "ID $chromoFiche DB $database" puts $FichierDesRequetes "FD DE" puts $FichierDesRequetes "LM 1" puts $FichierDesRequetes "//" incr nbRequests } close $FichierDesRequetes set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UpdateTableConversionNCBI : Executing $nbRequests queries" BirdFetch "/tmp/gene2accession.bql" "/tmp/gene2accession.res" set FichierDesRequetesExecutees [open "/tmp/gene2accession.res" "r"] while { [gets $FichierDesRequetesExecutees Ligne] } { gets $FichierDesRequetesExecutees Ligne if {$Ligne !="EMPTY"} { set chromosome "" regexp -nocase {(contig|chromosome|plasmid)\s*[A-z0-9]*-*[A-z0-9]*[, .]} $Ligne chromosome regsub -all -nocase {chromosome\s} $chromosome "chr" chromosome regsub -all -nocase {\,|\.} $chromosome "" chromosome regsub -all -nocase {\s} $chromosome "_" chromosome #regsub -all -nocase {^[A-z].*\s} $chromophrase "" chromosome if {$chromosome == ""} { regsub -nocase "DEFINITION=" $Ligne "" chromosome regsub -all -nocase {^[A-z].*\s} $chromosome "" chromosome regsub -all -nocase {^[A-z].*\s} $chromosome "" chromosome } } else { set chromosome "EMPTY" } set chromosome [string trim $chromosome] set LigneOut "$bin\t$tax_id\t$GeneID\t$status\t$RNA_nucleotide_accession_version\t$RNA_nucleotide_gi\t$protein_accession_version\t$protein_gi\t$genomic_nucleotide_accession_version\t$genomic_nucleotide_gi\t$chromosome\t$start_position_on_the_genomic_accession\t$end_position_on_the_genomic_accession\t$orientation\t$assembly" puts $FichierOut $LigneOut } close $FichierDesRequetesExecutees close $FichierIn close FichierOut set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UpdateTableConversionNCBI : Loading $Table table in mySQL..." exec /usr/bin/mysqlimport --user=anno --password=ceji387. --host=[LbgiHost] "ucschuman" "/tmp/gene2accession.csv" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|UpdateTableConversionNCBI : Done." } proc UpdateVMDFeatures {name1 name2 op} { global ListeTypeDeFeatures VMDsend "NouvelleFeatures $ListeTypesDeFeatures" return } proc UpdateXmlWithMacsim {FichierXml {NewFichierXml ""}} { Espionne "UpdateXmlWithMacsim" if {$NewFichierXml==""} { set NewFichierXml $FichierXml } set VraiXmlIn $FichierXml if { ! [regexp "^/" $VraiXmlIn]} { set VraiXmlIn "[pwd]/$VraiXmlIn" } set TmpXmlOut "[TmpFile]Out.xml" NousAllonsAuBoulot #rR il y avait /home/julie/MACSIM/macsim_ko if {[catch {exec macsim $VraiXmlIn $TmpXmlOut 2> /dev/null} Message]} { return "Error : error from macsim \n$Message" } OnRevientDuBoulot if { ! [file exists $TmpXmlOut]} { return "Error : No xml output file $TmpXmlOut" } file rename -force $TmpXmlOut $NewFichierXml return $NewFichierXml } proc UpgradeOrdaliDB {fold fnew} { sqlite old $fold sqlite new $fnew FabriqueDeTables [set Defauts(TablesDB1.1)] new $fnew return } proc UrlCommandeOligo {} { return "http://wappli-igbmc.u-strasbg.fr:2030/oligcde" } proc UsageDesCodons {NomVoulu} { global UsageDesCodons global RepertoireDuGenome global ListeDeBoites if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] } if {[info exists UsageDesCodons("EstCharge")]} { return "" } set FichierUsageDesCodons "$RepertoireDuGenome/fiches/usagedescodons" if {[file exists $FichierUsageDesCodons]} { array set UsageDesCodons [split [ContenuDuFichier $FichierUsageDesCodons] ":"] if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] } return "" } if { ! [OuiOuNon "Do I calculate now UsageDesCodons ?" 0]} { set UsageDesCodons("EstCharge") 1 return "" } set NombreDeCodons 0 foreach Boite [ListeDeBoites] { set Nom [Box $Boite nom] set Debut [Box $Boite debut] set Fin [Box $Boite fin] set Orient [Box $Boite orient] if { ! [YaPABdans $Nom]} { continue } if {[Enterre $Nom]} { continue } if {$Orient == "F"} { incr Fin 3 } else { incr Debut -3 } if {[OuiOuNonMemo "Do I use the genome DNA file for CodonW?"]} { set SeqNuc [BoutADN $Debut $Fin $Orient] } else { set Rep [RepDesNucPourCodonW] set SeqNuc [QueLaSequenceDuFichierTFA [GscopeFile $Nom $Rep]] } for {set i 0} {$i <= [expr $Fin-$Debut]} {incr i 3} { set Codon [string range $SeqNuc $i [expr $i+2]] if { ! [info exists CodonUsage($Codon)]} { if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue } lappend ListeDesCodons $Codon set CodonUsage($Codon) 0 } incr CodonUsage($Codon) incr NombreDeCodons if { ! [info exists CodonUsage($Codon,$Nom)]} { set CodonUsage($Codon,$Nom) 0 } incr CodonUsage($Codon,$Nom) } lappend ListeDesLongueurs [expr ($Fin-$Debut+1)/3] lappend ListeDesNoms $Nom } Espionne "J'ai compte $NombreDeCodons codons" set UC {} set OldPremiereBase "X" foreach Codon [lsort $ListeDesCodons] { set PremiereBase [string index $Codon 0] if {$PremiereBase != $OldPremiereBase} { if { $OldPremiereBase != "X" } { lappend UC $Codons lappend UC $PourCent lappend UC "" } set Codons "" set PourCent "" } set OldPremiereBase [string index $Codon 0] append Codons [format " %s %s" [AAduCodon $Codon] $Codon] append PourCent [format " %5d" [expr round(10000.*[set CodonUsage($Codon)]/$NombreDeCodons)]] } lappend UC $Codons lappend UC $PourCent lappend UC "" set UsageDesCodons(Global) "\n[join $UC "\n"]" foreach Nom $ListeDesNoms Longueur $ListeDesLongueurs { Espionne $Nom set UC {} set OldPremiereBase "X" foreach Codon [lsort $ListeDesCodons] { set PremiereBase [string index $Codon 0] if {$PremiereBase != $OldPremiereBase} { if { $OldPremiereBase != "X" } { lappend UC $Codons lappend UC $PourCent lappend UC $PourNom lappend UC "" } set Codons "" set PourCent "" set PourNom "" } set OldPremiereBase [string index $Codon 0] append Codons [format " %s %s" [AAduCodon $Codon] $Codon] append PourCent [format " %5d" [expr round(10000.*[set CodonUsage($Codon)]/$NombreDeCodons)]] if {[info exists CodonUsage($Codon,$Nom)]} { set CodonUsageDuNom [set CodonUsage($Codon,$Nom)] } else { set CodonUsageDuNom 0 } append PourNom [format " %5d" [expr round(10000.*$CodonUsageDuNom/$Longueur)]] } lappend UC $Codons lappend UC $PourCent lappend UC $PourNom lappend UC "" set UsageDesCodons($Nom) "\n[join $UC "\n"]" } set UsageDesCodons("EstCharge") 1 Sauve [join [array get UsageDesCodons] ":"] dans $FichierUsageDesCodons if {[info exists UsageDesCodons($NomVoulu)]} { return [set UsageDesCodons($NomVoulu)] } return "" } proc UsageDesCodonsEtCodeCirculaire {} { #rR on veut voir si le code circulaire préférencie l'ensemble X0 ci-dessous foreach Codon [list AAC AAT ACC ATC ATT CAG CTC CTG GAA GAC GAG GAT GCC GGC GGT GTA GTC GTT TAC TTC] { set X($Codon) 1 set Codon1 "[string range $Codon 1 end][string index $Codon 0]" set Codon2 "[string range $Codon1 1 end][string index $Codon1 0]" set X1($Codon1) 1 set X2($Codon2) 1 } set NbCodons 0 foreach Nom [ListeDesPABs] { set FiNuc [GscopeFile $Nom nuctfa] if {[FileAbsent $FiNuc]} { continue } set Seq [QueLaSequenceDuFichierTFA $FiNuc] set Seq [string toupper $Seq] foreach {A B C} [split $Seq ""] { set Codon "$A$B$C" if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue } lappend LesCodons $Codon incr Frame0($Codon) incr NbCodons } set Seq "[string range $Seq 1 end]X" foreach {A B C} [split $Seq ""] { set Codon "$A$B$C" if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue } lappend LesCodons $Codon incr Frame1($Codon) } set Seq "[string range $Seq 1 end]X" foreach {A B C} [split $Seq ""] { set Codon "$A$B$C" if { ! [regexp {^[ATGC][ATGC][ATGC]$} $Codon]} { continue } lappend LesCodons $Codon incr Frame2($Codon) } } set LesCodons [lsort -unique $LesCodons] set LesN0 {} set LesN1 {} set LesN2 {} foreach Codon $LesCodons { if { ! [info exists Frame0($Codon)]} { set N 0 } else { set N $Frame0($Codon) } lappend LesCodonsDe0($N) $Codon lappend LesN0 $N if { ! [info exists Frame1($Codon)]} { set N 0 } else { set N $Frame1($Codon) } lappend LesCodonsDe1($N) $Codon lappend LesN1 $N if { ! [info exists Frame2($Codon)]} { set N 0 } else { set N $Frame2($Codon) } lappend LesCodonsDe2($N) $Codon lappend LesN2 $N } set LesN0 [lsort -integer -unique -decreasing $LesN0] set LesN1 [lsort -integer -unique -decreasing $LesN1] set LesN2 [lsort -integer -unique -decreasing $LesN2] set LesCodonsTries0 {} foreach N $LesN0 { LConcat LesCodonsTries0 $LesCodonsDe0($N) } set LesCodonsTries1 {} foreach N $LesN1 { LConcat LesCodonsTries1 $LesCodonsDe1($N) } set LesCodonsTries2 {} foreach N $LesN2 { LConcat LesCodonsTries2 $LesCodonsDe2($N) } set LesCircu0 {} foreach Codon $LesCodonsTries0 { if {[info exists Frame0($Codon)]} { set F $Frame0($Codon) } else { set P 0 } if {[info exists X($Codon)]} { lappend LesCircu0 $Codon lappend LesPourCent0 [format "%3d" [expr ($F*10000)/$NbCodons]] } else { lappend LesCircu0 " " lappend LesPourCent0 [format "%3d" [expr ($F*10000)/$NbCodons]] } } set LesCircu1 {} foreach Codon $LesCodonsTries1 { if {[info exists Frame1($Codon)]} { set F $Frame1($Codon) } else { set P 0 } if {[info exists X1($Codon)]} { lappend LesCircu1 $Codon lappend LesPourCent1 [format "%3d" [expr ($F*10000)/$NbCodons]] } else { lappend LesCircu1 " " lappend LesPourCent1 [format "%3d" [expr ($F*10000)/$NbCodons]] } } set LesCircu2 {} foreach Codon $LesCodonsTries2 { if {[info exists Frame2($Codon)]} { set F $Frame2($Codon) } else { set P 0 } if {[info exists X2($Codon)]} { lappend LesCircu2 $Codon lappend LesPourCent2 [format "%3d" [expr ($F*10000)/$NbCodons]] } else { lappend LesCircu2 " " lappend LesPourCent2 [format "%3d" [expr ($F*10000)/$NbCodons]] } } set LeMessage {} lappend LeMessage [join $LesCircu0 " "] lappend LeMessage [join $LesCodonsTries0 " "] lappend LeMessage [join $LesPourCent0 " "] lappend LeMessage "" lappend LeMessage [join $LesCircu1 " "] lappend LeMessage [join $LesCodonsTries1 " "] lappend LeMessage [join $LesPourCent1 " "] lappend LeMessage "" lappend LeMessage [join $LesCircu2 " "] lappend LeMessage [join $LesCodonsTries2 " "] lappend LeMessage [join $LesPourCent2 " "] set Message [join $LeMessage "\n"] return [Affiche $Message "" "CodonOrderFor_[NotreOS]"] } proc UseBanqueIdForDbClustal {{Value ""}} { global UseBanqueIdForDbClustal if {$Value!=""} { set UseBanqueIdForDbClustal $Value } if { ! [info exists UseBanqueIdForDbClustal]} { set UseBanqueIdForDbClustal 0 } return $UseBanqueIdForDbClustal } proc UseBirdForUniprot {{Value ""}} { #rR c'est pour que DbClustal puisse utiliser FromOrthoInspector ou FromYannis global UseBirdForUniprot if {$Value!=""} { set UseBirdForUniprot $Value } if { ! [info exists UseBirdForUniprot]} { return 0 } return $UseBirdForUniprot } proc UseExistingJalviewHtml {{Value ""}} { global UseExistingJalviewHtml if {$Value!=""} { set UseExistingJalviewHtml $Value } if { ! [info exists UseExistingJalviewHtml]} { set UseExistingJalviewHtml [file exists "[RepertoireDuGenome]/webXXXXXXXXXX"] } return $UseExistingJalviewHtml } proc UserDeRapport {Rapport} { foreach Ligne [LesLignesDuFichier $Rapport] { scan $Ligne "%s %s" type def if {$type=="User:"} {return $def} } } proc Utf8 {} { set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/Library/Ligatures.txt"] set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/phpNE/Article/pdf_txt/UpL20070206173536_of_calpain.pdf.txt"] return $Texte Espionne $Texte regsub {\uFB01} $Texte "fi" Texte Espionne "\uFB01" Espionne $Texte return $Texte } proc UtiliseCCode {} { return 1 if {0 && [catch {package require tcc} Msg]} { puts "failed package require" return 0 } else { puts "package loaded" flush stdout } # package require tcc tcc::reset tcc::cproc csum {double a double b} double {return a+b;} set c [csum 4.2 5.01] if {$c != 9.21} {return 0} return 1 } proc VE {Qui {Quoi ""}} { global VE if {[info exists VE($Qui,$Quoi)]} { return $VE($Qui,$Quoi) } if {[info exists VE("EstCharge")]} { return "" } VeFromSbgpDatabase set VE("EstCharge") 1 return [VE $Qui $Quoi] } proc VEDidier {{Qui ""} {Quoi ""}} { global VEDidier if {$Qui==""} { set Qui "ListeDes" } if {$Quoi==""} { if {$Qui=="ListeDes"} { set Quoi "VE" } else { set Quoi "Ligne" } } if {$Qui=="Show" && $Quoi=="All"} { return [VEDidier "All" "Show"] } if {$Quoi=="Show"} { set VEs $Qui if {$Qui=="All"} { set VEs [join [lsort [VEDidier ListeDes VE]] " "] } set LaPage {} foreach Mot [LesMotsDeLaLigne $VEs] { if { ! [regexp {^VE[0-9]+$} $Mot]} { continue } lappend LaPage [VEDidier $Mot Ligne] } return [AfficheListe $LaPage "AvecOligo" $Qui] } if {[info exists VEDidier($Qui,$Quoi)]} { return $VEDidier($Qui,$Quoi) } if {[info exists VEDidier("EstCharge")]} { return "" } set Texte [HttpGetTextFromUrl "http://tursan/vestatus/vecsvcrlf.php"] set DejaVuEntete 0 foreach Ligne [split $Texte "\n"] { if { ! [regexp "^VE" $Ligne]} {continue} set Ligne [string trim $Ligne ";"] set LesMots [split $Ligne ";"] if {! $DejaVuEntete} { set LesClefs $LesMots set VEDidier(ListeDes,Clefs) $LesClefs set DejaVuEntete 1 continue } set VE [lindex $LesMots 0] if {[info exists VEDidier($VE,Ligne)]} { continue } lappend VEDidier(ListeDes,VE) $VE set VEDidier($VE,Ligne) $Ligne foreach Mot $LesMots Clef $LesClefs { set VEDidier($VE,$Clef) $Mot } } set VEDidier("EstCharge") 1 return [VEDidier $Qui $Quoi] } proc VMDDemande {Id pdb quoi args} { global ListePDB set pdb [string tolower $pdb] set ix [lsearch -regexp $ListePDB $pdb] set MolId [lindex [lindex $ListePDB $ix] 0] set chn [DonneChainDeAccessPDB $MolId] switch $quoi { "Couleurs" { set type [lindex $args 0] if {$type == "conservation"} { set LesCmds [CouleursPourVMD [CouleursOrdali $MolId] $Id] } else { set LesCmds [CouleursPourVMD [ColorieStructureSelonFeature $type $MolId] $Id] } foreach ord $LesCmds { IlFautVoir $ord } IlFautVoir "MChangeStyle $Id" } } return } proc VMDacpt {sock addr port} { global clients putlog "Accept $sock from $addr port $port" set clients($sock) 1 fconfigure $sock -buffering line -blocking 1 fileevent $sock readable [list VMDrecv $sock] return } proc VMDexe {} { global tcl_platform global env set fexe [auto_execok vmd] if {$fexe ne ""} {return $fexe} if {$tcl_platform(platform) eq "windows"} { set fexe [FindTcl "vmd.exe" $env(ProgramFiles)] } return $fexe } proc VMDrecv {sock} { global CanalV global clients if { [eof $sock] || [catch {gets $sock line}]} { # end of file or abnormal connection drop close $sock putlog "Closing $sock" unset clients($sock) catch {unset CanalV} trace remove variable ListeTypeDeFeatures write UpdateVMDFeatures } else { if {$line eq "quit"} { # prevent new connections # existing connections stay open putlog "Disallowing incoming connections by request of $sock" close $CanalV unset CanalV trace remove variable ListeTypeDeFeatures write UpdateVMDFeatures } puts $line if {[regexp {^AuLog} $line]} {eval $line ; return} if {[regexp {^VMD} $line]} {eval $line ; return} if {[regexp {^Faire} $line]} {eval $line ; return} eval $line } return } proc VMDsend {line} { global clients global CanalV foreach client [array name clients] { if { [string compare $CanalV $client] != 0 } { # don't send to originator putlog "send '$line' to $client" puts $client $line } } return } proc VMDstart {} { global CanalV set port 21212 set CanalV [socket -server VMDacpt $port] putlog "Listening on port $port" update return } proc VMT {x y z L t} { lassign $L a b c return [expr {$x*$a + $y*$b + $z*$c +$t}] } proc V_MV {A op V} { set W {} foreach VA $A { lappend W [S_VV $VA * $V] } return $W } proc V_SV {s op u} { set w {} switch $op { "+" { foreach e $u {lappend w [expr {$e+$s}]} } "-" { foreach e $u {lappend w [expr {$e-$s}]} } "*" { foreach e $u {lappend w [expr {$e*$s}]} } "/" { foreach e $u {lappend w [expr {$e/$s}]} } } return $w } proc V_T {aT} { upvar $aT T set Zero 0 foreach Bornes [array names T] { set I "undefined" scan $Bornes "%d" I if {$I=="undefined"} { continue } set Valeur [set T($Bornes)] if {[regexp "\." $Valeur]} { set Zero 0.0 } set BonT($I) $Valeur lappend LesIs $I } set LesIs [lsort $LesIs] set DebI [lindex $LesIs 0] set FinI [lindex $LesIs end] set V {} for {set I $DebI} {$I<=$FinI} {incr I} { if {[info exists BonT($I)]} { lappend V [set BonT($I)] } else { lappend V $Zero } } return $V } proc V_VM {V op A} { set W {} foreach VtA [M_tM $A] { lappend W [V_VV $V * $VtA] } return $W } proc V_VS {u op s} { set w {} switch $op { "+" { foreach e $u {lappend w [expr {$e+$s}]} } "-" { foreach e $u {lappend w [expr {$e-$s}]} } "*" { foreach e $u {lappend w [expr {$e*$s}]} } "/" { foreach e $u {lappend w [expr {$e/$s}]} } } return $w } proc V_VV {u op v} { set w {} switch $op { "+" { foreach e $u f $v { lappend w [expr {$e + $f}] } } "-" { foreach e $u f $v { lappend w [expr {$e - $f}] } } "*" { foreach e $u f $v { lappend w [expr {$e * $f}] } } "/" { foreach e $u f $v { lappend w [expr {$e / $f}] } } } return $w } proc V_Vwithout {V i} { return [lreplace $V $i $i] } proc V_create {args} { return $args } proc V_fromM {M {i 0}} { return [lindex $M $i] } proc V_fromV {V d f} { return [lrange $V $d $f] } proc V_lVV {s opu u op t opv v} { set w {} foreach e $u f $v { lappend $w [expr ($s $opu $e) $op ($t $opv $f)] } return $w } proc V_nV {u} { set N [S_nV $u] if {$N < 1.e-20} { return [V_VS $u * 0] } return [V_VS $u / $N] } proc V_unit {{i 0} {n 3} {Valeur 1.0}} { set V {} set Zero [expr $Valeur - $Valeur] for {set j 0} {$j<$n} {incr j} { if {$i!=$j} { lappend V $Zero } else { lappend V $Valeur } } return $V } proc ValFromStack {{OtherStack ""} {Pull ""}} { global OurCurrentStack OurStacks if {$OtherStack!=""} { set OurCurrentStack $OtherStack } if { ! [info exists OurCurrentStack]} { return "" } if { ! [info exists OurStacks($OurCurrentStack,StackHeight)]} { set OurStacks($OurCurrentStack,StackHeight) 0 } set h [set OurStacks($OurCurrentStack,StackHeight)] if {$h==0} { return "" } set Val [set OurStacks($OurCurrentStack,$h)] if {$Pull!=""} { set OurStacks($OurCurrentStack,StackHeight) [incr h -1]} return $Val } proc Valerie {RS RD} { cd $RS foreach S [lsort [glob "*.img"]] { set D "$RD/$S" if {[file exists $D]} { continue } file copy $S $D Espionne $D } } proc ValeurApres {Champ dans Texte Format} { set iZone [string first $Champ $Texte] if {$iZone<0} { return "" } incr iZone [string length $Champ] if { $Format == "ExposantEventuellementMalFoutu" } { set sPN [string trim [string range $Texte $iZone end] " '"] regsub {^[eE]} $sPN "1.0e" sPN scan $sPN "%f" PN if {[catch { expr $PN > 0.001 } ]} { Warne "Oh le vilain $sPN trop petit, je prends 1.0E-200" set PN 1.0E-200 } set Valeur $PN } else { if {$iZone<0} {return ""} set Valeur "" scan [string range $Texte $iZone end] "$Format" Valeur } return $Valeur } proc ValeurBoot {} { global TokCourant if {$TokCourant=="\["} { Tok set Entier [Entier] if {[regexp "NonValide" $Entier]} { return "ValeurBootNonValideCar$Entier" } if {$TokCourant=="\]"} { Tok return $Entier } return "ValeurBootNonValideCarNonCrochetFermant" } return "ValeurBootNonValideCarNonCrochetOuvrant" } proc ValeurDeLaBalise {Item aTexte {Rogner Rogner} {aAttributs ""} {Vide ""}} { upvar $aTexte Texte if {$aAttributs!=""} { upvar $aAttributs Attributs } set Rogner [expr ! [string equal -nocase $Rogner "NePasRogner"]] regsub -all -- "-" $Item "\-" ItemX if { ! [regexp -indices -nocase "<${ItemX}(>| )" $Texte Indices]} { return $Vide } set FinItem [lindex $Indices 1] set NouveauTexte [string range $Texte [expr $FinItem] end] set iChevronFermant [string first ">" $NouveauTexte] if {$iChevronFermant<0} { return "" } set Attributs [string range $NouveauTexte 0 $iChevronFermant] set LongAttributs [string length $Attributs] regsub ">" $Attributs "" Attributs set Attributs [string trim $Attributs] set NouveauTexte [string trim [string range $NouveauTexte $LongAttributs end]] set Fermant [ItemHTMLFermant $Item] if {$Fermant==">"} { set Valeur $Attributs set Derriere 0 } else { regsub -all -- "-" $Fermant "\-" FermantX if { ! [regexp -indices -nocase "$FermantX" $NouveauTexte Indices]} { return $Vide } set iFin [lindex $Indices 0] if {[regexp {<[^/]} $FermantX]} { set Derriere [expr $iFin - 1] } else { set Derriere [expr [lindex $Indices 1] + 1] } set Valeur [string range $NouveauTexte 0 [expr $iFin - 1]] } if {$Rogner} { set Texte [string range $NouveauTexte $Derriere end] } if {$Valeur==""} { set Valeur $Vide } return $Valeur } proc ValeurDist {} { global TokCourant if {$TokCourant==":"} { Tok set Flottant [Flottant] if {[regexp "NonValide" $Flottant]} { return "ValeurDistNonValideCar$Flottant" } return $Flottant } return "ValeurDistNonValideCarNonDoublePoints" } proc ValeurEnFin {de Texte Format} { set BonTexte [string trim $Texte] set iZone [expr [string last " " $BonTexte]+1] scan [string range $BonTexte $iZone end] "$Format" Valeur return $Valeur } proc ValeurFeuille {} { global TokCourant global ValueurFeuille if {regexp -nocase {[a-z_]} $TokCourant} { set ValeurFeuille $TokCourant Tok set AlphaNum [AlphaNum] if { ! [regexp "NonValide" $AlphaNum} { append ValeurFeuille $AlphaNum } return $ValeurFeuille } return "ValeurFeuilleNonValideCarNonAlphaEnDebut" } proc ValeurPk {Texte} { set Pk "" scan $Texte "%s" Pk return $Pk } proc ValiDE {Nom} { set DE [ExtraitInfo $Nom "ValiDE:"] if {$DE==""} { set DE [ExtraitInfo $Nom "ValiDEProt:"] } if {[string equal -nocase "no value" $DE]} { set DE "" } return $DE } proc ValiGN {Nom} { set GN [ExtraitInfo $Nom "ValiGN:"] if {$GN==""} { set GN [ExtraitInfo $Nom "ValiGNProt:"] } if {[string equal -nocase "no value" $GN]} { set GN "" } return $GN } proc ValiGNHNR {} { foreach Nom [ListeDesPABs] { set Access [ExtraitInfo $Nom "AccessProt:"] set GN [BirdWeb uniprot $Access GN] Espionne $GN set ValiGN [StringApres "Name=" dans $GN] regsub {\;.*} $ValiGN "" ValiGN Espionne "$Nom $Access $ValiGN" InformeSansDemander $Nom "=ValiGN: $ValiGN" } exit } proc ValidBlastDatabaseForGrilladin {BlastDatabase} { return 1 return [string equal $BlastDatabase "Proteome201501"] } proc ValidBlastDatabaseForHotdog {BlastDatabase} { return [ValidBlastDatabaseForGrilladin $BlastDatabase] } proc ValidLaListeBoxDePanelFindProtein {KListBox} { set LesOrganismes {} set LesGO {} set LesEntry {} foreach Ligne [$KListBox get 0 end] { if {$Ligne == ""} {continue} set LaLigne [split $Ligne " "] if {![string equal -nocase [lindex $LaLigne 0] "\#Entry"]} {continue} lappend LesEntry $Ligne set Type [lindex $LaLigne 1 ] set Entry [lrange $LaLigne 2 end] if {$Type == "OS"} { lappend LesOrganismes $Entry if {[regexp -nocase {^Rattus} $Entry]} { lappend LesOrganismes "Rattus norvegicus" lappend LesOrganismes "Rattus sp" lappend LesOrganismes "Rattus sp." } if {[regexp -nocase {^Mus|mouse} $Entry]} { lappend LesOrganismes "Mus musculus" lappend LesOrganismes "House mouse" lappend LesOrganismes "Mouse" } if {[regexp -nocase {^Homo|Human} $Entry]} { lappend LesOrganismes "Homo sapiens" lappend LesOrganismes "Human" } if {[regexp -nocase {^Danio|Brachydanio} $Entry]} { lappend LesOrganismes "Zebrafish" lappend LesOrganismes "Brachydanio rerio" lappend LesOrganismes "Danio rerio" lappend LesOrganismes "Brachydanio rerio" } } if {$Type == "GO"} { foreach GO [lrange $LaLigne 2 end] {lappend LesGO $GO} } if {$Type == "GOF"} { if {![file exists $Entry]} {continue} foreach GO [LesLignesDuFichier $Entry] { set GO [string trim $GO] if {$GO == ""} {continue} lappend LesGO $GO } } if {$Type == "EKW"} { foreach GO [LesGOAvecCeKeyword $Entry "Exactly" ] {lappend LesGO $GO} } if {$Type == "CKW"} { foreach GO [LesGOAvecCeKeyword $Entry "Contained"] {lappend LesGO $GO} } } $KListBox delete 0 end foreach Ligne $LesEntry {$KListBox insert end $Ligne} $KListBox insert end "\#SEARCHING ..." if {$LesOrganismes != {}} {set LesOrganismes [lsort -unique $LesOrganismes]} set NbProteins 0 set LesLignes {} set EnAiJeDejaRencontreUn 0 foreach Ligne [LesProteinesAvecCesGO $LesGO $LesOrganismes "ID ACC DES ORG" protein] { if {[regexp -nocase "^ID " $Ligne]} { incr NbProteins if {$EnAiJeDejaRencontreUn} {lappend LesLignes "//"} lappend LesLignes "" set EnAiJeDejaRencontreUn 1 } lappend LesLignes $Ligne } if {$EnAiJeDejaRencontreUn} {lappend LesLignes "//"} $KListBox insert end "\#Number of proteins found : $NbProteins" foreach Ligne $LesLignes { $KListBox insert end $Ligne } return } proc ValidateServer {w} { global TCon CMDef # check for empty fields if {[string trim $TCon(ServerName)] eq ""} { FaireLire "Please give a name to this server !" return } if {[string trim $TCon(Username)] eq ""} { FaireLire "Please give a username !" return } if {[string trim $TCon(Password)] eq ""} { FaireLire "Please give a password !" return } if {[string trim $TCon(ServerAddress)] eq ""} { FaireLire "Please give a server address !" return } # debug if {1} { puts "------------------------" puts "Server Name ...: $TCon(ServerName)" puts "Server Address : $TCon(ServerAddress)" puts "Username ......: $TCon(Username)" puts "Password ......: $TCon(Password)" puts "Use SSL .......: $TCon(UseSSL)" puts "Port ..........: $TCon(Port)" puts "------------------------" } # Connect to server and log in if {[set imapID [ConnectServer $TCon(ServerAddress) $TCon(UseSSL) $TCon(Port)]] == 0} { return } set TCon(imapID) $imapID puts "connection ok" if {! [LoginServer $imapID $TCon(Username) $TCon(Password)]} { return } puts "login ok" array set CMDef [array get TCon] RegisterNewMailServer unset TCon if {[winfo toplevel $w] ne "."} { # we come from the main interface destroy $w } else { destroy .f } return } proc Validate_SetUp {} { Wup "Verifie le bon nombre de parametre" set LesSetUps [list PROGDIR BLASTDIR BLASTDBDIR GETZDIR] set Validated 1 foreach SetUp $LesSetUps { if {[LesParametresDuSetUp $SetUp "" Existe]} { continue } else { switch -exact -- $SetUp { "PROGDIR" {} "BLASTDIR" {} "BLASTDBDIR" {} "GETZDIR" {} } set Validated 0 break } } return $Validated } proc Validation {{Sens -increasing}} { global ListeDeBoites if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites } set JeVeuxFaire 1 if { $Sens == "Voir"} { set Sens "-increasing" set JeVeuxFaire 0 } set JeVeuxVoir [expr ! $JeVeuxFaire] foreach Boite [lsort $Sens $ListeDeBoites] { set Nom [Box $Boite nom] if {[FiabiliteFonction $Nom] != 5} { continue } if {$JeVeuxFaire && [ExtraitInfo $Nom "ValiDE"] != "" || $JeVeuxVoir && [ExtraitInfo $Nom "ValiDE"] == "" } { continue } puts $Nom continue if { [QueDitAful $Nom] && ! [OuiOuNon "Au suivant ?"] } { break } } } proc ValidationDeLaSequenceMasquee {FichierTFA} { set TailleMin 10 if {[NombreDeBasesContinuesMax $FichierTFA] < $TailleMin} { return 0 } else { return 1 } } proc ValidationESTDeQueryParHTG {FichierTFA Organism} { ############################################################### ### Validation des EST spe de la sequence query par les HTG ### ############################################################### set FichierTFAMasked "$FichierTFA.masked" set FichierBlastnHTG "$FichierTFA.blastnhtg" set FichierBlastnHTGReduced "$FichierBlastnHTG.reduced" set FichierBlastnEST "$FichierTFA.blastnest" set FichierESTSpeQueryTFA "$FichierTFA.esttfas" set FichierESTDB "[RepertoireDeTravail]/$FichierBlastnEST.dbest" if {![file exists $FichierTFAMasked]} { Espionne "$FichierTFAMasked does not exists, please create it" return } ########## Determination du meilleur HTG de la sequence query ########## ###BlastnHTG avec filtre de la sequence query masquee contre la banque d'HTG### #BlastNDuFichier $FichierTFAMasked "htg" $FichierBlastnHTG T 2000 0.1 0 if {![file exists $FichierBlastnHTG]} { set Commande "eval exec blastall -p blastn -i \$FichierTFAMasked -o \$FichierBlastnHTG -d /blast/htg -v 2000 -K 0 -b 2000 -e 2000 -F T -a 4" if {[catch {eval $Commande} Message]} { Espionne "Problem with $FichierBlastnHTG" Espionne $Message } } ### Recherche des HTG specifiques de la sequence tfa ### if {![file exists $FichierBlastnHTGReduced]} { set FichierBlastnHTGReduced [BlastDesMeilleursHTGDuBlast $FichierBlastnHTG $FichierTFA $Organism] } ### Selection du HTG qui "centre" au mieux la query ### ### cad du HTG ayant la plus grande petite extremite ### set HTGDeLaSequenceTFA [HTGDeLaSequenceTFA $FichierBlastnHTGReduced $FichierTFA $Organism] ########## Alignement du contig selectionne sur la banque d'EST specifiques de la query ########## ### Creation de la banque des EST specifiques de la query dans le repertoire junkdir### File copy -force $FichierESTSpeQueryTFA $FichierESTDB TFAs2DB $FichierESTDB ### Alignement du contig contre cette banque ### return } proc ValsDeCouleurs {} { global Couleurs set Couleurs(IdenGlob) "white black" set Couleurs(ConsGlob) "white DimGray" set Couleurs(SimiGlob) "black LightGray" set Couleurs(IdenGrp1) "black red" set Couleurs(IdenGrp2) "black blue" set Couleurs(IdenGrp3) "black yellow" set Couleurs(IdenGrp1Gris) "red LightGray" set Couleurs(IdenGrp2Gris) "blue LightGray" set Couleurs(IdenGrp3Gris) "yellow LightGray" set Couleurs(InterG12) "black magenta" set Couleurs(InterG13) "black coral" set Couleurs(InterG23) "black green" set Couleurs(InterG12Gris) "magenta LightGray" set Couleurs(InterG13Gris) "coral LightGray" set Couleurs(InterG23Gris) "green LightGray" set Couleurs(PoinGrp1) "red white" set Couleurs(PoinGrp2) "blue white" set Couleurs(PoinGrp3) "yellow white" } proc ValsDesDefauts {} { global Defauts set Defauts(Email) luc.moulinier@unistra.fr set Defauts(WithPackages) 1 set Defauts(Mode) Interactive set Defauts(MarcheForcee) 0 set Defauts(InProject) 0 set Defauts(Project) "" set Defauts(dispmode) "ordali" set Defauts(Devlpt) 0 set Defauts(FirstPass) 1 set Defauts(MacsimDone) 0 set Defauts(ToggleAllSeqs) 1 set Defauts(ToggleToolBar) 1 set Defauts(ToggleFeature) 1 set Defauts(ToggleScores) 0 set Defauts(ToggleColRes) 0 set Defauts(ToggleAuLog) 0 set Defauts(RemovePropagated) 0 set Defauts(NmMacCourant) "" set Defauts(LogAtStartup) 0 set Defauts(OnlyTLog) 0 set Defauts(ShowFrame) 0 set Defauts(FullScreen) 1 set Defauts(TypeAli) "pasdali" set Defauts(LongNom) 30 set Defauts(NomsAffiches) "seqname" set Defauts(PreCompute) 0 set Defauts(PrecomputeSrf) 0 set Defauts(CheckSeq) 0 set Defauts(Poids) 0 set Defauts(Poids2) 0 set Defauts(Poids3) 0 set Defauts(SelectionNom) 0 set Defauts(SelectionLong) 0 set Defauts(CutLong) 2 set Defauts(TypeDeGroupesACreer) "User" set Defauts(FichierClu) "" set Defauts(Run) 0 set Defauts(PDB) 0 set Defauts(PDBDansPilier) 1 set Defauts(SeqAssocie) 0 set Defauts(FichierMSF) "" set Defauts(FichierRSF) "" set Defauts(FichierTFA) "" set Defauts(FichierXML) "" set Defauts(FichierORD) "" set Defauts(FichierOBK) "" set Defauts(FichierALN) "" set Defauts(FichierPDB) "" set Defauts(FichierOMAC) "" set Defauts(Visualize) 0 set Defauts(ConsNGrp) 1 set Defauts(AffSS) 1 set Defauts(AffPhy) 0 set Defauts(AffGrp) 0 set Defauts(SphPts) 1 set Defauts(RunScript) 0 set Defauts(FgEukaryota) black set Defauts(BgEukaryota) PaleVioletRed1 set Defauts(FgArchaea) black set Defauts(BgArchaea) LightBlue set Defauts(FgBacteria) black set Defauts(BgBacteria) LightYellow set Defauts(FgViruses) white set Defauts(BgViruses) black set Defauts(LifeDomains) [list Eukaryota Archaea Bacteria Viruses] set Defauts(PrefixesBank) [list SPT SW PDB VARSPLIC UniRef90 UniRef100 PQS ENS sp unp tr ref gb dbj ENA toto] set Defauts(RemoveBankPrefix) 1 set Defauts(Background) "white" set Defauts(BackAppli) "#ffffffffd0d0" set Defauts(BackAppliOri) "" set Defauts(ForeAppli) "#000000000000" set Defauts(ForeAppliOri) "" set Defauts(DeltaYScroll) 1 set Defauts(PCThrGap) 0.5 set Defauts(MinThrGap) 4 set fontFml "Courier New" set Defauts(SeqFontFaml) $fontFml set Defauts(SeqFontSize) 14 set Defauts(SeqFontWght) normal set Defauts(DeltaXScroll) 10 set Defauts(Mapping) [EditorMappingData] set Defauts(UrlPdbHoan) "http://d1.crihan.fr:8080/bird/bsearch?db=pdb&accession=XXXX" set Defauts(UrlPdbHome) "http://bird:8080/bird/bsearch?db=pdb&accession=XXXX" set Defauts(UrlPdbWorld) "http://www.rcsb.org/pdb/cgi/export.cgi/XXXX.pdb?format=PDB&pdbId=XXXX&compression=None" set Defauts(UrlSRSHome) "http://bips.u-strasbg.fr/srsbin/cgi-bin/wgetz?-e+\[\{sptrembl_SP_swissprot\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2" set Defauts(UrlSRSWorld) "http://srs.ebi.ac.uk/srsbin/cgi-bin/wgetz?-e+%5b%7bsptrembl_SP_swissprot%7d-acc:XXXX%5d%7c%5bswissprot-id:XXXX%5d+-vn+2" set Defauts(UrlSRSHoan) "http://d1.crihan.fr:8080/bird/bsearch?db=YYYY&accession=XXXX" set Defauts(Threshold) 80 set Defauts(ThresholdIden) 100 set Defauts(MethodeConservation) "Threshold" set Defauts(SimiGris) 1 set Defauts(LockSeqs) 1 set Defauts(CanvasHTree) 2000 set Defauts(CanvasWTree) 2000 set Defauts(FWidthTree) 400 set Defauts(FHeightTree) 400 set Defauts(TreeBoot) 0 set Defauts(TreeNBoot) 100 set Defauts(ThresBootPC) 80 set Defauts(TypeGapTree) "pairwise" set Defauts(TypeTree) "dendrogram" set Defauts(PDBTree) 0 set Defauts(CollapseTree) 0 set Defauts(FontSizeTree) 10 set Defauts(FontSizeTreeBoot) 8 set Defauts(FontWghtTree) normal set Defauts(CanvasHSFeat) 2000 set Defauts(CanvasWSFeat) 2000 set Defauts(FWidthSFeat) 600 set Defauts(FHeightSFeat) 400 set i 0 foreach c [GammeDeCouleursRVB 10] g [GammeDeCouleursDeGris 10] { set Defauts(GammeCoul$i) $c set Defauts(GammeGris$i) $g incr i } set Defauts(Sampling) 3 set Defauts(CoulVariable) "LightSlateGray" set Defauts(Viewer) "Viandox" set Defauts(Label3DColor) [list 0.0 1.0 0.0] set Defauts(MethodeSuper) "ordali" set Defauts(Super) "CA" # peut etre 'dont' pour ne pas donwloader set Defauts(DownloadPDB) "internet" set Defauts(juju) 0 set Defauts(SaveLog) 0 set Defauts(clusdeb) 0 set Defauts(Balibase) 0 set Defauts(RemoveQuery) 0 set Defauts(Dump) 0 set Defauts(Exit) 0 set Defauts(Debug) 0 #set Defauts(UrlPdbHoan) "http://star4:8080/bird/getproduct?db=pdb&id=XXXX" set Defauts(UserDef) [list Background BackAppli BackAppliOri ForeAppli ForeAppliOri SeqFontFaml SeqFontSize SeqFontWght DeltaXScroll DeltaYScroll UrlPdbHoan UrlPdbWorld UrlPdbHome UrlSRSHome UrlSRSWorld UrlSRSHoan Threshold MethodeConservation TreeBoot TreeNBoot ThresBootPC TypeGapTree TypeTree PDBTree FontSizeTree FontWghtTree CoulVariable Label3DColor ] set Defauts(TablesDB) " - ordalie : parametres generaux d'ordalie { . key T (nom du parametre) . val T (valeur du parametre) } - seqinfo : les infos des sequences { . pk_seqinfo P . seqname T (nickname de sequence) . access T . bid T . description T . organism T . taxid I . fragment I . cgroup I . ec T . complex I . phylum T . go T . lineage T . hydrophobicity R . isoelectric R . seqori T } - seqfeat : les features des sequences { . pk_seqfeat P . ftype T (de feature (PFAM, secstr, ...)) . fstart I . fstop I . fcolor T . fscore R . fnote T . fcsys T (systeme coords, local ou global) } - ln_seqinfo_seqfeat : { . pk_seqinfo I . pk_seqfeat I } - seqali : une instance d'un seqinfo dans le contexte d'un alignement, et possede : { . pk_seqali P (pk pour chaque sequence) . pk_seqinfo I (de l'info de la sequence) . seqname T (nom affiche) . seq T (aminoacid + gap) } - mac : est un macsim { . pk_mac P . name T . description T } - ln_mac_seqali { . pk_mac I . pk_seqali I . pos I } - featali : les features des sequences DANS LE CONTEXT DE L ALIGNEMENT { . pk_featali P . ftype T (de feature (PFAM, secstr, ...)) . fstart I . fstop I . fcolor T . fscore R . fnote T . fcsys T (systeme coords, local ou global) } - ln_seqali_featali : { . pk_seqali I . pk_featali I } - clustering : definition generale du clustering { . pk_clustering P . pk_mac I . name T . methode T . zone T } - cluster : sont les paquets de sequences d'un clustering donne. { . pk_cluster P . pk_clustering I . name T } - ln_seqali_cluster : { . pk_seqali I . pk_cluster I . pos } - ln_mac_clustering : { . pk_mac I . pk_clustering I . pos I } - colmeasure : un calcul par colonne { . pk_colmeasure P . name T } - ln_mac_colmeasure { . pk_mac I . pk_colmeasure I } - colscore : conservation { . pk_colscore P . pk_colmeasure I . name T . owner T . type T . data T } - ln_cluster_colscore { . pk_cluster I . pk_colscore I } - ln_seqali_colscore { . pk_seqali I - pk_colscore I } - anno : anotations d'un mac donne { . pk_anno P . annotation T . zone T } - ln_mac_anno { . pk_mac I . pk_anno I } - pdb : stockage des PDB { . pk_pdb P . nom T . source T . header T } - chaines : contient info sur chaines { . pk_chaines P . pk_pdb I . nom T . type T } - residues : residues de chaine { . pk_residues P . pk_pdb I . pk_chaines I . rnom1l T . rnom3l T . rnmr T . type T } - atomes : info sur atome. na = numero atomique { . pk_atomes P . pk_pdb I . pk_chaines I . pk_residues I . anom T . x R . y R . z R . b R . q R . na I } - objetinit : template objet { . pk_obj P . pk_pdb I . pk_chaines I . pk_residues I . currsel I . surface I . ribbon I . ribcol T . catrace I . cacol T . atomes I . atmcol T . cpk I . pearl I . picked I . label T } " set Defauts(TablesDB1.1) " - ordalie : tableaux generaux d'ordalie { . var V64 (nom du tableau) . key V64 (nom du parametre) . val T (valeur du parametre) } - seqinfo : les infos des sequences { . pk_seqinfo P . seqname V64 (nickname de sequence) . access V64 . bid V64 . description T . organism V128 . taxid I . fragment I . cgroup I . ec V16 . complex I . phylum V16 . go T . lineage T . hydrophobicity R . isoelectric R . molweight R . seqori T } - seqfeat : les features des sequences { . pk_seqfeat P . pk_seqinfo I . ftype V32 (de feature (PFAM, secstr, ...)) . fstart I . fstop I . fcolor V32 . fscore R . fnote T . fcsys V8 (systeme coords, local ou global) } - ln_seqinfo_seqfeat : { . pk_seqinfo I . pk_seqfeat I } - mac : est un macsim { . pk_mac P . name T . description T } - seqali : une instance d'un seqinfo dans le contexte d'un alignement, et possede : { . pk_seqali P (pk pour chaque sequence) . pk_seqinfo I (de l'info de la sequence) . seqname V64 (nom affiche) . seq T (aminoacid + gap) } - ln_mac_seqali { . pk_mac I . pk_seqali I . pos I } - featali : les features des sequences DANS LE CONTEXT DE L ALIGNEMENT { . pk_featali P . ftype V32 (de feature (PFAM, secstr, ...)) . fstart I . fstop I . fcolor V32 . fscore R . fnote V256 . fcsys V8 (systeme coords, local ou global) } - ln_seqali_featali : { . pk_seqali I . pk_featali I } - clustering : definition generale du clustering { . pk_clustering P . pk_mac I . name V64 . method V64 . zone T } - ln_mac_clustering : { . pk_mac I . pk_clustering I . pos I } - cluster : sont les paquets de sequences d'un clustering donne. { . pk_cluster P . pk_clustering I . name V64 } - ln_seqali_cluster : { . pk_seqali I . pk_cluster I . pos I } - colmeasure : un calcul par colonne { . pk_colmeasure P . name V64 . method V64 } - ln_mac_colmeasure { . pk_mac I . pk_colmeasure I } - colscore : conservation { . pk_colscore P . pk_colmeasure I . name V64 . owner V64 . type V64 . cgroup T . data T } - ln_cluster_colscore { . pk_cluster I . pk_colscore I } - ln_seqali_colscore { . pk_seqali I - pk_colscore I } - annotation : anotations d'un mac donne { . pk_annotation P . pk_mac I . annotation T . zone T } - pdb : stockage des PDB { . pk_pdb P . name V4 . source T . header T } - chains : contient info sur chaines { . pk_chains P . pk_pdb I . name V1 . type V16 } - residues : residues de chaine { . pk_residues P . pk_pdb I . pk_chains I . rname1l V1 . rname3l V3 . rnbr V8 . type V16 } - atoms : info sur atome. na = numero atomique { . pk_atoms P . pk_pdb I . pk_chains I . pk_residues I . aname V4 . x R . y R . z R . b R . q R . na I } - objetinit : template objet { . pk_obj P . pk_pdb I . pk_chains I . pk_residues I . currsel I . surface I . ribbon I . ribcol V32 . catrace I . cacol V32 . atoms I . atmcol V32 . cpk I . pearl I . picked I . label V32 } " return } proc ValueAffy {Ps Fichier} { #Exemple de Fichier "[RepertoireAffyAnnot na32]/MG430A_2.0/Mouse430A_2.na32.annot.csv" set LesLignes [TabulonsSansQuote $Fichier "," ";" " " "GetListOfValues"] foreach Ligne $LesLignes { if {[regexp "$Ps" $Ligne]} { set LesElmts [split $Ligne ";"] EspionneL $LesElmts } } } proc ValueFromSerial {Texte} { return [ValueFromSeriallist [SeriallistFromSerial $Texte]] } proc ValueFromSeriallist {Liste} { return [lindex $Liste 1] } proc ValueOfTree {Tree} { return [DataSet value $Tree] } proc VanishIsolatedAgents {n {DoIt 0}} { set s $::Sequences($n) set nbC 0 for {set i 0} {$i < [string length $s]} {incr i} { set ai [string index $s $i] set isC [expr {$ai ne "."}] if {$isC} { incr nbC } else { if {$nbC > 0 && $nbC < 3} { set done 0 while {! $done} { set ai [string index $s $i-$nbC] set s [string replace $s $i $i] set s [string replace $s $i-$nbC $i-$nbC ".$ai"] set next [expr {$i+1}] if {$next >= [string length $s]} { set done 1 } elseif {[string index $s $next] ne "."} { set done 1 } else { incr i } } } set nbC 0 } } set ::Sequences($n) $s if {$DoIt == 0} { VanishIsolatedAgents $n 1 } return } proc VarianceDeLaListe {Liste {nOUnmoins1 nmoins1}} { set Mean [MoyenneDeLaListe $Liste] set n [llength $Liste] set Somme 0 foreach v $Liste { set Somme [expr $Somme + ($v - $Mean) * ($v - $Mean)] } if {[string equal -nocase $nOUnmoins1 "nmoins1"]} {return [expr $Somme * 1.0 / ($n - 1)]} return [expr $Somme * 1.0 / $n] } proc VariantSCR3 {} { foreach Fichier [lsort [glob "[RepertoireDuGenome]/atelier/SRC3/src1v*.tfa"]] { regsub ".tfa$" $Fichier "-Prot.tfa" FiPro set Entete [EnteteDuFichierTFA $Fichier] set Seq [QueLaSequenceDuFichierTFA $Fichier] set Pro [SeqNucToSeqPro $Seq] set ProtTfa [SequenceFormatTFA $Pro $Entete "protbrut"] Sauve $ProtTfa dans $FiPro } } proc VdWDe {e} { return [set ::Chm($e,vdw)] } proc VdrInteractivePattern {Sequence Strand} { # Recherche un motif en générant un mismatch (adapté récepteurs nucléaires) set Start 0 set End 0 set DR "" set SequenceOut "" set ListeDesPositionsPlus {} set ListeDesPositionsMoins {} if { $Strand == "+" } { set RegExp {[AG]G[TG]T[CG]A} append RegExp {|[CT]G[TG]T[CG]A} append RegExp {|[AG][ATC][TG]T[CG]A} append RegExp {|[AG]G[AC]T[CG]A} append RegExp {|[AG]G[TG][ACG][CG]A} append RegExp {|[AG]G[TG]T[AT]A} append RegExp {|[AG]G[TG]T[CG][TCG]} set ListeDesPositionsPlus [regexp -indices -all -inline -nocase "$RegExp" $Sequence] foreach PaireDeBornes $ListeDesPositionsPlus { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 4 } { set DR "DR3" } if { [expr $NewStart - $End] == 5 } { set DR "DR4" } if { [expr $NewStart - $End] == 7 } { set DR "DR6" } set Start $NewStart set End $NewEnd } if { [llength $ListeDesPositionsPlus] != 0 } { set SequenceOut [regexp -all -nocase "$RegExp" $Sequence] } } else { set RegExp {T[GC]A[CA]C[TC]} append RegExp {|[ACG][GC]A[CA]C[TC]} append RegExp {|T[AT]A[CA]C[TC]} append RegExp {|T[GC][CGT][CA]C[TC]} append RegExp {|T[GC]A[GC]C[TC]} append RegExp {|T[GC]A[CA][GAT][TC]} append RegExp {|T[GC]A[CA]C[AG]} set ListeDesPositionsMoins [regexp -indices -all -inline -nocase "$RegExp" $Sequence] foreach PaireDeBornes $ListeDesPositionsMoins { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 4 } { set DR "DR3" } if { [expr $NewStart - $End] == 5 } { set DR "DR4" } if { [expr $NewStart - $End] == 7 } { set DR "DR6" } set Start $NewStart set End $NewEnd } } set Retour "$DR" set Retour [string trim $Retour] return $Retour } proc VdrPHICS {OrganismeQuery Chromosome Clade Path {Projet Fichier} {LongueurVoulueDeChaqueCote 0} {DR ""} {SequenceQuery ""}} { # A partir d'une séquence d'un organisme, récuopére les séquences alignées par l'UCSC dans tous les organismes dispos # /!\ Vérifier les MAJ UCSC opour utiliser les derniéres versions des alignements ou pour intégrer de nouveaux alignements /! # Gestion des paths d'alignements é explorer en fonction de l'organisme query set I 1 set CompteurEcrit 0 set ResultatPHICS "" set ListeDeSortie {} if { $DR != "" } { set DRnumero [string range $DR 2 2] } set Chromotexte "-Chr" set FichierDesCoordonnees [open "$Path$Chromosome.pro" "r"] set FichierDesConservations [open "$Path$Chromosome$OrganismeQuery.VS.$Clade.phics" "w"] set FichierDesRepechesHuman [open "$Path$Chromosome$OrganismeQuery.VS.$Clade.hrep" "w"] set FichierDesRepechesMouse [open "$Path$Chromosome$OrganismeQuery.VS.$Clade.mrep" "w"] set ListeDeSortie {} if { $Clade == "mouse" } { set Alignement$I "/genomics/link/UCSCAlignements/mm9/" set Espece$I "mm9" incr I } gets $FichierDesCoordonnees LigneCoordonnees # Boucle de stockage du fichier de Coordonnees dans une liste while { [gets $FichierDesCoordonnees LigneCoordonnees] >=0 } { lappend ListeCoordonnees $LigneCoordonnees } close $FichierDesCoordonnees unset FichierDesCoordonnees #Routine de chargement des fichiers for {set Espece 1} {$Espece < $I} {incr Espece} { set NomEspece [set Espece$Espece] set NomAlignement [set Alignement$Espece] set Path "$NomAlignement chr $Chromosome .hg18. $NomEspece .net.axt" regsub -all -nocase {\s} $Path "" Path set AlignementChromosome [open "$Path" "r"] set ListeDesAlignementsDeCetteEspece {} Espionne "Stockage des alignements du chromosome $Chromosome $OrganismeQuery avec $Clade" while { [gets $AlignementChromosome LigneAli] >=0 } { if {$LigneAli != "" } { ScanLaListe $LigneAli SeqNum ChromosomeH AlignementStartQ EndH AlignementChromosomeT AlignementStartT AlignementEndT AlignementOrientationT ScoreAli set LigneEntete [string range $ChromosomeH 0 2 ] if { $LigneEntete == "chr" } { set FullLine "$ChromosomeH $AlignementStartQ $EndH $AlignementChromosomeT $AlignementStartT $AlignementEndT $AlignementOrientationT $ScoreAli" gets $AlignementChromosome SeqH ScanLaListe $SeqH SequenceH gets $AlignementChromosome SeqM ScanLaListe $SeqM SequenceM set FullLine "$FullLine $SequenceH $SequenceM" lappend ListeDesAlignementsDeCetteEspece $FullLine set $ChromosomeH "" } } } close $AlignementChromosome unset AlignementChromosome set NumeroLigneEntree -1 set PlusAucuneChanceDeTrouver "Faux" Espionne "Balayage des coordonnees en entree" foreach Coordonnee $ListeCoordonnees { incr NumeroLigneEntree set NomEspece [set Espece$Espece] set QuelMismatchs1 " " set QuelMismatchs1 " " set alias "" ScanLaListe $Coordonnee Acc Deb Fin Orientation Distance ExonOutron UtrOuCDS DebutExonOutron FinExonOuIntron DebutOuFinExonOuIntron DistanceAlaBorneDeExonOuIntron ChromosomeQuery DRQuery IdQuery StartQuery EndQuery OrientationQuery SequenceQuery ScoreQuery NbMismatchQuery QuelsMismatchs gID displayID alias set CoordonneeCopy $Coordonnee set Coordonnee "$ChromosomeQuery $IdQuery $DRQuery $StartQuery $EndQuery $OrientationQuery $SequenceQuery $ScoreQuery $NbMismatchQuery $QuelsMismatchs" set LongueurQ [string length $SequenceQuery] set Stockage $ResultatPHICS set input 0 set RandomOuPas "NON" set Conservation 0 set ConservesSansGap 0 set ConservesMaisGap 0 set NonConserves 0 set ConservesTotaux 0 set Retenus 0 set NonRetenus 0 set LongueurSequenceTotale [expr $EndQuery - $StartQuery] foreach Alignement $ListeDesAlignementsDeCetteEspece { set Conservation 0 ScanLaListe $Alignement ChromosomeH AlignementStartQ AlignementEndQ AlignementChromosomeT AlignementStartT AlignementEndT AlignementOrientationT ScoreAli SeQ SeT set RandomOuPas "Complet" if { [regexp -- {random} $AlignementChromosomeT] } { set RandomOuPas "Random" } if { $StartQuery >= $AlignementStartQ && $EndQuery <= $AlignementEndQ} { if { $OrientationQuery == "-" } { set SequenceRegexp [NucToReverseAndComplementNuc $SequenceQuery] } else { set SequenceRegexp $SequenceQuery } set ListeDistanceAvantQueryAvecGaps [regexp -indices -all -inline -nocase "$SequenceRegexp" $SeQ] # Si on ne retrouve pas la séquence humaine, il y a un gap chez human # On récup alors une portion plus large que la séquence souris qu'on passera au crible du pattern # si on retrouve une signature VDR (2 MM allowed) , on garde. if { [llength $ListeDistanceAvantQueryAvecGaps] == 0 } { set StartRelatifAvecEventuellementDesGapsQ [expr $StartQuery - $AlignementStartQ] if { [expr $StartRelatifAvecEventuellementDesGapsQ - 20] <= 0 } { set StartBout 0 } else { set StartBout [expr $StartRelatifAvecEventuellementDesGapsQ - 20] } set MouseExtend [string range $SeT $StartBout [expr $StartRelatifAvecEventuellementDesGapsQ + $LongueurQ + 20] ] regsub -all -nocase {\-} $MouseExtend "" MouseExtend set MouseVdrPattern "" set MouseVdrPattern [VdrInteractivePattern $MouseExtend $AlignementOrientationT] if { [string range $MouseVdrPattern 0 1] == "DR" } { puts $FichierDesRepechesHuman "Human$IdQuery $DRQuery $AlignementChromosomeT None None $AlignementOrientationT $MouseVdrPattern $SequenceQuery $gID $displayID $alias" } break } # Si une séquence occure plusieurs fois dans le meme alignement, on scan pour chaque occurence # On aura donc des séquences traitées autant de fois qu'elles ont de duplicons donc des doublons dans # le fichier en sortie mais donnannt une idée des génes multirégulés set Multi 0 foreach HitRegexp $ListeDistanceAvantQueryAvecGaps { incr Multi if { $Multi > 1 } { Espionne "Multiii !" } ScanLaListe $HitRegexp StartExp EndExp set DistanceAvantQueryAvecGaps $StartExp set DistanceAvantTargetAvecGaps $StartExp set SequenceAvantQueryAvecGaps [string range $SeQ 0 [expr $DistanceAvantQueryAvecGaps - 1]] set SequenceAvantTargetAvecGaps [string range $SeT 0 [expr $DistanceAvantQueryAvecGaps - 1]] regsub -all -nocase {\-} $SequenceAvantQueryAvecGaps "" SequenceAvantQuerySansGaps regsub -all -nocase {\-} $SequenceAvantTargetAvecGaps "" SequenceAvantTargetSansGaps set DistanceAvantQuerySansGaps [ llength [split $SequenceAvantQuerySansGaps "" ]] set DistanceAvantTargetSansGaps [ llength [split $SequenceAvantTargetSansGaps "" ]] set NbGapsBeforeQ [expr $DistanceAvantQueryAvecGaps - $DistanceAvantQuerySansGaps] set NbGapsBeforeT [expr $DistanceAvantTargetAvecGaps - $DistanceAvantTargetSansGaps] set SequenceQ [string range $SeQ $DistanceAvantQueryAvecGaps [expr $DistanceAvantQueryAvecGaps - 1 + $LongueurQ] ] set SequenceT [string range $SeT $DistanceAvantQueryAvecGaps [expr $DistanceAvantQueryAvecGaps - 1 + $LongueurQ] ] set ReverseQ [NucToReverseAndComplementNuc $SequenceQ] set ReverseT [NucToReverseAndComplementNuc $SequenceT] set StartT [expr $AlignementStartT + $DistanceAvantTargetSansGaps] set EndT [expr $StartT + $LongueurQ - 1] if { $AlignementOrientationT == "-" } { set ChromoSize [ChromoSize $Clade "mm9" $AlignementChromosomeT] set StartT [ expr $ChromoSize - $StartT] set EndT [expr $StartT + $LongueurQ - 1] } set DRQuery "DR3" if { [ regexp -- {-} $SequenceT ] } { # S'il y a des gaps peu nombreux et centrés, éa peut juste changer la classe de DR ==> On les stocke set GapsChezMouse 1 incr ConservesMaisGap 1 set ListeDesGapsSequencesT [regexp -indices -all -inline -nocase {\-} $SequenceT] set NombreDeGapsSequenceT [llength $ListeDesGapsSequencesT] if { $DRQuery == "DR4" && $NombreDeGapsSequenceT == 1 } { puts $FichierDesRepechesMouse "Human$IdQuery $DRQuery $AlignementChromosomeT $StartT $EndT $AlignementOrientationT $SequenceT GapsT$NombreDeGapsSequenceT $SequenceQ $gID $displayID $alias" } if { $DRQuery == "DR6" && $NombreDeGapsSequenceT <= 3 && $NombreDeGapsSequenceT >= 2} { puts $FichierDesRepechesMouse "Human$IdQuery $DRQuery $AlignementChromosomeT $StartT $EndT $AlignementOrientationT $SequenceT GapsT$NombreDeGapsSequenceT $SequenceQ $gID $displayID $alias" } } else { set GapsChezMouse 0 } if { !$GapsChezMouse } { set DRnumero [string range $DRQuery 2 2] set ConsensusCheck [RGKTSA $SequenceT $DRnumero] set ReverseCheck [RGKTSA $ReverseT $DRnumero] set NbMismatchT [llindex [split $ConsensusCheck "/"] 1] set NbMismatchRT [llindex [split $ReverseCheck "/"] 1] if { $NbMismatchT > $NbMismatchRT } { set ConsensusCheck $ReverseCheck set SequenceT $ReverseT } set GapsOuPas "SansGaps" } else { set ConsensusCheck "X/X/X" set GapsOuPas "AvecGaps" } set ResultatPHICS "$AlignementChromosomeT:$StartT-$EndT/$AlignementOrientationT/$GapsOuPas/$SequenceT/$ConsensusCheck" break } unset ListeDistanceAvantQueryAvecGaps } } lappend ListeDeSortie "$Coordonnee $ResultatPHICS $gID $displayID $alias" } set Long [llength $ListeDeSortie] Espionne $Long unset ListeDesAlignementsDeCetteEspece } #Routine de vidage de la liste de sortie dans le fichier de sortie set Ecrit 0 foreach LigneSortie $ListeDeSortie { incr Ecrit puts $FichierDesConservations $LigneSortie } close $FichierDesConservations close $FichierDesRepechesMouse close $FichierDesRepechesHuman } proc VdrPatternMouse {chr} { # Recherche un motif en générant un mismatch (adapté récepteurs nucléaires) set FichierSouris "/tmp/Conservation/SequencesMouse.tfa" set FichierDesDR3 "/tmp/Conservation/DR3-Mouse-Chr$chr.txt" set FichierDesDR4 "/tmp/Conservation/DR4-Mouse-Chr$chr.txt" set FichierDesDR6 "/tmp/Conservation/DR6-Mouse-Chr$chr.txt" if { [file exists $FichierDesDR3] } { file delete $FichierDesDR3 } if { [file exists $FichierDesDR4] } { file delete $FichierDesDR4 } if { [file exists $FichierDesDR6] } { file delete $FichierDesDR6 } set DR3 0 set DR4 0 set DR6 0 while { [gets $FichierSouris Ligne] >=0 } { array unset SeqTFA array set SeqTFA [readFasta $Ligne 0] set Acc [lindex $SeqTFA(index) 0] set RegExp {[AG]G[TG]T[CG]A} append RegExp {|[CT]G[TG]T[CG]A} append RegExp {|[AG][ATC][TG]T[CG]A} append RegExp {|[AG]G[AC]T[CG]A} append RegExp {|[AG]G[TG][ACG][CG]A} append RegExp {|[AG]G[TG]T[AT]A} append RegExp {|[AG]G[TG]T[CG][TCG]} set ListeDesPositionsPlus [regexp -indices -all -inline -nocase "$RegExp" $SeqTFA($Acc,sequence)] set RegExp {T[GC]A[CA]C[TC]} append RegExp {|[ACG][GC]A[CA]C[TC]} append RegExp {|T[AT]A[CA]C[TC]} append RegExp {|T[GC][CGT][CA]C[TC]} append RegExp {|T[GC]A[GC]C[TC]} append RegExp {|T[GC]A[CA][GAT][TC]} append RegExp {|T[GC]A[CA]C[AG]} set ListeDesPositionsMoins [regexp -indices -all -inline -nocase "$RegExp" $SeqTFA($Acc,sequence)] set Start 0 set End 0 set DR3f [open $FichierDesDR3 "w"] set DR4f [open $FichierDesDR4 "w"] set DR6f [open $FichierDesDR6 "w"] foreach PaireDeBornes $ListeDesPositionsPlus { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 4 } { incr DR3 puts $DR3f "$DR3 $Start $NewEnd +" } if { [expr $NewStart - $End] == 5 } { incr DR4 puts $DR4f "$DR4 $Start $NewEnd +" } if { [expr $NewStart - $End] == 7 } { incr DR6 puts $DR6f "$DR6 $Start $NewEnd +" } set Start $NewStart set End $NewEnd } set Start 0 set End 0 foreach PaireDeBornes $ListeDesPositionsMoins { set NewStart [expr [lindex $PaireDeBornes 0] + 1] set NewEnd [expr [lindex $PaireDeBornes 1] + 1] if { [expr $NewStart - $End] == 4 } { incr DR3 puts $DR3f "$DR3 $Start $NewEnd -" } if { [expr $NewStart - $End] == 5 } { incr DR4 puts $DR4f "$DR4 $Start $NewEnd -" } if { [expr $NewStart - $End] == 7 } { incr DR6 puts $DR6f "$DR6 $Start $NewEnd -" } set Start $NewStart set End $NewEnd } } close $DR3f close $DR4f close $DR6f } proc VeFromSbgpDatabase {{V ""} {P ""} {S ""}} { global VE set GetFirst 1 if {$V=="" && $P=="" && $S==""} { set GetFirst 0 set V "%" } set SiteVe "http://130.79.76.61/TREX/steroids/steroids_list/Cloning/cloning_list/Vetxt.php" set Url $SiteVe append Url "?ve=" append Url $V append Url "&protein=" append Url $P append Url "&scientist=" append Url $S set LesLignes {} HttpCopy $Url LesLignes if {$LesLignes=={}} { return "" } set Entete [lindex $LesLignes 0] set LesLignes [lrange $LesLignes 1 end] if {$Entete==""} { set Entete [lindex $LesLignes 0] set LesLignes [lrange $LesLignes 1 end] } if {$GetFirst} { return [lindex $LesLignes 0] } if {[info exists VE]} {unset VE} set Precedent "" foreach NomCol [split $Entete ";"] { regsub -all "#" $NomCol "" NomCol set NomCol [string trim $NomCol] regsub -all " " $NomCol "_" NomCol if {$NomCol==""} { set NomCol "${Precedent}_2" } lappend LesNomsCols $NomCol } set VE(ListOf,Columns) $LesNomsCols set NLig 0 foreach Ligne $LesLignes { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } incr NLig set LesVals [split $Ligne ";"] foreach NomCol $LesNomsCols Val $LesVals { if {$NomCol=="VE"} { set ValVE $Val set VE($ValVE,Line) $Ligne lappend VE(ListOf,VE) $ValVE } set VE($NLig,$NomCol) $Val set VE($ValVE,$NomCol) $Val } } return $NLig } proc VecItem {Fichier} { if { ! [file exists $Fichier]} { return {} } set LesXYZP {} foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z0-9;]} $Ligne]} { continue } if { [regexp -nocase {^\#} $Ligne]} { continue } if {[regexp {;} $Ligne] || [regexp {\:=} $Ligne]} { if {[info exists XYZP]} { lappend LesXYZP $XYZP unset XYZP } } if {[regexp {;} $Ligne]} { continue } if {[regexp {\:=} $Ligne]} { regsub {\:=} $Ligne " " Ligne scan $Ligne "%s %s %s" Objet MotVec ItemOuDots if { ! [regexp -nocase "vec" $MotVec]} { FaireLire "$Ligne is wrong" } set Item [regexp -nocase "^item" $ItemOuDots] set Dots [regexp -nocase "^dots" $ItemOuDots] set XYZP {} set y 0.0 continue } regsub -all {[\t\,]} $Ligne " " Ligne set y [expr $y+1] set z 0.0 scan $Ligne "%s %f %f %f" PL x y z set PL [string tolower $PL] if {$Item} { lappend XYZP $z $y $x $PL } if {$Dots} { lappend XYZP $x $y $z p lappend XYZP $x $y $z l } } return $LesXYZP } proc VectDeLaRosace {} { global OrdEtcDir TBlosum ListeDesAcidesAmines # set f [file join $OrdEtcDir pam250.bla] set f [file join $OrdEtcDir blosum62.dat] InitTBlosum $f array set TPam [array get TBlosum] #set laa [lrange $ListeDesAcidesAmines 0 end-1] set laa [split "ARNDCQEGHILKMFPSTWYV" ""] set lx "2 20 20" foreach a $laa { foreach b $laa { lappend lx [set TPam($a,$b)] } } set X [join $lx " "] lassign [nist_pca $X] Evals Evecs set Evals [lrange $Evals 3 end] AnalyseValeursPropres $Evals for {set k 0} {$k < 20} {incr k} { set lv [lrange $Evecs [expr {3 + $k*20}] [expr {22 + $k*20}]] for {set i 0} {$i < 20} {incr i} { lappend Vec($i) [lindex $lv $i] } } set Ev1 $Vec(0) set Ev2 $Vec(1) set Ev3 $Vec(2) package require sqlite for {set i 1} {$i < 4} {incr i} { puts "\n $i vecteur propre" puts "==================" lassign [AnalyseVecteursPropres [set Ev$i]] k$i cp if {$i != -1} { puts "Test -1.0 * Vect. Propre" set En$i [V_SV -1.0 * [set Ev$i]] lassign [AnalyseVecteursPropres [set En$i]] kn$i cn if {$cn > $cp} { set Ev$i [set En$i] set k$i [set kn$i] } } set Av$i [VecteurDeAAIndex [set k$i]] } FittingParRotation $Ev1 $Ev2 $Ev3 $Av1 $Av2 $Av3 exit } proc Vecteur {args} { return $args } proc VecteurDeAAIndex {pk} { return [lindex [$::db eval {select vecteur from aaindex where pk_aaindex = $pk}] 0] } proc VecteurVRP {AA} { global FichierGscopeVRP global VecteurVRP if {[info exists VecteurVRP($AA)]} { return [set VecteurVRP($AA)] } if {[info exists VecteurVRP("EstCharge")]} { return [set VecteurVRP(*)] } foreach Ligne [LesLignesDuFichier "$FichierGscopeVRP"] { scan $Ligne "%s %f %f" A X Y set VecteurVRP($A) "$X $Y" } set VecteurVRP("EstCharge") "0.0 0.0" return [VecteurVRP $AA]] } proc Vectoriel {u v} { #lM Prdt Vectoriel definit pour 3d. #lM ... on va plus vite .... set zu 0.0 ; set zv 0.0 lassign $u xu yu zu lassign $v xv yv zv set xw [expr {$yu*$zv - $zu*$yv}] set yw [expr {$zu*$xv - $xu*$zv}] set zw [expr {$xu*$yv - $yu*$xv}] return [list $xw $yw $zw] } proc VectorsRecuDeDidier {} { foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/vecteurs/VectorsRecuDeDidier.txt"] { if {[regexp ">" $Ligne]} { scan $Ligne "%s" Access regsub ">" $Access "" Access if {[info exists Seq($Access)]} { FaireLire "dejavu $access" } set Seq($Access) "" lappend LesAccess $Access } else { set Ligne [string toupper $Ligne] if {[regexp -nocase {[^atgc]} $Ligne]} { FaireLire $Ligne } append Seq($Access) $Ligne } } foreach Access $LesAccess { set ADN $Seq($Access) set F [FindVector $Access] if {$F!=""} { set Moi [QueLaSequenceDuFichierTFA $F] if { ! [string equal -nocase $ADN $Moi]} { VoisinADN ">[file tail $F]\n$ADN\n>Moi\n$Moi" AfficheVariable "$F" "AvecRetour" } continue } set L [string length $ADN] set TFA [SequenceFormatTFA $ADN "$Access cloning vector $L bp. (from Didier)"] Sauve $TFA dans "[RepertoireDuGenome]/vecteurs/pDEST/$Access.tfa" Espionne "$Access $L" } } proc Verbose_Mode {{Quoi ""}} { Wup "Permet de dire et positionner le mode Verbose du programme" global Verbose_Mode if {$Quoi != ""} { if {$Quoi != "0" && $Quoi != "1"} { #Par defaut on dit non Verbose set Verbose_Mode 0 } else { set Verbose_Mode $Quoi } } else { if {[info exists Verbose_Mode]} { return $Verbose_Mode } else { #Par defaut on dit non Verbose set Verbose_Mode 0 } } return $Verbose_Mode } proc Verif1 {} { #rr a renomme proc Verif set Fichier1 "[RepertoireDuGenome]/fichesannotation/bacteria" set Fichier2 "[RepertoireDuGenome]/fichesannotation/eukaryota" foreach Ligne1 [LesLignesDuFichier $Fichier1] { scan $Ligne1 "%s %s" A B foreach Ligne2 [LesLignesDuFichier $Fichier2] { scan $Ligne2 "%s %s" C D if {$A == $C} { if {$B == 0 && $D == 1} { Espionne "$A $C $B $D" } } } } } proc Verif2 {} { set Fichier1 "[RepertoireDuGenome]/fichesannotation/mycobacterium_bovis" set Fichier2 "[RepertoireDuGenome]/fichesannotation/mycobacterium_tuberculosis" lappend Liste $Fichier1 lappend Liste $Fichier2 foreach Fichier $Liste { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s" Nom Presence lappend LaPresenceOrganismeDuNom($Nom) $Presence } } } proc VerifAnnaick {FichierCourtes} { foreach Ligne [LesLignesDuFichier $FichierCourtes] { if {$Ligne==""} {continue} set LesData [split $Ligne "\t"] set DD [lindex $LesData 0] if {![info exists Vu($DD)]} {set Vu($DD) 1} else {Espionne $DD} set AccessProt [InterrogeProtAndmRNAChoisis $DD ProteineChoisie Access] set Orga [InterrogeProtAndmRNAChoisis $DD OrganismeChoisi] if {$AccessProt=="NOPROTEIN" || $AccessProt==""} { continue } elseif {$Orga=="Homo sapiens"} {set Prot 1; Espionne "$DD $AccessProt $Orga"} if {$AccessProt!="NOPROTEIN" && $AccessProt!="" && $Orga!="Homo sapiens"} {set Prot 1; Espionne "$DD $AccessProt $Orga"} } } proc VerifBlastAffy {} { foreach Nom [ListeDesPABs] { set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {[file exists $FichiermRNA]} { set FichierBlastmRNA "[RepertoireDuGenome]/BlastnHumanmRNAaffy/$Nom" if {![file exists $FichierBlastmRNA]} {Espionne "$FichierBlastmRNA doesn t exist";continue} continue } elseif {[file exists $FichierProttfa]} { set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] set H 0 if {[regexp "from CONTIG" $EnteteProttfa]} { if {[regexp "from Homo sapiens from CONTIG" $EnteteProttfa]} {set H 1} } elseif {[regexp "from Homo sapiens" $EnteteProttfa] || [regexp "from mitochondrion Homo" $EnteteProttfa]} {set H 1} if {$H==1} { set FichierBlastProt "[RepertoireDuGenome]/tBlastNHumanProtAffy/$Nom" if {![file exists $FichierBlastProt]} {Espionne "$FichierBlastProt doesn t exist"; continue} continue } } set FichierBlastNucmask "[RepertoireDuGenome]/BlastNNucmaskAffy/$Nom" if {![file exists $FichierBlastNucmask]} {Espionne "$FichierBlastNucmask doesn t exist"} } } proc VerifDansEVItest {} { #rR a renomme cette proc Verif set nbseq 0; set nbpab 0; set nbnuc 0; set nbprotembl 0; set nbprotemblrecupere 0 set FichierAttritout "/genomics/link/EVItest/parser/AttriToutVf" foreach Ligne [LesLignesDuFichier $FichierAttritout] { if {[regexp "^>" $Ligne]} {incr nbseq} } set FichierBornePabs "/genomics/link/EVItest/fiches/bornesdespabs" foreach Ligne2 [LesLignesDuFichier $FichierBornePabs] { scan $Ligne2 "%s" NomPab incr nbpab } set RepertoireNuctfa "/genomics/link/EVItest/nuctfa" foreach F [glob -nocomplain "$RepertoireNuctfa/EVI*"] { incr nbnuc } set RepertoireProtemblR "/genomics/link/EVItest/protemblRecupere" foreach F [glob -nocomplain "$RepertoireProtemblR/EVI*"] {incr nbprotemblrecupere} set RepertoireProtembl "/genomics/link/EVItest/protembl" foreach F [glob -nocomplain "$RepertoireProtembl/EVI*"] { incr nbprotembl } #set RepertoireProtemblR "/genomics/link/EVI3/protemblreserve" # foreach F [glob -nocomplain "$RepertoireProtemblR/EVI*"] #set Queue [file tail $F] #set LesMots [split $Queue "_"] #set Nom [lindex $LesMots 0] #if {[info exists DejaVuR($Nom)]} {incr DejaVuR($Nom)} else {set DejaVuR($Nom) 1} set RepertoireProtembl "/genomics/link/EVItest/protembl" foreach F [glob -nocomplain "$RepertoireProtembl/EVI*"] { set Queue [file tail $F] set LesMots [split $Queue "_"] set Nom [lindex $LesMots 0] if {[info exists DejaVu($Nom)]} { incr DejaVu($Nom) } else { set DejaVu($Nom) 1 } } Espionne [array get DejaVu] Espionne "nbseq $nbseq" Espionne "nbpab $nbpab" Espionne "nbnuc $nbnuc" #Espionne [array size DejaVu] #Espionne [array size DejaVuR] Espionne "nbprotemblrecupere= $nbprotemblrecupere" Espionne "nbprotembl= $nbprotembl" } proc VerifDesCopains {} { global RepertoireDuGenome global NotreOS foreach Nom [ListeDesPABs] { set FichierDesCops "$RepertoireDuGenome/tfasdescopains/$Nom" if { ! [file exists $FichierDesCops]} { continue } set n 0 set LesPositions {} foreach Ligne [LesLignesDuFichier $FichierDesCops] { if { ! [regexp "^>" $Ligne]} { continue } incr n if {[regexp "OS\:$NotreOS" $Ligne]} { lappend LesPositions [format "%3d" $n] } } if {$n<40} { continue } Espionne "$Nom $n [join $LesPositions " "]" } } proc VerifEst {{Liste ""}} { set RepNuctfa "[RepertoireDuGenome]/nuctfa" set RepBlastnest "[RepertoireDuGenome]/blastnest-mouse" set FichierSelectedEST "[RepertoireDuGenome]/fiches/SelectedEST" if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } set total 0; set noest 0; set passeq 0; set pbblast1 0; set pbblast2 0; set pbest 0 set cas1 0; set cas2 0; set cas3 0; set cas4 0 foreach Ligne [LesLignesDuFichier $FichierSelectedEST] { scan $Ligne "%s %s" Name Acc if {$Acc=="NoESTFound"} { if {[regexp "bidon" [lindex [LesLignesDuFichier $RepNuctfa/$Name] 0]]} { continue } incr noest #set Ligne $Name; lappend LesLignes $Ligne lappend LesNamesSsEst $Name } } set LesNamesSsEst [ListeSansDoublon $LesNamesSsEst] #SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/LesNamesSsEst2" foreach Nom $Liste { set cestbon1 0; set cestbon2 0; set nohits1 0; set nohits2 0 regsub "EVI" $Nom "" NomSsEvi incr total Espionne $Nom set H "$RepNuctfa/$Nom" set LesLignes [LesLignesDuFichier $H] if {[regexp "bidon" [lindex $LesLignes 0]]} { incr passeq; Espionne "pas seq" continue } set F "$RepBlastnest/$Nom" if {![file exists $F]} { incr pbblast1 Espionne "fichier blastnest1 nexiste pas"; } else { foreach Ligne [LesLignesDuFichier $F] { if {[regexp {^Gap Penalties} $Ligne]} { set cestbon1 1 break } if {[regexp "No hits found" $Ligne]} { set nohits1 1 } } if {!$cestbon1} { incr pbblast1 Espionne "fichier blastnest1 pas bon" } } set G "$RepBlastnest/$Nom.reduced" if {![file exists $G]} { incr pbblast2 Espionne "fichier blastnest2 nexiste pas"; } else { foreach Ligne [LesLignesDuFichier $G] { if {[regexp {^Gap Penalties} $Ligne]} { set cestbon2 1 break } if {[regexp "No hits found" $Ligne]} { set nohits2 1 } } if {!$cestbon2} { incr pbblast2 Espionne "fichier blastnest2 pas bon" } } if {$nohits1 && $nohits2} {incr cas1;Espionne "cas1"} if {!$nohits1 && !$nohits2} {incr cas2;Espionne "cas2"} if {$nohits1 && !$nohits2} {incr cas3;Espionne "cas3"} if {!$nohits1 && $nohits2} {incr cas4;Espionne "cas4"} foreach elmt $LesNamesSsEst { if {$elmt==$Nom} { if {!$nohits1} { Espionne "pb dans fichier Selectedest 1" incr pbest } if {!$nohits2} { Espionne "pb dans fichier Selectedest 2" incr pbest } } } } Espionne "total $total";Espionne "passeq $passeq";Espionne "noest $noest";Espionne "pbblast1 $pbblast1";Espionne "pbblast2 $pbblast2";Espionne "pbest $pbest" Espionne "cas1 $cas1";Espionne "cas2 $cas2";Espionne "cas3 $cas3";Espionne "cas4 $cas4" } proc VerifFichierAccessChoisis {FichierAccessChoisis FichierDesPABs FichierSortie} { foreach Ligne [LesLignesDuFichier $FichierAccessChoisis] { if {$Ligne==""} {continue} set DD [lindex [split $Ligne "\t"] 0 ] Espionne $DD set Vu($DD) 1 } #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] set Liste "" foreach Nom $L { if {![info exists Vu($Nom)]} {lappend Liste $Nom} } Espionne "nb pabs des 1954 absents de FichierAccessChoisis: [llength $Liste]" SauveLesLignes $Liste dans $FichierSortie } proc VerifFichierTfaDesQuery {} { set FichierOut "/genomics/link/SpliRetMouse/FichiersModifUnique/FichierTfaDesQuery" foreach Ligne [LesLignesDuFichier $FichierOut] { if {[regexp "^>" $Ligne]} { set cluster [lindex [split $Ligne " "] 0] if {[info exists DejaVu($cluster)]} { incr DejaVu($cluster) } else { set DejaVu($cluster) 1 } } } foreach Clef [array names DejaVu] { if {$DejaVu($Clef)>1} { Espionne "$Clef $DejaVu($Clef)" } } } proc VerifFungi {} { set NbFungi 0 foreach Ligne [LesLignesDuFichier "/genomics/link/BaDe/banques/Proteome201501_TaillesDesOs.txt"] { set LesMots [split $Ligne "_"] set TaxId [lindex $LesMots 2] set EstDansProteome($TaxId) 1 if {[QuestionDeScience EVImm "ret JeSuisTonAncetre Fungi $TaxId"]} { incr NbFungi } } set NbHitFungi 0 foreach Ligne [LesLignesDuFichier "/genomics/link/BaDe/taxobla/BaDe00007"] { set LesMots [LesMotsDuTexte $Ligne] set TaxId [lindex $LesMots 2] set OS [lindex $LesMots 3] if {[QuestionDeScience EVImm "ret JeSuisTonAncetre Fungi $TaxId"]} { incr NbHitFungi } } Espionne "$NbFungi $NbHitFungi" } proc VerifInterproscan {} { foreach Box [ListeDesPABs] { if {![file exists "[RepertoireDuGenome]/Interproscan/$Box.is"]} { Espionne $Box } } } proc VerifJumeauxAdd {FichierEntree FichierJum} { set n 0 foreach Ligne [LesLignesDuFichier $FichierEntree] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach J $LesJumeaux {set Vu($J) 1} } foreach Ligne [LesLignesDuFichier $FichierJum] { if {$Ligne==""} {continue} set LesElts [split $Ligne " "] foreach Elt $LesElts { if {![info exists Vu($Elt)]} {incr n;Espionne $Elt} } } return $n } proc VerifLongSqMSF {file} { global LNOrdali global Sequence set pab [file tail $file] DecortiqueUnMSF $file LNOrdali Sequences foreach seq $LNOrdali { regsub -all "\\." [set Sequences($seq)] "" seq$seq set lg [string length [set seq$seq]] if {$lg > 3000} { puts "pour $pab, on a sq > 3000" #puts "pour $seq, on a $lg" break } } return 1 } proc VerifMasking {{Liste ""}} { set passeq 0; set manquefichier 0; set pbout 0; set pbrm 0; set pbtmp 0; set pbblast 0 set RepNucmask "[RepertoireDuGenome]/nucmask" if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set onassextension 0; set onam 0; set onarm 0; set onamrm 0; set onablastnhtg 0; set onamasked 0; set onaout 0; set onatmp 0; set onatmpcat 0; set onatmpstderr 0 Espionne "" Espionne "$Nom" set cestbon 0; set nbfichier 0 set H "[RepertoireDuGenome]/nuctfa/$Nom" set LesLignes [LesLignesDuFichier $H] if {[regexp "bidon" [lindex $LesLignes 0]]} { incr passeq; Espionne "pas seq" continue } foreach G [glob -nocomplain "$RepNucmask/$Nom*"] { set Queue [file tail $G] if {$Queue==$Nom} {set onassextension 1} if {$Queue=="$Nom.m"} {set onam 1} if {$Queue=="$Nom.rm"} {set onarm 1} if {$Queue=="$Nom.mrm"} {set onamrm 1} if {$Queue=="$Nom.blastnhtg"} {set onablastnhtg 1} if {$Queue=="$Nom.masked"} {set onamasked 1} if {$Queue=="$Nom.out"} {set onaout 1} if {$Queue=="$Nom.tmp"} {set onatmp 1} if {$Queue=="$Nom.tmp.cat"} {set onatmpcat 1} if {$Queue=="$Nom.tmp.stderr"} {set onatmpstderr 1} #Espionne $G incr nbfichier } if {$nbfichier < 10} { Espionne "manque un fichier" incr manquefichier if {!$onassextension} {Espionne "manque ssextension"} if {!$onam} {Espionne "manque m"} if {!$onarm} {Espionne "manque rm"} if {!$onamrm} {Espionne "manque mrm"} if {!$onablastnhtg} {Espionne "manque blastnhtg"} if {!$onamasked} {Espionne "manque masked"} if {!$onaout} {Espionne "manque out"} if {!$onatmp} {Espionne "manque tmp"} if {!$onatmpcat} {Espionne "manque tmpcat"} if {!$onatmpstderr} {Espionne "manque tmpstderr"} } set E "$RepNucmask/$Nom.out" if {![file exists $E]} { incr pbout Espionne "fichier out nexiste pas" } else { set LesLignes [LesLignesDuFichier $E] set long [llength $LesLignes] if {$long<2} { incr pbout Espionne "fichier out pas complet" } } set J "$RepNucmask/$Nom.rm" if {![file exists $J]} { incr pbrm Espionne "fichier rm nexiste pas" } else { set LesLignes2 [LesLignesDuFichier $J] set premiereligne [lindex $LesLignes2 0] set LesMots [split $premiereligne "."] if {[lindex $LesMots 1]==""} { incr pbrm Espionne "pas fin rm" } } set K "$RepNucmask/$Nom.tmp" if {![file exists $K]} { incr pbtmp Espionne "fichier tmp nexiste pas" } else { set LesLignes3 [LesLignesDuFichier $K] set deuxiemeligne [lindex $LesLignes3 1] if {[regexp {[a-z]} $deuxiemeligne]} { incr pbtmp Espionne "pas bon tmp" } } set F "$RepNucmask/$Nom.blastnhtg" if {![file exists $F]} { incr pbblast Espionne "fichier blastnhtg nexiste pas"; } else { foreach Ligne [LesLignesDuFichier $F] { if {[regexp {^Gap Penalties} $Ligne]} { set cestbon 1 break } } #if {$cestbon} {Espionne "fichier blastnhtg bon"} if {!$cestbon} { incr pbblast Espionne "fichier blastnhtg pas bon" } } } Espionne "passeq $passeq" Espionne "manquefichier $manquefichier" Espionne "pbout $pbout" Espionne "pbrm $pbrm" Espionne "pbtmp $pbtmp" Espionne "pbblast $pbblast" } proc VerifMemeNombreLettres {} { set Fichier "[RepertoireDuGenome]/transcriptomique/MetaCluster/Ravi/TfaAllexp_cluster.tfa" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp ">" $Ligne]} {continue} set nombre [string length $Ligne] #Espionne $nombre lappend LesComptes $nombre } set LesComptes [ListeSansDoublon $LesComptes] EspionneL $LesComptes if {[llength $LesComptes]>1} {Espionne "probleme"} } proc VerifMiRNAdeMarianna {} { foreach Nom [ListeDesPABs] { set AccessRefseq [ExtraitInfo $Nom "AccessRefseq:"] lappend NomsDe($AccessRefseq) $Nom } foreach Ligne [LesLignesDuFichier "/genomics/link/MiRNAkarali/DeMarianna/unique.lst"] { scan $Ligne "%s" Access if {[info exists NomsDe($Access)]} { continue } set LE [LaSequenceDesBanques $Access] Espionne $Access EspionneL $LE } exit } proc VerifPABLoc {FichierLoc} { foreach Ligne [LesLignesDuFichier $FichierLoc] { if {$Ligne==""} {continue} set LesElts [split $Ligne "\t"] set DD [lindex $LesElts 0] if {![info exists Vu($DD)]} {set Vu($DD) 1; lappend LesDD $DD} } Espionne [llength $LesDD] #return $LesDD } proc VerifPresenceAddSeq {pab} { global laddSeq global PipeCollection set best "leon" if {[info exists laddSeq] && $laddSeq ne ""} { if {$PipeCollection} { set fileBestMsf [file join [RepertoireDuGenome] "leon" $pab] set fileNormd [file join [RepertoireDuGenome] "normd" $pab] } else { set fileBestMsf "[file rootname $pab].leon.msf" set fileNormd "[file rootname $pab].normd" } set lignes [LesLignesDuFichier $fileBestMsf] set i 1 foreach e $laddSeq { if {[lsearch -regexp $lignes "Name: $e"] != -1} { continue } else { set best [string tolower [DefineBestMsfClRasPipe $fileNormd]] } } } return $best } proc VerifPresencePDB {file pdb} { global LesNomsDesSequencesDansLOrdre global Sequences if {[info exists LesNomsDesSequencesDansLOrdre]} {unset LesNomsDesSequencesDansLOrdre} if {[info exists Sequences]} {unset Sequences} DecortiqueUnMSF $file LesNomsDesSequencesDansLOrdre Sequences if {[lsearch $LesNomsDesSequencesDansLOrdre $pdb] == -1} { return 0 } else { return 1 } } proc VerifProtAccMouse {} { set M 0 set H 0 set R 0 set T 0 foreach I [RetChip2 ListOf Index] { set liste {} set Des [RetChip2 $I "description_customer"] set Ac1 [RetChip2 $I "refseq_PIQOR"] set Ac2 [RetChip2 $I "DNA_acc"] set Ac4 [RetChip2 $I "prot_acc"] set Ac3 [RetChip2 $I "prot_acc_PIQOR"] if { [regexp {^RA[0-9]+} $Des] } { continue } if {$Ac1=="" && $Ac2==""} { if {$Ac4!=""} { if {[regexp "," $Ac4]} { set SesAcs [split $Ac4 ","] foreach Ac $SesAcs { set Commande1 "getz \"\\\[protein-acc:$Ac\\\]\" \-f org" set GetzOut1 [eval exec $Commande1] set Lu1 "" set GenreLu1 "" set EspeceLu1 "" scan $GetzOut1 "%s %s %s" Lu1 GenreLu1 EspeceLu1 puts "plsligne=$I acc=$Ac4=>organisme=$GenreLu1 $EspeceLu1" set og "$GenreLu1 $EspeceLu1" puts "**$og" lappend liste $og } set liste [lsort -unique $liste] if {[llength $liste] > 1} { incr T puts "plus d'un orga pour ligne $I" foreach x $liste { puts "++$x" } } else { set orga [lindex $liste 0] if {[regexp {^Mus} $orga]} { incr M puts "Mpl=$M\n" } if {[regexp {^Homo} $orga]} { incr H puts "Hpl=$H\n" } if {[regexp {^Rattus} $orga]} { incr R puts "Rpl=$R\n" } } continue } set Commande "getz \"\\\[protein-acc:$Ac4\\\]\" \-f org" set GetzOut [eval exec $Commande] set Lu1 "" set GenreLu1 "" set EspeceLu1 "" scan $GetzOut "%s %s %s" Lu1 GenreLu1 EspeceLu1 puts "uniligne=$I acc=$Ac4=>organisme=$GenreLu1 $EspeceLu1" if {[regexp {^Mus$} $GenreLu1]} { incr M puts "Mui=$M\n" } if {[regexp {^Homo$} $GenreLu1]} { incr H puts "Hui=$H\n" } if {[regexp {^Rattus$} $GenreLu1]} { incr R puts "Rui=$R\n" } } } } Espionne "$M=nb de souris" Espionne "$H=nb d'homme" Espionne "$R=nb de rat" Espionne "$T=nb de multiple" } proc VerifReduction {FileMacsims} { set fh [open $FileMacsims "r"] dom parse -channel $fh doc close $fh $doc documentElement root set Box [file tail $FileMacsims] while {[regexp {\.} $Box]} {regsub {\.[^\.]+$} $Box "" Box} set ListeDesGroup [GroupDeMaSelection $Box] Espionne "$ListeDesGroup" foreach seq [$root selectNodes "//sequence"] { set Name [$seq selectNodes "string(./seq-name)"] set Group [$seq selectNodes "string(./seq-info/group)"] Espionne "$Name $Group" } } proc VerifSeqs {} { global db LNOrdali LSOrdali TDesSeqnames # Met a jour si besoin est table seqali , ou # insere nouvelle sequence foreach n $LNOrdali s $LSOrdali { if {$n eq ""} {continue} set sqn [set TDesSeqnames($n)] if {[$db eval {select count(pk_seqali) from seqali where seqname=$sqn and seq=$s}]} { # seqname et sequence existent continue } elseif {[$db eval {select count(pk_seqali) from seqali where seq=$s}]} { # seq identique , nom different ? set seqref $s if {[regexp "__" $sqn]} { set nom [string range $sqn 0 [string first "__" $sqn]-1] if {[$db eval {select count(pk_seqali) from seqali where seqname=$nom and seq=$s}]} { # seq est copie d'une autre set nomref $nom } else { # nom n'existe pas set nomref "" } } else { # on a nouveau nom set nomref "" } } elseif {[$db eval {select count(pk_seqali) from seqali where seqname=$sqn}]} { # meme nom, mais nouvelle seq set seqref "" set nomref $sqn } else { set seqref "" set nomref "" } # Si nom ref existe, prend infos de ref if {$nomref ne ""} { set refinf [lindex [$db eval {select pk_seqinfo from seqali where seqname=$nomref}] 0] $db eval {insert into seqali values (NULL, $refinf, $sqn, $s)} } else { InsereNouvelleSequence $n $s } } return } proc VerificationAvantCalculs {} { global TableScore set ncols [llength [set TableScore(1)]] for {set x 0} {$x < $ncols} {incr x} { set l 0 foreach i [array names TableScore] { lappend l [lindex [set TableScore($i)] $x] } set l [lsort -unique $l] if {[llength $l] == 1} {return 0} set neuf [lsearch $l -999.] if {$neuf != -1} { set l [lreplace $l $neuf $neuf] } if {[llength $l] == 1} {return 0} } return 1 } proc VerificationSequencage {{LesFichiersDeSequences ""} {FichierOuBanqueCible ""} {FastaOuBlast ""}} { JeMeSignale Wup "LesFichiersDeSequences can be a list of TFA files, a TFAs file or GetMacSeq or AskForsequence" set LesFichiersCibles {} if {$FichierOuBanqueCible==""} { set FichierOuBanqueCible "All" } if {$FichierOuBanqueCible=="All"} { set CibleEstAll 1 } else { set CibleEstAll 0 } if {$FichierOuBanqueCible=="Rec1OfQuery"} { set CibleEstRec1 1 } else { set CibleEstRec1 0 } if {[regexp "/Specif_" $FichierOuBanqueCible]} { set CibleEstNom 1 } else { set CibleEstNom 0 } if {$FastaOuBlast==""} { if {$CibleEstAll || $CibleEstNom} { set FastaOuBlast "Blast" } else { set FastaOuBlast "Fasta" } } if {$LesFichiersDeSequences=="AskForSequence"} { set LesFichiersDeSequences [LesFichiersDeType "All"] } if {$LesFichiersDeSequences=="GATC"} { set LesFichiersDeSequences [GetFromGATC] } if {$LesFichiersDeSequences=="GetMacSeq" || [regexp "^User_" $LesFichiersDeSequences]} { if {[regexp "^User_" $LesFichiersDeSequences]} { set User [StringSuivant "User_" dans $LesFichiersDeSequences] } else { set User "" } set LesFichiersDeSequences [GetMacSeq $User] } if {[llength $LesFichiersDeSequences]==0} { return {} } if {[llength $LesFichiersDeSequences] >1} { set LesBons {} set LesDout {} set UniqueBC [lindex $FichierOuBanqueCible 0] foreach FS $LesFichiersDeSequences BC $FichierOuBanqueCible { if {$BC==""} { set BC $UniqueBC } set LeRetour [VerificationSequencage $FS $BC $FastaOuBlast] foreach Bon [lindex $LeRetour 0] Dou [lindex $LeRetour 1] { lappend LesBons $Bon lappend LesDout $Dou } } return [list $LesBons $LesDout] } if {[llength $LesFichiersDeSequences]==1 && [file exists $LesFichiersDeSequences]} { set LesFicTFA {} set LesCiblesAll {} set LesCiblesNom {} set LesCiblesRec1 {} foreach Access [LaSequenceDuTFAs $LesFichiersDeSequences "LaListeDesAccess"] { Espionne $Access set BelAccess $Access # regsub -nocase {_A[12]$} $Access "" BelAccess # set BelAccess "${BelAccess}_Sequenced" set TFA [LaSequenceDuTFAs $LesFichiersDeSequences $Access] if {[regexp -nocase {_A[12](_|$)} $Access Match]} { if {0 && [regexp -nocase "A2" $Match]} { # set BelAccess "${BelAccess}RaC" set BelAccess $Access set RacSeq [NucToReverseAndComplementNuc [QueLaSequenceDuTexteTFA $TFA]] set TFA [SequenceFormatTFA $RacSeq "$Access RaC by Gscope" "nucbrut"] } } set Rep "[RepertoireDuGenome]/retoursequencage" set FicTFA [Sauve $TFA dans "$Rep/$BelAccess.tfa"] if {$CibleEstAll} { lappend LesCiblesAll "[RepertoireDuGenome]/banques/AllProGS" } if {$CibleEstNom} { lappend LesCiblesNom $FichierOuBanqueCible } if {$CibleEstRec1} { set Queue [file tail $FicTFA] regsub ".tfa$" $Queue "" Queue regsub -nocase {_A[12](_.*|$)} $Queue "" Queue set LesCibles [LesFichiersQuiCommencentPar "${Queue}_" "[RepertoireDuGenome]/rec1/" ".tfa"] Espionne "$Queue $LesCibles" while {[llength $LesCibles]==0} { if { ! [OuiOuNon "I cannot find the rec1 for $Queue. Can You help me ?" 0]} { break } set UneCible [ButineArborescence "All" "[RepertoireDuGenome]/rec1/"] if {$UneCible!=""} { set LesCibles [list $UneCible] ; break } } if {[llength $LesCibles]==0} { continue } if {[llength $LesCibles]>1} { FaireLire "Please help me to choose te rec1 file" } set Cible [ChoixParmi $LesCibles] lappend LesCiblesRec1 $Cible } lappend LesFicTFA $FicTFA } if {$LesFicTFA !={}} { set LesFichiersDeSequences $LesFicTFA } if {$LesCiblesAll !={}} { set LesFichiersCibles $LesCiblesAll } if {$LesCiblesNom !={}} { set LesFichiersCibles $LesCiblesNom } if {$LesCiblesRec1!={}} { set LesFichiersCibles $LesCiblesRec1 } } else { if {[OuiOuNon "You submited a list of TFA files. Does it concern the same Rec1 sequence ?"]} { } } set LesBonsFicQuery {} set LesDouteuxFicQuery {} foreach FicQuery $LesFichiersDeSequences FicCible $LesFichiersCibles { Espionne "FicQuery $FicCible" set NomQuery [file tail $FicQuery] set SeqQuery [QueLaSequenceDuFichierTFA $FicQuery] Wup "if FichierOuBanqueCible is the same for all then LesFichiersCibles is empty" if {$FicCible==""} { set FicCible $FichierOuBanqueCible } set FichierTFACible $FicCible set SeqCible [QueLaSequenceDuFichierTFA $FichierTFACible] if {[regexp -nocase -indices $SeqQuery $SeqCible]} { lappend LesBonsFicQuery $FicQuery continue } regsub {\.[^\.]*$} $FicCible "" NomCible set Banque "$NomCible" if { $FastaOuBlast=="Blast" && (! [file exists $FichierTFACible] || ! [file exists "$Banque.nhr"])} { set Banque [CreeBanqueBlastDuFichier $FicCible $NomCible] } set FichierTFACible $Banque set FichierBlast "[RepertoireDuGenome]/retoursequencage/blast/$NomQuery" regsub ".tfa$" $FichierBlast "" FichierBlast append FichierBlast ".blast" if {$FastaOuBlast=="Blast"} { if {[catch { exec blastall -p blastn -d $Banque -i $FicQuery -F F -v 2000 -b 2000 -o $FichierBlast } Message]} { FaireLire "I got an error from exec blastall with message\n$Message" continue } } else { regsub ".blast$" $FichierBlast ".fasta" FichierFasta Espionne "Je vais faire FastaN $FicQuery $Banque $FichierBlast" BlastNAvecFastaN $FicQuery $Banque.tfa $FichierBlast $FichierFasta } set OnTeste 1 set OnRange 0 if {$OnTeste} { set Val [VerificationSequencageApprofondie $FicQuery $FichierBlast "Show" "AvecRetour"] if {$Val==""} { set Val 0 } else { set Val 1 } if {$Val} { lappend LesBonsFicQuery $FicQuery } else { lappend LesDouteuxFicQuery $FicQuery } } if {$OnRange} { DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN] } } return [list $LesBonsFicQuery $LesDouteuxFicQuery] } proc VerificationSequencageApprofondie {FichierSequence FichierBlast {Action ""} {Maniere ""}} { if {$Action==""} { set Action "Show" } global ScoreDansProfil set ScoreDansProfilMemo 0 if {[info exists ScoreDansProfil]} { set ScoreDansProfilMemo $ScoreDansProfil } set ScoreDansProfil 1 set lPartieSegAli {} set n [DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombreDuTout" Query lBanqueId lAccess lDE lScore lPN lPartieSegAli] set ScoreDansProfil $ScoreDansProfilMemo set Compte 0 set NFoisQuoiMax 10 foreach BanqueId $lBanqueId ScoreLu $lScore PN $lPN { set Quoi [NatureDeLaSequenceAuVuDu $BanqueId] if { ! [info exists NFois($Quoi)]} { set NFois($Quoi) 0 } if {[incr NFois($Quoi)] > $NFoisQuoiMax} { continue } if {$Quoi==""} { lappend LesHits(Autres) $BanqueId lappend Expect(Autres) $PN lappend Score(Autres) $ScoreLu continue } if { ! [info exists Expect($Quoi)]} { set Expect($Quoi) $PN } #rR if { $PN > [set Expect($Quoi)] } { continue } if { ! [info exists Score($Quoi)]} { set Score($Quoi) $ScoreLu } if { $ScoreLu < [set Score($Quoi)] } { continue } if {$Quoi=="Alias"} { set PGS [NomDuAlias $BanqueId] foreach PG [split $PGS " "] { if {[EstUnPAB $PG]} { lappend LesHits(PGS) $PG} } } lappend LesHits($Quoi) $BanqueId } set LaPage {} lappend LaPage $FichierSequence lappend LaPage $FichierBlast set LesIllumines {} foreach Quoi [list "PGS" "Alias" "Oli" "VPPCR" "PPCR" "Rec1" "pDONR" "pDEST" "Autres"] { if { ! [info exists LesHits($Quoi)] } { continue } lappend LaPage "\n" if {[info exists Score($Quoi)] && [info exists Expect($Quoi)]} { lappend LaPage "$Quoi [set Score($Quoi)] [set Expect($Quoi)]" } set Prems 1 foreach Hi [set LesHits($Quoi)] { set Ligne " $Quoi $Hi" if {$Prems && ($Quoi=="PGS" || $Quoi=="Oli" || $Quoi=="VPPCR")} { lappend LesIllumines $Ligne } if {$Quoi=="Oli"} { append Ligne " [Oli $Hi Description]" } if {$Quoi=="VPPCR"} { append Ligne " [VirtualPPCREnStock $Hi Resume]" } set Prems 0 lappend LaPage $Ligne } } set Page [join $LaPage "\n"] if {$Action=="RetourneTexte"} { return $Page } set MaManiere $Maniere if {[regexp "AvecRetour" $Maniere]} { append MaManiere "AvecRetourMaisSansWait" } set w [AfficheVariable $Page "AvecOli$MaManiere" "Hits_of_$FichierBlast"] if { ! [regexp "AvecRetour" $Maniere]} { return $w } if {$LesIllumines!={}} { foreach Illu $LesIllumines { Illumine $Illu $w } Illumine [lindex $LesIllumines 0] $w } set Clavier "$w.buttons" TouchePour $Clavier "See the Blast" "AfficheUneSortieBlast $FichierBlast" "" "lightblue" TouchePour $Clavier "Disp SegAli" "AfficheZoneContigue $FichierBlast \[selection get\]" "" "lightblue" TouchePour $Clavier "InformSeqCheck" "InformeSeqCheck \[selection get\] \[set PagePropre($w)\]" "" "lightblue" global VariableDeRetour tkwait variable VariableDeRetour($w) set v $VariableDeRetour($w) unset VariableDeRetour($w) catch {destroy $w} return $v } proc VerificationSequencageApprofondiePourTous {} { foreach FichierBlast [glob "[RepertoireDuGenome]/retoursequencage/blast/*.blast"] { Espionne $FichierBlast if {[regexp "FASTA" [ContenuDuFichier $FichierBlast]]} { continue } set Retour [VerificationSequencageApprofondie "" $FichierBlast "Show" "AvecRetour"] if {$Retour==""} { continue } foreach Ligne [split $Retour "\n"] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } Espionne $Ligne } } } proc VerifieAgam {} { global LesSequencesDuTFAs foreach Ligne [LesLignesDuFichier "/genomics/link/Agam/banques/AGAM"] { if { ! [regexp {^>(.*?)( |$)} $Ligne Tout Access]} { continue } lappend TousLesAccess $Access } set TousLesAccess [lsort $TousLesAccess] set LesAccess [LaSequenceDuTFAs "/genomics/link/Agam/banques/AGAM" "LaListeDesAccess" "" "" "ForceAccessFirst"] Espionne [llength [array names LesSequencesDuTFAs]] set LesAccess [lsort $LesAccess] SauveLesLignes $TousLesAccess dans tla SauveLesLignes $LesAccess dans la Espionne "[llength $TousLesAccess] [llength [lsort -unique $TousLesAccess]] [llength $LesAccess] [llength [lsort -unique $LesAccess]]" exit foreach Access $LesAccess { set TFA($Access) [LaSequenceDuTFAs "/genomics/link/Agam/banques/AGAM" $Access ] } foreach Fichier [lsort [glob "/genomics/link/Agam/prottfa/*"]] { set Nom [file tail $Fichier] set Entete [EnteteDuFichierTFA $Fichier] set Access [lindex [split $Entete " "] 1] if { 0 && ! [info exists TFA($Access)]} { FaireLire "$Entete" } # Espionne "$Nom $Access" set Agam($Access) $Nom } foreach Access $LesAccess { if { ! [info exists Agam($Access)]} { FaireLire "$Access" } } } proc VerifieAllChrFinal {} { set ChrPrecedent "" set Status Ok foreach Ligne [LesLignesDuFichier "[AnnotRep]/AllChrFinalWithT.txt"] { lassign [LesMotsDeLaLigne $Ligne] Chr D F if {$Chr eq $ChrPrecedent && $D!=[incr FPrecedent]} { FaireLire "oups $Chr $FPrecedent $D $F" ; set Status "Bad" } set FPrecedent $F set ChrPrecedent $Chr } return $Rate } proc VerifieBestMsf {f} { set Vl -999. set Vd -999. set Vr -999. set Ll [LesLignesDuFichier "$f.normd"] foreach l $Ll { if {[regexp "dbclustal" $l]} { set Vd [string range $l [expr [string first ":" $l] +2] end] } if {[regexp "rascal" $l]} { set Vr [string range $l [expr [string first ":" $l] +2] end] } if {[regexp "leon" $l]} { set Vl [string range $l [expr [string first ":" $l] +2] end] } } # if {$Vl == "undetermined"} {set Vl -999.} # if {$Vd == "undetermined"} {set Vd -999.} # if {$Vr == "undetermined"} {set Vr -999.} if {$Vl == -999.} { set max [Maxi $Vr $Vd] if {$max == -999.} {return "no file"} if {$max == $Vr} { return ".rascal" } else { return "" } } if {$Vl > -999. && $Vl <= 0.3} { set max [Maxi $Vl $Vr] set max [Maxi $Vd $max] if {$max == $Vl} { return ".leon" } elseif {$max == $Vr} { return ".rascal" } else { return "" } } return ".leon" } proc VerifieBlastProGS {} { #rR il manquait les PGSxxx en debut de ces fichiers set LesBad {} foreach Nom [ListeDesPABs] { set Fichier [GscopeFile $Nom "blastp"] if {[FileAbsent $Fichier]} { lappend LesBad "$Nom absent"; continue } set Blast [ContenuDuFichier $Fichier] set Q [StringApres "Query=" dans $Blast] if {$Q==$Nom} { continue } lappend LesBad "$Nom $Q" regsub "Query= " $Blast "Query= $Nom " NewBlast Espionne [string range $NewBlast 0 400] Sauve $NewBlast dans $Fichier } AfficheListe $LesBad } proc VerifieChangementSeqlab {LNSeqlab LSSTemp} { global LNOrdali LSOrdali set ChClu 0 ; # Chgt ordre seqs set ChSeq 0 ; # Chgt +/- gaps set ChAas 0 ; # Chgt dans les aas de seqs if {$LNOrdali != $LNSeqlab} { set ChClu 1 } foreach n $LNSeqlab s $LSSTemp { if {$n eq ""} {continue} set in [lsearch $LNOrdali $n] if {$in == -1} {continue} set so [lindex $LSOrdali $in] set sd [string map [list "." "" "Z" ""] $s] set sdo [string map [list "." "" "Z" ""] $so] if {$sd ne $sdo} {set ChAas 1} if {$s ne $so} {set ChSeq 1} } return [list $ChClu $ChSeq $ChAas] } 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 VerifieCoherenceGscopeBioArrayBase {{Schema ""} {FromWhere ""}} { if {$FromWhere==""} { set FromWhere "FromInfo" } if {$Schema==""} { set Schema "poidevin" } CanalSqlBioArrayBase foreach Nom [ListeDesPABs] { set TxStartSql "" set TxEndSql "" set TxStart "" set TxEnd "" if {$Schema=="poidevin"} { set Li [SqlExec "select tsstart,tsstop from retinobase2.probeset where gscopeid = '$Nom';" "GetList"] Espionne "LI $Li" ScanLaListe $Li TxStartSql TxEndSql } if {$Schema=="retinobase2"} { set Access [AccessEvi $Nom] if {$Access==""} { continue } set Li [SqlExec "select chromo_loc from retinobase2.probeset where accno = '$Access';" "GetList"] Espionne "LI for $Nom $Access $Li" if {$Li==""} { continue } set StrandSql "?" regsub {\-} $Li " " Li regsub -all {[\:\(\)]} $Li " " Li scan $Li "%s %s %s %s" ChromSql TxStartSql TxEndSql StrandSql } if {$FromWhere=="FromInfo"} { set Loc [ExtraitInfo $Nom "InfoLocUcsc"] scan $Loc "%s %s %s %s %s" NomLu Chrom Strand TxStart TxEnd } if {$FromWhere=="From200508"} { set Access [AccessEvi $Nom] set Strand "?" regsub {\-} $Loc " " Loc regsub -all {[\:\(\)]} $Loc " " Loc scan $Loc "%s %s %s %s" Chrom TxStart TxEnd Strand } if {$FromWhere=="From200503"} { set Access [AccessEvi $Nom] set Loc [LocUcscEvi $Access "From200503"] puts $Loc set Strand "?" regsub {\-} $Loc " " Loc puts $Loc regsub -all {[\:\(\)]} $Loc " " Loc puts $Loc scan $Loc "%s %s %s %s" Chrom TxStart TxEnd Strand } Espionne "Loc for $Access $FromWhere $Loc" Espionne "$Nom $TxStart $TxEnd $FromWhere" Espionne "$Nom $TxStartSql $TxEndSql $Schema" Espionne "" if {$TxStartSql>$TxEnd || $TxStart>$TxEndSql } { FaireLire horreur } } CanalSqlDisconnect } proc VerifieDoublonsDansGo {} { foreach Ligne [LesLignesDuFichier [Fiches "NomGnGOs.txt"]] { set LesGOs [lrange [split $Ligne " "] 1 end] if {[llength $LesGOs]!=[llength [lsort -unique $LesGOs]]} { Espionne $Ligne } } } proc VerifieExtractRefseqOldAndNew {} { foreach N [lsort [glob [RepertoireDuGenome]/sequencesAllMiRNA2907/*.prottfa]] { set Q [file tail $N] set O [RepertoireDuGenome]/sequences/$Q set SN [QueLaSequenceDuFichierTFA $N] set SO [QueLaSequenceDuFichierTFA $O] if {$SN!=$SO} { FaireLire "$N\n$SN\n$SO" } } } proc VerifieFormatAlignement {file format} { set rep [EstLeBonFormat $file $format] if {[ModeI] && ! $rep} { FaireLire "This seems not to be a $format file !" } if {$rep} { return 1 } else { LesDefauts TypeAli "pasdali" return 0 } } proc VerifieGscopeGagniere {} { set LesManquants {} foreach F [glob "/home/gagniere/gscoperso/*.tcl"] { Espionne $F foreach Ligne [LesLignesDuFichier $F] { if { ! [regexp {^proc ([^ \{]+)} $Ligne Match P]} { continue } if {[info procs $P]!=""} { break } lappend LesManquants $P } } AfficheListe $LesManquants } proc VerifieInfos {} { foreach Nom [ListeDesPABs] { set Texte [ExtraitInfo $Nom] set LeBeau {} foreach Ligne [split $Texte "\n"] { if {[string trim $Ligne]==""} { Espionne "$Nom avec ligne vide" ; continue} scan $Ligne "%s" Clef if { ! [regexp -nocase {^[0-9a-z\-_]+\:$} $Clef]} { continue set Prems [string first $Ligne $Texte] set Deuss [string first $Ligne $Texte [expr $Prems + 1]] if {$Deuss<0} { Informe $Nom } else { Espionne "$Nom $Ligne" } } lappend LeBeau $Ligne } Espionne [SauveLesLignes $LeBeau dans [GscopeFile $Nom "infos2"]] } } proc VerifieInputTfa {f} { global LesNomsDesSequencesDansLOrdre global Sequences LitLeTFAMagos $f Ntm Stm if {[lindex $Ntm 0] == ""} { set Ntmp "query" } else { set Ntmp [lindex $Ntm 0] puts $Ntmp regsub -all {\|} $Ntmp "" Ntmp regsub -all {\!} $Ntmp "" Ntmp regsub -all {\"} $Ntmp "" Ntmp regsub -all {\:} $Ntmp "" Ntmp regsub -all {\.} $Ntmp "" Ntmp regsub -all {\\} $Ntmp "" Ntmp regsub -all {\/} $Ntmp "" Ntmp regsub -all {\;} $Ntmp "" Ntmp regsub -all {\,} $Ntmp "" Ntmp set Ntmp [string trim [string range [EnlevePrefixeBank $Ntmp] 0 30]] if {[regexp {^[0-9]} $Ntmp]} { set Ntmp [string replace $Ntmp 0 0 "_"] } } set LesLignes [LesLignesDuFichier $f] set LesLignes [lreplace $LesLignes 0 0 ">$Ntmp"] set fi [open $f w] foreach l $LesLignes { puts $fi $l } close $fi return $Ntmp #{} else {} #set s [set Stmp($Ntmp)] #regsub -all {\|} $Ntmp "" Ntmp #regsub -all {\!} $Ntmp "" Ntmp #regsub -all {\"} $Ntmp "" Ntmp #regsub -all {:} $Ntmp "" Ntmp #regsub -all {.} $Ntmp "" Ntmp #regsub -all {\\} $Ntmp "" Ntmp #regsub -all {\/} $Ntmp "" Ntmp #regsub -all {;} $Ntmp "" Ntmp #regsub -all {,} $Ntmp "" Ntmp #set Ntmp [string trim [string range [EnlevePrefixeBank $Ntmp] 0 30]] #if {[regexp {^[0-9]} $Ntmp]} { # set Ntmp [string replace $Ntmp 0 0 "_"] #} #set LesNomsDesSequencesDansLOrdre $Ntmp #set Sequences($Ntmp) $s #CreeLeTfa $f #catch {unset LesNomsDesSequencesDansLOrdre} #catch {unset Sequences} #return $Ntmp #{} } proc VerifieKozak {Nom} { set KozakTrouve [ExtraitKOZAK $Nom] set LaSeqKozak [list G C C G C C A C C A T G G] set LaSeqKozak2 [list G C C G C C G C C A T G G] set Similarite "" foreach Car [split $KozakTrouve ""] Base $LaSeqKozak Base2 $LaSeqKozak2 { #Espionne "$Car $Base $Base2" if {$Car==$Base} { append Similarite "$Car" } elseif {$Car==$Base2} { append Similarite "$Car" } if {$Car!=$Base && $Car!=$Base2} { append Similarite "X" } } #Espionne $KozakTrouve return $Similarite } proc VerifieKozakPourTous {} { foreach Nom [ListeDesPABs] { set Simil [VerifieKozak $Nom] set n 0 foreach Lettre [split $Simil ""] { if {$Lettre=="X"} {incr n} } append LesResultatsKozak "$Nom\t$Simil\t$n\n" } return $LesResultatsKozak } proc VerifieLeFasta {Fichier} { #rR j'ai ecrit ca pour voir pourquoi le proteome de OrthoInspector etait mauvais ... mais c'était la faute a formatdb set n 0 set t 0 foreach Ligne [LesLignesDuFichier $Fichier] { incr t if {[regexp {^>([^ ]+)( |$)} $Ligne Match Access]} { if { ! [regexp -nocase {^[A-Z0-9_\-\:\.]+$} $Access]} { FaireLire "Wrong $Access" } set ACCESS [string toupper $Access] if {[info exists DejaVu($ACCESS)]} { FaireLire "DejaVu $Access" } set DejaVu($ACCESS) 1 if {[string length $Access]>50} { FaireLire "long $Access" } if {[string length $Ligne]>1000} { FaireLire "long $Ligne" } incr n lappend LeNouveau $Ligne continue } if {[regexp -nocase {[^A-Z]} $Ligne]} { FaireLire "wrong seq for $Access\n$Ligne" } if {$Ligne==""} { continue } lappend LeNouveau $Ligne } SauveLesLignes $LeNouveau dans $Fichier.NEW return "$t lines for $n accesses" } proc VerifieLes18Conta {} { set FichierDes18 "[RepertoireDuGenome]/fiches/18nolocavecgb" foreach DD [ListeDesJR $FichierDes18] { set Vu($DD) 1 } set FichierRedondance1SansCourts "[RepertoireDuGenome]/fiches/Redondance1SansCourts" foreach Ligne [LesLignesDuFichier $FichierRedondance1SansCourts] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { if {[info exists Vu($DD)]} {lappend LesConta $Ligne} } } return $LesConta } proc VerifieLesGenomesCompletsIGBMC {{Fichier ""}} { if {$Fichier==""} { set Fichier "/genome/GCGdbs" } foreach Ligne [LesLignesDuFichier $Fichier] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } if { ! [regexp {^[ \t]} $Ligne]} { continue } if {[regexp "All the " $Ligne]} { continue } regsub -all {\.} $Ligne " " Ligne scan $Ligne "%s %s" Genre Espece if {$Espece=="sp"} { set Espece "sp." } set Organisme [Glossaire "$Genre $Espece" Complet] if {[info exists DejaVu($Organisme)]} { continue } set DejaVu($Organisme) 1 if {$Organisme!="$Genre $Espece"} { if {$Organisme==""} { set Trouve "nothing" } else { set Trouve "'$Organisme'" } set Bon "" if {[OuiOuNon "I found $Trouve for\n$Ligne\n Do I keep '$Genre $Espece' ?"]} { set Bon "$Genre $Espece" } if {$Bon=="" && $Organisme!="" && [OuiOuNon " Do I keep '$Organisme' ?"]} { set Bon "$Genre $Espece" } if {$Bon==""} { continue } } lappend LesOrganismes $Organisme } set LesBons [ChoixDesPresents $LesOrganismes] return $LesBons } 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 VerifieLesMutantsPourClonage {} { set LesMalPlaces {} foreach Ligne [LesLignesDuFichier [Fiches "bornesdespabs"]] { Espionne $Ligne scan $Ligne "%s %s %s" Nom D F if {[info exists DejaVu($D,$F)]} { set GrandFrere [GrandFrereDuMutant $Nom] while {[EstUnPABMute $GrandFrere]} { set GrandFrere [GrandFrereDuMutant $GrandFrere] } if {$DejaVu($D,$F)==$GrandFrere} { continue } # FaireLire "$Nom $D $F $DejaVu($D,$F)" lappend LesMalPlaces "$Nom $D $F $DejaVu($D,$F)" } set DejaVu($D,$F) $Nom } AfficheListe $LesMalPlaces } 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 VerifieLesNarcissesDesMutants {} { foreach Nom [ListeDesPABs] { if { ! [EstUnPABMute $Nom]} { continue } set GF [GrandFrereDuMutant $Nom] if {$GF==""} { FaireLire "$Nom has no GrandFrere" ; continue } if {[Narcisse $GF]==[Narcisse $Nom]} { continue } FaireLire "$Nom [Narcisse $Nom] is not [Narcisse $GF] of $GF" } } proc VerifieLesOverlapsPlusGrandsQue {{LongMini 18}} { global ListeDeBoites global KanvaCourant if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites } foreach Boite $ListeDeBoites { set Nom [Box $Boite nom] if {[Fantome $Nom]} { continue } foreach Ovl [split [Overlap $Nom] "/"] { if {[scan $Ovl "%d" Long] != 1} { continue } if {$Long < $LongMini} { continue } set Autre [StringApres "in" dans $Ovl] if {[Fantome $Autre]} { continue } if {[NombreDeCopainsDansBlast $Nom] >[NombreDeCopainsDansBlast $Autre]} { continue } if {[NombreDeCopainsDansBlast $Nom] > 5} { continue } if {[info exists KanvaCourant]} { RepereBox $Nom $KanvaCourant } else { Informe $Nom } } } } proc VerifieLesPDBs {} { global RepertoireDuGenome foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/lespdbs"] { regsub ">" $Ligne "" Ligne ScanLaListe [split $Ligne ":"] Nom aPDB set SeqBanque [LaSequenceDuTFAs "/blast/pdb" $aPDB] set SeqPerox [LaSequenceDuTFAs "$RepertoireDuGenome/tfasdescopains/$Nom" $aPDB] set SeqBanque [join [lrange [split $SeqBanque "\n"] 1 end] ""] set SeqPerox [join [lrange [split $SeqPerox "\n"] 1 end] ""] if {$SeqBanque==$SeqPerox} { continue } Espionne "$Nom $aPDB" Espionne "$SeqBanque\n$SeqPerox" FaireLire "$Nom $aPDB" lappend LesMauvais $Nom } SauveLesLignes $LesMauvais dans "$RepertoireDuGenome/lesmauvais" exit } proc VerifieLesPPCR {} { set LesPerdus {} foreach Nom [ListeDesPABs] { foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "notes"]] { if { ! [regexp {^N[0-9]{4} } $Ligne N]} { continue } set N [string trim $N] lappend PGS($N) $Nom if {[file exists "[RepertoireDuGenome]/ppcr_virtuels/$N"]} { continue } lappend LesPerdus $Ligne set Perdu($N) 1 } } set LesPerdus [lsort $LesPerdus] AfficheVariable [join $LesPerdus "\n"] "" "Les N manquant" set LesN {} foreach FN [lsort [glob -nocomplain "[RepertoireDuGenome]/ppcr_virtuels/N*"]] { set N [file tail $FN] set Old($N) [ContenuDuFichier $FN] set EOld [lindex [split $Old($N) "\n"] 0] regsub ">$N " $EOld "" EOld set Old($EOld) $N regsub ">$N " $Old($N) "" ESOld($EOld) lappend LesN $N lappend LesE $EOld } set LesN [lsort -unique $LesN] set LesLouches {} foreach N $LesN { Espionne $N set P [info exists Perdu($N)] set G [info exists PGS($N)] if {[info exists Old($N)]} { set VO $Old($N) } else { set VO "no Old" } if { ! $P && $G } { continue } set T "$N $P $G" if {$G} { lappend T $PGS($N) } if {$VO=="no Old"} { lappend T $VO } lappend LesLouches [join $T " "] } AfficheVariable [join $LesLouches "\n"] "" "Les N louches" } proc VerifieLesProfilsDD {} { set Fichier "[RepertoireDuGenome]/pourgscope_databaseUser" set Liste {} foreach Ligne [LesLignesDuFichier $Fichier] { #set Ligne [string trim $Ligne] if {$Ligne=={}} {continue} if {[regexp -nocase "codeClone" $Ligne]} {continue} #Espionne $Ligne set L [split $Ligne "\t"] set CC [lindex $L 0] set User [lindex $L 1] set Band [lindex $L 2] set Prof [lindex $L 3] set G [lindex $L 4] if {$Prof=="" || $Band==""} {continue} #Espionne "$CC $User $Band $Prof $G" if {[info exists P($Band)] && [info exists U($Band)]} { if {$U($Band)==$User} { if {$Prof!=$P($Band)} { lappend Liste "$G\t$User\t$CC\t$Prof\t$P($Band)\t$U($Band)" } } } else { if {$Band!=""} { set P($Band) $Prof set U($Band) $User } } } if {$Liste=={}} {return "nothing"} Espionne [llength $Liste] SauveLesLignes $Liste dans "[RepertoireDuGenome]/resultats_database_profilDD_user" } proc VerifieLesRec2 {} { foreach R [glob "[RepertoireDuGenome]/rec2Oublies/*"] { set Queue [file tail $R] regsub {\.tfa$} $Queue "" R2 set D "[RepertoireDuGenome]/rec2/$R2" if {[FileExists $D]} { continue } regexp {N[0-9]+} $R2 N lappend LesOublies "$N $R" } AfficheVariable [join $LesOublies "\n"] AvecVirtualPPCR "LesOublies" return set LesCorrectifs {} foreach D [glob "[RepertoireDuGenome]/rec2/*"] { set R2 [file tail $D] set R "[RepertoireDuGenome]/rec2Oublies/$R2" if {[FileAbsent $R]} { set R "$R.tfa" if {[FileAbsent $R]} { continue } } if {[ContenuDuFichier $D]==[ContenuDuFichier $R]} { Espionne "ok $D" ; continue } set SR [QueLaSequenceDuFichierTFA $R] set SD [QueLaSequenceDuFichierTFA $D] set ER [EnteteDuFichierTFA $R] set ED [EnteteDuFichierTFA $D] if { ! [string equal -nocase $SR $SD]} { FaireLire "les sequences different\n$ER\n$ED" ; continue } set OldER $ER if {[regexp -nocase "ppcr PGS" $ER]} { regsub -nocase "ppcr PGS" $ER "Ppcr for PGS" ER } if {$ER==$ED} { lappend LesCorrectifs "il faut corriger $OldER" ; continue } if {[string first " Rec2 " $ER]!=[set L [string last " Rec2 " $ER]]} { set ER [string range $ER 0 [incr L -1]] } if {$ER==$ED} { lappend LesCorrectifs "il enlecer le second Rec2 dans $OldER" ; continue } set Mouchard "" foreach X [split $ER ""] Y [split $ED ""] { if {$X==$Y} { set M " " } else { set M "^" } append Mouchard $M } AfficheVariable "\n$ER<\n$ED<\n$Mouchard<" AvecRetour } AfficheVariable [join $LesCorrectifs "\n"] } proc VerifieNbrDeGroupes {} { global ConsRef global LNDG update set lori [lrange $LNDG 1 end-1] set lori [lsort -command TrieNomGroupe $lori] set lgrf [lrange [ReordonneTypeCons "plein"] 3 end] set nlg [expr {[llength $lgrf] - 3}] set nbg [expr {[llength $LNDG] - 2}] if {$nlg == $nbg} {return} if {$nbg == 1} { set LNDG [lreplace $LNDG 1 1] return } set rep 0 set Radical "CoulG" foreach a $lori b $lgrf { set x [ExtraitNoDuGroupe $a] set y [ExtraitNoDuGroupe $b] if {$x == $y} {continue} set nwg "$Radical$x" set ConsRef($nwg) {} set rep 1 break } if {$rep} {set rep [VerifieNbrDeGroupes]} return $rep } proc VerifieNucProt {} { foreach FN [lsort [glob *.nuctfa]] { Espionne $FN set N [QueLaSequenceDuFichierTFA $FN] regsub ".nuctfa$" $FN "" FP append FP ".prottfa" set P [QueLaSequenceDuFichierTFA $FP] set PduN [SeqNucToSeqPro $N] if {$PduN!=$P} { Espionne "$PduN\n$P" FaireLire $FN } } } proc VerifieOrganismeDuPAB {} { foreach Nom [ListeDesPABs] { set OI [ExtraitInfo $Nom "Organism"] set OO [OrganismeDuPAB $Nom] if {$OI==$OO && $OI!=""} { continue } Espionne "$Nom\n$OI\n$OO\n" } exit } proc VerifieOrthoBlastP {} { global RepertoireDuGenome foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/orthoblastp"] { scan $Ligne "%s" Nom regsub {RIB[0-9]+ } $Ligne "" Accesses if {[regexp {[A-Z][a-z]+ } $Accesses Match]} { Espionne "$Nom $Match" ; continue ; Espionne $Ligne } } } proc VerifieOverlap {x1 x2} { global ZoneSuperposition if {! [info exists ZoneSuperposition]} {return 0} if {$ZoneSuperposition == {} } {return 0} foreach pos $ZoneSuperposition { lassign $pos xl xr if {($x1 >= $xl && $x1 <= $xr) || ($x2 >= $xl && $x2 <= $xr)} { return 1 } else { return 0 } } } proc VerifiePDB {} { foreach Nom [ListeDesPABs] { set PDB [ExtraitInfo $Nom "PDB"] set Task [ExtraitInfo $Nom "SpineTask"] if {$Task!="PDB"} { continue } Espionne "$Nom $Task $PDB" } foreach Nom [ListeDesPABs] { set PDB [ExtraitInfo $Nom "PDB"] set Task [ExtraitInfo $Nom "SpineTask"] if {$PDB==""} { continue } Espionne "$Nom $PDB $Task" } } proc VerifieParametres {} { global DefautsPipe foreach f {Filter,maxseq Blast,e Blast,v Blast,b} {max min} {500 100 10000 10 10000 10 10000 10} { foreach {p a} [split $f ,] {break} set v [set DefautsPipe($f)] if {$v > $max || $v < $min} { set rep [tk_dialog .mxs "Bad value" "Do you really want to have $v for $p $a ?" "" 0 "Yes" "No"] if {$rep == "No"} {return 0} } } return 1 } proc VerifiePresencePDB {file pdb} { DecortiqueUnMSF $file LesNomsDesSequencesDansLOrdre Sequences if {[lsearch $LesNomsDesSequencesDansLOrdre $pdb] == -1} { return 0 } else { return 1 } } proc VerifieSiTousLes1954blast {RepBlast FichierDesPABs FichierSortie} { foreach Fichier [glob -nocomplain -directory $RepBlast "DD*"] { if {[regexp "old" $Fichier]} {continue} set DD [file tail $Fichier] Espionne $DD set Vu($DD) 1 } set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] set Liste "" foreach Nom $L { if {![info exists Vu($Nom)]} {lappend Liste $Nom} } Espionne "nb pabs des 1954 absents dans $RepBlast: [llength $Liste]" SauveLesLignes $Liste dans $FichierSortie } proc VerifieSpineDefDesMutants {} { foreach Nom [ListeDesPABs] { if { ! [EstUnPABMute $Nom]} { continue } set Def [ExtraitInfo $Nom "SpineDef"] set Grand [GrandFrereDuMutant $Nom] set DefGrand [ExtraitInfo "SpineDef" $Grand] if {$Def==$DefGrand} { continue } FaireLire "The definitions do not correspond \n $Nom =$Def=\nmutant of \nGrand =$DefGrand=\nPlease informe $Nom" Informe $Nom "SpineDef: $DefGrand" } } proc VerifieSpineRefDesMutants {} { foreach Nom [ListeDesPABs] { if { ! [EstUnPABMute $Nom]} { continue } set Ref [ExtraitInfo $Nom "SpineRef"] set Grand [GrandFrereDuMutant $Nom] set RefGrand [ExtraitInfo $Grand "SpineRef"] if {$Ref==$RefGrand} { continue } FaireLire "The SpineRefs do not correspond \n $Nom =$Ref=\nmutant of \n$Grand =$RefGrand=\nPlease informe $Nom" Informe $Nom "SpineRef: $RefGrand" } } proc VerifieTfaProGS {} { #rR il manquait les PGSxxx en debut de ces fichiers set LesBad {} foreach Nom [ListeDesPABs] { set Fichier [GscopeFile $Nom "prottfa"] if {[FileAbsent $Fichier]} { lappend LesBad "$Nom absent"; continue } set TFA [ContenuDuFichier $Fichier] if {[regexp ">$Nom" $TFA]} { continue } scan $TFA "%s" A set A [string range $A 1 end] regsub ">" $TFA ">$Nom " NewTFA Espionne $NewTFA # Sauve $NewTFA dans $Fichier } AfficheListe $LesBad } proc VerifieZonesSuperposition {} { global ZoneSelect ZoneSuperposition ListePDB LNOrdali StrucAVoir Sequences if {! [info exists ZoneSelect]} { set ZoneSelect [list] } set ZoneSuperposition $ZoneSelect # On est en coordonnes generale de l'alignement set Lzone [list] foreach z $ZoneSuperposition { puts "z= >$z<" set MolSansZone {} lassign $z x1 x2 set lgt [expr {$x2-$x1+1}] set Ltmp [lrepeat $lgt 1] set Lres [list] # Cherche la sequence du PDB foreach mol $StrucAVoir { set mol [BonNomPDB $mol] set seq [set Sequences($mol)] set Lseq [split [string range $seq $x1 $x2] ""] set Lseg [list] foreach e $Lseq { lappend Lseg [regexp {[^\.]} $e] } if {1 ni $Lseg} { lappend MolSansZone $mol puts "==> no zone : $mol $z" continue } foreach e $Ltmp v $Lseg { lappend Lres [expr {$e & $v}] } set Ltmp $Lres set Lres [list] } set dep -1 ; set arr -1 set i 0 foreach e $Ltmp { if {$e} { if {$dep == -1} { set dep [expr {$x1+$i}] } } else { if {$dep != -1} { set arr [expr {$x1 + $i - 1}] lappend Lzone [list $dep $arr $MolSansZone] set dep -1 } } incr i } if {$dep != -1} { lappend Lzone [list $dep $x2 $MolSansZone] } } set ZoneSuperposition $Lzone set rtot 0 foreach z $ZoneSuperposition { lassign $z x1 x2 e set rtot [expr {$x2-$x1+1 + $rtot}] } return $rtot } proc VerifmRNAs {} { set ListeA ""; set ListeF "" foreach Nom [ListeDesPABs] { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccBestmRNAHuman!=""} { set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNA]} { lappend ListeF "$Nom $FichiermRNA doesn t exist" } else { if {![regexp $AccBestmRNAHuman [EnteteDuFichierTFA $FichiermRNA]]} { lappend ListeA "$Nom $AccBestmRNAHuman [EnteteDuFichierTFA $FichiermRNA]" } } } } Espionne "n fichiers : [llength $ListeF]" Espionne "n access: [llength $ListeA]" #return $Liste } proc VerifyStaf {} { set CompteurTotal 0 set CompteurAutres 0 set CompteurLongueur 0 set CompteurOrientation 0 set CompteurDoubles 0 set CompteurComplement 0 set CompteurOK 0 set CompteurRetrouvees 0 set CompteurDecalage 0 set CompteurInversion 0 set CompteurRegexp 0 set CompteurKO 0 set LesAnomaliesAutres {} set LesAnomaliesDoubles {} set LesAnomaliesDOrientation {} set LesAnomaliesDeComplement {} set LesAnomaliesDeLongueur {} set LesSequencesOK {} set LesSequencesRetrouvees {} set LesAnomaliesDecalageG {} set LesAnomaliesDecalageD {} set LesAnomaliesDecalageRG {} set LesAnomaliesDecalageRD {} set LesAnomaliesInversion {} set LesAnomaliesRegexp {} foreach Nom [ListeDesPABs] { set Loc [ExtraitInfo $Nom "ExcelLoc200405"] set Chro [string trim [lindex [split $Loc ":"] 0]] lappend LesSTAFsDuChro($Chro) $Nom lappend LesChro $Chro } set LesChro [lsort -unique $LesChro] foreach Chro $LesChro { Espionne "Loading : $Chro" foreach Nom $LesSTAFsDuChro($Chro} { incr CompteurTotal 1 set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]] set Ali [ExtraitInfo $Nom "ExcelAli:"] set Loc [ExtraitInfo $Nom "ExcelLoc200405"] set Bornes [lindex [split $Loc ":"] 1] if { ![ regexp {^[0-9]+\-[0-9]+$} $Bornes ]} { lappend LesAnomaliesRegexp $Nom continue } ScanLaListe [split $Bornes "-"] Deb Fin set Orient [ExtraitInfo $Nom "ExcelOrient:"] if {$Orient=="-"} { set $Orient "R" } if {$Orient=="+"} { set $Orient "F" } set Difference [expr $Deb-$Fin] if { ![expr $Deb-$Fin==-24] } { lappend LesAnomaliesDeLongueur $Nom continue } set SeqUcsc [BoutADNDeUcsc $Deb $Fin $Orient "Human" $Chro "bigZips200405"] set Com [NucToComplementNuc $Seq] if { [string equal -nocase $Seq $SeqUcsc] } { lappend LesSequencesOK $Nom lappend LesSequencesRetrouvees $Nom continue } # Espionne "" # Espionne "$Com (Complementaire de Seq)" # Espionne "$Seq (Seq)" # Espionne "$SeqUcsc (Ucsc)" if { [string equal -nocase $Com $SeqUcsc] } { lappend LesAnomaliesDeComplement $Nom lappend LesSequencesRetrouvees $Nom continue } if {$Orient=="F"} { set Orient "R" } elseif {$Orient=="R"} { set Orient "F" } set SeqUcsc2 [BoutADNDeUcsc $Deb $Fin $Orient "Human" $Chro "bigZips200603"] if { [string equal -nocase $Seq $SeqUcsc2] } { lappend LesAnomaliesDOrientation $Nom lappend LesSequencesRetrouvees $Nom continue } set ReverseSeq [ReverseString $Seq] if { [string equal -nocase $Seq $SeqUcsc2] } { lappend LesAnomaliesDOrientaton $Nom lappend LesSequencesRetrouvees $Nom continue } if { [string equal -nocase $SeqUcsc2 $ReverseSeq]} { lappend LesAnomaliesInversion $Nom lappend LesSequencesRetrouvees $Nom continue } if { [string equal -nocase $Com $SeqUcsc2] } { lappend LesAnomaliesDoubles $Nom lappend LesSequencesRetrouvees $Nom continue } if { ! [string equal -nocase $Com $SeqUcsc2] } { # Espionne " \n $Seq (XL)\n $SeqUcsc (UCSC)\n $Com (Complementaire XL)" set SeqFin [string range $Seq 2 24] set SeqDebut [string range $Seq 1 23] set ComFin [string range $Com 2 24] set ComDebut [string range $Com 1 23] set UCSCDebut [string range $SeqUcsc2 1 23] set UCSCFin [string range $SeqUcsc2 2 24] if { [string equal -nocase $SeqDebut $UCSCFin]} { lappend LesAnomaliesDecalageG $Nom lappend LesSequencesRetrouvees $Nom continue } if { [string equal -nocase $SeqFin $UCSCDebut]} { lappend LesAnomaliesDecalageD $Nom lappend LesSequencesRetrouvees $Nom continue } if { [string equal -nocase $ComDebut $UCSCFin]} { lappend LesAnomaliesDecalageRG $Nom lappend LesSequencesRetrouvees $Nom continue } if { [string equal -nocase $ComFin $UCSCDebut]} { lappend LesAnomaliesDecalageRD $Nom lappend LesSequencesRetrouvees $Nom continue } lappend LesAnomaliesAutres $Nom } } Espionne "\nScanning done.\n \n ************\n Statistiques\n ************\n " Espionne "* $CompteurTotal SBS lus\n" foreach Nom $LesSequencesOK { incr CompteurOK 1 } foreach Nom $LesSequencesRetrouvees { incr CompteurRetrouvees 1 } Espionne "* $CompteurRetrouvees retrouvables ($CompteurOK OK + petites erreurs)" foreach Nom $LesAnomaliesAutres { incr CompteurAutres 1 } foreach Nom $LesAnomaliesRegexp { incr CompteurRegexp 1 } foreach Nom $LesAnomaliesDeLongueur { incr CompteurLongueur 1 } set CompteurKO [expr $CompteurLongueur + $CompteurRegexp + $CompteurAutres] Espionne "* $CompteurKO non-retrouvables (dont $CompteurAutres non-identifiées)" foreach Nom $LesAnomaliesDeComplement { incr CompteurComplement 1 } foreach Nom $LesAnomaliesDOrientation { incr CompteurOrientation 1 } foreach Nom $LesAnomaliesInversion { incr CompteurInversion 1 } foreach Nom $LesAnomaliesDoubles { incr CompteurDoubles 1 } foreach Nom $LesAnomaliesDecalageG { incr CompteurDecalage 1 } foreach Nom $LesAnomaliesDecalageD { incr CompteurDecalage 1 } foreach Nom $LesAnomaliesDecalageRG { incr CompteurDecalage 1 } foreach Nom $LesAnomaliesDecalageRD { incr CompteurDecalage 1 } Espionne "\n-------------------------" Espionne "Détail des SBS identifiés:" Espionne "-------------------------" Espionne " $CompteurOrientation mauvaises orientations" Espionne " $CompteurComplement prises du complémentaires" Espionne " $CompteurDoubles prises du complémentaire et mal orientées" Espionne " $CompteurDecalage décalages de 1 dans un sens ou l'autre" Espionne "\n------------------------------" Espionne "Détail des SBS non-identifiées" Espionne "------------------------------" Espionne " $CompteurLongueur de longueur incorrecte" Espionne " $CompteurRegexp coquilles dans les bornes" Espionne " $CompteurAutres non-retruvées sur l'UCSC\n" } proc VersBiolo {{Qui ""}} { set Date [Date] set LesLogin {} foreach Destin [glob -nocomplain -type d "/biolo/gscope_contrib/*"] { if {$Qui!="" && [file tail $Destin]!=$Qui} { continue } Espionne $Destin if { [file type $Destin]!="directory" } { continue } set Login [file tail $Destin] set Source "/home/$Login/gscopublic" if { ! [file exists $Source]} { continue } set DestinOld "/biolo/gscope_contrib/Poubelle/$Login.$Date" set DestinTmp "${Destin}_Tmp" file mkdir $DestinTmp file copy -force $Source $DestinTmp file rename $Destin $DestinOld file rename "$DestinTmp/gscopublic" $Destin exec chmod -R g+w $Destin file delete $DestinTmp lappend LesLogin $Login } return $LesLogin } proc VersO {Commande} { global CanalO global RecuperationEffectuee global env if { ! [info exists CanalO]} { set vodat $env(ODAT) set CanalO [open "| /biolo/over6/sg_ono622" w+] # fconfigure $CanalO -blocking false -buffering full fconfigure $CanalO -blocking true -buffering none AuLog "Launching o." while {1} { gets $CanalO Reponse if {[regexp "Define an O file" $Reponse]} { break } after 500 } puts $CanalO "[file join $vodat menu.o]" flush $CanalO while {1} { gets $CanalO Reponse if {[regexp "Define an O file" $Reponse]} { AuLog $Reponse break } after 500 } puts $CanalO "[file join $vodat startup.o]" flush $CanalO while {1} { gets $CanalO Reponse if {[regexp "Define an O file" $Reponse]} { AuLog $Reponse break } after 500 } puts $CanalO "[file join $vodat access.o]" flush $CanalO while {1} { gets $CanalO Reponse if {[regexp "Define an O file" $Reponse]} { AuLog $Reponse break } after 500 } puts $CanalO "" flush $CanalO while {1} { gets $CanalO Reponse if {[regexp "Define an O file" $Reponse]} { break } after 500 } puts $CanalO "" flush $CanalO puts $CanalO "yes" flush $CanalO fileevent $CanalO readable "Recupere $CanalO" after 5000 # AuLog "On envoie : # TURLUTUTU" puts $CanalO "# TURLUTUTU" flush $CanalO tkwait variable RecuperationEffectuee unset RecuperationEffectuee } puts $CanalO "$Commande" flush $CanalO puts $CanalO "# TURLUTUTU" flush $CanalO tkwait variable RecuperationEffectuee unset RecuperationEffectuee return } proc VersPoubelle {Nom} { set Poubelle "[RepertoireDuGenome]/poubelle" if { ! [file exists $Poubelle]} { file mkdir $Poubelle } set LesFiPou {} foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] { if { ! [file exists $Fichier]} { continue } set Rep [file tail [file dirname $Fichier]] if {[file type $Rep]=="link"} { continue } set Pou "${Rep}_$Nom" set FiPou "$Poubelle/$Pou" if {[file exists $FiPou]} { Garde $FiPou } file rename -force $Fichier $FiPou lappend LesFiPou $FiPou } foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"] { if { ! [file exists $Fichier]} { continue } set Rep [file tail [file dirname $Fichier]] if { ! [OuiOuNon "$Fichier\nis in a directory which is a link.\nDo I move to poubelle anyway ?"]} { continue } set Pou "${Rep}_$Nom" set FiPou "$Poubelle/$Pou" if {[file exists $FiPou]} { Garde $FiPou } file rename -force $Fichier $FiPou lappend LesFiPou $FiPou } return $LesFiPou } proc VersPyMOL {Commande} { global CanalP global RecuperationEffectuee if { ! [info exists CanalP]} { set Pyloc [OuEstPymol] puts "pyloc >>$Pyloc<<" if {$Pyloc == 0} { FaireLire "Pymol not found ! Choose another viewer !" return } set CanalP [open "| $Pyloc" a+] fconfigure $CanalP -blocking false -buffering full fileevent $CanalP readable "Recupere $CanalP" puts $CanalP "# TURLUTUTU" tkwait variable RecuperationEffectuee unset RecuperationEffectuee } puts $CanalP "$Commande" flush $CanalP puts $CanalP "# TURLUTUTU" flush $CanalP tkwait variable RecuperationEffectuee unset RecuperationEffectuee return } proc VersRasMol {Commande} { global CanalR global RecuperationEffectuee global tcl_platform global LiaisonCoupee global InitRasMol if {$InitRasMol && ![info exists LiaisonCoupee]} {set LiaisonCoupee 0} if {$LiaisonCoupee} {unset CanalR} if {! [info exists CanalR]} { FaireAttendre "Please wait .... \n Loading RasMol and PDB file ..." eval set CanalR [open "|[RasmolExe] " r+] fconfigure $CanalR -blocking 0 -buffering line -buffersize 4094 # InitialiseRasMol $CanalR fileevent $CanalR readable [list RecupereRepRasMol $CanalR] # set cPick [dde request RasWin System Pick] FaireLaSuite .attendre } if {$tcl_platform(platform) == "windows"} { # catch {dde execute RasWin System "$Commande ; echo TURLU"} Msg puts $CanalR $Commande flush $CanalR } else { # send rasmol "\[$Commande\] \[echo TURLU\] " puts $CanalR $Commande flush $CanalR } tkwait variable RecuperationEffectuee unset RecuperationEffectuee # AuLog "Ordali_> $Commande done !" return } proc VersVMD {Commande} { global CanalV global clients global chatsock global OrdEtcDir if {! [info exists CanalV]} { set vexe [VMDexe] if {$vexe eq ""} { FaireLire "Can't find VMD !" return } VMDstart eval exec $vexe -e [file join $OrdEtcDir "VMD.tcl"] -args 21212 & update while {! [info exists clients]} { after 200 update } InitialiseVMD } VMDsend $Commande return } proc VersionDeGscope {} { global VersionDeGscope set VersionDeGscope 2017.01 return $VersionDeGscope } proc VersionOrdalieDB {} { global db # version 1.0 - # la table 'ordalie' ne contient pas la colonne # 'var' set Lcol [list] $db eval {PRAGMA TABLE_INFO(ordalie)} col { lappend Lcol $col(name) } if {[llength $Lcol] == 2} { return 1.0 } # Version > 1.0 - # la version de la db est dans table ordalie set VersionDB [$db eval {select val from ordalie where var='Defauts' and key='VersionDB'}] return $VersionDB } proc VersionSurBiolo {{Rep ""}} { foreach Dec [lsort [glob "/dec/biolo/$Rep/*.tcl"]] { regsub "/dec/" $Dec "/linux/" Lin if {[FileAbsent $Lin]} { Espionne "absence de $Lin" continue } if {[ContenuDuFichier $Dec]==[ContenuDuFichier $Lin]} { continue } exec dxdiff $Dec $Lin } exit } proc VerticalNames {TexteDesORGAorga} { foreach Orga [split $TexteDesORGAorga " "] { set Orga [string totitle $Orga] append Orga "..." lappend L0 [string index $Orga 0] lappend L1 [string index $Orga 1] lappend L2 [string index $Orga 2] lappend L3 [string index $Orga 3] } return " O [join $L0 ""] \n r [join $L1 ""] \n g [join $L2 ""] \n a [join $L3 ""]" } proc ViewPDB {args} { global Defauts StrucAVoir db ListePDB pdbIdRef LoadTclPackages LoadTkAndPackages set db [FabriqueDeTables [set Defauts(TablesDB1.1)] memory] set pdbIdRef 9999 set StrucAVoir [list] set ListePDB [list] foreach pdbid $args { puts "pdbid in : $pdbid" if {[file exists $pdbid]} { set Lpdb [ContenuDuFichier $pdbid] set pdbid [file rootname $pdbid] } else { set pdbid [DonneIdDeAccessPDB $pdbid] set Lpdb [TextePDB $pdbid ALL "" OnTheWeb] } if {! [EstUnAccessPDB $pdbid]} { set old_pdbid $pdbid set pdbid [incr pdbIdRef -1] } puts "pdbid new : $pdbid" lappend StrucAVoir PDB_${pdbid}_A lappend ListePDB PDB_${pdbid}_A LoadNouveauPDB $Lpdb $pdbid puts "$pdbid loaded" } if {0} { Structure create $pdbid $pdbid new $Lpdb "" 0 1 } InfosDesPDB puts "ready to show !" AfficheDansViandox return } proc ViewerPourClonage {} { global PositionInitiale global NomTextSeq global NomNomSeq global FrmBouton global Retour global Defauts global WTextSequence global NomFenetreOrdali $NomNomSeq configure -state disabled $NomTextSeq configure -state disabled wm title . "Select orgalnisms and select zone (Button 1 then Shift-Button 1)" set Defauts(AffSS) 1 MontreStrSecDansAlignement EnleveColonnesGaps set WTextSequence [$NomTextSeq get 0.0 end] AfficheZonesSelectionnees StockPosition bind $NomTextSeq <1> {eval StockPosition \[$NomTextSeq index current \] } bind $NomTextSeq <2> {eval DeselectLesColonnes \[$NomTextSeq index current \] } bind $NomTextSeq {eval SelectLesColonnes \[$NomTextSeq index current \] } $NomNomSeq tag configure SelN -foreground white -background black bind $NomNomSeq <1> {eval SelectLeNomDeSeq \[$NomNomSeq index current \] } DetruitBoutonsOrdali set w $FrmBouton button $w.fin -text "Accept limits" -command "EnvoieZoneACloner" -background green1 -width 7 -height 2 pack $w.fin -expand 1 -side left button $w.dis -text "Dismiss" -command "AdieuOrdali" -background red -width 7 -height 2 pack $w.dis -expand 1 -side left button $w.cle -text "Clear" -command "DeselectToutesLesColonnes " -background cyan -width 7 -height 2 pack $w.cle -expand 1 -side left button $w.sal -text "Select All" -command "SelectionneToutesColonnes" -background cyan -width 7 -height 2 pack $w.sal -expand 1 -side left button $w.hlp -text "Help" -command {eval source [file join $OrdHlpDir superposition.tcl]} -background magenta -width 7 -height 2 pack $w.hlp -expand 1 -side left tkwait variable Retour return $Retour } proc VirerLeHeader {File} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|VirerLeHeader : Start" set Fichier [open $File "r"] set FichierPure [open "/tmp/$File.csv" "w"] set lus 0 gets $Fichier Header while { [gets $Fichier Ligne] >= 0} { incr lus ScanLaListe $Ligne chrom start end sequence score strand puts $FichierEncodePure "0\t$Factor\t$chrom\t$start\t$end\t$strand\t$score\t$Replicate\t$CellType" } close $Fichier close $FichierPure set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|VirerLeHeader : Done." } proc VirerLesQuotes {Path} { # Prepare un fichier CSV avec des ";" en remplacant les espaces par des "_" et les ";" par des tabulations set FichierIn [open "$Path.txs" "r"] set FichierOut [open "$Path.txt" "w"] set PrevLigne "" while { [gets $FichierIn Ligne] >=0 } { regsub -all -nocase "\'" $Ligne "" Ligne puts $FichierOut $PrevLigne set PrevLigne $Ligne } close $FichierIn close $FichierOut } proc VirerLesRepeats {Chrox} { # Vire les N d'un fichier masque set PathIn "/tmp/GenomeMasque" set PathOut "/tmp/GenomeMasque" set End "fa.masked" set Ligne "" set FichierFa [open "$PathIn/Chr$Chrox" "r"] set FichierDecoupe "/tmp/GenomeMasque/$Chrox" while { [gets $FichierFa LigneFa] >=0 } { ScanLaListe $LigneFa SequenceFa regsub -all -nocase {N} $LigneFa "" Ligne AppendAuFichier $FichierDecoupe $Ligne } } proc VirerLesSequencesDansEncode {CellType Factor Replicate Table} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|VirerLesSequencesDansEncode : Start for factor $Factor in cell $CellType (replicate $Replicate)" set FichierEncode [open "wgEncodeYaleChIPseqAlignments$Replicate$CellType$Factor.tagAlign" "r"] set FichierEncodePure [open "/tmp/$Table.csv" "w"] set lus 0 while { [gets $FichierEncode Ligne] >= 0} { incr lus ScanLaListe $Ligne chrom start end sequence score strand puts $FichierEncodePure "0\t$Factor\t$chrom\t$start\t$end\t$strand\t$score\t$Replicate\t$CellType" } close $FichierEncode close $FichierEncodePure set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|VirerLesSequencesDansEncode : Loading $Table table in mySQL..." exec /usr/bin/mysqlimport --user=anno --password=ceji387. --host=[LbgiHost] "ucschuman" "/tmp/$Table.csv" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|VirerLesSequencesDansEncode : Done. ($lus inserted)" } proc VirtualPPCREnStock {N {Quoi ""}} { global VirtualPPCREnStock if {$Quoi==""} { set Quoi "Resume" } if {$Quoi=="LesRec1"} { return [Rec1 $N LesRec1] } if {$Quoi=="LesFichiersRec1"} { return [Rec1 $N LesFichiers] } set RepDesVirtualPPCR "[RepertoireDuGenome]/ppcr_virtuels" if { ! [info exists VirtualPPCREnStock("EstCharge")]} { set VirtualPPCREnStock("EstCharge") 1 set LesResumes {} set LesQuois {} set VirtualPPCREnStock(LaListeDesNs) {} foreach Fichier [glob -nocomplain "$RepDesVirtualPPCR/N*"] { set Queue [file tail $Fichier] if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue } set Entete [EnteteDuFichierTFA $Fichier] scan $Entete "%s %s %s %s %s %s %s %s %s" Nlu ppcr for PGS Sujet with oligos P5 P3 if { ! [regexp "^>" $Nlu]} { continue } regsub ">" $Nlu "" Nlu lappend VirtualPPCREnStock(LaListeDesNs) $Nlu set FullName [StringSuivant "FN: " dans $Entete] #??? lappend VirtualPPCREnStock(N,$FullName) $Nlu set VirtualPPCREnStock($Nlu,FullName) $FullName set VirtualPPCREnStock($Nlu,PGS) $PGS set VirtualPPCREnStock($Nlu,Sujet) $Sujet set VirtualPPCREnStock($Nlu,P5) $P5 set VirtualPPCREnStock($Nlu,P3) $P3 set VirtualPPCREnStock($Nlu,File) $Fichier set Resume "$Nlu $PGS [format "%-13s" [Alias $PGS]] $P5 $P3 $FullName" set VirtualPPCREnStock($Nlu,Resume) $Resume lappend LesResumes $Resume } set LesQuois {} lappend LesQuois "Resume" "FullName" "PGS" "P5" "P3" "Seq" "SeqSubject" "TFA" "File" lappend LesQuois "LesRec1" "LesFichierRec1" set VirtualPPCREnStock(LesQuois) $LesQuois set VirtualPPCREnStock(LesResumes) $LesResumes } if {$N=="LaListeDesNs"} { return [set VirtualPPCREnStock(LaListeDesNs)] } if {$N=="LesQuois"} { return [set VirtualPPCREnStock(LesQuois)] } if {$N=="LesResumes"} { return [set VirtualPPCREnStock(LesResumes)] } if {$Quoi==""} { set Quoi "TFA" } if { ! [info exists VirtualPPCREnStock($N,FullName)]} { return "" } if {$Quoi=="TFA"} { return [ContenuDuFichier "$RepDesVirtualPPCR/$N"] } if {$Quoi=="Seq"} { return [QueLaSequenceDuFichierTFA "$RepDesVirtualPPCR/$N"] } if {$Quoi=="SeqSubject"} { return [SequenceSansOligosDuVirtualPPCR $N] } if {[info exists VirtualPPCREnStock($N,$Quoi)]} { return [set VirtualPPCREnStock($N,$Quoi)] } } proc Viseur {K X Y} { global OldLigneX OldX global OldLigneY OldY if {[info exists OldLigneX($K)] || [info exists OldLigneY($K)]} { catch {$K delete [set OldLigneX($K)]} catch {$K delete [set OldLigneY($K)]} unset OldLigneX($K) unset OldLigneY($K) if {$X == [set OldX($K)] || $Y == [set OldY($K)]} { return } } set OldX($K) $X set OldY($K) $Y set x [$K canvasx $X] set y [$K canvasy $Y] set OldLigneX($K) [$K create line $x [expr $y-1000] $x [expr $y+1000]] set OldLigneY($K) [$K create line [expr $x-1000] $y [expr $x+1000] $y ] } proc ViseurDeGC {K X Y XDebut XFin YDebut {YFin ""} {OneNtPixel ""} {Minimum ""}} { Wup "Un viseur avec la melting temperature en degre sur le graph" Wup "Domaine de validite sur X (XDebut XFin) et valeur sur Y (YDebut YFin)" Wup "Minimum est necessaire car on ne commence pas a 0 ou 1 depend des valeurs observees" global LigneX OldX if {$YFin ==""} {set YFin [$YDebut + 1000]} if {$Minimum==""} {set Minimum 0} set Police {-family "Comic" -size 10 -weight bold} if {[info exists LigneX($K)]} { catch {$K delete [set LigneX($K)]} catch {$K delete [set LigneX($K,zone)]} unset LigneX($K) if {[info exists LigneX($K,$X,zone)]} {unset LigneX($K,$X,zone)} if {$X == [set OldX($K)] } {return ""} } set OldX($K) $X set x [$K canvasx $X] if {$x>$XFin || $x<$XDebut} {return ""} set GC [expr (($x-$XDebut) / (1.0*$OneNtPixel)) + $Minimum] set LigneX($K) [$K create line $x $YDebut $x $YFin] set LigneX($K,zone) [$K create text $x [expr $YDebut-11] -font "$Police" -text "[format "%.1f" $GC]" -fill "yellow" -anchor "center"] return "" } proc ViseurDeSeq {K X Y XDebut XFin YDebut {YFin ""} {OneNtPixel ""}} { Wup "Un viseur avec la position en nt sur la query" Wup "Domaine de validite sur X (XDebut XFin) et valeur sur Y (YDebut YFin)" Wup "Modif pour tenir compte du zoom" global LigneX OldX if {$YFin==""} {set YFin [$YDebut + 1000]} set Police {-family "Comic" -size 10 -weight bold} if {[info exists LigneX($K)]} { catch {$K delete [set LigneX($K)]} catch {$K delete [set LigneX($K,zone)]} unset LigneX($K) if {[info exists LigneX($K,$X,zone)]} {unset LigneX($K,$X,zone)} if {$X == [set OldX($K)] } {return ""} } set OldX($K) $X #Pour tenir compte du facteur de zoom set TailleQueryNt [LesInfosDe $K MaTailleDeQuery] if {$TailleQueryNt!=""} { set Facteurx [ZoomFacteur $K X] set Facteury [ZoomFacteur $K Y] set OneNtPixel [expr $OneNtPixel * $Facteurx] if {$Facteurx!="1.0"} { foreach F [list XDebut XFin] { set $F [expr [set $F]*$Facteurx] } } if {$Facteury!="1.0"} { foreach F [list YDebut YFin] { set $F [expr [set $F]*$Facteury] } } } set x [$K canvasx $X] if {$x>$XFin || $x<$XDebut} {return ""} set Nt [expr (($x-$XDebut) / (1.0*$OneNtPixel)) + 1] set LigneX($K) [$K create line $x $YDebut $x $YFin] set LigneX($K,zone) [$K create text $x [expr $YDebut-11] -font "$Police" -text "[format "%.0f" $Nt]" -fill "yellow" -anchor "center"] return "" } proc ViseurDeTm {K X Y XDebut XFin YDebut {YFin ""} {OneNtPixel ""} {Minimum ""}} { Wup "Un viseur avec la melting temperature en degre sur le graph" Wup "Domaine de validite sur X (XDebut XFin) et valeur sur Y (YDebut YFin)" Wup "Minimum est necessaire car on ne commence pas a 0 ou 1 depend des valeurs observees" global LigneX OldX if {$YFin ==""} {set YFin [$YDebut + 1000]} if {$Minimum==""} {set Minimum 0} set Police {-family "Comic" -size 10 -weight bold} if {[info exists LigneX($K)]} { catch {$K delete [set LigneX($K)]} catch {$K delete [set LigneX($K,zone)]} unset LigneX($K) if {[info exists LigneX($K,$X,zone)]} {unset LigneX($K,$X,zone)} if {$X == [set OldX($K)] } {return ""} } set OldX($K) $X set x [$K canvasx $X] if {$x>$XFin || $x<$XDebut} {return ""} set Tm [expr (($x-$XDebut) / (1.0*$OneNtPixel)) + $Minimum] set LigneX($K) [$K create line $x $YDebut $x $YFin] set LigneX($K,zone) [$K create text $x [expr $YDebut-11] -font "$Police" -text "[format "%.1f" $Tm]" -fill "yellow" -anchor "center"] return "" } proc VisiblePartOfAlignment {} { lassign [$::NomTextSeq xview] fxm fxx lassign [$::NomTextSeq yview] fym fyx set Lgt [LongueurDeLAlignement] set xm [expr {$Lgt*$fxm}] set xx [expr {$Lgt*$fxx}] set Nseq [llength $::LNOrdali] set ym [expr {$Nseq*$fym}] set yx [expr {$Nseq*$fyx}] return [list $xm $ym $xx $yx] } proc VisualiseStructure {} { global Defauts ListePDB StrucAVoir #::profiler::reset if {[TypeAli] eq "pasdali"} {return} if {[QuelMode] eq "seqlab"} { FaireLire "Not available in Editor mode !" return } if {! [llength $ListePDB]} { FaireLire "No structures to display !" return } else { set StrucAVoir [list] foreach elt $ListePDB { lassign $elt mol pdb lappend StrucAVoir $mol } } set Ltop [winfo children .] if {".fcviewer" in $Ltop} {return} FaireAttendre "Please wait ...\nPreparing structures to be displayed ..." PrepareViewer set viewer [set Defauts(Viewer)] if {$viewer eq "O macro file"} {set viewer "Omac"} DownloadStructures AfficheDans$viewer FaireLaSuite #AfficheProfileResults return } proc Vitrine {{V ""} {Top ""}} { global VitrineCourante global RepertoireDuGenome global CurrentGenome global FichierGscopeHelp global FichierGscopeImage global FichierGscopeImage2 global FichierGscopeLogoBInG global FichierGscopeLogoMacsim global FichierGscopeExitGscope global NotreOS Org1 Org2 global LesBoutonsNonOpen global LesBoutonsDeVitrine global LesBoutonsDeVitrineCaches if {[regexp "GetVitrine" $V]} { if {[info exists VitrineCourante]} { return $VitrineCourante } if {[regexp "Create" $V]} { Vitrine "" $Top return [Vitrine "GetVitrine"] } return "NoCurrentVitrine" } set VitrineCourante $V if {$Top!=""} { toplevel $V } set SW [winfo screenwidth .] set SH [winfo screenheight .] set OffX [expr ($SW/2) - 500] set OffY [expr 200] wm geometry . +${OffX}+${OffY} set Bouton $V.bseqin lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Enter sequence/Show a file/ Edit" bind $Bouton <1> {AfficheVariable [SeqIn] "SansFetchAvecFormateAvecBlasteAvecAligneurs"} bind $Bouton <2> ShowFile bind $Bouton <3> EditeEtCreeFichier set Bouton $V.bvisu lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "See Seq/Blast/MSF" bind $Bouton <1> AfficheUneSequence bind $Bouton <2> BlastTools bind $Bouton <3> EtudieUneSortieMSF bind $Bouton AfficheUneSortieBlast set Bouton $V.bcochealigneurs lappend LesBoutonsDeVitrineCaches $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Choose multiple alignment program ..." bind $Bouton CocheAligneurs set Bouton $V.borgas lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Ontology/GOTools/Decrypthon" bind $Bouton <1> "GOPanel \[NomDe gopanel\]" bind $Bouton <2> "GOTools" bind $Bouton <3> "AfficheDecrypthon" set Bouton $V.devtissue lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Develop Stage/Tissue Type/ Taxo" bind $Bouton <1> "IllustreDevStage" bind $Bouton <2> "IllustreTissueType" bind $Bouton <3> "BrowseTaxNCBI" set Bouton $V.bmenage lappend LesBoutonsDeVitrineCaches $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Clean directory" bind $Bouton <1> {MenageLesTmp "Rename"} set Bouton $V.inventaire lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Inventory/Check /DbW" bind $Bouton <1> Inventaire bind $Bouton <2> CheckInventaire bind $Bouton <3> QuoiQuOnFait if {[PreFixe]=="HNR"} { set Bouton $V.orgatblastn lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "OrgaInBlastP genomes/wgs" bind $Bouton <1> "GenomiqueComparativeParBlast tblastncompletegenomes" bind $Bouton <2> "GenomiqueComparativeParBlast tblastnwgs" set Bouton $V.orgablastn lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "OrgaInBlastN wgs" bind $Bouton <1> "GenomiqueComparativeParBlast blastnwgs" set Bouton $V.orgatblastp lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "OrgaInBlastP protall/ refseq" bind $Bouton <1> "GenomiqueComparativeParBlast blastp" bind $Bouton <2> "GenomiqueComparativeParBlast blastprefseq-prot" } if {[regexp "YEAH" [RepertoireDuGenome]]} { set Bouton $V.yeah lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "YEAH Show / Find / What" bind $Bouton <1> YEAHshow bind $Bouton <2> YEAHfind bind $Bouton <3> YEAHshowYeast set Bouton $V.yeah2 lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "YEAH mouvement 340 319" bind $Bouton <1> YEAHmouvement } if {[regexp "Tparva" [RepertoireDuGenome]]} { set Bouton $V.genoComp lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "ComparativeGenomic Tb/Pf/Eh" bind $Bouton <1> YesScNoTb bind $Bouton <2> YesScNoPf bind $Bouton <3> YesScNoEh set Bouton $V.genoCount lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "ComparativeGenomic Counts/Combi" bind $Bouton <1> "PhyloDistribution {} {} Show" bind $Bouton <2> "PhyloDistribution ChooseCombi Name Show" } if {[OnTraite "MTM1"]} { set Bouton $V.clonage lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "MTM1" bind $Bouton <1> "MTM1 show" bind $Bouton <2> "MTM1 show" bind $Bouton <3> "MTM1 show" } if {[OnTraiteDesClones]} { set Bouton $V.clonage lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Cloning /Show/ Order" bind $Bouton <1> InventaireDeLaDatabaseClonage bind $Bouton <2> InventaireDeLaDatabaseClonage bind $Bouton <3> GestionDesClones } if {0} { set Bouton $V.genoret lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Genoret GUs /ShowUploads" bind $Bouton <1> ShowGUs bind $Bouton <2> ShowUploads } if {[OnTraite "Bathy2010"]} { set Bouton $V.assemblybbtools lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "AssemblyDbTools Bathymodiolus" bind $Bouton <1> "AssemblyDbTools Bathymodiolus" } if {[OnTraite "CilioCarta" "Like"] || [OnTraite "OI2017" "Like"]} { set Bouton $V.blastOutliers lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "OlymClades /BlastOutliers Expect/Score" bind $Bouton <1> "OlymMedals" bind $Bouton <2> "BlastOutliers UseExpect" bind $Bouton <3> "BlastOutliers UseSCore" set Bouton $V.distri lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Clades Rank Distribution Average/ First Only" bind $Bouton <1> "CladesDistribution Average Rank" bind $Bouton <2> "CladesDistribution First Rank" bind $Bouton <3> "" } set Bouton $V.baide lappend LesBoutons $Bouton button $Bouton -text "ShowOrf/ChangeGenome/Exit\nDissmiss all windows" bind $Bouton <1> {SeeAby Show [Entre [PreFixe]]} bind $Bouton <2> ChangeGenome bind $Bouton <3> Boum bind $Bouton "DismissToutesLesFenetres" if { ! [info exists AvecTintin]} { set AvecTintin 1 } if { ! [PourWscope] && $AvecTintin} { image create photo periscope -file $FichierGscopeImage image create photo periscope2 -file $FichierGscopeImage2 $Bouton configure -image periscope bind $Bouton "$Bouton configure -image periscope2" bind $Bouton "$Bouton configure -image periscope" } set Bouton $V.bgscope lappend LesBoutons $Bouton button $Bouton -text "View Linear/Circular/List of $CurrentGenome" bind $Bouton <1> "GscopeBoard $CurrentGenome" bind $Bouton <2> "RscopeBoard $CurrentGenome" bind $Bouton <3> "SeeAby Show \[ChoixParmi \[PresentationDesPABs\]\]" set Bouton $V.bmap if {[MapCliquable "Existe"]} { lappend LesBoutons $Bouton } else { lappend LesBoutonsDeVitrineCaches $Bouton } lappend LesWebDeny $Bouton button $Bouton -text "Clicable Map of $CurrentGenome" bind $Bouton <1> MapCliquable set Bouton $V.bblaali set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali" if {[file exists $FichierDiffBlaAli]} { lappend LesBoutons $Bouton } else { lappend LesBoutonsDeVitrineCaches $Bouton lappend LesWebDeny $Bouton } button $Bouton -text "BlastP vs DbClust / ClustOperon" bind $Bouton <1> "AfficheVariable \[ContenuDuFichier $FichierDiffBlaAli\] AvecSmallMSF" bind $Bouton <2> "AfficheOperonsCommunsAuxClusters" set Bouton $V.bvisupepcurrentgenome lappend LesBoutonsDeVitrineCaches $Bouton button $Bouton -text "List prot/nuc of $CurrentGenome" bind $Bouton <1> {EtudieLesProteinesDe $CurrentGenome} bind $Bouton <2> {EtudieLesNucleiquesDe $CurrentGenome} if {[OnTraiteUnGenome]} { set Bouton $V.bdotplot lappend LesBoutons $Bouton button $Bouton -text "Proteome DotPlot vs ... " bind $Bouton <1> {eval DotPlot [Entre "genomes Ask Proches"]} set Bouton $V.bblastn lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "BlastN of another Complete Genome" bind $Bouton <1> BlastNDUnOrgaComplet set Bouton $V.bTGCA lappend LesBoutonsDeVitrineCaches $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Show Two Gene Cluster Analysis ... " bind $Bouton <1> RosaceDesTwoGenesCluster } if {[OnTraiteUnGenome] || [PreFixe]=="ANN"} { set Bouton $V.brangphylo lappend LesBoutons $Bouton button $Bouton -text "Phylogenic rank Show/New/Tamis" bind $Bouton <1> DemandeEtDessineOrgaEtSesPlaces bind $Bouton <2> PhyloRank bind $Bouton <3> PhyloRankDuTamis } if {0} { set Bouton $V.bDHA lappend LesBoutons $Bouton lappend LesWebDeny $Bouton button $Bouton -text "X-HDA Show/Ask/New" #Jean a rajoute #bind $Bouton <1> "ShowHDACroises {}" bind $Bouton <1> "AfficheBilanXHda" bind $Bouton <2> "ShowHDACroises AskForFile" bind $Bouton <3> "NewHDACroises" } set Bouton $V.bSetup lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "SetupGscope/setenv / Bird" bind $Bouton <1> SetupGscope bind $Bouton <2> AfficheLEnvironnementDeGscope bind $Bouton <3> BirdGscopeSearch set Bouton $V.bbigbang lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Complete database/Start/Stop" bind $Bouton <1> CreeLaBaseOuLaCollection bind $Bouton <2> JeCommenceABosser bind $Bouton <3> TuArretesDeBosser set Bouton $V.environnement lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Gscope Sources / .tar / .exe" bind $Bouton <1> AfficheLesSourcesDeGscope bind $Bouton <2> TarDeGscope bind $Bouton <3> FreewrapGscope set Bouton $V.blittlebrother lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Gscope chez le Psy /Src/Environ" bind $Bouton <1> AfficheLesProcs bind $Bouton <2> AfficheLesSourcesDeGscope bind $Bouton <3> AfficheLEnvironnementDeGscope set ExistingPorts [DialogPort "GetAll"] set Bouton $V.dialog lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Dialog on [Hostname] $ExistingPorts /+" bind $Bouton <1> "DialogPort DisplayAll" bind $Bouton <2> "DialogPort New; DialogPort DisplayAll" set Bouton $V.bbigbrother lappend LesBoutons $Bouton lappend LesBoutonsNonOpen $Bouton lappend LesWebDeny $Bouton button $Bouton -text "Big Brother /Source/again" bind $Bouton <1> DemandeEtExecute bind $Bouton <2> ReSource bind $Bouton <3> "ReSource Precedent" set Bouton $V.bboum lappend LesBoutons $Bouton button $Bouton -text "Exit Gscope \!" bind $Bouton <1> Boum bind $Bouton <2> "CodeSecret 0" bind $Bouton <3> "CodeSecret 1" if {0 && ! [PourWscope] && $AvecTintin} { image create photo LogoBInG -file $FichierGscopeLogoBInG image create photo ExitGscope -file $FichierGscopeExitGscope $Bouton configure -image LogoBInG bind $Bouton "CodeSecret Enter ; $Bouton configure -image ExitGscope" bind $Bouton "CodeSecret Leave ; $Bouton configure -image LogoBInG" } set nB [llength $LesBoutons] set iB $nB foreach b $LesBoutons { if {[PourWscope] && [lsearch -exact $LesWebDeny $b]>-1 } { if {[catch {destroy $b} Message]} { Espionne $Message } continue } if { ! [GscopeIsOpen] && [lsearch -exact $LesBoutonsNonOpen $b]>-1 } { continue } lappend LesBoutonsDeVitrine $b $b configure -background [Nuance [expr [incr iB -1]/(1.*$nB)]] $b configure -foreground black pack $b -fill both if { ! [PourWscope]} { bind $b "if \[OuiOuNon \"Destroy this button ?\"\] { destroy $b }" } } foreach b $LesBoutonsDeVitrineCaches { $b configure -background "#654321" $b configure -foreground "#123456" } if {[OnTraiteDesClones]} { $V.clonage configure -background "magenta" } if { $V=="" } { set V . } set Ports [DialogPort "GetAll"] wm title $V "$CurrentGenome $Ports Gscope [VersionDeGscope]" return $V } proc VoirADNduContig {ChroContig Selection} { set SansAffichage "" set CarNature(Prom) "P" set CarNature(Init) "I" set CarNature(Intr) "X" set CarNature(Sngl) "S" set CarNature(Term) "T" set CarNature(PlyA) "A" set CarNature(InGN) "." set CarNature(OuGN) " " set LesBornes {} foreach Ligne [split $Selection "\n"] { if { ! [regexp {^ *[0-9]+\.[0-9]+ } $Ligne]} { continue } scan $Ligne "%s %s %s %d %d" Num Nature Sens D F if {$Sens=="-"} { set W $D set D $F set F $W } lappend LesBornes "$D $F $Sens" set C " " if {[info exists CarNature($Nature)]} { set C [set CarNature($Nature)] } set CarNature($D) $C set Orientation($D) $Sens } if {$LesBornes=={}} { return "" } set Seq "n[QueLaSequenceDuTFA [ContigEnStock $ChroContig "FileNamePlease"]]" Espionne "$ChroContig $Seq" if {$Seq==""} { return "" } set BornesDebut [lindex $LesBornes 0] scan $BornesDebut "%s" Debut set BornesFin [lindex $LesBornes end] scan $BornesFin "%s %s" Bidon Fin set LongN [expr $Fin-$Debut+1] set DebutEtendu [expr $Debut-99] set FinEtendu [expr $Fin +99] while { $DebutEtendu < 1 } { incr DebutEtendu 3} while { $FinEtendu >= [string length $Seq] } { incr FinEtendu -3} set adn [string range $Seq $DebutEtendu $FinEtendu] set tdn [NucToComplementNuc $adn] set Orient "F" set NaturePlus "" set NatureMinus "" set pep(0) "" set pep(1) "" set pep(2) "" set pep(3) "" set pep(4) "" set pep(5) "" set Precision 25 set Loc $DebutEtendu set Regle [string repeat " " [expr $Precision - $Loc%$Precision]] set iBornes 0 set Bornes [lindex $LesBornes $iBornes] scan $Bornes "%d %d %s" D F Sens for {set i 0} { $i < [string length $adn] } {incr i } { append pep([expr $i%3]) "[AAduCodon [string range $adn $i [expr $i+2]]] " append pep([expr $i%3+3]) "[AAduCodon [ReverseString [string range $tdn $i [expr $i+2]]]] " set Car " " if {$D <= $Loc && $Loc <= $F} { set Car [set CarNature($D)] set Sens [set Orientation($D)] if {$Car==" "} { set Car [set CarNature(InGN)] } } if {$Sens=="+"} { append NaturePlus $Car append NatureMinus " " } else { append NaturePlus " " append NatureMinus $Car } if {$Loc==$F} { incr iBornes set Bornes [lindex $LesBornes $iBornes] scan $Bornes "%d %d %s" D F Sens } if {[expr $Loc-($Loc/$Precision)*$Precision]==0} { set Gradu [string range "$Loc[string repeat " " $Precision]" 0 [expr $Precision - 1]] append Regle $Gradu } incr Loc } set FrameP0 " $pep(2)" set FrameP1 " $pep(1)" set FrameP2 "$pep(0)" set FrameM0 " $pep(3)" set FrameM1 " $pep(4)" set FrameM2 " $pep(5)" set Texte "$FrameP0\n$FrameP1\n$FrameP2\n $NaturePlus\n$adn\n$Regle\n$tdn\n$NatureMinus\n $FrameM0\n$FrameM1\n$FrameM2" set i -1 foreach Ligne [split $Texte "\n"] { set LaLigne([incr i]) $Ligne lappend LesIemes $i } set Largeur 1000 set D 0 set F [expr $D+$Largeur-1] set LeHachis {} while {$D<$FinEtendu} { foreach i $LesIemes { lappend LeHachis [string range [set LaLigne($i)] $D $F] } lappend LeHachis "\n" incr D $Largeur incr F $Largeur } set Texte [join $LeHachis "\n"] if {$SansAffichage!=""} { return $Texte } return [AfficheVariable $Texte "GrandeLargeur" $ChroContig] } proc VoirLaMeilleureLocalisationDuCDNA {Nom} { Wup "Shows the first localisation of Nom" Gs "Canvas" set Loc [MeilleureLocalisationSurChroContig $Nom] if {[regexp "Chro0 Contig00" $Loc]} { return "" } scan $Loc "%s %s" Chro Contig return [VoirLesLocalisations $Chro $Contig] } proc VoirLesLocalisations {Chro Contig} { Gs "Canvas" JeMeSignale set Minimum 999999999 set Maximum -999999999 set ChroContig "${Chro}_$Contig" set Maximum [ContigEnStock "$ChroContig" "SizePlease"] if {$Maximum==""} { return "" } set LesBornes [LesBornesDeChroContig $Chro $Contig] foreach Ligne $LesBornes { scan $Ligne "%s %d %d %s" Nom D F O set Minimum [Mini $Minimum $D] set Maximum [Maxi $Maximum $F] } set LesLocGenscan [LesProteinesPreditesDuGenscan $ChroContig "Loc"] foreach Loc $LesLocGenscan { scan $Loc "%d %d %s %s" D F O P set Maximum [Maxi $Maximum $F] lappend LesLocs $Loc } set SX 800 set SY 800 set MX [expr $Maximum + 50] set LargeurMini 20 set MY $SY set BY 100 set K [UnCanva $MX $MY $SX $SY] regsub ".canvas$" $K "" w set Y 0 set OldFPAB -999 set OldFAFF -999 foreach Ligne $LesBornes { scan $Ligne "%s %d %d %s" Nom D F O if {[info exists DejaVu($Nom)]} { continue } set DejaVu($Nom) 1 if {$O=="F"} { set C "blue" } else { set C "red" } if {[EstUnPAB $Nom]} { set DeltaY -30 if {[expr $OldFPAB < $D]} { set Y [expr $MY/2 - $BY] } else { incr Y $DeltaY } set OldFPAB $F } else { set DeltaY 30 if {[expr $OldFAFF < $D]} { set Y [expr $MY/2 + $BY] } else { incr Y $DeltaY } set OldFAFF $F } set Dm $D set Fm $F if {0 && [expr ($F-$D)*1.*$SX/$Maximum < $LargeurMini]} { set Dm [expr ($D+$F)/2-$LargeurMini*$Maximum/(2.*$SX)] set Fm [expr ($D+$F)/2+$LargeurMini*$Maximum/(2.*$SX)] } if {[EstUnPAB $Nom]} { set NdS [NomDeScene $Nom] } else { set NdS $Nom } set IdR [$K create rectangle $Dm [expr $Y-10] $Fm [expr $Y+10] -fill "white"] set IdT [$K create text [expr ($D+$F)/2] $Y -text $NdS -anchor c -fill $C -tags [list "CDNA" $Nom "$D $F $O"]] if {[EstUnPAB $Nom]} { $K itemconfigure $IdR -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"] $K itemconfigure $IdT -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"] } } $K bind "CDNA" "Devoile $K %x %y" $K bind "CDNA" "Devoile $K %x %y Efface" $K bind "FetchMe" <1> "FetcheBox $K %x %y" $K bind "FetchMe" <3> "FetcheBox $K %x %y" $K bind "FetchMe" <2> "SearchOnBoard \[NomDuCourant $K\]" $K create rectangle 0 [expr $MY/2-1] $Maximum [expr $MY/2+1] -fill "black" $K create text [expr ($Maximum)/2] [expr $MY/2+30] -text "$Chro $Contig $Maximum bases" -tags [list "ChroContig"] -anchor c -fill "black" $K bind "ChroContig" <1> "AfficheContigComplet ${Chro}_$Contig" $K bind "ChroContig" <3> "AfficheContigComplet ${Chro}_$Contig" set Ecart 5 foreach Loc $LesLocGenscan { scan $Loc "%d %d %s %s" D F O P if {$O=="+"} { set Couleur "blue"} else { set Couleur "red" } set Ecart [expr -$Ecart] set Haut [expr $MY/2-$Ecart-10] set Bas [expr $MY/2-$Ecart+10] $K create rectangle $D $Haut $F $Bas -fill $Couleur -outline $Couleur -tag [list "Box" "Predite" "$D $F $O $ChroContig $P"] } $K bind "Predite" "Devoile $K %x %y" $K bind "Predite" "Devoile $K %x %y Efface" $K bind "Predite" <3> "Devoile $K %x %y GenScan" wm title $w "Localisation on $Chro $Contig" Gonfle $w all [expr (1.*$SX)/$MX] 1.0 if { 0 && [PourWscope] } { return [winfo toplevel $K] } return $K } proc VoirLesLocalisationsDuCDNA {Nom {Selection ""}} { Wup "Shows all localisations of Nom if Selection is empty, otherwise only these from Selection" set K "" if {$Selection==""} { set Selection [join [ChaqueSegmentDuBlastN $Nom 0.001 {}] "\n"] } foreach Ligne [split $Selection "\n"] { scan $Ligne "%s" ChroContig ScanLaListe [split $ChroContig ":"] Chro Contig regsub {_[0-9]+} $Contig "" Contig set K [VoirLesLocalisations $Chro $Contig] } return $K } proc VoisinADN {NomOuTexte {Debut ""} {Fin ""} {Orient ""} {SansAffichage ""} {Titre ""}} { if {[regexp -nocase {[A-Z]} $Debut]} { set SansAffichage $Debut set Titre $Fin set Debut "" set Fin "" } set AvecReverse 1 if {[EstPABouTROUouTRNAouARN $NomOuTexte]} { set Nom $NomOuTexte if {$Debut=="nuctfa"} { set adn [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]] set Debut 1 set Fin [string length $adn] set LongN [expr $Fin-$Debut+1] set DebutEtendu $Debut set FinEtendu $Fin set Orient "F" } else { if {$Debut == "" } { set Nom [Box $Nom nom] set Debut [Box $Nom debut] set Fin [Box $Nom fin] set Orient [Box $Nom orient] } set LongN [expr $Fin-$Debut+1] set DebutEtendu [expr $Debut-900] set FinEtendu [expr $Fin +900] while { $DebutEtendu < 1 } { incr DebutEtendu 3} while { $FinEtendu > [LongueurADN] } { incr FinEtendu -3} set adn [BoutADN $DebutEtendu $FinEtendu $Orient] } } else { if {[regexp "^>" $NomOuTexte]} { set Nom [EnteteDuTexteTFA $NomOuTexte "access"] set adn [QueLaSequenceDuTexteTFA $NomOuTexte "ListOfTxt"] if {[llength $adn]>1} { set AvecReverse 0 ScanLaListe $adn adn AutreAdn } } else { if {[regexp -nocase {[^atgcn \n0-9\.]} $NomOuTexte] && ! [OuiOuNon "Do You really want to see the 6 frame translation of the whole text ?" 0] } { return "" } set Nom "Six_frames_translation" regsub -nocase -all {[^a-z]} $NomOuTexte "" adn } set Debut 1 set Fin [string length $adn] set LongN [expr $Fin-$Debut+1] set DebutEtendu $Debut set FinEtendu $Fin set Orient "F" } if {$AvecReverse} { set tdn [ComplementString $adn] } else { set tdn $AutreAdn } set pep(0) "" set pep(1) "" set pep(2) "" set pep(3) "" set pep(4) "" set pep(5) "" for {set i 0} { $i < [string length $adn] } {incr i } { append pep([expr $i%3]) "[AAduCodon [string range $adn $i [expr $i+2]]] " if {$AvecReverse} { append pep([expr $i%3+3]) "[AAduCodon [ReverseString [string range $tdn $i [expr $i+2]]]] " } else { append pep([expr $i%3+3]) "[AAduCodon [string range $tdn $i [expr $i+2]]] " } } set Blanc "" for {set i 0} {$i<6000} {incr i} {append Blanc " "} if {$Orient == "F" } { set OffsetAvant [expr $Debut-$DebutEtendu] set OffsetApres [expr $FinEtendu-$Fin] } else { set OffsetApres [expr $Debut-$DebutEtendu] set OffsetAvant [expr $FinEtendu-$Fin] } set BlancAvant [string range $Blanc 0 [expr $OffsetAvant-1]] set BlancApres [string range $Blanc 0 [expr $OffsetApres-1]] set pepOriF [string range $pep(0) $OffsetAvant [expr [string length $pep(0)]-$OffsetApres] ] set pepOriR [string range $pep(3) $OffsetAvant [expr [string length $pep(3)]-$OffsetApres] ] set Regle [string range $Blanc 0 [expr $OffsetAvant%10-1]] for {set a [expr -($OffsetAvant/10)*10]} {$a < 0} {incr a 10} { set Marque "$a " append Regle [string range $Marque 0 9] } for {set a 1} {$a<$LongN} {incr a 10} { set p [expr ($a+2)/3] set Marque "${a}<$p " append Regle [string range $Marque 0 9] } append Regle [string range $Blanc 0 [expr ($LongN-1)%10-1]] for {set a 10} {$a<$OffsetApres} {incr a 10} { set Marque "+$a " append Regle [string range $Marque 0 9] } set CodeGenetiqueN "" set CodeGenetiqueP "" foreach A {a c g t} { foreach B {a c g t} { foreach C {a c g t} { set Codon "$A$B$C" set AA [AAduCodon $Codon] set AAA [UT $AA] append CodeGenetiqueN "$Codon " append CodeGenetiqueAA [string range "$AA " 0 3] append CodeGenetiqueAAA [string totitle [string range "$AAA " 0 3]] } } } set Explication "Find below the 3 frames translation of the 2 DNA sequences. To find the differences use the horizontal scrollbar : an X indicates the mutation." set CodeGenetique "$CodeGenetiqueN\n$CodeGenetiqueAA\n$CodeGenetiqueAAA" if {$AvecReverse} { set Texte " $pep(2)\n $pep(1)\n$pep(0)\n$BlancAvant$pepOriF$BlancApres\n$adn\n$Regle\n$tdn\n $BlancAvant$pepOriR$BlancApres\n $pep(3)\n $pep(4)\n $pep(5)" } else { set Highlight "" foreach A [string toupper [split $adn ""]] T [string toupper [split $tdn ""]] { if {$A==$T} { append Highlight " " } else { append Highlight "X" } } # set Texte " $pep(2)\n $pep(5)\n$adn\n$tdn\n$Regle\n\n $pep(1)\n $pep(4)\n$adn\n$tdn\n$Regle\n\n$pep(0)\n$pep(3)\n$adn\n$tdn\n$Regle\n$BlancAvant$pepOriF$BlancApres\n$BlancAvant$pepOriR$BlancApres\n\n$Highlight" set Texte "$Explication\nFrame+2\n $pep(2)\n $pep(5)\n$adn\n$tdn\n$Regle\n\nFrame+1\n $pep(1)\n $pep(4)\n$adn\n$tdn\n$Regle\n\nFrame+0\n$pep(0)\n$pep(3)\n$adn\n$tdn\n$Regle\n$Highlight\nDifferences are highlighted with X ->" } append Texte "\nGenetic code\n$CodeGenetique" if {$SansAffichage!=""} { if {[PourWscope]} { set Texte "

$Texte

" } return $Texte } if {$Titre==""} { set Titre $Nom } return [AfficheVariable $Texte "GrandeLargeur" $Titre] Wup "AfficheVariable uses listbox, AfficheText uses widget text" return [AfficheTexte $Texte $Nom [expr $OffsetAvant-50]] } proc VoisinADNDeLaZone {K} { global xDebutRectangleDeSelectionNucleique global yDebutRectangleDeSelectionNucleique global xFinRectangleDeSelectionNucleique global yFinRectangleDeSelectionNucleique if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} { FaireLire "Il faut selectionner une zone par " return "" } if {[regexp "rond" $K]} { set D [set xDebutRectangleDeSelectionNucleique($K)] set F [set xFinRectangleDeSelectionNucleique($K)] set Debut [Mini $D $F] set Fin [Maxi $D $F] } else { set Debut [PositionCanvaOriginaleX $K [Mini [set xDebutRectangleDeSelectionNucleique($K)] [set xFinRectangleDeSelectionNucleique($K)] ]] set Fin [PositionCanvaOriginaleX $K [Maxi [set xDebutRectangleDeSelectionNucleique($K)] [set xFinRectangleDeSelectionNucleique($K)] ]] } set Orient "F" VoisinADN Zone $Debut $Fin $Orient } proc VoitLesPauvres {} { #set Fichier "[RepertoireDuGenome]/parser/AttriToutVf2" set Fichier "[RepertoireDuGenome]/parser2007/NewAttriToutVf" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^ligne } $Ligne]} { set onla 0 scan $Ligne "%s %s" bidon numeroligne } if {[regexp {bidon trouve pas} $Ligne]} { set DejaVuTrouvePas($numeroligne) 1 } if {[regexp {bidon fiche n'existe plus} $Ligne]} { set DejaVuFicheExistePlus($numeroligne) 1 } } #Espionne "DejaVuTrouvePas" set taille1 [array size DejaVuTrouvePas] Espionne $taille1 #Espionne [array names DejaVuTrouvePas] #Espionne "DejaVuFicheExistePlus" set taille2 [array size DejaVuFicheExistePlus] Espionne $taille2 #Espionne [array names DejaVuFicheExistePlus] } proc Vrac2TFA {Nom Seq} { #utilise une sequence sous forme de liste #rend la sequence au format fasta avec Nom en en-tete set NewSeq [list] lappend NewSeq ">$Nom" set NbRestant [llength $Seq] set Indice 0 while {$NbRestant>80} { set Chaine "[join [lrange $Seq $Indice [expr $Indice+79]] ""]" lappend NewSeq $Chaine set Indice [expr $Indice + 80] set NbRestant [expr $NbRestant - 80] } set Chaine "[join [lrange $Seq $Indice [expr $Indice+79]] ""]" lappend NewSeq $Chaine return [join $NewSeq "\n"] } proc VraiChemin {Chemin} { set MemoWD [pwd] if { ! [file isdirectory $Chemin]} { set Dir [file dirname $Chemin] set Queue [file tail $Chemin] } else { set Dir $Chemin } if {[catch { cd $Dir } ]} { return $Chemin } set VraiChemin [pwd] if {[info exists Queue]} { append VraiChemin "/$Queue" } cd $MemoWD return $VraiChemin } proc VraiDEDeLaLigneDE {Ligne} { regsub "^DE *" $Ligne "" DE if { ! [regexp -nocase "RecName:" $DE]} { return $DE } Espionne $DE set Full ""; regexp {Full=([^\;]+)\;} $DE Match Full set Short ""; regexp {Short=([^\;]+)\;} $DE Match Short set EC ""; regexp {EC=([^\;]+)\;} $DE Match EC Espionne $EC set Vrai "$Full $Short EC=$EC" if {$Full=="" && $Short==""} { return $DE } return $Vrai } proc VraiGNDeLaLigneGN {Ligne} { regsub "^GN *" $Ligne "" GN regsub {\;$} $GN "" GN if { ! [regexp -nocase "Name=" $GN NameEgal]} { return $GN } regsub -all "\;" $GN " " GN set Vrai [StringApres $NameEgal dans $GN] if {$Vrai==""} { return $GN } return $Vrai } proc VraiNom {Betise} { global VraiNom if {[info exists VraiNom($Betise)]} { return $VraiNom($Betise) } if {[info exists VraiNom("EstCharge")]} { return "" } set VraiNom("EstCharge") 1 set VraiNom(dm) "Drosophila melanogaster" set VraiNom(apis) "Apis melifera" set VraiNom(orizaref) "Oryza sativa" set VraiNom(kluiverxp) "Kluyveromyces lactis" set VraiNom(pombe) "Schizosaccharomyces pombe" set VraiNom(cryptococcus) "Cryptococcus neoformans" set VraiNom(dictyostelium) "Dictostelium unknownus" set VraiNom(danior) "Brachidanio rerio" set VraiNom(panisoform) "Pan troglodytes" set VraiNom(panisoform2) "Pan troglodytes" set VraiNom(panisoform5) "Pan troglodytes" set VraiNom(canis) "Canis familiaris" set VraiNom(gallusgallusp) "Gallus gallus" set VraiNom(xenopuslae) "Xenopus laevis" set VraiNom(xenoplaevis) "Xenopus laevis" set VraiNom(ncrassa) "Neurospora crassa" set VraiNom(schyzosac) "Schizosaccharomyces pombe" set VraiNom(athaliananref) "Arabidopsis thaliana" set VraiNom(nasonia) "Nasonia vitripennis" set VraiNom(bovis) "Bovis taurus" set VraiNom(gallus) "Gallus gallus" set VraiNom(opossum) "Opossum " set VraiNom(nemast) "Nematostella unknownus" set VraiNom(athalian) "Arabidopsis thaliana" set VraiNom(orizaesativ) "Oryza sativa" set VraiNom(tribolium) "Tribolium castaneum" set VraiNom(mm) "Mus musculus" set VraiNom(homosapisoform) "Homo sapiens" set VraiNom(ATHALAINA) "Arabidopsis thaliana" set VraiNom(athalaina) "Arabidopsis thaliana" set VraiNom(Aspergil) "Aspergillus unknownus" set VraiNom(aspergil) "Aspergillus unknownus" set VraiNom(Athalian) "Arabidopsis thaliana" set VraiNom(Athaliana) "Arabidopsis thaliana" set VraiNom(Orizasativ) "Oryza sativa" set VraiNom(Orizasativa) "Oryza sativa" set VraiNom(Picea) "Picea unknownus" set VraiNom(Saccharocerev) "Saccharomyces cerevisiae" set VraiNom(athalian) "Arabidopsis thaliana" set VraiNom(athaliana) "Arabidopsis thaliana" set VraiNom(orizasativ) "Oryza sativa" set VraiNom(orizasativa) "Oryza sativa" set VraiNom(picea) "Picea unknownus" set VraiNom(saccharocerev) "Saccharomyces cerevisiae" set VraiNom(epicea) "Picea unknownus" set VraiNom(orizasat) "Oryza sativa" set VraiNom(orizasativ) "Oryza sativa" set VraiNom(phycomitrella) "Phycomitrella unknownus" set VraiNom(physcomitrel) "Phycomitrella unknownus" set VraiNom(physcomitrella) "Phycomitrella unknownus" set VraiNom(physcomitrellagb) "Phycomitrella unknownus" set VraiNom(vitis) "Vitis vinifera" set VraiNom(vitisvini) "Vitis vinifera" set VraiNom(aedesput) "Aedes aegypti" set VraiNom(ascomycetes) "Ascomycete sp." set VraiNom(asper) "Aspergillus unknownus" set VraiNom(asperg) "Aspergillus unknownus" set VraiNom(aspergil) "Aspergillus unknownus" set VraiNom(athalia) "Arabidopsis thaliana" set VraiNom(athaliana) "Arabidopsis thaliana" set VraiNom(caeno) "Caenorhabditis elegans" set VraiNom(candida) "Candida unknownus" set VraiNom(ce) "Caenorhabditis elegans" set VraiNom(cryptosporidium) "" set VraiNom(dictyostel) "Dictostelium unknownus" set VraiNom(drozo) "Drosophila melanogaster" set VraiNom(fungi) "Ascomycete sp." set VraiNom(fungi-macro-gb) "Fungi unknownus" set VraiNom(homosap) "Homo sapiens" set VraiNom(kluiverlactis) "Kluyveromyces lactis" set VraiNom(leishmania3) "Leishmania unknownus" set VraiNom(monodelphis) "Monodelphis domestica" set VraiNom(orizasativ) "Oryza sativa" set VraiNom(orizasativa) "Oryza sativa" set VraiNom(ornithor) "Ornithorhynchus anatinus" set VraiNom(ostreococcus) "Ostreococcus unknownus" set VraiNom(p62canis) "Canis familiaris" set VraiNom(p62nematopref) "Nematode sp." set VraiNom(pan) "Pan troglodytes" set VraiNom(phycomitrella) "Physcomitrella patens" set VraiNom(physcomitrellagb) "Physcomitrella patens" set VraiNom(pichia) "Pichia pastoris" set VraiNom(plantegb) "Plant unkownus" set VraiNom(plasmodium) "Plasmodium sp." set VraiNom(plasmodiumvivax) "Plasmodium vivax" set VraiNom(sac) "Saccharomyces cerevisiae" set VraiNom(saccharocerev) "Saccharomyces cerevisiae" set VraiNom(sclerotina) "Sclerotinia sclerotiorum" set VraiNom(strongylo) "Unknownus unknownus" set VraiNom(tetraodon) "Tetraodon sp." set VraiNom(vitis) "Vitis vinifera" set VraiNom(xenopuslaevis) "Xenopus laevis" set VraiNom(yeast) "Yeast unknownus" return [VraiNom $Betise] } proc VraisParaloguesDe {Nom} { global VraisParaloguesDe global RepertoireDuGenome set SeuilParalogue 20 if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] } if {[info exists VraisParaloguesDe]} { return {} } set FichierVraisParalogues "$RepertoireDuGenome/fiches/paralogues" if {[file exists $FichierVraisParalogues]} { foreach Ligne [LesLignesDuFichier $FichierVraisParalogues] { set LesParas [split $Ligne " "] set NomLu [lindex $LesParas 0] lappend LesNoms $NomLu set VraisParaloguesDe($NomLu) [lrange $LesParas 1 end] } set VraisParaloguesDe(LaListeMerci) $LesNoms if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] } return {} } set PICPar "$RepertoireDuGenome/fiches/piclustalw.paralogues" if { ! [file exists $PICPar]} { FaireLire "Please create the paralogues with AlignonsLesParalogues" set VraisParaloguesDe(LaListeMerci) {} return {} } foreach Ligne [LesLignesDuFichier $PICPar] { set Liste [split $Ligne " "] set NomLu [lindex $Liste 0] set LesParas {} foreach {Para PIC} [lrange $Liste 1 end] { if {$Para==$NomLu} { continue } if { $PIC < $SeuilParalogue } { break } lappend LesParas $Para } if {$LesParas=={}} { continue } lappend LesLignes "$NomLu [join $LesParas " "]" } SauveLesLignes $LesLignes dans $FichierVraisParalogues return [VraisParaloguesDe $Nom] } proc VrpCircle {} { global VrpC if {[winfo exists .vrpcircle]} {return} set VrpC(AA1name,1) {} set WinScale 20.0 set VrpC(Radius) [expr abs($VrpC(MaxX))] if { abs($VrpC(MinX)) > abs($VrpC(MaxX)) } { set VrpC(Radius) [expr abs($VrpC(MinX))] } if { $VrpC(Radius) < abs($VrpC(MinY)) } { set VrpC(Radius) [expr abs($VrpC(MinY))] } if { $VrpC(Radius) < abs($VrpC(MaxY)) } { set VrpC(Radius) [expr abs($VrpC(MaxY))] } set VrpC(Radius) [expr int($VrpC(Radius)+0.5)] set VrpC(Delta) 10 set VrpC(CentX) [expr int( $VrpC(Radius) * $WinScale + 0.5) ] set VrpC(CentX) [expr $VrpC(CentX) + $VrpC(Delta)] set VrpC(Radius) $VrpC(CentX) set VrpC(CentY) $VrpC(CentX) set WinX [expr 2*$VrpC(CentX)] set WinY [expr 2*$VrpC(CentY)] set font "Helvetica 10 normal" # fenetre cercle VRP set w .vrpcircle toplevel $w wm title $w "Vrp Circle" set c $w.c canvas $c -scrollregion [list 0 0 $WinX $WinY] -width $WinX -height $WinY -relief sunken -borderwidth 2 -background white button $w.print -text "Print" -background yellow -command [list PrintCanvas $c png] button $w.close -text "Close" -background green1 -command [list destroy $w] grid $c -row 0 -column 0 -columnspan 2 -sticky news -padx 5 -pady 5 grid $w.print -row 1 -column 0 -sticky w -padx 5 -pady 10 grid $w.close -row 1 -column 1 -sticky e -padx 5 -pady 10 grid columnconfig $w all -weight 1 set blue DeepSkyBlue3 set red red set bisque bisque3 set green SeaGreen3 #set blue black #set red black #set bisque black #set green black set x1 $VrpC(Delta) set y1 $VrpC(Delta) set x2 [expr $WinX - $VrpC(Delta) ] set y2 [expr $WinY - $VrpC(Delta) ] # cercle et lignes $c create oval $x1 $y1 $x2 $y2 -outline $red -width 1 $c create line $VrpC(CentX) $VrpC(Delta) $VrpC(CentX) [expr $WinY-$VrpC(Delta)] -fill $red $c create line $VrpC(Delta) $VrpC(CentY) [expr $WinX-$VrpC(Delta)] $VrpC(CentY) -fill $red for {set i 0 } { $i < $VrpC(NbAA) } { incr i } { set x [expr $VrpC(HydX,$i)*$WinScale + $VrpC(CentX)] set y [expr -$VrpC(HydY,$i)*$WinScale+$VrpC(CentY)] $c create line $VrpC(CentX) $VrpC(CentY) $x $y -arrow last if { ( $x >= $VrpC(CentX) ) } { set anchor [ expr "{$y} >= $VrpC(CentY) ? {nw} : {sw} " ] } else { set anchor [ expr "{$y} >= $VrpC(CentY) ? {ne} : {se}" ] } $c create text $x $y -text $VrpC(AA1name,$i) -anchor $anchor } set lastX 0 set lastY 0 FenetreAuCentre $w return } proc VrpDeGroupe {g} { global Vrp VrpC ListeDesPiliersDuGroupe FaireAttendre "Please wait ...\nBuilding VRP for group $g" set xprev 0.0 ; set yprev 0.0 set cmx 0.0 ; set cmy 0.0 set minX 9999999. ; set minY 9999999. set maxX -9999999. ; set maxY -9999999. set newX {} ; set newY {} set Vrp(seqSS) {} set Vrp(SS) {} set Vrp(AA1) "" set Vrp(Sz) [LongueurDeLAlignement] set Vrp(Nb) {} if {! [info exists ListeDesPiliersDuGroupe]} { CreeLesPiliers } if {$g eq "All"} {set g "GroupeToutLeMonde"} set i 0 set ntot [string length [lindex [set ListeDesPiliersDuGroupe($g)] 0]] foreach p [set ListeDesPiliersDuGroupe($g)] { set xt 0.0 set yt 0.0 set n 0 foreach aa [split $p ""] { if {$aa eq "." || $aa eq "X" || $aa eq "Z"} {continue} set xt [expr {$xt + $VrpC(HydX,$aa)}] set yt [expr {$yt + $VrpC(HydY,$aa)}] incr n } # Attention ! # Suppose : 1 colonne de E par exemple # on a donc sumX = n*E et ici n=ntot # x= sumX/ntot set x [expr {(1.0/$ntot) * $Vrp(ScaleOrig)*$xt + $xprev}] set y [expr {(1.0/$ntot) * $Vrp(ScaleOrig)*$yt + $yprev}] lappend newX $x lappend newY $y lappend Vrp(Nb) [expr {$i + 1}] set xprev $x set yprev $y set cmx [expr {$cmx + $x}] set cmy [expr {$cmy + $y}] incr i } set minX [expr min([join $newX ,])] set minY [expr min([join $newY ,])] set maxX [expr max([join $newX ,])] set maxY [expr max([join $newY ,])] set Vrp(X) [LissageParFenetre $newX 5] set Vrp(Y) [LissageParFenetre $newY 5] set Vrp(CmX) [expr {$cmx / ($Vrp(Sz)+1)}] set Vrp(CmY) [expr {$cmy / ($Vrp(Sz)+1)}] set Vrp(MinX) $minX set Vrp(MinY) $minY set Vrp(MaxX) $maxX set Vrp(MaxY) $maxY set Vrp(SzX) [expr {($Vrp(MaxX) - $Vrp(MinX))/2}] set Vrp(SzY) [expr {($Vrp(MaxY) - $Vrp(MinY))/2}] FaireLaSuite return } proc VueEditee {{edt ""}} { if {$edt eq ""} {return $::VueEditee} set ::VueEditee $edt return } proc WCoucou {} { puts "un petit coucou de Wolfgang" } proc WIW {{Qui ""} {Quoi ""}} { #rR Attention pour que ça marche pour les Eukaryota Archaea et autre il faut être dasn le bon Gscope #rR oi pour Eukaryota; OIA pour Archaea etc. global WIW #rR WIW Who is Where # Attention il y a quelques P12345_BIDULE qui correspondent à plusieurs organismes if {[info exists WIW($Qui,$Quoi)]} { return $WIW($Qui,$Quoi) } if {[info exists WIW("EstCharge")]} { if {[regexp {_([^_]+)$} $Qui Match CodeOrga]} { if {[info exists WIW(CodeOrga_$CodeOrga,$Quoi)]} { return $WIW(CodeOrga_$CodeOrga,$Quoi) } else { if {[info exists WIW(CodeOrga_$CodeOrga,OX)]} { set LeResultat {} foreach OX $WIW(CodeOrga_$CodeOrga,OX) { if {[info exists WIW($OX,$Quoi)]} { lappend LeResultat $WIW($OX,$Quoi) } } return $LeResultat } } } if {[info exists WIW($Qui,ListOfOX)]} { set LeR {} foreach OX $WIW($Qui,ListOfOX) { if {[info exists WIW($OX,$Quoi)]} { LConcat LeR $WIW($OX,$Quoi) } } return $LeR } if {[info exists WIW(CodeOrga_$Qui,OX)]} { return [WIW CodeOrga_$Qui $Quoi] } return "" } set WIW("EstCharge") 1 set Science [ScienceOiDeMonDomaine] # set FicWIW "[RepertoireDuGenome]/fiches/wiw.txt" set FicWIW "/genomics/link/$Science/fiches/wiw.txt" set WIW(Filename,) $FicWIW if {[file exists $FicWIW]} { array set WIW [ContenuDuFichier $FicWIW] return [WIW $Qui $Quoi] } set RepOip "/genomics/link/$Science/oip" NousAllonsAuBoulot $RepOip set NiveauSeq 0 foreach Nom [ListeDesPABs] { lappend WIW(ListOf,OP) $Nom foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "oip"]] { if {[string index $Ligne 0]!=">"} { lappend LaTranche $Ligne; continue } lassign [BAIOX $Ligne "AcceptIdOnly"] B Ac Id OX if {[info exists WIW($Ac,OX)] && $OX!=5763} { FaireLire "Double in $Nom\n$Ac\n$WIW($Ac,OX)\n$OX" } set WIW($Ac,OX) $OX if {[info exists WIW($Id,OX)] && $OX!=5763} { FaireLire "Double in $Nom\n$Id\n$WIW($Id,OX)\n$OX" } lappend WIW($OX,ListOfOP) $Nom lappend WIW($Nom,ListOfOX) $OX lappend WIW($Nom,ListOfID) $Id lappend WIW(ListOf,OX) $OX lappend WIW($OX,ListOfAC) $Ac lappend WIW($OX,ListOfID) $Id set CodeOrga [lindex [split $Id "_"] end] if {[info exists WIW(CodeOrga_$CodeOrga,OX)]} { if {[lsearch $WIW(CodeOrga_$CodeOrga,OX) $OX]<0} { lappend WIW(CodeOrga_$CodeOrga,OX) $OX lappend WIW(ListOf,CodeOrgaWithMultipleOX) $CodeOrga } } else { lappend WIW(ListOf,CodeOrga) $CodeOrga set WIW(CodeOrga_$CodeOrga,OX) $OX } if {[info exists WIW($OX,CodeOrga)] && [lsearch $WIW($OX,CodeOrga) $CodeOrga]<0} { lappend WIW($OX,CodeOrga) $CodeOrga lappend WIW(ListOf,OXWithMultipleCodeOrga) $OX } else { set WIW($OX,CodeOrga) $CodeOrga } if {$NiveauSeq} { set WIW($Ac,OX) $OX set WIW($Id,OX) $OX set WIW($Ac,AC) $Ac set WIW($Id,AC) $Ac set WIW($Ac,ID) $Ac set WIW($Id,IC) $Id lappend WIW($Nom,ItsAC) $Ac lappend WIW($Nom,ItsID) $Id lappend WIW(ListOf,AC) $Ac lappend WIW(ListOf,ID) $Id } } set WIW($Nom,ListOfID) [lsort $WIW($Nom,ListOfID)] } if {[info exists WIW(ListOf,CodeOrgaWithMultipleOX)]} { set WIW(ListOf,CodeOrgaWithMultipleOX) [lsort -unique $WIW(ListOf,CodeOrgaWithMultipleOX)] } set WIW(ListOf,OX) [lsort -integer -unique $WIW(ListOf,OX)] foreach OX $WIW(ListOf,OX) { set WIW($OX,ListOfOP) [lsort -unique $WIW($OX,ListOfOP)] } foreach OP $WIW(ListOf,OP) { set WIW($OP,ListOfOX) [lsort -integer -unique $WIW($OP,ListOfOX)] } Sauve [array get WIW] dans $FicWIW OnRevientDuBoulot return [WIW $Qui $Quoi] } proc WIWB {{Qui ""} {Quoi ""}} { #rR Who Is Where in the Blast global WIWB if {$Quoi==""} { if {[EstUnPAB $Qui]} { set Quoi "Queries" } else { set Quoi "Nom" } } if {[info exists WIWB($Qui,$Quoi)]} { return $WIWB($Qui,$Quoi) } if {[info exists WIWB("EstCharge")]} { return "" } set WIWB("EstCharge") 1 set Fichier "[RepertoireDuGenome]/fiches/WhereIsCodeOrga.txt" foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" Nom lappend WIWB(ListOf,Nom) $Nom set LesQuery [lrange [split $Ligne " "] 1 end] set WIWB($Nom,Queries) $LesQuery foreach Query $LesQuery { lappend WIWB($Query,Nom) $Nom lappend WIWB(ListOf,Queries) $Query } } set WIWB(ListOf,Queries) [lsort -unique $WIWB(ListOf,Queries)] return [WIWB $Qui $Quoi] } proc WaliSourceDir {{Value ""}} { global WaliSourceDir if {$Value!=""} { set WaliSourceDir $Value } if { ! [info exists WaliSourceDir]} { set WaliSourceDir "[HomeRipp]/wwwLinux/wali" } return $WaliSourceDir } proc Warne {Texte} { global WarneWindow global WarneEnPuts global WarneNon if {[info exists WarneNon] && $WarneNon} { return "" } if { ! [info exists WarneEnPuts]} { set WarneEnPuts 1 } if { [info exists WarneEnPuts] && $WarneEnPuts } { puts $Texte return $Texte } # return "" Wup "La suite est a revoir si Warne dans fenetre" if { ! [info exists WarneWindow] || ! [winfo exists $WarneWindow]} { set WarneWindow [AfficheVariable "Warnings..." "" "Warnings"] wm iconify $WarneWindow } $WarneWindow.frame.list insert end $Texte $WarneWindow.frame.list yview end update return $WarneWindow } proc WarneReading {Texte} { global WarneReading global RepertoireDuGenome set Fichier "$RepertoireDuGenome/fiches/warne_reading" if { ! [info exists WarneReading]} { if {[file exists $Fichier]} { if {0 && [OuiOuNon "Do I warne reading problems in warne_reading file ?"]} { set WarneReading 1 File delete -force $Fichier } else { set WarneReading 0 } } else { set WarneReading 1 } } if { ! $WarneReading} { return "" } return [AppendAuFichier $Fichier $Texte] } proc Warning2Text {aT} { upvar $aT tbl global TextOut lappend TextOut "[string repeat = 60]" if {$tbl(Title) ne ""} { lappend TextOut "[string toupper $tbl(Title)]" } if {$tbl(Text) ne ""} { lappend TextOut $tbl(Text) } lappend TextOut "[string repeat = 60]" lappend TextOut "" return } proc WarningNterCter {Box Ref Name} { #pas termine #peut pas utiliser RefPfam comme Ref car on n a pas les coord" set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord.aj" if {![file exists $FileMacsims]} {set FileMacsims "[RepertoireDuGenome]/macsimXml/$Box.orgord"} set CoordRef [CoordGenom $Box,$Ref coord] set CoordName [CoordGenom $Box,$Name coord] scan $CoordRef "%s %s %s" ChrRef StartRef StopRef scan $CoordName "%s %s %s" ChrName StartName StopName Espionne "$Ref $CoordRef" Espionne "$Name $CoordName" if {$ChrRef!=$ChrName} {return "la ref et le name ne sont pas sur meme chr"} set Result [DiffProt $FileMacsims] foreach Ligne [split $Result "\n"] { if {[regexp "^$Name" $Ligne]} { Espionne "$Ligne" scan $Ligne "%s %s %s" toto Nter Cter break } } if {[regexp "^-" $Nter]} { Espionne "onentre1" regsub -all {\-} $Nter "" Nter set nbbuc [expr $Nter * 3] Espionne "nbbuc $nbbuc" set limit [expr $StartRef-$nbbuc] Espionne "limit $limit" if {$StartName>$limit} { Espionne "warning" } else { Espionne "ok" } } if {[regexp "^-" $Cter]} { Espionne "onentre2" regsub -all {\-} $Cter "" Cter set nbbuc [expr $Cter * 3] Espionne "nbbuc $nbbuc" set limit [expr $StopRef-$nbbuc] Espionne "limit $limit" if {$StopName>$limit} { Espionne "ok" } else { Espionne "warning" } } } proc WarningsDesSeqs {} { global Warn if {! [info exists Warn]} {return} foreach e [array names Warn] { switch $e { "B" { FaireLire "There are B amino acids (stands for D or N) in the sequence of :\n[join [set Warn(B)] ","]\nSome computations won't be available !" AuLog @begin warning AuLog @title Warning : B amino acids AuLog @text "There are B amino acids (stands for D or N) in the sequence of :\n[join [set Warn(B)] ","]\nSome computations won't be available !" AuLog @end } "Z" { FaireLire "There are Z amino acids (stands for E or Q) in the sequence of :\n[join [set Warn(Z)] ","]\nSome computations won't be available !" AuLog @begin warning AuLog @title Warning : Z amino acids AuLog @text "There are Z amino acids (stands for E or Q) in the sequence of :\n[join [set Warn(Z)] ","]\nSome computations won't be available !" AuLog @end } "J" { FaireLire "There are J amino acids (stands for L or I) in the sequence of :\n[join [set Warn(J)] ","]\nSome computations won't be available !" AuLog @begin warning AuLog @title Warning : J amino acids AuLog @text "There are J amino acids (stands for L or I) in the sequence of :\n[join [set Warn(J)] ","]\nSome computations won't be available !" AuLog @end } "O" { FaireLire "There are unknown amino acids (O) in the sequence of :\n[join [set Warn(O)] ","]\nSome computations won't be available !" AuLog @begin warning AuLog @title Warning : unknown amino acids AuLog @text "There are unknown amino acids (O) in the sequence of :\n[join [set Warn(O)] ","]\nSome computations won't be available !" AuLog @end } "U" { if {[ModeI]} { set choix [tk_dialog .uwarn "Warning" "There are seleno-cysteins (U) residues in the sequence of :\n[join [set Warn(U)] ","]\nSome computations won't be available if you keep them.\nDo you want to replace them with C ?" "" 0 " Yes " " No "] } else { set choix 1 } AuLog @begin warning AuLog @title Warning : seleno-cystein amino acids if {$choix} { ChangeSelenoC2C AuLog @text "There are seleno-cystein amino acids (U) in the sequence of :\n[join [set Warn(U)] ","]\nThey have been replaced by cysteins (C)" } else { AuLog @text "There are seleno-cystein amino acids (U) in the sequence of :\n[join [set Warn(U)] ","]\nSome computations won't be available !" } AuLog @end } "Numbers" { FaireLire "There are numbers (0-9) in the sequence of :\n[join [set Warn(Numbers)] ","]\nSome computations won't be available !" AuLog @title Warning : numbers in sequence AuLog @text "There are numbers [0-9] in the sequence of :\n[join [set Warn(Numbers)] ","]\nSome computations won't be available !" AuLog @end } "BadPdb" { FaireLire "Can't download the following PDB entries from servers :\n[join [set Warn(BadPdb)] ","]\n" AuLog @title Warning : problems downloading PDB AuLog @text "Can't download the following PDB entries from servers :\n[join [set Warn(BadPdb)] ","]\n" AuLog @end } "ChnPdb" { FaireLire "Can't find the requested chain in the following PDB entries:\n[join [set Warn(ChnPdb)] ","]\n" } "Vide" { FaireLire "The following sequences names do not contain any amino acid sequences :\n[join [set Warn(Vide)] ","].\nThey will be discarded from the alignment." AuLog @title Warning : empty sequences AuLog @text "The following sequences names do not contain any amino acid sequences :\n[join [set Warn(Vide)] ","].\nThey will be discarded from the alignment." AuLog @end } } } return } proc WebInforme {Nom} { #rR je ne sais pas qui l'utilise !! set Info [ExtraitInfo $Nom] Html_ZeroToBody Html_Banner Wscope Html_BackTo $Nom Html_Append "
" Html_Append "

" Html_Append "Search any string within the infos files of [Science]" Html_Append "
    to search a Gene Name exactly, use the search string 'ValiGN: Pax6' (with ':' and one space)" Html_Append "

" Html_Append "

" Html_Append "

" Html_Append " " Html_Append " " Html_Append " Search string : " Html_Append " " Html_Append "     " Html_Append " " Html_Append " ListAll" Html_Append " FirstOne" Html_Append " NextOne" Html_Append " " Html_Append "     " Html_Append " GeneName Synonym : " Html_Append " " Html_Append "     " Html_Append " " Html_Append "

" Html_Append "

" #LP if {[OnTraite "EVImm"]} { Html_Append "

or do a blast search

" Html_Append "" } #LP Html_BodyToEnd return [Html_Get] } proc WebOrder {{LesSeq ""} {LesNom ""} {LesNot ""}} { if {$LesSeq=={}} { set LesSeq "OligosKeeper" } while {$LesSeq=="OligosKeeper" } { if { ! [OuiOuNon "Do we use OligosKeeper ?"]} { return "" } FaireLire "Please choose the OligoKeeper.tfas" set FiSeq [ButineArborescence "All" "[RepertoireDuGenome]/atelier/OligosKeeper/*.tfas"] if {$FiSeq==""} { continue } regsub {.tfas$} $FiSeq "" FiNom regsub {.tfas$} $FiSeq "" FiNot append FiNom ".noms" append FiNot ".nots" set LesSeq [LesLignesDuFichier $FiSeq] set LesNom [LesLignesDuFichier $FiNom] set LesNot [LesLignesDuFichier $FiNot] return [WebOrder $LesSeq $LesNom $LesNot] } if {[OuiOuNon "OligosKeeper\n We could keep that oligo-order in a file and order all together ?"]} { set FiSeq "" if { ! [OuiOuNon "Do we create a new OligosKeeper ?" 1]} { FaireLire "Please choose the OligoKeeper.tfas" set FiSeq [ButineArborescence "All" "[RepertoireDuGenome]/atelier/OligosKeeper/*.tfas"] } while {$FiSeq==""} { set FiSeq [FichierPourSaveAs "[RepertoireDuGenome]/atelier/OligosKeeper/OligosKeeper[Date].tfas"] if {$FiSeq=="" && [OuiOuNon "Do I cancel OligosKeeper ?"]} { break } if {$FiSeq==""} { continue } } regsub {.tfas$} $FiSeq "" FiNom regsub {.tfas$} $FiSeq "" FiNot append FiNom ".noms" append FiNot ".nots" foreach Seq $LesSeq Nom $LesNom Not $LesNot { if {$Nom==""} { set Nom "NoValue" } if {$Not==""} { set Not "NoValue" } AppendAuFichier $FiSeq $Seq AppendAuFichier $FiNom $Nom AppendAuFichier $FiNot $Not } return $FiSeq } while 1 { set FichierForm "~/oligo.php.html" set LeTexte {} lappend LeTexte "Il faut maintenant se connecter sur le site de commande d'oligos" lappend LeTexte "" lappend LeTexte "[UrlCommandeOligo]/login.html" lappend LeTexte "" lappend LeTexte "Se loguer, et sauver le cadre de commande dans le fichier" lappend LeTexte "$FichierForm" lappend LeTexte "" lappend LeTexte "Valider cette page en selectionnant le nom du fichier ci-dessus." lappend LeTexte "" lappend LeTexte " Merci." lappend LeTexte "" set Texte [join $LeTexte "\n"] set Retour [AfficheVariable $Texte "AvecRetour"] if {$Retour!=""} { break } if {[OuiOuNon "Do I cancel ?"]} { return "" } } while 1 { set NewForm [MiseAJourFormulairePourMichel $FichierForm $LesSeq $LesNom $LesNot] set FichierNewForm [Sauve $NewForm dans $FichierForm.html] set LeTexte {} regsub {\~} $FichierNewForm "" FichierNewForm lappend LeTexte "Il faut maintenant recharger le fichier suivant dans le browser (Windows ou Linux)" lappend LeTexte " en corrigeant pour que le PC s'y retrouve" lappend LeTexte "" lappend LeTexte "file://h:$FichierNewForm" lappend LeTexte "file://[HomeRipp]/$FichierNewForm" lappend LeTexte "" lappend LeTexte "et valider cette page si tout se passe bien." lappend LeTexte "" lappend LeTexte " Merci." lappend LeTexte "" set Texte [join $LeTexte "\n"] set Retour [AfficheVariable $Texte "AvecRetour"] if {$Retour!=""} { break } if {[OuiOuNon "Do I cancel ?"]} { return "" } } return $Retour } proc WebServer_Address {} { #Adresse du serveur web hebergeant ARPAnno global WebServer_Address if {[info exists WebServer_Address]} {return $WebServer_Address} #set WebServer_Address "http://bips.u-strasbg.fr:85" set WebServer_Address "http://bips.u-strasbg.fr" #set WebServer_Address "https://crpgtw.crp-sante.healthnet.lu/http://crpbio.crp-sante.healthnet.lu" #set WebServer_Address "http://bioinfo.crp-sante.lu" #set WebServer_Address "http://www.bioinformatics.lu" return $WebServer_Address } proc WebService {Qui Commande args} { #rR args est une liste key value key value key value #rR pour Execute il faut utiliser querytext #rR voir les exemples dans TestWebService package require http set Url [WebServiceUrl $Qui] if {$Commande==""} { set QueryEncode [::http::formatQuery {*}$args] } else { set QueryEncode [::http::formatQuery "webcommand" $Commande {*}$args] } # set QueryEncode [::http::formatQuery from ACC to P_REFSEQ_AC format tab query P13368] # Espionne $QueryEncode set Token [::http::geturl $Url -query $QueryEncode] set Retour [::http::data $Token] set Retour [string trim $Retour] set iGetWhat [lsearch $args "getwhatfromserial"] if {$iGetWhat>=0} { set GetWhat [lindex $args [incr iGetWhat]] if {$GetWhat=="GetList"} { return [ListFromSerial $Retour] } if {$GetWhat=="GetFirstValue"} { return [FirstElementFromSerial $Retour] } } return $Retour } proc WebServiceOOOOOOOOOOLD {Qui Commande args} { #rR args est une liste key value key value key value set Url [WebServiceUrl $Qui] set QueryEncode [eval ::http::formatQuery "webcommand" $Commande $args] Espionne $QueryEncode set Token [eval ::http::geturl $Url -query $QueryEncode] set Retour [::http::data $Token] set Retour [string trim $Retour] set iGetWhat [lsearch $args "getwhatfromserial"] if {$iGetWhat>=0} { set GetWhat [lindex $args [incr iGetWhat]] if {$GetWhat=="GetList"} { return [ListFromSerial $Retour] } if {$GetWhat=="GetFirstValue"} { return [FirstElementFromSerial $Retour] } } return $Retour } proc WebServiceUrl {{Qui ""}} { if {$Qui=="GxDb" } { return "http://gx.lbgi.fr/gx/phpRR/lance.php?action=Munitions::WebService" } if {$Qui=="Gx" } { return "http://gx.lbgi.fr/gx/phpRR/lance.php?action=Munitions::WebService" } if {$Qui=="Genoret"} { return "http://genoret.lbgi.fr/genoret/phpRR/lance.php?action=Munitions::WebService" } return $Qui } proc WeightDeHenikoff {ListePil} { # Henikoff and Henikoff # # wi= 1/L sum 1/(Kx.Nx) # L = alignment length # Kx = number of amino acid types at position x # Nx = number of amino acid at pos x that # are the same as seq i # inits set NbSeq [string length [lindex $ListePil 0]] for {set i 0} {$i < $ns} {incr i} { set w($i) 0.0 } # loop over all positions foreach p $ListePil { # number of elements set lp [split $p ""] set kx [llength [lsort -unique $lp]] set i -1 foreach a $lp { incr i if {$a ne "."} { set na [expr {$NbSeq - [string length [string map [list $a ""] $p]]}] set w($i) [expr {[set w($i)] + 1./($na*$kx)}] } } } set Lw [list] set len [expr {double([llength $Lpil])}] for {set i 0} {$i < $NbSeq} {incr i} { lappend Lw [expr {[set w($i)]/$len}] } return $Lw } proc WeightDeVingron {Ln LPCI} { # Argos and Vingron # wi = 1/(N-1) sum_i!=j d(si,sj) # moyenne des distance de seq j aux autres array set T $LPCI set Ns [llength $Ln] foreach a $Ln { set sum 0.0 foreach b $Ln { if {$a eq $b} {continue} # Attention ! distance, pas PCI set sum [expr {$sum + (1. - [lindex [set T($a,$b)] 0])}] } lappend Lw [expr {$sum/($Ns-1)}] } return $Lw } proc WeightsDeLuc {Ln LPCI} { # circular weights # # wi = sum_i!=j wj x d(si,sj) # w = D x w # (1 - D)x w = 0 # # D = distance matrix # w = vector of weights # # solved using eigen decomposition # weights are coordinates of eigenvector of the # highest eigenvalue # package require math::linearalgebra set Ns [llength $Ln] set b [::math::linearalgebra::mkVector $Ns 1.0] set mt [::math::linearalgebra::mkMatrix $Ns $Ns 0.] set mf [::math::linearalgebra::mkMatrix $Ns $Ns 0.] # Matrix (1-D) # D = 1 - pci so 1 - D = pci array set T $LPCI set Md [list] foreach a $Ln { set Lv [list] foreach b $Ln { lappend Lv [lindex [set T($a,$b)] 0] } lappend Md $Lv } # eigen decomposition set Msg "" catch {set R [::math::linearalgebra::eigenvectorsSVD $Md]} Msg if {$Msg ne ""} { set Ns [llength $Ln] set v [expr {1.0/$Ns}] set Lw [lrepeat $Ns $v] FaireLire "Error while computing Eigen decomposition !\nAll weights are set to $v" puts "Error while computing Eigen decomposition !\nAll weights are set to $v" return $Lw } lassign $R V1 V2 # vector with highest eigenvalue ranks 0 set Lv [lindex $V1 0] # puts weights so that sum wi = 1. set b [lsort -real $Lv] set min [lindex $b 0] set max [lindex $b end] set eps 0.01 set s 0.0 foreach v $Lv { set x [expr {($v - $min + $eps)/($max - $min + $eps)}] lappend Lx $x set s [expr {$s + $x}] } set sum 0.0 set Lw [list] foreach x $Lx { set n [expr {$x / $s}] lappend Lw $n set sum [expr {$sum + $n}] } return $Lw } proc WelcomeToMe {} { PourWscope 1 set FichierPresentation "[RepertoireDuGenome]/html/index.html" if {[file exists $FichierPresentation]} { return [ContenuDuFichier $FichierPresentation] } set NomGscope [file tail [RepertoireDuGenome]] set PreFixe [PreFixe] set Organisme [NotreOS] if {$Organisme=="Inconnu inconnu"} { set Organisme "" } set TexteAffiche "$NomGscope $PreFixe $Organisme" return [H_Href $TexteAffiche "[WscopeServer]?$NomGscope&GuideMoi"] } proc WelcomeToWscope {{ReScan ""} {Order ""}} { PourWscope 1 if {$Order==""} { set Order 0 } set ReScan [regexp -nocase "ReScan" $ReScan] set Science [Science] set RepExisting "[GscopeDatabaseDir Zero]/fiches" set LesFichiersExistingProjects [lsort -decreasing [glob -nocomplain "$RepExisting/ExistingProjects*.txt"]] set FichierExistingProjects [lindex $LesFichiersExistingProjects 0] set Memorise 0 if {$ReScan || [FileAbsent $FichierExistingProjects]} { set Date [Date "YMD_HMS"] set FichierExistingProjects "$RepExisting/ExistingProjects_$Date.txt" set Memorise 1 } if {[FileAbsent $FichierExistingProjects]} { set LesTexteAffiche {} foreach FichierMiniConfig [lsort [glob "/genomics/link/*/beton/miniconfig"]] { set NomGscope [file tail [file dirname [file dirname $FichierMiniConfig]]] if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue } regsub "miniconfig$" $FichierMiniConfig "deny" FichierDeny if {[file exists $FichierDeny]} { continue } set OrganismeLu "Unknown organism name" set Prefixe "" foreach Ligne [LesLignesDuFichier $FichierMiniConfig] { if {[regexp "^NotreOS " $Ligne]} { scan $Ligne "%s %s %s" Bidon Genre Espece regsub {\.$} $Espece "" Espece set OrganismeLu "$Genre $Espece" continue } if {[regexp "PrefixeDesORFs" $Ligne]} { set Prefixe [StringApres "PrefixeDesORFs" dasn $Ligne] continue } } set Owner [StringApres "owner" dans [file attributes $FichierMiniConfig]] set Date [DateOfFile $FichierMiniConfig "NiceYMD"] set NbPab 0 set FichierBornes "[file dirname [file dirname $FichierMiniConfig]]/fiches/bornesdespabs" if {[file exists $FichierBornes]} { set NbPab [llength [LesLignesDuFichier $FichierBornes]] } if {[regexp -nocase {^[0-9]} $NomGscope] && $Owner=="jmuller"} { continue } ;#rR on enleve jmuller numerique set TexteAffiche "$NomGscope\t$OrganismeLu\t$NbPab\t$Prefixe\t$Owner\t$Date" lappend LesTexteAffiche $TexteAffiche } SauveLesLignes $LesTexteAffiche dans $FichierExistingProjects } else { set LesTexteAffiche [LesLignesDuFichier $FichierExistingProjects] } set LesTexteAffiche [lsort -dictionary $LesTexteAffiche] set NbProject [llength $LesTexteAffiche] if {$Order!=0} { #rR on retrie ! set LesLTA {} foreach TA $LesTexteAffiche { set LTA [split $TA "\t"] lappend LesLTA $LTA set TAdu($LTA) $TA } set LesLTATrie [lsort -index $Order -dictionary $LesLTA] set LesNouveauTexteAffiche {} foreach LTA $LesLTATrie { lappend LesNouveauTexteAffiche $TAdu($LTA) } set LesTexteAffiche $LesNouveauTexteAffiche } set LesRefText {} foreach TexteAffiche $LesTexteAffiche { scan $TexteAffiche "%s" NomGscope regsub "=.*" $NomGscope "" NomGscope lappend LesRefText "[WscopeServer]?$NomGscope&GuideMoi" $TexteAffiche } set DateVersion [file tail $FichierExistingProjects] regexp {[0-9]+_[0-9]+} $DateVersion DateVersion regsub {[0-9][0-9]$} $DateVersion "" DateVersion set AboutVersion "Last update: $DateVersion (if too old please update it)" set Titre "

" append Titre "

Click one of these $NbProject Gscope Projects in following list

" append Titre "

$AboutVersion   Order by " set C 0 foreach Header [list Project Orga NbProt Prefixe Owner Date] { append Titre " $Header" incr C } append Titre "

" append Titre "

" set Html [Html_ListOfRefs $LesRefText $Titre "PleaseSplitText"] return $Html } proc Wget {url args} { #rR from Kroc http://wfr.tcl.tk/1409 # Nom du fichier de sortie : if {[llength $args] && [lindex $args 0] eq "-O"} { set fichier [lrange $args 1 end] } else { set fichier [file tail $url] } # Téléchargement : if {![catch { package require http set fout [open $fichier w] set tok [http::geturl $url -binary 1 -channel $fout] http::wait $tok close $fout }]} { return [expr [http::ncode $tok] != 200] } return 1 } proc WgetAndLoadIntoDOPA {OrganismeTarget GenomeTarget {OrganismeQuery human} {GenomeQuery hg19} {NbPairesDeChromosomes 23} {BirdVersion bird}} { #script à lancer dans le repertoire ou l'on veut download les fichiers #Le nom du GenomeTarget doit commencer par une majuscule set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Start" set firstchar [string range $GenomeTarget 0 0] set rest [string range $GenomeTarget 1 10] set first [string tolower $firstchar] set GenomeTarget2 "$first$rest" for {set I 1} {$I < $NbPairesDeChromosomes} {incr I} { Espionne "Recuperation de http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" 2>@1 exec gunzip "/tmp/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" } exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chrX.$GenomeQuery.$GenomeTarget2.net.axt.gz" exec gunzip "chrX.$GenomeQuery.$GenomeTarget2.net.axt.gz" exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chrY.$GenomeQuery.$GenomeTarget2.net.axt.gz" exec gunzip "chrY.$GenomeQuery.$GenomeTarget2.net.axt.gz" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file ($OrganismeQuery VS $OrganismeTarget) start " set Extension "$VersionGenomeQuery.$VersionGenomeTarget.net.axt" set FichierDeDump [open "$PathOut/$VersionGenomeQuery.VS.$VersionGenomeTarget.dump" "w"] set genomeT $GenomeTarget set genomeQ $GenomeQuery set organismeT $OrganismeTarget set VraiNbChromosomes [expr $NbPairesDeChromosomes + 1] for {set I 1 } { $I <= $VraiNbChromosomes } {incr I} { if { $I < $NbPairesDeChromosomes } { set Chrox $I } else { if { $I == $NbPairesDeChromosomes } { set Chrox "X" } else { set Chrox "Y" } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA: Adding chromosom $Chrox to dump file" set FichierAli [open "$Path/chr$Chrox.$Extension" "r"] set CompteurIdentifiantUnique 0 while { [gets $FichierAli Ligne] >= 0 } { set FirstChar [string range $Ligne 0 0] while { $FirstChar == "#" } { gets $FichierAli Ligne set FirstChar [string range $Ligne 0 0] } incr CompteurIdentifiantUnique ScanLaListe $Ligne aligID chromosomeQ startQ endQ chromosomeT startT endT strandT score gets $FichierAli sequenceQ gets $FichierAli sequenceT gets $FichierAli ligneVide set access "$VersionGenomeQuery.chr$I.seq$CompteurIdentifiantUnique.VS.$VersionGenomeTarget" puts $FichierDeDump "$access|$genomeQ|$genomeT|$CompteurIdentifiantUnique|$organismeT|$chromosomeQ|$startQ|$endQ|$chromosomeT|$startT|$endT|$strandT|$score|$sequenceQ|$sequenceT" } close $FichierAli unset FichierAli } close $FichierDeDump set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file created. Loading..." set FichierDeDump [open "$PathOut/$VersionGenomeQuery.VS.$VersionGenomeTarget.dump" "r"] exec /biolo/bird/bin/bird_pub.sh $BirdVersion $Database.$Table $DumpFile | set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file loaded into DOPA" Espionne "$timestamp|WgetAndLoadIntoDOPA : Deleting Axt files" for {set I 1} {$I < $NbPairesDeChromosomes} {incr I} { file delete "chr$I.$GenomeQuery.$GenomeTarget2.net.axt" } file delete "chrX.$GenomeQuery.$GenomeTarget2.net.axt" file delete "chrY.$GenomeQuery.$GenomeTarget2.net.axt" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : End" } proc WgetAndLoadIntoDOPAmySql {OrganismeTarget GenomeTarget {OrganismeQuery human} {GenomeQuery hg18} {NbPairesDeChromosomes 23} {BirdVersion bird}} { #script à lancer dans le repertoire ou l'on veut download les fichiers #Le nom du GenomeTarget doit commencer par une majuscule set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Start" set firstchar [string range $GenomeTarget 0 0] set rest [string range $GenomeTarget 1 10] set first [string tolower $firstchar] set GenomeTarget2 "$first$rest" for {set I 1} {$I < $NbPairesDeChromosomes} {incr I} { Espionne "Recuperation de http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" catch { exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" } Espionne "Gunzipping /tmp/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" exec gunzip "/tmp/chr$I.$GenomeQuery.$GenomeTarget2.net.axt.gz" } catch { exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chrX.$GenomeQuery.$GenomeTarget2.net.axt.gz"} exec gunzip "chrX.$GenomeQuery.$GenomeTarget2.net.axt.gz" catch { exec wget "http://hgdownload.cse.ucsc.edu/goldenPath/$GenomeQuery/vs$GenomeTarget/axtNet/chrY.$GenomeQuery.$GenomeTarget2.net.axt.gz"} exec gunzip "chrY.$GenomeQuery.$GenomeTarget2.net.axt.gz" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file ($OrganismeQuery VS $OrganismeTarget) start " set Extension "$GenomeQuery.$GenomeTarget2.net.axt" set FichierDeDump [open "/tmp/alignements.csv" "w"] set genomeT $GenomeTarget2 set genomeQ $GenomeQuery set organismeT $OrganismeTarget set VraiNbChromosomes [expr $NbPairesDeChromosomes + 1] for {set I 1 } { $I <= $VraiNbChromosomes } {incr I} { if { $I < $NbPairesDeChromosomes } { set Chrox $I } else { if { $I == $NbPairesDeChromosomes } { set Chrox "X" } else { set Chrox "Y" } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA: Adding chromosom $Chrox to dump file" set FichierAli [open "/tmp/chr$Chrox.$Extension" "r"] set CompteurIdentifiantUnique 0 while { [gets $FichierAli Ligne] >= 0 } { set FirstChar [string range $Ligne 0 0] while { $FirstChar == "#" } { gets $FichierAli Ligne set FirstChar [string range $Ligne 0 0] } incr CompteurIdentifiantUnique ScanLaListe $Ligne aligID chromosomeQ startQ endQ chromosomeT startT endT strandT score gets $FichierAli sequenceQ gets $FichierAli sequenceT gets $FichierAli ligneVide set access "$GenomeQuery.chr$I.seq$CompteurIdentifiantUnique.VS.$GenomeTarget2" puts $FichierDeDump "$access\t$genomeQ\t$genomeT\t$CompteurIdentifiantUnique\t$organismeT\t$chromosomeQ\t$startQ\t$endQ\t$chromosomeT\t$startT\t$endT\t$strandT\t$score\t$sequenceQ\t$sequenceT" } close $FichierAli unset FichierAli } close $FichierDeDump set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file created. Loading..." exec /usr/bin/mysqlimport --user=anno --password=ceji387. --host=[LbgiHost] "ucsc$OrganismeQuery" "/tmp/alignements.csv" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : Dump file loaded into DOPA" Espionne "$timestamp|WgetAndLoadIntoDOPA : Deleting Axt files" for {set I 1} {$I < $NbPairesDeChromosomes} {incr I} { file delete "chr$I.$GenomeQuery.$GenomeTarget2.net.axt" } file delete "chrX.$GenomeQuery.$GenomeTarget2.net.axt" file delete "chrY.$GenomeQuery.$GenomeTarget2.net.axt" file delete "/tmp/alignements.csv" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|WgetAndLoadIntoDOPA : End" } proc WgetzSurWeb {molid {url ""} {GetUrl ""}} { set SiteRSCB "http://www.rcsb.org" set SiteIGBMC "http://bips.u-strasbg.fr" set WGetz "srsbin/cgi-bin/wgetz" set SwTr "swissprot_SP_sptrembl" # set SwTrNw "swissprot_SP_sptrembl_SP_sptnew" set Defauts(UrlPdbHome) "$SiteIGBMC/PipeAlign/get_pdb_file.cgi?XXXX" # set Defauts(UrlSRSHome) "$SiteIGBMC/$WGetz?-e+\[\{$SwTr\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2" set Defauts(UrlSRSHome) "http://www.ncbi.nlm.nih.gov/sites/entrez?Db=protein&Cmd=DetailsSearch&Term=XXXX" set Defauts(UrlRefSeqH) "$SiteIGBMC/$WGetz?-e+\[\{REFSEQ\}-acc:XXXX\]|\[REFSEQ-id:XXXX\]+-vn+2" set Defauts(UrlSRSWorld) "$SiteIGBMC/$WGetz?-e+\[\{$SwTr\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2" set Defauts(UrlPdbWorld) "$SiteRSCB/pdb/cgi/export.cgi/XXXX.pdb?format=PDB&pdbId=XXXX&compression=None" set Defauts(UrlUniprot) "http://www.uniprot.org/uniprot/XXXX" set site "UNK" if {$url == ""} { if {[EstUnAccessPDB $molid]} { set site "Pdb" set url $Defauts(UrlPdbHome) } else { set site "SRS" if {[regexp "^NM" $molid]} { set url $Defauts(UrlRefSeqH) } else { set url $Defauts(UrlUniprot) } } } if {[regexp "\:" $molid]} { set molid [StringApres ":" dans $molid] } regsub -all "XXXX" $url $molid url if {$GetUrl=="GetUrl"} { return $url } set LesLignes {} set TexteHTML [HttpGetTextFromUrl $url] if {$TexteHTML!=""} { set LesLignes [split $TexteHTML "\n"] } else { HttpCopy $url LesLignes } if {$site == "UNK"} {return $LesLignes} if {$site == "SRS"} { set TexteHTML [join $LesLignes "\n"] set Texte [ValeurDeLaBalise "pre" TexteHTML] set LesLignes [split $Texte "\n"] } set head "[string range [lindex $LesLignes 0] 0 1]" if { $head != "HE" && $head != "ID"} { set LesLignes {} regsub -all "XXXX" [set Defauts(Url${site}World)] $molid url HttpCopy $url LesLignes if {$site=="SRS"} { set TexteHTML [join $LesLignes "\n"] set Texte [ValeurDeLaBalise "pre" TexteHTML] set LesLignes [split $Texte "\n"] } set head "[string range [lindex $LesLignes 0] 0 1]" if { $head != "HE" && $head != "ID"} { set LesLignes "ERREUR" if {$site == "Pdb"} { if {[file exists "${molid}.pdb"]} { set LesLignes [LesLignesDuFichier "${molid}.pdb"] set head "[string range [lindex $LesLignes 0] 0 1]" if { $head != "HE"} {set LesLignes "ERREUR"} } } } } set LesBonnesLignes {} foreach Ligne $LesLignes { if {[regexp -nocase "} $Ligne $V Ligne } lappend LesBonnesLignes $Ligne } return $LesBonnesLignes } proc WhatIsMyUcscAccess {Path Database Organisme {BirdVersion star4}} { set FichierDesCoordonnees [open "$Path.fav" "r"] set FichierDesRequetes [open "$Path.sqp" "w"] set FichierDesProteines [open "$Path.pro" "w"] Espionne "WhatIsMyUcscAccess : Constitution des requetes" while { [gets $FichierDesCoordonnees LigneCoordonnees] >=0 } { ScanLaListe $LigneCoordonnees ID Reste puts $FichierDesRequetes "ID * DB UCSC" if { $Database == "knowngene"} { puts $FichierDesRequetes "WH SQLNATIVE select geneSymbol, protAcc from ucsc$Organisme.kgxref Where kgID='$ID'" } if { $Database == "refgene"} { puts $FichierDesRequetes "WH SQLNATIVE select geneSymbol, protAcc from ucsc$Organisme.kgxref Where refseq='$ID'" } puts $FichierDesRequetes "FM FLAT" puts $FichierDesRequetes "//" puts $FichierDesRequetes "ID * DB UCSC" if { $Database == "knowngene"} { puts $FichierDesRequetes "WH SQLNATIVE select description from ucsc$Organisme.kgxref Where kgID='$ID'" } if { $Database == "refgene"} { puts $FichierDesRequetes "WH SQLNATIVE select description from ucsc$Organisme.kgxref Where refseq='$ID'" } puts $FichierDesRequetes "FM FLAT" puts $FichierDesRequetes "//" } close $FichierDesRequetes close $FichierDesCoordonnees Espionne "WhatIsMyUcscAccess : Execution des requetes" set Tudu [BirdFetch "$Path.sqp" $BirdVersion "$Path.resultp"] set FichierDesRequetesExecutees [open "$Path.resultp" "r"] set FichierDesCoordonnees [open "$Path.fav" "r"] Espionne "WhatIsMyUcscAccess : Traitement des resultats proteiques" while { [gets $FichierDesRequetesExecutees LigneResultat] >=0 } { ScanLaListe $LigneResultat Entete1 gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat GeneSymbol ProtAcc gets $FichierDesRequetesExecutees LigneResultat ScanLaListe Entete2 gets $FichierDesRequetesExecutees LigneResultat ScanLaListe $LigneResultat Description regsub -all -nocase {\s} $LigneResultat "_" Description puts $FichierDesProteines "$LigneCoordonnees $GeneSymbol $ProtAcc $Description" gets $FichierDesCoordonnees LigneCoordonnees } close $FichierDesProteines close $FichierDesCoordonnees close $FichierDesRequetesExecutees } proc Which {Exe {AsRealpath ""}} { set AsRealpath [string equal -nocase "AsRealpath" $AsRealpath ] if {[catch {set Path [exec which $Exe]} ] } { return "" } Espionne $Path if {$AsRealpath} { return [Realpath $Path] } return $Path } proc WhichBanqueTBlastN {{BanqueTBlastN ""}} { if {$BanqueTBlastN!=""} { return $BanqueTBlastN } set LesBanquesTBlastNPossibles [glob -nocomplain "[RepertoireDuGenome]/tblastn*"] if {[llength $LesBanquesTBlastNPossibles]==0} { set BanqueTBlastN "" } else { set RepTBlastN [lindex $LesBanquesTBlastNPossibles 0] if {[llength $LesBanquesTBlastNPossibles]>1} { FaireLire "Please tell me which tblastn you want to use" set RepTBlastN [ChoixParmi $LesBanquesTBlastNPossibles] } set BanqueTBlastN [StringApres "/tblastn" dans $RepTBlastN] } return $BanqueTBlastN } proc WhyBiggerString {} { set file10items "/tempor/string/10/items_schema.v10.sql" set f [open $file10items r] set i 0 while {[gets $f Ligne] >= 0} { incr i if {[regexp {^COPY} $Ligne]} { lappend Lesi $i Espionne "$i $Ligne" continue } } Espionne "$Lesi" foreach i $Lesi { lappend Lesj $i lappend Lesj [expr $i -1] lappend Lesj [expr $i -2] lappend Lesj [expr $i -3] lappend Lesj [expr $i -4] lappend Lesj [expr $i -5] lappend Lesj [expr $i -6] lappend Lesj [expr $i -7] lappend Lesj [expr $i -8] lappend Lesj [expr $i -9] lappend Lesj [expr $i -10] } Espionne "$Lesj" set k 0 set g [open $file10items r] while {[gets $g Ligne] >= 0} { incr k foreach j $Lesj { if {$k==$j} { Espionne "$j $Ligne" } } } close $f close $g } proc WidthMode {AId val} { global Abr if {$val > 0} {set quoi wplus} {set quoi wmoins} ChangeCurseur $AId $quoi set PAD [set Abr($AId,PAD)] bind $PAD [list AppliqueWidth $AId $val] bind $PAD {} return } proc WikiTable {{TexteOuFichier ""} {What ""} {Separateur ""}} { if {$Separateur == ""} { set Separateur "\[\t|;\]" } if {$What == ""} { set What "Show" } if {[regexp "\n" $TexteOuFichier]} { set Texte $TexteOuFichier } else { if {[file exists $TexteOuFichier]} { set Texte [ContenuDuFichier $TexteOuFichier] } else { set Texte [EntreTexte $TexteOuFichier] } } set LesLignes [split $Texte "\n"] set LeNew [list "{|"] set Style "!" foreach Ligne $LesLignes { regsub -all $Separateur $Ligne "\n$Style" New lappend LeNew "$Style$New" lappend LeNew "|-" set Style "|" } lappend LeNew "|}" if {$What=="Show"} { return [AfficheVariable [join $LeNew "\n"] "AvecRetour" "WikiTable"] } if {$What=="GetList"} { return $LeNew } if {$What=="GetText"} { return [join $LeNew "\n"] } } proc WindowEditItem {type} { global EFeat set w .wedtf toplevel $w wm title $w "Feature Item Editor" wm iconname $w "Feature Editor" wm protocol $w WM_DELETE_WINDOW KillParLaCroix label $w.titre -text "Item Edition" -justify left -anchor w frame $w.f set ft $EFeat(Feat) if {$type eq "edit"} { label $w.f.lnm -text "Feature Name : " -justify right -anchor w label $w.f.lft -text " $ft " -justify left -anchor w } else { label $w.f.lm -text "Feature Name : " -justify right -anchor w entry $w.f.em -bg white -fg black -textvariable EFeat(Name) set wdt [PlusLongEltDe $EFeat(FTypes)] set EFeat(CbName) $w.f.cm ttk::combobox $w.f.cm -state readonly -width $wdt -background white -values $EFeat(FTypes) -textvariable EFeat(CName) $w.f.cm current 0 bind $w.f.cm <> [list SetFeatValue %W Name] } # Zone label $w.f.lz -text "Residue Range : " -justify right -anchor w if {[llength $EFeat(Lx1x2)] > 2} { label $w.f.lx -text "multiple zones" -justify left -anchor w } else { lassign [lindex $EFeat(Lx1x2) 1] EFeat(ZoneX1) EFeat(ZoneX2) entry $w.f.ex1 -width 6 -bg white -fg black -justify right -textvariable EFeat(ZoneX1) entry $w.f.ex2 -width 6 -bg white -fg black -justify right -textvariable EFeat(ZoneX2) #set wdt [PlusLongEltDe $EFeat(Lx1x2)] #ttk::combobox $w.f.cz -state readonly -width $wdt -background white -values $EFeat(Lx1x2) -textvariable EFeat(CRange) #$w.f.cz current 0 #bind $w.f.cz <> [list SetFeatValue %W Range] } # Color label $w.f.lc -text "Item Color : " -justify right -anchor w entry $w.f.ec -bg white -fg black -textvariable EFeat(Color) set wdt [PlusLongEltDe $EFeat(Lcolor)] set EFeat(CbColor) $w.f.cc ttk::combobox $w.f.cc -state readonly -width $wdt -background white -values $EFeat(Lcolor) -textvariable EFeat(CColor) $w.f.cc current 0 bind $w.f.cc <> [list SetFeatValue %W Color] # Score label $w.f.ls -text "Score : " -justify right -anchor w entry $w.f.es -bg white -fg black -justify right -textvariable EFeat(Score) set wdt [PlusLongEltDe $EFeat(Lscore)] set EFeat(CbScore) $w.f.cs ttk::combobox $w.f.cs -state readonly -width $wdt -background white -values $EFeat(Lscore) -textvariable EFeat(CScore) $w.f.cs current 0 bind $w.f.cs <> [list SetFeatValue %W Score] # Note label $w.f.ln -text "Note : " -justify right -anchor w entry $w.f.en -bg white -fg black -textvariable EFeat(Note) set wdt [PlusLongEltDe $EFeat(Lnote)] set EFeat(CbNote) $w.f.cn ttk::combobox $w.f.cn -state readonly -width $wdt -background white -values $EFeat(Lnote) -textvariable EFeat(CNote) $w.f.cn current 0 bind $w.f.cn <> [list SetFeatValue %W Note] if {$type eq "edit"} { grid $w.f.lnm -row 0 -column 0 -sticky e grid $w.f.lft -row 0 -column 1 -columnspan 2 -sticky w } else { grid $w.f.lm -row 0 -column 0 -sticky e grid $w.f.em -row 0 -column 1 -sticky w grid $w.f.cm -row 0 -column 2 -sticky ew } grid $w.f.lz -row 1 -column 0 -sticky e if {[llength $EFeat(Lx1x2)] > 2} { grid $w.f.lx -row 1 -column 1 -columnspan 2 -sticky w } else { grid $w.f.ex1 -row 1 -column 1 -sticky w grid $w.f.ex2 -row 1 -column 2 -sticky w } # color grid $w.f.lc -row 2 -column 0 -sticky e grid $w.f.ec -row 2 -column 1 -sticky e grid $w.f.cc -row 2 -column 2 -sticky ew # score grid $w.f.ls -row 3 -column 0 -sticky e grid $w.f.es -row 3 -column 1 -sticky e grid $w.f.cs -row 3 -column 2 -sticky ew # note grid $w.f.ln -row 4 -column 0 -sticky e grid $w.f.en -row 4 -column 1 -sticky e grid $w.f.cn -row 4 -column 2 -sticky ew grid columnconfig $w.f 2 -weight 1 frame $w.fb button $w.fb.ok -text " OK " -bg green1 -command [list AcceptNewValues $w $type ok] button $w.fb.dis -text "Dismiss" -bg red -command [list AcceptNewValues $w $type dismiss] grid $w.fb.dis -row 0 -column 0 -sticky w grid $w.fb.ok -row 0 -column 1 -sticky e grid columnconfig $w.fb all -weight 1 grid $w.titre -row 0 -column 0 -sticky ew -padx 10 -pady {10 15} grid $w.f -row 1 -column 0 -sticky news -padx 10 grid $w.fb -row 2 -column 0 -sticky news -padx 10 -pady {25 10} grid columnconfig $w all -weight 1 grab $w FenetreAuCentre $w tkwait window $w return } proc WindowSelectItemBy {} { set w .itemby toplevel $w wm title $w "Select Items by ..." wm iconname $w "Select" wm protocol $w WM_DELETE_WINDOW KillParLaCroix label $w.titre -text "Select Items by ..." -justify left -anchor w frame $w.f checkbutton $w.f.lr -text "Range : " -variable EFeat(UseRange) -onvalue 1 -offvalue 0 -justify right -anchor w entry $w.f.ex1 -width 6 -bg white -fg black -justify right -textvariable EFeat(ZoneX1) entry $w.f.ex2 -width 6 -bg white -fg black -justify right -textvariable EFeat(ZoneX2) label $w.f.lo -justify right -anchor w -text "or" checkbutton $w.f.ca -text "all alignment" -onvalue 1 -offvalue 0 -textvariable EFeat(AllAli) checkbutton $w.f.lco -text "Color : " -variable EFeat(UseColor) -onvalue 1 -offvalue 0 entry $w.f.eco -bg white -fg black -justify right -textvariable EFeat(Color) -justify right -anchor w frame $w.fb button $w.fb.ok -text " OK " -bg green1 -command [list AcceptNewValues $w $type ok] button $w.fb.dis -text "Dismiss" -bg red -command [list AcceptNewValues $w $type dismiss] grid $w.fb.dis -row 0 -column 0 -sticky w grid $w.fb.ok -row 0 -column 1 -sticky e grid columnconfig $w.fb all -weight 1 return } proc WithAnyWithSwForDao {RepertoireOut} { #RepertoireOut /home/poidevin/ordi/MS2PHProt/String_9606_201008161150 set WithAnyFile "$RepertoireOut/WithAny.string" set SummaryFile "$RepertoireOut/Summary.txt" foreach Ligne [LesLignesDuFichier $WithAnyFile] { if {[regexp "^PIDInitial" $Ligne]} {continue} set LesMots [split $Ligne "\t"] set IdSource [lindex $LesMots 0] set IdDest [lindex $LesMots 2] set SwSource [SwFromProtIDString9 $IdSource 9606] set SwSource [join $SwSource "_"] #set SwSource [FromSummary $IdSource IdInitial $SummaryFile] set SwDest [SwFromProtIDString9 $IdDest 9606] set SwDest [join $SwDest "_"] # Espionne "$IdSource $SwSource" # Espionne "$IdDest $SwDest" set LesMots [lreplace $LesMots 1 1 $SwSource] set LesMots [lreplace $LesMots 3 3 $SwDest] set LigneModif [join $LesMots "\t"] lappend LesLignesModif $LigneModif } SauveLesLignes $LesLignesModif dans "$RepertoireOut/WithAnyWithSw.string" } proc WithBrocOli {} { return [OuiOuNonMemo "Do we use BrocOli (Brocken Oligos) ?\nSo you have to do 2 PCRs." ] } proc WithOverlapAffymetrix {Nom} { return [llength [LesAffymetrixEnOverlap $Nom]] } proc WithPDB {Nom} { global RepertoireDuGenome global WithPDB if {[info exists WithPDB($Nom)]} { return [set WithPDB($Nom)] } if {[info exists WithPDB]} { return 0 } set FichierWithPDB "[RepertoireDuGenome]/fiches/withpdb" if {[file exists $FichierWithPDB]} { foreach Ligne [LesLignesDuFichier $FichierWithPDB] { scan $Ligne "%s %d" NomLu nPDB set WithPDB($NomLu) $nPDB } set WithPDB("EstCharge") 1 return [WithPDB $Nom] } if { ! [OuiOuNon "Do I count the PDBs in each blast ?"]} { set WithPDB("EstCharge") 1 return 0 } set Sortie {} foreach NomLu [ListeDesPABs] { set FichierBlast "$RepertoireDuGenome/blastp/$NomLu" if { ! [file exists $FichierBlast]} { continue } set nPDB 0 DecortiqueBlast $FichierBlast "" "" Quer lBanqueId lAccess lDE lProfil lPN foreach BanqueId $lBanqueId] { if {[EstUnAccessPDB $BanqueId]} { incr nPDB } } lappend Sortie "$NomLu $nPDB" set WithPDB($NomLu) $nPDB } SauveLesLignes $Sortie dans $FichierWithPDB return [WithPDB $Nom] } proc WithPackage {Pack {Valeur ""}} { global WithPackage if {$Valeur!=""} { set WithPackage($Pack) $Valeur } if {[info exists WithPackage($Pack)]} { return [set WithPackage($Pack)] } set WithPackage(Default,CafeDesSciences) [InsideCSTB] set WithPackage(Default,GscopeContrib) 1 set WithPackage(Default,GscopeSpecifique) 1 set WithPackage(Default,Genoret) 0 set WithPackage(Default,Ordali) 1 set WithPackage(Default,Correlator) 1 set WithPackage(Default,Math3D) 1 if { ! [info exists WithPackage(Default,$Pack)]} { set WithPackage(Default,$Pack) 0 } set WithPackage($Pack) [set WithPackage(Default,$Pack)] return [set WithPackage($Pack)] } proc WithWebService {{Qui ""} {Valeur ""}} { global WithWebService if {[string equal -nocase $Valeur "TestIfExists"]} { return [info exists WithWebService($Qui)] } if {$Qui==""} { set Qui "Gx" } if {$Valeur!=""} { set WithWebService($Qui) $Valeur} if {[info exists WithWebService($Qui)]} { return $WithWebService($Qui) } set WithWebService($Qui) 1 return [WithWebService $Qui] } proc WithinFed {} { return 0 } proc WithinGenoret {} { return 0 } proc WiwOxFrom {Qui} { global WiwOxFrom set Science [ScienceOiDeMonDomaine] #if { ! [OnTraite $Science]} { return [QuestionDeScience $Science "ret WiwOxFrom $Qui"] } if {[info exists WiwOxFrom($Qui)]} { return $WiwOxFrom($Qui) } if {[info exists WiwOxFrom("EstCharge")]} { set CodeOrga [lindex [split $Qui "|"] end] return [WIW CodeOrga_$CodeOrga OX] } set Science [ScienceOiDeMonDomaine] #set Fichier "[RepertoireDuGenome]/fiches/wiwoxfrom.txt" set Fichier "/genomics/link/$Science/fiches/wiwoxfrom.txt" if {[file exists $Fichier]} { array set WiwOxFrom [ContenuDuFichier $Fichier] } else { set WiwOxFrom("EstCharge") 1 foreach CodeOrga [WIW ListOf CodeOrgaWithMultipleOX] { Espionne $CodeOrga foreach OX [WIW CodeOrga_$CodeOrga OX] { Espionne $OX foreach Id [WIW $OX ListOfID] { if {$Id=="A0A0E9NSC1_9ASCO"} { Espionne $OX } set WiwOxFrom($Id) $OX } } } Sauve [array get WiwOxFrom] dans $Fichier } return [WiwOxFrom $Qui] } proc WobbleDeLacide {nom_acide} { global Wobble classes_default set acide "Acide_${nom_acide}" global Acide_${nom_acide} set nom_acide [string index $acide end] global Wobble_[set nom_acide] if {! [info exists Wobble($nom_acide)]} { puts "pas de wobble !" return } set wobble $Wobble($nom_acide) foreach ligne $wobble { foreach vclasse $classes_default { set $vclasse 0 } # Pour chaque anticodon, on regroupe les # valeurs des codons correspondants foreach arnc [lrange $ligne 1 end] { set arnc [string map {U T} $arnc] foreach vclasse $classes_default { set $vclasse [expr {[set $vclasse] + [set [set acide]($arnc,$vclasse)]}] } } set anti [lindex $ligne 0] foreach vclasse $classes_default { set Wobble_${nom_acide}($anti,$vclasse) [set $vclasse] } # Le tableau est de forme Wobble_aa(anticodon,classe) et contien le nombre de l'anticodon donnd dans cette classe } #parray Wobble_${nom_acide} return } proc WobbleDeLacidePourProt {nom_acide} { global Wobble classes_default set acide "Aprot_${nom_acide}" global Aprot_${nom_acide} set nom_acide [string index $acide end] global Wprot_[set nom_acide] if {! [info exists Wobble($nom_acide)] || [llength $Wobble($nom_acide)] < 2} { #puts "pas de wobble !" return } set wobble $Wobble($nom_acide) foreach ligne $wobble { foreach vclasse $classes_default { set $vclasse 0 } # Pour chaque anticodon, on regroupe les # valeurs des codons correspondants set Lcd [split $ligne " "] foreach arnc [lrange $Lcd 1 end] { set arnc [string map {U T} $arnc] foreach vclasse $classes_default { set $vclasse [expr {[set $vclasse] + [set [set acide]($arnc,$vclasse)]}] } } set anti [lindex $Lcd 0] foreach vclasse $classes_default { set Wprot_${nom_acide}($anti,$vclasse) [set $vclasse] } # Le tableau est de forme : # Wobble_aa(anticodon,classe) et contient # le nombre de l'anticodon donnd dans cette classe } #parray Wobble_${nom_acide} return } proc WrapLeTexte {Texte {Largeur 50}} { if {[string length $Texte]<=$Largeur} { return [list $Texte] } set Entamme [string range $Texte 0 [expr $Largeur-1]] set DernierBlanc [string last " " $Entamme] if {$DernierBlanc<0} { set DernierBlanc $Largeur } set Entamme [string range $Texte 0 [expr $DernierBlanc - 1]] set Reste [string trim [string range $Texte $DernierBlanc end]] return [concat [list $Entamme] [WrapLeTexte $Reste $Largeur]] } proc WriteFogPrm {} { puts "\n-- FOG ----------" puts "| fog enabled $::fogon" puts "| system $::fogsys" puts "| coords $::fogcoords" puts "" return } proc WriteSelectedTaxId {} { set file [DemandeEtSauveFichier *] if {$file eq ""} {return} set f [open $file w] foreach i $::LTaxSelected { set Lv [$::db eval {select Name,Rank,Lineage from taxonomy where taxid=$i}] puts $f "$i\t[join $Lv \t]" } close $f return } proc WriteTaxName {tid nom x1 y1} { global Tx LModelId LUserId LShowId LTaxSelected HExstModel HExstUser HExstSel set PAD [set Tx(PAD)] set xi [SurGrille $x1] set yi [SurGrille $y1] set Etat $Tx(Etat,$tid) # open/close node if {$Etat != -1} { set Id [DrawOpenCloseArrow $PAD $xi $yi $Etat] $PAD itemconfig $Id -tags [list "A${tid}" Arrow] lassign [$PAD bbox $Id] xmt ymt xxt yxt incr xi [expr {$xxt-$xmt}] if {$Tx(NbInt,$tid) > 0} { # number of intermediate nodes set Id [$PAD create text [list $xi $yi] -fill white -font TaxFont -text "$Tx(NbInt,$tid)" -anchor w -justify center -tags [list "NI$tid" IntFlag]] lassign [$PAD bbox $Id] xmt ymt xxt yxt incr xmt -1 ; incr xxt 1 incr ymt 1 ; incr yxt -1 if {$Tx(ShowInt,$tid)} { set fillInt "magenta" } else { set fillInt "blue" } set Id [$PAD create rectangle [list $xmt $ymt $xxt $yxt] -outline black -fill $fillInt -tags [list "RI$tid" RectInt IntFlag]] incr xi [expr {2 * ($xxt-$xmt-1)}] } } else { set xt [expr {$xi+10}] $PAD create line [list $xi $yi $xt $yi] -fill $Tx(fgCan) -width 1 -tags {Line} incr xi 20 } if {[info exists HExstModel($tid)]} { set cfill cyan set ctext black } elseif {$Tx(isInt,$tid)} { set cfill pink set ctext black } elseif {[info exists HExstUser($tid)]} { set cfill yellow set ctext black } else { set cfill $Tx(bgCan) set ctext $Tx(fgCan) } set Id [$PAD create text [list $xi $yi] -fill $ctext -font TaxFont -text $nom -anchor w -justify left -tags {"N$tid" NodeName LNode}] $PAD addtag "N$tid" withtag $Id # rectangle under name set RId [$PAD create rectangle [$PAD bbox $Id] -fill $cfill -outline $Tx(bgCan) -width 2 -tags {"R$tid" Rleaf LNode}] $PAD addtag "R$tid" withtag $RId $PAD raise $Id # create sensor $PAD create rectangle [$PAD bbox $Id] -fill "" -outline "" -tags sensor # if n is a leaf if {$Etat == -1} { $PAD addtag Leaf withtag $Id $PAD addtag Leaf withtag $RId if {[info exists HExstSel($tid)]} { $PAD itemconfig $RId -outline $Tx(fgCan) } } return } proc WriteTaxNameHTML {tid doBaton} { global TaxRoot Tx HExstSel HExstModel HExstUser LSelectableId set Etat $Tx(Etat,$tid) set nom $Tx(Name,$tid) set spanInt "" set LClasses [list] set LClassesNom [list] if {$tid == $TaxRoot} { lappend LClasses noleftmargin } if {$Etat != -1} { if {! $Tx(isInt,$tid)} { lappend LClasses toggable set type "noeud" } else { set type "internal" } # open/close state if {$Etat} { # div content affichee set disTit "none" set disCon "block" } else { set disTit "block" set disCon "none" } # number of internal nodes if {$Tx(NbInt,$tid) > 0} { if {$Tx(ShowInt,$tid)} { set fillInt "magenta" } else { set fillInt "blue" } set spanInt "$Tx(NbInt,$tid)" } # vertical line linking brothers if {$doBaton} { set cplus "solid" } else { set cplus "none" } } else { set type "feuille" } if {[info exists Tx(Rank,$tid)]} { set Rank [set Tx(Rank,$tid)] } else { set Rank "" } if {[info exists HExstModel($tid)]} { lappend LClassesNom cmodel } elseif {[info exists HExstUser($tid)]} { lappend LClassesNom cuser csel } if {[info exists HExstSel($tid)]} { lappend LClassesNom csel } if {$Tx(isInt,$tid) && $Etat != -1} { set type "internal" set par $Tx(Parent,$tid) while {$Tx(isInt,$par)} { set par $Tx(Parent,$par) } lappend LClasses "batardde$par" cacheDiv } # tid may not be a leaf, but a complete genome if {$Tx(isComp,$tid)} { lappend LClassesNom cfeuille } set imgArrowOpen "" set imgArrowClose "" switch $type { "noeud" { return "

$imgArrowClose $spanInt $nom

$imgArrowOpen $spanInt $nom " } "feuille" { return "

$nom " } "internal" { return "

$nom " } } } proc WscopeApplet {} { if {[SciencePublic [Science]]} { set RepApplet "~ripp/gagapplet" } else { set RepApplet "gag/applet" } set WscopeApplet "[WscopeSite]/$RepApplet" return $WscopeApplet } proc WscopeCgibin {} { #rR il vaut mieux utiliser WscopeServer !!! mais c'est pas encore tres clair pour moi if {[ScienceIsPublic]} { set RepCgi "~ripp/cgi-bin" } else { set RepCgi "gag/cgi-bin" } set WscopeCgibin "[WscopeSite]/$RepCgi" return $WscopeCgibin } proc WscopeICDS {} { return "http://www.lbgi.fr/~ripp/cgi-bin/gscope_html_server.tcsh?ICDS" } proc WscopeLinks {{Context ""} {Qui ""}} { if {$Context==""} { set Context "GuideMoi" } set Fichier "[RepertoireDuGenome]/fiches/WscopeLinks$Context.txt" if {[FileAbsent $Fichier]} { return {} } set LesRT {} foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^\#} $Ligne]} { continue } regsub -all {\[Alias \$Qui\]} $Ligne [Alias $Qui] Ligne regsub -all {\$\{Qui\}} $Ligne $Qui Ligne regsub -all {\$Qui} $Ligne $Qui Ligne regsub {\[Science\]} $Ligne [Science] Ligne regsub {\[PreFixe\]} $Ligne [PreFixe] Ligne regsub {\[LbgiUrl\]} $Ligne [LbgiUrl] Ligne regsub {\[GenoretGenesUrl\]} $Ligne [GenoretGenesUrl] Ligne regsub {\[WscopeServer\]} $Ligne [WscopeServer] Ligne regsub {\[WscopeScience\]} $Ligne [WscopeScience] Ligne regsub -all {\t+} $Ligne "\t" Ligne set RT [split $Ligne "\t"] set Ref [lindex $RT 0] set Text [join [lrange $RT 1 end] "\t"] ;#rR 2014/12/21 on garde les tab dans le texte. regsub -all {\&} $Ref "\&" Ref lappend LesRT $Ref $Text } return $LesRT } proc WscopeScience {{NewValue ""}} { global WscopeScience if {$NewValue!=""} { set WscopeScience $NewValue } if {[info exists WscopeScience]} { return $WscopeScience } set WscopeScience "[WscopeServer]?[Science]" return $WscopeScience } proc WscopeServer {{NewValue ""}} { # set WscopeServer "[WscopeCgibin]/GscopeServer" # return $WscopeServer #rR AAAAAA Attention pas encore fini #rR cette procédure doit rendre WscopeServer.tcl soit par le chemin WscopeServer soit par wscoperr #rR Mais ... WscopeServer.tcl ne marche pas encore bien. #rR en fait il faut corriger WscopeServer.tcl pour qu'il soit comme gscope_html_server.tcsh global WscopeServer #rR j'ai collé ça la dedans !!!!!! Je suppose que c'est pour rendre le meme que l'appelant. if {[RequestUriFromWscope]!=""} { regsub "/.*" [RequestUriFromWscope] "" Server return $Server } #rR on peut aussi le positionner dans gscope lui même if {$NewValue!=""} { set WscopeServer $NewValue } if {[info exists WscopeServer]} { return $WscopeServer } #rR là est le défaut : if {[ScienceIsPublic]} { set WscopeServer "wscoperr" } else { set WscopeServer "WscopeServer" } return $WscopeServer } proc WscopeSite {} { #rR .................................................... essai du 2014/05/15 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! set WscopeSite "" # set WscopeSite "http://www.lbgi.fr" } proc WscopeWebForm {args} { global PagePropre set Fenetre "" set LaSelection {} set Bouton "" set TexteB "" set VarToSet "" foreach {k v} $args { if {$k=="fenetre"} { set Fenetre $v continue } if {$k=="selectedlines"} { regsub -all {\[} $v "\\\[" v regsub -all {\]} $v "\\\]" v regsub -all {\"} $v "\\\"" v regsub -all {\$} $v "\\\$" v lappend LaSelection $v continue } set Bouton $k set TexteB $v if {$k=="vartoset"} { set VarToSet $v } } regsub "_" $Fenetre "." PFenetre set Selection [join $LaSelection "\n"] set LesInfosDuBouton [TouchePourWscope "LesInfosDuBouton" $Bouton] if {$LesInfosDuBouton=={}} { return [GuideMoi "Sorry, it seems the Gscope process was canceled on the server. I just restarted it, running a new session."] } lassign $LesInfosDuBouton Clavier Texte Commande Maniere Couleur regsub {\[selection get\]} $Commande "\"$Selection\"" Commande # LogWscope [string range $Commande 0 100] if {[regexp {set VariableDeRetour\(([^\)]+)\) (.*)} $Commande Match Var Val]} { set Val [string trim $Val "\""] global VariableDeRetour ; set VariableDeRetour($Var) $Val ;#rR servira peut etre un jour if {$VarToSet!=""} { global $VarToSet ; set $VarToSet $Val } return "Please kill this window and go back to the calling window to continue your Job" return "'" } LogWscope [string range $Commande 0 1000] if {[catch {set R [eval $Commande]} Message]} { LogWscope $Message; return $Message } if {$R==""} { set R "Nothing to display" } return $R } proc Wup {Texte} { } proc Wup_CACHEparRR {Texte} { } proc XGSPourOwner {Selection} { if {[regexp "\n" $Selection]} { foreach Ligne [split $Selection "\n"] { XGSPourOwner $Ligne } return } if { ! [regexp -nocase {[a-z]} $Selection]} { return "" } ScanLaLigneSpine $Selection XGS set LigneCorrigee [Entre $Selection] if {$LigneCorrigee==""} { return "" } ScanLaLigneSpine $LigneCorrigee X Al Ac SpOk SpTsk Owner Or set NouvelleLigne [format "%s %-15s %-15s %1s %-4s %-20s %s" $X $Al $Ac $SpOk $SpTsk $Owner $Or] set NouveauXGS($XGS) $NouvelleLigne return [RefreshFichierXGS NouveauXGS] } proc XML4Macsim {f} { set Ll [LesLignesDuFichier $f] set o [open $f w] foreach l $Ll { if {! [regexp {goxref|goid|goclass|molecularweight|isoelectric} $l]} { puts $o $l } } close $o return } proc XYZCenterAtom {} { global pgl TypeRep AtomePique Rad if {$AtomePique eq ""} {return 0} lassign [Tag2MolObjAtm $AtomePique] mol obj atm lassign [$mol AtomXYZ $atm] x y z set pgl(xCen) $x set pgl(yCen) $y set pgl(zCen) $z set pgl(xTra) 0.0 set pgl(yTra) 0.0 set pgl(zTra) 0.0 set pgl(frontclip) [expr {$Rad+$pgl(zCen)}] set pgl(backclip) [expr {$pgl(zCen)-$Rad}] set pgl(eyeZ) $pgl(frontclip) update return 1 } proc XenoGreffe {{FichierAccessProbeset ""}} { if {$FichierAccessProbeset==""} { set FichierAccessProbeset [ButineArborescence "all" "[RepertoireDuGenome]/"] } set NewRep [file tail $FichierAccessProbeset] regsub {\.txt} $NewRep "" NewRep if {[FileAbsent "[RepertoireDuGenome]/$NewRep"]} { file mkdir "[RepertoireDuGenome]/$NewRep" } if {[FileAbsent "[RepertoireDuGenome]/$NewRep/FASTA_NM"]} { file mkdir "[RepertoireDuGenome]/$NewRep/FASTA_NM" } if {[FileAbsent "[RepertoireDuGenome]/$NewRep/FASTA"]} { file mkdir "[RepertoireDuGenome]/$NewRep/FASTA" } if {[FileAbsent "[RepertoireDuGenome]/$NewRep/EMBL"]} { file mkdir "[RepertoireDuGenome]/$NewRep/EMBL" } set LesIntrouvables {} set LesBons {} foreach Ligne [LesLignesDuFichier $FichierAccessProbeset] { scan $Ligne "%s %s" NM PS set NmPs "${NM}_$PS" set Trouve 0 foreach Rep [list "FASTA_NM" "FASTA" "EMBL"] { set Fic "[RepertoireDuGenome]/$NewRep/$Rep/$NmPs" if {[FileExists $Fic]} { lappend LesBons $Fic Espionne $Fic set Trouve 1 continue } } if {$Trouve} { continue } set LesLignesEMBL [LaSequenceDesBanques $NM] EspionneL $LesLignesEMBL if {$LesLignesEMBL!={}} { SauveLesLignes $LesLignesEMBL dans "[RepertoireDuGenome]/$NewRep/FASTA_NM/${NM}_$PS" Espionne "$NM $PS recupere pour FASTA_NM" continue } Espionne "$NM $PS est introuvable" lappend LesIntrouvables "$NM $PS est introuvable" } SauveLesLignes $LesIntrouvables dans "[RepertoireDuGenome]/$NewRep/LesIntrouvables.txt" foreach Fic $LesBons { Espionne $Fic set Queue [file tail $Fic] set Rep [file tail [file dirname $Fic]] set TFA "" if {$Rep=="FASTA" || $Rep=="FASTA_NM"} { set Seq [QueLaSequenceDuFichierTFA $Fic] set TFA [SequenceFormatTFA $Seq "$Queue" "nucbrut"] } if {$Rep=="EMBL"} { set TFA [SequenceFormatTFA [ContenuDuFichier $Fic] "$Queue" "embl"] } Espionne [Sauve $TFA dans "[RepertoireDuGenome]/$NewRep/nuctfaOri/$Queue"] } } proc XenoGreffe22 {} { foreach Ligne [LesLignesDuFichier 22.txt] { scan $Ligne "%s %s" NM PS set LesLignesEMBL [LaSequenceDesBanques $NM "" a "OnVeutEMBL"] Espionne "$NM $PS" if {$LesLignesEMBL!=""} { SauveLesLignes $LesLignesEMBL dans "[RepertoireDuGenome]/XenoGreffeEMBL/${NM}_$PS" } else { set TFA [EntreTexte $NM] Sauve $TFA dans "[RepertoireDuGenome]/XenoGreffeFASTA/${NM}_$PS" } } } proc XieVsMatrix {} { set FichierDesCoordonneesIn [open "[Fiches]/Bidir/FichierDeCoordonnees-200603-AvecSequences-Et-ActaStart-EtDoublons.txt" "r"] set FichierDesCoordonneesOut [open "[Fiches]/Bidir/FichierDeCoordonnees-200603-AvecSequences-Et-ActaStart-EtDoublons-EtScores.txt" "w"] Espionne "XieVsMatrix : Start" set NbLectures 0 set NbSbs 0 while { [gets $FichierDesCoordonneesIn LigneCoordonnees] >=0 } { incr NbLectures ScanLaListe $LigneCoordonnees ID Type ChromosomeHg17 StartHg17 EndHg17 AccessHg17 BrinHg17 ChromosomeHg18 StartHg18 EndHg18 BrinHg18 ActaRallonge SbsPotentiel ActaRealStart DoublonOuOriginal Espionne $SbsPotentiel set Score "" set AverageScore "" set I 0 set ListeDesCaracteresDuSbs [split $SbsPotentiel ""] foreach Caractere $ListeDesCaracteresDuSbs { incr I set PosiScore [StafPosiScore $I $Caractere] set Score [expr $Score + $PosiScore] } if { $Score > 0 } { set AverageScore [expr $Score / 18] } else { set AverageScore 0 set Score 0 } set LigneOut "$LigneCoordonnees $ID $Type $ChromosomeHg17 $StartHg17 $EndHg17 $AccessHg17 $BrinHg17 $ChromosomeHg18 $StartHg18 $EndHg18 $BrinHg18 $ActaRallonge $SbsPotentiel $ActaRealStart $DoublonOuOriginal $AverageScore" puts $FichierDesCoordonneesOut $LigneOut if { $Score > 12} { incr NbSbs } } close $FichierDesCoordonneesIn close $FichierDesCoordonneesOut Espionne "XieVsMatrix : Done ($NbSbs SBS valides sur $NbLectures)" } proc XignalMiner {FichierFasta indiceFichier LongueurDesMots {ASortir ""} {monofasta yes} {combinations no} {MaxSpacer 0} {framed no} {masked yes} {typeSequence genome}} { #Recherche un enrichissement en signal en criblant tous les mots possibles dans un intervalle donné (en amont ou en aval d'une séquence). Se déplace sur toutes les positions et recense egalement pour chaque position les signaux. # Si on ne precise pas la longueur du classement a sortir, tous les mots trouves seront dans le fichier de sorti # Donc basiquement 4^X, X=longuer du mot considéré if {$ASortir == ""} { set ASortir [expr round(pow(4,$LongueurDesMots))] } set FichierOut [open "/tmp/XignalMiner.chr$indiceFichier.wordOf$LongueurDesMots.txt" "w"] set CompteurLus 0 set CompteurGC 0 set CompteurDeChar 0 set CompteurDeCharSaufN 0 set Max 0 set ListeDesAccess {} set SequenceTotale "" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Starting with monofasta=$monofasta, framed=$framed, masked=$masked, combinations=$combinations, typeSequence = $typeSequence." Espionne "$timestamp|XignalMiner|$LongueurDesMots: Expected outputs : $ASortir." set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Loading sequences of $FichierFasta" if {$typeSequence != "promoteur"} { set FichierIn [open "$FichierFasta" "r"] gets $FichierIn Ligne } if { $monofasta == "yes" } { lappend ListeDesAccess "Unique" array set SequenceTotaleArray [readFasta $FichierFasta 0] foreach Sequence $SequenceTotaleArray(index) { set SequenceTotale $SequenceTotaleArray($Sequence,sequence) } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Purifying" regsub -all -nocase {\s|\n|\t} $SequenceTotale "" SequenceTotale set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Adding to sequence list" flush stdout lappend ListeDesSequences $SequenceTotale set CompteurDeChar [string length $SequenceTotale] set Max $CompteurDeChar set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Counting GC rates" #set CompteurGC [llength [regexp -all -inline {G|C|g|c} $SequenceTotale]] #set CompteurDeCharSaufN [expr $CompteurDeChar - [llength [regexp -all -inline {N|n} $SequenceTotale]]] set CompteurLus 1 } else { if {$typeSequence == "promoteur"} { CanalSqlUcscHuman set FichierIn [open "$FichierFasta" "w"] foreach sequence [SqlExec "SELECT sequence from ucschuman.GeCo_prom" "-list"] { puts $FichierIn ">UneSequence" puts $FichierIn "$sequence" } close $FichierIn } set FichierIn [open "$FichierFasta" "r"] while { [gets $FichierIn Access] >=0 } { lappend ListeDesAccess $Access gets $FichierIn Ligne incr CompteurLus ScanLaListe $Ligne SequenceIn set LongueurSeq [string length $SequenceIn] set ListeDesChars [split $SequenceIn ""] foreach Char $ListeDesChars { if { $Char == "G" || $Char == "C" } { incr CompteurGC } if { $Char != "N" } { incr CompteurDeCharSaufN } incr CompteurDeChar } lappend ListeDesSequences $SequenceIn if { $Max < $LongueurSeq } { set Max $LongueurSeq } } } close $FichierIn #set TauxGC [expr (100*$CompteurGC)/$CompteurDeChar] #set TauxGcSansN [expr (100*$CompteurGC)/$CompteurDeCharSaufN] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] #Espionne "$timestamp|XignalMiner|$LongueurDesMots: $CompteurLus sequences loaded ($CompteurDeChar bases)" #Espionne "$timestamp|XignalMiner|$LongueurDesMots: GC%: $TauxGC % ($TauxGcSansN % without N)" Espionne "$timestamp|XignalMiner|$LongueurDesMots: Searching for overrepresented patterns of $LongueurDesMots bp" set ListeDesCompteursDuCadre {} set NombreDeCadres [expr $Max - $LongueurDesMots] for {set Cadre 0 } { $Cadre <= $NombreDeCadres} { incr Cadre } { array unset CompteursDuCadre set GoodCadre [expr $Cadre + 1] if {$framed == "yes"} { puts $FichierOut "Cadre $GoodCadre :" } foreach Sequence $ListeDesSequences { set Range [string range $Sequence $Cadre [expr $Cadre + $LongueurDesMots - 1]] if {$masked == "yes"} { if { [regexp {a|t|c|g|n|N} $Range] } { continue } } else { if { [regexp {N|n} $Range] } { continue } } set Range [string toupper $Range] set RangeComp [NucToReverseAndComplementNuc $Range] if { ![info exists CompteursDuCadre($Range)] } { set CompteursDuCadre($Range) 1 } else { incr CompteursDuCadre($Range) } if { !([info exists Compteurs($Range)] ||[info exists Compteurs($RangeComp)] ) } { set Compteurs($Range) 1 } elseif {[info exists Compteurs($Range)] } { incr Compteurs($Range) } elseif {[info exists Compteurs($RangeComp)] } { incr Compteurs($RangeComp) } } foreach MotCadre [array names CompteursDuCadre] { lappend ListeDesCompteursDuCadre [list $CompteursDuCadre($MotCadre) $MotCadre] } set ListeDesCompteursDuCadre [lsort -index 0 -integer -decreasing $ListeDesCompteursDuCadre] if {$framed == "yes"} { for { set K 0 } { $K < $ASortir } { incr K} { set ClassementCadre [lindex $ListeDesCompteursDuCadre $K] set GoodK [expr $K+1] #puts $FichierOutTotal "$GoodK: $ClassementCadre" } } set ListeDesCompteursDuCadre {} } foreach Mot [array names Compteurs] { lappend ListeDesCompteurs [list $Compteurs($Mot) $Mot] } set ListeDesCompteurs [lsort -index 0 -integer -decreasing $ListeDesCompteurs] set prevPattern "" set prevOccurences -1 for { set L 0 } { $L <= $ASortir } { incr L} { set Element [lindex $ListeDesCompteurs $L] ScanLaListe $Element NbOccurences Motif set MotifComp [NucToReverseAndComplementNuc $Motif] lappend ListeDesMotifs $Motif lappend ListeDesMotifs $MotifComp set GoodL [expr $L+1] set LigneOut "$GoodL\t$Motif\t$NbOccurences" if { $prevPattern == $Motif } { if {$prevOccurences == $NbOccurences} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Break at $L patterns" break } else { Espionne "$timestamp|XignalMiner|$LongueurDesMots: WARNING!!! Duplicate pattern with different occurences !!!" } } else { puts $FichierOut $LigneOut set prevPattern $Motif set prevOccurences $NbOccurences } } if { $combinations == "yes"} { set SequenceNum 0 array unset CompteursDuo Espionne "" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: ======================================" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: = PATTERN COMBINATION IN SEQUENCES =" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: ======================================" foreach Sequence $ListeDesSequences { incr SequenceNum for {set M 0 } { $M < [llength $ListeDesMotifs]} {incr M} { set Motif1 [lindex $ListeDesMotifs $M] for {set N 0 } { $N < [llength $ListeDesMotifs]} {incr N} { set Motif2 [lindex $ListeDesMotifs $N] set RegExp "$Motif1\[ATCG\]{0,$MaxSpacer}$Motif2" set ListeDesPositions [regexp -indices -all -inline "$RegExp" $Sequence] foreach PaireDeBornes $ListeDesPositions { set Motif1Comp [NucToReverseAndComplementNuc $Motif1] set Motif2Comp [NucToReverseAndComplementNuc $Motif2] set Range1 "$Motif1.x.$Motif2" set Range2 "$Motif2.x.$Motif1" set Range3 "$Motif1Comp.x.$Motif2" set Range3 "$Motif2Comp.x.$Motif1" set Range4 "$Motif1.x.$Motif2Comp" set Range4 "$Motif2.x.$Motif1Comp" set Range5 "$Motif1Comp.x.$Motif2Comp" set Range6 "$Motif2Comp.x.$Motif1Comp" if { !([info exists CompteursDuo($Range1)] || [info exists CompteursDuo($Range2)] || [info exists CompteursDuo($Range3)] || [info exists CompteursDuo($Range4)] || [info exists CompteursDuo($Range5)] || [info exists CompteursDuo($Range6)]) } { set CompteursDuo($Range1) 1 } elseif {[info exists CompteursDuo($Range1)] } { incr CompteursDuo($Range1) } elseif {[info exists CompteursDuo($Range2)] } { incr CompteursDuo($Range2) } elseif {[info exists CompteursDuo($Range3)] } { incr CompteursDuo($Range3) } elseif {[info exists CompteursDuo($Range4)] } { incr CompteursDuo($Range4) } elseif {[info exists CompteursDuo($Range5)] } { incr CompteursDuo($Range5) } elseif {[info exists CompteursDuo($Range6)] } { incr CompteursDuo($Range6) } ScanLaListe $PaireDeBornes Start End set Spacer [expr $End - $Start - [string length $Motif1] - [string length $Motif1] + 1] set Access [lindex $ListeDesAccess $SequenceNum ] Espionne "$timestamp|XignalMiner|$LongueurDesMots: $Access $PaireDeBornes ($Motif1.$Spacer.$Motif2)" } } } } set ListeDesCompteursDuo {} foreach Duo [array names CompteursDuo] { lappend ListeDesCompteursDuo [list $CompteursDuo($Duo) $Duo] } Espionne "" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: ======================================" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: =OVERREPRESENTED PATTERN COMBINATIONS=" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: ======================================" set ListeDesCompteursDuo [lsort -index 0 -integer -decreasing $ListeDesCompteursDuo] for { set P 0 } { $P < $ASortir } { incr P} { set ElementDuo [lindex $ListeDesCompteursDuo $P] ScanLaListe $ElementDuo NbDuo MotifDuo set GoodP [expr $P+1] set LigneOutF "$GoodP: $MotifDuo ($NbDuo times)" puts $FichierOut $LigneOutF Espionne "$timestamp|XignalMiner|$LongueurDesMots: $LigneOutF" } } close $FichierOut set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalMiner|$LongueurDesMots: Done" } proc XignalParser {WordOf {masked yes}} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Start" set FichierBienFormate [open "/tmp/XignalParser.WordOf$WordOf.sig" "w"] set ListeDesLignes {} set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Listing" set ListeDesPatterns {"Z"} foreach I { "Y" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 "X" } { set FichierAparser [open "XignalMiner.chr$I.wordOf$WordOf.txt" "r"] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] puts -nonewline "$timestamp|XignalParser: * adding chromosome $I" flush stdout set prevLigne "" set patternsDuFichier 0 set evidence "Z" while { [gets $FichierAparser Ligne] >=0 } { incr patternsDuFichier regsub -all -nocase {:\s|\sor\s|\s\(|\stimes\)} $Ligne "\t" LigneX set LigneX [string trim $LigneX] ScanLaListe $LigneX top pattern occurences set reverse [NucToReverseAndComplementNuc $pattern] if {$evidence == "$pattern $reverse $occurences"} { break } else { set evidence "$pattern $reverse $occurences" } if { [string compare $pattern $reverse] == -1 } { set temp $pattern set pattern $reverse set reverse $temp } lappend ListeDesLignes [list $pattern $reverse $occurences] } Espionne " ($patternsDuFichier patterns trouves)" flush stdout close $FichierAparser } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Sorting raw list" set ListeDesLignes [lsort -index 0 $ListeDesLignes] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Melting chromosomic occurencies" set precPattern "X" set precOccurences 0 set ListeDesUniques {} set greedylines 0 foreach Element $ListeDesLignes { ScanLaListe $Element pattern reverse occurences if { ($pattern == $precPattern || $reverse == $precPattern) && $precOccurences != $occurences} { set occurences [expr $occurences + $precOccurences] set melted 1 } else { set melted 0 if {$precPattern == "AAAAA" | $precPattern == "TTTTT"} { Espionne "Youhou $pattern $precPattern $occurences $precOccurences $greedylines" } if {$greedylines != 0} { set rev [NucToReverseAndComplementNuc $precPattern] lappend ListeDesUniques [list $precOccurences $precPattern $rev] } } set precPattern $pattern set precOccurences $occurences incr greedylines } lappend ListeDesUniques [list $occurences $pattern $reverse] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Sorting melted list" set ListeDesUniques [lsort -decreasing -integer -index 0 $ListeDesUniques] set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: Writing" set J 0 foreach ElementUnique $ListeDesUniques { incr J ScanLaListe $ElementUnique occurences pattern rev puts $FichierBienFormate "\t$pattern\t$rev\t$occurences\t$J\tgenome" } close $FichierBienFormate Espionne "$timestamp|XignalParser: Loading into in mySQL" if {$masked == "yes"} { file rename -force "/tmp/XignalParser.WordOf$WordOf.sig" "/tmp/patterns$WordOf.txt" exec /usr/bin/mysqlimport --user='anno' --password=ceji387. --host=[LbgiHost] -L ucschuman "/tmp/patterns$WordOf.txt" #file delete "/tmp/patterns$WordOf.txt" } else { file rename -force "/tmp/XignalParser.WordOf$WordOf.sig" "/tmp/patterns$WordOf_full.txt" exec /usr/bin/mysqlimport --user='anno' --password=ceji387. --host=[LbgiHost] -L ucschuman "/tmp/patterns$WordOf_full.txt" #file delete "/tmp/patterns$WordOf_full.txt" } set ListeToDelete [glob -nocomplain -directory "/tmp/" "XignalMiner.chr*..wordOf$WordOf*"] foreach Fichier $ListeToDelete { file delete $Fichier } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|XignalParser: End" } proc XmlFromRsf {NomOuFichier {FichierXml ""}} { set Nom "" set Fichier $NomOuFichier if { ! [regexp "/" $NomOuFichier]} { if {[EstUnPAB $NomOuFichier]} { set Nom $NomOuFichier set FichierPossible "[RepertoireDuGenome]/macsimRsf/$Nom" if {[FileExists $FichierPossible]} { set Fichier $FichierPossible } } } if {[FileAbsent $Fichier]} {return ""} if {$FichierXml==""} { if {$Nom!=""} { set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom" } else { regsub -nocase ".rsf$" $Fichier "" FichierXml append FichierXml ".xml" } } set GetText 0 if {$FichierXml=="GetText"} { set GetText 1 set FichierXml "[TmpFile].xml" } if {[catch {exec clustalw $Fichier -convert -output=macsim -outfile=$FichierXml} Message]} { return "" } if {$GetText} { set TexteXml [ContenuDuFichier $FichierXml] file delete $FichierXml return $TexteXml } return $FichierXml } proc XmlFromRsfMacsim {NomOuFichier {FichierXml ""}} { return XmlFromRsf $NomOuFichier $FichierXml } proc XmlValidePourTous {} { foreach Nom [ListeDesPABs] { set Fichier "[RepertoireDuGenome]/macsimXml/$Nom" if { ! [file exists $Fichier]} { continue } set Retour "nothing" if {[catch {set Retour [exec xmlvalid $Fichier]} Message]} { FaireLire "During the command 'xmlvalid $Fichier'\n I got the error message $Message\n and $Retour as output" continue } if {$Retour!=""} { FaireLire "During the command 'xmlvalid $Fichier'\n I got the output\n\'$Retour" continue } Espionne "Ok for xmlvalid $Fichier" } } proc XpertComment {Nom} { set Info [ExtraitInfo $Nom] regsub -all "\n" $Info "
\n" Info set Date [Date Nice] regsub -all " " $Date "_" Date regsub -all "\:" $Date "h" Date Html_ZeroToBody Html_Banner Wscope Html_Append "
" Html_Append "

" Html_Append "Please add your comment at the end" Html_Append "

" Html_Append "

" Html_Append "

" Html_Append " " Html_Append " " Html_Append " " Html_Append "$Info
" Html_Append "XpertComment: " Html_Append " " Html_Append "

" Html_Append "

" Html_BodyToEnd return [Html_Get] } proc XpertCommentNew {Nom {NewInfo ""}} { return [Html_DuTexteTelQuel [InformeSansDemander $Nom "XpertComment: $NewInfo"]] set Info [ExtraitInfo $Nom] regsub -all "\n" $Info "
\n" Info return [Html_DuTexteTelQuel "$Info\n
XpertComment: $NewInfo"] } proc XtoN {FichierTFA} { set E [open "$FichierTFA" "r"] set S [open "$FichierTFA.new" "w"] while {[gets $E Ligne]>=0} { if { ! [regexp ">" $Ligne]} { regsub -all -nocase "X" $Ligne "N" Ligne } puts $S $Ligne } exit } proc YEAHOrganisms {{A ""} {B ""} {C ""}} { set L {} foreach O [list "Sc" "Eh" "At" "Hs"] { if {$A==$O} { continue } if {$B==$O} { continue } if {$C==$O} { continue } lappend L $O } return $L } proc YEAHStore {{Qui ""} {Start ""} {Stop ""}} { global YEAHStore if {[info exists YEAHStore($Qui)]} { return $YEAHStore($Qui) } if {$Start==""} { set Start 0 } if {$Stop==""} { set Stop 999999 } if {$Qui==""} { set Qui "ListOfAccess" } if {[info exists YEAHStore($Qui)]} { return $YEAHStore($Qui) } if {[info exists YEAHStore("EstCharge")]} { return "" } set YEAHStore("EstCharge") 1 foreach O [YEAHOrganisms] { set n 0 set Fi "[RepertoireDuGenome]/DeJohan/$O.tfa" foreach Access [LaSequenceDuTFAs $Fi "LaListeDesAccess"] { incr n if {$n<$Start} { continue } if {$n>$Stop} { break } lappend YEAHStore(ListOfAccess) $Access set TFA [LaSequenceDuTFAs $Fi $Access] set YEAHStore($Access) $TFA } } return [YEAHStore $Qui] } proc YEAHbadThingsInAlignment {{FichierSource ""}} { if {$FichierSource==""} { set FichierSource "[RepertoireDuGenome]/msf/YEAH000001" } set LesLignes [LesLignesDuFichier $FichierSource] DecortiqueUnMSF $FichierSource LesSources set i 0 set OnAttend 1 set LesMauvais {} foreach Ligne $LesLignes { if {$OnAttend} { if {[regexp "//" $Ligne]} { set OnAttend 0 } continue } if { ! [regexp -nocase {[a-z]} $Ligne]} { set i 0 ; continue } scan $Ligne "%s" Access set Source [lindex $LesSources $i] if {$Access!=$Source} { lappend LesMauvais "$Source!=$Access dans $Ligne" } Espionne "$Source $Access" incr i } return $LesMauvais } proc YEAHbilan {Qui {Quoi ""}} { global YEAHbilan if {[info exists YEAHbilan($Qui,$Quoi)]} { return $YEAHbilan($Qui,$Quoi) } if {[info exists YEAHbilan("EstCharge")]} { return "" } set YEAHbilan("EstCharge") 1 foreach Org [YEAHOrganisms] { foreach Autre [YEAHOrganisms] { if {$Autre==$Org} { continue } set YEAHbilan([YeahOui $Org],[YeahOui $Autre]) {} set YEAHbilan([YeahOui $Org],[YeahNon $Autre]) {} } } foreach Org [YEAHOrganisms] { foreach Moi [YEAHpa $Org "MySeqs"] { set Others [YEAHpa $Moi "OtherBests"] # Espionne "$Moi $Others" set nAutres 0 foreach Toi $Others { set Autre [YEAHorganOf $Toi] if {$Autre==$Org} { continue } incr nAutres lappend YEAHbilan($Moi,$Autre) "$Moi $Toi" lappend YEAHbilan([YeahOui $Org],[YeahOui $Autre]) $Moi } foreach Autre [YEAHOrganisms] { if {$Autre==$Org} { continue } if {[info exists YEAHbilan($Moi,$Autre)]} { continue } set YEAHbilan($Moi,[YeahNon $Autre])) $nAutres lappend YEAHbilan([YeahOui $Org],[YeahNon $Autre]) $Moi } } foreach SaS [YEAHpa $Org "MySeqs"] { } } # return [YEAHbilan $Qui $Quoi] foreach I [YEAHOrganisms] { foreach Iin [list "Non" "Oui"] { foreach J [YEAHOrganisms $I] { foreach Jin [list "Non" "Oui"] { if { ! [info exists YEAHbilan([$Iin $I],[$Jin $J])]} { set YEAHbilan([$Iin $I],[$Jin $J]) {}} if { ! [info exists YEAHbilan([$Jin $J],[$Iin $I])]} { set YEAHbilan([$Jin $J],[$Iin $I]) {}} foreach K [YEAHOrganisms $I $J] { foreach Kin [list "Non" "Oui"] { foreach L [YEAHOrganisms $I $J $K] { foreach Lin [list "Non" "Oui"] { if { ! [info exists YEAHbilan([$Kin $K],[$Lin $L])]} { set YEAHbilan([$Kin $K],[$Lin $L]) {}} if { ! [info exists YEAHbilan([$Lin $L],[$Kin $K])]} { set YEAHbilan([$Lin $L],[$Kin $K]) {}} } } } } } } } } set Iin "Oui" foreach I [YEAHOrganisms] { foreach J [YEAHOrganisms $I] { foreach Jin [list "Non" "Oui"] { foreach K [YEAHOrganisms $I $J] { foreach Kin [list "Non" "Oui"] { foreach L [YEAHOrganisms $I $J $K] { foreach Lin [list "Non" "Oui"] { set BI [$Iin $I] set BJ [$Jin $J] set BK [$Kin $K] set BL [$Lin $L] set ListeIJ $YEAHbilan([$Iin $I],[$Jin $J]) set ListeIK $YEAHbilan([$Iin $I],[$Kin $K]) set ListeIL $YEAHbilan([$Iin $I],[$Lin $L]) set ListeIJK [ListsIntersection $ListeIJ $ListeIK] set ListeIJKL [ListsIntersection $ListeIJK $ListeIL] set YEAHbilan([$Iin $I],[$Jin $J],[$Kin $K],[$Lin $L]) $ListeIJKL } } } } } } } return [YEAHbilan $Qui $Quoi] set LeDazi {} foreach Org [YEAHOrganisms] { foreach Autre [YEAHOrganisms] { if {$Autre==$Org} { continue } lappend LeDazi "$Org $Autre [llength $YEAHbilan($Org,$Autre)]" } foreach Autre [YEAHOrganisms] { if {$Autre==$Org} { continue } lappend LeDazi "$Org non-$Autre [llength $YEAHbilan($Org,non-$Autre)]" } } AfficheVariable [join $LeDazi "\n"] } proc YEAHblast {{Banque ""}} { set SeuilExpect "1.0e-30" set MaxListe "30" if {$Banque==""} { set Banque "protall" } set Queue [file tail $Banque] foreach S [YEAHbilan "SC" "at,eh,HS"] { foreach X [YEAHpa $S "Hs"] { set FiTFA "[RepertoireDuGenome]/prottfa/$X" if {[FileAbsent $FiTFA]} { continue } set FichierBlast "[RepertoireDuGenome]/blastp$Queue/$X" if {[FileExists $FichierBlast]} { continue } if {[PasTouche $X]} { continue } BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect FinPasTouche $X } } } proc YEAHbosse {} { set SeuilExpect "1.0e-10" set MaxListe "SansLimiteDeNombre" set Banque "[RepertoireDuGenome]/banques/YEAH" foreach S [YEAHbilan "SC" "at,EH,hs"] { set LesH [YEAHpa $S Others] foreach H $LesH { set FiBla "[RepertoireDuGenome]/blastpYEAH/$H" if {[file exists $FiBla]} { continue } if {[PasTouche $H]} { continue } set FiTFA "[RepertoireDuGenome]/prottfa/$H" Espionne "$S $H" BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect FinPasTouche $H } } } proc YEAHcorrigeOffsetEtSpaceEtTilde {{Fichier ""}} { if {$Fichier==""} { set Fichier [ButineArborescence "" "[RepertoireDuGenome]/DeJohan"] } set LeNew {} set OnAttendSeq 1 set DansSeq 0 set Offset 0 foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp "^offset " $Ligne]} { set Offset [IntegerApres "offset" dans $Ligne] continue } if {$OnAttendSeq} { if {[regexp "^sequence" $Ligne]} { set OnAttendSeq 0 set DansSeq 1 set Sequence [string repeat "." $Offset] } lappend LeNew $Ligne continue } if {$DansSeq} { if {[regexp {^\}} $Ligne]} { set OnAttendSeq 1 set DansSeq 0 set Offset 0 set LaSequence {} set SequenceRestante $Sequence while 1 { if {$SequenceRestante==""} { break } set Bout [string range $SequenceRestante 0 59] set SequenceRestante [string range $SequenceRestante 60 end] lappend LeNew " $Bout" } lappend LeNew $Ligne continue } set Seq [string range $Ligne 2 end] regsub -all {[ ~]} $Seq "." Seq append Sequence $Seq continue } lappend LeNew $Ligne } regsub ".rsf" $Fichier "-OK.rsf" NewFichier return [SauveLesLignes $LeNew dans $NewFichier] } proc YEAHcreateGoodAlignment {{Fichier ""}} { if {$Fichier==""} { set Fichier [ButineArborescence "All"] } set FiRsfOri [GscopeFile "YEAH000001" rsforiginal] file copy -force $Fichier $FiRsfOri set MaquRsf [YEAHmaquilleRsf $Fichier] set GoodRsf [YEAHcorrigeOffsetEtSpaceEtTilde $MaquRsf] set FiRsf [GscopeFile "YEAH000001" rsf] file copy -force $GoodRsf $FiRsf set GoodMsf [ConvertToMsf $GoodRsf "GetFile"] set FiMsf [GscopeFile "YEAH000001" msf] file copy -force $GoodMsf $FiMsf Espionne "I created $FiMsf" set LesMauvais [YEAHbadThingsInAlignment $FiMsf] if {$LesMauvais!={}} { AfficheVariable [join $LesMauvais "\n"] "AvecFetch" "BadThingsInAlignment" } set FiMacsimXml [GscopeFile "YEAH000001" macsimXml] set FiMacsimRsf [GscopeFile "YEAH000001" macsimRsf] Macsims $FiMsf "DeleteXmlFile" $FiMacsimRsf ReordonneRsf $FiMacsimRsf "OrderFromMsf" "SameFile" exec clustalw $FiMacsimRsf -convert -output=macsims -outfile=$FiMacsimXml -outorder=input return $FiMacsimXml } proc YEAHfind {{Qui ""}} { if {$Qui==""} { set Qui [Entre] } if {$Qui==""} { return "" } scan $Qui "%s" Qui set Others [YEAHpa $Qui Others] if {$Others==""} { return "" } return [YEAHshowList $Qui $Others] } proc YEAHmaquilleAlignmentOld {{FichierSource ""} {FichierMaquille ""}} { if {$FichierSource ==""} { set FichierSource [GscopeFile YEAH000001 "msf"] } if {$FichierMaquille==""} { set FichierMaquille [GscopeFile YEAH000001 "msfwithlinks"] ; file mkdir "[RepertoireDuGenome]/msfwithlinks" } set LesNouveaux {} DecortiqueUnMSF $FichierSource LesSources set MaxAccess -1 foreach Source $LesSources { set Nouveau $Source if { [regexp -nocase {(NP|NM|XP)_?[0-9]+$} $Source Nouveau]} { } elseif {[regexp -nocase {^(SW|SPT)[_\:][A-Z0-9]+} $Source Nouveau]} { } elseif {[regexp -nocase {_([A-Z0-9]{6,})$} $Source Match Nouveau]} { } if {[regexp -nocase {^[0-9]+$} $Nouveau]} { set Nouveau "n:$Nouveau" } if { ! [regexp -nocase {[a-z]} $Nouveau]} { set Nouveau $Source } while {[info exists DejaVu($Nouveau)]} { append Nouveau "_2" } set DejaVu($Nouveau) $Source lappend LesNouveaux $Nouveau set MaxAccess [Maxi $MaxAccess [string length $Nouveau]] if {$Source!=$Nouveau} { Espionne "$Source $Nouveau" } # EspionneL [LaSequenceDesBanques $Nouveau] } global MaquilleNon set MemoMaquilleNon $MaquilleNon set MaquilleNon 0 set LeMaquille [MaquilleLeMSF $FichierSource $LesSources $LesNouveaux $MaxAccess] set MaquilleNon $MemoMaquilleNon set Maquille [join $LeMaquille "\n"] set FM [Sauve $Maquille dans $FichierMaquille] return $FM } proc YEAHmaquilleRsf {{FichierSource ""} {FichierMaquille ""}} { if {$FichierSource ==""} { set FichierSource [ButineArborescence "" "[RepertoireDuGenome]/DeJohan"] } if {$FichierMaquille==""} { set FichierMaquille $FichierSource regsub ".rsf" $FichierMaquille "" FichierMaquille append FichierMaquille "-maquille.rsf" } set LesDifferents {} set LesNouveaux {} set LeMaquille {} foreach Ligne [LesLignesDuFichier $FichierSource] { if { ! [regexp -nocase {^name +([^ ]+)} $Ligne Match Access]} { lappend LeMaquille $Ligne ; continue } set Nouveau $Access if {[regexp -nocase {^[0-9]+$} $Nouveau]} { set Nouveau "n:$Nouveau" } if { ! [regexp -nocase {[a-z]} $Nouveau]} { set Nouveau $Source } while {[info exists DejaVu($Nouveau)]} { append Nouveau "_2" } set DejaVu($Nouveau) $Access lappend LesNouveaux $Nouveau if {$Access!=$Nouveau} { lappend LesDifferents "$Access $Nouveau" } lappend LeMaquille "name $Nouveau" } regsub {\.rsf$} $FichierMaquille "" FichierDiff append FichierDiff "-DIFFERENCES.txt" set Diff [SauveLesLignes $LesDifferents dans $FichierDiff] set FM [SauveLesLignes $LeMaquille dans $FichierMaquille] AfficheFichier $FichierDiff return $FM } proc YEAHmouvement {} { set Les340 [LesLignesDuFichier "[Fiches]/SCHS340.txt"] foreach Ligne $Les340 { set SCHS340($Ligne) 1 } set Les319 [LesLignesDuFichier "[Fiches]/SCHS319.txt"] foreach Ligne $Les319 { set SCHS319($Ligne) 1 } set LeTout [lsort -unique [concat $Les340 $Les319]] set LesPerdus [list "LesPerdus"] set LesGagnes [list "LesGagnes"] set LesCommuns [list "LesCommuns"] foreach Ligne $LeTout { if {[info exists SCHS340($Ligne)]} { if {[info exists SCHS319($Ligne)]} { lappend LesCommuns $Ligne ; continue } lappend LesPerdus $Ligne ; continue } lappend LesGagnes $Ligne } set Dazi [join $LesPerdus "\n"] set F [AfficheVariable $Dazi "" "SortisDes340"] BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" set Dazi [join $LesGagnes "\n"] set F [AfficheVariable $Dazi "" "NouveauxDans319"] BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" set Dazi [join $LesCommuns "\n"] set F [AfficheVariable $Dazi "" "Communs340et319"] BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" return $F } proc YEAHorganOf {Qui} { return [string range $Qui 0 1] } proc YEAHpa {Qui {Quoi ""} {Val ""}} { global YEAHpa if {$Val != "" && ! [info exists YEAHpa("EstCharge")]} { YEAHpa "Load" if {$Qui!="Load"} { return [YEAHpa $Qui $Quoi $Val] } return "" } if {$Val != ""} { if { ! [info exists YEAHpa($Qui,$Quoi)]} { lappend YEAHpa(ListOf,Couples) "$Qui $Quoi" lappend YEAHpa($Qui,Others) $Quoi set YEAHpa($Qui,$Quoi) $Val } return $YEAHpa($Qui,$Quoi) } set FiYEAHpa "[Fiches]/YEAHpa.txt" if {$Qui=="Save"} { if { ! [info exists YEAHpa(ListOf,Couples)]} { YEAHpa "Load" } if { ! [info exists YEAHpa(ListOf,Couples)]} { return "" } set LesLignes {} foreach MT $YEAHpa(ListOf,Couples) { scan $MT "%s %s" Moi Toi set Val $YEAHpa($Moi,$Toi) lappend LesLignes "$Moi $Toi $Val" } SauveLesLignes $LesLignes dans $FiYEAHpa return $FiYEAHpa } if {[info exists YEAHpa($Qui,$Quoi)]} { return $YEAHpa($Qui,$Quoi) } if {[info exists YEAHpa("EstCharge")]} { return "" } set YEAHpa("EstCharge") 1 if {[file exists $FiYEAHpa]} { foreach Ligne [LesLignesDuFichier $FiYEAHpa] { set LesMots [split $Ligne " "] set Moi [lindex $LesMots 0] set Org [YEAHorganOf $Moi] lappend YEAHpa($Org,MySeqs) $Moi set Toi [lindex $LesMots 1] if {[info exists YEAHpa($Moi,$Toi)]} { continue } set Aut [YEAHorganOf $Toi] # Espionne "$Moi $Aut $Toi" if { ! [info exists YEAHpa($Moi,$Aut)]} { set YEAHpa($Moi,$Aut) $Toi lappend YEAHpa($Moi,OtherBests) $Toi } lappend YEAHpa($Moi,$Aut-all) $Toi set Val [lrange $LesMots 2 end] set YEAHpa($Moi,$Toi) $Val lappend YEAHpa($Moi,Others) $Toi lappend YEAHpa(ListOf,Couples) "$Moi $Toi" } } foreach Org [YEAHOrganisms] { if { ! [info exists YEAHpa($Org,MySeqs)]} { set YEAHpa($Org,MySeqs) {} } set YEAHpa($Org,MySeqs) [lsort -unique $YEAHpa($Org,MySeqs)] } return [YEAHpa $Qui $Quoi] } proc YEAHrecap {{Config ""}} { if {$Config==""} { set Iin "Oui" foreach I [list "Sc"] { foreach J [YEAHOrganisms $I] { foreach Jin [list "Non" "Oui"] { foreach K [YEAHOrganisms $I $J] { foreach Kin [list "Non" "Oui"] { foreach L [YEAHOrganisms $I $J $K] { foreach Lin [list "Non" "Oui"] { set Config "[$Jin $J],[$Kin $K],[$Lin $L]" foreach S [YEAHbilan "SC" $Config] { set LesH [YEAHpa $S Others] foreach H $LesH { if {$H==$S} { continue } set FiBla "[RepertoireDuGenome]/blastpYEAH/$H" if {[file exists $FiBla]} { continue } lappend LesManquants "$S $H" Espionne "$S $H" } } } } } } } } } } } proc YEAHreciprocal {} { # foreach M [YEAHpa "Sc" "MySeqs"] { } foreach M [YEAHbilan "SC" "AT,eh,hs"] { foreach T [YEAHpa $M OtherBests] { if {[YEAHpa $T $M]==""} { Espionne "$M $T [YEAHpa $M $T] [YEAHpa $T $M]" } } } } proc YEAHreduitYEAHpa {} { YEAHpa a b set FiYEAHpa "[Fiches]/YEAHpa.txt" set LeReduit {} foreach Ligne [LesLignesDuFichier $FiYEAHpa] { if {[regexp "^Sc" $Ligne]} { scan $Ligne "%s %s" Moi Toi if {[YEAHpa $Toi $Moi]==""} { continue } } lappend LeReduit $Ligne } return [SauveLesLignes $LeReduit dans "[Fiches]/YEAHpaReduit.txt"] } proc YEAHshow {} { set LeDazi {} set Iin "Oui" foreach I [YEAHOrganisms] { foreach J [YEAHOrganisms $I] { foreach Jin [list "Non" "Oui"] { foreach K [YEAHOrganisms $I $J] { foreach Kin [list "Non" "Oui"] { foreach L [YEAHOrganisms $I $J $K] { foreach Lin [list "Non" "Oui"] { set Liste [YEAHbilan [$Iin $I] "[$Jin $J],[$Kin $K],[$Lin $L]"] set Ligne "[$Iin $I] [$Jin $J] [$Kin $K] [$Lin $L] [llength $Liste]" lappend LeDazi $Ligne } } } } } } } if {[PourWscope]} { return [YEAHshowAvecRef $LeDazi] } set Dazi [join $LeDazi "\n"] set F [AfficheVariable $Dazi "" "YEAHshow"] BoutonneLaFenetre $F "Fais-voir" "YEAHshowList \[selection get\]" return $F } proc YEAHshowAvecRef {LeDazi} { set LeNew {} foreach Ligne $LeDazi { regsub -all " " $Ligne "_" Sel lappend LeNew "$Ligne" } set New [join $LeNew "
\n"] return $New } proc YEAHshowAvecRefYeastProttfaBlastp {LeDazi} { set LeNew {} foreach Ligne $LeDazi { if {[regexp "^<" $Ligne]} { lappend LeNew $Ligne ; continue } scan $Ligne "%s" Sel set Gene [StringApres "gene:" dans $Ligne] lappend LeNew "Yeast Seq Blast $Ligne" } set New [join $LeNew "
\n"] return $New } proc YEAHshowBlastAvecRef {Qui} { set LeNew [list "

"]
    set FiBla "[RepertoireDuGenome]/blastpYEAH/$Qui"
    if {[FileAbsent $FiBla]} { return "" }
    set OnAttend 1
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/blastpYEAH/$Qui"] {
	if {$OnAttend && ! [regexp "Sequences producing significant alignments" $Ligne]} { lappend LeNew $Ligne ; continue }
	set OnAttend 0
	if {[regexp {^(Sc|At|Eh|Hs)[0-9]+} $Ligne Match]} {
	    if {[file exists "[RepertoireDuGenome]/blastpYEAH/$Match"]} {
		regsub "$Match " $Ligne "" Ligne
		set Ligne "$Match $Ligne"
	    }
	}
	lappend LeNew $Ligne
    }
    lappend LeNew "

" set New [join $LeNew "\n"] return $New } proc YEAHshowIt {Qui Quoi} { scan $Qui "%s" Qui if {[PourWscope]} { if {[regexp "blastp" $Quoi]} { return [YEAHshowBlastAvecRef $Qui] } return [FileMoi $Quoi $Qui] } set F [AfficheFichier "[RepertoireDuGenome]/$Quoi/$Qui"] BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F "Protall" "YEAHshowIt \[selection get\] blastpprotall" BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" } proc YEAHshowList {Selection {Liste ""}} { regsub -all "_" $Selection " " Selection set I "" set J "" set K "" set L "" if {$Liste==""} { ScanLaListe [split $Selection " "] I J K L set Liste [YEAHbilan $I "$J,$K,$L"] } set LeDazi {} set LeDazi2 {} foreach S $Liste { set Def [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfa/$S"] regsub ">$S *" $Def "" Def lappend LeDazi "$S $Def" set Txt "" if {[regexp "^Sc" $S]} { set OrfName [StringApres "gene:" dans $Def] set Txt [YeastGlossary $OrfName "Txt"] } lappend LeDazi2 "$S $Txt" } if {[PourWscope]} { set LeTitre [list "

This page contains two parts ... the second has Yeast information

"] set LeSaut [list "

Second part with Yeast information

"] return [YEAHshowAvecRefYeastProttfaBlastp [concat $LeTitre $LeDazi $LeSaut $LeDazi2]] } set Dazi [join $LeDazi "\n"] set F [AfficheVariable $Dazi "" "$I-$J-$K-$L"] BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" set Dazi2 [join $LeDazi2 "\n"] set F2 [AfficheVariable $Dazi2 "" "$I-$J-$K-$L"] BoutonneLaFenetre $F2 "ShowYeast" "YEAHshowYeast \[selection get\]" BoutonneLaFenetre $F2 "ShowSeq" "YEAHshowIt \[selection get\] prottfa" BoutonneLaFenetre $F2 "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH" return $F } proc YEAHshowSc {{Sc ""} {What ""}} { if {$What==""} { set What "All" } if {$What=="Show"} { set Action "Show" set What "" } else { set Action "Get" } set Entete [EnteteDuFichierTFA "[GscopeDatabaseDir YEAH]/prottfa/$Sc"] return [YEAHshowYeast $Entete $Action $What] } proc YEAHshowYeast {{Selection ""} {Action ""} {What ""}} { if {$Action==""} { set Action "Show" } if {$What==""} { set What "All" } if {[regexp " " $Selection]} { set OrfName [StringApres "gene:" dans $Selection] } else { scan $Selection "%s" OrfName } if {$OrfName==""} { if {[PourWscope]} { return "Sorry there is no information about Yeast" } set Selection [Entre] if {$Selection==""} { return "" } return [YEAHshowYeast $Selection $Action] } set Info [YeastGlossary $OrfName $What] if {$Action=="Get"} { return $Info } return [Affiche $Info "" $OrfName] } proc Ya {} { set PN [LesLignesDuFichier "[HomeRipp]/pHMGWA.txt"] set P [lindex $PN 0] set N [lindex $PN 4] set Fin [string first " K D A Q T " $P] incr Fin 15 set N [string range $N 113 $Fin] set P [string range $P 112 $Fin] while 1 { set NN [string range $N 0 59] set PP [string range $P 0 59] Espionne $NN Espionne $PP Espionne set N [string range $N 60 end] set P [string range $P 60 end] if {$N==""} { break } } exit } proc YaCodonStartEnPosition {Touche {sPAB ""} {NomOuADN ""}} { global YCSEP_sPAB YCSEP_NomOuADN if {$sPAB==""} { set sPAB $YCSEP_sPAB } if {$NomOuADN ==""} { set NomOuADN $YCSEP_NomOuADN } set YCSEP_sPAB $sPAB set YCSEP_NomOuADN $NomOuADN regsub -all {[^\.]} [string range $sPAB 0 $Touche] "" PointsAvant set nPoints [string length $PointsAvant] set iStart [expr $Touche-$nPoints] if {[EstUnPAB $NomOuADN]} { set Nom $NomOuADN set SeqADN [BoutADN [Box $Nom debut] [Box $Nom fin] [Box $Nom orient]] if {$SeqADN==""} { set FichierNucTfa [GscopeFile $Nom nuctfa] if {[FileAbsent $FichierNucTfa]} { FaireLire "I can't find the nucleic sequence for $Nom" return 0 } set SeqADN [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]] Espionne $SeqADN } } else { set SeqADN $NomOuADN } set dCodon [expr $iStart*3] set fCodon [expr $dCodon+2] set Codon [string range $SeqADN $dCodon $fCodon] return [CodonStartPossible $Codon] } proc YaOrthologue {Nom Orga {Genome ""}} { global RepertoireDuGenome Wup "return 1 if piclustalw exists and >= 20" set SeuilYaOrthologue 20 Wup "YaOrthologue works also for other genomes" if {$Genome==""} { if {[YaPABouTROUouTRNAouARNenDebutDe $Nom]} { set FichierPIC "" } else { set Genome [lindex [GenomeDu $Nom] 0] set FichierPIC "$Genome/fiches/piclustalw" } } else { if { ! [file exists $Genome]} { set Genome "$RepertoireDuGenome/../$Genome" } set FichierPIC "$Genome/fiches/piclustalw" } set PI [PourcentageIdentiteOrga $Nom $Orga $FichierPIC] return [expr $PI >= $SeuilYaOrthologue] } proc YaPABdans {Texte} { if {[OnTraite "REFUNI" "NonStrict"] && [regexp {^(AGAM|SCER|XTRO)[0-9\.]+} $Texte]} { return 1 } if {[regexp "[PreFixe]" $Texte]} { return 1 } return 0 } proc YaPABenDebutDe {Texte} { if {[regexp "^[PreFixe]" $Texte]} { return 1 } return 0 } proc YaPABouTROUouTRNAouARNdans {Texte} { if {[YaPABdans $Texte]} { return 1 } if {[regexp {TROU|TRNA|ARN} $Texte]} { return 1 } return 0 } proc YaPABouTROUouTRNAouARNenDebutDe {Texte} { if {[YaPABenDebutDe $Texte]} { return 1 } if {[regexp {^TROU|^TRNA|^ARN} $Texte]} { return 1 } return 0 } proc Yann {} { # set Texte [HttpGetTextFromUrl "http://saiph"] set Texte [ContenuDuFichier "[HomeRipp]/vrac/fir.htm"] while 1 { set F [ValeurDeLaBalise font Texte Rogner Att] if {$F==""} { break } Espionne "$F $Att" } exit set X [ValeurDeLaBalise form Texte] Espionne $X Espionne "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" set X [ValeurDeLaBalise form Texte] Espionne $X exit } proc YannisOrganism {{Qui ""} {Quoi ""}} { global YannisOrganism if {$Qui==""} { set Qui "ListOf" ; set Quoi "Keys" } set LesKeys [list TaxId FullOs Filename OS Strain Keys] foreach K $LesKeys { if {[string equal -nocase $Quoi $K]} { set Quoi $K ; break } } if {[info exists YannisOrganism($Qui,$Quoi)]} { return $YannisOrganism($Qui,$Quoi) } if {[info exists YannisOrganism("EstCharge")]} { if {[info exists YannisOrganism($Qui,Id)]} { set Id $YannisOrganism($Qui,Id) if {[info exists YannisOrganism($Id,$Quoi)]} { return $YannisOrganism($Id,$Quoi) } } return "" } set YannisOrganism("EstCharge") 1 set Rep "/home/nevers/StageJuin/Proteomes" set YannisOrganism(Rep,) $Rep NousAllonsAuBoulot $Rep set LesFichiersTfa [lsort [glob -nocomplain "*.tfa"]] foreach Fichier $LesFichiersTfa { if { ! [regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\.\-]+)_(.*)} $Fichier Match TaxId G E R]} { FaireLire "Bas $Fichier"; continue } set Filename "$Rep/$Fichier" set OS "${G}_$E" set Strain $R regsub "\.tfa$" $Strain "" Strain if {$Strain=="-"} { set Strain "" } set FullOs "$TaxId $G $E $Strain" lappend YannisOrganism(ListOf,TaxId) $TaxId lappend YannisOrganism(ListOf,OS) $OS lappend YannisOrganism(ListOf,Strain) $Strain lappend YannisOrganism(ListOf,Filename) $Fichier lappend YannisOrganism(ListOf,FullOs) $FullOs set YannisOrganism($TaxId,TaxId) $TaxId set YannisOrganism($TaxId,OS) $OS set YannisOrganism($TaxId,FullOs) $FullOs set YannisOrganism($TaxId,Strain) $Strain set YannisOrganism($TaxId,Filename) $Filename lappend YannisOrganism($OS,TaxId) $TaxId set YannisOrganism($FullOs,TaxId) $TaxId set YannisOrganism($Filename,TaxId) $TaxId } set YannisOrganism(ListOf,Keys) $LesKeys set YannisOrganism(ListOf,TaxId) [lsort -integer $YannisOrganism(ListOf,TaxId)] set YannisOrganism(ListOf,OS) [lsort -unique $YannisOrganism(ListOf,OS)] set YannisOrganism(ListOf,FullOs) [lsort $YannisOrganism(ListOf,FullOs)] OnRevientDuBoulot return [YannisOrganism $Qui $Quoi] } proc YatilUneMet {Org Cluster Name} { # Org Mouse Rat set trouve 0; set Premier "" if {[regexp -nocase "Mouse" $Org]} { set LesRepertoires [LesRepertoires "Mouse" "Mod"] } if {[regexp -nocase "Rat" $Org]} { set LesRepertoires [LesRepertoires "Rat" "Mod"] } lassign $LesRepertoires FirstRep SecondRep ThirdRep set FileTfa "$FirstRep/$Cluster.fa" if {![file exists $FileTfa]} {set FileTfa "$SecondRep/$Cluster.fa"} if {![file exists $FileTfa]} {set FileTfa "$ThirdRep/$Cluster.fa"} set f [open $FileTfa r] while {![eof $f]} { set Ligne [gets $f] if {[regexp "$Name" $Ligne]} { set trouve 1 continue } if {$trouve} { set Premier [lindex [split $Ligne ""] 0] set trouve 0 } } close $f return $Premier } proc YeahNon {X} { return [string tolower $X] } proc YeahOui {X} { return [string toupper $X] } proc YeastGlossary {{Qui ""} {Quoi ""}} { global YeastGlossary if {$Qui==""} { set Qui "ListOf" ; set Quoi "Locus_Name" } if {$Quoi==""} { set Quoi "All" } if {[info exists YeastGlossary($Qui,$Quoi)]} { return $YeastGlossary($Qui,$Quoi) } if {[info exists YeastGlossary("EstCharge")]} { if {[info exists YeastGlossary($Qui,Locus_Name)]} { set Y $YeastGlossary($Qui,Locus_Name) if {[info exists YeastGlossary($Y,$Quoi)]} { return $YeastGlossary($Y,$Quoi) } return } return "" } set YeastGlossary("EstCharge") 1 set YeastGlossary(Filename,) "/genomics/link/YEAH/DeJohan/YeastGenenames.txt" if {[FileAbsent $YeastGlossary(Filename,)]} { FaireLire "$YeastGlossary(Filename,) n'existe pas" ; return "" } foreach Ligne [LesLignesDuFichier $YeastGlossary(Filename,)] { set YaClef [regexp {([^\:]+)\:} $Ligne Match Clef] if {$YaClef} { set Valeur [string trim [StringSuivant $Match dans $Ligne]] if {$Clef=="Locus_Name"} { set Y $Valeur set YeastGlossary($Y,All) {} } if {[info exists YeastGlossary($Y,$Clef)]} { append YeastGlossary($Y,$Clef) " $Valeur" } else { set YeastGlossary($Y,$Clef) $Valeur } if { $Clef=="Locus_Name" || $Clef=="ORF_Name" || $Clef=="SGDID" } { set YeastGlossary($Valeur,Locus_Name) $Y lappend YeastGlossary(ListOf,$Clef) $Valeur } lappend YeastGlossary($Y,All) "[string range "$Clef.............." 0 12]: $Valeur" continue } set Reste [string trim $Ligne "\t "] regsub -all {[ \t]+} $Reste " " Reste if {$Reste!=""} { lappend YeastGlossary($Y,All) "[string repeat " " 13] $Reste" } } foreach Y $YeastGlossary(ListOf,Locus_Name) { set YeastGlossary($Y,Txt) [join $YeastGlossary($Y,All) " "] regsub -all { +} $YeastGlossary($Y,Txt) " " YeastGlossary($Y,Txt) regsub -all {\.\.+} $YeastGlossary($Y,Txt) "" YeastGlossary($Y,Txt) set YeastGlossary($Y,All) [join $YeastGlossary($Y,All) "\n"] } return [YeastGlossary $Qui $Quoi] } proc YesScNoEh {{Un ""}} { if {$Un==""} { set Un "1"} set LesSc {} foreach Nom [ListeDesPABs] { set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"] set Eh [ExtraitInfo $Nom "Reciproc1_blastpEhistolica:"] if { [regexp "^No" $Sc]} { continue } if { ! [regexp "^No" $Eh]} { continue } set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfaSc/$Sc"] set Info [YEAHshowYeast $Entete "Get"] set InfoDe($Sc) $Info lappend HameconDe($Sc) $Nom lappend LesSc $Sc } set LesSc [lsort -unique $LesSc] set LaSortie {} foreach Sc $LesSc { lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]" } set Sortie [join $LaSortie "\n\n"] AfficheVariable $Sortie "" "AllWithScWithoutEh" } proc YesScNoPf {{Un ""}} { if {$Un==""} { set Un "1"} set LesSc {} foreach Nom [ListeDesPABs] { set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"] set Pf [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"] if { [regexp "^No" $Sc]} { continue } if { ! [regexp "^No" $Pf]} { continue } set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfaSc/$Sc"] set Info [YEAHshowYeast $Entete "Get"] set InfoDe($Sc) $Info lappend HameconDe($Sc) $Nom lappend LesSc $Sc } set LesSc [lsort -unique $LesSc] set LaSortie {} foreach Sc $LesSc { lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]" } set Sortie [join $LaSortie "\n\n"] AfficheVariable $Sortie "" "AllWithScWithoutPf" } proc YesScNoTb {{Un ""}} { if {$Un==""} { set Un "1"} set LesSc {} foreach Nom [ListeDesPABs] { set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"] if {$Sc==""} { continue } set Tb [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"] if { [regexp "^No" $Sc]} { continue } if { ! [regexp "^No" $Tb]} { continue } set FichierProtSc "[RepertoireDuGenome]/prottfaSc/$Sc" set Entete [EnteteDuFichierTFA $FichierProtSc] set Info [YEAHshowYeast $Entete "Get"] set InfoDe($Sc) $Info lappend HameconDe($Sc) $Nom lappend LesSc $Sc } set LesSc [lsort -unique $LesSc] set LaSortie {} foreach Sc $LesSc { lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]" } set Sortie [join $LaSortie "\n\n"] AfficheVariable $Sortie "" "AllWithScWithoutTb" } proc ZScore {NbSeqDansCeGroupeAvecCeCritereInteressant NbSeqDansCeGroupe NbIndividuAyantUnCritereInteressant NbIndividuDansPop} { #Genome Biology, 6 janvier 2003 4R7, MAPPFINDER, Doniger,Salomonis... set r $NbSeqDansCeGroupeAvecCeCritereInteressant set n $NbSeqDansCeGroupe set R $NbIndividuAyantUnCritereInteressant set N $NbIndividuDansPop set RsurN [expr $R * 1.0 / $N] set Numerateur [expr ($r - $n * $RsurN)] set a [expr $n * $RsurN] set b [expr 1 - $RsurN] set c [expr 1 - ($n - 1) * 1.0 /($N - 1)] set Denominateur [expr sqrt( $a * $b * $c)] if {$Denominateur == 0} {return} return [expr $Numerateur / $Denominateur] } proc ZScoreDesClustersFusionnesParBestOntologyDesClusters {FichierGO {ZScoreMin 1.5}} { set LesClusters [lsort -unique [InterrogeGeneOntology $FichierGO LesGroupes]] foreach Cluster $LesClusters { set Tab($Cluster,LesGO) {} foreach GO [InterrogeGeneOntology $FichierGO Groupe $Cluster LesGO] { lappend Tab($Cluster,LesGO) $GO foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { lappend Tab($Cluster,LesGO) $Ancetre } } foreach GO [lsort -unique [set Tab($Cluster,LesGO)]] { set Type [Onto $GO Type] if {![info exists Tab($Type,NbGO) ]} {set Tab($Type,NbGO) 0} incr Tab($Type,NbGO) if {![info exists Tab($Type,$Cluster,NbGO)]} {set Tab($Type,$Cluster,NbGO) 0} incr Tab($Type,$Cluster,NbGO) if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} incr Tab($GO,n) if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} incr Tab($Cluster,$GO,n) } } foreach Cluster1 $LesClusters { foreach GO [lsort -unique [set Tab($Cluster1,LesGO)]] { set Type [Onto $GO Type] set r1 [set Tab($Cluster1,$GO,n) ] set R1 [set Tab($Type,$Cluster1,NbGO)] set n [set Tab($GO,n) ] set N [set Tab($Type,NbGO) ] set ZScore1 [ZScore $r1 $R1 $n $N ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] if {$ZScore1 < $ZScoreMin} {continue} foreach Cluster2 $LesClusters { if {$Cluster1 == $Cluster2} {continue} if {![info exists Tab($Cluster2,$GO,n)]} {continue} if {![info exists Tab($Type,$Cluster2,NbGO)]} {continue} set r2 [set Tab($Cluster2,$GO,n) ] set R2 [set Tab($Type,$Cluster2,NbGO)] set r [expr $r1 + $r2] set R [expr $R1 + $R2] set ZScore12 [ZScore $r $R $n $N] set DiffZScore [expr $ZScore12 - $ZScore1] if {$DiffZScore < 0} {continue} set Distance [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] Espionne "$Cluster1\t$Cluster2\t$Distance\t$Type\t$GO\t$ZScore1\t$ZScore12\t$DiffZScore\t$Def\t$r1\t$r2\t$R1\t$R2\t$n\t$N" } } } return } proc ZScoreDesClustersFusionnesParBestOntologyProttfa {FichierGO {ZScoreMin 1.5}} { set LesClusters [O2C2O LesClusters] foreach Cluster $LesClusters { set Tab($Cluster,LesGO) {} foreach Nom [O2C2O Cluster $Cluster LesOrfs] { foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {[info exists TabTmp($Nom,$GO)]} {continue} set TabTmp($Nom,$GO) 1 lappend Tab($Cluster,LesGO) $GO foreach Ancetre [InterrogeGeneOntology $FichierGO GO $GO LesAncetres] { if {[info exists TabTmp($Nom,$Ancetre)]} {continue} set TabTmp($Nom,$Ancetre) 1 lappend Tab($Cluster,LesGO) $Ancetre } } } foreach GO [set Tab($Cluster,LesGO)] { set Type [Onto $GO Type] if {![info exists Tab($Type,NbGO) ]} {set Tab($Type,NbGO) 0} incr Tab($Type,NbGO) if {![info exists Tab($Type,$Cluster,NbGO)]} {set Tab($Type,$Cluster,NbGO) 0} incr Tab($Type,$Cluster,NbGO) if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} incr Tab($GO,n) if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} incr Tab($Cluster,$GO,n) } } foreach Cluster1 $LesClusters { foreach GO [lsort -unique [set Tab($Cluster1,LesGO)]] { set Type [Onto $GO Type] set r1 [set Tab($Cluster1,$GO,n) ] set R1 [set Tab($Type,$Cluster1,NbGO)] set n [set Tab($GO,n) ] set N [set Tab($Type,NbGO) ] set ZScore1 [ZScore $r1 $R1 $n $N ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] if {$ZScore1 < $ZScoreMin} {continue} foreach Cluster2 $LesClusters { if {$Cluster1 == $Cluster2} {continue} if {![info exists Tab($Cluster2,$GO,n)]} {continue} if {![info exists Tab($Type,$Cluster2,NbGO)]} {continue} set r2 [set Tab($Cluster2,$GO,n) ] set R2 [set Tab($Type,$Cluster2,NbGO)] set r [expr $r1 + $r2] set R [expr $R1 + $R2] set ZScore12 [ZScore $r $R $n $N] set DiffZScore [expr $ZScore12 - $ZScore1] if {$DiffZScore < 0} {continue} set Distance [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] Espionne "$Cluster1\t$Cluster2\t$Distance\t$Type\t$GO\t$ZScore1\t$ZScore12\t$DiffZScore\t$Def\t$r1\t$r2\t$R1\t$R2\t$n\t$N" } } } return } proc ZScoreDesClustersFusionnesParBestOntologyProttfaEtClusters {FichierBestGOProttfa FichierBestGOClusterXHDA {NiveauMin 3} {ZScoreMin 1.5}} { set FichierOut "[RepertoireDuGenome]/fiches/ZScoreDesClustersFusionnesParBestOntologyProttfaEtClusters" set LesInfos {} set LesClusters [O2C2O LesClusters] foreach Cluster $LesClusters { Espionne $Cluster foreach GO [InterrogeGeneOntology $FichierBestGOClusterXHDA Groupe $Cluster LesGO] { Espionne $GO set Type [Onto $GO Type] set EstCeOk 1 foreach Niveau [Onto $Type $GO LesNiveaux] { if {$Niveau < $NiveauMin} {set EstCeOk 0; break} } if {!$EstCeOk} {continue} set TabTmp($GO) 1 foreach Ancetre [InterrogeGeneOntology $FichierBestGOClusterXHDA GO $GO LesAncetres] { set Type [Onto $Ancetre Type] foreach Niveau [Onto $Type $Ancetre LesNiveaux] { if {$Niveau < $NiveauMin} {set EstCeOk 0; break} } if {!$EstCeOk} {continue} set TabTmp($Ancetre) 1 } } set Tab($Cluster,LesGO) {} foreach Nom [O2C2O Cluster $Cluster LesOrfs] { foreach GO [InterrogeGeneOntology $FichierBestGOProttfa $Nom LesGO] { if {[info exists TabTmp($Nom,$GO)]} {continue} set TabTmp($Nom,$GO) 1 if {[info exists TabTmp($GO)]} {lappend Tab($Cluster,LesGO) $GO} foreach Ancetre [InterrogeGeneOntology $FichierBestGOProttfa GO $GO LesAncetres] { if {[info exists TabTmp($Nom,$Ancetre)]} {continue} set TabTmp($Nom,$Ancetre) 1 if {[info exists TabTmp($Ancetre)]} {lappend Tab($Cluster,LesGO) $Ancetre} } } } foreach GO [set Tab($Cluster,LesGO)] { set Type [Onto $GO Type] if {![info exists Tab($Type,NbGO) ]} {set Tab($Type,NbGO) 0} incr Tab($Type,NbGO) if {![info exists Tab($Type,$Cluster,NbGO)]} {set Tab($Type,$Cluster,NbGO) 0} incr Tab($Type,$Cluster,NbGO) if {![info exists Tab($GO,n)]} {set Tab($GO,n) 0} incr Tab($GO,n) if {![info exists Tab($Cluster,$GO,n)]} {set Tab($Cluster,$GO,n) 0} incr Tab($Cluster,$GO,n) } } foreach Cluster1 $LesClusters { foreach GO [lsort -unique [set Tab($Cluster1,LesGO)]] { set Type [Onto $GO Type] set r1 [set Tab($Cluster1,$GO,n) ] set R1 [set Tab($Type,$Cluster1,NbGO)] set n [set Tab($GO,n) ] set N [set Tab($Type,NbGO) ] set ZScore1 [ZScore $r1 $R1 $n $N ] set Def [lindex [Onto $Type $GO LesDefinitions] 0] if {$ZScore1 < $ZScoreMin} {continue} foreach Cluster2 $LesClusters { if {$Cluster1 == $Cluster2} {continue} if {![info exists Tab($Cluster2,$GO,n)]} {continue} if {![info exists Tab($Type,$Cluster2,NbGO)]} {continue} set r2 [set Tab($Cluster2,$GO,n) ] set R2 [set Tab($Type,$Cluster2,NbGO)] set r [expr $r1 + $r2] set R [expr $R1 + $R2] set ZScore12 [ZScore $r $R $n $N] set DiffZScore [expr $ZScore12 - $ZScore1] if {$DiffZScore < 0} {continue} set Distance [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 Distance] set NbCommonOp [O2C2O Cluster1 $Cluster1 Cluster2 $Cluster2 NbOperonsCommuns] Espionne "$Cluster1\t$Cluster2\t$Distance\t$NbCommonOp\t$Type\t$GO\t$ZScore1\t$ZScore12\t$DiffZScore\t$Def\t$r1\t$r2\t$R1\t$R2\t$n\t$N" lappend LesInfos "$Cluster1\t$Cluster2\t$Distance\t$NbCommonOp\t$Type\t$GO\t$ZScore1\t$ZScore12\t$DiffZScore\t$Def" } } } Sauve [join $LesInfos "\n"] dans $FichierOut return } proc ZeTestII {} { foreach f [ListeDesPABs] { AuChoixDuBlast $f } exit } proc ZincrSite {{Value ""}} { #rR Attention existe dans zincr_tools.tcl et gscope_pipala.tcl global ZincrSite if {$Value!=""} { set ZincrSite $Value } if { ! [info exists ZincrSite]} { set ZincrSite "/wali" } return $ZincrSite } proc Zippe {ListeA ListeB} { set LongPetite [Mini [llength $ListeA] [llength $ListeB]] foreach A [lrange $ListeA 0 $LongPetite] B [lrange $ListeB 0 $LongPetite] { lappend ListeAB $A $B } incr LongPetite if {[llength $ListeA] > $LongPetite} { return [concat $ListeAB [lrange $ListeA $LongPetite end]] } if {[llength $ListeB] > $LongPetite} { return [concat $ListeAB [lrange $ListeB $LongPetite end]] } return $ListeAB } proc ZoneADN {Debut Fin FicTexCon {Orient ""}} { Wup "Chooses between Texte Fichier and Contig. Use the correct if you know it" if {[regexp {[> \n\t]} $FicTexCon]} { return [ZoneADNDuTexteTFA $Debut $Fin $FicTexCon $Orient] } if {[regexp "/" $FicTexCon]} { return [ZoneADNDuFichierTFA $Debut $Fin $FicTexCon $Orient] } if {[file exists $FicTexCon]} { return [ZoneADNDuFichierTFA $Debut $Fin $FicTexCon $Orient] } if {[regexp -nocase {[A-Z0-9]+(\:|_)[A-Z0-9]+} $FicTexCon]} { set EssaiContig [ZoneADNDuContig $Debut $Fin $FicTexCon $Orient] if {$EssaiContig!=""} { return $EssaiContig } } return [ZoneADNDuTexteTFA $Debut $Fin $FicTexCon $Orient] } proc ZoneADNDuContig {Debut Fin ChroContig {Orient ""}} { set FichierTFA [ContigEnStock $ChroContig "FileNamePlease"] if {$FichierTFA==""} { return "" } return [ZoneADNDuFichierTFA $Debut $Fin $FichierTFA $Orient] } proc ZoneADNDuFichierTFA {Debut Fin FichierTFA {Orient ""}} { if {$FichierTFA=="" || ! [file exists $FichierTFA]} { return "" } return [ZoneADNDuTexteTFA $Debut $Fin [ContenuDuFichier $FichierTFA] $Orient] } proc ZoneADNDuTexteTFA {Debut Fin Texte {Orient ""}} { Wup "if Orient (F or R, + or -) exists it decides for the orientation, otherwize I test Fin < Debut" Wup "Returns a contigous DNA zone from Debut to Fin (reverse and complement if Orient - )" Wup "Count start with 1 not 0" set Seq "x[QueLaSequenceDuTexteTFA $Texte]" if {$Fin=="end"} { set Fin [string length $Seq] } set D [Maxi 1 [Mini $Debut $Fin]] set F [Maxi $Debut $Fin] set Zone [string range $Seq $D $F] if {[regexp -nocase {F|\+} $Orient]} { set Positif 1 } if {[regexp -nocase {R|\-} $Orient]} { set Positif 0 } if { $Orient=="" && $Debut<=$Fin } { set Positif 1 } if { $Orient=="" && $Fin <$Debut } { set Positif 0 } if {$Positif} { return $Zone } else { return [NucToReverseAndComplementNuc $Zone] } } proc ZonesClustering {} { set pkm [MacCourant] return [$::db eval {select zone from clustering where pk_mac=$pkm}] } proc ZonesDeSequence {s} { global ZoneClusterisation if {! [info exists ZoneClusterisation]} {return $s} set r "" foreach z $ZoneClusterisation { lassign $z x1 x2 append r [string range $s $x1 $x2] } if {$r eq ""} {set r $s} return $r } proc ZoomFacteur {K Quoi {Valeur ""}} { Wup "Permet de stocker les facteurs de zoom" global ZoomFacteur #Espionne "$Quoi $Valeur" if {$Quoi == ""} {return ""} if {$Valeur == ""} { if {[info exists ZoomFacteur($K,$Quoi)]} { return "[set ZoomFacteur($K,$Quoi)]" } else { return "1.0" } } else { if {! [info exists ZoomFacteur($K,$Quoi)]} { set ZoomFacteur($K,$Quoi) $Valeur } else { set ZoomFacteur($K,$Quoi) [expr [set ZoomFacteur($K,$Quoi)] * $Valeur] } } return "" } proc ZoomMode {AId quoi} { global Abr set Abr($AId,Mode) "zoom" ChangeCurseur $AId $quoi set PAD [set Abr($AId,PAD)] bind $PAD [list AppliqueZoom $AId $quoi %x %y] bind $PAD {} return } proc _CombleSSParCoil {{lss ""} molid chn} { variable SecStr variable NmrRes set LesRes [set NmrRes($chn)] set 1ResPDB [lindex $LesRes 0] set DResPDB [lindex $LesRes end] set df {} foreach s $lss { lassign $s Elt a z e Nm1 r Nm2 t q lappend df [list $Nm1 $Nm2] } if {$df == {}} { lappend df "Coil xxx xxx $chn $1ResPDB xxx $DResPDB xxx" return $df } set 1ResSS [lindex [lindex $df 0] 0] if {$1ResPDB - $1ResSS < 0} { lappend lss "Coil xxx xxx $chn $1ResPDB xxx [expr {$1ResSS-1}]" } set debc [_NextResDuPdb $name [lindex [lindex $df 0] 1] $chn $molid] foreach cpl [lrange $df 1 end] { set finc [_PreviousResDuPdb $name [lindex $cpl 0] $chn $molid] if {$finc-$debc >= 0} { lappend lss "Coil xxx xxx $chn $debc xxx $finc xxx" } set debc [_NextResDuPdb $name [lindex $cpl 1] $chn $molid] } if {$debc ne ""} { if {$DResPDB - $debc >= 0} { lappend lss "Coil xxx xxx $chn $debc xxx $DResPDB xxx" } } return [lsort -integer -index 4 $lss] } proc _NextResDuPdb {name res chn mol} { variable NmrRes set ires [lsearch [set NmrRes($chn)] $res] set deb [lindex [set NmrRes($chn)] [expr {$ires+1}]] return $deb } proc _PreviousResDuPdb {name res chn mol} { variable NmrRes set ires [lsearch [set NmrRes($chn)] $res] set fin [lindex [set NmrRes($chn)] [expr {$ires-1}]] return $fin } proc _____Access2GO {Access} { set TousLesGO {} foreach Requete [Access2Requetes $Access] { if {[regexp -nocase "^go:" $Requete]} { lappend TousLesGO [string toupper $Requete] continue } foreach GO [Interroge2GO $Requete] { lappend TousLesGO [string toupper $GO] } } return [lsort -unique [EnterrerLesAncetresOntologiques $TousLesGO]] } proc _____Access2Requetes {Access} { set Page [PageInfo $Access protein "DES DR Key"] #set Page [join [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNature"] "\n"] return [PageInfo2Requetes $Page] } proc _____EstCeQueGO1EstUnEnfantDeGO2 {GO1 GO2} { set Type [Onto $GO1 Type] foreach Ancetre [TousLesAncetresOntologiques $Type $GO2] {if {$Ancetre == $GO2} {return 1}} return 0 } proc _____EstCeQueGO1EstUnParentDeGO2 {GO1 GO2} { set Type [Onto $GO2 Type] foreach Ancetre [TousLesAncetresOntologiques $Type $GO2] {if {$Ancetre == $GO1} {return 1}} return 0 } proc _____PageInfo2GO {PageInfo} { set TousLesGO {} foreach Requete [PageInfo2Requetes $PageInfo] { if {[regexp -nocase "^go:" $Requete]} { lappend TousLesGO [string toupper $Requete] continue } foreach GO [Interroge2GO $Requete] {lappend TousLesGO [string toupper $GO]} } set LesGO [EnterrerLesAncetresOntologiques $TousLesGO] return [ElimineLesRedondancesDansUneListe $LesGO] } proc _____PageInfo2Requetes {Page} { if {$Page == ""} {return {}} set LesSomething {} foreach Ligne [split $Page "\n"] { set Ligne [string trim $Ligne] if {$Ligne == ""} {continue} if {[info exists Champs]} {unset Champs} scan $Ligne "%s" Champs if {![info exists Champs]} {continue} if {[string equal -nocase $Champs "DE"]} { while {[regexp -nocase {EC[ \:]([0-9\.\-]+)} $Ligne tmp EC]} { lappend LesSomething [string tolower "ec [string trim [CorrigeLEC $EC]]"] regsub -nocase $tmp $Ligne "" Ligne } continue } if {[string equal -nocase $Champs "DR"]} { set Debut [expr [string first ";" $Ligne] + 1] set Ligne [string range $Ligne $Debut end] set Fin [expr [string first ";" $Ligne] - 1] lappend LesSomething [string tolower [string trim [string range $Ligne 0 $Fin]]] continue } if {[string equal -nocase $Champs "KW"]} { regsub "^$Champs" $Ligne "" Ligne set Ligne [string trim $Ligne] regsub -all "\.$" $Ligne "" Ligne set LaLigne [split [string trim $Ligne] ";"] foreach Element $LaLigne { set Element [string trim $Element] if {$Element == ""} {continue} lappend LesSomething [string tolower $Element] } continue } } return [ElimineLesRedondancesDansUneListe $LesSomething] } proc __tcl3dAddMenuCmd {menu label acc cmd} { $menu add command -label $label -accelerator $acc -command $cmd } proc __tcl3dCaptureInit {} { global __tcl3dCaptureInt set retVal [catch {package require Img} __tcl3dCaptureInt(Img,version)] set __tcl3dCaptureInt(Img,avail) [expr !$retVal] set retVal [catch {package require twapi} __tcl3dCaptureInt(twapi,version)] set __tcl3dCaptureInt(twapi,avail) [expr !$retVal] set retVal [catch {package require base64} __tcl3dCaptureInt(base64,version)] set __tcl3dCaptureInt(base64,avail) [expr !$retVal] } proc __tcl3dCaptureSubWindow {win img px py ign} { if { ![winfo ismapped $win] } { return } regexp {([0-9]*)x([0-9]*)\+([-]*[0-9]*)\+([-]*[0-9]*)} [winfo geometry $win] - w h x y if { $x < 0 || $y < 0 } { return } incr px $x incr py $y # Make an image from this widget set tmpImg [image create photo -format window -data $win] # Copy this image into place on the main image $img copy $tmpImg -to $px $py image delete $tmpImg foreach child [winfo children $win] { if { $ign ne "" && ! [string match -nocase $ign $child] } { __tcl3dCaptureSubWindow $child $img $px $py $ign } } } proc __tcl3dCgSourcePkgs {dir} { source [file join $dir tcl3dCgQuery.tcl] load [file join $dir tcl3dCg[info sharedlibextension]] tcl3dCg source [file join $dir tcl3dCgUtil.tcl] } proc __tcl3dConsoleB1Leave {w x y} { upvar #0 $w v set v(y) $y set v(x) $x __tcl3dConsoleMotor $w } proc __tcl3dConsoleB1Motion {w x y} { upvar #0 $w v set v(y) $y set v(x) $x __tcl3dConsoleSelectTo $w $x $y } proc __tcl3dConsoleBackspace {w} { upvar #0 $w v scan [$w index insert] %d.%d row col if {$col>$v(plength)} { $w delete {insert -1c} } } proc __tcl3dConsoleButton1 {w x y} { global tkPriv upvar #0 $w v set v(mouseMoved) 0 set v(pressX) $x set p [__tcl3dConsoleNearestBoundry $w $x $y] scan [$w index insert] %d.%d ix iy scan $p %d.%d px py if {$px==$ix} { $w mark set insert $p } $w mark set anchor $p focus $w } proc __tcl3dConsoleCanCut {w} { set r [catch { scan [$w index sel.first] %d.%d s1x s1y scan [$w index sel.last] %d.%d s2x s2y scan [$w index insert] %d.%d ix iy }] if {$r==1} {return 0} if {$s1x==$ix && $s2x==$ix} {return 1} return 2 } proc __tcl3dConsoleCancelMotor {w} { upvar #0 $w v catch {after cancel $v(timer)} catch {unset v(timer)} } proc __tcl3dConsoleClear {w} { $w delete 1.0 {insert linestart} } proc __tcl3dConsoleCopy {w} { if {![catch {set text [$w get sel.first sel.last]}]} { clipboard clear -displayof $w clipboard append -displayof $w $text } } proc __tcl3dConsoleCreateChild {w prompt editMenu} { upvar #0 $w.t v if {$editMenu!=""} { menu $editMenu -tearoff 0 __tcl3dAddMenuCmd $editMenu "Cut" "" "__tcl3dConsoleCut $w.t" __tcl3dAddMenuCmd $editMenu "Copy" "" "__tcl3dConsoleCopy $w.t" __tcl3dAddMenuCmd $editMenu "Paste" "" "__tcl3dConsolePaste $w.t" __tcl3dAddMenuCmd $editMenu "Clear" "" "__tcl3dConsoleClear $w.t" $editMenu add separator __tcl3dAddMenuCmd $editMenu "Source ..." "" "__tcl3dConsoleSourceFile $w.t" catch {$editMenu config -postcommand "__tcl3dConsoleEnableEditMenu $w"} } scrollbar $w.sb -orient vertical -command "$w.t yview" pack $w.sb -side right -fill y text $w.t -font fixed -yscrollcommand "$w.sb set" pack $w.t -side right -fill both -expand 1 bindtags $w.t Console set v(editmenu) $editMenu set v(text) $w.t set v(history) 0 set v(historycnt) 0 set v(current) -1 set v(prompt) $prompt set v(prior) {} set v(plength) [string length $v(prompt)] set v(x) 0 set v(y) 0 $w.t mark set insert end $w.t tag config ok -foreground blue $w.t tag config err -foreground red $w.t insert end $v(prompt) $w.t mark set out 1.0 catch {rename puts __tcl3dConsoleOldPuts$w} proc puts args [format { if {![winfo exists %s]} { rename puts {} rename __tcl3dConsoleOldPuts%s puts return [uplevel #0 puts $args] } switch -glob -- "[llength $args] $args" { {1 *} { set msg [lindex $args 0]\n set tag ok } {2 stdout *} { set msg [lindex $args 1]\n set tag ok } {2 stderr *} { set msg [lindex $args 1]\n set tag err } {2 -nonewline *} { set msg [lindex $args 1] set tag ok } {3 -nonewline stdout *} { set msg [lindex $args 2] set tag ok } {3 -nonewline stderr *} { set msg [lindex $args 2] set tag err } default { uplevel #0 __tcl3dConsoleOldPuts%s $args return } } __tcl3dConsolePuts %s $msg $tag } $w $w $w $w.t] after idle "focus $w.t" } proc __tcl3dConsoleCut {w} { if {[__tcl3dConsoleCanCut $w]==1} { __tcl3dConsoleCopy $w $w delete sel.first sel.last } } proc __tcl3dConsoleDelete {w} { $w delete insert } proc __tcl3dConsoleEnableEditMenu {w} { upvar #0 $w.t v set m $v(editmenu) if {$m=="" || ![winfo exists $m]} return switch [__tcl3dConsoleCanCut $w.t] { 0 { $m entryconf Copy -state disabled $m entryconf Cut -state disabled } 1 { $m entryconf Copy -state normal $m entryconf Cut -state normal } 2 { $m entryconf Copy -state normal $m entryconf Cut -state disabled } } } proc __tcl3dConsoleEnd {w} { $w mark set insert {insert lineend} } proc __tcl3dConsoleEnter {w} { upvar #0 $w v scan [$w index insert] %d.%d row col set start $row.$v(plength) set line [$w get $start "$start lineend"] if {$v(historycnt)>0} { set last [lindex $v(history) [expr $v(historycnt)-1]] if {[string compare $last $line]} { lappend v(history) $line incr v(historycnt) } } else { set v(history) [list $line] set v(historycnt) 1 } set v(current) $v(historycnt) $w insert end \n $w mark set out end if {$v(prior)==""} { set cmd $line } else { set cmd $v(prior)\n$line } if {[info complete $cmd]} { set rc [catch {uplevel #0 $cmd} res] if {![winfo exists $w]} return if {$rc} { $w insert end $res\n err } elseif {[string length $res]>0} { $w insert end $res\n ok } set v(prior) {} $w insert end $v(prompt) } else { set v(prior) $cmd regsub -all {[^ ]} $v(prompt) . x $w insert end $x } $w mark set insert end $w mark set out {insert linestart} $w yview insert } proc __tcl3dConsoleEraseEOL {w} { upvar #0 $w v scan [$w index insert] %d.%d row col if {$col>=$v(plength)} { $w delete insert {insert lineend} } } proc __tcl3dConsoleHome {w} { upvar #0 $w v scan [$w index insert] %d.%d row col $w mark set insert $row.$v(plength) } proc __tcl3dConsoleInsert {w a} { $w insert insert $a $w yview insert } proc __tcl3dConsoleLeft {w} { upvar #0 $w v scan [$w index insert] %d.%d row col if {$col>$v(plength)} { $w mark set insert "insert -1c" } } proc __tcl3dConsoleMotor {w} { upvar #0 $w v if {![winfo exists $w]} return if {$v(y)>=[winfo height $w]} { $w yview scroll 1 units } elseif {$v(y)<0} { $w yview scroll -1 units } else { return } __tcl3dConsoleSelectTo $w $v(x) $v(y) set v(timer) [after 50 __tcl3dConsoleMotor $w] } proc __tcl3dConsoleNearestBoundry {w x y} { set p [$w index @$x,$y] set bb [$w bbox $p] if {![string compare $bb ""]} {return $p} if {($x-[lindex $bb 0])<([lindex $bb 2]/2)} {return $p} $w index "$p + 1 char" } proc __tcl3dConsoleNext {w} { upvar #0 $w v if {$v(current)>=$v(historycnt)} return incr v(current) 1 set line [lindex $v(history) $v(current)] __tcl3dConsoleSetLine $w $line } proc __tcl3dConsolePaste {w} { if {[__tcl3dConsoleCanCut $w]==1} { $w delete sel.first sel.last } if {[catch {selection get -displayof $w -selection CLIPBOARD} topaste]} { return } set prior 0 foreach line [split $topaste \n] { if {$prior} { __tcl3dConsoleEnter $w update } set prior 1 $w insert insert $line } } proc __tcl3dConsolePrior {w} { upvar #0 $w v if {$v(current)<=0} return incr v(current) -1 set line [lindex $v(history) $v(current)] __tcl3dConsoleSetLine $w $line } proc __tcl3dConsolePuts {w t tag} { set nc [string length $t] set endc [string index $t [expr $nc-1]] if {$endc=="\n"} { if {[$w index out]<[$w index {insert linestart}]} { $w insert out [string range $t 0 [expr $nc-2]] $tag $w mark set out {out linestart +1 lines} } else { $w insert out $t $tag } } else { if {[$w index out]<[$w index {insert linestart}]} { $w insert out $t $tag } else { $w insert out $t\n $tag $w mark set out {out -1 char} } } $w yview insert } proc __tcl3dConsoleRight {w} { $w mark set insert "insert +1c" } proc __tcl3dConsoleSaveFile {w} { set types { {{Text Files} {.txt}} {{All Files} *} } set f [tk_getSaveFile -filetypes $types -title "Write Screen To..."] if {$f!=""} { if {[catch {open $f w} fd]} { tk_messageBox -type ok -icon error -message $fd } else { puts $fd [string trimright [$w get 1.0 end] \n] close $fd } } } proc __tcl3dConsoleSelectTo {w x y} { upvar #0 $w v set cur [__tcl3dConsoleNearestBoundry $w $x $y] if {[catch {$w index anchor}]} { $w mark set anchor $cur } set anchor [$w index anchor] if {[$w compare $cur != $anchor] || (abs($v(pressX) - $x) >= 3)} { if {$v(mouseMoved)==0} { $w tag remove sel 0.0 end } set v(mouseMoved) 1 } if {[$w compare $cur < anchor]} { set first $cur set last anchor } else { set first anchor set last $cur } if {$v(mouseMoved)} { $w tag remove sel 0.0 $first $w tag add sel $first $last $w tag remove sel $last end update idletasks } } proc __tcl3dConsoleSetLine {w line} { upvar #0 $w v scan [$w index insert] %d.%d row col set start $row.$v(plength) $w delete $start end $w insert end $line $w mark set insert end $w yview insert } proc __tcl3dConsoleSourceFile {w} { set types { {{TCL Scripts} {.tcl}} {{All Files} *} } set f [tk_getOpenFile -filetypes $types -title "TCL Script To Source..."] if {$f!=""} { uplevel #0 source $f } } proc __tcl3dFTGLSourcePkgs {dir} { source [file join $dir tcl3dFTGLQuery.tcl] load [file join $dir tcl3dFTGL[info sharedlibextension]] tcl3dFTGL source [file join $dir tcl3dFTGLUtil.tcl] } proc __tcl3dGaugesSourcePkgs {dir} { source [file join $dir gaugeImgs.tcl] source [file join $dir gaugeBase64.tcl] source [file join $dir airspeed.tcl] source [file join $dir altimeter.tcl] source [file join $dir compass.tcl] source [file join $dir tiltmeter.tcl] } proc __tcl3dGl2psSourcePkgs {dir} { source [file join $dir tcl3dGl2psQuery.tcl] load [file join $dir tcl3dGl2ps[info sharedlibextension]] tcl3dGl2ps source [file join $dir tcl3dGl2psUtil.tcl] } proc __tcl3dLogoPoLogo200_text {} { return { R0lGODdhyACpAPcAAAAAAAEBAQUFBQ8PDyQkJERERGhoaIODg4iIiHZ2dlRU VDIyMhgYGAkJCQMDAwsLCxwcHDs7O2VlZYyMjJ+fn5aWlnV1dUpKSiYmJhAQ EEZGRm1tbYeHh0BAQCEhIQ4ODgwMDB8fH2tra5KSkqSkpJmZmUtLSwQEBCMj I5CQkKGhoZeXl3l5eVFRUS0tLRUVFQgICAICAiIiIkVFRXFxcaioqJubmx4e Hj09PWZmZo2NjaampqWlpYuLi2RkZDw8PCUlJUlJSampqZqamnR0dEhISDMz M1lZWaKioqurq01NTSkpKRISEgYGBnh4eJycnHBwcA0NDREREScnJ3Nzc6ys rF1dXTU1NRkZGUxMTKenp5WVlUJCQiAgIB0dHTo6OmJiYpSUlGxsbEFBQQcH BxQUFFJSUn19faCgoK2trXp6ek9PTyoqKnd3d29vb0NDQ1xcXDQ0NJiYmHJy cgoKChsbGzk5OT4+Pi8vL1ZWVoKCgq6urm5ubp2dnX9/f1NTUxMTE5OTk4qK il5eXj8/P05OTigoKImJiWlpaXx8fH5+fkdHR1BQUI6OjoGBgYWFhaqqqp6e nnt7eysrK4CAgCwsLI+Pjy4uLhoaGjg4OGNjY1dXVzY2Nl9fX2FhYTc3N6Oj ozExMTAwMFtbWxYWFoaGhlpaWmBgYJGRkVVVVYSEhBcXF1hYWGdnZ2pqaq+v r8bGxv///+Li4ra2tr6+vszMzMPDw8rKytbW1tDQ0Li4uLS0tM7OztjY2NPT 08HBwc3NzcXFxbq6usjIyLOzs7m5ub+/v729vbW1tbe3t7KysrCwsLGxsf// //////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// /////////////////////ywAAAAAyACpAAAI/wABCBxIsKDBgwgHBhAwgEAB AwcQJFCwgEEDBwkTJkyYMGHChAkTOngAIYKECRQqWLiAIYOAAAkTJkyYMGHC hAkBBBAwgICGDRMqcJDQwcMHAQESJkyYMGHChAkTInQAIkQHESNIlEhgAkMG AQESJkyYMGHChAkTAghw4gOKAhtSqFjBooWLFzBiJEyYMGHChAkTJjwY4MQH GTNorKhhI8EFDAMEBEiYMGHChAkTJkwIIMAJEDdw5NCxg0cPHz9ugDgRIGHC hAkTJkyYMKHBACcGAAmSwIaQIUSKEPhwIkDChAkTJkyYMGFCgTEaMDBy5ACS JDYSKFnCpEmAhAkTJv9MmDBhwoQGAwjIgMGEkydCVkCZISPKiQAJEyZMmDBh woQJCQRQgCZSpgShUqIKDw5WrmBp4AAgAIEDCRY0eBBhQoULGSYMICDDlCxO nmjZsoFLFxAnAjRs2LBhw4YFAzh44OULmAk1koQRw8VDlBMBGjZs2LBhQ4QB BGSYksWJjR1hxIzpAsJBw4YNGzZseDAGmTIuzJxBk4aCmjVsmDQJ0LBhw4YN GyIMICADBhNtbGip4OaNhygnAjRs2LBhw4YGAwj4gKKAmxVpdnCAE4dBgxgN GzZs2LAhwgAnBgAJYmFIDTlzNKD4cCJAw4YNGzZseNABnTp2wOgQkmSEgTv/ Nx44aNiwYcOGDREGOPEBhYY5cmoMsRAEyIATARo2bNiwYcODMci8wJNHD4k9 NogUATJAQICGDRs2bNjwYIATUTy84bNFi402JjAMEBCgYcOGDRs2PAgwgIAM GEy06bMHiZ8/LgCRCQAQgMCBBAsaPIgwocKFDBE6ABGig4hAO2w4yTIlg4AA DRs2bNiw4cEAJ0CE6CAiTJUaggZdYdAgRsOGDRs2bIjQAYgQhEQE0tJHTSFD UgQEaNiwYcOGDRHGaIDlyqBDWpIEQnTnxgMHDRs2bNiwIUIHIEJ0ELNFCIVE a5ZIERCgYcOGDRs2RBiDDCAXfxSpSFJiziICH04E/2jYsGHDhg0PngDR5Y2b FUlUnGHERoqAAA0bNmzYsCHCAAIGEFg0R46QPmrWLJHSJEDDhg0bNmxoMMCJ KB4K0ChRBU2iNUukCAjQsGHDhg0bJnTwwMuPHI14oHGUB88LMjEaNmzYsGFD gwFORJGhYc6QKhTUKJmSQUCAhg0bNmzYMGGMBgziwAH4SIUKDlauMGgQAyAA gQMJFjR4EGFChQsZGgxw4gMKDVSGQOrTxgSGAQICNGzYsGHDhgljkCnjQoGi SCQa5fgB4YGDhg0bNmzY0GCAEx9QLKJSQogNC0GADDgRoGHDhg0bNkwYQICU JYXUPNGyhQ8XD1FOBGjYsP9hw4YNCwY48YHAIiJDapSgsojAhxMBGjZs2LBh w4QBBAwAciHBE0g2LAQBMuBEgIYNGzZs2LBggBMfCBQhMkRICSqLCHw4EaBh w4YNGzZMGODEBxQa5gypQkFSIUMZBARo2LBhw4YNCwY48YHAIiJDhAwhUoTA hxMBGjZs2LBhQ4UnQHThwmdFEiR+zExi0iRAw4YNGzZsWDDAiQ8yZtCQI8RG mwsYBggI0LBhw4YNGyp0APCBlzuIAglBQklBJUBNAgAEIHAgwYIGDyJMqHAh w4IBToDoMmZDGC191KxZIqVJgIYNGzZs2FChAzp1IkiwpAWJnjyXypAJ0LBh w4b/DRsadPDAy48clnagcZQHzwsyMRo2bNiwYUOFMRpgyqRJxw4kBzbheUEm RsOGDRs2bGgwRgMsnDod4sFDkKdMmOg4aNiwYcOGDRXGaIDlk6cJO0A9OhLq BZkYDRs2bNiwocEYZF6I2qQHCaQtG954iHIiQMOGDRs2bJgwRgMsnzxN0MKD w6gFpGDEaNiwYcOGDQ0GaCLFkBIWkapEkrSGDZMmARo2bNiwYcOEMRpg+QRG Rw0eCOAsIAUjRsOGDRs2bGgwwIkoHt7wqZCER6lRRhg0iNGwYcOGDRsmjNEA UyZNOgDW4FHKVChSZGIABCBwIMGCBg8iTKhwIcODDuhg/8p0SpAWIagM3LkB wkGAhg0bNmzYEKEDOnW+SLCkBcmBTXhekInRsGHDhg0bHoxBpoyLP4rQQCpB JAiGDAICNGzYsGHDhggdPLhxB9EILWj8/KkEqEmAhg0bNmzY8GAAAQMIaIBS QQgaSqnwvIARo2HDhg0bNjwY4EQUGQWgrBDSR00hQ1IEBGjYsGHDhg0ROngA 4YumCTt2TND0BcIDBw0bNmzYsOHBAAIyGMripA+kIUSKEBhwIkDDhg0bNmyI MAaMF3jyOFIBaQUNDQQGCAjQsGHDhg0bGoxBpsylVI6QQNqygUuXKCcCNGzY sGHDhggDCMiA4YKFIUnQ+FGA5/8FjBgNGzZs2LChwRgNADK4MugQjxqNfHyB QMcBQAACBxIsaPAgwoQKFzJMGOAEiBB3DKSooWWCjx83QJwI0LBhw4YNGxZ0 8MDLjxyWtCBRdWQBKRgxGjZs2LBhQ4UxGqxawEqPCkglEiiZVAZGjIYNGzZs 2JBgAAEDCGiAUmGHDRaF2DBpEqBhw4YNGzZUGKCJlClB5lQQQgKBpx8hopwI 0LBhw4YNGw6MQQZQpRaSnuwIw+eNjA8nAjRs2LBhw4YKAzh4AMFOJw6gIJVo w+gSqQYOGjZs2LBhw4EO6GDhNIgDKB4TNH2pQ8dBw4YNGzZsyDAGGUBsshBZ AWnHhFb/HWQMEBCgYcOGDRs2BBDgxAcPXMQEqoHkwJFQpGDEaNiwYcOGDRkG OAHCi51Bj5Ak6ZMoVSgGdBw0bNiwYUMNAQBQDBhlKjFS0wfSExaFlkhpEgAg AIEDCRY0eBBhQoULGTaMQQaQoSBQAtXYYcnVGwIZmgRo2LBhw4YMAwiIciOC JwQkaowQwcVDlBMBGjZs2LBhw4YBTjzAdIWVn0iQIvlhFQcLHQcBGjZs2LCh wgAn6DC4tMZCBS1oVI26goWOg4YNGzZs2LChwBhNMhDggqjRDi0jNmjAIKVJ jIYNGzZsqNABjDKGZhgQhGRHGBoXDDFpEqNhw4YNGzZsONBB/4NVohRIegIJ jR5TVzA9cBCgYcOGDRsijNEkgwwcnQ5EEkJBD5xMEECcCNCwYcOGDRs2HBhA wAAZHQw00iIkkJtFU5iQidGwYcOGDQ8GOAECwpVNkkpA2pFiwyJDTMjEaNiw YcOGDRsWdNBgFZ4/kp5AUgHwgJVMXqIICAAQgMCBBAsaPIgwocKFBR3AeDHJ BJQRNSCVUJPKCKYHJwIwZMiQIUOGDBkGEPDBQ4ccPUjU2EKk0KVVdBwEYMiQ IUOGCQMIGODhDhgOKiBF0tPph4cBTWIwZMiQIUOGDBkKdNCA1KU1CVbUACWo 1RsMTMjEYMiQIUOGCR00YCDqDws5Wv9UHGpVYAogGA4YMmTIkCFDhgwHBhAQ JcSXTqrQQIrkyMqXEB8EBGDIkCFDhgcDCMiAgguiCUhAWXJjwsUqOicCMGTI kCFDhgwZEoxBBpChInxQ1YAkx4mZUFgenAjAkCFDhgwNOmjAIFSeMzZ2lFCT Kk4dEAICMGTIkCFDhgwZFgxw4gEmI3kS2UiixZKYIkvKwHDAkCFDhgwLBgAo YIAMLq4s7SAxIUcHGRmaxAAIQOBAggUNHkSYUOFChg0ZBmgyQMYdMByQVFHx yNMdFFLIxHDo0KFDhDEakMKjIFEfSH0S/cGzqoEDhw4dOnTo0OFBBzDKsAmy wRIPIUMSsfr/dOODgAAOHTp0aDCAgA8eOrRqpKUGKhFcZAwQEMChQ4cOHTp0 eDDAiQeYQplJsEWLlkBUGInC8uBEAIcOHTos6KDBKlF/JPVJosIRKyMMGjhw 6NChQ4cOHSaM0eRDCDumFD2BxEOHiCJsXjRwEMChQ4cOBwZokgEFF0SWakAK 40YDkAxNAjh06NChQ4cOFcYgw4TAGB8IkFRRUQoMIRRSyMRw6NChQ4EBHNDB YmSTHwppQKkadQUTHQcOHTp06NChw4UBHDQgNemCG1Q1qgB8ouhIphsfBAQA CEDgQIIFDR5EmFChwBhNpGDQsCEQpCRboBSZIqVJjIULFy5cuHDh/8KFCwOc eIDJiAIWJZJAqmCBkSgsD04EWLhw4cKFARw8wHRl1AEke5AcGMWpzgMHARYu XLhw4cKFCxcuBBCjyYAuEazooVBlRyMRi5aUgeFg4cKFCxfGaCJlShEoW6ok CcRHAwYpTWIsXLhw4cKFCxcuXDgwBgxAGN60EkQijYpSnu7IyNAkxsKFCxcm DODgQR1OcFSB2oOG0iYjWOg4CLBw4cKFCxcuXLhw4cAADuiscpEFyogaSWxI yhOnDogTARYuXLgQYYAmUqYUoVGhihBUrt4QyNAkwMKFCxcuXLhw4cKFBQOc AFEnjgIWJSBpQeUmCJsyMBwABCBwIMGCBv8PIkx40AEdLFdGqQKVhsKZVKFW NXCgUKFChQoVKlSoUKHCgzGaDPAQYZCeSELQPPJ0R0aGJjEUKlSoUGEAAQMI zOATJomQFIjGyBggIIBChQoVKlSoUKFChQoRxoABCMObVodU7JCjJpWROg9O BFCoUKHChDEarAq1iZKKNBQUKRC1qoEDhQoVKlSoUKFChQoVJgxwgs4qF1mg pAAFKgWfC2xewHCgUKFChQgDnPjgYQwiVJAgjRDBRcYAAQEUKlSoUKFChQoV KlSoMIAAEBDipFIjRwsaDprueBggIIBChQoVHoxBpowLM4ko7AF14IgRBg0c KFSoUKFChQoVKlT/qFChwBhNMsi4owkBEkg2EqUyguWBgwAKFSqkUEEABXAA wksETRNqpJFDYxGGDE0CAAQgcCDBggYPIkyocCHDhg4fDnQA48WkLFQqQBIy gs8iQ4DIxIAIsWGAJlKmBCFSIs2OQ50y1XngACJEiBAhQoTIMMAJEF4ywTmA JA2oR50ihPggIABEiAxjNGCw4MgBJElstFHCBhCZGBAhQoQIESLEhjHIMJmi YQMqIVVKODETCsuDEwEgQlQY4ESULoQMWNrBo4ePHzdAnAgAESJEiBAhQmwY wAEdLAtSSXpSRYulDUXYvGjgIABEiAljkAE0qVCbEjuGsGjh4gWMGBAh/0KE CBEixIcBBAzwcAcMB1BpkHDwMQYIEzIxIEJEGMDBAwiZOpVCA0pHK0IePpwI ABEiRIgQIUKE6ABGGTZB3KCqUSUSJThfugxoEgAixIMBADbJgKEIlDA7+ijK E2pVgxgAAQgcSLCgwYMIEypcyLChw4cJA5x4gMmIAhYlkiSR4+TPAiwPHASA CNFgjAarFrDSg6bGFiiLgGQQEAAiRIgQIUKECFFgjCYDukSw4ohCmhopxGiY wqRJDIgQCwY4EaVLB0SoauzoAeYLhAcOAkCECBEiRIgQIQ6MAQMQhjc5DpHY g+TAKE6Y6DiACLFggCZM2BRi0SeNCj8KLr0gE/8DIkSIECFChAiRYAAHdEhV MgElEKQkYfjMQDFAQACIEAnGaMAgDhwOO6rIoaGBwAABASBChAgRIkSIEAsG EACizhVWlNCkQXPGjIsyZGJAhDgwgAMQIQghGpGkxgQwdiA8cAARIkSIECFC hHgwRhMpQGbw2ZJEy6FBV7A0iAER4kCAAQQMwBDEgo00SCgpuPSCTAyAAAQO JFjQ4EGECRUuZNjQ4UOIDuhg+nRKkBZIIwzg8PLAAUSIAwM0AVTpjx8kaWwQ KQJkgIAAECFChAgRIkSICGOQKXNJASUVSVa4KeAhyokAECEKjAFjlZFRCLQk CeSK0A0QDiBChAgRIkT/iBATBhCQAcMFC0NqDLEQBMgAAQEgQhQYowEmO5os QYKkA0wmTA1iQIQIESJEiBAhJgxwAkSIDq5SkLAhidEkJk0CQIQo0MEDL3dc halSA8GoBaRgxIAIESJEiBAhQlTooAEWToM4oImk58iCVTBiQIQIIMCJKB7e QCmxh4eeVC4ANQkAESJEiBAhQoSoMAaZF3hSKeqDZIKEH15AOAgAEWKAEwMI BEnQ5xWSM2uWSBEQACJEiCCCCCKIIFIIoAACMkwxkaDEjhVUimDIICAAQAAC BxIsaPAgwQACMhgqJAnNnkhtLgAZcCIAQoQIESJEiBAhQoQIESIcmCpVqlSZ /xAiRCgwwIkoMt7w2SJEBaVUl16QiYEQIUKEAZowmWTGD5IqJaAU8BDlRACE CBEiRIgQIUKECBEiRJgJFsBYAgcKTAUQgMCBBAsaHOiADoQIPhrV0NLDUyZM dBwcPHjwIMEATQBdSqUHlJBAiO7ceODg4MGDBw8ePHjQYCpIkCDpyCQwE6RU Bw8ePDgwFcBYAgcShAAQgMCBBAsaHBgDBqkFR1SBEhJIRIcQIE4EOHjw4MGB Mci8EMXqgAoSPTxlwtQgxsGDBw8ePHjwIEEdAGMJHBhLFgQdAmkABCBwIMGC Bg8CyBQrVqxYkCDBihUrlg6EqWLFgoSwYIAmUpYocf/yREgJIkGADBAQACFC hAdjwFhlZJQqChQOHFlACkYMhAgRIkSIEKFACLIAxhI4cKAsgbIAAhA4kGBB gwcFQooVC1JBCKkgIIQUK1YqhAUDnIjigYuYQDv6JGpRCVCTAAgRIjwYowEW Tp0QULBx5o8LQE0CIESIECFChAgFyooVKxYsHalS0YAVK1asWDQQIkRoMFas WJkQIoQVK1YmhAYd0KljB0wPEipUmVqwCkYMhAgRHnTwwMuPHDqQDGFRaImU JgEQIkSIECGATKlSpUqFcCCNWLFipTIIKVasWBAQCsyUKlWqVAgNZooVKxZC hABixYqF8GAMGKQWmFKFhIf/Dk1f6tBxgBAhQoMBTkTpwmVDmB022piYkkFA AIQEaQCEJFBgpkyQYsWKFUuWDggAAQgcSBCCDoCxBA6MpQMCQAACBwqEFSsW DYIDIcSKJYsgQQg6AMYSODCWDggAAQgcKDBVqlQ6YsWCBTCVwIEAAQgcSDBT rFiwCBIkODBAE0AuFFBSISSMmA4hQDggSJAgQYIECQoMcOIDgSJEhkCykSAI kAEnAhAkSBASwFgCBcoaOFCgLAgAAQgcKFAHwFgCBxKUBQEgAIEDAcSKFYsg QQCxYkEiOFAHwFgCBxKUBQEgAIEDMwGMJXAgQYGQAAIQOFAgJICxBA4kKBAC QAAC/wcCCCBAypI1idBUGUJlEYoPJwIQJEiQIEGCBAEEEJDBkBI1FKrYoLII xYcTAQgSJAgwlsCBBAvGkgUBIACBAyHFihUrlixIkCDFihUrlqyBAwHEihUL wsCBADLFikVj4EBIsWLFiiULEiRIsWLFiiVr4EAaAGMJHEhQoA6AAAQOFAgw lsCBBAcCBCBwoMAAAgYAudCmTxoKLLJMySAgAEGCBAkSJEgQQIAmTCaZ8YOk ihwobzxEORGAIEGCqVLpABhLoEAaEAAAAEBjoA6AAAQKhBQrVixImQYK1BEr ViwaAwfCihUL0sCBAzNBGCgQUqxYsSBlGihQR6xYsWgMFP9IAxIkSLFixQII SeDATAABCBwIIBPAWAIHEhQICSAAgQMFBjgRRcYMGiWqqDjDiI2UJgEIEiRI kCBBggACkClzKc8BEkm2iCB044EDggQJDoQUK1YsWRAICkwVK1YsgjRixYqV iiBBSLFiQSIoMFOsWLFiQYKkIxUEggQB0IgVK1YqggQhxYoFiSDBVLFiySJI kCBBCLFixSJIkCBBAA5AhOggIowQFX7+VGLSJABBggQJEiRIEEAMMqRCmeKw AxKqHBEg0HFAkCDBgbBixZIFgSBBWbFipRooK1YsHQQJAsgUK1YsggMhAYwl cKBAWBAAAhA4EICsWLF0ECQIIFP/rFixCBLUESsWJIIECRJMFSsWJIIECRIE 4IBOnS8+Gu1A4yjVpTJNAhAkSJAgQYIEAcSAweBKpx41hOgA8wlLgxgECRIc GCtWrEwECQKAFCtWKoGpYsWSRZDgwFixYhEkSANgLIEDB2YCCECgwFSxYska OHCgwFixYg0cKBBSrFipBg4cOHAgAB2xYukYOHDgwIECYzTAwqnTISRo9GzC 84JMDIAABA4kWNDgQQAxGmCy48MSpBqCBsVZBSMGQoOpYsWChVAgpFixUgmE FCsWDYQDY8WKhVBgKhqQIMGKFSuWrIKQYsWigXBgrFixEMaKFSsTQoSQYsVK hRAhgBgw/1YZgVNKhQpVR0KRghEDIUKEBR088IIDUaAqWjiYCvWCTAyEBmnE iqUDocBYsWJBEBgrViwICAVmihULFsKDmWLFipWJYKxYsSAgFJgpVixYByHE ihULIUIAsWLFQohQYAwYpBaMKoUEFAc4RlbBiIEQIcKCDkCEGMNnRRoeB/Jc AtQkAEKDkGLFSoUQAI1YsWANjBUrFsKBOmLF0jEwEyRImRACgBQrViqCsWLF QjhQR6xYOg6mihULFkKEEGLFgoUQoUCAYsAgZWQUBxI8BHW6wgBGDIAABA4k WNDgwQAnosiYMcfGHlB+zExi0iTAwYOyYsWicRAABFmxYtEYGP8rVqyDAzPF ihUr00AdsWKlOigQVqxYqQjGihXr4MBMsWLFynRQR6xYOg4eFJgqVixIBw8S jAGD1IJRHEjwENTpCgMYMQ4ePHgwwIkBQIIk6LMHjSQlhjIICHDwYKxYsWQd hCArVixZBGXFikXjIAAIsmLFgkQQUqxYNA4CgBArViwIBGXFikXjIAAIsmLF gnQQAKRYsVIdPChQR6xYqQ4CgJDqIIAYMEgtGFUKFIlDg64wgBHj4MGDBwMI yDBFiRo0afokCAJkwIkABw2mihUrVixIBTPJihUrViaCOmLFkgXBYCZZsWLJ gkBQVqxYsiAYhCArFsBYsAACEChQR6z/WLIgDByYSVasWLIgDBwoMFasWBAG Dhw4cCAASLFipRo4MBWsWJAGDhQYAwapBaYeqVDxaJQRUjBiAAQgcCDBggYP BhAgZQmjMyqqlKAxQ0aUEwEOGtQBMJZAgbJ0pNIBa2CsVAABCBSYKVasWLJ0 pEqVigasWLFixUo1EEAmgLEECtSRKlWqVJAGxoIAEIBAgZlixYolS0eqVKlo wIoVK1asVAMF0oAECVKsWLEAQhI4ECAAgQMJAoAUK5asVKlSpYIUK1asWJAK DowBY5WRUY/QUNDDStQLMjEKFixYsODAAE2YTDLjRwWkMCI6hADhoGBBgpBi xZIFMJbAgQNl/6UCCEDgQAA0AMYSOJBgLFmpAAIQKFBHrFiyAMYSOJBgrFQA AQgcCIAGwFgCBxKMJSsVQAACBwKMJXAgwYEAAQgcSBBAJoCxBA4kKFAHQAAC BwqM0YDBlUEIVERylOdSGTIBCBIkSJAgQYIBmgByoYCSCi0pcvyAQMcBQYIE BcaKFQuCDoCxBA6MpQMCQAACBw5MBTCWwIEDdUAACEDgQFmxYkGABDCWwIEC ZWUCCEDgwIGpAMYSOHCgDggAAQgcmAlgLIEDCQqEBBCAwIEEBaYCGEvgQIGy aEAACEDgwIEO6NT5okkHCQqUFLgA1CQAQYIECRIkSDAAmTKX8jhCw/9jgiY7 mBrEIEiQIAAIsWLFGphKByQdqQgSJAgAAg2AkAQKTAUBIACBAwFAgARLlsBM OiBBggRJRyaCBAlCoAEQkkCBqSAABCBwoEAIAFMJHEhQYCaAAAQOJDgQgg5I kCBBSgWhYEGBDh54uYMIlRYKisxMYtIkQMGCBQsWHBiDzAtRrFQh4dHD0ycs DWIULDgwVaxYkAACEDiQYEGDBxEmVLiQYUOHDw0GOAGiC5cNW2pEkrRmiRQB ASAyjAGD1AJTpUjs6OHpE5YGMRamSgUrVixYqVKlSpUJIkSIECFChJgwwIkP MmZAqbBDDpEgQAYICACRYQwYq4xYObSjhg7/MJ+wNIixEGAsgQMJpgIIQOBA ggUNHkSYUOFChg0dPgQQQMAAIEGIrAA1YgMXD1FOBIDIMAaMVXEGCaoBqRGY TFgaxFgIMJbAgQQhAAQgcCDBggYPIkyocCHDhg4fAgjQhMmSQixKqNCR44eX Bw4gNowBg8GVThOEJLGkKROmBjEWAoQkcCBBgAAEDiRY0OBBhAkVLmTY0OFD gTHIvMCTx1EkFYdOfcLSIAbEhjEaMODkSQekJJY0ZcLSIAZEiBAhQoQIEeLD GA2wfDp1CBSSUqOMrIIRA2LDGA2wZAJjKUmSRp4+YWkQAyJEiBAhQoQI8aGD BzfuIBpRA4mjPJfK/5CJAbGhAzp1vkhAVQXShE5XGMCIAREiRIgCA0CECBHi wgAnPqCYQUMOJAqS1rCR0iQAxIYOHni5gyhMlRoIRi0gRSYGRIgQHwZwcOLE iRgBIEKECBFhAAFSDClh0QfSECJFCAwQEAAiwwAnQHThwkdOGh4H8lwqQyYA RIgQGwZw0IROlA9RGgiIEQAiRIgQDcYgU+ZSHkdIhIQR0SEECAcQGwY48QEF wEVEbKRRcYYRGyZNAgAEIHAgwYIGDyJMqNCgAzIDGHSREWLVBzIxFi5cuHDh QoIxGmDh1EnQDi06wGTCRMfBwoUHAwgYgOFCmydJbFgIAmSAgAALFy5cuP+w YIwmA27gufMGxyUvA5rEWLhw4cKFCwc6eHDjDqIRkHiUMrWAFIwYCxceDCAg gyElLJ5oCbOBi4coJwIsXLhw4UKCAU6AqLNAiSYRmpQYgQDiRICFCxcuXLgQ QIATHwgsojIkjQpFZiYxaRJg4cKDAZpIYbNGjQ1QjXL88PLAwcKFCxcuLBiD DJMlQTYcCiPITZZKL2DEWLhw4cKFCwEEaMKEDaMzKvb0SRAEyAABARYuPBig CZNJLRLZUCEITCZMdBwsXLhw4cKCDuhg4jQIgZBZVQA2akXIwwcBAQACEDiQ YEGDBxEmVLgwBhlSoY6U2pFmxYYxXUCcCLBw4cH/AE0AuVDgJxISQac+YWkQ Y+HChQsXEgxw4oOMAjT60KplS4uiP5dewIixcOHChQsXxmiAKROYRpCSpPDx pQ4dBwsXIoxBpgyePHpU8JgAJhOmBjEWLly4cCHBAE2YsGnhJ8ktXLl0jciB 4waIEwEWLly4cKFCBw9uEBKxJU0NBHCMrIIRY+FChDHIvBDFShWJGpYkfKlD x8HChQsXLiQYA8YqI3B67OLVy9cvFW2yLGHSJMDChQsXLkwY4MQHFBqo2NhD wpECF4CaBFi4EGEMMmXwsFLFA9KIVj8g0HGwcOHChQsJOqBT50uOMLqA+coV LA0HOHEYNIixcOHChQsT/wIogIAMU5SoobAnkpMsUzIICAAQgMCBBAsaPCgw QJMyl/IcIAEpECIcXh44QIgQIUKECBEOdACiyxg+NoQNuzXMFrEwiAiFAHEi AEKECBEiRIjwYAAyZVwocASqihwoBWREOREAIUKEBgM0AeRCgSMkQgIhuuPl gQOECBEiRIgQocAAJz4QKGKBQrFfxo4dQ/bEQhAgAwQEQIgQIUKECBEejAGD QRw4HHjUSJHjB4QHDhAiRHgwQBMmk8woQlNjBKI7Xh44QIgQIUKECBEKDCAg wxQlapAkK6Zs2S5iKs60mMSkSQCECBEiRIgQocEAJ0DcwJHD0g5Qj0YZWQUj Bv9ChAgPBmjCZFILRWhqjEB058YDBwgRIkSIECFCgQGaMJlkxg8JZMx2gIL0 isQBVqJekAEYAyAAgQMJFjR4EGFChQcDNJGCIQiVFVpssFjDhkmTAAsXJgzQ hMkkM35UCAnk6s6NBw4WLly4cOHAGGRe4GGlaocyIUNWqEjCA8EgTlgaxFi4 cOHChQcdNGCwgJUjNFoCbXgj48OJAAsXJgzQBJALBY5AQQrj6s6NBw4WLly4 cOHAGA0YXOkkqMYrFZYmyKmhpVGOHxAeOFi4cOHChQYDnIjioQOiFFpIHOr0 CRMdBwsXKgxApgyeTap4VAnj6o6XBw4WLly4cOFABw//vOAwMCJJEjmqHKHi IWQLnwIyPpwIsHDhwoULC8YgU6YSIzV9qlA4Y8ZFGTIxFi5UGIPMC1FHSmmp EgYRDi8PHCxcuHDhQoEBTnwgsIjKkDRaLLFIABABmiRPnBRawqRJAIAABA4k WNDgQYQJFRZ08KCOHU+CtCTZwqcAigECAixcqDAGGVKhRiGoUSWQgR8Q6DhY uHDhwoUCAzQBNKnFGRV7VKgSYSCRHEigVJkywqCBg4ULFy5cSDCAgAxAFtGQ U2UHgk6fMNFxsHDhwhgwSBmBc6hGElQ5vtSh42DhwoULFwqMAWOVETgctKSR k2DUJjETSOywZKBDlygnAixc/7hw4cKBMWCQEpWHkooqfVgUYgOITIyFCxfG gLHKiJVDWiBZ0pQJU4MYCxcuXLhQoIMHEH7kSAGphg4DJjSYSjRkh5wEStgw aRJj4cKFCxcOdPDASwQfOmoISWGAUJcoJwIsXLgwBoxVcawc0lJjgqdPWBrE WLhw4cKFAAKc+CCjAEAoK5Ig0WPqB6cirhqBonBgVBwGDWIABCBwIMGCBg8i TKhQYAABGTAUoVIiCRJHm0KtghFj4cKFAGLAWBVnkKAdWnp0usIARoyFCxcu XAgggAAphpSw6ANpSAIleAxlOuIoEihLBgiFAHEiwMKFCxcuBBCDzAs8eRyp SFKCSv8QDBkEBFi4cCGAGDAYXBkkaMcOQYOuMIARY+HChQsXAohB5oWoTQdA CQkkgguQG5WyWCihpYQFE1MyCAiwcOHChQsBOKBT54smHTWEWMrxw8sDBwsX LhQYAwYDTqd61NDSo9MVBjBiLFy4cOFCAA7oYMoEZoIWLRM82bmxCgUXMYFq qKCU6lIZMjEWLly4cGGAEx9QzIAiJw2PR6YWrIIRY+HChQJjNMDCyZMOITV6 dLrCAEaMhQsXLrQQQAFOgOgyRsyWJDweHQmFhYmXL5p0aOGBAE6cVTBiAAQg cCDBggYPIkyoMEATQJNanFGxh4KaQkukNAmgUKHCgjEaYPn/5EkHJCETTnFi ACOGQoUKFSosGEDAACAXEjxJo+IMo0llPjAwYuoRKB4TwNjBRMeBQoUKFSos 6KABFk6DDtVIs4LPGw9RTgRQqFBhwRgNsHwC0wiSkAmnODGAEUOhQoUKFRYM 0ARQpT9+QO2xQaQIkAwPykxqIekJCUutcNx44EChQoUKFRIMcOKDBy5itlQR MsFTJkx0HChUqNBgjAZYPnnSIUTIhFNXGMCIoVChQoUKC8aAsSqOlUM1qoQR QShEFBgZgCyaswVJID4FZHw4EUChQoUKFQ6MQQbQJEaSIqVRoeiPizJkYihU qNBgjAZYOHmaUKNGj05XADKAEQMg/wCBAwkWNHgQYUKFDuhAiJADVRIhEzx9 wkSnSZQQhBBZQiKnjZIlUpoEUKhQoUKFAx3QwfSp06EdSSq4mYFigIAAChUq NBijAQNOp3po0SJoUJxVMGIoVKhQoUKCAU5E8VAAipw0PFRtEvUChgA6dexo mkACjR5WoUjBiKFQoUKFCgUGEPABRQE+YYSQQDDoEyY6DhQqVHgwBgwGVzr1 0LLjkJU4q2DEUKhQoUKFBAMIyDAlCwsKe9BIKrRESpMTDVbFsYKAhxYdmuzU oeNAoUKFChUKjEGmjIsWkvoIGdKmEBtAZGIoVKjwYIwGDDid6qFFi6BBcVbB iKFQoUKFCv8JxiBT5lIqPST2DJmjAcUHAQ7IlLmURw+oJBU2cOkCEMSJAAAB CBxIsKDBgwgTGnRAp06mTgiQkNCR406IKCcCKFSo8GCMBgw4nZpQQ4ugQVdW wYihUKFChQoJxoDBIM4gQTWqBDKAw8sDBzGaSFmyJhGaPX0SBAEyQEAAhQoV KlQYQMAAFAX4BOLRR1EqUaRgxFCoUCHCGA0YcDo1oUaNHp2uMIARQ6FChQoV EnRAp06EHKiSCJlwihOWBg4CnPhAoIiFPnuQnGHERkqTAAoVKlSoMAaZMi7M JOqjpQKNRUAyCAigUKFChDEaMOB0qkcNLT06XWEAI4ZChQoVKiT/6ABEiDEb VqTZ8YiVqBdkYgQ4AaLLGzdy9vA4kMoFoCYBFCpUqFChAzp1Mp0StENLIwk/ vDxwoFChwoQxYKyKM+gQD4A7BA26wgBGDIAABA4kWNDgQYQJEQY4EUXGjDk2 9oDyY2YSkyYBAjh4cOOOqy1VtJQ6IuoFmRgKFSpUmDCAgAEoZripkITHI1ML VsGIoVChwoQxYJBaYOoREhKHOl1h0CCGQoUKFSocGODEACBBEvTZg0aSkikZ BAQI4IAOhB+tRlTRgmDUAlJkYihUqFBhwhgwXlz6o0hFGgpq1rBh0iSAQoUK E8YgUwZPHkcUQPXwlAlTgxgKFSpUqHBg/wABGaZkUUMhTZ8EQYAMOBEAQIwG mOz4SAGpxiErRlbBiKFQoUKFCAOcAHHjhw8dQqpsEcPFQ5QTARQqVJgwQBNA lcycicTDUiscXh44UKhQoUKFAwMIkLJkTSI0VUrMmSEjyokAAGI0wPLJE0Ad Qmr06HSFAYwYAAEIHEiwoMGDCBMOjNGEyZIsCWyk2cHBCicsDRwoVKhQYQAB UgwVUtOnxhY+bzxEORFAoUKFChUKDNAEUKU/fpBA2iJmTAgQDgIAiAFjVRwr h7TUaKQpE6YGMRQqVKgQoQM6mD4N4sAjzZM2StgwaRJDoUKFCgMIGAAkiAUb kJ60MYEhg4AACv8VKlSoUGAMMi9EbTqARIulHBEg0HEgMAaZF6KOPOIBaYQB HF4eOFCoUKHCgwEEDCCgAUqFKjV0SMBxA8SJAAoVKlQY4EQUD2/crICkQpGZ SUyaBFCoUKFChQJjNGBwZRACEiQOdbrCoEEMgQGaAKr0hxKSKnKgFPAQ5UQA hQoVKjQYAwYpUXkoqagSKZGZSy9gxFCoUKFCgQA5eODlR6sUWpAc2CTqBZkY AAEIHEiwoMGDCBMedPAAwo8cjXigcZQHzwsyMQQGEJBhihIWFNJEcmICQwYB ARQqVKjQoIMHEL5o6sFDSwpEYzx8EBBAoUKFCgXGaMAgjpVSKtCoMrX/gBSM GAoVKlSoEECAEyC6jBGBClQJJ0qWSGkSQGCAEx9QaJgzJA0SP38qAWoSQKFC hQoLBjgRpcsYRI1UDEmUStSqBjEUKlSocGAMMmVcmFGzYogeU0ZWwYihUKFC hQoBBDgRxQMXETqGTHDFRcaHEwEGOnhwg5CrQEl4PDoS6gWZGAoVKlRYMMCJ KB465HiE6lEOLigGCAigUKFChQMDCMgAZNEGQSkkbVqwCkYMhQoVKlQIIMCJ KF3ugPGDgMWRK5joOCAYowEmgJk8TdCy49CgOAxgxAAIQOBAggUNHkSYMMAJ EF7ssKLhBJESPKsaOEiYMGFChAFOgAjx49QZl1VUWuB5ASNGwoQJEyY86OBB nThmXLnxNMMQIDIxCMaAQWqBqUdISAg69QlLgxgJEyZMmBCAgwarKhVIdSTL lRAfBARImDBhwoQO6GC6koeGGhFZJpUhEyNhwoQJEx6MAePFkjF/8gQx4iXK iQAEA5AB5OKPoj5IBHnKhKlBjIQJEyZMCCBGkww38Hz5sUAGIBgOEiY8GBAA Ow==} } proc __tcl3dLogoPoLogo200_text_flip {} { return { R0lGODdhyACpAPYAANjY2NbW1ri4uLe3t9DQ0M7OzsHBwb+/v8rKysjIyLOz s7Kysr29vbq6ur6+vrGxsczMzNPT07W1tWZmZmVlZTw8PDs7O8XFxcPDw21t bWxsbEJCQkFBQVFRUVBQUIeHh4aGhpGRkZCQkEVFRURERGFhYWBgYK+vr35+ fn19fZeXl5aWll5eXl1dXYKCgoGBgSgoKCcnJ5+fn56enhwcHBsbGzQ0NDMz MxQUFBMTE3Z2dnV1dWRkZElJSUhISHBwcG9vb6enp6ampq6urkBAQI+Pj2tr a4CAgC4uLi0tLZWVlSYmJlxcXDk5OSIiIiEhIYyMjIuLi5ubm5qamk5OTq2t rXt7e4SEhKKioqGhoUdHR2NjYxoaGhcXFxYWFjExMXNzc6ysrKWlpSUlJSAg ID4+PpmZmZOTk1paWqurq2hoaOLi4jg4OExMTFVVVVNTU4mJiSoqKnl5eR4e HqqqqjY2Nqmpqf///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAAyACp AEYH/oB4goOEhYaHiIk5Sz07KzJQFBY0OYmWl5iZmpuIOTg3bjofLmokY5Wc qaqrmzlPI2AqQVM7PaesuLm6gzldNkwfYlUqP6aou8jJl14xVHIzVVNgI07H ytfYnkhuRzJCRROT2OPkeDlJ3N5FFBU05e+6XOguWEHrFVzW8PutXRZbUYQE gbJlkj5+CC/laPaMDjFqBxNKNNfli5sUM9JgAcGCDaWJIDHlyPEFDb0gSjJs eBIxJDYcY0hMiFJPxQ4PSHC43KlpJJkKJl7MoIPlQ4ky1VryzJSDDJESIGRU KUqBw62lWFXlGDMigxI69tRsqJZVEQ1QVlQIwQJnwoYl/krLytWEwwkRIyLs pEk54lRchHU58PiAZeqHLRVYzl2srFeSDnKmCDGjw0OSv+OaVlATwk6QKCbY 5GNMupyXbS+wDJGiowdcfp6amIgSxE4RHu2SubnDuzfvBBZKz2264YcZjUc6 xMGcC2YbOVJnyLEV17d134iKXL/+w9Aa33TAfu+dxtAO3mwO0eh9aDzv8EHc 3ylfaI787dZ7OtECRkoVGVZQAQNzrHBRhwlwiCHGB0x8gQOBhdDBmxucQMEb FIew0VsTlrA3yG53XJAIiBgKoiFvHCbiIR4/8LaGO4e0eMcareQQxxtHiLHa NGSRk4MTPcQixEM9CmckIk24/qGkGxfwdoGSInHBRgkBiQECGl948U4Oc9x1 hh1YHOFGTkemMtKZZRoy0jYuCDGECiqRAeEqNnIjxglS8DjnYjgs8VwWBkQA QAEKRNHCDV2Yk2YONFhAQRFBiHEFGjd4sacqODyWggxhzGBFB5elSUhTJHgV aQguXKFCGmmcMUFui3ZRgRFKhGHlmDoh1MsNaIAgjBk/QHSkNm6gkEUQZ2gw VhdkNFECFEEMVIIFNVwKEhc2zCYQaHWMJhGjZTwqRlEsNFEtaTnUsEEGq2Lh Aq6C+DSCcSeI8W6oRvoyW7Sg2cDFTjZSoYN/C4bmbVlS8gBtEHCwYIOWhZCx gQZf/oWpnLW60rABEEoEIUWAA2I10hM3WGDBF3NgnA0ObMyWxQwogDrSIene 0IOSHMBgKbo4xEGFEVaA4Ya/otLsxLwr2CGFHG28VvQ1fQoshUYuUNqFyk8L 0gUMVFgxA7JGECFn1sh0cUMLUdgRhhJhp0z2LlvxZwYdtGhx1dt0ArmDFHSw Rh3euezKhK9prBAn1m97cQMwYthTgmiIPz0S1zrMnUXViAKuy0glXXEsOLBq rhANv7ggAx2evvFFoqI3BkMPP3SMRRSlhBy5yE9UAFUWYRR1VJGtl+MTERRE IcY3Rox1u64/QcWpGFG45XTwIY20RFdKpLH2D1qEvJgX/tdnEEIQdKywAxVx 5Er9YnH/oEIY0hrkUrpsMHGFamK09dby6++TAxf/gIIQ7BACNZRhbLoym0lm IAOOEK1/ieMVHIKwNiOU4SNbqkivZAC9EpiLExZwEidOdIdxnKc3F/iBkqDQ JBeVaSSakoIM4GCCB5aDC6iRAVtYUIerqcJCdyiRJkBEB0SsCBHjoRAhQoif 7hziiO2ZkCCImIgmQFEhOajDszzTLx/6aBsomEEWGmYDLx5CO/jpTXo6lMYr uuE+3DkEiNI4HiFOEY7WcWIh3kjH93CiS7SiQxZitpx3+KJXWWCLwfgHweqx rARFSAMdoFCCHjKyEFvpgQ5m/jCELKTAA4XUnCfi0AYgwEEJcMhAD3R2yS3R oAITKAIWPoa+Vo4qB4sDQT1ANwe8dSEOHUhBFhQggQcsQAADwEKAYmDLzHSB CGo4QxBkQMhmYpIG0BRBtKCAGwyWqQvN2IFapmAFNIygDWqAgh3oIIJXwahM UiqBCMASBSZUaiI4QEIHUFAYT4GyEtYMnMQ4hgUlTOMqTqEV/Az1sG/aYIt2 gEJoWDeRXfVKDIUDgrD4VBIQUJBtYsMkDDqQmh1R40gGYkGC8ucwilaPJBeZ QhaKoAYOIHApMHyDsaKhJzU1wwpmEIMIlEWG0gjOBVnIwgdaUMaAlgMHMWiE FIKw/oKeNpIpNoKMCrIgggz0xanDwSbFhLC0NjDzqiLRGMXSED+3ofUQfdLk VFOivLcq4gk+6E+93uUgsC7ml8GUQRpUAIQNFNWuRuPPFNIwyDfgC7GGiOve gmAGMGgBeJDlkgViKQaYOVZ9kC1EXHUwBTsQgwSYtSsM94mFwR4utGrSmFeI 8i4ywVYQn+gVFoRAScjdlhdjCNLcqAmqB/0WD/l0w0lEwANq+VUuMORGFtJA ix6c9bjmmMO6KiamxyLWE0nwQOWI8oHQeBO7rtguWT91mefOrwa8QsHpYIYG f7lXOMQxgjQXNK3zrq8pbGgBUtMghRR0YHXYtcRIYqCF/gyIQAh0MIMV3FAH /+ItXV/ogA5UAJYQAEEL102wSLyQhFLKEgtQqGlqRYVhD4BhfFTVQQducDAR b6IuG8DLNicgtvsGrgZf8MAOvhJhObiBxj4OnvV8EDtJpsQHSwAtYybXAyCE AMJmMLJ9bZyMkThhA5xRGzF8EGLozqEMg5FBEFSgZQtzGRnpNUIIwlNAIihG ZEDWKvxCkAEQJ/m2k5Ma1aymKJD8DxQbZpWEj1zjN8ODc8X6mhJ+4IO76Sqr m/rPEerbaEczb15mCIMQQGBPM/oPSKS1Q3Wn5+mQkKEM+mUrgxAF1kyKczI7 MOufWx0vGHggBVg4wQxaY2kf/jnBBzswgx2kQ4UyXyINUjwEEEO0Tt+sURk6 uBAN8CgCFnthSjTJwqQc9GgucIBidJDBC9zg3UwgAD2WWNKSWgiFJSGCDGi0 ThEO6x3evJMQYBDhIfC9nSL0MhFzKIJ8wmCyMDjc4WCgyxjaQFoh0PWm2TiH TrNgB5BiXBO9qQEnkogIaN+hiHLsjR4NQQM3QCE81jaEyVFuiDmuvDdKJMS2 e2MHTjDqLrWy15isabbBYWEj9tyZKq54id78exAJgHci1sObJapxEy28tno8 RPUSJgKIK1cIDkryAQqeQQ3taKYvjN5ALCn9EGEIUc4/5MdNzIHpeNj5jLQu CL3b/hEPLXwRy8dDo0HofQ18z3sdCUHCNaRoEBLCeSv0xkkZyKHZthwJMOUb BBFY0M0sd0N4wgOFpyOCDfJO/ZJM33c3rHP0P2B9Idjw8tdDYY1ruAAdWN/y 0Ycn9plw+SRz7vSe4KAJW4CCGNQNLx/VYLNQwMIULu89Xuui69vJRDwjaYd+ QcxHvt5UhIO1Yut/yxcseHkYQiCJc/kIl2j4AIQLGDrReYEMSKjABiqABLcW rS5SRWCtwWrZ4A88IAKSVASP02lFE10pEAQGAAEMMANggFq7phUsMxtYQE2f 9WhOQAJAEGpY8AId+DbpAmtKoAAYkAAIkAANIAUZYFMX/uhzXVAG0ZQGQpcE UpYZZEACGjA+WfAChEY2UsICviJIKiAFdrAA9oIGtvVCXLAZZ0AUR/AGheRU UoIgYhAGxGA3M+hzXMAr9GBaKaAGGuA5J+BJF7MoXrAZISBrTPCEj7YVyHYc Qdh8w1IDNihLM7BpbAADSCAwi8Vs1ZcvNsACtPEZLfVcpJIBK1AFDNMR/2Ik jOIsyrcRVqN5v5YFVeA3xUYa2LIvk2Qw18IGLBAMHacS5ScyCmQ6YkAQTTCJ kHYFOnJadyYcZqNS2zRRhrYVSOMxVuBYX3gIWxNM/aQDPlAk9PMsQZAGIRAO 7lcaBrIvA2ECPTQ/EqNQEYUb/v5XForDBBPETpIwibyAapXHNM42HI9EEzOw bkiwa2vyBhgRBlkgJuRWFlxCAsYxFVW4HNbgCYe4UuXFBqYGXVklX4P1Aysx g2tCBWqgAyrUBLJnaNhyio3TW+RYCNiCBlbwAShwFB+Hj2bjBlYgAlHgVQT4 fxNXOWIQAmHDbwnGKIIBAisABV71iW9FhzswBX2DjDgZWv9TAQpzPFAwAWVw cLBFHKZSVikJlAbSAr4SBpVlXcP4LT0IBCtAVjrQNFUJEuDkAVbAKcT1jscF E5qkbJX1VejFBdD0hhHlQSJXljDwHFIgBGdgBDaFXhrHT0MwbG1QiLC1Nb/2 NSug/gFE0I1A+WrRBBZwwFQZeVuCmWmVZYHHxQxgqYQqYFk/iVh9QnFDIQ0b dVsV+QFJRWpNFZNjwB8qoDQ74IW/xSXrkpW0BJiAlpo7qWo7oJa3hQO+FpY8 dVldWVE50JuS9lqAdiOpYQdnRwQT+V00MCXKlz/WyIBoRSz3w1tbIBoi9pXz yGyhlJSKc1HSQpAxyZZqkBdCABof9Jpe0FECoYCxiF6Zkg52sALBspnVeQ5u 8AJqVkBHiV6v4D6C5I47CJTHBgalRYjBCRtRyAOJKAIGFJJOaQE8ACksdZoT WgKoWFV/I2ILITVDcp8LKjxdMgEC5BC5RpuvCUBDSS7d/pJZT0ACalAEjXMG lKaix7UIApMR0mEZIwo1R+NgQfANYrGK7Fk6aqYElYEEBUk9XpCaPzBn9sBj RpqjzylgMrBsLmACFVClWdMLgThkdgA9VPqjWBGGJDk3QRACP9AG3yk6dWEB TMCfdtBAJmABiMlrCyETcHAsKjBhCCZKi+ADGqBNYVBgjGam0IUtaeoxKOAG q6Ool4ADZFAHaJACUxApRaBK6WN+iZBP8jgDy5YCqlOgwwJVPmAEytc3KIAG TSChnhovh/QC0zUDpJolkipaT8AGlzoDYUBAQOCm3xernbB29/Mfj5o5uWo9 WmAERSAEYSADLtACFgCrxKqR/nXABPQwBO7CBFuGX2dxEVMDrG3ApLmaJmGI Bt3ArVfABN1ipk1RBs6jpSxgAbd4rZowkpmGBe1aRlM2nD2QAbIkVG1qrvhq Ju15EVJRj1jiUiLDBRaRAlNTFDyAFOdqgrnlAjoiA6TabjsRpybgK9zqAkzg ERd7YVk4QdFQC+lYUajqYELQiSmQqAe7Cz8BEMdDUxVgrfvgBU4gp0fgq2v6 Az3QqTULN69mohsIAqERjRIBEyPgrHYwBOpGrTx7tD53ND+wAtOEOcOqK0F6 BpJ0BsGaBE2KtawQXTvlT2/KD6FIG2ujUV6KtjRoic3onzDpP9oFBKtSj29A lnTb/hh02B9TgQLCmBCAZQVSIFQvebLVWQPQGR63EZ+wISsUEH0wMyZfG7hw o58aewJmUFj36iPz2Q2pWFfKYAHyhrWZtElUCzJO9T9eEgT8Silvlwt3l0Zz pwxoMAQVIAgVUARV4HBoIDk1MCtKACa1hYXAJLF2mTxXSwhUdAhz4AZPF3k0 pwyER0dImS+8cgUM1K64uiU4EEDjMimVMid4pyJShwlo4AbvGxyJQAa9kb1T pHKX8L5ogAbya2g/ZQYoFg552hhkoFhpwLEegKN4kLttRB+GEHdtdAeJRwZ4 1Bt/JwhVUHVGpMERU8EXggj2gR/3Yb+fGlx7Qzdg0KHk/vBLmyiVxWCkENxG iYcHFuB7MPcev1cIJxREs2cH9RsxMywIkSciOmzBsxcEP0wI+aZHNCAjFgwl TBGj7tM71bQl6MCf31AQcZkKkbe7lxB5FywIV4cIQFR4hUADLXQdJIwHY3xG LnS/M4IIekfEPQFAFDBno5Z0wqNBIJBIs+awQ1R3mkBCG+x1iSAjPUcI7qF7 dKBCbGTIiIDIcLzGg9BCXmwJ6Jc27MQD2ukjXXAgxrMg9mSqmNBCzWkIluzG PPzI0ivIhsAGknRtQBTGhLAiUXcHYdfKJ+dzbCIMcGJYmYd+wYB0WRJv3avL tIwI02sIkSd4MfLGfVd8z7zL/pDnIrInI2aMB4THeu7hc2PQNdGBjE0JN2OH BkLRdpmTCCbHG2Egb+NByZBHBw8Xw+GRBmE3RyGiQivkHnyHfWkgb/nWvniA zym0JFDAz3vkGxdQbwdtHcmMSU0BaoyFAgncTPKQDq9YEKfcxBV8yRESwRLM ctN2HR6NB2xQwXZAddncdyNtHSVNAy2tbeurJnMAS9pUj3iYDTEwmFQVg9HL uYNgciVtCPFkPJjYVz4iMeKDBTahwkBdc20kEjkAnUO6VOlLui3DjgT61Ops w74nEpC7BUVABxHVUsKTXKmBLAZ0zFydDNvHKkWQnY8JpI0wNwra1thQdGW3 NgZ0/sqB0wVUnZ6LRD040AU1QAZk8CCOGy9x4AE7JQWtiZ+bM1I7VTeSvShz cANUsAUawANUkM4N+ATbBYwCYk1NQQTsImpXUsyLfU1EEEthMABB8AE8NNeU +G1UIgMFtobCkwO/UHZVAFJ+TYlReMcCQAAAgABpQNFteySQ+yxicDk5PQ7g s6Ovi3ko+9thcAEEEAEFMABKAI0n2wuwhMdV47HXEJQToE2ijKFfqjdSoAAM wAAHYAACIAO1cNkiCU3JGyZD5z++FhlrlsIxYFySU860eAJEIQYPMABikBzN bVTmOT7Ehd7pnbKNA6FlMLovVNOPEi0qAAVFkAUn8Bkm/oBkixKFgTSC7EbK XfYj28VWNBSLi701zpARSqUDcgApPFVpF9sLKMhWV3IDBr4lAfMM9Lhu97go 2DSjkWKTbsAEGwaJf3yuOeAFmxUCC3UoZzsOI5kaYUALZPbj2KKtHFQERuAD dVABJtFapzW3OPXcCwMH3grI7/BKseQZBCE/wzJxySYEtOCmNDAGOfYl7jLd 6DKNAfEZTGXnwsM1XlMFahjhf/Xb76nR/9NRGHVxy/q2taGANlS50Kk2hQnM xG3TYlBgoKTYBzoF3FqFFr6oD6VOaRDXBMmIP4I0aSAENMQGTssncykHW0VT PWYOkGsC0OKMkgB6+Kjo21RJ/l3+fj4zMEHgKR0AuFN2fFQSKUuFoR+6Kdfd stDlCy0ABwIhUe6dEAmLAoubEpQ5ZeZItZ/0pq+kBrUSiaCNLp+sUuc+nUnW KLHEL027oNH1ub98U5DmUW/i04raC9lCG29pSdXT2JHeWHKYFVfOK8D9jBUQ jQsGzn0pzg0figmCiVdtaF5wiMHQiVupwNXj6ZP0OGY0EjQAC8eBwC6PU7LC WRxbXADzSo9C6uTXlZoxAW84algiZZoVS2vBV1ryo1tBlz3p4zwBmzMqBNCj xVXpHNDxH5fnbGuynxxUlM5lVEjQ5p33KmxtaE/AARMAAiEAAlXB4S5RzoRz lwekQA8+AWZRMAVQkDx0nxUK9AJT8Kc+LzI0UAdt8L4jYLAis47jMuQFumAj YAIZYARvYANbzBinIWQukAJc+tOJEAgAOw==} } proc __tcl3dLogoPwrdLogo200 {} { return { R0lGODlhggDIAPUAAP//////zP//mf//AP/MzP/Mmf/MAP+Zmf+ZZv+ZAMz/ /8zM/8zMzMyZzMyZmcyZZsyZAMxmZsxmM8xmAMwzM8wzAJnM/5nMzJmZzJmZ mZlmmZlmZpkzZpkzM5kzAGaZzGZmzGZmmWZmZmYzZmYzMzNmzDNmmTMzmTMz ZgAzmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH+BSAtZGwtACH5BAEKAAIALAAA AACCAMgAAAb+QIFwSCwaj8ikcslsOp/QqFT6qEYkWElly+1WJNOweKysVrNa r3rN9kbIcHhkfqXY2/i8Hg+O+417gYKDg29/f4SJbBOKexRiCJEPaGlbfVCN axMJCXkGA6CMmXkRZpSjX1KoXJ8Dopqgsa6rtIKGmKutnW2tsga1wHkPqqgJ sXi9sQa7wc1ew1GrscxqE76vztlcU5WKELHYXrLU2uXco62/bMag5OXa55mt 4V3K7/db8Y3H66Dq+O/0KfLXBhzAewITheo3wN3BYJegPBgFqmDFh+UiPpmY acA/L98GQKgV4QABAgW6AdTohOM+hxVa0XpAAIDNmwcwQovicuD+yGrtVtW8 SRRAgYc7JVL86YUdKgkBikqNcBBBGHT0KhDMJEEqAAwfPmCoGeCgGKxAZzVC UJRBiRRw4aJ4AKCnuauZEtCTuZboAhBxA6c4sYEAwLOZINALqigCUQyCI6fA QAEf4kYTwllTS6jrTcCSI2+wjBeY00SebZoILfmEB4Sla336GIhCVAALVrOO 3OEeyyfNGA8aymC3ZBL4fjsJtjkrngM2ixsXPGLlZVqnBXleMF0wioNJowGb Pcg2AAW6u8N9DTA8rlrC9wxNr763WTEqMzW3ZfOD+rjV1WKMAc5VMEZ+mC0U SFQX/AfXCYJsMptz6bBxYC3f0PbceQ7+wmWfHhOEZFBaDa2RAX4CelSbTaD9 F6AgInLmRS9rnCCZEwgq8glMakAnnYMDxcKUF5sNUGNkJuAom4xteEZfdx8O IkuB/HghGQgtLVlgF9BB5uCLhPRCZYlqSPZBlrRcpIdqHcqzFRufZHUjmtIY qQddXv6H3D7xqaGiGh3M2YRdHWm4Rk1PGvddkzluMSIsWQUa2UbwGepFV9w5 GOUWERQwVFmLVLkGBEN2IWlgJbyHikh6QOefi13Q5FWOIVm6BY8jRHYmcGmW eigAbW7RQQgYFLtAUQgwtCUeuQomnjTLdvVjdyiMYGNkJ3yggE05rcGXIs0G 9iwqBJICwKv+HbKWgU2GrdHnIChMqio6rQJwbbqhedYukQoqEm9gSc6blx4E ZIqvZCjou8aAo9wLF5YCY6ZHAHkeLBgJdAGwbxef+DqIvBFrA0CLFgfWAVsA dNvFZqiAzGtyACRacgUFcKuGMTzucWpcxODjWMmRfTcUoXGOsjNcPd8TgcFA w4XcTSpZY2sgR6c67jsHVNx0B6ndzGQiJAi2KxSNBpN104FVAJ3GahgwdSDh Ii1F2cAcgG7TQttklzXL7hF3CglpcwDJQJNAwU1qQPB2IP/yPDdAB8h8sAeO GdV233s0nkLAUdBdCwKSpwvhUFEvzjiqgWcTQegdVsfuzZjv4ez+FFT5zDpc t3uYMaEeNzK7FLX7drvDu1VA1j2/RxH8PbcTHlrCNi3vzNFhSF/O7XezNgJd G2ezM+fKH6S5d5NBWZPnqOw8dtLv/A1gByVkn2/K+ITteGzth0aCBxg4H/QB oLqH/eSGv3IMUDAe6MACiCeZEQAAfauI2xgOcrQHVcCB3XGAyu7ROPCxDxjJ 6oIHGliBECigO917R+MgVsBaHGCDFThOBTDQIONsAIK0aNz6PliLmvVEMr1h QA21h5EY3q+FtBgaF8aXggp04Fy7WRRGxDXBbAwFAA0YAQnG950nys9kRTQi AZEolKJ8gHjV2UDMWLMnjJzKgzxMok3+FFAsEBCuN+uSnBTdGJcdxrGMUAxN bxoArNCogQI4zMSp4KCNobzFkBU4lv62YJKTPLB+RyQjKobCQAtWwCZRHMGx bAKQATLSiqB8nhNxM50TQCeF2fjXCU7pjJowjToVcMwQtVcTGGrjXywMQwgE x8pJ0mWXoXHgJTGZAj9GYZjZ8BEbK+CAr0xHAzZJZCbsBwdoOqNLrHkNIb8o mGoC4CDcJIM3mwHO0LymJuQMDAPYVsoxhsEE2nCMA1izhXnG80FR8aU2wgZH KYggnwDYJyRt8kjWnEBvFGwmHA6aja4cIDQQ+uQad6NMbSoScBPVxuEOwMQU dJFNu1HjMvH+Eag4gCkYhytASb/jJONg85wRdWk5AkCAAwLoCyhlTeUwMks4 vDQYPPWp0yqg0ts5BpblCKYYjgoMT1UwBchR6XSeihEMxKGN3wTAVZGTMUVx 9SF+2FQw6CLGwJA1ldrrClThEQe1AqMrEmAicsxpHMPR8z5wsGst8MpEPMJV kMabazbS+g4ARMB9hi0ka3pTE4wwthwEOABkK7AuyUISOpaFwwcE60ICVDCy UdyCp0JLBhCwJ5+m5Q1nDxu0LQTgKA+xChlM8NqKnlO2nd0NcroSwqrAwTX3 eCBwaXuxCrAVI7odQwp6a8W8Cga1kzUebnMLh+neIxLjw64huxL+RvdIwbvv kEAB/oac4PKTANZLDhn8A5CeNte9xylJGFMxBvriowBHay9z49IBQh1EOU9Y TXskcN8Bm7QyXDBwRnbbxOQoNC7IuSliI4xTtEq3wvg4gMO+E4KgxiWjEnjA bYpIBriAR3MkNrHTKLA2xLE2DCY9cAgC852mRqYLCBgKi6W7x3uIgMdMlXGA PLDFh3YYsFPwT5HfcbQLKjluD1XsYsXwlimXo8pPDKRD/wplKXQ5I8WtwAjT 1oFt/XMw9LvxeXNcDo1VAoEKFHNoSizhu+CYzo3klgQ6QJ/eHOvNJfYoKj4M Vmdk7DNurYAFAIDMyFQzjIxObnSehBz+DFDaOCfBtBiWijUANDQw1fH0tCLj QIHCZgqgabQzuqI1uVRAw6xRY3xfbWZSl5qBENIqa55bRPM2AcMAoZhkKsAB m3TSpKEOI4KXQOD2mPrHYZacrvc7bSVUGyAFWOB1I7lRSwewiN1Owrfru2rk wLOBAeizb/6cAtI6gwIEmFZ1qvnFCJy7iI+QArrsfW8C5Ok7xwwaARQNDFiv +yAUYECegLrqFGzA1R6OQnoIrg0auvhwJ+QxxjMOhbTtt4Rn7A1tOX6YObv4 5BVAgQmqg6gTw9wLUzA5zFHwnZq1SNYnz3lcbi4stQXSy0F3OYiJ7piRJx0K dyM6F+QqdTX+SCE9GX2HpwgQgLIB4N9Vv3pckO6MbOKhslXvgtLJ3gyztwE6 DPfzE5AMELezgS67hvna+YAAeQvC7msgbtojHAW6s4HqqwD8GuI8+Fs04W5s RzwqFK+GaDceCqcGuiXWNoc2lOQA8qa8F0A7+FxCgT6a/wJ0AtB5NUjgJBJA 5MLZIPpYrbTqjmdCc5tE5i5IXvJeqP3U61L6gDth94fvPRdqpjLP0P72tN9u 1Y1/7EjzHqoQjXCOhM8Frhe/5NZPPvaJvwfub4Etcb/3E7KXeqCO3+9cMD9Q 4S9nJdyRD8rfQk3sEvvFQ5/2WjZkTfAk9gZ8tid9xvN86IN2aff+BMRTgF/n XNZTM5WQEgq4B3A3eHM3bmfHU2kWKyfxQghyAAVQgiWoB11Bf2XmbRxYep+k gi1XfWDkgsYDg6Qhg0NHgxXQdxr4eD+mgynWg0xwai8HhEK4BImigzQYXSwo GErogsZWBMvmDAnUASRwhTzXOFm4hVp0hV5IAh0QhmIYhvsVhUQwhYkghlc4 Ajz3bGhjHCewhVnYhV8IhmMYhtS1BmY4BLXFBmI4AoDIc284iIQIF1ZDb2PX AYEoiIXYiI7YR2LgP484iZQoUWFAhJWYiY7oTMeniZ74iJyIg584imgTirpH iqjYNB+WiqyIL6vYirCoHpEIhyZQi7v+YQJhETrpgS4m0Em1aItI8ous8Ysy cwLC2B2zuBsfcBMVBxfLeBO1tjnWZAIjkwIlUI2C4WSfFhmeZhPRSI1zZCY3 kRvTIQZu6Iym5mmJQo0LUAImME+YmAILwB3L2CCe1hrYKBmedgLzJBnUGI3o aEfFtBujZhzLGD/l1kflZk3cCCzzBCwLUGlw1j/xeI8X4FlxQY0XAALxeJDN lJCConSh8YwDGRgXGRgA0IzXuIyetoz+81AKsADR2I16lpE2IZPi+BYgkI+h UZDKeC7x+JGg8Y+hMUopcBMYxZOC4WkxGRpEOZLXpo7G4ZOs4ZFO2R8lsC1B 6WkNcpESCWfDH+CO+jgyDCkYGimWunIuy9iMyQN102GVobGTkBaXUHSNkqiN zWiRICmNSJmW0XGO9rR+3ZE7J1ACJQCYZ+SMt3iM2agbveiPjGmWwGgcBTWA sXiZg3lPmLmZw4iInPmZuOOZoMmZlXkIogUCuTOaUmWarEkEH4CagAmLptia tDkEr5mamjibtbmbRZCLuEmIusmbwokEr3mYlBicw5mcTMCRg6iczmmatxmb LvOc1AmdqDmV1ZmdwhmW6aGd3vmdSxAEADs=} } proc __tcl3dLogoSetWackelDelay {mouseX mouseY} { global __tcl3dLogoWackel set __tcl3dLogoWackel(wackelSpeed) [expr $mouseX + $mouseY] } proc __tcl3dLogoShrinkWindow {tw dir} { set width [winfo width $tw] set height [winfo height $tw] set x [winfo x $tw] set y [winfo y $tw] set inc -1 if { [string compare $dir "x"] == 0 } { for { set w $width } { $w >= 20 } { incr w $inc } { wm geometry $tw [format "%dx%d+%d+%d" $w $height $x $y] update incr inc -1 } } else { for { set h $height } { $h >= 20 } { incr h $inc } { wm geometry $tw [format "%dx%d+%d+%d" $width $h $x $y] update incr inc -1 } } } proc __tcl3dLogoStartWackel {b} { global __tcl3dLogoWackel if { $__tcl3dLogoWackel(onoff) == 0 } { set __tcl3dLogoWackel(onoff) 1 __tcl3dLogoWackel $b } else { __tcl3dLogoStopWackel $b } } proc __tcl3dLogoStopWackel {b} { global __tcl3dLogoWackel set __tcl3dLogoWackel(onoff) 0 set __tcl3dLogoWackel(curImg) 1 after $__tcl3dLogoWackel(wackelSpeed) __tcl3dLogoWackel $b } proc __tcl3dLogoSwitchLogo {b} { global __tcl3dLogoWackel if { $__tcl3dLogoWackel(onoff) == 1 } { set __tcl3dLogoWackel(onoff) 0 } set __tcl3dLogoWackel(curImg) [expr 1 - $__tcl3dLogoWackel(curImg)] $b configure -image $__tcl3dLogoWackel($__tcl3dLogoWackel(curImg)) } proc __tcl3dLogoWackel {b} { global __tcl3dLogoWackel if { $__tcl3dLogoWackel(onoff) == 1 } { set __tcl3dLogoWackel(curImg) [expr 1 - $__tcl3dLogoWackel(curImg)] $b configure -image $__tcl3dLogoWackel($__tcl3dLogoWackel(curImg)) update after $__tcl3dLogoWackel(wackelSpeed) "__tcl3dLogoWackel $b" } } proc __tcl3dOdeSourcePkgs {dir} { source [file join $dir tcl3dOdeQuery.tcl] load [file join $dir tcl3dOde[info sharedlibextension]] tcl3dOde source [file join $dir tcl3dOdeUtil.tcl] } proc __tcl3dOglCreateSafeOrDebugFunc {glFunc debugFlag normalFlag {printCmd puts}} { if { [info commands ${glFunc}Standard] eq "${glFunc}Standard" } { rename ::${glFunc} {} rename ::${glFunc}Standard $glFunc } if { $normalFlag } { return } set code [format " if { \[__%sAvail\] } { if { %d } { %s \"%s \$args\" } eval %sStandard \$args } else { %s \">>> %s \$args (N/A in driver)\" }" $glFunc $debugFlag $printCmd $glFunc $glFunc $printCmd $glFunc] uplevel "proc ${glFunc}Safe args { $code }" rename ::$glFunc ::${glFunc}Standard rename ::${glFunc}Safe ::$glFunc } proc __tcl3dOglFindExtension {type val} { set extList [tcl3dOglGetExtSuffixes] if { [string compare $type "cmd"] == 0 } { set typeList [info commands gl*] set fmtStr "%s%s" } else { set typeList [info globals GL_*] set fmtStr "%s_%s" } set result {} foreach ext $extList { set typeExt [format $fmtStr $val $ext] if { [lsearch -exact $typeList $typeExt] >= 0 } { lappend result $typeExt } } return $result } proc __tcl3dOglSourcePkgs {dir} { # Source the files from sub-module tcl3dOgl source [file join $dir tcl3dOglQuery.tcl] source [file join $dir tcl3dOglStateList.tcl] source [file join $dir tcl3dOglHelp.tcl] load [file join $dir tcl3dOgl[info sharedlibextension]] tcl3dOgl source [file join $dir tcl3dShapesGlut.tcl] # Note: This file must be loaded after the wrapped OGL library, # because of the redefined glMultiDrawElements function. source [file join $dir tcl3dOglUtil.tcl] # Source the file from former sub-module tcl3dDemoUtil source [file join $dir tcl3dDemoHeightMap.tcl] # Source the file from former sub-module tcl3dUtil source [file join $dir tcl3dGuiAutoscroll.tcl] source [file join $dir tcl3dGuiWidgets.tcl] source [file join $dir tcl3dGuiConsole.tcl] source [file join $dir tcl3dGuiToolhelp.tcl] source [file join $dir tcl3dUtilColors.tcl] source [file join $dir tcl3dUtilInfo.tcl] source [file join $dir tcl3dUtilFile.tcl] source [file join $dir tcl3dUtilTrackball.tcl] source [file join $dir tcl3dUtilLogo.tcl] source [file join $dir tcl3dUtilCapture.tcl] source [file join $dir tcl3dVecMath.tcl] source [file join $dir tcl3dVector.tcl] } proc __tcl3dOsgSourcePkgs {dir} { source [file join $dir tcl3dOsgQuery.tcl] load [file join $dir tcl3dOsg[info sharedlibextension]] tcl3dOsg load [file join $dir tcl3dOsgDB[info sharedlibextension]] tcl3dOsgDB load [file join $dir tcl3dOsgFX[info sharedlibextension]] tcl3dOsgFX load [file join $dir tcl3dOsgGA[info sharedlibextension]] tcl3dOsgGA load [file join $dir tcl3dOsgManipulator[info sharedlibextension]] tcl3dOsgManipulator load [file join $dir tcl3dOsgOpenThreads[info sharedlibextension]] tcl3dOsgOpenThreads load [file join $dir tcl3dOsgParticle[info sharedlibextension]] tcl3dOsgParticle load [file join $dir tcl3dOsgSim[info sharedlibextension]] tcl3dOsgSim load [file join $dir tcl3dOsgShadow[info sharedlibextension]] tcl3dOsgShadow load [file join $dir tcl3dOsgTerrain[info sharedlibextension]] tcl3dOsgTerrain load [file join $dir tcl3dOsgText[info sharedlibextension]] tcl3dOsgText load [file join $dir tcl3dOsgUtil[info sharedlibextension]] tcl3dOsgUtil load [file join $dir tcl3dOsgViewer[info sharedlibextension]] tcl3dOsgViewer source [file join $dir tcl3dOsgUtil.tcl] source [file join $dir tcl3dOsgKeysym.tcl] source [file join $dir tcl3dOsgBitmaps.tcl] } proc __tcl3dSDLSourcePkgs {dir} { source [file join $dir tcl3dSDLQuery.tcl] load [file join $dir tcl3dSDL[info sharedlibextension]] tcl3dSDL source [file join $dir tcl3dSDLUtil.tcl] } proc __tcl3dScrolledFrameCfgCB {wid width height} { set newSR [list 0 0 $width $height] if { ! [string equal [$wid.canv cget -scrollregion] $newSR] } { $wid.canv configure -scrollregion $newSR } } proc __tcl3dSourcePkgs {dir} { set subPkgs [list tcl3dogl tcl3dgauges tcl3dcg tcl3dftgl tcl3dsdl tcl3dgl2ps tcl3dode tcl3dosg] foreach pkg $subPkgs { set retVal [catch {package require $pkg} ::__tcl3dPkgInfo($pkg,version)] set ::__tcl3dPkgInfo($pkg,avail) [expr !$retVal] } package provide tcl3d 0.4.1 } proc _tcl3dTbAnimate {toglwin} { global __tcl3dTB tcl3dTrackballAddQuats $__tcl3dTB(lastQuat,$toglwin) $__tcl3dTB(curQuat,$toglwin) $__tcl3dTB(curQuat,$toglwin) $toglwin postredisplay set __tcl3dTB(afterId,$toglwin) [after idle "_tcl3dTbAnimate $toglwin"] } proc _tcl3dTbGetTimeMS {toglwin} { global __tcl3dTB return [expr int ([tcl3dLookupSwatch $__tcl3dTB(swatch,$toglwin)] * 10)] } proc _tcl3dTbStopIdleFunc {toglwin} { global __tcl3dTB if { [info exists __tcl3dTB(afterId,$toglwin)] } { after cancel $__tcl3dTB(afterId,$toglwin) } } proc acBlastNPourTous {{Banque human} {LesNoms ""}} { global RepertoireDuGenome global GardeToutBlastNPourTous global TestExistenceBlastNPourTous JeMeSignale if {$LesNoms == {}} { set Liste [ListeDesPABs] } else { set Liste $LesNoms } set NomDeLaBanque "/blast/$Banque" while { ! [file exists "$NomDeLaBanque.nhr"] && ! [file exists "$NomDeLaBanque.nal"]} { if {[OuiOuNon "The blastn database $NomDeLaBanque doesn't exist.\n Do I cancel BlastNPourTous ?"]} { return "" } FaireLire "Please complete the full name of the blastn database" set NomDeLaBanque [Entre "/genomics/link/"] set Banque [file tail $NomDeLaBanque] } set Repertoire "$RepertoireDuGenome/blastn$Banque" if { ! [file exists "$Repertoire"]} { File mkdir $Repertoire } if {[OnTraiteDesCDNAs] && $Banque=="human" && ! [file exists "$RepertoireDuGenome/blastn"]} { set Link "$RepertoireDuGenome/blastn" if {[OuiOuNon "Do I create a link \n $Link -> \n $Repertoire\n ?"]} { exec ln -s $Repertoire $Link } } if { ! [file exists "$RepertoireDuGenome/nucmask"]} { if {[OuiOuNon "Do You want to run RepeatMasker for all ?"]} { RepeatMaskerForAll } } if {[info exists CommandeBlastNPourTous]} { set CommandeBlast $CommandeBlastNPourTous if {[info exists GardeToutBlastNPourTous]} { set GardeTout $GardeToutBlastNPourTous } else { setGardeTout 0 } if {[info exists TestExistenceBlastNPourTous]} { set TestExistence $TestExistenceBlastNPourTous } else { set TestExistence 1 } } else { set GardeTout 0 set TestExistence 1 set BlastNDataBase [LocaliseBlastNDataBase $NomDeLaBanque] if {$BlastNDataBase==""} { return "" } set CommandeBlast "blastall -p blastn -i \$FichierTFA -o \${FichierBlast}.encours -d $BlastNDataBase -v 250 -K 0 -b 250 -e 10.0 -F T -a 4" if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} { set CommandeBlast [Entre $CommandeBlast] if {$CommandeBlast==""} { return "" } } while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} { if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} { set TestExistence 1 set GardeTout 1 break } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} { set TestExistence 0 set GardeTout 0 break } elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} { set TestExistence 1 set GardeTout 0 break } } set CommandeBlastNPourTous $CommandeBlast set GardeToutBlastNPourTous $GardeTout set TestExistenceBlastNPourTous $TestExistence } set TestLongueurMinimale [OnTraiteDesCDNAs] set SeuilLongueur 9 foreach Nom $Liste { if {[PasTouche $Nom]} { continue } set FichierTFA "" foreach Rep {nucMaskAndReMask nucmask nuctfa} { set FichierTFA "$RepertoireDuGenome/$Rep/$Nom" if {[file exists $FichierTFA]} { break } } if { $FichierTFA=="" || ! [file exists $FichierTFA]} { Warne "$FichierTFA doesn't exist." FinPasTouche $Nom continue } set FichierBlast "$Repertoire/$Nom" if {$TestLongueurMinimale} { set LeTFA [LesLignesDuFichier $FichierTFA] set Seq [join [lrange $LeTFA 1 end]] regsub -all -nocase "N" $Seq "" SeqSansN if {[string length $SeqSansN]<$SeuilLongueur} { FinPasTouche $Nom continue } } if {$GardeTout && [file exists $FichierBlast] } { FinPasTouche $Nom continue } if { $TestExistence && [file exists $FichierBlast] } { if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} { FinPasTouche $Nom continue } } Espionne "Je vais lancer blastn sur $FichierBlast" if {[catch {eval exec $CommandeBlast} Message]} { Espionne "Problem with $FichierBlast" Espionne $Message } if {[file exists "${FichierBlast}.encours"]} { file rename -force "${FichierBlast}.encours" $FichierBlast } else { Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !" } FinPasTouche $Nom } } proc acBlastXPourTous {{NomATraiter ""} {Banque ""}} { global RepertoireDuGenome if {$Banque==""} { set BlastXDataBase "/blast/protall" } else { if {[regexp "/" $Banque]} { set BlastXDataBase $Banque } else { set BlastXDataBase "/blast/$Banque" } } set RepFileMask "$RepertoireDuGenome/nucmask" set Repertoire "$RepertoireDuGenome/blastx" if { ! [file exists "$Repertoire"]} { File mkdir $Repertoire } if {$NomATraiter == ""} { set Liste [ListeDesPABs] } else { if {[regexp " " $NomATraiter]} { regsub -all " " $NomATraiter " " NomATraiter set Liste [split $NomATraiter " "] } else { set Liste [list $NomATraiter] } } set CommandeBlast "blastall -p blastx -i \$FichierTFA -o \$FichierBlast.encours -d $BlastXDataBase -a 4 -v 50 -b 50 " if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} { set CommandeBlast [Entre $CommandeBlast] if {$CommandeBlast==""} { return "" } } set CommandeBlastXPourTous $CommandeBlast set TestLongueurMinimale [OnTraiteDesCDNAs] set SeuilLongueur 9 foreach Nom $Liste { set FichierTFA "" foreach Rep {nucMaskAndReMask nucmask nuctfa} { set FichierTFA "$RepertoireDuGenome/$Rep/$Nom" if {[file exists $FichierTFA]} { break } } if { $FichierTFA=="" || ! [file exists $FichierTFA]} { Warne "$FichierTFA doesn't exist." continue } set FichierBlast "$Repertoire/$Nom" if {$TestLongueurMinimale} { set LeTFA [LesLignesDuFichier $FichierTFA] set Seq [join [lrange $LeTFA 1 end]] regsub -all -nocase "N" $Seq "" SeqSansN if {[string length $SeqSansN]<$SeuilLongueur} { continue } } if {[file exists $FichierBlast] } { continue } Espionne "Je vais lancer BlastX \n de $FichierTFA \nsur $BlastXDataBase \nresultat dans $FichierBlast" if {[catch {eval exec $CommandeBlast} Message]} { Espionne "Problem with $FichierBlast" Espionne $Message } if {[file exists "${FichierBlast}.encours"]} { file rename -force "${FichierBlast}.encours" $FichierBlast } else { Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !" } } } proc acCreeFichiersProtTFAEtProtEMBL {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] CreeFichiersProtTFAEtProtEMBL $Liste } proc acCreeLesNotes {{LesNoms ""} {Keep ""}} { #revoir pour la bande cytologique global RepertoireDuGenome set RepNotes "[RepertoireDuGenome]/notes" if { ! [file exists $RepNotes]} { File mkdir $RepNotes } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set Liste [ListeDesPABs]} else {set Liste [split $LesNoms " "]} set FichierClusters "[RepertoireDuGenome]/fiches/clusters" if {[file exists $FichierClusters]} {set Clusters 1} else {set Clusters 0} foreach Nom $Liste { Espionne $Nom if {$Keep && [file exists "$RepNotes/$Nom"]} { continue } set Note {} #Clusters if {$Clusters==1} { #le fichier jumeaux est une copie de jumeaux_Overlap set NbJumeaux [NombreDeJumeauxOuListeDesJumeaux $Nom $FichierClusters] if {$NbJumeaux!=0} { set JR [JumeauRepresentatif $Nom] if {$JR!=$Nom} { #set CC [CodeClone $JR] lappend Note "Name" "$Nom" lappend Note "Belongs to the cluster of" "$JR ($NbJumeaux clones)" } else { lappend Note "Name" "$Nom" lappend Note "Head of the cluster" "$NbJumeaux clones" } } else { lappend Note "Name" "$Nom" } } else {lappend Note "Name" "$Nom"} lappend Note "" "" #Identites if {[file exists "$RepertoireDuGenome/nuctfa/$Nom"]} { lappend Note "cDNA length" [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]] } set Clone [CodeClone $Nom] set Owner [OwnerOfCDNA $Nom] lappend Note "Code in the Access database" $Clone lappend Note "Owner in the Access database" $Owner if {[OnTraiteDesAffymetrix]} { set Access [AffymetrixAccess $Nom] set DE [ExtraitInfo $Nom "GBtagsDefinition"] lappend Note "GBtags accession number" $Access lappend Note "GBtags definition" $DE } #RepeatMasker set TypeMask [QuelMasqueAvantReMasking $Nom] Espionne $TypeMask set PourcentMask [ExtraitInfo $Nom "RMPourcent"] lappend Note "RepeatMasker results" "$TypeMask ( $PourcentMask % )" set TypeRepeat [ExtraitInfo $Nom "RM"] if {$TypeRepeat!=""} { lappend Note "" "$Nom contains $TypeRepeat sequence(s)" } #ReMasking set TypeMask2 [QuelMasqueApresReMasking $Nom] Espionne $TypeMask2 set PourcentReMask [QuelPourcentageApresMRM $Nom] lappend Note "ReMasking results" "$TypeMask2 ( $PourcentReMask % )" #BlastN contre le genome humain apres ReMasking set TypeLoc [PolyLocalise $Nom] #polylocalise a ete obtenu en lancant proc FichierPolyLocalise de Fred Espionne "localisation : $TypeLoc" lappend Note "BlastN human results" $TypeLoc set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastnhuman"] Espionne [lindex $LesCopains 0] lappend Note "" [lindex $LesCopains 0] foreach Copain [lrange $LesCopains 1 end] { lappend Note "" $Copain } #GenScan set GS [ExtraitInfo $Nom "GS"] if {$GS != "" } {lappend Note "GenScan results" $GS} set GS3 [ExtraitInfo $Nom "GS3"] if {$GS3 != "" } {lappend Note "" "$Nom is $GS3"} set GSE [ExtraitInfo $Nom "GSE"] if {$GSE != "" } {lappend Note "" "$Nom is $GSE"} #BlastP set LesCopains [MeilleursCopains $Nom] if {[lindex $LesCopains 0]!="No blastp file available"} { lappend Note "BlastP results" [lindex $LesCopains 0] foreach Copain [lrange $LesCopains 1 end] { lappend Note "" $Copain } } set CvP [ConsacreVersusPredite $Nom] Espionne $CvP if {$CvP!="No values available"} { lappend Note "Prediction_vs_BlastPHit" $CvP } #BlastX set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"] Espionne [lindex $LesCopains 0] if {[lindex $LesCopains 0]!="No hits found"} { lappend Note "BlastX results" [lindex $LesCopains 0] foreach Copain [lrange $LesCopains 1 end] { lappend Note "" $Copain } } #mRNA complete cds set ResultatRecherche [ExtraitmRNADesInfosAutomatiques $Nom] Espionne $ResultatRecherche if {$ResultatRecherche != ""} { lappend Note "mRNA complete cds" $ResultatRecherche } #BlastN contre genembl, EST, AffyHS foreach {Banque Titre} {blastngenembl "BlastN Genembl" blastnest "BlastN Est" blastnaffy "BlastN Affymetrix"} { set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque] if {$LesCops=={}} { lappend Note "$Titre results" "values not yet available" } elseif {[lindex $LesCops 0]=="File not yet available"} { lappend Note "$Titre results" "values not yet available" } elseif {[lindex $LesCops 0]=="No value"} { lappend Note "$Titre results" "no value available" } elseif {[lindex $LesCops 0]=="No hit"} { lappend Note "$Titre results" "no hit" } else { set PremiereFois 1 foreach Cop $LesCops { set Genre "Inconnu" set Espece "inconnu" scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece set OS "$Genre $Espece" set DE [join [lrange [split $Cop " "] 5 end] " "] if { ! [regexp -nocase "Homo sapiens" $OS]} { continue } if {$PremiereFois} { lappend Note "$Titre results" "$BID $Access $Expect $DE" set PremiereFois 0 continue } else { lappend Note "" "$BID $Access $Expect $DE" } } } } #Affymetrix overlaps if {![OnTraiteDesAffymetrix]} { set LesAffys [LesAffymetrixEnOverlap $Nom] if {$LesAffys!={}} { set TexteAffy "[join $LesAffys " "]" } else { if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} { set TexteAffy "not tested" } else { set TexteAffy "not detected" } } lappend Note "Affymetrix" $TexteAffy } #Traitement pour tous Espionne "leslignes" set LesLignes {} foreach {T V} $Note { if {$T=="Name"} { lappend LesLignes $Nom continue } if {$T!="" || $V!=""} { set L [expr 37 - [string length $T]] if {$T!=""} { set C "." ; set S ":" } else { set C " " ; set S " " } set P [string repeat $C $L] lappend LesLignes [format "%s %s %s %s" $T $P $S $V] } else { lappend LesLignes "" } } SauveLesLignes $LesLignes dans "$RepNotes/$Nom" Espionne "Sauve" } return "" } proc acCreeLesRapportsPourAccess {{LesNoms ""} {Keep ""}} { global RepertoireDuGenome set RepRapports "$RepertoireDuGenome/rapportsaccess" if { ! [file exists $RepRapports]} { File mkdir $RepRapports } if {$Keep==""} { set Keep 0 } else { set Keep 1 } if {$LesNoms==""} {set Liste [ListeDesPABs]} else {set Liste [split $LesNoms " "]} foreach Nom $Liste { if {$Keep && [file exists "$RepRapports/$Nom"]} { continue } Espionne $Nom set Rapport {} #Generalites lappend Rapport "GscopeCode: $Nom" set codeCl [CodeClone $Nom] Espionne "code clone: $codeCl" lappend Rapport "CodeClone: $codeCl" set Longueur [SeqLength $Nom] lappend Rapport "Length: $Longueur" if {[OnTraiteDesAffymetrix]} { set Access [AffymetrixAccess $Nom] lappend Rapport "AffymetrixAccess: $Access" set DE [ExtraitInfo $Nom "GBtagsDefinition"] lappend Rapport "Description: $DE" } else { set User [OwnerOfCDNA $Nom] lappend Rapport "User: $User" } #Clusters set FichierClusters "$RepertoireDuGenome/fiches/clusters" if {[file exists $FichierClusters]} { #le fichier jumeaux est une copie de jumeaux_Overlap if {[NombreDeJumeauxOuListeDesJumeaux $Nom $FichierClusters]!="0"} { set JR [JumeauRepresentatif $Nom] set CC [CodeClone $JR] lappend Rapport "JR: $JR $CC" } } #RepeatMasker set TypeMask [QuelMask $Nom] Espionne $TypeMask lappend Rapport "MaskType: $TypeMask" set PourcentMask [ExtraitInfo $Nom "RMPourcent"] lappend Rapport "MaskedProportion: $PourcentMask" set TypeRepeat [ExtraitInfo $Nom "RM"] if {$TypeRepeat!=""} { lappend Rapport "RepeatType: $TypeRepeat" } #BlastN contre le genome humain set PolyLoc [PolyLocalise $Nom] Espionne $PolyLoc lappend Rapport "LocType: $loc" if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} { set MeilleureLoc [MeilleureLocalisationSurChroContig $Nom] scan $MeilleureLoc "%s %s %d %d %s" Chro Contig Debut Fin Orient regsub "HS" $Chro "" Chro lappend Rapport "Chromosome: $Chro" lappend Rapport "Contig: $Contig" lappend Rapport "Begin: $Debut" lappend Rapport "End: $Fin" lappend Rapport "Orientation: $Orient" } #BlastN contre genembl et est, et TBlastN contre est foreach {Banque Titre} {blastngenembl Genembl} { set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque] if {$LesCops=={}} { lappend Rapport "${Titre}Def: values not yet available" } elseif {[lindex $LesCops 0]=="File not yet available"} { lappend Rapport "${Titre}Def: values not yet available" } elseif {[lindex $LesCops 0]=="No value"} { lappend Rapport "${Titre}Def: no value available" } elseif {[lindex $LesCops 0]=="No hit"} { lappend Rapport "${Titre}Def: no hit" } else { set PremiereFois 1 set Autre 0 foreach Cop $LesCops { set Genre "Inconnu" set Espece "inconnu" scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece set OS "$Genre $Espece" set DE [join [lrange [split $Cop " "] 5 end] " "] if { ! [regexp -nocase "Homo sapiens" $OS]} { continue } if {$PremiereFois} { lappend Rapport "${Titre}Def: $DE" lappend Rapport "${Titre}Access: $BID" set PremDE $DE set PremiereFois 0 continue } if {$DE!=$PremDE} { incr Autre } } lappend Rapport "${Titre}More: [expr $Autre > 0]" } } #Affymetrix overlaps if {![OnTraiteDesAffymetrix]} { set LesCC [LesCodeCloneDesAffymetrixEnOverlap $Nom] if {$LesCC!={}} { set TexteAffy "Affymetrix: [join $LesCC " "]" } else { if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} { set TexteAffy "Affymetrix: not tested" } else { set TexteAffy "Affymetrix: not detected" } } lappend Rapport $TexteAffy } Espionne "fin" SauveLesLignes $Rapport dans "$RepRapports/$Nom" } return "" } proc acCrossValidationPourTous {{NomATraiter ""} {Save ""}} { global RepertoireDuGenome set EspecesSelectionnees "" set LesOrganismesAEtudier [LaSelectionDeNoe] foreach OrganismeAEtudier $LesOrganismesAEtudier { if {$EspecesSelectionnees != ""} {append EspecesSelectionnees "|"} scan $OrganismeAEtudier "%s %s" Genre Espece append EspecesSelectionnees "$Espece" } if {$NomATraiter == ""} { set Liste [ListeDesPABs] } else { if {[regexp " " $NomATraiter]} { regsub -all " " $NomATraiter " " NomATraiter set Liste [split $NomATraiter " "] } else { set Liste [list $NomATraiter] } } set Resultats "" foreach Nom $Liste { Espionne "$Nom" set MeilleurTirCroise [join [CrossValidation $Nom $EspecesSelectionnees] "\t"] append Resultats "$MeilleurTirCroise\n" } Espionne $Resultats set RepFiches "$RepertoireDuGenome/fiches" set File "$RepFiches/CrossValidation" if {$Save == ""} { if {[OuiOuNon "Would you want to save this results in $File?"]} {set Save "Save"} } if {$Save == "Save"} {Sauve $Resultats dans $File} return "$Resultats\n\nSave in $File" } proc acDbClustalPourTous {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] DbClustalPourTous $Liste } proc acFichierContigAndProtPourTous {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] FichierContigAndProtPourTous $Liste } proc acFichierProtAndmRNAPourTous {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] FichierProtAndmRNAPourTous $Liste } proc acFichierRecapitulatif {Nom {Projet ""} {Lab ""} {Protocol ""} {Def spe} {Nature DNA} {Orga ""} {IdMin 0.8} {IdMax 0.95}} { if {$Nom==""} {return} set RepRecap "[RepertoireDuGenome]/bilan" if {![file exists $RepRecap]} {File mkdir $RepRecap} set FichierRecap "$RepRecap/$Nom" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom" set FichierLocHumanG "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human" set FichierLocHumanG_mrna "[RepertoireDuGenome]/Localisation/mRNAHsapLocalisation_Human" set FichierLocHumanG_prot "[RepertoireDuGenome]/Localisation/ProttfaLocalisation_Human" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" #set FichierProttfaExonicMap "[RepertoireDuGenome]/prottfaexonicmap/$Nom" set FichiermRNAHumanExonicMap "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_exonicmap/$Nom" set FichiermRNAMurinExonicMap "[RepertoireDuGenome]/mrnatfa_Mus_musculus_exonicmap/$Nom" set FichiermRNARatExonicMap "[RepertoireDuGenome]/mrnatfa_Rattus_norvegicus_exonicmap/$Nom" set FichierClustMSF "[RepertoireDuGenome]/msf/$Nom.clust" set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set FichierDefinition "[RepertoireDuGenome]/fiches/DefinitionsConsensus" set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" set FichierPF "[RepertoireDuGenome]/pestfind/pest$Nom.embl" set FichierFEF "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_promoter/$Nom.firstef" set FichierHydrophobicity "[RepertoireDuGenome]/fiches/hydrophobicity" ########## #PROJET### ########## if {$Projet!=""} { set LeTexte [list "*********************************************************************"] lappend LeTexte "PROJECT: $Projet" } else { set Projet [RepertoireDuGenome] set Projet [file tail $Projet] set LeTexte [list "PROJECT: $Projet"] } lappend LeTexte "" lappend LeTexte "*********************************************************************" ############################################################################# ######## #INPUT## ######## lappend LeTexte "INPUT:" Espionne "$Nom -> From ; Protocol; Access ; Definition ; Organism; Nature; Length" if {$Lab==""} { set Lab $Projet } lappend LeTexte " From: $Lab" #Suppressive Subtractive Hybridization (SSH) if {$Protocol!=""} {lappend LeTexte " Protocol: $Protocol" } if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] != ""} { set AccessSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] lappend LeTexte " Access/Clone: $AccessSeq" } if {$Def=="spe"} { if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] != ""} { set DefinitionSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] lappend LeTexte " Infos: $DefinitionSeq" } } else { if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] != ""} { set DefinitionSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] lappend LeTexte " Definition: $DefinitionSeq" } } if {$Nature=="Protein"} { if {[file exists $FichierProttfa]} { set TailleSeq [TailleDeLaSequenceDuFichierTFA $FichierProttfa] lappend LeTexte " Length: $TailleSeq AA" } } elseif {[file exists $FichierNuctfa]} { set TailleSeq [TailleDeLaSequenceDuFichierTFA $FichierNuctfa] lappend LeTexte " Length: $TailleSeq pb" } if {$Orga=="mouse"} {lappend LeTexte " Organism: Mus musculus"} if {$Orga=="rat"} {lappend LeTexte " Organism: Rattus norvegicus"} if {$Orga=="human"} {lappend LeTexte " Organism: Homo sapiens"} lappend LeTexte " Nature: $Nature" #set OrganismeSeq [OrganismeDuPAB $Nom] #lappend LeTexte " Organism: $OrganismeSeq" #if {$OrganismeSeq == "Homo sapiens"} {set IdDeRef $IdMax} else {set IdDeRef $IdMin} set IdDeRef $IdMin set PIdDeRef [format "%.1f" [expr $IdDeRef * 100]] ###Cluster dans lequel se trouve la sequence#### Espionne "$Nom -> cluster" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] != ""} { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] lappend LeTexte " Cluster: $Cluster" } ###Les expressions sur les puces affymetrix##### Espionne "$Nom -> expression" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions] != ""} { set LesTemps [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesPointsTemporels] set LesConditions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesConditions ] set LaLigneTemps [list [format "%-6s" ""]] foreach Temps $LesTemps {lappend LaLigneTemps [format "%-6s" $Temps]} lappend LeTexte "" lappend LeTexte " Expression:" lappend LeTexte [join $LaLigneTemps ""] foreach Condition $LesConditions { set LaLigneCondition [list [format "%-6s" $Condition]] foreach Temps $LesTemps { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Condition $Condition PointTemporel $Temps Expression] if {$Expr == ""} {lappend LaLigneCondition [format "%-6s" ""];continue} lappend LaLigneCondition [format "%-6.0f" $Expr] } lappend LeTexte [join $LaLigneCondition ""] } } ###Composition ATCG### #....................# ###Les informations relatives au masking, remasking et mrm#### Espionne "$Nom -> Masking ; ReMasking ; Masking and ReMasking" if {[InterrogeBilanMasking $Nom LesEtats] != ""} { lappend LeTexte "" foreach Etat [InterrogeBilanMasking $Nom LesEtats] { if {[InterrogeBilanMasking $Nom Etat $Etat PMasked] == ""} {continue} set PMasked [InterrogeBilanMasking $Nom Etat $Etat PMasked ] set NbRepeat [InterrogeBilanMasking $Nom Etat $Etat NbRepeat] lappend LeTexte " $Etat PMasked: ${PMasked}%" lappend LeTexte " $Etat NbRepeat: $NbRepeat" set LesRepeatsEtLeurEffectif {} foreach Repeat [InterrogeBilanMasking $Nom Etat $Etat LesRepeats] { set n [InterrogeBilanMasking $Nom Etat $Etat Repeat $Repeat n] lappend LesRepeatsEtLeurEffectif [list $Repeat $n] } set LesRepeats {} foreach LeRepeat [lsort -index 1 -integer -decreasing $LesRepeatsEtLeurEffectif] { lappend LesRepeats "[lindex $LeRepeat 0] ([lindex $LeRepeat 1])" } if {$LesRepeats != {}} { lappend LeTexte " $Etat Repeat: [join $LesRepeats " ; "]" #lappend LeTexte [join $LesRepeats " ; "] } } } lappend LeTexte "" lappend LeTexte "**********************************************************************" ######## #OUTPUT# ######## lappend LeTexte "OUTPUT:" #lappend LeTexte " **********************************************" #lappend LeTexte " General points:" lappend LeTexte "" lappend LeTexte " GScopeName: $Nom" lappend LeTexte "" ############################################################################## ###Localisation de la sequence sur le genome humain### Espionne "$Nom -> localisation on human genome" if {[file exists $FichierLocHumanG]} { lappend LeTexte "" lappend LeTexte " Input sequence localisation:" if {[InterrogeLocalisation $FichierLocHumanG Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierLocHumanG Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] if {$InfoLoc != "MonoLoc"} { lappend LeTexte " WARNING $InfoLoc" } foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation end-1] != "BestLoc" && [lindex $LaLocalisation end-1] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10 ] set F [lindex $LaLocalisation 11 ] set Sens [lindex $LaLocalisation 12 ] set Contig [lindex $LaLocalisation 13 ] set BCyto [lindex $LaLocalisation end-2] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } } } else { lappend LeTexte " WARNING NoLoc" } } if {[file exists $FichierLocHumanG_mrna]} { lappend LeTexte "" lappend LeTexte " Human mRNA sequence localisation:" if {[InterrogeLocalisation $FichierLocHumanG_mrna Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierLocHumanG_mrna Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] if {$InfoLoc != "MonoLoc"} { lappend LeTexte " WARNING $InfoLoc" } foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation end-1] != "BestLoc" && [lindex $LaLocalisation end-1] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10 ] set F [lindex $LaLocalisation 11 ] set Sens [lindex $LaLocalisation 12 ] set Contig [lindex $LaLocalisation 13 ] set BCyto [lindex $LaLocalisation end-2] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } } } else { lappend LeTexte " WARNING NoLoc" } } if {[file exists $FichierLocHumanG_mrna]} { lappend LeTexte "" lappend LeTexte " Protein sequence localisation:" if {[InterrogeLocalisation $FichierLocHumanG_prot Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierLocHumanG_prot Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] if {$InfoLoc != "MonoLoc"} { lappend LeTexte " WARNING $InfoLoc" } foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation end-1] != "BestLoc" && [lindex $LaLocalisation end-1] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10 ] set F [lindex $LaLocalisation 11 ] set Sens [lindex $LaLocalisation 12 ] set Contig [lindex $LaLocalisation 13 ] set BCyto [lindex $LaLocalisation end-2] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } } } else { lappend LeTexte " WARNING NoLoc" } } #lappend LeTexte "" lappend LeTexte " **********************************************" #lappend LeTexte " Your protein:" #lappend LeTexte "" ########################### EST mouse###################################### ### Tissue Type ### Espionne "$Nom -> Tissue Type" set TT "no" if {[InterrogeTissueType $Nom LesTissues] != ""} { set TT "yes" lappend LeTexte "" #lappend LeTexte " **********************************************" lappend LeTexte " EST:" lappend LeTexte "" set LesTissues {} foreach Tissue [InterrogeTissueType $Nom LesTissues] { if {$Tissue == ""} {continue} if {$Projet=="Confidential" && [regexp -nocase "liver" $Tissue]} { lappend LesFoies [list $Tissue [InterrogeTissueType $Nom Tissue $Tissue n]] continue } lappend LesTissues [list $Tissue [InterrogeTissueType $Nom Tissue $Tissue n]] } if {$LesTissues != {}} { set LesTissuesEtLeurEffectif {} foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { lappend LesTissuesEtLeurEffectif "[lindex $LeTissue 0] ([lindex $LeTissue 1])" } if {$Projet=="Confidential"} { if {[info exists LesFoies]} { set LesFoiesEtLeurEffectif {} foreach LeFoie [lsort -index 1 -decreasing -integer $LesFoies] { lappend LesFoiesEtLeurEffectif "[lindex $LeFoie 0] ([lindex $LeFoie 1])" } lappend LeTexte " Tissue type: [join $LesFoiesEtLeurEffectif " ; "]" lappend LeTexte " [join $LesTissuesEtLeurEffectif " ; "]" lappend LeTexte "" } else { lappend LeTexte " Tissue type: -" lappend LeTexte " [join $LesTissuesEtLeurEffectif " ; "]" lappend LeTexte "" } } else { lappend LeTexte " Tissue type: [join $LesTissuesEtLeurEffectif " ; "]" } } } ### Development Stage ### Espionne "$Nom -> Development stage" if {[InterrogeDevStage $Nom LesDevStages] != ""} { if {$TT=="no"} { lappend LeTexte "" lappend LeTexte " **********************************************" #lappend LeTexte " Complementary informations:" #lappend LeTexte "" lappend LeTexte " EST:" lappend LeTexte "" } set LesDevStage {} foreach DevStage [InterrogeDevStage $Nom LesDevStages] { if {$DevStage == ""} {continue} lappend LesDevStage [list $DevStage [InterrogeDevStage $Nom DevStage $DevStage n]] } if {$LesDevStage != {}} { set LesDevStageEtLeurEffectif {} foreach LeDevStage [lsort -index 1 -decreasing -integer $LesDevStage] { lappend LesDevStageEtLeurEffectif "[lindex $LeDevStage 0] ([lindex $LeDevStage 1])" } lappend LeTexte " Developpement stage: [join $LesDevStageEtLeurEffectif " ; "]" lappend LeTexte "" } } ############################# PESTFIND ############################## if {[file exists $FichierPF]} { set ContenuPF [ContenuDuFichier $FichierPF] if {[regexp "No PEST motif was identified" $ContenuPF]} { lappend LeTexte " **********************************************" lappend LeTexte " PEST motifs:" lappend LeTexte "" lappend LeTexte " No PEST motif was identified in your sequence" } else { foreach Ligne [LesLignesDuFichier $FichierPF] { if {[regexp "Potential PEST motif" $Ligne] && ![info exists Vu]} { lappend LeTexte " **********************************************" lappend LeTexte " PEST motifs:" lappend LeTexte "" set n 0 set Vu 1 } if {[info exists Vu] && $n<5} { incr n lappend LeTexte " $Ligne" } } if {![info exists Vu]} { lappend LeTexte " **********************************************" lappend LeTexte " PEST motifs:" lappend LeTexte "" lappend LeTexte " No potential PEST motif was identified in your sequence" } lappend LeTexte "" } } ########################### Hydrophobicity ########################## if {[file exists $FichierHydrophobicity]} { set Nhelices [Hydrophobicity $Nom] set HydrophobiciteDuMSF [Hydrophobicity $Nom Hydro] set Hydrophobicite [Hydrophobicity $Nom OwnHydro] if {$Nhelices!="-2"} { lappend LeTexte " **********************************************" lappend LeTexte " Transmembrane helices:" lappend LeTexte "" lappend LeTexte " Nb_helices in your protein: $Nhelices" lappend LeTexte " Hydrophobicity of your protein: $Hydrophobicite" lappend LeTexte " Hydrophobicity average in MACS: $HydrophobiciteDuMSF" } } ########################## le MSF ################################### Espionne "$Nom -> informations about multiple alignment" set AvecMSF 0 if {[file exists $FichierMSF] && [DecortiqueUnMSF $FichierMSF LesAccess Sequences]} { set AvecMSF 1 set NbAccess [llength $LesAccess ] set NormMDTot [MDScore $FichierMSF "CalculeMoi"] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Protein family:" lappend LeTexte "" lappend LeTexte " Multiple alignment (MACS):" lappend LeTexte " Nb proteins: $NbAccess" lappend LeTexte " NormMD: $NormMDTot" if { $NormMDTot < 0.3} {lappend LeTexte " WARNING the quality of the alignment is bad" } if {0.3 <= $NormMDTot && $NormMDTot < 0.5} {lappend LeTexte " WARNING the quality of the alignment is medium"} } if {[InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] != "" && $AvecMSF} { set LesClusters [InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] set NbClusters [llength $LesClusters] set ClusterDeLaProt [InterrogeLesClustersDesMSF $FichierClustMSF Access $Nom Cluster ] set LesAccess [InterrogeLesClustersDesMSF $FichierClustMSF Cluster $ClusterDeLaProt LesAccess] set NbAccess [llength $LesAccess] set NormMDDuClust [MDScoreAvecSelectionDuFichier $FichierMSF $LesAccess] lappend LeTexte " Nb clusters: $NbClusters" lappend LeTexte " Cluster of our protein: $ClusterDeLaProt" lappend LeTexte " Nb proteins in our cluster: $NbAccess" lappend LeTexte " NormMD of our Cluster: $NormMDDuClust" if {$NormMDDuClust < 0.3} {lappend LeTexte " WARNING the quality of the alignment is bad" } if {0.3 <= $NormMDDuClust && $NormMDDuClust < 0.5} {lappend LeTexte " WARNING the quality of the alignment is medium"} InterrogeLesClustersDesMSF unset ###Your MACS cluster lappend LeTexte "" lappend LeTexte " **************************************" lappend LeTexte " Your cluster:" lappend LeTexte "" } ###Definition moyenne### Espionne "$Nom -> mean definition" if {[InterrogeDefinitionsConsensus $Nom Definition]!=""} { set DefMoy [InterrogeDefinitionsConsensus $Nom Definition] lappend LeTexte " Mean definition: $DefMoy" } ###Les noms des genes des proteines du meme cluster de msf que la proteine de ref### Espionne "$Nom -> Gene name" if {[InterrogeGeneName $Nom LesGeneNames] != ""} { set LesGeneNames {} foreach GN [InterrogeGeneName $Nom LesGeneNames] { if {$GN == ""} {continue} lappend LesGeneNames [list $GN [InterrogeGeneName $Nom GeneName $GN n]] } if {$LesGeneNames != {}} { set LesGeneNamesEtLeurEffectif {} foreach LeGN [lsort -index 1 -decreasing -integer $LesGeneNames] { lappend LesGeneNamesEtLeurEffectif "[lindex $LeGN 0] ([lindex $LeGN 1])" } lappend LeTexte "" lappend LeTexte " GeneName: [join $LesGeneNamesEtLeurEffectif " ; "]" #lappend LeTexte " [join $LesGeneNamesEtLeurEffectif " ; "]" } } ###Recherche des proteines identiques a 98%################# set LesAccessDesChoisi {} #if {$AccessDuChoisi != ""} {lappend LesAccessDesChoisi $AccessDuChoisi} Espionne "$Nom -> proteins with 98% of identity with the best protein" if {$AvecMSF} { set LesAccessDesIdentiques {} foreach Access [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $Nom 0.98] { set Access [string toupper $Access] if {[info exists DejaVu($Access)]} {continue} set DejaVu($Access) 1 lappend LesAccessDesChoisi $Access set PageInfo [PageInfo $Access protein "id acc des org"] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] set Taille [TailleDeLaProt_PageInfo $PageInfo] foreach Org $LesOrgas { lappend LesAccessDesIdentiques " $Access ; Protein ; $Taille AA ; $Org ; $Def" } } if {$LesAccessDesIdentiques != {}} { lappend LeTexte "" #lappend LeTexte "Proteins with 98% of identity with our protein:" #lappend LeTexte " **************************************" #lappend LeTexte "" lappend LeTexte " Identical or quasi-identical proteins:" foreach LAccessIdentique $LesAccessDesIdentiques { lappend LeTexte $LAccessIdentique } } } ###recherche des mRNAs et des proteines CrossLinked#### Espionne "$Nom -> mRNAs and proteins cross-linked" if {$LesAccessDesChoisi != {}} { set LesAccessCrossLinked {} foreach Access $LesAccessDesChoisi { if {$Access == ""} {continue} set LesAccessCrossLinked [concat $LesAccessCrossLinked [LesCrossLinkedDeLAccess_Recursif $Access]] } if {$LesAccessCrossLinked != {}} { set LeTexteDesCrossLinked {} foreach LAccessCL [lsort -index 1 $LesAccessCrossLinked] { set Access [string toupper [lindex $LAccessCL 0]] if {[info exists DejaVu($Access)]} {continue} set Quoi [lindex $LAccessCL 1] set Taille [lindex $LAccessCL 2] if {$Quoi == "mRNA" } {set Taille "$Taille bp"} if {$Quoi == "Protein"} {set Taille "$Taille AA"} set Org [lindex $LAccessCL 3] set Def [lindex $LAccessCL 4] lappend LeTexteDesCrossLinked " $Quoi ; $Access ; $Taille ; $Org ; $Def" } if {$LeTexteDesCrossLinked != {}} { lappend LeTexte "" lappend LeTexte " Others CrossLinked Accessions:" set LeTexte [concat $LeTexte $LeTexteDesCrossLinked] } } } lappend LeTexte "" ###Domaines### Espionne "$Nom -> Domaines" if {[InterrogeDomaines $Nom LesDomaines]!=""} { set LesDomaines [InterrogeDomaines $Nom LesDomaines] lappend LeTexte " Mean domains:" foreach Domaine $LesDomaines { if {[regexp "CHAIN" $Domaine] && [regexp "\{\}]" $Domaine]} {continue} regsub -all {\{} $Domaine "" Domaine regsub -all {\}} $Domaine "" Domaine if {[regexp "STRAND" $Domaine] || [regexp "HELIX" $Domaine] || [regexp "TURN" $Domaine]} { continue } if {![regexp {1\.0} $Domaine]} {continue} lappend LeTexte " $Domaine" } } lappend LeTexte "" ### ontologie #### Espionne "$Nom -> ontology" if {[InterrogeGeneOntology $FichierGO $Nom LesGO] != ""} { #lappend LeTexte " **********************************************" lappend LeTexte " Mean Gene Ontology:" set LesGOFunction {} set LesGOProcess {} set LesGOComponent {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {$GO == ""} {continue} set Type [InterrogeGeneOntology $FichierGO GO $GO Type] if {$Type == "function" } {lappend LesGOFunction $GO} if {$Type == "process" } {lappend LesGOProcess $GO} if {$Type == "component"} {lappend LesGOComponent $GO} } foreach GO $LesGOFunction { lappend LeTexte " Function $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } foreach GO $LesGOProcess { lappend LeTexte " Process $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } foreach GO $LesGOComponent { lappend LeTexte " Component $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } } ##Pathways KEGG## Espionne "$Nom -> KEGG" if {[InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC]!=""} { lappend LeTexte "" lappend LeTexte " Mean KEGG:" } if {[InterrogeMesKEGG $Nom LesPathway]!=""} { set LesNumerosDesPathways [InterrogeMesKEGG $Nom LesPathway] foreach Pathway $LesNumerosDesPathways { set DefPathway [InterrogeMesKEGG Pathway $Pathway Definition] lappend LeTexte " Pathway $Pathway $DefPathway" } } if {[InterrogeMesKEGG $Nom LesEC]!=""} { set LesEC [InterrogeMesKEGG $Nom LesEC] foreach EC $LesEC { lappend LeTexte " EC $EC" } } if {[InterrogeMesKEGG $Nom LesKegg]!=""} { set LesKegg [InterrogeMesKEGG $Nom LesKegg] foreach Kegg $LesKegg { set DefKegg [InterrogeMesKEGG Kegg $Kegg Definition] lappend LeTexte " Kegg $Kegg $DefKegg" } } lappend LeTexte "" ####Si projet proteine if {$Nature=="Protein"} { Espionne coucou1 if {[file exists $FichierBest]} { Espionne coucou2 if {$Orga=="rat"} { Espionne coucou3 #special pour ProteoSys #rat protein set ProteinAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Rattus norvegicus" Protein Access] if {$ProteinAccess!=""} { Espionne "$Nom -> rat protein" set ProteinDef [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Definition] set ProteinTaille [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Taille] set ProteinId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $ProteinAccess Identity] #lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Rat protein:" lappend LeTexte " Protein Access: $ProteinAccess" lappend LeTexte " Protein Definition: $ProteinDef" lappend LeTexte " Protein Organism: Rattus norvegicus" lappend LeTexte " Protein Length: $ProteinTaille AA" lappend LeTexte " Percent Identity: $ProteinId" } #rat mRNA set mRNAAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Rattus norvegicus" mRNA Access] if {$mRNAAccess!=""} { set mRNADef [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Definition] set mRNATaille [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Taille] set mRNAId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $mRNAAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Rat mRNA complete cds:" lappend LeTexte " mRNA Access: $mRNAAccess" lappend LeTexte " mRNA Definition: $mRNADef" lappend LeTexte " mRNA Organism: Rattus norvegicus" lappend LeTexte " mRNA Length: $mRNATaille bp" lappend LeTexte " Percent Identity: $mRNAId" } ###Localisation du mRNA full length rat sur le genome humain### Espionne "$Nom -> Localisation du mRNA rat sur le genome humain" if {[file exists $FichiermRNARatExonicMap]} { lappend LeTexte "" #lappend LeTexte " **********************************************" lappend LeTexte " Localisation on the human genome:" if {[InterrogeFichierExonicMap $FichiermRNARatExonicMap LesRangs] != ""} { #nb exons set NbExons [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang 1 NbExonicAreas] if {$NbExons>0} { set Contig [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang 1 Contig] set LesDebEtFin {} set n 1 while {$n<[expr $NbExons+1]} { set DS [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang 1 ExonArea $n DS] set FS [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang 1 ExonArea $n FS] set Sens [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang 1 ExonArea $n Sens] lappend LesDebEtFin "Exon $n From $DS To $FS ($Sens) on Contig $Contig" incr n } } set LesRangs [InterrogeFichierExonicMap $FichiermRNARatExonicMap LesRangs] if {1 < [llength $LesRangs]} { lappend LeTexte " WARNING PolyLoc" } foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang Contig] set DebCont [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang ContigLocalisation Debut] set FinCont [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang ContigLocalisation Fin ] set SensCont [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang Sens ] set LesCoordonneesSurChro [CoordonneesSurChromosome $Contig $DebCont $FinCont $SensCont] set D [lindex $LesCoordonneesSurChro 1] set F [lindex $LesCoordonneesSurChro 2] set Sens [lindex $LesCoordonneesSurChro 3] set BCyto [join [LesBandesCytologiquesDeLaLocalisation $Contig $DebCont $FinCont] " ; "] set n 0 set nTot 0 set NbAreas [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang NbExonicAreas] for {set i 1} {$i <= $NbAreas} {incr i} { incr n [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang ExonArea $i nAli ] incr nTot [InterrogeFichierExonicMap $FichiermRNARatExonicMap Rang $Rang ExonArea $i nAliTot] } if {$nTot == 0} {continue} set Id [expr $n * 1.0 / $nTot] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } if {[info exists NbExons]&& $Rang==1} { lappend LeTexte " Nb_Exons: $NbExons" foreach DebFin $LesDebEtFin { lappend LeTexte " $DebFin" } lappend LeTexte "" } } } else { lappend LeTexte " WARNING NoLoc" } InterrogeFichierExonicMap unset } else { lappend LeTexte " WARNING NoLoc" } InterrogeFichierExonicMap unset } #fin du si rat #special pour ProteoSys #mouse protein set ProteinAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Mus musculus" Protein Access] if {$ProteinAccess!=""} { set ProteinDef [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Definition] set ProteinTaille [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Taille] set ProteinId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $ProteinAccess Identity] #lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Mouse protein:" lappend LeTexte " Protein Access: $ProteinAccess" lappend LeTexte " Protein Definition: $ProteinDef" lappend LeTexte " Protein Organism: Mus musculus" lappend LeTexte " Protein Length: $ProteinTaille AA" lappend LeTexte " Percent Identity: $ProteinId" } #mouse mRNA set mRNAAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Mus musculus" mRNA Access] if {$mRNAAccess!=""} { set mRNADef [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Definition] set mRNATaille [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Taille] set mRNAId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $mRNAAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Mouse mRNA complete cds:" lappend LeTexte " mRNA Access: $mRNAAccess" lappend LeTexte " mRNA Definition: $mRNADef" lappend LeTexte " mRNA Organism: Mus musculus" lappend LeTexte " mRNA Length: $mRNATaille bp" lappend LeTexte " Percent Identity: $mRNAId" } ###Localisation de la proteine mouse sur le genome humain### Espionne "$Nom -> Localisation de la proteine mouse sur le genome humain" if {[file exists $FichiermRNAMurinExonicMap]} { lappend LeTexte "" #lappend LeTexte " **********************************************" lappend LeTexte " Localisation on the human genome:" if {[InterrogeFichierExonicMap $FichiermRNAMurinExonicMap LesRangs] != ""} { #nb exons set NbExons [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang 1 NbExonicAreas] if {$NbExons>0} { set Contig [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang 1 Contig] set LesDebEtFin {} set n 1 while {$n<[expr $NbExons+1]} { set DS [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang 1 ExonArea $n DS] set FS [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang 1 ExonArea $n FS] set Sens [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang 1 ExonArea $n Sens] lappend LesDebEtFin "Exon $n From $DS To $FS ($Sens) on Contig $Contig" incr n } } set LesRangs [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap LesRangs] if {1 < [llength $LesRangs]} { lappend LeTexte " WARNING PolyLoc" } foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang Contig] set DebCont [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang ContigLocalisation Debut] set FinCont [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang ContigLocalisation Fin ] set SensCont [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang Sens ] set LesCoordonneesSurChro [CoordonneesSurChromosome $Contig $DebCont $FinCont $SensCont] set D [lindex $LesCoordonneesSurChro 1] set F [lindex $LesCoordonneesSurChro 2] set Sens [lindex $LesCoordonneesSurChro 3] set BCyto [join [LesBandesCytologiquesDeLaLocalisation $Contig $DebCont $FinCont] " ; "] set n 0 set nTot 0 set NbAreas [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang NbExonicAreas] for {set i 1} {$i <= $NbAreas} {incr i} { incr n [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang ExonArea $i nAli ] incr nTot [InterrogeFichierExonicMap $FichiermRNAMurinExonicMap Rang $Rang ExonArea $i nAliTot] } if {$nTot == 0} {continue} set Id [expr $n * 1.0 / $nTot] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } if {[info exists NbExons]&& $Rang==1} { lappend LeTexte " Nb_Exons: $NbExons" foreach DebFin $LesDebEtFin { lappend LeTexte " $DebFin" } lappend LeTexte "" } } } else { lappend LeTexte " WARNING NoLoc" } InterrogeFichierExonicMap unset } #human protein set ProteinAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$ProteinAccess!=""} { set ProteinDef [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Definition] set ProteinTaille [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Taille] set ProteinId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $ProteinAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Human protein:" lappend LeTexte " Protein Access: $ProteinAccess" lappend LeTexte " Protein Definition: $ProteinDef" lappend LeTexte " Protein Organism: Homo sapiens" lappend LeTexte " Protein Length: $ProteinTaille AA" lappend LeTexte " Percent Identity: $ProteinId" } #human mRNA set mRNAAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$mRNAAccess!=""} { set mRNADef [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Definition] set mRNATaille [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Taille] set mRNAId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $mRNAAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Human mRNA complete cds:" lappend LeTexte " mRNA Access: $mRNAAccess" lappend LeTexte " mRNA Definition: $mRNADef" lappend LeTexte " mRNA Organism: Homo sapiens" lappend LeTexte " mRNA Length: $mRNATaille bp" lappend LeTexte " Percent Identity: $mRNAId" } ###Localisation du human complete cds mRNA sur le genome humain### Espionne "$Nom -> Localisation du human complete cds mRNA sur le genome humain" if {[file exists $FichiermRNAHumanExonicMap]} { lappend LeTexte "" lappend LeTexte " Localisation on the human genome:" if {[InterrogeFichierExonicMap $FichiermRNAHumanExonicMap LesRangs] != ""} { #nb exons set NbExons [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang 1 NbExonicAreas] if {$NbExons>0} { set Contig [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang 1 Contig] set LesDebEtFin {} set n 1 while {$n<[expr $NbExons+1]} { set DS [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang 1 ExonArea $n DS] set FS [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang 1 ExonArea $n FS] set Sens [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang 1 ExonArea $n Sens] lappend LesDebEtFin "Exon $n From $DS To $FS ($Sens) on Contig $Contig" incr n } } set LesRangs [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap LesRangs] if {1 < [llength $LesRangs]} { lappend LeTexte " WARNING PolyLoc" #lappend LeTexte "" } foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang Contig] set DebCont [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang ContigLocalisation Debut] set FinCont [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang ContigLocalisation Fin ] set SensCont [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang Sens] set LesCoordonneesSurChro [CoordonneesSurChromosome $Contig $DebCont $FinCont $SensCont] set D [lindex $LesCoordonneesSurChro 1] set F [lindex $LesCoordonneesSurChro 2] set Sens [lindex $LesCoordonneesSurChro 3] set BCyto [join [LesBandesCytologiquesDeLaLocalisation $Contig $DebCont $FinCont] " ; "] set n 0 set nTot 0 set NbAreas [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang NbExonicAreas] for {set i 1} {$i <= $NbAreas} {incr i} { incr n [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang ExonArea $i nAli] incr nTot [InterrogeFichierExonicMap $FichiermRNAHumanExonicMap Rang $Rang ExonArea $i nAliTot] } if {$nTot == 0} {continue} set Id [expr $n * 1.0 / $nTot] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" set IdDeRef $IdMax if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } if {[info exists NbExons] && $Rang==1} { lappend LeTexte " Nb_Exons: $NbExons" foreach DebFin $LesDebEtFin { lappend LeTexte " $DebFin" } lappend LeTexte "" } } } else { lappend LeTexte " WARNING NoLoc" } InterrogeFichierExonicMap unset } } } ################### PROMOTER ################################################ #Espionne "$Nom -> promoter" #if {[file exists $FichierFEF]} { #lappend Letexte "" #lappend LeTexte " **********************************************" #lappend LeTexte " Promoter predicted from human mRNA complete cds:" #lappend LeTexte "" #foreach Ligne [LesLignesDuFichier $FichierFEF] { #lappend LeTexte " $Ligne" #} #lappend LeTexte "" #} lappend LeTexte "" EspionneL $LeTexte Sauve [join $LeTexte "\n"] dans $FichierRecap return } proc acFichierRecapitulatifPourTous {NomATraiter {Projet ""} {Lab ""} {Protocol ""} {Def spe} {Nature DNA} {Orga ""} {IdMin 0.8} {IdMax 0.95}} { JeMeSignale if {$NomATraiter==""} { set Liste [ListeDesPABs] } elseif {[string equal -nocase $NomATraiter "AskForSubList"]} { set Liste [SousListe [ListeDesPABs]] } elseif {[llength $NomATraiter]>1} { set Liste $NomATraiter } else { set Liste [list $NomATraiter] } set RepRecap "[RepertoireDuGenome]/bilan" set Keep 0 if {![file exists $RepRecap]} { File mkdir $RepRecap set Keep 0 } elseif {[OuiOuNon "If some file exists in $RepRecap, Do you want to conserv them?"]} { set Keep 1 } foreach Nom $Liste { Espionne $Nom if {[file exists "$RepRecap/$Nom"] && $Keep} {continue} Espionne "$Nom -> Bilan" acFichierRecapitulatif $Nom $Projet $Lab $Protocol $Def $Nature $Orga $IdMin $IdMax Espionne "$Nom -> Bilan done" } return } proc acFichierTFADesProteinesChoisiesPourTous {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] FichierTFADesProteinesChoisiesPourTous $Liste } proc acFichierTFADesProteinesDesContigsPourTous {FichierClusters} { set Liste [ListeMinimumDesJR $FichierClusters] FichierTFADesProteinesDesContigsPourTous $Liste } proc acInformeIdentitesDuCDNA {Nom} { global RepertoireDuGenome set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom" if { ! [file exists $FichierTFA]} { return "" } set CC "" set Ow "" set Entete [PremiereLigneDuFichier $FichierTFA] if {[regexp -nocase "Affy" $RepertoireDuGenome]} { regsub " target:HG-U95Av2:" $Entete "" Entete set AC [lindex [split $Entete ";"] 1] #FaireLire $AC set Definition1 [lindex [split $Entete "/"] 0] set Definition [lindex [split $Definition1 ":"] 2] #FaireLire $Definition set CC1 [lindex [split $Entete ";"] 0] set CC [lindex [split $CC1 ":"] 1] #FaireLire $CC InformeSansDemander $Nom "=AffymetrixAccess: $AC" InformeSansDemander $Nom "=OwnerOfCDNA: Affymetrix" InformeSansDemander $Nom "=GBtagsDefinition: $Definition" } else { scan $Entete "%s %s %s" NomLu CC Ow if {$Ow!=""} { InformeSansDemander $Nom "=OwnerOfCDNA: $Ow" } if {$CC==""} { return "" } } return [InformeSansDemander $Nom "=CodeClone: $CC"] } proc acInformeIdentitesDuCDNAPourTous {} { foreach Nom [ListeDesPABs] { Espionne [acInformeIdentitesDuCDNA $Nom] } } proc acLesProteinesEtLesmRNAsPourTous {{NomATraiter ""} {Expect 0.001} {NbSubject 500}} { global RepertoireDuGenome set LesOrganismes [LaSelectionDeNoe] set UnFichierACompleter 0 if {[OuiOuNon "Would you want to complete existing files?"]} { set UnFichierACompleter 1 if {[OuiOuNon "Do I use $RepertoireDuGenome/infos"]} { set RepInfo "$RepertoireDuGenome/infos" } else { set RepInfo [ChoisirUnRepertoire "$RepertoireDuGenome/infos"] } } set RepInfoAuto "$RepertoireDuGenome/mRNAAndProt" if {![file exists $RepInfoAuto]} {File mkdir $RepInfoAuto} set Reponse 0 if {[OuiOuNon "Would you want to conserve your work?"]} {set Reponse 1} if {$NomATraiter == ""} { set Liste [ListeDesPABs] } else { if {[regexp " " $NomATraiter]} { regsub -all " " $NomATraiter " " NomATraiter set Liste [split $NomATraiter " "] } else { set Liste [list $NomATraiter] } } foreach Nom $Liste { if {[file exists "$RepInfoAuto/$Nom"] && $Reponse} {continue} Espionne "$Nom in progress..." if {$UnFichierACompleter == 0} { set Info "" } else { if {![file exists "$RepInfo/$Nom"] } { Espionne "$Nom stop..." continue } else { set Info [ContenuDuFichier "$RepInfo/$Nom"] } } set Taille [TailleDeLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"] append Info "\nLength: $Taille" PourcentagesDeMasking Repeat $Nom if {[info exists Repeat(Masking)] } {append Info "\nMasking: [set Repeat(Masking)]"} if {[info exists Repeat(ReMasking)]} {append Info "\nReMasking: [set Repeat(ReMasking)]"} if {[info exists Repeat(MRM)] } {append Info "\nMRM: [set Repeat(MRM)]"} Sauve $Info dans "$RepInfoAuto/$Nom" set Resultats [LesProteinesEtLesmRNAs $Nom $LesOrganismes $Expect $NbSubject] if {[regexp -nocase {[a-z0-9]} $Resultats]} { append Info "\n\nBEGINNING OF THE AUTOMATIC PROTOCOL\n" append Info "$Resultats\n" append Info "\nEND OF THE AUTOMATIC PROTOCOL" } Espionne $Info Sauve $Info dans "$RepInfoAuto/$Nom" } return "The End" } proc acMeilleursCopainsDuBlastPourTous {{NomATraiter ""} {Rep blastngenembl}} { global RepertoireDuGenome Wup "Creates the file and returns its name. Returns an empty string if nothing found" set Fichier "$RepertoireDuGenome/fiches/cops_$Rep" if {[file exists $Fichier]} { if {[OuiOuNon "Do I keep existing results found in $Fichier ?"]} { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" Nom lappend LesOldCops($Nom) $Ligne } if {[info exists Nom]} { unset LesOldCops($Nom) } } File rename -force $Fichier $Fichier.copie File delete -force $Fichier } if {$NomATraiter == ""} { set Liste [ListeDesPABs] } else { if {[regexp " " $NomATraiter]} { regsub -all " " $NomATraiter " " NomATraiter set Liste [split $NomATraiter " "] } else { set Liste [list $NomATraiter] } } foreach Nom $Liste { Espionne "Je vais chercher les cops dans $Rep de $Nom" if {[info exists LesOldCops($Nom)]} { AppendAuFichier $Fichier [join $LesOldCops($Nom) "\n"] continue } set LesCops [MeilleursCopainsDuBlast $Nom $Rep] if {$LesCops=={}} { continue } AppendAuFichier $Fichier [join $LesCops "\n"] } if {[file exists $Fichier]} { return $Fichier } else { return "" } } proc acMeilleursCopainsDuBlastPourUneListe {{Liste ""} {Rep blastngenembl}} { global RepertoireDuGenome Wup "Creates the file and returns its name. Returns an empty string if nothing found" set Fichier "$RepertoireDuGenome/fiches/cops_$Rep" if {[file exists $Fichier]} { if {[OuiOuNon "Do I keep existing results found in $Fichier ?"]} { foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s" Nom lappend LesOldCops($Nom) $Ligne } if {[info exists Nom]} { unset LesOldCops($Nom) } } File rename -force $Fichier $Fichier.copie File delete -force $Fichier } if {$Liste == {}} { set Liste [ListeDesPABs] } foreach Nom $Liste { if {$Nom == ""} {continue} Espionne "Je vais chercher les cops dans $Rep de $Nom" if {[info exists LesOldCops($Nom)]} { AppendAuFichier $Fichier [join $LesOldCops($Nom) "\n"] continue } set LesCops [MeilleursCopainsDuBlast $Nom $Rep] if {$LesCops=={}} { continue } AppendAuFichier $Fichier [join $LesCops "\n"] } if {[file exists $Fichier]} { return $Fichier } else { return "" } } proc acTailleDeLaSequenceDuFichierTFA {FichierTFA} { if {![file exists $FichierTFA]} {return ""} set Sequence "" foreach Ligne [LesLignesDuFichier $FichierTFA] { if {[regexp -nocase "^>" $Ligne]} {continue} regsub -all "\n" $Ligne "" Ligne regsub -all " " $Ligne "" Ligne append Sequence $Ligne } set Taille [string length $Sequence] return $Taille } proc ac_AfficheVariable {Page {Maniere ""} {NomDuFichierOrigine ""}} { Wup "Cette proc est le coeur de Gscope" Wup "Most used procedure ... : " Wup "Shows the text Page in a listbox, with a lot of buttons." Wup "Copyright 1999 Raymond Ripp" Gs "Frame" if {$Page==""} { return "" } global VariableDeRetour global LesFenetresDePAB global PagePropre global CurrentGenome set Nom "" set Queue [file tail $NomDuFichierOrigine] set w [NomDe fenetre] regsub -all {\t} $Page " " PagePropre($w) if { [EstPABouTROUouTRNAouARN [file tail $NomDuFichierOrigine]] } { set Nom $Queue } lappend LesFenetresDePAB($Queue) $w if { $NomDuFichierOrigine == "" } { set NomDuFichierOrigine "Tsointsoin" } if {$Maniere=="AutoManiere" || $Maniere==""} { set Maniere [LaManierePourAffiche $NomDuFichierOrigine] } toplevel $w if {$Nom!="" && [NomDeScene $Nom]!=""} { set Titre "[NomDeScene $Nom] $NomDuFichierOrigine" } else { set Titre "$NomDuFichierOrigine" } wm title $w "$Titre" wm iconname $w "$Titre" label $w.msg -wraplength 4i -justify left -text "$Titre" pack $w.msg -side top set Clavier $w.buttons frame $Clavier pack $Clavier -side bottom -fill x -padx 3m -pady 1m TouchePour $Clavier NouvelleGamme TouchePour $Clavier NouvelleCouleur "red" if { [regexp "AvecRetour" $Maniere] } { TouchePour $Clavier "Validate sel." "set VariableDeRetour($w) \[selection get\]" "" "green" TouchePour <2> " /All" "set VariableDeRetour($w) \[set PagePropre($w)\]" "" TouchePour <3> " / No!" "set VariableDeRetour($w) {}" TouchePour $Clavier NouvelleCouleur "pink" } TouchePour $Clavier "Dismiss" "unset PagePropre($w) ; after 10 destroy $w" TouchePour $Clavier "Dismiss_all" "DismissToutCePAB $Queue" frame $w.frame -borderwidth 10 pack $w.frame -side top -expand yes -fill both scrollbar $w.frame.yscroll -command "$w.frame.list yview" scrollbar $w.frame.xscroll -command "$w.frame.list xview" -orient horizontal #set Largeur 80 set Largeur 100 set Hauteur 35 if { [regexp "GrandeLargeur" $Maniere] } { set Largeur 128 } listbox $w.frame.list -width $Largeur -height $Hauteur -setgrid 1 -yscroll "$w.frame.yscroll set" -xscroll "$w.frame.xscroll set" -selectmode extended -background "LightGrey" -foreground "Black" -selectbackground "LightYellow" -selectforeground "Black" -font [list Courier [PolicePourListBox]] grid $w.frame.list -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew grid $w.frame.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew grid rowconfig $w.frame 0 -weight 1 -minsize 0 grid columnconfig $w.frame 0 -weight 1 -minsize 0 set nLignes 0 foreach Ligne [split [set PagePropre($w)] "\n"] { incr nLignes #if { [regexp "AvecSegAlignement" $Maniere] && [regexp {^>[\./a-zA-Z]} $Ligne]} { break } $w.frame.list insert end $Ligne } if {$nLignes<30} { $w.frame.list configure -height [expr $nLignes+3] } bind $w.frame.list <3> "DecrisLaLigne %W %x %y" bind $w.frame.list "DecrisLaLigne %W %x %y Efface" } proc ac_BlastXDuFichier {FichierTFA {Banque protall} {NbSubject 10} {Expect 10.0} {Filtre 1} {FichierBlast ""} {EditCommand 0}} { global RepertoireDuGenome AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running" if {$Filtre} { set Filtre "T" } else { set Filtre "F"} ##ac #if {$Banque != "protall"} {AttendreTantQueExiste "/gcg/Update/.updtgcgnew_running"} if {[regexp "/" $Banque]} { set NomDeLaBanque "$Banque" } else { set NomDeLaBanque "/blast/$Banque" } ## set CommandeBlastX "eval exec blastall -p blastx -i \$FichierTFA -o \$FichierBlast -d \$NomDeLaBanque -F \$Filtre -e $Expect -v $NbSubject -b $NbSubject -a 4" if {$EditCommand == 1 && [OuiOuNon "Do You want to edit the BlastX command ?" 0]} { set CommandeBlastX [Entre $CommandeBlastX] } if {$FichierBlast == ""} { set RepBlast [RepertoireDeTravail] set FichierBlast "$RepBlast/[file tail $FichierTFA]" } if { ! [file exists $FichierTFA]} { Warne "$FichierTFA doesn't exist.";exit} eval $CommandeBlastX return $FichierBlast } proc ac_ChromosomeSelectionne {K} { set Liste [$K find withtag current] foreach Id $Liste { set Chromosome [lindex [$K gettags $Id] 0] set FichierCourbeBAC [lindex [$K gettags $Id] 1] set FichierCourbeOligo [lindex [$K gettags $Id] 2] set RepFichierLocCGHBAC [lindex [$K gettags $Id] 3] set RepFichierLocCGHOligo [lindex [$K gettags $Id] 4] ac_IllustreUnChromosome $Chromosome $FichierCourbeBAC $FichierCourbeOligo $RepFichierLocCGHBAC $RepFichierLocCGHOligo } } proc ac_ChromosomeSelectionneAvtEtApresSeg {K} { Espionne "chro selectionne" set Liste [$K find withtag current] foreach Id $Liste { set Chromosome [lindex [$K gettags $Id] 0] set FichierCourbeCGH [lindex [$K gettags $Id] 1] set FichierCourbeSEG [lindex [$K gettags $Id] 2] ac_IllustreUnChromosomeAvtEtApresSeg $Chromosome $FichierCourbeCGH $FichierCourbeSEG } } proc ac_ChromosomeSelectionneCGH {K} { set Liste [$K find withtag current] foreach Id $Liste { set Chromosome [lindex [$K gettags $Id] 0] set LesCas [lindex [$K gettags $Id] 1] ac_IllustreUnChromosomeCGH $Chromosome $LesCas } } proc ac_ChromosomeSelectionneCGH_seg {K} { # pour la vue All set Liste [$K find withtag current] foreach Id $Liste { set Chromosome [lindex [$K gettags $Id] 0] set LesCas [lindex [$K gettags $Id] 1] ac_IllustreUnChromosomeCGH_seg $Chromosome $LesCas } } proc ac_ChromosomeSelectionneSEG {K} { Espionne "chro selectionne" set Liste [$K find withtag current] foreach Id $Liste { set Chromosome [lindex [$K gettags $Id] 0] set FichierCourbeCGH [lindex [$K gettags $Id] 1] set FichierCourbeSEG [lindex [$K gettags $Id] 2] ac_IllustreUnChromosome_SEG $Chromosome $FichierCourbeCGH $FichierCourbeSEG } } proc ac_IllustreUnChromosome {Chromosome FichierCourbeBAC FichierCourbeOligo RepFichierLocCGHBAC RepFichierLocCGHOligo {FichierBACfou ""} {LesPos ""} {LesNoms ""}} { FaireAttendreAnnaick .fenetre "Running" "Please wait..." #Espionne "IllustreUnchromosome en cours" Espionne "$Chromosome $FichierCourbeBAC $FichierCourbeOligo $RepFichierLocCGHBAC $RepFichierLocCGHOligo" #choix du cas if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]} if {$FichierCourbeBAC==""} { FaireLire "Please, Choose your BAC CGH array file. Thank you!" set FichierCourbeBAC [tk_getOpenFile -title "BAC CGH array file to open"] } # Modif MG set BACfile 1 if {$FichierCourbeBAC=="null" && $RepFichierLocCGHBAC=="null"} { Espionne "No BAC data file" set BACfile 0 } if {$FichierCourbeOligo==""} { FaireLire "Please, Choose your Oligo CGH array file. Thank you!" set FichierCourbeOligo [tk_getOpenFile -title "Oligo CGH array file to open"] } if {$BACfile!=0} { set NomFichierBAC [file tail $FichierCourbeBAC] set FichierLocCGHBAC "[RepertoireDuGenome]/$RepFichierLocCGHBAC/CGH_BAC_localisation" } set NomFichierOligo [file tail $FichierCourbeOligo] set FichierLocCGHOligo "[RepertoireDuGenome]/$RepFichierLocCGHOligo/CGH_Oligo_localisation" #if {![file exists $FichierCourbeBAC] || ![file exists $FichierCourbeOligo] || ![file exists $FichierLocCGHBAC] || ![file exists $FichierLocCGHOligo]} {Espionne "Sorry, one file is missing";return} # attention il doit exister le rep PRIMA_Affichage dans le rep de mon prog.tcl set FichierLocGenes "[RepertoireDuGenome]/PRIMA_Affichage/HumanAllGenesUCSC" if {![file exists $FichierLocGenes] || $FichierLocGenes == ""} {return} #set FichierLocmiRNA "[RepertoireDuGenome]/PRIMA_Affichage/HumanmiRNAloc" #if {![file exists $FichierLocmiRNA] || $FichierLocmiRNA == ""} {return ""} #set FichierLocRefSeq "[RepertoireDuGenome]/PRIMA_Affichage/RefSeqLocalisation_ucsc" #if {![file exists $FichierLocRefSeq] || $FichierLocRefSeq == ""} {return ""} #ChargeFichierLoc TabM $FichierLocmiRNA $Chromosome $LesNoms # Modif MG if {$BACfile!=0} { ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms } ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms #Espionne "[array names TabB]" #ChargeFichierLoc TabR $FichierLocRefSeq $Chromosome $LesNoms ChargeFichierLoc TabG $FichierLocGenes $Chromosome $LesNoms # Mofid MG if {$BACfile!=0} { ChargeFichierCourbeCGH TabC $FichierCourbeBAC $Chromosome $LesPos } ChargeFichierCourbeCGH TabL $FichierCourbeOligo $Chromosome $LesPos set nChromosome [NumeroDuChromosome $Chromosome] #Voir proc CreeFichierCytologicMapUCSC set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 if {$BACfile!=0} { set HauteurMax [expr $BordY + $HauteurBoiteChromo + 6*$HauteurBoite + 7*$EcartEntreRepresentations] } else { set HauteurMax [expr $BordY + $HauteurBoiteChromo + 3*$HauteurBoite + 4*$EcartEntreRepresentations] } if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] #$K configure -background "lightgrey" $K configure -background "white" set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] set Taille [expr round($TailleChromo * 1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set i 0 set PosIni 0 ### Mapper le chromosome et ses bandes cytologiques ### foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" ################## Tracer le plot by position for 1 given patient ### BAC ### # Mofif MG if {$BACfile!=0} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set VMax [LaValeurMaxCGHBAC $FichierCourbeBAC $Chromosome] #vmax formate set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMin [LaValeurMinCGHBAC $FichierCourbeBAC $Chromosome] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set X1 0;set Y1 0 if {[info exists TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,LesPos)] { foreach LInfo [set TabC($FichierCourbeBAC,Chromosome,$Chromosome,$Pos)] { set PosMid [lindex $LInfo 1] set Val [lindex $LInfo 2] #val transformee set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere #($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro) # Ne pas oublier de prevoir le cas ou aucun point dans le centromere #($X1<$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro)||($X1>=$DebutCentro && $X1<=$FinCentro && $PosMid>=$FinCentro) || ($X1>=$DebutCentro && $X1<=$FinCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro) #if {$X1>=43200000 && $X1<=48000000} {Espionne "0- je suis la - x1=$X1 x2=$PosMid debcentro=$DebutCentro fincentro=$FinCentro"} if {$X1<=$DebutCentro && $PosMid>=$DebutCentro && $PosMid<=$FinCentro} { # x1 est avant le debut du centro et x2 dedans set X1 $PosMid set Y1 $Value continue } if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { # aucun point dans le centromere set X1 $PosMid set Y1 $Value } if {($X1>=$DebutCentro && $X1<=$FinCentro) && ($PosMid>=$DebutCentro && $PosMid<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } if {$X1<=$FinCentro && $PosMid>=$FinCentro && $X1>=$DebutCentro} { # x1 est avant la fin du centro et x2 apres le centromere set X1 $PosMid set Y1 $Value } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 3 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierBAC CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } ### Tracer le plot by position for 1 given patient ### Oligo ### set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] #set x [InterrogeFichierCourbeCGH $FichierCourbeOligo "unset"] #set VMin [InterrogeFichierCourbeCGH $FichierCourbeOligo VMin] #set VMax [InterrogeFichierCourbeCGH $FichierCourbeOligo VMax] set VMax [LaValeurMaxCGHOligo $FichierCourbeOligo $Chromosome] set VMin [LaValeurMinCGHOligo $FichierCourbeOligo $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] ### set X1 0;set Y1 0 if {[info exists TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,LesPos)] { set PosMid $Pos foreach LInfo [set TabL($FichierCourbeOligo,Chromosome,$Chromosome,$Pos)] { set Val [lindex $LInfo 3] set Val [expr ($Val*log(10)/log(2))*1.0] #val transformee pour l'affichage set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGHOligo" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # Interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { set X1 $PosMid set Y1 $Value continue } if {($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro)} { set X1 $PosMid set Y1 $Value continue } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 3 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] #set AfficheVMin -0 set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierOligo CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } ### Tracer le plot Affy by position for 1 given patient # RMA value ### U133 Plus2.0 ### #set FichierCourbeAffy [ChoixDuFichierRMA] if {![info exists TabRMA]} { if {[OuiOuNon "Do you have the corresponding RMA file?"]} { FaireLire "Please, Choose your Affymetrix file. Thank you!" set FichierCourbeAffy [tk_getOpenFile -title "Affymetrix (RMA) file to open"] Espionne "fichieraffy: $FichierCourbeAffy" set NomFichierAffy [file tail $FichierCourbeAffy] ChargeFichierAffyRMA TabRMA $FichierCourbeAffy } } if {[info exists TabRMA]} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set VMax [InterrogeFichierAffyRMA $FichierCourbeAffy ValMax] set VMax [format "%.2f" [expr $VMax*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/$VMax] set VMin [InterrogeFichierAffyRMA $FichierCourbeAffy ValMin] set VMin [format "%.2f" [expr $VMin*1.0]] set X1 0;set Y1 0 regsub "HS" $Chromosome "" num if {[regexp "^0" $num]} {regsub "0" $num "" num} set Chrom "chr$num" set LesProbeSets [InterrogeAffy_UCSC "" human $Chrom LesProbeSets] foreach ProbeSet $LesProbeSets { set LesChros [InterrogeAffy_UCSC "" human $ProbeSet Chromosome] ## cas ou pls chros if {[llength $LesChros]>1} { set Warning($ProbeSet) 1 regsub " " $LesChros "" LesChros set C($ProbeSet) $LesChros } set LesDebuts [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Debut] set LesFins [InterrogeAffy_UCSC "" human $ProbeSet $Chrom Fin] #si [llength $LesDebuts]>1 || [llength $LesFins]>1 set Warning($ProbeSet) 1 if {[llength $LesDebuts]!=[llength $LesFins]} {Espionne "pb loc de $ProbeSet"; continue} foreach Debut $LesDebuts Fin $LesFins { set PosMid [expr ($Fin-$Debut)/2 + $Debut] lappend L "$ProbeSet\t$PosMid" } #set Deb [lrange $LesDebuts 0 0] #set Fin [lrange $LesFins 0 0] #set PosMid [expr ($Fin-$Deb)/2 + $Deb] #lappend L "$ProbeSet\t$PosMid" } set Ltriee [lsort -integer -increasing -index 1 $L] if {$Ltriee!=""} { foreach Elt $Ltriee { set LesInfos [split $Elt "\t"] set PosMid [lindex $LesInfos 1] set ProbeSet [lindex $LesInfos 0] set Val [InterrogeFichierAffyRMA $FichierCourbeAffy $ProbeSet Val] set Value -[format "%.2f" [expr $Val*1.0]] lappend LesInfos $Val if {[info exists Warning($ProbeSet)]} { set ColorFill "Red" lappend LesInfos "$C($ProbeSet)" } else { set ColorFill "Mediumblue" } set LInfoAffy [join $LesInfos "\t"] lappend LInfoAffy "Affy" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # Interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { set X1 $PosMid set Y1 $Value continue } if {($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro)} { set X1 $PosMid set Y1 $Value continue } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 4 -tags $LInfoAffy $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill "Mediumblue" -width 1 #$K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 1 set X1 $PosMid set Y1 $Value } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr $VMax*1.0]] set AfficheVMin -[format "%.2f" [expr $VMin*1.0]] #ligne repere a 2 en pointille #$K create line $BordX [expr $PosYMin + (-2* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-2* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMax" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMin" -font "$Police" -fill "Mediumblue" #echelle horizontale #$K create text [expr $LargeurMax - $BordX+10] [expr $PosYMin + (-2* $FacteurY) + $Var] -text "2" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierAffy Affy U133 Plus2.0 plot" -font "$PoliceTitre" -fill "Mediumblue" } } ########## Mapper nos sequences: les BAC et les oligos de CGH + les miRNAs + RefSeq ############ # Localisation des miRNAs #set PosYMax [expr $PosYMin - $EcartEntreRepresentations] #set PosYMin [expr $PosYMax - $HauteurBoite] #set PosYCenter [expr ($PosYMax + $PosYMin)/2] #if {[info exists TabM($FichierLocmiRNA,Chromosome,$Chromosome,LesNoms)]} { #foreach Nom [set TabM($FichierLocmiRNA,Chromosome,$Chromosome,LesNoms)] { #foreach LInfo [set TabM($FichierLocmiRNA,Chromosome,$Chromosome,$Nom)] { #set Debut [lindex $LInfo 1] #set Fin [lindex $LInfo 2] #lappend LInfo "Box" #set ColorFill "Red" #set PosXMin [expr $BordX + ($Debut*$Facteur)] #set PosXMax [expr $BordX + ($Fin*$Facteur)] #set Var -10 #$K create oval $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo #} #} #} #$K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #$K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "Red" #$K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "Red" #$K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "Homo sapiens miRNAs" -font "$PoliceTitre" -fill "Red" # Localisation des CGH BAC # Modif MG if {$BACfile!=0} { # les BACs "fous" if {$FichierBACfou!=""} { foreach Ligne [LesLignesDuFichier $FichierBACfou] { set LesElts [split $Ligne " "] set sample [lindex $LesElts 0] set chromosome [lindex $LesElts 1] set posmid [lindex $LesElts 3] if {$sample==$NomFichierBAC && $chromosome==$Chromosome} { set posmid [expr $posmid*1.0] set Vu($posmid) 1 } } } set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] { set DebutBAC [lindex $LInfo 1] set FinBAC [lindex $LInfo 2] set PosMidBAC [expr $DebutBAC*1.0 + (($FinBAC*1.0-$DebutBAC*1.0)/2)] if {[info exists Vu($PosMidBAC)]} { set ColorFill "blue" } else { set ColorFill "darkorange" } lappend LInfo "BAC" #set ColorFill "yellow" if {($DebutBAC>=$DebutCentro && $DebutBAC<=$FinCentro) && ($FinBAC>=$DebutCentro && $FinBAC<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } set Var -10 set PosXMin [expr $BordX + ($DebutBAC*$Facteur)] set PosXMax [expr $BordX + ($FinBAC*$Facteur)] $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline "$ColorFill" -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #$K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "yellow" $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkorange" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkorange" #$K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "yellow" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH BAC" -font "$PoliceTitre" -fill "darkorange" #$K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH BAC" -font "$PoliceTitre" -fill "yellow" } } # Localisation des CGH Oligo set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] { set DebutOli [lindex $LInfo 1] set FinOli [lindex $LInfo 2] #set Id [lindex $LInfo 3] #set Fold [set Expression($Nom)] #lappend LInfo $Fold lappend LInfo "Oli" #set ColorFill [CouleurDuFold $Fold] set ColorFill "darkgreen" set PosXMin [expr $BordX + ($DebutOli*$Facteur)] set PosXMax [expr $BordX + ($FinOli*$Facteur)] #if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} set Var -10 #if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkgreen" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkgreen" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH Oligo" -font "$PoliceTitre" -fill "darkgreen" } # Localisation des RefSeq UCSC #set PosYMax [expr $PosYMin - $EcartEntreRepresentations] #set PosYMin [expr $PosYMax - $HauteurBoite] #set PosXCenter [expr $LargeurMax/2] #set PosYCenter [expr ($PosYMax + $PosYMin)/2] #if {[info exists TabR($FichierLocRefSeq,Chromosome,$Chromosome,LesNoms)]} { #foreach Nom [set TabR($FichierLocRefSeq,Chromosome,$Chromosome,LesNoms)] { #foreach LInfo [set TabR($FichierLocRefSeq,Chromosome,$Chromosome,$Nom)] { #set DebutRef [lindex $LInfo 1] #set FinRef [lindex $LInfo 2] #set Id [lindex $LInfo 3] #set Fold [set Expression($Nom)] #lappend LInfo $Fold #lappend LInfo "Ref" #set ColorFill [CouleurDuFold $Fold] #set ColorFill "darkorange" #set PosXMin [expr $BordX + ($DebutRef*$Facteur)] #set PosXMax [expr $BordX + ($FinRef*$Facteur)] #if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} #set Var -10 #if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} #$K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo #} #} #$K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #$K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkorange" #$K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkorange" #$K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "RefSeq UCSC sept.2005" -font "$PoliceTitre" -fill "darkorange" #} # Localisation des Human genes UCSC set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabG($FichierLocGenes,Chromosome,$Chromosome,$Nom)] { #Espionne coucou set DebutGene [lindex $LInfo 1] set FinGene [lindex $LInfo 2] #set Id [lindex $LInfo 3] #set Fold [set Expression($Nom)] #lappend LInfo $Fold lappend LInfo "Gene" #set ColorFill [CouleurDuFold $Fold] #set ColorFill "purple" set ColorFill "darkorange" set PosXMin [expr $BordX + ($DebutGene*$Facteur)] set PosXMax [expr $BordX + ($FinGene*$Facteur)] #if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} set Var -10 #if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkorange" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkorange" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "All Human genes UCSC" -font "$PoliceTitre" -fill "darkorange" } ################ Fin localisation CGH BAC Oligo et miRNAs et RefSeq et genes ########################## LesNomsEnStock $K $LesNoms #$K bind "Contig" "DevoileLesContigs $K %x %y Enter" #$K bind "Contig" "DevoileLesContigs $K %x %y Leave" #$K bind "Box" "DevoileLesBoites $K %x %y Enter" #$K bind "Box" "DevoileLesBoites $K %x %y Leave" $K bind "Affy" "DevoileLePlotAffy $K %x %y Enter" $K bind "Affy" "DevoileLePlotAffy $K %x %y Leave" $K bind "Affy" <1> "AfficheLePlotAffy $K" $K bind "CGHOligo" "DevoileLePlot $K %x %y Enter" $K bind "CGHOligo" "DevoileLePlot $K %x %y Leave" $K bind "CGHOligo" <1> "AfficheLePlot $K" $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "CGH" <1> "AfficheLePlot $K" #$K bind "Ref" "DevoileLesRefSeq $K %x %y Enter" #$K bind "Ref" "DevoileLesRefSeq $K %x %y Leave" $K bind "Gene" "DevoileLesGenes $K %x %y Enter" $K bind "Gene" "DevoileLesGenes $K %x %y Leave" $K bind "Gene" <1> "AfficheLesGenes $K" $K bind "Oli" "DevoileLesOligo $K %x %y Enter" $K bind "Oli" "DevoileLesOligo $K %x %y Leave" $K bind "Oli" <1> "AfficheLesOligo $K" $K bind "BAC" "DevoileLesBAC $K %x %y Enter" $K bind "BAC" "DevoileLesBAC $K %x %y Leave" $K bind "BAC" <1> "AfficheLesBAC $K" $K bind "Box" "DevoileLesmiRNAs $K %x %y Enter" $K bind "Box" "DevoileLesmiRNAs $K %x %y Leave" $K bind "Box" <1> "AfficheLesmiRNAs $K" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" #$K bind "BandesCytologiques" <1> "AfficheRequeteSurLaMeilleureLocalisation $K $FichierLocalisation $Qui \[LesNomsEnStock $K\]" #$K bind "Box" <1> "AfficheFicheInfo $K" regsub {\.canvas} $K "" w #set B [BoutonneLaFenetre $w "WithMapViewer/WithoutMapViewer\nOnlyBestLoc/All"] #bind $B <1> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithMapViewer" #bind $B <2> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithoutMapViewer" #bind $B "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] $WithoutOrWithMapViewer" #bind $B "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] $WithoutOrWithMapViewer" #set C [BoutonneLaFenetre $w "Histogramm"] #bind $C <1> "ChoixHistogramme" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" FaireLaSuiteAnnaick .fenetre return $K } proc ac_IllustreUnChromosomeAvtEtApresSeg {{Chromosome ""} {FichierCourbeCGH ""} {FichierCourbeSEG ""} {LesPos ""} {LesNoms ""}} { #choix du cas if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]} if {$FichierCourbeCGH==""} {set FichierCourbeCGH [ChoixDuFichierCourbeCGH]} if {$FichierCourbeSEG==""} {set FichierCourbeSEG [ChoixDuFichierCourbeSEG]} #chro posmid val if {![file exists $FichierCourbeCGH] || $FichierCourbeCGH == ""} {return ""} if {![file exists $FichierCourbeSEG] || $FichierCourbeSEG == ""} {return ""} set NomFichierCGH [file tail $FichierCourbeCGH] set NomFichierSEG [file tail $FichierCourbeSEG] ChargeFichierCourbeCGH TabC $FichierCourbeCGH $Chromosome $LesPos ChargeFichierSEG TabL $FichierCourbeSEG $Chromosome $LesPos set nChromosome [NumeroDuChromosome $Chromosome] #Voir proc CreeFichierCytologicMapUCSC set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 #set HauteurMax [expr $BordY + $HauteurBoiteChromo + 4*$HauteurBoite + 3*$EcartEntreRepresentations] # modif MG: Ajout des oligo et des genes set HauteurMax [expr $BordY + $HauteurBoiteChromo + 6*$HauteurBoite + 5*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] set Taille [expr round($TailleChromo * 1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set i 0 set PosIni 0 ### Mapper le chromosome et ses bandes cytologiques ### foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" ################## Tracer le plot by position for 1 given patient ### CGH ### set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set x [InterrogeFichierCourbeCGH $FichierCourbeCGH "unset"] if {[regexp "Oligo" $NomFichierCGH]|| [regexp "CL" $NomFichierCGH]} { set VMax [LaValeurMaxCGHOligo $FichierCourbeCGH $Chromosome] #vmax formate set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMin [LaValeurMinCGHOligo $FichierCourbeCGH $Chromosome] set VMinf [format "%.2f" [expr $VMin*1.0]] set VuOligo 1 } else { set VMax [LaValeurMaxCGHBAC $FichierCourbeCGH $Chromosome] #vmax formate set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMin [LaValeurMinCGHBAC $FichierCourbeCGH $Chromosome] set VMinf [format "%.2f" [expr $VMin*1.0]] set VuBAC 1 } set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] set X1 0;set Y1 0 if {[info exists TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,LesPos)] { set PosMid $Pos foreach LInfo [set TabC($FichierCourbeCGH,Chromosome,$Chromosome,$Pos)] { if {[regexp "Oligo" $NomFichierCGH] || [regexp "CL" $NomFichierCGH]} { set Val [lindex $LInfo 3] set Val [expr ($Val*log(10)/log(2))*1.0] } else { set Val [lindex $LInfo 2] } set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { set X1 $PosMid set Y1 $Value continue } if {($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro)} { set X1 $PosMid set Y1 $Value continue } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 3 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierCGH CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } ### Tracer le plot by position for 1 given patient ### SEG ### set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set VMin [LaValeurMinCGHSeg $FichierCourbeSEG $Chromosome] set VMax [LaValeurMaxCGHSeg $FichierCourbeSEG $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] ### set X1 0;set Y1 0 if {[info exists TabL($FichierCourbeSEG,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabL($FichierCourbeSEG,Chromosome,$Chromosome,LesPos)] { #set PosMid $Pos foreach LInfo [set TabL($FichierCourbeSEG,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] #FaireLire "$FichierCourbeSEG $Chromosome $PosMid $Val" set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierSEG CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } ################ Fin plots ########################## set FichierLocCGHOligo "[RepertoireDuGenome]/PRIMA_CGH/CGH_Oligo_localisation" set FichierLocCGHBAC "[RepertoireDuGenome]/PRIMA_CGH/CGH_BAC_localisation" # Localisation des CGH BAC if {[info exists VuBAC]} { ChargeFichierLoc TabB $FichierLocCGHBAC $Chromosome $LesNoms set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabB($FichierLocCGHBAC,Chromosome,$Chromosome,$Nom)] { set DebutBAC [lindex $LInfo 1] set FinBAC [lindex $LInfo 2] set PosMidBAC [expr $DebutBAC*1.0 + (($FinBAC*1.0-$DebutBAC*1.0)/2)] if {[info exists Vu($PosMidBAC)]} { set ColorFill "blue" } else { set ColorFill "darkorange" } lappend LInfo "BAC" #set ColorFill "yellow" if {($DebutBAC>=$DebutCentro && $DebutBAC<=$FinCentro) && ($FinBAC>=$DebutCentro && $FinBAC<=$FinCentro)} { # x1 et x2 sont dans le centromere set X1 $PosMid set Y1 $Value continue } set Var -10 set PosXMin [expr $BordX + ($DebutBAC*$Facteur)] set PosXMax [expr $BordX + ($FinBAC*$Facteur)] $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline "$ColorFill" -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #$K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "yellow" $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkorange" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkorange" #$K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "yellow" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH BAC" -font "$PoliceTitre" -fill "darkorange" #$K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH BAC" -font "$PoliceTitre" -fill "yellow" } } # Localisation des CGH Oligo if {[info exists VuOligo]} { ChargeFichierLoc TabO $FichierLocCGHOligo $Chromosome $LesNoms set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabO($FichierLocCGHOligo,Chromosome,$Chromosome,$Nom)] { set DebutOli [lindex $LInfo 1] set FinOli [lindex $LInfo 2] #set Id [lindex $LInfo 3] #set Fold [set Expression($Nom)] #lappend LInfo $Fold lappend LInfo "Oli" #set ColorFill [CouleurDuFold $Fold] set ColorFill "darkgreen" set PosXMin [expr $BordX + ($DebutOli*$Facteur)] set PosXMax [expr $BordX + ($FinOli*$Facteur)] #if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} set Var -10 #if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkgreen" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkgreen" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "CGH Oligo" -font "$PoliceTitre" -fill "darkgreen" } } # Localisation des Human genes UCSC set FichierLocGenes "[RepertoireDuGenome]/PRIMA_Affichage/HumanAllGenesUCSC" ChargeFichierLoc TabG $FichierLocGenes $Chromosome $LesNoms set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] if {[info exists TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)]} { foreach Nom [set TabG($FichierLocGenes,Chromosome,$Chromosome,LesNoms)] { foreach LInfo [set TabG($FichierLocGenes,Chromosome,$Chromosome,$Nom)] { #Espionne coucou set DebutGene [lindex $LInfo 1] set FinGene [lindex $LInfo 2] #set Id [lindex $LInfo 3] #set Fold [set Expression($Nom)] #lappend LInfo $Fold lappend LInfo "Gene" #set ColorFill [CouleurDuFold $Fold] #set ColorFill "purple" set ColorFill "darkorange" set PosXMin [expr $BordX + ($DebutGene*$Facteur)] set PosXMax [expr $BordX + ($FinGene*$Facteur)] #if {$Sens == "+"} {set Var -10} elseif {$Sens == "-"} {set Var 10} set Var -10 #if {$Qui != "OnlyTheBest" && $Info != "BestLoc"} {set Var [expr $Var * 3]} $K create rectangle $PosXMin [expr $PosYMin + $Var] $PosXMax [expr $PosYMax + $Var] -outline $ColorFill -fill $ColorFill -tags $LInfo } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "darkorange" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "darkorange" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations/2] -text "All Human genes UCSC" -font "$PoliceTitre" -fill "darkorange" } ################ Fin localisation des boites et des genes ########################## LesNomsEnStock $K $LesNoms $K bind "CGHSEG" "DevoileLePlot $K %x %y Enter" $K bind "CGHSEG" "DevoileLePlot $K %x %y Leave" $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Gene" "DevoileLesGenes $K %x %y Enter" $K bind "Gene" "DevoileLesGenes $K %x %y Leave" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc ac_IllustreUnChromosomeCGH {{Chromosome ""} {LesCas ""} {LesPos ""} {LesNoms ""}} { Espionne "ac_IllustreUnChromosomeCGH $Chromosome $LesCas , en cours" if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]} set nChromosome [NumeroDuChromosome $Chromosome] set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoiteChromo + [expr [llength $LesCas]-1] *$HauteurBoite + [expr [llength $LesCas]+1]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] set Taille [expr round($TailleChromo * 1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set PosIni 0 set i 0 ### Mapper le chromosome et ses bandes cytologiques ### foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" ### Tracer les plot BAC ### # pour chaque cas foreach Cas $LesCas { Espionne $Cas set FichierCourbe $Cas if {![file exists $FichierCourbe]} {Espionne "$FichierCourbe does not exist"; return} set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set NomFichier [file tail $FichierCourbe] if {[regexp "BAC" $Cas]} {set TypeCGH "BAC"} if {[regexp "Oligo" $Cas]} {set TypeCGH "Oligo"} if {[regexp "CL" $Cas]} {set TypeCGH "CL"} if {$TypeCGH=="Oligo" || $TypeCGH=="CL"} { # meta: min 817 max 819 #set VMax 2.97 #set VMin -2.48 # HR: min 823 max 823 set VMax 2.61 set VMin -2.49 } else { #set VMax [LaValeurMaxCGHBAC $FichierCourbe $Chromosome] #set VMin [LaValeurMinCGHBAC $FichierCourbe $Chromosome] # meta: min 806 max 819 #set VMax 2.20 #set VMin -1.05 # HR: min 821 max 823 set VMax 1.31 set VMin -1.01 } set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] if {[info exists TabC]} {unset TabC} ChargeFichierCourbeCGH TabC $FichierCourbe $Chromosome $LesPos set X1 0;set Y1 0 if {[info exists TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbe,Chromosome,$Chromosome,LesPos)] { set PosMid $Pos foreach LInfo [set TabC($FichierCourbe,Chromosome,$Chromosome,$Pos)] { if {$TypeCGH=="BAC"} { set Val [lindex $LInfo 2] lappend LInfo "CGH" } else { set Val [lindex $LInfo 3] set Val [expr ($Val*log(10)/log(2))*1.0] lappend LInfo "CGHOligo" } set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] set ColorFill "Mediumblue" set Var -10 if {$X1==0 && $Y1==0} { set X1 $PosMid set Y1 $Value continue } # interrompre la courbe quand centromere if {$X1<=$DebutCentro && $PosMid>=$FinCentro} { set X1 $PosMid set Y1 $Value continue } if {($X1>$DebutCentro && $X1<$FinCentro)||($PosMid>$DebutCentro && $PosMid<$FinCentro)} { set X1 $PosMid set Y1 $Value continue } set PosX1 [expr $BordX + ($X1*$Facteur)] set PosY1 [expr $PosYMin + ($Y1*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosMid*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 3 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 set X1 $PosMid set Y1 $Value } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 0 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" #echelle horizontale $K create text [expr $BordX-10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichier CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } ################ Fin Courbes ########################## LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "CGH" <1> "AfficheLePlot $K" $K bind "CGHOligo" "DevoileLePlot $K %x %y Enter" $K bind "CGHOligo" "DevoileLePlot $K %x %y Leave" $K bind "CGHOligo" <1> "AfficheLePlot $K" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc ac_IllustreUnChromosomeCGH_seg {{Chromosome ""} {LesCas ""} {LesPos ""} {LesNoms ""}} { Espionne "ac_IllustreUnChromosomeCGH_seg $Chromosome $LesCas , en cours" if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]} set nChromosome [NumeroDuChromosome $Chromosome] set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoiteChromo + [expr [llength $LesCas]-1] *$HauteurBoite + [expr [llength $LesCas]+1]*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] set Taille [expr round($TailleChromo * 1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set PosIni 0 set i 0 ### Mapper le chromosome et ses bandes cytologiques ### foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" ## BAC ou oligo? foreach cas $LesCas { if {[regexp -nocase "BAC" $cas]} {set Type "BAC";break} else {set Type "Oligo";break} } Espionne "type :$Type" ### Tracer les plot ### ### BAC # pour chaque cas Espionne "liste: $LesCas" if {$Type=="BAC"} { foreach Cas $LesCas { Espionne $Cas set FichierCourbeBACSeg $Cas set NomFichierBACSeg [file tail $FichierCourbeBACSeg] ChargeFichierSEG TabC $FichierCourbeBACSeg $Chromosome $LesPos set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] # chro8 meta: min 806 max 819 #set VMin -0.70 #set VMax 1.84 # chro8 hr: min 821 max 815 set VMin -0.54 set VMax 0.96 set VMaxf $VMax set VMinf $VMin if {$VMaxf==0.00 || $VMinf==0.00} { set FacteurY [expr ($EcartEntreRepresentations/2)/1.50] } else { set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] } ### set X1 0;set Y1 0 if {[info exists TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)] { #set PosMid $Pos foreach LInfo [set TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min if {$VMax!=0.00 && $VMin!=0.00} { $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 if {$VMin==$VMax} { $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "$VMaxf" -font "$Police" -fill "Mediumblue" } else { #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" } } #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierBACSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } } else { foreach Cas $LesCas { Espionne $Cas set FichierCourbeOligoSeg $Cas set NomFichierOligoSeg [file tail $FichierCourbeOligoSeg] ChargeFichierSEG TabL $FichierCourbeOligoSeg $Chromosome $LesPos set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] # meta: min 819 max 819 #set VMin -0.94 #set VMax 2.13 # hr: min 823 max 823 set VMin -1.49 set VMax 1.85 set VMaxf $VMax set VMinf $VMin if {$VMaxf==0.00 || $VMinf==0.00} { set FacteurY [expr ($EcartEntreRepresentations/2)/1.50] } else { set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] } ### set X1 0;set Y1 0 if {[info exists TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)] { #set PosMid $Pos foreach LInfo [set TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min if {$VMax!=0.00 && $VMin!=0.00} { $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 if {$VMin==$VMax} { $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "$VMaxf" -font "$Police" -fill "Mediumblue" } else { #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" } } #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierOligoSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } } ################ Fin Courbes ########################## LesNomsEnStock $K $LesNoms $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "CGH" <1> "AfficheLePlot $K" $K bind "CGHOligo" "DevoileLePlot $K %x %y Enter" $K bind "CGHOligo" "DevoileLePlot $K %x %y Leave" $K bind "CGHOligo" <1> "AfficheLePlot $K" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc ac_IllustreUnChromosome_SEG {{Chromosome ""} {FichierCourbeBACSeg ""} {FichierCourbeOligoSeg ""} {LesPos ""} {LesNoms ""}} { #choix du cas if {$Chromosome==""} {set Chromosome [ChoixDuChromosome]} #chro posmid val #modif MG if {(![file exists $FichierCourbeBACSeg] || $FichierCourbeBACSeg == "") && (![file exists $FichierCourbeOligoSeg] || $FichierCourbeOligoSeg == "")} {return ""} if {[file exists $FichierCourbeBACSeg]} { set NomFichierBACSeg [file tail $FichierCourbeBACSeg] ChargeFichierSEG TabC $FichierCourbeBACSeg $Chromosome $LesPos } if {[file exists $FichierCourbeOligoSeg]} { set NomFichierOligoSeg [file tail $FichierCourbeOligoSeg] ChargeFichierSEG TabL $FichierCourbeOligoSeg $Chromosome $LesPos } set nChromosome [NumeroDuChromosome $Chromosome] #Voir proc CreeFichierCytologicMapUCSC set FichierBandesCytos "[RepertoireDuGenome]/PRIMA_Affichage/CytologicMap" if {![file exists $FichierBandesCytos]} { Espionne "$FichierBandesCytos does not exist" return "" } set FichierPosCentro "[RepertoireDuGenome]/PRIMA_Affichage/PosCentromeres" set DebutCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome DebutCentro] set FinCentro [InterrogeFichierCentromere $FichierPosCentro $Chromosome FinCentro] set PolicePetite "Courier 8" set Police "Courier 8" set PoliceTitre "Courier 12 bold" set BordY 30.0 set BordX 75.0 set HauteurFenetre [expr [winfo screenwidth .] - 200] set LargeurMax [expr [winfo screenwidth .] - 100] set LargeurFenetre [expr [winfo screenwidth .] - 100 ] set LargeurAffichage [expr ($LargeurMax - 2*$BordX)*1.0] set HauteurBoiteChromo 30 set HauteurBoite 10 set EcartEntreRepresentations 100 set HauteurMax [expr $BordY + $HauteurBoiteChromo + 4*$HauteurBoite + 3*$EcartEntreRepresentations] if {$HauteurMax < $HauteurFenetre} {set HauteurFenetre $HauteurMax} set HauteurAffichage [expr ($HauteurMax - 2*$BordY)*1.0] set K [UnCanva $LargeurMax $HauteurMax $LargeurFenetre $HauteurFenetre] set FichierChros "[RepertoireDuGenome]/PRIMA_Affichage/chromInfo" set x [InterrogeFichierHumanChromos $FichierChros "unset"] set TailleChromo [InterrogeFichierHumanChromos $FichierChros $nChromosome Taille] set TailleChromo [expr $TailleChromo*1.0] set Taille [expr round($TailleChromo * 1.0/1.e6)] set Facteur [expr $LargeurAffichage / $TailleChromo] ChargeBandesCytologiques LesBandesCytos $FichierBandesCytos if {![info exist LesBandesCytos($Chromosome,TailleP)]} {return ""} set LesBandesP [lsort -decreasing [set LesBandesCytos($Chromosome,LesBandesP)]] set LesBandesQ [lsort [set LesBandesCytos($Chromosome,LesBandesQ)]] set LesBandesCytologiques $LesBandesP foreach BandeQ $LesBandesQ {lappend LesBandesCytologiques $BandeQ} set PosYMin [expr $HauteurMax - $BordY - $HauteurBoiteChromo] set PosYMax [expr $HauteurMax - $BordY ] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set PosXCenter [expr $LargeurMax/2] set PosXMin $BordX set i 0 set PosIni 0 ### Mapper le chromosome et ses bandes cytologiques ### foreach Bande $LesBandesCytologiques { set LesInfos [set LesBandesCytos($Chromosome,$Bande)] set Position [expr [lindex $LesInfos 0] * 1.e6] set TailleBande [expr round(($Position-$PosIni)/1.e6)] set Type [lindex $LesInfos 2] set ColorFill [CouleurDeLaBandeCytologique $Type] set PosXMax [expr $BordX + ($Position*$Facteur)] $K create rectangle $PosXMin $PosYMin $PosXMax $PosYMax -outline black -fill $ColorFill -tags [list "$Bande" "$TailleBande" "BandesCytologiques"] if {$i == 40} {set i 0} else {incr i 10} set PosXMin $PosXMax set PosIni $Position } $K create text [expr $BordX/2] $PosYCenter -text "0 Mpb" -font "$Police" -fill "blue" $K create text [expr $LargeurMax - $BordX/2] $PosYCenter -text "$Taille Mpb" -font "$Police" -fill "blue" $K create text $PosXCenter [expr $PosYMin - $EcartEntreRepresentations*1/3] -text "$Chromosome" -font "$PoliceTitre" -fill "blue" ################## chro display BAC ############################### # modif MG if {$FichierCourbeBACSeg!="" && [file exists $FichierCourbeBACSeg]} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set VMin [LaValeurMinCGHSeg $FichierCourbeBACSeg $Chromosome] set VMax [LaValeurMaxCGHSeg $FichierCourbeBACSeg $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] if {$VMaxf==0.00 || $VMinf==0.00} { set FacteurY [expr ($EcartEntreRepresentations/2)/1.50] } else { set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] } ### set X1 0;set Y1 0 if {[info exists TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,LesPos)] { #set PosMid $Pos foreach LInfo [set TabC($FichierCourbeBACSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] #FaireLire "$FichierCourbeSEG $Chromosome $PosMid $Val" set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -[format "%.2f" [expr ($VMin+abs($VMin))*1.0]] #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min if {$VMax!=0.00 && $VMin!=0.00} { $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 if {$VMin==$VMax} { $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "$VMaxf" -font "$Police" -fill "Mediumblue" } else { #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" } } #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierBACSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } ######################### chro display Oligo ####################### # Modif MG if {$FichierCourbeOligoSeg!="" && [file exists $FichierCourbeOligoSeg]} { set PosYMax [expr $PosYMin - $EcartEntreRepresentations] set PosYMin [expr $PosYMax - $HauteurBoite] set PosXCenter [expr $LargeurMax/2] set PosYCenter [expr ($PosYMax + $PosYMin)/2] set VMin [LaValeurMinCGHSeg $FichierCourbeOligoSeg $Chromosome] set VMax [LaValeurMaxCGHSeg $FichierCourbeOligoSeg $Chromosome] set VMaxf [format "%.2f" [expr $VMax*1.0]] set VMinf [format "%.2f" [expr $VMin*1.0]] if {$VMaxf==0.00 || $VMinf==0.00} { set FacteurY [expr ($EcartEntreRepresentations/2)/1.50] } else { set FacteurY [expr ($EcartEntreRepresentations/2)/($VMaxf+abs($VMinf))] } ### set X1 0;set Y1 0 if {[info exists TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)]} { foreach Pos [set TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,LesPos)] { #set PosMid $Pos foreach LInfo [set TabL($FichierCourbeOligoSeg,Chromosome,$Chromosome,$Pos)] { set PosInf [lindex $LInfo 3] set PosSup [lindex $LInfo 4] set Val [lindex $LInfo 6] #FaireLire "$FichierCourbeSEG $Chromosome $PosMid $Val" set Valt [expr abs($VMin)+$Val] set Value -[format "%.2f" [expr $Valt*1.0]] lappend LInfo "CGH" set ColorFill "Mediumblue" set Var -10 set PosX1 [expr $BordX + ($PosInf*$Facteur)] set PosY1 [expr $PosYMin + ($Value*$FacteurY) + $Var] set PosX2 [expr $BordX + ($PosSup*$Facteur)] set PosY2 [expr $PosYMin + ($Value*$FacteurY) + $Var] $K create oval $PosX2 $PosY2 $PosX2 $PosY2 -outline $ColorFill -fill $ColorFill -width 1 -tags $LInfo $K create line $PosX1 $PosY1 $PosX2 $PosY2 -fill $ColorFill -width 2 } } $K create line $BordX $PosYCenter [expr $LargeurMax-$BordX] $PosYCenter -fill black -width 2 #echelle set AfficheVMax -[format "%.2f" [expr ($VMax+abs($VMin))*1.0]] set AfficheVMin -0 #ligne repere a 2 en pointille $K create line $BordX [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] [expr $LargeurMax-$BordX] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -fill red -width 1 -dash {2 2} #lignes verticales $K create line $BordX $PosYCenter $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $LargeurMax-$BordX] $PosYCenter [expr $LargeurMax-$BordX] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 #petit trait repere max et min if {$VMax!=0.00 && $VMin!=0.00} { $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -fill black -width 2 $K create line [expr $BordX-10] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] $BordX [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -fill black -width 2 if {$VMin==$VMax} { $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "$VMaxf" -font "$Police" -fill "Mediumblue" } else { #val max $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMax * $FacteurY) + $Var] -text "max $VMaxf" -font "$Police" -fill "Mediumblue" #val min $K create text [expr $BordX/2] [expr $PosYMin + ($AfficheVMin * $FacteurY) + $Var] -text "min $VMinf" -font "$Police" -fill "Mediumblue" } } #echelle horizontale $K create text [expr $BordX -10] [expr $PosYMin + (-[expr abs($VMinf)]* $FacteurY) + $Var] -text "0" -font "$Police" -fill "Red" $K create text $PosXCenter [expr $PosYCenter + 10] -text "$NomFichierOligoSeg CGH plot" -font "$PoliceTitre" -fill "Mediumblue" } } ################ Fin localisation CGH CGH Oligo et SEG ########################## LesNomsEnStock $K $LesNoms $K bind "CGHSEG" "DevoileLePlot $K %x %y Enter" $K bind "CGHSEG" "DevoileLePlot $K %x %y Leave" $K bind "CGH" "DevoileLePlot $K %x %y Enter" $K bind "CGH" "DevoileLePlot $K %x %y Leave" $K bind "Gene" "DevoileLesGenes $K %x %y Enter" $K bind "Gene" "DevoileLesGenes $K %x %y Leave" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Enter" $K bind "BandesCytologiques" "DevoileLesBandesCytologiques $K %x %y Leave" #regsub {\.canvas} $K "" w #set B [BoutonneLaFenetre $w "WithMapViewer/WithoutMapViewer\nOnlyBestLoc/All"] #bind $B <1> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithMapViewer" #bind $B <2> "IllustreUnChromosome $Chromosome \[LesNomsEnStock $K\] WithoutMapViewer" #set C [BoutonneLaFenetre $w "Histogramm"] #bind $C <1> "ChoixHistogramme" bind $K "Viseur $K %x %y" bind $K "Viseur $K %x %y" return $K } proc ac_JumeauRepresentatif {Nom} { global JumeauRepresentatif if {[info exists JumeauRepresentatif($Nom)]} { return [set JumeauRepresentatif($Nom)] } if {[info exists JumeauRepresentatif("EstCharge")]} { return "" } set FichierDesJumeaux "[RepertoireDuGenome]/fiches/ClustersNew" if { $FichierDesJumeaux=={} || ! [file exists $FichierDesJumeaux]} {return ""} foreach Ligne [LesLignesDuFichier $FichierDesJumeaux] { set LesJumeaux [split $Ligne " "] set JR [lindex $LesJumeaux 0] lappend JumeauRepresentatif(LaListeMerci) $JR foreach J [lrange $LesJumeaux 0 end] { set JumeauRepresentatif($J) $JR } } set JumeauRepresentatif("EstCharge") 1 return [JumeauRepresentatif $Nom] } proc ac_LesProchesDansLeBlast {FichierBlast {DirDesJumeaux ""} {Identity ""} {PCoverQuery ""} {PCoverSubject ""} {FichierLog ""}} { Wup "Determine dans un fichier blast les BIds tres proches en fonction du IdGlobal puis du IdEtendu" ##ac set NomFichier [file tail $FichierBlast] #set DirDesJumeaux "[RepertoireDuGenome]/Jumeaux" if {![file exists $DirDesJumeaux]} {file mkdir $DirDesJumeaux} if {$Identity == ""} {set Identity 0.95} if {$PCoverQuery == ""} {set PCoverQuery 0.95} if {$PCoverSubject == ""} {set PCoverSubject 0.95} if {$FichierLog == ""} {set FichierLog "$DirDesJumeaux/TousLesJumeaux_${Identity}_${PCoverQuery}_${PCoverSubject}.log"} DepouilleLeBlast TabBlast $FichierBlast "1e-3" set NbSbjct [set TabBlast(NbSubject)] set TailleQuery [set TabBlast(Taille)] set NomQuery [set TabBlast(Query)] set LesProches "" #ac #if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} if {$NbSbjct=="0"} {return ""} AppendAuFichier $FichierLog "\nQuery: $NomFichier $NomQuery" #AppendAuFichier $FichierLog "\nQuery: $NomQuery" for {set i 1} {$i <=$NbSbjct} {incr i} { set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [set TabBlast($i)] set IdGlobal [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] if {$IdGlobal<=$Identity} {continue} #PCoverQuery Query par rapport a Subject set PRecouvrementQuery [PourcentageDeRecouvrement_TabBlast TabBlast $BId "Query"] #PCoverSubject Subject par rapport a Query set PRecouvrementSubject [PourcentageDeRecouvrement_TabBlast TabBlast $BId "Subject"] if {$PRecouvrementQuery <= $PCoverQuery || $PRecouvrementSubject <= $PCoverSubject} {continue} #set IdEtendu [PourcentageDesBasesAligneesSurToutesLesBasesAlignables_TabBlast TabBlast $BId] #set P2 [PourcentageDesRegionsAligneesSurToutesLesRegionsAlignables_TabBlast TabBlast $BId] lappend LesProches $BId AppendAuFichier $FichierLog ">>$BId IdGlobal $IdGlobal Cover S/Q $PRecouvrementQuery Cover Q/S $PRecouvrementSubject" } if {[info exists TabBlast]} {unset TabBlast} return $LesProches } proc ac_LesProchesDansLeBlastBis {FichierBlast {Identity ""} {PCoverQuery ""} {PCoverSubject ""}} { Wup "Determine dans un fichier blast les BIds tres proches en fonction du IdGlobal et des 2 covers: PCoverQuery et PCoverSubject" ##ac set NomFichier [file tail $FichierBlast] if {$Identity == ""} {set Identity 0.95} if {$PCoverQuery == ""} {set PCoverQuery 0.95} if {$PCoverSubject == ""} {set PCoverSubject 0.95} #### Seuil Expect DepouilleLeBlast TabBlast $FichierBlast "1e-3" set NbSbjct [set TabBlast(NbSubject)] set TailleQuery [set TabBlast(Taille)] set NomQuery [set TabBlast(Query)] set LesProches "" #ac #if {$NbSbjct=="0"} {Espionne "Petit probleme pas de hit";return ""} if {$NbSbjct=="0"} {return 0} set Proches 0 for {set i 1} {$i <=$NbSbjct} {incr i} { set IdGlobal 0 set PRecouvrementQuery 0 set PRecouvrementSubject 0 set BId [set TabBlast($i)] set IdGlobal [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] if {$IdGlobal<=$Identity} {continue} #PCoverQuery: Query par rapport a Subject set PRecouvrementQuery [PourcentageDeRecouvrement_TabBlast TabBlast $BId "Query"] #PCoverSubject: Subject par rapport a Query set PRecouvrementSubject [PourcentageDeRecouvrement_TabBlast TabBlast $BId "Subject"] if {$PRecouvrementQuery <= $PCoverQuery || $PRecouvrementSubject <= $PCoverSubject} {continue} set Proches 1 break #lappend LesProches $BId } if {[info exists TabBlast]} {unset TabBlast} #return $LesProches return $Proches } proc ac_LocalisationPourAnnaick {FichierDesPABs} { #from Frederic C. set RepEM "[RepertoireDuGenome]/nuctfa_exonicmap" if {![file exists $RepEM]} {file mkdir $RepEM} set RepLoc "[RepertoireDuGenome]/Localisation" if {![file exists $RepLoc]} {file mkdir $RepLoc} set FichierBoxLoc "$RepLoc/NuctfaLocalisation_Human" set LeTexte {} #set L [CreeListePourFichierAUneColonne $FichierDesPABs] #Espionne [llength $L] foreach Nom [ListeDesPABs] { InterrogeFichierExonicMap unset set FileTFA "[RepertoireDuGenome]/nucmask/$Nom" set FileBlast "[RepertoireDuGenome]/blastnhuman/$Nom" if {![file exists $FileTFA] || ![file exists $FileBlast]} {continue} Espionne $Nom set FileEM "$RepEM/$Nom" if {![file exists $FileEM]} { ExonicMapHuman $FileTFA $FileBlast $FileEM "SansBlast" 0.05 0.0 "Yes" 0.95 10 150 0.1 } if {![file exists $FileEM]} {continue} foreach Ligne [mRNAHsapLocalisation $Nom $FileEM] { lappend LeTexte $Ligne } } SauveLesLignes $LeTexte dans $FichierBoxLoc return } proc ac_LocalisationPourAnnaick_miRNAs {FichierDesmiRNAs} { # from Frederic C. # FichierDesmiRNAs=ANALYSE/miRNAs/LesM (colonne des noms) set RepEM "[RepertoireDuGenome]/miRNAtfa_exonicmap" if {![file exists $RepEM]} {file mkdir $RepEM} set RepLoc "[RepertoireDuGenome]/Localisation" if {![file exists $RepLoc]} {file mkdir $RepLoc} set FichierBoxLoc "$RepLoc/miRNAtfaLocalisation_Human" set LeTexte {} set L [CreeListePourFichierAUneColonne $FichierDesmiRNAs] #Espionne [llength $L] foreach Nom $L { InterrogeFichierExonicMap unset set FileTFA "[RepertoireDuGenome]/mirnatfa/$Nom" set FileBlast "[RepertoireDuGenome]/mirnatfa_blastnhuman/$Nom" if {![file exists $FileTFA] || ![file exists $FileBlast]} {continue} Espionne $Nom set FileEM "$RepEM/$Nom" if {![file exists $FileEM]} { ExonicMapHuman $FileTFA $FileBlast $FileEM "SansBlast" 0.05 0.0 "Yes" 0.95 10 150 0.1 } if {![file exists $FileEM]} {continue} foreach Ligne [mRNAHsapLocalisation $Nom $FileEM] { lappend LeTexte $Ligne } } SauveLesLignes $LeTexte dans $FichierBoxLoc return } proc acc2 {} { set La [LesLignesDuFichier /home/moumou/rrps/sel.acc] set o [open sel.acc2 w] puts $o [join $La " "] close $o exit } proc accelerateMenu {menu {topWin .} {modBase Control-Key} disableVarName} { set i 0 set UCharsList {} while { $i <= [$menu index end] } { set type [ $menu type $i ] if { $type == "separator" } {incr i; continue} if { $type == "cascade" } { accelerateMenu [$menu entrycget $i -menu] $topWin $modBase $disableVarName; incr i ;continue} ; # Recursively follow cascades set label [ $menu entrycget $i -label] set underLineIndex [ $menu entrycget $i -underline] if {$underLineIndex < 0 } { incr i ;continue } set char [string index $label $underLineIndex] if { [lsearch $UCharsList $char] >= 0 } { puts "skipping $label" incr i continue } bind $topWin <$modBase-$char> [format "if \{\$%s\} \{%s invoke %d\}" $disableVarName $menu $i ] $menu entryconfigure $i -accelerator <$modBase-$char> lappend UCharsList incr i } } proc addToXmlMac {Fichier} { ReadRawFeatureFile $Fichier SauveLAlignement XML JLeSauveAs } proc add_quats {q1 q2} { set t1 [lrange $q1 0 2] set t1 [vscale $t1 [lindex $q2 3]] set t2 [lrange $q2 0 2] set t2 [vscale $t2 [lindex $q1 3]] set t3 [Vectoriel [lrange $q2 0 2] [lrange $q1 0 2]] set tf [vadd $t1 $t2] set tf [vadd $t3 $tf] lappend tf [expr {[lindex $q1 3] * [lindex $q2 3] - [vdot $q1 $q2]}] set dest $tf if {[incr ::qCount] > 97} { set ::qCount 0 set dest [normalize_quat $dest] } return $dest } proc addtb {} { global db set tb " - results : resultat de test { . pk_results P . pk_tests I . cm T clustering method . gapthr R threshold pour gap . pos T positions list } " set db [FabriqueDeTables $tb "" bench.sql 1] DumpSqliteDB $db close exit } proc adrs {} { set Ll [LesLignesDuFichier tmpp] set lem [list] foreach l $Ll { set l [string map {";" " " "," " "} $l] set Lv [split $l " "] set res [lsearch -inline -glob -all $Lv "*@*"] if {$res eq ""} {continue} lappend Lem {*}[split $res " "] } set o [open "nogonz.dat" w] puts $o [join $Lem \n] close $o exit } proc affichageHitsWeb {FichierEntree {Type Subj}} { set Type [string tolower $Type] if {[regexp mid $Type]} { set var lignesMid } elseif {[regexp sub $Type]} { set var lignesSubject } else { throw 2 {Type must be "Mid" or "Subject"} } puts stderr "[clock seconds] Parsing" set d [grouperHitsParTaxid [parserFichierBlast $FichierEntree]] puts stderr "[clock seconds] Done" set res {

}
	puts stderr "[clock seconds] Making groups"
	dict for {taxid groupe} $d {
		append res "Groupe OX=$taxid\n"
		#puts "groupe isoformes pour OX=$taxid"
		if {$taxid eq "unknown"} {
			set tmpGroupes [list $groupe]
		} else {
			set tmpGroupes [grouperIsoformesScore $groupe estIsoformeFenetre $Type]
		}
		# affichage
		foreach g $tmpGroupes {
			set g [triHitsParNbTirets $g $Type]
			set class ""
			if {[llength $g] > 1} {
				set class "ref"
			}
			foreach h $g {
				append res ""
				set shortid [$h getShortid]
				for {set i 0} {$i<[$h getNbBlocks]} {incr i} {
					append res "[format {%-20s} $shortid][string repeat " " [$h getOffset $i]][$h enleverTirets $Type $i]\n"
					set shortid "    |"
				}
				append res ""
				set class "iso"
			}
		}
	}
	puts stderr "[clock seconds] Done"
	append res {

} return $res } proc ale {} { for {set i 0} {$i < 1000000} {incr i} { set nv [expr {int(rand()*18)+2}] set Lv [list] for {set j 0} {$j < $nv} {incr j} { lappend Lv [expr {int(rand()*100)}] } set tot [::tcl::mathop::+ {*}$Lv] if {$tot == 0} {continue} set nb [expr {int(rand()*100)+1}] puts "" puts "nb = $nb" set s "" foreach v $Lv { append s [format %6d $v] } puts "$s" tvn $nb $Lv } exit } proc alignSequencesToConsensus {aContig} { upvar $aContig contig # Calculate and set the consensus left offset if {$contig(lowestRelativeConsensusPosition) < 1} { set consensusOffset [expr abs($contig(lowestRelativeConsensusPosition))+1] } else { set consensusOffset 0 } # Add gaps before the consensus sequence if needed if {$consensusOffset != 0} { set contig(consensus) "[string repeat "." $consensusOffset]$contig(consensus)" } # Let's do the same for each reads foreach readIdx $contig(index) { set contig($readIdx,sequence) "[string repeat "." [expr $consensusOffset - 1 + $contig($readIdx,consensusPosition)]]$contig($readIdx,sequence)" } } proc alignmentToSequenceIndex {alignedSequence} { array set index {} for {set i 0; set counter 0; set length [string length $alignedSequence]} {$i < $length} {incr i} { if {[regexp -nocase {[a-z]} [string index $alignedSequence $i]]} { incr counter set index([expr $i + 1]) $counter } } return [array get index] } proc anaa {} { package require sqlite3 sqlite3 d res.sql set Lf0 [d eval {select distinct nom from file as f, ln_file_block as lfb, ln_block_segment as lbs, segment as s where s.motiflen = 13 and s.rank = 0.0 and s.pk_segment = lbs.pk_segment and lbs.pk_block = lfb.pk_block and lfb.pk_file = f.pk_file and f.nbSeqs < 20 }] set Lf [d eval {select distinct nom from file where nbSeqs < 20}] puts "Lf0 [llength $Lf0]" puts "Lf [llength $Lf]" set diff [lor $Lf0 $Lf] puts "\n[join [lsort $diff] \n]" exit } proc anab {} { package require sqlite3 sqlite3 d res.sql set Ls [d eval {select b.start,b.stop,s.rank, s.min, s.max from segment as s, ln_block_segment as lbs, block as b, ln_file_block as lfb, file as f where f.nom = 'BB11003.xml' and f.pk_file = lfb.pk_file and lfb.pk_block = b.pk_block and b.pk_block = lbs.pk_block and lbs.pk_segment = s.pk_segment and s.motiflen = 13}] foreach {d f r min max} $Ls { puts "$d $f $r $min $max" } exit } proc anadb {} { global db InitTaxDB $db eval {begin transaction} set Lp [$db eval {select distinct(Parent) from taxonomy where isGold=1}] set Lv [$db eval "select NbKeep from taxonomy where taxid in ([join $Lp ,])"] set tot [+ {*}$Lv] puts "tot $tot" set Lp [$db eval {select distinct(Parent) from taxonomy where isGold=1 and NbGold=1}] set Lv [$db eval "select NbKeep from taxonomy where taxid in ([join $Lp ,])"] set tot [+ {*}$Lv] puts "tot $tot" set Lp [$db eval {select distinct(Parent) from taxonomy where isGold=1 and NbKeep=1}] set Lv [$db eval "select NbKeep from taxonomy where taxid in ([join $Lp ,])"] set tot [+ {*}$Lv] puts "tot $tot" # Model set Lv [$db eval {select t.taxid,t.Rank,t.Name from taxonomy as t , gold as g where g.Model=1 and g.taxid=t.taxid}] foreach {t r n} $Lv { puts "$n $r" set par [$db eval {select Parent from taxonomy where taxid=$t}] set rkp [$db eval {select Rank from taxonomy where taxid=$par}] set nf [$db eval {select count(*) from taxonomy where Parent=$par}] #puts " nb freres $nf" #puts " rk parent $rkp" } puts "" # check nbgold set Lgi [$db eval {select distinct Parent,NbGold from taxonomy where isGold=1 and NbGold=1}] set tot 0 foreach {t n} $Lgi { incr tot $n } set Ngold [$db eval {select count(*) from taxonomy where isGold = 1}] puts "NbGold $tot ngold $Ngold" set nG [$db eval {select count(*) from taxonomy where isGold=1 and NbGold=1}] puts "nG $nG" set Lr [$db eval {select distinct Rank from taxonomy}] foreach r [lsort $Lr] { puts "$r [$db eval {select count(*) from taxonomy where Rank=$r}]" } $db eval {commit} exit set Ln [$db eval {select NbGold from taxonomy where Rank="Genus"}] foreach n $Ln { incr tot $n } puts "total $tot" $db eval {commit} exit set euk [$db eval {select taxid from taxonomy where Name="Eukaryota"}] set Ltv [$db eval {select taxid,NbChildCum from taxonomy where Parent=$euk}] while {1} { set Lp [list] set max -1 ; set tmax 0 #puts "" foreach {t v} $Ltv { if {$v > $max} { set max $v set tmax $t set imax [format "%6d %-32s %6d | %d" {*}[$db eval {select taxid,Name,Parent,NbChildCum from taxonomy where taxid=$t}]] } } if {$max == 1} { break } puts $imax set Lp $tmax if {[llength $Lp] == 0} { break } set Ltv [$db eval "select taxid,NbChildCum from taxonomy where Parent in ([join $Lp ,])"] } $db eval {commit} $db close update return } proc anagold {} { package require sqlite3 set db root sqlite3 $db taxo.sql $db eval {begin transaction} set Ltnp [$db eval {select t.taxid, t.Name, t.Parent from sotol as s, taxonomy as t where s.isGold=1 and t.Rank='no rank' and s.taxid=t.taxid}] puts "[expr {[llength $Ltnp]/3}]" puts "" set Ltnp [lsort -stride 3 -index 1 $Ltnp] foreach {t n p} $Ltnp { lassign [$db eval {select Rank,Name,Parent from taxonomy where taxid=$p}] rk nm pr set ig [$db eval {select isGold from sotol where taxid=$p}] if {$rk ne "Species"} { incr no lappend Lrk $rk puts "no rank : $n" puts " par : $ig $rk $nm" lassign [$db eval {select Rank,Name,Parent from taxonomy where taxid=$pr}] rkp nmp prp set igp [$db eval {select isGold from sotol where taxid=$pr}] puts " Gpr : $igp $rkp $nmp" set lvp 0 while {$rkp ne "Species" && $prp > 0} { lassign [$db eval {select Rank,Parent from taxonomy where taxid=$prp}] rkp prp incr lvp } lappend Lanc $lvp puts "" if {$rkp eq "Species"} { lappend Lsig [$db eval {select isGold from sotol where taxid=$prp}] } } } $db eval {commit} puts "" puts "$no" puts "[lsort -unique $Lrk]" puts "[join [DenombreLaListe $Lanc] \n]" puts "" puts "[join [DenombreLaListe $Lsig] \n]" exit puts [$db eval {select count(s.isGold) from sotol as s, taxonomy as t where t.Name like 'escherichia coli%' and t.taxid=s.taxid and s.isGold=1}] exit } proc anal {} { global LNOrdali set Lf [LesFichiersDeBalibase] foreach l $Lf { unset -nocomplain LNOrdali DecortiqueXmlAgent $l set lgt [llength $LNOrdali] puts "$l $lgt" lappend Lg $lgt } array set Tres [CreeHistogramme $Lg 20] foreach k [lsort -real [array names Tres]] { puts "$k $Tres($k)" } exit } proc anald {} { global db InitTaxDB set Ld [$db eval {select g.domaine from sotol as s, gold as g where s.isComp = 1 and s.taxid = g. taxid}] set Ld [DenombreLaListe $Ld] puts "[join $Ld \n]" set Le [$db eval {select distinct g.taxid from gold as g, sotol as s where g.Domaine = 'EUKARYAL' and s.isComp=1 and s.taxid = g.taxid}] puts "toto [llength $Le]" $db close exit } proc analyseSuite {} { #Ajouter Espionne "Bilan Orthologie" DeleteDoublonFastaFilePourTous #mettre le BilanOrthologiePourTous dans analyse2 et doit faire le bilan avec les sequences dans le repertoire newtfas... #BilanOrthologiePourTous #Premier alignement multiple CreeLesBanquesBlastDesTFAsPourTous BlastPPourTous "" _dedicated_banquesdescopains exec ln -s blastp_dedicated_banquesdescopains blastp Espionne "Premier DbClustalPourTous" DbClustalPourTous Espionne "Sauvegarde first alignment" SauveFirstAlignmentPourTous #prepare le format d'entre pour psiblast Espionne "clustalConvertForpsiblast" clustalConvertForpsiblastPourTous ######### Deux psiblat avec pour l'instant une iteration demande d'information a l'utilisateur #premier pisblat contre protpdb Espionne "PsiBlastPXavierPourTous 1" #Peut-etre revoir la procedure PsiBlastPXavierPourTous???????? PsiBlastPXavierPourTous #deuxieme contre pdb onlyCreateFileResumePourTous global GardeToutPsiBlastPPourTous; unset GardeToutPsiBlastPPourTous global CommandePsiBlastPPourTous; unset CommandePsiBlastPPourTous Espionne "PsiBlastPXavierPourTous 2" PsiBlastPXavierPourTous #pour chaque SU creation d'un fihier contenant la liste des pdb trouver Espionne "parsePsiblastPourTous" parsePsiblastPourTous exec rm -R [RepertoireDuGenome]/banquesdescopains exec rm -R [RepertoireDuGenome]/blastp_dedicated_banquesdescopains exec rm -R [RepertoireDuGenome]/blastp exec rm -R [RepertoireDuGenome]/ballast Espionne "Second DbClustal" CreeLesBanquesBlastDesTFAsPourTous BlastPPourTous "" _dedicated_banquesdescopains exec ln -s blastp_dedicated_banquesdescopains blastp Espionne "DbClustalPourTous" DbClustalPourTous #Ajoute les noms des Organismes aux sequences des msf Espionne "Msf2MsfOrgPourTous" Msf2MsfOrgPourTous2 } proc analyseSuite2 {} { #Enleve les noms des Organimse aux sequence des msf Espionne "MsfOrg2MsfPourTous" MsfOrg2MsfPourTous2 Espionne "clustalConvertForMacsim" #Interproscan clustalConvertForMacsimPourTous Espionne "LeonEtMacsimPourTousX" LeonEtMacsimPourTousX #test programme pour remettre dans l'ordre le fichier macsimXml Espionne "reorder1PourTous" reorder1PourTous Espionne "KoAnnoPourTous" KoAnnoPourTous Espionne "tfadescopainsSansSw" tfadescopainsSansSwPourTous ########################################### VOIR AVEC LAETITIA POUR RAJOUTER DES PASTOUCHE AVEC INTERPROSCAN ET LITETCOMPLETEXML ################################ Espionne "Interproscan" Interproscan #reecris les fichiers xml avec les organismes Espionne "LitEtCompleteXML" LitEtCompleteXML Espionne "ReecritTousLesMacsimsAcOrga" ReecritTousLesMacsimsAcOrga ################################################################################################################################################################# Espionne "LesCopainsPourInterpro" SauveTfasPourInterproPourTous Espionne "StringPourTous" StringPourTous #Creation d'un repertoire qui contient un fichier tfasdescopains pour chaque SU en accord avec les modifications apporter dans l'analyse des alignements NettoiTfasDesCopainsPourTous #creation du bilan Orthologie fichier csv BilanOrthologiePourTous Espionne "Fichier Bilan" #Bilan fichier resumer pour l'ensemble des SUs FileBilanPourTous #creation d'un fichier texte r¨¦capitulatif pour chaque SUs Espionne "CreateFileResume" CreateFileResumePourTous #Sauvegarde pour chaque SU les sequence tfadescopains utilise pour l'analyse Interproscan dans lesCopainsPourInterpro #Creation pour chaque protein des images pfma domain pdb etc... #createImageScView Espionne "Fin des analyses" ###################### A ajouter dans la procedure.... ######################### #ajouter la commande /biolo/macsim/macsim2jal fileentry fileout #exemple: /biolo/macsim/macsim2jal PUZ01 PUZ01 #le programme genere les fichier PUZ01.html, PUZ01.tfa et PUZ01.txt #avec procedure pour Tous!!! } proc ancbi {} { set Ll [LesLignesDuFichier ../SoTOL/toto] foreach l $Ll { if {[string index $l 0] eq "#"} {continue} set Lv [split $l \t] set sca [lindex $Lv end-7] set sta [lindex $Lv end-2] if {[regexp -nocase {complete} $sta]} { puts "$sca" } lappend Lc [lindex $Lv end-7] lappend Ls [lindex $Lv end-2] } #puts [join [DenombreLaListe $Lc] \n] #puts [join [DenombreLaListe $Ls] \n] exit } proc ani {} { set in [LesLignesDuFichier file.surf] foreach l $in { lappend Ls [string range $l 21 end] } set in [LesLignesDuFichier file.alni] foreach l $in { lappend La [string range $l 21 end] } set fs [open f.surf w] puts $fs [join $Ls \n] close $fs set fa [open f.alni w] puts $fa [join $La \n] close $fa exit } proc anneClassementParBandeDesNseqPlusBiais {} { set Fichier "[GscopeDatabaseDir DDetAffy2]/Localisation/cyto_Distribution" set NbGenesTotal 0 set NbSeqTotal 0 foreach Ligne [LesLignesDuFichier "[GscopeDatabaseDir DDetAffy2]/Localisation/chr_Distribution"] { scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3 if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue} set NbSeqTotal [expr [expr $seq1+$seq2+$seq3+$seq4]+$NbSeqTotal] set NbGenesTotal [expr [expr $gene1+$gene2+$gene3]+$NbGenesTotal] } #Espionne $NbSeqTotal #Espionne $NbGenesTotal set ListeBande {} set ListeNbSeq {} set ListeNbGenes {} foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s %s %s" chro long type var set n 0 if {$var=="Var"} { foreach Elt $Ligne { if {$Elt!=" "} { incr n if {$n>4} {lappend ListeBande "$Elt"} } } } if {$var=="NbSeq"} { foreach Elt $Ligne { if {$Elt!=" "} { incr n if {$n>4} {lappend ListeNbSeq "$Elt"} } } } if {$var=="NbGenes"} { foreach Elt $Ligne { if {$Elt!=" "} { incr n if {$n>4} {lappend ListeNbGenes "$Elt"} } } } } set ListeTotale {} foreach Band $ListeBande Nseq $ListeNbSeq Ngene $ListeNbGenes { if {$Ngene!=0} { set BiaisBande [expr round((100*$Nseq*$NbGenesTotal)/($NbSeqTotal*$Ngene))] } set Somme [expr $BiaisBande+$Nseq] lappend ListeTotale "$Band $Nseq $Ngene $BiaisBande $Somme" } set ListeTriee [lsort -decreasing -integer -index 4 $ListeTotale] set Final [format "%-12s %-5s %-5s %-5s %-5s %-10s\n" Band NSeq NGene Biais Somme Expr] foreach Elt $ListeTriee { scan $Elt "%s %s %s %s %s" band nseq ngene biais somme set Expr [ProfilDExpressionPourUneBande $band] append Final [format "%-12s %-5s %-5s %-5s %-5s %-10s\n" $band $nseq $ngene $biais $somme $Expr] } #Espionne $Final Sauve $Final dans "[GscopeDatabaseDir DDetAffy2]/Classements/NbSeqPlusBiaisParBande" } proc annoterIsoformesDansXmlMacsims {FichierBlast FichierMacsims FichierResultat} { # BLAST set dic [dict create] set isoforms [dict create] set hits [parserFichierBlast $FichierBlast] foreach h $hits { dict set dic [$h getShortid] $h } set groupes [grouperHitsParTaxid $hits] dict for {taxid g} $groupes { set sousGroupes [grouperIsoformesScore $g estIsoformeFenetre Subj] foreach sg $sousGroupes { if {[llength $sg] > 1} { set sg [triHitsParNbTirets $sg Subj] set refid [[lindex $sg 0] getShortid] dict set isoforms $refid $refid foreach h [lrange $sg 1 end] { dict set isoforms [$h getShortid] $refid } } } } # MACSIMS package require tdom set f [open $FichierMacsims r] dom parse -channel $f mac close $f $mac documentElement root set i 0 foreach seq [$root selectNodes "//sequence"] { set seqname [[$seq child 1 "seq-name"] text] set length [expr [[$seq descendant 1 "length"] text]-1] set ftable [$seq descendant 1 "ftable"] if {[dict exists $isoforms $seqname]} { set color 0 set note "Isoforme choisi" if {[dict get $isoforms $seqname] ne [$h getShortid]} { set color 1 set note "Isoforme de [dict get $isoforms $seqname]" } $ftable appendXML "ISOFORM1$length$color0.00$note" } } set f [open $FichierResultat w] puts -nonewline $f { } puts -nonewline $f [$mac asXML] close $f return 1 } proc areRangeOverlapping {range1 range2} { set start1 [lindex $range1 0] set start2 [lindex $range2 0] set stop1 [lindex $range1 1] set stop2 [lindex $range2 1] if {$start1 >= $start2 && $start1 <= $stop2} { return 1 } elseif {$stop1 >= $start2 && $stop1 <= $stop2} { return 1 } elseif {$start2 >= $start1 && $start2 <= $stop1} { return 1 } elseif {$stop2 >= $start1 && $stop2 <= $stop1} { return 1 } return 0 } proc arit {} { set a [list -1.25 -3.0 2.5 12.1 0.05] set b [lsort -real $a] set min [lindex $b 0] set max [lindex $b end] set eps 0.01 set s 0.0 foreach v $a { set x [expr {($v - $min + $eps)/($max - $min + $eps)}] lappend Lx $x set s [expr {$s + $x}] } set sum 0.0 foreach x $Lx { set n [expr {$x / $s}] lappend Ln $n set sum [expr {$sum + $n}] } puts "s= $s" puts "sum= $sum" foreach q $a s $Ln { puts "$q $s" } exit } proc arno {} { set str "grep \"|\" arno" set var [eval exec $str] #set var [exec grep "|" arno] puts $var exit } proc atmp {} { package require sqlite3 sqlite3 d res.sql d eval {begin transaction} set Lv [d eval {select f.nom,f.nbSeqs,f.length,b.start,b.stop,s.rank,s.min,s.max from file as f, ln_file_block as lfb, block as b, ln_block_segment as lbs, segment as s where f.nbSeqs < 20 and f.pk_file = lfb.pk_file and lfb.pk_block = b.pk_block and b.pk_block = lbs.pk_block and lbs.pk_segment = s.pk_segment and s.motiflen = 13 and s.rank <= 0.05 }] set Lv [lsort -real -stride 8 -index 3 $Lv] foreach {nom nbs lgt start stop rank min max} $Lv { if {$rank == 0.0} {continue} puts [format "%s %3d %4d %5.3f %-3d %-3d %-3d %-3d" $nom $nbs $lgt $rank $start $stop $min $max] } d eval {commit} d close exit } proc atnw {} { set Ll [LesLignesDuFichier out] set idtnw [lsearch -regexp $Ll {^DTNW}] set iftnw [lsearch -regexp $Ll {^FTNW}] set idtor [lsearch -regexp $Ll {^DTOR}] set iftor [lsearch -regexp $Ll {^FTOR}] set verif [list [list A 5 5 5 5 5 6 5 5 5 5 6 4 4 4 5 3 3 2 2 0] [list T 4 4 4 4 5 4 4 4 5 4 4 5 4 4 3 4 3 2 1 1] [list A 4 3 3 3 3 4 3 3 3 3 4 3 3 3 4 3 3 2 2 0] [list G 2 2 3 2 2 2 3 2 2 3 2 2 2 3 2 2 2 3 1 0] [list A 2 1 1 1 1 2 1 1 1 1 2 1 1 1 2 1 1 1 2 0] [list T 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 1]] set i 0 foreach l1 [lrange $Ll $idtnw+1 $iftnw-1] l2 [lrange $Ll $idtor+1 $iftor-1] { regsub -all { +} [string trim $l1] " " l1 regsub -all { +} [string trim $l2] " " l2 if {$l1 ne $l2} { puts "- $i ------------" puts "$l1" puts "$l2\n" } incr i } exit } proc attend {} { set version "na27" set FichierMG430A "[RepertoireAffyAnnot $version]/MG430A_2.0/Mouse430A_2.na27.annot.csv" set FichierMG430 "[RepertoireAffyAnnot $version]/MG430_2.0/Mouse430_2.na27.annot.csv" set FichierMGU74A "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Av2.na26.annot.csv" set FichierMGU74B "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Bv2.na26.annot.csv" set FichierMGU74C "[RepertoireAffyAnnot $version]/MGU74v2/MG_U74Cv2.na26.annot.csv" set FichierRGU34A "[RepertoireAffyAnnot $version]/RG-U34/RG_U34A.na27.annot.csv" set FichierHGU1332 "[RepertoireAffyAnnot $version]/HG-U133+2/HG-U133_Plus_2.na27.annot.csv" set FichierHGU133A "[RepertoireAffyAnnot $version]/HG-U133/HG-U133A.na27.annot.csv" set FichierZebra "[RepertoireAffyAnnot $version]/Zebrafish/Zebrafish.na27.annot.csv" set FichierDroso "[RepertoireAffyAnnot $version]/Drosophila/DrosGenome1.na27.annot.csv" set FichierChick "[RepertoireAffyAnnot $version]/Chicken/Chicken.na27.annot.csv" set LesFichiers [list $FichierMG430A $FichierMG430 $FichierMGU74A $FichierMGU74B $FichierMGU74C $FichierRGU34A $FichierHGU1332 $FichierHGU133A $FichierZebra $FichierDroso $FichierChick] } proc attend_OBSOLETE {} { if {$LesAcsDeLaLigne == ""} { set LignePauvre "ligne $I Ac1=$Ac1 Ac2=$Ac2 Ac3=$Ac3 Ac4=$Ac4" lappend LesLignesPauvres $LignePauvre Espionne ">bidon trouve pas \natgc" } else { foreach Acs $LesAcsDeLaLigne { if { [regexp "^NM_" $Acs] || [regexp "^XM_" $Acs] || [regexp "^NR_" $Acs] } { set GetzOut "" set Commande "getz \"\\\[refseq-acc:$Acs\\\]\" \-view FastaSeqs" set GetzOut [eval exec $Commande] if {$GetzOut == ""} {Espionne ">bidon fiche n'existe plus\natgc" } if {$GetzOut != ""} { set GetzOut [string range $GetzOut [string last ">" $GetzOut] end] if { [regexp {^>ref.+>ref} $GetzOut] } { #Espionne "ATTENTION AU - 2 SEQ FASTA" } Espionne $GetzOut } } else { set GetzOut "" set Commande "getz \"\\\[genbankfull-acc:$Acs\\\]\" \-view FastaSeqs" set GetzOut [eval exec $Commande] if {$GetzOut == ""} {Espionne ">bidon fiche n'existe plus\natgc" } if {$GetzOut != ""} { set GetzOut [string range $GetzOut [string last ">" $GetzOut] end] if { [regexp {^>ref.+>ref} $GetzOut] } { #Espionne "ATTENTION AU - 2 SEQ FASTA" } Espionne $GetzOut } } } } } proc audrey {} { DecortiqueUnTFA audrey.tfa Ln Seq set Ljobs [list] foreach n [lrange $Ln 0 end] { puts "$n" set s [string map {"." ""} $Seq($n)] #set rep($n) [BlastService -p blastp -d nr -expect 1e-100 -query ">$n\n$s" -nlist 10 -f 1] set query ">$n $s " lappend Ljobs [list -p blastp -d nr -expect 1e-100 -query $query -nlist 10 -f 1] #puts "\n$rep($n)" } array set rep [ThreadedBlastService $Ljobs] # lookup job id <-> query set Ljid [array names rep *,query] foreach k $Ljid { lassign [split $k ,] jid tmp set rep($query) $jid } #parray rep puts "" set Lnew [list] foreach n [lrange $Ln 0 end] { puts "" if {! [info exists rep($n)]} { puts "pas $n" continue } set jid $rep($n) set Lres $rep($jid,Res) puts "[join $Lres \n]" DecortiqueBlast $Lres "" "" "" LBbid LBacc LBde "" LBPN LAli foreach a $LBacc p $LBPN ali $LAli { if {$p == 0.0} { puts "=> OK $n $a $p" lappend Lnew $a break } else { puts " $n $a $p" } } puts "" } puts "\n[join $Lnew \n]" exit } proc austra {} { LoadTkAndPackages set ph [image create photo] #$ph read map_of_australia2.jpg -format jpeg #$ph read roads_australia2.jpg -format jpeg $ph read roads_australia3.gif -format gif set wdt [image width $ph] set hgt [image height $ph] set str [$ph data] foreach a $str { foreach d $a { if {! [info exists t($d)]} { set t($d) 1 } else { incr t($d) } } } #parray t set lt [array get t] set lt [lsort -stride 2 -decreasing -index 1 -integer $lt] canvas .c -width 500 -height 500 pack .c set i 0 ; set j 0 puts "compage nbr pixels / couleur" foreach {a b} $lt { puts "$a $b" set x1 [expr {$i*25}] set y1 [expr {$j*25}] set x2 [expr {($i+1)*25}] set y2 [expr {($j+1)*25}] .c create rectangle $x1 $y1 $x2 $y2 -fill $a incr i if {$i > 19} { set i 0 incr j } if {$j > 19} {break} } # liste color ordered by presence set Lcol [list] foreach {a b} $lt { lappend Lcol $a } # threshold for color differences set thr 5 set i 0 foreach a [lrange $Lcol 0 49] { incr i if {[string index $a 0] ne "#"} {continue} lassign [CouleurHexa2Int $a] ra ga ba foreach c [lrange $Lcol $i 49] { if {$c eq $a} {continue} if {[string index $c 0] ne "#"} {continue} lassign [CouleurHexa2Int $c] rc gc bc # calc diff if { abs($ra - $rc) < $thr && abs($ga - $gc) < $thr && abs($ba - $bc) < $thr} { if {[set t($a)] > [set t($c)]} { lappend cg($a) $c } else { lappend cg($c) $a } } } } # trie les cg qui ont le plus de couleurs proches set Ll [list] puts "" puts "--> cg in [llength [array names cg]]" foreach c [array names cg] { set cg($c) [lsort -unique [set cg($c)]] update lappend Ll $c [llength [set cg($c)]] } set Ll [lsort -stride 2 -index 1 -integer -decreasing $Ll] # elimine ceux deja pris puts "" puts "couleurs proches" set Lok [list] foreach {c n} $Ll { puts "$c $n" if {[info exists cg($c)]} { lappend Lok $c puts "[set cg($c)]" set Lv [set cg($c)] foreach v $Lv { if {$v in $Lok} {continue} unset -nocomplain cg($v) } update } } puts "\nAfter reduction :" puts "cg [llength [array names cg]]" # Quandtite a enleve a chaque couleur set fdim 100 foreach c [array names cg] { set Lcol [set cg($c)] # assombrit c lassign [CouleurHexa2Int $c] nr ng nb set nr [expr {$nr - $fdim}] if {$nr < 0} {set nr 0} set ng [expr {$ng - $fdim}] if {$ng < 0} {set ng 0} set nb [expr {$nb - $fdim}] if {$nb < 0} {set nb 0} set cout [CouleurInt2Hexa [list $nr $ng $nb]] puts "$c $cout" set fmt [list] foreach col $Lcol { lappend fmt $col $cout } set str [string map $fmt $str] } set nw [image create photo] $nw put $str puts "in $wdt $hgt" puts "out [$nw cget -width] [$nw cget -height]" # images avant et apres set wfc .t toplevel $wfc canvas $wfc.c -width 400 -height 400 -scrollregion [list 0 0 $wdt $hgt] set ItImg [$wfc.c create image 0 0 -image $nw -anchor nw] scrollbar $wfc.vs -command "$wfc.c yview" -width 8 scrollbar $wfc.hs -orient horiz -command "$wfc.c xview" -width 8 button $wfc.bold -command "$wfc.c itemconfigure $ItImg -image $ph" -bg blue -fg white -text " OLD " button $wfc.bnew -command "$wfc.c itemconfigure $ItImg -image $nw" -bg blue -fg white -text " NEW " grid $wfc.c -row 0 -column 0 -sticky news grid $wfc.vs -row 0 -column 1 -sticky ns grid $wfc.hs -row 1 -column 0 -sticky ew grid $wfc.bold -row 2 -column 0 -sticky w grid $wfc.bnew -row 2 -column 1 -sticky e grid rowconfig $wfc 0 -weight 1 grid columnconfig $wfc 0 -weight 1 grid columnconfig $wfc 1 -weight 0 bind $wfc.c {%W scan mark %x %y} bind $wfc.c {%W scan dragto %x %y 1} update idletasks #$nw write new.gif return exit } proc auto_mkindex {dir args} { if {[interp issafe]} { error "can't generate index within safe interpreter" } set oldDir [pwd] cd $dir append index "# Tcl autoload index file, version 2.0\n" append index "# This file is generated by the \"auto_mkindex\" command\n" append index "# and sourced to set up indexing information for one or\n" append index "# more commands. Typically each line is a command that\n" append index "# sets an element in the auto_index array, where the\n" append index "# element name is the name of a command and the value is\n" append index "# a script that loads the command.\n\n" if {![llength $args]} { set args *.tcl } auto_mkindex_parser::init foreach file [glob -- {*}$args] { try { append index [auto_mkindex_parser::mkindex $file] } on error {msg opts} { cd $oldDir return -options $opts $msg } } auto_mkindex_parser::cleanup set fid [open "tclIndex" w] puts -nonewline $fid $index close $fid cd $oldDir } proc auto_mkindex_old {dir args} { set oldDir [pwd] cd $dir set dir [pwd] append index "# Tcl autoload index file, version 2.0\n" append index "# This file is generated by the \"auto_mkindex\" command\n" append index "# and sourced to set up indexing information for one or\n" append index "# more commands. Typically each line is a command that\n" append index "# sets an element in the auto_index array, where the\n" append index "# element name is the name of a command and the value is\n" append index "# a script that loads the command.\n\n" if {![llength $args]} { set args *.tcl } foreach file [glob -- {*}$args] { set f "" set error [catch { set f [open $file] while {[gets $f line] >= 0} { if {[regexp {^proc[ ]+([^ ]*)} $line match procName]} { set procName [lindex [auto_qualify $procName "::"] 0] append index "set [list auto_index($procName)]" append index " \[list source \[file join \$dir [list $file]\]\]\n" } } close $f } msg opts] if {$error} { catch {close $f} cd $oldDir return -options $opts $msg } } set f "" set error [catch { set f [open tclIndex w] puts -nonewline $f $index close $f cd $oldDir } msg opts] if {$error} { catch {close $f} cd $oldDir error $msg $info $code return -options $opts $msg } } proc auto_reset {} { global auto_execs auto_index auto_path if {[array exists auto_index]} { foreach cmdName [array names auto_index] { set fqcn [namespace which $cmdName] if {$fqcn eq ""} { continue } rename $fqcn {} } } unset -nocomplain auto_execs auto_index ::tcl::auto_oldpath if {[catch {llength $auto_path}]} { set auto_path [list [info library]] } elseif {[info library] ni $auto_path} { lappend auto_path [info library] } } proc autre_CreeLaListeDesPFAMUniques {} { # more Domaines | gr PFAM | grep PF | gr -v PB | grep "1\.0" | wc set Fichier "[RepertoireDuGenome]/fiches/Domaines" foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} if {![regexp "PFAM" $Ligne]} {continue} set Ligne [split $Ligne "\t"] set Acc [lindex $Ligne 2] #FaireLire [lindex $Ligne 3] set Id [lindex $Ligne 6] if {[regexp "^PF" $Acc] && $Id=="1.0"} { lappend Liste $Acc lappend ListeComplete $Ligne } else { #Espionne $Ligne } } Espionne [llength $Liste] set Liste [lsort -unique $Liste] SauveLesLignes $ListeComplete dans "[RepertoireDuGenome]/fiches/pfamA100avecDes" #SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/pfamA100" } proc axis_to_quat {a phi} { set a [vnormal $a] set q $a set q [vscale $q [expr {sin($phi/2.0)}]] lappend q [expr {cos($phi/2.0)}] return $q } proc balloon {target message {cx 0} {cy 0}} { global Bulle if {$Bulle(first) == 1 } { set Bulle(first) 2 if { $cx == 0 && $cy == 0 } { set X [winfo rootx $target] set Y [winfo rooty $target] } else { set X $cx set Y $cy } set Xmin [winfo rootx $target] set Xmax [expr $Xmin + [winfo width $target]] set Ymin [winfo rooty $target] set Ymax [expr $Ymin + [winfo height $target]] toplevel .balloon -bg black wm overrideredirect .balloon 1 label .balloon.l -text $message -relief flat -bg #ffffaa -fg black -padx 2 -pady 0 -anchor w pack .balloon.l -side left -padx 1 -pady 1 wm withdraw .balloon update set MessageLargeur [winfo width .balloon] set MessageHauteur [winfo height .balloon] if {$MessageLargeur=="1" && $MessageHauteur=="1"} { set MessageLargeur [winfo reqwidth .balloon] set MessageHauteur [winfo reqheight .balloon] } #Ajustement des positions de l InfoBulle #Sur Beaufort le withdraw empeche d avoir la taille de la fenetre voir mise a jour #Mais le reqwidth et le reqheight contourne le pb set OnForceADroite 1 set OnForceEnBas 0 if {$MessageHauteur==1} {set OnForceADroite 0} if {$MessageLargeur==1} {set OnForceEnBas 1} set EcranHauteur [winfo screenheight .] set EcranLargeur [winfo screenwidth .] if {$OnForceADroite && $X> [expr $EcranLargeur/2]} { #On affiche a gauche incr X -10 #while {$X>$Xmin} {incr X -1} set PosX [expr $X - $MessageLargeur] } else { #On affiche a droite incr X 10 #while {$X<$Xmax} {incr X 1} set PosX $X } if {$OnForceEnBas || $Y< 50} { #On affiche en bas incr Y 5 #set PosY $Y set PosY $Ymax } else { #On affiche en haut incr Y -5 set PosY [expr $Ymin -$MessageHauteur] } set PosX [format "%.0f" $PosX] set PosY [format "%.0f" $PosY] #Ajustement final des positions de l InfoBulle et positionnement if {$PosX<0} { #On sort de l ecran par la gauche set PosX 0 } elseif {[expr $PosX + $MessageLargeur]> $EcranLargeur} { #On sort de l ecran par le droite set PosX [expr $EcranLargeur - $MessageLargeur] } if {$PosY<0} { #On sort de l ecran par le dessus set PosY 0 } elseif {[expr $PosY + $MessageHauteur]> $EcranHauteur} { #On sort de l ecran par le dessous set PosY [expr $EcranHauteur - $MessageHauteur] } wm geometry .balloon +${PosX}+${PosY} #wm geometry .balloon +${x}+${y} set Bulle(set) 1 #5 Apres l avoir oublie on se souvient wm deiconify .balloon } } proc bb1 {} { set Fichier "[RepertoireDuGenome]/fiches/tubgroupe3" set NbD 0 set NbE 0 set Nb 0 foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s %s %s %s" A B C D E incr Nb if {$D != "None"} {incr NbD} if {$E != "None"} {incr NbE} } Espionne "$NbD $NbE $Nb" } proc bb12044 {} { global T TAg LNOrdali Lspy Sref InitialiseRosace #lululu DecortiqueXmlAgent BB12044.xml set Lbck [CoreBlocksDuXML] foreach {deb fin} [lrange $Lbck 0 1] { puts "BB12044.xml 13 $deb $fin blosum62_p sop" AnalyseFichierBalibase BB12044.xml 13 $deb $fin blosum62_p bild } exit # agents pour pos 150 set Lspy {} foreach n [array names Sref] { set x [AbsRef2Seq $n 150] foreach k [array names TAg "*,$n,dep"] { if {$TAg($k) == $x} { lassign [split $k ,] ag tmp tmp lappend Lspy $n $ag } } } puts "Lspy [llength $Lspy]" set nv 0 ; set srk 0.0 foreach {n1 ag1} $Lspy { foreach {n2 ag2} $Lspy { if {$n1 eq $n2 && $ag1 == $ag2} { continue } set idx [lsearch -exact -index 0 $T($n1,$ag1,$n2) $ag2] set srk [expr {$srk + $idx}] incr nv if {$idx == 0} { continue } puts "$n1 - $n2 : [Seq2AbsRef $n1 $ag1]" set ipos 0 foreach cpl [lrange $T($n1,$ag1,$n2) 0 $idx] { lassign $cpl agx score puts " $TAg($ag1,$n1,seq) $ipos [format %6.2f $score]" puts " $TAg($agx,$n2,seq) [Seq2AbsRef $n2 $agx]" puts "" incr ipos } puts "" puts "" } } set srk [expr {$srk/$nv}] puts "srk $srk" exit } proc bgerror_togl {msg} { tk_messageBox -icon error -type ok -message "Error: $msg\n\n$::errorInfo" ExitProg } proc bidon2 {} { global Defauts global LesPCI LesDefauts LesDefauts Mode batch DecortiqueEtAfficheUnMSF "toto.msf" EspionneL $LesPCI exit } proc bidouille {} { set Lf [LesLignesDuFichier "listeMs2ph"] set foo [open "listeMs2ph_new" w] foreach l $Lf { puts $foo "set ExistsM([string trim $l]) 1" } close $foo set Lf [LesLignesDuFichier "listeHomol"] set foo [open "listeHomol_new" w] foreach l $Lf { puts $foo "set ExistsH([string trim $l]) 1" } close $foo exit } proc bidouilleListes {} { set Lf [LesLignesDuFichier "listeMs2ph"] set foo [open "listeMs2ph_new" w] foreach l $Lf { puts $foo "set ExistsM([string trim $l]) 1" } close $foo set Lf [LesLignesDuFichier "listeHomol"] set foo [open "listeHomol_new" w] foreach l $Lf { puts $foo "set ExistsH([string trim $l]) 1" } close $foo exit } proc biotextbutton1 {w x y} { $w index @$x,$y focus $w return } proc bmpr {} { LitLeTFA bactos_prot.tfa Lbp Sbp LitLeTFA mito_prot.tfa Lmp Smp LitLeTFA 250ori_prot.tfa Lop Sop LitLeTFA 250ori_rna.tfa Lor Sor foreach n $Lbp { set i [lsearch $Lop $n] set nr [lindex $Lor $i] lappend Lnr $nr lappend Lsr [set Sor($nr)] } EcritLeTfa bactos_rna.tfa $Lnr $Lsr set Lnr [list] ; set Lsr [list] foreach n $Lmp { set i [lsearch $Lop $n] set nr [lindex $Lor $i] lappend Lnr $nr lappend Lsr [set Sor($nr)] } EcritLeTfa mito_rna.tfa $Lnr $Lsr exit } proc btest {} { global LNOrdali LSOrdali Sequences ListeDesPiliersDuGroupe SDG LNDG LongueurTotale TbScores ListeScore ConsMeth # soit executable -> exe ou library -> lib #set how "lib" set how "exe" set Lpcgap [list 0.01 0.25 0.5 0.75] set Lmscore [list [list Dist Kabat Entrop1]] set Lcm [list mixturemodel dpc secator] #set Lf [list PF04045.9 PF09327.6 PF14464.1_smp PF04046.11 PF09328.5 PF14465.1 PF04048.9 PF09329.6 PF14466.1 PF04049.8 PF09330.6 PF14467.1] set Lf PF02273.10 foreach f $Lf { set f [file join /home/moumou/work/moumou/BenchPfam/ $f] puts "\nf= $f" unset -nocomplain ListeDesPiliersDuGroupe LNOrdali Sequences DecortiqueUnTFA $f LNOrdali Sequences set LongueurTotale [string length [set Sequences([lindex [array names Sequences] 0])]] set LNDG GroupeToutLeMonde set SDG(GroupeToutLeMonde) $LNOrdali CreeLesPiliers # prepare pour scores set Lrcm [list] foreach pcgap $Lpcgap { LesDefauts PCThrGap $pcgap puts "pc thr gap $pcgap" foreach mscore $Lmscore { puts "$mscore" if {[llength $mscore] > 1} { set Scale 1 } else { set Scale 0 } unset -nocomplain ListeScore TbScores set TbScores(Lcols) $mscore foreach msc $mscore { set sco [ScoreDe$msc [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] if {$Scale} { set sco [CentreData $sco -999.0] } set TbScores(Score,$msc) $sco } CreeListeScore if {[llength $ListeScore] < 2} { puts "\nListeScore < 2\n" continue } set Lori $ListeScore set LgS [llength $ListeScore] puts "LgS $LgS" if {$how eq "exe"} { set fdat cpk set o [open $fdat w] foreach l $Lori { puts $o [join $l \t] } close $o } # pour chaque meth clustering foreach cm $Lcm { set Lval $Lori # Fait clusters switch $cm { "dpc" { if {$how eq "lib"} { set Lgr [Tclcluspack $Lval -dt coordinates -cm kmeans -nbc dpc -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=kmeans -nbc=dpc -wc] } set lab dpc } "secator" { if {$how eq "lib"} { set Lgr [Tclcluspack $Lval -dt coordinates -cm hierar -nbc secator -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=hierar -nbc=secator -wc] } set lab secator } "mixturemodel" { if {$how eq "lib"} { set Lgr [Tclcluspack $Lval -dt coordinates -cm mm -nbc aic -wc] } else { set cmd [list /biolo/cluspack/binNew/cluspack $fdat -dt=coordinates -cm=mm -nbc=aic -wc] } set lab mm } } if {$how eq "exe"} { if {[catch {exec {*}$cmd >& ${fdat}.log} Msg]} { puts stderr "Pb Cluspack\n$Msg" flush stderr } if {! [file exists ${fdat}.clu]} { puts "[ContenuDuFichier ${fdat}.log]" continue } # lit nombre clusters set Lc [LesLignesDuFichier ${fdat}.clu] puts "[lindex $Lc 0]" set Lres [TraiteResultatClustering ${fdat}.clu ""] file delete -force ${fdat}.clu ${fdat}.log } else { set Lres [TraiteResultatClusteringTcl $Lgr ""] } puts "$Lres" set Ltrouve [lindex $Lres 1] puts "lab $lab [llength $Ltrouve]" } if {$how eq "exe"} { file delete -force $fdat } } } } exit } proc bufferNTimes {what {n ""}} { global BufNTimes set res 1 switch $what { "add" {append BufNTimes $n} "empty" { if {$BufNTimes ne ""} { set res $BufNTimes set BufNTimes "" } } } return $res } proc build_rotmatrix {q} { lassign $q q0 q1 q2 q3 set m00 [expr { 1.0 - 2.0 * ($q1 * $q1 + $q2 * $q2)}] set m01 [expr { 2.0 * ($q0 * $q1 - $q2 * $q3)}] set m02 [expr { 2.0 * ($q2 * $q0 + $q1 * $q3)}] set m03 0.0 set m10 [expr { 2.0 * ($q0 * $q1 + $q2 * $q3)}] set m11 [expr { 1.0 - 2.0 * ($q2 * $q2 + $q0 * $q0)}] set m12 [expr { 2.0 * ($q1 * $q2 - $q0 * $q3)}] set m13 [expr { 0.0}] set m20 [expr { 2.0 * ($q2 * $q0 - $q1 * $q3)}] set m21 [expr { 2.0 * ($q1 * $q2 + $q0 * $q3)}] set m22 [expr { 1.0 - 2.0 * ($q1 * $q1 + $q0 * $q0)}] set m23 [expr { 0.0}] set m30 0.0 set m31 0.0 set m32 0.0 set m33 1.0 return [list $m00 $m01 $m02 $m03 $m10 $m11 $m12 $m13 $m20 $m21 $m22 $m23 $m30 $m31 $m32 $m33] } proc bx {} { set pdbid 1bbr Structure create $pdbid set cok [$pdbid new $pdbid "" 0 0] foreach c [$pdbid _chains] { if {[$pdbid _chainIs $c] eq "Protein"} { puts [$pdbid _resnumber -chain $c -polymer] } } #exit } proc c2u {} { global LNOrdali TDesAccess Defauts TDesSeqnames set lc [Convert2UniProtAcc $LNOrdali] foreach n $LNOrdali c $lc { puts "$n $c" set TDesAccess($n) $c set TDesSeqnames($n) $c } SauveLeMac 0 set fic "[file rootname [set Defauts(FichierTFA)]].xml" CreeLeXml $fic return #exit } proc calc_normd_for_subgroup {grp score_win conserved} { global CpB CBPCI DistBlosum Sequences ListeDesAcidesAmines puts "conserved $conserved" set Lseqs [set CpB($grp)] set nseqs [llength $Lseqs] set Ltot $CpB(Ltot) set Lpil [set CpB($grp,Lpil)] set ListeAA $ListeDesAcidesAmines # distance matrix between residue vectors InitTBlosum gon250 # Inits for {set i 0} {$i < $Ltot} {incr i} { set p [lindex $Lpil $i] set n [string length [string map [list "." ""] $p]] set CpB(ns,$i) $n set CpB(ntot,$i) 0 } foreach n $Lseqs { set s [set Sequences($n)] set start [expr {[string length $s] - [string length [string trimleft $s "."]]}] set stop [expr {[string length [string trimright $s "."]]-1}] for {set i $start} {$i <= $stop} {incr i} { incr CpB(ntot,$i) } set CpB(startstop,$n) [list $start $stop] } for {set i 0} {$i < $Ltot} {incr i} { set pori [lindex $Lpil $i] set p [string map [list X "" Z "" "." "" " " ""] $pori] set nres [string length $p] if {[set CpB(ntot,$i)] < 1} { set ColScore($i) 0.0 continue } set d 0.0 ; set j 0 foreach a [lrange $ListeAA 0 end-1] { incr j set n [expr {[string length $p] - [string length [string map [list $a ""] $p]]}] if {! $n} {continue} foreach b [lrange $ListeAA $j end] { set m [expr {[string length $p] - [string length [string map [list $b ""] $p]]}] if {! $m} {continue} set d [expr {$d+($n*$m)*[set DistBlosum($a,$b)]}] } } set nbr [expr {double($nres)*($nres-1)/2.}] if {$nbr > 0.0} { set d [expr {$d/$nbr}] } set ColScore($i) [expr {exp(-1.*$d/2.)*100.}] if {$conserved > 0.0} { set ntot [set CpB(ntot,$i)] set ns [set CpB(ns,$i)] # standardise scores if {$ns > 0} { set ColScore($i) [expr {[set ColScore($i)]*exp(-10.0*($ntot-$ns)/$ntot)}] } else { set ColScore($i) 0.0 } } } for {set i 0} {$i < $Ltot} {incr i} { set ColScore($i) [expr {int([set ColScore($i)])}] } for {set i 0} {$i < $Ltot} {incr i} { set winscore($i) 0.0 } set half_win [expr {$score_win / 2}] if {$half_win == 0} {set half_win 1} for {set i 0} {$i < ($half_win+1) && $i < $Ltot} {incr i} { for {set j 0} {$j < $score_win} {incr j} { set ij [expr {$i+$j}] set winscore($i) [expr {[set winscore($i)] + [set ColScore($ij)]}] } set winscore($i) [expr {[set winscore($i)]/$score_win}] if {[set winscore($i)] > 100} { set winscore($i) 100.0 } if {[set CpB(ns,$i)] < 1} { set winscore($i) 0.0 } } for {set i 0} {($i+$score_win) < $Ltot} {incr i} { set ih [expr {$i+$half_win}] for {set j 0} {$j < $score_win} {incr j} { set ij [expr {$i+$j}] set winscore($ih) [expr {[set winscore($ih)] + [set ColScore($ij)]}] } set winscore($ih) [expr {[set winscore($ih)]/$score_win}] if {[set winscore($ih)] > 100} { set winscore($ih) 100.0 } if {[set CpB(ns,$ih)] < 1} { set winscore($ih) 0.0 } } for {set i [expr {$Ltot-$score_win}]} {($i+$half_win) < $Ltot} {incr i} { set ih [expr {$i+$half_win}] for {set j 0} {$j < $half_win} {incr j} { set ij [expr {$i+$j}] set winscore($ih) [expr {[set winscore($ih)] + [set ColScore($ij)]}] } set winscore($ih) [expr {[set winscore($ih)]/$score_win}] if {[set winscore($ih)] > 100} { set winscore($ih) 100.0 } if {[set CpB(ns,$ih)] < 1} { set winscore($ih) 0 } } if {$conserved > 0.0} { for {set i 0} {$i < $Ltot} {incr i} { if {[set CpB(ns,$i)] != 0 && ([set CpB(ns,$i)] < [set CpB(ntot,$i)]*$conserved || [set CpB(ntot,$i)] < $nseqs*$conserved)} { set winscore($i) 0.0 } } } return [array get winscore] } proc calc_normd_global {grp score_win conserved} { global CpB CBPCI TableScore Sequences ListeDesAcidesAmines DistBlosum set Lseqs [set CpB($grp)] set nseqs [llength $Lseqs] set Ltot $CpB(Ltot) set ListeAA $ListeDesAcidesAmines set Lpil [set CpB($grp,Lpil)] # distance matrix between residue vectors InitTBlosum gon250 1 # Inits for {set i 0} {$i < $Ltot} {incr i} { set CpB(ntot,$i) 0 set p [lindex $Lpil $i] set n [string length [string map [list "." ""] $p]] set CpB(ns,$i) $n } foreach n $Lseqs { set s [set Sequences($n)] set start [expr {[string length $s] - [string length [string trimleft $s "."]]}] set stop [string length [string trimright $s "."]] for {set i $start} {$i <= $stop} {incr i} { incr CpB(ntot,$i) } set CpB(startstop,$n) [list $start $stop] } for {set i 0} {$i < $Ltot} {incr i} { set pori [lindex $Lpil $i] set p [string map [list X "" Z "" "." "" " " ""] $pori] if {[set ntot [string length $p]] < 2} { set ColScore($i) 0.0 continue } set d 0.0 ; set j 0 foreach a [lrange $ListeAA 0 end-1] { incr j set n [expr {[string length $p] - [string length [string map [list $a ""] $p]]}] if {! $n} {continue} foreach b [lrange $ListeAA $j end] { set m [expr {[string length $p] - [string length [string map [list $b ""] $p]]}] if {! $m} {continue} set d [expr {$d+($n*$m)*[set DistBlosum($a,$b)]}] } } set d [expr {$d/double(($ntot*($ntot-1)/2.))}] set dist [expr {exp(-1.*$d/2.)*100.}] # Standardise scores set ntot [set CpB(ntot,$i)] set ns [set CpB(ns,$i)] set ColScore($i) [expr {$dist*exp(-10.0*($ntot-$ns)/$ntot)}] } for {set i 0} {$i < $Ltot} {incr i} { set winscore($i) 0.0 } set half_win [expr {$score_win / 2}] if {$half_win == 0} {set half_win 1} for {set i 0} {$i < ($half_win+1) && $i < $Ltot} {incr i} { for {set j 0} {$j < $half_win} {incr j} { set ij [expr {$i+$j}] set winscore($i) [expr {[set winscore($i)] + [set ColScore($ij)]}] } set winscore($i) [expr {[set winscore($i)]/$score_win}] if {[set winscore($i)] > 100} { set winscore($i) 100 } if {[set CpB(ns,$i)] < [set CpB(ntot,$i)]/2.0} { set winscore($i) 0.0 } } for {set i 0} {($i+$score_win) < $Ltot} {incr i} { set ih [expr {$i+$half_win}] for {set j 0} {$j < $score_win} {incr j} { set ij [expr {$i+$j}] set winscore($ih) [expr {[set winscore($ih)] + [set ColScore($ij)]}] } set winscore($ih) [expr {[set winscore($ih)]/$score_win}] if {[set winscore($ih)] > 100} { set winscore($ih) 100 } if {[set CpB(ns,$ih)] < [set CpB(ntot,$ih)]/2.0} { set winscore($ih) 0.0 } } for {set i [expr {$Ltot-$score_win}]} {($i+$half_win) < $Ltot} {incr i} { set ih [expr {$i+$half_win}] for {set j 0} {$j < $half_win} {incr j} { set ij [expr {$i+$j}] set winscore($ih) [expr {[set winscore($ih)] + [set ColScore($ij)]}] } set winscore($ih) [expr {[set winscore($ih)]/$score_win}] if {[set winscore($ih)] > 100} { set winscore($ih) 100 } if {[set CpB(ns,$ih)] < [set CpB(ntot,$ih)]/2.0} { set winscore($ih) 0 } } if {$grp eq "GroupeToutLeMonde" && $conserved > 1.0} { for {set i 0} {$i < $Ltot} {incr i} { if {[set CpB(ns,$i)] < $nseqs*($conserved - 1.0)} { set winscore($i) 0 } } } elseif {$conserved > 0.} { for {set i 0} {$i < $Ltot} {incr i} { if {$grp eq "GroupeToutLeMonde"} { if {[set CpB(ns,$i)] < [set CpB(ntot,$i)]*$conserved} { set winscore($i) 0 } } else { if {[set CpB(ns,$i)] != 0 && ([set CpB(ns,$i)] < [set CpB(ntot,$i)]*$conserved || [set CpB(ntot,$i)] < $nseqs*$conserved)} { set winscore($i) 0 } } } } foreach k [lsort -integer [array names winscore]] { puts "ITEM $k [set winscore($k)]" } return [array get winscore] } proc canalSqlAssemblyDb {} { # pour mon pc # set pgHost 130.79.79.89 # set pgDb assembly # set pgUser alvinella # set pgPass bdp67fr set pgHost [LbgiUrl] set pgDb assembly set pgUser alvinella set pgPass 7tytOpnA97 # set pgUser mouse # set pgPass 2Mqlv3v17G return [CanalSql "host=$pgHost dbname=$pgDb user=$pgUser password=$pgPass"] } proc canid {} { set w .c pack [canvas .c -width 500 -height 500 -background SlateGrey] set idx 0 for {set i 0} {$i < 50} {incr i} { set x1 [expr {$i*10}] set x2 [expr {($i+1)*10-1}] for {set j 0} {$j < 50} {incr j} { set y1 [expr {$j*10}] set y2 [expr {($j+1)*10-1}] $w create rectangle $x1 $y1 $x2 $y2 -fill blue -tags [list R$idx toto] incr idx } } set Ls [$w find withtag toto] foreach e $Ls {lappend Lt "R$e"} puts "with toto [llength $Ls]" $w dtag "\{[join $Ls ||]\}" toto update puts "verif ids [llength [$w find withtag toto]]" $w dtag "\{[join $Lt ||]\}" toto update puts "verif tag [llength [$w find withtag toto]]" $w itemconfig "[join $Lt ||]" -fill green return } proc canva2png {K FilePNG} { set FilePS "$FilePNG.ps" set Width [$K cget -width ] set Height [$K cget -height] canva2ps $K $FilePS $Width $Height return [ps2png $FilePS $FilePNG $Width $Height] } proc canva2ps {K {FilePS ""} {Width ""} {Height ""}} { if {$Width != ""} {set Width [$K cget -width ]} if {$Height != ""} {set Height [$K cget -height]} set TextPostScript [$K postscript -width $Width -height $Height -x 0 -y 0 -pageanchor center -pagewidth $Width -pageheight $Height -pagex [expr $Width * 1.0 / 2] -pagey [expr $Height * 1.0 / 2]] if {$FilePS != ""} {Sauve $TextPostScript dans $FilePS} return $TextPostScript } proc cava {} { return [CaVa] } proc cboot {} { package require tcc tcc::ccode doboot {char** seqs} char** { int i for (i==0;i<;i++) { pil[i]= } } return } proc cgncbi {} { if {0} { set url "http://ftp.ncbi.nlm.nih.gov/genomes/GENOME_REPORTS/eukaryotes.txt" set euk [HttpCopy $url] set o [open eukaryotes.txt w] puts $o $euk close $o set url "http://ftp.ncbi.nlm.nih.gov/genomes/GENOME_REPORTS/prokaryotes.txt" set pro [HttpCopy $url] set o [open prokaryotes.txt w] puts $o $pro close $o set Le [split $euk \n] set Lp [split $pro \n] } else { set Le [LesLignesDuFichier eukaryotes.txt] set Lp [LesLignesDuFichier prokaryotes.txt] } set Lce [split [lindex $Le 0] \t] set Lcp [split [lindex $Lp 0] \t] puts "And" puts "[land $Lce $Lcp]" puts "from euk" puts "[lor $Lce $Lcp from1]" puts "rom pro" puts "[lor $Lce $Lcp from2]" set Lins [list] # PROKARYOTES processing # --- set nbchrom 0 ; set nborganels 0 ; set nbplasmid 0 foreach l $Lp { if {$l eq "" || [string index $l 0] eq "#"} { continue } set Lv [split $l \t] lassign $Lv Name TaxID bioprojacc bioprojid group subgroup size gcpc chromrefseq chrominsdc plasmidrefseq plasmidinsdc wgs scaffolds genes proteins reldate moddate status center biosampleacc assemblyacc reference ftppath pubmedid set assacc [lindex $Lv end-3] set Lv [lreplace $Lv end-3 end-3] set Lv [linsert $Lv 8 $assacc $nbchrom] set Lv [linsert $Lv 12 $nbplasmid] set Lv [linsert $Lv 15 $nborganels] lappend Lins $Lv } set p1 [lindex $Lins 67] # EUKARYOTES processing # -- set chromrefseq "-" ; set chrominsdc "-" set plamidrefseq "-" ; set plasmidinsdc "-" set ftppath "-" ; set pubmedid "-" ; set reference "-" foreach l $Le { if {[string index $l 0] eq "#"} { continue } set Lv [split $l \t] lassign $Lv Name TaxID bioprojacc bioprojid group subgroup size gcpc assemblyacc nbchrom nborganels nbplasmid wgs scaffolds genes proteins reldate moddate status center biosampleacc set nborganels [lindex $Lv 10] set Lv [lreplace $Lv 10 10] set Lv [linsert $Lv end $reference $ftppath $pubmedid] set Lv [linsert $Lv 10 $chromrefseq $chrominsdc] set Lv [linsert $Lv 13 $plasmidrefseq $plasmidinsdc $nborganels] lappend Lins $Lv } puts "" set e1 [lindex $Lins end-67] puts "" foreach a $p1 b $e1 { puts "$a ||| $b" } exit } proc changeColorSpace {space P} { global label1 label2 label3 if {$space == "rgb"} { set label1 Red set label2 Green set label3 Blue tc_setScales $P return } if {$space == "cmy"} { set label1 Cyan set label2 Magenta set label3 Yellow tc_setScales $P return } if {$space == "hsb"} { set label1 Hue set label2 Saturation set label3 Brightness tc_setScales $P return } } proc changeFontSize {font direction} { set size [font configure $font -size] if {$direction == "+"} { incr size 2 } else { incr size -2 } font configure $font -size $size } proc chcb {} { package require Tk ChangeTkOptions toplevel .t set val [list msldkfj sldfj sdklfjskdf sldmkfjslfj] ttk::combobox .t.c -style vdx.TCombobox -state readonly -values $val -width 12 grid .t.c -row 0 -column 0 -padx 20 -pady 20 .t.c current 0 set ::var 0 tkwait variable var return } proc checkBlast {disque projet {nomRepBlast ""} {prefix ""}} { set Prob 0 set count 0 foreach elt [ListeDesPABs2] { if {(![file exists "/genomics/$disque/$projet/$nomRepBlast/$elt"]) & $nomRepBlast!=""} { puts "$elt absent (blast)" set Prob 1 } if {![file exists "/genomics/$disque/$projet/prottfa/$elt"]} { puts "$elt absent (prottfa)" set Prob 1 } incr count } if {!$Prob} {puts "aucuns problèmes"} } proc cherchespeciaux {} { set FileCibles "/genomics/link/SafeAcne/FichiersInitiaux/KRZYZOSIAK_SummarizedList.csv" set LesLignesDuFichier [LesLignesDuFichier $FileCibles] foreach Ligne [lrange $LesLignesDuFichier 2 end] { set n -1 foreach Elmt [split $Ligne ";"] { incr n if {$n==1} { set Gn $Elmt if {[regexp "/" $Gn]} { Espionne "$Gn" set NvGn [lindex [split $Gn "/"] 0] Espionne "$NvGn" } set Gn [string trim $Gn] } } } } proc chkt {} { global db InitTaxDB set Lt [LesLignesDuFichier marie.tax] array set T [eFetchREST taxonomy $Lt] set LNotFound [list] set Lok [list] foreach id $Lt { if {[string trim $id] eq ""} {continue} if {! [info exists T($id,ScientificName)]} { lappend LNotFound $id continue } set Ln [split $T($id,ScientificName) " "] lappend Lgenre [lindex $Ln 0] lappend Lespece [lrange $Ln 0 1] lappend Lok $id } puts "Doublon [DonneDoublons $Lespece]" set Lgenre [lsort -unique $Lgenre] set Lespece [lsort -unique $Lespece] puts "Lt [llength $Lt]" puts "Lgenre [llength $Lgenre]" puts "Lespece [llength $Lespece]" puts "LNotFound $LNotFound" puts "Lok [llength $Lok]" exit } proc chooseCouple {} { global LNOrdali TAg NbSeq set iAg1 {} while {$iAg1 == {}} { set iSeq1 [expr {round(rand()*($NbSeq-1))}] set seq1 [lindex $LNOrdali $iSeq1] set iAg1 [expr {round(rand()*([llength $TAg($seq1)]-1))}] set Ag1 [lindex $TAg($seq1) $iAg1] if {! $TAg($Ag1,$seq1,active)} { set iAg1 {} } } # select seq 2 set iSeq2 [expr {round(rand()*($NbSeq - 1))}] while {$iSeq2 == $iSeq1} { set iSeq2 [expr {int(rand()*$::NbSeq)}] } set seq2 [lindex $LNOrdali $iSeq2] if {0} { set iAgn2 [expr {int(rand()*[llength $TAg($seq2)])}] set Ag2 [lindex $TAg($seq2) $iAgn2] while {! $TAg($Ag2,active)} { set iAgn2 [expr {int(rand()*[llength $TAg($seq2)])}] set Ag2 [lindex $TAg($seq2) $iAgn2] } } return [list $seq1 $Ag1 $seq2] } proc ck2 {} { parray ::TDesSeqnames puts [join [$::db eval {select pk_seqali, seqname from seqali}] \n] exit } proc ckdb {} { global db LNOrdali foreach n $LNOrdali { if {$n eq ""} {continue} set Lp [$db eval {select pk_seqinfo from seqinfo where access=$n}] if {[llength $Lp] == 1} { continue } lassign $Lp a b set L1 [$db eval {select * from seqinfo where pk_seqinfo=$a}] set L2 [$db eval {select * from seqinfo where pk_seqinfo=$b}] set pka [lindex $L1 0] set pkb [lindex $L2 0] set dif 0 puts "pka $pka pkb $pkb" foreach a [lrange $L1 1 end] b [lrange $L2 1 end] { if {$a ne $b} { puts "a= $a\nb= $b" set dif 1 } } # recupere seqali correspondant set Ls1 [$db eval {select * from seqali where pk_seqinfo=$pka}] set Ls2 [$db eval {select * from seqali where pk_seqinfo=$pkb}] if {$Ls1 == {}} { puts "$pka - $pkb : pas seqali pour A" continue } if {$Ls2 == {}} { puts "$pka - $pkb : pas seqali pour B" continue } set dif 0 foreach a [lrange $Ls1 2 end] b [lrange $Ls2 2 end] { if {$a ne $b} { puts "sa= $a\nsb= $b" set dif 1 } } } exit } proc cleanE {} { global TabSF #2cuz 2dxi Dis-bact_4 Discri foreach n [list "PDB_2dxi_A" "PDB_2cuz_A"] { puts "" puts "$n :" set Ld [set TabSF($n,Discri)] set Lb [set TabSF($n,Dis-bact_4)] set Li [list] set i 0 foreach fb [lsort -unique -index 1 -integer $Lb] { DecortiqueUneFeature $fb db fb cb sb nb set ya 0 foreach fd $Ld { DecortiqueUneFeature $fd dd fd cd sd nd if {($db >= $dd && $db <= $fd) && ($fb >= $dd && $fb <= $fd) } { set ya 1 } } puts " $db $fb $ya" if {! $ya} { lappend Li $i } incr i } set Li [lsort -integer -decreasing $Li] foreach i $Li { set Lb [lreplace $Lb $i $i] } set TabSF($n,Dis-bact_4) $Lb } return } proc cleanPhd {keepedSequence keepedRange phdFile keepStatus} { # we need lower case sequence set keepedSequence [string tolower $keepedSequence] # revert to saved if exists if {[file isfile "$phdFile.backup"]} { file rename -force "$phdFile.backup" $phdFile } # read the file array set phd [readPhd $phdFile] # build the sequence of phd file set phdSequence {} foreach callInfo $phd(dna) { lappend phdSequence [string index $callInfo 0] } set phdSequence [string tolower [join $phdSequence ""]] # only backup and modify if needed if {$keepedSequence ne $phdSequence && $keepStatus} { # only keep the specified range set phd(dna) [lrange $phd(dna) [lindex $keepedRange 0] [lindex $keepedRange 1]] # synchronize sequence letters for {set i 0} {$i < [llength $phd(dna)]} {incr i} { set callInfo [lindex $phd(dna) $i] set callInfo [string replace $callInfo 0 0 [string index $keepedSequence $i]] lset phd(dna) $i $callInfo } # modify trim header for {set i 0} {$i < [llength $phd(comment)]} {incr i} { set headerProperty [lindex $phd(comment) $i] if {[regexp -nocase {^trim:} $headerProperty]} { lset phd(comment) $i "TRIM: 0 [expr [llength $phd(dna)] - 1] -1.00" break } } # do a backup file rename $phdFile "$phdFile.backup" # write the cleaned phd writePhd [array get phd] $phdFile } } proc cleanScf {phdFile scfFile} { # revert to saved if exists if {[file isfile "$scfFile.backup"]} { file rename -force "$scfFile.backup" $scfFile } if {[file isfile $phdFile] && [file isfile $scfFile]} { # read files array set phd [readPhd $phdFile] array set scf [readScf $scfFile] # build the sequence of phd file set phdSequence {} foreach callInfo $phd(dna) { lappend phdSequence [string index $callInfo 0] } set phdSequence [string toupper [join $phdSequence ""]] # build the sequence of scf file set scfSequence [string toupper [join $scf(calledBases) ""]] # only modify if needed if {$phdSequence ne $scfSequence} { # do a backup file copy $scfFile "$scfFile.backup" # clear all calling informations lset scf(peakIdx) {} lset scf(probA) {} lset scf(probC) {} lset scf(probG) {} lset scf(probT) {} lset scf(calledBases) {} lset scf(probSub) {} lset scf(probIns) {} lset scf(probDel) {} # set calling informations base by base foreach callInfo $phd(dna) { regexp -nocase {([a-z]) [0-9]+ ([0-9]+)} $callInfo regMatch base peakIdx lappend scf(calledBases) [string toupper $base] lappend scf(peakIdx) $peakIdx lappend scf(probA) 0 lappend scf(probC) 0 lappend scf(probG) 0 lappend scf(probT) 0 lappend scf(probSub) 0 lappend scf(probIns) 0 lappend scf(probDel) 0 } # set the number of bases set scf(bases) [llength $scf(calledBases)] # clear left and rigth clippings set scf(basesLeftClip) 0 set scf(basesRightClip) [expr $scf(bases) - 1] # (samplesOffset don't change) # (basesOffset don't change) # set changed offsets set scf(commentsOffset) [expr $scf(basesOffset) + ($scf(bases) * 12)] set scf(privateOffset) [expr $scf(commentsOffset) + $scf(commentsSize)] # write the cleaned scf writeScf [array get scf] $scfFile # success !! remove backup file delete "$scfFile.backup" } } } proc clockSet {var} { global $var global maclock # set $var [clock format [clock seconds] -format %H-%M-%S] set maclock [clock format [clock seconds] -format %H-%M-%S] after 999 [list clockSet maclock] } proc clustalConvertForMacsimPourTous {{Repertoire ""}} { if {$Repertoire == ""} { set Repertoire [RepertoireDuGenome]/msf } set r [glob -directory $Repertoire *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } clustalConvertTestForMacsim $fichier FinPasTouche $f } } proc clustalConvertForpsiblast {fichier} { if { ! [file exists "alignClustal"]} { File mkdir alignClustal } set newRep [RepertoireDuGenome]/alignClustal/ set list [split $fichier "/"] set newFile $newRep[lindex $list [llength $list]-1] exec clustalw $fichier -convert -outfile=$newFile set ma_list [LesLignesDuFichier $newFile] set newList [lrange $ma_list 1 end] SauveLesLignes $newList dans $newFile } proc clustalConvertForpsiblastPourTous {{Repertoire ""}} { if {$Repertoire == ""} { set Repertoire [RepertoireDuGenome]/msf } set r [glob -directory $Repertoire *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } clustalConvertForpsiblast $fichier FinPasTouche $f } } proc clustalConvertTestForMacsim {fichier} { if { ! [file exists "alignFasta"]} { File mkdir alignFasta } set newRep [RepertoireDuGenome]/alignFasta/ set list [split $fichier "/"] set newFile $newRep[lindex $list [llength $list]-1] exec clustalw $fichier -convert -output=FASTA -outfile=$newFile #faut faire des duplications selon les cas qd rencontre un PUZquelque chose set ma_list [LesLignesDuFichier $newFile] set sauve "no" set newList {} set newSeq {} foreach Ligne $ma_list { if {$Ligne==">[lindex $list [llength $list]-1]"} { lappend newList $Ligne set sauve "yes" } elseif {$sauve eq "yes" && [regexp {^[^>].*} $Ligne]} { lappend newSeq $Ligne lappend newList $Ligne } elseif {$sauve eq "yes" && [regexp {^[>].*} $Ligne]} { set ma_list [LesLignesDuFichier [RepertoireDuGenome]/prottfa/[lindex $list [llength $list]-1]] set ID [lindex [split [lindex $ma_list 0] ] 1] lappend newList ">$ID" foreach l $newSeq { lappend newList "$l" } lappend newList "$Ligne" set sauve "no" } else { lappend newList $Ligne } } SauveLesLignes $newList dans $newFile } proc cmptf {} { for {set i 4} {$i <=9} {incr i} { set n [expr {[factorial1 10]/([factorial1 $i]*[factorial1 (10-$i)])}] puts "i=$i $n" } exit } proc coeursDispos {{min ""} {max ""}} { set perc [exec vmstat 1 2 | tail -1] set perc [lindex [regsub -all {\s+} $perc " "] 14] set np [expr $perc*[exec nproc]/100] if {$min != ""} { set np [expr max($np, $min)] } if {$max != ""} { set np [expr min($np, $max)] } return $np } proc coherenceParSelfBlastN {{minOverlap 200} {minIdentity 95} {ecritDansFichier 1}} { if { ! [file isdirectory [RepertoireDuGenome]/selfblastn] } { puts "pas de repertoire selfblastn" exit 1 } set listeDesBlastN [lsort -dictionary [glob [RepertoireDuGenome]/selfblastn/*]] set fichierSortie [RepertoireDuGenome]/fiches/coherenceParSelfBlastN set nombreBlastNAvecOverlap 0 if { $ecritDansFichier } { set fh [open $fichierSortie w] } # pour chaque blast foreach blastN $listeDesBlastN { puts "Analyse $blastN" set currentId [regsub {^.*/} $blastN {}] set overlappingHits {} DecortiqueBlast $blastN 0.001 "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lAli #pour chaque hit foreach banqueId $lBanqueId access $lAccess DE $lDE profil $lProfil PN $lPN ali $lAli { if { $banqueId eq $currentId } { foreach ligneAli $ali { # chope la taille de la query et prenant celle du subject si les IDs sont identiques if { [regexp -nocase {length = ([0-9]+)} $ligneAli regMatch queryLength] } { break } } } else { set queryBegin 0 set sbjctBegin 0 foreach ligneAli $ali { # chope la taille du hit regexp -nocase {length = ([0-9]+)} $ligneAli regMatch sbjctLength if { [regexp -nocase {score =} $ligneAli] && ($queryBegin != 0) } { # le premier HSP est deja traite, quitte la boucle break } elseif { [regexp -nocase {identities = ([0-9]+)/([0-9]+) \(([0-9]+)} $ligneAli regMatch identities overlap percentIdent] } { if { ($overlap < $minOverlap) || ($percentIdent < $minIdentity) } { # ca colle pas, pas besoin de continuer break } } elseif { [regexp -nocase {query[^0-9]*([0-9]+)[^0-9]*([0-9]+)} $ligneAli regMatch qLeft queryEnd] } { if { $queryBegin == 0 } { set queryBegin $qLeft } } elseif { [regexp -nocase {sbjct[^0-9]*([0-9]+)[^0-9]*([0-9]+)} $ligneAli regMatch sLeft sbjctEnd] } { if { $sbjctBegin == 0 } { set sbjctBegin $sLeft } } } # foreach ligneAli $ali # teste les conditions pour ce hit if { ($overlap >= $minOverlap) && ($percentIdent >= $minIdentity) } { # teste l'overlap des extremites (on s'accroche, car c'est plutot rigolo) set morceauQueryGaucheAlign [expr $queryBegin - 1] set morceauQueryDroiteAlign [expr $queryLength - $queryEnd] if { $sbjctBegin < $sbjctEnd } { set morceauSbjctGaucheAlign [expr $sbjctBegin - 1] set morceauSbjctDroiteAlign [expr $sbjctLength - $sbjctEnd] } else { set morceauSbjctGaucheAlign [expr $sbjctLength - $sbjctBegin] set morceauSbjctDroiteAlign [expr $sbjctEnd - 1] } # au moins un petit 'morceau' apres l'alignement de chaque cote if { ($morceauQueryGaucheAlign <= 10) || ($morceauSbjctGaucheAlign <= 10) } { if { ($morceauQueryDroiteAlign <= 10) || ($morceauSbjctDroiteAlign <= 10) } { # teste les 2 cas ou ca colle pas restants if { ($morceauQueryGaucheAlign <= 10) && ($morceauQueryDroiteAlign <= 10) && ($morceauSbjctGaucheAlign > 10) && ($morceauSbjctDroiteAlign > 10) } { # ne fait rien puts -nonewline {} } elseif { ($morceauSbjctGaucheAlign <= 10) && ($morceauSbjctDroiteAlign <= 10) && ($morceauQueryGaucheAlign > 10) && ($morceauQueryDroiteAlign > 10) } { # ne fait rien non plus puts -nonewline {} } else { # ok c'est bon lappend overlappingHits $banqueId } } } } } # else L.149 } # foreach banqueId $lBanqueId... puts $overlappingHits if { $ecritDansFichier } { puts $fh "${currentId}: [llength $overlappingHits] ends overlapping hits" if { [llength $overlappingHits] != 0 } { puts $fh "${currentId}: $overlappingHits" } flush $fh } if { [llength $overlappingHits] != 0 } { incr nombreBlastNAvecOverlap } } # foreach blastN $listeDesBlastN if { $ecritDansFichier } { close $fh } return $nombreBlastNAvecOverlap } proc comp {a b} { set La [LesLignesDuFichier $a] set Lb [LesLignesDuFichier $b] foreach s $La r $Lb { if {$s != $r} {puts $s} } exit } proc compIUPAC {IUPAC} { set tab [split $IUPAC ""] set compIUPAC "" foreach letter $tab { if {$letter == "A"} { append compIUPAC "T" } if {$letter == "T"} { append compIUPAC "A" } if {$letter == "C"} { append compIUPAC "G" } if {$letter == "G"} { append compIUPAC "C" } if {$letter == "V"} { append compIUPAC "B" } if {$letter == "B"} { append compIUPAC "V" } if {$letter == "D"} { append compIUPAC "H" } if {$letter == "H"} { append compIUPAC "D" } if {$letter == "R"} { append compIUPAC "Y" } if {$letter == "Y"} { append compIUPAC "R" } if {$letter == "S"} { append compIUPAC "S" } if {$letter == "W"} { append compIUPAC "W" } if {$letter == "M"} { append compIUPAC "K" } if {$letter == "K"} { append compIUPAC "M" } if {$letter == "N"} { append compIUPAC "N" } } return $compIUPAC; } proc compar {} { set i [lsearch $::LNOrdali "Smito_Homo.sapi"] set seq [lindex $::LSOrdali $i] set sdg [string map {. ""} $seq] DecortiqueUnTFA h.tfa Lh Sh set seh $Sh($Lh) if {$seh != $sdg} { ShowProtDiff seh sdg } set Lid Q9NP81 #set Lid [IDMapping P_REFSEQ_AC ACC NP_001139373] puts $Lid set Le [split [DbFetchGET uniprot $Lid] \n] DecortiqueLesLignesEMBL $Le id ac de gn os oc ox squ puts $squ if {$squ != $sdg} { ShowProtDiff squ sdg } puts "" lassign [NW $squ $sdg] nu ng ShowProtDiff nu ng exit } proc compareFeatures {a b} { array set ftA $a array set ftB $b set typeCmp [string compare $ftA(type) $ftB(type)] if {$typeCmp != 0} {return $typeCmp} if {$ftA(start) < $ftB(start)} { return -1 } elseif {$ftA(start) > $ftB(start)} { return 1 } return 0 } proc comparePDB {l1 lBest} { set toAdd 0 set x 0 if {$lBest == ""} { lappend lBest $l1 return $lBest } else { set lgl1 [expr [lindex $l1 1] - [lindex $l1 0]] foreach e $lBest { set lge [expr [lindex $e 1] - [lindex $e 0]] #determine le + long segment des 2 if {$lge > $lgl1} { set maxlg $lge } else { set maxlg $lgl1 } set diffLg [expr [expr abs($lgl1 - $lge)] / $maxlg.] # si l1 commence apres e if {[lindex $l1 0] > [lindex $e 0]} { #puts "l1 commence apres e" #si l1 finit avant e : empreinte incluse if {[lindex $l1 1] < [lindex $e 1]} { if {[lindex $e 2] > 0.3 && [lindex $l1 2] < 0.3} { return $lBest } if {[lindex $l1 2] > 0.3 && [lindex $e 2] < 0.3} { set lBest [lreplace $lBest $x $x $l1] return $lBest } elseif {[expr [lindex $l1 2] - [lindex $e 2]] > 0.2 && $diffLg < 0.1} { set lBest [lreplace $lBest $x $x $l1] return $lBest } else { #puts "l1 finit avant e, je bouge pas lbest" return $lBest } # sinon, si empreinte chevauchante a droite } elseif {[lindex $l1 0] < [lindex $e 1]} { #puts "chevauchement a droite" if {[lindex $e 2] > 0.3 && [lindex $l1 2] < 0.3} { return $lBest } if {[lindex $l1 2] > 0.3 && [lindex $e 2] < 0.3} { set lBest [lreplace $lBest $x $x $l1] return $lBest } #si + de 10% d'ecart entre les 2 identite if { [expr abs([lindex $l1 2] - [lindex $e 2])] > 0.1 } { #puts "+ 10% diff" #si l1 a le + grand % id, on remplace e par l1 if {[lindex $l1 2] > [lindex $e 2]} { #puts "c'est l1 le + grand, je remplace" set lBest [lreplace $lBest $x $x $l1] return $lBest # sinon, on garde e } else { #puts "c'est e le + grand, je garde" return $lBest } # si - de 10% id d'ecart, on prend le plus long } else { #puts "moins de 10% diff" # si l1 est le plus long, on remplace e par l1 if {$lgl1 > $lge} { #puts "le + gd est l1, je remplace" set lBest [lreplace $lBest $x $x $l1] return $lBest # sinon, on garde e } else { #puts "le + gd est e, je garde" return $lBest } } # sinon, empreinte a l'exterieur, on va voir les suivants } else { #puts "empreinte a l'ext, je vois avec les suivants" set toAdd 1 incr x #break continue } # si l1 commence avant e (chevauchante gauche, excluse ou e compris ds l1) } else { #si e est compris ds l1 if {[lindex $l1 1] >= [lindex $e 1]} { if {[lindex $e 2] > 0.3 && [lindex $l1 2] < 0.3} { return $lBest } if {[lindex $l1 2] > 0.3 && [lindex $e 2] < 0.3} { set lBest [lreplace $lBest $x $x $l1] return $lBest } elseif {[expr [lindex $e 2] - [lindex $l1 2]] > 0.2 && $diffLg < 0.1} { return $lBest } else { set lBest [lreplace $lBest $x $x $l1] return $lBest } # sinon, si empreinte a l'exterieur, on va voir les suivants } elseif {[lindex $l1 1] <= [lindex $e 0]} { #puts "l1 est a l'ext, je vois avec les suivants" set toAdd 1 #break incr x continue # sinon, si empreinte chevauchante gauche } else { if {[lindex $e 2] > 0.3 && [lindex $l1 2] < 0.3} { return $lBest } #puts "chevauchemant gauche" if {[lindex $l1 2] > 0.3 && [lindex $e 2] < 0.3} { set lBest [lreplace $lBest $x $x $l1] return $lBest } #si + de 10% d'ecart entre les 2 identites if { [expr abs([lindex $l1 2] - [lindex $e 2])] > 0.1 } { #puts "+ de 10% diff" #si l1 a le + grand % id, on remplace e par l1 if {[lindex $l1 2] > [lindex $e 2]} { #puts "l1 est mieux, je remplace" set lBest [lreplace $lBest $x $x $l1] return $lBest # sinon, on garde e } else { #puts "e est mieux, je garde" return $lBest } # si - de 10% id d'ecart, on prend le plus long } else { #puts "moins de 10% diff" # si l1 est le plus long, on remplace e par l1 if {$lgl1 > $lge} { #puts "l1 est + grand, je remplace" set lBest [lreplace $lBest $x $x $l1] return $lBest # sinon, on garde e } else { #puts "e est + grand, je garde" return $lBest } } } } incr x } } if {$toAdd == 1} { #puts "en fin de compte j'ajoute l1" lappend lBest $l1 } return $lBest } proc compcsv {} { set Lold [LesLignesDuFichier participants.csv_bak] set Lnew [LesLignesDuFichier participants.csv] set nbo 0 set nbn 0 foreach l $Lold { set ix [lsearch $Lnew $l] if {$ix == -1} { puts "NOT FOUND !" incr nbn continue } set Lnew [lreplace $Lnew $ix $ix] incr nbo update } #puts "[join $Lnew \n]" puts "nbo $nbo nbn $nbn" exit } proc comptNbOrtho {orthofile} { Espionne "Calcul le nombre d'orthologue" if { ! [file exists $orthofile]} { return 0 } set compteur 0 #Espionne "$orthofile" set Lignes [LesLignesDuFichier $orthofile] foreach ligne $Lignes { if {[regexp {^[>]} $ligne]} { set para [split $ligne ";"] if {[lindex $para 2] ne "NOTHING"} { incr compteur } } } return $compteur } proc computeCombinedScore {lScores} { set products 1.0 foreach score $lScores { set products [expr $products * (1.0 - double($score) / 1000.0)] } return [expr (1.0 - $products) * 1000.0] } proc computeConsensusFeature {identicalFeatures {popFraction 0.6}} { array set positionsCount {} foreach aFt $identicalFeatures { array unset ft array set ft $aFt for {set i $ft(start)} {$i <= $ft(stop)} {incr i} { if {[info exists positionsCount($i)]} { incr positionsCount($i) } else { set positionsCount($i) 1 } } } array unset ft array set ft [lindex $identicalFeatures 0] set ft(start) 0 set ft(stop) 0 set ft(note) [regsub -nocase {^PROP_} $ft(note) ""] set ft(note) [regsub -nocase {\s*PARTIAL\s*} $ft(note) " "] set ft(score) "0.0" foreach pos [lsort -integer [array names positionsCount]] { if {[expr double($positionsCount($pos)) / [llength $identicalFeatures]] >= $popFraction} { set ft(start) $pos break } } foreach pos [lsort -integer -decreasing [array names positionsCount]] { if {[expr double($positionsCount($pos)) / [llength $identicalFeatures]] >= $popFraction} { set ft(stop) $pos break } } return [array get ft] } proc consensusPosition {list {popToSelect 0.8}} { # Compte le nombre d'individus par élement foreach e $list { if {![info exists a($e)]} {set a($e) 1 } else {incr a($e)} } # Crée une liste triée set lCounts {} foreach e [array names a] { lappend lCounts [list $e $a($e)] } set lCounts [lsort -integer -decreasing -index 1 $lCounts] # Sélectionne à partir de l'élément qui à le + d'individus jusqu'à popToSelect % de population set selectedPop 0 set selectedElements {} foreach e $lCounts { set elem [lindex $e 0] set nb [lindex $e 1] for {set i 0} {$i < $nb} {incr i} {lappend selectedElements $elem} incr selectedPop $nb if {[expr double($selectedPop) / [llength $list]] >= $popToSelect} {break} } return [integersMeanCeil $selectedElements] } proc consensusQualityColoring {consensus basesQuality} { # Find segments of same base and store the result in t array array set t [runLengthCount $basesQuality] # Create a clean array to return array set returned {} set returned(count) $t(count) for {set i 1} {$i <= $t(count)} {incr i} { if {$t($i,value) < 33} { #Red set qualityColor 3 set qualityComment "Low quality \[0,33\[" } elseif {$t($i,value) < 66} { #Orange set qualityColor 1 set qualityComment "Medium quality \[33,66\[" } else { #LimeGreen set qualityColor 5 set qualityComment "High quality \[66,99\]" } set returned($i,ftype) $qualityComment set returned($i,fstart) [expr $t($i,start) + 1] set returned($i,fstop) [expr $t($i,stop) + 1] set returned($i,fscore) $t($i,value) set returned($i,fcolor) $qualityColor } return [array get returned] } proc console {args} { } proc copytt {} { set RepertoireSource "/genomics/link/EVI3Old/protembl" set RepertoireDestination "/genomics/link/EVI3/protembl" foreach F [glob -nocomplain "$RepertoireSource/*"] { puts $F File copy -force $F "$RepertoireDestination/." } } proc corbo {} { package require sqlite3 sqlite3 d /home/moumou/www/perso/books/books.sql set Lvoy [list a e i o u y] set Lcon [list b c d f g h j k l m n p q r s t v w x z] set Lpnpt [d eval {select pk_books,Nom,Prenom,Titre from books order by Nom}] puts "Nb books : [expr {[llength $Lpnpt]/4}]" set LToDel [list] foreach {pk nom pre tit} $Lpnpt { puts -nonewline "$nom | $pre | $tit :" set c4 0 foreach v {nom pre tit} { set $v [string tolower [set $v]] set nc 0 for {set i 0} {$i < [string length [set $v]]} {incr i} { if {[string index [set $v] $i] in $Lcon} { incr nc } else { set nc 0 } if {$nc == 3} { set c4 1 break } } if {$c4} { break } } puts " $c4" if {$c4} { update idletasks while {1} { gets stdin rep if {$rep eq "y" || $rep eq "n"} { break } } if {$rep eq "y"} { lappend LToDel $pk } } } if {$LToDel != {} } { d eval "delete from books where pk_books in ([join $LToDel ,])" } d close exit } proc cordis {} { global TabSF foreach k [array names TabSF "*,Dis-bact_4"] { foreach f [set TabSF($k)] { DecortiqueUneFeature $f dg fg c tmp note if {[regexp {^indel} $note]} {continue} lappend Lf [list $dg $fg $note] } } set Lf [lsort -unique -integer -index 0 $Lf] puts "[join $Lf \n]" return } proc corrdb {} { sqlite3 o bench_bak.sql o eval {begin transaction} set Lid [o eval {select pfamid from pfam}] set Lid [lsort -unique -dictionary $Lid] foreach i $Lid { set Lpk [o eval {select pk_pfam from pfam where pfamid=$i}] if {[llength $Lpk] < 2} { continue } set ppk [lindex $Lpk 0] set dpk [lindex $Lpk end] set Lv [o eval {select * from pfam where pk_pfam=$dpk}] lassign $Lv tmp tmp tmp nseqs lgt idm idsd o eval {update pfam set nseqs=$nseqs,idm=$idm,idsd=$idsd where pk_pfam=$ppk} } o eval {delete from residues} set Lo [LesLignesDuFichier tb.o] foreach l $Lo { if {[string trim $l] eq ""} {continue} set Lv [split $l " "] lassign $Lv pk pkp s g t o eval {insert into residues values ($pk,$pkp,$s,$g,$t)} } o eval {commit} exit } proc correspMSPHid {id} { set fic "/genomics/link/MS2PHdbEucaGridMarch08/listeCorresp" set LesLignes [LesLignesDuFichier $fic] set prefix [string range [lindex $LesLignes [lsearch -regexp $LesLignes $id]] 0 7] return $prefix } proc correspPosPdbQuery {pos seq1 seq2} { set posAli [CorrespSeqAli $seq1 $pos] set posSeq2 [CorrespAliSeq $seq2 $posAli] return $posSeq2 } proc correspondanceIndex {inputAceFile inputSingletsFile} { set prefix [PreFixe] set numerotation [FormatDesNumerosPourCollection] set correspFile [RepertoireDuGenome]/fiches/corresp.idx array set ace [readACEfile $inputAceFile] array set sing [readFasta $inputSingletsFile] set ORFnumber 1 set fh [open $correspFile w] foreach contigIdx $ace(index) { puts $fh [format "CO %s %s%${numerotation} %s" $ace($contigIdx,name) $prefix $ORFnumber $ace($contigIdx,reads)] foreach readIdx $ace($contigIdx,index) { puts $fh [format "RD %s %d" $ace($contigIdx,$readIdx,name) [getUnpaddedSequencePosition $ace($contigIdx,consensus) $ace($contigIdx,$readIdx,consensusPosition)]] } incr ORFnumber } foreach singIdx $sing(index) { puts $fh [format "SI %s %s%${numerotation}" $singIdx $prefix $ORFnumber] incr ORFnumber } close $fh } proc correspondanceIndexOld {inputAceFile inputSingletsFile} { set prefix [PreFixe] set numerotation [FormatDesNumerosPourCollection] set correspFile [RepertoireDuGenome]/fiches/corresp.idx array set ace [readACEfile $inputAceFile] array set sing [readFasta $inputSingletsFile] set ORFnumber 1 set fh [open $correspFile w] foreach contigIdx $ace(index) { puts $fh [format "CO %s %s%${numerotation}" $ace($contigIdx,name) $prefix $ORFnumber] foreach readIdx $ace($contigIdx,index) { puts $fh [format "RD %s" $ace($contigIdx,$readIdx,name)] } incr ORFnumber } foreach singIdx $sing(index) { puts $fh [format "SI %s %s%${numerotation}" $singIdx $prefix $ORFnumber] incr ORFnumber } close $fh } proc corrigefichierjumeauxtemp {Fichier266 FichierJum} { foreach Ligne [LesLignesDuFichier $Fichier266] { if {$Ligne==""} {continue} set Vu($Ligne) 1 } foreach Ligne [LesLignesDuFichier $FichierJum] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set V 0 foreach Jumeau $LesJumeaux { if {[info exists Vu($Jumeau)]} { #Espionne $Ligne set V 1; break } } if {$V==0} {lappend Liste $Ligne} } Espionne [llength $Liste] SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/929" } proc corrmod {} { global TabSF LNOrdali Defauts set f [file tail [set Defauts(FichierXML)]] set root [file rootname [set Defauts(FichierXML)]] set sys [string range $f 0 [string first "_" $f]-1] set hmt "${sys}mito_Homo.sapi" foreach sqn $LNOrdali { if {$sqn eq ""} {continue} set Lnew [list] set Lft [set TabSF($sqn,MODULE)] foreach ft $Lft { DecortiqueUneFeature $ft d f col sc note csys if {$note ne "Putative_MTS"} { lappend Lnew $ft continue } if {$sqn eq $hmt} { lappend Lnew $ft } } set TabSF($sqn,MODULE) $Lnew } SauveLAlignement XML "${root}_corr.xml" exit } proc corrrna {} { LitLeTFA 250_rna.tfa Ln Sq set lmax -999 foreach n $Ln { set s [set Sq($n)] set l [string length $s] #set s [string map [list "." ""] $s] lappend Ls $s lappend Ll $l } puts "[DenombreLaListe $Ll]" #EcritLeTfa 250_rna_deg.tfa $Ln $Ls set f [open 250_nrna.tfa w] foreach n $Ln s $Ls { set s [string map [list "." "-"] $s] puts $f ">$n" puts $f $s } close $f exit } proc corrx2 {} { set L [LesLignesDuFichier DARS2_DARS_uniprot.xml2] set Li [lsearch -all -regexp $L "PROP_PF01336_tRNA_anti_from_B3MK45"] foreach i [lsort -integer -decreasing $Li] { set L [lreplace $L $i-6 $i+1] } set o [open last.xml w] puts $o [join $L \n] close $o exit } proc createImageScView {} { #SchematicViewPourTous "" domain #SchematicViewPourTous "" domain "" position #SchematicViewPourTous "" pfam #SchematicViewPourTous "" pfam "" position #faire un test pour voir si PFAM&DOMAIN fonctionne... SchematicViewPourTous "" DomPfam SchematicViewPourTous "" DomPfam "" position ##fin du test SchematicViewPourTous "" koanno globulaire SchematicViewPourTous "" koanno globulaire position SchematicViewPourTous "" koanno Ronn_DR SchematicViewPourTous "" koanno Ronn_DR position SchematicViewPourTous "" koanno GlobPlot_Disorder SchematicViewPourTous "" koanno GlobPlot_Disorder position SchematicViewPourTous "" koanno FoldIndex_pds SchematicViewPourTous "" koanno FoldIndex_pds position SchematicViewPourTous "" pdb filtre SchematicViewPourTous "" pdb filtre position SchematicViewPourTousPDB SchematicViewPourTousPDB "" position } proc creeAliPir {pab lgEmpreinte pdb chn} { global DefautsPipe global PipeCollection global repModele global toAdd if {$PipeCollection} { set ficAli [file join $repModele "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.ali"] set ficScript [file join $repModele "model${pab}.py"] set ficPDB [file join $repModele "${pdb}.pdb"] } else { set ficAli "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.ali" set ficScript "model${pab}.py" set ficPDB "${pdb}.pdb" } set lgPDB [LesLignesDuFichier $ficPDB] set listAt [lsearch -all -regexp $lgPDB "^ATOM|^HETATM"] set pdbF [string trim [string range [lindex $lgPDB [lindex $listAt 0]] 22 25]] set pdbL [string trim [string range [lindex $lgPDB [lindex $listAt end]] 22 25]] set fs [open $ficScript w] puts $fs "from modeller import *\nfrom modeller.automodel import *\nenv = environ()\nenv.io.hetatm = True\na = automodel(env, alnfile='[file tail $ficAli]',knowns=('$pdb$chaine'), sequence='$pab', assess_methods=assess.normalized_dope)\na.starting_model = 1\na.ending_model = 5\na.make()\nok_models = filter(lambda x: x\['failure'\] is None, a.outputs)\nkey = 'Normalized DOPE score'\nok_models.sort(lambda a,b: cmp(a\[key\], b\[key\]))\ntry:\n\tm = ok_models\[0\]\n\tprint \"Top model: %s (Normalized DOPE score %.3f)\" % (m\['name'\], m\[key\])\nexcept IndexError:\n\tprint \"no 3D model created\"" close $fs set sqQueO [string range [lindex $lgEmpreinte 1] 8 end] set sqPDBO [string range [lindex $lgEmpreinte 2] 11 end] #regsub -all "X" $sqPDBO {-} sqPDBO regsub -all {\-} $sqQueO "" seqQueI set sqQueO [split $sqQueO ""] set sqPDBO [split $sqPDBO ""] # il ne faut integrer que la partie couverte de la query dans l'alignement PIR # on va chercher la 1er position a laquelle on a un lettre dans un PDB, ainsi que la derniere # on va ensuite travailler uniquement sur cet intervalle # ATTENTION : la sequence PDB dans .ali doit correspondre en tous points a celle du fichier pdb de reference # meme si la query s arrete avant, la totalite du PDB est alignee... set lidx [lsearch -regexp -all $sqPDBO {[A-Z]}] if {[llength $lidx] != 0} { set lidx [lsearch -regexp -all $sqPDBO {[A-Z]}] set idxD [lindex $lidx 0] set idxF [lindex $lidx end] set debQ [lrange $sqQueO 0 [expr $idxD - 1]] set nbDec [llength [lsearch -regexp -all $debQ {[A-Z]}]] set sqQueO [lrange $sqQueO $idxD $idxF] set sqPDBO [lrange $sqPDBO $idxD $idxF] set sqQue "" set sqPDB "" set sqM [creePDBAvecX $pdb ${pdb}_$chn 0] set lPosH [lsearch -all $sqM "."] set posPDB 0 foreach q $sqQueO p $sqPDBO { if {$q eq "-" && $p eq "-"} { continue } elseif {$q eq "-" && $p eq "X"} { continue } else { append sqQue $q if {$p ne "-" && [lsearch $lPosH $posPDB] != -1} { append sqPDB "." incr posPDB } elseif {$p eq "X"} { append sqPDB "-" incr posPDB } else { append sqPDB $p if {$p ne "-"} { incr posPDB } } } } regsub -all {\-} $sqQue "" sqQQ set sqQlength [string length $sqQQ] if {$sqQlength == 0} { return "noAli" } set fa [open $ficAli w] puts $fa ">P1;$pab\nsequence:${pab}:[expr 1 + $nbDec]:${chn}:[expr $sqQlength + $nbDec]::::-1.00:-1.00" set identity 0 lappend toAdd "FIRST_1=[expr 1 + $nbDec]" lappend toAdd "END_1=[expr $sqQlength + $nbDec]" lappend toAdd "SPECIES_1=Human" lappend toAdd "FULL_SEQ_1=$seqQueI" lappend toAdd "ALL_TEMP_1=$pdb$chn" lappend toAdd "PDB_CODE_1=$pdb$chn" lappend toAdd "SOV=0.0" lappend toAdd "MODPROT_1=$sqQue" lappend toAdd "PDBPROT_1=$sqPDB" set i 0 while {$i < [string length $sqQue]} { puts $fa [string range $sqQue $i [expr $i + 59]] incr i 60 } puts $fa "*\n>P1;$pdb$chaine\nstructureX:${pdb}${chaine}:${pdbF}:${chn}:${pdbL}:::::-1.00" set i 0 while {$i < [string length $sqPDB]} { puts $fa [string range $sqPDB $i [expr $i + 59]] incr i 60 } puts $fa "*" close $fa return $nbDec } else { return "noAli" } } proc creeEmpPdb {pdb chn} { global DefautsPipe global PipeCollection global repModele if {$PipeCollection} { set ficTmp [file join $repModele "${pdb}.tmp"] set ficBirdQ [file join $repModele "rqBird.ql"] set ficPDB [file join $repModele "${pdb}.pdb"] } else { set ficTmp "${pdb}.tmp" set ficBirdQ "rqBird.ql" set ficPDB "${pdb}.pdb" } if {$chn eq ""} { set chaine "_" } else { set chaine $chn } # cree la requete birdb set fq [open $ficBirdQ w] puts $fq "ID $pdb DB PDB\nFM FLAT" close $fq set cmd "[BirdqlExe] $ficBirdQ > $ficTmp" catch {eval exec $cmd} if {[file exists $ficTmp]} { set LesLignes [LesLignesDuFichier $ficTmp] set fp [open $ficPDB w] set numX "-500" foreach lg $LesLignes { if {![regexp "^ATOM" $lg] && ![regexp "^TER" $lg] && ![regexp "^HETATM" $lg] } { puts $fp $lg } elseif {[string trim [string range $lg 20 21]] eq $chn} { set numY [string trim [string range $lg 22 26]] if {[regexp {[A-Z]} $numY]} { continue } elseif {$numX == -500} { puts $fp $lg set numX $numY } elseif {[expr abs ($numX)] != [expr abs ($numY)] && [string range $numX end-1 end] eq [string range $numY end-1 end]} { continue } else { puts $fp $lg set numX $numY } if {[regexp "^TER" $lg]} { puts $fp "END" break } } } close $fp return 1 } else { return 0 } } proc creeListeCorresp {file} { set lignes [LesLignesDuFichier $file] set long [llength $lignes] for {set i 0} {$i < $long} {incr i} { if {[regexp {^==>} [lindex $lignes $i]]} { puts "[string range [lindex $lignes $i] 4 11]\t[string range [lindex $lignes [expr $i + 1]] 1 6]" } } return 1 } proc creeListeMs2phAvecSynonymes {} { set file [file join [RepertoireDuGenome] "liste" "listeMs2ph"] set lMsphInit "" set lMsphComplete "" set lPab [ListeDesPABs] foreach pab $lPab { set fic [file join [RepertoireDuGenome] "prottfa" $pab] set lignes [LesLignesDuFichier $fic] set acc [string range [lindex $lignes 0] 1 end] lappend lMsphInit $acc } foreach msph $lMsphInit { set url "http://www.expasy.org/uniprot/$msph" set x [HttpCopy $url LesLignes] set lAccNum [recupUniprotListAccNum2 $LesLignes] lappend lMsphComplete $msph foreach syn $lAccNum { if {$syn != "None"} { lappend lMsphComplete $syn } } set lMsphCompletelHomol [lsort -uniq $lMsphComplete] } Espionne $lMsphCompletelHomol set l [llength $lMsphCompletelHomol] puts $l set f [open $file w] foreach e $lMsphCompletelHomol { puts $f $e } close $f return 1 } proc creeModeleSelonEmpreinte {ficEmpreinte} { # prend en entree un fichier empreinte global DefautsPipe global PipeCollection global repModele global toAdd set toAdd "" set pab [file rootname [file tail $ficEmpreinte]] set lgEmpreinte [LesLignesDuFichier $ficEmpreinte] set pdb [string range [lindex $lgEmpreinte 0] 6 9] set chn [string range [lindex $lgEmpreinte 0] 11 end] switch $chn { "aa" { set chn 1 } "ab" { set chn 2 } "a" { set chn "" } } if {$PipeCollection} { set repModele "[RepertoireDuGenome]/modeles3D/" set ficScript [file join $repModele "model$pab.py"] set ficLog [file join $repModele "model$pab.log"] set ficMod [file join $repModele "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.pdb"] set ficInfo [file join $repModele "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.info"] set ficAli [file join $repModele "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.ali"] } else { set repModele "" set ficScript "model$pab.py" set ficLog "model$pab.log" set ficMod "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.pdb" set ficInfo "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.info"] set ficAli "[string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.ali" } if {[file exists $ficMod]} { puts "modele [string range $pab 0 [expr [string first "_" $pab] - 1]]_${pdb}${chn}.pdb existe deja" return 0 } else { set toAdd "DBCODE_1=[string range $pab 0 5]_${pdb}${chn}" # creation du fichier PDB template utilise par modeller creeEmpPdb $pdb $chn # creation du fichier pab.ali qui va contenir alignement empreinte/query au format PIR # + creation du fichier de script model.py # en sorite de creeAliPir, on obtient le nombre de residu de decalage entre seqQuery et la parti qui a ete modelisee set decal [creeAliPir $pab $lgEmpreinte $pdb $chn] if {$decal eq "noAli"} { puts "default in alignment" return 0 } else { if {[file exists $ficScript]} { set cmd "[ModellerExe] $ficScript" catch {eval exec $cmd} message set message [split $message "\n"] # par defaut, 4 lignes de warning dans message... # si on a plus que ces 4 lignes, on affiche le message if {[llength $message] > 4} { puts "etape modelisation:" foreach lgM [lrange $message 4 end] { puts $lgM } } if {[glob -nocomplain "${pab}*.pdb"] != ""} { set lgFicLog [LesLignesDuFichier $ficLog] set idx [lsearch -regexp $lgFicLog "^Top model:"] if {$idx != -1} { set lgTopMod [lindex $lgFicLog $idx] puts "$lgTopMod" set bModel [string trim [string range $lgTopMod [expr [string first ":" $lgTopMod] + 1] [expr [string first "(" $lgTopMod] - 1]]] set ficBModel [string trim [string range $lgTopMod [expr [string first ":" $lgTopMod] + 1] [expr [string first "(" $lgTopMod] - 1]]] set dope [string trim [string range $lgTopMod [expr [string first "score" $lgTopMod] + 6] [expr [string last ")" $lgTopMod] - 1]]] # modification de la numerotation des residus dans le fichier PDB decaleFicModele $ficBModel $ficMod $decal $dope $chn set lfLog [LesLignesDuFichier $ficLog] set lIdx [lsearch -regexp -all $lfLog "^DOPE score"] set idx [lindex $lIdx [expr [string index $ficBModel end-4] - 1]] set lener [lindex $lfLog $idx] set ener [string trim [string range $lener [expr [string first ":" $lener] + 1] end]] set lgIdent [lindex [LesLignesDuFichier $ficMod] 3] set ident [string trim [string range $lgIdent [expr [string first ":" $lgIdent] + 1] end]] set toAdd [lreplace $toAdd 3 3 "IDENTITY_1=[string range $ident 0 [expr [string first "." $ident] - 1]]"] lappend toAdd "ENERGY_1=$ener" # efface les modeles temporaires cree par modeller foreach mod [glob -nocomplain "${pab}.*.pdb"] { catch {file delete -force $mod} } } set fI [open $ficInfo w] foreach add $toAdd { puts $fI $add } close $fI } else { puts "Modeller : no 3D model generated" } if {[file exists $ficScript]} { file delete -force $ficScript } if {[file exists $ficLog]} { file delete -force $ficLog } if {[file exists $ficAli]} { file delete -force $ficAli } } } return 1 } } proc creePDBAvecX {id1 id2 {het 1}} { set chain "" set MolId [string range $id1 0 3] set chain [string range [string trim $id2] 5 end] switch $chain { "" { set chain "a" } "aa" { set chain "1" } "ab" { set chain "2" } } global PDB_${MolId}_NomRes global PDB_${MolId}_NmrRes global PDB_${MolId}_TypAtm DecortiqueUnPDB $id1 $id2 set NmrRes [array get PDB_${MolId}_NmrRes] set NomRes [array get PDB_${MolId}_NomRes] set TypAtm [array get PDB_${MolId}_TypAtm] set idx [lsearch [set NmrRes] "$chain"] set numResidu [lindex [set NmrRes] [expr $idx + 1]] set nomResidu [lindex [set NomRes] [expr $idx + 1]] set atmTyp [lindex [set TypAtm] [expr $idx + 1]] set listeRes "" # first est la numerotation du 1er res (le premier qui finit par un entier) set first [lindex $numResidu [lsearch -regexp $numResidu {[[:digit:]]\M}]] #set nbT 0 puts $first set z [expr $first + 1] foreach x $numResidu y $nomResidu t $atmTyp { if {$y eq "XXX"} { set y "X" } set x [string trim $x] #pour gestion des insertions notees genre 28-28A-29 # on ne recupere pas le residu 28A dans ce cas # on continue le parsing if {[regexp {[A-Z]} $x]} { #lappend listeRes $y set a $x continue } # si on ne souhaite pas integrer les heteroatome # on met un "." dans la sequence... --> necessaire pour modeller if {$het == 0 && $t eq "HETA"} { set y "." } # pour gestion des insertions notees genre 28-328-29 # on ne recupere pas le residu 28A dans ce cas # on continue le parsing if {[expr abs ($x - $z)] > 100} { set lgX [string length $x] #if {[string index $a end] eq [string index $x end]} {} if {[string range $a end-[expr $lgX - 2] end] eq [string range $x end-[expr $lgX - 2] end]} { #set a $x continue } } if {[expr abs ($x - $z)] > 1000} { lappend listeRes $y set a $x continue } if {$x == [expr $z - 1]} { lappend listeRes $y incr z set a $x } else { if {$x == 1} { lappend listeRes $y incr z 2 set a $x } else { set i 0 while {$x != [expr $z - 1]} { if { $i > 500} { # si on se retrouve avec des insertion de plus de 500X # on considere qu il y a erreur dans la gestion du fichier # on retourne la liste des noms de residus de la chaine tel quel... return $nomResidu } lappend listeRes "X" incr i incr z } #puts "enfin ajoute $y" lappend listeRes $y incr z set a $x } } } foreach v [info globals "*${MolId}*"] { global $v catch {unset $v} } return $listeRes } proc creeRapportHTMLfromAli {{ficAli ""}} { LesDefauts if {$ficAli == ""} { puts "USAGE : creeRapportHTMLfromAli ficAli" puts "ficAli format : MSF, FASTA or MACSIMS" exit } if {[EstLeBonFormat $ficAli "XML"]} { set lAcc [getListAccGpFromMacsims $ficAli] } elseif {[EstLeBonFormat $ficAli "MSF"]} { DecortiqueUnMSF $ficAli lAcc Sequences } elseif {[EstLeBonFormat $ficAli "TFA"]} { DecortiqueUnTFA $ficAli lAcc Sequences } else { puts "Problem with the file format.\nficAli supported format : MSF, FASTA or MACSIMS\nPlease verify!" } set ficOut "[file tail ${ficAli}].report.html" set of [open $ficOut w] puts $of "\n\n\n\n\n" set gpAff 99 foreach acc $lAcc { set gp "" if {[regexp "_gp" $acc]} { set gp [string range $acc [expr [string last "_" $acc] + 3] end] set acc [string range $acc 0 [expr [string last "_" $acc] - 1]] } # set InfoAcc [recupInfoBirdF $acc] set InfoAcc [recupInfoBirdF [EnlevePrefixeBank $acc]] if {$InfoAcc != ""} { set ID [lindex [lindex $InfoAcc 0] 1] set InfoAcc [lrange $InfoAcc 1 end] set def "" foreach lg $InfoAcc { if {[regexp "^DE" $lg]} { append def "[string trim [string range $lg 4 end]]
" } } set idxOS [lsearch -regexp $InfoAcc "^OS"] if {$idxOS != -1} { set lgOrga [lindex $InfoAcc $idxOS] set orga [string range $lgOrga 5 end] } if {$gp != "" && $gp != $gpAff} { puts $of "" set gpAff $gp } puts $of "" } else { if {$gp != "" && $gp != $gpAff} { puts $of "" set gpAff $gp } puts $of "" } } puts $of "

\n
Groupe ${gp}
$acc	${ID}	${def}	${orga}
Groupe ${gp}
$acc	no information	no information	no information

" close $of return 1 } proc csasql {} { set Ll [LesLignesDuFichier csa.sql] set out [open out.sql w] set tmp "" foreach l $Ll { set l [string trim $l] if {$l eq ""} {continue} regsub -all "`" $l "'" l append tmp "$l " if {[string index $l end] eq ";"} { puts $out $tmp set tmp "" } } close $out exit } proc ctcs {} { set s [string repeat "sldkjfljfsdfjsdfsdfqsffsldf" 1] proc sreg {s c} { return [regsub -all $c $s $c tmp] } proc sstm {s c} { return [expr {[string length $s]-[string length [string map [list $c ""] $s]]}] } puts "sreg [time {sreg $s a}]" puts "sstm [time {sreg $s a}]" exit } proc ctmp {} { set Ll [LesLignesDuFichier tmp.txt] foreach l [lsort $Ll] { set l [string range $l [string first "Sauvegarde/" $l]+11 end] set l [string trim $l] puts $l } exit } proc cube {} { set f [open /home/moumou/tmp/polyr/test2 w] for {set i 0} {$i < 5} {incr i} { for {set j 0} {$j < 5} {incr j} { for {set k 0} {$k < 5} {incr k} { if {($i == 0 || $i == 4) || ($j == 0 || $j == 4) || ($k == 0 || $k == 4)} { puts -nonewline $f 0 } else { puts -nonewline $f 5 } } } } close $f exit } proc dao {} { set pdbid 3kbu Structure create $pdbid set ok [$pdbid new 3kbu.pdb B] return } proc dbSize {B} { JeMeSignale if { ! [regexp "^/" $B]} { set B "/blast/$B" } set queue [file tail $B] set fichierTest "/home/joly/BlastTest/$queue.test.blast" if {[file exists $fichierTest]} { if {[regexp {([0-9\,]+) sequences} [ContenuDuFichier $fichierTest] Match NAV]} { regsub -all "\," $NAV "" N return $N } } else { if {[OuiOuNon "$fichierTest does not exist ... Do I create it ... It will take some time" 0]} { set fichierQuery "/home/joly/BlastTest/queryBidon.tfa" set creationBlast [monBlast $fichierQuery $fichierTest $B] set dbSize [dbSize $B] return $dbSize } else { return 0 } } return -2 set FicFormat "$B.formatdb.log" set total 0 if {[file exists $FicFormat]} { foreach Ligne [LesLignesDuFichier $FicFormat] { if {![regexp {Formatted ([0-9]+) sequences} $Ligne Match N]} {continue} incr total $N } return $total } set FicPal "$B.pal" Espionne $FicPal set total 0 if {[file exists $FicPal]} { set Dir [file dirname $FicPal] foreach Ligne [LesLignesDuFichier $FicPal] { if {![regexp {^DBLIST } $Ligne]} {continue} regsub -all {[ \t]+} $Ligne " " Ligne set LesMots [split $Ligne " "] foreach B [lrange $LesMots 1 end] { if {! [regexp "^/" $B]} { set B "$Dir/$B" } Espionne $B set N [dbSize $B] incr total $N Espionne $N } } return $total } } proc dblock {{len ""}} { global TColScore LNOrdali LSOrdali if {[TypeAli] eq "XML"} { set Lbornes [CoreBlocksDuXML] } else { set Lbornes [list 3 7 16 20] } if {$Lbornes == {}} { puts "Error ! No blocks in $::Defauts(FichierXML)" return [list] } array set ::Sref [array get Sequences] if {$len ne ""} { set ok [AlA "" -lenmotif $len] } else { set ok [AlA ""] } if {$ok == 0} { puts "Problem in AlA !" return 0 } set rep [AnalyseCoreBlocksAgent $Lbornes] return $rep #exit } proc dbmis {} { cd /home/moumou/dbmarie/ package require sqlite3 set db "rold" sqlite3 $db misypat.sql $db eval {alter table mutation add column comment TEXT} $db eval {vacuum} exit } proc ddl {} { for {set i 0} {$i < 100} {incr i} { set n [expr {round(100*rand())}] lappend L "Node-$n" } puts [time {lsort $L} 100] puts [time {lsort -dictionary $L} 100] exit } proc ddoc {} { set Ld [LesLignesDuFichier doc.txt] set Lt [LesLignesDuFichier tmp.txt] foreach l $Ld { set l [string trim $l] if {$l eq ""} {continue} lappend nd $l } foreach l $Lt { set l [string trim $l] if {$l eq ""} {continue} lappend nt $l } foreach d $nd t $nt { if {$d ne $t} { puts "doc :\n$d\ntmp :\n$t\n" } } exit } proc debB {} { set d toto sqlite3 $d bench.sql foreach {ar gp lgt} [$d eval {select args,gapthr,lgt from results where job='PF00001' order by gapthr}] { lassign [lindex $ar 0] tmp tmp mth puts "$lgt $gp $mth" } puts "" foreach {job ar cm pos} [$d eval {select job,args,cm,pos from results where cm='''secator''' and gapthr=0.1 order by job DESC}] { lassign [lindex $ar 0] tmp tmp mth puts "$job $mth $cm $pos" } exit } proc debcb {{f1 mlog} {f2 llog}} { set l1 [LesLignesDuFichier $f1] set l2 [LesLignesDuFichier $f2] foreach l $l1 { switch -regexp -- $l { {^DEBITEM } { set item [lindex [split $l " "] 1] } {^ITEM } { lappend T(1,$item) [lrange [split $l " "] 1 end] } } } foreach l $l2 { switch -regexp -- $l { {^DEBITEM } { set item [lindex [split $l " "] 1] lappend Litem $item } {^ITEM } { lappend T(2,$item) [lrange [split $l " "] 1 end] } } } set Litem [lsort -unique $Litem] foreach item $Litem { if {! [info exists T(1,$item)]} { puts "\nWARNING : $item n'existe pas dans $f1 !\n" continue } if {! [info exists T(2,$item)]} { puts "\nWARNING : $item n'existe pas dans $f2 !\n" continue } puts "item $item" set l1 [lsort [set T(1,$item)]] set l2 [lsort [set T(2,$item)]] #puts "l1 $l1" #puts "l2 $l2" #puts "lor [lor $l1 $l2]" puts "from1" puts "[join [lor $l1 $l2 from1] \n]" puts "from2" puts "[join [lor $l1 $l2 from2] \n]" puts "" } exit } proc decaleFicModele {ficModOri ficModFin decal dope chn} { set lgModel [LesLignesDuFichier $ficModOri] set of [open $ficModFin w] puts $of [lindex $lgModel 0] puts $of "REMARK 6 MODELLER NORMALIZED DOPE SCORE : $dope" foreach lg [lrange $lgModel 1 end] { if {[regexp "^ATOM" $lg]} { set posO [string trim [string range $lg 22 25]] set pos [expr $posO + $decal] switch [string length $pos] { 4 { set posF $chn$pos } 3 { set posF "$chn $pos" } 2 { set posF "$chn $pos"} default { set posF "$chn $pos" } } set lg [string replace $lg 21 25 $posF] } puts $of $lg } close $of return 1 } proc decode {file} { global debug if {! [catch {set f [open $file r]}]} { set l {} set decode 0 set encoding text set data {} while {! [eof $f]} { gets $f l set l $l if {! $decode} { if {! [string length $l]} { set decode 1 } elseif {[lindex [string map {\" {}} $l] 0] == "Content-Transfer-Encoding:"} { set encoding [lindex [string map {\" {}} $l] 1] } } else { set data "[set data]\n$l" } } seek $f 0 start close $f if {$decode && $encoding == "base64"} { set f [open $file w+] fconfigure $f -translation binary set data [base64::decode $data] puts -nonewline $f $data close $f } elseif {$decode} { set f [open $file w+] #fconfigure $f -translation binary #set data [base64::decode $data] puts -nonewline $f $data close $f } } } proc df {} { set db [InitTaxDB] set Ltmp [LesLignesDuFichier marie.tax] #set Ltmp [LesLignesDuFichier tax.txt] #set Ltmp [LesLignesDuFichier out_html.tax] set Lmar [list] foreach id $Ltmp { if {$id ne ""} { lappend Lmar $id } } #set L2 [LesLignesDuFichier sotol-taxids.csv] set L2 [LesLignesDuFichier out.tax] set Lsot [list] foreach l $L2 { set Lv [split $l "\t"] lappend Lsot [lindex $Lv 0] } puts "Lmar [llength $Lmar]" puts "Lsot [llength $Lsot]" set Land [land $Lmar $Lsot] puts "and [llength $Land]" set Lor [lor $Lmar $Lsot from1] puts "Lor [llength $Lor]" foreach nm [$db eval "select Name from taxonomy where taxid in ([join $Lor ,])"] { puts $nm } exit } proc diffMat {aA aB} { upvar $aA A $aB B set Laa {A C D E F G H I K L M N P Q R S T V W Y} set diff 0.0 ; set dp 0.0 set sa 0.0 ; set sb 0.0 foreach a $Laa { foreach b $Laa { if {$a eq $b} {continue} set diff [expr {$diff + $A($a,$b) - $B($a,$b)}] set dp [expr {$dp + abs($A($a,$b) - $B($a,$b))}] set sa [expr {$sa + $A($a,$b)}] set sb [expr {$sb + $B($a,$b)}] } } set diff [expr {$diff/2.}] set dp [expr {$dp/2.}] set sa [expr {$sa/2.}] set sb [expr {$sb/2.}] set fmt "%6.2f %6.2f" puts "diff [format $fmt $diff $dp]" puts "sum [format $fmt $sa $sb]" return } proc disp_string {} { global mol AtmPick AtomePique TypeRep Pck Cor # dont_use_light foreach a $AtmPick { if {$TypeRep eq "fildefer"} { lassign [set PDB_[set mol]_Labels($a)] text Lx } if {$TypeRep eq "benjilamalice"} { lassign [set Cor($a)] text Lx } lassign $Lx x y z # recup de la matrice de modelisation set mvmatrix [tcl3dVector GLdouble 16] glGetDoublev GL_MODELVIEW_MATRIX $mvmatrix set modmat [tcl3dVectorToList $mvmatrix 16] # recup de la matrice de projection set pjmatrix [tcl3dVector GLdouble 16] glGetDoublev GL_PROJECTION_MATRIX $pjmatrix set projmat [tcl3dVectorToList $pjmatrix 16] # Recup du viewport set viewmat [tcl3dVector GLint 4] glGetIntegerv GL_VIEWPORT $viewmat set viewport [tcl3dVectorToList $viewmat 4] # print the string glMatrixMode GL_MODELVIEW glPushMatrix glLoadIdentity set xa [expr {[lindex $modmat 0]*$x + [lindex $modmat 4]*$y + [lindex $modmat 8]*$z + [lindex $modmat 12]}] set ya [expr {[lindex $modmat 1]*$x + [lindex $modmat 5]*$y + [lindex $modmat 9]*$z + [lindex $modmat 13]}] set za [expr {[lindex $modmat 2]*$x + [lindex $modmat 6]*$y + [lindex $modmat 10]*$z + [lindex $modmat 14]}] glColor3f 0.0 1.0 0.0 glRasterPos3f $xa $ya $za printString $text glPopMatrix glFlush } return } proc distributionDesLongueursDesSequencesFichier {fichierTFA fichierSortieCSV {tailleClasse 10}} { if { $tailleClasse < 2 } { set tailleClasse 2 } array set tfa [readFasta $fichierTFA] array set distrib {} foreach index $tfa(index) { set sequence [join [lrange $tfa($index) 1 end] {}] set taille [string length $sequence] set classe [expr $taille / $tailleClasse] if { ! [info exists distrib($classe)] } { set distrib($classe) 1 } else { incr distrib($classe) } } foreach classe [lsort -integer [array names distrib]] { lappend classesCSV "\[[expr $classe * $tailleClasse]-[expr ($classe + 1) * $tailleClasse]\[" lappend distribCSV $distrib($classe) } set fh [open $fichierSortieCSV w] puts $fh [join $classesCSV {;}] puts $fh [join $distribCSV {;}] close $fh } proc distributionDuPourcentGCdesSequencesFichier {fichierTFA fichierSortieCSV {tailleClasse 10}} { if { $tailleClasse < 2 } { set tailleClasse 2 } elseif { $tailleClasse > 100 } { set tailleClasse 100 } array set tfa [readFasta $fichierTFA] array set distrib {} foreach index $tfa(index) { set sequence [join [lrange $tfa($index) 1 end] {}] set taille [string length $sequence] set nbGC [regexp -all -nocase {g|c} $sequence] set pourcentGC [expr int((double($nbGC) / $taille) * 100)] set classe [expr $pourcentGC / $tailleClasse] if { ! [info exists distrib($classe)] } { set distrib($classe) 1 } else { incr distrib($classe) } } foreach classe [lsort -integer [array names distrib]] { lappend classesCSV "\[[expr $classe * $tailleClasse]-[expr ($classe + 1) * $tailleClasse]\[" lappend distribCSV $distrib($classe) } set fh [open $fichierSortieCSV w] puts $fh [join $classesCSV {;}] puts $fh [join $distribCSV {;}] close $fh } proc dnic {} { set home [pwd] cd /home/moumou/ordali/Extensions/tclcluspack0.1/Linux-x86_64 set Lf [glob ../src/*.c] file copy -force {*}$Lf "[pwd]" puts "copy done ..." set warn [exec make] puts "make done ..." file copy -force libtclcluspack0.1.so /home/moumou/ordali/lib/tclcluspack0.1/. file copy -force libtclcluspack0.1.so /usr/local/ActiveTcl/lib/tclcluspack0.1/. cd $home package require tclcluspack set Ll [LesLignesDuFichier plantage.dat] set Lval [list] foreach l $Ll { lassign [split $l "\t"] idx v lappend Lval [list $idx $v] } set Lgr [Tclcluspack $Lval -dt coordinates -cm mm -nbc aic -wc] puts "nb cl [llength $Lgr]" set i 0 foreach gr $Lgr { puts "gr $i [llength $gr]\n[join $gr \n]" } exit } proc do {body keyword expression} { if {$keyword eq "while"} { set expression "!($expression)" } elseif {$keyword ne "until"} { return -code error "unknown keyword \"$keyword\": must be until or while" } set condition [list expr $expression] while 1 { uplevel 1 $body if {[uplevel 1 $condition]} { break } } return } proc dont_use_light {} { global pgl # glDisable GL_COLOR_MATERIAL return glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR [list 0.0 0.0 0.0 1.0] glMaterialfv GL_FRONT_AND_BACK GL_DIFFUSE [list 0.0 0.0 0.0 1.0] # glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR [list 0.0 0.0 0.0 1.0] # glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT [list 0.0 0.0 0.0 1.0] # next calls to glColor will affect GL_AMBIENT composante #glColorMaterial GL_FRONT_AND_BACK GL_AMBIENT glColorMaterial GL_FRONT GL_AMBIENT glColorMaterial GL_FRONT GL_SPECULAR return } proc dosvg {} { global WOrdali ChangeMode arbres tkwait window $WOrdali(Tree,SelectAll) update idletasks $WOrdali(Tree,SelectAll) invoke update idletasks WOrdali(Tree,Draw) invoke return } proc drna {} { LitLeTFA 250_rna.tfa Ln Sq set f [open 250_rna1l.tfa w] set i 1 foreach n $Ln { set s [string map [list "." ""] $Sq($n)] if {$s eq ""} { puts "$n vide" } set l [string length $s] if {$l%3} { puts "$n $l [expr {$l%3}]" } puts $f ">seqn$i" puts $f $s incr i #lappend Ls [string map [list "." ""] [set Sq($n)]] } close $f LitLeTFA 250_prot.tfa Lp Sp set f [open 250_prot1l.tfa w] set i 1 foreach p $Lp { set s [string map [list "." "-"] [set Sp($p)]] puts $f ">seq$i" puts $f $s incr i } close $f #EcritLeTfa 250_rna_deg.tfa $Ln $Ls exit } proc dumpstruct {} { global TabSF set n "PDB_1eov_A" set Lft [lsort -integer -index 1 [set TabSF(${n},STRUCT)]] puts "lgt [llength $Lft]" foreach f $Lft { DecortiqueUneFeature $f dg fg col sco no cs puts "$dg $fg $col" } return } proc eFch {str} { global TParser set type [lindex $TParser(S) end] switch $type { GBSeq_locus { set TParser(Id) $str lappend TParser(LId) $str } GBSeq_definition { set id [set TParser(Id)] set TParser($id,des) $str } GBSeq_taxonomy { set id [set TParser(Id)] set TParser($id,lineage) $str set phy [lindex [split $str ";"] 0] set TParser($id,phylum) $phy } GBSeq_organism { set id [set TParser(Id)] set TParser($id,organism) $str } } } proc eFed {name} { set ::TParser(S) [lrange $::TParser(S) 0 end-1] ;# pop } proc eFetchPeel {l} { global eFiLevel eFLval set eFiLevel 0 set eFLval [list] DoeFetchPeeling $l if {$eFLval != {} } { puts " : [join $Lval]" } unset eFLval eFiLevel return } proc eFetchProcessXML-SAX {Lxml} { global TParser unset -nocomplain TParse set p [expat -elementstartcommand eFst -characterdatacommand eFch -elementendcommand eFed ] if [catch {$p parse $Lxml} res] { puts "ERROR while parsing XML !" puts "$res" $p delete update return "" } $p delete update return [array get TParser] } proc eFetchProcessXML-tDOM {Lxml} { set Lfd [list taxonomy organism definition] set Id [dom parse $Lxml] set doc [$Id documentElement] foreach ns [$doc selectNodes //GBSeq] { set id [$ns selectNode //GBSeq_locus/string(.)] foreach fd $Lfd { set v [$ns selectnode //GBSeq_$fd/string(.)] set T($id,$fd) $v if {$fd eq taxonomy} { set lfd [lindex [split $lin ";"] 0] set T($id,phylum) $lfd } } } return [array get T] } proc eFetchREST {db Lid {what ""}} { # part of eUtils service from NCBI. # # the type and format of returning data depends on # the rettype (gb entry, cds sequence, ...) and # retmode value (asn.1, xml, txt ...) # rettype and retmode are defined in table # http://www.ncbi.nlm.nih.gov/books/NBK25499/table/chapter4.chapter4_table1/?report=objectonly if {$what eq ""} {set what "gb"} set url "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi" set db [string tolower $db] switch $db { "protein" { switch $what { "tiny" { set rettype fasta set retmode xml } "gb" { set rettype native #set rettype gb set retmode "" } "xml" { set rettype gb set retmode xml } default { set rettype "null" set retmode "null" } } } "nucleotide" { switch $what { "gb" { set rettype "gb" #set retmode "xml" set retmode "text" } "cds" { set rettype "fasta_cds_na" set retmode "text" } } } "taxonomy" { set rettype "null" set retmode "xml" } "pubmed" { set rettype "full" set retmode "xml" } "pmc" { set rettype "full" set retmode "null" } "genome" { set retmode "raw" #set rettype "gb" set rettype "" } } set paquets 200 set ni [expr {int([llength $Lid]/$paquets)+1}] for {set i 0} {$i < $ni} {incr i} { set d [expr {$i*$paquets}] set f [expr {($i+1)*$paquets-1}] set LidNow [lrange $Lid $d $f] if {$retmode ne ""} { set query [::http::formatQuery db $db id [join $LidNow ,] rettype $rettype retmode $retmode] } else { set query [::http::formatQuery db $db id [join $LidNow ,] rettype $rettype] } set ddb [HttpCopy $url "" $query] if {$ddb eq ""} { return "" } switch $db { "taxonomy" { lappend ret {*}[TaxonomyProcessXML $ddb $LidNow] } "pubmed" { lappend ret {*}[PubMedProcessXML $ddb $LidNow] } default { lappend ret $ddb } } } return $ret } proc eFetchSOAP {db Lid01} { # the eFetch SOAP service only returns XML data set xml [::WS::Client::DoRawCall eFetchSequenceService run_eFetch [list db $db id [join $Lid ,]]] return $xml } proc eFst {name atts} { global TParser lappend TParser(S) $name ;# push } proc eLinkProcess {Lxml what} { #puts "$Lxml" if {[catch {set RId [dom parse $Lxml]} Msg]} { puts "$Msg" puts "$Lxml" return ReDo } set doc [$RId documentElement] set Lid {} set Nerr [$doc selectNodes //eLinkResult/ERROR] if {$Nerr != {} } { set err [$Nerr selectNode string(.)] $RId delete if {[regexp {timed out} $err]} { return "ReDo" } else { return -1 } } set nid [lindex [$doc selectNodes //IdList/Id] 0] if {[$nid selectNode string(.)] == -1} { $RId delete return -1 } switch $what { "cross" { set Lnd [$doc selectNodes //LinkSetDb/Link/Id] } "ngb" { set lsd [lindex [$doc selectNodes //eLinkResult/LinkSet/LinkSetDb] 0] if {$lsd eq ""} { $RId delete return -1 } set Lnd [lrange [$lsd selectNodes ./Link/Id] 0 10] } } set Lid [list] foreach n $Lnd { lappend Lid [$n selectNode string(.)] } $RId delete update return $Lid } proc eLinkREST {dbfrom dbto Lid} { # Part of eUtils from NCBI # eLink only accepts GI numbers as input set url "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/elink.fcgi" set Paquet 200 set Lres [list] set ni [expr {int([llength $Lid]/$Paquet)+1}] for {set i 0} {$i < $ni} {incr i} { set d [expr {$i*$Paquet}] set f [expr {($i+1)*$Paquet-1}] set Ln [lrange $Lid $d $f] set cmd "" if {$dbfrom eq $dbto} { set cmd ncheck } else { set cmd acheck } # cmd $cmd set query [::http::formatQuery dbfrom $dbfrom db $dbto id [join $Ln ,]] set xml [HttpCopy $url "" $query] if {$dbfrom eq $dbto} { set rpro [eLinkProcess $xml ngb] } else { set rpro [eLinkProcess $xml cross] } if {$rpro == "ReDo"} { set Lres [eLinkREST $dbfrom $dbto $Lid] break } if {$rpro == -1} { puts "\nError in eLink !" } else { lappend Lres {*}$rpro } } return $Lres } proc eSearchProcessXML {Lxml} { set rep [list] set RId [dom parse $Lxml] set doc [$RId documentElement] set Lnid [$doc selectNodes //Id] if {$Lnid eq ""} { set rep "" } else { foreach n $Lnid { lappend rep [$n selectNode string(.)] } } $RId delete update return $rep } proc eSearchREST {db Lid} { # Part of eUtils from NCBI # eSearch returns a possible UID corresponding to # the entered term # db = protein nucleotide pubmed taxonomy # # proceed ONE By ONE !! # Returns a list in the same order as input. # Item not found remain unchanged in the output list if {$db ni [list protein nucleotide pubmed taxonomy]} { puts "Bad Database !" return "" } set url "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi" set Lres [list] foreach id $Lid { # version 2.0 set query [::http::formatQuery db $db retmax 1000 term $id] set ddb [HttpCopy $url "" $query] lappend Lres {*}[eSearchProcessXML $ddb] } if {$db eq "pubmed" && $Lres=={}} { return "" } set Lret [list] foreach id $Lid rs $Lres { if {$rs eq ""} { lappend Lret $id } else { lappend Lret $rs } } return $Lret } proc eSummaryProcess {Lsum {what all}} { set Ls [dict get $Lsum DocSum] foreach p $Ls { set id [lindex $p 1] set Lit [lindex $p 3] lassign [lindex $Lit 0] tmp T($id,acc) lassign [lindex $Lit 1] tmp T($id,def) lassign [lindex $Lit 2] tmp T($id,crs) } if {$what eq "all"} { return [array get T] } else { return [array get T *$what] } } proc eSummaryProcessXML {Lxml} { array set T [list] #Espionne "\neSummary\n$Lxml" set RId [dom parse $Lxml] set doc [$RId documentElement] foreach nd [$doc selectNodes //DocSum] { foreach nc [$nd childNodes] { if {[$nc nodeName] eq "Id"} { set id [$nc selectNode string(.)] } else { set t [$nc getAttribute Name unk] set v [$nc selectNode string(.)] set T($id,$t) $v } foreach dbn {refseq genbank embl} { set T($id,$dbn) "" } if {[info exists T($id,Extra)]} { set Lr [split [set T($id,Extra)] "|"] foreach pfx {ref gb emb} dbn {refseq genbank embl} { set i [lsearch $Lr $pfx] if {$i != -1} { set seqid [lindex $Lr $i+1] set T($id,$dbn) $seqid } } } if {[set T($id,refseq)] eq "" && [info exists T($id,Caption)]} { set T($id,refseq) [set T($id,Caption)] } } } $RId delete update return [array get T] } proc eSummaryREST {db Lid {GetXml ""}} { # Part of eUtils from NCBI # # ==> WARNING !!!! # ==> eSummary only accepts GI numbers # # db = protein nucleotide pubmed taxonomy # # proceed by 200 IDs batches set url "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi" set Lres [list] set Paquet 200 set ni [expr {int([llength $Lid]/$Paquet)+1}] set LesXml {} for {set i 0} {$i < $ni} {incr i} { set d [expr {$i*$Paquet}] set f [expr {($i+1)*$Paquet-1}] # version 2.0 set query [::http::formatQuery db $db id [lrange $Lid $d $f] retmax 1000] set ddb [HttpCopy $url "" $query] if {$GetXml=="GetXml"} { lappend LesXml $ddb continue } lappend Lres {*}[eSummaryProcessXML $ddb] } if {$GetXml=="GetXml"} { return $LesXml } return $Lres } proc eSummarySOAP {db Lid} { # eSummary with db=protein only accepts GI numbers # proceed by 200 ids batches set Lres [list] set i 0 set lg [llength $Lid] while {$i < $lg} { set Ln [lrange $Lid $i $i+199] set ddb [::eUtilsService::run_eSummary $db "" [join $Ln ,] "" "" "" "" ""] lappend Lres {*}[eSummaryProcess $ddb acc] incr i 200 } return $Lres } proc ecrireListeIsoforme {FichierSortie data} { set fo [open "$FichierSortie" w] dict for {taxid g} $data { foreach sg $g { puts $fo [[lindex $sg 0] get id] } } close $fo } proc ecrireLogIsoforme {Log data} { set fl [open "$Log" w] dict for {taxid g} $data { if {$taxid ne "unknown"} { foreach sg $g { if {[llength $sg] > 1} { puts $fl "[[lindex $sg 0] get id] has following isoforms:" } foreach h [lreplace $sg 0 0] { puts $fl " [$h get id]" } } } } close $fl } proc ecrireRapportIsoforme {Rapport data} { set f [open "$Rapport" w] puts -nonewline $f {

}
	dict for {taxid g} $data {
		puts $f "TaxId $taxid"
		foreach sg $g {
			set class ""
			if {$taxid ne "unknown" && [llength $sg] > 1} {
				set class "ref"
			}
			set i 0
	#for {set i 0} {$i<[$h getNbBlocks]} {incr i}
			foreach h $sg {
				set shortid [$h getShortid]
				puts -nonewline $f ""
				for {set i 0} {$i<[$h getNbBlocks]} {incr i} {
					puts $f "[format {%-20s} $shortid][string repeat " " [$h getOffset $i]][$h enleverTirets Subj $i]"
					set shortid " |"
				}
				puts -nonewline $f ""
				if {$taxid ne "unknown" && [llength $sg] > 1} {
					set class "iso"
				}
			}
		}
	}
	puts -nonewline $f {

} close $f } proc eft {} { set Lid [list Q55C99 xp_570076 SYDC_HUMAN P13368 ZP_01623730.1 YP_003326263.1 XP_001267188.1] array set T [InfosFromRefSeq $Lid] parray T exit } proc emptyStr {args} { return "" } proc enattendant {} { set Fichier "[RepertoireDuGenome]/transcriptomique/ConeSpe/ListeRMAExp2J15Cond" foreach Ligne [LesLignesDuFichier $Fichier] { set GeneName [AffyAnnoMG430 $Ligne "Gene_Symbol"] Espionne "$Ligne $GeneName" } } proc encoursClassement {{TypeDistri area1e6bp} {NbSeq 0} {Biais 1}} { #1 signifie que l'on veut classer en fonction du biais #0 non if {$TypeDistri=="area1e6bp"} { set FichierDistributionDesSeq "[RepertoireDuGenome]/Localisation/area1e6bp_Distribution" set FichierDistributionDesGenes "[HumanGenomeDir]/Localisation/Gene_area1e6bp_Distribution" } elseif {$TypeDistri=="area1e7bp"} { set FichierDistributionDesSeq "[RepertoireDuGenome]/Localisation/area1e7bp_Distribution" set FichierDistributionDesGenes "[HumanGenomeDir]/Localisation/Gene_area1e7bp_Distribution" } elseif {$TypeDistri=="chr"} { set FichierDistributionDesSeq "[RepertoireDuGenome]/Localisation/chr_Distribution" set FichierDistributionDesGenes "[HumanGenomeDir]/Localisation/Gene_chr_Distribution" } elseif {$TypeDistri=="ctg"} { set FichierDistributionDesSeq "[RepertoireDuGenome]/Localisation/ctg_Distribution" set FichierDistributionDesGenes "[HumanGenomeDir]/Localisation/Gene_ctg_Distribution" } elseif {$TypeDistri=="cyto"} { set FichierDistributionDesSeq "[RepertoireDuGenome]/Localisation/cyto_Distribution" set FichierDistributionDesGenes "[HumanGenomeDir]/Localisation/Gene_cyto_Distribution" } set ListeClassee {} set NbSeqTotal 0 set NbGenesTotal 0 foreach Ligne [LesLignesDuFichier $FichierDistributionDesGenes] { if {$TypeDistri=="chr"} { scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3 if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue} set NbGenesTotal [expr [expr $gene1+$gene2+$gene3]+$NbGenesTotal] } } foreach Ligne [LesLignesDuFichier $FichierDistributionDesSeq] { if {$TypeDistri=="chr"} { scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3 if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue} set NbSeqTotal [expr [expr $seq1+$seq2+$seq3+$seq4]+$NbSeqTotal] } } #Espionne $NbSeqTotal #Espionne $NbGenesTotal foreach Ligne [LesLignesDuFichier $Fichier] { scan $Ligne "%s %s %s %s %s %s %s %s %s" chro long seq1 seq2 seq3 seq4 gene1 gene2 gene3 if {$chro=="Chromosome" || $chro=="Total" || $chro=="Remaining"} {continue} set NseqChro [expr $seq1+$seq2+$seq3+$seq4] set NgenesChro [expr $gene1+$gene2+$gene3] set BiaisChromo [expr round((100*$NseqChro*$NbGenesTotal)/($NbSeqTotal*$NgenesChro))] #Espionne "$chro:$BiaisChromo" set Somme [expr $NseqChro+$BiaisChromo] lappend ListeClassee "$chro\t$NseqChro\t$BiaisChromo\t$Somme" } set ListeClassee [lsort -decreasing -index 3 -integer $ListeClassee] #set ListeClassee [lrange $ListeClassee 0 2] set ListeClassee [join $ListeClassee "\n"] set Titres "Chromo NSeq Skew Skew+Nseq\n" set Classement "$Titres$ListeClassee" Sauve $Classement dans "[GscopeDatabaseDir DDetAffy]/Classements/NbSeqPlusBiaisParChromo" } proc ensGtpUcscMouse {{Qui ""} {Quoi ""}} { global ensGtpUcscMouse if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists ensGtpUcscMouse($Qui,$Quoi)]} {return $ensGtpUcscMouse($Qui,$Quoi)} if {[info exists ensGtpUcscMouse("EstCharge")]} {return ""} set ensGtpUcscMouse("EstCharge") 1 set Fichier "/genomics/link/UCSCGenomes/Mus_musculus/database/ensGtp.txt" set LesLignes [LesLignesDuFichier $Fichier] set LesHeaders [list EnsGene EnsTran EnsProt] set ensGtpUcscMouse(ListOf,headers) $LesHeaders foreach Ligne $LesLignes { set LesMots [split $Ligne "\t"] set EnsGene [lindex $LesMots 0] set EnsTran [lindex $LesMots 1] set EnsProt [lindex $LesMots 2] lappend ensGtpUcscMouse(ListOf,EnsGene) $EnsGene lappend ensGtpUcscMouse($EnsGene,EnsTran) $EnsTran lappend ensGtpUcscMouse($EnsTran,EnsGene) $EnsGene lappend ensGtpUcscMouse($EnsGene,EnsProt) $EnsProt lappend ensGtpUcscMouse($EnsProt,EnsGene) $EnsGene lappend ensGtpUcscMouse($EnsTran,EnsProt) $EnsProt lappend ensGtpUcscMouse($EnsProt,EnsTran) $EnsTran } return [ensGtpUcscMouse $Qui $Quoi] } proc entryLimit {entry traceProc {init ""}} { if [string match {} [set var [$entry cget -textvariable]]] { return -code error "-textvariable not set for entry \"$entry\"" } if {[string compare $traceProc {}]} { ## TextVars are always considered global uplevel \#0 [list set $var $init] uplevel \#0 [list trace variable $var w $traceProc] if {[catch {uplevel \#0 [list set $var $init]} err]} { ## If this errors out, the $init value was bad, or ## something was wrong with the traceProc return -code error "an error was received setting the initial value of \"$var\" to \"$init\". Make sure the value is valid and the traceProc is functional:\n$err" } else { ## Do you really want to delete the trace when ## destroying the entry? #bind $entry [list + trace vdelete $var w $traceProc] return } } foreach p [uplevel \#0 [list trace vinfo $var]] { if {[string match w [lindex $p 0]]} { uplevel \#0 trace vdelete [list $var] $p } } } proc essai4994 {} { set RepEntree "[RepertoireDuGenome]/protemblRecupere" set FichierProtEmblRecupere "$RepEntree/EVI04994" set Nom [file tail $FichierProtEmblRecupere] puts $Nom set FichierProtTfa "[GscopeFile $Nom prottfaRecupere]" set FichierNucTfa "[GscopeFile $Nom nuctfa]" if {[FileExists $FichierProtTfa]} { continue } set LesLignesEMBL [LesLignesDuFichier $FichierProtEmblRecupere] Espionne $LesLignesEMBL } proc essai_AjouteLesDescriptions {FichierDomainesSpec FichierPFA100avecDes} { foreach Ligne [LesLignesDuFichier $FichierPFA100avecDes] { if {$Ligne==""} {continue} set Nom [lindex $Ligne 0] set PFAM [lindex $Ligne 2] set Des [lindex $Ligne 3] set DE($PFAM) $Des } foreach Ligne [LesLignesDuFichier $FichierDomainesSpec] { if {$Ligne==""} {continue} set PFAM [lindex $Ligne 0] if {[info exists DE($PFAM)]} {lappend L "$PFAM\t$DE($PFAM)"} } Espionne [llength $L] set L [lsort -index 1 -dictionary $L] SauveLesLignes $L dans "[RepertoireDuGenome]/fiches/DomainesSpecifAvecDes" } proc essai_SelectionFichierRequete {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set PFAM [lindex $Ligne 0] set NbSupp [lindex $Ligne 1] set NbPABs [lindex $Ligne 2] set S [expr $NbSupp + $NbPABs] set Percent [expr ($NbPABs*1.0)/$S] if {$NbSupp<$NbPABs && $Percent>0.5} {lappend LesPFAMSpecifiques $Ligne} } Espionne [llength $LesPFAMSpecifiques] set L [lsort -index 2 -integer $LesPFAMSpecifiques] SauveLesLignes $L dans "[RepertoireDuGenome]/fiches/Domaines-essai" } proc essaiarray {} { set liste {100 100 98 95 98 4 100 1 5 4} foreach elmt $liste { if {[info exists DejaVu($elmt)]} { incr DejaVu($elmt) continue } set DejaVu($elmt) 1 } array get DejaVu } proc essaidecortique {Texte} { set LesElmt {} set i 0 set oldi 0 #set i [string first "///" $Texte] #Espionne "++$i" while {[set i [string first "///" $Texte]]} { } } proc essaidix {} { set A 0; set B 0; set C 0; set D 0; set E 0; set G 0 foreach F [glob -nocomplain "[RepertoireDuGenome]/protemblRecupere/EVI*"] {incr A} foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaRecupere/EVI*"] {incr B} foreach F [glob -nocomplain "[RepertoireDuGenome]/protembl/EVI*"] {incr C} foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaBEST/EVI*"] {incr D} foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaBEST2/EVI*"] {incr E} foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfa/EVI*"] {incr G} puts "A= $A"; puts "B= $B"; puts "C= $C"; puts "D= $D"; puts "E= $E"; puts "G= $G" } proc essaireplace {} { set L [list a b c] Espionne $L set Lnew [lreplace $L 1 1 "toto"] Espionne $Lnew } proc essaitfarecupe {fichier NomSeq} { RecupereUnTFA $fichier $NomSeq os seq Espionne $fichier Espionne $NomSeq Espionne "os: $os" Espionne "seq: $seq" } proc essaitoto {} { set Liste [lrange [ListeDesPABs] 1164 end] set Rep "[RepertoireDuGenome]/mrnatfa_Homo_sapiens" foreach PAB $Liste { set File "$Rep/$PAB" if {[file exists $File]} { file copy -force $File "[RepertoireDuGenome]/Jumeaux/NewmRNAtfa" } } return "" } proc essaivingt {{Liste ""}} { set pls 0; set seul 0; set recupere 0 if {[EstUnPAB $Liste]} { set Liste [list $Liste] } if {$Liste==""} { set Liste [ListeDesPABs] } foreach Nom $Liste { set FichierProtEmblun "[GscopeFile $Nom protembl]_1" set FichierProtEmbldeux "[GscopeFile $Nom protembl]_2" set FichierProtEmblRecupere "[GscopeFile $Nom protemblRecupere]" if {[file exists $FichierProtEmblun] && [file exists $FichierProtEmbldeux]} {incr pls} if {[file exists $FichierProtEmblun] && ![file exists $FichierProtEmbldeux]} {incr seul} if {[file exists $FichierProtEmblRecupere]} {incr recupere} } puts "pls $pls" puts "seul $seul" puts "recupere $recupere" } proc euka {} { set Ll [LesLignesDuFichier euka.txt] foreach l $Ll { set Lv [split $l \t] set i 0 foreach v $Lv { lappend T($i) $v incr i } } foreach k [lsort -integer [array names T]] { puts "$k [llength [lsort -unique $T($k)]]" if {[lsearch $T($k) "*Scaffold*"] != -1} { puts "[lsort -unique $T($k)]" } } puts "" foreach n $T(0) t $T(1) s $T(18) { if {! [regexp -nocase "complete" $s]} { continue } lappend Lcomp [list $n $t $s] incr nCmp } puts "nCmp $nCmp" exit } proc extm {} { DecortiqueUnMSF BB11038.msf Ln Sq foreach n $Ln { set s $Sq($n) lappend Ls [string range $s 370 600] } EcritLeTfa court.tfa $Ln $Ls exit } proc extraitHomologuesMS2PH {} { global OuiOuNonToujoursParDefaut ; set OuiOuNonToujoursParDefaut 1 set repBlast "[RepertoireDuGenome]/blastp5000" set ficOut "listeHomol2" set lHomol "" set lPab [ListeDesPABs] foreach pab $lPab { puts $pab set bfile [file join $repBlast $pab] set LBlast [LesLignesDuFichier $bfile] #DecortiqueBlast $LBlast 0.001 5000 Query lBanqueId lAccess lDE lProfil lPN "LongDescription" DecortiqueBlast $LBlast 0.001 5000 Query lBanqueId lAccess foreach a [lrange $lAccess 0 end-1] b [lrange $lBanqueId 0 end-1] { if {![regexp {^PDB:} $b] && ![regexp {^VARSPLIC:} $b]} { lappend lHomol $a } } set lHomol [lsort -uniq $lHomol] } EspionneL $lHomol set f [open $ficOut w] foreach homol $lHomol { puts $f $homol } close $f return 1 } proc factorial1 {n} { expr {$n>1?$n*[factorial1 [expr {$n-1}]]:1} } proc factorial2 {n} { # n! = sqrt(2*pi)*n^(n+1/2)*e^-n return [expr {sqrt(2.*3.1415926)*pow($n,($n+0.5))*exp(-1.*$n)}] } proc fballs {} { global TFB LoadTkAndPackages # parametres set TFB(step) 5 set TFB(lenFourmi) 30 set TFB(widFourmi) 20 set TFB(headFourmi) 10 set TFB(colFourmi) white set TFB(nFourmis) 10 set TFB(rad) 10 set TFB(nRouges) 30 set TFB(nJaunes) 30 set TFB(nBleues) 20 set TFB(dimX) 1200 set TFB(dimY) 1000 set TFB(mur) 1 Plateau InitFourmis StartFourmis return } proc fillResAgentsDB {} { global dbR AlATables LesDefsAlA package require sqlite3 file delete res.sql set dbR [FabriqueDeTables $AlATables "" res.sql] $dbR eval {begin transaction} set Lout [lsort [glob /home/moumou/Agents/jobs/out*]] puts "out files [llength $Lout]" foreach f [lrange $Lout 0 end] { set Ll [LesLignesDuFichier $f] set Lres [lindex $Ll end] ResAnaBalAgents tmp tmp $Lres "" } $dbR eval {commit} $dbR close exit } proc finLaTrace {} { global ListeProc set ListeProc [lsort -unique $ListeProc] set f [open "touteslesprocs.tcl" w] foreach e $ListeProc { set a [info args $e] set b [info body $e] set sar "" foreach g $a { if {[info default $e $g Def]} { if {$Def == ""} { set Def "\"\"" } append sar "{$g $Def} " } else { append sar "$g " } } set sar [string trim $sar] puts $f $b puts $f "\}" puts $f "" } close $f return } proc firstef {Nom} { set FichierFEF "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_promoter/$Nom.firstef" set LeTexte {} if {[file exists $FichierFEF]} { lappend Letexte "" lappend LeTexte " **********************************************" lappend LeTexte " Promoter predicted from human mRNA full length:" lappend LeTexte "" #set ContenuFEF [ContenuDuFichier $FichierFEF] foreach Ligne [LesLignesDuFichier $FichierFEF] { lappend LeTexte " $Ligne" } lappend LeTexte "" } EspionneL $LeTexte } proc forceAlpha {name el op} { global $name ${name}_alpha if [string comp {} $el] { set old ${name}_alpha\($el) set name $name\($el) } else { set old ${name}_alpha } if ![regexp {^[a-zA-Z]*$} [set $name]] { set $name [set $old] bell; return } set $old [set $name] } proc forceInt {name el op} { global $name ${name}_int if [string comp {} $el] { set old ${name}_int\($el) set name $name\($el) } else { set old ${name}_int } if ![regexp {^[-+]?[0-9]*$} [set $name]] { set $name [set $old] bell; return } set $old [set $name] } proc forceLen {len name el op} { global $name ${name}_len if [string comp $el {}] { set old ${name}_len\($el) set name $name\($el) } else { set old ${name}_len } if {[string length [set $name]] > $len} { set $name [set $old] bell; return } set $old [set $name] } proc forceReal {name el op} { global $name ${name}_real if [string comp {} $el] { set old ${name}_real\($el) set name $name\($el) } else { set old ${name}_real } if ![regexp {^[-+]?[0-9]*\.?[0-9]*([0-9]\.?e[-+]?[0-9]*)?$} [set $name]] { set $name [set $old] bell; return } set $old [set $name] } proc forceRegexp {regexp name el op} { global $name ${name}_regexp if [string comp {} $el] { set old ${name}_regexp\($el) set name $name\($el) } else { set old ${name}_regexp } if ![regexp $regexp [set $name]] { set $name [set $old] bell; return } set $old [set $name] } proc forceValue {default name el op} { global $name if [string comp {} $el] { set name $name\($el) } if ![info exists $name] { set $name $default } } proc formatFasta {description sequence {lineWidth 50}} { if { ! [regexp {^>} $description] } { set description ">$description" } lappend tfa $description # au cas ou sequence est une liste set sequence [join $sequence ""] while {[string length $sequence] != 0} { lappend tfa [string range $sequence 0 [expr $lineWidth - 1]] set sequence [string replace $sequence 0 [expr $lineWidth - 1]] } return [join $tfa "\n"] } proc formatQualFasta {{description ""} {lQual ""} {lineWidth 50}} { if { ! [regexp {^>} $description] } { set description ">$description" } lappend tfa $description # au cas ou quality est une liste de listes set lQual [join $lQual " "] while {[llength $lQual] != 0} { lappend line [lindex $lQual 0] set lQual [lreplace $lQual 0 0] if {[string length [join $line]] >= $lineWidth || [llength $lQual] == 0} { if {[string length [join $line]] > $lineWidth} { set lQual [linsert $lQual 0 [lindex $line end]] set line [lreplace $line end end] } lappend tfa [join $line] lset line {} } } return [join $tfa "\n"] } proc frat {} { global TabSF Sequences Cons set Cons(PDB) 1 set Cons(Method) Threshold set Cons(Title) "" set Cons(OnlyGlobal) 1 set Cons(Entry) "" set Cons(ComboSel) "" LanceCalculConservation SauveConservation foreach k [array names TabSF "*,Cons*"] { #puts "$k" set n [lindex [split $k ,] 0] foreach f $TabSF($k) { DecortiqueUneFeature $f d f col sc nt if {$nt eq "IdenGlob"} { puts "[string index $Sequences($n) $d] $d $f $col $nt" } } } exit } proc gamma {x} { if {$x <= 0} { error "Invalid input" $x } # Split the function domain into three intervals: # (0, 0.001), [0.001, 12), and (12, infinity) ########################################################################### # First interval: (0, 0.001) # # For small x, 1/Gamma(x) has power series x + gamma x^2 - ... # So in this range, 1/Gamma(x) = x + gamma x^2 with error on the order of x^3. # The relative error over this interval is less than 6e-7. # Euler's gamma constant set gamma 0.577215664901532860606512090 if {$x < 0.001} { return [expr {1.0/($x*(1.0 + $gamma*$x))}] } ########################################################################### # Second interval: [0.001, 12) if {$x < 12.0} { # The algorithm directly approximates gamma over (1,2) and uses # reduction identities to reduce other arguments to this interval. set y $x set n 0 set arg_was_less_than_one [expr {$y < 1.0}] # Add or subtract integers as necessary to bring y into (1,2) # Will correct for this below if {$arg_was_less_than_one} { set y [expr {$y + 1.0}] } else { # will use n later set n [expr {entier($y) - 1}] set y [expr {$y - $n}] } # numerator coefficients for approximation over the interval (1,2) set p [list -1.71618513886549492533811E+0 2.47656508055759199108314E+1 -3.79804256470945635097577E+2 6.29331155312818442661052E+2 8.66966202790413211295064E+2 -3.14512729688483675254357E+4 -3.61444134186911729807069E+4 6.64561438202405440627855E+4 ] # denominator coefficients for approximation over the interval (1,2) set q [list -3.08402300119738975254353E+1 3.15350626979604161529144E+2 -1.01515636749021914166146E+3 -3.10777167157231109440444E+3 2.25381184209801510330112E+4 4.75584627752788110767815E+3 -1.34659959864969306392456E+5 -1.15132259675553483497211E+5 ] set num 0.0 set den 1.0 set z [expr {$y - 1}] for {set i 0} {$i < 8} {incr i} { set num [expr {($num + [lindex $p $i])*$z}] set den [expr {$den*$z + [lindex $q $i]}] } set result [expr {$num/$den + 1.0}] # Apply correction if argument was not initially in (1,2) if {$arg_was_less_than_one} { # Use identity gamma(z) = gamma(z+1)/z # The variable "result" now holds gamma of the original y + 1 # Thus we use y-1 to get back the orginal y. set result [expr {$result / ($y-1.0)}] } else { # Use the identity gamma(z+n) = z*(z+1)* ... *(z+n-1)*gamma(z) for {set i 0} {$i < $n} {incr i} { set result [expr {$result * $y}] set y [expr {$y + 1}] } } return $result } ########################################################################### # Third interval: [12, infinity) if {$x > 171.624} { # Correct answer too large to display. return 1.0/0 # float infinity } return [expr {exp([log_gamma $x])}] } proc gapQualityValues {seq qual} { for {set i 0} {$i < [string length $seq]} {incr i} { if {[string index $seq $i] eq "*"} { set qual [linsert $qual $i "*"] } } if {[string length $seq] != [llength $qual]} { puts "ERROR: gapped sequence length differs from gapped quality values length" exit 1 } return $qual } proc gcd {u v} { expr {$u? [gcd [expr $v%$u] $u]: $v} } proc generateXMLmacsim {aContig} { package require tdom upvar $aContig contig set xmlHeader "\n\n" # Create XML document and his root element 'macsim' dom createDocument macsim XMLdoc # Get the root element $XMLdoc documentElement root # Create the commands to build up the XML document dom createNodeCmd elementNode alignment dom createNodeCmd elementNode aln-name dom createNodeCmd elementNode sequence dom createNodeCmd elementNode seq-name dom createNodeCmd elementNode seq-info dom createNodeCmd elementNode ftable dom createNodeCmd elementNode fitem dom createNodeCmd elementNode ftype dom createNodeCmd elementNode fstart dom createNodeCmd elementNode fstop dom createNodeCmd elementNode fcolor dom createNodeCmd elementNode fscore dom createNodeCmd elementNode fnote dom createNodeCmd elementNode length dom createNodeCmd elementNode seq-data dom createNodeCmd elementNode sense dom createNodeCmd textNode t # Build the document $root appendFromScript { alignment { aln-name { t "$contig(alignmentName)_$contig(contigIdx)" } sequence {seq-type DNA} { seq-name { t $contig(name) } seq-info { array set feat {} array set feat [consensusQualityColoring $contig(consensus) $contig(basesQuality)] if {$feat(count) != 0} { ftable { for {set j 1} {$j <= $feat(count)} {incr j} { fitem { ftype { t $feat($j,ftype) } fstart { t $feat($j,fstart) } fstop { t $feat($j,fstop) } fcolor { t $feat($j,fcolor) } fscore { t $feat($j,fscore) } fnote { t "Phred quality: $feat($j,fscore)" } } } } } length { t $contig(length) } sense { if {$contig(strand) eq "U"} { t 1 } else { t -1 } } } seq-data { t $contig(consensus) } } foreach readIdx $contig(index) { sequence {seq-type DNA} { seq-name { t $contig($readIdx,name) } seq-info { ftable { fitem { ftype { t quality } fstart { t $contig($readIdx,qualityStart) } fstop { t $contig($readIdx,qualityEnd) } fcolor { # Orange t 1 } } fitem { ftype { t alignment } fstart { t $contig($readIdx,alignmentStart) } fstop { t $contig($readIdx,alignmentEnd) } fcolor { # Forest Green t 0 } } } length { t $contig($readIdx,length) } sense { if {$contig($readIdx,strand) eq "U"} { t 1 } else { t -1 } } } seq-data { t $contig($readIdx,sequence) } } } } } return "$xmlHeader[$XMLdoc asXML]" } proc gestionOrthologues {} { set Alicia "yes" puts $Alicia foreach Fichier [glob -nocomplain "/home/depulp2/orthoinspector/orthologuesMiniProteome/*"] { set Id [file tail $Fichier] regsub {_fm5$} $Id "" Id set Nom [LesPABsAvecInfo "Id: $Id"] if {$Nom == ""} {continue} Espionne $Nom lappend LesOk $Nom file copy $Fichier "[RepertoireDuGenome]/orthologue/$Nom" } return $LesOk } proc gestionOrthologues2 {DirSource} { set Alicia "yes" puts $Alicia foreach Fichier [glob -nocomplain "$DirSource/*"] { set Id [file tail $Fichier] regsub {_fm5$} $Id "" Id set Nom [LesPABsAvecInfo "Id: $Id"] if {$Nom == ""} {continue} Espionne $Nom lappend LesOk $Nom file copy $Fichier "$DirSource/$Nom" } return $LesOk } proc getContigAlignment {aAce contig {complement 0}} { upvar $aAce ace array set align {index {} consensus ""} set align(consensus) $ace($contig,name) lappend align(index) $ace($contig,name) set align($ace($contig,name)) "[string repeat "-" $ace($contig,padding)]$ace($contig,consensus)" if {$ace($contig,strand) eq "C"} { set align($ace($contig,name),complemented) 1 } else { set align($ace($contig,name),complemented) 0 } set align($ace($contig,name),complemented) 0 set maxLength [string length $align($ace($contig,name))] foreach read $ace($contig,index) { lappend align(index) $ace($contig,$read,name) set align($ace($contig,$read,name)) "[string repeat "-" $ace($contig,$read,padding)]$ace($contig,$read,sequence)" if {$ace($contig,$read,strand) eq "C"} { set align($ace($contig,$read,name),complemented) 1 } else { set align($ace($contig,$read,name),complemented) 0 } array unset posIndex array set posIndex [alnPos2SeqPosIndex $ace($contig,$read,sequence)] set align($ace($contig,$read,name),aligned) [list $posIndex($ace($contig,$read,alignmentStart)) $posIndex($ace($contig,$read,alignmentEnd))] set length [string length $align($ace($contig,$read,name))] if {$length > $maxLength} {set maxLength $length} } # Rajoute le gaps de fin foreach access $align(index) { set aRajouter [expr $maxLength - [string length $align($access)]] set align($access) "$align($access)[string repeat "-" $aRajouter]" } # Complemente tout le contig si besoin if {$complement} { foreach access $align(index) { set align($access) [NucToReverseAndComplementNuc $align($access)] set align($access,complemented) [expr ! $align($access,complemented)] if {$access ne $align(consensus)} { set length [string length [regsub -all -nocase {[^a-z]} $align($access)]] set previousAlignStart [lindex $align($access,aligned) 0] set previousAlignEnd [lindex $align($access,aligned) 1] set align($access,aligned) [list [expr $length - $previousAlignEnd + 1] [expr $length - $previousAlignStart + 1]] } } } return [array get align] } proc getGraphHubString {g n {reset 0}} { if {$reset} { foreach n [$g nodes] { $g node unset $n "passed" } } if {![$g node keyexists $n "passed"]} { $g node set $n "passed" 1 set neighbours {} foreach tmp [$g nodes -adj $n] { if {!([$g node keyexists $n "stopRecursion"] && [$g node keyexists $tmp "stopRecursion"])} { set neighbours [concat $neighbours [getGraphHubString $g $tmp 0]] } } return [concat $n $neighbours] } return {} } proc getGroupMeanFeatures {lSequenceNodes {type REGION} {minHaving 0.6}} { # Vérification que ce sont bien les séquences d'un même groupe foreach n $lSequenceNodes { set seqGroup [string trim [$n selectNodes "string(.//group\[1\])"]] if {[info exists group]} { if {$seqGroup != $group} { puts "Sequences are not from the same group" exit 1 } } else { set group $seqGroup } } # Extrait les features et les convertit en coordonées d'alignement set features {} foreach n $lSequenceNodes { set seq [string trim [$n selectNodes "string(seq-data)"]] foreach item [$n selectNodes ".//fitem\[ftype=\"$type\"\]"] { set ft {} # lappend ft [seqPos2AlnPos $seq [string trim [$item selectNodes "string(fstart)"]]] # lappend ft [seqPos2AlnPos $seq [string trim [$item selectNodes "string(fstop)"]]] set fStart [seqPos2AlnPos $seq [string trim [$item selectNodes "string(fstart)"]]] set fStop [seqPos2AlnPos $seq [string trim [$item selectNodes "string(fstop)"]]] if {$fStart > $fStop} { set tmp $fStart set fStart $fStop set fStop $tmp } if {$fStart < 1} {continue} lappend ft $fStart lappend ft $fStop lappend ft [string trim [$item selectNodes "string(fnote)"]] lappend features $ft } } # Regroupe les features qui se chevauchent set fGroups {} foreach f $features { set isAdded 0 set breakLoop 0 for {set i 0} {!$breakLoop && $i < [llength $fGroups]} {incr i} { foreach f2 [lindex $fGroups $i] { if {[areRangeOverlapping [lrange $f 0 1] [lrange $f2 0 1]]} { lset fGroups $i [concat [lindex $fGroups $i] [list $f]] set isAdded 1 set breakLoop 1 break } } } if {!$isAdded} {lappend fGroups [list $f]} } # Calcule un feature consensus pour chaque groupe # sauf si pas assez de sequences forment ce groupe set mFeatures {} foreach g $fGroups { if {[expr double([llength $g]) / [llength $lSequenceNodes]] < $minHaving} {continue} set allStarts {} set allStops {} set note "" foreach f $g { lappend allStarts [lindex $f 0] lappend allStops [lindex $f 1] if {![regexp -nocase {^PROP_(.*)\s+from \w+$} [lindex $f 2] regMatch tmpNote]} {set tmpNote [lindex $f 2]} if {$note eq ""} { set note $tmpNote } elseif {$tmpNote ne $note} { puts "Some of the overlapping features are not the same" exit 1 } } lappend mFeatures [list [consensusPosition $allStarts] [consensusPosition $allStops] $note] } set mFeatures [lsort -integer -index 0 $mFeatures] return $mFeatures } proc getHubs {lProteinId {minCombinedScore 700} {fuseHubs 1}} { set lProteinId [lsort -unique $lProteinId] array set interact {} set count 0 set total [llength $lProteinId] set procName [lindex [info level 0] 0] foreach proteinId $lProteinId { set interact($proteinId) [list $proteinId] set sql "SELECT protein_id_b, combined_score FROM network.protein_protein_links WHERE protein_id_a = $proteinId AND combined_score >= $minCombinedScore" incr count Espionne "$procName: Retrieving $proteinId... ($count/$total)" foreach {proteinIdB score} [SqlExec $sql "GetList"] { if {[lsearch -exact $lProteinId $proteinIdB] != -1} { lappend interact($proteinId) $proteinIdB } } } set hasChanged $fuseHubs while {$hasChanged} { set hasChanged 0 foreach key [array names interact] { if {![info exists interact($key)]} {continue} foreach proteinId $interact($key) { if {$proteinId ne $key} { foreach key2 [array names interact] { if {![info exists interact($key2)]} {continue} if {$key2 ne $key && [lsearch -exact $interact($key2) $proteinId] != -1} { set interact($key) [lsort -unique [concat $interact($key) $interact($key2)]] unset interact($key2) set hasChanged 1 #break } } } } #if {$hasChanged} {break} } } set hubs {} foreach key [array names interact] {lappend hubs $interact($key)} if {[llength $lProteinId] != [llength [join $hubs]]} { error "IN [llength $lProteinId] != OUT [llength [join $hubs]]" } return [lsort -decreasing -command "lsortBySublistsLengths" $hubs] } proc getHubsWithLevel {lProteinId {depth 1} {minCombinedScore 700}} { set lProteinId [lsort -unique $lProteinId] set hubs {} foreach proteinId $lProteinId { set tmp {} foreach interact [getInteracts $proteinId $depth $minCombinedScore] { if {[lsearch -exact $lProteinId $interact] != -1} {lappend tmp $interact} } lappend hubs [lsort -unique [concat $proteinId $tmp]] } if {[llength $lProteinId] != [llength $hubs]} { error "IN [llength $lProteinId] != OUT [llength $hubs]" } return [lsort -unique -decreasing -command "lsortBySublistsLengths" $hubs] } proc getHyperconnectedHubs {lProteinId {depth 1} {minCombinedScore 700} {minConnections 3}} { package require struct::graph set g [::struct::graph] set lProteinId [lsort -unique $lProteinId] foreach proteinId $lProteinId { if {![$g node exists $proteinId]} { $g node insert $proteinId } #foreach interact [getInteractsWithoutTextMining $proteinId $depth $minCombinedScore] {} foreach interact [getInteractsWithoutTextMining $proteinId 1 $minCombinedScore] { if {![$g node exists $interact]} { $g node insert $interact } if {[lsearch -exact [$g nodes -adj $proteinId] $interact] == -1} { $g arc insert $proteinId $interact $g arc insert $interact $proteinId } } } # Vire les noeuds qui ne sont pas en entrée Espionne "Removing nodes not in input dataset..." foreach n [$g nodes] { if {[lsearch -exact $lProteinId $n] == -1} { $g node delete $n } } # Tag les noeuds qui n'ont pas assez de connexions Espionne "Taging nodes whithout enough connections..." foreach n [$g nodes] { if {[llength [$g nodes -adj $n]] < $minConnections} { $g node set $n "stopRecursion" 1 } } # Recherche les hubs set hubs {} foreach n [$g nodes] { set hub [getGraphHubString $g $n] if {[llength $hub] != 0} { lappend hubs [lsort $hub] } } $g destroy if {[llength $lProteinId] != [llength [join $hubs]]} { error "IN [llength $lProteinId] != OUT [llength [join $hubs]]" } return [lsort -decreasing -command "lsortBySublistsLengths" $hubs] } proc getInteracts {lProteinId depth {minCombinedScore 700}} { global GAGNIERE_DEBUG if {$depth <= 0} {return {}} set lProteinId [lsort -unique $lProteinId] set count 0 set total [llength $lProteinId] set procName [lindex [info level 0] 0] set fromProcName [lindex [info level -1] 0] set interacts {} foreach proteinId $lProteinId { set sql "SELECT protein_id_b, combined_score FROM network.protein_protein_links WHERE protein_id_a = $proteinId AND combined_score >= $minCombinedScore" incr count if {[info exists GAGNIERE_DEBUG] && $GAGNIERE_DEBUG} { Espionne "$procName (From $fromProcName Depth$depth): Retrieving $proteinId... ($count/$total)" } foreach {proteinIdB score} [SqlExec $sql "GetList"] { lappend interacts $proteinIdB } } set interacts [lsort -unique [concat $interacts [getInteracts $interacts [expr $depth - 1] $minCombinedScore]]] return $interacts } proc getInteractsFromStringGraph {g lProteinId {depth 1}} { global GAGNIERE_DEBUG if {$depth < 1} {return {}} set lProteinId [lsort -unique $lProteinId] set count 0 set total [llength $lProteinId] set procName [lindex [info level 0] 0] set fromProcName [lindex [info level -1] 0] set interacts {} foreach proteinId $lProteinId { incr count if {[info exists GAGNIERE_DEBUG] && $GAGNIERE_DEBUG == 2} { Espionne "$procName (From $fromProcName Depth$depth): Retrieving $proteinId... ($count/$total)" } set interacts [lsort -unique [concat $interacts [$g nodes -adj $proteinId]]] } set interacts [lsort -unique [concat $interacts [getInteractsFromStringGraph $g $interacts [expr $depth - 1]]]] return $interacts } proc getListAccGpFromMacsims {ficMacsims} { set lxml [LesLignesDuFichier $ficMacsims] set lAcc "" foreach lg $lxml { if {[regexp {^} $lg]} { set acc [string range $lg [expr [string first ">" $lg] + 1] [expr [string last "<" $lg] -1]] } elseif {[regexp {^} $lg]} { set gp [string range $lg [expr [string first ">" $lg] + 1] [expr [string last "<" $lg] -1]] lappend lAcc ${acc}_gp$gp } } return $lAcc } proc getMacsimsInf {filename ConcatPfam {option ""}} { #Espionne "getMacsimsInf" #Espionne "ConcatPfam: $ConcatPfam" set directory [RepertoireDuGenome] #liste des infos a recupere dans le fichier macsimXML #set infoParse {"ConcatDomain" "ConcatPfam" "ConcatStruct" "ConcatKoanno"} set infoParse $ConcatPfam if {$ConcatPfam == "ConcatDomPf"} { set infoParse {"ConcatPfam" "ConcatDomain"} } #Espionne "infoParse $infoParse" set filetmp {} set pdbList {} #lappend filetmp "Annotation Macsim" if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} { set fileMacsim "[RepertoireDuGenome]/macsimXml/$filename.aj" } else { set fileMacsim "[RepertoireDuGenome]/macsimXml/$filename" } if {$ConcatPfam=="pdb"} { if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} { set annotation [FromMacsims "$fileMacsim" "$filename" "SeqData"] set SeqInt [split $annotation ""] } else { set annotation [FromMacsims "$fileMacsim" "$filename" "SeqData"] set SeqInt [split $annotation ""] } #recuperation des pdb set ListProt [FromMacsims "$fileMacsim" "ListOf" "Names"] foreach l $ListProt { if {[regexp {^[1-9][A-Z0-9]{3}_[A-Z]} $l]} { lappend pdbList $l } } #parcours la liste des PDBs foreach lpdb $pdbList { set ty 0 if { [file exists "[RepertoireDuGenome]/macsimXml/$filename.aj"]} { set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"] set SeqPdb [split [string trim $annotation] ""] } else { set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"] set SeqPdb [split [string trim $annotation] ""] } #creation d'un pocedure pour calculer le recouvrement entre deux sequences. #recouvrement position de debut et de fin du pbd par rapport ¨¤ une sequene cible (dan l'alignement) set recouvrement [RecouvrementDesSequences $SeqInt $SeqPdb] set position [split $recouvrement "/"] set deb [lindex $position 0] set fin [lindex $position 1] #Espionne "PDB: $lpdb" #Espionne "deb; $deb" #Espionne "fin: $fin" if {$option=="filtre"} { if {$filetmp==""} {lappend filetmp " $lpdb;$deb;$fin"} set i 0 set indice -1 #Espionne "filetmp: [llength $filetmp]" set listeIndice {} foreach li $filetmp { #Espionne "i: $i" set position [split $li ";"] set debA [lindex $position 1] set finA [lindex $position 2] Espionne "LI: $li" #Espionne "debA: $debA" #Espionne "finA: $finA" if {$deb<=$debA && $fin>=$finA} { #Espionne "on retire $li" lappend listeIndice $i set indice -2 } elseif {$deb>=$debA && $fin<=$finA} { #Espionne "on fait rien avec $lpdb" set indice -2 } else { #Espionne "-1 On ajoute la pdb $lpdb" } incr i } if {$listeIndice!=""} { foreach l $listeIndice { set filetmp [lreplace $filetmp $l $l " $lpdb;$deb;$fin"] } } elseif {$indice==-1} { lappend filetmp " $lpdb;$deb;$fin" } } else { lappend filetmp " $lpdb;$deb;$fin" } incr ty if {$ty==2} {exit} } #lsort vire les doublons... set filetmp [lsort -unique $filetmp] } else { foreach Iparse $infoParse { #Espionne "Dans le else pas de PDB pour: $Iparse" if { [regexp {Concat(.*)} $Iparse p ip]} { #lappend filetmp "ip: $ip:" #Espionne "p: $p" #Espionne "ip: $ip" #Espionne "option: $option" #Espionne "fileMacsim: $fileMacsim" #Espionne "filename $filename" #Espionne "Iparse: $Iparse" set annotation [FromMacsims "$fileMacsim" "$filename" "$Iparse"] foreach an $annotation { #Espionne "an!!!!!!!!! ----> $an" set pos [split [lindex [split $an "/"] 1] "-"] set deb [lindex $pos 0] set end [lindex $pos 1] set long [expr $end-$deb+1] set inf [lindex [split $an "/"] 0] if {$ip=="Koanno"} { Espionne "Dans le KoAnno" switch $option { globulaire { if {[lindex [split $inf "_"] 1]=="GlobDoms"} { lappend filetmp " $inf;$deb;$end" Espionne "----------------------------> les valeur --> $inf;$deb;$end" } } disorder { switch $inf { FoldIndex_pds { lappend filetmp " $inf;$deb;$end" } GlobPlot_Disorder { lappend filetmp " $inf;$deb;$end" } Ronn_DR { lappend filetmp " $inf;$deb;$end" } default {} } } FoldIndex_pds { if {$inf=="FoldIndex_pds"} { lappend filetmp " $inf;$deb;$end" } } Ronn_DR { if {$inf=="Ronn_DR"} { lappend filetmp " $inf;$deb;$end" } } GlobPlot_Disorder { if {[lindex [split $inf "_"] 1]=="Disorder"} { lappend filetmp " $inf;$deb;$end" } } } } else { #faire ici difference entre domaine et pfam #je dois parcourir le lappend et regarder pour chaque couple $deb et $end si varie moins de 10 alors garde pas... #le if else test pour virer les informations de domaines fusionne avec pfam set dejavue "no" if {$ip=="Domain"} { #peut pas fonctionne car vas rentre les memes plusieur fois... #pour une deja vue alors que pour les autres rien a voir... foreach valeur $filetmp { set valeurs [split $valeur ";"] set debut [lindex $valeurs 1] set fin [lindex $valeurs 2] #Espionne "[expr $debut-10]<=$deb && $deb<=[expr $debut+10] && [expr $fin-10]<=$end && $end<=[expr $fin+10]" if {[expr $debut-10]<=$deb && $deb<=[expr $debut+10] && [expr $fin-10]<=$end && $end<=[expr $fin+10]} { set dejavue "OK" break; } } if {$dejavue!="OK"} { lappend filetmp " $ip;$deb;$end;$inf" } } else { lappend filetmp " $ip;$deb;$end;$inf" } } } } } } #ici si infoparse CompDomPfam alors regarde si pas plusieurs fois les memes... set filetmp [lsort -unique $filetmp] return $filetmp #foreach l $filetmp { # Espionne "--> $l" #} } proc getMacsimsInfNew {fileMac MaProt ConcatPfam {option ""}} { set directory [RepertoireDuGenome] #set infoParse {"ConcatDomain" "ConcatPfam" "ConcatStruct" "ConcatKoanno"} set infoParse $ConcatPfam if {$ConcatPfam == "ConcatDomPf"} { set infoParse {"ConcatPfam" "ConcatDomain"} } set filetmp {} set pdbList {} #lappend filetmp "Annotation Macsim" if { [file exists "[RepertoireDuGenome]/macsimXml/$fileMac.aj"]} { set fileMacsim "[RepertoireDuGenome]/macsimXml/$fileMac.aj" } else { set fileMacsim "[RepertoireDuGenome]/macsimXml/$fileMac" } if {$ConcatPfam=="pdb"} { #if { [file exists "[RepertoireDuGenome]/macsimXml/$fileMac.aj"]} { set annotation [FromMacsims "$fileMacsim" "$MaProt" "SeqData"] set SeqInt [split $annotation ""] #} else { #set annotation [FromMacsims "$fileMacsim" "$MaProt" "SeqData"] #set SeqInt [split $annotation ""] #} #recuperation des pdb set ListProt [FromMacsims "$fileMacsim" "ListOf" "Names"] foreach l $ListProt { if {[regexp {^[1-9][A-Z0-9]{3}_[A-Z]} $l]} { lappend pdbList $l } } #parcours la liste des PDBs foreach lpdb $pdbList { set ty 0 #if { [file exists "[RepertoireDuGenome]/macsimXml/$fileMac.aj"]} { set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"] set SeqPdb [split [string trim $annotation] ""] #} else { #set annotation [FromMacsims "$fileMacsim" "$lpdb" "SeqData"] #set SeqPdb [split [string trim $annotation] ""] #} #creation d'un pocedure pour calculer le recouvrement entre deux sequences. #recouvrement position de debut et de fin du pbd par rapport ¨¤ une sequene cible (dan l'alignement) set recouvrement [RecouvrementDesSequences $SeqInt $SeqPdb] set position [split $recouvrement "/"] set deb [lindex $position 0] set fin [lindex $position 1] if {$option=="filtre"} { if {$filetmp==""} {lappend filetmp " $lpdb;$deb;$fin"} set i 0 set indice -1 set listeIndice {} foreach li $filetmp { set position [split $li ";"] set debA [lindex $position 1] set finA [lindex $position 2] if {$deb<=$debA && $fin>=$finA} { #Espionne "on retire $li" lappend listeIndice $i set indice -2 } elseif {$deb>=$debA && $fin<=$finA} { set indice -2 } else { #Espionne "-1 On ajoute la pdb $lpdb" } incr i } if {$listeIndice!=""} { foreach l $listeIndice { set filetmp [lreplace $filetmp $l $l " $lpdb;$deb;$fin"] } } elseif {$indice==-1} { lappend filetmp " $lpdb;$deb;$fin" } } else { lappend filetmp " $lpdb;$deb;$fin" } incr ty if {$ty==2} {exit} } #lsort vire les doublons... set filetmp [lsort -unique $filetmp] } else { foreach Iparse $infoParse { Espionne "pour: $Iparse" if { [regexp {Concat(.*)} $Iparse p ip]} { #lappend filetmp "ip: $ip:" #Espionne "p: $p" #Espionne "ip: $ip" #Espionne "option: $option" #Espionne "fileMacsim: $fileMacsim" #Espionne "filename $filename" #Espionne "Iparse: $Iparse" set annotation [FromMacsims "$fileMacsim" "$MaProt" "$Iparse"] foreach an $annotation { #Espionne "an ----> $an" set pos [split [lindex [split $an "/"] 1] "-"] set deb [lindex $pos 0] set end [lindex $pos 1] set long [expr $end-$deb+1] set inf [lindex [split $an "/"] 0] #set recouvrement [expr ($long*100)/$taille] #lappend filetmp " $ip;$deb;$end;$inf" #Espionne "inf ------> $inf" if {$ip=="Koanno"} { switch $option { globulaire { if {[lindex [split $inf "_"] 1]=="GlobDoms"} { lappend filetmp " $inf;$deb;$end" } } disorder { switch $inf { FoldIndex_pds { lappend filetmp " $inf;$deb;$end" } GlobPlot_Disorder { lappend filetmp " $inf;$deb;$end" } Ronn_DR { lappend filetmp " $inf;$deb;$end" } default {} } } FoldIndex_pds { if {$inf=="FoldIndex_pds"} { lappend filetmp " $inf;$deb;$end" } } Ronn_DR { if {$inf=="Ronn_DR"} { lappend filetmp " $inf;$deb;$end" } } GlobPlot_Disorder { if {[lindex [split $inf "_"] 1]=="Disorder"} { lappend filetmp " $inf;$deb;$end" } } } } else { #faire ici difference entre domaine et pfam #je dois parcourir le lappend et regarder pour chaque couple $deb et $end si varie moins de 10 alors garde pas... #le if else test pour virer les informations de domaines fusionne avec pfam set dejavue "no" if {$ip=="Domain"} { #peut pas fonctionne car vas rentre les memes plusieur fois... #pour une deja vue alors que pour les autres rien a voir... foreach valeur $filetmp { set valeurs [split $valeur ";"] set debut [lindex $valeurs 1] set fin [lindex $valeurs 2] #Espionne "[expr $debut-10]<=$deb && $deb<=[expr $debut+10] && [expr $fin-10]<=$end && $end<=[expr $fin+10]" if {[expr $debut-10]<=$deb && $deb<=[expr $debut+10] && [expr $fin-10]<=$end && $end<=[expr $fin+10]} { set dejavue "OK" break; } } if {$dejavue!="OK"} { lappend filetmp " $ip;$deb;$end;$inf" } } else { lappend filetmp " $ip;$deb;$end;$inf" } } } } } } return $filetmp #foreach l $filetmp { # Espionne "--> $l" #} } proc getProteinIdAndPreferredNameByAccessionRefSeqP {Acc} { set taxId "9031" set InfoFiche [TraiteLesRefSeqP $Acc] if {$InfoFiche==""} { error "BirdEntry: '$Acc' non trouve" } set LesInfos [split $InfoFiche "|"] set Gn [lindex $LesInfos 0] set NM [lindex $LesInfos 1] set GeneID [lindex $LesInfos 2] set taxId [lindex $LesInfos 3] #Espionne "Acc:$Acc\nGn:$Gn\nNM:$NM\nGeneID:$GeneID" set sqlWhere {} foreach access [concat $Acc $Gn $NM $GeneID] { lappend sqlWhere "pn.protein_name = '$access'" } set sqlWhere [join $sqlWhere " OR "] set sql "SELECT p.protein_id, p.preferred_name FROM items.proteins_names pn, items.proteins p WHERE ($sqlWhere) AND pn.species_id = $taxId AND pn.protein_id = p.protein_id LIMIT 1" set list [SqlExec $sql "GetList"] return $list } proc getProteinIdAndPreferredNameByUniprotIdOrAccessString {IdOuAc {aEMBL ""}} { error "!!! NETTOYER FIN DE [lindex [info level 0] 0] !!!" error "!!! UTILISER BLASTP STRING AVEC EXPECT !!!" error "!!! RECHERCHE HOMOLOGUE AVEC SEQUENCE EN PARAM PLUTOT QUE SEQUENCE DE L'ACCESS !!!" set entries [BirdEntry $IdOuAc] if {$entries eq ""} { error "BirdEntry: '$IdOuAc' non trouvé" } elseif {[llength $entries] > 1} { error "BirdEntry: 1+ trouvés pour '$IdOuAc'" } set entry [lindex $entries 0] if {$aEMBL ne ""} {upvar $aEMBL embl} ParseEMBL $entry embl set id $embl(ID) set lAccessions $embl(AC) set taxId $embl(TaxId) set lEnsembl {} set lRefSeq {} set lGenomeReviews {} if {[info exists embl(DR)]} { foreach dbxref $embl(DR) { foreach {db primary secondary tertiary quaternary} $dbxref {} switch -exact $db { "Ensembl" { lappend lEnsembl $primary } "RefSeq" { lappend lRefSeq $primary } "GenomeReviews" { lappend lGenomeReviews $secondary } } } } set lGN {} if {[info exists embl(GN)]} { foreach list $embl(GN) { foreach {name synonyms loci ORFs} $list {} set lGN [concat $lGN $name $synonyms] } } Espionne "ID:$id\nAC:$lAccessions\nEnsembl:$lEnsembl\nRefSeq:$lRefSeq\nGenomeReviews:$lGenomeReviews\nGN:$lGN" set sqlWhere {} foreach access [concat $id $lAccessions $lEnsembl $lRefSeq $lGenomeReviews $lGN] { lappend sqlWhere "pn.protein_name = '$access'" } set sqlWhere [join $sqlWhere " OR "] set sql "SELECT p.protein_id, p.preferred_name FROM items.proteins_names pn, items.proteins p WHERE ($sqlWhere) AND pn.species_id = $taxId AND pn.protein_id = p.protein_id LIMIT 1" set list [SqlExec $sql "GetList"] if {[llength $list] == 0} { set fichierFasta "/tmp/$embl(ID).fasta" set out [open $fichierFasta "w"] puts $out [formatFasta $embl(ID) $embl(Sequence)] close $out set list [BlastPString $fichierFasta $embl(TaxId)] file delete $fichierFasta } Espionne "\t$list\n" return $list } proc getResAgents {} { package require sqlite3 set db "root" sqlite3 $db res.sql $db eval {begin transaction} puts "Nb files [llength [$db eval {select distinct(nom) from file}]]" set Llen [$db eval {select distinct(motiflen) from segment}] puts "Llen $Llen" foreach len $Llen { puts "\nlen $len :" foreach rk {0.0 0.05 0.1 0.2} { set Lv [$db eval {select f.nom,s.min,s.max from file as f, block as b, ln_file_block as lfb, segment as s, ln_block_segment as lbs where s.rank <= $rk and s.motiflen = $len and s.pk_segment = lbs.pk_segment and lbs.pk_block = lfb.pk_block and f.pk_file = lfb.pk_file}] set Lf {} ; set Lmin {} ; set Lmax {} foreach {f min max} $Lv { lappend Lf $f lappend Lmin $min lappend Lmax $max } set nf [llength [lsort -unique $Lf]] set min [lindex [lsort -integer $Lmin] 0] set max [lindex [lsort -integer $Lmax] end] puts "rank $rk | $nf | $min $max" } } puts "" exit set ilen 0 foreach l1 $Llen { foreach l2 $Llen { if {$l1 == $l2} { continue } puts "$l1 - $l2 : [llength [land $T($l1) $T($l2)]] [lor $T($l1) $T($l2)]" } } set Lf [$db eval {select distinct(nom) from file where nom like 'BB%'}] puts "\nfile [llength $Lf]" puts "[lsort -dictionary [lor $T(5) $Lf]]" $db eval {commit} $db close exit } proc getSequence {seqNode} { if {[$seqNode nodeType] ne "ELEMENT_NODE" || [$seqNode nodeName] ne "sequence"} { puts "This is not a sequence node" exit 1 } return [string trim [$seqNode selectNodes "string(seq-data)"]] } proc getSequenceFeatures {seqNode {type ""} {withAlignementPositions 1}} { if {[$seqNode nodeType] ne "ELEMENT_NODE" || [$seqNode nodeName] ne "sequence"} { puts "This is not a sequence node" exit 1 } if {$withAlignementPositions} { array set index [seqPos2AlnPosIndex [getSequence $seqNode]] } if {$type ne ""} { set xpath ".//fitem\[ftype=\"$type\"\]" } else { set xpath ".//fitem" } set lFeatures {} foreach n [$seqNode selectNodes $xpath] { set type [string trim [$n selectNodes "string(ftype)"]] set start [string trim [$n selectNodes "string(fstart)"]] set stop [string trim [$n selectNodes "string(fstop)"]] set color [string trim [$n selectNodes "string(fcolor)"]] set score [string trim [$n selectNodes "string(fscore)"]] set note [string trim [$n selectNodes "string(fnote)"]] # Macsims bugs !!! if {$start > $stop} { set tmp $start set start $stop set stop $tmp } if {$start < 1} {continue} # /Macsims bugs if {$withAlignementPositions} { set start $index($start) set stop $index($stop) } lappend lFeatures [list "type" $type "start" $start "stop" $stop "color" $color "score" $score "note" $note] } return [lsort -command compareFeatures $lFeatures] } proc getSequenceGroup {seqNode} { if {[$seqNode nodeType] ne "ELEMENT_NODE" || [$seqNode nodeName] ne "sequence"} { puts "This is not a sequence node" exit 1 } return [string trim [$seqNode selectNodes "string(.//group\[1\])"]] } proc getSequenceName {seqNode} { if {[$seqNode nodeType] ne "ELEMENT_NODE" || [$seqNode nodeName] ne "sequence"} { puts "This is not a sequence node" exit 1 } return [string trim [$seqNode selectNodes "string(seq-name)"]] } proc getSequenceNode {node name} { return [$node selectNodes "//sequence\[seq-name=\"$name\"\]"] } proc getStringGraph {lProteinId {minCombinedScore 700} {lTagsProteinId ""}} { package require struct::graph set g [::struct::graph] set lProteinId [lsort -unique $lProteinId] foreach proteinId $lProteinId { if {![$g node exists $proteinId]} { $g node insert $proteinId } foreach interact [getInteracts $proteinId 1 $minCombinedScore] { if {![$g node exists $interact]} { $g node insert $interact } if {[lsearch -exact [$g nodes -adj $proteinId] $interact] == -1} { $g arc insert $proteinId $interact $g arc insert $interact $proteinId } } } # Vire les noeuds qui ne sont pas en entrée foreach n [$g nodes] { if {[lsearch -exact $lProteinId $n] == -1} { $g node delete $n } } # Tag les noeuds spécifiés foreach {tag lProteinIdToTag} $lTagsProteinId { foreach n [$g nodes] { if {[lsearch -exact $lProteinIdToTag $n] != -1} { $g node set $n $tag 1 } } } # Rajoute le nom préféré et l'annotation foreach n [$g nodes] { set sql "SELECT preferred_name, annotation FROM items.proteins WHERE protein_id = $n" foreach {preferred_name annotation} [SqlExec $sql "GetList"] {} $g node set $n "preferred_name" $preferred_name $g node set $n "annotation" $annotation } return $g } proc getStringGraphMoi {lProteinId {minCombinedScore 700} {lTagsProteinId ""}} { package require struct::graph CanalSqlString set g [::struct::graph] set lProteinId [lsort -unique $lProteinId] foreach proteinId $lProteinId { if {![$g node exists $proteinId]} { $g node insert $proteinId } foreach interact [getInteracts $proteinId 1 $minCombinedScore] { if {![$g node exists $interact]} { $g node insert $interact } if {[lsearch -exact [$g nodes -adj $proteinId] $interact] == -1} { $g arc insert $proteinId $interact $g arc insert $interact $proteinId } } } # Vire les noeuds qui ne sont pas en entrée foreach n [$g nodes] { if {[lsearch -exact $lProteinId $n] == -1} { $g node delete $n } } # Tag les noeuds spécifiés foreach {tag lProteinIdToTag} $lTagsProteinId { foreach n [$g nodes] { if {[lsearch -exact $lProteinIdToTag $n] != -1} { $g node set $n $tag 1 } } } # Rajoute le nom préféré et l'annotation foreach n [$g nodes] { set sql "SELECT preferred_name, annotation FROM items.proteins WHERE protein_id = $n" Espionne "$sql" set result [SqlExec $sql "GetFirstValue"] Espionne "$result" foreach {preferred_name annotation} [SqlExec $sql "GetList"] {} Espionne "$preferred_name" Espionne "$annotation" $g node set $n "preferred_name" $preferred_name $g node set $n "annotation" $annotation } return $g } proc getStringGraphWithLevel {lProteinId {minCombinedScore 700} {level 0}} { set lProteinId [lsort -unique $lProteinId] set interacts {} foreach proteinId $lProteinId { if {$level > 0} { set interacts [lsort -unique [concat $interacts [getInteracts $proteinId $level $minCombinedScore]]] } } set lProteinId [lsort -unique [concat $lProteinId $interacts]] return [getStringGraph $lProteinId $minCombinedScore] } proc getStringSubGraph {g lProteinId} { package require struct::graph # Crée une copie set sg [::struct::graph] $sg = $g # Vire les noeuds qui ne sont pas en entrée foreach n [$sg nodes] { if {[lsearch -exact $lProteinId $n] == -1} { $sg node delete $n } } return $sg } proc getUnpaddedSequencePosition {sequence paddedPosition} { if { $paddedPosition <= 1 } { return $paddedPosition } set unpaddedPosition 1 set strlen [string length $sequence] for { set i 0 } { $i < $strlen } { incr i } { if { [expr $i + 1] == $paddedPosition } { return $unpaddedPosition } if { [string index $sequence $i] ne "*" } { incr unpaddedPosition } } return 0 } proc get_blocks {grp block_cutoff window conserved minlength} { global TableScore CpB set nseqs [llength [set CpB($grp)]] if {$grp eq "GroupeToutLeMonde"} { array set colscore [calc_normd_global $grp $window $conserved] } else { if {[llength [set CpB($grp)]] < 2} { return 0 } array set colscore [calc_normd_for_subgroup $grp $window $conserved] } set inregion 0 set Ltot $CpB(Ltot) set nblocks 0 set CpB(Blocks,$grp) [list] for {set i 0} {$i < $Ltot} {incr i} { if {[set colscore($i)] >= $block_cutoff} { if {! $inregion} { set first $i set inregion 1 } } else { if {$inregion} { set last [expr {$i-1}] if {$last >= ($first+$minlength)} { lappend CpB(Blocks,$grp) [list $first $last] } set inregion 0 } } } if {$inregion} { set last $Ltot if {$last >= ($first+$minlength)} { lappend CpB(Blocks,$grp) [list $first $last] } } if {$grp eq "GroupeToutLeMonde"} { puts "DEBITEM BTous" foreach b [set CpB(Blocks,$grp)] { lassign $b f d puts "ITEM $f $d" } } return [llength $CpB(Blocks,$grp)] } proc glMultiDrawElements {mode count type indices primcount} { for { set i 0 } { $i < $primcount } { incr i } { if { [$count get $i] > 0 } { glDrawElements $mode [$count get $i] $type [lindex $indices $i] } } } proc globXB {directory} { set directory [RepertoireDuGenome]/$directory #set directory [RepertoireDuGenome]/GroupeDomain/PUZ03 #set n [split $directory "/"] #set fichier [lindex $n [llength $n]-1] #if { [file exists "[RepertoireDuGenome]/macsimXml/$fichier.aj"]} { #set FichierMacsim "[RepertoireDuGenome]/macsimXml/$fichier.aj" #} else { # set FichierMacsim "[RepertoireDuGenome]/macsimXml/$fichier" #} set r [glob -directory $directory *] set ListeDesRpertoires {} foreach rep $r { #Espionne "rep:$rep" set re [glob -directory $rep *.png] foreach monFichier $re { set n [split $monFichier "/"] set f1 [lindex $n [llength $n]-2] set f2 [lindex $n [llength $n]-1] if {[regexp {(.*)Domain.png} $f2 p na]} { set name $na } elseif {[regexp {(.*)Pfam.png} $f2 p na]} { set name $na } #set OS [OrgaDuAccess $na] #pour les pdb regarde dans le fichiers macsim et pour les ensembl regarde dans le fichier newtfasdescopains.... #normalement devrai fonctionne mais erreur dans le code de Laetitia lui demander de regarder qd reviens.... #set Organism "" #if {$OS=="Inconnu inconnu"} { #set OS [FromMacsims $FichierMacsim $na "Organism"] #} #if {$OS=="" || $OS=="Inconnu inconnu"} { #set OS [getOrgaTfasDesCopains "" $fichier $na] #} #set f2bis [lindex [split $f2 "Pfam"] 0] #faut pas faire un split.... if {[regexp {^(.*)Pfam.*} $f2 tmp access]} { set f2bis $access } elseif {[regexp {^(.*)Domain.*} $f2 tmp access]} { set f2bis $access } elseif {[regexp {^(.*)Region.*} $f2 tmp access]} { set f2bis $access } #Espionne "F1: $f1; F2: $f2; F2bis:$f2bis" lappend groupeProt "$f2bis;" #lappend ListeDesRpertoires "$f1/$f2bis;" set groupeProt [lsort -unique $groupeProt] } lappend ListeDesRpertoires "#$f1/[join $groupeProt ""]" set groupeProt "" } set ListeDesRpertoires [lsort -unique $ListeDesRpertoires] #Espionne $ListeDesRpertoires #foreach l $ListeDesRpertoires { # Espionne $l #} return $ListeDesRpertoires } proc globXBAncien {directory} { set directory [RepertoireDuGenome]/$directory set r [glob -directory $directory *] set ListeDesRpertoires {} foreach rep $r { set re [glob -directory $rep *.png] #Espionne "--->>>$rep:" foreach fichier $re { Espionne "fichier: $fichier" set n [split $fichier "/"] set f1 [lindex $n [llength $n]-2] set f2 [lindex $n [llength $n]-1] lappend ListeDesRpertoires "$f1/$f2;" } lappend ListeDesRpertoires "#" } #Espionne $ListeDesRpertoires # foreach l $ListeDesRpertoires { # Espionne $l # } #return $ListeDesRpertoires } proc glutSolidCone {base height slices stacks} { set quadObj [gluNewQuadric] gluQuadricDrawStyle $quadObj GLU_FILL gluQuadricNormals $quadObj GLU_SMOOTH gluCylinder $quadObj $base 0.0 $height $slices $stacks gluDeleteQuadric $quadObj } proc glutSolidCube {size} { tcl3dDrawBox $size GL_QUADS } proc glutSolidDodecahedron {} { tcl3dDodecahedron GL_TRIANGLE_FAN } proc glutSolidIcosahedron {} { tcl3dIcosahedron GL_TRIANGLES } proc glutSolidOctahedron {} { tcl3dOctahedron GL_TRIANGLES } proc glutSolidSphere {radius slices stacks} { set quadObj [gluNewQuadric] gluQuadricDrawStyle $quadObj GLU_FILL gluQuadricNormals $quadObj GLU_SMOOTH gluSphere $quadObj $radius $slices $stacks gluDeleteQuadric $quadObj } proc glutSolidTeapot {scale {grid 14}} { tcl3dTeapot $grid $scale GL_FILL } proc glutSolidTetrahedron {} { tcl3dTetrahedron GL_TRIANGLES } proc glutSolidTorus {innerRadius outerRadius nsides rings} { tcl3dDoughnut $innerRadius $outerRadius $nsides $rings } proc glutWireCone {base height slices stacks} { set quadObj [gluNewQuadric] gluQuadricDrawStyle $quadObj GLU_LINE gluQuadricNormals $quadObj GLU_SMOOTH gluCylinder $quadObj $base 0.0 $height $slices $stacks gluDeleteQuadric $quadObj } proc glutWireCube {size} { tcl3dDrawBox $size GL_LINE_LOOP } proc glutWireDodecahedron {} { tcl3dDodecahedron GL_LINE_LOOP } proc glutWireIcosahedron {} { tcl3dIcosahedron GL_LINE_LOOP } proc glutWireOctahedron {} { tcl3dOctahedron GL_LINE_LOOP } proc glutWireSphere {radius slices stacks} { set quadObj [gluNewQuadric] gluQuadricDrawStyle $quadObj GLU_LINE gluQuadricNormals $quadObj GLU_SMOOTH gluSphere $quadObj $radius $slices $stacks gluDeleteQuadric $quadObj } proc glutWireTeapot {scale {grid 10}} { tcl3dTeapot $grid $scale GL_LINE } proc glutWireTetrahedron {} { tcl3dTetrahedron GL_LINE_LOOP } proc glutWireTorus {innerRadius outerRadius nsides rings} { glPushAttrib GL_POLYGON_BIT glPolygonMode GL_FRONT_AND_BACK GL_LINE tcl3dDoughnut $innerRadius $outerRadius $nsides $rings glPopAttrib } proc groupIdenticalFeatures {features} { # Regroupement des features identiques (recouvrement + même color) set groups {} while {[llength $features] != 0} { set newFeatures {} # Crée un nouveau groupe à partir du premier element set current [lindex $features 0] set newGroup [list $current] # Ajoute au groupe les elements identiques à celui ci # et met de côté les autres for {set i 1} {$i < [llength $features]} {incr i} { set ft [lindex $features $i] if {[isSameFeature $current $ft]} { lappend newGroup $ft } else { lappend newFeatures $ft } } # Tente de fusionner ce nouveau groupe avec un précédent # sinon il est juste ajouté en tant que tel set fused 0 for {set i 0} {$i < [llength $groups]} {incr i} { set grp [lindex $groups $i] foreach ftA $grp { foreach ftB $newGroup { if {[isSameFeature $ftA $ftB]} { set grp [concat $grp $newGroup] lset groups $i $grp set fused 1 break } } if {$fused} {break} } if {$fused} {break} } if {!$fused} {lappend groups $newGroup} set features $newFeatures } return $groups } proc grouperHitsParTaxid {hits} { set res [dict create] foreach h $hits { set taxid [$h get taxid] dict lappend res $taxid $h } return $res } proc grouperIsoformes {hits Fonction {Type Subj}} { proc do {code while cond} { tailcall try $code\n[list $while $cond $code] } set res {} set curGroup $hits do { set tmpGroup {} set ref [lindex $curGroup 0] set isoformes [list $ref] foreach el [lrange $curGroup 1 end] { if {[$ref $Fonction $el $Type]} { lappend isoformes $el } else { lappend tmpGroup $el } } lappend res $isoformes set curGroup $tmpGroup } while {[llength $curGroup] > 0} return $res } proc grouperIsoformesScore {hits Fonction Type} { set scores [dict create] set i 0 foreach refh $hits { set j [expr $i+1] foreach h [lrange $hits [expr $i+1] end] { #puts "($i,$j) [$refh getShortid] against [$h getShortid]: [$refh estIsoformeFenetre $h Subject]" dict set scores "$i,$j" [$refh estIsoformeFenetre $h Subject] incr j } incr i } set groups {} set indexes [dict create] set i 0 foreach h $hits { set max 0 set copain "" for {set j 0} {$j<[llength $hits]} {incr j} { set key [join [lsort -increasing -integer [list $i $j]] ","] if {[dict exists $scores $key] && [dict get $scores $key] > $max} { set max [dict get $scores $key] set copain $j } } if {$copain == "" || ![dict exists $indexes $copain]} { lappend groups [list $h] dict set indexes $i [expr [llength $groups]-1] } else { set idx [dict get $indexes $copain] lset groups $idx end+1 $h dict set indexes $i $idx } incr i } #foreach g $groups { # puts "=====" # foreach h $g { # puts [$h getShortid] # } #} return $groups } proc grpm {} { global LNOrdali # Article M.Sissler splice variant AspRS # # proc pour remettre les bons numeros de groupes # dans fichier xml output de macsim # entre avec fichier tfa ordonne d'olivier # Groupes : numerotation 0 -> # 0-39 Fungi # 40-70 Animaux # 71-79 Plants # 80-184 Bacteria # 185-193 cyto (outgroup) LitLeTFA DARS2_DARS_uniprot.tfa tmp St foreach n $tmp { lappend Lt [string toupper $n] } puts "Lt [llength $Lt]" puts "[join $Lt \n]" set SDG(1) [lrange $Lt 0 39] set SDG(2) [lrange $Lt 40 70] set SDG(3) [lrange $Lt 71 79] set SDG(4) [lrange $Lt 80 184] set SDG(5) [lrange $Lt 185 end] set Lxml [ContenuDuFichier DARS2_DARS_uniprot.xml] set RId [dom parse $Lxml] set doc [$RId documentElement] set Lsq [$doc selectNodes //sequence] puts "xml lsq [llength $Lsq]" foreach ns $Lsq { set nn [$ns selectNodes seq-name] set name [$nn selectNode string(.)] set g -1 foreach i {1 2 3 4 5} { set name [string toupper $name] if {$name in [set SDG($i)]} { set g $i set done 1 break } } if {$g == -1} { puts "Pb ! Seq $name has no group" } set ng [$ns selectNodes ./seq-info/group/text()] $ng nodeValue $g } set out t.xml set fout [open $out w] puts $fout "" puts $fout "" $doc asXML -channel $fout close $fout $RId delete parray SDG exit } proc haveFeature {seqNode feature {type REGION}} { set seq [string trim [$seqNode selectNodes "string(seq-data)"]] foreach f [$seqNode selectNodes ".//fitem\[ftype=\"$type\"\]"] { set fStart [seqPos2AlnPos $seq [string trim [$f selectNodes "string(fstart)"]]] set fStop [seqPos2AlnPos $seq [string trim [$f selectNodes "string(fstop)"]]] if {$fStart > $fStop} { set tmp $fStart set fStart $fStop set fStop $tmp } if {$fStart < 1} {continue} set fNote [string trim [$f selectNodes "string(fnote)"]] if {[regexp -nocase {^PROP_(.*)\s+from \w+$} $fNote regMatch tmpNote]} {set fNote $tmpNote} if {[areRangeOverlapping [list $fStart $fStop $fNote] $feature] && $fNote eq [lindex $feature 2]} {return 1} } return 0 } proc helcomp {} { foreach FichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsimsOld/*.xml"] { set fin [file tail $FichierMacsim] #regsub {\.[^\.]+$} $fin "" fin #regsub {\.[^\.]+$} $fin "" fin if {![file exists "[RepertoireDuGenome]/macsims/$fin"]} { incr i; Espionne "manque dans macsims $fin" } } } proc helcompInv {} { foreach FichierMacsim [glob -nocomplain "[RepertoireDuGenome]/macsims/*.xml"] { set fin [file tail $FichierMacsim] #Espionne "[RepertoireDuGenome]/macsimsOld/$fin" if {![file exists "[RepertoireDuGenome]/macsimsOld/$fin"]} { incr i; Espionne "manque dans macsims $fin" } } } proc helplog {} { foreach FichierLog [glob -nocomplain "[RepertoireDuGenome]/log/*"] { foreach Ligne [LesLignesDuFichier $FichierLog] { if {[regexp "addSeq" $Ligne]} { lappend LesElus "$FichierLog" } } } set LesElus [lsort $LesElus] EspionneL "$LesElus" } proc histdescore {} { global ready set ready 0 set d [list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1 0 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 10 5 0 1 2 35 3 5 1 9 20 2 0 27 7 0 23 0 7 0 5 59 2 2 0 11 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 5 6 0 4 1 12 24 33 8 18 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 36 27 11 44 19 67 39 54 5 31 20 4 53 38 40 14 50 65 38 2 45 55 25 6 7 6 17 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 100 1 0 0 4 0 0 8 8 1 6 43 0 3 3 23 5 4 52 8 2 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] set ld [split $d " "] puts "nval = [llength $ld]" for {set i 10} {$i <= 100} {incr i 10} { set r($i) 0 } foreach e $ld { if {$e == 0} { incr r(10) continue } for {set i 10} {$i <= 100} {incr i 10} { if {double($e)/$i <= 1.} { incr r($i) break } } } set dh [array get r] parray r histogram $dh 500 400 return } proc histogram {slist wid ht} { # render a histogram global ready array set scores $slist set nms [lsort -integer [array names scores]] catch {destroy .h} {} catch {destroy .b} {} canvas .h -width $wid -height $ht -bg beige pack .h set nbars [array size scores] #how many histogram bars set nax [expr $nbars/10] ;# axis spacing set hwid [expr $wid/ $nbars] set i 0 set hmax -9999999 ;# largest y value set hmin 9999999 ;# smallest y value while {$i<$nbars} { set f $scores([lindex $nms $i]) set hmax [ expr {$f>$hmax} ? $f : $hmax] set hmin [ expr {$f<$hmin} ? $f : $hmin] incr i } if {$hmax>$hmin} { set i 0 set nay 100 while {$nay<$hmax} { set yp [expr $ht-0.75*$nay-20] .h create line 0 $yp $wid $yp -fill red incr nay 100 } set nax 10 while {$i<$nbars} { set x [expr $hwid*$i] set rhs [expr $x+$hwid/2] set f [expr $ht-20-.75*$ht*$scores([lindex $nms $i])/$hmax] .h create rectangle $x [expr $ht-20] $rhs $f -fill gray if {[expr $i>=$nax]} { .h create line $x [expr $ht-20] $x 0 -fill red incr nax 10 } incr i incr x $hwid } update # button .b -text "Next" -command "incr ready" ;# when ready is changed, proceeds with commands # pack .b } } proc hopla {} { set dir "/home/moumou" foreach {i d} {1 "clustal" 2 "cluspack" 3 "rascal"} { cd [file join $dir $d] set lc$i {} set lc$i [glob -nocomplain -- *.c] lappend lc$i [glob -nocomplain -- *.h] } foreach i {1 2} { foreach j {2 3} { if {$i == $j} {continue} set rep [land [set lc$i] [set lc$j]] puts "$i $j $rep" } } return } proc hsbToRgb {hue sat value} { set v [format %.0f [expr {65535.0*$value}]] if {$sat == 0} { return "$v $v $v" } else { set hue [expr {$hue*6.0}] if {$hue >= 6.0} { set hue 0.0 } scan $hue. %d i set f [expr {$hue-$i}] set p [format %.0f [expr {65535.0*$value*(1 - $sat)}]] set q [format %.0f [expr {65535.0*$value*(1 - ($sat*$f))}]] set t [format %.0f [expr {65535.0*$value*(1 - ($sat*(1 - $f)))}]] case $i 0 {return "$v $t $p"} 1 {return "$q $v $p"} 2 {return "$p $v $t"} 3 {return "$p $q $v"} 4 {return "$t $p $v"} 5 {return "$v $p $q"} error "i value $i is out of range" } } proc httpCallback {token} { upvar #0 $token State # Access State as a Tcl array if {[info exists State(error)]} { return [set State(error)] } else { return "pasmarche" } } proc ihr {} { set Header "genename humangenesymbol altnames species detectionmethod stage1 stage2 stage3 stage4 moumsechromodist mgd humanchromoloc omim mousemappingref humanmappingref expressionref typeofprotein abnormalitiesinmutant" set LesHeader [split $Header "\t"] set NewHeader [join $LesHeader ";"] lappend LeNew $NewHeader foreach Ligne [LesLignesDuFichier "[HomeRipp]/GenoretWww/ImAnno/ImAnnoEar/mousegene.txt"] { if { ! [regexp -nocase {[a-z]} $Ligne]} { continue } regsub -all {\;} $Ligne ".," Ligne set LesMots [split $Ligne "\t"] set N [llength $LesMots] Espionne [lindex $LesMots 14] if {$N==14} { lappend LesMots "" } if {$N>15} { set LesMots [lrange $LesMots 0 14] } set New [join $LesMots ";"] lappend LeNew $New } SauveLesLignes $LeNew dans "[HomeRipp]/GenoretWww/ImAnno/ImAnnoEar/mousegeneRR.txt" AfficheVariable [join $LeNew "\n"] } proc iii {} { global Bornes return [dict info $Bornes] } proc image.bitmap.to.photo {bmp} { set options {} foreach opt {-background -data -file -foreground -maskdata -maskfile} { lappend options $opt [$bmp cget $opt] } return [eval image.create.xbm $options] } proc image.create.xbm {args} { array set a $args if {[array names a -exact -file] ne {}} { set fid [open $a(-file) r] set a(-data) [read $fid] close $fid } if {[array names a -exact -maskfile] ne {}} { set fid [open $a(-maskfile) r] set a(-maskdata) [read $fid] close $fid } if {[array names a -exact -foreground] eq {}} {set a(-foreground) black} if {[array names a -exact -background] eq {}} {set a(-background) {}} if {$a(-background) eq {}} { set a(-maskdata) $a(-data) set a(-background) white } set width [set a(-width)] set height [set a(-height)] set result [image create photo -width $width -height $height] set data [join [split [set a(-data)] " "]] set line {} set ycntr0 0 set ycntr1 1 foreach datum $data { foreach cntr {0 1 2 3 4 5 6 7} { if {($datum %2) == 0} then {lappend line $a(-background)} else {lappend line $a(-foreground)} set datum [expr {$datum >> 1}] } if {[llength $line] >= $width} { $result put [list $line] -to 0 $ycntr0 $width $ycntr1 incr ycntr0 incr ycntr1 set line {} } } if {[array names a -exact -maskdata] ne {}} { set w [lindex [regexp -inline -- {width\s+(\d+)} $a(-data)] 1] set h [lindex [regexp -inline -- {height\s+(\d+)} $a(-data)] 1] if {($w != $width) || ($h != $height)} { error {bitmap and mask have different sizes} } regexp -indices -- {\{\s*(0x[^\}]*)} $a(-maskdata) r1 range foreach {b e} $range break set data [join [split [string trim [string range $a(-maskdata) $b $e]] ,]] set ycntr 0 set xcntr 0 foreach datum $data { foreach cntr {0 1 2 3 4 5 6 7} { if {($datum %2) == 0} { $result transparency set $xcntr $ycntr true } set datum [expr {$datum >> 1}] incr xcntr if {$xcntr >= $width} { incr ycntr set xcntr 0 break } } } } return $result } proc initbooks {} { package require sqlite3 set tbl " - books { . pk_books P . prenom V256 . nom V256 . titre V256 }" set f /home/moumou/www/perso/books/books.sql file delete $f set d [FabriqueDeTables $tbl roo $f] puts "d= $d" exit } proc inittrace {} { set Lp [info procs] foreach e $Lp { if {$e == "LaTrace"} {continue} if {[regexp {^[A-Z]} $e]} {trace add execution $e enter LaTrace} } return } proc integersMeanCeil {list} { set sum 0 foreach e $list {incr sum $e} return [expr int( ceil( double($sum) / [llength $list] ) )] } proc invcol {f} { LoadTkAndPackages package require Img set ph [image create photo -file $f] set Ldata [$ph data] puts "width [$ph cget -width]" puts "heigh [$ph cget -height]" puts "[llength $Ldata]" puts "[llength [lindex $Ldata 0]]" puts [lrange [lindex $Ldata 0] 0 10] set out [image create photo] set newI [list] foreach l $Ldata { set newL [list] foreach p $l { lassign [CouleurHexa2Int $p] r g b set nr [expr {255-$r}] set ng [expr {255-$g}] set nb [expr {255-$b}] set c [CouleurInt2Hexa [list $nr $ng $nb]] lappend newL $c } lappend newI $newL } $out put $newI $out write out.png -format png exit } proc ip:external {} { #this uses the TCP DNS port of the DNS root-servers. #If these aren't reachable, you probably don't #have a working external internet connection anyway. set MyIP "" foreach a {a b c d e f g h i j k} { catch { set external [socket $a.root-servers.net 53] set MyIP [lindex [fconfigure $external -sockname] 0] close $external } if { ![string equal $MyIP ""] } { break } } return $MyIP } proc isPdb {access} { return [regexp -nocase {^\d\w{3}_[a-z]?$} $access] } proc isPeakInCentromere {PathPeaks PathCentromeres} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "isPeakInCentromere : Start" set FichierPeaks [open "$PathPeaks.coord" "r"] set FichierPeaksEnrichi [open "$PathPeaks.csv" "w"] set I 0 set O 0 set ListeDesID {} while { [gets $FichierPeaks LignePeak] >=0 } { incr I ScanLaListe $LignePeak chrom start end length summit tags peak fold set FichierCentromeres [open "$PathCentromeres.coord" "r"] while { [gets $FichierCentromeres LigneCentromeres] >=0 } { ScanLaListe $LigneCentromeres chromCentromeres startCentromeres endCentromeres if { $chrom == $chromCentromeres && $start >= $startCentromeres && $end <= $endCentromeres } { set LignePeak "$LignePeak Centromere" incr O break } } if {![regexp -all -nocase {Centromere} $LignePeak]} { set LignePeak "$LignePeak NoCentro" } puts $FichierPeaksEnrichi $LignePeak close $FichierCentromeres } close $FichierPeaks close $FichierPeaksEnrichi set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|isPeakInCentromere: End ($I/$O)" } proc isRegionComplete {rQuery rRef {minRefCoverage 0.9} {tolerance 2}} { if {[areRangeOverlapping [lrange $rQuery 0 1] [lrange $rRef 0 1]]} { # calcule longeurs set lQuery [expr abs([lindex $rQuery 1] - [lindex $rQuery 0]) + 1] set lRef [expr abs([lindex $rRef 1] - [lindex $rRef 0]) + 1] # calcule couverture if {[lindex $rQuery 0] < [lindex $rRef 0]} {set do [lindex $rRef 0]} else {set do [lindex $rQuery 0]} if {[lindex $rQuery 1] < [lindex $rRef 1]} {set fo [lindex $rQuery 1]} else {set fo [lindex $rRef 1]} set coverage [expr abs($do - $fo) + 1] set refCover [expr double($coverage) / $lRef] if {$refCover >= $minRefCoverage} {return 1} } return 0 } proc isSameFeature {featureA featureB} { array set a $featureA array set b $featureB if {$a(color) != $b(color)} {return 0} if {$a(start) >= $b(start) && $a(start) <= $b(stop) || $a(stop) >= $b(start) && $a(stop) <= $b(stop) || $b(start) >= $a(start) && $b(start) <= $a(stop) || $b(stop) >= $a(start) && $b(stop) <= $a(stop)} { return 1 } return 0 } proc itemScale {c x y} { global lastX lastY Vrp set dx [expr { $x - $lastX}] set dy [expr {-$y + $lastY}] set d [expr {sqrt($dx*$dx + $dy*$dy)}] if {$d < 10.} {return} if {$dy < 0} {set zoomIn 1} {set zoomIn 0} if {$zoomIn} { set scale [expr {1.0 + $d/500.0}] } else { set scale [expr {1.0/(1.0 + $d/500.0)}] } set Vrp(Scale) [expr {$Vrp(Scale) * $scale}] $c scale all $Vrp(CX) $Vrp(CY) $scale $scale ConfigureVrp $c set lastX $x set lastY $y return } proc itemStartDrag {c x y} { global lastX lastY set lastX $x set lastY $y $c scan mark $x $y return } proc itemStartScale {c x y} { global lastX lastY set lastX $x set lastY $y return } proc jROTATE {aa i j k l s ag ah tau} { upvar $aa a upvar $ah h upvar $ag g set g [expr {[set a($i,$j)]}] set h [expr {[set a($k,$l)]}] set a($i,$j) [expr {$g - $s * ($h + $g * $tau)}] set a($k,$l) [expr {$h + $s * ($g - $h * $tau)}] return } proc jacobi {aa av ad n} { upvar $aa a upvar $ad d upvar $av v set ERROR [expr {1.0 / 16777216.0}] set converge 0 # cree la matrice unitaire set Un [M_unit] T_M v $Un for {set ip 0} {$ip < $n} {incr ip} { set b($ip) [set a($ip,$ip)] set d($ip) [set a($ip,$ip)] set z($ip) 0.0 } # iteration pour converger set nrot 0 for {set i 0} {$i < 128} {incr i} { set sm 0.0 for {set ip 0} {$ip < $n - 1} {incr ip} { for {set iq [expr {$ip+1}]} {$iq<$n} {incr iq} { set sm [expr {$sm + abs([set a($ip,$iq)])}] } } if {$sm == 0.0} { set converge 1 break } if {$i < 3} { set thresh [expr {0.2 * $sm / ($n * $n)}] } else { set thresh 0.0 } for {set ip 0} {$ip < $n - 1} {incr ip} { for {set iq [expr {$ip+1}]} {$iq<$n} {incr iq} { set g [expr {1000000.0 * abs([set a($ip,$iq)])}] if {$i > 3 && abs([set d($ip)]) + $g == abs([set d($ip)]) && abs([set d($iq)]) + $g == abs([set d($iq)])} { set a($ip,$iq) 0.0 } elseif {abs([set a($ip,$iq)]) > $thresh} { set h [expr {[set d($iq)] - [set d($ip)]}] if {(abs($h) + $g) == abs($h)} { set t [expr {[set a($ip,$iq)] / $h}] } else { set theta [expr {0.5*$h/[set a($ip,$iq)]}] set t [expr {1.0 / (abs($theta) + sqrt(1.0 + $theta**2))}] if {$theta < 0.0} { set t [expr {-1.*$t}] } } set c [expr {1.0 / sqrt(1.0 + $t * $t)}] set s [expr {$t * $c}] set tau [expr {$s / (1.0 + $c)}] set h [expr {$t*[set a($ip,$iq)]}] set z($ip) [expr {[set z($ip)] - $h}] set z($iq) [expr {[set z($iq)] + $h}] set d($ip) [expr {[set d($ip)] - $h}] set d($iq) [expr {[set d($iq)] + $h}] set a($ip,$iq) 0.0 for {set j 0} {$j < $ip} {incr j} { jROTATE a $j $ip $j $iq $s g h $tau } for {set j [expr {$ip+1}]} {$j < $iq} {incr j} { jROTATE a $ip $j $j $iq $s g h $tau } for {set j [expr {$iq+1}]} {$j < $n} {incr j} { jROTATE a $ip $j $iq $j $s g h $tau } for {set j 0} {$j < $n} {incr j} { jROTATE v $j $ip $j $iq $s g h $tau } incr nrot } } } for {set ip 0} {$ip < $n} {incr ip} { set b(ip) [expr {[set b($ip)] + [set z($ip)]}] set d($ip) [set b($ip)] set z($ip) 0.0 } } if { $converge } { return $nrot } else { puts "Error: too many iterations to compute eigen vectors and eigen values." } return } proc jemenommelaetitia {} { Espionne "jemenommelaetitia" } proc jumprot95 {} { foreach Ligne [LesLignesDuFichier $FichierRedondance] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { set Vu($DD) 1 } } foreach Ligne [LesLignesDuFichier $FichierJumeaux] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach DD $LesJumeaux { set JumP($DD) 1 } #verifier s'ils sont deja ensemble ou pas } } proc kgXrefUcscMouse {{Qui ""} {Quoi ""}} { global kgXrefUcscMouse if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists kgXrefUcscMouse($Qui,$Quoi)]} {return $kgXrefUcscMouse($Qui,$Quoi)} if {[info exists kgXrefUcscMouse("EstCharge")]} {return ""} set kgXrefUcscMouse("EstCharge") 1 set Fichier "/genomics/link/UCSCGenomes/Mus_musculus/database/kgXref.txt" set LesLignes [LesLignesDuFichier $Fichier] set LesHeaders [list KgId mRNA SwAcc SwId Gn RsAcc ProtAcc Des] set kgXrefUcscMouse(ListOf,headers) $LesHeaders foreach Ligne $LesLignes { set LesMots [split $Ligne "\t"] set KgId [lindex $LesMots 0] set mRNA [lindex $LesMots 1] set SwAcc [lindex $LesMots 2] set SwId [lindex $LesMots 3] set Gn [lindex $LesMots 4] set GnMaj [string toupper $Gn] set GnMin [string tolower $Gn] set RsAcc [lindex $LesMots 5] set ProtAcc [lindex $LesMots 6] set Des [lindex $LesMots 7] regsub -all " " $Des "_" Des lappend kgXrefUcscMouse(ListOf,KgId) $KgId set kgXrefUcscMouse($KgId,Ligne) $Ligne set kgXrefUcscMouse($KgId,mRNA) $mRNA set kgXrefUcscMouse($KgId,SwAcc) $SwAcc set kgXrefUcscMouse($KgId,SwId) $SwId set kgXrefUcscMouse($KgId,Gn) $Gn set kgXrefUcscMouse($KgId,GnMaj) $GnMaj set kgXrefUcscMouse($KgId,GnMin) $GnMin set kgXrefUcscMouse($KgId,RsAcc) $RsAcc set kgXrefUcscMouse($KgId,ProtAcc) $ProtAcc set kgXrefUcscMouse($KgId,Des) $Des lappend kgXrefUcscMouse($mRNA,KgId) $KgId lappend kgXrefUcscMouse($SwAcc,KgId) $KgId lappend kgXrefUcscMouse($SwId,KgId) $KgId lappend kgXrefUcscMouse($Gn,KgId) $KgId lappend kgXrefUcscMouse($GnMaj,KgId) $KgId lappend kgXrefUcscMouse($GnMin,KgId) $KgId lappend kgXrefUcscMouse($RsAcc,KgId) $KgId lappend kgXrefUcscMouse($ProtAcc,KgId) $KgId lappend kgXrefUcscMouse($Des,KgId) $KgId #lien avec le Gn set kgXrefUcscMouse($RsAcc,Gn) $Gn lappend kgXrefUcscMouse($Gn,RsAcc) $RsAcc set kgXrefUcscMouse($ProtAcc,Gn) $Gn lappend kgXrefUcscMouse($Gn,ProtAcc) $ProtAcc set kgXrefUcscMouse($mRNA,Gn) $Gn lappend kgXrefUcscMouse($Gn,mRNA) $mRNA set kgXrefUcscMouse($SwAcc,Gn) $Gn lappend kgXrefUcscMouse($Gn,SwAcc) $SwAcc set kgXrefUcscMouse($RsAcc,GnMaj) $GnMaj lappend kgXrefUcscMouse($GnMaj,RsAcc) $RsAcc set kgXrefUcscMouse($ProtAcc,GnMaj) $GnMaj lappend kgXrefUcscMouse($GnMaj,ProtAcc) $ProtAcc set kgXrefUcscMouse($mRNA,GnMaj) $GnMaj lappend kgXrefUcscMouse($GnMaj,mRNA) $mRNA set kgXrefUcscMouse($SwAcc,GnMaj) $GnMaj lappend kgXrefUcscMouse($GnMaj,SwAcc) $SwAcc set kgXrefUcscMouse($RsAcc,GnMin) $GnMin lappend kgXrefUcscMouse($GnMin,RsAcc) $RsAcc set kgXrefUcscMouse($ProtAcc,GnMin) $GnMin lappend kgXrefUcscMouse($GnMin,ProtAcc) $ProtAcc set kgXrefUcscMouse($mRNA,GnMin) $GnMin lappend kgXrefUcscMouse($GnMin,mRNA) $mRNA set kgXrefUcscMouse($SwAcc,GnMin) $GnMin lappend kgXrefUcscMouse($GnMin,SwAcc) $SwAcc #lien avec la Des set kgXrefUcscMouse($RsAcc,Des) $Des lappend kgXrefUcscMouse($Des,RsAcc) $RsAcc set kgXrefUcscMouse($ProtAcc,Des) $Des lappend kgXrefUcscMouse($Des,ProtAcc) $ProtAcc set kgXrefUcscMouse($mRNA,Des) $Des lappend kgXrefUcscMouse($Des,mRNA) $mRNA set kgXrefUcscMouse($SwAcc,Des) $Des lappend kgXrefUcscMouse($Des,SwAcc) $SwAcc #lien entre Gn et Des lappend kgXrefUcscMouse($Gn,Des) $Des lappend kgXrefUcscMouse($Des,Gn) $Gn lappend kgXrefUcscMouse($GnMaj,Des) $Des lappend kgXrefUcscMouse($Des,GnMaj) $GnMaj lappend kgXrefUcscMouse($GnMin,Des) $Des lappend kgXrefUcscMouse($Des,GnMin) $GnMin #lien entre nucleique lappend kgXrefUcscMouse($RsAcc,mRNA) $mRNA lappend kgXrefUcscMouse($mRNA,RsAcc) $RsAcc #lien entre proteique lappend kgXrefUcscMouse($ProtAcc,SwAcc) $SwAcc lappend kgXrefUcscMouse($SwAcc,ProtAcc) $ProtAcc #lien entre nucleique et proteique lappend kgXrefUcscMouse($RsAcc,SwAcc) $SwAcc lappend kgXrefUcscMouse($SwAcc,RsAcc) $RsAcc lappend kgXrefUcscMouse($RsAcc,ProtAcc) $ProtAcc lappend kgXrefUcscMouse($ProtAcc,RsAcc) $RsAcc lappend kgXrefUcscMouse($mRNA,SwAcc) $SwAcc lappend kgXrefUcscMouse($SwAcc,mRNA) $mRNA lappend kgXrefUcscMouse($mRNA,ProtAcc) $ProtAcc lappend kgXrefUcscMouse($ProtAcc,mRNA) $mRNA } return [kgXrefUcscMouse $Qui $Quoi] } proc kill_balloon {} { global Bulle after cancel $Bulle(id) if {[winfo exists .balloon] == 1} { destroy .balloon } set Bulle(set) 0 } proc killjid {} { set Ll [LesLignesDuFichier jid] set Lid [list] foreach l [lrange $Ll 1 end] { set l [string trim $l] regsub -all { +} $l " " l set id [lindex [split $l " "] 0] lappend Lid $id if {[llength $Lid] > 100} { exec scancel {*}$Lid set Lid {} } } exit } proc knownToEnsemblUcscMouse {{Qui ""} {Quoi ""}} { global knownToEnsemblUcscMouse if {$Qui==""} { set Qui "ListOf" ; set Quoi "headers" } if {[info exists knownToEnsemblUcscMouse($Qui,$Quoi)]} {return $knownToEnsemblUcscMouse($Qui,$Quoi)} if {[info exists knownToEnsemblUcscMouse("EstCharge")]} {return ""} set knownToEnsemblUcscMouse("EstCharge") 1 set Fichier "/genomics/link/UCSCGenomes/Mus_musculus/database/knownToEnsembl.txt" set LesLignes [LesLignesDuFichier $Fichier] set LesHeaders [list Acc EnsTran] set knownToEnsemblUcscMouse(ListOf,headers) $LesHeaders foreach Ligne $LesLignes { set LesMots [split $Ligne "\t"] set Acc [lindex $LesMots 0] set EnsTranComp [lindex $LesMots 1] set EnsTran [lindex [split $EnsTranComp "."] 0] lappend knownToEnsemblUcscMouse($Acc,EnsTran) $EnsTran lappend knownToEnsemblUcscMouse($EnsTran,Acc) $Acc } return [knownToEnsemblUcscMouse $Qui $Quoi] } proc krs {} { set ali [Mafft_AddSequences D_WithModules.tfa syk.tfa] set o [open kd.tfa w] puts $o [join $ali \n] close $o exit } proc krs2 {} { global TDesPCI ListePDB set s Q15046 foreach p $ListePDB { lassign [set TDesPCI($s,$p)] pc l1 l2 set pc [expr {100.*$pc}] puts "$p [format %6.2f $pc] $l2" } exit } proc lanceAjoutCons {ficMacsims} { global PipeCollection set PipeCollection 1 AjoutConservationMacsims $ficMacsims Cluster return 1 } proc lanceblast5000ForMS2PHdb {} { foreach pab [ListeDesPABs] { puts "traite $pab" set ficBl5000 [file join [RepertoireDuGenome] "blastp5000" $pab] if { ![file exists $ficBl5000] } { puts "lance blastp pour $pab" set ficIn [file join [RepertoireDuGenome] "prottfa" $pab] set cmd "blastall -p blastp -d protein -v 5000 -b 0 -e 0.001 -i $ficIn -o $ficBl5000" eval exec $cmd } } return 1 } proc land {a b} { set la {} foreach e $a { set Vu($e) 1 } foreach e $b { if {[info exists Vu($e)]} { lappend la $e } } return $la } proc landInd {a b} { set la {} foreach e $a { set n [lsearch $b $e] if {$n != -1} { # puts "commun : $e" lappend la $n } } return $la } proc lengthFilter {sequence {XminLength 200} {minLength 100}} { # initialize return value array set retArray {sequence "" range {} keep -1 messages {}} # check if sequence if masked set haveX [regexp -nocase {x} $sequence] # find sequence ranges without mask set noMaskRanges [regexp -indices -inline -all -nocase {[^x]+} $sequence] # set return value if {$haveX} { # find the largest range without mask set largestRange {} set largestRangeLength 0 foreach r $noMaskRanges { set length [expr [lindex $r 1] - [lindex $r 0] + 1] if {$length > $largestRangeLength} { set largestRange $r set largestRangeLength $length } } if {$largestRangeLength >= $XminLength} { set lIdx [lindex $largestRange 0] set rIdx [lindex $largestRange 1] set retArray(sequence) [string range $sequence $lIdx $rIdx] set retArray(range) $largestRange set retArray(keep) 1 lappend retArray(messages) "Selecting sequence from [expr $lIdx + 1] to [expr $rIdx + 1], length $largestRangeLength" } else { # initialize return value set retArray(sequence) $sequence set retArray(range) [list 0 [expr [string length $sequence] - 1]] set retArray(keep) 0 lappend retArray(messages) "Length $largestRangeLength < XminLength $XminLength" } } else { set length [string length $sequence] if {$length >= $minLength} { set retArray(sequence) $sequence set retArray(range) [list 0 [expr [string length $sequence] - 1]] set retArray(keep) 1 lappend retArray(messages) "Selecting whole sequence, length $length" } else { set retArray(sequence) $sequence set retArray(range) [list 0 [expr [string length $sequence] - 1]] set retArray(keep) 0 lappend retArray(messages) "Length $length < minLength $minLength" } } if {$retArray(keep) == -1} { puts "ERROR: Problem with length filter" exit 1 } return [array get retArray] } proc lequal {a b} { set rep 1 foreach e $a f $b { if {$e != $f} { set rep 0 break } } return $rep } proc lesOrthologs {nomRepertoireBlast {listOrgas ""}} { if {$listOrgas==""} {set liste {"Saccharomyces cerevisiae" "Xenopus tropicalis"}} GiveMeThisOrthologs $nomRepertoireBlast $liste "toLogs" } proc lesOrthologsTous {nomRepertoireBlast} { #set liste [ConcernedOrganisms "proteomeToBlast.fasta"] set liste {"Anopheles gambiae" "Alvinella pompejana" "Arabidopsis thaliana" "Caenorhabditis elegans" "Dictyostelium discoideum" "Drosophila melanogaster" "Encephalitozoon cuniculi" "Entamoeba histolytica" "Gallus gallus" "Giardia lamblia" "Homo sapiens" "Mus musculus" "Nematostella vectensis" "Plasmodium falciparum" "Saccharomyces cerevisiae" "Schistosoma japonicum" "Strongylocentrotus purpuratus" "Trypanosoma brucei" "Tetraodon nigroviridis" "Theileria parva" "Xenopus tropicalis"} GiveMeThisOrthologs2 $nomRepertoireBlast $liste "toLogs" } proc lesParalogs {nomRepertoireBlast {listOrgas ""}} { if {$listOrgas==""} {set liste {"Saccharomyces cerevisiae" "Xenopus tropicalis"}} GiveMeThisParalogs $nomRepertoireBlast $liste "toLogs" } proc lesParalogsTous {nomRepertoireBlast} { set liste [ConcernedOrganisms "proteomeToBlast.fasta"] #set liste {"Anopheles gambiae" "Alvinella pompejana" "Arabidopsis thaliana" "Caenorhabditis elegans" "Dictyostelium discoideum" "Drosophila melanogaster" "Encephalitozoon cuniculi" "Entamoeba histolytica" "Gallus gallus" "Giardia lamblia" "Homo sapiens" "Mus musculus" "Nematostella vectensis" "Plasmodium falciparum" "Saccharomyces cerevisiae" "Schistosoma japonicum" "Strongylocentrotus purpuratus" "Trypanosoma brucei" "Tetraodon nigroviridis" "Theileria parva" "Xenopus tropicalis"} GiveMeThisParalogs2 $nomRepertoireBlast $liste "toLogs" } proc light_color3f {a b c} { set le [list $a $b $c 1.0] glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE $le glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR [list 1.0 1.0 1.0 1.0] glMaterialfv GL_FRONT_AND_BACK GL_EMISSION [list 0.0 0.0 0.0 1.0] glMaterialfv GL_FRONT_AND_BACK GL_SHININESS 100. return } proc light_color3fv {a} { lappend a 1.0 glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE $a glMaterialfv GL_FRONT GL_SPECULAR [list 1.0 1.0 1.0 1.0] #glMaterialfv GL_FRONT GL_EMISSION [list 0.0 0.0 0.0 1.0] glMaterialfv GL_FRONT GL_SHININESS 100. return } proc lireFichierIds {Fichier} { set Liste {} if {$Fichier ne ""} { set f [open $Fichier r] while {[gets $f line] >= 0} { lappend Liste $line } close $f } return $Liste } proc listMean {list} { set sum 0 foreach e $list {incr sum $e} return [expr double($sum) / [llength $list]] } proc listePdbs {{prot ""}} { if {$prot==""} {Espionne "vous devez indiquer la sequence souhaiter:"; exit} #set r [glob -directory [RepertoireDuGenome]/pdb/$prot] set FichierDepart [RepertoireDuGenome]/pdb/$prot foreach Ligne [LesLignesDuFichier $FichierDepart] { if {[regexp {^>(\w*)} $Ligne tmp access]} { lappend listSeq $access } } return $listSeq } proc listedes931 {Fichier931etjum} { foreach Ligne [LesLignesDuFichier $Fichier931etjum] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set JR [lindex $LesJumeaux 0] lappend Liste $JR } Espionne [llength $Liste] return $Liste } proc listeles30ok {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set Ligne [split $Ligne "\t"] set DD [lindex $Ligne 1] lappend Liste $DD } return $Liste } proc ll {} { puts [ContenuDuFichier [RepertoireDuGenome]] } proc llower {l} { set o [list] foreach e $l { lappend o [string tolower $e] } return $o } proc lmPDBSearch {} { package require http ::http::config -urlencoding utf-8 # set xml "\" 0 head org.pdb.query.simple.EnzymeClassificationQuery Enzyme Classification Search : EC=6.1.1.* 6.1.1.* 1 and head org.pdb.query.simple.ExpTypeQuery Experimental Method is X-RAY X-RAY \"" set xml " B0907 org.pdb.query.simple.ExpTypeQuery Experimental Method Search : Experimental Method=SOLID-STATE NMR SOLID-STATE NMR " set url "http://www.rcsb.org/pdb/rest/search/" # set url "http://lbgi.fr" set query [::http::formatQuery data "$xml"] puts "[string range $query 0 end]" #set query [string range $query 6 end] # set rep [HttpCopy $url -query $query] set rep [::http::geturl $url -query $query] exit puts "$rep" puts "[info body ::http::geturl]" #set rep [::http::data [::http::geturl $url]] #exit #set rep [::http::data [::http::geturl $url -query $query]] exit } proc ln_arraytype_analysissoftware {} { WithWebService "Gx" 0 set LesTetes "pk_arraytype,pk_analysissoftware" #set LesChipAcLesAs [list Mouse430_2 Mouse430A_2 MG_U74Av2 MG_U74Bv2 MG_U74Cv2 MG_U74ABv2 MG_U74ABCv2 HG-U133_Plus_2 HG-U133A HG-U133B HG_U95Av2 HG_U95A HG_U95B HG_U95C HG_U95D HG_U95E HG_U95ABCDE HG_U95Av2BCDE RG_U34A Chicken DrosGenome1 Zebrafish Xenopus_laevis Celegans] set LesChipAcLesAs [list Celegans] set LesAs [list RMA gcRMA MAS5.0 dChip PLIER VSN] foreach Chip $LesChipAcLesAs { set PkAt [GxDbSqlExec "select pk_arraytype from arraytype where name='$Chip';" "GetFirstValue"] foreach As $LesAs { set PkAs [GxDbSqlExec "select pk_analysissoftware from analysissoftware where name='$As';" "GetFirstValue"] set Ligne "$PkAt,$PkAs" set status [GxDbSqlExec "insert into ln_arraytype_analysissoftware ($LesTetes) values ($Ligne);"] } } } proc log_gamma {x} { if {$x <= 0} { error "Invalid input" } if {$x < 12.0} { return [expr {log(abs([gamma $x]))}] } # Abramowitz and Stegun 6.1.41 # Asymptotic series should be good to at least 11 or 12 figures # For error analysis, see Whittiker and Watson # A Course in Modern Analysis (1927), page 252 set c [list 1.0/12.0 -1.0/360.0 1.0/1260.0 -1.0/1680.0 1.0/1188.0 -691.0/360360.0 1.0/156.0 -3617.0/122400.0 ] set z [expr {1.0/($x*$x)}] set sum [lindex $c 7] for {set i 6} {$i >= 0} {incr i -1} { set sum [expr $sum * $z] set sum [expr $sum + [lindex $c $i]] } set series [expr $sum/$x] set halfLogTwoPi 0.91893853320467274178032973640562 set logGamma [expr {($x - 0.5)*log($x) - $x + $halfLogTwoPi + $series}] return $logGamma } proc logrr {what w h} { puts "\n$what" puts "request $w $h" puts "actual [winfo width .t] [winfo height .t]" puts "full [wm attributes .t -fullscreen]" puts "zoomed [wm attributes .t -zoomed]" return } proc longueurMoyenneSequencesFichier {fichierTFA} { array set tfa [readFasta $fichierTFA] set longueurTotale 0 set nombreDeSequences [llength $tfa(index)] foreach seqIdx $tfa(index) { incr longueurTotale [string length [join [lrange $tfa($seqIdx) 1 end] {}]] } return [expr $longueurTotale / $nombreDeSequences] } proc lor {a b {what all}} { if {$what eq "from1" || $what eq "all"} { foreach elt $b { set tb($elt) 1 } set l1 {} foreach elt $a { if {! [info exists tb($elt)]} { lappend l1 $elt } } } if {$what eq "from2" || $what eq "all"} { foreach elt $a { set ta($elt) 1 } set l2 {} foreach elt $b { if {! [info exists ta($elt)]} { lappend l2 $elt } } } switch $what { "from1" {return $l1} "from2" {return $l2} "all" {return [concat $l1 $l2]} } } proc lorga {} { global TDesOrganismes SDG LNDG TDuLineage foreach g $LNDG { set Lo [list] foreach s [set SDG($g)] { lappend Lo [set TDesOrganismes($s)] } set Lo [lsort -unique $Lo] puts "groupe $g\n[join $Lo \n]\n" } return } proc lscan {liste elt} { set i 0 foreach s $liste { if {[regexp $elt $s]} {lappend lhit $i} incr i } return $lhit } proc lsearchNodeKeyGraphFilter {args} { # lsearchNodeKeyGraphFilter ? lsearch_options ? node_key pattern foreach {key pattern graph node} [lrange $args end-3 end] {} regsub -all {\"} $pattern {\\\0} pattern set lsearchOptions [lrange $args 0 end-4] if {[$graph node keyexists $node $key] && [eval "lsearch $lsearchOptions \[$graph node get $node $key\] \"$pattern\""] != -1} { return 1 } return 0 } proc lso {} { set L [LesLignesDuFichier lso] set FichierCommande "usethisname_/genomics/link/ProGS/atelier/Arnaud/AFaire20061010.txt" CommandeOligos $L $FichierCommande } proc lsortBySublistsLengths {a b} { set lengthA [llength $a] set lengthB [llength $b] if {$lengthA < $lengthB} { return -1 } elseif {$lengthA > $lengthB} { return 1 } return 0 } proc lsqsup {sys p1} { # activer lsqman par : setusf # if {! [file exists "${p1}.pdb"]} { set pdb [TextePDB $p1 ALL OnTheWeb] set f [open "${p1}.pdb" w] puts $f $pdb close $f } else { set pdb [ContenuDuFichier "${p1}.pdb"] } set o [open "|lsqman " w] #fconfigure $o -buffering line #fileevent $o readable [list LogSup $o] file delete ${sys}1.pdb ${sys}2.pdb set cmd "re m1 ${p1}.pdb re m2 ${sys}_mon1.pdb br m1 A m2 A 50 25 100 im m1 A1-999 m2 A1-999 ap m1 m2 wr m2 ${sys}1.pdb re m3 ${sys}_mon2.pdb br m1 B m3 A 50 25 100 im m1 B1-999 m3 A1-999 ap m1 m3 wr m3 ${sys}2.pdb qu " puts $o $cmd flush $o catch {close $o} set l2 [ContenuDuFichier ${sys}2.pdb] set l2 [string map {" A " " B "} $l2] set L2 [split $l2 \n] set L1 [LesLignesDuFichier ${sys}1.pdb] set Ldim [lrange $L1 0 end-1] lappend Ldim "TER " lappend Ldim {*}$L2 set f [open ${sys}_model.pdb w] puts $f [join $Ldim \n] close $f puts "" puts "All done !!" puts "" exit } proc lsublist {l n} { set nl {} foreach e $l { lappend nl [lindex $e $n] } return $nl } proc lunique {l} { set res {} foreach e $l { if {! [info exists t($e)]} { set t($e) 1 lappend res $e } } return $res } proc lupper {l} { set o [list] foreach e $l { lappend o [string toupper $e] } return $o } proc mRNAChoisiOuPas {FichierDesPABs FichierSortie} { #FichierDesPABs=fiches/LesPABsSansJumeauxSeqSansCourts set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] set Zero 0; set Un 0; set NoHuman 0 foreach Nom $L { set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] if {$AccessmRNA=="" || $AccessmRNA=="NOMRNA"} { set mRNA 0 incr Zero } elseif {$Orga=="Homo sapiens"} {set mRNA 1; incr Un; lappend LesAccessmRNAHuman $AccessmRNA} if {$AccessmRNA!="NOMRNA" && $AccessmRNA!="" && $Orga!="Homo sapiens"} {set mRNA 1; incr NoHuman; lappend LesAccessmRNANotHuman $AccessmRNA} lappend Liste "$Nom\t$mRNA" } Espionne [llength $Liste] set ListeTriee [lsort -unique $Liste] Espionne [llength $ListeTriee] Espionne "Nb sans: $Zero - Nb mrna_human: $Un - Nb mrna_nothuman: $NoHuman" #set ListeTriee2 [lsort -index 1 $ListeTriee] SauveLesLignes $ListeTriee dans $FichierSortie Espionne "nb mrna human avt tri : [llength $LesAccessmRNAHuman]" set LesAccessmRNAHumanUnique [lsort -unique $LesAccessmRNAHuman] Espionne "nb mrna human sans doublons : [llength $LesAccessmRNAHumanUnique]" Espionne "nb mrna NOT human avt tri : [llength $LesAccessmRNANotHuman]" set LesAccessmRNANotHumanUnique [lsort -unique $LesAccessmRNANotHuman] Espionne "nb mrna NOT human sans doublons : [llength $LesAccessmRNANotHumanUnique]" } proc mRNAHsapLocalisation {Nom FileExonicMap {mRNAouBox mRNA}} { set FileEM $FileExonicMap if {![file exists $FileEM]} {return} set TailleFragment 100000 set LeTexte {} set LesRangs [InterrogeFichierExonicMap $FileEM LesRangs] set BestLoc "BestLoc" set InfoLoc "MonoLoc" if {1 < [llength $LesRangs]} {set InfoLoc "PolyLoc";set BestLoc "BestPolyLoc"} foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FileEM Rang $Rang Chromosome] set Contig [InterrogeFichierExonicMap $FileEM Rang $Rang Contig ] set LesContigsFrag [InterrogeFichierExonicMap $FileEM Rang $Rang ContigFragments] set nChiffresFragContig [string length [lindex $LesContigsFrag 0]] set NbExonicAreas [InterrogeFichierExonicMap $FileEM Rang $Rang NbExonicAreas] if {$NbExonicAreas <= 0} {continue} set LesRegions {} for {set i 1} {$i <= $NbExonicAreas} {incr i} { set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i nAli ] set Id [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $i Identity] lappend LesRegions [list $i $nAli $Id] } set LesRegions [lsort -index 1 -real -decreasing [lsort -index 2 -real -decreasing $LesRegions]] set nAliMax [lindex [lindex $LesRegions 0] 1] set EstCeLePremier 1 foreach LaRegion $LesRegions { set Info "" if {$EstCeLePremier} {set Info $BestLoc;set EstCeLePremier 0} set ExonArea [lindex $LaRegion 0] set nAli [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea nAli ] set Id [expr [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Identity]/100] set DQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DQ ] set FQ [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FQ ] set DS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea DS ] set FS [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea FS ] set Orient [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Orientation] set Sens [InterrogeFichierExonicMap $FileEM Rang $Rang ExonArea $ExonArea Sens ] set Fragments "" if {0 < $nChiffresFragContig} { set FragmentMin [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Mini $DS $FS] / $TailleFragment)]] set FragmentMax [format "%${nChiffresFragContig}.${nChiffresFragContig}d" [expr round([Maxi $DS $FS] / $TailleFragment)]] set Fragments $FragmentMin if {$FragmentMin != $FragmentMax} {set Fragments [string trim "$FragmentMin $FragmentMax"]} } set LaLocSurLeChrom [CoordonneesSurChromosome $Contig $DS $FS $Sens] set DChrom [lindex $LaLocSurLeChrom 1] set FChrom [lindex $LaLocSurLeChrom 2] set SensChrom [lindex $LaLocSurLeChrom 3] set BandesCyto {} foreach LaBC [LesBandesCytologiquesDeLaRegion [NumeroDuChromosome $Chromosome] $DChrom $FChrom] { lappend BandesCyto [lindex $LaBC 0] } set BandesCyto [join $BandesCyto " "] set EMax "" set E "" set Ligne "$Nom\t$InfoLoc\t$EMax\t$E\t$nAliMax\t$nAli\t$Id\t$DQ\t$FQ\t$Chromosome\t$DChrom\t$FChrom\t$SensChrom\t$Contig\t$Fragments\t$DS\t$FS\t$Orient\t$Sens\t$BandesCyto\t$Info" if {$mRNAouBox == "mRNA"} {set Ligne "$Ligne\tmrnatfa_Homo_sapiens"} lappend LeTexte $Ligne } } InterrogeFichierExonicMap unset return $LeTexte } proc mama {} { package require sqlite3 set db "root" sqlite3 $db misynpat.sql set Lm [$db eval {select distinct(ldisease) from disease}] set o [open maladies.txt w] puts $o [join $Lm \n] close $o $db close exit } proc mapuce {} { LoadTkAndPackages set w .puce frame $w -background black grid $w -row 0 -column 0 -sticky news set c $w.can canvas $c -background black -width 800 -height 800 grid $c -row 0 -column 0 -sticky news set off 20 set diam 600 set ray [expr {$diam/2}] set cenx [expr {$off+$ray}] set ceny [expr {$off+$ray}] $c create oval $off $off [expr {$off+$diam}] [expr {$off+$diam}] -outline white -width 1 for {set i 0} {$i < 5} {incr i} { set ang [expr {(72.*$i)*[2Pi]/360.}] set p($i,x) [expr {int($ray*cos($ang)+$cenx)}] set p($i,y) [expr {int($ray*sin($ang)+$ceny)}] $c create oval $p($i,x) $p($i,y) $p($i,x) $p($i,y) -width 15 -fill white -outline white } # trace etoile for {set i 0} {$i < 5} {incr i} { set dep [expr {$i+2}] if {$dep >= 5} {set dep [expr {$dep - 5}]} set fin [expr {$i-2}] if {$fin < 0} {set fin [expr {5 + $fin}]} # etoile $c create line $p($i,x) $p($i,y) $p($dep,x) $p($dep,y) -fill white -tags etoile $c create line $p($i,x) $p($i,y) $p($fin,x) $p($fin,y) -fill white -tags etoile # le verre set vecxd [expr {int(($p($dep,x)-$p($i,x))*0.2+$p($i,x))}] set vecyd [expr {int(($p($dep,y)-$p($i,y))*0.2+$p($i,y))}] set vecxf [expr {int(($p($fin,x)-$p($i,x))*0.2+$p($i,x))}] set vecyf [expr {int(($p($fin,y)-$p($i,y))*0.2+$p($i,y))}] $c create polygon $p($i,x) $p($i,y) $vecxd $vecyd $vecxf $vecyf -width 20 -fill grey -tags verre set midxd [expr {int(($p($i,x)+$p($dep,x))/2)}] set midyd [expr {int(($p($i,y)+$p($dep,y))/2)}] $c create line $p($i,x) $p($i,y) $midxd $midyd -width 10 -fill cyan -tags bcyan set midxf [expr {int(($p($i,x)+$p($fin,x))/2)}] set midyf [expr {int(($p($i,y)+$p($fin,y))/2)}] $c create line $p($i,x) $p($i,y) $midxf $midyf -width 10 -fill red -tags bred } set ::FaireLireNon 0 $c raise verre $c itemconfig verre -fill black -width 0 $c itemconfig bred -fill black -width 0 $c itemconfig bcyan -fill black -width 0 $c raise etoile PrintCanvas $c "" etoile.png FaireLire "next" $c itemconfig verre -fill grey -width 20 $c raise verre PrintCanvas $c "" verre.png FaireLire "next" $c itemconfig bred -fill red -width 15 $c itemconfig bcyan -fill cyan -width 15 $c raise bred bcyan $c lower etoile PrintCanvas $c "" all.png FaireLire "next" $c itemconfig bred -width 25 $c itemconfig bcyan -width 5 PrintCanvas $c "" desusdessous.png FaireLire "next" $c configure -width 1500 -height 1000 # profil droit $c delete all set Lverre [list 50 150 500 150 500 650 250 650 250 450 50 350] $c create polygon $Lverre -fill grey -tags verre set Lgauche [list 300 300 800 580 1000 580 1200 300] $c create line $Lgauche -width 10 -tags gauche -fill cyan set Ldroit [list 300 300 800 20 1000 20 1200 300] $c create line $Ldroit -width 50 -tags droit -fill red $c raise gauche $c raise verre $c raise droit PrintCanvas $c "" profil_droit.png FaireLire "next" # profil gauche $c delete all set Lverre [list 50 150 500 150 500 650 250 650 250 450 50 350] set tmp [list] foreach {x y} $Lverre { lappend tmp [expr {1500-$x}] $y } set Lverre $tmp $c create polygon $Lverre -fill grey -tags verre set Lgauche [list 300 300 800 580 1000 580 1200 300] set tmp [list] foreach {x y} $Lgauche { lappend tmp [expr {1500-$x}] $y } set Lgauche $tmp $c create line $Lgauche -width 50 -tags gauche -fill cyan set Ldroit [list 300 300 800 20 1000 20 1200 300] set tmp [list] foreach {x y} $Ldroit { lappend tmp [expr {1500-$x}] $y } set Ldroit $tmp $c create line $Ldroit -width 10 -tags droit -fill red $c raise droit $c raise verre $c raise gauche PrintCanvas $c "" profil_gauche.png FaireLire "next" return } proc marieid {} { set Ll [LesLignesDuFichier ListeOG.txt] foreach l $Ll { regsub -all {\t+} $l "\t" l set Lv [split $l "\t"] lappend Lid [lindex $Lv 2] } set o [open marie.id w] puts $o [join $Lid \n] close $o exit } proc matDefine {FichierSequence} { set FileIn [open "$FichierSequence.txt" "r"] set A0 0 set T0 0 set C0 0 set G0 0 set A1 0 set T1 0 set C1 0 set G1 0 set A2 0 set T2 0 set C2 0 set G2 0 set A3 0 set T3 0 set C3 0 set G3 0 set A4 0 set T4 0 set C4 0 set G4 0 set A5 0 set T5 0 set C5 0 set G5 0 set A6 0 set T6 0 set C6 0 set G6 0 set A7 0 set T7 0 set C7 0 set G7 0 set A8 0 set T8 0 set C8 0 set G8 0 set A9 0 set T9 0 set C9 0 set G9 0 set A10 0 set T10 0 set C10 0 set G10 0 set A11 0 set T11 0 set C11 0 set G11 0 set A12 0 set T12 0 set C12 0 set G12 0 set A13 0 set T13 0 set C13 0 set G13 0 set A14 0 set T14 0 set C14 0 set G14 0 set A15 0 set T15 0 set C15 0 set G15 0 set A16 0 set T16 0 set C16 0 set G16 0 set A17 0 set T17 0 set C17 0 set G17 0 set A18 0 set T18 0 set C18 0 set G18 while { [gets $FileIn Ligne] >=0 } { set seqSplit [split $Ligne ""] if {$seqSplit[0] = "A"} { incr A0 } if {$seqSplit[0] = "T"} { incr T0 } if {$seqSplit[0] = "C"} { incr C0 } if {$seqSplit[0] = "G"} { incr G0 } if {$seqSplit[1] = "A"} { incr A1 } if {$seqSplit[1] = "T"} { incr T1 } if {$seqSplit[1] = "C"} { incr C1 } if {$seqSplit[1] = "G"} { incr G1 } if {$seqSplit[2] = "A"} { incr A2 } if {$seqSplit[2] = "T"} { incr T2 } if {$seqSplit[2] = "C"} { incr C2 } if {$seqSplit[2] = "G"} { incr G2 } if {$seqSplit[3] = "A"} { incr A3 } if {$seqSplit[3] = "T"} { incr T3 } if {$seqSplit[3] = "C"} { incr C3 } if {$seqSplit[3] = "G"} { incr G3 } if {$seqSplit[4] = "A"} { incr A4 } if {$seqSplit[4] = "T"} { incr T4 } if {$seqSplit[4] = "C"} { incr C4 } if {$seqSplit[4] = "G"} { incr G4 } if {$seqSplit[5] = "A"} { incr A5 } if {$seqSplit[5] = "T"} { incr T5 } if {$seqSplit[5] = "C"} { incr C5 } if {$seqSplit[5] = "G"} { incr G5 } if {$seqSplit[6] = "A"} { incr A6 } if {$seqSplit[6] = "T"} { incr T6 } if {$seqSplit[6] = "C"} { incr C6 } if {$seqSplit[6] = "G"} { incr G6 } if {$seqSplit[7] = "A"} { incr A7 } if {$seqSplit[7] = "T"} { incr T7 } if {$seqSplit[7] = "C"} { incr C7 } if {$seqSplit[7] = "G"} { incr G7 } if {$seqSplit[8] = "A"} { incr A8 } if {$seqSplit[8] = "T"} { incr T8 } if {$seqSplit[8] = "C"} { incr C8 } if {$seqSplit[8] = "G"} { incr G8 } if {$seqSplit[9] = "A"} { incr A9 } if {$seqSplit[9] = "T"} { incr T9 } if {$seqSplit[9] = "C"} { incr C9 } if {$seqSplit[9] = "G"} { incr G9 } if {$seqSplit[10] = "A"} { incr A10 } if {$seqSplit[10] = "T"} { incr T10 } if {$seqSplit[10] = "C"} { incr C10 } if {$seqSplit[10] = "G"} { incr G10 } if {$seqSplit[11] = "A"} { incr A11 } if {$seqSplit[11] = "T"} { incr T11 } if {$seqSplit[11] = "C"} { incr C11 } if {$seqSplit[11] = "G"} { incr G11 } if {$seqSplit[12] = "A"} { incr A12 } if {$seqSplit[12] = "T"} { incr T12 } if {$seqSplit[12] = "C"} { incr C12 } if {$seqSplit[12] = "G"} { incr G12 } if {$seqSplit[13] = "A"} { incr A13 } if {$seqSplit[13] = "T"} { incr T13 } if {$seqSplit[13] = "C"} { incr C13 } if {$seqSplit[13] = "G"} { incr G13 } if {$seqSplit[14] = "A"} { incr A14 } if {$seqSplit[14] = "T"} { incr T14 } if {$seqSplit[14] = "C"} { incr C14 } if {$seqSplit[14] = "G"} { incr G14 } if {$seqSplit[15] = "A"} { incr A15 } if {$seqSplit[15] = "T"} { incr T15 } if {$seqSplit[15] = "C"} { incr C15 } if {$seqSplit[15] = "G"} { incr G15 } if {$seqSplit[16] = "A"} { incr A16 } if {$seqSplit[16] = "T"} { incr T16 } if {$seqSplit[16] = "C"} { incr C16 } if {$seqSplit[16] = "G"} { incr G16 } if {$seqSplit[17] = "A"} { incr A17 } if {$seqSplit[17] = "T"} { incr T17 } if {$seqSplit[17] = "C"} { incr C17 } if {$seqSplit[17] = "G"} { incr G17 } if {$seqSplit[18] = "A"} { incr A18 } if {$seqSplit[18] = "T"} { incr T18 } if {$seqSplit[18] = "C"} { incr C18 } if {$seqSplit[18] = "G"} { incr G18 } } close $FileIn Espionne "A: $A0 $A1 $A2 $A3 $A4 $A5 $A6 $A7 $A8 $A9 $A10 $A0 $A11 $A12 $A13 $A14 $A15 $A16 $A17 $A18" Espionne "T: $T0 $T1 $T2 $T3 $T4 $T5 $T6 $T7 $T8 $T9 $T10 $T0 $T11 $T12 $T13 $T14 $T15 $T16 $T17 $T18" Espionne "C: $C0 $C1 $C2 $C3 $C4 $C5 $C6 $C7 $C8 $C9 $C10 $C0 $C11 $C12 $C13 $C14 $C15 $C16 $C17 $C18" Espionne "G: $G0 $G1 $G2 $G3 $G4 $G5 $G6 $G7 $G8 $G9 $G10 $G0 $G11 $G12 $G13 $G14 $G15 $G16 $G17 $G18" } proc matecg {} { set tot 78089 set Lv [list 46 447 75505 1263 828] foreach v $Lv { incr tmp $v } puts "tot $tot $tmp" set n 23 set sx 0.0 set sr 0 while {1} { puts "n=$n" foreach v $Lv { set x [expr {double($v)/$tot*$n}] set sx [expr {$sx+$x}] set r [expr {round($x)}] set i [expr {int($x)}] puts "$v $x $r $i" incr sr $r incr si $i } puts "$sx" puts "$sr" puts "$si" if {$sr < $n} { incr n } else { break } puts "" } exit } proc maxSNP {} { CanalSqlUcscHuman set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "maxSNP|$timestamp : Start" set max 0 foreach chrom {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 X Y} { Espionne "maxSNP|$timestamp : Scanning chromosome $chrom" set oldEnd 0 foreach Ligne [SqlExec "SELECT chrom, chromStart, chromEnd FROM ucschuman.snp130 WHERE chrom='chr$chrom' ORDER BY chromStart ASC" "-list"] { ScanLaListe $Ligne chrom chromStart chromEnd set distance [expr $chromStart - $oldEnd] if {$distance > $max} { set max $distance Espionne "====> New max = $max" } set oldEnd $chromEnd } } set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "maxSNP|$timestamp : End. Maximum distance is $max" } proc mimeGetPartName {token} { set params [mime::getproperty $token params] set i [lsearch -exact $params name] if {$i >= 0} { incr i return [lindex $params $i] } return "" } proc mimeGetParts {token} { set parts {} if {! [catch {mime::getproperty $token parts}]} { foreach p [mime::getproperty $token parts] { lappend parts $p foreach p1 [mimeGetParts $p] { lappend parts $p1 } } } return $parts } proc mimeSaveFile {token} { global outdir debug typeExts totalAttachments #get the attachment name set name [mimeGetPartName $token] #if attachment does not have a name return. if {! [string length $name]} { return } set name [string map {\\ _ / _ : _ * _ ? _ \" _ < _ > _ | _} $name] #make unique filename #break up file name if {[llength [split $name .]] > 1} { set fn [join [lrange [split $name .] 0 end-1] .] set ext [lindex [split $name .] end] } else { set fn $name set ext txt } if {[lsearch -glob $typeExts "[mime::getproperty $token content] *"] > -1} { set ext [lindex [lsearch -glob -inline $typeExts "[mime::getproperty $token content] *"] 1] } #filename set file [file normalize [file join $outdir $fn.$ext]] #create a new filename for {set i 0} {[file exists $file]} {incr i} { set file [file join $outdir $fn.$i.$ext] } #save attachment set f [open $file w+] mime::copymessage $token $f close $f #decode attachment decode $file incr totalAttachments return } proc minMaxRangeOfList {list} { if {[llength $list] == 0} {return ""} set min [lindex $list 0] set max [lindex $list 1] foreach i [lrange $list 1 end] { if {$i < $min} {set min $i} if {$i > $max} {set max $i} } return [list $min $max] } proc mlog {} { set Ll [LesLignesDuFichier "mlog"] foreach l $Ll { set l [string trim $l] while {[regsub -all " " $l " " tmp]} {set l $tmp} set Le [split $l " "] lappend meme [lindex $Le 6] } set meme [lsort -unique $meme] puts "[join $meme "\n"]" exit } proc modifFic {file} { set fileOut [file join [RepertoireDuGenome] "msf_nature" "Rascal" "Leon" "out"] set f [open $fileOut w] foreach li [LesLignesDuFichier $file] { if {[regexp "pour " $li]} { regsub -all "pour " $li "" li } if {[regexp "norMD : " $li]} { regsub -all "norMD : " $li "" li } puts $f $li } close $f return 1 } proc modifFic2 {file} { set l {} set fileOut [file join [RepertoireDuGenome] "msf_nature" "Rascal" "Leon" "out2"] set f [open $fileOut w] foreach li [LesLignesDuFichier $file] { if {$l == "" && [regexp "nPDB" $li]} { set l $li } elseif {![regexp "nPDB" $li]} { puts $f "$l\t$li" set l {} } else { puts $f $l set l $li } } close $f return 1 } proc modifInform {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/protembl} Espionne "Repertoire : $directory" set r [glob -directory $directory *] foreach fichier $r { Espionne $fichier set tmp [split $fichier "/"] set nom [lindex $tmp 5] set f [open $fichier r] set full_text [read $f] set record [split $full_text "\n"] foreach ligne $record { if {[regexp {^GN\s*Name=(\w*);} $ligne string val]} { Espionne $val InformeSansDemander $nom "=ValiGN: $val" } } } } proc modifOrthoFile2 {orthofile newfile} { if { [file exists $orthofile]} { Espionne "$orthofile existe" set myacc [lindex [split [lindex [split $orthofile "/"] 5] "."] 0] set newList {} set ma_list [LesLignesDuFichier $orthofile] #set newList [linsert $newList 0 $myseq] #set newList [linsert $newList 0 >$myacc] lappend newList >$myacc set TFA [LaSequenceDuTFAs [RepertoireDuGenome]/prottfa/$myacc $myacc] lappend newList [QueLaSequenceDuTexteTFA $TFA] foreach Ligne $ma_list { if {[regexp {^[^#].*} $Ligne] && [regexp {^>} $Ligne]} { set defaultseq "no" set para [split $Ligne ";"] set species [lindex $para 1] if {[lindex $para 2] ne "NOTHING"} { set parse [lindex $para 5] if {$parse == ""} { #set tmp "no" } elseif {[regexp {.* GN=} $parse] || [regexp {.*\]\. $} $parse] } { set spID ">[lindex $parse 1] [lindex $parse 1] $species" set spSeq [string toupper [QueLaSequenceDesBanques [lindex $parse 1]]] #voir si pas un probleme la... if {$spSeq != ""} { lappend newList $spID lappend newList $spSeq } else { set defaultseq "yes" lappend newList ">[lindex $parse 0] [lindex $parse 0] $species" } } else { #if {[regexp ^ENS.* $parse]} set xref [split $parse ":"] set trSeq "" set spSeq "" set xpSeq "" set npSeq "" foreach ID $xref { if { [regexp {sp=(\w*)} $parse sw swp] && $swp != "" } { set spID ">$swp $swp $species" set spSeq [string toupper [QueLaSequenceDesBanques $swp]] break } elseif { [regexp {xp=(XP_\w*)} $ID sw xp] && $xp != "" } { set xpID ">$xp $xp $species" set xpSeq [string toupper [QueLaSequenceDesBanques $xp]] break } elseif { [regexp {np=(NP_\w*)} $ID sw np] && $np != "" } { set npID ">$np $np $species" set npSeq [string toupper [QueLaSequenceDesBanques $np]] break } elseif { [regexp {tr=(\w*)} $ID sw tr] && $tr != "" } { set id ">$tr $tr $species" set tmpseq [string toupper [QueLaSequenceDesBanques $tr]] set leng [string length $tmpseq] Espionne "leng: $leng ------ taille seq: [string length $trSeq]" if {[expr $leng > [string length $trSeq]]} { set trID ">$tr $tr $species" set trSeq [string toupper [QueLaSequenceDesBanques $tr]] } } } if {$spSeq != ""} { lappend newList $spID lappend newList $spSeq } elseif {$xpSeq != ""} { lappend newList $xpID lappend newList $xpSeq } elseif {$npSeq != ""} { lappend newList $npID lappend newList $npSeq } elseif {$trSeq != ""} { lappend newList $trID lappend newList $trSeq } else { if {[lindex $parse 3]!="pompejana"} { set defaultseq "yes" lappend newList ">[lindex $parse 3] [lindex $parse 3] $species" } } } } } elseif {[regexp {^[^#].*} $Ligne] && [regexp {^[^>]} $Ligne]} { if {$defaultseq eq "yes" } { lappend newList [string toupper $Ligne] } } } set redondant "" set finalList "" set seqwrite "NO" foreach ligne $newList { if {[regexp {^[>]} $ligne]} { #si pas egale alors je charge la liste if {$redondant ne $ligne} { lappend finalList $ligne set seqwrite "OK" } else { set seqwrite "NO" } set redondant $ligne } elseif {$seqwrite eq "OK"} { lappend finalList $ligne } } #SauveLesLignes $newList dans [RepertoireDuGenome]/totoXavier.tfa SauveLesLignes $finalList dans $newfile } else { Espionne "Fichier introuvable:\n $orthofile" } } proc modiftfa {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/protembl} Espionne "Repertoire : $directory" set r [glob -directory $directory *] foreach fichier $r { Espionne $fichier set LL [LaSequenceDesBanques $fichier] DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX SequenceBrute LaDETotal #EspionneL [list $ID $AC $DE $GN $OS $OC $OX $LaDETotal] #Espionne $SequenceBrute #Espionne >$ID #Espionne $AC #Espionne $OS #Espionne $DE set Entete ">$ID $AC $OS $DE" #sauve ou sauveligne #Espionne "Entete: $Entete" Sauve [SequenceFormatTFA $SequenceBrute $Entete "protbrut"] dans [RepertoireDuGenome]/prottfa/$ID } } proc monBlast {fichierEntree {fichierSortie ""} {banque ""} {ecrase ""} {Wait ""}} { set Wait [string equal -nocase $Wait "Wait"] if { ! [regexp "BlastTest" $fichierEntree]} { regsub "^magasin/" $fichierEntree "/home/joly/magasin/" fichierEntree if {$fichierSortie == ""} { set fichierSortie $fichierEntree regsub "\.tfa$" $fichierSortie "" fichierSortie append fichierSortie ".blast" } regsub "^magasin/" $fichierSortie "/home/joly/magasin/" fichierSortie if {![regexp "^/home/joly/magasin/" $fichierEntree]} {return "$fichierEntree sorry you're not allowed to use this file"} if {![regexp "^/home/joly/magasin/" $fichierSortie]} {return " $fichierSortie sorry you're not allowed to use this file"} if { [regexp {\.\.} $fichierSortie]} {return " $fichierSortie sorry you're not allowed to use this file"} } Espionne "$fichierEntree $fichierSortie $banque" if {$ecrase=="lire" && [file exist $fichierSortie]} {return [ContenuDuFichier $fichierSortie]} if {$ecrase!="ecrase" && [file exist $fichierSortie]} {return "ecrasement"} if {$banque == ""} {set banque /blast/swissprot} set commande "tcsh -c \"/biolo/ncbi/bin/blastall -i $fichierEntree -d $banque -p blastp -F T -o $fichierSortie.tmp -K 0 -v 5000 -b 5000 -e 10; mv $fichierSortie.tmp $fichierSortie;\"" if {$Wait} { Espionne "I'll launch $commande" eval exec $commande Espionne "Done" return $fichierSortie } set pid [eval exec $commande &] return "blast was launched with command\n$commande\npid $pid result will be available in $fichierSortie" } proc mrnabiscorrige {FichierSortie} { set n 0 foreach DD [ListeDesPABs] { set FichierProttfa "[RepertoireDuGenome]/prottfa/$DD" if {[file exists $FichierProttfa]} { set EnteteProttfa [EnteteDuFichierTFA $FichierProttfa] if {[regexp "from Homo sapiens" $EnteteProttfa]} { set AccessHumanProt [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] if {$AccessHumanProt!=""} { incr n if {[regexp $AccessHumanProt $EnteteProttfa]} {lappend Liste $DD} } } } } Espionne $n Espionne [llength $Liste] set Lt [lsort -unique $Liste] Espionne [llength $Lt] SauveLesLignes $Lt dans $FichierSortie exit foreach Nom $Lt { set FichiermRNAHomo "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {[file exists $FichiermRNAHomo]} {lappend LesDDAvecProtEtmRNAHuman $Nom} } Espionne [llength $LesDDAvecProtEtmRNAHuman] set L [lsort -unique $LesDDAvecProtEtmRNAHuman] Espionne [llength $L] } proc mrnatfahuman {} { foreach Nom [ListeDesPABs] { set FichiermRNAHomo "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {[file exists $FichiermRNAHomo]} {lappend LesDDAvecmRNAHuman $Nom} } Espionne [llength $LesDDAvecmRNAHuman] set L [lsort -unique $LesDDAvecmRNAHuman] Espionne [llength $L] } proc myIP {} { if { [ catch { set ip 127.0.0.1 set sid [ socket -async [ info hostname ] 22 ] set ip [ lindex [ fconfigure $sid -sockname ] 0 ] ::close $sid } err ] } { catch { ::close $sid } puts stderr "myIP error: '$err' on port 22 (sshd). using 127.0.0.1" } return $ip } proc myReadBlast {path {full 0}} { set infile [open $path r] set lines {} if { !$full } { while { ![regexp "Sequences producing significant alignments" [gets $infile]] } {} gets $infile } while { [gets $infile line] >= 0 && ($full || $line != "") } { lappend lines $line } close $infile return $lines } proc nUplet {args} { return $args } proc nblocks {} { set Lf [LesFichiersDeBalibase] foreach f $Lf { DecortiqueXmlAgent $f set Lbck [CoreBlocksDuXML] foreach {deb fin} $Lbck { set len [expr {$fin - $deb + 1}] if {$len < 5} { continue } lappend Llen $len } } puts "ntot [llength $Llen]" set Lx {} for {set i 0} {$i <= 100} {incr i 10} { lappend Lx $i } set Lx [linsert $Lx 1 7] set Lx [list 5 7 9 11 13 15 17 19 100] lappend Lx 1000 set ix 0 foreach x [lrange $Lx 0 end-1] { incr ix set xp [lindex $Lx $ix] foreach v $Llen { if {$v >= $x && $v < $xp} { incr H($x) } } } parray H LoadTkAndPackages package require Plotchart canvas .c -width 550 -height 550 -scrollregion [list 0 0 550 550] -yscrollcommand ".y set" -xscrollcommand ".x set" scrollbar .x -orient horiz -command ".c xview " scrollbar .y -orient vertical -command ".c yview " grid .c -row 0 -column 0 -sticky news grid .y -row 0 -column 1 -sticky ns grid .x -row 1 -column 0 -sticky ew grid columnconfigure . 0 -weight 1 grid rowconfigure . 0 -weight 1 set Lx {} ; set Ly {} foreach k [lsort -integer [array names H]] { lappend Lx $k lappend Ly $H($k) } puts "[llength $Lx] | $Lx" puts "[llength $Ly] | $Ly" set Lxaxis [list 0 100 10] set tmp [lsort -integer $Ly] set Lyaxis [list [lindex $tmp 0] [lindex $tmp end] 9] ::Plotchart::plotconfig vertbars leftaxis color white ::Plotchart::plotconfig vertbars bottomaxis color white ::Plotchart::plotconfig vertbars text textcolor white ::Plotchart::plotconfig vertbars text background cyan ::Plotchart::plotconfig vertbars bar outline white ::Plotchart::plotconfig vertbars title textcolor white ::Plotchart::plotconfig vertbars title background black ::Plotchart::plotconfig vertbars title font "Helvetica 32 bold" ::Plotchart::plotconfig vertbars legend background black set p [::Plotchart::createBarchart .c $Lx $Lyaxis 1] $p config -showvalues 1 -valuecolour white $p background axes black $p background plot black $p title "Distribution of blocks lengths" $p plot toto $Ly magenta $p legend toto "Ceci est la légende" .c itemconfig legend -fill white FenetreAuCentre . if {0} { set Lhis [CreeHistogramme $Llen 50] array set Tres $Lhis set Lv [list] foreach {k v} $Lhis { lappend Lv $v } set K [Graphe $Lv] bind all {destroy $k} $K configure -background black $K itemconfig Cadre -fill black #return $K itemconfig oval -fill white #parray Tres } #exit } proc nettoieLecturesPourTous {{pasDeChromato 0} {suffixe ""}} { # Ask parameters FaireLire "Please select screened fasta file containing the sequences" set fastaFilename [ButineArborescence "All" [RepertoireDuGenome]/edit_dir] FaireLire "Please select fasta file containing the quality" set qualityFilename [ButineArborescence "All" [RepertoireDuGenome]/edit_dir] set XminLength 0 while { $XminLength < 1 } { set XminLength [Entre "Minimal length for vector trimmed sequence (XminLength): 200"] set XminLength [string trim [lindex [split $XminLength ":"] 1]] if { ! [regexp {^[0-9]+$} $XminLength XminLength] } { set XminLength 0 } } set minLength 0 while { $minLength < 1 } { set minLength [Entre "Minimal sequence length (minLength): 100"] set minLength [string trim [lindex [split $minLength ":"] 1]] if { ! [regexp {^[0-9]+$} $minLength minLength] } { set minLength 0 } } if {!$pasDeChromato} { set phdDirectory [RepertoireDuGenome]/phd_dir if { ! [OuiOuNon "Are phd files in $phdDirectory ?"] } { FaireLire "Please select the directory containing phd files" set phdDirectory [ChoixDuRepertoire [RepertoireDuGenome]] } set scfDirectory [RepertoireDuGenome]/chromat_dir if { ! [OuiOuNon "Are scf files in $scfDirectory ?"] } { FaireLire "Please select the directory containing scf files" set scfDirectory [ChoixDuRepertoire [RepertoireDuGenome]] } } set logFile "" while {$logFile eq ""} { set logFile [Entre "Log file: [RepertoireDuGenome]/nettoieLecturesPourTous$suffixe.log"] set logFile [string trim [lindex [split $logFile ":"] 1]] } # Read files array set fasta [readFasta $fastaFilename] array set quality [readFasta $qualityFilename] # Open output files set cleanFasta [open "$fastaFilename.clean$suffixe" w] set discardFasta [open "$fastaFilename.discard$suffixe" w] set cleanQuality [open "$qualityFilename.clean$suffixe" w] set discardQuality [open "$qualityFilename.discard$suffixe" w] set log [open $logFile w] # Print a header in log file puts $log "nettoieLecturesPourTous parameters:" puts $log "-----------------------------------" puts $log "Sequence file: $fastaFilename" puts $log "Quality file: $qualityFilename" puts $log "Output sequence file: $fastaFilename.clean$suffixe" puts $log "Output quality file: $qualityFilename.clean$suffixe" puts $log "Minimal length for vector trimmed sequence: $XminLength" puts $log "Minimal sequence length: $minLength" if {!$pasDeChromato} { puts $log ".phd files directory: $phdDirectory" puts $log ".scf files directory: $scfDirectory" } puts $log {} # Set statistics variables set keepedSeqs [llength $fasta(index)] set discardedByLengthFilter 0 set discardedByPolyFilter 0 # Clean for each read foreach r $fasta(index) { set description [lindex $fasta($r) 0] # build the sequence from the file lines set sequence [join [lrange $fasta($r) 1 end] ""] # handle post filter results array set currentRead [list sequence $sequence keep 1] # used to range for initial sequence with ranges given by filters # to clean quality, phd and scf files set rangeStack {} # length filtering if {$currentRead(keep)} { array set fRes [lengthFilter $currentRead(sequence) $XminLength $minLength] set currentRead(sequence) $fRes(sequence) set currentRead(keep) $fRes(keep) lappend rangeStack $fRes(range) if {$fRes(keep)} { set status "KEEP" } else { set status "DISCARD" incr keepedSeqs -1 incr discardedByLengthFilter } puts "$r -> LENGTH FILTER: $status" puts $log "$r -> LENGTH FILTER: $status" foreach msg $fRes(messages) { puts "\t* $msg" puts $log "\t* $msg" } array unset fRes } # poly filtering if {$currentRead(keep)} { array set fRes [polyFilter $currentRead(sequence) 50 100] set currentRead(sequence) $fRes(sequence) set currentRead(keep) $fRes(keep) lappend rangeStack $fRes(range) if {$fRes(keep)} { set status "KEEP" } else { set status "DISCARD" incr keepedSeqs -1 incr discardedByPolyFilter } puts "$r -> POLY FILTER: $status" puts $log "$r -> POLY FILTER: $status" foreach msg $fRes(messages) { puts "\t* $msg" puts $log "\t* $msg" } array unset fRes } # compute range for initial sequence set iniRange {0 0} foreach rng $rangeStack { set iniRngLIdx [lindex $iniRange 0] set rngLIdx [lindex $rng 0] lset iniRange 0 [expr $iniRngLIdx + $rngLIdx] } set iniRngLIdx [lindex $iniRange 0] set lastRng [lindex $rangeStack end] set rngLIdx [lindex $lastRng 0] set rngRIdx [lindex $lastRng 1] lset iniRange 1 [expr $iniRngLIdx + $rngRIdx - $rngLIdx] ## puts "++ $rangeStack -> $iniRange" # Output results - useful computations set lIdx [lindex $iniRange 0] set rIdx [lindex $iniRange 1] set currentQual [join [lrange $quality($r) 1 end]] # Output results - output if {$currentRead(keep)} { # Write clean fasta puts "$r -> WRITE SEQUENCE FASTA" puts $cleanFasta [formatFasta $description $currentRead(sequence)] # Write clean quality fasta puts "$r -> WRITE QUALITY FASTA" puts $cleanQuality [formatQualFasta [lindex $quality($r) 0] [lrange $currentQual $lIdx $rIdx]] } else { # Write discard fasta puts "$r -> WRITE SEQUENCE FASTA" # puts $discardFasta [formatFasta $description $currentRead(sequence)] puts $discardFasta [formatFasta $description $sequence] # Write discard quality fasta puts "$r -> WRITE QUALITY FASTA" # puts $discardQuality [formatQualFasta [lindex $quality($r) 0] [lrange $currentQual $lIdx $rIdx]] puts $discardQuality [formatQualFasta [lindex $quality($r) 0] $currentQual] } if {!$pasDeChromato} { # Clean and write phd puts "$r -> CLEAN AND WRITE .PHD FILE" cleanPhd $currentRead(sequence) $iniRange "$phdDirectory/$r.phd.1" $currentRead(keep) # Clean and write scf puts "$r -> CLEAN AND WRITE .SCF FILE" cleanScf "$phdDirectory/${r}.phd.1" "$scfDirectory/$r" } array unset currentRead } # Print a footer in log file puts $log {} puts $log "nettoieLecturesPourTous results:" puts $log "--------------------------------" puts $log "Keeped sequences: $keepedSeqs" puts $log "Discarded by length filter: $discardedByLengthFilter" puts $log "Discarded by poly filter: $discardedByPolyFilter" puts $log "Total sequences: [llength $fasta(index)]" # Close output files close $cleanFasta close $discardFasta close $cleanQuality close $discardQuality close $log puts "FINISHED." } proc newGetHubs {lProteinId {minCombinedScore 700} {getGraphVar ""}} { package require struct::graph set g [::struct::graph] set lProteinId [lsort -unique $lProteinId] foreach proteinId $lProteinId { if {![$g node exists $proteinId]} { $g node insert $proteinId } foreach interact [getInteracts $proteinId 1 $minCombinedScore] { if {![$g node exists $interact]} { $g node insert $interact } if {[lsearch -exact [$g nodes -adj $proteinId] $interact] == -1} { $g arc insert $proteinId $interact $g arc insert $interact $proteinId } } } # Vire les noeuds qui ne sont pas en entrée Espionne "Removing nodes not in input dataset..." foreach n [$g nodes] { if {[lsearch -exact $lProteinId $n] == -1} { $g node delete $n } } # # Tag les noeuds qui n'ont pas assez de connexions # Espionne "Taging nodes whithout enough connections..." # foreach n [$g nodes] { # if {[llength [$g nodes -adj $n]] < $minConnections} { # $g node set $n "stopRecursion" 1 # } # } # Recherche les hubs set hubs {} foreach n [$g nodes] { set hub [getGraphHubString $g $n] if {[llength $hub] != 0} { lappend hubs [lsort $hub] } } if {$getGraphVar ne ""} { upvar $getGraphVar extG set extG $g } else { $g destroy } if {[llength $lProteinId] != [llength [join $hubs]]} { # On devrait obtenir autant de proteinId composant les hubs que de proteinId d'entrée error "IN [llength $lProteinId] != OUT [llength [join $hubs]]" } return [lsort -decreasing -command "lsortBySublistsLengths" $hubs] } proc newGetHubsWithLevel {lProteinId {depth 1} {minCombinedScore 700}} { set lProteinId [lsort -unique $lProteinId] set hubs {} foreach proteinId $lProteinId { set tmp {} foreach interact [getInteracts $proteinId $depth $minCombinedScore] { if {[lsearch -exact $lProteinId $interact] != -1} {lappend tmp $interact} } if {$depth == 1} { # Ici pas de besoin du traitement un plus lourd d'en dessous lappend hubs [lsort -unique [concat $proteinId $tmp]] } else { # Rajoute uniquement le hub contenant proteinId foreach hub [newGetHubs [concat $proteinId $tmp] $minCombinedScore] { if {[lsearch -exact $hub $proteinId] != -1} { lappend hubs $hub } } } } if {[llength $lProteinId] != [llength $hubs]} { # On devrait obtenir autant de hubs que de proteinId d'entrée error "IN [llength $lProteinId] != OUT [llength $hubs]" } return [lsort -unique -decreasing -command "lsortBySublistsLengths" $hubs] } proc newLesBestProteinesHumanAvecLoc2EtGO {FichierClusters {ListeNoms ""}} { if {![file exists $FichierClusters] && $ListeNoms==""} { set Liste [ListeDesPABs] } if {[file exists $FichierClusters] && $ListeNoms==""} { set Liste [ListeDesJR $FichierClusters] } if {$ListeNoms!=""} {set Liste [split $ListeNoms " "]} set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" if {![file exists $FichierBest]} {return} set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" if {![file exists $FichierGO]} {return} set FichierBestLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" if {![file exists $FichierBestLoc] } {return} set Entete "Name\tTwins\tClone\tCytoBand\tSource Loc.\tAcc. Protein\tId. Prot\tDefinition Prot.\tOrganism P.\tLength Prot\tAcc. mRNA\tId. mRNA\tDefinition mRNA\tOrganism mRNA\tLength mRNA\tGO" lappend LApercu $Entete foreach Nom $Liste { #pb dans les infos de exonhit et de SSH2 #set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] set CodeExonhit [ExtraitInfo $Nom "CodeClone"] if {[file exists $FichierClusters]} { set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] } set LesDefinitionsGO {} set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO] if {$LesGO!={}} { foreach GO $LesGO { set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] lappend LesDefinitionsGO $LaDefinitionGO } } set Loc [InterrogeLocalisation $FichierBestLoc Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProt Identity] set LesOrgasP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt LesOrganismes] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Definition] set TailleP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Taille] set LesOrgasR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA LesOrganismes] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Definition] set TailleR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Taille] #if {$AccessmRNA!="" || $AccessProt!=""} { #lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" #} if {[info exists LesJumeaux]} { lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" } else { lappend LApercu "$Nom\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" } } return $LApercu } proc newLesBestProteinesHumanAvecLocEtGO {FichierClusters {ListeNoms ""}} { if {![file exists $FichierClusters] && $ListeNoms==""} { set Liste [ListeDesPABs] } if {[file exists $FichierClusters] && $ListeNoms==""} { set Liste [ListeDesJR $FichierClusters] } if {$ListeNoms!=""} {set Liste [split $ListeNoms " "]} set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" if {![file exists $FichierBest]} {return} set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" if {![file exists $FichierGO]} {return} #set FichierBestLocNuctfa "[RepertoireDuGenome]/Localisation/BestLocalisation_Human_Box" #set FichierBestLocNuctfa "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" set FichierBestLocProttfa "[RepertoireDuGenome]/Localisation/BestProttfaLocalisation_Human" set FichierBestLocmRNA "[RepertoireDuGenome]/Localisation/BestmRNAHsapLocalisation_Human" if {![file exists $FichierBestLocNuctfa] || ![file exists $FichierBestLocProttfa] || ![file exists $FichierBestLocmRNA]} {return} set Entete "Name\tTwins\tClone\tCytoBand\tSource Loc.\tAcc. Protein\tId. Prot\tDefinition Prot.\tOrganism P.\tLength Prot\tAcc. mRNA\tId. mRNA\tDefinition mRNA\tOrganism mRNA\tLength mRNA\tGO" lappend LApercu $Entete foreach Nom $Liste { #pb dans les infos de exonhit et de SSH2 set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] if {[file exists $FichierClusters]} { set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] } set LesDefinitionsGO {} set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO] if {$LesGO!={}} { foreach GO $LesGO { set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] lappend LesDefinitionsGO $LaDefinitionGO } } set Loc [InterrogeLocalisation $FichierBestLocNuctfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocProttfa Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } else { set Loc [InterrogeLocalisation $FichierBestLocmRNA Nom $Nom] if {$Loc!=""} { set Loc [lindex $Loc 0] set Band [lindex $Loc 19] set Source [lindex $Loc 21] } } } set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessmRNA Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessProt Identity] set LesOrgasP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt LesOrganismes] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Definition] set TailleP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessProt Taille] set LesOrgasR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA LesOrganismes] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Definition] set TailleR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessmRNA Taille] #if {$AccessmRNA!="" || $AccessProt!=""} { #lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" #} lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Band\t$Source\t$AccessProt\t$IdProt\t$DefP\t$LesOrgasP\t$TailleP\t$AccessmRNA\t$IdmRNA\t$DefR\t$LesOrgasR\t$TailleR\t$LesDefinitionsGO" } return $LApercu } proc newNewGetHubsWithLevel {lProteinId {level 1} {minCombinedScore 700}} { set lProteinId [lsort -unique $lProteinId] set procName [lindex [info level 0] 0] set todo [llength $lProteinId] set hubs {} set count 0 foreach proteinId $lProteinId { incr count Espionne "$procName: $count/$todo" set g [getStringGraphWithLevel $proteinId $minCombinedScore $level] # Renvoie le hub à partir de proteinId lappend hubs [lsort -unique [getGraphHubString $g $proteinId]] $g destroy } if {[llength $lProteinId] != [llength $hubs]} { # On devrait obtenir autant de hubs que de proteinId d'entrée error "IN [llength $lProteinId] != OUT [llength $hubs]" } return [lsort -unique -decreasing -command "lsortBySublistsLengths" $hubs] } proc newr {} { LitLeTFA 250_nrna.tfa Ln Sq set Li [list 0 1 5 7 8 41 50 85 125 130 132 133 150] foreach i $Li { set n [lindex $Ln $i] lappend Nn $n lappend Ns [set Sq($n)] } EcritLeTfa new.tfa $Nn $Ns puts "[string length [set Sq($n)]] [expr {[string length [set Sq($n)]] / 3}]" exit } proc nicotax {} { global T Lfils #set Ll [LesLignesDuFichier ins.tab] set Ll [LesLignesDuFichier nico.tab] #set T(0,nom) "ZeRoot" #set T(-1,nom) "ZeRoot" foreach l $Ll { set Lv [split $l "\t"] set id [lindex $Lv 0] set par [lindex $Lv end-1] set nom [lindex $Lv 2] set T($id,nom) $nom set T($id,par) $par lappend T($par,child) $id lappend Lpar $par lappend Lall $id } set Lpar [lsort -unique -integer $Lpar] set Lall [lsort -unique -integer $Lall] set Lfbr [lsort -integer -unique [lor $Lall $Lpar from1]] set Llvs [list] foreach f $Lall { if {! [info exists T($f,child)]} { lappend Llvs $f set T($f,child) {} } } puts "Llgn [llength $Ll]" puts "Lall [llength $Lall]" puts "Lpar [llength $Lpar]" puts "Lfbr [llength $Lfbr]" puts "Llvs [llength $Llvs]" puts "orfb [llength [lor $Lfbr $Llvs]]" exit foreach f $T(131567,child) { if {$f ni {2157 2 2759}} { set T($f,par) 0 } } set icmp 0 ; set itot 0 foreach f $Llvs { if {131567 in [set Lanc [AncetresDe $f]]} { lappend Lco {*}$Lanc } incr icmp incr itot if {$icmp == 10000} { set Lco [lsort -unique $Lco] set icmp 0 puts "done $itot" } } set Lco [lsort -unique $Lco] foreach f $Lco { set out($f) 1 } set o [open nico.tab w] foreach l $Ll { set Lv [split $l "\t"] set id [lindex $Lv 0] if {[info exists out($id)]} { puts $o $l } } close $o exit } proc nist_pca {X} { # set X {2 10 3 7 4 3 4 1 8 6 3 5 8 6 1 8 5 7 7 2 9 5 3 3 9 5 8 7 4 5 8 2 2} set nlin [lindex $X 1] set ncol [lindex $X 2] puts "Matrix of observation data X\[$nlin,$ncol\]" puts [show $X] puts {Compute column norms} mnorms_br X Xmeans Xsigmas puts "Means=[show $Xmeans]" puts "Sigmas=[show $Xsigmas %.6f]" puts "Normalize observation data creating Z\[$nlin,$ncol\]" puts [show [set Z [mnormalize $X $Xmeans $Xsigmas]] %10.6f]\n puts {Naive computation method that is sensitive to round-off error} puts {ZZ is (Ztranspose)(Z) } puts "ZZ=\n[show [set ZZ [mmult [transpose $Z] $Z]] %10.6f]" puts {the correlation matrix, R = (Zt)(Z)/(n-1)} puts "R=\n[show [set R [mscale $ZZ [expr 1/9.0]]] %8.4f]" puts {Continuing the naive example use R for the eigensolution} set V $R mevsvd_br V evals puts "eigenvalues=[show $evals %8.4f]" puts "eigenvectors:\n[show $V %8.4f]\n" puts "Good computation method- perform SVD of Z" #lm : on retourne eigenvalue et eigenvectors set Eval $evals set Evec $V set U $Z msvd_br U S V puts "Singular values, S=[show $S]" puts "square S and divide by (number of observations)-1 to get the eigenvalues" set SS [mprod $S $S] set evals [mscale $SS [expr 1.0/9.0]] puts "eigenvalues=[show $evals %8.4f]" puts "eigenvectors:\n[show $V %8.4f]" puts "(the 3rd vector/column has inverted signs, thats ok the math still works)" puts "\nverify V x transpose = I" puts "As computed\n[show [mmult $V [transpose $V]] %20g]\n" puts "Rounded off\n[show [mround [mmult $V [transpose $V]]]]" #puts "Diagonal matrix of eigenvalues, L" #set L [mdiag $evals] # puts "\nsquare root of eigenvalues as a diagonal matrix" proc sqrt x { return [expr sqrt($x)] } set evals_sr [mat_unary_op $evals sqrt] set Lhalf [mdiag $evals_sr] puts [show $Lhalf %8.4f] puts "Factor Structure Matrix S" set S [mmult $V $Lhalf] puts [show $S %8.4f]\n set S2 [mrange $S 0 1] puts "Use first two eigenvalues\n[show $S2 %8.4f]" # Nash discusses better ways to compute this than multiplying SSt # the NIST method is sensitive to round-off error set S2S2 [mmult $S2 [transpose $S2]] puts "SSt for first two components, communality is the diagonal" puts [show $S2S2 %8.4f]\n # define reciprocal square root function proc recipsqrt x { return [expr 1.0/sqrt($x)] } # use it for Lrhalf calculation set Lrhalf [mdiag [mat_unary_op $evals recipsqrt]] set B [mmult $V $Lrhalf] puts "Factor score coefficients B Matrix:\n[show $B %12.4f]" puts "NIST shows B with a mistake, -.18 for -1.2 (-1.18 with a typo)" puts "\nWork with first normalized observation row" # set z1 {2 3 0 0.065621795889 0.316227766017 -0.7481995314} set z1 "2 $ncol 0" for {set li 0} {$li < $ncol} {incr li} { lappend z1 [lindex $Z [expr $li + 3]] } puts [show $z1 %.4f] puts "compute the \"factor scores\" from multiplying by B" set t [mmult [transpose $z1] $B] puts [show $t %.4f] puts "NIST implies you might chart these" #set T2 [dotprod $t $t] #puts "Hotelling T2=[format %.4f $T2]" puts "Compute the scores using V, these are more familiar" set t [mmult [transpose $z1] $V] puts [show $t %.4f] puts "Calculate T2 from the scores, sum ti*ti/evi" set T2 [msum [transpose [mdiv [mprod $t $t] [transpose $evals]]]] puts "Hotelling T2=[format %.4f $T2]" puts "Fit z1 using first two principal components" set p [mrange $V 0 1] puts p=\n[show $p %10.4f] set t [mmult [transpose $z1] $p] set zhat [mmult $t [transpose $p]] puts " z1=[show $z1 %10.6f]" puts "zhat=[show $zhat %10.6f]" set diffs [msub [transpose $z1] $zhat] puts "diff=[show $diffs %10.6f]" puts "Q statistic - distance from the model measurement for the first observation" set Q [dotprod $diffs $diffs] puts Q=[format %.4f $Q] puts "Some experts would compute a corrected Q that is larger since the observation was used in building the model. The Q calculation just used properly applies to the analysis of new observations." set corr [expr 10.0/(10.0 - 2 -1)] ;# N/(N - Ncomp - 1) puts "Corrected Q=[format %.4f [expr $Q * $corr]] (factor=[format %.4f $corr])" return [list $Eval $Evec] } proc nogonz {} { set Ll [LesLignesDuFichier nogonz.dat] set f [list] foreach a $Ll { lappend f [string trim $a] } puts [join $f ";"] exit } proc nolight_color3f {r g b} { global pgl set c $pgl(coeff_ambient) glColor3f [expr {$r/$c}] [expr {$g/$c}] [expr {$b/$c}] return } proc nolight_color3fv {col} { global pgl lassign $col r g b a set c $pgl(coeff_ambient) glColor3f [expr {$r/$c}] [expr {$g/$c}] [expr {$b/$c}] return } proc nombreCaracteristiqueAnalyse {{sequence ""} {information ""}} { #if {$directory==""} {set directory [RepertoireDuGenome]/protembl} if {$sequence==""} {Espionne "vous devez donner la sequence" exit} if {$information==""} {Espionne "devez donner l'information souhaiter" exit} if {$information=="orthologie"} {return [expr [comptNbOrtho "[RepertoireDuGenome]/NewTfasDesCopains/$sequence"] -1] } if {$information=="pfam"} {return [NBPfam "[RepertoireDuGenome]/macsimXml/$sequence"]} if {$information=="pdb"} {return [NbPdb [RepertoireDuGenome]/pdb/$sequence]} if {$information=="interaction"} {return [NbInt [RepertoireDuGenome]/StringRep/String/$sequence]} } proc nombreRA {} { set A 0 set B 0 set C 0 set T 0 foreach I [RetChip2 ListOf Index] { set Des [RetChip2 $I "description_customer"] set Ac1 [RetChip2 $I "refseq_PIQOR"] set Ac2 [RetChip2 $I "DNA_acc"] set Ac3 [RetChip2 $I "prot_acc_PIQOR"] set Ac4 [RetChip2 $I "prot_acc"] if { ![regexp {^RA[0-9]+} $Des] } { continue } incr T puts "RA=$Des=>$T" if { $Ac1=="" && $Ac2=="" && $Ac3=="" && $Ac4=="" } { incr A puts "Aucun access=$A" } if { $Ac1!="" || $Ac2!="" } { incr B puts "A access dna=$B" } if { $Ac1=="" && $Ac2=="" } { if {$Ac3!="" || $Ac4!="" } { incr C puts "N'a pas access dna, a access prot=$C" } } } Espionne "$T =nb de RA" Espionne "$A =nb de RA ss aucun acces" Espionne "$B =nb de RA ac un access dna" Espionne "$C =nb de RA ss access dna ms ac un access prot" } proc normalize_quat {q} { lassign $q a b c d set mag [expr {$a*$a + $b*$b + $c*$c + $d*$d}] foreach v $q { lappend r [expr {$v/$mag}] } return $r } proc number_processors {} { global tcl_platform package require fileutil set max_jobs 0 if { [string equal -nocase "windows" "$tcl_platform(platform)"] } { set max_jobs $::env(NUMBER_OF_PROCESSORS) } elseif { [file readable /proc/cpuinfo] } { set np [llength [::fileutil::grep processor /proc/cpuinfo]] set max_jobs $np } else { # Unknown OS } return $max_jobs } proc oldApercuDesGenesDuProjet {FichierClusters} { set Liste [ListeDesJR $FichierClusters] foreach Nom $Liste { set Definition [InterrogeProtAndmRNA $Nom Rang 1 Definition] if {$Definition==""} {continue} lappend LApercu "$Nom\t$Definition\n" } Espionne "nb pabs avec une def: [llength $LApercu]" return $LApercu } proc oldCompareLocalisations {FichierLesDDLocsSansFct FichierDesmiRNAs} { foreach Nom [CreeListePourFichierAUneColonne $FichierLesDDLocsSansFct] { if {$Nom==""} {continue} set Vu($Nom) 1 } set FichierFinal "[RepertoireDuGenome]/ANALYSE/finaaal_6jul05_avecMAetSel_mitoch" foreach Ligne [LesLignesDuFichier $FichierFinal] { if {$Ligne==""} {continue} set LesInfos [split $Ligne "\t"] set JR [lindex $LesInfos 1] if {![info exists Vu($JR)]} {continue} set Chro [lindex $LesInfos 29] set Deb [lindex $LesInfos 30] set Fin [lindex $LesInfos 31] #set Sens [lindex $LesInfos 32] lappend LesLocsNom "$Chro $Deb $Fin $JR" } Espionne "lesDD: [llength $LesLocsNom]" set L [CreeListePourFichierAUneColonne $FichierDesmiRNAs] set FichierLoc "[RepertoireDuGenome]/Localisation/miRNAtfaLocalisation_Human" foreach M $L { set Locs [InterrogeLocalisation $FichierLoc Nom $M] if {$Locs==""} {continue} #if {[llength $Loc]>=2} {continue} foreach Loc $Locs { #set L [join $L ""] #EspionneL $Loc set Chro [lindex $Loc 9] set DSurChro [lindex $Loc 10] set FSurChro [lindex $Loc 11] lappend LesLocsNom "$Chro $DSurChro $FSurChro $M" } } Espionne "lesDD et les M: [llength $LesLocsNom]" set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom] set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees] lappend LesLocsNomTriees "bidon bidon bidon bidon bidon" ######### set FichierBob "[RepertoireDuGenome]/bob" SauveLesLignes $LesLocsNomTriees dans $FichierBob exit ######### set OldChromo "zzzz" set OldInf 1111111111111111 set OldSup 0 set LaSortie {} foreach Loc $LesLocsNomTriees { if {$Loc!="bidon bidon bidon bidon bidon"} { scan $Loc "%s %d %d %s" chromo inf sup code if {($chromo == $OldChromo) && ($inf <= $OldSup)} { if {![info exists LesMemes]} { set LesMemes $Oldcode } lappend LesMemes $code } else { if {[info exists LesMemes]} { lappend LaSortie [join $LesMemes " "] unset LesMemes } } set OldChromo $chromo set OldInf $inf set OldSup $sup set Oldcode $code } } set FichierDesClonesEnOverlap "[RepertoireDuGenome]/LocOverlapDDmiRNAs" if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace $FichierDesClonesEnOverlap"]} { if {$LaSortie=={}} { Sauve "No overlaps were found" dans $FichierDesClonesEnOverlap } else { #set Sortie [TrieLaSortie $LaSortie] Espionne "fin" SauveLesLignes $LaSortie dans $FichierDesClonesEnOverlap } } return $FichierDesClonesEnOverlap } proc oldCreeFichierFinal {FichierTot FichierUniq FichierOverlap FichierAffy FichierRefSeq FichierSortie} { #FichierTot "[RepertoireDuGenome]/OVERLAP931NEW/TotalDesData" #FichierUniq "[RepertoireDuGenome]/OVERLAP931NEW/DataUniques" #FichierOverlap "/OVERLAP931NEW/bestoverlaps" #FichierAffy "/genomics/link/AffyTarget/OVERLAP/TotalDesData" #oldFichierRefSeq "OverlapRefSeq/new/DDRefSeqDef" #FichierRefSeq "overlapHumanmRNARefSeq/DDNMDef" #Presence ou absence d'un affy en overlap. foreach Ligne [LesLignesDuFichier $FichierOverlap] { if {$Ligne==""} {continue} set LesCodes [split $Ligne "\t"] set DD [lindex $LesCodes 0] set CodeAffy [lindex $Ligne 1] set Affy($DD) $CodeAffy } #Profil Virtual Northern et Northern set FichierProfilDDValidation "[RepertoireDuGenome]/totalite/ValidationProfil.txt" if {![file exists $FichierProfilDDValidation]} {return} foreach Ligne [LesLignesDuFichier $FichierProfilDDValidation] { if {$Ligne=="" || [regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set Owner [lindex $Ligne 0] set CC [lindex $Ligne 2] if {$Owner=="F"} {set CC [string toupper $CC]} if {$Owner=="I"} {regsub -all "\'" $CC "_" CC} set ProfVN [lindex $Ligne 3] set ProfNorthern [lindex $Ligne 5] set PVN($Owner,$CC) $ProfVN set PN($Owner,$CC) $ProfNorthern } #profil Macroarray set FichierMacroarray "[RepertoireDuGenome]/MembranesRegine/compar_profils_mb_gscope" foreach Ligne [LesLignesDuFichier $FichierMacroarray] { if {$Ligne==""} {continue} set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 1] set ProfMb [lindex $LesChamps 2] set PMb($DD) $ProfMb } set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology_GPO" set n 0 foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/931"] { Espionne $Ligne set LesJumeaux [split $Ligne " "] set NbJumeaux [llength $LesJumeaux] #Espionne "nb jum : $NbJumeaux" set ProfilVN ""; set ProfilNorthern ""; set ProfilMb ""; set LesGO ""; set LesPathwaysKegg ""; set LesDomainesPFAMA "" foreach Jumeau $LesJumeaux { set CodeClone [InterrogeFichierTotalDataDD $FichierTot $Jumeau Code] set User [InterrogeFichierTotalDataDD $FichierTot $Jumeau User] #virtual northern if {[info exists PVN($User,$CodeClone)] && $ProfilVN==""} {set ProfilVN $PVN($User,$CodeClone)} set ProfilVN [string trim $ProfilVN] if {[info exists PVN($User,$CodeClone)] && $ProfilVN!="" && [string trim $PVN($User,$CodeClone)]!="" && $ProfilVN!=$PVN($User,$CodeClone)} { if {$ProfilVN==0 && $PVN($User,$CodeClone)!=0} { set ProfilVN $PVN($User,$CodeClone) } } #northern if {[info exists PN($User,$CodeClone)] && $ProfilNorthern==""} {set ProfilNorthern $PN($User,$CodeClone)} set ProfilNorthern [string trim $ProfilNorthern] #membrane nylon Regine if {[info exists PMb($Jumeau)] && $ProfilMb==""} {set ProfilMb $PMb($Jumeau)} set ProfilMb [string trim $ProfilMb] #Les GOs if {$LesGO==""} {set LesGO [InterrogeGeneOntology $FichierGO $Jumeau LesGO]} #Les Pathways KEGG if {$LesPathwaysKegg==""} {set LesPathwaysKegg [InterrogeMesKEGG $Jumeau LesPathway]} #Les Domaines PFAMA (Id>0.8) if {$LesDomainesPFAMA==""} {set LesDomainesPFAMA [InterrogeDomaines $Jumeau LesDomaines]} } set JR [lindex $LesJumeaux 0] #Espionne $JR set LesJumeauxDuJR [lreplace $LesJumeaux 0 0] ### INFOS JR ############# incr n set NumGeneDD [InterrogeFichierTotalDataDD $FichierTot $JR N] set CodeClone [InterrogeFichierTotalDataDD $FichierTot $JR Code] set User [InterrogeFichierTotalDataDD $FichierTot $JR User] set Band [InterrogeFichierTotalDataDD $FichierTot $JR Bande] #les profils set ProfilCalc [InterrogeFichierTotalDataDD $FichierTot $JR Profil] set ProfilConsensus [InterrogeFichierTotalDataDD $FichierTot $JR ProfCons] #Sequence set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$JR" if {![file exists $FichierNuctfa]} {Espionne "$FichierNuctfa doesn t exist";set Seq ""; set LSeq ""} else {set Seq [QueLaSequenceDuFichierTFA $FichierNuctfa];set LSeq [string length $Seq]} #Masking if {[InterrogeBilanMasking $JR LesEtats] != ""} { set PercentMask [InterrogeBilanMasking $JR Etat MRM PMasked ] set LesRepeatsMasques [InterrogeBilanMasking $JR Etat MRM LesRepeats] } #localisation bande cyto (from proc CreeListeTotaleDD) set BandeCyto "" set FichierLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" if {![file exists $FichierLoc]} {Espionne "$FichierLoc doesn t exist"} set LesLocs [InterrogeLocalisation $FichierLoc Nom $JR] if {$LesLocs!=""} { foreach Loc $LesLocs { if {[regexp "Best" [lindex $Loc 20]]} { set BandeCyto [lindex $Loc 19] break } set Vu($Bande,$Ow) 1 } } #Espionne $BandeCyto #if {$JR=="DD0004"} {FaireLire "$FichierLoc - [llength $Loc] - $BandeCyto"} #RefSeq set AccessRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR NM] set DefRefSeq [InterrogeFichierBestNMavecDef $FichierRefSeq $JR Def] if {$AccessRefSeq==""} {set AccessRefSeq "";set DefRefSeq ""} #Best Human Prot set AccBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccProt] set DefBestProtHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefProt] set AccBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD AccRNA] set DefBestRNAHuman [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DefRNA] #Gel DD pour le JR set DifE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifE] set ProfE [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfE] set DifS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifS] set ProfS [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfS] set DifU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifU] set ProfU [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD ProfU] set DifMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD DifMoy] set ProfMoy [InterrogeFichierDDUniques3T $FichierUniq $NumGeneDD Pmoy] #Les GO if {$AccBestProtHuman!=""} { if {$LesGO==""} {set Ontology ""} else { set Ontology "" foreach GO $LesGO { set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] append Ontology "$GO $LaDefinitionGO /" } } #LesPathways Kegg if {$LesPathwaysKegg==""} {set Pathways ""} else { foreach Pathway $LesPathwaysKegg { set Pathways "" set LaDefinitionKEGG [InterrogeMesKEGG Pathway $Pathway Definition] append Pathways "$Pathway $LaDefinitionKEGG /" } } #Les Domaines if {$LesDomainesPFAMA==""} {set DomainesPFAMA ""} else { set DomainesPFAMA "" foreach LeDomaine $LesDomainesPFAMA { set i 0; set Liste "" foreach Do $LeDomaine { incr i if {$i<4} {lappend Liste $Do} } append DomainesPFAMA "$Liste /" } #set DomainesPFAMA [join $LesDomaines " /"] } } else {set Ontology ""; set Pathways ""; set DomainesPFAMA ""} #INFOS AFFY ### if {[info exists Affy($JR)]} { set MA 1 set CodeAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Code] set Def [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) Def] set FoldMoy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) FoldMoy] set ProfilMoyAffy [InterrogeFichierDataAffyPourTous3T $FichierAffy $Affy($JR) ProfMoy] } else {set MA 0;set CodeAffy ""; set Def ""; set FoldMoy ""; set ProfilMoyAffy ""} AppendAuFichier $FichierSortie "$n\t$JR\t$CodeClone\t$Band\t$User\t$LesJumeauxDuJR\t$LSeq\t$Seq\t$PercentMask\t$LesRepeatsMasques\t$DifE\t$ProfE\t$DifS\t$ProfS\t$DifU\t$ProfU\t$DifMoy\t$ProfMoy\t$ProfilCalc\t$ProfilConsensus\t$ProfilVN\t$ProfilNorthern\t$ProfilMb\t$ProfilMoyAffy\t$BandeCyto\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestRNAHuman\t$DefBestRNAHuman\t$AccessRefSeq\t$DefRefSeq\t$Ontology\t$Pathways\t$DomainesPFAMA\t$MA\t$CodeAffy\t$Def\t$FoldMoy" } } proc oldCreeFichierJumeauxLocs {} { # basee sur fichier BestLocalisation_Human SEULEMENT!!!voir proc au-dessous # Cree le fichier jumeaux_Overlap dans le dir fiches. # Jumeaux = Clones localises sur le meme chromosome avec des locs chevauchantes. # Attention : Considere la best localisation. # Premiere best si cas polyloc. # Trie les clones d'un meme cluster par ordre decroissant de leur longueur (nuctfa) set ListeDesPABsApresJumSeq [CreeLaNouvelleListeDesPABsApresJumeauxSeq] if { ! [file exists "[RepertoireDuGenome]/fiches"]} { File mkdir "[RepertoireDuGenome]/fiches" } set FichierDesClonesEnOverlap "[RepertoireDuGenome]/fiches/jumeaux_Overlap" set FichierBestLoc "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" if {![file exists $FichierBestLoc]} {return "I need the file /Localisation/BestLocalisation_Human"} set LesLocsNom {} foreach Nom $ListeDesPABsApresJumSeq { #FaireLire $Nom set Loc [InterrogeLocalisation $FichierBestLoc Nom $Nom] if {$Loc==""} {continue} if {[llength $Loc]>=2} { set Loc [lindex $Loc 0] } else { set Loc [join $Loc ""] } set Chro [lindex $Loc 9] set DSurChro [lindex $Loc 10] set FSurChro [lindex $Loc 11] if {$Chro==""} {Espionne $Nom} lappend LesLocsNom "$Chro $DSurChro $FSurChro $Nom" } #commande vue avec Raymond #permet de trier en fonction de la borne inferieure "a" set LesLocsNomPreTriees [lsort -command CompareChroDebut $LesLocsNom] set LesLocsNomTriees [lsort -command CompareChroFin $LesLocsNomPreTriees] lappend LesLocsNomTriees "bidon bidon bidon bidon bidon" set OldChromo "zzzz" set OldInf 1111111111111111 set OldSup 0 set LaSortie {} foreach Loc $LesLocsNomTriees { if {$Loc!="bidon bidon bidon bidon bidon"} { scan $Loc "%s %d %d %s" chromo inf sup code if {($chromo == $OldChromo) && ($inf <= $OldSup)} { if {![info exists LesMemes]} { set LesMemes $Oldcode } lappend LesMemes $code } else { if {[info exists LesMemes]} { lappend LaSortie [join $LesMemes " "] unset LesMemes } } set OldChromo $chromo set OldInf $inf set OldSup $sup set Oldcode $code } } if {![file exists $FichierDesClonesEnOverlap] || [file exists $FichierDesClonesEnOverlap] && [OuiOuNon "Do you want to replace the file jumeaux_Overlap"]} { if {$LaSortie=={}} { Sauve "No overlap were found" dans $FichierDesClonesEnOverlap } else { set Sortie [TrieLaSortie $LaSortie] Espionne "fin" Sauve $Sortie dans $FichierDesClonesEnOverlap } } return $FichierDesClonesEnOverlap } proc oldCreeFichierTous {FichierSortie1} { #Sortie: /ANALYSE/TousComplete #---Courts, conta et N foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsCourts"] { set Court($Ligne) 1 } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsContamines.28"] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach Nom $LesJumeaux { set Conta($Nom) 1 } } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/LesPABsAvecN.26avr05"] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach Nom $LesJumeaux { set N($Nom) 1 } } #--- paper1 set FichierCorres "[RepertoireDuGenome]/lacorrespondance" foreach Ligne [LesLignesDuFichier $FichierCorres] { if {$Ligne==""} {continue} set Ligne [split $Ligne "\t"] set New [lindex $Ligne 0]; set Old [lindex $Ligne 1] set O($Old) $New } foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/paper1"] { if {[info exists O($Ligne)]} {set DD $O($Ligne); set Paper($DD) 1} else {Espionne "no correspondance pour $Ligne"} } #--- #la bande pour un couple (user, codeclone) foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] { ## (rq: pas de user R dans ce fichier) if {[regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set U [lindex $LesChamps 0] ### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ###### set CodeClone [string trim [lindex $LesChamps 1]] if {$U=="F"} { set CodeClone [string toupper $CodeClone] } set B [lindex $LesChamps 2] set Band($U,$CodeClone) $B } #Espionne "[array names Band]" #Profil foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] { set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 0] set Prof [lindex $LesChamps 1] if {$Prof=="+"} {set P($DD) "T"} if {$Prof=="-"} {set P($DD) "N"} if {$Prof=="0"} {set P($DD) "C"} } #Profil_consensus foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/ResolutionTotaleDesConflits_pourGscope.txt"] { if {[regexp "gscopecode" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 1] set ProfCons [lindex $LesChamps 5] set Pc($DD) $ProfCons } #Intensites ############################################# # Attention! # # les numeros de bandes ne sont pas uniques # # Exemple: J PM et CW ont fait une bande 48 # ############################################# foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Bands_intensiteDD.txt"] { if {[regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set User [lindex $LesChamps 0] set B [lindex $LesChamps 1] regsub -all "\'" $B "" B set I_TE($User,$B) [lindex $LesChamps 3] set I_NE($User,$B) [lindex $LesChamps 4] set I_TS($User,$B) [lindex $LesChamps 5] set I_NS($User,$B) [lindex $LesChamps 6] set I_TU($User,$B) [lindex $LesChamps 7] set I_NU($User,$B) [lindex $LesChamps 8] } set FichierLocBox "[RepertoireDuGenome]/Localisation/oldBoxLocalisation_Human_Best" set FichierLocBox2 "[RepertoireDuGenome]/Localisation/BoxLoc" if {![file exists $FichierLocBox]} {Espionne "$FichierLocBox does not exist"} if {![file exists $FichierLocBox2]} {Espionne "$FichierLocBox2 does not exist"} set FichierLocBest "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" if {![file exists $FichierLocBest]} {Espionne "$FichierLocBest does not exist"} set FichierSelectEST "[RepertoireDuGenome]/fiches/SelectedEST" foreach DD [ListeDesPABs] { Espionne $DD #--- set JR [JumeauRepresentatif $DD] # Listes speciales if {[info exists Court($DD)]} {set InfoCourt 1} else {set InfoCourt 0} if {[info exists Conta($DD)]} {set InfoConta 1} else {set InfoConta 0} if {[info exists N($DD)]} {set InfoN 1} else {set InfoN 0} # Localisation set LesLocBest [InterrogeLocalisation $FichierLocBest Nom $DD] if {$LesLocBest==""} { set LesLocBox [InterrogeLocalisation $FichierLocBox Nom $DD] if {$LesLocBox==""} { set LesLocBox2 [InterrogeLocalisation $FichierLocBox2 Nom $JR] if {$LesLocBox2==""} { set Chro ""; set Deb ""; set Fin ""; set Sens ""; set BandeCyto "" Espionne "$JR est sans loc!" } else { foreach Loc $LesLocBox2 { if {[regexp "Best" [lindex $Loc 20]]} { set BandeCyto [lindex $Loc 19] set Chro [lindex $Loc 9] set Deb [lindex $Loc 10] set Fin [lindex $Loc 11] set Sens [lindex $Loc 12] break } } } } else { foreach Loc $LesLocBox { if {[regexp "Best" [lindex $Loc 20]]} { set BandeCyto [lindex $Loc 19] set Chro [lindex $Loc 9] set Deb [lindex $Loc 10] set Fin [lindex $Loc 11] set Sens [lindex $Loc 12] break } } } } else { foreach Loc $LesLocBest { if {[regexp "Best" [lindex $Loc 20]]} { set BandeCyto [lindex $Loc 19] set Chro [lindex $Loc 9] set Deb [lindex $Loc 10] set Fin [lindex $Loc 11] set Sens [lindex $Loc 12] break } } } # EST set EST [InterrogeSelectedEST $FichierSelectEST Nom $DD LesAccess] if {$EST==""} {set SiEST 0} else {set SiEST 1} # Papier Lemaire et al. if {[info exists Paper($DD)]} {set Papier 1} else {set Papier 0} # profil moyen (Jumeaux) set FichierFinal "[RepertoireDuGenome]/ANALYSE/final" set PMoy [InterrogeFichierFinal $DD PMoy] set IMoy [InterrogeFichierFinal $DD IMoy] # set CC [ExtraitInfo $DD "CodeClone"] set Ow [ExtraitInfo $DD "OwnerOfCDNA"] if {$Ow=="R"} {set Ow "I"} if {$Ow=="F"} {set CC [string toupper $CC]} set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" mRNA Access] # JR if {$JR!=""} { if {$AccBestProtHuman==""} { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" Protein Access] } } # -- if {$AccBestProtHuman!=""} { set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition] } else {set DefBestProtHuman ""} # JR if {$JR!=""} { if {$AccBestmRNAHuman==""} { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $JR Organisme "Homo sapiens" mRNA Access] } } # -- if {$AccBestmRNAHuman!=""} { set DefBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestmRNAHuman Definition] } else {set DefBestmRNAHuman ""} if {[info exists Band($Ow,$CC)]} { set Bande $Band($Ow,$CC) #Bandes de Fred du type H16B sans profil alors que H16 avec profil et meme bande if {$Ow=="F" && [regexp -nocase {[A-Z]+[0-9]+[A-Z]} $Bande]} { regexp -nocase -indices {[A-Z]+[0-9]+} $Bande tmp set NewBande [string range $Bande 0 [lindex $tmp 1]] set Bande $NewBande } # Donnees manquantes (pour la plupart, clones de Fred) if {(![info exists I_TE($Ow,$Bande)] || ([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)=="")) || (![info exists I_NE($Ow,$Bande)] || ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)==""))} { set Ite "" set Ine "" } if {(![info exists I_TS($Ow,$Bande)] || ([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)=="")) || (![info exists I_NS($Ow,$Bande)] || ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)==""))} { set Its "" set Ins "" } if {(![info exists I_TU($Ow,$Bande)] || ([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)==""))|| (![info exists I_NU($Ow,$Bande)] || ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)==""))} { set Itu "" set Inu "" } if {([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)!="") && ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)!="")} { set Ite $I_TE($Ow,$Bande) set Ine $I_NE($Ow,$Bande) } if {([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)!="") && ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)!="")} { set Its $I_TS($Ow,$Bande) set Ins $I_NS($Ow,$Bande) } if {([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)!="") && ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)!="")} { set Itu $I_TU($Ow,$Bande) set Inu $I_NU($Ow,$Bande) } if {$Ite=="" && $Ine=="" && $Its=="" && $Ins=="" && $Itu=="" && $Inu==""} { Espionne "aucune valeur de gel DD pour cette bande: $Bande" } } else { Espionne "$DD : no band" #AppendAuFichier $FichierPbsBand "$DD $CC $Ow" set Bande ""; set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu "" } if {[info exists P($DD)]} {set Profil $P($DD)} else {set Profil ""} if {[info exists Pc($DD)]} {set Pcons $Pc($DD)} else {set Pcons ""} AppendAuFichier $FichierSortie1 "$DD\t$JR\t$CC\t$Ow\t$Bande\t$InfoCourt\t$InfoConta\t$InfoN\t$Chro\t$Deb\t$Fin\t$Sens\t$BandeCyto\t$SiEST\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Profil\t$Pcons\t$PMoy\t$IMoy\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu\t$Papier" } } proc oldCreeLesFichiersDataDD {FichierSortie1 FichierSortie2 FichierPbsBand FichierPbsExpr} { #FichierSortie1 TotalData #FichierSortie2 DataUniques #FichierPbsBand Pbs_band #FichierPbsExpr Pbs_expr #Attention au fichier avec les jumeaux. foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Clones_bandes_new"] { ## (rq: pas de user R dans ce fichier) if {[regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set U [lindex $LesChamps 0] ### ATTENTION: enlever les espaces qui sont parfois apres le codeclone ###### set CodeClone [string trim [lindex $LesChamps 1]] if {$U=="F"} { set CodeClone [string toupper $CodeClone] } set B [lindex $LesChamps 2] set Band($U,$CodeClone) $B } #Espionne "[array names Band]" #Profil foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/FoldExpression_tous"] { set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 0] set Prof [lindex $LesChamps 1] if {$Prof=="+"} {set P($DD) "T"} if {$Prof=="-"} {set P($DD) "N"} if {$Prof=="0"} {set P($DD) "C"} } #Profil_consensus foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/ResolutionTotaleDesConflits_pourGscope.txt"] { if {[regexp "gscopecode" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set DD [lindex $LesChamps 1] set ProfCons [lindex $LesChamps 5] set Pc($DD) $ProfCons } #Intensites ############################################# # Attention! # # les numeros de bandes ne sont pas uniques # # Exemple: J PM et CW ont fait une bande 48 # ############################################# foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/OVERLAP/Bands_intensiteDD.txt"] { if {[regexp "user" $Ligne]} {continue} set LesChamps [split $Ligne "\t"] set User [lindex $LesChamps 0] set B [lindex $LesChamps 1] regsub -all "\'" $B "" B set I_TE($User,$B) [lindex $LesChamps 3] set I_NE($User,$B) [lindex $LesChamps 4] set I_TS($User,$B) [lindex $LesChamps 5] set I_NS($User,$B) [lindex $LesChamps 6] set I_TU($User,$B) [lindex $LesChamps 7] set I_NU($User,$B) [lindex $LesChamps 8] } set n 0 #j ai remplace LesLignesDuFichier "[RepertoireDuGenome]/fiches/ClustersNew" #par listedespabs foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/931"] { Espionne $Ligne set LesJumeaux [split $Ligne " "] set NbJumeaux [llength $LesJumeaux] #Espionne "nb jum : $NbJumeaux" set Pena 0 incr n #Espionne "nb jum : $LesJumeaux" set SommeIte 0 set SommeIne 0 set SommeIts 0 set SommeIns 0 set SommeItu 0 set SommeInu 0 set VuProt 0 set VuRNA 0 foreach DD $LesJumeaux { Espionne $DD set CC [ExtraitInfo $DD "CodeClone"] set Ow [ExtraitInfo $DD "OwnerOfCDNA"] if {$Ow=="R"} {set Ow "I"} if {$Ow=="F"} {set CC [string toupper $CC]} set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" Protein Access] set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $DD Organisme "Homo sapiens" mRNA Access] if {$AccBestProtHuman!=""} { set DefBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition] set VuProt 1 set AccProt $AccBestProtHuman set DefProt $DefBestProtHuman } else {set DefBestProtHuman ""} if {$AccBestmRNAHuman!=""} { set DefBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestmRNAHuman Definition] set VuRNA 1 set AccRNA $AccBestmRNAHuman set DefRNA $DefBestmRNAHuman } else {set DefBestmRNAHuman ""} if {[info exists Band($Ow,$CC)]} { set Bande $Band($Ow,$CC) #Donnees manquantes #"Pena" compte les bandes pour lesquelles y a des data manquantes if {(![info exists I_TE($Ow,$Bande)] || ([info exists I_TE($Ow,$Bande)] && $I_TE($Ow,$Bande)=="")) || (![info exists I_NE($Ow,$Bande)] || ([info exists I_NE($Ow,$Bande)] && $I_NE($Ow,$Bande)=="")) || (![info exists I_TS($Ow,$Bande)] || ([info exists I_TS($Ow,$Bande)] && $I_TS($Ow,$Bande)=="")) || (![info exists I_NS($Ow,$Bande)] || ([info exists I_NS($Ow,$Bande)] && $I_NS($Ow,$Bande)=="")) || (![info exists I_TU($Ow,$Bande)] || ([info exists I_TU($Ow,$Bande)] && $I_TU($Ow,$Bande)=="")) || (![info exists I_NU($Ow,$Bande)] || ([info exists I_NU($Ow,$Bande)] && $I_NU($Ow,$Bande)=="")) } { set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu ""; incr Pena if {[info exists P($DD)]} {set Profil $P($DD)} else {set Profil ""} if {[info exists Pc($DD)]} {set Pcons $Pc($DD)} else {set Pcons ""} AppendAuFichier $FichierSortie1 "$n\t$DD\t$CC\t$Ow\t$Bande\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Profil\t$Pcons\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu" #Espionne "$DD : pas de donnees d expression" AppendAuFichier $FichierPbsExpr "$DD $CC $Ow" continue } set Ite $I_TE($Ow,$Bande) set Ine $I_NE($Ow,$Bande) set Its $I_TS($Ow,$Bande) set Ins $I_NS($Ow,$Bande) set Itu $I_TU($Ow,$Bande) set Inu $I_NU($Ow,$Bande) #[info exists Vu($Bande,$Ow)] #le profil d'une bande deja vue ne compte pas. #incr Pena #else set SommeIte [expr $SommeIte + $Ite] set SommeIne [expr $SommeIne + $Ine] set SommeIts [expr $SommeIts + $Its] set SommeIns [expr $SommeIns + $Ins] set SommeItu [expr $SommeItu + $Itu] set SommeInu [expr $SommeInu + $Inu] } else { #Espionne "$DD : no band" AppendAuFichier $FichierPbsBand "$DD $CC $Ow" set Bande ""; set Ite "";set Ine "";set Its "";set Ins "";set Itu "";set Inu "" incr Pena } if {[info exists P($DD)]} {set Profil $P($DD)} else {set Profil ""} if {[info exists Pc($DD)]} {set Pcons $Pc($DD)} else {set Pcons ""} AppendAuFichier $FichierSortie1 "$n\t$DD\t$CC\t$Ow\t$Bande\t$AccBestProtHuman\t$DefBestProtHuman\t$AccBestmRNAHuman\t$DefBestmRNAHuman\t$Profil\t$Pcons\t$Ite\t$Ine\t$Its\t$Ins\t$Itu\t$Inu" set Vu($Bande,$Ow) 1 } if {$VuProt==0} {set AccProt ""; set DefProt ""} if {$VuRNA==0} {set AccRNA "";set DefRNA ""} set Total [expr $NbJumeaux-$Pena] if {$Total==0} { #Espionne "total nul pour $Ligne" AppendAuFichier $FichierSortie2 "$n\t$AccProt\t$DefProt\t$AccRNA\t$DefRNA" if {[info exists Vu]} {unset Vu} continue } ####### E S U distincts ############## set TNE [expr $SommeIte-$SommeIne] set TNS [expr $SommeIts-$SommeIns] set TNU [expr $SommeItu-$SommeInu] if {$TNE>0} {set PE "T"} ; if {$TNE<0} {set PE "N"} ;if {$TNE==0} {set PE "0"} if {$TNS>0} {set PS "T"} ; if {$TNS<0} {set PS "N"} ;if {$TNS==0} {set PS "0"} if {$TNU>0} {set PU "T"} ; if {$TNU<0} {set PU "N"} ;if {$TNU==0} {set PU "0"} ######## MOYENNES ################## set SommeDesMoyennesN [format "%.3f" [expr ($SommeIne*1.0/$Total*1.0)+($SommeIns*1.0/$Total*1.0)+($SommeInu*1.0/$Total*1.0)]] set SommeDesMoyennesT [format "%.3f" [expr ($SommeIte*1.0/$Total*1.0)+($SommeIts*1.0/$Total*1.0)+($SommeItu*1.0/$Total*1.0)]] set TNmoy [expr ($SommeDesMoyennesT-$SommeDesMoyennesN)] if {$TNmoy>0} {set Pmoy "T"} if {$TNmoy<0} {set Pmoy "N"} if {$TNmoy==0} {set Pmoy "0"} AppendAuFichier $FichierSortie2 "$n\t$AccProt\t$DefProt\t$AccRNA\t$DefRNA\t$TNE\t$PE\t$TNS\t$PS\t$TNU\t$PU\t$TNmoy\t$Pmoy" if {[info exists Vu]} {unset Vu} } } proc oldLesAutresJumeaux {FichierClusters {RepCollection ""}} { #Autres jumeaux = JR ayant le meme mRNA ou la meme proteine. if {$RepCollection==""} {set RepCollection [RepertoireDuGenome]} set LesDefinitons {} foreach Nom [ListeDesJR $FichierClusters] { set Proteine [ExtraitLaProteineDesInfosAutomatiques $Nom $RepCollection] if {$Proteine !=""} { lappend LesDefinitons "$Proteine $Nom" } else { set mRNA [ExtraitDefinitionRNADesInfosAutomatiques $Nom $RepCollection] if {$mRNA!=""} { lappend LesDefinitons "$mRNA $Nom" } } } set LesDefinitonsTriees [lsort -dictionary $LesDefinitons] set DefinitionPrec "" set LesDoublons {} foreach Definition $LesDefinitonsTriees { if {[regexp " " $Definition]} {regsub " " $Definition " " Definition} set l [llength $Definition] set Nom [lindex $Definition [expr $l-1]] regsub "$Nom" $Definition "" Def if {$DefinitionPrec!=""} { set lprec [llength $DefinitionPrec] set NomPrec [lindex $DefinitionPrec [expr $lprec-1]] regsub "$NomPrec" $DefinitionPrec "" DefPrec } else {set DefPrec $DefinitionPrec} if {$Def==$DefPrec} { #lappend LesDoublons "$Nom = $NomPrec" lappend LesDoublons $Nom } set DefinitionPrec $Definition } #Espionne [llength $LesDoublons] return $LesDoublons } proc oldM_invM {M} { T_M T $M 1 return [M_T [T33_invT33 TI T]] } proc oldTailleEchantillon {FichierTfa} { set LongueurTfa [LongueurSeqTfa $FichierTfa] set NbCodons [expr $LongueurTfa/3] return $NbCodons } proc old_CreeFichierDaedalus {} { foreach Nom [ListeDesPABs] { Espionne $Nom #set AccessProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access] set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom" set ID [AccessDuTFADeLaProteine $FichierTFA] if {$AccessProtHuman==""} {set AccessProtHuman $ID; lappend LesIDAccessProtHuman $AccessProtHuman} #FaireLire "$Nom $AccessProtHuman $ID" #AppendAuFichier "[RepertoireDuGenome]/PremierFichierDaedalus" "ID $ID\nDR prot;$AccessProtHuman;prot.\n//" } foreach ID $ } proc old_InterrogeFichierRequete {Fichier} { foreach Ligne [LesLignesDuFichier $Fichier] { if {$Ligne==""} {continue} set PFAM [lindex $Ligne 0] set Nb [lindex $Ligne 1] if {$Nb==0} {lappend LesPFAMSpecifiques $PFAM} } Espionne [llength $LesPFAMSpecifiques] SauveLesLignes $LesPFAMSpecifiques dans "[RepertoireDuGenome]/fiches/DomainesSpecifiques" } proc old_ListeDesDatas {FichierClusters {Selec "EXH-PPRB PP00"}} { set Liste [ListeDesJR $FichierClusters] set LesDatas {} set LesSelec [split $Selec " "] foreach Nom $Liste { set CodeClone [ExtraitInfo $Nom OwnerOfCDNA] foreach Sel $LesSelec { if {[regexp "^$Sel" $CodeClone]} {lappend LesDatas $Nom} } } Espionne "nb uniques: [llength $LesDatas]" SauveLesLignes $LesDatas dans "[RepertoireDuGenome]/DatasBPH" } proc old_ListeLesSansRien {} { set ListeNo {} set Fichier "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human_Best" #set Fichier "[RepertoireDuGenome]/Localisation/BestLocalisation_Human" if {![file exists $Fichier]} {return "$Fichier doesn t exist"} foreach Nom [ListeDesPABs] { #Espionne $Nom set FMRM "[RepertoireDuGenome]/nucmask/$Nom.mrm" if {![file exists $FMRM]} {return "$Nom -> pas de nucmask!"} set SeqMRM [QueLaSequenceDuFichierTFA $FMRM] #set LAvtMRM [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqSansNMRM set LApresMRM [string length $SeqSansNMRM] if {$LApresMRM>=25} { Espionne $Nom #la loc des seq DD est tellement difficile qu'il ne faut pas en tenir compte! #sauf si elle est nulle. Voir proc CompteLesSequencesDDBizarres set Loc [InterrogeLocalisation $Fichier Nom $Nom] #set AccRNACh [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] #set AccProtCh [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] #set OrgaChoisi [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] set AccessmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "mRNA" Access] set AccessProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" "Protein" Access] set FichierBlastnest "[RepertoireDuGenome]/blastnest-human/$Nom" if {$Loc==""} {set L 0} else {set L 1} if {$AccessmRNAHuman==""} {set R 0} else {set R 1} if {$AccessProtHuman==""} {set P 0} else {set P 1} if {$L==0 && $R==0 && $P==0} { if {[file exists $FichierBlastnest]} { #set Test [TestBlast $FichierBlastnest] #95% pour test par defaut set Test [MatchWithESTsOuiOuNon $Nom $FichierBlastnest] #if {$Test==0} {lappend ListeNo $Nom} if {$Test==0} { lappend ListeNo $Nom AppendAuFichier "[RepertoireDuGenome]/lessansrien2" $Nom } #if {$Test==1} {lappend ListeNoAvecEST $Nom} } else { lappend ListeNo $Nom AppendAuFichier "[RepertoireDuGenome]/lessansrien2" $Nom } } } } #Espionne "avec est: [llength $ListeNoAvecEST]" Espionne "sans rien:[llength $ListeNo]" return $ListeNo } proc oldacFichierRecapitulatif {Nom {Projet ""} {Lab ""} {Protocol ""} {Def spe} {Nature DNA} {Orga ""} {IdMin 0.8} {IdMax 0.95}} { if {$Nom==""} {return} set RepRecap "[RepertoireDuGenome]/bilan" if {![file exists $RepRecap]} {File mkdir $RepRecap} set FichierRecap "$RepRecap/$Nom" set FichierOCADE "[RepertoireDuGenome]/fiches/Orf2Cluster2Access2Def2Expression" set FichierNuctfa "[RepertoireDuGenome]/nuctfa/$Nom" set FichierLocHumanG "[RepertoireDuGenome]/Localisation/BoxLocalisation_Human" set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" #set FichierProttfaExonicMap "[RepertoireDuGenome]/prottfaexonicmap/$Nom" set FichiermRNAExonicMap "[RepertoireDuGenome]/mrnatfa_Homo_sapiens_exonicmap/$Nom" set FichierClustMSF "[RepertoireDuGenome]/msf/$Nom.clust" set FichierMSF "[RepertoireDuGenome]/msf/$Nom" set FichierDefinition "[RepertoireDuGenome]/fiches/DefinitionsConsensus" set FichierBest "[RepertoireDuGenome]/fiches/BestProteinAndmRNAForeachOrga" ########## #PROJET### ########## if {$Projet!=""} { set LeTexte [list "PROJECT: $Projet"] } else { set Projet [RepertoireDuGenome] set Projet [file tail $Projet] set LeTexte [list "PROJECT: $Projet"] } lappend LeTexte "" lappend LeTexte "******************************************************" ############################################################################# ######## #INPUT## ######## lappend LeTexte "INPUT:" Espionne "$Nom -> From ; Protocol; Access ; Definition ; Organism; Nature; Length" if {$Lab==""} { set Lab $Projet } lappend LeTexte " From: $Lab" #Suppressive Subtractive Hybridization (SSH) if {$Protocol!=""} {lappend LeTexte " Protocol: $Protocol" } if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] != ""} { set AccessSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Access] lappend LeTexte " Access/Clone: $AccessSeq" } if {$Def=="spe"} { if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] != ""} { set DefinitionSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] lappend LeTexte " Infos: $DefinitionSeq" } } else { if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] != ""} { set DefinitionSeq [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Definition] lappend LeTexte " Definition: $DefinitionSeq" } } if {$Nature=="Protein"} { if {[file exists $FichierProttfa]} { set TailleSeq [TailleDeLaSequenceDuFichierTFA $FichierProttfa] lappend LeTexte " Length: $TailleSeq pb" } } elseif {[file exists $FichierNuctfa]} { set TailleSeq [TailleDeLaSequenceDuFichierTFA $FichierNuctfa] lappend LeTexte " Length: $TailleSeq pb" } lappend LeTexte " Nature: $Nature" set OrganismeSeq [OrganismeDuPAB $Nom] lappend LeTexte " Organism: $OrganismeSeq" if {$OrganismeSeq == "Homo sapiens"} {set IdDeRef $IdMax} else {set IdDeRef $IdMin} set PIdDeRef [format "%.1f" [expr $IdDeRef * 100]] ###Cluster dans lequel se trouve la sequence#### Espionne "$Nom -> cluster" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] != ""} { set Cluster [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Cluster] lappend LeTexte " Cluster: $Cluster" } ###Les expressions sur les puces affymetrix##### Espionne "$Nom -> expression" if {[InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom LesExpressions] != ""} { set LesTemps [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesPointsTemporels] set LesConditions [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE LesConditions ] set LaLigneTemps [list [format "%-6s" ""]] foreach Temps $LesTemps {lappend LaLigneTemps [format "%-6s" $Temps]} lappend LeTexte "" lappend LeTexte " Expression:" lappend LeTexte [join $LaLigneTemps ""] foreach Condition $LesConditions { set LaLigneCondition [list [format "%-6s" $Condition]] foreach Temps $LesTemps { set Expr [InterrogeOrf2Cluster2Access2Def2Expression $FichierOCADE $Nom Condition $Condition PointTemporel $Temps Expression] if {$Expr == ""} {lappend LaLigneCondition [format "%-6s" ""];continue} lappend LaLigneCondition [format "%-6.0f" $Expr] } lappend LeTexte [join $LaLigneCondition ""] } } ###Composition ATCG### #....................# ###Les informations relatives au masking, remasking et mrm#### Espionne "$Nom -> Masking ; ReMasking ; Masking and ReMasking" if {[InterrogeBilanMasking $Nom LesEtats] != ""} { lappend LeTexte "" foreach Etat [InterrogeBilanMasking $Nom LesEtats] { if {[InterrogeBilanMasking $Nom Etat $Etat PMasked] == ""} {continue} set PMasked [InterrogeBilanMasking $Nom Etat $Etat PMasked ] set NbRepeat [InterrogeBilanMasking $Nom Etat $Etat NbRepeat] lappend LeTexte " $Etat PMasked: ${PMasked}%" lappend LeTexte " $Etat NbRepeat: $NbRepeat" set LesRepeatsEtLeurEffectif {} foreach Repeat [InterrogeBilanMasking $Nom Etat $Etat LesRepeats] { set n [InterrogeBilanMasking $Nom Etat $Etat Repeat $Repeat n] lappend LesRepeatsEtLeurEffectif [list $Repeat $n] } set LesRepeats {} foreach LeRepeat [lsort -index 1 -integer -decreasing $LesRepeatsEtLeurEffectif] { lappend LesRepeats "[lindex $LeRepeat 0] ([lindex $LeRepeat 1])" } if {$LesRepeats != {}} { lappend LeTexte " $Etat Repeat: [join $LesRepeats " ; "]" #lappend LeTexte [join $LesRepeats " ; "] } } } lappend LeTexte "" lappend LeTexte "******************************************************" ############################################################################# ######## #OUTPUT# ######## lappend LeTexte "OUTPUT:" lappend LeTexte " **********************************************" lappend LeTexte " General points:" lappend LeTexte "" lappend LeTexte " GScopeName: $Nom" ###Definition moyenne### Espionne "$Nom -> mean definition" if {[InterrogeDefinitionsConsensus $Nom Definition]!=""} { set DefMoy [InterrogeDefinitionsConsensus $Nom Definition] lappend LeTexte " Mean definition: $DefMoy" } ###Les noms des genes des proteines du meme cluster de msf que la proteine de ref### Espionne "$Nom -> Gene name" if {[InterrogeGeneName $Nom LesGeneNames] != ""} { set LesGeneNames {} foreach GN [InterrogeGeneName $Nom LesGeneNames] { if {$GN == ""} {continue} lappend LesGeneNames [list $GN [InterrogeGeneName $Nom GeneName $GN n]] } if {$LesGeneNames != {}} { set LesGeneNamesEtLeurEffectif {} foreach LeGN [lsort -index 1 -decreasing -integer $LesGeneNames] { lappend LesGeneNamesEtLeurEffectif "[lindex $LeGN 0] ([lindex $LeGN 1])" } #lappend LeTexte "" lappend LeTexte " GeneName: [join $LesGeneNamesEtLeurEffectif " ; "]" #lappend LeTexte " [join $LesGeneNamesEtLeurEffectif " ; "]" } } lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Chromosomal localisation" ############################################################################## ###Localisation de la sequence sur le genome humain### Espionne "$Nom -> localisation on human genome" if {[file exists $FichierLocHumanG]} { lappend LeTexte "" lappend LeTexte " Input sequence localisation:" if {[InterrogeLocalisation $FichierLocHumanG Nom $Nom] != ""} { set LesLocalisations [InterrogeLocalisation $FichierLocHumanG Nom $Nom] set InfoLoc [lindex [lindex $LesLocalisations 0] 1] if {$InfoLoc != "MonoLoc"} { lappend LeTexte " WARNING $InfoLoc" } foreach LaLocalisation $LesLocalisations { if {[lindex $LaLocalisation end] != "BestLoc" && [lindex $LaLocalisation end] != "BestPolyLoc"} {continue} set Chromosome [lindex $LaLocalisation 9 ] set D [lindex $LaLocalisation 10 ] set F [lindex $LaLocalisation 11 ] set Sens [lindex $LaLocalisation 12 ] set Contig [lindex $LaLocalisation 13 ] set BCyto [lindex $LaLocalisation end-1] set Id [lindex $LaLocalisation 6 ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } } } else { lappend LeTexte " WARNING NoLoc" } } ###Localisation du human mRNA sur le genome humain### Espionne "$Nom -> localisation of the human complete cds mRNA" if {[file exists $FichiermRNAExonicMap]} { lappend LeTexte "" lappend LeTexte " Complete cds human mRNA localisation:" if {[InterrogeFichierExonicMap $FichiermRNAExonicMap LesRangs] != ""} { #nb exons set NbExons [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang 1 NbExonicAreas] if {$NbExons>0} { set Contig [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang 1 Contig] set LesDebEtFin {} set n 1 while {$n<[expr $NbExons+1]} { set DS [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang 1 ExonArea $n DS] set FS [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang 1 ExonArea $n FS] set Sens [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang 1 ExonArea $n Sens] lappend LesDebEtFin "Exon $n From $DS To $FS ($Sens) on Contig $Contig" incr n } } set LesRangs [InterrogeFichierExonicMap $FichiermRNAExonicMap LesRangs] if {1 < [llength $LesRangs]} {lappend LeTexte " WARNING PolyLoc"} foreach Rang $LesRangs { set Chromosome [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang Chromosome ] set Contig [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang Contig ] set DebCont [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang ContigLocalisation Debut] set FinCont [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang ContigLocalisation Fin ] set SensCont [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang Sens ] set LesCoordonneesSurChro [CoordonneesSurChromosome $Contig $DebCont $FinCont $SensCont] set D [lindex $LesCoordonneesSurChro 1] set F [lindex $LesCoordonneesSurChro 2] set Sens [lindex $LesCoordonneesSurChro 3] set BCyto [join [LesBandesCytologiquesDeLaLocalisation $Contig $DebCont $FinCont] " ; "] set n 0 set nTot 0 set NbAreas [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang NbExonicAreas] for {set i 1} {$i <= $NbAreas} {incr i} { incr n [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang ExonArea $i nAli ] incr nTot [InterrogeFichierExonicMap $FichiermRNAExonicMap Rang $Rang ExonArea $i nAliTot] } if {$nTot == 0} {continue} set Id [expr $n * 1.0 / $nTot] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Chromosome $Chromosome from $D to $F in $Sens strand ; Contig $Contig ; CytoBand $BCyto" lappend LeTexte " Human Identity: ${PId}%" set IdDeRef $IdMax if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the human genome is only $PId% (< $PIdDeRef%)" } } } else { lappend LeTexte " WARNING NoLoc" } InterrogeFichierExonicMap unset } if {[info exists NbExons]} { lappend LeTexte " Nb_Exons: $NbExons" foreach DebFin $LesDebEtFin { lappend LeTexte " $DebFin" } } ######################################################################## ####Si projet proteine if {$Nature=="Protein"} { if {[file exists $FichierBest]} { if {$Orga=="mouse"} { #special pour ProteoSys #mouse protein set ProteinAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Mus musculus" Protein Access] if {$ProteinAccess!=""} { set ProteinDef [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Definition] set ProteinTaille [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Taille] set ProteinId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $ProteinAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Mouse protein:" lappend LeTexte " Protein Access: $ProteinAccess" lappend LeTexte " Protein Definition: $ProteinDef" lappend LeTexte " Protein Organism: Mus musculus" lappend LeTexte " Protein Length: $ProteinTaille AA" lappend LeTexte " Percent Identity: $ProteinId" } #mouse mRNA set mRNAAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Mus musculus" mRNA Access] if {$mRNAAccess!=""} { set mRNADef [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Definition] set mRNATaille [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Taille] set mRNAId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $mRNAAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Mouse mRNA full length:" lappend LeTexte " mRNA Access: $mRNAAccess" lappend LeTexte " mRNA Definition: $mRNADef" lappend LeTexte " mRNA Organism: Mus musculus" lappend LeTexte " mRNA Length: $mRNATaille bp" lappend LeTexte " Percent Identity: $mRNAId" } } #human protein set ProteinAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$ProteinAccess!=""} { set ProteinDef [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Definition] set ProteinTaille [InterrogeBestProteinAndmRNAForeachOrga Access $ProteinAccess Taille] set ProteinId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $ProteinAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Human protein:" lappend LeTexte " Protein Access: $ProteinAccess" lappend LeTexte " Protein Definition: $ProteinDef" lappend LeTexte " Protein Organism: Homo sapiens" lappend LeTexte " Protein Length: $ProteinTaille AA" lappend LeTexte " Percent Identity: $ProteinId" } #human mRNA set mRNAAccess [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$mRNAAccess!=""} { set mRNADef [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Definition] set mRNATaille [InterrogeBestProteinAndmRNAForeachOrga Access $mRNAAccess Taille] set mRNAId [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $mRNAAccess Identity] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Human mRNA full length:" lappend LeTexte " mRNA Access: $mRNAAccess" lappend LeTexte " mRNA Definition: $mRNADef" lappend LeTexte " mRNA Organism: Homo sapiens" lappend LeTexte " mRNA Length: $mRNATaille bp" lappend LeTexte " Percent Identity: $mRNAId" } } } ######################################################################### ###Commencons maintenant le boulot pour la meilleure proteine trouvee#### ##fichier accessdesprotetdesmrnaschoisis absent dans projet protein Espionne "$Nom -> best protein found" set AccessDuChoisi "" set InfoSeq [InterrogeProtAndmRNAChoisis $Nom SeqChoisie] set TailleProt [TailleDeLaSequenceDuFichierTFA $FichierProttfa] if {$InfoSeq != ""} { if {$InfoSeq == "SeqOK"} { lappend LeTexte "" lappend LeTexte " **********************************************" set AccessProt [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessmRNA [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] if {![string equal -nocase $AccessProt "NoProtein"]} { set AccessDuChoisi $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LesOrganismes [LesOrgasDeLaPage_PageInfo $PageInfoProt] if {$LesOrganismes == ""} { set LesOrganismes [list [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]] } } if {[string equal -nocase $AccessProt "NoProtein"] && ![string equal -nocase $AccessmRNA "NomRNA"]} { set AccessProt "NoAccess" set DefProt "NoDef" set LesOrganismes [list [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi]] set From "mRNA complete CDS of BLASTN against genembl DB" set AccessDuChoisi $AccessmRNA } if {![string equal -nocase $AccessProt "NoProtein"] || ![string equal -nocase $AccessmRNA "NomRNA"]} { set Rang [lindex [InterrogeProtAndmRNA $Nom Access $AccessDuChoisi LesRangs] 0] set Type [InterrogeProtAndmRNA $Nom Rang $Rang Type ] if {$Type == "mRNA"} {set From "mRNA complete CDS from BLASTN against genembl DB"} else {set From "BLASTX against protein DB"} lappend LeTexte " Protein:" lappend LeTexte " Protein Access: $AccessProt" lappend LeTexte " Protein Definition: $DefProt" lappend LeTexte " Protein Organisms: [join $LesOrganismes " ; "]" lappend LeTexte " Protein Length: $TailleProt AA" lappend LeTexte " Protein From: $From" set DejaVu($AccessProt) 1 set IdDeLaProtAvecSeq $IdMin foreach Orga $LesOrganismes { if {$Orga == $OrganismeSeq} {set IdDeLaProtAvecSeq $IdMax} } set PIdDeLaProtAvecSeq [format "%.1f" [expr $IdDeLaProtAvecSeq * 100]] set Id [InterrogeProtAndmRNA $Nom Rang $Rang Id] set PId [format "%.1f" [expr $Id * 100]] if {$Type != "mRNA"} { lappend LeTexte " Protein Identity: $PId%" if {$Id < $IdDeLaProtAvecSeq} { lappend LeTexte " WARNING the identity with the sequence is only $PId% (< $PIdDeLaProtAvecSeq%)" } } if {$AccessmRNA != "NomRNA" && $Type == "mRNA"} { set PageInfomRNA [PageInfo $AccessmRNA genbankfull "id acc des org"] set DefmRNA [join [LaDefinitionDeLAcNuc_PageInfo $PageInfomRNA] " " ] set Organismes [join [LesOrgasDeLaPage_PageInfo $PageInfomRNA] " ; "] set TaillemRNA [TailleDeLAcNuc_PageInfo $PageInfomRNA] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " mRNA:" lappend LeTexte " mRNA Access: $AccessmRNA" lappend LeTexte " mRNA Definition: $DefmRNA" lappend LeTexte " mRNA Organisms: $Organismes" lappend LeTexte " mRNA Length: $TaillemRNA pb" lappend LeTexte " mRNA Identity: $PId%" if {$Id < $IdDeLaProtAvecSeq} { lappend LeTexte " WARNING the identity with the sequence is only $PId% (< $PIdDeLaProtAvecSeq%)" } set DejaVu($AccessmRNA) 1 } } InterrogeProtAndmRNA unset } else { set AccessProt [string toupper [InterrogeContigAndProt $Nom Protein Access]] if {$AccessProt != ""} { lappend LeTexte "" lappend LeTexte " **********************************************" set AccessDuChoisi $AccessProt set PageInfoProt [PageInfo $AccessProt protein "ID ORG DES"] set DefProt [join [LaDefinitionDeLaProt_PageInfo $PageInfoProt] " " ] set LesOrganismes [LesOrgasDeLaPage_PageInfo $PageInfoProt] set Organismes [join $LesOrganismes " ; " ] set From " Contig from BLASTN against genembl DB" set AccessContig [string toupper [InterrogeContigAndProt $Nom Contig Access ]] set TailleContig [InterrogeContigAndProt $Nom Contig Taille ] set OrgaContig [InterrogeContigAndProt $Nom Contig Organisme] lappend LeTexte " Protein:" lappend LeTexte " Protein Access: $AccessProt" lappend LeTexte " Protein Definition: $DefProt" lappend LeTexte " Protein Organism: $Organismes" lappend LeTexte " Protein Length: $TailleProt AA" lappend LeTexte " Protein From: $From" set DejaVu($AccessProt) 1 set Id [InterrogeContigAndProt $Nom Protein Identity ] set PId [format "%.1f" [expr $Id * 100]] set IdDeRefDeLaProtAvecContig $IdMin foreach Orga $LesOrganismes { if {$Orga == $OrgaContig} {set IdDeRefDeLaProtAvecContig $IdMax} } set PIdDeRefDeLaProtAvecContig [format "%.1f" [expr $IdDeRefDeLaProtAvecContig * 100]] lappend LeTexte " Identity with Contig: $PId%" if {$Id < $IdDeRefDeLaProtAvecContig} { lappend LeTexte " WARNING the identity with the se is only $PId% (< $PIdDeRefDeLaProtAvecContig%)" } lappend LeTexte "" lappend LeTexte " Contig:" lappend LeTexte " Contig Access: $AccessContig" lappend LeTexte " Contig Organism: $OrgaContig" lappend LeTexte " Contig Length: $TailleContig pb" set DejaVu($AccessContig) 1 set Id [InterrogeContigAndProt $Nom Contig Identity ] set PId [format "%.1f" [expr $Id * 100]] lappend LeTexte " Identity with sequence: $PId%" if {$Id < $IdDeRef} { lappend LeTexte " WARNING the identity with the sequence is only $PId% (< $PIdDeRef%)" } } } } ######################################################################## ###Enfin le MSF c'etait pas trop tot#### Espionne "$Nom -> informations about multiple alignment" set AvecMSF 0 if {[file exists $FichierMSF] && [DecortiqueUnMSF $FichierMSF LesAccess Sequences]} { set AvecMSF 1 set NbAccess [llength $LesAccess ] set NormMDTot [MDScore $FichierMSF "CalculeMoi"] lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Protein family:" lappend LeTexte "" lappend LeTexte " Multiple alignment:" lappend LeTexte " Nb proteins: $NbAccess" lappend LeTexte " NormMD: $NormMDTot" if { $NormMDTot < 0.3} {lappend LeTexte " WARNING the quality of the alignment is bad" } if {0.3 <= $NormMDTot && $NormMDTot < 0.5} {lappend LeTexte " WARNING the quality of the alignment is medium"} } if {[InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] != "" && $AvecMSF} { set LesClusters [InterrogeLesClustersDesMSF $FichierClustMSF LesClusters] set NbClusters [llength $LesClusters] set ClusterDeLaProt [InterrogeLesClustersDesMSF $FichierClustMSF Access $Nom Cluster ] set LesAccess [InterrogeLesClustersDesMSF $FichierClustMSF Cluster $ClusterDeLaProt LesAccess] set NbAccess [llength $LesAccess] set NormMDDuClust [MDScoreAvecSelectionDuFichier $FichierMSF $LesAccess] lappend LeTexte " Nb clusters: $NbClusters" lappend LeTexte " Cluster of our protein: $ClusterDeLaProt" lappend LeTexte " Nb proteins in our cluster: $NbAccess" lappend LeTexte " NormMD of our Cluster: $NormMDDuClust" if { $NormMDDuClust < 0.3} {lappend LeTexte " WARNING the quality of the alignment is bad" } if {0.3 <= $NormMDDuClust && $NormMDDuClust < 0.5} {lappend LeTexte " WARNING the quality of the alignment is medium"} InterrogeLesClustersDesMSF unset } ###Recherche des proteines identiques a 98%" set LesAccessDesChoisi {} if {$AccessDuChoisi != ""} {lappend LesAccessDesChoisi $AccessDuChoisi} Espionne "$Nom -> proteins with 98% of identity with the best protein" if {$AvecMSF} { set LesAccessDesIdentiques {} foreach Access [LesAccessDesProteinesIdentiquesDansMSF $FichierMSF $Nom 0.98] { set Access [string toupper $Access] if {[info exists DejaVu($Access)]} {continue} set DejaVu($Access) 1 lappend LesAccessDesChoisi $Access set PageInfo [PageInfo $Access protein "id acc des org"] set LesOrgas [LesOrgasDeLaPage_PageInfo $PageInfo] set Def [join [LaDefinitionDeLaProt_PageInfo $PageInfo] " "] set Taille [TailleDeLaProt_PageInfo $PageInfo] foreach Orga $LesOrgas { lappend LesAccessDesIdentiques " $Access ; Protein ; $Taille AA ; $Orga ; $Def" } } if {$LesAccessDesIdentiques != {}} { lappend LeTexte "" #lappend LeTexte "Proteins with 98% of identity with our protein:" lappend LeTexte " Identical or quasi-identical proteins:" foreach LAccessIdentique $LesAccessDesIdentiques { lappend LeTexte $LAccessIdentique } } } ###recherche des mRNAs et des proteines CrossLinked#### Espionne "$Nom -> mRNAs and proteins cross-linked" if {$LesAccessDesChoisi != {}} { set LesAccessCrossLinked {} foreach Access $LesAccessDesChoisi { if {$Access == ""} {continue} set LesAccessCrossLinked [concat $LesAccessCrossLinked [LesCrossLinkedDeLAccess_Recursif $Access]] } if {$LesAccessCrossLinked != {}} { set LeTexteDesCrossLinked {} foreach LAccessCL [lsort -index 1 $LesAccessCrossLinked] { set Access [string toupper [lindex $LAccessCL 0]] if {[info exists DejaVu($Access)]} {continue} set Quoi [lindex $LAccessCL 1] set Taille [lindex $LAccessCL 2] if {$Quoi == "mRNA" } {set Taille "$Taille bp"} if {$Quoi == "Protein"} {set Taille "$Taille AA"} set Orga [lindex $LAccessCL 3] set Def [lindex $LAccessCL 4] lappend LeTexteDesCrossLinked " $Quoi ; $Access ; $Taille ; $Orga ; $Def" } if {$LeTexteDesCrossLinked != {}} { lappend LeTexte "" lappend LeTexte " Others CrossLinked Accessions:" set LeTexte [concat $LeTexte $LeTexteDesCrossLinked] } } } lappend LeTexte "" ###Domaines### Espionne "$Nom -> Domaines" if {[InterrogeDomaines $Nom LesDomaines]!=""} { set LesDomaines [InterrogeDomaines $Nom LesDomaines] lappend LeTexte " Domains:" foreach Domaine $LesDomaines { if {[regexp "^INTERPRO" $Domaine] || [regexp "^PFAM" $Domaine]} { regsub -all {\{.*\}} $Domaine "" Domaine lappend LeTexte " $Domaine" } } } lappend LeTexte "" ###Et maintenant, TATATATA (roulements de tambours), l'ontologie#### Espionne "$Nom -> ontology" if {[InterrogeGeneOntology $FichierGO $Nom LesGO] != ""} { #lappend LeTexte " **********************************************" lappend LeTexte " Mean Gene Ontology:" set LesGOFunction {} set LesGOProcess {} set LesGOComponent {} foreach GO [InterrogeGeneOntology $FichierGO $Nom LesGO] { if {$GO == ""} {continue} set Type [InterrogeGeneOntology $FichierGO GO $GO Type] if {$Type == "function" } {lappend LesGOFunction $GO} if {$Type == "process" } {lappend LesGOProcess $GO} if {$Type == "component"} {lappend LesGOComponent $GO} } foreach GO $LesGOFunction { lappend LeTexte " Function $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } foreach GO $LesGOProcess { lappend LeTexte " Process $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } foreach GO $LesGOComponent { lappend LeTexte " Component $GO [join [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] ""]" } } ##Pathways KEGG## Espionne "$Nom -> KEGG" if {[InterrogeMesKEGG $Nom LesPathwayEtKeggEtEC]!=""} { lappend LeTexte "" lappend LeTexte " Mean KEGG:" } if {[InterrogeMesKEGG $Nom LesPathway]!=""} { set LesNumerosDesPathways [InterrogeMesKEGG $Nom LesPathway] foreach Pathway $LesNumerosDesPathways { set DefPathway [InterrogeMesKEGG Pathway $Pathway Definition] lappend LeTexte " Pathway $Pathway $DefPathway" } } if {[InterrogeMesKEGG $Nom LesEC]!=""} { set LesEC [InterrogeMesKEGG $Nom LesEC] foreach EC $LesEC { lappend LeTexte " EC $EC" } } if {[InterrogeMesKEGG $Nom LesKegg]!=""} { set LesKegg [InterrogeMesKEGG $Nom LesKegg] foreach Kegg $LesKegg { set DefKegg [InterrogeMesKEGG Kegg $Kegg Definition] lappend LeTexte " Kegg $Kegg $DefKegg" } } ###Tissue Type######### Espionne "$Nom -> Tissue Type" set TT "no" if {[InterrogeTissueType $Nom LesTissues] != ""} { set TT "yes" lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Complementary informations:" lappend LeTexte "" lappend LeTexte " EST of the input sequence:" set LesTissues {} foreach Tissue [InterrogeTissueType $Nom LesTissues] { if {$Tissue == ""} {continue} lappend LesTissues [list $Tissue [InterrogeTissueType $Nom Tissue $Tissue n]] } if {$LesTissues != {}} { set LesTissuesEtLeurEffectif {} foreach LeTissue [lsort -index 1 -decreasing -integer $LesTissues] { lappend LesTissuesEtLeurEffectif "[lindex $LeTissue 0] ([lindex $LeTissue 1])" } lappend LeTexte " TissueType: [join $LesTissuesEtLeurEffectif " ; "]" #lappend LeTexte " [join $LesTissuesEtLeurEffectif " ; "]" } } ###Development Stage######### Espionne "$Nom -> Development stage" if {[InterrogeDevStage $Nom LesDevStages] != ""} { if {$TT=="no"} { lappend LeTexte "" lappend LeTexte " **********************************************" lappend LeTexte " Complementary informations:" lappend LeTexte "" lappend LeTexte " EST of the input sequence:" } set LesDevStage {} foreach DevStage [InterrogeDevStage $Nom LesDevStages] { if {$DevStage == ""} {continue} lappend LesDevStage [list $DevStage [InterrogeDevStage $Nom DevStage $DevStage n]] } if {$LesDevStage != {}} { set LesDevStageEtLeurEffectif {} foreach LeDevStage [lsort -index 1 -decreasing -integer $LesDevStage] { lappend LesDevStageEtLeurEffectif "[lindex $LeDevStage 0] ([lindex $LeDevStage 1])" } lappend LeTexte " DevStage: [join $LesDevStageEtLeurEffectif " ; "]" #lappend LeTexte " [join $LesDevStageEtLeurEffectif " ; "]" } } EspionneL $LeTexte Sauve [join $LeTexte "\n"] dans $FichierRecap return } proc oldhsbToRgb {hue sat value} { # The procedure converts an HSB value to RGB. It takes hue, saturation, # and value components (floating-point, 0-1.0) as arguments, and returns a # list containing RGB components (integers, 0-65535) as result. The code # here is a copy of the code on page 616 of "Fundamentals of Interactive # Computer Graphics" by Foley and Van Dam. set v [format %.0f [expr 65535.0*$value]] if {$sat == 0} { return "$v $v $v" } else { set hue [expr $hue*6.0] if {$hue >= 6.0} { set hue 0.0 } scan $hue. %d i set f [expr $hue-$i] set p [format %.0f [expr {65535.0*$value*(1 - $sat)}]] set q [format %.0f [expr {65535.0*$value*(1 - ($sat*$f))}]] set t [format %.0f [expr {65535.0*$value*(1 - ($sat*(1 - $f)))}]] case $i 0 {return "$v $t $p"} 1 {return "$q $v $p"} 2 {return "$p $v $t"} 3 {return "$p $q $v"} 4 {return "$t $p $v"} 5 {return "$v $p $q"} error "i value $i is out of range" } } proc oldtmplistedespabs {} { set L [tempCompteNO] foreach Nom $L { set Vu($Nom) 1 } set FichierLDP "/genomics/link/HeadNecknonrnr/fiches/ListeDesPABs" foreach PAB [ListeDesPABs] { if {[info exists Vu($PAB)]} {continue} AppendAuFichier $FichierLDP $PAB } } proc optim {image coef} { set coef [expr {int($coef)}] if {$coef == 1} { return $image } set width [image width $image] set height [image height $image] set data [$image data] set data2 {} for {set y 0} {$y < $height} {incr y} { set row [lindex $data $y] set row2 {} for {set x 0} {$x < $width} {incr x} { set pixel [lindex $row $x] for {set i 0} {$i < $coef} {incr i} { lappend row2 $pixel } } for {set j 0} {$j < $coef} {incr j} { lappend data2 $row2 } } set image2 [image create photo] $image2 put $data2 return $image2 } proc orga {FichierClusters} { set FichierProtAndmRNA "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis" if {![file exists $FichierProtAndmRNA]} {return} set Liste [ListeDesJR $FichierClusters] set Entete "Name\tTwins\tClone\tOrganism\tAcc. Protein\tId. Prot\tDefinition Prot.\tAcc. mRNA\tId. mRNA\tDefinition mRNA" lappend LApercu $Entete foreach Nom $Liste { set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] if {$AccessmRNA=="" && $AccessProt==""} { set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] if {$Orga=="NoOrganism"} {continue} set AccessP [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessR [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessR Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessP Identity] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessP Definition] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessR Definition] lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Orga\t$AccessP\t$IdProt\t$DefP\t$AccessR\t$IdmRNA\t$DefR" } } return $LApercu } proc orgaEtGO {FichierClusters} { set FichierProtAndmRNA "[RepertoireDuGenome]/fiches/AccessDesProteinesEtDesmRNAsChoisis" set FichierGO "[RepertoireDuGenome]/fiches/GeneOntology" if {![file exists $FichierProtAndmRNA]} {return} if {![file exists $FichierGO]} {return} set Liste [ListeDesJR $FichierClusters] set Entete "Name\tTwins\tClone\tOrganism\tAcc. Protein\tId. Prot\tDefinition Prot.\tAcc. mRNA\tId. mRNA\tDefinition mRNA\tGO" lappend LApercu $Entete foreach Nom $Liste { set LesGO [InterrogeGeneOntology $FichierGO $Nom LesGO] if {$LesGO!={}} { foreach GO $LesGO { set LaDefinitionGO [InterrogeGeneOntology $FichierGO GO $GO LaDefinition] lappend LesDefinitionsGO $LaDefinitionGO } } set AccessmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] set AccessProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] set AccessmRNA [string toupper $AccessmRNA] set AccessProt [string toupper $AccessProt] if {$AccessmRNA=="" && $AccessProt==""} { set LesJumeaux [LesJumeauxDuPAB $Nom $FichierClusters] set CodeExonhit [ExtraitInfo $Nom "OwnerOfCDNA"] set Orga [InterrogeProtAndmRNAChoisis $Nom OrganismeChoisi] if {$Orga=="NoOrganism"} {continue} set AccessP [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] set AccessR [InterrogeProtAndmRNAChoisis $Nom mRNAChoisi Access] set IdmRNA [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessR Identity] set IdProt [InterrogeBestProteinAndmRNAForeachOrga $Nom Access $AccessP Identity] set DefP [InterrogeBestProteinAndmRNAForeachOrga Access $AccessP Definition] set DefR [InterrogeBestProteinAndmRNAForeachOrga Access $AccessR Definition] lappend LApercu "$Nom\t$LesJumeaux\t$CodeExonhit\t$Orga\t$AccessP\t$IdProt\t$DefP\t$AccessR\t$IdmRNA\t$DefR\t$LesDefinitionsGO" } } return $LApercu } proc orgmsf2 {FichierMsf} { set TFADep [CreeLeTFAsDuMSF $FichierMsf] set TFAFin [list] set FichierDescri "" if {$FichierDescri==""} { puts "CreeLesDescriptifsAvecLeMSF" CreeLesDescriptifsAvecLeMSF $FichierMsf file_${FichierMsf}.descriptif set Descri [LitFichier "${FichierMsf}.descriptif"] } else { set Descri [LitFichier $FichierDescri] } set Nom [lindex [split $FichierMsf {\.}] 0] set FichierTFAModifie ${Nom}.orgtfa set FichierMSFFinal ${Nom}.orgmsf foreach Ligne $Descri { if {$Ligne==""} continue scan $Ligne "%s %s %s" AccessAccess Genre Espece set Access [lindex [split $AccessAccess "="] 0] regsub "OS:" $Genre "" Genre if {[info exists Nb($Genre,$Espece)]} { set Nb($Genre,$Espece) [expr [set Nb($Genre,$Espece)]+1] set GnSp($Access) "[string range $Genre 0 2]_[string range $Espece 0 2][set Nb($Genre,$Espece)]_$Access" } else { set Nb($Genre,$Espece) 1 set GnSp($Access) "[string range $Genre 0 2]_[string range $Espece 0 2]_$Access" } puts [set GnSp($Access)] } foreach Ligne $TFADep { if {[regexp "^>" $Ligne ]} { scan $Ligne "%s" a regsub ">" $a "" Access if {[info exists GnSp($Access)]} { lappend TFAFin ">[set GnSp($Access)]" } else { lappend TFAFin $Ligne } } else { regsub -all {\.} $Ligne "-" Ligne lappend TFAFin $Ligne } } EcritFichier $TFAFin $FichierTFAModifie exec clustalw $FichierTFAModifie -convert -output=gcg -outfile=$FichierMSFFinal } proc orthoinspector {Liste} { set FileNonAnalyse {} set directory [RepertoireDuGenome]/prottfa if { ! [file exists "OrthoResult"]} { File mkdir OrthoResult } if { ! [file exists "tfasdescopains"]} { File mkdir tfasdescopains } foreach fichier $Liste { #Espionne $fichier set f [open $fichier r] set full_text [read $f] set seq [lindex [split $full_text " "] 1] set seqOut ortho[lindex [split $full_text " "] 1] regexp {^>(\w*) |} $full_text string seqMod testOrtho "$seq" "[RepertoireDuGenome]/OrthoResult/$seqMod" "$directory" "$fichier" modifOrthoFile2 "[RepertoireDuGenome]/OrthoResult/$seqMod.fasta" "[RepertoireDuGenome]/tfasdescopains/$seqMod" if {![file exist "[RepertoireDuGenome]/tfasdescopains/$seqMod"]} { lappend FileNonAnalyse $seqMod } close $f } if {$FileNonAnalyse!=""} { SauveLesLignes $FileNonAnalyse dans [RepertoireDuGenome]/OrthoResult/Error.txt } } proc orthoinspectorPourTous {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/prottfa} set r [glob -directory $directory *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } lappend listSeq $fichier FinPasTouche $f } orthoinspector $listSeq } proc p2rtree {} { # change labels de l'arbre. # met ID rna a la place prot. LitLeTFA 78ori_rna.tfa Lr Sr LitLeTFA 78ori_uniprot.tfa Lp Sp set tree [ContenuDuFichier 78ori_uniprot.ph] set t $tree foreach p $Lp r $Lr { set t [string map [list $p $r] $t] } set f [open 78ori_rna.ph w] puts $f $t close $f exit } proc pNW {a b LM {n 1} {With0 0}} { puts "" puts "A hori : $a" puts "B vert : $b" set la [split $a ""] set lga [llength $la] set sa [join $la [string repeat " " $n]] set lb [split $b ""] set ns [string repeat " " $n] puts " $sa" set i 0 foreach e $lb row $LM { puts -nonewline "$e" foreach x $row { if {$n < 2 && $x == 0} { puts -nonewline "$ns " } else { puts -nonewline [format " %${n}d" $x] } } puts "" } return } proc pNW_old {a b aM {n 1}} { upvar $aM M puts "" puts "A vert : $a" puts "B hori : $b" set la [split $a ""] set lb [split $b ""] set lgb [llength $lb] set sb [join $lb [string repeat " " $n]] set ns [string repeat " " $n] puts " $sb" set i 0 foreach e $la { puts -nonewline "$e " for {set j 0} {$j < $lgb} {incr j} { set x $M($i,$j) if {$n < 2 && $x == 0} { puts -nonewline "$ns " } else { puts -nonewline [format "%${n}d " $x] } } incr i puts "" } return } proc pagesMutation {gene type} { set url1 "[LbgiUrl]/~friedric/mutation.php" set Query [::http::formatQuery gene $gene database $type] set url "${url1}?$Query" set LesLignes {} set x [HttpCopy $url LesLignes] return $LesLignes } proc parseCoRearr {lignes file} { #pas finalise set l0 [lindex $lignes 0] set l0 [string range $l0 [expr [string first "left" $l0] + 5] end] set Descr [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {<} $l0] + 20] end] set Pheno [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {href} $l0] + 6] end] set Addr [string range $l0 0 [expr [string first {'} $l0] -1]] set l0 [string range $l0 [expr [string first {'} $l0] + 2] end] set Ref [string range $l0 0 [expr [string first {<} $l0] - 1]] set f [open $file a+] puts $f "\nComplex Rearrangements\n" puts $f "$Descr\t$Pheno\t$Addr\t$Ref" foreach l $lignes { set Descr "" set Pheno "" set Addr "" set Ref "" if {[regexp "^"] set LesLignes [lrange $LesLignes $tpx end] while {[lsearch -regexp $LesLignes "$id"] != -1} { set idx [lsearch -regexp $LesLignes "$id"] set ligne [lindex $LesLignes $idx] if {[string first "$id" $ligne] == 0} { set idx1 [expr [string first "/" $ligne] + 1] set idx2 [string first "-" $ligne] set idx3 [expr [string first "\t" $ligne] - 1] set debPDB [string range $ligne $idx1 [expr $idx2 - 1]] set finPDB [string range $ligne [expr $idx2 + 1] $idx3] set deb [correspPosPdbQuery $debPDB $seqPDB $seqQuery] set fin [correspPosPdbQuery $finPDB $seqPDB $seqQuery] set tmp [string first "?fold=" $ligne] if {$tmp != -1} { set ligne [string range $ligne $tmp end] set idx4 [expr [string first ">" $ligne] + 1] set idx5 [expr [string first "<" $ligne] - 1] set numFssp [string trim [string range $ligne $idx4 $idx5]] set idx6 [expr [string first "a>" $ligne] + 4] } else { set numFssp "" set idx6 [expr [string first "interact<\/a>" $ligne] + 13] } set descFssp [string trim [string range $ligne $idx6 end]] # lappend toWrite "fold@@$debPDB@@$finPDB@@$numFssp@@$descFssp" # lappend toWrite "fold@@$deb@@$fin@@$numFssp@@$descFssp" puts $file "fold:$deb@@$fin@@$numFssp@@$descFssp" } set LesLignes [lrange $LesLignes [expr $idx + 1] end] } } #EspionneL $toWrite return 1 } proc parseFicUniprot {id {f ""}} { #recupere la fiche uniprot set url "http://www.expasy.org/uniprot/$id" set x [HttpCopy $url LesLignes] set EName [recupUniprotEntryName $LesLignes] set lAccNum2 [recupUniprotListAccNum2 $LesLignes] set ProtName [recupUniprotProtname $LesLignes] set lSynProtName [recupUniprotListSynProtName $LesLignes] set GeneName [recupUniprotGeneName $LesLignes] set lSynGeneName [recupUniprotListSynGeneName $LesLignes] set Function [recupUniprotFunction $LesLignes] set lGO [recupUniprotListGO $LesLignes] set lOmimGene [recupRefGeneOmim $LesLignes] set lOmimPheno [recupRefPhenoOmim $LesLignes] puts $f "${id}@@${EName}@@${lAccNum2}@@${ProtName}@@${lSynProtName}@@${GeneName}@@${lSynGeneName}@@${Function}@@${lGO}@@${lOmimGene}@@${lOmimPheno}@@" return 1 } proc parseGrDeletion {lignes file} { #set lignes [lrange $lignes [lsearch -regexp $lignes "Number of results"] end] set l0 [lindex $lignes 0] set l0 [string range $l0 [expr [string first "left" $l0] + 5] end] set Descr [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {<} $l0] + 20] end] set Pheno [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {href} $l0] + 6] end] set Addr [string range $l0 0 [expr [string first {'} $l0] -1]] set l0 [string range $l0 [expr [string first {'} $l0] + 2] end] set Ref [string range $l0 0 [expr [string first {<} $l0] - 1]] set f [open $file a+] puts $f "\nGross Deletions\n" puts $f "$Descr\t$Pheno\t$Addr\t$Ref" foreach l $lignes { set Descr "" set Pheno "" set Addr "" set Ref "" if {[regexp "^$access" lappend Lpdb $seq puts $f >$access puts $f $seq } } else { set res [ResolutionUnPDB $access] #plus petit que 0 alors il n'y a pas de resolution -> donc RMN #plus grand que 4 pas bon Espionne "res: $res" if {$res<0 || $res<=$resolution} { set seq [QueLaSequenceDesBanques $access] if {$seq != ""} { #faire un lappend ici puis sauve dans un fichier!! lappend Lpdb ">$access" lappend Lpdb $seq puts $f >$access puts $f $seq } } } } } close $f # ici sauve les fichier pdb... SauveLesLignes $Lpdb dans [RepertoireDuGenome]/pdb/[lindex $list [llength $list]-1] } proc parsePsiblastPourTous {{Repertoire ""}} { if {$Repertoire == ""} { set Repertoire [RepertoireDuGenome]/psiblastp } set r [glob -directory $Repertoire *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } parsePsiblast $fichier FinPasTouche $f } } proc parseRegulatory {lignes} { #pas finalise set l0 [lindex $lignes 0] set l0 [string range $l0 [expr [string first "center" $l0] + 24] end] set Seq [string range $l0 0 [expr [string first {$idProt"] set idx2 [lsearch -regexp $LesLignes "<\/seq-data><\/sequence>"] set LesLignes [lrange $LesLignes $idx1 $idx2] set seq [string range [lindex $LesLignes [lsearch -regexp $LesLignes ""]] 10 end] foreach l $LesLignes { set toAdd [recupDonneesMacsims $l $seq] if {$toAdd != ""} { puts $f "macsims:$toAdd" } } return 1 } proc parseSmDeletion {lignes file} { # set lignes [lrange $lignes [lsearch -regexp $lignes "Number of results"] end] set l0 [lindex $lignes 0] set l0 [string range $l0 [expr [string first "left" $l0] + 5] end] set Del [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {<} $l0] + 21] end] set Codon [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {<} $l0] + 20] end] set Pheno [string range $l0 0 [expr [string first {<} $l0] - 1]] set l0 [string range $l0 [expr [string first {href} $l0] + 6] end] set Addr [string range $l0 0 [expr [string first {'} $l0] -1]] set l0 [string range $l0 [expr [string first {'} $l0] + 2] end] set Ref [string range $l0 0 [expr [string first {<} $l0] - 1]] set f [open $file a+] puts $f "\nSmall Deletions\n" puts $f "$Del\t$Codon\t$Pheno\t$Addr\t$Ref" foreach l $lignes { set Del "" set Codon "" set Pheno "" set Addr "" set Ref "" if {[regexp "^= 0 && ![regexp {^>} $line]} {} set hits {} set curhead "" set curblock "" set tmphead "" do { set chevron 0 if {[regexp {^>} $line]} { append tmphead $line set chevron 1 } if {[regexp {OX=[0-9]+} $line] && !$chevron} { append tmphead $line } if {[regexp {^[ ]+Length =} $line] || [regexp {^ Database:} $line]} { if {$curhead != ""} { set tmphit [hit new $curhead $curblock] if {[llength $Liste]==0 || [lsearch $Liste [$tmphit get id]]>=0} { lappend hits $tmphit } } if {[regexp {^ Database:} $line]} { break } set curhead $tmphead set tmphead "" set curblock "" } elseif {$line ne ""} { append curblock "$line\n" } } while {[gets $f line] >= 0} return $hits } proc pb2469ou2467 {Fichier2467} { #comprendre pourquoi on est passe de 2469 a 2467 foreach Ligne [LesLignesDuFichier $Fichier2467] { set Vu($Ligne) 1 } set Rep "[RepertoireDuGenome]/nucmask" foreach Fichier [glob -nocomplain -directory $Rep "DD*.mrm"] { set Nom [NomDeFichierSansExtension [file tail $Fichier]] if {![info exists Vu($Nom)]} {Espionne $Nom} } } proc pcapam {} { LesDefauts global TBlosum package require La 1.0 catch {namespace import La::*} InitTBlosum "etc/pam250.bla" set AA "ACDEFGHIKLMNPQRSTVWY" set LAA [split $AA ""] set X "2 20 20" foreach a $LAA { foreach b $LAA { append X " [set TBlosum($a,$b)]" } } nist_pca $X exit } proc pchart {} { LoadTkAndPackages package require Plotchart foreach k [lsort [::Plotchart::plotconfig vertbars]] { puts "$k :" foreach v [lsort [::Plotchart::plotconfig vertbars $k]] { puts " $v" } puts "" } exit } proc pdbhu {} { set Lid [PDBQuery -organism human -identity 75] puts "[llength $Lid]" puts "$Lid" exit } proc pdict {d {i 0} {p " "} {s " -> "}} { set errorInfo $::errorInfo set errorCode $::errorCode set fRepExist [expr {0 < [llength [info commands tcl::unsupported::representation]]}] while 1 { if { [catch {dict keys $d}] } { if {! [info exists dName] && [uplevel 1 [list info exists $d]]} { set dName $d unset d upvar 1 $dName d continue } return -code error "error: pdict - argument is not a dict" } break } if {[info exists dName]} { puts "dict $dName" } set prefix [string repeat $p $i] set max 0 foreach key [dict keys $d] { if { [string length $key] > $max } { set max [string length $key] } } dict for {key val} ${d} { puts -nonewline "${prefix}[format "%-${max}s" $key]$s" if { $fRepExist && ! [string match "value is a dict*" [tcl::unsupported::representation $val]] || ! $fRepExist && [catch {dict keys $val}] } { puts "'${val}'" } else { puts "" pdict $val [expr {$i+1}] $p $s } } set ::errorInfo $errorInfo set ::errorCode $errorCode return "" } proc pestfind {Nom} { set FichierPF "[RepertoireDuGenome]/pestfind/pest$Nom.embl" set LeTexte {} if {[file exists $FichierPF]} { lappend Letexte "" lappend LeTexte " **********************************************" lappend LeTexte " PEST motifs in your sequence:" lappend LeTexte "" set ContenuPF [ContenuDuFichier $FichierPF] if {[regexp "No PEST motif was identified" $ContenuPF]} { lappend LeTexte " No PEST motif was identified" } else { foreach Ligne [LesLignesDuFichier $FichierPF] { if {[regexp "Potential PEST motif" $Ligne]} { set n 0 set Vu 1 } if {[info exists Vu] && $n<5} { incr n lappend LeTexte " $Ligne" } } } } EspionneL $LeTexte } proc pfamito {} { LoadTkAndPackages cd /home/moumou/synmito/3Data/test set Lf [lsort [glob *_maj.xml]] foreach f $Lf { global TabSF puts "file $f" set sys [string range $f 0 [string first "_" $f]-1] puts "system $sys" DecortiqueUnXml2 $f InitSequences InitInfoSeqs AssignSeqToGroup DonneTabFeature TabSF global {*}[info globals "TD*"] set seq "${sys}mito_Homo.sapi" if {[info exists TabSF(${seq},PFAM-A)]} { set Lft [set TabSF(${seq},PFAM-A)] foreach ft $Lft { DecortiqueUneFeature $ft dg fg col sc nt puts " $dg $fg $nt" } } else { puts " => pas de ${sys}mito_Homo.sapi" } unset -nocomplain TabSF {*}[info globals "TD*"] puts "" } exit } proc pkg_mkIndex {args} { set usage {"pkg_mkIndex ?-direct? ?-lazy? ?-load pattern? ?-verbose? ?--? dir ?pattern ...?"} set argCount [llength $args] if {$argCount < 1} { return -code error "wrong # args: should be\n$usage" } set more "" set direct 1 set doVerbose 0 set loadPat "" for {set idx 0} {$idx < $argCount} {incr idx} { set flag [lindex $args $idx] switch -glob -- $flag { -- { # done with the flags incr idx break } -verbose { set doVerbose 1 } -lazy { set direct 0 append more " -lazy" } -direct { append more " -direct" } -load { incr idx set loadPat [lindex $args $idx] append more " -load $loadPat" } -* { return -code error "unknown flag $flag: should be\n$usage" } default { # done with the flags break } } } set dir [lindex $args $idx] set patternList [lrange $args [expr {$idx + 1}] end] if {![llength $patternList]} { set patternList [list "*.tcl" "*[info sharedlibextension]"] } try { set fileList [glob -directory $dir -tails -types {r f} -- {*}$patternList] } on error {msg opt} { return -options $opt $msg } foreach file $fileList { # For each file, figure out what commands and packages it provides. # To do this, create a child interpreter, load the file into the # interpreter, and get a list of the new commands and packages that # are defined. if {$file eq "pkgIndex.tcl"} { continue } set c [interp create] # Load into the child any packages currently loaded in the parent # interpreter that match the -load pattern. if {$loadPat ne ""} { if {$doVerbose} { tclLog "currently loaded packages: '[info loaded]'" tclLog "trying to load all packages matching $loadPat" } if {![llength [info loaded]]} { tclLog "warning: no packages are currently loaded, nothing" tclLog "can possibly match '$loadPat'" } } foreach pkg [info loaded] { if {![string match -nocase $loadPat [lindex $pkg 1]]} { continue } if {$doVerbose} { tclLog "package [lindex $pkg 1] matches '$loadPat'" } try { load [lindex $pkg 0] [lindex $pkg 1] $c } on error err { if {$doVerbose} { tclLog "warning: load [lindex $pkg 0] [lindex $pkg 1]\nfailed with: $err" } } on ok {} { if {$doVerbose} { tclLog "loaded [lindex $pkg 0] [lindex $pkg 1]" } } if {[lindex $pkg 1] eq "Tk"} { # Withdraw . if Tk was loaded, to avoid showing a window. $c eval [list wm withdraw .] } } $c eval { # Stub out the package command so packages can require other # packages. rename package __package_orig proc package {what args} { switch -- $what { require { return; # Ignore transitive requires } default { __package_orig $what {*}$args } } } proc tclPkgUnknown args {} package unknown tclPkgUnknown # Stub out the unknown command so package can call into each other # during their initialilzation. proc unknown {args} {} # Stub out the auto_import mechanism proc auto_import {args} {} # reserve the ::tcl namespace for support procs and temporary # variables. This might make it awkward to generate a # pkgIndex.tcl file for the ::tcl namespace. namespace eval ::tcl { variable dir ;# Current directory being processed variable file ;# Current file being processed variable direct ;# -direct flag value variable x ;# Loop variable variable debug ;# For debugging variable type ;# "load" or "source", for -direct variable namespaces ;# Existing namespaces (e.g., ::tcl) variable packages ;# Existing packages (e.g., Tcl) variable origCmds ;# Existing commands variable newCmds ;# Newly created commands variable newPkgs {} ;# Newly created packages } } $c eval [list set ::tcl::dir $dir] $c eval [list set ::tcl::file $file] $c eval [list set ::tcl::direct $direct] # Download needed procedures into the slave because we've just deleted # the unknown procedure. This doesn't handle procedures with default # arguments. foreach p {::tcl::Pkg::CompareExtension} { $c eval [list namespace eval [namespace qualifiers $p] {}] $c eval [list proc $p [info args $p] [info body $p]] } try { $c eval { set ::tcl::debug "loading or sourcing" # we need to track command defined by each package even in the # -direct case, because they are needed internally by the # "partial pkgIndex.tcl" step above. proc ::tcl::GetAllNamespaces {{root ::}} { set list $root foreach ns [namespace children $root] { lappend list {*}[::tcl::GetAllNamespaces $ns] } return $list } # init the list of existing namespaces, packages, commands foreach ::tcl::x [::tcl::GetAllNamespaces] { set ::tcl::namespaces($::tcl::x) 1 } foreach ::tcl::x [package names] { if {[package provide $::tcl::x] ne ""} { set ::tcl::packages($::tcl::x) 1 } } set ::tcl::origCmds [info commands] # Try to load the file if it has the shared library extension, # otherwise source it. It's important not to try to load # files that aren't shared libraries, because on some systems # (like SunOS) the loader will abort the whole application # when it gets an error. if {[::tcl::Pkg::CompareExtension $::tcl::file [info sharedlibextension]]} { # The "file join ." command below is necessary. Without # it, if the file name has no \'s and we're on UNIX, the # load command will invoke the LD_LIBRARY_PATH search # mechanism, which could cause the wrong file to be used. set ::tcl::debug loading load [file join $::tcl::dir $::tcl::file] set ::tcl::type load } else { set ::tcl::debug sourcing source [file join $::tcl::dir $::tcl::file] set ::tcl::type source } # As a performance optimization, if we are creating direct # load packages, don't bother figuring out the set of commands # created by the new packages. We only need that list for # setting up the autoloading used in the non-direct case. if {!$::tcl::direct} { # See what new namespaces appeared, and import commands # from them. Only exported commands go into the index. foreach ::tcl::x [::tcl::GetAllNamespaces] { if {![info exists ::tcl::namespaces($::tcl::x)]} { namespace import -force ${::tcl::x}::* } # Figure out what commands appeared foreach ::tcl::x [info commands] { set ::tcl::newCmds($::tcl::x) 1 } foreach ::tcl::x $::tcl::origCmds { unset -nocomplain ::tcl::newCmds($::tcl::x) } foreach ::tcl::x [array names ::tcl::newCmds] { # determine which namespace a command comes from set ::tcl::abs [namespace origin $::tcl::x] # special case so that global names have no # leading ::, this is required by the unknown # command set ::tcl::abs [lindex [auto_qualify $::tcl::abs ::] 0] if {$::tcl::x ne $::tcl::abs} { # Name changed during qualification set ::tcl::newCmds($::tcl::abs) 1 unset ::tcl::newCmds($::tcl::x) } } } } # Look through the packages that appeared, and if there is a # version provided, then record it foreach ::tcl::x [package names] { if {[package provide $::tcl::x] ne "" && ![info exists ::tcl::packages($::tcl::x)]} { lappend ::tcl::newPkgs [list $::tcl::x [package provide $::tcl::x]] } } } } on error msg { set what [$c eval set ::tcl::debug] if {$doVerbose} { tclLog "warning: error while $what $file: $msg" } } on ok {} { set what [$c eval set ::tcl::debug] if {$doVerbose} { tclLog "successful $what of $file" } set type [$c eval set ::tcl::type] set cmds [lsort [$c eval array names ::tcl::newCmds]] set pkgs [$c eval set ::tcl::newPkgs] if {$doVerbose} { if {!$direct} { tclLog "commands provided were $cmds" } tclLog "packages provided were $pkgs" } if {[llength $pkgs] > 1} { tclLog "warning: \"$file\" provides more than one package ($pkgs)" } foreach pkg $pkgs { # cmds is empty/not used in the direct case lappend files($pkg) [list $file $type $cmds] } if {$doVerbose} { tclLog "processed $file" } } interp delete $c } append index "# Tcl package index file, version 1.1\n" append index "# This file is generated by the \"pkg_mkIndex$more\" command\n" append index "# and sourced either when an application starts up or\n" append index "# by a \"package unknown\" script. It invokes the\n" append index "# \"package ifneeded\" command to set up package-related\n" append index "# information so that packages will be loaded automatically\n" append index "# in response to \"package require\" commands. When this\n" append index "# script is sourced, the variable \$dir must contain the\n" append index "# full path name of this file's directory.\n" foreach pkg [lsort [array names files]] { set cmd {} lassign $pkg name version lappend cmd ::tcl::Pkg::Create -name $name -version $version foreach spec [lsort -index 0 $files($pkg)] { foreach {file type procs} $spec { if {$direct} { set procs {} } lappend cmd "-$type" [list $file $procs] } } append index "\n[eval $cmd]" } set f [open [file join $dir pkgIndex.tcl] w] puts $f $index close $f } proc plantage {} { set Ll [LesLignesDuFichier plantage.dat] set m 0.0 ; set m2 0.0 set nv 0 foreach l [lrange $Ll 1 end] { lassign [split $l "\t"] tmp v set m [expr {$m + $v}] set m2 [expr {$m2 + $v*$v}] incr nv } puts "m= $m" puts "m2= $m2" puts "nv= $nv" set m [expr {$m/$nv}] puts "moy : $m" set m2 [expr {$m2/$nv}] puts "moy2 : $m2" set sd [expr {sqrt($m2 - $m*$m)}] puts "sd : $sd" exit } proc plid {} { set Lid [LesLignesDuFichier coli.ids] foreach id $Lid { lappend Lok [string range $id 0 3] } set Lok [lsort -unique $Lok] puts "Lok [llength $Lok]" set o [open coli.ids_ok w] puts $o [join $Lok \n] close $o exit } proc pmc {} { set Ll [LesLignesDuFichier /home/moumou/liste.csv] set Lkey [list gene path tissue frep pubid hohezy mutation exon protein domain ref pid] foreach l [lrange $Ll 1 end] { if {[string trim $l] eq ""} {continue} lassign [ParseLigneCSV $l] {*}$Lkey regsub -all { +} [string trim $gene] " " gene if {$gene ne ""} { puts "$gene" } if {[regexp {^pubmed} $pid] && ! [regexp {record} $pid]} { lappend Lpid [string range $pid 7 end] } } puts [join $Lpid \n] puts "\n[llength $Lpid]" set f [open list.pid w] puts $f [join $Lpid \n] close $f exit } proc polyFilter {sequence {extrCutoff 50} {minNoMaskRangeLength 100}} { # initialize return value array set retArray [list sequence $sequence range [list 0 [expr [string length $sequence] - 1]] keep -1 messages {}] # searching polyA set polyAList [polySlidingWindow $sequence "a"] # searching polyT set polyTList [polySlidingWindow $sequence "t"] if {[llength $polyAList] == 0 && [llength $polyTList] == 0} { set retArray(keep) 1 lappend retArray(messages) "No poly detected" return [array get retArray] } # detect chimera with internal polyA if {[llength $polyAList] > 0} { set length [string length $sequence] foreach poly $polyAList { set lIdx [lindex $poly 0] set rIdx [lindex $poly 1] if {($lIdx >= $extrCutoff) && ($rIdx < [expr $length - $extrCutoff])} { set retArray(keep) 0 lappend retArray(messages) "Chimera with internal polyA from [expr $lIdx + 1] to [expr $rIdx + 1]" return [array get retArray] } } } # mask 5' polyA with Ns if {$retArray(keep) != 0 && [llength $polyAList] > 0} { set length [string length $sequence] foreach poly $polyAList { set lIdx [lindex $poly 0] set rIdx [lindex $poly 1] if {$lIdx < $extrCutoff} { set mask [string repeat "N" [expr $rIdx - $lIdx + 1]] set retArray(sequence) [string replace $sequence $lIdx $rIdx $mask] set retArray(range) [list 0 [expr $length - 1]] set retArray(keep) 1 lappend retArray(messages) "Masking 5' polyA from [expr $lIdx + 1] to [expr $rIdx + 1]" } } # check if there is enough non masked consecutives bases if {![regexp -nocase "\[^n\]{${minNoMaskRangeLength},}" $retArray(sequence)]} { set retArray(keep) 0 lappend retArray(messages) "Too many masked sequence" return [array get retArray] } } # trim 5' polyT and 3' polyA extremities if {$retArray(keep) != 0} { set length [string length $retArray(sequence)] if {[llength $polyAList] > 0} { set lastPolyA [lindex $polyAList end] set rIdx [lindex $lastPolyA 1] if {$rIdx >= [expr $length - $extrCutoff] && $rIdx < [expr $length - 1]} { lset retArray(range) 1 $rIdx set trimmedSeq [string range $retArray(sequence) [expr $rIdx + 1] end] lappend retArray(messages) "Trimming sequence \"$trimmedSeq\" after 3' polyA" } } if {[llength $polyTList] > 0} { set firstPolyT [lindex $polyTList 0] set lIdx [lindex $firstPolyT 0] if {$lIdx < $extrCutoff && $lIdx > 0} { lset retArray(range) 0 $lIdx set trimmedSeq [string range $retArray(sequence) 0 [expr $lIdx - 1]] lappend retArray(messages) "Trimming sequence \"$trimmedSeq\" before 5' polyT" } } set retArray(sequence) [string range $retArray(sequence) [lindex $retArray(range) 0] [lindex $retArray(range) 1]] set retArray(keep) 1 } if {$retArray(keep) == -1} { puts "ERROR: Problem with poly filter" exit 1 } return [array get retArray] } proc polySlidingWindow {sequence {polyType a} {winSize 25} {minScore 20}} { set seqLength [string length $sequence] set winLeftIdx 0 set polyFlags [string repeat 0 $seqLength] if { $winSize > $seqLength } { return {} } while { [expr $winLeftIdx + $winSize] <= $seqLength } { set window [string range $sequence $winLeftIdx [expr $winLeftIdx + $winSize - 1]] if { [regexp -nocase -all $polyType $window] >= $minScore } { set polyFlags [string replace $polyFlags $winLeftIdx [expr $winLeftIdx + $winSize - 1] [string repeat 1 $winSize]] } incr winLeftIdx } #correction des extremite des poly set start 0 while { [regexp -indices -start $start -- {1+} $polyFlags polyIdx] } { set poly [string range $sequence [lindex $polyIdx 0] [lindex $polyIdx 1]] regexp -nocase -indices "${polyType}.*${polyType}" $poly regMatch set leftCorrect [lindex $regMatch 0] set rigthCorrect [expr [string length $poly] - [lindex $regMatch 1] - 1] set polyFlags [string replace $polyFlags [lindex $polyIdx 0] [expr [lindex $polyIdx 0] + $leftCorrect - 1] [string repeat 0 $leftCorrect]] set polyFlags [string replace $polyFlags [expr [lindex $polyIdx 1] - $rigthCorrect + 1] [lindex $polyIdx 1] [string repeat 0 $rigthCorrect]] set start [expr [lindex $polyIdx 1] + 1] } set start 0 set result {} while { [regexp -indices -start $start -- {1+} $polyFlags regMatch] } { lappend result $regMatch set start [expr [lindex $regMatch 1] + 1] } return $result } proc posttt {} { global classes_default classes CodeGenetique set classes_default {helix sheet turn coil} set classes {helix coil} InitialisationResultats InitialisationTableaux #InitialisationWobble global {*}[info globals Acide_*] {*}[info globals Wobble_*] set dcdn "cdn" sqlite3 $dcdn wobble.sql # cherche aa avec nbCodon >= 4 set Laa [list] set min 9999999 foreach acide [array names Ribo] { if {[llength $Ribo($acide)] < 4} { continue } set Lcdn [set Ribo($acide)] set cdt [list] foreach cdn $Lcdn { lappend cdt "$cdn > 0" } set cdt [join $cdt " and "] set Lpk$acide [$dcdn eval "select pk_items from codons where $cdt"] if {[set nb [llength [set Lpk$acide]]] > 0} { lappend Laa $acide } } puts "Laa [llength $Laa]" set Laa [lsort $Laa] set Lan [list] foreach aa $Laa { lappend Lan $aa [llength [set Lpk$aa]] } set Lan [lsort -stride 2 -index 1 -integer $Lan] puts "$Lan" # enleve aa avec plus faible nb de seq set Laa [list] foreach {a n} $Lan { lappend Laa $a } set Laa [lrange $Laa 2 end] # prend les commun set Ltmp [set Lpk[lindex $Laa 0]] foreach aa [lrange $Laa 2 end] { set Ltmp [land $Ltmp [set Lpk$aa]] } puts "communs [llength $Ltmp]" exit return } proc poubelle {} { if { ! [regexp {^NM_[0-9]+$} $NM]} { set NM [RetChip "DNA_acc" $I] } if { ! [regexp {^NM_[0-9]+$} $NM]} { #Espionne "la ligne $I n'a pas de NM" continue set GB [NmEnStock $NM] if {$GB!=""} { continue } Espionne "$NM n'existe pas dans refseq" } #exit set Commande "getz \"\\\[refseq-acc:$Nm\\\]\" \-vf gid" set GetzOut [eval exec $Commande] #puts $GetzOut set NmLu "" set GiLu "" scan $GetzOut "%s %s" NmLu GiLu #puts "$GiLu" } proc pourlesjr {FichierClusters} { set liste [ListeDesJR $FichierClusters] acFichierRecapitulatifPourTous $liste "ProCureBioPharm" "ExonHit" "DATAS" "" } proc preFiltrerGroupeIsoformes {hits} { } proc prepmds {} { global TBlosum LesDefauts InitTBlosum "etc/pam250.bla" set LAA [split "ACDEFGHIKLMNPQRSTVWY" ""] set f [open "pam.dat" w] puts $f "20" foreach a $LAA { set X {} foreach b $LAA { lappend X "[set TBlosum($a,$b)]" } set e [join $X "\t"] puts $f $e } close $f exec /biolo/secator/mds pam.dat pam.out 2 set Lf [LesLignesDuFichier "pam.out"] set f [open "mds.dat" w] foreach l [lrange $Lf 1 end] a $LAA { set l [string trim $l] regsub -all "\t" $l " " l regsub -all " " $l " " l puts $f "$a $l" } close $f exit } proc printString {str} { glDisable GL_DEPTH_TEST glListBase $::pgl(FontBase) set len [string length $str] set sa [tcl3dVectorFromString GLubyte $str] glCallLists $len GL_UNSIGNED_BYTE $sa $sa delete glEnable GL_DEPTH_TEST return } proc processHits {hits} { set AtmPick [list] set count 0 for {set i 0} {$i < $hits} {incr i} { # 1st rec : nbr of Nnames in this hit set NbrNames [$::selectBuffer get $count] incr count # 2nd rec : min z-depth div par # set minz [$::selectBuffer get $count] incr count # 3rd rec : max z incr count # 4th rec : noms set MOA [list] for {set j 0} {$j < $NbrNames} { incr j } { set unom [$::selectBuffer get $count] lappend MOA $unom incr count } lappend AtmPick $MOA } # return si le unom n'est pas > a 6 char if {[llength [lindex $AtmPick end]] < 3} { return } lassign [lindex $AtmPick end] mol obj atm # conversion mol as number to command set ZePicked [format "%d%02d%02d" $atm $obj $mol] lassign [Tag2MolObjAtm $ZePicked] mol obj atm set rnra [$::db eval {select r.rnbr,r.rname3l, a.aname from atoms as a , residues as r where a.pk_atoms=$atm and r.pk_residues=a.pk_residues}] puts "pick -> $mol $obj $rnra" lassign $rnra rnmr rnom natm set rnmr [string trimleft $rnmr 0] set ::pgl(TextInfo) "Mol $mol Res $rnmr $rnom $natm" $mol AddPicked $obj $atm DefineLabels2Show set ::AtomePique $ZePicked return } proc processSelectItemBy {} { return } proc profilePkgSetup {dir} { source $dir/profile.tcl tclPkgSetup $dir profile 0.1 {{profile.tcl source {}}} } proc protcomputed {} { #liste des 931 foreach Nom [ListeDesPABs] { set AccBestProtHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" Protein Access] if {$AccBestProtHuman!=""} { set DefinitionProtHuman [InterrogeBestProteinAndmRNAForeachOrga Access $AccBestProtHuman Definition] if {[regexp -nocase "HYPOTHETICAL" $DefinitionProtHuman] || [regexp -nocase "PREDICTED" $DefinitionProtHuman] || [regexp -nocase "SIMILAR TO" $DefinitionProtHuman] || [regexp -nocase "KIAA" $DefinitionProtHuman] || [regexp -nocase "DKFZp" $DefinitionProtHuman]|| [regexp -nocase "FLJ" $DefinitionProtHuman]} { #Espionne $DefinitionProtHuman lappend LpourAffy $AccBestProtHuman lappend L $Nom } } } Espionne [llength $L] #return $LpourAffy return $L } proc ps2png {FilePS FilePNG Width Height} { if {![file exists $FilePS]} {return 0} set Commande "eval exec [ProgPathway gs] -sDEVICE=png256 -sOutputFile=$FilePNG -g${Width}x${Height} -q -dNOPAUSE -dBATCH $FilePS" if {[catch {eval $Commande} Message]} {Espionne $Message;return 0} return 1 } proc pseq {} { DecortiqueUnTFA FRAT01.tfa Lnom Seq set Lnom [lrange $Lnom 0 12] set Lseq [list] set Lref [list] foreach n $Lnom { set s [string range $Seq($n) 0 200] lappend Lref $s set s [string map {- "" "." ""} $s] lappend Lseq $s } EcritLeTfa tst.tfa $Lnom $Lseq EcritLeTfa tstref.tfa $Lnom $Lref exit } proc putLog {aString {logFileName ""}} { if {$logFileName==""} { set chan [open "log" a] } else { set chan [open "$logFileName" a] } #puts $aString puts $chan $aString close $chan } proc putlog {text} { puts $text return } proc qds {Science args} { set Question [join $args " "] if {[string range $Question 0 2] ne "ret"} { set Question "ret $Question" } return [QuestionDeScience $Science $Question] } proc rangedimer {} { set Ldim [glob *_dim.pdb] set dirdim [MiSynPatDir]/data/structures foreach fd $Ldim { set sys [string range $fd 0 [string first "_" $fd]-1] if {$sys eq "gars2"} {set sys "gars"} set fin [file join $dirdim $sys $sys.pdb] set fmon [file join $dirdim $sys ${sys}_mon.pdb] if {[file exists $fmon]} { file delete $fin } if {[file exists $fin]} { file rename $fin $fmon } file copy $fd $fin } exit } proc reAss {contig} { #puts [canalSqlAssemblyDb] puts [NSAssemblyDb::getCanal] set seqFh [open $contig w] set qualFh [open $contig.qual w] set sql "SELECT sequence.name, sequence.gapped_sequence, sequence.gapped_quality_values, sequence.consed_informations, sequence.reverse FROM contig, sequence WHERE contig.name = '$contig' AND contig.pk_contig = sequence.pk_contig" set result [SqlExec $sql GetList] puts $result foreach {name seq qual consed reverse } $result { if {$reverse eq "f"} { puts $seqFh [formatFasta "$name $consed" [ungapSequence $seq]] puts $qualFh [formatQualFasta "$name $consed " [ungapQualityValues $qual]] } else { puts $seqFh [formatFasta "$name $consed" [ungapSequence [RetourneLaChaine $seq]]] puts $qualFh [formatQualFasta "$name $consed " [ungapQualityValues [RetourneLaListeIter $qual]]] } } close $seqFh close $qualFh } proc read35 {} { set lb [split "ACDEFGHIKLMNPQRSTVWY" ""] set Lf [LesLignesDuFichier "3_5.cmp"] set i 0 foreach l $Lf { if {[regexp {\.\.} $l]} {break} incr i } set aa [string trim [lindex $Lf $i]] regsub -all " " $aa "" aa regsub -all "\t" $aa "" aa regsub -all {\.} $aa "" aa set LAA [split $aa ""] set d [expr $i+1] set i 0 foreach a $LAA { set bon 0 while {! $bon} { set l [lindex $Lf $d] set l [string trim $l] regsub -all " " $l " " l puts $l if {$l != ""} { set bon 1 break } incr d } set min 999. set le [split $l " "] foreach b [lrange $LAA $i end] e [lrange $le 0 end-1] { set t($a,$b) $e set t($b,$a) $e if {$e <= $min} {set min $e} } incr i incr d } foreach e [array names t] {set t($e) [expr [set t($e)] - $min]} set dg [set t(A,A)] foreach e [array names t] {set t($e) [expr [set t($e)] - $dg]} set f [open "p35.dat" w] set pca "2 20 20" puts $f "20" foreach a $lb { set x {} foreach b $lb {lappend x [set t($a,$b)]} set p [join $x " "] puts $f $p append pca " $p" } close $f package require La 1.0 catch {namespace import La::*} nist_pca $pca exit exec /biolo/secator/mds p35.dat p35.out 2 set Lf [LesLignesDuFichier "p35.out"] set f [open "p35m.dat" w] foreach l [lrange $Lf 1 end] a $lb { set l [string trim $l] regsub -all "\t" $l " " l regsub -all " " $l " " l puts $f "$a $l" } close $f exit } proc readACEfile {fileName {computeLeftPadding 0} {showProgress 1}} { set fh [open $fileName "r"] set nextContigID 1 set currentContig "none" set ace(alignmentName) [regsub {^.*/} $fileName {}] #rR debut rajout pour tenir copte d'un fichier vide set ace(index) {} #rR fin rajout if {$showProgress} {Espionne "Reading ACE file: $fileName"} while {![eof $fh]} { gets $fh line # Read the AS line if { [regexp {^AS +([0-9]+) +([0-9]+)} $line regMatch ace(numContigs) ace(numReads)] } { if {$showProgress} {Espionne "$ace(numReads) reads in $ace(numContigs) contigs..."} } elseif { [regexp {^CO +([^ ]+) +([0-9]+) +([0-9]+) +([0-9]+) +(U|C)} $line regMatch contig(name) contig(length) contig(reads) contig(segments) contig(strand)] } { # Read a CO line # we are in a new contig, so update the current name set currentContig $contig(name) if {$showProgress} {Espionne "Reading $currentContig..."} # add contig name to index lappend ace(index) $currentContig # reset the next read id set nextReadID 1 # add a few informations set ace($currentContig,name) $contig(name) set ace($currentContig,length) $contig(length) set ace($currentContig,reads) $contig(reads) set ace($currentContig,segments) $contig(segments) set ace($currentContig,strand) $contig(strand) # read the consensus sequence set ace($currentContig,consensus) [readSequence $fh] } elseif { [regexp {^BQ} $line] } { # Read BQ block set ace($currentContig,basesQuality) [readBasesQuality $fh] } elseif { [regexp {^AF +([^ ]+) +(U|C) +(-?[0-9]+)} $line regMatch read(name) read(strand) read(consensusPosition)] } { # Read an AF line # like contig but for reads set currentRead $read(name) # add the id to index lappend ace($currentContig,index) $currentRead # store informations set ace($currentContig,$currentRead,name) $read(name) set ace($currentContig,$currentRead,strand) $read(strand) set ace($currentContig,$currentRead,consensusPosition) $read(consensusPosition) # Whe need later to know the lowest relative consensus position, following code do the job if { [info exists ace($currentContig,lowestRelativeConsensusPosition)] } { if { $read(consensusPosition) < $ace($currentContig,lowestRelativeConsensusPosition) } { set ace($currentContig,lowestRelativeConsensusPosition) $read(consensusPosition) } } else { set ace($currentContig,lowestRelativeConsensusPosition) $read(consensusPosition) } } elseif { [regexp {^RD +([^ ]+) +([0-9]+) +([0-9]+) +([0-9]+)} $line regMatch read(name) read(length) read(numWholeReads) read(numTagReads)] } { # Read an RD line set currentRead $read(name) # store results with the help of reads index set ace($currentContig,$currentRead,length) $read(length) set ace($currentContig,$currentRead,numWholeReads) $read(numWholeReads) set ace($currentContig,$currentRead,numTagReads) $read(numTagReads) # read the sequence set ace($currentContig,$currentRead,sequence) [readSequence $fh] } elseif { [regexp {^QA +(-?[0-9]+) +(-?[0-9]+) +(-?[0-9]+) +(-?[0-9]+)} $line regMatch read(qualityStart) read(qualityEnd) read(alignmentStart) read(alignmentEnd)] } { # Read a QA line # currentRead should contains the good id (see in the Read RD line bloc) set ace($currentContig,$currentRead,qualityStart) $read(qualityStart) set ace($currentContig,$currentRead,qualityEnd) $read(qualityEnd) set ace($currentContig,$currentRead,alignmentStart) $read(alignmentStart) set ace($currentContig,$currentRead,alignmentEnd) $read(alignmentEnd) } elseif { [regexp {^DS +(.*)} $line regMatch read(consedInfos)] } { # Read a DS line set ace($currentContig,$currentRead,consedInfos) $read(consedInfos) } } if {$computeLeftPadding} { array unset contig array unset read foreach contig $ace(index) { if {$showProgress} {Espionne "Compute padding for $contig"} if {$ace($contig,lowestRelativeConsensusPosition) < 1} { set ace($contig,padding) [expr abs($ace($contig,lowestRelativeConsensusPosition))+1] } else { set ace($contig,padding) 0 } set ace($contig,alignmentLength) [expr [string length $ace($contig,consensus)] + $ace($contig,padding)] foreach read $ace($contig,index) { set ace($contig,$read,padding) [expr $ace($contig,padding) - 1 + $ace($contig,$read,consensusPosition)] set alnLength [expr [string length $ace($contig,$read,sequence)] + $ace($contig,$read,padding)] if {$alnLength > $ace($contig,alignmentLength)} {set ace($contig,alignmentLength) $alnLength} } } } close $fh return [array get ace] } proc readBasesQuality {fh} { set basesQuality "" while {! [eof $fh] } { gets $fh line set line [string trim $line] if { [string length $line] != 0 } { lappend sequence $line } else { break } } return [join $sequence] } proc readCorrespIdx {} { set fichierCorresp "[RepertoireDuGenome]/fiches/corresp.idx" foreach ligne [LesLignesDuFichier $fichierCorresp] { if {[regexp {^CO\s+(\S+)\s+(\S+)\s+(\d+)$} $ligne regMatch nomContig nomGscope nbReads]} { set currentContig $nomContig set tab($nomGscope,type) CO set tab($nomGscope,contig) $nomContig set tab($nomContig,gscope) $nomGscope } elseif {[regexp {^RD\s+(\S+)\s+(\d+)$} $ligne regMatch nom posConsensus]} { lappend tab($currentContig,reads) $nom set tab($nom,type) RD set tab($nom,consensusPosition) $posConsensus } elseif {[regexp {^SI\s+(\S+)\s+(\S+)} $ligne regMatch nom nomGscope]} { set tab($nomGscope,type) SI set tab($nomGscope,read) $nom set tab($nom,gscope) $nomGscope } } return [array get tab] } proc readFasta {filename {showProgress 1}} { array set fasta {index {}} set fh [open $filename "r"] unset -nocomplain currentAccess while {![eof $fh]} { gets $fh line set line [string trim $line] if {[regexp {^>(\S+)(?:\s+(.*))?} $line regMatch access description]} { set currentAccess $access lappend fasta(index) $access set fasta($access) {} regsub -all {\s+} $line " " line set fasta($access,header) $line set fasta($access,description) [string trim $description] if {$showProgress} {Espionne "Reading ${access}..."} } if { [info exists currentAccess] && ([string length $line] != 0) } { lappend fasta($currentAccess) $line } } close $fh foreach access $fasta(index) { set fasta($access,sequence) [join [lrange $fasta($access) 1 end] ""] } return [array get fasta] } proc readPhd {filename} { set fh [open $filename "r"] set section 0 while {![eof $fh]} { gets $fh line if { [regexp -nocase {begin_sequence[[:space:]]+([^[:space:]]+)} $line regMatch sequence] } { set phd(sequence) $sequence } elseif { [regexp -nocase {begin_comment} $line] } { set section comment continue } elseif { [regexp -nocase {end_comment} $line] } { set section 0 } elseif { [regexp -nocase {begin_dna} $line] } { set section dna continue } elseif { [regexp -nocase {end_dna} $line] } { set section 0 } if { ([string length $line] != 0) && ($section != 0) } { lappend phd($section) $line } } close $fh return [array get phd] } proc readScf {filename} { set fh [open $filename "r"] fconfigure $fh -translation binary #---------------------------------------------------------------------------- # lecture en tete #---------------------------------------------------------------------------- set scf(magic) [read $fh 4] binary scan [read $fh 4] I scf(samples) binary scan [read $fh 4] I scf(samplesOffset) binary scan [read $fh 4] I scf(bases) binary scan [read $fh 4] I scf(basesLeftClip) binary scan [read $fh 4] I scf(basesRightClip) binary scan [read $fh 4] I scf(basesOffset) binary scan [read $fh 4] I scf(commentsSize) binary scan [read $fh 4] I scf(commentsOffset) set scf(version) [read $fh 4] binary scan [read $fh 4] I scf(sampleSize) binary scan [read $fh 4] I scf(codeSet) binary scan [read $fh 4] I scf(privateSize) binary scan [read $fh 4] I scf(privateOffset) binary scan [read $fh [expr 4 * 18]] I* scf(headerSpare) # convertion en entiers non signes set scf(samples) [expr {$scf(samples) & 0xFFFFFFFF}] set scf(samplesOffset) [expr {$scf(samplesOffset) & 0xFFFFFFFF}] set scf(bases) [expr {$scf(bases) & 0xFFFFFFFF}] set scf(basesLeftClip) [expr {$scf(basesLeftClip) & 0xFFFFFFFF}] set scf(basesRightClip) [expr {$scf(basesRightClip) & 0xFFFFFFFF}] set scf(basesOffset) [expr {$scf(basesOffset) & 0xFFFFFFFF}] set scf(commentsSize) [expr {$scf(commentsSize) & 0xFFFFFFFF}] set scf(commentsOffset) [expr {$scf(commentsOffset) & 0xFFFFFFFF}] set scf(sampleSize) [expr {$scf(sampleSize) & 0xFFFFFFFF}] set scf(codeSet) [expr {$scf(codeSet) & 0xFFFFFFFF}] set scf(privateSize) [expr {$scf(privateSize) & 0xFFFFFFFF}] set scf(privateOffset) [expr {$scf(privateOffset) & 0xFFFFFFFF}] for {set i 0} {$i < [llength $scf(headerSpare)]} {incr i} { set uint [lindex $scf(headerSpare) $i] set uint [expr {$uint & 0xFFFFFFFF}] lset scf(headerSpare) $i $uint } #---------------------------------------------------------------------------- # verification de version #---------------------------------------------------------------------------- if {$scf(version) > "3.10"} { puts "SCF version: $scf(version)" puts "Can only read SCF versions <= 3.10" close $fh exit 1 } #---------------------------------------------------------------------------- # lecture des donnees echantillons # !!!!! pour version >= 3.0 !!!! # il faut encore decoder les valeurs des echantillons # voir: http://staden.sourceforge.net/manual/formats_unix_4.html #---------------------------------------------------------------------------- if {$scf(version) >= "3.00" && $scf(sampleSize) == 2} { # SCF >= 3.00 16 bits samples binary scan [read $fh [expr 2 * $scf(samples)]] S* scf(samplesA) binary scan [read $fh [expr 2 * $scf(samples)]] S* scf(samplesC) binary scan [read $fh [expr 2 * $scf(samples)]] S* scf(samplesG) binary scan [read $fh [expr 2 * $scf(samples)]] S* scf(samplesT) # convertion en entiers non signes for {set i 0} {$i < $scf(samples)} {incr i} { set uint [lindex $scf(samplesA) $i] set uint [expr {$uint & 0xFFFF}] lset scf(samplesA) $i $uint set uint [lindex $scf(samplesC) $i] set uint [expr {$uint & 0xFFFF}] lset scf(samplesC) $i $uint set uint [lindex $scf(samplesG) $i] set uint [expr {$uint & 0xFFFF}] lset scf(samplesG) $i $uint set uint [lindex $scf(samplesT) $i] set uint [expr {$uint & 0xFFFF}] lset scf(samplesT) $i $uint } } elseif {$scf(version) >= "3.00"} { # SCF >= 3.00 8 bits samples binary scan [read $fh $scf(samples)] c* scf(samplesA) binary scan [read $fh $scf(samples)] c* scf(samplesC) binary scan [read $fh $scf(samples)] c* scf(samplesG) binary scan [read $fh $scf(samples)] c* scf(samplesT) # convertion en entiers non signes for {set i 0} {$i < $scf(samples)} {incr i} { set uint [lindex $scf(samplesA) $i] set uint [expr {$uint & 0xFF}] lset scf(samplesA) $i $uint set uint [lindex $scf(samplesC) $i] set uint [expr {$uint & 0xFF}] lset scf(samplesC) $i $uint set uint [lindex $scf(samplesG) $i] set uint [expr {$uint & 0xFF}] lset scf(samplesG) $i $uint set uint [lindex $scf(samplesT) $i] set uint [expr {$uint & 0xFF}] lset scf(samplesT) $i $uint } } elseif {$scf(sampleSize) == 2} { # SCF < 3.00 16 bits samples for {set i 0} {$i < $scf(samples)} {incr i} { binary scan [read $fh 8] S* smplA smplC smplG smplT # convertion en entiers non signes avant d'ajouter les valeurs set smplA [expr {$smplA & 0xFFFF}] set smplC [expr {$smplC & 0xFFFF}] set smplG [expr {$smplG & 0xFFFF}] set smplT [expr {$smplT & 0xFFFF}] # ajout des valeurs lappend scf(samplesA) $smplA lappend scf(samplesC) $smplC lappend scf(samplesG) $smplG lappend scf(samplesT) $smplT } } else { # SCF < 3.00 8 bits samples for {set i 0} {$i < $scf(samples)} {incr i} { binary scan [read $fh 4] c* smplA smplC smplG smplT # convertion en entiers non signes avant d'ajouter les valeurs set smplA [expr {$smplA & 0xFF}] set smplC [expr {$smplC & 0xFF}] set smplG [expr {$smplG & 0xFF}] set smplT [expr {$smplT & 0xFF}] # ajout des valeurs lappend scf(samplesA) $smplA lappend scf(samplesC) $smplC lappend scf(samplesG) $smplG lappend scf(samplesT) $smplT } } #---------------------------------------------------------------------------- # lecture des bases #---------------------------------------------------------------------------- if {$scf(version) >= "3.00"} { binary scan [read $fh [expr 4 * $scf(bases)]] I* scf(peakIdx) binary scan [read $fh $scf(bases)] c* scf(probA) binary scan [read $fh $scf(bases)] c* scf(probC) binary scan [read $fh $scf(bases)] c* scf(probG) binary scan [read $fh $scf(bases)] c* scf(probT) set scf(calledBases) [split [read $fh $scf(bases)] {}] # lecture des probas specifiques a version 3.10 binary scan [read $fh $scf(bases)] c* scf(probSub) binary scan [read $fh $scf(bases)] c* scf(probIns) binary scan [read $fh $scf(bases)] c* scf(probDel) # convertion en entiers non signes for {set i 0} {$i < $scf(bases)} {incr i} { set uint [lindex $scf(peakIdx) $i] set uint [expr {$uint & 0xFFFFFFFF}] lset scf(peakIdx) $i $uint set uint [lindex $scf(probA) $i] set uint [expr {$uint & 0xFF}] lset scf(probA) $i $uint set uint [lindex $scf(probC) $i] set uint [expr {$uint & 0xFF}] lset scf(probC) $i $uint set uint [lindex $scf(probG) $i] set uint [expr {$uint & 0xFF}] lset scf(probG) $i $uint set uint [lindex $scf(probT) $i] set uint [expr {$uint & 0xFF}] lset scf(probT) $i $uint set uint [lindex $scf(probSub) $i] set uint [expr {$uint & 0xFF}] lset scf(probSub) $i $uint set uint [lindex $scf(probIns) $i] set uint [expr {$uint & 0xFF}] lset scf(probIns) $i $uint set uint [lindex $scf(probDel) $i] set uint [expr {$uint & 0xFF}] lset scf(probDel) $i $uint } } else { #pour version <= 2 for {set i 0} {$i < $scf(bases)} {incr i} { binary scan [read $fh 8] Ic4 peakIdx probA probC probG probT # convertion en entiers non signes avant d'ajouter les valeurs set peakIdx [expr {$peakIdx & 0xFFFFFFFF}] set probA [expr {$probA & 0xFF}] set probC [expr {$probC & 0xFF}] set probG [expr {$probG & 0xFF}] set probT [expr {$probT & 0xFF}] # ajout des valeurs lappend scf(peakIdx) $peakIdx lappend scf(probA) $probA lappend scf(probC) $probC lappend scf(probG) $probG lappend scf(probT) $probT lappend scf(calledBases) [read $fh 1] # passe l'espace libre read $fh 3 # ajoute des 0 pour rester homogene avec la sortie de la version 3.1 lappend scf(probSub) 0 lappend scf(probIns) 0 lappend scf(probDel) 0 } } #---------------------------------------------------------------------------- # lecture des commentaires #---------------------------------------------------------------------------- set scf(comments) [read $fh $scf(commentsSize)] #---------------------------------------------------------------------------- # lecture des donnees privees #---------------------------------------------------------------------------- set scf(private) [read $fh $scf(privateSize)] close $fh return [array get scf] } proc readSequence {fh} { set sequence "" while {! [eof $fh] } { gets $fh line set line [string trim $line] if { [string length $line] != 0 } { lappend sequence $line } else { break } } return [join $sequence ""] } proc read_sock {} { global SckR # [eof $sock] == 1 || [catch {gets $sock l}] || $l == "\f" if {[eof $SckR(socket)] == 1} { puts "eof pout $SckR(socket)" fileevent $SckR(socket) readable {} close $SckR(socket) } else { while {[gets $SckR(socket) l] > 0} { append SckR(tmp) "$l\n" flush $SckR(socket) } append SckR(tmp) $l #puts "tmp : $SckR(tmp)" if {[regexp "turlututu" $SckR(tmp)]} { set tmp [set SckR(tmp)] set SckR(tmp) "" set SckR(Reponse) $tmp } } return } proc recupDonneesMacsims {ligne seq} { if {[string first "DOMAIN" $ligne] != -1} { set toAdd "domain" } elseif {[string first "PFAM-A" $ligne] != -1} { set toAdd "pfam-A" } elseif {[string first "PROSITE" $ligne] != -1} { set toAdd "prosite" } elseif {[string first "SITE" $ligne] != -1} { set toAdd "site" } elseif {[string first "SIGNAL" $ligne] != -1} { set toAdd "signal" } else { return "" } set idx1 [expr [string first "" $ligne] + 8] set idx2 [string first "<\/fstart>" $ligne] set posDeb [string range $ligne $idx1 [expr $idx2 - 1]] set idx3 [expr [string first "<\/fstop>" $ligne] - 1] set posFin [string range $ligne [expr $idx2 + 16] $idx3] set idx4 [expr [string first "" $ligne] + 7] set idx5 [expr [string first "<\/fnote>" $ligne] - 1] set desc [string range $ligne $idx4 $idx5] if {[string first "ERROR" $desc] != -1} { set toAdd "" } else { set toAdd "$toAdd@@$posDeb@@$posFin@@$desc" } return $toAdd } proc recupFold {pab file} { foreach f [glob -nocomplain /genomics/link/MS2PH-dbEuca/empreinte/${pab}_*.empreinte] { set lignes [LesLignesDuFichier $f] set pdb [string range [lindex $lignes 0] 6 end] if {[string index $pdb end] == "a"} { set pdb [string range $pdb 0 3] } else { regsub "_" $pdb "" pdb } set seqPDB [string range [lindex $lignes 2] 11 end] set seqQuery [string range [lindex $lignes 1] 8 end] set info [parseFSSP $pdb $seqPDB $seqQuery $file] } # EspionneL $info return 1 } proc recupGene {gdb} { set url1 "[LbgiUrl]/~friedric/searchHgmd.php" set Query [::http::formatQuery search "$gdb"] set url "${url1}?$Query" set LesLignes {} set x [HttpCopy $url LesLignes] set gene [parsePourGene $LesLignes] return $gene } proc recupInfoBirdF {access} { set ficIn "$access.ql" set ficOut "$access.bird" set fi [open $ficIn w] # recuperation de la fiche UP de l access # recuperation des variants de splicing dans varsplic en fasta # recuperation de la sequence UP de l access en fasta puts $fi "ID $access DB uniprot\nFD ID,OS,DE\nFM FLAT\n" close $fi set cmd "/home/friedric/bin/birdql_http.sh $ficIn > $ficOut" catch {eval exec $cmd} Message set lignes [LesLignesDuFichier $ficOut] file delete -force $ficIn file delete -force $ficOut return $lignes } proc recupPheno {} { set ficIn [file join [RepertoireDuGenome] "list" "listeEquivalence"] set lineIn [LesLignesDuFichier $ficIn] set ListeGdb "" foreach l $lineIn { lappend ListeGdb [string range [lindex $l 2] 4 end] } foreach gdb $ListeGdb { set gene [recupGene $gdb] puts $gene set fileName [lindex [lindex $lineIn [lsearch -regexp $lineIn $gdb]] 0] set file [file join [RepertoireDuGenome] "mutation" $fileName] #pour chaque type de mutation, sachant qu on zappe Splice, Regulatory, Complex rearrangements et Repeat variations foreach type {"Missense/nonsense" "Small deletions" "Small insertions" "Small indels" "Gross deletions" "Gross insertions"} { set lignes [pagesMutation $gene $type] # si on a des mutations connues if {[lsearch -regexp $lignes {Error.....no results returned}] == -1} { set lignes [lrange $lignes [lsearch -regexp $lignes "Number of results"] end] if {$type == "Missense/nonsense"} { parseMissense $lignes $file} if {$type == "Splice"} { parseSplice $lignes $file} if {$type == "Regulatory"} { parseRegulatory $lignes $file} if {$type == "Small deletions"} { parseSmDeletion $lignes $file} if {$type == "Small insertions"} { parseSmInsertion $lignes $file} if {$type == "Small indels"} { parseSmIndel $lignes $file} if {$type == "Gross deletions"} { parseGrDeletion $lignes $file} if {$type == "Gross insertions"} { parseGrInsertion $lignes $file} if {$type == "Complex rearrangements"} { parseCoRearr $lignes $file} if {$type == "Repeat variations"} { parseRepeat $lignes $file} } } } return 1 } proc recupRefGeneOmim {lignes} { set lGene "" set idx [lsearch -regexp $lignes ">MIM<"] set lignes [lrange $lignes [expr $idx + 1] end] set idxf [lsearch -regexp $lignes ""] set lignes [lrange $lignes 0 [expr $idxf - 1]] foreach l $lignes { if {[regexp "gene" $l]} { set idx1 [string first ";" $l] set toAdd [string range $l [expr $idx1 - 7] [expr $idx1 - 1]] set toAdd [string trim $toAdd ">"] set desc [recupereDescOmim $toAdd] append toAdd ".${desc}" lappend lGene $toAdd } } return $lGene } proc recupRefOmim {id type} { set url "http://www.genome.jp/dbget-bin/www_linkdbsub?dbkey=linkdb&mode=single2db&sort=to&targetdb=mim&keywords=uniprot%3A$id" set x [HttpCopy $url LesLignes] set idxA [expr [lsearch -regexp $LesLignes "-----"] + 1] set LesLignes [lrange $LesLignes $idxA end] set idxB [expr [lsearch -regexp $LesLignes ""] - 1] set LesLignes [lrange $LesLignes 0 $idxB] if { $type == "Gene" } { set list [RefGeneOmim $LesLignes] } if { $type == "Pheno" } { set list [RefPhenoOmim $LesLignes] } return $list } proc recupRefPhenoOmim {lignes} { set lPheno "" set idx [lsearch -regexp $lignes ">MIM<"] set lignes [lrange $lignes [expr $idx + 1] end] set idxf [lsearch -regexp $lignes ""] set lignes [lrange $lignes 0 [expr $idxf - 1]] foreach l $lignes { if {[regexp "phenotype" $l]} { set idx1 [string first ";" $l] set toAdd [string range $l [expr $idx1 - 7] [expr $idx1 - 1]] set toAdd [string trim $toAdd ">"] set desc [recupereDescOmim $toAdd] append toAdd ".${desc}" lappend lPheno $toAdd } } return $lPheno } proc recupUniprotEntryName {lignes} { set name "" set idx [lsearch -regexp $lignes ">Entry name<"] set ligne [lindex $lignes [expr $idx + 1]] set idx1 [expr [string first "" $ligne] + 3] set idx2 [expr [string first "" $ligne] - 1] set name [string range $ligne $idx1 $idx2] return $name } proc recupUniprotFunction {lignes} { set fct "" set idx [lsearch -regexp $lignes ">FUNCTION<"] set ligne [lindex $lignes $idx] set idx1 [expr [string first ":" $ligne] + 6] set idx2 [expr [string first "

" $ligne] - 1] set fct [string range $ligne $idx1 $idx2] return $fct } proc recupUniprotGeneName {lignes} { set name "" set idx [lsearch -regexp $lignes ">Gene name<"] set ligne [lindex $lignes [expr $idx + 2]] set idx1 [expr [string first "" $ligne] + 12] set name [string range $ligne $idx1 end] set idx2 [expr [string first "" $name] - 1] set name [string range $name 0 $idx2] return $name } proc recupUniprotListAccNum2 {lignes} { set laccNum "" set idx [lsearch -regexp $lignes ">Secondary accession number"] set ligne [lindex $lignes [expr $idx + 1]] set idx1 [expr [string first "" $ligne] + 4] set idx2 [expr [string first "" $ligne] - 1] set laccNum [string range $ligne $idx1 $idx2] set laccNum [split $laccNum " "] return $laccNum } proc recupUniprotListGO {lignes} { set idxA [expr [lsearch -regexp $lignes ">GO<"] + 1] set idxB [lsearch -regexp $lignes ">QuickGo view.<"] set Lignes [lrange $lignes $idxA $idxB] if { $Lignes == ""} { return "none" } set lGO "" foreach l $Lignes { set idx1 [string first "" $toAdd "" toAdd lappend lGO $toAdd } return $lGO } proc recupUniprotListSynGeneName {lignes} { set lSyn "" set idx [lsearch -regexp $lignes ">Gene name<"] set ligne [lindex $lignes [expr $idx + 3]] if { [regexp "Synonym" $ligne] } { set idx1 [expr [string first "" $ligne] + 9] set lSyn [string range $ligne $idx1 end] set idx2 [expr [string first "" $lSyn] - 1] set lSyn [string range $lSyn 0 $idx2] regsub -all " " $lSyn "" lSyn set lSyn [split $lSyn ","] } else { set lSyn "none" } return $lSyn } proc recupUniprotListSynProtName {lignes} { set lprotName "" set idx [lsearch -regexp $lignes ">Protein name<"] set lignes [lrange $lignes [expr $idx + 4] end] if { [lsearch -regexp $lignes ">Synonym"] == 0 } { if { [lsearch -regexp $lignes "None"] == 1 } { set lprotName "none" } else { set lignes [lrange $lignes 2 end] set idx2 [lsearch -regexp $lignes ""] set lignes [lrange $lignes 0 $idx2] set lprotName "" foreach l $lignes { if { [regexp "href" $l] } { set idxE [expr [string first "" $l] + 3] lappend lprotName [string trimleft [string range $l 0 $idxE]] } else { set idxE [expr [string first "<" $l] - 1] lappend lprotName [string trimleft [string range $l 0 $idxE]] } } } } else { set lprotName "none" } return $lprotName } proc recupUniprotProtname {lignes} { set name "" set idx [lsearch -regexp $lignes ">Protein name<"] set ligne [lindex $lignes [expr $idx + 1]] set idx1 [expr [string first "" $ligne] + 3] set idx2 [expr [string first "" $ligne] - 1] set name [string range $ligne $idx1 $idx2] return $name } proc recupereDescOmim {id} { set url "http://srs6.ebi.ac.uk/srs6bin/cgi-bin/wgetz?-e+\[omim-id:$id\]" set x [HttpCopy $url lignes] set ligne [lindex $lignes [expr [lsearch -regexp $lignes ">Title<"] + 1]] set desc [string range $ligne [expr [string first "

" $ligne] + 4] end] set desc [string trim $desc] return $desc } proc regExpMistake {regExp positions} { set mistaken "" set IUPACcomp "" #Quand on demande deux mutations au meme endroit, elles s'annulent donc, on les fusionne en une seule for {set I 0} {$I <= 9} {incr I} { regsub -all "$I $I" $positions "$I" positions } regsub {^\_} $regExp "" regExp regsub {\_$} $regExp "" regExp set tab [split $regExp "_"] set positionArray [split $positions " "] foreach position $positionArray { if {$position != ""} { set fragmentRegExp [lindex $tab $position] if {$fragmentRegExp == "A"} { set IUPACcomp {[TCG]} } elseif {$fragmentRegExp == "T"} { set IUPACcomp {[AGC]} } elseif {$fragmentRegExp == "C"} { set IUPACcomp {[AGT]} } elseif {$fragmentRegExp == "G"} { set IUPACcomp {[CTA]} } elseif {$fragmentRegExp == {[AG]} || $fragmentRegExp == {[GA]} } { set IUPACcomp {[TC]} } elseif {$fragmentRegExp == {[TC]} || $fragmentRegExp == {[CT]} } { set IUPACcomp {[AG]} } elseif {$fragmentRegExp == {[CA]} || $fragmentRegExp == {[AC]} } { set IUPACcomp {[TG]} } elseif {$fragmentRegExp == {[TG]} || $fragmentRegExp == {[GT]} } { set IUPACcomp {[AC]} } elseif {$fragmentRegExp == {[AT]} || $fragmentRegExp == {[TA]} } { set IUPACcomp {[GC]} } elseif {$fragmentRegExp == {[CG]} || $fragmentRegExp == {[GC]} } { set IUPACcomp {[AT]} } elseif {$fragmentRegExp == {[CTG]} || $fragmentRegExp == {[TGC]} || $fragmentRegExp == {[GCT]} || $fragmentRegExp == {[CGT]} || $fragmentRegExp == {[CTG]} || $fragmentRegExp == {[TCG]} } { set IUPACcomp "A" } elseif {$fragmentRegExp == {[ATG]} || $fragmentRegExp == {[TGA]} || $fragmentRegExp == {[GAT]} || $fragmentRegExp == {[GTA]} || $fragmentRegExp == {[TAG]} || $fragmentRegExp == {[AGT]} } { set IUPACcomp "C" } elseif {$fragmentRegExp == {[ATC]} || $fragmentRegExp == {[TCA]} || $fragmentRegExp == {[CAT]} || $fragmentRegExp == {[CTA]} || $fragmentRegExp == {[ACT]} || $fragmentRegExp == {[TAC]} } { set IUPACcomp "G" } elseif {$fragmentRegExp == {[ACG]} || $fragmentRegExp == {[CGA]} || $fragmentRegExp == {[GAC]} || $fragmentRegExp == {[AGC]} || $fragmentRegExp == {[GCA]} || $fragmentRegExp == {[CAG]} } { set IUPACcomp "T" } elseif {$fragmentRegExp == {[ATCG]} || $fragmentRegExp == {[ATGC]} || $fragmentRegExp == {[AGCT]} || $fragmentRegExp == {[AGTC]} || $fragmentRegExp == {[ACTG]} || $fragmentRegExp == {[ACGT]} || $fragmentRegExp == {[TAGC]} || $fragmentRegExp == {[TACG]} || $fragmentRegExp == {[TCAG]} || $fragmentRegExp == {[TCGA]} || $fragmentRegExp == {[TGCA]} || $fragmentRegExp == {[TGAC]} || $fragmentRegExp == {[GACT]} || $fragmentRegExp == {[GATC]} || $fragmentRegExp == {[GCTA]} || $fragmentRegExp == {[GCAT]} || $fragmentRegExp == {[GTCA]} || $fragmentRegExp == {[GTAC]} || $fragmentRegExp == {[CTAG]} || $fragmentRegExp == {[CTGA]} || $fragmentRegExp == {[CAGT]} || $fragmentRegExp == {[CATG]} || $fragmentRegExp == {[CGAT]} || $fragmentRegExp == {[CGTA]} } { set IUPACcomp {[ATCG]} } else { Espionne "Erreur regExpMistake : fragmentRegexp '$fragmentRegExp' inconnu dans $tab a la position $position" exit } set tab [lreplace $tab $position $position $IUPACcomp] } } set mistaken [join $tab ""] #Espionne "mis $mistaken" return $mistaken } proc regeccb {} { set pr(early,etudiants) [list 350 300 250] set pr(early,academics) [list 600 550 500] set pr(early,corporate) [list 850 800 750] set pr(late,etudiants) [list 470 420 370] set pr(late,academics) [list 720 670 620] set pr(late,corporate) [list 970 920 870] fconfigure stdout -buffering none fconfigure stdin -blocking 1 puts "" puts -nonewline "total people ......: " gets stdin total puts -nonewline "%age late .........: " gets stdin plate set pearly [expr {100-$plate}] puts -nonewline "%age students .....: " gets stdin pstu puts -nonewline "%age academics ....: " gets stdin paca puts -nonewline "%age corporate ....: " gets stdin pcor set nstu [expr {$total*$pstu/100}] set naca [expr {$total*$paca/100}] set ncor [expr {$total*$pcor/100}] set sum 0 foreach d {late early} { foreach q {stu aca cor} cl {etudiants academics corporate} { foreach fee [set pr($d,$cl)] pc {50 15 35} { set mt [expr {[set n$q]*[set p$d]/100*$pc/100*$fee}] puts "$d $q $pc $fee -> $mt" set sum [expr {$sum + $mt}] } } } puts "sum = $sum" exit } proc regtestt {exp exp2} { set test ">CELE00100 NP_492842 Caenorhabditis eleganserpentine Receptor, class T family member (srt-61) Caenorhabditis elegans" regexp -indices $exp $test res puts $res puts [string replace $test [lindex $res 0] [lindex $res 1] $exp2] } proc removeLotsOfFile {} { set Lfile [glob -nocomplain *.tfalelog] foreach file $Lfile { set pref [file rootname $file] foreach fic [glob -nocomplain ${pref}*] { puts $fic eval exec "rm $fic" } } return 1 } proc reorder1PourTous {{directory ""}} { if {$directory==""} {set directory [RepertoireDuGenome]/infos} set r [glob -directory $directory *] foreach fichier $r { #if {![regexp {_Org} $fichier]} { continue } set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } set newf $f append newf "_Order" Espionne "f: $f" Espionne "newf: $newf" Espionne "/biolo/macsim/reorder1 [RepertoireDuGenome]/macsimXml/$f [RepertoireDuGenome]/msf/$f [RepertoireDuGenome]/macsimXml/$newf" exec /biolo/macsim/reorder1 [RepertoireDuGenome]/macsimXml/$f [RepertoireDuGenome]/msf/$f [RepertoireDuGenome]/macsimXml/$f FinPasTouche $f } } proc repeatmasker {FichierTFA {OptionSpecies ""} {AvecNoLow 1}} { if { ! [file exists $FichierTFA]} {return ""} set OptionNoLow "" if {$AvecNoLow} {set OptionNoLow "-nolow"} AppendAuFichier [Fiches]/qds.log "tototitit" set Rep [RepRepeatMasker "Prog"] if {[regexp ".lib$|.ref$" $OptionSpecies]} { AppendAuFichier [Fiches]/qds.log "1 repeatmasker $FichierTFA $OptionNoLow -lib $OptionSpecies" catch {exec repeatmasker $FichierTFA $OptionNoLow -lib $OptionSpecies} Message } elseif {$OptionSpecies != ""} { set OptionSpecies "-$OptionSpecies" AppendAuFichier [Fiches]/qds.log "2 repeatmasker $FichierTFA $OptionNoLow $OptionSpecies" catch {exec repeatmasker $FichierTFA $OptionNoLow $OptionSpecies} Message } else { AppendAuFichier [Fiches]/qds.log "3 repeatmasker $FichierTFA $OptionNoLow " catch {exec repeatmasker $FichierTFA $OptionNoLow } Message } AppendAuFichier [Fiches]/qds.log "onsort1" if {[file exists "$FichierTFA.masked"]} { return "$FichierTFA.masked" } AppendAuFichier [Fiches]/qds.log "onsort2" return "" } proc res35 {} { #array set Mbl [InitClustalMatrix blosum62 0 1.] #array set Mbl [OriginalDayhoff] array set Mbl [InitClustalMatrix pam250 1 1.] set laa {A C D E F G H I K L M N P Q R S T V W Y} # make a positive matrix array unset Mbl laa array unset Mbl min array unset Mbl max set min [lindex [lsort -real -stride 2 -index 1 [array get Mbl]] 1] if {$min < 0.0} { puts "min = $min : Make positive matrix" foreach k [array names Mbl "*,*"] { set Mbl($k) [expr {$Mbl($k) - $min}] } } # A B C D # A 5 1 -2 -3 # B 4 0 1 # C 6 4 # D 5 # AA AB AC AD , CA CB CC CD # AA AB AC AD , AC BC CC CD set ia 0 foreach a1 [lrange $laa 0 end] { foreach a2 [lrange $laa 0 end] { set sum 0.0 foreach x $laa { set sum [expr {$sum + $Mbl($x,$a2)}] set sum [expr {$sum + $Mbl($a1,$x)}] } #set sum [expr {$sum - $Mbl($a1,$a1) - $Mbl($a2,$a2)}] #set sum [expr {$sum - 2. * $Mbl($a1,$a2)}] set sum [expr {$Mbl($a1,$a2)/$sum}] set T($a1,$a2) $sum #set T($a2,$a1) $sum } incr ia } #parray T #exit set nv 0 ; set sT 0.0 ; set sT2 0.0 set ia 0 foreach a [lrange $laa 0 end] { foreach b [lrange $laa $ia end] { if {1 && $a eq $b} { continue } set sT [expr {$sT + $T($a,$b)}] set sT2 [expr {$sT2 + $T($a,$b)**2}] incr nv } #incr ia } #incr nv -1 set sT [expr {$sT/2.}] set sT2 [expr {$sT2/2.}] set nv [expr {$nv/2.}] set moy [expr {$sT / $nv}] set sd [expr {sqrt($sT2/$nv - $moy*$moy)}] set min 999. ; set max -999. foreach a $laa { foreach b $laa { set T($a,$b) [expr {($T($a,$b) - $moy)/$sd}] if {$T($a,$b) < $min} { set min $T($a,$b) } if {$T($a,$b) > $max} { set max $T($a,$b) } } } puts "" #parray T #array set pam35 [InitPAM35] array set pam35 [InitPAM15] foreach aa {W G} { set s1 "$aa " ; set s2 "$aa " ; set s3 "$aa " foreach a $laa { append s1 [format "%5.2f " $Mbl($aa,$a)] append s2 [format "%5.2f " $T($aa,$a)] append s3 [format "%5.2f " $pam35($aa,$a)] } puts "origine" puts $s1 puts "modifie" puts $s2 puts "pam35" puts $s3 } puts "" diffMat pam35 T puts "" exit } proc retournerIsoformes {FichierEntree FichierSortie Log Rapport {FichierId ""}} { set data {} set Liste [lireFichierIds $FichierId] set groupes [grouperHitsParTaxid [parserFichierBlast $FichierEntree $Liste]] dict for {taxid g} $groupes { if {$taxid eq "unknown"} { set sousGroupes [list $g] set listeSS [list $g] } else { set listeSS {} set sousGroupes [grouperIsoformesScore $g estIsoformeFenetre Subj] foreach sg $sousGroupes { set sg [triHitsParNbTirets $sg Subj] lappend listeSS $sg } } dict set data $taxid $listeSS } ecrireLogIsoforme $Log $data ecrireListeIsoforme $FichierSortie $data ecrireRapportIsoforme $Rapport $data return } proc retournerIsoformesParallele {FichierEntree FichierSortie Log Rapport {FichierId ""}} { set data {} set Liste [lireFichierIds $FichierId] set groupes [grouperHitsParTaxid [parserFichierBlast $FichierEntree $Liste]] package require Thread set initscript {global GscopeDir; set GscopeDir /home/ripp/gscope; global RepertoireDuGenome ; set RepertoireDuGenome "/genomics/link/Zero"; #source /home/ripp/gscope/gscope_source.tcl source /home/kress/sandbox/gscope_isoforme.tcl #PourWscope 1 #InteractiveMode Off proc grouperIsoformesThread {taxid} { set debut [clock seconds] set g {} set hits [tsv::pop groups $taxid] foreach h $hits { lappend g [::hit new $h] } if {$taxid eq "unknown"} { set sousGroupes [list $g] set listeSS [list $g] } else { set listeSS {} set sousGroupes [grouperIsoformesScore $g estIsoformeFenetre Subj] foreach sg $sousGroupes { set sg [triHitsParNbTirets $sg Subj] lappend listeSS $sg } } set res {} foreach sg $listeSS { set tmp {} foreach h $sg { lappend tmp [$h serialize] } lappend res $tmp } #puts "End $taxid ([expr [clock seconds]-$debut]s), [llength $hits] sequences" return $res } } set nthreads [coeursDispos 1 [dict size $groupes]] set tp [tpool::create -minworkers $nthreads -initcmd $initscript] set nb 0 set total 0 dict for {taxid g} $groupes { set len [llength $g] if {$len > 1} { incr nb incr total $len } } puts "$total sequences in [dict size $groupes] groups" set idToTaxid [dict create] set jobs {} set data [dict create] dict for {taxid g} $groupes { if {[llength $g]==1} { dict set data $taxid [list [list $g]] continue } elseif {$taxid eq "unknown"} { dict set data $taxid $g continue } set hits {} foreach h $g { lappend hits [$h serialize] } tsv::set groups $taxid $hits set id [tpool::post -nowait $tp "grouperIsoformesThread $taxid"] dict set idToTaxid $id $taxid lappend jobs $id } while {[llength $jobs]>0} { foreach id [tpool::wait $tp $jobs jobs] { set serial [tpool::get $tp $id] set listeSS {} foreach sg $serial { set tmp {} foreach h $sg { lappend tmp [::hit new $h] } lappend listeSS $tmp } dict set data [dict get $idToTaxid $id] $listeSS } } ecrireLogIsoforme $Log $data ecrireListeIsoforme $FichierSortie $data ecrireRapportIsoforme $Rapport $data puts "Done" return } proc rgbToHsv {red green blue} { if {$red > $green} { set max $red.0 set min $green.0 } else { set max $green.0 set min $red.0 } if {$blue > $max} { set max $blue.0 } else { if {$blue < $min} { set min $blue.0 } } set range [expr $max-$min] if {$max == 0} { set sat 0 } else { set sat [expr {($max-$min)/$max}] } if {$sat == 0} { set hue 0 } else { set rc [expr {($max - $red)/$range}] set gc [expr {($max - $green)/$range}] set bc [expr {($max - $blue)/$range}] if {$red == $max} { set hue [expr {.166667*($bc - $gc)}] } else { if {$green == $max} { set hue [expr {.166667*(2 + $rc - $bc)}] } else { set hue [expr {.166667*(4 + $gc - $rc)}] } } if {$hue < 0.0} { set hue [expr $hue + 1.0] } } return [list $hue $sat [expr {$max/65535}]] } proc rpw {} { package require Expect if {$::tcl_platform(platform) eq "windows"} { set Rexe [file join c:/ PROGRA~1 R R-2.15.2 bin i386 Rterm.exe] } else { set Rexe "/biolo/R_surf/R-2.15.2/lib64/R/bin/R" } spawn $Rexe --vanilla expect -re "\>" { exp_send_user "on a prompt !" exp_send "# TURLUTUTU" puts "rep = $expect_out(buffer)" } eof { exp_send_user "eof !" break } return } proc rrQuelMask {Nom {Color ""}} { global RepertoireDuGenome global CouleurDuFond set Color [string equal -nocase $Color "ColorPlease"] set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom" set FichierMAS "$RepertoireDuGenome/nucmask/$Nom" set CouleurDuMask(NoSequenceToMask) "white" set CouleurDuMask(NoMaskFile) "grey" set CouleurDuMask(NoRepeatToMask) "green" set CouleurDuMask(PartiallyMasked) "orange" set CouleurDuMask(TotallyMasked) "red" if { ! [file exists $FichierMAS]} { set Annotation "NoMaskFile" if {$Color} { return [set CouleurDuMask($Annotation)] } else { return $Annotation } } set LeTFA [LesLignesDuFichier $FichierTFA] set TFA [join [lrange $LeTFA 1 end] ""] set LeMAS [LesLignesDuFichier $FichierMAS] set Entete [lindex $LeMAS 0] set Annotation "" scan $Entete "%s %s" NomLu Annotation if {[regexp "NoSequenceToMask|NoRepeatToMask|TotallyMasked|PartiallyMasked" $Annotation]} { if {$Color} { return [set CouleurDuMask($Annotation)] } else { return $Annotation } } set ToutMAS [join [lrange $LeMAS 0 end] "\n"] set MAS [join [lrange $LeMAS 1 end] ""] if {[string equal $TFA $MAS]} { set Annotation "NoRepeatToMask" } else { set LongueurInitiale [string length $TFA] if {$LongueurInitiale==0} { set Annotation NoSequenceToMask } else { set SeuilPourcentage 90 regsub -all -nocase "N" $MAS "" SeqMaskSansN regsub -all -nocase "N" $TFA "" SeqSansN set LongSeqMaskSansN [string length $SeqMaskSansN] set LongSeqSansN [string length $SeqSansN] set NbNuclMasques [expr $LongSeqSansN-$LongSeqMaskSansN] set PourcentageMasque [expr $NbNuclMasques*100/$LongueurInitiale] if {[expr $PourcentageMasque>$SeuilPourcentage]} { set Annotation "TotallyMasked" } else { set Annotation "PartiallyMasked" } } } regsub ">$Nom " $ToutMAS ">$Nom $Annotation " ToutMAS Sauve $ToutMAS dans $FichierMAS if {$Color} { return [set CouleurDuMask($Annotation)] } else { return $Annotation } } proc rrps {{orga yeast} {userid ""}} { global TInf taxid organism PourWscope 1 SetupRRPSOrga $orga # PreTraite homo.ids set Linterdit [list 1B7X] if {$userid ne ""} { set Lpdbid $userid } else { set Lpdbid [PDBQuery -organism $taxid -experiment x-ray -identity 70] puts "[join $Lpdbid \n]" } set Lok [list] puts "Nombre IDs : [llength $Lpdbid]\n" foreach pdbid $Lpdbid { if {[string trim $pdbid] eq ""} { puts "VIDE >$pdbid<\n" continue } set aTInf [rrps_traitement $pdbid] array set TInf $aTInf set ok 0 foreach k [array names TInf *,ok] { # une chaine ok -> bon pdb if {$TInf($k)} { set ok 1 break } } if {$ok} { BilanProt $pdbid } puts "PDB ok : $ok" puts "\n\n" lappend Lok $pdbid } puts "Lok [llength $Lok]" puts "[DonneDateEtHeure]" #exit } proc rrpsDir {} { return "/home/moumou/rrps" } proc rrps_InitDB {} { global dbR package require sqlite3 set tables " - items { . pk_items P . pdbid V4 . chain V1 . length I . taxid I . accession V16 . bid V16 . gbid T . rsid T . offset I . seqpdb T . seqpdbal T . seqresori T . seqres T . seqresal T . sequnpori T . sequnp T . sequnpal T . seqadn T . seqpdn T . binhe T . binsh T . bintu T . seqrsa T . seqnac T . ssi T . seqssi T } - secstr { . pk_secstr P . pk_items I . type V6 helix sheet turn . start I . stop I . length I } " set dbR [FabriqueDeTables $tables "" rrps.sql] $dbR eval {create index idx_items on items (pdbid,chain,taxid,accession,bid)} $dbR eval {create index idx_secstr on secstr(type,length)} return $dbR } proc rrps_Liste {} { set Lf [glob kmdpc/sel*_50..acc] set Lid [list] foreach f $Lf { lappend Lid {*}[LesLignesDuFichier $f] } set embl [DbFetchGET uniprotkb $Lid] set Lembl [SplitLesEMBL $embl] set o [open "ListeACC.txt" w] foreach embl $Lembl { DecortiqueLesLignesEMBL $embl ID AC DE GN OS OC OX puts $o "$AC $ID $GN $DE" } return } proc rrps_TCree {} { set GscopeDir $env(GSCOPEDIR) set OrdaliDejaSource 1 source [file join $GscopeDir gscope_source.tcl] set OrdaliDir $env(ORDALIDIR) set OrdaliDejaSource 0 source [file join $OrdaliDir src ordali_source.tcl] package require Thread package require http #LoadTclPackages package require tclcluspack #package require tclordalie package require sqlite3 #set VariablesAuDepart [info globals] InitLesDefauts LesDefauts OnlyTLog 1 LesDefauts Mode batch set ::OuiOuNonToujoursParDefaut 1 PourWscope 1 } proc rrps_TExe {pdbid} { set res [rrps_traitement $pdbid] return $res } proc rrps_TResults {pktest pdbid Lval} { global dbR if {$Lval == {} } { puts "PDB ok : 0" return [list] } array set TInf $Lval set ok 0 foreach c [set TInf($pdbid,LChains)] { if {! $TInf($pdbid,$c,ok)} { continue } set ok 1 set lgt $TInf($pdbid,$c,length) set acc $TInf($pdbid,$c,up_acc) set bid $TInf($pdbid,$c,up_bid) set gbid $TInf($pdbid,$c,gb_acc) set rsid $TInf($pdbid,$c,rs_acc) set offset $TInf($pdbid,$c,offset) set seqpdb $TInf($pdbid,$c,seqpdb) set seqpdbal $TInf($pdbid,$c,seqpdbal) set seqresori $TInf($pdbid,$c,seqresori) set seqres $TInf($pdbid,$c,seqres) set seqresal $TInf($pdbid,$c,seqresal) set sequnp $TInf($pdbid,$c,sequnp) set sequnpal $TInf($pdbid,$c,sequnpal) set sequnpori $TInf($pdbid,$c,sequnpori) set seqadn $TInf($pdbid,$c,seqadn) set seqpdn $TInf($pdbid,$c,seqpdn) set binhe $TInf($pdbid,$c,bin_he) set binsh $TInf($pdbid,$c,bin_sh) set bintu $TInf($pdbid,$c,bin_tu) set seqrsa $TInf($pdbid,$c,seqrsa) set seqnac $TInf($pdbid,$c,seqnac) set ssi $TInf($pdbid,$c,SSi) set sss $TInf($pdbid,$c,sSS) $dbR eval {insert into items values (NULL,$pdbid,$c,$lgt,$::taxid,$acc,$bid,$gbid,$rsid,$offset,$seqpdb,$seqpdbal,$seqresori,$seqres,$seqresal,$sequnpori,$sequnp,$sequnpal,$seqadn,$seqpdn,$binhe,$binsh,$bintu,$seqrsa,$seqnac,$ssi,$sss)} set pki [$dbR last_insert_rowid] # record sec. str. foreach ss $TInf($pdbid,$c,secstr) { lassign $ss type tmp tmp chn dep tmp fin tmp tmp set lgt [expr {$fin - $dep + 1}] $dbR eval {insert into secstr values (NULL,$pki,$type,$dep,$fin,$lgt)} } } if {$ok} { BilanProt $pdbid $Lval } puts "PDB ok : $ok" return [list] } proc rrps_ana_hub {{thr ""} {orga yeast}} { global traiteglobal taxid organism classes_default classes ThresholdRSA SetupRRPSOrga $orga if {$thr eq ""} { set ThresholdRSA 70. } else { set ThresholdRSA $thr } set classes_default {expose buried} set classes {expose buried} set traiteglobal 0 #rrps_analyse "hubert" #ClusteringRRPS hie sec CreeSummary #StatsCdn #OutputData #OutputListeACC #HistoLongueur return } proc rrps_ana_struc {{orga yeast}} { global traiteglobal taxid organism classes_default classes ThrHelix VariablesAuDepart nbCodon nbCodOK set ::typeAnalyse "structure" SetupRRPSOrga $orga set nbCodon 0 set nbCodOK 0 set classes_default {helix sheet turn coil} set classes {helix coil} #set classes {turn coil} set traiteglobal 0 # 1BFT : error needleman wunsch dans comparaison # seqres uniprot #set LThrHelix [list 3 4 5] set LThrHelix 5 set acides "ACDEFGHIKLMNPQRSTVWY" set emax -1.0 ; set amax "" set ::DeleteDone 0 set VariablesAuDepart [info globals] foreach ThrHelix $LThrHelix { rrps_analyse "structure" global {*}[info globals "Wobble_*"] update foreach aa [split $acides ""] { if {$aa eq "W"} {continue} # recup codons set Lcds [list] foreach k [array names Wobble_${aa}] { lassign [split $k ,] cd tmp lappend Lcds $cd } set Lcds [lsort -unique $Lcds] if {[llength $Lcds] == 1} {continue} set i 1 foreach c1 [lrange $Lcds 0 end-1] { foreach c2 [lrange $Lcds $i end] { set dc [expr {abs([set Wobble_pourcentC_${aa}($c1,coil)] - [set Wobble_pourcentC_${aa}($c2,coil)])}] puts "$c1 $c2 $dc" if {$dc > $emax} { set emax $dc set amax $aa set dmax "$c1-$c2" } } incr i } } ClusteringRRPS mm aic DetruitVariablesSaufDepart update } puts "emax $emax" puts "amax $amax" puts "dmax $dmax" puts "" puts "nbCodon $nbCodon" puts "nbCodOK $nbCodOK" return } proc rrps_analyse {typeAnalyse} { global traiteglobal taxid organism classes_default classes set db [rrps_setup] $db eval {begin transaction} InitGeneticCode InitialisationResultats InitialisationTableaux InitialisationWobble global {*}[info globals Acide_*] {*}[info globals Wobble_*] dcdn set LongueurMin 200 set Lacc [$db eval {select distinct accession from items where taxid=$taxid}] puts "Nbr accessions uniques : [llength $Lacc]" set o [open ${organism}.acc w] puts $o [join $Lacc \n] close $o set Lpk [list] foreach acc $Lacc { set Lpseq [$db eval {select pk_items,seqpdbal from items where accession=$acc}] set Lpl [list] foreach {pk seq} $Lpseq { set seq [string map {- "" X "" 0 ""} $seq] lappend Lpl $pk [string length $seq] } set Lpl [lsort -stride 2 -index 1 -integer $Lpl] if {[lindex $Lpl end] >= $LongueurMin} { lappend Lpk [lindex $Lpl end-1] } #lappend Lpk [$db eval {select pk_items from items where accession=$acc and length > 100 order by length DESC limit 1}] } puts "Longueur minimale : $LongueurMin" puts "Nbr chains >= $LongueurMin : [llength $Lpk]" # database de resultats pour clustering set dcdn "cdn" file delete wobble.sql # cree table pour tous les codons # valeurs butes pour toutes prot set table "" global {*}[info globals Wobble*] puts "\nDefinit codons :" foreach aa [lsort [array names Wobble]] { if {[llength $Wobble($aa)] < 2} { continue } puts "$aa [llength $Wobble($aa)]" append table " - ${aa}_AA : { . pk_items I " foreach scdn $Wobble($aa) { set Lsc [split $scdn " "] set cdn [lindex $Lsc 0] puts "\t$cdn | {*}[lrange $Lsc 1 end]" foreach cl [lsort $classes] { append table " . ${aa}_${cdn}_$cl R \n" } } append table " } \n" } puts "" FabriqueDeTables $table $dcdn wobble.sql # setup specific options switch $typeAnalyse { "hubert" { global SA ThresholdRSA set strRSA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwx" set req "pdbid,chain,seqpdb,sequnp,seqadn,offset,seqrsa,seqnac,seqpdbal,seqssi" set lass [list pdbid chn seqpdb sequnp seqadn offset seqrsa seqnac seqpdbal seqssi] } "structure" { global ThrHelix if {! [info exists ThrHelix]} { set ThrHelix 5 } set req "pdbid,chain,seqpdb,seqres,sequnp,seqadn,offset,binhe,binsh,bintu,ssi,seqssi,seqpdbal,seqresal,sequnpal" set lass [list pdbid chn seqpdb seqres sequnp seqadn offset binhe binsh bintu Lssi seqssi seqpdbal seqresal sequnpal] } } # boucle sur toutes les structures foreach pk $Lpk { set Lv [$db eval "select $req from items where pk_items=$pk"] lassign $Lv {*}$lass set sdegap [string map {X "" - "" 0 ""} $seqpdbal] set lgt [string length $sdegap] puts "\nPDB $pdbid $chn | $lgt" set seqpdn [SeqNucToSeqPro $seqadn] set Lseqpdbal [split $seqpdbal ""] set Lseqpdn [split $seqpdn ""] set Lseqssi [split $seqssi ""] # split seqadn en codon set Lseqadn [list] for {set i 0} {$i < [string length $seqadn]} {incr i 3} { lappend Lseqadn [string range $seqadn $i $i+2] } # longueur totale = long pdb set lgt [llength $Lseqpdbal] set Lseqadn [lrange $Lseqadn 0 $lgt-1] set Lseqpdn [lrange $Lseqpdn 0 $lgt-1] switch $typeAnalyse { "structure" { if {$seqssi eq ""} { puts "Pas de SSi !" continue } set binhe [string repeat "0" $lgt] set binsh [string repeat "0" $lgt] set bintu [string repeat "0" $lgt] set Lssi [split $seqssi ""] # type de SS dans Stride : # 310Helix AlphaHelix Disulfide GammaClassic # GammaInv PiHelix Strand TurnI TurnI' TurnII # TurnII' TurnIV TurnVIII TurnVIa TurnVIb set i 0 foreach ss $Lssi { switch $ss { "H" - "G" - "I" { set binhe [string replace $binhe $i $i 1] } "E" { set binsh [string replace $binsh $i $i 1] } "T" { set bintu [string replace $bintu $i $i 1] } } incr i } set binhe [FiltreHelix $binhe] set Lbinhe [split $binhe ""] set Lbinsh [split $binsh ""] set Lbintu [split $bintu ""] #CodonsDeProt init InitialisationTableauxPourProt set i -1 puts "lgt $lgt spdbal [llength $Lseqpdbal] sadn [llength $Lseqadn] sbhe [llength $Lbinhe] spdn [llength $Lseqpdn]" foreach a $Lseqpdbal cdn $Lseqadn ih $Lbinhe is $Lbinsh it $Lbintu t $Lseqpdn { incr ::nbCodon incr i if {$a eq "" || $cdn eq "" || $t eq ""} { puts "END [format %3d $i] pdbal $a cg $cdn pdn $t" break } puts "[format %3d $i] pdbal $a cg [set ::CodeGen($cdn)] pdn $t" # gap dans pdb if {$a eq "-" || $a eq "X" || $t eq "X"} { continue } if {$ih} { set classe helix } elseif {$is} { set classe sheet } elseif {$it} { set classe turn } else { set classe coil } # aa pdb != aa traduit if {$a ne "X" && $a ne "0" && $a ne $t} { puts "$a != >$t< ..." continue } #puts "ok $a $cdn $classe" incr ::nbCodOK incr Acide_${a}($cdn,$classe) incr ::Aprot_${a}($cdn,$classe) incr ::Nbr$aa } # sauve codons pour prot courante #CodonsDeProt sauve $pk RegroupementWobblePourProt SauveWobblePourProt $pk } "hubert" { InitialisationTableauxPourProt #if {$seqrsa eq ""} { # continue #} #set Lseqrsa [split $seqrsa ""] if {$seqnac eq ""} { continue } set Lseqrsa [split $seqnac ""] set i -1 foreach a $Lseqpdbal cdn $Lseqadn rsa $Lseqrsa t $Lseqpdn { incr ::nbCodon incr i if {$a eq "" || $cdn eq "" || $t eq ""} { puts "END [format %3d $i] pdbal $a cg $cdn pdn $t" break } #puts "[format %3d $i] pdbal $a cg [set ::CodeGen($cdn)] pdn $t" # gap dans pdb if {$a eq "-" || $a eq "X" || $t eq "X" || $rsa eq ""} { continue } # aa pdb != aa traduit if {$a ne "X" && $a ne "0" && $a ne $t} { puts "$a != >$t< ..." continue } set val [expr {2.*([string first $rsa $strRSA]+1)}] #puts ">$a< $rsa $val" if {$val >= $ThresholdRSA} { set classe expose } else { set classe buried } #puts "ok $a $cdn $classe" incr ::nbCodOK incr Acide_${a}($cdn,$classe) incr ::Aprot_${a}($cdn,$classe) incr ::Nbr$aa } # sauve codons pour prot courante #CodonsDeProt sauve $pk RegroupementWobblePourProt SauveWobblePourProt $pk } } } $db eval {commit} $db close puts "Statistic globales :" foreach a [lsort [info globals Acide_*]] { parray $a puts "" } RegroupementWobble puts "WOBBLE global :" foreach w [lsort [info globals Wobble_*]] { global $w if {! [info exists $w]} { continue } #parray $w foreach {a b} [lsort [array names $w]] { if {! [info exists ${w}($a)] || ! [info exists ${w}($b)]} { continue } puts "${w}($a) = [set ${w}($a)]" puts "${w}($b) = [set ${w}($b)]" puts " [expr {abs([set ${w}($a)]-[set ${w}($b)])}]" } puts "" } if {$typeAnalyse eq "structure"} { $dcdn close } #exit return } proc rrps_optihub {{orga yeast}} { global VariablesAuDepart set Acides "ACDEFGHIKLMNPQRSTVWY" set Lacides [split $Acides ""] set Lclasses {buried expose} set ::typeAnalyse "hubert" set ::DeleteDone 0 set VariablesAuDepart [info globals] set dmax -1. ; set aamax "" ; set thrmax 0.0 set emax -1. ; set eamax "" ; set ehrmax 0.0 set Lthr [list 30. 40. 50. 60. 70. 80.] #set Lthr [list 50.] foreach thr $Lthr { puts "\n\nTHRESHOLD : $thr" puts "---------------\n" rrps_ana_hub $thr $orga DetruitVariablesSaufDepart update } return } proc rrps_setup {{args yeast}} { global dbR SetupRRPSOrga $args set dbR "root" if {! [file exists rrps.sql]} { set dbR [rrps_InitDB] } else { sqlite3 $dbR rrps.sql } return $dbR } proc rrps_traitement {pdbid} { set pdbid [string range $pdbid 0 3] unset -nocomplain ::TInf update puts "=> $pdbid :" puts "----------" set ok [TraitePdbId $pdbid] if {! $ok} { puts "pdb traitement failed" if {[info commands $pdbid] ne ""} { $pdbid destroy update } return {} } set ok [TraiteUniProtId $pdbid] # on n'en a plus besoin if {[info commands $pdbid] ne ""} { $pdbid destroy update } if {! $ok} { puts "uniprot traitement failed" return {} } set ok [TraiteGenBankId $pdbid] if {! $ok} { puts "genbank traitement failed" return {} } # on doit re-aligner seqrsa, seqnacc, et seqstr PolishSequences return [array get ::TInf] } proc rrpsthr {args} { global dbR taxid organism PourWscope 1 set dbR [rrps_setup $args] #set Lpdbid [LesLignesDuFichier $organism.ids_ok] set Lpdbid [PDBQuery -organism $taxid -experiment x-ray] puts "Initial PDB list : [llength $Lpdbid]" set Ljobs [list] set Linterdit [list 1B7X] foreach id $Lpdbid { if {$id in $Linterdit || $id eq ""} { continue } lappend Ljobs [list $id [list $id]] } set bCree [info body ::rrps_TCree] append bCree "global organism OrgaScientific taxid\n" append bCree "set organism $::organism\n" append bCree "set OrgaScientific $::OrgaScientific\n" append bCree "set taxid $::taxid\n" proc ::rrps_TCree {} $bCree Thr_Submit -joblist $Ljobs -proccreate rrps_TCree -procexe rrps_TExe -procresults rrps_TResults $dbR close exit } proc rrpstst {} { package require sqlite3 set dbR rootR sqlite3 $dbR rrps.sql set pk 7165 set Lv [$dbR eval {select * from items where pk_items=$pk}] lassign $Lv pk pdbid chn lgt taxid acc bid gbid rsid seqpdb sequnp seqadn binhe binsh bintu puts "$pdbid $chn $lgt" puts "$acc $bid" puts "" puts "pdb [string length $seqpdb]" set seqpdn [SeqNucToSeqPro $seqadn] puts "unp [string length $sequnp]" puts "adn [string length $seqpdn]" puts "" puts "pdb [string range $seqpdb 0 50]" puts "unp [string range $sequnp 0 50]" puts "adn [string range $seqpdn 0 50]" puts "" puts "pdb [string range $seqpdb 50 end]" puts "unp [string range $sequnp 50 end]" puts "adn [string range $seqpdn 50 end]" exit } proc rspf {} { LitLeTFA bactos_rna.tfa Lr Sr puts "seq. rna. test : [string length [set Sr([lindex $Lr 0])]]" LitLeTFA bactos_prot.tfa Lp Sp puts "seq. rna. prot : [string length [set Sp([lindex $Lp 0])]]" set Ll [LesLignesDuFichier bactos.neg] set f [open bactos.feat w] foreach thr [list 0.1 0.0001 0.0000001 0.0000000001] tag [list 0,1 10e-4 10e-7 10e-10] { puts $f "FEATURE dNdS-$tag" foreach r $Lr p $Lp { foreach l $Ll { set l [string map [list "\t" " "] $l] regsub -all { +} $l " " l if {[string trim $l] eq ""} {continue} set Lv [split $l " "] set x [lindex $Lv 0] set pval [lindex $Lv end] if {$pval <= $thr} { puts $f "$p;GLOBAL;$x;$x;green;0.0;$pval" } } } } close $f exit } proc runLengthCount {intList} { set count 0 set start 0 set previousValue [lindex $intList 0] for {set i 1} {$i < [llength $intList]} {incr i} { if { [lindex $intList $i] != $previousValue } { incr count set returned($count,start) $start set returned($count,stop) [expr $i - 1] set returned($count,value) $previousValue set start $i set previousValue [lindex $intList $i] } if { $i == [expr [llength $intList] - 1] } { incr count set returned($count,start) $start set returned($count,stop) $i set returned($count,value) $previousValue } } set returned(count) $count return [array get returned] } proc sE {} { global TabSF SM_KillFeat array unset TabSF "PDB_2dxi_A,Discri" global db set del "1 20920 371 371 R/K 0 20921 372 372 R/K 1 20922 377 377 S 0 20923 378 378 S 1 20924 392 392 F/Y 0 20925 393 393 F/Y 1 20926 420 420 D 0 20927 421 421 D 1 20928 444 444 W 0 20929 446 446 W 1 20930 452 452 E 1 20931 453 472 indel_yes 0 20932 454 473 indel_yes 1 20933 472 472 ~G 1 20934 473 473 P 0 20935 474 474 P 1 20936 476 476 Q 0 20937 477 477 Q 1 20938 483 483 Y 0 20939 484 484 Y 1 20940 499 499 C_(~C) 1 20941 500 500 Y/F 0 20942 501 501 Y/F 1 20943 517 663 indel_type1 0 20944 527 665 indel_type1 1 20945 675 675 D 0 20946 676 676 D 1 20947 687 687 G/A 0 20948 688 688 G/A 1 20949 733 737 KLSKR 0 20950 734 738 KLSKR" set del "0 11111 445 445 W" foreach e [split $del \n] { set e [string trim $e] if {$e eq ""} {continue} lassign [split $e " "] i pk d f n if {$i} { lappend Lgrd $pk } else { lappend Ldel [list $d $f $n] } } set g [set ::GroupeDeLaSequence(PDB_2dxi_A)] puts "PDB_2dxi_A $g" foreach nm [set ::SDG($g)] { set Lpk [list] set pkf [lindex [$db eval {select pk_seqinfo from seqinfo where access=$nm}] end] puts "nm= $nm $pkf" foreach e $Ldel { lassign $e d f n if {! [regexp {^PDB\_} $nm]} { incr d -1 incr f -1 set res [$db eval {select fi.pk_featali from featali as fi, seqali as si, ln_seqali_featali as ln where si.pk_seqinfo=$pkf and ln.pk_seqali=si.pk_seqali and fi.pk_featali=ln.pk_featali and fi.ftype='Discri' and fi.fstart=$d and fi.fstop=$f and fi.fnote=$n}] if {$res != {}} { lappend Lpk $res } } else { puts "EST UN PDB" set res [$db eval {select fi.pk_featali from featali as fi, seqali as si, ln_seqali_featali as ln where si.pk_seqinfo=$pkf and ln.pk_seqali=si.pk_seqali and fi.pk_featali=ln.pk_featali and fi.ftype='Discri' and fi.fnote=$n}] puts "res= $res" lappend Lpk {*}$res } } set Lpk [lsort -unique $Lpk] if {$Lpk == {} } {continue} puts "Lpk= $Lpk" $db eval "delete from featali where pk_featali in ([join $Lpk ,])" $db eval "delete from ln_seqali_featali where pk_featali in ([join $Lpk ,])" } exit return } proc scoreNormAgents {s1 s2} { global Rosace Wg InitialiseRosace set score 0.0 set i 0 set lg [string length $s1] foreach c1 [split $s1 ""] c2 [split $s2 ""] { lassign [set Rosace($c1)] x1 y1 lassign [set Rosace($c2)] x2 y2 set xVp [expr {$x1 + $x2}] set yVp [expr {$y1 + $y2}] set sn [expr {[set Rosace(Norm$c1)] + [set Rosace(Norm$c2)]}] # norme vecteur resultant set nVp [expr {sqrt($xVp**2 + $yVp**2)}] set norm [expr {$nVp/$sn}] set score [expr {$score + $Wg($lg,$i) * $norm}] incr i } set score [expr {$score / $Wg($lg)}] return $score } proc scrollTxt {t args} { $Vrp(WText) xview {*}$args return } proc send_simple_message {recipient email_server subject body {originator ""}} { package require smtp package require mime set token [mime::initialize -canonical "text/plain" -string $body] mime::setheader $token Subject $subject set Lopt [list -recipients $recipient -servers $email_server] if {$originator ne ""} { lappend Lopt -originator $originator } smtp::sendmessage $token {*}$Lopt mime::finalize $token return } proc seqPos2AlnPos {seq pos} { set len [string length $seq] set seqPos 0 for {set i 0} {$i < $len} {incr i} { if {[regexp -nocase {[^.-]} [string index $seq $i]]} { incr seqPos } if {$seqPos == $pos} { return [expr $i + 1] } } return "" } proc sequenceToAlignmentIndex {alignedSequence} { array set index {} for {set i 0; set counter 0; set length [string length $alignedSequence]} {$i < $length} {incr i} { if {[regexp -nocase {[a-z]} [string index $alignedSequence $i]]} { incr counter set index($counter) [expr $i + 1] } } return [array get index] } proc setLCD {} { # The shapes of individual elements of a digit global lcdshape global lcdelems array set lcdshape { a {3.0 5 5.2 3 7.0 5 6.0 15 3.8 17 2.0 15} b {6.3 2 8.5 0 18.5 0 20.3 2 18.1 4 8.1 4} c {19.0 5 21.2 3 23.0 5 22.0 15 19.8 17 18.0 15} d {17.4 21 19.6 19 21.4 21 20.4 31 18.2 33 16.4 31} e {3.1 34 5.3 32 15.3 32 17.1 34 14.9 36 4.9 36} f {1.4 21 3.6 19 5.4 21 4.4 31 2.2 33 0.4 31} g {4.7 18 6.9 16 16.9 16 18.7 18 16.5 20 6.5 20} } # Which elements are turned on/off for a given digit? foreach {digit onElems offElems} { 0 {a b c d e f} {g} 1 {c d} {a b e f g} 2 {b c e f g} {a d} 3 {b c d e g} {a f} 4 {a c d g} {b e f} 5 {a b d e g} {c f} 6 {a b d e f g} {c} 7 {b c d} {a e f g} 8 {a b c d e f g} {} 9 {a b c d e g} {f} - {g} {a b c d e f} { } {} {a b c d e f g} } { set lcdelems(on-$digit) $onElems set lcdelems(off-$digit) $offElems } } proc setTooltip {widget text} { if { $text != "" } { # 2) Adjusted timings and added key and button bindings. These seem to # make artifacts tolerably rare. bind $widget [list after 500 [list showTooltip %W $text]] bind $widget [list after 500 [list destroy %W.tooltip]] bind $widget [list after 500 [list destroy %W.tooltip]] bind $widget [list after 500 [list destroy %W.tooltip]] } } proc set_balloon {target message} { global Bulle if {! [info exists Bulle]} {BindBulle} set Bulle($target) $message bindtags $target "[bindtags $target] Bulle" } proc showLCD {w num {width 5} {colours "#ff0000 #ff0000 #000000 #000000"}} { global lcdshape global lcdelems set lcdoffset 0 $w delete lcd lassign $colours onRim onFill offRim offFill lassign [split $num "-"] H M S foreach e {H M S} { foreach glyph [split [set $e] {}] { foreach symbol $lcdelems(on-$glyph) { $w move [eval $w create polygon $lcdshape($symbol) -tags lcd -outline $onRim -fill $onFill] $lcdoffset 0 } incr lcdoffset 22 } if {$e eq "S"} {continue} $w create oval [list [expr {$lcdoffset+ 5}] 23 [expr {$lcdoffset+11}] 29] -fill red $w create oval [list [expr {$lcdoffset+ 8}] 8 [expr {$lcdoffset+14}] 14] -fill red incr lcdoffset 22 } } proc showStatus {frm index} { global tk_library set tags [$frm tag names $index] set i [lsearch -glob $tags help-*] set cursor [$frm cget -cursor] if {$i < 0} { .help.statusBar.lab config -text " " set newcursor xterm } else { set demo [string range [lindex $tags $i] 5 end] .help.statusBar.lab config -text "load the \"$demo\" help page" set newcursor hand2 } if [string compare $cursor $newcursor] { $frm config -cursor $newcursor } } proc showTooltip {widget text} { global tcl_platform if { [string match $widget* [winfo containing [winfo pointerx .] [winfo pointery .]] ] == 0 } { return } catch { destroy $widget.tooltip } set scrh [winfo screenheight $widget] ; # 1) flashing window fix set scrw [winfo screenwidth $widget] ; # 1) flashing window fix set tooltip [toplevel $widget.tooltip -bd 1 -bg black] wm geometry $tooltip +$scrh+$scrw ; # 1) flashing window fix wm overrideredirect $tooltip 1 if {$tcl_platform(platform) == {windows}} { # 3) wm attributes... wm attributes $tooltip -topmost 1 # 3) assumes... } # 3) Windows pack [label $tooltip.label -bg lightyellow -fg black -text $text -justify left] set width [winfo reqwidth $tooltip.label] set height [winfo reqheight $tooltip.label] set positionX [winfo pointerx .] set positionY [expr [winfo pointery .] + 25] # a.) Ad-hockery: Set positionX so the entire tooltip widget will be displayed. if {[expr $positionX + $width] > [winfo screenwidth .]} { set positionX [expr ($positionX - (($positionX + $width) - [winfo screenwidth .]))] } wm geometry $tooltip [join "$width x $height + $positionX + $positionY" {}] raise $tooltip # 2) Kludge: defeat rare artifact by passing mouse over a tooltip to destroy it. bind $widget.tooltip {destroy %W} bind $widget.tooltip {destroy %W} } proc singleProc {} { foreach p [info procs] { if {$p in $::ProcsAuDepart} {continue} set res [exec moueo $p | wc] set res [lindex [split [string trim $res] " "] 0] if {$res == 1} { lappend Ls $p } } puts "\n[llength $Ls]\n[join [lsort $Ls] \n]" exit } proc spi {} { set a [string repeat "A" 5000] set la [split $a ""] puts "[time {string index $a 3021} 10000]" puts "[time {lindex $la 3021} 10000]" exit } proc splitEmblOlida {getzOut} { set entries {} set entry "" foreach line [split $getzOut "\n"] { set line [string trimright $line] if {[string length $line] != 0} { append entry "$line\n" if {[regexp {^//} $line] && [string length $entry] != 0} { lappend entries [string trimright $entry] set entry "" } } } if {[string length $entry] != 0} {lappend entries [string trimright $entry]} return $entries } proc splitFastaOlida {getzOut} { set entries {} set entry "" foreach line [split $getzOut "\n"] { set line [string trimright $line] if {[string length $line] != 0} { if {[regexp {^>} $line] && [string length $entry] != 0} { lappend entries [string trimright $entry] set entry "" } append entry "$line\n" } } if {[string length $entry] != 0} {lappend entries [string trimright $entry]} return $entries } proc stambl {} { array set Mbl [InitClustalMatrix blosum62] set Laa [list A C D E F G H I K L M N P Q R S T V W Y] set nel [llength [array names Mbl "*,*"]] set sum 0.0 set i 0 set nel 0 foreach a1 [lrange $Laa 0 end] { foreach a2 [lrange $Laa $i end] { set sum [expr {$sum + $Mbl($a1,$a2)}] incr nel } incr i } set sum [expr {$sum/$nel}] puts "nel $nel" puts "sum $sum" foreach a $Laa { set sum 0. foreach b $Laa { if {$a eq $b} {continue} set sum [expr {$sum + $Mbl($a,$b)}] } puts "$a $Mbl($a,$a) $sum" } exit } proc stl {} { set Ll [LesLignesDuFichier "scene(1).stl"] set nv 0 set sx 0.0 ; set sy 0.0 ; set sz 0.0 foreach l $Ll { if {[string first "vertex" [string trim $l]] == 0} { lassign $l tmp x y z set sx [expr {$sx + $x}] set sy [expr {$sy + $y}] set sz [expr {$sz + $z}] incr nv } } set sx [expr {$sx/$nv}] set sy [expr {$sy/$nv}] set sz [expr {$sz/$nv}] puts "$sx\n$sy\n$sz" exit } proc sunday {} { foreach f [lsort [glob *.ord]] { sqlite db $f db eval {begin transaction} if {0} { set Lft [list] foreach pkm [db eval {select pk_mac from mac}] { set Ls [db eval {select pk_seqali from ln_mac_seqali where pk_mac=$pkm}] set Lf [db eval "select pk_featali from ln_seqali_featali where pk_seqali in ([join $Ls ,])"] set Lft [concat $Lft $Lf] } set Li [db eval {select pk_featali from featali}] set dif1 [lor $Li $Lft from1] puts "$f" puts "[llength $dif1]" puts "" db eval "delete from featali where pk_featali in ([join $dif1 ,])" } # feature Cons set Lc [db eval {select pk_featali from featali where ftype like '%Cons-%'}] if {$Lc != {} } { puts "$f\ndelete [llength $Lc] features\n" db eval "delete from ln_seqali_featali where pk_featali in ([join $Lc ,])" db eval "delete from featali where pk_featali in ([join $Lc ,])" } # colmeasure set Ltbl [db eval "select tbl_name from sqlite_master where (type = \"table\")"] foreach t [list colmeasure colscore ln_mac_colmeasure ln_seqali_colscore ln_cluster_colscore] { if {$t in $Ltbl} { db eval "delete from $t" } } db eval {commit} db eval {vacuum} db close } exit } proc superpose {} { set l1 [LesLignesDuFichier h1c.pdb] set l2 [LesLignesDuFichier h2c.pdb] set i 1 foreach e1 $l1 { if {[string range $e1 0 2] eq "END"} {continue} set W($i) 1. set x1 [string trim [string range $e1 30 37]] set x2 [string trim [string range $e1 38 45]] set x3 [string trim [string range $e1 46 53]] foreach j {1 2 3} { set XX($j,$i,1) [set x$j] } incr i } # 2eme fichier set i 1 foreach e1 $l2 { if {[string range $e1 0 2] eq "END"} {continue} set W($i) 1. set x1 [string trim [string range $e1 30 37]] set x2 [string trim [string range $e1 38 45]] set x3 [string trim [string range $e1 46 53]] foreach j {1 2 3} { set XX($j,$i,2) [set x$j] } incr i } COMPARORTHO XX W R T exit return } proc svgcanvas {w args} { source uriencode.tcl source tinyfileutils.tcl source can2svg.tcl eval canvas $w $args ;# create the "base" thing rename $w _$w ;# keep the original widget command # Here comes the overloaded widget proc: proc $w {cmd args} { set self [lindex [info level 0] 0] ;# get name I was called with puts "self $self" puts "cmd $cmd" puts "infl 0 [info level 0]" puts "infl 1 [info level 1]" #set rep [uplevel 1 set ::repSVG [_$self $cmd $args]] set status1 [catch { uplevel 1 _$self $cmd $args } ::repSVG] puts "rep $::repSVG" puts "" set Dont [list delete itemcget itemconfig configure cget bbox find gettags addtag bind raise lower type itemconfigure coords] if {$cmd ni $Dont} { can2svg::can2svg $cmd {*}$args } return $::repSVG } return $w ;# like the original "text" command } proc t11 {} { foreach len {5 7 9 11 13 15 17 19} { set log [exec ordali exe AnalyseFichierBalibase BB11001.xml $len] set log [split $log \n] set lr [lsearch -all -inline -glob $log "rank all*"] set min 999. foreach l $lr { regsub -all { +} $l " " l lassign [split $l " "] tmp tmp rk if {$rk < $min} { set lmin $l set min $rk } } puts "$lmin" } exit } proc tClassementGlobal {} { set LesPremiersGOs [TousLesPremiersGOsDesClassements 1] set LesMeilleurs {} set LesResultats {} foreach Premier $LesPremiersGOs { Espionne $Premier scan $Premier "%s %f" go n lappend LesMeilleurs $go if {[info exists DejaVu($go)]} {set N($go) [expr $n + $N($go)]} set DejaVu($go) 1 set N($go) $n regsub "$go" $Premier "" Premier regsub "$n" $Premier "" Premier set D($go) $Premier } foreach GO $LesMeilleurs { Espionne $GO Espionne $N($GO) lappend LesResultats "$GO $N($GO) $D($GO)" } set LeClassementFinal [lsort -decreasing -index 1 $LesResultats] return $LeClassementFinal } proc tDis {} { set p "YMMAAAAAYAAKCAQRQ" puts "$p" lassign [DispersionDeColonne $p] v a e puts "v $v" puts "vn [V_nV $v]" puts "a $a" puts "e $e" puts "[join \n]" set v2 [list 0.207 -0.978] puts [ColonneOverlap $v $v2 1.03 0.0 1.06 0.0] exit } proc tNW {} { #set S "ACTAGCTGATCGATCGAT" set S "ACGCTAGCTGATCGATCGAT" #set T "CTAGCTATATAGAT" set T "CGCTAGCTATATAGATGCGC" lassign [NW $S $T] al bl puts "$al" puts "$bl" exit #set S "ESIRMVLIGPPGAGKGTQAPNLQERFHAAHLATGDMLRSQIAKGTQLGLEAKKIMDQGGLVSDDIM" #set T "SSESIRMVLIGPPGAGKGTQAPNLQERFHAAHLATGDMLRSQIAKGTQLGLEAKKIMDQGGLVSDDIM" puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time lassign $al s1 s2 puts "$s1" puts "$s2" #exit set S [string repeat $S 2] set T [string repeat $T 2] puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time set S [string repeat $S 2] set T [string repeat $T 2] puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time set S [string repeat $S 2] set T [string repeat $T 2] puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time set S [string repeat $S 2] set T [string repeat $T 2] puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time set S [string repeat $S 2] set T [string repeat $T 2] puts "\nS= [string length $S] T= [string length $T]" set time [time {set al [NW $S $T]}] puts $time exit } proc tRI {} { set xml [PDBeInterface 1OCP] puts "$xml" puts "[ResiduesInterface $xml 1OCP A]" exit } proc tRp {} { #package require Tk package require Expect set txt [list 1.1 2.2 3.4] puts "Rpipe [Rpipe "print('[join $txt ,]')"]" puts "Rpipe [Rpipe "toto <- c([join $txt ,])"]" puts "Rpipe [Rpipe "(min(toto))"]" #exit set ListeVal [list 1.0 2.0 3.0 4.0 1.1 2.1 3.1 4.1 1.2 2.2 3.2 4.2 1.3 2.3 3.3 4.3] set NbRow 3 set NbGagne 1 set NbPerdu 1 set NbNul 1 set size 2 set decay 0.0075 Rpipe "All <- c([join $ListeVal ,])" Rpipe "All <- matrix(All,nrow=$NbRow)" Rpipe "fac <- rep( factor( c('gagne', 'perdu','nul')), c($NbGagne,$NbPerdu,$NbNul))" Rpipe "library(nnet)" ## index des etiquettes Rpipe "T <- class.ind(fac)" ### size = taille couche cachee, decay= vitesse d'apprentissage, maxit = nbre iteration puts [Rpipe "model <- nnet(All,T,size=$size,decay=$decay,softmax=TRUE,maxit=500)"] exit } proc taa {} { LoadTkAndPackages AskAddSeqs return } proc talc {} { foreach v {1.0 2.0 3.0} { set i 0 foreach k {toto titi tata} { if {[regexp {i} $k]} { set res $k break } incr i } puts "$res $i" } exit } proc tanac {} { set Ll [LesLignesDuFichier prokaryotes.txt] foreach l $Ll { set Lv [split $l \t] lappend Lr [lindex $Lv end-2] } puts "[join [DenombreLaListe $Lr] \n]" exit } proc tangle {a b op} { puts "[info level -1]" puts " ang $::TFB(F5,angle)" return } proc tarno {} { package require Thread set pool [tpool::create -idletime 30 -minworkers 1 -maxworkers 8] set program {puts begin after 5000 puts ok } set joblist {} # calculé un par un lappend joblist [tpool::post -nowait $pool $program] lappend joblist [tpool::post -nowait $pool $program] lappend joblist [tpool::post -nowait $pool $program] # calculé en parallèle lappend joblist [tpool::post $pool $program] lappend joblist [tpool::post $pool $program] lappend joblist [tpool::post $pool $program] while {[llength $joblist] > 0} { puts $joblist tpool::wait $pool $joblist joblist } exit } proc tars {} { set Laa [list a c d e f g h i k l m n p q r s t v w y] foreach aa $Laa { lappend Lid "sy${aa}m_human" } set Lrep [IDMapping "ACC+ID" ACC $Lid] LesDefauts DonwloadPDB dont foreach aa $Laa id $Lid acc $Lrep { set aa [string toupper $aa] if {$aa eq "F"} {set af "Fb"} {set af $aa} set f [MiSynPatDir]/data/alignments/${af}_WithModules.xml if {! [file exists $f]} {continue} DecortiqueUnXml2 $f InitSequences InitInfoSeqs AssignSeqToGroup global LNOrdali {*}[info globals "TD*"] set sqn "${aa}mito_Homo.sapi" if {$sqn ni $LNOrdali} { set ali "NONE" set equi "NONE" } else { set ali [set TDesAccess($sqn)] if {! [EstUnUniProt $ali]} { set gi [Convert2GI protein $ali] set equi [IDMapping P_GI ACC $gi] } else { set equi $ali } } puts "$aa | $id | $acc |>> $ali <-->$equi" } exit } proc tartine {} { array set T [InfosFromRefSeq XP_001332388.5] parray T array set R [InfosFromUniProt P21889] parray R foreach k [array names T] { lassign [split $k ,] tmp c lappend LT $c } foreach k [array names R] { lassign [split $k ,] tmp c lappend LR $c } set LT [lsort $LT] set LR [lsort $LR] puts "$LR" puts "$LT" exit } proc tatito {} { LitLeTFA court4.tfa ::LNOrdali ::Sequences foreach n $::LNOrdali { lappend ::LSOrdali $::Sequences($n) } AgentsRemoveColsGaps foreach n $::LNOrdali s $::LSOrdali { if {[string trim $n] eq ""} {continue} lappend Lnom $n lappend Lseq $s } EcritLeTfa tatito $Lnom $Lseq exit } proc tatom2 {} { set o [open "|lsqman " w] #fconfigure $o -buffering line #fileevent $o readable [list LogSup $o] set ref 4phc set phy hars2 set cmd "re m1 $ref.pdb re m2 $phy.pdb br m1 A m2 A 50 25 100 im m1 A1-999 m2 A1-999 ap m1 m2 wr m2 ${phy}_rt.pdb re m3 $atm br m1 A m3 A 50 25 100 im m1 A1-999 m3 A1-999 ap m1 m3 wr m3 ${atm}_rt.pdb qu " puts $o $cmd flush $o catch {close $o} exit } proc tauxi {} { #m = [(K*t)/12] / [1-(1+(t/12))^-n foreach an {10 15 20} { puts "\n" puts "$an ans" set n [expr {$an*12}] foreach K {100000. 110000. 120000. 130000.} { puts -nonewline "$K " foreach t {0.028 0.03 0.032 0.035} { set m [expr { (($K*$t)/12) / (1-pow(1+($t/12),-$n))}] puts -nonewline [format %8.2f $m] } puts "" } puts "" } exit } proc tax {} { global TDesTaxId LNOrdali ListePDB set o [open tax w] foreach n $LNOrdali { if {$n in $ListePDB || $n eq ""} {continue} lappend tax $TDesTaxId($n) } set tax [lsort -unique $tax] puts $o [join $tax \n] close $o exit } proc taxma {} { global LNOrdali TDesTaxId ListePDB cd /home/moumou/synmito/3Data/test set Ltax [list] lappend ::VariablesAuDepart Ltax set Lf [glob *_maj.xml] foreach f $Lf { puts "[file rootname [file tail $f]]" LesDefauts LesDefauts Mode batch DecortiqueUnXml2 $f InitSequences foreach n $LNOrdali { if {$n eq "" || $n in $ListePDB} { continue } lappend Ltax $TDesTaxId($n) } FermeFichier } set Ltax [lsort -unique $Ltax] puts "Ltax [llength $Ltax]" cd /home/moumou/SoTOL set o [open tax.txt w] puts $o [join $Ltax \n] close $o exit } proc tb11 {} { package require sqlite3 set db [sqlite3 "" res.sql] $db eval {begin transaction} set res [$db eval {select s.* from segment as s, file as f, ln_file_block as lfb, ln_block_segment as lbs where f.nom = 'BB11008.xml' and f.pk_file=lfb.pk_file and lfb.pk_block = lbs.pk_block and lbs.pk_segment = s.pk_segment}] set res [lsort -stride 5 -index 2 -decreasing $res] puts [join $res \n] exit } proc tb_project_to_sphere {x y} { # !! r= 1.0 set d [expr {sqrt($x*$x + $y*$y)}] #inside sphere if {$d < 0.70710678118654752440} { set z [expr {sqrt(1. - $d*$d)}] } else { set t [expr {1.0 / 1.41421356237309504880}] set z [expr {$t*$t / $d}] } return $z } proc tbal {} { set f BB11034.xml AnalyseFichierBalibase $f exit } proc tbd {} { LoadTkAndPackages toplevel .tbd text .tbd.t1 -bg black -fg white -font "Helvetica 32 bold" -width 40 -height 2 -wrap none grid .tbd.t1 -row 0 -column 0 -pady 10 -sticky news .tbd.t1 tag configure toto -background green -foreground white -borderwidth 10 -underline 1 .tbd.t1 insert end "Et voici qu'arrive la lumiere !\n" .tbd.t1 insert end "Y li zouli li lumiire hein ?" .tbd.t1 tag add toto 1.5 1.12 2.3 2.7 # deuxieme text .tbd.t2 -bg black -fg white -font "Helvetica 32 bold" -width 40 -height 2 -wrap none grid .tbd.t2 -row 1 -column 0 -pady 10 -sticky news .tbd.t2 tag configure tata -background red -foreground white .tbd.t2 insert end "Et voici qu'arrive la lumiere !\n" .tbd.t2 insert end "Y li zouli li lumiire hein ?" .tbd.t2 tag add tata 1.5 1.12 2.3 2.7 update puts "t1 [winfo height .tbd.t1] [winfo reqheight .tbd.t1]" puts "t2 [winfo height .tbd.t2] [winfo reqheight .tbd.t2]" return } proc tbloc {orga} { global taxid SetupRRPSOrga $orga set i 0 set s1 [string repeat "ACDEFGHILMNPQQQRST" 10] set s2 [string repeat "ACCDEFFGHIKKLMNPQRST" 10] set o [open f1 w] puts $o $s1 close $o set o [open f2 w] puts $o $s2 close $o exit while {1} { set Lpdbid [PDBQuery -organism $taxid -experiment x-ray -identity 70] lassign [NWalign $s1 $s2] s1al s2al incr i puts "done $i" } exit } proc tbls {} { set seq "...............................................................................................................................................................M............................................................................................................................YFP......................................................SWLSQLYRGLSRP...............................................................................IRRTTQPIWGSLYRSLLQSS.QRRIPEF..........................................SSFVVR...TNTCGELR....S.SH.....LGQEVTLCGWIQYRRQ....N.TFLVLRDFDG.LVQVIIPQDES........A......ASVKKIL....CEAPVESVVQVSGTVISRPAGQENPKMPTGEIEIKVKTAELLNAC.K............KLPFEIK.NF...................VK.......................................................KTEALRLQYRYLDLRSFQMQYNLRLRSQMVMKMREYLCNLHGFVDIETPTLFKRTPGGAKEFLVPSR.EPG....KFYSLPQSPQQFKQLLMV.GGLDRYFQVARCYRDEGSRPDRQP.EFTQIDIEMSFVD.QTGIQSLIEGLLQYSWPNDK..DPVV...................VPFPTMTFAEVLATYGT.DKPDTRFGMKIIDISDVFR..NTE...IGFLQDALSK..PHG.......TVKAICIPEGAK....YLKRKDIESIRNFA.A..DH.FNQEILPVFLNAN.........RN....WN...SPVANFIMES....QRLELIRL..........METQEEDVVLLTAGE.HN...KACSLLGKLRLECADLLETRGVVLRD...PT.LFSFLWVVDFPLFL...PKEE............NPRELESAHHPF.TAP..............HPSDI......HLL................Y....TE.PKKARSQHYDLVLNGNEIGGGSIRIHNAELQRYILATLLK.......................EDVKMLSHLLQALDYGAPPHGGIALGLDR....LICLVTGSPSIRDVIAFPKSFRGHDLMSNTPDSVPPEELKPYHIRVSKP..................................................................................TDSKAERAH.............................................................................................................................................................................................................................................................................................................................." set seq [string map {. ""} $seq] set Lblast [BlastService -p blastp -d nr -expect 0.00001 -query ">toto\n$seq" -nlist 10 -f 1 -qdef yes] DecortiqueBlast $Lblast "" "" "" Lbid Lacc Lde "" LPN set i 0 foreach b $Lbid a $Lacc d $Lde p $LPN { puts "$b $a $p $d" incr i if {$i > 10} { break } } exit } proc tbulle {} { LoadTkAndPackages pack [canvas .c -width 400 -height 200 -bg black] set id [.c create text 50 50 -text "Hello everybody" -fill white -tags {thello ttest} -font "Helvetica 10" -justify left -anchor nw] .c create rectangle [.c bbox $id] -fill black -outline white -tags {trect ttest} .c raise $id if {1} { set rk [.c create rect [.c bbox $id] -fill "" -outline "" -tags sensor] .c raise sensor } .c bind sensor {ShowRank %W %x %y} .c bind sensor {%W delete balloon} return } proc tbusy {} { set tbl " - test : { . pk P . i1 I . i2 I . i3 I . i4 I . i5 I . i6 I } " catch {file delete test.sql} set dres [FabriqueDeTables $tbl d test.sql] } proc tbut {} { LoadTkAndPackages label .l -text "this is a very very very very very long label" frame .f button .f.b1 -text "button ONE" -bg green1 button .f.b2 -text "button TWO" -bg red grid .l -row 0 -column 0 -sticky news grid .f -row 1 -column 0 -sticky news grid columnconfig .f all -weight 1 grid .f.b1 -row 0 -column 0 -sticky w grid .f.b2 -row 0 -column 1 -sticky e #grid columnconfig .f all -weight 1 FenetreAuCentre . return } proc tc_loadNamedColor {name P} { global red green blue color autoUpdate global LaCouleurDePaletteDeCouleurs if {[string index $name 0] != "#"} { if {[catch {set list [winfo rgb $P.swatch $name]} Message]} { FaireLire "Error in color name with message\n$Message" return "" } set red [lindex $list 0] set green [lindex $list 1] set blue [lindex $list 2] } else { case [string length $name] { 4 {set format "#%1x%1x%1x"; set shift 12} 7 {set format "#%2x%2x%2x"; set shift 8} 10 {set format "#%3x%3x%3x"; set shift 4} 13 {set format "#%4x%4x%4x"; set shift 0} default {error "syntax error in color name \"$name\""} } if {[scan $name $format red green blue] != 3} { error "syntax error in color name \"$name\"" } set red [expr $red<<$shift] set green [expr $green<<$shift] set blue [expr $blue<<$shift] } tc_setScales $P set color [format "#%04x%04x%04x" $red $green $blue] $P.swatch config -bg $color if { $autoUpdate } { set LaCouleurDePaletteDeCouleurs $color } } proc tc_scaleChanged {P args} { global red green blue colorSpace color updating autoUpdate global LaCouleurDePaletteDeCouleurs if $updating { return } if {$colorSpace == "rgb"} { set red [format %.0f [expr [$P.scale1 get]*65.535]] set green [format %.0f [expr [$P.scale2 get]*65.535]] set blue [format %.0f [expr [$P.scale3 get]*65.535]] } else { if {$colorSpace == "cmy"} { set red [format %.0f [expr {65535 - [$P.scale1 get]*65.535}]] set green [format %.0f [expr {65535 - [$P.scale2 get]*65.535}]] set blue [format %.0f [expr {65535 - [$P.scale3 get]*65.535}]] } else { set list [hsbToRgb [expr {[$P.scale1 get]/1000.0}] [expr {[$P.scale2 get]/1000.0}] [expr {[$P.scale3 get]/1000.0}]] set red [lindex $list 0] set green [lindex $list 1] set blue [lindex $list 2] } } set color [format "#%04x%04x%04x" $red $green $blue] $P.swatch config -bg $color if { $autoUpdate } { set LaCouleurDePaletteDeCouleurs $color } update idletasks } proc tc_setScales {P} { global red green blue colorSpace updating set updating 1 if {$colorSpace == "rgb"} { $P.scale1 set [format %.0f [expr $red/65.535]] $P.scale2 set [format %.0f [expr $green/65.535]] $P.scale3 set [format %.0f [expr $blue/65.535]] } else { if {$colorSpace == "cmy"} { $P.scale1 set [format %.0f [expr (65535-$red)/65.535]] $P.scale2 set [format %.0f [expr (65535-$green)/65.535]] $P.scale3 set [format %.0f [expr (65535-$blue)/65.535]] } else { set list [rgbToHsv $red $green $blue] $P.scale1 set [format %.0f [expr {[lindex $list 0] * 1000.0}]] $P.scale2 set [format %.0f [expr {[lindex $list 1] * 1000.0}]] $P.scale3 set [format %.0f [expr {[lindex $list 2] * 1000.0}]] } } set updating 0 } proc tcaret {} { cd /home/moumou/ter source d.data puts "lit [lindex $Lit 0]" puts "Lot [lindex $Lot 0]" puts "lie [lindex $Lie 0]" puts "loe [lindex $Loe 0]" #exit set NbRow [llength $Lit] set NbRowT [llength $Lie] puts "NbRow $NbRow NbRowT $NbRowT" #exit set NbCol [llength [lindex $Lit 0]] set scol "" for {set i 1} {$i <= $NbCol} {incr i} { append scol "col$i + " } set scol [string range $scol 0 end-2] Rpipe "library(nnet)" Rpipe "library(caret)" #Rpipe "rm(list = ls(all.names = TRUE))" Rpipe "All <- c([join [concat {*}$Lit] ,])" Rpipe "All <- matrix(All,nrow=$NbRow,byrow=T)" Rpipe "Val <- c([join [concat {*}$Lot] ,])" Rpipe "Val <- matrix(Val,nrow=$NbRow,byrow=T)" Rpipe "Test <- c([join [concat {*}$Lie] ,])" Rpipe "Test <- matrix(Test,nrow=$NbRowT, byrow=T)" set Lvtst [list] for {set i 0; set j 0} {$i < $NbRowT} {incr i ; incr j} { if {$j == 3} {set j 0} switch $j { 0 {lappend Lvtst [list 1.0 0.0 0.0]} 1 {lappend Lvtst [list 0.0 1.0 0.0]} 2 {lappend Lvtst [list 0.0 0.0 1.0]} } } Rpipe "VTst <- c([join [concat {*}$Lvtst] ,])" Rpipe "VTst <- matrix(VTst,nrow=$NbRowT, byrow=T)" Rpipe "colnames(All) <- paste('col',1:ncol(All),sep='')" Rpipe "colnames(Val) <- paste('cls',1:ncol(Val),sep='')" Rpipe "colnames(Test) <- paste('col',1:ncol(Test),sep='')" Rpipe "colnames(VTst) <- paste('cls',1:ncol(VTst),sep='')" Rpipe "dt1 <- data.frame(Val,All)" Rpipe "dt1\$class = as.factor(paste0(\"v\",dt1\$cls1 ,dt1\$cls2, dt1\$cls3))" #Rpipe "dt2 <- as.data.frame(Test)" Rpipe "dt2 <- data.frame(VTst,Test)" Rpipe "dt2\$class = as.factor(paste0(\"v\",dt2\$cls1 ,dt2\$cls2 ,dt2\$cls3))" Rpipe "dt1" Rpipe "dt2" #exit Rpipe "set.seed(101112)" set out [Rpipe "fitControl <- trainControl(method = \"repeatedcv\", number = 10, repeats = 10)"] puts "out control = \n$out\n" puts "[DonneDateEtHeure]" set out [Rpipe "mod <- train(class ~ $scol, data = dt1, method='gbm',trControl = fitControl, verbose = TRUE)"] puts "[DonneDateEtHeure]" puts "out model =\n$out" set out [Rpipe "mod"] puts "out mod =\n$out" Rpipe "pred <- predict(mod,newdata = dt2,type='prob')" set out [Rpipe "print(pred)"] puts "$out" Rpipe "rm(list = ls(all.names = TRUE))" Rclose exit } proc tchar {} { set out [MapCharSet octal char "\311"] puts $out set s "\311tude d'ét\311" puts [Html2Char $s] exit set o [open cat.html r] fconfigure $o -encoding ascii set l [read -nonewline $o] set Ll [split $l "\n"] close $o set Lres {} foreach l $Ll { lappend Lres [Html2Char $l] } exit } proc tcl3dAddEvents {} { event add <> event add <> event add <> if { $::tcl_platform(os) eq "Darwin" } { event add <> event add <> event add <> event add <> event add <> event add <> event add <> } else { event add <> event add <> event add <> event add <> event add <> event add <> } } proc tcl3dCanvas2File {canv fileName {fmt JPEG} {opts ""}} { set img [tcl3dCanvas2Img $canv] if { [string length $fileName] != 0 } { $img write $fileName -format "$fmt $opts" } image delete $img } proc tcl3dCanvas2Img {canv} { global __tcl3dCaptureInt set region [$canv cget -scrollregion] set xsize [lindex $region 2] set ysize [lindex $region 3] set img [image create photo -width $xsize -height $ysize] if { !$__tcl3dCaptureInt(Img,avail) } { $img blank } else { $canv xview moveto 0 $canv yview moveto 0 update set xr 0.0 set yr 0.0 set px 0 set py 0 while { $xr < 1.0 } { while { $yr < 1.0 } { set tmpImg [image create photo -format window -data $canv] $img copy $tmpImg -to $px $py image delete $tmpImg set yr [lindex [$canv yview] 1] $canv yview moveto $yr set py [expr round ($ysize * [lindex [$canv yview] 0])] update } $canv yview moveto 0 set yr 0.0 set py 0 set xr [lindex [$canv xview] 1] $canv xview moveto $xr set px [expr round ($xsize * [lindex [$canv xview] 0])] update } } return $img } proc tcl3dCgGetVersion {} { if { [info commands cgGetString] ne "" } { return [cgGetString CG_VERSION] } else { return "" } } proc tcl3dCharToNum {char} { scan $char %c value return $value } proc tcl3dCheckGlError {msg} { set err [glGetError] if { $err == $::GL_NO_ERROR } { return 0 } puts [format "%s: GL error: 0X%X (%s)" $msg $err [gluErrorString $err]] return 1 } proc tcl3dClipboard2File {fileName {fmt JPEG} {opts ""}} { set img [tcl3dClipboard2Img] if { [string length $fileName] != 0 } { $img write $fileName -format "$fmt $opts" } image delete $img } proc tcl3dClipboard2Img {} { global __tcl3dCaptureInt if { !$__tcl3dCaptureInt(twapi,avail) } { error "Twapi extension not available" } twapi::open_clipboard # Assume clipboard content is in format 8 (CF_DIB) set retVal [catch {twapi::read_clipboard 8} clipData] if { $retVal != 0 } { error "Invalid or no content in clipboard" } # First parse the bitmap data to collect header information binary scan $clipData "iiissiiiiii" size width height planes bitcount compression sizeimage xpelspermeter ypelspermeter clrused clrimportant # We only handle BITMAPINFOHEADER right now (size must be 40) if {$size != 40} { error "Unsupported bitmap format. Header size=$size" } # We need to figure out the offset to the actual bitmap data # from the start of the file header. For this we need to know the # size of the color table which directly follows the BITMAPINFOHEADER if {$bitcount == 0} { error "Unsupported format: implicit JPEG or PNG" } elseif {$bitcount == 1} { set color_table_size 2 } elseif {$bitcount == 4} { # TBD - Not sure if this is the size or the max size set color_table_size 16 } elseif {$bitcount == 8} { # TBD - Not sure if this is the size or the max size set color_table_size 256 } elseif {$bitcount == 16 || $bitcount == 32} { if {$compression == 0} { # BI_RGB set color_table_size $clrused } elseif {$compression == 3} { # BI_BITFIELDS set color_table_size 3 } else { error "Unsupported compression type '$compression' for bitcount value $bitcount" } } elseif {$bitcount == 24} { set color_table_size $clrused } else { error "Unsupported value '$bitcount' in bitmap bitcount field" } set phImg [image create photo] set filehdr_size 14 ; # sizeof(BITMAPFILEHEADER) set bitmap_file_offset [expr {$filehdr_size+$size+($color_table_size*4)}] set filehdr [binary format "a2 i x2 x2 i" "BM" [expr {$filehdr_size + [string length $clipData]}] $bitmap_file_offset] append filehdr $clipData $phImg put $filehdr -format bmp twapi::close_clipboard return $phImg } proc tcl3dConsoleCreate {w prompt title} { upvar #0 $w.t v if {[winfo exists $w]} {destroy $w} if {[info exists v]} {unset v} toplevel $w wm title $w $title wm iconname $w $title set mnu $w.mb menu $mnu -borderwidth 2 -relief sunken $mnu add cascade -menu $mnu.file -label File -underline 0 $mnu add cascade -menu $mnu.edit -label Edit -underline 0 set fileMenu $mnu.file set editMenu $mnu.edit menu $fileMenu -tearoff 0 __tcl3dAddMenuCmd $fileMenu "Save as ..." "" "__tcl3dConsoleSaveFile $w.t" __tcl3dAddMenuCmd $fileMenu "Close" "" "destroy $w" __tcl3dAddMenuCmd $fileMenu "Quit" "" "exit" __tcl3dConsoleCreateChild $w $prompt $editMenu $w configure -menu $mnu } proc tcl3dCreatePdf {toglwin filename {title "Tcl3D Screenshot"} {drawBackground 0} {producer Tcl3D}} { tcl3dGl2psCreatePdf $toglwin $filename $title $drawBackground $producer } proc tcl3dCreateScrolledCanvas {wid titleStr args} { return [eval {tcl3dCreateScrolledWidget canvas $wid $titleStr} $args ] } proc tcl3dCreateScrolledFrame {wid titleStr args} { frame $wid.par pack $wid.par -fill both -expand 1 if { [string compare $titleStr ""] != 0 } { label $wid.par.label -text "$titleStr" -borderwidth 2 -relief raised } eval {canvas $wid.par.canv -xscrollcommand [list $wid.par.xscroll set] -yscrollcommand [list $wid.par.yscroll set]} $args scrollbar $wid.par.xscroll -orient horizontal -command "$wid.par.canv xview" scrollbar $wid.par.yscroll -orient vertical -command "$wid.par.canv yview" set fr [frame $wid.par.canv.fr -borderwidth 0 -highlightthickness 0] $wid.par.canv create window 0 0 -anchor nw -window $fr set rowNo 0 if { [string compare $titleStr ""] != 0 } { set rowNo 1 grid $wid.par.label -sticky ew -columnspan 2 } grid $wid.par.canv $wid.par.yscroll -sticky news grid $wid.par.xscroll -sticky ew grid rowconfigure $wid.par $rowNo -weight 1 grid columnconfigure $wid.par 0 -weight 1 # This binding makes the scroll-region of the canvas behave correctly as # you place more things in the content frame. bind $fr [list __tcl3dScrolledFrameCfgCB $wid.par %w %h] $wid.par.canv configure -borderwidth 0 -highlightthickness 0 return $fr } proc tcl3dCreateScrolledListbox {wid titleStr args} { return [eval {tcl3dCreateScrolledWidget listbox $wid $titleStr} $args ] } proc tcl3dCreateScrolledTable {wid titleStr args} { return [eval {tcl3dCreateScrolledWidget table $wid $titleStr} $args ] } proc tcl3dCreateScrolledTablelist {wid titleStr args} { return [eval {tcl3dCreateScrolledWidget tablelist::tablelist $wid $titleStr} $args ] } proc tcl3dCreateScrolledText {wid titleStr args} { return [eval {tcl3dCreateScrolledWidget text $wid $titleStr} $args ] } proc tcl3dCreateScrolledWidget {wType wid titleStr args} { if { [winfo exists $wid.par] } { destroy $wid.par } frame $wid.par pack $wid.par -side top -fill both -expand 1 if { [string compare $titleStr ""] != 0 } { label $wid.par.label -text "$titleStr" } eval { $wType $wid.par.widget -xscrollcommand "$wid.par.xscroll set" -yscrollcommand "$wid.par.yscroll set" } $args scrollbar $wid.par.xscroll -command "$wid.par.widget xview" -orient horizontal -takefocus 0 scrollbar $wid.par.yscroll -command "$wid.par.widget yview" -orient vertical -takefocus 0 set rowNo 0 if { [string compare $titleStr ""] != 0 } { set rowNo 1 grid $wid.par.label -sticky ew -columnspan 2 } grid $wid.par.widget $wid.par.yscroll -sticky news grid $wid.par.xscroll -sticky ew grid rowconfigure $wid.par $rowNo -weight 1 grid columnconfigure $wid.par 0 -weight 1 ::tcl3dAutoscroll::autoscroll $wid.par.xscroll ::tcl3dAutoscroll::autoscroll $wid.par.yscroll return $wid.par.widget } proc tcl3dCreateTmpDir {} { set masterTmpDir [tcl3dGetTmpDir] set i 0 while { 1 } { set tmpDirName [format "tcl3d_%05d.tmp" $i] set tmpDir [file join $masterTmpDir $tmpDirName] # puts "Checking for directory $masterTmpDir" if { [file exists $tmpDir] } { # Directory already exists. Try to delete it and recreate it first, # before attempting to create new number. set retVal [catch { file delete -force $tmpDir } ] if { $retVal != 0 } { incr i continue } } file mkdir $tmpDir # puts "\tCreating directory $tmpDir" return $tmpDir } } proc tcl3dDegToRad {ang} { return [expr {$ang * 3.1415926535 / 180.0}] } proc tcl3dDemoUtilHeightmapFromPhoto {phImg flHeightScale flResolution} { set w [image width $phImg] set h [image height $phImg] set n [tcl3dPhotoChans $phImg] if { $n < 3 } { error "Photo must have 3 or more channels" } set numVtx [expr {int ($w * $h * 6 / ($flResolution * $flResolution))}] set vtxVec [tcl3dVector GLfloat [expr {3 * $numVtx}]] set texVec [tcl3dVector GLfloat [expr {2 * $numVtx}]] tcl3dDemoUtilPhoto2Heightmap $phImg $vtxVec $texVec $flHeightScale $flResolution return [list $vtxVec $texVec $numVtx] } proc tcl3dDesktop2Clipboard {} { global __tcl3dCaptureInt if { !$__tcl3dCaptureInt(twapi,avail) } { error "Twapi extension not available" } twapi::send_keys {{PRTSC}} update } proc tcl3dFTGLGetVersion {} { if { [info commands FTGLBitmapFont] ne "" } { return [format "%d.%d.%d" 2 1 2] } else { return "" } } proc tcl3dFindColorName {colorName} { global __tcl3dColorList return [lsearch -inline $__tcl3dColorList $colorName] } proc tcl3dGenExtName {fileName} { if { [string first "vfs" [file system $fileName]] >= 0 } { set extDirName [file join [tcl3dGetTmpDir] "tcl3dData.tmp"] if { ! [file isdirectory $extDirName] } { file mkdir $extDirName } return [file join $extDirName [file tail $fileName]] } else { return $fileName } } proc tcl3dGetColorNames {} { global __tcl3dColorList set len [llength $__tcl3dColorList] for { set i 0 } { $i < $len } { incr i 4 } { lappend l [lindex $__tcl3dColorList $i] } return $l } proc tcl3dGetExtFile {fileName} { if { [string first "vfs" [file system $fileName]] >= 0 } { set extDirName [file join [tcl3dGetTmpDir] "tcl3dData.tmp"] if { ! [file isdirectory $extDirName] } { file mkdir $extDirName } set extFileName [file join $extDirName [file tail $fileName]] if { [file exists $extFileName] } { # puts "\t$extFileName already exists. No action." } else { # puts "\tCopy $fileName to $extDirName" file copy $fileName $extDirName } # puts "\tReturning <$extFileName>" return $extFileName } # puts "No Starpack: Returning <$fileName>" return $fileName } proc tcl3dGetExtensions {} { return [tcl3dOglGetExtensions] } proc tcl3dGetLibraryInfo {pkgName} { set retVal "" switch $pkgName { "tcl3dcg" { if { [info procs tcl3dCgGetVersion] ne "" } { return [tcl3dCgGetVersion] } } "tcl3dftgl" { if { [info procs tcl3dFTGLGetVersion] ne "" } { return [tcl3dFTGLGetVersion] } } "tcl3dgl2ps" { if { [info procs tcl3dGl2psGetVersion] ne "" } { return [tcl3dGl2psGetVersion] } } "tcl3dode" { if { [info procs tcl3dOdeGetVersion] ne "" } { return [tcl3dOdeGetVersion] } } "tcl3dogl" { if { [info procs tcl3dOglGetVersion] ne "" } { return [tcl3dOglGetVersion] } } "tcl3dosg" { if { [info procs tcl3dOsgGetVersion] ne "" } { return [tcl3dOsgGetVersion] } } "tcl3dsdl" { if { [info procs tcl3dSDLGetVersion] ne "" } { return [tcl3dSDLGetVersion] } } } return $retVal } proc tcl3dGetPackageInfo {} { set msgList {} foreach name [lsort [array names ::__tcl3dPkgInfo "*,avail"]] { set pkg [lindex [split $name ","] 0] set libVersion [tcl3dGetLibraryInfo $pkg] lappend msgList [list $pkg $::__tcl3dPkgInfo($pkg,avail) $::__tcl3dPkgInfo($pkg,version) $libVersion] } return $msgList } proc tcl3dGetStateList {} { return { { glGetFloatv GL_CURRENT_COLOR 4 1,1,1,1 } { glGetFloatv GL_CURRENT_SECONDARY_COLOR 4 0,0,0,1 } { glGetFloatv GL_CURRENT_INDEX 1 1 } { glGetFloatv GL_CURRENT_TEXTURE_COORDS 4 0,0,0,1 } { glGetFloatv GL_CURRENT_NORMAL 3 0,0,1 } { glGetFloatv GL_CURRENT_FOG_COORD 1 0 } { glGetFloatv GL_CURRENT_RASTER_POSITION 4 0,0,0,1 } { glGetFloatv GL_CURRENT_RASTER_DISTANCE 1 0 } { glGetFloatv GL_CURRENT_RASTER_COLOR 4 1,1,1,1 } { glGetIntegerv GL_CURRENT_RASTER_INDEX 1 1 } { glGetFloatv GL_CURRENT_RASTER_TEXTURE_COORDS 4 0,0,0,1 } { glGetBooleanv GL_CURRENT_RASTER_POSITION_VALID 1 True } { glGetBooleanv GL_EDGE_FLAG 1 True } { glGetIntegerv GL_CLIENT_ACTIVE_TEXTURE 1 TEXTURE0 } { glIsEnabled GL_VERTEX_ARRAY 1 False } { glGetIntegerv GL_VERTEX_ARRAY_SIZE 1 4 } { glGetIntegerv GL_VERTEX_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_VERTEX_ARRAY_STRIDE 1 0 } { glGetPointerv GL_VERTEX_ARRAY_POINTER 1 0 } { glIsEnabled GL_NORMAL_ARRAY 1 False } { glGetIntegerv GL_NORMAL_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_NORMAL_ARRAY_STRIDE 1 0 } { glGetPointerv GL_NORMAL_ARRAY_POINTER 1 0 } { glIsEnabled GL_FOG_COORD_ARRAY 1 False } { glGetIntegerv GL_FOG_COORD_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_FOG_COORD_ARRAY_STRIDE 1 0 } { glGetPointerv GL_FOG_COORD_ARRAY_POINTER 1 0 } { glIsEnabled GL_COLOR_ARRAY 1 False } { glGetIntegerv GL_COLOR_ARRAY_SIZE 1 4 } { glGetIntegerv GL_COLOR_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_COLOR_ARRAY_STRIDE 1 0 } { glGetPointerv GL_COLOR_ARRAY_POINTER 1 0 } { glIsEnabled GL_SECONDARY_COLOR_ARRAY 1 False } { glGetIntegerv GL_SECONDARY_COLOR_ARRAY_SIZE 1 3 } { glGetIntegerv GL_SECONDARY_COLOR_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_SECONDARY_COLOR_ARRAY_STRIDE 1 0 } { glGetPointerv GL_SECONDARY_COLOR_ARRAY_POINTER 1 0 } { glIsEnabled GL_INDEX_ARRAY 1 False } { glGetIntegerv GL_INDEX_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_INDEX_ARRAY_STRIDE 1 0 } { glGetPointerv GL_INDEX_ARRAY_POINTER 1 0 } { glIsEnabled GL_TEXTURE_COORD_ARRAY 1 False } { glGetIntegerv GL_TEXTURE_COORD_ARRAY_SIZE 1 4 } { glGetIntegerv GL_TEXTURE_COORD_ARRAY_TYPE 1 FLOAT } { glGetIntegerv GL_TEXTURE_COORD_ARRAY_STRIDE 1 0 } { glGetPointerv GL_TEXTURE_COORD_ARRAY_POINTER 1 0 } { glGetVertexAttribiv GL_VERTEX_ATTRIB_ARRAY_ENABLED 1 False } { glGetVertexAttribiv GL_VERTEX_ATTRIB_ARRAY_SIZE 1 4 } { glGetVertexAttribiv GL_VERTEX_ATTRIB_ARRAY_STRIDE 1 0 } { glGetVertexAttribiv GL_VERTEX_ATTRIB_ARRAY_TYPE 1 FLOAT } { glGetVertexAttribiv GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 1 False } { glGetVertexAttribPointerv GL_VERTEX_ATTRIB_ARRAY_POINTER 1 NULL } { glIsEnabled GL_EDGE_FLAG_ARRAY 1 False } { glGetIntegerv GL_EDGE_FLAG_ARRAY_STRIDE 1 0 } { glGetPointerv GL_EDGE_FLAG_ARRAY_POINTER 1 0 } { glGetIntegerv GL_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_VERTEX_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_NORMAL_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_COLOR_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_INDEX_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_FOG_COORD_ARRAY_BUFFER_BINDING 1 0 } { glGetIntegerv GL_ELEMENT_ARRAY_BUFFER_BINDING 1 0 } { glGetBufferSubData - 1 - } { glGetBufferParameteriv GL_BUFFER_SIZE 1 0 } { glGetBufferParameteriv GL_BUFFER_USAGE 1 STATIC_DRAW } { glGetBufferParameteriv GL_BUFFER_ACCESS 1 READ_WRITE } { glGetBufferParameteriv GL_BUFFER_MAPPED 1 FALSE } { glGetBufferPointerv GL_BUFFER_MAP_POINTER 1 NULL } { glGetFloatv GL_COLOR_MATRIX 16 Identity } { glGetFloatv GL_TRANSPOSE_COLOR_MATRIX 16 Identity } { glGetFloatv GL_MODELVIEW_MATRIX 16 Identity } { glGetFloatv GL_TRANSPOSE_MODELVIEW_MATRIX 16 Identity } { glGetFloatv GL_PROJECTION_MATRIX 16 Identity } { glGetFloatv GL_TRANSPOSE_PROJECTION_MATRIX 16 Identity } { glGetFloatv GL_TEXTURE_MATRIX 16 Identity } { glGetFloatv GL_TRANSPOSE_TEXTURE_MATRIX 16 Identity } { glGetIntegerv GL_VIEWPORT 1 {see 2.11.1} } { glGetFloatv GL_DEPTH_RANGE 2 0,1 } { glGetIntegerv GL_COLOR_MATRIX_STACK_DEPTH 1 1 } { glGetIntegerv GL_MODELVIEW_STACK_DEPTH 1 1 } { glGetIntegerv GL_PROJECTION_STACK_DEPTH 1 1 } { glGetIntegerv GL_TEXTURE_STACK_DEPTH 1 1 } { glGetIntegerv GL_MATRIX_MODE 1 MODELVIEW } { glIsEnabled GL_NORMALIZE 1 False } { glIsEnabled GL_RESCALE_NORMAL 1 False } { glGetClipPlane GL_CLIP_PLANE0 4 0,0,0,0 } { glGetClipPlane GL_CLIP_PLANE1 4 0,0,0,0 } { glGetClipPlane GL_CLIP_PLANE2 4 0,0,0,0 } { glGetClipPlane GL_CLIP_PLANE3 4 0,0,0,0 } { glGetClipPlane GL_CLIP_PLANE4 4 0,0,0,0 } { glGetClipPlane GL_CLIP_PLANE5 4 0,0,0,0 } { glIsEnabled GL_CLIP_PLANE0 1 False } { glIsEnabled GL_CLIP_PLANE1 1 False } { glIsEnabled GL_CLIP_PLANE2 1 False } { glIsEnabled GL_CLIP_PLANE3 1 False } { glIsEnabled GL_CLIP_PLANE4 1 False } { glIsEnabled GL_CLIP_PLANE5 1 False } { glGetFloatv GL_FOG_COLOR 4 0,0,0,0 } { glGetFloatv GL_FOG_INDEX 1 0 } { glGetFloatv GL_FOG_DENSITY 1 1.0 } { glGetFloatv GL_FOG_START 1 0.0 } { glGetFloatv GL_FOG_END 1 1.0 } { glGetIntegerv GL_FOG_MODE 1 EXP } { glIsEnabled GL_FOG 1 False } { glGetIntegerv GL_FOG_COORD_SOURCE 1 FRAGMENT_DEPTH } { glIsEnabled GL_COLOR_SUM 1 False } { glGetIntegerv GL_SHADE_MODEL 1 SMOOTH } { glIsEnabled GL_LIGHTING 1 False } { glIsEnabled GL_COLOR_MATERIAL 1 False } { glGetIntegerv GL_COLOR_MATERIAL_PARAMETER 1 AMBIENT_AND_DIFFUSE } { glGetIntegerv GL_COLOR_MATERIAL_FACE 1 FRONT_AND_BACK } { glGetMaterialfv GL_AMBIENT 4 0.2,0.2,0.2,1.0 } { glGetMaterialfv GL_DIFFUSE 4 0.8,0.8,0.8,1.0 } { glGetMaterialfv GL_SPECULAR 4 0.0,0.0,0.0,1.0 } { glGetMaterialfv GL_EMISSION 4 0.0,0.0,0.0,1.0 } { glGetMaterialfv GL_SHININESS 1 0.0 } { glGetFloatv GL_LIGHT_MODEL_AMBIENT 4 0.2,0.2,0.2,1.0 } { glGetBooleanv GL_LIGHT_MODEL_LOCAL_VIEWER 1 False } { glGetBooleanv GL_LIGHT_MODEL_TWO_SIDE 1 False } { glGetIntegerv GL_LIGHT_MODEL_COLOR_CONTROL 1 SINGLE_COLOR } { glGetLightfv GL_AMBIENT 4 0.0,0.0,0.0,1.0 } { glGetLightfv GL_DIFFUSE 1 {see table 2.10} } { glGetLightfv GL_SPECULAR 1 {see table 2.10} } { glGetLightfv GL_POSITION 4 0.0,0.0,1.0,0.0 } { glGetLightfv GL_CONSTANT_ATTENUATION 1 1.0 } { glGetLightfv GL_LINEAR_ATTENUATION 1 0.0 } { glGetLightfv GL_QUADRATIC_ATTENUATION 1 0.0 } { glGetLightfv GL_SPOT_DIRECTION 3 0.0,0.0,-1.0 } { glGetLightfv GL_SPOT_EXPONENT 1 0.0 } { glGetLightfv GL_SPOT_CUTOFF 1 180.0 } { glIsEnabled GL_LIGHT0 1 False } { glIsEnabled GL_LIGHT1 1 False } { glIsEnabled GL_LIGHT2 1 False } { glIsEnabled GL_LIGHT3 1 False } { glIsEnabled GL_LIGHT4 1 False } { glIsEnabled GL_LIGHT5 1 False } { glIsEnabled GL_LIGHT6 1 False } { glIsEnabled GL_LIGHT7 1 False } { glGetMaterialfv GL_COLOR_INDEXES 3 0,1,1 } { glGetFloatv GL_POINT_SIZE 1 1.0 } { glIsEnabled GL_POINT_SMOOTH 1 False } { glIsEnabled GL_POINT_SPRITE 1 False } { glGetFloatv GL_POINT_SIZE_MIN 1 0.0 } { glGetFloatv GL_POINT_SIZE_MAX 1 1 } { glGetFloatv GL_POINT_FADE_THRESHOLD_SIZE 1 1.0 } { glGetFloatv GL_POINT_DISTANCE_ATTENUATION 3 1,0,0 } { glGetIntegerv GL_POINT_SPRITE_COORD_ORIGIN 1 UPPER_LEFT } { glGetFloatv GL_LINE_WIDTH 1 1.0 } { glIsEnabled GL_LINE_SMOOTH 1 False } { glGetIntegerv GL_LINE_STIPPLE_PATTERN 1 1's } { glGetIntegerv GL_LINE_STIPPLE_REPEAT 1 1 } { glIsEnabled GL_LINE_STIPPLE 1 False } { glIsEnabled GL_CULL_FACE 1 False } { glGetIntegerv GL_CULL_FACE_MODE 1 BACK } { glGetIntegerv GL_FRONT_FACE 1 CCW } { glIsEnabled GL_POLYGON_SMOOTH 1 False } { glGetIntegerv GL_POLYGON_MODE 1 FILL } { glGetFloatv GL_POLYGON_OFFSET_FACTOR 1 0 } { glGetFloatv GL_POLYGON_OFFSET_UNITS 1 0 } { glIsEnabled GL_POLYGON_OFFSET_POINT 1 False } { glIsEnabled GL_POLYGON_OFFSET_LINE 1 False } { glIsEnabled GL_POLYGON_OFFSET_FILL 1 False } { glGetPolygonStipple - 1 1's } { glIsEnabled GL_POLYGON_STIPPLE 1 False } { glIsEnabled GL_MULTISAMPLE 1 True } { glIsEnabled GL_SAMPLE_ALPHA_TO_COVERAGE 1 False } { glIsEnabled GL_SAMPLE_ALPHA_TO_ONE 1 False } { glIsEnabled GL_SAMPLE_COVERAGE 1 False } { glGetFloatv GL_SAMPLE_COVERAGE_VALUE 1 1 } { glGetBooleanv GL_SAMPLE_COVERAGE_INVERT 1 False } { glIsEnabled GL_TEXTURE_1D 1 False } { glIsEnabled GL_TEXTURE_2D 1 False } { glIsEnabled GL_TEXTURE_3D 1 False } { glIsEnabled GL_TEXTURE_CUBE_MAP 1 False } { glGetIntegerv GL_TEXTURE_BINDING_1D 1 0 } { glGetIntegerv GL_TEXTURE_BINDING_2D 1 0 } { glGetIntegerv GL_TEXTURE_BINDING_3D 1 0 } { glGetIntegerv GL_TEXTURE_BINDING_CUBE_MAP 1 0 } { glGetTexImage GL_TEXTURE_1D 1 {see 3.8} } { glGetTexImage GL_TEXTURE_2D 1 {see 3.8} } { glGetTexImage GL_TEXTURE_3D 1 {see 3.8} } { glGetTexImage GL_TEXTURE_CUBE_MAP_POSITIVE_X 1 {see 3.8.1} } { glGetTexImage GL_TEXTURE_CUBE_MAP_NEGATIVE_X 1 {see 3.8.1} } { glGetTexImage GL_TEXTURE_CUBE_MAP_POSITIVE_Y 1 {see 3.8.1} } { glGetTexImage GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 1 {see 3.8.1} } { glGetTexImage GL_TEXTURE_CUBE_MAP_POSITIVE_Z 1 {see 3.8.1} } { glGetTexImage GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 1 {see 3.8.1} } { glGetTexParameterfv GL_TEXTURE_BORDER_COLOR 4 0,0,0,0 } { glGetTexParameteriv GL_TEXTURE_MIN_FILTER 1 {see 3.8} } { glGetTexParameteriv GL_TEXTURE_MAG_FILTER 1 {see 3.8} } { glGetTexParameteriv GL_TEXTURE_WRAP_S 1 REPEAT } { glGetTexParameteriv GL_TEXTURE_WRAP_T 1 REPEAT } { glGetTexParameteriv GL_TEXTURE_WRAP_R 1 REPEAT } { glGetTexParameterfv GL_TEXTURE_PRIORITY 1 1 } { glGetTexParameteriv GL_TEXTURE_RESIDENT 1 {see 3.8.12} } { glGetTexParameterfv GL_TEXTURE_MIN_LOD 1 -1000 } { glGetTexParameterfv GL_TEXTURE_MAX_LOD 1 1000 } { glGetTexParameteriv GL_TEXTURE_BASE_LEVEL 1 0 } { glGetTexParameteriv GL_TEXTURE_MAX_LEVEL 1 1000 } { glGetTexParameterfv GL_TEXTURE_LOD_BIAS 1 0.0 } { glGetTexParameteriv GL_DEPTH_TEXTURE_MODE 1 LUMINANCE } { glGetTexParameteriv GL_TEXTURE_COMPARE_MODE 1 NONE } { glGetTexParameteriv GL_TEXTURE_COMPARE_FUNC 1 LEQUAL } { glGetTexParameteriv GL_GENERATE_MIPMAP 1 FALSE } { glGetTexLevelParameteriv GL_TEXTURE_WIDTH 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_HEIGHT 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_DEPTH 1 {0 3D} } { glGetTexLevelParameteriv GL_TEXTURE_BORDER 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_INTERNAL_FORMAT 1 1 } { glGetTexLevelParameteriv GL_TEXTURE_RED_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_GREEN_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_BLUE_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_ALPHA_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_LUMINANCE_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_INTENSITY_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_DEPTH_SIZE 1 0 } { glGetTexLevelParameteriv GL_TEXTURE_COMPRESSED 1 False } { glGetTexLevelParameteriv GL_TEXTURE_COMPRESSED_IMAGE_SIZE 1 0 } { glGetTexEnviv GL_COORD_REPLACE 1 False } { glGetIntegerv GL_ACTIVE_TEXTURE 1 TEXTURE0 } { glGetTexEnviv GL_TEXTURE_ENV_MODE 1 MODULATE } { glGetTexEnvfv GL_TEXTURE_ENV_COLOR 4 0,0,0,0 } { glGetTexEnvfv GL_TEXTURE_LOD_BIAS 1 0.0 } { glIsEnabled GL_TEXTURE_GEN_S 1 False } { glIsEnabled GL_TEXTURE_GEN_T 1 False } { glIsEnabled GL_TEXTURE_GEN_R 1 False } { glIsEnabled GL_TEXTURE_GEN_Q 1 False } { glGetTexGenfv GL_EYE_PLANE 1 {see 2.11.4} } { glGetTexGenfv GL_OBJECT_PLANE 1 {see 2.11.4} } { glGetTexGeniv GL_TEXTURE_GEN_MODE 1 EYE_LINEAR } { glGetTexEnviv GL_COMBINE_RGB 1 MODULATE } { glGetTexEnviv GL_COMBINE_ALPHA 1 MODULATE } { glGetTexEnviv GL_SRC0_RGB 1 TEXTURE } { glGetTexEnviv GL_SRC1_RGB 1 PREVIOUS } { glGetTexEnviv GL_SRC2_RGB 1 CONSTANT } { glGetTexEnviv GL_SRC0_ALPHA 1 TEXTURE } { glGetTexEnviv GL_SRC1_ALPHA 1 PREVIOUS } { glGetTexEnviv GL_SRC2_ALPHA 1 CONSTANT } { glGetTexEnviv GL_OPERAND0_RGB 1 SRC_COLOR } { glGetTexEnviv GL_OPERAND1_RGB 1 SRC_COLOR } { glGetTexEnviv GL_OPERAND2_RGB 1 {SRC ALPHA} } { glGetTexEnviv GL_OPERAND0_ALPHA 1 {SRC ALPHA} } { glGetTexEnviv GL_OPERAND1_ALPHA 1 {SRC ALPHA} } { glGetTexEnviv GL_OPERAND2_ALPHA 1 SRC_ALPHA } { glGetTexEnvfv GL_RGB_SCALE 1 1.0 } { glGetTexEnvfv GL_ALPHA_SCALE 1 1.0 } { glIsEnabled GL_SCISSOR_TEST 1 False } { glGetIntegerv GL_SCISSOR_BOX 1 {see 4.1.2} } { glIsEnabled GL_ALPHA_TEST 1 False } { glGetIntegerv GL_ALPHA_TEST_FUNC 1 ALWAYS } { glGetIntegerv GL_ALPHA_TEST_REF 1 0 } { glIsEnabled GL_STENCIL_TEST 1 False } { glGetIntegerv GL_STENCIL_FUNC 1 ALWAYS } { glGetIntegerv GL_STENCIL_VALUE_MASK 1 1's } { glGetIntegerv GL_STENCIL_REF 1 0 } { glGetIntegerv GL_STENCIL_FAIL 1 KEEP } { glGetIntegerv GL_STENCIL_PASS_DEPTH_FAIL 1 KEEP } { glGetIntegerv GL_STENCIL_PASS_DEPTH_PASS 1 KEEP } { glGetIntegerv GL_STENCIL_BACK_FUNC 1 ALWAYS } { glGetIntegerv GL_STENCIL_BACK_VALUE_MASK 1 1's } { glGetIntegerv GL_STENCIL_BACK_REF 1 0 } { glGetIntegerv GL_STENCIL_BACK_FAIL 1 KEEP } { glGetIntegerv GL_STENCIL_BACK_PASS_DEPTH_FAIL 1 KEEP } { glGetIntegerv GL_STENCIL_BACK_PASS_DEPTH_PASS 1 KEEP } { glIsEnabled GL_DEPTH_TEST 1 False } { glGetIntegerv GL_DEPTH_FUNC 1 LESS } { glIsEnabled GL_BLEND 1 False } { glGetIntegerv GL_BLEND_SRC_RGB 1 ONE } { glGetIntegerv GL_BLEND_SRC 1 ONE } { glGetIntegerv GL_BLEND_SRC_ALPHA 1 ONE } { glGetIntegerv GL_BLEND_DST_RGB 1 ZERO } { glGetIntegerv GL_BLEND_DST 1 ZERO } { glGetIntegerv GL_BLEND_DST_ALPHA 1 ZERO } { glGetIntegerv GL_BLEND_EQUATION_RGB 1 FUNC_ADD } { glGetIntegerv GL_BLEND_EQUATION 1 FUNC_ADD } { glGetIntegerv GL_BLEND_EQUATION_ALPHA 1 FUNC_ADD } { glGetFloatv GL_BLEND_COLOR 4 0,0,0,0 } { glIsEnabled GL_DITHER 1 True } { glIsEnabled GL_INDEX_LOGIC_OP 1 False } { glIsEnabled GL_LOGIC_OP 1 False } { glIsEnabled GL_COLOR_LOGIC_OP 1 False } { glGetIntegerv GL_LOGIC_OP_MODE 1 COPY } { glGetIntegerv GL_DRAW_BUFFER_i 1 {see 4.2.1} } { glGetIntegerv GL_INDEX_WRITEMASK 1 1's } { glGetBooleanv GL_COLOR_WRITEMASK 1 True } { glGetBooleanv GL_DEPTH_WRITEMASK 1 True } { glGetIntegerv GL_STENCIL_WRITEMASK 1 1's } { glGetIntegerv GL_STENCIL_BACK_WRITEMASK 1 1's } { glGetFloatv GL_COLOR_CLEAR_VALUE 4 0,0,0,0 } { glGetFloatv GL_INDEX_CLEAR_VALUE 1 0 } { glGetIntegerv GL_DEPTH_CLEAR_VALUE 1 1 } { glGetIntegerv GL_STENCIL_CLEAR_VALUE 1 0 } { glGetFloatv GL_ACCUM_CLEAR_VALUE 1 0 } { glGetBooleanv GL_UNPACK_SWAP_BYTES 1 False } { glGetBooleanv GL_UNPACK_LSB_FIRST 1 False } { glGetIntegerv GL_UNPACK_IMAGE_HEIGHT 1 0 } { glGetIntegerv GL_UNPACK_SKIP_IMAGES 1 0 } { glGetIntegerv GL_UNPACK_ROW_LENGTH 1 0 } { glGetIntegerv GL_UNPACK_SKIP_ROWS 1 0 } { glGetIntegerv GL_UNPACK_SKIP_PIXELS 1 0 } { glGetIntegerv GL_UNPACK_ALIGNMENT 1 4 } { glGetBooleanv GL_PACK_SWAP_BYTES 1 False } { glGetBooleanv GL_PACK_LSB_FIRST 1 False } { glGetIntegerv GL_PACK_IMAGE_HEIGHT 1 0 } { glGetIntegerv GL_PACK_SKIP_IMAGES 1 0 } { glGetIntegerv GL_PACK_ROW_LENGTH 1 0 } { glGetIntegerv GL_PACK_SKIP_ROWS 1 0 } { glGetIntegerv GL_PACK_SKIP_PIXELS 1 0 } { glGetIntegerv GL_PACK_ALIGNMENT 1 4 } { glGetBooleanv GL_MAP_COLOR 1 False } { glGetBooleanv GL_MAP_STENCIL 1 False } { glGetIntegerv GL_INDEX_SHIFT 1 0 } { glGetIntegerv GL_INDEX_OFFSET 1 0 } { glGetFloatv GL_RED_SCALE 1 1 } { glGetFloatv GL_GREEN_SCALE 1 1 } { glGetFloatv GL_BLUE_SCALE 1 1 } { glGetFloatv GL_ALPHA_SCALE 1 1 } { glGetFloatv GL_DEPTH_SCALE 1 1 } { glGetFloatv GL_RED_BIAS 1 0 } { glGetFloatv GL_GREEN_BIAS 1 0 } { glGetFloatv GL_BLUE_BIAS 1 0 } { glGetFloatv GL_ALPHA_BIAS 1 0 } { glGetFloatv GL_DEPTH_BIAS 1 0 } { glIsEnabled GL_COLOR_TABLE 1 False } { glIsEnabled GL_POST_CONVOLUTION_COLOR_TABLE 1 False } { glIsEnabled GL_POST_COLOR_MATRIX_COLOR_TABLE 1 False } { glGetColorTable GL_COLOR_TABLE 1 empty } { glGetColorTable GL_POST_CONVOLUTION_COLOR_TABLE 1 empty } { glGetColorTable GL_POST_COLOR_MATRIX_COLOR_TABLE 1 empty } { glGetColorTableParameteriv GL_COLOR_TABLE_FORMAT 1 RGBA } { glGetColorTableParameteriv GL_COLOR_TABLE_WIDTH 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_RED_SIZE 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_GREEN_SIZE 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_BLUE_SIZE 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_ALPHA_SIZE 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_LUMINANCE_SIZE 1 0 } { glGetColorTableParameteriv GL_COLOR_TABLE_INTENSITY_SIZE 1 0 } { glGetColorTableParameterfv GL_COLOR_TABLE_SCALE 4 1,1,1,1 } { glGetColorTableParameterfv GL_COLOR_TABLE_BIAS 4 0,0,0,0 } { glIsEnabled GL_CONVOLUTION_1D 1 False } { glIsEnabled GL_CONVOLUTION_2D 1 False } { glIsEnabled GL_SEPARABLE_2D 1 False } { glGetConvolutionFilter GL_CONVOLUTION_1D 1 empty } { glGetConvolutionFilter GL_CONVOLUTION_2D 1 empty } { glGetSeparableFilter GL_SEPARABLE_2D 1 empty } { glGetConvolutionParameterfv GL_CONVOLUTION_BORDER_COLOR 4 0,0,0,0 } { glGetConvolutionParameteriv GL_CONVOLUTION_BORDER_MODE 1 REDUCE } { glGetConvolutionParameterfv GL_CONVOLUTION_FILTER_SCALE 4 1,1,1,1 } { glGetConvolutionParameterfv GL_CONVOLUTION_FILTER_BIAS 4 0,0,0,0 } { glGetConvolutionParameteriv GL_CONVOLUTION_FORMAT 1 RGBA } { glGetConvolutionParameteriv GL_CONVOLUTION_WIDTH 1 0 } { glGetConvolutionParameteriv GL_CONVOLUTION_HEIGHT 1 0 } { glGetFloatv GL_POST_CONVOLUTION_RED_SCALE 1 1 } { glGetFloatv GL_POST_CONVOLUTION_GREEN_SCALE 1 1 } { glGetFloatv GL_POST_CONVOLUTION_BLUE_SCALE 1 1 } { glGetFloatv GL_POST_CONVOLUTION_ALPHA_SCALE 1 1 } { glGetFloatv GL_POST_CONVOLUTION_RED_BIAS 1 0 } { glGetFloatv GL_POST_CONVOLUTION_GREEN_BIAS 1 0 } { glGetFloatv GL_POST_CONVOLUTION_BLUE_BIAS 1 0 } { glGetFloatv GL_POST_CONVOLUTION_ALPHA_BIAS 1 0 } { glGetFloatv GL_POST_COLOR_MATRIX_RED_SCALE 1 1 } { glGetFloatv GL_POST_COLOR_MATRIX_GREEN_SCALE 1 1 } { glGetFloatv GL_POST_COLOR_MATRIX_BLUE_SCALE 1 1 } { glGetFloatv GL_POST_COLOR_MATRIX_ALPHA_SCALE 1 1 } { glGetFloatv GL_POST_COLOR_MATRIX_RED_BIAS 1 0 } { glGetFloatv GL_POST_COLOR_MATRIX_GREEN_BIAS 1 0 } { glGetFloatv GL_POST_COLOR_MATRIX_BLUE_BIAS 1 0 } { glGetFloatv GL_POST_COLOR_MATRIX_ALPHA_BIAS 1 0 } { glIsEnabled GL_HISTOGRAM 1 False } { glGetHistogram GL_HISTOGRAM 1 empty } { glGetHistogramParameteriv GL_HISTOGRAM_WIDTH 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM_FORMAT 1 RGBA } { glGetHistogramParameteriv GL_HISTOGRAM_RED_SIZE 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM_GREEN_SIZE 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM_BLUE_SIZE 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM_ALPHA_SIZE 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM_LUMINANCE_SIZE 1 0 } { glGetHistogramParameteriv GL_HISTOGRAM SINK 1 False } { glIsEnabled GL_MINMAX 1 False } { glGetMinmax GL_MINMAX 8 M,M,M,M),(m,m,m,m } { glGetMinmaxParameteriv GL_MINMAX_FORMAT 1 RGBA } { glGetMinmaxParameteriv GL_MINMAX_SINK 1 False } { glGetFloatv GL_ZOOM_X 1 1.0 } { glGetFloatv GL_ZOOM_Y 1 1.0 } { glGetPixelMapfv GL_PIXEL_MAP_I_TO_I 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_S_TO_S 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_I_TO_R 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_I_TO_G 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_I_TO_B 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_I_TO_A 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_R_TO_R 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_G_TO_G 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_B_TO_B 1 0's } { glGetPixelMapfv GL_PIXEL_MAP_A_TO_A 1 0's } { glGetIntegerv GL_PIXEL_MAP_I_TO_I_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_S_TO_S_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_I_TO_R_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_I_TO_G_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_I_TO_B_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_I_TO_A_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_R_TO_R_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_G_TO_G_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_B_TO_B_SIZE 1 1 } { glGetIntegerv GL_PIXEL_MAP_A_TO_A_SIZE 1 1 } { glGetIntegerv GL_READ_BUFFER 1 {see 4.3.2} } { glGetMapiv GL_ORDER 1 1 } { glGetMapiv GL_ORDER 2 1,1 } { glGetMapfv GL_COEFF 1 {see 5.1} } { glGetMapfv GL_COEFF 1 {see 5.1} } { glGetMapfv GL_DOMAIN 1 {see 5.1} } { glGetMapfv GL_DOMAIN 1 {see 5.1} } { glIsEnabled GL_MAP1_NORMAL 1 False } { glIsEnabled GL_MAP2_NORMAL 1 False } { glGetFloatv GL_MAP1_GRID_DOMAIN 2 0,1 } { glGetFloatv GL_MAP2_GRID_DOMAIN 3 {0,1;0,1} } { glGetFloatv GL_MAP1_GRID_SEGMENTS 1 1 } { glGetFloatv GL_MAP2_GRID_SEGMENTS 2 1,1 } { glIsEnabled GL_AUTO_NORMAL 1 False } { glGetShaderSource - 1 empty } { glGetIntegerv GL_CURRENT_PROGRAM 1 0 } { glGetProgramiv GL_DELETE_STATUS 1 False } { glGetProgramiv GL_LINK_STATUS 1 False } { glGetProgramiv GL_VALIDATE_STATUS 1 False } { glGetProgramiv GL_ATTACHED_SHADERS 1 0 } { glGetAttachedObjects - 1 empty } { glGetProgramiv GL_INFO_LOG_LENGTH 1 0 } { glGetProgramiv GL_ACTIVE_UNIFORMS 1 0 } { glGetUniformLocation - 1 - } { glGetActiveUniform - 1 - } { glGetActiveUniform - 1 - } { glGetActiveUniform - 1 empty } { glGetProgramiv GL_ACTIVE_UNIFORM_MAX_LENGTH 1 0 } { glGetUniformfv - 1 0 } { glGetProgramiv GL_ACTIVE_ATTRIBUTES 1 0 } { glGetAttribLocation - 1 - } { glGetActiveAttrib - 1 - } { glGetActiveAttrib - 1 - } { glGetActiveAttrib - 1 empty } { glGetProgramiv GL_ACTIVE_ATTRIBUTES_MAX_LENGTH 1 0 } { glIsEnabled GL_VERTEX_PROGRAM_TWO_SIDE 1 False } { glGetVertexAttribfv GL_CURRENT_VERTEX_ATTRIB 4 0,0,0,1 } { glIsEnabled GL_VERTEX_PROGRAM_POINT_SIZE 1 False } { glGetIntegerv GL_PERSPECTIVE_CORRECTION_HINT 1 DONT_CARE } { glGetIntegerv GL_POINT_SMOOTH_HINT 1 DONT_CARE } { glGetIntegerv GL_LINE_SMOOTH_HINT 1 DONT_CARE } { glGetIntegerv GL_POLYGON_SMOOTH_HINT 1 DONT_CARE } { glGetIntegerv GL_FOG_HINT 1 DONT_CARE } { glGetIntegerv GL_GENERATE_MIPMAP_HINT 1 DONT_CARE } { glGetIntegerv GL_TEXTURE_COMPRESSION_HINT 1 DONT_CARE } { glGetIntegerv GL_FRAGMENT_SHADER_DERIVATIVE_HINT 1 DONT_CARE } { glGetIntegerv GL_MAX_LIGHTS 1 8 } { glGetIntegerv GL_MAX_CLIP_PLANES 1 6 } { glGetIntegerv GL_MAX_COLOR_MATRIX_STACK_DEPTH 1 2 } { glGetIntegerv GL_MAX_MODELVIEW_STACK_DEPTH 1 32 } { glGetIntegerv GL_MAX_PROJECTION_STACK_DEPTH 1 2 } { glGetIntegerv GL_MAX_TEXTURE_STACK_DEPTH 1 2 } { glGetIntegerv GL_SUBPIXEL_BITS 1 4 } { glGetIntegerv GL_MAX_3D_TEXTURE_SIZE 1 16 } { glGetIntegerv GL_MAX_TEXTURE_SIZE 1 64 } { glGetFloatv GL_MAX_TEXTURE_LOD_BIAS 1 2.0 } { glGetIntegerv GL_MAX_CUBE_MAP_TEXTURE_SIZE 1 16 } { glGetIntegerv GL_MAX_PIXEL_MAP_TABLE 1 32 } { glGetIntegerv GL_MAX_NAME_STACK_DEPTH 1 64 } { glGetIntegerv GL_MAX_LIST_NESTING 1 64 } { glGetIntegerv GL_MAX_EVAL_ORDER 1 8 } { glGetIntegerv GL_MAX_VIEWPORT_DIMS 1 {see 2.11.1} } { glGetIntegerv GL_MAX_ATTRIB_STACK_DEPTH 1 16 } { glGetIntegerv GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 1 16 } { gl- - 1 32 } { gl- - 1 32 } { glGetIntegerv GL_AUX_BUFFERS 1 0 } { glGetBooleanv GL_RGBA_MODE 1 - } { glGetBooleanv GL_INDEX_MODE 1 - } { glGetBooleanv GL_DOUBLEBUFFER 1 - } { glGetBooleanv GL_STEREO 1 - } { glGetFloatv GL_ALIASED_POINT_SIZE_RANGE 2 1,1 } { glGetFloatv GL_SMOOTH_POINT_SIZE_RANGE 2 1,1 } { glGetFloatv GL_POINT_SIZE_RANGE 2 1,1 } { glGetFloatv GL_SMOOTH_POINT_SIZE_GRANULARITY 1 - } { glGetFloatv GL_POINT_SIZE_GRANULARITY 1 - } { glGetFloatv GL_ALIASED_LINE_WIDTH_RANGE 2 1,1 } { glGetFloatv GL_SMOOTH_LINE_WIDTH_RANGE 2 1,1 } { glGetFloatv GL_LINE_WIDTH_RANGE 2 1,1 } { glGetFloatv GL_SMOOTH_LINE_WIDTH_GRANULARITY 1 - } { glGetFloatv GL_LINE_WIDTH_GRANULARITY 1 - } { glGetConvolutionParameteriv GL_MAX_CONVOLUTION_WIDTH 1 3 } { glGetConvolutionParameteriv GL_MAX_CONVOLUTION_HEIGHT 1 3 } { glGetIntegerv GL_MAX_ELEMENTS_INDICES 1 - } { glGetIntegerv GL_MAX_ELEMENTS_VERTICES 1 - } { glGetIntegerv GL_SAMPLE_BUFFERS 1 0 } { glGetIntegerv GL_SAMPLES 1 0 } { glGetIntegerv GL_COMPRESSED_TEXTURE_FORMATS 1 - } { glGetIntegerv GL_NUM_COMPRESSED_TEXTURE_FORMATS 1 0 } { glGetQueryiv GL_QUERYCOUNTER_BITS 1 {see 6.1.12} } { glGetString GL_EXTENSIONS 1 - } { glGetString GL_RENDERER 1 - } { glGetString GL_SHADING_LANGUAGE_VERSION 1 - } { glGetString GL_VENDOR 1 - } { glGetString GL_VERSION 1 - } { glGetIntegerv GL_MAX_TEXTURE_UNITS 1 2 } { glGetIntegerv GL_MAX_VERTEX_ATTRIBS 1 16 } { glGetIntegerv GL_MAX_VERTEX_UNIFORM_COMPONENTS 1 512 } { glGetIntegerv GL_MAX_VARYING_FLOATS 1 32 } { glGetIntegerv GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 1 2 } { glGetIntegerv GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 1 0 } { glGetIntegerv GL_MAX_TEXTURE_IMAGE_UNITS 1 2 } { glGetIntegerv GL_MAX_TEXTURE_COORDS 1 2 } { glGetIntegerv GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 1 64 } { glGetIntegerv GL_MAX_DRAW_BUFFERS 1 1+ } { glGetIntegerv GL_RED_BITS 1 - } { glGetIntegerv GL_GREEN_BITS 1 - } { glGetIntegerv GL_BLUE_BITS 1 - } { glGetIntegerv GL_ALPHA_BITS 1 - } { glGetIntegerv GL_INDEX_BITS 1 - } { glGetIntegerv GL_DEPTH_BITS 1 - } { glGetIntegerv GL_STENCIL_BITS 1 - } { glGetIntegerv GL_ACCUM_RED_BITS 1 - } { glGetIntegerv GL_ACCUM_GREEN_BITS 1 - } { glGetIntegerv GL_ACCUM_BLUE_BITS 1 - } { glGetIntegerv GL_ACCUM_ALPHA_BITS 1 - } { glGetIntegerv GL_LIST_BASE 1 0 } { glGetIntegerv GL_LIST_INDEX 1 0 } { glGetIntegerv GL_LIST_MODE 1 0 } { gl- - 1 empty } { glGetIntegerv GL_ATTRIB_STACK_DEPTH 1 0 } { gl- - 1 empty } { glGetIntegerv GL_CLIENT_ATTRIB_STACK_DEPTH 1 0 } { glGetIntegerv GL_NAME_STACK_DEPTH 1 0 } { glGetIntegerv GL_RENDER_MODE 1 RENDER } { glGetPointerv GL_SELECTION_BUFFER_POINTER 1 0 } { glGetIntegerv GL_SELECTION_BUFFER_SIZE 1 0 } { glGetPointerv GL_FEEDBACK_BUFFER_POINTER 1 0 } { glGetIntegerv GL_FEEDBACK_BUFFER_SIZE 1 0 } { glGetIntegerv GL_FEEDBACK_BUFFER_TYPE 1 2D } { glGetError - 1 0 } { gl- - 1 False } { gl- - 1 False } { glGetQueryiv GL_CURRENT_QUERY 1 0 } { gl- - 1 0 } } } proc tcl3dGetStates {{sortFlag none}} { return [tcl3dOglGetStates $sortFlag] } proc tcl3dGetTmpDir {} { global tcl_platform env set tmpDir "" # Try different environment variables. if { [info exists env(TMP)] && [file isdirectory $env(TMP)] } { set tmpDir $env(TMP) } elseif { [info exists env(TEMP)] && [file isdirectory $env(TEMP)] } { set tmpDir $env(TEMP) } elseif { [info exists env(TMPDIR)] && [file isdirectory $env(TMPDIR)] } { set tmpDir $env(TMPDIR) } else { # Last resort. These directories should be available at least. switch $tcl_platform(platform) { windows { if { [file isdirectory "C:/Windows/Temp"] } { set tmpDir "C:/Windows/Temp" } elseif { [file isdirectory "C:/Winnt/Temp"] } { set tmpDir "C:/Winnt/Temp" } } unix { if { [file isdirectory "/tmp"] } { set tmpDir "/tmp" } } } } return [file nativename $tmpDir] } proc tcl3dGetVersions {} { return [tcl3dOglGetVersions] } proc tcl3dGl2psCreatePdf {toglwin filename {title "Tcl3D Screenshot"} {drawBackground 0} {producer Tcl3D}} { set retVal [catch {fopen $filename wb} fp] if { $retVal != 0 } { error "Could not open file $filename for writing" } set opt [expr {$::GL2PS_OCCLUSION_CULL | $::GL2PS_USE_CURRENT_VIEWPORT | $::GL2PS_SILENT}] if { $drawBackground } { set opt [expr {$opt | $::GL2PS_DRAW_BACKGROUND}] } set bufSize 0 set state $::GL2PS_OVERFLOW while { $state == $::GL2PS_OVERFLOW } { set bufSize [expr {$bufSize + 1024*1024}] set retVal [gl2psBeginPage $title $producer NULL $::GL2PS_PDF $::GL2PS_SIMPLE_SORT $opt $::GL_RGBA 0 NULL 0 0 0 $bufSize $fp $title] if { $retVal == $::GL2PS_ERROR } { error "Could not initialize PDF creation: gl2psBeginPage" } $toglwin render set state [gl2psEndPage] if { $retVal == $::GL2PS_ERROR } { error "Could not write PDF: gl2psEndPage" } } fclose $fp } proc tcl3dGl2psGetVersion {} { if { [info exists ::GL2PS_MAJOR_VERSION] } { return [format "%d.%d.%d" $::GL2PS_MAJOR_VERSION $::GL2PS_MINOR_VERSION $::GL2PS_PATCH_VERSION] } else { return "" } } proc tcl3dHaveAqua {} { if { [tk windowingsystem] eq "aqua" } { return true } else { return false } } proc tcl3dHaveCg {} { return $::__tcl3dPkgInfo(tcl3dcg,avail) } proc tcl3dHaveExtension {extensionName} { return [tcl3dOglHaveExtension $extensionName] } proc tcl3dHaveFTGL {} { return $::__tcl3dPkgInfo(tcl3dftgl,avail) } proc tcl3dHaveGl2ps {} { return $::__tcl3dPkgInfo(tcl3dgl2ps,avail) } proc tcl3dHaveOde {} { return $::__tcl3dPkgInfo(tcl3dode,avail) } proc tcl3dHaveOsg {} { return $::__tcl3dPkgInfo(tcl3dosg,avail) } proc tcl3dHavePackage {pkgName version} { uplevel #0 [package unknown] [list $pkgName $version] foreach found [package versions $pkgName] { if {[package vsatisfies $found $version]} { return 1 } } return 0 } proc tcl3dHaveSDL {} { return $::__tcl3dPkgInfo(tcl3dsdl,avail) } proc tcl3dHaveVersion {majorWanted {minorWanted 0} {patchWanted 0}} { return [tcl3dOglHaveVersion $majorWanted $minorWanted $patchWanted] } proc tcl3dHeightmapFromPhoto {phImg flHeightScale flResolution} { return [tcl3dDemoUtilHeightmapFromPhoto $phImg $flHeightScale $flResolution] } proc tcl3dImg2Clipboard {phImg} { global __tcl3dCaptureInt if { !$__tcl3dCaptureInt(base64,avail) } { error "Base64 extension not available" } if { !$__tcl3dCaptureInt(twapi,avail) } { error "Twapi extension not available" } # First 14 bytes are bitmapfileheader - get rid of this set data [string range [base64::decode [$phImg data -format bmp]] 14 end] twapi::open_clipboard twapi::empty_clipboard twapi::write_clipboard 8 $data twapi::close_clipboard } proc tcl3dInit {} { tcl3dOglExtInit } proc tcl3dLogoDestroyPoSoft {} { global __tcl3dLogoWackel global __tcl3dLogoWinId global __tcl3dLogoWithdrawnWinId if { [info exists __tcl3dLogoWinId] && [winfo exists $__tcl3dLogoWinId] } { __tcl3dLogoShrinkWindow $__tcl3dLogoWinId x set __tcl3dLogoWackel(onoff) 0 image delete $__tcl3dLogoWackel(0) image delete $__tcl3dLogoWackel(1) destroy $__tcl3dLogoWinId if { [winfo exists $__tcl3dLogoWithdrawnWinId] } { wm deiconify $__tcl3dLogoWithdrawnWinId } } } proc tcl3dLogoDestroyTcl {w img} { __tcl3dLogoShrinkWindow $w y image delete $img destroy $w } proc tcl3dLogoShowPoSoft {version copyright {withdrawWin ""}} { global __tcl3dLogoWackel global __tcl3dLogoWinId global __tcl3dLogoWithdrawnWinId set t ".poShowLogo" set __tcl3dLogoWinId $t set __tcl3dLogoWithdrawnWinId $withdrawWin if { [winfo exists $t] } { tcl3dWinRaise $t return } set __tcl3dLogoWackel(0) [image create photo -data [__tcl3dLogoPoLogo200_text]] set __tcl3dLogoWackel(1) [image create photo -data [__tcl3dLogoPoLogo200_text_flip]] set __tcl3dLogoWackel(onoff) 0 set __tcl3dLogoWackel(curImg) 0 set __tcl3dLogoWackel(wackelSpeed) 500 if { [catch {toplevel $t -visual truecolor}] } { toplevel $t } frame $t.f pack $t.f wm resizable $t false false if { [string compare $withdrawWin ""] == 0 } { wm title $t "poSoft Information" } else { if { [string compare $withdrawWin "."] != 0 } { wm withdraw . } if { [winfo exists $withdrawWin] } { wm withdraw $withdrawWin set __tcl3dLogoWithdrawnWinId $withdrawWin } wm overrideredirect $t 1 set xmax [winfo screenwidth $t] set ymax [winfo screenheight $t] set x0 [expr {($xmax - [image width $__tcl3dLogoWackel(0)])/2}] set y0 [expr {($ymax - [image height $__tcl3dLogoWackel(0)])/2}] wm geometry $t "+$x0+$y0" $t.f configure -borderwidth 10 raise $t update } label $t.f.l1 -text "Paul Obermeier's Portable Software" pack $t.f.l1 -fill x button $t.f.l2 -image $__tcl3dLogoWackel(0) bind $t.f.l2 { __tcl3dLogoSetWackelDelay %x %y } bind $t.f.l2 "__tcl3dLogoStartWackel $t.f.l2" bind $t.f.l2 "__tcl3dLogoSwitchLogo $t.f.l2" pack $t.f.l2 label $t.f.l3 -text $version pack $t.f.l3 -fill x label $t.f.l4 -text $copyright pack $t.f.l4 -fill x if { [string compare $withdrawWin ""] == 0 } { button $t.f.b -text "OK" -command "tcl3dLogoDestroyPoSoft" pack $t.f.b -fill x bind $t "tcl3dLogoDestroyPoSoft" bind $t "tcl3dLogoDestroyPoSoft" focus $t update } else { focus $t update after 500 __tcl3dLogoSwitchLogo $t.f.l2 update after 300 } } proc tcl3dLogoShowTcl {args} { global __url set t ".tcl3dLogoShowTcl" if { [winfo exists $t] } { tcl3dWinRaise $t return } if { [catch {toplevel $t -visual truecolor}] } { toplevel $t } wm title $t "Tcl/Tk Information" wm resizable $t false false set ph [image create photo -data [__tcl3dLogoPwrdLogo200]] button $t.img -image $ph pack $t.img label $t.l1 -anchor w -text "With a little help from my Tcl friends ..." pack $t.l1 set row 0 frame $t.f -relief sunken -borderwidth 2 pack $t.f -fill both -expand 1 foreach extension $args { set retVal [catch {package present $extension} versionStr] if { $retVal != 0 } { set versionStr "(not loaded)" } switch $extension { Tk { set progName "Tcl/Tk [info patchlevel]" set __url($row) "http://www.tcl.tk" set author "all Tcl/Tk core developers" } Img { set progName "Img $versionStr" set __url($row) "http://sourceforge.net/projects/tkImg/" set author "Jan Nijtmans, Andreas Kupries" } Tktable { set progName "Tktable $versionStr" set __url($row) "https://sourceforge.net/projects/tktable/" set author "Jeffrey Hobbs" } mktclapp { set progName "mktclapp 3.9" set __url($row) "http://www.hwaci.com/sw/mktclapp" set author "D. Richard Hipp" } combobox { set progName "combobox $versionStr" set __url($row) "http://www2.clearlight.com/~oakley" set author "Bryan Oakley" } mysqltcl { set progName "mysqltcl $versionStr" set __url($row) "http://www.xdobry.de/mysqltcl" set author "Hakan Soderlund, Tobias Ritzau ..." } tcom { set progName "tcom $versionStr" set __url($row) "http://www.vex.net/~cthuang/tcom" set author "Chin Huang" } tablelist { set progName "tablelist $versionStr" set __url($row) "http://www.nemethi.de" set author "Csaba Nemethi" } } label $t.f.lext$row -text $progName set bgColor [$t.f.lext$row cget -bg] eval entry $t.f.rext$row -state normal -width 35 -relief flat -bg $bgColor -textvariable __url($row) grid $t.f.lext$row -row $row -column 0 -sticky w grid $t.f.rext$row -row $row -column 1 -sticky w incr row } button $t.b -text "OK" -command "tcl3dLogoDestroyTcl $t $ph" pack $t.b -fill x bind $t "tcl3dLogoDestroyTcl $t $ph" bind $t "tcl3dLogoDestroyTcl $t $ph" focus $t } proc tcl3dMatfPrint {mat {precisionString %6.3f}} { for { set i 0 } { $i < 4 } { incr i } { for { set j 0 } { $j < 4 } { incr j } { puts -nonewline [format "$precisionString " [$mat get [expr 4*$j + $i]]] } puts "" } } proc tcl3dName2Hex {colorName} { global __tcl3dColorList if {[string index $colorName 0] eq "#" } { return $colorName } else { set ind [lsearch $__tcl3dColorList $colorName] if { $ind >= 0 } { set rgb [lrange $__tcl3dColorList [expr $ind+1] [expr $ind+3]] return [eval "format \#%02X%02X%02X $rgb"] } } error "Invalid color name \"$colorName\" specified" } proc tcl3dName2Hexa {colorName} { return [eval "format %s%02X [tcl3dName2Hex $colorName] 255"] } proc tcl3dName2rgb {colorName} { global __tcl3dColorList if {[string index $colorName 0] eq "#" } { scan $colorName "#%2x%2x%2x" r g b return [list $r $g $b] } else { set ind [lsearch $__tcl3dColorList $colorName] if { $ind >= 0 } { return [lrange $__tcl3dColorList [expr $ind+1] [expr $ind+3]] } } error "Invalid color name \"$colorName\" specified" } proc tcl3dName2rgba {colorName} { return [linsert [tcl3dName2rgb $colorName] end 255] } proc tcl3dName2rgbaf {colorName} { foreach elem [tcl3dName2rgba $colorName] { lappend l [expr {$elem / 255.0}] } return $l } proc tcl3dName2rgbf {colorName} { foreach elem [tcl3dName2rgb $colorName] { lappend l [expr {$elem / 255.0}] } return $l } proc tcl3dNumToChar {num} { return [format "%c" $num] } proc tcl3dOdeGetVersion {} { if { [info commands dWorldCreate] ne "" } { return [format "%d.%d.%d" 0 7 0] } else { return "" } } proc tcl3dOglExtInit {} { if { [info commands glewInit] ne "" } { # GLEW based wrapper. Tcl3D Version >= 0.4 glewInit } elseif { [info commands glexGetVersion] ne "" } { # OglExt based wrapper. Tcl3D Version >= 0.2 glexGetVersion } else { error "OpenGL extension library not wrapped" } } proc tcl3dOglFindFunc {glFunc} { if { [tcl3dOglHaveFunc $glFunc] } { return $glFunc } else { foreach ext [tcl3dOglGetExtSuffixes] { set func "${glFunc}${ext}" if { [tcl3dOglHaveFunc $func] } { return $func } } } return "" } proc tcl3dOglGetDoubleState {state {numVals 1}} { if { $numVals <= 0 } { error "Number of values must be greater than zero" } set vec [tcl3dVector GLdouble $numVals] glGetDoublev $state $vec if { $numVals == 1 } { set val [$vec get 0] } else { set val [tcl3dVectorToList $vec $numVals] } $vec delete return $val } proc tcl3dOglGetError {} { set err [glGetError] if { $err == $::GL_NO_ERROR } { return "" } return [format "GL error: 0X%X (%s)" $err [gluErrorString $err]] } proc tcl3dOglGetExtSuffixes {} { return { "ARB" "EXT" "NV" "ATI" "SGI" "SGIX" "SGIS" "SUN" "WIN" "MESA" "INTEL" "IBM" "HP" } } proc tcl3dOglGetExtensions {} { set versList {} set version [string trim [glGetString GL_EXTENSIONS]] lappend versList [list GL_EXTENSIONS $version] if { [info exists ::GLU_VERSION_1_1] } { set version [string trim [gluGetString GLU_EXTENSIONS]] lappend versList [list GLU_EXTENSIONS $version] } return $versList } proc tcl3dOglGetFloatState {state {numVals 1}} { if { $numVals <= 0 } { error "Number of values must be greater than zero" } set vec [tcl3dVector GLfloat $numVals] glGetFloatv $state $vec if { $numVals == 1 } { set val [$vec get 0] } else { set val [tcl3dVectorToList $vec $numVals] } $vec delete return $val } proc tcl3dOglGetFuncList {} { return [list glAccum glAlphaFunc glAreTexturesResident glArrayElement glBegin glBindTexture glBitmap glBlendFunc glCallList glCallLists glClear glClearAccum glClearColor glClearDepth glClearIndex glClearStencil glClipPlane glColor3b glColor3bv glColor3d glColor3dv glColor3f glColor3fv glColor3i glColor3iv glColor3s glColor3sv glColor3ub glColor3ubv glColor3ui glColor3uiv glColor3us glColor3usv glColor4b glColor4bv glColor4d glColor4dv glColor4f glColor4fv glColor4i glColor4iv glColor4s glColor4sv glColor4ub glColor4ubv glColor4ui glColor4uiv glColor4us glColor4usv glColorMask glColorMaterial glColorPointer glCopyPixels glCopyTexImage1D glCopyTexImage2D glCopyTexSubImage1D glCopyTexSubImage2D glCullFace glDeleteLists glDeleteTextures glDepthFunc glDepthMask glDepthRange glDisable glDisableClientState glDrawArrays glDrawBuffer glDrawElements glDrawPixels glEdgeFlag glEdgeFlagPointer glEdgeFlagv glEnable glEnableClientState glEnd glEndList glEvalCoord1d glEvalCoord1dv glEvalCoord1f glEvalCoord1fv glEvalCoord2d glEvalCoord2dv glEvalCoord2f glEvalCoord2fv glEvalMesh1 glEvalMesh2 glEvalPoint1 glEvalPoint2 glFeedbackBuffer glFinish glFlush glFogf glFogfv glFogi glFogiv glFrontFace glFrustum glGenLists glGenTextures glGetBooleanv glGetClipPlane glGetDoublev glGetError glGetFloatv glGetIntegerv glGetLightfv glGetLightiv glGetMapdv glGetMapfv glGetMapiv glGetMaterialfv glGetMaterialiv glGetPixelMapfv glGetPixelMapuiv glGetPixelMapusv glGetPointerv glGetPolygonStipple glGetString glGetTexEnvfv glGetTexEnviv glGetTexGendv glGetTexGenfv glGetTexGeniv glGetTexImage glGetTexLevelParameterfv glGetTexLevelParameteriv glGetTexParameterfv glGetTexParameteriv glHint glIndexMask glIndexPointer glIndexd glIndexdv glIndexf glIndexfv glIndexi glIndexiv glIndexs glIndexsv glIndexub glIndexubv glInitNames glInterleavedArrays glIsEnabled glIsList glIsTexture glLightModelf glLightModelfv glLightModeli glLightModeliv glLightf glLightfv glLighti glLightiv glLineStipple glLineWidth glListBase glLoadIdentity glLoadMatrixd glLoadMatrixf glLoadName glLogicOp glMap1d glMap1f glMap2d glMap2f glMapGrid1d glMapGrid1f glMapGrid2d glMapGrid2f glMaterialf glMaterialfv glMateriali glMaterialiv glMatrixMode glMultMatrixd glMultMatrixf glNewList glNormal3b glNormal3bv glNormal3d glNormal3dv glNormal3f glNormal3fv glNormal3i glNormal3iv glNormal3s glNormal3sv glNormalPointer glOrtho glPassThrough glPixelMapfv glPixelMapuiv glPixelMapusv glPixelStoref glPixelStorei glPixelTransferf glPixelTransferi glPixelZoom glPointSize glPolygonMode glPolygonOffset glPolygonStipple glPopAttrib glPopClientAttrib glPopMatrix glPopName glPrioritizeTextures glPushAttrib glPushClientAttrib glPushMatrix glPushName glRasterPos2d glRasterPos2dv glRasterPos2f glRasterPos2fv glRasterPos2i glRasterPos2iv glRasterPos2s glRasterPos2sv glRasterPos3d glRasterPos3dv glRasterPos3f glRasterPos3fv glRasterPos3i glRasterPos3iv glRasterPos3s glRasterPos3sv glRasterPos4d glRasterPos4dv glRasterPos4f glRasterPos4fv glRasterPos4i glRasterPos4iv glRasterPos4s glRasterPos4sv glReadBuffer glReadPixels glRectd glRectdv glRectf glRectfv glRecti glRectiv glRects glRectsv glRenderMode glRotated glRotatef glScaled glScalef glScissor glSelectBuffer glShadeModel glStencilFunc glStencilMask glStencilOp glTexCoord1d glTexCoord1dv glTexCoord1f glTexCoord1fv glTexCoord1i glTexCoord1iv glTexCoord1s glTexCoord1sv glTexCoord2d glTexCoord2dv glTexCoord2f glTexCoord2fv glTexCoord2i glTexCoord2iv glTexCoord2s glTexCoord2sv glTexCoord3d glTexCoord3dv glTexCoord3f glTexCoord3fv glTexCoord3i glTexCoord3iv glTexCoord3s glTexCoord3sv glTexCoord4d glTexCoord4dv glTexCoord4f glTexCoord4fv glTexCoord4i glTexCoord4iv glTexCoord4s glTexCoord4sv glTexCoordPointer glTexEnvf glTexEnvfv glTexEnvi glTexEnviv glTexGend glTexGendv glTexGenf glTexGenfv glTexGeni glTexGeniv glTexImage1D glTexImage2D glTexParameterf glTexParameterfv glTexParameteri glTexParameteriv glTexSubImage1D glTexSubImage2D glTranslated glTranslatef glVertex2d glVertex2dv glVertex2f glVertex2fv glVertex2i glVertex2iv glVertex2s glVertex2sv glVertex3d glVertex3dv glVertex3f glVertex3fv glVertex3i glVertex3iv glVertex3s glVertex3sv glVertex4d glVertex4dv glVertex4f glVertex4fv glVertex4i glVertex4iv glVertex4s glVertex4sv glVertexPointer glViewport glCopyTexSubImage3D glDrawRangeElements glTexImage3D glTexSubImage3D glActiveTexture glClientActiveTexture glCompressedTexImage1D glCompressedTexImage2D glCompressedTexImage3D glCompressedTexSubImage1D glCompressedTexSubImage2D glCompressedTexSubImage3D glGetCompressedTexImage glLoadTransposeMatrixd glLoadTransposeMatrixf glMultTransposeMatrixd glMultTransposeMatrixf glMultiTexCoord1d glMultiTexCoord1dv glMultiTexCoord1f glMultiTexCoord1fv glMultiTexCoord1i glMultiTexCoord1iv glMultiTexCoord1s glMultiTexCoord1sv glMultiTexCoord2d glMultiTexCoord2dv glMultiTexCoord2f glMultiTexCoord2fv glMultiTexCoord2i glMultiTexCoord2iv glMultiTexCoord2s glMultiTexCoord2sv glMultiTexCoord3d glMultiTexCoord3dv glMultiTexCoord3f glMultiTexCoord3fv glMultiTexCoord3i glMultiTexCoord3iv glMultiTexCoord3s glMultiTexCoord3sv glMultiTexCoord4d glMultiTexCoord4dv glMultiTexCoord4f glMultiTexCoord4fv glMultiTexCoord4i glMultiTexCoord4iv glMultiTexCoord4s glMultiTexCoord4sv glSampleCoverage glBlendColor glBlendEquation glBlendFuncSeparate glFogCoordPointer glFogCoordd glFogCoorddv glFogCoordf glFogCoordfv glMultiDrawArrays glMultiDrawElements glPointParameterf glPointParameterfv glPointParameteri glPointParameteriv glSecondaryColor3b glSecondaryColor3bv glSecondaryColor3d glSecondaryColor3dv glSecondaryColor3f glSecondaryColor3fv glSecondaryColor3i glSecondaryColor3iv glSecondaryColor3s glSecondaryColor3sv glSecondaryColor3ub glSecondaryColor3ubv glSecondaryColor3ui glSecondaryColor3uiv glSecondaryColor3us glSecondaryColor3usv glSecondaryColorPointer glWindowPos2d glWindowPos2dv glWindowPos2f glWindowPos2fv glWindowPos2i glWindowPos2iv glWindowPos2s glWindowPos2sv glWindowPos3d glWindowPos3dv glWindowPos3f glWindowPos3fv glWindowPos3i glWindowPos3iv glWindowPos3s glWindowPos3sv glBeginQuery glBindBuffer glBufferData glBufferSubData glDeleteBuffers glDeleteQueries glEndQuery glGenBuffers glGenQueries glGetBufferParameteriv glGetBufferPointerv glGetBufferSubData glGetQueryObjectiv glGetQueryObjectuiv glGetQueryiv glIsBuffer glIsQuery glMapBuffer glUnmapBuffer glAttachShader glBindAttribLocation glBlendEquationSeparate glCompileShader glCreateProgram glCreateShader glDeleteProgram glDeleteShader glDetachShader glDisableVertexAttribArray glDrawBuffers glEnableVertexAttribArray glGetActiveAttrib glGetActiveUniform glGetAttachedShaders glGetAttribLocation glGetProgramInfoLog glGetProgramiv glGetShaderInfoLog glGetShaderSource glGetShaderiv glGetUniformLocation glGetUniformfv glGetUniformiv glGetVertexAttribPointerv glGetVertexAttribdv glGetVertexAttribfv glGetVertexAttribiv glIsProgram glIsShader glLinkProgram glShaderSource glStencilFuncSeparate glStencilMaskSeparate glStencilOpSeparate glUniform1f glUniform1fv glUniform1i glUniform1iv glUniform2f glUniform2fv glUniform2i glUniform2iv glUniform3f glUniform3fv glUniform3i glUniform3iv glUniform4f glUniform4fv glUniform4i glUniform4iv glUniformMatrix2fv glUniformMatrix3fv glUniformMatrix4fv glUseProgram glValidateProgram glVertexAttrib1d glVertexAttrib1dv glVertexAttrib1f glVertexAttrib1fv glVertexAttrib1s glVertexAttrib1sv glVertexAttrib2d glVertexAttrib2dv glVertexAttrib2f glVertexAttrib2fv glVertexAttrib2s glVertexAttrib2sv glVertexAttrib3d glVertexAttrib3dv glVertexAttrib3f glVertexAttrib3fv glVertexAttrib3s glVertexAttrib3sv glVertexAttrib4Nbv glVertexAttrib4Niv glVertexAttrib4Nsv glVertexAttrib4Nub glVertexAttrib4Nubv glVertexAttrib4Nuiv glVertexAttrib4Nusv glVertexAttrib4bv glVertexAttrib4d glVertexAttrib4dv glVertexAttrib4f glVertexAttrib4fv glVertexAttrib4iv glVertexAttrib4s glVertexAttrib4sv glVertexAttrib4ubv glVertexAttrib4uiv glVertexAttrib4usv glVertexAttribPointer glUniformMatrix2x3fv glUniformMatrix2x4fv glUniformMatrix3x2fv glUniformMatrix3x4fv glUniformMatrix4x2fv glUniformMatrix4x3fv glBeginConditionalRender glBeginTransformFeedback glBindBufferBase glBindBufferRange glBindFragDataLocation glClampColor glClearBufferfi glClearBufferfv glClearBufferiv glClearBufferuiv glColorMaski glDisablei glEnablei glEndConditionalRender glEndTransformFeedback glGetBooleani_v glGetFragDataLocation glGetIntegeri_v glGetStringi glGetTexParameterIiv glGetTexParameterIuiv glGetTransformFeedbackVarying glGetUniformuiv glGetVertexAttribIiv glGetVertexAttribIuiv glIsEnabledi glTexParameterIiv glTexParameterIuiv glTransformFeedbackVaryings glUniform1ui glUniform1uiv glUniform2ui glUniform2uiv glUniform3ui glUniform3uiv glUniform4ui glUniform4uiv glVertexAttribI1i glVertexAttribI1iv glVertexAttribI1ui glVertexAttribI1uiv glVertexAttribI2i glVertexAttribI2iv glVertexAttribI2ui glVertexAttribI2uiv glVertexAttribI3i glVertexAttribI3iv glVertexAttribI3ui glVertexAttribI3uiv glVertexAttribI4bv glVertexAttribI4i glVertexAttribI4iv glVertexAttribI4sv glVertexAttribI4ubv glVertexAttribI4ui glVertexAttribI4uiv glVertexAttribI4usv glVertexAttribIPointer glTbufferMask3DFX glDrawElementArrayAPPLE glDrawRangeElementArrayAPPLE glElementPointerAPPLE glMultiDrawElementArrayAPPLE glMultiDrawRangeElementArrayAPPLE glDeleteFencesAPPLE glFinishFenceAPPLE glFinishObjectAPPLE glGenFencesAPPLE glIsFenceAPPLE glSetFenceAPPLE glTestFenceAPPLE glTestObjectAPPLE glBufferParameteriAPPLE glFlushMappedBufferRangeAPPLE glGetTexParameterPointervAPPLE glTextureRangeAPPLE glBindVertexArrayAPPLE glDeleteVertexArraysAPPLE glGenVertexArraysAPPLE glIsVertexArrayAPPLE glFlushVertexArrayRangeAPPLE glVertexArrayParameteriAPPLE glVertexArrayRangeAPPLE glClampColorARB glDrawBuffersARB glDrawArraysInstancedARB glDrawElementsInstancedARB glBindFramebuffer glBindRenderbuffer glBlitFramebuffer glCheckFramebufferStatus glDeleteFramebuffers glDeleteRenderbuffers glFramebufferRenderbuffer glFramebufferTexturLayer glFramebufferTexture1D glFramebufferTexture2D glFramebufferTexture3D glGenFramebuffers glGenRenderbuffers glGenerateMipmap glGetFramebufferAttachmentParameteriv glGetRenderbufferParameteriv glIsFramebuffer glIsRenderbuffer glRenderbufferStorage glRenderbufferStorageMultisample glFramebufferTextureARB glFramebufferTextureFaceARB glFramebufferTextureLayerARB glProgramParameteriARB glColorSubTable glColorTable glColorTableParameterfv glColorTableParameteriv glConvolutionFilter1D glConvolutionFilter2D glConvolutionParameterf glConvolutionParameterfv glConvolutionParameteri glConvolutionParameteriv glCopyColorSubTable glCopyColorTable glCopyConvolutionFilter1D glCopyConvolutionFilter2D glGetColorTable glGetColorTableParameterfv glGetColorTableParameteriv glGetConvolutionFilter glGetConvolutionParameterfv glGetConvolutionParameteriv glGetHistogram glGetHistogramParameterfv glGetHistogramParameteriv glGetMinmax glGetMinmaxParameterfv glGetMinmaxParameteriv glGetSeparableFilter glHistogram glMinmax glResetHistogram glResetMinmax glSeparableFilter2D glVertexAttribDivisorARB glFlushMappedBufferRange glMapBufferRange glCurrentPaletteMatrixARB glMatrixIndexPointerARB glMatrixIndexubvARB glMatrixIndexuivARB glMatrixIndexusvARB glSampleCoverageARB glActiveTextureARB glClientActiveTextureARB glMultiTexCoord1dARB glMultiTexCoord1dvARB glMultiTexCoord1fARB glMultiTexCoord1fvARB glMultiTexCoord1iARB glMultiTexCoord1ivARB glMultiTexCoord1sARB glMultiTexCoord1svARB glMultiTexCoord2dARB glMultiTexCoord2dvARB glMultiTexCoord2fARB glMultiTexCoord2fvARB glMultiTexCoord2iARB glMultiTexCoord2ivARB glMultiTexCoord2sARB glMultiTexCoord2svARB glMultiTexCoord3dARB glMultiTexCoord3dvARB glMultiTexCoord3fARB glMultiTexCoord3fvARB glMultiTexCoord3iARB glMultiTexCoord3ivARB glMultiTexCoord3sARB glMultiTexCoord3svARB glMultiTexCoord4dARB glMultiTexCoord4dvARB glMultiTexCoord4fARB glMultiTexCoord4fvARB glMultiTexCoord4iARB glMultiTexCoord4ivARB glMultiTexCoord4sARB glMultiTexCoord4svARB glBeginQueryARB glDeleteQueriesARB glEndQueryARB glGenQueriesARB glGetQueryObjectivARB glGetQueryObjectuivARB glGetQueryivARB glIsQueryARB glPointParameterfARB glPointParameterfvARB glAttachObjectARB glCompileShaderARB glCreateProgramObjectARB glCreateShaderObjectARB glDeleteObjectARB glDetachObjectARB glGetActiveUniformARB glGetAttachedObjectsARB glGetHandleARB glGetInfoLogARB glGetObjectParameterfvARB glGetObjectParameterivARB glGetShaderSourceARB glGetUniformLocationARB glGetUniformfvARB glGetUniformivARB glLinkProgramARB glShaderSourceARB glUniform1fARB glUniform1fvARB glUniform1iARB glUniform1ivARB glUniform2fARB glUniform2fvARB glUniform2iARB glUniform2ivARB glUniform3fARB glUniform3fvARB glUniform3iARB glUniform3ivARB glUniform4fARB glUniform4fvARB glUniform4iARB glUniform4ivARB glUniformMatrix2fvARB glUniformMatrix3fvARB glUniformMatrix4fvARB glUseProgramObjectARB glValidateProgramARB glTexBufferARB glCompressedTexImage1DARB glCompressedTexImage2DARB glCompressedTexImage3DARB glCompressedTexSubImage1DARB glCompressedTexSubImage2DARB glCompressedTexSubImage3DARB glGetCompressedTexImageARB glLoadTransposeMatrixdARB glLoadTransposeMatrixfARB glMultTransposeMatrixdARB glMultTransposeMatrixfARB glBindVertexArray glDeleteVertexArrays glGenVertexArrays glIsVertexArray glVertexBlendARB glWeightPointerARB glWeightbvARB glWeightdvARB glWeightfvARB glWeightivARB glWeightsvARB glWeightubvARB glWeightuivARB glWeightusvARB glBindBufferARB glBufferDataARB glBufferSubDataARB glDeleteBuffersARB glGenBuffersARB glGetBufferParameterivARB glGetBufferPointervARB glGetBufferSubDataARB glIsBufferARB glMapBufferARB glUnmapBufferARB glBindProgramARB glDeleteProgramsARB glDisableVertexAttribArrayARB glEnableVertexAttribArrayARB glGenProgramsARB glGetProgramEnvParameterdvARB glGetProgramEnvParameterfvARB glGetProgramLocalParameterdvARB glGetProgramLocalParameterfvARB glGetProgramStringARB glGetProgramivARB glGetVertexAttribPointervARB glGetVertexAttribdvARB glGetVertexAttribfvARB glGetVertexAttribivARB glIsProgramARB glProgramEnvParameter4dARB glProgramEnvParameter4dvARB glProgramEnvParameter4fARB glProgramEnvParameter4fvARB glProgramLocalParameter4dARB glProgramLocalParameter4dvARB glProgramLocalParameter4fARB glProgramLocalParameter4fvARB glProgramStringARB glVertexAttrib1dARB glVertexAttrib1dvARB glVertexAttrib1fARB glVertexAttrib1fvARB glVertexAttrib1sARB glVertexAttrib1svARB glVertexAttrib2dARB glVertexAttrib2dvARB glVertexAttrib2fARB glVertexAttrib2fvARB glVertexAttrib2sARB glVertexAttrib2svARB glVertexAttrib3dARB glVertexAttrib3dvARB glVertexAttrib3fARB glVertexAttrib3fvARB glVertexAttrib3sARB glVertexAttrib3svARB glVertexAttrib4NbvARB glVertexAttrib4NivARB glVertexAttrib4NsvARB glVertexAttrib4NubARB glVertexAttrib4NubvARB glVertexAttrib4NuivARB glVertexAttrib4NusvARB glVertexAttrib4bvARB glVertexAttrib4dARB glVertexAttrib4dvARB glVertexAttrib4fARB glVertexAttrib4fvARB glVertexAttrib4ivARB glVertexAttrib4sARB glVertexAttrib4svARB glVertexAttrib4ubvARB glVertexAttrib4uivARB glVertexAttrib4usvARB glVertexAttribPointerARB glBindAttribLocationARB glGetActiveAttribARB glGetAttribLocationARB glWindowPos2dARB glWindowPos2dvARB glWindowPos2fARB glWindowPos2fvARB glWindowPos2iARB glWindowPos2ivARB glWindowPos2sARB glWindowPos2svARB glWindowPos3dARB glWindowPos3dvARB glWindowPos3fARB glWindowPos3fvARB glWindowPos3iARB glWindowPos3ivARB glWindowPos3sARB glWindowPos3svARB glDrawBuffersATI glDrawElementArrayATI glDrawRangeElementArrayATI glElementPointerATI glGetTexBumpParameterfvATI glGetTexBumpParameterivATI glTexBumpParameterfvATI glTexBumpParameterivATI glAlphaFragmentOp1ATI glAlphaFragmentOp2ATI glAlphaFragmentOp3ATI glBeginFragmentShaderATI glBindFragmentShaderATI glColorFragmentOp1ATI glColorFragmentOp2ATI glColorFragmentOp3ATI glDeleteFragmentShaderATI glEndFragmentShaderATI glGenFragmentShadersATI glPassTexCoordATI glSampleMapATI glSetFragmentShaderConstantATI glMapObjectBufferATI glUnmapObjectBufferATI glPNTrianglesfATI glPNTrianglesiATI glStencilFuncSeparateATI glStencilOpSeparateATI glArrayObjectATI glFreeObjectBufferATI glGetArrayObjectfvATI glGetArrayObjectivATI glGetObjectBufferfvATI glGetObjectBufferivATI glGetVariantArrayObjectfvATI glGetVariantArrayObjectivATI glIsObjectBufferATI glNewObjectBufferATI glUpdateObjectBufferATI glVariantArrayObjectATI glGetVertexAttribArrayObjectfvATI glGetVertexAttribArrayObjectivATI glVertexAttribArrayObjectATI glClientActiveVertexStreamATI glNormalStream3bATI glNormalStream3bvATI glNormalStream3dATI glNormalStream3dvATI glNormalStream3fATI glNormalStream3fvATI glNormalStream3iATI glNormalStream3ivATI glNormalStream3sATI glNormalStream3svATI glVertexBlendEnvfATI glVertexBlendEnviATI glVertexStream2dATI glVertexStream2dvATI glVertexStream2fATI glVertexStream2fvATI glVertexStream2iATI glVertexStream2ivATI glVertexStream2sATI glVertexStream2svATI glVertexStream3dATI glVertexStream3dvATI glVertexStream3fATI glVertexStream3fvATI glVertexStream3iATI glVertexStream3ivATI glVertexStream3sATI glVertexStream3svATI glVertexStream4dATI glVertexStream4dvATI glVertexStream4fATI glVertexStream4fvATI glVertexStream4iATI glVertexStream4ivATI glVertexStream4sATI glVertexStream4svATI glGetUniformBufferSizeEXT glGetUniformOffsetEXT glUniformBufferEXT glBlendColorEXT glBlendEquationSeparateEXT glBlendFuncSeparateEXT glBlendEquationEXT glColorSubTableEXT glCopyColorSubTableEXT glLockArraysEXT glUnlockArraysEXT glConvolutionFilter1DEXT glConvolutionFilter2DEXT glConvolutionParameterfEXT glConvolutionParameterfvEXT glConvolutionParameteriEXT glConvolutionParameterivEXT glCopyConvolutionFilter1DEXT glCopyConvolutionFilter2DEXT glGetConvolutionFilterEXT glGetConvolutionParameterfvEXT glGetConvolutionParameterivEXT glGetSeparableFilterEXT glSeparableFilter2DEXT glBinormalPointerEXT glTangentPointerEXT glCopyTexImage1DEXT glCopyTexImage2DEXT glCopyTexSubImage1DEXT glCopyTexSubImage2DEXT glCopyTexSubImage3DEXT glCullParameterdvEXT glCullParameterfvEXT glDepthBoundsEXT glBindMultiTextureEXT glCheckNamedFramebufferStatusEXT glClientAttribDefaultEXT glCompressedMultiTexImage1DEXT glCompressedMultiTexImage2DEXT glCompressedMultiTexImage3DEXT glCompressedMultiTexSubImage1DEXT glCompressedMultiTexSubImage2DEXT glCompressedMultiTexSubImage3DEXT glCompressedTextureImage1DEXT glCompressedTextureImage2DEXT glCompressedTextureImage3DEXT glCompressedTextureSubImage1DEXT glCompressedTextureSubImage2DEXT glCompressedTextureSubImage3DEXT glCopyMultiTexImage1DEXT glCopyMultiTexImage2DEXT glCopyMultiTexSubImage1DEXT glCopyMultiTexSubImage2DEXT glCopyMultiTexSubImage3DEXT glCopyTextureImage1DEXT glCopyTextureImage2DEXT glCopyTextureSubImage1DEXT glCopyTextureSubImage2DEXT glCopyTextureSubImage3DEXT glDisableClientStateIndexedEXT glEnableClientStateIndexedEXT glFramebufferDrawBufferEXT glFramebufferDrawBuffersEXT glFramebufferReadBufferEXT glGenerateMultiTexMipmapEXT glGenerateTextureMipmapEXT glGetCompressedMultiTexImageEXT glGetCompressedTextureImageEXT glGetDoubleIndexedvEXT glGetFloatIndexedvEXT glGetFramebufferParameterivEXT glGetMultiTexEnvfvEXT glGetMultiTexEnvivEXT glGetMultiTexGendvEXT glGetMultiTexGenfvEXT glGetMultiTexGenivEXT glGetMultiTexImageEXT glGetMultiTexLevelParameterfvEXT glGetMultiTexLevelParameterivEXT glGetMultiTexParameterIivEXT glGetMultiTexParameterIuivEXT glGetMultiTexParameterfvEXT glGetMultiTexParameterivEXT glGetNamedBufferParameterivEXT glGetNamedBufferPointervEXT glGetNamedBufferSubDataEXT glGetNamedFramebufferAttachmentParameterivEXT glGetNamedProgramLocalParameterIivEXT glGetNamedProgramLocalParameterIuivEXT glGetNamedProgramLocalParameterdvEXT glGetNamedProgramLocalParameterfvEXT glGetNamedProgramStringEXT glGetNamedProgramivEXT glGetNamedRenderbufferParameterivEXT glGetPointerIndexedvEXT glGetTextureImageEXT glGetTextureLevelParameterfvEXT glGetTextureLevelParameterivEXT glGetTextureParameterIivEXT glGetTextureParameterIuivEXT glGetTextureParameterfvEXT glGetTextureParameterivEXT glMapNamedBufferEXT glMatrixFrustumEXT glMatrixLoadIdentityEXT glMatrixLoadTransposedEXT glMatrixLoadTransposefEXT glMatrixLoaddEXT glMatrixLoadfEXT glMatrixMultTransposedEXT glMatrixMultTransposefEXT glMatrixMultdEXT glMatrixMultfEXT glMatrixOrthoEXT glMatrixPopEXT glMatrixPushEXT glMatrixRotatedEXT glMatrixRotatefEXT glMatrixScaledEXT glMatrixScalefEXT glMatrixTranslatedEXT glMatrixTranslatefEXT glMultiTexBufferEXT glMultiTexCoordPointerEXT glMultiTexEnvfEXT glMultiTexEnvfvEXT glMultiTexEnviEXT glMultiTexEnvivEXT glMultiTexGendEXT glMultiTexGendvEXT glMultiTexGenfEXT glMultiTexGenfvEXT glMultiTexGeniEXT glMultiTexGenivEXT glMultiTexImage1DEXT glMultiTexImage2DEXT glMultiTexImage3DEXT glMultiTexParameterIivEXT glMultiTexParameterIuivEXT glMultiTexParameterfEXT glMultiTexParameterfvEXT glMultiTexParameteriEXT glMultiTexParameterivEXT glMultiTexRenderbufferEXT glMultiTexSubImage1DEXT glMultiTexSubImage2DEXT glMultiTexSubImage3DEXT glNamedBufferDataEXT glNamedBufferSubDataEXT glNamedFramebufferRenderbufferEXT glNamedFramebufferTexture1DEXT glNamedFramebufferTexture2DEXT glNamedFramebufferTexture3DEXT glNamedFramebufferTextureEXT glNamedFramebufferTextureFaceEXT glNamedFramebufferTextureLayerEXT glNamedProgramLocalParameter4dEXT glNamedProgramLocalParameter4dvEXT glNamedProgramLocalParameter4fEXT glNamedProgramLocalParameter4fvEXT glNamedProgramLocalParameterI4iEXT glNamedProgramLocalParameterI4ivEXT glNamedProgramLocalParameterI4uiEXT glNamedProgramLocalParameterI4uivEXT glNamedProgramLocalParameters4fvEXT glNamedProgramLocalParametersI4ivEXT glNamedProgramLocalParametersI4uivEXT glNamedProgramStringEXT glNamedRenderbufferStorageEXT glNamedRenderbufferStorageMultisampleCoverageEXT glNamedRenderbufferStorageMultisampleEXT glProgramUniform1fEXT glProgramUniform1fvEXT glProgramUniform1iEXT glProgramUniform1ivEXT glProgramUniform1uiEXT glProgramUniform1uivEXT glProgramUniform2fEXT glProgramUniform2fvEXT glProgramUniform2iEXT glProgramUniform2ivEXT glProgramUniform2uiEXT glProgramUniform2uivEXT glProgramUniform3fEXT glProgramUniform3fvEXT glProgramUniform3iEXT glProgramUniform3ivEXT glProgramUniform3uiEXT glProgramUniform3uivEXT glProgramUniform4fEXT glProgramUniform4fvEXT glProgramUniform4iEXT glProgramUniform4ivEXT glProgramUniform4uiEXT glProgramUniform4uivEXT glProgramUniformMatrix2fvEXT glProgramUniformMatrix2x3fvEXT glProgramUniformMatrix2x4fvEXT glProgramUniformMatrix3fvEXT glProgramUniformMatrix3x2fvEXT glProgramUniformMatrix3x4fvEXT glProgramUniformMatrix4fvEXT glProgramUniformMatrix4x2fvEXT glProgramUniformMatrix4x3fvEXT glPushClientAttribDefaultEXT glTextureBufferEXT glTextureImage1DEXT glTextureImage2DEXT glTextureImage3DEXT glTextureParameterIivEXT glTextureParameterIuivEXT glTextureParameterfEXT glTextureParameterfvEXT glTextureParameteriEXT glTextureParameterivEXT glTextureRenderbufferEXT glTextureSubImage1DEXT glTextureSubImage2DEXT glTextureSubImage3DEXT glUnmapNamedBufferEXT glColorMaskIndexedEXT glDisableIndexedEXT glEnableIndexedEXT glGetBooleanIndexedvEXT glGetIntegerIndexedvEXT glIsEnabledIndexedEXT glDrawArraysInstancedEXT glDrawElementsInstancedEXT glDrawRangeElementsEXT glFogCoordPointerEXT glFogCoorddEXT glFogCoorddvEXT glFogCoordfEXT glFogCoordfvEXT glFragmentColorMaterialEXT glFragmentLightModelfEXT glFragmentLightModelfvEXT glFragmentLightModeliEXT glFragmentLightModelivEXT glFragmentLightfEXT glFragmentLightfvEXT glFragmentLightiEXT glFragmentLightivEXT glFragmentMaterialfEXT glFragmentMaterialfvEXT glFragmentMaterialiEXT glFragmentMaterialivEXT glGetFragmentLightfvEXT glGetFragmentLightivEXT glGetFragmentMaterialfvEXT glGetFragmentMaterialivEXT glLightEnviEXT glBlitFramebufferEXT glRenderbufferStorageMultisampleEXT glBindFramebufferEXT glBindRenderbufferEXT glCheckFramebufferStatusEXT glDeleteFramebuffersEXT glDeleteRenderbuffersEXT glFramebufferRenderbufferEXT glFramebufferTexture1DEXT glFramebufferTexture2DEXT glFramebufferTexture3DEXT glGenFramebuffersEXT glGenRenderbuffersEXT glGenerateMipmapEXT glGetFramebufferAttachmentParameterivEXT glGetRenderbufferParameterivEXT glIsFramebufferEXT glIsRenderbufferEXT glRenderbufferStorageEXT glFramebufferTextureEXT glFramebufferTextureFaceEXT glFramebufferTextureLayerEXT glProgramParameteriEXT glProgramEnvParameters4fvEXT glProgramLocalParameters4fvEXT glBindFragDataLocationEXT glGetFragDataLocationEXT glGetUniformuivEXT glGetVertexAttribIivEXT glGetVertexAttribIuivEXT glUniform1uiEXT glUniform1uivEXT glUniform2uiEXT glUniform2uivEXT glUniform3uiEXT glUniform3uivEXT glUniform4uiEXT glUniform4uivEXT glVertexAttribI1iEXT glVertexAttribI1ivEXT glVertexAttribI1uiEXT glVertexAttribI1uivEXT glVertexAttribI2iEXT glVertexAttribI2ivEXT glVertexAttribI2uiEXT glVertexAttribI2uivEXT glVertexAttribI3iEXT glVertexAttribI3ivEXT glVertexAttribI3uiEXT glVertexAttribI3uivEXT glVertexAttribI4bvEXT glVertexAttribI4iEXT glVertexAttribI4ivEXT glVertexAttribI4svEXT glVertexAttribI4ubvEXT glVertexAttribI4uiEXT glVertexAttribI4uivEXT glVertexAttribI4usvEXT glVertexAttribIPointerEXT glGetHistogramEXT glGetHistogramParameterfvEXT glGetHistogramParameterivEXT glGetMinmaxEXT glGetMinmaxParameterfvEXT glGetMinmaxParameterivEXT glHistogramEXT glMinmaxEXT glResetHistogramEXT glResetMinmaxEXT glIndexFuncEXT glIndexMaterialEXT glApplyTextureEXT glTextureLightEXT glTextureMaterialEXT glMultiDrawArraysEXT glMultiDrawElementsEXT glSampleMaskEXT glSamplePatternEXT glColorTableEXT glGetColorTableEXT glGetColorTableParameterfvEXT glGetColorTableParameterivEXT glGetPixelTransformParameterfvEXT glGetPixelTransformParameterivEXT glPixelTransformParameterfEXT glPixelTransformParameterfvEXT glPixelTransformParameteriEXT glPixelTransformParameterivEXT glPointParameterfEXT glPointParameterfvEXT glPolygonOffsetEXT glBeginSceneEXT glEndSceneEXT glSecondaryColor3bEXT glSecondaryColor3bvEXT glSecondaryColor3dEXT glSecondaryColor3dvEXT glSecondaryColor3fEXT glSecondaryColor3fvEXT glSecondaryColor3iEXT glSecondaryColor3ivEXT glSecondaryColor3sEXT glSecondaryColor3svEXT glSecondaryColor3ubEXT glSecondaryColor3ubvEXT glSecondaryColor3uiEXT glSecondaryColor3uivEXT glSecondaryColor3usEXT glSecondaryColor3usvEXT glSecondaryColorPointerEXT glActiveStencilFaceEXT glTexSubImage1DEXT glTexSubImage2DEXT glTexSubImage3DEXT glTexImage3DEXT glTexBufferEXT glClearColorIiEXT glClearColorIuiEXT glGetTexParameterIivEXT glGetTexParameterIuivEXT glTexParameterIivEXT glTexParameterIuivEXT glAreTexturesResidentEXT glBindTextureEXT glDeleteTexturesEXT glGenTexturesEXT glIsTextureEXT glPrioritizeTexturesEXT glTextureNormalEXT glGetQueryObjecti64vEXT glGetQueryObjectui64vEXT glBeginTransformFeedbackEXT glBindBufferBaseEXT glBindBufferOffsetEXT glBindBufferRangeEXT glEndTransformFeedbackEXT glGetTransformFeedbackVaryingEXT glTransformFeedbackVaryingsEXT glArrayElementEXT glColorPointerEXT glDrawArraysEXT glEdgeFlagPointerEXT glGetPointervEXT glIndexPointerEXT glNormalPointerEXT glTexCoordPointerEXT glVertexPointerEXT glBeginVertexShaderEXT glBindLightParameterEXT glBindMaterialParameterEXT glBindParameterEXT glBindTexGenParameterEXT glBindTextureUnitParameterEXT glBindVertexShaderEXT glDeleteVertexShaderEXT glDisableVariantClientStateEXT glEnableVariantClientStateEXT glEndVertexShaderEXT glExtractComponentEXT glGenSymbolsEXT glGenVertexShadersEXT glGetInvariantBooleanvEXT glGetInvariantFloatvEXT glGetInvariantIntegervEXT glGetLocalConstantBooleanvEXT glGetLocalConstantFloatvEXT glGetLocalConstantIntegervEXT glGetVariantBooleanvEXT glGetVariantFloatvEXT glGetVariantIntegervEXT glGetVariantPointervEXT glInsertComponentEXT glIsVariantEnabledEXT glSetInvariantEXT glSetLocalConstantEXT glShaderOp1EXT glShaderOp2EXT glShaderOp3EXT glSwizzleEXT glVariantPointerEXT glVariantbvEXT glVariantdvEXT glVariantfvEXT glVariantivEXT glVariantsvEXT glVariantubvEXT glVariantuivEXT glVariantusvEXT glWriteMaskEXT glVertexWeightPointerEXT glVertexWeightfEXT glVertexWeightfvEXT glFrameTerminatorGREMEDY glStringMarkerGREMEDY glGetImageTransformParameterfvHP glGetImageTransformParameterivHP glImageTransformParameterfHP glImageTransformParameterfvHP glImageTransformParameteriHP glImageTransformParameterivHP glMultiModeDrawArraysIBM glMultiModeDrawElementsIBM glColorPointerListIBM glEdgeFlagPointerListIBM glFogCoordPointerListIBM glIndexPointerListIBM glNormalPointerListIBM glSecondaryColorPointerListIBM glTexCoordPointerListIBM glVertexPointerListIBM glColorPointervINTEL glNormalPointervINTEL glTexCoordPointervINTEL glVertexPointervINTEL glTexScissorFuncINTEL glTexScissorINTEL glBufferRegionEnabledEXT glDeleteBufferRegionEXT glDrawBufferRegionEXT glNewBufferRegionEXT glReadBufferRegionEXT glResizeBuffersMESA glWindowPos2dMESA glWindowPos2dvMESA glWindowPos2fMESA glWindowPos2fvMESA glWindowPos2iMESA glWindowPos2ivMESA glWindowPos2sMESA glWindowPos2svMESA glWindowPos3dMESA glWindowPos3dvMESA glWindowPos3fMESA glWindowPos3fvMESA glWindowPos3iMESA glWindowPos3ivMESA glWindowPos3sMESA glWindowPos3svMESA glWindowPos4dMESA glWindowPos4dvMESA glWindowPos4fMESA glWindowPos4fvMESA glWindowPos4iMESA glWindowPos4ivMESA glWindowPos4sMESA glWindowPos4svMESA glBeginConditionalRenderNV glEndConditionalRenderNV glClearDepthdNV glDepthBoundsdNV glDepthRangedNV glEvalMapsNV glGetMapAttribParameterfvNV glGetMapAttribParameterivNV glGetMapControlPointsNV glGetMapParameterfvNV glGetMapParameterivNV glMapControlPointsNV glMapParameterfvNV glMapParameterivNV glGetMultisamplefvNV glSampleMaskIndexedNV glTexRenderbufferNV glDeleteFencesNV glFinishFenceNV glGenFencesNV glGetFenceivNV glIsFenceNV glSetFenceNV glTestFenceNV glGetProgramNamedParameterdvNV glGetProgramNamedParameterfvNV glProgramNamedParameter4dNV glProgramNamedParameter4dvNV glProgramNamedParameter4fNV glProgramNamedParameter4fvNV glRenderbufferStorageMultisampleCoverageNV glProgramVertexLimitNV glProgramEnvParameterI4iNV glProgramEnvParameterI4ivNV glProgramEnvParameterI4uiNV glProgramEnvParameterI4uivNV glProgramEnvParametersI4ivNV glProgramEnvParametersI4uivNV glProgramLocalParameterI4iNV glProgramLocalParameterI4ivNV glProgramLocalParameterI4uiNV glProgramLocalParameterI4uivNV glProgramLocalParametersI4ivNV glProgramLocalParametersI4uivNV glColor3hNV glColor3hvNV glColor4hNV glColor4hvNV glFogCoordhNV glFogCoordhvNV glMultiTexCoord1hNV glMultiTexCoord1hvNV glMultiTexCoord2hNV glMultiTexCoord2hvNV glMultiTexCoord3hNV glMultiTexCoord3hvNV glMultiTexCoord4hNV glMultiTexCoord4hvNV glNormal3hNV glNormal3hvNV glSecondaryColor3hNV glSecondaryColor3hvNV glTexCoord1hNV glTexCoord1hvNV glTexCoord2hNV glTexCoord2hvNV glTexCoord3hNV glTexCoord3hvNV glTexCoord4hNV glTexCoord4hvNV glVertex2hNV glVertex2hvNV glVertex3hNV glVertex3hvNV glVertex4hNV glVertex4hvNV glVertexAttrib1hNV glVertexAttrib1hvNV glVertexAttrib2hNV glVertexAttrib2hvNV glVertexAttrib3hNV glVertexAttrib3hvNV glVertexAttrib4hNV glVertexAttrib4hvNV glVertexAttribs1hvNV glVertexAttribs2hvNV glVertexAttribs3hvNV glVertexAttribs4hvNV glVertexWeighthNV glVertexWeighthvNV glBeginOcclusionQueryNV glDeleteOcclusionQueriesNV glEndOcclusionQueryNV glGenOcclusionQueriesNV glGetOcclusionQueryivNV glGetOcclusionQueryuivNV glIsOcclusionQueryNV glProgramBufferParametersIivNV glProgramBufferParametersIuivNV glProgramBufferParametersfvNV glFlushPixelDataRangeNV glPixelDataRangeNV glPointParameteriNV glPointParameterivNV glGetVideoi64vNV glGetVideoivNV glGetVideoui64vNV glGetVideouivNV glPresentFrameDualFillNV glPresentFrameKeyedNV glVideoParameterivNV glPrimitiveRestartIndexNV glPrimitiveRestartNV glCombinerInputNV glCombinerOutputNV glCombinerParameterfNV glCombinerParameterfvNV glCombinerParameteriNV glCombinerParameterivNV glFinalCombinerInputNV glGetCombinerInputParameterfvNV glGetCombinerInputParameterivNV glGetCombinerOutputParameterfvNV glGetCombinerOutputParameterivNV glGetFinalCombinerInputParameterfvNV glGetFinalCombinerInputParameterivNV glCombinerStageParameterfvNV glGetCombinerStageParameterfvNV glActiveVaryingNV glBeginTransformFeedbackNV glBindBufferBaseNV glBindBufferOffsetNV glBindBufferRangeNV glEndTransformFeedbackNV glGetActiveVaryingNV glGetTransformFeedbackVaryingNV glGetVaryingLocationNV glTransformFeedbackAttribsNV glTransformFeedbackVaryingsNV glFlushVertexArrayRangeNV glVertexArrayRangeNV glAreProgramsResidentNV glBindProgramNV glDeleteProgramsNV glExecuteProgramNV glGenProgramsNV glGetProgramParameterdvNV glGetProgramParameterfvNV glGetProgramStringNV glGetProgramivNV glGetTrackMatrixivNV glGetVertexAttribPointervNV glGetVertexAttribdvNV glGetVertexAttribfvNV glGetVertexAttribivNV glIsProgramNV glLoadProgramNV glProgramParameter4dNV glProgramParameter4dvNV glProgramParameter4fNV glProgramParameter4fvNV glProgramParameters4dvNV glProgramParameters4fvNV glRequestResidentProgramsNV glTrackMatrixNV glVertexAttrib1dNV glVertexAttrib1dvNV glVertexAttrib1fNV glVertexAttrib1fvNV glVertexAttrib1sNV glVertexAttrib1svNV glVertexAttrib2dNV glVertexAttrib2dvNV glVertexAttrib2fNV glVertexAttrib2fvNV glVertexAttrib2sNV glVertexAttrib2svNV glVertexAttrib3dNV glVertexAttrib3dvNV glVertexAttrib3fNV glVertexAttrib3fvNV glVertexAttrib3sNV glVertexAttrib3svNV glVertexAttrib4dNV glVertexAttrib4dvNV glVertexAttrib4fNV glVertexAttrib4fvNV glVertexAttrib4sNV glVertexAttrib4svNV glVertexAttrib4ubNV glVertexAttrib4ubvNV glVertexAttribPointerNV glVertexAttribs1dvNV glVertexAttribs1fvNV glVertexAttribs1svNV glVertexAttribs2dvNV glVertexAttribs2fvNV glVertexAttribs2svNV glVertexAttribs3dvNV glVertexAttribs3fvNV glVertexAttribs3svNV glVertexAttribs4dvNV glVertexAttribs4fvNV glVertexAttribs4svNV glVertexAttribs4ubvNV glClearDepthfOES glClipPlanefOES glDepthRangefOES glFrustumfOES glGetClipPlanefOES glOrthofOES glDetailTexFuncSGIS glGetDetailTexFuncSGIS glFogFuncSGIS glGetFogFuncSGIS glSampleMaskSGIS glSamplePatternSGIS glGetSharpenTexFuncSGIS glSharpenTexFuncSGIS glTexImage4DSGIS glTexSubImage4DSGIS glGetTexFilterFuncSGIS glTexFilterFuncSGIS glAsyncMarkerSGIX glDeleteAsyncMarkersSGIX glFinishAsyncSGIX glGenAsyncMarkersSGIX glIsAsyncMarkerSGIX glPollAsyncSGIX glFlushRasterSGIX glTextureFogSGIX glFragmentColorMaterialSGIX glFragmentLightModelfSGIX glFragmentLightModelfvSGIX glFragmentLightModeliSGIX glFragmentLightModelivSGIX glFragmentLightfSGIX glFragmentLightfvSGIX glFragmentLightiSGIX glFragmentLightivSGIX glFragmentMaterialfSGIX glFragmentMaterialfvSGIX glFragmentMaterialiSGIX glFragmentMaterialivSGIX glGetFragmentLightfvSGIX glGetFragmentLightivSGIX glGetFragmentMaterialfvSGIX glGetFragmentMaterialivSGIX glFrameZoomSGIX glPixelTexGenSGIX glReferencePlaneSGIX glSpriteParameterfSGIX glSpriteParameterfvSGIX glSpriteParameteriSGIX glSpriteParameterivSGIX glTagSampleBufferSGIX glColorTableParameterfvSGI glColorTableParameterivSGI glColorTableSGI glCopyColorTableSGI glGetColorTableParameterfvSGI glGetColorTableParameterivSGI glGetColorTableSGI glFinishTextureSUNX glGlobalAlphaFactorbSUN glGlobalAlphaFactordSUN glGlobalAlphaFactorfSUN glGlobalAlphaFactoriSUN glGlobalAlphaFactorsSUN glGlobalAlphaFactorubSUN glGlobalAlphaFactoruiSUN glGlobalAlphaFactorusSUN glReadVideoPixelsSUN glReplacementCodePointerSUN glReplacementCodeubSUN glReplacementCodeubvSUN glReplacementCodeuiSUN glReplacementCodeuivSUN glReplacementCodeusSUN glReplacementCodeusvSUN glColor3fVertex3fSUN glColor3fVertex3fvSUN glColor4fNormal3fVertex3fSUN glColor4fNormal3fVertex3fvSUN glColor4ubVertex2fSUN glColor4ubVertex2fvSUN glColor4ubVertex3fSUN glColor4ubVertex3fvSUN glNormal3fVertex3fSUN glNormal3fVertex3fvSUN glReplacementCodeuiColor3fVertex3fSUN glReplacementCodeuiColor3fVertex3fvSUN glReplacementCodeuiColor4fNormal3fVertex3fSUN glReplacementCodeuiColor4fNormal3fVertex3fvSUN glReplacementCodeuiColor4ubVertex3fSUN glReplacementCodeuiColor4ubVertex3fvSUN glReplacementCodeuiNormal3fVertex3fSUN glReplacementCodeuiNormal3fVertex3fvSUN glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN glReplacementCodeuiTexCoord2fVertex3fSUN glReplacementCodeuiTexCoord2fVertex3fvSUN glReplacementCodeuiVertex3fSUN glReplacementCodeuiVertex3fvSUN glTexCoord2fColor3fVertex3fSUN glTexCoord2fColor3fVertex3fvSUN glTexCoord2fColor4fNormal3fVertex3fSUN glTexCoord2fColor4fNormal3fVertex3fvSUN glTexCoord2fColor4ubVertex3fSUN glTexCoord2fColor4ubVertex3fvSUN glTexCoord2fNormal3fVertex3fSUN glTexCoord2fNormal3fVertex3fvSUN glTexCoord2fVertex3fSUN glTexCoord2fVertex3fvSUN glTexCoord4fColor4fNormal3fVertex4fSUN glTexCoord4fColor4fNormal3fVertex4fvSUN glTexCoord4fVertex4fSUN glTexCoord4fVertex4fvSUN glAddSwapHintRectWIN ] } proc tcl3dOglGetFuncSignatureList {} { return [list "void glAccum (GLenum op, GLfloat value)" "void glAlphaFunc (GLenum func, GLclampf ref)" "GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)" "void glArrayElement (GLint i)" "void glBegin (GLenum mode)" "void glBindTexture (GLenum target, GLuint texture)" "void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)" "void glBlendFunc (GLenum sfactor, GLenum dfactor)" "void glCallList (GLuint list)" "void glCallLists (GLsizei n, GLenum type, const GLvoid *lists)" "void glClear (GLbitfield mask)" "void glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)" "void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)" "void glClearDepth (GLclampd depth)" "void glClearIndex (GLfloat c)" "void glClearStencil (GLint s)" "void glClipPlane (GLenum plane, const GLdouble *equation)" "void glColor3b (GLbyte red, GLbyte green, GLbyte blue)" "void glColor3bv (const GLbyte *v)" "void glColor3d (GLdouble red, GLdouble green, GLdouble blue)" "void glColor3dv (const GLdouble *v)" "void glColor3f (GLfloat red, GLfloat green, GLfloat blue)" "void glColor3fv (const GLfloat *v)" "void glColor3i (GLint red, GLint green, GLint blue)" "void glColor3iv (const GLint *v)" "void glColor3s (GLshort red, GLshort green, GLshort blue)" "void glColor3sv (const GLshort *v)" "void glColor3ub (GLubyte red, GLubyte green, GLubyte blue)" "void glColor3ubv (const GLubyte *v)" "void glColor3ui (GLuint red, GLuint green, GLuint blue)" "void glColor3uiv (const GLuint *v)" "void glColor3us (GLushort red, GLushort green, GLushort blue)" "void glColor3usv (const GLushort *v)" "void glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)" "void glColor4bv (const GLbyte *v)" "void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)" "void glColor4dv (const GLdouble *v)" "void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)" "void glColor4fv (const GLfloat *v)" "void glColor4i (GLint red, GLint green, GLint blue, GLint alpha)" "void glColor4iv (const GLint *v)" "void glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha)" "void glColor4sv (const GLshort *v)" "void glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)" "void glColor4ubv (const GLubyte *v)" "void glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)" "void glColor4uiv (const GLuint *v)" "void glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)" "void glColor4usv (const GLushort *v)" "void glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)" "void glColorMaterial (GLenum face, GLenum mode)" "void glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)" "void glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)" "void glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)" "void glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)" "void glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)" "void glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCullFace (GLenum mode)" "void glDeleteLists (GLuint list, GLsizei range)" "void glDeleteTextures (GLsizei n, const GLuint *textures)" "void glDepthFunc (GLenum func)" "void glDepthMask (GLboolean flag)" "void glDepthRange (GLclampd zNear, GLclampd zFar)" "void glDisable (GLenum cap)" "void glDisableClientState (GLenum array)" "void glDrawArrays (GLenum mode, GLint first, GLsizei count)" "void glDrawBuffer (GLenum mode)" "void glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)" "void glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)" "void glEdgeFlag (GLboolean flag)" "void glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer)" "void glEdgeFlagv (const GLboolean *flag)" "void glEnable (GLenum cap)" "void glEnableClientState (GLenum array)" "void glEnd (void)" "void glEndList (void)" "void glEvalCoord1d (GLdouble u)" "void glEvalCoord1dv (const GLdouble *u)" "void glEvalCoord1f (GLfloat u)" "void glEvalCoord1fv (const GLfloat *u)" "void glEvalCoord2d (GLdouble u, GLdouble v)" "void glEvalCoord2dv (const GLdouble *u)" "void glEvalCoord2f (GLfloat u, GLfloat v)" "void glEvalCoord2fv (const GLfloat *u)" "void glEvalMesh1 (GLenum mode, GLint i1, GLint i2)" "void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)" "void glEvalPoint1 (GLint i)" "void glEvalPoint2 (GLint i, GLint j)" "void glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)" "void glFinish (void)" "void glFlush (void)" "void glFogf (GLenum pname, GLfloat param)" "void glFogfv (GLenum pname, const GLfloat *params)" "void glFogi (GLenum pname, GLint param)" "void glFogiv (GLenum pname, const GLint *params)" "void glFrontFace (GLenum mode)" "void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)" "GLuint glGenLists (GLsizei range)" "void glGenTextures (GLsizei n, GLuint *textures)" "void glGetBooleanv (GLenum pname, GLboolean *params)" "void glGetClipPlane (GLenum plane, GLdouble *equation)" "void glGetDoublev (GLenum pname, GLdouble *params)" "GLenum glGetError (void)" "void glGetFloatv (GLenum pname, GLfloat *params)" "void glGetIntegerv (GLenum pname, GLint *params)" "void glGetLightfv (GLenum light, GLenum pname, GLfloat *params)" "void glGetLightiv (GLenum light, GLenum pname, GLint *params)" "void glGetMapdv (GLenum target, GLenum query, GLdouble *v)" "void glGetMapfv (GLenum target, GLenum query, GLfloat *v)" "void glGetMapiv (GLenum target, GLenum query, GLint *v)" "void glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)" "void glGetMaterialiv (GLenum face, GLenum pname, GLint *params)" "void glGetPixelMapfv (GLenum map, GLfloat *values)" "void glGetPixelMapuiv (GLenum map, GLuint *values)" "void glGetPixelMapusv (GLenum map, GLushort *values)" "void glGetPointerv (GLenum pname, GLvoid* *params)" "void glGetPolygonStipple (GLubyte *mask)" "const GLubyte * glGetString (GLenum name)" "void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetTexEnviv (GLenum target, GLenum pname, GLint *params)" "void glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params)" "void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params)" "void glGetTexGeniv (GLenum coord, GLenum pname, GLint *params)" "void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)" "void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)" "void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)" "void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params)" "void glHint (GLenum target, GLenum mode)" "void glIndexMask (GLuint mask)" "void glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer)" "void glIndexd (GLdouble c)" "void glIndexdv (const GLdouble *c)" "void glIndexf (GLfloat c)" "void glIndexfv (const GLfloat *c)" "void glIndexi (GLint c)" "void glIndexiv (const GLint *c)" "void glIndexs (GLshort c)" "void glIndexsv (const GLshort *c)" "void glIndexub (GLubyte c)" "void glIndexubv (const GLubyte *c)" "void glInitNames (void)" "void glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer)" "GLboolean glIsEnabled (GLenum cap)" "GLboolean glIsList (GLuint list)" "GLboolean glIsTexture (GLuint texture)" "void glLightModelf (GLenum pname, GLfloat param)" "void glLightModelfv (GLenum pname, const GLfloat *params)" "void glLightModeli (GLenum pname, GLint param)" "void glLightModeliv (GLenum pname, const GLint *params)" "void glLightf (GLenum light, GLenum pname, GLfloat param)" "void glLightfv (GLenum light, GLenum pname, const GLfloat *params)" "void glLighti (GLenum light, GLenum pname, GLint param)" "void glLightiv (GLenum light, GLenum pname, const GLint *params)" "void glLineStipple (GLint factor, GLushort pattern)" "void glLineWidth (GLfloat width)" "void glListBase (GLuint base)" "void glLoadIdentity (void)" "void glLoadMatrixd (const GLdouble *m)" "void glLoadMatrixf (const GLfloat *m)" "void glLoadName (GLuint name)" "void glLogicOp (GLenum opcode)" "void glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)" "void glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)" "void glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)" "void glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)" "void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2)" "void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2)" "void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)" "void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)" "void glMaterialf (GLenum face, GLenum pname, GLfloat param)" "void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)" "void glMateriali (GLenum face, GLenum pname, GLint param)" "void glMaterialiv (GLenum face, GLenum pname, const GLint *params)" "void glMatrixMode (GLenum mode)" "void glMultMatrixd (const GLdouble *m)" "void glMultMatrixf (const GLfloat *m)" "void glNewList (GLuint list, GLenum mode)" "void glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz)" "void glNormal3bv (const GLbyte *v)" "void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)" "void glNormal3dv (const GLdouble *v)" "void glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)" "void glNormal3fv (const GLfloat *v)" "void glNormal3i (GLint nx, GLint ny, GLint nz)" "void glNormal3iv (const GLint *v)" "void glNormal3s (GLshort nx, GLshort ny, GLshort nz)" "void glNormal3sv (const GLshort *v)" "void glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)" "void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)" "void glPassThrough (GLfloat token)" "void glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values)" "void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values)" "void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values)" "void glPixelStoref (GLenum pname, GLfloat param)" "void glPixelStorei (GLenum pname, GLint param)" "void glPixelTransferf (GLenum pname, GLfloat param)" "void glPixelTransferi (GLenum pname, GLint param)" "void glPixelZoom (GLfloat xfactor, GLfloat yfactor)" "void glPointSize (GLfloat size)" "void glPolygonMode (GLenum face, GLenum mode)" "void glPolygonOffset (GLfloat factor, GLfloat units)" "void glPolygonStipple (const GLubyte *mask)" "void glPopAttrib (void)" "void glPopClientAttrib (void)" "void glPopMatrix (void)" "void glPopName (void)" "void glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)" "void glPushAttrib (GLbitfield mask)" "void glPushClientAttrib (GLbitfield mask)" "void glPushMatrix (void)" "void glPushName (GLuint name)" "void glRasterPos2d (GLdouble x, GLdouble y)" "void glRasterPos2dv (const GLdouble *v)" "void glRasterPos2f (GLfloat x, GLfloat y)" "void glRasterPos2fv (const GLfloat *v)" "void glRasterPos2i (GLint x, GLint y)" "void glRasterPos2iv (const GLint *v)" "void glRasterPos2s (GLshort x, GLshort y)" "void glRasterPos2sv (const GLshort *v)" "void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)" "void glRasterPos3dv (const GLdouble *v)" "void glRasterPos3f (GLfloat x, GLfloat y, GLfloat z)" "void glRasterPos3fv (const GLfloat *v)" "void glRasterPos3i (GLint x, GLint y, GLint z)" "void glRasterPos3iv (const GLint *v)" "void glRasterPos3s (GLshort x, GLshort y, GLshort z)" "void glRasterPos3sv (const GLshort *v)" "void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glRasterPos4dv (const GLdouble *v)" "void glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glRasterPos4fv (const GLfloat *v)" "void glRasterPos4i (GLint x, GLint y, GLint z, GLint w)" "void glRasterPos4iv (const GLint *v)" "void glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w)" "void glRasterPos4sv (const GLshort *v)" "void glReadBuffer (GLenum mode)" "void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)" "void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)" "void glRectdv (const GLdouble *v1, const GLdouble *v2)" "void glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)" "void glRectfv (const GLfloat *v1, const GLfloat *v2)" "void glRecti (GLint x1, GLint y1, GLint x2, GLint y2)" "void glRectiv (const GLint *v1, const GLint *v2)" "void glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)" "void glRectsv (const GLshort *v1, const GLshort *v2)" "GLint glRenderMode (GLenum mode)" "void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)" "void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)" "void glScaled (GLdouble x, GLdouble y, GLdouble z)" "void glScalef (GLfloat x, GLfloat y, GLfloat z)" "void glScissor (GLint x, GLint y, GLsizei width, GLsizei height)" "void glSelectBuffer (GLsizei size, GLuint *buffer)" "void glShadeModel (GLenum mode)" "void glStencilFunc (GLenum func, GLint ref, GLuint mask)" "void glStencilMask (GLuint mask)" "void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass)" "void glTexCoord1d (GLdouble s)" "void glTexCoord1dv (const GLdouble *v)" "void glTexCoord1f (GLfloat s)" "void glTexCoord1fv (const GLfloat *v)" "void glTexCoord1i (GLint s)" "void glTexCoord1iv (const GLint *v)" "void glTexCoord1s (GLshort s)" "void glTexCoord1sv (const GLshort *v)" "void glTexCoord2d (GLdouble s, GLdouble t)" "void glTexCoord2dv (const GLdouble *v)" "void glTexCoord2f (GLfloat s, GLfloat t)" "void glTexCoord2fv (const GLfloat *v)" "void glTexCoord2i (GLint s, GLint t)" "void glTexCoord2iv (const GLint *v)" "void glTexCoord2s (GLshort s, GLshort t)" "void glTexCoord2sv (const GLshort *v)" "void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r)" "void glTexCoord3dv (const GLdouble *v)" "void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r)" "void glTexCoord3fv (const GLfloat *v)" "void glTexCoord3i (GLint s, GLint t, GLint r)" "void glTexCoord3iv (const GLint *v)" "void glTexCoord3s (GLshort s, GLshort t, GLshort r)" "void glTexCoord3sv (const GLshort *v)" "void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)" "void glTexCoord4dv (const GLdouble *v)" "void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)" "void glTexCoord4fv (const GLfloat *v)" "void glTexCoord4i (GLint s, GLint t, GLint r, GLint q)" "void glTexCoord4iv (const GLint *v)" "void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)" "void glTexCoord4sv (const GLshort *v)" "void glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)" "void glTexEnvf (GLenum target, GLenum pname, GLfloat param)" "void glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)" "void glTexEnvi (GLenum target, GLenum pname, GLint param)" "void glTexEnviv (GLenum target, GLenum pname, const GLint *params)" "void glTexGend (GLenum coord, GLenum pname, GLdouble param)" "void glTexGendv (GLenum coord, GLenum pname, const GLdouble *params)" "void glTexGenf (GLenum coord, GLenum pname, GLfloat param)" "void glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params)" "void glTexGeni (GLenum coord, GLenum pname, GLint param)" "void glTexGeniv (GLenum coord, GLenum pname, const GLint *params)" "void glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)" "void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)" "void glTexParameterf (GLenum target, GLenum pname, GLfloat param)" "void glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)" "void glTexParameteri (GLenum target, GLenum pname, GLint param)" "void glTexParameteriv (GLenum target, GLenum pname, const GLint *params)" "void glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)" "void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)" "void glTranslated (GLdouble x, GLdouble y, GLdouble z)" "void glTranslatef (GLfloat x, GLfloat y, GLfloat z)" "void glVertex2d (GLdouble x, GLdouble y)" "void glVertex2dv (const GLdouble *v)" "void glVertex2f (GLfloat x, GLfloat y)" "void glVertex2fv (const GLfloat *v)" "void glVertex2i (GLint x, GLint y)" "void glVertex2iv (const GLint *v)" "void glVertex2s (GLshort x, GLshort y)" "void glVertex2sv (const GLshort *v)" "void glVertex3d (GLdouble x, GLdouble y, GLdouble z)" "void glVertex3dv (const GLdouble *v)" "void glVertex3f (GLfloat x, GLfloat y, GLfloat z)" "void glVertex3fv (const GLfloat *v)" "void glVertex3i (GLint x, GLint y, GLint z)" "void glVertex3iv (const GLint *v)" "void glVertex3s (GLshort x, GLshort y, GLshort z)" "void glVertex3sv (const GLshort *v)" "void glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glVertex4dv (const GLdouble *v)" "void glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glVertex4fv (const GLfloat *v)" "void glVertex4i (GLint x, GLint y, GLint z, GLint w)" "void glVertex4iv (const GLint *v)" "void glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)" "void glVertex4sv (const GLshort *v)" "void glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)" "void glViewport (GLint x, GLint y, GLsizei width, GLsizei height)" "void glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)" "void glTexImage3D (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)" "void glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)" "void glActiveTexture (GLenum texture)" "void glClientActiveTexture (GLenum texture)" "void glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)" "void glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)" "void glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)" "void glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)" "void glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)" "void glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)" "void glGetCompressedTexImage (GLenum target, GLint lod, GLvoid *img)" "void glLoadTransposeMatrixd (const GLdouble m\[16\])" "void glLoadTransposeMatrixf (const GLfloat m\[16\])" "void glMultTransposeMatrixd (const GLdouble m\[16\])" "void glMultTransposeMatrixf (const GLfloat m\[16\])" "void glMultiTexCoord1d (GLenum target, GLdouble s)" "void glMultiTexCoord1dv (GLenum target, const GLdouble *v)" "void glMultiTexCoord1f (GLenum target, GLfloat s)" "void glMultiTexCoord1fv (GLenum target, const GLfloat *v)" "void glMultiTexCoord1i (GLenum target, GLint s)" "void glMultiTexCoord1iv (GLenum target, const GLint *v)" "void glMultiTexCoord1s (GLenum target, GLshort s)" "void glMultiTexCoord1sv (GLenum target, const GLshort *v)" "void glMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t)" "void glMultiTexCoord2dv (GLenum target, const GLdouble *v)" "void glMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t)" "void glMultiTexCoord2fv (GLenum target, const GLfloat *v)" "void glMultiTexCoord2i (GLenum target, GLint s, GLint t)" "void glMultiTexCoord2iv (GLenum target, const GLint *v)" "void glMultiTexCoord2s (GLenum target, GLshort s, GLshort t)" "void glMultiTexCoord2sv (GLenum target, const GLshort *v)" "void glMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r)" "void glMultiTexCoord3dv (GLenum target, const GLdouble *v)" "void glMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r)" "void glMultiTexCoord3fv (GLenum target, const GLfloat *v)" "void glMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r)" "void glMultiTexCoord3iv (GLenum target, const GLint *v)" "void glMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r)" "void glMultiTexCoord3sv (GLenum target, const GLshort *v)" "void glMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)" "void glMultiTexCoord4dv (GLenum target, const GLdouble *v)" "void glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)" "void glMultiTexCoord4fv (GLenum target, const GLfloat *v)" "void glMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q)" "void glMultiTexCoord4iv (GLenum target, const GLint *v)" "void glMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)" "void glMultiTexCoord4sv (GLenum target, const GLshort *v)" "void glSampleCoverage (GLclampf value, GLboolean invert)" "void glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)" "void glBlendEquation (GLenum mode)" "void glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)" "void glFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)" "void glFogCoordd (GLdouble coord)" "void glFogCoorddv (const GLdouble *coord)" "void glFogCoordf (GLfloat coord)" "void glFogCoordfv (const GLfloat *coord)" "void glMultiDrawArrays (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)" "void glMultiDrawElements (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)" "void glPointParameterf (GLenum pname, GLfloat param)" "void glPointParameterfv (GLenum pname, const GLfloat *params)" "void glPointParameteri (GLenum pname, GLint param)" "void glPointParameteriv (GLenum pname, const GLint *params)" "void glSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue)" "void glSecondaryColor3bv (const GLbyte *v)" "void glSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue)" "void glSecondaryColor3dv (const GLdouble *v)" "void glSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue)" "void glSecondaryColor3fv (const GLfloat *v)" "void glSecondaryColor3i (GLint red, GLint green, GLint blue)" "void glSecondaryColor3iv (const GLint *v)" "void glSecondaryColor3s (GLshort red, GLshort green, GLshort blue)" "void glSecondaryColor3sv (const GLshort *v)" "void glSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue)" "void glSecondaryColor3ubv (const GLubyte *v)" "void glSecondaryColor3ui (GLuint red, GLuint green, GLuint blue)" "void glSecondaryColor3uiv (const GLuint *v)" "void glSecondaryColor3us (GLushort red, GLushort green, GLushort blue)" "void glSecondaryColor3usv (const GLushort *v)" "void glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, GLvoid *pointer)" "void glWindowPos2d (GLdouble x, GLdouble y)" "void glWindowPos2dv (const GLdouble *p)" "void glWindowPos2f (GLfloat x, GLfloat y)" "void glWindowPos2fv (const GLfloat *p)" "void glWindowPos2i (GLint x, GLint y)" "void glWindowPos2iv (const GLint *p)" "void glWindowPos2s (GLshort x, GLshort y)" "void glWindowPos2sv (const GLshort *p)" "void glWindowPos3d (GLdouble x, GLdouble y, GLdouble z)" "void glWindowPos3dv (const GLdouble *p)" "void glWindowPos3f (GLfloat x, GLfloat y, GLfloat z)" "void glWindowPos3fv (const GLfloat *p)" "void glWindowPos3i (GLint x, GLint y, GLint z)" "void glWindowPos3iv (const GLint *p)" "void glWindowPos3s (GLshort x, GLshort y, GLshort z)" "void glWindowPos3sv (const GLshort *p)" "void glBeginQuery (GLenum target, GLuint id)" "void glBindBuffer (GLenum target, GLuint buffer)" "void glBufferData (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)" "void glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)" "void glDeleteBuffers (GLsizei n, const GLuint* buffers)" "void glDeleteQueries (GLsizei n, const GLuint* ids)" "void glEndQuery (GLenum target)" "void glGenBuffers (GLsizei n, GLuint* buffers)" "void glGenQueries (GLsizei n, GLuint* ids)" "void glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params)" "void glGetBufferPointerv (GLenum target, GLenum pname, GLvoid** params)" "void glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data)" "void glGetQueryObjectiv (GLuint id, GLenum pname, GLint* params)" "void glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint* params)" "void glGetQueryiv (GLenum target, GLenum pname, GLint* params)" "GLboolean glIsBuffer (GLuint buffer)" "GLboolean glIsQuery (GLuint id)" "GLvoid* glMapBuffer (GLenum target, GLenum access)" "GLboolean glUnmapBuffer (GLenum target)" "void glAttachShader (GLuint program, GLuint shader)" "void glBindAttribLocation (GLuint program, GLuint index, const GLchar* name)" "void glBlendEquationSeparate (GLenum, GLenum)" "void glCompileShader (GLuint shader)" "GLuint glCreateProgram (void)" "GLuint glCreateShader (GLenum type)" "void glDeleteProgram (GLuint program)" "void glDeleteShader (GLuint shader)" "void glDetachShader (GLuint program, GLuint shader)" "void glDisableVertexAttribArray (GLuint)" "void glDrawBuffers (GLsizei n, const GLenum* bufs)" "void glEnableVertexAttribArray (GLuint)" "void glGetActiveAttrib (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name)" "void glGetActiveUniform (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name)" "void glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders)" "GLint glGetAttribLocation (GLuint program, const GLchar* name)" "void glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog)" "void glGetProgramiv (GLuint program, GLenum pname, GLint* param)" "void glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog)" "void glGetShaderSource (GLint obj, GLsizei maxLength, GLsizei* length, GLchar* source)" "void glGetShaderiv (GLuint shader, GLenum pname, GLint* param)" "GLint glGetUniformLocation (GLuint program, const GLchar* name)" "void glGetUniformfv (GLuint program, GLint location, GLfloat* params)" "void glGetUniformiv (GLuint program, GLint location, GLint* params)" "void glGetVertexAttribPointerv (GLuint, GLenum, GLvoid*)" "void glGetVertexAttribdv (GLuint, GLenum, GLdouble*)" "void glGetVertexAttribfv (GLuint, GLenum, GLfloat*)" "void glGetVertexAttribiv (GLuint, GLenum, GLint*)" "GLboolean glIsProgram (GLuint program)" "GLboolean glIsShader (GLuint shader)" "void glLinkProgram (GLuint program)" "void glShaderSource (GLuint shader, GLsizei count, const GLchar** strings, const GLint* lengths)" "void glStencilFuncSeparate (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)" "void glStencilMaskSeparate (GLenum, GLuint)" "void glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)" "void glUniform1f (GLint location, GLfloat v0)" "void glUniform1fv (GLint location, GLsizei count, const GLfloat* value)" "void glUniform1i (GLint location, GLint v0)" "void glUniform1iv (GLint location, GLsizei count, const GLint* value)" "void glUniform2f (GLint location, GLfloat v0, GLfloat v1)" "void glUniform2fv (GLint location, GLsizei count, const GLfloat* value)" "void glUniform2i (GLint location, GLint v0, GLint v1)" "void glUniform2iv (GLint location, GLsizei count, const GLint* value)" "void glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)" "void glUniform3fv (GLint location, GLsizei count, const GLfloat* value)" "void glUniform3i (GLint location, GLint v0, GLint v1, GLint v2)" "void glUniform3iv (GLint location, GLsizei count, const GLint* value)" "void glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)" "void glUniform4fv (GLint location, GLsizei count, const GLfloat* value)" "void glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)" "void glUniform4iv (GLint location, GLsizei count, const GLint* value)" "void glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUseProgram (GLuint program)" "void glValidateProgram (GLuint program)" "void glVertexAttrib1d (GLuint index, GLdouble x)" "void glVertexAttrib1dv (GLuint index, const GLdouble* v)" "void glVertexAttrib1f (GLuint index, GLfloat x)" "void glVertexAttrib1fv (GLuint index, const GLfloat* v)" "void glVertexAttrib1s (GLuint index, GLshort x)" "void glVertexAttrib1sv (GLuint index, const GLshort* v)" "void glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)" "void glVertexAttrib2dv (GLuint index, const GLdouble* v)" "void glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)" "void glVertexAttrib2fv (GLuint index, const GLfloat* v)" "void glVertexAttrib2s (GLuint index, GLshort x, GLshort y)" "void glVertexAttrib2sv (GLuint index, const GLshort* v)" "void glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)" "void glVertexAttrib3dv (GLuint index, const GLdouble* v)" "void glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)" "void glVertexAttrib3fv (GLuint index, const GLfloat* v)" "void glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)" "void glVertexAttrib3sv (GLuint index, const GLshort* v)" "void glVertexAttrib4Nbv (GLuint index, const GLbyte* v)" "void glVertexAttrib4Niv (GLuint index, const GLint* v)" "void glVertexAttrib4Nsv (GLuint index, const GLshort* v)" "void glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)" "void glVertexAttrib4Nubv (GLuint index, const GLubyte* v)" "void glVertexAttrib4Nuiv (GLuint index, const GLuint* v)" "void glVertexAttrib4Nusv (GLuint index, const GLushort* v)" "void glVertexAttrib4bv (GLuint index, const GLbyte* v)" "void glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glVertexAttrib4dv (GLuint index, const GLdouble* v)" "void glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glVertexAttrib4fv (GLuint index, const GLfloat* v)" "void glVertexAttrib4iv (GLuint index, const GLint* v)" "void glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)" "void glVertexAttrib4sv (GLuint index, const GLshort* v)" "void glVertexAttrib4ubv (GLuint index, const GLubyte* v)" "void glVertexAttrib4uiv (GLuint index, const GLuint* v)" "void glVertexAttrib4usv (GLuint index, const GLushort* v)" "void glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)" "void glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)" "void glBeginConditionalRender (GLuint, GLenum)" "void glBeginTransformFeedback (GLenum)" "void glBindBufferBase (GLenum, GLuint, GLuint)" "void glBindBufferRange (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr)" "void glBindFragDataLocation (GLuint, GLuint, const GLchar*)" "void glClampColor (GLenum, GLenum)" "void glClearBufferfi (GLenum, GLint, GLfloat, GLint)" "void glClearBufferfv (GLenum, GLint, const GLfloat*)" "void glClearBufferiv (GLenum, GLint, const GLint*)" "void glClearBufferuiv (GLenum, GLint, const GLuint*)" "void glColorMaski (GLuint, GLboolean, GLboolean, GLboolean, GLboolean)" "void glDisablei (GLenum, GLuint)" "void glEnablei (GLenum, GLuint)" "void glEndConditionalRender (void)" "void glEndTransformFeedback (void)" "void glGetBooleani_v (GLenum, GLuint, GLboolean*)" "GLint glGetFragDataLocation (GLuint, const GLchar*)" "void glGetIntegeri_v (GLenum, GLuint, GLint*)" "const GLubyte* glGetStringi (GLenum, GLuint)" "void glGetTexParameterIiv (GLenum, GLenum, GLint*)" "void glGetTexParameterIuiv (GLenum, GLenum, GLuint*)" "void glGetTransformFeedbackVarying (GLuint, GLuint, GLint*)" "void glGetUniformuiv (GLuint, GLint, GLuint*)" "void glGetVertexAttribIiv (GLuint, GLenum, GLint*)" "void glGetVertexAttribIuiv (GLuint, GLenum, GLuint*)" "GLboolean glIsEnabledi (GLenum, GLuint)" "void glTexParameterIiv (GLenum, GLenum, const GLint*)" "void glTexParameterIuiv (GLenum, GLenum, const GLuint*)" "void glTransformFeedbackVaryings (GLuint, GLsizei, const GLint*, GLenum)" "void glUniform1ui (GLint, GLuint)" "void glUniform1uiv (GLint, GLsizei, const GLuint*)" "void glUniform2ui (GLint, GLuint, GLuint)" "void glUniform2uiv (GLint, GLsizei, const GLuint*)" "void glUniform3ui (GLint, GLuint, GLuint, GLuint)" "void glUniform3uiv (GLint, GLsizei, const GLuint*)" "void glUniform4ui (GLint, GLuint, GLuint, GLuint, GLuint)" "void glUniform4uiv (GLint, GLsizei, const GLuint*)" "void glVertexAttribI1i (GLuint, GLint)" "void glVertexAttribI1iv (GLuint, const GLint*)" "void glVertexAttribI1ui (GLuint, GLuint)" "void glVertexAttribI1uiv (GLuint, const GLuint*)" "void glVertexAttribI2i (GLuint, GLint, GLint)" "void glVertexAttribI2iv (GLuint, const GLint*)" "void glVertexAttribI2ui (GLuint, GLuint, GLuint)" "void glVertexAttribI2uiv (GLuint, const GLuint*)" "void glVertexAttribI3i (GLuint, GLint, GLint, GLint)" "void glVertexAttribI3iv (GLuint, const GLint*)" "void glVertexAttribI3ui (GLuint, GLuint, GLuint, GLuint)" "void glVertexAttribI3uiv (GLuint, const GLuint*)" "void glVertexAttribI4bv (GLuint, const GLbyte*)" "void glVertexAttribI4i (GLuint, GLint, GLint, GLint, GLint)" "void glVertexAttribI4iv (GLuint, const GLint*)" "void glVertexAttribI4sv (GLuint, const GLshort*)" "void glVertexAttribI4ubv (GLuint, const GLubyte*)" "void glVertexAttribI4ui (GLuint, GLuint, GLuint, GLuint, GLuint)" "void glVertexAttribI4uiv (GLuint, const GLuint*)" "void glVertexAttribI4usv (GLuint, const GLushort*)" "void glVertexAttribIPointer (GLuint, GLint, GLenum, GLsizei, const GLvoid*)" "void glTbufferMask3DFX (GLuint mask)" "void glDrawElementArrayAPPLE (GLenum mode, GLint first, GLsizei count)" "void glDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)" "void glElementPointerAPPLE (GLenum type, const void* pointer)" "void glMultiDrawElementArrayAPPLE (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount)" "void glMultiDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei *count, GLsizei primcount)" "void glDeleteFencesAPPLE (GLsizei n, const GLuint* fences)" "void glFinishFenceAPPLE (GLuint fence)" "void glFinishObjectAPPLE (GLenum object, GLint name)" "void glGenFencesAPPLE (GLsizei n, GLuint* fences)" "GLboolean glIsFenceAPPLE (GLuint fence)" "void glSetFenceAPPLE (GLuint fence)" "GLboolean glTestFenceAPPLE (GLuint fence)" "GLboolean glTestObjectAPPLE (GLenum object, GLuint name)" "void glBufferParameteriAPPLE (GLenum target, GLenum pname, GLint param)" "void glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size)" "void glGetTexParameterPointervAPPLE (GLenum target, GLenum pname, GLvoid **params)" "void glTextureRangeAPPLE (GLenum target, GLsizei length, GLvoid *pointer)" "void glBindVertexArrayAPPLE (GLuint array)" "void glDeleteVertexArraysAPPLE (GLsizei n, const GLuint* arrays)" "void glGenVertexArraysAPPLE (GLsizei n, const GLuint* arrays)" "GLboolean glIsVertexArrayAPPLE (GLuint array)" "void glFlushVertexArrayRangeAPPLE (GLsizei length, void* pointer)" "void glVertexArrayParameteriAPPLE (GLenum pname, GLint param)" "void glVertexArrayRangeAPPLE (GLsizei length, void* pointer)" "void glClampColorARB (GLenum target, GLenum clamp)" "void glDrawBuffersARB (GLsizei n, const GLenum* bufs)" "void glDrawArraysInstancedARB (GLenum mode, GLint first, GLsizei count, GLsizei primcount)" "void glDrawElementsInstancedARB (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount)" "void glBindFramebuffer (GLenum target, GLuint framebuffer)" "void glBindRenderbuffer (GLenum target, GLuint renderbuffer)" "void glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)" "GLenum glCheckFramebufferStatus (GLenum target)" "void glDeleteFramebuffers (GLsizei n, const GLuint* framebuffers)" "void glDeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers)" "void glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)" "void glFramebufferTexturLayer (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer)" "void glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer)" "void glGenFramebuffers (GLsizei n, GLuint* framebuffers)" "void glGenRenderbuffers (GLsizei n, GLuint* renderbuffers)" "void glGenerateMipmap (GLenum target)" "void glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params)" "void glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params)" "GLboolean glIsFramebuffer (GLuint framebuffer)" "GLboolean glIsRenderbuffer (GLuint renderbuffer)" "void glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)" "void glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)" "void glFramebufferTextureARB (GLenum target, GLenum attachment, GLuint texture, GLint level)" "void glFramebufferTextureFaceARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)" "void glFramebufferTextureLayerARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)" "void glProgramParameteriARB (GLuint program, GLenum pname, GLint value)" "void glColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)" "void glColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)" "void glColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params)" "void glColorTableParameteriv (GLenum target, GLenum pname, const GLint *params)" "void glConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)" "void glConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)" "void glConvolutionParameterf (GLenum target, GLenum pname, GLfloat params)" "void glConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params)" "void glConvolutionParameteri (GLenum target, GLenum pname, GLint params)" "void glConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params)" "void glCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)" "void glCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)" "void glCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)" "void glCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)" "void glGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table)" "void glGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params)" "void glGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image)" "void glGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params)" "void glGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)" "void glGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params)" "void glGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values)" "void glGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params)" "void glGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params)" "void glGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)" "void glHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)" "void glMinmax (GLenum target, GLenum internalformat, GLboolean sink)" "void glResetHistogram (GLenum target)" "void glResetMinmax (GLenum target)" "void glSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)" "void glVertexAttribDivisorARB (GLuint index, GLuint divisor)" "void glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)" "GLvoid * glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)" "void glCurrentPaletteMatrixARB (GLint index)" "void glMatrixIndexPointerARB (GLint size, GLenum type, GLsizei stride, GLvoid *pointer)" "void glMatrixIndexubvARB (GLint size, GLubyte *indices)" "void glMatrixIndexuivARB (GLint size, GLuint *indices)" "void glMatrixIndexusvARB (GLint size, GLushort *indices)" "void glSampleCoverageARB (GLclampf value, GLboolean invert)" "void glActiveTextureARB (GLenum texture)" "void glClientActiveTextureARB (GLenum texture)" "void glMultiTexCoord1dARB (GLenum target, GLdouble s)" "void glMultiTexCoord1dvARB (GLenum target, const GLdouble *v)" "void glMultiTexCoord1fARB (GLenum target, GLfloat s)" "void glMultiTexCoord1fvARB (GLenum target, const GLfloat *v)" "void glMultiTexCoord1iARB (GLenum target, GLint s)" "void glMultiTexCoord1ivARB (GLenum target, const GLint *v)" "void glMultiTexCoord1sARB (GLenum target, GLshort s)" "void glMultiTexCoord1svARB (GLenum target, const GLshort *v)" "void glMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t)" "void glMultiTexCoord2dvARB (GLenum target, const GLdouble *v)" "void glMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t)" "void glMultiTexCoord2fvARB (GLenum target, const GLfloat *v)" "void glMultiTexCoord2iARB (GLenum target, GLint s, GLint t)" "void glMultiTexCoord2ivARB (GLenum target, const GLint *v)" "void glMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t)" "void glMultiTexCoord2svARB (GLenum target, const GLshort *v)" "void glMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r)" "void glMultiTexCoord3dvARB (GLenum target, const GLdouble *v)" "void glMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r)" "void glMultiTexCoord3fvARB (GLenum target, const GLfloat *v)" "void glMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r)" "void glMultiTexCoord3ivARB (GLenum target, const GLint *v)" "void glMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r)" "void glMultiTexCoord3svARB (GLenum target, const GLshort *v)" "void glMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)" "void glMultiTexCoord4dvARB (GLenum target, const GLdouble *v)" "void glMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)" "void glMultiTexCoord4fvARB (GLenum target, const GLfloat *v)" "void glMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q)" "void glMultiTexCoord4ivARB (GLenum target, const GLint *v)" "void glMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)" "void glMultiTexCoord4svARB (GLenum target, const GLshort *v)" "void glBeginQueryARB (GLenum target, GLuint id)" "void glDeleteQueriesARB (GLsizei n, const GLuint* ids)" "void glEndQueryARB (GLenum target)" "void glGenQueriesARB (GLsizei n, GLuint* ids)" "void glGetQueryObjectivARB (GLuint id, GLenum pname, GLint* params)" "void glGetQueryObjectuivARB (GLuint id, GLenum pname, GLuint* params)" "void glGetQueryivARB (GLenum target, GLenum pname, GLint* params)" "GLboolean glIsQueryARB (GLuint id)" "void glPointParameterfARB (GLenum pname, GLfloat param)" "void glPointParameterfvARB (GLenum pname, const GLfloat* params)" "void glAttachObjectARB (GLhandleARB containerObj, GLhandleARB obj)" "void glCompileShaderARB (GLhandleARB shaderObj)" "GLhandleARB glCreateProgramObjectARB (void)" "GLhandleARB glCreateShaderObjectARB (GLenum shaderType)" "void glDeleteObjectARB (GLhandleARB obj)" "void glDetachObjectARB (GLhandleARB containerObj, GLhandleARB attachedObj)" "void glGetActiveUniformARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name)" "void glGetAttachedObjectsARB (GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB *obj)" "GLhandleARB glGetHandleARB (GLenum pname)" "void glGetInfoLogARB (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *infoLog)" "void glGetObjectParameterfvARB (GLhandleARB obj, GLenum pname, GLfloat* params)" "void glGetObjectParameterivARB (GLhandleARB obj, GLenum pname, GLint* params)" "void glGetShaderSourceARB (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *source)" "GLint glGetUniformLocationARB (GLhandleARB programObj, const GLcharARB* name)" "void glGetUniformfvARB (GLhandleARB programObj, GLint location, GLfloat* params)" "void glGetUniformivARB (GLhandleARB programObj, GLint location, GLint* params)" "void glLinkProgramARB (GLhandleARB programObj)" "void glShaderSourceARB (GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint *length)" "void glUniform1fARB (GLint location, GLfloat v0)" "void glUniform1fvARB (GLint location, GLsizei count, const GLfloat* value)" "void glUniform1iARB (GLint location, GLint v0)" "void glUniform1ivARB (GLint location, GLsizei count, const GLint* value)" "void glUniform2fARB (GLint location, GLfloat v0, GLfloat v1)" "void glUniform2fvARB (GLint location, GLsizei count, const GLfloat* value)" "void glUniform2iARB (GLint location, GLint v0, GLint v1)" "void glUniform2ivARB (GLint location, GLsizei count, const GLint* value)" "void glUniform3fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)" "void glUniform3fvARB (GLint location, GLsizei count, const GLfloat* value)" "void glUniform3iARB (GLint location, GLint v0, GLint v1, GLint v2)" "void glUniform3ivARB (GLint location, GLsizei count, const GLint* value)" "void glUniform4fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)" "void glUniform4fvARB (GLint location, GLsizei count, const GLfloat* value)" "void glUniform4iARB (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)" "void glUniform4ivARB (GLint location, GLsizei count, const GLint* value)" "void glUniformMatrix2fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUniformMatrix3fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUniformMatrix4fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glUseProgramObjectARB (GLhandleARB programObj)" "void glValidateProgramARB (GLhandleARB programObj)" "void glTexBufferARB (GLenum target, GLenum internalformat, GLuint buffer)" "void glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data)" "void glGetCompressedTexImageARB (GLenum target, GLint lod, void* img)" "void glLoadTransposeMatrixdARB (GLdouble m\[16\])" "void glLoadTransposeMatrixfARB (GLfloat m\[16\])" "void glMultTransposeMatrixdARB (GLdouble m\[16\])" "void glMultTransposeMatrixfARB (GLfloat m\[16\])" "void glBindVertexArray (GLuint array)" "void glDeleteVertexArrays (GLsizei n, const GLuint* arrays)" "void glGenVertexArrays (GLsizei n, GLuint* arrays)" "GLboolean glIsVertexArray (GLuint array)" "void glVertexBlendARB (GLint count)" "void glWeightPointerARB (GLint size, GLenum type, GLsizei stride, GLvoid *pointer)" "void glWeightbvARB (GLint size, GLbyte *weights)" "void glWeightdvARB (GLint size, GLdouble *weights)" "void glWeightfvARB (GLint size, GLfloat *weights)" "void glWeightivARB (GLint size, GLint *weights)" "void glWeightsvARB (GLint size, GLshort *weights)" "void glWeightubvARB (GLint size, GLubyte *weights)" "void glWeightuivARB (GLint size, GLuint *weights)" "void glWeightusvARB (GLint size, GLushort *weights)" "void glBindBufferARB (GLenum target, GLuint buffer)" "void glBufferDataARB (GLenum target, GLsizeiptrARB size, const GLvoid* data, GLenum usage)" "void glBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid* data)" "void glDeleteBuffersARB (GLsizei n, const GLuint* buffers)" "void glGenBuffersARB (GLsizei n, GLuint* buffers)" "void glGetBufferParameterivARB (GLenum target, GLenum pname, GLint* params)" "void glGetBufferPointervARB (GLenum target, GLenum pname, GLvoid** params)" "void glGetBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data)" "GLboolean glIsBufferARB (GLuint buffer)" "GLvoid * glMapBufferARB (GLenum target, GLenum access)" "GLboolean glUnmapBufferARB (GLenum target)" "void glBindProgramARB (GLenum target, GLuint program)" "void glDeleteProgramsARB (GLsizei n, const GLuint* programs)" "void glDisableVertexAttribArrayARB (GLuint index)" "void glEnableVertexAttribArrayARB (GLuint index)" "void glGenProgramsARB (GLsizei n, GLuint* programs)" "void glGetProgramEnvParameterdvARB (GLenum target, GLuint index, GLdouble* params)" "void glGetProgramEnvParameterfvARB (GLenum target, GLuint index, GLfloat* params)" "void glGetProgramLocalParameterdvARB (GLenum target, GLuint index, GLdouble* params)" "void glGetProgramLocalParameterfvARB (GLenum target, GLuint index, GLfloat* params)" "void glGetProgramStringARB (GLenum target, GLenum pname, void* string)" "void glGetProgramivARB (GLenum target, GLenum pname, GLint* params)" "void glGetVertexAttribPointervARB (GLuint index, GLenum pname, GLvoid** pointer)" "void glGetVertexAttribdvARB (GLuint index, GLenum pname, GLdouble* params)" "void glGetVertexAttribfvARB (GLuint index, GLenum pname, GLfloat* params)" "void glGetVertexAttribivARB (GLuint index, GLenum pname, GLint* params)" "GLboolean glIsProgramARB (GLuint program)" "void glProgramEnvParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glProgramEnvParameter4dvARB (GLenum target, GLuint index, const GLdouble* params)" "void glProgramEnvParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glProgramEnvParameter4fvARB (GLenum target, GLuint index, const GLfloat* params)" "void glProgramLocalParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glProgramLocalParameter4dvARB (GLenum target, GLuint index, const GLdouble* params)" "void glProgramLocalParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glProgramLocalParameter4fvARB (GLenum target, GLuint index, const GLfloat* params)" "void glProgramStringARB (GLenum target, GLenum format, GLsizei len, const void* string)" "void glVertexAttrib1dARB (GLuint index, GLdouble x)" "void glVertexAttrib1dvARB (GLuint index, const GLdouble* v)" "void glVertexAttrib1fARB (GLuint index, GLfloat x)" "void glVertexAttrib1fvARB (GLuint index, const GLfloat* v)" "void glVertexAttrib1sARB (GLuint index, GLshort x)" "void glVertexAttrib1svARB (GLuint index, const GLshort* v)" "void glVertexAttrib2dARB (GLuint index, GLdouble x, GLdouble y)" "void glVertexAttrib2dvARB (GLuint index, const GLdouble* v)" "void glVertexAttrib2fARB (GLuint index, GLfloat x, GLfloat y)" "void glVertexAttrib2fvARB (GLuint index, const GLfloat* v)" "void glVertexAttrib2sARB (GLuint index, GLshort x, GLshort y)" "void glVertexAttrib2svARB (GLuint index, const GLshort* v)" "void glVertexAttrib3dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z)" "void glVertexAttrib3dvARB (GLuint index, const GLdouble* v)" "void glVertexAttrib3fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z)" "void glVertexAttrib3fvARB (GLuint index, const GLfloat* v)" "void glVertexAttrib3sARB (GLuint index, GLshort x, GLshort y, GLshort z)" "void glVertexAttrib3svARB (GLuint index, const GLshort* v)" "void glVertexAttrib4NbvARB (GLuint index, const GLbyte* v)" "void glVertexAttrib4NivARB (GLuint index, const GLint* v)" "void glVertexAttrib4NsvARB (GLuint index, const GLshort* v)" "void glVertexAttrib4NubARB (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)" "void glVertexAttrib4NubvARB (GLuint index, const GLubyte* v)" "void glVertexAttrib4NuivARB (GLuint index, const GLuint* v)" "void glVertexAttrib4NusvARB (GLuint index, const GLushort* v)" "void glVertexAttrib4bvARB (GLuint index, const GLbyte* v)" "void glVertexAttrib4dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glVertexAttrib4dvARB (GLuint index, const GLdouble* v)" "void glVertexAttrib4fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glVertexAttrib4fvARB (GLuint index, const GLfloat* v)" "void glVertexAttrib4ivARB (GLuint index, const GLint* v)" "void glVertexAttrib4sARB (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)" "void glVertexAttrib4svARB (GLuint index, const GLshort* v)" "void glVertexAttrib4ubvARB (GLuint index, const GLubyte* v)" "void glVertexAttrib4uivARB (GLuint index, const GLuint* v)" "void glVertexAttrib4usvARB (GLuint index, const GLushort* v)" "void glVertexAttribPointerARB (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer)" "void glBindAttribLocationARB (GLhandleARB programObj, GLuint index, const GLcharARB* name)" "void glGetActiveAttribARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name)" "GLint glGetAttribLocationARB (GLhandleARB programObj, const GLcharARB* name)" "void glWindowPos2dARB (GLdouble x, GLdouble y)" "void glWindowPos2dvARB (const GLdouble* p)" "void glWindowPos2fARB (GLfloat x, GLfloat y)" "void glWindowPos2fvARB (const GLfloat* p)" "void glWindowPos2iARB (GLint x, GLint y)" "void glWindowPos2ivARB (const GLint* p)" "void glWindowPos2sARB (GLshort x, GLshort y)" "void glWindowPos2svARB (const GLshort* p)" "void glWindowPos3dARB (GLdouble x, GLdouble y, GLdouble z)" "void glWindowPos3dvARB (const GLdouble* p)" "void glWindowPos3fARB (GLfloat x, GLfloat y, GLfloat z)" "void glWindowPos3fvARB (const GLfloat* p)" "void glWindowPos3iARB (GLint x, GLint y, GLint z)" "void glWindowPos3ivARB (const GLint* p)" "void glWindowPos3sARB (GLshort x, GLshort y, GLshort z)" "void glWindowPos3svARB (const GLshort* p)" "void glDrawBuffersATI (GLsizei n, const GLenum* bufs)" "void glDrawElementArrayATI (GLenum mode, GLsizei count)" "void glDrawRangeElementArrayATI (GLenum mode, GLuint start, GLuint end, GLsizei count)" "void glElementPointerATI (GLenum type, const void* pointer)" "void glGetTexBumpParameterfvATI (GLenum pname, GLfloat *param)" "void glGetTexBumpParameterivATI (GLenum pname, GLint *param)" "void glTexBumpParameterfvATI (GLenum pname, GLfloat *param)" "void glTexBumpParameterivATI (GLenum pname, GLint *param)" "void glAlphaFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)" "void glAlphaFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)" "void glAlphaFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)" "void glBeginFragmentShaderATI (void)" "void glBindFragmentShaderATI (GLuint id)" "void glColorFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)" "void glColorFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)" "void glColorFragmentOp3ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)" "void glDeleteFragmentShaderATI (GLuint id)" "void glEndFragmentShaderATI (void)" "GLuint glGenFragmentShadersATI (GLuint range)" "void glPassTexCoordATI (GLuint dst, GLuint coord, GLenum swizzle)" "void glSampleMapATI (GLuint dst, GLuint interp, GLenum swizzle)" "void glSetFragmentShaderConstantATI (GLuint dst, const GLfloat* value)" "void* glMapObjectBufferATI (GLuint buffer)" "void glUnmapObjectBufferATI (GLuint buffer)" "void glPNTrianglesfATI (GLenum pname, GLfloat param)" "void glPNTrianglesiATI (GLenum pname, GLint param)" "void glStencilFuncSeparateATI (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)" "void glStencilOpSeparateATI (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)" "void glArrayObjectATI (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)" "void glFreeObjectBufferATI (GLuint buffer)" "void glGetArrayObjectfvATI (GLenum array, GLenum pname, GLfloat* params)" "void glGetArrayObjectivATI (GLenum array, GLenum pname, GLint* params)" "void glGetObjectBufferfvATI (GLuint buffer, GLenum pname, GLfloat* params)" "void glGetObjectBufferivATI (GLuint buffer, GLenum pname, GLint* params)" "void glGetVariantArrayObjectfvATI (GLuint id, GLenum pname, GLfloat* params)" "void glGetVariantArrayObjectivATI (GLuint id, GLenum pname, GLint* params)" "GLboolean glIsObjectBufferATI (GLuint buffer)" "GLuint glNewObjectBufferATI (GLsizei size, const void* pointer, GLenum usage)" "void glUpdateObjectBufferATI (GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve)" "void glVariantArrayObjectATI (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)" "void glGetVertexAttribArrayObjectfvATI (GLuint index, GLenum pname, GLfloat* params)" "void glGetVertexAttribArrayObjectivATI (GLuint index, GLenum pname, GLint* params)" "void glVertexAttribArrayObjectATI (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset)" "void glClientActiveVertexStreamATI (GLenum stream)" "void glNormalStream3bATI (GLenum stream, GLbyte x, GLbyte y, GLbyte z)" "void glNormalStream3bvATI (GLenum stream, const GLbyte *v)" "void glNormalStream3dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z)" "void glNormalStream3dvATI (GLenum stream, const GLdouble *v)" "void glNormalStream3fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z)" "void glNormalStream3fvATI (GLenum stream, const GLfloat *v)" "void glNormalStream3iATI (GLenum stream, GLint x, GLint y, GLint z)" "void glNormalStream3ivATI (GLenum stream, const GLint *v)" "void glNormalStream3sATI (GLenum stream, GLshort x, GLshort y, GLshort z)" "void glNormalStream3svATI (GLenum stream, const GLshort *v)" "void glVertexBlendEnvfATI (GLenum pname, GLfloat param)" "void glVertexBlendEnviATI (GLenum pname, GLint param)" "void glVertexStream2dATI (GLenum stream, GLdouble x, GLdouble y)" "void glVertexStream2dvATI (GLenum stream, const GLdouble *v)" "void glVertexStream2fATI (GLenum stream, GLfloat x, GLfloat y)" "void glVertexStream2fvATI (GLenum stream, const GLfloat *v)" "void glVertexStream2iATI (GLenum stream, GLint x, GLint y)" "void glVertexStream2ivATI (GLenum stream, const GLint *v)" "void glVertexStream2sATI (GLenum stream, GLshort x, GLshort y)" "void glVertexStream2svATI (GLenum stream, const GLshort *v)" "void glVertexStream3dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z)" "void glVertexStream3dvATI (GLenum stream, const GLdouble *v)" "void glVertexStream3fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z)" "void glVertexStream3fvATI (GLenum stream, const GLfloat *v)" "void glVertexStream3iATI (GLenum stream, GLint x, GLint y, GLint z)" "void glVertexStream3ivATI (GLenum stream, const GLint *v)" "void glVertexStream3sATI (GLenum stream, GLshort x, GLshort y, GLshort z)" "void glVertexStream3svATI (GLenum stream, const GLshort *v)" "void glVertexStream4dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glVertexStream4dvATI (GLenum stream, const GLdouble *v)" "void glVertexStream4fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glVertexStream4fvATI (GLenum stream, const GLfloat *v)" "void glVertexStream4iATI (GLenum stream, GLint x, GLint y, GLint z, GLint w)" "void glVertexStream4ivATI (GLenum stream, const GLint *v)" "void glVertexStream4sATI (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w)" "void glVertexStream4svATI (GLenum stream, const GLshort *v)" "GLint glGetUniformBufferSizeEXT (GLuint program, GLint location)" "GLintptr glGetUniformOffsetEXT (GLuint program, GLint location)" "void glUniformBufferEXT (GLuint program, GLint location, GLuint buffer)" "void glBlendColorEXT (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)" "void glBlendEquationSeparateEXT (GLenum modeRGB, GLenum modeAlpha)" "void glBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)" "void glBlendEquationEXT (GLenum mode)" "void glColorSubTableEXT (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data)" "void glCopyColorSubTableEXT (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)" "void glLockArraysEXT (GLint first, GLsizei count)" "void glUnlockArraysEXT (void)" "void glConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image)" "void glConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image)" "void glConvolutionParameterfEXT (GLenum target, GLenum pname, GLfloat param)" "void glConvolutionParameterfvEXT (GLenum target, GLenum pname, const GLfloat* params)" "void glConvolutionParameteriEXT (GLenum target, GLenum pname, GLint param)" "void glConvolutionParameterivEXT (GLenum target, GLenum pname, const GLint* params)" "void glCopyConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)" "void glCopyConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)" "void glGetConvolutionFilterEXT (GLenum target, GLenum format, GLenum type, void* image)" "void glGetConvolutionParameterfvEXT (GLenum target, GLenum pname, GLfloat* params)" "void glGetConvolutionParameterivEXT (GLenum target, GLenum pname, GLint* params)" "void glGetSeparableFilterEXT (GLenum target, GLenum format, GLenum type, void* row, void* column, void* span)" "void glSeparableFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column)" "void glBinormalPointerEXT (GLenum type, GLsizei stride, void* pointer)" "void glTangentPointerEXT (GLenum type, GLsizei stride, void* pointer)" "void glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)" "void glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)" "void glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)" "void glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCullParameterdvEXT (GLenum pname, GLdouble* params)" "void glCullParameterfvEXT (GLenum pname, GLfloat* params)" "void glDepthBoundsEXT (GLclampd zmin, GLclampd zmax)" "void glBindMultiTextureEXT (GLenum texunit, GLenum target, GLuint texture)" "GLenum glCheckNamedFramebufferStatusEXT (GLuint framebuffer, GLenum target)" "void glClientAttribDefaultEXT (GLbitfield mask)" "void glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data)" "void glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)" "void glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data)" "void glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data)" "void glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)" "void glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data)" "void glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)" "void glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)" "void glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)" "void glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)" "void glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)" "void glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)" "void glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)" "void glDisableClientStateIndexedEXT (GLenum array, GLuint index)" "void glEnableClientStateIndexedEXT (GLenum array, GLuint index)" "void glFramebufferDrawBufferEXT (GLuint framebuffer, GLenum mode)" "void glFramebufferDrawBuffersEXT (GLuint framebuffer, GLsizei n, const GLenum* bufs)" "void glFramebufferReadBufferEXT (GLuint framebuffer, GLenum mode)" "void glGenerateMultiTexMipmapEXT (GLenum texunit, GLenum target)" "void glGenerateTextureMipmapEXT (GLuint texture, GLenum target)" "void glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, void* img)" "void glGetCompressedTextureImageEXT (GLuint texture, GLenum target, GLint level, void* img)" "void glGetDoubleIndexedvEXT (GLenum pname, GLuint index, GLdouble* params)" "void glGetFloatIndexedvEXT (GLenum pname, GLuint index, GLfloat* params)" "void glGetFramebufferParameterivEXT (GLuint framebuffer, GLenum pname, GLint* param)" "void glGetMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat* params)" "void glGetMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, GLint* params)" "void glGetMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble* params)" "void glGetMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat* params)" "void glGetMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, GLint* params)" "void glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void* pixels)" "void glGetMultiTexLevelParameterfvEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params)" "void glGetMultiTexLevelParameterivEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params)" "void glGetMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, GLint* params)" "void glGetMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, GLuint* params)" "void glGetMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat* params)" "void glGetMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, GLint* params)" "void glGetNamedBufferParameterivEXT (GLuint buffer, GLenum pname, GLint* params)" "void glGetNamedBufferPointervEXT (GLuint buffer, GLenum pname, void** params)" "void glGetNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, void* data)" "void glGetNamedFramebufferAttachmentParameterivEXT (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params)" "void glGetNamedProgramLocalParameterIivEXT (GLuint program, GLenum target, GLuint index, GLint* params)" "void glGetNamedProgramLocalParameterIuivEXT (GLuint program, GLenum target, GLuint index, GLuint* params)" "void glGetNamedProgramLocalParameterdvEXT (GLuint program, GLenum target, GLuint index, GLdouble* params)" "void glGetNamedProgramLocalParameterfvEXT (GLuint program, GLenum target, GLuint index, GLfloat* params)" "void glGetNamedProgramStringEXT (GLuint program, GLenum target, GLenum pname, void* string)" "void glGetNamedProgramivEXT (GLuint program, GLenum target, GLenum pname, GLint* params)" "void glGetNamedRenderbufferParameterivEXT (GLuint renderbuffer, GLenum pname, GLint* params)" "void glGetPointerIndexedvEXT (GLenum pname, GLuint index, GLvoid** params)" "void glGetTextureImageEXT (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels)" "void glGetTextureLevelParameterfvEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params)" "void glGetTextureLevelParameterivEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params)" "void glGetTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, GLint* params)" "void glGetTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, GLuint* params)" "void glGetTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, GLfloat* params)" "void glGetTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, GLint* params)" "GLvoid * glMapNamedBufferEXT (GLuint buffer, GLenum access)" "void glMatrixFrustumEXT (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f)" "void glMatrixLoadIdentityEXT (GLenum matrixMode)" "void glMatrixLoadTransposedEXT (GLenum matrixMode, const GLdouble* m)" "void glMatrixLoadTransposefEXT (GLenum matrixMode, const GLfloat* m)" "void glMatrixLoaddEXT (GLenum matrixMode, const GLdouble* m)" "void glMatrixLoadfEXT (GLenum matrixMode, const GLfloat* m)" "void glMatrixMultTransposedEXT (GLenum matrixMode, const GLdouble* m)" "void glMatrixMultTransposefEXT (GLenum matrixMode, const GLfloat* m)" "void glMatrixMultdEXT (GLenum matrixMode, const GLdouble* m)" "void glMatrixMultfEXT (GLenum matrixMode, const GLfloat* m)" "void glMatrixOrthoEXT (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f)" "void glMatrixPopEXT (GLenum matrixMode)" "void glMatrixPushEXT (GLenum matrixMode)" "void glMatrixRotatedEXT (GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)" "void glMatrixRotatefEXT (GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)" "void glMatrixScaledEXT (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z)" "void glMatrixScalefEXT (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z)" "void glMatrixTranslatedEXT (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z)" "void glMatrixTranslatefEXT (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z)" "void glMultiTexBufferEXT (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer)" "void glMultiTexCoordPointerEXT (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void* pointer)" "void glMultiTexEnvfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param)" "void glMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat* params)" "void glMultiTexEnviEXT (GLenum texunit, GLenum target, GLenum pname, GLint param)" "void glMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint* params)" "void glMultiTexGendEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble param)" "void glMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params)" "void glMultiTexGenfEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat param)" "void glMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params)" "void glMultiTexGeniEXT (GLenum texunit, GLenum coord, GLenum pname, GLint param)" "void glMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, const GLint* params)" "void glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels)" "void glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)" "void glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels)" "void glMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint* params)" "void glMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, const GLuint* params)" "void glMultiTexParameterfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param)" "void glMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat* param)" "void glMultiTexParameteriEXT (GLenum texunit, GLenum target, GLenum pname, GLint param)" "void glMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint* param)" "void glMultiTexRenderbufferEXT (GLenum texunit, GLenum target, GLuint renderbuffer)" "void glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels)" "void glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)" "void glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels)" "void glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const void* data, GLenum usage)" "void glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data)" "void glNamedFramebufferRenderbufferEXT (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)" "void glNamedFramebufferTexture1DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glNamedFramebufferTexture2DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glNamedFramebufferTexture3DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)" "void glNamedFramebufferTextureEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)" "void glNamedFramebufferTextureFaceEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face)" "void glNamedFramebufferTextureLayerEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)" "void glNamedProgramLocalParameter4dEXT (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glNamedProgramLocalParameter4dvEXT (GLuint program, GLenum target, GLuint index, const GLdouble* params)" "void glNamedProgramLocalParameter4fEXT (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glNamedProgramLocalParameter4fvEXT (GLuint program, GLenum target, GLuint index, const GLfloat* params)" "void glNamedProgramLocalParameterI4iEXT (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)" "void glNamedProgramLocalParameterI4ivEXT (GLuint program, GLenum target, GLuint index, const GLint* params)" "void glNamedProgramLocalParameterI4uiEXT (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)" "void glNamedProgramLocalParameterI4uivEXT (GLuint program, GLenum target, GLuint index, const GLuint* params)" "void glNamedProgramLocalParameters4fvEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params)" "void glNamedProgramLocalParametersI4ivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params)" "void glNamedProgramLocalParametersI4uivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params)" "void glNamedProgramStringEXT (GLuint program, GLenum target, GLenum format, GLsizei len, const void* string)" "void glNamedRenderbufferStorageEXT (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)" "void glNamedRenderbufferStorageMultisampleCoverageEXT (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)" "void glNamedRenderbufferStorageMultisampleEXT (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)" "void glProgramUniform1fEXT (GLuint program, GLint location, GLfloat v0)" "void glProgramUniform1fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat* value)" "void glProgramUniform1iEXT (GLuint program, GLint location, GLint v0)" "void glProgramUniform1ivEXT (GLuint program, GLint location, GLsizei count, const GLint* value)" "void glProgramUniform1uiEXT (GLuint program, GLint location, GLuint v0)" "void glProgramUniform1uivEXT (GLuint program, GLint location, GLsizei count, const GLuint* value)" "void glProgramUniform2fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1)" "void glProgramUniform2fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat* value)" "void glProgramUniform2iEXT (GLuint program, GLint location, GLint v0, GLint v1)" "void glProgramUniform2ivEXT (GLuint program, GLint location, GLsizei count, const GLint* value)" "void glProgramUniform2uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1)" "void glProgramUniform2uivEXT (GLuint program, GLint location, GLsizei count, const GLuint* value)" "void glProgramUniform3fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)" "void glProgramUniform3fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat* value)" "void glProgramUniform3iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)" "void glProgramUniform3ivEXT (GLuint program, GLint location, GLsizei count, const GLint* value)" "void glProgramUniform3uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)" "void glProgramUniform3uivEXT (GLuint program, GLint location, GLsizei count, const GLuint* value)" "void glProgramUniform4fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)" "void glProgramUniform4fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat* value)" "void glProgramUniform4iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)" "void glProgramUniform4ivEXT (GLuint program, GLint location, GLsizei count, const GLint* value)" "void glProgramUniform4uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)" "void glProgramUniform4uivEXT (GLuint program, GLint location, GLsizei count, const GLuint* value)" "void glProgramUniformMatrix2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix2x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix2x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix3x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix3x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix4x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glProgramUniformMatrix4x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)" "void glPushClientAttribDefaultEXT (GLbitfield mask)" "void glTextureBufferEXT (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)" "void glTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels)" "void glTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)" "void glTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels)" "void glTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, const GLint* params)" "void glTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, const GLuint* params)" "void glTextureParameterfEXT (GLuint texture, GLenum target, GLenum pname, GLfloat param)" "void glTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, const GLfloat* param)" "void glTextureParameteriEXT (GLuint texture, GLenum target, GLenum pname, GLint param)" "void glTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, const GLint* param)" "void glTextureRenderbufferEXT (GLuint texture, GLenum target, GLuint renderbuffer)" "void glTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels)" "void glTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)" "void glTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels)" "GLboolean glUnmapNamedBufferEXT (GLuint buffer)" "void glColorMaskIndexedEXT (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a)" "void glDisableIndexedEXT (GLenum target, GLuint index)" "void glEnableIndexedEXT (GLenum target, GLuint index)" "void glGetBooleanIndexedvEXT (GLenum value, GLuint index, GLboolean* data)" "void glGetIntegerIndexedvEXT (GLenum value, GLuint index, GLint* data)" "GLboolean glIsEnabledIndexedEXT (GLenum target, GLuint index)" "void glDrawArraysInstancedEXT (GLenum mode, GLint start, GLsizei count, GLsizei primcount)" "void glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)" "void glDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)" "void glFogCoordPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer)" "void glFogCoorddEXT (GLdouble coord)" "void glFogCoorddvEXT (const GLdouble *coord)" "void glFogCoordfEXT (GLfloat coord)" "void glFogCoordfvEXT (const GLfloat *coord)" "void glFragmentColorMaterialEXT (GLenum face, GLenum mode)" "void glFragmentLightModelfEXT (GLenum pname, GLfloat param)" "void glFragmentLightModelfvEXT (GLenum pname, GLfloat* params)" "void glFragmentLightModeliEXT (GLenum pname, GLint param)" "void glFragmentLightModelivEXT (GLenum pname, GLint* params)" "void glFragmentLightfEXT (GLenum light, GLenum pname, GLfloat param)" "void glFragmentLightfvEXT (GLenum light, GLenum pname, GLfloat* params)" "void glFragmentLightiEXT (GLenum light, GLenum pname, GLint param)" "void glFragmentLightivEXT (GLenum light, GLenum pname, GLint* params)" "void glFragmentMaterialfEXT (GLenum face, GLenum pname, const GLfloat param)" "void glFragmentMaterialfvEXT (GLenum face, GLenum pname, const GLfloat* params)" "void glFragmentMaterialiEXT (GLenum face, GLenum pname, const GLint param)" "void glFragmentMaterialivEXT (GLenum face, GLenum pname, const GLint* params)" "void glGetFragmentLightfvEXT (GLenum light, GLenum pname, GLfloat* params)" "void glGetFragmentLightivEXT (GLenum light, GLenum pname, GLint* params)" "void glGetFragmentMaterialfvEXT (GLenum face, GLenum pname, const GLfloat* params)" "void glGetFragmentMaterialivEXT (GLenum face, GLenum pname, const GLint* params)" "void glLightEnviEXT (GLenum pname, GLint param)" "void glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)" "void glRenderbufferStorageMultisampleEXT (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)" "void glBindFramebufferEXT (GLenum target, GLuint framebuffer)" "void glBindRenderbufferEXT (GLenum target, GLuint renderbuffer)" "GLenum glCheckFramebufferStatusEXT (GLenum target)" "void glDeleteFramebuffersEXT (GLsizei n, const GLuint* framebuffers)" "void glDeleteRenderbuffersEXT (GLsizei n, const GLuint* renderbuffers)" "void glFramebufferRenderbufferEXT (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)" "void glFramebufferTexture1DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glFramebufferTexture2DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)" "void glFramebufferTexture3DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)" "void glGenFramebuffersEXT (GLsizei n, GLuint* framebuffers)" "void glGenRenderbuffersEXT (GLsizei n, GLuint* renderbuffers)" "void glGenerateMipmapEXT (GLenum target)" "void glGetFramebufferAttachmentParameterivEXT (GLenum target, GLenum attachment, GLenum pname, GLint* params)" "void glGetRenderbufferParameterivEXT (GLenum target, GLenum pname, GLint* params)" "GLboolean glIsFramebufferEXT (GLuint framebuffer)" "GLboolean glIsRenderbufferEXT (GLuint renderbuffer)" "void glRenderbufferStorageEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)" "void glFramebufferTextureEXT (GLenum target, GLenum attachment, GLuint texture, GLint level)" "void glFramebufferTextureFaceEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)" "void glFramebufferTextureLayerEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)" "void glProgramParameteriEXT (GLuint program, GLenum pname, GLint value)" "void glProgramEnvParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat* params)" "void glProgramLocalParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat* params)" "void glBindFragDataLocationEXT (GLuint program, GLuint color, const GLchar *name)" "GLint glGetFragDataLocationEXT (GLuint program, const GLchar *name)" "void glGetUniformuivEXT (GLuint program, GLint location, GLuint *params)" "void glGetVertexAttribIivEXT (GLuint index, GLenum pname, GLint *params)" "void glGetVertexAttribIuivEXT (GLuint index, GLenum pname, GLuint *params)" "void glUniform1uiEXT (GLint location, GLuint v0)" "void glUniform1uivEXT (GLint location, GLsizei count, const GLuint *value)" "void glUniform2uiEXT (GLint location, GLuint v0, GLuint v1)" "void glUniform2uivEXT (GLint location, GLsizei count, const GLuint *value)" "void glUniform3uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2)" "void glUniform3uivEXT (GLint location, GLsizei count, const GLuint *value)" "void glUniform4uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)" "void glUniform4uivEXT (GLint location, GLsizei count, const GLuint *value)" "void glVertexAttribI1iEXT (GLuint index, GLint x)" "void glVertexAttribI1ivEXT (GLuint index, const GLint *v)" "void glVertexAttribI1uiEXT (GLuint index, GLuint x)" "void glVertexAttribI1uivEXT (GLuint index, const GLuint *v)" "void glVertexAttribI2iEXT (GLuint index, GLint x, GLint y)" "void glVertexAttribI2ivEXT (GLuint index, const GLint *v)" "void glVertexAttribI2uiEXT (GLuint index, GLuint x, GLuint y)" "void glVertexAttribI2uivEXT (GLuint index, const GLuint *v)" "void glVertexAttribI3iEXT (GLuint index, GLint x, GLint y, GLint z)" "void glVertexAttribI3ivEXT (GLuint index, const GLint *v)" "void glVertexAttribI3uiEXT (GLuint index, GLuint x, GLuint y, GLuint z)" "void glVertexAttribI3uivEXT (GLuint index, const GLuint *v)" "void glVertexAttribI4bvEXT (GLuint index, const GLbyte *v)" "void glVertexAttribI4iEXT (GLuint index, GLint x, GLint y, GLint z, GLint w)" "void glVertexAttribI4ivEXT (GLuint index, const GLint *v)" "void glVertexAttribI4svEXT (GLuint index, const GLshort *v)" "void glVertexAttribI4ubvEXT (GLuint index, const GLubyte *v)" "void glVertexAttribI4uiEXT (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)" "void glVertexAttribI4uivEXT (GLuint index, const GLuint *v)" "void glVertexAttribI4usvEXT (GLuint index, const GLushort *v)" "void glVertexAttribIPointerEXT (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)" "void glGetHistogramEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values)" "void glGetHistogramParameterfvEXT (GLenum target, GLenum pname, GLfloat* params)" "void glGetHistogramParameterivEXT (GLenum target, GLenum pname, GLint* params)" "void glGetMinmaxEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values)" "void glGetMinmaxParameterfvEXT (GLenum target, GLenum pname, GLfloat* params)" "void glGetMinmaxParameterivEXT (GLenum target, GLenum pname, GLint* params)" "void glHistogramEXT (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)" "void glMinmaxEXT (GLenum target, GLenum internalformat, GLboolean sink)" "void glResetHistogramEXT (GLenum target)" "void glResetMinmaxEXT (GLenum target)" "void glIndexFuncEXT (GLenum func, GLfloat ref)" "void glIndexMaterialEXT (GLenum face, GLenum mode)" "void glApplyTextureEXT (GLenum mode)" "void glTextureLightEXT (GLenum pname)" "void glTextureMaterialEXT (GLenum face, GLenum mode)" "void glMultiDrawArraysEXT (GLenum mode, GLint* first, GLsizei *count, GLsizei primcount)" "void glMultiDrawElementsEXT (GLenum mode, GLsizei* count, GLenum type, const GLvoid **indices, GLsizei primcount)" "void glSampleMaskEXT (GLclampf value, GLboolean invert)" "void glSamplePatternEXT (GLenum pattern)" "void glColorTableEXT (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* data)" "void glGetColorTableEXT (GLenum target, GLenum format, GLenum type, void* data)" "void glGetColorTableParameterfvEXT (GLenum target, GLenum pname, GLfloat* params)" "void glGetColorTableParameterivEXT (GLenum target, GLenum pname, GLint* params)" "void glGetPixelTransformParameterfvEXT (GLenum target, GLenum pname, const GLfloat* params)" "void glGetPixelTransformParameterivEXT (GLenum target, GLenum pname, const GLint* params)" "void glPixelTransformParameterfEXT (GLenum target, GLenum pname, const GLfloat param)" "void glPixelTransformParameterfvEXT (GLenum target, GLenum pname, const GLfloat* params)" "void glPixelTransformParameteriEXT (GLenum target, GLenum pname, const GLint param)" "void glPixelTransformParameterivEXT (GLenum target, GLenum pname, const GLint* params)" "void glPointParameterfEXT (GLenum pname, GLfloat param)" "void glPointParameterfvEXT (GLenum pname, const GLfloat* params)" "void glPolygonOffsetEXT (GLfloat factor, GLfloat bias)" "void glBeginSceneEXT (void)" "void glEndSceneEXT (void)" "void glSecondaryColor3bEXT (GLbyte red, GLbyte green, GLbyte blue)" "void glSecondaryColor3bvEXT (const GLbyte *v)" "void glSecondaryColor3dEXT (GLdouble red, GLdouble green, GLdouble blue)" "void glSecondaryColor3dvEXT (const GLdouble *v)" "void glSecondaryColor3fEXT (GLfloat red, GLfloat green, GLfloat blue)" "void glSecondaryColor3fvEXT (const GLfloat *v)" "void glSecondaryColor3iEXT (GLint red, GLint green, GLint blue)" "void glSecondaryColor3ivEXT (const GLint *v)" "void glSecondaryColor3sEXT (GLshort red, GLshort green, GLshort blue)" "void glSecondaryColor3svEXT (const GLshort *v)" "void glSecondaryColor3ubEXT (GLubyte red, GLubyte green, GLubyte blue)" "void glSecondaryColor3ubvEXT (const GLubyte *v)" "void glSecondaryColor3uiEXT (GLuint red, GLuint green, GLuint blue)" "void glSecondaryColor3uivEXT (const GLuint *v)" "void glSecondaryColor3usEXT (GLushort red, GLushort green, GLushort blue)" "void glSecondaryColor3usvEXT (const GLushort *v)" "void glSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLvoid *pointer)" "void glActiveStencilFaceEXT (GLenum face)" "void glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels)" "void glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)" "void glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels)" "void glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels)" "void glTexBufferEXT (GLenum target, GLenum internalformat, GLuint buffer)" "void glClearColorIiEXT (GLint red, GLint green, GLint blue, GLint alpha)" "void glClearColorIuiEXT (GLuint red, GLuint green, GLuint blue, GLuint alpha)" "void glGetTexParameterIivEXT (GLenum target, GLenum pname, GLint *params)" "void glGetTexParameterIuivEXT (GLenum target, GLenum pname, GLuint *params)" "void glTexParameterIivEXT (GLenum target, GLenum pname, const GLint *params)" "void glTexParameterIuivEXT (GLenum target, GLenum pname, const GLuint *params)" "GLboolean glAreTexturesResidentEXT (GLsizei n, const GLuint* textures, GLboolean* residences)" "void glBindTextureEXT (GLenum target, GLuint texture)" "void glDeleteTexturesEXT (GLsizei n, const GLuint* textures)" "void glGenTexturesEXT (GLsizei n, GLuint* textures)" "GLboolean glIsTextureEXT (GLuint texture)" "void glPrioritizeTexturesEXT (GLsizei n, const GLuint* textures, const GLclampf* priorities)" "void glTextureNormalEXT (GLenum mode)" "void glGetQueryObjecti64vEXT (GLuint id, GLenum pname, GLint64EXT *params)" "void glGetQueryObjectui64vEXT (GLuint id, GLenum pname, GLuint64EXT *params)" "void glBeginTransformFeedbackEXT (GLenum primitiveMode)" "void glBindBufferBaseEXT (GLenum target, GLuint index, GLuint buffer)" "void glBindBufferOffsetEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset)" "void glBindBufferRangeEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)" "void glEndTransformFeedbackEXT (void)" "void glGetTransformFeedbackVaryingEXT (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei *size, GLenum *type, char *name)" "void glTransformFeedbackVaryingsEXT (GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode)" "void glArrayElementEXT (GLint i)" "void glColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer)" "void glDrawArraysEXT (GLenum mode, GLint first, GLsizei count)" "void glEdgeFlagPointerEXT (GLsizei stride, GLsizei count, const GLboolean* pointer)" "void glGetPointervEXT (GLenum pname, void** params)" "void glIndexPointerEXT (GLenum type, GLsizei stride, GLsizei count, const void* pointer)" "void glNormalPointerEXT (GLenum type, GLsizei stride, GLsizei count, const void* pointer)" "void glTexCoordPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer)" "void glVertexPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer)" "void glBeginVertexShaderEXT (void)" "GLuint glBindLightParameterEXT (GLenum light, GLenum value)" "GLuint glBindMaterialParameterEXT (GLenum face, GLenum value)" "GLuint glBindParameterEXT (GLenum value)" "GLuint glBindTexGenParameterEXT (GLenum unit, GLenum coord, GLenum value)" "GLuint glBindTextureUnitParameterEXT (GLenum unit, GLenum value)" "void glBindVertexShaderEXT (GLuint id)" "void glDeleteVertexShaderEXT (GLuint id)" "void glDisableVariantClientStateEXT (GLuint id)" "void glEnableVariantClientStateEXT (GLuint id)" "void glEndVertexShaderEXT (void)" "void glExtractComponentEXT (GLuint res, GLuint src, GLuint num)" "GLuint glGenSymbolsEXT (GLenum dataType, GLenum storageType, GLenum range, GLuint components)" "GLuint glGenVertexShadersEXT (GLuint range)" "void glGetInvariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data)" "void glGetInvariantFloatvEXT (GLuint id, GLenum value, GLfloat *data)" "void glGetInvariantIntegervEXT (GLuint id, GLenum value, GLint *data)" "void glGetLocalConstantBooleanvEXT (GLuint id, GLenum value, GLboolean *data)" "void glGetLocalConstantFloatvEXT (GLuint id, GLenum value, GLfloat *data)" "void glGetLocalConstantIntegervEXT (GLuint id, GLenum value, GLint *data)" "void glGetVariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data)" "void glGetVariantFloatvEXT (GLuint id, GLenum value, GLfloat *data)" "void glGetVariantIntegervEXT (GLuint id, GLenum value, GLint *data)" "void glGetVariantPointervEXT (GLuint id, GLenum value, GLvoid **data)" "void glInsertComponentEXT (GLuint res, GLuint src, GLuint num)" "GLboolean glIsVariantEnabledEXT (GLuint id, GLenum cap)" "void glSetInvariantEXT (GLuint id, GLenum type, GLvoid *addr)" "void glSetLocalConstantEXT (GLuint id, GLenum type, GLvoid *addr)" "void glShaderOp1EXT (GLenum op, GLuint res, GLuint arg1)" "void glShaderOp2EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2)" "void glShaderOp3EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)" "void glSwizzleEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)" "void glVariantPointerEXT (GLuint id, GLenum type, GLuint stride, GLvoid *addr)" "void glVariantbvEXT (GLuint id, GLbyte *addr)" "void glVariantdvEXT (GLuint id, GLdouble *addr)" "void glVariantfvEXT (GLuint id, GLfloat *addr)" "void glVariantivEXT (GLuint id, GLint *addr)" "void glVariantsvEXT (GLuint id, GLshort *addr)" "void glVariantubvEXT (GLuint id, GLubyte *addr)" "void glVariantuivEXT (GLuint id, GLuint *addr)" "void glVariantusvEXT (GLuint id, GLushort *addr)" "void glWriteMaskEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)" "void glVertexWeightPointerEXT (GLint size, GLenum type, GLsizei stride, void* pointer)" "void glVertexWeightfEXT (GLfloat weight)" "void glVertexWeightfvEXT (GLfloat* weight)" "void glFrameTerminatorGREMEDY (void)" "void glStringMarkerGREMEDY (GLsizei len, const void* string)" "void glGetImageTransformParameterfvHP (GLenum target, GLenum pname, const GLfloat* params)" "void glGetImageTransformParameterivHP (GLenum target, GLenum pname, const GLint* params)" "void glImageTransformParameterfHP (GLenum target, GLenum pname, const GLfloat param)" "void glImageTransformParameterfvHP (GLenum target, GLenum pname, const GLfloat* params)" "void glImageTransformParameteriHP (GLenum target, GLenum pname, const GLint param)" "void glImageTransformParameterivHP (GLenum target, GLenum pname, const GLint* params)" "void glMultiModeDrawArraysIBM (const GLenum* mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride)" "void glMultiModeDrawElementsIBM (const GLenum* mode, const GLsizei *count, GLenum type, const GLvoid * const *indices, GLsizei primcount, GLint modestride)" "void glColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glEdgeFlagPointerListIBM (GLint stride, const GLboolean ** pointer, GLint ptrstride)" "void glFogCoordPointerListIBM (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glIndexPointerListIBM (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glNormalPointerListIBM (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glSecondaryColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glTexCoordPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glVertexPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride)" "void glColorPointervINTEL (GLint size, GLenum type, const void** pointer)" "void glNormalPointervINTEL (GLenum type, const void** pointer)" "void glTexCoordPointervINTEL (GLint size, GLenum type, const void** pointer)" "void glVertexPointervINTEL (GLint size, GLenum type, const void** pointer)" "void glTexScissorFuncINTEL (GLenum target, GLenum lfunc, GLenum hfunc)" "void glTexScissorINTEL (GLenum target, GLclampf tlow, GLclampf thigh)" "GLuint glBufferRegionEnabledEXT (void)" "void glDeleteBufferRegionEXT (GLenum region)" "void glDrawBufferRegionEXT (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest)" "GLuint glNewBufferRegionEXT (GLenum region)" "void glReadBufferRegionEXT (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height)" "void glResizeBuffersMESA (void)" "void glWindowPos2dMESA (GLdouble x, GLdouble y)" "void glWindowPos2dvMESA (const GLdouble* p)" "void glWindowPos2fMESA (GLfloat x, GLfloat y)" "void glWindowPos2fvMESA (const GLfloat* p)" "void glWindowPos2iMESA (GLint x, GLint y)" "void glWindowPos2ivMESA (const GLint* p)" "void glWindowPos2sMESA (GLshort x, GLshort y)" "void glWindowPos2svMESA (const GLshort* p)" "void glWindowPos3dMESA (GLdouble x, GLdouble y, GLdouble z)" "void glWindowPos3dvMESA (const GLdouble* p)" "void glWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z)" "void glWindowPos3fvMESA (const GLfloat* p)" "void glWindowPos3iMESA (GLint x, GLint y, GLint z)" "void glWindowPos3ivMESA (const GLint* p)" "void glWindowPos3sMESA (GLshort x, GLshort y, GLshort z)" "void glWindowPos3svMESA (const GLshort* p)" "void glWindowPos4dMESA (GLdouble x, GLdouble y, GLdouble z, GLdouble)" "void glWindowPos4dvMESA (const GLdouble* p)" "void glWindowPos4fMESA (GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glWindowPos4fvMESA (const GLfloat* p)" "void glWindowPos4iMESA (GLint x, GLint y, GLint z, GLint w)" "void glWindowPos4ivMESA (const GLint* p)" "void glWindowPos4sMESA (GLshort x, GLshort y, GLshort z, GLshort w)" "void glWindowPos4svMESA (const GLshort* p)" "void glBeginConditionalRenderNV (GLuint id, GLenum mode)" "void glEndConditionalRenderNV (void)" "void glClearDepthdNV (GLdouble depth)" "void glDepthBoundsdNV (GLdouble zmin, GLdouble zmax)" "void glDepthRangedNV (GLdouble zNear, GLdouble zFar)" "void glEvalMapsNV (GLenum target, GLenum mode)" "void glGetMapAttribParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat* params)" "void glGetMapAttribParameterivNV (GLenum target, GLuint index, GLenum pname, GLint* params)" "void glGetMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void* points)" "void glGetMapParameterfvNV (GLenum target, GLenum pname, GLfloat* params)" "void glGetMapParameterivNV (GLenum target, GLenum pname, GLint* params)" "void glMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void* points)" "void glMapParameterfvNV (GLenum target, GLenum pname, const GLfloat* params)" "void glMapParameterivNV (GLenum target, GLenum pname, const GLint* params)" "void glGetMultisamplefvNV (GLenum pname, GLuint index, GLfloat* val)" "void glSampleMaskIndexedNV (GLuint index, GLbitfield mask)" "void glTexRenderbufferNV (GLenum target, GLuint renderbuffer)" "void glDeleteFencesNV (GLsizei n, const GLuint* fences)" "void glFinishFenceNV (GLuint fence)" "void glGenFencesNV (GLsizei n, GLuint* fences)" "void glGetFenceivNV (GLuint fence, GLenum pname, GLint* params)" "GLboolean glIsFenceNV (GLuint fence)" "void glSetFenceNV (GLuint fence, GLenum condition)" "GLboolean glTestFenceNV (GLuint fence)" "void glGetProgramNamedParameterdvNV (GLuint id, GLsizei len, const GLubyte* name, GLdouble *params)" "void glGetProgramNamedParameterfvNV (GLuint id, GLsizei len, const GLubyte* name, GLfloat *params)" "void glProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glProgramNamedParameter4dvNV (GLuint id, GLsizei len, const GLubyte* name, const GLdouble *v)" "void glProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glProgramNamedParameter4fvNV (GLuint id, GLsizei len, const GLubyte* name, const GLfloat *v)" "void glRenderbufferStorageMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)" "void glProgramVertexLimitNV (GLenum target, GLint limit)" "void glProgramEnvParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)" "void glProgramEnvParameterI4ivNV (GLenum target, GLuint index, const GLint *params)" "void glProgramEnvParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)" "void glProgramEnvParameterI4uivNV (GLenum target, GLuint index, const GLuint *params)" "void glProgramEnvParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params)" "void glProgramEnvParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params)" "void glProgramLocalParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)" "void glProgramLocalParameterI4ivNV (GLenum target, GLuint index, const GLint *params)" "void glProgramLocalParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)" "void glProgramLocalParameterI4uivNV (GLenum target, GLuint index, const GLuint *params)" "void glProgramLocalParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params)" "void glProgramLocalParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params)" "void glColor3hNV (GLhalf red, GLhalf green, GLhalf blue)" "void glColor3hvNV (const GLhalf* v)" "void glColor4hNV (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha)" "void glColor4hvNV (const GLhalf* v)" "void glFogCoordhNV (GLhalf fog)" "void glFogCoordhvNV (const GLhalf* fog)" "void glMultiTexCoord1hNV (GLenum target, GLhalf s)" "void glMultiTexCoord1hvNV (GLenum target, const GLhalf* v)" "void glMultiTexCoord2hNV (GLenum target, GLhalf s, GLhalf t)" "void glMultiTexCoord2hvNV (GLenum target, const GLhalf* v)" "void glMultiTexCoord3hNV (GLenum target, GLhalf s, GLhalf t, GLhalf r)" "void glMultiTexCoord3hvNV (GLenum target, const GLhalf* v)" "void glMultiTexCoord4hNV (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q)" "void glMultiTexCoord4hvNV (GLenum target, const GLhalf* v)" "void glNormal3hNV (GLhalf nx, GLhalf ny, GLhalf nz)" "void glNormal3hvNV (const GLhalf* v)" "void glSecondaryColor3hNV (GLhalf red, GLhalf green, GLhalf blue)" "void glSecondaryColor3hvNV (const GLhalf* v)" "void glTexCoord1hNV (GLhalf s)" "void glTexCoord1hvNV (const GLhalf* v)" "void glTexCoord2hNV (GLhalf s, GLhalf t)" "void glTexCoord2hvNV (const GLhalf* v)" "void glTexCoord3hNV (GLhalf s, GLhalf t, GLhalf r)" "void glTexCoord3hvNV (const GLhalf* v)" "void glTexCoord4hNV (GLhalf s, GLhalf t, GLhalf r, GLhalf q)" "void glTexCoord4hvNV (const GLhalf* v)" "void glVertex2hNV (GLhalf x, GLhalf y)" "void glVertex2hvNV (const GLhalf* v)" "void glVertex3hNV (GLhalf x, GLhalf y, GLhalf z)" "void glVertex3hvNV (const GLhalf* v)" "void glVertex4hNV (GLhalf x, GLhalf y, GLhalf z, GLhalf w)" "void glVertex4hvNV (const GLhalf* v)" "void glVertexAttrib1hNV (GLuint index, GLhalf x)" "void glVertexAttrib1hvNV (GLuint index, const GLhalf* v)" "void glVertexAttrib2hNV (GLuint index, GLhalf x, GLhalf y)" "void glVertexAttrib2hvNV (GLuint index, const GLhalf* v)" "void glVertexAttrib3hNV (GLuint index, GLhalf x, GLhalf y, GLhalf z)" "void glVertexAttrib3hvNV (GLuint index, const GLhalf* v)" "void glVertexAttrib4hNV (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w)" "void glVertexAttrib4hvNV (GLuint index, const GLhalf* v)" "void glVertexAttribs1hvNV (GLuint index, GLsizei n, const GLhalf* v)" "void glVertexAttribs2hvNV (GLuint index, GLsizei n, const GLhalf* v)" "void glVertexAttribs3hvNV (GLuint index, GLsizei n, const GLhalf* v)" "void glVertexAttribs4hvNV (GLuint index, GLsizei n, const GLhalf* v)" "void glVertexWeighthNV (GLhalf weight)" "void glVertexWeighthvNV (const GLhalf* weight)" "void glBeginOcclusionQueryNV (GLuint id)" "void glDeleteOcclusionQueriesNV (GLsizei n, const GLuint* ids)" "void glEndOcclusionQueryNV (void)" "void glGenOcclusionQueriesNV (GLsizei n, GLuint* ids)" "void glGetOcclusionQueryivNV (GLuint id, GLenum pname, GLint* params)" "void glGetOcclusionQueryuivNV (GLuint id, GLenum pname, GLuint* params)" "GLboolean glIsOcclusionQueryNV (GLuint id)" "void glProgramBufferParametersIivNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params)" "void glProgramBufferParametersIuivNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params)" "void glProgramBufferParametersfvNV (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params)" "void glFlushPixelDataRangeNV (GLenum target)" "void glPixelDataRangeNV (GLenum target, GLsizei length, void* pointer)" "void glPointParameteriNV (GLenum pname, GLint param)" "void glPointParameterivNV (GLenum pname, const GLint* params)" "void glGetVideoi64vNV (GLuint video_slot, GLenum pname, GLint64EXT* params)" "void glGetVideoivNV (GLuint video_slot, GLenum pname, GLint* params)" "void glGetVideoui64vNV (GLuint video_slot, GLenum pname, GLuint64EXT* params)" "void glGetVideouivNV (GLuint video_slot, GLenum pname, GLuint* params)" "void glPresentFrameDualFillNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3)" "void glPresentFrameKeyedNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1)" "void glVideoParameterivNV (GLuint video_slot, GLenum pname, const GLint* params)" "void glPrimitiveRestartIndexNV (GLuint index)" "void glPrimitiveRestartNV (void)" "void glCombinerInputNV (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)" "void glCombinerOutputNV (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)" "void glCombinerParameterfNV (GLenum pname, GLfloat param)" "void glCombinerParameterfvNV (GLenum pname, const GLfloat* params)" "void glCombinerParameteriNV (GLenum pname, GLint param)" "void glCombinerParameterivNV (GLenum pname, const GLint* params)" "void glFinalCombinerInputNV (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)" "void glGetCombinerInputParameterfvNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params)" "void glGetCombinerInputParameterivNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params)" "void glGetCombinerOutputParameterfvNV (GLenum stage, GLenum portion, GLenum pname, GLfloat* params)" "void glGetCombinerOutputParameterivNV (GLenum stage, GLenum portion, GLenum pname, GLint* params)" "void glGetFinalCombinerInputParameterfvNV (GLenum variable, GLenum pname, GLfloat* params)" "void glGetFinalCombinerInputParameterivNV (GLenum variable, GLenum pname, GLint* params)" "void glCombinerStageParameterfvNV (GLenum stage, GLenum pname, const GLfloat* params)" "void glGetCombinerStageParameterfvNV (GLenum stage, GLenum pname, GLfloat* params)" "void glActiveVaryingNV (GLuint program, const GLchar *name)" "void glBeginTransformFeedbackNV (GLenum primitiveMode)" "void glBindBufferBaseNV (GLenum target, GLuint index, GLuint buffer)" "void glBindBufferOffsetNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset)" "void glBindBufferRangeNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)" "void glEndTransformFeedbackNV (void)" "void glGetActiveVaryingNV (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)" "void glGetTransformFeedbackVaryingNV (GLuint program, GLuint index, GLint *location)" "GLint glGetVaryingLocationNV (GLuint program, const GLchar *name)" "void glTransformFeedbackAttribsNV (GLuint count, const GLint *attribs, GLenum bufferMode)" "void glTransformFeedbackVaryingsNV (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode)" "void glFlushVertexArrayRangeNV (void)" "void glVertexArrayRangeNV (GLsizei length, void* pointer)" "GLboolean glAreProgramsResidentNV (GLsizei n, const GLuint* ids, GLboolean *residences)" "void glBindProgramNV (GLenum target, GLuint id)" "void glDeleteProgramsNV (GLsizei n, const GLuint* ids)" "void glExecuteProgramNV (GLenum target, GLuint id, const GLfloat* params)" "void glGenProgramsNV (GLsizei n, GLuint* ids)" "void glGetProgramParameterdvNV (GLenum target, GLuint index, GLenum pname, GLdouble* params)" "void glGetProgramParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat* params)" "void glGetProgramStringNV (GLuint id, GLenum pname, GLubyte* program)" "void glGetProgramivNV (GLuint id, GLenum pname, GLint* params)" "void glGetTrackMatrixivNV (GLenum target, GLuint address, GLenum pname, GLint* params)" "void glGetVertexAttribPointervNV (GLuint index, GLenum pname, GLvoid** pointer)" "void glGetVertexAttribdvNV (GLuint index, GLenum pname, GLdouble* params)" "void glGetVertexAttribfvNV (GLuint index, GLenum pname, GLfloat* params)" "void glGetVertexAttribivNV (GLuint index, GLenum pname, GLint* params)" "GLboolean glIsProgramNV (GLuint id)" "void glLoadProgramNV (GLenum target, GLuint id, GLsizei len, const GLubyte* program)" "void glProgramParameter4dNV (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble* params)" "void glProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat* params)" "void glProgramParameters4dvNV (GLenum target, GLuint index, GLuint num, const GLdouble* params)" "void glProgramParameters4fvNV (GLenum target, GLuint index, GLuint num, const GLfloat* params)" "void glRequestResidentProgramsNV (GLsizei n, GLuint* ids)" "void glTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform)" "void glVertexAttrib1dNV (GLuint index, GLdouble x)" "void glVertexAttrib1dvNV (GLuint index, const GLdouble* v)" "void glVertexAttrib1fNV (GLuint index, GLfloat x)" "void glVertexAttrib1fvNV (GLuint index, const GLfloat* v)" "void glVertexAttrib1sNV (GLuint index, GLshort x)" "void glVertexAttrib1svNV (GLuint index, const GLshort* v)" "void glVertexAttrib2dNV (GLuint index, GLdouble x, GLdouble y)" "void glVertexAttrib2dvNV (GLuint index, const GLdouble* v)" "void glVertexAttrib2fNV (GLuint index, GLfloat x, GLfloat y)" "void glVertexAttrib2fvNV (GLuint index, const GLfloat* v)" "void glVertexAttrib2sNV (GLuint index, GLshort x, GLshort y)" "void glVertexAttrib2svNV (GLuint index, const GLshort* v)" "void glVertexAttrib3dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z)" "void glVertexAttrib3dvNV (GLuint index, const GLdouble* v)" "void glVertexAttrib3fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z)" "void glVertexAttrib3fvNV (GLuint index, const GLfloat* v)" "void glVertexAttrib3sNV (GLuint index, GLshort x, GLshort y, GLshort z)" "void glVertexAttrib3svNV (GLuint index, const GLshort* v)" "void glVertexAttrib4dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)" "void glVertexAttrib4dvNV (GLuint index, const GLdouble* v)" "void glVertexAttrib4fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glVertexAttrib4fvNV (GLuint index, const GLfloat* v)" "void glVertexAttrib4sNV (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)" "void glVertexAttrib4svNV (GLuint index, const GLshort* v)" "void glVertexAttrib4ubNV (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)" "void glVertexAttrib4ubvNV (GLuint index, const GLubyte* v)" "void glVertexAttribPointerNV (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer)" "void glVertexAttribs1dvNV (GLuint index, GLsizei n, const GLdouble* v)" "void glVertexAttribs1fvNV (GLuint index, GLsizei n, const GLfloat* v)" "void glVertexAttribs1svNV (GLuint index, GLsizei n, const GLshort* v)" "void glVertexAttribs2dvNV (GLuint index, GLsizei n, const GLdouble* v)" "void glVertexAttribs2fvNV (GLuint index, GLsizei n, const GLfloat* v)" "void glVertexAttribs2svNV (GLuint index, GLsizei n, const GLshort* v)" "void glVertexAttribs3dvNV (GLuint index, GLsizei n, const GLdouble* v)" "void glVertexAttribs3fvNV (GLuint index, GLsizei n, const GLfloat* v)" "void glVertexAttribs3svNV (GLuint index, GLsizei n, const GLshort* v)" "void glVertexAttribs4dvNV (GLuint index, GLsizei n, const GLdouble* v)" "void glVertexAttribs4fvNV (GLuint index, GLsizei n, const GLfloat* v)" "void glVertexAttribs4svNV (GLuint index, GLsizei n, const GLshort* v)" "void glVertexAttribs4ubvNV (GLuint index, GLsizei n, const GLubyte* v)" "void glClearDepthfOES (GLclampd depth)" "void glClipPlanefOES (GLenum plane, const GLfloat* equation)" "void glDepthRangefOES (GLclampf n, GLclampf f)" "void glFrustumfOES (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)" "void glGetClipPlanefOES (GLenum plane, GLfloat* equation)" "void glOrthofOES (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)" "void glDetailTexFuncSGIS (GLenum target, GLsizei n, const GLfloat* points)" "void glGetDetailTexFuncSGIS (GLenum target, GLfloat* points)" "void glFogFuncSGIS (GLsizei n, const GLfloat* points)" "void glGetFogFuncSGIS (GLfloat* points)" "void glSampleMaskSGIS (GLclampf value, GLboolean invert)" "void glSamplePatternSGIS (GLenum pattern)" "void glGetSharpenTexFuncSGIS (GLenum target, GLfloat* points)" "void glSharpenTexFuncSGIS (GLenum target, GLsizei n, const GLfloat* points)" "void glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void* pixels)" "void glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const void* pixels)" "void glGetTexFilterFuncSGIS (GLenum target, GLenum filter, GLfloat* weights)" "void glTexFilterFuncSGIS (GLenum target, GLenum filter, GLsizei n, const GLfloat* weights)" "void glAsyncMarkerSGIX (GLuint marker)" "void glDeleteAsyncMarkersSGIX (GLuint marker, GLsizei range)" "GLint glFinishAsyncSGIX (GLuint* markerp)" "GLuint glGenAsyncMarkersSGIX (GLsizei range)" "GLboolean glIsAsyncMarkerSGIX (GLuint marker)" "GLint glPollAsyncSGIX (GLuint* markerp)" "void glFlushRasterSGIX (void)" "void glTextureFogSGIX (GLenum pname)" "void glFragmentColorMaterialSGIX (GLenum face, GLenum mode)" "void glFragmentLightModelfSGIX (GLenum pname, GLfloat param)" "void glFragmentLightModelfvSGIX (GLenum pname, GLfloat* params)" "void glFragmentLightModeliSGIX (GLenum pname, GLint param)" "void glFragmentLightModelivSGIX (GLenum pname, GLint* params)" "void glFragmentLightfSGIX (GLenum light, GLenum pname, GLfloat param)" "void glFragmentLightfvSGIX (GLenum light, GLenum pname, GLfloat* params)" "void glFragmentLightiSGIX (GLenum light, GLenum pname, GLint param)" "void glFragmentLightivSGIX (GLenum light, GLenum pname, GLint* params)" "void glFragmentMaterialfSGIX (GLenum face, GLenum pname, const GLfloat param)" "void glFragmentMaterialfvSGIX (GLenum face, GLenum pname, const GLfloat* params)" "void glFragmentMaterialiSGIX (GLenum face, GLenum pname, const GLint param)" "void glFragmentMaterialivSGIX (GLenum face, GLenum pname, const GLint* params)" "void glGetFragmentLightfvSGIX (GLenum light, GLenum value, GLfloat* data)" "void glGetFragmentLightivSGIX (GLenum light, GLenum value, GLint* data)" "void glGetFragmentMaterialfvSGIX (GLenum face, GLenum pname, const GLfloat* data)" "void glGetFragmentMaterialivSGIX (GLenum face, GLenum pname, const GLint* data)" "void glFrameZoomSGIX (GLint factor)" "void glPixelTexGenSGIX (GLenum mode)" "void glReferencePlaneSGIX (const GLdouble* equation)" "void glSpriteParameterfSGIX (GLenum pname, GLfloat param)" "void glSpriteParameterfvSGIX (GLenum pname, GLfloat* params)" "void glSpriteParameteriSGIX (GLenum pname, GLint param)" "void glSpriteParameterivSGIX (GLenum pname, GLint* params)" "void glTagSampleBufferSGIX (void)" "void glColorTableParameterfvSGI (GLenum target, GLenum pname, const GLfloat* params)" "void glColorTableParameterivSGI (GLenum target, GLenum pname, const GLint* params)" "void glColorTableSGI (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table)" "void glCopyColorTableSGI (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)" "void glGetColorTableParameterfvSGI (GLenum target, GLenum pname, GLfloat* params)" "void glGetColorTableParameterivSGI (GLenum target, GLenum pname, GLint* params)" "void glGetColorTableSGI (GLenum target, GLenum format, GLenum type, void* table)" "void glFinishTextureSUNX (void)" "void glGlobalAlphaFactorbSUN (GLbyte factor)" "void glGlobalAlphaFactordSUN (GLdouble factor)" "void glGlobalAlphaFactorfSUN (GLfloat factor)" "void glGlobalAlphaFactoriSUN (GLint factor)" "void glGlobalAlphaFactorsSUN (GLshort factor)" "void glGlobalAlphaFactorubSUN (GLubyte factor)" "void glGlobalAlphaFactoruiSUN (GLuint factor)" "void glGlobalAlphaFactorusSUN (GLushort factor)" "void glReadVideoPixelsSUN (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)" "void glReplacementCodePointerSUN (GLenum type, GLsizei stride, const void* pointer)" "void glReplacementCodeubSUN (GLubyte code)" "void glReplacementCodeubvSUN (const GLubyte* code)" "void glReplacementCodeuiSUN (GLuint code)" "void glReplacementCodeuivSUN (const GLuint* code)" "void glReplacementCodeusSUN (GLushort code)" "void glReplacementCodeusvSUN (const GLushort* code)" "void glColor3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)" "void glColor3fVertex3fvSUN (const GLfloat* c, const GLfloat *v)" "void glColor4fNormal3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glColor4fNormal3fVertex3fvSUN (const GLfloat* c, const GLfloat *n, const GLfloat *v)" "void glColor4ubVertex2fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)" "void glColor4ubVertex2fvSUN (const GLubyte* c, const GLfloat *v)" "void glColor4ubVertex3fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)" "void glColor4ubVertex3fvSUN (const GLubyte* c, const GLfloat *v)" "void glNormal3fVertex3fSUN (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glNormal3fVertex3fvSUN (const GLfloat* n, const GLfloat *v)" "void glReplacementCodeuiColor3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiColor3fVertex3fvSUN (const GLuint* rc, const GLfloat *c, const GLfloat *v)" "void glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint* rc, const GLfloat *c, const GLfloat *n, const GLfloat *v)" "void glReplacementCodeuiColor4ubVertex3fSUN (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint* rc, const GLubyte *c, const GLfloat *v)" "void glReplacementCodeuiNormal3fVertex3fSUN (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint* rc, const GLfloat *n, const GLfloat *v)" "void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint* rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)" "void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint* rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v)" "void glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint* rc, const GLfloat *tc, const GLfloat *v)" "void glReplacementCodeuiVertex3fSUN (GLuint rc, GLfloat x, GLfloat y, GLfloat z)" "void glReplacementCodeuiVertex3fvSUN (const GLuint* rc, const GLfloat *v)" "void glTexCoord2fColor3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)" "void glTexCoord2fColor3fVertex3fvSUN (const GLfloat* tc, const GLfloat *c, const GLfloat *v)" "void glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)" "void glTexCoord2fColor4ubVertex3fSUN (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)" "void glTexCoord2fColor4ubVertex3fvSUN (const GLfloat* tc, const GLubyte *c, const GLfloat *v)" "void glTexCoord2fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)" "void glTexCoord2fNormal3fVertex3fvSUN (const GLfloat* tc, const GLfloat *n, const GLfloat *v)" "void glTexCoord2fVertex3fSUN (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)" "void glTexCoord2fVertex3fvSUN (const GLfloat* tc, const GLfloat *v)" "void glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)" "void glTexCoord4fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)" "void glTexCoord4fVertex4fvSUN (const GLfloat* tc, const GLfloat *v)" "void glAddSwapHintRectWIN (GLint x, GLint y, GLsizei width, GLsizei height)" ] } proc tcl3dOglGetFuncVersionList {} { return [list GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_1 GL_VERSION_1_2 GL_VERSION_1_2 GL_VERSION_1_2 GL_VERSION_1_2 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_3 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_4 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_1_5 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_0 GL_VERSION_2_1 GL_VERSION_2_1 GL_VERSION_2_1 GL_VERSION_2_1 GL_VERSION_2_1 GL_VERSION_2_1 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_VERSION_3_0 GL_3DFX_tbuffer GL_APPLE_element_array GL_APPLE_element_array GL_APPLE_element_array GL_APPLE_element_array GL_APPLE_element_array GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_fence GL_APPLE_flush_buffer_range GL_APPLE_flush_buffer_range GL_APPLE_texture_range GL_APPLE_texture_range GL_APPLE_vertex_array_object GL_APPLE_vertex_array_object GL_APPLE_vertex_array_object GL_APPLE_vertex_array_object GL_APPLE_vertex_array_range GL_APPLE_vertex_array_range GL_APPLE_vertex_array_range GL_ARB_color_buffer_float GL_ARB_draw_buffers GL_ARB_draw_instanced GL_ARB_draw_instanced GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_framebuffer_object GL_ARB_geometry_shader4 GL_ARB_geometry_shader4 GL_ARB_geometry_shader4 GL_ARB_geometry_shader4 GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_imaging GL_ARB_instanced_arrays GL_ARB_map_buffer_range GL_ARB_map_buffer_range GL_ARB_matrix_palette GL_ARB_matrix_palette GL_ARB_matrix_palette GL_ARB_matrix_palette GL_ARB_matrix_palette GL_ARB_multisample GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_multitexture GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_occlusion_query GL_ARB_point_parameters GL_ARB_point_parameters GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_shader_objects GL_ARB_texture_buffer_object GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_texture_compression GL_ARB_transpose_matrix GL_ARB_transpose_matrix GL_ARB_transpose_matrix GL_ARB_transpose_matrix GL_ARB_vertex_array_object GL_ARB_vertex_array_object GL_ARB_vertex_array_object GL_ARB_vertex_array_object GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_blend GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_buffer_object GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_program GL_ARB_vertex_shader GL_ARB_vertex_shader GL_ARB_vertex_shader GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ARB_window_pos GL_ATI_draw_buffers GL_ATI_element_array GL_ATI_element_array GL_ATI_element_array GL_ATI_envmap_bumpmap GL_ATI_envmap_bumpmap GL_ATI_envmap_bumpmap GL_ATI_envmap_bumpmap GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_fragment_shader GL_ATI_map_object_buffer GL_ATI_map_object_buffer GL_ATI_pn_triangles GL_ATI_pn_triangles GL_ATI_separate_stencil GL_ATI_separate_stencil GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_array_object GL_ATI_vertex_attrib_array_object GL_ATI_vertex_attrib_array_object GL_ATI_vertex_attrib_array_object GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_ATI_vertex_streams GL_EXT_bindable_uniform GL_EXT_bindable_uniform GL_EXT_bindable_uniform GL_EXT_blend_color GL_EXT_blend_equation_separate GL_EXT_blend_func_separate GL_EXT_blend_minmax GL_EXT_color_subtable GL_EXT_color_subtable GL_EXT_compiled_vertex_array GL_EXT_compiled_vertex_array GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_convolution GL_EXT_coordinate_frame GL_EXT_coordinate_frame GL_EXT_copy_texture GL_EXT_copy_texture GL_EXT_copy_texture GL_EXT_copy_texture GL_EXT_copy_texture GL_EXT_cull_vertex GL_EXT_cull_vertex GL_EXT_depth_bounds_test GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_direct_state_access GL_EXT_draw_buffers2 GL_EXT_draw_buffers2 GL_EXT_draw_buffers2 GL_EXT_draw_buffers2 GL_EXT_draw_buffers2 GL_EXT_draw_buffers2 GL_EXT_draw_instanced GL_EXT_draw_instanced GL_EXT_draw_range_elements GL_EXT_fog_coord GL_EXT_fog_coord GL_EXT_fog_coord GL_EXT_fog_coord GL_EXT_fog_coord GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_fragment_lighting GL_EXT_framebuffer_blit GL_EXT_framebuffer_multisample GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_framebuffer_object GL_EXT_geometry_shader4 GL_EXT_geometry_shader4 GL_EXT_geometry_shader4 GL_EXT_geometry_shader4 GL_EXT_gpu_program_parameters GL_EXT_gpu_program_parameters GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_gpu_shader4 GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_histogram GL_EXT_index_func GL_EXT_index_material GL_EXT_light_texture GL_EXT_light_texture GL_EXT_light_texture GL_EXT_multi_draw_arrays GL_EXT_multi_draw_arrays GL_EXT_multisample GL_EXT_multisample GL_EXT_paletted_texture GL_EXT_paletted_texture GL_EXT_paletted_texture GL_EXT_paletted_texture GL_EXT_pixel_transform GL_EXT_pixel_transform GL_EXT_pixel_transform GL_EXT_pixel_transform GL_EXT_pixel_transform GL_EXT_pixel_transform GL_EXT_point_parameters GL_EXT_point_parameters GL_EXT_polygon_offset GL_EXT_scene_marker GL_EXT_scene_marker GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_secondary_color GL_EXT_stencil_two_side GL_EXT_subtexture GL_EXT_subtexture GL_EXT_subtexture GL_EXT_texture3D GL_EXT_texture_buffer_object GL_EXT_texture_integer GL_EXT_texture_integer GL_EXT_texture_integer GL_EXT_texture_integer GL_EXT_texture_integer GL_EXT_texture_integer GL_EXT_texture_object GL_EXT_texture_object GL_EXT_texture_object GL_EXT_texture_object GL_EXT_texture_object GL_EXT_texture_object GL_EXT_texture_perturb_normal GL_EXT_timer_query GL_EXT_timer_query GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_transform_feedback GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_array GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_shader GL_EXT_vertex_weighting GL_EXT_vertex_weighting GL_EXT_vertex_weighting GL_GREMEDY_frame_terminator GL_GREMEDY_string_marker GL_HP_image_transform GL_HP_image_transform GL_HP_image_transform GL_HP_image_transform GL_HP_image_transform GL_HP_image_transform GL_IBM_multimode_draw_arrays GL_IBM_multimode_draw_arrays GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_IBM_vertex_array_lists GL_INTEL_parallel_arrays GL_INTEL_parallel_arrays GL_INTEL_parallel_arrays GL_INTEL_parallel_arrays GL_INTEL_texture_scissor GL_INTEL_texture_scissor GL_KTX_buffer_region GL_KTX_buffer_region GL_KTX_buffer_region GL_KTX_buffer_region GL_KTX_buffer_region GL_MESA_resize_buffers GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_MESA_window_pos GL_NV_conditional_render GL_NV_conditional_render GL_NV_depth_buffer_float GL_NV_depth_buffer_float GL_NV_depth_buffer_float GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_evaluators GL_NV_explicit_multisample GL_NV_explicit_multisample GL_NV_explicit_multisample GL_NV_fence GL_NV_fence GL_NV_fence GL_NV_fence GL_NV_fence GL_NV_fence GL_NV_fence GL_NV_fragment_program GL_NV_fragment_program GL_NV_fragment_program GL_NV_fragment_program GL_NV_fragment_program GL_NV_fragment_program GL_NV_framebuffer_multisample_coverage GL_NV_geometry_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_gpu_program4 GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_half_float GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_occlusion_query GL_NV_parameter_buffer_object GL_NV_parameter_buffer_object GL_NV_parameter_buffer_object GL_NV_pixel_data_range GL_NV_pixel_data_range GL_NV_point_sprite GL_NV_point_sprite GL_NV_present_video GL_NV_present_video GL_NV_present_video GL_NV_present_video GL_NV_present_video GL_NV_present_video GL_NV_present_video GL_NV_primitive_restart GL_NV_primitive_restart GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners GL_NV_register_combiners2 GL_NV_register_combiners2 GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_transform_feedback GL_NV_vertex_array_range GL_NV_vertex_array_range GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_NV_vertex_program GL_OES_single_precision GL_OES_single_precision GL_OES_single_precision GL_OES_single_precision GL_OES_single_precision GL_OES_single_precision GL_SGIS_detail_texture GL_SGIS_detail_texture GL_SGIS_fog_function GL_SGIS_fog_function GL_SGIS_multisample GL_SGIS_multisample GL_SGIS_sharpen_texture GL_SGIS_sharpen_texture GL_SGIS_texture4D GL_SGIS_texture4D GL_SGIS_texture_filter4 GL_SGIS_texture_filter4 GL_SGIX_async GL_SGIX_async GL_SGIX_async GL_SGIX_async GL_SGIX_async GL_SGIX_async GL_SGIX_flush_raster GL_SGIX_fog_texture GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_fragment_specular_lighting GL_SGIX_framezoom GL_SGIX_pixel_texture GL_SGIX_reference_plane GL_SGIX_sprite GL_SGIX_sprite GL_SGIX_sprite GL_SGIX_sprite GL_SGIX_tag_sample_buffer GL_SGI_color_table GL_SGI_color_table GL_SGI_color_table GL_SGI_color_table GL_SGI_color_table GL_SGI_color_table GL_SGI_color_table GL_SUNX_constant_data GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_global_alpha GL_SUN_read_video_pixels GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_triangle_list GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_SUN_vertex GL_WIN_swap_hint ] } proc tcl3dOglGetInfoLogARB {object} { set infoLenVec [tcl3dVector GLint 1] glGetObjectParameterivARB $object GL_OBJECT_INFO_LOG_LENGTH_ARB $infoLenVec set infoLen [$infoLenVec get 0] set infoStr "" if { $infoLen > 0 } { set infoStrVec [tcl3dVector GLubyte $infoLen] glGetInfoLogARB $object $infoLen "NULL" $infoStrVec set infoStr [tcl3dVectorToString $infoStrVec] $infoStrVec delete } $infoLenVec delete return $infoStr } proc tcl3dOglGetIntState {state {numVals 1}} { if { $numVals <= 0 } { error "Number of values must be greater than zero" } set vec [tcl3dVector GLint $numVals] glGetIntegerv $state $vec if { $numVals == 1 } { set val [$vec get 0] } else { set val [tcl3dVectorToList $vec $numVals] } $vec delete return $val } proc tcl3dOglGetMaxTextureSize {} { return [tcl3dOglGetIntState GL_MAX_TEXTURE_SIZE] } proc tcl3dOglGetMaxTextureUnits {} { return [tcl3dOglGetIntState GL_MAX_TEXTURE_UNITS] } proc tcl3dOglGetProgramInfoLog {program} { set infoLenVec [tcl3dVector GLint 1] glGetProgramiv $program GL_INFO_LOG_LENGTH $infoLenVec set infoLen [$infoLenVec get 0] set infoStr "" if { $infoLen > 0 } { set infoStrVec [tcl3dVector GLubyte $infoLen] glGetProgramInfoLog $program $infoLen "NULL" $infoStrVec set infoStr [tcl3dVectorToString $infoStrVec] $infoStrVec delete } $infoLenVec delete return $infoStr } proc tcl3dOglGetShaderInfoLog {shader} { set infoLenVec [tcl3dVector GLint 1] glGetShaderiv $shader GL_INFO_LOG_LENGTH $infoLenVec set infoLen [$infoLenVec get 0] set infoStr "" if { $infoLen > 0 } { set infoStrVec [tcl3dVector GLubyte $infoLen] glGetShaderInfoLog $shader $infoLen "NULL" $infoStrVec set infoStr [tcl3dVectorToString $infoStrVec] $infoStrVec delete } $infoLenVec delete return $infoStr } proc tcl3dOglGetShaderSource {shader} { set srcLenVec [tcl3dVector GLint 1] glGetShaderiv $shader GL_SHADER_SOURCE_LENGTH $srcLenVec set srcLen [$srcLenVec get 0] set srcStr "" if { $srcLen > 0 } { set srcStrVec [tcl3dVector GLubyte $srcLen] glGetShaderSource $shader $srcLen "NULL" $srcStrVec set srcStr [tcl3dVectorToString $srcStrVec] $srcStrVec delete } $srcLenVec delete return $srcStr } proc tcl3dOglGetStates {{sortFlag none}} { set maxSize 20 set intVec [tcl3dVector GLint $maxSize] set boolVec [tcl3dVector GLboolean $maxSize] set ubyteVec [tcl3dVector GLubyte $maxSize] set floatVec [tcl3dVector GLfloat $maxSize] set doubleVec [tcl3dVector GLdouble $maxSize] set stateList [tcl3dGetStateList] set row 0 set globalResult {} foreach line $stateList { for { set i 0 } { $i < $maxSize } { incr i } { $intVec set $i -10000 $ubyteVec set $i 100 $boolVec set $i 100 $floatVec set $i -10000.0 $doubleVec set $i -10000.0 } set glCmd [lindex $line 0] set enumVal [lindex $line 1] set numVals [lindex $line 2] set initVal [lindex $line 3] if { [llength [info commands $glCmd]] == 0 } { puts "Not found cmd: $glCmd" lappend globalResult [list 0 $glCmd $enumVal "Not available"] set cmdList [__tcl3dOglFindExtension "cmd" $glCmd] puts "\tFound $cmdList instead" } else { set cmdList $glCmd } if { [llength [info globals $enumVal]] == 0 } { puts "Not found enum: $enumVal" set enumList [__tcl3dOglFindExtension "enum" $enumVal] puts "\tFound $enumList instead" } else { set enumList $enumVal } # Put all functions ending with "fv" which need special handling # at the top. All others are handled with the default case used # for glGetFloatv. foreach glCmd $cmdList { set result {} if { [string equal "glGetPixelMapfv" $glCmd] } { set sizeEnum [format "%s_SIZE" $enumVal] glGetIntegerv $sizeEnum $intVec set numMapEntries [$intVec get 0] set mapTable [tcl3dVector GLfloat $numMapEntries] $glCmd $enumVal $mapTable set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numMapEntries } { incr i } { lappend result [$mapTable get $i] } $mapTable delete # puts "\t$enumVal is $result (Should be $initVal)" } elseif { [string equal "glGetMaterialfv" $glCmd] } { foreach face { GL_FRONT GL_BACK GL_FRONT_AND_BACK } { $glCmd $face $enumVal $floatVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$floatVec get $i] } # puts "\t$face $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetLightfv" $glCmd] } { for {set lgtNum 0 } { $lgtNum < 8 } { incr lgtNum } { set light [format "GL_LIGHT%d" $lgtNum] $glCmd $light $enumVal $floatVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$floatVec get $i] } # puts "\t$light $enumVal is $result (Shoud be $initVal)" } } elseif { [string match "glGetTexLevel*iv" $glCmd] } { foreach target { GL_TEXTURE_1D GL_TEXTURE_2D } { $glCmd $target 0 $enumVal $intVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$intVec get $i] } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string match "glGetTex*fv" $glCmd] } { foreach target { GL_TEXTURE_1D GL_TEXTURE_2D } { $glCmd $target $enumVal $floatVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$floatVec get $i] } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string match "glGetTex*iv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_TEXTURE_1D GL_TEXTURE_2D } { $glCmd $target $enumVal $intVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$intVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetColorTableParameterfv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_COLOR_TABLE GL_POST_CONVOLUTION_COLOR_TABLE GL_POST_COLOR_MATRIX_COLOR_TABLE GL_PROXY_COLOR_TABLE GL_PROXY_POST_CONVOLUTION_COLOR_TABLE GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE } { $glCmd $target $enumVal $floatVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$floatVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetColorTableParameteriv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_COLOR_TABLE GL_POST_CONVOLUTION_COLOR_TABLE GL_POST_COLOR_MATRIX_COLOR_TABLE GL_PROXY_COLOR_TABLE GL_PROXY_POST_CONVOLUTION_COLOR_TABLE GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE } { $glCmd $target $enumVal $intVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$intVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetConvolutionParameterfv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_CONVOLUTION_1D GL_CONVOLUTION_2D GL_SEPARABLE_2D } { $glCmd $target $enumVal $floatVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$floatVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetConvolutionParameteriv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_CONVOLUTION_1D GL_CONVOLUTION_2D GL_SEPARABLE_2D } { $glCmd $target $enumVal $intVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$intVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetVertexAttribiv" $glCmd] } { if { [llength [info globals GL_MAX_VERTEX_ATTRIBS]] == 0 } { set enumName [lindex [__tcl3dOglFindExtension "enum" GL_MAX_VERTEX_ATTRIBS] 0] } else { set enumName GL_MAX_VERTEX_ATTRIBS } glGetIntegerv $enumName $intVec set numAttributes [$intVec get 0] foreach enumVal $enumList { set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numAttributes } { incr i } { $glCmd $i $enumVal $intVec for { set j 0 } { $j < 4 } { incr j } { lappend tmpResult [$intVec get $j] } } set result $tmpResult # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetVertexAttribfv" $glCmd] } { if { [llength [info globals GL_MAX_VERTEX_ATTRIBS]] == 0 } { set enumName [lindex [__tcl3dOglFindExtension "enum" GL_MAX_VERTEX_ATTRIBS] 0] } else { set enumName GL_MAX_VERTEX_ATTRIBS } glGetFloatv $enumName $floatVec set numAttributes [$floatVec get 0] foreach enumVal $enumList { set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numAttributes } { incr i } { $glCmd $i $enumVal $floatVec for { set j 0 } { $j < 4 } { incr j } { lappend tmpResult [$floatVec get $j] } } set result $tmpResult # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetMapfv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_MAP1_VERTEX_3 GL_MAP1_VERTEX_4 GL_MAP1_INDEX GL_MAP1_COLOR_4 GL_MAP1_NORMAL GL_MAP1_TEXTURE_COORD_1 GL_MAP1_TEXTURE_COORD_2 GL_MAP1_TEXTURE_COORD_3 GL_MAP1_TEXTURE_COORD_4 } { $glCmd $target $enumVal $floatVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$floatVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string equal "glGetMapiv" $glCmd] } { foreach enumVal $enumList { foreach target { GL_MAP1_VERTEX_3 GL_MAP1_VERTEX_4 GL_MAP1_INDEX GL_MAP1_COLOR_4 GL_MAP1_NORMAL GL_MAP1_TEXTURE_COORD_1 GL_MAP1_TEXTURE_COORD_2 GL_MAP1_TEXTURE_COORD_3 GL_MAP1_TEXTURE_COORD_4 } { $glCmd $target $enumVal $intVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$intVec get $i] } set result $tmpResult } # puts "\t$target $enumVal is $result (Shoud be $initVal)" } } elseif { [string match "glGetUniform*v" $glCmd] } { puts "NOT handled glCmd <$glCmd $enumVal $numVals>" set result [list 0 $glCmd $enumVal "--"] } elseif { [string equal "glGetFloatv" $glCmd] || [string match "*fv" $glCmd] } { $glCmd $enumVal $floatVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$floatVec get $i] } # puts "\t$enumVal is $result (Should be $initVal)" } elseif { [string equal "glGetIntegerv" $glCmd] } { foreach enumVal $enumList { $glCmd $enumVal $intVec set tmpResult [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend tmpResult [$intVec get $i] } set result $tmpResult } # puts "\t$enumVal is $result (Shoud be $initVal)" } elseif { [string equal "glGetBooleanv" $glCmd] } { $glCmd $enumVal $boolVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$boolVec get $i] } # puts "\t$enumVal is $result (Shoud be $initVal)" } elseif { [string equal "glGetClipPlane" $glCmd] } { $glCmd $enumVal $doubleVec set result [list 1 $glCmd $enumVal] for { set i 0 } { $i < $numVals } { incr i } { lappend result [$doubleVec get $i] } # puts "\t$enumVal is $result (Should be $initVal)" } elseif { [string equal "glIsEnabled" $glCmd] } { foreach enumVal $enumList { set tmpResult [list 1 $glCmd $enumVal] lappend tmpResult [$glCmd $enumVal] set result $tmpResult } # puts "\t$enumVal is $result (Shoud be $initVal)" } elseif { [string equal "glGetPolygonStipple" $glCmd] } { # OPA TODO Core dump on Windows # $glCmd $ubyteVec # set result [list 1 $glCmd $enumVal] # for { set i 0 } { $i < $numVals } { incr i } { # lappend result [$ubyteVec get $i] # } # puts "\t$enumVal is $result (Shoud be $initVal)" } else { puts "NOT handled glCmd <$glCmd $enumVal $numVals>" set result [list 0 $glCmd $enumVal "--"] } lappend globalResult $result incr row } } if { $sortFlag eq "increasing" || $sortFlag eq "decreasing" } { return [lsort -index 1 -$sortFlag $globalResult] } else { return $globalResult } } proc tcl3dOglGetVersion {} { if { [info commands glGetString] ne "" } { return [glGetString GL_VERSION] } else { return "" } } proc tcl3dOglGetVersions {} { set versList {} set version [glGetString GL_VENDOR] lappend versList [list GL_VENDOR $version] set version [glGetString GL_RENDERER] lappend versList [list GL_RENDERER $version] set version [glGetString GL_VERSION] lappend versList [list GL_VERSION $version] if { [info exists ::GLU_VERSION_1_1] } { set version [gluGetString GLU_VERSION] lappend versList [list GLU_VERSION $version] } else { lappend versList [list GLU_VERSION "1.0"] } if { [info global GL_SHADING_LANGUAGE_VERSION] ne "" } { set version [glGetString GL_SHADING_LANGUAGE_VERSION] lappend versList [list GL_SHADING_LANGUAGE_VERSION $version] } return $versList } proc tcl3dOglGetViewport {} { return [tcl3dOglGetIntState GL_VIEWPORT 4] } proc tcl3dOglHaveExtension {extensionName} { foreach glInfo [tcl3dOglGetExtensions] { set found [lsearch -exact [lindex $glInfo 1] $extensionName] if { $found >= 0 } { return 1 } } return 0 } proc tcl3dOglHaveFunc {glFuncName} { set checkCmd [format "__%sAvail" $glFuncName] if { [info commands $checkCmd] eq "" } { if { [info commands $glFuncName] eq "" } { return 0 } else { return 1 } } else { return [$checkCmd] } } proc tcl3dOglHaveVersion {majorWanted {minorWanted 0} {patchWanted 0}} { set versionStr [glGetString GL_VERSION] # Add Mac OSX specific match: Version string looks like "1.2 APPLE-1.4.56" set index [string first "APPLE-" $versionStr] if { $index >= 0 } { set versionStr [string range $versionStr [expr $index + 6] end] } if {3 != [scan $versionStr "%d.%d.%d" majorHave minorHave patchHave] } { set patchHave 0 if {2 != [scan $versionStr "%d.%d" majorHave minorHave] } { set minorHave 0 if {1 != [scan $versionStr "%d" majorHave] } { error "Could not determine GL version from $versionStr" } } } set numberHave [expr $majorHave*100 + $minorHave*10 + $patchHave] set numberWanted [expr $majorWanted*100 + $minorWanted*10 + $patchWanted] if { $numberHave >= $numberWanted } { return 1 } return 0 } proc tcl3dOglSetDebugMode {{printCmd puts}} { foreach glFunc [tcl3dOglGetFuncList] { __tcl3dOglCreateSafeOrDebugFunc $glFunc 1 0 } } proc tcl3dOglSetMode {mode {printCmd puts}} { if { $mode eq "normal" } { tcl3dOglSetNormalMode $printCmd } elseif { $mode eq "safe" } { tcl3dOglSetSafeMode $printCmd } elseif { $mode eq "debug" } { tcl3dOglSetDebugMode $printCmd } else { error "Unknown OpenGL mode: $mode" } } proc tcl3dOglSetNormalMode {{printCmd puts}} { foreach glFunc [tcl3dOglGetFuncList] { __tcl3dOglCreateSafeOrDebugFunc $glFunc 0 1 } } proc tcl3dOglSetSafeMode {{printCmd puts}} { foreach glFunc [tcl3dOglGetFuncList] { __tcl3dOglCreateSafeOrDebugFunc $glFunc 0 0 } } proc tcl3dOglShaderSource {shaderId shaderString} { set shaderStringList [list $shaderString] set lenList [list [string length $shaderString]] glShaderSource $shaderId 1 $shaderStringList $lenList } proc tcl3dOsgGetVersion {} { if { [info commands osg::osgGetVersion] ne "" } { return [osg::osgGetVersion] } else { return "" } } proc tcl3dRadToDeg {ang} { return [expr {$ang * 180.0 / 3.1415926535}] } proc tcl3dRgb2Name {r g b} { return [format "\#%02X%02X%02X" $r $g $b] } proc tcl3dRgba2Name {r g b a} { return [format "\#%02X%02X%02X%02X" $r $g $b $a] } proc tcl3dRgbaf2Name {r g b a} { return [format "\#%02X%02X%02X%02X" [expr {int ($r*255.0)}] [expr {int ($g*255.0)}] [expr {int ($b*255.0)}] [expr {int ($a*255.0)}]] } proc tcl3dRgbf2Name {r g b} { return [format "\#%02X%02X%02X" [expr {int ($r*255.0)}] [expr {int ($g*255.0)}] [expr {int ($b*255.0)}]] } proc tcl3dSDLGetVersion {} { if { [info commands SDL_Linked_Version] ne "" } { set vers [SDL_Linked_Version] return [format "%d.%d.%d" [$vers cget -major] [$vers cget -minor] [$vers cget -patch]] } else { return "" } } proc tcl3dSetFullScreenMode {wid} { set sh [winfo screenheight $wid] set sw [winfo screenwidth $wid] wm minsize $wid $sw $sh wm maxsize $wid $sw $sh set fmtStr [format "%dx%d+0+0" $sw $sh] wm geometry $wid $fmtStr wm overrideredirect $wid 1 focus -force $wid } proc tcl3dSetScrolledTitle {wid titleStr {fgColor black}} { set pathList [split $wid "."] # Index -3 is needed for CreateScrolledFrame. # Index -2 is needed for all other widget types. foreach ind { -2 -3 } { set parList [lrange $pathList 0 [expr [llength $pathList] $ind]] set parPath [join $parList "."] set labelPath $parPath append labelPath ".label" if { [winfo exists $labelPath] } { $labelPath configure -text $titleStr -foreground $fgColor break } } } proc tcl3dSetWindowMode {wid w h} { set sh [winfo screenheight $wid] set sw [winfo screenwidth $wid] wm minsize $wid 10 10 wm maxsize $wid $sw $sh set fmtStr [format "%dx%d+0+25" $w $h] wm geometry $wid $fmtStr wm overrideredirect $wid 0 focus -force $wid } proc tcl3dShowIndicator {} { if { [tcl3dHaveAqua] } { return true } else { return false } } proc tcl3dShowPackageInfo {} { set tw .tcl3d:PkgInfoWin catch { destroy $tw } toplevel $tw wm title $tw "Tcl3D Packages" wm resizable $tw true true frame $tw.fr0 -relief sunken -borderwidth 1 grid $tw.fr0 -row 0 -column 0 -sticky nwse set pkgInfoList [tcl3dGetPackageInfo] set numPkgs [llength $pkgInfoList] set textId [tcl3dCreateScrolledText $tw.fr0 "" -wrap word -height $numPkgs] foreach pkgInfo $pkgInfoList { set msgStr "Package [lindex $pkgInfo 0]: [lindex $pkgInfo 2] [lindex $pkgInfo 3]\n" if { [lindex $pkgInfo 1] == 1} { set tag avail } else { set tag unavail } $textId insert end $msgStr $tag } $textId tag configure avail -background green $textId tag configure unavail -background red $textId configure -state disabled # Create OK button frame $tw.fr1 -relief sunken -borderwidth 1 grid $tw.fr1 -row 1 -column 0 -sticky nwse button $tw.fr1.b -text "OK" -command "destroy $tw" -default active bind $tw.fr1.b "destroy $tw" pack $tw.fr1.b -side left -fill x -padx 2 -expand 1 grid columnconfigure $tw 0 -weight 1 grid rowconfigure $tw 0 -weight 1 bind $tw "destroy $tw" bind $tw "destroy $tw" focus $tw } proc tcl3dTbAnimate {toglwin animate} { global __tcl3dTB set __tcl3dTB(animate,$toglwin) $animate } proc tcl3dTbInit {toglwin} { global __tcl3dTB set __tcl3dTB(swatch,$toglwin) [tcl3dNewSwatch] tcl3dStartSwatch $__tcl3dTB(swatch,$toglwin) set __tcl3dTB(lasttime,$toglwin) [_tcl3dTbGetTimeMS $toglwin] set __tcl3dTB(tracking,$toglwin) 0 set __tcl3dTB(animate,$toglwin) 1 set __tcl3dTB(curQuat,$toglwin) [tcl3dVector GLfloat 4] set __tcl3dTB(lastQuat,$toglwin) [tcl3dVector GLfloat 4] tcl3dTrackball $__tcl3dTB(curQuat,$toglwin) 0.0 0.0 0.0 0.0 } proc tcl3dTbMatrix {toglwin} { global __tcl3dTB set m [tcl3dVector GLfloat 16] tcl3dTrackballBuildRotMatrix $m $__tcl3dTB(curQuat,$toglwin) set ml [tcl3dVectorToList $m 16] glMultMatrixf $ml $m delete } proc tcl3dTbMotion {toglwin x y} { global __tcl3dTB if { $__tcl3dTB(tracking,$toglwin) } { set __tcl3dTB(lasttime,$toglwin) [_tcl3dTbGetTimeMS $toglwin] set w $__tcl3dTB(width,$toglwin) set h $__tcl3dTB(height,$toglwin) set bx $__tcl3dTB(beginx,$toglwin) set by $__tcl3dTB(beginy,$toglwin) tcl3dTrackball $__tcl3dTB(lastQuat,$toglwin) [expr {(2.0 * $bx - $w) / $w}] [expr {($h - 2.0 * $by) / $h}] [expr {(2.0 * $x - $w) / $w}] [expr {($h - 2.0 * $y) / $h}] set __tcl3dTB(beginx,$toglwin) $x set __tcl3dTB(beginy,$toglwin) $y tcl3dTrackballAddQuats $__tcl3dTB(lastQuat,$toglwin) $__tcl3dTB(curQuat,$toglwin) $__tcl3dTB(curQuat,$toglwin) $toglwin postredisplay } } proc tcl3dTbReshape {toglwin w h} { global __tcl3dTB set __tcl3dTB(width,$toglwin) $w set __tcl3dTB(height,$toglwin) $h } proc tcl3dTbStartMotion {toglwin x y} { global __tcl3dTB _tcl3dTbStopIdleFunc $toglwin set __tcl3dTB(tracking,$toglwin) 1 set __tcl3dTB(lasttime,$toglwin) [_tcl3dTbGetTimeMS $toglwin ] set __tcl3dTB(beginx,$toglwin) $x set __tcl3dTB(beginy,$toglwin) $y } proc tcl3dTbStopMotion {toglwin} { global __tcl3dTB set __tcl3dTB(tracking,$toglwin) 0 set t [_tcl3dTbGetTimeMS $toglwin ] if { ($t == $__tcl3dTB(lasttime,$toglwin)) && $__tcl3dTB(animate,$toglwin) } { _tcl3dTbAnimate $toglwin } else { _tcl3dTbStopIdleFunc $toglwin } } proc tcl3dToolhelpAddBinding {w str} { global __tcl3dToolhelpWidget if { ![info exists __tcl3dToolhelpWidget]} { tcl3dToolhelpInit .tcl3dToolhelp } bind $w "tcl3dToolhelpShow %X %Y [list $str]" bind $w "tcl3dToolhelpHide" bind $w "tcl3dToolhelpHide" } proc tcl3dToolhelpHide {} { global __tcl3dToolhelpWidget wm geometry $__tcl3dToolhelpWidget [format "+%d+%d" -100 -100] } proc tcl3dToolhelpInit {w {bgColor yellow} {fgColor black}} { global __tcl3dToolhelpWidget # Create Toolbar help window with a simple label in it. if { [winfo exists $w] } { destroy $w } toplevel $w set __tcl3dToolhelpWidget $w label $w.l -text "Toolhelp" -bg $bgColor -fg $fgColor -relief ridge pack $w.l wm overrideredirect $w true if {[tcl3dHaveAqua]} { ::tk::unsupported::MacWindowStyle style $w help none } wm geometry $w [format "+%d+%d" -100 -100] } proc tcl3dToolhelpShow {x y str} { global __tcl3dToolhelpWidget $__tcl3dToolhelpWidget.l configure -text $str raise $__tcl3dToolhelpWidget set labelWidth [winfo width $__tcl3dToolhelpWidget.l] wm geometry $__tcl3dToolhelpWidget [format "+%d+%d" [expr {$x - $labelWidth/2}] [expr {$y +10}]] } proc tcl3dVec3fPrint {vec {precisionString %6.3f}} { for { set i 0 } { $i < 3 } { incr i } { puts -nonewline [format "$precisionString " [$vec get $i]] } puts "" } proc tcl3dVector {type size} { set ptr [new_$type $size] set code { set method [lindex $args 0] set parms [concat $ptr [lrange $args 1 end]] switch $method { get {return [eval "${type}_getitem $parms"]} set {return [eval "${type}_setitem $parms"]} setvec {return [eval "${type}_setvector $parms"]} addvec {return [eval "${type}_addvector $parms"]} mulvec {return [eval "${type}_mulvector $parms"]} delete {eval "delete_$type $ptr; rename $ptr {}"} } } # Create a procedure for the new Tcl3D Vector. uplevel "proc $ptr args {set ptr $ptr; set type $type;$code}" return $ptr } proc tcl3dVectorFromArgs {type args} { set len [llength $args] if { $len == 0 } { error "Vector init has zero length" } set a [tcl3dVector $type $len] set i 0 foreach elem $args { ${type}_setitem $a $i $elem incr i } return $a } proc tcl3dVectorFromByteArray {type str} { set len [string length $str] if { $len == 0 } { error "String has zero length" } set a [tcl3dVector $type $len] tcl3dByteArray2Vector $str $a $len 0 0 return $a } proc tcl3dVectorFromLinspace {type s e n} { if { $s > $e } { error "Start value ($s) greater than end value ($e)" } if { $n <= 0 } { error "Vector length ($n) not positive." } if { [info commands tcl3dVectorLinspace_$type] eq "" } { error "Linspace command not supported for type ($type)." } set a [tcl3dVector $type $n] tcl3dVectorLinspace_$type $a $s $e $n return $a } proc tcl3dVectorFromList {type l {maxElems -1}} { set len [llength $l] if { $len == 0 } { error "List has zero length" } if { $maxElems > 0 } { if { $maxElems < $len } { set len $maxElems } } set a [tcl3dVector $type $len] set fastCmd "tcl3dListToVector_$type" if { [info commands $fastCmd] eq $fastCmd } { $fastCmd $l $a $len } else { set i 0 foreach elem $l { ${type}_setitem $a $i $elem incr i } } return $a } proc tcl3dVectorFromPhoto {phImg {numChans -1} {scl 1.0} {off 0.0}} { set w [image width $phImg] set h [image height $phImg] set n [tcl3dPhotoChans $phImg] if { $numChans > $n || $numChans <= 0 } { set numChans $n } set texImg [tcl3dVector GLubyte [expr {$w * $h * $numChans}]] tcl3dPhotoToVector $phImg $texImg $numChans $scl $off return $texImg } proc tcl3dVectorFromString {type str} { set len [string length $str] if { $len == 0 } { error "String has zero length" } set a [tcl3dVector $type $len] set i 0 foreach elem [split $str ""] { # puts "Setting a($i) to: $elem ( [tcl3dCharToNum $elem] )" $a set $i [tcl3dCharToNum $elem] incr i } return $a } proc tcl3dVectorInd {vec type ind} { eval "${type}_ind $vec $ind" } proc tcl3dVectorPrint {vec num {precisionString %6.3f}} { for { set i 0 } { $i < $num } { incr i } { puts [format "%4d: $precisionString" $i [$vec get $i]] } } proc tcl3dVectorToByteArray {vec numBytes {srcOff 0} {destOff 0}} { if { $numBytes == 0 } { error "Vector has zero length" } # First generate a binary string of approriate size. set tmp [binary format c 0] set bytes [string repeat $tmp $numBytes] tcl3dVector2ByteArray $vec $bytes $numBytes $srcOff $destOff return $bytes } proc tcl3dVectorToList {vec num} { set l {} for { set i 0 } { $i < $num } { incr i } { set val [$vec get $i] lappend l $val } return $l } proc tcl3dVectorToString {vec} { set i 0 set str "" while { 1 } { set val [$vec get $i] if { $val == 0 } { break } append str [tcl3dNumToChar $val] incr i } return $str } proc tcl3dWidget2File {win fileName {ign ""} {fmt JPEG} {opts ""}} { set img [tcl3dWidget2Img $win $ign] if { [string length $fileName] != 0 } { $img write $fileName -format "$fmt $opts" } image delete $img } proc tcl3dWidget2Img {win {ign ""}} { global __tcl3dCaptureInt regexp {([0-9]*)x([0-9]*)\+([0-9]*)\+([0-9]*)} [winfo geometry $win] - w h x y if { !$__tcl3dCaptureInt(Img,avail) } { set img [image create photo -width $h -height $h] $img blank } else { set img [image create photo -format window -data $win] foreach child [winfo children $win] { if { $ign ne "" && ! [string match -nocase $ign $child] } { __tcl3dCaptureSubWindow $child $img 0 0 $ign } } } return $img } proc tcl3dWinIsTop {wid} { string equal $wid [winfo toplevel $wid] } proc tcl3dWinRaise {wid} { wm deiconify $wid update raise $wid } proc tcl3dWindow2Clipboard {} { global __tcl3dCaptureInt if { !$__tcl3dCaptureInt(twapi,avail) } { error "Twapi extension not available" } twapi::send_keys {%{PRTSC}} update } proc tcl3dWindow2File {fileName {fmt JPEG} {opts ""}} { if { $::tcl_platform(platform) eq "windows" } { tcl3dWindow2Clipboard tcl3dClipboard2File $fileName $fmt $opts } else { set img [tcl3dWindow2Img] if { [string length $fileName] != 0 } { $img write $fileName -format "$fmt $opts" } image delete $img } } proc tcl3dWindow2Img {} { if { $::tcl_platform(platform) eq "windows" } { tcl3dWindow2Clipboard return [tcl3dClipboard2Img] } else { set dumpProg [auto_execok "import"] if { $dumpProg ne "" } { set fp [open "|$dumpProg -frame -window [winfo id .] png:-" "r"] fconfigure $fp -translation binary set data [read $fp] close $fp set phImg [image create photo -data $data] return $phImg } else { error "Screenshot on X11 needs the import command (ImageMagick)" } } } proc tclPkgSetup {dir pkg version files} { global auto_index package provide $pkg $version foreach fileInfo $files { set f [lindex $fileInfo 0] set type [lindex $fileInfo 1] foreach cmd [lindex $fileInfo 2] { if {$type eq "load"} { set auto_index($cmd) [list load [file join $dir $f] $pkg] } else { set auto_index($cmd) [list source [file join $dir $f]] } } } } proc tclPkgUnknown {name args} { global auto_path env if {![info exists auto_path]} { return } # Cache the auto_path, because it may change while we run through the # first set of pkgIndex.tcl files set old_path [set use_path $auto_path] while {[llength $use_path]} { set dir [lindex $use_path end] # Make sure we only scan each directory one time. if {[info exists tclSeenPath($dir)]} { set use_path [lrange $use_path 0 end-1] continue } set tclSeenPath($dir) 1 # we can't use glob in safe interps, so enclose the following in a # catch statement, where we get the pkgIndex files out of the # subdirectories catch { foreach file [glob -directory $dir -join -nocomplain * pkgIndex.tcl] { set dir [file dirname $file] if {![info exists procdDirs($dir)]} { try { source $file } trap {POSIX EACCES} {} { # $file was not readable; silently ignore continue } on error msg { tclLog "error reading package index file $file: $msg" } on ok {} { set procdDirs($dir) 1 } } } } set dir [lindex $use_path end] if {![info exists procdDirs($dir)]} { set file [file join $dir pkgIndex.tcl] # safe interps usually don't have "file exists", if {([interp issafe] || [file exists $file])} { try { source $file } trap {POSIX EACCES} {} { # $file was not readable; silently ignore continue } on error msg { tclLog "error reading package index file $file: $msg" } on ok {} { set procdDirs($dir) 1 } } } set use_path [lrange $use_path 0 end-1] # Check whether any of the index scripts we [source]d above set a new # value for $::auto_path. If so, then find any new directories on the # $::auto_path, and lappend them to the $use_path we are working from. # This gives index scripts the (arguably unwise) power to expand the # index script search path while the search is in progress. set index 0 if {[llength $old_path] == [llength $auto_path]} { foreach dir $auto_path old $old_path { if {$dir ne $old} { # This entry in $::auto_path has changed. break } incr index } } # $index now points to the first element of $auto_path that has # changed, or the beginning if $auto_path has changed length Scan the # new elements of $auto_path for directories to add to $use_path. # Don't add directories we've already seen, or ones already on the # $use_path. foreach dir [lrange $auto_path $index end] { if {![info exists tclSeenPath($dir)] && ($dir ni $use_path)} { lappend use_path $dir } } set old_path $auto_path } } proc tcl_findLibrary {basename version patch initScript enVarName varName} { upvar #0 $varName the_library global auto_path env tcl_platform set dirs {} set errors {} # The C application may have hardwired a path, which we honor if {[info exists the_library] && $the_library ne ""} { lappend dirs $the_library } else { # Do the canonical search # 1. From an environment variable, if it exists. Placing this first # gives the end-user ultimate control to work-around any bugs, or # to customize. if {[info exists env($enVarName)]} { lappend dirs $env($enVarName) } # 2. In the package script directory registered within the # configuration of the package itself. catch { lappend dirs [::${basename}::pkgconfig get scriptdir,runtime] } # 3. Relative to auto_path directories. This checks relative to the # Tcl library as well as allowing loading of libraries added to the # auto_path that is not relative to the core library or binary paths. foreach d $auto_path { lappend dirs [file join $d $basename$version] if {$tcl_platform(platform) eq "unix" && $tcl_platform(os) eq "Darwin"} { # 4. On MacOSX, check the Resources/Scripts subdir too lappend dirs [file join $d $basename$version Resources Scripts] } } # 3. Various locations relative to the executable # ../lib/foo1.0 (From bin directory in install hierarchy) # ../../lib/foo1.0 (From bin/arch directory in install hierarchy) # ../library (From unix directory in build hierarchy) # # Remaining locations are out of date (when relevant, they ought to be # covered by the $::auto_path seach above) and disabled. # # ../../library (From unix/arch directory in build hierarchy) # ../../foo1.0.1/library # (From unix directory in parallel build hierarchy) # ../../../foo1.0.1/library # (From unix/arch directory in parallel build hierarchy) set parentDir [file dirname [file dirname [info nameofexecutable]]] set grandParentDir [file dirname $parentDir] lappend dirs [file join $parentDir lib $basename$version] lappend dirs [file join $grandParentDir lib $basename$version] lappend dirs [file join $parentDir library] if {0} { lappend dirs [file join $grandParentDir library] lappend dirs [file join $grandParentDir $basename$patch library] lappend dirs [file join [file dirname $grandParentDir] $basename$patch library] } } # uniquify $dirs in order array set seen {} foreach i $dirs { # Take note that the [file normalize] below has been noted to cause # difficulties for the freewrap utility. See Bug 1072136. Until # freewrap resolves the matter, one might work around the problem by # disabling that branch. if {[interp issafe]} { set norm $i } else { set norm [file normalize $i] } if {[info exists seen($norm)]} { continue } set seen($norm) {} lappend uniqdirs $i } set dirs $uniqdirs foreach i $dirs { set the_library $i set file [file join $i $initScript] # source everything when in a safe interpreter because we have a # source command, but no file exists command if {[interp issafe] || [file exists $file]} { if {![catch {uplevel #0 [list source $file]} msg opts]} { return } append errors "$file: $msg\n" append errors [dict get $opts -errorinfo]\n } } unset -nocomplain the_library set msg "Can't find a usable $initScript in the following directories: \n" append msg " $dirs\n\n" append msg "$errors\n\n" append msg "This probably means that $basename wasn't installed properly.\n" error $msg } proc tcnk {} { set o [LCnk [list 1 2 3 4 5] 3] puts [join $o] exit } proc tcoli {} { puts "[set lel [eLinkREST protein protein 135102]]" set at [eSummaryREST protein $lel] array set T $at foreach a [array names T "*,refseq"] { puts "$a [set T($a)]" } set Lm [IDMapping P_GI ACC $lel] puts "\nmapping" foreach m $Lm e $lel { puts "$e $m" } exit } proc tcr5 {} { set pdbid 1cr5 Structure create $pdbid set pdbText [TextePDB $pdbid ALL "" OnTheWeb] set cok [$pdbid new $pdbText "" 0 1] set seqpdb [join [$pdbid _resname -polymer -chain A] ""] set seqres [$pdbid _seqres A] lassign [NWalign $seqpdb $seqres] a b ShowProtDiff a b puts "" lassign [NW $seqpdb $seqres] a b ShowProtDiff a b exit } proc tct {} { LoadTkAndPackages canvas .c -width 500 -height 500 -scrollregion [list 0 0 500 500] -background black grid .c -row 0 -column 0 -sticky news set id [.c create text 200 200 -text "Salut Le Monde !" -font "Courier 24 bold" -fill white -anchor e -justify right] puts "in [.c coords $id]" .c delete $id set id [.c create text 200 200 -text "Salut Le Monde !" -font "Courier 24 bold" -fill white -angle 306. -anchor e -justify right] puts "out [.c coords $id]" puts "bbox [.c bbox $id]" return } proc tdate {} { source /home/moumou/mime.tcl source /home/moumou/rfc2822.tcl set d "Thu, 27 Sep 2012 09:04:48 EEST" set d "Sun, 2 Jan 2005 09:17:29 +0100" #set date [::mime::parsedatetime $d clock] set date [::rfc2822::parseDate $d] puts "$date" puts "[clock format $date]" set dateDis [clock format $date -format "%Y/%m/%d %H:%M:%S"] puts $dateDis exit set i [clock scan $d] puts $i exit } proc tdbid {} { # see : # http://www.uniprot.org/help/programmatic_access#id_mapping_examples set Ldb " set Ll [LesLignesDuFichier [file join $::OrdSrcDir dbid]] foreach l $Ll { set Lv [split $l \t] if {[llength $Lv] > 2} { lassign $Lv tmp abb sens switch $sens { "both" { lappend Lto $abb lappend Lfrom $abb } "from" { lappend Lfrom $abb } "to" { lappend Lto $abb } } } } puts "from:\n$Lfrom" puts "\nto:\n$Lto" puts "\n[lor $Lfrom $Lto]" exit } proc tdbl {} { namespace import ::tcl::mathfunc::* set L [list [list 24.2 57.9 18.0] [list 32.8 45.4 21.8] [list 51.3 28.1 20.5] [list 28.4 51.0 20.7] [list 63.6 27.9 8.5] [list 39.1 34.9 26.0] [list 56.1 21.7 22.2] [list 35.7 36.3 28.0] [list 46.2 42.4 11.4] [list 34.0 38.5 27.5] [list 35.4 38.3 26.3] [list 35.3 39.6 25.1] [list 56.4 29.2 14.4] [list 41.1 54.1 4.8] [list 25.8 7.4 66.8]] set Le2 [list [list 61. 39. 0.] [list 60. 35. 5.] [list 59. 30. 9.] [list 58. 24. 18.] [list 57. 21.5 21.5] [list 55. 5. 40.] [list 55.1 10. 24.9] [list 65.2 0. 34.8] [list 65.3 5. 29.7] [list 65.4 10. 24.6] [list 65.5 15. 19.5] [list 45. 45. 10.] [list 50. 15. 35.] [list 48. 42. 10.]] set Ls [list] foreach e $L { lassign $e g n p set mx [max $g $n $p] set m2 [expr {($g*$g + $n*$n + $p*$p)/3.}] set s [expr {sqrt($m2 - (100./3.)**2)}] set gn [expr {abs($g - $n)}] set gp [expr {abs($g - $p)}] set np [expr {abs($n - $p)}] set ss [expr {($gn + $gp + $np)/3.}] set d2 [expr {sqrt($gn*$gn+$gp*$gp+$np*$np)}] foreach v {g n p} qs {{n p} {g p} {g n}} { lassign $qs r t if {[set $v] == $mx} { set vr [expr {abs([set $v]-[set $r])}] set sr [expr {[set $v]+[set $r]}] set vt [expr {abs([set $v]-[set $t])}] set st [expr {[set $v]+[set $t]}] if {$vr < $vt} { set md $vr set sd $sr set cmp "$v $r" } else { set md $vt set sd $st set cmp "$v $t" } } } lappend Le [list $d2 $g $n $p $gn $gp $np $s $md $sd $cmp] #puts [format "%5.1f %5.1f %5.1f | %7.1f" $g $n $p [expr {$g*$n*$p}]] } foreach e [lsort -real -index 0 $Le] { puts [format "%6.1f %6.1f %6.1f %6.1f " {*}[lrange $e 0 3]] } exit puts "" set Le [lsort -decreasing -command ttridbl $Le] set Le [lsort -decreasing -command ttridbl $Le] set Le [lsort -decreasing -real -index {7} $Le] foreach e $Le { lassign $e g n p gn gp np s md sd cmp puts [format "%5.1f %5.1f %5.1f %3s %5.1f %6.1f" $g $n $p $cmp $md $sd] } exit return } proc tdbs {} { set a " - tata : { . pk_tata P } " set o " - toto : { . pk_toto P } " set da [FabriqueDeTables $a a.sql] set db [FabriqueDeTables $a b.sql] $a eval {attach b.sql as b} $a eval {insert into } } proc tdbt {} { set tbl " - dhis : { . pk_dhis P . pk_journee I . equipe V32 . joues I . domicile I joue a domicile . exterieur I joue exterier . points R point classement . classement R classement . diff R difference de buts . butpour R but marques . butcontre R but encaisses . pointsDom R points gagne domiciele . classementDom I . diffDom R difference de buts . butpourDom R but marques domiciles . butcontreDom R but encaisses domicile . pointsExt R points gagne domiciele . classementExt I . diffExt R difference de buts . butpourExt R but marques exterier . butcontreExt R but encaisse ext }" set db root set db [FabriqueDeTables $tbl $db ":memory:"] $db eval {attach database curr.sql as cur} } proc tdf {} { set Lid [list p90831 q9run7] set Lgi [Convert2GI protein $Lid] puts "$Lgi" set res [eSummaryREST protein $Lgi] puts "res $res" array set T $res parray T exit set Lid [list q9run7 q8g863 NP_506019 P15179 XP_002131496] set Luni [Convert2UniProtAcc $Lid] set Lres [split [DbFetchGET uniprot $Luni] "\n"] set Lembl [SplitLesEMBL $Lres] foreach em $Lembl { DecortiqueLesLignesEMBL $em ID AC DE GN OS OC OX "" LaDETotal GNTotal foreach v {ID AC DE GN OS OC OX LaDETotal GNTotal} { puts "$v [set $v]" } puts "" } exit return set res [Convert2GI protein $Lid] puts "$Lid" puts "$res" set res2 [eSummaryREST protein $res] array set T $res2 foreach k [array names T "*,TaxId"] { lappend Ltx [set T($k)] } array set Tx [eSummaryREST taxonomy $Ltx] parray Tx #puts "\n[join $res2 \n]" exit } proc tdmp {} { cd /genomics/link/taxonomy/ncbi_taxonomy/ set Ldmp [glob *.dmp] foreach f $Ldmp { puts "\n$f" AnalyseTabulatedFile $f } exit set con [ContenuDuFichier names.dmp] set con [string map {"\t\|\n" "YouPLaBouM"} $con] set con [string map {"\n" " "} $con] set con [string map {"YouPLaBouM" "\n"} $con] set Ll [split $con "\n"] foreach l $Ll { set tx [string range $l 0 [string first "\t" $l]-1] lappend Li $tx if {! [string is integer -strict $tx]} { puts $l } } #puts "[DonneDoublons $Li]" exit } proc te {} { set xml [PDBeInterface [list 1il2 2KOE 2ks9]] set f [open i.xml w] puts $f $xml close $f exit set xml [ContenuDuFichier inte.xml] set res [ResiduesInterface $xml A] puts "$res" exit } proc teccb {} { package require sqlite3 set db "root" sqlite3 $db eccb.sql set lps [$db eval {select pk_participants from participants where Statut='INDUSTRIEL' and Categorie != 'Workshop Only'}] set lpc [$db eval {select pk_participants from participants where Categorie='Industriel'}] set lpw [$db eval {select pk_participants from participants where Categorie='Workshop Only' and Statut='INDUSTRIEL'}] puts "statut : [llength $lps]" puts "catego : [llength $lpc]" puts "all : [llength [lsort -unique [concat $lps $lpc]]]" puts "workon : [llength $lpw]" puts "" puts "land [llength [land $lps $lpc]]" puts "lor from catego : [llength [set lo2 [lor $lps $lpc from2]]]" foreach {nom pre ttc} [$db eval "select Nom,Prenom,TotalTTC from participants where pk_participants in ([join $lo2 ,])"] { puts " $nom $pre $ttc" } puts "" puts "lor from statut : [llength [set lo1 [lor $lps $lpc from1]]]" foreach {nom pre ttc} [$db eval "select Nom,Prenom,TotalTTC from participants where pk_participants in ([join $lo1 ,])"] { puts " $nom $pre $ttc" } exit } proc teli {} { set res [IDMapping "ACC+ID" ACC SYD_ECOLI] puts "$res" set url "http://www.uniprot.org/mapping?query=SYD_ECOLI&from=ACC+ID&to=ACC&format=tab" set url "http://www.uniprot.org/mapping?query=SYDC_HUMAN&from=ACC+ID&to=ID&format=tab" set res [HttpCopy $url] puts "$res" puts "mnemonic" set url "http://www.uniprot.org/uniprot/?query=mnemonic%3aSYFB_SILPO&format=list" set res [HttpCopy $url] puts "$res" exit } proc ten {} { sqlite3 n /genomics/link/genomes/ncbi_genomes/ncbi_genomes.sql set Lt [n eval {select distinct taxid from genomes where Status like 'complete%'}] array set T [eFetchREST $Lt] foreach id $Ft { if {! [info exists T($id,Lineage)]} { lappend Lnf $id continue } set Ln [split $T($id,Lineage)] } } proc tesp {} { set url "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?" set id {( ("aars2"[Abstract] OR "ears2"[Abstract] OR "fars2"[Abstract] OR "hars2"[Abstract] OR "vars2"[Abstract] OR "yars2"[Abstract] OR "cars2"[Abstract] OR "dars2"[Abstract] OR "iars2"[Abstract] OR "lars2"[Abstract] OR "mars2"[Abstract] OR "nars2"[Abstract] OR "rars2"[Abstract] OR "sars2"[Abstract] OR "tars2"[Abstract] OR "wars2"[Abstract] OR "pars2"[Abstract] OR "gars2"[Abstract] OR "kars2"[Abstract]) AND ("2007"[Date - Publication] : "3000"[Date - Publication])) AND ( "mutation"[Title/Abstract] OR "patient"[Title/Abstract] OR "mutations"[Title/Abstract] OR "patients"[Title/Abstract] OR "lbsl"[Title/Abstract] OR "leukoencephalopathy"[Title/Abstract] OR "subject"[Abstract] OR "subjects"[Abstract] OR "disease"[Abstract] OR "diseases"[Abstract] OR "disorder"[Abstract] OR "disorders"[Abstract]) AND "English"[Language]} set id [list "[string map {"\"" "\\\""} $id]"] set Lrep [eSearchREST pubmed $id] puts "[llength $Lrep]" exit set query [::http::formatQuery db pubmed term $id] set ddb [HttpCopy $url "" $query] puts "$ddb" return } proc testAnalyseSelections {outOf} { LesDefauts DefinitionPreferences InitComparaison global SDG global ListeDesAcidesAmines global TableauCouleurEtGroupe global Threshold global Defauts global TypeCons global ConsRef global ListeDesConsensusDuGroupe global Sequences global lesTypes if {$outOf == ""} { set lesTypes [list "_nature" "_mounir" "_bandelettes" "_luc"] set repIn "msf_nature/Rascal/Leon" } else { set lesTypes [list "_Selnature" "_Selmounir" "_Selbandelettes" "_Selluc"] set repIn "msf_Selnature" } set fileOut {} set file {} puts "Info\tNature\tSelMounir\tSelBandelettes\tSelLuc" set Lpab [ListeDesPABs] #set Lpab [lrange $Lpab 224 224] set Lpab "nPDB225 nPDB025 nPDB010" foreach f $Lpab { set lNbSeq {} set lNbSeqId {} set lNbClus {} set lNbIdGlob {} set lNbCGlob {} set lNbSGlob {} set lRandInd {} set ltabSAFinal {} if {![file exists [file join [RepertoireDuGenome] ${repIn} $f]]} {continue} puts "[file join [RepertoireDuGenome] ${repIn} $f]" if {[lsearch [LesLignesDuFichier [file join [RepertoireDuGenome] ${repIn} $f]] "NoSequenceToAlign"] == 0} {continue} set tabSiteActif [DetSiteActifALaVolee $f] #puts "les res des sites actif de $f sont " #EspionneL $tabSiteActif foreach type $lesTypes { puts "pour $type" # mode Batch pour travailler sans interface graphique LesDefauts Mode "Batch" LesDefauts CheckSeq 0 set Threshold [set Defauts(Threshold)] if {$outOf == ""} { set file [file join [RepertoireDuGenome] "msf$type" "Rascal" "Leon" $f] set ficComp "/usr/tmp/${f}_nature.clu" } else { set file [file join [RepertoireDuGenome] "msf$type" $f] set ficComp "/usr/tmp/${f}_Selnature.clu" } puts "file est $file" DecortiqueEtAfficheUnMSF $file DefinitionGroupes "dpc" RunOrdali RecupereReference set grps($type) [array get SDG] set data($type) [RecupereDonneesGlobales $type] EspionneL [set data($type)] lappend lNbSeq [lindex [set data($type)] 0] lappend lNbClus [lindex [set data($type)] 1] lappend lNbIdGlob [lindex [set data($type)] 2] lappend lNbCGlob [lindex [set data($type)] 3] lappend lNbSGlob [lindex [set data($type)] 4] # verification que les residus du site actif son les bons et au bon endroit # on le fait que au moment ou on traite nature if {[regexp "nature" $type]} { set tabPosSiteActif {} regsub -all {\.|Z} [set Sequences($f)] "" LaSeq # pour chaque residu du site actif if { $tabSiteActif != ""} { foreach pos $tabSiteActif { # on compare la (position du site-1) au residu du tableau if { [string index $LaSeq [expr [lindex $pos 1] - 1]] == [lindex $pos 0]} { # si ok, on place la (position-1) dans un tableau lappend tabPosSiteActif [expr [lindex $pos 1] - 1] } } } puts "tab des positions des sites" EspionneL $tabPosSiteActif } #mise en evidence des residus Globaux (identite, conservation et similarite) set lR$type [TabGlobaux $f [set data($type)] $outOf] puts "les truc globaux sont [set lR$type]" #verification de la conservation des res du site actif if {$outOf != ""} { set lR [TabGlobaux $f [set data($type)] ""] } else { set lR [set lR$type] } set tabConsSA$type {} if { [info exists tabPosSiteActif]} { set tabConsSA$type [DeterminationNbConservationSA $lR $tabPosSiteActif] } puts "alors qu est ce qui est conserve est :" EspionneL [set tabConsSA$type] lappend ltabSAFinal [set tabConsSA$type] # traitement du fichier resu de la clusterisation # comparaison des clusters obtenus pour chacune des selection par rapport a la ref # calcul d un indice de conservation set fileOut "/usr/tmp/${f}.dpc" set fic "/usr/tmp/${f}${type}.clu" file copy -force $fileOut $fic if {![regexp "nature" $type]} { set lstat($type) [CompCluster $ficComp $fic] lappend lRandInd [string range [lindex [set lstat($type)] 0] 0 3] lappend lNbSeqId [lindex [set lstat($type)] 1] } else { array set SeqN [array get Sequences] } FermeFichier } set lCommunsGlobaux [DetermineNbGlobauxCommuns [set lR[lindex $lesTypes 1]] [set lR[lindex $lesTypes 2]] [set lR[lindex $lesTypes 3]] [set lR[lindex $lesTypes 0]]] #determination des groupes communs set ListeCorrespondance [DetermineGroupesEquivalents [array get grps] [array get data] [array get SeqN]] puts "\n" puts "${f}_NbResSiteActif\t[llength $tabPosSiteActif]" puts "${f}_DistriSiteActif\t[lindex [ExtraitListeDeListe $ltabSAFinal 0] 0]-[lindex [ExtraitListeDeListe $ltabSAFinal 1] 0]-[lindex [ExtraitListeDeListe $ltabSAFinal 2] 0]\t[lindex [ExtraitListeDeListe $ltabSAFinal 0] 1]-[lindex [ExtraitListeDeListe $ltabSAFinal 1] 1]-[lindex [ExtraitListeDeListe $ltabSAFinal 2] 1]\t[lindex [ExtraitListeDeListe $ltabSAFinal 0] 2]-[lindex [ExtraitListeDeListe $ltabSAFinal 1] 2]-[lindex [ExtraitListeDeListe $ltabSAFinal 2] 2]\t[lindex [ExtraitListeDeListe $ltabSAFinal 0] 3]-[lindex [ExtraitListeDeListe $ltabSAFinal 1] 3]-[lindex [ExtraitListeDeListe $ltabSAFinal 2] 3]" puts "${f}_NbSeqTot\t[lindex $lNbSeq 0]\t[lindex $lNbSeq 1]\t[lindex $lNbSeq 2]\t[lindex $lNbSeq 3]" puts "${f}_NbSeqIden\t[lindex $lNbSeq 0]\t[lindex $lNbSeqId 0]\t[lindex $lNbSeqId 1]\t[lindex $lNbSeqId 2]" puts "${f}_NbIdGlob\t[lindex $lNbIdGlob 0]\t[lindex $lNbIdGlob 1]\t[lindex $lNbIdGlob 2]\t[lindex $lNbIdGlob 3]" puts "${f}_NbIdGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 0] 3]" puts "${f}_NbConsGlob\t[lindex $lNbCGlob 0]\t[lindex $lNbCGlob 1]\t[lindex $lNbCGlob 2]\t[lindex $lNbCGlob 3]" puts "${f}_NbConsGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 1] 3]" puts "${f}_NbSimiGlob\t[lindex $lNbSGlob 0]\t[lindex $lNbSGlob 1]\t[lindex $lNbSGlob 2]\t[lindex $lNbSGlob 3]" puts "${f}_NbSimiGlobCom\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 0]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 1]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 2]\t[lindex [ExtraitListeDeListe $lCommunsGlobaux 2] 3]" puts "${f}_NbClusTot\t[lindex $lNbClus 0]\t[lindex $lNbClus 1]\t[lindex $lNbClus 2]\t[lindex $lNbClus 3]" puts "${f}_aRandIndex\t1\t[lindex $lRandInd 0]\t[lindex $lRandInd 1]\t[lindex $lRandInd 2]" for {set i 1} {$i<=[lindex $lNbClus 0]} {incr i} { puts "${f}_Cl${i}-SqId-IdGrCom\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 0]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 0]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 0]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 1]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 1]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 1]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 2]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 2]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 2]\t[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 4]] 3]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 3]] 3]-[lindex [ExtraitListeDeListe $ListeCorrespondance [expr $i * 4 - 1]] 3]" } # efface fichiers crees pour la clusterisation dans /usr/tmp foreach fic [glob -nocomplain /usr/tmp/*${f}*] { file delete -force $fic } if { [array exists Sequences] } { #puts "j'unset sequences" array unset Sequences } if { [array exists grps] } { #puts "j'unset grps" array unset grps } if { [array exists data] } { #puts "j'unset data" array unset data } if { [array exists SeqN] } { # puts "j'unset seqn" array unset SeqN } } return 1 } proc testAngleEntre {} { set Lv1 [list 1.0 1.0 -1.0 1.0 -1.0 -1.0 1.0 -1.0] set Lv2 [list 0.0 1.0 1.0 -1.0 -1.0 -1.0 1.0 0.0] foreach {x1 y1} $Lv1 { set V1 [list [expr {$x1+0.01}] [expr {$y1+0.01}] 0.0] foreach {x2 y2} $Lv2 { set V2 [list [expr {$x2+0.01}] [expr {$y2+0.01}] 0.0] puts "\n" puts "$V1 | $V2 | [AngleDeg [AngleEntre $V1 $V2]]" } } exit } proc testClusterAvOuSsRef {} { Espionne [ClusterAvOuSsRef "cluster_6346" ref Mouse] Espionne [ClusterAvOuSsRef "cluster_6346" ref Rat] } proc testExec {} { puts [package require Pgtcl] return [exec tcsh -c "setgscoperr Zero -q ; gscope puts ListeDesPABs"] } proc testFeaturesDesPfam {} { set FileMacsims "[RepertoireDuGenome]/macsimXml/SPR0002.orgord" set LesPfamInfoName [FromMacsims $FileMacsims ENSRNOP00000018109_Rattus "ConcatPfam"] set LesBlockInfoName [FromMacsims $FileMacsims ENSRNOP00000018109_Rattus "ConcatBlock"] set LesPrositeInfoName [FromMacsims $FileMacsims ENSRNOP00000018109_Rattus "ConcatProsite"] FeaturesDesPfam toto $LesPfamInfoName $LesPrositeInfoName Espionne "result $toto(PROP_PF00046 Homeobox from Q4RLZ4/47-103)" } proc testGPL {} { #ajeter Espionne "coucou" #set G "[HomeRipp]/GxHome/AgilentAnnot/GPL13607_family.soft" set F "[HomeRipp]/GxHome/AgilentAnnot/GPL14550_family.soft" set LetsGo 0 set PremiereFois 1 set ctrlpos 0; set ctrlneg 0; set pasctrl 0 set m 0 set n 0 set o 0 set p 0 set q 0 set r 0 set s 0 set t 0 set u 0 set f [open $F r] while {[gets $f Ligne] >= 0} { set LesRef {}; set LesEns {}; set LesGb {}; set LesTc {}; set LesLinc {} if {[regexp "^!platform_table_begin" $Ligne]} {set LetsGo 1; continue} if {[regexp "^!platform_table_end" $Ligne]} {break} if {!$LetsGo} {continue} if {$PremiereFois} { set PremiereFois 0 continue } # Espionne "$Ligne" set LesMots [split $Ligne "\t"] set Type [lindex $LesMots 2] #type: pos (139) neg (1) FALSE (42405) if {$Type == "pos"} { incr ctrlpos } if {$Type == "neg"} { incr ctrlneg } if {$Type == "FALSE"} { incr pasctrl } lappend LesTypes $Type if {$Type != "FALSE"} { continue } set Id [lindex $LesMots 0] set Ps [lindex $LesMots 1] if {$Id!=$Ps} {Espionne $Ligne} set Gb [lindex $LesMots 3] set Rs [lindex $LesMots 4] if {$Gb!="" && $Rs!="" && $Gb==$Rs} { incr m # m 27355 if {[regexp "^NM_" $Gb] && [regexp "^NM_" $Rs]} { incr n #n 24461 } elseif {[regexp "^XM_" $Gb] && [regexp "^XM_" $Rs]} { incr o #o 266 } elseif {[regexp "^NR_" $Gb] && [regexp "^NR_" $Rs]} { incr p #p 2136 } elseif {[regexp "^XR_" $Gb] && [regexp "^XR_" $Rs]} { incr q #q 492 } else { # Espionne "$Ligne" } } if {$Gb!="" && $Rs!="" && $Gb!=$Rs} {incr r} #r 0 if {$Gb=="" && $Rs !=""} {incr s} #s 3550 if {$Gb!="" && $Rs ==""} {incr t} #t 0 if {$Gb=="" && $Rs ==""} { incr u #u 11500 } set LesAcc [lindex $LesMots 11] # Espionne "++$LesAcc" if {$LesAcc==""} {continue} if {![regexp {\|} $LesAcc]} { #mets directment ça dans acc sans se poser de question continue } set LesMotsAcc [split $LesAcc "|"] for {set j 0} {$j<[llength $LesMotsAcc]} {incr j 2} { # Espionne "j $j" set type [lindex $LesMotsAcc $j] lappend LesTypesAcc $type # Espionne "type $type" if {$type=="linc"} {lappend LesLinc [lindex $LesMotsAcc $j+1]} if {$type=="ref"} {lappend LesRef [lindex $LesMotsAcc $j+1]} if {$type=="ens"} {lappend LesEns [lindex $LesMotsAcc $j+1]} if {$type=="gb"} {lappend LesGb [lindex $LesMotsAcc $j+1]} if {$type=="tc"} {lappend LesTc [lindex $LesMotsAcc $j+1]} } # Espionne "LesLinc $LesLinc" # Espionne "LesRef $LesRef" # Espionne "LesEns $LesEns" # Espionne "LesGb $LesGb" # Espionne "LesTc $LesTc" set ens [lindex $LesMots 9] # Espionne "ens $ens" set onatrouve 0 if {$ens != "" && $LesEns != ""} { foreach Ens $LesEns { if {$ens==$Ens} {set onatrouve 1} } if {$onatrouve} { Espionne $Ligne } } #cytoband hs|6q27 #si cest vide laisse tomber # Espionne "$chrloc" } set LesTypes [ListeSansDoublon $LesTypes] EspionneL $LesTypes Espionne "ctrlpos $ctrlpos" Espionne "ctrlneg $ctrlneg" Espionne "pasctrl $pasctrl" Espionne "m $m" Espionne "n $n" Espionne "o $o" Espionne "p $p" Espionne "q $q" Espionne "r $r" Espionne "s $s" Espionne "t $t" Espionne "u $u" set LesTypesAcc [ListeSansDoublon $LesTypesAcc] EspionneL $LesTypesAcc close $f } proc testGraphNico {} { set fileId "/groupes/poch/ripp/wwwLinux/genoret/ImAnno/ImAnnoEar/String/S_K_urov/Identifiers" foreach Id [LesLignesDuFichier $fileId] { lappend LesIds $Id } getStringGraphMoi $LesIds } proc testIsoformesFenetre {FichierEntree} { set hits [parserFichierBlast $FichierEntree] set h1 [lindex $hits 51] set h2 [lindex $hits 241] puts ">[$h1 getShortid]" puts [$h1 enleverTirets Sub] puts ">[$h2 getShortid]" puts [$h2 enleverTirets Sub] set i 0 foreach h $hits { #puts "$i [$h getShortid]" incr i } return [$h1 estIsoformeFenetre $h2 Subject] } proc testIsoformesPourcentage {FichierEntree} { set hits [parserFichierBlast $FichierEntree] set h1 [lindex $hits 3] set h2 [lindex $hits 4] return [$h1 estIsoformePourcentage $h2 Subject] } proc testOrtho {seq seqOut directory fichier} { #Espionne "seq: $seq" set analyse1 "exec oi_client -mode single -query $seq -organism_list all -out $seqOut.fasta" set analyse2 "exec oi_client -mode single -query $seq -organism_list all -outfmt 2 -out $seqOut.csv" #Espionne "--------->analyse1: $analyse1" exec tcsh -c "setorthoinspector ; $analyse1" exec tcsh -c "setorthoinspector ; $analyse2" } proc testParseBlast {FichierEntree} { set hits [parserFichierBlast $FichierEntree] foreach h $hits { if {[$h getShortid] eq "A0A147ACG0_FUNHE"} { set h1 $h } if {[$h getShortid] eq "A0A146XAX2_FUNHE"} { set h2 $h } } grouperHitsParTaxid $hits return #grouperIsoformesScore [dict get [grouperHitsParTaxid $hits] 8078] estIsoformeFenetre Subject return } proc testPdb {} { set Lpdb [SearchAllAARSPDB] puts "\n$Lpdb\n" foreach id $Lpdb { puts "$id" set id [string tolower $id] set Ll [LaSequenceDesBanques $id OnVeutNature] set tit [lsearch -inline -regexp $Ll {^TITLE }] puts "$tit\n" } exit } proc testRegsub {} { set l "bonjour xavier brochet" Espionne "$l" regsub -all { +} $l " " l Espionne "$l" } proc testSamplingTaxo {input class} { set lines [myReadBlast $input 1] set elus [BlastSamplingTaxo $lines $class 1050] puts $elus } proc testclock {} { Espionne "[clock format [clock scan now]]" set Sql2 "select ps.pk_probeset, ps.pk_sp \ from probeset as ps where not exists \ (select pk_probeset, pk_sourceprobeset from ln_probeset_sourceprobeset as lnpssp where lnpssp.pk_probeset=ps.pk_probeset and lnpssp.pk_sourceprobeset=ps.pk_sp);" set Status2 [GxDbSqlExec $Sql2] Espionne "[clock format [clock scan now]]" } 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 testdelete {} { file delete "/tmp/testdelete" } proc testeLesNouvellesProc {} { set url "http://www.expasy.org/uniprot/Q13496" #set url "http://www.expasy.org/uniprot/P14689" set url "http://www.expasy.org/uniprot/P15976" set x [HttpCopy $url LesLignes] set name [recupUniprotEntryName $LesLignes] puts "Name:$name" set lAccNum [recupUniprotListAccNum2 $LesLignes] puts "Synonymes accession number" EspionneL $lAccNum set protName [recupUniprotProtname $LesLignes] puts "Protein name:$protName" set synProtName [recupUniprotListSynProtName $LesLignes] puts "Synonymes protein name" EspionneL $synProtName set geneName [recupUniprotGeneName $LesLignes] puts "Gene name:$geneName" set synGeneName [recupUniprotListSynGeneName $LesLignes] puts "Synonymes gene name" EspionneL $synGeneName set function [recupUniprotFunction $LesLignes] puts "Function:$function" set lGO [recupUniprotListGO $LesLignes] puts "Liste des GO" EspionneL $lGO return 0 } proc testensembl {} { set Site "http://lbgi.igbmc.fr/lbgi/" set Texte [ContenuDuFichier $Site] Espionne "$Texte" } proc testgetzonweb {molid {url ""}} { set molid "Hs_S1730160" set SiteIGBMC "http://igbmc.u-strasbg.fr" set WGetz "srsbin/cgi-bin/wgetz" set SwTr "swissprot_SP_sptrembl" set SwTrNw "swissprot_SP_sptrembl_SP_sptnew" #set Defauts(UrlPdbHome) "$SiteIGBMC/PipeAlign/get_pdb_file.cgi?XXXX" #set Defauts(UrlSRSHome) "$SiteIGBMC/$WGetz?\[uniseq-all:XXXX\]>protein+-vn+2+-e" set Defauts(UrlSRSHome) "$SiteIGBMC/$WGetz?\[uniseq-all:XXXX\]>protein+-vn+2+-vf+\{id_SP_des\}" set Defauts(UrlSRSWorld) "$SiteIGBMC/$WGetz?\[uniseq-all:XXXX\]>protein+-vn+2+-vf+id%20des" #set Defauts(UrlSRSWorld) "$SiteIGBMC/$WGetz?-e+\[\{$SwTr\}-acc:XXXX\]|\[swissprot-id:XXXX\]+-vn+2" #set Defauts(UrlPdbWorld) "$SiteRSCB/pdb/cgi/export.cgi/XXXX.pdb?format=PDB&pdbId=XXXX&compression=None" if {$url == ""} { set site "SRS" set url [set Defauts(UrlSRSHome)] } Espionne "URL: $url" if {[regexp "\:" $molid]} { set molid [StringApres ":" dans $molid] } regsub -all "XXXX" $url $molid url HttpCopy $url LesLignes Espionne "URL: $url" if {$site == "SRS"} { set TexteHTML [join $LesLignes "\n"] set Texte [ValeurDeLaBalise "pre" TexteHTML] set LesLignes [split $Texte "\n"] } #Espionne "$Texte" #return "" #set head "[string range [lindex $LesLignes 0] 0 1]" #Espionne "hrad $head" set LesBonnesLignes {} foreach Ligne $LesLignes { if {[regexp -nocase "} $Ligne $V Ligne } lappend LesBonnesLignes $Ligne } return $LesBonnesLignes } proc testgz {} { set File "toto.protein.gpff.gz" if {[regexp {.+\.gz$} $File]} {Espionne "yes"} } proc testlesdesign {{LesPABs ""}} { set RepProbes "[RepertoireDuGenome]/Probes" set FichierOut "[RepertoireDuGenome]/Poster_identity" set Texte [join [list "PAB" "100.0" "90.0" "80.0" "70.0" "60.0" "50.0" "PseudoGene"] "\t"] #Espionne "$Texte" AppendAuFichier $FichierOut "$Texte" #set LesPABs [lrange [ListeDesPABs] 0 1165] set LesPABs [lrange [ListeDesPABs] 1165 end] #set LesPABs [list ACT0001 ACT0002 ACT0004 ACT0054] foreach PAB $LesPABs { if {[info exists InfoPAB($PAB)]} {Espionne toto;continue} set BId "" set AccessDeRef "" #set FichierBlast "$RepProbes/test/${PAB}.blastn" #set FichierBlast "$RepProbes/RefSeqBLAST3/${PAB}.blastn" set FichierBlast "$RepProbes/NewRefSeqBLAST3/${PAB}.blastn" if {![file exists $FichierBlast]} {Espionne "$FichierBlast do not exists";continue} #Charge les resultats du Blast ############################## #ASKBLAST a changer DepouilleLeBlast TabBlast $FichierBlast set SeuilId "None" set TailleQuery [set TabBlast(Taille)] set NbSubject [set TabBlast(NbSubject)] set TailleLimite [expr $TailleQuery/3] #Espionne "$PAB $TailleLimite" if {$NbSubject>0} { set LesBIdsBases "" set NbBasesCommuns "" set InfoPAB($PAB) 1 for {set i 1} {$i <=$NbSubject} {incr i} { set BId [set TabBlast($i)] set NbBasesCommuns [NombreDeBasesEnCommun_TabBlast TabBlast $BId "Query"] if {$NbBasesCommuns<$TailleLimite} {continue} set IdGlobal [PourcentageDIdentiteGlobal_TabBlast TabBlast $BId] if {$IdGlobal!=""} { set IdGlobal [expr 100.0 * $IdGlobal] } foreach Cat [list 98.0 90.0 80.0 70.0 60.0 50.0] { if {$IdGlobal>=$Cat} { if {[info exists InfoPAB($PAB,$Cat)]} { incr InfoPAB($PAB,$Cat) } else { set InfoPAB($PAB,$Cat) 1 } if {[regexp {NG[0-9]+} $BId]} { if {[info exists InfoPAB($PAB,PseudoGene)]} { incr InfoPAB($PAB,PseudoGene) } else { set InfoPAB($PAB,PseudoGene) 1 } } #Espionne [set InfoPAB($PAB,$Cat)] break } } #lappend LesBIdsBases [list $BId $NbBasesCommuns $IdGlobal] } #Espionne "$LesBIdsBases" set Texte $PAB foreach Cat [list 98.0 90.0 80.0 70.0 60.0 50.0 PseudoGene] { if {[info exists InfoPAB($PAB,$Cat)]} { lappend Texte [set InfoPAB($PAB,$Cat)] } else { lappend Texte 0 } } set Texte [join $Texte "\t"] #Espionne "$Texte" AppendAuFichier $FichierOut $Texte set Texte "" } #ASKBLAST if {[info exist TabBlast]} {unset TabBlast} } return "" } proc testlog {} { set ::VersionDeOrdali 10.10 set ::Defauts(TypeAli) XML set ::Defauts(FichierXML) testlog.xml AuLog @begin blob AuLog @title titre du blob AuLog @text ceci est un blob AuLog @end AuLog @begin table AuLog @title ===> TABLE TITTLE <=== AuLog @begin tabular AuLog @titlecols ind2 col1 col2 col3 col4 col5 col6 AuLog @typecols I R R R R R R AuLog @row 1 123.0 NULL 214. 123.0 NULL 214. AuLog @row 2 147.0 0.0 12. 147.0 0.0 12. AuLog @row 3 123.0 NULL 214. 123.0 NULL 214. AuLog @row 4 147.0 0.0 12. 147.0 0.0 12. AuLog @row 5 123.0 NULL 214. 123.0 NULL 214. AuLog @row 6 147.0 0.0 12. 147.0 0.0 12. AuLog @end AuLog @separator AuLog @text ligne de texte AuLog @separator AuLog @title 2eme tableau AuLog @begin tabular AuLog @titlecols indices col1 col2 col3 AuLog @typecols I I R R AuLog @row 1 123 NULL 214. AuLog @row 2 147 0.0 12. AuLog @end AuLog @end AuLog @begin warning AuLog @title WARNING : AuLog @text this is a warning text AuLog @end AuLog LOutput HTML testlog.html #set res [OutputTLog HTML $Log] #Sauve $res Dans t.html exit } proc testmail {} { # multi-destinataires separes par virgule !! send_simple_message "raymond.ripp@unistra.fr,luc.moulinier@unistra.fr" localhost "Cé1Test" "" #send_simple_message allot@unistra.fr localhost "Salut msieur Alexis" "Et ca c'est le corps" "barak.obama@maisonblanche.int" return } proc testmow {} { global Defauts #set msf [ContenuDuFichier $Defauts(FichierMSF)] set xml [MacsimsOnWeb D_verylastfinal.msf] puts $xml return } proc testnff {} { global Ltrig Lnorm Lvert pgl Rad rename EnvoieLesObjets EnvoieLesObjetstmp rename EnvoieLesObjets3 EnvoieLesObjets Initialisation if {1} { #LecturePolyr global FBidon set FBidon 1 FormeBidon set bb [list 0.0 2.0 0.0 2.0 0.0 2.0] set xm 0.0 ; set ym 0.0 ; set zm 0.0 set xx 2.0 ; set yx 2.0 ; set zx 2.0 set Lc [list 1.0 1.0 1.0] puts "BBox [BBox3D $Lvert]" } else { LectureQHull lassign [BBox3D $Lvert] xm xx ym yx zm zx } puts "" puts "Lvert [llength $Lvert]" puts " [lindex $Lvert 0]" puts "Ltrig [llength $Ltrig]" puts " [lindex $Ltrig 0]" puts "Lnorm [llength $Lnorm]" puts " [lindex $Lnorm 0]" set xc [expr {($xm+$xx)/2.}] set yc [expr {($ym+$yx)/2.}] set zc [expr {($zm+$zx)/2.}] set Rad [expr {10.*sqrt(($xx-$xm)**2+($yx-$ym)**2+($zx-$zm)**2)/2.}] set pgl(Rad) $Rad set pgl(xCen) $xc set pgl(yCen) $yc set pgl(zCen) $zc set pgl(frontclip) $Rad set pgl(backclip) [expr {-2.0*$Rad}] set pgl(eyeX) 0.0 set pgl(eyeY) 0.0 set pgl(eyeZ) [expr {1.1*$pgl(zCen)}] AfficheFenetreOpengl #exit } proc testpageinforefseq {{BId RSHUM:NM014857}} { set Page [PageInfoLaTotale $BId] set LaDef [LaDefinition_PageInfo $Page] set Def [join $LaDef " "] #return $Def Espionne $Def set SeqTFA [SequenceFormatTFA $Page $BId rshuman] Espionne "seq: $SeqTFA" } proc testrefseq {} { Wup "Permet de lancer les analyses pour determiner le meilleur Tm pour un groupe de sequence" set Dir [tk_chooseDirectory -title "Choose a saving directory." -initialdir "[RepertoireDuGenome]"] #set LesQuerys [glob -nocomplain -directory $Dir "*"] set LesQuerys [glob -nocomplain -directory $Dir "NC*"] #set LesQuerys [glob -nocomplain -directory $Dir "NG*"] #set LesQuerys [concat $LesQuerys [glob -nocomplain -directory $Dir "NR*"]] #set LesQuerys [glob -nocomplain -directory $Dir "NM*"] if {0} { Espionne "[llength $LesQuerys]" foreach Q $LesQuerys { set Entete [EnteteDuFichierTFA $Q "all"] if {[regexp -nocase "pseudogene" $Entete]} { lappend LaListe $Q } else {continue} } set LesQuerys $LaListe } Espionne "[llength $LesQuerys]" if {$LesQuerys==""} {return ""} set Fichier [tk_getSaveFile -title "Choose a file name to save sequence" -initialdir "[RepertoireDuGenome]"] if {1} { foreach Q $LesQuerys { AppendAuFichier $Fichier [file tail $Q] ChargeTmCount $Q } CalculLaMoyenneTmCount IllustreTmCount #DechargeTmCount } if {1} { foreach Q $LesQuerys { AppendAuFichier $Fichier [file tail $Q] ChargeGCCount $Q } CalculLaMoyenneGCCount IllustreGCCount } } proc testrepartitionloc {FichierEntree FichierSortie} { foreach Ligne [LesLignesDuFichier $FichierEntree] { if {$Ligne==""} {continue} set LesInfos [split $Ligne "\t"] set BandeCyto [lindex $LesInfos 10] if {$BandeCyto==""} {continue} if {![info exists Vu($BandeCyto)]} { lappend LesBandesCyto $BandeCyto; set Vu($BandeCyto) 1; set n($BandeCyto) 1 } else {incr n($BandeCyto)} } foreach BC $LesBandesCyto { AppendAuFichier $FichierSortie "$BC\t$n($BC)" } } proc testrepartitionlocplusgrossier {FichierEntree FichierSortie} { foreach Ligne [LesLignesDuFichier $FichierEntree] { if {$Ligne==""} {continue} set LesInfos [split $Ligne "\t"] set BandeCyto [lindex $LesInfos 10] if {$BandeCyto==""} {continue} #Espionne $BandeCyto regsub {\.[0-9]+} $BandeCyto "" BandeCyto #FaireLire $BandeCyto if {![info exists Vu($BandeCyto)]} { lappend LesBandesCyto $BandeCyto; set Vu($BandeCyto) 1; set n($BandeCyto) 1 } else {incr n($BandeCyto)} } foreach BC $LesBandesCyto { AppendAuFichier $FichierSortie "$BC\t$n($BC)" } } proc testservice {} { package require http set Lid [list Q55C99 SYDC_HUMAN P13368] DbFetchSOAP refseqp $Lid set Lid file.fof set url "http://www.uniprot.org/batch/" set query [::http::formatQuery format txt file "file.fof"] puts "pwd [pwd]" cd /home/moumou/ordali/alitest #set query [::http::formatQuery format txt file "P13368 sydc_human q55c99"] set rep [HttpCopy $url "" $query] puts "$rep" exit return } proc testsplit {} { set Commande "getz -e \"\\\[protein-acc:P12750\\\]\" \-vf gen" set GetzOut [eval exec $Commande] set L1 [lindex [split $GetzOut "\n"] 0] Espionne $L1 set GN [lindex [split $L1 "\t"] 1] return $GN } proc testw {} { set Ll [TW1] puts "[time {ExtraitHeadDuPDB $Ll} 10]" puts "[time {ExtraitHeadDuPDB2 $Ll} 10]" return } proc tews {} { global LNOrdali Sequences TDesAccess set Lseq [list] set prend 1 ; set i 0 foreach n $LNOrdali { if {$n eq ""} {continue} set s [set Sequences($n)] set s [string map {"." ""} $s] set acc [set TDesAccess($n)] lappend Lseq ">$acc" #lappend Lseq "MQRASMHNST${s}FWSQAERMPMTK" lappend Lseq "MTRASTFASPMLINQ$s" #lappend Lseq "" incr i if {$i == $prend} { break } } set seq "[join $Lseq \n]" puts ">$seq<" set time [time {set res [InterproScanWebService -sequence $seq]}] puts "time $time" #puts "$res" exit } proc tfa {} { set Lv [list toto 10.3156 turlututu] puts [time { foreach {a b c} $Lv {} } 10000] puts [time {lassign $Lv a b c} 10000] exit } proc tfadescopainsSansSw {{Liste ""} {ReptlescopainsComplet ""}} { set Reptfasdescopains [RepertoireDuGenome]/tfasdescopains/ if {$ReptlescopainsComplet==""} {set ReptlescopainsComplet "[RepertoireDuGenome]/lescopainsComplet"} if {$Liste==""} {set Liste [ListeDesPABs]} #voir apres pour changement if { ! [file exists $ReptlescopainsComplet]} {file mkdir $ReptlescopainsComplet} set sauve "yes" #pour chaque fichiers des tfasdescopains: #copie du fichier complet dans le repertoire de sauvegarde #reecriture des fichiers sans les seq swissprot foreach Nom $Liste { set newList {} if {[file exists $Reptfasdescopains$Nom]} { exec cp $Reptfasdescopains$Nom $ReptlescopainsComplet/. set ma_list [LesLignesDuFichier $Reptfasdescopains$Nom] foreach Ligne $ma_list { if {[regexp {>[A-Z0-9]{6}} $Ligne]} { set sauve "no" } elseif {[regexp {^>} $Ligne]} { set sauve "yes" lappend newList $Ligne } elseif {$sauve eq "yes"} { lappend newList $Ligne } } SauveLesLignes $newList dans $Reptfasdescopains$Nom } } } proc tfadescopainsSansSwPourTous {{Repertoire ""}} { if {$Repertoire==""} { set Repertoire [RepertoireDuGenome]/tfasdescopains } set r [glob -directory $Repertoire *] foreach fichier $r { set n [split $fichier "/"] set f [lindex $n [llength $n]-1] if {[PasTouche $f]} { continue } lappend listSeq $f FinPasTouche $f } tfadescopainsSansSw $listSeq } proc tfeat {} { set Ll [LesLignesDuFichier /home/moumou/Pour_Luc.csv] set vpre "" foreach l $Ll { set Lv [split $l ";"] set v [lindex $Lv 0] if {$v ne $vpre} { puts ">>--------------<<" } puts "[string range $l 0 20]" } exit } proc tfoot {} { package require http set url "http://www.les-sports.info/ajax_php.php?majajax=resultats_manche&epreuveid=55087&surPlusieursJours=1&finale=1&place_3eme=0&man_saison=0&affclassement=1&clas=&contientResult=0&id_fichier=11&langage=fr&mancheid=233948" set tok [::http::geturl $url] set txt [::http::data $tok] puts "txt $txt" exit } proc tfred {} { set LLE [LaSequenceDesBanques GB_PR12:BC000249 BC000249 a OnVeutNucEMBL] Espionne [SequenceFormatTFA_l $LLE "" ""] exit } proc tftp {} { package require http package require ftp set url http://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/idmapping_selected.tab.gz set url http://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/README set tok [::http::geturl $url] upvar #0 $tok var puts "$var(meta)" puts "" puts "[::http::data $tok]" set furl ftp.uniprot.org set dir /pub/databases/uniprot/current_release/knowledgebase/idmapping/ set hf [::ftp::Open $furl anonymous toto -mode passive] ::ftp::Cd $hf $dir puts [clock format [ftp::ModTime $hf README]] puts [clock format [ftp::ModTime $hf idmapping_selected.tab.gz]] set fm [file mtime idmapping_selected.tab.gz] puts "$fm [clock seconds]" ::ftp::Close $hf exit } proc tgb {} { set res [DbFetchGET uniprot p12345] #puts "$res" set gb AAGW02052878 set out [DbFetchGET genbank $gb] #puts $out set ref XM_002711551.2 set out [eFetchREST nucleotide $ref] puts $out exit } proc tgen {} { global Tx set Tx(-txdb) uniprot set Tx(-cgdb) uniprot TaxDB2Memory puts "[DonneGenealogieMem 48479]" exit } proc tgi {} { set Lgi [list 154323340 363755064 340380923 301603688 291240797 390352799 32566633 345488679 301093825 168001325 221124310] set aT [eSummaryREST protein $Lgi] array set T $aT foreach k [array names T "*,refseq"] { puts "T($k) [set T($k)]" } exit } proc tgk {} { set Lid [list NM_001179999.1 NM_001179838.1 M63555 AAA34811.1 AY692777 AAT92796.1 Z28272 CAA82124.2] set Lres [DbFetchGET ena_sequence $Lid embl] set Lres [SplitLesEMBL $Lres] foreach res $Lres { puts "\n\nres=" puts [join $res \n] } exit } proc tgo {} { set Ll [LesLignesDuFichier gold-tab.dat] foreach l [lrange $Ll 1 end] { set Lv [split $l \t] lappend Lres [lindex $Lv end] } puts "[join [DenombreLaListe $Lres] \n]" exit } proc tgoe {} { set Ll [LesLignesDuFichier mmaic/sel0_70..acc] set res [GOEnrichmentWebService [lrange $Ll 0 100]] puts "$res" exit } proc tgos {} { set s 0.0 set step [expr {2./12.}] set max [GaussProbability 0.0 0.0 1.0] for {set i 0} {$i < 13} {incr i} { set v [expr {-1.0 + $i * $step}] set x [GaussProbability $v 0.0 1.0] puts [format "%2d %5.3f %5.3f %5.3f" $i $v $x [expr {$x/$max}]] set s [expr {$s+$x}] } puts "\ns= $s" exit } proc tgun {} { set url "http://www.uniprot.org/taxonomy/?format=tab&compress=yes" set res [HttpCopy $url] set o [open out.gz w] fconfigure $o -encoding binary -translation binary puts $o $res close $o set txt [zlib gunzip $res] puts $txt exit } proc tgun2 {} { set o [open out.gz r] fconfigure $o -encoding binary -translation binary set gz [read -nonewline $o] close $o puts [zlib gunzip $gz] exit } proc thash {} { set Lf {10 25 50 100 200 500 1000} set Lt {10 25 50 100 200 500 1000} set Lt {10 300} set Lf {10 300} foreach t $Lt { set Lxt [list] for {set i 0} {$i < $t} {incr i} { lappend Lxt [expr {int($t*rand())}] } set T(Lt,$t) $Lxt } foreach f $Lf { set Lxf [list] for {set i 0} {$i < $f} {incr i} { lappend Lxf [expr {int((2*$f)*rand())}] } set T(Lf,$f) $Lxf } foreach t $Lt { set Lxt [set T(Lt,$t)] foreach f $Lf { set Lxf [set T(Lf,$f)] set rep 0 set o [time { foreach x $Lxt { if {$x in $Lxf} { incr rep } } } 20] set res(in,$t,$f) [lindex $o 0] set rep 0 unset -nocomplain TH set o [time { array set TH [HashExiste $Lxf] foreach x $Lxt { incr rep [info exists TH($x)] } } 20] set res(Hash,$t,$f) [lindex $o 0] } } set lg [PlusLongEltDe [array names res]] set Li [array get res "in,*"] set Lh [array get res "Hash,*"] set Li [lsort -real -stride 2 -index 1 $Li] set Lh [lsort -real -stride 2 -index 1 $Lh] foreach {ki vi} $Li {kh vh} $Lh { puts [format "%${lg}s %7.1f %${lg}s %f" $ki $vi $kh $vh] } exit } proc thc111 {} { set Lid [list NM_123] set res [eFetchREST nucleotide $Lid cds] puts "$res" exit } proc thc222 {} { set query [::http::formatQuery db uniprot id Q07930 style raw] puts "[HttpCopy http://www.ebi.ac.uk/Tools/dbfetch/dbfetch? "" $query]" exit puts [HttpCopy "http://www.ebi.ac.uk/Tools/dbfetch/dbfetch?db\=uniprot\&id\=Q07930\&style=raw" ] exit } proc thomo {} { global Tx db TaxDB2Memory set Lg [lreverse [DonneGenealogieMem 9606]] set start 0 foreach g $Lg { if {! $start} { set start 1 set Parent $g set Brothers 3 puts "$g $Brothers $Tx(NbChild,$g)" continue } set dBr [$db eval {select NbChild from taxonomy where taxid=$Parent}] set dCh [$db eval {select NbChild from taxonomy where taxid=$g}] puts "$g $Tx(NbChild,$Parent) $Tx(NbChild,$g) $dBr $dCh $Tx(Child,$g)" set Parent $g } #AssignNbInternal 9606 puts "lfeuil [llength $::Lfeuilles]" puts "" set LR [array names Tx "*,131567"] foreach r [lsort $LR] { puts "$r $Tx($r)" } exit } proc thtml {} { set T [ContenuDuFichier trp7_human.blastp] set B [ProchaineBalise T Attrib "Rogner"] Espionne "Attributs de $B : $Attrib" set B [ProchaineBalise T Attrib "Rogner"] Espionne "Attributs de $B : $Attrib" set Iter [ValeurDeLaBalise "Iteration" T] set Num [ValeurDeLaBalise "Iteration_iter-num" Iter] set Hits [ValeurDeLaBalise "Iteration_hits" Iter] set Stat [ValeurDeLaBalise "Iteration_stat" Iter] Espionne "Num =$Num=" Espionne $Stat while 1 { set Hit [ValeurDeLaBalise "Hit" Hits "" "Rogner"] set Hit_def [ValeurDeLaBalise "Hit_def" Hit "NePasRogner"] set Hit_id [ValeurDeLaBalise "Hit_id" Hit "NePasRogner"] Espionne "$Hit_id $Hit_def" while 1 { set BH [ProchaineBalise Hit "" "Rogner"] if {$BH==""} { break } Espionne " $BH" } } exit exit foreach BornesDuHit [LesSousChamps $Hits] { scan $BornesDuHit "%d %d" D F set Hit [string range $Hits $D $F] Espionne [string range $Hit 0 300] set Hit_def [ValeurDeLaBalise "Hit_def" Hit "NePasRogner"] set Hit_id [ValeurDeLaBalise "Hit_id" Hit "NePasRogner"] Espionne "$Hit_id $Hit_def" while 1 { set BH [ProchaineBalise Hit "" "Rogner"] if {$BH==""} { break } Espionne " $BH" } } exit Recure $T while 1 { set Bal [ProchaineBalise T Attrib] if {$Bal==""} { break } set Val [ValeurDeLaBalise $Bal T] Espionne "=$Bal=[string range $Val 0 50]" } exit } proc ti {} { set lp [list 1jny 1kjz 1nou 1ob2] set lp [list 1JNY 1KJZ 1NOU 1OB2] if {1} { set xml [PDBeInterface $lp] set f [open i2.xml w] puts $f $xml close $f } else { set xml [ContenuDuFichier i2.xml] } set RId [dom parse $xml] set doc [$RId documentElement] puts "doc [$doc nodeName]" set Lent [$doc selectNodes //pisa_interfaces/pdb_entry] puts "Lent [llength $Lent]" foreach pdb $lp chn [list A A A A] { set gc 0 puts "pdb $pdb" set found 0 foreach ent $Lent { set npc [$ent selectNodes ./pdb_code] puts "npc [$npc selectNode string(.)]" if {[$npc selectNode string(.)] eq "[string toupper $pdb]"} { set found 1 break } } set ni [lindex [$ent selectNodes ./interface] 0] puts " ni [llength $ni]" set Lb [$ni selectNodes ./h-bonds/bond] foreach nb $Lb { set Lv [$nb childNodes] set nr "" ; set nm "" foreach nv $Lv { switch [$nv nodeName] { "chain-1" - "chain-2" { set v [$nv selectNode string(.)] if {$v eq $chn} { set gc 1 } } "seqnum-1" - "seqnum-2" { set v [$nv selectNode string(.)] if {$gc} { set nr $v set gc 0 } } "res-1" - "rse-2" { set v [$nv selectNode string(.)] if {$gc} { set nm $v set gc 0 } } } } if {$nr ne ""} { lappend Lres [list $nr $nm] } } puts " Lres $Lres" } exit } proc tidm {} { set o [open /home/moumou/idmapping.dat r] set Ldb {} set i 0 set lamax 0 ; set ltmax 0 while {[gets $o l] > 0} { lassign [split $l \t] acc db tar set la [string length $acc] if {$la > $lamax} {set lamax $la} set ltar [string length $tar] if {$ltar > $ltmax} {set ltmax $ltar} lappend Ldb $db if {! ($i % 10000)} { set Ldb [lsort -unique $Ldb] } incr i } set Ldb [lsort -unique $Ldb] puts "acc $lamax" puts "tar $ltmax" puts [join $Ldb \n] exit } proc timap {} { package require imap4 package require tls package require mime source /home/moumou/imap4.tcl source /home/moumou/mime.tcl set user luc.moulinier set pass "#Derry5#" set server 130.79.200.160 set FOLDER "INBOX.testIMAP" # Connect to server set ::imap4::use_ssl 1 set imap [::imap4::open $server 993] puts "imap $imap" ::imap4::login $imap $user $pass puts "login done" set Lfold [::imap4::folders $imap -inline] puts "\n[join $Lfold \n]" ::imap4::select $imap $FOLDER # Output all the information about that mailbox foreach info [::imap4::mboxinfo $imap] { puts "$info -> [::imap4::mboxinfo $imap $info]" } set nbMails [::imap4::mboxinfo $imap exists] # fetch 3 records inline set start 2 ; set end 2 imap4::fetch $imap $start:$end -inline flags from: BODYSTRUCTURE Subject: date: fullbody set body [::imap4::msginfo $imap $start body] set token [::mime::initialize -string $body] set out [mimeGetPartsTree $token root] puts "\nout\n$::tSer" ::mime::finalize $token ::imap4::cleanup $imap set t [::struct::tree] $t deserialize $::tSer set Lf [list] foreach n [$t leaves] { set d [$t depth $n] lappend Lf $d $n } puts "Lf $Lf" set Lf [lsort -decreasing -integer -stride 2 -index 0 $Lf] puts "Lf $Lf" set c 0 ; set in 1 while {$c < [llength $Lf]} { set n [lindex $Lf $in] set p [$t parent $n] set type [$t attr type -nodes $p] set subtype [$t attr subtype -nodes $p] puts "$type $subtype" if {$type eq "multipart" && $subtype eq "alternative"} { set Ln [$t children $p] # Take the "text" part foreach np $Ln { set ntype [$t attr type -nodes $np] if {$ntype eq "text"} {break} } } incr c 2 ; incr in 2 } exit for {set i $start} {$i <= $end} {incr i} { puts "\nMessage $i" set body [::imap4::msginfo $imap $i bodystructure] set isAtta [CheckAttachment $body] puts " isAtta $isAtta" puts " [::imap4::msginfo $imap $i]" foreach k {flags from: subject: date:} { puts " $k = [::imap4::msginfo $imap $i $k]" } continue if {$isAtta < 0} { continue } # attachment present, get the whole body set rep [::imap4::fetch $imap $i FULLBODY] set body [::imap4::msginfo $imap $i body] # parse body parts using MIME set token [::mime::initialize -string $body] set Lparts [mimeGetPartsHierarchy $token] puts "Lparts $Lparts" ::mime::finalize $token } ::imap4::close $imap exit #set rep [::imap4::request $imap "FETCH 3 (FLAGS BODY.PEEK\[*\])\r\n"] #puts "rep $rep" #puts "response [::imap4::getresponse $imap]" #::imap::request foreach rec [::imap4::fetch $imap 2:5 -inline {*}$fields] { puts -nonewline "#[incr idx])" for {set j 0} {$j<[llength $fields]} {incr j} { puts "\t[lindex $fields $j] [lindex $rec $j]" } } # Show all the information available about the message ID 1 puts "Available info about message 1: [::imap4::msginfo $imap 1]" # Use the capability stuff puts "Capabilities: [::imap4::isableto $imap]" puts "Is able to imap4rev1? [::imap4::isableto $imap imap4rev1]" package require mime set head [::imap4::fetch $imap 3:3 -inline text] puts "\n==============\n$head" set token [::mime::initialize -string $head] set parts [list] foreach p [mime::getproperty $token parts] { lappend parts $p } puts "part $parts" ::mime::finalize $token # Cleanup ::imap4::cleanup $imap return } proc tinrf {} { set Lother {XP_002127690 XP_797369} set Lref [Convert2RefSeq $Lother] puts "loth $Lother" puts "lref $Lref" array set T [InfosFromRefSeq $Lref] parray T foreach acc $Lref oth $Lother { if {[array names T "$acc,*"] == {}} { lappend Lfail $acc puts ">> $acc" continue } } exit } proc tipr {} { #cd /home/moumou/work/BenchPfam/ puts "[pwd]" DecortiqueUnTFA "tata" Lnori Sq set nl [list] foreach n $Lnori { set s [set Sq($n)] set n [string map [list "/" "@"] $n] set tmp($n) $s lappend nl $n } set Lnori $nl unset Sq update array set Sq [array get tmp] puts "nseq [llength $Lnori]" set i 0 foreach n $Lnori { set s [set Sq($n)] set s [string map [list "." "" "-" ""] $s] lappend Ln $n lappend Ls $s incr i if {$i > 299} { EcritLeTfa tmpfa $Ln $Ls set Ln [list] set Ls [list] set i 0 LanceInterproScan tmpfa tmpo after 1000 lappend Lo {*}[LesLignesDuFichier tmpo] } } set Lpat [list] foreach l $Lo { set Lv [split $l \t] set acc [lindex $Lv 0] set prs [lindex $Lv 4] set deb [lindex $Lv 6] set fin [lindex $Lv 7] lappend res($prs) $acc } set Lpat [array names res] puts "[llength $Lpat] $Lpat" set p1 [lindex $Lpat 0] puts " $p1 [llength [set res($p1)]]" set p2 [lindex $Lpat 1] puts " $p2 [llength [set res($p2)]]" set land [land [set res($p1)] [set res($p2)]] set lgland [llength $land] puts "land [llength $land]" set SAli [list] foreach acc $land { lappend SAli $acc [set Sq($acc)] } set nseqs [llength $land] set LPCI [CalculeLesPCIGenerique $SAli] set l100 [list] ; set n100 0 ; set dejavu 0 foreach {k v} $LPCI { if {[lindex $v 0] < 1.0} {continue} if {$k in $l100} { incr dejavu continue } lassign [split $k ,] a b set lid "$b,$a" lappend l100 $k $lid lappend Ltot $a $b incr n100 } puts "nelt [expr {[llength $LPCI]/2}]" puts "n100 $n100 dejavu $dejavu l100 [llength $l100]" set Ltot [DenombreLaListe $Ltot] foreach e $Ltot { lassign $e v n if {$n > 2} { puts "$v $n" lappend Lvire $v } } puts "viree [llength $Lvire]" lassign [SM_StatPCI $LPCI] moy std min max puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "whole" $nseqs $moy $std $min $max] array set TPCI $LPCI update # vire redondant set landnet $land foreach n $Lvire { set i [lsearch $landnet $n] set landnet [lreplace $landnet $i $i] } puts "apres virage [llength $landnet]" # recomence sans doublons set SAli [list] foreach acc $landnet { lappend SAli $acc [set Sq($acc)] } set nseqs [llength $landnet] set LPnet [CalculeLesPCIGenerique $SAli] lassign [SM_StatPCI $LPnet] moy std min max puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "whole" $nseqs $moy $std $min $max] # sample 500 set i 0 ; set Li [list] set Lseq2 [list] while {$i < 500} { set x [expr {int(rand()*$lgland)}] if {$x ni $Li} { lappend Li $x lappend Lseq2 [lindex $land $x] incr i } } set S500 [list] foreach acc $Lseq2 { lappend S500 $acc [set Sq($acc)] } set LP500 [CalculeLesPCIGenerique $S500] lassign [SM_StatPCI $LP500] moy std min max set nseqs [llength $Lseq2] puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "500sq" $nseqs $moy $std $min $max] # verif set lv [list] ; set i 1 foreach a [lrange $Lseq2 0 end] { foreach b [lrange $Lseq2 0 end] { lappend lv "$a,$b" $TPCI($a,$b) } incr i } lassign [SM_StatPCI $lv] moy std min max puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "500vf" $nseqs $moy $std $min $max] update # sample 200 set i 0 ; set Li [list] set Lseq3 [list] while {$i < 200} { set x [expr {int(rand()*$lgland)}] if {$x ni $Li} { lappend Li $x lappend Lseq3 [lindex $land $x] incr i } } set SAli3 [list] foreach acc $Lseq3 { lappend SAli3 $acc [set Sq($acc)] } set LPCI3 [CalculeLesPCIGenerique $SAli3] lassign [SM_StatPCI $LPCI3] moy std min max set nseqs [llength $Lseq3] puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "200sq" $nseqs $moy $std $min $max] # verif set lv [list] ; set i 1 foreach a [lrange $Lseq3 0 end-1] { foreach b [lrange $Lseq3 $i end] { lappend lv "$a,$b" $TPCI($a,$b) } incr i } lassign [SM_StatPCI $lv] moy std min max puts [format "%s %d %8.5f %8.5f %8.5f %8.5f" "200vf" $nseqs $moy $std $min $max] exit } proc tjm {} { global LNOrdali cd /home/moumou/Agents/jobs set Lf [LesFichiersDeBalibase] foreach f $Lf { unset -nocomplain LNOrdali DecortiqueXmlAgent $f set ns [llength $LNOrdali] set Lb [CoreBlocksDuXML] set max -999 foreach {deb fin} $Lb { if {($fin - $deb) > $max} { set max [expr {$fin - $deb}] set dmax $deb ; set fmax $fin } } lappend Lbck $f $ns $max $dmax $fmax } puts "\nBlocks" foreach {f ns lb deb fin} [lrange [lsort -stride 5 -index 2 -integer -decreasing $Lbck] 0 49] { puts "[lindex [file split $f] end] $ns $lb $deb $fin" } puts "\nLength" foreach {f ns lb deb fin} [lrange [lsort -stride 5 -index 1 -integer -decreasing $Lbck] 0 49] { puts "[lindex [file split $f] end] $ns $lb $deb $fin" } exit } proc tk_chooseColor {args} { return [::tk::dialog::color:: {*}$args] } proc tk_chooseDirectory {args} { return [::tk::dialog::file::chooseDir:: {*}$args] } proc tk_getOpenFile {args} { if {$::tk_strictMotif} { return [::tk::MotifFDialog open {*}$args] } else { return [::tk::dialog::file:: open {*}$args] } } proc tk_getSaveFile {args} { if {$::tk_strictMotif} { return [::tk::MotifFDialog save {*}$args] } else { return [::tk::dialog::file:: save {*}$args] } } proc tk_menuSetFocus {menu} { variable ::tk::Priv if {![info exists Priv(focus)] || $Priv(focus) eq ""} { set Priv(focus) [focus] } focus $menu } proc tk_messageBox {args} { return [::tk::MessageBox {*}$args] } proc tk_popup {menu x y {entry ""}} { variable ::tk::Priv global tcl_platform if {$Priv(popup) ne "" || $Priv(postedMb) ne ""} { tk::MenuUnpost {} } tk::PostOverPoint $menu $x $y $entry if {[tk windowingsystem] eq "x11" && [winfo viewable $menu]} { tk::SaveGrabInfo $menu grab -global $menu set Priv(popup) $menu set Priv(window) $menu set Priv(menuActivated) 1 tk_menuSetFocus $menu } } proc tk_textCopy {w} { if {![catch {set data [$w get sel.first sel.last]}]} { clipboard clear -displayof $w clipboard append -displayof $w $data } } proc tk_textCut {w} { if {![catch {set data [$w get sel.first sel.last]}]} { clipboard clear -displayof $w clipboard append -displayof $w $data $w delete sel.first sel.last } } proc tk_textPaste {w} { global tcl_platform if {![catch {::tk::GetSelection $w CLIPBOARD} sel]} { set oldSeparator [$w cget -autoseparators] if {$oldSeparator} { $w configure -autoseparators 0 $w edit separator } if {[tk windowingsystem] ne "x11"} { catch { $w delete sel.first sel.last } } $w insert insert $sel if {$oldSeparator} { $w edit separator $w configure -autoseparators 1 } } } proc tla {} { set a [list 2 3 3 -2 2 3 7 5 6 -7 8 9] set b [list 2 3 3 1 0 0 0 0 0 0 0 0] package require La set c [La::mmult $a $b] puts [La::show $c] set v [list 2 3 0 1 1 1] #puts [La::msolve $c $v] puts "" puts [La::mlssvd $a $v] exit } proc tla2 {} { package require math::linearalgebra set a [list 2 3 3 -2.0 2.0 3.0 7.0 5.0 6.0 -7.0 8.0 9.0] set b [list 2 3 3 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0] set v [list 2 3 0 0.0 0.0 0.0] set ma [::math::linearalgebra::from_LA $a] puts "ma\n$ma" set mb [::math::linearalgebra::from_LA $b] puts "mb\n$mb" set mv [::math::linearalgebra::from_LA $v] puts "\nmatrix A" puts "[::math::linearalgebra::show $ma %3.1f]" puts "\nmatrix B" puts "[::math::linearalgebra::show $mb %3.1f]" set mc [::math::linearalgebra::matmul $ma $mb] puts "matrix C" puts "[::math::linearalgebra::show $mc %3.1f]" puts "SVD 1" puts "[::math::linearalgebra::determineSVD $mc]" puts "SVD 2" puts "[::math::linearalgebra::leastSquaresSVD $mc $v 0.0]" exit } proc tlesnm {} { set Ll [LesLignesDuFichier lesnm] set ret [eFetchREST nucleotide $Ll cds] puts "[join $ret \n]" foreach k [array names ::TDesPhylum] { if {[set ::TDesPhylum($k)] ne ""} { puts "$k" } } exit } proc tlmp {} { for {set i 0} {$i < 10000} {incr i} { lappend L [list "ti$i" [expr {rand()}]] } puts [time {set r1 [tlmp1 $L]} 1000] puts [time {set r2 [tlmp2 $L]} 1000] puts [expr {$r1 eq $r2}] exit } proc tlmp1 {l} { set i -1 set res [lmap x $l { linsert $x 0 [incr i] }] return $res } proc tlmp2 {l} { set i -1 foreach x $l { lappend res [linsert $x 0 [incr i]] } return $res } proc tloto {} { set url "http://www.fff.fr/cgi-bin/championnats/champ_calend.pl?code_cg=0000&code_comp=11111&type_rech=jour&journee=1" set Ll [HttpCopy $url] EspionneL $Ll exit } proc tlps {} { set Lo [LancePSScan tata] puts "[join [lrange $Lo 0 10] \n]" set LF [LesPrositesDuTFA toto] array set F $LF parray F exit } proc tlurl {} { set Ll [LesLignesDuFichier lurl] foreach l $Ll { lassign [split $l " "] tmp url tmp query set res [HttpCopy $url "" $query] } exit } proc tlyx {} { LesDefauts set pdbid 1il2 Structure create $pdbid set pdbText [TextePDB $pdbid ALL "" OnTheWeb] set cok [$pdbid new $pdbText "" 0 1] foreach c [$pdbid _chains] { puts "chain $c [$pdbid _source $c]" puts "chain $c [$pdbid _source $c orga]" puts "seq\n[join [$pdbid _resname -chain $c -polymer] ""]" } exit } proc tmaft {} { set out [Mafft_AddSequences mtest.tfa add.tfa] puts "\n\n\n$out" exit } proc tmap {} { set Ll [LesLignesDuFichier idmapping.dat.example] foreach l $Ll { set lv [split $l \t] lappend bk [lindex $lv 1] } puts "[join [lsort -unique $bk] \n]" exit } proc tmd5 {} { package require md5 set url "http://milex/~moumou/SoTOL/t2.txt" set taxo [split [HttpCopy $url] \n] #set taxo [HttpCopy $url] #set taxo [join [HttpCopy $url] \n] set tmd5 [::md5::md5 -hex $taxo] #set omd5 [ContenuDuFichier t2.txt] #set taxo [ContenuDuFichier t2.txt] set taxo [LesLignesDuFichier t2.txt] #set taxo [join $taxo \n] set omd5 [::md5::md5 -hex $taxo] puts "tmd5 $tmd5\nomd5 $omd5" exit } proc tmebi {} { set url "http://www.ebi.ac.uk/Tools/picr/rest/" set udb "${url}getMappedDatabaseNames" puts "[HttpCopy $udb]" set lacc [list O26328 Q9XYM1 Q8ZYM8] #set lacc O26328 set db REFSEQ set url "http://www.ebi.ac.uk/Tools/picr/rest/getUPIForAccession" set query [::http::formatQuery database $db accession [join $lacc " "]] set Lxml [HttpCopy $url "" $query] puts "" puts $Lxml set RId [dom parse $Lxml] set doc [$RId documentElement] set fout [open toto w] $doc asXML -channel $fout close $fout $RId delete exit } proc tmem {} { set j 1 set ::VariablesAuDepart [info globals] set cmdD [info commands] set pdbid 1bjt while {$j < 30} { Structure create $pdbid #set cok [$pdbid new $pdbid "" 0 1] set cok [$pdbid new $pdbid "" 0 0] $pdbid destroy update #rrps yeast 1asy lassign [split [exec ps -o rss [pid]] \n] tmp mem puts "\nj=$j" puts "memo= $mem" puts [join [lor [info globals] $::VariablesAuDepart]] puts [join [lor $cmdD [info commands]]] incr j } exit } proc tmenu {} { package require Tk package require combobox 2.3 namespace import ::combobox::* toplevel .t ttk::menubutton .t.m -text "et hopla ! voila !" -menu .t.m.menu menu .t.m.menu for {set i 0} {$i < 123} {incr i} { .t.m.menu add checkbutton -label "menu-$i" lappend Lval "val-$i" } combobox .t.c -listvar Lval -editable false pack .t.m .t.c -side left -padx 10 .t.c itemconfig 0 -background black -foreground white return } proc tmf {} { cd /home/moumou/alitest/Olivier puts "[pwd]" puts "[join [lsort [glob *.tfa]] \n]" set out [Mafft_AddSequences_local ori.tfa add.tfa] puts "\n\nOUTPUT" puts "[join $out \n]" exit } proc tmin {} { set Lp [list mPm toto eAe dDd tata mFm] set Lre [list toto dDd] set re [join $Lre |] set Li [lsearch -regexp -all $Lp $re] puts $Li exit } proc tmol {} { set o [open "|moleman " w] fconfigure stdout -blocking 1 -buffering line -translation {lg crlf} #fileevent stdout readable [list gets stdout line ; lappend Log $line] set cmd "read 3m4q.pdb chai B 0 0 quit " puts $o $cmd flush $o catch {close $o} puts "" puts "c est fini" puts "Log $Log" exit } proc tmp {} { set l [LesLignesDuFichier "mds.dat"] foreach e $l { set le [split [string trim $e] " "] lappend ln [lindex $e 0] lappend lx [lindex $e 1] lappend ly [lindex $e 2] } set o [open "mds_out.dat" w] foreach x $lx y $ly n $ln { puts $o "$n $y $x" } close $o exit } proc tmpcomptenbdeboitesuniques {} { set Fichier "[RepertoireDuGenome]/fiches/GeneOntology_GPO_receptor" set n 0 set b 0 foreach Ligne [LesLignesDuFichier $Fichier] { set PCA [lindex $Ligne 0] if {[info exists Vu($PCA)]} {incr b;continue} set Vu($PCA) 1 incr n lappend LaNouvelleListe $Ligne } Espionne $b #return $n SauveLesLignes $LaNouvelleListe dans "[RepertoireDuGenome]/fiches/GeneOntology_GPO_receptor_unique" } proc tmplistedespabs {FichierDesPABsASupprimer} { set L [CreeListePourFichierAUneColonne $FichierDesPABsASupprimer] foreach Nom $L { set Vu($Nom) 1 } set FichierLDP "/genomics/link/HeadNecknonrnr/fiches/ListeDesPABsNew" foreach PAB [ListeDesPABs] { if {[info exists Vu($PAB)]} {continue} AppendAuFichier $FichierLDP $PAB } } proc tmpscores {} { global VolPol TRPCA Rosace InitialiseVolPol InitialiseRosace InitialiseRPCA set fmt "%1s | %7.4f %7.4f %7.4f" puts "aa| Rosace VolPol RPCA" foreach a [split ACDEFGHIKLMNPQRSTVWY ""] { puts [format $fmt $a [set Rosace(Norm$a)] [set VolPol(Norm$a)] [set TRPCA(Norm$a)]] } exit } proc tmptmp {} { DecortiqueUnPDB 2frv global PDB_2frv_ChnIdn global PDB_2frv_NomRes global PDB_2frv_NmrRes puts "chains [join $PDB_2frv_ChnIdn]" foreach c [set PDB_2frv_ChnIdn] { set nom [join [set PDB_2frv_NomRes($c)]] regsub -all { +} $nom "" nom puts "$c $nom" } exit } proc tms {} { set Lh [list 182 180 170 180] set Lf [list 152 168 165 175] lassign [Mean-Std $Lh] moyh stdh puts "$moyh" puts "$stdh" puts "[expr {$stdh*$stdh}]" puts [GaussProbability 183 $moyh $stdh] exit } proc tmt {} { global DistBlosum TBlosum InitTBlosum set Ll [LesLignesDuFichier mlog] # check mat pos puts "[lsearch -all -regexp $Ll {^lucky matrix finale}]" set i [lindex [lsearch -all -regexp $Ll {^lucky matrix finale}] 1] foreach l [lrange $Ll $i+1 end] { if {[regexp {^lucky} $l]} { break } set Lv [split $l " "] lassign $Lv a b s set p($a,$b) $s } foreach k [lsort [array names p]] { puts "$k [set p($k)] [set TBlosum($k)]" } # check vec dist set i [lsearch -regexp $Ll {^lucky vecdist}] foreach l [lrange $Ll $i+3 end] { if {[regexp {^colscore} $l]} { break } set Lv [split $l " "] lassign $Lv a b s set m($a,$b) $s } foreach k [lsort [array names m]] { set vj [set m($k)] set vl [format "%.6f" [set DistBlosum($k)]] if {abs($vj - $vl) < 0.000001} {set ok "*"} {set ok " "} puts "$ok $k $vj $vl" } exit } proc tnal {} { CreationDuNalDesGenomesComplets "pfur" "dmel|worm" "Pfuriosus" } proc tnb {} { set Lacc [list NM_001179999.1 NM_1180000.1 vtxlskdjf NM_001179999.1] set Lres [eFetchREST nucleotide $Lacc] foreach res $Lres { puts "\n\n" puts $res } puts "[llength $Lres]" exit } proc tnd {} { cd /genomics/link/taxonomy/ncbi_taxonomy package require md5 set url "http://ftp.ncbi.nih.gov/pub/taxonomy/taxdump.tar.gz" set c [HttpCopy $url] #set c [ContenuDuFichier taxdump.tar.gz] set md5 [::md5::md5 -hex $c] puts "md5 : $md5" cd /home/moumou/SoTOL exit set cont [ContenuDuFichier nodes.dmp] set cont [string map {"\t\|\n" "LuCkYlUc67"} $cont] set cont [string map {"\n" " "} $cont] set cont [string map {"LuCkYlUc67" "\n"} $cont] set Ll [split $cont \n] foreach l [lrange $Ll 0 5] { puts ">$l<" } cd /home/moumou/SoTOL exit } proc tnm {} { set Lid [list NM_006540.2 XM_005251128.3 XM_005251129.3 XM_005251130.3 XM_005251131.3 XM_011517436.1 XM_011517437.1 XM_011517438.1 XM_011517439.1] set Lres [eFetchREST nucleotide $Lid cds] puts "[llength $Lres]" foreach res $Lres { puts "$res" LitLeTFA $tfa nom seq puts "[llength $nom]" } exit } proc tnora {s1 s2} { set Lpil {} set Lpil [lmap c1 [split $s1 ""] c2 [split $s2 ""] {set pil "$c1$c2"} ] set Lv [ScoreDeNorm $Lpil 0] set sum 0.0 foreach v $Lv { set sum [expr {$sum + $v}] } return $sum } proc tnw2 {} { set l1 [lindex [LesLignesDuFichier str1.fa] 1] set l2 [lindex [LesLignesDuFichier str2.fa] 1] set time [time {set out [NW $l2 $l1]}] lassign $out n1 n2 ShowProtDiff n1 n2 puts "time $time" exit lassign [NW $l2 $l1] na nb #lassign [NW [string range $l2 0 19] [string range $l1 0 19]] na nb puts "$nb" puts "$na" exit } proc tnw3 {} { set str1 "MACDEFGILMFYWHRK" set str2 "MGILMFYW" set str1 "CGCTAGCTATATAGAT" set str2 "ACGCTAGCTGATCGATCGATGCG" #set str1 [lindex [LesLignesDuFichier str1.fa] 1] #set str2 [lindex [LesLignesDuFichier str2.fa] 1] foreach var {str1 str2} { set o [open "$var.fa" w] puts $o ">$var" puts $o "[set $var]" close $o } catch {exec ./nw.com} Msg puts "$Msg" puts "" lassign [NW $str2 $str1] na nb puts "" ShowProtDiff na nb #puts "\n$na\n$nb" exit } proc tnwa {} { set s1 "ACDEFGHLM" set s2 "ACDEFLM" set s1 [string repeat $s1 100] set s2 [string repeat $s2 100] set f1 [file tempfile].seq set f2 [file tempfile].seq set o [open $f1 w] puts $o $s1 close $o set o [open $f2 w] puts $o $s2 close $o set ret [exec NWalign $f1 $f2 0 0] puts "res:\n$ret\n----" lassign [NWalign $s1 $s2] r1 r2 puts "r1\n$r1" puts "r2\n$r2" set o [open "|/home/moumou/NWalign $f1 $f2 0 0" r+] puts "o= $o" chan close $o write set l [read -nonewline $o] set Ll [split $l \n] close $o puts "\n\nLl\n[join $Ll \n]" exit } proc toUpperList {list} { set upList {} foreach e $list { set f [string toupper $e] lappend upList $f } return $upList } proc torgs2add {} { InitTaxDB # fichier csv out set o [open orgas.csv w] # orga deja presents puts $o "Organismes déjà présents" set Lo [LesLignesDuFichier marie.id] set Ltnl [$::db eval "select taxid,Name,Lineage from taxonomy where taxid in ([join $Lo ,])"] foreach {t n l} $Ltnl { set l [string map {";" "-"} $l] puts $o "$t;$n;$l" } puts $o ";;;" puts $o ";;;" # nouveaux euka puts $o "Eukaryotes supp" set Lo [LesLignesDuFichier eukaTTL.id] set Ltnl [$::db eval "select taxid,Name,Lineage from taxonomy where taxid in ([join $Lo ,])"] foreach {t n l} $Ltnl { set l [string map {";" "-"} $l] puts $o "$t;$n;$l" } close $o exit } proc totati {} { set file filefof set ifid [open $file "r"] fconfigure $ifid -translation binary set data [read $ifid] close $ifid puts "data $data" exit } proc totoDeAnnaick {FichierDesPABs} { #FichierDesPABs=fiches/LesDDSansJumSeqSansCourtsSansJumProtChoisie #FichierSortie=fiches/ProteineContigOuPas set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne [llength $L] foreach Nom $L { set AccessProtCont [InterrogeProtAndContigChoisis $Nom ProteineChoisie Access] set AccessProtChoi [InterrogeProtAndmRNAChoisis $Nom ProteineChoisie Access] if {$AccessProtCont=="" && ($AccessProtChoi=="NOPROTEIN" || $AccessProtChoi=="")} { set FichierProttfa "[RepertoireDuGenome]/prottfa/$Nom" if {[file exists $FichierProttfa]} {lappend Liste $Nom} } } Espionne [llength $Liste] return $Liste } proc tototiti {} { Espionne "tototiti" } proc tototo {} { global db set VC [VisCourante] $db eval {begin transaction} set Lg [$db eval {select pk_cluster from cluster where pk_clustering=$c}] foreach g $Lg { set Sql "select si.access, sa.seq from seqali as sa , ln_seqali_cluster as lsc, seqinfo as si, ln_vis_seqali as lvs where $g = lsc.pk_cluster and lsc.pk_seqali = lvs.pk_seqali and lvs.pk_vis = $VC and lvs.pk_seqali = sa.pk_seqali and sa.pk_seqinfo = si.pk_seqinfo" set res [$db eval $Sql] lappend Las $res } $db eval {commit} return $Las } proc tp {} { set FichierGB "HS09:NT008421_29.gbtags" Espionne [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] } proc tpc {} { global TDesPCI LNOrdali CalculeLesPCIDuMac foreach n1 $LNOrdali { if {$n1 eq "" || $n1 in $::ListePDB} {continue} foreach n2 $LNOrdali { if {$n1 eq $n2 || $n2 eq "" || $n2 in $::ListePDB} {continue} set pc $TDesPCI($n1,$n2) if {$pc > 0.99} { puts "$n1 $n2 $TDesPCI($n1,$n2)" } } } exit } proc tpca {} { LesDefauts package require La 1.0 catch {namespace import La::*} package require math::linearalgebra set lX [list [list 0.0 0.1 0.2 0.1 0.2] [list 0.1 0.0 0.1 0.2 0.1] [list 0.2 0.1 0.0 0.8 0.9] [list 0.1 0.2 0.8 0.0 0.9] [list 0.2 0.1 0.9 0.9 0.0]] #nist_pca $X set X [::math::linearalgebra::mkMatrix 5 5 0.0] set b [::math::linearalgebra::mkVector 5 1.0] set i 0 foreach l $lX { ::math::linearalgebra::setrow X $i $l incr i } puts "$b\n" puts "[join $X \n]\n" #puts "det=[::math::linearalgebra::det $X]" puts "1-D" foreach r $X { set v [list] foreach c $r { lappend v [expr {1.-$c}] } lappend 1mX $v } set R [::math::linearalgebra::eigenvectorsSVD $1mX] lassign $R V1 V2 puts "V1\n[join $V1 \n]" puts "\nV2\n[join $V2 \n]" set Lw [lindex $V1 0] set min [lindex [lsort -real $Lw] 0] set max [lindex [lsort -real $Lw] end] set s 0.0 foreach x $Lw { set s [expr {$s + $x-$min}] } puts "s=$s" foreach x $Lw { lappend Ln [expr {($x - $min)/$s}] } puts [::math::linearalgebra::show $Ln %5.3f] exit #set R [::math::linearalgebra::solveGauss $X $b] set Rd [::math::linearalgebra::determineSVD $X] lassign $Rd U S V puts "U= $U" puts "S= $S" puts "V= $V" set R1 [lindex $R 0] foreach v $R1 { puts [format "%6.3f %6.3f %6.3f %6.3f %6.3f" {*}$v] } set R2 [lindex $R 1] puts "R2=[join $R2 \n]" set s 0.0 ; set min 99999999999.0 foreach x $R2 { if {$x < $min} {set min $x} } if {$min > 0.} {set min 0.} foreach x $R { set s [expr {$s+($x-$min)}] } puts "s= $s\n" #set s [expr {$s + abs($min*5)}] foreach x $R { set x [expr {($x-$min)/$s*100.}] puts [format "x=%6.2f" $x] } exit } proc tpe {} { package require Thread set initCmd { proc Test {{n ""}} { set w [expr {int(rand()*30000)}] if {$w < 10000} {set w 10000} after $w puts "attend $w dans [thread::id]" return $w } } set poolId [tpool::create -minworkers 20 -maxworkers 20 -initcmd $initCmd] set Ljids {} ; set njobs 500 puts "start sending ..." for {set n 0} {$n < $njobs} {incr n} { lappend Ljids [tpool::post -nowait $poolId Test] } puts "Sending done ..." puts "start recup ..." while {[llength $Ljids] > 0} { set idDone [tpool::wait $poolId $Ljids Ljids] puts "done [llength $idDone] reste [llength $Ljids]" foreach id $idDone { set v [tpool::get $poolId $id] puts "id= $id v= $v" } } tpool::release $poolId exit } proc tpf {} { DecortiqueUnTFA pf.tfa Ln Sq foreach n $Ln { lappend Lns $n [set Sq($n)] } puts "[time {set LPCI [CalculeLesPCIGenerique $Lns]}]" exit } proc tpfam {} { set f [file join /home moumou work moumou BenchPfam PF00008.22] DecortiqueUnTFA $f Ln Sq puts "[llength $Ln]" puts "[join [lrange $Ln 0 10] \n]" foreach n $Ln { lappend new [lindex [split $n "/"] 0] } puts "[llength [lsort -unique $new]]" puts "[join [lrange $new 0 10] \n]" exit } proc tpfm {} { if {0} { set res [PfamScanWebService] set res [join $res " "] puts "\n$res\n" source ~/json-procs.tcl set out [::util::json::parse $res] #puts "$out" #exit package require json set dres [::json::json2dict $res] #set dres $out puts "" puts "out [llength $out] dres [llength $dres]" puts "out\n[lindex $out 0]" puts "dres\n[lindex $dres 0]" } else { # tcllib set dres [ContenuDuFichier dres.json] # json-procs.tcl (OpenACS) set out [ContenuDuFichier out.json] } if {0} { set o [open "dres.json" w] puts $o $dres close $o set o [open "out.json" w] puts $o $out close $o exit } foreach t {0 1} { if {$t == 0} { set json $out } else { set json $dres } puts "" puts "KEYS:\n[dict keys $json]" puts "" puts "[llength $json]" puts [lindex $json 1] } # dres foreach dict $dres { dict for {k v} $dict { puts "$k $v" } puts "" } exit puts "[dict get $dres seq]" exit set val [dict get $dres matchset] foreach e $val { puts "e= $e\n" foreach {k v} $e { puts "\t$k $v" } } exit } proc tpoly {} { set aa1 E set num 284 set aa2 K set acc Q6PI48 if {$aa1 eq "X" || $aa2 eq "X"} { return [list "Not appliable !" "Not appliable !"] } set aa1 [string totitle [AutreCodeLuc $aa1]] set aa2 [string totitle [AutreCodeLuc $aa2]] set fileIn [file join [MiSynPatDir] temp "poly__[clock scan now].txt"] set fileStats [file join [MiSynPatDir] temp "poly__[clock scan now].html"] set o [open $fileIn w] #A0PJX8:p.Arg284His #A1L453:p.Met204Val puts $o "$acc:p.$aa1$num$aa2" close $o set Msg "" carch {set log [exec /biolo/ngs/apps/variant_identification/ensembl-tools/scripts/variant_effect_predictor/variant_effect_predictor.pl -i $fileIn -o stdout --poly b --sift b --Stats_file $fileStats --canonical --database --port 3337 ]} Msg if {$Msg ne ""} { return [list "Pb in computing PolyPhen prediction !" "Pb in computing PolyPhen prediction !"] } set Ll [split $log \n] set res [lsearch -inline -nocase -glob $Ll "*canonical=yes*"] set Lps [lindex [split $res \t] 13] set Lv [split $Lps ";"] set poly [lsearch -inline -glob $Lv "PolyPhen=*"] set sift [lsearch -inline -glob $Lv "SIFT=*"] set poly [string range $poly [string first "=" $poly]+1 end] set sift [string range $sift [string first "=" $poly]+1 end] return [list $poly $sift] puts "[ContenuDuFichier log]" exit } proc tpoolagents {Ljobs} { global env package require Thread set program { set OrdaliDejaSource 1 set GscopeDir $env(GSCOPEDIR) #source [file join $GscopeDir gscope_source.tcl] source [file join $GscopeDir gscope_outils.tcl] source [file join $GscopeDir gscope_sequence.tcl] set OrdaliDir $env(ORDALIDIR) set OrdaliDejaSource 0 source [file join $OrdaliDir src ordali_source.tcl] package require Thread package require http LoadTclPackages package require sqlite3 InitLesDefauts LesDefauts OnlyTLog 1 LesDefauts Mode batch set VariablesAuDepart [info globals] set cmdIn [info commands] } # Create a pool of threads and initialize them with our code set poolid [tpool::create -maxworkers 40 -minworkers 40 -initcmd $program] # Create a number of job requests and # submit the jobs to the pool. # We keep an id for each job so we can # track when they complete set jids {} #set Ljobs [lrange $Ljobs 0 100] foreach job $Ljobs { lassign $job tmp Largs set id [tpool::post -nowait $poolid [list AnalyseFichierBalibase $Largs]] lappend jids $id } # Wait for jobs we submitted to complete. # Collect the results and remove completed jobs # from the set of job ids so that we can # wait on the running jobs each time around the outer loop. set limit 0 set maxlim [expr {5*[llength $jids]}] set nDone 0 set nInit [llength $jids] while {[llength $jids] > 0 && $limit < $maxlim} { if {! ($nDone % 10)} { puts [format "%d done ..." $nDone] flush stdout } set done [tpool::wait $poolid $jids] # check finished jobs foreach id $done { set res [tpool::get $poolid $id] if {! [string is list -strict $res]} { puts "----------------------" puts " Error !" puts "Args :" puts "----------------------" flush stdout update idletasks } else { ResAnaBalAgents tmp tmp $res } set ndx [lsearch -exact $jids $id] if {$ndx != -1} { set jids [lreplace $jids $ndx $ndx] update } } incr limit set nDone [expr {$nInit - [llength $jids]}] } if {$limit >= $maxlim} { puts "hit limit" } # Clean up and report tpool::release $poolid return } proc tpos {} { package require tls source /home/moumou/imap4.tcl set imap [ConnectServer imap.laposte.net 1 993] puts "imap $imap" set rep [LoginServer $imap luc.moulinier derry5] puts "login $rep" set Lfold [::imap4::folders $imap -inline] puts "[join $Lfold \n]" set ifold [lsearch -index 0 $Lfold "\"INBOX\""] set folder [lindex [lindex $Lfold $ifold] 0] puts "mailbox $folder" puts "[::imap4::select $imap $folder]" #set LfieldsIn [list uid from: to: Subject: date: flags bodystructure] set LfieldsIn [list uid from: to: Subject: date: flags] set Lval [::imap4::fetch $imap 1:10 -inline {*}$LfieldsIn] puts "\n$Lval\n" foreach m $Lval { lassign $m uid from to subject date flags puts "\n$uid\n$from\n$to\n$subject\n$date\n$flags\n" } ::imap4::cleanup $imap exit } proc tpq {} { set Lres [PDBQuery -organism 9606 -experiment x-ray -identity 70] puts "Lres [llength $Lres]" exit } proc tpros {} { package require sqlite3 set db root sqlite3 $db /home/moumou/Prosite/Prosite.sql set pt1 [$db eval {select pattern from prosite where accession='PS00118'}] set pt2 [$db eval {select pattern from prosite where accession='PS00119'}] $db close set f /home/moumou/work/moumou/BenchPfam/PF00068.14 DecortiqueUnTFA $f Ln Sq puts "nseq [llength $Ln]" set rg1 [Pattern2Regexp $pt1] set rg2 [Pattern2Regexp $pt2] puts "pt1 $pt1\nrg1 $rg1" puts "pt2 $pt2\nrg2 $rg2\n" #set np1 [regsub -all "\(" $rg1 "" tmp] set np1 0 set Lv1 [list] for {set i 0} {$i < $np1} {incr i} { lappend Lv1 sv1$i } set np2 0 #set np2 [regsub -all "\(" $rg2 "" tmp] set Lv2 [list] for {set i 0} {$i < $np2} {incr i} { lappend Lv2 sv2$i } set nr1 0 ; set nr2 0 ; set nr12 0 foreach n $Ln { set s [set Sq($n)] set sdg [string map [list "." ""] $s] set rp1 [regexp -inline -indices $rg1 $sdg] set rp2 [regexp -inline -indices $rg2 $sdg] if {$rp1 ne "" && $rp2 ne ""} { puts "$sdg" puts "rp1 $rp1" puts "rp2 $rp2" #incr nr1 $rp1 #incr nr2 $rp2 #if {$rp1 && $rp2} {incr nr12} } } puts "$nr1 $nr2 $nr12" exit } proc tprosite {} { #http://prosite.expasy.org/cgi-bin/prosite/PSScan.cgi?seq=sydc_human&output=xml set url "http://prosite.expasy.org/cgi-bin/prosite/PSScan.cgi" set Lseq [list SYAC_HUMAN SYDM_YEAST titin_human] set sseq [join $Lseq \n] set que [http::formatQuery seq $sseq output json] puts "Query\n$que" set res [HttpCopy $url "" $que] puts "$res" package require json set dres [::json::json2dict $res] dict for {k v} $dres {puts "$k $v"} set val [dict get $dres matchset] foreach e $val { puts "e= $e\n" foreach {k v} $e { puts "\t$k $v" } } exit } proc tpub {} { set Lpid [LesLignesDuFichier liste.pid] set Lpid "25787132" set rep [eFetchREST pubmed $Lpid] array set T $rep set LmeshMaj [list] ; set LmeshMin [list] foreach id $Lpid { lappend LmeshMaj {*}[set T($id,MeSHMajor)] lappend LmeshMin {*}[set T($id,MeSHMinor)] lappend Ltitle [set T($id,Title)] lappend Labstract [set T($id,Abstract)] } set f [open mesh.major w] puts $f "[join [lsort -unique $LmeshMaj] \n]" close $f set f [open mesh.minor w] puts $f "[join [lsort -unique $LmeshMin] \n]" close $f set f [open titles.txt w] puts $f "[join $Ltitle \n]" close $f set f [open abstracts.txt w] puts $f "[join $Labstract \n]" close $f exit } proc tpw {} { load /home/moumou/ordali/Extensions/tclordalie0.1/Linux-x86_64/libtclordalie0.1.so set Lseq [list] lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACCEFGHIKLMNPQRS" lappend Lseq "ANNEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPPPP" lappend Lseq "ACDEFGHKKKKNPQRS" lappend Lseq "AIIIIGHIKLMNPQRS" set Lpci [Ccode_Pairwise2 $Lseq] puts "$Lpci" exit } proc tpw2 {} { # load /home/moumou/ordali/Extensions/tclordalie0.1/Linux-x86_64/libtclordalie0.1.so package require tclordalie set Lseq [list] lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" lappend Lseq "ACDEFGHIKLMNPQRS" set Lpci [Ccode_Pairwise $Lseq] puts "$Lpci" exit } proc tpws {} { set Lseq [list SYAC_HUMAN SYDM_YEAST titin_human] set Lseq ">tototo ACDFGILHDLMVPASKDELMSTACCEQLMIV" set res [PrositeWebService -seq $Lseq] puts $res exit } proc tpxb {} { InitLesDefauts set k [array names ::Defauts *Bank] puts $::Defauts($k) puts "" set out [EnlevePrefixeBank "ENA|AAC74936|AAC74936.3"] puts $out exit } proc trackball {p1x p1y p2x p2y} { if {$p1x == $p2x && $p1y == $p2y} { set q [list 0.0 0.0 0.0 1.0] return $q } # First, figure out z-coordinates for projection of P1 and P2 to # deformed sphere set p1 [list $p1x $p1y [tb_project_to_sphere $p1x $p1y]] set p2 [list $p2x $p2y [tb_project_to_sphere $p2x $p2y]] # produit vectoriel set a [Vectoriel $p2 $p1] # rotation angle set d [vsub $p1 $p2] set t [expr {[vlength $d] / 2.0}] # Avoid problems with out-of-control values. if {$t > 1.0} {set t 1.0} if {$t < -1.0} {set t -1.0} set phi [expr {2.0 * asin($t)}] set q [axis_to_quat $a $phi] return $q } proc tralala {} { set res [HttpCopy "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi" "" "db=nucleotide&id=NM_001181762.1%2CJ03279%2CAAA34543.1%2CAY690619%2CAAT99430.1%2CZ49604%2CCAA89634.1%2CAY558073%2CAAS56399.1%2CBK006943%2CDAA08889.1&rettype=gb&retmode=text"] puts $res exit } proc trans {} { package require Tk catch {console show} catch {console eval {set ::tk::console::maxLines 10000}} catch {console eval {.console configure -bg black -fg white -font "Helvetica 14 bold"}} package require Img InitialiseCouleurs set size 30 font create Fnt -family Courier -size $size -weight normal puts "font meas Fnt i [font measure Fnt i]" puts "font meas Fnt toto [font measure Fnt toto]" puts "font metrics Fnt [font metrics Fnt]" #toplevel .t set w ".t" frame $w grid $w -in . -row 0 -column 0 -sticky news grid columnconfig . 0 -weight 1 grid rowconfig . 0 -weight 1 update idletasks puts "frame .t [winfo ismapped $w]" set wl "$w.l" ; set wt "$w.lt" ; set wo "$w.lo" label $wl -text "TOTOTOTOTOTOTOTOTOTO" -fg white -bd 0 -anchor nw -justify center -font Fnt -pady 0 -padx 0 label $wt -text "T" -fg white -bd 0 -anchor nw -justify center -font Fnt -pady 0 -padx 0 label $wo -text "O" -fg white -bd 0 -anchor nw -justify center -font Fnt -pady 0 -padx 0 grid $wl -row 0 -column 0 -padx 20 -pady 20 grid $wt -row 1 -column 0 -padx 20 -pady 20 grid $wo -row 2 -column 0 -padx 20 -pady 20 grid columnconfig $w 0 -weight 1 #wm deiconify .t update idletasks after 500 #set cdef [CouleurDeci2Int [RGBDeLaTkCol [.t.l cget -background]]] set cdef [CouleurDeci2Int [CouleurHexa2Deci #d9d9d9]] puts "cdef $cdef" update idletasks after 500 image create photo toto -format window -data $wl image create photo igt -format window -data $wt image create photo igo -format window -data $wo #toto blank ; igt blank ; igo blank update #toto configure -format window -data $wl update #igt configure -format window -data $wt update #igo configure -format window -data $wo update idletasks after 500 set iwdt [image width igt] #set iwdt [igt cget -width] set ihgt [image height igt] puts "image width $iwdt" puts "image height $ihgt" image create photo ivt ; ivt blank image create photo ivo ; ivo blank ivt copy igt ; ivo copy igo set blc [list 255 255 255] for {set i 0} {$i < $iwdt} {incr i} { for {set j 0} {$j < $ihgt} {incr j} { set colt [ivt get $i $j] lassign $colt rr gg bb if {$colt == $cdef} { ivt transparency set $i $j 1 } elseif {0 && $colt != $blc} { puts "$rr $gg $bb [ivt transparency get $i $j]" set rr [expr {255-$rr}] set gg [expr {255-$gg}] set bb [expr {255-$bb}] ivt put [format "\#%04x%04x%04x" $rr $gg $bb] -to $i $j } set colo [ivo get $i $j] lassign $colo rr gg bb if {$colo == $cdef} { ivo transparency set $i $j 1 } elseif {0 && $colo != $blc} { puts "$rr $gg $bb [ivo transparency get $i $j]" set rr [expr {255-$rr}] set gg [expr {255-$gg}] set bb [expr {255-$bb}] ivo put [format "\#%04x%04x%04x" $rr $gg $bb] -to $i $j } } } canvas .t.c -width 500 -height 250 -bg black grid .t.c -row 3 -column 0 -sticky news for {set i 10} {$i < 400} {incr i 10} { .t.c create line $i 0 $i 250 -fill white } .t.c create text 10 10 -text "TOTOTOTOTOTOTOTOTOTO" -anchor nw -justify center -tags Ttoto -fill white -font Fnt -width 0 puts "bbox text [.t.c bbox Ttoto]" set x0 11 for {set i 0} {$i < 20} {incr i} { if {$i % 2} { set img igo } else { set img igt } set x [expr {$x0+($i*$iwdt)}] .t.c create image $x 60 -image $img -anchor nw -tags ti puts "x= $x" } #.t.c raise ti set x0 10 for {set i 0} {$i < 20} {incr i} { if {$i % 2} { set c O } else { set c T } set x [expr {$x0+$i*$iwdt}] .t.c create text $x 110 -text $c -anchor nw -font Fnt -fill white -tags solo } .t.c create image 60 200 -image igt -anchor nw .t.c create image 110 200 -image igo -anchor nw .t.c create image 170 200 -image ivt -anchor nw .t.c create image 230 200 -image ivo -anchor nw puts "solo [.t.c bbox solo]" update after 500 update idletasks set var 0 tkwait variable var return } proc trans2 {} { package require Tk package require Img InitialiseCouleurs #font create Fnt -family Courier -size 32 -weight bold set size 30 font create Fnt -family Courier -size $size -weight normal puts "font measure Fnt i [font measure Fnt i]" puts "font measure Fnt toto [font measure Fnt toto]" puts "font metrics Fnt [font metrics Fnt]" pack [frame .t] label .t.lt -text "t" -fg white -bd 0 -anchor nw -justify center -font Fnt -pady 0 label .t.lo -text "o" -fg white -bd 0 -anchor nw -justify center -font Fnt -pady 0 pack .t.lt .t.lo -padx 20 -pady 20 -side bottom set wt .t.lt set wo .t.lo update idletasks image create photo igt image create photo igo igt blank igo blank igt configure -format window -data $wt igo configure -format window -data $wo update idletasks after 500 igt write igt.png -format png igo write igo.png -format png update idletasks set iwdt [image width igt] puts "image width [image width igt]" puts "image height [image height igt]" pack [canvas .t.c -bg black -width 200 -height 200] -side bottom .t.c create line 10 0 10 200 -fill white .t.c create text 10 10 -text "tototototototo" -anchor nw -justify center -fill white set x0 11 for {set i 0} {$i < 14} {incr i} { if {$i % 2} { set img igt } else { set img igo } set x [expr {$x0+$i*$iwdt}] .t.c create image $x 100 -image $img -anchor nw } update idletasks set var 0 tkwait variable var return } proc trari {} { package require sqlite3 sqlite3 d taxo.sql lassign [d eval {select Name,Rank,Parent from taxonomy where Name='Danio rerio'}] name rank f puts "$name $rank $f" while {$f >= 0} { lassign [d eval {select Name,Rank,Parent from taxonomy where taxid=$f}] name rank p puts "$name $rank $p" set f $p } exit } proc treg {} { set a "S1." if {[regexp {([A-Z]{1})([0-9]+)([A-Z]{1})} $a => a1 no a2]} { puts "toto" } exit } proc triHitsParNbTirets {hits Type} { proc compare {a b} { upvar Type Type set isoa [expr ![regexp -nocase {isoform} [$a get head]]] set isob [expr ![regexp -nocase {isoform} [$b get head]]] set dba [expr {[lindex [split [$a get id] "|"] 0] eq "sp"}] set dbb [expr {[lindex [split [$b get id] "|"] 0] eq "sp"}] set nta [regexp -all -- {-} [$a enleverTirets $Type]] set ntb [regexp -all -- {-} [$b enleverTirets $Type]] if {$isoa > $isob} { puts "[$b get id] is ISO: [$b get head]"; return 1 } if {$isoa < $isob} { puts "[$a get id] is ISO: [$a get head]"; return -1 } if {$dba > $dbb} { return 1 } if {$dba < $dbb} { return -1 } if {$nta > $ntb} { return 1 } if {$nta < $ntb} { return -1 } return 0 } return [lsort -decreasing -command compare $hits] } proc triHitsParNbTiretsOld {hits Type} { set ntirets 9999 set best 0 for {set i 0} {$i<[llength $hits]} {incr i} { set h [lindex $hits $i] set tmp [regexp -all -- {-} [$h enleverTirets $Type]] if {$tmp < $ntirets} { set ntirets $tmp set best $i } } set h [lindex $hits $best] return [linsert [lreplace $hits $best $best] 0 $h] } proc triall1 {} { set Ll [LesLignesDuFichier all.id] puts "[llength $Ll]" set Ll [lsort -unique -integer $Ll] puts "[llength $Ll]" set o [open all.id w] puts $o [join $Ll \n] close $o exit } proc trna {} { global pgl Lpts Rad rename EnvoieLesObjets EnvoieLesObjetstmp rename EnvoieLesObjets4 EnvoieLesObjets Initialisation set Ll [LesLignesDuFichier p.xyz] set sx 0.0 ; set sy 0.0 ; set sz 0.0 foreach l $Ll { scan [string range $l 30 54] "%8f%8f%8f" x y z set sx [expr {$sx + $x}] set sy [expr {$sy + $y}] set sz [expr {$sz + $z}] lappend Nc $x $y $z } set sx [expr {$sx / [llength $Ll]}] set sy [expr {$sy / [llength $Ll]}] set sz [expr {$sz / [llength $Ll]}] foreach {x y z} $Nc { set x [expr {$x - $sx}] set y [expr {$y - $sy}] set z [expr {$z - $sz}] lappend Lpts [list $x $y $z] } puts "Lpts [llength $Lpts]" set Lpts [Lissage3D $Lpts] puts "Lpts [llength $Lpts]" lassign [BBox3D $Lpts] xm xx ym yx zm zx set xc $sx set yc $sy set zc $sz set Rad [expr {5.*sqrt(($xx-$xm)**2+($yx-$ym)**2+($zx-$zm)**2)/2.}] set pgl(Rad) $Rad set pgl(xCen) [expr {($xx+$xm)/2.}] set pgl(yCen) [expr {($yx+$ym)/2.}] set pgl(zCen) [expr {($zx+$zm)/2.}] set pgl(frontclip) $Rad set pgl(backclip) [expr {-2.0*$Rad}] set pgl(eyeX) 0.0 set pgl(eyeY) 0.0 set pgl(eyeZ) [expr {1.1*$pgl(zCen)}] puts "jusque la tout va bien ! " ; flush stdout #AfficheFenetreOpengl return set p0 [lindex $Lpts 0] set Va [list 1.0 2.0 3.0] set Rd 1. foreach pt [lrange $Lpts 1 end] { if {0} { set dir [V_VV $pt - $p0] set V2 [V_VV $Va - $p0] set Vo [V_VV $p0 + [V_VS [V_nV [Vectoriel $dir $V2]] * $Rd]] set pf [V_VV $p0 + [V_VS $dir * 0.75]] # calcul du cercle . 10 pas for {set i 0} {$i < 360} {incr i 36} { } } set p0 $pt } return } proc troc {} { set Lp1 [list dP-eP dC-eC dP-eP-dC-eC ""] set Lp2 [list dA-dD-eA-eD ""] set Lp3 [list dAd-dDd-eAe-eDe dAd-eAe dDd-eDe ""] foreach p1 $Lp1 { foreach p2 $Lp2 { foreach p3 $Lp3 { set p [list $p1 $p2 $p3] set par [string trim [join $p "-"] -] lappend Lpar [string map [list "--" "-"] $par] } } } puts "[join $Lpar \n]" puts [llength $Lpar] exit } proc trouvegnwithcombipathway {} { set i 0 lappend LesFiles "/home/poidevin/ordi/bilbault/down/String_9606_700_201007281509/Summary.txt" lappend LesFiles "/home/poidevin/ordi/bilbault/up/String_9606_700_201007281442/Summary.txt" foreach File $LesFiles { Espionne "$File" foreach Ligne [LesLignesDuFichier $File] { if {[regexp {^Initial} $Ligne]} {continue} set Gn [lindex [split $Ligne ";"] 2] set Gn [string trim $Gn] lappend LesGns $Gn } } set FileFromKegg "/home/poidevin/ordi/bilbault/AttributeNodeFromKEGG" foreach LigneK [LesLignesDuFichier $FileFromKegg] { set GnK [lindex [split $LigneK "\t"] 0] set GnK [string trim $GnK] foreach Gn $LesGns { if {$Gn==$GnK} { incr i Espionne "$LigneK" break } } } Espionne $i } proc trouvelespassourisdeac1plein {} { set Fichier "[RepertoireDuGenome]/fiches/Ac1Plein2" foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^ligne } $Ligne]} { set onla 0 scan $Ligne "%s %s" bidon numeroligne } if {[regexp {^cas1} $Ligne]} { set DejaVu($numeroligne) 1 } } foreach Ligne [LesLignesDuFichier $Fichier] { if {[regexp {^ligne } $Ligne]} { set onla 0 scan $Ligne "%s %s" bidon numeroligne if {![info exists DejaVu($numeroligne)]} { Espionne "$numeroligne attention" } } } } proc trr {} { set Lpdbid [list 1c0a 1il2 1asy] foreach pdbid $Lpdbid { set file "/db/catalog/pdb/compressed_files/[string range $pdbid 1 2]/pdb${pdbid}.ent.gz" set temps [time { Structure create $pdbid set cok [$pdbid new $file "" 0 0] foreach c [$pdbid _chains] { puts "$pdbid" puts "$c [$pdbid _chainIs $c]" set s [join [$pdbid _resname -chain A] ""] } }] puts "temps $pdbid $temps" } exit } proc trsm {} { set str "...ASDFSDFDSF...S.S.S.S" set seq [string repeat $str 100] set Lseq [lrepeat 100 $seq] puts "[time {regsub -all {\.} $Lseq {-} tmp} 10]" set res [list] puts "[time {foreach s $Lseq { lappend res [string map {\. -} $s] }} 10]" exit } proc truncateAssemblyDb {} { #canalSqlAssemblyDb NSAssemblyDb::getCanal puts "WARNING: will truncate the full database" gets stdin puts "DELETING HISTORY..." SqlExec "DELETE FROM history" puts "DELETING READS..." SqlExec "DELETE FROM sequence WHERE pk_contig IS NOT NULL" puts "DELETING CONTIGS..." SqlExec "DELETE FROM contig" puts "DELETING SINGLETS..." SqlExec "DELETE FROM singlet" puts "DELETING CONTIGS AND SINGLETS FROM SEQUENCE TABLE..." SqlExec "DELETE FROM sequence" puts "DELETING ASSEMBLER PARAMETERS..." SqlExec "DELETE FROM cap3_assembler_parameters" puts "DELETING ASSEMBLY..." SqlExec "DELETE FROM assembly" puts "DELETING LIBRARY..." SqlExec "DELETE FROM library" SqlExec "ALTER SEQUENCE assembly_pk_assembly_seq RESTART WITH 1" SqlExec "ALTER SEQUENCE contig_pk_contig_seq RESTART WITH 1" SqlExec "ALTER SEQUENCE library_pk_library_seq RESTART WITH 1" SqlExec "ALTER SEQUENCE sequence_pk_sequence_seq RESTART WITH 1" SqlExec "ALTER SEQUENCE singlet_pk_singlet_seq RESTART WITH 1" puts "WARNING: database truncated" CanalSqlDisconnect } proc tsco {} { global LNDG SDG LNOrdali Sequences LongueurTotale ListeDesPiliersDuGroupe DecortiqueUnTFA /home/moumou/ordali/alitest/neo.tfa LNOrdali Sequences set LNDG GroupeToutLeMonde set SDG(GroupeToutLeMonde) $LNOrdali set LongueurTotale [string length [set Sequences([lindex [array names Sequences] 0])]] CreeLesPiliers #set Lw [ScoreDeWilliamson [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] #set Lk [ScoreDeKabat [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] #set Le [ScoreDeEntrop1 [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)]] set Lns [list] foreach n $LNOrdali { lappend Lns $n [set Sequences($n)] } set LPCI [CalculeLesPCIGenerique $Lns] set Ls [ScoreDeSanderSP [set ListeDesPiliersDuGroupe(GroupeToutLeMonde)] $LNOrdali $LPCI] puts "[join $Ls \n]" exit } proc tscr {} { LesDefauts MinThrGap 0 LesDefauts PCThrGap 0.0 InitialiseRosace set sr RVIIKENKQPTYY set s1 NVIGAEQRHPQMA set s2 EKIMKELKEKGIK set s3 ESVVRAQMVTTYR set s4 ELIILLSKFPEVV set s5 ELIVEELKKELPE set s6 LVLRRSDGTATYT foreach i {1 2 3 4 5 6} { set Lpil [list] foreach c1 [split $sr ""] c2 [split [set s$i] ""] { lappend Lpil "$c1$c2" } set ros [scoreNormAgents $sr [set s$i]] puts -nonewline "$i : [format %6.2f $ros] " foreach msc {Norm BILD Entrop1} { set sum 0.0 foreach v [ScoreDe$msc $Lpil] { set sum [expr {$sum + $v}] } puts -nonewline [format %6.2f $sum] } puts "" } exit } proc tse {} { set a toto puts [time {if {[string equal $a "-key"]} {}} 100000] puts [time {if {$a ne "-key"} {}} 100000] exit } proc tseqp {} { set pdbid 1aky set uniprot P07170 set tp [TextePDB $pdbid ALL "" OnTheWeb] Structure create $pdbid $pdbid new $tp set sr [$pdbid _seqres A] set sp [join [$pdbid _resname -chain A] ""] puts "sp $sp" puts "sr $sr" puts "" puts "NW" lassign [NWAlign $sp $sr] op or puts "al pdb $op" puts "al res $or" #exit # PDB : seqres contre seqpdb set i [string first [string range $sp 0 10] $sr] if {$i == -1} { puts "pdb seqs pas compatible !" #exit } #set sp "[string range $sr 0 $i-1]$sp" #ShowProtDiff $sr $sp #exit set tu [DbFetchGET uniprot P00549] set Lu [split $tu \n] DecortiqueLesLignesEMBL $Lu a b c d e f g su puts "su $su" lassign [NWAlign $sr $su] ar au puts "al ar $ar" puts "al au $au" #puts [regexp "$sp" $su] #exit set i [string first $sp $su] puts "i= $i" set i [string first [string range $sp 0 19] $su] puts "i= $i" set sp "[string range $su 0 $i-1]$sp" ShowProtDiff $sp $su exit lassign [NWAlign $sp $su] op ou puts $op puts $ou exit set Lp [LaSequenceDesBanques 1bjt] set Lu [LaSequenceDesBanques P06786] set tp [join $Lp \n] set tu [join $Lu \n] set sp [DecortiqueLesLignesEMBL $tp] set su [DecortiqueLesLignesEMBL $tu] puts $su puts $sp exit } proc tsor {} { proc t1 {} { set Nb 10000 set Lv [list] for {set i 0} {$i <= $Nb} {incr i} { set v [expr {rand()*$Nb}] lappend Lv1 $i $v } set res [lsort -real -stride 2 -index 1 $Lv1] } proc t2 {} { set Nb 10000 set Lv [list] for {set i 0} {$i <= $Nb} {incr i} { set v [expr {rand()*$Nb}] lappend Lv2 [list $i $v] } set res [lsort -real -index 1 $Lv2] } puts "[time {t1} 1000]" puts "[time {t2} 1000]" exit } proc tsq {} { CanalSqlGeneOntology Espionne [SqlExec "mysqlinfo [CanalSql] tables"] set R [SqlExec "select * from term limit 10;"] foreach {Id Na Ty Ac toto titi tutu} $R { Espionne "$Id $Ac" } exit } proc tsql {} { package require sqlite3 set db root sqlite3 $db eccb.sql set pk [$db eval {select lpd.pk_participants from ln_participants_discounts as lpd, discounts as d where d.Nom = 'D4' and lpd.pk_discounts=d.pk_discounts}] set v [$db eval {select p.Nom,d.Nom from participants as p, ln_participants_discounts as lpd, discounts as d where p.pk_participants = $pk and lpd.pk_participants = p.pk_participants and d.pk_discounts = lpd.pk_discounts}] puts "$v" exit set Ln [$db eval {select Nom from participants}] foreach n $Ln { puts "$n" if {[string trim $n] eq "" || [string trim $n] eq "NULL"} { puts "vide" } if {[$db eval {select count(Nom) from participants where Nom=$n}] > 1} { puts "$n" } } $db close exit } proc tssi {} { set dbR rootR package require sqlite3 sqlite3 $dbR rrps.sql set Lv [$dbR eval {select ssi from items}] foreach v $Lv { foreach i $v { lassign $i type tmp lappend Ltype $type } } puts [lsort -unique $Ltype] $dbR close exit } proc tstadd {} { global NomSeqSel update idletasks set NomSeqSel 5.0 AjouteSeqs return } proc tstag {} { set s1 "---AGEFTHTWILMRSVAL----THILSNTMVRAQVQIPSMHGW------" set ::Sequences(s1) [string map {- .} $s1] #set ::Sequences(s1) ".AC..DEFGHIKLMN.." set ::LNOrdali [list s1] set ::MotifLen 3 UpdateAgentsOfSeq s1 parray ::TAg exit } proc tstat {} { set jid "ncbiblast-R20140331-100922-0009-50350078-pg" set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/status/$jid" set res [HttpCopy $url] puts "$res" puts "\n\n" #exit set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/resulttypes/$jid" set res [HttpCopy $url] puts "RESTYPES\n[string map { 23} { set k 0 incr i #if {$i == 4} {break} } else { incr k } } set n [expr {[llength $Lp]/4*3}] set sx [expr {$sx/$n}] set sy [expr {$sy/$n}] set sz [expr {$sz/$n}] foreach p $Lp { lassign $p l x y z set x [expr {$x-$sx}] set y [expr {$y-$sy}] set z [expr {$z-$sz}] lappend Lpts [list $x $y $z] lappend Llbl $l } puts "Lpts [llength $Lpts] Llbl [llength $Llbl] Lnrm [llength $Lnrm]" #traite les normales set nl [list] foreach p $Lpts n $Lnrm { lappend nl [Rescale $n $p] } set Lnrm $nl lassign [BBox3D $Lpts] xm xx ym yx zm zx set xc $sx set yc $sy set zc $sz set Rad [expr {5.*sqrt(($xx-$xm)**2+($yx-$ym)**2+($zx-$zm)**2)/2.}] set pgl(Rad) $Rad set pgl(xCen) [expr {($xx+$xm)/2.}] set pgl(yCen) [expr {($yx+$ym)/2.}] set pgl(zCen) [expr {($zx+$zm)/2.}] set pgl(frontclip) $Rad set pgl(backclip) [expr {-2.0*$Rad}] set pgl(eyeX) 0.0 set pgl(eyeY) 0.0 set pgl(eyeZ) [expr {1.1*$pgl(zCen)}] #AfficheFenetreOpengl raise .ordogl $pgl(Wogl) postredisplay return } proc tstps {} { set Lps [LesPrositesDuTFA PF00001.16_smp] array set T $Lps parray T puts "Nb seqs [llength [array names T]]" set reg "(\[GSTALIVMFYWC\])(\[GSTANCPDE\])...(\[LIVMNQGA\])..(\[LIVMFT\])(\[GSTANC\])(\[LIVMFYWSTAC\])(\[DENH\])(R)(\[FYWCSH\])..(\[LIVM\])" DecortiqueUnTFA PF00001.16_smp Ln Sq set nv 0 foreach n $Ln { lappend Ls [set Sq($n)] set sd [string toupper [string map [list "-" "" "." ""] [set Sq($n)]]] set rep [regexp -inline -indices $reg $sd] if {$rep != ""} { puts "$n $rep" incr nv } } puts "nVu $nv" exit } proc tstri {} { set pdbid 1asy set txt [TextePDB $pdbid ALL "" OnTheWeb] set o [open "$pdbid.pdb" w] puts $o $txt close $o update catch {exec /home/moumou/bin/stride ${pdbid}.pdb} Msg file delete $pdbid.pdb puts "$Msg" exit } proc tstsurf {} { global StrucAVoir doneSurfBall set doneSurfBall 0 LoadTkAndPackages rename EnvoieLesObjets Envoie_wait rename SurfBall EnvoieLesObjets #rename Cubes EnvoieLesObjets catch {glDeleteLists 513 1} glFlush glFinish set StrucAVoir [list] Initialisation AfficheFenetreOpengl #Update3DMatrices $::pgl(wogl) postredisplay return } proc tstwb {} { set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/" # programm set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/program" set res [HttpCopy $url] puts "PROGRAM" puts "$res\n" # sequence set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/sequence" set res [HttpCopy $url] puts "SEQUENCE" puts "$res\n" # STYPE set url "http://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/stype" set res [HttpCopy $url] puts "STYPE" puts "$res\n" #exit set seq ">sp|P15179|SYDM_YEAST Aspartate--tRNA ligase, mitochondrial OS=Saccharomyces cerevisiae (strain ATCC 204508 / S288c) GN=MSD1 PE=1 SV=1 MLARSRVCLQTITRRLADFPEANAIKKKFLFRKDTSTIKQLKGLSSGQKIVLNGWIEQKPKRVGKNLIFGLLRDSNGDIIQLVDNKSLLKGFTLEDVVQAVGILSLKRKLSNEDADEYEVQLEDITVLNASNKKPAQMQDFKLSAIYPPEFRYLQLRNPKYQDFLKKRSSISKEIRNSFNNFDFTEVETPMLFKATPEGAREFLVPTRTKRSDGKPSFYALDQSPQQYKQLLMASGVNKY YQMARCFRDEDLRADRQPEFTQVDMEMAFANSEDVMKIIEKTVSGVWSKFSKKRGLLTLDSKGTLVPAKKENGTVSIFRMTYEQAMTSYGIDKPDLRAPDLKIINLGEFNAFSHLNKKFPVFEVIILRSAFSNMEEYKERWSFLTNNSNYNYRVPIVLPIENDEQANSNWFENFHAIATFENPHLITKFLKLKKGDIVCGCTREPNHSIFENPTPLGRLRQLVLQSEHGKNIYHAVNKDVASWIVDFPLFSPVIIEDKSGKKEKLAYPEYEKDRLCSTHHPFTMVKLKDYEKLEKTPEKCLGRHYDLVVNGVELGGGSTRIHDPRLQDYIFEDILKIDNAYELFGHLLNAFDMGTPPHAGFAIGFDRMCAMICETESIRDVIAFPKSITGADLVVKSPSVIPESILEPYNIKYSNSKK " set Lres [BlastServiceEBI -p blastp -d uniprotkb -expect 1e-5 -query $seq -nlist 10 -f T -stype protein] puts "\n-----------------------" puts "Blast result\n$Lres\n" DecortiqueBlast $Lres "" "" "" LBbid LBacc LBde "" LBPN LAli puts "\n----------------------------" foreach a $LBacc p $LBPN ali $LAli { puts "$a $p" set lgt -1 ; set pid -1 foreach l $ali { set l [string trim $l] if {[string range $l 0 5] eq "Length"} { set lgt [string range $l 7 end] } if {[string range $l 0 9] eq "Identities"} { set id [string first "(" $l] set if [string first ")" $l] set pid [string range $l $id+1 $if-1] } } puts "$lgt $pid" puts "" } exit } proc tsumtax {} { set Lid [list 578455 242507 759272 5141 431241 660122 645133 559298 330879 441960 336722 246410 663202 554155 656061 306902 284592 322104 237561 379508 294746 644223 284591 284593 559292 436907 284590 284811 931890 559295 559307 284812 402676 486041 246409 999809 237631 1128400 1054147 9606 10090 9305 7955 7739 10228 6239 7217 7165 7176 7159 121224 6669 6945 13686 104421 946362 6183 81824 403677 3055 554065 296587 70448 3694 3702 4577 452637 583355 391774 883 207559 525146 525897 363253 443144 351605 316067 243231 398767 338966 177439 177437 335543 56780 639282 264201 530564 446471 247156 446465 471857 292415 335283 349741 436114 204536 123214 518766 289376 608538 309799 515635 340099 273068 351627 521460 373903 370438 246194 477974 429009 349161 591001 292459 272564 224308 279010 315750 491915 545693 235909 398511 458233 226185 324057 387092 479437 278197 309801 479434 525904 243164 383372 326427 316274 526218 190304 655815 521097] array set T [eSummaryREST taxonomy $Lid] parray T exit } proc tsvg {} { source [file join $::OrdLibDir uriencode.tcl] source [file join $::OrdLibDir tinyfileutils.tcl] source [file join $::OrdLibDir can2svg.tcl] LoadTkAndPackages canvas .c -scrollregion [list 0 0 400 400] -width 400 -height 400 -background black grid .c -row 0 -column 0 -sticky news grid columnconfig . 0 -weight 1 grid rowconfig . 0 -weight 1 FenetreAuCentre . set ang 45. set id [.c create text 100 100 -fill white -text "Salut le Monde" -font "Courier 24" -anchor w -justify left] set Lb [.c bbox $id] puts "bbox $Lb" .c itemconfig $id -angle $ang lassign $Lb x1 y1 x2 y2 set ym [expr {($y1+$y2)/2}] incr x1 -5 ; incr y1 -5 incr x2 5 ; incr y2 5 set Lb [list $x1 $y1 $x2 $y1 $x2 $y2 $x1 $y2] puts "Lb $Lb" set ang [expr {-1.0*$ang}] set Lb [TourneListe 100 $ym $ang $Lb] puts "rot $Lb" set pol [.c create polygon {*}$Lb -width 3 -outline white] .c raise $id update idletasks can2svg::canvas2file ".c" toto.svg return } proc tt2p {} { global Abr set ph [ContenuDuFichier calibre5.ph] puts "Tree IN :" puts "$ph" set AId [DecortiqueUnArbre $ph] set t [set Abr(Arbre,$AId)] #puts "\nTree ORD" #puts "[$t serialize root]" set res [Tree2PH $t root] puts "\n$res" exit } proc ttaa {} { #global toto set ::toto "salut arnaud" package require Thread set program { global toto env package require Thread puts "$env(USER)" source /home/moumou/ordali/src/ordali_agents.tcl } set poolid [tpool::create -maxworkers 3 -minworkers 3 -initcmd $program -exitcmd {puts "je sors !"}] set Lids [list] for {set i 0} {$i < 12} {incr i} { set id [tpool::post -nowait $poolid PostProc] lappend Lids $id } while {[llength $Lids] > 0} { set done [tpool::wait $poolid $Lids] foreach id $done { set res [tpool::get $poolid $id] puts "res-> $res $id" set idx [lsearch -exact $Lids $id] set Lids [lreplace $Lids $idx $idx] update } } exit } proc ttag {} { package require Tk toplevel .t text .t.t -width 20 -height 20 -wrap none -background black -foreground white pack .t.t button .t.b -bg blue -fg white -text "DUMP" -command {Dumple} pack .t.b -side bottom set txt1 "A.B.C.D.E.F.G.H.I.J.\n.A.B.C.D.E.F.G.H.I.J" set txt [join [lrepeat 10 $txt1] \n] .t.t insert end $txt .t.t tag configure Tag1 -foreground white -background magenta .t.t tag configure Tag2 -foreground black -background green1 .t.t tag configure Tag3 -foreground white -background brown set Lt1 [list 1.1 1.2 1.3 1.4 1.6 1.7 3.3 3.8 5.2 5.7 7.2 7.8] set Lt2 [list 7.3 7.7] set Lt3 [list 7.4 7.6] .t.t tag add Tag1 {*}$Lt1 .t.t tag add Tag2 {*}$Lt2 .t.t tag add Tag3 {*}$Lt3 return } proc ttax {} { global db TaxRoot InitTaxDB set pere "" set fils 3702 set pere [$db eval {select Parent from taxonomy where taxid=$fils}] while {$pere != $TaxRoot} { lappend Lgen $pere set fils $pere set pere [$db eval {select Parent from taxonomy where taxid=$fils}] incr nNiveau } puts "niveaux $nNiveau" set Lin [$db eval {select Lineage from taxonomy where taxid=3702}] puts "nlin [llength [split $Lin ;]]" puts "Lgen $Lgen" eval set Lid [$db eval {select IdLineage from taxonomy where taxid=3702}] puts "Lid [lreverse $Lid]" puts "$TaxRoot" exit } proc ttax999 {} { package require sqlite3 set db "root" sqlite3 $db taxo.sql set Lec [$db eval {select taxid from gold where Name like 'saccharomyces cerevis%'}] set Lrp [$db eval "select taxid, Name, Parent, Rank from taxonomy where taxid in ([join $Lec ,])"] set Lig [$db eval "select isGold from sotol where taxid in ([join $Lec ,])"] foreach {t n p r} $Lrp i $Lig { if {$r eq "no rank"} { set rkn [$db eval {select Rank,Name from taxonomy where taxid=$p}] puts "$i $r $n | $rkn" } else { puts "$i $r $n" } lappend Lrk $r } puts "[::tcl::mathop::+ {*}$Lig] [llength $Lrk] [lsort -unique $Lrk]" exit } proc ttid {} { set t1 [ContenuDuFichier t1.txt] set t1 [split $t1] set L1 [list] foreach e $t1 { if {$e != ""} {lappend L1 $e} } set L1 [lsort -integer $L1] set t2 [LesLignesDuFichier t2.txt] set L2 [list] foreach e $t2 { if {$e != ""} {lappend L2 $e} } set L2 [lsort -integer $L2] puts "[llength $L1] [llength $L2]" puts "from1 [lor $L1 $L2 from1]" puts "from2 [lor $L1 $L2 from2]" puts "[set Lor [lor $L1 $L2]]" package require sqlite3 set db root sqlite3 $db taxo.sql $db eval {begin transaction} foreach i $Lor { set nr [$db eval {select Name,Rank from taxonomy where taxid=$i}] puts "$i [join $nr]" } $db eval {commit} exit } proc ttid_SERVICE {} { set Li [list XP_002997757.1 BAM80333] set L [eSearchREST protein $Li] array set X [eSummaryREST protein $L] parray X puts "" foreach k [array names X "*,TaxId"] { unset -nocomplain T array set T [eFetchREST taxonomy [set X($k)]] parray T puts "" } exit } proc ttinf {} { # q5vz01 set Luni q5vz01 #set Lres [split [DbFetchGET uniprot $Luni] \n] #set Lembl [SplitLesEMBL $Lres] #puts [join [lindex $Lembl 0] \n] #exit set ::ListePDB {} set Lid [LesLignesDuFichier lgi] #FetchInfosSeqs $Lid #set Lacc [IDMapping "ACC+ID" ACC $Lid] #set Lbid [IDMapping "ACC+ID" ID $Lid] #exit array set T [InfosFromRefSeq $Lid] foreach k [array names T "*,GI"] { lappend Lk $T($k) } set Lr [ConvertGI2RefSeq $Lid] foreach k [lsort $Lk] g [lsort $Lid] r $Lr { puts "$k $g $r " } exit #parray T foreach k [array names T "*,currAC"] { lassign [split $k ,] ac tmp set dif "" if {$ac ne $T($k)} {set dif X} puts "$ac $T($k) $dif" } exit #ChangeMode feature set tmp [array names T "*,TaxId"] foreach k $tmp { lappend Lk [lindex [split $k ,] 0] } puts "Lor [lor $Lid $Lk]" return } proc ttmp {} { set ligne [ContenuDuFichier tmp] set ligne [string map {"\n" ""} $ligne] set dtd [string first "" $ligne] while {$dtd != -1} { set td [string range $ligne $dtd $ftd+4] puts "$td" set ligne [string replace $ligne $dtd $ftd+4] set Lcom [regexp -all -indices -inline {\<\!.\>} $td] set Lcom [lreverse $Lcom] puts "Lcom $Lcom" foreach {lb la} $Lcom { lassign $la d tmp lassign $lb tmp f set td [string replace $td $d $f] } set res [regexp -all -inline "\>.+\<" $td] puts $res puts "" set dtd [string first " $mxb} { return 1 } else { return -1 } } proc ttsurf {} { package require tsurf set Ll [LesLignesDuFichier p.xyz] set sx 0.0 ; set sy 0.0 ; set sz 0.0 foreach l $Ll { scan [string range $l 30 54] "%8f%8f%8f" x y z set sx [expr {$sx + $x}] set sy [expr {$sy + $y}] set sz [expr {$sz + $z}] lappend Nc $x $y $z } set sx [expr {$sx / [llength $Ll]}] set sy [expr {$sy / [llength $Ll]}] set sz [expr {$sz / [llength $Ll]}] foreach {x y z} $Nc { set x [expr {$x - $sx}] set y [expr {$y - $sy}] set z [expr {$z - $sz}] lappend Lpts [list $x $y $z] } puts "Lpts [llength $Lpts]" set Lpts [Lissage3D $Lpts] puts "Lpts [llength $Lpts]" foreach p $Lpts { lassign $p x y z lappend Lva [list $x $y $z 8 1] } lassign [tsurf -expand 2 -contract 2 -smooth -connolly $Lva] Lv Ln puts "Lv [llength $Lv]" exit return } proc ttt {} { set Lid [list Q8SRE0 Q8IJP3 Q22XF6 Q9GQ39 XP_763084 Q54KR1 Q4QGR8 Q4CQ34 Q4CUZ9 XP_002286825 O76618] set res [IDMapping "ACC+ID" ACC $Lid] puts "$res" puts "\n-----------------------" puts "[Convert2UniProtAcc $Lid]" exit } proc ttu {} { set Lres [eFetchREST nucleotide NM_001184046.1] set res [lindex $Lres 0] set Lorfs [DecortiqueGenBank OS OC SeqAdn $res] puts [join $Lorfs \n] exit } proc tup {} { global Sequences set seq "A...CDREFE..FEFD..SSSS" set seq "acdefghkl.mn" set seq "..CEF.AFDLM.QQ.PQRST...ARETDF" set Sequences(toto) $seq puts $seq UpdateAgentsOfSeq toto #parray ::TAg exit } proc tupref {} { global db set Lt [UniProtProteome 1] InitTaxDB puts "Lt0 [llength $Lt]" set tmp [list] foreach t $Lt { if {$t ne ""} {lappend tmp $t} } set Lt [lsort -unique -integer $tmp] puts "Lt2 [llength $Lt]" puts "uniprot genomes contre gold complete" set Lo [$db eval "select taxid from sotol where isComp=1 and taxid in ([join $Lt ,]) group by taxid"] puts "overlap : [llength $Lo]" set Ld [$db eval "select Domaine,taxid from gold where taxid in ([join $Lt ,]) group by taxid"] set Lo [list] set Lo [lmap {x y} $Ld {set x}] puts "[join [DenombreLaListe $Lo] \n]" puts "\nboucle sur taxid" set Lo [list] foreach id $Lt { lappend Lo [$db eval {select Domaine from gold where taxid = $id limit 1}] } puts "\n gold :\n [join [DenombreLaListe $Lo] \n]" set Ll [$db eval "select Lineage from taxonomy where taxid in ([join $Lt ,])"] foreach l $Ll { set Lt [split $l ";"] lappend Lv [lindex $Lt 0] } puts "[join [DenombreLaListe $Lv] \n]" $db close exit } proc turlu {} { set l [Getz dq319864 genbankfull] set Ll [split $l "\n"] set f [open "tmp_[pid]" w] puts $f $l close $f DecortiqueGenBankLuc gde gos goc gad $Ll puts "$gde" puts "$gos" puts "$goc" exit set Le [GenBankToEMBL "tmp_[pid]"] puts ">>$Le<<" DecortiqueLesLignesEMBL $Le id ac de gn os oc ox puts "$id" exit } proc turp {} { set L " Rcy_Ence.cuni Rmi_Homo.sapi Rar_Nano.equi Rcy_Caen.eleg Rcy_Dict.disc Rcy_Sacc.cere Rmi_Sacc.cere Rcy_Schi.pomb Rcy_Enta.hist Rcy_Stro.purp Rcy_Stro.purp2 Rcy_Cryp.neof Rmi_Cion.inte Rmi_Dros.mela Rmi_Gall.gall PDB_1f7u_A Rba_Rhiz.meli Rba_Agro.tume Rba_Bruc.abor Rba_Bart.quin Rba_Bruc.meli Rba_Bruc.suis Rba_Rhiz.loti Rba_Bart.hens Rba_Rhod.palu Rba_Gluc.oxyd Rba_Sili.pome Rba_Zymo.mobi Rba_Zymo.mobi2 Rba_Rick.cono Rba_Rick.feli Rba_Rick.prow Rba_Rick.typh Rba_Ehrl.rumi Rba_Ehrl.rumi2 Rba_Ehrl.cani Rba_Wolb.endo Rba_Wolb.sp Rba_Pela.ubiq Rar_Aero.pern Rar_Arch.fulg Rba_Dein.radi Rar_Meth.ther Rar_Meth.jann Rar_Meth.kand Rar_Meth.maze Rar_Pyro.aero Rar_Pyro.furi Rar_Ther.acid PDB_1iq0_A Rar_Sulf.solf Rcy_Arab.thal2 Rcy_Arab.thal3 Rcy_Arab.thal4 Rcy_Arab.thal5 Rcy_Oryz.sati Rcy_Oryz.sati2 Rcy_Plas.falc Rcy_Dani.reri Rcy_Dani.reri2 Rcy_Caen.eleg2 Rcy_Caen.eleg3 Rcy_Stro.purp3 Rcy_Stro.purp4 Rcy_Dros.mela Rcy_Gall.gall Rcy_Homo.sapi Rcy_Cion.inte Rcy_Tetr.ther Rcy_Tryp.cruz Rcy_Thei.parv2 Rcy_Leis.majo Rcy_Thal.pseu2 Rba_Bact.thet Rba_Borr.burg Rba_Stre.pneu Rba_Lact.john Rba_Baci.anth2 Rcy_Dict.disc2 Rcy_Thei.parv Rba_Caul.cres Rba_Rhod.balt Rba_Fuso.nucl Rba_Chla.muri Rba_Chla.pneu Rcy_Cyan.mero Rba_Syne.sp Rba_Anab.sp Rba_Anab.vari Rcy_Thal.pseu Rba_Prop.acne Rba_Neis.meni Rba_Vibr.para Rba_Esch.coli Rcy_Arab.thal Rba_Aqui.aeol Rba_Azoa.sp Rba_Baci.anth Rba_Bifi.long Rba_Camp.jeju Rba_Carb.hydr Rba_Deha.ethe Rba_Geob.sulf Rba_Lept.inte Rba_Stap.aure Rba_Ther.mari Rba_Trop.whip Rba_Leif.xyli Rba_Chlo.tepi Rba_Myco.pene " set Ls [split $L \n] set sq "Rcy_Stro.purp" puts [lsearch $Ls $sq] puts [lsearch $Ls "$sq"] exit } proc tutu {} { set Ll [LesLignesDuFichier /home/moumou/ordali/src/ordali_agents.tcl] foreach l $Ll { set l [string trim $l] if {[string range $l 0 5] eq "global"} { lappend Lg {*}[split [string range $l 6 end] " "] } } set Lg [lsort -unique $Lg] puts "[join $Lg \n]" exit } proc tuuu {} { package require sqlite3 set dir "/genomics/link/genomes/" sqlite3 g [file join $dir gold_genomes gold_genomes.sql] sqlite3 n [file join $dir ncbi_genomes ncbi_genomes.sql] sqlite3 u [file join $dir uniprot_genomes uniprot_genomes.sql] set Lg [g eval {select distinct(taxid) from genomes where ProjStatus like 'complete%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "proj comp [llength $Lg]" set Lg [g eval {select distinct(taxid) from genomes where SeqStatus like 'complete%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "seq comp [llength $Lg]" set Lg [g eval {select distinct(taxid) from genomes where ProjStatus like 'permanent draft%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "proj draft [llength $Lg]" set Lg [g eval {select distinct(taxid) from genomes where SeqStatus like 'draft%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "seq draft [llength $Lg]" set Lg [g eval {select count(distinct(taxid)) from genomes where ProjStatus like 'permanent draft%' and SeqStatus like 'complete%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "proj perm seq comp [join $Lg \n]" puts "" # ncbi set Ln [n eval {select taxid from genomes where Status like 'complete%'}] puts "ncbi : [llength $Ln]" # uniprot set Lu [u eval {select taxid from genomes}] puts "uniprot : [llength $Lu]" # gold set Lg [g eval {select distinct(taxid) from genomes where ProjStatus like 'complete%' and Domain in ('ARCHAEAL','BACTERIAL','EUKARYAL')}] puts "gold : [llength $Lg]" # overlap puts "uniprot - ncbi : [llength [land $Lu $Ln]]" puts "uniprot - gold : [llength [land $Lu $Lg]]" puts "ncbi - gold : [llength [land $Ln $Lg]]" exit } proc tvn {nb Lv} { #set nb 11 #set Lv {5 3 8 14} set Lr [RepartiValEntreN $nb $Lv] puts "" # %ages set tot [::tcl::mathop::+ {*}$Lv] set sv "" ; set sr "" ; set spt "" ; set spr "" foreach v $Lv r $Lr { set pt [expr {1.*$v/$tot*100}] set pb [expr {1.*$r/$nb*100}] append sv [format %6d $v] append spt [format %6.2f $pt] append sr [format %6d $r] append spb [format %6.2f $pb] } puts "$sv\n$spt\n$sr\n$spb" return exit } proc twild {} { # 1000 sequences en entree DecortiqueUnTFA wild.tfa Lseq Tseq set Ln [list] ; set Ls [list] # prend 1 sur 4. for {set i 0} {$i < [llength $Lseq]} {incr i 4} { set n [lindex $Lseq $i] lappend Ln $n lappend Ls [set Tseq($n)] } set Lu [IDMapping NF50 ACC $Ln] set Lnom [list] foreach u $Lu n $Ln s $Ls { if {$u eq ""} {set u $n} lappend Lnom $u } set f gnat_ali.tfa EcritLeTfa $f $Lnom $Ls catch {exec mafft --quiet $f > gnat_mafft.tfa} {Message} return } proc twin {} { package require Tk toplevel .t pack [button .t.l -text "slkdjf\n slkjdfklsdjf\nsdljsdkljf\n sdlfkjsdlkfjsd\nslkdfjls" -bg cyan -command { puts "Pressed !" puts "full [set full [wm attributes .t -fullscreen]]" puts "zoom [set zoom [wm attributes .t -zoomed]]" wm withdraw .t wm attributes .t -fullscreen [expr {! $full}] -zoomed [expr {! $zoom}] update idletasks wm deiconify .t } ] -expand 1 -fill both bind .t {logrr ResizeRequest %w %h} bind .t {logrr ConfRequest %w %h} bind .t {logrr Configure %w %h} puts "Start" puts "max [wm maxsize .t]" puts "scr [winfo screenwidth .t] [winfo screenheight .t]" puts "full [wm attributes .t -fullscreen]" puts "zoom [wm attributes .t -zoomed]" return } proc tws {} { set xml " 0 head org.pdb.query.simple.OrganismQuery Organism Search : Organism Name=Homo sapiens (human) Homo sapiens (human) 1 and head org.pdb.query.simple.EnzymeClassificationQuery Enzyme Classification Search : EC=6.1.1.* 6.1.1.* 2 and head org.pdb.query.simple.TreeEntityQuery CellComponentTree Search for mitochondrion (GO ID:5739) mitochondrion (GO ID:5739) " return $xml } proc tx {} { set organism_name "Homo sapiens" set xml1 " 0 head org.pdb.query.simple.EnzymeClassificationQuery Enzyme Classification Search : EC=6.1.1.* 6.1.1.* 1 and head org.pdb.query.simple.ExpTypeQuery Experimental Method is X-RAY X-RAY 2 and head org.pdb.query.simple.OrganismQuery Organism Search : Organism Name=$organism_name $organism_name " set Lpdb1 [SendPDBQuery $xml1] puts "xml1 [llength $Lpdb1]" set organism_name "Homo sapiens" set xml2 " 0 head org.pdb.query.simple.EnzymeClassificationQuery Enzyme Classification Search : EC=6.1.1.* 6.1.1.* 1 and head org.pdb.query.simple.ExpTypeQuery Experimental Method is X-RAY X-RAY 2 and head org.pdb.query.simple.OrganismQuery Organism Search : Organism Name=$organism_name $organism_name " set Lpdb2 [SendPDBQuery $xml2] puts "xml2 [llength $Lpdb2]" puts "[lor $Lpdb1 $Lpdb2]" #puts "$Lpdb2" set xml3 [MakePDBQuery -orga "Homo sapiens" -ec "6.1.1.*"] set Lpdb3 [SendPDBQuery $xml3] puts "$Lpdb3" exit } proc txtScroll {t first last} { global Vrp set ts $t.scroll # puts "\nin txtScroll from text $t" set beg [expr $first*$Vrp(Sz)] set end [expr $last*$Vrp(Sz)] set beg [expr int($beg+0.5)] set end [expr int($end+0.5)] if { $beg != $end } { incr beg incr end } $t.resbeg configure -text [format "%4d" $beg] $t.resend configure -text [format "%-4d" $end] $ts set $first $last return } proc typeProc {t} { switch $t { "a" { set body {global x set y [expr {$x * $v}] puts "x= $x v= $v y- $y" return $y } } "b" { set body {global x set y [expr {$x + $v}] puts "b: x= $x v= $v y- $y" return $y } } } proc ::ptest {v} "$body" return } proc tys {} { set que " 0 head org.pdb.query.simple.CifSingleFieldQuery CifSingleFieldQuery: entity_src_nat.pdbx_organism_scientific.comparator== entity_src_nat.pdbx_organism_scientific.value=Saccharomyces cerevisiae 5EC1A12B 432 2016-01-22T11:11:59Z 47 = Saccharomyces cerevisiae 1 and head org.pdb.query.simple.TreeQueryExpression 32B38AA0 2895 2016-01-22T11:14:27Z 58 1 +4932. " } proc ucscMySqlUpdater {{Database ucschuman_hg18} {Table refGene}} { set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ucscMySqlUpdater|$Database: Start" if {[file exists "/tmp/$Table.txt"]} { file delete "/tmp/$Table.txt" } set Genome [lindex [split $Database "_"] 1] exec wget -q -O "/tmp/$Table.txt.gz" "http://hgdownload.cse.ucsc.edu/goldenPath/$Genome/database/$Table.txt.gz" exec gunzip "/tmp/$Table.txt.gz" exec /usr/bin/mysqlimport --user='anno' --password=ceji387. --host=[LbgiHost] -L "$Database" "/tmp/$Table.txt" set timestamp [clock format [clock seconds] -format "%H:%M:%S"] Espionne "$timestamp|ucscMySqlUpdater|$Database: End" } proc ungapQualityValues {qual} { for {set i 0} {$i < [llength $qual]} {incr i} { if {[lindex $qual $i] ne "*"} { lappend uqual [lindex $qual $i] } } return $uqual } proc ungapSequence {seq} { for {set i 0} {$i < [string length $seq]} {incr i} { if {[string index $seq $i] ne "*"} { append useq [string index $seq $i] } } return $useq } proc update_pdb {} { global Tpdb LesDefauts Mode batch set db root sqlite3 $db [file join [MiSynPatDir] misynpat.sql] # existing pdb set Lold [$db eval {select id from structure}] set Lold [list] puts "Number old [llength $Lold]" # get actual list of pdb set Lnew [llower [SearchAllAARSPDB]] puts "Number new [llength $Lnew]" # is there new ones ? set Ladd [lsort -unique [lor $Lold $Lnew]] if {! [llength $Ladd]} { # nothing to do, see you soon ! puts "Nothing to do ... exiting" exit } #set Ladd [lrange $Ladd 0 100] #set Ladd [lrange $Ladd 0 10] puts " ==> Number of PDB to check : [llength $Ladd]" # check new pdb # - are they aaRS (by EC number # - are they human mito # - pcid against human mito seq foreach pdbid $Ladd { set id [string tolower [string range $pdbid 0 3]] puts "\n$id" # First, download the file set Lf [split [TextePDB $id All] \n] if {$Lf == {} } { set Lf [RecupereUnFichierSurWeb $id] } # is it an aaRS ? set sys [whichAARSSystem $Lf] if {$sys == 0} {set sys "unknown"} set Tpdb($id,aaRS) $sys if {$sys eq "unknown"} { # not an aaRS, continue puts "unknown system !" continue } lappend Tpdb(system,$sys) $id puts "system $sys" # keep lines set Tpdb($id,lignes) $Lf incr accpt [AddNewAARSPDB $id $Lf] } puts "\n accepted : $accpt" $db close set MiSynPatDir [MiSynPatDir] # treat each system # find closest PDB from human mito global LNOrdali LSOrdali TabSF ListeTypeDeFeatures Sequences ListePDB foreach key [lsort [array names Tpdb "system,*"]] { lassign [split $key ,] tmp sys puts "\nSYSTEM $sys" puts "--------" unset -nocomplain LNOrdali LSOrdali TabSF ListeTypesDeFeatures Sequences TDesAccess ListePDB Tacc TPCI set file [file join [MiSynPatDir] data alignments ${sys}_maj.xml] set file [file join $MiSynPatDir data alignments ${sys}_maj.xml] puts "file $file" if {! [file exists $file]} { foreach pdbid $Tpdb(system,$sys) { array unset Tpdb "$pdbid,*" } array unset Tpdb "system,$sys" update continue } set LcmdO [info commands] DecortiqueUnXml2 $file InitSequences InitInfoSeqs AssignSeqToGroup DonneTabFeature TabSF global {*}[info globals "TD*"] update set LcmdN [info commands] puts "Cmds [set Lco [lor $LcmdO $LcmdN]]" set Lseq [list] # cree tab acc -> sqn RetourneTableau TDesAccess Tacc set Tpdb(system,$sys) [lunique $Tpdb(system,$sys)] puts "PDBs : $Tpdb(system,$sys)" foreach pdbid $Tpdb(system,$sys) { # parse the pdb # it may be already created through the XML ... set Tpdb($pdbid,ok) 1 #puts "[expr {$pdbid in $ListePDB}] [expr {$pdbid in [info commands]}] >$pdbid< >$Lco<" set InAlgt [expr {$pdbid in [info commands]}] set Tpdb($pdbid,InAlgt) $InAlgt if {! $InAlgt} { Structure create $pdbid set cok [$pdbid new $Tpdb($pdbid,lignes) "" 0 0] set Tpdb($pdbid,ok) $cok if {$cok == 0} { puts "problem loading $id !" continue } } # matching pdb <-> access / seq-name set access "" set Tpdb($pdbid,dbacc) [list] set Tpdb($pdbid,dbbid) [list] foreach c [$pdbid _chains] { if {[$pdbid _chainIs $c] ne "Protein"} { continue } lassign [$pdbid dbref $c] acc bid lappend Tpdb($pdbid,dbacc) $acc lappend Tpdb($pdbid,dbbid) $bid if {[info exists Tacc($acc)]} { set access $acc } if {[info exists Tacc($bid)]} { set access $bid } } # There is an access (uniprot/ncbi ...) in one chain # of pdb that match with one sequence of alignment if {$access ne ""} { set sqn $Tacc($access) lappend Lseq $sqn set Tpdb($pdbid,acc) $access set Tpdb($pdbid,sqn) $sqn lappend Tseq($sqn) $pdbid } else { set Tpdb($pdbid,acc) "unknown" } set Tpdb($pdbid,pc) -1. } set Lseq [lsort -unique $Lseq] puts "Lseq $Lseq" # Delete structure objects foreach pdbid $Tpdb(system,$sys) { $pdbid destroy array unset Tpdb "$pdbid,lignes" } if {$Lseq == {} } { puts "no pdb matchng seq in alignemtn !" continue } # seq human mito set shm "${sys}mito_Homo.sapi" if {$shm ni $LNOrdali} { puts "\n===> PAS HUMAN MITO !!\n" continue } # compute PCI for seqs set Lns [list] foreach n $Lseq { set s [set Sequences($n)] lappend Lns $n $s } lappend Lns $shm [set Sequences($shm)] CalculeLesPCIGenerique $Lns TPCI puts "" puts "PDB with no alignment counterpart :" foreach pdbid $Tpdb(system,$sys) { set acc $Tpdb($pdbid,acc) if {$acc eq "unknown"} { puts "$pdbid | [join [lunique $Tpdb($pdbid,dbacc)]] | [join [lunique $Tpdb($pdbid,dbbid)]]" } } puts "" foreach pdbid $Tpdb(system,$sys) { set acc $Tpdb($pdbid,acc) if {$Tpdb($pdbid,InAlgt)} { set Etat "old" } else { set Etat "NEW" } if {$acc ne "unknown"} { set sqn $Tpdb($pdbid,sqn) set pc [lindex $TPCI($shm,$sqn) 0] set txt "$sqn [format %6.4f $pc] $acc" puts "$Etat $pdbid $txt" } } } # fill db ... StorePDBInDB puts "[DonneDateEtHeure]" exit } proc updatedb {} { # rajoute table structure a misynpat.sql set tbl " - structure { . pk_structure P . pk_synthetase I . id V4 . seqname V32 . pcid R identity percent with human mito } " set db "root" #$db eval {drop table if exists structure} set db [FabriqueDeTables $tbl "" misynpat.sql 1 1] $db close exit } proc use_light {} { # global pgl # return # glEnable GL_LIGHTING #glEnable GL_COLOR_MATERIAL # glLightfv GL_LIGHT0 GL_AMBIENT $pgl(light_ambient) glMaterialfv GL_FRONT_AND_BACK GL_AMBIENT_AND_DIFFUSE {0.2 0.2 0.2 1.0} glMaterialfv GL_FRONT_AND_BACK GL_SPECULAR {1.0 1.0 1.0 1.0} glMaterialf GL_FRONT_AND_BACK GL_SHININESS 80. return } proc uuuh {t} { global x typeProc $t set x 4 ptest 10 return } proc vadd {v1 v2} { foreach x $v1 y $v2 { lappend r [expr {$x + $y}] } return $r } proc van {} { global Sequences set seq "C..A.AFD..SD..FFF" set Sequences(toto) $seq puts "$seq" VanishIsolatedAgents toto puts "$Sequences(toto)" exit } proc vcross {v1 v2} { lassign $v1 a b c lassign $v2 d e f set x [expr {($b * $f) - ($c * $e)}] set y [expr {($c * $d) - ($a * $f)}] set z [expr {($a * $e) - ($b * $d)}] return [list $x $y $z] } proc vdot {v1 v2} { lassign $v1 a b c tmp lassign $v2 d e f tmp return [expr {$a*$d + $b*$e + $c*$f}] } proc verifNmDemrnaRefseq {} { set VNM [MrnaRefseqUcscMouse ListOf Nm] #Espionne $liste set liste [split $VNM " "] foreach x $liste { if {![regexp "^NM_" $x]} { Espionne "attention ca commence pas par NM" } } } proc verifblast {Rep} { set Liste "" foreach DD [ListeDesPABs] { set FichierBlast "[RepertoireDuGenome]/$Rep/$DD" if {![file exists $FichierBlast]} {lappend Liste $DD} } Espionne [llength $Liste] return $Liste } proc verifdoublons {FichierDesPABs} { set L [CreeListePourFichierAUneColonne $FichierDesPABs] Espionne "avant: [llength $L]" set Ltriee [lsort -unique $L] Espionne "apres: [llength $Ltriee]" } proc verifdoublonsid {Fichier Sortie} { set L [CreeListePourFichierAUneColonne $Fichier] Espionne [llength $L] #set Lt [lsort -unique $L] #SauveLesLignes $Lt dans $Sortie return [llength [lsort -unique $L]] } proc verifg {} { global SDG LitLeTFA Mito_uniprot.tfa tmp St foreach n $tmp { lappend Lt [string toupper $n] } puts "Lt [llength $Lt]" set G(Group1) [lrange $Lt 0 39] set G(Group2) [lrange $Lt 40 70] set G(Group3) [lrange $Lt 71 80] set G(Group4) [lrange $Lt 81 end] foreach g [array names G] { set GG [lsort $G($g)] set SG [lsort $SDG($g)] if {$GG != $SG} { puts "\nerror in group $g" puts "[join [lor $GG $SG] \n]" } } exit } proc veriflongueur {FichierAverifier} { set n 0 foreach Ligne [LesLignesDuFichier $FichierAverifier] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] foreach J $LesJumeaux { set FichierMRM "[RepertoireDuGenome]/nucmask/$J" set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM] #set L [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN set LSansN [string length $SeqMRMSansN] if {$LSansN<25} {incr n; Espionne $J} } } return $n } proc veriflongueurbornes {FichierAverifier} { set n 0 foreach Ligne [LesLignesDuFichier $FichierAverifier] { if {$Ligne==""} {continue} set LesJumeaux [split $Ligne " "] set J [lindex $LesJumeaux 0] set FichierMRM "[RepertoireDuGenome]/nucmask/$J" set SeqMRM [QueLaSequenceDuFichierTFA $FichierMRM] #set L [string length $SeqMRM] regsub -all -nocase "N" $SeqMRM "" SeqMRMSansN set LSansN [string length $SeqMRMSansN] if {$LSansN<25} {incr n; Espionne $J} } return $n } proc verifmrnaspourrelancer {FichierSortie} { #1217 pabs foreach Nom [ListeDesPABs] { set AccBestmRNAHuman [InterrogeBestProteinAndmRNAForeachOrga $Nom Organisme "Homo sapiens" mRNA Access] if {$AccBestmRNAHuman!=""} { set FichiermRNA "[RepertoireDuGenome]/mrnatfa_Homo_sapiens/$Nom" if {![file exists $FichiermRNA]} { lappend Liste $Nom } else { if {![regexp $AccBestmRNAHuman [EnteteDuFichierTFA $FichiermRNA]]} { lappend Liste $Nom } } } } Espionne [llength $Liste] SauveLesLignes $Liste dans $FichierSortie } proc verifredondcontrol {} { set LesPsLus {}; set I 0 set file "[GxData]/ToGx/ProbesetEtLnAtPs/InputPsControlAcRedond.txt" set LesLignes [lsort -unique [LesLignesDuFichier $file]] set PP "" set LP "" set AffP 1 foreach Ligne $LesLignes { scan $Ligne "%s" PS if {$PP != "" && $PP == $PS} { set LesMots [LesMotsDeLaLigne $LP] ScanLaListe $LesMots pP pG pE pA set pR [lrange $LesMots 4 end-1] set LesMots [LesMotsDeLaLigne $LP] ScanLaListe $LesMots aP aG aE aA set aR [lrange $LesMots 4 end-1] if {$pR!=$aR} { FaireLire $Ligne } if {$pG==$aG && $pE==$aE && $pA != $aA } { FaireLire $Ligne } if {$AffP} { lappend LesDoubles "" [BelleLigne $LP] } lappend LesDoubles [BelleLigne $Ligne] set AffP 0 } else { set AffP 1 } set PP $PS set LP $Ligne } AfficheVariable [join $LesDoubles "\n"] return foreach ligne [LesLignesDuFichier $file] { set elmtligne [split $ligne "\t"] set Ps [lindex $elmtligne 0] lappend DejaVu($Ps) $ligne } foreach Clef [array names DejaVu] { incr I; set J 0 Espionne "" Espionne "$Clef" foreach elmt $DejaVu($Clef) { incr J; set K 0 set Lessouselmt [split $elmt "\t"] foreach sselmt $Lessouselmt { incr K #if {$Dis1 != "" && $Dis2 != ""} { set ValueofCol "$Dis1/ $Dis2" } #Espionne "$J $K $sselmt" set Vu($J,$K) $sselmt } } if {$J==1} { Espionne "1 seule elmt" continue } for {set j 1} {$j<=$J} {incr j} { for {set k 1} {$k<=$K} {incr k} { Espionne "$j/$k" lappend result $j/$k } set result [ListeSansDoublon $result] set long [llength $result] if {$long==1} { Espionne "$k ok" } else { Espionne "$k nul" } } } Espionne "I $I" } proc veriftableln_arraytype_probeset {} { WithWebService "Gx" 0 set Sql "select pk_arraytype, pk_probeset from ln_arraytype_probeset order by pk_probeset,pk_arraytype;" set LesPkAPkP [GxDbSqlExec $Sql "GetList"] set premiere 1 foreach {PkA PkP} $LesPkAPkP { if {!$premiere && $PkPOld == $PkP} { if {$PkAOld == $PkA} {FaireLire "Ausecours $PkP $PkA"} } if {$premiere} { set premiere 0 set PkPOld $PkP set PkAOld $PkA } lappend LesCouples($PkP) $PkA if { ! [info exists DejaVu($PkP)]} { set DejaVu($PkP) 0 } incr DejaVu($PkP) set PkPOld $PkP set PkAOld $PkA } set LesCouplesFamilles {} foreach Clef [array names DejaVu] { if {[llength $LesCouples($Clef)]==1} {continue} #Espionne "$Clef $LesCouples($Clef)" lappend LesCouplesFamilles $LesCouples($Clef) } foreach Famille $LesCouplesFamilles { if { ! [info exists DejaVu2($Famille)]} { set DejaVu2($Famille) 0 } incr DejaVu2($Famille) } foreach Clef2 [array names DejaVu2] { Espionne "$Clef2 \t $DejaVu2($Clef2)" } } proc verifyBlast {{blastDirectory blastx}} { set dir "[RepertoireDuGenome]/$blastDirectory" if {![file isdirectory $dir]} { puts "$dir is not a directory" exit 1 } foreach file [glob "$dir/*"] { if {[file extension $file] ne ".encours"} { set queryLength 0 set haveHits 1 set haveDone 0 set haveMatrix 0 set fh [open $file r] while {![eof $fh]} { gets $fh line if {[regexp -nocase {([0-9]+)\s+letters} $line regMatch queryLength]} { } elseif {[regexp -nocase {no hits found} $line]} { set haveHits 0 } elseif {[regexp -nocase {^Searching\.*(done)?} $line regMatch done]} { if {$done eq "done"} { set haveDone 1 } } elseif {[regexp -nocase {^matrix:} $line regMatch]} { set haveMatrix 1 break } } close $fh if {$queryLength == 0 || !$haveHits || !$haveDone || !$haveMatrix} { if {$queryLength == 0} { puts "[file tail $file] have query length=0" } elseif {!$haveHits} { puts "[file tail $file] have no hits" } else { puts "[file tail $file] has been aborted" } } } } } proc vlength {v} { lassign $v x y z return [expr {sqrt($x*$x + $y*$y + $z*$z)}] } proc vnormal {v} { return [vscale $v [expr {1.0/[vlength $v]}]] } proc vscale {v div} { foreach x $v { lappend r [expr {$x*$div}] } return $r } proc vset {x y z} { return [list $x $y $z] } proc vsub {v1 v2} { foreach a $v1 b $v2 { lappend r [expr {$a-$b}] } return $r } proc vtax {} { package require sqlite3 set db root sqlite3 $db taxo.sql $db eval {begin transaction} set Lg [$db eval {select taxid,Espece from gold where (Status like 'complete%' or Status like 'permanent%') and (not Name like '%metagenomi%') and (Domaine != 'VIRUS' and Domaine != 'PLASMID')}] set nerr 0 set NoNCBI [list] foreach {tg eg} $Lg { set name "[string tolower [lindex [$db eval {select Name from taxonomy where taxid=$tg}] 0]]" regsub -all { +} [string trim [string tolower $eg]] " " eg regsub -all { +} [string trim [string tolower $name]] " " name set Leg [split $eg " "] set Lname [split $name " "] if {[llength [land $Leg $Lname]] == 0} { puts "" if {$name eq ""} { lappend NoNCBI $tg puts [$db eval {select * from gold where taxid=$tg}] set aT [eFetchREST taxonomy $tg] if {$aT != {} } { array set T $aT set newid [lindex [split [lindex $aT 0] ,] 0] if {$newid != $tg} {} parray T unset -nocomplain T } } else { puts "$tg $eg | $name" } incr nerr } } $db eval {commit} puts "\nerr $nerr from [expr {[llength $Lg]/2}]\n" exit } proc vvide {} { InitChemicals foreach e [array names ::Chm *,na] { lappend Lno [set ::Chm($e)] } set Lno [lsort -integer -decreasing $Lno] puts "[llength $Lno]" puts "[lindex $Lno 0]" set k 0 set S "" foreach na $Lno { if {[info exists ::Chm(${na},vdw)]} { append S "vdw\[$na\]=[set ::Chm(${na},vdw)]; " if {! ($k%3 )} { puts $S set S "" } incr k } } exit } proc vzero {} { return [list 0.0 0.0 0.0] } proc whichAARSSystem {Lignes} { # search its EC Number set i [lsearch -regexp $Lignes {^COMPND.*EC\:}] if {$i == {} } { puts "Pb ... pas de EC" return 0 } set l [string trim [lindex $Lignes $i]] set dEC [string first "6." $l] set fEC [string first ";" $l] set EC [string range $l $dEC $fEC-1] # define which system ... # taken from http://enzyme.expasy.org/EC/6.1.1.- set sys "unknown" switch $EC { "6.1.1.1" { # Tyrosine--tRNA ligase set sys Y } "6.1.1.2" { # Tryptophan--tRNA ligase set sys W } "6.1.1.3" { # Threonine--tRNA ligase set sys T } "6.1.1.4" { # Leucine--tRNA ligase set sys L } "6.1.1.5" { # Isoleucine--tRNA ligase set sys I } "6.1.1.6" { # Lysine--tRNA ligase set sys K } "6.1.1.7" { # Alanine--tRNA ligase set sys A } "6.1.1.9" { # Valine--tRNA ligase set sys V } "6.1.1.10" { # Methionine--tRNA ligase set sys M } "6.1.1.11" { # Serine--tRNA ligase set sys S } "6.1.1.12" { # Aspartate--tRNA ligase set sys D } "6.1.1.13" { # D-alanine--poly(phosphoribitol) ligase } "6.1.1.14" { # Glycine--tRNA ligase set sys G } "6.1.1.15" { # Proline--tRNA ligase set sys P } "6.1.1.16" { # Cysteine--tRNA ligase set sys C } "6.1.1.17" { # Glutamate--tRNA ligase set sys E } "6.1.1.18" { # Glutamine--tRNA ligase set sys Q } "6.1.1.19" { # Arginine--tRNA ligase set sys R } "6.1.1.20" { # Phenylalanine--tRNA ligase set sys F } "6.1.1.21" { # Histidine--tRNA ligase set sys H } "6.1.1.22" { # Asparagine--tRNA ligase set sys N } "6.1.1.23" { # Aspartate--tRNA(Asn) ligase } "6.1.1.24" { # Glutamate--tRNA(Gln) ligase } "6.1.1.26" { # Pyrrolysine--tRNA(Pyl) ligase } "6.1.1.27" { # O-phosphoserine--tRNA ligase } } return $sys } proc writePhd {arrayGetPhd filename} { array set phd $arrayGetPhd set fh [open $filename "w"] puts $fh "BEGIN_SEQUENCE $phd(sequence)" puts $fh {} puts $fh BEGIN_COMMENT puts $fh {} foreach comment $phd(comment) { puts $fh $comment } puts $fh {} puts $fh END_COMMENT puts $fh {} puts $fh BEGIN_DNA foreach dna $phd(dna) { puts $fh $dna } puts $fh END_DNA puts $fh {} puts $fh END_SEQUENCE close $fh } proc writeScf {arrayGetScf filename} { array set scf $arrayGetScf set fh [open $filename "w"] fconfigure $fh -translation binary # ecriture nouvelle en tete puts -nonewline $fh $scf(magic) puts -nonewline $fh [binary format I $scf(samples)] puts -nonewline $fh [binary format I $scf(samplesOffset)] puts -nonewline $fh [binary format I $scf(bases)] puts -nonewline $fh [binary format I $scf(basesLeftClip)] puts -nonewline $fh [binary format I $scf(basesRightClip)] puts -nonewline $fh [binary format I $scf(basesOffset)] puts -nonewline $fh [binary format I $scf(commentsSize)] puts -nonewline $fh [binary format I $scf(commentsOffset)] puts -nonewline $fh $scf(version) puts -nonewline $fh [binary format I $scf(sampleSize)] puts -nonewline $fh [binary format I $scf(codeSet)] puts -nonewline $fh [binary format I $scf(privateSize)] puts -nonewline $fh [binary format I $scf(privateOffset)] puts -nonewline $fh [binary format I* $scf(headerSpare)] # ecriture des donnees if {$scf(version) >= "3.00" && $scf(sampleSize) == 2} { puts -nonewline $fh [binary format S* $scf(samplesA)] puts -nonewline $fh [binary format S* $scf(samplesC)] puts -nonewline $fh [binary format S* $scf(samplesG)] puts -nonewline $fh [binary format S* $scf(samplesT)] } elseif {$scf(version) >= "3.00"} { puts -nonewline $fh [binary format c* $scf(samplesA)] puts -nonewline $fh [binary format c* $scf(samplesC)] puts -nonewline $fh [binary format c* $scf(samplesG)] puts -nonewline $fh [binary format c* $scf(samplesT)] } elseif {$scf(sampleSize) == 2} { for {set i 0} {$i < $scf(samples)} {incr i} { puts -nonewline $fh [binary format S* [lindex $scf(samplesA) $i]] puts -nonewline $fh [binary format S* [lindex $scf(samplesC) $i]] puts -nonewline $fh [binary format S* [lindex $scf(samplesG) $i]] puts -nonewline $fh [binary format S* [lindex $scf(samplesT) $i]] } } else { for {set i 0} {$i < $scf(samples)} {incr i} { puts -nonewline $fh [binary format c* [lindex $scf(samplesA) $i]] puts -nonewline $fh [binary format c* [lindex $scf(samplesC) $i]] puts -nonewline $fh [binary format c* [lindex $scf(samplesG) $i]] puts -nonewline $fh [binary format c* [lindex $scf(samplesT) $i]] } } # ecriture des bases if {$scf(version) >= "3.00"} { puts -nonewline $fh [binary format I* $scf(peakIdx)] puts -nonewline $fh [binary format c* $scf(probA)] puts -nonewline $fh [binary format c* $scf(probC)] puts -nonewline $fh [binary format c* $scf(probG)] puts -nonewline $fh [binary format c* $scf(probT)] puts -nonewline $fh [join $scf(calledBases) {}] puts -nonewline $fh [binary format c* $scf(probSub)] puts -nonewline $fh [binary format c* $scf(probIns)] puts -nonewline $fh [binary format c* $scf(probDel)] } else { #pour version <= 2 for {set i 0} {$i < $scf(bases)} {incr i} { puts -nonewline $fh [binary format I [lindex $scf(peakIdx) $i]] puts -nonewline $fh [binary format c [lindex $scf(probA) $i]] puts -nonewline $fh [binary format c [lindex $scf(probC) $i]] puts -nonewline $fh [binary format c [lindex $scf(probG) $i]] puts -nonewline $fh [binary format c [lindex $scf(probT) $i]] puts -nonewline $fh [lindex $scf(calledBases) $i] puts -nonewline $fh [binary format c3 {0 0 0}] } } # ecriture des commentaires puts -nonewline $fh $scf(comments) # ecriture des donnees privees puts -nonewline $fh $scf(private) close $fh } proc wtest {} { package require WS::Client set ret [::WS::Client::GetAndParseWsdl "http://www.ncbi.nlm.nih.gov/entrez/eutils/soap/v2.0/efetch_seq.wsdl"] ::WS::Client::CreateStubs eFetchSequenceService set Ln [list XP_002377002] set rep [::eFetchSequenceService::run_eFetch "" protein "" [join $Ln ,] "" "" "" "" "" "" "" "" "" ""] set ret [::WS::Client::GetAndParseWsdl "http://www.ncbi.nlm.nih.gov/entrez/eutils/soap/v2.0/efetch_seq.wsdl"] return $rep } proc xDoublet {t} { return [lindex $t 0] } proc xTriplet {t} { return [lindex $t 0] } proc yDoublet {t} { return [lindex $t 1] } proc yTriplet {t} { return [lindex $t 1] } proc ylt {} { package require sqlite3 set db rrot sqlite3 $db rrps.sql set Lacc [$db eval {select accession from items where taxid=4932}] set o [open all.acc w] puts $o [join $Lacc \n] close $o $db close exit } proc zTriplet {t} { return [lindex $t 2] } proc zoom {canvas factorx factory {xcenter ""} {ycenter ""} {winxlength ""} {winylength ""}} { ######################################################### # If (xcenter,ycenter) were not supplied, # # get the canvas coordinates of the center # # of the current view. Note that canvas # # size may have changed, so ask the window # # manager for its size # ######################################################### if { [string equal $xcenter ""] } { set winxlength [winfo width $canvas] set winylength [winfo height $canvas] set xcenter [$canvas canvasx [expr {$winxlength/2.0}]] set ycenter [$canvas canvasy [expr {$winylength/2.0}]] } ######################################################### # Scale all objects in the canvas # # Adjust our viewport center point # ######################################################### $canvas scale all 0 0 $factorx $factory set xcenter [expr {$xcenter * $factorx}] set ycenter [expr {$ycenter * $factory}] ZoomFacteur $canvas X $factorx ZoomFacteur $canvas Y $factory ######################################################### # Get the size of all the items on the canvas. # # # # This is *really easy* using # # $canvas bbox all # # but it is also wrong. Non-scalable canvas # # items like text and windows now have a different # # relative size when compared to all the lines and # # rectangles that were uniformly scaled with the # # [$canvas scale] command. # # # # It would be better to tag all scalable items, # # and make a single call to [bbox]. # # Instead, we iterate through all canvas items and # # their coordinates to compute our own bbox. # ######################################################### set x0 1.0e30; set x1 -1.0e30 ; set y0 1.0e30; set y1 -1.0e30 ; foreach item [$canvas find all] { switch -exact [$canvas type $item] { "arc" - "line" - "oval" - "polygon" - "rectangle" { set coords [$canvas coords $item] foreach {x y} $coords { if { $x < $x0 } {set x0 $x} if { $x > $x1 } {set x1 $x} if { $y < $y0 } {set y0 $y} if { $y > $y0 } {set y1 $y} } } } } ######################################################### # Now figure the size of the bounding box # ######################################################### set xlength [expr {$x1-$x0}] set ylength [expr {$y1-$y0}] ######################################################### # But ... if we set the scrollregion and xview/yview # # based on only the scalable items, then it is not # # possible to zoom in on one of the non-scalable items # # that is outside of the boundary of the scalable items# # # # So expand the [bbox] of scaled items until it is # # larger than [bbox all], but do so uniformly. # ######################################################### foreach {ax0 ay0 ax1 ay1} [$canvas bbox all] {break} while { ($ax0<$x0) || ($ay0<$y0) || ($ax1>$x1) || ($ay1>$y1) } { # triple the scalable area size set x0 [expr {$x0-$xlength}] set x1 [expr {$x1+$xlength}] set y0 [expr {$y0-$ylength}] set y1 [expr {$y1+$ylength}] set xlength [expr {$xlength*3.0}] set ylength [expr {$ylength*3.0}] } ######################################################### # Now that we ve finally got a region defined with # # the proper aspect ratio (of only the scalable items) # # but large enough to include all items, we can compute# # the xview/yview fractions and set our new viewport # # correctly. # ######################################################### set newxleft [expr {($xcenter-$x0-($winxlength/2.0))/$xlength}] set newytop [expr {($ycenter-$y0-($winylength/2.0))/$ylength}] $canvas configure -scrollregion [list $x0 $y0 $x1 $y1] $canvas xview moveto $newxleft $canvas yview moveto $newytop ######################################################### # Change the scroll region one last time, to fit the # # items on the canvas. # ######################################################### $canvas configure -scrollregion [$canvas bbox all] } proc zoomArea {c x y} { global zoomArea ######################################################### # Get the final coordinates. # # Remove area selection rectangle # ######################################################### set zoomArea(x1) [$c canvasx $x] set zoomArea(y1) [$c canvasy $y] $c delete zoomArea ######################################################### # Check for zero-size area # ######################################################### if {($zoomArea(x0)==$zoomArea(x1)) || ($zoomArea(y0)==$zoomArea(y1))} { return } ######################################################### # Determine size and center of selected area # ######################################################### set areaxlength [expr {abs($zoomArea(x1)-$zoomArea(x0))}] set areaylength [expr {abs($zoomArea(y1)-$zoomArea(y0))}] set xcenter [expr {($zoomArea(x0)+$zoomArea(x1))/2.0}] set ycenter [expr {($zoomArea(y0)+$zoomArea(y1))/2.0}] ######################################################### # Determine size of current window view # # Rq that canvas scaling always changes the coordinates# # into pixel coordinates, so the size of the current # # viewport is always the canvas size in pixels. # # Since the canvas may have been resized, ask the # # window manager for the canvas dimensions. # ######################################################### set winxlength [winfo width $c] set winylength [winfo height $c] ######################################################### # Calculate scale factors, and choose smaller # ######################################################### set xscale [expr {$winxlength/$areaxlength}] set yscale [expr {$winylength/$areaylength}] if { $xscale > $yscale } { set factor $yscale } else { set factor $xscale } ######################################################### # Perform zoom operation # ######################################################### zoom $c $factor $factor $xcenter $ycenter $winxlength $winylength } proc zoomMark {c x y} { global zoomArea set zoomArea(x0) [$c canvasx $x] set zoomArea(y0) [$c canvasy $y] $c create rectangle $x $y $x $y -outline black -tag zoomArea } proc zoomStroke {c x y} { global zoomArea set zoomArea(x1) [$c canvasx $x] set zoomArea(y1) [$c canvasy $y] $c coords zoomArea $zoomArea(x0) $zoomArea(y0) $zoomArea(x1) $zoomArea(y1) } # Test si on est dans un starpack ou pas set InStarPack [regexp {app-ordalie} [info script]] if {! $InStarPack} { if {$tcl_platform(platform) eq "windows"} { set OrdaliDir [file join o:/ ordali] set GscopeDir [file join k:/ gscope] set OrdLibDir [file join C:/ Tcl lib] set RepertoireDuGenome [pwd] } else { if {! [info exists OrdaliDir]} { if {[info exists env(ORDALIDIR)]} { set OrdaliDir $env(ORDALIDIR) } else { set OrdaliDir [file join [pwd] ..] } } set OrdLibDir [file join $OrdaliDir lib] if {[info exists env(GSCOPEDIR)]} { set GscopeDir $env(GSCOPEDIR) } elseif {! [info exists GscopeDir]} { set GscopeDir [file join /home ripp gscope] } if {[info exists env(REPERTOIREDUGENOME)]} { set RepertoireDuGenome $env(REPERTOIREDUGENOME) } else { set RepertoireDuGenome [file join g: genomics Pabyssi] } } } else { # in starpack #puts "\n Running Ordalie as a starpack\n" set OrdaliDir [file normalize [file join [file dirname [info script]] .. .. ..]] #puts "OrdaliDir $OrdaliDir" set OrdLibDir [file join $OrdaliDir lib] #puts "OrdLibDir $OrdLibDir" set OrdEtcDir [file join $OrdaliDir etc] set RepertoireDuGenome "" set auto_path [linsert $auto_path 0 $OrdLibDir] } package require platform # triche, pour developpement sous mac ... if {[::platform::generic] eq "macosx-ix86"} { set auto_path [linsert $auto_path 0 [file join $OrdaliDir Build ToPack lib]] } set auto_path [linsert $auto_path 0 /home/moumou/tmp/tcl8.6.0/install/lib] set auto_path [linsert $auto_path 0 $OrdLibDir] if {$tcl_version <= 8.5} { package require TclOO } ################ # arguments # if {[lindex $argv 0] eq "-OProfiling"} { package require profiler ::profiler::init set argv [lreplace $argv 0 0] } ############################## # Initialisation variables # set GlobalsAuDepart [info globals] set ProcsAuDepart [info procs] if {! $InStarPack} { if {! [file exists [file join $GscopeDir gscope_source.tcl]]} { source [file join $OrdaliDir src LesProcsDeGscope.tcl] } else { set OrdaliDejaSource 1 source [file join $GscopeDir gscope_source.tcl] } set OrdaliDejaSource 0 source [file join $OrdaliDir src ordali_source.tcl] } ####################### # procs utilitaires # set VariablesAuDepart [info globals] if {[lindex $argv 0] == "ToutesLesProcs"} { EtVoilaToutesLesProcs exit } ### Launch ORDALIE ###### # Programme principal InitLesDefauts set retour [InterpreteLaLigneDeCommande $argv] if {[ModeI]} { LoadTkAndPackages } if {$retour eq ""} { LanceOrdali master } if {"-recall" in $argv} { set i [lsearch $argv "-recall"] set fic [lindex $argv [incr i]] Recall $fic } ######## Ca finit ici #####################